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