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