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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ipv6_sockglue.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：11k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

ipv6_sockglue.c：源码内容
  1. /*
  2.  * IPv6 BSD socket options interface
  3.  * Linux INET6 implementation 
  4.  *
  5.  * Authors:
  6.  * Pedro Roque <roque@di.fc.ul.pt>
  7.  *
  8.  * Based on linux/net/ipv4/ip_sockglue.c
  9.  *
  10.  * $Id: ipv6_sockglue.c,v 1.40 2001/09/18 22:29:10 davem Exp $
  11.  *
  12.  * This program is free software; you can redistribute it and/or
  13.  *      modify it under the terms of the GNU General Public License
  14.  *      as published by the Free Software Foundation; either version
  15.  *      2 of the License, or (at your option) any later version.
  16.  *
  17.  * FIXME: Make the setsockopt code POSIX compliant: That is
  18.  *
  19.  * o Return -EINVAL for setsockopt of short lengths
  20.  * o Truncate getsockopt returns
  21.  * o Return an optlen of the truncated length if need be
  22.  */
  24. #define __NO_VERSION__
  25. #include <linux/module.h>
  26. #include <linux/config.h>
  27. #include <linux/errno.h>
  28. #include <linux/types.h>
  29. #include <linux/socket.h>
  30. #include <linux/sockios.h>
  31. #include <linux/sched.h>
  32. #include <linux/net.h>
  33. #include <linux/in6.h>
  34. #include <linux/netdevice.h>
  35. #include <linux/if_arp.h>
  36. #include <linux/init.h>
  37. #include <linux/sysctl.h>
  38. #include <linux/netfilter.h>
  40. #include <net/sock.h>
  41. #include <net/snmp.h>
  42. #include <net/ipv6.h>
  43. #include <net/ndisc.h>
  44. #include <net/protocol.h>
  45. #include <net/transp_v6.h>
  46. #include <net/ip6_route.h>
  47. #include <net/addrconf.h>
  48. #include <net/inet_common.h>
  49. #include <net/tcp.h>
  50. #include <net/udp.h>
  52. #include <asm/uaccess.h>
  54. struct ipv6_mib ipv6_statistics[NR_CPUS*2];
  56. struct packet_type ipv6_packet_type =
  57. {
  58. __constant_htons(ETH_P_IPV6), 
  59. NULL, /* All devices */
  60. ipv6_rcv,
  61. (void*)1,
  62. NULL
  63. };
  65. /*
  66.  * addrconf module should be notifyed of a device going up
  67.  */
  68. static struct notifier_block ipv6_dev_notf = {
  69. addrconf_notify,
  70. NULL,
  71. 0
  72. };
  74. struct ip6_ra_chain *ip6_ra_chain;
  75. rwlock_t ip6_ra_lock = RW_LOCK_UNLOCKED;
  77. int ip6_ra_control(struct sock *sk, int sel, void (*destructor)(struct sock *))
  78. {
  79. struct ip6_ra_chain *ra, *new_ra, **rap;
  81. /* RA packet may be delivered ONLY to IPPROTO_RAW socket */
  82. if (sk->type != SOCK_RAW || sk->num != IPPROTO_RAW)
  83. return -EINVAL;
  85. new_ra = (sel>=0) ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
  87. write_lock_bh(&ip6_ra_lock);
  88. for (rap = &ip6_ra_chain; (ra=*rap) != NULL; rap = &ra->next) {
  89. if (ra->sk == sk) {
  90. if (sel>=0) {
  91. write_unlock_bh(&ip6_ra_lock);
  92. if (new_ra)
  93. kfree(new_ra);
  94. return -EADDRINUSE;
  95. }
  97. *rap = ra->next;
  98. write_unlock_bh(&ip6_ra_lock);
  100. if (ra->destructor)
  101. ra->destructor(sk);
  102. sock_put(sk);
  103. kfree(ra);
  104. return 0;
  105. }
  106. }
  107. if (new_ra == NULL) {
  108. write_unlock_bh(&ip6_ra_lock);
  109. return -ENOBUFS;
  110. }
  111. new_ra->sk = sk;
  112. new_ra->sel = sel;
  113. new_ra->destructor = destructor;
  114. new_ra->next = ra;
  115. *rap = new_ra;
  116. sock_hold(sk);
  117. write_unlock_bh(&ip6_ra_lock);
  118. return 0;
  119. }
  122. int ipv6_setsockopt(struct sock *sk, int level, int optname, char *optval, 
  123.     int optlen)
  124. {
  125. struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;
  126. int val, valbool;
  127. int retv = -ENOPROTOOPT;
  129. if(level==SOL_IP && sk->type != SOCK_RAW)
  130. return udp_prot.setsockopt(sk, level, optname, optval, optlen);
  132. if(level!=SOL_IPV6)
  133. goto out;
  135. if (optval == NULL)
  136. val=0;
  137. else if (get_user(val, (int *) optval))
  138. return -EFAULT;
  140. valbool = (val!=0);
  142. lock_sock(sk);
  144. switch (optname) {
  146. case IPV6_ADDRFORM:
  147. if (val == PF_INET) {
  148. struct ipv6_txoptions *opt;
  149. struct sk_buff *pktopt;
  151. if (sk->protocol != IPPROTO_UDP &&
  152.     sk->protocol != IPPROTO_TCP)
  153. break;
  155. if (sk->state != TCP_ESTABLISHED) {
  156. retv = -ENOTCONN;
  157. break;
  158. }
  160. if (!(ipv6_addr_type(&np->daddr) & IPV6_ADDR_MAPPED)) {
  161. retv = -EADDRNOTAVAIL;
  162. break;
  163. }
  165. fl6_free_socklist(sk);
  166. ipv6_sock_mc_close(sk);
  168. if (sk->protocol == IPPROTO_TCP) {
  169. struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
  171. local_bh_disable();
  172. sock_prot_dec_use(sk->prot);
  173. sock_prot_inc_use(&tcp_prot);
  174. local_bh_enable();
  175. sk->prot = &tcp_prot;
  176. tp->af_specific = &ipv4_specific;
  177. sk->socket->ops = &inet_stream_ops;
  178. sk->family = PF_INET;
  179. tcp_sync_mss(sk, tp->pmtu_cookie);
  180. } else {
  181. local_bh_disable();
  182. sock_prot_dec_use(sk->prot);
  183. sock_prot_inc_use(&udp_prot);
  184. local_bh_enable();
  185. sk->prot = &udp_prot;
  186. sk->socket->ops = &inet_dgram_ops;
  187. sk->family = PF_INET;
  188. }
  189. opt = xchg(&np->opt, NULL);
  190. if (opt)
  191. sock_kfree_s(sk, opt, opt->tot_len);
  192. pktopt = xchg(&np->pktoptions, NULL);
  193. if (pktopt)
  194. kfree_skb(pktopt);
  196. sk->destruct = inet_sock_destruct;
  197. #ifdef INET_REFCNT_DEBUG
  198. atomic_dec(&inet6_sock_nr);
  199. #endif
  200. MOD_DEC_USE_COUNT;
  201. retv = 0;
  202. break;
  203. }
  204. goto e_inval;
  206. case IPV6_PKTINFO:
  207. np->rxopt.bits.rxinfo = valbool;
  208. retv = 0;
  209. break;
  211. case IPV6_HOPLIMIT:
  212. np->rxopt.bits.rxhlim = valbool;
  213. retv = 0;
  214. break;
  216. case IPV6_RTHDR:
  217. if (val < 0 || val > 2)
  218. goto e_inval;
  219. np->rxopt.bits.srcrt = val;
  220. retv = 0;
  221. break;
  223. case IPV6_HOPOPTS:
  224. np->rxopt.bits.hopopts = valbool;
  225. retv = 0;
  226. break;
  228. case IPV6_AUTHHDR:
  229. np->rxopt.bits.authhdr = valbool;
  230. retv = 0;
  231. break;
  233. case IPV6_DSTOPTS:
  234. np->rxopt.bits.dstopts = valbool;
  235. retv = 0;
  236. break;
  238. case IPV6_FLOWINFO:
  239. np->rxopt.bits.rxflow = valbool;
  240. retv = 0;
  241. break;
  243. case IPV6_PKTOPTIONS:
  244. {
  245. struct ipv6_txoptions *opt = NULL;
  246. struct msghdr msg;
  247. struct flowi fl;
  248. int junk;
  250. fl.fl6_flowlabel = 0;
  251. fl.oif = sk->bound_dev_if;
  253. if (optlen == 0)
  254. goto update;
  256. /* 1K is probably excessive
  257.  * 1K is surely not enough, 2K per standard header is 16K.
  258.  */
  259. retv = -EINVAL;
  260. if (optlen > 64*1024)
  261. break;
  263. opt = sock_kmalloc(sk, sizeof(*opt) + optlen, GFP_KERNEL);
  264. retv = -ENOBUFS;
  265. if (opt == NULL)
  266. break;
  268. memset(opt, 0, sizeof(*opt));
  269. opt->tot_len = sizeof(*opt) + optlen;
  270. retv = -EFAULT;
  271. if (copy_from_user(opt+1, optval, optlen))
  272. goto done;
  274. msg.msg_controllen = optlen;
  275. msg.msg_control = (void*)(opt+1);
  277. retv = datagram_send_ctl(&msg, &fl, opt, &junk);
  278. if (retv)
  279. goto done;
  280. update:
  281. retv = 0;
  282. if (sk->type == SOCK_STREAM) {
  283. if (opt) {
  284. struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
  285. if (!((1<<sk->state)&(TCPF_LISTEN|TCPF_CLOSE))
  286.     && sk->daddr != LOOPBACK4_IPV6) {
  287. tp->ext_header_len = opt->opt_flen + opt->opt_nflen;
  288. tcp_sync_mss(sk, tp->pmtu_cookie);
  289. }
  290. }
  291. opt = xchg(&np->opt, opt);
  292. sk_dst_reset(sk);
  293. } else {
  294. write_lock(&sk->dst_lock);
  295. opt = xchg(&np->opt, opt);
  296. write_unlock(&sk->dst_lock);
  297. sk_dst_reset(sk);
  298. }
  300. done:
  301. if (opt)
  302. sock_kfree_s(sk, opt, opt->tot_len);
  303. break;
  304. }
  305. case IPV6_UNICAST_HOPS:
  306. if (val > 255 || val < -1)
  307. goto e_inval;
  308. np->hop_limit = val;
  309. retv = 0;
  310. break;
  312. case IPV6_MULTICAST_HOPS:
  313. if (sk->type == SOCK_STREAM)
  314. goto e_inval;
  315. if (val > 255 || val < -1)
  316. goto e_inval;
  317. np->mcast_hops = val;
  318. retv = 0;
  319. break;
  321. case IPV6_MULTICAST_LOOP:
  322. np->mc_loop = valbool;
  323. retv = 0;
  324. break;
  326. case IPV6_MULTICAST_IF:
  327. if (sk->type == SOCK_STREAM)
  328. goto e_inval;
  329. if (sk->bound_dev_if && sk->bound_dev_if != val)
  330. goto e_inval;
  332. if (__dev_get_by_index(val) == NULL) {
  333. retv = -ENODEV;
  334. break;
  335. }
  336. np->mcast_oif = val;
  337. retv = 0;
  338. break;
  339. case IPV6_ADD_MEMBERSHIP:
  340. case IPV6_DROP_MEMBERSHIP:
  341. {
  342. struct ipv6_mreq mreq;
  344. retv = -EFAULT;
  345. if (copy_from_user(&mreq, optval, sizeof(struct ipv6_mreq)))
  346. break;
  348. if (optname == IPV6_ADD_MEMBERSHIP)
  349. retv = ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
  350. else
  351. retv = ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
  352. break;
  353. }
  354. case IPV6_ROUTER_ALERT:
  355. retv = ip6_ra_control(sk, val, NULL);
  356. break;
  357. case IPV6_MTU_DISCOVER:
  358. if (val<0 || val>2)
  359. goto e_inval;
  360. np->pmtudisc = val;
  361. retv = 0;
  362. break;
  363. case IPV6_MTU:
  364. if (val && val < IPV6_MIN_MTU)
  365. goto e_inval;
  366. np->frag_size = val;
  367. retv = 0;
  368. break;
  369. case IPV6_RECVERR:
  370. np->recverr = valbool;
  371. if (!val)
  372. skb_queue_purge(&sk->error_queue);
  373. retv = 0;
  374. break;
  375. case IPV6_FLOWINFO_SEND:
  376. np->sndflow = valbool;
  377. retv = 0;
  378. break;
  379. case IPV6_FLOWLABEL_MGR:
  380. retv = ipv6_flowlabel_opt(sk, optval, optlen);
  381. break;
  383. #ifdef CONFIG_NETFILTER
  384. default:
  385. retv = nf_setsockopt(sk, PF_INET6, optname, optval, 
  386.     optlen);
  387. break;
  388. #endif
  390. }
  391. release_sock(sk);
  393. out:
  394. return retv;
  396. e_inval:
  397. release_sock(sk);
  398. return -EINVAL;
  399. }
  401. int ipv6_getsockopt(struct sock *sk, int level, int optname, char *optval, 
  402.     int *optlen)
  403. {
  404. struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;
  405. int len;
  406. int val;
  408. if(level==SOL_IP && sk->type != SOCK_RAW)
  409. return udp_prot.getsockopt(sk, level, optname, optval, optlen);
  410. if(level!=SOL_IPV6)
  411. return -ENOPROTOOPT;
  412. if (get_user(len, optlen))
  413. return -EFAULT;
  414. switch (optname) {
  415. case IPV6_PKTOPTIONS:
  416. {
  417. struct msghdr msg;
  418. struct sk_buff *skb;
  420. if (sk->type != SOCK_STREAM)
  421. return -ENOPROTOOPT;
  423. msg.msg_control = optval;
  424. msg.msg_controllen = len;
  425. msg.msg_flags = 0;
  427. lock_sock(sk);
  428. skb = np->pktoptions;
  429. if (skb)
  430. atomic_inc(&skb->users);
  431. release_sock(sk);
  433. if (skb) {
  434. int err = datagram_recv_ctl(sk, &msg, skb);
  435. kfree_skb(skb);
  436. if (err)
  437. return err;
  438. } else {
  439. if (np->rxopt.bits.rxinfo) {
  440. struct in6_pktinfo src_info;
  441. src_info.ipi6_ifindex = np->mcast_oif;
  442. ipv6_addr_copy(&src_info.ipi6_addr, &np->daddr);
  443. put_cmsg(&msg, SOL_IPV6, IPV6_PKTINFO, sizeof(src_info), &src_info);
  444. }
  445. if (np->rxopt.bits.rxhlim) {
  446. int hlim = np->mcast_hops;
  447. put_cmsg(&msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);
  448. }
  449. }
  450. len -= msg.msg_controllen;
  451. return put_user(len, optlen);
  452. }
  453. case IPV6_MTU:
  454. {
  455. struct dst_entry *dst;
  456. val = 0;
  457. lock_sock(sk);
  458. dst = sk_dst_get(sk);
  459. if (dst) {
  460. val = dst->pmtu;
  461. dst_release(dst);
  462. }
  463. release_sock(sk);
  464. if (!val)
  465. return -ENOTCONN;
  466. break;
  467. }
  469. case IPV6_PKTINFO:
  470. val = np->rxopt.bits.rxinfo;
  471. break;
  473. case IPV6_HOPLIMIT:
  474. val = np->rxopt.bits.rxhlim;
  475. break;
  477. case IPV6_RTHDR:
  478. val = np->rxopt.bits.srcrt;
  479. break;
  481. case IPV6_HOPOPTS:
  482. val = np->rxopt.bits.hopopts;
  483. break;
  485. case IPV6_AUTHHDR:
  486. val = np->rxopt.bits.authhdr;
  487. break;
  489. case IPV6_DSTOPTS:
  490. val = np->rxopt.bits.dstopts;
  491. break;
  493. case IPV6_FLOWINFO:
  494. val = np->rxopt.bits.rxflow;
  495. break;
  497. case IPV6_UNICAST_HOPS:
  498. val = np->hop_limit;
  499. break;
  501. case IPV6_MULTICAST_HOPS:
  502. val = np->mcast_hops;
  503. break;
  505. case IPV6_MULTICAST_LOOP:
  506. val = np->mc_loop;
  507. break;
  509. case IPV6_MULTICAST_IF:
  510. val = np->mcast_oif;
  511. break;
  513. case IPV6_MTU_DISCOVER:
  514. val = np->pmtudisc;
  515. break;
  517. case IPV6_RECVERR:
  518. val = np->recverr;
  519. break;
  521. case IPV6_FLOWINFO_SEND:
  522. val = np->sndflow;
  523. break;
  525. default:
  526. #ifdef CONFIG_NETFILTER
  527. lock_sock(sk);
  528. val = nf_getsockopt(sk, PF_INET6, optname, optval, 
  529.     &len);
  530. release_sock(sk);
  531. if (val >= 0)
  532. val = put_user(len, optlen);
  533. return val;
  534. #else
  535. return -EINVAL;
  536. #endif
  537. }
  538. len = min_t(unsigned int, sizeof(int), len);
  539. if(put_user(len, optlen))
  540. return -EFAULT;
  541. if(copy_to_user(optval,&val,len))
  542. return -EFAULT;
  543. return 0;
  544. }
  546. #if defined(MODULE) && defined(CONFIG_SYSCTL)
  548. /*
  549.  * sysctl registration functions defined in sysctl_net_ipv6.c
  550.  */
  552. extern void ipv6_sysctl_register(void);
  553. extern void ipv6_sysctl_unregister(void);
  554. #endif
  556. void __init ipv6_packet_init(void)
  557. {
  558. dev_add_pack(&ipv6_packet_type);
  559. }
  561. void __init ipv6_netdev_notif_init(void)
  562. {
  563. register_netdevice_notifier(&ipv6_dev_notf);
  564. }
  566. #ifdef MODULE
  567. void ipv6_packet_cleanup(void)
  568. {
  569. dev_remove_pack(&ipv6_packet_type);
  570. }
  572. void ipv6_netdev_notif_cleanup(void)
  573. {
  574. unregister_netdevice_notifier(&ipv6_dev_notf);
  575. }
  576. #endif