udp.c 37 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501
  1. /*
  2. * UDP over IPv6
  3. * Linux INET6 implementation
  4. *
  5. * Authors:
  6. * Pedro Roque <roque@di.fc.ul.pt>
  7. *
  8. * Based on linux/ipv4/udp.c
  9. *
  10. * Fixes:
  11. * Hideaki YOSHIFUJI : sin6_scope_id support
  12. * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
  13. * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
  14. * a single port at the same time.
  15. * Kazunori MIYAZAWA @USAGI: change process style to use ip6_append_data
  16. * YOSHIFUJI Hideaki @USAGI: convert /proc/net/udp6 to seq_file.
  17. *
  18. * This program is free software; you can redistribute it and/or
  19. * modify it under the terms of the GNU General Public License
  20. * as published by the Free Software Foundation; either version
  21. * 2 of the License, or (at your option) any later version.
  22. */
  23. #include <linux/errno.h>
  24. #include <linux/types.h>
  25. #include <linux/socket.h>
  26. #include <linux/sockios.h>
  27. #include <linux/net.h>
  28. #include <linux/in6.h>
  29. #include <linux/netdevice.h>
  30. #include <linux/if_arp.h>
  31. #include <linux/ipv6.h>
  32. #include <linux/icmpv6.h>
  33. #include <linux/init.h>
  34. #include <linux/module.h>
  35. #include <linux/skbuff.h>
  36. #include <linux/slab.h>
  37. #include <asm/uaccess.h>
  38. #include <net/ndisc.h>
  39. #include <net/protocol.h>
  40. #include <net/transp_v6.h>
  41. #include <net/ip6_route.h>
  42. #include <net/raw.h>
  43. #include <net/tcp_states.h>
  44. #include <net/ip6_checksum.h>
  45. #include <net/xfrm.h>
  46. #include <linux/proc_fs.h>
  47. #include <linux/seq_file.h>
  48. #include "udp_impl.h"
  49. int ipv6_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2)
  50. {
  51. const struct in6_addr *sk_rcv_saddr6 = &inet6_sk(sk)->rcv_saddr;
  52. const struct in6_addr *sk2_rcv_saddr6 = inet6_rcv_saddr(sk2);
  53. __be32 sk1_rcv_saddr = inet_sk(sk)->inet_rcv_saddr;
  54. __be32 sk2_rcv_saddr = inet_rcv_saddr(sk2);
  55. int sk_ipv6only = ipv6_only_sock(sk);
  56. int sk2_ipv6only = inet_v6_ipv6only(sk2);
  57. int addr_type = ipv6_addr_type(sk_rcv_saddr6);
  58. int addr_type2 = sk2_rcv_saddr6 ? ipv6_addr_type(sk2_rcv_saddr6) : IPV6_ADDR_MAPPED;
  59. /* if both are mapped, treat as IPv4 */
  60. if (addr_type == IPV6_ADDR_MAPPED && addr_type2 == IPV6_ADDR_MAPPED)
  61. return (!sk2_ipv6only &&
  62. (!sk1_rcv_saddr || !sk2_rcv_saddr ||
  63. sk1_rcv_saddr == sk2_rcv_saddr));
  64. if (addr_type2 == IPV6_ADDR_ANY &&
  65. !(sk2_ipv6only && addr_type == IPV6_ADDR_MAPPED))
  66. return 1;
  67. if (addr_type == IPV6_ADDR_ANY &&
  68. !(sk_ipv6only && addr_type2 == IPV6_ADDR_MAPPED))
  69. return 1;
  70. if (sk2_rcv_saddr6 &&
  71. ipv6_addr_equal(sk_rcv_saddr6, sk2_rcv_saddr6))
  72. return 1;
  73. return 0;
  74. }
  75. static unsigned int udp6_portaddr_hash(struct net *net,
  76. const struct in6_addr *addr6,
  77. unsigned int port)
  78. {
  79. unsigned int hash, mix = net_hash_mix(net);
  80. if (ipv6_addr_any(addr6))
  81. hash = jhash_1word(0, mix);
  82. else if (ipv6_addr_v4mapped(addr6))
  83. hash = jhash_1word((__force u32)addr6->s6_addr32[3], mix);
  84. else
  85. hash = jhash2((__force u32 *)addr6->s6_addr32, 4, mix);
  86. return hash ^ port;
  87. }
  88. int udp_v6_get_port(struct sock *sk, unsigned short snum)
  89. {
  90. unsigned int hash2_nulladdr =
  91. udp6_portaddr_hash(sock_net(sk), &in6addr_any, snum);
  92. unsigned int hash2_partial =
  93. udp6_portaddr_hash(sock_net(sk), &inet6_sk(sk)->rcv_saddr, 0);
  94. /* precompute partial secondary hash */
  95. udp_sk(sk)->udp_portaddr_hash = hash2_partial;
  96. return udp_lib_get_port(sk, snum, ipv6_rcv_saddr_equal, hash2_nulladdr);
  97. }
  98. static inline int compute_score(struct sock *sk, struct net *net,
  99. unsigned short hnum,
  100. struct in6_addr *saddr, __be16 sport,
  101. struct in6_addr *daddr, __be16 dport,
  102. int dif)
  103. {
  104. int score = -1;
  105. if (net_eq(sock_net(sk), net) && udp_sk(sk)->udp_port_hash == hnum &&
  106. sk->sk_family == PF_INET6) {
  107. struct ipv6_pinfo *np = inet6_sk(sk);
  108. struct inet_sock *inet = inet_sk(sk);
  109. score = 0;
  110. if (inet->inet_dport) {
  111. if (inet->inet_dport != sport)
  112. return -1;
  113. score++;
  114. }
  115. if (!ipv6_addr_any(&np->rcv_saddr)) {
  116. if (!ipv6_addr_equal(&np->rcv_saddr, daddr))
  117. return -1;
  118. score++;
  119. }
  120. if (!ipv6_addr_any(&np->daddr)) {
  121. if (!ipv6_addr_equal(&np->daddr, saddr))
  122. return -1;
  123. score++;
  124. }
  125. if (sk->sk_bound_dev_if) {
  126. if (sk->sk_bound_dev_if != dif)
  127. return -1;
  128. score++;
  129. }
  130. }
  131. return score;
  132. }
  133. #define SCORE2_MAX (1 + 1 + 1)
  134. static inline int compute_score2(struct sock *sk, struct net *net,
  135. const struct in6_addr *saddr, __be16 sport,
  136. const struct in6_addr *daddr, unsigned short hnum,
  137. int dif)
  138. {
  139. int score = -1;
  140. if (net_eq(sock_net(sk), net) && udp_sk(sk)->udp_port_hash == hnum &&
  141. sk->sk_family == PF_INET6) {
  142. struct ipv6_pinfo *np = inet6_sk(sk);
  143. struct inet_sock *inet = inet_sk(sk);
  144. if (!ipv6_addr_equal(&np->rcv_saddr, daddr))
  145. return -1;
  146. score = 0;
  147. if (inet->inet_dport) {
  148. if (inet->inet_dport != sport)
  149. return -1;
  150. score++;
  151. }
  152. if (!ipv6_addr_any(&np->daddr)) {
  153. if (!ipv6_addr_equal(&np->daddr, saddr))
  154. return -1;
  155. score++;
  156. }
  157. if (sk->sk_bound_dev_if) {
  158. if (sk->sk_bound_dev_if != dif)
  159. return -1;
  160. score++;
  161. }
  162. }
  163. return score;
  164. }
  165. /* called with read_rcu_lock() */
  166. static struct sock *udp6_lib_lookup2(struct net *net,
  167. const struct in6_addr *saddr, __be16 sport,
  168. const struct in6_addr *daddr, unsigned int hnum, int dif,
  169. struct udp_hslot *hslot2, unsigned int slot2)
  170. {
  171. struct sock *sk, *result;
  172. struct hlist_nulls_node *node;
  173. int score, badness;
  174. begin:
  175. result = NULL;
  176. badness = -1;
  177. udp_portaddr_for_each_entry_rcu(sk, node, &hslot2->head) {
  178. score = compute_score2(sk, net, saddr, sport,
  179. daddr, hnum, dif);
  180. if (score > badness) {
  181. result = sk;
  182. badness = score;
  183. if (score == SCORE2_MAX)
  184. goto exact_match;
  185. }
  186. }
  187. /*
  188. * if the nulls value we got at the end of this lookup is
  189. * not the expected one, we must restart lookup.
  190. * We probably met an item that was moved to another chain.
  191. */
  192. if (get_nulls_value(node) != slot2)
  193. goto begin;
  194. if (result) {
  195. exact_match:
  196. if (unlikely(!atomic_inc_not_zero(&result->sk_refcnt)))
  197. result = NULL;
  198. else if (unlikely(compute_score2(result, net, saddr, sport,
  199. daddr, hnum, dif) < badness)) {
  200. sock_put(result);
  201. goto begin;
  202. }
  203. }
  204. return result;
  205. }
  206. static struct sock *__udp6_lib_lookup(struct net *net,
  207. struct in6_addr *saddr, __be16 sport,
  208. struct in6_addr *daddr, __be16 dport,
  209. int dif, struct udp_table *udptable)
  210. {
  211. struct sock *sk, *result;
  212. struct hlist_nulls_node *node;
  213. unsigned short hnum = ntohs(dport);
  214. unsigned int hash2, slot2, slot = udp_hashfn(net, hnum, udptable->mask);
  215. struct udp_hslot *hslot2, *hslot = &udptable->hash[slot];
  216. int score, badness;
  217. rcu_read_lock();
  218. if (hslot->count > 10) {
  219. hash2 = udp6_portaddr_hash(net, daddr, hnum);
  220. slot2 = hash2 & udptable->mask;
  221. hslot2 = &udptable->hash2[slot2];
  222. if (hslot->count < hslot2->count)
  223. goto begin;
  224. result = udp6_lib_lookup2(net, saddr, sport,
  225. daddr, hnum, dif,
  226. hslot2, slot2);
  227. if (!result) {
  228. hash2 = udp6_portaddr_hash(net, &in6addr_any, hnum);
  229. slot2 = hash2 & udptable->mask;
  230. hslot2 = &udptable->hash2[slot2];
  231. if (hslot->count < hslot2->count)
  232. goto begin;
  233. result = udp6_lib_lookup2(net, saddr, sport,
  234. &in6addr_any, hnum, dif,
  235. hslot2, slot2);
  236. }
  237. rcu_read_unlock();
  238. return result;
  239. }
  240. begin:
  241. result = NULL;
  242. badness = -1;
  243. sk_nulls_for_each_rcu(sk, node, &hslot->head) {
  244. score = compute_score(sk, net, hnum, saddr, sport, daddr, dport, dif);
  245. if (score > badness) {
  246. result = sk;
  247. badness = score;
  248. }
  249. }
  250. /*
  251. * if the nulls value we got at the end of this lookup is
  252. * not the expected one, we must restart lookup.
  253. * We probably met an item that was moved to another chain.
  254. */
  255. if (get_nulls_value(node) != slot)
  256. goto begin;
  257. if (result) {
  258. if (unlikely(!atomic_inc_not_zero(&result->sk_refcnt)))
  259. result = NULL;
  260. else if (unlikely(compute_score(result, net, hnum, saddr, sport,
  261. daddr, dport, dif) < badness)) {
  262. sock_put(result);
  263. goto begin;
  264. }
  265. }
  266. rcu_read_unlock();
  267. return result;
  268. }
  269. static struct sock *__udp6_lib_lookup_skb(struct sk_buff *skb,
  270. __be16 sport, __be16 dport,
  271. struct udp_table *udptable)
  272. {
  273. struct sock *sk;
  274. struct ipv6hdr *iph = ipv6_hdr(skb);
  275. if (unlikely(sk = skb_steal_sock(skb)))
  276. return sk;
  277. return __udp6_lib_lookup(dev_net(skb_dst(skb)->dev), &iph->saddr, sport,
  278. &iph->daddr, dport, inet6_iif(skb),
  279. udptable);
  280. }
  281. /*
  282. * This should be easy, if there is something there we
  283. * return it, otherwise we block.
  284. */
  285. int udpv6_recvmsg(struct kiocb *iocb, struct sock *sk,
  286. struct msghdr *msg, size_t len,
  287. int noblock, int flags, int *addr_len)
  288. {
  289. struct ipv6_pinfo *np = inet6_sk(sk);
  290. struct inet_sock *inet = inet_sk(sk);
  291. struct sk_buff *skb;
  292. unsigned int ulen;
  293. int peeked;
  294. int err;
  295. int is_udplite = IS_UDPLITE(sk);
  296. int is_udp4;
  297. if (addr_len)
  298. *addr_len=sizeof(struct sockaddr_in6);
  299. if (flags & MSG_ERRQUEUE)
  300. return ipv6_recv_error(sk, msg, len);
  301. if (np->rxpmtu && np->rxopt.bits.rxpmtu)
  302. return ipv6_recv_rxpmtu(sk, msg, len);
  303. try_again:
  304. skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
  305. &peeked, &err);
  306. if (!skb)
  307. goto out;
  308. ulen = skb->len - sizeof(struct udphdr);
  309. if (len > ulen)
  310. len = ulen;
  311. else if (len < ulen)
  312. msg->msg_flags |= MSG_TRUNC;
  313. is_udp4 = (skb->protocol == htons(ETH_P_IP));
  314. /*
  315. * If checksum is needed at all, try to do it while copying the
  316. * data. If the data is truncated, or if we only want a partial
  317. * coverage checksum (UDP-Lite), do it before the copy.
  318. */
  319. if (len < ulen || UDP_SKB_CB(skb)->partial_cov) {
  320. if (udp_lib_checksum_complete(skb))
  321. goto csum_copy_err;
  322. }
  323. if (skb_csum_unnecessary(skb))
  324. err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr),
  325. msg->msg_iov,len);
  326. else {
  327. err = skb_copy_and_csum_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov);
  328. if (err == -EINVAL)
  329. goto csum_copy_err;
  330. }
  331. if (err)
  332. goto out_free;
  333. if (!peeked) {
  334. if (is_udp4)
  335. UDP_INC_STATS_USER(sock_net(sk),
  336. UDP_MIB_INDATAGRAMS, is_udplite);
  337. else
  338. UDP6_INC_STATS_USER(sock_net(sk),
  339. UDP_MIB_INDATAGRAMS, is_udplite);
  340. }
  341. sock_recv_ts_and_drops(msg, sk, skb);
  342. /* Copy the address. */
  343. if (msg->msg_name) {
  344. struct sockaddr_in6 *sin6;
  345. sin6 = (struct sockaddr_in6 *) msg->msg_name;
  346. sin6->sin6_family = AF_INET6;
  347. sin6->sin6_port = udp_hdr(skb)->source;
  348. sin6->sin6_flowinfo = 0;
  349. sin6->sin6_scope_id = 0;
  350. if (is_udp4)
  351. ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr,
  352. &sin6->sin6_addr);
  353. else {
  354. ipv6_addr_copy(&sin6->sin6_addr,
  355. &ipv6_hdr(skb)->saddr);
  356. if (ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL)
  357. sin6->sin6_scope_id = IP6CB(skb)->iif;
  358. }
  359. }
  360. if (is_udp4) {
  361. if (inet->cmsg_flags)
  362. ip_cmsg_recv(msg, skb);
  363. } else {
  364. if (np->rxopt.all)
  365. datagram_recv_ctl(sk, msg, skb);
  366. }
  367. err = len;
  368. if (flags & MSG_TRUNC)
  369. err = ulen;
  370. out_free:
  371. skb_free_datagram_locked(sk, skb);
  372. out:
  373. return err;
  374. csum_copy_err:
  375. lock_sock_bh(sk);
  376. if (!skb_kill_datagram(sk, skb, flags)) {
  377. if (is_udp4)
  378. UDP_INC_STATS_USER(sock_net(sk),
  379. UDP_MIB_INERRORS, is_udplite);
  380. else
  381. UDP6_INC_STATS_USER(sock_net(sk),
  382. UDP_MIB_INERRORS, is_udplite);
  383. }
  384. unlock_sock_bh(sk);
  385. if (flags & MSG_DONTWAIT)
  386. return -EAGAIN;
  387. goto try_again;
  388. }
  389. void __udp6_lib_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
  390. u8 type, u8 code, int offset, __be32 info,
  391. struct udp_table *udptable)
  392. {
  393. struct ipv6_pinfo *np;
  394. struct ipv6hdr *hdr = (struct ipv6hdr*)skb->data;
  395. struct in6_addr *saddr = &hdr->saddr;
  396. struct in6_addr *daddr = &hdr->daddr;
  397. struct udphdr *uh = (struct udphdr*)(skb->data+offset);
  398. struct sock *sk;
  399. int err;
  400. sk = __udp6_lib_lookup(dev_net(skb->dev), daddr, uh->dest,
  401. saddr, uh->source, inet6_iif(skb), udptable);
  402. if (sk == NULL)
  403. return;
  404. np = inet6_sk(sk);
  405. if (!icmpv6_err_convert(type, code, &err) && !np->recverr)
  406. goto out;
  407. if (sk->sk_state != TCP_ESTABLISHED && !np->recverr)
  408. goto out;
  409. if (np->recverr)
  410. ipv6_icmp_error(sk, skb, err, uh->dest, ntohl(info), (u8 *)(uh+1));
  411. sk->sk_err = err;
  412. sk->sk_error_report(sk);
  413. out:
  414. sock_put(sk);
  415. }
  416. static __inline__ void udpv6_err(struct sk_buff *skb,
  417. struct inet6_skb_parm *opt, u8 type,
  418. u8 code, int offset, __be32 info )
  419. {
  420. __udp6_lib_err(skb, opt, type, code, offset, info, &udp_table);
  421. }
  422. int udpv6_queue_rcv_skb(struct sock * sk, struct sk_buff *skb)
  423. {
  424. struct udp_sock *up = udp_sk(sk);
  425. int rc;
  426. int is_udplite = IS_UDPLITE(sk);
  427. if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
  428. goto drop;
  429. /*
  430. * UDP-Lite specific tests, ignored on UDP sockets (see net/ipv4/udp.c).
  431. */
  432. if ((is_udplite & UDPLITE_RECV_CC) && UDP_SKB_CB(skb)->partial_cov) {
  433. if (up->pcrlen == 0) { /* full coverage was set */
  434. LIMIT_NETDEBUG(KERN_WARNING "UDPLITE6: partial coverage"
  435. " %d while full coverage %d requested\n",
  436. UDP_SKB_CB(skb)->cscov, skb->len);
  437. goto drop;
  438. }
  439. if (UDP_SKB_CB(skb)->cscov < up->pcrlen) {
  440. LIMIT_NETDEBUG(KERN_WARNING "UDPLITE6: coverage %d "
  441. "too small, need min %d\n",
  442. UDP_SKB_CB(skb)->cscov, up->pcrlen);
  443. goto drop;
  444. }
  445. }
  446. if (sk->sk_filter) {
  447. if (udp_lib_checksum_complete(skb))
  448. goto drop;
  449. }
  450. if ((rc = ip_queue_rcv_skb(sk, skb)) < 0) {
  451. /* Note that an ENOMEM error is charged twice */
  452. if (rc == -ENOMEM)
  453. UDP6_INC_STATS_BH(sock_net(sk),
  454. UDP_MIB_RCVBUFERRORS, is_udplite);
  455. goto drop_no_sk_drops_inc;
  456. }
  457. return 0;
  458. drop:
  459. atomic_inc(&sk->sk_drops);
  460. drop_no_sk_drops_inc:
  461. UDP6_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
  462. kfree_skb(skb);
  463. return -1;
  464. }
  465. static struct sock *udp_v6_mcast_next(struct net *net, struct sock *sk,
  466. __be16 loc_port, struct in6_addr *loc_addr,
  467. __be16 rmt_port, struct in6_addr *rmt_addr,
  468. int dif)
  469. {
  470. struct hlist_nulls_node *node;
  471. struct sock *s = sk;
  472. unsigned short num = ntohs(loc_port);
  473. sk_nulls_for_each_from(s, node) {
  474. struct inet_sock *inet = inet_sk(s);
  475. if (!net_eq(sock_net(s), net))
  476. continue;
  477. if (udp_sk(s)->udp_port_hash == num &&
  478. s->sk_family == PF_INET6) {
  479. struct ipv6_pinfo *np = inet6_sk(s);
  480. if (inet->inet_dport) {
  481. if (inet->inet_dport != rmt_port)
  482. continue;
  483. }
  484. if (!ipv6_addr_any(&np->daddr) &&
  485. !ipv6_addr_equal(&np->daddr, rmt_addr))
  486. continue;
  487. if (s->sk_bound_dev_if && s->sk_bound_dev_if != dif)
  488. continue;
  489. if (!ipv6_addr_any(&np->rcv_saddr)) {
  490. if (!ipv6_addr_equal(&np->rcv_saddr, loc_addr))
  491. continue;
  492. }
  493. if (!inet6_mc_check(s, loc_addr, rmt_addr))
  494. continue;
  495. return s;
  496. }
  497. }
  498. return NULL;
  499. }
  500. static void flush_stack(struct sock **stack, unsigned int count,
  501. struct sk_buff *skb, unsigned int final)
  502. {
  503. unsigned int i;
  504. struct sock *sk;
  505. struct sk_buff *skb1;
  506. for (i = 0; i < count; i++) {
  507. skb1 = (i == final) ? skb : skb_clone(skb, GFP_ATOMIC);
  508. sk = stack[i];
  509. if (skb1) {
  510. if (sk_rcvqueues_full(sk, skb)) {
  511. kfree_skb(skb1);
  512. goto drop;
  513. }
  514. bh_lock_sock(sk);
  515. if (!sock_owned_by_user(sk))
  516. udpv6_queue_rcv_skb(sk, skb1);
  517. else if (sk_add_backlog(sk, skb1)) {
  518. kfree_skb(skb1);
  519. bh_unlock_sock(sk);
  520. goto drop;
  521. }
  522. bh_unlock_sock(sk);
  523. continue;
  524. }
  525. drop:
  526. atomic_inc(&sk->sk_drops);
  527. UDP6_INC_STATS_BH(sock_net(sk),
  528. UDP_MIB_RCVBUFERRORS, IS_UDPLITE(sk));
  529. UDP6_INC_STATS_BH(sock_net(sk),
  530. UDP_MIB_INERRORS, IS_UDPLITE(sk));
  531. }
  532. }
  533. /*
  534. * Note: called only from the BH handler context,
  535. * so we don't need to lock the hashes.
  536. */
  537. static int __udp6_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
  538. struct in6_addr *saddr, struct in6_addr *daddr,
  539. struct udp_table *udptable)
  540. {
  541. struct sock *sk, *stack[256 / sizeof(struct sock *)];
  542. const struct udphdr *uh = udp_hdr(skb);
  543. struct udp_hslot *hslot = udp_hashslot(udptable, net, ntohs(uh->dest));
  544. int dif;
  545. unsigned int i, count = 0;
  546. spin_lock(&hslot->lock);
  547. sk = sk_nulls_head(&hslot->head);
  548. dif = inet6_iif(skb);
  549. sk = udp_v6_mcast_next(net, sk, uh->dest, daddr, uh->source, saddr, dif);
  550. while (sk) {
  551. stack[count++] = sk;
  552. sk = udp_v6_mcast_next(net, sk_nulls_next(sk), uh->dest, daddr,
  553. uh->source, saddr, dif);
  554. if (unlikely(count == ARRAY_SIZE(stack))) {
  555. if (!sk)
  556. break;
  557. flush_stack(stack, count, skb, ~0);
  558. count = 0;
  559. }
  560. }
  561. /*
  562. * before releasing the lock, we must take reference on sockets
  563. */
  564. for (i = 0; i < count; i++)
  565. sock_hold(stack[i]);
  566. spin_unlock(&hslot->lock);
  567. if (count) {
  568. flush_stack(stack, count, skb, count - 1);
  569. for (i = 0; i < count; i++)
  570. sock_put(stack[i]);
  571. } else {
  572. kfree_skb(skb);
  573. }
  574. return 0;
  575. }
  576. static inline int udp6_csum_init(struct sk_buff *skb, struct udphdr *uh,
  577. int proto)
  578. {
  579. int err;
  580. UDP_SKB_CB(skb)->partial_cov = 0;
  581. UDP_SKB_CB(skb)->cscov = skb->len;
  582. if (proto == IPPROTO_UDPLITE) {
  583. err = udplite_checksum_init(skb, uh);
  584. if (err)
  585. return err;
  586. }
  587. if (uh->check == 0) {
  588. /* RFC 2460 section 8.1 says that we SHOULD log
  589. this error. Well, it is reasonable.
  590. */
  591. LIMIT_NETDEBUG(KERN_INFO "IPv6: udp checksum is 0\n");
  592. return 1;
  593. }
  594. if (skb->ip_summed == CHECKSUM_COMPLETE &&
  595. !csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
  596. skb->len, proto, skb->csum))
  597. skb->ip_summed = CHECKSUM_UNNECESSARY;
  598. if (!skb_csum_unnecessary(skb))
  599. skb->csum = ~csum_unfold(csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
  600. &ipv6_hdr(skb)->daddr,
  601. skb->len, proto, 0));
  602. return 0;
  603. }
  604. int __udp6_lib_rcv(struct sk_buff *skb, struct udp_table *udptable,
  605. int proto)
  606. {
  607. struct net *net = dev_net(skb->dev);
  608. struct sock *sk;
  609. struct udphdr *uh;
  610. struct in6_addr *saddr, *daddr;
  611. u32 ulen = 0;
  612. if (!pskb_may_pull(skb, sizeof(struct udphdr)))
  613. goto discard;
  614. saddr = &ipv6_hdr(skb)->saddr;
  615. daddr = &ipv6_hdr(skb)->daddr;
  616. uh = udp_hdr(skb);
  617. ulen = ntohs(uh->len);
  618. if (ulen > skb->len)
  619. goto short_packet;
  620. if (proto == IPPROTO_UDP) {
  621. /* UDP validates ulen. */
  622. /* Check for jumbo payload */
  623. if (ulen == 0)
  624. ulen = skb->len;
  625. if (ulen < sizeof(*uh))
  626. goto short_packet;
  627. if (ulen < skb->len) {
  628. if (pskb_trim_rcsum(skb, ulen))
  629. goto short_packet;
  630. saddr = &ipv6_hdr(skb)->saddr;
  631. daddr = &ipv6_hdr(skb)->daddr;
  632. uh = udp_hdr(skb);
  633. }
  634. }
  635. if (udp6_csum_init(skb, uh, proto))
  636. goto discard;
  637. /*
  638. * Multicast receive code
  639. */
  640. if (ipv6_addr_is_multicast(daddr))
  641. return __udp6_lib_mcast_deliver(net, skb,
  642. saddr, daddr, udptable);
  643. /* Unicast */
  644. /*
  645. * check socket cache ... must talk to Alan about his plans
  646. * for sock caches... i'll skip this for now.
  647. */
  648. sk = __udp6_lib_lookup_skb(skb, uh->source, uh->dest, udptable);
  649. if (sk == NULL) {
  650. if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
  651. goto discard;
  652. if (udp_lib_checksum_complete(skb))
  653. goto discard;
  654. UDP6_INC_STATS_BH(net, UDP_MIB_NOPORTS,
  655. proto == IPPROTO_UDPLITE);
  656. icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);
  657. kfree_skb(skb);
  658. return 0;
  659. }
  660. /* deliver */
  661. if (sk_rcvqueues_full(sk, skb)) {
  662. sock_put(sk);
  663. goto discard;
  664. }
  665. bh_lock_sock(sk);
  666. if (!sock_owned_by_user(sk))
  667. udpv6_queue_rcv_skb(sk, skb);
  668. else if (sk_add_backlog(sk, skb)) {
  669. atomic_inc(&sk->sk_drops);
  670. bh_unlock_sock(sk);
  671. sock_put(sk);
  672. goto discard;
  673. }
  674. bh_unlock_sock(sk);
  675. sock_put(sk);
  676. return 0;
  677. short_packet:
  678. LIMIT_NETDEBUG(KERN_DEBUG "UDP%sv6: short packet: From [%pI6c]:%u %d/%d to [%pI6c]:%u\n",
  679. proto == IPPROTO_UDPLITE ? "-Lite" : "",
  680. saddr,
  681. ntohs(uh->source),
  682. ulen,
  683. skb->len,
  684. daddr,
  685. ntohs(uh->dest));
  686. discard:
  687. UDP6_INC_STATS_BH(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
  688. kfree_skb(skb);
  689. return 0;
  690. }
  691. static __inline__ int udpv6_rcv(struct sk_buff *skb)
  692. {
  693. return __udp6_lib_rcv(skb, &udp_table, IPPROTO_UDP);
  694. }
  695. /*
  696. * Throw away all pending data and cancel the corking. Socket is locked.
  697. */
  698. static void udp_v6_flush_pending_frames(struct sock *sk)
  699. {
  700. struct udp_sock *up = udp_sk(sk);
  701. if (up->pending == AF_INET)
  702. udp_flush_pending_frames(sk);
  703. else if (up->pending) {
  704. up->len = 0;
  705. up->pending = 0;
  706. ip6_flush_pending_frames(sk);
  707. }
  708. }
  709. /**
  710. * udp6_hwcsum_outgoing - handle outgoing HW checksumming
  711. * @sk: socket we are sending on
  712. * @skb: sk_buff containing the filled-in UDP header
  713. * (checksum field must be zeroed out)
  714. */
  715. static void udp6_hwcsum_outgoing(struct sock *sk, struct sk_buff *skb,
  716. const struct in6_addr *saddr,
  717. const struct in6_addr *daddr, int len)
  718. {
  719. unsigned int offset;
  720. struct udphdr *uh = udp_hdr(skb);
  721. __wsum csum = 0;
  722. if (skb_queue_len(&sk->sk_write_queue) == 1) {
  723. /* Only one fragment on the socket. */
  724. skb->csum_start = skb_transport_header(skb) - skb->head;
  725. skb->csum_offset = offsetof(struct udphdr, check);
  726. uh->check = ~csum_ipv6_magic(saddr, daddr, len, IPPROTO_UDP, 0);
  727. } else {
  728. /*
  729. * HW-checksum won't work as there are two or more
  730. * fragments on the socket so that all csums of sk_buffs
  731. * should be together
  732. */
  733. offset = skb_transport_offset(skb);
  734. skb->csum = skb_checksum(skb, offset, skb->len - offset, 0);
  735. skb->ip_summed = CHECKSUM_NONE;
  736. skb_queue_walk(&sk->sk_write_queue, skb) {
  737. csum = csum_add(csum, skb->csum);
  738. }
  739. uh->check = csum_ipv6_magic(saddr, daddr, len, IPPROTO_UDP,
  740. csum);
  741. if (uh->check == 0)
  742. uh->check = CSUM_MANGLED_0;
  743. }
  744. }
  745. /*
  746. * Sending
  747. */
  748. static int udp_v6_push_pending_frames(struct sock *sk)
  749. {
  750. struct sk_buff *skb;
  751. struct udphdr *uh;
  752. struct udp_sock *up = udp_sk(sk);
  753. struct inet_sock *inet = inet_sk(sk);
  754. struct flowi *fl = &inet->cork.fl;
  755. int err = 0;
  756. int is_udplite = IS_UDPLITE(sk);
  757. __wsum csum = 0;
  758. /* Grab the skbuff where UDP header space exists. */
  759. if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
  760. goto out;
  761. /*
  762. * Create a UDP header
  763. */
  764. uh = udp_hdr(skb);
  765. uh->source = fl->fl_ip_sport;
  766. uh->dest = fl->fl_ip_dport;
  767. uh->len = htons(up->len);
  768. uh->check = 0;
  769. if (is_udplite)
  770. csum = udplite_csum_outgoing(sk, skb);
  771. else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
  772. udp6_hwcsum_outgoing(sk, skb, &fl->fl6_src, &fl->fl6_dst,
  773. up->len);
  774. goto send;
  775. } else
  776. csum = udp_csum_outgoing(sk, skb);
  777. /* add protocol-dependent pseudo-header */
  778. uh->check = csum_ipv6_magic(&fl->fl6_src, &fl->fl6_dst,
  779. up->len, fl->proto, csum );
  780. if (uh->check == 0)
  781. uh->check = CSUM_MANGLED_0;
  782. send:
  783. err = ip6_push_pending_frames(sk);
  784. if (err) {
  785. if (err == -ENOBUFS && !inet6_sk(sk)->recverr) {
  786. UDP6_INC_STATS_USER(sock_net(sk),
  787. UDP_MIB_SNDBUFERRORS, is_udplite);
  788. err = 0;
  789. }
  790. } else
  791. UDP6_INC_STATS_USER(sock_net(sk),
  792. UDP_MIB_OUTDATAGRAMS, is_udplite);
  793. out:
  794. up->len = 0;
  795. up->pending = 0;
  796. return err;
  797. }
  798. int udpv6_sendmsg(struct kiocb *iocb, struct sock *sk,
  799. struct msghdr *msg, size_t len)
  800. {
  801. struct ipv6_txoptions opt_space;
  802. struct udp_sock *up = udp_sk(sk);
  803. struct inet_sock *inet = inet_sk(sk);
  804. struct ipv6_pinfo *np = inet6_sk(sk);
  805. struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) msg->msg_name;
  806. struct in6_addr *daddr, *final_p = NULL, final;
  807. struct ipv6_txoptions *opt = NULL;
  808. struct ip6_flowlabel *flowlabel = NULL;
  809. struct flowi fl;
  810. struct dst_entry *dst;
  811. int addr_len = msg->msg_namelen;
  812. int ulen = len;
  813. int hlimit = -1;
  814. int tclass = -1;
  815. int dontfrag = -1;
  816. int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
  817. int err;
  818. int connected = 0;
  819. int is_udplite = IS_UDPLITE(sk);
  820. int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
  821. /* destination address check */
  822. if (sin6) {
  823. if (addr_len < offsetof(struct sockaddr, sa_data))
  824. return -EINVAL;
  825. switch (sin6->sin6_family) {
  826. case AF_INET6:
  827. if (addr_len < SIN6_LEN_RFC2133)
  828. return -EINVAL;
  829. daddr = &sin6->sin6_addr;
  830. break;
  831. case AF_INET:
  832. goto do_udp_sendmsg;
  833. case AF_UNSPEC:
  834. msg->msg_name = sin6 = NULL;
  835. msg->msg_namelen = addr_len = 0;
  836. daddr = NULL;
  837. break;
  838. default:
  839. return -EINVAL;
  840. }
  841. } else if (!up->pending) {
  842. if (sk->sk_state != TCP_ESTABLISHED)
  843. return -EDESTADDRREQ;
  844. daddr = &np->daddr;
  845. } else
  846. daddr = NULL;
  847. if (daddr) {
  848. if (ipv6_addr_v4mapped(daddr)) {
  849. struct sockaddr_in sin;
  850. sin.sin_family = AF_INET;
  851. sin.sin_port = sin6 ? sin6->sin6_port : inet->inet_dport;
  852. sin.sin_addr.s_addr = daddr->s6_addr32[3];
  853. msg->msg_name = &sin;
  854. msg->msg_namelen = sizeof(sin);
  855. do_udp_sendmsg:
  856. if (__ipv6_only_sock(sk))
  857. return -ENETUNREACH;
  858. return udp_sendmsg(iocb, sk, msg, len);
  859. }
  860. }
  861. if (up->pending == AF_INET)
  862. return udp_sendmsg(iocb, sk, msg, len);
  863. /* Rough check on arithmetic overflow,
  864. better check is made in ip6_append_data().
  865. */
  866. if (len > INT_MAX - sizeof(struct udphdr))
  867. return -EMSGSIZE;
  868. if (up->pending) {
  869. /*
  870. * There are pending frames.
  871. * The socket lock must be held while it's corked.
  872. */
  873. lock_sock(sk);
  874. if (likely(up->pending)) {
  875. if (unlikely(up->pending != AF_INET6)) {
  876. release_sock(sk);
  877. return -EAFNOSUPPORT;
  878. }
  879. dst = NULL;
  880. goto do_append_data;
  881. }
  882. release_sock(sk);
  883. }
  884. ulen += sizeof(struct udphdr);
  885. memset(&fl, 0, sizeof(fl));
  886. if (sin6) {
  887. if (sin6->sin6_port == 0)
  888. return -EINVAL;
  889. fl.fl_ip_dport = sin6->sin6_port;
  890. daddr = &sin6->sin6_addr;
  891. if (np->sndflow) {
  892. fl.fl6_flowlabel = sin6->sin6_flowinfo&IPV6_FLOWINFO_MASK;
  893. if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) {
  894. flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
  895. if (flowlabel == NULL)
  896. return -EINVAL;
  897. daddr = &flowlabel->dst;
  898. }
  899. }
  900. /*
  901. * Otherwise it will be difficult to maintain
  902. * sk->sk_dst_cache.
  903. */
  904. if (sk->sk_state == TCP_ESTABLISHED &&
  905. ipv6_addr_equal(daddr, &np->daddr))
  906. daddr = &np->daddr;
  907. if (addr_len >= sizeof(struct sockaddr_in6) &&
  908. sin6->sin6_scope_id &&
  909. ipv6_addr_type(daddr)&IPV6_ADDR_LINKLOCAL)
  910. fl.oif = sin6->sin6_scope_id;
  911. } else {
  912. if (sk->sk_state != TCP_ESTABLISHED)
  913. return -EDESTADDRREQ;
  914. fl.fl_ip_dport = inet->inet_dport;
  915. daddr = &np->daddr;
  916. fl.fl6_flowlabel = np->flow_label;
  917. connected = 1;
  918. }
  919. if (!fl.oif)
  920. fl.oif = sk->sk_bound_dev_if;
  921. if (!fl.oif)
  922. fl.oif = np->sticky_pktinfo.ipi6_ifindex;
  923. fl.mark = sk->sk_mark;
  924. if (msg->msg_controllen) {
  925. opt = &opt_space;
  926. memset(opt, 0, sizeof(struct ipv6_txoptions));
  927. opt->tot_len = sizeof(*opt);
  928. err = datagram_send_ctl(sock_net(sk), msg, &fl, opt, &hlimit,
  929. &tclass, &dontfrag);
  930. if (err < 0) {
  931. fl6_sock_release(flowlabel);
  932. return err;
  933. }
  934. if ((fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) && !flowlabel) {
  935. flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
  936. if (flowlabel == NULL)
  937. return -EINVAL;
  938. }
  939. if (!(opt->opt_nflen|opt->opt_flen))
  940. opt = NULL;
  941. connected = 0;
  942. }
  943. if (opt == NULL)
  944. opt = np->opt;
  945. if (flowlabel)
  946. opt = fl6_merge_options(&opt_space, flowlabel, opt);
  947. opt = ipv6_fixup_options(&opt_space, opt);
  948. fl.proto = sk->sk_protocol;
  949. if (!ipv6_addr_any(daddr))
  950. ipv6_addr_copy(&fl.fl6_dst, daddr);
  951. else
  952. fl.fl6_dst.s6_addr[15] = 0x1; /* :: means loopback (BSD'ism) */
  953. if (ipv6_addr_any(&fl.fl6_src) && !ipv6_addr_any(&np->saddr))
  954. ipv6_addr_copy(&fl.fl6_src, &np->saddr);
  955. fl.fl_ip_sport = inet->inet_sport;
  956. /* merge ip6_build_xmit from ip6_output */
  957. if (opt && opt->srcrt) {
  958. struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
  959. ipv6_addr_copy(&final, &fl.fl6_dst);
  960. ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
  961. final_p = &final;
  962. connected = 0;
  963. }
  964. if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst)) {
  965. fl.oif = np->mcast_oif;
  966. connected = 0;
  967. }
  968. security_sk_classify_flow(sk, &fl);
  969. err = ip6_sk_dst_lookup(sk, &dst, &fl);
  970. if (err)
  971. goto out;
  972. if (final_p)
  973. ipv6_addr_copy(&fl.fl6_dst, final_p);
  974. err = __xfrm_lookup(sock_net(sk), &dst, &fl, sk, XFRM_LOOKUP_WAIT);
  975. if (err < 0) {
  976. if (err == -EREMOTE)
  977. err = ip6_dst_blackhole(sk, &dst, &fl);
  978. if (err < 0)
  979. goto out;
  980. }
  981. if (hlimit < 0) {
  982. if (ipv6_addr_is_multicast(&fl.fl6_dst))
  983. hlimit = np->mcast_hops;
  984. else
  985. hlimit = np->hop_limit;
  986. if (hlimit < 0)
  987. hlimit = ip6_dst_hoplimit(dst);
  988. }
  989. if (tclass < 0)
  990. tclass = np->tclass;
  991. if (dontfrag < 0)
  992. dontfrag = np->dontfrag;
  993. if (msg->msg_flags&MSG_CONFIRM)
  994. goto do_confirm;
  995. back_from_confirm:
  996. lock_sock(sk);
  997. if (unlikely(up->pending)) {
  998. /* The socket is already corked while preparing it. */
  999. /* ... which is an evident application bug. --ANK */
  1000. release_sock(sk);
  1001. LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 2\n");
  1002. err = -EINVAL;
  1003. goto out;
  1004. }
  1005. up->pending = AF_INET6;
  1006. do_append_data:
  1007. up->len += ulen;
  1008. getfrag = is_udplite ? udplite_getfrag : ip_generic_getfrag;
  1009. err = ip6_append_data(sk, getfrag, msg->msg_iov, ulen,
  1010. sizeof(struct udphdr), hlimit, tclass, opt, &fl,
  1011. (struct rt6_info*)dst,
  1012. corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags, dontfrag);
  1013. if (err)
  1014. udp_v6_flush_pending_frames(sk);
  1015. else if (!corkreq)
  1016. err = udp_v6_push_pending_frames(sk);
  1017. else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
  1018. up->pending = 0;
  1019. if (dst) {
  1020. if (connected) {
  1021. ip6_dst_store(sk, dst,
  1022. ipv6_addr_equal(&fl.fl6_dst, &np->daddr) ?
  1023. &np->daddr : NULL,
  1024. #ifdef CONFIG_IPV6_SUBTREES
  1025. ipv6_addr_equal(&fl.fl6_src, &np->saddr) ?
  1026. &np->saddr :
  1027. #endif
  1028. NULL);
  1029. } else {
  1030. dst_release(dst);
  1031. }
  1032. dst = NULL;
  1033. }
  1034. if (err > 0)
  1035. err = np->recverr ? net_xmit_errno(err) : 0;
  1036. release_sock(sk);
  1037. out:
  1038. dst_release(dst);
  1039. fl6_sock_release(flowlabel);
  1040. if (!err)
  1041. return len;
  1042. /*
  1043. * ENOBUFS = no kernel mem, SOCK_NOSPACE = no sndbuf space. Reporting
  1044. * ENOBUFS might not be good (it's not tunable per se), but otherwise
  1045. * we don't have a good statistic (IpOutDiscards but it can be too many
  1046. * things). We could add another new stat but at least for now that
  1047. * seems like overkill.
  1048. */
  1049. if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
  1050. UDP6_INC_STATS_USER(sock_net(sk),
  1051. UDP_MIB_SNDBUFERRORS, is_udplite);
  1052. }
  1053. return err;
  1054. do_confirm:
  1055. dst_confirm(dst);
  1056. if (!(msg->msg_flags&MSG_PROBE) || len)
  1057. goto back_from_confirm;
  1058. err = 0;
  1059. goto out;
  1060. }
  1061. void udpv6_destroy_sock(struct sock *sk)
  1062. {
  1063. lock_sock(sk);
  1064. udp_v6_flush_pending_frames(sk);
  1065. release_sock(sk);
  1066. inet6_destroy_sock(sk);
  1067. }
  1068. /*
  1069. * Socket option code for UDP
  1070. */
  1071. int udpv6_setsockopt(struct sock *sk, int level, int optname,
  1072. char __user *optval, unsigned int optlen)
  1073. {
  1074. if (level == SOL_UDP || level == SOL_UDPLITE)
  1075. return udp_lib_setsockopt(sk, level, optname, optval, optlen,
  1076. udp_v6_push_pending_frames);
  1077. return ipv6_setsockopt(sk, level, optname, optval, optlen);
  1078. }
  1079. #ifdef CONFIG_COMPAT
  1080. int compat_udpv6_setsockopt(struct sock *sk, int level, int optname,
  1081. char __user *optval, unsigned int optlen)
  1082. {
  1083. if (level == SOL_UDP || level == SOL_UDPLITE)
  1084. return udp_lib_setsockopt(sk, level, optname, optval, optlen,
  1085. udp_v6_push_pending_frames);
  1086. return compat_ipv6_setsockopt(sk, level, optname, optval, optlen);
  1087. }
  1088. #endif
  1089. int udpv6_getsockopt(struct sock *sk, int level, int optname,
  1090. char __user *optval, int __user *optlen)
  1091. {
  1092. if (level == SOL_UDP || level == SOL_UDPLITE)
  1093. return udp_lib_getsockopt(sk, level, optname, optval, optlen);
  1094. return ipv6_getsockopt(sk, level, optname, optval, optlen);
  1095. }
  1096. #ifdef CONFIG_COMPAT
  1097. int compat_udpv6_getsockopt(struct sock *sk, int level, int optname,
  1098. char __user *optval, int __user *optlen)
  1099. {
  1100. if (level == SOL_UDP || level == SOL_UDPLITE)
  1101. return udp_lib_getsockopt(sk, level, optname, optval, optlen);
  1102. return compat_ipv6_getsockopt(sk, level, optname, optval, optlen);
  1103. }
  1104. #endif
  1105. static int udp6_ufo_send_check(struct sk_buff *skb)
  1106. {
  1107. struct ipv6hdr *ipv6h;
  1108. struct udphdr *uh;
  1109. if (!pskb_may_pull(skb, sizeof(*uh)))
  1110. return -EINVAL;
  1111. ipv6h = ipv6_hdr(skb);
  1112. uh = udp_hdr(skb);
  1113. uh->check = ~csum_ipv6_magic(&ipv6h->saddr, &ipv6h->daddr, skb->len,
  1114. IPPROTO_UDP, 0);
  1115. skb->csum_start = skb_transport_header(skb) - skb->head;
  1116. skb->csum_offset = offsetof(struct udphdr, check);
  1117. skb->ip_summed = CHECKSUM_PARTIAL;
  1118. return 0;
  1119. }
  1120. static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb, int features)
  1121. {
  1122. struct sk_buff *segs = ERR_PTR(-EINVAL);
  1123. unsigned int mss;
  1124. unsigned int unfrag_ip6hlen, unfrag_len;
  1125. struct frag_hdr *fptr;
  1126. u8 *mac_start, *prevhdr;
  1127. u8 nexthdr;
  1128. u8 frag_hdr_sz = sizeof(struct frag_hdr);
  1129. int offset;
  1130. __wsum csum;
  1131. mss = skb_shinfo(skb)->gso_size;
  1132. if (unlikely(skb->len <= mss))
  1133. goto out;
  1134. if (skb_gso_ok(skb, features | NETIF_F_GSO_ROBUST)) {
  1135. /* Packet is from an untrusted source, reset gso_segs. */
  1136. int type = skb_shinfo(skb)->gso_type;
  1137. if (unlikely(type & ~(SKB_GSO_UDP | SKB_GSO_DODGY) ||
  1138. !(type & (SKB_GSO_UDP))))
  1139. goto out;
  1140. skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(skb->len, mss);
  1141. segs = NULL;
  1142. goto out;
  1143. }
  1144. /* Do software UFO. Complete and fill in the UDP checksum as HW cannot
  1145. * do checksum of UDP packets sent as multiple IP fragments.
  1146. */
  1147. offset = skb->csum_start - skb_headroom(skb);
  1148. csum = skb_checksum(skb, offset, skb->len- offset, 0);
  1149. offset += skb->csum_offset;
  1150. *(__sum16 *)(skb->data + offset) = csum_fold(csum);
  1151. skb->ip_summed = CHECKSUM_NONE;
  1152. /* Check if there is enough headroom to insert fragment header. */
  1153. if ((skb_headroom(skb) < frag_hdr_sz) &&
  1154. pskb_expand_head(skb, frag_hdr_sz, 0, GFP_ATOMIC))
  1155. goto out;
  1156. /* Find the unfragmentable header and shift it left by frag_hdr_sz
  1157. * bytes to insert fragment header.
  1158. */
  1159. unfrag_ip6hlen = ip6_find_1stfragopt(skb, &prevhdr);
  1160. nexthdr = *prevhdr;
  1161. *prevhdr = NEXTHDR_FRAGMENT;
  1162. unfrag_len = skb_network_header(skb) - skb_mac_header(skb) +
  1163. unfrag_ip6hlen;
  1164. mac_start = skb_mac_header(skb);
  1165. memmove(mac_start-frag_hdr_sz, mac_start, unfrag_len);
  1166. skb->mac_header -= frag_hdr_sz;
  1167. skb->network_header -= frag_hdr_sz;
  1168. fptr = (struct frag_hdr *)(skb_network_header(skb) + unfrag_ip6hlen);
  1169. fptr->nexthdr = nexthdr;
  1170. fptr->reserved = 0;
  1171. ipv6_select_ident(fptr);
  1172. /* Fragment the skb. ipv6 header and the remaining fields of the
  1173. * fragment header are updated in ipv6_gso_segment()
  1174. */
  1175. segs = skb_segment(skb, features);
  1176. out:
  1177. return segs;
  1178. }
  1179. static const struct inet6_protocol udpv6_protocol = {
  1180. .handler = udpv6_rcv,
  1181. .err_handler = udpv6_err,
  1182. .gso_send_check = udp6_ufo_send_check,
  1183. .gso_segment = udp6_ufo_fragment,
  1184. .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
  1185. };
  1186. /* ------------------------------------------------------------------------ */
  1187. #ifdef CONFIG_PROC_FS
  1188. static void udp6_sock_seq_show(struct seq_file *seq, struct sock *sp, int bucket)
  1189. {
  1190. struct inet_sock *inet = inet_sk(sp);
  1191. struct ipv6_pinfo *np = inet6_sk(sp);
  1192. struct in6_addr *dest, *src;
  1193. __u16 destp, srcp;
  1194. dest = &np->daddr;
  1195. src = &np->rcv_saddr;
  1196. destp = ntohs(inet->inet_dport);
  1197. srcp = ntohs(inet->inet_sport);
  1198. seq_printf(seq,
  1199. "%5d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
  1200. "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %d\n",
  1201. bucket,
  1202. src->s6_addr32[0], src->s6_addr32[1],
  1203. src->s6_addr32[2], src->s6_addr32[3], srcp,
  1204. dest->s6_addr32[0], dest->s6_addr32[1],
  1205. dest->s6_addr32[2], dest->s6_addr32[3], destp,
  1206. sp->sk_state,
  1207. sk_wmem_alloc_get(sp),
  1208. sk_rmem_alloc_get(sp),
  1209. 0, 0L, 0,
  1210. sock_i_uid(sp), 0,
  1211. sock_i_ino(sp),
  1212. atomic_read(&sp->sk_refcnt), sp,
  1213. atomic_read(&sp->sk_drops));
  1214. }
  1215. int udp6_seq_show(struct seq_file *seq, void *v)
  1216. {
  1217. if (v == SEQ_START_TOKEN)
  1218. seq_printf(seq,
  1219. " sl "
  1220. "local_address "
  1221. "remote_address "
  1222. "st tx_queue rx_queue tr tm->when retrnsmt"
  1223. " uid timeout inode ref pointer drops\n");
  1224. else
  1225. udp6_sock_seq_show(seq, v, ((struct udp_iter_state *)seq->private)->bucket);
  1226. return 0;
  1227. }
  1228. static struct udp_seq_afinfo udp6_seq_afinfo = {
  1229. .name = "udp6",
  1230. .family = AF_INET6,
  1231. .udp_table = &udp_table,
  1232. .seq_fops = {
  1233. .owner = THIS_MODULE,
  1234. },
  1235. .seq_ops = {
  1236. .show = udp6_seq_show,
  1237. },
  1238. };
  1239. int __net_init udp6_proc_init(struct net *net)
  1240. {
  1241. return udp_proc_register(net, &udp6_seq_afinfo);
  1242. }
  1243. void udp6_proc_exit(struct net *net) {
  1244. udp_proc_unregister(net, &udp6_seq_afinfo);
  1245. }
  1246. #endif /* CONFIG_PROC_FS */
  1247. /* ------------------------------------------------------------------------ */
  1248. struct proto udpv6_prot = {
  1249. .name = "UDPv6",
  1250. .owner = THIS_MODULE,
  1251. .close = udp_lib_close,
  1252. .connect = ip6_datagram_connect,
  1253. .disconnect = udp_disconnect,
  1254. .ioctl = udp_ioctl,
  1255. .destroy = udpv6_destroy_sock,
  1256. .setsockopt = udpv6_setsockopt,
  1257. .getsockopt = udpv6_getsockopt,
  1258. .sendmsg = udpv6_sendmsg,
  1259. .recvmsg = udpv6_recvmsg,
  1260. .backlog_rcv = udpv6_queue_rcv_skb,
  1261. .hash = udp_lib_hash,
  1262. .unhash = udp_lib_unhash,
  1263. .get_port = udp_v6_get_port,
  1264. .memory_allocated = &udp_memory_allocated,
  1265. .sysctl_mem = sysctl_udp_mem,
  1266. .sysctl_wmem = &sysctl_udp_wmem_min,
  1267. .sysctl_rmem = &sysctl_udp_rmem_min,
  1268. .obj_size = sizeof(struct udp6_sock),
  1269. .slab_flags = SLAB_DESTROY_BY_RCU,
  1270. .h.udp_table = &udp_table,
  1271. #ifdef CONFIG_COMPAT
  1272. .compat_setsockopt = compat_udpv6_setsockopt,
  1273. .compat_getsockopt = compat_udpv6_getsockopt,
  1274. #endif
  1275. };
  1276. static struct inet_protosw udpv6_protosw = {
  1277. .type = SOCK_DGRAM,
  1278. .protocol = IPPROTO_UDP,
  1279. .prot = &udpv6_prot,
  1280. .ops = &inet6_dgram_ops,
  1281. .no_check = UDP_CSUM_DEFAULT,
  1282. .flags = INET_PROTOSW_PERMANENT,
  1283. };
  1284. int __init udpv6_init(void)
  1285. {
  1286. int ret;
  1287. ret = inet6_add_protocol(&udpv6_protocol, IPPROTO_UDP);
  1288. if (ret)
  1289. goto out;
  1290. ret = inet6_register_protosw(&udpv6_protosw);
  1291. if (ret)
  1292. goto out_udpv6_protocol;
  1293. out:
  1294. return ret;
  1295. out_udpv6_protocol:
  1296. inet6_del_protocol(&udpv6_protocol, IPPROTO_UDP);
  1297. goto out;
  1298. }
  1299. void udpv6_exit(void)
  1300. {
  1301. inet6_unregister_protosw(&udpv6_protosw);
  1302. inet6_del_protocol(&udpv6_protocol, IPPROTO_UDP);
  1303. }