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_find(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_find_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_find(net, tunnel_id); 68 if (tunnel) 69 session = l2tp_session_find(net, tunnel, session_id); 70 } 71 72 return session; 73 } 74 75 static int l2tp_nl_cmd_noop(struct sk_buff *skb, struct genl_info *info) 76 { 77 struct sk_buff *msg; 78 void *hdr; 79 int ret = -ENOBUFS; 80 81 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 82 if (!msg) { 83 ret = -ENOMEM; 84 goto out; 85 } 86 87 hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq, 88 &l2tp_nl_family, 0, L2TP_CMD_NOOP); 89 if (!hdr) { 90 ret = -EMSGSIZE; 91 goto err_out; 92 } 93 94 genlmsg_end(msg, hdr); 95 96 return genlmsg_unicast(genl_info_net(info), msg, info->snd_portid); 97 98 err_out: 99 nlmsg_free(msg); 100 101 out: 102 return ret; 103 } 104 105 static int l2tp_tunnel_notify(struct genl_family *family, 106 struct genl_info *info, 107 struct l2tp_tunnel *tunnel, 108 u8 cmd) 109 { 110 struct sk_buff *msg; 111 int ret; 112 113 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 114 if (!msg) 115 return -ENOMEM; 116 117 ret = l2tp_nl_tunnel_send(msg, info->snd_portid, info->snd_seq, 118 NLM_F_ACK, tunnel, cmd); 119 120 if (ret >= 0) { 121 ret = genlmsg_multicast_allns(family, msg, 0, 0, GFP_ATOMIC); 122 /* We don't care if no one is listening */ 123 if (ret == -ESRCH) 124 ret = 0; 125 return ret; 126 } 127 128 nlmsg_free(msg); 129 130 return ret; 131 } 132 133 static int l2tp_session_notify(struct genl_family *family, 134 struct genl_info *info, 135 struct l2tp_session *session, 136 u8 cmd) 137 { 138 struct sk_buff *msg; 139 int ret; 140 141 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 142 if (!msg) 143 return -ENOMEM; 144 145 ret = l2tp_nl_session_send(msg, info->snd_portid, info->snd_seq, 146 NLM_F_ACK, session, cmd); 147 148 if (ret >= 0) { 149 ret = genlmsg_multicast_allns(family, msg, 0, 0, GFP_ATOMIC); 150 /* We don't care if no one is listening */ 151 if (ret == -ESRCH) 152 ret = 0; 153 return ret; 154 } 155 156 nlmsg_free(msg); 157 158 return ret; 159 } 160 161 static int l2tp_nl_cmd_tunnel_create(struct sk_buff *skb, struct genl_info *info) 162 { 163 u32 tunnel_id; 164 u32 peer_tunnel_id; 165 int proto_version; 166 int fd; 167 int ret = 0; 168 struct l2tp_tunnel_cfg cfg = { 0, }; 169 struct l2tp_tunnel *tunnel; 170 struct net *net = genl_info_net(info); 171 172 if (!info->attrs[L2TP_ATTR_CONN_ID]) { 173 ret = -EINVAL; 174 goto out; 175 } 176 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 177 178 if (!info->attrs[L2TP_ATTR_PEER_CONN_ID]) { 179 ret = -EINVAL; 180 goto out; 181 } 182 peer_tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_PEER_CONN_ID]); 183 184 if (!info->attrs[L2TP_ATTR_PROTO_VERSION]) { 185 ret = -EINVAL; 186 goto out; 187 } 188 proto_version = nla_get_u8(info->attrs[L2TP_ATTR_PROTO_VERSION]); 189 190 if (!info->attrs[L2TP_ATTR_ENCAP_TYPE]) { 191 ret = -EINVAL; 192 goto out; 193 } 194 cfg.encap = nla_get_u16(info->attrs[L2TP_ATTR_ENCAP_TYPE]); 195 196 fd = -1; 197 if (info->attrs[L2TP_ATTR_FD]) { 198 fd = nla_get_u32(info->attrs[L2TP_ATTR_FD]); 199 } else { 200 #if IS_ENABLED(CONFIG_IPV6) 201 if (info->attrs[L2TP_ATTR_IP6_SADDR] && 202 info->attrs[L2TP_ATTR_IP6_DADDR]) { 203 cfg.local_ip6 = nla_data( 204 info->attrs[L2TP_ATTR_IP6_SADDR]); 205 cfg.peer_ip6 = nla_data( 206 info->attrs[L2TP_ATTR_IP6_DADDR]); 207 } else 208 #endif 209 if (info->attrs[L2TP_ATTR_IP_SADDR] && 210 info->attrs[L2TP_ATTR_IP_DADDR]) { 211 cfg.local_ip.s_addr = nla_get_in_addr( 212 info->attrs[L2TP_ATTR_IP_SADDR]); 213 cfg.peer_ip.s_addr = nla_get_in_addr( 214 info->attrs[L2TP_ATTR_IP_DADDR]); 215 } else { 216 ret = -EINVAL; 217 goto out; 218 } 219 if (info->attrs[L2TP_ATTR_UDP_SPORT]) 220 cfg.local_udp_port = nla_get_u16(info->attrs[L2TP_ATTR_UDP_SPORT]); 221 if (info->attrs[L2TP_ATTR_UDP_DPORT]) 222 cfg.peer_udp_port = nla_get_u16(info->attrs[L2TP_ATTR_UDP_DPORT]); 223 cfg.use_udp_checksums = nla_get_flag( 224 info->attrs[L2TP_ATTR_UDP_CSUM]); 225 226 #if IS_ENABLED(CONFIG_IPV6) 227 cfg.udp6_zero_tx_checksums = nla_get_flag( 228 info->attrs[L2TP_ATTR_UDP_ZERO_CSUM6_TX]); 229 cfg.udp6_zero_rx_checksums = nla_get_flag( 230 info->attrs[L2TP_ATTR_UDP_ZERO_CSUM6_RX]); 231 #endif 232 } 233 234 if (info->attrs[L2TP_ATTR_DEBUG]) 235 cfg.debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]); 236 237 tunnel = l2tp_tunnel_find(net, tunnel_id); 238 if (tunnel != NULL) { 239 ret = -EEXIST; 240 goto out; 241 } 242 243 ret = -EINVAL; 244 switch (cfg.encap) { 245 case L2TP_ENCAPTYPE_UDP: 246 case L2TP_ENCAPTYPE_IP: 247 ret = l2tp_tunnel_create(net, fd, proto_version, tunnel_id, 248 peer_tunnel_id, &cfg, &tunnel); 249 break; 250 } 251 252 if (ret >= 0) 253 ret = l2tp_tunnel_notify(&l2tp_nl_family, info, 254 tunnel, L2TP_CMD_TUNNEL_CREATE); 255 out: 256 return ret; 257 } 258 259 static int l2tp_nl_cmd_tunnel_delete(struct sk_buff *skb, struct genl_info *info) 260 { 261 struct l2tp_tunnel *tunnel; 262 u32 tunnel_id; 263 int ret = 0; 264 struct net *net = genl_info_net(info); 265 266 if (!info->attrs[L2TP_ATTR_CONN_ID]) { 267 ret = -EINVAL; 268 goto out; 269 } 270 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 271 272 tunnel = l2tp_tunnel_find(net, tunnel_id); 273 if (tunnel == NULL) { 274 ret = -ENODEV; 275 goto out; 276 } 277 278 l2tp_tunnel_notify(&l2tp_nl_family, info, 279 tunnel, L2TP_CMD_TUNNEL_DELETE); 280 281 (void) l2tp_tunnel_delete(tunnel); 282 283 out: 284 return ret; 285 } 286 287 static int l2tp_nl_cmd_tunnel_modify(struct sk_buff *skb, struct genl_info *info) 288 { 289 struct l2tp_tunnel *tunnel; 290 u32 tunnel_id; 291 int ret = 0; 292 struct net *net = genl_info_net(info); 293 294 if (!info->attrs[L2TP_ATTR_CONN_ID]) { 295 ret = -EINVAL; 296 goto out; 297 } 298 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 299 300 tunnel = l2tp_tunnel_find(net, tunnel_id); 301 if (tunnel == NULL) { 302 ret = -ENODEV; 303 goto out; 304 } 305 306 if (info->attrs[L2TP_ATTR_DEBUG]) 307 tunnel->debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]); 308 309 ret = l2tp_tunnel_notify(&l2tp_nl_family, info, 310 tunnel, L2TP_CMD_TUNNEL_MODIFY); 311 312 out: 313 return ret; 314 } 315 316 static int l2tp_nl_tunnel_send(struct sk_buff *skb, u32 portid, u32 seq, int flags, 317 struct l2tp_tunnel *tunnel, u8 cmd) 318 { 319 void *hdr; 320 struct nlattr *nest; 321 struct sock *sk = NULL; 322 struct inet_sock *inet; 323 #if IS_ENABLED(CONFIG_IPV6) 324 struct ipv6_pinfo *np = NULL; 325 #endif 326 327 hdr = genlmsg_put(skb, portid, seq, &l2tp_nl_family, flags, cmd); 328 if (!hdr) 329 return -EMSGSIZE; 330 331 if (nla_put_u8(skb, L2TP_ATTR_PROTO_VERSION, tunnel->version) || 332 nla_put_u32(skb, L2TP_ATTR_CONN_ID, tunnel->tunnel_id) || 333 nla_put_u32(skb, L2TP_ATTR_PEER_CONN_ID, tunnel->peer_tunnel_id) || 334 nla_put_u32(skb, L2TP_ATTR_DEBUG, tunnel->debug) || 335 nla_put_u16(skb, L2TP_ATTR_ENCAP_TYPE, tunnel->encap)) 336 goto nla_put_failure; 337 338 nest = nla_nest_start(skb, L2TP_ATTR_STATS); 339 if (nest == NULL) 340 goto nla_put_failure; 341 342 if (nla_put_u64_64bit(skb, L2TP_ATTR_TX_PACKETS, 343 atomic_long_read(&tunnel->stats.tx_packets), 344 L2TP_ATTR_STATS_PAD) || 345 nla_put_u64_64bit(skb, L2TP_ATTR_TX_BYTES, 346 atomic_long_read(&tunnel->stats.tx_bytes), 347 L2TP_ATTR_STATS_PAD) || 348 nla_put_u64_64bit(skb, L2TP_ATTR_TX_ERRORS, 349 atomic_long_read(&tunnel->stats.tx_errors), 350 L2TP_ATTR_STATS_PAD) || 351 nla_put_u64_64bit(skb, L2TP_ATTR_RX_PACKETS, 352 atomic_long_read(&tunnel->stats.rx_packets), 353 L2TP_ATTR_STATS_PAD) || 354 nla_put_u64_64bit(skb, L2TP_ATTR_RX_BYTES, 355 atomic_long_read(&tunnel->stats.rx_bytes), 356 L2TP_ATTR_STATS_PAD) || 357 nla_put_u64_64bit(skb, L2TP_ATTR_RX_SEQ_DISCARDS, 358 atomic_long_read(&tunnel->stats.rx_seq_discards), 359 L2TP_ATTR_STATS_PAD) || 360 nla_put_u64_64bit(skb, L2TP_ATTR_RX_OOS_PACKETS, 361 atomic_long_read(&tunnel->stats.rx_oos_packets), 362 L2TP_ATTR_STATS_PAD) || 363 nla_put_u64_64bit(skb, L2TP_ATTR_RX_ERRORS, 364 atomic_long_read(&tunnel->stats.rx_errors), 365 L2TP_ATTR_STATS_PAD)) 366 goto nla_put_failure; 367 nla_nest_end(skb, nest); 368 369 sk = tunnel->sock; 370 if (!sk) 371 goto out; 372 373 #if IS_ENABLED(CONFIG_IPV6) 374 if (sk->sk_family == AF_INET6) 375 np = inet6_sk(sk); 376 #endif 377 378 inet = inet_sk(sk); 379 380 switch (tunnel->encap) { 381 case L2TP_ENCAPTYPE_UDP: 382 switch (sk->sk_family) { 383 case AF_INET: 384 if (nla_put_u8(skb, L2TP_ATTR_UDP_CSUM, !sk->sk_no_check_tx)) 385 goto nla_put_failure; 386 break; 387 #if IS_ENABLED(CONFIG_IPV6) 388 case AF_INET6: 389 if (udp_get_no_check6_tx(sk) && 390 nla_put_flag(skb, L2TP_ATTR_UDP_ZERO_CSUM6_TX)) 391 goto nla_put_failure; 392 if (udp_get_no_check6_rx(sk) && 393 nla_put_flag(skb, L2TP_ATTR_UDP_ZERO_CSUM6_RX)) 394 goto nla_put_failure; 395 break; 396 #endif 397 } 398 if (nla_put_u16(skb, L2TP_ATTR_UDP_SPORT, ntohs(inet->inet_sport)) || 399 nla_put_u16(skb, L2TP_ATTR_UDP_DPORT, ntohs(inet->inet_dport))) 400 goto nla_put_failure; 401 /* NOBREAK */ 402 case L2TP_ENCAPTYPE_IP: 403 #if IS_ENABLED(CONFIG_IPV6) 404 if (np) { 405 if (nla_put_in6_addr(skb, L2TP_ATTR_IP6_SADDR, 406 &np->saddr) || 407 nla_put_in6_addr(skb, L2TP_ATTR_IP6_DADDR, 408 &sk->sk_v6_daddr)) 409 goto nla_put_failure; 410 } else 411 #endif 412 if (nla_put_in_addr(skb, L2TP_ATTR_IP_SADDR, 413 inet->inet_saddr) || 414 nla_put_in_addr(skb, L2TP_ATTR_IP_DADDR, 415 inet->inet_daddr)) 416 goto nla_put_failure; 417 break; 418 } 419 420 out: 421 genlmsg_end(skb, hdr); 422 return 0; 423 424 nla_put_failure: 425 genlmsg_cancel(skb, hdr); 426 return -1; 427 } 428 429 static int l2tp_nl_cmd_tunnel_get(struct sk_buff *skb, struct genl_info *info) 430 { 431 struct l2tp_tunnel *tunnel; 432 struct sk_buff *msg; 433 u32 tunnel_id; 434 int ret = -ENOBUFS; 435 struct net *net = genl_info_net(info); 436 437 if (!info->attrs[L2TP_ATTR_CONN_ID]) { 438 ret = -EINVAL; 439 goto out; 440 } 441 442 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 443 444 tunnel = l2tp_tunnel_find(net, tunnel_id); 445 if (tunnel == NULL) { 446 ret = -ENODEV; 447 goto out; 448 } 449 450 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 451 if (!msg) { 452 ret = -ENOMEM; 453 goto out; 454 } 455 456 ret = l2tp_nl_tunnel_send(msg, info->snd_portid, info->snd_seq, 457 NLM_F_ACK, tunnel, L2TP_CMD_TUNNEL_GET); 458 if (ret < 0) 459 goto err_out; 460 461 return genlmsg_unicast(net, msg, info->snd_portid); 462 463 err_out: 464 nlmsg_free(msg); 465 466 out: 467 return ret; 468 } 469 470 static int l2tp_nl_cmd_tunnel_dump(struct sk_buff *skb, struct netlink_callback *cb) 471 { 472 int ti = cb->args[0]; 473 struct l2tp_tunnel *tunnel; 474 struct net *net = sock_net(skb->sk); 475 476 for (;;) { 477 tunnel = l2tp_tunnel_find_nth(net, ti); 478 if (tunnel == NULL) 479 goto out; 480 481 if (l2tp_nl_tunnel_send(skb, NETLINK_CB(cb->skb).portid, 482 cb->nlh->nlmsg_seq, NLM_F_MULTI, 483 tunnel, L2TP_CMD_TUNNEL_GET) < 0) 484 goto out; 485 486 ti++; 487 } 488 489 out: 490 cb->args[0] = ti; 491 492 return skb->len; 493 } 494 495 static int l2tp_nl_cmd_session_create(struct sk_buff *skb, struct genl_info *info) 496 { 497 u32 tunnel_id = 0; 498 u32 session_id; 499 u32 peer_session_id; 500 int ret = 0; 501 struct l2tp_tunnel *tunnel; 502 struct l2tp_session *session; 503 struct l2tp_session_cfg cfg = { 0, }; 504 struct net *net = genl_info_net(info); 505 506 if (!info->attrs[L2TP_ATTR_CONN_ID]) { 507 ret = -EINVAL; 508 goto out; 509 } 510 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 511 tunnel = l2tp_tunnel_find(net, tunnel_id); 512 if (!tunnel) { 513 ret = -ENODEV; 514 goto out; 515 } 516 517 if (!info->attrs[L2TP_ATTR_SESSION_ID]) { 518 ret = -EINVAL; 519 goto out; 520 } 521 session_id = nla_get_u32(info->attrs[L2TP_ATTR_SESSION_ID]); 522 session = l2tp_session_find(net, tunnel, session_id); 523 if (session) { 524 ret = -EEXIST; 525 goto out; 526 } 527 528 if (!info->attrs[L2TP_ATTR_PEER_SESSION_ID]) { 529 ret = -EINVAL; 530 goto out; 531 } 532 peer_session_id = nla_get_u32(info->attrs[L2TP_ATTR_PEER_SESSION_ID]); 533 534 if (!info->attrs[L2TP_ATTR_PW_TYPE]) { 535 ret = -EINVAL; 536 goto out; 537 } 538 cfg.pw_type = nla_get_u16(info->attrs[L2TP_ATTR_PW_TYPE]); 539 if (cfg.pw_type >= __L2TP_PWTYPE_MAX) { 540 ret = -EINVAL; 541 goto out; 542 } 543 544 if (tunnel->version > 2) { 545 if (info->attrs[L2TP_ATTR_OFFSET]) 546 cfg.offset = nla_get_u16(info->attrs[L2TP_ATTR_OFFSET]); 547 548 if (info->attrs[L2TP_ATTR_DATA_SEQ]) 549 cfg.data_seq = nla_get_u8(info->attrs[L2TP_ATTR_DATA_SEQ]); 550 551 cfg.l2specific_type = L2TP_L2SPECTYPE_DEFAULT; 552 if (info->attrs[L2TP_ATTR_L2SPEC_TYPE]) 553 cfg.l2specific_type = nla_get_u8(info->attrs[L2TP_ATTR_L2SPEC_TYPE]); 554 555 cfg.l2specific_len = 4; 556 if (info->attrs[L2TP_ATTR_L2SPEC_LEN]) 557 cfg.l2specific_len = nla_get_u8(info->attrs[L2TP_ATTR_L2SPEC_LEN]); 558 559 if (info->attrs[L2TP_ATTR_COOKIE]) { 560 u16 len = nla_len(info->attrs[L2TP_ATTR_COOKIE]); 561 if (len > 8) { 562 ret = -EINVAL; 563 goto out; 564 } 565 cfg.cookie_len = len; 566 memcpy(&cfg.cookie[0], nla_data(info->attrs[L2TP_ATTR_COOKIE]), len); 567 } 568 if (info->attrs[L2TP_ATTR_PEER_COOKIE]) { 569 u16 len = nla_len(info->attrs[L2TP_ATTR_PEER_COOKIE]); 570 if (len > 8) { 571 ret = -EINVAL; 572 goto out; 573 } 574 cfg.peer_cookie_len = len; 575 memcpy(&cfg.peer_cookie[0], nla_data(info->attrs[L2TP_ATTR_PEER_COOKIE]), len); 576 } 577 if (info->attrs[L2TP_ATTR_IFNAME]) 578 cfg.ifname = nla_data(info->attrs[L2TP_ATTR_IFNAME]); 579 580 if (info->attrs[L2TP_ATTR_VLAN_ID]) 581 cfg.vlan_id = nla_get_u16(info->attrs[L2TP_ATTR_VLAN_ID]); 582 } 583 584 if (info->attrs[L2TP_ATTR_DEBUG]) 585 cfg.debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]); 586 587 if (info->attrs[L2TP_ATTR_RECV_SEQ]) 588 cfg.recv_seq = nla_get_u8(info->attrs[L2TP_ATTR_RECV_SEQ]); 589 590 if (info->attrs[L2TP_ATTR_SEND_SEQ]) 591 cfg.send_seq = nla_get_u8(info->attrs[L2TP_ATTR_SEND_SEQ]); 592 593 if (info->attrs[L2TP_ATTR_LNS_MODE]) 594 cfg.lns_mode = nla_get_u8(info->attrs[L2TP_ATTR_LNS_MODE]); 595 596 if (info->attrs[L2TP_ATTR_RECV_TIMEOUT]) 597 cfg.reorder_timeout = nla_get_msecs(info->attrs[L2TP_ATTR_RECV_TIMEOUT]); 598 599 if (info->attrs[L2TP_ATTR_MTU]) 600 cfg.mtu = nla_get_u16(info->attrs[L2TP_ATTR_MTU]); 601 602 if (info->attrs[L2TP_ATTR_MRU]) 603 cfg.mru = nla_get_u16(info->attrs[L2TP_ATTR_MRU]); 604 605 #ifdef CONFIG_MODULES 606 if (l2tp_nl_cmd_ops[cfg.pw_type] == NULL) { 607 genl_unlock(); 608 request_module("net-l2tp-type-%u", cfg.pw_type); 609 genl_lock(); 610 } 611 #endif 612 if ((l2tp_nl_cmd_ops[cfg.pw_type] == NULL) || 613 (l2tp_nl_cmd_ops[cfg.pw_type]->session_create == NULL)) { 614 ret = -EPROTONOSUPPORT; 615 goto out; 616 } 617 618 /* Check that pseudowire-specific params are present */ 619 switch (cfg.pw_type) { 620 case L2TP_PWTYPE_NONE: 621 break; 622 case L2TP_PWTYPE_ETH_VLAN: 623 if (!info->attrs[L2TP_ATTR_VLAN_ID]) { 624 ret = -EINVAL; 625 goto out; 626 } 627 break; 628 case L2TP_PWTYPE_ETH: 629 break; 630 case L2TP_PWTYPE_PPP: 631 case L2TP_PWTYPE_PPP_AC: 632 break; 633 case L2TP_PWTYPE_IP: 634 default: 635 ret = -EPROTONOSUPPORT; 636 break; 637 } 638 639 ret = -EPROTONOSUPPORT; 640 if (l2tp_nl_cmd_ops[cfg.pw_type]->session_create) 641 ret = (*l2tp_nl_cmd_ops[cfg.pw_type]->session_create)(net, tunnel_id, 642 session_id, peer_session_id, &cfg); 643 644 if (ret >= 0) { 645 session = l2tp_session_find(net, tunnel, session_id); 646 if (session) 647 ret = l2tp_session_notify(&l2tp_nl_family, info, session, 648 L2TP_CMD_SESSION_CREATE); 649 } 650 651 out: 652 return ret; 653 } 654 655 static int l2tp_nl_cmd_session_delete(struct sk_buff *skb, struct genl_info *info) 656 { 657 int ret = 0; 658 struct l2tp_session *session; 659 u16 pw_type; 660 661 session = l2tp_nl_session_find(info); 662 if (session == NULL) { 663 ret = -ENODEV; 664 goto out; 665 } 666 667 l2tp_session_notify(&l2tp_nl_family, info, 668 session, L2TP_CMD_SESSION_DELETE); 669 670 pw_type = session->pwtype; 671 if (pw_type < __L2TP_PWTYPE_MAX) 672 if (l2tp_nl_cmd_ops[pw_type] && l2tp_nl_cmd_ops[pw_type]->session_delete) 673 ret = (*l2tp_nl_cmd_ops[pw_type]->session_delete)(session); 674 675 out: 676 return ret; 677 } 678 679 static int l2tp_nl_cmd_session_modify(struct sk_buff *skb, struct genl_info *info) 680 { 681 int ret = 0; 682 struct l2tp_session *session; 683 684 session = l2tp_nl_session_find(info); 685 if (session == NULL) { 686 ret = -ENODEV; 687 goto out; 688 } 689 690 if (info->attrs[L2TP_ATTR_DEBUG]) 691 session->debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]); 692 693 if (info->attrs[L2TP_ATTR_DATA_SEQ]) 694 session->data_seq = nla_get_u8(info->attrs[L2TP_ATTR_DATA_SEQ]); 695 696 if (info->attrs[L2TP_ATTR_RECV_SEQ]) 697 session->recv_seq = nla_get_u8(info->attrs[L2TP_ATTR_RECV_SEQ]); 698 699 if (info->attrs[L2TP_ATTR_SEND_SEQ]) { 700 session->send_seq = nla_get_u8(info->attrs[L2TP_ATTR_SEND_SEQ]); 701 l2tp_session_set_header_len(session, session->tunnel->version); 702 } 703 704 if (info->attrs[L2TP_ATTR_LNS_MODE]) 705 session->lns_mode = nla_get_u8(info->attrs[L2TP_ATTR_LNS_MODE]); 706 707 if (info->attrs[L2TP_ATTR_RECV_TIMEOUT]) 708 session->reorder_timeout = nla_get_msecs(info->attrs[L2TP_ATTR_RECV_TIMEOUT]); 709 710 if (info->attrs[L2TP_ATTR_MTU]) 711 session->mtu = nla_get_u16(info->attrs[L2TP_ATTR_MTU]); 712 713 if (info->attrs[L2TP_ATTR_MRU]) 714 session->mru = nla_get_u16(info->attrs[L2TP_ATTR_MRU]); 715 716 ret = l2tp_session_notify(&l2tp_nl_family, info, 717 session, L2TP_CMD_SESSION_MODIFY); 718 719 out: 720 return ret; 721 } 722 723 static int l2tp_nl_session_send(struct sk_buff *skb, u32 portid, u32 seq, int flags, 724 struct l2tp_session *session, u8 cmd) 725 { 726 void *hdr; 727 struct nlattr *nest; 728 struct l2tp_tunnel *tunnel = session->tunnel; 729 struct sock *sk = NULL; 730 731 sk = tunnel->sock; 732 733 hdr = genlmsg_put(skb, portid, seq, &l2tp_nl_family, flags, cmd); 734 if (!hdr) 735 return -EMSGSIZE; 736 737 if (nla_put_u32(skb, L2TP_ATTR_CONN_ID, tunnel->tunnel_id) || 738 nla_put_u32(skb, L2TP_ATTR_SESSION_ID, session->session_id) || 739 nla_put_u32(skb, L2TP_ATTR_PEER_CONN_ID, tunnel->peer_tunnel_id) || 740 nla_put_u32(skb, L2TP_ATTR_PEER_SESSION_ID, 741 session->peer_session_id) || 742 nla_put_u32(skb, L2TP_ATTR_DEBUG, session->debug) || 743 nla_put_u16(skb, L2TP_ATTR_PW_TYPE, session->pwtype) || 744 nla_put_u16(skb, L2TP_ATTR_MTU, session->mtu) || 745 (session->mru && 746 nla_put_u16(skb, L2TP_ATTR_MRU, session->mru))) 747 goto nla_put_failure; 748 749 if ((session->ifname[0] && 750 nla_put_string(skb, L2TP_ATTR_IFNAME, session->ifname)) || 751 (session->cookie_len && 752 nla_put(skb, L2TP_ATTR_COOKIE, session->cookie_len, 753 &session->cookie[0])) || 754 (session->peer_cookie_len && 755 nla_put(skb, L2TP_ATTR_PEER_COOKIE, session->peer_cookie_len, 756 &session->peer_cookie[0])) || 757 nla_put_u8(skb, L2TP_ATTR_RECV_SEQ, session->recv_seq) || 758 nla_put_u8(skb, L2TP_ATTR_SEND_SEQ, session->send_seq) || 759 nla_put_u8(skb, L2TP_ATTR_LNS_MODE, session->lns_mode) || 760 #ifdef CONFIG_XFRM 761 (((sk) && (sk->sk_policy[0] || sk->sk_policy[1])) && 762 nla_put_u8(skb, L2TP_ATTR_USING_IPSEC, 1)) || 763 #endif 764 (session->reorder_timeout && 765 nla_put_msecs(skb, L2TP_ATTR_RECV_TIMEOUT, 766 session->reorder_timeout, L2TP_ATTR_PAD))) 767 goto nla_put_failure; 768 769 nest = nla_nest_start(skb, L2TP_ATTR_STATS); 770 if (nest == NULL) 771 goto nla_put_failure; 772 773 if (nla_put_u64_64bit(skb, L2TP_ATTR_TX_PACKETS, 774 atomic_long_read(&session->stats.tx_packets), 775 L2TP_ATTR_STATS_PAD) || 776 nla_put_u64_64bit(skb, L2TP_ATTR_TX_BYTES, 777 atomic_long_read(&session->stats.tx_bytes), 778 L2TP_ATTR_STATS_PAD) || 779 nla_put_u64_64bit(skb, L2TP_ATTR_TX_ERRORS, 780 atomic_long_read(&session->stats.tx_errors), 781 L2TP_ATTR_STATS_PAD) || 782 nla_put_u64_64bit(skb, L2TP_ATTR_RX_PACKETS, 783 atomic_long_read(&session->stats.rx_packets), 784 L2TP_ATTR_STATS_PAD) || 785 nla_put_u64_64bit(skb, L2TP_ATTR_RX_BYTES, 786 atomic_long_read(&session->stats.rx_bytes), 787 L2TP_ATTR_STATS_PAD) || 788 nla_put_u64_64bit(skb, L2TP_ATTR_RX_SEQ_DISCARDS, 789 atomic_long_read(&session->stats.rx_seq_discards), 790 L2TP_ATTR_STATS_PAD) || 791 nla_put_u64_64bit(skb, L2TP_ATTR_RX_OOS_PACKETS, 792 atomic_long_read(&session->stats.rx_oos_packets), 793 L2TP_ATTR_STATS_PAD) || 794 nla_put_u64_64bit(skb, L2TP_ATTR_RX_ERRORS, 795 atomic_long_read(&session->stats.rx_errors), 796 L2TP_ATTR_STATS_PAD)) 797 goto nla_put_failure; 798 nla_nest_end(skb, nest); 799 800 genlmsg_end(skb, hdr); 801 return 0; 802 803 nla_put_failure: 804 genlmsg_cancel(skb, hdr); 805 return -1; 806 } 807 808 static int l2tp_nl_cmd_session_get(struct sk_buff *skb, struct genl_info *info) 809 { 810 struct l2tp_session *session; 811 struct sk_buff *msg; 812 int ret; 813 814 session = l2tp_nl_session_find(info); 815 if (session == NULL) { 816 ret = -ENODEV; 817 goto out; 818 } 819 820 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 821 if (!msg) { 822 ret = -ENOMEM; 823 goto out; 824 } 825 826 ret = l2tp_nl_session_send(msg, info->snd_portid, info->snd_seq, 827 0, session, L2TP_CMD_SESSION_GET); 828 if (ret < 0) 829 goto err_out; 830 831 return genlmsg_unicast(genl_info_net(info), msg, info->snd_portid); 832 833 err_out: 834 nlmsg_free(msg); 835 836 out: 837 return ret; 838 } 839 840 static int l2tp_nl_cmd_session_dump(struct sk_buff *skb, struct netlink_callback *cb) 841 { 842 struct net *net = sock_net(skb->sk); 843 struct l2tp_session *session; 844 struct l2tp_tunnel *tunnel = NULL; 845 int ti = cb->args[0]; 846 int si = cb->args[1]; 847 848 for (;;) { 849 if (tunnel == NULL) { 850 tunnel = l2tp_tunnel_find_nth(net, ti); 851 if (tunnel == NULL) 852 goto out; 853 } 854 855 session = l2tp_session_find_nth(tunnel, si); 856 if (session == NULL) { 857 ti++; 858 tunnel = NULL; 859 si = 0; 860 continue; 861 } 862 863 if (l2tp_nl_session_send(skb, NETLINK_CB(cb->skb).portid, 864 cb->nlh->nlmsg_seq, NLM_F_MULTI, 865 session, L2TP_CMD_SESSION_GET) < 0) 866 break; 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