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_be32( 209 info->attrs[L2TP_ATTR_IP_SADDR]); 210 cfg.peer_ip.s_addr = nla_get_be32( 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(skb, L2TP_ATTR_IP6_SADDR, sizeof(np->saddr), 380 &np->saddr) || 381 nla_put(skb, L2TP_ATTR_IP6_DADDR, sizeof(sk->sk_v6_daddr), 382 &sk->sk_v6_daddr)) 383 goto nla_put_failure; 384 } else 385 #endif 386 if (nla_put_be32(skb, L2TP_ATTR_IP_SADDR, inet->inet_saddr) || 387 nla_put_be32(skb, L2TP_ATTR_IP_DADDR, inet->inet_daddr)) 388 goto nla_put_failure; 389 break; 390 } 391 392 out: 393 genlmsg_end(skb, hdr); 394 return 0; 395 396 nla_put_failure: 397 genlmsg_cancel(skb, hdr); 398 return -1; 399 } 400 401 static int l2tp_nl_cmd_tunnel_get(struct sk_buff *skb, struct genl_info *info) 402 { 403 struct l2tp_tunnel *tunnel; 404 struct sk_buff *msg; 405 u32 tunnel_id; 406 int ret = -ENOBUFS; 407 struct net *net = genl_info_net(info); 408 409 if (!info->attrs[L2TP_ATTR_CONN_ID]) { 410 ret = -EINVAL; 411 goto out; 412 } 413 414 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 415 416 tunnel = l2tp_tunnel_find(net, tunnel_id); 417 if (tunnel == NULL) { 418 ret = -ENODEV; 419 goto out; 420 } 421 422 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 423 if (!msg) { 424 ret = -ENOMEM; 425 goto out; 426 } 427 428 ret = l2tp_nl_tunnel_send(msg, info->snd_portid, info->snd_seq, 429 NLM_F_ACK, tunnel, L2TP_CMD_TUNNEL_GET); 430 if (ret < 0) 431 goto err_out; 432 433 return genlmsg_unicast(net, msg, info->snd_portid); 434 435 err_out: 436 nlmsg_free(msg); 437 438 out: 439 return ret; 440 } 441 442 static int l2tp_nl_cmd_tunnel_dump(struct sk_buff *skb, struct netlink_callback *cb) 443 { 444 int ti = cb->args[0]; 445 struct l2tp_tunnel *tunnel; 446 struct net *net = sock_net(skb->sk); 447 448 for (;;) { 449 tunnel = l2tp_tunnel_find_nth(net, ti); 450 if (tunnel == NULL) 451 goto out; 452 453 if (l2tp_nl_tunnel_send(skb, NETLINK_CB(cb->skb).portid, 454 cb->nlh->nlmsg_seq, NLM_F_MULTI, 455 tunnel, L2TP_CMD_TUNNEL_GET) < 0) 456 goto out; 457 458 ti++; 459 } 460 461 out: 462 cb->args[0] = ti; 463 464 return skb->len; 465 } 466 467 static int l2tp_nl_cmd_session_create(struct sk_buff *skb, struct genl_info *info) 468 { 469 u32 tunnel_id = 0; 470 u32 session_id; 471 u32 peer_session_id; 472 int ret = 0; 473 struct l2tp_tunnel *tunnel; 474 struct l2tp_session *session; 475 struct l2tp_session_cfg cfg = { 0, }; 476 struct net *net = genl_info_net(info); 477 478 if (!info->attrs[L2TP_ATTR_CONN_ID]) { 479 ret = -EINVAL; 480 goto out; 481 } 482 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]); 483 tunnel = l2tp_tunnel_find(net, tunnel_id); 484 if (!tunnel) { 485 ret = -ENODEV; 486 goto out; 487 } 488 489 if (!info->attrs[L2TP_ATTR_SESSION_ID]) { 490 ret = -EINVAL; 491 goto out; 492 } 493 session_id = nla_get_u32(info->attrs[L2TP_ATTR_SESSION_ID]); 494 session = l2tp_session_find(net, tunnel, session_id); 495 if (session) { 496 ret = -EEXIST; 497 goto out; 498 } 499 500 if (!info->attrs[L2TP_ATTR_PEER_SESSION_ID]) { 501 ret = -EINVAL; 502 goto out; 503 } 504 peer_session_id = nla_get_u32(info->attrs[L2TP_ATTR_PEER_SESSION_ID]); 505 506 if (!info->attrs[L2TP_ATTR_PW_TYPE]) { 507 ret = -EINVAL; 508 goto out; 509 } 510 cfg.pw_type = nla_get_u16(info->attrs[L2TP_ATTR_PW_TYPE]); 511 if (cfg.pw_type >= __L2TP_PWTYPE_MAX) { 512 ret = -EINVAL; 513 goto out; 514 } 515 516 if (tunnel->version > 2) { 517 if (info->attrs[L2TP_ATTR_OFFSET]) 518 cfg.offset = nla_get_u16(info->attrs[L2TP_ATTR_OFFSET]); 519 520 if (info->attrs[L2TP_ATTR_DATA_SEQ]) 521 cfg.data_seq = nla_get_u8(info->attrs[L2TP_ATTR_DATA_SEQ]); 522 523 cfg.l2specific_type = L2TP_L2SPECTYPE_DEFAULT; 524 if (info->attrs[L2TP_ATTR_L2SPEC_TYPE]) 525 cfg.l2specific_type = nla_get_u8(info->attrs[L2TP_ATTR_L2SPEC_TYPE]); 526 527 cfg.l2specific_len = 4; 528 if (info->attrs[L2TP_ATTR_L2SPEC_LEN]) 529 cfg.l2specific_len = nla_get_u8(info->attrs[L2TP_ATTR_L2SPEC_LEN]); 530 531 if (info->attrs[L2TP_ATTR_COOKIE]) { 532 u16 len = nla_len(info->attrs[L2TP_ATTR_COOKIE]); 533 if (len > 8) { 534 ret = -EINVAL; 535 goto out; 536 } 537 cfg.cookie_len = len; 538 memcpy(&cfg.cookie[0], nla_data(info->attrs[L2TP_ATTR_COOKIE]), len); 539 } 540 if (info->attrs[L2TP_ATTR_PEER_COOKIE]) { 541 u16 len = nla_len(info->attrs[L2TP_ATTR_PEER_COOKIE]); 542 if (len > 8) { 543 ret = -EINVAL; 544 goto out; 545 } 546 cfg.peer_cookie_len = len; 547 memcpy(&cfg.peer_cookie[0], nla_data(info->attrs[L2TP_ATTR_PEER_COOKIE]), len); 548 } 549 if (info->attrs[L2TP_ATTR_IFNAME]) 550 cfg.ifname = nla_data(info->attrs[L2TP_ATTR_IFNAME]); 551 552 if (info->attrs[L2TP_ATTR_VLAN_ID]) 553 cfg.vlan_id = nla_get_u16(info->attrs[L2TP_ATTR_VLAN_ID]); 554 } 555 556 if (info->attrs[L2TP_ATTR_DEBUG]) 557 cfg.debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]); 558 559 if (info->attrs[L2TP_ATTR_RECV_SEQ]) 560 cfg.recv_seq = nla_get_u8(info->attrs[L2TP_ATTR_RECV_SEQ]); 561 562 if (info->attrs[L2TP_ATTR_SEND_SEQ]) 563 cfg.send_seq = nla_get_u8(info->attrs[L2TP_ATTR_SEND_SEQ]); 564 565 if (info->attrs[L2TP_ATTR_LNS_MODE]) 566 cfg.lns_mode = nla_get_u8(info->attrs[L2TP_ATTR_LNS_MODE]); 567 568 if (info->attrs[L2TP_ATTR_RECV_TIMEOUT]) 569 cfg.reorder_timeout = nla_get_msecs(info->attrs[L2TP_ATTR_RECV_TIMEOUT]); 570 571 if (info->attrs[L2TP_ATTR_MTU]) 572 cfg.mtu = nla_get_u16(info->attrs[L2TP_ATTR_MTU]); 573 574 if (info->attrs[L2TP_ATTR_MRU]) 575 cfg.mru = nla_get_u16(info->attrs[L2TP_ATTR_MRU]); 576 577 if ((l2tp_nl_cmd_ops[cfg.pw_type] == NULL) || 578 (l2tp_nl_cmd_ops[cfg.pw_type]->session_create == NULL)) { 579 ret = -EPROTONOSUPPORT; 580 goto out; 581 } 582 583 /* Check that pseudowire-specific params are present */ 584 switch (cfg.pw_type) { 585 case L2TP_PWTYPE_NONE: 586 break; 587 case L2TP_PWTYPE_ETH_VLAN: 588 if (!info->attrs[L2TP_ATTR_VLAN_ID]) { 589 ret = -EINVAL; 590 goto out; 591 } 592 break; 593 case L2TP_PWTYPE_ETH: 594 break; 595 case L2TP_PWTYPE_PPP: 596 case L2TP_PWTYPE_PPP_AC: 597 break; 598 case L2TP_PWTYPE_IP: 599 default: 600 ret = -EPROTONOSUPPORT; 601 break; 602 } 603 604 ret = -EPROTONOSUPPORT; 605 if (l2tp_nl_cmd_ops[cfg.pw_type]->session_create) 606 ret = (*l2tp_nl_cmd_ops[cfg.pw_type]->session_create)(net, tunnel_id, 607 session_id, peer_session_id, &cfg); 608 609 if (ret >= 0) { 610 session = l2tp_session_find(net, tunnel, session_id); 611 if (session) 612 ret = l2tp_session_notify(&l2tp_nl_family, info, session, 613 L2TP_CMD_SESSION_CREATE); 614 } 615 616 out: 617 return ret; 618 } 619 620 static int l2tp_nl_cmd_session_delete(struct sk_buff *skb, struct genl_info *info) 621 { 622 int ret = 0; 623 struct l2tp_session *session; 624 u16 pw_type; 625 626 session = l2tp_nl_session_find(info); 627 if (session == NULL) { 628 ret = -ENODEV; 629 goto out; 630 } 631 632 l2tp_session_notify(&l2tp_nl_family, info, 633 session, L2TP_CMD_SESSION_DELETE); 634 635 pw_type = session->pwtype; 636 if (pw_type < __L2TP_PWTYPE_MAX) 637 if (l2tp_nl_cmd_ops[pw_type] && l2tp_nl_cmd_ops[pw_type]->session_delete) 638 ret = (*l2tp_nl_cmd_ops[pw_type]->session_delete)(session); 639 640 out: 641 return ret; 642 } 643 644 static int l2tp_nl_cmd_session_modify(struct sk_buff *skb, struct genl_info *info) 645 { 646 int ret = 0; 647 struct l2tp_session *session; 648 649 session = l2tp_nl_session_find(info); 650 if (session == NULL) { 651 ret = -ENODEV; 652 goto out; 653 } 654 655 if (info->attrs[L2TP_ATTR_DEBUG]) 656 session->debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]); 657 658 if (info->attrs[L2TP_ATTR_DATA_SEQ]) 659 session->data_seq = nla_get_u8(info->attrs[L2TP_ATTR_DATA_SEQ]); 660 661 if (info->attrs[L2TP_ATTR_RECV_SEQ]) 662 session->recv_seq = nla_get_u8(info->attrs[L2TP_ATTR_RECV_SEQ]); 663 664 if (info->attrs[L2TP_ATTR_SEND_SEQ]) { 665 session->send_seq = nla_get_u8(info->attrs[L2TP_ATTR_SEND_SEQ]); 666 l2tp_session_set_header_len(session, session->tunnel->version); 667 } 668 669 if (info->attrs[L2TP_ATTR_LNS_MODE]) 670 session->lns_mode = nla_get_u8(info->attrs[L2TP_ATTR_LNS_MODE]); 671 672 if (info->attrs[L2TP_ATTR_RECV_TIMEOUT]) 673 session->reorder_timeout = nla_get_msecs(info->attrs[L2TP_ATTR_RECV_TIMEOUT]); 674 675 if (info->attrs[L2TP_ATTR_MTU]) 676 session->mtu = nla_get_u16(info->attrs[L2TP_ATTR_MTU]); 677 678 if (info->attrs[L2TP_ATTR_MRU]) 679 session->mru = nla_get_u16(info->attrs[L2TP_ATTR_MRU]); 680 681 ret = l2tp_session_notify(&l2tp_nl_family, info, 682 session, L2TP_CMD_SESSION_MODIFY); 683 684 out: 685 return ret; 686 } 687 688 static int l2tp_nl_session_send(struct sk_buff *skb, u32 portid, u32 seq, int flags, 689 struct l2tp_session *session, u8 cmd) 690 { 691 void *hdr; 692 struct nlattr *nest; 693 struct l2tp_tunnel *tunnel = session->tunnel; 694 struct sock *sk = NULL; 695 696 sk = tunnel->sock; 697 698 hdr = genlmsg_put(skb, portid, seq, &l2tp_nl_family, flags, cmd); 699 if (!hdr) 700 return -EMSGSIZE; 701 702 if (nla_put_u32(skb, L2TP_ATTR_CONN_ID, tunnel->tunnel_id) || 703 nla_put_u32(skb, L2TP_ATTR_SESSION_ID, session->session_id) || 704 nla_put_u32(skb, L2TP_ATTR_PEER_CONN_ID, tunnel->peer_tunnel_id) || 705 nla_put_u32(skb, L2TP_ATTR_PEER_SESSION_ID, 706 session->peer_session_id) || 707 nla_put_u32(skb, L2TP_ATTR_DEBUG, session->debug) || 708 nla_put_u16(skb, L2TP_ATTR_PW_TYPE, session->pwtype) || 709 nla_put_u16(skb, L2TP_ATTR_MTU, session->mtu) || 710 (session->mru && 711 nla_put_u16(skb, L2TP_ATTR_MRU, session->mru))) 712 goto nla_put_failure; 713 714 if ((session->ifname[0] && 715 nla_put_string(skb, L2TP_ATTR_IFNAME, session->ifname)) || 716 (session->cookie_len && 717 nla_put(skb, L2TP_ATTR_COOKIE, session->cookie_len, 718 &session->cookie[0])) || 719 (session->peer_cookie_len && 720 nla_put(skb, L2TP_ATTR_PEER_COOKIE, session->peer_cookie_len, 721 &session->peer_cookie[0])) || 722 nla_put_u8(skb, L2TP_ATTR_RECV_SEQ, session->recv_seq) || 723 nla_put_u8(skb, L2TP_ATTR_SEND_SEQ, session->send_seq) || 724 nla_put_u8(skb, L2TP_ATTR_LNS_MODE, session->lns_mode) || 725 #ifdef CONFIG_XFRM 726 (((sk) && (sk->sk_policy[0] || sk->sk_policy[1])) && 727 nla_put_u8(skb, L2TP_ATTR_USING_IPSEC, 1)) || 728 #endif 729 (session->reorder_timeout && 730 nla_put_msecs(skb, L2TP_ATTR_RECV_TIMEOUT, session->reorder_timeout))) 731 goto nla_put_failure; 732 733 nest = nla_nest_start(skb, L2TP_ATTR_STATS); 734 if (nest == NULL) 735 goto nla_put_failure; 736 737 if (nla_put_u64(skb, L2TP_ATTR_TX_PACKETS, 738 atomic_long_read(&session->stats.tx_packets)) || 739 nla_put_u64(skb, L2TP_ATTR_TX_BYTES, 740 atomic_long_read(&session->stats.tx_bytes)) || 741 nla_put_u64(skb, L2TP_ATTR_TX_ERRORS, 742 atomic_long_read(&session->stats.tx_errors)) || 743 nla_put_u64(skb, L2TP_ATTR_RX_PACKETS, 744 atomic_long_read(&session->stats.rx_packets)) || 745 nla_put_u64(skb, L2TP_ATTR_RX_BYTES, 746 atomic_long_read(&session->stats.rx_bytes)) || 747 nla_put_u64(skb, L2TP_ATTR_RX_SEQ_DISCARDS, 748 atomic_long_read(&session->stats.rx_seq_discards)) || 749 nla_put_u64(skb, L2TP_ATTR_RX_OOS_PACKETS, 750 atomic_long_read(&session->stats.rx_oos_packets)) || 751 nla_put_u64(skb, L2TP_ATTR_RX_ERRORS, 752 atomic_long_read(&session->stats.rx_errors))) 753 goto nla_put_failure; 754 nla_nest_end(skb, nest); 755 756 genlmsg_end(skb, hdr); 757 return 0; 758 759 nla_put_failure: 760 genlmsg_cancel(skb, hdr); 761 return -1; 762 } 763 764 static int l2tp_nl_cmd_session_get(struct sk_buff *skb, struct genl_info *info) 765 { 766 struct l2tp_session *session; 767 struct sk_buff *msg; 768 int ret; 769 770 session = l2tp_nl_session_find(info); 771 if (session == NULL) { 772 ret = -ENODEV; 773 goto out; 774 } 775 776 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 777 if (!msg) { 778 ret = -ENOMEM; 779 goto out; 780 } 781 782 ret = l2tp_nl_session_send(msg, info->snd_portid, info->snd_seq, 783 0, session, L2TP_CMD_SESSION_GET); 784 if (ret < 0) 785 goto err_out; 786 787 return genlmsg_unicast(genl_info_net(info), msg, info->snd_portid); 788 789 err_out: 790 nlmsg_free(msg); 791 792 out: 793 return ret; 794 } 795 796 static int l2tp_nl_cmd_session_dump(struct sk_buff *skb, struct netlink_callback *cb) 797 { 798 struct net *net = sock_net(skb->sk); 799 struct l2tp_session *session; 800 struct l2tp_tunnel *tunnel = NULL; 801 int ti = cb->args[0]; 802 int si = cb->args[1]; 803 804 for (;;) { 805 if (tunnel == NULL) { 806 tunnel = l2tp_tunnel_find_nth(net, ti); 807 if (tunnel == NULL) 808 goto out; 809 } 810 811 session = l2tp_session_find_nth(tunnel, si); 812 if (session == NULL) { 813 ti++; 814 tunnel = NULL; 815 si = 0; 816 continue; 817 } 818 819 if (l2tp_nl_session_send(skb, NETLINK_CB(cb->skb).portid, 820 cb->nlh->nlmsg_seq, NLM_F_MULTI, 821 session, L2TP_CMD_SESSION_GET) < 0) 822 break; 823 824 si++; 825 } 826 827 out: 828 cb->args[0] = ti; 829 cb->args[1] = si; 830 831 return skb->len; 832 } 833 834 static struct nla_policy l2tp_nl_policy[L2TP_ATTR_MAX + 1] = { 835 [L2TP_ATTR_NONE] = { .type = NLA_UNSPEC, }, 836 [L2TP_ATTR_PW_TYPE] = { .type = NLA_U16, }, 837 [L2TP_ATTR_ENCAP_TYPE] = { .type = NLA_U16, }, 838 [L2TP_ATTR_OFFSET] = { .type = NLA_U16, }, 839 [L2TP_ATTR_DATA_SEQ] = { .type = NLA_U8, }, 840 [L2TP_ATTR_L2SPEC_TYPE] = { .type = NLA_U8, }, 841 [L2TP_ATTR_L2SPEC_LEN] = { .type = NLA_U8, }, 842 [L2TP_ATTR_PROTO_VERSION] = { .type = NLA_U8, }, 843 [L2TP_ATTR_CONN_ID] = { .type = NLA_U32, }, 844 [L2TP_ATTR_PEER_CONN_ID] = { .type = NLA_U32, }, 845 [L2TP_ATTR_SESSION_ID] = { .type = NLA_U32, }, 846 [L2TP_ATTR_PEER_SESSION_ID] = { .type = NLA_U32, }, 847 [L2TP_ATTR_UDP_CSUM] = { .type = NLA_U8, }, 848 [L2TP_ATTR_VLAN_ID] = { .type = NLA_U16, }, 849 [L2TP_ATTR_DEBUG] = { .type = NLA_U32, }, 850 [L2TP_ATTR_RECV_SEQ] = { .type = NLA_U8, }, 851 [L2TP_ATTR_SEND_SEQ] = { .type = NLA_U8, }, 852 [L2TP_ATTR_LNS_MODE] = { .type = NLA_U8, }, 853 [L2TP_ATTR_USING_IPSEC] = { .type = NLA_U8, }, 854 [L2TP_ATTR_RECV_TIMEOUT] = { .type = NLA_MSECS, }, 855 [L2TP_ATTR_FD] = { .type = NLA_U32, }, 856 [L2TP_ATTR_IP_SADDR] = { .type = NLA_U32, }, 857 [L2TP_ATTR_IP_DADDR] = { .type = NLA_U32, }, 858 [L2TP_ATTR_UDP_SPORT] = { .type = NLA_U16, }, 859 [L2TP_ATTR_UDP_DPORT] = { .type = NLA_U16, }, 860 [L2TP_ATTR_MTU] = { .type = NLA_U16, }, 861 [L2TP_ATTR_MRU] = { .type = NLA_U16, }, 862 [L2TP_ATTR_STATS] = { .type = NLA_NESTED, }, 863 [L2TP_ATTR_IP6_SADDR] = { 864 .type = NLA_BINARY, 865 .len = sizeof(struct in6_addr), 866 }, 867 [L2TP_ATTR_IP6_DADDR] = { 868 .type = NLA_BINARY, 869 .len = sizeof(struct in6_addr), 870 }, 871 [L2TP_ATTR_IFNAME] = { 872 .type = NLA_NUL_STRING, 873 .len = IFNAMSIZ - 1, 874 }, 875 [L2TP_ATTR_COOKIE] = { 876 .type = NLA_BINARY, 877 .len = 8, 878 }, 879 [L2TP_ATTR_PEER_COOKIE] = { 880 .type = NLA_BINARY, 881 .len = 8, 882 }, 883 }; 884 885 static const struct genl_ops l2tp_nl_ops[] = { 886 { 887 .cmd = L2TP_CMD_NOOP, 888 .doit = l2tp_nl_cmd_noop, 889 .policy = l2tp_nl_policy, 890 /* can be retrieved by unprivileged users */ 891 }, 892 { 893 .cmd = L2TP_CMD_TUNNEL_CREATE, 894 .doit = l2tp_nl_cmd_tunnel_create, 895 .policy = l2tp_nl_policy, 896 .flags = GENL_ADMIN_PERM, 897 }, 898 { 899 .cmd = L2TP_CMD_TUNNEL_DELETE, 900 .doit = l2tp_nl_cmd_tunnel_delete, 901 .policy = l2tp_nl_policy, 902 .flags = GENL_ADMIN_PERM, 903 }, 904 { 905 .cmd = L2TP_CMD_TUNNEL_MODIFY, 906 .doit = l2tp_nl_cmd_tunnel_modify, 907 .policy = l2tp_nl_policy, 908 .flags = GENL_ADMIN_PERM, 909 }, 910 { 911 .cmd = L2TP_CMD_TUNNEL_GET, 912 .doit = l2tp_nl_cmd_tunnel_get, 913 .dumpit = l2tp_nl_cmd_tunnel_dump, 914 .policy = l2tp_nl_policy, 915 .flags = GENL_ADMIN_PERM, 916 }, 917 { 918 .cmd = L2TP_CMD_SESSION_CREATE, 919 .doit = l2tp_nl_cmd_session_create, 920 .policy = l2tp_nl_policy, 921 .flags = GENL_ADMIN_PERM, 922 }, 923 { 924 .cmd = L2TP_CMD_SESSION_DELETE, 925 .doit = l2tp_nl_cmd_session_delete, 926 .policy = l2tp_nl_policy, 927 .flags = GENL_ADMIN_PERM, 928 }, 929 { 930 .cmd = L2TP_CMD_SESSION_MODIFY, 931 .doit = l2tp_nl_cmd_session_modify, 932 .policy = l2tp_nl_policy, 933 .flags = GENL_ADMIN_PERM, 934 }, 935 { 936 .cmd = L2TP_CMD_SESSION_GET, 937 .doit = l2tp_nl_cmd_session_get, 938 .dumpit = l2tp_nl_cmd_session_dump, 939 .policy = l2tp_nl_policy, 940 .flags = GENL_ADMIN_PERM, 941 }, 942 }; 943 944 int l2tp_nl_register_ops(enum l2tp_pwtype pw_type, const struct l2tp_nl_cmd_ops *ops) 945 { 946 int ret; 947 948 ret = -EINVAL; 949 if (pw_type >= __L2TP_PWTYPE_MAX) 950 goto err; 951 952 genl_lock(); 953 ret = -EBUSY; 954 if (l2tp_nl_cmd_ops[pw_type]) 955 goto out; 956 957 l2tp_nl_cmd_ops[pw_type] = ops; 958 ret = 0; 959 960 out: 961 genl_unlock(); 962 err: 963 return ret; 964 } 965 EXPORT_SYMBOL_GPL(l2tp_nl_register_ops); 966 967 void l2tp_nl_unregister_ops(enum l2tp_pwtype pw_type) 968 { 969 if (pw_type < __L2TP_PWTYPE_MAX) { 970 genl_lock(); 971 l2tp_nl_cmd_ops[pw_type] = NULL; 972 genl_unlock(); 973 } 974 } 975 EXPORT_SYMBOL_GPL(l2tp_nl_unregister_ops); 976 977 static int l2tp_nl_init(void) 978 { 979 pr_info("L2TP netlink interface\n"); 980 return genl_register_family_with_ops_groups(&l2tp_nl_family, 981 l2tp_nl_ops, 982 l2tp_multicast_group); 983 } 984 985 static void l2tp_nl_cleanup(void) 986 { 987 genl_unregister_family(&l2tp_nl_family); 988 } 989 990 module_init(l2tp_nl_init); 991 module_exit(l2tp_nl_cleanup); 992 993 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>"); 994 MODULE_DESCRIPTION("L2TP netlink"); 995 MODULE_LICENSE("GPL"); 996 MODULE_VERSION("1.0"); 997 MODULE_ALIAS_GENL_FAMILY("l2tp"); 998