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
,
301 (sk
->sk_no_check
!= UDP_CSUM_NOXMIT
)))
302 goto nla_put_failure
;
304 case L2TP_ENCAPTYPE_IP
:
305 #if IS_ENABLED(CONFIG_IPV6)
307 if (nla_put(skb
, L2TP_ATTR_IP6_SADDR
, sizeof(np
->saddr
),
309 nla_put(skb
, L2TP_ATTR_IP6_DADDR
, sizeof(sk
->sk_v6_daddr
),
311 goto nla_put_failure
;
314 if (nla_put_be32(skb
, L2TP_ATTR_IP_SADDR
, inet
->inet_saddr
) ||
315 nla_put_be32(skb
, L2TP_ATTR_IP_DADDR
, inet
->inet_daddr
))
316 goto nla_put_failure
;
321 return genlmsg_end(skb
, hdr
);
324 genlmsg_cancel(skb
, hdr
);
328 static int l2tp_nl_cmd_tunnel_get(struct sk_buff
*skb
, struct genl_info
*info
)
330 struct l2tp_tunnel
*tunnel
;
334 struct net
*net
= genl_info_net(info
);
336 if (!info
->attrs
[L2TP_ATTR_CONN_ID
]) {
341 tunnel_id
= nla_get_u32(info
->attrs
[L2TP_ATTR_CONN_ID
]);
343 tunnel
= l2tp_tunnel_find(net
, tunnel_id
);
344 if (tunnel
== NULL
) {
349 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
355 ret
= l2tp_nl_tunnel_send(msg
, info
->snd_portid
, info
->snd_seq
,
360 return genlmsg_unicast(net
, msg
, info
->snd_portid
);
369 static int l2tp_nl_cmd_tunnel_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
371 int ti
= cb
->args
[0];
372 struct l2tp_tunnel
*tunnel
;
373 struct net
*net
= sock_net(skb
->sk
);
376 tunnel
= l2tp_tunnel_find_nth(net
, ti
);
380 if (l2tp_nl_tunnel_send(skb
, NETLINK_CB(cb
->skb
).portid
,
381 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
394 static int l2tp_nl_cmd_session_create(struct sk_buff
*skb
, struct genl_info
*info
)
400 struct l2tp_tunnel
*tunnel
;
401 struct l2tp_session
*session
;
402 struct l2tp_session_cfg cfg
= { 0, };
403 struct net
*net
= genl_info_net(info
);
405 if (!info
->attrs
[L2TP_ATTR_CONN_ID
]) {
409 tunnel_id
= nla_get_u32(info
->attrs
[L2TP_ATTR_CONN_ID
]);
410 tunnel
= l2tp_tunnel_find(net
, tunnel_id
);
416 if (!info
->attrs
[L2TP_ATTR_SESSION_ID
]) {
420 session_id
= nla_get_u32(info
->attrs
[L2TP_ATTR_SESSION_ID
]);
421 session
= l2tp_session_find(net
, tunnel
, session_id
);
427 if (!info
->attrs
[L2TP_ATTR_PEER_SESSION_ID
]) {
431 peer_session_id
= nla_get_u32(info
->attrs
[L2TP_ATTR_PEER_SESSION_ID
]);
433 if (!info
->attrs
[L2TP_ATTR_PW_TYPE
]) {
437 cfg
.pw_type
= nla_get_u16(info
->attrs
[L2TP_ATTR_PW_TYPE
]);
438 if (cfg
.pw_type
>= __L2TP_PWTYPE_MAX
) {
443 if (tunnel
->version
> 2) {
444 if (info
->attrs
[L2TP_ATTR_OFFSET
])
445 cfg
.offset
= nla_get_u16(info
->attrs
[L2TP_ATTR_OFFSET
]);
447 if (info
->attrs
[L2TP_ATTR_DATA_SEQ
])
448 cfg
.data_seq
= nla_get_u8(info
->attrs
[L2TP_ATTR_DATA_SEQ
]);
450 cfg
.l2specific_type
= L2TP_L2SPECTYPE_DEFAULT
;
451 if (info
->attrs
[L2TP_ATTR_L2SPEC_TYPE
])
452 cfg
.l2specific_type
= nla_get_u8(info
->attrs
[L2TP_ATTR_L2SPEC_TYPE
]);
454 cfg
.l2specific_len
= 4;
455 if (info
->attrs
[L2TP_ATTR_L2SPEC_LEN
])
456 cfg
.l2specific_len
= nla_get_u8(info
->attrs
[L2TP_ATTR_L2SPEC_LEN
]);
458 if (info
->attrs
[L2TP_ATTR_COOKIE
]) {
459 u16 len
= nla_len(info
->attrs
[L2TP_ATTR_COOKIE
]);
464 cfg
.cookie_len
= len
;
465 memcpy(&cfg
.cookie
[0], nla_data(info
->attrs
[L2TP_ATTR_COOKIE
]), len
);
467 if (info
->attrs
[L2TP_ATTR_PEER_COOKIE
]) {
468 u16 len
= nla_len(info
->attrs
[L2TP_ATTR_PEER_COOKIE
]);
473 cfg
.peer_cookie_len
= len
;
474 memcpy(&cfg
.peer_cookie
[0], nla_data(info
->attrs
[L2TP_ATTR_PEER_COOKIE
]), len
);
476 if (info
->attrs
[L2TP_ATTR_IFNAME
])
477 cfg
.ifname
= nla_data(info
->attrs
[L2TP_ATTR_IFNAME
]);
479 if (info
->attrs
[L2TP_ATTR_VLAN_ID
])
480 cfg
.vlan_id
= nla_get_u16(info
->attrs
[L2TP_ATTR_VLAN_ID
]);
483 if (info
->attrs
[L2TP_ATTR_DEBUG
])
484 cfg
.debug
= nla_get_u32(info
->attrs
[L2TP_ATTR_DEBUG
]);
486 if (info
->attrs
[L2TP_ATTR_RECV_SEQ
])
487 cfg
.recv_seq
= nla_get_u8(info
->attrs
[L2TP_ATTR_RECV_SEQ
]);
489 if (info
->attrs
[L2TP_ATTR_SEND_SEQ
])
490 cfg
.send_seq
= nla_get_u8(info
->attrs
[L2TP_ATTR_SEND_SEQ
]);
492 if (info
->attrs
[L2TP_ATTR_LNS_MODE
])
493 cfg
.lns_mode
= nla_get_u8(info
->attrs
[L2TP_ATTR_LNS_MODE
]);
495 if (info
->attrs
[L2TP_ATTR_RECV_TIMEOUT
])
496 cfg
.reorder_timeout
= nla_get_msecs(info
->attrs
[L2TP_ATTR_RECV_TIMEOUT
]);
498 if (info
->attrs
[L2TP_ATTR_MTU
])
499 cfg
.mtu
= nla_get_u16(info
->attrs
[L2TP_ATTR_MTU
]);
501 if (info
->attrs
[L2TP_ATTR_MRU
])
502 cfg
.mru
= nla_get_u16(info
->attrs
[L2TP_ATTR_MRU
]);
504 if ((l2tp_nl_cmd_ops
[cfg
.pw_type
] == NULL
) ||
505 (l2tp_nl_cmd_ops
[cfg
.pw_type
]->session_create
== NULL
)) {
506 ret
= -EPROTONOSUPPORT
;
510 /* Check that pseudowire-specific params are present */
511 switch (cfg
.pw_type
) {
512 case L2TP_PWTYPE_NONE
:
514 case L2TP_PWTYPE_ETH_VLAN
:
515 if (!info
->attrs
[L2TP_ATTR_VLAN_ID
]) {
520 case L2TP_PWTYPE_ETH
:
522 case L2TP_PWTYPE_PPP
:
523 case L2TP_PWTYPE_PPP_AC
:
527 ret
= -EPROTONOSUPPORT
;
531 ret
= -EPROTONOSUPPORT
;
532 if (l2tp_nl_cmd_ops
[cfg
.pw_type
]->session_create
)
533 ret
= (*l2tp_nl_cmd_ops
[cfg
.pw_type
]->session_create
)(net
, tunnel_id
,
534 session_id
, peer_session_id
, &cfg
);
540 static int l2tp_nl_cmd_session_delete(struct sk_buff
*skb
, struct genl_info
*info
)
543 struct l2tp_session
*session
;
546 session
= l2tp_nl_session_find(info
);
547 if (session
== NULL
) {
552 pw_type
= session
->pwtype
;
553 if (pw_type
< __L2TP_PWTYPE_MAX
)
554 if (l2tp_nl_cmd_ops
[pw_type
] && l2tp_nl_cmd_ops
[pw_type
]->session_delete
)
555 ret
= (*l2tp_nl_cmd_ops
[pw_type
]->session_delete
)(session
);
561 static int l2tp_nl_cmd_session_modify(struct sk_buff
*skb
, struct genl_info
*info
)
564 struct l2tp_session
*session
;
566 session
= l2tp_nl_session_find(info
);
567 if (session
== NULL
) {
572 if (info
->attrs
[L2TP_ATTR_DEBUG
])
573 session
->debug
= nla_get_u32(info
->attrs
[L2TP_ATTR_DEBUG
]);
575 if (info
->attrs
[L2TP_ATTR_DATA_SEQ
])
576 session
->data_seq
= nla_get_u8(info
->attrs
[L2TP_ATTR_DATA_SEQ
]);
578 if (info
->attrs
[L2TP_ATTR_RECV_SEQ
])
579 session
->recv_seq
= nla_get_u8(info
->attrs
[L2TP_ATTR_RECV_SEQ
]);
581 if (info
->attrs
[L2TP_ATTR_SEND_SEQ
]) {
582 session
->send_seq
= nla_get_u8(info
->attrs
[L2TP_ATTR_SEND_SEQ
]);
583 l2tp_session_set_header_len(session
, session
->tunnel
->version
);
586 if (info
->attrs
[L2TP_ATTR_LNS_MODE
])
587 session
->lns_mode
= nla_get_u8(info
->attrs
[L2TP_ATTR_LNS_MODE
]);
589 if (info
->attrs
[L2TP_ATTR_RECV_TIMEOUT
])
590 session
->reorder_timeout
= nla_get_msecs(info
->attrs
[L2TP_ATTR_RECV_TIMEOUT
]);
592 if (info
->attrs
[L2TP_ATTR_MTU
])
593 session
->mtu
= nla_get_u16(info
->attrs
[L2TP_ATTR_MTU
]);
595 if (info
->attrs
[L2TP_ATTR_MRU
])
596 session
->mru
= nla_get_u16(info
->attrs
[L2TP_ATTR_MRU
]);
602 static int l2tp_nl_session_send(struct sk_buff
*skb
, u32 portid
, u32 seq
, int flags
,
603 struct l2tp_session
*session
)
607 struct l2tp_tunnel
*tunnel
= session
->tunnel
;
608 struct sock
*sk
= NULL
;
612 hdr
= genlmsg_put(skb
, portid
, seq
, &l2tp_nl_family
, flags
, L2TP_CMD_SESSION_GET
);
616 if (nla_put_u32(skb
, L2TP_ATTR_CONN_ID
, tunnel
->tunnel_id
) ||
617 nla_put_u32(skb
, L2TP_ATTR_SESSION_ID
, session
->session_id
) ||
618 nla_put_u32(skb
, L2TP_ATTR_PEER_CONN_ID
, tunnel
->peer_tunnel_id
) ||
619 nla_put_u32(skb
, L2TP_ATTR_PEER_SESSION_ID
,
620 session
->peer_session_id
) ||
621 nla_put_u32(skb
, L2TP_ATTR_DEBUG
, session
->debug
) ||
622 nla_put_u16(skb
, L2TP_ATTR_PW_TYPE
, session
->pwtype
) ||
623 nla_put_u16(skb
, L2TP_ATTR_MTU
, session
->mtu
) ||
625 nla_put_u16(skb
, L2TP_ATTR_MRU
, session
->mru
)))
626 goto nla_put_failure
;
628 if ((session
->ifname
[0] &&
629 nla_put_string(skb
, L2TP_ATTR_IFNAME
, session
->ifname
)) ||
630 (session
->cookie_len
&&
631 nla_put(skb
, L2TP_ATTR_COOKIE
, session
->cookie_len
,
632 &session
->cookie
[0])) ||
633 (session
->peer_cookie_len
&&
634 nla_put(skb
, L2TP_ATTR_PEER_COOKIE
, session
->peer_cookie_len
,
635 &session
->peer_cookie
[0])) ||
636 nla_put_u8(skb
, L2TP_ATTR_RECV_SEQ
, session
->recv_seq
) ||
637 nla_put_u8(skb
, L2TP_ATTR_SEND_SEQ
, session
->send_seq
) ||
638 nla_put_u8(skb
, L2TP_ATTR_LNS_MODE
, session
->lns_mode
) ||
640 (((sk
) && (sk
->sk_policy
[0] || sk
->sk_policy
[1])) &&
641 nla_put_u8(skb
, L2TP_ATTR_USING_IPSEC
, 1)) ||
643 (session
->reorder_timeout
&&
644 nla_put_msecs(skb
, L2TP_ATTR_RECV_TIMEOUT
, session
->reorder_timeout
)))
645 goto nla_put_failure
;
647 nest
= nla_nest_start(skb
, L2TP_ATTR_STATS
);
649 goto nla_put_failure
;
651 if (nla_put_u64(skb
, L2TP_ATTR_TX_PACKETS
,
652 atomic_long_read(&session
->stats
.tx_packets
)) ||
653 nla_put_u64(skb
, L2TP_ATTR_TX_BYTES
,
654 atomic_long_read(&session
->stats
.tx_bytes
)) ||
655 nla_put_u64(skb
, L2TP_ATTR_TX_ERRORS
,
656 atomic_long_read(&session
->stats
.tx_errors
)) ||
657 nla_put_u64(skb
, L2TP_ATTR_RX_PACKETS
,
658 atomic_long_read(&session
->stats
.rx_packets
)) ||
659 nla_put_u64(skb
, L2TP_ATTR_RX_BYTES
,
660 atomic_long_read(&session
->stats
.rx_bytes
)) ||
661 nla_put_u64(skb
, L2TP_ATTR_RX_SEQ_DISCARDS
,
662 atomic_long_read(&session
->stats
.rx_seq_discards
)) ||
663 nla_put_u64(skb
, L2TP_ATTR_RX_OOS_PACKETS
,
664 atomic_long_read(&session
->stats
.rx_oos_packets
)) ||
665 nla_put_u64(skb
, L2TP_ATTR_RX_ERRORS
,
666 atomic_long_read(&session
->stats
.rx_errors
)))
667 goto nla_put_failure
;
668 nla_nest_end(skb
, nest
);
670 return genlmsg_end(skb
, hdr
);
673 genlmsg_cancel(skb
, hdr
);
677 static int l2tp_nl_cmd_session_get(struct sk_buff
*skb
, struct genl_info
*info
)
679 struct l2tp_session
*session
;
683 session
= l2tp_nl_session_find(info
);
684 if (session
== NULL
) {
689 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
695 ret
= l2tp_nl_session_send(msg
, info
->snd_portid
, info
->snd_seq
,
700 return genlmsg_unicast(genl_info_net(info
), msg
, info
->snd_portid
);
709 static int l2tp_nl_cmd_session_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
711 struct net
*net
= sock_net(skb
->sk
);
712 struct l2tp_session
*session
;
713 struct l2tp_tunnel
*tunnel
= NULL
;
714 int ti
= cb
->args
[0];
715 int si
= cb
->args
[1];
718 if (tunnel
== NULL
) {
719 tunnel
= l2tp_tunnel_find_nth(net
, ti
);
724 session
= l2tp_session_find_nth(tunnel
, si
);
725 if (session
== NULL
) {
732 if (l2tp_nl_session_send(skb
, NETLINK_CB(cb
->skb
).portid
,
733 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
747 static struct nla_policy l2tp_nl_policy
[L2TP_ATTR_MAX
+ 1] = {
748 [L2TP_ATTR_NONE
] = { .type
= NLA_UNSPEC
, },
749 [L2TP_ATTR_PW_TYPE
] = { .type
= NLA_U16
, },
750 [L2TP_ATTR_ENCAP_TYPE
] = { .type
= NLA_U16
, },
751 [L2TP_ATTR_OFFSET
] = { .type
= NLA_U16
, },
752 [L2TP_ATTR_DATA_SEQ
] = { .type
= NLA_U8
, },
753 [L2TP_ATTR_L2SPEC_TYPE
] = { .type
= NLA_U8
, },
754 [L2TP_ATTR_L2SPEC_LEN
] = { .type
= NLA_U8
, },
755 [L2TP_ATTR_PROTO_VERSION
] = { .type
= NLA_U8
, },
756 [L2TP_ATTR_CONN_ID
] = { .type
= NLA_U32
, },
757 [L2TP_ATTR_PEER_CONN_ID
] = { .type
= NLA_U32
, },
758 [L2TP_ATTR_SESSION_ID
] = { .type
= NLA_U32
, },
759 [L2TP_ATTR_PEER_SESSION_ID
] = { .type
= NLA_U32
, },
760 [L2TP_ATTR_UDP_CSUM
] = { .type
= NLA_U8
, },
761 [L2TP_ATTR_VLAN_ID
] = { .type
= NLA_U16
, },
762 [L2TP_ATTR_DEBUG
] = { .type
= NLA_U32
, },
763 [L2TP_ATTR_RECV_SEQ
] = { .type
= NLA_U8
, },
764 [L2TP_ATTR_SEND_SEQ
] = { .type
= NLA_U8
, },
765 [L2TP_ATTR_LNS_MODE
] = { .type
= NLA_U8
, },
766 [L2TP_ATTR_USING_IPSEC
] = { .type
= NLA_U8
, },
767 [L2TP_ATTR_RECV_TIMEOUT
] = { .type
= NLA_MSECS
, },
768 [L2TP_ATTR_FD
] = { .type
= NLA_U32
, },
769 [L2TP_ATTR_IP_SADDR
] = { .type
= NLA_U32
, },
770 [L2TP_ATTR_IP_DADDR
] = { .type
= NLA_U32
, },
771 [L2TP_ATTR_UDP_SPORT
] = { .type
= NLA_U16
, },
772 [L2TP_ATTR_UDP_DPORT
] = { .type
= NLA_U16
, },
773 [L2TP_ATTR_MTU
] = { .type
= NLA_U16
, },
774 [L2TP_ATTR_MRU
] = { .type
= NLA_U16
, },
775 [L2TP_ATTR_STATS
] = { .type
= NLA_NESTED
, },
776 [L2TP_ATTR_IP6_SADDR
] = {
778 .len
= sizeof(struct in6_addr
),
780 [L2TP_ATTR_IP6_DADDR
] = {
782 .len
= sizeof(struct in6_addr
),
784 [L2TP_ATTR_IFNAME
] = {
785 .type
= NLA_NUL_STRING
,
788 [L2TP_ATTR_COOKIE
] = {
792 [L2TP_ATTR_PEER_COOKIE
] = {
798 static const struct genl_ops l2tp_nl_ops
[] = {
800 .cmd
= L2TP_CMD_NOOP
,
801 .doit
= l2tp_nl_cmd_noop
,
802 .policy
= l2tp_nl_policy
,
803 /* can be retrieved by unprivileged users */
806 .cmd
= L2TP_CMD_TUNNEL_CREATE
,
807 .doit
= l2tp_nl_cmd_tunnel_create
,
808 .policy
= l2tp_nl_policy
,
809 .flags
= GENL_ADMIN_PERM
,
812 .cmd
= L2TP_CMD_TUNNEL_DELETE
,
813 .doit
= l2tp_nl_cmd_tunnel_delete
,
814 .policy
= l2tp_nl_policy
,
815 .flags
= GENL_ADMIN_PERM
,
818 .cmd
= L2TP_CMD_TUNNEL_MODIFY
,
819 .doit
= l2tp_nl_cmd_tunnel_modify
,
820 .policy
= l2tp_nl_policy
,
821 .flags
= GENL_ADMIN_PERM
,
824 .cmd
= L2TP_CMD_TUNNEL_GET
,
825 .doit
= l2tp_nl_cmd_tunnel_get
,
826 .dumpit
= l2tp_nl_cmd_tunnel_dump
,
827 .policy
= l2tp_nl_policy
,
828 .flags
= GENL_ADMIN_PERM
,
831 .cmd
= L2TP_CMD_SESSION_CREATE
,
832 .doit
= l2tp_nl_cmd_session_create
,
833 .policy
= l2tp_nl_policy
,
834 .flags
= GENL_ADMIN_PERM
,
837 .cmd
= L2TP_CMD_SESSION_DELETE
,
838 .doit
= l2tp_nl_cmd_session_delete
,
839 .policy
= l2tp_nl_policy
,
840 .flags
= GENL_ADMIN_PERM
,
843 .cmd
= L2TP_CMD_SESSION_MODIFY
,
844 .doit
= l2tp_nl_cmd_session_modify
,
845 .policy
= l2tp_nl_policy
,
846 .flags
= GENL_ADMIN_PERM
,
849 .cmd
= L2TP_CMD_SESSION_GET
,
850 .doit
= l2tp_nl_cmd_session_get
,
851 .dumpit
= l2tp_nl_cmd_session_dump
,
852 .policy
= l2tp_nl_policy
,
853 .flags
= GENL_ADMIN_PERM
,
857 int l2tp_nl_register_ops(enum l2tp_pwtype pw_type
, const struct l2tp_nl_cmd_ops
*ops
)
862 if (pw_type
>= __L2TP_PWTYPE_MAX
)
867 if (l2tp_nl_cmd_ops
[pw_type
])
870 l2tp_nl_cmd_ops
[pw_type
] = ops
;
878 EXPORT_SYMBOL_GPL(l2tp_nl_register_ops
);
880 void l2tp_nl_unregister_ops(enum l2tp_pwtype pw_type
)
882 if (pw_type
< __L2TP_PWTYPE_MAX
) {
884 l2tp_nl_cmd_ops
[pw_type
] = NULL
;
888 EXPORT_SYMBOL_GPL(l2tp_nl_unregister_ops
);
890 static int l2tp_nl_init(void)
892 pr_info("L2TP netlink interface\n");
893 return genl_register_family_with_ops(&l2tp_nl_family
, l2tp_nl_ops
);
896 static void l2tp_nl_cleanup(void)
898 genl_unregister_family(&l2tp_nl_family
);
901 module_init(l2tp_nl_init
);
902 module_exit(l2tp_nl_cleanup
);
904 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
905 MODULE_DESCRIPTION("L2TP netlink");
906 MODULE_LICENSE("GPL");
907 MODULE_VERSION("1.0");
908 MODULE_ALIAS_GENL_FAMILY("l2tp");