ipv6.c 31.3 KB
Newer Older
1 2
/*
 *	DCCP over IPv6
A
Arnaldo Carvalho de Melo 已提交
3
 *	Linux INET6 implementation
4 5 6 7 8 9 10 11 12 13 14 15 16
 *
 *	Based on net/dccp6/ipv6.c
 *
 *	Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
 *
 *	This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */

#include <linux/module.h>
#include <linux/random.h>
17
#include <linux/slab.h>
18 19 20 21 22
#include <linux/xfrm.h>

#include <net/addrconf.h>
#include <net/inet_common.h>
#include <net/inet_hashtables.h>
23
#include <net/inet_sock.h>
24 25 26 27 28 29
#include <net/inet6_connection_sock.h>
#include <net/inet6_hashtables.h>
#include <net/ip6_route.h>
#include <net/ipv6.h>
#include <net/protocol.h>
#include <net/transp_v6.h>
30
#include <net/ip6_checksum.h>
31
#include <net/xfrm.h>
32
#include <net/secure_seq.h>
33 34 35

#include "dccp.h"
#include "ipv6.h"
36
#include "feat.h"
37

38
/* The per-net dccp.v6_ctl_sk is used for sending RSTs and ACKs */
39

40 41
static const struct inet_connection_sock_af_ops dccp_ipv6_mapped;
static const struct inet_connection_sock_af_ops dccp_ipv6_af_ops;
42 43 44 45 46

static void dccp_v6_hash(struct sock *sk)
{
	if (sk->sk_state != DCCP_CLOSED) {
		if (inet_csk(sk)->icsk_af_ops == &dccp_ipv6_mapped) {
47
			inet_hash(sk);
48 49 50
			return;
		}
		local_bh_disable();
51
		__inet6_hash(sk, NULL);
52 53 54 55
		local_bh_enable();
	}
}

56
/* add pseudo-header to DCCP checksum stored in skb->csum */
57
static inline __sum16 dccp_v6_csum_finish(struct sk_buff *skb,
58 59
				      const struct in6_addr *saddr,
				      const struct in6_addr *daddr)
60
{
61 62 63
	return csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_DCCP, skb->csum);
}

64
static inline void dccp_v6_send_check(struct sock *sk, struct sk_buff *skb)
65 66 67 68 69 70
{
	struct ipv6_pinfo *np = inet6_sk(sk);
	struct dccp_hdr *dh = dccp_hdr(skb);

	dccp_csum_outgoing(skb);
	dh->dccph_checksum = dccp_v6_csum_finish(skb, &np->saddr, &np->daddr);
71 72
}

73
static inline __u64 dccp_v6_init_sequence(struct sk_buff *skb)
74
{
75 76
	return secure_dccpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
					     ipv6_hdr(skb)->saddr.s6_addr32,
77 78 79
					     dccp_hdr(skb)->dccph_dport,
					     dccp_hdr(skb)->dccph_sport     );

80 81 82
}

static void dccp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
83
			u8 type, u8 code, int offset, __be32 info)
84
{
85
	const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
86
	const struct dccp_hdr *dh = (struct dccp_hdr *)(skb->data + offset);
87
	struct dccp_sock *dp;
88 89 90 91
	struct ipv6_pinfo *np;
	struct sock *sk;
	int err;
	__u64 seq;
92
	struct net *net = dev_net(skb->dev);
93

94 95
	if (skb->len < offset + sizeof(*dh) ||
	    skb->len < offset + __dccp_basic_hdr_len(dh)) {
96 97
		ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
				   ICMP6_MIB_INERRORS);
98 99 100
		return;
	}

101
	sk = inet6_lookup(net, &dccp_hashinfo,
102
			&hdr->daddr, dh->dccph_dport,
103
			&hdr->saddr, dh->dccph_sport, inet6_iif(skb));
104 105

	if (sk == NULL) {
106 107
		ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
				   ICMP6_MIB_INERRORS);
108 109 110 111
		return;
	}

	if (sk->sk_state == DCCP_TIME_WAIT) {
112
		inet_twsk_put(inet_twsk(sk));
113 114 115 116 117
		return;
	}

	bh_lock_sock(sk);
	if (sock_owned_by_user(sk))
118
		NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
119 120 121 122

	if (sk->sk_state == DCCP_CLOSED)
		goto out;

123 124 125 126 127 128 129 130
	dp = dccp_sk(sk);
	seq = dccp_hdr_seq(dh);
	if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_LISTEN) &&
	    !between48(seq, dp->dccps_awl, dp->dccps_awh)) {
		NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
		goto out;
	}

131 132
	np = inet6_sk(sk);

133 134 135 136 137 138 139
	if (type == NDISC_REDIRECT) {
		struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);

		if (dst && dst->ops->redirect)
			dst->ops->redirect(dst, skb);
	}

140 141 142 143 144 145 146 147 148 149 150 151
	if (type == ICMPV6_PKT_TOOBIG) {
		struct dst_entry *dst = NULL;

		if (sock_owned_by_user(sk))
			goto out;
		if ((1 << sk->sk_state) & (DCCPF_LISTEN | DCCPF_CLOSED))
			goto out;

		/* icmp should have updated the destination cache entry */
		dst = __sk_dst_check(sk, np->dst_cookie);
		if (dst == NULL) {
			struct inet_sock *inet = inet_sk(sk);
152
			struct flowi6 fl6;
153 154 155 156 157

			/* BUGGG_FUTURE: Again, it is not clear how
			   to handle rthdr case. Ignore this complexity
			   for now.
			 */
158 159
			memset(&fl6, 0, sizeof(fl6));
			fl6.flowi6_proto = IPPROTO_DCCP;
A
Alexey Dobriyan 已提交
160 161
			fl6.daddr = np->daddr;
			fl6.saddr = np->saddr;
162
			fl6.flowi6_oif = sk->sk_bound_dev_if;
163 164
			fl6.fl6_dport = inet->inet_dport;
			fl6.fl6_sport = inet->inet_sport;
165 166 167
			security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));

			dst = ip6_dst_lookup_flow(sk, &fl6, NULL, false);
