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