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