ipv6.c 30.6 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
{
	struct ipv6_pinfo *np = inet6_sk(sk);
	struct dccp_hdr *dh = dccp_hdr(skb);

	dccp_csum_outgoing(skb);
70
	dh->dccph_checksum = dccp_v6_csum_finish(skb, &np->saddr, &sk->sk_v6_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
	if (type == NDISC_REDIRECT) {
		struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);

136
		if (dst)
137
			dst->ops->redirect(dst, sk, skb);
138
		goto out;
139 140
	}

141 142 143 144 145 146 147 148
	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;

149 150 151 152 153
		dst = inet6_csk_update_pmtu(sk, ntohl(info));
		if (!dst)
			goto out;

		if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst))
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
			dccp_sync_mss(sk, dst_mtu(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 已提交
170
		if (req == NULL)
171 172
			goto out;

A
Arnaldo Carvalho de Melo 已提交
173 174 175
		/*
		 * ICMPs are not backlogged, hence we cannot get an established
		 * socket here.
176
		 */
177
		WARN_ON(req->sk != NULL);
178

179 180
		if (!between48(seq, dccp_rsk(req)->dreq_iss,
				    dccp_rsk(req)->dreq_gss)) {
181
			NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
182 183 184 185 186 187 188 189
			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 已提交
190
			       It can, it SYNs are crossed. --ANK */
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
		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);
}


C
Christoph Paasch 已提交
217
static int dccp_v6_send_response(struct sock *sk, struct request_sock *req)
218
{
219
	struct inet_request_sock *ireq = inet_rsk(req);
220 221
	struct ipv6_pinfo *np = inet6_sk(sk);
	struct sk_buff *skb;
222
	struct in6_addr *final_p, final;
223
	struct flowi6 fl6;
224
	int err = -1;
225
	struct dst_entry *dst;
226

227 228
	memset(&fl6, 0, sizeof(fl6));
	fl6.flowi6_proto = IPPROTO_DCCP;
229 230
	fl6.daddr = ireq->ir_v6_rmt_addr;
	fl6.saddr = ireq->ir_v6_loc_addr;
231
	fl6.flowlabel = 0;
232 233
	fl6.flowi6_oif = ireq->ir_iif;
	fl6.fl6_dport = ireq->ir_rmt_port;
E
Eric Dumazet 已提交
234
	fl6.fl6_sport = htons(ireq->ir_num);
235
	security_req_classify_flow(req, flowi6_to_flowi(&fl6));
236 237


238
	final_p = fl6_update_dst(&fl6, np->opt, &final);
239

240
	dst = ip6_dst_lookup_flow(sk, &fl6, final_p, false);
241 242 243
	if (IS_ERR(dst)) {
		err = PTR_ERR(dst);
		dst = NULL;
244
		goto done;
245
	}
246 247 248 249

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

251
		dh->dccph_checksum = dccp_v6_csum_finish(skb,
252 253 254
							 &ireq->ir_v6_loc_addr,
							 &ireq->ir_v6_rmt_addr);
		fl6.daddr = ireq->ir_v6_rmt_addr;
255
		err = ip6_xmit(sk, skb, &fl6, np->opt, np->tclass);
256
		err = net_xmit_eval(err);
257 258 259
	}

done:
260
	dst_release(dst);
261 262 263 264 265
	return err;
}

static void dccp_v6_reqsk_destructor(struct request_sock *req)
{
266
	dccp_feat_list_purge(&dccp_rsk(req)->dreq_featneg);
267
	kfree_skb(inet_rsk(req)->pktopts);
268 269
}

