| Linux kernel & device driver programming |
| [ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] |
1 /* 1 /*
2 * TCP over IPv6 2 * TCP over IPv6
3 * Linux INET6 implementation !! 3 * Linux INET6 implementation
4 * 4 *
5 * Authors: 5 * Authors:
6 * Pedro Roque <roque@di.fc.u !! 6 * Pedro Roque <roque@di.fc.ul.pt>
7 * 7 *
8 * $Id: tcp_ipv6.c,v 1.144 2002/02/01 22: 8 * $Id: tcp_ipv6.c,v 1.144 2002/02/01 22:01:04 davem Exp $
9 * 9 *
10 * Based on: !! 10 * Based on:
11 * linux/net/ipv4/tcp.c 11 * linux/net/ipv4/tcp.c
12 * linux/net/ipv4/tcp_input.c 12 * linux/net/ipv4/tcp_input.c
13 * linux/net/ipv4/tcp_output.c 13 * linux/net/ipv4/tcp_output.c
14 * 14 *
15 * Fixes: 15 * Fixes:
16 * Hideaki YOSHIFUJI : sin6_s 16 * Hideaki YOSHIFUJI : sin6_scope_id support
17 * YOSHIFUJI Hideaki @USAGI and: Suppor 17 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
18 * Alexey Kuznetsov allow 18 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
19 * a sing 19 * a single port at the same time.
20 * YOSHIFUJI Hideaki @USAGI: conver 20 * YOSHIFUJI Hideaki @USAGI: convert /proc/net/tcp6 to seq_file.
21 * 21 *
22 * This program is free software; you can 22 * This program is free software; you can redistribute it and/or
23 * modify it under the terms of the GNU G 23 * modify it under the terms of the GNU General Public License
24 * as published by the Free Software Foun 24 * as published by the Free Software Foundation; either version
25 * 2 of the License, or (at your option) 25 * 2 of the License, or (at your option) any later version.
26 */ 26 */
27 27
28 #include <linux/module.h> 28 #include <linux/module.h>
>> 29 #include <linux/config.h>
29 #include <linux/errno.h> 30 #include <linux/errno.h>
30 #include <linux/types.h> 31 #include <linux/types.h>
31 #include <linux/socket.h> 32 #include <linux/socket.h>
32 #include <linux/sockios.h> 33 #include <linux/sockios.h>
33 #include <linux/net.h> 34 #include <linux/net.h>
34 #include <linux/jiffies.h> 35 #include <linux/jiffies.h>
35 #include <linux/in.h> 36 #include <linux/in.h>
36 #include <linux/in6.h> 37 #include <linux/in6.h>
37 #include <linux/netdevice.h> 38 #include <linux/netdevice.h>
38 #include <linux/init.h> 39 #include <linux/init.h>
39 #include <linux/jhash.h> 40 #include <linux/jhash.h>
40 #include <linux/ipsec.h> 41 #include <linux/ipsec.h>
41 #include <linux/times.h> 42 #include <linux/times.h>
42 43
43 #include <linux/ipv6.h> 44 #include <linux/ipv6.h>
44 #include <linux/icmpv6.h> 45 #include <linux/icmpv6.h>
45 #include <linux/random.h> 46 #include <linux/random.h>
46 47
47 #include <net/tcp.h> 48 #include <net/tcp.h>
48 #include <net/ndisc.h> 49 #include <net/ndisc.h>
49 #include <net/inet6_hashtables.h> <<
50 #include <net/inet6_connection_sock.h> <<
51 #include <net/ipv6.h> 50 #include <net/ipv6.h>
52 #include <net/transp_v6.h> 51 #include <net/transp_v6.h>
53 #include <net/addrconf.h> 52 #include <net/addrconf.h>
54 #include <net/ip6_route.h> 53 #include <net/ip6_route.h>
55 #include <net/ip6_checksum.h> 54 #include <net/ip6_checksum.h>
56 #include <net/inet_ecn.h> 55 #include <net/inet_ecn.h>
57 #include <net/protocol.h> 56 #include <net/protocol.h>
58 #include <net/xfrm.h> 57 #include <net/xfrm.h>
>> 58 #include <net/addrconf.h>
59 #include <net/snmp.h> 59 #include <net/snmp.h>
60 #include <net/dsfield.h> 60 #include <net/dsfield.h>
61 #include <net/timewait_sock.h> <<
62 #include <net/netdma.h> <<
63 61
64 #include <asm/uaccess.h> 62 #include <asm/uaccess.h>
65 63
66 #include <linux/proc_fs.h> 64 #include <linux/proc_fs.h>
67 #include <linux/seq_file.h> 65 #include <linux/seq_file.h>
68 66
69 #include <linux/crypto.h> !! 67 static void tcp_v6_send_reset(struct sk_buff *skb);
70 #include <linux/scatterlist.h> !! 68 static void tcp_v6_or_send_ack(struct sk_buff *skb, struct open_request *req);
71 !! 69 static void tcp_v6_send_check(struct sock *sk, struct tcphdr *th, int len,
72 /* Socket used for sending RSTs and ACKs */ <<
73 static struct socket *tcp6_socket; <<
74 <<
75 static void tcp_v6_send_reset(struct sock <<
76 static void tcp_v6_reqsk_send_ack(struct s <<
77 static void tcp_v6_send_check(struct sock <<
78 struct sk_bu 70 struct sk_buff *skb);
79 71
80 static int tcp_v6_do_rcv(struct sock *sk, 72 static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
>> 73 static int tcp_v6_xmit(struct sk_buff *skb, int ipfragok);
>> 74
>> 75 static struct tcp_func ipv6_mapped;
>> 76 static struct tcp_func ipv6_specific;
>> 77
>> 78 /* I have no idea if this is a good hash for v6 or not. -DaveM */
>> 79 static __inline__ int tcp_v6_hashfn(struct in6_addr *laddr, u16 lport,
>> 80 struct in6_addr *faddr, u16 fport)
>> 81 {
>> 82 int hashent = (lport ^ fport);
>> 83
>> 84 hashent ^= (laddr->s6_addr32[3] ^ faddr->s6_addr32[3]);
>> 85 hashent ^= hashent>>16;
>> 86 hashent ^= hashent>>8;
>> 87 return (hashent & (tcp_ehash_size - 1));
>> 88 }
>> 89
>> 90 static __inline__ int tcp_v6_sk_hashfn(struct sock *sk)
>> 91 {
>> 92 struct inet_sock *inet = inet_sk(sk);
>> 93 struct ipv6_pinfo *np = inet6_sk(sk);
>> 94 struct in6_addr *laddr = &np->rcv_saddr;
>> 95 struct in6_addr *faddr = &np->daddr;
>> 96 __u16 lport = inet->num;
>> 97 __u16 fport = inet->dport;
>> 98 return tcp_v6_hashfn(laddr, lport, faddr, fport);
>> 99 }
>> 100
>> 101 static inline int tcp_v6_bind_conflict(struct sock *sk,
>> 102 struct tcp_bind_bucket *tb)
>> 103 {
>> 104 struct sock *sk2;
>> 105 struct hlist_node *node;
>> 106
>> 107 /* We must walk the whole port owner list in this case. -DaveM */
>> 108 sk_for_each_bound(sk2, node, &tb->owners) {
>> 109 if (sk != sk2 &&
>> 110 (!sk->sk_bound_dev_if ||
>> 111 !sk2->sk_bound_dev_if ||
>> 112 sk->sk_bound_dev_if == sk2->sk_bound_dev_if) &&
>> 113 (!sk->sk_reuse || !sk2->sk_reuse ||
>> 114 sk2->sk_state == TCP_LISTEN) &&
>> 115 ipv6_rcv_saddr_equal(sk, sk2))
>> 116 break;
>> 117 }
>> 118
>> 119 return node != NULL;
>> 120 }
>> 121
>> 122 /* Grrr, addr_type already calculated by caller, but I don't want
>> 123 * to add some silly "cookie" argument to this method just for that.
>> 124 * But it doesn't matter, the recalculation is in the rarest path
>> 125 * this function ever takes.
>> 126 */
>> 127 static int tcp_v6_get_port(struct sock *sk, unsigned short snum)
>> 128 {
>> 129 struct tcp_bind_hashbucket *head;
>> 130 struct tcp_bind_bucket *tb;
>> 131 struct hlist_node *node;
>> 132 int ret;
>> 133
>> 134 local_bh_disable();
>> 135 if (snum == 0) {
>> 136 int low = sysctl_local_port_range[0];
>> 137 int high = sysctl_local_port_range[1];
>> 138 int remaining = (high - low) + 1;
>> 139 int rover;
>> 140
>> 141 spin_lock(&tcp_portalloc_lock);
>> 142 rover = tcp_port_rover;
>> 143 do { rover++;
>> 144 if ((rover < low) || (rover > high))
>> 145 rover = low;
>> 146 head = &tcp_bhash[tcp_bhashfn(rover)];
>> 147 spin_lock(&head->lock);
>> 148 tb_for_each(tb, node, &head->chain)
>> 149 if (tb->port == rover)
>> 150 goto next;
>> 151 break;
>> 152 next:
>> 153 spin_unlock(&head->lock);
>> 154 } while (--remaining > 0);
>> 155 tcp_port_rover = rover;
>> 156 spin_unlock(&tcp_portalloc_lock);
>> 157
>> 158 /* Exhausted local port range during search? */
>> 159 ret = 1;
>> 160 if (remaining <= 0)
>> 161 goto fail;
>> 162
>> 163 /* OK, here is the one we will use. */
>> 164 snum = rover;
>> 165 } else {
>> 166 head = &tcp_bhash[tcp_bhashfn(snum)];
>> 167 spin_lock(&head->lock);
>> 168 tb_for_each(tb, node, &head->chain)
>> 169 if (tb->port == snum)
>> 170 goto tb_found;
>> 171 }
>> 172 tb = NULL;
>> 173 goto tb_not_found;
>> 174 tb_found:
>> 175 if (tb && !hlist_empty(&tb->owners)) {
>> 176 if (tb->fastreuse > 0 && sk->sk_reuse &&
>> 177 sk->sk_state != TCP_LISTEN) {
>> 178 goto success;
>> 179 } else {
>> 180 ret = 1;
>> 181 if (tcp_v6_bind_conflict(sk, tb))
>> 182 goto fail_unlock;
>> 183 }
>> 184 }
>> 185 tb_not_found:
>> 186 ret = 1;
>> 187 if (!tb && (tb = tcp_bucket_create(head, snum)) == NULL)
>> 188 goto fail_unlock;
>> 189 if (hlist_empty(&tb->owners)) {
>> 190 if (sk->sk_reuse && sk->sk_state != TCP_LISTEN)
>> 191 tb->fastreuse = 1;
>> 192 else
>> 193 tb->fastreuse = 0;
>> 194 } else if (tb->fastreuse &&
>> 195 (!sk->sk_reuse || sk->sk_state == TCP_LISTEN))
>> 196 tb->fastreuse = 0;
>> 197
>> 198 success:
>> 199 if (!tcp_sk(sk)->bind_hash)
>> 200 tcp_bind_hash(sk, tb, snum);
>> 201 BUG_TRAP(tcp_sk(sk)->bind_hash == tb);
>> 202 ret = 0;
>> 203
>> 204 fail_unlock:
>> 205 spin_unlock(&head->lock);
>> 206 fail:
>> 207 local_bh_enable();
>> 208 return ret;
>> 209 }
>> 210
>> 211 static __inline__ void __tcp_v6_hash(struct sock *sk)
>> 212 {
>> 213 struct hlist_head *list;
>> 214 rwlock_t *lock;
>> 215
>> 216 BUG_TRAP(sk_unhashed(sk));
>> 217
>> 218 if (sk->sk_state == TCP_LISTEN) {
>> 219 list = &tcp_listening_hash[tcp_sk_listen_hashfn(sk)];
>> 220 lock = &tcp_lhash_lock;
>> 221 tcp_listen_wlock();
>> 222 } else {
>> 223 sk->sk_hashent = tcp_v6_sk_hashfn(sk);
>> 224 list = &tcp_ehash[sk->sk_hashent].chain;
>> 225 lock = &tcp_ehash[sk->sk_hashent].lock;
>> 226 write_lock(lock);
>> 227 }
>> 228
>> 229 __sk_add_node(sk, list);
>> 230 sock_prot_inc_use(sk->sk_prot);
>> 231 write_unlock(lock);
>> 232 }
81 233
82 static struct inet_connection_sock_af_ops ipv6 <<
83 static struct inet_connection_sock_af_ops ipv6 <<
84 #ifdef CONFIG_TCP_MD5SIG <<
85 static struct tcp_sock_af_ops tcp_sock_ipv6_sp <<
86 static struct tcp_sock_af_ops tcp_sock_ipv6_ma <<
87 #endif <<
88 234
89 static void tcp_v6_hash(struct sock *sk) 235 static void tcp_v6_hash(struct sock *sk)
90 { 236 {
91 if (sk->sk_state != TCP_CLOSE) { 237 if (sk->sk_state != TCP_CLOSE) {
92 if (inet_csk(sk)->icsk_af_ops !! 238 struct tcp_sock *tp = tcp_sk(sk);
>> 239
>> 240 if (tp->af_specific == &ipv6_mapped) {
93 tcp_prot.hash(sk); 241 tcp_prot.hash(sk);
94 return; 242 return;
95 } 243 }
96 local_bh_disable(); 244 local_bh_disable();
97 __inet6_hash(sk); !! 245 __tcp_v6_hash(sk);
98 local_bh_enable(); 246 local_bh_enable();
99 } 247 }
100 } 248 }
101 249
102 static __inline__ __sum16 tcp_v6_check(struct !! 250 static struct sock *tcp_v6_lookup_listener(struct in6_addr *daddr, unsigned short hnum, int dif)
103 struct in6_ !! 251 {
104 struct in6_ !! 252 struct sock *sk;
105 __wsum base !! 253 struct hlist_node *node;
>> 254 struct sock *result = NULL;
>> 255 int score, hiscore;
>> 256
>> 257 hiscore=0;
>> 258 read_lock(&tcp_lhash_lock);
>> 259 sk_for_each(sk, node, &tcp_listening_hash[tcp_lhashfn(hnum)]) {
>> 260 if (inet_sk(sk)->num == hnum && sk->sk_family == PF_INET6) {
>> 261 struct ipv6_pinfo *np = inet6_sk(sk);
>> 262
>> 263 score = 1;
>> 264 if (!ipv6_addr_any(&np->rcv_saddr)) {
>> 265 if (!ipv6_addr_equal(&np->rcv_saddr, daddr))
>> 266 continue;
>> 267 score++;
>> 268 }
>> 269 if (sk->sk_bound_dev_if) {
>> 270 if (sk->sk_bound_dev_if != dif)
>> 271 continue;
>> 272 score++;
>> 273 }
>> 274 if (score == 3) {
>> 275 result = sk;
>> 276 break;
>> 277 }
>> 278 if (score > hiscore) {
>> 279 hiscore = score;
>> 280 result = sk;
>> 281 }
>> 282 }
>> 283 }
>> 284 if (result)
>> 285 sock_hold(result);
>> 286 read_unlock(&tcp_lhash_lock);
>> 287 return result;
>> 288 }
>> 289
>> 290 /* Sockets in TCP_CLOSE state are _always_ taken out of the hash, so
>> 291 * we need not check it for TCP lookups anymore, thanks Alexey. -DaveM
>> 292 *
>> 293 * The sockhash lock must be held as a reader here.
>> 294 */
>> 295
>> 296 static inline struct sock *__tcp_v6_lookup_established(struct in6_addr *saddr, u16 sport,
>> 297 struct in6_addr *daddr, u16 hnum,
>> 298 int dif)
>> 299 {
>> 300 struct tcp_ehash_bucket *head;
>> 301 struct sock *sk;
>> 302 struct hlist_node *node;
>> 303 __u32 ports = TCP_COMBINED_PORTS(sport, hnum);
>> 304 int hash;
>> 305
>> 306 /* Optimize here for direct hit, only listening connections can
>> 307 * have wildcards anyways.
>> 308 */
>> 309 hash = tcp_v6_hashfn(daddr, hnum, saddr, sport);
>> 310 head = &tcp_ehash[hash];
>> 311 read_lock(&head->lock);
>> 312 sk_for_each(sk, node, &head->chain) {
>> 313 /* For IPV6 do the cheaper port and family tests first. */
>> 314 if(TCP_IPV6_MATCH(sk, saddr, daddr, ports, dif))
>> 315 goto hit; /* You sunk my battleship! */
>> 316 }
>> 317 /* Must check for a TIME_WAIT'er before going to listener hash. */
>> 318 sk_for_each(sk, node, &(head + tcp_ehash_size)->chain) {
>> 319 /* FIXME: acme: check this... */
>> 320 struct tcp_tw_bucket *tw = (struct tcp_tw_bucket *)sk;
>> 321
>> 322 if(*((__u32 *)&(tw->tw_dport)) == ports &&
>> 323 sk->sk_family == PF_INET6) {
>> 324 if(ipv6_addr_equal(&tw->tw_v6_daddr, saddr) &&
>> 325 ipv6_addr_equal(&tw->tw_v6_rcv_saddr, daddr) &&
>> 326 (!sk->sk_bound_dev_if || sk->sk_bound_dev_if == dif))
>> 327 goto hit;
>> 328 }
>> 329 }
>> 330 read_unlock(&head->lock);
>> 331 return NULL;
>> 332
>> 333 hit:
>> 334 sock_hold(sk);
>> 335 read_unlock(&head->lock);
>> 336 return sk;
>> 337 }
>> 338
>> 339
>> 340 static inline struct sock *__tcp_v6_lookup(struct in6_addr *saddr, u16 sport,
>> 341 struct in6_addr *daddr, u16 hnum,
>> 342 int dif)
>> 343 {
>> 344 struct sock *sk;
>> 345
>> 346 sk = __tcp_v6_lookup_established(saddr, sport, daddr, hnum, dif);
>> 347
>> 348 if (sk)
>> 349 return sk;
>> 350
>> 351 return tcp_v6_lookup_listener(daddr, hnum, dif);
>> 352 }
>> 353
>> 354 inline struct sock *tcp_v6_lookup(struct in6_addr *saddr, u16 sport,
>> 355 struct in6_addr *daddr, u16 dport,
>> 356 int dif)
>> 357 {
>> 358 struct sock *sk;
>> 359
>> 360 local_bh_disable();
>> 361 sk = __tcp_v6_lookup(saddr, sport, daddr, ntohs(dport), dif);
>> 362 local_bh_enable();
>> 363
>> 364 return sk;
>> 365 }
>> 366
>> 367 EXPORT_SYMBOL_GPL(tcp_v6_lookup);
>> 368
>> 369
>> 370 /*
>> 371 * Open request hash tables.
>> 372 */
>> 373
>> 374 static u32 tcp_v6_synq_hash(struct in6_addr *raddr, u16 rport, u32 rnd)
>> 375 {
>> 376 u32 a, b, c;
>> 377
>> 378 a = raddr->s6_addr32[0];
>> 379 b = raddr->s6_addr32[1];
>> 380 c = raddr->s6_addr32[2];
>> 381
>> 382 a += JHASH_GOLDEN_RATIO;
>> 383 b += JHASH_GOLDEN_RATIO;
>> 384 c += rnd;
>> 385 __jhash_mix(a, b, c);
>> 386
>> 387 a += raddr->s6_addr32[3];
>> 388 b += (u32) rport;
>> 389 __jhash_mix(a, b, c);
>> 390
>> 391 return c & (TCP_SYNQ_HSIZE - 1);
>> 392 }
>> 393
>> 394 static struct open_request *tcp_v6_search_req(struct tcp_sock *tp,
>> 395 struct open_request ***prevp,
>> 396 __u16 rport,
>> 397 struct in6_addr *raddr,
>> 398 struct in6_addr *laddr,
>> 399 int iif)
>> 400 {
>> 401 struct tcp_listen_opt *lopt = tp->listen_opt;
>> 402 struct open_request *req, **prev;
>> 403
>> 404 for (prev = &lopt->syn_table[tcp_v6_synq_hash(raddr, rport, lopt->hash_rnd)];
>> 405 (req = *prev) != NULL;
>> 406 prev = &req->dl_next) {
>> 407 if (req->rmt_port == rport &&
>> 408 req->class->family == AF_INET6 &&
>> 409 ipv6_addr_equal(&req->af.v6_req.rmt_addr, raddr) &&
>> 410 ipv6_addr_equal(&req->af.v6_req.loc_addr, laddr) &&
>> 411 (!req->af.v6_req.iif || req->af.v6_req.iif == iif)) {
>> 412 BUG_TRAP(req->sk == NULL);
>> 413 *prevp = prev;
>> 414 return req;
>> 415 }
>> 416 }
>> 417
>> 418 return NULL;
>> 419 }
>> 420
>> 421 static __inline__ u16 tcp_v6_check(struct tcphdr *th, int len,
>> 422 struct in6_addr *saddr,
>> 423 struct in6_addr *daddr,
>> 424 unsigned long base)
106 { 425 {
107 return csum_ipv6_magic(saddr, daddr, l 426 return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, base);
108 } 427 }
109 428
110 static __u32 tcp_v6_init_sequence(struct sk_bu !! 429 static __u32 tcp_v6_init_sequence(struct sock *sk, struct sk_buff *skb)
111 { 430 {
112 return secure_tcpv6_sequence_number(ip !! 431 if (skb->protocol == htons(ETH_P_IPV6)) {
113 ip !! 432 return secure_tcpv6_sequence_number(skb->nh.ipv6h->daddr.s6_addr32,
114 tc !! 433 skb->nh.ipv6h->saddr.s6_addr32,
115 tc !! 434 skb->h.th->dest,
>> 435 skb->h.th->source);
>> 436 } else {
>> 437 return secure_tcp_sequence_number(skb->nh.iph->daddr,
>> 438 skb->nh.iph->saddr,
>> 439 skb->h.th->dest,
>> 440 skb->h.th->source);
>> 441 }
116 } 442 }
117 443
118 static int tcp_v6_connect(struct sock *sk, str !! 444 static int tcp_v6_check_established(struct sock *sk)
>> 445 {
>> 446 struct inet_sock *inet = inet_sk(sk);
>> 447 struct ipv6_pinfo *np = inet6_sk(sk);
>> 448 struct in6_addr *daddr = &np->rcv_saddr;
>> 449 struct in6_addr *saddr = &np->daddr;
>> 450 int dif = sk->sk_bound_dev_if;
>> 451 u32 ports = TCP_COMBINED_PORTS(inet->dport, inet->num);
>> 452 int hash = tcp_v6_hashfn(daddr, inet->num, saddr, inet->dport);
>> 453 struct tcp_ehash_bucket *head = &tcp_ehash[hash];
>> 454 struct sock *sk2;
>> 455 struct hlist_node *node;
>> 456 struct tcp_tw_bucket *tw;
>> 457
>> 458 write_lock_bh(&head->lock);
>> 459
>> 460 /* Check TIME-WAIT sockets first. */
>> 461 sk_for_each(sk2, node, &(head + tcp_ehash_size)->chain) {
>> 462 tw = (struct tcp_tw_bucket*)sk2;
>> 463
>> 464 if(*((__u32 *)&(tw->tw_dport)) == ports &&
>> 465 sk2->sk_family == PF_INET6 &&
>> 466 ipv6_addr_equal(&tw->tw_v6_daddr, saddr) &&
>> 467 ipv6_addr_equal(&tw->tw_v6_rcv_saddr, daddr) &&
>> 468 sk2->sk_bound_dev_if == sk->sk_bound_dev_if) {
>> 469 struct tcp_sock *tp = tcp_sk(sk);
>> 470
>> 471 if (tw->tw_ts_recent_stamp) {
>> 472 /* See comment in tcp_ipv4.c */
>> 473 tp->write_seq = tw->tw_snd_nxt + 65535 + 2;
>> 474 if (!tp->write_seq)
>> 475 tp->write_seq = 1;
>> 476 tp->rx_opt.ts_recent = tw->tw_ts_recent;
>> 477 tp->rx_opt.ts_recent_stamp = tw->tw_ts_recent_stamp;
>> 478 sock_hold(sk2);
>> 479 goto unique;
>> 480 } else
>> 481 goto not_unique;
>> 482 }
>> 483 }
>> 484 tw = NULL;
>> 485
>> 486 /* And established part... */
>> 487 sk_for_each(sk2, node, &head->chain) {
>> 488 if(TCP_IPV6_MATCH(sk2, saddr, daddr, ports, dif))
>> 489 goto not_unique;
>> 490 }
>> 491
>> 492 unique:
>> 493 BUG_TRAP(sk_unhashed(sk));
>> 494 __sk_add_node(sk, &head->chain);
>> 495 sk->sk_hashent = hash;
>> 496 sock_prot_inc_use(sk->sk_prot);
>> 497 write_unlock_bh(&head->lock);
>> 498
>> 499 if (tw) {
>> 500 /* Silly. Should hash-dance instead... */
>> 501 local_bh_disable();
>> 502 tcp_tw_deschedule(tw);
>> 503 NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED);
>> 504 local_bh_enable();
>> 505
>> 506 tcp_tw_put(tw);
>> 507 }
>> 508 return 0;
>> 509
>> 510 not_unique:
>> 511 write_unlock_bh(&head->lock);
>> 512 return -EADDRNOTAVAIL;
>> 513 }
>> 514
>> 515 static int tcp_v6_hash_connect(struct sock *sk)
>> 516 {
>> 517 struct tcp_bind_hashbucket *head;
>> 518 struct tcp_bind_bucket *tb;
>> 519
>> 520 /* XXX */
>> 521 if (inet_sk(sk)->num == 0) {
>> 522 int err = tcp_v6_get_port(sk, inet_sk(sk)->num);
>> 523 if (err)
>> 524 return err;
>> 525 inet_sk(sk)->sport = htons(inet_sk(sk)->num);
>> 526 }
>> 527
>> 528 head = &tcp_bhash[tcp_bhashfn(inet_sk(sk)->num)];
>> 529 tb = tb_head(head);
>> 530
>> 531 spin_lock_bh(&head->lock);
>> 532
>> 533 if (sk_head(&tb->owners) == sk && !sk->sk_bind_node.next) {
>> 534 __tcp_v6_hash(sk);
>> 535 spin_unlock_bh(&head->lock);
>> 536 return 0;
>> 537 } else {
>> 538 spin_unlock_bh(&head->lock);
>> 539 return tcp_v6_check_established(sk);
>> 540 }
>> 541 }
>> 542
>> 543 static __inline__ int tcp_v6_iif(struct sk_buff *skb)
>> 544 {
>> 545 return IP6CB(skb)->iif;
>> 546 }
>> 547
>> 548 static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
119 int addr_len) 549 int addr_len)
120 { 550 {
121 struct sockaddr_in6 *usin = (struct so 551 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
122 struct inet_sock *inet = inet_sk(sk); 552 struct inet_sock *inet = inet_sk(sk);
123 struct inet_connection_sock *icsk = in <<
124 struct ipv6_pinfo *np = inet6_sk(sk); 553 struct ipv6_pinfo *np = inet6_sk(sk);
125 struct tcp_sock *tp = tcp_sk(sk); 554 struct tcp_sock *tp = tcp_sk(sk);
126 struct in6_addr *saddr = NULL, *final_ 555 struct in6_addr *saddr = NULL, *final_p = NULL, final;
127 struct flowi fl; 556 struct flowi fl;
128 struct dst_entry *dst; 557 struct dst_entry *dst;
129 int addr_type; 558 int addr_type;
130 int err; 559 int err;
131 560
132 if (addr_len < SIN6_LEN_RFC2133) !! 561 if (addr_len < SIN6_LEN_RFC2133)
133 return -EINVAL; 562 return -EINVAL;
134 563
135 if (usin->sin6_family != AF_INET6) !! 564 if (usin->sin6_family != AF_INET6)
136 return(-EAFNOSUPPORT); 565 return(-EAFNOSUPPORT);
137 566
138 memset(&fl, 0, sizeof(fl)); 567 memset(&fl, 0, sizeof(fl));
139 568
140 if (np->sndflow) { 569 if (np->sndflow) {
141 fl.fl6_flowlabel = usin->sin6_ 570 fl.fl6_flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
142 IP6_ECN_flow_init(fl.fl6_flowl 571 IP6_ECN_flow_init(fl.fl6_flowlabel);
143 if (fl.fl6_flowlabel&IPV6_FLOW 572 if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) {
144 struct ip6_flowlabel * 573 struct ip6_flowlabel *flowlabel;
145 flowlabel = fl6_sock_l 574 flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
146 if (flowlabel == NULL) 575 if (flowlabel == NULL)
147 return -EINVAL 576 return -EINVAL;
148 ipv6_addr_copy(&usin-> 577 ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
149 fl6_sock_release(flowl 578 fl6_sock_release(flowlabel);
150 } 579 }
151 } 580 }
152 581
153 /* 582 /*
154 * connect() to INADDR_ANY means !! 583 * connect() to INADDR_ANY means loopback (BSD'ism).
155 */ !! 584 */
156 !! 585
157 if(ipv6_addr_any(&usin->sin6_addr)) !! 586 if(ipv6_addr_any(&usin->sin6_addr))
158 usin->sin6_addr.s6_addr[15] = !! 587 usin->sin6_addr.s6_addr[15] = 0x1;
159 588
160 addr_type = ipv6_addr_type(&usin->sin6 589 addr_type = ipv6_addr_type(&usin->sin6_addr);
161 590
162 if(addr_type & IPV6_ADDR_MULTICAST) 591 if(addr_type & IPV6_ADDR_MULTICAST)
163 return -ENETUNREACH; 592 return -ENETUNREACH;
164 593
165 if (addr_type&IPV6_ADDR_LINKLOCAL) { 594 if (addr_type&IPV6_ADDR_LINKLOCAL) {
166 if (addr_len >= sizeof(struct 595 if (addr_len >= sizeof(struct sockaddr_in6) &&
167 usin->sin6_scope_id) { 596 usin->sin6_scope_id) {
168 /* If interface is set 597 /* If interface is set while binding, indices
169 * must coincide. 598 * must coincide.
170 */ 599 */
171 if (sk->sk_bound_dev_i 600 if (sk->sk_bound_dev_if &&
172 sk->sk_bound_dev_i 601 sk->sk_bound_dev_if != usin->sin6_scope_id)
173 return -EINVAL 602 return -EINVAL;
174 603
175 sk->sk_bound_dev_if = 604 sk->sk_bound_dev_if = usin->sin6_scope_id;
176 } 605 }
177 606
178 /* Connect to link-local addre 607 /* Connect to link-local address requires an interface */
179 if (!sk->sk_bound_dev_if) 608 if (!sk->sk_bound_dev_if)
180 return -EINVAL; 609 return -EINVAL;
181 } 610 }
182 611
183 if (tp->rx_opt.ts_recent_stamp && 612 if (tp->rx_opt.ts_recent_stamp &&
184 !ipv6_addr_equal(&np->daddr, &usin 613 !ipv6_addr_equal(&np->daddr, &usin->sin6_addr)) {
185 tp->rx_opt.ts_recent = 0; 614 tp->rx_opt.ts_recent = 0;
186 tp->rx_opt.ts_recent_stamp = 0 615 tp->rx_opt.ts_recent_stamp = 0;
187 tp->write_seq = 0; 616 tp->write_seq = 0;
188 } 617 }
189 618
190 ipv6_addr_copy(&np->daddr, &usin->sin6 619 ipv6_addr_copy(&np->daddr, &usin->sin6_addr);
191 np->flow_label = fl.fl6_flowlabel; 620 np->flow_label = fl.fl6_flowlabel;
192 621
193 /* 622 /*
194 * TCP over IPv4 623 * TCP over IPv4
195 */ 624 */
196 625
197 if (addr_type == IPV6_ADDR_MAPPED) { 626 if (addr_type == IPV6_ADDR_MAPPED) {
198 u32 exthdrlen = icsk->icsk_ext !! 627 u32 exthdrlen = tp->ext_header_len;
199 struct sockaddr_in sin; 628 struct sockaddr_in sin;
200 629
201 SOCK_DEBUG(sk, "connect: ipv4 630 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
202 631
203 if (__ipv6_only_sock(sk)) 632 if (__ipv6_only_sock(sk))
204 return -ENETUNREACH; 633 return -ENETUNREACH;
205 634
206 sin.sin_family = AF_INET; 635 sin.sin_family = AF_INET;
207 sin.sin_port = usin->sin6_port 636 sin.sin_port = usin->sin6_port;
208 sin.sin_addr.s_addr = usin->si 637 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
209 638
210 icsk->icsk_af_ops = &ipv6_mapp !! 639 tp->af_specific = &ipv6_mapped;
211 sk->sk_backlog_rcv = tcp_v4_do 640 sk->sk_backlog_rcv = tcp_v4_do_rcv;
212 #ifdef CONFIG_TCP_MD5SIG <<
213 tp->af_specific = &tcp_sock_ip <<
214 #endif <<
215 641
216 err = tcp_v4_connect(sk, (stru 642 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
217 643
218 if (err) { 644 if (err) {
219 icsk->icsk_ext_hdr_len !! 645 tp->ext_header_len = exthdrlen;
220 icsk->icsk_af_ops = &i !! 646 tp->af_specific = &ipv6_specific;
221 sk->sk_backlog_rcv = t 647 sk->sk_backlog_rcv = tcp_v6_do_rcv;
222 #ifdef CONFIG_TCP_MD5SIG <<
223 tp->af_specific = &tcp <<
224 #endif <<
225 goto failure; 648 goto failure;
226 } else { 649 } else {
227 ipv6_addr_set(&np->sad 650 ipv6_addr_set(&np->saddr, 0, 0, htonl(0x0000FFFF),
228 inet->sa 651 inet->saddr);
229 ipv6_addr_set(&np->rcv 652 ipv6_addr_set(&np->rcv_saddr, 0, 0, htonl(0x0000FFFF),
230 inet->rc 653 inet->rcv_saddr);
231 } 654 }
232 655
233 return err; 656 return err;
234 } 657 }
235 658
236 if (!ipv6_addr_any(&np->rcv_saddr)) 659 if (!ipv6_addr_any(&np->rcv_saddr))
237 saddr = &np->rcv_saddr; 660 saddr = &np->rcv_saddr;
238 661
239 fl.proto = IPPROTO_TCP; 662 fl.proto = IPPROTO_TCP;
240 ipv6_addr_copy(&fl.fl6_dst, &np->daddr 663 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
241 ipv6_addr_copy(&fl.fl6_src, 664 ipv6_addr_copy(&fl.fl6_src,
242 (saddr ? saddr : &np->s 665 (saddr ? saddr : &np->saddr));
243 fl.oif = sk->sk_bound_dev_if; 666 fl.oif = sk->sk_bound_dev_if;
244 fl.fl_ip_dport = usin->sin6_port; 667 fl.fl_ip_dport = usin->sin6_port;
245 fl.fl_ip_sport = inet->sport; 668 fl.fl_ip_sport = inet->sport;
246 669
247 if (np->opt && np->opt->srcrt) { 670 if (np->opt && np->opt->srcrt) {
248 struct rt0_hdr *rt0 = (struct 671 struct rt0_hdr *rt0 = (struct rt0_hdr *)np->opt->srcrt;
249 ipv6_addr_copy(&final, &fl.fl6 672 ipv6_addr_copy(&final, &fl.fl6_dst);
250 ipv6_addr_copy(&fl.fl6_dst, rt 673 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
251 final_p = &final; 674 final_p = &final;
252 } 675 }
253 676
254 security_sk_classify_flow(sk, &fl); <<
255 <<
256 err = ip6_dst_lookup(sk, &dst, &fl); 677 err = ip6_dst_lookup(sk, &dst, &fl);
257 if (err) 678 if (err)
258 goto failure; 679 goto failure;
259 if (final_p) 680 if (final_p)
260 ipv6_addr_copy(&fl.fl6_dst, fi 681 ipv6_addr_copy(&fl.fl6_dst, final_p);
261 682
262 if ((err = __xfrm_lookup(&dst, &fl, sk !! 683 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) {
263 if (err == -EREMOTE) !! 684 dst_release(dst);
264 err = ip6_dst_blackhol !! 685 goto failure;
265 if (err < 0) <<
266 goto failure; <<
267 } 686 }
268 687
269 if (saddr == NULL) { 688 if (saddr == NULL) {
270 saddr = &fl.fl6_src; 689 saddr = &fl.fl6_src;
271 ipv6_addr_copy(&np->rcv_saddr, 690 ipv6_addr_copy(&np->rcv_saddr, saddr);
272 } 691 }
273 692
274 /* set the source address */ 693 /* set the source address */
275 ipv6_addr_copy(&np->saddr, saddr); 694 ipv6_addr_copy(&np->saddr, saddr);
276 inet->rcv_saddr = LOOPBACK4_IPV6; 695 inet->rcv_saddr = LOOPBACK4_IPV6;
277 696
278 sk->sk_gso_type = SKB_GSO_TCPV6; !! 697 ip6_dst_store(sk, dst, NULL);
279 __ip6_dst_store(sk, dst, NULL, NULL); !! 698 sk->sk_route_caps = dst->dev->features &
>> 699 ~(NETIF_F_IP_CSUM | NETIF_F_TSO);
280 700
281 icsk->icsk_ext_hdr_len = 0; !! 701 tp->ext_header_len = 0;
282 if (np->opt) 702 if (np->opt)
283 icsk->icsk_ext_hdr_len = (np-> !! 703 tp->ext_header_len = np->opt->opt_flen + np->opt->opt_nflen;
284 np-> !! 704 tp->ext2_header_len = dst->header_len;
285 705
286 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - 706 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
287 707
288 inet->dport = usin->sin6_port; 708 inet->dport = usin->sin6_port;
289 709
290 tcp_set_state(sk, TCP_SYN_SENT); 710 tcp_set_state(sk, TCP_SYN_SENT);
291 err = inet6_hash_connect(&tcp_death_ro !! 711 err = tcp_v6_hash_connect(sk);
292 if (err) 712 if (err)
293 goto late_failure; 713 goto late_failure;
294 714
295 if (!tp->write_seq) 715 if (!tp->write_seq)
296 tp->write_seq = secure_tcpv6_s 716 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
297 717 np->daddr.s6_addr32,
298 718 inet->sport,
299 719 inet->dport);
300 720
301 err = tcp_connect(sk); 721 err = tcp_connect(sk);
302 if (err) 722 if (err)
303 goto late_failure; 723 goto late_failure;
304 724
305 return 0; 725 return 0;
306 726
307 late_failure: 727 late_failure:
308 tcp_set_state(sk, TCP_CLOSE); 728 tcp_set_state(sk, TCP_CLOSE);
309 __sk_dst_reset(sk); 729 __sk_dst_reset(sk);
310 failure: 730 failure:
311 inet->dport = 0; 731 inet->dport = 0;
312 sk->sk_route_caps = 0; 732 sk->sk_route_caps = 0;
313 return err; 733 return err;
314 } 734 }
315 735
316 static void tcp_v6_err(struct sk_buff *skb, st 736 static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
317 int type, int code, int offset !! 737 int type, int code, int offset, __u32 info)
318 { 738 {
319 struct ipv6hdr *hdr = (struct ipv6hdr* 739 struct ipv6hdr *hdr = (struct ipv6hdr*)skb->data;
320 const struct tcphdr *th = (struct tcph !! 740 struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
321 struct ipv6_pinfo *np; 741 struct ipv6_pinfo *np;
322 struct sock *sk; 742 struct sock *sk;
323 int err; 743 int err;
324 struct tcp_sock *tp; !! 744 struct tcp_sock *tp;
325 __u32 seq; 745 __u32 seq;
326 746
327 sk = inet6_lookup(skb->dev->nd_net, &t !! 747 sk = tcp_v6_lookup(&hdr->daddr, th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
328 th->dest, &hdr->saddr, <<
329 748
330 if (sk == NULL) { 749 if (sk == NULL) {
331 ICMP6_INC_STATS_BH(__in6_dev_g 750 ICMP6_INC_STATS_BH(__in6_dev_get(skb->dev), ICMP6_MIB_INERRORS);
332 return; 751 return;
333 } 752 }
334 753
335 if (sk->sk_state == TCP_TIME_WAIT) { 754 if (sk->sk_state == TCP_TIME_WAIT) {
336 inet_twsk_put(inet_twsk(sk)); !! 755 tcp_tw_put((struct tcp_tw_bucket*)sk);
337 return; 756 return;
338 } 757 }
339 758
340 bh_lock_sock(sk); 759 bh_lock_sock(sk);
341 if (sock_owned_by_user(sk)) 760 if (sock_owned_by_user(sk))
342 NET_INC_STATS_BH(LINUX_MIB_LOC 761 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
343 762
344 if (sk->sk_state == TCP_CLOSE) 763 if (sk->sk_state == TCP_CLOSE)
345 goto out; 764 goto out;
346 765
347 tp = tcp_sk(sk); 766 tp = tcp_sk(sk);
348 seq = ntohl(th->seq); !! 767 seq = ntohl(th->seq);
349 if (sk->sk_state != TCP_LISTEN && 768 if (sk->sk_state != TCP_LISTEN &&
350 !between(seq, tp->snd_una, tp->snd 769 !between(seq, tp->snd_una, tp->snd_nxt)) {
351 NET_INC_STATS_BH(LINUX_MIB_OUT 770 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
352 goto out; 771 goto out;
353 } 772 }
354 773
355 np = inet6_sk(sk); 774 np = inet6_sk(sk);
356 775
357 if (type == ICMPV6_PKT_TOOBIG) { 776 if (type == ICMPV6_PKT_TOOBIG) {
358 struct dst_entry *dst = NULL; 777 struct dst_entry *dst = NULL;
359 778
360 if (sock_owned_by_user(sk)) 779 if (sock_owned_by_user(sk))
361 goto out; 780 goto out;
362 if ((1 << sk->sk_state) & (TCP 781 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
363 goto out; 782 goto out;
364 783
365 /* icmp should have updated th 784 /* icmp should have updated the destination cache entry */
366 dst = __sk_dst_check(sk, np->d 785 dst = __sk_dst_check(sk, np->dst_cookie);
367 786
368 if (dst == NULL) { 787 if (dst == NULL) {
369 struct inet_sock *inet 788 struct inet_sock *inet = inet_sk(sk);
370 struct flowi fl; 789 struct flowi fl;
371 790
372 /* BUGGG_FUTURE: Again 791 /* BUGGG_FUTURE: Again, it is not clear how
373 to handle rthdr cas 792 to handle rthdr case. Ignore this complexity
374 for now. 793 for now.
375 */ 794 */
376 memset(&fl, 0, sizeof( 795 memset(&fl, 0, sizeof(fl));
377 fl.proto = IPPROTO_TCP 796 fl.proto = IPPROTO_TCP;
378 ipv6_addr_copy(&fl.fl6 797 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
379 ipv6_addr_copy(&fl.fl6 798 ipv6_addr_copy(&fl.fl6_src, &np->saddr);
380 fl.oif = sk->sk_bound_ 799 fl.oif = sk->sk_bound_dev_if;
381 fl.fl_ip_dport = inet- 800 fl.fl_ip_dport = inet->dport;
382 fl.fl_ip_sport = inet- 801 fl.fl_ip_sport = inet->sport;
383 security_skb_classify_ <<
384 802
385 if ((err = ip6_dst_loo 803 if ((err = ip6_dst_lookup(sk, &dst, &fl))) {
386 sk->sk_err_sof 804 sk->sk_err_soft = -err;
387 goto out; 805 goto out;
388 } 806 }
389 807
390 if ((err = xfrm_lookup 808 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) {
391 sk->sk_err_sof 809 sk->sk_err_soft = -err;
392 goto out; 810 goto out;
393 } 811 }
394 812
395 } else 813 } else
396 dst_hold(dst); 814 dst_hold(dst);
397 815
398 if (inet_csk(sk)->icsk_pmtu_co !! 816 if (tp->pmtu_cookie > dst_pmtu(dst)) {
399 tcp_sync_mss(sk, dst_m !! 817 tcp_sync_mss(sk, dst_pmtu(dst));
400 tcp_simple_retransmit( 818 tcp_simple_retransmit(sk);
401 } /* else let the usual retran 819 } /* else let the usual retransmit timer handle it */
402 dst_release(dst); 820 dst_release(dst);
403 goto out; 821 goto out;
404 } 822 }
405 823
406 icmpv6_err_convert(type, code, &err); 824 icmpv6_err_convert(type, code, &err);
407 825
408 /* Might be for an request_sock */ !! 826 /* Might be for an open_request */
409 switch (sk->sk_state) { 827 switch (sk->sk_state) {
410 struct request_sock *req, **pr !! 828 struct open_request *req, **prev;
411 case TCP_LISTEN: 829 case TCP_LISTEN:
412 if (sock_owned_by_user(sk)) 830 if (sock_owned_by_user(sk))
413 goto out; 831 goto out;
414 832
415 req = inet6_csk_search_req(sk, !! 833 req = tcp_v6_search_req(tp, &prev, th->dest, &hdr->daddr,
416 &hd !! 834 &hdr->saddr, tcp_v6_iif(skb));
417 if (!req) 835 if (!req)
418 goto out; 836 goto out;
419 837
420 /* ICMPs are not backlogged, h 838 /* ICMPs are not backlogged, hence we cannot get
421 * an established socket here. 839 * an established socket here.
422 */ 840 */
423 BUG_TRAP(req->sk == NULL); 841 BUG_TRAP(req->sk == NULL);
424 842
425 if (seq != tcp_rsk(req)->snt_i !! 843 if (seq != req->snt_isn) {
426 NET_INC_STATS_BH(LINUX 844 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
427 goto out; 845 goto out;
428 } 846 }
429 847
430 inet_csk_reqsk_queue_drop(sk, !! 848 tcp_synq_drop(sk, req, prev);
431 goto out; 849 goto out;
432 850
433 case TCP_SYN_SENT: 851 case TCP_SYN_SENT:
434 case TCP_SYN_RECV: /* Cannot happen. 852 case TCP_SYN_RECV: /* Cannot happen.
435 It can, it SYNs !! 853 It can, it SYNs are crossed. --ANK */
436 if (!sock_owned_by_user(sk)) { 854 if (!sock_owned_by_user(sk)) {
>> 855 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
437 sk->sk_err = err; 856 sk->sk_err = err;
438 sk->sk_error_report(sk 857 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
439 858
440 tcp_done(sk); 859 tcp_done(sk);
441 } else 860 } else
442 sk->sk_err_soft = err; 861 sk->sk_err_soft = err;
443 goto out; 862 goto out;
444 } 863 }
445 864
446 if (!sock_owned_by_user(sk) && np->rec 865 if (!sock_owned_by_user(sk) && np->recverr) {
447 sk->sk_err = err; 866 sk->sk_err = err;
448 sk->sk_error_report(sk); 867 sk->sk_error_report(sk);
449 } else 868 } else
450 sk->sk_err_soft = err; 869 sk->sk_err_soft = err;
451 870
452 out: 871 out:
453 bh_unlock_sock(sk); 872 bh_unlock_sock(sk);
454 sock_put(sk); 873 sock_put(sk);
455 } 874 }
456 875
457 876
458 static int tcp_v6_send_synack(struct sock *sk, !! 877 static int tcp_v6_send_synack(struct sock *sk, struct open_request *req,
459 struct dst_entry 878 struct dst_entry *dst)
460 { 879 {
461 struct inet6_request_sock *treq = inet <<
462 struct ipv6_pinfo *np = inet6_sk(sk); 880 struct ipv6_pinfo *np = inet6_sk(sk);
463 struct sk_buff * skb; 881 struct sk_buff * skb;
464 struct ipv6_txoptions *opt = NULL; 882 struct ipv6_txoptions *opt = NULL;
465 struct in6_addr * final_p = NULL, fina 883 struct in6_addr * final_p = NULL, final;
466 struct flowi fl; 884 struct flowi fl;
467 int err = -1; 885 int err = -1;
468 886
469 memset(&fl, 0, sizeof(fl)); 887 memset(&fl, 0, sizeof(fl));
470 fl.proto = IPPROTO_TCP; 888 fl.proto = IPPROTO_TCP;
471 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt !! 889 ipv6_addr_copy(&fl.fl6_dst, &req->af.v6_req.rmt_addr);
472 ipv6_addr_copy(&fl.fl6_src, &treq->loc !! 890 ipv6_addr_copy(&fl.fl6_src, &req->af.v6_req.loc_addr);
473 fl.fl6_flowlabel = 0; 891 fl.fl6_flowlabel = 0;
474 fl.oif = treq->iif; !! 892 fl.oif = req->af.v6_req.iif;
475 fl.fl_ip_dport = inet_rsk(req)->rmt_po !! 893 fl.fl_ip_dport = req->rmt_port;
476 fl.fl_ip_sport = inet_sk(sk)->sport; 894 fl.fl_ip_sport = inet_sk(sk)->sport;
477 security_req_classify_flow(req, &fl); <<
478 895
479 if (dst == NULL) { 896 if (dst == NULL) {
480 opt = np->opt; 897 opt = np->opt;
>> 898 if (opt == NULL &&
>> 899 np->rxopt.bits.srcrt == 2 &&
>> 900 req->af.v6_req.pktopts) {
>> 901 struct sk_buff *pktopts = req->af.v6_req.pktopts;
>> 902 struct inet6_skb_parm *rxopt = IP6CB(pktopts);
>> 903 if (rxopt->srcrt)
>> 904 opt = ipv6_invert_rthdr(sk, (struct ipv6_rt_hdr*)(pktopts->nh.raw + rxopt->srcrt));
>> 905 }
>> 906
481 if (opt && opt->srcrt) { 907 if (opt && opt->srcrt) {
482 struct rt0_hdr *rt0 = 908 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
483 ipv6_addr_copy(&final, 909 ipv6_addr_copy(&final, &fl.fl6_dst);
484 ipv6_addr_copy(&fl.fl6 910 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
485 final_p = &final; 911 final_p = &final;
486 } 912 }
487 913
488 err = ip6_dst_lookup(sk, &dst, 914 err = ip6_dst_lookup(sk, &dst, &fl);
489 if (err) 915 if (err)
490 goto done; 916 goto done;
491 if (final_p) 917 if (final_p)
492 ipv6_addr_copy(&fl.fl6 918 ipv6_addr_copy(&fl.fl6_dst, final_p);
493 if ((err = xfrm_lookup(&dst, & 919 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
494 goto done; 920 goto done;
495 } 921 }
496 922
497 skb = tcp_make_synack(sk, dst, req); 923 skb = tcp_make_synack(sk, dst, req);
498 if (skb) { 924 if (skb) {
499 struct tcphdr *th = tcp_hdr(sk !! 925 struct tcphdr *th = skb->h.th;
500 926
501 th->check = tcp_v6_check(th, s 927 th->check = tcp_v6_check(th, skb->len,
502 &treq !! 928 &req->af.v6_req.loc_addr, &req->af.v6_req.rmt_addr,
503 csum_ 929 csum_partial((char *)th, skb->len, skb->csum));
504 930
505 ipv6_addr_copy(&fl.fl6_dst, &t !! 931 ipv6_addr_copy(&fl.fl6_dst, &req->af.v6_req.rmt_addr);
506 err = ip6_xmit(sk, skb, &fl, o 932 err = ip6_xmit(sk, skb, &fl, opt, 0);
507 err = net_xmit_eval(err); !! 933 if (err == NET_XMIT_CN)
>> 934 err = 0;
508 } 935 }
509 936
510 done: 937 done:
511 if (opt && opt != np->opt) <<
512 sock_kfree_s(sk, opt, opt->tot <<
513 dst_release(dst); 938 dst_release(dst);
>> 939 if (opt && opt != np->opt)
>> 940 sock_kfree_s(sk, opt, opt->tot_len);
514 return err; 941 return err;
515 } 942 }
516 943
517 static void tcp_v6_reqsk_destructor(struct req !! 944 static void tcp_v6_or_free(struct open_request *req)
518 { <<
519 if (inet6_rsk(req)->pktopts) <<
520 kfree_skb(inet6_rsk(req)->pkto <<
521 } <<
522 <<
523 #ifdef CONFIG_TCP_MD5SIG <<
524 static struct tcp_md5sig_key *tcp_v6_md5_do_lo <<
525 <<
526 { <<
527 struct tcp_sock *tp = tcp_sk(sk); <<
528 int i; <<
529 <<
530 BUG_ON(tp == NULL); <<
531 <<
532 if (!tp->md5sig_info || !tp->md5sig_in <<
533 return NULL; <<
534 <<
535 for (i = 0; i < tp->md5sig_info->entri <<
536 if (ipv6_addr_cmp(&tp->md5sig_ <<
537 return &tp->md5sig_inf <<
538 } <<
539 return NULL; <<
540 } <<
541 <<
542 static struct tcp_md5sig_key *tcp_v6_md5_looku <<
543 <<
544 { <<
545 return tcp_v6_md5_do_lookup(sk, &inet6 <<
546 } <<
547 <<
548 static struct tcp_md5sig_key *tcp_v6_reqsk_md5 <<
549 <<
550 { <<
551 return tcp_v6_md5_do_lookup(sk, &inet6 <<
552 } <<
553 <<
554 static int tcp_v6_md5_do_add(struct sock *sk, <<
555 char *newkey, u8 <<
556 { 945 {
557 /* Add key to the list */ !! 946 if (req->af.v6_req.pktopts)
558 struct tcp_md5sig_key *key; !! 947 kfree_skb(req->af.v6_req.pktopts);
559 struct tcp_sock *tp = tcp_sk(sk); <<
560 struct tcp6_md5sig_key *keys; <<
561 <<
562 key = tcp_v6_md5_do_lookup(sk, peer); <<
563 if (key) { <<
564 /* modify existing entry - jus <<
565 kfree(key->key); <<
566 key->key = newkey; <<
567 key->keylen = newkeylen; <<
568 } else { <<
569 /* reallocate new list if curr <<
570 if (!tp->md5sig_info) { <<
571 tp->md5sig_info = kzal <<
572 if (!tp->md5sig_info) <<
573 kfree(newkey); <<
574 return -ENOMEM <<
575 } <<
576 sk->sk_route_caps &= ~ <<
577 } <<
578 if (tcp_alloc_md5sig_pool() == <<
579 kfree(newkey); <<
580 return -ENOMEM; <<
581 } <<
582 if (tp->md5sig_info->alloced6 <<
583 keys = kmalloc((sizeof <<
584 (tp->md <<
585 <<
586 if (!keys) { <<
587 tcp_free_md5si <<
588 kfree(newkey); <<
589 return -ENOMEM <<
590 } <<
591 <<
592 if (tp->md5sig_info->e <<
593 memmove(keys, <<
594 (sizeo <<
595 tp->m <<
596 <<
597 kfree(tp->md5sig_info- <<
598 tp->md5sig_info->keys6 <<
599 tp->md5sig_info->alloc <<
600 } <<
601 <<
602 ipv6_addr_copy(&tp->md5sig_inf <<
603 peer); <<
604 tp->md5sig_info->keys6[tp->md5 <<
605 tp->md5sig_info->keys6[tp->md5 <<
606 <<
607 tp->md5sig_info->entries6++; <<
608 } <<
609 return 0; <<
610 } 948 }
611 949
612 static int tcp_v6_md5_add_func(struct sock *sk !! 950 static struct or_calltable or_ipv6 = {
613 u8 *newkey, __u !! 951 .family = AF_INET6,
614 { !! 952 .rtx_syn_ack = tcp_v6_send_synack,
615 return tcp_v6_md5_do_add(sk, &inet6_sk !! 953 .send_ack = tcp_v6_or_send_ack,
616 newkey, newke !! 954 .destructor = tcp_v6_or_free,
617 } !! 955 .send_reset = tcp_v6_send_reset
618 !! 956 };
619 static int tcp_v6_md5_do_del(struct sock *sk, <<
620 { <<
621 struct tcp_sock *tp = tcp_sk(sk); <<
622 int i; <<
623 <<
624 for (i = 0; i < tp->md5sig_info->entri <<
625 if (ipv6_addr_cmp(&tp->md5sig_ <<
626 /* Free the key */ <<
627 kfree(tp->md5sig_info- <<
628 tp->md5sig_info->entri <<
629 <<
630 if (tp->md5sig_info->e <<
631 kfree(tp->md5s <<
632 tp->md5sig_inf <<
633 tp->md5sig_inf <<
634 } else { <<
635 /* shrink the <<
636 if (tp->md5sig <<
637 memmov <<
638 <<
639 <<
640 <<
641 } <<
642 tcp_free_md5sig_pool() <<
643 return 0; <<
644 } <<
645 } <<
646 return -ENOENT; <<
647 } <<
648 <<
649 static void tcp_v6_clear_md5_list (struct sock <<
650 { <<
651 struct tcp_sock *tp = tcp_sk(sk); <<
652 int i; <<
653 <<
654 if (tp->md5sig_info->entries6) { <<
655 for (i = 0; i < tp->md5sig_inf <<
656 kfree(tp->md5sig_info- <<
657 tp->md5sig_info->entries6 = 0; <<
658 tcp_free_md5sig_pool(); <<
659 } <<
660 <<
661 kfree(tp->md5sig_info->keys6); <<
662 tp->md5sig_info->keys6 = NULL; <<
663 tp->md5sig_info->alloced6 = 0; <<
664 <<
665 if (tp->md5sig_info->entries4) { <<
666 for (i = 0; i < tp->md5sig_inf <<
667 kfree(tp->md5sig_info- <<
668 tp->md5sig_info->entries4 = 0; <<
669 tcp_free_md5sig_pool(); <<
670 } <<
671 <<
672 kfree(tp->md5sig_info->keys4); <<
673 tp->md5sig_info->keys4 = NULL; <<
674 tp->md5sig_info->alloced4 = 0; <<
675 } <<
676 957
677 static int tcp_v6_parse_md5_keys (struct sock !! 958 static int ipv6_opt_accepted(struct sock *sk, struct sk_buff *skb)
678 int optlen) <<
679 { 959 {
680 struct tcp_md5sig cmd; !! 960 struct ipv6_pinfo *np = inet6_sk(sk);
681 struct sockaddr_in6 *sin6 = (struct so !! 961 struct inet6_skb_parm *opt = IP6CB(skb);
682 u8 *newkey; <<
683 <<
684 if (optlen < sizeof(cmd)) <<
685 return -EINVAL; <<
686 <<
687 if (copy_from_user(&cmd, optval, sizeo <<
688 return -EFAULT; <<
689 <<
690 if (sin6->sin6_family != AF_INET6) <<
691 return -EINVAL; <<
692 <<
693 if (!cmd.tcpm_keylen) { <<
694 if (!tcp_sk(sk)->md5sig_info) <<
695 return -ENOENT; <<
696 if (ipv6_addr_v4mapped(&sin6-> <<
697 return tcp_v4_md5_do_d <<
698 return tcp_v6_md5_do_del(sk, & <<
699 } <<
700 <<
701 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKE <<
702 return -EINVAL; <<
703 <<
704 if (!tcp_sk(sk)->md5sig_info) { <<
705 struct tcp_sock *tp = tcp_sk(s <<
706 struct tcp_md5sig_info *p; <<
707 <<
708 p = kzalloc(sizeof(struct tcp_ <<
709 if (!p) <<
710 return -ENOMEM; <<
711 <<
712 tp->md5sig_info = p; <<
713 sk->sk_route_caps &= ~NETIF_F_ <<
714 } <<
715 <<
716 newkey = kmemdup(cmd.tcpm_key, cmd.tcp <<
717 if (!newkey) <<
718 return -ENOMEM; <<
719 if (ipv6_addr_v4mapped(&sin6->sin6_add <<
720 return tcp_v4_md5_do_add(sk, s <<
721 newke <<
722 } <<
723 return tcp_v6_md5_do_add(sk, &sin6->si <<
724 } <<
725 <<
726 static int tcp_v6_do_calc_md5_hash(char *md5_h <<
727 struct in6_ <<
728 struct in6_ <<
729 struct tcph <<
730 unsigned in <<
731 { <<
732 struct scatterlist sg[4]; <<
733 __u16 data_len; <<
734 int block = 0; <<
735 __sum16 cksum; <<
736 struct tcp_md5sig_pool *hp; <<
737 struct tcp6_pseudohdr *bp; <<
738 struct hash_desc *desc; <<
739 int err; <<
740 unsigned int nbytes = 0; <<
741 <<
742 hp = tcp_get_md5sig_pool(); <<
743 if (!hp) { <<
744 printk(KERN_WARNING "%s(): has <<
745 goto clear_hash_noput; <<
746 } <<
747 bp = &hp->md5_blk.ip6; <<
748 desc = &hp->md5_desc; <<
749 <<
750 /* 1. TCP pseudo-header (RFC2460) */ <<
751 ipv6_addr_copy(&bp->saddr, saddr); <<
752 ipv6_addr_copy(&bp->daddr, daddr); <<
753 bp->len = htonl(tcplen); <<
754 bp->protocol = htonl(protocol); <<
755 <<
756 sg_init_table(sg, 4); <<
757 <<
758 sg_set_buf(&sg[block++], bp, sizeof(*b <<
759 nbytes += sizeof(*bp); <<
760 <<
761 /* 2. TCP header, excluding options */ <<
762 cksum = th->check; <<
763 th->check = 0; <<
764 sg_set_buf(&sg[block++], th, sizeof(*t <<
765 nbytes += sizeof(*th); <<
766 <<
767 /* 3. TCP segment data (if any) */ <<
768 data_len = tcplen - (th->doff << 2); <<
769 if (data_len > 0) { <<
770 u8 *data = (u8 *)th + (th->dof <<
771 sg_set_buf(&sg[block++], data, <<
772 nbytes += data_len; <<
773 } <<
774 <<
775 /* 4. shared key */ <<
776 sg_set_buf(&sg[block++], key->key, key <<
777 nbytes += key->keylen; <<
778 <<
779 sg_mark_end(&sg[block - 1]); <<
780 <<
781 /* Now store the hash into the packet <<
782 err = crypto_hash_init(desc); <<
783 if (err) { <<
784 printk(KERN_WARNING "%s(): has <<
785 goto clear_hash; <<
786 } <<
787 err = crypto_hash_update(desc, sg, nby <<
788 if (err) { <<
789 printk(KERN_WARNING "%s(): has <<
790 goto clear_hash; <<
791 } <<
792 err = crypto_hash_final(desc, md5_hash <<
793 if (err) { <<
794 printk(KERN_WARNING "%s(): has <<
795 goto clear_hash; <<
796 } <<
797 <<
798 /* Reset header, and free up the crypt <<
799 tcp_put_md5sig_pool(); <<
800 th->check = cksum; <<
801 out: <<
802 return 0; <<
803 clear_hash: <<
804 tcp_put_md5sig_pool(); <<
805 clear_hash_noput: <<
806 memset(md5_hash, 0, 16); <<
807 goto out; <<
808 } <<
809 <<
810 static int tcp_v6_calc_md5_hash(char *md5_hash <<
811 struct sock *s <<
812 struct dst_ent <<
813 struct request <<
814 struct tcphdr <<
815 unsigned int t <<
816 { <<
817 struct in6_addr *saddr, *daddr; <<
818 <<
819 if (sk) { <<
820 saddr = &inet6_sk(sk)->saddr; <<
821 daddr = &inet6_sk(sk)->daddr; <<
822 } else { <<
823 saddr = &inet6_rsk(req)->loc_a <<
824 daddr = &inet6_rsk(req)->rmt_a <<
825 } <<
826 return tcp_v6_do_calc_md5_hash(md5_has <<
827 saddr, <<
828 th, pro <<
829 } <<
830 <<
831 static int tcp_v6_inbound_md5_hash (struct soc <<
832 { <<
833 __u8 *hash_location = NULL; <<
834 struct tcp_md5sig_key *hash_expected; <<
835 struct ipv6hdr *ip6h = ipv6_hdr(skb); <<
836 struct tcphdr *th = tcp_hdr(skb); <<
837 int length = (th->doff << 2) - sizeof <<
838 int genhash; <<
839 u8 *ptr; <<
840 u8 newhash[16]; <<
841 <<
842 hash_expected = tcp_v6_md5_do_lookup(s <<
843 <<
844 /* If the TCP option is too short, we <<
845 if (length < TCPOLEN_MD5SIG) <<
846 return hash_expected ? 1 : 0; <<
847 <<
848 /* parse options */ <<
849 ptr = (u8*)(th + 1); <<
850 while (length > 0) { <<
851 int opcode = *ptr++; <<
852 int opsize; <<
853 <<
854 switch(opcode) { <<
855 case TCPOPT_EOL: <<
856 goto done_opts; <<
857 case TCPOPT_NOP: <<
858 length--; <<
859 continue; <<
860 default: <<
861 opsize = *ptr++; <<
862 if (opsize < 2 || opsi <<
863 goto done_opts <<
864 if (opcode == TCPOPT_M <<
865 hash_location <<
866 goto done_opts <<
867 } <<
868 } <<
869 ptr += opsize - 2; <<
870 length -= opsize; <<
871 } <<
872 962
873 done_opts: !! 963 if (np->rxopt.all) {
874 /* do we have a hash as expected? */ !! 964 if ((opt->hop && np->rxopt.bits.hopopts) ||
875 if (!hash_expected) { !! 965 ((IPV6_FLOWINFO_MASK&*(u32*)skb->nh.raw) &&
876 if (!hash_location) !! 966 np->rxopt.bits.rxflow) ||
877 return 0; !! 967 (opt->srcrt && np->rxopt.bits.srcrt) ||
878 if (net_ratelimit()) { !! 968 ((opt->dst1 || opt->dst0) && np->rxopt.bits.dstopts))
879 printk(KERN_INFO "MD5 !! 969 return 1;
880 "(" NIP6_FMT ", <<
881 "(" NIP6_FMT ", <<
882 NIP6(ip6h->sadd <<
883 NIP6(ip6h->dadd <<
884 } <<
885 return 1; <<
886 } <<
887 <<
888 if (!hash_location) { <<
889 if (net_ratelimit()) { <<
890 printk(KERN_INFO "MD5 <<
891 "(" NIP6_FMT ", <<
892 "(" NIP6_FMT ", <<
893 NIP6(ip6h->sadd <<
894 NIP6(ip6h->dadd <<
895 } <<
896 return 1; <<
897 } <<
898 <<
899 /* check the signature */ <<
900 genhash = tcp_v6_do_calc_md5_hash(newh <<
901 hash <<
902 &ip6 <<
903 th, <<
904 skb- <<
905 if (genhash || memcmp(hash_location, n <<
906 if (net_ratelimit()) { <<
907 printk(KERN_INFO "MD5 <<
908 "(" NIP6_FMT ", <<
909 "(" NIP6_FMT ", <<
910 genhash ? "fail <<
911 NIP6(ip6h->sadd <<
912 NIP6(ip6h->dadd <<
913 } <<
914 return 1; <<
915 } 970 }
916 return 0; 971 return 0;
917 } 972 }
918 #endif <<
919 973
920 static struct request_sock_ops tcp6_request_so <<
921 .family = AF_INET6, <<
922 .obj_size = sizeof(struct <<
923 .rtx_syn_ack = tcp_v6_send_sy <<
924 .send_ack = tcp_v6_reqsk_s <<
925 .destructor = tcp_v6_reqsk_d <<
926 .send_reset = tcp_v6_send_re <<
927 }; <<
928 <<
929 #ifdef CONFIG_TCP_MD5SIG <<
930 static struct tcp_request_sock_ops tcp_request <<
931 .md5_lookup = tcp_v6_reqsk_m <<
932 }; <<
933 #endif <<
934 974
935 static struct timewait_sock_ops tcp6_timewait_ !! 975 static void tcp_v6_send_check(struct sock *sk, struct tcphdr *th, int len,
936 .twsk_obj_size = sizeof(struct tcp6_t !! 976 struct sk_buff *skb)
937 .twsk_unique = tcp_twsk_unique, <<
938 .twsk_destructor= tcp_twsk_destructor, <<
939 }; <<
940 <<
941 static void tcp_v6_send_check(struct sock *sk, <<
942 { 977 {
943 struct ipv6_pinfo *np = inet6_sk(sk); 978 struct ipv6_pinfo *np = inet6_sk(sk);
944 struct tcphdr *th = tcp_hdr(skb); <<
945 979
946 if (skb->ip_summed == CHECKSUM_PARTIAL !! 980 if (skb->ip_summed == CHECKSUM_HW) {
947 th->check = ~csum_ipv6_magic(& 981 th->check = ~csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP, 0);
948 skb->csum_start = skb_transpor !! 982 skb->csum = offsetof(struct tcphdr, check);
949 skb->csum_offset = offsetof(st <<
950 } else { 983 } else {
951 th->check = csum_ipv6_magic(&n !! 984 th->check = csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP,
952 cs !! 985 csum_partial((char *)th, th->doff<<2,
953 986 skb->csum));
954 } 987 }
955 } 988 }
956 989
957 static int tcp_v6_gso_send_check(struct sk_buf <<
958 { <<
959 struct ipv6hdr *ipv6h; <<
960 struct tcphdr *th; <<
961 <<
962 if (!pskb_may_pull(skb, sizeof(*th))) <<
963 return -EINVAL; <<
964 <<
965 ipv6h = ipv6_hdr(skb); <<
966 th = tcp_hdr(skb); <<
967 990
968 th->check = 0; !! 991 static void tcp_v6_send_reset(struct sk_buff *skb)
969 th->check = ~csum_ipv6_magic(&ipv6h->s <<
970 IPPROTO_T <<
971 skb->csum_start = skb_transport_header <<
972 skb->csum_offset = offsetof(struct tcp <<
973 skb->ip_summed = CHECKSUM_PARTIAL; <<
974 return 0; <<
975 } <<
976 <<
977 static void tcp_v6_send_reset(struct sock *sk, <<
978 { 992 {
979 struct tcphdr *th = tcp_hdr(skb), *t1; !! 993 struct tcphdr *th = skb->h.th, *t1;
980 struct sk_buff *buff; 994 struct sk_buff *buff;
981 struct flowi fl; 995 struct flowi fl;
982 unsigned int tot_len = sizeof(*th); <<
983 #ifdef CONFIG_TCP_MD5SIG <<
984 struct tcp_md5sig_key *key; <<
985 #endif <<
986 996
987 if (th->rst) 997 if (th->rst)
988 return; 998 return;
989 999
990 if (!ipv6_unicast_destination(skb)) 1000 if (!ipv6_unicast_destination(skb))
991 return; !! 1001 return;
992 <<
993 #ifdef CONFIG_TCP_MD5SIG <<
994 if (sk) <<
995 key = tcp_v6_md5_do_lookup(sk, <<
996 else <<
997 key = NULL; <<
998 <<
999 if (key) <<
1000 tot_len += TCPOLEN_MD5SIG_ALI <<
1001 #endif <<
1002 1002
1003 /* 1003 /*
1004 * We need to grab some memory, and p 1004 * We need to grab some memory, and put together an RST,
1005 * and then put it into the queue to 1005 * and then put it into the queue to be sent.
1006 */ 1006 */
1007 1007
1008 buff = alloc_skb(MAX_HEADER + sizeof( !! 1008 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + sizeof(struct tcphdr),
1009 GFP_ATOMIC); 1009 GFP_ATOMIC);
1010 if (buff == NULL) !! 1010 if (buff == NULL)
1011 return; !! 1011 return;
1012 1012
1013 skb_reserve(buff, MAX_HEADER + sizeof !! 1013 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + sizeof(struct tcphdr));
1014 1014
1015 t1 = (struct tcphdr *) skb_push(buff, !! 1015 t1 = (struct tcphdr *) skb_push(buff,sizeof(struct tcphdr));
1016 1016
1017 /* Swap the send and the receive. */ 1017 /* Swap the send and the receive. */
1018 memset(t1, 0, sizeof(*t1)); 1018 memset(t1, 0, sizeof(*t1));
1019 t1->dest = th->source; 1019 t1->dest = th->source;
1020 t1->source = th->dest; 1020 t1->source = th->dest;
1021 t1->doff = tot_len / 4; !! 1021 t1->doff = sizeof(*t1)/4;
1022 t1->rst = 1; 1022 t1->rst = 1;
1023 !! 1023
1024 if(th->ack) { 1024 if(th->ack) {
1025 t1->seq = th->ack_seq; !! 1025 t1->seq = th->ack_seq;
1026 } else { 1026 } else {
1027 t1->ack = 1; 1027 t1->ack = 1;
1028 t1->ack_seq = htonl(ntohl(th- 1028 t1->ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin
1029 + skb->le 1029 + skb->len - (th->doff<<2));
1030 } 1030 }
1031 1031
1032 #ifdef CONFIG_TCP_MD5SIG <<
1033 if (key) { <<
1034 __be32 *opt = (__be32*)(t1 + <<
1035 opt[0] = htonl((TCPOPT_NOP << <<
1036 (TCPOPT_NOP << <<
1037 (TCPOPT_MD5SIG <<
1038 TCPOLEN_MD5SIG <<
1039 tcp_v6_do_calc_md5_hash((__u8 <<
1040 &ipv6 <<
1041 &ipv6 <<
1042 t1, I <<
1043 } <<
1044 #endif <<
1045 <<
1046 buff->csum = csum_partial((char *)t1, 1032 buff->csum = csum_partial((char *)t1, sizeof(*t1), 0);
1047 1033
1048 memset(&fl, 0, sizeof(fl)); 1034 memset(&fl, 0, sizeof(fl));
1049 ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr !! 1035 ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
1050 ipv6_addr_copy(&fl.fl6_src, &ipv6_hdr !! 1036 ipv6_addr_copy(&fl.fl6_src, &skb->nh.ipv6h->daddr);
1051 1037
1052 t1->check = csum_ipv6_magic(&fl.fl6_s 1038 t1->check = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst,
1053 sizeof(*t 1039 sizeof(*t1), IPPROTO_TCP,
1054 buff->csu 1040 buff->csum);
1055 1041
1056 fl.proto = IPPROTO_TCP; 1042 fl.proto = IPPROTO_TCP;
1057 fl.oif = inet6_iif(skb); !! 1043 fl.oif = tcp_v6_iif(skb);
1058 fl.fl_ip_dport = t1->dest; 1044 fl.fl_ip_dport = t1->dest;
1059 fl.fl_ip_sport = t1->source; 1045 fl.fl_ip_sport = t1->source;
1060 security_skb_classify_flow(skb, &fl); <<
1061 1046
1062 /* sk = NULL, but it is safe for now. 1047 /* sk = NULL, but it is safe for now. RST socket required. */
1063 if (!ip6_dst_lookup(NULL, &buff->dst, 1048 if (!ip6_dst_lookup(NULL, &buff->dst, &fl)) {
1064 1049
1065 if (xfrm_lookup(&buff->dst, & !! 1050 if ((xfrm_lookup(&buff->dst, &fl, NULL, 0)) < 0) {
1066 ip6_xmit(tcp6_socket- !! 1051 dst_release(buff->dst);
1067 TCP_INC_STATS_BH(TCP_ <<
1068 TCP_INC_STATS_BH(TCP_ <<
1069 return; 1052 return;
1070 } 1053 }
>> 1054
>> 1055 ip6_xmit(NULL, buff, &fl, NULL, 0);
>> 1056 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
>> 1057 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
>> 1058 return;
1071 } 1059 }
1072 1060
1073 kfree_skb(buff); 1061 kfree_skb(buff);
1074 } 1062 }
1075 1063
1076 static void tcp_v6_send_ack(struct tcp_timewa !! 1064 static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack, u32 win, u32 ts)
1077 struct sk_buff *s <<
1078 { 1065 {
1079 struct tcphdr *th = tcp_hdr(skb), *t1 !! 1066 struct tcphdr *th = skb->h.th, *t1;
1080 struct sk_buff *buff; 1067 struct sk_buff *buff;
1081 struct flowi fl; 1068 struct flowi fl;
1082 unsigned int tot_len = sizeof(struct !! 1069 int tot_len = sizeof(struct tcphdr);
1083 __be32 *topt; <<
1084 #ifdef CONFIG_TCP_MD5SIG <<
1085 struct tcp_md5sig_key *key; <<
1086 struct tcp_md5sig_key tw_key; <<
1087 #endif <<
1088 <<
1089 #ifdef CONFIG_TCP_MD5SIG <<
1090 if (!tw && skb->sk) { <<
1091 key = tcp_v6_md5_do_lookup(sk <<
1092 } else if (tw && tw->tw_md5_keylen) { <<
1093 tw_key.key = tw->tw_md5_key; <<
1094 tw_key.keylen = tw->tw_md5_ke <<
1095 key = &tw_key; <<
1096 } else { <<
1097 key = NULL; <<
1098 } <<
1099 #endif <<
1100 1070
1101 if (ts) 1071 if (ts)
1102 tot_len += TCPOLEN_TSTAMP_ALI !! 1072 tot_len += 3*4;
1103 #ifdef CONFIG_TCP_MD5SIG <<
1104 if (key) <<
1105 tot_len += TCPOLEN_MD5SIG_ALI <<
1106 #endif <<
1107 1073
1108 buff = alloc_skb(MAX_HEADER + sizeof( 1074 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
1109 GFP_ATOMIC); 1075 GFP_ATOMIC);
1110 if (buff == NULL) 1076 if (buff == NULL)
1111 return; 1077 return;
1112 1078
1113 skb_reserve(buff, MAX_HEADER + sizeof 1079 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
1114 1080
1115 t1 = (struct tcphdr *) skb_push(buff, 1081 t1 = (struct tcphdr *) skb_push(buff,tot_len);
1116 1082
1117 /* Swap the send and the receive. */ 1083 /* Swap the send and the receive. */
1118 memset(t1, 0, sizeof(*t1)); 1084 memset(t1, 0, sizeof(*t1));
1119 t1->dest = th->source; 1085 t1->dest = th->source;
1120 t1->source = th->dest; 1086 t1->source = th->dest;
1121 t1->doff = tot_len/4; 1087 t1->doff = tot_len/4;
1122 t1->seq = htonl(seq); 1088 t1->seq = htonl(seq);
1123 t1->ack_seq = htonl(ack); 1089 t1->ack_seq = htonl(ack);
1124 t1->ack = 1; 1090 t1->ack = 1;
1125 t1->window = htons(win); 1091 t1->window = htons(win);
1126 !! 1092
1127 topt = (__be32 *)(t1 + 1); <<
1128 <<
1129 if (ts) { 1093 if (ts) {
1130 *topt++ = htonl((TCPOPT_NOP < !! 1094 u32 *ptr = (u32*)(t1 + 1);
1131 (TCPOPT_TIMES !! 1095 *ptr++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1132 *topt++ = htonl(tcp_time_stam !! 1096 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1133 *topt = htonl(ts); !! 1097 *ptr++ = htonl(tcp_time_stamp);
>> 1098 *ptr = htonl(ts);
1134 } 1099 }
1135 1100
1136 #ifdef CONFIG_TCP_MD5SIG <<
1137 if (key) { <<
1138 *topt++ = htonl((TCPOPT_NOP < <<
1139 (TCPOPT_MD5SI <<
1140 tcp_v6_do_calc_md5_hash((__u8 <<
1141 &ipv6 <<
1142 &ipv6 <<
1143 t1, I <<
1144 } <<
1145 #endif <<
1146 <<
1147 buff->csum = csum_partial((char *)t1, 1101 buff->csum = csum_partial((char *)t1, tot_len, 0);
1148 1102
1149 memset(&fl, 0, sizeof(fl)); 1103 memset(&fl, 0, sizeof(fl));
1150 ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr !! 1104 ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
1151 ipv6_addr_copy(&fl.fl6_src, &ipv6_hdr !! 1105 ipv6_addr_copy(&fl.fl6_src, &skb->nh.ipv6h->daddr);
1152 1106
1153 t1->check = csum_ipv6_magic(&fl.fl6_s 1107 t1->check = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst,
1154 tot_len, 1108 tot_len, IPPROTO_TCP,
1155 buff->csu 1109 buff->csum);
1156 1110
1157 fl.proto = IPPROTO_TCP; 1111 fl.proto = IPPROTO_TCP;
1158 fl.oif = inet6_iif(skb); !! 1112 fl.oif = tcp_v6_iif(skb);
1159 fl.fl_ip_dport = t1->dest; 1113 fl.fl_ip_dport = t1->dest;
1160 fl.fl_ip_sport = t1->source; 1114 fl.fl_ip_sport = t1->source;
1161 security_skb_classify_flow(skb, &fl); <<
1162 1115
1163 if (!ip6_dst_lookup(NULL, &buff->dst, 1116 if (!ip6_dst_lookup(NULL, &buff->dst, &fl)) {
1164 if (xfrm_lookup(&buff->dst, & !! 1117 if ((xfrm_lookup(&buff->dst, &fl, NULL, 0)) < 0) {
1165 ip6_xmit(tcp6_socket- !! 1118 dst_release(buff->dst);
1166 TCP_INC_STATS_BH(TCP_ <<
1167 return; 1119 return;
1168 } 1120 }
>> 1121 ip6_xmit(NULL, buff, &fl, NULL, 0);
>> 1122 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
>> 1123 return;
1169 } 1124 }
1170 1125
1171 kfree_skb(buff); 1126 kfree_skb(buff);
1172 } 1127 }
1173 1128
1174 static void tcp_v6_timewait_ack(struct sock * 1129 static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
1175 { 1130 {
1176 struct inet_timewait_sock *tw = inet_ !! 1131 struct tcp_tw_bucket *tw = (struct tcp_tw_bucket *)sk;
1177 struct tcp_timewait_sock *tcptw = tcp <<
1178 1132
1179 tcp_v6_send_ack(tcptw, skb, tcptw->tw !! 1133 tcp_v6_send_ack(skb, tw->tw_snd_nxt, tw->tw_rcv_nxt,
1180 tcptw->tw_rcv_wnd >> !! 1134 tw->tw_rcv_wnd >> tw->tw_rcv_wscale, tw->tw_ts_recent);
1181 tcptw->tw_ts_recent); <<
1182 1135
1183 inet_twsk_put(tw); !! 1136 tcp_tw_put(tw);
1184 } 1137 }
1185 1138
1186 static void tcp_v6_reqsk_send_ack(struct sk_b !! 1139 static void tcp_v6_or_send_ack(struct sk_buff *skb, struct open_request *req)
1187 { 1140 {
1188 tcp_v6_send_ack(NULL, skb, tcp_rsk(re !! 1141 tcp_v6_send_ack(skb, req->snt_isn+1, req->rcv_isn+1, req->rcv_wnd, req->ts_recent);
1189 } 1142 }
1190 1143
1191 1144
1192 static struct sock *tcp_v6_hnd_req(struct soc 1145 static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
1193 { 1146 {
1194 struct request_sock *req, **prev; !! 1147 struct open_request *req, **prev;
1195 const struct tcphdr *th = tcp_hdr(skb !! 1148 struct tcphdr *th = skb->h.th;
>> 1149 struct tcp_sock *tp = tcp_sk(sk);
1196 struct sock *nsk; 1150 struct sock *nsk;
1197 1151
1198 /* Find possible connection requests. 1152 /* Find possible connection requests. */
1199 req = inet6_csk_search_req(sk, &prev, !! 1153 req = tcp_v6_search_req(tp, &prev, th->source, &skb->nh.ipv6h->saddr,
1200 &ipv6_hdr( !! 1154 &skb->nh.ipv6h->daddr, tcp_v6_iif(skb));
1201 &ipv6_hdr( <<
1202 if (req) 1155 if (req)
1203 return tcp_check_req(sk, skb, 1156 return tcp_check_req(sk, skb, req, prev);
1204 1157
1205 nsk = __inet6_lookup_established(sk-> !! 1158 nsk = __tcp_v6_lookup_established(&skb->nh.ipv6h->saddr,
1206 &ipv6_hdr(skb)->saddr !! 1159 th->source,
1207 &ipv6_hdr(skb)->daddr !! 1160 &skb->nh.ipv6h->daddr,
>> 1161 ntohs(th->dest),
>> 1162 tcp_v6_iif(skb));
1208 1163
1209 if (nsk) { 1164 if (nsk) {
1210 if (nsk->sk_state != TCP_TIME 1165 if (nsk->sk_state != TCP_TIME_WAIT) {
1211 bh_lock_sock(nsk); 1166 bh_lock_sock(nsk);
1212 return nsk; 1167 return nsk;
1213 } 1168 }
1214 inet_twsk_put(inet_twsk(nsk)) !! 1169 tcp_tw_put((struct tcp_tw_bucket*)nsk);
1215 return NULL; 1170 return NULL;
1216 } 1171 }
1217 1172
1218 #if 0 /*def CONFIG_SYN_COOKIES*/ 1173 #if 0 /*def CONFIG_SYN_COOKIES*/
1219 if (!th->rst && !th->syn && th->ack) 1174 if (!th->rst && !th->syn && th->ack)
1220 sk = cookie_v6_check(sk, skb, 1175 sk = cookie_v6_check(sk, skb, &(IPCB(skb)->opt));
1221 #endif 1176 #endif
1222 return sk; 1177 return sk;
1223 } 1178 }
1224 1179
>> 1180 static void tcp_v6_synq_add(struct sock *sk, struct open_request *req)
>> 1181 {
>> 1182 struct tcp_sock *tp = tcp_sk(sk);
>> 1183 struct tcp_listen_opt *lopt = tp->listen_opt;
>> 1184 u32 h = tcp_v6_synq_hash(&req->af.v6_req.rmt_addr, req->rmt_port, lopt->hash_rnd);
>> 1185
>> 1186 req->sk = NULL;
>> 1187 req->expires = jiffies + TCP_TIMEOUT_INIT;
>> 1188 req->retrans = 0;
>> 1189 req->dl_next = lopt->syn_table[h];
>> 1190
>> 1191 write_lock(&tp->syn_wait_lock);
>> 1192 lopt->syn_table[h] = req;
>> 1193 write_unlock(&tp->syn_wait_lock);
>> 1194
>> 1195 tcp_synq_added(sk);
>> 1196 }
>> 1197
>> 1198
1225 /* FIXME: this is substantially similar to th 1199 /* FIXME: this is substantially similar to the ipv4 code.
1226 * Can some kind of merge be done? -- erics 1200 * Can some kind of merge be done? -- erics
1227 */ 1201 */
1228 static int tcp_v6_conn_request(struct sock *s 1202 static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1229 { 1203 {
1230 struct inet6_request_sock *treq; <<
1231 struct ipv6_pinfo *np = inet6_sk(sk); 1204 struct ipv6_pinfo *np = inet6_sk(sk);
1232 struct tcp_options_received tmp_opt; 1205 struct tcp_options_received tmp_opt;
1233 struct tcp_sock *tp = tcp_sk(sk); 1206 struct tcp_sock *tp = tcp_sk(sk);
1234 struct request_sock *req = NULL; !! 1207 struct open_request *req = NULL;
1235 __u32 isn = TCP_SKB_CB(skb)->when; 1208 __u32 isn = TCP_SKB_CB(skb)->when;
1236 1209
1237 if (skb->protocol == htons(ETH_P_IP)) 1210 if (skb->protocol == htons(ETH_P_IP))
1238 return tcp_v4_conn_request(sk 1211 return tcp_v4_conn_request(sk, skb);
1239 1212
1240 if (!ipv6_unicast_destination(skb)) 1213 if (!ipv6_unicast_destination(skb))
1241 goto drop; !! 1214 goto drop;
1242 1215
1243 /* 1216 /*
1244 * There are no SYN attacks on I !! 1217 * There are no SYN attacks on IPv6, yet...
1245 */ 1218 */
1246 if (inet_csk_reqsk_queue_is_full(sk) !! 1219 if (tcp_synq_is_full(sk) && !isn) {
1247 if (net_ratelimit()) 1220 if (net_ratelimit())
1248 printk(KERN_INFO "TCP 1221 printk(KERN_INFO "TCPv6: dropping request, synflood is possible\n");
1249 goto drop; !! 1222 goto drop;
1250 } 1223 }
1251 1224
1252 if (sk_acceptq_is_full(sk) && inet_cs !! 1225 if (sk_acceptq_is_full(sk) && tcp_synq_young(sk) > 1)
1253 goto drop; 1226 goto drop;
1254 1227
1255 req = inet6_reqsk_alloc(&tcp6_request !! 1228 req = tcp_openreq_alloc();
1256 if (req == NULL) 1229 if (req == NULL)
1257 goto drop; 1230 goto drop;
1258 1231
1259 #ifdef CONFIG_TCP_MD5SIG <<
1260 tcp_rsk(req)->af_specific = &tcp_requ <<
1261 #endif <<
1262 <<
1263 tcp_clear_options(&tmp_opt); 1232 tcp_clear_options(&tmp_opt);
1264 tmp_opt.mss_clamp = IPV6_MIN_MTU - si 1233 tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
1265 tmp_opt.user_mss = tp->rx_opt.user_ms 1234 tmp_opt.user_mss = tp->rx_opt.user_mss;
1266 1235
1267 tcp_parse_options(skb, &tmp_opt, 0); 1236 tcp_parse_options(skb, &tmp_opt, 0);
1268 1237
1269 tmp_opt.tstamp_ok = tmp_opt.saw_tstam 1238 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1270 tcp_openreq_init(req, &tmp_opt, skb); 1239 tcp_openreq_init(req, &tmp_opt, skb);
1271 1240
1272 treq = inet6_rsk(req); !! 1241 req->class = &or_ipv6;
1273 ipv6_addr_copy(&treq->rmt_addr, &ipv6 !! 1242 ipv6_addr_copy(&req->af.v6_req.rmt_addr, &skb->nh.ipv6h->saddr);
1274 ipv6_addr_copy(&treq->loc_addr, &ipv6 !! 1243 ipv6_addr_copy(&req->af.v6_req.loc_addr, &skb->nh.ipv6h->daddr);
1275 TCP_ECN_create_request(req, tcp_hdr(s !! 1244 TCP_ECN_create_request(req, skb->h.th);
1276 treq->pktopts = NULL; !! 1245 req->af.v6_req.pktopts = NULL;
1277 if (ipv6_opt_accepted(sk, skb) || 1246 if (ipv6_opt_accepted(sk, skb) ||
1278 np->rxopt.bits.rxinfo || np->rxop !! 1247 np->rxopt.bits.rxinfo ||
1279 np->rxopt.bits.rxhlim || np->rxop !! 1248 np->rxopt.bits.rxhlim) {
1280 atomic_inc(&skb->users); 1249 atomic_inc(&skb->users);
1281 treq->pktopts = skb; !! 1250 req->af.v6_req.pktopts = skb;
1282 } 1251 }
1283 treq->iif = sk->sk_bound_dev_if; !! 1252 req->af.v6_req.iif = sk->sk_bound_dev_if;
1284 1253
1285 /* So that link locals have meaning * 1254 /* So that link locals have meaning */
1286 if (!sk->sk_bound_dev_if && 1255 if (!sk->sk_bound_dev_if &&
1287 ipv6_addr_type(&treq->rmt_addr) & !! 1256 ipv6_addr_type(&req->af.v6_req.rmt_addr) & IPV6_ADDR_LINKLOCAL)
1288 treq->iif = inet6_iif(skb); !! 1257 req->af.v6_req.iif = tcp_v6_iif(skb);
1289 <<
1290 if (isn == 0) <<
1291 isn = tcp_v6_init_sequence(sk <<
1292 1258
1293 tcp_rsk(req)->snt_isn = isn; !! 1259 if (isn == 0)
>> 1260 isn = tcp_v6_init_sequence(sk,skb);
1294 1261
1295 security_inet_conn_request(sk, skb, r !! 1262 req->snt_isn = isn;
1296 1263
1297 if (tcp_v6_send_synack(sk, req, NULL) 1264 if (tcp_v6_send_synack(sk, req, NULL))
1298 goto drop; 1265 goto drop;
1299 1266
1300 inet6_csk_reqsk_queue_hash_add(sk, re !! 1267 tcp_v6_synq_add(sk, req);
>> 1268
1301 return 0; 1269 return 0;
1302 1270
1303 drop: 1271 drop:
1304 if (req) 1272 if (req)
1305 reqsk_free(req); !! 1273 tcp_openreq_free(req);
1306 1274
>> 1275 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
1307 return 0; /* don't send reset */ 1276 return 0; /* don't send reset */
1308 } 1277 }
1309 1278
1310 static struct sock * tcp_v6_syn_recv_sock(str 1279 static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1311 str !! 1280 struct open_request *req,
1312 str 1281 struct dst_entry *dst)
1313 { 1282 {
1314 struct inet6_request_sock *treq = ine <<
1315 struct ipv6_pinfo *newnp, *np = inet6 1283 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1316 struct tcp6_sock *newtcp6sk; 1284 struct tcp6_sock *newtcp6sk;
1317 struct inet_sock *newinet; 1285 struct inet_sock *newinet;
1318 struct tcp_sock *newtp; 1286 struct tcp_sock *newtp;
1319 struct sock *newsk; 1287 struct sock *newsk;
1320 struct ipv6_txoptions *opt; 1288 struct ipv6_txoptions *opt;
1321 #ifdef CONFIG_TCP_MD5SIG <<
1322 struct tcp_md5sig_key *key; <<
1323 #endif <<
1324 1289
1325 if (skb->protocol == htons(ETH_P_IP)) 1290 if (skb->protocol == htons(ETH_P_IP)) {
1326 /* 1291 /*
1327 * v6 mapped 1292 * v6 mapped
1328 */ 1293 */
1329 1294
1330 newsk = tcp_v4_syn_recv_sock( 1295 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1331 1296
1332 if (newsk == NULL) !! 1297 if (newsk == NULL)
1333 return NULL; 1298 return NULL;
1334 1299
1335 newtcp6sk = (struct tcp6_sock 1300 newtcp6sk = (struct tcp6_sock *)newsk;
1336 inet_sk(newsk)->pinet6 = &new 1301 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1337 1302
1338 newinet = inet_sk(newsk); 1303 newinet = inet_sk(newsk);
1339 newnp = inet6_sk(newsk); 1304 newnp = inet6_sk(newsk);
1340 newtp = tcp_sk(newsk); 1305 newtp = tcp_sk(newsk);
1341 1306
1342 memcpy(newnp, np, sizeof(stru 1307 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1343 1308
1344 ipv6_addr_set(&newnp->daddr, 1309 ipv6_addr_set(&newnp->daddr, 0, 0, htonl(0x0000FFFF),
1345 newinet->daddr) 1310 newinet->daddr);
1346 1311
1347 ipv6_addr_set(&newnp->saddr, 1312 ipv6_addr_set(&newnp->saddr, 0, 0, htonl(0x0000FFFF),
1348 newinet->saddr) 1313 newinet->saddr);
1349 1314
1350 ipv6_addr_copy(&newnp->rcv_sa 1315 ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);
1351 1316
1352 inet_csk(newsk)->icsk_af_ops !! 1317 newtp->af_specific = &ipv6_mapped;
1353 newsk->sk_backlog_rcv = tcp_v 1318 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
1354 #ifdef CONFIG_TCP_MD5SIG <<
1355 newtp->af_specific = &tcp_soc <<
1356 #endif <<
1357 <<
1358 newnp->pktoptions = NULL; 1319 newnp->pktoptions = NULL;
1359 newnp->opt = NULL; 1320 newnp->opt = NULL;
1360 newnp->mcast_oif = inet6_ii !! 1321 newnp->mcast_oif = tcp_v6_iif(skb);
1361 newnp->mcast_hops = ipv6_hdr !! 1322 newnp->mcast_hops = skb->nh.ipv6h->hop_limit;
1362 1323
1363 /* !! 1324 /* Charge newly allocated IPv6 socket. Though it is mapped,
1364 * No need to charge this soc !! 1325 * it is IPv6 yet.
1365 * here, tcp_create_openreq_c <<
1366 * that function for the gory <<
1367 */ 1326 */
>> 1327 #ifdef INET_REFCNT_DEBUG
>> 1328 atomic_inc(&inet6_sock_nr);
>> 1329 #endif
1368 1330
1369 /* It is tricky place. Until 1331 /* It is tricky place. Until this moment IPv4 tcp
1370 worked with IPv6 icsk.icsk !! 1332 worked with IPv6 af_tcp.af_specific.
1371 Sync it now. 1333 Sync it now.
1372 */ 1334 */
1373 tcp_sync_mss(newsk, inet_csk( !! 1335 tcp_sync_mss(newsk, newtp->pmtu_cookie);
1374 1336
1375 return newsk; 1337 return newsk;
1376 } 1338 }
1377 1339
1378 opt = np->opt; 1340 opt = np->opt;
1379 1341
1380 if (sk_acceptq_is_full(sk)) 1342 if (sk_acceptq_is_full(sk))
1381 goto out_overflow; 1343 goto out_overflow;
1382 1344
>> 1345 if (np->rxopt.bits.srcrt == 2 &&
>> 1346 opt == NULL && req->af.v6_req.pktopts) {
>> 1347 struct inet6_skb_parm *rxopt = IP6CB(req->af.v6_req.pktopts);
>> 1348 if (rxopt->srcrt)
>> 1349 opt = ipv6_invert_rthdr(sk, (struct ipv6_rt_hdr*)(req->af.v6_req.pktopts->nh.raw+rxopt->srcrt));
>> 1350 }
>> 1351
1383 if (dst == NULL) { 1352 if (dst == NULL) {
1384 struct in6_addr *final_p = NU 1353 struct in6_addr *final_p = NULL, final;
1385 struct flowi fl; 1354 struct flowi fl;
1386 1355
1387 memset(&fl, 0, sizeof(fl)); 1356 memset(&fl, 0, sizeof(fl));
1388 fl.proto = IPPROTO_TCP; 1357 fl.proto = IPPROTO_TCP;
1389 ipv6_addr_copy(&fl.fl6_dst, & !! 1358 ipv6_addr_copy(&fl.fl6_dst, &req->af.v6_req.rmt_addr);
1390 if (opt && opt->srcrt) { 1359 if (opt && opt->srcrt) {
1391 struct rt0_hdr *rt0 = 1360 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
1392 ipv6_addr_copy(&final 1361 ipv6_addr_copy(&final, &fl.fl6_dst);
1393 ipv6_addr_copy(&fl.fl 1362 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
1394 final_p = &final; 1363 final_p = &final;
1395 } 1364 }
1396 ipv6_addr_copy(&fl.fl6_src, & !! 1365 ipv6_addr_copy(&fl.fl6_src, &req->af.v6_req.loc_addr);
1397 fl.oif = sk->sk_bound_dev_if; 1366 fl.oif = sk->sk_bound_dev_if;
1398 fl.fl_ip_dport = inet_rsk(req !! 1367 fl.fl_ip_dport = req->rmt_port;
1399 fl.fl_ip_sport = inet_sk(sk)- 1368 fl.fl_ip_sport = inet_sk(sk)->sport;
1400 security_req_classify_flow(re <<
1401 1369
1402 if (ip6_dst_lookup(sk, &dst, 1370 if (ip6_dst_lookup(sk, &dst, &fl))
1403 goto out; 1371 goto out;
1404 1372
1405 if (final_p) 1373 if (final_p)
1406 ipv6_addr_copy(&fl.fl 1374 ipv6_addr_copy(&fl.fl6_dst, final_p);
1407 1375
1408 if ((xfrm_lookup(&dst, &fl, s 1376 if ((xfrm_lookup(&dst, &fl, sk, 0)) < 0)
1409 goto out; 1377 goto out;
1410 } !! 1378 }
1411 1379
1412 newsk = tcp_create_openreq_child(sk, 1380 newsk = tcp_create_openreq_child(sk, req, skb);
1413 if (newsk == NULL) 1381 if (newsk == NULL)
1414 goto out; 1382 goto out;
1415 1383
1416 /* !! 1384 /* Charge newly allocated IPv6 socket */
1417 * No need to charge this sock to the !! 1385 #ifdef INET_REFCNT_DEBUG
1418 * count here, tcp_create_openreq_chi !! 1386 atomic_inc(&inet6_sock_nr);
1419 * comment in that function for the g !! 1387 #endif
1420 */ <<
1421 1388
1422 newsk->sk_gso_type = SKB_GSO_TCPV6; !! 1389 ip6_dst_store(newsk, dst, NULL);
1423 __ip6_dst_store(newsk, dst, NULL, NUL !! 1390 newsk->sk_route_caps = dst->dev->features &
>> 1391 ~(NETIF_F_IP_CSUM | NETIF_F_TSO);
1424 1392
1425 newtcp6sk = (struct tcp6_sock *)newsk 1393 newtcp6sk = (struct tcp6_sock *)newsk;
1426 inet_sk(newsk)->pinet6 = &newtcp6sk-> 1394 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1427 1395
1428 newtp = tcp_sk(newsk); 1396 newtp = tcp_sk(newsk);
1429 newinet = inet_sk(newsk); 1397 newinet = inet_sk(newsk);
1430 newnp = inet6_sk(newsk); 1398 newnp = inet6_sk(newsk);
1431 1399
1432 memcpy(newnp, np, sizeof(struct ipv6_ 1400 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1433 1401
1434 ipv6_addr_copy(&newnp->daddr, &treq-> !! 1402 ipv6_addr_copy(&newnp->daddr, &req->af.v6_req.rmt_addr);
1435 ipv6_addr_copy(&newnp->saddr, &treq-> !! 1403 ipv6_addr_copy(&newnp->saddr, &req->af.v6_req.loc_addr);
1436 ipv6_addr_copy(&newnp->rcv_saddr, &tr !! 1404 ipv6_addr_copy(&newnp->rcv_saddr, &req->af.v6_req.loc_addr);
1437 newsk->sk_bound_dev_if = treq->iif; !! 1405 newsk->sk_bound_dev_if = req->af.v6_req.iif;
1438 1406
1439 /* Now IPv6 options... !! 1407 /* Now IPv6 options...
1440 1408
1441 First: no IPv4 options. 1409 First: no IPv4 options.
1442 */ 1410 */
1443 newinet->opt = NULL; 1411 newinet->opt = NULL;
1444 newnp->ipv6_fl_list = NULL; <<
1445 1412
1446 /* Clone RX bits */ 1413 /* Clone RX bits */
1447 newnp->rxopt.all = np->rxopt.all; 1414 newnp->rxopt.all = np->rxopt.all;
1448 1415
1449 /* Clone pktoptions received with SYN 1416 /* Clone pktoptions received with SYN */
1450 newnp->pktoptions = NULL; 1417 newnp->pktoptions = NULL;
1451 if (treq->pktopts != NULL) { !! 1418 if (req->af.v6_req.pktopts) {
1452 newnp->pktoptions = skb_clone !! 1419 newnp->pktoptions = skb_clone(req->af.v6_req.pktopts,
1453 kfree_skb(treq->pktopts); !! 1420 GFP_ATOMIC);
1454 treq->pktopts = NULL; !! 1421 kfree_skb(req->af.v6_req.pktopts);
>> 1422 req->af.v6_req.pktopts = NULL;
1455 if (newnp->pktoptions) 1423 if (newnp->pktoptions)
1456 skb_set_owner_r(newnp 1424 skb_set_owner_r(newnp->pktoptions, newsk);
1457 } 1425 }
1458 newnp->opt = NULL; 1426 newnp->opt = NULL;
1459 newnp->mcast_oif = inet6_iif(skb); !! 1427 newnp->mcast_oif = tcp_v6_iif(skb);
1460 newnp->mcast_hops = ipv6_hdr(skb)->ho !! 1428 newnp->mcast_hops = skb->nh.ipv6h->hop_limit;
1461 1429
1462 /* Clone native IPv6 options from lis 1430 /* Clone native IPv6 options from listening socket (if any)
1463 1431
1464 Yes, keeping reference count would 1432 Yes, keeping reference count would be much more clever,
1465 but we make one more one thing the 1433 but we make one more one thing there: reattach optmem
1466 to newsk. 1434 to newsk.
1467 */ 1435 */
1468 if (opt) { 1436 if (opt) {
1469 newnp->opt = ipv6_dup_options 1437 newnp->opt = ipv6_dup_options(newsk, opt);
1470 if (opt != np->opt) 1438 if (opt != np->opt)
1471 sock_kfree_s(sk, opt, 1439 sock_kfree_s(sk, opt, opt->tot_len);
1472 } 1440 }
1473 1441
1474 inet_csk(newsk)->icsk_ext_hdr_len = 0 !! 1442 newtp->ext_header_len = 0;
1475 if (newnp->opt) 1443 if (newnp->opt)
1476 inet_csk(newsk)->icsk_ext_hdr !! 1444 newtp->ext_header_len = newnp->opt->opt_nflen +
1477 !! 1445 newnp->opt->opt_flen;
>> 1446 newtp->ext2_header_len = dst->header_len;
1478 1447
1479 tcp_mtup_init(newsk); !! 1448 tcp_sync_mss(newsk, dst_pmtu(dst));
1480 tcp_sync_mss(newsk, dst_mtu(dst)); <<
1481 newtp->advmss = dst_metric(dst, RTAX_ 1449 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
1482 tcp_initialize_rcv_mss(newsk); 1450 tcp_initialize_rcv_mss(newsk);
1483 1451
1484 newinet->daddr = newinet->saddr = new 1452 newinet->daddr = newinet->saddr = newinet->rcv_saddr = LOOPBACK4_IPV6;
1485 1453
1486 #ifdef CONFIG_TCP_MD5SIG !! 1454 __tcp_v6_hash(newsk);
1487 /* Copy over the MD5 key from the ori !! 1455 tcp_inherit_port(sk, newsk);
1488 if ((key = tcp_v6_md5_do_lookup(sk, & <<
1489 /* We're using one, so create <<
1490 * on the newsk structure. If <<
1491 * memory, then we end up not <<
1492 * across. Shucks. <<
1493 */ <<
1494 char *newkey = kmemdup(key->k <<
1495 if (newkey != NULL) <<
1496 tcp_v6_md5_do_add(new <<
1497 new <<
1498 } <<
1499 #endif <<
1500 <<
1501 __inet6_hash(newsk); <<
1502 inet_inherit_port(sk, newsk); <<
1503 1456
1504 return newsk; 1457 return newsk;
1505 1458
1506 out_overflow: 1459 out_overflow:
1507 NET_INC_STATS_BH(LINUX_MIB_LISTENOVER 1460 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
1508 out: 1461 out:
1509 NET_INC_STATS_BH(LINUX_MIB_LISTENDROP 1462 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
1510 if (opt && opt != np->opt) 1463 if (opt && opt != np->opt)
1511 sock_kfree_s(sk, opt, opt->to 1464 sock_kfree_s(sk, opt, opt->tot_len);
1512 dst_release(dst); 1465 dst_release(dst);
1513 return NULL; 1466 return NULL;
1514 } 1467 }
1515 1468
1516 static __sum16 tcp_v6_checksum_init(struct sk !! 1469 static int tcp_v6_checksum_init(struct sk_buff *skb)
1517 { 1470 {
1518 if (skb->ip_summed == CHECKSUM_COMPLE !! 1471 if (skb->ip_summed == CHECKSUM_HW) {
1519 if (!tcp_v6_check(tcp_hdr(skb !! 1472 skb->ip_summed = CHECKSUM_UNNECESSARY;
1520 &ipv6_hdr(s !! 1473 if (!tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
1521 skb->ip_summed = CHEC !! 1474 &skb->nh.ipv6h->daddr,skb->csum))
1522 return 0; 1475 return 0;
1523 } !! 1476 LIMIT_NETDEBUG(printk(KERN_DEBUG "hw tcp v6 csum failed\n"));
1524 } 1477 }
1525 <<
1526 skb->csum = ~csum_unfold(tcp_v6_check <<
1527 <<
1528 <<
1529 <<
1530 if (skb->len <= 76) { 1478 if (skb->len <= 76) {
1531 return __skb_checksum_complet !! 1479 if (tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
>> 1480 &skb->nh.ipv6h->daddr,skb_checksum(skb, 0, skb->len, 0)))
>> 1481 return -1;
>> 1482 skb->ip_summed = CHECKSUM_UNNECESSARY;
>> 1483 } else {
>> 1484 skb->csum = ~tcp_v6_check(skb->h.th,skb->len,&skb->nh.ipv6h->saddr,
>> 1485 &skb->nh.ipv6h->daddr,0);
1532 } 1486 }
1533 return 0; 1487 return 0;
1534 } 1488 }
1535 1489
1536 /* The socket must have it's spinlock held wh 1490 /* The socket must have it's spinlock held when we get
1537 * here. 1491 * here.
1538 * 1492 *
1539 * We have a potential double-lock case here, 1493 * We have a potential double-lock case here, so even when
1540 * doing backlog processing we use the BH loc 1494 * doing backlog processing we use the BH locking scheme.
1541 * This is because we cannot sleep with the o 1495 * This is because we cannot sleep with the original spinlock
1542 * held. 1496 * held.
1543 */ 1497 */
1544 static int tcp_v6_do_rcv(struct sock *sk, str 1498 static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1545 { 1499 {
1546 struct ipv6_pinfo *np = inet6_sk(sk); 1500 struct ipv6_pinfo *np = inet6_sk(sk);
1547 struct tcp_sock *tp; 1501 struct tcp_sock *tp;
1548 struct sk_buff *opt_skb = NULL; 1502 struct sk_buff *opt_skb = NULL;
1549 1503
1550 /* Imagine: socket is IPv6. IPv4 pack 1504 /* Imagine: socket is IPv6. IPv4 packet arrives,
1551 goes to IPv4 receive handler and b 1505 goes to IPv4 receive handler and backlogged.
1552 From backlog it always goes here. 1506 From backlog it always goes here. Kerboom...
1553 Fortunately, tcp_rcv_established a 1507 Fortunately, tcp_rcv_established and rcv_established
1554 handle them correctly, but it is n 1508 handle them correctly, but it is not case with
1555 tcp_v6_hnd_req and tcp_v6_send_res 1509 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1556 */ 1510 */
1557 1511
1558 if (skb->protocol == htons(ETH_P_IP)) 1512 if (skb->protocol == htons(ETH_P_IP))
1559 return tcp_v4_do_rcv(sk, skb) 1513 return tcp_v4_do_rcv(sk, skb);
1560 1514
1561 #ifdef CONFIG_TCP_MD5SIG !! 1515 if (sk_filter(sk, skb, 0))
1562 if (tcp_v6_inbound_md5_hash (sk, skb) <<
1563 goto discard; <<
1564 #endif <<
1565 <<
1566 if (sk_filter(sk, skb)) <<
1567 goto discard; 1516 goto discard;
1568 1517
1569 /* 1518 /*
1570 * socket locking is here for SM 1519 * socket locking is here for SMP purposes as backlog rcv
1571 * is currently called with bh p 1520 * is currently called with bh processing disabled.
1572 */ 1521 */
1573 1522
1574 /* Do Stevens' IPV6_PKTOPTIONS. 1523 /* Do Stevens' IPV6_PKTOPTIONS.
1575 1524
1576 Yes, guys, it is the only place in 1525 Yes, guys, it is the only place in our code, where we
1577 may make it not affecting IPv4. 1526 may make it not affecting IPv4.
1578 The rest of code is protocol indep 1527 The rest of code is protocol independent,
1579 and I do not like idea to uglify I 1528 and I do not like idea to uglify IPv4.
1580 1529
1581 Actually, all the idea behind IPV6 1530 Actually, all the idea behind IPV6_PKTOPTIONS
1582 looks not very well thought. For n 1531 looks not very well thought. For now we latch
1583 options, received in the last pack 1532 options, received in the last packet, enqueued
1584 by tcp. Feel free to propose bette 1533 by tcp. Feel free to propose better solution.
1585 !! 1534 --ANK (980728)
1586 */ 1535 */
1587 if (np->rxopt.all) 1536 if (np->rxopt.all)
1588 opt_skb = skb_clone(skb, GFP_ 1537 opt_skb = skb_clone(skb, GFP_ATOMIC);
1589 1538
1590 if (sk->sk_state == TCP_ESTABLISHED) 1539 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1591 TCP_CHECK_TIMER(sk); 1540 TCP_CHECK_TIMER(sk);
1592 if (tcp_rcv_established(sk, s !! 1541 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len))
1593 goto reset; 1542 goto reset;
1594 TCP_CHECK_TIMER(sk); 1543 TCP_CHECK_TIMER(sk);
1595 if (opt_skb) 1544 if (opt_skb)
1596 goto ipv6_pktoptions; 1545 goto ipv6_pktoptions;
1597 return 0; 1546 return 0;
1598 } 1547 }
1599 1548
1600 if (skb->len < tcp_hdrlen(skb) || tcp !! 1549 if (skb->len < (skb->h.th->doff<<2) || tcp_checksum_complete(skb))
1601 goto csum_err; 1550 goto csum_err;
1602 1551
1603 if (sk->sk_state == TCP_LISTEN) { !! 1552 if (sk->sk_state == TCP_LISTEN) {
1604 struct sock *nsk = tcp_v6_hnd 1553 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1605 if (!nsk) 1554 if (!nsk)
1606 goto discard; 1555 goto discard;
1607 1556
1608 /* 1557 /*
1609 * Queue it on the new socket 1558 * Queue it on the new socket if the new socket is active,
1610 * otherwise we just shortcir 1559 * otherwise we just shortcircuit this and continue with
1611 * the new socket.. 1560 * the new socket..
1612 */ 1561 */
1613 if(nsk != sk) { !! 1562 if(nsk != sk) {
1614 if (tcp_child_process 1563 if (tcp_child_process(sk, nsk, skb))
1615 goto reset; 1564 goto reset;
1616 if (opt_skb) 1565 if (opt_skb)
1617 __kfree_skb(o 1566 __kfree_skb(opt_skb);
1618 return 0; 1567 return 0;
1619 } 1568 }
1620 } 1569 }
1621 1570
1622 TCP_CHECK_TIMER(sk); 1571 TCP_CHECK_TIMER(sk);
1623 if (tcp_rcv_state_process(sk, skb, tc !! 1572 if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len))
1624 goto reset; 1573 goto reset;
1625 TCP_CHECK_TIMER(sk); 1574 TCP_CHECK_TIMER(sk);
1626 if (opt_skb) 1575 if (opt_skb)
1627 goto ipv6_pktoptions; 1576 goto ipv6_pktoptions;
1628 return 0; 1577 return 0;
1629 1578
1630 reset: 1579 reset:
1631 tcp_v6_send_reset(sk, skb); !! 1580 tcp_v6_send_reset(skb);
1632 discard: 1581 discard:
1633 if (opt_skb) 1582 if (opt_skb)
1634 __kfree_skb(opt_skb); 1583 __kfree_skb(opt_skb);
1635 kfree_skb(skb); 1584 kfree_skb(skb);
1636 return 0; 1585 return 0;
1637 csum_err: 1586 csum_err:
1638 TCP_INC_STATS_BH(TCP_MIB_INERRS); 1587 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1639 goto discard; 1588 goto discard;
1640 1589
1641 1590
1642 ipv6_pktoptions: 1591 ipv6_pktoptions:
1643 /* Do you ask, what is it? 1592 /* Do you ask, what is it?
1644 1593
1645 1. skb was enqueued by tcp. 1594 1. skb was enqueued by tcp.
1646 2. skb is added to tail of read qu 1595 2. skb is added to tail of read queue, rather than out of order.
1647 3. socket is not in passive state. 1596 3. socket is not in passive state.
1648 4. Finally, it really contains opt 1597 4. Finally, it really contains options, which user wants to receive.
1649 */ 1598 */
1650 tp = tcp_sk(sk); 1599 tp = tcp_sk(sk);
1651 if (TCP_SKB_CB(opt_skb)->end_seq == t 1600 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1652 !((1 << sk->sk_state) & (TCPF_CLO 1601 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
1653 if (np->rxopt.bits.rxinfo || !! 1602 if (np->rxopt.bits.rxinfo)
1654 np->mcast_oif = inet6 !! 1603 np->mcast_oif = tcp_v6_iif(opt_skb);
1655 if (np->rxopt.bits.rxhlim || !! 1604 if (np->rxopt.bits.rxhlim)
1656 np->mcast_hops = ipv6 !! 1605 np->mcast_hops = opt_skb->nh.ipv6h->hop_limit;
1657 if (ipv6_opt_accepted(sk, opt 1606 if (ipv6_opt_accepted(sk, opt_skb)) {
1658 skb_set_owner_r(opt_s 1607 skb_set_owner_r(opt_skb, sk);
1659 opt_skb = xchg(&np->p 1608 opt_skb = xchg(&np->pktoptions, opt_skb);
1660 } else { 1609 } else {
1661 __kfree_skb(opt_skb); 1610 __kfree_skb(opt_skb);
1662 opt_skb = xchg(&np->p 1611 opt_skb = xchg(&np->pktoptions, NULL);
1663 } 1612 }
1664 } 1613 }
1665 1614
1666 if (opt_skb) 1615 if (opt_skb)
1667 kfree_skb(opt_skb); 1616 kfree_skb(opt_skb);
1668 return 0; 1617 return 0;
1669 } 1618 }
1670 1619
1671 static int tcp_v6_rcv(struct sk_buff *skb) !! 1620 static int tcp_v6_rcv(struct sk_buff **pskb, unsigned int *nhoffp)
1672 { 1621 {
1673 struct tcphdr *th; !! 1622 struct sk_buff *skb = *pskb;
>> 1623 struct tcphdr *th;
1674 struct sock *sk; 1624 struct sock *sk;
1675 int ret; 1625 int ret;
1676 1626
1677 if (skb->pkt_type != PACKET_HOST) 1627 if (skb->pkt_type != PACKET_HOST)
1678 goto discard_it; 1628 goto discard_it;
1679 1629
1680 /* 1630 /*
1681 * Count it even if it's bad. 1631 * Count it even if it's bad.
1682 */ 1632 */
1683 TCP_INC_STATS_BH(TCP_MIB_INSEGS); 1633 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1684 1634
1685 if (!pskb_may_pull(skb, sizeof(struct 1635 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1686 goto discard_it; 1636 goto discard_it;
1687 1637
1688 th = tcp_hdr(skb); !! 1638 th = skb->h.th;
1689 1639
1690 if (th->doff < sizeof(struct tcphdr)/ 1640 if (th->doff < sizeof(struct tcphdr)/4)
1691 goto bad_packet; 1641 goto bad_packet;
1692 if (!pskb_may_pull(skb, th->doff*4)) 1642 if (!pskb_may_pull(skb, th->doff*4))
1693 goto discard_it; 1643 goto discard_it;
1694 1644
1695 if (!skb_csum_unnecessary(skb) && tcp !! 1645 if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
>> 1646 tcp_v6_checksum_init(skb) < 0))
1696 goto bad_packet; 1647 goto bad_packet;
1697 1648
1698 th = tcp_hdr(skb); !! 1649 th = skb->h.th;
1699 TCP_SKB_CB(skb)->seq = ntohl(th->seq) 1650 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1700 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_C 1651 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1701 skb->len 1652 skb->len - th->doff*4);
1702 TCP_SKB_CB(skb)->ack_seq = ntohl(th-> 1653 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1703 TCP_SKB_CB(skb)->when = 0; 1654 TCP_SKB_CB(skb)->when = 0;
1704 TCP_SKB_CB(skb)->flags = ipv6_get_dsf !! 1655 TCP_SKB_CB(skb)->flags = ipv6_get_dsfield(skb->nh.ipv6h);
1705 TCP_SKB_CB(skb)->sacked = 0; 1656 TCP_SKB_CB(skb)->sacked = 0;
1706 1657
1707 sk = __inet6_lookup(skb->dev->nd_net, !! 1658 sk = __tcp_v6_lookup(&skb->nh.ipv6h->saddr, th->source,
1708 &ipv6_hdr(skb)->saddr !! 1659 &skb->nh.ipv6h->daddr, ntohs(th->dest), tcp_v6_iif(skb));
1709 &ipv6_hdr(skb)->daddr <<
1710 inet6_iif(skb)); <<
1711 1660
1712 if (!sk) 1661 if (!sk)
1713 goto no_tcp_socket; 1662 goto no_tcp_socket;
1714 1663
1715 process: 1664 process:
1716 if (sk->sk_state == TCP_TIME_WAIT) 1665 if (sk->sk_state == TCP_TIME_WAIT)
1717 goto do_time_wait; 1666 goto do_time_wait;
1718 1667
1719 if (!xfrm6_policy_check(sk, XFRM_POLI 1668 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1720 goto discard_and_relse; 1669 goto discard_and_relse;
1721 1670
1722 if (sk_filter(sk, skb)) !! 1671 if (sk_filter(sk, skb, 0))
1723 goto discard_and_relse; 1672 goto discard_and_relse;
1724 1673
1725 skb->dev = NULL; 1674 skb->dev = NULL;
1726 1675
1727 bh_lock_sock_nested(sk); !! 1676 bh_lock_sock(sk);
1728 ret = 0; 1677 ret = 0;
1729 if (!sock_owned_by_user(sk)) { 1678 if (!sock_owned_by_user(sk)) {
1730 #ifdef CONFIG_NET_DMA !! 1679 if (!tcp_prequeue(sk, skb))
1731 struct tcp_sock *tp = tcp_sk( <<
1732 if (!tp->ucopy.dma_chan && tp <<
1733 tp->ucopy.dma_chan = <<
1734 if (tp->ucopy.dma_chan) <<
1735 ret = tcp_v6_do_rcv(s 1680 ret = tcp_v6_do_rcv(sk, skb);
1736 else <<
1737 #endif <<
1738 { <<
1739 if (!tcp_prequeue(sk, <<
1740 ret = tcp_v6_ <<
1741 } <<
1742 } else 1681 } else
1743 sk_add_backlog(sk, skb); 1682 sk_add_backlog(sk, skb);
1744 bh_unlock_sock(sk); 1683 bh_unlock_sock(sk);
1745 1684
1746 sock_put(sk); 1685 sock_put(sk);
1747 return ret ? -1 : 0; 1686 return ret ? -1 : 0;
1748 1687
1749 no_tcp_socket: 1688 no_tcp_socket:
1750 if (!xfrm6_policy_check(NULL, XFRM_PO 1689 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1751 goto discard_it; 1690 goto discard_it;
1752 1691
1753 if (skb->len < (th->doff<<2) || tcp_c 1692 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1754 bad_packet: 1693 bad_packet:
1755 TCP_INC_STATS_BH(TCP_MIB_INER 1694 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1756 } else { 1695 } else {
1757 tcp_v6_send_reset(NULL, skb); !! 1696 tcp_v6_send_reset(skb);
1758 } 1697 }
1759 1698
1760 discard_it: 1699 discard_it:
1761 1700
1762 /* 1701 /*
1763 * Discard frame 1702 * Discard frame
1764 */ 1703 */
1765 1704
1766 kfree_skb(skb); 1705 kfree_skb(skb);
1767 return 0; 1706 return 0;
1768 1707
1769 discard_and_relse: 1708 discard_and_relse:
1770 sock_put(sk); 1709 sock_put(sk);
1771 goto discard_it; 1710 goto discard_it;
1772 1711
1773 do_time_wait: 1712 do_time_wait:
1774 if (!xfrm6_policy_check(NULL, XFRM_PO 1713 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1775 inet_twsk_put(inet_twsk(sk)); !! 1714 tcp_tw_put((struct tcp_tw_bucket *) sk);
1776 goto discard_it; 1715 goto discard_it;
1777 } 1716 }
1778 1717
1779 if (skb->len < (th->doff<<2) || tcp_c 1718 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1780 TCP_INC_STATS_BH(TCP_MIB_INER 1719 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1781 inet_twsk_put(inet_twsk(sk)); !! 1720 tcp_tw_put((struct tcp_tw_bucket *) sk);
1782 goto discard_it; 1721 goto discard_it;
1783 } 1722 }
1784 1723
1785 switch (tcp_timewait_state_process(in !! 1724 switch(tcp_timewait_state_process((struct tcp_tw_bucket *)sk,
>> 1725 skb, th, skb->len)) {
1786 case TCP_TW_SYN: 1726 case TCP_TW_SYN:
1787 { 1727 {
1788 struct sock *sk2; 1728 struct sock *sk2;
1789 1729
1790 sk2 = inet6_lookup_listener(s !! 1730 sk2 = tcp_v6_lookup_listener(&skb->nh.ipv6h->daddr, ntohs(th->dest), tcp_v6_iif(skb));
1791 & <<
1792 n <<
1793 if (sk2 != NULL) { 1731 if (sk2 != NULL) {
1794 struct inet_timewait_ !! 1732 tcp_tw_deschedule((struct tcp_tw_bucket *)sk);
1795 inet_twsk_deschedule( !! 1733 tcp_tw_put((struct tcp_tw_bucket *)sk);
1796 inet_twsk_put(tw); <<
1797 sk = sk2; 1734 sk = sk2;
1798 goto process; 1735 goto process;
1799 } 1736 }
1800 /* Fall through to ACK */ 1737 /* Fall through to ACK */
1801 } 1738 }
1802 case TCP_TW_ACK: 1739 case TCP_TW_ACK:
1803 tcp_v6_timewait_ack(sk, skb); 1740 tcp_v6_timewait_ack(sk, skb);
1804 break; 1741 break;
1805 case TCP_TW_RST: 1742 case TCP_TW_RST:
1806 goto no_tcp_socket; 1743 goto no_tcp_socket;
1807 case TCP_TW_SUCCESS:; 1744 case TCP_TW_SUCCESS:;
1808 } 1745 }
1809 goto discard_it; 1746 goto discard_it;
1810 } 1747 }
1811 1748
>> 1749 static int tcp_v6_rebuild_header(struct sock *sk)
>> 1750 {
>> 1751 int err;
>> 1752 struct dst_entry *dst;
>> 1753 struct ipv6_pinfo *np = inet6_sk(sk);
>> 1754
>> 1755 dst = __sk_dst_check(sk, np->dst_cookie);
>> 1756
>> 1757 if (dst == NULL) {
>> 1758 struct inet_sock *inet = inet_sk(sk);
>> 1759 struct in6_addr *final_p = NULL, final;
>> 1760 struct flowi fl;
>> 1761
>> 1762 memset(&fl, 0, sizeof(fl));
>> 1763 fl.proto = IPPROTO_TCP;
>> 1764 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
>> 1765 ipv6_addr_copy(&fl.fl6_src, &np->saddr);
>> 1766 fl.fl6_flowlabel = np->flow_label;
>> 1767 fl.oif = sk->sk_bound_dev_if;
>> 1768 fl.fl_ip_dport = inet->dport;
>> 1769 fl.fl_ip_sport = inet->sport;
>> 1770
>> 1771 if (np->opt && np->opt->srcrt) {
>> 1772 struct rt0_hdr *rt0 = (struct rt0_hdr *) np->opt->srcrt;
>> 1773 ipv6_addr_copy(&final, &fl.fl6_dst);
>> 1774 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
>> 1775 final_p = &final;
>> 1776 }
>> 1777
>> 1778 err = ip6_dst_lookup(sk, &dst, &fl);
>> 1779 if (err) {
>> 1780 sk->sk_route_caps = 0;
>> 1781 return err;
>> 1782 }
>> 1783 if (final_p)
>> 1784 ipv6_addr_copy(&fl.fl6_dst, final_p);
>> 1785
>> 1786 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) {
>> 1787 sk->sk_err_soft = -err;
>> 1788 dst_release(dst);
>> 1789 return err;
>> 1790 }
>> 1791
>> 1792 ip6_dst_store(sk, dst, NULL);
>> 1793 sk->sk_route_caps = dst->dev->features &
>> 1794 ~(NETIF_F_IP_CSUM | NETIF_F_TSO);
>> 1795 tcp_sk(sk)->ext2_header_len = dst->header_len;
>> 1796 }
>> 1797
>> 1798 return 0;
>> 1799 }
>> 1800
>> 1801 static int tcp_v6_xmit(struct sk_buff *skb, int ipfragok)
>> 1802 {
>> 1803 struct sock *sk = skb->sk;
>> 1804 struct inet_sock *inet = inet_sk(sk);
>> 1805 struct ipv6_pinfo *np = inet6_sk(sk);
>> 1806 struct flowi fl;
>> 1807 struct dst_entry *dst;
>> 1808 struct in6_addr *final_p = NULL, final;
>> 1809
>> 1810 memset(&fl, 0, sizeof(fl));
>> 1811 fl.proto = IPPROTO_TCP;
>> 1812 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
>> 1813 ipv6_addr_copy(&fl.fl6_src, &np->saddr);
>> 1814 fl.fl6_flowlabel = np->flow_label;
>> 1815 IP6_ECN_flow_xmit(sk, fl.fl6_flowlabel);
>> 1816 fl.oif = sk->sk_bound_dev_if;
>> 1817 fl.fl_ip_sport = inet->sport;
>> 1818 fl.fl_ip_dport = inet->dport;
>> 1819
>> 1820 if (np->opt && np->opt->srcrt) {
>> 1821 struct rt0_hdr *rt0 = (struct rt0_hdr *) np->opt->srcrt;
>> 1822 ipv6_addr_copy(&final, &fl.fl6_dst);
>> 1823 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
>> 1824 final_p = &final;
>> 1825 }
>> 1826
>> 1827 dst = __sk_dst_check(sk, np->dst_cookie);
>> 1828
>> 1829 if (dst == NULL) {
>> 1830 int err = ip6_dst_lookup(sk, &dst, &fl);
>> 1831
>> 1832 if (err) {
>> 1833 sk->sk_err_soft = -err;
>> 1834 return err;
>> 1835 }
>> 1836
>> 1837 if (final_p)
>> 1838 ipv6_addr_copy(&fl.fl6_dst, final_p);
>> 1839
>> 1840 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) {
>> 1841 sk->sk_route_caps = 0;
>> 1842 dst_release(dst);
>> 1843 return err;
>> 1844 }
>> 1845
>> 1846 ip6_dst_store(sk, dst, NULL);
>> 1847 sk->sk_route_caps = dst->dev->features &
>> 1848 ~(NETIF_F_IP_CSUM | NETIF_F_TSO);
>> 1849 tcp_sk(sk)->ext2_header_len = dst->header_len;
>> 1850 }
>> 1851
>> 1852 skb->dst = dst_clone(dst);
>> 1853
>> 1854 /* Restore final destination back after routing done */
>> 1855 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
>> 1856
>> 1857 return ip6_xmit(sk, skb, &fl, np->opt, 0);
>> 1858 }
>> 1859
>> 1860 static void v6_addr2sockaddr(struct sock *sk, struct sockaddr * uaddr)
>> 1861 {
>> 1862 struct ipv6_pinfo *np = inet6_sk(sk);
>> 1863 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) uaddr;
>> 1864
>> 1865 sin6->sin6_family = AF_INET6;
>> 1866 ipv6_addr_copy(&sin6->sin6_addr, &np->daddr);
>> 1867 sin6->sin6_port = inet_sk(sk)->dport;
>> 1868 /* We do not store received flowlabel for TCP */
>> 1869 sin6->sin6_flowinfo = 0;
>> 1870 sin6->sin6_scope_id = 0;
>> 1871 if (sk->sk_bound_dev_if &&
>> 1872 ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL)
>> 1873 sin6->sin6_scope_id = sk->sk_bound_dev_if;
>> 1874 }
>> 1875
1812 static int tcp_v6_remember_stamp(struct sock 1876 static int tcp_v6_remember_stamp(struct sock *sk)
1813 { 1877 {
1814 /* Alas, not yet... */ 1878 /* Alas, not yet... */
1815 return 0; 1879 return 0;
1816 } 1880 }
1817 1881
1818 static struct inet_connection_sock_af_ops ipv !! 1882 static struct tcp_func ipv6_specific = {
1819 .queue_xmit = inet6_csk_xmit, !! 1883 .queue_xmit = tcp_v6_xmit,
1820 .send_check = tcp_v6_send_chec !! 1884 .send_check = tcp_v6_send_check,
1821 .rebuild_header = inet6_sk_rebuild !! 1885 .rebuild_header = tcp_v6_rebuild_header,
1822 .conn_request = tcp_v6_conn_requ !! 1886 .conn_request = tcp_v6_conn_request,
1823 .syn_recv_sock = tcp_v6_syn_recv_ !! 1887 .syn_recv_sock = tcp_v6_syn_recv_sock,
1824 .remember_stamp = tcp_v6_remember_ !! 1888 .remember_stamp = tcp_v6_remember_stamp,
1825 .net_header_len = sizeof(struct ip !! 1889 .net_header_len = sizeof(struct ipv6hdr),
1826 .setsockopt = ipv6_setsockopt, !! 1890
1827 .getsockopt = ipv6_getsockopt, !! 1891 .setsockopt = ipv6_setsockopt,
1828 .addr2sockaddr = inet6_csk_addr2s !! 1892 .getsockopt = ipv6_getsockopt,
1829 .sockaddr_len = sizeof(struct so !! 1893 .addr2sockaddr = v6_addr2sockaddr,
1830 .bind_conflict = inet6_csk_bind_c !! 1894 .sockaddr_len = sizeof(struct sockaddr_in6)
1831 #ifdef CONFIG_COMPAT <<
1832 .compat_setsockopt = compat_ipv6_sets <<
1833 .compat_getsockopt = compat_ipv6_gets <<
1834 #endif <<
1835 }; <<
1836 <<
1837 #ifdef CONFIG_TCP_MD5SIG <<
1838 static struct tcp_sock_af_ops tcp_sock_ipv6_s <<
1839 .md5_lookup = tcp_v6_md5_lo <<
1840 .calc_md5_hash = tcp_v6_calc_m <<
1841 .md5_add = tcp_v6_md5_ad <<
1842 .md5_parse = tcp_v6_parse_ <<
1843 }; 1895 };
1844 #endif <<
1845 1896
1846 /* 1897 /*
1847 * TCP over IPv4 via INET6 API 1898 * TCP over IPv4 via INET6 API
1848 */ 1899 */
1849 1900
1850 static struct inet_connection_sock_af_ops ipv !! 1901 static struct tcp_func ipv6_mapped = {
1851 .queue_xmit = ip_queue_xmit, !! 1902 .queue_xmit = ip_queue_xmit,
1852 .send_check = tcp_v4_send_chec !! 1903 .send_check = tcp_v4_send_check,
1853 .rebuild_header = inet_sk_rebuild_ !! 1904 .rebuild_header = tcp_v4_rebuild_header,
1854 .conn_request = tcp_v6_conn_requ !! 1905 .conn_request = tcp_v6_conn_request,
1855 .syn_recv_sock = tcp_v6_syn_recv_ !! 1906 .syn_recv_sock = tcp_v6_syn_recv_sock,
1856 .remember_stamp = tcp_v4_remember_ !! 1907 .remember_stamp = tcp_v4_remember_stamp,
1857 .net_header_len = sizeof(struct ip !! 1908 .net_header_len = sizeof(struct iphdr),
1858 .setsockopt = ipv6_setsockopt, !! 1909
1859 .getsockopt = ipv6_getsockopt, !! 1910 .setsockopt = ipv6_setsockopt,
1860 .addr2sockaddr = inet6_csk_addr2s !! 1911 .getsockopt = ipv6_getsockopt,
1861 .sockaddr_len = sizeof(struct so !! 1912 .addr2sockaddr = v6_addr2sockaddr,
1862 .bind_conflict = inet6_csk_bind_c !! 1913 .sockaddr_len = sizeof(struct sockaddr_in6)
1863 #ifdef CONFIG_COMPAT <<
1864 .compat_setsockopt = compat_ipv6_sets <<
1865 .compat_getsockopt = compat_ipv6_gets <<
1866 #endif <<
1867 }; 1914 };
1868 1915
1869 #ifdef CONFIG_TCP_MD5SIG !! 1916
1870 static struct tcp_sock_af_ops tcp_sock_ipv6_m <<
1871 .md5_lookup = tcp_v4_md5_lo <<
1872 .calc_md5_hash = tcp_v4_calc_m <<
1873 .md5_add = tcp_v6_md5_ad <<
1874 .md5_parse = tcp_v6_parse_ <<
1875 }; <<
1876 #endif <<
1877 1917
1878 /* NOTE: A lot of things set to zero explicit 1918 /* NOTE: A lot of things set to zero explicitly by call to
1879 * sk_alloc() so need not be done here. 1919 * sk_alloc() so need not be done here.
1880 */ 1920 */
1881 static int tcp_v6_init_sock(struct sock *sk) 1921 static int tcp_v6_init_sock(struct sock *sk)
1882 { 1922 {
1883 struct inet_connection_sock *icsk = i <<
1884 struct tcp_sock *tp = tcp_sk(sk); 1923 struct tcp_sock *tp = tcp_sk(sk);
1885 1924
1886 skb_queue_head_init(&tp->out_of_order 1925 skb_queue_head_init(&tp->out_of_order_queue);
1887 tcp_init_xmit_timers(sk); 1926 tcp_init_xmit_timers(sk);
1888 tcp_prequeue_init(tp); 1927 tcp_prequeue_init(tp);
1889 1928
1890 icsk->icsk_rto = TCP_TIMEOUT_INIT; !! 1929 tp->rto = TCP_TIMEOUT_INIT;
1891 tp->mdev = TCP_TIMEOUT_INIT; 1930 tp->mdev = TCP_TIMEOUT_INIT;
1892 1931
1893 /* So many TCP implementations out th 1932 /* So many TCP implementations out there (incorrectly) count the
1894 * initial SYN frame in their delayed 1933 * initial SYN frame in their delayed-ACK and congestion control
1895 * algorithms that we must have the f 1934 * algorithms that we must have the following bandaid to talk
1896 * efficiently to them. -DaveM 1935 * efficiently to them. -DaveM
1897 */ 1936 */
1898 tp->snd_cwnd = 2; 1937 tp->snd_cwnd = 2;
1899 1938
1900 /* See draft-stevens-tcpca-spec-01 fo 1939 /* See draft-stevens-tcpca-spec-01 for discussion of the
1901 * initialization of these values. 1940 * initialization of these values.
1902 */ 1941 */
1903 tp->snd_ssthresh = 0x7fffffff; 1942 tp->snd_ssthresh = 0x7fffffff;
1904 tp->snd_cwnd_clamp = ~0; 1943 tp->snd_cwnd_clamp = ~0;
1905 tp->mss_cache = 536; !! 1944 tp->mss_cache_std = tp->mss_cache = 536;
1906 1945
1907 tp->reordering = sysctl_tcp_reorderin 1946 tp->reordering = sysctl_tcp_reordering;
1908 1947
1909 sk->sk_state = TCP_CLOSE; 1948 sk->sk_state = TCP_CLOSE;
1910 1949
1911 icsk->icsk_af_ops = &ipv6_specific; !! 1950 tp->af_specific = &ipv6_specific;
1912 icsk->icsk_ca_ops = &tcp_init_congest <<
1913 icsk->icsk_sync_mss = tcp_sync_mss; <<
1914 sk->sk_write_space = sk_stream_write_ <<
1915 sock_set_flag(sk, SOCK_USE_WRITE_QUEU <<
1916 1951
1917 #ifdef CONFIG_TCP_MD5SIG !! 1952 sk->sk_write_space = sk_stream_write_space;
1918 tp->af_specific = &tcp_sock_ipv6_spec !! 1953 sk->sk_use_write_queue = 1;
1919 #endif <<
1920 1954
1921 sk->sk_sndbuf = sysctl_tcp_wmem[1]; 1955 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1922 sk->sk_rcvbuf = sysctl_tcp_rmem[1]; 1956 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1923 1957
1924 atomic_inc(&tcp_sockets_allocated); 1958 atomic_inc(&tcp_sockets_allocated);
1925 1959
1926 return 0; 1960 return 0;
1927 } 1961 }
1928 1962
1929 static int tcp_v6_destroy_sock(struct sock *s 1963 static int tcp_v6_destroy_sock(struct sock *sk)
1930 { 1964 {
1931 #ifdef CONFIG_TCP_MD5SIG !! 1965 extern int tcp_v4_destroy_sock(struct sock *sk);
1932 /* Clean up the MD5 key list */ !! 1966
1933 if (tcp_sk(sk)->md5sig_info) <<
1934 tcp_v6_clear_md5_list(sk); <<
1935 #endif <<
1936 tcp_v4_destroy_sock(sk); 1967 tcp_v4_destroy_sock(sk);
1937 return inet6_destroy_sock(sk); 1968 return inet6_destroy_sock(sk);
1938 } 1969 }
1939 1970
1940 #ifdef CONFIG_PROC_FS <<
1941 /* Proc filesystem TCPv6 sock list dumping. * 1971 /* Proc filesystem TCPv6 sock list dumping. */
1942 static void get_openreq6(struct seq_file *seq !! 1972 static void get_openreq6(struct seq_file *seq,
1943 struct sock *sk, str !! 1973 struct sock *sk, struct open_request *req, int i, int uid)
1944 { 1974 {
>> 1975 struct in6_addr *dest, *src;
1945 int ttd = req->expires - jiffies; 1976 int ttd = req->expires - jiffies;
1946 struct in6_addr *src = &inet6_rsk(req <<
1947 struct in6_addr *dest = &inet6_rsk(re <<
1948 1977
1949 if (ttd < 0) 1978 if (ttd < 0)
1950 ttd = 0; 1979 ttd = 0;
1951 1980
>> 1981 src = &req->af.v6_req.loc_addr;
>> 1982 dest = &req->af.v6_req.rmt_addr;
1952 seq_printf(seq, 1983 seq_printf(seq,
1953 "%4d: %08X%08X%08X%08X:%04 1984 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1954 "%02X %08X:%08X %02X:%08lX 1985 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
1955 i, 1986 i,
1956 src->s6_addr32[0], src->s6 1987 src->s6_addr32[0], src->s6_addr32[1],
1957 src->s6_addr32[2], src->s6 1988 src->s6_addr32[2], src->s6_addr32[3],
1958 ntohs(inet_sk(sk)->sport), 1989 ntohs(inet_sk(sk)->sport),
1959 dest->s6_addr32[0], dest-> 1990 dest->s6_addr32[0], dest->s6_addr32[1],
1960 dest->s6_addr32[2], dest-> 1991 dest->s6_addr32[2], dest->s6_addr32[3],
1961 ntohs(inet_rsk(req)->rmt_p !! 1992 ntohs(req->rmt_port),
1962 TCP_SYN_RECV, 1993 TCP_SYN_RECV,
1963 0,0, /* could print option 1994 0,0, /* could print option size, but that is af dependent. */
1964 1, /* timers active (onl !! 1995 1, /* timers active (only the expire timer) */
1965 jiffies_to_clock_t(ttd), !! 1996 jiffies_to_clock_t(ttd),
1966 req->retrans, 1997 req->retrans,
1967 uid, 1998 uid,
1968 0, /* non standard timer !! 1999 0, /* non standard timer */
1969 0, /* open_requests have n 2000 0, /* open_requests have no inode */
1970 0, req); 2001 0, req);
1971 } 2002 }
1972 2003
1973 static void get_tcp6_sock(struct seq_file *se 2004 static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1974 { 2005 {
1975 struct in6_addr *dest, *src; 2006 struct in6_addr *dest, *src;
1976 __u16 destp, srcp; 2007 __u16 destp, srcp;
1977 int timer_active; 2008 int timer_active;
1978 unsigned long timer_expires; 2009 unsigned long timer_expires;
1979 struct inet_sock *inet = inet_sk(sp); 2010 struct inet_sock *inet = inet_sk(sp);
1980 struct tcp_sock *tp = tcp_sk(sp); 2011 struct tcp_sock *tp = tcp_sk(sp);
1981 const struct inet_connection_sock *ic <<
1982 struct ipv6_pinfo *np = inet6_sk(sp); 2012 struct ipv6_pinfo *np = inet6_sk(sp);
1983 2013
1984 dest = &np->daddr; 2014 dest = &np->daddr;
1985 src = &np->rcv_saddr; 2015 src = &np->rcv_saddr;
1986 destp = ntohs(inet->dport); 2016 destp = ntohs(inet->dport);
1987 srcp = ntohs(inet->sport); 2017 srcp = ntohs(inet->sport);
1988 !! 2018 if (tp->pending == TCP_TIME_RETRANS) {
1989 if (icsk->icsk_pending == ICSK_TIME_R <<
1990 timer_active = 1; 2019 timer_active = 1;
1991 timer_expires = icsk->icsk_ !! 2020 timer_expires = tp->timeout;
1992 } else if (icsk->icsk_pending == ICSK !! 2021 } else if (tp->pending == TCP_TIME_PROBE0) {
1993 timer_active = 4; 2022 timer_active = 4;
1994 timer_expires = icsk->icsk_ !! 2023 timer_expires = tp->timeout;
1995 } else if (timer_pending(&sp->sk_time 2024 } else if (timer_pending(&sp->sk_timer)) {
1996 timer_active = 2; 2025 timer_active = 2;
1997 timer_expires = sp->sk_time 2026 timer_expires = sp->sk_timer.expires;
1998 } else { 2027 } else {
1999 timer_active = 0; 2028 timer_active = 0;
2000 timer_expires = jiffies; 2029 timer_expires = jiffies;
2001 } 2030 }
2002 2031
2003 seq_printf(seq, 2032 seq_printf(seq,
2004 "%4d: %08X%08X%08X%08X:%04 2033 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2005 "%02X %08X:%08X %02X:%08lX 2034 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %u %u %u %u %d\n",
2006 i, 2035 i,
2007 src->s6_addr32[0], src->s6 2036 src->s6_addr32[0], src->s6_addr32[1],
2008 src->s6_addr32[2], src->s6 2037 src->s6_addr32[2], src->s6_addr32[3], srcp,
2009 dest->s6_addr32[0], dest-> 2038 dest->s6_addr32[0], dest->s6_addr32[1],
2010 dest->s6_addr32[2], dest-> 2039 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2011 sp->sk_state, !! 2040 sp->sk_state,
2012 tp->write_seq-tp->snd_una, !! 2041 tp->write_seq-tp->snd_una, tp->rcv_nxt-tp->copied_seq,
2013 (sp->sk_state == TCP_LISTE <<
2014 timer_active, 2042 timer_active,
2015 jiffies_to_clock_t(timer_e 2043 jiffies_to_clock_t(timer_expires - jiffies),
2016 icsk->icsk_retransmits, !! 2044 tp->retransmits,
2017 sock_i_uid(sp), 2045 sock_i_uid(sp),
2018 icsk->icsk_probes_out, !! 2046 tp->probes_out,
2019 sock_i_ino(sp), 2047 sock_i_ino(sp),
2020 atomic_read(&sp->sk_refcnt 2048 atomic_read(&sp->sk_refcnt), sp,
2021 icsk->icsk_rto, !! 2049 tp->rto, tp->ack.ato, (tp->ack.quick<<1)|tp->ack.pingpong,
2022 icsk->icsk_ack.ato, <<
2023 (icsk->icsk_ack.quick << 1 <<
2024 tp->snd_cwnd, tp->snd_ssth 2050 tp->snd_cwnd, tp->snd_ssthresh>=0xFFFF?-1:tp->snd_ssthresh
2025 ); 2051 );
2026 } 2052 }
2027 2053
2028 static void get_timewait6_sock(struct seq_fil !! 2054 static void get_timewait6_sock(struct seq_file *seq,
2029 struct inet_ti !! 2055 struct tcp_tw_bucket *tw, int i)
2030 { 2056 {
2031 struct in6_addr *dest, *src; 2057 struct in6_addr *dest, *src;
2032 __u16 destp, srcp; 2058 __u16 destp, srcp;
2033 struct inet6_timewait_sock *tw6 = ine <<
2034 int ttd = tw->tw_ttd - jiffies; 2059 int ttd = tw->tw_ttd - jiffies;
2035 2060
2036 if (ttd < 0) 2061 if (ttd < 0)
2037 ttd = 0; 2062 ttd = 0;
2038 2063
2039 dest = &tw6->tw_v6_daddr; !! 2064 dest = &tw->tw_v6_daddr;
2040 src = &tw6->tw_v6_rcv_saddr; !! 2065 src = &tw->tw_v6_rcv_saddr;
2041 destp = ntohs(tw->tw_dport); 2066 destp = ntohs(tw->tw_dport);
2042 srcp = ntohs(tw->tw_sport); 2067 srcp = ntohs(tw->tw_sport);
2043 2068
2044 seq_printf(seq, 2069 seq_printf(seq,
2045 "%4d: %08X%08X%08X%08X:%04 2070 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2046 "%02X %08X:%08X %02X:%08lX 2071 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
2047 i, 2072 i,
2048 src->s6_addr32[0], src->s6 2073 src->s6_addr32[0], src->s6_addr32[1],
2049 src->s6_addr32[2], src->s6 2074 src->s6_addr32[2], src->s6_addr32[3], srcp,
2050 dest->s6_addr32[0], dest-> 2075 dest->s6_addr32[0], dest->s6_addr32[1],
2051 dest->s6_addr32[2], dest-> 2076 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2052 tw->tw_substate, 0, 0, 2077 tw->tw_substate, 0, 0,
2053 3, jiffies_to_clock_t(ttd) 2078 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2054 atomic_read(&tw->tw_refcnt 2079 atomic_read(&tw->tw_refcnt), tw);
2055 } 2080 }
2056 2081
>> 2082 #ifdef CONFIG_PROC_FS
2057 static int tcp6_seq_show(struct seq_file *seq 2083 static int tcp6_seq_show(struct seq_file *seq, void *v)
2058 { 2084 {
2059 struct tcp_iter_state *st; 2085 struct tcp_iter_state *st;
2060 2086
2061 if (v == SEQ_START_TOKEN) { 2087 if (v == SEQ_START_TOKEN) {
2062 seq_puts(seq, 2088 seq_puts(seq,
2063 " sl " 2089 " sl "
2064 "local_address 2090 "local_address "
2065 "remote_address 2091 "remote_address "
2066 "st tx_queue rx_queu 2092 "st tx_queue rx_queue tr tm->when retrnsmt"
2067 " uid timeout ino 2093 " uid timeout inode\n");
2068 goto out; 2094 goto out;
2069 } 2095 }
2070 st = seq->private; 2096 st = seq->private;
2071 2097
2072 switch (st->state) { 2098 switch (st->state) {
2073 case TCP_SEQ_STATE_LISTENING: 2099 case TCP_SEQ_STATE_LISTENING:
2074 case TCP_SEQ_STATE_ESTABLISHED: 2100 case TCP_SEQ_STATE_ESTABLISHED:
2075 get_tcp6_sock(seq, v, st->num 2101 get_tcp6_sock(seq, v, st->num);
2076 break; 2102 break;
2077 case TCP_SEQ_STATE_OPENREQ: 2103 case TCP_SEQ_STATE_OPENREQ:
2078 get_openreq6(seq, st->syn_wai 2104 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
2079 break; 2105 break;
2080 case TCP_SEQ_STATE_TIME_WAIT: 2106 case TCP_SEQ_STATE_TIME_WAIT:
2081 get_timewait6_sock(seq, v, st 2107 get_timewait6_sock(seq, v, st->num);
2082 break; 2108 break;
2083 } 2109 }
2084 out: 2110 out:
2085 return 0; 2111 return 0;
2086 } 2112 }
2087 2113
2088 static struct file_operations tcp6_seq_fops; 2114 static struct file_operations tcp6_seq_fops;
2089 static struct tcp_seq_afinfo tcp6_seq_afinfo 2115 static struct tcp_seq_afinfo tcp6_seq_afinfo = {
2090 .owner = THIS_MODULE, 2116 .owner = THIS_MODULE,
2091 .name = "tcp6", 2117 .name = "tcp6",
2092 .family = AF_INET6, 2118 .family = AF_INET6,
2093 .seq_show = tcp6_seq_show, 2119 .seq_show = tcp6_seq_show,
2094 .seq_fops = &tcp6_seq_fops, 2120 .seq_fops = &tcp6_seq_fops,
2095 }; 2121 };
2096 2122
2097 int __init tcp6_proc_init(void) 2123 int __init tcp6_proc_init(void)
2098 { 2124 {
2099 return tcp_proc_register(&tcp6_seq_af 2125 return tcp_proc_register(&tcp6_seq_afinfo);
2100 } 2126 }
2101 2127
2102 void tcp6_proc_exit(void) 2128 void tcp6_proc_exit(void)
2103 { 2129 {
2104 tcp_proc_unregister(&tcp6_seq_afinfo) 2130 tcp_proc_unregister(&tcp6_seq_afinfo);
2105 } 2131 }
2106 #endif 2132 #endif
2107 2133
2108 DEFINE_PROTO_INUSE(tcpv6) <<
2109 <<
2110 struct proto tcpv6_prot = { 2134 struct proto tcpv6_prot = {
2111 .name = "TCPv6", 2135 .name = "TCPv6",
2112 .owner = THIS_MODULE 2136 .owner = THIS_MODULE,
2113 .close = tcp_close, 2137 .close = tcp_close,
2114 .connect = tcp_v6_conn 2138 .connect = tcp_v6_connect,
2115 .disconnect = tcp_disconn 2139 .disconnect = tcp_disconnect,
2116 .accept = inet_csk_ac !! 2140 .accept = tcp_accept,
2117 .ioctl = tcp_ioctl, 2141 .ioctl = tcp_ioctl,
2118 .init = tcp_v6_init 2142 .init = tcp_v6_init_sock,
2119 .destroy = tcp_v6_dest 2143 .destroy = tcp_v6_destroy_sock,
2120 .shutdown = tcp_shutdow 2144 .shutdown = tcp_shutdown,
2121 .setsockopt = tcp_setsock 2145 .setsockopt = tcp_setsockopt,
2122 .getsockopt = tcp_getsock 2146 .getsockopt = tcp_getsockopt,
>> 2147 .sendmsg = tcp_sendmsg,
2123 .recvmsg = tcp_recvmsg 2148 .recvmsg = tcp_recvmsg,
2124 .backlog_rcv = tcp_v6_do_r 2149 .backlog_rcv = tcp_v6_do_rcv,
2125 .hash = tcp_v6_hash 2150 .hash = tcp_v6_hash,
2126 .unhash = inet_unhash !! 2151 .unhash = tcp_unhash,
2127 .get_port = inet_csk_ge !! 2152 .get_port = tcp_v6_get_port,
2128 .enter_memory_pressure = tcp_enter_m 2153 .enter_memory_pressure = tcp_enter_memory_pressure,
2129 .sockets_allocated = &tcp_socket 2154 .sockets_allocated = &tcp_sockets_allocated,
2130 .memory_allocated = &tcp_memory 2155 .memory_allocated = &tcp_memory_allocated,
2131 .memory_pressure = &tcp_memory 2156 .memory_pressure = &tcp_memory_pressure,
2132 .orphan_count = &tcp_orphan <<
2133 .sysctl_mem = sysctl_tcp_ 2157 .sysctl_mem = sysctl_tcp_mem,
2134 .sysctl_wmem = sysctl_tcp_ 2158 .sysctl_wmem = sysctl_tcp_wmem,
2135 .sysctl_rmem = sysctl_tcp_ 2159 .sysctl_rmem = sysctl_tcp_rmem,
2136 .max_header = MAX_TCP_HEA 2160 .max_header = MAX_TCP_HEADER,
2137 .obj_size = sizeof(stru !! 2161 .slab_obj_size = sizeof(struct tcp6_sock),
2138 .twsk_prot = &tcp6_timew <<
2139 .rsk_prot = &tcp6_reque <<
2140 .hashinfo = &tcp_hashin <<
2141 #ifdef CONFIG_COMPAT <<
2142 .compat_setsockopt = compat_tcp_ <<
2143 .compat_getsockopt = compat_tcp_ <<
2144 #endif <<
2145 REF_PROTO_INUSE(tcpv6) <<
2146 }; 2162 };
2147 2163
2148 static struct inet6_protocol tcpv6_protocol = 2164 static struct inet6_protocol tcpv6_protocol = {
2149 .handler = tcp_v6_rcv, 2165 .handler = tcp_v6_rcv,
2150 .err_handler = tcp_v6_err, 2166 .err_handler = tcp_v6_err,
2151 .gso_send_check = tcp_v6_gso_se <<
2152 .gso_segment = tcp_tso_segme <<
2153 .flags = INET6_PROTO_N 2167 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
2154 }; 2168 };
2155 2169
>> 2170 extern struct proto_ops inet6_stream_ops;
>> 2171
2156 static struct inet_protosw tcpv6_protosw = { 2172 static struct inet_protosw tcpv6_protosw = {
2157 .type = SOCK_STREAM, 2173 .type = SOCK_STREAM,
2158 .protocol = IPPROTO_TCP, 2174 .protocol = IPPROTO_TCP,
2159 .prot = &tcpv6_prot, 2175 .prot = &tcpv6_prot,
2160 .ops = &inet6_stream 2176 .ops = &inet6_stream_ops,
2161 .capability = -1, 2177 .capability = -1,
2162 .no_check = 0, 2178 .no_check = 0,
2163 .flags = INET_PROTOSW_ !! 2179 .flags = INET_PROTOSW_PERMANENT,
2164 INET_PROTOSW_ <<
2165 }; 2180 };
2166 2181
2167 int __init tcpv6_init(void) !! 2182 void __init tcpv6_init(void)
2168 { 2183 {
2169 int ret; <<
2170 <<
2171 ret = inet6_add_protocol(&tcpv6_proto <<
2172 if (ret) <<
2173 goto out; <<
2174 <<
2175 /* register inet6 protocol */ 2184 /* register inet6 protocol */
2176 ret = inet6_register_protosw(&tcpv6_p !! 2185 if (inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP) < 0)
2177 if (ret) !! 2186 printk(KERN_ERR "tcpv6_init: Could not register protocol\n");
2178 goto out_tcpv6_protocol; !! 2187 inet6_register_protosw(&tcpv6_protosw);
2179 <<
2180 ret = inet_csk_ctl_sock_create(&tcp6_ <<
2181 SOCK_R <<
2182 if (ret) <<
2183 goto out_tcpv6_protosw; <<
2184 out: <<
2185 return ret; <<
2186 <<
2187 out_tcpv6_protocol: <<
2188 inet6_del_protocol(&tcpv6_protocol, I <<
2189 out_tcpv6_protosw: <<
2190 inet6_unregister_protosw(&tcpv6_proto <<
2191 goto out; <<
2192 } <<
2193 <<
2194 void tcpv6_exit(void) <<
2195 { <<
2196 sock_release(tcp6_socket); <<
2197 inet6_unregister_protosw(&tcpv6_proto <<
2198 inet6_del_protocol(&tcpv6_protocol, I <<
2199 } 2188 }
2200 2189
| This page was automatically generated by the LXR engine. |