udp.c 36 KB

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