270
static void dccp_v6_ctl_send_reset(struct sock *sk, struct sk_buff *rxskb)
271
{
272
	const struct ipv6hdr *rxip6h;
273
	struct sk_buff *skb;
274
	struct flowi6 fl6;
E
Eric Dumazet 已提交
275
	struct net *net = dev_net(skb_dst(rxskb)->dev);
276
	struct sock *ctl_sk = net->dccp.v6_ctl_sk;
E
Eric Dumazet 已提交
277
	struct dst_entry *dst;
278

279
	if (dccp_hdr(rxskb)->dccph_type == DCCP_PKT_RESET)
280 281 282
		return;

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

285
	skb = dccp_ctl_make_reset(ctl_sk, rxskb);
A
Arnaldo Carvalho de Melo 已提交
286
	if (skb == NULL)
287
		return;
288

289
	rxip6h = ipv6_hdr(rxskb);
290 291
	dccp_hdr(skb)->dccph_checksum = dccp_v6_csum_finish(skb, &rxip6h->saddr,
							    &rxip6h->daddr);
292

293
	memset(&fl6, 0, sizeof(fl6));
A
Alexey Dobriyan 已提交
294 295
	fl6.daddr = rxip6h->saddr;
	fl6.saddr = rxip6h->daddr;
296

297 298
	fl6.flowi6_proto = IPPROTO_DCCP;
	fl6.flowi6_oif = inet6_iif(rxskb);
299 300
	fl6.fl6_dport = dccp_hdr(skb)->dccph_dport;
	fl6.fl6_sport = dccp_hdr(skb)->dccph_sport;
301
	security_skb_classify_flow(rxskb, flowi6_to_flowi(&fl6));
302 303

	/* sk = NULL, but it is safe for now. RST socket required. */
304
	dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL, false);
305 306
	if (!IS_ERR(dst)) {
		skb_dst_set(skb, dst);
307
		ip6_xmit(ctl_sk, skb, &fl6, NULL, 0);
308 309 310
		DCCP_INC_STATS_BH(DCCP_MIB_OUTSEGS);
		DCCP_INC_STATS_BH(DCCP_MIB_OUTRSTS);
		return;
311 312 313 314 315
	}

	kfree_skb(skb);
}

316 317 318 319 320 321 322
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,
323
	.syn_ack_timeout = dccp_syn_ack_timeout,
324 325
};

326 327 328
static struct sock *dccp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
{
	const struct dccp_hdr *dh = dccp_hdr(skb);
329
	const struct ipv6hdr *iph = ipv6_hdr(skb);
330 331 332 333 334 335 336 337 338 339 340
	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);

341
	nsk = __inet6_lookup_established(sock_net(sk), &dccp_hashinfo,
342 343 344 345 346 347 348 349
					 &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;
		}
350
		inet_twsk_put(inet_twsk(nsk));
351 352 353 354 355 356 357 358 359 360
		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;
361
	struct inet_request_sock *ireq;
362
	struct ipv6_pinfo *np = inet6_sk(sk);
363
	const __be32 service = dccp_hdr_request(skb)->dccph_req_service;
364 365 366 367 368 369
	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))
370
		return 0;	/* discard, don't send a reset here */
371 372

	if (dccp_bad_service_code(sk, service)) {
373
		dcb->dccpd_reset_code = DCCP_RESET_CODE_BAD_SERVICE_CODE;
374
		goto drop;
375
	}
376
	/*
A
Arnaldo Carvalho de Melo 已提交
377
	 * There are no SYN attacks on IPv6, yet...
378
	 */
379
	dcb->dccpd_reset_code = DCCP_RESET_CODE_TOO_BUSY;
380
	if (inet_csk_reqsk_queue_is_full(sk))
A
Arnaldo Carvalho de Melo 已提交
381
		goto drop;
382 383 384 385

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

G
Gerrit Renker 已提交
386
	req = inet6_reqsk_alloc(&dccp6_request_sock_ops);
387 388 389
	if (req == NULL)
		goto drop;

390 391
	if (dccp_reqsk_init(req, dccp_sk(sk), skb))
		goto drop_and_free;
392

393 394 395 396
	dreq = dccp_rsk(req);
	if (dccp_parse_options(sk, dreq, skb))
		goto drop_and_free;

