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