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