ip_sockglue.c 41 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * INET An implementation of the TCP/IP protocol suite for the LINUX
  4. * operating system. INET is implemented using the BSD Socket
  5. * interface as the means of communication with the user level.
  6. *
  7. * The IP to API glue.
  8. *
  9. * Authors: see ip.c
  10. *
  11. * Fixes:
  12. * Many : Split from ip.c , see ip.c for history.
  13. * Martin Mares : TOS setting fixed.
  14. * Alan Cox : Fixed a couple of oopses in Martin's
  15. * TOS tweaks.
  16. * Mike McLagan : Routing by source
  17. */
  18. #include <linux/module.h>
  19. #include <linux/types.h>
  20. #include <linux/mm.h>
  21. #include <linux/skbuff.h>
  22. #include <linux/ip.h>
  23. #include <linux/icmp.h>
  24. #include <linux/inetdevice.h>
  25. #include <linux/netdevice.h>
  26. #include <linux/slab.h>
  27. #include <net/sock.h>
  28. #include <net/ip.h>
  29. #include <net/icmp.h>
  30. #include <net/tcp_states.h>
  31. #include <linux/udp.h>
  32. #include <linux/igmp.h>
  33. #include <linux/netfilter.h>
  34. #include <linux/route.h>
  35. #include <linux/mroute.h>
  36. #include <net/inet_ecn.h>
  37. #include <net/route.h>
  38. #include <net/xfrm.h>
  39. #include <net/compat.h>
  40. #include <net/checksum.h>
  41. #if IS_ENABLED(CONFIG_IPV6)
  42. #include <net/transp_v6.h>
  43. #endif
  44. #include <net/ip_fib.h>
  45. #include <linux/errqueue.h>
  46. #include <linux/uaccess.h>
  47. #include <linux/bpfilter.h>
  48. /*
  49. * SOL_IP control messages.
  50. */
  51. static void ip_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb)
  52. {
  53. struct in_pktinfo info = *PKTINFO_SKB_CB(skb);
  54. info.ipi_addr.s_addr = ip_hdr(skb)->daddr;
  55. put_cmsg(msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
  56. }
  57. static void ip_cmsg_recv_ttl(struct msghdr *msg, struct sk_buff *skb)
  58. {
  59. int ttl = ip_hdr(skb)->ttl;
  60. put_cmsg(msg, SOL_IP, IP_TTL, sizeof(int), &ttl);
  61. }
  62. static void ip_cmsg_recv_tos(struct msghdr *msg, struct sk_buff *skb)
  63. {
  64. put_cmsg(msg, SOL_IP, IP_TOS, 1, &ip_hdr(skb)->tos);
  65. }
  66. static void ip_cmsg_recv_opts(struct msghdr *msg, struct sk_buff *skb)
  67. {
  68. if (IPCB(skb)->opt.optlen == 0)
  69. return;
  70. put_cmsg(msg, SOL_IP, IP_RECVOPTS, IPCB(skb)->opt.optlen,
  71. ip_hdr(skb) + 1);
  72. }
  73. static void ip_cmsg_recv_retopts(struct net *net, struct msghdr *msg,
  74. struct sk_buff *skb)
  75. {
  76. unsigned char optbuf[sizeof(struct ip_options) + 40];
  77. struct ip_options *opt = (struct ip_options *)optbuf;
  78. if (IPCB(skb)->opt.optlen == 0)
  79. return;
  80. if (ip_options_echo(net, opt, skb)) {
  81. msg->msg_flags |= MSG_CTRUNC;
  82. return;
  83. }
  84. ip_options_undo(opt);
  85. put_cmsg(msg, SOL_IP, IP_RETOPTS, opt->optlen, opt->__data);
  86. }
  87. static void ip_cmsg_recv_fragsize(struct msghdr *msg, struct sk_buff *skb)
  88. {
  89. int val;
  90. if (IPCB(skb)->frag_max_size == 0)
  91. return;
  92. val = IPCB(skb)->frag_max_size;
  93. put_cmsg(msg, SOL_IP, IP_RECVFRAGSIZE, sizeof(val), &val);
  94. }
  95. static void ip_cmsg_recv_checksum(struct msghdr *msg, struct sk_buff *skb,
  96. int tlen, int offset)
  97. {
  98. __wsum csum = skb->csum;
  99. if (skb->ip_summed != CHECKSUM_COMPLETE)
  100. return;
  101. if (offset != 0) {
  102. int tend_off = skb_transport_offset(skb) + tlen;
  103. csum = csum_sub(csum, skb_checksum(skb, tend_off, offset, 0));
  104. }
  105. put_cmsg(msg, SOL_IP, IP_CHECKSUM, sizeof(__wsum), &csum);
  106. }
  107. static void ip_cmsg_recv_security(struct msghdr *msg, struct sk_buff *skb)
  108. {
  109. char *secdata;
  110. u32 seclen, secid;
  111. int err;
  112. err = security_socket_getpeersec_dgram(NULL, skb, &secid);
  113. if (err)
  114. return;
  115. err = security_secid_to_secctx(secid, &secdata, &seclen);
  116. if (err)
  117. return;
  118. put_cmsg(msg, SOL_IP, SCM_SECURITY, seclen, secdata);
  119. security_release_secctx(secdata, seclen);
  120. }
  121. static void ip_cmsg_recv_dstaddr(struct msghdr *msg, struct sk_buff *skb)
  122. {
  123. __be16 _ports[2], *ports;
  124. struct sockaddr_in sin;
  125. /* All current transport protocols have the port numbers in the
  126. * first four bytes of the transport header and this function is
  127. * written with this assumption in mind.
  128. */
  129. ports = skb_header_pointer(skb, skb_transport_offset(skb),
  130. sizeof(_ports), &_ports);
  131. if (!ports)
  132. return;
  133. sin.sin_family = AF_INET;
  134. sin.sin_addr.s_addr = ip_hdr(skb)->daddr;
  135. sin.sin_port = ports[1];
  136. memset(sin.sin_zero, 0, sizeof(sin.sin_zero));
  137. put_cmsg(msg, SOL_IP, IP_ORIGDSTADDR, sizeof(sin), &sin);
  138. }
  139. void ip_cmsg_recv_offset(struct msghdr *msg, struct sock *sk,
  140. struct sk_buff *skb, int tlen, int offset)
  141. {
  142. struct inet_sock *inet = inet_sk(sk);
  143. unsigned int flags = inet->cmsg_flags;
  144. /* Ordered by supposed usage frequency */
  145. if (flags & IP_CMSG_PKTINFO) {
  146. ip_cmsg_recv_pktinfo(msg, skb);
  147. flags &= ~IP_CMSG_PKTINFO;
  148. if (!flags)
  149. return;
  150. }
  151. if (flags & IP_CMSG_TTL) {
  152. ip_cmsg_recv_ttl(msg, skb);
  153. flags &= ~IP_CMSG_TTL;
  154. if (!flags)
  155. return;
  156. }
  157. if (flags & IP_CMSG_TOS) {
  158. ip_cmsg_recv_tos(msg, skb);
  159. flags &= ~IP_CMSG_TOS;
  160. if (!flags)
  161. return;
  162. }
  163. if (flags & IP_CMSG_RECVOPTS) {
  164. ip_cmsg_recv_opts(msg, skb);
  165. flags &= ~IP_CMSG_RECVOPTS;
  166. if (!flags)
  167. return;
  168. }
  169. if (flags & IP_CMSG_RETOPTS) {
  170. ip_cmsg_recv_retopts(sock_net(sk), msg, skb);
  171. flags &= ~IP_CMSG_RETOPTS;
  172. if (!flags)
  173. return;
  174. }
  175. if (flags & IP_CMSG_PASSSEC) {
  176. ip_cmsg_recv_security(msg, skb);
  177. flags &= ~IP_CMSG_PASSSEC;
  178. if (!flags)
  179. return;
  180. }
  181. if (flags & IP_CMSG_ORIGDSTADDR) {
  182. ip_cmsg_recv_dstaddr(msg, skb);
  183. flags &= ~IP_CMSG_ORIGDSTADDR;
  184. if (!flags)
  185. return;
  186. }
  187. if (flags & IP_CMSG_CHECKSUM)
  188. ip_cmsg_recv_checksum(msg, skb, tlen, offset);
  189. if (flags & IP_CMSG_RECVFRAGSIZE)
  190. ip_cmsg_recv_fragsize(msg, skb);
  191. }
  192. EXPORT_SYMBOL(ip_cmsg_recv_offset);
  193. int ip_cmsg_send(struct sock *sk, struct msghdr *msg, struct ipcm_cookie *ipc,
  194. bool allow_ipv6)
  195. {
  196. int err, val;
  197. struct cmsghdr *cmsg;
  198. struct net *net = sock_net(sk);
  199. for_each_cmsghdr(cmsg, msg) {
  200. if (!CMSG_OK(msg, cmsg))
  201. return -EINVAL;
  202. #if IS_ENABLED(CONFIG_IPV6)
  203. if (allow_ipv6 &&
  204. cmsg->cmsg_level == SOL_IPV6 &&
  205. cmsg->cmsg_type == IPV6_PKTINFO) {
  206. struct in6_pktinfo *src_info;
  207. if (cmsg->cmsg_len < CMSG_LEN(sizeof(*src_info)))
  208. return -EINVAL;
  209. src_info = (struct in6_pktinfo *)CMSG_DATA(cmsg);
  210. if (!ipv6_addr_v4mapped(&src_info->ipi6_addr))
  211. return -EINVAL;
  212. if (src_info->ipi6_ifindex)
  213. ipc->oif = src_info->ipi6_ifindex;
  214. ipc->addr = src_info->ipi6_addr.s6_addr32[3];
  215. continue;
  216. }
  217. #endif
  218. if (cmsg->cmsg_level == SOL_SOCKET) {
  219. err = __sock_cmsg_send(sk, msg, cmsg, &ipc->sockc);
  220. if (err)
  221. return err;
  222. continue;
  223. }
  224. if (cmsg->cmsg_level != SOL_IP)
  225. continue;
  226. switch (cmsg->cmsg_type) {
  227. case IP_RETOPTS:
  228. err = cmsg->cmsg_len - sizeof(struct cmsghdr);
  229. /* Our caller is responsible for freeing ipc->opt */
  230. err = ip_options_get(net, &ipc->opt,
  231. KERNEL_SOCKPTR(CMSG_DATA(cmsg)),
  232. err < 40 ? err : 40);
  233. if (err)
  234. return err;
  235. break;
  236. case IP_PKTINFO:
  237. {
  238. struct in_pktinfo *info;
  239. if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct in_pktinfo)))
  240. return -EINVAL;
  241. info = (struct in_pktinfo *)CMSG_DATA(cmsg);
  242. if (info->ipi_ifindex)
  243. ipc->oif = info->ipi_ifindex;
  244. ipc->addr = info->ipi_spec_dst.s_addr;
  245. break;
  246. }
  247. case IP_TTL:
  248. if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)))
  249. return -EINVAL;
  250. val = *(int *)CMSG_DATA(cmsg);
  251. if (val < 1 || val > 255)
  252. return -EINVAL;
  253. ipc->ttl = val;
  254. break;
  255. case IP_TOS:
  256. if (cmsg->cmsg_len == CMSG_LEN(sizeof(int)))
  257. val = *(int *)CMSG_DATA(cmsg);
  258. else if (cmsg->cmsg_len == CMSG_LEN(sizeof(u8)))
  259. val = *(u8 *)CMSG_DATA(cmsg);
  260. else
  261. return -EINVAL;
  262. if (val < 0 || val > 255)
  263. return -EINVAL;
  264. ipc->tos = val;
  265. ipc->priority = rt_tos2priority(ipc->tos);
  266. break;
  267. default:
  268. return -EINVAL;
  269. }
  270. }
  271. return 0;
  272. }
  273. static void ip_ra_destroy_rcu(struct rcu_head *head)
  274. {
  275. struct ip_ra_chain *ra = container_of(head, struct ip_ra_chain, rcu);
  276. sock_put(ra->saved_sk);
  277. kfree(ra);
  278. }
  279. int ip_ra_control(struct sock *sk, unsigned char on,
  280. void (*destructor)(struct sock *))
  281. {
  282. struct ip_ra_chain *ra, *new_ra;
  283. struct ip_ra_chain __rcu **rap;
  284. struct net *net = sock_net(sk);
  285. if (sk->sk_type != SOCK_RAW || inet_sk(sk)->inet_num == IPPROTO_RAW)
  286. return -EINVAL;
  287. new_ra = on ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
  288. if (on && !new_ra)
  289. return -ENOMEM;
  290. mutex_lock(&net->ipv4.ra_mutex);
  291. for (rap = &net->ipv4.ra_chain;
  292. (ra = rcu_dereference_protected(*rap,
  293. lockdep_is_held(&net->ipv4.ra_mutex))) != NULL;
  294. rap = &ra->next) {
  295. if (ra->sk == sk) {
  296. if (on) {
  297. mutex_unlock(&net->ipv4.ra_mutex);
  298. kfree(new_ra);
  299. return -EADDRINUSE;
  300. }
  301. /* dont let ip_call_ra_chain() use sk again */
  302. ra->sk = NULL;
  303. RCU_INIT_POINTER(*rap, ra->next);
  304. mutex_unlock(&net->ipv4.ra_mutex);
  305. if (ra->destructor)
  306. ra->destructor(sk);
  307. /*
  308. * Delay sock_put(sk) and kfree(ra) after one rcu grace
  309. * period. This guarantee ip_call_ra_chain() dont need
  310. * to mess with socket refcounts.
  311. */
  312. ra->saved_sk = sk;
  313. call_rcu(&ra->rcu, ip_ra_destroy_rcu);
  314. return 0;
  315. }
  316. }
  317. if (!new_ra) {
  318. mutex_unlock(&net->ipv4.ra_mutex);
  319. return -ENOBUFS;
  320. }
  321. new_ra->sk = sk;
  322. new_ra->destructor = destructor;
  323. RCU_INIT_POINTER(new_ra->next, ra);
  324. rcu_assign_pointer(*rap, new_ra);
  325. sock_hold(sk);
  326. mutex_unlock(&net->ipv4.ra_mutex);
  327. return 0;
  328. }
  329. static void ipv4_icmp_error_rfc4884(const struct sk_buff *skb,
  330. struct sock_ee_data_rfc4884 *out)
  331. {
  332. switch (icmp_hdr(skb)->type) {
  333. case ICMP_DEST_UNREACH:
  334. case ICMP_TIME_EXCEEDED:
  335. case ICMP_PARAMETERPROB:
  336. ip_icmp_error_rfc4884(skb, out, sizeof(struct icmphdr),
  337. icmp_hdr(skb)->un.reserved[1] * 4);
  338. }
  339. }
  340. void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
  341. __be16 port, u32 info, u8 *payload)
  342. {
  343. struct sock_exterr_skb *serr;
  344. skb = skb_clone(skb, GFP_ATOMIC);
  345. if (!skb)
  346. return;
  347. serr = SKB_EXT_ERR(skb);
  348. serr->ee.ee_errno = err;
  349. serr->ee.ee_origin = SO_EE_ORIGIN_ICMP;
  350. serr->ee.ee_type = icmp_hdr(skb)->type;
  351. serr->ee.ee_code = icmp_hdr(skb)->code;
  352. serr->ee.ee_pad = 0;
  353. serr->ee.ee_info = info;
  354. serr->ee.ee_data = 0;
  355. serr->addr_offset = (u8 *)&(((struct iphdr *)(icmp_hdr(skb) + 1))->daddr) -
  356. skb_network_header(skb);
  357. serr->port = port;
  358. if (skb_pull(skb, payload - skb->data)) {
  359. if (inet_sk(sk)->recverr_rfc4884)
  360. ipv4_icmp_error_rfc4884(skb, &serr->ee.ee_rfc4884);
  361. skb_reset_transport_header(skb);
  362. if (sock_queue_err_skb(sk, skb) == 0)
  363. return;
  364. }
  365. kfree_skb(skb);
  366. }
  367. void ip_local_error(struct sock *sk, int err, __be32 daddr, __be16 port, u32 info)
  368. {
  369. struct inet_sock *inet = inet_sk(sk);
  370. struct sock_exterr_skb *serr;
  371. struct iphdr *iph;
  372. struct sk_buff *skb;
  373. if (!inet->recverr)
  374. return;
  375. skb = alloc_skb(sizeof(struct iphdr), GFP_ATOMIC);
  376. if (!skb)
  377. return;
  378. skb_put(skb, sizeof(struct iphdr));
  379. skb_reset_network_header(skb);
  380. iph = ip_hdr(skb);
  381. iph->daddr = daddr;
  382. serr = SKB_EXT_ERR(skb);
  383. serr->ee.ee_errno = err;
  384. serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
  385. serr->ee.ee_type = 0;
  386. serr->ee.ee_code = 0;
  387. serr->ee.ee_pad = 0;
  388. serr->ee.ee_info = info;
  389. serr->ee.ee_data = 0;
  390. serr->addr_offset = (u8 *)&iph->daddr - skb_network_header(skb);
  391. serr->port = port;
  392. __skb_pull(skb, skb_tail_pointer(skb) - skb->data);
  393. skb_reset_transport_header(skb);
  394. if (sock_queue_err_skb(sk, skb))
  395. kfree_skb(skb);
  396. }
  397. /* For some errors we have valid addr_offset even with zero payload and
  398. * zero port. Also, addr_offset should be supported if port is set.
  399. */
  400. static inline bool ipv4_datagram_support_addr(struct sock_exterr_skb *serr)
  401. {
  402. return serr->ee.ee_origin == SO_EE_ORIGIN_ICMP ||
  403. serr->ee.ee_origin == SO_EE_ORIGIN_LOCAL || serr->port;
  404. }
  405. /* IPv4 supports cmsg on all imcp errors and some timestamps
  406. *
  407. * Timestamp code paths do not initialize the fields expected by cmsg:
  408. * the PKTINFO fields in skb->cb[]. Fill those in here.
  409. */
  410. static bool ipv4_datagram_support_cmsg(const struct sock *sk,
  411. struct sk_buff *skb,
  412. int ee_origin)
  413. {
  414. struct in_pktinfo *info;
  415. if (ee_origin == SO_EE_ORIGIN_ICMP)
  416. return true;
  417. if (ee_origin == SO_EE_ORIGIN_LOCAL)
  418. return false;
  419. /* Support IP_PKTINFO on tstamp packets if requested, to correlate
  420. * timestamp with egress dev. Not possible for packets without iif
  421. * or without payload (SOF_TIMESTAMPING_OPT_TSONLY).
  422. */
  423. info = PKTINFO_SKB_CB(skb);
  424. if (!(sk->sk_tsflags & SOF_TIMESTAMPING_OPT_CMSG) ||
  425. !info->ipi_ifindex)
  426. return false;
  427. info->ipi_spec_dst.s_addr = ip_hdr(skb)->saddr;
  428. return true;
  429. }
  430. /*
  431. * Handle MSG_ERRQUEUE
  432. */
  433. int ip_recv_error(struct sock *sk, struct msghdr *msg, int len, int *addr_len)
  434. {
  435. struct sock_exterr_skb *serr;
  436. struct sk_buff *skb;
  437. DECLARE_SOCKADDR(struct sockaddr_in *, sin, msg->msg_name);
  438. struct {
  439. struct sock_extended_err ee;
  440. struct sockaddr_in offender;
  441. } errhdr;
  442. int err;
  443. int copied;
  444. err = -EAGAIN;
  445. skb = sock_dequeue_err_skb(sk);
  446. if (!skb)
  447. goto out;
  448. copied = skb->len;
  449. if (copied > len) {
  450. msg->msg_flags |= MSG_TRUNC;
  451. copied = len;
  452. }
  453. err = skb_copy_datagram_msg(skb, 0, msg, copied);
  454. if (unlikely(err)) {
  455. kfree_skb(skb);
  456. return err;
  457. }
  458. sock_recv_timestamp(msg, sk, skb);
  459. serr = SKB_EXT_ERR(skb);
  460. if (sin && ipv4_datagram_support_addr(serr)) {
  461. sin->sin_family = AF_INET;
  462. sin->sin_addr.s_addr = *(__be32 *)(skb_network_header(skb) +
  463. serr->addr_offset);
  464. sin->sin_port = serr->port;
  465. memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
  466. *addr_len = sizeof(*sin);
  467. }
  468. memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
  469. sin = &errhdr.offender;
  470. memset(sin, 0, sizeof(*sin));
  471. if (ipv4_datagram_support_cmsg(sk, skb, serr->ee.ee_origin)) {
  472. sin->sin_family = AF_INET;
  473. sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
  474. if (inet_sk(sk)->cmsg_flags)
  475. ip_cmsg_recv(msg, skb);
  476. }
  477. put_cmsg(msg, SOL_IP, IP_RECVERR, sizeof(errhdr), &errhdr);
  478. /* Now we could try to dump offended packet options */
  479. msg->msg_flags |= MSG_ERRQUEUE;
  480. err = copied;
  481. consume_skb(skb);
  482. out:
  483. return err;
  484. }
  485. static void __ip_sock_set_tos(struct sock *sk, int val)
  486. {
  487. if (sk->sk_type == SOCK_STREAM) {
  488. val &= ~INET_ECN_MASK;
  489. val |= inet_sk(sk)->tos & INET_ECN_MASK;
  490. }
  491. if (inet_sk(sk)->tos != val) {
  492. inet_sk(sk)->tos = val;
  493. sk->sk_priority = rt_tos2priority(val);
  494. sk_dst_reset(sk);
  495. }
  496. }
  497. void ip_sock_set_tos(struct sock *sk, int val)
  498. {
  499. lock_sock(sk);
  500. __ip_sock_set_tos(sk, val);
  501. release_sock(sk);
  502. }
  503. EXPORT_SYMBOL(ip_sock_set_tos);
  504. void ip_sock_set_freebind(struct sock *sk)
  505. {
  506. lock_sock(sk);
  507. inet_sk(sk)->freebind = true;
  508. release_sock(sk);
  509. }
  510. EXPORT_SYMBOL(ip_sock_set_freebind);
  511. void ip_sock_set_recverr(struct sock *sk)
  512. {
  513. lock_sock(sk);
  514. inet_sk(sk)->recverr = true;
  515. release_sock(sk);
  516. }
  517. EXPORT_SYMBOL(ip_sock_set_recverr);
  518. int ip_sock_set_mtu_discover(struct sock *sk, int val)
  519. {
  520. if (val < IP_PMTUDISC_DONT || val > IP_PMTUDISC_OMIT)
  521. return -EINVAL;
  522. lock_sock(sk);
  523. inet_sk(sk)->pmtudisc = val;
  524. release_sock(sk);
  525. return 0;
  526. }
  527. EXPORT_SYMBOL(ip_sock_set_mtu_discover);
  528. void ip_sock_set_pktinfo(struct sock *sk)
  529. {
  530. lock_sock(sk);
  531. inet_sk(sk)->cmsg_flags |= IP_CMSG_PKTINFO;
  532. release_sock(sk);
  533. }
  534. EXPORT_SYMBOL(ip_sock_set_pktinfo);
  535. /*
  536. * Socket option code for IP. This is the end of the line after any
  537. * TCP,UDP etc options on an IP socket.
  538. */
  539. static bool setsockopt_needs_rtnl(int optname)
  540. {
  541. switch (optname) {
  542. case IP_ADD_MEMBERSHIP:
  543. case IP_ADD_SOURCE_MEMBERSHIP:
  544. case IP_BLOCK_SOURCE:
  545. case IP_DROP_MEMBERSHIP:
  546. case IP_DROP_SOURCE_MEMBERSHIP:
  547. case IP_MSFILTER:
  548. case IP_UNBLOCK_SOURCE:
  549. case MCAST_BLOCK_SOURCE:
  550. case MCAST_MSFILTER:
  551. case MCAST_JOIN_GROUP:
  552. case MCAST_JOIN_SOURCE_GROUP:
  553. case MCAST_LEAVE_GROUP:
  554. case MCAST_LEAVE_SOURCE_GROUP:
  555. case MCAST_UNBLOCK_SOURCE:
  556. return true;
  557. }
  558. return false;
  559. }
  560. static int set_mcast_msfilter(struct sock *sk, int ifindex,
  561. int numsrc, int fmode,
  562. struct sockaddr_storage *group,
  563. struct sockaddr_storage *list)
  564. {
  565. int msize = IP_MSFILTER_SIZE(numsrc);
  566. struct ip_msfilter *msf;
  567. struct sockaddr_in *psin;
  568. int err, i;
  569. msf = kmalloc(msize, GFP_KERNEL);
  570. if (!msf)
  571. return -ENOBUFS;
  572. psin = (struct sockaddr_in *)group;
  573. if (psin->sin_family != AF_INET)
  574. goto Eaddrnotavail;
  575. msf->imsf_multiaddr = psin->sin_addr.s_addr;
  576. msf->imsf_interface = 0;
  577. msf->imsf_fmode = fmode;
  578. msf->imsf_numsrc = numsrc;
  579. for (i = 0; i < numsrc; ++i) {
  580. psin = (struct sockaddr_in *)&list[i];
  581. if (psin->sin_family != AF_INET)
  582. goto Eaddrnotavail;
  583. msf->imsf_slist[i] = psin->sin_addr.s_addr;
  584. }
  585. err = ip_mc_msfilter(sk, msf, ifindex);
  586. kfree(msf);
  587. return err;
  588. Eaddrnotavail:
  589. kfree(msf);
  590. return -EADDRNOTAVAIL;
  591. }
  592. static int copy_group_source_from_sockptr(struct group_source_req *greqs,
  593. sockptr_t optval, int optlen)
  594. {
  595. if (in_compat_syscall()) {
  596. struct compat_group_source_req gr32;
  597. if (optlen != sizeof(gr32))
  598. return -EINVAL;
  599. if (copy_from_sockptr(&gr32, optval, sizeof(gr32)))
  600. return -EFAULT;
  601. greqs->gsr_interface = gr32.gsr_interface;
  602. greqs->gsr_group = gr32.gsr_group;
  603. greqs->gsr_source = gr32.gsr_source;
  604. } else {
  605. if (optlen != sizeof(*greqs))
  606. return -EINVAL;
  607. if (copy_from_sockptr(greqs, optval, sizeof(*greqs)))
  608. return -EFAULT;
  609. }
  610. return 0;
  611. }
  612. static int do_mcast_group_source(struct sock *sk, int optname,
  613. sockptr_t optval, int optlen)
  614. {
  615. struct group_source_req greqs;
  616. struct ip_mreq_source mreqs;
  617. struct sockaddr_in *psin;
  618. int omode, add, err;
  619. err = copy_group_source_from_sockptr(&greqs, optval, optlen);
  620. if (err)
  621. return err;
  622. if (greqs.gsr_group.ss_family != AF_INET ||
  623. greqs.gsr_source.ss_family != AF_INET)
  624. return -EADDRNOTAVAIL;
  625. psin = (struct sockaddr_in *)&greqs.gsr_group;
  626. mreqs.imr_multiaddr = psin->sin_addr.s_addr;
  627. psin = (struct sockaddr_in *)&greqs.gsr_source;
  628. mreqs.imr_sourceaddr = psin->sin_addr.s_addr;
  629. mreqs.imr_interface = 0; /* use index for mc_source */
  630. if (optname == MCAST_BLOCK_SOURCE) {
  631. omode = MCAST_EXCLUDE;
  632. add = 1;
  633. } else if (optname == MCAST_UNBLOCK_SOURCE) {
  634. omode = MCAST_EXCLUDE;
  635. add = 0;
  636. } else if (optname == MCAST_JOIN_SOURCE_GROUP) {
  637. struct ip_mreqn mreq;
  638. psin = (struct sockaddr_in *)&greqs.gsr_group;
  639. mreq.imr_multiaddr = psin->sin_addr;
  640. mreq.imr_address.s_addr = 0;
  641. mreq.imr_ifindex = greqs.gsr_interface;
  642. err = ip_mc_join_group_ssm(sk, &mreq, MCAST_INCLUDE);
  643. if (err && err != -EADDRINUSE)
  644. return err;
  645. greqs.gsr_interface = mreq.imr_ifindex;
  646. omode = MCAST_INCLUDE;
  647. add = 1;
  648. } else /* MCAST_LEAVE_SOURCE_GROUP */ {
  649. omode = MCAST_INCLUDE;
  650. add = 0;
  651. }
  652. return ip_mc_source(add, omode, sk, &mreqs, greqs.gsr_interface);
  653. }
  654. static int ip_set_mcast_msfilter(struct sock *sk, sockptr_t optval, int optlen)
  655. {
  656. struct group_filter *gsf = NULL;
  657. int err;
  658. if (optlen < GROUP_FILTER_SIZE(0))
  659. return -EINVAL;
  660. if (optlen > sysctl_optmem_max)
  661. return -ENOBUFS;
  662. gsf = memdup_sockptr(optval, optlen);
  663. if (IS_ERR(gsf))
  664. return PTR_ERR(gsf);
  665. /* numsrc >= (4G-140)/128 overflow in 32 bits */
  666. err = -ENOBUFS;
  667. if (gsf->gf_numsrc >= 0x1ffffff ||
  668. gsf->gf_numsrc > sock_net(sk)->ipv4.sysctl_igmp_max_msf)
  669. goto out_free_gsf;
  670. err = -EINVAL;
  671. if (GROUP_FILTER_SIZE(gsf->gf_numsrc) > optlen)
  672. goto out_free_gsf;
  673. err = set_mcast_msfilter(sk, gsf->gf_interface, gsf->gf_numsrc,
  674. gsf->gf_fmode, &gsf->gf_group, gsf->gf_slist);
  675. out_free_gsf:
  676. kfree(gsf);
  677. return err;
  678. }
  679. static int compat_ip_set_mcast_msfilter(struct sock *sk, sockptr_t optval,
  680. int optlen)
  681. {
  682. const int size0 = offsetof(struct compat_group_filter, gf_slist);
  683. struct compat_group_filter *gf32;
  684. unsigned int n;
  685. void *p;
  686. int err;
  687. if (optlen < size0)
  688. return -EINVAL;
  689. if (optlen > sysctl_optmem_max - 4)
  690. return -ENOBUFS;
  691. p = kmalloc(optlen + 4, GFP_KERNEL);
  692. if (!p)
  693. return -ENOMEM;
  694. gf32 = p + 4; /* we want ->gf_group and ->gf_slist aligned */
  695. err = -EFAULT;
  696. if (copy_from_sockptr(gf32, optval, optlen))
  697. goto out_free_gsf;
  698. /* numsrc >= (4G-140)/128 overflow in 32 bits */
  699. n = gf32->gf_numsrc;
  700. err = -ENOBUFS;
  701. if (n >= 0x1ffffff)
  702. goto out_free_gsf;
  703. err = -EINVAL;
  704. if (offsetof(struct compat_group_filter, gf_slist[n]) > optlen)
  705. goto out_free_gsf;
  706. /* numsrc >= (4G-140)/128 overflow in 32 bits */
  707. err = -ENOBUFS;
  708. if (n > sock_net(sk)->ipv4.sysctl_igmp_max_msf)
  709. goto out_free_gsf;
  710. err = set_mcast_msfilter(sk, gf32->gf_interface, n, gf32->gf_fmode,
  711. &gf32->gf_group, gf32->gf_slist);
  712. out_free_gsf:
  713. kfree(p);
  714. return err;
  715. }
  716. static int ip_mcast_join_leave(struct sock *sk, int optname,
  717. sockptr_t optval, int optlen)
  718. {
  719. struct ip_mreqn mreq = { };
  720. struct sockaddr_in *psin;
  721. struct group_req greq;
  722. if (optlen < sizeof(struct group_req))
  723. return -EINVAL;
  724. if (copy_from_sockptr(&greq, optval, sizeof(greq)))
  725. return -EFAULT;
  726. psin = (struct sockaddr_in *)&greq.gr_group;
  727. if (psin->sin_family != AF_INET)
  728. return -EINVAL;
  729. mreq.imr_multiaddr = psin->sin_addr;
  730. mreq.imr_ifindex = greq.gr_interface;
  731. if (optname == MCAST_JOIN_GROUP)
  732. return ip_mc_join_group(sk, &mreq);
  733. return ip_mc_leave_group(sk, &mreq);
  734. }
  735. static int compat_ip_mcast_join_leave(struct sock *sk, int optname,
  736. sockptr_t optval, int optlen)
  737. {
  738. struct compat_group_req greq;
  739. struct ip_mreqn mreq = { };
  740. struct sockaddr_in *psin;
  741. if (optlen < sizeof(struct compat_group_req))
  742. return -EINVAL;
  743. if (copy_from_sockptr(&greq, optval, sizeof(greq)))
  744. return -EFAULT;
  745. psin = (struct sockaddr_in *)&greq.gr_group;
  746. if (psin->sin_family != AF_INET)
  747. return -EINVAL;
  748. mreq.imr_multiaddr = psin->sin_addr;
  749. mreq.imr_ifindex = greq.gr_interface;
  750. if (optname == MCAST_JOIN_GROUP)
  751. return ip_mc_join_group(sk, &mreq);
  752. return ip_mc_leave_group(sk, &mreq);
  753. }
  754. static int do_ip_setsockopt(struct sock *sk, int level, int optname,
  755. sockptr_t optval, unsigned int optlen)
  756. {
  757. struct inet_sock *inet = inet_sk(sk);
  758. struct net *net = sock_net(sk);
  759. int val = 0, err;
  760. bool needs_rtnl = setsockopt_needs_rtnl(optname);
  761. switch (optname) {
  762. case IP_PKTINFO:
  763. case IP_RECVTTL:
  764. case IP_RECVOPTS:
  765. case IP_RECVTOS:
  766. case IP_RETOPTS:
  767. case IP_TOS:
  768. case IP_TTL:
  769. case IP_HDRINCL:
  770. case IP_MTU_DISCOVER:
  771. case IP_RECVERR:
  772. case IP_ROUTER_ALERT:
  773. case IP_FREEBIND:
  774. case IP_PASSSEC:
  775. case IP_TRANSPARENT:
  776. case IP_MINTTL:
  777. case IP_NODEFRAG:
  778. case IP_BIND_ADDRESS_NO_PORT:
  779. case IP_UNICAST_IF:
  780. case IP_MULTICAST_TTL:
  781. case IP_MULTICAST_ALL:
  782. case IP_MULTICAST_LOOP:
  783. case IP_RECVORIGDSTADDR:
  784. case IP_CHECKSUM:
  785. case IP_RECVFRAGSIZE:
  786. case IP_RECVERR_RFC4884:
  787. if (optlen >= sizeof(int)) {
  788. if (copy_from_sockptr(&val, optval, sizeof(val)))
  789. return -EFAULT;
  790. } else if (optlen >= sizeof(char)) {
  791. unsigned char ucval;
  792. if (copy_from_sockptr(&ucval, optval, sizeof(ucval)))
  793. return -EFAULT;
  794. val = (int) ucval;
  795. }
  796. }
  797. /* If optlen==0, it is equivalent to val == 0 */
  798. if (optname == IP_ROUTER_ALERT)
  799. return ip_ra_control(sk, val ? 1 : 0, NULL);
  800. if (ip_mroute_opt(optname))
  801. return ip_mroute_setsockopt(sk, optname, optval, optlen);
  802. err = 0;
  803. if (needs_rtnl)
  804. rtnl_lock();
  805. lock_sock(sk);
  806. switch (optname) {
  807. case IP_OPTIONS:
  808. {
  809. struct ip_options_rcu *old, *opt = NULL;
  810. if (optlen > 40)
  811. goto e_inval;
  812. err = ip_options_get(sock_net(sk), &opt, optval, optlen);
  813. if (err)
  814. break;
  815. old = rcu_dereference_protected(inet->inet_opt,
  816. lockdep_sock_is_held(sk));
  817. if (inet->is_icsk) {
  818. struct inet_connection_sock *icsk = inet_csk(sk);
  819. #if IS_ENABLED(CONFIG_IPV6)
  820. if (sk->sk_family == PF_INET ||
  821. (!((1 << sk->sk_state) &
  822. (TCPF_LISTEN | TCPF_CLOSE)) &&
  823. inet->inet_daddr != LOOPBACK4_IPV6)) {
  824. #endif
  825. if (old)
  826. icsk->icsk_ext_hdr_len -= old->opt.optlen;
  827. if (opt)
  828. icsk->icsk_ext_hdr_len += opt->opt.optlen;
  829. icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie);
  830. #if IS_ENABLED(CONFIG_IPV6)
  831. }
  832. #endif
  833. }
  834. rcu_assign_pointer(inet->inet_opt, opt);
  835. if (old)
  836. kfree_rcu(old, rcu);
  837. break;
  838. }
  839. case IP_PKTINFO:
  840. if (val)
  841. inet->cmsg_flags |= IP_CMSG_PKTINFO;
  842. else
  843. inet->cmsg_flags &= ~IP_CMSG_PKTINFO;
  844. break;
  845. case IP_RECVTTL:
  846. if (val)
  847. inet->cmsg_flags |= IP_CMSG_TTL;
  848. else
  849. inet->cmsg_flags &= ~IP_CMSG_TTL;
  850. break;
  851. case IP_RECVTOS:
  852. if (val)
  853. inet->cmsg_flags |= IP_CMSG_TOS;
  854. else
  855. inet->cmsg_flags &= ~IP_CMSG_TOS;
  856. break;
  857. case IP_RECVOPTS:
  858. if (val)
  859. inet->cmsg_flags |= IP_CMSG_RECVOPTS;
  860. else
  861. inet->cmsg_flags &= ~IP_CMSG_RECVOPTS;
  862. break;
  863. case IP_RETOPTS:
  864. if (val)
  865. inet->cmsg_flags |= IP_CMSG_RETOPTS;
  866. else
  867. inet->cmsg_flags &= ~IP_CMSG_RETOPTS;
  868. break;
  869. case IP_PASSSEC:
  870. if (val)
  871. inet->cmsg_flags |= IP_CMSG_PASSSEC;
  872. else
  873. inet->cmsg_flags &= ~IP_CMSG_PASSSEC;
  874. break;
  875. case IP_RECVORIGDSTADDR:
  876. if (val)
  877. inet->cmsg_flags |= IP_CMSG_ORIGDSTADDR;
  878. else
  879. inet->cmsg_flags &= ~IP_CMSG_ORIGDSTADDR;
  880. break;
  881. case IP_CHECKSUM:
  882. if (val) {
  883. if (!(inet->cmsg_flags & IP_CMSG_CHECKSUM)) {
  884. inet_inc_convert_csum(sk);
  885. inet->cmsg_flags |= IP_CMSG_CHECKSUM;
  886. }
  887. } else {
  888. if (inet->cmsg_flags & IP_CMSG_CHECKSUM) {
  889. inet_dec_convert_csum(sk);
  890. inet->cmsg_flags &= ~IP_CMSG_CHECKSUM;
  891. }
  892. }
  893. break;
  894. case IP_RECVFRAGSIZE:
  895. if (sk->sk_type != SOCK_RAW && sk->sk_type != SOCK_DGRAM)
  896. goto e_inval;
  897. if (val)
  898. inet->cmsg_flags |= IP_CMSG_RECVFRAGSIZE;
  899. else
  900. inet->cmsg_flags &= ~IP_CMSG_RECVFRAGSIZE;
  901. break;
  902. case IP_TOS: /* This sets both TOS and Precedence */
  903. __ip_sock_set_tos(sk, val);
  904. break;
  905. case IP_TTL:
  906. if (optlen < 1)
  907. goto e_inval;
  908. if (val != -1 && (val < 1 || val > 255))
  909. goto e_inval;
  910. inet->uc_ttl = val;
  911. break;
  912. case IP_HDRINCL:
  913. if (sk->sk_type != SOCK_RAW) {
  914. err = -ENOPROTOOPT;
  915. break;
  916. }
  917. inet->hdrincl = val ? 1 : 0;
  918. break;
  919. case IP_NODEFRAG:
  920. if (sk->sk_type != SOCK_RAW) {
  921. err = -ENOPROTOOPT;
  922. break;
  923. }
  924. inet->nodefrag = val ? 1 : 0;
  925. break;
  926. case IP_BIND_ADDRESS_NO_PORT:
  927. inet->bind_address_no_port = val ? 1 : 0;
  928. break;
  929. case IP_MTU_DISCOVER:
  930. if (val < IP_PMTUDISC_DONT || val > IP_PMTUDISC_OMIT)
  931. goto e_inval;
  932. inet->pmtudisc = val;
  933. break;
  934. case IP_RECVERR:
  935. inet->recverr = !!val;
  936. if (!val)
  937. skb_queue_purge(&sk->sk_error_queue);
  938. break;
  939. case IP_RECVERR_RFC4884:
  940. if (val < 0 || val > 1)
  941. goto e_inval;
  942. inet->recverr_rfc4884 = !!val;
  943. break;
  944. case IP_MULTICAST_TTL:
  945. if (sk->sk_type == SOCK_STREAM)
  946. goto e_inval;
  947. if (optlen < 1)
  948. goto e_inval;
  949. if (val == -1)
  950. val = 1;
  951. if (val < 0 || val > 255)
  952. goto e_inval;
  953. inet->mc_ttl = val;
  954. break;
  955. case IP_MULTICAST_LOOP:
  956. if (optlen < 1)
  957. goto e_inval;
  958. inet->mc_loop = !!val;
  959. break;
  960. case IP_UNICAST_IF:
  961. {
  962. struct net_device *dev = NULL;
  963. int ifindex;
  964. int midx;
  965. if (optlen != sizeof(int))
  966. goto e_inval;
  967. ifindex = (__force int)ntohl((__force __be32)val);
  968. if (ifindex == 0) {
  969. inet->uc_index = 0;
  970. err = 0;
  971. break;
  972. }
  973. dev = dev_get_by_index(sock_net(sk), ifindex);
  974. err = -EADDRNOTAVAIL;
  975. if (!dev)
  976. break;
  977. midx = l3mdev_master_ifindex(dev);
  978. dev_put(dev);
  979. err = -EINVAL;
  980. if (sk->sk_bound_dev_if && midx != sk->sk_bound_dev_if)
  981. break;
  982. inet->uc_index = ifindex;
  983. err = 0;
  984. break;
  985. }
  986. case IP_MULTICAST_IF:
  987. {
  988. struct ip_mreqn mreq;
  989. struct net_device *dev = NULL;
  990. int midx;
  991. if (sk->sk_type == SOCK_STREAM)
  992. goto e_inval;
  993. /*
  994. * Check the arguments are allowable
  995. */
  996. if (optlen < sizeof(struct in_addr))
  997. goto e_inval;
  998. err = -EFAULT;
  999. if (optlen >= sizeof(struct ip_mreqn)) {
  1000. if (copy_from_sockptr(&mreq, optval, sizeof(mreq)))
  1001. break;
  1002. } else {
  1003. memset(&mreq, 0, sizeof(mreq));
  1004. if (optlen >= sizeof(struct ip_mreq)) {
  1005. if (copy_from_sockptr(&mreq, optval,
  1006. sizeof(struct ip_mreq)))
  1007. break;
  1008. } else if (optlen >= sizeof(struct in_addr)) {
  1009. if (copy_from_sockptr(&mreq.imr_address, optval,
  1010. sizeof(struct in_addr)))
  1011. break;
  1012. }
  1013. }
  1014. if (!mreq.imr_ifindex) {
  1015. if (mreq.imr_address.s_addr == htonl(INADDR_ANY)) {
  1016. inet->mc_index = 0;
  1017. inet->mc_addr = 0;
  1018. err = 0;
  1019. break;
  1020. }
  1021. dev = ip_dev_find(sock_net(sk), mreq.imr_address.s_addr);
  1022. if (dev)
  1023. mreq.imr_ifindex = dev->ifindex;
  1024. } else
  1025. dev = dev_get_by_index(sock_net(sk), mreq.imr_ifindex);
  1026. err = -EADDRNOTAVAIL;
  1027. if (!dev)
  1028. break;
  1029. midx = l3mdev_master_ifindex(dev);
  1030. dev_put(dev);
  1031. err = -EINVAL;
  1032. if (sk->sk_bound_dev_if &&
  1033. mreq.imr_ifindex != sk->sk_bound_dev_if &&
  1034. midx != sk->sk_bound_dev_if)
  1035. break;
  1036. inet->mc_index = mreq.imr_ifindex;
  1037. inet->mc_addr = mreq.imr_address.s_addr;
  1038. err = 0;
  1039. break;
  1040. }
  1041. case IP_ADD_MEMBERSHIP:
  1042. case IP_DROP_MEMBERSHIP:
  1043. {
  1044. struct ip_mreqn mreq;
  1045. err = -EPROTO;
  1046. if (inet_sk(sk)->is_icsk)
  1047. break;
  1048. if (optlen < sizeof(struct ip_mreq))
  1049. goto e_inval;
  1050. err = -EFAULT;
  1051. if (optlen >= sizeof(struct ip_mreqn)) {
  1052. if (copy_from_sockptr(&mreq, optval, sizeof(mreq)))
  1053. break;
  1054. } else {
  1055. memset(&mreq, 0, sizeof(mreq));
  1056. if (copy_from_sockptr(&mreq, optval,
  1057. sizeof(struct ip_mreq)))
  1058. break;
  1059. }
  1060. if (optname == IP_ADD_MEMBERSHIP)
  1061. err = ip_mc_join_group(sk, &mreq);
  1062. else
  1063. err = ip_mc_leave_group(sk, &mreq);
  1064. break;
  1065. }
  1066. case IP_MSFILTER:
  1067. {
  1068. struct ip_msfilter *msf;
  1069. if (optlen < IP_MSFILTER_SIZE(0))
  1070. goto e_inval;
  1071. if (optlen > sysctl_optmem_max) {
  1072. err = -ENOBUFS;
  1073. break;
  1074. }
  1075. msf = memdup_sockptr(optval, optlen);
  1076. if (IS_ERR(msf)) {
  1077. err = PTR_ERR(msf);
  1078. break;
  1079. }
  1080. /* numsrc >= (1G-4) overflow in 32 bits */
  1081. if (msf->imsf_numsrc >= 0x3ffffffcU ||
  1082. msf->imsf_numsrc > net->ipv4.sysctl_igmp_max_msf) {
  1083. kfree(msf);
  1084. err = -ENOBUFS;
  1085. break;
  1086. }
  1087. if (IP_MSFILTER_SIZE(msf->imsf_numsrc) > optlen) {
  1088. kfree(msf);
  1089. err = -EINVAL;
  1090. break;
  1091. }
  1092. err = ip_mc_msfilter(sk, msf, 0);
  1093. kfree(msf);
  1094. break;
  1095. }
  1096. case IP_BLOCK_SOURCE:
  1097. case IP_UNBLOCK_SOURCE:
  1098. case IP_ADD_SOURCE_MEMBERSHIP:
  1099. case IP_DROP_SOURCE_MEMBERSHIP:
  1100. {
  1101. struct ip_mreq_source mreqs;
  1102. int omode, add;
  1103. if (optlen != sizeof(struct ip_mreq_source))
  1104. goto e_inval;
  1105. if (copy_from_sockptr(&mreqs, optval, sizeof(mreqs))) {
  1106. err = -EFAULT;
  1107. break;
  1108. }
  1109. if (optname == IP_BLOCK_SOURCE) {
  1110. omode = MCAST_EXCLUDE;
  1111. add = 1;
  1112. } else if (optname == IP_UNBLOCK_SOURCE) {
  1113. omode = MCAST_EXCLUDE;
  1114. add = 0;
  1115. } else if (optname == IP_ADD_SOURCE_MEMBERSHIP) {
  1116. struct ip_mreqn mreq;
  1117. mreq.imr_multiaddr.s_addr = mreqs.imr_multiaddr;
  1118. mreq.imr_address.s_addr = mreqs.imr_interface;
  1119. mreq.imr_ifindex = 0;
  1120. err = ip_mc_join_group_ssm(sk, &mreq, MCAST_INCLUDE);
  1121. if (err && err != -EADDRINUSE)
  1122. break;
  1123. omode = MCAST_INCLUDE;
  1124. add = 1;
  1125. } else /* IP_DROP_SOURCE_MEMBERSHIP */ {
  1126. omode = MCAST_INCLUDE;
  1127. add = 0;
  1128. }
  1129. err = ip_mc_source(add, omode, sk, &mreqs, 0);
  1130. break;
  1131. }
  1132. case MCAST_JOIN_GROUP:
  1133. case MCAST_LEAVE_GROUP:
  1134. if (in_compat_syscall())
  1135. err = compat_ip_mcast_join_leave(sk, optname, optval,
  1136. optlen);
  1137. else
  1138. err = ip_mcast_join_leave(sk, optname, optval, optlen);
  1139. break;
  1140. case MCAST_JOIN_SOURCE_GROUP:
  1141. case MCAST_LEAVE_SOURCE_GROUP:
  1142. case MCAST_BLOCK_SOURCE:
  1143. case MCAST_UNBLOCK_SOURCE:
  1144. err = do_mcast_group_source(sk, optname, optval, optlen);
  1145. break;
  1146. case MCAST_MSFILTER:
  1147. if (in_compat_syscall())
  1148. err = compat_ip_set_mcast_msfilter(sk, optval, optlen);
  1149. else
  1150. err = ip_set_mcast_msfilter(sk, optval, optlen);
  1151. break;
  1152. case IP_MULTICAST_ALL:
  1153. if (optlen < 1)
  1154. goto e_inval;
  1155. if (val != 0 && val != 1)
  1156. goto e_inval;
  1157. inet->mc_all = val;
  1158. break;
  1159. case IP_FREEBIND:
  1160. if (optlen < 1)
  1161. goto e_inval;
  1162. inet->freebind = !!val;
  1163. break;
  1164. case IP_IPSEC_POLICY:
  1165. case IP_XFRM_POLICY:
  1166. err = -EPERM;
  1167. if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
  1168. break;
  1169. err = xfrm_user_policy(sk, optname, optval, optlen);
  1170. break;
  1171. case IP_TRANSPARENT:
  1172. if (!!val && !ns_capable(sock_net(sk)->user_ns, CAP_NET_RAW) &&
  1173. !ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) {
  1174. err = -EPERM;
  1175. break;
  1176. }
  1177. if (optlen < 1)
  1178. goto e_inval;
  1179. inet->transparent = !!val;
  1180. break;
  1181. case IP_MINTTL:
  1182. if (optlen < 1)
  1183. goto e_inval;
  1184. if (val < 0 || val > 255)
  1185. goto e_inval;
  1186. inet->min_ttl = val;
  1187. break;
  1188. default:
  1189. err = -ENOPROTOOPT;
  1190. break;
  1191. }
  1192. release_sock(sk);
  1193. if (needs_rtnl)
  1194. rtnl_unlock();
  1195. return err;
  1196. e_inval:
  1197. release_sock(sk);
  1198. if (needs_rtnl)
  1199. rtnl_unlock();
  1200. return -EINVAL;
  1201. }
  1202. /**
  1203. * ipv4_pktinfo_prepare - transfer some info from rtable to skb
  1204. * @sk: socket
  1205. * @skb: buffer
  1206. *
  1207. * To support IP_CMSG_PKTINFO option, we store rt_iif and specific
  1208. * destination in skb->cb[] before dst drop.
  1209. * This way, receiver doesn't make cache line misses to read rtable.
  1210. */
  1211. void ipv4_pktinfo_prepare(const struct sock *sk, struct sk_buff *skb)
  1212. {
  1213. struct in_pktinfo *pktinfo = PKTINFO_SKB_CB(skb);
  1214. bool prepare = (inet_sk(sk)->cmsg_flags & IP_CMSG_PKTINFO) ||
  1215. ipv6_sk_rxinfo(sk);
  1216. if (prepare && skb_rtable(skb)) {
  1217. /* skb->cb is overloaded: prior to this point it is IP{6}CB
  1218. * which has interface index (iif) as the first member of the
  1219. * underlying inet{6}_skb_parm struct. This code then overlays
  1220. * PKTINFO_SKB_CB and in_pktinfo also has iif as the first
  1221. * element so the iif is picked up from the prior IPCB. If iif
  1222. * is the loopback interface, then return the sending interface
  1223. * (e.g., process binds socket to eth0 for Tx which is
  1224. * redirected to loopback in the rtable/dst).
  1225. */
  1226. struct rtable *rt = skb_rtable(skb);
  1227. bool l3slave = ipv4_l3mdev_skb(IPCB(skb)->flags);
  1228. if (pktinfo->ipi_ifindex == LOOPBACK_IFINDEX)
  1229. pktinfo->ipi_ifindex = inet_iif(skb);
  1230. else if (l3slave && rt && rt->rt_iif)
  1231. pktinfo->ipi_ifindex = rt->rt_iif;
  1232. pktinfo->ipi_spec_dst.s_addr = fib_compute_spec_dst(skb);
  1233. } else {
  1234. pktinfo->ipi_ifindex = 0;
  1235. pktinfo->ipi_spec_dst.s_addr = 0;
  1236. }
  1237. skb_dst_drop(skb);
  1238. }
  1239. int ip_setsockopt(struct sock *sk, int level, int optname, sockptr_t optval,
  1240. unsigned int optlen)
  1241. {
  1242. int err;
  1243. if (level != SOL_IP)
  1244. return -ENOPROTOOPT;
  1245. err = do_ip_setsockopt(sk, level, optname, optval, optlen);
  1246. #if IS_ENABLED(CONFIG_BPFILTER_UMH)
  1247. if (optname >= BPFILTER_IPT_SO_SET_REPLACE &&
  1248. optname < BPFILTER_IPT_SET_MAX)
  1249. err = bpfilter_ip_set_sockopt(sk, optname, optval, optlen);
  1250. #endif
  1251. #ifdef CONFIG_NETFILTER
  1252. /* we need to exclude all possible ENOPROTOOPTs except default case */
  1253. if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
  1254. optname != IP_IPSEC_POLICY &&
  1255. optname != IP_XFRM_POLICY &&
  1256. !ip_mroute_opt(optname))
  1257. err = nf_setsockopt(sk, PF_INET, optname, optval, optlen);
  1258. #endif
  1259. return err;
  1260. }
  1261. EXPORT_SYMBOL(ip_setsockopt);
  1262. /*
  1263. * Get the options. Note for future reference. The GET of IP options gets
  1264. * the _received_ ones. The set sets the _sent_ ones.
  1265. */
  1266. static bool getsockopt_needs_rtnl(int optname)
  1267. {
  1268. switch (optname) {
  1269. case IP_MSFILTER:
  1270. case MCAST_MSFILTER:
  1271. return true;
  1272. }
  1273. return false;
  1274. }
  1275. static int ip_get_mcast_msfilter(struct sock *sk, void __user *optval,
  1276. int __user *optlen, int len)
  1277. {
  1278. const int size0 = offsetof(struct group_filter, gf_slist);
  1279. struct group_filter __user *p = optval;
  1280. struct group_filter gsf;
  1281. int num;
  1282. int err;
  1283. if (len < size0)
  1284. return -EINVAL;
  1285. if (copy_from_user(&gsf, p, size0))
  1286. return -EFAULT;
  1287. num = gsf.gf_numsrc;
  1288. err = ip_mc_gsfget(sk, &gsf, p->gf_slist);
  1289. if (err)
  1290. return err;
  1291. if (gsf.gf_numsrc < num)
  1292. num = gsf.gf_numsrc;
  1293. if (put_user(GROUP_FILTER_SIZE(num), optlen) ||
  1294. copy_to_user(p, &gsf, size0))
  1295. return -EFAULT;
  1296. return 0;
  1297. }
  1298. static int compat_ip_get_mcast_msfilter(struct sock *sk, void __user *optval,
  1299. int __user *optlen, int len)
  1300. {
  1301. const int size0 = offsetof(struct compat_group_filter, gf_slist);
  1302. struct compat_group_filter __user *p = optval;
  1303. struct compat_group_filter gf32;
  1304. struct group_filter gf;
  1305. int num;
  1306. int err;
  1307. if (len < size0)
  1308. return -EINVAL;
  1309. if (copy_from_user(&gf32, p, size0))
  1310. return -EFAULT;
  1311. gf.gf_interface = gf32.gf_interface;
  1312. gf.gf_fmode = gf32.gf_fmode;
  1313. num = gf.gf_numsrc = gf32.gf_numsrc;
  1314. gf.gf_group = gf32.gf_group;
  1315. err = ip_mc_gsfget(sk, &gf, p->gf_slist);
  1316. if (err)
  1317. return err;
  1318. if (gf.gf_numsrc < num)
  1319. num = gf.gf_numsrc;
  1320. len = GROUP_FILTER_SIZE(num) - (sizeof(gf) - sizeof(gf32));
  1321. if (put_user(len, optlen) ||
  1322. put_user(gf.gf_fmode, &p->gf_fmode) ||
  1323. put_user(gf.gf_numsrc, &p->gf_numsrc))
  1324. return -EFAULT;
  1325. return 0;
  1326. }
  1327. static int do_ip_getsockopt(struct sock *sk, int level, int optname,
  1328. char __user *optval, int __user *optlen)
  1329. {
  1330. struct inet_sock *inet = inet_sk(sk);
  1331. bool needs_rtnl = getsockopt_needs_rtnl(optname);
  1332. int val, err = 0;
  1333. int len;
  1334. if (level != SOL_IP)
  1335. return -EOPNOTSUPP;
  1336. if (ip_mroute_opt(optname))
  1337. return ip_mroute_getsockopt(sk, optname, optval, optlen);
  1338. if (get_user(len, optlen))
  1339. return -EFAULT;
  1340. if (len < 0)
  1341. return -EINVAL;
  1342. if (needs_rtnl)
  1343. rtnl_lock();
  1344. lock_sock(sk);
  1345. switch (optname) {
  1346. case IP_OPTIONS:
  1347. {
  1348. unsigned char optbuf[sizeof(struct ip_options)+40];
  1349. struct ip_options *opt = (struct ip_options *)optbuf;
  1350. struct ip_options_rcu *inet_opt;
  1351. inet_opt = rcu_dereference_protected(inet->inet_opt,
  1352. lockdep_sock_is_held(sk));
  1353. opt->optlen = 0;
  1354. if (inet_opt)
  1355. memcpy(optbuf, &inet_opt->opt,
  1356. sizeof(struct ip_options) +
  1357. inet_opt->opt.optlen);
  1358. release_sock(sk);
  1359. if (opt->optlen == 0)
  1360. return put_user(0, optlen);
  1361. ip_options_undo(opt);
  1362. len = min_t(unsigned int, len, opt->optlen);
  1363. if (put_user(len, optlen))
  1364. return -EFAULT;
  1365. if (copy_to_user(optval, opt->__data, len))
  1366. return -EFAULT;
  1367. return 0;
  1368. }
  1369. case IP_PKTINFO:
  1370. val = (inet->cmsg_flags & IP_CMSG_PKTINFO) != 0;
  1371. break;
  1372. case IP_RECVTTL:
  1373. val = (inet->cmsg_flags & IP_CMSG_TTL) != 0;
  1374. break;
  1375. case IP_RECVTOS:
  1376. val = (inet->cmsg_flags & IP_CMSG_TOS) != 0;
  1377. break;
  1378. case IP_RECVOPTS:
  1379. val = (inet->cmsg_flags & IP_CMSG_RECVOPTS) != 0;
  1380. break;
  1381. case IP_RETOPTS:
  1382. val = (inet->cmsg_flags & IP_CMSG_RETOPTS) != 0;
  1383. break;
  1384. case IP_PASSSEC:
  1385. val = (inet->cmsg_flags & IP_CMSG_PASSSEC) != 0;
  1386. break;
  1387. case IP_RECVORIGDSTADDR:
  1388. val = (inet->cmsg_flags & IP_CMSG_ORIGDSTADDR) != 0;
  1389. break;
  1390. case IP_CHECKSUM:
  1391. val = (inet->cmsg_flags & IP_CMSG_CHECKSUM) != 0;
  1392. break;
  1393. case IP_RECVFRAGSIZE:
  1394. val = (inet->cmsg_flags & IP_CMSG_RECVFRAGSIZE) != 0;
  1395. break;
  1396. case IP_TOS:
  1397. val = inet->tos;
  1398. break;
  1399. case IP_TTL:
  1400. {
  1401. struct net *net = sock_net(sk);
  1402. val = (inet->uc_ttl == -1 ?
  1403. net->ipv4.sysctl_ip_default_ttl :
  1404. inet->uc_ttl);
  1405. break;
  1406. }
  1407. case IP_HDRINCL:
  1408. val = inet->hdrincl;
  1409. break;
  1410. case IP_NODEFRAG:
  1411. val = inet->nodefrag;
  1412. break;
  1413. case IP_BIND_ADDRESS_NO_PORT:
  1414. val = inet->bind_address_no_port;
  1415. break;
  1416. case IP_MTU_DISCOVER:
  1417. val = inet->pmtudisc;
  1418. break;
  1419. case IP_MTU:
  1420. {
  1421. struct dst_entry *dst;
  1422. val = 0;
  1423. dst = sk_dst_get(sk);
  1424. if (dst) {
  1425. val = dst_mtu(dst);
  1426. dst_release(dst);
  1427. }
  1428. if (!val) {
  1429. release_sock(sk);
  1430. return -ENOTCONN;
  1431. }
  1432. break;
  1433. }
  1434. case IP_RECVERR:
  1435. val = inet->recverr;
  1436. break;
  1437. case IP_RECVERR_RFC4884:
  1438. val = inet->recverr_rfc4884;
  1439. break;
  1440. case IP_MULTICAST_TTL:
  1441. val = inet->mc_ttl;
  1442. break;
  1443. case IP_MULTICAST_LOOP:
  1444. val = inet->mc_loop;
  1445. break;
  1446. case IP_UNICAST_IF:
  1447. val = (__force int)htonl((__u32) inet->uc_index);
  1448. break;
  1449. case IP_MULTICAST_IF:
  1450. {
  1451. struct in_addr addr;
  1452. len = min_t(unsigned int, len, sizeof(struct in_addr));
  1453. addr.s_addr = inet->mc_addr;
  1454. release_sock(sk);
  1455. if (put_user(len, optlen))
  1456. return -EFAULT;
  1457. if (copy_to_user(optval, &addr, len))
  1458. return -EFAULT;
  1459. return 0;
  1460. }
  1461. case IP_MSFILTER:
  1462. {
  1463. struct ip_msfilter msf;
  1464. if (len < IP_MSFILTER_SIZE(0)) {
  1465. err = -EINVAL;
  1466. goto out;
  1467. }
  1468. if (copy_from_user(&msf, optval, IP_MSFILTER_SIZE(0))) {
  1469. err = -EFAULT;
  1470. goto out;
  1471. }
  1472. err = ip_mc_msfget(sk, &msf,
  1473. (struct ip_msfilter __user *)optval, optlen);
  1474. goto out;
  1475. }
  1476. case MCAST_MSFILTER:
  1477. if (in_compat_syscall())
  1478. err = compat_ip_get_mcast_msfilter(sk, optval, optlen,
  1479. len);
  1480. else
  1481. err = ip_get_mcast_msfilter(sk, optval, optlen, len);
  1482. goto out;
  1483. case IP_MULTICAST_ALL:
  1484. val = inet->mc_all;
  1485. break;
  1486. case IP_PKTOPTIONS:
  1487. {
  1488. struct msghdr msg;
  1489. release_sock(sk);
  1490. if (sk->sk_type != SOCK_STREAM)
  1491. return -ENOPROTOOPT;
  1492. msg.msg_control_is_user = true;
  1493. msg.msg_control_user = optval;
  1494. msg.msg_controllen = len;
  1495. msg.msg_flags = in_compat_syscall() ? MSG_CMSG_COMPAT : 0;
  1496. if (inet->cmsg_flags & IP_CMSG_PKTINFO) {
  1497. struct in_pktinfo info;
  1498. info.ipi_addr.s_addr = inet->inet_rcv_saddr;
  1499. info.ipi_spec_dst.s_addr = inet->inet_rcv_saddr;
  1500. info.ipi_ifindex = inet->mc_index;
  1501. put_cmsg(&msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
  1502. }
  1503. if (inet->cmsg_flags & IP_CMSG_TTL) {
  1504. int hlim = inet->mc_ttl;
  1505. put_cmsg(&msg, SOL_IP, IP_TTL, sizeof(hlim), &hlim);
  1506. }
  1507. if (inet->cmsg_flags & IP_CMSG_TOS) {
  1508. int tos = inet->rcv_tos;
  1509. put_cmsg(&msg, SOL_IP, IP_TOS, sizeof(tos), &tos);
  1510. }
  1511. len -= msg.msg_controllen;
  1512. return put_user(len, optlen);
  1513. }
  1514. case IP_FREEBIND:
  1515. val = inet->freebind;
  1516. break;
  1517. case IP_TRANSPARENT:
  1518. val = inet->transparent;
  1519. break;
  1520. case IP_MINTTL:
  1521. val = inet->min_ttl;
  1522. break;
  1523. default:
  1524. release_sock(sk);
  1525. return -ENOPROTOOPT;
  1526. }
  1527. release_sock(sk);
  1528. if (len < sizeof(int) && len > 0 && val >= 0 && val <= 255) {
  1529. unsigned char ucval = (unsigned char)val;
  1530. len = 1;
  1531. if (put_user(len, optlen))
  1532. return -EFAULT;
  1533. if (copy_to_user(optval, &ucval, 1))
  1534. return -EFAULT;
  1535. } else {
  1536. len = min_t(unsigned int, sizeof(int), len);
  1537. if (put_user(len, optlen))
  1538. return -EFAULT;
  1539. if (copy_to_user(optval, &val, len))
  1540. return -EFAULT;
  1541. }
  1542. return 0;
  1543. out:
  1544. release_sock(sk);
  1545. if (needs_rtnl)
  1546. rtnl_unlock();
  1547. return err;
  1548. }
  1549. int ip_getsockopt(struct sock *sk, int level,
  1550. int optname, char __user *optval, int __user *optlen)
  1551. {
  1552. int err;
  1553. err = do_ip_getsockopt(sk, level, optname, optval, optlen);
  1554. #if IS_ENABLED(CONFIG_BPFILTER_UMH)
  1555. if (optname >= BPFILTER_IPT_SO_GET_INFO &&
  1556. optname < BPFILTER_IPT_GET_MAX)
  1557. err = bpfilter_ip_get_sockopt(sk, optname, optval, optlen);
  1558. #endif
  1559. #ifdef CONFIG_NETFILTER
  1560. /* we need to exclude all possible ENOPROTOOPTs except default case */
  1561. if (err == -ENOPROTOOPT && optname != IP_PKTOPTIONS &&
  1562. !ip_mroute_opt(optname)) {
  1563. int len;
  1564. if (get_user(len, optlen))
  1565. return -EFAULT;
  1566. err = nf_getsockopt(sk, PF_INET, optname, optval, &len);
  1567. if (err >= 0)
  1568. err = put_user(len, optlen);
  1569. return err;
  1570. }
  1571. #endif
  1572. return err;
  1573. }
  1574. EXPORT_SYMBOL(ip_getsockopt);