ipv6.c 31.7 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 32 33 34
#include <net/xfrm.h>

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

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

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

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

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

63
static inline void dccp_v6_send_check(struct sock *sk, struct sk_buff *skb)
64 65 66 67 68 69
{
	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);
70 71
}

A
Al Viro 已提交
72
static inline __u32 secure_dccpv6_sequence_number(__be32 *saddr, __be32 *daddr,
73
						  __be16 sport, __be16 dport   )
74
{
75 76 77 78 79
	return secure_tcpv6_sequence_number(saddr, daddr, sport, dport);
}

static inline __u32 dccp_v6_init_sequence(struct sk_buff *skb)
{
80 81
	return secure_dccpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
					     ipv6_hdr(skb)->saddr.s6_addr32,
82 83 84
					     dccp_hdr(skb)->dccph_dport,
					     dccp_hdr(skb)->dccph_sport     );

85 86 87
}

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

99 100
	if (skb->len < offset + sizeof(*dh) ||
	    skb->len < offset + __dccp_basic_hdr_len(dh)) {
101 102
		ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
				   ICMP6_MIB_INERRORS);
103 104 105
		return;
	}

106
	sk = inet6_lookup(net, &dccp_hashinfo,
107
			&hdr->daddr, dh->dccph_dport,
108
			&hdr->saddr, dh->dccph_sport, inet6_iif(skb));
109 110

	if (sk == NULL) {
111 112
		ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
				   ICMP6_MIB_INERRORS);
113 114 115 116
		return;
	}

	if (sk->sk_state == DCCP_TIME_WAIT) {
117
		inet_twsk_put(inet_twsk(sk));
118 119 120 121 122
		return;
	}

	bh_lock_sock(sk);
	if (sock_owned_by_user(sk))
123
		NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
124 125 126 127

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

128 129 130 131 132 133 134 135
	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;
	}

136 137 138 139 140 141 142 143 144 145 146 147 148 149
	np = inet6_sk(sk);

	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);
150
			struct flowi6 fl6;
151 152 153 154 155

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

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

173
		if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
			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 已提交
192
		if (req == NULL)
193 194
			goto out;

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

		if (seq != dccp_rsk(req)->dreq_iss) {
202
			NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
203 204 205 206 207 208 209 210
			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 已提交
211
			       It can, it SYNs are crossed. --ANK */
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
		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);
}


238 239
static int dccp_v6_send_response(struct sock *sk, struct request_sock *req,
				 struct request_values *rv_unused)
240 241 242 243 244
{
	struct inet6_request_sock *ireq6 = inet6_rsk(req);
	struct ipv6_pinfo *np = inet6_sk(sk);
	struct sk_buff *skb;
	struct ipv6_txoptions *opt = NULL;
245
	struct in6_addr *final_p, final;
246
	struct flowi6 fl6;
247
	int err = -1;
248
	struct dst_entry *dst;
249

250 251 252 253 254 255
	memset(&fl6, 0, sizeof(fl6));
	fl6.flowi6_proto = IPPROTO_DCCP;
	ipv6_addr_copy(&fl6.daddr, &ireq6->rmt_addr);
	ipv6_addr_copy(&fl6.saddr, &ireq6->loc_addr);
	fl6.flowlabel = 0;
	fl6.flowi6_oif = ireq6->iif;
256 257
	fl6.fl6_dport = inet_rsk(req)->rmt_port;
	fl6.fl6_sport = inet_rsk(req)->loc_port;
258
	security_req_classify_flow(req, flowi6_to_flowi(&fl6));
259

260
	opt = np->opt;
261

262
	final_p = fl6_update_dst(&fl6, opt, &final);
263

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

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

275 276 277
		dh->dccph_checksum = dccp_v6_csum_finish(skb,
							 &ireq6->loc_addr,
							 &ireq6->rmt_addr);
278 279
		ipv6_addr_copy(&fl6.daddr, &ireq6->rmt_addr);
		err = ip6_xmit(sk, skb, &fl6, opt);
280
		err = net_xmit_eval(err);
281 282 283
	}

done:
A
Arnaldo Carvalho de Melo 已提交
284
	if (opt != NULL && opt != np->opt)
285
		sock_kfree_s(sk, opt, opt->tot_len);
286
	dst_release(dst);
287 288 289 290 291
	return err;
}

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

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

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

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

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

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