168 169
			if (IS_ERR(dst)) {
				sk->sk_err_soft = -PTR_ERR(dst);
170 171 172 173 174
				goto out;
			}
		} else
			dst_hold(dst);

175 176
		dst->ops->update_pmtu(dst, ntohl(info));

177
		if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195
			dccp_sync_mss(sk, dst_mtu(dst));
		} /* else let the usual retransmit timer handle it */
		dst_release(dst);
		goto out;
	}

	icmpv6_err_convert(type, code, &err);

	/* Might be for an request_sock */
	switch (sk->sk_state) {
		struct request_sock *req, **prev;
	case DCCP_LISTEN:
		if (sock_owned_by_user(sk))
			goto out;

		req = inet6_csk_search_req(sk, &prev, dh->dccph_dport,
					   &hdr->daddr, &hdr->saddr,
					   inet6_iif(skb));
A
Arnaldo Carvalho de Melo 已提交
196
		if (req == NULL)
197 198
			goto out;

A
Arnaldo Carvalho de Melo 已提交
199 200 201
		/*
		 * ICMPs are not backlogged, hence we cannot get an established
		 * socket here.
202
		 */
203
		WARN_ON(req->sk != NULL);
204

205 206
		if (!between48(seq, dccp_rsk(req)->dreq_iss,
				    dccp_rsk(req)->dreq_gss)) {
207
			NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
208 209 210 211 212 213 214 215
			goto out;
		}

		inet_csk_reqsk_queue_drop(sk, req, prev);
		goto out;

	case DCCP_REQUESTING:
	case DCCP_RESPOND:  /* Cannot happen.
A
Arnaldo Carvalho de Melo 已提交
216
			       It can, it SYNs are crossed. --ANK */
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
		if (!sock_owned_by_user(sk)) {
			DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS);
			sk->sk_err = err;
			/*
			 * Wake people up to see the error
			 * (see connect in sock.c)
			 */
			sk->sk_error_report(sk);
			dccp_done(sk);
		} else
			sk->sk_err_soft = err;
		goto out;
	}

	if (!sock_owned_by_user(sk) && np->recverr) {
		sk->sk_err = err;
		sk->sk_error_report(sk);
	} else
		sk->sk_err_soft = err;

out:
	bh_unlock_sock(sk);
	sock_put(sk);
}


243 244
static int dccp_v6_send_response(struct sock *sk, struct request_sock *req,
				 struct request_values *rv_unused)
245 246 247 248
{
	struct inet6_request_sock *ireq6 = inet6_rsk(req);
	struct ipv6_pinfo *np = inet6_sk(sk);
	struct sk_buff *skb;
249
	struct in6_addr *final_p, final;
250
	struct flowi6 fl6;
251
	int err = -1;
252
	struct dst_entry *dst;
253

254 255
	memset(&fl6, 0, sizeof(fl6));
	fl6.flowi6_proto = IPPROTO_DCCP;
A
Alexey Dobriyan 已提交
256 257
	fl6.daddr = ireq6->rmt_addr;
	fl6.saddr = ireq6->loc_addr;
258 259
	fl6.flowlabel = 0;
	fl6.flowi6_oif = ireq6->iif;
260 261
	fl6.fl6_dport = inet_rsk(req)->rmt_port;
	fl6.fl6_sport = inet_rsk(req)->loc_port;
262
	security_req_classify_flow(req, flowi6_to_flowi(&fl6));
263 264


265
	final_p = fl6_update_dst(&fl6, np->opt, &final);
266

267
	dst = ip6_dst_lookup_flow(sk, &fl6, final_p, false);
268 269 270
	if (IS_ERR(dst)) {
		err = PTR_ERR(dst);
		dst = NULL;
271
		goto done;
272
	}
273 274 275 276

	skb = dccp_make_response(sk, dst, req);
	if (skb != NULL) {
		struct dccp_hdr *dh = dccp_hdr(skb);
A
Arnaldo Carvalho de Melo 已提交
277

278 279 280
		dh->dccph_checksum = dccp_v6_csum_finish(skb,
							 &ireq6->loc_addr,
							 &ireq6->rmt_addr);
A
Alexey Dobriyan 已提交
281
		fl6.daddr = ireq6->rmt_addr;
282
		err = ip6_xmit(sk, skb, &fl6, np->opt, np->tclass);
283
		err = net_xmit_eval(err);
284 285 286
	}

done:
287
	dst_release(dst);
288 289 290 291 292
	return err;
}

static void dccp_v6_reqsk_destructor(struct request_sock *req)
{
293
	dccp_feat_list_purge(&dccp_rsk(req)->dreq_featneg);
294 295 296 297
	if (inet6_rsk(req)->pktopts != NULL)
		kfree_skb(inet6_rsk(req)->pktopts);
}

298
static void dccp_v6_ctl_send_reset(struct sock *sk, struct sk_buff *rxskb)
299
{
300
	const struct ipv6hdr *rxip6h;
301
	struct sk_buff *skb;
302
	struct flowi6 fl6;
E
Eric Dumazet 已提交
303
	struct net *net = dev_net(skb_dst(rxskb)->dev);
304
	struct sock *ctl_sk = net->dccp.v6_ctl_sk;
E
Eric Dumazet 已提交
305
	struct dst_entry *dst;
306

307
	if (dccp_hdr(rxskb)->dccph_type == DCCP_PKT_RESET)
308 309 310
		return;

	if (!ipv6_unicast_destination(rxskb))
A
Arnaldo Carvalho de Melo 已提交
311
		return;
312

313
	skb = dccp_ctl_make_reset(ctl_sk, rxskb);
A
Arnaldo Carvalho de Melo 已提交
314
	if (skb == NULL)
315
		return;
316

317
	rxip6h = ipv6_hdr(rxskb);
318 319
	dccp_hdr(skb)->dccph_checksum = dccp_v6_csum_finish(skb, &rxip6h->saddr,
							    &rxip6h->daddr);
320

321
	memset(&fl6, 0, sizeof(fl6));
A
Alexey Dobriyan 已提交
322 323
	fl6.daddr = rxip6h->saddr;
	fl6.saddr = rxip6h->daddr;
324

325 326
	fl6.flowi6_proto = IPPROTO_DCCP;
	fl6.flowi6_oif = inet6_iif(rxskb);
327 328
	fl6.fl6_dport = dccp_hdr(skb)->dccph_dport;
	fl6.fl6_sport = dccp_hdr(skb)->dccph_sport;
329
	security_skb_classify_flow(rxskb, flowi6_to_flowi(&fl6));
330 331

	/* sk = NULL, but it is safe for now. RST socket required. */
332
	dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL, false);
