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
;
250 hdr
= genlmsg_put(skb
, portid
, seq
, &l2tp_nl_family
, flags
,
251 L2TP_CMD_TUNNEL_GET
);
255 if (nla_put_u8(skb
, L2TP_ATTR_PROTO_VERSION
, tunnel
->version
) ||
256 nla_put_u32(skb
, L2TP_ATTR_CONN_ID
, tunnel
->tunnel_id
) ||
257 nla_put_u32(skb
, L2TP_ATTR_PEER_CONN_ID
, tunnel
->peer_tunnel_id
) ||
258 nla_put_u32(skb
, L2TP_ATTR_DEBUG
, tunnel
->debug
) ||
259 nla_put_u16(skb
, L2TP_ATTR_ENCAP_TYPE
, tunnel
->encap
))
260 goto nla_put_failure
;
262 nest
= nla_nest_start(skb
, L2TP_ATTR_STATS
);
264 goto nla_put_failure
;
266 if (nla_put_u64(skb
, L2TP_ATTR_TX_PACKETS
,
267 atomic_long_read(&tunnel
->stats
.tx_packets
)) ||
268 nla_put_u64(skb
, L2TP_ATTR_TX_BYTES
,
269 atomic_long_read(&tunnel
->stats
.tx_bytes
)) ||
270 nla_put_u64(skb
, L2TP_ATTR_TX_ERRORS
,
271 atomic_long_read(&tunnel
->stats
.tx_errors
)) ||
272 nla_put_u64(skb
, L2TP_ATTR_RX_PACKETS
,
273 atomic_long_read(&tunnel
->stats
.rx_packets
)) ||
274 nla_put_u64(skb
, L2TP_ATTR_RX_BYTES
,
275 atomic_long_read(&tunnel
->stats
.rx_bytes
)) ||
276 nla_put_u64(skb
, L2TP_ATTR_RX_SEQ_DISCARDS
,
277 atomic_long_read(&tunnel
->stats
.rx_seq_discards
)) ||
278 nla_put_u64(skb
, L2TP_ATTR_RX_OOS_PACKETS
,
279 atomic_long_read(&tunnel
->stats
.rx_oos_packets
)) ||
280 nla_put_u64(skb
, L2TP_ATTR_RX_ERRORS
,
281 atomic_long_read(&tunnel
->stats
.rx_errors
)))
282 goto nla_put_failure
;
283 nla_nest_end(skb
, nest
);
289 #if IS_ENABLED(CONFIG_IPV6)
290 if (sk
->sk_family
== AF_INET6
)
296 switch (tunnel
->encap
) {
297 case L2TP_ENCAPTYPE_UDP
:
298 if (nla_put_u16(skb
, L2TP_ATTR_UDP_SPORT
, ntohs(inet
->inet_sport
)) ||
299 nla_put_u16(skb
, L2TP_ATTR_UDP_DPORT
, ntohs(inet
->inet_dport
)) ||
300 nla_put_u8(skb
, L2TP_ATTR_UDP_CSUM
, !sk
->sk_no_check_tx
))
301 goto nla_put_failure
;
303 case L2TP_ENCAPTYPE_IP
:
304 #if IS_ENABLED(CONFIG_IPV6)
306 if (nla_put(skb
, L2TP_ATTR_IP6_SADDR
, sizeof(np
->saddr
),
308 nla_put(skb
, L2TP_ATTR_IP6_DADDR
, sizeof(sk
->sk_v6_daddr
),
310 goto nla_put_failure
;
313 if (nla_put_be32(skb
, L2TP_ATTR_IP_SADDR
, inet
->inet_saddr
) ||
314 nla_put_be32(skb
, L2TP_ATTR_IP_DADDR
, inet
->inet_daddr
))
315 goto nla_put_failure
;
320 return genlmsg_end(skb
, hdr
);
323 genlmsg_cancel(skb
, hdr
);
327 static int l2tp_nl_cmd_tunnel_get(struct sk_buff
*skb
, struct genl_info
*info
)
329 struct l2tp_tunnel
*tunnel
;
333 struct net
*net
= genl_info_net(info
);
335 if (!info
->attrs
[L2TP_ATTR_CONN_ID
]) {
340 tunnel_id
= nla_get_u32(info
->attrs
[L2TP_ATTR_CONN_ID
]);
342 tunnel
= l2tp_tunnel_find(net
, tunnel_id
);
343 if (tunnel
== NULL
) {
348 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
354 ret
= l2tp_nl_tunnel_send(msg
, info
->snd_portid
, info
->snd_seq
,
359 return genlmsg_unicast(net
, msg
, info
->snd_portid
);
368 static int l2tp_nl_cmd_tunnel_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
370 int ti
= cb
->args
[0];
371 struct l2tp_tunnel
*tunnel
;
372 struct net
*net
= sock_net(skb
->sk
);
375 tunnel
= l2tp_tunnel_find_nth(net
, ti
);
379 if (l2tp_nl_tunnel_send(skb
, NETLINK_CB(cb
->skb
).portid
,
380 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
393 static int l2tp_nl_cmd_session_create(struct sk_buff
*skb
, struct genl_info
*info
)
399 struct l2tp_tunnel
*tunnel
;
400 struct l2tp_session
*session
;
401 struct l2tp_session_cfg cfg
= { 0, };
402 struct net
*net
= genl_info_net(info
);
404 if (!info
->attrs
[L2TP_ATTR_CONN_ID
]) {
408 tunnel_id
= nla_get_u32(info
->attrs
[L2TP_ATTR_CONN_ID
]);
409 tunnel
= l2tp_tunnel_find(net
, tunnel_id
);
415 if (!info
->attrs
[L2TP_ATTR_SESSION_ID
]) {
419 session_id
= nla_get_u32(info
->attrs
[L2TP_ATTR_SESSION_ID
]);
420 session
= l2tp_session_find(net
, tunnel
, session_id
);
426 if (!info
->attrs
[L2TP_ATTR_PEER_SESSION_ID
]) {
430 peer_session_id
= nla_get_u32(info
->attrs
[L2TP_ATTR_PEER_SESSION_ID
]);
432 if (!info
->attrs
[L2TP_ATTR_PW_TYPE
]) {
436 cfg
.pw_type
= nla_get_u16(info
->attrs
[L2TP_ATTR_PW_TYPE
]);
437 if (cfg
.pw_type
>= __L2TP_PWTYPE_MAX
) {
442 if (tunnel
->version
> 2) {
443 if (info
->attrs
[L2TP_ATTR_OFFSET
])
444 cfg
.offset
= nla_get_u16(info
->attrs
[L2TP_ATTR_OFFSET
]);
446 if (info
->attrs
[L2TP_ATTR_DATA_SEQ
])
447 cfg
.data_seq
= nla_get_u8(info
->attrs
[L2TP_ATTR_DATA_SEQ
]);
449 cfg
.l2specific_type
= L2TP_L2SPECTYPE_DEFAULT
;
450 if (info
->attrs
[L2TP_ATTR_L2SPEC_TYPE
])
451 cfg
.l2specific_type
= nla_get_u8(info
->attrs
[L2TP_ATTR_L2SPEC_TYPE
]);
453 cfg
.l2specific_len
= 4;
454 if (info
->attrs
[L2TP_ATTR_L2SPEC_LEN
])
455 cfg
.l2specific_len
= nla_get_u8(info
->attrs
[L2TP_ATTR_L2SPEC_LEN
]);
457 if (info
->attrs
[L2TP_ATTR_COOKIE
]) {
458 u16 len
= nla_len(info
->attrs
[L2TP_ATTR_COOKIE
]);
463 cfg
.cookie_len
= len
;
464 memcpy(&cfg
.cookie
[0], nla_data(info
->attrs
[L2TP_ATTR_COOKIE
]), len
);
466 if (info
->attrs
[L2TP_ATTR_PEER_COOKIE
]) {
467 u16 len
= nla_len(info
->attrs
[L2TP_ATTR_PEER_COOKIE
]);
472 cfg
.peer_cookie_len
= len
;
473 memcpy(&cfg
.peer_cookie
[0], nla_data(info
->attrs
[L2TP_ATTR_PEER_COOKIE
]), len
);
475 if (info
->attrs
[L2TP_ATTR_IFNAME
])
476 cfg
.ifname
= nla_data(info
->attrs
[L2TP_ATTR_IFNAME
]);
478 if (info
->attrs
[L2TP_ATTR_VLAN_ID
])
479 cfg
.vlan_id
= nla_get_u16(info
->attrs
[L2TP_ATTR_VLAN_ID
]);
482 if (info
->attrs
[L2TP_ATTR_DEBUG
])
483 cfg
.debug
= nla_get_u32(info
->attrs
[L2TP_ATTR_DEBUG
]);
485 if (info
->attrs
[L2TP_ATTR_RECV_SEQ
])
486 cfg
.recv_seq
= nla_get_u8(info
->attrs
[L2TP_ATTR_RECV_SEQ
]);
488 if (info
->attrs
[L2TP_ATTR_SEND_SEQ
])
489 cfg
.send_seq
= nla_get_u8(info
->attrs
[L2TP_ATTR_SEND_SEQ
]);
491 if (info
->attrs
[L2TP_ATTR_LNS_MODE
])
492 cfg
.lns_mode
= nla_get_u8(info
->attrs
[L2TP_ATTR_LNS_MODE
]);
494 if (info
->attrs
[L2TP_ATTR_RECV_TIMEOUT
])
495 cfg
.reorder_timeout
= nla_get_msecs(info
->attrs
[L2TP_ATTR_RECV_TIMEOUT
]);
497 if (info
->attrs
[L2TP_ATTR_MTU
])
498 cfg
.mtu
= nla_get_u16(info
->attrs
[L2TP_ATTR_MTU
]);
500 if (info
->attrs
[L2TP_ATTR_MRU
])
501 cfg
.mru
= nla_get_u16(info
->attrs
[L2TP_ATTR_MRU
]);
503 if ((l2tp_nl_cmd_ops
[cfg
.pw_type
] == NULL
) ||
504 (l2tp_nl_cmd_ops
[cfg
.pw_type
]->session_create
== NULL
)) {
505 ret
= -EPROTONOSUPPORT
;
509 /* Check that pseudowire-specific params are present */
510 switch (cfg
.pw_type
) {
511 case L2TP_PWTYPE_NONE
:
513 case L2TP_PWTYPE_ETH_VLAN
:
514 if (!info
->attrs
[L2TP_ATTR_VLAN_ID
]) {
519 case L2TP_PWTYPE_ETH
:
521 case L2TP_PWTYPE_PPP
:
522 case L2TP_PWTYPE_PPP_AC
:
526 ret
= -EPROTONOSUPPORT
;
530 ret
= -EPROTONOSUPPORT
;
531 if (l2tp_nl_cmd_ops
[cfg
.pw_type
]->session_create
)
532 ret
= (*l2tp_nl_cmd_ops
[cfg
.pw_type
]->session_create
)(net
, tunnel_id
,
533 session_id
, peer_session_id
, &cfg
);
539 static int l2tp_nl_cmd_session_delete(struct sk_buff
*skb
, struct genl_info
*info
)
542 struct l2tp_session
*session
;
545 session
= l2tp_nl_session_find(info
);
546 if (session
== NULL
) {
551 pw_type
= session
->pwtype
;
552 if (pw_type
< __L2TP_PWTYPE_MAX
)
553 if (l2tp_nl_cmd_ops
[pw_type
] && l2tp_nl_cmd_ops
[pw_type
]->session_delete
)
554 ret
= (*l2tp_nl_cmd_ops
[pw_type
]->session_delete
)(session
);
560 static int l2tp_nl_cmd_session_modify(struct sk_buff
*skb
, struct genl_info
*info
)
563 struct l2tp_session
*session
;
565 session
= l2tp_nl_session_find(info
);
566 if (session
== NULL
) {
571 if (info
->attrs
[L2TP_ATTR_DEBUG
])
572 session
->debug
= nla_get_u32(info
->attrs
[L2TP_ATTR_DEBUG
]);
574 if (info
->attrs
[L2TP_ATTR_DATA_SEQ
])
575 session
->data_seq
= nla_get_u8(info
->attrs
[L2TP_ATTR_DATA_SEQ
]);
577 if (info
->attrs
[L2TP_ATTR_RECV_SEQ
])
578 session
->recv_seq
= nla_get_u8(info
->attrs
[L2TP_ATTR_RECV_SEQ
]);
580 if (info
->attrs
[L2TP_ATTR_SEND_SEQ
]) {
581 session
->send_seq
= nla_get_u8(info
->attrs
[L2TP_ATTR_SEND_SEQ
]);
582 l2tp_session_set_header_len(session
, session
->tunnel
->version
);
585 if (info
->attrs
[L2TP_ATTR_LNS_MODE
])
586 session
->lns_mode
= nla_get_u8(info
->attrs
[L2TP_ATTR_LNS_MODE
]);
588 if (info
->attrs
[L2TP_ATTR_RECV_TIMEOUT
])
589 session
->reorder_timeout
= nla_get_msecs(info
->attrs
[L2TP_ATTR_RECV_TIMEOUT
]);
591 if (info
->attrs
[L2TP_ATTR_MTU
])
592 session
->mtu
= nla_get_u16(info
->attrs
[L2TP_ATTR_MTU
]);
594 if (info
->attrs
[L2TP_ATTR_MRU
])
595 session
->mru
= nla_get_u16(info
->attrs
[L2TP_ATTR_MRU
]);
601 static int l2tp_nl_session_send(struct sk_buff
*skb
, u32 portid
, u32 seq
, int flags
,
602 struct l2tp_session
*session
)
606 struct l2tp_tunnel
*tunnel
= session
->tunnel
;
607 struct sock
*sk
= NULL
;
611 hdr
= genlmsg_put(skb
, portid
, seq
, &l2tp_nl_family
, flags
, L2TP_CMD_SESSION_GET
);
615 if (nla_put_u32(skb
, L2TP_ATTR_CONN_ID
, tunnel
->tunnel_id
) ||
616 nla_put_u32(skb
, L2TP_ATTR_SESSION_ID
, session
->session_id
) ||
617 nla_put_u32(skb
, L2TP_ATTR_PEER_CONN_ID
, tunnel
->peer_tunnel_id
) ||
618 nla_put_u32(skb
, L2TP_ATTR_PEER_SESSION_ID
,
619 session
->peer_session_id
) ||
620 nla_put_u32(skb
, L2TP_ATTR_DEBUG
, session
->debug
) ||
621 nla_put_u16(skb
, L2TP_ATTR_PW_TYPE
, session
->pwtype
) ||
622 nla_put_u16(skb
, L2TP_ATTR_MTU
, session
->mtu
) ||
624 nla_put_u16(skb
, L2TP_ATTR_MRU
, session
->mru
)))
625 goto nla_put_failure
;
627 if ((session
->ifname
[0] &&
628 nla_put_string(skb
, L2TP_ATTR_IFNAME
, session
->ifname
)) ||
629 (session
->cookie_len
&&
630 nla_put(skb
, L2TP_ATTR_COOKIE
, session
->cookie_len
,
631 &session
->cookie
[0])) ||
632 (session
->peer_cookie_len
&&
633 nla_put(skb
, L2TP_ATTR_PEER_COOKIE
, session
->peer_cookie_len
,
634 &session
->peer_cookie
[0])) ||
635 nla_put_u8(skb
, L2TP_ATTR_RECV_SEQ
, session
->recv_seq
) ||
636 nla_put_u8(skb
, L2TP_ATTR_SEND_SEQ
, session
->send_seq
) ||
637 nla_put_u8(skb
, L2TP_ATTR_LNS_MODE
, session
->lns_mode
) ||
639 (((sk
) && (sk
->sk_policy
[0] || sk
->sk_policy
[1])) &&
640 nla_put_u8(skb
, L2TP_ATTR_USING_IPSEC
, 1)) ||
642 (session
->reorder_timeout
&&
643 nla_put_msecs(skb
, L2TP_ATTR_RECV_TIMEOUT
, session
->reorder_timeout
)))
644 goto nla_put_failure
;
646 nest
= nla_nest_start(skb
, L2TP_ATTR_STATS
);
648 goto nla_put_failure
;
650 if (nla_put_u64(skb
, L2TP_ATTR_TX_PACKETS
,
651 atomic_long_read(&session
->stats
.tx_packets
)) ||
652 nla_put_u64(skb
, L2TP_ATTR_TX_BYTES
,
653 atomic_long_read(&session
->stats
.tx_bytes
)) ||
654 nla_put_u64(skb
, L2TP_ATTR_TX_ERRORS
,
655 atomic_long_read(&session
->stats
.tx_errors
)) ||
656 nla_put_u64(skb
, L2TP_ATTR_RX_PACKETS
,
657 atomic_long_read(&session
->stats
.rx_packets
)) ||
658 nla_put_u64(skb
, L2TP_ATTR_RX_BYTES
,
659 atomic_long_read(&session
->stats
.rx_bytes
)) ||
660 nla_put_u64(skb
, L2TP_ATTR_RX_SEQ_DISCARDS
,
661 atomic_long_read(&session
->stats
.rx_seq_discards
)) ||
662 nla_put_u64(skb
, L2TP_ATTR_RX_OOS_PACKETS
,
663 atomic_long_read(&session
->stats
.rx_oos_packets
)) ||
664 nla_put_u64(skb
, L2TP_ATTR_RX_ERRORS
,
665 atomic_long_read(&session
->stats
.rx_errors
)))
666 goto nla_put_failure
;
667 nla_nest_end(skb
, nest
);
669 return genlmsg_end(skb
, hdr
);
672 genlmsg_cancel(skb
, hdr
);
676 static int l2tp_nl_cmd_session_get(struct sk_buff
*skb
, struct genl_info
*info
)
678 struct l2tp_session
*session
;
682 session
= l2tp_nl_session_find(info
);
683 if (session
== NULL
) {
688 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
694 ret
= l2tp_nl_session_send(msg
, info
->snd_portid
, info
->snd_seq
,
699 return genlmsg_unicast(genl_info_net(info
), msg
, info
->snd_portid
);
708 static int l2tp_nl_cmd_session_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
710 struct net
*net
= sock_net(skb
->sk
);
711 struct l2tp_session
*session
;
712 struct l2tp_tunnel
*tunnel
= NULL
;
713 int ti
= cb
->args
[0];
714 int si
= cb
->args
[1];
717 if (tunnel
== NULL
) {
718 tunnel
= l2tp_tunnel_find_nth(net
, ti
);
723 session
= l2tp_session_find_nth(tunnel
, si
);
724 if (session
== NULL
) {
731 if (l2tp_nl_session_send(skb
, NETLINK_CB(cb
->skb
).portid
,
732 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
746 static struct nla_policy l2tp_nl_policy
[L2TP_ATTR_MAX
+ 1] = {
747 [L2TP_ATTR_NONE
] = { .type
= NLA_UNSPEC
, },
748 [L2TP_ATTR_PW_TYPE
] = { .type
= NLA_U16
, },
749 [L2TP_ATTR_ENCAP_TYPE
] = { .type
= NLA_U16
, },
750 [L2TP_ATTR_OFFSET
] = { .type
= NLA_U16
, },
751 [L2TP_ATTR_DATA_SEQ
] = { .type
= NLA_U8
, },
752 [L2TP_ATTR_L2SPEC_TYPE
] = { .type
= NLA_U8
, },
753 [L2TP_ATTR_L2SPEC_LEN
] = { .type
= NLA_U8
, },
754 [L2TP_ATTR_PROTO_VERSION
] = { .type
= NLA_U8
, },
755 [L2TP_ATTR_CONN_ID
] = { .type
= NLA_U32
, },
756 [L2TP_ATTR_PEER_CONN_ID
] = { .type
= NLA_U32
, },
757 [L2TP_ATTR_SESSION_ID
] = { .type
= NLA_U32
, },
758 [L2TP_ATTR_PEER_SESSION_ID
] = { .type
= NLA_U32
, },
759 [L2TP_ATTR_UDP_CSUM
] = { .type
= NLA_U8
, },
760 [L2TP_ATTR_VLAN_ID
] = { .type
= NLA_U16
, },
761 [L2TP_ATTR_DEBUG
] = { .type
= NLA_U32
, },
762 [L2TP_ATTR_RECV_SEQ
] = { .type
= NLA_U8
, },
763 [L2TP_ATTR_SEND_SEQ
] = { .type
= NLA_U8
, },
764 [L2TP_ATTR_LNS_MODE
] = { .type
= NLA_U8
, },
765 [L2TP_ATTR_USING_IPSEC
] = { .type
= NLA_U8
, },
766 [L2TP_ATTR_RECV_TIMEOUT
] = { .type
= NLA_MSECS
, },
767 [L2TP_ATTR_FD
] = { .type
= NLA_U32
, },
768 [L2TP_ATTR_IP_SADDR
] = { .type
= NLA_U32
, },
769 [L2TP_ATTR_IP_DADDR
] = { .type
= NLA_U32
, },
770 [L2TP_ATTR_UDP_SPORT
] = { .type
= NLA_U16
, },
771 [L2TP_ATTR_UDP_DPORT
] = { .type
= NLA_U16
, },
772 [L2TP_ATTR_MTU
] = { .type
= NLA_U16
, },
773 [L2TP_ATTR_MRU
] = { .type
= NLA_U16
, },
774 [L2TP_ATTR_STATS
] = { .type
= NLA_NESTED
, },
775 [L2TP_ATTR_IP6_SADDR
] = {
777 .len
= sizeof(struct in6_addr
),
779 [L2TP_ATTR_IP6_DADDR
] = {
781 .len
= sizeof(struct in6_addr
),
783 [L2TP_ATTR_IFNAME
] = {
784 .type
= NLA_NUL_STRING
,
787 [L2TP_ATTR_COOKIE
] = {
791 [L2TP_ATTR_PEER_COOKIE
] = {
797 static const struct genl_ops l2tp_nl_ops
[] = {
799 .cmd
= L2TP_CMD_NOOP
,
800 .doit
= l2tp_nl_cmd_noop
,
801 .policy
= l2tp_nl_policy
,
802 /* can be retrieved by unprivileged users */
805 .cmd
= L2TP_CMD_TUNNEL_CREATE
,
806 .doit
= l2tp_nl_cmd_tunnel_create
,
807 .policy
= l2tp_nl_policy
,
808 .flags
= GENL_ADMIN_PERM
,
811 .cmd
= L2TP_CMD_TUNNEL_DELETE
,
812 .doit
= l2tp_nl_cmd_tunnel_delete
,
813 .policy
= l2tp_nl_policy
,
814 .flags
= GENL_ADMIN_PERM
,
817 .cmd
= L2TP_CMD_TUNNEL_MODIFY
,
818 .doit
= l2tp_nl_cmd_tunnel_modify
,
819 .policy
= l2tp_nl_policy
,
820 .flags
= GENL_ADMIN_PERM
,
823 .cmd
= L2TP_CMD_TUNNEL_GET
,
824 .doit
= l2tp_nl_cmd_tunnel_get
,
825 .dumpit
= l2tp_nl_cmd_tunnel_dump
,
826 .policy
= l2tp_nl_policy
,
827 .flags
= GENL_ADMIN_PERM
,
830 .cmd
= L2TP_CMD_SESSION_CREATE
,
831 .doit
= l2tp_nl_cmd_session_create
,
832 .policy
= l2tp_nl_policy
,
833 .flags
= GENL_ADMIN_PERM
,
836 .cmd
= L2TP_CMD_SESSION_DELETE
,
837 .doit
= l2tp_nl_cmd_session_delete
,
838 .policy
= l2tp_nl_policy
,
839 .flags
= GENL_ADMIN_PERM
,
842 .cmd
= L2TP_CMD_SESSION_MODIFY
,
843 .doit
= l2tp_nl_cmd_session_modify
,
844 .policy
= l2tp_nl_policy
,
845 .flags
= GENL_ADMIN_PERM
,
848 .cmd
= L2TP_CMD_SESSION_GET
,
849 .doit
= l2tp_nl_cmd_session_get
,
850 .dumpit
= l2tp_nl_cmd_session_dump
,
851 .policy
= l2tp_nl_policy
,
852 .flags
= GENL_ADMIN_PERM
,
856 int l2tp_nl_register_ops(enum l2tp_pwtype pw_type
, const struct l2tp_nl_cmd_ops
*ops
)
861 if (pw_type
>= __L2TP_PWTYPE_MAX
)
866 if (l2tp_nl_cmd_ops
[pw_type
])
869 l2tp_nl_cmd_ops
[pw_type
] = ops
;
877 EXPORT_SYMBOL_GPL(l2tp_nl_register_ops
);
879 void l2tp_nl_unregister_ops(enum l2tp_pwtype pw_type
)
881 if (pw_type
< __L2TP_PWTYPE_MAX
) {
883 l2tp_nl_cmd_ops
[pw_type
] = NULL
;
887 EXPORT_SYMBOL_GPL(l2tp_nl_unregister_ops
);
889 static int l2tp_nl_init(void)
891 pr_info("L2TP netlink interface\n");
892 return genl_register_family_with_ops(&l2tp_nl_family
, l2tp_nl_ops
);
895 static void l2tp_nl_cleanup(void)
897 genl_unregister_family(&l2tp_nl_family
);
900 module_init(l2tp_nl_init
);
901 module_exit(l2tp_nl_cleanup
);
903 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
904 MODULE_DESCRIPTION("L2TP netlink");
905 MODULE_LICENSE("GPL");
906 MODULE_VERSION("1.0");
907 MODULE_ALIAS_GENL_FAMILY("l2tp");