320 321 322
	memset(&fl6, 0, sizeof(fl6));
	ipv6_addr_copy(&fl6.daddr, &rxip6h->saddr);
	ipv6_addr_copy(&fl6.saddr, &rxip6h->daddr);
323

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

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

	kfree_skb(skb);
}

343 344 345 346 347 348 349 350 351
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,
};

352 353 354
static struct sock *dccp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
{
	const struct dccp_hdr *dh = dccp_hdr(skb);
355
	const struct ipv6hdr *iph = ipv6_hdr(skb);
356 357 358 359 360 361 362 363 364 365 366
	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);

367
	nsk = __inet6_lookup_established(sock_net(sk), &dccp_hashinfo,
368 369 370 371 372 373 374 375
					 &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;
		}
376
		inet_twsk_put(inet_twsk(nsk));
377 378 379 380 381 382 383 384 385 386 387 388
		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);
389
	const __be32 service = dccp_hdr_request(skb)->dccph_req_service;
390 391 392 393 394 395
	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))
396
		return 0;	/* discard, don't send a reset here */
397 398

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

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

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

416 417
	if (dccp_reqsk_init(req, dccp_sk(sk), skb))
		goto drop_and_free;
418

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

423 424 425
	if (security_inet_conn_request(sk, skb, req))
		goto drop_and_free;

426
	ireq6 = inet6_rsk(req);
427 428
	ipv6_addr_copy(&ireq6->rmt_addr, &ipv6_hdr(skb)->saddr);
	ipv6_addr_copy(&ireq6->loc_addr, &ipv6_hdr(skb)->daddr);
429 430 431 432 433 434 435 436 437 438 439 440 441 442

	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 已提交
443
	/*
444 445
	 * Step 3: Process LISTEN state
	 *
446
	 *   Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookie
447
	 *
448 449
	 *   In fact we defer setting S.GSR, S.SWL, S.SWH to
	 *   dccp_create_openreq_child.
450 451
	 */
	dreq->dreq_isr	   = dcb->dccpd_seq;
452
	dreq->dreq_iss	   = dccp_v6_init_sequence(skb);
453 454
	dreq->dreq_service = service;

455
	if (dccp_v6_send_response(sk, req, NULL))
456 457 458 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
		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;
	struct ipv6_txoptions *opt;

	if (skb->protocol == htons(ETH_P_IP)) {
		/*
		 *	v6 mapped
		 */
		newsk = dccp_v4_request_recv_sock(sk, skb, req, dst);
A
Arnaldo Carvalho de Melo 已提交
485
		if (newsk == NULL)
486 487 488 489 490 491 492 493 494
			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 已提交
495
		ipv6_addr_set_v4mapped(newinet->inet_daddr, &newnp->daddr);
496

E
Eric Dumazet 已提交
497
		ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
498 499 500 501 502 503 504 505

		ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);

		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);
506
		newnp->mcast_hops  = ipv6_hdr(skb)->hop_limit;
507 508 509 510 511 512 513 514 515 516 517

		/*
		 * 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.
		 */
518
		dccp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
519 520 521 522 523 524 525 526 527 528

		return newsk;
	}

	opt = np->opt;

	if (sk_acceptq_is_full(sk))
		goto out_overflow;

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

		memset(&fl6, 0, sizeof(fl6));
		fl6.flowi6_proto = IPPROTO_DCCP;
		ipv6_addr_copy(&fl6.daddr, &ireq6->rmt_addr);
		final_p = fl6_update_dst(&fl6, opt, &final);
		ipv6_addr_copy(&fl6.saddr, &ireq6->loc_addr);
		fl6.flowi6_oif = sk->sk_bound_dev_if;
538 539
		fl6.fl6_dport = inet_rsk(req)->rmt_port;
		fl6.fl6_sport = inet_rsk(req)->loc_port;
540 541 542
		security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));

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

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

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

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

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

	ipv6_addr_copy(&newnp->daddr, &ireq6->rmt_addr);
	ipv6_addr_copy(&newnp->saddr, &ireq6->loc_addr);
	ipv6_addr_copy(&newnp->rcv_saddr, &ireq6->loc_addr);
	newsk->sk_bound_dev_if = ireq6->iif;

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

	   First: no IPv4 options.
	 */
576
	newinet->inet_opt = NULL;
