Linux Audio

Check our new training course

Linux debugging, profiling, tracing and performance analysis training

Mar 24-27, 2025, special US time zones
Register
Loading...
v4.17
 
   1/* SCTP kernel implementation
   2 * (C) Copyright IBM Corp. 2002, 2004
   3 * Copyright (c) 2001 Nokia, Inc.
   4 * Copyright (c) 2001 La Monte H.P. Yarroll
   5 * Copyright (c) 2002-2003 Intel Corp.
   6 *
   7 * This file is part of the SCTP kernel implementation
   8 *
   9 * SCTP over IPv6.
  10 *
  11 * This SCTP implementation is free software;
  12 * you can redistribute it and/or modify it under the terms of
  13 * the GNU General Public License as published by
  14 * the Free Software Foundation; either version 2, or (at your option)
  15 * any later version.
  16 *
  17 * This SCTP implementation is distributed in the hope that it
  18 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  19 *		   ************************
  20 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  21 * See the GNU General Public License for more details.
  22 *
  23 * You should have received a copy of the GNU General Public License
  24 * along with GNU CC; see the file COPYING.  If not, see
  25 * <http://www.gnu.org/licenses/>.
  26 *
  27 * Please send any bug reports or fixes you make to the
  28 * email address(es):
  29 *    lksctp developers <linux-sctp@vger.kernel.org>
  30 *
  31 * Written or modified by:
  32 *    Le Yanqun		    <yanqun.le@nokia.com>
  33 *    Hui Huang		    <hui.huang@nokia.com>
  34 *    La Monte H.P. Yarroll <piggy@acm.org>
  35 *    Sridhar Samudrala	    <sri@us.ibm.com>
  36 *    Jon Grimm		    <jgrimm@us.ibm.com>
  37 *    Ardelle Fan	    <ardelle.fan@intel.com>
  38 *
  39 * Based on:
  40 *	linux/net/ipv6/tcp_ipv6.c
  41 */
  42
  43#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  44
  45#include <linux/module.h>
  46#include <linux/errno.h>
  47#include <linux/types.h>
  48#include <linux/socket.h>
  49#include <linux/sockios.h>
  50#include <linux/net.h>
  51#include <linux/in.h>
  52#include <linux/in6.h>
  53#include <linux/netdevice.h>
  54#include <linux/init.h>
  55#include <linux/ipsec.h>
  56#include <linux/slab.h>
  57
  58#include <linux/ipv6.h>
  59#include <linux/icmpv6.h>
  60#include <linux/random.h>
  61#include <linux/seq_file.h>
  62
  63#include <net/protocol.h>
  64#include <net/ndisc.h>
  65#include <net/ip.h>
  66#include <net/ipv6.h>
  67#include <net/transp_v6.h>
  68#include <net/addrconf.h>
  69#include <net/ip6_route.h>
  70#include <net/inet_common.h>
  71#include <net/inet_ecn.h>
  72#include <net/sctp/sctp.h>
  73
  74#include <linux/uaccess.h>
  75
  76static inline int sctp_v6_addr_match_len(union sctp_addr *s1,
  77					 union sctp_addr *s2);
  78static void sctp_v6_to_addr(union sctp_addr *addr, struct in6_addr *saddr,
  79			      __be16 port);
  80static int sctp_v6_cmp_addr(const union sctp_addr *addr1,
  81			    const union sctp_addr *addr2);
  82
  83/* Event handler for inet6 address addition/deletion events.
  84 * The sctp_local_addr_list needs to be protocted by a spin lock since
  85 * multiple notifiers (say IPv4 and IPv6) may be running at the same
  86 * time and thus corrupt the list.
  87 * The reader side is protected with RCU.
  88 */
  89static int sctp_inet6addr_event(struct notifier_block *this, unsigned long ev,
  90				void *ptr)
  91{
  92	struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
  93	struct sctp_sockaddr_entry *addr = NULL;
  94	struct sctp_sockaddr_entry *temp;
  95	struct net *net = dev_net(ifa->idev->dev);
  96	int found = 0;
  97
  98	switch (ev) {
  99	case NETDEV_UP:
 100		addr = kmalloc(sizeof(struct sctp_sockaddr_entry), GFP_ATOMIC);
 101		if (addr) {
 102			addr->a.v6.sin6_family = AF_INET6;
 103			addr->a.v6.sin6_port = 0;
 104			addr->a.v6.sin6_addr = ifa->addr;
 105			addr->a.v6.sin6_scope_id = ifa->idev->dev->ifindex;
 106			addr->valid = 1;
 107			spin_lock_bh(&net->sctp.local_addr_lock);
 108			list_add_tail_rcu(&addr->list, &net->sctp.local_addr_list);
 109			sctp_addr_wq_mgmt(net, addr, SCTP_ADDR_NEW);
 110			spin_unlock_bh(&net->sctp.local_addr_lock);
 111		}
 112		break;
 113	case NETDEV_DOWN:
 114		spin_lock_bh(&net->sctp.local_addr_lock);
 115		list_for_each_entry_safe(addr, temp,
 116					&net->sctp.local_addr_list, list) {
 117			if (addr->a.sa.sa_family == AF_INET6 &&
 118					ipv6_addr_equal(&addr->a.v6.sin6_addr,
 119						&ifa->addr)) {
 120				sctp_addr_wq_mgmt(net, addr, SCTP_ADDR_DEL);
 121				found = 1;
 122				addr->valid = 0;
 123				list_del_rcu(&addr->list);
 124				break;
 125			}
 126		}
 127		spin_unlock_bh(&net->sctp.local_addr_lock);
 128		if (found)
 129			kfree_rcu(addr, rcu);
 130		break;
 131	}
 132
 133	return NOTIFY_DONE;
 134}
 135
 136static struct notifier_block sctp_inet6addr_notifier = {
 137	.notifier_call = sctp_inet6addr_event,
 138};
 139
 140/* ICMP error handler. */
 141static void sctp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
 142			u8 type, u8 code, int offset, __be32 info)
 143{
 144	struct inet6_dev *idev;
 145	struct sock *sk;
 146	struct sctp_association *asoc;
 147	struct sctp_transport *transport;
 148	struct ipv6_pinfo *np;
 149	__u16 saveip, savesctp;
 150	int err;
 151	struct net *net = dev_net(skb->dev);
 152
 153	idev = in6_dev_get(skb->dev);
 154
 155	/* Fix up skb to look at the embedded net header. */
 156	saveip	 = skb->network_header;
 157	savesctp = skb->transport_header;
 158	skb_reset_network_header(skb);
 159	skb_set_transport_header(skb, offset);
 160	sk = sctp_err_lookup(net, AF_INET6, skb, sctp_hdr(skb), &asoc, &transport);
 161	/* Put back, the original pointers. */
 162	skb->network_header   = saveip;
 163	skb->transport_header = savesctp;
 164	if (!sk) {
 165		__ICMP6_INC_STATS(net, idev, ICMP6_MIB_INERRORS);
 
 166		goto out;
 167	}
 168
 169	/* Warning:  The sock lock is held.  Remember to call
 170	 * sctp_err_finish!
 171	 */
 172
 173	switch (type) {
 174	case ICMPV6_PKT_TOOBIG:
 175		if (ip6_sk_accept_pmtu(sk))
 176			sctp_icmp_frag_needed(sk, asoc, transport, ntohl(info));
 177		goto out_unlock;
 178	case ICMPV6_PARAMPROB:
 179		if (ICMPV6_UNK_NEXTHDR == code) {
 180			sctp_icmp_proto_unreachable(sk, asoc, transport);
 181			goto out_unlock;
 182		}
 183		break;
 184	case NDISC_REDIRECT:
 185		sctp_icmp_redirect(sk, transport, skb);
 186		goto out_unlock;
 187	default:
 188		break;
 189	}
 190
 191	np = inet6_sk(sk);
 192	icmpv6_err_convert(type, code, &err);
 193	if (!sock_owned_by_user(sk) && np->recverr) {
 194		sk->sk_err = err;
 195		sk->sk_error_report(sk);
 196	} else {  /* Only an error on timeout */
 197		sk->sk_err_soft = err;
 198	}
 199
 200out_unlock:
 201	sctp_err_finish(sk, transport);
 202out:
 203	if (likely(idev != NULL))
 204		in6_dev_put(idev);
 
 
 205}
 206
 207static int sctp_v6_xmit(struct sk_buff *skb, struct sctp_transport *transport)
 208{
 209	struct sock *sk = skb->sk;
 210	struct ipv6_pinfo *np = inet6_sk(sk);
 211	struct flowi6 *fl6 = &transport->fl.u.ip6;
 
 212	int res;
 213
 214	pr_debug("%s: skb:%p, len:%d, src:%pI6 dst:%pI6\n", __func__, skb,
 215		 skb->len, &fl6->saddr, &fl6->daddr);
 216
 217	IP6_ECN_flow_xmit(sk, fl6->flowlabel);
 
 
 
 
 218
 219	if (!(transport->param_flags & SPP_PMTUD_ENABLE))
 220		skb->ignore_df = 1;
 221
 222	SCTP_INC_STATS(sock_net(sk), SCTP_MIB_OUTSCTPPACKS);
 223
 224	rcu_read_lock();
 225	res = ip6_xmit(sk, skb, fl6, sk->sk_mark, rcu_dereference(np->opt),
 226		       np->tclass);
 227	rcu_read_unlock();
 228	return res;
 229}
 230
 231/* Returns the dst cache entry for the given source and destination ip
 232 * addresses.
 233 */
 234static void sctp_v6_get_dst(struct sctp_transport *t, union sctp_addr *saddr,
 235			    struct flowi *fl, struct sock *sk)
 236{
 237	struct sctp_association *asoc = t->asoc;
 238	struct dst_entry *dst = NULL;
 239	struct flowi6 *fl6 = &fl->u.ip6;
 240	struct sctp_bind_addr *bp;
 241	struct ipv6_pinfo *np = inet6_sk(sk);
 242	struct sctp_sockaddr_entry *laddr;
 243	union sctp_addr *daddr = &t->ipaddr;
 244	union sctp_addr dst_saddr;
 245	struct in6_addr *final_p, final;
 246	enum sctp_scope scope;
 247	__u8 matchlen = 0;
 248
 249	memset(fl6, 0, sizeof(struct flowi6));
 250	fl6->daddr = daddr->v6.sin6_addr;
 251	fl6->fl6_dport = daddr->v6.sin6_port;
 252	fl6->flowi6_proto = IPPROTO_SCTP;
 253	if (ipv6_addr_type(&daddr->v6.sin6_addr) & IPV6_ADDR_LINKLOCAL)
 254		fl6->flowi6_oif = daddr->v6.sin6_scope_id;
 255	else if (asoc)
 256		fl6->flowi6_oif = asoc->base.sk->sk_bound_dev_if;
 
 
 
 
 
 
 
 
 
 
 
 257
 258	pr_debug("%s: dst=%pI6 ", __func__, &fl6->daddr);
 259
 260	if (asoc)
 261		fl6->fl6_sport = htons(asoc->base.bind_addr.port);
 262
 263	if (saddr) {
 264		fl6->saddr = saddr->v6.sin6_addr;
 265		fl6->fl6_sport = saddr->v6.sin6_port;
 
 266
 267		pr_debug("src=%pI6 - ", &fl6->saddr);
 268	}
 269
 270	rcu_read_lock();
 271	final_p = fl6_update_dst(fl6, rcu_dereference(np->opt), &final);
 272	rcu_read_unlock();
 273
 274	dst = ip6_dst_lookup_flow(sk, fl6, final_p);
 275	if (!asoc || saddr)
 276		goto out;
 277
 278	bp = &asoc->base.bind_addr;
 279	scope = sctp_scope(daddr);
 280	/* ip6_dst_lookup has filled in the fl6->saddr for us.  Check
 281	 * to see if we can use it.
 282	 */
 283	if (!IS_ERR(dst)) {
 284		/* Walk through the bind address list and look for a bind
 285		 * address that matches the source address of the returned dst.
 286		 */
 287		sctp_v6_to_addr(&dst_saddr, &fl6->saddr, htons(bp->port));
 288		rcu_read_lock();
 289		list_for_each_entry_rcu(laddr, &bp->address_list, list) {
 290			if (!laddr->valid || laddr->state == SCTP_ADDR_DEL ||
 291			    (laddr->state != SCTP_ADDR_SRC &&
 292			     !asoc->src_out_of_asoc_ok))
 293				continue;
 294
 295			/* Do not compare against v4 addrs */
 296			if ((laddr->a.sa.sa_family == AF_INET6) &&
 297			    (sctp_v6_cmp_addr(&dst_saddr, &laddr->a))) {
 298				rcu_read_unlock();
 299				goto out;
 300			}
 301		}
 302		rcu_read_unlock();
 303		/* None of the bound addresses match the source address of the
 304		 * dst. So release it.
 305		 */
 306		dst_release(dst);
 307		dst = NULL;
 308	}
 309
 310	/* Walk through the bind address list and try to get the
 311	 * best source address for a given destination.
 312	 */
 313	rcu_read_lock();
 314	list_for_each_entry_rcu(laddr, &bp->address_list, list) {
 315		struct dst_entry *bdst;
 316		__u8 bmatchlen;
 317
 318		if (!laddr->valid ||
 319		    laddr->state != SCTP_ADDR_SRC ||
 320		    laddr->a.sa.sa_family != AF_INET6 ||
 321		    scope > sctp_scope(&laddr->a))
 322			continue;
 323
 324		fl6->saddr = laddr->a.v6.sin6_addr;
 325		fl6->fl6_sport = laddr->a.v6.sin6_port;
 326		final_p = fl6_update_dst(fl6, rcu_dereference(np->opt), &final);
 327		bdst = ip6_dst_lookup_flow(sk, fl6, final_p);
 328
 329		if (IS_ERR(bdst))
 330			continue;
 331
 332		if (ipv6_chk_addr(dev_net(bdst->dev),
 333				  &laddr->a.v6.sin6_addr, bdst->dev, 1)) {
 334			if (!IS_ERR_OR_NULL(dst))
 335				dst_release(dst);
 336			dst = bdst;
 337			break;
 338		}
 339
 340		bmatchlen = sctp_v6_addr_match_len(daddr, &laddr->a);
 341		if (matchlen > bmatchlen) {
 342			dst_release(bdst);
 343			continue;
 344		}
 345
 346		if (!IS_ERR_OR_NULL(dst))
 347			dst_release(dst);
 348		dst = bdst;
 349		matchlen = bmatchlen;
 350	}
 351	rcu_read_unlock();
 352
 353out:
 354	if (!IS_ERR_OR_NULL(dst)) {
 355		struct rt6_info *rt;
 356
 357		rt = (struct rt6_info *)dst;
 358		t->dst = dst;
 359		t->dst_cookie = rt6_get_cookie(rt);
 360		pr_debug("rt6_dst:%pI6/%d rt6_src:%pI6\n",
 361			 &rt->rt6i_dst.addr, rt->rt6i_dst.plen,
 362			 &fl6->saddr);
 363	} else {
 364		t->dst = NULL;
 365
 366		pr_debug("no route\n");
 367	}
 368}
 369
 370/* Returns the number of consecutive initial bits that match in the 2 ipv6
 371 * addresses.
 372 */
 373static inline int sctp_v6_addr_match_len(union sctp_addr *s1,
 374					 union sctp_addr *s2)
 375{
 376	return ipv6_addr_diff(&s1->v6.sin6_addr, &s2->v6.sin6_addr);
 377}
 378
 379/* Fills in the source address(saddr) based on the destination address(daddr)
 380 * and asoc's bind address list.
 381 */
 382static void sctp_v6_get_saddr(struct sctp_sock *sk,
 383			      struct sctp_transport *t,
 384			      struct flowi *fl)
 385{
 386	struct flowi6 *fl6 = &fl->u.ip6;
 387	union sctp_addr *saddr = &t->saddr;
 388
 389	pr_debug("%s: asoc:%p dst:%p\n", __func__, t->asoc, t->dst);
 390
 391	if (t->dst) {
 392		saddr->v6.sin6_family = AF_INET6;
 393		saddr->v6.sin6_addr = fl6->saddr;
 394	}
 395}
 396
 397/* Make a copy of all potential local addresses. */
 398static void sctp_v6_copy_addrlist(struct list_head *addrlist,
 399				  struct net_device *dev)
 400{
 401	struct inet6_dev *in6_dev;
 402	struct inet6_ifaddr *ifp;
 403	struct sctp_sockaddr_entry *addr;
 404
 405	rcu_read_lock();
 406	if ((in6_dev = __in6_dev_get(dev)) == NULL) {
 407		rcu_read_unlock();
 408		return;
 409	}
 410
 411	read_lock_bh(&in6_dev->lock);
 412	list_for_each_entry(ifp, &in6_dev->addr_list, if_list) {
 413		/* Add the address to the local list.  */
 414		addr = kzalloc(sizeof(*addr), GFP_ATOMIC);
 415		if (addr) {
 416			addr->a.v6.sin6_family = AF_INET6;
 417			addr->a.v6.sin6_port = 0;
 418			addr->a.v6.sin6_addr = ifp->addr;
 419			addr->a.v6.sin6_scope_id = dev->ifindex;
 420			addr->valid = 1;
 421			INIT_LIST_HEAD(&addr->list);
 422			list_add_tail(&addr->list, addrlist);
 423		}
 424	}
 425
 426	read_unlock_bh(&in6_dev->lock);
 427	rcu_read_unlock();
 428}
 429
 430/* Copy over any ip options */
 431static void sctp_v6_copy_ip_options(struct sock *sk, struct sock *newsk)
 432{
 433	struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
 434	struct ipv6_txoptions *opt;
 435
 436	newnp = inet6_sk(newsk);
 437
 438	rcu_read_lock();
 439	opt = rcu_dereference(np->opt);
 440	if (opt) {
 441		opt = ipv6_dup_options(newsk, opt);
 442		if (!opt)
 443			pr_err("%s: Failed to copy ip options\n", __func__);
 444	}
 445	RCU_INIT_POINTER(newnp->opt, opt);
 446	rcu_read_unlock();
 447}
 448
 449/* Account for the IP options */
 450static int sctp_v6_ip_options_len(struct sock *sk)
 451{
 452	struct ipv6_pinfo *np = inet6_sk(sk);
 453	struct ipv6_txoptions *opt;
 454	int len = 0;
 455
 456	rcu_read_lock();
 457	opt = rcu_dereference(np->opt);
 458	if (opt)
 459		len = opt->opt_flen + opt->opt_nflen;
 460
 461	rcu_read_unlock();
 462	return len;
 463}
 464
 465/* Initialize a sockaddr_storage from in incoming skb. */
 466static void sctp_v6_from_skb(union sctp_addr *addr, struct sk_buff *skb,
 467			     int is_saddr)
 468{
 469	/* Always called on head skb, so this is safe */
 470	struct sctphdr *sh = sctp_hdr(skb);
 471	struct sockaddr_in6 *sa = &addr->v6;
 472
 473	addr->v6.sin6_family = AF_INET6;
 474	addr->v6.sin6_flowinfo = 0; /* FIXME */
 475	addr->v6.sin6_scope_id = ((struct inet6_skb_parm *)skb->cb)->iif;
 476
 477	if (is_saddr) {
 478		sa->sin6_port = sh->source;
 479		sa->sin6_addr = ipv6_hdr(skb)->saddr;
 480	} else {
 481		sa->sin6_port = sh->dest;
 482		sa->sin6_addr = ipv6_hdr(skb)->daddr;
 483	}
 484}
 485
 486/* Initialize an sctp_addr from a socket. */
 487static void sctp_v6_from_sk(union sctp_addr *addr, struct sock *sk)
 488{
 489	addr->v6.sin6_family = AF_INET6;
 490	addr->v6.sin6_port = 0;
 491	addr->v6.sin6_addr = sk->sk_v6_rcv_saddr;
 492}
 493
 494/* Initialize sk->sk_rcv_saddr from sctp_addr. */
 495static void sctp_v6_to_sk_saddr(union sctp_addr *addr, struct sock *sk)
 496{
 497	if (addr->sa.sa_family == AF_INET) {
 498		sk->sk_v6_rcv_saddr.s6_addr32[0] = 0;
 499		sk->sk_v6_rcv_saddr.s6_addr32[1] = 0;
 500		sk->sk_v6_rcv_saddr.s6_addr32[2] = htonl(0x0000ffff);
 501		sk->sk_v6_rcv_saddr.s6_addr32[3] =
 502			addr->v4.sin_addr.s_addr;
 503	} else {
 504		sk->sk_v6_rcv_saddr = addr->v6.sin6_addr;
 505	}
 506}
 507
 508/* Initialize sk->sk_daddr from sctp_addr. */
 509static void sctp_v6_to_sk_daddr(union sctp_addr *addr, struct sock *sk)
 510{
 511	if (addr->sa.sa_family == AF_INET) {
 512		sk->sk_v6_daddr.s6_addr32[0] = 0;
 513		sk->sk_v6_daddr.s6_addr32[1] = 0;
 514		sk->sk_v6_daddr.s6_addr32[2] = htonl(0x0000ffff);
 515		sk->sk_v6_daddr.s6_addr32[3] = addr->v4.sin_addr.s_addr;
 516	} else {
 517		sk->sk_v6_daddr = addr->v6.sin6_addr;
 518	}
 519}
 520
 521/* Initialize a sctp_addr from an address parameter. */
 522static void sctp_v6_from_addr_param(union sctp_addr *addr,
 523				    union sctp_addr_param *param,
 524				    __be16 port, int iif)
 525{
 526	addr->v6.sin6_family = AF_INET6;
 527	addr->v6.sin6_port = port;
 528	addr->v6.sin6_flowinfo = 0; /* BUG */
 529	addr->v6.sin6_addr = param->v6.addr;
 530	addr->v6.sin6_scope_id = iif;
 531}
 532
 533/* Initialize an address parameter from a sctp_addr and return the length
 534 * of the address parameter.
 535 */
 536static int sctp_v6_to_addr_param(const union sctp_addr *addr,
 537				 union sctp_addr_param *param)
 538{
 539	int length = sizeof(struct sctp_ipv6addr_param);
 540
 541	param->v6.param_hdr.type = SCTP_PARAM_IPV6_ADDRESS;
 542	param->v6.param_hdr.length = htons(length);
 543	param->v6.addr = addr->v6.sin6_addr;
 544
 545	return length;
 546}
 547
 548/* Initialize a sctp_addr from struct in6_addr. */
 549static void sctp_v6_to_addr(union sctp_addr *addr, struct in6_addr *saddr,
 550			      __be16 port)
 551{
 552	addr->sa.sa_family = AF_INET6;
 553	addr->v6.sin6_port = port;
 554	addr->v6.sin6_flowinfo = 0;
 555	addr->v6.sin6_addr = *saddr;
 556	addr->v6.sin6_scope_id = 0;
 557}
 558
 559static int __sctp_v6_cmp_addr(const union sctp_addr *addr1,
 560			      const union sctp_addr *addr2)
 561{
 562	if (addr1->sa.sa_family != addr2->sa.sa_family) {
 563		if (addr1->sa.sa_family == AF_INET &&
 564		    addr2->sa.sa_family == AF_INET6 &&
 565		    ipv6_addr_v4mapped(&addr2->v6.sin6_addr) &&
 566		    addr2->v6.sin6_addr.s6_addr32[3] ==
 567		    addr1->v4.sin_addr.s_addr)
 568			return 1;
 569
 570		if (addr2->sa.sa_family == AF_INET &&
 571		    addr1->sa.sa_family == AF_INET6 &&
 572		    ipv6_addr_v4mapped(&addr1->v6.sin6_addr) &&
 573		    addr1->v6.sin6_addr.s6_addr32[3] ==
 574		    addr2->v4.sin_addr.s_addr)
 575			return 1;
 576
 577		return 0;
 578	}
 579
 580	if (!ipv6_addr_equal(&addr1->v6.sin6_addr, &addr2->v6.sin6_addr))
 581		return 0;
 582
 583	/* If this is a linklocal address, compare the scope_id. */
 584	if ((ipv6_addr_type(&addr1->v6.sin6_addr) & IPV6_ADDR_LINKLOCAL) &&
 585	    addr1->v6.sin6_scope_id && addr2->v6.sin6_scope_id &&
 586	    addr1->v6.sin6_scope_id != addr2->v6.sin6_scope_id)
 587		return 0;
 588
 589	return 1;
 590}
 591
 592/* Compare addresses exactly.
 593 * v4-mapped-v6 is also in consideration.
 594 */
 595static int sctp_v6_cmp_addr(const union sctp_addr *addr1,
 596			    const union sctp_addr *addr2)
 597{
 598	return __sctp_v6_cmp_addr(addr1, addr2) &&
 599	       addr1->v6.sin6_port == addr2->v6.sin6_port;
 600}
 601
 602/* Initialize addr struct to INADDR_ANY. */
 603static void sctp_v6_inaddr_any(union sctp_addr *addr, __be16 port)
 604{
 605	memset(addr, 0x00, sizeof(union sctp_addr));
 606	addr->v6.sin6_family = AF_INET6;
 607	addr->v6.sin6_port = port;
 608}
 609
 610/* Is this a wildcard address? */
 611static int sctp_v6_is_any(const union sctp_addr *addr)
 612{
 613	return ipv6_addr_any(&addr->v6.sin6_addr);
 614}
 615
 616/* Should this be available for binding?   */
 617static int sctp_v6_available(union sctp_addr *addr, struct sctp_sock *sp)
 618{
 619	int type;
 620	struct net *net = sock_net(&sp->inet.sk);
 621	const struct in6_addr *in6 = (const struct in6_addr *)&addr->v6.sin6_addr;
 622
 623	type = ipv6_addr_type(in6);
 624	if (IPV6_ADDR_ANY == type)
 625		return 1;
 626	if (type == IPV6_ADDR_MAPPED) {
 627		if (sp && ipv6_only_sock(sctp_opt2sk(sp)))
 628			return 0;
 629		sctp_v6_map_v4(addr);
 630		return sctp_get_af_specific(AF_INET)->available(addr, sp);
 631	}
 632	if (!(type & IPV6_ADDR_UNICAST))
 633		return 0;
 634
 635	return sp->inet.freebind || net->ipv6.sysctl.ip_nonlocal_bind ||
 636		ipv6_chk_addr(net, in6, NULL, 0);
 637}
 638
 639/* This function checks if the address is a valid address to be used for
 640 * SCTP.
 641 *
 642 * Output:
 643 * Return 0 - If the address is a non-unicast or an illegal address.
 644 * Return 1 - If the address is a unicast.
 645 */
 646static int sctp_v6_addr_valid(union sctp_addr *addr,
 647			      struct sctp_sock *sp,
 648			      const struct sk_buff *skb)
 649{
 650	int ret = ipv6_addr_type(&addr->v6.sin6_addr);
 651
 652	/* Support v4-mapped-v6 address. */
 653	if (ret == IPV6_ADDR_MAPPED) {
 654		/* Note: This routine is used in input, so v4-mapped-v6
 655		 * are disallowed here when there is no sctp_sock.
 656		 */
 657		if (sp && ipv6_only_sock(sctp_opt2sk(sp)))
 658			return 0;
 659		sctp_v6_map_v4(addr);
 660		return sctp_get_af_specific(AF_INET)->addr_valid(addr, sp, skb);
 661	}
 662
 663	/* Is this a non-unicast address */
 664	if (!(ret & IPV6_ADDR_UNICAST))
 665		return 0;
 666
 667	return 1;
 668}
 669
 670/* What is the scope of 'addr'?  */
 671static enum sctp_scope sctp_v6_scope(union sctp_addr *addr)
 672{
 673	enum sctp_scope retval;
 674	int v6scope;
 675
 676	/* The IPv6 scope is really a set of bit fields.
 677	 * See IFA_* in <net/if_inet6.h>.  Map to a generic SCTP scope.
 678	 */
 679
 680	v6scope = ipv6_addr_scope(&addr->v6.sin6_addr);
 681	switch (v6scope) {
 682	case IFA_HOST:
 683		retval = SCTP_SCOPE_LOOPBACK;
 684		break;
 685	case IFA_LINK:
 686		retval = SCTP_SCOPE_LINK;
 687		break;
 688	case IFA_SITE:
 689		retval = SCTP_SCOPE_PRIVATE;
 690		break;
 691	default:
 692		retval = SCTP_SCOPE_GLOBAL;
 693		break;
 694	}
 695
 696	return retval;
 697}
 698
 699/* Create and initialize a new sk for the socket to be returned by accept(). */
 700static struct sock *sctp_v6_create_accept_sk(struct sock *sk,
 701					     struct sctp_association *asoc,
 702					     bool kern)
 703{
 704	struct sock *newsk;
 705	struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
 706	struct sctp6_sock *newsctp6sk;
 707
 708	newsk = sk_alloc(sock_net(sk), PF_INET6, GFP_KERNEL, sk->sk_prot, kern);
 709	if (!newsk)
 710		goto out;
 711
 712	sock_init_data(NULL, newsk);
 713
 714	sctp_copy_sock(newsk, sk, asoc);
 715	sock_reset_flag(sk, SOCK_ZAPPED);
 716
 717	newsctp6sk = (struct sctp6_sock *)newsk;
 718	inet_sk(newsk)->pinet6 = &newsctp6sk->inet6;
 719
 720	sctp_sk(newsk)->v4mapped = sctp_sk(sk)->v4mapped;
 721
 722	newnp = inet6_sk(newsk);
 723
 724	memcpy(newnp, np, sizeof(struct ipv6_pinfo));
 725	newnp->ipv6_mc_list = NULL;
 726	newnp->ipv6_ac_list = NULL;
 727	newnp->ipv6_fl_list = NULL;
 728
 729	sctp_v6_copy_ip_options(sk, newsk);
 730
 731	/* Initialize sk's sport, dport, rcv_saddr and daddr for getsockname()
 732	 * and getpeername().
 733	 */
 734	sctp_v6_to_sk_daddr(&asoc->peer.primary_addr, newsk);
 735
 736	newsk->sk_v6_rcv_saddr = sk->sk_v6_rcv_saddr;
 737
 738	sk_refcnt_debug_inc(newsk);
 739
 740	if (newsk->sk_prot->init(newsk)) {
 741		sk_common_release(newsk);
 742		newsk = NULL;
 743	}
 744
 745out:
 746	return newsk;
 747}
 748
 749/* Format a sockaddr for return to user space. This makes sure the return is
 750 * AF_INET or AF_INET6 depending on the SCTP_I_WANT_MAPPED_V4_ADDR option.
 751 */
 752static int sctp_v6_addr_to_user(struct sctp_sock *sp, union sctp_addr *addr)
 753{
 754	if (sp->v4mapped) {
 755		if (addr->sa.sa_family == AF_INET)
 756			sctp_v4_map_v6(addr);
 757	} else {
 758		if (addr->sa.sa_family == AF_INET6 &&
 759		    ipv6_addr_v4mapped(&addr->v6.sin6_addr))
 760			sctp_v6_map_v4(addr);
 761	}
 762
 763	if (addr->sa.sa_family == AF_INET) {
 764		memset(addr->v4.sin_zero, 0, sizeof(addr->v4.sin_zero));
 765		return sizeof(struct sockaddr_in);
 766	}
 767	return sizeof(struct sockaddr_in6);
 768}
 769
 770/* Where did this skb come from?  */
 771static int sctp_v6_skb_iif(const struct sk_buff *skb)
 772{
 773	return IP6CB(skb)->iif;
 774}
 775
 776/* Was this packet marked by Explicit Congestion Notification? */
 777static int sctp_v6_is_ce(const struct sk_buff *skb)
 778{
 779	return *((__u32 *)(ipv6_hdr(skb))) & (__force __u32)htonl(1 << 20);
 780}
 781
 782/* Dump the v6 addr to the seq file. */
 783static void sctp_v6_seq_dump_addr(struct seq_file *seq, union sctp_addr *addr)
 784{
 785	seq_printf(seq, "%pI6 ", &addr->v6.sin6_addr);
 786}
 787
 788static void sctp_v6_ecn_capable(struct sock *sk)
 789{
 790	inet6_sk(sk)->tclass |= INET_ECN_ECT_0;
 791}
 792
 793/* Initialize a PF_INET msgname from a ulpevent. */
 794static void sctp_inet6_event_msgname(struct sctp_ulpevent *event,
 795				     char *msgname, int *addrlen)
 796{
 797	union sctp_addr *addr;
 798	struct sctp_association *asoc;
 799	union sctp_addr *paddr;
 800
 801	if (!msgname)
 802		return;
 803
 804	addr = (union sctp_addr *)msgname;
 805	asoc = event->asoc;
 806	paddr = &asoc->peer.primary_addr;
 807
 808	if (paddr->sa.sa_family == AF_INET) {
 809		addr->v4.sin_family = AF_INET;
 810		addr->v4.sin_port = htons(asoc->peer.port);
 811		addr->v4.sin_addr = paddr->v4.sin_addr;
 812	} else {
 813		addr->v6.sin6_family = AF_INET6;
 814		addr->v6.sin6_flowinfo = 0;
 815		if (ipv6_addr_type(&paddr->v6.sin6_addr) & IPV6_ADDR_LINKLOCAL)
 816			addr->v6.sin6_scope_id = paddr->v6.sin6_scope_id;
 817		else
 818			addr->v6.sin6_scope_id = 0;
 819		addr->v6.sin6_port = htons(asoc->peer.port);
 820		addr->v6.sin6_addr = paddr->v6.sin6_addr;
 821	}
 822
 823	*addrlen = sctp_v6_addr_to_user(sctp_sk(asoc->base.sk), addr);
 824}
 825
 826/* Initialize a msg_name from an inbound skb. */
 827static void sctp_inet6_skb_msgname(struct sk_buff *skb, char *msgname,
 828				   int *addr_len)
 829{
 830	union sctp_addr *addr;
 831	struct sctphdr *sh;
 832
 833	if (!msgname)
 834		return;
 835
 836	addr = (union sctp_addr *)msgname;
 837	sh = sctp_hdr(skb);
 838
 839	if (ip_hdr(skb)->version == 4) {
 840		addr->v4.sin_family = AF_INET;
 841		addr->v4.sin_port = sh->source;
 842		addr->v4.sin_addr.s_addr = ip_hdr(skb)->saddr;
 843	} else {
 844		addr->v6.sin6_family = AF_INET6;
 845		addr->v6.sin6_flowinfo = 0;
 846		addr->v6.sin6_port = sh->source;
 847		addr->v6.sin6_addr = ipv6_hdr(skb)->saddr;
 848		if (ipv6_addr_type(&addr->v6.sin6_addr) & IPV6_ADDR_LINKLOCAL)
 849			addr->v6.sin6_scope_id = sctp_v6_skb_iif(skb);
 850		else
 851			addr->v6.sin6_scope_id = 0;
 852	}
 853
 854	*addr_len = sctp_v6_addr_to_user(sctp_sk(skb->sk), addr);
 855}
 856
 857/* Do we support this AF? */
 858static int sctp_inet6_af_supported(sa_family_t family, struct sctp_sock *sp)
 859{
 860	switch (family) {
 861	case AF_INET6:
 862		return 1;
 863	/* v4-mapped-v6 addresses */
 864	case AF_INET:
 865		if (!__ipv6_only_sock(sctp_opt2sk(sp)))
 866			return 1;
 867		/* fallthru */
 868	default:
 869		return 0;
 870	}
 871}
 872
 873/* Address matching with wildcards allowed.  This extra level
 874 * of indirection lets us choose whether a PF_INET6 should
 875 * disallow any v4 addresses if we so choose.
 876 */
 877static int sctp_inet6_cmp_addr(const union sctp_addr *addr1,
 878			       const union sctp_addr *addr2,
 879			       struct sctp_sock *opt)
 880{
 881	struct sock *sk = sctp_opt2sk(opt);
 882	struct sctp_af *af1, *af2;
 883
 884	af1 = sctp_get_af_specific(addr1->sa.sa_family);
 885	af2 = sctp_get_af_specific(addr2->sa.sa_family);
 886
 887	if (!af1 || !af2)
 888		return 0;
 889
 890	/* If the socket is IPv6 only, v4 addrs will not match */
 891	if (__ipv6_only_sock(sk) && af1 != af2)
 892		return 0;
 893
 894	/* Today, wildcard AF_INET/AF_INET6. */
 895	if (sctp_is_any(sk, addr1) || sctp_is_any(sk, addr2))
 896		return 1;
 897
 898	if (addr1->sa.sa_family == AF_INET && addr2->sa.sa_family == AF_INET)
 899		return addr1->v4.sin_addr.s_addr == addr2->v4.sin_addr.s_addr;
 900
 901	return __sctp_v6_cmp_addr(addr1, addr2);
 902}
 903
 904/* Verify that the provided sockaddr looks bindable.   Common verification,
 905 * has already been taken care of.
 906 */
 907static int sctp_inet6_bind_verify(struct sctp_sock *opt, union sctp_addr *addr)
 908{
 909	struct sctp_af *af;
 910
 911	/* ASSERT: address family has already been verified. */
 912	if (addr->sa.sa_family != AF_INET6)
 913		af = sctp_get_af_specific(addr->sa.sa_family);
 914	else {
 915		int type = ipv6_addr_type(&addr->v6.sin6_addr);
 916		struct net_device *dev;
 917
 918		if (type & IPV6_ADDR_LINKLOCAL) {
 919			struct net *net;
 920			if (!addr->v6.sin6_scope_id)
 921				return 0;
 922			net = sock_net(&opt->inet.sk);
 923			rcu_read_lock();
 924			dev = dev_get_by_index_rcu(net, addr->v6.sin6_scope_id);
 925			if (!dev || !(opt->inet.freebind ||
 926				      net->ipv6.sysctl.ip_nonlocal_bind ||
 927				      ipv6_chk_addr(net, &addr->v6.sin6_addr,
 928						    dev, 0))) {
 929				rcu_read_unlock();
 930				return 0;
 931			}
 932			rcu_read_unlock();
 933		}
 934
 935		af = opt->pf->af;
 936	}
 937	return af->available(addr, opt);
 938}
 939
 940/* Verify that the provided sockaddr looks sendable.   Common verification,
 941 * has already been taken care of.
 942 */
 943static int sctp_inet6_send_verify(struct sctp_sock *opt, union sctp_addr *addr)
 944{
 945	struct sctp_af *af = NULL;
 946
 947	/* ASSERT: address family has already been verified. */
 948	if (addr->sa.sa_family != AF_INET6)
 949		af = sctp_get_af_specific(addr->sa.sa_family);
 950	else {
 951		int type = ipv6_addr_type(&addr->v6.sin6_addr);
 952		struct net_device *dev;
 953
 954		if (type & IPV6_ADDR_LINKLOCAL) {
 955			if (!addr->v6.sin6_scope_id)
 956				return 0;
 957			rcu_read_lock();
 958			dev = dev_get_by_index_rcu(sock_net(&opt->inet.sk),
 959						   addr->v6.sin6_scope_id);
 960			rcu_read_unlock();
 961			if (!dev)
 962				return 0;
 963		}
 964		af = opt->pf->af;
 965	}
 966
 967	return af != NULL;
 968}
 969
 970/* Fill in Supported Address Type information for INIT and INIT-ACK
 971 * chunks.   Note: In the future, we may want to look at sock options
 972 * to determine whether a PF_INET6 socket really wants to have IPV4
 973 * addresses.
 974 * Returns number of addresses supported.
 975 */
 976static int sctp_inet6_supported_addrs(const struct sctp_sock *opt,
 977				      __be16 *types)
 978{
 979	types[0] = SCTP_PARAM_IPV6_ADDRESS;
 980	if (!opt || !ipv6_only_sock(sctp_opt2sk(opt))) {
 981		types[1] = SCTP_PARAM_IPV4_ADDRESS;
 982		return 2;
 983	}
 984	return 1;
 985}
 986
 987/* Handle SCTP_I_WANT_MAPPED_V4_ADDR for getpeername() and getsockname() */
 988static int sctp_getname(struct socket *sock, struct sockaddr *uaddr,
 989			int peer)
 990{
 991	int rc;
 992
 993	rc = inet6_getname(sock, uaddr, peer);
 994
 995	if (rc < 0)
 996		return rc;
 997
 998	rc = sctp_v6_addr_to_user(sctp_sk(sock->sk),
 999					  (union sctp_addr *)uaddr);
1000
1001	return rc;
1002}
1003
1004static const struct proto_ops inet6_seqpacket_ops = {
1005	.family		   = PF_INET6,
1006	.owner		   = THIS_MODULE,
1007	.release	   = inet6_release,
1008	.bind		   = inet6_bind,
1009	.connect	   = sctp_inet_connect,
1010	.socketpair	   = sock_no_socketpair,
1011	.accept		   = inet_accept,
1012	.getname	   = sctp_getname,
1013	.poll		   = sctp_poll,
1014	.ioctl		   = inet6_ioctl,
 
1015	.listen		   = sctp_inet_listen,
1016	.shutdown	   = inet_shutdown,
1017	.setsockopt	   = sock_common_setsockopt,
1018	.getsockopt	   = sock_common_getsockopt,
1019	.sendmsg	   = inet_sendmsg,
1020	.recvmsg	   = inet_recvmsg,
1021	.mmap		   = sock_no_mmap,
1022#ifdef CONFIG_COMPAT
1023	.compat_setsockopt = compat_sock_common_setsockopt,
1024	.compat_getsockopt = compat_sock_common_getsockopt,
1025#endif
1026};
1027
1028static struct inet_protosw sctpv6_seqpacket_protosw = {
1029	.type          = SOCK_SEQPACKET,
1030	.protocol      = IPPROTO_SCTP,
1031	.prot 	       = &sctpv6_prot,
1032	.ops           = &inet6_seqpacket_ops,
1033	.flags         = SCTP_PROTOSW_FLAG
1034};
1035static struct inet_protosw sctpv6_stream_protosw = {
1036	.type          = SOCK_STREAM,
1037	.protocol      = IPPROTO_SCTP,
1038	.prot 	       = &sctpv6_prot,
1039	.ops           = &inet6_seqpacket_ops,
1040	.flags         = SCTP_PROTOSW_FLAG,
1041};
1042
1043static int sctp6_rcv(struct sk_buff *skb)
1044{
1045	return sctp_rcv(skb) ? -1 : 0;
1046}
1047
1048static const struct inet6_protocol sctpv6_protocol = {
1049	.handler      = sctp6_rcv,
1050	.err_handler  = sctp_v6_err,
1051	.flags        = INET6_PROTO_NOPOLICY | INET6_PROTO_FINAL,
1052};
1053
1054static struct sctp_af sctp_af_inet6 = {
1055	.sa_family	   = AF_INET6,
1056	.sctp_xmit	   = sctp_v6_xmit,
1057	.setsockopt	   = ipv6_setsockopt,
1058	.getsockopt	   = ipv6_getsockopt,
1059	.get_dst	   = sctp_v6_get_dst,
1060	.get_saddr	   = sctp_v6_get_saddr,
1061	.copy_addrlist	   = sctp_v6_copy_addrlist,
1062	.from_skb	   = sctp_v6_from_skb,
1063	.from_sk	   = sctp_v6_from_sk,
1064	.from_addr_param   = sctp_v6_from_addr_param,
1065	.to_addr_param	   = sctp_v6_to_addr_param,
1066	.cmp_addr	   = sctp_v6_cmp_addr,
1067	.scope		   = sctp_v6_scope,
1068	.addr_valid	   = sctp_v6_addr_valid,
1069	.inaddr_any	   = sctp_v6_inaddr_any,
1070	.is_any		   = sctp_v6_is_any,
1071	.available	   = sctp_v6_available,
1072	.skb_iif	   = sctp_v6_skb_iif,
1073	.is_ce		   = sctp_v6_is_ce,
1074	.seq_dump_addr	   = sctp_v6_seq_dump_addr,
1075	.ecn_capable	   = sctp_v6_ecn_capable,
1076	.net_header_len	   = sizeof(struct ipv6hdr),
1077	.sockaddr_len	   = sizeof(struct sockaddr_in6),
1078	.ip_options_len	   = sctp_v6_ip_options_len,
1079#ifdef CONFIG_COMPAT
1080	.compat_setsockopt = compat_ipv6_setsockopt,
1081	.compat_getsockopt = compat_ipv6_getsockopt,
1082#endif
1083};
1084
1085static struct sctp_pf sctp_pf_inet6 = {
1086	.event_msgname = sctp_inet6_event_msgname,
1087	.skb_msgname   = sctp_inet6_skb_msgname,
1088	.af_supported  = sctp_inet6_af_supported,
1089	.cmp_addr      = sctp_inet6_cmp_addr,
1090	.bind_verify   = sctp_inet6_bind_verify,
1091	.send_verify   = sctp_inet6_send_verify,
1092	.supported_addrs = sctp_inet6_supported_addrs,
1093	.create_accept_sk = sctp_v6_create_accept_sk,
1094	.addr_to_user  = sctp_v6_addr_to_user,
1095	.to_sk_saddr   = sctp_v6_to_sk_saddr,
1096	.to_sk_daddr   = sctp_v6_to_sk_daddr,
1097	.copy_ip_options = sctp_v6_copy_ip_options,
1098	.af            = &sctp_af_inet6,
1099};
1100
1101/* Initialize IPv6 support and register with socket layer.  */
1102void sctp_v6_pf_init(void)
1103{
1104	/* Register the SCTP specific PF_INET6 functions. */
1105	sctp_register_pf(&sctp_pf_inet6, PF_INET6);
1106
1107	/* Register the SCTP specific AF_INET6 functions. */
1108	sctp_register_af(&sctp_af_inet6);
1109}
1110
1111void sctp_v6_pf_exit(void)
1112{
1113	list_del(&sctp_af_inet6.list);
1114}
1115
1116/* Initialize IPv6 support and register with socket layer.  */
1117int sctp_v6_protosw_init(void)
1118{
1119	int rc;
1120
1121	rc = proto_register(&sctpv6_prot, 1);
1122	if (rc)
1123		return rc;
1124
1125	/* Add SCTPv6(UDP and TCP style) to inetsw6 linked list. */
1126	inet6_register_protosw(&sctpv6_seqpacket_protosw);
1127	inet6_register_protosw(&sctpv6_stream_protosw);
1128
1129	return 0;
1130}
1131
1132void sctp_v6_protosw_exit(void)
1133{
1134	inet6_unregister_protosw(&sctpv6_seqpacket_protosw);
1135	inet6_unregister_protosw(&sctpv6_stream_protosw);
1136	proto_unregister(&sctpv6_prot);
1137}
1138
1139
1140/* Register with inet6 layer. */
1141int sctp_v6_add_protocol(void)
1142{
1143	/* Register notifier for inet6 address additions/deletions. */
1144	register_inet6addr_notifier(&sctp_inet6addr_notifier);
1145
1146	if (inet6_add_protocol(&sctpv6_protocol, IPPROTO_SCTP) < 0)
1147		return -EAGAIN;
1148
1149	return 0;
1150}
1151
1152/* Unregister with inet6 layer. */
1153void sctp_v6_del_protocol(void)
1154{
1155	inet6_del_protocol(&sctpv6_protocol, IPPROTO_SCTP);
1156	unregister_inet6addr_notifier(&sctp_inet6addr_notifier);
1157}
v5.4
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/* SCTP kernel implementation
   3 * (C) Copyright IBM Corp. 2002, 2004
   4 * Copyright (c) 2001 Nokia, Inc.
   5 * Copyright (c) 2001 La Monte H.P. Yarroll
   6 * Copyright (c) 2002-2003 Intel Corp.
   7 *
   8 * This file is part of the SCTP kernel implementation
   9 *
  10 * SCTP over IPv6.
  11 *
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  12 * Please send any bug reports or fixes you make to the
  13 * email address(es):
  14 *    lksctp developers <linux-sctp@vger.kernel.org>
  15 *
  16 * Written or modified by:
  17 *    Le Yanqun		    <yanqun.le@nokia.com>
  18 *    Hui Huang		    <hui.huang@nokia.com>
  19 *    La Monte H.P. Yarroll <piggy@acm.org>
  20 *    Sridhar Samudrala	    <sri@us.ibm.com>
  21 *    Jon Grimm		    <jgrimm@us.ibm.com>
  22 *    Ardelle Fan	    <ardelle.fan@intel.com>
  23 *
  24 * Based on:
  25 *	linux/net/ipv6/tcp_ipv6.c
  26 */
  27
  28#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  29
  30#include <linux/module.h>
  31#include <linux/errno.h>
  32#include <linux/types.h>
  33#include <linux/socket.h>
  34#include <linux/sockios.h>
  35#include <linux/net.h>
  36#include <linux/in.h>
  37#include <linux/in6.h>
  38#include <linux/netdevice.h>
  39#include <linux/init.h>
  40#include <linux/ipsec.h>
  41#include <linux/slab.h>
  42
  43#include <linux/ipv6.h>
  44#include <linux/icmpv6.h>
  45#include <linux/random.h>
  46#include <linux/seq_file.h>
  47
  48#include <net/protocol.h>
  49#include <net/ndisc.h>
  50#include <net/ip.h>
  51#include <net/ipv6.h>
  52#include <net/transp_v6.h>
  53#include <net/addrconf.h>
  54#include <net/ip6_route.h>
  55#include <net/inet_common.h>
  56#include <net/inet_ecn.h>
  57#include <net/sctp/sctp.h>
  58
  59#include <linux/uaccess.h>
  60
  61static inline int sctp_v6_addr_match_len(union sctp_addr *s1,
  62					 union sctp_addr *s2);
  63static void sctp_v6_to_addr(union sctp_addr *addr, struct in6_addr *saddr,
  64			      __be16 port);
  65static int sctp_v6_cmp_addr(const union sctp_addr *addr1,
  66			    const union sctp_addr *addr2);
  67
  68/* Event handler for inet6 address addition/deletion events.
  69 * The sctp_local_addr_list needs to be protocted by a spin lock since
  70 * multiple notifiers (say IPv4 and IPv6) may be running at the same
  71 * time and thus corrupt the list.
  72 * The reader side is protected with RCU.
  73 */
  74static int sctp_inet6addr_event(struct notifier_block *this, unsigned long ev,
  75				void *ptr)
  76{
  77	struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
  78	struct sctp_sockaddr_entry *addr = NULL;
  79	struct sctp_sockaddr_entry *temp;
  80	struct net *net = dev_net(ifa->idev->dev);
  81	int found = 0;
  82
  83	switch (ev) {
  84	case NETDEV_UP:
  85		addr = kzalloc(sizeof(*addr), GFP_ATOMIC);
  86		if (addr) {
  87			addr->a.v6.sin6_family = AF_INET6;
 
  88			addr->a.v6.sin6_addr = ifa->addr;
  89			addr->a.v6.sin6_scope_id = ifa->idev->dev->ifindex;
  90			addr->valid = 1;
  91			spin_lock_bh(&net->sctp.local_addr_lock);
  92			list_add_tail_rcu(&addr->list, &net->sctp.local_addr_list);
  93			sctp_addr_wq_mgmt(net, addr, SCTP_ADDR_NEW);
  94			spin_unlock_bh(&net->sctp.local_addr_lock);
  95		}
  96		break;
  97	case NETDEV_DOWN:
  98		spin_lock_bh(&net->sctp.local_addr_lock);
  99		list_for_each_entry_safe(addr, temp,
 100					&net->sctp.local_addr_list, list) {
 101			if (addr->a.sa.sa_family == AF_INET6 &&
 102					ipv6_addr_equal(&addr->a.v6.sin6_addr,
 103						&ifa->addr)) {
 104				sctp_addr_wq_mgmt(net, addr, SCTP_ADDR_DEL);
 105				found = 1;
 106				addr->valid = 0;
 107				list_del_rcu(&addr->list);
 108				break;
 109			}
 110		}
 111		spin_unlock_bh(&net->sctp.local_addr_lock);
 112		if (found)
 113			kfree_rcu(addr, rcu);
 114		break;
 115	}
 116
 117	return NOTIFY_DONE;
 118}
 119
 120static struct notifier_block sctp_inet6addr_notifier = {
 121	.notifier_call = sctp_inet6addr_event,
 122};
 123
 124/* ICMP error handler. */
 125static int sctp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
 126			u8 type, u8 code, int offset, __be32 info)
 127{
 128	struct inet6_dev *idev;
 129	struct sock *sk;
 130	struct sctp_association *asoc;
 131	struct sctp_transport *transport;
 132	struct ipv6_pinfo *np;
 133	__u16 saveip, savesctp;
 134	int err, ret = 0;
 135	struct net *net = dev_net(skb->dev);
 136
 137	idev = in6_dev_get(skb->dev);
 138
 139	/* Fix up skb to look at the embedded net header. */
 140	saveip	 = skb->network_header;
 141	savesctp = skb->transport_header;
 142	skb_reset_network_header(skb);
 143	skb_set_transport_header(skb, offset);
 144	sk = sctp_err_lookup(net, AF_INET6, skb, sctp_hdr(skb), &asoc, &transport);
 145	/* Put back, the original pointers. */
 146	skb->network_header   = saveip;
 147	skb->transport_header = savesctp;
 148	if (!sk) {
 149		__ICMP6_INC_STATS(net, idev, ICMP6_MIB_INERRORS);
 150		ret = -ENOENT;
 151		goto out;
 152	}
 153
 154	/* Warning:  The sock lock is held.  Remember to call
 155	 * sctp_err_finish!
 156	 */
 157
 158	switch (type) {
 159	case ICMPV6_PKT_TOOBIG:
 160		if (ip6_sk_accept_pmtu(sk))
 161			sctp_icmp_frag_needed(sk, asoc, transport, ntohl(info));
 162		goto out_unlock;
 163	case ICMPV6_PARAMPROB:
 164		if (ICMPV6_UNK_NEXTHDR == code) {
 165			sctp_icmp_proto_unreachable(sk, asoc, transport);
 166			goto out_unlock;
 167		}
 168		break;
 169	case NDISC_REDIRECT:
 170		sctp_icmp_redirect(sk, transport, skb);
 171		goto out_unlock;
 172	default:
 173		break;
 174	}
 175
 176	np = inet6_sk(sk);
 177	icmpv6_err_convert(type, code, &err);
 178	if (!sock_owned_by_user(sk) && np->recverr) {
 179		sk->sk_err = err;
 180		sk->sk_error_report(sk);
 181	} else {  /* Only an error on timeout */
 182		sk->sk_err_soft = err;
 183	}
 184
 185out_unlock:
 186	sctp_err_finish(sk, transport);
 187out:
 188	if (likely(idev != NULL))
 189		in6_dev_put(idev);
 190
 191	return ret;
 192}
 193
 194static int sctp_v6_xmit(struct sk_buff *skb, struct sctp_transport *transport)
 195{
 196	struct sock *sk = skb->sk;
 197	struct ipv6_pinfo *np = inet6_sk(sk);
 198	struct flowi6 *fl6 = &transport->fl.u.ip6;
 199	__u8 tclass = np->tclass;
 200	int res;
 201
 202	pr_debug("%s: skb:%p, len:%d, src:%pI6 dst:%pI6\n", __func__, skb,
 203		 skb->len, &fl6->saddr, &fl6->daddr);
 204
 205	if (transport->dscp & SCTP_DSCP_SET_MASK)
 206		tclass = transport->dscp & SCTP_DSCP_VAL_MASK;
 207
 208	if (INET_ECN_is_capable(tclass))
 209		IP6_ECN_flow_xmit(sk, fl6->flowlabel);
 210
 211	if (!(transport->param_flags & SPP_PMTUD_ENABLE))
 212		skb->ignore_df = 1;
 213
 214	SCTP_INC_STATS(sock_net(sk), SCTP_MIB_OUTSCTPPACKS);
 215
 216	rcu_read_lock();
 217	res = ip6_xmit(sk, skb, fl6, sk->sk_mark, rcu_dereference(np->opt),
 218		       tclass, sk->sk_priority);
 219	rcu_read_unlock();
 220	return res;
 221}
 222
 223/* Returns the dst cache entry for the given source and destination ip
 224 * addresses.
 225 */
 226static void sctp_v6_get_dst(struct sctp_transport *t, union sctp_addr *saddr,
 227			    struct flowi *fl, struct sock *sk)
 228{
 229	struct sctp_association *asoc = t->asoc;
 230	struct dst_entry *dst = NULL;
 231	struct flowi6 *fl6 = &fl->u.ip6;
 232	struct sctp_bind_addr *bp;
 233	struct ipv6_pinfo *np = inet6_sk(sk);
 234	struct sctp_sockaddr_entry *laddr;
 235	union sctp_addr *daddr = &t->ipaddr;
 236	union sctp_addr dst_saddr;
 237	struct in6_addr *final_p, final;
 238	enum sctp_scope scope;
 239	__u8 matchlen = 0;
 240
 241	memset(fl6, 0, sizeof(struct flowi6));
 242	fl6->daddr = daddr->v6.sin6_addr;
 243	fl6->fl6_dport = daddr->v6.sin6_port;
 244	fl6->flowi6_proto = IPPROTO_SCTP;
 245	if (ipv6_addr_type(&daddr->v6.sin6_addr) & IPV6_ADDR_LINKLOCAL)
 246		fl6->flowi6_oif = daddr->v6.sin6_scope_id;
 247	else if (asoc)
 248		fl6->flowi6_oif = asoc->base.sk->sk_bound_dev_if;
 249	if (t->flowlabel & SCTP_FLOWLABEL_SET_MASK)
 250		fl6->flowlabel = htonl(t->flowlabel & SCTP_FLOWLABEL_VAL_MASK);
 251
 252	if (np->sndflow && (fl6->flowlabel & IPV6_FLOWLABEL_MASK)) {
 253		struct ip6_flowlabel *flowlabel;
 254
 255		flowlabel = fl6_sock_lookup(sk, fl6->flowlabel);
 256		if (IS_ERR(flowlabel))
 257			goto out;
 258		fl6_sock_release(flowlabel);
 259	}
 260
 261	pr_debug("%s: dst=%pI6 ", __func__, &fl6->daddr);
 262
 263	if (asoc)
 264		fl6->fl6_sport = htons(asoc->base.bind_addr.port);
 265
 266	if (saddr) {
 267		fl6->saddr = saddr->v6.sin6_addr;
 268		if (!fl6->fl6_sport)
 269			fl6->fl6_sport = saddr->v6.sin6_port;
 270
 271		pr_debug("src=%pI6 - ", &fl6->saddr);
 272	}
 273
 274	rcu_read_lock();
 275	final_p = fl6_update_dst(fl6, rcu_dereference(np->opt), &final);
 276	rcu_read_unlock();
 277
 278	dst = ip6_dst_lookup_flow(sk, fl6, final_p);
 279	if (!asoc || saddr)
 280		goto out;
 281
 282	bp = &asoc->base.bind_addr;
 283	scope = sctp_scope(daddr);
 284	/* ip6_dst_lookup has filled in the fl6->saddr for us.  Check
 285	 * to see if we can use it.
 286	 */
 287	if (!IS_ERR(dst)) {
 288		/* Walk through the bind address list and look for a bind
 289		 * address that matches the source address of the returned dst.
 290		 */
 291		sctp_v6_to_addr(&dst_saddr, &fl6->saddr, htons(bp->port));
 292		rcu_read_lock();
 293		list_for_each_entry_rcu(laddr, &bp->address_list, list) {
 294			if (!laddr->valid || laddr->state == SCTP_ADDR_DEL ||
 295			    (laddr->state != SCTP_ADDR_SRC &&
 296			     !asoc->src_out_of_asoc_ok))
 297				continue;
 298
 299			/* Do not compare against v4 addrs */
 300			if ((laddr->a.sa.sa_family == AF_INET6) &&
 301			    (sctp_v6_cmp_addr(&dst_saddr, &laddr->a))) {
 302				rcu_read_unlock();
 303				goto out;
 304			}
 305		}
 306		rcu_read_unlock();
 307		/* None of the bound addresses match the source address of the
 308		 * dst. So release it.
 309		 */
 310		dst_release(dst);
 311		dst = NULL;
 312	}
 313
 314	/* Walk through the bind address list and try to get the
 315	 * best source address for a given destination.
 316	 */
 317	rcu_read_lock();
 318	list_for_each_entry_rcu(laddr, &bp->address_list, list) {
 319		struct dst_entry *bdst;
 320		__u8 bmatchlen;
 321
 322		if (!laddr->valid ||
 323		    laddr->state != SCTP_ADDR_SRC ||
 324		    laddr->a.sa.sa_family != AF_INET6 ||
 325		    scope > sctp_scope(&laddr->a))
 326			continue;
 327
 328		fl6->saddr = laddr->a.v6.sin6_addr;
 329		fl6->fl6_sport = laddr->a.v6.sin6_port;
 330		final_p = fl6_update_dst(fl6, rcu_dereference(np->opt), &final);
 331		bdst = ip6_dst_lookup_flow(sk, fl6, final_p);
 332
 333		if (IS_ERR(bdst))
 334			continue;
 335
 336		if (ipv6_chk_addr(dev_net(bdst->dev),
 337				  &laddr->a.v6.sin6_addr, bdst->dev, 1)) {
 338			if (!IS_ERR_OR_NULL(dst))
 339				dst_release(dst);
 340			dst = bdst;
 341			break;
 342		}
 343
 344		bmatchlen = sctp_v6_addr_match_len(daddr, &laddr->a);
 345		if (matchlen > bmatchlen) {
 346			dst_release(bdst);
 347			continue;
 348		}
 349
 350		if (!IS_ERR_OR_NULL(dst))
 351			dst_release(dst);
 352		dst = bdst;
 353		matchlen = bmatchlen;
 354	}
 355	rcu_read_unlock();
 356
 357out:
 358	if (!IS_ERR_OR_NULL(dst)) {
 359		struct rt6_info *rt;
 360
 361		rt = (struct rt6_info *)dst;
 362		t->dst = dst;
 363		t->dst_cookie = rt6_get_cookie(rt);
 364		pr_debug("rt6_dst:%pI6/%d rt6_src:%pI6\n",
 365			 &rt->rt6i_dst.addr, rt->rt6i_dst.plen,
 366			 &fl6->saddr);
 367	} else {
 368		t->dst = NULL;
 369
 370		pr_debug("no route\n");
 371	}
 372}
 373
 374/* Returns the number of consecutive initial bits that match in the 2 ipv6
 375 * addresses.
 376 */
 377static inline int sctp_v6_addr_match_len(union sctp_addr *s1,
 378					 union sctp_addr *s2)
 379{
 380	return ipv6_addr_diff(&s1->v6.sin6_addr, &s2->v6.sin6_addr);
 381}
 382
 383/* Fills in the source address(saddr) based on the destination address(daddr)
 384 * and asoc's bind address list.
 385 */
 386static void sctp_v6_get_saddr(struct sctp_sock *sk,
 387			      struct sctp_transport *t,
 388			      struct flowi *fl)
 389{
 390	struct flowi6 *fl6 = &fl->u.ip6;
 391	union sctp_addr *saddr = &t->saddr;
 392
 393	pr_debug("%s: asoc:%p dst:%p\n", __func__, t->asoc, t->dst);
 394
 395	if (t->dst) {
 396		saddr->v6.sin6_family = AF_INET6;
 397		saddr->v6.sin6_addr = fl6->saddr;
 398	}
 399}
 400
 401/* Make a copy of all potential local addresses. */
 402static void sctp_v6_copy_addrlist(struct list_head *addrlist,
 403				  struct net_device *dev)
 404{
 405	struct inet6_dev *in6_dev;
 406	struct inet6_ifaddr *ifp;
 407	struct sctp_sockaddr_entry *addr;
 408
 409	rcu_read_lock();
 410	if ((in6_dev = __in6_dev_get(dev)) == NULL) {
 411		rcu_read_unlock();
 412		return;
 413	}
 414
 415	read_lock_bh(&in6_dev->lock);
 416	list_for_each_entry(ifp, &in6_dev->addr_list, if_list) {
 417		/* Add the address to the local list.  */
 418		addr = kzalloc(sizeof(*addr), GFP_ATOMIC);
 419		if (addr) {
 420			addr->a.v6.sin6_family = AF_INET6;
 
 421			addr->a.v6.sin6_addr = ifp->addr;
 422			addr->a.v6.sin6_scope_id = dev->ifindex;
 423			addr->valid = 1;
 424			INIT_LIST_HEAD(&addr->list);
 425			list_add_tail(&addr->list, addrlist);
 426		}
 427	}
 428
 429	read_unlock_bh(&in6_dev->lock);
 430	rcu_read_unlock();
 431}
 432
 433/* Copy over any ip options */
 434static void sctp_v6_copy_ip_options(struct sock *sk, struct sock *newsk)
 435{
 436	struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
 437	struct ipv6_txoptions *opt;
 438
 439	newnp = inet6_sk(newsk);
 440
 441	rcu_read_lock();
 442	opt = rcu_dereference(np->opt);
 443	if (opt) {
 444		opt = ipv6_dup_options(newsk, opt);
 445		if (!opt)
 446			pr_err("%s: Failed to copy ip options\n", __func__);
 447	}
 448	RCU_INIT_POINTER(newnp->opt, opt);
 449	rcu_read_unlock();
 450}
 451
 452/* Account for the IP options */
 453static int sctp_v6_ip_options_len(struct sock *sk)
 454{
 455	struct ipv6_pinfo *np = inet6_sk(sk);
 456	struct ipv6_txoptions *opt;
 457	int len = 0;
 458
 459	rcu_read_lock();
 460	opt = rcu_dereference(np->opt);
 461	if (opt)
 462		len = opt->opt_flen + opt->opt_nflen;
 463
 464	rcu_read_unlock();
 465	return len;
 466}
 467
 468/* Initialize a sockaddr_storage from in incoming skb. */
 469static void sctp_v6_from_skb(union sctp_addr *addr, struct sk_buff *skb,
 470			     int is_saddr)
 471{
 472	/* Always called on head skb, so this is safe */
 473	struct sctphdr *sh = sctp_hdr(skb);
 474	struct sockaddr_in6 *sa = &addr->v6;
 475
 476	addr->v6.sin6_family = AF_INET6;
 477	addr->v6.sin6_flowinfo = 0; /* FIXME */
 478	addr->v6.sin6_scope_id = ((struct inet6_skb_parm *)skb->cb)->iif;
 479
 480	if (is_saddr) {
 481		sa->sin6_port = sh->source;
 482		sa->sin6_addr = ipv6_hdr(skb)->saddr;
 483	} else {
 484		sa->sin6_port = sh->dest;
 485		sa->sin6_addr = ipv6_hdr(skb)->daddr;
 486	}
 487}
 488
 489/* Initialize an sctp_addr from a socket. */
 490static void sctp_v6_from_sk(union sctp_addr *addr, struct sock *sk)
 491{
 492	addr->v6.sin6_family = AF_INET6;
 493	addr->v6.sin6_port = 0;
 494	addr->v6.sin6_addr = sk->sk_v6_rcv_saddr;
 495}
 496
 497/* Initialize sk->sk_rcv_saddr from sctp_addr. */
 498static void sctp_v6_to_sk_saddr(union sctp_addr *addr, struct sock *sk)
 499{
 500	if (addr->sa.sa_family == AF_INET) {
 501		sk->sk_v6_rcv_saddr.s6_addr32[0] = 0;
 502		sk->sk_v6_rcv_saddr.s6_addr32[1] = 0;
 503		sk->sk_v6_rcv_saddr.s6_addr32[2] = htonl(0x0000ffff);
 504		sk->sk_v6_rcv_saddr.s6_addr32[3] =
 505			addr->v4.sin_addr.s_addr;
 506	} else {
 507		sk->sk_v6_rcv_saddr = addr->v6.sin6_addr;
 508	}
 509}
 510
 511/* Initialize sk->sk_daddr from sctp_addr. */
 512static void sctp_v6_to_sk_daddr(union sctp_addr *addr, struct sock *sk)
 513{
 514	if (addr->sa.sa_family == AF_INET) {
 515		sk->sk_v6_daddr.s6_addr32[0] = 0;
 516		sk->sk_v6_daddr.s6_addr32[1] = 0;
 517		sk->sk_v6_daddr.s6_addr32[2] = htonl(0x0000ffff);
 518		sk->sk_v6_daddr.s6_addr32[3] = addr->v4.sin_addr.s_addr;
 519	} else {
 520		sk->sk_v6_daddr = addr->v6.sin6_addr;
 521	}
 522}
 523
 524/* Initialize a sctp_addr from an address parameter. */
 525static void sctp_v6_from_addr_param(union sctp_addr *addr,
 526				    union sctp_addr_param *param,
 527				    __be16 port, int iif)
 528{
 529	addr->v6.sin6_family = AF_INET6;
 530	addr->v6.sin6_port = port;
 531	addr->v6.sin6_flowinfo = 0; /* BUG */
 532	addr->v6.sin6_addr = param->v6.addr;
 533	addr->v6.sin6_scope_id = iif;
 534}
 535
 536/* Initialize an address parameter from a sctp_addr and return the length
 537 * of the address parameter.
 538 */
 539static int sctp_v6_to_addr_param(const union sctp_addr *addr,
 540				 union sctp_addr_param *param)
 541{
 542	int length = sizeof(struct sctp_ipv6addr_param);
 543
 544	param->v6.param_hdr.type = SCTP_PARAM_IPV6_ADDRESS;
 545	param->v6.param_hdr.length = htons(length);
 546	param->v6.addr = addr->v6.sin6_addr;
 547
 548	return length;
 549}
 550
 551/* Initialize a sctp_addr from struct in6_addr. */
 552static void sctp_v6_to_addr(union sctp_addr *addr, struct in6_addr *saddr,
 553			      __be16 port)
 554{
 555	addr->sa.sa_family = AF_INET6;
 556	addr->v6.sin6_port = port;
 557	addr->v6.sin6_flowinfo = 0;
 558	addr->v6.sin6_addr = *saddr;
 559	addr->v6.sin6_scope_id = 0;
 560}
 561
 562static int __sctp_v6_cmp_addr(const union sctp_addr *addr1,
 563			      const union sctp_addr *addr2)
 564{
 565	if (addr1->sa.sa_family != addr2->sa.sa_family) {
 566		if (addr1->sa.sa_family == AF_INET &&
 567		    addr2->sa.sa_family == AF_INET6 &&
 568		    ipv6_addr_v4mapped(&addr2->v6.sin6_addr) &&
 569		    addr2->v6.sin6_addr.s6_addr32[3] ==
 570		    addr1->v4.sin_addr.s_addr)
 571			return 1;
 572
 573		if (addr2->sa.sa_family == AF_INET &&
 574		    addr1->sa.sa_family == AF_INET6 &&
 575		    ipv6_addr_v4mapped(&addr1->v6.sin6_addr) &&
 576		    addr1->v6.sin6_addr.s6_addr32[3] ==
 577		    addr2->v4.sin_addr.s_addr)
 578			return 1;
 579
 580		return 0;
 581	}
 582
 583	if (!ipv6_addr_equal(&addr1->v6.sin6_addr, &addr2->v6.sin6_addr))
 584		return 0;
 585
 586	/* If this is a linklocal address, compare the scope_id. */
 587	if ((ipv6_addr_type(&addr1->v6.sin6_addr) & IPV6_ADDR_LINKLOCAL) &&
 588	    addr1->v6.sin6_scope_id && addr2->v6.sin6_scope_id &&
 589	    addr1->v6.sin6_scope_id != addr2->v6.sin6_scope_id)
 590		return 0;
 591
 592	return 1;
 593}
 594
 595/* Compare addresses exactly.
 596 * v4-mapped-v6 is also in consideration.
 597 */
 598static int sctp_v6_cmp_addr(const union sctp_addr *addr1,
 599			    const union sctp_addr *addr2)
 600{
 601	return __sctp_v6_cmp_addr(addr1, addr2) &&
 602	       addr1->v6.sin6_port == addr2->v6.sin6_port;
 603}
 604
 605/* Initialize addr struct to INADDR_ANY. */
 606static void sctp_v6_inaddr_any(union sctp_addr *addr, __be16 port)
 607{
 608	memset(addr, 0x00, sizeof(union sctp_addr));
 609	addr->v6.sin6_family = AF_INET6;
 610	addr->v6.sin6_port = port;
 611}
 612
 613/* Is this a wildcard address? */
 614static int sctp_v6_is_any(const union sctp_addr *addr)
 615{
 616	return ipv6_addr_any(&addr->v6.sin6_addr);
 617}
 618
 619/* Should this be available for binding?   */
 620static int sctp_v6_available(union sctp_addr *addr, struct sctp_sock *sp)
 621{
 622	int type;
 623	struct net *net = sock_net(&sp->inet.sk);
 624	const struct in6_addr *in6 = (const struct in6_addr *)&addr->v6.sin6_addr;
 625
 626	type = ipv6_addr_type(in6);
 627	if (IPV6_ADDR_ANY == type)
 628		return 1;
 629	if (type == IPV6_ADDR_MAPPED) {
 630		if (sp && ipv6_only_sock(sctp_opt2sk(sp)))
 631			return 0;
 632		sctp_v6_map_v4(addr);
 633		return sctp_get_af_specific(AF_INET)->available(addr, sp);
 634	}
 635	if (!(type & IPV6_ADDR_UNICAST))
 636		return 0;
 637
 638	return sp->inet.freebind || net->ipv6.sysctl.ip_nonlocal_bind ||
 639		ipv6_chk_addr(net, in6, NULL, 0);
 640}
 641
 642/* This function checks if the address is a valid address to be used for
 643 * SCTP.
 644 *
 645 * Output:
 646 * Return 0 - If the address is a non-unicast or an illegal address.
 647 * Return 1 - If the address is a unicast.
 648 */
 649static int sctp_v6_addr_valid(union sctp_addr *addr,
 650			      struct sctp_sock *sp,
 651			      const struct sk_buff *skb)
 652{
 653	int ret = ipv6_addr_type(&addr->v6.sin6_addr);
 654
 655	/* Support v4-mapped-v6 address. */
 656	if (ret == IPV6_ADDR_MAPPED) {
 657		/* Note: This routine is used in input, so v4-mapped-v6
 658		 * are disallowed here when there is no sctp_sock.
 659		 */
 660		if (sp && ipv6_only_sock(sctp_opt2sk(sp)))
 661			return 0;
 662		sctp_v6_map_v4(addr);
 663		return sctp_get_af_specific(AF_INET)->addr_valid(addr, sp, skb);
 664	}
 665
 666	/* Is this a non-unicast address */
 667	if (!(ret & IPV6_ADDR_UNICAST))
 668		return 0;
 669
 670	return 1;
 671}
 672
 673/* What is the scope of 'addr'?  */
 674static enum sctp_scope sctp_v6_scope(union sctp_addr *addr)
 675{
 676	enum sctp_scope retval;
 677	int v6scope;
 678
 679	/* The IPv6 scope is really a set of bit fields.
 680	 * See IFA_* in <net/if_inet6.h>.  Map to a generic SCTP scope.
 681	 */
 682
 683	v6scope = ipv6_addr_scope(&addr->v6.sin6_addr);
 684	switch (v6scope) {
 685	case IFA_HOST:
 686		retval = SCTP_SCOPE_LOOPBACK;
 687		break;
 688	case IFA_LINK:
 689		retval = SCTP_SCOPE_LINK;
 690		break;
 691	case IFA_SITE:
 692		retval = SCTP_SCOPE_PRIVATE;
 693		break;
 694	default:
 695		retval = SCTP_SCOPE_GLOBAL;
 696		break;
 697	}
 698
 699	return retval;
 700}
 701
 702/* Create and initialize a new sk for the socket to be returned by accept(). */
 703static struct sock *sctp_v6_create_accept_sk(struct sock *sk,
 704					     struct sctp_association *asoc,
 705					     bool kern)
 706{
 707	struct sock *newsk;
 708	struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
 709	struct sctp6_sock *newsctp6sk;
 710
 711	newsk = sk_alloc(sock_net(sk), PF_INET6, GFP_KERNEL, sk->sk_prot, kern);
 712	if (!newsk)
 713		goto out;
 714
 715	sock_init_data(NULL, newsk);
 716
 717	sctp_copy_sock(newsk, sk, asoc);
 718	sock_reset_flag(sk, SOCK_ZAPPED);
 719
 720	newsctp6sk = (struct sctp6_sock *)newsk;
 721	inet_sk(newsk)->pinet6 = &newsctp6sk->inet6;
 722
 723	sctp_sk(newsk)->v4mapped = sctp_sk(sk)->v4mapped;
 724
 725	newnp = inet6_sk(newsk);
 726
 727	memcpy(newnp, np, sizeof(struct ipv6_pinfo));
 728	newnp->ipv6_mc_list = NULL;
 729	newnp->ipv6_ac_list = NULL;
 730	newnp->ipv6_fl_list = NULL;
 731
 732	sctp_v6_copy_ip_options(sk, newsk);
 733
 734	/* Initialize sk's sport, dport, rcv_saddr and daddr for getsockname()
 735	 * and getpeername().
 736	 */
 737	sctp_v6_to_sk_daddr(&asoc->peer.primary_addr, newsk);
 738
 739	newsk->sk_v6_rcv_saddr = sk->sk_v6_rcv_saddr;
 740
 741	sk_refcnt_debug_inc(newsk);
 742
 743	if (newsk->sk_prot->init(newsk)) {
 744		sk_common_release(newsk);
 745		newsk = NULL;
 746	}
 747
 748out:
 749	return newsk;
 750}
 751
 752/* Format a sockaddr for return to user space. This makes sure the return is
 753 * AF_INET or AF_INET6 depending on the SCTP_I_WANT_MAPPED_V4_ADDR option.
 754 */
 755static int sctp_v6_addr_to_user(struct sctp_sock *sp, union sctp_addr *addr)
 756{
 757	if (sp->v4mapped) {
 758		if (addr->sa.sa_family == AF_INET)
 759			sctp_v4_map_v6(addr);
 760	} else {
 761		if (addr->sa.sa_family == AF_INET6 &&
 762		    ipv6_addr_v4mapped(&addr->v6.sin6_addr))
 763			sctp_v6_map_v4(addr);
 764	}
 765
 766	if (addr->sa.sa_family == AF_INET) {
 767		memset(addr->v4.sin_zero, 0, sizeof(addr->v4.sin_zero));
 768		return sizeof(struct sockaddr_in);
 769	}
 770	return sizeof(struct sockaddr_in6);
 771}
 772
 773/* Where did this skb come from?  */
 774static int sctp_v6_skb_iif(const struct sk_buff *skb)
 775{
 776	return IP6CB(skb)->iif;
 777}
 778
 779/* Was this packet marked by Explicit Congestion Notification? */
 780static int sctp_v6_is_ce(const struct sk_buff *skb)
 781{
 782	return *((__u32 *)(ipv6_hdr(skb))) & (__force __u32)htonl(1 << 20);
 783}
 784
 785/* Dump the v6 addr to the seq file. */
 786static void sctp_v6_seq_dump_addr(struct seq_file *seq, union sctp_addr *addr)
 787{
 788	seq_printf(seq, "%pI6 ", &addr->v6.sin6_addr);
 789}
 790
 791static void sctp_v6_ecn_capable(struct sock *sk)
 792{
 793	inet6_sk(sk)->tclass |= INET_ECN_ECT_0;
 794}
 795
 796/* Initialize a PF_INET msgname from a ulpevent. */
 797static void sctp_inet6_event_msgname(struct sctp_ulpevent *event,
 798				     char *msgname, int *addrlen)
 799{
 800	union sctp_addr *addr;
 801	struct sctp_association *asoc;
 802	union sctp_addr *paddr;
 803
 804	if (!msgname)
 805		return;
 806
 807	addr = (union sctp_addr *)msgname;
 808	asoc = event->asoc;
 809	paddr = &asoc->peer.primary_addr;
 810
 811	if (paddr->sa.sa_family == AF_INET) {
 812		addr->v4.sin_family = AF_INET;
 813		addr->v4.sin_port = htons(asoc->peer.port);
 814		addr->v4.sin_addr = paddr->v4.sin_addr;
 815	} else {
 816		addr->v6.sin6_family = AF_INET6;
 817		addr->v6.sin6_flowinfo = 0;
 818		if (ipv6_addr_type(&paddr->v6.sin6_addr) & IPV6_ADDR_LINKLOCAL)
 819			addr->v6.sin6_scope_id = paddr->v6.sin6_scope_id;
 820		else
 821			addr->v6.sin6_scope_id = 0;
 822		addr->v6.sin6_port = htons(asoc->peer.port);
 823		addr->v6.sin6_addr = paddr->v6.sin6_addr;
 824	}
 825
 826	*addrlen = sctp_v6_addr_to_user(sctp_sk(asoc->base.sk), addr);
 827}
 828
 829/* Initialize a msg_name from an inbound skb. */
 830static void sctp_inet6_skb_msgname(struct sk_buff *skb, char *msgname,
 831				   int *addr_len)
 832{
 833	union sctp_addr *addr;
 834	struct sctphdr *sh;
 835
 836	if (!msgname)
 837		return;
 838
 839	addr = (union sctp_addr *)msgname;
 840	sh = sctp_hdr(skb);
 841
 842	if (ip_hdr(skb)->version == 4) {
 843		addr->v4.sin_family = AF_INET;
 844		addr->v4.sin_port = sh->source;
 845		addr->v4.sin_addr.s_addr = ip_hdr(skb)->saddr;
 846	} else {
 847		addr->v6.sin6_family = AF_INET6;
 848		addr->v6.sin6_flowinfo = 0;
 849		addr->v6.sin6_port = sh->source;
 850		addr->v6.sin6_addr = ipv6_hdr(skb)->saddr;
 851		if (ipv6_addr_type(&addr->v6.sin6_addr) & IPV6_ADDR_LINKLOCAL)
 852			addr->v6.sin6_scope_id = sctp_v6_skb_iif(skb);
 853		else
 854			addr->v6.sin6_scope_id = 0;
 855	}
 856
 857	*addr_len = sctp_v6_addr_to_user(sctp_sk(skb->sk), addr);
 858}
 859
 860/* Do we support this AF? */
 861static int sctp_inet6_af_supported(sa_family_t family, struct sctp_sock *sp)
 862{
 863	switch (family) {
 864	case AF_INET6:
 865		return 1;
 866	/* v4-mapped-v6 addresses */
 867	case AF_INET:
 868		if (!__ipv6_only_sock(sctp_opt2sk(sp)))
 869			return 1;
 870		/* fallthru */
 871	default:
 872		return 0;
 873	}
 874}
 875
 876/* Address matching with wildcards allowed.  This extra level
 877 * of indirection lets us choose whether a PF_INET6 should
 878 * disallow any v4 addresses if we so choose.
 879 */
 880static int sctp_inet6_cmp_addr(const union sctp_addr *addr1,
 881			       const union sctp_addr *addr2,
 882			       struct sctp_sock *opt)
 883{
 884	struct sock *sk = sctp_opt2sk(opt);
 885	struct sctp_af *af1, *af2;
 886
 887	af1 = sctp_get_af_specific(addr1->sa.sa_family);
 888	af2 = sctp_get_af_specific(addr2->sa.sa_family);
 889
 890	if (!af1 || !af2)
 891		return 0;
 892
 893	/* If the socket is IPv6 only, v4 addrs will not match */
 894	if (__ipv6_only_sock(sk) && af1 != af2)
 895		return 0;
 896
 897	/* Today, wildcard AF_INET/AF_INET6. */
 898	if (sctp_is_any(sk, addr1) || sctp_is_any(sk, addr2))
 899		return 1;
 900
 901	if (addr1->sa.sa_family == AF_INET && addr2->sa.sa_family == AF_INET)
 902		return addr1->v4.sin_addr.s_addr == addr2->v4.sin_addr.s_addr;
 903
 904	return __sctp_v6_cmp_addr(addr1, addr2);
 905}
 906
 907/* Verify that the provided sockaddr looks bindable.   Common verification,
 908 * has already been taken care of.
 909 */
 910static int sctp_inet6_bind_verify(struct sctp_sock *opt, union sctp_addr *addr)
 911{
 912	struct sctp_af *af;
 913
 914	/* ASSERT: address family has already been verified. */
 915	if (addr->sa.sa_family != AF_INET6)
 916		af = sctp_get_af_specific(addr->sa.sa_family);
 917	else {
 918		int type = ipv6_addr_type(&addr->v6.sin6_addr);
 919		struct net_device *dev;
 920
 921		if (type & IPV6_ADDR_LINKLOCAL) {
 922			struct net *net;
 923			if (!addr->v6.sin6_scope_id)
 924				return 0;
 925			net = sock_net(&opt->inet.sk);
 926			rcu_read_lock();
 927			dev = dev_get_by_index_rcu(net, addr->v6.sin6_scope_id);
 928			if (!dev || !(opt->inet.freebind ||
 929				      net->ipv6.sysctl.ip_nonlocal_bind ||
 930				      ipv6_chk_addr(net, &addr->v6.sin6_addr,
 931						    dev, 0))) {
 932				rcu_read_unlock();
 933				return 0;
 934			}
 935			rcu_read_unlock();
 936		}
 937
 938		af = opt->pf->af;
 939	}
 940	return af->available(addr, opt);
 941}
 942
 943/* Verify that the provided sockaddr looks sendable.   Common verification,
 944 * has already been taken care of.
 945 */
 946static int sctp_inet6_send_verify(struct sctp_sock *opt, union sctp_addr *addr)
 947{
 948	struct sctp_af *af = NULL;
 949
 950	/* ASSERT: address family has already been verified. */
 951	if (addr->sa.sa_family != AF_INET6)
 952		af = sctp_get_af_specific(addr->sa.sa_family);
 953	else {
 954		int type = ipv6_addr_type(&addr->v6.sin6_addr);
 955		struct net_device *dev;
 956
 957		if (type & IPV6_ADDR_LINKLOCAL) {
 958			if (!addr->v6.sin6_scope_id)
 959				return 0;
 960			rcu_read_lock();
 961			dev = dev_get_by_index_rcu(sock_net(&opt->inet.sk),
 962						   addr->v6.sin6_scope_id);
 963			rcu_read_unlock();
 964			if (!dev)
 965				return 0;
 966		}
 967		af = opt->pf->af;
 968	}
 969
 970	return af != NULL;
 971}
 972
 973/* Fill in Supported Address Type information for INIT and INIT-ACK
 974 * chunks.   Note: In the future, we may want to look at sock options
 975 * to determine whether a PF_INET6 socket really wants to have IPV4
 976 * addresses.
 977 * Returns number of addresses supported.
 978 */
 979static int sctp_inet6_supported_addrs(const struct sctp_sock *opt,
 980				      __be16 *types)
 981{
 982	types[0] = SCTP_PARAM_IPV6_ADDRESS;
 983	if (!opt || !ipv6_only_sock(sctp_opt2sk(opt))) {
 984		types[1] = SCTP_PARAM_IPV4_ADDRESS;
 985		return 2;
 986	}
 987	return 1;
 988}
 989
 990/* Handle SCTP_I_WANT_MAPPED_V4_ADDR for getpeername() and getsockname() */
 991static int sctp_getname(struct socket *sock, struct sockaddr *uaddr,
 992			int peer)
 993{
 994	int rc;
 995
 996	rc = inet6_getname(sock, uaddr, peer);
 997
 998	if (rc < 0)
 999		return rc;
1000
1001	rc = sctp_v6_addr_to_user(sctp_sk(sock->sk),
1002					  (union sctp_addr *)uaddr);
1003
1004	return rc;
1005}
1006
1007static const struct proto_ops inet6_seqpacket_ops = {
1008	.family		   = PF_INET6,
1009	.owner		   = THIS_MODULE,
1010	.release	   = inet6_release,
1011	.bind		   = inet6_bind,
1012	.connect	   = sctp_inet_connect,
1013	.socketpair	   = sock_no_socketpair,
1014	.accept		   = inet_accept,
1015	.getname	   = sctp_getname,
1016	.poll		   = sctp_poll,
1017	.ioctl		   = inet6_ioctl,
1018	.gettstamp	   = sock_gettstamp,
1019	.listen		   = sctp_inet_listen,
1020	.shutdown	   = inet_shutdown,
1021	.setsockopt	   = sock_common_setsockopt,
1022	.getsockopt	   = sock_common_getsockopt,
1023	.sendmsg	   = inet_sendmsg,
1024	.recvmsg	   = inet_recvmsg,
1025	.mmap		   = sock_no_mmap,
1026#ifdef CONFIG_COMPAT
1027	.compat_setsockopt = compat_sock_common_setsockopt,
1028	.compat_getsockopt = compat_sock_common_getsockopt,
1029#endif
1030};
1031
1032static struct inet_protosw sctpv6_seqpacket_protosw = {
1033	.type          = SOCK_SEQPACKET,
1034	.protocol      = IPPROTO_SCTP,
1035	.prot 	       = &sctpv6_prot,
1036	.ops           = &inet6_seqpacket_ops,
1037	.flags         = SCTP_PROTOSW_FLAG
1038};
1039static struct inet_protosw sctpv6_stream_protosw = {
1040	.type          = SOCK_STREAM,
1041	.protocol      = IPPROTO_SCTP,
1042	.prot 	       = &sctpv6_prot,
1043	.ops           = &inet6_seqpacket_ops,
1044	.flags         = SCTP_PROTOSW_FLAG,
1045};
1046
1047static int sctp6_rcv(struct sk_buff *skb)
1048{
1049	return sctp_rcv(skb) ? -1 : 0;
1050}
1051
1052static const struct inet6_protocol sctpv6_protocol = {
1053	.handler      = sctp6_rcv,
1054	.err_handler  = sctp_v6_err,
1055	.flags        = INET6_PROTO_NOPOLICY | INET6_PROTO_FINAL,
1056};
1057
1058static struct sctp_af sctp_af_inet6 = {
1059	.sa_family	   = AF_INET6,
1060	.sctp_xmit	   = sctp_v6_xmit,
1061	.setsockopt	   = ipv6_setsockopt,
1062	.getsockopt	   = ipv6_getsockopt,
1063	.get_dst	   = sctp_v6_get_dst,
1064	.get_saddr	   = sctp_v6_get_saddr,
1065	.copy_addrlist	   = sctp_v6_copy_addrlist,
1066	.from_skb	   = sctp_v6_from_skb,
1067	.from_sk	   = sctp_v6_from_sk,
1068	.from_addr_param   = sctp_v6_from_addr_param,
1069	.to_addr_param	   = sctp_v6_to_addr_param,
1070	.cmp_addr	   = sctp_v6_cmp_addr,
1071	.scope		   = sctp_v6_scope,
1072	.addr_valid	   = sctp_v6_addr_valid,
1073	.inaddr_any	   = sctp_v6_inaddr_any,
1074	.is_any		   = sctp_v6_is_any,
1075	.available	   = sctp_v6_available,
1076	.skb_iif	   = sctp_v6_skb_iif,
1077	.is_ce		   = sctp_v6_is_ce,
1078	.seq_dump_addr	   = sctp_v6_seq_dump_addr,
1079	.ecn_capable	   = sctp_v6_ecn_capable,
1080	.net_header_len	   = sizeof(struct ipv6hdr),
1081	.sockaddr_len	   = sizeof(struct sockaddr_in6),
1082	.ip_options_len	   = sctp_v6_ip_options_len,
1083#ifdef CONFIG_COMPAT
1084	.compat_setsockopt = compat_ipv6_setsockopt,
1085	.compat_getsockopt = compat_ipv6_getsockopt,
1086#endif
1087};
1088
1089static struct sctp_pf sctp_pf_inet6 = {
1090	.event_msgname = sctp_inet6_event_msgname,
1091	.skb_msgname   = sctp_inet6_skb_msgname,
1092	.af_supported  = sctp_inet6_af_supported,
1093	.cmp_addr      = sctp_inet6_cmp_addr,
1094	.bind_verify   = sctp_inet6_bind_verify,
1095	.send_verify   = sctp_inet6_send_verify,
1096	.supported_addrs = sctp_inet6_supported_addrs,
1097	.create_accept_sk = sctp_v6_create_accept_sk,
1098	.addr_to_user  = sctp_v6_addr_to_user,
1099	.to_sk_saddr   = sctp_v6_to_sk_saddr,
1100	.to_sk_daddr   = sctp_v6_to_sk_daddr,
1101	.copy_ip_options = sctp_v6_copy_ip_options,
1102	.af            = &sctp_af_inet6,
1103};
1104
1105/* Initialize IPv6 support and register with socket layer.  */
1106void sctp_v6_pf_init(void)
1107{
1108	/* Register the SCTP specific PF_INET6 functions. */
1109	sctp_register_pf(&sctp_pf_inet6, PF_INET6);
1110
1111	/* Register the SCTP specific AF_INET6 functions. */
1112	sctp_register_af(&sctp_af_inet6);
1113}
1114
1115void sctp_v6_pf_exit(void)
1116{
1117	list_del(&sctp_af_inet6.list);
1118}
1119
1120/* Initialize IPv6 support and register with socket layer.  */
1121int sctp_v6_protosw_init(void)
1122{
1123	int rc;
1124
1125	rc = proto_register(&sctpv6_prot, 1);
1126	if (rc)
1127		return rc;
1128
1129	/* Add SCTPv6(UDP and TCP style) to inetsw6 linked list. */
1130	inet6_register_protosw(&sctpv6_seqpacket_protosw);
1131	inet6_register_protosw(&sctpv6_stream_protosw);
1132
1133	return 0;
1134}
1135
1136void sctp_v6_protosw_exit(void)
1137{
1138	inet6_unregister_protosw(&sctpv6_seqpacket_protosw);
1139	inet6_unregister_protosw(&sctpv6_stream_protosw);
1140	proto_unregister(&sctpv6_prot);
1141}
1142
1143
1144/* Register with inet6 layer. */
1145int sctp_v6_add_protocol(void)
1146{
1147	/* Register notifier for inet6 address additions/deletions. */
1148	register_inet6addr_notifier(&sctp_inet6addr_notifier);
1149
1150	if (inet6_add_protocol(&sctpv6_protocol, IPPROTO_SCTP) < 0)
1151		return -EAGAIN;
1152
1153	return 0;
1154}
1155
1156/* Unregister with inet6 layer. */
1157void sctp_v6_del_protocol(void)
1158{
1159	inet6_del_protocol(&sctpv6_protocol, IPPROTO_SCTP);
1160	unregister_inet6addr_notifier(&sctp_inet6addr_notifier);
1161}