reassembly.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806
  1. /*
  2. * IPv6 fragment reassembly
  3. * Linux INET6 implementation
  4. *
  5. * Authors:
  6. * Pedro Roque <roque@di.fc.ul.pt>
  7. *
  8. * Based on: net/ipv4/ip_fragment.c
  9. *
  10. * This program is free software; you can redistribute it and/or
  11. * modify it under the terms of the GNU General Public License
  12. * as published by the Free Software Foundation; either version
  13. * 2 of the License, or (at your option) any later version.
  14. */
  15. /*
  16. * Fixes:
  17. * Andi Kleen Make it work with multiple hosts.
  18. * More RFC compliance.
  19. *
  20. * Horst von Brand Add missing #include <linux/string.h>
  21. * Alexey Kuznetsov SMP races, threading, cleanup.
  22. * Patrick McHardy LRU queue of frag heads for evictor.
  23. * Mitsuru KANDA @USAGI Register inet6_protocol{}.
  24. * David Stevens and
  25. * YOSHIFUJI,H. @USAGI Always remove fragment header to
  26. * calculate ICV correctly.
  27. */
  28. #include <linux/errno.h>
  29. #include <linux/types.h>
  30. #include <linux/string.h>
  31. #include <linux/socket.h>
  32. #include <linux/sockios.h>
  33. #include <linux/jiffies.h>
  34. #include <linux/net.h>
  35. #include <linux/list.h>
  36. #include <linux/netdevice.h>
  37. #include <linux/in6.h>
  38. #include <linux/ipv6.h>
  39. #include <linux/icmpv6.h>
  40. #include <linux/random.h>
  41. #include <linux/jhash.h>
  42. #include <linux/skbuff.h>
  43. #include <net/sock.h>
  44. #include <net/snmp.h>
  45. #include <net/ipv6.h>
  46. #include <net/ip6_route.h>
  47. #include <net/protocol.h>
  48. #include <net/transp_v6.h>
  49. #include <net/rawv6.h>
  50. #include <net/ndisc.h>
  51. #include <net/addrconf.h>
  52. #include <net/inet_frag.h>
  53. struct ip6frag_skb_cb
  54. {
  55. struct inet6_skb_parm h;
  56. int offset;
  57. };
  58. #define FRAG6_CB(skb) ((struct ip6frag_skb_cb*)((skb)->cb))
  59. /*
  60. * Equivalent of ipv4 struct ipq
  61. */
  62. struct frag_queue
  63. {
  64. struct inet_frag_queue q;
  65. __be32 id; /* fragment id */
  66. u32 user;
  67. struct in6_addr saddr;
  68. struct in6_addr daddr;
  69. int iif;
  70. unsigned int csum;
  71. __u16 nhoffset;
  72. };
  73. static struct inet_frags ip6_frags;
  74. int ip6_frag_nqueues(struct net *net)
  75. {
  76. return net->ipv6.frags.nqueues;
  77. }
  78. int ip6_frag_mem(struct net *net)
  79. {
  80. return atomic_read(&net->ipv6.frags.mem);
  81. }
  82. static int ip6_frag_reasm(struct frag_queue *fq, struct sk_buff *prev,
  83. struct net_device *dev);
  84. /*
  85. * callers should be careful not to use the hash value outside the ipfrag_lock
  86. * as doing so could race with ipfrag_hash_rnd being recalculated.
  87. */
  88. unsigned int inet6_hash_frag(__be32 id, const struct in6_addr *saddr,
  89. const struct in6_addr *daddr, u32 rnd)
  90. {
  91. u32 a, b, c;
  92. a = (__force u32)saddr->s6_addr32[0];
  93. b = (__force u32)saddr->s6_addr32[1];
  94. c = (__force u32)saddr->s6_addr32[2];
  95. a += JHASH_GOLDEN_RATIO;
  96. b += JHASH_GOLDEN_RATIO;
  97. c += rnd;
  98. __jhash_mix(a, b, c);
  99. a += (__force u32)saddr->s6_addr32[3];
  100. b += (__force u32)daddr->s6_addr32[0];
  101. c += (__force u32)daddr->s6_addr32[1];
  102. __jhash_mix(a, b, c);
  103. a += (__force u32)daddr->s6_addr32[2];
  104. b += (__force u32)daddr->s6_addr32[3];
  105. c += (__force u32)id;
  106. __jhash_mix(a, b, c);
  107. return c & (INETFRAGS_HASHSZ - 1);
  108. }
  109. EXPORT_SYMBOL_GPL(inet6_hash_frag);
  110. static unsigned int ip6_hashfn(struct inet_frag_queue *q)
  111. {
  112. struct frag_queue *fq;
  113. fq = container_of(q, struct frag_queue, q);
  114. return inet6_hash_frag(fq->id, &fq->saddr, &fq->daddr, ip6_frags.rnd);
  115. }
  116. int ip6_frag_match(struct inet_frag_queue *q, void *a)
  117. {
  118. struct frag_queue *fq;
  119. struct ip6_create_arg *arg = a;
  120. fq = container_of(q, struct frag_queue, q);
  121. return (fq->id == arg->id && fq->user == arg->user &&
  122. ipv6_addr_equal(&fq->saddr, arg->src) &&
  123. ipv6_addr_equal(&fq->daddr, arg->dst));
  124. }
  125. EXPORT_SYMBOL(ip6_frag_match);
  126. /* Memory Tracking Functions. */
  127. static inline void frag_kfree_skb(struct netns_frags *nf,
  128. struct sk_buff *skb, int *work)
  129. {
  130. if (work)
  131. *work -= skb->truesize;
  132. atomic_sub(skb->truesize, &nf->mem);
  133. kfree_skb(skb);
  134. }
  135. void ip6_frag_init(struct inet_frag_queue *q, void *a)
  136. {
  137. struct frag_queue *fq = container_of(q, struct frag_queue, q);
  138. struct ip6_create_arg *arg = a;
  139. fq->id = arg->id;
  140. fq->user = arg->user;
  141. ipv6_addr_copy(&fq->saddr, arg->src);
  142. ipv6_addr_copy(&fq->daddr, arg->dst);
  143. }
  144. EXPORT_SYMBOL(ip6_frag_init);
  145. /* Destruction primitives. */
  146. static __inline__ void fq_put(struct frag_queue *fq)
  147. {
  148. inet_frag_put(&fq->q, &ip6_frags);
  149. }
  150. /* Kill fq entry. It is not destroyed immediately,
  151. * because caller (and someone more) holds reference count.
  152. */
  153. static __inline__ void fq_kill(struct frag_queue *fq)
  154. {
  155. inet_frag_kill(&fq->q, &ip6_frags);
  156. }
  157. static void ip6_evictor(struct net *net, struct inet6_dev *idev)
  158. {
  159. int evicted;
  160. evicted = inet_frag_evictor(&net->ipv6.frags, &ip6_frags);
  161. if (evicted)
  162. IP6_ADD_STATS_BH(net, idev, IPSTATS_MIB_REASMFAILS, evicted);
  163. }
  164. static void ip6_frag_expire(unsigned long data)
  165. {
  166. struct frag_queue *fq;
  167. struct net_device *dev = NULL;
  168. struct net *net;
  169. fq = container_of((struct inet_frag_queue *)data, struct frag_queue, q);
  170. spin_lock(&fq->q.lock);
  171. if (fq->q.last_in & INET_FRAG_COMPLETE)
  172. goto out;
  173. fq_kill(fq);
  174. net = container_of(fq->q.net, struct net, ipv6.frags);
  175. rcu_read_lock();
  176. dev = dev_get_by_index_rcu(net, fq->iif);
  177. if (!dev)
  178. goto out_rcu_unlock;
  179. IP6_INC_STATS_BH(net, __in6_dev_get(dev), IPSTATS_MIB_REASMTIMEOUT);
  180. IP6_INC_STATS_BH(net, __in6_dev_get(dev), IPSTATS_MIB_REASMFAILS);
  181. /* Don't send error if the first segment did not arrive. */
  182. if (!(fq->q.last_in & INET_FRAG_FIRST_IN) || !fq->q.fragments)
  183. goto out_rcu_unlock;
  184. /*
  185. But use as source device on which LAST ARRIVED
  186. segment was received. And do not use fq->dev
  187. pointer directly, device might already disappeared.
  188. */
  189. fq->q.fragments->dev = dev;
  190. icmpv6_send(fq->q.fragments, ICMPV6_TIME_EXCEED, ICMPV6_EXC_FRAGTIME, 0);
  191. out_rcu_unlock:
  192. rcu_read_unlock();
  193. out:
  194. spin_unlock(&fq->q.lock);
  195. fq_put(fq);
  196. }
  197. static __inline__ struct frag_queue *
  198. fq_find(struct net *net, __be32 id, struct in6_addr *src, struct in6_addr *dst)
  199. {
  200. struct inet_frag_queue *q;
  201. struct ip6_create_arg arg;
  202. unsigned int hash;
  203. arg.id = id;
  204. arg.user = IP6_DEFRAG_LOCAL_DELIVER;
  205. arg.src = src;
  206. arg.dst = dst;
  207. read_lock(&ip6_frags.lock);
  208. hash = inet6_hash_frag(id, src, dst, ip6_frags.rnd);
  209. q = inet_frag_find(&net->ipv6.frags, &ip6_frags, &arg, hash);
  210. if (q == NULL)
  211. return NULL;
  212. return container_of(q, struct frag_queue, q);
  213. }
  214. static int ip6_frag_queue(struct frag_queue *fq, struct sk_buff *skb,
  215. struct frag_hdr *fhdr, int nhoff)
  216. {
  217. struct sk_buff *prev, *next;
  218. struct net_device *dev;
  219. int offset, end;
  220. struct net *net = dev_net(skb_dst(skb)->dev);
  221. if (fq->q.last_in & INET_FRAG_COMPLETE)
  222. goto err;
  223. offset = ntohs(fhdr->frag_off) & ~0x7;
  224. end = offset + (ntohs(ipv6_hdr(skb)->payload_len) -
  225. ((u8 *)(fhdr + 1) - (u8 *)(ipv6_hdr(skb) + 1)));
  226. if ((unsigned int)end > IPV6_MAXPLEN) {
  227. IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
  228. IPSTATS_MIB_INHDRERRORS);
  229. icmpv6_param_prob(skb, ICMPV6_HDR_FIELD,
  230. ((u8 *)&fhdr->frag_off -
  231. skb_network_header(skb)));
  232. return -1;
  233. }
  234. if (skb->ip_summed == CHECKSUM_COMPLETE) {
  235. const unsigned char *nh = skb_network_header(skb);
  236. skb->csum = csum_sub(skb->csum,
  237. csum_partial(nh, (u8 *)(fhdr + 1) - nh,
  238. 0));
  239. }
  240. /* Is this the final fragment? */
  241. if (!(fhdr->frag_off & htons(IP6_MF))) {
  242. /* If we already have some bits beyond end
  243. * or have different end, the segment is corrupted.
  244. */
  245. if (end < fq->q.len ||
  246. ((fq->q.last_in & INET_FRAG_LAST_IN) && end != fq->q.len))
  247. goto err;
  248. fq->q.last_in |= INET_FRAG_LAST_IN;
  249. fq->q.len = end;
  250. } else {
  251. /* Check if the fragment is rounded to 8 bytes.
  252. * Required by the RFC.
  253. */
  254. if (end & 0x7) {
  255. /* RFC2460 says always send parameter problem in
  256. * this case. -DaveM
  257. */
  258. IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
  259. IPSTATS_MIB_INHDRERRORS);
  260. icmpv6_param_prob(skb, ICMPV6_HDR_FIELD,
  261. offsetof(struct ipv6hdr, payload_len));
  262. return -1;
  263. }
  264. if (end > fq->q.len) {
  265. /* Some bits beyond end -> corruption. */
  266. if (fq->q.last_in & INET_FRAG_LAST_IN)
  267. goto err;
  268. fq->q.len = end;
  269. }
  270. }
  271. if (end == offset)
  272. goto err;
  273. /* Point into the IP datagram 'data' part. */
  274. if (!pskb_pull(skb, (u8 *) (fhdr + 1) - skb->data))
  275. goto err;
  276. if (pskb_trim_rcsum(skb, end - offset))
  277. goto err;
  278. /* Find out which fragments are in front and at the back of us
  279. * in the chain of fragments so far. We must know where to put
  280. * this fragment, right?
  281. */
  282. prev = NULL;
  283. for(next = fq->q.fragments; next != NULL; next = next->next) {
  284. if (FRAG6_CB(next)->offset >= offset)
  285. break; /* bingo! */
  286. prev = next;
  287. }
  288. /* We found where to put this one. Check for overlap with
  289. * preceding fragment, and, if needed, align things so that
  290. * any overlaps are eliminated.
  291. */
  292. if (prev) {
  293. int i = (FRAG6_CB(prev)->offset + prev->len) - offset;
  294. if (i > 0) {
  295. offset += i;
  296. if (end <= offset)
  297. goto err;
  298. if (!pskb_pull(skb, i))
  299. goto err;
  300. if (skb->ip_summed != CHECKSUM_UNNECESSARY)
  301. skb->ip_summed = CHECKSUM_NONE;
  302. }
  303. }
  304. /* Look for overlap with succeeding segments.
  305. * If we can merge fragments, do it.
  306. */
  307. while (next && FRAG6_CB(next)->offset < end) {
  308. int i = end - FRAG6_CB(next)->offset; /* overlap is 'i' bytes */
  309. if (i < next->len) {
  310. /* Eat head of the next overlapped fragment
  311. * and leave the loop. The next ones cannot overlap.
  312. */
  313. if (!pskb_pull(next, i))
  314. goto err;
  315. FRAG6_CB(next)->offset += i; /* next fragment */
  316. fq->q.meat -= i;
  317. if (next->ip_summed != CHECKSUM_UNNECESSARY)
  318. next->ip_summed = CHECKSUM_NONE;
  319. break;
  320. } else {
  321. struct sk_buff *free_it = next;
  322. /* Old fragment is completely overridden with
  323. * new one drop it.
  324. */
  325. next = next->next;
  326. if (prev)
  327. prev->next = next;
  328. else
  329. fq->q.fragments = next;
  330. fq->q.meat -= free_it->len;
  331. frag_kfree_skb(fq->q.net, free_it, NULL);
  332. }
  333. }
  334. FRAG6_CB(skb)->offset = offset;
  335. /* Insert this fragment in the chain of fragments. */
  336. skb->next = next;
  337. if (prev)
  338. prev->next = skb;
  339. else
  340. fq->q.fragments = skb;
  341. dev = skb->dev;
  342. if (dev) {
  343. fq->iif = dev->ifindex;
  344. skb->dev = NULL;
  345. }
  346. fq->q.stamp = skb->tstamp;
  347. fq->q.meat += skb->len;
  348. atomic_add(skb->truesize, &fq->q.net->mem);
  349. /* The first fragment.
  350. * nhoffset is obtained from the first fragment, of course.
  351. */
  352. if (offset == 0) {
  353. fq->nhoffset = nhoff;
  354. fq->q.last_in |= INET_FRAG_FIRST_IN;
  355. }
  356. if (fq->q.last_in == (INET_FRAG_FIRST_IN | INET_FRAG_LAST_IN) &&
  357. fq->q.meat == fq->q.len)
  358. return ip6_frag_reasm(fq, prev, dev);
  359. write_lock(&ip6_frags.lock);
  360. list_move_tail(&fq->q.lru_list, &fq->q.net->lru_list);
  361. write_unlock(&ip6_frags.lock);
  362. return -1;
  363. err:
  364. IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
  365. IPSTATS_MIB_REASMFAILS);
  366. kfree_skb(skb);
  367. return -1;
  368. }
  369. /*
  370. * Check if this packet is complete.
  371. * Returns NULL on failure by any reason, and pointer
  372. * to current nexthdr field in reassembled frame.
  373. *
  374. * It is called with locked fq, and caller must check that
  375. * queue is eligible for reassembly i.e. it is not COMPLETE,
  376. * the last and the first frames arrived and all the bits are here.
  377. */
  378. static int ip6_frag_reasm(struct frag_queue *fq, struct sk_buff *prev,
  379. struct net_device *dev)
  380. {
  381. struct net *net = container_of(fq->q.net, struct net, ipv6.frags);
  382. struct sk_buff *fp, *head = fq->q.fragments;
  383. int payload_len;
  384. unsigned int nhoff;
  385. fq_kill(fq);
  386. /* Make the one we just received the head. */
  387. if (prev) {
  388. head = prev->next;
  389. fp = skb_clone(head, GFP_ATOMIC);
  390. if (!fp)
  391. goto out_oom;
  392. fp->next = head->next;
  393. prev->next = fp;
  394. skb_morph(head, fq->q.fragments);
  395. head->next = fq->q.fragments->next;
  396. kfree_skb(fq->q.fragments);
  397. fq->q.fragments = head;
  398. }
  399. WARN_ON(head == NULL);
  400. WARN_ON(FRAG6_CB(head)->offset != 0);
  401. /* Unfragmented part is taken from the first segment. */
  402. payload_len = ((head->data - skb_network_header(head)) -
  403. sizeof(struct ipv6hdr) + fq->q.len -
  404. sizeof(struct frag_hdr));
  405. if (payload_len > IPV6_MAXPLEN)
  406. goto out_oversize;
  407. /* Head of list must not be cloned. */
  408. if (skb_cloned(head) && pskb_expand_head(head, 0, 0, GFP_ATOMIC))
  409. goto out_oom;
  410. /* If the first fragment is fragmented itself, we split
  411. * it to two chunks: the first with data and paged part
  412. * and the second, holding only fragments. */
  413. if (skb_has_frags(head)) {
  414. struct sk_buff *clone;
  415. int i, plen = 0;
  416. if ((clone = alloc_skb(0, GFP_ATOMIC)) == NULL)
  417. goto out_oom;
  418. clone->next = head->next;
  419. head->next = clone;
  420. skb_shinfo(clone)->frag_list = skb_shinfo(head)->frag_list;
  421. skb_frag_list_init(head);
  422. for (i=0; i<skb_shinfo(head)->nr_frags; i++)
  423. plen += skb_shinfo(head)->frags[i].size;
  424. clone->len = clone->data_len = head->data_len - plen;
  425. head->data_len -= clone->len;
  426. head->len -= clone->len;
  427. clone->csum = 0;
  428. clone->ip_summed = head->ip_summed;
  429. atomic_add(clone->truesize, &fq->q.net->mem);
  430. }
  431. /* We have to remove fragment header from datagram and to relocate
  432. * header in order to calculate ICV correctly. */
  433. nhoff = fq->nhoffset;
  434. skb_network_header(head)[nhoff] = skb_transport_header(head)[0];
  435. memmove(head->head + sizeof(struct frag_hdr), head->head,
  436. (head->data - head->head) - sizeof(struct frag_hdr));
  437. head->mac_header += sizeof(struct frag_hdr);
  438. head->network_header += sizeof(struct frag_hdr);
  439. skb_shinfo(head)->frag_list = head->next;
  440. skb_reset_transport_header(head);
  441. skb_push(head, head->data - skb_network_header(head));
  442. atomic_sub(head->truesize, &fq->q.net->mem);
  443. for (fp=head->next; fp; fp = fp->next) {
  444. head->data_len += fp->len;
  445. head->len += fp->len;
  446. if (head->ip_summed != fp->ip_summed)
  447. head->ip_summed = CHECKSUM_NONE;
  448. else if (head->ip_summed == CHECKSUM_COMPLETE)
  449. head->csum = csum_add(head->csum, fp->csum);
  450. head->truesize += fp->truesize;
  451. atomic_sub(fp->truesize, &fq->q.net->mem);
  452. }
  453. head->next = NULL;
  454. head->dev = dev;
  455. head->tstamp = fq->q.stamp;
  456. ipv6_hdr(head)->payload_len = htons(payload_len);
  457. IP6CB(head)->nhoff = nhoff;
  458. /* Yes, and fold redundant checksum back. 8) */
  459. if (head->ip_summed == CHECKSUM_COMPLETE)
  460. head->csum = csum_partial(skb_network_header(head),
  461. skb_network_header_len(head),
  462. head->csum);
  463. rcu_read_lock();
  464. IP6_INC_STATS_BH(net, __in6_dev_get(dev), IPSTATS_MIB_REASMOKS);
  465. rcu_read_unlock();
  466. fq->q.fragments = NULL;
  467. return 1;
  468. out_oversize:
  469. if (net_ratelimit())
  470. printk(KERN_DEBUG "ip6_frag_reasm: payload len = %d\n", payload_len);
  471. goto out_fail;
  472. out_oom:
  473. if (net_ratelimit())
  474. printk(KERN_DEBUG "ip6_frag_reasm: no memory for reassembly\n");
  475. out_fail:
  476. rcu_read_lock();
  477. IP6_INC_STATS_BH(net, __in6_dev_get(dev), IPSTATS_MIB_REASMFAILS);
  478. rcu_read_unlock();
  479. return -1;
  480. }
  481. static int ipv6_frag_rcv(struct sk_buff *skb)
  482. {
  483. struct frag_hdr *fhdr;
  484. struct frag_queue *fq;
  485. struct ipv6hdr *hdr = ipv6_hdr(skb);
  486. struct net *net = dev_net(skb_dst(skb)->dev);
  487. IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_REASMREQDS);
  488. /* Jumbo payload inhibits frag. header */
  489. if (hdr->payload_len==0)
  490. goto fail_hdr;
  491. if (!pskb_may_pull(skb, (skb_transport_offset(skb) +
  492. sizeof(struct frag_hdr))))
  493. goto fail_hdr;
  494. hdr = ipv6_hdr(skb);
  495. fhdr = (struct frag_hdr *)skb_transport_header(skb);
  496. if (!(fhdr->frag_off & htons(0xFFF9))) {
  497. /* It is not a fragmented frame */
  498. skb->transport_header += sizeof(struct frag_hdr);
  499. IP6_INC_STATS_BH(net,
  500. ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_REASMOKS);
  501. IP6CB(skb)->nhoff = (u8 *)fhdr - skb_network_header(skb);
  502. return 1;
  503. }
  504. if (atomic_read(&net->ipv6.frags.mem) > net->ipv6.frags.high_thresh)
  505. ip6_evictor(net, ip6_dst_idev(skb_dst(skb)));
  506. fq = fq_find(net, fhdr->identification, &hdr->saddr, &hdr->daddr);
  507. if (fq != NULL) {
  508. int ret;
  509. spin_lock(&fq->q.lock);
  510. ret = ip6_frag_queue(fq, skb, fhdr, IP6CB(skb)->nhoff);
  511. spin_unlock(&fq->q.lock);
  512. fq_put(fq);
  513. return ret;
  514. }
  515. IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_REASMFAILS);
  516. kfree_skb(skb);
  517. return -1;
  518. fail_hdr:
  519. IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_INHDRERRORS);
  520. icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, skb_network_header_len(skb));
  521. return -1;
  522. }
  523. static const struct inet6_protocol frag_protocol =
  524. {
  525. .handler = ipv6_frag_rcv,
  526. .flags = INET6_PROTO_NOPOLICY,
  527. };
  528. #ifdef CONFIG_SYSCTL
  529. static struct ctl_table ip6_frags_ns_ctl_table[] = {
  530. {
  531. .procname = "ip6frag_high_thresh",
  532. .data = &init_net.ipv6.frags.high_thresh,
  533. .maxlen = sizeof(int),
  534. .mode = 0644,
  535. .proc_handler = proc_dointvec
  536. },
  537. {
  538. .procname = "ip6frag_low_thresh",
  539. .data = &init_net.ipv6.frags.low_thresh,
  540. .maxlen = sizeof(int),
  541. .mode = 0644,
  542. .proc_handler = proc_dointvec
  543. },
  544. {
  545. .procname = "ip6frag_time",
  546. .data = &init_net.ipv6.frags.timeout,
  547. .maxlen = sizeof(int),
  548. .mode = 0644,
  549. .proc_handler = proc_dointvec_jiffies,
  550. },
  551. { }
  552. };
  553. static struct ctl_table ip6_frags_ctl_table[] = {
  554. {
  555. .procname = "ip6frag_secret_interval",
  556. .data = &ip6_frags.secret_interval,
  557. .maxlen = sizeof(int),
  558. .mode = 0644,
  559. .proc_handler = proc_dointvec_jiffies,
  560. },
  561. { }
  562. };
  563. static int __net_init ip6_frags_ns_sysctl_register(struct net *net)
  564. {
  565. struct ctl_table *table;
  566. struct ctl_table_header *hdr;
  567. table = ip6_frags_ns_ctl_table;
  568. if (!net_eq(net, &init_net)) {
  569. table = kmemdup(table, sizeof(ip6_frags_ns_ctl_table), GFP_KERNEL);
  570. if (table == NULL)
  571. goto err_alloc;
  572. table[0].data = &net->ipv6.frags.high_thresh;
  573. table[1].data = &net->ipv6.frags.low_thresh;
  574. table[2].data = &net->ipv6.frags.timeout;
  575. }
  576. hdr = register_net_sysctl_table(net, net_ipv6_ctl_path, table);
  577. if (hdr == NULL)
  578. goto err_reg;
  579. net->ipv6.sysctl.frags_hdr = hdr;
  580. return 0;
  581. err_reg:
  582. if (!net_eq(net, &init_net))
  583. kfree(table);
  584. err_alloc:
  585. return -ENOMEM;
  586. }
  587. static void __net_exit ip6_frags_ns_sysctl_unregister(struct net *net)
  588. {
  589. struct ctl_table *table;
  590. table = net->ipv6.sysctl.frags_hdr->ctl_table_arg;
  591. unregister_net_sysctl_table(net->ipv6.sysctl.frags_hdr);
  592. if (!net_eq(net, &init_net))
  593. kfree(table);
  594. }
  595. static struct ctl_table_header *ip6_ctl_header;
  596. static int ip6_frags_sysctl_register(void)
  597. {
  598. ip6_ctl_header = register_net_sysctl_rotable(net_ipv6_ctl_path,
  599. ip6_frags_ctl_table);
  600. return ip6_ctl_header == NULL ? -ENOMEM : 0;
  601. }
  602. static void ip6_frags_sysctl_unregister(void)
  603. {
  604. unregister_net_sysctl_table(ip6_ctl_header);
  605. }
  606. #else
  607. static inline int ip6_frags_ns_sysctl_register(struct net *net)
  608. {
  609. return 0;
  610. }
  611. static inline void ip6_frags_ns_sysctl_unregister(struct net *net)
  612. {
  613. }
  614. static inline int ip6_frags_sysctl_register(void)
  615. {
  616. return 0;
  617. }
  618. static inline void ip6_frags_sysctl_unregister(void)
  619. {
  620. }
  621. #endif
  622. static int __net_init ipv6_frags_init_net(struct net *net)
  623. {
  624. net->ipv6.frags.high_thresh = IPV6_FRAG_HIGH_THRESH;
  625. net->ipv6.frags.low_thresh = IPV6_FRAG_LOW_THRESH;
  626. net->ipv6.frags.timeout = IPV6_FRAG_TIMEOUT;
  627. inet_frags_init_net(&net->ipv6.frags);
  628. return ip6_frags_ns_sysctl_register(net);
  629. }
  630. static void __net_exit ipv6_frags_exit_net(struct net *net)
  631. {
  632. ip6_frags_ns_sysctl_unregister(net);
  633. inet_frags_exit_net(&net->ipv6.frags, &ip6_frags);
  634. }
  635. static struct pernet_operations ip6_frags_ops = {
  636. .init = ipv6_frags_init_net,
  637. .exit = ipv6_frags_exit_net,
  638. };
  639. int __init ipv6_frag_init(void)
  640. {
  641. int ret;
  642. ret = inet6_add_protocol(&frag_protocol, IPPROTO_FRAGMENT);
  643. if (ret)
  644. goto out;
  645. ret = ip6_frags_sysctl_register();
  646. if (ret)
  647. goto err_sysctl;
  648. ret = register_pernet_subsys(&ip6_frags_ops);
  649. if (ret)
  650. goto err_pernet;
  651. ip6_frags.hashfn = ip6_hashfn;
  652. ip6_frags.constructor = ip6_frag_init;
  653. ip6_frags.destructor = NULL;
  654. ip6_frags.skb_free = NULL;
  655. ip6_frags.qsize = sizeof(struct frag_queue);
  656. ip6_frags.match = ip6_frag_match;
  657. ip6_frags.frag_expire = ip6_frag_expire;
  658. ip6_frags.secret_interval = 10 * 60 * HZ;
  659. inet_frags_init(&ip6_frags);
  660. out:
  661. return ret;
  662. err_pernet:
  663. ip6_frags_sysctl_unregister();
  664. err_sysctl:
  665. inet6_del_protocol(&frag_protocol, IPPROTO_FRAGMENT);
  666. goto out;
  667. }
  668. void ipv6_frag_exit(void)
  669. {
  670. inet_frags_fini(&ip6_frags);
  671. ip6_frags_sysctl_unregister();
  672. unregister_pernet_subsys(&ip6_frags_ops);
  673. inet6_del_protocol(&frag_protocol, IPPROTO_FRAGMENT);
  674. }