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");