datagram.c 25 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * common UDP/RAW code
  4. * Linux INET6 implementation
  5. *
  6. * Authors:
  7. * Pedro Roque <roque@di.fc.ul.pt>
  8. */
  9. #include <linux/capability.h>
  10. #include <linux/errno.h>
  11. #include <linux/types.h>
  12. #include <linux/kernel.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/socket.h>
  15. #include <linux/sockios.h>
  16. #include <linux/in6.h>
  17. #include <linux/ipv6.h>
  18. #include <linux/route.h>
  19. #include <linux/slab.h>
  20. #include <linux/export.h>
  21. #include <linux/icmp.h>
  22. #include <net/ipv6.h>
  23. #include <net/ndisc.h>
  24. #include <net/addrconf.h>
  25. #include <net/transp_v6.h>
  26. #include <net/ip6_route.h>
  27. #include <net/tcp_states.h>
  28. #include <net/dsfield.h>
  29. #include <net/sock_reuseport.h>
  30. #include <linux/errqueue.h>
  31. #include <linux/uaccess.h>
  32. static bool ipv6_mapped_addr_any(const struct in6_addr *a)
  33. {
  34. return ipv6_addr_v4mapped(a) && (a->s6_addr32[3] == 0);
  35. }
  36. static void ip6_datagram_flow_key_init(struct flowi6 *fl6, struct sock *sk)
  37. {
  38. struct inet_sock *inet = inet_sk(sk);
  39. struct ipv6_pinfo *np = inet6_sk(sk);
  40. memset(fl6, 0, sizeof(*fl6));
  41. fl6->flowi6_proto = sk->sk_protocol;
  42. fl6->daddr = sk->sk_v6_daddr;
  43. fl6->saddr = np->saddr;
  44. fl6->flowi6_oif = sk->sk_bound_dev_if;
  45. fl6->flowi6_mark = sk->sk_mark;
  46. fl6->fl6_dport = inet->inet_dport;
  47. fl6->fl6_sport = inet->inet_sport;
  48. fl6->flowlabel = np->flow_label;
  49. fl6->flowi6_uid = sk->sk_uid;
  50. if (!fl6->flowi6_oif)
  51. fl6->flowi6_oif = np->sticky_pktinfo.ipi6_ifindex;
  52. if (!fl6->flowi6_oif && ipv6_addr_is_multicast(&fl6->daddr))
  53. fl6->flowi6_oif = np->mcast_oif;
  54. security_sk_classify_flow(sk, flowi6_to_flowi(fl6));
  55. }
  56. int ip6_datagram_dst_update(struct sock *sk, bool fix_sk_saddr)
  57. {
  58. struct ip6_flowlabel *flowlabel = NULL;
  59. struct in6_addr *final_p, final;
  60. struct ipv6_txoptions *opt;
  61. struct dst_entry *dst;
  62. struct inet_sock *inet = inet_sk(sk);
  63. struct ipv6_pinfo *np = inet6_sk(sk);
  64. struct flowi6 fl6;
  65. int err = 0;
  66. if (np->sndflow && (np->flow_label & IPV6_FLOWLABEL_MASK)) {
  67. flowlabel = fl6_sock_lookup(sk, np->flow_label);
  68. if (IS_ERR(flowlabel))
  69. return -EINVAL;
  70. }
  71. ip6_datagram_flow_key_init(&fl6, sk);
  72. rcu_read_lock();
  73. opt = flowlabel ? flowlabel->opt : rcu_dereference(np->opt);
  74. final_p = fl6_update_dst(&fl6, opt, &final);
  75. rcu_read_unlock();
  76. dst = ip6_dst_lookup_flow(sock_net(sk), sk, &fl6, final_p);
  77. if (IS_ERR(dst)) {
  78. err = PTR_ERR(dst);
  79. goto out;
  80. }
  81. if (fix_sk_saddr) {
  82. if (ipv6_addr_any(&np->saddr))
  83. np->saddr = fl6.saddr;
  84. if (ipv6_addr_any(&sk->sk_v6_rcv_saddr)) {
  85. sk->sk_v6_rcv_saddr = fl6.saddr;
  86. inet->inet_rcv_saddr = LOOPBACK4_IPV6;
  87. if (sk->sk_prot->rehash)
  88. sk->sk_prot->rehash(sk);
  89. }
  90. }
  91. ip6_sk_dst_store_flow(sk, dst, &fl6);
  92. out:
  93. fl6_sock_release(flowlabel);
  94. return err;
  95. }
  96. void ip6_datagram_release_cb(struct sock *sk)
  97. {
  98. struct dst_entry *dst;
  99. if (ipv6_addr_v4mapped(&sk->sk_v6_daddr))
  100. return;
  101. rcu_read_lock();
  102. dst = __sk_dst_get(sk);
  103. if (!dst || !dst->obsolete ||
  104. dst->ops->check(dst, inet6_sk(sk)->dst_cookie)) {
  105. rcu_read_unlock();
  106. return;
  107. }
  108. rcu_read_unlock();
  109. ip6_datagram_dst_update(sk, false);
  110. }
  111. EXPORT_SYMBOL_GPL(ip6_datagram_release_cb);
  112. int __ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr,
  113. int addr_len)
  114. {
  115. struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
  116. struct inet_sock *inet = inet_sk(sk);
  117. struct ipv6_pinfo *np = inet6_sk(sk);
  118. struct in6_addr *daddr, old_daddr;
  119. __be32 fl6_flowlabel = 0;
  120. __be32 old_fl6_flowlabel;
  121. __be16 old_dport;
  122. int addr_type;
  123. int err;
  124. if (usin->sin6_family == AF_INET) {
  125. if (__ipv6_only_sock(sk))
  126. return -EAFNOSUPPORT;
  127. err = __ip4_datagram_connect(sk, uaddr, addr_len);
  128. goto ipv4_connected;
  129. }
  130. if (addr_len < SIN6_LEN_RFC2133)
  131. return -EINVAL;
  132. if (usin->sin6_family != AF_INET6)
  133. return -EAFNOSUPPORT;
  134. if (np->sndflow)
  135. fl6_flowlabel = usin->sin6_flowinfo & IPV6_FLOWINFO_MASK;
  136. if (ipv6_addr_any(&usin->sin6_addr)) {
  137. /*
  138. * connect to self
  139. */
  140. if (ipv6_addr_v4mapped(&sk->sk_v6_rcv_saddr))
  141. ipv6_addr_set_v4mapped(htonl(INADDR_LOOPBACK),
  142. &usin->sin6_addr);
  143. else
  144. usin->sin6_addr = in6addr_loopback;
  145. }
  146. addr_type = ipv6_addr_type(&usin->sin6_addr);
  147. daddr = &usin->sin6_addr;
  148. if (addr_type & IPV6_ADDR_MAPPED) {
  149. struct sockaddr_in sin;
  150. if (__ipv6_only_sock(sk)) {
  151. err = -ENETUNREACH;
  152. goto out;
  153. }
  154. sin.sin_family = AF_INET;
  155. sin.sin_addr.s_addr = daddr->s6_addr32[3];
  156. sin.sin_port = usin->sin6_port;
  157. err = __ip4_datagram_connect(sk,
  158. (struct sockaddr *) &sin,
  159. sizeof(sin));
  160. ipv4_connected:
  161. if (err)
  162. goto out;
  163. ipv6_addr_set_v4mapped(inet->inet_daddr, &sk->sk_v6_daddr);
  164. if (ipv6_addr_any(&np->saddr) ||
  165. ipv6_mapped_addr_any(&np->saddr))
  166. ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
  167. if (ipv6_addr_any(&sk->sk_v6_rcv_saddr) ||
  168. ipv6_mapped_addr_any(&sk->sk_v6_rcv_saddr)) {
  169. ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
  170. &sk->sk_v6_rcv_saddr);
  171. if (sk->sk_prot->rehash)
  172. sk->sk_prot->rehash(sk);
  173. }
  174. goto out;
  175. }
  176. if (__ipv6_addr_needs_scope_id(addr_type)) {
  177. if (addr_len >= sizeof(struct sockaddr_in6) &&
  178. usin->sin6_scope_id) {
  179. if (!sk_dev_equal_l3scope(sk, usin->sin6_scope_id)) {
  180. err = -EINVAL;
  181. goto out;
  182. }
  183. sk->sk_bound_dev_if = usin->sin6_scope_id;
  184. }
  185. if (!sk->sk_bound_dev_if && (addr_type & IPV6_ADDR_MULTICAST))
  186. sk->sk_bound_dev_if = np->mcast_oif;
  187. /* Connect to link-local address requires an interface */
  188. if (!sk->sk_bound_dev_if) {
  189. err = -EINVAL;
  190. goto out;
  191. }
  192. }
  193. /* save the current peer information before updating it */
  194. old_daddr = sk->sk_v6_daddr;
  195. old_fl6_flowlabel = np->flow_label;
  196. old_dport = inet->inet_dport;
  197. sk->sk_v6_daddr = *daddr;
  198. np->flow_label = fl6_flowlabel;
  199. inet->inet_dport = usin->sin6_port;
  200. /*
  201. * Check for a route to destination an obtain the
  202. * destination cache for it.
  203. */
  204. err = ip6_datagram_dst_update(sk, true);
  205. if (err) {
  206. /* Restore the socket peer info, to keep it consistent with
  207. * the old socket state
  208. */
  209. sk->sk_v6_daddr = old_daddr;
  210. np->flow_label = old_fl6_flowlabel;
  211. inet->inet_dport = old_dport;
  212. goto out;
  213. }
  214. reuseport_has_conns(sk, true);
  215. sk->sk_state = TCP_ESTABLISHED;
  216. sk_set_txhash(sk);
  217. out:
  218. return err;
  219. }
  220. EXPORT_SYMBOL_GPL(__ip6_datagram_connect);
  221. int ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
  222. {
  223. int res;
  224. lock_sock(sk);
  225. res = __ip6_datagram_connect(sk, uaddr, addr_len);
  226. release_sock(sk);
  227. return res;
  228. }
  229. EXPORT_SYMBOL_GPL(ip6_datagram_connect);
  230. int ip6_datagram_connect_v6_only(struct sock *sk, struct sockaddr *uaddr,
  231. int addr_len)
  232. {
  233. DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, uaddr);
  234. if (sin6->sin6_family != AF_INET6)
  235. return -EAFNOSUPPORT;
  236. return ip6_datagram_connect(sk, uaddr, addr_len);
  237. }
  238. EXPORT_SYMBOL_GPL(ip6_datagram_connect_v6_only);
  239. static void ipv6_icmp_error_rfc4884(const struct sk_buff *skb,
  240. struct sock_ee_data_rfc4884 *out)
  241. {
  242. switch (icmp6_hdr(skb)->icmp6_type) {
  243. case ICMPV6_TIME_EXCEED:
  244. case ICMPV6_DEST_UNREACH:
  245. ip_icmp_error_rfc4884(skb, out, sizeof(struct icmp6hdr),
  246. icmp6_hdr(skb)->icmp6_datagram_len * 8);
  247. }
  248. }
  249. void ipv6_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
  250. __be16 port, u32 info, u8 *payload)
  251. {
  252. struct ipv6_pinfo *np = inet6_sk(sk);
  253. struct icmp6hdr *icmph = icmp6_hdr(skb);
  254. struct sock_exterr_skb *serr;
  255. if (!np->recverr)
  256. return;
  257. skb = skb_clone(skb, GFP_ATOMIC);
  258. if (!skb)
  259. return;
  260. skb->protocol = htons(ETH_P_IPV6);
  261. serr = SKB_EXT_ERR(skb);
  262. serr->ee.ee_errno = err;
  263. serr->ee.ee_origin = SO_EE_ORIGIN_ICMP6;
  264. serr->ee.ee_type = icmph->icmp6_type;
  265. serr->ee.ee_code = icmph->icmp6_code;
  266. serr->ee.ee_pad = 0;
  267. serr->ee.ee_info = info;
  268. serr->ee.ee_data = 0;
  269. serr->addr_offset = (u8 *)&(((struct ipv6hdr *)(icmph + 1))->daddr) -
  270. skb_network_header(skb);
  271. serr->port = port;
  272. __skb_pull(skb, payload - skb->data);
  273. if (inet6_sk(sk)->recverr_rfc4884)
  274. ipv6_icmp_error_rfc4884(skb, &serr->ee.ee_rfc4884);
  275. skb_reset_transport_header(skb);
  276. if (sock_queue_err_skb(sk, skb))
  277. kfree_skb(skb);
  278. }
  279. void ipv6_local_error(struct sock *sk, int err, struct flowi6 *fl6, u32 info)
  280. {
  281. const struct ipv6_pinfo *np = inet6_sk(sk);
  282. struct sock_exterr_skb *serr;
  283. struct ipv6hdr *iph;
  284. struct sk_buff *skb;
  285. if (!np->recverr)
  286. return;
  287. skb = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
  288. if (!skb)
  289. return;
  290. skb->protocol = htons(ETH_P_IPV6);
  291. skb_put(skb, sizeof(struct ipv6hdr));
  292. skb_reset_network_header(skb);
  293. iph = ipv6_hdr(skb);
  294. iph->daddr = fl6->daddr;
  295. ip6_flow_hdr(iph, 0, 0);
  296. serr = SKB_EXT_ERR(skb);
  297. serr->ee.ee_errno = err;
  298. serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
  299. serr->ee.ee_type = 0;
  300. serr->ee.ee_code = 0;
  301. serr->ee.ee_pad = 0;
  302. serr->ee.ee_info = info;
  303. serr->ee.ee_data = 0;
  304. serr->addr_offset = (u8 *)&iph->daddr - skb_network_header(skb);
  305. serr->port = fl6->fl6_dport;
  306. __skb_pull(skb, skb_tail_pointer(skb) - skb->data);
  307. skb_reset_transport_header(skb);
  308. if (sock_queue_err_skb(sk, skb))
  309. kfree_skb(skb);
  310. }
  311. void ipv6_local_rxpmtu(struct sock *sk, struct flowi6 *fl6, u32 mtu)
  312. {
  313. struct ipv6_pinfo *np = inet6_sk(sk);
  314. struct ipv6hdr *iph;
  315. struct sk_buff *skb;
  316. struct ip6_mtuinfo *mtu_info;
  317. if (!np->rxopt.bits.rxpmtu)
  318. return;
  319. skb = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
  320. if (!skb)
  321. return;
  322. skb_put(skb, sizeof(struct ipv6hdr));
  323. skb_reset_network_header(skb);
  324. iph = ipv6_hdr(skb);
  325. iph->daddr = fl6->daddr;
  326. mtu_info = IP6CBMTU(skb);
  327. mtu_info->ip6m_mtu = mtu;
  328. mtu_info->ip6m_addr.sin6_family = AF_INET6;
  329. mtu_info->ip6m_addr.sin6_port = 0;
  330. mtu_info->ip6m_addr.sin6_flowinfo = 0;
  331. mtu_info->ip6m_addr.sin6_scope_id = fl6->flowi6_oif;
  332. mtu_info->ip6m_addr.sin6_addr = ipv6_hdr(skb)->daddr;
  333. __skb_pull(skb, skb_tail_pointer(skb) - skb->data);
  334. skb_reset_transport_header(skb);
  335. skb = xchg(&np->rxpmtu, skb);
  336. kfree_skb(skb);
  337. }
  338. /* For some errors we have valid addr_offset even with zero payload and
  339. * zero port. Also, addr_offset should be supported if port is set.
  340. */
  341. static inline bool ipv6_datagram_support_addr(struct sock_exterr_skb *serr)
  342. {
  343. return serr->ee.ee_origin == SO_EE_ORIGIN_ICMP6 ||
  344. serr->ee.ee_origin == SO_EE_ORIGIN_ICMP ||
  345. serr->ee.ee_origin == SO_EE_ORIGIN_LOCAL || serr->port;
  346. }
  347. /* IPv6 supports cmsg on all origins aside from SO_EE_ORIGIN_LOCAL.
  348. *
  349. * At one point, excluding local errors was a quick test to identify icmp/icmp6
  350. * errors. This is no longer true, but the test remained, so the v6 stack,
  351. * unlike v4, also honors cmsg requests on all wifi and timestamp errors.
  352. */
  353. static bool ip6_datagram_support_cmsg(struct sk_buff *skb,
  354. struct sock_exterr_skb *serr)
  355. {
  356. if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP ||
  357. serr->ee.ee_origin == SO_EE_ORIGIN_ICMP6)
  358. return true;
  359. if (serr->ee.ee_origin == SO_EE_ORIGIN_LOCAL)
  360. return false;
  361. if (!IP6CB(skb)->iif)
  362. return false;
  363. return true;
  364. }
  365. /*
  366. * Handle MSG_ERRQUEUE
  367. */
  368. int ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len, int *addr_len)
  369. {
  370. struct ipv6_pinfo *np = inet6_sk(sk);
  371. struct sock_exterr_skb *serr;
  372. struct sk_buff *skb;
  373. DECLARE_SOCKADDR(struct sockaddr_in6 *, sin, msg->msg_name);
  374. struct {
  375. struct sock_extended_err ee;
  376. struct sockaddr_in6 offender;
  377. } errhdr;
  378. int err;
  379. int copied;
  380. err = -EAGAIN;
  381. skb = sock_dequeue_err_skb(sk);
  382. if (!skb)
  383. goto out;
  384. copied = skb->len;
  385. if (copied > len) {
  386. msg->msg_flags |= MSG_TRUNC;
  387. copied = len;
  388. }
  389. err = skb_copy_datagram_msg(skb, 0, msg, copied);
  390. if (unlikely(err)) {
  391. kfree_skb(skb);
  392. return err;
  393. }
  394. sock_recv_timestamp(msg, sk, skb);
  395. serr = SKB_EXT_ERR(skb);
  396. if (sin && ipv6_datagram_support_addr(serr)) {
  397. const unsigned char *nh = skb_network_header(skb);
  398. sin->sin6_family = AF_INET6;
  399. sin->sin6_flowinfo = 0;
  400. sin->sin6_port = serr->port;
  401. if (skb->protocol == htons(ETH_P_IPV6)) {
  402. const struct ipv6hdr *ip6h = container_of((struct in6_addr *)(nh + serr->addr_offset),
  403. struct ipv6hdr, daddr);
  404. sin->sin6_addr = ip6h->daddr;
  405. if (np->sndflow)
  406. sin->sin6_flowinfo = ip6_flowinfo(ip6h);
  407. sin->sin6_scope_id =
  408. ipv6_iface_scope_id(&sin->sin6_addr,
  409. IP6CB(skb)->iif);
  410. } else {
  411. ipv6_addr_set_v4mapped(*(__be32 *)(nh + serr->addr_offset),
  412. &sin->sin6_addr);
  413. sin->sin6_scope_id = 0;
  414. }
  415. *addr_len = sizeof(*sin);
  416. }
  417. memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
  418. sin = &errhdr.offender;
  419. memset(sin, 0, sizeof(*sin));
  420. if (ip6_datagram_support_cmsg(skb, serr)) {
  421. sin->sin6_family = AF_INET6;
  422. if (np->rxopt.all)
  423. ip6_datagram_recv_common_ctl(sk, msg, skb);
  424. if (skb->protocol == htons(ETH_P_IPV6)) {
  425. sin->sin6_addr = ipv6_hdr(skb)->saddr;
  426. if (np->rxopt.all)
  427. ip6_datagram_recv_specific_ctl(sk, msg, skb);
  428. sin->sin6_scope_id =
  429. ipv6_iface_scope_id(&sin->sin6_addr,
  430. IP6CB(skb)->iif);
  431. } else {
  432. ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr,
  433. &sin->sin6_addr);
  434. if (inet_sk(sk)->cmsg_flags)
  435. ip_cmsg_recv(msg, skb);
  436. }
  437. }
  438. put_cmsg(msg, SOL_IPV6, IPV6_RECVERR, sizeof(errhdr), &errhdr);
  439. /* Now we could try to dump offended packet options */
  440. msg->msg_flags |= MSG_ERRQUEUE;
  441. err = copied;
  442. consume_skb(skb);
  443. out:
  444. return err;
  445. }
  446. EXPORT_SYMBOL_GPL(ipv6_recv_error);
  447. /*
  448. * Handle IPV6_RECVPATHMTU
  449. */
  450. int ipv6_recv_rxpmtu(struct sock *sk, struct msghdr *msg, int len,
  451. int *addr_len)
  452. {
  453. struct ipv6_pinfo *np = inet6_sk(sk);
  454. struct sk_buff *skb;
  455. struct ip6_mtuinfo mtu_info;
  456. DECLARE_SOCKADDR(struct sockaddr_in6 *, sin, msg->msg_name);
  457. int err;
  458. int copied;
  459. err = -EAGAIN;
  460. skb = xchg(&np->rxpmtu, NULL);
  461. if (!skb)
  462. goto out;
  463. copied = skb->len;
  464. if (copied > len) {
  465. msg->msg_flags |= MSG_TRUNC;
  466. copied = len;
  467. }
  468. err = skb_copy_datagram_msg(skb, 0, msg, copied);
  469. if (err)
  470. goto out_free_skb;
  471. sock_recv_timestamp(msg, sk, skb);
  472. memcpy(&mtu_info, IP6CBMTU(skb), sizeof(mtu_info));
  473. if (sin) {
  474. sin->sin6_family = AF_INET6;
  475. sin->sin6_flowinfo = 0;
  476. sin->sin6_port = 0;
  477. sin->sin6_scope_id = mtu_info.ip6m_addr.sin6_scope_id;
  478. sin->sin6_addr = mtu_info.ip6m_addr.sin6_addr;
  479. *addr_len = sizeof(*sin);
  480. }
  481. put_cmsg(msg, SOL_IPV6, IPV6_PATHMTU, sizeof(mtu_info), &mtu_info);
  482. err = copied;
  483. out_free_skb:
  484. kfree_skb(skb);
  485. out:
  486. return err;
  487. }
  488. void ip6_datagram_recv_common_ctl(struct sock *sk, struct msghdr *msg,
  489. struct sk_buff *skb)
  490. {
  491. struct ipv6_pinfo *np = inet6_sk(sk);
  492. bool is_ipv6 = skb->protocol == htons(ETH_P_IPV6);
  493. if (np->rxopt.bits.rxinfo) {
  494. struct in6_pktinfo src_info;
  495. if (is_ipv6) {
  496. src_info.ipi6_ifindex = IP6CB(skb)->iif;
  497. src_info.ipi6_addr = ipv6_hdr(skb)->daddr;
  498. } else {
  499. src_info.ipi6_ifindex =
  500. PKTINFO_SKB_CB(skb)->ipi_ifindex;
  501. ipv6_addr_set_v4mapped(ip_hdr(skb)->daddr,
  502. &src_info.ipi6_addr);
  503. }
  504. if (src_info.ipi6_ifindex >= 0)
  505. put_cmsg(msg, SOL_IPV6, IPV6_PKTINFO,
  506. sizeof(src_info), &src_info);
  507. }
  508. }
  509. void ip6_datagram_recv_specific_ctl(struct sock *sk, struct msghdr *msg,
  510. struct sk_buff *skb)
  511. {
  512. struct ipv6_pinfo *np = inet6_sk(sk);
  513. struct inet6_skb_parm *opt = IP6CB(skb);
  514. unsigned char *nh = skb_network_header(skb);
  515. if (np->rxopt.bits.rxhlim) {
  516. int hlim = ipv6_hdr(skb)->hop_limit;
  517. put_cmsg(msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);
  518. }
  519. if (np->rxopt.bits.rxtclass) {
  520. int tclass = ipv6_get_dsfield(ipv6_hdr(skb));
  521. put_cmsg(msg, SOL_IPV6, IPV6_TCLASS, sizeof(tclass), &tclass);
  522. }
  523. if (np->rxopt.bits.rxflow) {
  524. __be32 flowinfo = ip6_flowinfo((struct ipv6hdr *)nh);
  525. if (flowinfo)
  526. put_cmsg(msg, SOL_IPV6, IPV6_FLOWINFO, sizeof(flowinfo), &flowinfo);
  527. }
  528. /* HbH is allowed only once */
  529. if (np->rxopt.bits.hopopts && (opt->flags & IP6SKB_HOPBYHOP)) {
  530. u8 *ptr = nh + sizeof(struct ipv6hdr);
  531. put_cmsg(msg, SOL_IPV6, IPV6_HOPOPTS, (ptr[1]+1)<<3, ptr);
  532. }
  533. if (opt->lastopt &&
  534. (np->rxopt.bits.dstopts || np->rxopt.bits.srcrt)) {
  535. /*
  536. * Silly enough, but we need to reparse in order to
  537. * report extension headers (except for HbH)
  538. * in order.
  539. *
  540. * Also note that IPV6_RECVRTHDRDSTOPTS is NOT
  541. * (and WILL NOT be) defined because
  542. * IPV6_RECVDSTOPTS is more generic. --yoshfuji
  543. */
  544. unsigned int off = sizeof(struct ipv6hdr);
  545. u8 nexthdr = ipv6_hdr(skb)->nexthdr;
  546. while (off <= opt->lastopt) {
  547. unsigned int len;
  548. u8 *ptr = nh + off;
  549. switch (nexthdr) {
  550. case IPPROTO_DSTOPTS:
  551. nexthdr = ptr[0];
  552. len = (ptr[1] + 1) << 3;
  553. if (np->rxopt.bits.dstopts)
  554. put_cmsg(msg, SOL_IPV6, IPV6_DSTOPTS, len, ptr);
  555. break;
  556. case IPPROTO_ROUTING:
  557. nexthdr = ptr[0];
  558. len = (ptr[1] + 1) << 3;
  559. if (np->rxopt.bits.srcrt)
  560. put_cmsg(msg, SOL_IPV6, IPV6_RTHDR, len, ptr);
  561. break;
  562. case IPPROTO_AH:
  563. nexthdr = ptr[0];
  564. len = (ptr[1] + 2) << 2;
  565. break;
  566. default:
  567. nexthdr = ptr[0];
  568. len = (ptr[1] + 1) << 3;
  569. break;
  570. }
  571. off += len;
  572. }
  573. }
  574. /* socket options in old style */
  575. if (np->rxopt.bits.rxoinfo) {
  576. struct in6_pktinfo src_info;
  577. src_info.ipi6_ifindex = opt->iif;
  578. src_info.ipi6_addr = ipv6_hdr(skb)->daddr;
  579. put_cmsg(msg, SOL_IPV6, IPV6_2292PKTINFO, sizeof(src_info), &src_info);
  580. }
  581. if (np->rxopt.bits.rxohlim) {
  582. int hlim = ipv6_hdr(skb)->hop_limit;
  583. put_cmsg(msg, SOL_IPV6, IPV6_2292HOPLIMIT, sizeof(hlim), &hlim);
  584. }
  585. if (np->rxopt.bits.ohopopts && (opt->flags & IP6SKB_HOPBYHOP)) {
  586. u8 *ptr = nh + sizeof(struct ipv6hdr);
  587. put_cmsg(msg, SOL_IPV6, IPV6_2292HOPOPTS, (ptr[1]+1)<<3, ptr);
  588. }
  589. if (np->rxopt.bits.odstopts && opt->dst0) {
  590. u8 *ptr = nh + opt->dst0;
  591. put_cmsg(msg, SOL_IPV6, IPV6_2292DSTOPTS, (ptr[1]+1)<<3, ptr);
  592. }
  593. if (np->rxopt.bits.osrcrt && opt->srcrt) {
  594. struct ipv6_rt_hdr *rthdr = (struct ipv6_rt_hdr *)(nh + opt->srcrt);
  595. put_cmsg(msg, SOL_IPV6, IPV6_2292RTHDR, (rthdr->hdrlen+1) << 3, rthdr);
  596. }
  597. if (np->rxopt.bits.odstopts && opt->dst1) {
  598. u8 *ptr = nh + opt->dst1;
  599. put_cmsg(msg, SOL_IPV6, IPV6_2292DSTOPTS, (ptr[1]+1)<<3, ptr);
  600. }
  601. if (np->rxopt.bits.rxorigdstaddr) {
  602. struct sockaddr_in6 sin6;
  603. __be16 _ports[2], *ports;
  604. ports = skb_header_pointer(skb, skb_transport_offset(skb),
  605. sizeof(_ports), &_ports);
  606. if (ports) {
  607. /* All current transport protocols have the port numbers in the
  608. * first four bytes of the transport header and this function is
  609. * written with this assumption in mind.
  610. */
  611. sin6.sin6_family = AF_INET6;
  612. sin6.sin6_addr = ipv6_hdr(skb)->daddr;
  613. sin6.sin6_port = ports[1];
  614. sin6.sin6_flowinfo = 0;
  615. sin6.sin6_scope_id =
  616. ipv6_iface_scope_id(&ipv6_hdr(skb)->daddr,
  617. opt->iif);
  618. put_cmsg(msg, SOL_IPV6, IPV6_ORIGDSTADDR, sizeof(sin6), &sin6);
  619. }
  620. }
  621. if (np->rxopt.bits.recvfragsize && opt->frag_max_size) {
  622. int val = opt->frag_max_size;
  623. put_cmsg(msg, SOL_IPV6, IPV6_RECVFRAGSIZE, sizeof(val), &val);
  624. }
  625. }
  626. void ip6_datagram_recv_ctl(struct sock *sk, struct msghdr *msg,
  627. struct sk_buff *skb)
  628. {
  629. ip6_datagram_recv_common_ctl(sk, msg, skb);
  630. ip6_datagram_recv_specific_ctl(sk, msg, skb);
  631. }
  632. EXPORT_SYMBOL_GPL(ip6_datagram_recv_ctl);
  633. int ip6_datagram_send_ctl(struct net *net, struct sock *sk,
  634. struct msghdr *msg, struct flowi6 *fl6,
  635. struct ipcm6_cookie *ipc6)
  636. {
  637. struct in6_pktinfo *src_info;
  638. struct cmsghdr *cmsg;
  639. struct ipv6_rt_hdr *rthdr;
  640. struct ipv6_opt_hdr *hdr;
  641. struct ipv6_txoptions *opt = ipc6->opt;
  642. int len;
  643. int err = 0;
  644. for_each_cmsghdr(cmsg, msg) {
  645. int addr_type;
  646. if (!CMSG_OK(msg, cmsg)) {
  647. err = -EINVAL;
  648. goto exit_f;
  649. }
  650. if (cmsg->cmsg_level == SOL_SOCKET) {
  651. err = __sock_cmsg_send(sk, msg, cmsg, &ipc6->sockc);
  652. if (err)
  653. return err;
  654. continue;
  655. }
  656. if (cmsg->cmsg_level != SOL_IPV6)
  657. continue;
  658. switch (cmsg->cmsg_type) {
  659. case IPV6_PKTINFO:
  660. case IPV6_2292PKTINFO:
  661. {
  662. struct net_device *dev = NULL;
  663. int src_idx;
  664. if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct in6_pktinfo))) {
  665. err = -EINVAL;
  666. goto exit_f;
  667. }
  668. src_info = (struct in6_pktinfo *)CMSG_DATA(cmsg);
  669. src_idx = src_info->ipi6_ifindex;
  670. if (src_idx) {
  671. if (fl6->flowi6_oif &&
  672. src_idx != fl6->flowi6_oif &&
  673. (sk->sk_bound_dev_if != fl6->flowi6_oif ||
  674. !sk_dev_equal_l3scope(sk, src_idx)))
  675. return -EINVAL;
  676. fl6->flowi6_oif = src_idx;
  677. }
  678. addr_type = __ipv6_addr_type(&src_info->ipi6_addr);
  679. rcu_read_lock();
  680. if (fl6->flowi6_oif) {
  681. dev = dev_get_by_index_rcu(net, fl6->flowi6_oif);
  682. if (!dev) {
  683. rcu_read_unlock();
  684. return -ENODEV;
  685. }
  686. } else if (addr_type & IPV6_ADDR_LINKLOCAL) {
  687. rcu_read_unlock();
  688. return -EINVAL;
  689. }
  690. if (addr_type != IPV6_ADDR_ANY) {
  691. int strict = __ipv6_addr_src_scope(addr_type) <= IPV6_ADDR_SCOPE_LINKLOCAL;
  692. if (!ipv6_can_nonlocal_bind(net, inet_sk(sk)) &&
  693. !ipv6_chk_addr_and_flags(net, &src_info->ipi6_addr,
  694. dev, !strict, 0,
  695. IFA_F_TENTATIVE) &&
  696. !ipv6_chk_acast_addr_src(net, dev,
  697. &src_info->ipi6_addr))
  698. err = -EINVAL;
  699. else
  700. fl6->saddr = src_info->ipi6_addr;
  701. }
  702. rcu_read_unlock();
  703. if (err)
  704. goto exit_f;
  705. break;
  706. }
  707. case IPV6_FLOWINFO:
  708. if (cmsg->cmsg_len < CMSG_LEN(4)) {
  709. err = -EINVAL;
  710. goto exit_f;
  711. }
  712. if (fl6->flowlabel&IPV6_FLOWINFO_MASK) {
  713. if ((fl6->flowlabel^*(__be32 *)CMSG_DATA(cmsg))&~IPV6_FLOWINFO_MASK) {
  714. err = -EINVAL;
  715. goto exit_f;
  716. }
  717. }
  718. fl6->flowlabel = IPV6_FLOWINFO_MASK & *(__be32 *)CMSG_DATA(cmsg);
  719. break;
  720. case IPV6_2292HOPOPTS:
  721. case IPV6_HOPOPTS:
  722. if (opt->hopopt || cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
  723. err = -EINVAL;
  724. goto exit_f;
  725. }
  726. hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
  727. len = ((hdr->hdrlen + 1) << 3);
  728. if (cmsg->cmsg_len < CMSG_LEN(len)) {
  729. err = -EINVAL;
  730. goto exit_f;
  731. }
  732. if (!ns_capable(net->user_ns, CAP_NET_RAW)) {
  733. err = -EPERM;
  734. goto exit_f;
  735. }
  736. opt->opt_nflen += len;
  737. opt->hopopt = hdr;
  738. break;
  739. case IPV6_2292DSTOPTS:
  740. if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
  741. err = -EINVAL;
  742. goto exit_f;
  743. }
  744. hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
  745. len = ((hdr->hdrlen + 1) << 3);
  746. if (cmsg->cmsg_len < CMSG_LEN(len)) {
  747. err = -EINVAL;
  748. goto exit_f;
  749. }
  750. if (!ns_capable(net->user_ns, CAP_NET_RAW)) {
  751. err = -EPERM;
  752. goto exit_f;
  753. }
  754. if (opt->dst1opt) {
  755. err = -EINVAL;
  756. goto exit_f;
  757. }
  758. opt->opt_flen += len;
  759. opt->dst1opt = hdr;
  760. break;
  761. case IPV6_DSTOPTS:
  762. case IPV6_RTHDRDSTOPTS:
  763. if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
  764. err = -EINVAL;
  765. goto exit_f;
  766. }
  767. hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
  768. len = ((hdr->hdrlen + 1) << 3);
  769. if (cmsg->cmsg_len < CMSG_LEN(len)) {
  770. err = -EINVAL;
  771. goto exit_f;
  772. }
  773. if (!ns_capable(net->user_ns, CAP_NET_RAW)) {
  774. err = -EPERM;
  775. goto exit_f;
  776. }
  777. if (cmsg->cmsg_type == IPV6_DSTOPTS) {
  778. opt->opt_flen += len;
  779. opt->dst1opt = hdr;
  780. } else {
  781. opt->opt_nflen += len;
  782. opt->dst0opt = hdr;
  783. }
  784. break;
  785. case IPV6_2292RTHDR:
  786. case IPV6_RTHDR:
  787. if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_rt_hdr))) {
  788. err = -EINVAL;
  789. goto exit_f;
  790. }
  791. rthdr = (struct ipv6_rt_hdr *)CMSG_DATA(cmsg);
  792. switch (rthdr->type) {
  793. #if IS_ENABLED(CONFIG_IPV6_MIP6)
  794. case IPV6_SRCRT_TYPE_2:
  795. if (rthdr->hdrlen != 2 ||
  796. rthdr->segments_left != 1) {
  797. err = -EINVAL;
  798. goto exit_f;
  799. }
  800. break;
  801. #endif
  802. default:
  803. err = -EINVAL;
  804. goto exit_f;
  805. }
  806. len = ((rthdr->hdrlen + 1) << 3);
  807. if (cmsg->cmsg_len < CMSG_LEN(len)) {
  808. err = -EINVAL;
  809. goto exit_f;
  810. }
  811. /* segments left must also match */
  812. if ((rthdr->hdrlen >> 1) != rthdr->segments_left) {
  813. err = -EINVAL;
  814. goto exit_f;
  815. }
  816. opt->opt_nflen += len;
  817. opt->srcrt = rthdr;
  818. if (cmsg->cmsg_type == IPV6_2292RTHDR && opt->dst1opt) {
  819. int dsthdrlen = ((opt->dst1opt->hdrlen+1)<<3);
  820. opt->opt_nflen += dsthdrlen;
  821. opt->dst0opt = opt->dst1opt;
  822. opt->dst1opt = NULL;
  823. opt->opt_flen -= dsthdrlen;
  824. }
  825. break;
  826. case IPV6_2292HOPLIMIT:
  827. case IPV6_HOPLIMIT:
  828. if (cmsg->cmsg_len != CMSG_LEN(sizeof(int))) {
  829. err = -EINVAL;
  830. goto exit_f;
  831. }
  832. ipc6->hlimit = *(int *)CMSG_DATA(cmsg);
  833. if (ipc6->hlimit < -1 || ipc6->hlimit > 0xff) {
  834. err = -EINVAL;
  835. goto exit_f;
  836. }
  837. break;
  838. case IPV6_TCLASS:
  839. {
  840. int tc;
  841. err = -EINVAL;
  842. if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)))
  843. goto exit_f;
  844. tc = *(int *)CMSG_DATA(cmsg);
  845. if (tc < -1 || tc > 0xff)
  846. goto exit_f;
  847. err = 0;
  848. ipc6->tclass = tc;
  849. break;
  850. }
  851. case IPV6_DONTFRAG:
  852. {
  853. int df;
  854. err = -EINVAL;
  855. if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)))
  856. goto exit_f;
  857. df = *(int *)CMSG_DATA(cmsg);
  858. if (df < 0 || df > 1)
  859. goto exit_f;
  860. err = 0;
  861. ipc6->dontfrag = df;
  862. break;
  863. }
  864. default:
  865. net_dbg_ratelimited("invalid cmsg type: %d\n",
  866. cmsg->cmsg_type);
  867. err = -EINVAL;
  868. goto exit_f;
  869. }
  870. }
  871. exit_f:
  872. return err;
  873. }
  874. EXPORT_SYMBOL_GPL(ip6_datagram_send_ctl);
  875. void __ip6_dgram_sock_seq_show(struct seq_file *seq, struct sock *sp,
  876. __u16 srcp, __u16 destp, int rqueue, int bucket)
  877. {
  878. const struct in6_addr *dest, *src;
  879. dest = &sp->sk_v6_daddr;
  880. src = &sp->sk_v6_rcv_saddr;
  881. seq_printf(seq,
  882. "%5d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
  883. "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %u\n",
  884. bucket,
  885. src->s6_addr32[0], src->s6_addr32[1],
  886. src->s6_addr32[2], src->s6_addr32[3], srcp,
  887. dest->s6_addr32[0], dest->s6_addr32[1],
  888. dest->s6_addr32[2], dest->s6_addr32[3], destp,
  889. sp->sk_state,
  890. sk_wmem_alloc_get(sp),
  891. rqueue,
  892. 0, 0L, 0,
  893. from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
  894. 0,
  895. sock_i_ino(sp),
  896. refcount_read(&sp->sk_refcnt), sp,
  897. atomic_read(&sp->sk_drops));
  898. }