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