Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
l2tp_ip6.c
Go to the documentation of this file.
1 /*
2  * L2TPv3 IP encapsulation support for IPv6
3  *
4  * Copyright (c) 2012 Katalix Systems Ltd
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  */
11 
12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13 
14 #include <linux/icmp.h>
15 #include <linux/module.h>
16 #include <linux/skbuff.h>
17 #include <linux/random.h>
18 #include <linux/socket.h>
19 #include <linux/l2tp.h>
20 #include <linux/in.h>
21 #include <linux/in6.h>
22 #include <net/sock.h>
23 #include <net/ip.h>
24 #include <net/icmp.h>
25 #include <net/udp.h>
26 #include <net/inet_common.h>
27 #include <net/inet_hashtables.h>
28 #include <net/tcp_states.h>
29 #include <net/protocol.h>
30 #include <net/xfrm.h>
31 
32 #include <net/transp_v6.h>
33 #include <net/addrconf.h>
34 #include <net/ip6_route.h>
35 
36 #include "l2tp_core.h"
37 
38 struct l2tp_ip6_sock {
39  /* inet_sock has to be the first member of l2tp_ip6_sock */
40  struct inet_sock inet;
41 
42  u32 conn_id;
43  u32 peer_conn_id;
44 
45  /* ipv6_pinfo has to be the last member of l2tp_ip6_sock, see
46  inet6_sk_generic */
47  struct ipv6_pinfo inet6;
48 };
49 
50 static DEFINE_RWLOCK(l2tp_ip6_lock);
51 static struct hlist_head l2tp_ip6_table;
52 static struct hlist_head l2tp_ip6_bind_table;
53 
54 static inline struct l2tp_ip6_sock *l2tp_ip6_sk(const struct sock *sk)
55 {
56  return (struct l2tp_ip6_sock *)sk;
57 }
58 
59 static struct sock *__l2tp_ip6_bind_lookup(struct net *net,
60  struct in6_addr *laddr,
61  int dif, u32 tunnel_id)
62 {
63  struct hlist_node *node;
64  struct sock *sk;
65 
66  sk_for_each_bound(sk, node, &l2tp_ip6_bind_table) {
67  struct in6_addr *addr = inet6_rcv_saddr(sk);
68  struct l2tp_ip6_sock *l2tp = l2tp_ip6_sk(sk);
69 
70  if (l2tp == NULL)
71  continue;
72 
73  if ((l2tp->conn_id == tunnel_id) &&
74  net_eq(sock_net(sk), net) &&
75  !(addr && ipv6_addr_equal(addr, laddr)) &&
76  !(sk->sk_bound_dev_if && sk->sk_bound_dev_if != dif))
77  goto found;
78  }
79 
80  sk = NULL;
81 found:
82  return sk;
83 }
84 
85 static inline struct sock *l2tp_ip6_bind_lookup(struct net *net,
86  struct in6_addr *laddr,
87  int dif, u32 tunnel_id)
88 {
89  struct sock *sk = __l2tp_ip6_bind_lookup(net, laddr, dif, tunnel_id);
90  if (sk)
91  sock_hold(sk);
92 
93  return sk;
94 }
95 
96 /* When processing receive frames, there are two cases to
97  * consider. Data frames consist of a non-zero session-id and an
98  * optional cookie. Control frames consist of a regular L2TP header
99  * preceded by 32-bits of zeros.
100  *
101  * L2TPv3 Session Header Over IP
102  *
103  * 0 1 2 3
104  * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
105  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
106  * | Session ID |
107  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
108  * | Cookie (optional, maximum 64 bits)...
109  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
110  * |
111  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
112  *
113  * L2TPv3 Control Message Header Over IP
114  *
115  * 0 1 2 3
116  * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
117  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
118  * | (32 bits of zeros) |
119  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
120  * |T|L|x|x|S|x|x|x|x|x|x|x| Ver | Length |
121  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
122  * | Control Connection ID |
123  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
124  * | Ns | Nr |
125  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
126  *
127  * All control frames are passed to userspace.
128  */
129 static int l2tp_ip6_recv(struct sk_buff *skb)
130 {
131  struct sock *sk;
132  u32 session_id;
133  u32 tunnel_id;
134  unsigned char *ptr, *optr;
135  struct l2tp_session *session;
136  struct l2tp_tunnel *tunnel = NULL;
137  int length;
138 
139  /* Point to L2TP header */
140  optr = ptr = skb->data;
141 
142  if (!pskb_may_pull(skb, 4))
143  goto discard;
144 
145  session_id = ntohl(*((__be32 *) ptr));
146  ptr += 4;
147 
148  /* RFC3931: L2TP/IP packets have the first 4 bytes containing
149  * the session_id. If it is 0, the packet is a L2TP control
150  * frame and the session_id value can be discarded.
151  */
152  if (session_id == 0) {
153  __skb_pull(skb, 4);
154  goto pass_up;
155  }
156 
157  /* Ok, this is a data packet. Lookup the session. */
158  session = l2tp_session_find(&init_net, NULL, session_id);
159  if (session == NULL)
160  goto discard;
161 
162  tunnel = session->tunnel;
163  if (tunnel == NULL)
164  goto discard;
165 
166  /* Trace packet contents, if enabled */
167  if (tunnel->debug & L2TP_MSG_DATA) {
168  length = min(32u, skb->len);
169  if (!pskb_may_pull(skb, length))
170  goto discard;
171 
172  pr_debug("%s: ip recv\n", tunnel->name);
173  print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, ptr, length);
174  }
175 
176  l2tp_recv_common(session, skb, ptr, optr, 0, skb->len,
177  tunnel->recv_payload_hook);
178  return 0;
179 
180 pass_up:
181  /* Get the tunnel_id from the L2TP header */
182  if (!pskb_may_pull(skb, 12))
183  goto discard;
184 
185  if ((skb->data[0] & 0xc0) != 0xc0)
186  goto discard;
187 
188  tunnel_id = ntohl(*(__be32 *) &skb->data[4]);
189  tunnel = l2tp_tunnel_find(&init_net, tunnel_id);
190  if (tunnel != NULL)
191  sk = tunnel->sock;
192  else {
193  struct ipv6hdr *iph = ipv6_hdr(skb);
194 
195  read_lock_bh(&l2tp_ip6_lock);
196  sk = __l2tp_ip6_bind_lookup(&init_net, &iph->daddr,
197  0, tunnel_id);
198  read_unlock_bh(&l2tp_ip6_lock);
199  }
200 
201  if (sk == NULL)
202  goto discard;
203 
204  sock_hold(sk);
205 
206  if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
207  goto discard_put;
208 
209  nf_reset(skb);
210 
211  return sk_receive_skb(sk, skb, 1);
212 
213 discard_put:
214  sock_put(sk);
215 
216 discard:
217  kfree_skb(skb);
218  return 0;
219 }
220 
221 static int l2tp_ip6_open(struct sock *sk)
222 {
223  /* Prevent autobind. We don't have ports. */
224  inet_sk(sk)->inet_num = IPPROTO_L2TP;
225 
226  write_lock_bh(&l2tp_ip6_lock);
227  sk_add_node(sk, &l2tp_ip6_table);
228  write_unlock_bh(&l2tp_ip6_lock);
229 
230  return 0;
231 }
232 
233 static void l2tp_ip6_close(struct sock *sk, long timeout)
234 {
235  write_lock_bh(&l2tp_ip6_lock);
236  hlist_del_init(&sk->sk_bind_node);
237  sk_del_node_init(sk);
238  write_unlock_bh(&l2tp_ip6_lock);
239 
240  sk_common_release(sk);
241 }
242 
243 static void l2tp_ip6_destroy_sock(struct sock *sk)
244 {
245  lock_sock(sk);
246  ip6_flush_pending_frames(sk);
247  release_sock(sk);
248 
249  inet6_destroy_sock(sk);
250 }
251 
252 static int l2tp_ip6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
253 {
254  struct inet_sock *inet = inet_sk(sk);
255  struct ipv6_pinfo *np = inet6_sk(sk);
256  struct sockaddr_l2tpip6 *addr = (struct sockaddr_l2tpip6 *) uaddr;
257  __be32 v4addr = 0;
258  int addr_type;
259  int err;
260 
261  if (!sock_flag(sk, SOCK_ZAPPED))
262  return -EINVAL;
263  if (addr->l2tp_family != AF_INET6)
264  return -EINVAL;
265  if (addr_len < sizeof(*addr))
266  return -EINVAL;
267 
268  addr_type = ipv6_addr_type(&addr->l2tp_addr);
269 
270  /* l2tp_ip6 sockets are IPv6 only */
271  if (addr_type == IPV6_ADDR_MAPPED)
272  return -EADDRNOTAVAIL;
273 
274  /* L2TP is point-point, not multicast */
275  if (addr_type & IPV6_ADDR_MULTICAST)
276  return -EADDRNOTAVAIL;
277 
278  err = -EADDRINUSE;
279  read_lock_bh(&l2tp_ip6_lock);
280  if (__l2tp_ip6_bind_lookup(&init_net, &addr->l2tp_addr,
281  sk->sk_bound_dev_if, addr->l2tp_conn_id))
282  goto out_in_use;
283  read_unlock_bh(&l2tp_ip6_lock);
284 
285  lock_sock(sk);
286 
287  err = -EINVAL;
288  if (sk->sk_state != TCP_CLOSE)
289  goto out_unlock;
290 
291  /* Check if the address belongs to the host. */
292  rcu_read_lock();
293  if (addr_type != IPV6_ADDR_ANY) {
294  struct net_device *dev = NULL;
295 
296  if (addr_type & IPV6_ADDR_LINKLOCAL) {
297  if (addr_len >= sizeof(struct sockaddr_in6) &&
298  addr->l2tp_scope_id) {
299  /* Override any existing binding, if another
300  * one is supplied by user.
301  */
302  sk->sk_bound_dev_if = addr->l2tp_scope_id;
303  }
304 
305  /* Binding to link-local address requires an
306  interface */
307  if (!sk->sk_bound_dev_if)
308  goto out_unlock_rcu;
309 
310  err = -ENODEV;
311  dev = dev_get_by_index_rcu(sock_net(sk),
312  sk->sk_bound_dev_if);
313  if (!dev)
314  goto out_unlock_rcu;
315  }
316 
317  /* ipv4 addr of the socket is invalid. Only the
318  * unspecified and mapped address have a v4 equivalent.
319  */
320  v4addr = LOOPBACK4_IPV6;
321  err = -EADDRNOTAVAIL;
322  if (!ipv6_chk_addr(sock_net(sk), &addr->l2tp_addr, dev, 0))
323  goto out_unlock_rcu;
324  }
325  rcu_read_unlock();
326 
327  inet->inet_rcv_saddr = inet->inet_saddr = v4addr;
328  np->rcv_saddr = addr->l2tp_addr;
329  np->saddr = addr->l2tp_addr;
330 
331  l2tp_ip6_sk(sk)->conn_id = addr->l2tp_conn_id;
332 
333  write_lock_bh(&l2tp_ip6_lock);
334  sk_add_bind_node(sk, &l2tp_ip6_bind_table);
335  sk_del_node_init(sk);
336  write_unlock_bh(&l2tp_ip6_lock);
337 
338  sock_reset_flag(sk, SOCK_ZAPPED);
339  release_sock(sk);
340  return 0;
341 
342 out_unlock_rcu:
343  rcu_read_unlock();
344 out_unlock:
345  release_sock(sk);
346  return err;
347 
348 out_in_use:
349  read_unlock_bh(&l2tp_ip6_lock);
350  return err;
351 }
352 
353 static int l2tp_ip6_connect(struct sock *sk, struct sockaddr *uaddr,
354  int addr_len)
355 {
356  struct sockaddr_l2tpip6 *lsa = (struct sockaddr_l2tpip6 *) uaddr;
357  struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
358  struct in6_addr *daddr;
359  int addr_type;
360  int rc;
361 
362  if (sock_flag(sk, SOCK_ZAPPED)) /* Must bind first - autobinding does not work */
363  return -EINVAL;
364 
365  if (addr_len < sizeof(*lsa))
366  return -EINVAL;
367 
368  addr_type = ipv6_addr_type(&usin->sin6_addr);
369  if (addr_type & IPV6_ADDR_MULTICAST)
370  return -EINVAL;
371 
372  if (addr_type & IPV6_ADDR_MAPPED) {
373  daddr = &usin->sin6_addr;
374  if (ipv4_is_multicast(daddr->s6_addr32[3]))
375  return -EINVAL;
376  }
377 
378  rc = ip6_datagram_connect(sk, uaddr, addr_len);
379 
380  lock_sock(sk);
381 
382  l2tp_ip6_sk(sk)->peer_conn_id = lsa->l2tp_conn_id;
383 
384  write_lock_bh(&l2tp_ip6_lock);
385  hlist_del_init(&sk->sk_bind_node);
386  sk_add_bind_node(sk, &l2tp_ip6_bind_table);
387  write_unlock_bh(&l2tp_ip6_lock);
388 
389  release_sock(sk);
390 
391  return rc;
392 }
393 
394 static int l2tp_ip6_disconnect(struct sock *sk, int flags)
395 {
396  if (sock_flag(sk, SOCK_ZAPPED))
397  return 0;
398 
399  return udp_disconnect(sk, flags);
400 }
401 
402 static int l2tp_ip6_getname(struct socket *sock, struct sockaddr *uaddr,
403  int *uaddr_len, int peer)
404 {
405  struct sockaddr_l2tpip6 *lsa = (struct sockaddr_l2tpip6 *)uaddr;
406  struct sock *sk = sock->sk;
407  struct ipv6_pinfo *np = inet6_sk(sk);
408  struct l2tp_ip6_sock *lsk = l2tp_ip6_sk(sk);
409 
410  lsa->l2tp_family = AF_INET6;
411  lsa->l2tp_flowinfo = 0;
412  lsa->l2tp_scope_id = 0;
413  lsa->l2tp_unused = 0;
414  if (peer) {
415  if (!lsk->peer_conn_id)
416  return -ENOTCONN;
417  lsa->l2tp_conn_id = lsk->peer_conn_id;
418  lsa->l2tp_addr = np->daddr;
419  if (np->sndflow)
420  lsa->l2tp_flowinfo = np->flow_label;
421  } else {
422  if (ipv6_addr_any(&np->rcv_saddr))
423  lsa->l2tp_addr = np->saddr;
424  else
425  lsa->l2tp_addr = np->rcv_saddr;
426 
427  lsa->l2tp_conn_id = lsk->conn_id;
428  }
429  if (ipv6_addr_type(&lsa->l2tp_addr) & IPV6_ADDR_LINKLOCAL)
430  lsa->l2tp_scope_id = sk->sk_bound_dev_if;
431  *uaddr_len = sizeof(*lsa);
432  return 0;
433 }
434 
435 static int l2tp_ip6_backlog_recv(struct sock *sk, struct sk_buff *skb)
436 {
437  int rc;
438 
439  /* Charge it to the socket, dropping if the queue is full. */
440  rc = sock_queue_rcv_skb(sk, skb);
441  if (rc < 0)
442  goto drop;
443 
444  return 0;
445 
446 drop:
447  IP_INC_STATS(&init_net, IPSTATS_MIB_INDISCARDS);
448  kfree_skb(skb);
449  return -1;
450 }
451 
452 static int l2tp_ip6_push_pending_frames(struct sock *sk)
453 {
454  struct sk_buff *skb;
455  __be32 *transhdr = NULL;
456  int err = 0;
457 
458  skb = skb_peek(&sk->sk_write_queue);
459  if (skb == NULL)
460  goto out;
461 
462  transhdr = (__be32 *)skb_transport_header(skb);
463  *transhdr = 0;
464 
465  err = ip6_push_pending_frames(sk);
466 
467 out:
468  return err;
469 }
470 
471 /* Userspace will call sendmsg() on the tunnel socket to send L2TP
472  * control frames.
473  */
474 static int l2tp_ip6_sendmsg(struct kiocb *iocb, struct sock *sk,
475  struct msghdr *msg, size_t len)
476 {
477  struct ipv6_txoptions opt_space;
478  struct sockaddr_l2tpip6 *lsa =
479  (struct sockaddr_l2tpip6 *) msg->msg_name;
480  struct in6_addr *daddr, *final_p, final;
481  struct ipv6_pinfo *np = inet6_sk(sk);
482  struct ipv6_txoptions *opt = NULL;
483  struct ip6_flowlabel *flowlabel = NULL;
484  struct dst_entry *dst = NULL;
485  struct flowi6 fl6;
486  int addr_len = msg->msg_namelen;
487  int hlimit = -1;
488  int tclass = -1;
489  int dontfrag = -1;
490  int transhdrlen = 4; /* zero session-id */
491  int ulen = len + transhdrlen;
492  int err;
493 
494  /* Rough check on arithmetic overflow,
495  better check is made in ip6_append_data().
496  */
497  if (len > INT_MAX)
498  return -EMSGSIZE;
499 
500  /* Mirror BSD error message compatibility */
501  if (msg->msg_flags & MSG_OOB)
502  return -EOPNOTSUPP;
503 
504  /*
505  * Get and verify the address.
506  */
507  memset(&fl6, 0, sizeof(fl6));
508 
509  fl6.flowi6_mark = sk->sk_mark;
510 
511  if (lsa) {
512  if (addr_len < SIN6_LEN_RFC2133)
513  return -EINVAL;
514 
515  if (lsa->l2tp_family && lsa->l2tp_family != AF_INET6)
516  return -EAFNOSUPPORT;
517 
518  daddr = &lsa->l2tp_addr;
519  if (np->sndflow) {
520  fl6.flowlabel = lsa->l2tp_flowinfo & IPV6_FLOWINFO_MASK;
521  if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
522  flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
523  if (flowlabel == NULL)
524  return -EINVAL;
525  daddr = &flowlabel->dst;
526  }
527  }
528 
529  /*
530  * Otherwise it will be difficult to maintain
531  * sk->sk_dst_cache.
532  */
533  if (sk->sk_state == TCP_ESTABLISHED &&
534  ipv6_addr_equal(daddr, &np->daddr))
535  daddr = &np->daddr;
536 
537  if (addr_len >= sizeof(struct sockaddr_in6) &&
538  lsa->l2tp_scope_id &&
539  ipv6_addr_type(daddr) & IPV6_ADDR_LINKLOCAL)
540  fl6.flowi6_oif = lsa->l2tp_scope_id;
541  } else {
542  if (sk->sk_state != TCP_ESTABLISHED)
543  return -EDESTADDRREQ;
544 
545  daddr = &np->daddr;
546  fl6.flowlabel = np->flow_label;
547  }
548 
549  if (fl6.flowi6_oif == 0)
550  fl6.flowi6_oif = sk->sk_bound_dev_if;
551 
552  if (msg->msg_controllen) {
553  opt = &opt_space;
554  memset(opt, 0, sizeof(struct ipv6_txoptions));
555  opt->tot_len = sizeof(struct ipv6_txoptions);
556 
557  err = datagram_send_ctl(sock_net(sk), sk, msg, &fl6, opt,
558  &hlimit, &tclass, &dontfrag);
559  if (err < 0) {
560  fl6_sock_release(flowlabel);
561  return err;
562  }
563  if ((fl6.flowlabel & IPV6_FLOWLABEL_MASK) && !flowlabel) {
564  flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
565  if (flowlabel == NULL)
566  return -EINVAL;
567  }
568  if (!(opt->opt_nflen|opt->opt_flen))
569  opt = NULL;
570  }
571 
572  if (opt == NULL)
573  opt = np->opt;
574  if (flowlabel)
575  opt = fl6_merge_options(&opt_space, flowlabel, opt);
576  opt = ipv6_fixup_options(&opt_space, opt);
577 
578  fl6.flowi6_proto = sk->sk_protocol;
579  if (!ipv6_addr_any(daddr))
580  fl6.daddr = *daddr;
581  else
582  fl6.daddr.s6_addr[15] = 0x1; /* :: means loopback (BSD'ism) */
583  if (ipv6_addr_any(&fl6.saddr) && !ipv6_addr_any(&np->saddr))
584  fl6.saddr = np->saddr;
585 
586  final_p = fl6_update_dst(&fl6, opt, &final);
587 
588  if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
589  fl6.flowi6_oif = np->mcast_oif;
590  else if (!fl6.flowi6_oif)
591  fl6.flowi6_oif = np->ucast_oif;
592 
593  security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
594 
595  dst = ip6_dst_lookup_flow(sk, &fl6, final_p, true);
596  if (IS_ERR(dst)) {
597  err = PTR_ERR(dst);
598  goto out;
599  }
600 
601  if (hlimit < 0) {
602  if (ipv6_addr_is_multicast(&fl6.daddr))
603  hlimit = np->mcast_hops;
604  else
605  hlimit = np->hop_limit;
606  if (hlimit < 0)
607  hlimit = ip6_dst_hoplimit(dst);
608  }
609 
610  if (tclass < 0)
611  tclass = np->tclass;
612 
613  if (dontfrag < 0)
614  dontfrag = np->dontfrag;
615 
616  if (msg->msg_flags & MSG_CONFIRM)
617  goto do_confirm;
618 
619 back_from_confirm:
620  lock_sock(sk);
621  err = ip6_append_data(sk, ip_generic_getfrag, msg->msg_iov,
622  ulen, transhdrlen, hlimit, tclass, opt,
623  &fl6, (struct rt6_info *)dst,
624  msg->msg_flags, dontfrag);
625  if (err)
626  ip6_flush_pending_frames(sk);
627  else if (!(msg->msg_flags & MSG_MORE))
628  err = l2tp_ip6_push_pending_frames(sk);
629  release_sock(sk);
630 done:
631  dst_release(dst);
632 out:
633  fl6_sock_release(flowlabel);
634 
635  return err < 0 ? err : len;
636 
637 do_confirm:
638  dst_confirm(dst);
639  if (!(msg->msg_flags & MSG_PROBE) || len)
640  goto back_from_confirm;
641  err = 0;
642  goto done;
643 }
644 
645 static int l2tp_ip6_recvmsg(struct kiocb *iocb, struct sock *sk,
646  struct msghdr *msg, size_t len, int noblock,
647  int flags, int *addr_len)
648 {
649  struct inet_sock *inet = inet_sk(sk);
650  struct sockaddr_l2tpip6 *lsa = (struct sockaddr_l2tpip6 *)msg->msg_name;
651  size_t copied = 0;
652  int err = -EOPNOTSUPP;
653  struct sk_buff *skb;
654 
655  if (flags & MSG_OOB)
656  goto out;
657 
658  if (addr_len)
659  *addr_len = sizeof(*lsa);
660 
661  if (flags & MSG_ERRQUEUE)
662  return ipv6_recv_error(sk, msg, len);
663 
664  skb = skb_recv_datagram(sk, flags, noblock, &err);
665  if (!skb)
666  goto out;
667 
668  copied = skb->len;
669  if (len < copied) {
670  msg->msg_flags |= MSG_TRUNC;
671  copied = len;
672  }
673 
674  err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
675  if (err)
676  goto done;
677 
678  sock_recv_timestamp(msg, sk, skb);
679 
680  /* Copy the address. */
681  if (lsa) {
682  lsa->l2tp_family = AF_INET6;
683  lsa->l2tp_unused = 0;
684  lsa->l2tp_addr = ipv6_hdr(skb)->saddr;
685  lsa->l2tp_flowinfo = 0;
686  lsa->l2tp_scope_id = 0;
687  if (ipv6_addr_type(&lsa->l2tp_addr) & IPV6_ADDR_LINKLOCAL)
688  lsa->l2tp_scope_id = IP6CB(skb)->iif;
689  }
690 
691  if (inet->cmsg_flags)
692  ip_cmsg_recv(msg, skb);
693 
694  if (flags & MSG_TRUNC)
695  copied = skb->len;
696 done:
697  skb_free_datagram(sk, skb);
698 out:
699  return err ? err : copied;
700 }
701 
702 static struct proto l2tp_ip6_prot = {
703  .name = "L2TP/IPv6",
704  .owner = THIS_MODULE,
705  .init = l2tp_ip6_open,
706  .close = l2tp_ip6_close,
707  .bind = l2tp_ip6_bind,
708  .connect = l2tp_ip6_connect,
709  .disconnect = l2tp_ip6_disconnect,
710  .ioctl = udp_ioctl,
711  .destroy = l2tp_ip6_destroy_sock,
712  .setsockopt = ipv6_setsockopt,
713  .getsockopt = ipv6_getsockopt,
714  .sendmsg = l2tp_ip6_sendmsg,
715  .recvmsg = l2tp_ip6_recvmsg,
716  .backlog_rcv = l2tp_ip6_backlog_recv,
717  .hash = inet_hash,
718  .unhash = inet_unhash,
719  .obj_size = sizeof(struct l2tp_ip6_sock),
720 #ifdef CONFIG_COMPAT
721  .compat_setsockopt = compat_ipv6_setsockopt,
722  .compat_getsockopt = compat_ipv6_getsockopt,
723 #endif
724 };
725 
726 static const struct proto_ops l2tp_ip6_ops = {
727  .family = PF_INET6,
728  .owner = THIS_MODULE,
729  .release = inet6_release,
730  .bind = inet6_bind,
731  .connect = inet_dgram_connect,
732  .socketpair = sock_no_socketpair,
733  .accept = sock_no_accept,
734  .getname = l2tp_ip6_getname,
735  .poll = datagram_poll,
736  .ioctl = inet6_ioctl,
737  .listen = sock_no_listen,
738  .shutdown = inet_shutdown,
739  .setsockopt = sock_common_setsockopt,
740  .getsockopt = sock_common_getsockopt,
741  .sendmsg = inet_sendmsg,
742  .recvmsg = sock_common_recvmsg,
743  .mmap = sock_no_mmap,
744  .sendpage = sock_no_sendpage,
745 #ifdef CONFIG_COMPAT
746  .compat_setsockopt = compat_sock_common_setsockopt,
747  .compat_getsockopt = compat_sock_common_getsockopt,
748 #endif
749 };
750 
751 static struct inet_protosw l2tp_ip6_protosw = {
752  .type = SOCK_DGRAM,
753  .protocol = IPPROTO_L2TP,
754  .prot = &l2tp_ip6_prot,
755  .ops = &l2tp_ip6_ops,
756  .no_check = 0,
757 };
758 
759 static struct inet6_protocol l2tp_ip6_protocol __read_mostly = {
760  .handler = l2tp_ip6_recv,
761 };
762 
763 static int __init l2tp_ip6_init(void)
764 {
765  int err;
766 
767  pr_info("L2TP IP encapsulation support for IPv6 (L2TPv3)\n");
768 
769  err = proto_register(&l2tp_ip6_prot, 1);
770  if (err != 0)
771  goto out;
772 
773  err = inet6_add_protocol(&l2tp_ip6_protocol, IPPROTO_L2TP);
774  if (err)
775  goto out1;
776 
777  inet6_register_protosw(&l2tp_ip6_protosw);
778  return 0;
779 
780 out1:
781  proto_unregister(&l2tp_ip6_prot);
782 out:
783  return err;
784 }
785 
786 static void __exit l2tp_ip6_exit(void)
787 {
788  inet6_unregister_protosw(&l2tp_ip6_protosw);
789  inet6_del_protocol(&l2tp_ip6_protocol, IPPROTO_L2TP);
790  proto_unregister(&l2tp_ip6_prot);
791 }
792 
793 module_init(l2tp_ip6_init);
794 module_exit(l2tp_ip6_exit);
795 
796 MODULE_LICENSE("GPL");
797 MODULE_AUTHOR("Chris Elston <[email protected]>");
798 MODULE_DESCRIPTION("L2TP IP encapsulation for IPv6");
799 MODULE_VERSION("1.0");
800 
801 /* Use the value of SOCK_DGRAM (2) directory, because __stringify doesn't like
802  * enums
803  */
804 MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET6, 2, IPPROTO_L2TP);
Generated on Thu Jan 10 2013 14:59:50 for Linux Kernel by   doxygen 1.8.2