397 398 399
	if (security_inet_conn_request(sk, skb, req))
		goto drop_and_free;

400 401 402
	ireq = inet_rsk(req);
	ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
	ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
403 404 405 406 407

	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);
408
		ireq->pktopts = skb;
409
	}
410
	ireq->ir_iif = sk->sk_bound_dev_if;
411 412 413

	/* So that link locals have meaning */
	if (!sk->sk_bound_dev_if &&
414 415
	    ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
		ireq->ir_iif = inet6_iif(skb);
416

A
Arnaldo Carvalho de Melo 已提交
417
	/*
418 419
	 * Step 3: Process LISTEN state
	 *
420
	 *   Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookie
421
	 *
422
	 * Setting S.SWL/S.SWH to is deferred to dccp_create_openreq_child().
423 424
	 */
	dreq->dreq_isr	   = dcb->dccpd_seq;
425
	dreq->dreq_gsr     = dreq->dreq_isr;
426
	dreq->dreq_iss	   = dccp_v6_init_sequence(skb);
427
	dreq->dreq_gss     = dreq->dreq_iss;
428 429
	dreq->dreq_service = service;

C
Christoph Paasch 已提交
430
	if (dccp_v6_send_response(sk, req))
431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447
		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)
{
448
	struct inet_request_sock *ireq = inet_rsk(req);
449 450 451 452 453 454 455 456 457 458
	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 已提交
459
		if (newsk == NULL)
460 461 462 463 464 465 466 467 468
			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));

469
		ipv6_addr_set_v4mapped(newinet->inet_daddr, &newsk->sk_v6_daddr);
470

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

473
		newsk->sk_v6_rcv_saddr = newnp->saddr;
474 475 476 477 478 479

		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);
480
		newnp->mcast_hops  = ipv6_hdr(skb)->hop_limit;
481 482 483 484 485 486 487 488 489 490 491

		/*
		 * 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.
		 */
492
		dccp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
493 494 495 496 497 498 499 500 501

		return newsk;
	}


	if (sk_acceptq_is_full(sk))
		goto out_overflow;

	if (dst == NULL) {
502
		struct in6_addr *final_p, final;
503 504 505 506
		struct flowi6 fl6;

		memset(&fl6, 0, sizeof(fl6));
		fl6.flowi6_proto = IPPROTO_DCCP;
507
		fl6.daddr = ireq->ir_v6_rmt_addr;
508
		final_p = fl6_update_dst(&fl6, np->opt, &final);
509
		fl6.saddr = ireq->ir_v6_loc_addr;
510
		fl6.flowi6_oif = sk->sk_bound_dev_if;
511
		fl6.fl6_dport = ireq->ir_rmt_port;
E
Eric Dumazet 已提交
512
		fl6.fl6_sport = htons(ireq->ir_num);
513 514 515
		security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));

		dst = ip6_dst_lookup_flow(sk, &fl6, final_p, false);
516
		if (IS_ERR(dst))
517
			goto out;
A
Arnaldo Carvalho de Melo 已提交
518
	}
519 520 521

	newsk = dccp_create_openreq_child(sk, req, skb);
	if (newsk == NULL)
522
		goto out_nonewsk;
523 524 525 526 527 528 529

	/*
	 * 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
	 */

530
	__ip6_dst_store(newsk, dst, NULL, NULL);
A
Arnaldo Carvalho de Melo 已提交
531 532
	newsk->sk_route_caps = dst->dev->features & ~(NETIF_F_IP_CSUM |
						      NETIF_F_TSO);
533 534 535 536 537 538 539
	newdp6 = (struct dccp6_sock *)newsk;
	newinet = inet_sk(newsk);
	newinet->pinet6 = &newdp6->inet6;
	newnp = inet6_sk(newsk);

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

540 541 542 543
	newsk->sk_v6_daddr	= ireq->ir_v6_rmt_addr;
	newnp->saddr		= ireq->ir_v6_loc_addr;
	newsk->sk_v6_rcv_saddr	= ireq->ir_v6_loc_addr;
	newsk->sk_bound_dev_if	= ireq->ir_iif;