333 334
	if (!IS_ERR(dst)) {
		skb_dst_set(skb, dst);
335
		ip6_xmit(ctl_sk, skb, &fl6, NULL, 0);
336 337 338
		DCCP_INC_STATS_BH(DCCP_MIB_OUTSEGS);
		DCCP_INC_STATS_BH(DCCP_MIB_OUTRSTS);
		return;
339 340 341 342 343
	}

	kfree_skb(skb);
}

344 345 346 347 348 349 350
static struct request_sock_ops dccp6_request_sock_ops = {
	.family		= AF_INET6,
	.obj_size	= sizeof(struct dccp6_request_sock),
	.rtx_syn_ack	= dccp_v6_send_response,
	.send_ack	= dccp_reqsk_send_ack,
	.destructor	= dccp_v6_reqsk_destructor,
	.send_reset	= dccp_v6_ctl_send_reset,
351
	.syn_ack_timeout = dccp_syn_ack_timeout,
352 353
};

354 355 356
static struct sock *dccp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
{
	const struct dccp_hdr *dh = dccp_hdr(skb);
357
	const struct ipv6hdr *iph = ipv6_hdr(skb);
358 359 360 361 362 363 364 365 366 367 368
	struct sock *nsk;
	struct request_sock **prev;
	/* Find possible connection requests. */
	struct request_sock *req = inet6_csk_search_req(sk, &prev,
							dh->dccph_sport,
							&iph->saddr,
							&iph->daddr,
							inet6_iif(skb));
	if (req != NULL)
		return dccp_check_req(sk, skb, req, prev);

369
	nsk = __inet6_lookup_established(sock_net(sk), &dccp_hashinfo,
370 371 372 373 374 375 376 377
					 &iph->saddr, dh->dccph_sport,
					 &iph->daddr, ntohs(dh->dccph_dport),
					 inet6_iif(skb));
	if (nsk != NULL) {
		if (nsk->sk_state != DCCP_TIME_WAIT) {
			bh_lock_sock(nsk);
			return nsk;
		}
378
		inet_twsk_put(inet_twsk(nsk));
379 380 381 382 383 384 385 386 387 388 389 390
		return NULL;
	}

	return sk;
}

static int dccp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
{
	struct request_sock *req;
	struct dccp_request_sock *dreq;
	struct inet6_request_sock *ireq6;
	struct ipv6_pinfo *np = inet6_sk(sk);
391
	const __be32 service = dccp_hdr_request(skb)->dccph_req_service;
392 393 394 395 396 397
	struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);

	if (skb->protocol == htons(ETH_P_IP))
		return dccp_v4_conn_request(sk, skb);

	if (!ipv6_unicast_destination(skb))
398
		return 0;	/* discard, don't send a reset here */
399 400

	if (dccp_bad_service_code(sk, service)) {
401
		dcb->dccpd_reset_code = DCCP_RESET_CODE_BAD_SERVICE_CODE;
402
		goto drop;
403
	}
404
	/*
A
Arnaldo Carvalho de Melo 已提交
405
	 * There are no SYN attacks on IPv6, yet...
406
	 */
407
	dcb->dccpd_reset_code = DCCP_RESET_CODE_TOO_BUSY;
408
	if (inet_csk_reqsk_queue_is_full(sk))
A
Arnaldo Carvalho de Melo 已提交
409
		goto drop;
410 411 412 413

	if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
		goto drop;

G
Gerrit Renker 已提交
414
	req = inet6_reqsk_alloc(&dccp6_request_sock_ops);
415 416 417
	if (req == NULL)
		goto drop;

418 419
	if (dccp_reqsk_init(req, dccp_sk(sk), skb))
		goto drop_and_free;
420

421 422 423 424
	dreq = dccp_rsk(req);
	if (dccp_parse_options(sk, dreq, skb))
		goto drop_and_free;

425 426 427
	if (security_inet_conn_request(sk, skb, req))
		goto drop_and_free;

428
	ireq6 = inet6_rsk(req);
A
Alexey Dobriyan 已提交
429 430
	ireq6->rmt_addr = ipv6_hdr(skb)->saddr;
	ireq6->loc_addr = ipv6_hdr(skb)->daddr;
431 432 433 434 435 436 437 438 439 440 441 442 443 444

	if (ipv6_opt_accepted(sk, skb) ||
	    np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
	    np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
		atomic_inc(&skb->users);
		ireq6->pktopts = skb;
	}
	ireq6->iif = sk->sk_bound_dev_if;

	/* So that link locals have meaning */
	if (!sk->sk_bound_dev_if &&
	    ipv6_addr_type(&ireq6->rmt_addr) & IPV6_ADDR_LINKLOCAL)
		ireq6->iif = inet6_iif(skb);

A
Arnaldo Carvalho de Melo 已提交
445
	/*
446 447
	 * Step 3: Process LISTEN state
	 *
448
	 *   Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookie
449
	 *
450
	 * Setting S.SWL/S.SWH to is deferred to dccp_create_openreq_child().
451 452
	 */
	dreq->dreq_isr	   = dcb->dccpd_seq;
453
	dreq->dreq_gsr     = dreq->dreq_isr;
454
	dreq->dreq_iss	   = dccp_v6_init_sequence(skb);
455
	dreq->dreq_gss     = dreq->dreq_iss;
456 457
	dreq->dreq_service = service;

458
	if (dccp_v6_send_response(sk, req, NULL))
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
		goto drop_and_free;

	inet6_csk_reqsk_queue_hash_add(sk, req, DCCP_TIMEOUT_INIT);
	return 0;

drop_and_free:
	reqsk_free(req);
drop:
	DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS);
	return -1;
}

