net/l2tp/l2tp_netlink.c

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