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

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

Linux/Unix编程

开发平台：

Unix_Linux

tcp_ipv6.c：源码内容
  1. /*
  2.  * TCP over IPv6
  3.  * Linux INET6 implementation 
  4.  *
  5.  * Authors:
  6.  * Pedro Roque <roque@di.fc.ul.pt>
  7.  *
  8.  * $Id: tcp_ipv6.c,v 1.142.2.1 2001/12/21 05:06:08 davem Exp $
  9.  *
  10.  * Based on: 
  11.  * linux/net/ipv4/tcp.c
  12.  * linux/net/ipv4/tcp_input.c
  13.  * linux/net/ipv4/tcp_output.c
  14.  *
  15.  * Fixes:
  16.  * Hideaki YOSHIFUJI : sin6_scope_id support
  17.  *
  18.  * This program is free software; you can redistribute it and/or
  19.  *      modify it under the terms of the GNU General Public License
  20.  *      as published by the Free Software Foundation; either version
  21.  *      2 of the License, or (at your option) any later version.
  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/net.h>
  32. #include <linux/sched.h>
  33. #include <linux/in.h>
  34. #include <linux/in6.h>
  35. #include <linux/netdevice.h>
  36. #include <linux/init.h>
  37. #include <linux/ipsec.h>
  39. #include <linux/ipv6.h>
  40. #include <linux/icmpv6.h>
  41. #include <linux/random.h>
  43. #include <net/tcp.h>
  44. #include <net/ndisc.h>
  45. #include <net/ipv6.h>
  46. #include <net/transp_v6.h>
  47. #include <net/addrconf.h>
  48. #include <net/ip6_route.h>
  49. #include <net/inet_ecn.h>
  51. #include <asm/uaccess.h>
  53. static void tcp_v6_send_reset(struct sk_buff *skb);
  54. static void tcp_v6_or_send_ack(struct sk_buff *skb, struct open_request *req);
  55. static void tcp_v6_send_check(struct sock *sk, struct tcphdr *th, int len, 
  56.   struct sk_buff *skb);
  58. static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
  59. static int tcp_v6_xmit(struct sk_buff *skb);
  61. static struct tcp_func ipv6_mapped;
  62. static struct tcp_func ipv6_specific;
  64. /* I have no idea if this is a good hash for v6 or not. -DaveM */
  65. static __inline__ int tcp_v6_hashfn(struct in6_addr *laddr, u16 lport,
  66.     struct in6_addr *faddr, u16 fport)
  67. {
  68. int hashent = (lport ^ fport);
  70. hashent ^= (laddr->s6_addr32[3] ^ faddr->s6_addr32[3]);
  71. hashent ^= hashent>>16;
  72. hashent ^= hashent>>8;
  73. return (hashent & (tcp_ehash_size - 1));
  74. }
  76. static __inline__ int tcp_v6_sk_hashfn(struct sock *sk)
  77. {
  78. struct in6_addr *laddr = &sk->net_pinfo.af_inet6.rcv_saddr;
  79. struct in6_addr *faddr = &sk->net_pinfo.af_inet6.daddr;
  80. __u16 lport = sk->num;
  81. __u16 fport = sk->dport;
  82. return tcp_v6_hashfn(laddr, lport, faddr, fport);
  83. }
  85. /* Grrr, addr_type already calculated by caller, but I don't want
  86.  * to add some silly "cookie" argument to this method just for that.
  87.  * But it doesn't matter, the recalculation is in the rarest path
  88.  * this function ever takes.
  89.  */
  90. static int tcp_v6_get_port(struct sock *sk, unsigned short snum)
  91. {
  92. struct tcp_bind_hashbucket *head;
  93. struct tcp_bind_bucket *tb;
  94. int ret;
  96. local_bh_disable();
  97. if (snum == 0) {
  98. int low = sysctl_local_port_range[0];
  99. int high = sysctl_local_port_range[1];
  100. int remaining = (high - low) + 1;
  101. int rover;
  103. spin_lock(&tcp_portalloc_lock);
  104. rover = tcp_port_rover;
  105. do { rover++;
  106. if ((rover < low) || (rover > high))
  107. rover = low;
  108. head = &tcp_bhash[tcp_bhashfn(rover)];
  109. spin_lock(&head->lock);
  110. for (tb = head->chain; tb; tb = tb->next)
  111. if (tb->port == rover)
  112. goto next;
  113. break;
  114. next:
  115. spin_unlock(&head->lock);
  116. } while (--remaining > 0);
  117. tcp_port_rover = rover;
  118. spin_unlock(&tcp_portalloc_lock);
  120. /* Exhausted local port range during search? */
  121. ret = 1;
  122. if (remaining <= 0)
  123. goto fail;
  125. /* OK, here is the one we will use. */
  126. snum = rover;
  127. tb = NULL;
  128. } else {
  129. head = &tcp_bhash[tcp_bhashfn(snum)];
  130. spin_lock(&head->lock);
  131. for (tb = head->chain; tb != NULL; tb = tb->next)
  132. if (tb->port == snum)
  133. break;
  134. }
  135. if (tb != NULL && tb->owners != NULL) {
  136. if (tb->fastreuse > 0 && sk->reuse != 0 && sk->state != TCP_LISTEN) {
  137. goto success;
  138. } else {
  139. struct sock *sk2 = tb->owners;
  140. int sk_reuse = sk->reuse;
  141. int addr_type = ipv6_addr_type(&sk->net_pinfo.af_inet6.rcv_saddr);
  143. /* We must walk the whole port owner list in this case. -DaveM */
  144. for( ; sk2 != NULL; sk2 = sk2->bind_next) {
  145. if (sk != sk2 &&
  146.     sk->bound_dev_if == sk2->bound_dev_if) {
  147. if (!sk_reuse ||
  148.     !sk2->reuse ||
  149.     sk2->state == TCP_LISTEN) {
  150. /* NOTE: IPv6 tw bucket have different format */
  151. if (!sk2->rcv_saddr ||
  152.     addr_type == IPV6_ADDR_ANY ||
  153.     !ipv6_addr_cmp(&sk->net_pinfo.af_inet6.rcv_saddr,
  154.    sk2->state != TCP_TIME_WAIT ?
  155.    &sk2->net_pinfo.af_inet6.rcv_saddr :
  156.    &((struct tcp_tw_bucket*)sk)->v6_rcv_saddr) ||
  157.     (addr_type==IPV6_ADDR_MAPPED && sk2->family==AF_INET &&
  158.      sk->rcv_saddr==sk2->rcv_saddr))
  159. break;
  160. }
  161. }
  162. }
  163. /* If we found a conflict, fail. */
  164. ret = 1;
  165. if (sk2 != NULL)
  166. goto fail_unlock;
  167. }
  168. }
  169. ret = 1;
  170. if (tb == NULL &&
  171.     (tb = tcp_bucket_create(head, snum)) == NULL)
  172. goto fail_unlock;
  173. if (tb->owners == NULL) {
  174. if (sk->reuse && sk->state != TCP_LISTEN)
  175. tb->fastreuse = 1;
  176. else
  177. tb->fastreuse = 0;
  178. } else if (tb->fastreuse &&
  179.    ((sk->reuse == 0) || (sk->state == TCP_LISTEN)))
  180. tb->fastreuse = 0;
  182. success:
  183. sk->num = snum;
  184. if (sk->prev == NULL) {
  185. if ((sk->bind_next = tb->owners) != NULL)
  186. tb->owners->bind_pprev = &sk->bind_next;
  187. tb->owners = sk;
  188. sk->bind_pprev = &tb->owners;
  189. sk->prev = (struct sock *) tb;
  190. } else {
  191. BUG_TRAP(sk->prev == (struct sock *) tb);
  192. }
  193. ret = 0;
  195. fail_unlock:
  196. spin_unlock(&head->lock);
  197. fail:
  198. local_bh_enable();
  199. return ret;
  200. }
  202. static __inline__ void __tcp_v6_hash(struct sock *sk)
  203. {
  204. struct sock **skp;
  205. rwlock_t *lock;
  207. BUG_TRAP(sk->pprev==NULL);
  209. if(sk->state == TCP_LISTEN) {
  210. skp = &tcp_listening_hash[tcp_sk_listen_hashfn(sk)];
  211. lock = &tcp_lhash_lock;
  212. tcp_listen_wlock();
  213. } else {
  214. skp = &tcp_ehash[(sk->hashent = tcp_v6_sk_hashfn(sk))].chain;
  215. lock = &tcp_ehash[sk->hashent].lock;
  216. write_lock(lock);
  217. }
  219. if((sk->next = *skp) != NULL)
  220. (*skp)->pprev = &sk->next;
  221. *skp = sk;
  222. sk->pprev = skp;
  223. sock_prot_inc_use(sk->prot);
  224. write_unlock(lock);
  225. }
  228. static void tcp_v6_hash(struct sock *sk)
  229. {
  230. if(sk->state != TCP_CLOSE) {
  231. if (sk->tp_pinfo.af_tcp.af_specific == &ipv6_mapped) {
  232. tcp_prot.hash(sk);
  233. return;
  234. }
  235. local_bh_disable();
  236. __tcp_v6_hash(sk);
  237. local_bh_enable();
  238. }
  239. }
  241. static struct sock *tcp_v6_lookup_listener(struct in6_addr *daddr, unsigned short hnum, int dif)
  242. {
  243. struct sock *sk;
  244. struct sock *result = NULL;
  245. int score, hiscore;
  247. hiscore=0;
  248. read_lock(&tcp_lhash_lock);
  249. sk = tcp_listening_hash[tcp_lhashfn(hnum)];
  250. for(; sk; sk = sk->next) {
  251. if((sk->num == hnum) && (sk->family == PF_INET6)) {
  252. struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;
  254. score = 1;
  255. if(!ipv6_addr_any(&np->rcv_saddr)) {
  256. if(ipv6_addr_cmp(&np->rcv_saddr, daddr))
  257. continue;
  258. score++;
  259. }
  260. if (sk->bound_dev_if) {
  261. if (sk->bound_dev_if != dif)
  262. continue;
  263. score++;
  264. }
  265. if (score == 3) {
  266. result = sk;
  267. break;
  268. }
  269. if (score > hiscore) {
  270. hiscore = score;
  271. result = sk;
  272. }
  273. }
  274. }
  275. if (result)
  276. sock_hold(result);
  277. read_unlock(&tcp_lhash_lock);
  278. return result;
  279. }
  281. /* Sockets in TCP_CLOSE state are _always_ taken out of the hash, so
  282.  * we need not check it for TCP lookups anymore, thanks Alexey. -DaveM
  283.  *
  284.  * The sockhash lock must be held as a reader here.
  285.  */
  287. static inline struct sock *__tcp_v6_lookup_established(struct in6_addr *saddr, u16 sport,
  288.        struct in6_addr *daddr, u16 hnum,
  289.        int dif)
  290. {
  291. struct tcp_ehash_bucket *head;
  292. struct sock *sk;
  293. __u32 ports = TCP_COMBINED_PORTS(sport, hnum);
  294. int hash;
  296. /* Optimize here for direct hit, only listening connections can
  297.  * have wildcards anyways.
  298.  */
  299. hash = tcp_v6_hashfn(daddr, hnum, saddr, sport);
  300. head = &tcp_ehash[hash];
  301. read_lock(&head->lock);
  302. for(sk = head->chain; sk; sk = sk->next) {
  303. /* For IPV6 do the cheaper port and family tests first. */
  304. if(TCP_IPV6_MATCH(sk, saddr, daddr, ports, dif))
  305. goto hit; /* You sunk my battleship! */
  306. }
  307. /* Must check for a TIME_WAIT'er before going to listener hash. */
  308. for(sk = (head + tcp_ehash_size)->chain; sk; sk = sk->next) {
  309. if(*((__u32 *)&(sk->dport)) == ports &&
  310.    sk->family == PF_INET6) {
  311. struct tcp_tw_bucket *tw = (struct tcp_tw_bucket *)sk;
  312. if(!ipv6_addr_cmp(&tw->v6_daddr, saddr) &&
  313.    !ipv6_addr_cmp(&tw->v6_rcv_saddr, daddr) &&
  314.    (!sk->bound_dev_if || sk->bound_dev_if == dif))
  315. goto hit;
  316. }
  317. }
  318. read_unlock(&head->lock);
  319. return NULL;
  321. hit:
  322. sock_hold(sk);
  323. read_unlock(&head->lock);
  324. return sk;
  325. }
  328. static inline struct sock *__tcp_v6_lookup(struct in6_addr *saddr, u16 sport,
  329.    struct in6_addr *daddr, u16 hnum,
  330.    int dif)
  331. {
  332. struct sock *sk;
  334. sk = __tcp_v6_lookup_established(saddr, sport, daddr, hnum, dif);
  336. if (sk)
  337. return sk;
  339. return tcp_v6_lookup_listener(daddr, hnum, dif);
  340. }
  342. __inline__ struct sock *tcp_v6_lookup(struct in6_addr *saddr, u16 sport,
  343.       struct in6_addr *daddr, u16 dport,
  344.       int dif)
  345. {
  346. struct sock *sk;
  348. local_bh_disable();
  349. sk = __tcp_v6_lookup(saddr, sport, daddr, ntohs(dport), dif);
  350. local_bh_enable();
  352. return sk;
  353. }
  356. /*
  357.  * Open request hash tables.
  358.  */
  360. static __inline__ unsigned tcp_v6_synq_hash(struct in6_addr *raddr, u16 rport)
  361. {
  362. unsigned h = raddr->s6_addr32[3] ^ rport;
  363. h ^= h>>16;
  364. h ^= h>>8;
  365. return h&(TCP_SYNQ_HSIZE-1);
  366. }
  368. static struct open_request *tcp_v6_search_req(struct tcp_opt *tp,
  369.       struct open_request ***prevp,
  370.       __u16 rport,
  371.       struct in6_addr *raddr,
  372.       struct in6_addr *laddr,
  373.       int iif)
  374. {
  375. struct tcp_listen_opt *lopt = tp->listen_opt;
  376. struct open_request *req, **prev;  
  378. for (prev = &lopt->syn_table[tcp_v6_synq_hash(raddr, rport)];
  379.      (req = *prev) != NULL;
  380.      prev = &req->dl_next) {
  381. if (req->rmt_port == rport &&
  382.     req->class->family == AF_INET6 &&
  383.     !ipv6_addr_cmp(&req->af.v6_req.rmt_addr, raddr) &&
  384.     !ipv6_addr_cmp(&req->af.v6_req.loc_addr, laddr) &&
  385.     (!req->af.v6_req.iif || req->af.v6_req.iif == iif)) {
  386. BUG_TRAP(req->sk == NULL);
  387. *prevp = prev;
  388. return req;
  389. }
  390. }
  392. return NULL;
  393. }
  395. static __inline__ u16 tcp_v6_check(struct tcphdr *th, int len,
  396.    struct in6_addr *saddr, 
  397.    struct in6_addr *daddr, 
  398.    unsigned long base)
  399. {
  400. return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, base);
  401. }
  403. static __u32 tcp_v6_init_sequence(struct sock *sk, struct sk_buff *skb)
  404. {
  405. if (skb->protocol == htons(ETH_P_IPV6)) {
  406. return secure_tcpv6_sequence_number(skb->nh.ipv6h->daddr.s6_addr32,
  407.     skb->nh.ipv6h->saddr.s6_addr32,
  408.     skb->h.th->dest,
  409.     skb->h.th->source);
  410. } else {
  411. return secure_tcp_sequence_number(skb->nh.iph->daddr,
  412.   skb->nh.iph->saddr,
  413.   skb->h.th->dest,
  414.   skb->h.th->source);
  415. }
  416. }
  418. static int tcp_v6_check_established(struct sock *sk)
  419. {
  420. struct in6_addr *daddr = &sk->net_pinfo.af_inet6.rcv_saddr;
  421. struct in6_addr *saddr = &sk->net_pinfo.af_inet6.daddr;
  422. int dif = sk->bound_dev_if;
  423. u32 ports = TCP_COMBINED_PORTS(sk->dport, sk->num);
  424. int hash = tcp_v6_hashfn(daddr, sk->num, saddr, sk->dport);
  425. struct tcp_ehash_bucket *head = &tcp_ehash[hash];
  426. struct sock *sk2, **skp;
  427. struct tcp_tw_bucket *tw;
  429. write_lock_bh(&head->lock);
  431. for(skp = &(head + tcp_ehash_size)->chain; (sk2=*skp)!=NULL; skp = &sk2->next) {
  432. tw = (struct tcp_tw_bucket*)sk2;
  434. if(*((__u32 *)&(sk2->dport)) == ports &&
  435.    sk2->family == PF_INET6 &&
  436.    !ipv6_addr_cmp(&tw->v6_daddr, saddr) &&
  437.    !ipv6_addr_cmp(&tw->v6_rcv_saddr, daddr) &&
  438.    sk2->bound_dev_if == sk->bound_dev_if) {
  439. struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
  441. if (tw->ts_recent_stamp) {
  442. /* See comment in tcp_ipv4.c */
  443. if ((tp->write_seq = tw->snd_nxt+65535+2) == 0)
  444. tp->write_seq = 1;
  445. tp->ts_recent = tw->ts_recent;
  446. tp->ts_recent_stamp = tw->ts_recent_stamp;
  447. sock_hold(sk2);
  448. skp = &head->chain;
  449. goto unique;
  450. } else
  451. goto not_unique;
  452. }
  453. }
  454. tw = NULL;
  456. for(skp = &head->chain; (sk2=*skp)!=NULL; skp = &sk2->next) {
  457. if(TCP_IPV6_MATCH(sk, saddr, daddr, ports, dif))
  458. goto not_unique;
  459. }
  461. unique:
  462. BUG_TRAP(sk->pprev==NULL);
  463. if ((sk->next = *skp) != NULL)
  464. (*skp)->pprev = &sk->next;
  466. *skp = sk;
  467. sk->pprev = skp;
  468. sk->hashent = hash;
  469. sock_prot_inc_use(sk->prot);
  470. write_unlock_bh(&head->lock);
  472. if (tw) {
  473. /* Silly. Should hash-dance instead... */
  474. local_bh_disable();
  475. tcp_tw_deschedule(tw);
  476. tcp_timewait_kill(tw);
  477. NET_INC_STATS_BH(TimeWaitRecycled);
  478. local_bh_enable();
  480. tcp_tw_put(tw);
  481. }
  482. return 0;
  484. not_unique:
  485. write_unlock_bh(&head->lock);
  486. return -EADDRNOTAVAIL;
  487. }
  489. static int tcp_v6_hash_connect(struct sock *sk)
  490. {
  491. struct tcp_bind_hashbucket *head;
  492. struct tcp_bind_bucket *tb;
  494. /* XXX */ 
  495. if (sk->num == 0) { 
  496. int err = tcp_v6_get_port(sk, sk->num);
  497. if (err)
  498. return err;
  499. sk->sport = htons(sk->num); 
  500. }
  502. head = &tcp_bhash[tcp_bhashfn(sk->num)];
  503. tb = head->chain;
  505. spin_lock_bh(&head->lock);
  507. if (tb->owners == sk && sk->bind_next == NULL) {
  508. __tcp_v6_hash(sk);
  509. spin_unlock_bh(&head->lock);
  510. return 0;
  511. } else {
  512. spin_unlock_bh(&head->lock);
  513. return tcp_v6_check_established(sk);
  514. }
  515. }
  517. static __inline__ int tcp_v6_iif(struct sk_buff *skb)
  518. {
  519. struct inet6_skb_parm *opt = (struct inet6_skb_parm *) skb->cb;
  520. return opt->iif;
  521. }
  523. static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr, 
  524.   int addr_len)
  525. {
  526. struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
  527. struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;
  528. struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
  529. struct in6_addr *saddr = NULL;
  530. struct in6_addr saddr_buf;
  531. struct flowi fl;
  532. struct dst_entry *dst;
  533. int addr_type;
  534. int err;
  536. if (addr_len < SIN6_LEN_RFC2133) 
  537. return -EINVAL;
  539. if (usin->sin6_family != AF_INET6) 
  540. return(-EAFNOSUPPORT);
  542. fl.fl6_flowlabel = 0;
  543. if (np->sndflow) {
  544. fl.fl6_flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
  545. IP6_ECN_flow_init(fl.fl6_flowlabel);
  546. if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) {
  547. struct ip6_flowlabel *flowlabel;
  548. flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
  549. if (flowlabel == NULL)
  550. return -EINVAL;
  551. ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
  552. fl6_sock_release(flowlabel);
  553. }
  554. }
  556. /*
  557.     * connect() to INADDR_ANY means loopback (BSD'ism).
  558.     */
  559.   
  560.    if(ipv6_addr_any(&usin->sin6_addr))
  561. usin->sin6_addr.s6_addr[15] = 0x1; 
  563. addr_type = ipv6_addr_type(&usin->sin6_addr);
  565. if(addr_type & IPV6_ADDR_MULTICAST)
  566. return -ENETUNREACH;
  568. if (addr_type&IPV6_ADDR_LINKLOCAL) {
  569. if (addr_len >= sizeof(struct sockaddr_in6) &&
  570.     usin->sin6_scope_id) {
  571. /* If interface is set while binding, indices
  572.  * must coincide.
  573.  */
  574. if (sk->bound_dev_if &&
  575.     sk->bound_dev_if != usin->sin6_scope_id)
  576. return -EINVAL;
  578. sk->bound_dev_if = usin->sin6_scope_id;
  579. }
  581. /* Connect to link-local address requires an interface */
  582. if (sk->bound_dev_if == 0)
  583. return -EINVAL;
  584. }
  586. if (tp->ts_recent_stamp && ipv6_addr_cmp(&np->daddr, &usin->sin6_addr)) {
  587. tp->ts_recent = 0;
  588. tp->ts_recent_stamp = 0;
  589. tp->write_seq = 0;
  590. }
  592. ipv6_addr_copy(&np->daddr, &usin->sin6_addr);
  593. np->flow_label = fl.fl6_flowlabel;
  595. /*
  596.  * TCP over IPv4
  597.  */
  599. if (addr_type == IPV6_ADDR_MAPPED) {
  600. u32 exthdrlen = tp->ext_header_len;
  601. struct sockaddr_in sin;
  603. SOCK_DEBUG(sk, "connect: ipv4 mappedn");
  605. sin.sin_family = AF_INET;
  606. sin.sin_port = usin->sin6_port;
  607. sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
  609. sk->tp_pinfo.af_tcp.af_specific = &ipv6_mapped;
  610. sk->backlog_rcv = tcp_v4_do_rcv;
  612. err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
  614. if (err) {
  615. tp->ext_header_len = exthdrlen;
  616. sk->tp_pinfo.af_tcp.af_specific = &ipv6_specific;
  617. sk->backlog_rcv = tcp_v6_do_rcv;
  618. goto failure;
  619. } else {
  620. ipv6_addr_set(&np->saddr, 0, 0, htonl(0x0000FFFF),
  621.       sk->saddr);
  622. ipv6_addr_set(&np->rcv_saddr, 0, 0, htonl(0x0000FFFF),
  623.       sk->rcv_saddr);
  624. }
  626. return err;
  627. }
  629. if (!ipv6_addr_any(&np->rcv_saddr))
  630. saddr = &np->rcv_saddr;
  632. fl.proto = IPPROTO_TCP;
  633. fl.fl6_dst = &np->daddr;
  634. fl.fl6_src = saddr;
  635. fl.oif = sk->bound_dev_if;
  636. fl.uli_u.ports.dport = usin->sin6_port;
  637. fl.uli_u.ports.sport = sk->sport;
  639. if (np->opt && np->opt->srcrt) {
  640. struct rt0_hdr *rt0 = (struct rt0_hdr *) np->opt->srcrt;
  641. fl.nl_u.ip6_u.daddr = rt0->addr;
  642. }
  644. dst = ip6_route_output(sk, &fl);
  646. if ((err = dst->error) != 0) {
  647. dst_release(dst);
  648. goto failure;
  649. }
  651. ip6_dst_store(sk, dst, NULL);
  652. sk->route_caps = dst->dev->features&~NETIF_F_IP_CSUM;
  654. if (saddr == NULL) {
  655. err = ipv6_get_saddr(dst, &np->daddr, &saddr_buf);
  656. if (err)
  657. goto failure;
  659. saddr = &saddr_buf;
  660. }
  662. /* set the source address */
  663. ipv6_addr_copy(&np->rcv_saddr, saddr);
  664. ipv6_addr_copy(&np->saddr, saddr);
  665. sk->rcv_saddr= LOOPBACK4_IPV6;
  667. tp->ext_header_len = 0;
  668. if (np->opt)
  669. tp->ext_header_len = np->opt->opt_flen+np->opt->opt_nflen;
  670. tp->mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
  672. sk->dport = usin->sin6_port;
  674. tcp_set_state(sk, TCP_SYN_SENT); 
  675. err = tcp_v6_hash_connect(sk); 
  676. if (err)
  677. goto late_failure;
  679. if (!tp->write_seq)
  680. tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
  681.      np->daddr.s6_addr32,
  682.      sk->sport, sk->dport);
  683. err = tcp_connect(sk);
  684. if (err)
  685. goto late_failure;
  687. return 0;
  689. late_failure:
  690. tcp_set_state(sk, TCP_CLOSE); 
  691. failure:
  692. __sk_dst_reset(sk);
  693. sk->dport = 0;
  694. sk->route_caps = 0;
  695. return err;
  696. }
  698. void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
  699. int type, int code, int offset, __u32 info)
  700. {
  701. struct ipv6hdr *hdr = (struct ipv6hdr*)skb->data;
  702. struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
  703. struct ipv6_pinfo *np;
  704. struct sock *sk;
  705. int err;
  706. struct tcp_opt *tp; 
  707. __u32 seq;
  709. sk = tcp_v6_lookup(&hdr->daddr, th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
  711. if (sk == NULL) {
  712. ICMP6_INC_STATS_BH(Icmp6InErrors);
  713. return;
  714. }
  716. if (sk->state == TCP_TIME_WAIT) {
  717. tcp_tw_put((struct tcp_tw_bucket*)sk);
  718. return;
  719. }
  721. bh_lock_sock(sk);
  722. if (sk->lock.users)
  723. NET_INC_STATS_BH(LockDroppedIcmps);
  725. if (sk->state == TCP_CLOSE)
  726. goto out;
  728. tp = &sk->tp_pinfo.af_tcp;
  729. seq = ntohl(th->seq); 
  730. if (sk->state != TCP_LISTEN && !between(seq, tp->snd_una, tp->snd_nxt)) {
  731. NET_INC_STATS_BH(OutOfWindowIcmps);
  732. goto out;
  733. }
  735. np = &sk->net_pinfo.af_inet6;
  737. if (type == ICMPV6_PKT_TOOBIG) {
  738. struct dst_entry *dst = NULL;
  740. if (sk->lock.users)
  741. goto out;
  742. if ((1<<sk->state)&(TCPF_LISTEN|TCPF_CLOSE))
  743. goto out;
  745. /* icmp should have updated the destination cache entry */
  746. dst = __sk_dst_check(sk, np->dst_cookie);
  748. if (dst == NULL) {
  749. struct flowi fl;
  751. /* BUGGG_FUTURE: Again, it is not clear how
  752.    to handle rthdr case. Ignore this complexity
  753.    for now.
  754.  */
  755. fl.proto = IPPROTO_TCP;
  756. fl.nl_u.ip6_u.daddr = &np->daddr;
  757. fl.nl_u.ip6_u.saddr = &np->saddr;
  758. fl.oif = sk->bound_dev_if;
  759. fl.uli_u.ports.dport = sk->dport;
  760. fl.uli_u.ports.sport = sk->sport;
  762. dst = ip6_route_output(sk, &fl);
  763. } else
  764. dst_clone(dst);
  766. if (dst->error) {
  767. sk->err_soft = -dst->error;
  768. } else if (tp->pmtu_cookie > dst->pmtu) {
  769. tcp_sync_mss(sk, dst->pmtu);
  770. tcp_simple_retransmit(sk);
  771. } /* else let the usual retransmit timer handle it */
  772. dst_release(dst);
  773. goto out;
  774. }
  776. icmpv6_err_convert(type, code, &err);
  778. /* Might be for an open_request */
  779. switch (sk->state) {
  780. struct open_request *req, **prev;
  781. case TCP_LISTEN:
  782. if (sk->lock.users)
  783. goto out;
  785. req = tcp_v6_search_req(tp, &prev, th->dest, &hdr->daddr,
  786. &hdr->saddr, tcp_v6_iif(skb));
  787. if (!req)
  788. goto out;
  790. /* ICMPs are not backlogged, hence we cannot get
  791.  * an established socket here.
  792.  */
  793. BUG_TRAP(req->sk == NULL);
  795. if (seq != req->snt_isn) {
  796. NET_INC_STATS_BH(OutOfWindowIcmps);
  797. goto out;
  798. }
  800. tcp_synq_drop(sk, req, prev);
  801. goto out;
  803. case TCP_SYN_SENT:
  804. case TCP_SYN_RECV:  /* Cannot happen.
  805.        It can, it SYNs are crossed. --ANK */ 
  806. if (sk->lock.users == 0) {
  807. TCP_INC_STATS_BH(TcpAttemptFails);
  808. sk->err = err;
  809. sk->error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
  811. tcp_done(sk);
  812. } else {
  813. sk->err_soft = err;
  814. }
  815. goto out;
  816. }
  818. if (sk->lock.users == 0 && np->recverr) {
  819. sk->err = err;
  820. sk->error_report(sk);
  821. } else {
  822. sk->err_soft = err;
  823. }
  825. out:
  826. bh_unlock_sock(sk);
  827. sock_put(sk);
  828. }
  831. static int tcp_v6_send_synack(struct sock *sk, struct open_request *req,
  832.       struct dst_entry *dst)
  833. {
  834. struct sk_buff * skb;
  835. struct ipv6_txoptions *opt = NULL;
  836. struct flowi fl;
  837. int err = -1;
  839. fl.proto = IPPROTO_TCP;
  840. fl.nl_u.ip6_u.daddr = &req->af.v6_req.rmt_addr;
  841. fl.nl_u.ip6_u.saddr = &req->af.v6_req.loc_addr;
  842. fl.fl6_flowlabel = 0;
  843. fl.oif = req->af.v6_req.iif;
  844. fl.uli_u.ports.dport = req->rmt_port;
  845. fl.uli_u.ports.sport = sk->sport;
  847. if (dst == NULL) {
  848. opt = sk->net_pinfo.af_inet6.opt;
  849. if (opt == NULL &&
  850.     sk->net_pinfo.af_inet6.rxopt.bits.srcrt == 2 &&
  851.     req->af.v6_req.pktopts) {
  852. struct sk_buff *pktopts = req->af.v6_req.pktopts;
  853. struct inet6_skb_parm *rxopt = (struct inet6_skb_parm *)pktopts->cb;
  854. if (rxopt->srcrt)
  855. opt = ipv6_invert_rthdr(sk, (struct ipv6_rt_hdr*)(pktopts->nh.raw + rxopt->srcrt));
  856. }
  858. if (opt && opt->srcrt) {
  859. struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
  860. fl.nl_u.ip6_u.daddr = rt0->addr;
  861. }
  863. dst = ip6_route_output(sk, &fl);
  864. if (dst->error)
  865. goto done;
  866. }
  868. skb = tcp_make_synack(sk, dst, req);
  869. if (skb) {
  870. struct tcphdr *th = skb->h.th;
  872. th->check = tcp_v6_check(th, skb->len,
  873.  &req->af.v6_req.loc_addr, &req->af.v6_req.rmt_addr,
  874.  csum_partial((char *)th, skb->len, skb->csum));
  876. fl.nl_u.ip6_u.daddr = &req->af.v6_req.rmt_addr;
  877. err = ip6_xmit(sk, skb, &fl, opt);
  878. if (err == NET_XMIT_CN)
  879. err = 0;
  880. }
  882. done:
  883. dst_release(dst);
  884.         if (opt && opt != sk->net_pinfo.af_inet6.opt)
  885. sock_kfree_s(sk, opt, opt->tot_len);
  886. return err;
  887. }
  889. static void tcp_v6_or_free(struct open_request *req)
  890. {
  891. if (req->af.v6_req.pktopts)
  892. kfree_skb(req->af.v6_req.pktopts);
  893. }
  895. static struct or_calltable or_ipv6 = {
  896. AF_INET6,
  897. tcp_v6_send_synack,
  898. tcp_v6_or_send_ack,
  899. tcp_v6_or_free,
  900. tcp_v6_send_reset
  901. };
  903. static int ipv6_opt_accepted(struct sock *sk, struct sk_buff *skb)
  904. {
  905. struct inet6_skb_parm *opt = (struct inet6_skb_parm *)skb->cb;
  907. if (sk->net_pinfo.af_inet6.rxopt.all) {
  908. if ((opt->hop && sk->net_pinfo.af_inet6.rxopt.bits.hopopts) ||
  909.     ((IPV6_FLOWINFO_MASK&*(u32*)skb->nh.raw) &&
  910.      sk->net_pinfo.af_inet6.rxopt.bits.rxflow) ||
  911.     (opt->srcrt && sk->net_pinfo.af_inet6.rxopt.bits.srcrt) ||
  912.     ((opt->dst1 || opt->dst0) && sk->net_pinfo.af_inet6.rxopt.bits.dstopts))
  913. return 1;
  914. }
  915. return 0;
  916. }
  919. static void tcp_v6_send_check(struct sock *sk, struct tcphdr *th, int len, 
  920.       struct sk_buff *skb)
  921. {
  922. struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;
  924. if (skb->ip_summed == CHECKSUM_HW) {
  925. th->check = csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP,  0);
  926. skb->csum = offsetof(struct tcphdr, check);
  927. } else {
  928. th->check = csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP, 
  929.     csum_partial((char *)th, th->doff<<2, 
  930.  skb->csum));
  931. }
  932. }
  935. static void tcp_v6_send_reset(struct sk_buff *skb)
  936. {
  937. struct tcphdr *th = skb->h.th, *t1; 
  938. struct sk_buff *buff;
  939. struct flowi fl;
  941. if (th->rst)
  942. return;
  944. if (ipv6_addr_is_multicast(&skb->nh.ipv6h->daddr))
  945. return; 
  947. /*
  948.  * We need to grab some memory, and put together an RST,
  949.  * and then put it into the queue to be sent.
  950.  */
  952. buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr), GFP_ATOMIC);
  953. if (buff == NULL) 
  954.    return;
  956. skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr));
  958. t1 = (struct tcphdr *) skb_push(buff,sizeof(struct tcphdr));
  960. /* Swap the send and the receive. */
  961. memset(t1, 0, sizeof(*t1));
  962. t1->dest = th->source;
  963. t1->source = th->dest;
  964. t1->doff = sizeof(*t1)/4;
  965. t1->rst = 1;
  966.   
  967. if(th->ack) {
  968.    t1->seq = th->ack_seq;
  969. } else {
  970. t1->ack = 1;
  971. t1->ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin
  972.     + skb->len - (th->doff<<2));
  973. }
  975. buff->csum = csum_partial((char *)t1, sizeof(*t1), 0);
  977. fl.nl_u.ip6_u.daddr = &skb->nh.ipv6h->saddr;
  978. fl.nl_u.ip6_u.saddr = &skb->nh.ipv6h->daddr;
  979. fl.fl6_flowlabel = 0;
  981. t1->check = csum_ipv6_magic(fl.nl_u.ip6_u.saddr,
  982.     fl.nl_u.ip6_u.daddr, 
  983.     sizeof(*t1), IPPROTO_TCP,
  984.     buff->csum);
  986. fl.proto = IPPROTO_TCP;
  987. fl.oif = tcp_v6_iif(skb);
  988. fl.uli_u.ports.dport = t1->dest;
  989. fl.uli_u.ports.sport = t1->source;
  991. /* sk = NULL, but it is safe for now. RST socket required. */
  992. buff->dst = ip6_route_output(NULL, &fl);
  994. if (buff->dst->error == 0) {
  995. ip6_xmit(NULL, buff, &fl, NULL);
  996. TCP_INC_STATS_BH(TcpOutSegs);
  997. TCP_INC_STATS_BH(TcpOutRsts);
  998. return;
  999. }
  1001. kfree_skb(buff);
  1002. }
  1004. static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack, u32 win, u32 ts)
  1005. {
  1006. struct tcphdr *th = skb->h.th, *t1;
  1007. struct sk_buff *buff;
  1008. struct flowi fl;
  1009. int tot_len = sizeof(struct tcphdr);
  1011. buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr), GFP_ATOMIC);
  1012. if (buff == NULL)
  1013. return;
  1015. skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr));
  1017. if (ts)
  1018. tot_len += 3*4;
  1020. t1 = (struct tcphdr *) skb_push(buff,tot_len);
  1022. /* Swap the send and the receive. */
  1023. memset(t1, 0, sizeof(*t1));
  1024. t1->dest = th->source;
  1025. t1->source = th->dest;
  1026. t1->doff = tot_len/4;
  1027. t1->seq = htonl(seq);
  1028. t1->ack_seq = htonl(ack);
  1029. t1->ack = 1;
  1030. t1->window = htons(win);
  1032. if (ts) {
  1033. u32 *ptr = (u32*)(t1 + 1);
  1034. *ptr++ = htonl((TCPOPT_NOP << 24) |
  1035.        (TCPOPT_NOP << 16) |
  1036.        (TCPOPT_TIMESTAMP << 8) |
  1037.        TCPOLEN_TIMESTAMP);
  1038. *ptr++ = htonl(tcp_time_stamp);
  1039. *ptr = htonl(ts);
  1040. }
  1042. buff->csum = csum_partial((char *)t1, tot_len, 0);
  1044. fl.nl_u.ip6_u.daddr = &skb->nh.ipv6h->saddr;
  1045. fl.nl_u.ip6_u.saddr = &skb->nh.ipv6h->daddr;
  1046. fl.fl6_flowlabel = 0;
  1048. t1->check = csum_ipv6_magic(fl.nl_u.ip6_u.saddr,
  1049.     fl.nl_u.ip6_u.daddr, 
  1050.     tot_len, IPPROTO_TCP,
  1051.     buff->csum);
  1053. fl.proto = IPPROTO_TCP;
  1054. fl.oif = tcp_v6_iif(skb);
  1055. fl.uli_u.ports.dport = t1->dest;
  1056. fl.uli_u.ports.sport = t1->source;
  1058. buff->dst = ip6_route_output(NULL, &fl);
  1060. if (buff->dst->error == 0) {
  1061. ip6_xmit(NULL, buff, &fl, NULL);
  1062. TCP_INC_STATS_BH(TcpOutSegs);
  1063. return;
  1064. }
  1066. kfree_skb(buff);
  1067. }
  1069. static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
  1070. {
  1071. struct tcp_tw_bucket *tw = (struct tcp_tw_bucket *)sk;
  1073. tcp_v6_send_ack(skb, tw->snd_nxt, tw->rcv_nxt,
  1074. tw->rcv_wnd>>tw->rcv_wscale, tw->ts_recent);
  1076. tcp_tw_put(tw);
  1077. }
  1079. static void tcp_v6_or_send_ack(struct sk_buff *skb, struct open_request *req)
  1080. {
  1081. tcp_v6_send_ack(skb, req->snt_isn+1, req->rcv_isn+1, req->rcv_wnd, req->ts_recent);
  1082. }
  1085. static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
  1086. {
  1087. struct open_request *req, **prev;
  1088. struct tcphdr *th = skb->h.th;
  1089. struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
  1090. struct sock *nsk;
  1092. /* Find possible connection requests. */
  1093. req = tcp_v6_search_req(tp, &prev, th->source, &skb->nh.ipv6h->saddr,
  1094. &skb->nh.ipv6h->daddr, tcp_v6_iif(skb));
  1095. if (req)
  1096. return tcp_check_req(sk, skb, req, prev);
  1098. nsk = __tcp_v6_lookup_established(&skb->nh.ipv6h->saddr,
  1099.   th->source,
  1100.   &skb->nh.ipv6h->daddr,
  1101.   ntohs(th->dest),
  1102.   tcp_v6_iif(skb));
  1104. if (nsk) {
  1105. if (nsk->state != TCP_TIME_WAIT) {
  1106. bh_lock_sock(nsk);
  1107. return nsk;
  1108. }
  1109. tcp_tw_put((struct tcp_tw_bucket*)nsk);
  1110. return NULL;
  1111. }
  1113. #if 0 /*def CONFIG_SYN_COOKIES*/
  1114. if (!th->rst && !th->syn && th->ack)
  1115. sk = cookie_v6_check(sk, skb, &(IPCB(skb)->opt));
  1116. #endif
  1117. return sk;
  1118. }
  1120. static void tcp_v6_synq_add(struct sock *sk, struct open_request *req)
  1121. {
  1122. struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
  1123. struct tcp_listen_opt *lopt = tp->listen_opt;
  1124. unsigned h = tcp_v6_synq_hash(&req->af.v6_req.rmt_addr, req->rmt_port);
  1126. req->sk = NULL;
  1127. req->expires = jiffies + TCP_TIMEOUT_INIT;
  1128. req->retrans = 0;
  1129. req->dl_next = lopt->syn_table[h];
  1131. write_lock(&tp->syn_wait_lock);
  1132. lopt->syn_table[h] = req;
  1133. write_unlock(&tp->syn_wait_lock);
  1135. tcp_synq_added(sk);
  1136. }
  1139. /* FIXME: this is substantially similar to the ipv4 code.
  1140.  * Can some kind of merge be done? -- erics
  1141.  */
  1142. static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
  1143. {
  1144. struct tcp_opt tp;
  1145. struct open_request *req = NULL;
  1146. __u32 isn = TCP_SKB_CB(skb)->when;
  1148. if (skb->protocol == htons(ETH_P_IP))
  1149. return tcp_v4_conn_request(sk, skb);
  1151. /* FIXME: do the same check for anycast */
  1152. if (ipv6_addr_is_multicast(&skb->nh.ipv6h->daddr))
  1153. goto drop; 
  1155. /*
  1156.  * There are no SYN attacks on IPv6, yet...
  1157.  */
  1158. if (tcp_synq_is_full(sk) && !isn) {
  1159. if (net_ratelimit())
  1160. printk(KERN_INFO "TCPv6: dropping request, synflood is possiblen");
  1161. goto drop;
  1162. }
  1164. if (tcp_acceptq_is_full(sk) && tcp_synq_young(sk) > 1)
  1165. goto drop;
  1167. req = tcp_openreq_alloc();
  1168. if (req == NULL)
  1169. goto drop;
  1171. tcp_clear_options(&tp);
  1172. tp.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
  1173. tp.user_mss = sk->tp_pinfo.af_tcp.user_mss;
  1175. tcp_parse_options(skb, &tp, 0);
  1177. tp.tstamp_ok = tp.saw_tstamp;
  1178. tcp_openreq_init(req, &tp, skb);
  1180. req->class = &or_ipv6;
  1181. ipv6_addr_copy(&req->af.v6_req.rmt_addr, &skb->nh.ipv6h->saddr);
  1182. ipv6_addr_copy(&req->af.v6_req.loc_addr, &skb->nh.ipv6h->daddr);
  1183. TCP_ECN_create_request(req, skb->h.th);
  1184. req->af.v6_req.pktopts = NULL;
  1185. if (ipv6_opt_accepted(sk, skb) ||
  1186.     sk->net_pinfo.af_inet6.rxopt.bits.rxinfo ||
  1187.     sk->net_pinfo.af_inet6.rxopt.bits.rxhlim) {
  1188. atomic_inc(&skb->users);
  1189. req->af.v6_req.pktopts = skb;
  1190. }
  1191. req->af.v6_req.iif = sk->bound_dev_if;
  1193. /* So that link locals have meaning */
  1194. if (!sk->bound_dev_if && ipv6_addr_type(&req->af.v6_req.rmt_addr)&IPV6_ADDR_LINKLOCAL)
  1195. req->af.v6_req.iif = tcp_v6_iif(skb);
  1197. if (isn == 0) 
  1198. isn = tcp_v6_init_sequence(sk,skb);
  1200. req->snt_isn = isn;
  1202. if (tcp_v6_send_synack(sk, req, NULL))
  1203. goto drop;
  1205. tcp_v6_synq_add(sk, req);
  1207. return 0;
  1209. drop:
  1210. if (req)
  1211. tcp_openreq_free(req);
  1213. TCP_INC_STATS_BH(TcpAttemptFails);
  1214. return 0; /* don't send reset */
  1215. }
  1217. static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
  1218.   struct open_request *req,
  1219.   struct dst_entry *dst)
  1220. {
  1221. struct ipv6_pinfo *np;
  1222. struct flowi fl;
  1223. struct tcp_opt *newtp;
  1224. struct sock *newsk;
  1225. struct ipv6_txoptions *opt;
  1227. if (skb->protocol == htons(ETH_P_IP)) {
  1228. /*
  1229.  * v6 mapped
  1230.  */
  1232. newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
  1234. if (newsk == NULL) 
  1235. return NULL;
  1237. np = &newsk->net_pinfo.af_inet6;
  1239. ipv6_addr_set(&np->daddr, 0, 0, htonl(0x0000FFFF),
  1240.       newsk->daddr);
  1242. ipv6_addr_set(&np->saddr, 0, 0, htonl(0x0000FFFF),
  1243.       newsk->saddr);
  1245. ipv6_addr_copy(&np->rcv_saddr, &np->saddr);
  1247. newsk->tp_pinfo.af_tcp.af_specific = &ipv6_mapped;
  1248. newsk->backlog_rcv = tcp_v4_do_rcv;
  1249. newsk->net_pinfo.af_inet6.pktoptions = NULL;
  1250. newsk->net_pinfo.af_inet6.opt = NULL;
  1251. newsk->net_pinfo.af_inet6.mcast_oif = tcp_v6_iif(skb);
  1252. newsk->net_pinfo.af_inet6.mcast_hops = skb->nh.ipv6h->hop_limit;
  1254. /* Charge newly allocated IPv6 socket. Though it is mapped,
  1255.  * it is IPv6 yet.
  1256.  */
  1257. #ifdef INET_REFCNT_DEBUG
  1258. atomic_inc(&inet6_sock_nr);
  1259. #endif
  1260. MOD_INC_USE_COUNT;
  1262. /* It is tricky place. Until this moment IPv4 tcp
  1263.    worked with IPv6 af_tcp.af_specific.
  1264.    Sync it now.
  1265.  */
  1266. tcp_sync_mss(newsk, newsk->tp_pinfo.af_tcp.pmtu_cookie);
  1268. return newsk;
  1269. }
  1271. opt = sk->net_pinfo.af_inet6.opt;
  1273. if (tcp_acceptq_is_full(sk))
  1274. goto out_overflow;
  1276. if (sk->net_pinfo.af_inet6.rxopt.bits.srcrt == 2 &&
  1277.     opt == NULL && req->af.v6_req.pktopts) {
  1278. struct inet6_skb_parm *rxopt = (struct inet6_skb_parm *)req->af.v6_req.pktopts->cb;
  1279. if (rxopt->srcrt)
  1280. opt = ipv6_invert_rthdr(sk, (struct ipv6_rt_hdr*)(req->af.v6_req.pktopts->nh.raw+rxopt->srcrt));
  1281. }
  1283. if (dst == NULL) {
  1284. fl.proto = IPPROTO_TCP;
  1285. fl.nl_u.ip6_u.daddr = &req->af.v6_req.rmt_addr;
  1286. if (opt && opt->srcrt) {
  1287. struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
  1288. fl.nl_u.ip6_u.daddr = rt0->addr;
  1289. }
  1290. fl.nl_u.ip6_u.saddr = &req->af.v6_req.loc_addr;
  1291. fl.fl6_flowlabel = 0;
  1292. fl.oif = sk->bound_dev_if;
  1293. fl.uli_u.ports.dport = req->rmt_port;
  1294. fl.uli_u.ports.sport = sk->sport;
  1296. dst = ip6_route_output(sk, &fl);
  1297. }
  1299. if (dst->error)
  1300. goto out;
  1302. newsk = tcp_create_openreq_child(sk, req, skb);
  1303. if (newsk == NULL)
  1304. goto out;
  1306. /* Charge newly allocated IPv6 socket */
  1307. #ifdef INET_REFCNT_DEBUG
  1308. atomic_inc(&inet6_sock_nr);
  1309. #endif
  1310. MOD_INC_USE_COUNT;
  1312. ip6_dst_store(newsk, dst, NULL);
  1313. sk->route_caps = dst->dev->features&~NETIF_F_IP_CSUM;
  1315. newtp = &(newsk->tp_pinfo.af_tcp);
  1317. np = &newsk->net_pinfo.af_inet6;
  1318. ipv6_addr_copy(&np->daddr, &req->af.v6_req.rmt_addr);
  1319. ipv6_addr_copy(&np->saddr, &req->af.v6_req.loc_addr);
  1320. ipv6_addr_copy(&np->rcv_saddr, &req->af.v6_req.loc_addr);
  1321. newsk->bound_dev_if = req->af.v6_req.iif;
  1323. /* Now IPv6 options... 
  1325.    First: no IPv4 options.
  1326.  */
  1327. newsk->protinfo.af_inet.opt = NULL;
  1329. /* Clone RX bits */
  1330. np->rxopt.all = sk->net_pinfo.af_inet6.rxopt.all;
  1332. /* Clone pktoptions received with SYN */
  1333. np->pktoptions = NULL;
  1334. if (req->af.v6_req.pktopts) {
  1335. np->pktoptions = skb_clone(req->af.v6_req.pktopts, GFP_ATOMIC);
  1336. kfree_skb(req->af.v6_req.pktopts);
  1337. req->af.v6_req.pktopts = NULL;
  1338. if (np->pktoptions)
  1339. skb_set_owner_r(np->pktoptions, newsk);
  1340. }
  1341. np->opt = NULL;
  1342. np->mcast_oif = tcp_v6_iif(skb);
  1343. np->mcast_hops = skb->nh.ipv6h->hop_limit;
  1345. /* Clone native IPv6 options from listening socket (if any)
  1347.    Yes, keeping reference count would be much more clever,
  1348.    but we make one more one thing there: reattach optmem
  1349.    to newsk.
  1350.  */
  1351. if (opt) {
  1352. np->opt = ipv6_dup_options(newsk, opt);
  1353. if (opt != sk->net_pinfo.af_inet6.opt)
  1354. sock_kfree_s(sk, opt, opt->tot_len);
  1355. }
  1357. newtp->ext_header_len = 0;
  1358. if (np->opt)
  1359. newtp->ext_header_len = np->opt->opt_nflen + np->opt->opt_flen;
  1361. tcp_sync_mss(newsk, dst->pmtu);
  1362. newtp->advmss = dst->advmss;
  1363. tcp_initialize_rcv_mss(newsk);
  1365. newsk->daddr = LOOPBACK4_IPV6;
  1366. newsk->saddr = LOOPBACK4_IPV6;
  1367. newsk->rcv_saddr= LOOPBACK4_IPV6;
  1369. __tcp_v6_hash(newsk);
  1370. tcp_inherit_port(sk, newsk);
  1372. return newsk;
  1374. out_overflow:
  1375. NET_INC_STATS_BH(ListenOverflows);
  1376. out:
  1377. NET_INC_STATS_BH(ListenDrops);
  1378. if (opt && opt != sk->net_pinfo.af_inet6.opt)
  1379. sock_kfree_s(sk, opt, opt->tot_len);
  1380. dst_release(dst);
  1381. return NULL;
  1382. }
  1384. static int tcp_v6_checksum_init(struct sk_buff *skb)
  1385. {
  1386. if (skb->ip_summed == CHECKSUM_HW) {
  1387. skb->ip_summed = CHECKSUM_UNNECESSARY;
  1388. if (!tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
  1389.   &skb->nh.ipv6h->daddr,skb->csum))
  1390. return 0;
  1391. NETDEBUG(if (net_ratelimit()) printk(KERN_DEBUG "hw tcp v6 csum failedn"));
  1392. }
  1393. if (skb->len <= 76) {
  1394. if (tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
  1395.  &skb->nh.ipv6h->daddr,skb_checksum(skb, 0, skb->len, 0)))
  1396. return -1;
  1397. skb->ip_summed = CHECKSUM_UNNECESSARY;
  1398. } else {
  1399. skb->csum = ~tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
  1400.   &skb->nh.ipv6h->daddr,0);
  1401. }
  1402. return 0;
  1403. }
  1405. /* The socket must have it's spinlock held when we get
  1406.  * here.
  1407.  *
  1408.  * We have a potential double-lock case here, so even when
  1409.  * doing backlog processing we use the BH locking scheme.
  1410.  * This is because we cannot sleep with the original spinlock
  1411.  * held.
  1412.  */
  1413. static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
  1414. {
  1415. #ifdef CONFIG_FILTER
  1416. struct sk_filter *filter;
  1417. #endif
  1418. struct sk_buff *opt_skb = NULL;
  1420. /* Imagine: socket is IPv6. IPv4 packet arrives,
  1421.    goes to IPv4 receive handler and backlogged.
  1422.    From backlog it always goes here. Kerboom...
  1423.    Fortunately, tcp_rcv_established and rcv_established
  1424.    handle them correctly, but it is not case with
  1425.    tcp_v6_hnd_req and tcp_v6_send_reset().   --ANK
  1426.  */
  1428. if (skb->protocol == htons(ETH_P_IP))
  1429. return tcp_v4_do_rcv(sk, skb);
  1431. #ifdef CONFIG_FILTER
  1432. filter = sk->filter;
  1433. if (filter && sk_filter(skb, filter))
  1434. goto discard;
  1435. #endif /* CONFIG_FILTER */
  1437. /*
  1438.  * socket locking is here for SMP purposes as backlog rcv
  1439.  * is currently called with bh processing disabled.
  1440.  */
  1442.    IP6_INC_STATS_BH(Ip6InDelivers);
  1444. /* Do Stevens' IPV6_PKTOPTIONS.
  1446.    Yes, guys, it is the only place in our code, where we
  1447.    may make it not affecting IPv4.
  1448.    The rest of code is protocol independent,
  1449.    and I do not like idea to uglify IPv4.
  1451.    Actually, all the idea behind IPV6_PKTOPTIONS
  1452.    looks not very well thought. For now we latch
  1453.    options, received in the last packet, enqueued
  1454.    by tcp. Feel free to propose better solution.
  1455.                                        --ANK (980728)
  1456.  */
  1457. if (sk->net_pinfo.af_inet6.rxopt.all)
  1458. opt_skb = skb_clone(skb, GFP_ATOMIC);
  1460. if (sk->state == TCP_ESTABLISHED) { /* Fast path */
  1461. TCP_CHECK_TIMER(sk);
  1462. if (tcp_rcv_established(sk, skb, skb->h.th, skb->len))
  1463. goto reset;
  1464. TCP_CHECK_TIMER(sk);
  1465. if (opt_skb)
  1466. goto ipv6_pktoptions;
  1467. return 0;
  1468. }
  1470. if (skb->len < (skb->h.th->doff<<2) || tcp_checksum_complete(skb))
  1471. goto csum_err;
  1473. if (sk->state == TCP_LISTEN) { 
  1474. struct sock *nsk = tcp_v6_hnd_req(sk, skb);
  1475. if (!nsk)
  1476. goto discard;
  1478. /*
  1479.  * Queue it on the new socket if the new socket is active,
  1480.  * otherwise we just shortcircuit this and continue with
  1481.  * the new socket..
  1482.  */
  1483.   if(nsk != sk) {
  1484. if (tcp_child_process(sk, nsk, skb))
  1485. goto reset;
  1486. if (opt_skb)
  1487. __kfree_skb(opt_skb);
  1488. return 0;
  1489. }
  1490. }
  1492. TCP_CHECK_TIMER(sk);
  1493. if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len))
  1494. goto reset;
  1495. TCP_CHECK_TIMER(sk);
  1496. if (opt_skb)
  1497. goto ipv6_pktoptions;
  1498. return 0;
  1500. reset:
  1501. tcp_v6_send_reset(skb);
  1502. discard:
  1503. if (opt_skb)
  1504. __kfree_skb(opt_skb);
  1505. kfree_skb(skb);
  1506. return 0;
  1507. csum_err:
  1508. TCP_INC_STATS_BH(TcpInErrs);
  1509. goto discard;
  1512. ipv6_pktoptions:
  1513. /* Do you ask, what is it?
  1515.    1. skb was enqueued by tcp.
  1516.    2. skb is added to tail of read queue, rather than out of order.
  1517.    3. socket is not in passive state.
  1518.    4. Finally, it really contains options, which user wants to receive.
  1519.  */
  1520. if (TCP_SKB_CB(opt_skb)->end_seq == sk->tp_pinfo.af_tcp.rcv_nxt &&
  1521.     !((1<<sk->state)&(TCPF_CLOSE|TCPF_LISTEN))) {
  1522. if (sk->net_pinfo.af_inet6.rxopt.bits.rxinfo)
  1523. sk->net_pinfo.af_inet6.mcast_oif = tcp_v6_iif(opt_skb);
  1524. if (sk->net_pinfo.af_inet6.rxopt.bits.rxhlim)
  1525. sk->net_pinfo.af_inet6.mcast_hops = opt_skb->nh.ipv6h->hop_limit;
  1526. if (ipv6_opt_accepted(sk, opt_skb)) {
  1527. skb_set_owner_r(opt_skb, sk);
  1528. opt_skb = xchg(&sk->net_pinfo.af_inet6.pktoptions, opt_skb);
  1529. } else {
  1530. __kfree_skb(opt_skb);
  1531. opt_skb = xchg(&sk->net_pinfo.af_inet6.pktoptions, NULL);
  1532. }
  1533. }
  1535. if (opt_skb)
  1536. kfree_skb(opt_skb);
  1537. return 0;
  1538. }
  1540. int tcp_v6_rcv(struct sk_buff *skb)
  1541. {
  1542. struct tcphdr *th;
  1543. struct sock *sk;
  1544. int ret;
  1546. if (skb->pkt_type != PACKET_HOST)
  1547. goto discard_it;
  1549. /*
  1550.  * Count it even if it's bad.
  1551.  */
  1552. TCP_INC_STATS_BH(TcpInSegs);
  1554. if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
  1555. goto discard_it;
  1557. th = skb->h.th;
  1559. if (th->doff < sizeof(struct tcphdr)/4)
  1560. goto bad_packet;
  1561. if (!pskb_may_pull(skb, th->doff*4))
  1562. goto discard_it;
  1564. if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
  1565.      tcp_v6_checksum_init(skb) < 0))
  1566. goto bad_packet;
  1568. th = skb->h.th;
  1569. TCP_SKB_CB(skb)->seq = ntohl(th->seq);
  1570. TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
  1571.     skb->len - th->doff*4);
  1572. TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
  1573. TCP_SKB_CB(skb)->when = 0;
  1574. TCP_SKB_CB(skb)->flags = ip6_get_dsfield(skb->nh.ipv6h);
  1575. TCP_SKB_CB(skb)->sacked = 0;
  1577. sk = __tcp_v6_lookup(&skb->nh.ipv6h->saddr, th->source,
  1578.      &skb->nh.ipv6h->daddr, ntohs(th->dest), tcp_v6_iif(skb));
  1580. if (!sk)
  1581. goto no_tcp_socket;
  1583. process:
  1584. if(!ipsec_sk_policy(sk,skb))
  1585. goto discard_and_relse;
  1586. if(sk->state == TCP_TIME_WAIT)
  1587. goto do_time_wait;
  1589. skb->dev = NULL;
  1591. bh_lock_sock(sk);
  1592. ret = 0;
  1593. if (!sk->lock.users) {
  1594. if (!tcp_prequeue(sk, skb))
  1595. ret = tcp_v6_do_rcv(sk, skb);
  1596. } else
  1597. sk_add_backlog(sk, skb);
  1598. bh_unlock_sock(sk);
  1600. sock_put(sk);
  1601. return ret;
  1603. no_tcp_socket:
  1604. if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
  1605. bad_packet:
  1606. TCP_INC_STATS_BH(TcpInErrs);
  1607. } else {
  1608. tcp_v6_send_reset(skb);
  1609. }
  1611. discard_it:
  1613. /*
  1614.  * Discard frame
  1615.  */
  1617. kfree_skb(skb);
  1618. return 0;
  1620. discard_and_relse:
  1621. sock_put(sk);
  1622. goto discard_it;
  1624. do_time_wait:
  1625. if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
  1626. TCP_INC_STATS_BH(TcpInErrs);
  1627. sock_put(sk);
  1628. goto discard_it;
  1629. }
  1631. switch(tcp_timewait_state_process((struct tcp_tw_bucket *)sk,
  1632.   skb, th, skb->len)) {
  1633. case TCP_TW_SYN:
  1634. {
  1635. struct sock *sk2;
  1637. sk2 = tcp_v6_lookup_listener(&skb->nh.ipv6h->daddr, ntohs(th->dest), tcp_v6_iif(skb));
  1638. if (sk2 != NULL) {
  1639. tcp_tw_deschedule((struct tcp_tw_bucket *)sk);
  1640. tcp_timewait_kill((struct tcp_tw_bucket *)sk);
  1641. tcp_tw_put((struct tcp_tw_bucket *)sk);
  1642. sk = sk2;
  1643. goto process;
  1644. }
  1645. /* Fall through to ACK */
  1646. }
  1647. case TCP_TW_ACK:
  1648. tcp_v6_timewait_ack(sk, skb);
  1649. break;
  1650. case TCP_TW_RST:
  1651. goto no_tcp_socket;
  1652. case TCP_TW_SUCCESS:;
  1653. }
  1654. goto discard_it;
  1655. }
  1657. static int tcp_v6_rebuild_header(struct sock *sk)
  1658. {
  1659. int err;
  1660. struct dst_entry *dst;
  1661. struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;
  1663. dst = __sk_dst_check(sk, np->dst_cookie);
  1665. if (dst == NULL) {
  1666. struct flowi fl;
  1668. fl.proto = IPPROTO_TCP;
  1669. fl.nl_u.ip6_u.daddr = &np->daddr;
  1670. fl.nl_u.ip6_u.saddr = &np->saddr;
  1671. fl.fl6_flowlabel = np->flow_label;
  1672. fl.oif = sk->bound_dev_if;
  1673. fl.uli_u.ports.dport = sk->dport;
  1674. fl.uli_u.ports.sport = sk->sport;
  1676. if (np->opt && np->opt->srcrt) {
  1677. struct rt0_hdr *rt0 = (struct rt0_hdr *) np->opt->srcrt;
  1678. fl.nl_u.ip6_u.daddr = rt0->addr;
  1679. }
  1681. dst = ip6_route_output(sk, &fl);
  1683. if (dst->error) {
  1684. err = dst->error;
  1685. dst_release(dst);
  1686. sk->route_caps = 0;
  1687. return err;
  1688. }
  1690. ip6_dst_store(sk, dst, NULL);
  1691. sk->route_caps = dst->dev->features&~NETIF_F_IP_CSUM;
  1692. }
  1694. return 0;
  1695. }
  1697. static int tcp_v6_xmit(struct sk_buff *skb)
  1698. {
  1699. struct sock *sk = skb->sk;
  1700. struct ipv6_pinfo * np = &sk->net_pinfo.af_inet6;
  1701. struct flowi fl;
  1702. struct dst_entry *dst;
  1704. fl.proto = IPPROTO_TCP;
  1705. fl.fl6_dst = &np->daddr;
  1706. fl.fl6_src = &np->saddr;
  1707. fl.fl6_flowlabel = np->flow_label;
  1708. IP6_ECN_flow_xmit(sk, fl.fl6_flowlabel);
  1709. fl.oif = sk->bound_dev_if;
  1710. fl.uli_u.ports.sport = sk->sport;
  1711. fl.uli_u.ports.dport = sk->dport;
  1713. if (np->opt && np->opt->srcrt) {
  1714. struct rt0_hdr *rt0 = (struct rt0_hdr *) np->opt->srcrt;
  1715. fl.nl_u.ip6_u.daddr = rt0->addr;
  1716. }
  1718. dst = __sk_dst_check(sk, np->dst_cookie);
  1720. if (dst == NULL) {
  1721. dst = ip6_route_output(sk, &fl);
  1723. if (dst->error) {
  1724. sk->err_soft = -dst->error;
  1725. dst_release(dst);
  1726. return -sk->err_soft;
  1727. }
  1729. ip6_dst_store(sk, dst, NULL);
  1730. }
  1732. skb->dst = dst_clone(dst);
  1734. /* Restore final destination back after routing done */
  1735. fl.nl_u.ip6_u.daddr = &np->daddr;
  1737. return ip6_xmit(sk, skb, &fl, np->opt);
  1738. }
  1740. static void v6_addr2sockaddr(struct sock *sk, struct sockaddr * uaddr)
  1741. {
  1742. struct ipv6_pinfo * np = &sk->net_pinfo.af_inet6;
  1743. struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) uaddr;
  1745. sin6->sin6_family = AF_INET6;
  1746. memcpy(&sin6->sin6_addr, &np->daddr, sizeof(struct in6_addr));
  1747. sin6->sin6_port = sk->dport;
  1748. /* We do not store received flowlabel for TCP */
  1749. sin6->sin6_flowinfo = 0;
  1750. sin6->sin6_scope_id = 0;
  1751. if (sk->bound_dev_if && ipv6_addr_type(&sin6->sin6_addr)&IPV6_ADDR_LINKLOCAL)
  1752. sin6->sin6_scope_id = sk->bound_dev_if;
  1753. }
  1755. static int tcp_v6_remember_stamp(struct sock *sk)
  1756. {
  1757. /* Alas, not yet... */
  1758. return 0;
  1759. }
  1761. static struct tcp_func ipv6_specific = {
  1762. tcp_v6_xmit,
  1763. tcp_v6_send_check,
  1764. tcp_v6_rebuild_header,
  1765. tcp_v6_conn_request,
  1766. tcp_v6_syn_recv_sock,
  1767. tcp_v6_remember_stamp,
  1768. sizeof(struct ipv6hdr),
  1770. ipv6_setsockopt,
  1771. ipv6_getsockopt,
  1772. v6_addr2sockaddr,
  1773. sizeof(struct sockaddr_in6)
  1774. };
  1776. /*
  1777.  * TCP over IPv4 via INET6 API
  1778.  */
  1780. static struct tcp_func ipv6_mapped = {
  1781. ip_queue_xmit,
  1782. tcp_v4_send_check,
  1783. tcp_v4_rebuild_header,
  1784. tcp_v6_conn_request,
  1785. tcp_v6_syn_recv_sock,
  1786. tcp_v4_remember_stamp,
  1787. sizeof(struct iphdr),
  1789. ipv6_setsockopt,
  1790. ipv6_getsockopt,
  1791. v6_addr2sockaddr,
  1792. sizeof(struct sockaddr_in6)
  1793. };
  1797. /* NOTE: A lot of things set to zero explicitly by call to
  1798.  *       sk_alloc() so need not be done here.
  1799.  */
  1800. static int tcp_v6_init_sock(struct sock *sk)
  1801. {
  1802. struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
  1804. skb_queue_head_init(&tp->out_of_order_queue);
  1805. tcp_init_xmit_timers(sk);
  1806. tcp_prequeue_init(tp);
  1808. tp->rto  = TCP_TIMEOUT_INIT;
  1809. tp->mdev = TCP_TIMEOUT_INIT;
  1811. /* So many TCP implementations out there (incorrectly) count the
  1812.  * initial SYN frame in their delayed-ACK and congestion control
  1813.  * algorithms that we must have the following bandaid to talk
  1814.  * efficiently to them.  -DaveM
  1815.  */
  1816. tp->snd_cwnd = 2;
  1818. /* See draft-stevens-tcpca-spec-01 for discussion of the
  1819.  * initialization of these values.
  1820.  */
  1821. tp->snd_ssthresh = 0x7fffffff;
  1822. tp->snd_cwnd_clamp = ~0;
  1823. tp->mss_cache = 536;
  1825. tp->reordering = sysctl_tcp_reordering;
  1827. sk->state = TCP_CLOSE;
  1829. sk->tp_pinfo.af_tcp.af_specific = &ipv6_specific;
  1831. sk->write_space = tcp_write_space;
  1832. sk->use_write_queue = 1;
  1834. sk->sndbuf = sysctl_tcp_wmem[1];
  1835. sk->rcvbuf = sysctl_tcp_rmem[1];
  1837. atomic_inc(&tcp_sockets_allocated);
  1839. return 0;
  1840. }
  1842. static int tcp_v6_destroy_sock(struct sock *sk)
  1843. {
  1844. struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
  1846. tcp_clear_xmit_timers(sk);
  1848. /* Cleanup up the write buffer. */
  1849.    tcp_writequeue_purge(sk);
  1851. /* Cleans up our, hopefully empty, out_of_order_queue. */
  1852.    __skb_queue_purge(&tp->out_of_order_queue);
  1854. /* Clean prequeue, it must be empty really */
  1855. __skb_queue_purge(&tp->ucopy.prequeue);
  1857. /* Clean up a referenced TCP bind bucket. */
  1858. if(sk->prev != NULL)
  1859. tcp_put_port(sk);
  1861. /* If sendmsg cached page exists, toss it. */
  1862. if (tp->sndmsg_page != NULL)
  1863. __free_page(tp->sndmsg_page);
  1865. atomic_dec(&tcp_sockets_allocated);
  1867. return inet6_destroy_sock(sk);
  1868. }
  1870. /* Proc filesystem TCPv6 sock list dumping. */
  1871. static void get_openreq6(struct sock *sk, struct open_request *req, char *tmpbuf, int i, int uid)
  1872. {
  1873. struct in6_addr *dest, *src;
  1874. int ttd = req->expires - jiffies;
  1876. if (ttd < 0)
  1877. ttd = 0;
  1879. src = &req->af.v6_req.loc_addr;
  1880. dest = &req->af.v6_req.rmt_addr;
  1881. sprintf(tmpbuf,
  1882. "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
  1883. "%02X %08X:%08X %02X:%08X %08X %5d %8d %d %d %p",
  1884. i,
  1885. src->s6_addr32[0], src->s6_addr32[1],
  1886. src->s6_addr32[2], src->s6_addr32[3],
  1887. ntohs(sk->sport),
  1888. dest->s6_addr32[0], dest->s6_addr32[1],
  1889. dest->s6_addr32[2], dest->s6_addr32[3],
  1890. ntohs(req->rmt_port),
  1891. TCP_SYN_RECV,
  1892. 0,0, /* could print option size, but that is af dependent. */
  1893. 1,   /* timers active (only the expire timer) */  
  1894. ttd, 
  1895. req->retrans,
  1896. uid,
  1897. 0,  /* non standard timer */  
  1898. 0, /* open_requests have no inode */
  1899. 0, req);
  1900. }
  1902. static void get_tcp6_sock(struct sock *sp, char *tmpbuf, int i)
  1903. {
  1904. struct in6_addr *dest, *src;
  1905. __u16 destp, srcp;
  1906. int timer_active;
  1907. unsigned long timer_expires;
  1908. struct tcp_opt *tp = &sp->tp_pinfo.af_tcp;
  1910. dest  = &sp->net_pinfo.af_inet6.daddr;
  1911. src   = &sp->net_pinfo.af_inet6.rcv_saddr;
  1912. destp = ntohs(sp->dport);
  1913. srcp  = ntohs(sp->sport);
  1914. if (tp->pending == TCP_TIME_RETRANS) {
  1915. timer_active = 1;
  1916. timer_expires = tp->timeout;
  1917. } else if (tp->pending == TCP_TIME_PROBE0) {
  1918. timer_active = 4;
  1919. timer_expires = tp->timeout;
  1920. } else if (timer_pending(&sp->timer)) {
  1921. timer_active = 2;
  1922. timer_expires = sp->timer.expires;
  1923. } else {
  1924. timer_active = 0;
  1925. timer_expires = jiffies;
  1926. }
  1928. sprintf(tmpbuf,
  1929. "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
  1930. "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %u %u %u %u %d",
  1931. i,
  1932. src->s6_addr32[0], src->s6_addr32[1],
  1933. src->s6_addr32[2], src->s6_addr32[3], srcp,
  1934. dest->s6_addr32[0], dest->s6_addr32[1],
  1935. dest->s6_addr32[2], dest->s6_addr32[3], destp,
  1936. sp->state, 
  1937. tp->write_seq-tp->snd_una, tp->rcv_nxt-tp->copied_seq,
  1938. timer_active, timer_expires-jiffies,
  1939. tp->retransmits,
  1940. sock_i_uid(sp),
  1941. tp->probes_out,
  1942. sock_i_ino(sp),
  1943. atomic_read(&sp->refcnt), sp,
  1944. tp->rto, tp->ack.ato, (tp->ack.quick<<1)|tp->ack.pingpong,
  1945. tp->snd_cwnd, tp->snd_ssthresh>=0xFFFF?-1:tp->snd_ssthresh
  1946. );
  1947. }
  1949. static void get_timewait6_sock(struct tcp_tw_bucket *tw, char *tmpbuf, int i)
  1950. {
  1951. struct in6_addr *dest, *src;
  1952. __u16 destp, srcp;
  1953. int ttd = tw->ttd - jiffies;
  1955. if (ttd < 0)
  1956. ttd = 0;
  1958. dest  = &tw->v6_daddr;
  1959. src   = &tw->v6_rcv_saddr;
  1960. destp = ntohs(tw->dport);
  1961. srcp  = ntohs(tw->sport);
  1963. sprintf(tmpbuf,
  1964. "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
  1965. "%02X %08X:%08X %02X:%08X %08X %5d %8d %d %d %p",
  1966. i,
  1967. src->s6_addr32[0], src->s6_addr32[1],
  1968. src->s6_addr32[2], src->s6_addr32[3], srcp,
  1969. dest->s6_addr32[0], dest->s6_addr32[1],
  1970. dest->s6_addr32[2], dest->s6_addr32[3], destp,
  1971. tw->substate, 0, 0,
  1972. 3, ttd, 0, 0, 0, 0,
  1973. atomic_read(&tw->refcnt), tw);
  1974. }
  1976. #define LINE_LEN 190
  1977. #define LINE_FMT "%-190sn"
  1979. int tcp6_get_info(char *buffer, char **start, off_t offset, int length)
  1980. {
  1981. int len = 0, num = 0, i;
  1982. off_t begin, pos = 0;
  1983. char tmpbuf[LINE_LEN+2];
  1985. if (offset < LINE_LEN+1)
  1986. len += sprintf(buffer, LINE_FMT,
  1987.        "  sl  " /* 6 */
  1988.        "local_address                         " /* 38 */
  1989.        "remote_address                        " /* 38 */
  1990.        "st tx_queue rx_queue tr tm->when retrnsmt" /* 41 */
  1991.        "   uid  timeout inode"); /* 21 */
  1992. /*----*/
  1993. /*144 */
  1995. pos = LINE_LEN+1;
  1997. /* First, walk listening socket table. */
  1998. tcp_listen_lock();
  1999. for(i = 0; i < TCP_LHTABLE_SIZE; i++) {
  2000. struct sock *sk = tcp_listening_hash[i];
  2001. struct tcp_listen_opt *lopt;
  2002. int k;
  2004. for (sk = tcp_listening_hash[i]; sk; sk = sk->next, num++) {
  2005. struct open_request *req;
  2006. int uid;
  2007. struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
  2009. if (sk->family != PF_INET6)
  2010. continue;
  2011. pos += LINE_LEN+1;
  2012. if (pos >= offset) {
  2013. get_tcp6_sock(sk, tmpbuf, num);
  2014. len += sprintf(buffer+len, LINE_FMT, tmpbuf);
  2015. if (pos >= offset + length) {
  2016. tcp_listen_unlock();
  2017. goto out_no_bh;
  2018. }
  2019. }
  2021. uid = sock_i_uid(sk);
  2022. read_lock_bh(&tp->syn_wait_lock);
  2023. lopt = tp->listen_opt;
  2024. if (lopt && lopt->qlen != 0) {
  2025. for (k=0; k<TCP_SYNQ_HSIZE; k++) {
  2026. for (req = lopt->syn_table[k]; req; req = req->dl_next, num++) {
  2027. if (req->class->family != PF_INET6)
  2028. continue;
  2029. pos += LINE_LEN+1;
  2030. if (pos <= offset)
  2031. continue;
  2032. get_openreq6(sk, req, tmpbuf, num, uid);
  2033. len += sprintf(buffer+len, LINE_FMT, tmpbuf);
  2034. if (pos >= offset + length) { 
  2035. read_unlock_bh(&tp->syn_wait_lock);
  2036. tcp_listen_unlock();
  2037. goto out_no_bh;
  2038. }
  2039. }
  2040. }
  2041. }
  2042. read_unlock_bh(&tp->syn_wait_lock);
  2044. /* Completed requests are in normal socket hash table */
  2045. }
  2046. }
  2047. tcp_listen_unlock();
  2049. local_bh_disable();
  2051. /* Next, walk established hash chain. */
  2052. for (i = 0; i < tcp_ehash_size; i++) {
  2053. struct tcp_ehash_bucket *head = &tcp_ehash[i];
  2054. struct sock *sk;
  2055. struct tcp_tw_bucket *tw;
  2057. read_lock(&head->lock);
  2058. for(sk = head->chain; sk; sk = sk->next, num++) {
  2059. if (sk->family != PF_INET6)
  2060. continue;
  2061. pos += LINE_LEN+1;
  2062. if (pos <= offset)
  2063. continue;
  2064. get_tcp6_sock(sk, tmpbuf, num);
  2065. len += sprintf(buffer+len, LINE_FMT, tmpbuf);
  2066. if (pos >= offset + length) {
  2067. read_unlock(&head->lock);
  2068. goto out;
  2069. }
  2070. }
  2071. for (tw = (struct tcp_tw_bucket *)tcp_ehash[i+tcp_ehash_size].chain;
  2072.      tw != NULL;
  2073.      tw = (struct tcp_tw_bucket *)tw->next, num++) {
  2074. if (tw->family != PF_INET6)
  2075. continue;
  2076. pos += LINE_LEN+1;
  2077. if (pos <= offset)
  2078. continue;
  2079. get_timewait6_sock(tw, tmpbuf, num);
  2080. len += sprintf(buffer+len, LINE_FMT, tmpbuf);
  2081. if (pos >= offset + length) {
  2082. read_unlock(&head->lock);
  2083. goto out;
  2084. }
  2085. }
  2086. read_unlock(&head->lock);
  2087. }
  2089. out:
  2090. local_bh_enable();
  2091. out_no_bh:
  2093. begin = len - (pos - offset);
  2094. *start = buffer + begin;
  2095. len -= begin;
  2096. if (len > length)
  2097. len = length;
  2098. if (len < 0)
  2099. len = 0; 
  2100. return len;
  2101. }
  2103. struct proto tcpv6_prot = {
  2104. name: "TCPv6",
  2105. close: tcp_close,
  2106. connect: tcp_v6_connect,
  2107. disconnect: tcp_disconnect,
  2108. accept: tcp_accept,
  2109. ioctl: tcp_ioctl,
  2110. init: tcp_v6_init_sock,
  2111. destroy: tcp_v6_destroy_sock,
  2112. shutdown: tcp_shutdown,
  2113. setsockopt: tcp_setsockopt,
  2114. getsockopt: tcp_getsockopt,
  2115. sendmsg: tcp_sendmsg,
  2116. recvmsg: tcp_recvmsg,
  2117. backlog_rcv: tcp_v6_do_rcv,
  2118. hash: tcp_v6_hash,
  2119. unhash: tcp_unhash,
  2120. get_port: tcp_v6_get_port,
  2121. };
  2123. static struct inet6_protocol tcpv6_protocol =
  2124. {
  2125. tcp_v6_rcv, /* TCP handler */
  2126. tcp_v6_err, /* TCP error control */
  2127. NULL, /* next */
  2128. IPPROTO_TCP, /* protocol ID */
  2129. 0, /* copy */
  2130. NULL, /* data */
  2131. "TCPv6" /* name */
  2132. };
  2134. extern struct proto_ops inet6_stream_ops;
  2136. static struct inet_protosw tcpv6_protosw = {
  2137. type:        SOCK_STREAM,
  2138. protocol:    IPPROTO_TCP,
  2139. prot:        &tcpv6_prot,
  2140. ops:         &inet6_stream_ops,
  2141. capability:  -1,
  2142. no_check:    0,
  2143. flags:       INET_PROTOSW_PERMANENT,
  2144. };
  2146. void __init tcpv6_init(void)
  2147. {
  2148. /* register inet6 protocol */
  2149. inet6_add_protocol(&tcpv6_protocol);
  2150. inet6_register_protosw(&tcpv6_protosw);
  2151. }