544

A
Arnaldo Carvalho de Melo 已提交
545
	/* Now IPv6 options...
546 547 548

	   First: no IPv4 options.
	 */
549
	newinet->inet_opt = NULL;
550 551 552 553 554 555

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

	/* Clone pktoptions received with SYN */
	newnp->pktoptions = NULL;
556 557 558 559
	if (ireq->pktopts != NULL) {
		newnp->pktoptions = skb_clone(ireq->pktopts, GFP_ATOMIC);
		consume_skb(ireq->pktopts);
		ireq->pktopts = NULL;
560 561 562 563 564
		if (newnp->pktoptions)
			skb_set_owner_r(newnp->pktoptions, newsk);
	}
	newnp->opt	  = NULL;
	newnp->mcast_oif  = inet6_iif(skb);
565
	newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
566

A
Arnaldo Carvalho de Melo 已提交
567 568 569 570 571
	/*
	 * 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.
572
	 */
573 574
	if (np->opt != NULL)
		newnp->opt = ipv6_dup_options(newsk, np->opt);
575

576
	inet_csk(newsk)->icsk_ext_hdr_len = 0;
A
Arnaldo Carvalho de Melo 已提交
577
	if (newnp->opt != NULL)
578 579
		inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
						     newnp->opt->opt_flen);
580 581 582

	dccp_sync_mss(newsk, dst_mtu(dst));

E
Eric Dumazet 已提交
583 584
	newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
	newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
585

586
	if (__inet_inherit_port(sk, newsk) < 0) {
587 588
		inet_csk_prepare_forced_close(newsk);
		dccp_done(newsk);
589 590
		goto out;
	}
591
	__inet6_hash(newsk, NULL);
592 593 594 595

	return newsk;

out_overflow:
596
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
597 598
out_nonewsk:
	dst_release(dst);
599
out:
600
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627
	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);

628
	if (sk_filter(sk, skb))
629 630 631
		goto discard;

	/*
A
Arnaldo Carvalho de Melo 已提交
632 633
	 * socket locking is here for SMP purposes as backlog rcv is currently
	 * called with bh processing disabled.
634 635 636 637 638 639 640 641 642 643 644 645 646
	 */

	/* 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.
647
					       --ANK (980728)
648 649
	 */
	if (np->rxopt.all)
650 651 652 653
	/*
	 * FIXME: Add handling of IPV6_PKTOPTIONS skb. See the comments below
	 *        (wrt ipv6_pktopions) and net/ipv6/tcp_ipv6.c for an example.
	 */
654 655 656 657 658
		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 已提交
659
		if (opt_skb) {
660
			/* XXX This is where we would goto ipv6_pktoptions. */
D
David S. Miller 已提交
661 662
			__kfree_skb(opt_skb);
		}
663 664 665
		return 0;
	}

666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
	/*
	 *  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 已提交
690
	if (sk->sk_state == DCCP_LISTEN) {
691 692
		struct sock *nsk = dccp_v6_hnd_req(sk, skb);

A
Arnaldo Carvalho de Melo 已提交
693 694
		if (nsk == NULL)
			goto discard;
695 696 697 698 699
		/*
		 * Queue it on the new socket if the new socket is active,
		 * otherwise we just shortcircuit this and continue with
		 * the new socket..
		 */
700
		if (nsk != sk) {
701 702
			if (dccp_child_process(sk, nsk, skb))
				goto reset;
A
Arnaldo Carvalho de Melo 已提交
703
			if (opt_skb != NULL)
704 705 706 707 708 709 710
				__kfree_skb(opt_skb);
			return 0;
		}
	}

	if (dccp_rcv_state_process(sk, skb, dccp_hdr(skb), skb->len))
		goto reset;
D
David S. Miller 已提交
711
	if (opt_skb) {
712
		/* XXX This is where we would goto ipv6_pktoptions. */
D
David S. Miller 已提交
713 714
		__kfree_skb(opt_skb);
	}
