ipv6_sockglue.c 32 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * IPv6 BSD socket options interface
  4. * Linux INET6 implementation
  5. *
  6. * Authors:
  7. * Pedro Roque <roque@di.fc.ul.pt>
  8. *
  9. * Based on linux/net/ipv4/ip_sockglue.c
  10. *
  11. * FIXME: Make the setsockopt code POSIX compliant: That is
  12. *
  13. * o Truncate getsockopt returns
  14. * o Return an optlen of the truncated length if need be
  15. *
  16. * Changes:
  17. * David L Stevens <dlstevens@us.ibm.com>:
  18. * - added multicast source filtering API for MLDv2
  19. */
  20. #include <linux/module.h>
  21. #include <linux/capability.h>
  22. #include <linux/errno.h>
  23. #include <linux/types.h>
  24. #include <linux/socket.h>
  25. #include <linux/sockios.h>
  26. #include <linux/net.h>
  27. #include <linux/in6.h>
  28. #include <linux/mroute6.h>
  29. #include <linux/netdevice.h>
  30. #include <linux/if_arp.h>
  31. #include <linux/init.h>
  32. #include <linux/sysctl.h>
  33. #include <linux/netfilter.h>
  34. #include <linux/slab.h>
  35. #include <net/sock.h>
  36. #include <net/snmp.h>
  37. #include <net/ipv6.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/addrconf.h>
  43. #include <net/inet_common.h>
  44. #include <net/tcp.h>
  45. #include <net/udp.h>
  46. #include <net/udplite.h>
  47. #include <net/xfrm.h>
  48. #include <net/compat.h>
  49. #include <net/seg6.h>
  50. #include <linux/uaccess.h>
  51. struct ip6_ra_chain *ip6_ra_chain;
  52. DEFINE_RWLOCK(ip6_ra_lock);
  53. int ip6_ra_control(struct sock *sk, int sel)
  54. {
  55. struct ip6_ra_chain *ra, *new_ra, **rap;
  56. /* RA packet may be delivered ONLY to IPPROTO_RAW socket */
  57. if (sk->sk_type != SOCK_RAW || inet_sk(sk)->inet_num != IPPROTO_RAW)
  58. return -ENOPROTOOPT;
  59. new_ra = (sel >= 0) ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
  60. if (sel >= 0 && !new_ra)
  61. return -ENOMEM;
  62. write_lock_bh(&ip6_ra_lock);
  63. for (rap = &ip6_ra_chain; (ra = *rap) != NULL; rap = &ra->next) {
  64. if (ra->sk == sk) {
  65. if (sel >= 0) {
  66. write_unlock_bh(&ip6_ra_lock);
  67. kfree(new_ra);
  68. return -EADDRINUSE;
  69. }
  70. *rap = ra->next;
  71. write_unlock_bh(&ip6_ra_lock);
  72. sock_put(sk);
  73. kfree(ra);
  74. return 0;
  75. }
  76. }
  77. if (!new_ra) {
  78. write_unlock_bh(&ip6_ra_lock);
  79. return -ENOBUFS;
  80. }
  81. new_ra->sk = sk;
  82. new_ra->sel = sel;
  83. new_ra->next = ra;
  84. *rap = new_ra;
  85. sock_hold(sk);
  86. write_unlock_bh(&ip6_ra_lock);
  87. return 0;
  88. }
  89. struct ipv6_txoptions *ipv6_update_options(struct sock *sk,
  90. struct ipv6_txoptions *opt)
  91. {
  92. if (inet_sk(sk)->is_icsk) {
  93. if (opt &&
  94. !((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE)) &&
  95. inet_sk(sk)->inet_daddr != LOOPBACK4_IPV6) {
  96. struct inet_connection_sock *icsk = inet_csk(sk);
  97. icsk->icsk_ext_hdr_len = opt->opt_flen + opt->opt_nflen;
  98. icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie);
  99. }
  100. }
  101. opt = xchg((__force struct ipv6_txoptions **)&inet6_sk(sk)->opt,
  102. opt);
  103. sk_dst_reset(sk);
  104. return opt;
  105. }
  106. static bool setsockopt_needs_rtnl(int optname)
  107. {
  108. switch (optname) {
  109. case IPV6_ADDRFORM:
  110. case IPV6_ADD_MEMBERSHIP:
  111. case IPV6_DROP_MEMBERSHIP:
  112. case IPV6_JOIN_ANYCAST:
  113. case IPV6_LEAVE_ANYCAST:
  114. case MCAST_JOIN_GROUP:
  115. case MCAST_LEAVE_GROUP:
  116. case MCAST_JOIN_SOURCE_GROUP:
  117. case MCAST_LEAVE_SOURCE_GROUP:
  118. case MCAST_BLOCK_SOURCE:
  119. case MCAST_UNBLOCK_SOURCE:
  120. case MCAST_MSFILTER:
  121. return true;
  122. }
  123. return false;
  124. }
  125. static int copy_group_source_from_sockptr(struct group_source_req *greqs,
  126. sockptr_t optval, int optlen)
  127. {
  128. if (in_compat_syscall()) {
  129. struct compat_group_source_req gr32;
  130. if (optlen < sizeof(gr32))
  131. return -EINVAL;
  132. if (copy_from_sockptr(&gr32, optval, sizeof(gr32)))
  133. return -EFAULT;
  134. greqs->gsr_interface = gr32.gsr_interface;
  135. greqs->gsr_group = gr32.gsr_group;
  136. greqs->gsr_source = gr32.gsr_source;
  137. } else {
  138. if (optlen < sizeof(*greqs))
  139. return -EINVAL;
  140. if (copy_from_sockptr(greqs, optval, sizeof(*greqs)))
  141. return -EFAULT;
  142. }
  143. return 0;
  144. }
  145. static int do_ipv6_mcast_group_source(struct sock *sk, int optname,
  146. sockptr_t optval, int optlen)
  147. {
  148. struct group_source_req greqs;
  149. int omode, add;
  150. int ret;
  151. ret = copy_group_source_from_sockptr(&greqs, optval, optlen);
  152. if (ret)
  153. return ret;
  154. if (greqs.gsr_group.ss_family != AF_INET6 ||
  155. greqs.gsr_source.ss_family != AF_INET6)
  156. return -EADDRNOTAVAIL;
  157. if (optname == MCAST_BLOCK_SOURCE) {
  158. omode = MCAST_EXCLUDE;
  159. add = 1;
  160. } else if (optname == MCAST_UNBLOCK_SOURCE) {
  161. omode = MCAST_EXCLUDE;
  162. add = 0;
  163. } else if (optname == MCAST_JOIN_SOURCE_GROUP) {
  164. struct sockaddr_in6 *psin6;
  165. int retv;
  166. psin6 = (struct sockaddr_in6 *)&greqs.gsr_group;
  167. retv = ipv6_sock_mc_join_ssm(sk, greqs.gsr_interface,
  168. &psin6->sin6_addr,
  169. MCAST_INCLUDE);
  170. /* prior join w/ different source is ok */
  171. if (retv && retv != -EADDRINUSE)
  172. return retv;
  173. omode = MCAST_INCLUDE;
  174. add = 1;
  175. } else /* MCAST_LEAVE_SOURCE_GROUP */ {
  176. omode = MCAST_INCLUDE;
  177. add = 0;
  178. }
  179. return ip6_mc_source(add, omode, sk, &greqs);
  180. }
  181. static int ipv6_set_mcast_msfilter(struct sock *sk, sockptr_t optval,
  182. int optlen)
  183. {
  184. struct group_filter *gsf;
  185. int ret;
  186. if (optlen < GROUP_FILTER_SIZE(0))
  187. return -EINVAL;
  188. if (optlen > sysctl_optmem_max)
  189. return -ENOBUFS;
  190. gsf = memdup_sockptr(optval, optlen);
  191. if (IS_ERR(gsf))
  192. return PTR_ERR(gsf);
  193. /* numsrc >= (4G-140)/128 overflow in 32 bits */
  194. ret = -ENOBUFS;
  195. if (gsf->gf_numsrc >= 0x1ffffffU ||
  196. gsf->gf_numsrc > sysctl_mld_max_msf)
  197. goto out_free_gsf;
  198. ret = -EINVAL;
  199. if (GROUP_FILTER_SIZE(gsf->gf_numsrc) > optlen)
  200. goto out_free_gsf;
  201. ret = ip6_mc_msfilter(sk, gsf, gsf->gf_slist);
  202. out_free_gsf:
  203. kfree(gsf);
  204. return ret;
  205. }
  206. static int compat_ipv6_set_mcast_msfilter(struct sock *sk, sockptr_t optval,
  207. int optlen)
  208. {
  209. const int size0 = offsetof(struct compat_group_filter, gf_slist);
  210. struct compat_group_filter *gf32;
  211. void *p;
  212. int ret;
  213. int n;
  214. if (optlen < size0)
  215. return -EINVAL;
  216. if (optlen > sysctl_optmem_max - 4)
  217. return -ENOBUFS;
  218. p = kmalloc(optlen + 4, GFP_KERNEL);
  219. if (!p)
  220. return -ENOMEM;
  221. gf32 = p + 4; /* we want ->gf_group and ->gf_slist aligned */
  222. ret = -EFAULT;
  223. if (copy_from_sockptr(gf32, optval, optlen))
  224. goto out_free_p;
  225. /* numsrc >= (4G-140)/128 overflow in 32 bits */
  226. ret = -ENOBUFS;
  227. n = gf32->gf_numsrc;
  228. if (n >= 0x1ffffffU || n > sysctl_mld_max_msf)
  229. goto out_free_p;
  230. ret = -EINVAL;
  231. if (offsetof(struct compat_group_filter, gf_slist[n]) > optlen)
  232. goto out_free_p;
  233. ret = ip6_mc_msfilter(sk, &(struct group_filter){
  234. .gf_interface = gf32->gf_interface,
  235. .gf_group = gf32->gf_group,
  236. .gf_fmode = gf32->gf_fmode,
  237. .gf_numsrc = gf32->gf_numsrc}, gf32->gf_slist);
  238. out_free_p:
  239. kfree(p);
  240. return ret;
  241. }
  242. static int ipv6_mcast_join_leave(struct sock *sk, int optname,
  243. sockptr_t optval, int optlen)
  244. {
  245. struct sockaddr_in6 *psin6;
  246. struct group_req greq;
  247. if (optlen < sizeof(greq))
  248. return -EINVAL;
  249. if (copy_from_sockptr(&greq, optval, sizeof(greq)))
  250. return -EFAULT;
  251. if (greq.gr_group.ss_family != AF_INET6)
  252. return -EADDRNOTAVAIL;
  253. psin6 = (struct sockaddr_in6 *)&greq.gr_group;
  254. if (optname == MCAST_JOIN_GROUP)
  255. return ipv6_sock_mc_join(sk, greq.gr_interface,
  256. &psin6->sin6_addr);
  257. return ipv6_sock_mc_drop(sk, greq.gr_interface, &psin6->sin6_addr);
  258. }
  259. static int compat_ipv6_mcast_join_leave(struct sock *sk, int optname,
  260. sockptr_t optval, int optlen)
  261. {
  262. struct compat_group_req gr32;
  263. struct sockaddr_in6 *psin6;
  264. if (optlen < sizeof(gr32))
  265. return -EINVAL;
  266. if (copy_from_sockptr(&gr32, optval, sizeof(gr32)))
  267. return -EFAULT;
  268. if (gr32.gr_group.ss_family != AF_INET6)
  269. return -EADDRNOTAVAIL;
  270. psin6 = (struct sockaddr_in6 *)&gr32.gr_group;
  271. if (optname == MCAST_JOIN_GROUP)
  272. return ipv6_sock_mc_join(sk, gr32.gr_interface,
  273. &psin6->sin6_addr);
  274. return ipv6_sock_mc_drop(sk, gr32.gr_interface, &psin6->sin6_addr);
  275. }
  276. static int ipv6_set_opt_hdr(struct sock *sk, int optname, sockptr_t optval,
  277. int optlen)
  278. {
  279. struct ipv6_pinfo *np = inet6_sk(sk);
  280. struct ipv6_opt_hdr *new = NULL;
  281. struct net *net = sock_net(sk);
  282. struct ipv6_txoptions *opt;
  283. int err;
  284. /* hop-by-hop / destination options are privileged option */
  285. if (optname != IPV6_RTHDR && !ns_capable(net->user_ns, CAP_NET_RAW))
  286. return -EPERM;
  287. /* remove any sticky options header with a zero option
  288. * length, per RFC3542.
  289. */
  290. if (optlen > 0) {
  291. if (sockptr_is_null(optval))
  292. return -EINVAL;
  293. if (optlen < sizeof(struct ipv6_opt_hdr) ||
  294. optlen & 0x7 ||
  295. optlen > 8 * 255)
  296. return -EINVAL;
  297. new = memdup_sockptr(optval, optlen);
  298. if (IS_ERR(new))
  299. return PTR_ERR(new);
  300. if (unlikely(ipv6_optlen(new) > optlen)) {
  301. kfree(new);
  302. return -EINVAL;
  303. }
  304. }
  305. opt = rcu_dereference_protected(np->opt, lockdep_sock_is_held(sk));
  306. opt = ipv6_renew_options(sk, opt, optname, new);
  307. kfree(new);
  308. if (IS_ERR(opt))
  309. return PTR_ERR(opt);
  310. /* routing header option needs extra check */
  311. err = -EINVAL;
  312. if (optname == IPV6_RTHDR && opt && opt->srcrt) {
  313. struct ipv6_rt_hdr *rthdr = opt->srcrt;
  314. switch (rthdr->type) {
  315. #if IS_ENABLED(CONFIG_IPV6_MIP6)
  316. case IPV6_SRCRT_TYPE_2:
  317. if (rthdr->hdrlen != 2 || rthdr->segments_left != 1)
  318. goto sticky_done;
  319. break;
  320. #endif
  321. case IPV6_SRCRT_TYPE_4:
  322. {
  323. struct ipv6_sr_hdr *srh =
  324. (struct ipv6_sr_hdr *)opt->srcrt;
  325. if (!seg6_validate_srh(srh, optlen, false))
  326. goto sticky_done;
  327. break;
  328. }
  329. default:
  330. goto sticky_done;
  331. }
  332. }
  333. err = 0;
  334. opt = ipv6_update_options(sk, opt);
  335. sticky_done:
  336. if (opt) {
  337. atomic_sub(opt->tot_len, &sk->sk_omem_alloc);
  338. txopt_put(opt);
  339. }
  340. return err;
  341. }
  342. static int do_ipv6_setsockopt(struct sock *sk, int level, int optname,
  343. sockptr_t optval, unsigned int optlen)
  344. {
  345. struct ipv6_pinfo *np = inet6_sk(sk);
  346. struct net *net = sock_net(sk);
  347. int val, valbool;
  348. int retv = -ENOPROTOOPT;
  349. bool needs_rtnl = setsockopt_needs_rtnl(optname);
  350. if (sockptr_is_null(optval))
  351. val = 0;
  352. else {
  353. if (optlen >= sizeof(int)) {
  354. if (copy_from_sockptr(&val, optval, sizeof(val)))
  355. return -EFAULT;
  356. } else
  357. val = 0;
  358. }
  359. valbool = (val != 0);
  360. if (ip6_mroute_opt(optname))
  361. return ip6_mroute_setsockopt(sk, optname, optval, optlen);
  362. if (needs_rtnl)
  363. rtnl_lock();
  364. lock_sock(sk);
  365. switch (optname) {
  366. case IPV6_ADDRFORM:
  367. if (optlen < sizeof(int))
  368. goto e_inval;
  369. if (val == PF_INET) {
  370. struct ipv6_txoptions *opt;
  371. struct sk_buff *pktopt;
  372. if (sk->sk_type == SOCK_RAW)
  373. break;
  374. if (sk->sk_protocol == IPPROTO_UDP ||
  375. sk->sk_protocol == IPPROTO_UDPLITE) {
  376. struct udp_sock *up = udp_sk(sk);
  377. if (up->pending == AF_INET6) {
  378. retv = -EBUSY;
  379. break;
  380. }
  381. } else if (sk->sk_protocol == IPPROTO_TCP) {
  382. if (sk->sk_prot != &tcpv6_prot) {
  383. retv = -EBUSY;
  384. break;
  385. }
  386. } else {
  387. break;
  388. }
  389. if (sk->sk_state != TCP_ESTABLISHED) {
  390. retv = -ENOTCONN;
  391. break;
  392. }
  393. if (ipv6_only_sock(sk) ||
  394. !ipv6_addr_v4mapped(&sk->sk_v6_daddr)) {
  395. retv = -EADDRNOTAVAIL;
  396. break;
  397. }
  398. fl6_free_socklist(sk);
  399. __ipv6_sock_mc_close(sk);
  400. __ipv6_sock_ac_close(sk);
  401. /*
  402. * Sock is moving from IPv6 to IPv4 (sk_prot), so
  403. * remove it from the refcnt debug socks count in the
  404. * original family...
  405. */
  406. sk_refcnt_debug_dec(sk);
  407. if (sk->sk_protocol == IPPROTO_TCP) {
  408. struct inet_connection_sock *icsk = inet_csk(sk);
  409. local_bh_disable();
  410. sock_prot_inuse_add(net, sk->sk_prot, -1);
  411. sock_prot_inuse_add(net, &tcp_prot, 1);
  412. local_bh_enable();
  413. sk->sk_prot = &tcp_prot;
  414. icsk->icsk_af_ops = &ipv4_specific;
  415. sk->sk_socket->ops = &inet_stream_ops;
  416. sk->sk_family = PF_INET;
  417. tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
  418. } else {
  419. struct proto *prot = &udp_prot;
  420. if (sk->sk_protocol == IPPROTO_UDPLITE)
  421. prot = &udplite_prot;
  422. local_bh_disable();
  423. sock_prot_inuse_add(net, sk->sk_prot, -1);
  424. sock_prot_inuse_add(net, prot, 1);
  425. local_bh_enable();
  426. sk->sk_prot = prot;
  427. sk->sk_socket->ops = &inet_dgram_ops;
  428. sk->sk_family = PF_INET;
  429. }
  430. opt = xchg((__force struct ipv6_txoptions **)&np->opt,
  431. NULL);
  432. if (opt) {
  433. atomic_sub(opt->tot_len, &sk->sk_omem_alloc);
  434. txopt_put(opt);
  435. }
  436. pktopt = xchg(&np->pktoptions, NULL);
  437. kfree_skb(pktopt);
  438. /*
  439. * ... and add it to the refcnt debug socks count
  440. * in the new family. -acme
  441. */
  442. sk_refcnt_debug_inc(sk);
  443. module_put(THIS_MODULE);
  444. retv = 0;
  445. break;
  446. }
  447. goto e_inval;
  448. case IPV6_V6ONLY:
  449. if (optlen < sizeof(int) ||
  450. inet_sk(sk)->inet_num)
  451. goto e_inval;
  452. sk->sk_ipv6only = valbool;
  453. retv = 0;
  454. break;
  455. case IPV6_RECVPKTINFO:
  456. if (optlen < sizeof(int))
  457. goto e_inval;
  458. np->rxopt.bits.rxinfo = valbool;
  459. retv = 0;
  460. break;
  461. case IPV6_2292PKTINFO:
  462. if (optlen < sizeof(int))
  463. goto e_inval;
  464. np->rxopt.bits.rxoinfo = valbool;
  465. retv = 0;
  466. break;
  467. case IPV6_RECVHOPLIMIT:
  468. if (optlen < sizeof(int))
  469. goto e_inval;
  470. np->rxopt.bits.rxhlim = valbool;
  471. retv = 0;
  472. break;
  473. case IPV6_2292HOPLIMIT:
  474. if (optlen < sizeof(int))
  475. goto e_inval;
  476. np->rxopt.bits.rxohlim = valbool;
  477. retv = 0;
  478. break;
  479. case IPV6_RECVRTHDR:
  480. if (optlen < sizeof(int))
  481. goto e_inval;
  482. np->rxopt.bits.srcrt = valbool;
  483. retv = 0;
  484. break;
  485. case IPV6_2292RTHDR:
  486. if (optlen < sizeof(int))
  487. goto e_inval;
  488. np->rxopt.bits.osrcrt = valbool;
  489. retv = 0;
  490. break;
  491. case IPV6_RECVHOPOPTS:
  492. if (optlen < sizeof(int))
  493. goto e_inval;
  494. np->rxopt.bits.hopopts = valbool;
  495. retv = 0;
  496. break;
  497. case IPV6_2292HOPOPTS:
  498. if (optlen < sizeof(int))
  499. goto e_inval;
  500. np->rxopt.bits.ohopopts = valbool;
  501. retv = 0;
  502. break;
  503. case IPV6_RECVDSTOPTS:
  504. if (optlen < sizeof(int))
  505. goto e_inval;
  506. np->rxopt.bits.dstopts = valbool;
  507. retv = 0;
  508. break;
  509. case IPV6_2292DSTOPTS:
  510. if (optlen < sizeof(int))
  511. goto e_inval;
  512. np->rxopt.bits.odstopts = valbool;
  513. retv = 0;
  514. break;
  515. case IPV6_TCLASS:
  516. if (optlen < sizeof(int))
  517. goto e_inval;
  518. if (val < -1 || val > 0xff)
  519. goto e_inval;
  520. /* RFC 3542, 6.5: default traffic class of 0x0 */
  521. if (val == -1)
  522. val = 0;
  523. np->tclass = val;
  524. retv = 0;
  525. break;
  526. case IPV6_RECVTCLASS:
  527. if (optlen < sizeof(int))
  528. goto e_inval;
  529. np->rxopt.bits.rxtclass = valbool;
  530. retv = 0;
  531. break;
  532. case IPV6_FLOWINFO:
  533. if (optlen < sizeof(int))
  534. goto e_inval;
  535. np->rxopt.bits.rxflow = valbool;
  536. retv = 0;
  537. break;
  538. case IPV6_RECVPATHMTU:
  539. if (optlen < sizeof(int))
  540. goto e_inval;
  541. np->rxopt.bits.rxpmtu = valbool;
  542. retv = 0;
  543. break;
  544. case IPV6_TRANSPARENT:
  545. if (valbool && !ns_capable(net->user_ns, CAP_NET_RAW) &&
  546. !ns_capable(net->user_ns, CAP_NET_ADMIN)) {
  547. retv = -EPERM;
  548. break;
  549. }
  550. if (optlen < sizeof(int))
  551. goto e_inval;
  552. /* we don't have a separate transparent bit for IPV6 we use the one in the IPv4 socket */
  553. inet_sk(sk)->transparent = valbool;
  554. retv = 0;
  555. break;
  556. case IPV6_FREEBIND:
  557. if (optlen < sizeof(int))
  558. goto e_inval;
  559. /* we also don't have a separate freebind bit for IPV6 */
  560. inet_sk(sk)->freebind = valbool;
  561. retv = 0;
  562. break;
  563. case IPV6_RECVORIGDSTADDR:
  564. if (optlen < sizeof(int))
  565. goto e_inval;
  566. np->rxopt.bits.rxorigdstaddr = valbool;
  567. retv = 0;
  568. break;
  569. case IPV6_HOPOPTS:
  570. case IPV6_RTHDRDSTOPTS:
  571. case IPV6_RTHDR:
  572. case IPV6_DSTOPTS:
  573. retv = ipv6_set_opt_hdr(sk, optname, optval, optlen);
  574. break;
  575. case IPV6_PKTINFO:
  576. {
  577. struct in6_pktinfo pkt;
  578. if (optlen == 0)
  579. goto e_inval;
  580. else if (optlen < sizeof(struct in6_pktinfo) ||
  581. sockptr_is_null(optval))
  582. goto e_inval;
  583. if (copy_from_sockptr(&pkt, optval, sizeof(pkt))) {
  584. retv = -EFAULT;
  585. break;
  586. }
  587. if (!sk_dev_equal_l3scope(sk, pkt.ipi6_ifindex))
  588. goto e_inval;
  589. np->sticky_pktinfo.ipi6_ifindex = pkt.ipi6_ifindex;
  590. np->sticky_pktinfo.ipi6_addr = pkt.ipi6_addr;
  591. retv = 0;
  592. break;
  593. }
  594. case IPV6_2292PKTOPTIONS:
  595. {
  596. struct ipv6_txoptions *opt = NULL;
  597. struct msghdr msg;
  598. struct flowi6 fl6;
  599. struct ipcm6_cookie ipc6;
  600. memset(&fl6, 0, sizeof(fl6));
  601. fl6.flowi6_oif = sk->sk_bound_dev_if;
  602. fl6.flowi6_mark = sk->sk_mark;
  603. if (optlen == 0)
  604. goto update;
  605. /* 1K is probably excessive
  606. * 1K is surely not enough, 2K per standard header is 16K.
  607. */
  608. retv = -EINVAL;
  609. if (optlen > 64*1024)
  610. break;
  611. opt = sock_kmalloc(sk, sizeof(*opt) + optlen, GFP_KERNEL);
  612. retv = -ENOBUFS;
  613. if (!opt)
  614. break;
  615. memset(opt, 0, sizeof(*opt));
  616. refcount_set(&opt->refcnt, 1);
  617. opt->tot_len = sizeof(*opt) + optlen;
  618. retv = -EFAULT;
  619. if (copy_from_sockptr(opt + 1, optval, optlen))
  620. goto done;
  621. msg.msg_controllen = optlen;
  622. msg.msg_control = (void *)(opt+1);
  623. ipc6.opt = opt;
  624. retv = ip6_datagram_send_ctl(net, sk, &msg, &fl6, &ipc6);
  625. if (retv)
  626. goto done;
  627. update:
  628. retv = 0;
  629. opt = ipv6_update_options(sk, opt);
  630. done:
  631. if (opt) {
  632. atomic_sub(opt->tot_len, &sk->sk_omem_alloc);
  633. txopt_put(opt);
  634. }
  635. break;
  636. }
  637. case IPV6_UNICAST_HOPS:
  638. if (optlen < sizeof(int))
  639. goto e_inval;
  640. if (val > 255 || val < -1)
  641. goto e_inval;
  642. np->hop_limit = val;
  643. retv = 0;
  644. break;
  645. case IPV6_MULTICAST_HOPS:
  646. if (sk->sk_type == SOCK_STREAM)
  647. break;
  648. if (optlen < sizeof(int))
  649. goto e_inval;
  650. if (val > 255 || val < -1)
  651. goto e_inval;
  652. np->mcast_hops = (val == -1 ? IPV6_DEFAULT_MCASTHOPS : val);
  653. retv = 0;
  654. break;
  655. case IPV6_MULTICAST_LOOP:
  656. if (optlen < sizeof(int))
  657. goto e_inval;
  658. if (val != valbool)
  659. goto e_inval;
  660. np->mc_loop = valbool;
  661. retv = 0;
  662. break;
  663. case IPV6_UNICAST_IF:
  664. {
  665. struct net_device *dev = NULL;
  666. int ifindex;
  667. if (optlen != sizeof(int))
  668. goto e_inval;
  669. ifindex = (__force int)ntohl((__force __be32)val);
  670. if (ifindex == 0) {
  671. np->ucast_oif = 0;
  672. retv = 0;
  673. break;
  674. }
  675. dev = dev_get_by_index(net, ifindex);
  676. retv = -EADDRNOTAVAIL;
  677. if (!dev)
  678. break;
  679. dev_put(dev);
  680. retv = -EINVAL;
  681. if (sk->sk_bound_dev_if)
  682. break;
  683. np->ucast_oif = ifindex;
  684. retv = 0;
  685. break;
  686. }
  687. case IPV6_MULTICAST_IF:
  688. if (sk->sk_type == SOCK_STREAM)
  689. break;
  690. if (optlen < sizeof(int))
  691. goto e_inval;
  692. if (val) {
  693. struct net_device *dev;
  694. int midx;
  695. rcu_read_lock();
  696. dev = dev_get_by_index_rcu(net, val);
  697. if (!dev) {
  698. rcu_read_unlock();
  699. retv = -ENODEV;
  700. break;
  701. }
  702. midx = l3mdev_master_ifindex_rcu(dev);
  703. rcu_read_unlock();
  704. if (sk->sk_bound_dev_if &&
  705. sk->sk_bound_dev_if != val &&
  706. (!midx || midx != sk->sk_bound_dev_if))
  707. goto e_inval;
  708. }
  709. np->mcast_oif = val;
  710. retv = 0;
  711. break;
  712. case IPV6_ADD_MEMBERSHIP:
  713. case IPV6_DROP_MEMBERSHIP:
  714. {
  715. struct ipv6_mreq mreq;
  716. if (optlen < sizeof(struct ipv6_mreq))
  717. goto e_inval;
  718. retv = -EPROTO;
  719. if (inet_sk(sk)->is_icsk)
  720. break;
  721. retv = -EFAULT;
  722. if (copy_from_sockptr(&mreq, optval, sizeof(struct ipv6_mreq)))
  723. break;
  724. if (optname == IPV6_ADD_MEMBERSHIP)
  725. retv = ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
  726. else
  727. retv = ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
  728. break;
  729. }
  730. case IPV6_JOIN_ANYCAST:
  731. case IPV6_LEAVE_ANYCAST:
  732. {
  733. struct ipv6_mreq mreq;
  734. if (optlen < sizeof(struct ipv6_mreq))
  735. goto e_inval;
  736. retv = -EFAULT;
  737. if (copy_from_sockptr(&mreq, optval, sizeof(struct ipv6_mreq)))
  738. break;
  739. if (optname == IPV6_JOIN_ANYCAST)
  740. retv = ipv6_sock_ac_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr);
  741. else
  742. retv = ipv6_sock_ac_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr);
  743. break;
  744. }
  745. case IPV6_MULTICAST_ALL:
  746. if (optlen < sizeof(int))
  747. goto e_inval;
  748. np->mc_all = valbool;
  749. retv = 0;
  750. break;
  751. case MCAST_JOIN_GROUP:
  752. case MCAST_LEAVE_GROUP:
  753. if (in_compat_syscall())
  754. retv = compat_ipv6_mcast_join_leave(sk, optname, optval,
  755. optlen);
  756. else
  757. retv = ipv6_mcast_join_leave(sk, optname, optval,
  758. optlen);
  759. break;
  760. case MCAST_JOIN_SOURCE_GROUP:
  761. case MCAST_LEAVE_SOURCE_GROUP:
  762. case MCAST_BLOCK_SOURCE:
  763. case MCAST_UNBLOCK_SOURCE:
  764. retv = do_ipv6_mcast_group_source(sk, optname, optval, optlen);
  765. break;
  766. case MCAST_MSFILTER:
  767. if (in_compat_syscall())
  768. retv = compat_ipv6_set_mcast_msfilter(sk, optval,
  769. optlen);
  770. else
  771. retv = ipv6_set_mcast_msfilter(sk, optval, optlen);
  772. break;
  773. case IPV6_ROUTER_ALERT:
  774. if (optlen < sizeof(int))
  775. goto e_inval;
  776. retv = ip6_ra_control(sk, val);
  777. break;
  778. case IPV6_ROUTER_ALERT_ISOLATE:
  779. if (optlen < sizeof(int))
  780. goto e_inval;
  781. np->rtalert_isolate = valbool;
  782. retv = 0;
  783. break;
  784. case IPV6_MTU_DISCOVER:
  785. if (optlen < sizeof(int))
  786. goto e_inval;
  787. if (val < IPV6_PMTUDISC_DONT || val > IPV6_PMTUDISC_OMIT)
  788. goto e_inval;
  789. np->pmtudisc = val;
  790. retv = 0;
  791. break;
  792. case IPV6_MTU:
  793. if (optlen < sizeof(int))
  794. goto e_inval;
  795. if (val && val < IPV6_MIN_MTU)
  796. goto e_inval;
  797. np->frag_size = val;
  798. retv = 0;
  799. break;
  800. case IPV6_RECVERR:
  801. if (optlen < sizeof(int))
  802. goto e_inval;
  803. np->recverr = valbool;
  804. if (!val)
  805. skb_queue_purge(&sk->sk_error_queue);
  806. retv = 0;
  807. break;
  808. case IPV6_FLOWINFO_SEND:
  809. if (optlen < sizeof(int))
  810. goto e_inval;
  811. np->sndflow = valbool;
  812. retv = 0;
  813. break;
  814. case IPV6_FLOWLABEL_MGR:
  815. retv = ipv6_flowlabel_opt(sk, optval, optlen);
  816. break;
  817. case IPV6_IPSEC_POLICY:
  818. case IPV6_XFRM_POLICY:
  819. retv = -EPERM;
  820. if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
  821. break;
  822. retv = xfrm_user_policy(sk, optname, optval, optlen);
  823. break;
  824. case IPV6_ADDR_PREFERENCES:
  825. if (optlen < sizeof(int))
  826. goto e_inval;
  827. retv = __ip6_sock_set_addr_preferences(sk, val);
  828. break;
  829. case IPV6_MINHOPCOUNT:
  830. if (optlen < sizeof(int))
  831. goto e_inval;
  832. if (val < 0 || val > 255)
  833. goto e_inval;
  834. np->min_hopcount = val;
  835. retv = 0;
  836. break;
  837. case IPV6_DONTFRAG:
  838. np->dontfrag = valbool;
  839. retv = 0;
  840. break;
  841. case IPV6_AUTOFLOWLABEL:
  842. np->autoflowlabel = valbool;
  843. np->autoflowlabel_set = 1;
  844. retv = 0;
  845. break;
  846. case IPV6_RECVFRAGSIZE:
  847. np->rxopt.bits.recvfragsize = valbool;
  848. retv = 0;
  849. break;
  850. case IPV6_RECVERR_RFC4884:
  851. if (optlen < sizeof(int))
  852. goto e_inval;
  853. if (val < 0 || val > 1)
  854. goto e_inval;
  855. np->recverr_rfc4884 = valbool;
  856. retv = 0;
  857. break;
  858. }
  859. release_sock(sk);
  860. if (needs_rtnl)
  861. rtnl_unlock();
  862. return retv;
  863. e_inval:
  864. release_sock(sk);
  865. if (needs_rtnl)
  866. rtnl_unlock();
  867. return -EINVAL;
  868. }
  869. int ipv6_setsockopt(struct sock *sk, int level, int optname, sockptr_t optval,
  870. unsigned int optlen)
  871. {
  872. int err;
  873. if (level == SOL_IP && sk->sk_type != SOCK_RAW)
  874. return udp_prot.setsockopt(sk, level, optname, optval, optlen);
  875. if (level != SOL_IPV6)
  876. return -ENOPROTOOPT;
  877. err = do_ipv6_setsockopt(sk, level, optname, optval, optlen);
  878. #ifdef CONFIG_NETFILTER
  879. /* we need to exclude all possible ENOPROTOOPTs except default case */
  880. if (err == -ENOPROTOOPT && optname != IPV6_IPSEC_POLICY &&
  881. optname != IPV6_XFRM_POLICY)
  882. err = nf_setsockopt(sk, PF_INET6, optname, optval, optlen);
  883. #endif
  884. return err;
  885. }
  886. EXPORT_SYMBOL(ipv6_setsockopt);
  887. static int ipv6_getsockopt_sticky(struct sock *sk, struct ipv6_txoptions *opt,
  888. int optname, char __user *optval, int len)
  889. {
  890. struct ipv6_opt_hdr *hdr;
  891. if (!opt)
  892. return 0;
  893. switch (optname) {
  894. case IPV6_HOPOPTS:
  895. hdr = opt->hopopt;
  896. break;
  897. case IPV6_RTHDRDSTOPTS:
  898. hdr = opt->dst0opt;
  899. break;
  900. case IPV6_RTHDR:
  901. hdr = (struct ipv6_opt_hdr *)opt->srcrt;
  902. break;
  903. case IPV6_DSTOPTS:
  904. hdr = opt->dst1opt;
  905. break;
  906. default:
  907. return -EINVAL; /* should not happen */
  908. }
  909. if (!hdr)
  910. return 0;
  911. len = min_t(unsigned int, len, ipv6_optlen(hdr));
  912. if (copy_to_user(optval, hdr, len))
  913. return -EFAULT;
  914. return len;
  915. }
  916. static int ipv6_get_msfilter(struct sock *sk, void __user *optval,
  917. int __user *optlen, int len)
  918. {
  919. const int size0 = offsetof(struct group_filter, gf_slist);
  920. struct group_filter __user *p = optval;
  921. struct group_filter gsf;
  922. int num;
  923. int err;
  924. if (len < size0)
  925. return -EINVAL;
  926. if (copy_from_user(&gsf, p, size0))
  927. return -EFAULT;
  928. if (gsf.gf_group.ss_family != AF_INET6)
  929. return -EADDRNOTAVAIL;
  930. num = gsf.gf_numsrc;
  931. lock_sock(sk);
  932. err = ip6_mc_msfget(sk, &gsf, p->gf_slist);
  933. if (!err) {
  934. if (num > gsf.gf_numsrc)
  935. num = gsf.gf_numsrc;
  936. if (put_user(GROUP_FILTER_SIZE(num), optlen) ||
  937. copy_to_user(p, &gsf, size0))
  938. err = -EFAULT;
  939. }
  940. release_sock(sk);
  941. return err;
  942. }
  943. static int compat_ipv6_get_msfilter(struct sock *sk, void __user *optval,
  944. int __user *optlen)
  945. {
  946. const int size0 = offsetof(struct compat_group_filter, gf_slist);
  947. struct compat_group_filter __user *p = optval;
  948. struct compat_group_filter gf32;
  949. struct group_filter gf;
  950. int len, err;
  951. int num;
  952. if (get_user(len, optlen))
  953. return -EFAULT;
  954. if (len < size0)
  955. return -EINVAL;
  956. if (copy_from_user(&gf32, p, size0))
  957. return -EFAULT;
  958. gf.gf_interface = gf32.gf_interface;
  959. gf.gf_fmode = gf32.gf_fmode;
  960. num = gf.gf_numsrc = gf32.gf_numsrc;
  961. gf.gf_group = gf32.gf_group;
  962. if (gf.gf_group.ss_family != AF_INET6)
  963. return -EADDRNOTAVAIL;
  964. lock_sock(sk);
  965. err = ip6_mc_msfget(sk, &gf, p->gf_slist);
  966. release_sock(sk);
  967. if (err)
  968. return err;
  969. if (num > gf.gf_numsrc)
  970. num = gf.gf_numsrc;
  971. len = GROUP_FILTER_SIZE(num) - (sizeof(gf)-sizeof(gf32));
  972. if (put_user(len, optlen) ||
  973. put_user(gf.gf_fmode, &p->gf_fmode) ||
  974. put_user(gf.gf_numsrc, &p->gf_numsrc))
  975. return -EFAULT;
  976. return 0;
  977. }
  978. static int do_ipv6_getsockopt(struct sock *sk, int level, int optname,
  979. char __user *optval, int __user *optlen, unsigned int flags)
  980. {
  981. struct ipv6_pinfo *np = inet6_sk(sk);
  982. int len;
  983. int val;
  984. if (ip6_mroute_opt(optname))
  985. return ip6_mroute_getsockopt(sk, optname, optval, optlen);
  986. if (get_user(len, optlen))
  987. return -EFAULT;
  988. switch (optname) {
  989. case IPV6_ADDRFORM:
  990. if (sk->sk_protocol != IPPROTO_UDP &&
  991. sk->sk_protocol != IPPROTO_UDPLITE &&
  992. sk->sk_protocol != IPPROTO_TCP)
  993. return -ENOPROTOOPT;
  994. if (sk->sk_state != TCP_ESTABLISHED)
  995. return -ENOTCONN;
  996. val = sk->sk_family;
  997. break;
  998. case MCAST_MSFILTER:
  999. if (in_compat_syscall())
  1000. return compat_ipv6_get_msfilter(sk, optval, optlen);
  1001. return ipv6_get_msfilter(sk, optval, optlen, len);
  1002. case IPV6_2292PKTOPTIONS:
  1003. {
  1004. struct msghdr msg;
  1005. struct sk_buff *skb;
  1006. if (sk->sk_type != SOCK_STREAM)
  1007. return -ENOPROTOOPT;
  1008. msg.msg_control = optval;
  1009. msg.msg_controllen = len;
  1010. msg.msg_flags = flags;
  1011. msg.msg_control_is_user = true;
  1012. lock_sock(sk);
  1013. skb = np->pktoptions;
  1014. if (skb)
  1015. ip6_datagram_recv_ctl(sk, &msg, skb);
  1016. release_sock(sk);
  1017. if (!skb) {
  1018. if (np->rxopt.bits.rxinfo) {
  1019. struct in6_pktinfo src_info;
  1020. src_info.ipi6_ifindex = np->mcast_oif ? np->mcast_oif :
  1021. np->sticky_pktinfo.ipi6_ifindex;
  1022. src_info.ipi6_addr = np->mcast_oif ? sk->sk_v6_daddr : np->sticky_pktinfo.ipi6_addr;
  1023. put_cmsg(&msg, SOL_IPV6, IPV6_PKTINFO, sizeof(src_info), &src_info);
  1024. }
  1025. if (np->rxopt.bits.rxhlim) {
  1026. int hlim = np->mcast_hops;
  1027. put_cmsg(&msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);
  1028. }
  1029. if (np->rxopt.bits.rxtclass) {
  1030. int tclass = (int)ip6_tclass(np->rcv_flowinfo);
  1031. put_cmsg(&msg, SOL_IPV6, IPV6_TCLASS, sizeof(tclass), &tclass);
  1032. }
  1033. if (np->rxopt.bits.rxoinfo) {
  1034. struct in6_pktinfo src_info;
  1035. src_info.ipi6_ifindex = np->mcast_oif ? np->mcast_oif :
  1036. np->sticky_pktinfo.ipi6_ifindex;
  1037. src_info.ipi6_addr = np->mcast_oif ? sk->sk_v6_daddr :
  1038. np->sticky_pktinfo.ipi6_addr;
  1039. put_cmsg(&msg, SOL_IPV6, IPV6_2292PKTINFO, sizeof(src_info), &src_info);
  1040. }
  1041. if (np->rxopt.bits.rxohlim) {
  1042. int hlim = np->mcast_hops;
  1043. put_cmsg(&msg, SOL_IPV6, IPV6_2292HOPLIMIT, sizeof(hlim), &hlim);
  1044. }
  1045. if (np->rxopt.bits.rxflow) {
  1046. __be32 flowinfo = np->rcv_flowinfo;
  1047. put_cmsg(&msg, SOL_IPV6, IPV6_FLOWINFO, sizeof(flowinfo), &flowinfo);
  1048. }
  1049. }
  1050. len -= msg.msg_controllen;
  1051. return put_user(len, optlen);
  1052. }
  1053. case IPV6_MTU:
  1054. {
  1055. struct dst_entry *dst;
  1056. val = 0;
  1057. rcu_read_lock();
  1058. dst = __sk_dst_get(sk);
  1059. if (dst)
  1060. val = dst_mtu(dst);
  1061. rcu_read_unlock();
  1062. if (!val)
  1063. return -ENOTCONN;
  1064. break;
  1065. }
  1066. case IPV6_V6ONLY:
  1067. val = sk->sk_ipv6only;
  1068. break;
  1069. case IPV6_RECVPKTINFO:
  1070. val = np->rxopt.bits.rxinfo;
  1071. break;
  1072. case IPV6_2292PKTINFO:
  1073. val = np->rxopt.bits.rxoinfo;
  1074. break;
  1075. case IPV6_RECVHOPLIMIT:
  1076. val = np->rxopt.bits.rxhlim;
  1077. break;
  1078. case IPV6_2292HOPLIMIT:
  1079. val = np->rxopt.bits.rxohlim;
  1080. break;
  1081. case IPV6_RECVRTHDR:
  1082. val = np->rxopt.bits.srcrt;
  1083. break;
  1084. case IPV6_2292RTHDR:
  1085. val = np->rxopt.bits.osrcrt;
  1086. break;
  1087. case IPV6_HOPOPTS:
  1088. case IPV6_RTHDRDSTOPTS:
  1089. case IPV6_RTHDR:
  1090. case IPV6_DSTOPTS:
  1091. {
  1092. struct ipv6_txoptions *opt;
  1093. lock_sock(sk);
  1094. opt = rcu_dereference_protected(np->opt,
  1095. lockdep_sock_is_held(sk));
  1096. len = ipv6_getsockopt_sticky(sk, opt, optname, optval, len);
  1097. release_sock(sk);
  1098. /* check if ipv6_getsockopt_sticky() returns err code */
  1099. if (len < 0)
  1100. return len;
  1101. return put_user(len, optlen);
  1102. }
  1103. case IPV6_RECVHOPOPTS:
  1104. val = np->rxopt.bits.hopopts;
  1105. break;
  1106. case IPV6_2292HOPOPTS:
  1107. val = np->rxopt.bits.ohopopts;
  1108. break;
  1109. case IPV6_RECVDSTOPTS:
  1110. val = np->rxopt.bits.dstopts;
  1111. break;
  1112. case IPV6_2292DSTOPTS:
  1113. val = np->rxopt.bits.odstopts;
  1114. break;
  1115. case IPV6_TCLASS:
  1116. val = np->tclass;
  1117. break;
  1118. case IPV6_RECVTCLASS:
  1119. val = np->rxopt.bits.rxtclass;
  1120. break;
  1121. case IPV6_FLOWINFO:
  1122. val = np->rxopt.bits.rxflow;
  1123. break;
  1124. case IPV6_RECVPATHMTU:
  1125. val = np->rxopt.bits.rxpmtu;
  1126. break;
  1127. case IPV6_PATHMTU:
  1128. {
  1129. struct dst_entry *dst;
  1130. struct ip6_mtuinfo mtuinfo;
  1131. if (len < sizeof(mtuinfo))
  1132. return -EINVAL;
  1133. len = sizeof(mtuinfo);
  1134. memset(&mtuinfo, 0, sizeof(mtuinfo));
  1135. rcu_read_lock();
  1136. dst = __sk_dst_get(sk);
  1137. if (dst)
  1138. mtuinfo.ip6m_mtu = dst_mtu(dst);
  1139. rcu_read_unlock();
  1140. if (!mtuinfo.ip6m_mtu)
  1141. return -ENOTCONN;
  1142. if (put_user(len, optlen))
  1143. return -EFAULT;
  1144. if (copy_to_user(optval, &mtuinfo, len))
  1145. return -EFAULT;
  1146. return 0;
  1147. }
  1148. case IPV6_TRANSPARENT:
  1149. val = inet_sk(sk)->transparent;
  1150. break;
  1151. case IPV6_FREEBIND:
  1152. val = inet_sk(sk)->freebind;
  1153. break;
  1154. case IPV6_RECVORIGDSTADDR:
  1155. val = np->rxopt.bits.rxorigdstaddr;
  1156. break;
  1157. case IPV6_UNICAST_HOPS:
  1158. case IPV6_MULTICAST_HOPS:
  1159. {
  1160. struct dst_entry *dst;
  1161. if (optname == IPV6_UNICAST_HOPS)
  1162. val = np->hop_limit;
  1163. else
  1164. val = np->mcast_hops;
  1165. if (val < 0) {
  1166. rcu_read_lock();
  1167. dst = __sk_dst_get(sk);
  1168. if (dst)
  1169. val = ip6_dst_hoplimit(dst);
  1170. rcu_read_unlock();
  1171. }
  1172. if (val < 0)
  1173. val = sock_net(sk)->ipv6.devconf_all->hop_limit;
  1174. break;
  1175. }
  1176. case IPV6_MULTICAST_LOOP:
  1177. val = np->mc_loop;
  1178. break;
  1179. case IPV6_MULTICAST_IF:
  1180. val = np->mcast_oif;
  1181. break;
  1182. case IPV6_MULTICAST_ALL:
  1183. val = np->mc_all;
  1184. break;
  1185. case IPV6_UNICAST_IF:
  1186. val = (__force int)htonl((__u32) np->ucast_oif);
  1187. break;
  1188. case IPV6_MTU_DISCOVER:
  1189. val = np->pmtudisc;
  1190. break;
  1191. case IPV6_RECVERR:
  1192. val = np->recverr;
  1193. break;
  1194. case IPV6_FLOWINFO_SEND:
  1195. val = np->sndflow;
  1196. break;
  1197. case IPV6_FLOWLABEL_MGR:
  1198. {
  1199. struct in6_flowlabel_req freq;
  1200. int flags;
  1201. if (len < sizeof(freq))
  1202. return -EINVAL;
  1203. if (copy_from_user(&freq, optval, sizeof(freq)))
  1204. return -EFAULT;
  1205. if (freq.flr_action != IPV6_FL_A_GET)
  1206. return -EINVAL;
  1207. len = sizeof(freq);
  1208. flags = freq.flr_flags;
  1209. memset(&freq, 0, sizeof(freq));
  1210. val = ipv6_flowlabel_opt_get(sk, &freq, flags);
  1211. if (val < 0)
  1212. return val;
  1213. if (put_user(len, optlen))
  1214. return -EFAULT;
  1215. if (copy_to_user(optval, &freq, len))
  1216. return -EFAULT;
  1217. return 0;
  1218. }
  1219. case IPV6_ADDR_PREFERENCES:
  1220. val = 0;
  1221. if (np->srcprefs & IPV6_PREFER_SRC_TMP)
  1222. val |= IPV6_PREFER_SRC_TMP;
  1223. else if (np->srcprefs & IPV6_PREFER_SRC_PUBLIC)
  1224. val |= IPV6_PREFER_SRC_PUBLIC;
  1225. else {
  1226. /* XXX: should we return system default? */
  1227. val |= IPV6_PREFER_SRC_PUBTMP_DEFAULT;
  1228. }
  1229. if (np->srcprefs & IPV6_PREFER_SRC_COA)
  1230. val |= IPV6_PREFER_SRC_COA;
  1231. else
  1232. val |= IPV6_PREFER_SRC_HOME;
  1233. break;
  1234. case IPV6_MINHOPCOUNT:
  1235. val = np->min_hopcount;
  1236. break;
  1237. case IPV6_DONTFRAG:
  1238. val = np->dontfrag;
  1239. break;
  1240. case IPV6_AUTOFLOWLABEL:
  1241. val = ip6_autoflowlabel(sock_net(sk), np);
  1242. break;
  1243. case IPV6_RECVFRAGSIZE:
  1244. val = np->rxopt.bits.recvfragsize;
  1245. break;
  1246. case IPV6_ROUTER_ALERT_ISOLATE:
  1247. val = np->rtalert_isolate;
  1248. break;
  1249. case IPV6_RECVERR_RFC4884:
  1250. val = np->recverr_rfc4884;
  1251. break;
  1252. default:
  1253. return -ENOPROTOOPT;
  1254. }
  1255. len = min_t(unsigned int, sizeof(int), len);
  1256. if (put_user(len, optlen))
  1257. return -EFAULT;
  1258. if (copy_to_user(optval, &val, len))
  1259. return -EFAULT;
  1260. return 0;
  1261. }
  1262. int ipv6_getsockopt(struct sock *sk, int level, int optname,
  1263. char __user *optval, int __user *optlen)
  1264. {
  1265. int err;
  1266. if (level == SOL_IP && sk->sk_type != SOCK_RAW)
  1267. return udp_prot.getsockopt(sk, level, optname, optval, optlen);
  1268. if (level != SOL_IPV6)
  1269. return -ENOPROTOOPT;
  1270. err = do_ipv6_getsockopt(sk, level, optname, optval, optlen, 0);
  1271. #ifdef CONFIG_NETFILTER
  1272. /* we need to exclude all possible ENOPROTOOPTs except default case */
  1273. if (err == -ENOPROTOOPT && optname != IPV6_2292PKTOPTIONS) {
  1274. int len;
  1275. if (get_user(len, optlen))
  1276. return -EFAULT;
  1277. err = nf_getsockopt(sk, PF_INET6, optname, optval, &len);
  1278. if (err >= 0)
  1279. err = put_user(len, optlen);
  1280. }
  1281. #endif
  1282. return err;
  1283. }
  1284. EXPORT_SYMBOL(ipv6_getsockopt);