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