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 ret = -EINVAL; 240 switch (cfg.encap) { 241 case L2TP_ENCAPTYPE_UDP: 242 case L2TP_ENCAPTYPE_IP: 243 ret = l2tp_tunnel_create(net, fd, proto_version, tunnel_id, 244 peer_tunnel_id, &cfg, &tunnel); 245 break; 246 } 247 248 if (ret < 0) 249 goto out; 250 251 l2tp_tunnel_inc_refcount(tunnel); 252 ret = l2tp_tunnel_register(tunnel, net, &cfg); 253 if (ret < 0) { 254 kfree(tunnel); 255 goto out; 256 } 257 ret = l2tp_tunnel_notify(&l2tp_nl_family, info, tunnel, 258 L2TP_CMD_TUNNEL_CREATE); 259 l2tp_tunnel_dec_refcount(tunnel); 260 261 out: 262 return ret; 263 } 264 265 static int l2tp_nl_cmd_tunnel_delete(struct sk_buff *skb, struct genl_info *info) 266 { 267 struct l2tp_tunnel *tunnel; 268 u32 tunnel_id; 269 int ret = 0; 270 struct net *net = genl_info_net(info); 271 272 if (!info->attrs[L2TP_ATTR_CONN_ID]) { 273 ret = -EINVAL; 274 goto out; 275 } 276 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 277 278 tunnel = l2tp_tunnel_get(net, tunnel_id); 279 if (!tunnel) { 280 ret = -ENODEV; 281 goto out; 282 } 283 284 l2tp_tunnel_notify(&l2tp_nl_family, info, 285 tunnel, L2TP_CMD_TUNNEL_DELETE); 286 287 l2tp_tunnel_delete(tunnel); 288 289 l2tp_tunnel_dec_refcount(tunnel); 290 291 out: 292 return ret; 293 } 294 295 static int l2tp_nl_cmd_tunnel_modify(struct sk_buff *skb, struct genl_info *info) 296 { 297 struct l2tp_tunnel *tunnel; 298 u32 tunnel_id; 299 int ret = 0; 300 struct net *net = genl_info_net(info); 301 302 if (!info->attrs[L2TP_ATTR_CONN_ID]) { 303 ret = -EINVAL; 304 goto out; 305 } 306 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 307 308 tunnel = l2tp_tunnel_get(net, tunnel_id); 309 if (!tunnel) { 310 ret = -ENODEV; 311 goto out; 312 } 313 314 if (info->attrs[L2TP_ATTR_DEBUG]) 315 tunnel->debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]); 316 317 ret = l2tp_tunnel_notify(&l2tp_nl_family, info, 318 tunnel, L2TP_CMD_TUNNEL_MODIFY); 319 320 l2tp_tunnel_dec_refcount(tunnel); 321 322 out: 323 return ret; 324 } 325 326 static int l2tp_nl_tunnel_send(struct sk_buff *skb, u32 portid, u32 seq, int flags, 327 struct l2tp_tunnel *tunnel, u8 cmd) 328 { 329 void *hdr; 330 struct nlattr *nest; 331 struct sock *sk = NULL; 332 struct inet_sock *inet; 333 #if IS_ENABLED(CONFIG_IPV6) 334 struct ipv6_pinfo *np = NULL; 335 #endif 336 337 hdr = genlmsg_put(skb, portid, seq, &l2tp_nl_family, flags, cmd); 338 if (!hdr) 339 return -EMSGSIZE; 340 341 if (nla_put_u8(skb, L2TP_ATTR_PROTO_VERSION, tunnel->version) || 342 nla_put_u32(skb, L2TP_ATTR_CONN_ID, tunnel->tunnel_id) || 343 nla_put_u32(skb, L2TP_ATTR_PEER_CONN_ID, tunnel->peer_tunnel_id) || 344 nla_put_u32(skb, L2TP_ATTR_DEBUG, tunnel->debug) || 345 nla_put_u16(skb, L2TP_ATTR_ENCAP_TYPE, tunnel->encap)) 346 goto nla_put_failure; 347 348 nest = nla_nest_start(skb, L2TP_ATTR_STATS); 349 if (nest == NULL) 350 goto nla_put_failure; 351 352 if (nla_put_u64_64bit(skb, L2TP_ATTR_TX_PACKETS, 353 atomic_long_read(&tunnel->stats.tx_packets), 354 L2TP_ATTR_STATS_PAD) || 355 nla_put_u64_64bit(skb, L2TP_ATTR_TX_BYTES, 356 atomic_long_read(&tunnel->stats.tx_bytes), 357 L2TP_ATTR_STATS_PAD) || 358 nla_put_u64_64bit(skb, L2TP_ATTR_TX_ERRORS, 359 atomic_long_read(&tunnel->stats.tx_errors), 360 L2TP_ATTR_STATS_PAD) || 361 nla_put_u64_64bit(skb, L2TP_ATTR_RX_PACKETS, 362 atomic_long_read(&tunnel->stats.rx_packets), 363 L2TP_ATTR_STATS_PAD) || 364 nla_put_u64_64bit(skb, L2TP_ATTR_RX_BYTES, 365 atomic_long_read(&tunnel->stats.rx_bytes), 366 L2TP_ATTR_STATS_PAD) || 367 nla_put_u64_64bit(skb, L2TP_ATTR_RX_SEQ_DISCARDS, 368 atomic_long_read(&tunnel->stats.rx_seq_discards), 369 L2TP_ATTR_STATS_PAD) || 370 nla_put_u64_64bit(skb, L2TP_ATTR_RX_OOS_PACKETS, 371 atomic_long_read(&tunnel->stats.rx_oos_packets), 372 L2TP_ATTR_STATS_PAD) || 373 nla_put_u64_64bit(skb, L2TP_ATTR_RX_ERRORS, 374 atomic_long_read(&tunnel->stats.rx_errors), 375 L2TP_ATTR_STATS_PAD)) 376 goto nla_put_failure; 377 nla_nest_end(skb, nest); 378 379 sk = tunnel->sock; 380 if (!sk) 381 goto out; 382 383 #if IS_ENABLED(CONFIG_IPV6) 384 if (sk->sk_family == AF_INET6) 385 np = inet6_sk(sk); 386 #endif 387 388 inet = inet_sk(sk); 389 390 switch (tunnel->encap) { 391 case L2TP_ENCAPTYPE_UDP: 392 switch (sk->sk_family) { 393 case AF_INET: 394 if (nla_put_u8(skb, L2TP_ATTR_UDP_CSUM, !sk->sk_no_check_tx)) 395 goto nla_put_failure; 396 break; 397 #if IS_ENABLED(CONFIG_IPV6) 398 case AF_INET6: 399 if (udp_get_no_check6_tx(sk) && 400 nla_put_flag(skb, L2TP_ATTR_UDP_ZERO_CSUM6_TX)) 401 goto nla_put_failure; 402 if (udp_get_no_check6_rx(sk) && 403 nla_put_flag(skb, L2TP_ATTR_UDP_ZERO_CSUM6_RX)) 404 goto nla_put_failure; 405 break; 406 #endif 407 } 408 if (nla_put_u16(skb, L2TP_ATTR_UDP_SPORT, ntohs(inet->inet_sport)) || 409 nla_put_u16(skb, L2TP_ATTR_UDP_DPORT, ntohs(inet->inet_dport))) 410 goto nla_put_failure; 411 /* fall through */ 412 case L2TP_ENCAPTYPE_IP: 413 #if IS_ENABLED(CONFIG_IPV6) 414 if (np) { 415 if (nla_put_in6_addr(skb, L2TP_ATTR_IP6_SADDR, 416 &np->saddr) || 417 nla_put_in6_addr(skb, L2TP_ATTR_IP6_DADDR, 418 &sk->sk_v6_daddr)) 419 goto nla_put_failure; 420 } else 421 #endif 422 if (nla_put_in_addr(skb, L2TP_ATTR_IP_SADDR, 423 inet->inet_saddr) || 424 nla_put_in_addr(skb, L2TP_ATTR_IP_DADDR, 425 inet->inet_daddr)) 426 goto nla_put_failure; 427 break; 428 } 429 430 out: 431 genlmsg_end(skb, hdr); 432 return 0; 433 434 nla_put_failure: 435 genlmsg_cancel(skb, hdr); 436 return -1; 437 } 438 439 static int l2tp_nl_cmd_tunnel_get(struct sk_buff *skb, struct genl_info *info) 440 { 441 struct l2tp_tunnel *tunnel; 442 struct sk_buff *msg; 443 u32 tunnel_id; 444 int ret = -ENOBUFS; 445 struct net *net = genl_info_net(info); 446 447 if (!info->attrs[L2TP_ATTR_CONN_ID]) { 448 ret = -EINVAL; 449 goto err; 450 } 451 452 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 453 454 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 455 if (!msg) { 456 ret = -ENOMEM; 457 goto err; 458 } 459 460 tunnel = l2tp_tunnel_get(net, tunnel_id); 461 if (!tunnel) { 462 ret = -ENODEV; 463 goto err_nlmsg; 464 } 465 466 ret = l2tp_nl_tunnel_send(msg, info->snd_portid, info->snd_seq, 467 NLM_F_ACK, tunnel, L2TP_CMD_TUNNEL_GET); 468 if (ret < 0) 469 goto err_nlmsg_tunnel; 470 471 l2tp_tunnel_dec_refcount(tunnel); 472 473 return genlmsg_unicast(net, msg, info->snd_portid); 474 475 err_nlmsg_tunnel: 476 l2tp_tunnel_dec_refcount(tunnel); 477 err_nlmsg: 478 nlmsg_free(msg); 479 err: 480 return ret; 481 } 482 483 static int l2tp_nl_cmd_tunnel_dump(struct sk_buff *skb, struct netlink_callback *cb) 484 { 485 int ti = cb->args[0]; 486 struct l2tp_tunnel *tunnel; 487 struct net *net = sock_net(skb->sk); 488 489 for (;;) { 490 tunnel = l2tp_tunnel_find_nth(net, ti); 491 if (tunnel == NULL) 492 goto out; 493 494 if (l2tp_nl_tunnel_send(skb, NETLINK_CB(cb->skb).portid, 495 cb->nlh->nlmsg_seq, NLM_F_MULTI, 496 tunnel, L2TP_CMD_TUNNEL_GET) < 0) 497 goto out; 498 499 ti++; 500 } 501 502 out: 503 cb->args[0] = ti; 504 505 return skb->len; 506 } 507 508 static int l2tp_nl_cmd_session_create(struct sk_buff *skb, struct genl_info *info) 509 { 510 u32 tunnel_id = 0; 511 u32 session_id; 512 u32 peer_session_id; 513 int ret = 0; 514 struct l2tp_tunnel *tunnel; 515 struct l2tp_session *session; 516 struct l2tp_session_cfg cfg = { 0, }; 517 struct net *net = genl_info_net(info); 518 519 if (!info->attrs[L2TP_ATTR_CONN_ID]) { 520 ret = -EINVAL; 521 goto out; 522 } 523 524 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 525 tunnel = l2tp_tunnel_get(net, tunnel_id); 526 if (!tunnel) { 527 ret = -ENODEV; 528 goto out; 529 } 530 531 if (!info->attrs[L2TP_ATTR_SESSION_ID]) { 532 ret = -EINVAL; 533 goto out_tunnel; 534 } 535 session_id = nla_get_u32(info->attrs[L2TP_ATTR_SESSION_ID]); 536 537 if (!info->attrs[L2TP_ATTR_PEER_SESSION_ID]) { 538 ret = -EINVAL; 539 goto out_tunnel; 540 } 541 peer_session_id = nla_get_u32(info->attrs[L2TP_ATTR_PEER_SESSION_ID]); 542 543 if (!info->attrs[L2TP_ATTR_PW_TYPE]) { 544 ret = -EINVAL; 545 goto out_tunnel; 546 } 547 cfg.pw_type = nla_get_u16(info->attrs[L2TP_ATTR_PW_TYPE]); 548 if (cfg.pw_type >= __L2TP_PWTYPE_MAX) { 549 ret = -EINVAL; 550 goto out_tunnel; 551 } 552 553 if (tunnel->version > 2) { 554 if (info->attrs[L2TP_ATTR_DATA_SEQ]) 555 cfg.data_seq = nla_get_u8(info->attrs[L2TP_ATTR_DATA_SEQ]); 556 557 if (info->attrs[L2TP_ATTR_L2SPEC_TYPE]) { 558 cfg.l2specific_type = nla_get_u8(info->attrs[L2TP_ATTR_L2SPEC_TYPE]); 559 if (cfg.l2specific_type != L2TP_L2SPECTYPE_DEFAULT && 560 cfg.l2specific_type != L2TP_L2SPECTYPE_NONE) { 561 ret = -EINVAL; 562 goto out_tunnel; 563 } 564 } else { 565 cfg.l2specific_type = L2TP_L2SPECTYPE_DEFAULT; 566 } 567 568 if (info->attrs[L2TP_ATTR_COOKIE]) { 569 u16 len = nla_len(info->attrs[L2TP_ATTR_COOKIE]); 570 if (len > 8) { 571 ret = -EINVAL; 572 goto out_tunnel; 573 } 574 cfg.cookie_len = len; 575 memcpy(&cfg.cookie[0], nla_data(info->attrs[L2TP_ATTR_COOKIE]), len); 576 } 577 if (info->attrs[L2TP_ATTR_PEER_COOKIE]) { 578 u16 len = nla_len(info->attrs[L2TP_ATTR_PEER_COOKIE]); 579 if (len > 8) { 580 ret = -EINVAL; 581 goto out_tunnel; 582 } 583 cfg.peer_cookie_len = len; 584 memcpy(&cfg.peer_cookie[0], nla_data(info->attrs[L2TP_ATTR_PEER_COOKIE]), len); 585 } 586 if (info->attrs[L2TP_ATTR_IFNAME]) 587 cfg.ifname = nla_data(info->attrs[L2TP_ATTR_IFNAME]); 588 589 if (info->attrs[L2TP_ATTR_VLAN_ID]) 590 cfg.vlan_id = nla_get_u16(info->attrs[L2TP_ATTR_VLAN_ID]); 591 } 592 593 if (info->attrs[L2TP_ATTR_DEBUG]) 594 cfg.debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]); 595 596 if (info->attrs[L2TP_ATTR_RECV_SEQ]) 597 cfg.recv_seq = nla_get_u8(info->attrs[L2TP_ATTR_RECV_SEQ]); 598 599 if (info->attrs[L2TP_ATTR_SEND_SEQ]) 600 cfg.send_seq = nla_get_u8(info->attrs[L2TP_ATTR_SEND_SEQ]); 601 602 if (info->attrs[L2TP_ATTR_LNS_MODE]) 603 cfg.lns_mode = nla_get_u8(info->attrs[L2TP_ATTR_LNS_MODE]); 604 605 if (info->attrs[L2TP_ATTR_RECV_TIMEOUT]) 606 cfg.reorder_timeout = nla_get_msecs(info->attrs[L2TP_ATTR_RECV_TIMEOUT]); 607 608 if (info->attrs[L2TP_ATTR_MTU]) 609 cfg.mtu = nla_get_u16(info->attrs[L2TP_ATTR_MTU]); 610 611 if (info->attrs[L2TP_ATTR_MRU]) 612 cfg.mru = nla_get_u16(info->attrs[L2TP_ATTR_MRU]); 613 614 #ifdef CONFIG_MODULES 615 if (l2tp_nl_cmd_ops[cfg.pw_type] == NULL) { 616 genl_unlock(); 617 request_module("net-l2tp-type-%u", cfg.pw_type); 618 genl_lock(); 619 } 620 #endif 621 if ((l2tp_nl_cmd_ops[cfg.pw_type] == NULL) || 622 (l2tp_nl_cmd_ops[cfg.pw_type]->session_create == NULL)) { 623 ret = -EPROTONOSUPPORT; 624 goto out_tunnel; 625 } 626 627 ret = l2tp_nl_cmd_ops[cfg.pw_type]->session_create(net, tunnel, 628 session_id, 629 peer_session_id, 630 &cfg); 631 632 if (ret >= 0) { 633 session = l2tp_session_get(net, tunnel, session_id); 634 if (session) { 635 ret = l2tp_session_notify(&l2tp_nl_family, info, session, 636 L2TP_CMD_SESSION_CREATE); 637 l2tp_session_dec_refcount(session); 638 } 639 } 640 641 out_tunnel: 642 l2tp_tunnel_dec_refcount(tunnel); 643 out: 644 return ret; 645 } 646 647 static int l2tp_nl_cmd_session_delete(struct sk_buff *skb, struct genl_info *info) 648 { 649 int ret = 0; 650 struct l2tp_session *session; 651 u16 pw_type; 652 653 session = l2tp_nl_session_get(info); 654 if (session == NULL) { 655 ret = -ENODEV; 656 goto out; 657 } 658 659 l2tp_session_notify(&l2tp_nl_family, info, 660 session, L2TP_CMD_SESSION_DELETE); 661 662 pw_type = session->pwtype; 663 if (pw_type < __L2TP_PWTYPE_MAX) 664 if (l2tp_nl_cmd_ops[pw_type] && l2tp_nl_cmd_ops[pw_type]->session_delete) 665 ret = (*l2tp_nl_cmd_ops[pw_type]->session_delete)(session); 666 667 l2tp_session_dec_refcount(session); 668 669 out: 670 return ret; 671 } 672 673 static int l2tp_nl_cmd_session_modify(struct sk_buff *skb, struct genl_info *info) 674 { 675 int ret = 0; 676 struct l2tp_session *session; 677 678 session = l2tp_nl_session_get(info); 679 if (session == NULL) { 680 ret = -ENODEV; 681 goto out; 682 } 683 684 if (info->attrs[L2TP_ATTR_DEBUG]) 685 session->debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]); 686 687 if (info->attrs[L2TP_ATTR_DATA_SEQ]) 688 session->data_seq = nla_get_u8(info->attrs[L2TP_ATTR_DATA_SEQ]); 689 690 if (info->attrs[L2TP_ATTR_RECV_SEQ]) 691 session->recv_seq = nla_get_u8(info->attrs[L2TP_ATTR_RECV_SEQ]); 692 693 if (info->attrs[L2TP_ATTR_SEND_SEQ]) { 694 session->send_seq = nla_get_u8(info->attrs[L2TP_ATTR_SEND_SEQ]); 695 l2tp_session_set_header_len(session, session->tunnel->version); 696 } 697 698 if (info->attrs[L2TP_ATTR_LNS_MODE]) 699 session->lns_mode = nla_get_u8(info->attrs[L2TP_ATTR_LNS_MODE]); 700 701 if (info->attrs[L2TP_ATTR_RECV_TIMEOUT]) 702 session->reorder_timeout = nla_get_msecs(info->attrs[L2TP_ATTR_RECV_TIMEOUT]); 703 704 if (info->attrs[L2TP_ATTR_MTU]) 705 session->mtu = nla_get_u16(info->attrs[L2TP_ATTR_MTU]); 706 707 if (info->attrs[L2TP_ATTR_MRU]) 708 session->mru = nla_get_u16(info->attrs[L2TP_ATTR_MRU]); 709 710 ret = l2tp_session_notify(&l2tp_nl_family, info, 711 session, L2TP_CMD_SESSION_MODIFY); 712 713 l2tp_session_dec_refcount(session); 714 715 out: 716 return ret; 717 } 718 719 static int l2tp_nl_session_send(struct sk_buff *skb, u32 portid, u32 seq, int flags, 720 struct l2tp_session *session, u8 cmd) 721 { 722 void *hdr; 723 struct nlattr *nest; 724 struct l2tp_tunnel *tunnel = session->tunnel; 725 struct sock *sk = NULL; 726 727 sk = tunnel->sock; 728 729 hdr = genlmsg_put(skb, portid, seq, &l2tp_nl_family, flags, cmd); 730 if (!hdr) 731 return -EMSGSIZE; 732 733 if (nla_put_u32(skb, L2TP_ATTR_CONN_ID, tunnel->tunnel_id) || 734 nla_put_u32(skb, L2TP_ATTR_SESSION_ID, session->session_id) || 735 nla_put_u32(skb, L2TP_ATTR_PEER_CONN_ID, tunnel->peer_tunnel_id) || 736 nla_put_u32(skb, L2TP_ATTR_PEER_SESSION_ID, 737 session->peer_session_id) || 738 nla_put_u32(skb, L2TP_ATTR_DEBUG, session->debug) || 739 nla_put_u16(skb, L2TP_ATTR_PW_TYPE, session->pwtype) || 740 nla_put_u16(skb, L2TP_ATTR_MTU, session->mtu) || 741 (session->mru && 742 nla_put_u16(skb, L2TP_ATTR_MRU, session->mru))) 743 goto nla_put_failure; 744 745 if ((session->ifname[0] && 746 nla_put_string(skb, L2TP_ATTR_IFNAME, session->ifname)) || 747 (session->cookie_len && 748 nla_put(skb, L2TP_ATTR_COOKIE, session->cookie_len, 749 &session->cookie[0])) || 750 (session->peer_cookie_len && 751 nla_put(skb, L2TP_ATTR_PEER_COOKIE, session->peer_cookie_len, 752 &session->peer_cookie[0])) || 753 nla_put_u8(skb, L2TP_ATTR_RECV_SEQ, session->recv_seq) || 754 nla_put_u8(skb, L2TP_ATTR_SEND_SEQ, session->send_seq) || 755 nla_put_u8(skb, L2TP_ATTR_LNS_MODE, session->lns_mode) || 756 #ifdef CONFIG_XFRM 757 (((sk) && (sk->sk_policy[0] || sk->sk_policy[1])) && 758 nla_put_u8(skb, L2TP_ATTR_USING_IPSEC, 1)) || 759 #endif 760 (session->reorder_timeout && 761 nla_put_msecs(skb, L2TP_ATTR_RECV_TIMEOUT, 762 session->reorder_timeout, L2TP_ATTR_PAD))) 763 goto nla_put_failure; 764 765 nest = nla_nest_start(skb, L2TP_ATTR_STATS); 766 if (nest == NULL) 767 goto nla_put_failure; 768 769 if (nla_put_u64_64bit(skb, L2TP_ATTR_TX_PACKETS, 770 atomic_long_read(&session->stats.tx_packets), 771 L2TP_ATTR_STATS_PAD) || 772 nla_put_u64_64bit(skb, L2TP_ATTR_TX_BYTES, 773 atomic_long_read(&session->stats.tx_bytes), 774 L2TP_ATTR_STATS_PAD) || 775 nla_put_u64_64bit(skb, L2TP_ATTR_TX_ERRORS, 776 atomic_long_read(&session->stats.tx_errors), 777 L2TP_ATTR_STATS_PAD) || 778 nla_put_u64_64bit(skb, L2TP_ATTR_RX_PACKETS, 779 atomic_long_read(&session->stats.rx_packets), 780 L2TP_ATTR_STATS_PAD) || 781 nla_put_u64_64bit(skb, L2TP_ATTR_RX_BYTES, 782 atomic_long_read(&session->stats.rx_bytes), 783 L2TP_ATTR_STATS_PAD) || 784 nla_put_u64_64bit(skb, L2TP_ATTR_RX_SEQ_DISCARDS, 785 atomic_long_read(&session->stats.rx_seq_discards), 786 L2TP_ATTR_STATS_PAD) || 787 nla_put_u64_64bit(skb, L2TP_ATTR_RX_OOS_PACKETS, 788 atomic_long_read(&session->stats.rx_oos_packets), 789 L2TP_ATTR_STATS_PAD) || 790 nla_put_u64_64bit(skb, L2TP_ATTR_RX_ERRORS, 791 atomic_long_read(&session->stats.rx_errors), 792 L2TP_ATTR_STATS_PAD)) 793 goto nla_put_failure; 794 nla_nest_end(skb, nest); 795 796 genlmsg_end(skb, hdr); 797 return 0; 798 799 nla_put_failure: 800 genlmsg_cancel(skb, hdr); 801 return -1; 802 } 803 804 static int l2tp_nl_cmd_session_get(struct sk_buff *skb, struct genl_info *info) 805 { 806 struct l2tp_session *session; 807 struct sk_buff *msg; 808 int ret; 809 810 session = l2tp_nl_session_get(info); 811 if (session == NULL) { 812 ret = -ENODEV; 813 goto err; 814 } 815 816 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 817 if (!msg) { 818 ret = -ENOMEM; 819 goto err_ref; 820 } 821 822 ret = l2tp_nl_session_send(msg, info->snd_portid, info->snd_seq, 823 0, session, L2TP_CMD_SESSION_GET); 824 if (ret < 0) 825 goto err_ref_msg; 826 827 ret = genlmsg_unicast(genl_info_net(info), msg, info->snd_portid); 828 829 l2tp_session_dec_refcount(session); 830 831 return ret; 832 833 err_ref_msg: 834 nlmsg_free(msg); 835 err_ref: 836 l2tp_session_dec_refcount(session); 837 err: 838 return ret; 839 } 840 841 static int l2tp_nl_cmd_session_dump(struct sk_buff *skb, struct netlink_callback *cb) 842 { 843 struct net *net = sock_net(skb->sk); 844 struct l2tp_session *session; 845 struct l2tp_tunnel *tunnel = NULL; 846 int ti = cb->args[0]; 847 int si = cb->args[1]; 848 849 for (;;) { 850 if (tunnel == NULL) { 851 tunnel = l2tp_tunnel_find_nth(net, ti); 852 if (tunnel == NULL) 853 goto out; 854 } 855 856 session = l2tp_session_get_nth(tunnel, si); 857 if (session == NULL) { 858 ti++; 859 tunnel = NULL; 860 si = 0; 861 continue; 862 } 863 864 if (l2tp_nl_session_send(skb, NETLINK_CB(cb->skb).portid, 865 cb->nlh->nlmsg_seq, NLM_F_MULTI, 866 session, L2TP_CMD_SESSION_GET) < 0) { 867 l2tp_session_dec_refcount(session); 868 break; 869 } 870 l2tp_session_dec_refcount(session); 871 872 si++; 873 } 874 875 out: 876 cb->args[0] = ti; 877 cb->args[1] = si; 878 879 return skb->len; 880 } 881 882 static const struct nla_policy l2tp_nl_policy[L2TP_ATTR_MAX + 1] = { 883 [L2TP_ATTR_NONE] = { .type = NLA_UNSPEC, }, 884 [L2TP_ATTR_PW_TYPE] = { .type = NLA_U16, }, 885 [L2TP_ATTR_ENCAP_TYPE] = { .type = NLA_U16, }, 886 [L2TP_ATTR_OFFSET] = { .type = NLA_U16, }, 887 [L2TP_ATTR_DATA_SEQ] = { .type = NLA_U8, }, 888 [L2TP_ATTR_L2SPEC_TYPE] = { .type = NLA_U8, }, 889 [L2TP_ATTR_L2SPEC_LEN] = { .type = NLA_U8, }, 890 [L2TP_ATTR_PROTO_VERSION] = { .type = NLA_U8, }, 891 [L2TP_ATTR_CONN_ID] = { .type = NLA_U32, }, 892 [L2TP_ATTR_PEER_CONN_ID] = { .type = NLA_U32, }, 893 [L2TP_ATTR_SESSION_ID] = { .type = NLA_U32, }, 894 [L2TP_ATTR_PEER_SESSION_ID] = { .type = NLA_U32, }, 895 [L2TP_ATTR_UDP_CSUM] = { .type = NLA_U8, }, 896 [L2TP_ATTR_VLAN_ID] = { .type = NLA_U16, }, 897 [L2TP_ATTR_DEBUG] = { .type = NLA_U32, }, 898 [L2TP_ATTR_RECV_SEQ] = { .type = NLA_U8, }, 899 [L2TP_ATTR_SEND_SEQ] = { .type = NLA_U8, }, 900 [L2TP_ATTR_LNS_MODE] = { .type = NLA_U8, }, 901 [L2TP_ATTR_USING_IPSEC] = { .type = NLA_U8, }, 902 [L2TP_ATTR_RECV_TIMEOUT] = { .type = NLA_MSECS, }, 903 [L2TP_ATTR_FD] = { .type = NLA_U32, }, 904 [L2TP_ATTR_IP_SADDR] = { .type = NLA_U32, }, 905 [L2TP_ATTR_IP_DADDR] = { .type = NLA_U32, }, 906 [L2TP_ATTR_UDP_SPORT] = { .type = NLA_U16, }, 907 [L2TP_ATTR_UDP_DPORT] = { .type = NLA_U16, }, 908 [L2TP_ATTR_MTU] = { .type = NLA_U16, }, 909 [L2TP_ATTR_MRU] = { .type = NLA_U16, }, 910 [L2TP_ATTR_STATS] = { .type = NLA_NESTED, }, 911 [L2TP_ATTR_IP6_SADDR] = { 912 .type = NLA_BINARY, 913 .len = sizeof(struct in6_addr), 914 }, 915 [L2TP_ATTR_IP6_DADDR] = { 916 .type = NLA_BINARY, 917 .len = sizeof(struct in6_addr), 918 }, 919 [L2TP_ATTR_IFNAME] = { 920 .type = NLA_NUL_STRING, 921 .len = IFNAMSIZ - 1, 922 }, 923 [L2TP_ATTR_COOKIE] = { 924 .type = NLA_BINARY, 925 .len = 8, 926 }, 927 [L2TP_ATTR_PEER_COOKIE] = { 928 .type = NLA_BINARY, 929 .len = 8, 930 }, 931 }; 932 933 static const struct genl_ops l2tp_nl_ops[] = { 934 { 935 .cmd = L2TP_CMD_NOOP, 936 .doit = l2tp_nl_cmd_noop, 937 .policy = l2tp_nl_policy, 938 /* can be retrieved by unprivileged users */ 939 }, 940 { 941 .cmd = L2TP_CMD_TUNNEL_CREATE, 942 .doit = l2tp_nl_cmd_tunnel_create, 943 .policy = l2tp_nl_policy, 944 .flags = GENL_ADMIN_PERM, 945 }, 946 { 947 .cmd = L2TP_CMD_TUNNEL_DELETE, 948 .doit = l2tp_nl_cmd_tunnel_delete, 949 .policy = l2tp_nl_policy, 950 .flags = GENL_ADMIN_PERM, 951 }, 952 { 953 .cmd = L2TP_CMD_TUNNEL_MODIFY, 954 .doit = l2tp_nl_cmd_tunnel_modify, 955 .policy = l2tp_nl_policy, 956 .flags = GENL_ADMIN_PERM, 957 }, 958 { 959 .cmd = L2TP_CMD_TUNNEL_GET, 960 .doit = l2tp_nl_cmd_tunnel_get, 961 .dumpit = l2tp_nl_cmd_tunnel_dump, 962 .policy = l2tp_nl_policy, 963 .flags = GENL_ADMIN_PERM, 964 }, 965 { 966 .cmd = L2TP_CMD_SESSION_CREATE, 967 .doit = l2tp_nl_cmd_session_create, 968 .policy = l2tp_nl_policy, 969 .flags = GENL_ADMIN_PERM, 970 }, 971 { 972 .cmd = L2TP_CMD_SESSION_DELETE, 973 .doit = l2tp_nl_cmd_session_delete, 974 .policy = l2tp_nl_policy, 975 .flags = GENL_ADMIN_PERM, 976 }, 977 { 978 .cmd = L2TP_CMD_SESSION_MODIFY, 979 .doit = l2tp_nl_cmd_session_modify, 980 .policy = l2tp_nl_policy, 981 .flags = GENL_ADMIN_PERM, 982 }, 983 { 984 .cmd = L2TP_CMD_SESSION_GET, 985 .doit = l2tp_nl_cmd_session_get, 986 .dumpit = l2tp_nl_cmd_session_dump, 987 .policy = l2tp_nl_policy, 988 .flags = GENL_ADMIN_PERM, 989 }, 990 }; 991 992 static struct genl_family l2tp_nl_family __ro_after_init = { 993 .name = L2TP_GENL_NAME, 994 .version = L2TP_GENL_VERSION, 995 .hdrsize = 0, 996 .maxattr = L2TP_ATTR_MAX, 997 .netnsok = true, 998 .module = THIS_MODULE, 999 .ops = l2tp_nl_ops, 1000 .n_ops = ARRAY_SIZE(l2tp_nl_ops), 1001 .mcgrps = l2tp_multicast_group, 1002 .n_mcgrps = ARRAY_SIZE(l2tp_multicast_group), 1003 }; 1004 1005 int l2tp_nl_register_ops(enum l2tp_pwtype pw_type, const struct l2tp_nl_cmd_ops *ops) 1006 { 1007 int ret; 1008 1009 ret = -EINVAL; 1010 if (pw_type >= __L2TP_PWTYPE_MAX) 1011 goto err; 1012 1013 genl_lock(); 1014 ret = -EBUSY; 1015 if (l2tp_nl_cmd_ops[pw_type]) 1016 goto out; 1017 1018 l2tp_nl_cmd_ops[pw_type] = ops; 1019 ret = 0; 1020 1021 out: 1022 genl_unlock(); 1023 err: 1024 return ret; 1025 } 1026 EXPORT_SYMBOL_GPL(l2tp_nl_register_ops); 1027 1028 void l2tp_nl_unregister_ops(enum l2tp_pwtype pw_type) 1029 { 1030 if (pw_type < __L2TP_PWTYPE_MAX) { 1031 genl_lock(); 1032 l2tp_nl_cmd_ops[pw_type] = NULL; 1033 genl_unlock(); 1034 } 1035 } 1036 EXPORT_SYMBOL_GPL(l2tp_nl_unregister_ops); 1037 1038 static int __init l2tp_nl_init(void) 1039 { 1040 pr_info("L2TP netlink interface\n"); 1041 return genl_register_family(&l2tp_nl_family); 1042 } 1043 1044 static void l2tp_nl_cleanup(void) 1045 { 1046 genl_unregister_family(&l2tp_nl_family); 1047 } 1048 1049 module_init(l2tp_nl_init); 1050 module_exit(l2tp_nl_cleanup); 1051 1052 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>"); 1053 MODULE_DESCRIPTION("L2TP netlink"); 1054 MODULE_LICENSE("GPL"); 1055 MODULE_VERSION("1.0"); 1056 MODULE_ALIAS_GENL_FAMILY("l2tp"); 1057