udp.c 37 KB

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