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