ip_sockglue.c 32 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443
  1. /*
  2. * INET An implementation of the TCP/IP protocol suite for the LINUX
  3. * operating system. INET is implemented using the BSD Socket
  4. * interface as the means of communication with the user level.
  5. *
  6. * The IP to API glue.
  7. *
  8. * Authors: see ip.c
  9. *
  10. * Fixes:
  11. * Many : Split from ip.c , see ip.c for history.
  12. * Martin Mares : TOS setting fixed.
  13. * Alan Cox : Fixed a couple of oopses in Martin's
  14. * TOS tweaks.
  15. * Mike McLagan : Routing by source
  16. */
  17. #include <linux/module.h>
  18. #include <linux/types.h>
  19. #include <linux/mm.h>
  20. #include <linux/skbuff.h>
  21. #include <linux/ip.h>
  22. #include <linux/icmp.h>
  23. #include <linux/inetdevice.h>
  24. #include <linux/netdevice.h>
  25. #include <linux/slab.h>
  26. #include <net/sock.h>
  27. #include <net/ip.h>
  28. #include <net/icmp.h>
  29. #include <net/tcp_states.h>
  30. #include <linux/udp.h>
  31. #include <linux/igmp.h>
  32. #include <linux/netfilter.h>
  33. #include <linux/route.h>
  34. #include <linux/mroute.h>
  35. #include <net/inet_ecn.h>
  36. #include <net/route.h>
  37. #include <net/xfrm.h>
  38. #include <net/compat.h>
  39. #if IS_ENABLED(CONFIG_IPV6)
  40. #include <net/transp_v6.h>
  41. #endif
  42. #include <net/ip_fib.h>
  43. #include <linux/errqueue.h>
  44. #include <asm/uaccess.h>
  45. #define IP_CMSG_PKTINFO 1
  46. #define IP_CMSG_TTL 2
  47. #define IP_CMSG_TOS 4
  48. #define IP_CMSG_RECVOPTS 8
  49. #define IP_CMSG_RETOPTS 16
  50. #define IP_CMSG_PASSSEC 32
  51. #define IP_CMSG_ORIGDSTADDR 64
  52. /*
  53. * SOL_IP control messages.
  54. */
  55. static void ip_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb)
  56. {
  57. struct in_pktinfo info = *PKTINFO_SKB_CB(skb);
  58. info.ipi_addr.s_addr = ip_hdr(skb)->daddr;
  59. put_cmsg(msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
  60. }
  61. static void ip_cmsg_recv_ttl(struct msghdr *msg, struct sk_buff *skb)
  62. {
  63. int ttl = ip_hdr(skb)->ttl;
  64. put_cmsg(msg, SOL_IP, IP_TTL, sizeof(int), &ttl);
  65. }
  66. static void ip_cmsg_recv_tos(struct msghdr *msg, struct sk_buff *skb)
  67. {
  68. put_cmsg(msg, SOL_IP, IP_TOS, 1, &ip_hdr(skb)->tos);
  69. }
  70. static void ip_cmsg_recv_opts(struct msghdr *msg, struct sk_buff *skb)
  71. {
  72. if (IPCB(skb)->opt.optlen == 0)
  73. return;
  74. put_cmsg(msg, SOL_IP, IP_RECVOPTS, IPCB(skb)->opt.optlen,
  75. ip_hdr(skb) + 1);
  76. }
  77. static void ip_cmsg_recv_retopts(struct msghdr *msg, struct sk_buff *skb)
  78. {
  79. unsigned char optbuf[sizeof(struct ip_options) + 40];
  80. struct ip_options *opt = (struct ip_options *)optbuf;
  81. if (IPCB(skb)->opt.optlen == 0)
  82. return;
  83. if (ip_options_echo(opt, skb)) {
  84. msg->msg_flags |= MSG_CTRUNC;
  85. return;
  86. }
  87. ip_options_undo(opt);
  88. put_cmsg(msg, SOL_IP, IP_RETOPTS, opt->optlen, opt->__data);
  89. }
  90. static void ip_cmsg_recv_security(struct msghdr *msg, struct sk_buff *skb)
  91. {
  92. char *secdata;
  93. u32 seclen, secid;
  94. int err;
  95. err = security_socket_getpeersec_dgram(NULL, skb, &secid);
  96. if (err)
  97. return;
  98. err = security_secid_to_secctx(secid, &secdata, &seclen);
  99. if (err)
  100. return;
  101. put_cmsg(msg, SOL_IP, SCM_SECURITY, seclen, secdata);
  102. security_release_secctx(secdata, seclen);
  103. }
  104. static void ip_cmsg_recv_dstaddr(struct msghdr *msg, struct sk_buff *skb)
  105. {
  106. struct sockaddr_in sin;
  107. const struct iphdr *iph = ip_hdr(skb);
  108. __be16 *ports = (__be16 *)skb_transport_header(skb);
  109. if (skb_transport_offset(skb) + 4 > skb->len)
  110. return;
  111. /* All current transport protocols have the port numbers in the
  112. * first four bytes of the transport header and this function is
  113. * written with this assumption in mind.
  114. */
  115. sin.sin_family = AF_INET;
  116. sin.sin_addr.s_addr = iph->daddr;
  117. sin.sin_port = ports[1];
  118. memset(sin.sin_zero, 0, sizeof(sin.sin_zero));
  119. put_cmsg(msg, SOL_IP, IP_ORIGDSTADDR, sizeof(sin), &sin);
  120. }
  121. void ip_cmsg_recv(struct msghdr *msg, struct sk_buff *skb)
  122. {
  123. struct inet_sock *inet = inet_sk(skb->sk);
  124. unsigned int flags = inet->cmsg_flags;
  125. /* Ordered by supposed usage frequency */
  126. if (flags & 1)
  127. ip_cmsg_recv_pktinfo(msg, skb);
  128. if ((flags >>= 1) == 0)
  129. return;
  130. if (flags & 1)
  131. ip_cmsg_recv_ttl(msg, skb);
  132. if ((flags >>= 1) == 0)
  133. return;
  134. if (flags & 1)
  135. ip_cmsg_recv_tos(msg, skb);
  136. if ((flags >>= 1) == 0)
  137. return;
  138. if (flags & 1)
  139. ip_cmsg_recv_opts(msg, skb);
  140. if ((flags >>= 1) == 0)
  141. return;
  142. if (flags & 1)
  143. ip_cmsg_recv_retopts(msg, skb);
  144. if ((flags >>= 1) == 0)
  145. return;
  146. if (flags & 1)
  147. ip_cmsg_recv_security(msg, skb);
  148. if ((flags >>= 1) == 0)
  149. return;
  150. if (flags & 1)
  151. ip_cmsg_recv_dstaddr(msg, skb);
  152. }
  153. EXPORT_SYMBOL(ip_cmsg_recv);
  154. int ip_cmsg_send(struct net *net, struct msghdr *msg, struct ipcm_cookie *ipc,
  155. bool allow_ipv6)
  156. {
  157. int err, val;
  158. struct cmsghdr *cmsg;
  159. for_each_cmsghdr(cmsg, msg) {
  160. if (!CMSG_OK(msg, cmsg))
  161. return -EINVAL;
  162. #if IS_ENABLED(CONFIG_IPV6)
  163. if (allow_ipv6 &&
  164. cmsg->cmsg_level == SOL_IPV6 &&
  165. cmsg->cmsg_type == IPV6_PKTINFO) {
  166. struct in6_pktinfo *src_info;
  167. if (cmsg->cmsg_len < CMSG_LEN(sizeof(*src_info)))
  168. return -EINVAL;
  169. src_info = (struct in6_pktinfo *)CMSG_DATA(cmsg);
  170. if (!ipv6_addr_v4mapped(&src_info->ipi6_addr))
  171. return -EINVAL;
  172. ipc->oif = src_info->ipi6_ifindex;
  173. ipc->addr = src_info->ipi6_addr.s6_addr32[3];
  174. continue;
  175. }
  176. #endif
  177. if (cmsg->cmsg_level != SOL_IP)
  178. continue;
  179. switch (cmsg->cmsg_type) {
  180. case IP_RETOPTS:
  181. err = cmsg->cmsg_len - CMSG_ALIGN(sizeof(struct cmsghdr));
  182. err = ip_options_get(net, &ipc->opt, CMSG_DATA(cmsg),
  183. err < 40 ? err : 40);
  184. if (err)
  185. return err;
  186. break;
  187. case IP_PKTINFO:
  188. {
  189. struct in_pktinfo *info;
  190. if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct in_pktinfo)))
  191. return -EINVAL;
  192. info = (struct in_pktinfo *)CMSG_DATA(cmsg);
  193. ipc->oif = info->ipi_ifindex;
  194. ipc->addr = info->ipi_spec_dst.s_addr;
  195. break;
  196. }
  197. case IP_TTL:
  198. if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)))
  199. return -EINVAL;
  200. val = *(int *)CMSG_DATA(cmsg);
  201. if (val < 1 || val > 255)
  202. return -EINVAL;
  203. ipc->ttl = val;
  204. break;
  205. case IP_TOS:
  206. if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)))
  207. return -EINVAL;
  208. val = *(int *)CMSG_DATA(cmsg);
  209. if (val < 0 || val > 255)
  210. return -EINVAL;
  211. ipc->tos = val;
  212. ipc->priority = rt_tos2priority(ipc->tos);
  213. break;
  214. default:
  215. return -EINVAL;
  216. }
  217. }
  218. return 0;
  219. }
  220. /* Special input handler for packets caught by router alert option.
  221. They are selected only by protocol field, and then processed likely
  222. local ones; but only if someone wants them! Otherwise, router
  223. not running rsvpd will kill RSVP.
  224. It is user level problem, what it will make with them.
  225. I have no idea, how it will masquearde or NAT them (it is joke, joke :-)),
  226. but receiver should be enough clever f.e. to forward mtrace requests,
  227. sent to multicast group to reach destination designated router.
  228. */
  229. struct ip_ra_chain __rcu *ip_ra_chain;
  230. static DEFINE_SPINLOCK(ip_ra_lock);
  231. static void ip_ra_destroy_rcu(struct rcu_head *head)
  232. {
  233. struct ip_ra_chain *ra = container_of(head, struct ip_ra_chain, rcu);
  234. sock_put(ra->saved_sk);
  235. kfree(ra);
  236. }
  237. int ip_ra_control(struct sock *sk, unsigned char on,
  238. void (*destructor)(struct sock *))
  239. {
  240. struct ip_ra_chain *ra, *new_ra;
  241. struct ip_ra_chain __rcu **rap;
  242. if (sk->sk_type != SOCK_RAW || inet_sk(sk)->inet_num == IPPROTO_RAW)
  243. return -EINVAL;
  244. new_ra = on ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
  245. spin_lock_bh(&ip_ra_lock);
  246. for (rap = &ip_ra_chain;
  247. (ra = rcu_dereference_protected(*rap,
  248. lockdep_is_held(&ip_ra_lock))) != NULL;
  249. rap = &ra->next) {
  250. if (ra->sk == sk) {
  251. if (on) {
  252. spin_unlock_bh(&ip_ra_lock);
  253. kfree(new_ra);
  254. return -EADDRINUSE;
  255. }
  256. /* dont let ip_call_ra_chain() use sk again */
  257. ra->sk = NULL;
  258. RCU_INIT_POINTER(*rap, ra->next);
  259. spin_unlock_bh(&ip_ra_lock);
  260. if (ra->destructor)
  261. ra->destructor(sk);
  262. /*
  263. * Delay sock_put(sk) and kfree(ra) after one rcu grace
  264. * period. This guarantee ip_call_ra_chain() dont need
  265. * to mess with socket refcounts.
  266. */
  267. ra->saved_sk = sk;
  268. call_rcu(&ra->rcu, ip_ra_destroy_rcu);
  269. return 0;
  270. }
  271. }
  272. if (new_ra == NULL) {
  273. spin_unlock_bh(&ip_ra_lock);
  274. return -ENOBUFS;
  275. }
  276. new_ra->sk = sk;
  277. new_ra->destructor = destructor;
  278. RCU_INIT_POINTER(new_ra->next, ra);
  279. rcu_assign_pointer(*rap, new_ra);
  280. sock_hold(sk);
  281. spin_unlock_bh(&ip_ra_lock);
  282. return 0;
  283. }
  284. void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
  285. __be16 port, u32 info, u8 *payload)
  286. {
  287. struct sock_exterr_skb *serr;
  288. skb = skb_clone(skb, GFP_ATOMIC);
  289. if (!skb)
  290. return;
  291. serr = SKB_EXT_ERR(skb);
  292. serr->ee.ee_errno = err;
  293. serr->ee.ee_origin = SO_EE_ORIGIN_ICMP;
  294. serr->ee.ee_type = icmp_hdr(skb)->type;
  295. serr->ee.ee_code = icmp_hdr(skb)->code;
  296. serr->ee.ee_pad = 0;
  297. serr->ee.ee_info = info;
  298. serr->ee.ee_data = 0;
  299. serr->addr_offset = (u8 *)&(((struct iphdr *)(icmp_hdr(skb) + 1))->daddr) -
  300. skb_network_header(skb);
  301. serr->port = port;
  302. if (skb_pull(skb, payload - skb->data) != NULL) {
  303. skb_reset_transport_header(skb);
  304. if (sock_queue_err_skb(sk, skb) == 0)
  305. return;
  306. }
  307. kfree_skb(skb);
  308. }
  309. void ip_local_error(struct sock *sk, int err, __be32 daddr, __be16 port, u32 info)
  310. {
  311. struct inet_sock *inet = inet_sk(sk);
  312. struct sock_exterr_skb *serr;
  313. struct iphdr *iph;
  314. struct sk_buff *skb;
  315. if (!inet->recverr)
  316. return;
  317. skb = alloc_skb(sizeof(struct iphdr), GFP_ATOMIC);
  318. if (!skb)
  319. return;
  320. skb_put(skb, sizeof(struct iphdr));
  321. skb_reset_network_header(skb);
  322. iph = ip_hdr(skb);
  323. iph->daddr = daddr;
  324. serr = SKB_EXT_ERR(skb);
  325. serr->ee.ee_errno = err;
  326. serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
  327. serr->ee.ee_type = 0;
  328. serr->ee.ee_code = 0;
  329. serr->ee.ee_pad = 0;
  330. serr->ee.ee_info = info;
  331. serr->ee.ee_data = 0;
  332. serr->addr_offset = (u8 *)&iph->daddr - skb_network_header(skb);
  333. serr->port = port;
  334. __skb_pull(skb, skb_tail_pointer(skb) - skb->data);
  335. skb_reset_transport_header(skb);
  336. if (sock_queue_err_skb(sk, skb))
  337. kfree_skb(skb);
  338. }
  339. static bool ipv4_pktinfo_prepare_errqueue(const struct sock *sk,
  340. const struct sk_buff *skb,
  341. int ee_origin)
  342. {
  343. struct in_pktinfo *info = PKTINFO_SKB_CB(skb);
  344. if ((ee_origin != SO_EE_ORIGIN_TIMESTAMPING) ||
  345. (!(sk->sk_tsflags & SOF_TIMESTAMPING_OPT_CMSG)) ||
  346. (!skb->dev))
  347. return false;
  348. info->ipi_spec_dst.s_addr = ip_hdr(skb)->saddr;
  349. info->ipi_ifindex = skb->dev->ifindex;
  350. return true;
  351. }
  352. /*
  353. * Handle MSG_ERRQUEUE
  354. */
  355. int ip_recv_error(struct sock *sk, struct msghdr *msg, int len, int *addr_len)
  356. {
  357. struct sock_exterr_skb *serr;
  358. struct sk_buff *skb;
  359. DECLARE_SOCKADDR(struct sockaddr_in *, sin, msg->msg_name);
  360. struct {
  361. struct sock_extended_err ee;
  362. struct sockaddr_in offender;
  363. } errhdr;
  364. int err;
  365. int copied;
  366. WARN_ON_ONCE(sk->sk_family == AF_INET6);
  367. err = -EAGAIN;
  368. skb = sock_dequeue_err_skb(sk);
  369. if (skb == NULL)
  370. goto out;
  371. copied = skb->len;
  372. if (copied > len) {
  373. msg->msg_flags |= MSG_TRUNC;
  374. copied = len;
  375. }
  376. err = skb_copy_datagram_msg(skb, 0, msg, copied);
  377. if (err)
  378. goto out_free_skb;
  379. sock_recv_timestamp(msg, sk, skb);
  380. serr = SKB_EXT_ERR(skb);
  381. if (sin) {
  382. sin->sin_family = AF_INET;
  383. sin->sin_addr.s_addr = *(__be32 *)(skb_network_header(skb) +
  384. serr->addr_offset);
  385. sin->sin_port = serr->port;
  386. memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
  387. *addr_len = sizeof(*sin);
  388. }
  389. memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
  390. sin = &errhdr.offender;
  391. memset(sin, 0, sizeof(*sin));
  392. if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP ||
  393. ipv4_pktinfo_prepare_errqueue(sk, skb, serr->ee.ee_origin)) {
  394. sin->sin_family = AF_INET;
  395. sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
  396. if (inet_sk(sk)->cmsg_flags)
  397. ip_cmsg_recv(msg, skb);
  398. }
  399. put_cmsg(msg, SOL_IP, IP_RECVERR, sizeof(errhdr), &errhdr);
  400. /* Now we could try to dump offended packet options */
  401. msg->msg_flags |= MSG_ERRQUEUE;
  402. err = copied;
  403. out_free_skb:
  404. kfree_skb(skb);
  405. out:
  406. return err;
  407. }
  408. /*
  409. * Socket option code for IP. This is the end of the line after any
  410. * TCP,UDP etc options on an IP socket.
  411. */
  412. static int do_ip_setsockopt(struct sock *sk, int level,
  413. int optname, char __user *optval, unsigned int optlen)
  414. {
  415. struct inet_sock *inet = inet_sk(sk);
  416. int val = 0, err;
  417. switch (optname) {
  418. case IP_PKTINFO:
  419. case IP_RECVTTL:
  420. case IP_RECVOPTS:
  421. case IP_RECVTOS:
  422. case IP_RETOPTS:
  423. case IP_TOS:
  424. case IP_TTL:
  425. case IP_HDRINCL:
  426. case IP_MTU_DISCOVER:
  427. case IP_RECVERR:
  428. case IP_ROUTER_ALERT:
  429. case IP_FREEBIND:
  430. case IP_PASSSEC:
  431. case IP_TRANSPARENT:
  432. case IP_MINTTL:
  433. case IP_NODEFRAG:
  434. case IP_UNICAST_IF:
  435. case IP_MULTICAST_TTL:
  436. case IP_MULTICAST_ALL:
  437. case IP_MULTICAST_LOOP:
  438. case IP_RECVORIGDSTADDR:
  439. if (optlen >= sizeof(int)) {
  440. if (get_user(val, (int __user *) optval))
  441. return -EFAULT;
  442. } else if (optlen >= sizeof(char)) {
  443. unsigned char ucval;
  444. if (get_user(ucval, (unsigned char __user *) optval))
  445. return -EFAULT;
  446. val = (int) ucval;
  447. }
  448. }
  449. /* If optlen==0, it is equivalent to val == 0 */
  450. if (ip_mroute_opt(optname))
  451. return ip_mroute_setsockopt(sk, optname, optval, optlen);
  452. err = 0;
  453. lock_sock(sk);
  454. switch (optname) {
  455. case IP_OPTIONS:
  456. {
  457. struct ip_options_rcu *old, *opt = NULL;
  458. if (optlen > 40)
  459. goto e_inval;
  460. err = ip_options_get_from_user(sock_net(sk), &opt,
  461. optval, optlen);
  462. if (err)
  463. break;
  464. old = rcu_dereference_protected(inet->inet_opt,
  465. sock_owned_by_user(sk));
  466. if (inet->is_icsk) {
  467. struct inet_connection_sock *icsk = inet_csk(sk);
  468. #if IS_ENABLED(CONFIG_IPV6)
  469. if (sk->sk_family == PF_INET ||
  470. (!((1 << sk->sk_state) &
  471. (TCPF_LISTEN | TCPF_CLOSE)) &&
  472. inet->inet_daddr != LOOPBACK4_IPV6)) {
  473. #endif
  474. if (old)
  475. icsk->icsk_ext_hdr_len -= old->opt.optlen;
  476. if (opt)
  477. icsk->icsk_ext_hdr_len += opt->opt.optlen;
  478. icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie);
  479. #if IS_ENABLED(CONFIG_IPV6)
  480. }
  481. #endif
  482. }
  483. rcu_assign_pointer(inet->inet_opt, opt);
  484. if (old)
  485. kfree_rcu(old, rcu);
  486. break;
  487. }
  488. case IP_PKTINFO:
  489. if (val)
  490. inet->cmsg_flags |= IP_CMSG_PKTINFO;
  491. else
  492. inet->cmsg_flags &= ~IP_CMSG_PKTINFO;
  493. break;
  494. case IP_RECVTTL:
  495. if (val)
  496. inet->cmsg_flags |= IP_CMSG_TTL;
  497. else
  498. inet->cmsg_flags &= ~IP_CMSG_TTL;
  499. break;
  500. case IP_RECVTOS:
  501. if (val)
  502. inet->cmsg_flags |= IP_CMSG_TOS;
  503. else
  504. inet->cmsg_flags &= ~IP_CMSG_TOS;
  505. break;
  506. case IP_RECVOPTS:
  507. if (val)
  508. inet->cmsg_flags |= IP_CMSG_RECVOPTS;
  509. else
  510. inet->cmsg_flags &= ~IP_CMSG_RECVOPTS;
  511. break;
  512. case IP_RETOPTS:
  513. if (val)
  514. inet->cmsg_flags |= IP_CMSG_RETOPTS;
  515. else
  516. inet->cmsg_flags &= ~IP_CMSG_RETOPTS;
  517. break;
  518. case IP_PASSSEC:
  519. if (val)
  520. inet->cmsg_flags |= IP_CMSG_PASSSEC;
  521. else
  522. inet->cmsg_flags &= ~IP_CMSG_PASSSEC;
  523. break;
  524. case IP_RECVORIGDSTADDR:
  525. if (val)
  526. inet->cmsg_flags |= IP_CMSG_ORIGDSTADDR;
  527. else
  528. inet->cmsg_flags &= ~IP_CMSG_ORIGDSTADDR;
  529. break;
  530. case IP_TOS: /* This sets both TOS and Precedence */
  531. if (sk->sk_type == SOCK_STREAM) {
  532. val &= ~INET_ECN_MASK;
  533. val |= inet->tos & INET_ECN_MASK;
  534. }
  535. if (inet->tos != val) {
  536. inet->tos = val;
  537. sk->sk_priority = rt_tos2priority(val);
  538. sk_dst_reset(sk);
  539. }
  540. break;
  541. case IP_TTL:
  542. if (optlen < 1)
  543. goto e_inval;
  544. if (val != -1 && (val < 1 || val > 255))
  545. goto e_inval;
  546. inet->uc_ttl = val;
  547. break;
  548. case IP_HDRINCL:
  549. if (sk->sk_type != SOCK_RAW) {
  550. err = -ENOPROTOOPT;
  551. break;
  552. }
  553. inet->hdrincl = val ? 1 : 0;
  554. break;
  555. case IP_NODEFRAG:
  556. if (sk->sk_type != SOCK_RAW) {
  557. err = -ENOPROTOOPT;
  558. break;
  559. }
  560. inet->nodefrag = val ? 1 : 0;
  561. break;
  562. case IP_MTU_DISCOVER:
  563. if (val < IP_PMTUDISC_DONT || val > IP_PMTUDISC_OMIT)
  564. goto e_inval;
  565. inet->pmtudisc = val;
  566. break;
  567. case IP_RECVERR:
  568. inet->recverr = !!val;
  569. if (!val)
  570. skb_queue_purge(&sk->sk_error_queue);
  571. break;
  572. case IP_MULTICAST_TTL:
  573. if (sk->sk_type == SOCK_STREAM)
  574. goto e_inval;
  575. if (optlen < 1)
  576. goto e_inval;
  577. if (val == -1)
  578. val = 1;
  579. if (val < 0 || val > 255)
  580. goto e_inval;
  581. inet->mc_ttl = val;
  582. break;
  583. case IP_MULTICAST_LOOP:
  584. if (optlen < 1)
  585. goto e_inval;
  586. inet->mc_loop = !!val;
  587. break;
  588. case IP_UNICAST_IF:
  589. {
  590. struct net_device *dev = NULL;
  591. int ifindex;
  592. if (optlen != sizeof(int))
  593. goto e_inval;
  594. ifindex = (__force int)ntohl((__force __be32)val);
  595. if (ifindex == 0) {
  596. inet->uc_index = 0;
  597. err = 0;
  598. break;
  599. }
  600. dev = dev_get_by_index(sock_net(sk), ifindex);
  601. err = -EADDRNOTAVAIL;
  602. if (!dev)
  603. break;
  604. dev_put(dev);
  605. err = -EINVAL;
  606. if (sk->sk_bound_dev_if)
  607. break;
  608. inet->uc_index = ifindex;
  609. err = 0;
  610. break;
  611. }
  612. case IP_MULTICAST_IF:
  613. {
  614. struct ip_mreqn mreq;
  615. struct net_device *dev = NULL;
  616. if (sk->sk_type == SOCK_STREAM)
  617. goto e_inval;
  618. /*
  619. * Check the arguments are allowable
  620. */
  621. if (optlen < sizeof(struct in_addr))
  622. goto e_inval;
  623. err = -EFAULT;
  624. if (optlen >= sizeof(struct ip_mreqn)) {
  625. if (copy_from_user(&mreq, optval, sizeof(mreq)))
  626. break;
  627. } else {
  628. memset(&mreq, 0, sizeof(mreq));
  629. if (optlen >= sizeof(struct ip_mreq)) {
  630. if (copy_from_user(&mreq, optval,
  631. sizeof(struct ip_mreq)))
  632. break;
  633. } else if (optlen >= sizeof(struct in_addr)) {
  634. if (copy_from_user(&mreq.imr_address, optval,
  635. sizeof(struct in_addr)))
  636. break;
  637. }
  638. }
  639. if (!mreq.imr_ifindex) {
  640. if (mreq.imr_address.s_addr == htonl(INADDR_ANY)) {
  641. inet->mc_index = 0;
  642. inet->mc_addr = 0;
  643. err = 0;
  644. break;
  645. }
  646. dev = ip_dev_find(sock_net(sk), mreq.imr_address.s_addr);
  647. if (dev)
  648. mreq.imr_ifindex = dev->ifindex;
  649. } else
  650. dev = dev_get_by_index(sock_net(sk), mreq.imr_ifindex);
  651. err = -EADDRNOTAVAIL;
  652. if (!dev)
  653. break;
  654. dev_put(dev);
  655. err = -EINVAL;
  656. if (sk->sk_bound_dev_if &&
  657. mreq.imr_ifindex != sk->sk_bound_dev_if)
  658. break;
  659. inet->mc_index = mreq.imr_ifindex;
  660. inet->mc_addr = mreq.imr_address.s_addr;
  661. err = 0;
  662. break;
  663. }
  664. case IP_ADD_MEMBERSHIP:
  665. case IP_DROP_MEMBERSHIP:
  666. {
  667. struct ip_mreqn mreq;
  668. err = -EPROTO;
  669. if (inet_sk(sk)->is_icsk)
  670. break;
  671. if (optlen < sizeof(struct ip_mreq))
  672. goto e_inval;
  673. err = -EFAULT;
  674. if (optlen >= sizeof(struct ip_mreqn)) {
  675. if (copy_from_user(&mreq, optval, sizeof(mreq)))
  676. break;
  677. } else {
  678. memset(&mreq, 0, sizeof(mreq));
  679. if (copy_from_user(&mreq, optval, sizeof(struct ip_mreq)))
  680. break;
  681. }
  682. if (optname == IP_ADD_MEMBERSHIP)
  683. err = ip_mc_join_group(sk, &mreq);
  684. else
  685. err = ip_mc_leave_group(sk, &mreq);
  686. break;
  687. }
  688. case IP_MSFILTER:
  689. {
  690. struct ip_msfilter *msf;
  691. if (optlen < IP_MSFILTER_SIZE(0))
  692. goto e_inval;
  693. if (optlen > sysctl_optmem_max) {
  694. err = -ENOBUFS;
  695. break;
  696. }
  697. msf = kmalloc(optlen, GFP_KERNEL);
  698. if (!msf) {
  699. err = -ENOBUFS;
  700. break;
  701. }
  702. err = -EFAULT;
  703. if (copy_from_user(msf, optval, optlen)) {
  704. kfree(msf);
  705. break;
  706. }
  707. /* numsrc >= (1G-4) overflow in 32 bits */
  708. if (msf->imsf_numsrc >= 0x3ffffffcU ||
  709. msf->imsf_numsrc > sysctl_igmp_max_msf) {
  710. kfree(msf);
  711. err = -ENOBUFS;
  712. break;
  713. }
  714. if (IP_MSFILTER_SIZE(msf->imsf_numsrc) > optlen) {
  715. kfree(msf);
  716. err = -EINVAL;
  717. break;
  718. }
  719. err = ip_mc_msfilter(sk, msf, 0);
  720. kfree(msf);
  721. break;
  722. }
  723. case IP_BLOCK_SOURCE:
  724. case IP_UNBLOCK_SOURCE:
  725. case IP_ADD_SOURCE_MEMBERSHIP:
  726. case IP_DROP_SOURCE_MEMBERSHIP:
  727. {
  728. struct ip_mreq_source mreqs;
  729. int omode, add;
  730. if (optlen != sizeof(struct ip_mreq_source))
  731. goto e_inval;
  732. if (copy_from_user(&mreqs, optval, sizeof(mreqs))) {
  733. err = -EFAULT;
  734. break;
  735. }
  736. if (optname == IP_BLOCK_SOURCE) {
  737. omode = MCAST_EXCLUDE;
  738. add = 1;
  739. } else if (optname == IP_UNBLOCK_SOURCE) {
  740. omode = MCAST_EXCLUDE;
  741. add = 0;
  742. } else if (optname == IP_ADD_SOURCE_MEMBERSHIP) {
  743. struct ip_mreqn mreq;
  744. mreq.imr_multiaddr.s_addr = mreqs.imr_multiaddr;
  745. mreq.imr_address.s_addr = mreqs.imr_interface;
  746. mreq.imr_ifindex = 0;
  747. err = ip_mc_join_group(sk, &mreq);
  748. if (err && err != -EADDRINUSE)
  749. break;
  750. omode = MCAST_INCLUDE;
  751. add = 1;
  752. } else /* IP_DROP_SOURCE_MEMBERSHIP */ {
  753. omode = MCAST_INCLUDE;
  754. add = 0;
  755. }
  756. err = ip_mc_source(add, omode, sk, &mreqs, 0);
  757. break;
  758. }
  759. case MCAST_JOIN_GROUP:
  760. case MCAST_LEAVE_GROUP:
  761. {
  762. struct group_req greq;
  763. struct sockaddr_in *psin;
  764. struct ip_mreqn mreq;
  765. if (optlen < sizeof(struct group_req))
  766. goto e_inval;
  767. err = -EFAULT;
  768. if (copy_from_user(&greq, optval, sizeof(greq)))
  769. break;
  770. psin = (struct sockaddr_in *)&greq.gr_group;
  771. if (psin->sin_family != AF_INET)
  772. goto e_inval;
  773. memset(&mreq, 0, sizeof(mreq));
  774. mreq.imr_multiaddr = psin->sin_addr;
  775. mreq.imr_ifindex = greq.gr_interface;
  776. if (optname == MCAST_JOIN_GROUP)
  777. err = ip_mc_join_group(sk, &mreq);
  778. else
  779. err = ip_mc_leave_group(sk, &mreq);
  780. break;
  781. }
  782. case MCAST_JOIN_SOURCE_GROUP:
  783. case MCAST_LEAVE_SOURCE_GROUP:
  784. case MCAST_BLOCK_SOURCE:
  785. case MCAST_UNBLOCK_SOURCE:
  786. {
  787. struct group_source_req greqs;
  788. struct ip_mreq_source mreqs;
  789. struct sockaddr_in *psin;
  790. int omode, add;
  791. if (optlen != sizeof(struct group_source_req))
  792. goto e_inval;
  793. if (copy_from_user(&greqs, optval, sizeof(greqs))) {
  794. err = -EFAULT;
  795. break;
  796. }
  797. if (greqs.gsr_group.ss_family != AF_INET ||
  798. greqs.gsr_source.ss_family != AF_INET) {
  799. err = -EADDRNOTAVAIL;
  800. break;
  801. }
  802. psin = (struct sockaddr_in *)&greqs.gsr_group;
  803. mreqs.imr_multiaddr = psin->sin_addr.s_addr;
  804. psin = (struct sockaddr_in *)&greqs.gsr_source;
  805. mreqs.imr_sourceaddr = psin->sin_addr.s_addr;
  806. mreqs.imr_interface = 0; /* use index for mc_source */
  807. if (optname == MCAST_BLOCK_SOURCE) {
  808. omode = MCAST_EXCLUDE;
  809. add = 1;
  810. } else if (optname == MCAST_UNBLOCK_SOURCE) {
  811. omode = MCAST_EXCLUDE;
  812. add = 0;
  813. } else if (optname == MCAST_JOIN_SOURCE_GROUP) {
  814. struct ip_mreqn mreq;
  815. psin = (struct sockaddr_in *)&greqs.gsr_group;
  816. mreq.imr_multiaddr = psin->sin_addr;
  817. mreq.imr_address.s_addr = 0;
  818. mreq.imr_ifindex = greqs.gsr_interface;
  819. err = ip_mc_join_group(sk, &mreq);
  820. if (err && err != -EADDRINUSE)
  821. break;
  822. greqs.gsr_interface = mreq.imr_ifindex;
  823. omode = MCAST_INCLUDE;
  824. add = 1;
  825. } else /* MCAST_LEAVE_SOURCE_GROUP */ {
  826. omode = MCAST_INCLUDE;
  827. add = 0;
  828. }
  829. err = ip_mc_source(add, omode, sk, &mreqs,
  830. greqs.gsr_interface);
  831. break;
  832. }
  833. case MCAST_MSFILTER:
  834. {
  835. struct sockaddr_in *psin;
  836. struct ip_msfilter *msf = NULL;
  837. struct group_filter *gsf = NULL;
  838. int msize, i, ifindex;
  839. if (optlen < GROUP_FILTER_SIZE(0))
  840. goto e_inval;
  841. if (optlen > sysctl_optmem_max) {
  842. err = -ENOBUFS;
  843. break;
  844. }
  845. gsf = kmalloc(optlen, GFP_KERNEL);
  846. if (!gsf) {
  847. err = -ENOBUFS;
  848. break;
  849. }
  850. err = -EFAULT;
  851. if (copy_from_user(gsf, optval, optlen))
  852. goto mc_msf_out;
  853. /* numsrc >= (4G-140)/128 overflow in 32 bits */
  854. if (gsf->gf_numsrc >= 0x1ffffff ||
  855. gsf->gf_numsrc > sysctl_igmp_max_msf) {
  856. err = -ENOBUFS;
  857. goto mc_msf_out;
  858. }
  859. if (GROUP_FILTER_SIZE(gsf->gf_numsrc) > optlen) {
  860. err = -EINVAL;
  861. goto mc_msf_out;
  862. }
  863. msize = IP_MSFILTER_SIZE(gsf->gf_numsrc);
  864. msf = kmalloc(msize, GFP_KERNEL);
  865. if (!msf) {
  866. err = -ENOBUFS;
  867. goto mc_msf_out;
  868. }
  869. ifindex = gsf->gf_interface;
  870. psin = (struct sockaddr_in *)&gsf->gf_group;
  871. if (psin->sin_family != AF_INET) {
  872. err = -EADDRNOTAVAIL;
  873. goto mc_msf_out;
  874. }
  875. msf->imsf_multiaddr = psin->sin_addr.s_addr;
  876. msf->imsf_interface = 0;
  877. msf->imsf_fmode = gsf->gf_fmode;
  878. msf->imsf_numsrc = gsf->gf_numsrc;
  879. err = -EADDRNOTAVAIL;
  880. for (i = 0; i < gsf->gf_numsrc; ++i) {
  881. psin = (struct sockaddr_in *)&gsf->gf_slist[i];
  882. if (psin->sin_family != AF_INET)
  883. goto mc_msf_out;
  884. msf->imsf_slist[i] = psin->sin_addr.s_addr;
  885. }
  886. kfree(gsf);
  887. gsf = NULL;
  888. err = ip_mc_msfilter(sk, msf, ifindex);
  889. mc_msf_out:
  890. kfree(msf);
  891. kfree(gsf);
  892. break;
  893. }
  894. case IP_MULTICAST_ALL:
  895. if (optlen < 1)
  896. goto e_inval;
  897. if (val != 0 && val != 1)
  898. goto e_inval;
  899. inet->mc_all = val;
  900. break;
  901. case IP_ROUTER_ALERT:
  902. err = ip_ra_control(sk, val ? 1 : 0, NULL);
  903. break;
  904. case IP_FREEBIND:
  905. if (optlen < 1)
  906. goto e_inval;
  907. inet->freebind = !!val;
  908. break;
  909. case IP_IPSEC_POLICY:
  910. case IP_XFRM_POLICY:
  911. err = -EPERM;
  912. if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
  913. break;
  914. err = xfrm_user_policy(sk, optname, optval, optlen);
  915. break;
  916. case IP_TRANSPARENT:
  917. if (!!val && !ns_capable(sock_net(sk)->user_ns, CAP_NET_RAW) &&
  918. !ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) {
  919. err = -EPERM;
  920. break;
  921. }
  922. if (optlen < 1)
  923. goto e_inval;
  924. inet->transparent = !!val;
  925. break;
  926. case IP_MINTTL:
  927. if (optlen < 1)
  928. goto e_inval;
  929. if (val < 0 || val > 255)
  930. goto e_inval;
  931. inet->min_ttl = val;
  932. break;
  933. default:
  934. err = -ENOPROTOOPT;
  935. break;
  936. }
  937. release_sock(sk);
  938. return err;
  939. e_inval:
  940. release_sock(sk);
  941. return -EINVAL;
  942. }
  943. /**
  944. * ipv4_pktinfo_prepare - transfer some info from rtable to skb
  945. * @sk: socket
  946. * @skb: buffer
  947. *
  948. * To support IP_CMSG_PKTINFO option, we store rt_iif and specific
  949. * destination in skb->cb[] before dst drop.
  950. * This way, receiver doesn't make cache line misses to read rtable.
  951. */
  952. void ipv4_pktinfo_prepare(const struct sock *sk, struct sk_buff *skb)
  953. {
  954. struct in_pktinfo *pktinfo = PKTINFO_SKB_CB(skb);
  955. bool prepare = (inet_sk(sk)->cmsg_flags & IP_CMSG_PKTINFO) ||
  956. ipv6_sk_rxinfo(sk);
  957. if (prepare && skb_rtable(skb)) {
  958. pktinfo->ipi_ifindex = inet_iif(skb);
  959. pktinfo->ipi_spec_dst.s_addr = fib_compute_spec_dst(skb);
  960. } else {
  961. pktinfo->ipi_ifindex = 0;
  962. pktinfo->ipi_spec_dst.s_addr = 0;
  963. }
  964. skb_dst_drop(skb);
  965. }
  966. int ip_setsockopt(struct sock *sk, int level,
  967. int optname, char __user *optval, unsigned int optlen)
  968. {
  969. int err;
  970. if (level != SOL_IP)
  971. return -ENOPROTOOPT;
  972. err = do_ip_setsockopt(sk, level, optname, optval, optlen);
  973. #ifdef CONFIG_NETFILTER
  974. /* we need to exclude all possible ENOPROTOOPTs except default case */
  975. if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
  976. optname != IP_IPSEC_POLICY &&
  977. optname != IP_XFRM_POLICY &&
  978. !ip_mroute_opt(optname)) {
  979. lock_sock(sk);
  980. err = nf_setsockopt(sk, PF_INET, optname, optval, optlen);
  981. release_sock(sk);
  982. }
  983. #endif
  984. return err;
  985. }
  986. EXPORT_SYMBOL(ip_setsockopt);
  987. #ifdef CONFIG_COMPAT
  988. int compat_ip_setsockopt(struct sock *sk, int level, int optname,
  989. char __user *optval, unsigned int optlen)
  990. {
  991. int err;
  992. if (level != SOL_IP)
  993. return -ENOPROTOOPT;
  994. if (optname >= MCAST_JOIN_GROUP && optname <= MCAST_MSFILTER)
  995. return compat_mc_setsockopt(sk, level, optname, optval, optlen,
  996. ip_setsockopt);
  997. err = do_ip_setsockopt(sk, level, optname, optval, optlen);
  998. #ifdef CONFIG_NETFILTER
  999. /* we need to exclude all possible ENOPROTOOPTs except default case */
  1000. if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
  1001. optname != IP_IPSEC_POLICY &&
  1002. optname != IP_XFRM_POLICY &&
  1003. !ip_mroute_opt(optname)) {
  1004. lock_sock(sk);
  1005. err = compat_nf_setsockopt(sk, PF_INET, optname,
  1006. optval, optlen);
  1007. release_sock(sk);
  1008. }
  1009. #endif
  1010. return err;
  1011. }
  1012. EXPORT_SYMBOL(compat_ip_setsockopt);
  1013. #endif
  1014. /*
  1015. * Get the options. Note for future reference. The GET of IP options gets
  1016. * the _received_ ones. The set sets the _sent_ ones.
  1017. */
  1018. static int do_ip_getsockopt(struct sock *sk, int level, int optname,
  1019. char __user *optval, int __user *optlen, unsigned int flags)
  1020. {
  1021. struct inet_sock *inet = inet_sk(sk);
  1022. int val;
  1023. int len;
  1024. if (level != SOL_IP)
  1025. return -EOPNOTSUPP;
  1026. if (ip_mroute_opt(optname))
  1027. return ip_mroute_getsockopt(sk, optname, optval, optlen);
  1028. if (get_user(len, optlen))
  1029. return -EFAULT;
  1030. if (len < 0)
  1031. return -EINVAL;
  1032. lock_sock(sk);
  1033. switch (optname) {
  1034. case IP_OPTIONS:
  1035. {
  1036. unsigned char optbuf[sizeof(struct ip_options)+40];
  1037. struct ip_options *opt = (struct ip_options *)optbuf;
  1038. struct ip_options_rcu *inet_opt;
  1039. inet_opt = rcu_dereference_protected(inet->inet_opt,
  1040. sock_owned_by_user(sk));
  1041. opt->optlen = 0;
  1042. if (inet_opt)
  1043. memcpy(optbuf, &inet_opt->opt,
  1044. sizeof(struct ip_options) +
  1045. inet_opt->opt.optlen);
  1046. release_sock(sk);
  1047. if (opt->optlen == 0)
  1048. return put_user(0, optlen);
  1049. ip_options_undo(opt);
  1050. len = min_t(unsigned int, len, opt->optlen);
  1051. if (put_user(len, optlen))
  1052. return -EFAULT;
  1053. if (copy_to_user(optval, opt->__data, len))
  1054. return -EFAULT;
  1055. return 0;
  1056. }
  1057. case IP_PKTINFO:
  1058. val = (inet->cmsg_flags & IP_CMSG_PKTINFO) != 0;
  1059. break;
  1060. case IP_RECVTTL:
  1061. val = (inet->cmsg_flags & IP_CMSG_TTL) != 0;
  1062. break;
  1063. case IP_RECVTOS:
  1064. val = (inet->cmsg_flags & IP_CMSG_TOS) != 0;
  1065. break;
  1066. case IP_RECVOPTS:
  1067. val = (inet->cmsg_flags & IP_CMSG_RECVOPTS) != 0;
  1068. break;
  1069. case IP_RETOPTS:
  1070. val = (inet->cmsg_flags & IP_CMSG_RETOPTS) != 0;
  1071. break;
  1072. case IP_PASSSEC:
  1073. val = (inet->cmsg_flags & IP_CMSG_PASSSEC) != 0;
  1074. break;
  1075. case IP_RECVORIGDSTADDR:
  1076. val = (inet->cmsg_flags & IP_CMSG_ORIGDSTADDR) != 0;
  1077. break;
  1078. case IP_TOS:
  1079. val = inet->tos;
  1080. break;
  1081. case IP_TTL:
  1082. val = (inet->uc_ttl == -1 ?
  1083. sysctl_ip_default_ttl :
  1084. inet->uc_ttl);
  1085. break;
  1086. case IP_HDRINCL:
  1087. val = inet->hdrincl;
  1088. break;
  1089. case IP_NODEFRAG:
  1090. val = inet->nodefrag;
  1091. break;
  1092. case IP_MTU_DISCOVER:
  1093. val = inet->pmtudisc;
  1094. break;
  1095. case IP_MTU:
  1096. {
  1097. struct dst_entry *dst;
  1098. val = 0;
  1099. dst = sk_dst_get(sk);
  1100. if (dst) {
  1101. val = dst_mtu(dst);
  1102. dst_release(dst);
  1103. }
  1104. if (!val) {
  1105. release_sock(sk);
  1106. return -ENOTCONN;
  1107. }
  1108. break;
  1109. }
  1110. case IP_RECVERR:
  1111. val = inet->recverr;
  1112. break;
  1113. case IP_MULTICAST_TTL:
  1114. val = inet->mc_ttl;
  1115. break;
  1116. case IP_MULTICAST_LOOP:
  1117. val = inet->mc_loop;
  1118. break;
  1119. case IP_UNICAST_IF:
  1120. val = (__force int)htonl((__u32) inet->uc_index);
  1121. break;
  1122. case IP_MULTICAST_IF:
  1123. {
  1124. struct in_addr addr;
  1125. len = min_t(unsigned int, len, sizeof(struct in_addr));
  1126. addr.s_addr = inet->mc_addr;
  1127. release_sock(sk);
  1128. if (put_user(len, optlen))
  1129. return -EFAULT;
  1130. if (copy_to_user(optval, &addr, len))
  1131. return -EFAULT;
  1132. return 0;
  1133. }
  1134. case IP_MSFILTER:
  1135. {
  1136. struct ip_msfilter msf;
  1137. int err;
  1138. if (len < IP_MSFILTER_SIZE(0)) {
  1139. release_sock(sk);
  1140. return -EINVAL;
  1141. }
  1142. if (copy_from_user(&msf, optval, IP_MSFILTER_SIZE(0))) {
  1143. release_sock(sk);
  1144. return -EFAULT;
  1145. }
  1146. err = ip_mc_msfget(sk, &msf,
  1147. (struct ip_msfilter __user *)optval, optlen);
  1148. release_sock(sk);
  1149. return err;
  1150. }
  1151. case MCAST_MSFILTER:
  1152. {
  1153. struct group_filter gsf;
  1154. int err;
  1155. if (len < GROUP_FILTER_SIZE(0)) {
  1156. release_sock(sk);
  1157. return -EINVAL;
  1158. }
  1159. if (copy_from_user(&gsf, optval, GROUP_FILTER_SIZE(0))) {
  1160. release_sock(sk);
  1161. return -EFAULT;
  1162. }
  1163. err = ip_mc_gsfget(sk, &gsf,
  1164. (struct group_filter __user *)optval,
  1165. optlen);
  1166. release_sock(sk);
  1167. return err;
  1168. }
  1169. case IP_MULTICAST_ALL:
  1170. val = inet->mc_all;
  1171. break;
  1172. case IP_PKTOPTIONS:
  1173. {
  1174. struct msghdr msg;
  1175. release_sock(sk);
  1176. if (sk->sk_type != SOCK_STREAM)
  1177. return -ENOPROTOOPT;
  1178. msg.msg_control = (__force void *) optval;
  1179. msg.msg_controllen = len;
  1180. msg.msg_flags = flags;
  1181. if (inet->cmsg_flags & IP_CMSG_PKTINFO) {
  1182. struct in_pktinfo info;
  1183. info.ipi_addr.s_addr = inet->inet_rcv_saddr;
  1184. info.ipi_spec_dst.s_addr = inet->inet_rcv_saddr;
  1185. info.ipi_ifindex = inet->mc_index;
  1186. put_cmsg(&msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
  1187. }
  1188. if (inet->cmsg_flags & IP_CMSG_TTL) {
  1189. int hlim = inet->mc_ttl;
  1190. put_cmsg(&msg, SOL_IP, IP_TTL, sizeof(hlim), &hlim);
  1191. }
  1192. if (inet->cmsg_flags & IP_CMSG_TOS) {
  1193. int tos = inet->rcv_tos;
  1194. put_cmsg(&msg, SOL_IP, IP_TOS, sizeof(tos), &tos);
  1195. }
  1196. len -= msg.msg_controllen;
  1197. return put_user(len, optlen);
  1198. }
  1199. case IP_FREEBIND:
  1200. val = inet->freebind;
  1201. break;
  1202. case IP_TRANSPARENT:
  1203. val = inet->transparent;
  1204. break;
  1205. case IP_MINTTL:
  1206. val = inet->min_ttl;
  1207. break;
  1208. default:
  1209. release_sock(sk);
  1210. return -ENOPROTOOPT;
  1211. }
  1212. release_sock(sk);
  1213. if (len < sizeof(int) && len > 0 && val >= 0 && val <= 255) {
  1214. unsigned char ucval = (unsigned char)val;
  1215. len = 1;
  1216. if (put_user(len, optlen))
  1217. return -EFAULT;
  1218. if (copy_to_user(optval, &ucval, 1))
  1219. return -EFAULT;
  1220. } else {
  1221. len = min_t(unsigned int, sizeof(int), len);
  1222. if (put_user(len, optlen))
  1223. return -EFAULT;
  1224. if (copy_to_user(optval, &val, len))
  1225. return -EFAULT;
  1226. }
  1227. return 0;
  1228. }
  1229. int ip_getsockopt(struct sock *sk, int level,
  1230. int optname, char __user *optval, int __user *optlen)
  1231. {
  1232. int err;
  1233. err = do_ip_getsockopt(sk, level, optname, optval, optlen, 0);
  1234. #ifdef CONFIG_NETFILTER
  1235. /* we need to exclude all possible ENOPROTOOPTs except default case */
  1236. if (err == -ENOPROTOOPT && optname != IP_PKTOPTIONS &&
  1237. !ip_mroute_opt(optname)) {
  1238. int len;
  1239. if (get_user(len, optlen))
  1240. return -EFAULT;
  1241. lock_sock(sk);
  1242. err = nf_getsockopt(sk, PF_INET, optname, optval,
  1243. &len);
  1244. release_sock(sk);
  1245. if (err >= 0)
  1246. err = put_user(len, optlen);
  1247. return err;
  1248. }
  1249. #endif
  1250. return err;
  1251. }
  1252. EXPORT_SYMBOL(ip_getsockopt);
  1253. #ifdef CONFIG_COMPAT
  1254. int compat_ip_getsockopt(struct sock *sk, int level, int optname,
  1255. char __user *optval, int __user *optlen)
  1256. {
  1257. int err;
  1258. if (optname == MCAST_MSFILTER)
  1259. return compat_mc_getsockopt(sk, level, optname, optval, optlen,
  1260. ip_getsockopt);
  1261. err = do_ip_getsockopt(sk, level, optname, optval, optlen,
  1262. MSG_CMSG_COMPAT);
  1263. #ifdef CONFIG_NETFILTER
  1264. /* we need to exclude all possible ENOPROTOOPTs except default case */
  1265. if (err == -ENOPROTOOPT && optname != IP_PKTOPTIONS &&
  1266. !ip_mroute_opt(optname)) {
  1267. int len;
  1268. if (get_user(len, optlen))
  1269. return -EFAULT;
  1270. lock_sock(sk);
  1271. err = compat_nf_getsockopt(sk, PF_INET, optname, optval, &len);
  1272. release_sock(sk);
  1273. if (err >= 0)
  1274. err = put_user(len, optlen);
  1275. return err;
  1276. }
  1277. #endif
  1278. return err;
  1279. }
  1280. EXPORT_SYMBOL(compat_ip_getsockopt);
  1281. #endif