715 716 717
	return 0;

reset:
718
	dccp_v6_ctl_send_reset(sk, skb);
719
discard:
A
Arnaldo Carvalho de Melo 已提交
720
	if (opt_skb != NULL)
721 722 723 724 725
		__kfree_skb(opt_skb);
	kfree_skb(skb);
	return 0;
}

726
static int dccp_v6_rcv(struct sk_buff *skb)
727 728 729
{
	const struct dccp_hdr *dh;
	struct sock *sk;
730
	int min_cov;
731

732
	/* Step 1: Check header basics */
733 734 735 736

	if (dccp_invalid_packet(skb))
		goto discard_it;

737
	/* Step 1: If header checksum is incorrect, drop packet and return. */
738 739
	if (dccp_v6_csum_finish(skb, &ipv6_hdr(skb)->saddr,
				     &ipv6_hdr(skb)->daddr)) {
740
		DCCP_WARN("dropped packet with invalid checksum\n");
741 742 743
		goto discard_it;
	}

744 745
	dh = dccp_hdr(skb);

746
	DCCP_SKB_CB(skb)->dccpd_seq  = dccp_hdr_seq(dh);
747 748 749 750 751 752 753 754
	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:
755
	 *	Look up flow ID in table and get corresponding socket */
756 757
	sk = __inet6_lookup_skb(&dccp_hashinfo, skb,
			        dh->dccph_sport, dh->dccph_dport);
A
Arnaldo Carvalho de Melo 已提交
758
	/*
759
	 * Step 2:
760
	 *	If no socket ...
761
	 */
762 763 764
	if (sk == NULL) {
		dccp_pr_debug("failed to look up flow ID in table and "
			      "get corresponding socket\n");
765
		goto no_dccp_socket;
766
	}
767

A
Arnaldo Carvalho de Melo 已提交
768
	/*
769
	 * Step 2:
770
	 *	... or S.state == TIMEWAIT,
771 772 773
	 *		Generate Reset(No Connection) unless P.type == Reset
	 *		Drop packet and return
	 */
774 775 776 777 778
	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;
	}
779

780 781
	/*
	 * RFC 4340, sec. 9.2.1: Minimum Checksum Coverage
782 783
	 *	o if MinCsCov = 0, only packets with CsCov = 0 are accepted
	 *	o if MinCsCov > 0, also accept packets with CsCov >= MinCsCov
784 785 786 787 788 789 790 791 792
	 */
	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;
	}

793 794 795
	if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
		goto discard_and_relse;

796
	return sk_receive_skb(sk, skb, 1) ? -1 : 0;
797 798 799 800 801 802

