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