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