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