static struct sock *dccp_v6_request_recv_sock(struct sock *sk,
					      struct sk_buff *skb,
					      struct request_sock *req,
					      struct dst_entry *dst)
{
	struct inet6_request_sock *ireq6 = inet6_rsk(req);
	struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
	struct inet_sock *newinet;
	struct dccp6_sock *newdp6;
	struct sock *newsk;

	if (skb->protocol == htons(ETH_P_IP)) {
		/*
		 *	v6 mapped
		 */
		newsk = dccp_v4_request_recv_sock(sk, skb, req, dst);
A
Arnaldo Carvalho de Melo 已提交
487
		if (newsk == NULL)
488 489 490 491 492 493 494 495 496
			return NULL;

		newdp6 = (struct dccp6_sock *)newsk;
		newinet = inet_sk(newsk);
		newinet->pinet6 = &newdp6->inet6;
		newnp = inet6_sk(newsk);

		memcpy(newnp, np, sizeof(struct ipv6_pinfo));

E
Eric Dumazet 已提交
497
		ipv6_addr_set_v4mapped(newinet->inet_daddr, &newnp->daddr);
498

E
Eric Dumazet 已提交
499
		ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
500

A
Alexey Dobriyan 已提交
501
		newnp->rcv_saddr = newnp->saddr;
502 503 504 505 506 507

		inet_csk(newsk)->icsk_af_ops = &dccp_ipv6_mapped;
		newsk->sk_backlog_rcv = dccp_v4_do_rcv;
		newnp->pktoptions  = NULL;
		newnp->opt	   = NULL;
		newnp->mcast_oif   = inet6_iif(skb);
508
		newnp->mcast_hops  = ipv6_hdr(skb)->hop_limit;
509 510 511 512 513 514 515 516 517 518 519

		/*
		 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
		 * here, dccp_create_openreq_child now does this for us, see the comment in
		 * that function for the gory details. -acme
		 */

		/* It is tricky place. Until this moment IPv4 tcp
		   worked with IPv6 icsk.icsk_af_ops.
		   Sync it now.
		 */
520
		dccp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
521 522 523 524 525 526 527 528 529

		return newsk;
	}


	if (sk_acceptq_is_full(sk))
		goto out_overflow;

	if (dst == NULL) {
530
		struct in6_addr *final_p, final;
531 532 533 534
		struct flowi6 fl6;

		memset(&fl6, 0, sizeof(fl6));
		fl6.flowi6_proto = IPPROTO_DCCP;
A
Alexey Dobriyan 已提交
535
		fl6.daddr = ireq6->rmt_addr;
536
		final_p = fl6_update_dst(&fl6, np->opt, &final);
A
Alexey Dobriyan 已提交
537
		fl6.saddr = ireq6->loc_addr;
538
		fl6.flowi6_oif = sk->sk_bound_dev_if;
539 540
		fl6.fl6_dport = inet_rsk(req)->rmt_port;
		fl6.fl6_sport = inet_rsk(req)->loc_port;
541 542 543
		security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));

		dst = ip6_dst_lookup_flow(sk, &fl6, final_p, false);
544
		if (IS_ERR(dst))
545
			goto out;
A
Arnaldo Carvalho de Melo 已提交
546
	}
547 548 549

	newsk = dccp_create_openreq_child(sk, req, skb);
	if (newsk == NULL)
550
		goto out_nonewsk;
551 552 553 554 555 556 557

	/*
	 * No need to charge this sock to the relevant IPv6 refcnt debug socks
	 * count here, dccp_create_openreq_child now does this for us, see the
	 * comment in that function for the gory details. -acme
	 */

558
	__ip6_dst_store(newsk, dst, NULL, NULL);
A
Arnaldo Carvalho de Melo 已提交
559 560
	newsk->sk_route_caps = dst->dev->features & ~(NETIF_F_IP_CSUM |
						      NETIF_F_TSO);
561 562 563 564 565 566 567
	newdp6 = (struct dccp6_sock *)newsk;
	newinet = inet_sk(newsk);
	newinet->pinet6 = &newdp6->inet6;
	newnp = inet6_sk(newsk);

	memcpy(newnp, np, sizeof(struct ipv6_pinfo));

A
Alexey Dobriyan 已提交
568 569 570
	newnp->daddr = ireq6->rmt_addr;
	newnp->saddr = ireq6->loc_addr;
	newnp->rcv_saddr = ireq6->loc_addr;
571 572
	newsk->sk_bound_dev_if = ireq6->iif;

A
Arnaldo Carvalho de Melo 已提交
573
	/* Now IPv6 options...
574 575 576

	   First: no IPv4 options.
	 */
577
	newinet->inet_opt = NULL;
578 579 580 581 582 583 584 585

	/* Clone RX bits */
	newnp->rxopt.all = np->rxopt.all;

	/* Clone pktoptions received with SYN */
	newnp->pktoptions = NULL;
	if (ireq6->pktopts != NULL) {
		newnp->pktoptions = skb_clone(ireq6->pktopts, GFP_ATOMIC);
586
		consume_skb(ireq6->pktopts);
587 588 589 590 591 592
		ireq6->pktopts = NULL;
		if (newnp->pktoptions)
			skb_set_owner_r(newnp->pktoptions, newsk);
	}
	newnp->opt	  = NULL;
	newnp->mcast_oif  = inet6_iif(skb);
593
	newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
594

A
Arnaldo Carvalho de Melo 已提交
595 596 597 598 599
	/*
	 * Clone native IPv6 options from listening socket (if any)
	 *
	 * Yes, keeping reference count would be much more clever, but we make
	 * one more one thing there: reattach optmem to newsk.
600
	 */
601 602
	if (np->opt != NULL)
		newnp->opt = ipv6_dup_options(newsk, np->opt);
603

604
	inet_csk(newsk)->icsk_ext_hdr_len = 0;
A
Arnaldo Carvalho de Melo 已提交
605
	if (newnp->opt != NULL)
606 607
		inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
						     newnp->opt->opt_flen);
608 609 610

	dccp_sync_mss(newsk, dst_mtu(dst));

E
Eric Dumazet 已提交
611 612
	newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
	newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
613

614 615 616 617
	if (__inet_inherit_port(sk, newsk) < 0) {
		sock_put(newsk);
		goto out;
	}
