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