blob: c25018106ef2659caa38fcdb61c99934fab31fc0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * TCP over IPv6
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09003 * Linux INET6 implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * Authors:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09006 * Pedro Roque <roque@di.fc.ul.pt>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09008 * Based on:
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * 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
Herbert Xueb4dea52008-12-29 23:04:08 -080026#include <linux/bottom_half.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/errno.h>
29#include <linux/types.h>
30#include <linux/socket.h>
31#include <linux/sockios.h>
32#include <linux/net.h>
33#include <linux/jiffies.h>
34#include <linux/in.h>
35#include <linux/in6.h>
36#include <linux/netdevice.h>
37#include <linux/init.h>
38#include <linux/jhash.h>
39#include <linux/ipsec.h>
40#include <linux/times.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090041#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43#include <linux/ipv6.h>
44#include <linux/icmpv6.h>
45#include <linux/random.h>
46
47#include <net/tcp.h>
48#include <net/ndisc.h>
Arnaldo Carvalho de Melo5324a042005-08-12 09:26:18 -030049#include <net/inet6_hashtables.h>
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -080050#include <net/inet6_connection_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include <net/ipv6.h>
52#include <net/transp_v6.h>
53#include <net/addrconf.h>
54#include <net/ip6_route.h>
55#include <net/ip6_checksum.h>
56#include <net/inet_ecn.h>
57#include <net/protocol.h>
58#include <net/xfrm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#include <net/snmp.h>
60#include <net/dsfield.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080061#include <net/timewait_sock.h>
Jeff Garzik18134be2007-10-26 22:53:14 -070062#include <net/netdma.h>
Denis V. Lunev3d58b5f2008-04-03 14:22:32 -070063#include <net/inet_common.h>
David S. Miller6e5714e2011-08-03 20:50:44 -070064#include <net/secure_seq.h>
Glauber Costad1a4c0b2011-12-11 21:47:04 +000065#include <net/tcp_memcontrol.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
67#include <asm/uaccess.h>
68
69#include <linux/proc_fs.h>
70#include <linux/seq_file.h>
71
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080072#include <linux/crypto.h>
73#include <linux/scatterlist.h>
74
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080075static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
Gui Jianfeng6edafaa2008-08-06 23:50:04 -070076static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
77 struct request_sock *req);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
79static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
Herbert Xu8ad50d92010-04-11 02:15:54 +000080static void __tcp_v6_send_check(struct sk_buff *skb,
Eric Dumazetb71d1d42011-04-22 04:53:02 +000081 const struct in6_addr *saddr,
82 const struct in6_addr *daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
Stephen Hemminger3b401a82009-09-01 19:25:04 +000084static const struct inet_connection_sock_af_ops ipv6_mapped;
85static const struct inet_connection_sock_af_ops ipv6_specific;
David S. Millera9286302006-11-14 19:53:22 -080086#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +000087static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
88static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090089#else
90static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +000091 const struct in6_addr *addr)
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090092{
93 return NULL;
94}
David S. Millera9286302006-11-14 19:53:22 -080095#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Linus Torvalds1da177e2005-04-16 15:20:36 -070097static void tcp_v6_hash(struct sock *sk)
98{
99 if (sk->sk_state != TCP_CLOSE) {
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800100 if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 tcp_prot.hash(sk);
102 return;
103 }
104 local_bh_disable();
Eric Dumazet9327f702009-12-04 03:46:54 +0000105 __inet6_hash(sk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 local_bh_enable();
107 }
108}
109
Herbert Xu684f2172009-01-08 10:41:23 -0800110static __inline__ __sum16 tcp_v6_check(int len,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000111 const struct in6_addr *saddr,
112 const struct in6_addr *daddr,
Al Viro868c86b2006-11-14 21:35:48 -0800113 __wsum base)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114{
115 return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, base);
116}
117
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400118static __u32 tcp_v6_init_sequence(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700120 return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
121 ipv6_hdr(skb)->saddr.s6_addr32,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700122 tcp_hdr(skb)->dest,
123 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124}
125
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900126static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 int addr_len)
128{
129 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900130 struct inet_sock *inet = inet_sk(sk);
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800131 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 struct ipv6_pinfo *np = inet6_sk(sk);
133 struct tcp_sock *tp = tcp_sk(sk);
Arnaud Ebalard20c59de2010-06-01 21:35:01 +0000134 struct in6_addr *saddr = NULL, *final_p, final;
David S. Miller493f3772010-12-02 12:14:29 -0800135 struct rt6_info *rt;
David S. Miller4c9483b2011-03-12 16:22:43 -0500136 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 struct dst_entry *dst;
138 int addr_type;
139 int err;
140
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900141 if (addr_len < SIN6_LEN_RFC2133)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 return -EINVAL;
143
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900144 if (usin->sin6_family != AF_INET6)
Eric Dumazeta02cec22010-09-22 20:43:57 +0000145 return -EAFNOSUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
David S. Miller4c9483b2011-03-12 16:22:43 -0500147 memset(&fl6, 0, sizeof(fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
149 if (np->sndflow) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500150 fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
151 IP6_ECN_flow_init(fl6.flowlabel);
152 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 struct ip6_flowlabel *flowlabel;
David S. Miller4c9483b2011-03-12 16:22:43 -0500154 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 if (flowlabel == NULL)
156 return -EINVAL;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000157 usin->sin6_addr = flowlabel->dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 fl6_sock_release(flowlabel);
159 }
160 }
161
162 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900163 * connect() to INADDR_ANY means loopback (BSD'ism).
164 */
165
166 if(ipv6_addr_any(&usin->sin6_addr))
167 usin->sin6_addr.s6_addr[15] = 0x1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
169 addr_type = ipv6_addr_type(&usin->sin6_addr);
170
171 if(addr_type & IPV6_ADDR_MULTICAST)
172 return -ENETUNREACH;
173
174 if (addr_type&IPV6_ADDR_LINKLOCAL) {
175 if (addr_len >= sizeof(struct sockaddr_in6) &&
176 usin->sin6_scope_id) {
177 /* If interface is set while binding, indices
178 * must coincide.
179 */
180 if (sk->sk_bound_dev_if &&
181 sk->sk_bound_dev_if != usin->sin6_scope_id)
182 return -EINVAL;
183
184 sk->sk_bound_dev_if = usin->sin6_scope_id;
185 }
186
187 /* Connect to link-local address requires an interface */
188 if (!sk->sk_bound_dev_if)
189 return -EINVAL;
190 }
191
192 if (tp->rx_opt.ts_recent_stamp &&
193 !ipv6_addr_equal(&np->daddr, &usin->sin6_addr)) {
194 tp->rx_opt.ts_recent = 0;
195 tp->rx_opt.ts_recent_stamp = 0;
196 tp->write_seq = 0;
197 }
198
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000199 np->daddr = usin->sin6_addr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500200 np->flow_label = fl6.flowlabel;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
202 /*
203 * TCP over IPv4
204 */
205
206 if (addr_type == IPV6_ADDR_MAPPED) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800207 u32 exthdrlen = icsk->icsk_ext_hdr_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 struct sockaddr_in sin;
209
210 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
211
212 if (__ipv6_only_sock(sk))
213 return -ENETUNREACH;
214
215 sin.sin_family = AF_INET;
216 sin.sin_port = usin->sin6_port;
217 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
218
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800219 icsk->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 sk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800221#ifdef CONFIG_TCP_MD5SIG
222 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
223#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
225 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
226
227 if (err) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800228 icsk->icsk_ext_hdr_len = exthdrlen;
229 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 sk->sk_backlog_rcv = tcp_v6_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800231#ifdef CONFIG_TCP_MD5SIG
232 tp->af_specific = &tcp_sock_ipv6_specific;
233#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 goto failure;
235 } else {
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000236 ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
237 ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
238 &np->rcv_saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 }
240
241 return err;
242 }
243
244 if (!ipv6_addr_any(&np->rcv_saddr))
245 saddr = &np->rcv_saddr;
246
David S. Miller4c9483b2011-03-12 16:22:43 -0500247 fl6.flowi6_proto = IPPROTO_TCP;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000248 fl6.daddr = np->daddr;
249 fl6.saddr = saddr ? *saddr : np->saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500250 fl6.flowi6_oif = sk->sk_bound_dev_if;
251 fl6.flowi6_mark = sk->sk_mark;
David S. Miller1958b852011-03-12 16:36:19 -0500252 fl6.fl6_dport = usin->sin6_port;
253 fl6.fl6_sport = inet->inet_sport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
David S. Miller4c9483b2011-03-12 16:22:43 -0500255 final_p = fl6_update_dst(&fl6, np->opt, &final);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
David S. Miller4c9483b2011-03-12 16:22:43 -0500257 security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700258
David S. Miller4c9483b2011-03-12 16:22:43 -0500259 dst = ip6_dst_lookup_flow(sk, &fl6, final_p, true);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800260 if (IS_ERR(dst)) {
261 err = PTR_ERR(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 goto failure;
David S. Miller14e50e52007-05-24 18:17:54 -0700263 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264
265 if (saddr == NULL) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500266 saddr = &fl6.saddr;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000267 np->rcv_saddr = *saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 }
269
270 /* set the source address */
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000271 np->saddr = *saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000272 inet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700274 sk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -0700275 __ip6_dst_store(sk, dst, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
David S. Miller493f3772010-12-02 12:14:29 -0800277 rt = (struct rt6_info *) dst;
278 if (tcp_death_row.sysctl_tw_recycle &&
279 !tp->rx_opt.ts_recent_stamp &&
280 ipv6_addr_equal(&rt->rt6i_dst.addr, &np->daddr)) {
281 struct inet_peer *peer = rt6_get_peer(rt);
282 /*
283 * VJ's idea. We save last timestamp seen from
284 * the destination in peer table, when entering state
285 * TIME-WAIT * and initialize rx_opt.ts_recent from it,
286 * when trying new connection.
287 */
288 if (peer) {
289 inet_peer_refcheck(peer);
290 if ((u32)get_seconds() - peer->tcp_ts_stamp <= TCP_PAWS_MSL) {
291 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
292 tp->rx_opt.ts_recent = peer->tcp_ts;
293 }
294 }
295 }
296
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800297 icsk->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 if (np->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800299 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
300 np->opt->opt_nflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
302 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
303
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000304 inet->inet_dport = usin->sin6_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
306 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Melod8313f52005-12-13 23:25:44 -0800307 err = inet6_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 if (err)
309 goto late_failure;
310
311 if (!tp->write_seq)
312 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
313 np->daddr.s6_addr32,
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000314 inet->inet_sport,
315 inet->inet_dport);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
317 err = tcp_connect(sk);
318 if (err)
319 goto late_failure;
320
321 return 0;
322
323late_failure:
324 tcp_set_state(sk, TCP_CLOSE);
325 __sk_dst_reset(sk);
326failure:
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000327 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 sk->sk_route_caps = 0;
329 return err;
330}
331
332static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700333 u8 type, u8 code, int offset, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000335 const struct ipv6hdr *hdr = (const struct ipv6hdr*)skb->data;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -0300336 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 struct ipv6_pinfo *np;
338 struct sock *sk;
339 int err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900340 struct tcp_sock *tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 __u32 seq;
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700342 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700344 sk = inet6_lookup(net, &tcp_hashinfo, &hdr->daddr,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -0800345 th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
347 if (sk == NULL) {
Denis V. Luneve41b5362008-10-08 10:33:26 -0700348 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
349 ICMP6_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 return;
351 }
352
353 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700354 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 return;
356 }
357
358 bh_lock_sock(sk);
359 if (sock_owned_by_user(sk))
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700360 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
362 if (sk->sk_state == TCP_CLOSE)
363 goto out;
364
Stephen Hemmingere802af92010-04-22 15:24:53 -0700365 if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
366 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
367 goto out;
368 }
369
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 tp = tcp_sk(sk);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900371 seq = ntohl(th->seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 if (sk->sk_state != TCP_LISTEN &&
373 !between(seq, tp->snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700374 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 goto out;
376 }
377
378 np = inet6_sk(sk);
379
380 if (type == ICMPV6_PKT_TOOBIG) {
David S. Miller68d0c6d2011-03-01 13:19:07 -0800381 struct dst_entry *dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
383 if (sock_owned_by_user(sk))
384 goto out;
385 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
386 goto out;
387
388 /* icmp should have updated the destination cache entry */
389 dst = __sk_dst_check(sk, np->dst_cookie);
390
391 if (dst == NULL) {
392 struct inet_sock *inet = inet_sk(sk);
David S. Miller4c9483b2011-03-12 16:22:43 -0500393 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
395 /* BUGGG_FUTURE: Again, it is not clear how
396 to handle rthdr case. Ignore this complexity
397 for now.
398 */
David S. Miller4c9483b2011-03-12 16:22:43 -0500399 memset(&fl6, 0, sizeof(fl6));
400 fl6.flowi6_proto = IPPROTO_TCP;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000401 fl6.daddr = np->daddr;
402 fl6.saddr = np->saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500403 fl6.flowi6_oif = sk->sk_bound_dev_if;
404 fl6.flowi6_mark = sk->sk_mark;
David S. Miller1958b852011-03-12 16:36:19 -0500405 fl6.fl6_dport = inet->inet_dport;
406 fl6.fl6_sport = inet->inet_sport;
David S. Miller4c9483b2011-03-12 16:22:43 -0500407 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
David S. Miller4c9483b2011-03-12 16:22:43 -0500409 dst = ip6_dst_lookup_flow(sk, &fl6, NULL, false);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800410 if (IS_ERR(dst)) {
411 sk->sk_err_soft = -PTR_ERR(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 goto out;
413 }
414
415 } else
416 dst_hold(dst);
417
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800418 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 tcp_sync_mss(sk, dst_mtu(dst));
420 tcp_simple_retransmit(sk);
421 } /* else let the usual retransmit timer handle it */
422 dst_release(dst);
423 goto out;
424 }
425
426 icmpv6_err_convert(type, code, &err);
427
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700428 /* Might be for an request_sock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700430 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 case TCP_LISTEN:
432 if (sock_owned_by_user(sk))
433 goto out;
434
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -0800435 req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
436 &hdr->saddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 if (!req)
438 goto out;
439
440 /* ICMPs are not backlogged, hence we cannot get
441 * an established socket here.
442 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700443 WARN_ON(req->sk != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700445 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700446 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 goto out;
448 }
449
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700450 inet_csk_reqsk_queue_drop(sk, req, prev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 goto out;
452
453 case TCP_SYN_SENT:
454 case TCP_SYN_RECV: /* Cannot happen.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900455 It can, it SYNs are crossed. --ANK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 sk->sk_err = err;
458 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
459
460 tcp_done(sk);
461 } else
462 sk->sk_err_soft = err;
463 goto out;
464 }
465
466 if (!sock_owned_by_user(sk) && np->recverr) {
467 sk->sk_err = err;
468 sk->sk_error_report(sk);
469 } else
470 sk->sk_err_soft = err;
471
472out:
473 bh_unlock_sock(sk);
474 sock_put(sk);
475}
476
477
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000478static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req,
479 struct request_values *rvp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480{
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -0800481 struct inet6_request_sock *treq = inet6_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 struct ipv6_pinfo *np = inet6_sk(sk);
483 struct sk_buff * skb;
484 struct ipv6_txoptions *opt = NULL;
Arnaud Ebalard20c59de2010-06-01 21:35:01 +0000485 struct in6_addr * final_p, final;
David S. Miller4c9483b2011-03-12 16:22:43 -0500486 struct flowi6 fl6;
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800487 struct dst_entry *dst;
David S. Miller68d0c6d2011-03-01 13:19:07 -0800488 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
David S. Miller4c9483b2011-03-12 16:22:43 -0500490 memset(&fl6, 0, sizeof(fl6));
491 fl6.flowi6_proto = IPPROTO_TCP;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000492 fl6.daddr = treq->rmt_addr;
493 fl6.saddr = treq->loc_addr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500494 fl6.flowlabel = 0;
495 fl6.flowi6_oif = treq->iif;
496 fl6.flowi6_mark = sk->sk_mark;
David S. Miller1958b852011-03-12 16:36:19 -0500497 fl6.fl6_dport = inet_rsk(req)->rmt_port;
498 fl6.fl6_sport = inet_rsk(req)->loc_port;
David S. Miller4c9483b2011-03-12 16:22:43 -0500499 security_req_classify_flow(req, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800501 opt = np->opt;
David S. Miller4c9483b2011-03-12 16:22:43 -0500502 final_p = fl6_update_dst(&fl6, opt, &final);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
David S. Miller4c9483b2011-03-12 16:22:43 -0500504 dst = ip6_dst_lookup_flow(sk, &fl6, final_p, false);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800505 if (IS_ERR(dst)) {
506 err = PTR_ERR(dst);
Boris Ostrovsky738faca2011-04-04 13:07:26 -0700507 dst = NULL;
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800508 goto done;
David S. Miller68d0c6d2011-03-01 13:19:07 -0800509 }
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000510 skb = tcp_make_synack(sk, dst, req, rvp);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800511 err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 if (skb) {
Herbert Xu8ad50d92010-04-11 02:15:54 +0000513 __tcp_v6_send_check(skb, &treq->loc_addr, &treq->rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000515 fl6.daddr = treq->rmt_addr;
Eric Dumazetb903d322011-10-27 00:44:35 -0400516 err = ip6_xmit(sk, skb, &fl6, opt, np->tclass);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200517 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 }
519
520done:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900521 if (opt && opt != np->opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 sock_kfree_s(sk, opt, opt->tot_len);
Eric W. Biederman78b91042006-01-31 17:51:44 -0800523 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 return err;
525}
526
Octavian Purdila72659ec2010-01-17 19:09:39 -0800527static int tcp_v6_rtx_synack(struct sock *sk, struct request_sock *req,
528 struct request_values *rvp)
529{
530 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
531 return tcp_v6_send_synack(sk, req, rvp);
532}
533
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700534static void tcp_v6_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535{
Wei Yongjun800d55f2009-02-23 21:45:33 +0000536 kfree_skb(inet6_rsk(req)->pktopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537}
538
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800539#ifdef CONFIG_TCP_MD5SIG
540static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000541 const struct in6_addr *addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800542{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000543 return tcp_md5_do_lookup(sk, (union tcp_md5_addr *)addr, AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800544}
545
546static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
547 struct sock *addr_sk)
548{
549 return tcp_v6_md5_do_lookup(sk, &inet6_sk(addr_sk)->daddr);
550}
551
552static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
553 struct request_sock *req)
554{
555 return tcp_v6_md5_do_lookup(sk, &inet6_rsk(req)->rmt_addr);
556}
557
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800558static int tcp_v6_parse_md5_keys (struct sock *sk, char __user *optval,
559 int optlen)
560{
561 struct tcp_md5sig cmd;
562 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800563
564 if (optlen < sizeof(cmd))
565 return -EINVAL;
566
567 if (copy_from_user(&cmd, optval, sizeof(cmd)))
568 return -EFAULT;
569
570 if (sin6->sin6_family != AF_INET6)
571 return -EINVAL;
572
573 if (!cmd.tcpm_keylen) {
Brian Haleye773e4f2007-08-24 23:16:08 -0700574 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000575 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
576 AF_INET);
577 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
578 AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800579 }
580
581 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
582 return -EINVAL;
583
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000584 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
585 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
586 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800587
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000588 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
589 AF_INET6, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800590}
591
Adam Langley49a72df2008-07-19 00:01:42 -0700592static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000593 const struct in6_addr *daddr,
594 const struct in6_addr *saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800595{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800596 struct tcp6_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -0700597 struct scatterlist sg;
YOSHIFUJI Hideaki8d26d762008-04-17 13:19:16 +0900598
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800599 bp = &hp->md5_blk.ip6;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800600 /* 1. TCP pseudo-header (RFC2460) */
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000601 bp->saddr = *saddr;
602 bp->daddr = *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700603 bp->protocol = cpu_to_be32(IPPROTO_TCP);
Adam Langley00b13042008-07-31 21:36:07 -0700604 bp->len = cpu_to_be32(nbytes);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800605
Adam Langley49a72df2008-07-19 00:01:42 -0700606 sg_init_one(&sg, bp, sizeof(*bp));
607 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
608}
David S. Millerc7da57a2007-10-26 00:41:21 -0700609
Adam Langley49a72df2008-07-19 00:01:42 -0700610static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000611 const struct in6_addr *daddr, struct in6_addr *saddr,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400612 const struct tcphdr *th)
Adam Langley49a72df2008-07-19 00:01:42 -0700613{
614 struct tcp_md5sig_pool *hp;
615 struct hash_desc *desc;
616
617 hp = tcp_get_md5sig_pool();
618 if (!hp)
619 goto clear_hash_noput;
620 desc = &hp->md5_desc;
621
622 if (crypto_hash_init(desc))
623 goto clear_hash;
624 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
625 goto clear_hash;
626 if (tcp_md5_hash_header(hp, th))
627 goto clear_hash;
628 if (tcp_md5_hash_key(hp, key))
629 goto clear_hash;
630 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800631 goto clear_hash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800632
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800633 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800634 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -0700635
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800636clear_hash:
637 tcp_put_md5sig_pool();
638clear_hash_noput:
639 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -0700640 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800641}
642
Adam Langley49a72df2008-07-19 00:01:42 -0700643static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400644 const struct sock *sk,
645 const struct request_sock *req,
646 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800647{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000648 const struct in6_addr *saddr, *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700649 struct tcp_md5sig_pool *hp;
650 struct hash_desc *desc;
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400651 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800652
653 if (sk) {
654 saddr = &inet6_sk(sk)->saddr;
655 daddr = &inet6_sk(sk)->daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700656 } else if (req) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800657 saddr = &inet6_rsk(req)->loc_addr;
658 daddr = &inet6_rsk(req)->rmt_addr;
Adam Langley49a72df2008-07-19 00:01:42 -0700659 } else {
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000660 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Adam Langley49a72df2008-07-19 00:01:42 -0700661 saddr = &ip6h->saddr;
662 daddr = &ip6h->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800663 }
Adam Langley49a72df2008-07-19 00:01:42 -0700664
665 hp = tcp_get_md5sig_pool();
666 if (!hp)
667 goto clear_hash_noput;
668 desc = &hp->md5_desc;
669
670 if (crypto_hash_init(desc))
671 goto clear_hash;
672
673 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
674 goto clear_hash;
675 if (tcp_md5_hash_header(hp, th))
676 goto clear_hash;
677 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
678 goto clear_hash;
679 if (tcp_md5_hash_key(hp, key))
680 goto clear_hash;
681 if (crypto_hash_final(desc, md5_hash))
682 goto clear_hash;
683
684 tcp_put_md5sig_pool();
685 return 0;
686
687clear_hash:
688 tcp_put_md5sig_pool();
689clear_hash_noput:
690 memset(md5_hash, 0, 16);
691 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800692}
693
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400694static int tcp_v6_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800695{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400696 const __u8 *hash_location = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800697 struct tcp_md5sig_key *hash_expected;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000698 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400699 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800700 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800701 u8 newhash[16];
702
703 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +0900704 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800705
David S. Miller785957d2008-07-30 03:03:15 -0700706 /* We've parsed the options - do we have a hash? */
707 if (!hash_expected && !hash_location)
708 return 0;
709
710 if (hash_expected && !hash_location) {
711 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800712 return 1;
713 }
714
David S. Miller785957d2008-07-30 03:03:15 -0700715 if (!hash_expected && hash_location) {
716 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800717 return 1;
718 }
719
720 /* check the signature */
Adam Langley49a72df2008-07-19 00:01:42 -0700721 genhash = tcp_v6_md5_hash_skb(newhash,
722 hash_expected,
723 NULL, NULL, skb);
724
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800725 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
726 if (net_ratelimit()) {
Joe Perches5856b602010-01-08 00:59:52 -0800727 printk(KERN_INFO "MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800728 genhash ? "failed" : "mismatch",
Harvey Harrison0c6ce782008-10-28 16:09:23 -0700729 &ip6h->saddr, ntohs(th->source),
730 &ip6h->daddr, ntohs(th->dest));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800731 }
732 return 1;
733 }
734 return 0;
735}
736#endif
737
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800738struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 .family = AF_INET6,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700740 .obj_size = sizeof(struct tcp6_request_sock),
Octavian Purdila72659ec2010-01-17 19:09:39 -0800741 .rtx_syn_ack = tcp_v6_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700742 .send_ack = tcp_v6_reqsk_send_ack,
743 .destructor = tcp_v6_reqsk_destructor,
Octavian Purdila72659ec2010-01-17 19:09:39 -0800744 .send_reset = tcp_v6_send_reset,
745 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746};
747
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800748#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +0000749static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800750 .md5_lookup = tcp_v6_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +0000751 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800752};
Andrew Mortonb6332e62006-11-30 19:16:28 -0800753#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800754
Herbert Xu8ad50d92010-04-11 02:15:54 +0000755static void __tcp_v6_send_check(struct sk_buff *skb,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000756 const struct in6_addr *saddr, const struct in6_addr *daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700758 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
Patrick McHardy84fa7932006-08-29 16:44:56 -0700760 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Herbert Xu8ad50d92010-04-11 02:15:54 +0000761 th->check = ~tcp_v6_check(skb->len, saddr, daddr, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700762 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800763 skb->csum_offset = offsetof(struct tcphdr, check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 } else {
Herbert Xu8ad50d92010-04-11 02:15:54 +0000765 th->check = tcp_v6_check(skb->len, saddr, daddr,
766 csum_partial(th, th->doff << 2,
767 skb->csum));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 }
769}
770
Herbert Xubb296242010-04-11 02:15:55 +0000771static void tcp_v6_send_check(struct sock *sk, struct sk_buff *skb)
Herbert Xu8ad50d92010-04-11 02:15:54 +0000772{
773 struct ipv6_pinfo *np = inet6_sk(sk);
774
775 __tcp_v6_send_check(skb, &np->saddr, &np->daddr);
776}
777
Herbert Xua430a432006-07-08 13:34:56 -0700778static int tcp_v6_gso_send_check(struct sk_buff *skb)
779{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000780 const struct ipv6hdr *ipv6h;
Herbert Xua430a432006-07-08 13:34:56 -0700781 struct tcphdr *th;
782
783 if (!pskb_may_pull(skb, sizeof(*th)))
784 return -EINVAL;
785
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700786 ipv6h = ipv6_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700787 th = tcp_hdr(skb);
Herbert Xua430a432006-07-08 13:34:56 -0700788
789 th->check = 0;
Patrick McHardy84fa7932006-08-29 16:44:56 -0700790 skb->ip_summed = CHECKSUM_PARTIAL;
Herbert Xu8ad50d92010-04-11 02:15:54 +0000791 __tcp_v6_send_check(skb, &ipv6h->saddr, &ipv6h->daddr);
Herbert Xua430a432006-07-08 13:34:56 -0700792 return 0;
793}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
Herbert Xu36990672009-05-22 00:45:28 -0700795static struct sk_buff **tcp6_gro_receive(struct sk_buff **head,
796 struct sk_buff *skb)
Herbert Xu684f2172009-01-08 10:41:23 -0800797{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000798 const struct ipv6hdr *iph = skb_gro_network_header(skb);
Herbert Xu684f2172009-01-08 10:41:23 -0800799
800 switch (skb->ip_summed) {
801 case CHECKSUM_COMPLETE:
Herbert Xu86911732009-01-29 14:19:50 +0000802 if (!tcp_v6_check(skb_gro_len(skb), &iph->saddr, &iph->daddr,
Herbert Xu684f2172009-01-08 10:41:23 -0800803 skb->csum)) {
804 skb->ip_summed = CHECKSUM_UNNECESSARY;
805 break;
806 }
807
808 /* fall through */
809 case CHECKSUM_NONE:
810 NAPI_GRO_CB(skb)->flush = 1;
811 return NULL;
812 }
813
814 return tcp_gro_receive(head, skb);
815}
Herbert Xu684f2172009-01-08 10:41:23 -0800816
Herbert Xu36990672009-05-22 00:45:28 -0700817static int tcp6_gro_complete(struct sk_buff *skb)
Herbert Xu684f2172009-01-08 10:41:23 -0800818{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000819 const struct ipv6hdr *iph = ipv6_hdr(skb);
Herbert Xu684f2172009-01-08 10:41:23 -0800820 struct tcphdr *th = tcp_hdr(skb);
821
822 th->check = ~tcp_v6_check(skb->len - skb_transport_offset(skb),
823 &iph->saddr, &iph->daddr, 0);
824 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6;
825
826 return tcp_gro_complete(skb);
827}
Herbert Xu684f2172009-01-08 10:41:23 -0800828
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700829static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
Eric Dumazetb903d322011-10-27 00:44:35 -0400830 u32 ts, struct tcp_md5sig_key *key, int rst, u8 tclass)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400832 const struct tcphdr *th = tcp_hdr(skb);
833 struct tcphdr *t1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 struct sk_buff *buff;
David S. Miller4c9483b2011-03-12 16:22:43 -0500835 struct flowi6 fl6;
Eric Dumazetadf30902009-06-02 05:19:30 +0000836 struct net *net = dev_net(skb_dst(skb)->dev);
Daniel Lezcanoe5047992008-03-07 11:16:26 -0800837 struct sock *ctl_sk = net->ipv6.tcp_sk;
YOSHIFUJI Hideaki9cb57342008-01-12 02:16:03 -0800838 unsigned int tot_len = sizeof(struct tcphdr);
Eric Dumazetadf30902009-06-02 05:19:30 +0000839 struct dst_entry *dst;
Al Viroe69a4ad2006-11-14 20:56:00 -0800840 __be32 *topt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841
842 if (ts)
YOSHIFUJI Hideaki4244f8a2006-10-10 19:40:50 -0700843 tot_len += TCPOLEN_TSTAMP_ALIGNED;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800844#ifdef CONFIG_TCP_MD5SIG
845 if (key)
846 tot_len += TCPOLEN_MD5SIG_ALIGNED;
847#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848
849 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
850 GFP_ATOMIC);
851 if (buff == NULL)
852 return;
853
854 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
855
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700856 t1 = (struct tcphdr *) skb_push(buff, tot_len);
Herbert Xu6651ffc2010-04-21 00:47:15 -0700857 skb_reset_transport_header(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858
859 /* Swap the send and the receive. */
860 memset(t1, 0, sizeof(*t1));
861 t1->dest = th->source;
862 t1->source = th->dest;
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700863 t1->doff = tot_len / 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 t1->seq = htonl(seq);
865 t1->ack_seq = htonl(ack);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700866 t1->ack = !rst || !th->ack;
867 t1->rst = rst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 t1->window = htons(win);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800869
Al Viroe69a4ad2006-11-14 20:56:00 -0800870 topt = (__be32 *)(t1 + 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900871
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 if (ts) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800873 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
874 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
875 *topt++ = htonl(tcp_time_stamp);
Ilpo Järvinen53b12572008-10-08 14:36:33 -0700876 *topt++ = htonl(ts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 }
878
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800879#ifdef CONFIG_TCP_MD5SIG
880 if (key) {
881 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
882 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
Adam Langley49a72df2008-07-19 00:01:42 -0700883 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
Adam Langley90b7e112008-07-31 20:49:48 -0700884 &ipv6_hdr(skb)->saddr,
885 &ipv6_hdr(skb)->daddr, t1);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800886 }
887#endif
888
David S. Miller4c9483b2011-03-12 16:22:43 -0500889 memset(&fl6, 0, sizeof(fl6));
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000890 fl6.daddr = ipv6_hdr(skb)->saddr;
891 fl6.saddr = ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892
David S. Millere5700af2010-04-21 14:59:20 -0700893 buff->ip_summed = CHECKSUM_PARTIAL;
894 buff->csum = 0;
895
David S. Miller4c9483b2011-03-12 16:22:43 -0500896 __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897
David S. Miller4c9483b2011-03-12 16:22:43 -0500898 fl6.flowi6_proto = IPPROTO_TCP;
899 fl6.flowi6_oif = inet6_iif(skb);
David S. Miller1958b852011-03-12 16:36:19 -0500900 fl6.fl6_dport = t1->dest;
901 fl6.fl6_sport = t1->source;
David S. Miller4c9483b2011-03-12 16:22:43 -0500902 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700904 /* Pass a socket to ip6_dst_lookup either it is for RST
905 * Underlying function will use this to retrieve the network
906 * namespace
907 */
David S. Miller4c9483b2011-03-12 16:22:43 -0500908 dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL, false);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800909 if (!IS_ERR(dst)) {
910 skb_dst_set(buff, dst);
Eric Dumazetb903d322011-10-27 00:44:35 -0400911 ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800912 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
913 if (rst)
914 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
915 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 }
917
918 kfree_skb(buff);
919}
920
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700921static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
922{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400923 const struct tcphdr *th = tcp_hdr(skb);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700924 u32 seq = 0, ack_seq = 0;
Guo-Fu Tsengfa3e5b42008-10-09 21:11:56 -0700925 struct tcp_md5sig_key *key = NULL;
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700926
927 if (th->rst)
928 return;
929
930 if (!ipv6_unicast_destination(skb))
931 return;
932
933#ifdef CONFIG_TCP_MD5SIG
934 if (sk)
shawnlu8a622e72012-01-20 12:22:04 +0000935 key = tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->saddr);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700936#endif
937
938 if (th->ack)
939 seq = ntohl(th->ack_seq);
940 else
941 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
942 (th->doff << 2);
943
Eric Dumazetb903d322011-10-27 00:44:35 -0400944 tcp_v6_send_response(skb, seq, ack_seq, 0, 0, key, 1, 0);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700945}
946
947static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack, u32 win, u32 ts,
Eric Dumazetb903d322011-10-27 00:44:35 -0400948 struct tcp_md5sig_key *key, u8 tclass)
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700949{
Eric Dumazetb903d322011-10-27 00:44:35 -0400950 tcp_v6_send_response(skb, seq, ack, win, ts, key, 0, tclass);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700951}
952
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
954{
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700955 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800956 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900958 tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700959 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
Eric Dumazetb903d322011-10-27 00:44:35 -0400960 tcptw->tw_ts_recent, tcp_twsk_md5_key(tcptw),
961 tw->tw_tclass);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700963 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964}
965
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700966static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
967 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968{
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900969 tcp_v6_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd, req->ts_recent,
Eric Dumazetb903d322011-10-27 00:44:35 -0400970 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971}
972
973
974static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
975{
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700976 struct request_sock *req, **prev;
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700977 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 struct sock *nsk;
979
980 /* Find possible connection requests. */
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -0800981 req = inet6_csk_search_req(sk, &prev, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700982 &ipv6_hdr(skb)->saddr,
983 &ipv6_hdr(skb)->daddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 if (req)
985 return tcp_check_req(sk, skb, req, prev);
986
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900987 nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -0800988 &ipv6_hdr(skb)->saddr, th->source,
989 &ipv6_hdr(skb)->daddr, ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990
991 if (nsk) {
992 if (nsk->sk_state != TCP_TIME_WAIT) {
993 bh_lock_sock(nsk);
994 return nsk;
995 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700996 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 return NULL;
998 }
999
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001000#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +00001001 if (!th->syn)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001002 sk = cookie_v6_check(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003#endif
1004 return sk;
1005}
1006
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007/* FIXME: this is substantially similar to the ipv4 code.
1008 * Can some kind of merge be done? -- erics
1009 */
1010static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1011{
William Allen Simpson4957faa2009-12-02 18:25:27 +00001012 struct tcp_extend_values tmp_ext;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001013 struct tcp_options_received tmp_opt;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001014 const u8 *hash_location;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001015 struct request_sock *req;
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001016 struct inet6_request_sock *treq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 struct ipv6_pinfo *np = inet6_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 struct tcp_sock *tp = tcp_sk(sk);
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001019 __u32 isn = TCP_SKB_CB(skb)->when;
David S. Miller493f3772010-12-02 12:14:29 -08001020 struct dst_entry *dst = NULL;
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001021 int want_cookie = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022
1023 if (skb->protocol == htons(ETH_P_IP))
1024 return tcp_v4_conn_request(sk, skb);
1025
1026 if (!ipv6_unicast_destination(skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001027 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001029 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Eric Dumazet946cedc2011-08-30 03:21:44 +00001030 want_cookie = tcp_syn_flood_action(sk, skb, "TCPv6");
1031 if (!want_cookie)
1032 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 }
1034
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001035 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 goto drop;
1037
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001038 req = inet6_reqsk_alloc(&tcp6_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 if (req == NULL)
1040 goto drop;
1041
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001042#ifdef CONFIG_TCP_MD5SIG
1043 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv6_ops;
1044#endif
1045
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 tcp_clear_options(&tmp_opt);
1047 tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
1048 tmp_opt.user_mss = tp->rx_opt.user_mss;
David S. Millerbb5b7c12009-12-15 20:56:42 -08001049 tcp_parse_options(skb, &tmp_opt, &hash_location, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050
William Allen Simpson4957faa2009-12-02 18:25:27 +00001051 if (tmp_opt.cookie_plus > 0 &&
1052 tmp_opt.saw_tstamp &&
1053 !tp->rx_opt.cookie_out_never &&
1054 (sysctl_tcp_cookie_size > 0 ||
1055 (tp->cookie_values != NULL &&
1056 tp->cookie_values->cookie_desired > 0))) {
1057 u8 *c;
1058 u32 *d;
1059 u32 *mess = &tmp_ext.cookie_bakery[COOKIE_DIGEST_WORDS];
1060 int l = tmp_opt.cookie_plus - TCPOLEN_COOKIE_BASE;
1061
1062 if (tcp_cookie_generator(&tmp_ext.cookie_bakery[0]) != 0)
1063 goto drop_and_free;
1064
1065 /* Secret recipe starts with IP addresses */
Eric Dumazet0eae88f2010-04-20 19:06:52 -07001066 d = (__force u32 *)&ipv6_hdr(skb)->daddr.s6_addr32[0];
William Allen Simpson4957faa2009-12-02 18:25:27 +00001067 *mess++ ^= *d++;
1068 *mess++ ^= *d++;
1069 *mess++ ^= *d++;
1070 *mess++ ^= *d++;
Eric Dumazet0eae88f2010-04-20 19:06:52 -07001071 d = (__force u32 *)&ipv6_hdr(skb)->saddr.s6_addr32[0];
William Allen Simpson4957faa2009-12-02 18:25:27 +00001072 *mess++ ^= *d++;
1073 *mess++ ^= *d++;
1074 *mess++ ^= *d++;
1075 *mess++ ^= *d++;
1076
1077 /* plus variable length Initiator Cookie */
1078 c = (u8 *)mess;
1079 while (l-- > 0)
1080 *c++ ^= *hash_location++;
1081
William Allen Simpson4957faa2009-12-02 18:25:27 +00001082 want_cookie = 0; /* not our kind of cookie */
William Allen Simpson4957faa2009-12-02 18:25:27 +00001083 tmp_ext.cookie_out_never = 0; /* false */
1084 tmp_ext.cookie_plus = tmp_opt.cookie_plus;
1085 } else if (!tp->rx_opt.cookie_in_always) {
1086 /* redundant indications, but ensure initialization. */
1087 tmp_ext.cookie_out_never = 1; /* true */
1088 tmp_ext.cookie_plus = 0;
1089 } else {
1090 goto drop_and_free;
1091 }
1092 tmp_ext.cookie_in_always = tp->rx_opt.cookie_in_always;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093
Florian Westphal4dfc2812008-04-10 03:12:40 -07001094 if (want_cookie && !tmp_opt.saw_tstamp)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001095 tcp_clear_options(&tmp_opt);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001096
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1098 tcp_openreq_init(req, &tmp_opt, skb);
1099
Arnaldo Carvalho de Meloca304b62005-12-13 23:15:40 -08001100 treq = inet6_rsk(req);
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001101 treq->rmt_addr = ipv6_hdr(skb)->saddr;
1102 treq->loc_addr = ipv6_hdr(skb)->daddr;
Florian Westphal172d69e2010-06-21 11:48:45 +00001103 if (!want_cookie || tmp_opt.tstamp_ok)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001104 TCP_ECN_create_request(req, tcp_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105
Eric Dumazet4d0fe502011-11-23 17:29:23 -05001106 treq->iif = sk->sk_bound_dev_if;
1107
1108 /* So that link locals have meaning */
1109 if (!sk->sk_bound_dev_if &&
1110 ipv6_addr_type(&treq->rmt_addr) & IPV6_ADDR_LINKLOCAL)
1111 treq->iif = inet6_iif(skb);
1112
Florian Westphal2bbdf382010-06-13 11:29:39 +00001113 if (!isn) {
David S. Miller493f3772010-12-02 12:14:29 -08001114 struct inet_peer *peer = NULL;
1115
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001116 if (ipv6_opt_accepted(sk, skb) ||
1117 np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
1118 np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
1119 atomic_inc(&skb->users);
1120 treq->pktopts = skb;
1121 }
David S. Miller493f3772010-12-02 12:14:29 -08001122
1123 if (want_cookie) {
Florian Westphal2bbdf382010-06-13 11:29:39 +00001124 isn = cookie_v6_init_sequence(sk, skb, &req->mss);
1125 req->cookie_ts = tmp_opt.tstamp_ok;
David S. Miller493f3772010-12-02 12:14:29 -08001126 goto have_isn;
Florian Westphal2bbdf382010-06-13 11:29:39 +00001127 }
David S. Miller493f3772010-12-02 12:14:29 -08001128
1129 /* VJ's idea. We save last timestamp seen
1130 * from the destination in peer table, when entering
1131 * state TIME-WAIT, and check against it before
1132 * accepting new connection request.
1133 *
1134 * If "isn" is not zero, this request hit alive
1135 * timewait bucket, so that all the necessary checks
1136 * are made in the function processing timewait state.
1137 */
1138 if (tmp_opt.saw_tstamp &&
1139 tcp_death_row.sysctl_tw_recycle &&
1140 (dst = inet6_csk_route_req(sk, req)) != NULL &&
1141 (peer = rt6_get_peer((struct rt6_info *)dst)) != NULL &&
David S. Miller7a71ed82011-02-09 14:30:26 -08001142 ipv6_addr_equal((struct in6_addr *)peer->daddr.addr.a6,
David S. Miller493f3772010-12-02 12:14:29 -08001143 &treq->rmt_addr)) {
1144 inet_peer_refcheck(peer);
1145 if ((u32)get_seconds() - peer->tcp_ts_stamp < TCP_PAWS_MSL &&
1146 (s32)(peer->tcp_ts - req->ts_recent) >
1147 TCP_PAWS_WINDOW) {
1148 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
1149 goto drop_and_release;
1150 }
1151 }
1152 /* Kill the following clause, if you dislike this way. */
1153 else if (!sysctl_tcp_syncookies &&
1154 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
1155 (sysctl_max_syn_backlog >> 2)) &&
1156 (!peer || !peer->tcp_ts_stamp) &&
1157 (!dst || !dst_metric(dst, RTAX_RTT))) {
1158 /* Without syncookies last quarter of
1159 * backlog is filled with destinations,
1160 * proven to be alive.
1161 * It means that we continue to communicate
1162 * to destinations, already remembered
1163 * to the moment of synflood.
1164 */
1165 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI6/%u\n",
1166 &treq->rmt_addr, ntohs(tcp_hdr(skb)->source));
1167 goto drop_and_release;
1168 }
1169
1170 isn = tcp_v6_init_sequence(skb);
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001171 }
David S. Miller493f3772010-12-02 12:14:29 -08001172have_isn:
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001173 tcp_rsk(req)->snt_isn = isn;
Jerry Chu9ad7c042011-06-08 11:08:38 +00001174 tcp_rsk(req)->snt_synack = tcp_time_stamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001176 security_inet_conn_request(sk, skb, req);
1177
William Allen Simpson4957faa2009-12-02 18:25:27 +00001178 if (tcp_v6_send_synack(sk, req,
1179 (struct request_values *)&tmp_ext) ||
1180 want_cookie)
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001181 goto drop_and_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001183 inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1184 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185
David S. Miller493f3772010-12-02 12:14:29 -08001186drop_and_release:
1187 dst_release(dst);
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001188drop_and_free:
1189 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190drop:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 return 0; /* don't send reset */
1192}
1193
1194static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001195 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 struct dst_entry *dst)
1197{
Vegard Nossum78d15e82008-09-12 16:17:43 -07001198 struct inet6_request_sock *treq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1200 struct tcp6_sock *newtcp6sk;
1201 struct inet_sock *newinet;
1202 struct tcp_sock *newtp;
1203 struct sock *newsk;
1204 struct ipv6_txoptions *opt;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001205#ifdef CONFIG_TCP_MD5SIG
1206 struct tcp_md5sig_key *key;
1207#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208
1209 if (skb->protocol == htons(ETH_P_IP)) {
1210 /*
1211 * v6 mapped
1212 */
1213
1214 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1215
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001216 if (newsk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 return NULL;
1218
1219 newtcp6sk = (struct tcp6_sock *)newsk;
1220 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1221
1222 newinet = inet_sk(newsk);
1223 newnp = inet6_sk(newsk);
1224 newtp = tcp_sk(newsk);
1225
1226 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1227
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001228 ipv6_addr_set_v4mapped(newinet->inet_daddr, &newnp->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001230 ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001232 newnp->rcv_saddr = newnp->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001234 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001236#ifdef CONFIG_TCP_MD5SIG
1237 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1238#endif
1239
Yan, Zheng676a1182011-09-25 02:21:30 +00001240 newnp->ipv6_ac_list = NULL;
1241 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 newnp->pktoptions = NULL;
1243 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001244 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001245 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001247 /*
1248 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1249 * here, tcp_create_openreq_child now does this for us, see the comment in
1250 * that function for the gory details. -acme
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252
1253 /* It is tricky place. Until this moment IPv4 tcp
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001254 worked with IPv6 icsk.icsk_af_ops.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 Sync it now.
1256 */
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001257 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258
1259 return newsk;
1260 }
1261
Vegard Nossum78d15e82008-09-12 16:17:43 -07001262 treq = inet6_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 opt = np->opt;
1264
1265 if (sk_acceptq_is_full(sk))
1266 goto out_overflow;
1267
David S. Miller493f3772010-12-02 12:14:29 -08001268 if (!dst) {
1269 dst = inet6_csk_route_req(sk, req);
1270 if (!dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 goto out;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001272 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273
1274 newsk = tcp_create_openreq_child(sk, req, skb);
1275 if (newsk == NULL)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001276 goto out_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001278 /*
1279 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1280 * count here, tcp_create_openreq_child now does this for us, see the
1281 * comment in that function for the gory details. -acme
1282 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
Stephen Hemminger59eed272006-08-25 15:55:43 -07001284 newsk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -07001285 __ip6_dst_store(newsk, dst, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286
1287 newtcp6sk = (struct tcp6_sock *)newsk;
1288 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1289
1290 newtp = tcp_sk(newsk);
1291 newinet = inet_sk(newsk);
1292 newnp = inet6_sk(newsk);
1293
1294 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1295
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001296 newnp->daddr = treq->rmt_addr;
1297 newnp->saddr = treq->loc_addr;
1298 newnp->rcv_saddr = treq->loc_addr;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001299 newsk->sk_bound_dev_if = treq->iif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001301 /* Now IPv6 options...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302
1303 First: no IPv4 options.
1304 */
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001305 newinet->inet_opt = NULL;
Yan, Zheng676a1182011-09-25 02:21:30 +00001306 newnp->ipv6_ac_list = NULL;
Masayuki Nakagawad35690b2007-03-16 16:14:03 -07001307 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
1309 /* Clone RX bits */
1310 newnp->rxopt.all = np->rxopt.all;
1311
1312 /* Clone pktoptions received with SYN */
1313 newnp->pktoptions = NULL;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001314 if (treq->pktopts != NULL) {
1315 newnp->pktoptions = skb_clone(treq->pktopts, GFP_ATOMIC);
1316 kfree_skb(treq->pktopts);
1317 treq->pktopts = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 if (newnp->pktoptions)
1319 skb_set_owner_r(newnp->pktoptions, newsk);
1320 }
1321 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001322 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001323 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324
1325 /* Clone native IPv6 options from listening socket (if any)
1326
1327 Yes, keeping reference count would be much more clever,
1328 but we make one more one thing there: reattach optmem
1329 to newsk.
1330 */
1331 if (opt) {
1332 newnp->opt = ipv6_dup_options(newsk, opt);
1333 if (opt != np->opt)
1334 sock_kfree_s(sk, opt, opt->tot_len);
1335 }
1336
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001337 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 if (newnp->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001339 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1340 newnp->opt->opt_flen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341
John Heffner5d424d52006-03-20 17:53:41 -08001342 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001344 newtp->advmss = dst_metric_advmss(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 tcp_initialize_rcv_mss(newsk);
Jerry Chu9ad7c042011-06-08 11:08:38 +00001346 if (tcp_rsk(req)->snt_synack)
1347 tcp_valid_rtt_meas(newsk,
1348 tcp_time_stamp - tcp_rsk(req)->snt_synack);
1349 newtp->total_retrans = req->retrans;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001351 newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1352 newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001354#ifdef CONFIG_TCP_MD5SIG
1355 /* Copy over the MD5 key from the original socket */
1356 if ((key = tcp_v6_md5_do_lookup(sk, &newnp->daddr)) != NULL) {
1357 /* We're using one, so create a matching key
1358 * on the newsk structure. If we fail to get
1359 * memory, then we end up not copying the key
1360 * across. Shucks.
1361 */
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001362 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newnp->daddr,
1363 AF_INET6, key->key, key->keylen, GFP_ATOMIC);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001364 }
1365#endif
1366
Balazs Scheidler093d2822010-10-21 13:06:43 +02001367 if (__inet_inherit_port(sk, newsk) < 0) {
1368 sock_put(newsk);
1369 goto out;
1370 }
Eric Dumazet9327f702009-12-04 03:46:54 +00001371 __inet6_hash(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372
1373 return newsk;
1374
1375out_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001376 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001377out_nonewsk:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 if (opt && opt != np->opt)
1379 sock_kfree_s(sk, opt, opt->tot_len);
1380 dst_release(dst);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001381out:
1382 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 return NULL;
1384}
1385
Al Virob51655b2006-11-14 21:40:42 -08001386static __sum16 tcp_v6_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387{
Patrick McHardy84fa7932006-08-29 16:44:56 -07001388 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Herbert Xu684f2172009-01-08 10:41:23 -08001389 if (!tcp_v6_check(skb->len, &ipv6_hdr(skb)->saddr,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001390 &ipv6_hdr(skb)->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001391 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001393 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001395
Herbert Xu684f2172009-01-08 10:41:23 -08001396 skb->csum = ~csum_unfold(tcp_v6_check(skb->len,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001397 &ipv6_hdr(skb)->saddr,
1398 &ipv6_hdr(skb)->daddr, 0));
Herbert Xufb286bb2005-11-10 13:01:24 -08001399
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001401 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 }
1403 return 0;
1404}
1405
1406/* The socket must have it's spinlock held when we get
1407 * here.
1408 *
1409 * We have a potential double-lock case here, so even when
1410 * doing backlog processing we use the BH locking scheme.
1411 * This is because we cannot sleep with the original spinlock
1412 * held.
1413 */
1414static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1415{
1416 struct ipv6_pinfo *np = inet6_sk(sk);
1417 struct tcp_sock *tp;
1418 struct sk_buff *opt_skb = NULL;
1419
1420 /* Imagine: socket is IPv6. IPv4 packet arrives,
1421 goes to IPv4 receive handler and backlogged.
1422 From backlog it always goes here. Kerboom...
1423 Fortunately, tcp_rcv_established and rcv_established
1424 handle them correctly, but it is not case with
1425 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1426 */
1427
1428 if (skb->protocol == htons(ETH_P_IP))
1429 return tcp_v4_do_rcv(sk, skb);
1430
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001431#ifdef CONFIG_TCP_MD5SIG
1432 if (tcp_v6_inbound_md5_hash (sk, skb))
1433 goto discard;
1434#endif
1435
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001436 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 goto discard;
1438
1439 /*
1440 * socket locking is here for SMP purposes as backlog rcv
1441 * is currently called with bh processing disabled.
1442 */
1443
1444 /* Do Stevens' IPV6_PKTOPTIONS.
1445
1446 Yes, guys, it is the only place in our code, where we
1447 may make it not affecting IPv4.
1448 The rest of code is protocol independent,
1449 and I do not like idea to uglify IPv4.
1450
1451 Actually, all the idea behind IPV6_PKTOPTIONS
1452 looks not very well thought. For now we latch
1453 options, received in the last packet, enqueued
1454 by tcp. Feel free to propose better solution.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001455 --ANK (980728)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 */
1457 if (np->rxopt.all)
1458 opt_skb = skb_clone(skb, GFP_ATOMIC);
1459
1460 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Tom Herbertbdeab992011-08-14 19:45:55 +00001461 sock_rps_save_rxhash(sk, skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001462 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 goto reset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 if (opt_skb)
1465 goto ipv6_pktoptions;
1466 return 0;
1467 }
1468
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001469 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 goto csum_err;
1471
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001472 if (sk->sk_state == TCP_LISTEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1474 if (!nsk)
1475 goto discard;
1476
1477 /*
1478 * Queue it on the new socket if the new socket is active,
1479 * otherwise we just shortcircuit this and continue with
1480 * the new socket..
1481 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001482 if(nsk != sk) {
Tom Herbertbdeab992011-08-14 19:45:55 +00001483 sock_rps_save_rxhash(nsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 if (tcp_child_process(sk, nsk, skb))
1485 goto reset;
1486 if (opt_skb)
1487 __kfree_skb(opt_skb);
1488 return 0;
1489 }
Neil Horman47482f12011-04-06 13:07:09 -07001490 } else
Tom Herbertbdeab992011-08-14 19:45:55 +00001491 sock_rps_save_rxhash(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001493 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 goto reset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 if (opt_skb)
1496 goto ipv6_pktoptions;
1497 return 0;
1498
1499reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001500 tcp_v6_send_reset(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501discard:
1502 if (opt_skb)
1503 __kfree_skb(opt_skb);
1504 kfree_skb(skb);
1505 return 0;
1506csum_err:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001507 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 goto discard;
1509
1510
1511ipv6_pktoptions:
1512 /* Do you ask, what is it?
1513
1514 1. skb was enqueued by tcp.
1515 2. skb is added to tail of read queue, rather than out of order.
1516 3. socket is not in passive state.
1517 4. Finally, it really contains options, which user wants to receive.
1518 */
1519 tp = tcp_sk(sk);
1520 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1521 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001522 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001523 np->mcast_oif = inet6_iif(opt_skb);
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001524 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001525 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526 if (ipv6_opt_accepted(sk, opt_skb)) {
1527 skb_set_owner_r(opt_skb, sk);
1528 opt_skb = xchg(&np->pktoptions, opt_skb);
1529 } else {
1530 __kfree_skb(opt_skb);
1531 opt_skb = xchg(&np->pktoptions, NULL);
1532 }
1533 }
1534
Wei Yongjun800d55f2009-02-23 21:45:33 +00001535 kfree_skb(opt_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 return 0;
1537}
1538
Herbert Xue5bbef22007-10-15 12:50:28 -07001539static int tcp_v6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540{
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001541 const struct tcphdr *th;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001542 const struct ipv6hdr *hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543 struct sock *sk;
1544 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001545 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546
1547 if (skb->pkt_type != PACKET_HOST)
1548 goto discard_it;
1549
1550 /*
1551 * Count it even if it's bad.
1552 */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001553 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554
1555 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1556 goto discard_it;
1557
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001558 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559
1560 if (th->doff < sizeof(struct tcphdr)/4)
1561 goto bad_packet;
1562 if (!pskb_may_pull(skb, th->doff*4))
1563 goto discard_it;
1564
Herbert Xu60476372007-04-09 11:59:39 -07001565 if (!skb_csum_unnecessary(skb) && tcp_v6_checksum_init(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 goto bad_packet;
1567
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001568 th = tcp_hdr(skb);
Stephen Hemmingere802af92010-04-22 15:24:53 -07001569 hdr = ipv6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1571 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1572 skb->len - th->doff*4);
1573 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1574 TCP_SKB_CB(skb)->when = 0;
Eric Dumazetb82d1bb2011-09-27 02:20:08 -04001575 TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 TCP_SKB_CB(skb)->sacked = 0;
1577
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001578 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 if (!sk)
1580 goto no_tcp_socket;
1581
1582process:
1583 if (sk->sk_state == TCP_TIME_WAIT)
1584 goto do_time_wait;
1585
Stephen Hemmingere802af92010-04-22 15:24:53 -07001586 if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
1587 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1588 goto discard_and_relse;
1589 }
1590
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1592 goto discard_and_relse;
1593
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001594 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 goto discard_and_relse;
1596
1597 skb->dev = NULL;
1598
Fabio Olive Leite293b9c42006-09-25 22:28:47 -07001599 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600 ret = 0;
1601 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001602#ifdef CONFIG_NET_DMA
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001603 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerb4caea82007-10-26 04:20:13 -07001604 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dan Williamsf67b4592009-01-06 11:38:15 -07001605 tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001606 if (tp->ucopy.dma_chan)
1607 ret = tcp_v6_do_rcv(sk, skb);
1608 else
Chris Leech1a2449a2006-05-23 18:05:53 -07001609#endif
1610 {
1611 if (!tcp_prequeue(sk, skb))
1612 ret = tcp_v6_do_rcv(sk, skb);
1613 }
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001614 } else if (unlikely(sk_add_backlog(sk, skb))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001615 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001616 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001617 goto discard_and_relse;
1618 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 bh_unlock_sock(sk);
1620
1621 sock_put(sk);
1622 return ret ? -1 : 0;
1623
1624no_tcp_socket:
1625 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1626 goto discard_it;
1627
1628 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1629bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001630 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001632 tcp_v6_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 }
1634
1635discard_it:
1636
1637 /*
1638 * Discard frame
1639 */
1640
1641 kfree_skb(skb);
1642 return 0;
1643
1644discard_and_relse:
1645 sock_put(sk);
1646 goto discard_it;
1647
1648do_time_wait:
1649 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001650 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 goto discard_it;
1652 }
1653
1654 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001655 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001656 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 goto discard_it;
1658 }
1659
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001660 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 case TCP_TW_SYN:
1662 {
1663 struct sock *sk2;
1664
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001665 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001666 &ipv6_hdr(skb)->daddr,
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001667 ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 if (sk2 != NULL) {
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001669 struct inet_timewait_sock *tw = inet_twsk(sk);
1670 inet_twsk_deschedule(tw, &tcp_death_row);
1671 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 sk = sk2;
1673 goto process;
1674 }
1675 /* Fall through to ACK */
1676 }
1677 case TCP_TW_ACK:
1678 tcp_v6_timewait_ack(sk, skb);
1679 break;
1680 case TCP_TW_RST:
1681 goto no_tcp_socket;
1682 case TCP_TW_SUCCESS:;
1683 }
1684 goto discard_it;
1685}
1686
David S. Millerccb7c412010-12-01 18:09:13 -08001687static struct inet_peer *tcp_v6_get_peer(struct sock *sk, bool *release_it)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688{
David S. Millerdb3949c2010-12-02 11:52:07 -08001689 struct rt6_info *rt = (struct rt6_info *) __sk_dst_get(sk);
1690 struct ipv6_pinfo *np = inet6_sk(sk);
1691 struct inet_peer *peer;
1692
1693 if (!rt ||
1694 !ipv6_addr_equal(&np->daddr, &rt->rt6i_dst.addr)) {
1695 peer = inet_getpeer_v6(&np->daddr, 1);
1696 *release_it = true;
1697 } else {
1698 if (!rt->rt6i_peer)
1699 rt6_bind_peer(rt, 1);
1700 peer = rt->rt6i_peer;
David S. Miller457de432010-12-10 13:16:09 -08001701 *release_it = false;
David S. Millerdb3949c2010-12-02 11:52:07 -08001702 }
1703
1704 return peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705}
1706
David S. Millerccb7c412010-12-01 18:09:13 -08001707static void *tcp_v6_tw_get_peer(struct sock *sk)
1708{
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001709 const struct inet6_timewait_sock *tw6 = inet6_twsk(sk);
1710 const struct inet_timewait_sock *tw = inet_twsk(sk);
David S. Millerccb7c412010-12-01 18:09:13 -08001711
1712 if (tw->tw_family == AF_INET)
1713 return tcp_v4_tw_get_peer(sk);
1714
David S. Millerdb3949c2010-12-02 11:52:07 -08001715 return inet_getpeer_v6(&tw6->tw_v6_daddr, 1);
David S. Millerccb7c412010-12-01 18:09:13 -08001716}
1717
1718static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1719 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
1720 .twsk_unique = tcp_twsk_unique,
1721 .twsk_destructor= tcp_twsk_destructor,
1722 .twsk_getpeer = tcp_v6_tw_get_peer,
1723};
1724
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001725static const struct inet_connection_sock_af_ops ipv6_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001726 .queue_xmit = inet6_csk_xmit,
1727 .send_check = tcp_v6_send_check,
1728 .rebuild_header = inet6_sk_rebuild_header,
1729 .conn_request = tcp_v6_conn_request,
1730 .syn_recv_sock = tcp_v6_syn_recv_sock,
David S. Miller3f419d22010-11-29 13:37:14 -08001731 .get_peer = tcp_v6_get_peer,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001732 .net_header_len = sizeof(struct ipv6hdr),
1733 .setsockopt = ipv6_setsockopt,
1734 .getsockopt = ipv6_getsockopt,
1735 .addr2sockaddr = inet6_csk_addr2sockaddr,
1736 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001737 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001738#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001739 .compat_setsockopt = compat_ipv6_setsockopt,
1740 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001741#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742};
1743
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001744#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001745static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001746 .md5_lookup = tcp_v6_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001747 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001748 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001749};
David S. Millera9286302006-11-14 19:53:22 -08001750#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001751
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752/*
1753 * TCP over IPv4 via INET6 API
1754 */
1755
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001756static const struct inet_connection_sock_af_ops ipv6_mapped = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001757 .queue_xmit = ip_queue_xmit,
1758 .send_check = tcp_v4_send_check,
1759 .rebuild_header = inet_sk_rebuild_header,
1760 .conn_request = tcp_v6_conn_request,
1761 .syn_recv_sock = tcp_v6_syn_recv_sock,
David S. Miller3f419d22010-11-29 13:37:14 -08001762 .get_peer = tcp_v4_get_peer,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001763 .net_header_len = sizeof(struct iphdr),
1764 .setsockopt = ipv6_setsockopt,
1765 .getsockopt = ipv6_getsockopt,
1766 .addr2sockaddr = inet6_csk_addr2sockaddr,
1767 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001768 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001769#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001770 .compat_setsockopt = compat_ipv6_setsockopt,
1771 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001772#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773};
1774
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001775#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001776static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001777 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001778 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001779 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001780};
David S. Millera9286302006-11-14 19:53:22 -08001781#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001782
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783/* NOTE: A lot of things set to zero explicitly by call to
1784 * sk_alloc() so need not be done here.
1785 */
1786static int tcp_v6_init_sock(struct sock *sk)
1787{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001788 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 struct tcp_sock *tp = tcp_sk(sk);
1790
1791 skb_queue_head_init(&tp->out_of_order_queue);
1792 tcp_init_xmit_timers(sk);
1793 tcp_prequeue_init(tp);
1794
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001795 icsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 tp->mdev = TCP_TIMEOUT_INIT;
1797
1798 /* So many TCP implementations out there (incorrectly) count the
1799 * initial SYN frame in their delayed-ACK and congestion control
1800 * algorithms that we must have the following bandaid to talk
1801 * efficiently to them. -DaveM
1802 */
1803 tp->snd_cwnd = 2;
1804
1805 /* See draft-stevens-tcpca-spec-01 for discussion of the
1806 * initialization of these values.
1807 */
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001808 tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809 tp->snd_cwnd_clamp = ~0;
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001810 tp->mss_cache = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811
1812 tp->reordering = sysctl_tcp_reordering;
1813
1814 sk->sk_state = TCP_CLOSE;
1815
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001816 icsk->icsk_af_ops = &ipv6_specific;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001817 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001818 icsk->icsk_sync_mss = tcp_sync_mss;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819 sk->sk_write_space = sk_stream_write_space;
1820 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1821
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001822#ifdef CONFIG_TCP_MD5SIG
1823 tp->af_specific = &tcp_sock_ipv6_specific;
1824#endif
1825
William Allen Simpson435cf552009-12-02 18:17:05 +00001826 /* TCP Cookie Transactions */
1827 if (sysctl_tcp_cookie_size > 0) {
1828 /* Default, cookies without s_data_payload. */
1829 tp->cookie_values =
1830 kzalloc(sizeof(*tp->cookie_values),
1831 sk->sk_allocation);
1832 if (tp->cookie_values != NULL)
1833 kref_init(&tp->cookie_values->kref);
1834 }
1835 /* Presumed zeroed, in order of appearance:
1836 * cookie_in_always, cookie_out_never,
1837 * s_data_constant, s_data_in, s_data_out
1838 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1840 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1841
Herbert Xueb4dea52008-12-29 23:04:08 -08001842 local_bh_disable();
Glauber Costad1a4c0b2011-12-11 21:47:04 +00001843 sock_update_memcg(sk);
Glauber Costa180d8cd2011-12-11 21:47:02 +00001844 sk_sockets_allocated_inc(sk);
Herbert Xueb4dea52008-12-29 23:04:08 -08001845 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846
1847 return 0;
1848}
1849
Brian Haley7d06b2e2008-06-14 17:04:49 -07001850static void tcp_v6_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 tcp_v4_destroy_sock(sk);
Brian Haley7d06b2e2008-06-14 17:04:49 -07001853 inet6_destroy_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854}
1855
YOSHIFUJI Hideaki952a10b2007-04-21 20:13:44 +09001856#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857/* Proc filesystem TCPv6 sock list dumping. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001858static void get_openreq6(struct seq_file *seq,
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001859 const struct sock *sk, struct request_sock *req, int i, int uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 int ttd = req->expires - jiffies;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001862 const struct in6_addr *src = &inet6_rsk(req)->loc_addr;
1863 const struct in6_addr *dest = &inet6_rsk(req)->rmt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864
1865 if (ttd < 0)
1866 ttd = 0;
1867
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868 seq_printf(seq,
1869 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00001870 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 i,
1872 src->s6_addr32[0], src->s6_addr32[1],
1873 src->s6_addr32[2], src->s6_addr32[3],
KOVACS Krisztianfd507032008-10-19 23:35:58 -07001874 ntohs(inet_rsk(req)->loc_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 dest->s6_addr32[0], dest->s6_addr32[1],
1876 dest->s6_addr32[2], dest->s6_addr32[3],
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001877 ntohs(inet_rsk(req)->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878 TCP_SYN_RECV,
1879 0,0, /* could print option size, but that is af dependent. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001880 1, /* timers active (only the expire timer) */
1881 jiffies_to_clock_t(ttd),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 req->retrans,
1883 uid,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001884 0, /* non standard timer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 0, /* open_requests have no inode */
1886 0, req);
1887}
1888
1889static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1890{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001891 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 __u16 destp, srcp;
1893 int timer_active;
1894 unsigned long timer_expires;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001895 const struct inet_sock *inet = inet_sk(sp);
1896 const struct tcp_sock *tp = tcp_sk(sp);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001897 const struct inet_connection_sock *icsk = inet_csk(sp);
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001898 const struct ipv6_pinfo *np = inet6_sk(sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899
1900 dest = &np->daddr;
1901 src = &np->rcv_saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001902 destp = ntohs(inet->inet_dport);
1903 srcp = ntohs(inet->inet_sport);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001904
1905 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001907 timer_expires = icsk->icsk_timeout;
1908 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001910 timer_expires = icsk->icsk_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 } else if (timer_pending(&sp->sk_timer)) {
1912 timer_active = 2;
1913 timer_expires = sp->sk_timer.expires;
1914 } else {
1915 timer_active = 0;
1916 timer_expires = jiffies;
1917 }
1918
1919 seq_printf(seq,
1920 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00001921 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %pK %lu %lu %u %u %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 i,
1923 src->s6_addr32[0], src->s6_addr32[1],
1924 src->s6_addr32[2], src->s6_addr32[3], srcp,
1925 dest->s6_addr32[0], dest->s6_addr32[1],
1926 dest->s6_addr32[2], dest->s6_addr32[3], destp,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001927 sp->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07001928 tp->write_seq-tp->snd_una,
1929 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 timer_active,
1931 jiffies_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001932 icsk->icsk_retransmits,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 sock_i_uid(sp),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001934 icsk->icsk_probes_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 sock_i_ino(sp),
1936 atomic_read(&sp->sk_refcnt), sp,
Stephen Hemminger7be87352008-06-27 20:00:19 -07001937 jiffies_to_clock_t(icsk->icsk_rto),
1938 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001939 (icsk->icsk_ack.quick << 1 ) | icsk->icsk_ack.pingpong,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001940 tp->snd_cwnd,
1941 tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 );
1943}
1944
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001945static void get_timewait6_sock(struct seq_file *seq,
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -07001946 struct inet_timewait_sock *tw, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001948 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 __u16 destp, srcp;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001950 const struct inet6_timewait_sock *tw6 = inet6_twsk((struct sock *)tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 int ttd = tw->tw_ttd - jiffies;
1952
1953 if (ttd < 0)
1954 ttd = 0;
1955
Arnaldo Carvalho de Melo0fa1a532005-12-13 23:23:09 -08001956 dest = &tw6->tw_v6_daddr;
1957 src = &tw6->tw_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 destp = ntohs(tw->tw_dport);
1959 srcp = ntohs(tw->tw_sport);
1960
1961 seq_printf(seq,
1962 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00001963 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964 i,
1965 src->s6_addr32[0], src->s6_addr32[1],
1966 src->s6_addr32[2], src->s6_addr32[3], srcp,
1967 dest->s6_addr32[0], dest->s6_addr32[1],
1968 dest->s6_addr32[2], dest->s6_addr32[3], destp,
1969 tw->tw_substate, 0, 0,
1970 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
1971 atomic_read(&tw->tw_refcnt), tw);
1972}
1973
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974static int tcp6_seq_show(struct seq_file *seq, void *v)
1975{
1976 struct tcp_iter_state *st;
1977
1978 if (v == SEQ_START_TOKEN) {
1979 seq_puts(seq,
1980 " sl "
1981 "local_address "
1982 "remote_address "
1983 "st tx_queue rx_queue tr tm->when retrnsmt"
1984 " uid timeout inode\n");
1985 goto out;
1986 }
1987 st = seq->private;
1988
1989 switch (st->state) {
1990 case TCP_SEQ_STATE_LISTENING:
1991 case TCP_SEQ_STATE_ESTABLISHED:
1992 get_tcp6_sock(seq, v, st->num);
1993 break;
1994 case TCP_SEQ_STATE_OPENREQ:
1995 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
1996 break;
1997 case TCP_SEQ_STATE_TIME_WAIT:
1998 get_timewait6_sock(seq, v, st->num);
1999 break;
2000 }
2001out:
2002 return 0;
2003}
2004
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002005static const struct file_operations tcp6_afinfo_seq_fops = {
2006 .owner = THIS_MODULE,
2007 .open = tcp_seq_open,
2008 .read = seq_read,
2009 .llseek = seq_lseek,
2010 .release = seq_release_net
2011};
2012
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013static struct tcp_seq_afinfo tcp6_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014 .name = "tcp6",
2015 .family = AF_INET6,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002016 .seq_fops = &tcp6_afinfo_seq_fops,
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002017 .seq_ops = {
2018 .show = tcp6_seq_show,
2019 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020};
2021
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002022int __net_init tcp6_proc_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002024 return tcp_proc_register(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025}
2026
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002027void tcp6_proc_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002029 tcp_proc_unregister(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030}
2031#endif
2032
2033struct proto tcpv6_prot = {
2034 .name = "TCPv6",
2035 .owner = THIS_MODULE,
2036 .close = tcp_close,
2037 .connect = tcp_v6_connect,
2038 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002039 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040 .ioctl = tcp_ioctl,
2041 .init = tcp_v6_init_sock,
2042 .destroy = tcp_v6_destroy_sock,
2043 .shutdown = tcp_shutdown,
2044 .setsockopt = tcp_setsockopt,
2045 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00002047 .sendmsg = tcp_sendmsg,
2048 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049 .backlog_rcv = tcp_v6_do_rcv,
2050 .hash = tcp_v6_hash,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002051 .unhash = inet_unhash,
2052 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 .enter_memory_pressure = tcp_enter_memory_pressure,
2054 .sockets_allocated = &tcp_sockets_allocated,
2055 .memory_allocated = &tcp_memory_allocated,
2056 .memory_pressure = &tcp_memory_pressure,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002057 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 .sysctl_wmem = sysctl_tcp_wmem,
2059 .sysctl_rmem = sysctl_tcp_rmem,
2060 .max_header = MAX_TCP_HEADER,
2061 .obj_size = sizeof(struct tcp6_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002062 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002063 .twsk_prot = &tcp6_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002064 .rsk_prot = &tcp6_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002065 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00002066 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002067#ifdef CONFIG_COMPAT
2068 .compat_setsockopt = compat_tcp_setsockopt,
2069 .compat_getsockopt = compat_tcp_getsockopt,
2070#endif
Glauber Costad1a4c0b2011-12-11 21:47:04 +00002071#ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM
2072 .proto_cgroup = tcp_proto_cgroup,
2073#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074};
2075
Alexey Dobriyan41135cc2009-09-14 12:22:28 +00002076static const struct inet6_protocol tcpv6_protocol = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 .handler = tcp_v6_rcv,
2078 .err_handler = tcp_v6_err,
Herbert Xua430a432006-07-08 13:34:56 -07002079 .gso_send_check = tcp_v6_gso_send_check,
Herbert Xuadcfc7d2006-06-30 13:36:15 -07002080 .gso_segment = tcp_tso_segment,
Herbert Xu684f2172009-01-08 10:41:23 -08002081 .gro_receive = tcp6_gro_receive,
2082 .gro_complete = tcp6_gro_complete,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
2084};
2085
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086static struct inet_protosw tcpv6_protosw = {
2087 .type = SOCK_STREAM,
2088 .protocol = IPPROTO_TCP,
2089 .prot = &tcpv6_prot,
2090 .ops = &inet6_stream_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 .no_check = 0,
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08002092 .flags = INET_PROTOSW_PERMANENT |
2093 INET_PROTOSW_ICSK,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094};
2095
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002096static int __net_init tcpv6_net_init(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002097{
Denis V. Lunev56772422008-04-03 14:28:30 -07002098 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
2099 SOCK_RAW, IPPROTO_TCP, net);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002100}
2101
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002102static void __net_exit tcpv6_net_exit(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002103{
Denis V. Lunev56772422008-04-03 14:28:30 -07002104 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002105}
2106
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002107static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002108{
2109 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002110}
2111
2112static struct pernet_operations tcpv6_net_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002113 .init = tcpv6_net_init,
2114 .exit = tcpv6_net_exit,
2115 .exit_batch = tcpv6_net_exit_batch,
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002116};
2117
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002118int __init tcpv6_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119{
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002120 int ret;
David Woodhouseae0f7d52006-01-11 15:53:04 -08002121
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002122 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
2123 if (ret)
2124 goto out;
2125
2126 /* register inet6 protocol */
2127 ret = inet6_register_protosw(&tcpv6_protosw);
2128 if (ret)
2129 goto out_tcpv6_protocol;
2130
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002131 ret = register_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002132 if (ret)
2133 goto out_tcpv6_protosw;
2134out:
2135 return ret;
2136
2137out_tcpv6_protocol:
2138 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2139out_tcpv6_protosw:
2140 inet6_unregister_protosw(&tcpv6_protosw);
2141 goto out;
2142}
2143
Daniel Lezcano09f77092007-12-13 05:34:58 -08002144void tcpv6_exit(void)
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002145{
Daniel Lezcano93ec9262008-03-07 11:16:02 -08002146 unregister_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08002147 inet6_unregister_protosw(&tcpv6_protosw);
2148 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149}