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 ret = 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 ret = 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 ret = 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 struct l2tp_tunnel *tunnel = session->tunnel; 705 706 session->send_seq = nla_get_u8(info->attrs[L2TP_ATTR_SEND_SEQ]); 707 l2tp_session_set_header_len(session, tunnel->version, tunnel->encap); 708 } 709 710 if (info->attrs[L2TP_ATTR_LNS_MODE]) 711 session->lns_mode = nla_get_u8(info->attrs[L2TP_ATTR_LNS_MODE]); 712 713 if (info->attrs[L2TP_ATTR_RECV_TIMEOUT]) 714 session->reorder_timeout = nla_get_msecs(info->attrs[L2TP_ATTR_RECV_TIMEOUT]); 715 716 ret = l2tp_session_notify(&l2tp_nl_family, info, 717 session, L2TP_CMD_SESSION_MODIFY); 718 719 l2tp_session_put(session); 720 721 out: 722 return ret; 723 } 724 725 static int l2tp_nl_session_send(struct sk_buff *skb, u32 portid, u32 seq, int flags, 726 struct l2tp_session *session, u8 cmd) 727 { 728 void *hdr; 729 struct nlattr *nest; 730 struct l2tp_tunnel *tunnel = session->tunnel; 731 732 hdr = genlmsg_put(skb, portid, seq, &l2tp_nl_family, flags, cmd); 733 if (!hdr) 734 return -EMSGSIZE; 735 736 if (nla_put_u32(skb, L2TP_ATTR_CONN_ID, tunnel->tunnel_id) || 737 nla_put_u32(skb, L2TP_ATTR_SESSION_ID, session->session_id) || 738 nla_put_u32(skb, L2TP_ATTR_PEER_CONN_ID, tunnel->peer_tunnel_id) || 739 nla_put_u32(skb, L2TP_ATTR_PEER_SESSION_ID, session->peer_session_id) || 740 nla_put_u32(skb, L2TP_ATTR_DEBUG, 0) || 741 nla_put_u16(skb, L2TP_ATTR_PW_TYPE, session->pwtype)) 742 goto nla_put_failure; 743 744 if ((session->ifname[0] && 745 nla_put_string(skb, L2TP_ATTR_IFNAME, session->ifname)) || 746 (session->cookie_len && 747 nla_put(skb, L2TP_ATTR_COOKIE, session->cookie_len, session->cookie)) || 748 (session->peer_cookie_len && 749 nla_put(skb, L2TP_ATTR_PEER_COOKIE, session->peer_cookie_len, session->peer_cookie)) || 750 nla_put_u8(skb, L2TP_ATTR_RECV_SEQ, session->recv_seq) || 751 nla_put_u8(skb, L2TP_ATTR_SEND_SEQ, session->send_seq) || 752 nla_put_u8(skb, L2TP_ATTR_LNS_MODE, session->lns_mode) || 753 (l2tp_tunnel_uses_xfrm(tunnel) && 754 nla_put_u8(skb, L2TP_ATTR_USING_IPSEC, 1)) || 755 (session->reorder_timeout && 756 nla_put_msecs(skb, L2TP_ATTR_RECV_TIMEOUT, 757 session->reorder_timeout, L2TP_ATTR_PAD))) 758 goto nla_put_failure; 759 760 nest = nla_nest_start_noflag(skb, L2TP_ATTR_STATS); 761 if (!nest) 762 goto nla_put_failure; 763 764 if (nla_put_u64_64bit(skb, L2TP_ATTR_TX_PACKETS, 765 atomic_long_read(&session->stats.tx_packets), 766 L2TP_ATTR_STATS_PAD) || 767 nla_put_u64_64bit(skb, L2TP_ATTR_TX_BYTES, 768 atomic_long_read(&session->stats.tx_bytes), 769 L2TP_ATTR_STATS_PAD) || 770 nla_put_u64_64bit(skb, L2TP_ATTR_TX_ERRORS, 771 atomic_long_read(&session->stats.tx_errors), 772 L2TP_ATTR_STATS_PAD) || 773 nla_put_u64_64bit(skb, L2TP_ATTR_RX_PACKETS, 774 atomic_long_read(&session->stats.rx_packets), 775 L2TP_ATTR_STATS_PAD) || 776 nla_put_u64_64bit(skb, L2TP_ATTR_RX_BYTES, 777 atomic_long_read(&session->stats.rx_bytes), 778 L2TP_ATTR_STATS_PAD) || 779 nla_put_u64_64bit(skb, L2TP_ATTR_RX_SEQ_DISCARDS, 780 atomic_long_read(&session->stats.rx_seq_discards), 781 L2TP_ATTR_STATS_PAD) || 782 nla_put_u64_64bit(skb, L2TP_ATTR_RX_COOKIE_DISCARDS, 783 atomic_long_read(&session->stats.rx_cookie_discards), 784 L2TP_ATTR_STATS_PAD) || 785 nla_put_u64_64bit(skb, L2TP_ATTR_RX_OOS_PACKETS, 786 atomic_long_read(&session->stats.rx_oos_packets), 787 L2TP_ATTR_STATS_PAD) || 788 nla_put_u64_64bit(skb, L2TP_ATTR_RX_ERRORS, 789 atomic_long_read(&session->stats.rx_errors), 790 L2TP_ATTR_STATS_PAD) || 791 nla_put_u64_64bit(skb, L2TP_ATTR_RX_INVALID, 792 atomic_long_read(&session->stats.rx_invalid), 793 L2TP_ATTR_STATS_PAD)) 794 goto nla_put_failure; 795 nla_nest_end(skb, nest); 796 797 genlmsg_end(skb, hdr); 798 return 0; 799 800 nla_put_failure: 801 genlmsg_cancel(skb, hdr); 802 return -1; 803 } 804 805 static int l2tp_nl_cmd_session_get(struct sk_buff *skb, struct genl_info *info) 806 { 807 struct l2tp_session *session; 808 struct sk_buff *msg; 809 int ret; 810 811 session = l2tp_nl_session_get(info); 812 if (!session) { 813 ret = -ENODEV; 814 goto err; 815 } 816 817 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 818 if (!msg) { 819 ret = -ENOMEM; 820 goto err_ref; 821 } 822 823 ret = l2tp_nl_session_send(msg, info->snd_portid, info->snd_seq, 824 0, session, L2TP_CMD_SESSION_GET); 825 if (ret < 0) 826 goto err_ref_msg; 827 828 ret = genlmsg_unicast(genl_info_net(info), msg, info->snd_portid); 829 830 l2tp_session_put(session); 831 832 return ret; 833 834 err_ref_msg: 835 nlmsg_free(msg); 836 err_ref: 837 l2tp_session_put(session); 838 err: 839 return ret; 840 } 841 842 static int l2tp_nl_cmd_session_dump(struct sk_buff *skb, struct netlink_callback *cb) 843 { 844 struct l2tp_nl_cb_data *cbd = (void *)&cb->ctx[0]; 845 struct net *net = sock_net(skb->sk); 846 struct l2tp_session *session; 847 struct l2tp_tunnel *tunnel = NULL; 848 unsigned long tkey = cbd->tkey; 849 unsigned long skey = cbd->skey; 850 851 for (;;) { 852 if (!tunnel) { 853 tunnel = l2tp_tunnel_get_next(net, &tkey); 854 if (!tunnel) 855 goto out; 856 } 857 858 session = l2tp_session_get_next(net, tunnel->sock, tunnel->version, 859 tunnel->tunnel_id, &skey); 860 if (!session) { 861 tkey++; 862 l2tp_tunnel_put(tunnel); 863 tunnel = NULL; 864 skey = 0; 865 continue; 866 } 867 868 if (l2tp_nl_session_send(skb, NETLINK_CB(cb->skb).portid, 869 cb->nlh->nlmsg_seq, NLM_F_MULTI, 870 session, L2TP_CMD_SESSION_GET) < 0) { 871 l2tp_session_put(session); 872 l2tp_tunnel_put(tunnel); 873 break; 874 } 875 l2tp_session_put(session); 876 877 skey++; 878 } 879 880 out: 881 cbd->tkey = tkey; 882 cbd->skey = skey; 883 884 return skb->len; 885 } 886 887 static const struct nla_policy l2tp_nl_policy[L2TP_ATTR_MAX + 1] = { 888 [L2TP_ATTR_NONE] = { .type = NLA_UNSPEC, }, 889 [L2TP_ATTR_PW_TYPE] = { .type = NLA_U16, }, 890 [L2TP_ATTR_ENCAP_TYPE] = { .type = NLA_U16, }, 891 [L2TP_ATTR_OFFSET] = { .type = NLA_U16, }, 892 [L2TP_ATTR_DATA_SEQ] = { .type = NLA_U8, }, 893 [L2TP_ATTR_L2SPEC_TYPE] = { .type = NLA_U8, }, 894 [L2TP_ATTR_L2SPEC_LEN] = { .type = NLA_U8, }, 895 [L2TP_ATTR_PROTO_VERSION] = { .type = NLA_U8, }, 896 [L2TP_ATTR_CONN_ID] = { .type = NLA_U32, }, 897 [L2TP_ATTR_PEER_CONN_ID] = { .type = NLA_U32, }, 898 [L2TP_ATTR_SESSION_ID] = { .type = NLA_U32, }, 899 [L2TP_ATTR_PEER_SESSION_ID] = { .type = NLA_U32, }, 900 [L2TP_ATTR_UDP_CSUM] = { .type = NLA_U8, }, 901 [L2TP_ATTR_VLAN_ID] = { .type = NLA_U16, }, 902 [L2TP_ATTR_DEBUG] = { .type = NLA_U32, }, 903 [L2TP_ATTR_RECV_SEQ] = { .type = NLA_U8, }, 904 [L2TP_ATTR_SEND_SEQ] = { .type = NLA_U8, }, 905 [L2TP_ATTR_LNS_MODE] = { .type = NLA_U8, }, 906 [L2TP_ATTR_USING_IPSEC] = { .type = NLA_U8, }, 907 [L2TP_ATTR_RECV_TIMEOUT] = { .type = NLA_MSECS, }, 908 [L2TP_ATTR_FD] = { .type = NLA_U32, }, 909 [L2TP_ATTR_IP_SADDR] = { .type = NLA_U32, }, 910 [L2TP_ATTR_IP_DADDR] = { .type = NLA_U32, }, 911 [L2TP_ATTR_UDP_SPORT] = { .type = NLA_U16, }, 912 [L2TP_ATTR_UDP_DPORT] = { .type = NLA_U16, }, 913 [L2TP_ATTR_MTU] = { .type = NLA_U16, }, 914 [L2TP_ATTR_MRU] = { .type = NLA_U16, }, 915 [L2TP_ATTR_STATS] = { .type = NLA_NESTED, }, 916 [L2TP_ATTR_IP6_SADDR] = { 917 .type = NLA_BINARY, 918 .len = sizeof(struct in6_addr), 919 }, 920 [L2TP_ATTR_IP6_DADDR] = { 921 .type = NLA_BINARY, 922 .len = sizeof(struct in6_addr), 923 }, 924 [L2TP_ATTR_IFNAME] = { 925 .type = NLA_NUL_STRING, 926 .len = IFNAMSIZ - 1, 927 }, 928 [L2TP_ATTR_COOKIE] = { 929 .type = NLA_BINARY, 930 .len = 8, 931 }, 932 [L2TP_ATTR_PEER_COOKIE] = { 933 .type = NLA_BINARY, 934 .len = 8, 935 }, 936 }; 937 938 static const struct genl_small_ops l2tp_nl_ops[] = { 939 { 940 .cmd = L2TP_CMD_NOOP, 941 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 942 .doit = l2tp_nl_cmd_noop, 943 /* can be retrieved by unprivileged users */ 944 }, 945 { 946 .cmd = L2TP_CMD_TUNNEL_CREATE, 947 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 948 .doit = l2tp_nl_cmd_tunnel_create, 949 .flags = GENL_UNS_ADMIN_PERM, 950 }, 951 { 952 .cmd = L2TP_CMD_TUNNEL_DELETE, 953 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 954 .doit = l2tp_nl_cmd_tunnel_delete, 955 .flags = GENL_UNS_ADMIN_PERM, 956 }, 957 { 958 .cmd = L2TP_CMD_TUNNEL_MODIFY, 959 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 960 .doit = l2tp_nl_cmd_tunnel_modify, 961 .flags = GENL_UNS_ADMIN_PERM, 962 }, 963 { 964 .cmd = L2TP_CMD_TUNNEL_GET, 965 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 966 .doit = l2tp_nl_cmd_tunnel_get, 967 .dumpit = l2tp_nl_cmd_tunnel_dump, 968 .flags = GENL_UNS_ADMIN_PERM, 969 }, 970 { 971 .cmd = L2TP_CMD_SESSION_CREATE, 972 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 973 .doit = l2tp_nl_cmd_session_create, 974 .flags = GENL_UNS_ADMIN_PERM, 975 }, 976 { 977 .cmd = L2TP_CMD_SESSION_DELETE, 978 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 979 .doit = l2tp_nl_cmd_session_delete, 980 .flags = GENL_UNS_ADMIN_PERM, 981 }, 982 { 983 .cmd = L2TP_CMD_SESSION_MODIFY, 984 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 985 .doit = l2tp_nl_cmd_session_modify, 986 .flags = GENL_UNS_ADMIN_PERM, 987 }, 988 { 989 .cmd = L2TP_CMD_SESSION_GET, 990 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 991 .doit = l2tp_nl_cmd_session_get, 992 .dumpit = l2tp_nl_cmd_session_dump, 993 .flags = GENL_UNS_ADMIN_PERM, 994 }, 995 }; 996 997 static struct genl_family l2tp_nl_family __ro_after_init = { 998 .name = L2TP_GENL_NAME, 999 .version = L2TP_GENL_VERSION, 1000 .hdrsize = 0, 1001 .maxattr = L2TP_ATTR_MAX, 1002 .policy = l2tp_nl_policy, 1003 .netnsok = true, 1004 .module = THIS_MODULE, 1005 .small_ops = l2tp_nl_ops, 1006 .n_small_ops = ARRAY_SIZE(l2tp_nl_ops), 1007 .resv_start_op = L2TP_CMD_SESSION_GET + 1, 1008 .mcgrps = l2tp_multicast_group, 1009 .n_mcgrps = ARRAY_SIZE(l2tp_multicast_group), 1010 }; 1011 1012 int l2tp_nl_register_ops(enum l2tp_pwtype pw_type, const struct l2tp_nl_cmd_ops *ops) 1013 { 1014 int ret; 1015 1016 ret = -EINVAL; 1017 if (pw_type >= __L2TP_PWTYPE_MAX) 1018 goto err; 1019 1020 genl_lock(); 1021 ret = -EBUSY; 1022 if (l2tp_nl_cmd_ops[pw_type]) 1023 goto out; 1024 1025 l2tp_nl_cmd_ops[pw_type] = ops; 1026 ret = 0; 1027 1028 out: 1029 genl_unlock(); 1030 err: 1031 return ret; 1032 } 1033 EXPORT_SYMBOL_GPL(l2tp_nl_register_ops); 1034 1035 void l2tp_nl_unregister_ops(enum l2tp_pwtype pw_type) 1036 { 1037 if (pw_type < __L2TP_PWTYPE_MAX) { 1038 genl_lock(); 1039 l2tp_nl_cmd_ops[pw_type] = NULL; 1040 genl_unlock(); 1041 } 1042 } 1043 EXPORT_SYMBOL_GPL(l2tp_nl_unregister_ops); 1044 1045 static int __init l2tp_nl_init(void) 1046 { 1047 pr_info("L2TP netlink interface\n"); 1048 return genl_register_family(&l2tp_nl_family); 1049 } 1050 1051 static void l2tp_nl_cleanup(void) 1052 { 1053 genl_unregister_family(&l2tp_nl_family); 1054 } 1055 1056 module_init(l2tp_nl_init); 1057 module_exit(l2tp_nl_cleanup); 1058 1059 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>"); 1060 MODULE_DESCRIPTION("L2TP netlink"); 1061 MODULE_LICENSE("GPL"); 1062 MODULE_VERSION("1.0"); 1063 MODULE_ALIAS_GENL_FAMILY("l2tp"); 1064