577 578 579 580 581 582 583 584 585 586 587 588 589 590 591

	/* 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);
		kfree_skb(ireq6->pktopts);
		ireq6->pktopts = NULL;
		if (newnp->pktoptions)
			skb_set_owner_r(newnp->pktoptions, newsk);
	}
	newnp->opt	  = NULL;
	newnp->mcast_oif  = inet6_iif(skb);
592
	newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
593

A
Arnaldo Carvalho de Melo 已提交
594 595 596 597 598
	/*
	 * 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.
599
	 */
A
Arnaldo Carvalho de Melo 已提交
600
	if (opt != NULL) {
601 602 603 604 605
		newnp->opt = ipv6_dup_options(newsk, opt);
		if (opt != np->opt)
			sock_kfree_s(sk, opt, opt->tot_len);
	}

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

	dccp_sync_mss(newsk, dst_mtu(dst));

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

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

	return newsk;

out_overflow:
625
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
626 627
out_nonewsk:
	dst_release(dst);
628
out:
629
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
A
Arnaldo Carvalho de Melo 已提交
630
	if (opt != NULL && opt != np->opt)
631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
		sock_kfree_s(sk, opt, opt->tot_len);
	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);

659
	if (sk_filter(sk, skb))
660 661 662
		goto discard;

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

	/* 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.
678
					       --ANK (980728)
679 680
	 */
	if (np->rxopt.all)
681 682 683 684
	/*
	 * FIXME: Add handling of IPV6_PKTOPTIONS skb. See the comments below
	 *        (wrt ipv6_pktopions) and net/ipv6/tcp_ipv6.c for an example.
	 */
685 686 687 688 689
		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 已提交
690
		if (opt_skb) {
691
			/* XXX This is where we would goto ipv6_pktoptions. */
D
David S. Miller 已提交
692 693
			__kfree_skb(opt_skb);
		}
694 695 696
		return 0;
	}

697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720
	/*
	 *  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 已提交
721
	if (sk->sk_state == DCCP_LISTEN) {
722 723
		struct sock *nsk = dccp_v6_hnd_req(sk, skb);

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

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

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

757
static int dccp_v6_rcv(struct sk_buff *skb)
758 759 760
{
	const struct dccp_hdr *dh;
	struct sock *sk;
761
	int min_cov;
762

763
	/* Step 1: Check header basics */
764 765 766 767

	if (dccp_invalid_packet(skb))
		goto discard_it;

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

775 776
	dh = dccp_hdr(skb);

777
	DCCP_SKB_CB(skb)->dccpd_seq  = dccp_hdr_seq(dh);
778 779 780 781 782 783 784 785
	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:
786
	 *	Look up flow ID in table and get corresponding socket */
787 788
	sk = __inet6_lookup_skb(&dccp_hashinfo, skb,
			        dh->dccph_sport, dh->dccph_dport);
A
Arnaldo Carvalho de Melo 已提交
789
	/*
790
	 * Step 2:
791
	 *	If no socket ...
792
	 */
793 794 795
	if (sk == NULL) {
		dccp_pr_debug("failed to look up flow ID in table and "
			      "get corresponding socket\n");
796
		goto no_dccp_socket;
797
	}
798

A
Arnaldo Carvalho de Melo 已提交
799
	/*
800
	 * Step 2:
801
	 *	... or S.state == TIMEWAIT,
802 803 804
	 *		Generate Reset(No Connection) unless P.type == Reset
	 *		Drop packet and return
	 */
805 806 807 808 809
	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;
	}
810

811 812
	/*
	 * RFC 4340, sec. 9.2.1: Minimum Checksum Coverage
813 814
	 *	o if MinCsCov = 0, only packets with CsCov = 0 are accepted
	 *	o if MinCsCov > 0, also accept packets with CsCov >= MinCsCov
815 816 817 818 819 820 821 822 823
	 */
	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;
	}

824 825 826
	if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
		goto discard_and_relse;

827
	return sk_receive_skb(sk, skb, 1) ? -1 : 0;
828 829 830 831 832 833

