开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
ip_sockglue.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：19k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

ip_sockglue.c：源码内容
  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.61 2001/10/20 00:00:11 davem 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.  */
  20. #include <linux/config.h>
  21. #include <linux/types.h>
  22. #include <linux/mm.h>
  23. #include <linux/sched.h>
  24. #include <linux/skbuff.h>
  25. #include <linux/ip.h>
  26. #include <linux/icmp.h>
  27. #include <linux/netdevice.h>
  28. #include <net/sock.h>
  29. #include <net/ip.h>
  30. #include <net/icmp.h>
  31. #include <net/tcp.h>
  32. #include <linux/tcp.h>
  33. #include <linux/udp.h>
  34. #include <linux/igmp.h>
  35. #include <linux/netfilter.h>
  36. #include <linux/route.h>
  37. #include <linux/mroute.h>
  38. #include <net/route.h>
  39. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  40. #include <net/transp_v6.h>
  41. #endif
  43. #include <linux/errqueue.h>
  44. #include <asm/uaccess.h>
  46. #define IP_CMSG_PKTINFO 1
  47. #define IP_CMSG_TTL 2
  48. #define IP_CMSG_TOS 4
  49. #define IP_CMSG_RECVOPTS 8
  50. #define IP_CMSG_RETOPTS 16
  52. /*
  53.  * SOL_IP control messages.
  54.  */
  56. static void ip_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb)
  57. {
  58. struct in_pktinfo info;
  59. struct rtable *rt = (struct rtable *)skb->dst;
  61. info.ipi_addr.s_addr = skb->nh.iph->daddr;
  62. if (rt) {
  63. info.ipi_ifindex = rt->rt_iif;
  64. info.ipi_spec_dst.s_addr = rt->rt_spec_dst;
  65. } else {
  66. info.ipi_ifindex = 0;
  67. info.ipi_spec_dst.s_addr = 0;
  68. }
  70. put_cmsg(msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
  71. }
  73. static void ip_cmsg_recv_ttl(struct msghdr *msg, struct sk_buff *skb)
  74. {
  75. int ttl = skb->nh.iph->ttl;
  76. put_cmsg(msg, SOL_IP, IP_TTL, sizeof(int), &ttl);
  77. }
  79. static void ip_cmsg_recv_tos(struct msghdr *msg, struct sk_buff *skb)
  80. {
  81. put_cmsg(msg, SOL_IP, IP_TOS, 1, &skb->nh.iph->tos);
  82. }
  84. static void ip_cmsg_recv_opts(struct msghdr *msg, struct sk_buff *skb)
  85. {
  86. if (IPCB(skb)->opt.optlen == 0)
  87. return;
  89. put_cmsg(msg, SOL_IP, IP_RECVOPTS, IPCB(skb)->opt.optlen, skb->nh.iph+1);
  90. }
  93. void ip_cmsg_recv_retopts(struct msghdr *msg, struct sk_buff *skb)
  94. {
  95. unsigned char optbuf[sizeof(struct ip_options) + 40];
  96. struct ip_options * opt = (struct ip_options*)optbuf;
  98. if (IPCB(skb)->opt.optlen == 0)
  99. return;
  101. if (ip_options_echo(opt, skb)) {
  102. msg->msg_flags |= MSG_CTRUNC;
  103. return;
  104. }
  105. ip_options_undo(opt);
  107. put_cmsg(msg, SOL_IP, IP_RETOPTS, opt->optlen, opt->__data);
  108. }
  111. void ip_cmsg_recv(struct msghdr *msg, struct sk_buff *skb)
  112. {
  113. unsigned flags = skb->sk->protinfo.af_inet.cmsg_flags;
  115. /* Ordered by supposed usage frequency */
  116. if (flags & 1)
  117. ip_cmsg_recv_pktinfo(msg, skb);
  118. if ((flags>>=1) == 0)
  119. return;
  121. if (flags & 1)
  122. ip_cmsg_recv_ttl(msg, skb);
  123. if ((flags>>=1) == 0)
  124. return;
  126. if (flags & 1)
  127. ip_cmsg_recv_tos(msg, skb);
  128. if ((flags>>=1) == 0)
  129. return;
  131. if (flags & 1)
  132. ip_cmsg_recv_opts(msg, skb);
  133. if ((flags>>=1) == 0)
  134. return;
  136. if (flags & 1)
  137. ip_cmsg_recv_retopts(msg, skb);
  138. }
  140. int ip_cmsg_send(struct msghdr *msg, struct ipcm_cookie *ipc)
  141. {
  142. int err;
  143. struct cmsghdr *cmsg;
  145. for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
  146. if (cmsg->cmsg_len < sizeof(struct cmsghdr) ||
  147.     (unsigned long)(((char*)cmsg - (char*)msg->msg_control)
  148.     + cmsg->cmsg_len) > msg->msg_controllen) {
  149. return -EINVAL;
  150. }
  151. if (cmsg->cmsg_level != SOL_IP)
  152. continue;
  153. switch (cmsg->cmsg_type) {
  154. case IP_RETOPTS:
  155. err = cmsg->cmsg_len - CMSG_ALIGN(sizeof(struct cmsghdr));
  156. err = ip_options_get(&ipc->opt, CMSG_DATA(cmsg), err < 40 ? err : 40, 0);
  157. if (err)
  158. return err;
  159. break;
  160. case IP_PKTINFO:
  161. {
  162. struct in_pktinfo *info;
  163. if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct in_pktinfo)))
  164. return -EINVAL;
  165. info = (struct in_pktinfo *)CMSG_DATA(cmsg);
  166. ipc->oif = info->ipi_ifindex;
  167. ipc->addr = info->ipi_spec_dst.s_addr;
  168. break;
  169. }
  170. default:
  171. return -EINVAL;
  172. }
  173. }
  174. return 0;
  175. }
  178. /* Special input handler for packets catched by router alert option.
  179.    They are selected only by protocol field, and then processed likely
  180.    local ones; but only if someone wants them! Otherwise, router
  181.    not running rsvpd will kill RSVP.
  183.    It is user level problem, what it will make with them.
  184.    I have no idea, how it will masquearde or NAT them (it is joke, joke :-)),
  185.    but receiver should be enough clever f.e. to forward mtrace requests,
  186.    sent to multicast group to reach destination designated router.
  187.  */
  188. struct ip_ra_chain *ip_ra_chain;
  189. rwlock_t ip_ra_lock = RW_LOCK_UNLOCKED;
  191. int ip_ra_control(struct sock *sk, unsigned char on, void (*destructor)(struct sock *))
  192. {
  193. struct ip_ra_chain *ra, *new_ra, **rap;
  195. if (sk->type != SOCK_RAW || sk->num == IPPROTO_RAW)
  196. return -EINVAL;
  198. new_ra = on ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
  200. write_lock_bh(&ip_ra_lock);
  201. for (rap = &ip_ra_chain; (ra=*rap) != NULL; rap = &ra->next) {
  202. if (ra->sk == sk) {
  203. if (on) {
  204. write_unlock_bh(&ip_ra_lock);
  205. if (new_ra)
  206. kfree(new_ra);
  207. return -EADDRINUSE;
  208. }
  209. *rap = ra->next;
  210. write_unlock_bh(&ip_ra_lock);
  212. if (ra->destructor)
  213. ra->destructor(sk);
  214. sock_put(sk);
  215. kfree(ra);
  216. return 0;
  217. }
  218. }
  219. if (new_ra == NULL) {
  220. write_unlock_bh(&ip_ra_lock);
  221. return -ENOBUFS;
  222. }
  223. new_ra->sk = sk;
  224. new_ra->destructor = destructor;
  226. new_ra->next = ra;
  227. *rap = new_ra;
  228. sock_hold(sk);
  229. write_unlock_bh(&ip_ra_lock);
  231. return 0;
  232. }
  234. void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err, 
  235.    u16 port, u32 info, u8 *payload)
  236. {
  237. struct sock_exterr_skb *serr;
  239. if (!sk->protinfo.af_inet.recverr)
  240. return;
  242. skb = skb_clone(skb, GFP_ATOMIC);
  243. if (!skb)
  244. return;
  246. serr = SKB_EXT_ERR(skb);  
  247. serr->ee.ee_errno = err;
  248. serr->ee.ee_origin = SO_EE_ORIGIN_ICMP;
  249. serr->ee.ee_type = skb->h.icmph->type; 
  250. serr->ee.ee_code = skb->h.icmph->code;
  251. serr->ee.ee_pad = 0;
  252. serr->ee.ee_info = info;
  253. serr->ee.ee_data = 0;
  254. serr->addr_offset = (u8*)&(((struct iphdr*)(skb->h.icmph+1))->daddr) - skb->nh.raw;
  255. serr->port = port;
  257. skb->h.raw = payload;
  258. if (!skb_pull(skb, payload - skb->data) ||
  259.     sock_queue_err_skb(sk, skb))
  260. kfree_skb(skb);
  261. }
  263. void ip_local_error(struct sock *sk, int err, u32 daddr, u16 port, u32 info)
  264. {
  265. struct sock_exterr_skb *serr;
  266. struct iphdr *iph;
  267. struct sk_buff *skb;
  269. if (!sk->protinfo.af_inet.recverr)
  270. return;
  272. skb = alloc_skb(sizeof(struct iphdr), GFP_ATOMIC);
  273. if (!skb)
  274. return;
  276. iph = (struct iphdr*)skb_put(skb, sizeof(struct iphdr));
  277. skb->nh.iph = iph;
  278. iph->daddr = daddr;
  280. serr = SKB_EXT_ERR(skb);  
  281. serr->ee.ee_errno = err;
  282. serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
  283. serr->ee.ee_type = 0; 
  284. serr->ee.ee_code = 0;
  285. serr->ee.ee_pad = 0;
  286. serr->ee.ee_info = info;
  287. serr->ee.ee_data = 0;
  288. serr->addr_offset = (u8*)&iph->daddr - skb->nh.raw;
  289. serr->port = port;
  291. skb->h.raw = skb->tail;
  292. __skb_pull(skb, skb->tail - skb->data);
  294. if (sock_queue_err_skb(sk, skb))
  295. kfree_skb(skb);
  296. }
  298. /* 
  299.  * Handle MSG_ERRQUEUE
  300.  */
  301. int ip_recv_error(struct sock *sk, struct msghdr *msg, int len)
  302. {
  303. struct sock_exterr_skb *serr;
  304. struct sk_buff *skb, *skb2;
  305. struct sockaddr_in *sin;
  306. struct {
  307. struct sock_extended_err ee;
  308. struct sockaddr_in  offender;
  309. } errhdr;
  310. int err;
  311. int copied;
  313. err = -EAGAIN;
  314. skb = skb_dequeue(&sk->error_queue);
  315. if (skb == NULL)
  316. goto out;
  318. copied = skb->len;
  319. if (copied > len) {
  320. msg->msg_flags |= MSG_TRUNC;
  321. copied = len;
  322. }
  323. err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
  324. if (err)
  325. goto out_free_skb;
  327. sock_recv_timestamp(msg, sk, skb);
  329. serr = SKB_EXT_ERR(skb);
  331. sin = (struct sockaddr_in *)msg->msg_name;
  332. if (sin) {
  333. sin->sin_family = AF_INET;
  334. sin->sin_addr.s_addr = *(u32*)(skb->nh.raw + serr->addr_offset);
  335. sin->sin_port = serr->port;
  336. memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
  337. }
  339. memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
  340. sin = &errhdr.offender;
  341. sin->sin_family = AF_UNSPEC;
  342. if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP) {
  343. sin->sin_family = AF_INET;
  344. sin->sin_addr.s_addr = skb->nh.iph->saddr;
  345. sin->sin_port = 0;
  346. memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
  347. if (sk->protinfo.af_inet.cmsg_flags)
  348. ip_cmsg_recv(msg, skb);
  349. }
  351. put_cmsg(msg, SOL_IP, IP_RECVERR, sizeof(errhdr), &errhdr);
  353. /* Now we could try to dump offended packet options */
  355. msg->msg_flags |= MSG_ERRQUEUE;
  356. err = copied;
  358. /* Reset and regenerate socket error */
  359. spin_lock_irq(&sk->error_queue.lock);
  360. sk->err = 0;
  361. if ((skb2 = skb_peek(&sk->error_queue)) != NULL) {
  362. sk->err = SKB_EXT_ERR(skb2)->ee.ee_errno;
  363. spin_unlock_irq(&sk->error_queue.lock);
  364. sk->error_report(sk);
  365. } else {
  366. spin_unlock_irq(&sk->error_queue.lock);
  367. }
  369. out_free_skb:
  370. kfree_skb(skb);
  371. out:
  372. return err;
  373. }
  376. /*
  377.  * Socket option code for IP. This is the end of the line after any TCP,UDP etc options on
  378.  * an IP socket.
  379.  */
  381. int ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen)
  382. {
  383. int val=0,err;
  385. if (level != SOL_IP)
  386. return -ENOPROTOOPT;
  388. if (((1<<optname) & ((1<<IP_PKTINFO) | (1<<IP_RECVTTL) | 
  389.     (1<<IP_RECVOPTS) | (1<<IP_RECVTOS) | 
  390.     (1<<IP_RETOPTS) | (1<<IP_TOS) | 
  391.     (1<<IP_TTL) | (1<<IP_HDRINCL) | 
  392.     (1<<IP_MTU_DISCOVER) | (1<<IP_RECVERR) | 
  393.     (1<<IP_ROUTER_ALERT) | (1<<IP_FREEBIND))) || 
  394. optname == IP_MULTICAST_TTL || 
  395. optname == IP_MULTICAST_LOOP) { 
  396. if (optlen >= sizeof(int)) {
  397. if (get_user(val, (int *) optval))
  398. return -EFAULT;
  399. } else if (optlen >= sizeof(char)) {
  400. unsigned char ucval;
  402. if (get_user(ucval, (unsigned char *) optval))
  403. return -EFAULT;
  404. val = (int) ucval;
  405. }
  406. }
  408. /* If optlen==0, it is equivalent to val == 0 */
  410. #ifdef CONFIG_IP_MROUTE
  411. if (optname >= MRT_BASE && optname <= (MRT_BASE + 10))
  412. return ip_mroute_setsockopt(sk,optname,optval,optlen);
  413. #endif
  415. err = 0;
  416. lock_sock(sk);
  418. switch (optname) {
  419. case IP_OPTIONS:
  420. {
  421. struct ip_options * opt = NULL;
  422. if (optlen > 40 || optlen < 0)
  423. goto e_inval;
  424. err = ip_options_get(&opt, optval, optlen, 1);
  425. if (err)
  426. break;
  427. if (sk->type == SOCK_STREAM) {
  428. struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
  429. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  430. if (sk->family == PF_INET ||
  431.     (!((1<<sk->state)&(TCPF_LISTEN|TCPF_CLOSE))
  432.      && sk->daddr != LOOPBACK4_IPV6)) {
  433. #endif
  434. if (opt)
  435. tp->ext_header_len = opt->optlen;
  436. tcp_sync_mss(sk, tp->pmtu_cookie);
  437. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  438. }
  439. #endif
  440. }
  441. opt = xchg(&sk->protinfo.af_inet.opt, opt);
  442. if (opt)
  443. kfree(opt);
  444. break;
  445. }
  446. case IP_PKTINFO:
  447. if (val)
  448. sk->protinfo.af_inet.cmsg_flags |= IP_CMSG_PKTINFO;
  449. else
  450. sk->protinfo.af_inet.cmsg_flags &= ~IP_CMSG_PKTINFO;
  451. break;
  452. case IP_RECVTTL:
  453. if (val)
  454. sk->protinfo.af_inet.cmsg_flags |=  IP_CMSG_TTL;
  455. else
  456. sk->protinfo.af_inet.cmsg_flags &= ~IP_CMSG_TTL;
  457. break;
  458. case IP_RECVTOS:
  459. if (val)
  460. sk->protinfo.af_inet.cmsg_flags |=  IP_CMSG_TOS;
  461. else
  462. sk->protinfo.af_inet.cmsg_flags &= ~IP_CMSG_TOS;
  463. break;
  464. case IP_RECVOPTS:
  465. if (val)
  466. sk->protinfo.af_inet.cmsg_flags |=  IP_CMSG_RECVOPTS;
  467. else
  468. sk->protinfo.af_inet.cmsg_flags &= ~IP_CMSG_RECVOPTS;
  469. break;
  470. case IP_RETOPTS:
  471. if (val)
  472. sk->protinfo.af_inet.cmsg_flags |= IP_CMSG_RETOPTS;
  473. else
  474. sk->protinfo.af_inet.cmsg_flags &= ~IP_CMSG_RETOPTS;
  475. break;
  476. case IP_TOS: /* This sets both TOS and Precedence */
  477. if (sk->type == SOCK_STREAM) {
  478. val &= ~3;
  479. val |= sk->protinfo.af_inet.tos & 3;
  480. }
  481. if (IPTOS_PREC(val) >= IPTOS_PREC_CRITIC_ECP && 
  482.     !capable(CAP_NET_ADMIN)) {
  483. err = -EPERM;
  484. break;
  485. }
  486. if (sk->protinfo.af_inet.tos != val) {
  487. sk->protinfo.af_inet.tos=val;
  488. sk->priority = rt_tos2priority(val);
  489. sk_dst_reset(sk); 
  490. }
  491. break;
  492. case IP_TTL:
  493. if (optlen<1)
  494. goto e_inval;
  495. if(val==-1)
  496. val = sysctl_ip_default_ttl;
  497. if(val<1||val>255)
  498. goto e_inval;
  499. sk->protinfo.af_inet.ttl=val;
  500. break;
  501. case IP_HDRINCL:
  502. if(sk->type!=SOCK_RAW) {
  503. err = -ENOPROTOOPT;
  504. break;
  505. }
  506. sk->protinfo.af_inet.hdrincl=val?1:0;
  507. break;
  508. case IP_MTU_DISCOVER:
  509. if (val<0 || val>2)
  510. goto e_inval;
  511. sk->protinfo.af_inet.pmtudisc = val;
  512. break;
  513. case IP_RECVERR:
  514. sk->protinfo.af_inet.recverr = !!val;
  515. if (!val)
  516. skb_queue_purge(&sk->error_queue);
  517. break;
  518. case IP_MULTICAST_TTL:
  519. if (sk->type == SOCK_STREAM)
  520. goto e_inval;
  521. if (optlen<1)
  522. goto e_inval;
  523. if (val==-1)
  524. val = 1;
  525. if (val < 0 || val > 255)
  526. goto e_inval;
  527. sk->protinfo.af_inet.mc_ttl=val;
  528.                 break;
  529. case IP_MULTICAST_LOOP: 
  530. if (optlen<1)
  531. goto e_inval;
  532. sk->protinfo.af_inet.mc_loop = val ? 1 : 0;
  533.                 break;
  534. case IP_MULTICAST_IF: 
  535. {
  536. struct ip_mreqn mreq;
  537. struct net_device *dev = NULL;
  539. if (sk->type == SOCK_STREAM)
  540. goto e_inval;
  541. /*
  542.  * Check the arguments are allowable
  543.  */
  545. err = -EFAULT;
  546. if (optlen >= sizeof(struct ip_mreqn)) {
  547. if (copy_from_user(&mreq,optval,sizeof(mreq)))
  548. break;
  549. } else {
  550. memset(&mreq, 0, sizeof(mreq));
  551. if (optlen >= sizeof(struct in_addr) &&
  552.     copy_from_user(&mreq.imr_address,optval,sizeof(struct in_addr)))
  553. break;
  554. }
  556. if (!mreq.imr_ifindex) {
  557. if (mreq.imr_address.s_addr == INADDR_ANY) {
  558. sk->protinfo.af_inet.mc_index = 0;
  559. sk->protinfo.af_inet.mc_addr  = 0;
  560. err = 0;
  561. break;
  562. }
  563. dev = ip_dev_find(mreq.imr_address.s_addr);
  564. if (dev) {
  565. mreq.imr_ifindex = dev->ifindex;
  566. dev_put(dev);
  567. }
  568. } else
  569. dev = __dev_get_by_index(mreq.imr_ifindex);
  572. err = -EADDRNOTAVAIL;
  573. if (!dev)
  574. break;
  576. err = -EINVAL;
  577. if (sk->bound_dev_if && mreq.imr_ifindex != sk->bound_dev_if)
  578. break;
  580. sk->protinfo.af_inet.mc_index = mreq.imr_ifindex;
  581. sk->protinfo.af_inet.mc_addr  = mreq.imr_address.s_addr;
  582. err = 0;
  583. break;
  584. }
  586. case IP_ADD_MEMBERSHIP:
  587. case IP_DROP_MEMBERSHIP: 
  588. {
  589. struct ip_mreqn mreq;
  591. if (optlen < sizeof(struct ip_mreq))
  592. goto e_inval;
  593. err = -EFAULT;
  594. if (optlen >= sizeof(struct ip_mreqn)) {
  595. if(copy_from_user(&mreq,optval,sizeof(mreq)))
  596. break;
  597. } else {
  598. memset(&mreq, 0, sizeof(mreq));
  599. if (copy_from_user(&mreq,optval,sizeof(struct ip_mreq)))
  600. break; 
  601. }
  603. if (optname == IP_ADD_MEMBERSHIP)
  604. err = ip_mc_join_group(sk,&mreq);
  605. else
  606. err = ip_mc_leave_group(sk,&mreq);
  607. break;
  608. }
  609. case IP_ROUTER_ALERT:
  610. err = ip_ra_control(sk, val ? 1 : 0, NULL);
  611. break;
  613. case IP_FREEBIND:
  614. if (optlen<1)
  615. goto e_inval;
  616. sk->protinfo.af_inet.freebind = !!val; 
  617.                 break;
  618.  
  619. default:
  620. #ifdef CONFIG_NETFILTER
  621. err = nf_setsockopt(sk, PF_INET, optname, optval, 
  622.     optlen);
  623. #else
  624. err = -ENOPROTOOPT;
  625. #endif
  626. break;
  627. }
  628. release_sock(sk);
  629. return err;
  631. e_inval:
  632. release_sock(sk);
  633. return -EINVAL;
  634. }
  636. /*
  637.  * Get the options. Note for future reference. The GET of IP options gets the
  638.  * _received_ ones. The set sets the _sent_ ones.
  639.  */
  641. int ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen)
  642. {
  643. int val;
  644. int len;
  646. if(level!=SOL_IP)
  647. return -EOPNOTSUPP;
  649. #ifdef CONFIG_IP_MROUTE
  650. if(optname>=MRT_BASE && optname <=MRT_BASE+10)
  651. {
  652. return ip_mroute_getsockopt(sk,optname,optval,optlen);
  653. }
  654. #endif
  656. if(get_user(len,optlen))
  657. return -EFAULT;
  658. if(len < 0)
  659. return -EINVAL;
  661. lock_sock(sk);
  663. switch(optname) {
  664. case IP_OPTIONS:
  665. {
  666. unsigned char optbuf[sizeof(struct ip_options)+40];
  667. struct ip_options * opt = (struct ip_options*)optbuf;
  668. opt->optlen = 0;
  669. if (sk->protinfo.af_inet.opt)
  670. memcpy(optbuf, sk->protinfo.af_inet.opt,
  671.        sizeof(struct ip_options)+
  672.        sk->protinfo.af_inet.opt->optlen);
  673. release_sock(sk);
  675. if (opt->optlen == 0) 
  676. return put_user(0, optlen);
  678. ip_options_undo(opt);
  680. len = min_t(unsigned int, len, opt->optlen);
  681. if(put_user(len, optlen))
  682. return -EFAULT;
  683. if(copy_to_user(optval, opt->__data, len))
  684. return -EFAULT;
  685. return 0;
  686. }
  687. case IP_PKTINFO:
  688. val = (sk->protinfo.af_inet.cmsg_flags & IP_CMSG_PKTINFO) != 0;
  689. break;
  690. case IP_RECVTTL:
  691. val = (sk->protinfo.af_inet.cmsg_flags & IP_CMSG_TTL) != 0;
  692. break;
  693. case IP_RECVTOS:
  694. val = (sk->protinfo.af_inet.cmsg_flags & IP_CMSG_TOS) != 0;
  695. break;
  696. case IP_RECVOPTS:
  697. val = (sk->protinfo.af_inet.cmsg_flags & IP_CMSG_RECVOPTS) != 0;
  698. break;
  699. case IP_RETOPTS:
  700. val = (sk->protinfo.af_inet.cmsg_flags & IP_CMSG_RETOPTS) != 0;
  701. break;
  702. case IP_TOS:
  703. val=sk->protinfo.af_inet.tos;
  704. break;
  705. case IP_TTL:
  706. val=sk->protinfo.af_inet.ttl;
  707. break;
  708. case IP_HDRINCL:
  709. val=sk->protinfo.af_inet.hdrincl;
  710. break;
  711. case IP_MTU_DISCOVER:
  712. val=sk->protinfo.af_inet.pmtudisc;
  713. break;
  714. case IP_MTU:
  715. {
  716. struct dst_entry *dst;
  717. val = 0;
  718. dst = sk_dst_get(sk);
  719. if (dst) {
  720. val = dst->pmtu;
  721. dst_release(dst);
  722. }
  723. if (!val) {
  724. release_sock(sk);
  725. return -ENOTCONN;
  726. }
  727. break;
  728. }
  729. case IP_RECVERR:
  730. val=sk->protinfo.af_inet.recverr;
  731. break;
  732. case IP_MULTICAST_TTL:
  733. val=sk->protinfo.af_inet.mc_ttl;
  734. break;
  735. case IP_MULTICAST_LOOP:
  736. val=sk->protinfo.af_inet.mc_loop;
  737. break;
  738. case IP_MULTICAST_IF:
  739. {
  740. struct in_addr addr;
  741. len = min_t(unsigned int, len, sizeof(struct in_addr));
  742. addr.s_addr = sk->protinfo.af_inet.mc_addr;
  743. release_sock(sk);
  745.    if(put_user(len, optlen))
  746.    return -EFAULT;
  747. if(copy_to_user((void *)optval, &addr, len))
  748. return -EFAULT;
  749. return 0;
  750. }
  751. case IP_PKTOPTIONS:
  752. {
  753. struct msghdr msg;
  755. release_sock(sk);
  757. if (sk->type != SOCK_STREAM)
  758. return -ENOPROTOOPT;
  760. msg.msg_control = optval;
  761. msg.msg_controllen = len;
  762. msg.msg_flags = 0;
  764. if (sk->protinfo.af_inet.cmsg_flags&IP_CMSG_PKTINFO) {
  765. struct in_pktinfo info;
  767. info.ipi_addr.s_addr = sk->rcv_saddr;
  768. info.ipi_spec_dst.s_addr = sk->rcv_saddr;
  769. info.ipi_ifindex = sk->protinfo.af_inet.mc_index;
  770. put_cmsg(&msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
  771. }
  772. if (sk->protinfo.af_inet.cmsg_flags&IP_CMSG_TTL) {
  773. int hlim = sk->protinfo.af_inet.mc_ttl;
  774. put_cmsg(&msg, SOL_IP, IP_TTL, sizeof(hlim), &hlim);
  775. }
  776. len -= msg.msg_controllen;
  777. return put_user(len, optlen);
  778. }
  779. case IP_FREEBIND: 
  780. val = sk->protinfo.af_inet.freebind; 
  781. break; 
  782. default:
  783. #ifdef CONFIG_NETFILTER
  784. val = nf_getsockopt(sk, PF_INET, optname, optval, 
  785.     &len);
  786. release_sock(sk);
  787. if (val >= 0)
  788. val = put_user(len, optlen);
  789. return val;
  790. #else
  791. release_sock(sk);
  792. return -ENOPROTOOPT;
  793. #endif
  794. }
  795. release_sock(sk);
  797. if (len < sizeof(int) && len > 0 && val>=0 && val<255) {
  798. unsigned char ucval = (unsigned char)val;
  799. len = 1;
  800. if(put_user(len, optlen))
  801. return -EFAULT;
  802. if(copy_to_user(optval,&ucval,1))
  803. return -EFAULT;
  804. } else {
  805. len = min_t(unsigned int, sizeof(int), len);
  806. if(put_user(len, optlen))
  807. return -EFAULT;
  808. if(copy_to_user(optval,&val,len))
  809. return -EFAULT;
  810. }
  811. return 0;
  812. }