2 * L2TP netlink layer, for management
4 * Copyright (c) 2008,2009,2010 Katalix Systems Ltd
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>
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.
17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20 #include <net/genetlink.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>
29 #include <linux/l2tp.h>
31 #include "l2tp_core.h"
34 static struct genl_family l2tp_nl_family = {
35 .id = GENL_ID_GENERATE,
36 .name = L2TP_GENL_NAME,
37 .version = L2TP_GENL_VERSION,
39 .maxattr = L2TP_ATTR_MAX,
43 /* Accessed under genl lock */
44 static const struct l2tp_nl_cmd_ops *l2tp_nl_cmd_ops[__L2TP_PWTYPE_MAX];
46 static struct l2tp_session *l2tp_nl_session_find(struct genl_info *info)
51 struct l2tp_tunnel *tunnel;
52 struct l2tp_session *session = NULL;
53 struct net *net = genl_info_net(info);
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);
64 session = l2tp_session_find(net, tunnel, session_id);
70 static int l2tp_nl_cmd_noop(struct sk_buff *skb, struct genl_info *info)
76 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
82 hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq,
83 &l2tp_nl_family, 0, L2TP_CMD_NOOP);
89 genlmsg_end(msg, hdr);
91 return genlmsg_unicast(genl_info_net(info), msg, info->snd_portid);
100 static int l2tp_nl_cmd_tunnel_create(struct sk_buff *skb, struct genl_info *info)
107 struct l2tp_tunnel_cfg cfg = { 0, };
108 struct l2tp_tunnel *tunnel;
109 struct net *net = genl_info_net(info);
111 if (!info->attrs[L2TP_ATTR_CONN_ID]) {
115 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]);
117 if (!info->attrs[L2TP_ATTR_PEER_CONN_ID]) {
121 peer_tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_PEER_CONN_ID]);
123 if (!info->attrs[L2TP_ATTR_PROTO_VERSION]) {
127 proto_version = nla_get_u8(info->attrs[L2TP_ATTR_PROTO_VERSION]);
129 if (!info->attrs[L2TP_ATTR_ENCAP_TYPE]) {
133 cfg.encap = nla_get_u16(info->attrs[L2TP_ATTR_ENCAP_TYPE]);
136 if (info->attrs[L2TP_ATTR_FD]) {
137 fd = nla_get_u32(info->attrs[L2TP_ATTR_FD]);
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]);
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]);
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]);
166 if (info->attrs[L2TP_ATTR_DEBUG])
167 cfg.debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]);
169 tunnel = l2tp_tunnel_find(net, tunnel_id);
170 if (tunnel != NULL) {
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);
188 static int l2tp_nl_cmd_tunnel_delete(struct sk_buff *skb, struct genl_info *info)
190 struct l2tp_tunnel *tunnel;
193 struct net *net = genl_info_net(info);
195 if (!info->attrs[L2TP_ATTR_CONN_ID]) {
199 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]);
201 tunnel = l2tp_tunnel_find(net, tunnel_id);
202 if (tunnel == NULL) {
207 (void) l2tp_tunnel_delete(tunnel);
213 static int l2tp_nl_cmd_tunnel_modify(struct sk_buff *skb, struct genl_info *info)
215 struct l2tp_tunnel *tunnel;
218 struct net *net = genl_info_net(info);
220 if (!info->attrs[L2TP_ATTR_CONN_ID]) {
224 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]);
226 tunnel = l2tp_tunnel_find(net, tunnel_id);
227 if (tunnel == NULL) {
232 if (info->attrs[L2TP_ATTR_DEBUG])
233 tunnel->debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]);
239 static int l2tp_nl_tunnel_send(struct sk_buff *skb, u32 portid, u32 seq, int flags,
240 struct l2tp_tunnel *tunnel)
244 struct sock *sk = NULL;
245 struct inet_sock *inet;
246 #if IS_ENABLED(CONFIG_IPV6)
247 struct ipv6_pinfo *np = NULL;
249 struct l2tp_stats stats;
252 hdr = genlmsg_put(skb, portid, seq, &l2tp_nl_family, flags,
253 L2TP_CMD_TUNNEL_GET);
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;
264 nest = nla_nest_start(skb, L2TP_ATTR_STATS);
266 goto nla_put_failure;
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));
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);
297 #if IS_ENABLED(CONFIG_IPV6)
298 if (sk->sk_family == AF_INET6)
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;
312 case L2TP_ENCAPTYPE_IP:
313 #if IS_ENABLED(CONFIG_IPV6)
315 if (nla_put(skb, L2TP_ATTR_IP6_SADDR, sizeof(np->saddr),
317 nla_put(skb, L2TP_ATTR_IP6_DADDR, sizeof(np->daddr),
319 goto nla_put_failure;
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;
329 return genlmsg_end(skb, hdr);
332 genlmsg_cancel(skb, hdr);
336 static int l2tp_nl_cmd_tunnel_get(struct sk_buff *skb, struct genl_info *info)
338 struct l2tp_tunnel *tunnel;
342 struct net *net = genl_info_net(info);
344 if (!info->attrs[L2TP_ATTR_CONN_ID]) {
349 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]);
351 tunnel = l2tp_tunnel_find(net, tunnel_id);
352 if (tunnel == NULL) {
357 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
363 ret = l2tp_nl_tunnel_send(msg, info->snd_portid, info->snd_seq,
368 return genlmsg_unicast(net, msg, info->snd_portid);
377 static int l2tp_nl_cmd_tunnel_dump(struct sk_buff *skb, struct netlink_callback *cb)
379 int ti = cb->args[0];
380 struct l2tp_tunnel *tunnel;
381 struct net *net = sock_net(skb->sk);
384 tunnel = l2tp_tunnel_find_nth(net, ti);
388 if (l2tp_nl_tunnel_send(skb, NETLINK_CB(cb->skb).portid,
389 cb->nlh->nlmsg_seq, NLM_F_MULTI,
402 static int l2tp_nl_cmd_session_create(struct sk_buff *skb, struct genl_info *info)
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);
413 if (!info->attrs[L2TP_ATTR_CONN_ID]) {
417 tunnel_id = nla_get_u32(info->attrs[L2TP_ATTR_CONN_ID]);
418 tunnel = l2tp_tunnel_find(net, tunnel_id);
424 if (!info->attrs[L2TP_ATTR_SESSION_ID]) {
428 session_id = nla_get_u32(info->attrs[L2TP_ATTR_SESSION_ID]);
429 session = l2tp_session_find(net, tunnel, session_id);
435 if (!info->attrs[L2TP_ATTR_PEER_SESSION_ID]) {
439 peer_session_id = nla_get_u32(info->attrs[L2TP_ATTR_PEER_SESSION_ID]);
441 if (!info->attrs[L2TP_ATTR_PW_TYPE]) {
445 cfg.pw_type = nla_get_u16(info->attrs[L2TP_ATTR_PW_TYPE]);
446 if (cfg.pw_type >= __L2TP_PWTYPE_MAX) {
451 if (tunnel->version > 2) {
452 if (info->attrs[L2TP_ATTR_OFFSET])
453 cfg.offset = nla_get_u16(info->attrs[L2TP_ATTR_OFFSET]);
455 if (info->attrs[L2TP_ATTR_DATA_SEQ])
456 cfg.data_seq = nla_get_u8(info->attrs[L2TP_ATTR_DATA_SEQ]);
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]);
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]);
466 if (info->attrs[L2TP_ATTR_COOKIE]) {
467 u16 len = nla_len(info->attrs[L2TP_ATTR_COOKIE]);
472 cfg.cookie_len = len;
473 memcpy(&cfg.cookie[0], nla_data(info->attrs[L2TP_ATTR_COOKIE]), len);
475 if (info->attrs[L2TP_ATTR_PEER_COOKIE]) {
476 u16 len = nla_len(info->attrs[L2TP_ATTR_PEER_COOKIE]);
481 cfg.peer_cookie_len = len;
482 memcpy(&cfg.peer_cookie[0], nla_data(info->attrs[L2TP_ATTR_PEER_COOKIE]), len);
484 if (info->attrs[L2TP_ATTR_IFNAME])
485 cfg.ifname = nla_data(info->attrs[L2TP_ATTR_IFNAME]);
487 if (info->attrs[L2TP_ATTR_VLAN_ID])
488 cfg.vlan_id = nla_get_u16(info->attrs[L2TP_ATTR_VLAN_ID]);
491 if (info->attrs[L2TP_ATTR_DEBUG])
492 cfg.debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]);
494 if (info->attrs[L2TP_ATTR_RECV_SEQ])
495 cfg.recv_seq = nla_get_u8(info->attrs[L2TP_ATTR_RECV_SEQ]);
497 if (info->attrs[L2TP_ATTR_SEND_SEQ])
498 cfg.send_seq = nla_get_u8(info->attrs[L2TP_ATTR_SEND_SEQ]);
500 if (info->attrs[L2TP_ATTR_LNS_MODE])
501 cfg.lns_mode = nla_get_u8(info->attrs[L2TP_ATTR_LNS_MODE]);
503 if (info->attrs[L2TP_ATTR_RECV_TIMEOUT])
504 cfg.reorder_timeout = nla_get_msecs(info->attrs[L2TP_ATTR_RECV_TIMEOUT]);
506 if (info->attrs[L2TP_ATTR_MTU])
507 cfg.mtu = nla_get_u16(info->attrs[L2TP_ATTR_MTU]);
509 if (info->attrs[L2TP_ATTR_MRU])
510 cfg.mru = nla_get_u16(info->attrs[L2TP_ATTR_MRU]);
512 if ((l2tp_nl_cmd_ops[cfg.pw_type] == NULL) ||
513 (l2tp_nl_cmd_ops[cfg.pw_type]->session_create == NULL)) {
514 ret = -EPROTONOSUPPORT;
518 /* Check that pseudowire-specific params are present */
519 switch (cfg.pw_type) {
520 case L2TP_PWTYPE_NONE:
522 case L2TP_PWTYPE_ETH_VLAN:
523 if (!info->attrs[L2TP_ATTR_VLAN_ID]) {
528 case L2TP_PWTYPE_ETH:
530 case L2TP_PWTYPE_PPP:
531 case L2TP_PWTYPE_PPP_AC:
535 ret = -EPROTONOSUPPORT;
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);
548 static int l2tp_nl_cmd_session_delete(struct sk_buff *skb, struct genl_info *info)
551 struct l2tp_session *session;
554 session = l2tp_nl_session_find(info);
555 if (session == NULL) {
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);
569 static int l2tp_nl_cmd_session_modify(struct sk_buff *skb, struct genl_info *info)
572 struct l2tp_session *session;
574 session = l2tp_nl_session_find(info);
575 if (session == NULL) {
580 if (info->attrs[L2TP_ATTR_DEBUG])
581 session->debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]);
583 if (info->attrs[L2TP_ATTR_DATA_SEQ])
584 session->data_seq = nla_get_u8(info->attrs[L2TP_ATTR_DATA_SEQ]);
586 if (info->attrs[L2TP_ATTR_RECV_SEQ])
587 session->recv_seq = nla_get_u8(info->attrs[L2TP_ATTR_RECV_SEQ]);
589 if (info->attrs[L2TP_ATTR_SEND_SEQ])
590 session->send_seq = nla_get_u8(info->attrs[L2TP_ATTR_SEND_SEQ]);
592 if (info->attrs[L2TP_ATTR_LNS_MODE])
593 session->lns_mode = nla_get_u8(info->attrs[L2TP_ATTR_LNS_MODE]);
595 if (info->attrs[L2TP_ATTR_RECV_TIMEOUT])
596 session->reorder_timeout = nla_get_msecs(info->attrs[L2TP_ATTR_RECV_TIMEOUT]);
598 if (info->attrs[L2TP_ATTR_MTU])
599 session->mtu = nla_get_u16(info->attrs[L2TP_ATTR_MTU]);
601 if (info->attrs[L2TP_ATTR_MRU])
602 session->mru = nla_get_u16(info->attrs[L2TP_ATTR_MRU]);
608 static int l2tp_nl_session_send(struct sk_buff *skb, u32 portid, u32 seq, int flags,
609 struct l2tp_session *session)
613 struct l2tp_tunnel *tunnel = session->tunnel;
614 struct sock *sk = NULL;
615 struct l2tp_stats stats;
620 hdr = genlmsg_put(skb, portid, seq, &l2tp_nl_family, flags, L2TP_CMD_SESSION_GET);
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) ||
633 nla_put_u16(skb, L2TP_ATTR_MRU, session->mru)))
634 goto nla_put_failure;
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) ||
648 (((sk) && (sk->sk_policy[0] || sk->sk_policy[1])) &&
649 nla_put_u8(skb, L2TP_ATTR_USING_IPSEC, 1)) ||
651 (session->reorder_timeout &&
652 nla_put_msecs(skb, L2TP_ATTR_RECV_TIMEOUT, session->reorder_timeout)))
653 goto nla_put_failure;
655 nest = nla_nest_start(skb, L2TP_ATTR_STATS);
657 goto nla_put_failure;
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));
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);
684 return genlmsg_end(skb, hdr);
687 genlmsg_cancel(skb, hdr);
691 static int l2tp_nl_cmd_session_get(struct sk_buff *skb, struct genl_info *info)
693 struct l2tp_session *session;
697 session = l2tp_nl_session_find(info);
698 if (session == NULL) {
703 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
709 ret = l2tp_nl_session_send(msg, info->snd_portid, info->snd_seq,
714 return genlmsg_unicast(genl_info_net(info), msg, info->snd_portid);
723 static int l2tp_nl_cmd_session_dump(struct sk_buff *skb, struct netlink_callback *cb)
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];
732 if (tunnel == NULL) {
733 tunnel = l2tp_tunnel_find_nth(net, ti);
738 session = l2tp_session_find_nth(tunnel, si);
739 if (session == NULL) {
746 if (l2tp_nl_session_send(skb, NETLINK_CB(cb->skb).portid,
747 cb->nlh->nlmsg_seq, NLM_F_MULTI,
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] = {
792 .len = sizeof(struct in6_addr),
794 [L2TP_ATTR_IP6_DADDR] = {
796 .len = sizeof(struct in6_addr),
798 [L2TP_ATTR_IFNAME] = {
799 .type = NLA_NUL_STRING,
802 [L2TP_ATTR_COOKIE] = {
806 [L2TP_ATTR_PEER_COOKIE] = {
812 static struct genl_ops l2tp_nl_ops[] = {
814 .cmd = L2TP_CMD_NOOP,
815 .doit = l2tp_nl_cmd_noop,
816 .policy = l2tp_nl_policy,
817 /* can be retrieved by unprivileged users */
820 .cmd = L2TP_CMD_TUNNEL_CREATE,
821 .doit = l2tp_nl_cmd_tunnel_create,
822 .policy = l2tp_nl_policy,
823 .flags = GENL_ADMIN_PERM,
826 .cmd = L2TP_CMD_TUNNEL_DELETE,
827 .doit = l2tp_nl_cmd_tunnel_delete,
828 .policy = l2tp_nl_policy,
829 .flags = GENL_ADMIN_PERM,
832 .cmd = L2TP_CMD_TUNNEL_MODIFY,
833 .doit = l2tp_nl_cmd_tunnel_modify,
834 .policy = l2tp_nl_policy,
835 .flags = GENL_ADMIN_PERM,
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,
845 .cmd = L2TP_CMD_SESSION_CREATE,
846 .doit = l2tp_nl_cmd_session_create,
847 .policy = l2tp_nl_policy,
848 .flags = GENL_ADMIN_PERM,
851 .cmd = L2TP_CMD_SESSION_DELETE,
852 .doit = l2tp_nl_cmd_session_delete,
853 .policy = l2tp_nl_policy,
854 .flags = GENL_ADMIN_PERM,
857 .cmd = L2TP_CMD_SESSION_MODIFY,
858 .doit = l2tp_nl_cmd_session_modify,
859 .policy = l2tp_nl_policy,
860 .flags = GENL_ADMIN_PERM,
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,
871 int l2tp_nl_register_ops(enum l2tp_pwtype pw_type, const struct l2tp_nl_cmd_ops *ops)
876 if (pw_type >= __L2TP_PWTYPE_MAX)
881 if (l2tp_nl_cmd_ops[pw_type])
884 l2tp_nl_cmd_ops[pw_type] = ops;
892 EXPORT_SYMBOL_GPL(l2tp_nl_register_ops);
894 void l2tp_nl_unregister_ops(enum l2tp_pwtype pw_type)
896 if (pw_type < __L2TP_PWTYPE_MAX) {
898 l2tp_nl_cmd_ops[pw_type] = NULL;
902 EXPORT_SYMBOL_GPL(l2tp_nl_unregister_ops);
904 static int l2tp_nl_init(void)
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));
915 static void l2tp_nl_cleanup(void)
917 genl_unregister_family(&l2tp_nl_family);
920 module_init(l2tp_nl_init);
921 module_exit(l2tp_nl_cleanup);
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");