ip_sockglue.c 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221
  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. * Version: $Id: ip_sockglue.c,v 1.1.1.1 2007/06/12 07:27:14 eyryu Exp $
  9. *
  10. * Authors: see ip.c
  11. *
  12. * Fixes:
  13. * Many : Split from ip.c , see ip.c for history.
  14. * Martin Mares : TOS setting fixed.
  15. * Alan Cox : Fixed a couple of oopses in Martin's
  16. * TOS tweaks.
  17. * Mike McLagan : Routing by source
  18. */
  19. #include <linux/module.h>
  20. #include <linux/types.h>
  21. #include <linux/mm.h>
  22. #include <linux/skbuff.h>
  23. #include <linux/ip.h>
  24. #include <linux/icmp.h>
  25. #include <linux/inetdevice.h>
  26. #include <linux/netdevice.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/route.h>
  37. #include <net/xfrm.h>
  38. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  39. #include <net/transp_v6.h>
  40. #endif
  41. #include <linux/errqueue.h>
  42. #include <asm/uaccess.h>
  43. #define IP_CMSG_PKTINFO 1
  44. #define IP_CMSG_TTL 2
  45. #define IP_CMSG_TOS 4
  46. #define IP_CMSG_RECVOPTS 8
  47. #define IP_CMSG_RETOPTS 16
  48. #define IP_CMSG_PASSSEC 32
  49. /*
  50. * SOL_IP control messages.
  51. */
  52. static void ip_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb)
  53. {
  54. struct in_pktinfo info;
  55. struct rtable *rt = (struct rtable *)skb->dst;
  56. info.ipi_addr.s_addr = skb->nh.iph->daddr;
  57. if (rt) {
  58. info.ipi_ifindex = rt->rt_iif;
  59. info.ipi_spec_dst.s_addr = rt->rt_spec_dst;
  60. } else {
  61. info.ipi_ifindex = 0;
  62. info.ipi_spec_dst.s_addr = 0;
  63. }
  64. put_cmsg(msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
  65. }
  66. static void ip_cmsg_recv_ttl(struct msghdr *msg, struct sk_buff *skb)
  67. {
  68. int ttl = skb->nh.iph->ttl;
  69. put_cmsg(msg, SOL_IP, IP_TTL, sizeof(int), &ttl);
  70. }
  71. static void ip_cmsg_recv_tos(struct msghdr *msg, struct sk_buff *skb)
  72. {
  73. put_cmsg(msg, SOL_IP, IP_TOS, 1, &skb->nh.iph->tos);
  74. }
  75. static void ip_cmsg_recv_opts(struct msghdr *msg, struct sk_buff *skb)
  76. {
  77. if (IPCB(skb)->opt.optlen == 0)
  78. return;
  79. put_cmsg(msg, SOL_IP, IP_RECVOPTS, IPCB(skb)->opt.optlen, skb->nh.iph+1);
  80. }
  81. static void ip_cmsg_recv_retopts(struct msghdr *msg, struct sk_buff *skb)
  82. {
  83. unsigned char optbuf[sizeof(struct ip_options) + 40];
  84. struct ip_options * opt = (struct ip_options*)optbuf;
  85. if (IPCB(skb)->opt.optlen == 0)
  86. return;
  87. if (ip_options_echo(opt, skb)) {
  88. msg->msg_flags |= MSG_CTRUNC;
  89. return;
  90. }
  91. ip_options_undo(opt);
  92. put_cmsg(msg, SOL_IP, IP_RETOPTS, opt->optlen, opt->__data);
  93. }
  94. static void ip_cmsg_recv_security(struct msghdr *msg, struct sk_buff *skb)
  95. {
  96. char *secdata;
  97. u32 seclen, secid;
  98. int err;
  99. err = security_socket_getpeersec_dgram(NULL, skb, &secid);
  100. if (err)
  101. return;
  102. err = security_secid_to_secctx(secid, &secdata, &seclen);
  103. if (err)
  104. return;
  105. put_cmsg(msg, SOL_IP, SCM_SECURITY, seclen, secdata);
  106. security_release_secctx(secdata, seclen);
  107. }
  108. void ip_cmsg_recv(struct msghdr *msg, struct sk_buff *skb)
  109. {
  110. struct inet_sock *inet = inet_sk(skb->sk);
  111. unsigned flags = inet->cmsg_flags;
  112. /* Ordered by supposed usage frequency */
  113. if (flags & 1)
  114. ip_cmsg_recv_pktinfo(msg, skb);
  115. if ((flags>>=1) == 0)
  116. return;
  117. if (flags & 1)
  118. ip_cmsg_recv_ttl(msg, skb);
  119. if ((flags>>=1) == 0)
  120. return;
  121. if (flags & 1)
  122. ip_cmsg_recv_tos(msg, skb);
  123. if ((flags>>=1) == 0)
  124. return;
  125. if (flags & 1)
  126. ip_cmsg_recv_opts(msg, skb);
  127. if ((flags>>=1) == 0)
  128. return;
  129. if (flags & 1)
  130. ip_cmsg_recv_retopts(msg, skb);
  131. if ((flags>>=1) == 0)
  132. return;
  133. if (flags & 1)
  134. ip_cmsg_recv_security(msg, skb);
  135. }
  136. int ip_cmsg_send(struct msghdr *msg, struct ipcm_cookie *ipc)
  137. {
  138. int err;
  139. struct cmsghdr *cmsg;
  140. for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
  141. if (!CMSG_OK(msg, cmsg))
  142. return -EINVAL;
  143. if (cmsg->cmsg_level != SOL_IP)
  144. continue;
  145. switch (cmsg->cmsg_type) {
  146. case IP_RETOPTS:
  147. err = cmsg->cmsg_len - CMSG_ALIGN(sizeof(struct cmsghdr));
  148. err = ip_options_get(&ipc->opt, CMSG_DATA(cmsg), err < 40 ? err : 40);
  149. if (err)
  150. return err;
  151. break;
  152. case IP_PKTINFO:
  153. {
  154. struct in_pktinfo *info;
  155. if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct in_pktinfo)))
  156. return -EINVAL;
  157. info = (struct in_pktinfo *)CMSG_DATA(cmsg);
  158. ipc->oif = info->ipi_ifindex;
  159. ipc->addr = info->ipi_spec_dst.s_addr;
  160. break;
  161. }
  162. default:
  163. return -EINVAL;
  164. }
  165. }
  166. return 0;
  167. }
  168. /* Special input handler for packets caught by router alert option.
  169. They are selected only by protocol field, and then processed likely
  170. local ones; but only if someone wants them! Otherwise, router
  171. not running rsvpd will kill RSVP.
  172. It is user level problem, what it will make with them.
  173. I have no idea, how it will masquearde or NAT them (it is joke, joke :-)),
  174. but receiver should be enough clever f.e. to forward mtrace requests,
  175. sent to multicast group to reach destination designated router.
  176. */
  177. struct ip_ra_chain *ip_ra_chain;
  178. DEFINE_RWLOCK(ip_ra_lock);
  179. int ip_ra_control(struct sock *sk, unsigned char on, void (*destructor)(struct sock *))
  180. {
  181. struct ip_ra_chain *ra, *new_ra, **rap;
  182. if (sk->sk_type != SOCK_RAW || inet_sk(sk)->num == IPPROTO_RAW)
  183. return -EINVAL;
  184. new_ra = on ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
  185. write_lock_bh(&ip_ra_lock);
  186. for (rap = &ip_ra_chain; (ra=*rap) != NULL; rap = &ra->next) {
  187. if (ra->sk == sk) {
  188. if (on) {
  189. write_unlock_bh(&ip_ra_lock);
  190. kfree(new_ra);
  191. return -EADDRINUSE;
  192. }
  193. *rap = ra->next;
  194. write_unlock_bh(&ip_ra_lock);
  195. if (ra->destructor)
  196. ra->destructor(sk);
  197. sock_put(sk);
  198. kfree(ra);
  199. return 0;
  200. }
  201. }
  202. if (new_ra == NULL) {
  203. write_unlock_bh(&ip_ra_lock);
  204. return -ENOBUFS;
  205. }
  206. new_ra->sk = sk;
  207. new_ra->destructor = destructor;
  208. new_ra->next = ra;
  209. *rap = new_ra;
  210. sock_hold(sk);
  211. write_unlock_bh(&ip_ra_lock);
  212. return 0;
  213. }
  214. void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
  215. __be16 port, u32 info, u8 *payload)
  216. {
  217. struct inet_sock *inet = inet_sk(sk);
  218. struct sock_exterr_skb *serr;
  219. if (!inet->recverr)
  220. return;
  221. skb = skb_clone(skb, GFP_ATOMIC);
  222. if (!skb)
  223. return;
  224. serr = SKB_EXT_ERR(skb);
  225. serr->ee.ee_errno = err;
  226. serr->ee.ee_origin = SO_EE_ORIGIN_ICMP;
  227. serr->ee.ee_type = skb->h.icmph->type;
  228. serr->ee.ee_code = skb->h.icmph->code;
  229. serr->ee.ee_pad = 0;
  230. serr->ee.ee_info = info;
  231. serr->ee.ee_data = 0;
  232. serr->addr_offset = (u8*)&(((struct iphdr*)(skb->h.icmph+1))->daddr) - skb->nh.raw;
  233. serr->port = port;
  234. skb->h.raw = payload;
  235. if (!skb_pull(skb, payload - skb->data) ||
  236. sock_queue_err_skb(sk, skb))
  237. kfree_skb(skb);
  238. }
  239. void ip_local_error(struct sock *sk, int err, __be32 daddr, __be16 port, u32 info)
  240. {
  241. struct inet_sock *inet = inet_sk(sk);
  242. struct sock_exterr_skb *serr;
  243. struct iphdr *iph;
  244. struct sk_buff *skb;
  245. if (!inet->recverr)
  246. return;
  247. skb = alloc_skb(sizeof(struct iphdr), GFP_ATOMIC);
  248. if (!skb)
  249. return;
  250. iph = (struct iphdr*)skb_put(skb, sizeof(struct iphdr));
  251. skb->nh.iph = iph;
  252. iph->daddr = daddr;
  253. serr = SKB_EXT_ERR(skb);
  254. serr->ee.ee_errno = err;
  255. serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
  256. serr->ee.ee_type = 0;
  257. serr->ee.ee_code = 0;
  258. serr->ee.ee_pad = 0;
  259. serr->ee.ee_info = info;
  260. serr->ee.ee_data = 0;
  261. serr->addr_offset = (u8*)&iph->daddr - skb->nh.raw;
  262. serr->port = port;
  263. skb->h.raw = skb->tail;
  264. __skb_pull(skb, skb->tail - skb->data);
  265. if (sock_queue_err_skb(sk, skb))
  266. kfree_skb(skb);
  267. }
  268. /*
  269. * Handle MSG_ERRQUEUE
  270. */
  271. int ip_recv_error(struct sock *sk, struct msghdr *msg, int len)
  272. {
  273. struct sock_exterr_skb *serr;
  274. struct sk_buff *skb, *skb2;
  275. struct sockaddr_in *sin;
  276. struct {
  277. struct sock_extended_err ee;
  278. struct sockaddr_in offender;
  279. } errhdr;
  280. int err;
  281. int copied;
  282. err = -EAGAIN;
  283. skb = skb_dequeue(&sk->sk_error_queue);
  284. if (skb == NULL)
  285. goto out;
  286. copied = skb->len;
  287. if (copied > len) {
  288. msg->msg_flags |= MSG_TRUNC;
  289. copied = len;
  290. }
  291. err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
  292. if (err)
  293. goto out_free_skb;
  294. sock_recv_timestamp(msg, sk, skb);
  295. serr = SKB_EXT_ERR(skb);
  296. sin = (struct sockaddr_in *)msg->msg_name;
  297. if (sin) {
  298. sin->sin_family = AF_INET;
  299. sin->sin_addr.s_addr = *(__be32*)(skb->nh.raw + serr->addr_offset);
  300. sin->sin_port = serr->port;
  301. memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
  302. }
  303. memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
  304. sin = &errhdr.offender;
  305. sin->sin_family = AF_UNSPEC;
  306. if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP) {
  307. struct inet_sock *inet = inet_sk(sk);
  308. sin->sin_family = AF_INET;
  309. sin->sin_addr.s_addr = skb->nh.iph->saddr;
  310. sin->sin_port = 0;
  311. memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
  312. if (inet->cmsg_flags)
  313. ip_cmsg_recv(msg, skb);
  314. }
  315. put_cmsg(msg, SOL_IP, IP_RECVERR, sizeof(errhdr), &errhdr);
  316. /* Now we could try to dump offended packet options */
  317. msg->msg_flags |= MSG_ERRQUEUE;
  318. err = copied;
  319. /* Reset and regenerate socket error */
  320. spin_lock_bh(&sk->sk_error_queue.lock);
  321. sk->sk_err = 0;
  322. if ((skb2 = skb_peek(&sk->sk_error_queue)) != NULL) {
  323. sk->sk_err = SKB_EXT_ERR(skb2)->ee.ee_errno;
  324. spin_unlock_bh(&sk->sk_error_queue.lock);
  325. sk->sk_error_report(sk);
  326. } else
  327. spin_unlock_bh(&sk->sk_error_queue.lock);
  328. out_free_skb:
  329. kfree_skb(skb);
  330. out:
  331. return err;
  332. }
  333. /*
  334. * Socket option code for IP. This is the end of the line after any TCP,UDP etc options on
  335. * an IP socket.
  336. */
  337. static int do_ip_setsockopt(struct sock *sk, int level,
  338. int optname, char __user *optval, int optlen)
  339. {
  340. struct inet_sock *inet = inet_sk(sk);
  341. int val=0,err;
  342. if (((1<<optname) & ((1<<IP_PKTINFO) | (1<<IP_RECVTTL) |
  343. (1<<IP_RECVOPTS) | (1<<IP_RECVTOS) |
  344. (1<<IP_RETOPTS) | (1<<IP_TOS) |
  345. (1<<IP_TTL) | (1<<IP_HDRINCL) |
  346. (1<<IP_MTU_DISCOVER) | (1<<IP_RECVERR) |
  347. (1<<IP_ROUTER_ALERT) | (1<<IP_FREEBIND) |
  348. (1<<IP_PASSSEC))) ||
  349. optname == IP_MULTICAST_TTL ||
  350. optname == IP_MULTICAST_LOOP) {
  351. if (optlen >= sizeof(int)) {
  352. if (get_user(val, (int __user *) optval))
  353. return -EFAULT;
  354. } else if (optlen >= sizeof(char)) {
  355. unsigned char ucval;
  356. if (get_user(ucval, (unsigned char __user *) optval))
  357. return -EFAULT;
  358. val = (int) ucval;
  359. }
  360. }
  361. /* If optlen==0, it is equivalent to val == 0 */
  362. #ifdef CONFIG_IP_MROUTE
  363. if (optname >= MRT_BASE && optname <= (MRT_BASE + 10))
  364. return ip_mroute_setsockopt(sk,optname,optval,optlen);
  365. #endif
  366. err = 0;
  367. lock_sock(sk);
  368. switch (optname) {
  369. case IP_OPTIONS:
  370. {
  371. struct ip_options * opt = NULL;
  372. if (optlen > 40 || optlen < 0)
  373. goto e_inval;
  374. err = ip_options_get_from_user(&opt, optval, optlen);
  375. if (err)
  376. break;
  377. if (inet->is_icsk) {
  378. struct inet_connection_sock *icsk = inet_csk(sk);
  379. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  380. if (sk->sk_family == PF_INET ||
  381. (!((1 << sk->sk_state) &
  382. (TCPF_LISTEN | TCPF_CLOSE)) &&
  383. inet->daddr != LOOPBACK4_IPV6)) {
  384. #endif
  385. if (inet->opt)
  386. icsk->icsk_ext_hdr_len -= inet->opt->optlen;
  387. if (opt)
  388. icsk->icsk_ext_hdr_len += opt->optlen;
  389. icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie);
  390. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  391. }
  392. #endif
  393. }
  394. opt = xchg(&inet->opt, opt);
  395. kfree(opt);
  396. break;
  397. }
  398. case IP_PKTINFO:
  399. if (val)
  400. inet->cmsg_flags |= IP_CMSG_PKTINFO;
  401. else
  402. inet->cmsg_flags &= ~IP_CMSG_PKTINFO;
  403. break;
  404. case IP_RECVTTL:
  405. if (val)
  406. inet->cmsg_flags |= IP_CMSG_TTL;
  407. else
  408. inet->cmsg_flags &= ~IP_CMSG_TTL;
  409. break;
  410. case IP_RECVTOS:
  411. if (val)
  412. inet->cmsg_flags |= IP_CMSG_TOS;
  413. else
  414. inet->cmsg_flags &= ~IP_CMSG_TOS;
  415. break;
  416. case IP_RECVOPTS:
  417. if (val)
  418. inet->cmsg_flags |= IP_CMSG_RECVOPTS;
  419. else
  420. inet->cmsg_flags &= ~IP_CMSG_RECVOPTS;
  421. break;
  422. case IP_RETOPTS:
  423. if (val)
  424. inet->cmsg_flags |= IP_CMSG_RETOPTS;
  425. else
  426. inet->cmsg_flags &= ~IP_CMSG_RETOPTS;
  427. break;
  428. case IP_PASSSEC:
  429. if (val)
  430. inet->cmsg_flags |= IP_CMSG_PASSSEC;
  431. else
  432. inet->cmsg_flags &= ~IP_CMSG_PASSSEC;
  433. break;
  434. case IP_TOS: /* This sets both TOS and Precedence */
  435. if (sk->sk_type == SOCK_STREAM) {
  436. val &= ~3;
  437. val |= inet->tos & 3;
  438. }
  439. if (IPTOS_PREC(val) >= IPTOS_PREC_CRITIC_ECP &&
  440. !capable(CAP_NET_ADMIN)) {
  441. err = -EPERM;
  442. break;
  443. }
  444. if (inet->tos != val) {
  445. inet->tos = val;
  446. sk->sk_priority = rt_tos2priority(val);
  447. sk_dst_reset(sk);
  448. }
  449. break;
  450. case IP_TTL:
  451. if (optlen<1)
  452. goto e_inval;
  453. if (val != -1 && (val < 1 || val>255))
  454. goto e_inval;
  455. inet->uc_ttl = val;
  456. break;
  457. case IP_HDRINCL:
  458. if (sk->sk_type != SOCK_RAW) {
  459. err = -ENOPROTOOPT;
  460. break;
  461. }
  462. inet->hdrincl = val ? 1 : 0;
  463. break;
  464. case IP_MTU_DISCOVER:
  465. if (val<0 || val>2)
  466. goto e_inval;
  467. inet->pmtudisc = val;
  468. break;
  469. case IP_RECVERR:
  470. inet->recverr = !!val;
  471. if (!val)
  472. skb_queue_purge(&sk->sk_error_queue);
  473. break;
  474. case IP_MULTICAST_TTL:
  475. if (sk->sk_type == SOCK_STREAM)
  476. goto e_inval;
  477. if (optlen<1)
  478. goto e_inval;
  479. if (val==-1)
  480. val = 1;
  481. if (val < 0 || val > 255)
  482. goto e_inval;
  483. inet->mc_ttl = val;
  484. break;
  485. case IP_MULTICAST_LOOP:
  486. if (optlen<1)
  487. goto e_inval;
  488. inet->mc_loop = !!val;
  489. break;
  490. case IP_MULTICAST_IF:
  491. {
  492. struct ip_mreqn mreq;
  493. struct net_device *dev = NULL;
  494. if (sk->sk_type == SOCK_STREAM)
  495. goto e_inval;
  496. /*
  497. * Check the arguments are allowable
  498. */
  499. err = -EFAULT;
  500. if (optlen >= sizeof(struct ip_mreqn)) {
  501. if (copy_from_user(&mreq,optval,sizeof(mreq)))
  502. break;
  503. } else {
  504. memset(&mreq, 0, sizeof(mreq));
  505. if (optlen >= sizeof(struct in_addr) &&
  506. copy_from_user(&mreq.imr_address,optval,sizeof(struct in_addr)))
  507. break;
  508. }
  509. if (!mreq.imr_ifindex) {
  510. if (mreq.imr_address.s_addr == INADDR_ANY) {
  511. inet->mc_index = 0;
  512. inet->mc_addr = 0;
  513. err = 0;
  514. break;
  515. }
  516. dev = ip_dev_find(mreq.imr_address.s_addr);
  517. if (dev) {
  518. mreq.imr_ifindex = dev->ifindex;
  519. dev_put(dev);
  520. }
  521. } else
  522. dev = __dev_get_by_index(mreq.imr_ifindex);
  523. err = -EADDRNOTAVAIL;
  524. if (!dev)
  525. break;
  526. err = -EINVAL;
  527. if (sk->sk_bound_dev_if &&
  528. mreq.imr_ifindex != sk->sk_bound_dev_if)
  529. break;
  530. inet->mc_index = mreq.imr_ifindex;
  531. inet->mc_addr = mreq.imr_address.s_addr;
  532. err = 0;
  533. break;
  534. }
  535. case IP_ADD_MEMBERSHIP:
  536. case IP_DROP_MEMBERSHIP:
  537. {
  538. struct ip_mreqn mreq;
  539. if (optlen < sizeof(struct ip_mreq))
  540. goto e_inval;
  541. err = -EFAULT;
  542. if (optlen >= sizeof(struct ip_mreqn)) {
  543. if(copy_from_user(&mreq,optval,sizeof(mreq)))
  544. break;
  545. } else {
  546. memset(&mreq, 0, sizeof(mreq));
  547. if (copy_from_user(&mreq,optval,sizeof(struct ip_mreq)))
  548. break;
  549. }
  550. if (optname == IP_ADD_MEMBERSHIP)
  551. err = ip_mc_join_group(sk, &mreq);
  552. else
  553. err = ip_mc_leave_group(sk, &mreq);
  554. break;
  555. }
  556. case IP_MSFILTER:
  557. {
  558. extern int sysctl_igmp_max_msf;
  559. struct ip_msfilter *msf;
  560. if (optlen < IP_MSFILTER_SIZE(0))
  561. goto e_inval;
  562. if (optlen > sysctl_optmem_max) {
  563. err = -ENOBUFS;
  564. break;
  565. }
  566. msf = kmalloc(optlen, GFP_KERNEL);
  567. if (msf == 0) {
  568. err = -ENOBUFS;
  569. break;
  570. }
  571. err = -EFAULT;
  572. if (copy_from_user(msf, optval, optlen)) {
  573. kfree(msf);
  574. break;
  575. }
  576. /* numsrc >= (1G-4) overflow in 32 bits */
  577. if (msf->imsf_numsrc >= 0x3ffffffcU ||
  578. msf->imsf_numsrc > sysctl_igmp_max_msf) {
  579. kfree(msf);
  580. err = -ENOBUFS;
  581. break;
  582. }
  583. if (IP_MSFILTER_SIZE(msf->imsf_numsrc) > optlen) {
  584. kfree(msf);
  585. err = -EINVAL;
  586. break;
  587. }
  588. err = ip_mc_msfilter(sk, msf, 0);
  589. kfree(msf);
  590. break;
  591. }
  592. case IP_BLOCK_SOURCE:
  593. case IP_UNBLOCK_SOURCE:
  594. case IP_ADD_SOURCE_MEMBERSHIP:
  595. case IP_DROP_SOURCE_MEMBERSHIP:
  596. {
  597. struct ip_mreq_source mreqs;
  598. int omode, add;
  599. if (optlen != sizeof(struct ip_mreq_source))
  600. goto e_inval;
  601. if (copy_from_user(&mreqs, optval, sizeof(mreqs))) {
  602. err = -EFAULT;
  603. break;
  604. }
  605. if (optname == IP_BLOCK_SOURCE) {
  606. omode = MCAST_EXCLUDE;
  607. add = 1;
  608. } else if (optname == IP_UNBLOCK_SOURCE) {
  609. omode = MCAST_EXCLUDE;
  610. add = 0;
  611. } else if (optname == IP_ADD_SOURCE_MEMBERSHIP) {
  612. struct ip_mreqn mreq;
  613. mreq.imr_multiaddr.s_addr = mreqs.imr_multiaddr;
  614. mreq.imr_address.s_addr = mreqs.imr_interface;
  615. mreq.imr_ifindex = 0;
  616. err = ip_mc_join_group(sk, &mreq);
  617. if (err && err != -EADDRINUSE)
  618. break;
  619. omode = MCAST_INCLUDE;
  620. add = 1;
  621. } else /* IP_DROP_SOURCE_MEMBERSHIP */ {
  622. omode = MCAST_INCLUDE;
  623. add = 0;
  624. }
  625. err = ip_mc_source(add, omode, sk, &mreqs, 0);
  626. break;
  627. }
  628. case MCAST_JOIN_GROUP:
  629. case MCAST_LEAVE_GROUP:
  630. {
  631. struct group_req greq;
  632. struct sockaddr_in *psin;
  633. struct ip_mreqn mreq;
  634. if (optlen < sizeof(struct group_req))
  635. goto e_inval;
  636. err = -EFAULT;
  637. if(copy_from_user(&greq, optval, sizeof(greq)))
  638. break;
  639. psin = (struct sockaddr_in *)&greq.gr_group;
  640. if (psin->sin_family != AF_INET)
  641. goto e_inval;
  642. memset(&mreq, 0, sizeof(mreq));
  643. mreq.imr_multiaddr = psin->sin_addr;
  644. mreq.imr_ifindex = greq.gr_interface;
  645. if (optname == MCAST_JOIN_GROUP)
  646. err = ip_mc_join_group(sk, &mreq);
  647. else
  648. err = ip_mc_leave_group(sk, &mreq);
  649. break;
  650. }
  651. case MCAST_JOIN_SOURCE_GROUP:
  652. case MCAST_LEAVE_SOURCE_GROUP:
  653. case MCAST_BLOCK_SOURCE:
  654. case MCAST_UNBLOCK_SOURCE:
  655. {
  656. struct group_source_req greqs;
  657. struct ip_mreq_source mreqs;
  658. struct sockaddr_in *psin;
  659. int omode, add;
  660. if (optlen != sizeof(struct group_source_req))
  661. goto e_inval;
  662. if (copy_from_user(&greqs, optval, sizeof(greqs))) {
  663. err = -EFAULT;
  664. break;
  665. }
  666. if (greqs.gsr_group.ss_family != AF_INET ||
  667. greqs.gsr_source.ss_family != AF_INET) {
  668. err = -EADDRNOTAVAIL;
  669. break;
  670. }
  671. psin = (struct sockaddr_in *)&greqs.gsr_group;
  672. mreqs.imr_multiaddr = psin->sin_addr.s_addr;
  673. psin = (struct sockaddr_in *)&greqs.gsr_source;
  674. mreqs.imr_sourceaddr = psin->sin_addr.s_addr;
  675. mreqs.imr_interface = 0; /* use index for mc_source */
  676. if (optname == MCAST_BLOCK_SOURCE) {
  677. omode = MCAST_EXCLUDE;
  678. add = 1;
  679. } else if (optname == MCAST_UNBLOCK_SOURCE) {
  680. omode = MCAST_EXCLUDE;
  681. add = 0;
  682. } else if (optname == MCAST_JOIN_SOURCE_GROUP) {
  683. struct ip_mreqn mreq;
  684. psin = (struct sockaddr_in *)&greqs.gsr_group;
  685. mreq.imr_multiaddr = psin->sin_addr;
  686. mreq.imr_address.s_addr = 0;
  687. mreq.imr_ifindex = greqs.gsr_interface;
  688. err = ip_mc_join_group(sk, &mreq);
  689. if (err && err != -EADDRINUSE)
  690. break;
  691. greqs.gsr_interface = mreq.imr_ifindex;
  692. omode = MCAST_INCLUDE;
  693. add = 1;
  694. } else /* MCAST_LEAVE_SOURCE_GROUP */ {
  695. omode = MCAST_INCLUDE;
  696. add = 0;
  697. }
  698. err = ip_mc_source(add, omode, sk, &mreqs,
  699. greqs.gsr_interface);
  700. break;
  701. }
  702. case MCAST_MSFILTER:
  703. {
  704. extern int sysctl_igmp_max_msf;
  705. struct sockaddr_in *psin;
  706. struct ip_msfilter *msf = NULL;
  707. struct group_filter *gsf = NULL;
  708. int msize, i, ifindex;
  709. if (optlen < GROUP_FILTER_SIZE(0))
  710. goto e_inval;
  711. if (optlen > sysctl_optmem_max) {
  712. err = -ENOBUFS;
  713. break;
  714. }
  715. gsf = kmalloc(optlen,GFP_KERNEL);
  716. if (gsf == 0) {
  717. err = -ENOBUFS;
  718. break;
  719. }
  720. err = -EFAULT;
  721. if (copy_from_user(gsf, optval, optlen)) {
  722. goto mc_msf_out;
  723. }
  724. /* numsrc >= (4G-140)/128 overflow in 32 bits */
  725. if (gsf->gf_numsrc >= 0x1ffffff ||
  726. gsf->gf_numsrc > sysctl_igmp_max_msf) {
  727. err = -ENOBUFS;
  728. goto mc_msf_out;
  729. }
  730. if (GROUP_FILTER_SIZE(gsf->gf_numsrc) > optlen) {
  731. err = -EINVAL;
  732. goto mc_msf_out;
  733. }
  734. msize = IP_MSFILTER_SIZE(gsf->gf_numsrc);
  735. msf = kmalloc(msize,GFP_KERNEL);
  736. if (msf == 0) {
  737. err = -ENOBUFS;
  738. goto mc_msf_out;
  739. }
  740. ifindex = gsf->gf_interface;
  741. psin = (struct sockaddr_in *)&gsf->gf_group;
  742. if (psin->sin_family != AF_INET) {
  743. err = -EADDRNOTAVAIL;
  744. goto mc_msf_out;
  745. }
  746. msf->imsf_multiaddr = psin->sin_addr.s_addr;
  747. msf->imsf_interface = 0;
  748. msf->imsf_fmode = gsf->gf_fmode;
  749. msf->imsf_numsrc = gsf->gf_numsrc;
  750. err = -EADDRNOTAVAIL;
  751. for (i=0; i<gsf->gf_numsrc; ++i) {
  752. psin = (struct sockaddr_in *)&gsf->gf_slist[i];
  753. if (psin->sin_family != AF_INET)
  754. goto mc_msf_out;
  755. msf->imsf_slist[i] = psin->sin_addr.s_addr;
  756. }
  757. kfree(gsf);
  758. gsf = NULL;
  759. err = ip_mc_msfilter(sk, msf, ifindex);
  760. mc_msf_out:
  761. kfree(msf);
  762. kfree(gsf);
  763. break;
  764. }
  765. case IP_ROUTER_ALERT:
  766. err = ip_ra_control(sk, val ? 1 : 0, NULL);
  767. break;
  768. case IP_FREEBIND:
  769. if (optlen<1)
  770. goto e_inval;
  771. inet->freebind = !!val;
  772. break;
  773. case IP_IPSEC_POLICY:
  774. case IP_XFRM_POLICY:
  775. err = -EPERM;
  776. if (!capable(CAP_NET_ADMIN))
  777. break;
  778. err = xfrm_user_policy(sk, optname, optval, optlen);
  779. break;
  780. default:
  781. err = -ENOPROTOOPT;
  782. break;
  783. }
  784. release_sock(sk);
  785. return err;
  786. e_inval:
  787. release_sock(sk);
  788. return -EINVAL;
  789. }
  790. int ip_setsockopt(struct sock *sk, int level,
  791. int optname, char __user *optval, int optlen)
  792. {
  793. int err;
  794. if (level != SOL_IP)
  795. return -ENOPROTOOPT;
  796. err = do_ip_setsockopt(sk, level, optname, optval, optlen);
  797. #ifdef CONFIG_NETFILTER
  798. /* we need to exclude all possible ENOPROTOOPTs except default case */
  799. if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
  800. optname != IP_IPSEC_POLICY && optname != IP_XFRM_POLICY
  801. #ifdef CONFIG_IP_MROUTE
  802. && (optname < MRT_BASE || optname > (MRT_BASE + 10))
  803. #endif
  804. ) {
  805. lock_sock(sk);
  806. err = nf_setsockopt(sk, PF_INET, optname, optval, optlen);
  807. release_sock(sk);
  808. }
  809. #endif
  810. return err;
  811. }
  812. #ifdef CONFIG_COMPAT
  813. int compat_ip_setsockopt(struct sock *sk, int level, int optname,
  814. char __user *optval, int optlen)
  815. {
  816. int err;
  817. if (level != SOL_IP)
  818. return -ENOPROTOOPT;
  819. err = do_ip_setsockopt(sk, level, optname, optval, optlen);
  820. #ifdef CONFIG_NETFILTER
  821. /* we need to exclude all possible ENOPROTOOPTs except default case */
  822. if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
  823. optname != IP_IPSEC_POLICY && optname != IP_XFRM_POLICY
  824. #ifdef CONFIG_IP_MROUTE
  825. && (optname < MRT_BASE || optname > (MRT_BASE + 10))
  826. #endif
  827. ) {
  828. lock_sock(sk);
  829. err = compat_nf_setsockopt(sk, PF_INET, optname,
  830. optval, optlen);
  831. release_sock(sk);
  832. }
  833. #endif
  834. return err;
  835. }
  836. EXPORT_SYMBOL(compat_ip_setsockopt);
  837. #endif
  838. /*
  839. * Get the options. Note for future reference. The GET of IP options gets the
  840. * _received_ ones. The set sets the _sent_ ones.
  841. */
  842. static int do_ip_getsockopt(struct sock *sk, int level, int optname,
  843. char __user *optval, int __user *optlen)
  844. {
  845. struct inet_sock *inet = inet_sk(sk);
  846. int val;
  847. int len;
  848. if(level!=SOL_IP)
  849. return -EOPNOTSUPP;
  850. #ifdef CONFIG_IP_MROUTE
  851. if(optname>=MRT_BASE && optname <=MRT_BASE+10)
  852. {
  853. return ip_mroute_getsockopt(sk,optname,optval,optlen);
  854. }
  855. #endif
  856. if(get_user(len,optlen))
  857. return -EFAULT;
  858. if(len < 0)
  859. return -EINVAL;
  860. lock_sock(sk);
  861. switch(optname) {
  862. case IP_OPTIONS:
  863. {
  864. unsigned char optbuf[sizeof(struct ip_options)+40];
  865. struct ip_options * opt = (struct ip_options*)optbuf;
  866. opt->optlen = 0;
  867. if (inet->opt)
  868. memcpy(optbuf, inet->opt,
  869. sizeof(struct ip_options)+
  870. inet->opt->optlen);
  871. release_sock(sk);
  872. if (opt->optlen == 0)
  873. return put_user(0, optlen);
  874. ip_options_undo(opt);
  875. len = min_t(unsigned int, len, opt->optlen);
  876. if(put_user(len, optlen))
  877. return -EFAULT;
  878. if(copy_to_user(optval, opt->__data, len))
  879. return -EFAULT;
  880. return 0;
  881. }
  882. case IP_PKTINFO:
  883. val = (inet->cmsg_flags & IP_CMSG_PKTINFO) != 0;
  884. break;
  885. case IP_RECVTTL:
  886. val = (inet->cmsg_flags & IP_CMSG_TTL) != 0;
  887. break;
  888. case IP_RECVTOS:
  889. val = (inet->cmsg_flags & IP_CMSG_TOS) != 0;
  890. break;
  891. case IP_RECVOPTS:
  892. val = (inet->cmsg_flags & IP_CMSG_RECVOPTS) != 0;
  893. break;
  894. case IP_RETOPTS:
  895. val = (inet->cmsg_flags & IP_CMSG_RETOPTS) != 0;
  896. break;
  897. case IP_PASSSEC:
  898. val = (inet->cmsg_flags & IP_CMSG_PASSSEC) != 0;
  899. break;
  900. case IP_TOS:
  901. val = inet->tos;
  902. break;
  903. case IP_TTL:
  904. val = (inet->uc_ttl == -1 ?
  905. sysctl_ip_default_ttl :
  906. inet->uc_ttl);
  907. break;
  908. case IP_HDRINCL:
  909. val = inet->hdrincl;
  910. break;
  911. case IP_MTU_DISCOVER:
  912. val = inet->pmtudisc;
  913. break;
  914. case IP_MTU:
  915. {
  916. struct dst_entry *dst;
  917. val = 0;
  918. dst = sk_dst_get(sk);
  919. if (dst) {
  920. val = dst_mtu(dst);
  921. dst_release(dst);
  922. }
  923. if (!val) {
  924. release_sock(sk);
  925. return -ENOTCONN;
  926. }
  927. break;
  928. }
  929. case IP_RECVERR:
  930. val = inet->recverr;
  931. break;
  932. case IP_MULTICAST_TTL:
  933. val = inet->mc_ttl;
  934. break;
  935. case IP_MULTICAST_LOOP:
  936. val = inet->mc_loop;
  937. break;
  938. case IP_MULTICAST_IF:
  939. {
  940. struct in_addr addr;
  941. len = min_t(unsigned int, len, sizeof(struct in_addr));
  942. addr.s_addr = inet->mc_addr;
  943. release_sock(sk);
  944. if(put_user(len, optlen))
  945. return -EFAULT;
  946. if(copy_to_user(optval, &addr, len))
  947. return -EFAULT;
  948. return 0;
  949. }
  950. case IP_MSFILTER:
  951. {
  952. struct ip_msfilter msf;
  953. int err;
  954. if (len < IP_MSFILTER_SIZE(0)) {
  955. release_sock(sk);
  956. return -EINVAL;
  957. }
  958. if (copy_from_user(&msf, optval, IP_MSFILTER_SIZE(0))) {
  959. release_sock(sk);
  960. return -EFAULT;
  961. }
  962. err = ip_mc_msfget(sk, &msf,
  963. (struct ip_msfilter __user *)optval, optlen);
  964. release_sock(sk);
  965. return err;
  966. }
  967. case MCAST_MSFILTER:
  968. {
  969. struct group_filter gsf;
  970. int err;
  971. if (len < GROUP_FILTER_SIZE(0)) {
  972. release_sock(sk);
  973. return -EINVAL;
  974. }
  975. if (copy_from_user(&gsf, optval, GROUP_FILTER_SIZE(0))) {
  976. release_sock(sk);
  977. return -EFAULT;
  978. }
  979. err = ip_mc_gsfget(sk, &gsf,
  980. (struct group_filter __user *)optval, optlen);
  981. release_sock(sk);
  982. return err;
  983. }
  984. case IP_PKTOPTIONS:
  985. {
  986. struct msghdr msg;
  987. release_sock(sk);
  988. if (sk->sk_type != SOCK_STREAM)
  989. return -ENOPROTOOPT;
  990. msg.msg_control = optval;
  991. msg.msg_controllen = len;
  992. msg.msg_flags = 0;
  993. if (inet->cmsg_flags & IP_CMSG_PKTINFO) {
  994. struct in_pktinfo info;
  995. info.ipi_addr.s_addr = inet->rcv_saddr;
  996. info.ipi_spec_dst.s_addr = inet->rcv_saddr;
  997. info.ipi_ifindex = inet->mc_index;
  998. put_cmsg(&msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
  999. }
  1000. if (inet->cmsg_flags & IP_CMSG_TTL) {
  1001. int hlim = inet->mc_ttl;
  1002. put_cmsg(&msg, SOL_IP, IP_TTL, sizeof(hlim), &hlim);
  1003. }
  1004. len -= msg.msg_controllen;
  1005. return put_user(len, optlen);
  1006. }
  1007. case IP_FREEBIND:
  1008. val = inet->freebind;
  1009. break;
  1010. default:
  1011. release_sock(sk);
  1012. return -ENOPROTOOPT;
  1013. }
  1014. release_sock(sk);
  1015. if (len < sizeof(int) && len > 0 && val>=0 && val<255) {
  1016. unsigned char ucval = (unsigned char)val;
  1017. len = 1;
  1018. if(put_user(len, optlen))
  1019. return -EFAULT;
  1020. if(copy_to_user(optval,&ucval,1))
  1021. return -EFAULT;
  1022. } else {
  1023. len = min_t(unsigned int, sizeof(int), len);
  1024. if(put_user(len, optlen))
  1025. return -EFAULT;
  1026. if(copy_to_user(optval,&val,len))
  1027. return -EFAULT;
  1028. }
  1029. return 0;
  1030. }
  1031. int ip_getsockopt(struct sock *sk, int level,
  1032. int optname, char __user *optval, int __user *optlen)
  1033. {
  1034. int err;
  1035. err = do_ip_getsockopt(sk, level, optname, optval, optlen);
  1036. #ifdef CONFIG_NETFILTER
  1037. /* we need to exclude all possible ENOPROTOOPTs except default case */
  1038. if (err == -ENOPROTOOPT && optname != IP_PKTOPTIONS
  1039. #ifdef CONFIG_IP_MROUTE
  1040. && (optname < MRT_BASE || optname > MRT_BASE+10)
  1041. #endif
  1042. ) {
  1043. int len;
  1044. if(get_user(len,optlen))
  1045. return -EFAULT;
  1046. lock_sock(sk);
  1047. err = nf_getsockopt(sk, PF_INET, optname, optval,
  1048. &len);
  1049. release_sock(sk);
  1050. if (err >= 0)
  1051. err = put_user(len, optlen);
  1052. return err;
  1053. }
  1054. #endif
  1055. return err;
  1056. }
  1057. #ifdef CONFIG_COMPAT
  1058. int compat_ip_getsockopt(struct sock *sk, int level, int optname,
  1059. char __user *optval, int __user *optlen)
  1060. {
  1061. int err = do_ip_getsockopt(sk, level, optname, optval, optlen);
  1062. #ifdef CONFIG_NETFILTER
  1063. /* we need to exclude all possible ENOPROTOOPTs except default case */
  1064. if (err == -ENOPROTOOPT && optname != IP_PKTOPTIONS
  1065. #ifdef CONFIG_IP_MROUTE
  1066. && (optname < MRT_BASE || optname > MRT_BASE+10)
  1067. #endif
  1068. ) {
  1069. int len;
  1070. if (get_user(len, optlen))
  1071. return -EFAULT;
  1072. lock_sock(sk);
  1073. err = compat_nf_getsockopt(sk, PF_INET, optname, optval, &len);
  1074. release_sock(sk);
  1075. if (err >= 0)
  1076. err = put_user(len, optlen);
  1077. return err;
  1078. }
  1079. #endif
  1080. return err;
  1081. }
  1082. EXPORT_SYMBOL(compat_ip_getsockopt);
  1083. #endif
  1084. EXPORT_SYMBOL(ip_cmsg_recv);
  1085. EXPORT_SYMBOL(ip_getsockopt);
  1086. EXPORT_SYMBOL(ip_setsockopt);