618
	__inet6_hash(newsk, NULL);
619 620 621 622

	return newsk;

out_overflow:
623
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
624 625
out_nonewsk:
	dst_release(dst);
626
out:
627
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
	return NULL;
}

/* The socket must have it's spinlock held when we get
 * here.
 *
 * We have a potential double-lock case here, so even when
 * doing backlog processing we use the BH locking scheme.
 * This is because we cannot sleep with the original spinlock
 * held.
 */
static int dccp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
{
	struct ipv6_pinfo *np = inet6_sk(sk);
	struct sk_buff *opt_skb = NULL;

	/* Imagine: socket is IPv6. IPv4 packet arrives,
	   goes to IPv4 receive handler and backlogged.
	   From backlog it always goes here. Kerboom...
	   Fortunately, dccp_rcv_established and rcv_established
	   handle them correctly, but it is not case with
	   dccp_v6_hnd_req and dccp_v6_ctl_send_reset().   --ANK
	 */

	if (skb->protocol == htons(ETH_P_IP))
		return dccp_v4_do_rcv(sk, skb);

655
	if (sk_filter(sk, skb))
656 657 658
		goto discard;

	/*
A
Arnaldo Carvalho de Melo 已提交
659 660
	 * socket locking is here for SMP purposes as backlog rcv is currently
	 * called with bh processing disabled.
661 662 663 664 665 666 667 668 669 670 671 672 673
	 */

	/* Do Stevens' IPV6_PKTOPTIONS.

	   Yes, guys, it is the only place in our code, where we
	   may make it not affecting IPv4.
	   The rest of code is protocol independent,
	   and I do not like idea to uglify IPv4.

	   Actually, all the idea behind IPV6_PKTOPTIONS
	   looks not very well thought. For now we latch
	   options, received in the last packet, enqueued
	   by tcp. Feel free to propose better solution.
674
					       --ANK (980728)
675 676
	 */
	if (np->rxopt.all)
677 678 679 680
	/*
	 * FIXME: Add handling of IPV6_PKTOPTIONS skb. See the comments below
	 *        (wrt ipv6_pktopions) and net/ipv6/tcp_ipv6.c for an example.
	 */
681 682 683 684 685
		opt_skb = skb_clone(skb, GFP_ATOMIC);

	if (sk->sk_state == DCCP_OPEN) { /* Fast path */
		if (dccp_rcv_established(sk, skb, dccp_hdr(skb), skb->len))
			goto reset;
D
David S. Miller 已提交
686
		if (opt_skb) {
687
			/* XXX This is where we would goto ipv6_pktoptions. */
D
David S. Miller 已提交
688 689
			__kfree_skb(opt_skb);
		}
690 691 692
		return 0;
	}

693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716
	/*
	 *  Step 3: Process LISTEN state
	 *     If S.state == LISTEN,
	 *	 If P.type == Request or P contains a valid Init Cookie option,
	 *	      (* Must scan the packet's options to check for Init
	 *		 Cookies.  Only Init Cookies are processed here,
	 *		 however; other options are processed in Step 8.  This
	 *		 scan need only be performed if the endpoint uses Init
	 *		 Cookies *)
	 *	      (* Generate a new socket and switch to that socket *)
	 *	      Set S := new socket for this port pair
	 *	      S.state = RESPOND
	 *	      Choose S.ISS (initial seqno) or set from Init Cookies
	 *	      Initialize S.GAR := S.ISS
	 *	      Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookies
	 *	      Continue with S.state == RESPOND
	 *	      (* A Response packet will be generated in Step 11 *)
	 *	 Otherwise,
	 *	      Generate Reset(No Connection) unless P.type == Reset
	 *	      Drop packet and return
	 *
	 * NOTE: the check for the packet types is done in
	 *	 dccp_rcv_state_process
	 */
A
Arnaldo Carvalho de Melo 已提交
717
	if (sk->sk_state == DCCP_LISTEN) {
718 719
		struct sock *nsk = dccp_v6_hnd_req(sk, skb);

A
Arnaldo Carvalho de Melo 已提交
720 721
		if (nsk == NULL)
			goto discard;
722 723 724 725 726
		/*
		 * Queue it on the new socket if the new socket is active,
		 * otherwise we just shortcircuit this and continue with
		 * the new socket..
		 */
727
		if (nsk != sk) {
728 729
			if (dccp_child_process(sk, nsk, skb))
				goto reset;
A
Arnaldo Carvalho de Melo 已提交
730
			if (opt_skb != NULL)
731 732 733 734 735 736 737
				__kfree_skb(opt_skb);
			return 0;
		}
	}

	if (dccp_rcv_state_process(sk, skb, dccp_hdr(skb), skb->len))
		goto reset;
D
David S. Miller 已提交
738
	if (opt_skb) {
739
		/* XXX This is where we would goto ipv6_pktoptions. */
D
David S. Miller 已提交
740 741
		__kfree_skb(opt_skb);
	}
742 743 744
	return 0;

reset:
745
	dccp_v6_ctl_send_reset(sk, skb);
746
discard:
A
Arnaldo Carvalho de Melo 已提交
747
	if (opt_skb != NULL)
748 749 750 751 752
		__kfree_skb(opt_skb);
	kfree_skb(skb);
	return 0;
}