no_dccp_socket:
	if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
		goto discard_it;
	/*
	 * Step 2:
803
	 *	If no socket ...
804 805 806 807 808 809
	 *		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;
810
		dccp_v6_ctl_send_reset(sk, skb);
811 812
	}

813
discard_it:
814 815 816 817 818 819 820 821
	kfree_skb(skb);
	return 0;

discard_and_relse:
	sock_put(sk);
	goto discard_it;
}

822 823 824 825 826 827 828 829
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);
830
	struct in6_addr *saddr = NULL, *final_p, final;
831
	struct flowi6 fl6;
832 833 834 835 836 837 838 839 840 841 842 843
	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;

844
	memset(&fl6, 0, sizeof(fl6));
845 846

	if (np->sndflow) {
847 848 849
		fl6.flowlabel = usin->sin6_flowinfo & IPV6_FLOWINFO_MASK;
		IP6_ECN_flow_init(fl6.flowlabel);
		if (fl6.flowlabel & IPV6_FLOWLABEL_MASK) {
850
			struct ip6_flowlabel *flowlabel;
851
			flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
852 853
			if (flowlabel == NULL)
				return -EINVAL;
A
Alexey Dobriyan 已提交
854
			usin->sin6_addr = flowlabel->dst;
855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886
			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;
	}

887
	sk->sk_v6_daddr = usin->sin6_addr;
888
	np->flow_label = fl6.flowlabel;
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 914 915

	/*
	 * 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 已提交
916
		ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
917
		ipv6_addr_set_v4mapped(inet->inet_rcv_saddr, &sk->sk_v6_rcv_saddr);
918 919 920 921

		return err;
	}

922 923
	if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
		saddr = &sk->sk_v6_rcv_saddr;
924

925
	fl6.flowi6_proto = IPPROTO_DCCP;
926
	fl6.daddr = sk->sk_v6_daddr;
A
Alexey Dobriyan 已提交
927
	fl6.saddr = saddr ? *saddr : np->saddr;
928
	fl6.flowi6_oif = sk->sk_bound_dev_if;
929 930
	fl6.fl6_dport = usin->sin6_port;
	fl6.fl6_sport = inet->inet_sport;
931
	security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
932

933
	final_p = fl6_update_dst(&fl6, np->opt, &final);
934

935
	dst = ip6_dst_lookup_flow(sk, &fl6, final_p, true);
936 937
	if (IS_ERR(dst)) {
		err = PTR_ERR(dst);
938
		goto failure;
939
	}
940 941

	if (saddr == NULL) {
942
		saddr = &fl6.saddr;
943
		sk->sk_v6_rcv_saddr = *saddr;
944 945 946
	}

	/* set the source address */
A
Alexey Dobriyan 已提交
947
	np->saddr = *saddr;
E
Eric Dumazet 已提交
948
	inet->inet_rcv_saddr = LOOPBACK4_IPV6;
949 950 951 952 953 954 955 956

	__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 已提交
957
	inet->inet_dport = usin->sin6_port;
958 959 960 961 962

	dccp_set_state(sk, DCCP_REQUESTING);
	err = inet6_hash_connect(&dccp_death_row, sk);
	if (err)
		goto late_failure;
963 964

	dp->dccps_iss = secure_dccpv6_sequence_number(np->saddr.s6_addr32,
965
						      sk->sk_v6_daddr.s6_addr32,
E
Eric Dumazet 已提交
966 967
						      inet->inet_sport,
						      inet->inet_dport);
968 969 970 971 972 973 974 975 976 977
	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 已提交
978
	inet->inet_dport = 0;
979 980 981 982
	sk->sk_route_caps = 0;
	return err;
}

983
static const struct inet_connection_sock_af_ops dccp_ipv6_af_ops = {
984 985 986 987 988 989 990 991 992 993
	.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),
994
	.bind_conflict	   = inet6_csk_bind_conflict,
995
#ifdef CONFIG_COMPAT
996 997
	.compat_setsockopt = compat_ipv6_setsockopt,
	.compat_getsockopt = compat_ipv6_getsockopt,
998
#endif
999 1000 1001 1002 1003
};

/*
 *	DCCP over IPv4 via INET6 API
 */
1004
static const struct inet_connection_sock_af_ops dccp_ipv6_mapped = {
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
	.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),
1015
#ifdef CONFIG_COMPAT
1016 1017
	.compat_setsockopt = compat_ipv6_setsockopt,
	.compat_getsockopt = compat_ipv6_getsockopt,
1018
#endif
1019 1020 1021 1022 1023 1024 1025
};