no_dccp_socket:
	if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
		goto discard_it;
	/*
	 * Step 2:
834
	 *	If no socket ...
835 836 837 838 839 840
	 *		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;
841
		dccp_v6_ctl_send_reset(sk, skb);
842 843
	}

844
discard_it:
845 846 847 848 849 850 851 852
	kfree_skb(skb);
	return 0;

discard_and_relse:
	sock_put(sk);
	goto discard_it;
}

853 854 855 856 857 858 859 860
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);
861
	struct in6_addr *saddr = NULL, *final_p, final;
862
	struct flowi6 fl6;
863 864 865 866 867 868 869 870 871 872 873 874
	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;

875
	memset(&fl6, 0, sizeof(fl6));
876 877

	if (np->sndflow) {
878 879 880
		fl6.flowlabel = usin->sin6_flowinfo & IPV6_FLOWINFO_MASK;
		IP6_ECN_flow_init(fl6.flowlabel);
		if (fl6.flowlabel & IPV6_FLOWLABEL_MASK) {
881
			struct ip6_flowlabel *flowlabel;
882
			flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
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 914 915 916 917 918
			if (flowlabel == NULL)
				return -EINVAL;
			ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
			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;
	}

	ipv6_addr_copy(&np->daddr, &usin->sin6_addr);
919
	np->flow_label = fl6.flowlabel;
920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946

	/*
	 * 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 已提交
947 948
		ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
		ipv6_addr_set_v4mapped(inet->inet_rcv_saddr, &np->rcv_saddr);
949 950 951 952 953 954 955

		return err;
	}

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

956 957 958 959
	fl6.flowi6_proto = IPPROTO_DCCP;
	ipv6_addr_copy(&fl6.daddr, &np->daddr);
	ipv6_addr_copy(&fl6.saddr, saddr ? saddr : &np->saddr);
	fl6.flowi6_oif = sk->sk_bound_dev_if;
960 961
	fl6.fl6_dport = usin->sin6_port;
	fl6.fl6_sport = inet->inet_sport;
962
	security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
963

964
	final_p = fl6_update_dst(&fl6, np->opt, &final);
965

966
	dst = ip6_dst_lookup_flow(sk, &fl6, final_p, true);
967 968
	if (IS_ERR(dst)) {
		err = PTR_ERR(dst);
969
		goto failure;
970
	}
971 972

	if (saddr == NULL) {
973
		saddr = &fl6.saddr;
974 975 976 977 978
		ipv6_addr_copy(&np->rcv_saddr, saddr);
	}

	/* set the source address */
	ipv6_addr_copy(&np->saddr, saddr);
E
Eric Dumazet 已提交
979
	inet->inet_rcv_saddr = LOOPBACK4_IPV6;
980 981 982 983 984 985 986 987

	__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 已提交
988
	inet->inet_dport = usin->sin6_port;
989 990 991 992 993

	dccp_set_state(sk, DCCP_REQUESTING);
	err = inet6_hash_connect(&dccp_death_row, sk);
	if (err)
		goto late_failure;
994 995 996

	dp->dccps_iss = secure_dccpv6_sequence_number(np->saddr.s6_addr32,
						      np->daddr.s6_addr32,
E
Eric Dumazet 已提交
997 998
						      inet->inet_sport,
						      inet->inet_dport);
999 1000 1001 1002 1003 1004 1005 1006 1007 1008
	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 已提交
1009
	inet->inet_dport = 0;
1010 1011 1012 1013
	sk->sk_route_caps = 0;
	return err;
}

1014
static const struct inet_connection_sock_af_ops dccp_ipv6_af_ops = {
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024
	.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),
1025
	.bind_conflict	   = inet6_csk_bind_conflict,
1026
#ifdef CONFIG_COMPAT
1027 1028
	.compat_setsockopt = compat_ipv6_setsockopt,
	.compat_getsockopt = compat_ipv6_getsockopt,
1029
#endif
1030 1031 1032 1033 1034
};

/*
 *	DCCP over IPv4 via INET6 API
 */
1035
static const struct inet_connection_sock_af_ops dccp_ipv6_mapped = {
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
	.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),
1046
#ifdef CONFIG_COMPAT
1047 1048
	.compat_setsockopt = compat_ipv6_setsockopt,
	.compat_getsockopt = compat_ipv6_getsockopt,
1049
#endif
1050 1051 1052 1053 1054 1055 1056
};