753
static int dccp_v6_rcv(struct sk_buff *skb)
754 755 756
{
	const struct dccp_hdr *dh;
	struct sock *sk;
757
	int min_cov;
758

759
	/* Step 1: Check header basics */
760 761 762 763

	if (dccp_invalid_packet(skb))
		goto discard_it;

764
	/* Step 1: If header checksum is incorrect, drop packet and return. */
765 766
	if (dccp_v6_csum_finish(skb, &ipv6_hdr(skb)->saddr,
				     &ipv6_hdr(skb)->daddr)) {
767
		DCCP_WARN("dropped packet with invalid checksum\n");
768 769 770
		goto discard_it;
	}

771 772
	dh = dccp_hdr(skb);

773
	DCCP_SKB_CB(skb)->dccpd_seq  = dccp_hdr_seq(dh);
774 775 776 777 778 779 780 781
	DCCP_SKB_CB(skb)->dccpd_type = dh->dccph_type;

	if (dccp_packet_without_ack(skb))
		DCCP_SKB_CB(skb)->dccpd_ack_seq = DCCP_PKT_WITHOUT_ACK_SEQ;
	else
		DCCP_SKB_CB(skb)->dccpd_ack_seq = dccp_hdr_ack_seq(skb);

	/* Step 2:
782
	 *	Look up flow ID in table and get corresponding socket */
783 784
	sk = __inet6_lookup_skb(&dccp_hashinfo, skb,
			        dh->dccph_sport, dh->dccph_dport);
A
Arnaldo Carvalho de Melo 已提交
785
	/*
786
	 * Step 2:
787
	 *	If no socket ...
788
	 */
789 790 791
	if (sk == NULL) {
		dccp_pr_debug("failed to look up flow ID in table and "
			      "get corresponding socket\n");
792
		goto no_dccp_socket;
793
	}
794

A
Arnaldo Carvalho de Melo 已提交
795
	/*
796
	 * Step 2:
797
	 *	... or S.state == TIMEWAIT,
798 799 800
	 *		Generate Reset(No Connection) unless P.type == Reset
	 *		Drop packet and return
	 */
801 802 803 804 805
	if (sk->sk_state == DCCP_TIME_WAIT) {
		dccp_pr_debug("sk->sk_state == DCCP_TIME_WAIT: do_time_wait\n");
		inet_twsk_put(inet_twsk(sk));
		goto no_dccp_socket;
	}
806

807 808
	/*
	 * RFC 4340, sec. 9.2.1: Minimum Checksum Coverage
809 810
	 *	o if MinCsCov = 0, only packets with CsCov = 0 are accepted
	 *	o if MinCsCov > 0, also accept packets with CsCov >= MinCsCov
811 812 813 814 815 816 817 818 819
	 */
	min_cov = dccp_sk(sk)->dccps_pcrlen;
	if (dh->dccph_cscov  &&  (min_cov == 0 || dh->dccph_cscov < min_cov))  {
		dccp_pr_debug("Packet CsCov %d does not satisfy MinCsCov %d\n",
			      dh->dccph_cscov, min_cov);
		/* FIXME: send Data Dropped option (see also dccp_v4_rcv) */
		goto discard_and_relse;
	}

820 821 822
	if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
		goto discard_and_relse;

823
	return sk_receive_skb(sk, skb, 1) ? -1 : 0;
824 825 826 827 828 829

no_dccp_socket:
	if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
		goto discard_it;
	/*
	 * Step 2:
830
	 *	If no socket ...
831 832 833 834 835 836
	 *		Generate Reset(No Connection) unless P.type == Reset
	 *		Drop packet and return
	 */
	if (dh->dccph_type != DCCP_PKT_RESET) {
		DCCP_SKB_CB(skb)->dccpd_reset_code =
					DCCP_RESET_CODE_NO_CONNECTION;
837
		dccp_v6_ctl_send_reset(sk, skb);
838 839
	}

840
discard_it:
841 842 843 844 845 846 847 848
	kfree_skb(skb);
	return 0;

discard_and_relse:
	sock_put(sk);
	goto discard_it;
}

849 850 851 852 853 854 855 856
static int dccp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
			   int addr_len)
{
	struct sockaddr_in6 *usin = (struct sockaddr_in6 *)uaddr;
	struct inet_connection_sock *icsk = inet_csk(sk);
	struct inet_sock *inet = inet_sk(sk);
	struct ipv6_pinfo *np = inet6_sk(sk);
	struct dccp_sock *dp = dccp_sk(sk);
857
	struct in6_addr *saddr = NULL, *final_p, final;
858
	struct flowi6 fl6;
859 860 861 862 863 864 865 866 867 868 869 870
	struct dst_entry *dst;
	int addr_type;
	int err;

	dp->dccps_role = DCCP_ROLE_CLIENT;

	if (addr_len < SIN6_LEN_RFC2133)
		return -EINVAL;

	if (usin->sin6_family != AF_INET6)
		return -EAFNOSUPPORT;

871
	memset(&fl6, 0, sizeof(fl6));
872 873

	if (np->sndflow) {
874 875 876
		fl6.flowlabel = usin->sin6_flowinfo & IPV6_FLOWINFO_MASK;
		IP6_ECN_flow_init(fl6.flowlabel);
		if (fl6.flowlabel & IPV6_FLOWLABEL_MASK) {
877
			struct ip6_flowlabel *flowlabel;
878
			flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
879 880
			if (flowlabel == NULL)
				return -EINVAL;
A
Alexey Dobriyan 已提交
881
			usin->sin6_addr = flowlabel->dst;
882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913
			fl6_sock_release(flowlabel);
		}
	}
	/*
	 * connect() to INADDR_ANY means loopback (BSD'ism).
	 */
	if (ipv6_addr_any(&usin->sin6_addr))
		usin->sin6_addr.s6_addr[15] = 1;

	addr_type = ipv6_addr_type(&usin->sin6_addr);

	if (addr_type & IPV6_ADDR_MULTICAST)
		return -ENETUNREACH;

	if (addr_type & IPV6_ADDR_LINKLOCAL) {
		if (addr_len >= sizeof(struct sockaddr_in6) &&
		    usin->sin6_scope_id) {
			/* If interface is set while binding, indices
			 * must coincide.
			 */
			if (sk->sk_bound_dev_if &&
			    sk->sk_bound_dev_if != usin->sin6_scope_id)
				return -EINVAL;

			sk->sk_bound_dev_if = usin->sin6_scope_id;
		}

		/* Connect to link-local address requires an interface */
		if (!sk->sk_bound_dev_if)
			return -EINVAL;
	}

A
Alexey Dobriyan 已提交
914
	np->daddr = usin->sin6_addr;
915
	np->flow_label = fl6.flowlabel;
916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942

	/*
	 * DCCP over IPv4
	 */
	if (addr_type == IPV6_ADDR_MAPPED) {
		u32 exthdrlen = icsk->icsk_ext_hdr_len;
		struct sockaddr_in sin;

		SOCK_DEBUG(sk, "connect: ipv4 mapped\n");

		if (__ipv6_only_sock(sk))
			return -ENETUNREACH;

		sin.sin_family = AF_INET;
		sin.sin_port = usin->sin6_port;
		sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];

		icsk->icsk_af_ops = &dccp_ipv6_mapped;
		sk->sk_backlog_rcv = dccp_v4_do_rcv;

		err = dccp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
		if (err) {
			icsk->icsk_ext_hdr_len = exthdrlen;
			icsk->icsk_af_ops = &dccp_ipv6_af_ops;
			sk->sk_backlog_rcv = dccp_v6_do_rcv;
			goto failure;
		}
E
Eric Dumazet 已提交
943 944
		ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
		ipv6_addr_set_v4mapped(inet->inet_rcv_saddr, &np->rcv_saddr);
945 946 947 948 949 950 951

		return err;
	}

	if (!ipv6_addr_any(&np->rcv_saddr))
		saddr = &np->rcv_saddr;

