1 /* 2 * L2TP netlink layer, for management 3 * 4 * Copyright (c) 2008,2009,2010 Katalix Systems Ltd 5 * 6 * Partly based on the IrDA nelink implementation 7 * (see net/irda/irnetlink.c) which is: 8 * Copyright (c) 2007 Samuel Ortiz <samuel@sortiz.org> 9 * which is in turn partly based on the wireless netlink code: 10 * Copyright 2006 Johannes Berg <johannes@sipsolutions.net> 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License version 2 as 14 * published by the Free Software Foundation. 15 */ 16 17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 18 19 #include <net/sock.h> 20 #include <net/genetlink.h> 21 #include <net/udp.h> 22 #include <linux/in.h> 23 #include <linux/udp.h> 24 #include <linux/socket.h> 25 #include <linux/module.h> 26 #include <linux/list.h> 27 #include <net/net_namespace.h> 28 29 #include <linux/l2tp.h> 30 31 #include "l2tp_core.h" 32 33 34 static struct genl_family l2tp_nl_family; 35 36 static const struct genl_multicast_group l2tp_multicast_group[] = { 37 { 38 .name = L2TP_GENL_MCGROUP, 39 }, 40 }; 41 42 static int l2tp_nl_tunnel_send(struct sk_buff *skb, u32 portid, u32 seq, 43 int flags, struct l2tp_tunnel *tunnel, u8 cmd); 44 static int l2tp_nl_session_send(struct sk_buff *skb, u32 portid, u32 seq, 45 int flags, struct l2tp_session *session, 46 u8 cmd); 47 48 /* Accessed under genl lock */ 49 static const struct l2tp_nl_cmd_ops *l2tp_nl_cmd_ops[__L2TP_PWTYPE_MAX]; 50 51 static struct l2tp_session *l2tp_nl_session_get(struct genl_info *info) 52 { 53 u32 tunnel_id; 54 u32 session_id; 55 char *ifname; 56 struct l2tp_tunnel *tunnel; 57 struct l2tp_session *session = NULL; 58 struct net *net = genl_info_net(info); 59 60 if (info->attrs[L2TP_ATTR_IFNAME]) { 61 ifname = nla_data(info->attrs[L2TP_ATTR_IFNAME]); 62 session = l2tp_session_get_by_ifname(net, ifname); 63 } else if ((info->attrs[L2TP_ATTR_SESSION_ID]) && 64 (info->attrs[L2TP_ATTR_CONN_ID])) { 65 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 66 session_id = nla_get_u32(info->attrs[L2TP_ATTR_SESSION_ID]); 67 tunnel = l2tp_tunnel_get(net, tunnel_id); 68 if (tunnel) { 69 session = l2tp_session_get(net, tunnel, session_id); 70 l2tp_tunnel_dec_refcount(tunnel); 71 } 72 } 73 74 return session; 75 } 76 77 static int l2tp_nl_cmd_noop(struct sk_buff *skb, struct genl_info *info) 78 { 79 struct sk_buff *msg; 80 void *hdr; 81 int ret = -ENOBUFS; 82 83 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 84 if (!msg) { 85 ret = -ENOMEM; 86 goto out; 87 } 88 89 hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq, 90 &l2tp_nl_family, 0, L2TP_CMD_NOOP); 91 if (!hdr) { 92 ret = -EMSGSIZE; 93 goto err_out; 94 } 95 96 genlmsg_end(msg, hdr); 97 98 return genlmsg_unicast(genl_info_net(info), msg, info->snd_portid); 99 100 err_out: 101 nlmsg_free(msg); 102 103 out: 104 return ret; 105 } 106 107 static int l2tp_tunnel_notify(struct genl_family *family, 108 struct genl_info *info, 109 struct l2tp_tunnel *tunnel, 110 u8 cmd) 111 { 112 struct sk_buff *msg; 113 int ret; 114 115 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 116 if (!msg) 117 return -ENOMEM; 118 119 ret = l2tp_nl_tunnel_send(msg, info->snd_portid, info->snd_seq, 120 NLM_F_ACK, tunnel, cmd); 121 122 if (ret >= 0) { 123 ret = genlmsg_multicast_allns(family, msg, 0, 0, GFP_ATOMIC); 124 /* We don't care if no one is listening */ 125 if (ret == -ESRCH) 126 ret = 0; 127 return ret; 128 } 129 130 nlmsg_free(msg); 131 132 return ret; 133 } 134 135 static int l2tp_session_notify(struct genl_family *family, 136 struct genl_info *info, 137 struct l2tp_session *session, 138 u8 cmd) 139 { 140 struct sk_buff *msg; 141 int ret; 142 143 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 144 if (!msg) 145 return -ENOMEM; 146 147 ret = l2tp_nl_session_send(msg, info->snd_portid, info->snd_seq, 148 NLM_F_ACK, session, cmd); 149 150 if (ret >= 0) { 151 ret = genlmsg_multicast_allns(family, msg, 0, 0, GFP_ATOMIC); 152 /* We don't care if no one is listening */ 153 if (ret == -ESRCH) 154 ret = 0; 155 return ret; 156 } 157 158 nlmsg_free(msg); 159 160 return ret; 161 } 162 163 static int l2tp_nl_cmd_tunnel_create(struct sk_buff *skb, struct genl_info *info) 164 { 165 u32 tunnel_id; 166 u32 peer_tunnel_id; 167 int proto_version; 168 int fd; 169 int ret = 0; 170 struct l2tp_tunnel_cfg cfg = { 0, }; 171 struct l2tp_tunnel *tunnel; 172 struct net *net = genl_info_net(info); 173 174 if (!info->attrs[L2TP_ATTR_CONN_ID]) { 175 ret = -EINVAL; 176 goto out; 177 } 178 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 179 180 if (!info->attrs[L2TP_ATTR_PEER_CONN_ID]) { 181 ret = -EINVAL; 182 goto out; 183 } 184 peer_tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_PEER_CONN_ID]); 185 186 if (!info->attrs[L2TP_ATTR_PROTO_VERSION]) { 187 ret = -EINVAL; 188 goto out; 189 } 190 proto_version = nla_get_u8(info->attrs[L2TP_ATTR_PROTO_VERSION]); 191 192 if (!info->attrs[L2TP_ATTR_ENCAP_TYPE]) { 193 ret = -EINVAL; 194 goto out; 195 } 196 cfg.encap = nla_get_u16(info->attrs[L2TP_ATTR_ENCAP_TYPE]); 197 198 fd = -1; 199 if (info->attrs[L2TP_ATTR_FD]) { 200 fd = nla_get_u32(info->attrs[L2TP_ATTR_FD]); 201 } else { 202 #if IS_ENABLED(CONFIG_IPV6) 203 if (info->attrs[L2TP_ATTR_IP6_SADDR] && 204 info->attrs[L2TP_ATTR_IP6_DADDR]) { 205 cfg.local_ip6 = nla_data( 206 info->attrs[L2TP_ATTR_IP6_SADDR]); 207 cfg.peer_ip6 = nla_data( 208 info->attrs[L2TP_ATTR_IP6_DADDR]); 209 } else 210 #endif 211 if (info->attrs[L2TP_ATTR_IP_SADDR] && 212 info->attrs[L2TP_ATTR_IP_DADDR]) { 213 cfg.local_ip.s_addr = nla_get_in_addr( 214 info->attrs[L2TP_ATTR_IP_SADDR]); 215 cfg.peer_ip.s_addr = nla_get_in_addr( 216 info->attrs[L2TP_ATTR_IP_DADDR]); 217 } else { 218 ret = -EINVAL; 219 goto out; 220 } 221 if (info->attrs[L2TP_ATTR_UDP_SPORT]) 222 cfg.local_udp_port = nla_get_u16(info->attrs[L2TP_ATTR_UDP_SPORT]); 223 if (info->attrs[L2TP_ATTR_UDP_DPORT]) 224 cfg.peer_udp_port = nla_get_u16(info->attrs[L2TP_ATTR_UDP_DPORT]); 225 cfg.use_udp_checksums = nla_get_flag( 226 info->attrs[L2TP_ATTR_UDP_CSUM]); 227 228 #if IS_ENABLED(CONFIG_IPV6) 229 cfg.udp6_zero_tx_checksums = nla_get_flag( 230 info->attrs[L2TP_ATTR_UDP_ZERO_CSUM6_TX]); 231 cfg.udp6_zero_rx_checksums = nla_get_flag( 232 info->attrs[L2TP_ATTR_UDP_ZERO_CSUM6_RX]); 233 #endif 234 } 235 236 if (info->attrs[L2TP_ATTR_DEBUG]) 237 cfg.debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]); 238 239 tunnel = l2tp_tunnel_find(net, tunnel_id); 240 if (tunnel != NULL) { 241 ret = -EEXIST; 242 goto out; 243 } 244 245 ret = -EINVAL; 246 switch (cfg.encap) { 247 case L2TP_ENCAPTYPE_UDP: 248 case L2TP_ENCAPTYPE_IP: 249 ret = l2tp_tunnel_create(net, fd, proto_version, tunnel_id, 250 peer_tunnel_id, &cfg, &tunnel); 251 break; 252 } 253 254 if (ret >= 0) 255 ret = l2tp_tunnel_notify(&l2tp_nl_family, info, 256 tunnel, L2TP_CMD_TUNNEL_CREATE); 257 out: 258 return ret; 259 } 260 261 static int l2tp_nl_cmd_tunnel_delete(struct sk_buff *skb, struct genl_info *info) 262 { 263 struct l2tp_tunnel *tunnel; 264 u32 tunnel_id; 265 int ret = 0; 266 struct net *net = genl_info_net(info); 267 268 if (!info->attrs[L2TP_ATTR_CONN_ID]) { 269 ret = -EINVAL; 270 goto out; 271 } 272 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 273 274 tunnel = l2tp_tunnel_get(net, tunnel_id); 275 if (!tunnel) { 276 ret = -ENODEV; 277 goto out; 278 } 279 280 l2tp_tunnel_notify(&l2tp_nl_family, info, 281 tunnel, L2TP_CMD_TUNNEL_DELETE); 282 283 l2tp_tunnel_delete(tunnel); 284 285 l2tp_tunnel_dec_refcount(tunnel); 286 287 out: 288 return ret; 289 } 290 291 static int l2tp_nl_cmd_tunnel_modify(struct sk_buff *skb, struct genl_info *info) 292 { 293 struct l2tp_tunnel *tunnel; 294 u32 tunnel_id; 295 int ret = 0; 296 struct net *net = genl_info_net(info); 297 298 if (!info->attrs[L2TP_ATTR_CONN_ID]) { 299 ret = -EINVAL; 300 goto out; 301 } 302 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 303 304 tunnel = l2tp_tunnel_get(net, tunnel_id); 305 if (!tunnel) { 306 ret = -ENODEV; 307 goto out; 308 } 309 310 if (info->attrs[L2TP_ATTR_DEBUG]) 311 tunnel->debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]); 312 313 ret = l2tp_tunnel_notify(&l2tp_nl_family, info, 314 tunnel, L2TP_CMD_TUNNEL_MODIFY); 315 316 l2tp_tunnel_dec_refcount(tunnel); 317 318 out: 319 return ret; 320 } 321 322 static int l2tp_nl_tunnel_send(struct sk_buff *skb, u32 portid, u32 seq, int flags, 323 struct l2tp_tunnel *tunnel, u8 cmd) 324 { 325 void *hdr; 326 struct nlattr *nest; 327 struct sock *sk = NULL; 328 struct inet_sock *inet; 329 #if IS_ENABLED(CONFIG_IPV6) 330 struct ipv6_pinfo *np = NULL; 331 #endif 332 333 hdr = genlmsg_put(skb, portid, seq, &l2tp_nl_family, flags, cmd); 334 if (!hdr) 335 return -EMSGSIZE; 336 337 if (nla_put_u8(skb, L2TP_ATTR_PROTO_VERSION, tunnel->version) || 338 nla_put_u32(skb, L2TP_ATTR_CONN_ID, tunnel->tunnel_id) || 339 nla_put_u32(skb, L2TP_ATTR_PEER_CONN_ID, tunnel->peer_tunnel_id) || 340 nla_put_u32(skb, L2TP_ATTR_DEBUG, tunnel->debug) || 341 nla_put_u16(skb, L2TP_ATTR_ENCAP_TYPE, tunnel->encap)) 342 goto nla_put_failure; 343 344 nest = nla_nest_start(skb, L2TP_ATTR_STATS); 345 if (nest == NULL) 346 goto nla_put_failure; 347 348 if (nla_put_u64_64bit(skb, L2TP_ATTR_TX_PACKETS, 349 atomic_long_read(&tunnel->stats.tx_packets), 350 L2TP_ATTR_STATS_PAD) || 351 nla_put_u64_64bit(skb, L2TP_ATTR_TX_BYTES, 352 atomic_long_read(&tunnel->stats.tx_bytes), 353 L2TP_ATTR_STATS_PAD) || 354 nla_put_u64_64bit(skb, L2TP_ATTR_TX_ERRORS, 355 atomic_long_read(&tunnel->stats.tx_errors), 356 L2TP_ATTR_STATS_PAD) || 357 nla_put_u64_64bit(skb, L2TP_ATTR_RX_PACKETS, 358 atomic_long_read(&tunnel->stats.rx_packets), 359 L2TP_ATTR_STATS_PAD) || 360 nla_put_u64_64bit(skb, L2TP_ATTR_RX_BYTES, 361 atomic_long_read(&tunnel->stats.rx_bytes), 362 L2TP_ATTR_STATS_PAD) || 363 nla_put_u64_64bit(skb, L2TP_ATTR_RX_SEQ_DISCARDS, 364 atomic_long_read(&tunnel->stats.rx_seq_discards), 365 L2TP_ATTR_STATS_PAD) || 366 nla_put_u64_64bit(skb, L2TP_ATTR_RX_OOS_PACKETS, 367 atomic_long_read(&tunnel->stats.rx_oos_packets), 368 L2TP_ATTR_STATS_PAD) || 369 nla_put_u64_64bit(skb, L2TP_ATTR_RX_ERRORS, 370 atomic_long_read(&tunnel->stats.rx_errors), 371 L2TP_ATTR_STATS_PAD)) 372 goto nla_put_failure; 373 nla_nest_end(skb, nest); 374 375 sk = tunnel->sock; 376 if (!sk) 377 goto out; 378 379 #if IS_ENABLED(CONFIG_IPV6) 380 if (sk->sk_family == AF_INET6) 381 np = inet6_sk(sk); 382 #endif 383 384 inet = inet_sk(sk); 385 386 switch (tunnel->encap) { 387 case L2TP_ENCAPTYPE_UDP: 388 switch (sk->sk_family) { 389 case AF_INET: 390 if (nla_put_u8(skb, L2TP_ATTR_UDP_CSUM, !sk->sk_no_check_tx)) 391 goto nla_put_failure; 392 break; 393 #if IS_ENABLED(CONFIG_IPV6) 394 case AF_INET6: 395 if (udp_get_no_check6_tx(sk) && 396 nla_put_flag(skb, L2TP_ATTR_UDP_ZERO_CSUM6_TX)) 397 goto nla_put_failure; 398 if (udp_get_no_check6_rx(sk) && 399 nla_put_flag(skb, L2TP_ATTR_UDP_ZERO_CSUM6_RX)) 400 goto nla_put_failure; 401 break; 402 #endif 403 } 404 if (nla_put_u16(skb, L2TP_ATTR_UDP_SPORT, ntohs(inet->inet_sport)) || 405 nla_put_u16(skb, L2TP_ATTR_UDP_DPORT, ntohs(inet->inet_dport))) 406 goto nla_put_failure; 407 /* fall through */ 408 case L2TP_ENCAPTYPE_IP: 409 #if IS_ENABLED(CONFIG_IPV6) 410 if (np) { 411 if (nla_put_in6_addr(skb, L2TP_ATTR_IP6_SADDR, 412 &np->saddr) || 413 nla_put_in6_addr(skb, L2TP_ATTR_IP6_DADDR, 414 &sk->sk_v6_daddr)) 415 goto nla_put_failure; 416 } else 417 #endif 418 if (nla_put_in_addr(skb, L2TP_ATTR_IP_SADDR, 419 inet->inet_saddr) || 420 nla_put_in_addr(skb, L2TP_ATTR_IP_DADDR, 421 inet->inet_daddr)) 422 goto nla_put_failure; 423 break; 424 } 425 426 out: 427 genlmsg_end(skb, hdr); 428 return 0; 429 430 nla_put_failure: 431 genlmsg_cancel(skb, hdr); 432 return -1; 433 } 434 435 static int l2tp_nl_cmd_tunnel_get(struct sk_buff *skb, struct genl_info *info) 436 { 437 struct l2tp_tunnel *tunnel; 438 struct sk_buff *msg; 439 u32 tunnel_id; 440 int ret = -ENOBUFS; 441 struct net *net = genl_info_net(info); 442 443 if (!info->attrs[L2TP_ATTR_CONN_ID]) { 444 ret = -EINVAL; 445 goto err; 446 } 447 448 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 449 450 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 451 if (!msg) { 452 ret = -ENOMEM; 453 goto err; 454 } 455 456 tunnel = l2tp_tunnel_get(net, tunnel_id); 457 if (!tunnel) { 458 ret = -ENODEV; 459 goto err_nlmsg; 460 } 461 462 ret = l2tp_nl_tunnel_send(msg, info->snd_portid, info->snd_seq, 463 NLM_F_ACK, tunnel, L2TP_CMD_TUNNEL_GET); 464 if (ret < 0) 465 goto err_nlmsg_tunnel; 466 467 l2tp_tunnel_dec_refcount(tunnel); 468 469 return genlmsg_unicast(net, msg, info->snd_portid); 470 471 err_nlmsg_tunnel: 472 l2tp_tunnel_dec_refcount(tunnel); 473 err_nlmsg: 474 nlmsg_free(msg); 475 err: 476 return ret; 477 } 478 479 static int l2tp_nl_cmd_tunnel_dump(struct sk_buff *skb, struct netlink_callback *cb) 480 { 481 int ti = cb->args[0]; 482 struct l2tp_tunnel *tunnel; 483 struct net *net = sock_net(skb->sk); 484 485 for (;;) { 486 tunnel = l2tp_tunnel_find_nth(net, ti); 487 if (tunnel == NULL) 488 goto out; 489 490 if (l2tp_nl_tunnel_send(skb, NETLINK_CB(cb->skb).portid, 491 cb->nlh->nlmsg_seq, NLM_F_MULTI, 492 tunnel, L2TP_CMD_TUNNEL_GET) < 0) 493 goto out; 494 495 ti++; 496 } 497 498 out: 499 cb->args[0] = ti; 500 501 return skb->len; 502 } 503 504 static int l2tp_nl_cmd_session_create(struct sk_buff *skb, struct genl_info *info) 505 { 506 u32 tunnel_id = 0; 507 u32 session_id; 508 u32 peer_session_id; 509 int ret = 0; 510 struct l2tp_tunnel *tunnel; 511 struct l2tp_session *session; 512 struct l2tp_session_cfg cfg = { 0, }; 513 struct net *net = genl_info_net(info); 514 515 if (!info->attrs[L2TP_ATTR_CONN_ID]) { 516 ret = -EINVAL; 517 goto out; 518 } 519 520 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 521 tunnel = l2tp_tunnel_get(net, tunnel_id); 522 if (!tunnel) { 523 ret = -ENODEV; 524 goto out; 525 } 526 527 if (!info->attrs[L2TP_ATTR_SESSION_ID]) { 528 ret = -EINVAL; 529 goto out_tunnel; 530 } 531 session_id = nla_get_u32(info->attrs[L2TP_ATTR_SESSION_ID]); 532 533 if (!info->attrs[L2TP_ATTR_PEER_SESSION_ID]) { 534 ret = -EINVAL; 535 goto out_tunnel; 536 } 537 peer_session_id = nla_get_u32(info->attrs[L2TP_ATTR_PEER_SESSION_ID]); 538 539 if (!info->attrs[L2TP_ATTR_PW_TYPE]) { 540 ret = -EINVAL; 541 goto out_tunnel; 542 } 543 cfg.pw_type = nla_get_u16(info->attrs[L2TP_ATTR_PW_TYPE]); 544 if (cfg.pw_type >= __L2TP_PWTYPE_MAX) { 545 ret = -EINVAL; 546 goto out_tunnel; 547 } 548 549 if (tunnel->version > 2) { 550 if (info->attrs[L2TP_ATTR_DATA_SEQ]) 551 cfg.data_seq = nla_get_u8(info->attrs[L2TP_ATTR_DATA_SEQ]); 552 553 if (info->attrs[L2TP_ATTR_L2SPEC_TYPE]) { 554 cfg.l2specific_type = nla_get_u8(info->attrs[L2TP_ATTR_L2SPEC_TYPE]); 555 if (cfg.l2specific_type != L2TP_L2SPECTYPE_DEFAULT && 556 cfg.l2specific_type != L2TP_L2SPECTYPE_NONE) { 557 ret = -EINVAL; 558 goto out_tunnel; 559 } 560 } else { 561 cfg.l2specific_type = L2TP_L2SPECTYPE_DEFAULT; 562 } 563 564 if (info->attrs[L2TP_ATTR_COOKIE]) { 565 u16 len = nla_len(info->attrs[L2TP_ATTR_COOKIE]); 566 if (len > 8) { 567 ret = -EINVAL; 568 goto out_tunnel; 569 } 570 cfg.cookie_len = len; 571 memcpy(&cfg.cookie[0], nla_data(info->attrs[L2TP_ATTR_COOKIE]), len); 572 } 573 if (info->attrs[L2TP_ATTR_PEER_COOKIE]) { 574 u16 len = nla_len(info->attrs[L2TP_ATTR_PEER_COOKIE]); 575 if (len > 8) { 576 ret = -EINVAL; 577 goto out_tunnel; 578 } 579 cfg.peer_cookie_len = len; 580 memcpy(&cfg.peer_cookie[0], nla_data(info->attrs[L2TP_ATTR_PEER_COOKIE]), len); 581 } 582 if (info->attrs[L2TP_ATTR_IFNAME]) 583 cfg.ifname = nla_data(info->attrs[L2TP_ATTR_IFNAME]); 584 585 if (info->attrs[L2TP_ATTR_VLAN_ID]) 586 cfg.vlan_id = nla_get_u16(info->attrs[L2TP_ATTR_VLAN_ID]); 587 } 588 589 if (info->attrs[L2TP_ATTR_DEBUG]) 590 cfg.debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]); 591 592 if (info->attrs[L2TP_ATTR_RECV_SEQ]) 593 cfg.recv_seq = nla_get_u8(info->attrs[L2TP_ATTR_RECV_SEQ]); 594 595 if (info->attrs[L2TP_ATTR_SEND_SEQ]) 596 cfg.send_seq = nla_get_u8(info->attrs[L2TP_ATTR_SEND_SEQ]); 597 598 if (info->attrs[L2TP_ATTR_LNS_MODE]) 599 cfg.lns_mode = nla_get_u8(info->attrs[L2TP_ATTR_LNS_MODE]); 600 601 if (info->attrs[L2TP_ATTR_RECV_TIMEOUT]) 602 cfg.reorder_timeout = nla_get_msecs(info->attrs[L2TP_ATTR_RECV_TIMEOUT]); 603 604 if (info->attrs[L2TP_ATTR_MTU]) 605 cfg.mtu = nla_get_u16(info->attrs[L2TP_ATTR_MTU]); 606 607 if (info->attrs[L2TP_ATTR_MRU]) 608 cfg.mru = nla_get_u16(info->attrs[L2TP_ATTR_MRU]); 609 610 #ifdef CONFIG_MODULES 611 if (l2tp_nl_cmd_ops[cfg.pw_type] == NULL) { 612 genl_unlock(); 613 request_module("net-l2tp-type-%u", cfg.pw_type); 614 genl_lock(); 615 } 616 #endif 617 if ((l2tp_nl_cmd_ops[cfg.pw_type] == NULL) || 618 (l2tp_nl_cmd_ops[cfg.pw_type]->session_create == NULL)) { 619 ret = -EPROTONOSUPPORT; 620 goto out_tunnel; 621 } 622 623 ret = l2tp_nl_cmd_ops[cfg.pw_type]->session_create(net, tunnel, 624 session_id, 625 peer_session_id, 626 &cfg); 627 628 if (ret >= 0) { 629 session = l2tp_session_get(net, tunnel, session_id); 630 if (session) { 631 ret = l2tp_session_notify(&l2tp_nl_family, info, session, 632 L2TP_CMD_SESSION_CREATE); 633 l2tp_session_dec_refcount(session); 634 } 635 } 636 637 out_tunnel: 638 l2tp_tunnel_dec_refcount(tunnel); 639 out: 640 return ret; 641 } 642 643 static int l2tp_nl_cmd_session_delete(struct sk_buff *skb, struct genl_info *info) 644 { 645 int ret = 0; 646 struct l2tp_session *session; 647 u16 pw_type; 648 649 session = l2tp_nl_session_get(info); 650 if (session == NULL) { 651 ret = -ENODEV; 652 goto out; 653 } 654 655 l2tp_session_notify(&l2tp_nl_family, info, 656 session, L2TP_CMD_SESSION_DELETE); 657 658 pw_type = session->pwtype; 659 if (pw_type < __L2TP_PWTYPE_MAX) 660 if (l2tp_nl_cmd_ops[pw_type] && l2tp_nl_cmd_ops[pw_type]->session_delete) 661 ret = (*l2tp_nl_cmd_ops[pw_type]->session_delete)(session); 662 663 l2tp_session_dec_refcount(session); 664 665 out: 666 return ret; 667 } 668 669 static int l2tp_nl_cmd_session_modify(struct sk_buff *skb, struct genl_info *info) 670 { 671 int ret = 0; 672 struct l2tp_session *session; 673 674 session = l2tp_nl_session_get(info); 675 if (session == NULL) { 676 ret = -ENODEV; 677 goto out; 678 } 679 680 if (info->attrs[L2TP_ATTR_DEBUG]) 681 session->debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]); 682 683 if (info->attrs[L2TP_ATTR_DATA_SEQ]) 684 session->data_seq = nla_get_u8(info->attrs[L2TP_ATTR_DATA_SEQ]); 685 686 if (info->attrs[L2TP_ATTR_RECV_SEQ]) 687 session->recv_seq = nla_get_u8(info->attrs[L2TP_ATTR_RECV_SEQ]); 688 689 if (info->attrs[L2TP_ATTR_SEND_SEQ]) { 690 session->send_seq = nla_get_u8(info->attrs[L2TP_ATTR_SEND_SEQ]); 691 l2tp_session_set_header_len(session, session->tunnel->version); 692 } 693 694 if (info->attrs[L2TP_ATTR_LNS_MODE]) 695 session->lns_mode = nla_get_u8(info->attrs[L2TP_ATTR_LNS_MODE]); 696 697 if (info->attrs[L2TP_ATTR_RECV_TIMEOUT]) 698 session->reorder_timeout = nla_get_msecs(info->attrs[L2TP_ATTR_RECV_TIMEOUT]); 699 700 if (info->attrs[L2TP_ATTR_MTU]) 701 session->mtu = nla_get_u16(info->attrs[L2TP_ATTR_MTU]); 702 703 if (info->attrs[L2TP_ATTR_MRU]) 704 session->mru = nla_get_u16(info->attrs[L2TP_ATTR_MRU]); 705 706 ret = l2tp_session_notify(&l2tp_nl_family, info, 707 session, L2TP_CMD_SESSION_MODIFY); 708 709 l2tp_session_dec_refcount(session); 710 711 out: 712 return ret; 713 } 714 715 static int l2tp_nl_session_send(struct sk_buff *skb, u32 portid, u32 seq, int flags, 716 struct l2tp_session *session, u8 cmd) 717 { 718 void *hdr; 719 struct nlattr *nest; 720 struct l2tp_tunnel *tunnel = session->tunnel; 721 struct sock *sk = NULL; 722 723 sk = tunnel->sock; 724 725 hdr = genlmsg_put(skb, portid, seq, &l2tp_nl_family, flags, cmd); 726 if (!hdr) 727 return -EMSGSIZE; 728 729 if (nla_put_u32(skb, L2TP_ATTR_CONN_ID, tunnel->tunnel_id) || 730 nla_put_u32(skb, L2TP_ATTR_SESSION_ID, session->session_id) || 731 nla_put_u32(skb, L2TP_ATTR_PEER_CONN_ID, tunnel->peer_tunnel_id) || 732 nla_put_u32(skb, L2TP_ATTR_PEER_SESSION_ID, 733 session->peer_session_id) || 734 nla_put_u32(skb, L2TP_ATTR_DEBUG, session->debug) || 735 nla_put_u16(skb, L2TP_ATTR_PW_TYPE, session->pwtype) || 736 nla_put_u16(skb, L2TP_ATTR_MTU, session->mtu) || 737 (session->mru && 738 nla_put_u16(skb, L2TP_ATTR_MRU, session->mru))) 739 goto nla_put_failure; 740 741 if ((session->ifname[0] && 742 nla_put_string(skb, L2TP_ATTR_IFNAME, session->ifname)) || 743 (session->cookie_len && 744 nla_put(skb, L2TP_ATTR_COOKIE, session->cookie_len, 745 &session->cookie[0])) || 746 (session->peer_cookie_len && 747 nla_put(skb, L2TP_ATTR_PEER_COOKIE, session->peer_cookie_len, 748 &session->peer_cookie[0])) || 749 nla_put_u8(skb, L2TP_ATTR_RECV_SEQ, session->recv_seq) || 750 nla_put_u8(skb, L2TP_ATTR_SEND_SEQ, session->send_seq) || 751 nla_put_u8(skb, L2TP_ATTR_LNS_MODE, session->lns_mode) || 752 #ifdef CONFIG_XFRM 753 (((sk) && (sk->sk_policy[0] || sk->sk_policy[1])) && 754 nla_put_u8(skb, L2TP_ATTR_USING_IPSEC, 1)) || 755 #endif 756 (session->reorder_timeout && 757 nla_put_msecs(skb, L2TP_ATTR_RECV_TIMEOUT, 758 session->reorder_timeout, L2TP_ATTR_PAD))) 759 goto nla_put_failure; 760 761 nest = nla_nest_start(skb, L2TP_ATTR_STATS); 762 if (nest == NULL) 763 goto nla_put_failure; 764 765 if (nla_put_u64_64bit(skb, L2TP_ATTR_TX_PACKETS, 766 atomic_long_read(&session->stats.tx_packets), 767 L2TP_ATTR_STATS_PAD) || 768 nla_put_u64_64bit(skb, L2TP_ATTR_TX_BYTES, 769 atomic_long_read(&session->stats.tx_bytes), 770 L2TP_ATTR_STATS_PAD) || 771 nla_put_u64_64bit(skb, L2TP_ATTR_TX_ERRORS, 772 atomic_long_read(&session->stats.tx_errors), 773 L2TP_ATTR_STATS_PAD) || 774 nla_put_u64_64bit(skb, L2TP_ATTR_RX_PACKETS, 775 atomic_long_read(&session->stats.rx_packets), 776 L2TP_ATTR_STATS_PAD) || 777 nla_put_u64_64bit(skb, L2TP_ATTR_RX_BYTES, 778 atomic_long_read(&session->stats.rx_bytes), 779 L2TP_ATTR_STATS_PAD) || 780 nla_put_u64_64bit(skb, L2TP_ATTR_RX_SEQ_DISCARDS, 781 atomic_long_read(&session->stats.rx_seq_discards), 782 L2TP_ATTR_STATS_PAD) || 783 nla_put_u64_64bit(skb, L2TP_ATTR_RX_OOS_PACKETS, 784 atomic_long_read(&session->stats.rx_oos_packets), 785 L2TP_ATTR_STATS_PAD) || 786 nla_put_u64_64bit(skb, L2TP_ATTR_RX_ERRORS, 787 atomic_long_read(&session->stats.rx_errors), 788 L2TP_ATTR_STATS_PAD)) 789 goto nla_put_failure; 790 nla_nest_end(skb, nest); 791 792 genlmsg_end(skb, hdr); 793 return 0; 794 795 nla_put_failure: 796 genlmsg_cancel(skb, hdr); 797 return -1; 798 } 799 800 static int l2tp_nl_cmd_session_get(struct sk_buff *skb, struct genl_info *info) 801 { 802 struct l2tp_session *session; 803 struct sk_buff *msg; 804 int ret; 805 806 session = l2tp_nl_session_get(info); 807 if (session == NULL) { 808 ret = -ENODEV; 809 goto err; 810 } 811 812 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 813 if (!msg) { 814 ret = -ENOMEM; 815 goto err_ref; 816 } 817 818 ret = l2tp_nl_session_send(msg, info->snd_portid, info->snd_seq, 819 0, session, L2TP_CMD_SESSION_GET); 820 if (ret < 0) 821 goto err_ref_msg; 822 823 ret = genlmsg_unicast(genl_info_net(info), msg, info->snd_portid); 824 825 l2tp_session_dec_refcount(session); 826 827 return ret; 828 829 err_ref_msg: 830 nlmsg_free(msg); 831 err_ref: 832 l2tp_session_dec_refcount(session); 833 err: 834 return ret; 835 } 836 837 static int l2tp_nl_cmd_session_dump(struct sk_buff *skb, struct netlink_callback *cb) 838 { 839 struct net *net = sock_net(skb->sk); 840 struct l2tp_session *session; 841 struct l2tp_tunnel *tunnel = NULL; 842 int ti = cb->args[0]; 843 int si = cb->args[1]; 844 845 for (;;) { 846 if (tunnel == NULL) { 847 tunnel = l2tp_tunnel_find_nth(net, ti); 848 if (tunnel == NULL) 849 goto out; 850 } 851 852 session = l2tp_session_get_nth(tunnel, si); 853 if (session == NULL) { 854 ti++; 855 tunnel = NULL; 856 si = 0; 857 continue; 858 } 859 860 if (l2tp_nl_session_send(skb, NETLINK_CB(cb->skb).portid, 861 cb->nlh->nlmsg_seq, NLM_F_MULTI, 862 session, L2TP_CMD_SESSION_GET) < 0) { 863 l2tp_session_dec_refcount(session); 864 break; 865 } 866 l2tp_session_dec_refcount(session); 867 868 si++; 869 } 870 871 out: 872 cb->args[0] = ti; 873 cb->args[1] = si; 874 875 return skb->len; 876 } 877 878 static const struct nla_policy l2tp_nl_policy[L2TP_ATTR_MAX + 1] = { 879 [L2TP_ATTR_NONE] = { .type = NLA_UNSPEC, }, 880 [L2TP_ATTR_PW_TYPE] = { .type = NLA_U16, }, 881 [L2TP_ATTR_ENCAP_TYPE] = { .type = NLA_U16, }, 882 [L2TP_ATTR_OFFSET] = { .type = NLA_U16, }, 883 [L2TP_ATTR_DATA_SEQ] = { .type = NLA_U8, }, 884 [L2TP_ATTR_L2SPEC_TYPE] = { .type = NLA_U8, }, 885 [L2TP_ATTR_L2SPEC_LEN] = { .type = NLA_U8, }, 886 [L2TP_ATTR_PROTO_VERSION] = { .type = NLA_U8, }, 887 [L2TP_ATTR_CONN_ID] = { .type = NLA_U32, }, 888 [L2TP_ATTR_PEER_CONN_ID] = { .type = NLA_U32, }, 889 [L2TP_ATTR_SESSION_ID] = { .type = NLA_U32, }, 890 [L2TP_ATTR_PEER_SESSION_ID] = { .type = NLA_U32, }, 891 [L2TP_ATTR_UDP_CSUM] = { .type = NLA_U8, }, 892 [L2TP_ATTR_VLAN_ID] = { .type = NLA_U16, }, 893 [L2TP_ATTR_DEBUG] = { .type = NLA_U32, }, 894 [L2TP_ATTR_RECV_SEQ] = { .type = NLA_U8, }, 895 [L2TP_ATTR_SEND_SEQ] = { .type = NLA_U8, }, 896 [L2TP_ATTR_LNS_MODE] = { .type = NLA_U8, }, 897 [L2TP_ATTR_USING_IPSEC] = { .type = NLA_U8, }, 898 [L2TP_ATTR_RECV_TIMEOUT] = { .type = NLA_MSECS, }, 899 [L2TP_ATTR_FD] = { .type = NLA_U32, }, 900 [L2TP_ATTR_IP_SADDR] = { .type = NLA_U32, }, 901 [L2TP_ATTR_IP_DADDR] = { .type = NLA_U32, }, 902 [L2TP_ATTR_UDP_SPORT] = { .type = NLA_U16, }, 903 [L2TP_ATTR_UDP_DPORT] = { .type = NLA_U16, }, 904 [L2TP_ATTR_MTU] = { .type = NLA_U16, }, 905 [L2TP_ATTR_MRU] = { .type = NLA_U16, }, 906 [L2TP_ATTR_STATS] = { .type = NLA_NESTED, }, 907 [L2TP_ATTR_IP6_SADDR] = { 908 .type = NLA_BINARY, 909 .len = sizeof(struct in6_addr), 910 }, 911 [L2TP_ATTR_IP6_DADDR] = { 912 .type = NLA_BINARY, 913 .len = sizeof(struct in6_addr), 914 }, 915 [L2TP_ATTR_IFNAME] = { 916 .type = NLA_NUL_STRING, 917 .len = IFNAMSIZ - 1, 918 }, 919 [L2TP_ATTR_COOKIE] = { 920 .type = NLA_BINARY, 921 .len = 8, 922 }, 923 [L2TP_ATTR_PEER_COOKIE] = { 924 .type = NLA_BINARY, 925 .len = 8, 926 }, 927 }; 928 929 static const struct genl_ops l2tp_nl_ops[] = { 930 { 931 .cmd = L2TP_CMD_NOOP, 932 .doit = l2tp_nl_cmd_noop, 933 .policy = l2tp_nl_policy, 934 /* can be retrieved by unprivileged users */ 935 }, 936 { 937 .cmd = L2TP_CMD_TUNNEL_CREATE, 938 .doit = l2tp_nl_cmd_tunnel_create, 939 .policy = l2tp_nl_policy, 940 .flags = GENL_ADMIN_PERM, 941 }, 942 { 943 .cmd = L2TP_CMD_TUNNEL_DELETE, 944 .doit = l2tp_nl_cmd_tunnel_delete, 945 .policy = l2tp_nl_policy, 946 .flags = GENL_ADMIN_PERM, 947 }, 948 { 949 .cmd = L2TP_CMD_TUNNEL_MODIFY, 950 .doit = l2tp_nl_cmd_tunnel_modify, 951 .policy = l2tp_nl_policy, 952 .flags = GENL_ADMIN_PERM, 953 }, 954 { 955 .cmd = L2TP_CMD_TUNNEL_GET, 956 .doit = l2tp_nl_cmd_tunnel_get, 957 .dumpit = l2tp_nl_cmd_tunnel_dump, 958 .policy = l2tp_nl_policy, 959 .flags = GENL_ADMIN_PERM, 960 }, 961 { 962 .cmd = L2TP_CMD_SESSION_CREATE, 963 .doit = l2tp_nl_cmd_session_create, 964 .policy = l2tp_nl_policy, 965 .flags = GENL_ADMIN_PERM, 966 }, 967 { 968 .cmd = L2TP_CMD_SESSION_DELETE, 969 .doit = l2tp_nl_cmd_session_delete, 970 .policy = l2tp_nl_policy, 971 .flags = GENL_ADMIN_PERM, 972 }, 973 { 974 .cmd = L2TP_CMD_SESSION_MODIFY, 975 .doit = l2tp_nl_cmd_session_modify, 976 .policy = l2tp_nl_policy, 977 .flags = GENL_ADMIN_PERM, 978 }, 979 { 980 .cmd = L2TP_CMD_SESSION_GET, 981 .doit = l2tp_nl_cmd_session_get, 982 .dumpit = l2tp_nl_cmd_session_dump, 983 .policy = l2tp_nl_policy, 984 .flags = GENL_ADMIN_PERM, 985 }, 986 }; 987 988 static struct genl_family l2tp_nl_family __ro_after_init = { 989 .name = L2TP_GENL_NAME, 990 .version = L2TP_GENL_VERSION, 991 .hdrsize = 0, 992 .maxattr = L2TP_ATTR_MAX, 993 .netnsok = true, 994 .module = THIS_MODULE, 995 .ops = l2tp_nl_ops, 996 .n_ops = ARRAY_SIZE(l2tp_nl_ops), 997 .mcgrps = l2tp_multicast_group, 998 .n_mcgrps = ARRAY_SIZE(l2tp_multicast_group), 999 }; 1000 1001 int l2tp_nl_register_ops(enum l2tp_pwtype pw_type, const struct l2tp_nl_cmd_ops *ops) 1002 { 1003 int ret; 1004 1005 ret = -EINVAL; 1006 if (pw_type >= __L2TP_PWTYPE_MAX) 1007 goto err; 1008 1009 genl_lock(); 1010 ret = -EBUSY; 1011 if (l2tp_nl_cmd_ops[pw_type]) 1012 goto out; 1013 1014 l2tp_nl_cmd_ops[pw_type] = ops; 1015 ret = 0; 1016 1017 out: 1018 genl_unlock(); 1019 err: 1020 return ret; 1021 } 1022 EXPORT_SYMBOL_GPL(l2tp_nl_register_ops); 1023 1024 void l2tp_nl_unregister_ops(enum l2tp_pwtype pw_type) 1025 { 1026 if (pw_type < __L2TP_PWTYPE_MAX) { 1027 genl_lock(); 1028 l2tp_nl_cmd_ops[pw_type] = NULL; 1029 genl_unlock(); 1030 } 1031 } 1032 EXPORT_SYMBOL_GPL(l2tp_nl_unregister_ops); 1033 1034 static int __init l2tp_nl_init(void) 1035 { 1036 pr_info("L2TP netlink interface\n"); 1037 return genl_register_family(&l2tp_nl_family); 1038 } 1039 1040 static void l2tp_nl_cleanup(void) 1041 { 1042 genl_unregister_family(&l2tp_nl_family); 1043 } 1044 1045 module_init(l2tp_nl_init); 1046 module_exit(l2tp_nl_cleanup); 1047 1048 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>"); 1049 MODULE_DESCRIPTION("L2TP netlink"); 1050 MODULE_LICENSE("GPL"); 1051 MODULE_VERSION("1.0"); 1052 MODULE_ALIAS_GENL_FAMILY("l2tp"); 1053