/* 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)
{
1057 1058
	static __u8 dccp_v6_ctl_sock_initialized;
	int err = dccp_init_sock(sk, dccp_v6_ctl_sock_initialized);
1059

1060 1061 1062
	if (err == 0) {
		if (unlikely(!dccp_v6_ctl_sock_initialized))
			dccp_v6_ctl_sock_initialized = 1;
1063
		inet_csk(sk)->icsk_af_ops = &dccp_ipv6_af_ops;
1064
	}
1065 1066 1067 1068

	return err;
}

1069
static void dccp_v6_destroy_sock(struct sock *sk)
1070
{
1071
	dccp_destroy_sock(sk);
1072
	inet6_destroy_sock(sk);
1073 1074
}

1075 1076 1077 1078
static struct timewait_sock_ops dccp6_timewait_sock_ops = {
	.twsk_obj_size	= sizeof(struct dccp6_timewait_sock),
};

1079
static struct proto dccp_v6_prot = {
1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
	.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,
1093
	.unhash		   = inet_unhash,
1094
	.accept		   = inet_csk_accept,
1095
	.get_port	   = inet_csk_get_port,
1096 1097 1098 1099 1100
	.shutdown	   = dccp_shutdown,
	.destroy	   = dccp_v6_destroy_sock,
	.orphan_count	   = &dccp_orphan_count,
	.max_header	   = MAX_DCCP_HEADER,
	.obj_size	   = sizeof(struct dccp6_sock),
1101
	.slab_flags	   = SLAB_DESTROY_BY_RCU,
1102 1103
	.rsk_prot	   = &dccp6_request_sock_ops,
	.twsk_prot	   = &dccp6_timewait_sock_ops,
1104
	.h.hashinfo	   = &dccp_hashinfo,
1105
#ifdef CONFIG_COMPAT
1106 1107
	.compat_setsockopt = compat_dccp_setsockopt,
	.compat_getsockopt = compat_dccp_getsockopt,
1108
#endif
1109 1110
};

1111
static const struct inet6_protocol dccp_v6_protocol = {
A
Arnaldo Carvalho de Melo 已提交
1112 1113 1114
	.handler	= dccp_v6_rcv,
	.err_handler	= dccp_v6_err,
	.flags		= INET6_PROTO_NOPOLICY | INET6_PROTO_FINAL,
1115 1116
};

1117
static const struct proto_ops inet6_dccp_ops = {
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135
	.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,
1136
#ifdef CONFIG_COMPAT
1137 1138
	.compat_setsockopt = compat_sock_common_setsockopt,
	.compat_getsockopt = compat_sock_common_getsockopt,
1139
#endif
1140 1141 1142 1143 1144 1145 1146
};

static struct inet_protosw dccp_v6_protosw = {
	.type		= SOCK_DCCP,
	.protocol	= IPPROTO_DCCP,
	.prot		= &dccp_v6_prot,
	.ops		= &inet6_dccp_ops,
1147
	.flags		= INET_PROTOSW_ICSK,
1148 1149
};

1150
static int __net_init dccp_v6_init_net(struct net *net)
1151
{
1152 1153
	if (dccp_hashinfo.bhash == NULL)
		return -ESOCKTNOSUPPORT;
1154

1155 1156
	return inet_ctl_sock_create(&net->dccp.v6_ctl_sk, PF_INET6,
				    SOCK_DCCP, IPPROTO_DCCP, net);
1157 1158
}

1159
static void __net_exit dccp_v6_exit_net(struct net *net)
1160
{
1161
	inet_ctl_sock_destroy(net->dccp.v6_ctl_sk);
1162 1163 1164 1165 1166 1167 1168
}

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

1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
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);
1181

1182 1183 1184
	err = register_pernet_subsys(&dccp_v6_ops);
	if (err != 0)
		goto out_destroy_ctl_sock;
1185 1186
out:
	return err;
1187 1188

out_destroy_ctl_sock:
1189 1190
	inet6_del_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
	inet6_unregister_protosw(&dccp_v6_protosw);
1191 1192 1193 1194 1195 1196 1197
out_unregister_proto:
	proto_unregister(&dccp_v6_prot);
	goto out;
}

static void __exit dccp_v6_exit(void)
{
1198
	unregister_pernet_subsys(&dccp_v6_ops);
1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211
	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
 */
1212 1213
MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET6, 33, 6);
MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET6, 0, 6);
1214 1215 1216
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@mandriva.com>");
MODULE_DESCRIPTION("DCCPv6 - Datagram Congestion Controlled Protocol");