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