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