/* 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)
{
1026 1027
	static __u8 dccp_v6_ctl_sock_initialized;
	int err = dccp_init_sock(sk, dccp_v6_ctl_sock_initialized);
1028

1029 1030 1031
	if (err == 0) {
		if (unlikely(!dccp_v6_ctl_sock_initialized))
			dccp_v6_ctl_sock_initialized = 1;
1032
		inet_csk(sk)->icsk_af_ops = &dccp_ipv6_af_ops;
1033
	}
1034 1035 1036 1037

	return err;
}

1038
static void dccp_v6_destroy_sock(struct sock *sk)
1039
{
1040
	dccp_destroy_sock(sk);
1041
	inet6_destroy_sock(sk);
1042 1043
}

1044 1045 1046 1047
static struct timewait_sock_ops dccp6_timewait_sock_ops = {
	.twsk_obj_size	= sizeof(struct dccp6_timewait_sock),
};

1048
static struct proto dccp_v6_prot = {
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
	.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,
1062
	.unhash		   = inet_unhash,
1063
	.accept		   = inet_csk_accept,
1064
	.get_port	   = inet_csk_get_port,
1065 1066 1067 1068 1069
	.shutdown	   = dccp_shutdown,
	.destroy	   = dccp_v6_destroy_sock,
	.orphan_count	   = &dccp_orphan_count,
	.max_header	   = MAX_DCCP_HEADER,
	.obj_size	   = sizeof(struct dccp6_sock),
1070
	.slab_flags	   = SLAB_DESTROY_BY_RCU,
1071 1072
	.rsk_prot	   = &dccp6_request_sock_ops,
	.twsk_prot	   = &dccp6_timewait_sock_ops,
1073
	.h.hashinfo	   = &dccp_hashinfo,
1074
#ifdef CONFIG_COMPAT
1075 1076
	.compat_setsockopt = compat_dccp_setsockopt,
	.compat_getsockopt = compat_dccp_getsockopt,
1077
#endif
1078 1079
};

1080
static const struct inet6_protocol dccp_v6_protocol = {
A
Arnaldo Carvalho de Melo 已提交
1081 1082 1083
	.handler	= dccp_v6_rcv,
	.err_handler	= dccp_v6_err,
	.flags		= INET6_PROTO_NOPOLICY | INET6_PROTO_FINAL,
1084 1085
};

1086
static const struct proto_ops inet6_dccp_ops = {
1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104
	.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,
1105
#ifdef CONFIG_COMPAT
1106 1107
	.compat_setsockopt = compat_sock_common_setsockopt,
	.compat_getsockopt = compat_sock_common_getsockopt,
1108
#endif
1109 1110 1111 1112 1113 1114 1115
};

static struct inet_protosw dccp_v6_protosw = {
	.type		= SOCK_DCCP,
	.protocol	= IPPROTO_DCCP,
	.prot		= &dccp_v6_prot,
	.ops		= &inet6_dccp_ops,
1116
	.flags		= INET_PROTOSW_ICSK,
1117 1118
};

1119
static int __net_init dccp_v6_init_net(struct net *net)
1120
{
1121 1122
	if (dccp_hashinfo.bhash == NULL)
		return -ESOCKTNOSUPPORT;
1123

1124 1125
	return inet_ctl_sock_create(&net->dccp.v6_ctl_sk, PF_INET6,
				    SOCK_DCCP, IPPROTO_DCCP, net);
1126 1127
}

1128
static void __net_exit dccp_v6_exit_net(struct net *net)
1129
{
1130
	inet_ctl_sock_destroy(net->dccp.v6_ctl_sk);
1131 1132 1133 1134 1135 1136 1137
}

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

1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149
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);
1150

1151 1152 1153
	err = register_pernet_subsys(&dccp_v6_ops);
	if (err != 0)
		goto out_destroy_ctl_sock;
1154 1155
out:
	return err;
1156 1157

out_destroy_ctl_sock:
1158 1159
	inet6_del_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
	inet6_unregister_protosw(&dccp_v6_protosw);
1160 1161 1162 1163 1164 1165 1166
out_unregister_proto:
	proto_unregister(&dccp_v6_prot);
	goto out;
}

static void __exit dccp_v6_exit(void)
{
1167
	unregister_pernet_subsys(&dccp_v6_ops);
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
	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
 */
1181 1182
MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET6, 33, 6);
MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET6, 0, 6);
1183 1184 1185
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@mandriva.com>");
MODULE_DESCRIPTION("DCCPv6 - Datagram Congestion Controlled Protocol");