952
	fl6.flowi6_proto = IPPROTO_DCCP;
A
Alexey Dobriyan 已提交
953 954
	fl6.daddr = np->daddr;
	fl6.saddr = saddr ? *saddr : np->saddr;
955
	fl6.flowi6_oif = sk->sk_bound_dev_if;
956 957
	fl6.fl6_dport = usin->sin6_port;
	fl6.fl6_sport = inet->inet_sport;
958
	security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
959

960
	final_p = fl6_update_dst(&fl6, np->opt, &final);
961

962
	dst = ip6_dst_lookup_flow(sk, &fl6, final_p, true);
963 964
	if (IS_ERR(dst)) {
		err = PTR_ERR(dst);
965
		goto failure;
966
	}
967 968

	if (saddr == NULL) {
969
		saddr = &fl6.saddr;
A
Alexey Dobriyan 已提交
970
		np->rcv_saddr = *saddr;
971 972 973
	}

	/* set the source address */
A
Alexey Dobriyan 已提交
974
	np->saddr = *saddr;
E
Eric Dumazet 已提交
975
	inet->inet_rcv_saddr = LOOPBACK4_IPV6;
976 977 978 979 980 981 982 983

	__ip6_dst_store(sk, dst, NULL, NULL);

	icsk->icsk_ext_hdr_len = 0;
	if (np->opt != NULL)
		icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
					  np->opt->opt_nflen);

E
Eric Dumazet 已提交
984
	inet->inet_dport = usin->sin6_port;
985 986 987 988 989

	dccp_set_state(sk, DCCP_REQUESTING);
	err = inet6_hash_connect(&dccp_death_row, sk);
	if (err)
		goto late_failure;
990 991 992

	dp->dccps_iss = secure_dccpv6_sequence_number(np->saddr.s6_addr32,
						      np->daddr.s6_addr32,
E
Eric Dumazet 已提交
993 994
						      inet->inet_sport,
						      inet->inet_dport);
995 996 997 998 999 1000 1001 1002 1003 1004
	err = dccp_connect(sk);
	if (err)
		goto late_failure;

	return 0;

late_failure:
	dccp_set_state(sk, DCCP_CLOSED);
	__sk_dst_reset(sk);
failure:
E
Eric Dumazet 已提交
1005
	inet->inet_dport = 0;
1006 1007 1008 1009
	sk->sk_route_caps = 0;
	return err;
}

1010
static const struct inet_connection_sock_af_ops dccp_ipv6_af_ops = {
1011 1012 1013 1014 1015 1016 1017 1018 1019 1020
	.queue_xmit	   = inet6_csk_xmit,
	.send_check	   = dccp_v6_send_check,
	.rebuild_header	   = inet6_sk_rebuild_header,
	.conn_request	   = dccp_v6_conn_request,
	.syn_recv_sock	   = dccp_v6_request_recv_sock,
	.net_header_len	   = sizeof(struct ipv6hdr),
	.setsockopt	   = ipv6_setsockopt,
	.getsockopt	   = ipv6_getsockopt,
	.addr2sockaddr	   = inet6_csk_addr2sockaddr,
	.sockaddr_len	   = sizeof(struct sockaddr_in6),
1021
	.bind_conflict	   = inet6_csk_bind_conflict,
1022
#ifdef CONFIG_COMPAT
1023 1024
	.compat_setsockopt = compat_ipv6_setsockopt,
	.compat_getsockopt = compat_ipv6_getsockopt,
1025
#endif
1026 1027 1028 1029 1030
};

/*
 *	DCCP over IPv4 via INET6 API
 */
1031
static const struct inet_connection_sock_af_ops dccp_ipv6_mapped = {
1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
	.queue_xmit	   = ip_queue_xmit,
	.send_check	   = dccp_v4_send_check,
	.rebuild_header	   = inet_sk_rebuild_header,
	.conn_request	   = dccp_v6_conn_request,
	.syn_recv_sock	   = dccp_v6_request_recv_sock,
	.net_header_len	   = sizeof(struct iphdr),
	.setsockopt	   = ipv6_setsockopt,
	.getsockopt	   = ipv6_getsockopt,
	.addr2sockaddr	   = inet6_csk_addr2sockaddr,
	.sockaddr_len	   = sizeof(struct sockaddr_in6),
1042
#ifdef CONFIG_COMPAT
1043 1044
	.compat_setsockopt = compat_ipv6_setsockopt,
	.compat_getsockopt = compat_ipv6_getsockopt,
1045
#endif
1046 1047 1048 1049 1050 1051 1052
};

/* NOTE: A lot of things set to zero explicitly by call to
 *       sk_alloc() so need not be done here.
 */
static int dccp_v6_init_sock(struct sock *sk)
{
1053 1054
	static __u8 dccp_v6_ctl_sock_initialized;
	int err = dccp_init_sock(sk, dccp_v6_ctl_sock_initialized);
1055

1056 1057 1058
	if (err == 0) {
		if (unlikely(!dccp_v6_ctl_sock_initialized))
			dccp_v6_ctl_sock_initialized = 1;
1059
		inet_csk(sk)->icsk_af_ops = &dccp_ipv6_af_ops;
1060
	}
1061 1062 1063 1064

	return err;
}

