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