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