1065
static void dccp_v6_destroy_sock(struct sock *sk)
1066
{
1067
	dccp_destroy_sock(sk);
1068
	inet6_destroy_sock(sk);
1069 1070
}

1071 1072 1073 1074
static struct timewait_sock_ops dccp6_timewait_sock_ops = {
	.twsk_obj_size	= sizeof(struct dccp6_timewait_sock),
};

1075
static struct proto dccp_v6_prot = {
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088
	.name		   = "DCCPv6",
	.owner		   = THIS_MODULE,
	.close		   = dccp_close,
	.connect	   = dccp_v6_connect,
	.disconnect	   = dccp_disconnect,
	.ioctl		   = dccp_ioctl,
	.init		   = dccp_v6_init_sock,
	.setsockopt	   = dccp_setsockopt,
	.getsockopt	   = dccp_getsockopt,
	.sendmsg	   = dccp_sendmsg,
	.recvmsg	   = dccp_recvmsg,
	.backlog_rcv	   = dccp_v6_do_rcv,
	.hash		   = dccp_v6_hash,
1089
	.unhash		   = inet_unhash,
1090
	.accept		   = inet_csk_accept,
1091
	.get_port	   = inet_csk_get_port,
1092 1093 1094 1095 1096
	.shutdown	   = dccp_shutdown,
	.destroy	   = dccp_v6_destroy_sock,
	.orphan_count	   = &dccp_orphan_count,
	.max_header	   = MAX_DCCP_HEADER,
	.obj_size	   = sizeof(struct dccp6_sock),
1097
	.slab_flags	   = SLAB_DESTROY_BY_RCU,
1098 1099
	.rsk_prot	   = &dccp6_request_sock_ops,
	.twsk_prot	   = &dccp6_timewait_sock_ops,
1100
	.h.hashinfo	   = &dccp_hashinfo,
1101
#ifdef CONFIG_COMPAT
1102 1103
	.compat_setsockopt = compat_dccp_setsockopt,
	.compat_getsockopt = compat_dccp_getsockopt,
1104
#endif
1105 1106
};

1107
static const struct inet6_protocol dccp_v6_protocol = {
A
Arnaldo Carvalho de Melo 已提交
1108 1109 1110
	.handler	= dccp_v6_rcv,
	.err_handler	= dccp_v6_err,
	.flags		= INET6_PROTO_NOPOLICY | INET6_PROTO_FINAL,
1111 1112
};

1113
static const struct proto_ops inet6_dccp_ops = {
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
	.family		   = PF_INET6,
	.owner		   = THIS_MODULE,
	.release	   = inet6_release,
	.bind		   = inet6_bind,
	.connect	   = inet_stream_connect,
	.socketpair	   = sock_no_socketpair,
	.accept		   = inet_accept,
	.getname	   = inet6_getname,
	.poll		   = dccp_poll,
	.ioctl		   = inet6_ioctl,
	.listen		   = inet_dccp_listen,
	.shutdown	   = inet_shutdown,
	.setsockopt	   = sock_common_setsockopt,
	.getsockopt	   = sock_common_getsockopt,
	.sendmsg	   = inet_sendmsg,
	.recvmsg	   = sock_common_recvmsg,
	.mmap		   = sock_no_mmap,
	.sendpage	   = sock_no_sendpage,
1132
#ifdef CONFIG_COMPAT
1133 1134
	.compat_setsockopt = compat_sock_common_setsockopt,
	.compat_getsockopt = compat_sock_common_getsockopt,
1135
#endif
1136 1137 1138 1139 1140 1141 1142
};

static struct inet_protosw dccp_v6_protosw = {
	.type		= SOCK_DCCP,
	.protocol	= IPPROTO_DCCP,
	.prot		= &dccp_v6_prot,
	.ops		= &inet6_dccp_ops,
1143
	.flags		= INET_PROTOSW_ICSK,
1144 1145
};

1146
static int __net_init dccp_v6_init_net(struct net *net)
1147
{
1148 1149
	if (dccp_hashinfo.bhash == NULL)
		return -ESOCKTNOSUPPORT;
1150

1151 1152
	return inet_ctl_sock_create(&net->dccp.v6_ctl_sk, PF_INET6,
				    SOCK_DCCP, IPPROTO_DCCP, net);
1153 1154
}

1155
static void __net_exit dccp_v6_exit_net(struct net *net)
1156
{
1157
	inet_ctl_sock_destroy(net->dccp.v6_ctl_sk);
1158 1159 1160 1161 1162 1163 1164
}

static struct pernet_operations dccp_v6_ops = {
	.init   = dccp_v6_init_net,
	.exit   = dccp_v6_exit_net,
};

1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176
static int __init dccp_v6_init(void)
{
	int err = proto_register(&dccp_v6_prot, 1);

	if (err != 0)
		goto out;

	err = inet6_add_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
	if (err != 0)
		goto out_unregister_proto;

	inet6_register_protosw(&dccp_v6_protosw);
1177

1178 1179 1180
	err = register_pernet_subsys(&dccp_v6_ops);
	if (err != 0)
		goto out_destroy_ctl_sock;
1181 1182
out:
	return err;
1183 1184

out_destroy_ctl_sock:
1185 1186
	inet6_del_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
	inet6_unregister_protosw(&dccp_v6_protosw);
1187 1188 1189 1190 1191 1192 1193
out_unregister_proto:
	proto_unregister(&dccp_v6_prot);
	goto out;
}

static void __exit dccp_v6_exit(void)
{
1194
	unregister_pernet_subsys(&dccp_v6_ops);
1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
	inet6_del_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
	inet6_unregister_protosw(&dccp_v6_protosw);
	proto_unregister(&dccp_v6_prot);
}

module_init(dccp_v6_init);
module_exit(dccp_v6_exit);

/*
 * __stringify doesn't likes enums, so use SOCK_DCCP (6) and IPPROTO_DCCP (33)
 * values directly, Also cover the case where the protocol is not specified,
 * i.e. net-pf-PF_INET6-proto-0-type-SOCK_DCCP
 */
1208 1209
MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET6, 33, 6);
MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET6, 0, 6);
1210 1211 1212
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@mandriva.com>");
MODULE_DESCRIPTION("DCCPv6 - Datagram Congestion Controlled Protocol");