ip6_output.c
上传用户:lgb322
上传日期:2013-02-24
资源大小:30529k
文件大小:19k
源码类别:

嵌入式Linux

开发平台:

Unix_Linux

  1. /*
  2.  * IPv6 output functions
  3.  * Linux INET6 implementation 
  4.  *
  5.  * Authors:
  6.  * Pedro Roque <roque@di.fc.ul.pt>
  7.  *
  8.  * $Id: ip6_output.c,v 1.33 2001/09/20 00:35:35 davem Exp $
  9.  *
  10.  * Based on linux/net/ipv4/ip_output.c
  11.  *
  12.  * This program is free software; you can redistribute it and/or
  13.  *      modify it under the terms of the GNU General Public License
  14.  *      as published by the Free Software Foundation; either version
  15.  *      2 of the License, or (at your option) any later version.
  16.  *
  17.  * Changes:
  18.  * A.N.Kuznetsov : airthmetics in fragmentation.
  19.  * extension headers are implemented.
  20.  * route changes now work.
  21.  * ip6_forward does not confuse sniffers.
  22.  * etc.
  23.  *
  24.  *      H. von Brand    :       Added missing #include <linux/string.h>
  25.  * Imran Patel :  frag id should be in NBO
  26.  */
  27. #include <linux/config.h>
  28. #include <linux/errno.h>
  29. #include <linux/types.h>
  30. #include <linux/string.h>
  31. #include <linux/socket.h>
  32. #include <linux/net.h>
  33. #include <linux/netdevice.h>
  34. #include <linux/if_arp.h>
  35. #include <linux/in6.h>
  36. #include <linux/route.h>
  37. #include <linux/netfilter.h>
  38. #include <linux/netfilter_ipv6.h>
  39. #include <net/sock.h>
  40. #include <net/snmp.h>
  41. #include <net/ipv6.h>
  42. #include <net/ndisc.h>
  43. #include <net/protocol.h>
  44. #include <net/ip6_route.h>
  45. #include <net/addrconf.h>
  46. #include <net/rawv6.h>
  47. #include <net/icmp.h>
  48. static __inline__ void ipv6_select_ident(struct sk_buff *skb, struct frag_hdr *fhdr)
  49. {
  50. static u32 ipv6_fragmentation_id = 1;
  51. static spinlock_t ip6_id_lock = SPIN_LOCK_UNLOCKED;
  52. spin_lock_bh(&ip6_id_lock);
  53. fhdr->identification = htonl(ipv6_fragmentation_id);
  54. if (++ipv6_fragmentation_id == 0)
  55. ipv6_fragmentation_id = 1;
  56. spin_unlock_bh(&ip6_id_lock);
  57. }
  58. static inline int ip6_output_finish(struct sk_buff *skb)
  59. {
  60. struct dst_entry *dst = skb->dst;
  61. struct hh_cache *hh = dst->hh;
  62. if (hh) {
  63. read_lock_bh(&hh->hh_lock);
  64. memcpy(skb->data - 16, hh->hh_data, 16);
  65. read_unlock_bh(&hh->hh_lock);
  66.         skb_push(skb, hh->hh_len);
  67. return hh->hh_output(skb);
  68. } else if (dst->neighbour)
  69. return dst->neighbour->output(skb);
  70. kfree_skb(skb);
  71. return -EINVAL;
  72. }
  73. /* dev_loopback_xmit for use with netfilter. */
  74. static int ip6_dev_loopback_xmit(struct sk_buff *newskb)
  75. {
  76. newskb->mac.raw = newskb->data;
  77. __skb_pull(newskb, newskb->nh.raw - newskb->data);
  78. newskb->pkt_type = PACKET_LOOPBACK;
  79. newskb->ip_summed = CHECKSUM_UNNECESSARY;
  80. BUG_TRAP(newskb->dst);
  81. netif_rx(newskb);
  82. return 0;
  83. }
  84. int ip6_output(struct sk_buff *skb)
  85. {
  86. struct dst_entry *dst = skb->dst;
  87. struct net_device *dev = dst->dev;
  88. skb->protocol = __constant_htons(ETH_P_IPV6);
  89. skb->dev = dev;
  90. if (ipv6_addr_is_multicast(&skb->nh.ipv6h->daddr)) {
  91. if (!(dev->flags&IFF_LOOPBACK) &&
  92.     (skb->sk == NULL || skb->sk->net_pinfo.af_inet6.mc_loop) &&
  93.     ipv6_chk_mcast_addr(dev, &skb->nh.ipv6h->daddr)) {
  94. struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC);
  95. /* Do not check for IFF_ALLMULTI; multicast routing
  96.    is not supported in any case.
  97.  */
  98. if (newskb)
  99. NF_HOOK(PF_INET6, NF_IP6_POST_ROUTING, newskb, NULL,
  100. newskb->dev,
  101. ip6_dev_loopback_xmit);
  102. if (skb->nh.ipv6h->hop_limit == 0) {
  103. kfree_skb(skb);
  104. return 0;
  105. }
  106. }
  107. IP6_INC_STATS(Ip6OutMcastPkts);
  108. }
  109. return NF_HOOK(PF_INET6, NF_IP6_POST_ROUTING, skb,NULL, skb->dev,ip6_output_finish);
  110. }
  111. #ifdef CONFIG_NETFILTER
  112. static int route6_me_harder(struct sk_buff *skb)
  113. {
  114. struct ipv6hdr *iph = skb->nh.ipv6h;
  115. struct dst_entry *dst;
  116. struct flowi fl;
  117. fl.proto = iph->nexthdr;
  118. fl.fl6_dst = &iph->daddr;
  119. fl.fl6_src = &iph->saddr;
  120. fl.oif = skb->sk ? skb->sk->bound_dev_if : 0;
  121. fl.fl6_flowlabel = 0;
  122. fl.uli_u.ports.dport = 0;
  123. fl.uli_u.ports.sport = 0;
  124. dst = ip6_route_output(skb->sk, &fl);
  125. if (dst->error) {
  126. if (net_ratelimit())
  127. printk(KERN_DEBUG "route6_me_harder: No more route.n");
  128. return -EINVAL;
  129. }
  130. /* Drop old route. */
  131. dst_release(skb->dst);
  132. skb->dst = dst;
  133. return 0;
  134. }
  135. #endif
  136. static inline int ip6_maybe_reroute(struct sk_buff *skb)
  137. {
  138. #ifdef CONFIG_NETFILTER
  139. if (skb->nfcache & NFC_ALTERED){
  140. if (route6_me_harder(skb) != 0){
  141. kfree_skb(skb);
  142. return -EINVAL;
  143. }
  144. }
  145. #endif /* CONFIG_NETFILTER */
  146. return skb->dst->output(skb);
  147. }
  148. /*
  149.  * xmit an sk_buff (used by TCP)
  150.  */
  151. int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl,
  152.      struct ipv6_txoptions *opt)
  153. {
  154. struct ipv6_pinfo * np = sk ? &sk->net_pinfo.af_inet6 : NULL;
  155. struct in6_addr *first_hop = fl->nl_u.ip6_u.daddr;
  156. struct dst_entry *dst = skb->dst;
  157. struct ipv6hdr *hdr;
  158. u8  proto = fl->proto;
  159. int seg_len = skb->len;
  160. int hlimit;
  161. if (opt) {
  162. int head_room;
  163. /* First: exthdrs may take lots of space (~8K for now)
  164.    MAX_HEADER is not enough.
  165.  */
  166. head_room = opt->opt_nflen + opt->opt_flen;
  167. seg_len += head_room;
  168. head_room += sizeof(struct ipv6hdr) + ((dst->dev->hard_header_len + 15)&~15);
  169. if (skb_headroom(skb) < head_room) {
  170. struct sk_buff *skb2 = skb_realloc_headroom(skb, head_room);
  171. kfree_skb(skb);
  172. skb = skb2;
  173. if (skb == NULL)
  174. return -ENOBUFS;
  175. if (sk)
  176. skb_set_owner_w(skb, sk);
  177. }
  178. if (opt->opt_flen)
  179. ipv6_push_frag_opts(skb, opt, &proto);
  180. if (opt->opt_nflen)
  181. ipv6_push_nfrag_opts(skb, opt, &proto, &first_hop);
  182. }
  183. hdr = skb->nh.ipv6h = (struct ipv6hdr*)skb_push(skb, sizeof(struct ipv6hdr));
  184. /*
  185.  * Fill in the IPv6 header
  186.  */
  187. *(u32*)hdr = __constant_htonl(0x60000000) | fl->fl6_flowlabel;
  188. hlimit = -1;
  189. if (np)
  190. hlimit = np->hop_limit;
  191. if (hlimit < 0)
  192. hlimit = ((struct rt6_info*)dst)->rt6i_hoplimit;
  193. hdr->payload_len = htons(seg_len);
  194. hdr->nexthdr = proto;
  195. hdr->hop_limit = hlimit;
  196. ipv6_addr_copy(&hdr->saddr, fl->nl_u.ip6_u.saddr);
  197. ipv6_addr_copy(&hdr->daddr, first_hop);
  198. if (skb->len <= dst->pmtu) {
  199. IP6_INC_STATS(Ip6OutRequests);
  200. return NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, ip6_maybe_reroute);
  201. }
  202. if (net_ratelimit())
  203. printk(KERN_DEBUG "IPv6: sending pkt_too_big to selfn");
  204. icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, dst->pmtu, skb->dev);
  205. kfree_skb(skb);
  206. return -EMSGSIZE;
  207. }
  208. /*
  209.  * To avoid extra problems ND packets are send through this
  210.  * routine. It's code duplication but I really want to avoid
  211.  * extra checks since ipv6_build_header is used by TCP (which
  212.  * is for us performace critical)
  213.  */
  214. int ip6_nd_hdr(struct sock *sk, struct sk_buff *skb, struct net_device *dev,
  215.        struct in6_addr *saddr, struct in6_addr *daddr,
  216.        int proto, int len)
  217. {
  218. struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;
  219. struct ipv6hdr *hdr;
  220. int totlen;
  221. skb->protocol = __constant_htons(ETH_P_IPV6);
  222. skb->dev = dev;
  223. totlen = len + sizeof(struct ipv6hdr);
  224. hdr = (struct ipv6hdr *) skb_put(skb, sizeof(struct ipv6hdr));
  225. skb->nh.ipv6h = hdr;
  226. *(u32*)hdr = htonl(0x60000000);
  227. hdr->payload_len = htons(len);
  228. hdr->nexthdr = proto;
  229. hdr->hop_limit = np->hop_limit;
  230. ipv6_addr_copy(&hdr->saddr, saddr);
  231. ipv6_addr_copy(&hdr->daddr, daddr);
  232. return 0;
  233. }
  234. static struct ipv6hdr * ip6_bld_1(struct sock *sk, struct sk_buff *skb, struct flowi *fl,
  235.   int hlimit, unsigned pktlength)
  236. {
  237. struct ipv6hdr *hdr;
  238. skb->nh.raw = skb_put(skb, sizeof(struct ipv6hdr));
  239. hdr = skb->nh.ipv6h;
  240. *(u32*)hdr = fl->fl6_flowlabel | htonl(0x60000000);
  241. hdr->payload_len = htons(pktlength - sizeof(struct ipv6hdr));
  242. hdr->hop_limit = hlimit;
  243. hdr->nexthdr = fl->proto;
  244. ipv6_addr_copy(&hdr->saddr, fl->nl_u.ip6_u.saddr);
  245. ipv6_addr_copy(&hdr->daddr, fl->nl_u.ip6_u.daddr);
  246. return hdr;
  247. }
  248. static __inline__ u8 * ipv6_build_fraghdr(struct sk_buff *skb, u8* prev_hdr, unsigned offset)
  249. {
  250. struct frag_hdr *fhdr;
  251. fhdr = (struct frag_hdr *) skb_put(skb, sizeof(struct frag_hdr));
  252. fhdr->nexthdr  = *prev_hdr;
  253. *prev_hdr = NEXTHDR_FRAGMENT;
  254. prev_hdr = &fhdr->nexthdr;
  255. fhdr->reserved = 0;
  256. fhdr->frag_off = htons(offset);
  257. ipv6_select_ident(skb, fhdr);
  258. return &fhdr->nexthdr;
  259. }
  260. static int ip6_frag_xmit(struct sock *sk, inet_getfrag_t getfrag,
  261.  const void *data, struct dst_entry *dst,
  262.  struct flowi *fl, struct ipv6_txoptions *opt,
  263.  struct in6_addr *final_dst,
  264.  int hlimit, int flags, unsigned length, int mtu)
  265. {
  266. struct ipv6hdr *hdr;
  267. struct sk_buff *last_skb;
  268. u8 *prev_hdr;
  269. int unfrag_len;
  270. int frag_len;
  271. int last_len;
  272. int nfrags;
  273. int fhdr_dist;
  274. int frag_off;
  275. int data_off;
  276. int err;
  277. /*
  278.  * Fragmentation
  279.  *
  280.  * Extension header order:
  281.  * Hop-by-hop -> Dest0 -> Routing -> Fragment -> Auth -> Dest1 -> rest (...)
  282.  *
  283.  * We must build the non-fragmented part that
  284.  * will be in every packet... this also means
  285.  * that other extension headers (Dest, Auth, etc)
  286.  * must be considered in the data to be fragmented
  287.  */
  288. unfrag_len = sizeof(struct ipv6hdr) + sizeof(struct frag_hdr);
  289. last_len = length;
  290. if (opt) {
  291. unfrag_len += opt->opt_nflen;
  292. last_len += opt->opt_flen;
  293. }
  294. /*
  295.  * Length of fragmented part on every packet but 
  296.  * the last must be an:
  297.  * "integer multiple of 8 octects".
  298.  */
  299. frag_len = (mtu - unfrag_len) & ~0x7;
  300. /* Unfragmentable part exceeds mtu. */
  301. if (frag_len <= 0) {
  302. ipv6_local_error(sk, EMSGSIZE, fl, mtu);
  303. return -EMSGSIZE;
  304. }
  305. nfrags = last_len / frag_len;
  306. /*
  307.  * We must send from end to start because of 
  308.  * UDP/ICMP checksums. We do a funny trick:
  309.  * fill the last skb first with the fixed
  310.  * header (and its data) and then use it
  311.  * to create the following segments and send it
  312.  * in the end. If the peer is checking the M_flag
  313.  * to trigger the reassembly code then this 
  314.  * might be a good idea.
  315.  */
  316. frag_off = nfrags * frag_len;
  317. last_len -= frag_off;
  318. if (last_len == 0) {
  319. last_len = frag_len;
  320. frag_off -= frag_len;
  321. nfrags--;
  322. }
  323. data_off = frag_off;
  324. /* And it is implementation problem: for now we assume, that
  325.    all the exthdrs will fit to the first fragment.
  326.  */
  327. if (opt) {
  328. if (frag_len < opt->opt_flen) {
  329. ipv6_local_error(sk, EMSGSIZE, fl, mtu);
  330. return -EMSGSIZE;
  331. }
  332. data_off = frag_off - opt->opt_flen;
  333. }
  334. if (flags&MSG_PROBE)
  335. return 0;
  336. last_skb = sock_alloc_send_skb(sk, unfrag_len + frag_len +
  337.        dst->dev->hard_header_len + 15,
  338.        flags & MSG_DONTWAIT, &err);
  339. if (last_skb == NULL)
  340. return err;
  341. last_skb->dst = dst_clone(dst);
  342. skb_reserve(last_skb, (dst->dev->hard_header_len + 15) & ~15);
  343. hdr = ip6_bld_1(sk, last_skb, fl, hlimit, frag_len+unfrag_len);
  344. prev_hdr = &hdr->nexthdr;
  345. if (opt && opt->opt_nflen)
  346. prev_hdr = ipv6_build_nfrag_opts(last_skb, prev_hdr, opt, final_dst, 0);
  347. prev_hdr = ipv6_build_fraghdr(last_skb, prev_hdr, frag_off);
  348. fhdr_dist = prev_hdr - last_skb->data;
  349. err = getfrag(data, &hdr->saddr, last_skb->tail, data_off, last_len);
  350. if (!err) {
  351. while (nfrags--) {
  352. struct sk_buff *skb;
  353. struct frag_hdr *fhdr2;
  354. skb = skb_copy(last_skb, sk->allocation);
  355. if (skb == NULL) {
  356. IP6_INC_STATS(Ip6FragFails);
  357. kfree_skb(last_skb);
  358. return -ENOMEM;
  359. }
  360. frag_off -= frag_len;
  361. data_off -= frag_len;
  362. fhdr2 = (struct frag_hdr *) (skb->data + fhdr_dist);
  363. /* more flag on */
  364. fhdr2->frag_off = htons(frag_off | 1);
  365. /* Write fragmentable exthdrs to the first chunk */
  366. if (nfrags == 0 && opt && opt->opt_flen) {
  367. ipv6_build_frag_opts(skb, &fhdr2->nexthdr, opt);
  368. frag_len -= opt->opt_flen;
  369. data_off = 0;
  370. }
  371. err = getfrag(data, &hdr->saddr,skb_put(skb, frag_len),
  372.       data_off, frag_len);
  373. if (err) {
  374. kfree_skb(skb);
  375. break;
  376. }
  377. IP6_INC_STATS(Ip6FragCreates);
  378. IP6_INC_STATS(Ip6OutRequests);
  379. err = NF_HOOK(PF_INET6,NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, ip6_maybe_reroute);
  380. if (err) {
  381. kfree_skb(last_skb);
  382. return err;
  383. }
  384. }
  385. }
  386. if (err) {
  387. IP6_INC_STATS(Ip6FragFails);
  388. kfree_skb(last_skb);
  389. return -EFAULT;
  390. }
  391. hdr->payload_len = htons(unfrag_len + last_len - sizeof(struct ipv6hdr));
  392. /*
  393.  * update last_skb to reflect the getfrag we did
  394.  * on start.
  395.  */
  396. skb_put(last_skb, last_len);
  397. IP6_INC_STATS(Ip6FragCreates);
  398. IP6_INC_STATS(Ip6FragOKs);
  399. IP6_INC_STATS(Ip6OutRequests);
  400. return NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, last_skb, NULL,dst->dev, ip6_maybe_reroute);
  401. }
  402. int ip6_build_xmit(struct sock *sk, inet_getfrag_t getfrag, const void *data,
  403.    struct flowi *fl, unsigned length,
  404.    struct ipv6_txoptions *opt, int hlimit, int flags)
  405. {
  406. struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;
  407. struct in6_addr *final_dst = NULL;
  408. struct dst_entry *dst;
  409. int err = 0;
  410. unsigned int pktlength, jumbolen, mtu;
  411. struct in6_addr saddr;
  412. if (opt && opt->srcrt) {
  413. struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
  414. final_dst = fl->fl6_dst;
  415. fl->fl6_dst = rt0->addr;
  416. }
  417. if (!fl->oif && ipv6_addr_is_multicast(fl->nl_u.ip6_u.daddr))
  418. fl->oif = np->mcast_oif;
  419. dst = __sk_dst_check(sk, np->dst_cookie);
  420. if (dst) {
  421. struct rt6_info *rt = (struct rt6_info*)dst;
  422. /* Yes, checking route validity in not connected
  423.    case is not very simple. Take into account,
  424.    that we do not support routing by source, TOS,
  425.    and MSG_DONTROUTE  --ANK (980726)
  426.    1. If route was host route, check that
  427.       cached destination is current.
  428.       If it is network route, we still may
  429.       check its validity using saved pointer
  430.       to the last used address: daddr_cache.
  431.       We do not want to save whole address now,
  432.       (because main consumer of this service
  433.        is tcp, which has not this problem),
  434.       so that the last trick works only on connected
  435.       sockets.
  436.    2. oif also should be the same.
  437.  */
  438. if (((rt->rt6i_dst.plen != 128 ||
  439.       ipv6_addr_cmp(fl->fl6_dst, &rt->rt6i_dst.addr))
  440.      && (np->daddr_cache == NULL ||
  441.  ipv6_addr_cmp(fl->fl6_dst, np->daddr_cache)))
  442.     || (fl->oif && fl->oif != dst->dev->ifindex)) {
  443. dst = NULL;
  444. } else
  445. dst_clone(dst);
  446. }
  447. if (dst == NULL)
  448. dst = ip6_route_output(sk, fl);
  449. if (dst->error) {
  450. IP6_INC_STATS(Ip6OutNoRoutes);
  451. dst_release(dst);
  452. return -ENETUNREACH;
  453. }
  454. if (fl->fl6_src == NULL) {
  455. err = ipv6_get_saddr(dst, fl->fl6_dst, &saddr);
  456. if (err) {
  457. #if IP6_DEBUG >= 2
  458. printk(KERN_DEBUG "ip6_build_xmit: "
  459.        "no availiable source addressn");
  460. #endif
  461. goto out;
  462. }
  463. fl->fl6_src = &saddr;
  464. }
  465. pktlength = length;
  466. if (hlimit < 0) {
  467. if (ipv6_addr_is_multicast(fl->fl6_dst))
  468. hlimit = np->mcast_hops;
  469. else
  470. hlimit = np->hop_limit;
  471. if (hlimit < 0)
  472. hlimit = ((struct rt6_info*)dst)->rt6i_hoplimit;
  473. }
  474. jumbolen = 0;
  475. if (!sk->protinfo.af_inet.hdrincl) {
  476. pktlength += sizeof(struct ipv6hdr);
  477. if (opt)
  478. pktlength += opt->opt_flen + opt->opt_nflen;
  479. if (pktlength > 0xFFFF + sizeof(struct ipv6hdr)) {
  480. /* Jumbo datagram.
  481.    It is assumed, that in the case of hdrincl
  482.    jumbo option is supplied by user.
  483.  */
  484. pktlength += 8;
  485. jumbolen = pktlength - sizeof(struct ipv6hdr);
  486. }
  487. }
  488. mtu = dst->pmtu;
  489. if (np->frag_size < mtu) {
  490. if (np->frag_size)
  491. mtu = np->frag_size;
  492. else if (np->pmtudisc == IPV6_PMTUDISC_DONT)
  493. mtu = IPV6_MIN_MTU;
  494. }
  495. /* Critical arithmetic overflow check.
  496.    FIXME: may gcc optimize it out? --ANK (980726)
  497.  */
  498. if (pktlength < length) {
  499. ipv6_local_error(sk, EMSGSIZE, fl, mtu);
  500. err = -EMSGSIZE;
  501. goto out;
  502. }
  503. if (flags&MSG_CONFIRM)
  504. dst_confirm(dst);
  505. if (pktlength <= mtu) {
  506. struct sk_buff *skb;
  507. struct ipv6hdr *hdr;
  508. struct net_device *dev = dst->dev;
  509. err = 0;
  510. if (flags&MSG_PROBE)
  511. goto out;
  512. skb = sock_alloc_send_skb(sk, pktlength + 15 +
  513.   dev->hard_header_len,
  514.   flags & MSG_DONTWAIT, &err);
  515. if (skb == NULL) {
  516. IP6_INC_STATS(Ip6OutDiscards);
  517. goto out;
  518. }
  519. skb->dst = dst_clone(dst);
  520. skb_reserve(skb, (dev->hard_header_len + 15) & ~15);
  521. hdr = (struct ipv6hdr *) skb->tail;
  522. skb->nh.ipv6h = hdr;
  523. if (!sk->protinfo.af_inet.hdrincl) {
  524. ip6_bld_1(sk, skb, fl, hlimit,
  525.   jumbolen ? sizeof(struct ipv6hdr) : pktlength);
  526. if (opt || jumbolen) {
  527. u8 *prev_hdr = &hdr->nexthdr;
  528. prev_hdr = ipv6_build_nfrag_opts(skb, prev_hdr, opt, final_dst, jumbolen);
  529. if (opt && opt->opt_flen)
  530. ipv6_build_frag_opts(skb, prev_hdr, opt);
  531. }
  532. }
  533. skb_put(skb, length);
  534. err = getfrag(data, &hdr->saddr,
  535.       ((char *) hdr) + (pktlength - length),
  536.       0, length);
  537. if (!err) {
  538. IP6_INC_STATS(Ip6OutRequests);
  539. err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, ip6_maybe_reroute);
  540. } else {
  541. err = -EFAULT;
  542. kfree_skb(skb);
  543. }
  544. } else {
  545. if (sk->protinfo.af_inet.hdrincl || jumbolen ||
  546.     np->pmtudisc == IPV6_PMTUDISC_DO) {
  547. ipv6_local_error(sk, EMSGSIZE, fl, mtu);
  548. err = -EMSGSIZE;
  549. goto out;
  550. }
  551. err = ip6_frag_xmit(sk, getfrag, data, dst, fl, opt, final_dst, hlimit,
  552.     flags, length, mtu);
  553. }
  554. /*
  555.  * cleanup
  556.  */
  557. out:
  558. ip6_dst_store(sk, dst, fl->nl_u.ip6_u.daddr == &np->daddr ? &np->daddr : NULL);
  559. if (err > 0)
  560. err = np->recverr ? net_xmit_errno(err) : 0;
  561. return err;
  562. }
  563. int ip6_call_ra_chain(struct sk_buff *skb, int sel)
  564. {
  565. struct ip6_ra_chain *ra;
  566. struct sock *last = NULL;
  567. read_lock(&ip6_ra_lock);
  568. for (ra = ip6_ra_chain; ra; ra = ra->next) {
  569. struct sock *sk = ra->sk;
  570. if (sk && ra->sel == sel) {
  571. if (last) {
  572. struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
  573. if (skb2)
  574. rawv6_rcv(last, skb2);
  575. }
  576. last = sk;
  577. }
  578. }
  579. if (last) {
  580. rawv6_rcv(last, skb);
  581. read_unlock(&ip6_ra_lock);
  582. return 1;
  583. }
  584. read_unlock(&ip6_ra_lock);
  585. return 0;
  586. }
  587. static inline int ip6_forward_finish(struct sk_buff *skb)
  588. {
  589. return skb->dst->output(skb);
  590. }
  591. int ip6_forward(struct sk_buff *skb)
  592. {
  593. struct dst_entry *dst = skb->dst;
  594. struct ipv6hdr *hdr = skb->nh.ipv6h;
  595. struct inet6_skb_parm *opt =(struct inet6_skb_parm*)skb->cb;
  596. if (ipv6_devconf.forwarding == 0)
  597. goto error;
  598. skb->ip_summed = CHECKSUM_NONE;
  599. /*
  600.  * We DO NOT make any processing on
  601.  * RA packets, pushing them to user level AS IS
  602.  * without ane WARRANTY that application will be able
  603.  * to interpret them. The reason is that we
  604.  * cannot make anything clever here.
  605.  *
  606.  * We are not end-node, so that if packet contains
  607.  * AH/ESP, we cannot make anything.
  608.  * Defragmentation also would be mistake, RA packets
  609.  * cannot be fragmented, because there is no warranty
  610.  * that different fragments will go along one path. --ANK
  611.  */
  612. if (opt->ra) {
  613. u8 *ptr = skb->nh.raw + opt->ra;
  614. if (ip6_call_ra_chain(skb, (ptr[2]<<8) + ptr[3]))
  615. return 0;
  616. }
  617. /*
  618.  * check and decrement ttl
  619.  */
  620. if (hdr->hop_limit <= 1) {
  621. /* Force OUTPUT device used as source address */
  622. skb->dev = dst->dev;
  623. icmpv6_send(skb, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT,
  624.     0, skb->dev);
  625. kfree_skb(skb);
  626. return -ETIMEDOUT;
  627. }
  628. /* IPv6 specs say nothing about it, but it is clear that we cannot
  629.    send redirects to source routed frames.
  630.  */
  631. if (skb->dev == dst->dev && dst->neighbour && opt->srcrt == 0) {
  632. struct in6_addr *target = NULL;
  633. struct rt6_info *rt;
  634. struct neighbour *n = dst->neighbour;
  635. /*
  636.  * incoming and outgoing devices are the same
  637.  * send a redirect.
  638.  */
  639. rt = (struct rt6_info *) dst;
  640. if ((rt->rt6i_flags & RTF_GATEWAY))
  641. target = (struct in6_addr*)&n->primary_key;
  642. else
  643. target = &hdr->daddr;
  644. /* Limit redirects both by destination (here)
  645.    and by source (inside ndisc_send_redirect)
  646.  */
  647. if (xrlim_allow(dst, 1*HZ))
  648. ndisc_send_redirect(skb, n, target);
  649. } else if (ipv6_addr_type(&hdr->saddr)&(IPV6_ADDR_MULTICAST|IPV6_ADDR_LOOPBACK
  650. |IPV6_ADDR_LINKLOCAL)) {
  651. /* This check is security critical. */
  652. goto error;
  653. }
  654. if (skb->len > dst->pmtu) {
  655. /* Again, force OUTPUT device used as source address */
  656. skb->dev = dst->dev;
  657. icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, dst->pmtu, skb->dev);
  658. IP6_INC_STATS_BH(Ip6InTooBigErrors);
  659. kfree_skb(skb);
  660. return -EMSGSIZE;
  661. }
  662. if (skb_cow(skb, dst->dev->hard_header_len))
  663. goto drop;
  664. hdr = skb->nh.ipv6h;
  665. /* Mangling hops number delayed to point after skb COW */
  666.  
  667. hdr->hop_limit--;
  668. IP6_INC_STATS_BH(Ip6OutForwDatagrams);
  669. return NF_HOOK(PF_INET6,NF_IP6_FORWARD, skb, skb->dev, dst->dev, ip6_forward_finish);
  670. error:
  671. IP6_INC_STATS_BH(Ip6InAddrErrors);
  672. drop:
  673. kfree_skb(skb);
  674. return -EINVAL;
  675. }