Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
datagram.c
Go to the documentation of this file.
1 /*
2  * common UDP/RAW code
3  * Linux INET6 implementation
4  *
5  * Authors:
6  * Pedro Roque <[email protected]>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version
11  * 2 of the License, or (at your option) any later version.
12  */
13 
14 #include <linux/capability.h>
15 #include <linux/errno.h>
16 #include <linux/types.h>
17 #include <linux/kernel.h>
18 #include <linux/interrupt.h>
19 #include <linux/socket.h>
20 #include <linux/sockios.h>
21 #include <linux/in6.h>
22 #include <linux/ipv6.h>
23 #include <linux/route.h>
24 #include <linux/slab.h>
25 #include <linux/export.h>
26 
27 #include <net/ipv6.h>
28 #include <net/ndisc.h>
29 #include <net/addrconf.h>
30 #include <net/transp_v6.h>
31 #include <net/ip6_route.h>
32 #include <net/tcp_states.h>
33 
34 #include <linux/errqueue.h>
35 #include <asm/uaccess.h>
36 
37 static bool ipv6_mapped_addr_any(const struct in6_addr *a)
38 {
39  return ipv6_addr_v4mapped(a) && (a->s6_addr32[3] == 0);
40 }
41 
42 int ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
43 {
44  struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
45  struct inet_sock *inet = inet_sk(sk);
46  struct ipv6_pinfo *np = inet6_sk(sk);
47  struct in6_addr *daddr, *final_p, final;
48  struct dst_entry *dst;
49  struct flowi6 fl6;
50  struct ip6_flowlabel *flowlabel = NULL;
51  struct ipv6_txoptions *opt;
52  int addr_type;
53  int err;
54 
55  if (usin->sin6_family == AF_INET) {
56  if (__ipv6_only_sock(sk))
57  return -EAFNOSUPPORT;
58  err = ip4_datagram_connect(sk, uaddr, addr_len);
59  goto ipv4_connected;
60  }
61 
62  if (addr_len < SIN6_LEN_RFC2133)
63  return -EINVAL;
64 
65  if (usin->sin6_family != AF_INET6)
66  return -EAFNOSUPPORT;
67 
68  memset(&fl6, 0, sizeof(fl6));
69  if (np->sndflow) {
70  fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
71  if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
72  flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
73  if (flowlabel == NULL)
74  return -EINVAL;
75  usin->sin6_addr = flowlabel->dst;
76  }
77  }
78 
79  addr_type = ipv6_addr_type(&usin->sin6_addr);
80 
81  if (addr_type == IPV6_ADDR_ANY) {
82  /*
83  * connect to self
84  */
85  usin->sin6_addr.s6_addr[15] = 0x01;
86  }
87 
88  daddr = &usin->sin6_addr;
89 
90  if (addr_type == IPV6_ADDR_MAPPED) {
91  struct sockaddr_in sin;
92 
93  if (__ipv6_only_sock(sk)) {
94  err = -ENETUNREACH;
95  goto out;
96  }
97  sin.sin_family = AF_INET;
98  sin.sin_addr.s_addr = daddr->s6_addr32[3];
99  sin.sin_port = usin->sin6_port;
100 
101  err = ip4_datagram_connect(sk,
102  (struct sockaddr *) &sin,
103  sizeof(sin));
104 
105 ipv4_connected:
106  if (err)
107  goto out;
108 
109  ipv6_addr_set_v4mapped(inet->inet_daddr, &np->daddr);
110 
111  if (ipv6_addr_any(&np->saddr) ||
112  ipv6_mapped_addr_any(&np->saddr))
113  ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
114 
115  if (ipv6_addr_any(&np->rcv_saddr) ||
116  ipv6_mapped_addr_any(&np->rcv_saddr)) {
117  ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
118  &np->rcv_saddr);
119  if (sk->sk_prot->rehash)
120  sk->sk_prot->rehash(sk);
121  }
122 
123  goto out;
124  }
125 
126  if (addr_type&IPV6_ADDR_LINKLOCAL) {
127  if (addr_len >= sizeof(struct sockaddr_in6) &&
128  usin->sin6_scope_id) {
129  if (sk->sk_bound_dev_if &&
130  sk->sk_bound_dev_if != usin->sin6_scope_id) {
131  err = -EINVAL;
132  goto out;
133  }
134  sk->sk_bound_dev_if = usin->sin6_scope_id;
135  }
136 
137  if (!sk->sk_bound_dev_if && (addr_type & IPV6_ADDR_MULTICAST))
138  sk->sk_bound_dev_if = np->mcast_oif;
139 
140  /* Connect to link-local address requires an interface */
141  if (!sk->sk_bound_dev_if) {
142  err = -EINVAL;
143  goto out;
144  }
145  }
146 
147  np->daddr = *daddr;
148  np->flow_label = fl6.flowlabel;
149 
150  inet->inet_dport = usin->sin6_port;
151 
152  /*
153  * Check for a route to destination an obtain the
154  * destination cache for it.
155  */
156 
157  fl6.flowi6_proto = sk->sk_protocol;
158  fl6.daddr = np->daddr;
159  fl6.saddr = np->saddr;
160  fl6.flowi6_oif = sk->sk_bound_dev_if;
161  fl6.flowi6_mark = sk->sk_mark;
162  fl6.fl6_dport = inet->inet_dport;
163  fl6.fl6_sport = inet->inet_sport;
164 
165  if (!fl6.flowi6_oif && (addr_type&IPV6_ADDR_MULTICAST))
166  fl6.flowi6_oif = np->mcast_oif;
167 
168  security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
169 
170  opt = flowlabel ? flowlabel->opt : np->opt;
171  final_p = fl6_update_dst(&fl6, opt, &final);
172 
173  dst = ip6_dst_lookup_flow(sk, &fl6, final_p, true);
174  err = 0;
175  if (IS_ERR(dst)) {
176  err = PTR_ERR(dst);
177  goto out;
178  }
179 
180  /* source address lookup done in ip6_dst_lookup */
181 
182  if (ipv6_addr_any(&np->saddr))
183  np->saddr = fl6.saddr;
184 
185  if (ipv6_addr_any(&np->rcv_saddr)) {
186  np->rcv_saddr = fl6.saddr;
187  inet->inet_rcv_saddr = LOOPBACK4_IPV6;
188  if (sk->sk_prot->rehash)
189  sk->sk_prot->rehash(sk);
190  }
191 
192  ip6_dst_store(sk, dst,
193  ipv6_addr_equal(&fl6.daddr, &np->daddr) ?
194  &np->daddr : NULL,
195 #ifdef CONFIG_IPV6_SUBTREES
196  ipv6_addr_equal(&fl6.saddr, &np->saddr) ?
197  &np->saddr :
198 #endif
199  NULL);
200 
201  sk->sk_state = TCP_ESTABLISHED;
202 out:
203  fl6_sock_release(flowlabel);
204  return err;
205 }
206 EXPORT_SYMBOL_GPL(ip6_datagram_connect);
207 
208 void ipv6_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
209  __be16 port, u32 info, u8 *payload)
210 {
211  struct ipv6_pinfo *np = inet6_sk(sk);
212  struct icmp6hdr *icmph = icmp6_hdr(skb);
213  struct sock_exterr_skb *serr;
214 
215  if (!np->recverr)
216  return;
217 
218  skb = skb_clone(skb, GFP_ATOMIC);
219  if (!skb)
220  return;
221 
222  skb->protocol = htons(ETH_P_IPV6);
223 
224  serr = SKB_EXT_ERR(skb);
225  serr->ee.ee_errno = err;
226  serr->ee.ee_origin = SO_EE_ORIGIN_ICMP6;
227  serr->ee.ee_type = icmph->icmp6_type;
228  serr->ee.ee_code = icmph->icmp6_code;
229  serr->ee.ee_pad = 0;
230  serr->ee.ee_info = info;
231  serr->ee.ee_data = 0;
232  serr->addr_offset = (u8 *)&(((struct ipv6hdr *)(icmph + 1))->daddr) -
233  skb_network_header(skb);
234  serr->port = port;
235 
236  __skb_pull(skb, payload - skb->data);
237  skb_reset_transport_header(skb);
238 
239  if (sock_queue_err_skb(sk, skb))
240  kfree_skb(skb);
241 }
242 
243 void ipv6_local_error(struct sock *sk, int err, struct flowi6 *fl6, u32 info)
244 {
245  struct ipv6_pinfo *np = inet6_sk(sk);
246  struct sock_exterr_skb *serr;
247  struct ipv6hdr *iph;
248  struct sk_buff *skb;
249 
250  if (!np->recverr)
251  return;
252 
253  skb = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
254  if (!skb)
255  return;
256 
257  skb->protocol = htons(ETH_P_IPV6);
258 
259  skb_put(skb, sizeof(struct ipv6hdr));
260  skb_reset_network_header(skb);
261  iph = ipv6_hdr(skb);
262  iph->daddr = fl6->daddr;
263 
264  serr = SKB_EXT_ERR(skb);
265  serr->ee.ee_errno = err;
266  serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
267  serr->ee.ee_type = 0;
268  serr->ee.ee_code = 0;
269  serr->ee.ee_pad = 0;
270  serr->ee.ee_info = info;
271  serr->ee.ee_data = 0;
272  serr->addr_offset = (u8 *)&iph->daddr - skb_network_header(skb);
273  serr->port = fl6->fl6_dport;
274 
275  __skb_pull(skb, skb_tail_pointer(skb) - skb->data);
276  skb_reset_transport_header(skb);
277 
278  if (sock_queue_err_skb(sk, skb))
279  kfree_skb(skb);
280 }
281 
282 void ipv6_local_rxpmtu(struct sock *sk, struct flowi6 *fl6, u32 mtu)
283 {
284  struct ipv6_pinfo *np = inet6_sk(sk);
285  struct ipv6hdr *iph;
286  struct sk_buff *skb;
287  struct ip6_mtuinfo *mtu_info;
288 
289  if (!np->rxopt.bits.rxpmtu)
290  return;
291 
292  skb = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
293  if (!skb)
294  return;
295 
296  skb_put(skb, sizeof(struct ipv6hdr));
297  skb_reset_network_header(skb);
298  iph = ipv6_hdr(skb);
299  iph->daddr = fl6->daddr;
300 
301  mtu_info = IP6CBMTU(skb);
302 
303  mtu_info->ip6m_mtu = mtu;
304  mtu_info->ip6m_addr.sin6_family = AF_INET6;
305  mtu_info->ip6m_addr.sin6_port = 0;
306  mtu_info->ip6m_addr.sin6_flowinfo = 0;
307  mtu_info->ip6m_addr.sin6_scope_id = fl6->flowi6_oif;
308  mtu_info->ip6m_addr.sin6_addr = ipv6_hdr(skb)->daddr;
309 
310  __skb_pull(skb, skb_tail_pointer(skb) - skb->data);
311  skb_reset_transport_header(skb);
312 
313  skb = xchg(&np->rxpmtu, skb);
314  kfree_skb(skb);
315 }
316 
317 /*
318  * Handle MSG_ERRQUEUE
319  */
320 int ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len)
321 {
322  struct ipv6_pinfo *np = inet6_sk(sk);
323  struct sock_exterr_skb *serr;
324  struct sk_buff *skb, *skb2;
325  struct sockaddr_in6 *sin;
326  struct {
327  struct sock_extended_err ee;
328  struct sockaddr_in6 offender;
329  } errhdr;
330  int err;
331  int copied;
332 
333  err = -EAGAIN;
334  skb = skb_dequeue(&sk->sk_error_queue);
335  if (skb == NULL)
336  goto out;
337 
338  copied = skb->len;
339  if (copied > len) {
340  msg->msg_flags |= MSG_TRUNC;
341  copied = len;
342  }
343  err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
344  if (err)
345  goto out_free_skb;
346 
347  sock_recv_timestamp(msg, sk, skb);
348 
349  serr = SKB_EXT_ERR(skb);
350 
351  sin = (struct sockaddr_in6 *)msg->msg_name;
352  if (sin) {
353  const unsigned char *nh = skb_network_header(skb);
354  sin->sin6_family = AF_INET6;
355  sin->sin6_flowinfo = 0;
356  sin->sin6_port = serr->port;
357  sin->sin6_scope_id = 0;
358  if (skb->protocol == htons(ETH_P_IPV6)) {
359  sin->sin6_addr =
360  *(struct in6_addr *)(nh + serr->addr_offset);
361  if (np->sndflow)
362  sin->sin6_flowinfo =
363  (*(__be32 *)(nh + serr->addr_offset - 24) &
364  IPV6_FLOWINFO_MASK);
365  if (ipv6_addr_type(&sin->sin6_addr) & IPV6_ADDR_LINKLOCAL)
366  sin->sin6_scope_id = IP6CB(skb)->iif;
367  } else {
368  ipv6_addr_set_v4mapped(*(__be32 *)(nh + serr->addr_offset),
369  &sin->sin6_addr);
370  }
371  }
372 
373  memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
374  sin = &errhdr.offender;
375  sin->sin6_family = AF_UNSPEC;
376  if (serr->ee.ee_origin != SO_EE_ORIGIN_LOCAL) {
377  sin->sin6_family = AF_INET6;
378  sin->sin6_flowinfo = 0;
379  sin->sin6_scope_id = 0;
380  if (skb->protocol == htons(ETH_P_IPV6)) {
381  sin->sin6_addr = ipv6_hdr(skb)->saddr;
382  if (np->rxopt.all)
383  datagram_recv_ctl(sk, msg, skb);
384  if (ipv6_addr_type(&sin->sin6_addr) & IPV6_ADDR_LINKLOCAL)
385  sin->sin6_scope_id = IP6CB(skb)->iif;
386  } else {
387  struct inet_sock *inet = inet_sk(sk);
388 
389  ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr,
390  &sin->sin6_addr);
391  if (inet->cmsg_flags)
392  ip_cmsg_recv(msg, skb);
393  }
394  }
395 
396  put_cmsg(msg, SOL_IPV6, IPV6_RECVERR, sizeof(errhdr), &errhdr);
397 
398  /* Now we could try to dump offended packet options */
399 
400  msg->msg_flags |= MSG_ERRQUEUE;
401  err = copied;
402 
403  /* Reset and regenerate socket error */
404  spin_lock_bh(&sk->sk_error_queue.lock);
405  sk->sk_err = 0;
406  if ((skb2 = skb_peek(&sk->sk_error_queue)) != NULL) {
407  sk->sk_err = SKB_EXT_ERR(skb2)->ee.ee_errno;
408  spin_unlock_bh(&sk->sk_error_queue.lock);
409  sk->sk_error_report(sk);
410  } else {
411  spin_unlock_bh(&sk->sk_error_queue.lock);
412  }
413 
414 out_free_skb:
415  kfree_skb(skb);
416 out:
417  return err;
418 }
419 EXPORT_SYMBOL_GPL(ipv6_recv_error);
420 
421 /*
422  * Handle IPV6_RECVPATHMTU
423  */
424 int ipv6_recv_rxpmtu(struct sock *sk, struct msghdr *msg, int len)
425 {
426  struct ipv6_pinfo *np = inet6_sk(sk);
427  struct sk_buff *skb;
428  struct sockaddr_in6 *sin;
429  struct ip6_mtuinfo mtu_info;
430  int err;
431  int copied;
432 
433  err = -EAGAIN;
434  skb = xchg(&np->rxpmtu, NULL);
435  if (skb == NULL)
436  goto out;
437 
438  copied = skb->len;
439  if (copied > len) {
440  msg->msg_flags |= MSG_TRUNC;
441  copied = len;
442  }
443  err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
444  if (err)
445  goto out_free_skb;
446 
447  sock_recv_timestamp(msg, sk, skb);
448 
449  memcpy(&mtu_info, IP6CBMTU(skb), sizeof(mtu_info));
450 
451  sin = (struct sockaddr_in6 *)msg->msg_name;
452  if (sin) {
453  sin->sin6_family = AF_INET6;
454  sin->sin6_flowinfo = 0;
455  sin->sin6_port = 0;
456  sin->sin6_scope_id = mtu_info.ip6m_addr.sin6_scope_id;
457  sin->sin6_addr = mtu_info.ip6m_addr.sin6_addr;
458  }
459 
460  put_cmsg(msg, SOL_IPV6, IPV6_PATHMTU, sizeof(mtu_info), &mtu_info);
461 
462  err = copied;
463 
464 out_free_skb:
465  kfree_skb(skb);
466 out:
467  return err;
468 }
469 
470 
471 int datagram_recv_ctl(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
472 {
473  struct ipv6_pinfo *np = inet6_sk(sk);
474  struct inet6_skb_parm *opt = IP6CB(skb);
475  unsigned char *nh = skb_network_header(skb);
476 
477  if (np->rxopt.bits.rxinfo) {
478  struct in6_pktinfo src_info;
479 
480  src_info.ipi6_ifindex = opt->iif;
481  src_info.ipi6_addr = ipv6_hdr(skb)->daddr;
482  put_cmsg(msg, SOL_IPV6, IPV6_PKTINFO, sizeof(src_info), &src_info);
483  }
484 
485  if (np->rxopt.bits.rxhlim) {
486  int hlim = ipv6_hdr(skb)->hop_limit;
487  put_cmsg(msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);
488  }
489 
490  if (np->rxopt.bits.rxtclass) {
491  int tclass = ipv6_tclass(ipv6_hdr(skb));
492  put_cmsg(msg, SOL_IPV6, IPV6_TCLASS, sizeof(tclass), &tclass);
493  }
494 
495  if (np->rxopt.bits.rxflow && (*(__be32 *)nh & IPV6_FLOWINFO_MASK)) {
496  __be32 flowinfo = *(__be32 *)nh & IPV6_FLOWINFO_MASK;
497  put_cmsg(msg, SOL_IPV6, IPV6_FLOWINFO, sizeof(flowinfo), &flowinfo);
498  }
499 
500  /* HbH is allowed only once */
501  if (np->rxopt.bits.hopopts && opt->hop) {
502  u8 *ptr = nh + opt->hop;
503  put_cmsg(msg, SOL_IPV6, IPV6_HOPOPTS, (ptr[1]+1)<<3, ptr);
504  }
505 
506  if (opt->lastopt &&
507  (np->rxopt.bits.dstopts || np->rxopt.bits.srcrt)) {
508  /*
509  * Silly enough, but we need to reparse in order to
510  * report extension headers (except for HbH)
511  * in order.
512  *
513  * Also note that IPV6_RECVRTHDRDSTOPTS is NOT
514  * (and WILL NOT be) defined because
515  * IPV6_RECVDSTOPTS is more generic. --yoshfuji
516  */
517  unsigned int off = sizeof(struct ipv6hdr);
518  u8 nexthdr = ipv6_hdr(skb)->nexthdr;
519 
520  while (off <= opt->lastopt) {
521  unsigned int len;
522  u8 *ptr = nh + off;
523 
524  switch (nexthdr) {
525  case IPPROTO_DSTOPTS:
526  nexthdr = ptr[0];
527  len = (ptr[1] + 1) << 3;
528  if (np->rxopt.bits.dstopts)
529  put_cmsg(msg, SOL_IPV6, IPV6_DSTOPTS, len, ptr);
530  break;
531  case IPPROTO_ROUTING:
532  nexthdr = ptr[0];
533  len = (ptr[1] + 1) << 3;
534  if (np->rxopt.bits.srcrt)
535  put_cmsg(msg, SOL_IPV6, IPV6_RTHDR, len, ptr);
536  break;
537  case IPPROTO_AH:
538  nexthdr = ptr[0];
539  len = (ptr[1] + 2) << 2;
540  break;
541  default:
542  nexthdr = ptr[0];
543  len = (ptr[1] + 1) << 3;
544  break;
545  }
546 
547  off += len;
548  }
549  }
550 
551  /* socket options in old style */
552  if (np->rxopt.bits.rxoinfo) {
553  struct in6_pktinfo src_info;
554 
555  src_info.ipi6_ifindex = opt->iif;
556  src_info.ipi6_addr = ipv6_hdr(skb)->daddr;
557  put_cmsg(msg, SOL_IPV6, IPV6_2292PKTINFO, sizeof(src_info), &src_info);
558  }
559  if (np->rxopt.bits.rxohlim) {
560  int hlim = ipv6_hdr(skb)->hop_limit;
561  put_cmsg(msg, SOL_IPV6, IPV6_2292HOPLIMIT, sizeof(hlim), &hlim);
562  }
563  if (np->rxopt.bits.ohopopts && opt->hop) {
564  u8 *ptr = nh + opt->hop;
565  put_cmsg(msg, SOL_IPV6, IPV6_2292HOPOPTS, (ptr[1]+1)<<3, ptr);
566  }
567  if (np->rxopt.bits.odstopts && opt->dst0) {
568  u8 *ptr = nh + opt->dst0;
569  put_cmsg(msg, SOL_IPV6, IPV6_2292DSTOPTS, (ptr[1]+1)<<3, ptr);
570  }
571  if (np->rxopt.bits.osrcrt && opt->srcrt) {
572  struct ipv6_rt_hdr *rthdr = (struct ipv6_rt_hdr *)(nh + opt->srcrt);
573  put_cmsg(msg, SOL_IPV6, IPV6_2292RTHDR, (rthdr->hdrlen+1) << 3, rthdr);
574  }
575  if (np->rxopt.bits.odstopts && opt->dst1) {
576  u8 *ptr = nh + opt->dst1;
577  put_cmsg(msg, SOL_IPV6, IPV6_2292DSTOPTS, (ptr[1]+1)<<3, ptr);
578  }
579  if (np->rxopt.bits.rxorigdstaddr) {
580  struct sockaddr_in6 sin6;
581  __be16 *ports = (__be16 *) skb_transport_header(skb);
582 
583  if (skb_transport_offset(skb) + 4 <= skb->len) {
584  /* All current transport protocols have the port numbers in the
585  * first four bytes of the transport header and this function is
586  * written with this assumption in mind.
587  */
588 
589  sin6.sin6_family = AF_INET6;
590  sin6.sin6_addr = ipv6_hdr(skb)->daddr;
591  sin6.sin6_port = ports[1];
592  sin6.sin6_flowinfo = 0;
593  sin6.sin6_scope_id = 0;
594 
595  put_cmsg(msg, SOL_IPV6, IPV6_ORIGDSTADDR, sizeof(sin6), &sin6);
596  }
597  }
598  return 0;
599 }
600 
601 int datagram_send_ctl(struct net *net, struct sock *sk,
602  struct msghdr *msg, struct flowi6 *fl6,
603  struct ipv6_txoptions *opt,
604  int *hlimit, int *tclass, int *dontfrag)
605 {
606  struct in6_pktinfo *src_info;
607  struct cmsghdr *cmsg;
608  struct ipv6_rt_hdr *rthdr;
609  struct ipv6_opt_hdr *hdr;
610  int len;
611  int err = 0;
612 
613  for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
614  int addr_type;
615 
616  if (!CMSG_OK(msg, cmsg)) {
617  err = -EINVAL;
618  goto exit_f;
619  }
620 
621  if (cmsg->cmsg_level != SOL_IPV6)
622  continue;
623 
624  switch (cmsg->cmsg_type) {
625  case IPV6_PKTINFO:
626  case IPV6_2292PKTINFO:
627  {
628  struct net_device *dev = NULL;
629 
630  if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct in6_pktinfo))) {
631  err = -EINVAL;
632  goto exit_f;
633  }
634 
635  src_info = (struct in6_pktinfo *)CMSG_DATA(cmsg);
636 
637  if (src_info->ipi6_ifindex) {
638  if (fl6->flowi6_oif &&
639  src_info->ipi6_ifindex != fl6->flowi6_oif)
640  return -EINVAL;
641  fl6->flowi6_oif = src_info->ipi6_ifindex;
642  }
643 
644  addr_type = __ipv6_addr_type(&src_info->ipi6_addr);
645 
646  rcu_read_lock();
647  if (fl6->flowi6_oif) {
648  dev = dev_get_by_index_rcu(net, fl6->flowi6_oif);
649  if (!dev) {
650  rcu_read_unlock();
651  return -ENODEV;
652  }
653  } else if (addr_type & IPV6_ADDR_LINKLOCAL) {
654  rcu_read_unlock();
655  return -EINVAL;
656  }
657 
658  if (addr_type != IPV6_ADDR_ANY) {
659  int strict = __ipv6_addr_src_scope(addr_type) <= IPV6_ADDR_SCOPE_LINKLOCAL;
660  if (!(inet_sk(sk)->freebind || inet_sk(sk)->transparent) &&
661  !ipv6_chk_addr(net, &src_info->ipi6_addr,
662  strict ? dev : NULL, 0))
663  err = -EINVAL;
664  else
665  fl6->saddr = src_info->ipi6_addr;
666  }
667 
668  rcu_read_unlock();
669 
670  if (err)
671  goto exit_f;
672 
673  break;
674  }
675 
676  case IPV6_FLOWINFO:
677  if (cmsg->cmsg_len < CMSG_LEN(4)) {
678  err = -EINVAL;
679  goto exit_f;
680  }
681 
682  if (fl6->flowlabel&IPV6_FLOWINFO_MASK) {
683  if ((fl6->flowlabel^*(__be32 *)CMSG_DATA(cmsg))&~IPV6_FLOWINFO_MASK) {
684  err = -EINVAL;
685  goto exit_f;
686  }
687  }
688  fl6->flowlabel = IPV6_FLOWINFO_MASK & *(__be32 *)CMSG_DATA(cmsg);
689  break;
690 
691  case IPV6_2292HOPOPTS:
692  case IPV6_HOPOPTS:
693  if (opt->hopopt || cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
694  err = -EINVAL;
695  goto exit_f;
696  }
697 
698  hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
699  len = ((hdr->hdrlen + 1) << 3);
700  if (cmsg->cmsg_len < CMSG_LEN(len)) {
701  err = -EINVAL;
702  goto exit_f;
703  }
704  if (!capable(CAP_NET_RAW)) {
705  err = -EPERM;
706  goto exit_f;
707  }
708  opt->opt_nflen += len;
709  opt->hopopt = hdr;
710  break;
711 
712  case IPV6_2292DSTOPTS:
713  if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
714  err = -EINVAL;
715  goto exit_f;
716  }
717 
718  hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
719  len = ((hdr->hdrlen + 1) << 3);
720  if (cmsg->cmsg_len < CMSG_LEN(len)) {
721  err = -EINVAL;
722  goto exit_f;
723  }
724  if (!capable(CAP_NET_RAW)) {
725  err = -EPERM;
726  goto exit_f;
727  }
728  if (opt->dst1opt) {
729  err = -EINVAL;
730  goto exit_f;
731  }
732  opt->opt_flen += len;
733  opt->dst1opt = hdr;
734  break;
735 
736  case IPV6_DSTOPTS:
737  case IPV6_RTHDRDSTOPTS:
738  if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
739  err = -EINVAL;
740  goto exit_f;
741  }
742 
743  hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
744  len = ((hdr->hdrlen + 1) << 3);
745  if (cmsg->cmsg_len < CMSG_LEN(len)) {
746  err = -EINVAL;
747  goto exit_f;
748  }
749  if (!capable(CAP_NET_RAW)) {
750  err = -EPERM;
751  goto exit_f;
752  }
753  if (cmsg->cmsg_type == IPV6_DSTOPTS) {
754  opt->opt_flen += len;
755  opt->dst1opt = hdr;
756  } else {
757  opt->opt_nflen += len;
758  opt->dst0opt = hdr;
759  }
760  break;
761 
762  case IPV6_2292RTHDR:
763  case IPV6_RTHDR:
764  if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_rt_hdr))) {
765  err = -EINVAL;
766  goto exit_f;
767  }
768 
769  rthdr = (struct ipv6_rt_hdr *)CMSG_DATA(cmsg);
770 
771  switch (rthdr->type) {
772 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
773  case IPV6_SRCRT_TYPE_2:
774  if (rthdr->hdrlen != 2 ||
775  rthdr->segments_left != 1) {
776  err = -EINVAL;
777  goto exit_f;
778  }
779  break;
780 #endif
781  default:
782  err = -EINVAL;
783  goto exit_f;
784  }
785 
786  len = ((rthdr->hdrlen + 1) << 3);
787 
788  if (cmsg->cmsg_len < CMSG_LEN(len)) {
789  err = -EINVAL;
790  goto exit_f;
791  }
792 
793  /* segments left must also match */
794  if ((rthdr->hdrlen >> 1) != rthdr->segments_left) {
795  err = -EINVAL;
796  goto exit_f;
797  }
798 
799  opt->opt_nflen += len;
800  opt->srcrt = rthdr;
801 
802  if (cmsg->cmsg_type == IPV6_2292RTHDR && opt->dst1opt) {
803  int dsthdrlen = ((opt->dst1opt->hdrlen+1)<<3);
804 
805  opt->opt_nflen += dsthdrlen;
806  opt->dst0opt = opt->dst1opt;
807  opt->dst1opt = NULL;
808  opt->opt_flen -= dsthdrlen;
809  }
810 
811  break;
812 
813  case IPV6_2292HOPLIMIT:
814  case IPV6_HOPLIMIT:
815  if (cmsg->cmsg_len != CMSG_LEN(sizeof(int))) {
816  err = -EINVAL;
817  goto exit_f;
818  }
819 
820  *hlimit = *(int *)CMSG_DATA(cmsg);
821  if (*hlimit < -1 || *hlimit > 0xff) {
822  err = -EINVAL;
823  goto exit_f;
824  }
825 
826  break;
827 
828  case IPV6_TCLASS:
829  {
830  int tc;
831 
832  err = -EINVAL;
833  if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)))
834  goto exit_f;
835 
836  tc = *(int *)CMSG_DATA(cmsg);
837  if (tc < -1 || tc > 0xff)
838  goto exit_f;
839 
840  err = 0;
841  *tclass = tc;
842 
843  break;
844  }
845 
846  case IPV6_DONTFRAG:
847  {
848  int df;
849 
850  err = -EINVAL;
851  if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)))
852  goto exit_f;
853 
854  df = *(int *)CMSG_DATA(cmsg);
855  if (df < 0 || df > 1)
856  goto exit_f;
857 
858  err = 0;
859  *dontfrag = df;
860 
861  break;
862  }
863  default:
864  LIMIT_NETDEBUG(KERN_DEBUG "invalid cmsg type: %d\n",
865  cmsg->cmsg_type);
866  err = -EINVAL;
867  goto exit_f;
868  }
869  }
870 
871 exit_f:
872  return err;
873 }
874 EXPORT_SYMBOL_GPL(datagram_send_ctl);
Generated on Thu Jan 10 2013 14:57:30 for Linux Kernel by   doxygen 1.8.2