1 // SPDX-License-Identifier: GPL-2.0-or-later <<
2 /* SCTP kernel implementation 1 /* SCTP kernel implementation
3 * (C) Copyright IBM Corp. 2001, 2004 2 * (C) Copyright IBM Corp. 2001, 2004
4 * Copyright (c) 1999-2000 Cisco, Inc. 3 * Copyright (c) 1999-2000 Cisco, Inc.
5 * Copyright (c) 1999-2001 Motorola, Inc. 4 * Copyright (c) 1999-2001 Motorola, Inc.
6 * Copyright (c) 2001-2003 Intel Corp. 5 * Copyright (c) 2001-2003 Intel Corp.
7 * Copyright (c) 2001-2002 Nokia, Inc. 6 * Copyright (c) 2001-2002 Nokia, Inc.
8 * Copyright (c) 2001 La Monte H.P. Yarroll 7 * Copyright (c) 2001 La Monte H.P. Yarroll
9 * 8 *
10 * This file is part of the SCTP kernel implem 9 * This file is part of the SCTP kernel implementation
11 * 10 *
12 * These functions interface with the sockets 11 * These functions interface with the sockets layer to implement the
13 * SCTP Extensions for the Sockets API. 12 * SCTP Extensions for the Sockets API.
14 * 13 *
15 * Note that the descriptions from the specifi 14 * Note that the descriptions from the specification are USER level
16 * functions--this file is the functions which 15 * functions--this file is the functions which populate the struct proto
17 * for SCTP which is the BOTTOM of the sockets 16 * for SCTP which is the BOTTOM of the sockets interface.
18 * 17 *
>> 18 * This SCTP implementation is free software;
>> 19 * you can redistribute it and/or modify it under the terms of
>> 20 * the GNU General Public License as published by
>> 21 * the Free Software Foundation; either version 2, or (at your option)
>> 22 * any later version.
>> 23 *
>> 24 * This SCTP implementation is distributed in the hope that it
>> 25 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
>> 26 * ************************
>> 27 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>> 28 * See the GNU General Public License for more details.
>> 29 *
>> 30 * You should have received a copy of the GNU General Public License
>> 31 * along with GNU CC; see the file COPYING. If not, see
>> 32 * <http://www.gnu.org/licenses/>.
>> 33 *
19 * Please send any bug reports or fixes you ma 34 * Please send any bug reports or fixes you make to the
20 * email address(es): 35 * email address(es):
21 * lksctp developers <linux-sctp@vger.kerne 36 * lksctp developers <linux-sctp@vger.kernel.org>
22 * 37 *
23 * Written or modified by: 38 * Written or modified by:
24 * La Monte H.P. Yarroll <piggy@acm.org> 39 * La Monte H.P. Yarroll <piggy@acm.org>
25 * Narasimha Budihal <narsi@refcode.org 40 * Narasimha Budihal <narsi@refcode.org>
26 * Karl Knutson <karl@athena.chica 41 * Karl Knutson <karl@athena.chicago.il.us>
27 * Jon Grimm <jgrimm@us.ibm.com 42 * Jon Grimm <jgrimm@us.ibm.com>
28 * Xingang Guo <xingang.guo@intel 43 * Xingang Guo <xingang.guo@intel.com>
29 * Daisy Chang <daisyc@us.ibm.com 44 * Daisy Chang <daisyc@us.ibm.com>
30 * Sridhar Samudrala <samudrala@us.ibm. 45 * Sridhar Samudrala <samudrala@us.ibm.com>
31 * Inaky Perez-Gonzalez <inaky.gonzalez@in 46 * Inaky Perez-Gonzalez <inaky.gonzalez@intel.com>
32 * Ardelle Fan <ardelle.fan@intel 47 * Ardelle Fan <ardelle.fan@intel.com>
33 * Ryan Layer <rmlayer@us.ibm.co 48 * Ryan Layer <rmlayer@us.ibm.com>
34 * Anup Pemmaiah <pemmaiah@cc.usu.e 49 * Anup Pemmaiah <pemmaiah@cc.usu.edu>
35 * Kevin Gao <kevin.gao@intel.c 50 * Kevin Gao <kevin.gao@intel.com>
36 */ 51 */
37 52
38 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 53 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
39 54
40 #include <crypto/hash.h> 55 #include <crypto/hash.h>
41 #include <linux/types.h> 56 #include <linux/types.h>
42 #include <linux/kernel.h> 57 #include <linux/kernel.h>
43 #include <linux/wait.h> 58 #include <linux/wait.h>
44 #include <linux/time.h> 59 #include <linux/time.h>
45 #include <linux/sched/signal.h> 60 #include <linux/sched/signal.h>
46 #include <linux/ip.h> 61 #include <linux/ip.h>
47 #include <linux/capability.h> 62 #include <linux/capability.h>
48 #include <linux/fcntl.h> 63 #include <linux/fcntl.h>
49 #include <linux/poll.h> 64 #include <linux/poll.h>
50 #include <linux/init.h> 65 #include <linux/init.h>
51 #include <linux/slab.h> 66 #include <linux/slab.h>
52 #include <linux/file.h> 67 #include <linux/file.h>
53 #include <linux/compat.h> 68 #include <linux/compat.h>
54 #include <linux/rhashtable.h> <<
55 69
56 #include <net/ip.h> 70 #include <net/ip.h>
57 #include <net/icmp.h> 71 #include <net/icmp.h>
58 #include <net/route.h> 72 #include <net/route.h>
59 #include <net/ipv6.h> 73 #include <net/ipv6.h>
60 #include <net/inet_common.h> 74 #include <net/inet_common.h>
61 #include <net/busy_poll.h> 75 #include <net/busy_poll.h>
62 #include <trace/events/sock.h> <<
63 76
64 #include <linux/socket.h> /* for sa_family_t * 77 #include <linux/socket.h> /* for sa_family_t */
65 #include <linux/export.h> 78 #include <linux/export.h>
66 #include <net/sock.h> 79 #include <net/sock.h>
67 #include <net/sctp/sctp.h> 80 #include <net/sctp/sctp.h>
68 #include <net/sctp/sm.h> 81 #include <net/sctp/sm.h>
69 #include <net/sctp/stream_sched.h> <<
70 #include <net/rps.h> <<
71 82
72 /* Forward declarations for internal helper fu 83 /* Forward declarations for internal helper functions. */
73 static bool sctp_writeable(const struct sock * !! 84 static int sctp_writeable(struct sock *sk);
74 static void sctp_wfree(struct sk_buff *skb); 85 static void sctp_wfree(struct sk_buff *skb);
75 static int sctp_wait_for_sndbuf(struct sctp_as 86 static int sctp_wait_for_sndbuf(struct sctp_association *asoc, long *timeo_p,
76 size_t msg_len 87 size_t msg_len);
77 static int sctp_wait_for_packet(struct sock *s 88 static int sctp_wait_for_packet(struct sock *sk, int *err, long *timeo_p);
78 static int sctp_wait_for_connect(struct sctp_a 89 static int sctp_wait_for_connect(struct sctp_association *, long *timeo_p);
79 static int sctp_wait_for_accept(struct sock *s 90 static int sctp_wait_for_accept(struct sock *sk, long timeo);
80 static void sctp_wait_for_close(struct sock *s 91 static void sctp_wait_for_close(struct sock *sk, long timeo);
81 static void sctp_destruct_sock(struct sock *sk 92 static void sctp_destruct_sock(struct sock *sk);
82 static struct sctp_af *sctp_sockaddr_af(struct 93 static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt,
83 union 94 union sctp_addr *addr, int len);
84 static int sctp_bindx_add(struct sock *, struc 95 static int sctp_bindx_add(struct sock *, struct sockaddr *, int);
85 static int sctp_bindx_rem(struct sock *, struc 96 static int sctp_bindx_rem(struct sock *, struct sockaddr *, int);
86 static int sctp_send_asconf_add_ip(struct sock 97 static int sctp_send_asconf_add_ip(struct sock *, struct sockaddr *, int);
87 static int sctp_send_asconf_del_ip(struct sock 98 static int sctp_send_asconf_del_ip(struct sock *, struct sockaddr *, int);
88 static int sctp_send_asconf(struct sctp_associ 99 static int sctp_send_asconf(struct sctp_association *asoc,
89 struct sctp_chunk 100 struct sctp_chunk *chunk);
90 static int sctp_do_bind(struct sock *, union s 101 static int sctp_do_bind(struct sock *, union sctp_addr *, int);
91 static int sctp_autobind(struct sock *sk); 102 static int sctp_autobind(struct sock *sk);
92 static int sctp_sock_migrate(struct sock *olds !! 103 static void sctp_sock_migrate(struct sock *oldsk, struct sock *newsk,
93 struct sctp_assoc !! 104 struct sctp_association *assoc,
94 enum sctp_socket_ !! 105 enum sctp_socket_type type);
95 106
96 static unsigned long sctp_memory_pressure; 107 static unsigned long sctp_memory_pressure;
97 static atomic_long_t sctp_memory_allocated; 108 static atomic_long_t sctp_memory_allocated;
98 static DEFINE_PER_CPU(int, sctp_memory_per_cpu <<
99 struct percpu_counter sctp_sockets_allocated; 109 struct percpu_counter sctp_sockets_allocated;
100 110
101 static void sctp_enter_memory_pressure(struct 111 static void sctp_enter_memory_pressure(struct sock *sk)
102 { 112 {
103 WRITE_ONCE(sctp_memory_pressure, 1); 113 WRITE_ONCE(sctp_memory_pressure, 1);
104 } 114 }
105 115
106 116
107 /* Get the sndbuf space available at the time 117 /* Get the sndbuf space available at the time on the association. */
108 static inline int sctp_wspace(struct sctp_asso 118 static inline int sctp_wspace(struct sctp_association *asoc)
109 { 119 {
110 struct sock *sk = asoc->base.sk; !! 120 int amt;
111 121
112 return asoc->ep->sndbuf_policy ? sk->s !! 122 if (asoc->ep->sndbuf_policy)
113 : sk_st !! 123 amt = asoc->sndbuf_used;
>> 124 else
>> 125 amt = sk_wmem_alloc_get(asoc->base.sk);
>> 126
>> 127 if (amt >= asoc->base.sk->sk_sndbuf) {
>> 128 if (asoc->base.sk->sk_userlocks & SOCK_SNDBUF_LOCK)
>> 129 amt = 0;
>> 130 else {
>> 131 amt = sk_stream_wspace(asoc->base.sk);
>> 132 if (amt < 0)
>> 133 amt = 0;
>> 134 }
>> 135 } else {
>> 136 amt = asoc->base.sk->sk_sndbuf - amt;
>> 137 }
>> 138 return amt;
114 } 139 }
115 140
116 /* Increment the used sndbuf space count of th 141 /* Increment the used sndbuf space count of the corresponding association by
117 * the size of the outgoing data chunk. 142 * the size of the outgoing data chunk.
118 * Also, set the skb destructor for sndbuf acc 143 * Also, set the skb destructor for sndbuf accounting later.
119 * 144 *
120 * Since it is always 1-1 between chunk and sk 145 * Since it is always 1-1 between chunk and skb, and also a new skb is always
121 * allocated for chunk bundling in sctp_packet 146 * allocated for chunk bundling in sctp_packet_transmit(), we can use the
122 * destructor in the data chunk skb for the pu 147 * destructor in the data chunk skb for the purpose of the sndbuf space
123 * tracking. 148 * tracking.
124 */ 149 */
125 static inline void sctp_set_owner_w(struct sct 150 static inline void sctp_set_owner_w(struct sctp_chunk *chunk)
126 { 151 {
127 struct sctp_association *asoc = chunk- 152 struct sctp_association *asoc = chunk->asoc;
128 struct sock *sk = asoc->base.sk; 153 struct sock *sk = asoc->base.sk;
129 154
130 /* The sndbuf space is tracked per ass 155 /* The sndbuf space is tracked per association. */
131 sctp_association_hold(asoc); 156 sctp_association_hold(asoc);
132 157
133 if (chunk->shkey) <<
134 sctp_auth_shkey_hold(chunk->sh <<
135 <<
136 skb_set_owner_w(chunk->skb, sk); 158 skb_set_owner_w(chunk->skb, sk);
137 159
138 chunk->skb->destructor = sctp_wfree; 160 chunk->skb->destructor = sctp_wfree;
139 /* Save the chunk pointer in skb for s 161 /* Save the chunk pointer in skb for sctp_wfree to use later. */
140 skb_shinfo(chunk->skb)->destructor_arg 162 skb_shinfo(chunk->skb)->destructor_arg = chunk;
141 163
>> 164 asoc->sndbuf_used += SCTP_DATA_SNDSIZE(chunk) +
>> 165 sizeof(struct sk_buff) +
>> 166 sizeof(struct sctp_chunk);
>> 167
142 refcount_add(sizeof(struct sctp_chunk) 168 refcount_add(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc);
143 asoc->sndbuf_used += chunk->skb->trues !! 169 sk->sk_wmem_queued += chunk->skb->truesize;
144 sk_wmem_queued_add(sk, chunk->skb->tru <<
145 sk_mem_charge(sk, chunk->skb->truesize 170 sk_mem_charge(sk, chunk->skb->truesize);
146 } 171 }
147 172
148 static void sctp_clear_owner_w(struct sctp_chu 173 static void sctp_clear_owner_w(struct sctp_chunk *chunk)
149 { 174 {
150 skb_orphan(chunk->skb); 175 skb_orphan(chunk->skb);
151 } 176 }
152 177
153 #define traverse_and_process() \ 178 #define traverse_and_process() \
154 do { \ 179 do { \
155 msg = chunk->msg; \ 180 msg = chunk->msg; \
156 if (msg == prev_msg) \ 181 if (msg == prev_msg) \
157 continue; \ 182 continue; \
158 list_for_each_entry(c, &msg->chunks, f 183 list_for_each_entry(c, &msg->chunks, frag_list) { \
159 if ((clear && asoc->base.sk == 184 if ((clear && asoc->base.sk == c->skb->sk) || \
160 (!clear && asoc->base.sk ! 185 (!clear && asoc->base.sk != c->skb->sk)) \
161 cb(c); \ 186 cb(c); \
162 } \ 187 } \
163 prev_msg = msg; \ 188 prev_msg = msg; \
164 } while (0) 189 } while (0)
165 190
166 static void sctp_for_each_tx_datachunk(struct 191 static void sctp_for_each_tx_datachunk(struct sctp_association *asoc,
167 bool cl 192 bool clear,
168 void (* 193 void (*cb)(struct sctp_chunk *))
169 194
170 { 195 {
171 struct sctp_datamsg *msg, *prev_msg = 196 struct sctp_datamsg *msg, *prev_msg = NULL;
172 struct sctp_outq *q = &asoc->outqueue; 197 struct sctp_outq *q = &asoc->outqueue;
173 struct sctp_chunk *chunk, *c; 198 struct sctp_chunk *chunk, *c;
174 struct sctp_transport *t; 199 struct sctp_transport *t;
175 200
176 list_for_each_entry(t, &asoc->peer.tra 201 list_for_each_entry(t, &asoc->peer.transport_addr_list, transports)
177 list_for_each_entry(chunk, &t- 202 list_for_each_entry(chunk, &t->transmitted, transmitted_list)
178 traverse_and_process() 203 traverse_and_process();
179 204
180 list_for_each_entry(chunk, &q->retrans 205 list_for_each_entry(chunk, &q->retransmit, transmitted_list)
181 traverse_and_process(); 206 traverse_and_process();
182 207
183 list_for_each_entry(chunk, &q->sacked, 208 list_for_each_entry(chunk, &q->sacked, transmitted_list)
184 traverse_and_process(); 209 traverse_and_process();
185 210
186 list_for_each_entry(chunk, &q->abandon 211 list_for_each_entry(chunk, &q->abandoned, transmitted_list)
187 traverse_and_process(); 212 traverse_and_process();
188 213
189 list_for_each_entry(chunk, &q->out_chu 214 list_for_each_entry(chunk, &q->out_chunk_list, list)
190 traverse_and_process(); 215 traverse_and_process();
191 } 216 }
192 217
193 static void sctp_for_each_rx_skb(struct sctp_a <<
194 void (*cb)(st <<
195 <<
196 { <<
197 struct sk_buff *skb, *tmp; <<
198 <<
199 sctp_skb_for_each(skb, &asoc->ulpq.lob <<
200 cb(skb, sk); <<
201 <<
202 sctp_skb_for_each(skb, &asoc->ulpq.rea <<
203 cb(skb, sk); <<
204 <<
205 sctp_skb_for_each(skb, &asoc->ulpq.rea <<
206 cb(skb, sk); <<
207 } <<
208 <<
209 /* Verify that this is a valid address. */ 218 /* Verify that this is a valid address. */
210 static inline int sctp_verify_addr(struct sock 219 static inline int sctp_verify_addr(struct sock *sk, union sctp_addr *addr,
211 int len) 220 int len)
212 { 221 {
213 struct sctp_af *af; 222 struct sctp_af *af;
214 223
215 /* Verify basic sockaddr. */ 224 /* Verify basic sockaddr. */
216 af = sctp_sockaddr_af(sctp_sk(sk), add 225 af = sctp_sockaddr_af(sctp_sk(sk), addr, len);
217 if (!af) 226 if (!af)
218 return -EINVAL; 227 return -EINVAL;
219 228
220 /* Is this a valid SCTP address? */ 229 /* Is this a valid SCTP address? */
221 if (!af->addr_valid(addr, sctp_sk(sk), 230 if (!af->addr_valid(addr, sctp_sk(sk), NULL))
222 return -EINVAL; 231 return -EINVAL;
223 232
224 if (!sctp_sk(sk)->pf->send_verify(sctp 233 if (!sctp_sk(sk)->pf->send_verify(sctp_sk(sk), (addr)))
225 return -EINVAL; 234 return -EINVAL;
226 235
227 return 0; 236 return 0;
228 } 237 }
229 238
230 /* Look up the association by its id. If this 239 /* Look up the association by its id. If this is not a UDP-style
231 * socket, the ID field is always ignored. 240 * socket, the ID field is always ignored.
232 */ 241 */
233 struct sctp_association *sctp_id2assoc(struct 242 struct sctp_association *sctp_id2assoc(struct sock *sk, sctp_assoc_t id)
234 { 243 {
235 struct sctp_association *asoc = NULL; 244 struct sctp_association *asoc = NULL;
236 245
237 /* If this is not a UDP-style socket, 246 /* If this is not a UDP-style socket, assoc id should be ignored. */
238 if (!sctp_style(sk, UDP)) { 247 if (!sctp_style(sk, UDP)) {
239 /* Return NULL if the socket s 248 /* Return NULL if the socket state is not ESTABLISHED. It
240 * could be a TCP-style listen 249 * could be a TCP-style listening socket or a socket which
241 * hasn't yet called connect() 250 * hasn't yet called connect() to establish an association.
242 */ 251 */
243 if (!sctp_sstate(sk, ESTABLISH 252 if (!sctp_sstate(sk, ESTABLISHED) && !sctp_sstate(sk, CLOSING))
244 return NULL; 253 return NULL;
245 254
246 /* Get the first and the only 255 /* Get the first and the only association from the list. */
247 if (!list_empty(&sctp_sk(sk)-> 256 if (!list_empty(&sctp_sk(sk)->ep->asocs))
248 asoc = list_entry(sctp 257 asoc = list_entry(sctp_sk(sk)->ep->asocs.next,
249 stru 258 struct sctp_association, asocs);
250 return asoc; 259 return asoc;
251 } 260 }
252 261
253 /* Otherwise this is a UDP-style socke 262 /* Otherwise this is a UDP-style socket. */
254 if (id <= SCTP_ALL_ASSOC) !! 263 if (!id || (id == (sctp_assoc_t)-1))
255 return NULL; 264 return NULL;
256 265
257 spin_lock_bh(&sctp_assocs_id_lock); 266 spin_lock_bh(&sctp_assocs_id_lock);
258 asoc = (struct sctp_association *)idr_ 267 asoc = (struct sctp_association *)idr_find(&sctp_assocs_id, (int)id);
259 if (asoc && (asoc->base.sk != sk || as 268 if (asoc && (asoc->base.sk != sk || asoc->base.dead))
260 asoc = NULL; 269 asoc = NULL;
261 spin_unlock_bh(&sctp_assocs_id_lock); 270 spin_unlock_bh(&sctp_assocs_id_lock);
262 271
263 return asoc; 272 return asoc;
264 } 273 }
265 274
266 /* Look up the transport from an address and a 275 /* Look up the transport from an address and an assoc id. If both address and
267 * id are specified, the associations matching 276 * id are specified, the associations matching the address and the id should be
268 * the same. 277 * the same.
269 */ 278 */
270 static struct sctp_transport *sctp_addr_id2tra 279 static struct sctp_transport *sctp_addr_id2transport(struct sock *sk,
271 280 struct sockaddr_storage *addr,
272 281 sctp_assoc_t id)
273 { 282 {
274 struct sctp_association *addr_asoc = N 283 struct sctp_association *addr_asoc = NULL, *id_asoc = NULL;
275 struct sctp_af *af = sctp_get_af_speci 284 struct sctp_af *af = sctp_get_af_specific(addr->ss_family);
276 union sctp_addr *laddr = (union sctp_a 285 union sctp_addr *laddr = (union sctp_addr *)addr;
277 struct sctp_transport *transport; 286 struct sctp_transport *transport;
278 287
279 if (!af || sctp_verify_addr(sk, laddr, 288 if (!af || sctp_verify_addr(sk, laddr, af->sockaddr_len))
280 return NULL; 289 return NULL;
281 290
282 addr_asoc = sctp_endpoint_lookup_assoc 291 addr_asoc = sctp_endpoint_lookup_assoc(sctp_sk(sk)->ep,
283 292 laddr,
284 293 &transport);
285 294
286 if (!addr_asoc) 295 if (!addr_asoc)
287 return NULL; 296 return NULL;
288 297
289 id_asoc = sctp_id2assoc(sk, id); 298 id_asoc = sctp_id2assoc(sk, id);
290 if (id_asoc && (id_asoc != addr_asoc)) 299 if (id_asoc && (id_asoc != addr_asoc))
291 return NULL; 300 return NULL;
292 301
293 sctp_get_pf_specific(sk->sk_family)->a 302 sctp_get_pf_specific(sk->sk_family)->addr_to_user(sctp_sk(sk),
294 303 (union sctp_addr *)addr);
295 304
296 return transport; 305 return transport;
297 } 306 }
298 307
299 /* API 3.1.2 bind() - UDP Style Syntax 308 /* API 3.1.2 bind() - UDP Style Syntax
300 * The syntax of bind() is, 309 * The syntax of bind() is,
301 * 310 *
302 * ret = bind(int sd, struct sockaddr *addr, 311 * ret = bind(int sd, struct sockaddr *addr, int addrlen);
303 * 312 *
304 * sd - the socket descriptor returned 313 * sd - the socket descriptor returned by socket().
305 * addr - the address structure (struct s 314 * addr - the address structure (struct sockaddr_in or struct
306 * sockaddr_in6 [RFC 2553]), 315 * sockaddr_in6 [RFC 2553]),
307 * addr_len - the size of the address struct 316 * addr_len - the size of the address structure.
308 */ 317 */
309 static int sctp_bind(struct sock *sk, struct s 318 static int sctp_bind(struct sock *sk, struct sockaddr *addr, int addr_len)
310 { 319 {
311 int retval = 0; 320 int retval = 0;
312 321
313 lock_sock(sk); 322 lock_sock(sk);
314 323
315 pr_debug("%s: sk:%p, addr:%p, addr_len 324 pr_debug("%s: sk:%p, addr:%p, addr_len:%d\n", __func__, sk,
316 addr, addr_len); 325 addr, addr_len);
317 326
318 /* Disallow binding twice. */ 327 /* Disallow binding twice. */
319 if (!sctp_sk(sk)->ep->base.bind_addr.p 328 if (!sctp_sk(sk)->ep->base.bind_addr.port)
320 retval = sctp_do_bind(sk, (uni 329 retval = sctp_do_bind(sk, (union sctp_addr *)addr,
321 addr_len 330 addr_len);
322 else 331 else
323 retval = -EINVAL; 332 retval = -EINVAL;
324 333
325 release_sock(sk); 334 release_sock(sk);
326 335
327 return retval; 336 return retval;
328 } 337 }
329 338
330 static int sctp_get_port_local(struct sock *, !! 339 static long sctp_get_port_local(struct sock *, union sctp_addr *);
331 340
332 /* Verify this is a valid sockaddr. */ 341 /* Verify this is a valid sockaddr. */
333 static struct sctp_af *sctp_sockaddr_af(struct 342 static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt,
334 union 343 union sctp_addr *addr, int len)
335 { 344 {
336 struct sctp_af *af; 345 struct sctp_af *af;
337 346
338 /* Check minimum size. */ 347 /* Check minimum size. */
339 if (len < sizeof (struct sockaddr)) 348 if (len < sizeof (struct sockaddr))
340 return NULL; 349 return NULL;
341 350
342 if (!opt->pf->af_supported(addr->sa.sa 351 if (!opt->pf->af_supported(addr->sa.sa_family, opt))
343 return NULL; 352 return NULL;
344 353
345 if (addr->sa.sa_family == AF_INET6) { 354 if (addr->sa.sa_family == AF_INET6) {
346 if (len < SIN6_LEN_RFC2133) 355 if (len < SIN6_LEN_RFC2133)
347 return NULL; 356 return NULL;
348 /* V4 mapped address are reall 357 /* V4 mapped address are really of AF_INET family */
349 if (ipv6_addr_v4mapped(&addr-> 358 if (ipv6_addr_v4mapped(&addr->v6.sin6_addr) &&
350 !opt->pf->af_supported(AF_ 359 !opt->pf->af_supported(AF_INET, opt))
351 return NULL; 360 return NULL;
352 } 361 }
353 362
354 /* If we get this far, af is valid. */ 363 /* If we get this far, af is valid. */
355 af = sctp_get_af_specific(addr->sa.sa_ 364 af = sctp_get_af_specific(addr->sa.sa_family);
356 365
357 if (len < af->sockaddr_len) 366 if (len < af->sockaddr_len)
358 return NULL; 367 return NULL;
359 368
360 return af; 369 return af;
361 } 370 }
362 371
363 static void sctp_auto_asconf_init(struct sctp_ 372 static void sctp_auto_asconf_init(struct sctp_sock *sp)
364 { 373 {
365 struct net *net = sock_net(&sp->inet.s 374 struct net *net = sock_net(&sp->inet.sk);
366 375
367 if (net->sctp.default_auto_asconf) { 376 if (net->sctp.default_auto_asconf) {
368 spin_lock_bh(&net->sctp.addr_w 377 spin_lock_bh(&net->sctp.addr_wq_lock);
369 list_add_tail(&sp->auto_asconf 378 list_add_tail(&sp->auto_asconf_list, &net->sctp.auto_asconf_splist);
370 spin_unlock_bh(&net->sctp.addr 379 spin_unlock_bh(&net->sctp.addr_wq_lock);
371 sp->do_auto_asconf = 1; 380 sp->do_auto_asconf = 1;
372 } 381 }
373 } 382 }
374 383
375 /* Bind a local address either to an endpoint 384 /* Bind a local address either to an endpoint or to an association. */
376 static int sctp_do_bind(struct sock *sk, union 385 static int sctp_do_bind(struct sock *sk, union sctp_addr *addr, int len)
377 { 386 {
378 struct net *net = sock_net(sk); 387 struct net *net = sock_net(sk);
379 struct sctp_sock *sp = sctp_sk(sk); 388 struct sctp_sock *sp = sctp_sk(sk);
380 struct sctp_endpoint *ep = sp->ep; 389 struct sctp_endpoint *ep = sp->ep;
381 struct sctp_bind_addr *bp = &ep->base. 390 struct sctp_bind_addr *bp = &ep->base.bind_addr;
382 struct sctp_af *af; 391 struct sctp_af *af;
383 unsigned short snum; 392 unsigned short snum;
384 int ret = 0; 393 int ret = 0;
385 394
386 /* Common sockaddr verification. */ 395 /* Common sockaddr verification. */
387 af = sctp_sockaddr_af(sp, addr, len); 396 af = sctp_sockaddr_af(sp, addr, len);
388 if (!af) { 397 if (!af) {
389 pr_debug("%s: sk:%p, newaddr:% 398 pr_debug("%s: sk:%p, newaddr:%p, len:%d EINVAL\n",
390 __func__, sk, addr, l 399 __func__, sk, addr, len);
391 return -EINVAL; 400 return -EINVAL;
392 } 401 }
393 402
394 snum = ntohs(addr->v4.sin_port); 403 snum = ntohs(addr->v4.sin_port);
395 404
396 pr_debug("%s: sk:%p, new addr:%pISc, p 405 pr_debug("%s: sk:%p, new addr:%pISc, port:%d, new port:%d, len:%d\n",
397 __func__, sk, &addr->sa, bp-> 406 __func__, sk, &addr->sa, bp->port, snum, len);
398 407
399 /* PF specific bind() address verifica 408 /* PF specific bind() address verification. */
400 if (!sp->pf->bind_verify(sp, addr)) 409 if (!sp->pf->bind_verify(sp, addr))
401 return -EADDRNOTAVAIL; 410 return -EADDRNOTAVAIL;
402 411
403 /* We must either be unbound, or bind 412 /* We must either be unbound, or bind to the same port.
404 * It's OK to allow 0 ports if we are 413 * It's OK to allow 0 ports if we are already bound.
405 * We'll just inhert an already bound 414 * We'll just inhert an already bound port in this case
406 */ 415 */
407 if (bp->port) { 416 if (bp->port) {
408 if (!snum) 417 if (!snum)
409 snum = bp->port; 418 snum = bp->port;
410 else if (snum != bp->port) { 419 else if (snum != bp->port) {
411 pr_debug("%s: new port 420 pr_debug("%s: new port %d doesn't match existing port "
412 "%d\n", __fun 421 "%d\n", __func__, snum, bp->port);
413 return -EINVAL; 422 return -EINVAL;
414 } 423 }
415 } 424 }
416 425
417 if (snum && inet_port_requires_bind_se !! 426 if (snum && snum < inet_prot_sock(net) &&
418 !ns_capable(net->user_ns, CAP_NET_ 427 !ns_capable(net->user_ns, CAP_NET_BIND_SERVICE))
419 return -EACCES; 428 return -EACCES;
420 429
421 /* See if the address matches any of t 430 /* See if the address matches any of the addresses we may have
422 * already bound before checking again 431 * already bound before checking against other endpoints.
423 */ 432 */
424 if (sctp_bind_addr_match(bp, addr, sp) 433 if (sctp_bind_addr_match(bp, addr, sp))
425 return -EINVAL; 434 return -EINVAL;
426 435
427 /* Make sure we are allowed to bind he 436 /* Make sure we are allowed to bind here.
428 * The function sctp_get_port_local() 437 * The function sctp_get_port_local() does duplicate address
429 * detection. 438 * detection.
430 */ 439 */
431 addr->v4.sin_port = htons(snum); 440 addr->v4.sin_port = htons(snum);
432 if (sctp_get_port_local(sk, addr)) !! 441 if ((ret = sctp_get_port_local(sk, addr))) {
433 return -EADDRINUSE; 442 return -EADDRINUSE;
>> 443 }
434 444
435 /* Refresh ephemeral port. */ 445 /* Refresh ephemeral port. */
436 if (!bp->port) { 446 if (!bp->port) {
437 bp->port = inet_sk(sk)->inet_n 447 bp->port = inet_sk(sk)->inet_num;
438 sctp_auto_asconf_init(sp); 448 sctp_auto_asconf_init(sp);
439 } 449 }
440 450
441 /* Add the address to the bind address 451 /* Add the address to the bind address list.
442 * Use GFP_ATOMIC since BHs will be di 452 * Use GFP_ATOMIC since BHs will be disabled.
443 */ 453 */
444 ret = sctp_add_bind_addr(bp, addr, af- 454 ret = sctp_add_bind_addr(bp, addr, af->sockaddr_len,
445 SCTP_ADDR_SRC 455 SCTP_ADDR_SRC, GFP_ATOMIC);
446 456
447 if (ret) { <<
448 sctp_put_port(sk); <<
449 return ret; <<
450 } <<
451 /* Copy back into socket for getsockna 457 /* Copy back into socket for getsockname() use. */
452 inet_sk(sk)->inet_sport = htons(inet_s !! 458 if (!ret) {
453 sp->pf->to_sk_saddr(addr, sk); !! 459 inet_sk(sk)->inet_sport = htons(inet_sk(sk)->inet_num);
>> 460 sp->pf->to_sk_saddr(addr, sk);
>> 461 }
454 462
455 return ret; 463 return ret;
456 } 464 }
457 465
458 /* ADDIP Section 4.1.1 Congestion Control of 466 /* ADDIP Section 4.1.1 Congestion Control of ASCONF Chunks
459 * 467 *
460 * R1) One and only one ASCONF Chunk MAY be in 468 * R1) One and only one ASCONF Chunk MAY be in transit and unacknowledged
461 * at any one time. If a sender, after sendin 469 * at any one time. If a sender, after sending an ASCONF chunk, decides
462 * it needs to transfer another ASCONF Chunk, 470 * it needs to transfer another ASCONF Chunk, it MUST wait until the
463 * ASCONF-ACK Chunk returns from the previous 471 * ASCONF-ACK Chunk returns from the previous ASCONF Chunk before sending a
464 * subsequent ASCONF. Note this restriction bi 472 * subsequent ASCONF. Note this restriction binds each side, so at any
465 * time two ASCONF may be in-transit on any gi 473 * time two ASCONF may be in-transit on any given association (one sent
466 * from each endpoint). 474 * from each endpoint).
467 */ 475 */
468 static int sctp_send_asconf(struct sctp_associ 476 static int sctp_send_asconf(struct sctp_association *asoc,
469 struct sctp_chunk 477 struct sctp_chunk *chunk)
470 { 478 {
471 int retval = 0; !! 479 struct net *net = sock_net(asoc->base.sk);
>> 480 int retval = 0;
472 481
473 /* If there is an outstanding ASCONF c 482 /* If there is an outstanding ASCONF chunk, queue it for later
474 * transmission. 483 * transmission.
475 */ 484 */
476 if (asoc->addip_last_asconf) { 485 if (asoc->addip_last_asconf) {
477 list_add_tail(&chunk->list, &a 486 list_add_tail(&chunk->list, &asoc->addip_chunk_list);
478 goto out; 487 goto out;
479 } 488 }
480 489
481 /* Hold the chunk until an ASCONF_ACK 490 /* Hold the chunk until an ASCONF_ACK is received. */
482 sctp_chunk_hold(chunk); 491 sctp_chunk_hold(chunk);
483 retval = sctp_primitive_ASCONF(asoc->b !! 492 retval = sctp_primitive_ASCONF(net, asoc, chunk);
484 if (retval) 493 if (retval)
485 sctp_chunk_free(chunk); 494 sctp_chunk_free(chunk);
486 else 495 else
487 asoc->addip_last_asconf = chun 496 asoc->addip_last_asconf = chunk;
488 497
489 out: 498 out:
490 return retval; 499 return retval;
491 } 500 }
492 501
493 /* Add a list of addresses as bind addresses t 502 /* Add a list of addresses as bind addresses to local endpoint or
494 * association. 503 * association.
495 * 504 *
496 * Basically run through each address specifie 505 * Basically run through each address specified in the addrs/addrcnt
497 * array/length pair, determine if it is IPv6 506 * array/length pair, determine if it is IPv6 or IPv4 and call
498 * sctp_do_bind() on it. 507 * sctp_do_bind() on it.
499 * 508 *
500 * If any of them fails, then the operation wi 509 * If any of them fails, then the operation will be reversed and the
501 * ones that were added will be removed. 510 * ones that were added will be removed.
502 * 511 *
503 * Only sctp_setsockopt_bindx() is supposed to 512 * Only sctp_setsockopt_bindx() is supposed to call this function.
504 */ 513 */
505 static int sctp_bindx_add(struct sock *sk, str 514 static int sctp_bindx_add(struct sock *sk, struct sockaddr *addrs, int addrcnt)
506 { 515 {
507 int cnt; 516 int cnt;
508 int retval = 0; 517 int retval = 0;
509 void *addr_buf; 518 void *addr_buf;
510 struct sockaddr *sa_addr; 519 struct sockaddr *sa_addr;
511 struct sctp_af *af; 520 struct sctp_af *af;
512 521
513 pr_debug("%s: sk:%p, addrs:%p, addrcnt 522 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n", __func__, sk,
514 addrs, addrcnt); 523 addrs, addrcnt);
515 524
516 addr_buf = addrs; 525 addr_buf = addrs;
517 for (cnt = 0; cnt < addrcnt; cnt++) { 526 for (cnt = 0; cnt < addrcnt; cnt++) {
518 /* The list may contain either 527 /* The list may contain either IPv4 or IPv6 address;
519 * determine the address lengt 528 * determine the address length for walking thru the list.
520 */ 529 */
521 sa_addr = addr_buf; 530 sa_addr = addr_buf;
522 af = sctp_get_af_specific(sa_a 531 af = sctp_get_af_specific(sa_addr->sa_family);
523 if (!af) { 532 if (!af) {
524 retval = -EINVAL; 533 retval = -EINVAL;
525 goto err_bindx_add; 534 goto err_bindx_add;
526 } 535 }
527 536
528 retval = sctp_do_bind(sk, (uni 537 retval = sctp_do_bind(sk, (union sctp_addr *)sa_addr,
529 af->sock 538 af->sockaddr_len);
530 539
531 addr_buf += af->sockaddr_len; 540 addr_buf += af->sockaddr_len;
532 541
533 err_bindx_add: 542 err_bindx_add:
534 if (retval < 0) { 543 if (retval < 0) {
535 /* Failed. Cleanup the 544 /* Failed. Cleanup the ones that have been added */
536 if (cnt > 0) 545 if (cnt > 0)
537 sctp_bindx_rem 546 sctp_bindx_rem(sk, addrs, cnt);
538 return retval; 547 return retval;
539 } 548 }
540 } 549 }
541 550
542 return retval; 551 return retval;
543 } 552 }
544 553
545 /* Send an ASCONF chunk with Add IP address pa 554 /* Send an ASCONF chunk with Add IP address parameters to all the peers of the
546 * associations that are part of the endpoint 555 * associations that are part of the endpoint indicating that a list of local
547 * addresses are added to the endpoint. 556 * addresses are added to the endpoint.
548 * 557 *
549 * If any of the addresses is already in the b 558 * If any of the addresses is already in the bind address list of the
550 * association, we do not send the chunk for t 559 * association, we do not send the chunk for that association. But it will not
551 * affect other associations. 560 * affect other associations.
552 * 561 *
553 * Only sctp_setsockopt_bindx() is supposed to 562 * Only sctp_setsockopt_bindx() is supposed to call this function.
554 */ 563 */
555 static int sctp_send_asconf_add_ip(struct sock 564 static int sctp_send_asconf_add_ip(struct sock *sk,
556 struct sock 565 struct sockaddr *addrs,
557 int 566 int addrcnt)
558 { 567 {
>> 568 struct net *net = sock_net(sk);
559 struct sctp_sock *sp; 569 struct sctp_sock *sp;
560 struct sctp_endpoint *ep; 570 struct sctp_endpoint *ep;
561 struct sctp_association *asoc; 571 struct sctp_association *asoc;
562 struct sctp_bind_addr *bp; 572 struct sctp_bind_addr *bp;
563 struct sctp_chunk *chunk 573 struct sctp_chunk *chunk;
564 struct sctp_sockaddr_entry *laddr 574 struct sctp_sockaddr_entry *laddr;
565 union sctp_addr *addr; 575 union sctp_addr *addr;
566 union sctp_addr savead 576 union sctp_addr saveaddr;
567 void *addr_ 577 void *addr_buf;
568 struct sctp_af *af; 578 struct sctp_af *af;
569 struct list_head *p; 579 struct list_head *p;
570 int i; 580 int i;
571 int retval 581 int retval = 0;
572 582
>> 583 if (!net->sctp.addip_enable)
>> 584 return retval;
>> 585
573 sp = sctp_sk(sk); 586 sp = sctp_sk(sk);
574 ep = sp->ep; 587 ep = sp->ep;
575 588
576 if (!ep->asconf_enable) <<
577 return retval; <<
578 <<
579 pr_debug("%s: sk:%p, addrs:%p, addrcnt 589 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
580 __func__, sk, addrs, addrcnt) 590 __func__, sk, addrs, addrcnt);
581 591
582 list_for_each_entry(asoc, &ep->asocs, 592 list_for_each_entry(asoc, &ep->asocs, asocs) {
583 if (!asoc->peer.asconf_capable 593 if (!asoc->peer.asconf_capable)
584 continue; 594 continue;
585 595
586 if (asoc->peer.addip_disabled_ 596 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_ADD_IP)
587 continue; 597 continue;
588 598
589 if (!sctp_state(asoc, ESTABLIS 599 if (!sctp_state(asoc, ESTABLISHED))
590 continue; 600 continue;
591 601
592 /* Check if any address in the 602 /* Check if any address in the packed array of addresses is
593 * in the bind address list of 603 * in the bind address list of the association. If so,
594 * do not send the asconf chun 604 * do not send the asconf chunk to its peer, but continue with
595 * other associations. 605 * other associations.
596 */ 606 */
597 addr_buf = addrs; 607 addr_buf = addrs;
598 for (i = 0; i < addrcnt; i++) 608 for (i = 0; i < addrcnt; i++) {
599 addr = addr_buf; 609 addr = addr_buf;
600 af = sctp_get_af_speci 610 af = sctp_get_af_specific(addr->v4.sin_family);
601 if (!af) { 611 if (!af) {
602 retval = -EINV 612 retval = -EINVAL;
603 goto out; 613 goto out;
604 } 614 }
605 615
606 if (sctp_assoc_lookup_ 616 if (sctp_assoc_lookup_laddr(asoc, addr))
607 break; 617 break;
608 618
609 addr_buf += af->sockad 619 addr_buf += af->sockaddr_len;
610 } 620 }
611 if (i < addrcnt) 621 if (i < addrcnt)
612 continue; 622 continue;
613 623
614 /* Use the first valid address 624 /* Use the first valid address in bind addr list of
615 * association as Address Para 625 * association as Address Parameter of ASCONF CHUNK.
616 */ 626 */
617 bp = &asoc->base.bind_addr; 627 bp = &asoc->base.bind_addr;
618 p = bp->address_list.next; 628 p = bp->address_list.next;
619 laddr = list_entry(p, struct s 629 laddr = list_entry(p, struct sctp_sockaddr_entry, list);
620 chunk = sctp_make_asconf_updat 630 chunk = sctp_make_asconf_update_ip(asoc, &laddr->a, addrs,
621 631 addrcnt, SCTP_PARAM_ADD_IP);
622 if (!chunk) { 632 if (!chunk) {
623 retval = -ENOMEM; 633 retval = -ENOMEM;
624 goto out; 634 goto out;
625 } 635 }
626 636
627 /* Add the new addresses to th 637 /* Add the new addresses to the bind address list with
628 * use_as_src set to 0. 638 * use_as_src set to 0.
629 */ 639 */
630 addr_buf = addrs; 640 addr_buf = addrs;
631 for (i = 0; i < addrcnt; i++) 641 for (i = 0; i < addrcnt; i++) {
632 addr = addr_buf; 642 addr = addr_buf;
633 af = sctp_get_af_speci 643 af = sctp_get_af_specific(addr->v4.sin_family);
634 memcpy(&saveaddr, addr 644 memcpy(&saveaddr, addr, af->sockaddr_len);
635 retval = sctp_add_bind 645 retval = sctp_add_bind_addr(bp, &saveaddr,
636 646 sizeof(saveaddr),
637 647 SCTP_ADDR_NEW, GFP_ATOMIC);
638 addr_buf += af->sockad 648 addr_buf += af->sockaddr_len;
639 } 649 }
640 if (asoc->src_out_of_asoc_ok) 650 if (asoc->src_out_of_asoc_ok) {
641 struct sctp_transport 651 struct sctp_transport *trans;
642 652
643 list_for_each_entry(tr 653 list_for_each_entry(trans,
644 &asoc->peer.transp 654 &asoc->peer.transport_addr_list, transports) {
>> 655 /* Clear the source and route cache */
>> 656 sctp_transport_dst_release(trans);
645 trans->cwnd = 657 trans->cwnd = min(4*asoc->pathmtu, max_t(__u32,
646 2*asoc->pa 658 2*asoc->pathmtu, 4380));
647 trans->ssthres 659 trans->ssthresh = asoc->peer.i.a_rwnd;
648 trans->rto = a 660 trans->rto = asoc->rto_initial;
649 sctp_max_rto(a 661 sctp_max_rto(asoc, trans);
650 trans->rtt = t 662 trans->rtt = trans->srtt = trans->rttvar = 0;
651 /* Clear the s <<
652 sctp_transport 663 sctp_transport_route(trans, NULL,
653 !! 664 sctp_sk(asoc->base.sk));
654 } 665 }
655 } 666 }
656 retval = sctp_send_asconf(asoc 667 retval = sctp_send_asconf(asoc, chunk);
657 } 668 }
658 669
659 out: 670 out:
660 return retval; 671 return retval;
661 } 672 }
662 673
663 /* Remove a list of addresses from bind addres 674 /* Remove a list of addresses from bind addresses list. Do not remove the
664 * last address. 675 * last address.
665 * 676 *
666 * Basically run through each address specifie 677 * Basically run through each address specified in the addrs/addrcnt
667 * array/length pair, determine if it is IPv6 678 * array/length pair, determine if it is IPv6 or IPv4 and call
668 * sctp_del_bind() on it. 679 * sctp_del_bind() on it.
669 * 680 *
670 * If any of them fails, then the operation wi 681 * If any of them fails, then the operation will be reversed and the
671 * ones that were removed will be added back. 682 * ones that were removed will be added back.
672 * 683 *
673 * At least one address has to be left; if onl 684 * At least one address has to be left; if only one address is
674 * available, the operation will return -EBUSY 685 * available, the operation will return -EBUSY.
675 * 686 *
676 * Only sctp_setsockopt_bindx() is supposed to 687 * Only sctp_setsockopt_bindx() is supposed to call this function.
677 */ 688 */
678 static int sctp_bindx_rem(struct sock *sk, str 689 static int sctp_bindx_rem(struct sock *sk, struct sockaddr *addrs, int addrcnt)
679 { 690 {
680 struct sctp_sock *sp = sctp_sk(sk); 691 struct sctp_sock *sp = sctp_sk(sk);
681 struct sctp_endpoint *ep = sp->ep; 692 struct sctp_endpoint *ep = sp->ep;
682 int cnt; 693 int cnt;
683 struct sctp_bind_addr *bp = &ep->base. 694 struct sctp_bind_addr *bp = &ep->base.bind_addr;
684 int retval = 0; 695 int retval = 0;
685 void *addr_buf; 696 void *addr_buf;
686 union sctp_addr *sa_addr; 697 union sctp_addr *sa_addr;
687 struct sctp_af *af; 698 struct sctp_af *af;
688 699
689 pr_debug("%s: sk:%p, addrs:%p, addrcnt 700 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
690 __func__, sk, addrs, addrcnt) 701 __func__, sk, addrs, addrcnt);
691 702
692 addr_buf = addrs; 703 addr_buf = addrs;
693 for (cnt = 0; cnt < addrcnt; cnt++) { 704 for (cnt = 0; cnt < addrcnt; cnt++) {
694 /* If the bind address list is 705 /* If the bind address list is empty or if there is only one
695 * bind address, there is noth 706 * bind address, there is nothing more to be removed (we need
696 * at least one address here). 707 * at least one address here).
697 */ 708 */
698 if (list_empty(&bp->address_li 709 if (list_empty(&bp->address_list) ||
699 (sctp_list_single_entry(&b 710 (sctp_list_single_entry(&bp->address_list))) {
700 retval = -EBUSY; 711 retval = -EBUSY;
701 goto err_bindx_rem; 712 goto err_bindx_rem;
702 } 713 }
703 714
704 sa_addr = addr_buf; 715 sa_addr = addr_buf;
705 af = sctp_get_af_specific(sa_a 716 af = sctp_get_af_specific(sa_addr->sa.sa_family);
706 if (!af) { 717 if (!af) {
707 retval = -EINVAL; 718 retval = -EINVAL;
708 goto err_bindx_rem; 719 goto err_bindx_rem;
709 } 720 }
710 721
711 if (!af->addr_valid(sa_addr, s 722 if (!af->addr_valid(sa_addr, sp, NULL)) {
712 retval = -EADDRNOTAVAI 723 retval = -EADDRNOTAVAIL;
713 goto err_bindx_rem; 724 goto err_bindx_rem;
714 } 725 }
715 726
716 if (sa_addr->v4.sin_port && 727 if (sa_addr->v4.sin_port &&
717 sa_addr->v4.sin_port != ht 728 sa_addr->v4.sin_port != htons(bp->port)) {
718 retval = -EINVAL; 729 retval = -EINVAL;
719 goto err_bindx_rem; 730 goto err_bindx_rem;
720 } 731 }
721 732
722 if (!sa_addr->v4.sin_port) 733 if (!sa_addr->v4.sin_port)
723 sa_addr->v4.sin_port = 734 sa_addr->v4.sin_port = htons(bp->port);
724 735
725 /* FIXME - There is probably a 736 /* FIXME - There is probably a need to check if sk->sk_saddr and
726 * sk->sk_rcv_addr are current 737 * sk->sk_rcv_addr are currently set to one of the addresses to
727 * be removed. This is somethi 738 * be removed. This is something which needs to be looked into
728 * when we are fixing the outs 739 * when we are fixing the outstanding issues with multi-homing
729 * socket routing and failover 740 * socket routing and failover schemes. Refer to comments in
730 * sctp_do_bind(). -daisy 741 * sctp_do_bind(). -daisy
731 */ 742 */
732 retval = sctp_del_bind_addr(bp 743 retval = sctp_del_bind_addr(bp, sa_addr);
733 744
734 addr_buf += af->sockaddr_len; 745 addr_buf += af->sockaddr_len;
735 err_bindx_rem: 746 err_bindx_rem:
736 if (retval < 0) { 747 if (retval < 0) {
737 /* Failed. Add the one 748 /* Failed. Add the ones that has been removed back */
738 if (cnt > 0) 749 if (cnt > 0)
739 sctp_bindx_add 750 sctp_bindx_add(sk, addrs, cnt);
740 return retval; 751 return retval;
741 } 752 }
742 } 753 }
743 754
744 return retval; 755 return retval;
745 } 756 }
746 757
747 /* Send an ASCONF chunk with Delete IP address 758 /* Send an ASCONF chunk with Delete IP address parameters to all the peers of
748 * the associations that are part of the endpo 759 * the associations that are part of the endpoint indicating that a list of
749 * local addresses are removed from the endpoi 760 * local addresses are removed from the endpoint.
750 * 761 *
751 * If any of the addresses is already in the b 762 * If any of the addresses is already in the bind address list of the
752 * association, we do not send the chunk for t 763 * association, we do not send the chunk for that association. But it will not
753 * affect other associations. 764 * affect other associations.
754 * 765 *
755 * Only sctp_setsockopt_bindx() is supposed to 766 * Only sctp_setsockopt_bindx() is supposed to call this function.
756 */ 767 */
757 static int sctp_send_asconf_del_ip(struct sock 768 static int sctp_send_asconf_del_ip(struct sock *sk,
758 struct sock 769 struct sockaddr *addrs,
759 int 770 int addrcnt)
760 { 771 {
>> 772 struct net *net = sock_net(sk);
761 struct sctp_sock *sp; 773 struct sctp_sock *sp;
762 struct sctp_endpoint *ep; 774 struct sctp_endpoint *ep;
763 struct sctp_association *asoc; 775 struct sctp_association *asoc;
764 struct sctp_transport *transport; 776 struct sctp_transport *transport;
765 struct sctp_bind_addr *bp; 777 struct sctp_bind_addr *bp;
766 struct sctp_chunk *chunk; 778 struct sctp_chunk *chunk;
767 union sctp_addr *laddr; 779 union sctp_addr *laddr;
768 void *addr_buf; 780 void *addr_buf;
769 struct sctp_af *af; 781 struct sctp_af *af;
770 struct sctp_sockaddr_entry *saddr; 782 struct sctp_sockaddr_entry *saddr;
771 int i; 783 int i;
772 int retval = 0; 784 int retval = 0;
773 int stored = 0; 785 int stored = 0;
774 786
775 chunk = NULL; 787 chunk = NULL;
>> 788 if (!net->sctp.addip_enable)
>> 789 return retval;
>> 790
776 sp = sctp_sk(sk); 791 sp = sctp_sk(sk);
777 ep = sp->ep; 792 ep = sp->ep;
778 793
779 if (!ep->asconf_enable) <<
780 return retval; <<
781 <<
782 pr_debug("%s: sk:%p, addrs:%p, addrcnt 794 pr_debug("%s: sk:%p, addrs:%p, addrcnt:%d\n",
783 __func__, sk, addrs, addrcnt) 795 __func__, sk, addrs, addrcnt);
784 796
785 list_for_each_entry(asoc, &ep->asocs, 797 list_for_each_entry(asoc, &ep->asocs, asocs) {
786 798
787 if (!asoc->peer.asconf_capable 799 if (!asoc->peer.asconf_capable)
788 continue; 800 continue;
789 801
790 if (asoc->peer.addip_disabled_ 802 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_DEL_IP)
791 continue; 803 continue;
792 804
793 if (!sctp_state(asoc, ESTABLIS 805 if (!sctp_state(asoc, ESTABLISHED))
794 continue; 806 continue;
795 807
796 /* Check if any address in the 808 /* Check if any address in the packed array of addresses is
797 * not present in the bind add 809 * not present in the bind address list of the association.
798 * If so, do not send the asco 810 * If so, do not send the asconf chunk to its peer, but
799 * continue with other associa 811 * continue with other associations.
800 */ 812 */
801 addr_buf = addrs; 813 addr_buf = addrs;
802 for (i = 0; i < addrcnt; i++) 814 for (i = 0; i < addrcnt; i++) {
803 laddr = addr_buf; 815 laddr = addr_buf;
804 af = sctp_get_af_speci 816 af = sctp_get_af_specific(laddr->v4.sin_family);
805 if (!af) { 817 if (!af) {
806 retval = -EINV 818 retval = -EINVAL;
807 goto out; 819 goto out;
808 } 820 }
809 821
810 if (!sctp_assoc_lookup 822 if (!sctp_assoc_lookup_laddr(asoc, laddr))
811 break; 823 break;
812 824
813 addr_buf += af->sockad 825 addr_buf += af->sockaddr_len;
814 } 826 }
815 if (i < addrcnt) 827 if (i < addrcnt)
816 continue; 828 continue;
817 829
818 /* Find one address in the ass 830 /* Find one address in the association's bind address list
819 * that is not in the packed a 831 * that is not in the packed array of addresses. This is to
820 * make sure that we do not de 832 * make sure that we do not delete all the addresses in the
821 * association. 833 * association.
822 */ 834 */
823 bp = &asoc->base.bind_addr; 835 bp = &asoc->base.bind_addr;
824 laddr = sctp_find_unmatch_addr 836 laddr = sctp_find_unmatch_addr(bp, (union sctp_addr *)addrs,
825 837 addrcnt, sp);
826 if ((laddr == NULL) && (addrcn 838 if ((laddr == NULL) && (addrcnt == 1)) {
827 if (asoc->asconf_addr_ 839 if (asoc->asconf_addr_del_pending)
828 continue; 840 continue;
829 asoc->asconf_addr_del_ 841 asoc->asconf_addr_del_pending =
830 kzalloc(sizeof(uni 842 kzalloc(sizeof(union sctp_addr), GFP_ATOMIC);
831 if (asoc->asconf_addr_ 843 if (asoc->asconf_addr_del_pending == NULL) {
832 retval = -ENOM 844 retval = -ENOMEM;
833 goto out; 845 goto out;
834 } 846 }
835 asoc->asconf_addr_del_ 847 asoc->asconf_addr_del_pending->sa.sa_family =
836 addrs->sa_ 848 addrs->sa_family;
837 asoc->asconf_addr_del_ 849 asoc->asconf_addr_del_pending->v4.sin_port =
838 htons(bp-> 850 htons(bp->port);
839 if (addrs->sa_family = 851 if (addrs->sa_family == AF_INET) {
840 struct sockadd 852 struct sockaddr_in *sin;
841 853
842 sin = (struct 854 sin = (struct sockaddr_in *)addrs;
843 asoc->asconf_a 855 asoc->asconf_addr_del_pending->v4.sin_addr.s_addr = sin->sin_addr.s_addr;
844 } else if (addrs->sa_f 856 } else if (addrs->sa_family == AF_INET6) {
845 struct sockadd 857 struct sockaddr_in6 *sin6;
846 858
847 sin6 = (struct 859 sin6 = (struct sockaddr_in6 *)addrs;
848 asoc->asconf_a 860 asoc->asconf_addr_del_pending->v6.sin6_addr = sin6->sin6_addr;
849 } 861 }
850 862
851 pr_debug("%s: keep the 863 pr_debug("%s: keep the last address asoc:%p %pISc at %p\n",
852 __func__, aso 864 __func__, asoc, &asoc->asconf_addr_del_pending->sa,
853 asoc->asconf_ 865 asoc->asconf_addr_del_pending);
854 866
855 asoc->src_out_of_asoc_ 867 asoc->src_out_of_asoc_ok = 1;
856 stored = 1; 868 stored = 1;
857 goto skip_mkasconf; 869 goto skip_mkasconf;
858 } 870 }
859 871
860 if (laddr == NULL) 872 if (laddr == NULL)
861 return -EINVAL; 873 return -EINVAL;
862 874
863 /* We do not need RCU protecti 875 /* We do not need RCU protection throughout this loop
864 * because this is done under 876 * because this is done under a socket lock from the
865 * setsockopt call. 877 * setsockopt call.
866 */ 878 */
867 chunk = sctp_make_asconf_updat 879 chunk = sctp_make_asconf_update_ip(asoc, laddr, addrs, addrcnt,
868 880 SCTP_PARAM_DEL_IP);
869 if (!chunk) { 881 if (!chunk) {
870 retval = -ENOMEM; 882 retval = -ENOMEM;
871 goto out; 883 goto out;
872 } 884 }
873 885
874 skip_mkasconf: 886 skip_mkasconf:
875 /* Reset use_as_src flag for t 887 /* Reset use_as_src flag for the addresses in the bind address
876 * list that are to be deleted 888 * list that are to be deleted.
877 */ 889 */
878 addr_buf = addrs; 890 addr_buf = addrs;
879 for (i = 0; i < addrcnt; i++) 891 for (i = 0; i < addrcnt; i++) {
880 laddr = addr_buf; 892 laddr = addr_buf;
881 af = sctp_get_af_speci 893 af = sctp_get_af_specific(laddr->v4.sin_family);
882 list_for_each_entry(sa 894 list_for_each_entry(saddr, &bp->address_list, list) {
883 if (sctp_cmp_a 895 if (sctp_cmp_addr_exact(&saddr->a, laddr))
884 saddr- 896 saddr->state = SCTP_ADDR_DEL;
885 } 897 }
886 addr_buf += af->sockad 898 addr_buf += af->sockaddr_len;
887 } 899 }
888 900
889 /* Update the route and saddr 901 /* Update the route and saddr entries for all the transports
890 * as some of the addresses in 902 * as some of the addresses in the bind address list are
891 * about to be deleted and can 903 * about to be deleted and cannot be used as source addresses.
892 */ 904 */
893 list_for_each_entry(transport, 905 list_for_each_entry(transport, &asoc->peer.transport_addr_list,
894 transp 906 transports) {
>> 907 sctp_transport_dst_release(transport);
895 sctp_transport_route(t 908 sctp_transport_route(transport, NULL,
896 s 909 sctp_sk(asoc->base.sk));
897 } 910 }
898 911
899 if (stored) 912 if (stored)
900 /* We don't need to tr 913 /* We don't need to transmit ASCONF */
901 continue; 914 continue;
902 retval = sctp_send_asconf(asoc 915 retval = sctp_send_asconf(asoc, chunk);
903 } 916 }
904 out: 917 out:
905 return retval; 918 return retval;
906 } 919 }
907 920
908 /* set addr events to assocs in the endpoint. 921 /* set addr events to assocs in the endpoint. ep and addr_wq must be locked */
909 int sctp_asconf_mgmt(struct sctp_sock *sp, str 922 int sctp_asconf_mgmt(struct sctp_sock *sp, struct sctp_sockaddr_entry *addrw)
910 { 923 {
911 struct sock *sk = sctp_opt2sk(sp); 924 struct sock *sk = sctp_opt2sk(sp);
912 union sctp_addr *addr; 925 union sctp_addr *addr;
913 struct sctp_af *af; 926 struct sctp_af *af;
914 927
915 /* It is safe to write port space in c 928 /* It is safe to write port space in caller. */
916 addr = &addrw->a; 929 addr = &addrw->a;
917 addr->v4.sin_port = htons(sp->ep->base 930 addr->v4.sin_port = htons(sp->ep->base.bind_addr.port);
918 af = sctp_get_af_specific(addr->sa.sa_ 931 af = sctp_get_af_specific(addr->sa.sa_family);
919 if (!af) 932 if (!af)
920 return -EINVAL; 933 return -EINVAL;
921 if (sctp_verify_addr(sk, addr, af->soc 934 if (sctp_verify_addr(sk, addr, af->sockaddr_len))
922 return -EINVAL; 935 return -EINVAL;
923 936
924 if (addrw->state == SCTP_ADDR_NEW) 937 if (addrw->state == SCTP_ADDR_NEW)
925 return sctp_send_asconf_add_ip 938 return sctp_send_asconf_add_ip(sk, (struct sockaddr *)addr, 1);
926 else 939 else
927 return sctp_send_asconf_del_ip 940 return sctp_send_asconf_del_ip(sk, (struct sockaddr *)addr, 1);
928 } 941 }
929 942
930 /* Helper for tunneling sctp_bindx() requests 943 /* Helper for tunneling sctp_bindx() requests through sctp_setsockopt()
931 * 944 *
932 * API 8.1 945 * API 8.1
933 * int sctp_bindx(int sd, struct sockaddr *add 946 * int sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt,
934 * int flags); 947 * int flags);
935 * 948 *
936 * If sd is an IPv4 socket, the addresses pass 949 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
937 * If the sd is an IPv6 socket, the addresses 950 * If the sd is an IPv6 socket, the addresses passed can either be IPv4
938 * or IPv6 addresses. 951 * or IPv6 addresses.
939 * 952 *
940 * A single address may be specified as INADDR 953 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
941 * Section 3.1.2 for this usage. 954 * Section 3.1.2 for this usage.
942 * 955 *
943 * addrs is a pointer to an array of one or mo 956 * addrs is a pointer to an array of one or more socket addresses. Each
944 * address is contained in its appropriate str 957 * address is contained in its appropriate structure (i.e. struct
945 * sockaddr_in or struct sockaddr_in6) the fam 958 * sockaddr_in or struct sockaddr_in6) the family of the address type
946 * must be used to distinguish the address len 959 * must be used to distinguish the address length (note that this
947 * representation is termed a "packed array" o 960 * representation is termed a "packed array" of addresses). The caller
948 * specifies the number of addresses in the ar 961 * specifies the number of addresses in the array with addrcnt.
949 * 962 *
950 * On success, sctp_bindx() returns 0. On fail 963 * On success, sctp_bindx() returns 0. On failure, sctp_bindx() returns
951 * -1, and sets errno to the appropriate error 964 * -1, and sets errno to the appropriate error code.
952 * 965 *
953 * For SCTP, the port given in each socket add 966 * For SCTP, the port given in each socket address must be the same, or
954 * sctp_bindx() will fail, setting errno to EI 967 * sctp_bindx() will fail, setting errno to EINVAL.
955 * 968 *
956 * The flags parameter is formed from the bitw 969 * The flags parameter is formed from the bitwise OR of zero or more of
957 * the following currently defined flags: 970 * the following currently defined flags:
958 * 971 *
959 * SCTP_BINDX_ADD_ADDR 972 * SCTP_BINDX_ADD_ADDR
960 * 973 *
961 * SCTP_BINDX_REM_ADDR 974 * SCTP_BINDX_REM_ADDR
962 * 975 *
963 * SCTP_BINDX_ADD_ADDR directs SCTP to add the 976 * SCTP_BINDX_ADD_ADDR directs SCTP to add the given addresses to the
964 * association, and SCTP_BINDX_REM_ADDR direct 977 * association, and SCTP_BINDX_REM_ADDR directs SCTP to remove the given
965 * addresses from the association. The two fla 978 * addresses from the association. The two flags are mutually exclusive;
966 * if both are given, sctp_bindx() will fail w 979 * if both are given, sctp_bindx() will fail with EINVAL. A caller may
967 * not remove all addresses from an associatio 980 * not remove all addresses from an association; sctp_bindx() will
968 * reject such an attempt with EINVAL. 981 * reject such an attempt with EINVAL.
969 * 982 *
970 * An application can use sctp_bindx(SCTP_BIND 983 * An application can use sctp_bindx(SCTP_BINDX_ADD_ADDR) to associate
971 * additional addresses with an endpoint after 984 * additional addresses with an endpoint after calling bind(). Or use
972 * sctp_bindx(SCTP_BINDX_REM_ADDR) to remove s 985 * sctp_bindx(SCTP_BINDX_REM_ADDR) to remove some addresses a listening
973 * socket is associated with so that no new as 986 * socket is associated with so that no new association accepted will be
974 * associated with those addresses. If the end 987 * associated with those addresses. If the endpoint supports dynamic
975 * address a SCTP_BINDX_REM_ADDR or SCTP_BINDX 988 * address a SCTP_BINDX_REM_ADDR or SCTP_BINDX_ADD_ADDR may cause a
976 * endpoint to send the appropriate message to 989 * endpoint to send the appropriate message to the peer to change the
977 * peers address lists. 990 * peers address lists.
978 * 991 *
979 * Adding and removing addresses from a connec 992 * Adding and removing addresses from a connected association is
980 * optional functionality. Implementations tha 993 * optional functionality. Implementations that do not support this
981 * functionality should return EOPNOTSUPP. 994 * functionality should return EOPNOTSUPP.
982 * 995 *
983 * Basically do nothing but copying the addres 996 * Basically do nothing but copying the addresses from user to kernel
984 * land and invoking either sctp_bindx_add() o 997 * land and invoking either sctp_bindx_add() or sctp_bindx_rem() on the sk.
985 * This is used for tunneling the sctp_bindx() 998 * This is used for tunneling the sctp_bindx() request through sctp_setsockopt()
986 * from userspace. 999 * from userspace.
987 * 1000 *
>> 1001 * We don't use copy_from_user() for optimization: we first do the
>> 1002 * sanity checks (buffer size -fast- and access check-healthy
>> 1003 * pointer); if all of those succeed, then we can alloc the memory
>> 1004 * (expensive operation) needed to copy the data to kernel. Then we do
>> 1005 * the copying without checking the user space area
>> 1006 * (__copy_from_user()).
>> 1007 *
988 * On exit there is no need to do sockfd_put() 1008 * On exit there is no need to do sockfd_put(), sys_setsockopt() does
989 * it. 1009 * it.
990 * 1010 *
991 * sk The sk of the socket 1011 * sk The sk of the socket
992 * addrs The pointer to the addresses !! 1012 * addrs The pointer to the addresses in user land
993 * addrssize Size of the addrs buffer 1013 * addrssize Size of the addrs buffer
994 * op Operation to perform (add or remo 1014 * op Operation to perform (add or remove, see the flags of
995 * sctp_bindx) 1015 * sctp_bindx)
996 * 1016 *
997 * Returns 0 if ok, <0 errno code on error. 1017 * Returns 0 if ok, <0 errno code on error.
998 */ 1018 */
999 static int sctp_setsockopt_bindx(struct sock * !! 1019 static int sctp_setsockopt_bindx(struct sock *sk,
>> 1020 struct sockaddr __user *addrs,
1000 int addrs_si 1021 int addrs_size, int op)
1001 { 1022 {
>> 1023 struct sockaddr *kaddrs;
1002 int err; 1024 int err;
1003 int addrcnt = 0; 1025 int addrcnt = 0;
1004 int walk_size = 0; 1026 int walk_size = 0;
1005 struct sockaddr *sa_addr; 1027 struct sockaddr *sa_addr;
1006 void *addr_buf = addrs; !! 1028 void *addr_buf;
1007 struct sctp_af *af; 1029 struct sctp_af *af;
1008 1030
1009 pr_debug("%s: sk:%p addrs:%p addrs_si 1031 pr_debug("%s: sk:%p addrs:%p addrs_size:%d opt:%d\n",
1010 __func__, sk, addr_buf, addr !! 1032 __func__, sk, addrs, addrs_size, op);
1011 1033
1012 if (unlikely(addrs_size <= 0)) 1034 if (unlikely(addrs_size <= 0))
1013 return -EINVAL; 1035 return -EINVAL;
1014 1036
>> 1037 /* Check the user passed a healthy pointer. */
>> 1038 if (unlikely(!access_ok(VERIFY_READ, addrs, addrs_size)))
>> 1039 return -EFAULT;
>> 1040
>> 1041 /* Alloc space for the address array in kernel memory. */
>> 1042 kaddrs = kmalloc(addrs_size, GFP_USER | __GFP_NOWARN);
>> 1043 if (unlikely(!kaddrs))
>> 1044 return -ENOMEM;
>> 1045
>> 1046 if (__copy_from_user(kaddrs, addrs, addrs_size)) {
>> 1047 kfree(kaddrs);
>> 1048 return -EFAULT;
>> 1049 }
>> 1050
1015 /* Walk through the addrs buffer and 1051 /* Walk through the addrs buffer and count the number of addresses. */
>> 1052 addr_buf = kaddrs;
1016 while (walk_size < addrs_size) { 1053 while (walk_size < addrs_size) {
1017 if (walk_size + sizeof(sa_fam !! 1054 if (walk_size + sizeof(sa_family_t) > addrs_size) {
>> 1055 kfree(kaddrs);
1018 return -EINVAL; 1056 return -EINVAL;
>> 1057 }
1019 1058
1020 sa_addr = addr_buf; 1059 sa_addr = addr_buf;
1021 af = sctp_get_af_specific(sa_ 1060 af = sctp_get_af_specific(sa_addr->sa_family);
1022 1061
1023 /* If the address family is n 1062 /* If the address family is not supported or if this address
1024 * causes the address buffer 1063 * causes the address buffer to overflow return EINVAL.
1025 */ 1064 */
1026 if (!af || (walk_size + af->s !! 1065 if (!af || (walk_size + af->sockaddr_len) > addrs_size) {
>> 1066 kfree(kaddrs);
1027 return -EINVAL; 1067 return -EINVAL;
>> 1068 }
1028 addrcnt++; 1069 addrcnt++;
1029 addr_buf += af->sockaddr_len; 1070 addr_buf += af->sockaddr_len;
1030 walk_size += af->sockaddr_len 1071 walk_size += af->sockaddr_len;
1031 } 1072 }
1032 1073
1033 /* Do the work. */ 1074 /* Do the work. */
1034 switch (op) { 1075 switch (op) {
1035 case SCTP_BINDX_ADD_ADDR: 1076 case SCTP_BINDX_ADD_ADDR:
1036 /* Allow security module to v !! 1077 err = sctp_bindx_add(sk, kaddrs, addrcnt);
1037 err = security_sctp_bind_conn <<
1038 <<
1039 if (err) 1078 if (err)
1040 return err; !! 1079 goto out;
1041 err = sctp_bindx_add(sk, addr !! 1080 err = sctp_send_asconf_add_ip(sk, kaddrs, addrcnt);
1042 if (err) !! 1081 break;
1043 return err; !! 1082
1044 return sctp_send_asconf_add_i <<
1045 case SCTP_BINDX_REM_ADDR: 1083 case SCTP_BINDX_REM_ADDR:
1046 err = sctp_bindx_rem(sk, addr !! 1084 err = sctp_bindx_rem(sk, kaddrs, addrcnt);
1047 if (err) 1085 if (err)
1048 return err; !! 1086 goto out;
1049 return sctp_send_asconf_del_i !! 1087 err = sctp_send_asconf_del_ip(sk, kaddrs, addrcnt);
>> 1088 break;
1050 1089
1051 default: 1090 default:
1052 return -EINVAL; !! 1091 err = -EINVAL;
1053 } !! 1092 break;
1054 } <<
1055 <<
1056 static int sctp_bind_add(struct sock *sk, str <<
1057 int addrlen) <<
1058 { <<
1059 int err; <<
1060 <<
1061 lock_sock(sk); <<
1062 err = sctp_setsockopt_bindx(sk, addrs <<
1063 release_sock(sk); <<
1064 return err; <<
1065 } <<
1066 <<
1067 static int sctp_connect_new_asoc(struct sctp_ <<
1068 const union <<
1069 const struct <<
1070 struct sctp_ <<
1071 { <<
1072 struct sctp_association *asoc; <<
1073 struct sock *sk = ep->base.sk; <<
1074 struct net *net = sock_net(sk); <<
1075 enum sctp_scope scope; <<
1076 int err; <<
1077 <<
1078 if (sctp_endpoint_is_peeled_off(ep, d <<
1079 return -EADDRNOTAVAIL; <<
1080 <<
1081 if (!ep->base.bind_addr.port) { <<
1082 if (sctp_autobind(sk)) <<
1083 return -EAGAIN; <<
1084 } else { <<
1085 if (inet_port_requires_bind_s <<
1086 !ns_capable(net->user_ns, <<
1087 return -EACCES; <<
1088 } <<
1089 <<
1090 scope = sctp_scope(daddr); <<
1091 asoc = sctp_association_new(ep, sk, s <<
1092 if (!asoc) <<
1093 return -ENOMEM; <<
1094 <<
1095 err = sctp_assoc_set_bind_addr_from_e <<
1096 if (err < 0) <<
1097 goto free; <<
1098 <<
1099 *tp = sctp_assoc_add_peer(asoc, daddr <<
1100 if (!*tp) { <<
1101 err = -ENOMEM; <<
1102 goto free; <<
1103 } <<
1104 <<
1105 if (!init) <<
1106 return 0; <<
1107 <<
1108 if (init->sinit_num_ostreams) { <<
1109 __u16 outcnt = init->sinit_nu <<
1110 <<
1111 asoc->c.sinit_num_ostreams = <<
1112 /* outcnt has been changed, n <<
1113 err = sctp_stream_init(&asoc- <<
1114 if (err) <<
1115 goto free; <<
1116 } 1093 }
1117 1094
1118 if (init->sinit_max_instreams) !! 1095 out:
1119 asoc->c.sinit_max_instreams = !! 1096 kfree(kaddrs);
1120 <<
1121 if (init->sinit_max_attempts) <<
1122 asoc->max_init_attempts = ini <<
1123 <<
1124 if (init->sinit_max_init_timeo) <<
1125 asoc->max_init_timeo = <<
1126 msecs_to_jiffies(init <<
1127 1097
1128 return 0; <<
1129 free: <<
1130 sctp_association_free(asoc); <<
1131 return err; 1098 return err;
1132 } 1099 }
1133 1100
1134 static int sctp_connect_add_peer(struct sctp_ <<
1135 union sctp_a <<
1136 { <<
1137 struct sctp_endpoint *ep = asoc->ep; <<
1138 struct sctp_association *old; <<
1139 struct sctp_transport *t; <<
1140 int err; <<
1141 <<
1142 err = sctp_verify_addr(ep->base.sk, d <<
1143 if (err) <<
1144 return err; <<
1145 <<
1146 old = sctp_endpoint_lookup_assoc(ep, <<
1147 if (old && old != asoc) <<
1148 return old->state >= SCTP_STA <<
1149 <<
1150 <<
1151 if (sctp_endpoint_is_peeled_off(ep, d <<
1152 return -EADDRNOTAVAIL; <<
1153 <<
1154 t = sctp_assoc_add_peer(asoc, daddr, <<
1155 if (!t) <<
1156 return -ENOMEM; <<
1157 <<
1158 return 0; <<
1159 } <<
1160 <<
1161 /* __sctp_connect(struct sock* sk, struct soc 1101 /* __sctp_connect(struct sock* sk, struct sockaddr *kaddrs, int addrs_size)
1162 * 1102 *
1163 * Common routine for handling connect() and 1103 * Common routine for handling connect() and sctp_connectx().
1164 * Connect will come in with just a single ad 1104 * Connect will come in with just a single address.
1165 */ 1105 */
1166 static int __sctp_connect(struct sock *sk, st !! 1106 static int __sctp_connect(struct sock *sk,
1167 int addrs_size, int !! 1107 struct sockaddr *kaddrs,
>> 1108 int addrs_size, int flags,
>> 1109 sctp_assoc_t *assoc_id)
1168 { 1110 {
1169 struct sctp_sock *sp = sctp_sk(sk); !! 1111 struct net *net = sock_net(sk);
1170 struct sctp_endpoint *ep = sp->ep; !! 1112 struct sctp_sock *sp;
>> 1113 struct sctp_endpoint *ep;
>> 1114 struct sctp_association *asoc = NULL;
>> 1115 struct sctp_association *asoc2;
1171 struct sctp_transport *transport; 1116 struct sctp_transport *transport;
1172 struct sctp_association *asoc; !! 1117 union sctp_addr to;
1173 void *addr_buf = kaddrs; !! 1118 enum sctp_scope scope;
1174 union sctp_addr *daddr; <<
1175 struct sctp_af *af; <<
1176 int walk_size, err; <<
1177 long timeo; 1119 long timeo;
>> 1120 int err = 0;
>> 1121 int addrcnt = 0;
>> 1122 int walk_size = 0;
>> 1123 union sctp_addr *sa_addr = NULL;
>> 1124 void *addr_buf;
>> 1125 unsigned short port;
>> 1126
>> 1127 sp = sctp_sk(sk);
>> 1128 ep = sp->ep;
1178 1129
>> 1130 /* connect() cannot be done on a socket that is already in ESTABLISHED
>> 1131 * state - UDP-style peeled off socket or a TCP-style socket that
>> 1132 * is already connected.
>> 1133 * It cannot be done even on a TCP-style listening socket.
>> 1134 */
1179 if (sctp_sstate(sk, ESTABLISHED) || s 1135 if (sctp_sstate(sk, ESTABLISHED) || sctp_sstate(sk, CLOSING) ||
1180 (sctp_style(sk, TCP) && sctp_ssta !! 1136 (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))) {
1181 return -EISCONN; !! 1137 err = -EISCONN;
>> 1138 goto out_free;
>> 1139 }
1182 1140
1183 daddr = addr_buf; !! 1141 /* Walk through the addrs buffer and count the number of addresses. */
1184 af = sctp_get_af_specific(daddr->sa.s !! 1142 addr_buf = kaddrs;
1185 if (!af || af->sockaddr_len > addrs_s !! 1143 while (walk_size < addrs_size) {
1186 return -EINVAL; !! 1144 struct sctp_af *af;
1187 1145
1188 err = sctp_verify_addr(sk, daddr, af- !! 1146 if (walk_size + sizeof(sa_family_t) > addrs_size) {
1189 if (err) !! 1147 err = -EINVAL;
1190 return err; !! 1148 goto out_free;
>> 1149 }
1191 1150
1192 asoc = sctp_endpoint_lookup_assoc(ep, !! 1151 sa_addr = addr_buf;
1193 if (asoc) !! 1152 af = sctp_get_af_specific(sa_addr->sa.sa_family);
1194 return asoc->state >= SCTP_ST <<
1195 <<
1196 1153
1197 err = sctp_connect_new_asoc(ep, daddr !! 1154 /* If the address family is not supported or if this address
1198 if (err) !! 1155 * causes the address buffer to overflow return EINVAL.
1199 return err; !! 1156 */
1200 asoc = transport->asoc; !! 1157 if (!af || (walk_size + af->sockaddr_len) > addrs_size) {
>> 1158 err = -EINVAL;
>> 1159 goto out_free;
>> 1160 }
1201 1161
1202 addr_buf += af->sockaddr_len; !! 1162 port = ntohs(sa_addr->v4.sin_port);
1203 walk_size = af->sockaddr_len; !! 1163
1204 while (walk_size < addrs_size) { !! 1164 /* Save current address so we can work with it */
1205 err = -EINVAL; !! 1165 memcpy(&to, sa_addr, af->sockaddr_len);
1206 if (walk_size + sizeof(sa_fam !! 1166
>> 1167 err = sctp_verify_addr(sk, &to, af->sockaddr_len);
>> 1168 if (err)
1207 goto out_free; 1169 goto out_free;
1208 1170
1209 daddr = addr_buf; !! 1171 /* Make sure the destination port is correctly set
1210 af = sctp_get_af_specific(dad !! 1172 * in all addresses.
1211 if (!af || af->sockaddr_len + !! 1173 */
>> 1174 if (asoc && asoc->peer.port && asoc->peer.port != port) {
>> 1175 err = -EINVAL;
1212 goto out_free; 1176 goto out_free;
>> 1177 }
1213 1178
1214 if (asoc->peer.port != ntohs( !! 1179 /* Check if there already is a matching association on the
>> 1180 * endpoint (other than the one created here).
>> 1181 */
>> 1182 asoc2 = sctp_endpoint_lookup_assoc(ep, &to, &transport);
>> 1183 if (asoc2 && asoc2 != asoc) {
>> 1184 if (asoc2->state >= SCTP_STATE_ESTABLISHED)
>> 1185 err = -EISCONN;
>> 1186 else
>> 1187 err = -EALREADY;
1215 goto out_free; 1188 goto out_free;
>> 1189 }
1216 1190
1217 err = sctp_connect_add_peer(a !! 1191 /* If we could not find a matching association on the endpoint,
1218 if (err) !! 1192 * make sure that there is no peeled-off association matching
>> 1193 * the peer address even on another socket.
>> 1194 */
>> 1195 if (sctp_endpoint_is_peeled_off(ep, &to)) {
>> 1196 err = -EADDRNOTAVAIL;
1219 goto out_free; 1197 goto out_free;
>> 1198 }
>> 1199
>> 1200 if (!asoc) {
>> 1201 /* If a bind() or sctp_bindx() is not called prior to
>> 1202 * an sctp_connectx() call, the system picks an
>> 1203 * ephemeral port and will choose an address set
>> 1204 * equivalent to binding with a wildcard address.
>> 1205 */
>> 1206 if (!ep->base.bind_addr.port) {
>> 1207 if (sctp_autobind(sk)) {
>> 1208 err = -EAGAIN;
>> 1209 goto out_free;
>> 1210 }
>> 1211 } else {
>> 1212 /*
>> 1213 * If an unprivileged user inherits a 1-many
>> 1214 * style socket with open associations on a
>> 1215 * privileged port, it MAY be permitted to
>> 1216 * accept new associations, but it SHOULD NOT
>> 1217 * be permitted to open new associations.
>> 1218 */
>> 1219 if (ep->base.bind_addr.port <
>> 1220 inet_prot_sock(net) &&
>> 1221 !ns_capable(net->user_ns,
>> 1222 CAP_NET_BIND_SERVICE)) {
>> 1223 err = -EACCES;
>> 1224 goto out_free;
>> 1225 }
>> 1226 }
>> 1227
>> 1228 scope = sctp_scope(&to);
>> 1229 asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);
>> 1230 if (!asoc) {
>> 1231 err = -ENOMEM;
>> 1232 goto out_free;
>> 1233 }
>> 1234
>> 1235 err = sctp_assoc_set_bind_addr_from_ep(asoc, scope,
>> 1236 GFP_KERNEL);
>> 1237 if (err < 0) {
>> 1238 goto out_free;
>> 1239 }
>> 1240
>> 1241 }
1220 1242
1221 addr_buf += af->sockaddr_len !! 1243 /* Prime the peer's transport structures. */
>> 1244 transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL,
>> 1245 SCTP_UNKNOWN);
>> 1246 if (!transport) {
>> 1247 err = -ENOMEM;
>> 1248 goto out_free;
>> 1249 }
>> 1250
>> 1251 addrcnt++;
>> 1252 addr_buf += af->sockaddr_len;
1222 walk_size += af->sockaddr_len 1253 walk_size += af->sockaddr_len;
1223 } 1254 }
1224 1255
1225 /* In case the user of sctp_connectx( 1256 /* In case the user of sctp_connectx() wants an association
1226 * id back, assign one now. 1257 * id back, assign one now.
1227 */ 1258 */
1228 if (assoc_id) { 1259 if (assoc_id) {
1229 err = sctp_assoc_set_id(asoc, 1260 err = sctp_assoc_set_id(asoc, GFP_KERNEL);
1230 if (err < 0) 1261 if (err < 0)
1231 goto out_free; 1262 goto out_free;
1232 } 1263 }
1233 1264
1234 err = sctp_primitive_ASSOCIATE(sock_n !! 1265 err = sctp_primitive_ASSOCIATE(net, asoc, NULL);
1235 if (err < 0) !! 1266 if (err < 0) {
1236 goto out_free; 1267 goto out_free;
>> 1268 }
1237 1269
1238 /* Initialize sk's dport and daddr fo 1270 /* Initialize sk's dport and daddr for getpeername() */
1239 inet_sk(sk)->inet_dport = htons(asoc- 1271 inet_sk(sk)->inet_dport = htons(asoc->peer.port);
1240 sp->pf->to_sk_daddr(daddr, sk); !! 1272 sp->pf->to_sk_daddr(sa_addr, sk);
1241 sk->sk_err = 0; 1273 sk->sk_err = 0;
1242 1274
>> 1275 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
>> 1276
1243 if (assoc_id) 1277 if (assoc_id)
1244 *assoc_id = asoc->assoc_id; 1278 *assoc_id = asoc->assoc_id;
>> 1279 err = sctp_wait_for_connect(asoc, &timeo);
>> 1280 /* Note: the asoc may be freed after the return of
>> 1281 * sctp_wait_for_connect.
>> 1282 */
1245 1283
1246 timeo = sock_sndtimeo(sk, flags & O_N !! 1284 /* Don't free association on exit. */
1247 return sctp_wait_for_connect(asoc, &t !! 1285 asoc = NULL;
1248 1286
1249 out_free: 1287 out_free:
1250 pr_debug("%s: took out_free path with 1288 pr_debug("%s: took out_free path with asoc:%p kaddrs:%p err:%d\n",
1251 __func__, asoc, kaddrs, err) 1289 __func__, asoc, kaddrs, err);
1252 sctp_association_free(asoc); !! 1290
>> 1291 if (asoc) {
>> 1292 /* sctp_primitive_ASSOCIATE may have added this association
>> 1293 * To the hash table, try to unhash it, just in case, its a noop
>> 1294 * if it wasn't hashed so we're safe
>> 1295 */
>> 1296 sctp_association_free(asoc);
>> 1297 }
1253 return err; 1298 return err;
1254 } 1299 }
1255 1300
1256 /* Helper for tunneling sctp_connectx() reque 1301 /* Helper for tunneling sctp_connectx() requests through sctp_setsockopt()
1257 * 1302 *
1258 * API 8.9 1303 * API 8.9
1259 * int sctp_connectx(int sd, struct sockaddr 1304 * int sctp_connectx(int sd, struct sockaddr *addrs, int addrcnt,
1260 * sctp_assoc_t *asoc); 1305 * sctp_assoc_t *asoc);
1261 * 1306 *
1262 * If sd is an IPv4 socket, the addresses pas 1307 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
1263 * If the sd is an IPv6 socket, the addresses 1308 * If the sd is an IPv6 socket, the addresses passed can either be IPv4
1264 * or IPv6 addresses. 1309 * or IPv6 addresses.
1265 * 1310 *
1266 * A single address may be specified as INADD 1311 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
1267 * Section 3.1.2 for this usage. 1312 * Section 3.1.2 for this usage.
1268 * 1313 *
1269 * addrs is a pointer to an array of one or m 1314 * addrs is a pointer to an array of one or more socket addresses. Each
1270 * address is contained in its appropriate st 1315 * address is contained in its appropriate structure (i.e. struct
1271 * sockaddr_in or struct sockaddr_in6) the fa 1316 * sockaddr_in or struct sockaddr_in6) the family of the address type
1272 * must be used to distengish the address len 1317 * must be used to distengish the address length (note that this
1273 * representation is termed a "packed array" 1318 * representation is termed a "packed array" of addresses). The caller
1274 * specifies the number of addresses in the a 1319 * specifies the number of addresses in the array with addrcnt.
1275 * 1320 *
1276 * On success, sctp_connectx() returns 0. It 1321 * On success, sctp_connectx() returns 0. It also sets the assoc_id to
1277 * the association id of the new association. 1322 * the association id of the new association. On failure, sctp_connectx()
1278 * returns -1, and sets errno to the appropri 1323 * returns -1, and sets errno to the appropriate error code. The assoc_id
1279 * is not touched by the kernel. 1324 * is not touched by the kernel.
1280 * 1325 *
1281 * For SCTP, the port given in each socket ad 1326 * For SCTP, the port given in each socket address must be the same, or
1282 * sctp_connectx() will fail, setting errno t 1327 * sctp_connectx() will fail, setting errno to EINVAL.
1283 * 1328 *
1284 * An application can use sctp_connectx to in 1329 * An application can use sctp_connectx to initiate an association with
1285 * an endpoint that is multi-homed. Much lik 1330 * an endpoint that is multi-homed. Much like sctp_bindx() this call
1286 * allows a caller to specify multiple addres 1331 * allows a caller to specify multiple addresses at which a peer can be
1287 * reached. The way the SCTP stack uses the 1332 * reached. The way the SCTP stack uses the list of addresses to set up
1288 * the association is implementation dependen 1333 * the association is implementation dependent. This function only
1289 * specifies that the stack will try to make 1334 * specifies that the stack will try to make use of all the addresses in
1290 * the list when needed. 1335 * the list when needed.
1291 * 1336 *
1292 * Note that the list of addresses passed in 1337 * Note that the list of addresses passed in is only used for setting up
1293 * the association. It does not necessarily 1338 * the association. It does not necessarily equal the set of addresses
1294 * the peer uses for the resulting associatio 1339 * the peer uses for the resulting association. If the caller wants to
1295 * find out the set of peer addresses, it mus 1340 * find out the set of peer addresses, it must use sctp_getpaddrs() to
1296 * retrieve them after the association has be 1341 * retrieve them after the association has been set up.
1297 * 1342 *
1298 * Basically do nothing but copying the addre 1343 * Basically do nothing but copying the addresses from user to kernel
1299 * land and invoking either sctp_connectx(). 1344 * land and invoking either sctp_connectx(). This is used for tunneling
1300 * the sctp_connectx() request through sctp_s 1345 * the sctp_connectx() request through sctp_setsockopt() from userspace.
1301 * 1346 *
>> 1347 * We don't use copy_from_user() for optimization: we first do the
>> 1348 * sanity checks (buffer size -fast- and access check-healthy
>> 1349 * pointer); if all of those succeed, then we can alloc the memory
>> 1350 * (expensive operation) needed to copy the data to kernel. Then we do
>> 1351 * the copying without checking the user space area
>> 1352 * (__copy_from_user()).
>> 1353 *
1302 * On exit there is no need to do sockfd_put( 1354 * On exit there is no need to do sockfd_put(), sys_setsockopt() does
1303 * it. 1355 * it.
1304 * 1356 *
1305 * sk The sk of the socket 1357 * sk The sk of the socket
1306 * addrs The pointer to the addresses !! 1358 * addrs The pointer to the addresses in user land
1307 * addrssize Size of the addrs buffer 1359 * addrssize Size of the addrs buffer
1308 * 1360 *
1309 * Returns >=0 if ok, <0 errno code on error. 1361 * Returns >=0 if ok, <0 errno code on error.
1310 */ 1362 */
1311 static int __sctp_setsockopt_connectx(struct !! 1363 static int __sctp_setsockopt_connectx(struct sock *sk,
1312 int add !! 1364 struct sockaddr __user *addrs,
>> 1365 int addrs_size,
>> 1366 sctp_assoc_t *assoc_id)
1313 { 1367 {
>> 1368 struct sockaddr *kaddrs;
>> 1369 gfp_t gfp = GFP_KERNEL;
1314 int err = 0, flags = 0; 1370 int err = 0, flags = 0;
1315 1371
1316 pr_debug("%s: sk:%p addrs:%p addrs_si 1372 pr_debug("%s: sk:%p addrs:%p addrs_size:%d\n",
1317 __func__, sk, kaddrs, addrs_ !! 1373 __func__, sk, addrs, addrs_size);
1318 1374
1319 /* make sure the 1st addr's sa_family !! 1375 if (unlikely(addrs_size <= 0))
1320 if (unlikely(addrs_size < sizeof(sa_f <<
1321 return -EINVAL; 1376 return -EINVAL;
1322 1377
1323 /* Allow security module to validate !! 1378 /* Check the user passed a healthy pointer. */
1324 err = security_sctp_bind_connect(sk, !! 1379 if (unlikely(!access_ok(VERIFY_READ, addrs, addrs_size)))
1325 (str !! 1380 return -EFAULT;
1326 add !! 1381
1327 if (err) !! 1382 /* Alloc space for the address array in kernel memory. */
1328 return err; !! 1383 if (sk->sk_socket->file)
>> 1384 gfp = GFP_USER | __GFP_NOWARN;
>> 1385 kaddrs = kmalloc(addrs_size, gfp);
>> 1386 if (unlikely(!kaddrs))
>> 1387 return -ENOMEM;
>> 1388
>> 1389 if (__copy_from_user(kaddrs, addrs, addrs_size)) {
>> 1390 kfree(kaddrs);
>> 1391 return -EFAULT;
>> 1392 }
1329 1393
1330 /* in-kernel sockets don't generally 1394 /* in-kernel sockets don't generally have a file allocated to them
1331 * if all they do is call sock_create 1395 * if all they do is call sock_create_kern().
1332 */ 1396 */
1333 if (sk->sk_socket->file) 1397 if (sk->sk_socket->file)
1334 flags = sk->sk_socket->file-> 1398 flags = sk->sk_socket->file->f_flags;
1335 1399
1336 return __sctp_connect(sk, kaddrs, add !! 1400 err = __sctp_connect(sk, kaddrs, addrs_size, flags, assoc_id);
>> 1401
>> 1402 kfree(kaddrs);
>> 1403
>> 1404 return err;
1337 } 1405 }
1338 1406
1339 /* 1407 /*
1340 * This is an older interface. It's kept for 1408 * This is an older interface. It's kept for backward compatibility
1341 * to the option that doesn't provide associa 1409 * to the option that doesn't provide association id.
1342 */ 1410 */
1343 static int sctp_setsockopt_connectx_old(struc 1411 static int sctp_setsockopt_connectx_old(struct sock *sk,
1344 struc !! 1412 struct sockaddr __user *addrs,
1345 int a 1413 int addrs_size)
1346 { 1414 {
1347 return __sctp_setsockopt_connectx(sk, !! 1415 return __sctp_setsockopt_connectx(sk, addrs, addrs_size, NULL);
1348 } 1416 }
1349 1417
1350 /* 1418 /*
1351 * New interface for the API. The since the 1419 * New interface for the API. The since the API is done with a socket
1352 * option, to make it simple we feed back the 1420 * option, to make it simple we feed back the association id is as a return
1353 * indication to the call. Error is always n 1421 * indication to the call. Error is always negative and association id is
1354 * always positive. 1422 * always positive.
1355 */ 1423 */
1356 static int sctp_setsockopt_connectx(struct so 1424 static int sctp_setsockopt_connectx(struct sock *sk,
1357 struct so !! 1425 struct sockaddr __user *addrs,
1358 int addrs 1426 int addrs_size)
1359 { 1427 {
1360 sctp_assoc_t assoc_id = 0; 1428 sctp_assoc_t assoc_id = 0;
1361 int err = 0; 1429 int err = 0;
1362 1430
1363 err = __sctp_setsockopt_connectx(sk, !! 1431 err = __sctp_setsockopt_connectx(sk, addrs, addrs_size, &assoc_id);
1364 1432
1365 if (err) 1433 if (err)
1366 return err; 1434 return err;
1367 else 1435 else
1368 return assoc_id; 1436 return assoc_id;
1369 } 1437 }
1370 1438
1371 /* 1439 /*
1372 * New (hopefully final) interface for the AP 1440 * New (hopefully final) interface for the API.
1373 * We use the sctp_getaddrs_old structure so 1441 * We use the sctp_getaddrs_old structure so that use-space library
1374 * can avoid any unnecessary allocations. The 1442 * can avoid any unnecessary allocations. The only different part
1375 * is that we store the actual length of the 1443 * is that we store the actual length of the address buffer into the
1376 * addrs_num structure member. That way we ca 1444 * addrs_num structure member. That way we can re-use the existing
1377 * code. 1445 * code.
1378 */ 1446 */
1379 #ifdef CONFIG_COMPAT 1447 #ifdef CONFIG_COMPAT
1380 struct compat_sctp_getaddrs_old { 1448 struct compat_sctp_getaddrs_old {
1381 sctp_assoc_t assoc_id; 1449 sctp_assoc_t assoc_id;
1382 s32 addr_num; 1450 s32 addr_num;
1383 compat_uptr_t addrs; /* st 1451 compat_uptr_t addrs; /* struct sockaddr * */
1384 }; 1452 };
1385 #endif 1453 #endif
1386 1454
1387 static int sctp_getsockopt_connectx3(struct s 1455 static int sctp_getsockopt_connectx3(struct sock *sk, int len,
1388 char __u 1456 char __user *optval,
1389 int __us 1457 int __user *optlen)
1390 { 1458 {
1391 struct sctp_getaddrs_old param; 1459 struct sctp_getaddrs_old param;
1392 sctp_assoc_t assoc_id = 0; 1460 sctp_assoc_t assoc_id = 0;
1393 struct sockaddr *kaddrs; <<
1394 int err = 0; 1461 int err = 0;
1395 1462
1396 #ifdef CONFIG_COMPAT 1463 #ifdef CONFIG_COMPAT
1397 if (in_compat_syscall()) { 1464 if (in_compat_syscall()) {
1398 struct compat_sctp_getaddrs_o 1465 struct compat_sctp_getaddrs_old param32;
1399 1466
1400 if (len < sizeof(param32)) 1467 if (len < sizeof(param32))
1401 return -EINVAL; 1468 return -EINVAL;
1402 if (copy_from_user(¶m32, 1469 if (copy_from_user(¶m32, optval, sizeof(param32)))
1403 return -EFAULT; 1470 return -EFAULT;
1404 1471
1405 param.assoc_id = param32.asso 1472 param.assoc_id = param32.assoc_id;
1406 param.addr_num = param32.addr 1473 param.addr_num = param32.addr_num;
1407 param.addrs = compat_ptr(para 1474 param.addrs = compat_ptr(param32.addrs);
1408 } else 1475 } else
1409 #endif 1476 #endif
1410 { 1477 {
1411 if (len < sizeof(param)) 1478 if (len < sizeof(param))
1412 return -EINVAL; 1479 return -EINVAL;
1413 if (copy_from_user(¶m, op 1480 if (copy_from_user(¶m, optval, sizeof(param)))
1414 return -EFAULT; 1481 return -EFAULT;
1415 } 1482 }
1416 1483
1417 kaddrs = memdup_user(param.addrs, par !! 1484 err = __sctp_setsockopt_connectx(sk, (struct sockaddr __user *)
1418 if (IS_ERR(kaddrs)) !! 1485 param.addrs, param.addr_num,
1419 return PTR_ERR(kaddrs); !! 1486 &assoc_id);
1420 <<
1421 err = __sctp_setsockopt_connectx(sk, <<
1422 kfree(kaddrs); <<
1423 if (err == 0 || err == -EINPROGRESS) 1487 if (err == 0 || err == -EINPROGRESS) {
1424 if (copy_to_user(optval, &ass 1488 if (copy_to_user(optval, &assoc_id, sizeof(assoc_id)))
1425 return -EFAULT; 1489 return -EFAULT;
1426 if (put_user(sizeof(assoc_id) 1490 if (put_user(sizeof(assoc_id), optlen))
1427 return -EFAULT; 1491 return -EFAULT;
1428 } 1492 }
1429 1493
1430 return err; 1494 return err;
1431 } 1495 }
1432 1496
1433 /* API 3.1.4 close() - UDP Style Syntax 1497 /* API 3.1.4 close() - UDP Style Syntax
1434 * Applications use close() to perform gracef 1498 * Applications use close() to perform graceful shutdown (as described in
1435 * Section 10.1 of [SCTP]) on ALL the associa 1499 * Section 10.1 of [SCTP]) on ALL the associations currently represented
1436 * by a UDP-style socket. 1500 * by a UDP-style socket.
1437 * 1501 *
1438 * The syntax is 1502 * The syntax is
1439 * 1503 *
1440 * ret = close(int sd); 1504 * ret = close(int sd);
1441 * 1505 *
1442 * sd - the socket descriptor of the a 1506 * sd - the socket descriptor of the associations to be closed.
1443 * 1507 *
1444 * To gracefully shutdown a specific associat 1508 * To gracefully shutdown a specific association represented by the
1445 * UDP-style socket, an application should us 1509 * UDP-style socket, an application should use the sendmsg() call,
1446 * passing no user data, but including the ap 1510 * passing no user data, but including the appropriate flag in the
1447 * ancillary data (see Section xxxx). 1511 * ancillary data (see Section xxxx).
1448 * 1512 *
1449 * If sd in the close() call is a branched-of 1513 * If sd in the close() call is a branched-off socket representing only
1450 * one association, the shutdown is performed 1514 * one association, the shutdown is performed on that association only.
1451 * 1515 *
1452 * 4.1.6 close() - TCP Style Syntax 1516 * 4.1.6 close() - TCP Style Syntax
1453 * 1517 *
1454 * Applications use close() to gracefully clo 1518 * Applications use close() to gracefully close down an association.
1455 * 1519 *
1456 * The syntax is: 1520 * The syntax is:
1457 * 1521 *
1458 * int close(int sd); 1522 * int close(int sd);
1459 * 1523 *
1460 * sd - the socket descriptor of th 1524 * sd - the socket descriptor of the association to be closed.
1461 * 1525 *
1462 * After an application calls close() on a so 1526 * After an application calls close() on a socket descriptor, no further
1463 * socket operations will succeed on that des 1527 * socket operations will succeed on that descriptor.
1464 * 1528 *
1465 * API 7.1.4 SO_LINGER 1529 * API 7.1.4 SO_LINGER
1466 * 1530 *
1467 * An application using the TCP-style socket 1531 * An application using the TCP-style socket can use this option to
1468 * perform the SCTP ABORT primitive. The lin 1532 * perform the SCTP ABORT primitive. The linger option structure is:
1469 * 1533 *
1470 * struct linger { 1534 * struct linger {
1471 * int l_onoff; // opt 1535 * int l_onoff; // option on/off
1472 * int l_linger; // lin 1536 * int l_linger; // linger time
1473 * }; 1537 * };
1474 * 1538 *
1475 * To enable the option, set l_onoff to 1. I 1539 * To enable the option, set l_onoff to 1. If the l_linger value is set
1476 * to 0, calling close() is the same as the A 1540 * to 0, calling close() is the same as the ABORT primitive. If the
1477 * value is set to a negative value, the sets 1541 * value is set to a negative value, the setsockopt() call will return
1478 * an error. If the value is set to a positi 1542 * an error. If the value is set to a positive value linger_time, the
1479 * close() can be blocked for at most linger_ 1543 * close() can be blocked for at most linger_time ms. If the graceful
1480 * shutdown phase does not finish during this 1544 * shutdown phase does not finish during this period, close() will
1481 * return but the graceful shutdown phase con 1545 * return but the graceful shutdown phase continues in the system.
1482 */ 1546 */
1483 static void sctp_close(struct sock *sk, long 1547 static void sctp_close(struct sock *sk, long timeout)
1484 { 1548 {
1485 struct net *net = sock_net(sk); 1549 struct net *net = sock_net(sk);
1486 struct sctp_endpoint *ep; 1550 struct sctp_endpoint *ep;
1487 struct sctp_association *asoc; 1551 struct sctp_association *asoc;
1488 struct list_head *pos, *temp; 1552 struct list_head *pos, *temp;
1489 unsigned int data_was_unread; 1553 unsigned int data_was_unread;
1490 1554
1491 pr_debug("%s: sk:%p, timeout:%ld\n", 1555 pr_debug("%s: sk:%p, timeout:%ld\n", __func__, sk, timeout);
1492 1556
1493 lock_sock_nested(sk, SINGLE_DEPTH_NES 1557 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
1494 sk->sk_shutdown = SHUTDOWN_MASK; 1558 sk->sk_shutdown = SHUTDOWN_MASK;
1495 inet_sk_set_state(sk, SCTP_SS_CLOSING !! 1559 sk->sk_state = SCTP_SS_CLOSING;
1496 1560
1497 ep = sctp_sk(sk)->ep; 1561 ep = sctp_sk(sk)->ep;
1498 1562
1499 /* Clean up any skbs sitting on the r 1563 /* Clean up any skbs sitting on the receive queue. */
1500 data_was_unread = sctp_queue_purge_ul 1564 data_was_unread = sctp_queue_purge_ulpevents(&sk->sk_receive_queue);
1501 data_was_unread += sctp_queue_purge_u 1565 data_was_unread += sctp_queue_purge_ulpevents(&sctp_sk(sk)->pd_lobby);
1502 1566
1503 /* Walk all associations on an endpoi 1567 /* Walk all associations on an endpoint. */
1504 list_for_each_safe(pos, temp, &ep->as 1568 list_for_each_safe(pos, temp, &ep->asocs) {
1505 asoc = list_entry(pos, struct 1569 asoc = list_entry(pos, struct sctp_association, asocs);
1506 1570
1507 if (sctp_style(sk, TCP)) { 1571 if (sctp_style(sk, TCP)) {
1508 /* A closed associati 1572 /* A closed association can still be in the list if
1509 * it belongs to a TC 1573 * it belongs to a TCP-style listening socket that is
1510 * not yet accepted. 1574 * not yet accepted. If so, free it. If not, send an
1511 * ABORT or SHUTDOWN 1575 * ABORT or SHUTDOWN based on the linger options.
1512 */ 1576 */
1513 if (sctp_state(asoc, 1577 if (sctp_state(asoc, CLOSED)) {
1514 sctp_associat 1578 sctp_association_free(asoc);
1515 continue; 1579 continue;
1516 } 1580 }
1517 } 1581 }
1518 1582
1519 if (data_was_unread || !skb_q 1583 if (data_was_unread || !skb_queue_empty(&asoc->ulpq.lobby) ||
1520 !skb_queue_empty(&asoc->u 1584 !skb_queue_empty(&asoc->ulpq.reasm) ||
1521 !skb_queue_empty(&asoc->u <<
1522 (sock_flag(sk, SOCK_LINGE 1585 (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime)) {
1523 struct sctp_chunk *ch 1586 struct sctp_chunk *chunk;
1524 1587
1525 chunk = sctp_make_abo 1588 chunk = sctp_make_abort_user(asoc, NULL, 0);
1526 sctp_primitive_ABORT( 1589 sctp_primitive_ABORT(net, asoc, chunk);
1527 } else 1590 } else
1528 sctp_primitive_SHUTDO 1591 sctp_primitive_SHUTDOWN(net, asoc, NULL);
1529 } 1592 }
1530 1593
1531 /* On a TCP-style socket, block for a 1594 /* On a TCP-style socket, block for at most linger_time if set. */
1532 if (sctp_style(sk, TCP) && timeout) 1595 if (sctp_style(sk, TCP) && timeout)
1533 sctp_wait_for_close(sk, timeo 1596 sctp_wait_for_close(sk, timeout);
1534 1597
1535 /* This will run the backlog queue. 1598 /* This will run the backlog queue. */
1536 release_sock(sk); 1599 release_sock(sk);
1537 1600
1538 /* Supposedly, no process has access 1601 /* Supposedly, no process has access to the socket, but
1539 * the net layers still may. 1602 * the net layers still may.
1540 * Also, sctp_destroy_sock() needs to 1603 * Also, sctp_destroy_sock() needs to be called with addr_wq_lock
1541 * held and that should be grabbed be 1604 * held and that should be grabbed before socket lock.
1542 */ 1605 */
1543 spin_lock_bh(&net->sctp.addr_wq_lock) 1606 spin_lock_bh(&net->sctp.addr_wq_lock);
1544 bh_lock_sock_nested(sk); 1607 bh_lock_sock_nested(sk);
1545 1608
1546 /* Hold the sock, since sk_common_rel 1609 /* Hold the sock, since sk_common_release() will put sock_put()
1547 * and we have just a little more cle 1610 * and we have just a little more cleanup.
1548 */ 1611 */
1549 sock_hold(sk); 1612 sock_hold(sk);
1550 sk_common_release(sk); 1613 sk_common_release(sk);
1551 1614
1552 bh_unlock_sock(sk); 1615 bh_unlock_sock(sk);
1553 spin_unlock_bh(&net->sctp.addr_wq_loc 1616 spin_unlock_bh(&net->sctp.addr_wq_lock);
1554 1617
1555 sock_put(sk); 1618 sock_put(sk);
1556 1619
1557 SCTP_DBG_OBJCNT_DEC(sock); 1620 SCTP_DBG_OBJCNT_DEC(sock);
1558 } 1621 }
1559 1622
1560 /* Handle EPIPE error. */ 1623 /* Handle EPIPE error. */
1561 static int sctp_error(struct sock *sk, int fl 1624 static int sctp_error(struct sock *sk, int flags, int err)
1562 { 1625 {
1563 if (err == -EPIPE) 1626 if (err == -EPIPE)
1564 err = sock_error(sk) ? : -EPI 1627 err = sock_error(sk) ? : -EPIPE;
1565 if (err == -EPIPE && !(flags & MSG_NO 1628 if (err == -EPIPE && !(flags & MSG_NOSIGNAL))
1566 send_sig(SIGPIPE, current, 0) 1629 send_sig(SIGPIPE, current, 0);
1567 return err; 1630 return err;
1568 } 1631 }
1569 1632
1570 /* API 3.1.3 sendmsg() - UDP Style Syntax 1633 /* API 3.1.3 sendmsg() - UDP Style Syntax
1571 * 1634 *
1572 * An application uses sendmsg() and recvmsg( 1635 * An application uses sendmsg() and recvmsg() calls to transmit data to
1573 * and receive data from its peer. 1636 * and receive data from its peer.
1574 * 1637 *
1575 * ssize_t sendmsg(int socket, const struct 1638 * ssize_t sendmsg(int socket, const struct msghdr *message,
1576 * int flags); 1639 * int flags);
1577 * 1640 *
1578 * socket - the socket descriptor of the en 1641 * socket - the socket descriptor of the endpoint.
1579 * message - pointer to the msghdr structure 1642 * message - pointer to the msghdr structure which contains a single
1580 * user message and possibly some 1643 * user message and possibly some ancillary data.
1581 * 1644 *
1582 * See Section 5 for complete desc 1645 * See Section 5 for complete description of the data
1583 * structures. 1646 * structures.
1584 * 1647 *
1585 * flags - flags sent or received with the 1648 * flags - flags sent or received with the user message, see Section
1586 * 5 for complete description of t 1649 * 5 for complete description of the flags.
1587 * 1650 *
1588 * Note: This function could use a rewrite e 1651 * Note: This function could use a rewrite especially when explicit
1589 * connect support comes in. 1652 * connect support comes in.
1590 */ 1653 */
1591 /* BUG: We do not implement the equivalent o 1654 /* BUG: We do not implement the equivalent of sk_stream_wait_memory(). */
1592 1655
1593 static int sctp_msghdr_parse(const struct msg 1656 static int sctp_msghdr_parse(const struct msghdr *msg,
1594 struct sctp_cmsg 1657 struct sctp_cmsgs *cmsgs);
1595 1658
1596 static int sctp_sendmsg_parse(struct sock *sk !! 1659 static int sctp_sendmsg(struct sock *sk, struct msghdr *msg, size_t msg_len)
1597 struct sctp_snd <<
1598 const struct ms <<
1599 { 1660 {
1600 __u16 sflags; !! 1661 struct net *net = sock_net(sk);
>> 1662 struct sctp_sock *sp;
>> 1663 struct sctp_endpoint *ep;
>> 1664 struct sctp_association *new_asoc = NULL, *asoc = NULL;
>> 1665 struct sctp_transport *transport, *chunk_tp;
>> 1666 struct sctp_chunk *chunk;
>> 1667 union sctp_addr to;
>> 1668 struct sockaddr *msg_name = NULL;
>> 1669 struct sctp_sndrcvinfo default_sinfo;
>> 1670 struct sctp_sndrcvinfo *sinfo;
>> 1671 struct sctp_initmsg *sinit;
>> 1672 sctp_assoc_t associd = 0;
>> 1673 struct sctp_cmsgs cmsgs = { NULL };
>> 1674 enum sctp_scope scope;
>> 1675 bool fill_sinfo_ttl = false, wait_connect = false;
>> 1676 struct sctp_datamsg *datamsg;
>> 1677 int msg_flags = msg->msg_flags;
>> 1678 __u16 sinfo_flags = 0;
>> 1679 long timeo;
1601 int err; 1680 int err;
1602 1681
1603 if (sctp_sstate(sk, LISTENING) && sct !! 1682 err = 0;
1604 return -EPIPE; !! 1683 sp = sctp_sk(sk);
>> 1684 ep = sp->ep;
>> 1685
>> 1686 pr_debug("%s: sk:%p, msg:%p, msg_len:%zu ep:%p\n", __func__, sk,
>> 1687 msg, msg_len, ep);
1605 1688
1606 if (msg_len > sk->sk_sndbuf) !! 1689 /* We cannot send a message over a TCP-style listening socket. */
1607 return -EMSGSIZE; !! 1690 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)) {
>> 1691 err = -EPIPE;
>> 1692 goto out_nounlock;
>> 1693 }
1608 1694
1609 memset(cmsgs, 0, sizeof(*cmsgs)); !! 1695 /* Parse out the SCTP CMSGs. */
1610 err = sctp_msghdr_parse(msg, cmsgs); !! 1696 err = sctp_msghdr_parse(msg, &cmsgs);
1611 if (err) { 1697 if (err) {
1612 pr_debug("%s: msghdr parse er 1698 pr_debug("%s: msghdr parse err:%x\n", __func__, err);
1613 return err; !! 1699 goto out_nounlock;
1614 } 1700 }
1615 1701
1616 memset(srinfo, 0, sizeof(*srinfo)); !! 1702 /* Fetch the destination address for this packet. This
1617 if (cmsgs->srinfo) { !! 1703 * address only selects the association--it is not necessarily
1618 srinfo->sinfo_stream = cmsgs- !! 1704 * the address we will send to.
1619 srinfo->sinfo_flags = cmsgs-> !! 1705 * For a peeled-off socket, msg_name is ignored.
1620 srinfo->sinfo_ppid = cmsgs->s !! 1706 */
1621 srinfo->sinfo_context = cmsgs !! 1707 if (!sctp_style(sk, UDP_HIGH_BANDWIDTH) && msg->msg_name) {
1622 srinfo->sinfo_assoc_id = cmsg !! 1708 int msg_namelen = msg->msg_namelen;
1623 srinfo->sinfo_timetolive = cm <<
1624 } <<
1625 <<
1626 if (cmsgs->sinfo) { <<
1627 srinfo->sinfo_stream = cmsgs- <<
1628 srinfo->sinfo_flags = cmsgs-> <<
1629 srinfo->sinfo_ppid = cmsgs->s <<
1630 srinfo->sinfo_context = cmsgs <<
1631 srinfo->sinfo_assoc_id = cmsg <<
1632 } <<
1633 <<
1634 if (cmsgs->prinfo) { <<
1635 srinfo->sinfo_timetolive = cm <<
1636 SCTP_PR_SET_POLICY(srinfo->si <<
1637 cmsgs->pri <<
1638 } <<
1639 1709
1640 sflags = srinfo->sinfo_flags; !! 1710 err = sctp_verify_addr(sk, (union sctp_addr *)msg->msg_name,
1641 if (!sflags && msg_len) !! 1711 msg_namelen);
1642 return 0; !! 1712 if (err)
>> 1713 return err;
1643 1714
1644 if (sctp_style(sk, TCP) && (sflags & !! 1715 if (msg_namelen > sizeof(to))
1645 return -EINVAL; !! 1716 msg_namelen = sizeof(to);
>> 1717 memcpy(&to, msg->msg_name, msg_namelen);
>> 1718 msg_name = msg->msg_name;
>> 1719 }
>> 1720
>> 1721 sinit = cmsgs.init;
>> 1722 if (cmsgs.sinfo != NULL) {
>> 1723 memset(&default_sinfo, 0, sizeof(default_sinfo));
>> 1724 default_sinfo.sinfo_stream = cmsgs.sinfo->snd_sid;
>> 1725 default_sinfo.sinfo_flags = cmsgs.sinfo->snd_flags;
>> 1726 default_sinfo.sinfo_ppid = cmsgs.sinfo->snd_ppid;
>> 1727 default_sinfo.sinfo_context = cmsgs.sinfo->snd_context;
>> 1728 default_sinfo.sinfo_assoc_id = cmsgs.sinfo->snd_assoc_id;
1646 1729
1647 if (((sflags & SCTP_EOF) && msg_len > !! 1730 sinfo = &default_sinfo;
1648 (!(sflags & (SCTP_EOF | SCTP_ABOR !! 1731 fill_sinfo_ttl = true;
1649 return -EINVAL; !! 1732 } else {
>> 1733 sinfo = cmsgs.srinfo;
>> 1734 }
>> 1735 /* Did the user specify SNDINFO/SNDRCVINFO? */
>> 1736 if (sinfo) {
>> 1737 sinfo_flags = sinfo->sinfo_flags;
>> 1738 associd = sinfo->sinfo_assoc_id;
>> 1739 }
1650 1740
1651 if ((sflags & SCTP_ADDR_OVER) && !msg !! 1741 pr_debug("%s: msg_len:%zu, sinfo_flags:0x%x\n", __func__,
1652 return -EINVAL; !! 1742 msg_len, sinfo_flags);
1653 1743
1654 return 0; !! 1744 /* SCTP_EOF or SCTP_ABORT cannot be set on a TCP-style socket. */
1655 } !! 1745 if (sctp_style(sk, TCP) && (sinfo_flags & (SCTP_EOF | SCTP_ABORT))) {
>> 1746 err = -EINVAL;
>> 1747 goto out_nounlock;
>> 1748 }
1656 1749
1657 static int sctp_sendmsg_new_asoc(struct sock !! 1750 /* If SCTP_EOF is set, no data can be sent. Disallow sending zero
1658 struct sctp_ !! 1751 * length messages when SCTP_EOF|SCTP_ABORT is not set.
1659 union sctp_a !! 1752 * If SCTP_ABORT is set, the message length could be non zero with
1660 struct sctp_ !! 1753 * the msg_iov set to the user abort reason.
1661 { !! 1754 */
1662 struct sctp_endpoint *ep = sctp_sk(sk !! 1755 if (((sinfo_flags & SCTP_EOF) && (msg_len > 0)) ||
1663 struct sctp_association *asoc; !! 1756 (!(sinfo_flags & (SCTP_EOF|SCTP_ABORT)) && (msg_len == 0))) {
1664 struct cmsghdr *cmsg; !! 1757 err = -EINVAL;
1665 __be32 flowinfo = 0; !! 1758 goto out_nounlock;
1666 struct sctp_af *af; !! 1759 }
1667 int err; <<
1668 1760
1669 *tp = NULL; !! 1761 /* If SCTP_ADDR_OVER is set, there must be an address
>> 1762 * specified in msg_name.
>> 1763 */
>> 1764 if ((sinfo_flags & SCTP_ADDR_OVER) && (!msg->msg_name)) {
>> 1765 err = -EINVAL;
>> 1766 goto out_nounlock;
>> 1767 }
1670 1768
1671 if (sflags & (SCTP_EOF | SCTP_ABORT)) !! 1769 transport = NULL;
1672 return -EINVAL; <<
1673 1770
1674 if (sctp_style(sk, TCP) && (sctp_ssta !! 1771 pr_debug("%s: about to look up association\n", __func__);
1675 sctp_ssta <<
1676 return -EADDRNOTAVAIL; <<
1677 1772
1678 /* Label connection socket for first !! 1773 lock_sock(sk);
1679 * style for client sequence socket() <<
1680 * needs to be done before sctp_assoc <<
1681 * set up the initial packet that nee <<
1682 * security ip options (CIPSO/CALIPSO <<
1683 */ <<
1684 af = sctp_get_af_specific(daddr->sa.s <<
1685 if (!af) <<
1686 return -EINVAL; <<
1687 err = security_sctp_bind_connect(sk, <<
1688 (str <<
1689 af-> <<
1690 if (err < 0) <<
1691 return err; <<
1692 1774
1693 err = sctp_connect_new_asoc(ep, daddr !! 1775 /* If a msg_name has been specified, assume this is to be used. */
1694 if (err) !! 1776 if (msg_name) {
1695 return err; !! 1777 /* Look for a matching association on the endpoint. */
1696 asoc = (*tp)->asoc; !! 1778 asoc = sctp_endpoint_lookup_assoc(ep, &to, &transport);
>> 1779
>> 1780 /* If we could not find a matching association on the
>> 1781 * endpoint, make sure that it is not a TCP-style
>> 1782 * socket that already has an association or there is
>> 1783 * no peeled-off association on another socket.
>> 1784 */
>> 1785 if (!asoc &&
>> 1786 ((sctp_style(sk, TCP) &&
>> 1787 (sctp_sstate(sk, ESTABLISHED) ||
>> 1788 sctp_sstate(sk, CLOSING))) ||
>> 1789 sctp_endpoint_is_peeled_off(ep, &to))) {
>> 1790 err = -EADDRNOTAVAIL;
>> 1791 goto out_unlock;
>> 1792 }
>> 1793 } else {
>> 1794 asoc = sctp_id2assoc(sk, associd);
>> 1795 if (!asoc) {
>> 1796 err = -EPIPE;
>> 1797 goto out_unlock;
>> 1798 }
>> 1799 }
1697 1800
1698 if (!cmsgs->addrs_msg) !! 1801 if (asoc) {
1699 return 0; !! 1802 pr_debug("%s: just looked up association:%p\n", __func__, asoc);
1700 1803
1701 if (daddr->sa.sa_family == AF_INET6) !! 1804 /* We cannot send a message on a TCP-style SCTP_SS_ESTABLISHED
1702 flowinfo = daddr->v6.sin6_flo !! 1805 * socket that has an association in CLOSED state. This can
>> 1806 * happen when an accepted socket has an association that is
>> 1807 * already CLOSED.
>> 1808 */
>> 1809 if (sctp_state(asoc, CLOSED) && sctp_style(sk, TCP)) {
>> 1810 err = -EPIPE;
>> 1811 goto out_unlock;
>> 1812 }
1703 1813
1704 /* sendv addr list parse */ !! 1814 if (sinfo_flags & SCTP_EOF) {
1705 for_each_cmsghdr(cmsg, cmsgs->addrs_m !! 1815 pr_debug("%s: shutting down association:%p\n",
1706 union sctp_addr _daddr; !! 1816 __func__, asoc);
1707 int dlen; <<
1708 <<
1709 if (cmsg->cmsg_level != IPPRO <<
1710 (cmsg->cmsg_type != SCTP_ <<
1711 cmsg->cmsg_type != SCTP_ <<
1712 continue; <<
1713 1817
1714 daddr = &_daddr; !! 1818 sctp_primitive_SHUTDOWN(net, asoc, NULL);
1715 memset(daddr, 0, sizeof(*dadd !! 1819 err = 0;
1716 dlen = cmsg->cmsg_len - sizeo !! 1820 goto out_unlock;
1717 if (cmsg->cmsg_type == SCTP_D !! 1821 }
1718 if (dlen < sizeof(str !! 1822 if (sinfo_flags & SCTP_ABORT) {
1719 err = -EINVAL <<
1720 goto free; <<
1721 } <<
1722 1823
1723 dlen = sizeof(struct !! 1824 chunk = sctp_make_abort_user(asoc, msg, msg_len);
1724 daddr->v4.sin_family !! 1825 if (!chunk) {
1725 daddr->v4.sin_port = !! 1826 err = -ENOMEM;
1726 memcpy(&daddr->v4.sin !! 1827 goto out_unlock;
1727 } else { <<
1728 if (dlen < sizeof(str <<
1729 err = -EINVAL <<
1730 goto free; <<
1731 } 1828 }
1732 1829
1733 dlen = sizeof(struct !! 1830 pr_debug("%s: aborting association:%p\n",
1734 daddr->v6.sin6_flowin !! 1831 __func__, asoc);
1735 daddr->v6.sin6_family <<
1736 daddr->v6.sin6_port = <<
1737 memcpy(&daddr->v6.sin <<
1738 } <<
1739 1832
1740 err = sctp_connect_add_peer(a !! 1833 sctp_primitive_ABORT(net, asoc, chunk);
1741 if (err) !! 1834 err = 0;
1742 goto free; !! 1835 goto out_unlock;
>> 1836 }
1743 } 1837 }
1744 1838
1745 return 0; !! 1839 /* Do we need to create the association? */
>> 1840 if (!asoc) {
>> 1841 pr_debug("%s: there is no association yet\n", __func__);
1746 1842
1747 free: !! 1843 if (sinfo_flags & (SCTP_EOF | SCTP_ABORT)) {
1748 sctp_association_free(asoc); !! 1844 err = -EINVAL;
1749 return err; !! 1845 goto out_unlock;
1750 } !! 1846 }
1751 1847
1752 static int sctp_sendmsg_check_sflags(struct s !! 1848 /* Check for invalid stream against the stream counts,
1753 __u16 sf !! 1849 * either the default or the user specified stream counts.
1754 size_t m !! 1850 */
1755 { !! 1851 if (sinfo) {
1756 struct sock *sk = asoc->base.sk; !! 1852 if (!sinit || !sinit->sinit_num_ostreams) {
1757 struct net *net = sock_net(sk); !! 1853 /* Check against the defaults. */
>> 1854 if (sinfo->sinfo_stream >=
>> 1855 sp->initmsg.sinit_num_ostreams) {
>> 1856 err = -EINVAL;
>> 1857 goto out_unlock;
>> 1858 }
>> 1859 } else {
>> 1860 /* Check against the requested. */
>> 1861 if (sinfo->sinfo_stream >=
>> 1862 sinit->sinit_num_ostreams) {
>> 1863 err = -EINVAL;
>> 1864 goto out_unlock;
>> 1865 }
>> 1866 }
>> 1867 }
1758 1868
1759 if (sctp_state(asoc, CLOSED) && sctp_ !! 1869 /*
1760 return -EPIPE; !! 1870 * API 3.1.2 bind() - UDP Style Syntax
>> 1871 * If a bind() or sctp_bindx() is not called prior to a
>> 1872 * sendmsg() call that initiates a new association, the
>> 1873 * system picks an ephemeral port and will choose an address
>> 1874 * set equivalent to binding with a wildcard address.
>> 1875 */
>> 1876 if (!ep->base.bind_addr.port) {
>> 1877 if (sctp_autobind(sk)) {
>> 1878 err = -EAGAIN;
>> 1879 goto out_unlock;
>> 1880 }
>> 1881 } else {
>> 1882 /*
>> 1883 * If an unprivileged user inherits a one-to-many
>> 1884 * style socket with open associations on a privileged
>> 1885 * port, it MAY be permitted to accept new associations,
>> 1886 * but it SHOULD NOT be permitted to open new
>> 1887 * associations.
>> 1888 */
>> 1889 if (ep->base.bind_addr.port < inet_prot_sock(net) &&
>> 1890 !ns_capable(net->user_ns, CAP_NET_BIND_SERVICE)) {
>> 1891 err = -EACCES;
>> 1892 goto out_unlock;
>> 1893 }
>> 1894 }
1761 1895
1762 if ((sflags & SCTP_SENDALL) && sctp_s !! 1896 scope = sctp_scope(&to);
1763 !sctp_state(asoc, ESTABLISHED)) !! 1897 new_asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);
1764 return 0; !! 1898 if (!new_asoc) {
>> 1899 err = -ENOMEM;
>> 1900 goto out_unlock;
>> 1901 }
>> 1902 asoc = new_asoc;
>> 1903 err = sctp_assoc_set_bind_addr_from_ep(asoc, scope, GFP_KERNEL);
>> 1904 if (err < 0) {
>> 1905 err = -ENOMEM;
>> 1906 goto out_free;
>> 1907 }
1765 1908
1766 if (sflags & SCTP_EOF) { !! 1909 /* If the SCTP_INIT ancillary data is specified, set all
1767 pr_debug("%s: shutting down a !! 1910 * the association init values accordingly.
1768 sctp_primitive_SHUTDOWN(net, !! 1911 */
>> 1912 if (sinit) {
>> 1913 if (sinit->sinit_num_ostreams) {
>> 1914 __u16 outcnt = sinit->sinit_num_ostreams;
>> 1915
>> 1916 asoc->c.sinit_num_ostreams = outcnt;
>> 1917 /* outcnt has been changed, so re-init stream */
>> 1918 err = sctp_stream_init(&asoc->stream, outcnt, 0,
>> 1919 GFP_KERNEL);
>> 1920 if (err)
>> 1921 goto out_free;
>> 1922 }
>> 1923 if (sinit->sinit_max_instreams) {
>> 1924 asoc->c.sinit_max_instreams =
>> 1925 sinit->sinit_max_instreams;
>> 1926 }
>> 1927 if (sinit->sinit_max_attempts) {
>> 1928 asoc->max_init_attempts
>> 1929 = sinit->sinit_max_attempts;
>> 1930 }
>> 1931 if (sinit->sinit_max_init_timeo) {
>> 1932 asoc->max_init_timeo =
>> 1933 msecs_to_jiffies(sinit->sinit_max_init_timeo);
>> 1934 }
>> 1935 }
1769 1936
1770 return 0; !! 1937 /* Prime the peer's transport structures. */
>> 1938 transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL, SCTP_UNKNOWN);
>> 1939 if (!transport) {
>> 1940 err = -ENOMEM;
>> 1941 goto out_free;
>> 1942 }
1771 } 1943 }
1772 1944
1773 if (sflags & SCTP_ABORT) { !! 1945 /* ASSERT: we have a valid association at this point. */
1774 struct sctp_chunk *chunk; !! 1946 pr_debug("%s: we have a valid association\n", __func__);
1775 <<
1776 chunk = sctp_make_abort_user( <<
1777 if (!chunk) <<
1778 return -ENOMEM; <<
1779 <<
1780 pr_debug("%s: aborting associ <<
1781 sctp_primitive_ABORT(net, aso <<
1782 iov_iter_revert(&msg->msg_ite <<
1783 1947
1784 return 0; !! 1948 if (!sinfo) {
>> 1949 /* If the user didn't specify SNDINFO/SNDRCVINFO, make up
>> 1950 * one with some defaults.
>> 1951 */
>> 1952 memset(&default_sinfo, 0, sizeof(default_sinfo));
>> 1953 default_sinfo.sinfo_stream = asoc->default_stream;
>> 1954 default_sinfo.sinfo_flags = asoc->default_flags;
>> 1955 default_sinfo.sinfo_ppid = asoc->default_ppid;
>> 1956 default_sinfo.sinfo_context = asoc->default_context;
>> 1957 default_sinfo.sinfo_timetolive = asoc->default_timetolive;
>> 1958 default_sinfo.sinfo_assoc_id = sctp_assoc2id(asoc);
>> 1959
>> 1960 sinfo = &default_sinfo;
>> 1961 } else if (fill_sinfo_ttl) {
>> 1962 /* In case SNDINFO was specified, we still need to fill
>> 1963 * it with a default ttl from the assoc here.
>> 1964 */
>> 1965 sinfo->sinfo_timetolive = asoc->default_timetolive;
1785 } 1966 }
1786 1967
1787 return 1; !! 1968 /* API 7.1.7, the sndbuf size per association bounds the
1788 } !! 1969 * maximum size of data that can be sent in a single send call.
1789 !! 1970 */
1790 static int sctp_sendmsg_to_asoc(struct sctp_a !! 1971 if (msg_len > sk->sk_sndbuf) {
1791 struct msghdr !! 1972 err = -EMSGSIZE;
1792 struct sctp_t !! 1973 goto out_free;
1793 struct sctp_s <<
1794 { <<
1795 struct sock *sk = asoc->base.sk; <<
1796 struct sctp_sock *sp = sctp_sk(sk); <<
1797 struct net *net = sock_net(sk); <<
1798 struct sctp_datamsg *datamsg; <<
1799 bool wait_connect = false; <<
1800 struct sctp_chunk *chunk; <<
1801 long timeo; <<
1802 int err; <<
1803 <<
1804 if (sinfo->sinfo_stream >= asoc->stre <<
1805 err = -EINVAL; <<
1806 goto err; <<
1807 } 1974 }
1808 1975
1809 if (unlikely(!SCTP_SO(&asoc->stream, !! 1976 if (asoc->pmtu_pending)
1810 err = sctp_stream_init_ext(&a !! 1977 sctp_assoc_pending_pmtu(asoc);
1811 if (err) <<
1812 goto err; <<
1813 } <<
1814 1978
1815 if (sp->disable_fragments && msg_len !! 1979 /* If fragmentation is disabled and the message length exceeds the
>> 1980 * association fragmentation point, return EMSGSIZE. The I-D
>> 1981 * does not specify what this error is, but this looks like
>> 1982 * a great fit.
>> 1983 */
>> 1984 if (sctp_sk(sk)->disable_fragments && (msg_len > asoc->frag_point)) {
1816 err = -EMSGSIZE; 1985 err = -EMSGSIZE;
1817 goto err; !! 1986 goto out_free;
1818 } 1987 }
1819 1988
1820 if (asoc->pmtu_pending) { !! 1989 /* Check for invalid stream. */
1821 if (sp->param_flags & SPP_PMT !! 1990 if (sinfo->sinfo_stream >= asoc->stream.outcnt) {
1822 sctp_assoc_sync_pmtu( !! 1991 err = -EINVAL;
1823 asoc->pmtu_pending = 0; !! 1992 goto out_free;
1824 } 1993 }
1825 1994
1826 if (sctp_wspace(asoc) < (int)msg_len) !! 1995 if (sctp_wspace(asoc) < msg_len)
1827 sctp_prsctp_prune(asoc, sinfo 1996 sctp_prsctp_prune(asoc, sinfo, msg_len - sctp_wspace(asoc));
1828 1997
1829 if (sctp_wspace(asoc) <= 0 || !sk_wme !! 1998 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1830 timeo = sock_sndtimeo(sk, msg !! 1999 if (!sctp_wspace(asoc)) {
>> 2000 /* sk can be changed by peel off when waiting for buf. */
1831 err = sctp_wait_for_sndbuf(as 2001 err = sctp_wait_for_sndbuf(asoc, &timeo, msg_len);
1832 if (err) !! 2002 if (err) {
1833 goto err; !! 2003 if (err == -ESRCH) {
1834 if (unlikely(sinfo->sinfo_str !! 2004 /* asoc is already dead. */
1835 err = -EINVAL; !! 2005 new_asoc = NULL;
1836 goto err; !! 2006 err = -EPIPE;
>> 2007 }
>> 2008 goto out_free;
1837 } 2009 }
1838 } 2010 }
1839 2011
>> 2012 /* If an address is passed with the sendto/sendmsg call, it is used
>> 2013 * to override the primary destination address in the TCP model, or
>> 2014 * when SCTP_ADDR_OVER flag is set in the UDP model.
>> 2015 */
>> 2016 if ((sctp_style(sk, TCP) && msg_name) ||
>> 2017 (sinfo_flags & SCTP_ADDR_OVER)) {
>> 2018 chunk_tp = sctp_assoc_lookup_paddr(asoc, &to);
>> 2019 if (!chunk_tp) {
>> 2020 err = -EINVAL;
>> 2021 goto out_free;
>> 2022 }
>> 2023 } else
>> 2024 chunk_tp = NULL;
>> 2025
>> 2026 /* Auto-connect, if we aren't connected already. */
1840 if (sctp_state(asoc, CLOSED)) { 2027 if (sctp_state(asoc, CLOSED)) {
1841 err = sctp_primitive_ASSOCIAT 2028 err = sctp_primitive_ASSOCIATE(net, asoc, NULL);
1842 if (err) !! 2029 if (err < 0)
1843 goto err; !! 2030 goto out_free;
1844 <<
1845 if (asoc->ep->intl_enable) { <<
1846 timeo = sock_sndtimeo <<
1847 err = sctp_wait_for_c <<
1848 if (err) { <<
1849 err = -ESRCH; <<
1850 goto err; <<
1851 } <<
1852 } else { <<
1853 wait_connect = true; <<
1854 } <<
1855 2031
>> 2032 wait_connect = true;
1856 pr_debug("%s: we associated p 2033 pr_debug("%s: we associated primitively\n", __func__);
1857 } 2034 }
1858 2035
>> 2036 /* Break the message into multiple chunks of maximum size. */
1859 datamsg = sctp_datamsg_from_user(asoc 2037 datamsg = sctp_datamsg_from_user(asoc, sinfo, &msg->msg_iter);
1860 if (IS_ERR(datamsg)) { 2038 if (IS_ERR(datamsg)) {
1861 err = PTR_ERR(datamsg); 2039 err = PTR_ERR(datamsg);
1862 goto err; !! 2040 goto out_free;
1863 } 2041 }
1864 <<
1865 asoc->force_delay = !!(msg->msg_flags 2042 asoc->force_delay = !!(msg->msg_flags & MSG_MORE);
1866 2043
>> 2044 /* Now send the (possibly) fragmented message. */
1867 list_for_each_entry(chunk, &datamsg-> 2045 list_for_each_entry(chunk, &datamsg->chunks, frag_list) {
1868 sctp_chunk_hold(chunk); 2046 sctp_chunk_hold(chunk);
>> 2047
>> 2048 /* Do accounting for the write space. */
1869 sctp_set_owner_w(chunk); 2049 sctp_set_owner_w(chunk);
1870 chunk->transport = transport; !! 2050
>> 2051 chunk->transport = chunk_tp;
1871 } 2052 }
1872 2053
>> 2054 /* Send it to the lower layers. Note: all chunks
>> 2055 * must either fail or succeed. The lower layer
>> 2056 * works that way today. Keep it that way or this
>> 2057 * breaks.
>> 2058 */
1873 err = sctp_primitive_SEND(net, asoc, 2059 err = sctp_primitive_SEND(net, asoc, datamsg);
>> 2060 /* Did the lower layer accept the chunk? */
1874 if (err) { 2061 if (err) {
1875 sctp_datamsg_free(datamsg); 2062 sctp_datamsg_free(datamsg);
1876 goto err; !! 2063 goto out_free;
1877 } 2064 }
1878 2065
1879 pr_debug("%s: we sent primitively\n", 2066 pr_debug("%s: we sent primitively\n", __func__);
1880 2067
1881 sctp_datamsg_put(datamsg); 2068 sctp_datamsg_put(datamsg);
>> 2069 err = msg_len;
1882 2070
1883 if (unlikely(wait_connect)) { 2071 if (unlikely(wait_connect)) {
1884 timeo = sock_sndtimeo(sk, msg !! 2072 timeo = sock_sndtimeo(sk, msg_flags & MSG_DONTWAIT);
1885 sctp_wait_for_connect(asoc, & 2073 sctp_wait_for_connect(asoc, &timeo);
1886 } 2074 }
1887 2075
1888 err = msg_len; !! 2076 /* If we are already past ASSOCIATE, the lower
1889 !! 2077 * layers are responsible for association cleanup.
1890 err: !! 2078 */
1891 return err; !! 2079 goto out_unlock;
1892 } <<
1893 <<
1894 static union sctp_addr *sctp_sendmsg_get_dadd <<
1895 <<
1896 <<
1897 { <<
1898 union sctp_addr *daddr = NULL; <<
1899 int err; <<
1900 <<
1901 if (!sctp_style(sk, UDP_HIGH_BANDWIDT <<
1902 int len = msg->msg_namelen; <<
1903 <<
1904 if (len > sizeof(*daddr)) <<
1905 len = sizeof(*daddr); <<
1906 <<
1907 daddr = (union sctp_addr *)ms <<
1908 <<
1909 err = sctp_verify_addr(sk, da <<
1910 if (err) <<
1911 return ERR_PTR(err); <<
1912 } <<
1913 <<
1914 return daddr; <<
1915 } <<
1916 <<
1917 static void sctp_sendmsg_update_sinfo(struct <<
1918 struct <<
1919 struct <<
1920 { <<
1921 if (!cmsgs->srinfo && !cmsgs->sinfo) <<
1922 sinfo->sinfo_stream = asoc->d <<
1923 sinfo->sinfo_ppid = asoc->def <<
1924 sinfo->sinfo_context = asoc-> <<
1925 sinfo->sinfo_assoc_id = sctp_ <<
1926 <<
1927 if (!cmsgs->prinfo) <<
1928 sinfo->sinfo_flags = <<
1929 } <<
1930 <<
1931 if (!cmsgs->srinfo && !cmsgs->prinfo) <<
1932 sinfo->sinfo_timetolive = aso <<
1933 <<
1934 if (cmsgs->authinfo) { <<
1935 /* Reuse sinfo_tsn to indicat <<
1936 * sinfo_ssn to save the keyi <<
1937 */ <<
1938 sinfo->sinfo_tsn = 1; <<
1939 sinfo->sinfo_ssn = cmsgs->aut <<
1940 } <<
1941 } <<
1942 <<
1943 static int sctp_sendmsg(struct sock *sk, stru <<
1944 { <<
1945 struct sctp_endpoint *ep = sctp_sk(sk <<
1946 struct sctp_transport *transport = NU <<
1947 struct sctp_sndrcvinfo _sinfo, *sinfo <<
1948 struct sctp_association *asoc, *tmp; <<
1949 struct sctp_cmsgs cmsgs; <<
1950 union sctp_addr *daddr; <<
1951 bool new = false; <<
1952 __u16 sflags; <<
1953 int err; <<
1954 <<
1955 /* Parse and get snd_info */ <<
1956 err = sctp_sendmsg_parse(sk, &cmsgs, <<
1957 if (err) <<
1958 goto out; <<
1959 <<
1960 sinfo = &_sinfo; <<
1961 sflags = sinfo->sinfo_flags; <<
1962 <<
1963 /* Get daddr from msg */ <<
1964 daddr = sctp_sendmsg_get_daddr(sk, ms <<
1965 if (IS_ERR(daddr)) { <<
1966 err = PTR_ERR(daddr); <<
1967 goto out; <<
1968 } <<
1969 <<
1970 lock_sock(sk); <<
1971 <<
1972 /* SCTP_SENDALL process */ <<
1973 if ((sflags & SCTP_SENDALL) && sctp_s <<
1974 list_for_each_entry_safe(asoc <<
1975 err = sctp_sendmsg_ch <<
1976 <<
1977 if (err == 0) <<
1978 continue; <<
1979 if (err < 0) <<
1980 goto out_unlo <<
1981 <<
1982 sctp_sendmsg_update_s <<
1983 <<
1984 err = sctp_sendmsg_to <<
1985 <<
1986 if (err < 0) <<
1987 goto out_unlo <<
1988 <<
1989 iov_iter_revert(&msg- <<
1990 } <<
1991 <<
1992 goto out_unlock; <<
1993 } <<
1994 <<
1995 /* Get and check or create asoc */ <<
1996 if (daddr) { <<
1997 asoc = sctp_endpoint_lookup_a <<
1998 if (asoc) { <<
1999 err = sctp_sendmsg_ch <<
2000 <<
2001 if (err <= 0) <<
2002 goto out_unlo <<
2003 } else { <<
2004 err = sctp_sendmsg_ne <<
2005 <<
2006 if (err) <<
2007 goto out_unlo <<
2008 <<
2009 asoc = transport->aso <<
2010 new = true; <<
2011 } <<
2012 <<
2013 if (!sctp_style(sk, TCP) && ! <<
2014 transport = NULL; <<
2015 } else { <<
2016 asoc = sctp_id2assoc(sk, sinf <<
2017 if (!asoc) { <<
2018 err = -EPIPE; <<
2019 goto out_unlock; <<
2020 } <<
2021 <<
2022 err = sctp_sendmsg_check_sfla <<
2023 if (err <= 0) <<
2024 goto out_unlock; <<
2025 } <<
2026 <<
2027 /* Update snd_info with the asoc */ <<
2028 sctp_sendmsg_update_sinfo(asoc, sinfo <<
2029 2080
2030 /* Send msg to the asoc */ !! 2081 out_free:
2031 err = sctp_sendmsg_to_asoc(asoc, msg, !! 2082 if (new_asoc)
2032 if (err < 0 && err != -ESRCH && new) <<
2033 sctp_association_free(asoc); 2083 sctp_association_free(asoc);
2034 <<
2035 out_unlock: 2084 out_unlock:
2036 release_sock(sk); 2085 release_sock(sk);
2037 out: !! 2086
2038 return sctp_error(sk, msg->msg_flags, !! 2087 out_nounlock:
>> 2088 return sctp_error(sk, msg_flags, err);
>> 2089
>> 2090 #if 0
>> 2091 do_sock_err:
>> 2092 if (msg_len)
>> 2093 err = msg_len;
>> 2094 else
>> 2095 err = sock_error(sk);
>> 2096 goto out;
>> 2097
>> 2098 do_interrupted:
>> 2099 if (msg_len)
>> 2100 err = msg_len;
>> 2101 goto out;
>> 2102 #endif /* 0 */
2039 } 2103 }
2040 2104
2041 /* This is an extended version of skb_pull() 2105 /* This is an extended version of skb_pull() that removes the data from the
2042 * start of a skb even when data is spread ac 2106 * start of a skb even when data is spread across the list of skb's in the
2043 * frag_list. len specifies the total amount 2107 * frag_list. len specifies the total amount of data that needs to be removed.
2044 * when 'len' bytes could be removed from the 2108 * when 'len' bytes could be removed from the skb, it returns 0.
2045 * If 'len' exceeds the total skb length, it 2109 * If 'len' exceeds the total skb length, it returns the no. of bytes that
2046 * could not be removed. 2110 * could not be removed.
2047 */ 2111 */
2048 static int sctp_skb_pull(struct sk_buff *skb, 2112 static int sctp_skb_pull(struct sk_buff *skb, int len)
2049 { 2113 {
2050 struct sk_buff *list; 2114 struct sk_buff *list;
2051 int skb_len = skb_headlen(skb); 2115 int skb_len = skb_headlen(skb);
2052 int rlen; 2116 int rlen;
2053 2117
2054 if (len <= skb_len) { 2118 if (len <= skb_len) {
2055 __skb_pull(skb, len); 2119 __skb_pull(skb, len);
2056 return 0; 2120 return 0;
2057 } 2121 }
2058 len -= skb_len; 2122 len -= skb_len;
2059 __skb_pull(skb, skb_len); 2123 __skb_pull(skb, skb_len);
2060 2124
2061 skb_walk_frags(skb, list) { 2125 skb_walk_frags(skb, list) {
2062 rlen = sctp_skb_pull(list, le 2126 rlen = sctp_skb_pull(list, len);
2063 skb->len -= (len-rlen); 2127 skb->len -= (len-rlen);
2064 skb->data_len -= (len-rlen); 2128 skb->data_len -= (len-rlen);
2065 2129
2066 if (!rlen) 2130 if (!rlen)
2067 return 0; 2131 return 0;
2068 2132
2069 len = rlen; 2133 len = rlen;
2070 } 2134 }
2071 2135
2072 return len; 2136 return len;
2073 } 2137 }
2074 2138
2075 /* API 3.1.3 recvmsg() - UDP Style Syntax 2139 /* API 3.1.3 recvmsg() - UDP Style Syntax
2076 * 2140 *
2077 * ssize_t recvmsg(int socket, struct msghdr 2141 * ssize_t recvmsg(int socket, struct msghdr *message,
2078 * int flags); 2142 * int flags);
2079 * 2143 *
2080 * socket - the socket descriptor of the en 2144 * socket - the socket descriptor of the endpoint.
2081 * message - pointer to the msghdr structure 2145 * message - pointer to the msghdr structure which contains a single
2082 * user message and possibly some 2146 * user message and possibly some ancillary data.
2083 * 2147 *
2084 * See Section 5 for complete desc 2148 * See Section 5 for complete description of the data
2085 * structures. 2149 * structures.
2086 * 2150 *
2087 * flags - flags sent or received with the 2151 * flags - flags sent or received with the user message, see Section
2088 * 5 for complete description of t 2152 * 5 for complete description of the flags.
2089 */ 2153 */
2090 static int sctp_recvmsg(struct sock *sk, stru 2154 static int sctp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
2091 int flags, int *addr_ !! 2155 int noblock, int flags, int *addr_len)
2092 { 2156 {
2093 struct sctp_ulpevent *event = NULL; 2157 struct sctp_ulpevent *event = NULL;
2094 struct sctp_sock *sp = sctp_sk(sk); 2158 struct sctp_sock *sp = sctp_sk(sk);
2095 struct sk_buff *skb, *head_skb; 2159 struct sk_buff *skb, *head_skb;
2096 int copied; 2160 int copied;
2097 int err = 0; 2161 int err = 0;
2098 int skb_len; 2162 int skb_len;
2099 2163
2100 pr_debug("%s: sk:%p, msghdr:%p, len:% !! 2164 pr_debug("%s: sk:%p, msghdr:%p, len:%zd, noblock:%d, flags:0x%x, "
2101 __func__, sk, msg, len, flag !! 2165 "addr_len:%p)\n", __func__, sk, msg, len, noblock, flags,
2102 !! 2166 addr_len);
2103 if (unlikely(flags & MSG_ERRQUEUE)) <<
2104 return inet_recv_error(sk, ms <<
2105 <<
2106 if (sk_can_busy_loop(sk) && <<
2107 skb_queue_empty_lockless(&sk->sk_ <<
2108 sk_busy_loop(sk, flags & MSG_ <<
2109 2167
2110 lock_sock(sk); 2168 lock_sock(sk);
2111 2169
2112 if (sctp_style(sk, TCP) && !sctp_ssta 2170 if (sctp_style(sk, TCP) && !sctp_sstate(sk, ESTABLISHED) &&
2113 !sctp_sstate(sk, CLOSING) && !sct 2171 !sctp_sstate(sk, CLOSING) && !sctp_sstate(sk, CLOSED)) {
2114 err = -ENOTCONN; 2172 err = -ENOTCONN;
2115 goto out; 2173 goto out;
2116 } 2174 }
2117 2175
2118 skb = sctp_skb_recv_datagram(sk, flag !! 2176 skb = sctp_skb_recv_datagram(sk, flags, noblock, &err);
2119 if (!skb) 2177 if (!skb)
2120 goto out; 2178 goto out;
2121 2179
2122 /* Get the total length of the skb in 2180 /* Get the total length of the skb including any skb's in the
2123 * frag_list. 2181 * frag_list.
2124 */ 2182 */
2125 skb_len = skb->len; 2183 skb_len = skb->len;
2126 2184
2127 copied = skb_len; 2185 copied = skb_len;
2128 if (copied > len) 2186 if (copied > len)
2129 copied = len; 2187 copied = len;
2130 2188
2131 err = skb_copy_datagram_msg(skb, 0, m 2189 err = skb_copy_datagram_msg(skb, 0, msg, copied);
2132 2190
2133 event = sctp_skb2event(skb); 2191 event = sctp_skb2event(skb);
2134 2192
2135 if (err) 2193 if (err)
2136 goto out_free; 2194 goto out_free;
2137 2195
2138 if (event->chunk && event->chunk->hea 2196 if (event->chunk && event->chunk->head_skb)
2139 head_skb = event->chunk->head 2197 head_skb = event->chunk->head_skb;
2140 else 2198 else
2141 head_skb = skb; 2199 head_skb = skb;
2142 sock_recv_cmsgs(msg, sk, head_skb); !! 2200 sock_recv_ts_and_drops(msg, sk, head_skb);
2143 if (sctp_ulpevent_is_notification(eve 2201 if (sctp_ulpevent_is_notification(event)) {
2144 msg->msg_flags |= MSG_NOTIFIC 2202 msg->msg_flags |= MSG_NOTIFICATION;
2145 sp->pf->event_msgname(event, 2203 sp->pf->event_msgname(event, msg->msg_name, addr_len);
2146 } else { 2204 } else {
2147 sp->pf->skb_msgname(head_skb, 2205 sp->pf->skb_msgname(head_skb, msg->msg_name, addr_len);
2148 } 2206 }
2149 2207
2150 /* Check if we allow SCTP_NXTINFO. */ 2208 /* Check if we allow SCTP_NXTINFO. */
2151 if (sp->recvnxtinfo) 2209 if (sp->recvnxtinfo)
2152 sctp_ulpevent_read_nxtinfo(ev 2210 sctp_ulpevent_read_nxtinfo(event, msg, sk);
2153 /* Check if we allow SCTP_RCVINFO. */ 2211 /* Check if we allow SCTP_RCVINFO. */
2154 if (sp->recvrcvinfo) 2212 if (sp->recvrcvinfo)
2155 sctp_ulpevent_read_rcvinfo(ev 2213 sctp_ulpevent_read_rcvinfo(event, msg);
2156 /* Check if we allow SCTP_SNDRCVINFO. 2214 /* Check if we allow SCTP_SNDRCVINFO. */
2157 if (sctp_ulpevent_type_enabled(sp->su !! 2215 if (sp->subscribe.sctp_data_io_event)
2158 sctp_ulpevent_read_sndrcvinfo 2216 sctp_ulpevent_read_sndrcvinfo(event, msg);
2159 2217
2160 err = copied; 2218 err = copied;
2161 2219
2162 /* If skb's length exceeds the user's 2220 /* If skb's length exceeds the user's buffer, update the skb and
2163 * push it back to the receive_queue 2221 * push it back to the receive_queue so that the next call to
2164 * recvmsg() will return the remainin 2222 * recvmsg() will return the remaining data. Don't set MSG_EOR.
2165 */ 2223 */
2166 if (skb_len > copied) { 2224 if (skb_len > copied) {
2167 msg->msg_flags &= ~MSG_EOR; 2225 msg->msg_flags &= ~MSG_EOR;
2168 if (flags & MSG_PEEK) 2226 if (flags & MSG_PEEK)
2169 goto out_free; 2227 goto out_free;
2170 sctp_skb_pull(skb, copied); 2228 sctp_skb_pull(skb, copied);
2171 skb_queue_head(&sk->sk_receiv 2229 skb_queue_head(&sk->sk_receive_queue, skb);
2172 2230
2173 /* When only partial message 2231 /* When only partial message is copied to the user, increase
2174 * rwnd by that amount. If al 2232 * rwnd by that amount. If all the data in the skb is read,
2175 * rwnd is updated when the e 2233 * rwnd is updated when the event is freed.
2176 */ 2234 */
2177 if (!sctp_ulpevent_is_notific 2235 if (!sctp_ulpevent_is_notification(event))
2178 sctp_assoc_rwnd_incre 2236 sctp_assoc_rwnd_increase(event->asoc, copied);
2179 goto out; 2237 goto out;
2180 } else if ((event->msg_flags & MSG_NO 2238 } else if ((event->msg_flags & MSG_NOTIFICATION) ||
2181 (event->msg_flags & MSG_EO 2239 (event->msg_flags & MSG_EOR))
2182 msg->msg_flags |= MSG_EOR; 2240 msg->msg_flags |= MSG_EOR;
2183 else 2241 else
2184 msg->msg_flags &= ~MSG_EOR; 2242 msg->msg_flags &= ~MSG_EOR;
2185 2243
2186 out_free: 2244 out_free:
2187 if (flags & MSG_PEEK) { 2245 if (flags & MSG_PEEK) {
2188 /* Release the skb reference 2246 /* Release the skb reference acquired after peeking the skb in
2189 * sctp_skb_recv_datagram(). 2247 * sctp_skb_recv_datagram().
2190 */ 2248 */
2191 kfree_skb(skb); 2249 kfree_skb(skb);
2192 } else { 2250 } else {
2193 /* Free the event which inclu 2251 /* Free the event which includes releasing the reference to
2194 * the owner of the skb, free 2252 * the owner of the skb, freeing the skb and updating the
2195 * rwnd. 2253 * rwnd.
2196 */ 2254 */
2197 sctp_ulpevent_free(event); 2255 sctp_ulpevent_free(event);
2198 } 2256 }
2199 out: 2257 out:
2200 release_sock(sk); 2258 release_sock(sk);
2201 return err; 2259 return err;
2202 } 2260 }
2203 2261
2204 /* 7.1.12 Enable/Disable message fragmentatio 2262 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
2205 * 2263 *
2206 * This option is a on/off flag. If enabled 2264 * This option is a on/off flag. If enabled no SCTP message
2207 * fragmentation will be performed. Instead 2265 * fragmentation will be performed. Instead if a message being sent
2208 * exceeds the current PMTU size, the message 2266 * exceeds the current PMTU size, the message will NOT be sent and
2209 * instead a error will be indicated to the u 2267 * instead a error will be indicated to the user.
2210 */ 2268 */
2211 static int sctp_setsockopt_disable_fragments( !! 2269 static int sctp_setsockopt_disable_fragments(struct sock *sk,
>> 2270 char __user *optval,
2212 2271 unsigned int optlen)
2213 { 2272 {
>> 2273 int val;
>> 2274
2214 if (optlen < sizeof(int)) 2275 if (optlen < sizeof(int))
2215 return -EINVAL; 2276 return -EINVAL;
2216 sctp_sk(sk)->disable_fragments = (*va !! 2277
>> 2278 if (get_user(val, (int __user *)optval))
>> 2279 return -EFAULT;
>> 2280
>> 2281 sctp_sk(sk)->disable_fragments = (val == 0) ? 0 : 1;
>> 2282
2217 return 0; 2283 return 0;
2218 } 2284 }
2219 2285
2220 static int sctp_setsockopt_events(struct sock !! 2286 static int sctp_setsockopt_events(struct sock *sk, char __user *optval,
2221 unsigned in 2287 unsigned int optlen)
2222 { 2288 {
2223 struct sctp_sock *sp = sctp_sk(sk); <<
2224 struct sctp_association *asoc; 2289 struct sctp_association *asoc;
2225 int i; !! 2290 struct sctp_ulpevent *event;
2226 2291
2227 if (optlen > sizeof(struct sctp_event 2292 if (optlen > sizeof(struct sctp_event_subscribe))
2228 return -EINVAL; 2293 return -EINVAL;
2229 !! 2294 if (copy_from_user(&sctp_sk(sk)->subscribe, optval, optlen))
2230 for (i = 0; i < optlen; i++) !! 2295 return -EFAULT;
2231 sctp_ulpevent_type_set(&sp->s <<
2232 sn_typ <<
2233 <<
2234 list_for_each_entry(asoc, &sp->ep->as <<
2235 asoc->subscribe = sctp_sk(sk) <<
2236 2296
2237 /* At the time when a user app subscr 2297 /* At the time when a user app subscribes to SCTP_SENDER_DRY_EVENT,
2238 * if there is no data to be sent or 2298 * if there is no data to be sent or retransmit, the stack will
2239 * immediately send up this notificat 2299 * immediately send up this notification.
2240 */ 2300 */
2241 if (sctp_ulpevent_type_enabled(sp->su !! 2301 if (sctp_ulpevent_type_enabled(SCTP_SENDER_DRY_EVENT,
2242 struct sctp_ulpevent *event; !! 2302 &sctp_sk(sk)->subscribe)) {
2243 <<
2244 asoc = sctp_id2assoc(sk, 0); 2303 asoc = sctp_id2assoc(sk, 0);
>> 2304
2245 if (asoc && sctp_outq_is_empt 2305 if (asoc && sctp_outq_is_empty(&asoc->outqueue)) {
2246 event = sctp_ulpevent 2306 event = sctp_ulpevent_make_sender_dry_event(asoc,
2247 GFP_U !! 2307 GFP_ATOMIC);
2248 if (!event) 2308 if (!event)
2249 return -ENOME 2309 return -ENOMEM;
2250 2310
2251 asoc->stream.si->enqu !! 2311 sctp_ulpq_tail_event(&asoc->ulpq, event);
2252 } 2312 }
2253 } 2313 }
2254 2314
2255 return 0; 2315 return 0;
2256 } 2316 }
2257 2317
2258 /* 7.1.8 Automatic Close of associations (SCT 2318 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
2259 * 2319 *
2260 * This socket option is applicable to the UD 2320 * This socket option is applicable to the UDP-style socket only. When
2261 * set it will cause associations that are id 2321 * set it will cause associations that are idle for more than the
2262 * specified number of seconds to automatical 2322 * specified number of seconds to automatically close. An association
2263 * being idle is defined an association that 2323 * being idle is defined an association that has NOT sent or received
2264 * user data. The special value of '' indica 2324 * user data. The special value of '' indicates that no automatic
2265 * close of any associations should be perfor 2325 * close of any associations should be performed. The option expects an
2266 * integer defining the number of seconds of 2326 * integer defining the number of seconds of idle time before an
2267 * association is closed. 2327 * association is closed.
2268 */ 2328 */
2269 static int sctp_setsockopt_autoclose(struct s !! 2329 static int sctp_setsockopt_autoclose(struct sock *sk, char __user *optval,
2270 unsigned 2330 unsigned int optlen)
2271 { 2331 {
2272 struct sctp_sock *sp = sctp_sk(sk); 2332 struct sctp_sock *sp = sctp_sk(sk);
2273 struct net *net = sock_net(sk); 2333 struct net *net = sock_net(sk);
2274 2334
2275 /* Applicable to UDP-style socket onl 2335 /* Applicable to UDP-style socket only */
2276 if (sctp_style(sk, TCP)) 2336 if (sctp_style(sk, TCP))
2277 return -EOPNOTSUPP; 2337 return -EOPNOTSUPP;
2278 if (optlen != sizeof(int)) 2338 if (optlen != sizeof(int))
2279 return -EINVAL; 2339 return -EINVAL;
>> 2340 if (copy_from_user(&sp->autoclose, optval, optlen))
>> 2341 return -EFAULT;
2280 2342
2281 sp->autoclose = *optval; <<
2282 if (sp->autoclose > net->sctp.max_aut 2343 if (sp->autoclose > net->sctp.max_autoclose)
2283 sp->autoclose = net->sctp.max 2344 sp->autoclose = net->sctp.max_autoclose;
2284 2345
2285 return 0; 2346 return 0;
2286 } 2347 }
2287 2348
2288 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ 2349 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
2289 * 2350 *
2290 * Applications can enable or disable heartbe 2351 * Applications can enable or disable heartbeats for any peer address of
2291 * an association, modify an address's heartb 2352 * an association, modify an address's heartbeat interval, force a
2292 * heartbeat to be sent immediately, and adju 2353 * heartbeat to be sent immediately, and adjust the address's maximum
2293 * number of retransmissions sent before an a 2354 * number of retransmissions sent before an address is considered
2294 * unreachable. The following structure is u 2355 * unreachable. The following structure is used to access and modify an
2295 * address's parameters: 2356 * address's parameters:
2296 * 2357 *
2297 * struct sctp_paddrparams { 2358 * struct sctp_paddrparams {
2298 * sctp_assoc_t spp_assoc_id; 2359 * sctp_assoc_t spp_assoc_id;
2299 * struct sockaddr_storage spp_address; 2360 * struct sockaddr_storage spp_address;
2300 * uint32_t spp_hbinterval 2361 * uint32_t spp_hbinterval;
2301 * uint16_t spp_pathmaxrxt 2362 * uint16_t spp_pathmaxrxt;
2302 * uint32_t spp_pathmtu; 2363 * uint32_t spp_pathmtu;
2303 * uint32_t spp_sackdelay; 2364 * uint32_t spp_sackdelay;
2304 * uint32_t spp_flags; 2365 * uint32_t spp_flags;
2305 * uint32_t spp_ipv6_flowl <<
2306 * uint8_t spp_dscp; <<
2307 * }; 2366 * };
2308 * 2367 *
2309 * spp_assoc_id - (one-to-many style soc 2368 * spp_assoc_id - (one-to-many style socket) This is filled in the
2310 * application, and ident 2369 * application, and identifies the association for
2311 * this query. 2370 * this query.
2312 * spp_address - This specifies which a 2371 * spp_address - This specifies which address is of interest.
2313 * spp_hbinterval - This contains the valu 2372 * spp_hbinterval - This contains the value of the heartbeat interval,
2314 * in milliseconds. If a 2373 * in milliseconds. If a value of zero
2315 * is present in this fie 2374 * is present in this field then no changes are to
2316 * be made to this parame 2375 * be made to this parameter.
2317 * spp_pathmaxrxt - This contains the maxi 2376 * spp_pathmaxrxt - This contains the maximum number of
2318 * retransmissions before 2377 * retransmissions before this address shall be
2319 * considered unreachable 2378 * considered unreachable. If a value of zero
2320 * is present in this fie 2379 * is present in this field then no changes are to
2321 * be made to this parame 2380 * be made to this parameter.
2322 * spp_pathmtu - When Path MTU discover 2381 * spp_pathmtu - When Path MTU discovery is disabled the value
2323 * specified here will be 2382 * specified here will be the "fixed" path mtu.
2324 * Note that if the spp_a 2383 * Note that if the spp_address field is empty
2325 * then all associations 2384 * then all associations on this address will
2326 * have this fixed path m 2385 * have this fixed path mtu set upon them.
2327 * 2386 *
2328 * spp_sackdelay - When delayed sack is e 2387 * spp_sackdelay - When delayed sack is enabled, this value specifies
2329 * the number of millisec 2388 * the number of milliseconds that sacks will be delayed
2330 * for. This value will a 2389 * for. This value will apply to all addresses of an
2331 * association if the spp 2390 * association if the spp_address field is empty. Note
2332 * also, that if delayed 2391 * also, that if delayed sack is enabled and this
2333 * value is set to 0, no 2392 * value is set to 0, no change is made to the last
2334 * recorded delayed sack 2393 * recorded delayed sack timer value.
2335 * 2394 *
2336 * spp_flags - These flags are used t 2395 * spp_flags - These flags are used to control various features
2337 * on an association. The 2396 * on an association. The flag field may contain
2338 * zero or more of the fo 2397 * zero or more of the following options.
2339 * 2398 *
2340 * SPP_HB_ENABLE - Enabl 2399 * SPP_HB_ENABLE - Enable heartbeats on the
2341 * specified address. Not 2400 * specified address. Note that if the address
2342 * field is empty all add 2401 * field is empty all addresses for the association
2343 * have heartbeats enable 2402 * have heartbeats enabled upon them.
2344 * 2403 *
2345 * SPP_HB_DISABLE - Disab 2404 * SPP_HB_DISABLE - Disable heartbeats on the
2346 * speicifed address. Not 2405 * speicifed address. Note that if the address
2347 * field is empty all add 2406 * field is empty all addresses for the association
2348 * will have their heartb 2407 * will have their heartbeats disabled. Note also
2349 * that SPP_HB_ENABLE and 2408 * that SPP_HB_ENABLE and SPP_HB_DISABLE are
2350 * mutually exclusive, on 2409 * mutually exclusive, only one of these two should
2351 * be specified. Enabling 2410 * be specified. Enabling both fields will have
2352 * undetermined results. 2411 * undetermined results.
2353 * 2412 *
2354 * SPP_HB_DEMAND - Reques 2413 * SPP_HB_DEMAND - Request a user initiated heartbeat
2355 * to be made immediately 2414 * to be made immediately.
2356 * 2415 *
2357 * SPP_HB_TIME_IS_ZERO - 2416 * SPP_HB_TIME_IS_ZERO - Specify's that the time for
2358 * heartbeat delayis to b 2417 * heartbeat delayis to be set to the value of 0
2359 * milliseconds. 2418 * milliseconds.
2360 * 2419 *
2361 * SPP_PMTUD_ENABLE - Thi 2420 * SPP_PMTUD_ENABLE - This field will enable PMTU
2362 * discovery upon the spe 2421 * discovery upon the specified address. Note that
2363 * if the address feild i 2422 * if the address feild is empty then all addresses
2364 * on the association are 2423 * on the association are effected.
2365 * 2424 *
2366 * SPP_PMTUD_DISABLE - Th 2425 * SPP_PMTUD_DISABLE - This field will disable PMTU
2367 * discovery upon the spe 2426 * discovery upon the specified address. Note that
2368 * if the address feild i 2427 * if the address feild is empty then all addresses
2369 * on the association are 2428 * on the association are effected. Not also that
2370 * SPP_PMTUD_ENABLE and S 2429 * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
2371 * exclusive. Enabling bo 2430 * exclusive. Enabling both will have undetermined
2372 * results. 2431 * results.
2373 * 2432 *
2374 * SPP_SACKDELAY_ENABLE - 2433 * SPP_SACKDELAY_ENABLE - Setting this flag turns
2375 * on delayed sack. The t 2434 * on delayed sack. The time specified in spp_sackdelay
2376 * is used to specify the 2435 * is used to specify the sack delay for this address. Note
2377 * that if spp_address is 2436 * that if spp_address is empty then all addresses will
2378 * enable delayed sack an 2437 * enable delayed sack and take on the sack delay
2379 * value specified in spp 2438 * value specified in spp_sackdelay.
2380 * SPP_SACKDELAY_DISABLE 2439 * SPP_SACKDELAY_DISABLE - Setting this flag turns
2381 * off delayed sack. If t 2440 * off delayed sack. If the spp_address field is blank then
2382 * delayed sack is disabl 2441 * delayed sack is disabled for the entire association. Note
2383 * also that this field i 2442 * also that this field is mutually exclusive to
2384 * SPP_SACKDELAY_ENABLE, 2443 * SPP_SACKDELAY_ENABLE, setting both will have undefined
2385 * results. 2444 * results.
2386 * <<
2387 * SPP_IPV6_FLOWLABEL: S <<
2388 * setting of the IPV6 fl <<
2389 * contained in the spp_i <<
2390 * Upon retrieval, this f <<
2391 * the spp_ipv6_flowlabel <<
2392 * If a specific destinat <<
2393 * spp_address field), th <<
2394 * the address. If just <<
2395 * no address), then the <<
2396 * is returned. If neith <<
2397 * is specified, then the <<
2398 * returned. For non-IPv <<
2399 * cleared. <<
2400 * <<
2401 * SPP_DSCP: Setting thi <<
2402 * Differentiated Service <<
2403 * associated with either <<
2404 * address. The value is <<
2405 * Upon retrieval, this f <<
2406 * the spp_dscp field has <<
2407 * specific destination a <<
2408 * spp_address field), th <<
2409 * address's DSCP value i <<
2410 * is specified, then the <<
2411 * returned. If neither <<
2412 * specified, then the so <<
2413 * <<
2414 * spp_ipv6_flowlabel <<
2415 * - This field is used in <<
2416 * SPP_IPV6_FLOWLABEL fla <<
2417 * The 20 least significa <<
2418 * label. This setting h <<
2419 * setting. <<
2420 * <<
2421 * spp_dscp - This field is used in <<
2422 * and contains the DSCP. <<
2423 * used for the DSCP. Th <<
2424 * IPv4- or IPv6- layer s <<
2425 */ 2445 */
2426 static int sctp_apply_peer_addr_params(struct 2446 static int sctp_apply_peer_addr_params(struct sctp_paddrparams *params,
2427 struct 2447 struct sctp_transport *trans,
2428 struct 2448 struct sctp_association *asoc,
2429 struct 2449 struct sctp_sock *sp,
2430 int 2450 int hb_change,
2431 int 2451 int pmtud_change,
2432 int 2452 int sackdelay_change)
2433 { 2453 {
2434 int error; 2454 int error;
2435 2455
2436 if (params->spp_flags & SPP_HB_DEMAND 2456 if (params->spp_flags & SPP_HB_DEMAND && trans) {
2437 error = sctp_primitive_REQUES !! 2457 struct net *net = sock_net(trans->asoc->base.sk);
2438 !! 2458
>> 2459 error = sctp_primitive_REQUESTHEARTBEAT(net, trans->asoc, trans);
2439 if (error) 2460 if (error)
2440 return error; 2461 return error;
2441 } 2462 }
2442 2463
2443 /* Note that unless the spp_flag is s 2464 /* Note that unless the spp_flag is set to SPP_HB_ENABLE the value of
2444 * this field is ignored. Note also 2465 * this field is ignored. Note also that a value of zero indicates
2445 * the current setting should be left 2466 * the current setting should be left unchanged.
2446 */ 2467 */
2447 if (params->spp_flags & SPP_HB_ENABLE 2468 if (params->spp_flags & SPP_HB_ENABLE) {
2448 2469
2449 /* Re-zero the interval if th 2470 /* Re-zero the interval if the SPP_HB_TIME_IS_ZERO is
2450 * set. This lets us use 0 v 2471 * set. This lets us use 0 value when this flag
2451 * is set. 2472 * is set.
2452 */ 2473 */
2453 if (params->spp_flags & SPP_H 2474 if (params->spp_flags & SPP_HB_TIME_IS_ZERO)
2454 params->spp_hbinterva 2475 params->spp_hbinterval = 0;
2455 2476
2456 if (params->spp_hbinterval || 2477 if (params->spp_hbinterval ||
2457 (params->spp_flags & SPP_ 2478 (params->spp_flags & SPP_HB_TIME_IS_ZERO)) {
2458 if (trans) { 2479 if (trans) {
2459 trans->hbinte 2480 trans->hbinterval =
2460 msecs_to_ 2481 msecs_to_jiffies(params->spp_hbinterval);
2461 sctp_transpor 2482 sctp_transport_reset_hb_timer(trans);
2462 } else if (asoc) { 2483 } else if (asoc) {
2463 asoc->hbinter 2484 asoc->hbinterval =
2464 msecs_to_ 2485 msecs_to_jiffies(params->spp_hbinterval);
2465 } else { 2486 } else {
2466 sp->hbinterva 2487 sp->hbinterval = params->spp_hbinterval;
2467 } 2488 }
2468 } 2489 }
2469 } 2490 }
2470 2491
2471 if (hb_change) { 2492 if (hb_change) {
2472 if (trans) { 2493 if (trans) {
2473 trans->param_flags = 2494 trans->param_flags =
2474 (trans->param 2495 (trans->param_flags & ~SPP_HB) | hb_change;
2475 } else if (asoc) { 2496 } else if (asoc) {
2476 asoc->param_flags = 2497 asoc->param_flags =
2477 (asoc->param_ 2498 (asoc->param_flags & ~SPP_HB) | hb_change;
2478 } else { 2499 } else {
2479 sp->param_flags = 2500 sp->param_flags =
2480 (sp->param_fl 2501 (sp->param_flags & ~SPP_HB) | hb_change;
2481 } 2502 }
2482 } 2503 }
2483 2504
2484 /* When Path MTU discovery is disable 2505 /* When Path MTU discovery is disabled the value specified here will
2485 * be the "fixed" path mtu (i.e. the 2506 * be the "fixed" path mtu (i.e. the value of the spp_flags field must
2486 * include the flag SPP_PMTUD_DISABLE 2507 * include the flag SPP_PMTUD_DISABLE for this field to have any
2487 * effect). 2508 * effect).
2488 */ 2509 */
2489 if ((params->spp_flags & SPP_PMTUD_DI 2510 if ((params->spp_flags & SPP_PMTUD_DISABLE) && params->spp_pathmtu) {
2490 if (trans) { 2511 if (trans) {
2491 trans->pathmtu = para 2512 trans->pathmtu = params->spp_pathmtu;
2492 sctp_assoc_sync_pmtu( 2513 sctp_assoc_sync_pmtu(asoc);
2493 } else if (asoc) { 2514 } else if (asoc) {
2494 sctp_assoc_set_pmtu(a !! 2515 asoc->pathmtu = params->spp_pathmtu;
2495 } else { 2516 } else {
2496 sp->pathmtu = params- 2517 sp->pathmtu = params->spp_pathmtu;
2497 } 2518 }
2498 } 2519 }
2499 2520
2500 if (pmtud_change) { 2521 if (pmtud_change) {
2501 if (trans) { 2522 if (trans) {
2502 int update = (trans-> 2523 int update = (trans->param_flags & SPP_PMTUD_DISABLE) &&
2503 (params->spp_ 2524 (params->spp_flags & SPP_PMTUD_ENABLE);
2504 trans->param_flags = 2525 trans->param_flags =
2505 (trans->param 2526 (trans->param_flags & ~SPP_PMTUD) | pmtud_change;
2506 if (update) { 2527 if (update) {
2507 sctp_transpor 2528 sctp_transport_pmtu(trans, sctp_opt2sk(sp));
2508 sctp_assoc_sy 2529 sctp_assoc_sync_pmtu(asoc);
2509 } 2530 }
2510 sctp_transport_pl_res <<
2511 } else if (asoc) { 2531 } else if (asoc) {
2512 asoc->param_flags = 2532 asoc->param_flags =
2513 (asoc->param_ 2533 (asoc->param_flags & ~SPP_PMTUD) | pmtud_change;
2514 } else { 2534 } else {
2515 sp->param_flags = 2535 sp->param_flags =
2516 (sp->param_fl 2536 (sp->param_flags & ~SPP_PMTUD) | pmtud_change;
2517 } 2537 }
2518 } 2538 }
2519 2539
2520 /* Note that unless the spp_flag is s 2540 /* Note that unless the spp_flag is set to SPP_SACKDELAY_ENABLE the
2521 * value of this field is ignored. N 2541 * value of this field is ignored. Note also that a value of zero
2522 * indicates the current setting shou 2542 * indicates the current setting should be left unchanged.
2523 */ 2543 */
2524 if ((params->spp_flags & SPP_SACKDELA 2544 if ((params->spp_flags & SPP_SACKDELAY_ENABLE) && params->spp_sackdelay) {
2525 if (trans) { 2545 if (trans) {
2526 trans->sackdelay = 2546 trans->sackdelay =
2527 msecs_to_jiff 2547 msecs_to_jiffies(params->spp_sackdelay);
2528 } else if (asoc) { 2548 } else if (asoc) {
2529 asoc->sackdelay = 2549 asoc->sackdelay =
2530 msecs_to_jiff 2550 msecs_to_jiffies(params->spp_sackdelay);
2531 } else { 2551 } else {
2532 sp->sackdelay = param 2552 sp->sackdelay = params->spp_sackdelay;
2533 } 2553 }
2534 } 2554 }
2535 2555
2536 if (sackdelay_change) { 2556 if (sackdelay_change) {
2537 if (trans) { 2557 if (trans) {
2538 trans->param_flags = 2558 trans->param_flags =
2539 (trans->param 2559 (trans->param_flags & ~SPP_SACKDELAY) |
2540 sackdelay_cha 2560 sackdelay_change;
2541 } else if (asoc) { 2561 } else if (asoc) {
2542 asoc->param_flags = 2562 asoc->param_flags =
2543 (asoc->param_ 2563 (asoc->param_flags & ~SPP_SACKDELAY) |
2544 sackdelay_cha 2564 sackdelay_change;
2545 } else { 2565 } else {
2546 sp->param_flags = 2566 sp->param_flags =
2547 (sp->param_fl 2567 (sp->param_flags & ~SPP_SACKDELAY) |
2548 sackdelay_cha 2568 sackdelay_change;
2549 } 2569 }
2550 } 2570 }
2551 2571
2552 /* Note that a value of zero indicate 2572 /* Note that a value of zero indicates the current setting should be
2553 left unchanged. 2573 left unchanged.
2554 */ 2574 */
2555 if (params->spp_pathmaxrxt) { 2575 if (params->spp_pathmaxrxt) {
2556 if (trans) { 2576 if (trans) {
2557 trans->pathmaxrxt = p 2577 trans->pathmaxrxt = params->spp_pathmaxrxt;
2558 } else if (asoc) { 2578 } else if (asoc) {
2559 asoc->pathmaxrxt = pa 2579 asoc->pathmaxrxt = params->spp_pathmaxrxt;
2560 } else { 2580 } else {
2561 sp->pathmaxrxt = para 2581 sp->pathmaxrxt = params->spp_pathmaxrxt;
2562 } 2582 }
2563 } 2583 }
2564 2584
2565 if (params->spp_flags & SPP_IPV6_FLOW <<
2566 if (trans) { <<
2567 if (trans->ipaddr.sa. <<
2568 trans->flowla <<
2569 <<
2570 trans->flowla <<
2571 } <<
2572 } else if (asoc) { <<
2573 struct sctp_transport <<
2574 <<
2575 list_for_each_entry(t <<
2576 t <<
2577 if (t->ipaddr <<
2578 conti <<
2579 t->flowlabel <<
2580 <<
2581 t->flowlabel <<
2582 } <<
2583 asoc->flowlabel = par <<
2584 SCT <<
2585 asoc->flowlabel |= SC <<
2586 } else if (sctp_opt2sk(sp)->s <<
2587 sp->flowlabel = param <<
2588 SCTP_ <<
2589 sp->flowlabel |= SCTP <<
2590 } <<
2591 } <<
2592 <<
2593 if (params->spp_flags & SPP_DSCP) { <<
2594 if (trans) { <<
2595 trans->dscp = params- <<
2596 trans->dscp |= SCTP_D <<
2597 } else if (asoc) { <<
2598 struct sctp_transport <<
2599 <<
2600 list_for_each_entry(t <<
2601 t <<
2602 t->dscp = par <<
2603 SCT <<
2604 t->dscp |= SC <<
2605 } <<
2606 asoc->dscp = params-> <<
2607 asoc->dscp |= SCTP_DS <<
2608 } else { <<
2609 sp->dscp = params->sp <<
2610 sp->dscp |= SCTP_DSCP <<
2611 } <<
2612 } <<
2613 <<
2614 return 0; 2585 return 0;
2615 } 2586 }
2616 2587
2617 static int sctp_setsockopt_peer_addr_params(s 2588 static int sctp_setsockopt_peer_addr_params(struct sock *sk,
2618 s !! 2589 char __user *optval,
2619 u 2590 unsigned int optlen)
2620 { 2591 {
>> 2592 struct sctp_paddrparams params;
2621 struct sctp_transport *trans = NULL 2593 struct sctp_transport *trans = NULL;
2622 struct sctp_association *asoc = NULL; 2594 struct sctp_association *asoc = NULL;
2623 struct sctp_sock *sp = sctp_sk 2595 struct sctp_sock *sp = sctp_sk(sk);
2624 int error; 2596 int error;
2625 int hb_change, pmtud_change, sackdela 2597 int hb_change, pmtud_change, sackdelay_change;
2626 2598
2627 if (optlen == ALIGN(offsetof(struct s !! 2599 if (optlen != sizeof(struct sctp_paddrparams))
2628 s <<
2629 if (params->spp_flags & (SPP_ <<
2630 return -EINVAL; <<
2631 } else if (optlen != sizeof(*params)) <<
2632 return -EINVAL; 2600 return -EINVAL;
2633 } !! 2601
>> 2602 if (copy_from_user(¶ms, optval, optlen))
>> 2603 return -EFAULT;
2634 2604
2635 /* Validate flags and value parameter 2605 /* Validate flags and value parameters. */
2636 hb_change = params->spp_flags !! 2606 hb_change = params.spp_flags & SPP_HB;
2637 pmtud_change = params->spp_flags !! 2607 pmtud_change = params.spp_flags & SPP_PMTUD;
2638 sackdelay_change = params->spp_flags !! 2608 sackdelay_change = params.spp_flags & SPP_SACKDELAY;
2639 2609
2640 if (hb_change == SPP_HB || 2610 if (hb_change == SPP_HB ||
2641 pmtud_change == SPP_PMTUD || 2611 pmtud_change == SPP_PMTUD ||
2642 sackdelay_change == SPP_SACKDELAY 2612 sackdelay_change == SPP_SACKDELAY ||
2643 params->spp_sackdelay > 500 || !! 2613 params.spp_sackdelay > 500 ||
2644 (params->spp_pathmtu && !! 2614 (params.spp_pathmtu &&
2645 params->spp_pathmtu < SCTP_DEFAU !! 2615 params.spp_pathmtu < SCTP_DEFAULT_MINSEGMENT))
2646 return -EINVAL; 2616 return -EINVAL;
2647 2617
2648 /* If an address other than INADDR_AN 2618 /* If an address other than INADDR_ANY is specified, and
2649 * no transport is found, then the re 2619 * no transport is found, then the request is invalid.
2650 */ 2620 */
2651 if (!sctp_is_any(sk, (union sctp_addr !! 2621 if (!sctp_is_any(sk, (union sctp_addr *)¶ms.spp_address)) {
2652 trans = sctp_addr_id2transpor !! 2622 trans = sctp_addr_id2transport(sk, ¶ms.spp_address,
2653 !! 2623 params.spp_assoc_id);
2654 if (!trans) 2624 if (!trans)
2655 return -EINVAL; 2625 return -EINVAL;
2656 } 2626 }
2657 2627
2658 /* Get association, if assoc_id != SC !! 2628 /* Get association, if assoc_id != 0 and the socket is a one
2659 * socket is a one to many style sock !! 2629 * to many style socket, and an association was not found, then
2660 * was not found, then the id was inv !! 2630 * the id was invalid.
2661 */ !! 2631 */
2662 asoc = sctp_id2assoc(sk, params->spp_ !! 2632 asoc = sctp_id2assoc(sk, params.spp_assoc_id);
2663 if (!asoc && params->spp_assoc_id != !! 2633 if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP))
2664 sctp_style(sk, UDP)) <<
2665 return -EINVAL; 2634 return -EINVAL;
2666 2635
2667 /* Heartbeat demand can only be sent 2636 /* Heartbeat demand can only be sent on a transport or
2668 * association, but not a socket. 2637 * association, but not a socket.
2669 */ 2638 */
2670 if (params->spp_flags & SPP_HB_DEMAND !! 2639 if (params.spp_flags & SPP_HB_DEMAND && !trans && !asoc)
2671 return -EINVAL; 2640 return -EINVAL;
2672 2641
2673 /* Process parameters. */ 2642 /* Process parameters. */
2674 error = sctp_apply_peer_addr_params(p !! 2643 error = sctp_apply_peer_addr_params(¶ms, trans, asoc, sp,
2675 h 2644 hb_change, pmtud_change,
2676 s 2645 sackdelay_change);
2677 2646
2678 if (error) 2647 if (error)
2679 return error; 2648 return error;
2680 2649
2681 /* If changes are for association, al 2650 /* If changes are for association, also apply parameters to each
2682 * transport. 2651 * transport.
2683 */ 2652 */
2684 if (!trans && asoc) { 2653 if (!trans && asoc) {
2685 list_for_each_entry(trans, &a 2654 list_for_each_entry(trans, &asoc->peer.transport_addr_list,
2686 transports) { 2655 transports) {
2687 sctp_apply_peer_addr_ !! 2656 sctp_apply_peer_addr_params(¶ms, trans, asoc, sp,
2688 2657 hb_change, pmtud_change,
2689 2658 sackdelay_change);
2690 } 2659 }
2691 } 2660 }
2692 2661
2693 return 0; 2662 return 0;
2694 } 2663 }
2695 2664
2696 static inline __u32 sctp_spp_sackdelay_enable 2665 static inline __u32 sctp_spp_sackdelay_enable(__u32 param_flags)
2697 { 2666 {
2698 return (param_flags & ~SPP_SACKDELAY) 2667 return (param_flags & ~SPP_SACKDELAY) | SPP_SACKDELAY_ENABLE;
2699 } 2668 }
2700 2669
2701 static inline __u32 sctp_spp_sackdelay_disabl 2670 static inline __u32 sctp_spp_sackdelay_disable(__u32 param_flags)
2702 { 2671 {
2703 return (param_flags & ~SPP_SACKDELAY) 2672 return (param_flags & ~SPP_SACKDELAY) | SPP_SACKDELAY_DISABLE;
2704 } 2673 }
2705 2674
2706 static void sctp_apply_asoc_delayed_ack(struc <<
2707 struc <<
2708 { <<
2709 struct sctp_transport *trans; <<
2710 <<
2711 if (params->sack_delay) { <<
2712 asoc->sackdelay = msecs_to_ji <<
2713 asoc->param_flags = <<
2714 sctp_spp_sackdelay_en <<
2715 } <<
2716 if (params->sack_freq == 1) { <<
2717 asoc->param_flags = <<
2718 sctp_spp_sackdelay_di <<
2719 } else if (params->sack_freq > 1) { <<
2720 asoc->sackfreq = params->sack <<
2721 asoc->param_flags = <<
2722 sctp_spp_sackdelay_en <<
2723 } <<
2724 <<
2725 list_for_each_entry(trans, &asoc->pee <<
2726 transports) { <<
2727 if (params->sack_delay) { <<
2728 trans->sackdelay = ms <<
2729 trans->param_flags = <<
2730 sctp_spp_sack <<
2731 } <<
2732 if (params->sack_freq == 1) { <<
2733 trans->param_flags = <<
2734 sctp_spp_sack <<
2735 } else if (params->sack_freq <<
2736 trans->sackfreq = par <<
2737 trans->param_flags = <<
2738 sctp_spp_sack <<
2739 } <<
2740 } <<
2741 } <<
2742 <<
2743 /* 2675 /*
2744 * 7.1.23. Get or set delayed ack timer (SCT 2676 * 7.1.23. Get or set delayed ack timer (SCTP_DELAYED_SACK)
2745 * 2677 *
2746 * This option will effect the way delayed ac 2678 * This option will effect the way delayed acks are performed. This
2747 * option allows you to get or set the delaye 2679 * option allows you to get or set the delayed ack time, in
2748 * milliseconds. It also allows changing the 2680 * milliseconds. It also allows changing the delayed ack frequency.
2749 * Changing the frequency to 1 disables the d 2681 * Changing the frequency to 1 disables the delayed sack algorithm. If
2750 * the assoc_id is 0, then this sets or gets 2682 * the assoc_id is 0, then this sets or gets the endpoints default
2751 * values. If the assoc_id field is non-zero 2683 * values. If the assoc_id field is non-zero, then the set or get
2752 * effects the specified association for the 2684 * effects the specified association for the one to many model (the
2753 * assoc_id field is ignored by the one to on 2685 * assoc_id field is ignored by the one to one model). Note that if
2754 * sack_delay or sack_freq are 0 when setting 2686 * sack_delay or sack_freq are 0 when setting this option, then the
2755 * current values will remain unchanged. 2687 * current values will remain unchanged.
2756 * 2688 *
2757 * struct sctp_sack_info { 2689 * struct sctp_sack_info {
2758 * sctp_assoc_t sack_assoc_id; 2690 * sctp_assoc_t sack_assoc_id;
2759 * uint32_t sack_delay; 2691 * uint32_t sack_delay;
2760 * uint32_t sack_freq; 2692 * uint32_t sack_freq;
2761 * }; 2693 * };
2762 * 2694 *
2763 * sack_assoc_id - This parameter, indicates 2695 * sack_assoc_id - This parameter, indicates which association the user
2764 * is performing an action upon. Note tha 2696 * is performing an action upon. Note that if this field's value is
2765 * zero then the endpoints default value i 2697 * zero then the endpoints default value is changed (effecting future
2766 * associations only). 2698 * associations only).
2767 * 2699 *
2768 * sack_delay - This parameter contains the 2700 * sack_delay - This parameter contains the number of milliseconds that
2769 * the user is requesting the delayed ACK 2701 * the user is requesting the delayed ACK timer be set to. Note that
2770 * this value is defined in the standard t 2702 * this value is defined in the standard to be between 200 and 500
2771 * milliseconds. 2703 * milliseconds.
2772 * 2704 *
2773 * sack_freq - This parameter contains the n 2705 * sack_freq - This parameter contains the number of packets that must
2774 * be received before a sack is sent witho 2706 * be received before a sack is sent without waiting for the delay
2775 * timer to expire. The default value for 2707 * timer to expire. The default value for this is 2, setting this
2776 * value to 1 will disable the delayed sac 2708 * value to 1 will disable the delayed sack algorithm.
2777 */ 2709 */
2778 static int __sctp_setsockopt_delayed_ack(stru !! 2710
2779 stru !! 2711 static int sctp_setsockopt_delayed_ack(struct sock *sk,
>> 2712 char __user *optval, unsigned int optlen)
2780 { 2713 {
2781 struct sctp_sock *sp = sctp_sk(sk); !! 2714 struct sctp_sack_info params;
2782 struct sctp_association *asoc; !! 2715 struct sctp_transport *trans = NULL;
>> 2716 struct sctp_association *asoc = NULL;
>> 2717 struct sctp_sock *sp = sctp_sk(sk);
>> 2718
>> 2719 if (optlen == sizeof(struct sctp_sack_info)) {
>> 2720 if (copy_from_user(¶ms, optval, optlen))
>> 2721 return -EFAULT;
>> 2722
>> 2723 if (params.sack_delay == 0 && params.sack_freq == 0)
>> 2724 return 0;
>> 2725 } else if (optlen == sizeof(struct sctp_assoc_value)) {
>> 2726 pr_warn_ratelimited(DEPRECATED
>> 2727 "%s (pid %d) "
>> 2728 "Use of struct sctp_assoc_value in delayed_ack socket option.\n"
>> 2729 "Use struct sctp_sack_info instead\n",
>> 2730 current->comm, task_pid_nr(current));
>> 2731 if (copy_from_user(¶ms, optval, optlen))
>> 2732 return -EFAULT;
>> 2733
>> 2734 if (params.sack_delay == 0)
>> 2735 params.sack_freq = 1;
>> 2736 else
>> 2737 params.sack_freq = 0;
>> 2738 } else
>> 2739 return -EINVAL;
2783 2740
2784 /* Validate value parameter. */ 2741 /* Validate value parameter. */
2785 if (params->sack_delay > 500) !! 2742 if (params.sack_delay > 500)
2786 return -EINVAL; 2743 return -EINVAL;
2787 2744
2788 /* Get association, if sack_assoc_id !! 2745 /* Get association, if sack_assoc_id != 0 and the socket is a one
2789 * socket is a one to many style sock !! 2746 * to many style socket, and an association was not found, then
2790 * was not found, then the id was inv !! 2747 * the id was invalid.
2791 */ 2748 */
2792 asoc = sctp_id2assoc(sk, params->sack !! 2749 asoc = sctp_id2assoc(sk, params.sack_assoc_id);
2793 if (!asoc && params->sack_assoc_id > !! 2750 if (!asoc && params.sack_assoc_id && sctp_style(sk, UDP))
2794 sctp_style(sk, UDP)) <<
2795 return -EINVAL; 2751 return -EINVAL;
2796 2752
2797 if (asoc) { !! 2753 if (params.sack_delay) {
2798 sctp_apply_asoc_delayed_ack(p !! 2754 if (asoc) {
2799 !! 2755 asoc->sackdelay =
2800 return 0; !! 2756 msecs_to_jiffies(params.sack_delay);
2801 } !! 2757 asoc->param_flags =
2802 !! 2758 sctp_spp_sackdelay_enable(asoc->param_flags);
2803 if (sctp_style(sk, TCP)) !! 2759 } else {
2804 params->sack_assoc_id = SCTP_ !! 2760 sp->sackdelay = params.sack_delay;
2805 <<
2806 if (params->sack_assoc_id == SCTP_FUT <<
2807 params->sack_assoc_id == SCTP_ALL <<
2808 if (params->sack_delay) { <<
2809 sp->sackdelay = param <<
2810 sp->param_flags = 2761 sp->param_flags =
2811 sctp_spp_sack 2762 sctp_spp_sackdelay_enable(sp->param_flags);
2812 } 2763 }
2813 if (params->sack_freq == 1) { !! 2764 }
>> 2765
>> 2766 if (params.sack_freq == 1) {
>> 2767 if (asoc) {
>> 2768 asoc->param_flags =
>> 2769 sctp_spp_sackdelay_disable(asoc->param_flags);
>> 2770 } else {
2814 sp->param_flags = 2771 sp->param_flags =
2815 sctp_spp_sack 2772 sctp_spp_sackdelay_disable(sp->param_flags);
2816 } else if (params->sack_freq !! 2773 }
2817 sp->sackfreq = params !! 2774 } else if (params.sack_freq > 1) {
>> 2775 if (asoc) {
>> 2776 asoc->sackfreq = params.sack_freq;
>> 2777 asoc->param_flags =
>> 2778 sctp_spp_sackdelay_enable(asoc->param_flags);
>> 2779 } else {
>> 2780 sp->sackfreq = params.sack_freq;
2818 sp->param_flags = 2781 sp->param_flags =
2819 sctp_spp_sack 2782 sctp_spp_sackdelay_enable(sp->param_flags);
2820 } 2783 }
2821 } 2784 }
2822 2785
2823 if (params->sack_assoc_id == SCTP_CUR !! 2786 /* If change is for association, also apply to each transport. */
2824 params->sack_assoc_id == SCTP_ALL !! 2787 if (asoc) {
2825 list_for_each_entry(asoc, &sp !! 2788 list_for_each_entry(trans, &asoc->peer.transport_addr_list,
2826 sctp_apply_asoc_delay !! 2789 transports) {
2827 !! 2790 if (params.sack_delay) {
2828 return 0; !! 2791 trans->sackdelay =
2829 } !! 2792 msecs_to_jiffies(params.sack_delay);
2830 !! 2793 trans->param_flags =
2831 static int sctp_setsockopt_delayed_ack(struct !! 2794 sctp_spp_sackdelay_enable(trans->param_flags);
2832 struct !! 2795 }
2833 unsign !! 2796 if (params.sack_freq == 1) {
2834 { !! 2797 trans->param_flags =
2835 if (optlen == sizeof(struct sctp_asso !! 2798 sctp_spp_sackdelay_disable(trans->param_flags);
2836 struct sctp_assoc_value *v = !! 2799 } else if (params.sack_freq > 1) {
2837 struct sctp_sack_info p; !! 2800 trans->sackfreq = params.sack_freq;
2838 !! 2801 trans->param_flags =
2839 pr_warn_ratelimited(DEPRECATE !! 2802 sctp_spp_sackdelay_enable(trans->param_flags);
2840 "%s (pid !! 2803 }
2841 "Use of s !! 2804 }
2842 "Use stru <<
2843 current-> <<
2844 <<
2845 p.sack_assoc_id = v->assoc_id <<
2846 p.sack_delay = v->assoc_value <<
2847 p.sack_freq = v->assoc_value <<
2848 return __sctp_setsockopt_dela <<
2849 } 2805 }
2850 2806
2851 if (optlen != sizeof(struct sctp_sack !! 2807 return 0;
2852 return -EINVAL; <<
2853 if (params->sack_delay == 0 && params <<
2854 return 0; <<
2855 return __sctp_setsockopt_delayed_ack( <<
2856 } 2808 }
2857 2809
2858 /* 7.1.3 Initialization Parameters (SCTP_INIT 2810 /* 7.1.3 Initialization Parameters (SCTP_INITMSG)
2859 * 2811 *
2860 * Applications can specify protocol paramete 2812 * Applications can specify protocol parameters for the default association
2861 * initialization. The option name argument 2813 * initialization. The option name argument to setsockopt() and getsockopt()
2862 * is SCTP_INITMSG. 2814 * is SCTP_INITMSG.
2863 * 2815 *
2864 * Setting initialization parameters is effec 2816 * Setting initialization parameters is effective only on an unconnected
2865 * socket (for UDP-style sockets only future 2817 * socket (for UDP-style sockets only future associations are effected
2866 * by the change). With TCP-style sockets, t 2818 * by the change). With TCP-style sockets, this option is inherited by
2867 * sockets derived from a listener socket. 2819 * sockets derived from a listener socket.
2868 */ 2820 */
2869 static int sctp_setsockopt_initmsg(struct soc !! 2821 static int sctp_setsockopt_initmsg(struct sock *sk, char __user *optval, unsigned int optlen)
2870 unsigned i <<
2871 { 2822 {
>> 2823 struct sctp_initmsg sinit;
2872 struct sctp_sock *sp = sctp_sk(sk); 2824 struct sctp_sock *sp = sctp_sk(sk);
2873 2825
2874 if (optlen != sizeof(struct sctp_init 2826 if (optlen != sizeof(struct sctp_initmsg))
2875 return -EINVAL; 2827 return -EINVAL;
>> 2828 if (copy_from_user(&sinit, optval, optlen))
>> 2829 return -EFAULT;
2876 2830
2877 if (sinit->sinit_num_ostreams) !! 2831 if (sinit.sinit_num_ostreams)
2878 sp->initmsg.sinit_num_ostream !! 2832 sp->initmsg.sinit_num_ostreams = sinit.sinit_num_ostreams;
2879 if (sinit->sinit_max_instreams) !! 2833 if (sinit.sinit_max_instreams)
2880 sp->initmsg.sinit_max_instrea !! 2834 sp->initmsg.sinit_max_instreams = sinit.sinit_max_instreams;
2881 if (sinit->sinit_max_attempts) !! 2835 if (sinit.sinit_max_attempts)
2882 sp->initmsg.sinit_max_attempt !! 2836 sp->initmsg.sinit_max_attempts = sinit.sinit_max_attempts;
2883 if (sinit->sinit_max_init_timeo) !! 2837 if (sinit.sinit_max_init_timeo)
2884 sp->initmsg.sinit_max_init_ti !! 2838 sp->initmsg.sinit_max_init_timeo = sinit.sinit_max_init_timeo;
2885 2839
2886 return 0; 2840 return 0;
2887 } 2841 }
2888 2842
2889 /* 2843 /*
2890 * 7.1.14 Set default send parameters (SCTP_D 2844 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
2891 * 2845 *
2892 * Applications that wish to use the sendto 2846 * Applications that wish to use the sendto() system call may wish to
2893 * specify a default set of parameters that 2847 * specify a default set of parameters that would normally be supplied
2894 * through the inclusion of ancillary data. 2848 * through the inclusion of ancillary data. This socket option allows
2895 * such an application to set the default s 2849 * such an application to set the default sctp_sndrcvinfo structure.
2896 * The application that wishes to use this 2850 * The application that wishes to use this socket option simply passes
2897 * in to this call the sctp_sndrcvinfo stru 2851 * in to this call the sctp_sndrcvinfo structure defined in Section
2898 * 5.2.2) The input parameters accepted by 2852 * 5.2.2) The input parameters accepted by this call include
2899 * sinfo_stream, sinfo_flags, sinfo_ppid, s 2853 * sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
2900 * sinfo_timetolive. The user must provide 2854 * sinfo_timetolive. The user must provide the sinfo_assoc_id field in
2901 * to this call if the caller is using the 2855 * to this call if the caller is using the UDP model.
2902 */ 2856 */
2903 static int sctp_setsockopt_default_send_param 2857 static int sctp_setsockopt_default_send_param(struct sock *sk,
2904 !! 2858 char __user *optval,
2905 2859 unsigned int optlen)
2906 { 2860 {
2907 struct sctp_sock *sp = sctp_sk(sk); 2861 struct sctp_sock *sp = sctp_sk(sk);
2908 struct sctp_association *asoc; 2862 struct sctp_association *asoc;
>> 2863 struct sctp_sndrcvinfo info;
2909 2864
2910 if (optlen != sizeof(*info)) !! 2865 if (optlen != sizeof(info))
2911 return -EINVAL; 2866 return -EINVAL;
2912 if (info->sinfo_flags & !! 2867 if (copy_from_user(&info, optval, optlen))
>> 2868 return -EFAULT;
>> 2869 if (info.sinfo_flags &
2913 ~(SCTP_UNORDERED | SCTP_ADDR_OVER 2870 ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
2914 SCTP_ABORT | SCTP_EOF)) 2871 SCTP_ABORT | SCTP_EOF))
2915 return -EINVAL; 2872 return -EINVAL;
2916 2873
2917 asoc = sctp_id2assoc(sk, info->sinfo_ !! 2874 asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);
2918 if (!asoc && info->sinfo_assoc_id > S !! 2875 if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP))
2919 sctp_style(sk, UDP)) <<
2920 return -EINVAL; 2876 return -EINVAL;
2921 <<
2922 if (asoc) { 2877 if (asoc) {
2923 asoc->default_stream = info-> !! 2878 asoc->default_stream = info.sinfo_stream;
2924 asoc->default_flags = info->s !! 2879 asoc->default_flags = info.sinfo_flags;
2925 asoc->default_ppid = info->si !! 2880 asoc->default_ppid = info.sinfo_ppid;
2926 asoc->default_context = info- !! 2881 asoc->default_context = info.sinfo_context;
2927 asoc->default_timetolive = in !! 2882 asoc->default_timetolive = info.sinfo_timetolive;
2928 !! 2883 } else {
2929 return 0; !! 2884 sp->default_stream = info.sinfo_stream;
2930 } !! 2885 sp->default_flags = info.sinfo_flags;
2931 !! 2886 sp->default_ppid = info.sinfo_ppid;
2932 if (sctp_style(sk, TCP)) !! 2887 sp->default_context = info.sinfo_context;
2933 info->sinfo_assoc_id = SCTP_F !! 2888 sp->default_timetolive = info.sinfo_timetolive;
2934 <<
2935 if (info->sinfo_assoc_id == SCTP_FUTU <<
2936 info->sinfo_assoc_id == SCTP_ALL_ <<
2937 sp->default_stream = info->si <<
2938 sp->default_flags = info->sin <<
2939 sp->default_ppid = info->sinf <<
2940 sp->default_context = info->s <<
2941 sp->default_timetolive = info <<
2942 } <<
2943 <<
2944 if (info->sinfo_assoc_id == SCTP_CURR <<
2945 info->sinfo_assoc_id == SCTP_ALL_ <<
2946 list_for_each_entry(asoc, &sp <<
2947 asoc->default_stream <<
2948 asoc->default_flags = <<
2949 asoc->default_ppid = <<
2950 asoc->default_context <<
2951 asoc->default_timetol <<
2952 } <<
2953 } 2889 }
2954 2890
2955 return 0; 2891 return 0;
2956 } 2892 }
2957 2893
2958 /* RFC6458, Section 8.1.31. Set/get Default S 2894 /* RFC6458, Section 8.1.31. Set/get Default Send Parameters
2959 * (SCTP_DEFAULT_SNDINFO) 2895 * (SCTP_DEFAULT_SNDINFO)
2960 */ 2896 */
2961 static int sctp_setsockopt_default_sndinfo(st 2897 static int sctp_setsockopt_default_sndinfo(struct sock *sk,
2962 st !! 2898 char __user *optval,
2963 un 2899 unsigned int optlen)
2964 { 2900 {
2965 struct sctp_sock *sp = sctp_sk(sk); 2901 struct sctp_sock *sp = sctp_sk(sk);
2966 struct sctp_association *asoc; 2902 struct sctp_association *asoc;
>> 2903 struct sctp_sndinfo info;
2967 2904
2968 if (optlen != sizeof(*info)) !! 2905 if (optlen != sizeof(info))
2969 return -EINVAL; 2906 return -EINVAL;
2970 if (info->snd_flags & !! 2907 if (copy_from_user(&info, optval, optlen))
>> 2908 return -EFAULT;
>> 2909 if (info.snd_flags &
2971 ~(SCTP_UNORDERED | SCTP_ADDR_OVER 2910 ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
2972 SCTP_ABORT | SCTP_EOF)) 2911 SCTP_ABORT | SCTP_EOF))
2973 return -EINVAL; 2912 return -EINVAL;
2974 2913
2975 asoc = sctp_id2assoc(sk, info->snd_as !! 2914 asoc = sctp_id2assoc(sk, info.snd_assoc_id);
2976 if (!asoc && info->snd_assoc_id > SCT !! 2915 if (!asoc && info.snd_assoc_id && sctp_style(sk, UDP))
2977 sctp_style(sk, UDP)) <<
2978 return -EINVAL; 2916 return -EINVAL;
2979 <<
2980 if (asoc) { 2917 if (asoc) {
2981 asoc->default_stream = info-> !! 2918 asoc->default_stream = info.snd_sid;
2982 asoc->default_flags = info->s !! 2919 asoc->default_flags = info.snd_flags;
2983 asoc->default_ppid = info->sn !! 2920 asoc->default_ppid = info.snd_ppid;
2984 asoc->default_context = info- !! 2921 asoc->default_context = info.snd_context;
2985 !! 2922 } else {
2986 return 0; !! 2923 sp->default_stream = info.snd_sid;
2987 } !! 2924 sp->default_flags = info.snd_flags;
2988 !! 2925 sp->default_ppid = info.snd_ppid;
2989 if (sctp_style(sk, TCP)) !! 2926 sp->default_context = info.snd_context;
2990 info->snd_assoc_id = SCTP_FUT <<
2991 <<
2992 if (info->snd_assoc_id == SCTP_FUTURE <<
2993 info->snd_assoc_id == SCTP_ALL_AS <<
2994 sp->default_stream = info->sn <<
2995 sp->default_flags = info->snd <<
2996 sp->default_ppid = info->snd_ <<
2997 sp->default_context = info->s <<
2998 } <<
2999 <<
3000 if (info->snd_assoc_id == SCTP_CURREN <<
3001 info->snd_assoc_id == SCTP_ALL_AS <<
3002 list_for_each_entry(asoc, &sp <<
3003 asoc->default_stream <<
3004 asoc->default_flags = <<
3005 asoc->default_ppid = <<
3006 asoc->default_context <<
3007 } <<
3008 } 2927 }
3009 2928
3010 return 0; 2929 return 0;
3011 } 2930 }
3012 2931
3013 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_A 2932 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
3014 * 2933 *
3015 * Requests that the local SCTP stack use the 2934 * Requests that the local SCTP stack use the enclosed peer address as
3016 * the association primary. The enclosed add 2935 * the association primary. The enclosed address must be one of the
3017 * association peer's addresses. 2936 * association peer's addresses.
3018 */ 2937 */
3019 static int sctp_setsockopt_primary_addr(struc !! 2938 static int sctp_setsockopt_primary_addr(struct sock *sk, char __user *optval,
3020 unsig 2939 unsigned int optlen)
3021 { 2940 {
>> 2941 struct sctp_prim prim;
3022 struct sctp_transport *trans; 2942 struct sctp_transport *trans;
3023 struct sctp_af *af; <<
3024 int err; <<
3025 2943
3026 if (optlen != sizeof(struct sctp_prim 2944 if (optlen != sizeof(struct sctp_prim))
3027 return -EINVAL; 2945 return -EINVAL;
3028 2946
3029 /* Allow security module to validate !! 2947 if (copy_from_user(&prim, optval, sizeof(struct sctp_prim)))
3030 af = sctp_get_af_specific(prim->ssp_a !! 2948 return -EFAULT;
3031 if (!af) <<
3032 return -EINVAL; <<
3033 <<
3034 err = security_sctp_bind_connect(sk, <<
3035 (str <<
3036 af-> <<
3037 if (err) <<
3038 return err; <<
3039 2949
3040 trans = sctp_addr_id2transport(sk, &p !! 2950 trans = sctp_addr_id2transport(sk, &prim.ssp_addr, prim.ssp_assoc_id);
3041 if (!trans) 2951 if (!trans)
3042 return -EINVAL; 2952 return -EINVAL;
3043 2953
3044 sctp_assoc_set_primary(trans->asoc, t 2954 sctp_assoc_set_primary(trans->asoc, trans);
3045 2955
3046 return 0; 2956 return 0;
3047 } 2957 }
3048 2958
3049 /* 2959 /*
3050 * 7.1.5 SCTP_NODELAY 2960 * 7.1.5 SCTP_NODELAY
3051 * 2961 *
3052 * Turn on/off any Nagle-like algorithm. Thi 2962 * Turn on/off any Nagle-like algorithm. This means that packets are
3053 * generally sent as soon as possible and no 2963 * generally sent as soon as possible and no unnecessary delays are
3054 * introduced, at the cost of more packets in 2964 * introduced, at the cost of more packets in the network. Expects an
3055 * integer boolean flag. 2965 * integer boolean flag.
3056 */ 2966 */
3057 static int sctp_setsockopt_nodelay(struct soc !! 2967 static int sctp_setsockopt_nodelay(struct sock *sk, char __user *optval,
3058 unsigned i 2968 unsigned int optlen)
3059 { 2969 {
>> 2970 int val;
>> 2971
3060 if (optlen < sizeof(int)) 2972 if (optlen < sizeof(int))
3061 return -EINVAL; 2973 return -EINVAL;
3062 sctp_sk(sk)->nodelay = (*val == 0) ? !! 2974 if (get_user(val, (int __user *)optval))
>> 2975 return -EFAULT;
>> 2976
>> 2977 sctp_sk(sk)->nodelay = (val == 0) ? 0 : 1;
3063 return 0; 2978 return 0;
3064 } 2979 }
3065 2980
3066 /* 2981 /*
3067 * 2982 *
3068 * 7.1.1 SCTP_RTOINFO 2983 * 7.1.1 SCTP_RTOINFO
3069 * 2984 *
3070 * The protocol parameters used to initialize 2985 * The protocol parameters used to initialize and bound retransmission
3071 * timeout (RTO) are tunable. sctp_rtoinfo st 2986 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
3072 * and modify these parameters. 2987 * and modify these parameters.
3073 * All parameters are time values, in millise 2988 * All parameters are time values, in milliseconds. A value of 0, when
3074 * modifying the parameters, indicates that t 2989 * modifying the parameters, indicates that the current value should not
3075 * be changed. 2990 * be changed.
3076 * 2991 *
3077 */ 2992 */
3078 static int sctp_setsockopt_rtoinfo(struct soc !! 2993 static int sctp_setsockopt_rtoinfo(struct sock *sk, char __user *optval, unsigned int optlen)
3079 struct sct <<
3080 unsigned i <<
3081 { 2994 {
>> 2995 struct sctp_rtoinfo rtoinfo;
3082 struct sctp_association *asoc; 2996 struct sctp_association *asoc;
3083 unsigned long rto_min, rto_max; 2997 unsigned long rto_min, rto_max;
3084 struct sctp_sock *sp = sctp_sk(sk); 2998 struct sctp_sock *sp = sctp_sk(sk);
3085 2999
3086 if (optlen != sizeof (struct sctp_rto 3000 if (optlen != sizeof (struct sctp_rtoinfo))
3087 return -EINVAL; 3001 return -EINVAL;
3088 3002
3089 asoc = sctp_id2assoc(sk, rtoinfo->srt !! 3003 if (copy_from_user(&rtoinfo, optval, optlen))
>> 3004 return -EFAULT;
>> 3005
>> 3006 asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id);
3090 3007
3091 /* Set the values to the specific ass 3008 /* Set the values to the specific association */
3092 if (!asoc && rtoinfo->srto_assoc_id ! !! 3009 if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP))
3093 sctp_style(sk, UDP)) <<
3094 return -EINVAL; 3010 return -EINVAL;
3095 3011
3096 rto_max = rtoinfo->srto_max; !! 3012 rto_max = rtoinfo.srto_max;
3097 rto_min = rtoinfo->srto_min; !! 3013 rto_min = rtoinfo.srto_min;
3098 3014
3099 if (rto_max) 3015 if (rto_max)
3100 rto_max = asoc ? msecs_to_jif 3016 rto_max = asoc ? msecs_to_jiffies(rto_max) : rto_max;
3101 else 3017 else
3102 rto_max = asoc ? asoc->rto_ma 3018 rto_max = asoc ? asoc->rto_max : sp->rtoinfo.srto_max;
3103 3019
3104 if (rto_min) 3020 if (rto_min)
3105 rto_min = asoc ? msecs_to_jif 3021 rto_min = asoc ? msecs_to_jiffies(rto_min) : rto_min;
3106 else 3022 else
3107 rto_min = asoc ? asoc->rto_mi 3023 rto_min = asoc ? asoc->rto_min : sp->rtoinfo.srto_min;
3108 3024
3109 if (rto_min > rto_max) 3025 if (rto_min > rto_max)
3110 return -EINVAL; 3026 return -EINVAL;
3111 3027
3112 if (asoc) { 3028 if (asoc) {
3113 if (rtoinfo->srto_initial != !! 3029 if (rtoinfo.srto_initial != 0)
3114 asoc->rto_initial = 3030 asoc->rto_initial =
3115 msecs_to_jiff !! 3031 msecs_to_jiffies(rtoinfo.srto_initial);
3116 asoc->rto_max = rto_max; 3032 asoc->rto_max = rto_max;
3117 asoc->rto_min = rto_min; 3033 asoc->rto_min = rto_min;
3118 } else { 3034 } else {
3119 /* If there is no association 3035 /* If there is no association or the association-id = 0
3120 * set the values to the endp 3036 * set the values to the endpoint.
3121 */ 3037 */
3122 if (rtoinfo->srto_initial != !! 3038 if (rtoinfo.srto_initial != 0)
3123 sp->rtoinfo.srto_init !! 3039 sp->rtoinfo.srto_initial = rtoinfo.srto_initial;
3124 sp->rtoinfo.srto_max = rto_ma 3040 sp->rtoinfo.srto_max = rto_max;
3125 sp->rtoinfo.srto_min = rto_mi 3041 sp->rtoinfo.srto_min = rto_min;
3126 } 3042 }
3127 3043
3128 return 0; 3044 return 0;
3129 } 3045 }
3130 3046
3131 /* 3047 /*
3132 * 3048 *
3133 * 7.1.2 SCTP_ASSOCINFO 3049 * 7.1.2 SCTP_ASSOCINFO
3134 * 3050 *
3135 * This option is used to tune the maximum re 3051 * This option is used to tune the maximum retransmission attempts
3136 * of the association. 3052 * of the association.
3137 * Returns an error if the new association re 3053 * Returns an error if the new association retransmission value is
3138 * greater than the sum of the retransmission 3054 * greater than the sum of the retransmission value of the peer.
3139 * See [SCTP] for more information. 3055 * See [SCTP] for more information.
3140 * 3056 *
3141 */ 3057 */
3142 static int sctp_setsockopt_associnfo(struct s !! 3058 static int sctp_setsockopt_associnfo(struct sock *sk, char __user *optval, unsigned int optlen)
3143 struct s <<
3144 unsigned <<
3145 { 3059 {
3146 3060
>> 3061 struct sctp_assocparams assocparams;
3147 struct sctp_association *asoc; 3062 struct sctp_association *asoc;
3148 3063
3149 if (optlen != sizeof(struct sctp_asso 3064 if (optlen != sizeof(struct sctp_assocparams))
3150 return -EINVAL; 3065 return -EINVAL;
>> 3066 if (copy_from_user(&assocparams, optval, optlen))
>> 3067 return -EFAULT;
3151 3068
3152 asoc = sctp_id2assoc(sk, assocparams- !! 3069 asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id);
3153 3070
3154 if (!asoc && assocparams->sasoc_assoc !! 3071 if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP))
3155 sctp_style(sk, UDP)) <<
3156 return -EINVAL; 3072 return -EINVAL;
3157 3073
3158 /* Set the values to the specific ass 3074 /* Set the values to the specific association */
3159 if (asoc) { 3075 if (asoc) {
3160 if (assocparams->sasoc_asocma !! 3076 if (assocparams.sasoc_asocmaxrxt != 0) {
3161 __u32 path_sum = 0; 3077 __u32 path_sum = 0;
3162 int paths = 0; 3078 int paths = 0;
3163 struct sctp_transport 3079 struct sctp_transport *peer_addr;
3164 3080
3165 list_for_each_entry(p 3081 list_for_each_entry(peer_addr, &asoc->peer.transport_addr_list,
3166 trans 3082 transports) {
3167 path_sum += p 3083 path_sum += peer_addr->pathmaxrxt;
3168 paths++; 3084 paths++;
3169 } 3085 }
3170 3086
3171 /* Only validate asoc 3087 /* Only validate asocmaxrxt if we have more than
3172 * one path/transport 3088 * one path/transport. We do this because path
3173 * retransmissions ar 3089 * retransmissions are only counted when we have more
3174 * then one path. 3090 * then one path.
3175 */ 3091 */
3176 if (paths > 1 && 3092 if (paths > 1 &&
3177 assocparams->saso !! 3093 assocparams.sasoc_asocmaxrxt > path_sum)
3178 return -EINVA 3094 return -EINVAL;
3179 3095
3180 asoc->max_retrans = a !! 3096 asoc->max_retrans = assocparams.sasoc_asocmaxrxt;
3181 } 3097 }
3182 3098
3183 if (assocparams->sasoc_cookie !! 3099 if (assocparams.sasoc_cookie_life != 0)
3184 asoc->cookie_life = !! 3100 asoc->cookie_life = ms_to_ktime(assocparams.sasoc_cookie_life);
3185 ms_to_ktime(a <<
3186 } else { 3101 } else {
3187 /* Set the values to the endp 3102 /* Set the values to the endpoint */
3188 struct sctp_sock *sp = sctp_s 3103 struct sctp_sock *sp = sctp_sk(sk);
3189 3104
3190 if (assocparams->sasoc_asocma !! 3105 if (assocparams.sasoc_asocmaxrxt != 0)
3191 sp->assocparams.sasoc 3106 sp->assocparams.sasoc_asocmaxrxt =
3192 !! 3107 assocparams.sasoc_asocmaxrxt;
3193 if (assocparams->sasoc_cookie !! 3108 if (assocparams.sasoc_cookie_life != 0)
3194 sp->assocparams.sasoc 3109 sp->assocparams.sasoc_cookie_life =
3195 !! 3110 assocparams.sasoc_cookie_life;
3196 } 3111 }
3197 return 0; 3112 return 0;
3198 } 3113 }
3199 3114
3200 /* 3115 /*
3201 * 7.1.16 Set/clear IPv4 mapped addresses (SC 3116 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
3202 * 3117 *
3203 * This socket option is a boolean flag which 3118 * This socket option is a boolean flag which turns on or off mapped V4
3204 * addresses. If this option is turned on an 3119 * addresses. If this option is turned on and the socket is type
3205 * PF_INET6, then IPv4 addresses will be mapp 3120 * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
3206 * If this option is turned off, then no mapp 3121 * If this option is turned off, then no mapping will be done of V4
3207 * addresses and a user will receive both PF_ 3122 * addresses and a user will receive both PF_INET6 and PF_INET type
3208 * addresses on the socket. 3123 * addresses on the socket.
3209 */ 3124 */
3210 static int sctp_setsockopt_mappedv4(struct so !! 3125 static int sctp_setsockopt_mappedv4(struct sock *sk, char __user *optval, unsigned int optlen)
3211 unsigned <<
3212 { 3126 {
>> 3127 int val;
3213 struct sctp_sock *sp = sctp_sk(sk); 3128 struct sctp_sock *sp = sctp_sk(sk);
3214 3129
3215 if (optlen < sizeof(int)) 3130 if (optlen < sizeof(int))
3216 return -EINVAL; 3131 return -EINVAL;
3217 if (*val) !! 3132 if (get_user(val, (int __user *)optval))
>> 3133 return -EFAULT;
>> 3134 if (val)
3218 sp->v4mapped = 1; 3135 sp->v4mapped = 1;
3219 else 3136 else
3220 sp->v4mapped = 0; 3137 sp->v4mapped = 0;
3221 3138
3222 return 0; 3139 return 0;
3223 } 3140 }
3224 3141
3225 /* 3142 /*
3226 * 8.1.16. Get or Set the Maximum Fragmentat 3143 * 8.1.16. Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG)
3227 * This option will get or set the maximum si 3144 * This option will get or set the maximum size to put in any outgoing
3228 * SCTP DATA chunk. If a message is larger t 3145 * SCTP DATA chunk. If a message is larger than this size it will be
3229 * fragmented by SCTP into the specified size 3146 * fragmented by SCTP into the specified size. Note that the underlying
3230 * SCTP implementation may fragment into smal 3147 * SCTP implementation may fragment into smaller sized chunks when the
3231 * PMTU of the underlying association is smal 3148 * PMTU of the underlying association is smaller than the value set by
3232 * the user. The default value for this opti 3149 * the user. The default value for this option is '' which indicates
3233 * the user is NOT limiting fragmentation and 3150 * the user is NOT limiting fragmentation and only the PMTU will effect
3234 * SCTP's choice of DATA chunk size. Note al 3151 * SCTP's choice of DATA chunk size. Note also that values set larger
3235 * than the maximum size of an IP datagram wi 3152 * than the maximum size of an IP datagram will effectively let SCTP
3236 * control fragmentation (i.e. the same as se 3153 * control fragmentation (i.e. the same as setting this option to 0).
3237 * 3154 *
3238 * The following structure is used to access 3155 * The following structure is used to access and modify this parameter:
3239 * 3156 *
3240 * struct sctp_assoc_value { 3157 * struct sctp_assoc_value {
3241 * sctp_assoc_t assoc_id; 3158 * sctp_assoc_t assoc_id;
3242 * uint32_t assoc_value; 3159 * uint32_t assoc_value;
3243 * }; 3160 * };
3244 * 3161 *
3245 * assoc_id: This parameter is ignored for o 3162 * assoc_id: This parameter is ignored for one-to-one style sockets.
3246 * For one-to-many style sockets this para 3163 * For one-to-many style sockets this parameter indicates which
3247 * association the user is performing an a 3164 * association the user is performing an action upon. Note that if
3248 * this field's value is zero then the end 3165 * this field's value is zero then the endpoints default value is
3249 * changed (effecting future associations 3166 * changed (effecting future associations only).
3250 * assoc_value: This parameter specifies the 3167 * assoc_value: This parameter specifies the maximum size in bytes.
3251 */ 3168 */
3252 static int sctp_setsockopt_maxseg(struct sock !! 3169 static int sctp_setsockopt_maxseg(struct sock *sk, char __user *optval, unsigned int optlen)
3253 struct sctp <<
3254 unsigned in <<
3255 { 3170 {
3256 struct sctp_sock *sp = sctp_sk(sk); 3171 struct sctp_sock *sp = sctp_sk(sk);
>> 3172 struct sctp_assoc_value params;
3257 struct sctp_association *asoc; 3173 struct sctp_association *asoc;
3258 sctp_assoc_t assoc_id; <<
3259 int val; 3174 int val;
3260 3175
3261 if (optlen == sizeof(int)) { 3176 if (optlen == sizeof(int)) {
3262 pr_warn_ratelimited(DEPRECATE 3177 pr_warn_ratelimited(DEPRECATED
3263 "%s (pid 3178 "%s (pid %d) "
3264 "Use of i 3179 "Use of int in maxseg socket option.\n"
3265 "Use stru 3180 "Use struct sctp_assoc_value instead\n",
3266 current-> 3181 current->comm, task_pid_nr(current));
3267 assoc_id = SCTP_FUTURE_ASSOC; !! 3182 if (copy_from_user(&val, optval, optlen))
3268 val = *(int *)params; !! 3183 return -EFAULT;
>> 3184 params.assoc_id = 0;
3269 } else if (optlen == sizeof(struct sc 3185 } else if (optlen == sizeof(struct sctp_assoc_value)) {
3270 assoc_id = params->assoc_id; !! 3186 if (copy_from_user(¶ms, optval, optlen))
3271 val = params->assoc_value; !! 3187 return -EFAULT;
>> 3188 val = params.assoc_value;
3272 } else { 3189 } else {
3273 return -EINVAL; 3190 return -EINVAL;
3274 } 3191 }
3275 3192
3276 asoc = sctp_id2assoc(sk, assoc_id); <<
3277 if (!asoc && assoc_id != SCTP_FUTURE_ <<
3278 sctp_style(sk, UDP)) <<
3279 return -EINVAL; <<
3280 <<
3281 if (val) { 3193 if (val) {
3282 int min_len, max_len; 3194 int min_len, max_len;
3283 __u16 datasize = asoc ? sctp_ <<
3284 sizeof(struc <<
3285 3195
3286 min_len = sctp_min_frag_point !! 3196 min_len = SCTP_DEFAULT_MINSEGMENT - sp->pf->af->net_header_len;
3287 max_len = SCTP_MAX_CHUNK_LEN !! 3197 min_len -= sizeof(struct sctphdr) +
>> 3198 sizeof(struct sctp_data_chunk);
>> 3199
>> 3200 max_len = SCTP_MAX_CHUNK_LEN - sizeof(struct sctp_data_chunk);
3288 3201
3289 if (val < min_len || val > ma 3202 if (val < min_len || val > max_len)
3290 return -EINVAL; 3203 return -EINVAL;
3291 } 3204 }
3292 3205
>> 3206 asoc = sctp_id2assoc(sk, params.assoc_id);
3293 if (asoc) { 3207 if (asoc) {
>> 3208 if (val == 0) {
>> 3209 val = asoc->pathmtu - sp->pf->af->net_header_len;
>> 3210 val -= sizeof(struct sctphdr) +
>> 3211 sizeof(struct sctp_data_chunk);
>> 3212 }
3294 asoc->user_frag = val; 3213 asoc->user_frag = val;
3295 sctp_assoc_update_frag_point( !! 3214 asoc->frag_point = sctp_frag_point(asoc, asoc->pathmtu);
3296 } else { 3215 } else {
>> 3216 if (params.assoc_id && sctp_style(sk, UDP))
>> 3217 return -EINVAL;
3297 sp->user_frag = val; 3218 sp->user_frag = val;
3298 } 3219 }
3299 3220
3300 return 0; 3221 return 0;
3301 } 3222 }
3302 3223
3303 3224
3304 /* 3225 /*
3305 * 7.1.9 Set Peer Primary Address (SCTP_SET_ 3226 * 7.1.9 Set Peer Primary Address (SCTP_SET_PEER_PRIMARY_ADDR)
3306 * 3227 *
3307 * Requests that the peer mark the enclosed 3228 * Requests that the peer mark the enclosed address as the association
3308 * primary. The enclosed address must be on 3229 * primary. The enclosed address must be one of the association's
3309 * locally bound addresses. The following s 3230 * locally bound addresses. The following structure is used to make a
3310 * set primary request: 3231 * set primary request:
3311 */ 3232 */
3312 static int sctp_setsockopt_peer_primary_addr( !! 3233 static int sctp_setsockopt_peer_primary_addr(struct sock *sk, char __user *optval,
3313 <<
3314 3234 unsigned int optlen)
3315 { 3235 {
>> 3236 struct net *net = sock_net(sk);
3316 struct sctp_sock *sp; 3237 struct sctp_sock *sp;
3317 struct sctp_association *asoc = NULL; 3238 struct sctp_association *asoc = NULL;
>> 3239 struct sctp_setpeerprim prim;
3318 struct sctp_chunk *chunk; 3240 struct sctp_chunk *chunk;
3319 struct sctp_af *af; 3241 struct sctp_af *af;
3320 int err; 3242 int err;
3321 3243
3322 sp = sctp_sk(sk); 3244 sp = sctp_sk(sk);
3323 3245
3324 if (!sp->ep->asconf_enable) !! 3246 if (!net->sctp.addip_enable)
3325 return -EPERM; 3247 return -EPERM;
3326 3248
3327 if (optlen != sizeof(struct sctp_setp 3249 if (optlen != sizeof(struct sctp_setpeerprim))
3328 return -EINVAL; 3250 return -EINVAL;
3329 3251
3330 asoc = sctp_id2assoc(sk, prim->sspp_a !! 3252 if (copy_from_user(&prim, optval, optlen))
>> 3253 return -EFAULT;
>> 3254
>> 3255 asoc = sctp_id2assoc(sk, prim.sspp_assoc_id);
3331 if (!asoc) 3256 if (!asoc)
3332 return -EINVAL; 3257 return -EINVAL;
3333 3258
3334 if (!asoc->peer.asconf_capable) 3259 if (!asoc->peer.asconf_capable)
3335 return -EPERM; 3260 return -EPERM;
3336 3261
3337 if (asoc->peer.addip_disabled_mask & 3262 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_SET_PRIMARY)
3338 return -EPERM; 3263 return -EPERM;
3339 3264
3340 if (!sctp_state(asoc, ESTABLISHED)) 3265 if (!sctp_state(asoc, ESTABLISHED))
3341 return -ENOTCONN; 3266 return -ENOTCONN;
3342 3267
3343 af = sctp_get_af_specific(prim->sspp_ !! 3268 af = sctp_get_af_specific(prim.sspp_addr.ss_family);
3344 if (!af) 3269 if (!af)
3345 return -EINVAL; 3270 return -EINVAL;
3346 3271
3347 if (!af->addr_valid((union sctp_addr !! 3272 if (!af->addr_valid((union sctp_addr *)&prim.sspp_addr, sp, NULL))
3348 return -EADDRNOTAVAIL; 3273 return -EADDRNOTAVAIL;
3349 3274
3350 if (!sctp_assoc_lookup_laddr(asoc, (u !! 3275 if (!sctp_assoc_lookup_laddr(asoc, (union sctp_addr *)&prim.sspp_addr))
3351 return -EADDRNOTAVAIL; 3276 return -EADDRNOTAVAIL;
3352 3277
3353 /* Allow security module to validate <<
3354 err = security_sctp_bind_connect(sk, <<
3355 (str <<
3356 af-> <<
3357 if (err) <<
3358 return err; <<
3359 <<
3360 /* Create an ASCONF chunk with SET_PR 3278 /* Create an ASCONF chunk with SET_PRIMARY parameter */
3361 chunk = sctp_make_asconf_set_prim(aso 3279 chunk = sctp_make_asconf_set_prim(asoc,
3362 (un !! 3280 (union sctp_addr *)&prim.sspp_addr);
3363 if (!chunk) 3281 if (!chunk)
3364 return -ENOMEM; 3282 return -ENOMEM;
3365 3283
3366 err = sctp_send_asconf(asoc, chunk); 3284 err = sctp_send_asconf(asoc, chunk);
3367 3285
3368 pr_debug("%s: we set peer primary add 3286 pr_debug("%s: we set peer primary addr primitively\n", __func__);
3369 3287
3370 return err; 3288 return err;
3371 } 3289 }
3372 3290
3373 static int sctp_setsockopt_adaptation_layer(s !! 3291 static int sctp_setsockopt_adaptation_layer(struct sock *sk, char __user *optval,
3374 s <<
3375 u 3292 unsigned int optlen)
3376 { 3293 {
>> 3294 struct sctp_setadaptation adaptation;
>> 3295
3377 if (optlen != sizeof(struct sctp_seta 3296 if (optlen != sizeof(struct sctp_setadaptation))
3378 return -EINVAL; 3297 return -EINVAL;
>> 3298 if (copy_from_user(&adaptation, optval, optlen))
>> 3299 return -EFAULT;
3379 3300
3380 sctp_sk(sk)->adaptation_ind = adapt-> !! 3301 sctp_sk(sk)->adaptation_ind = adaptation.ssb_adaptation_ind;
3381 3302
3382 return 0; 3303 return 0;
3383 } 3304 }
3384 3305
3385 /* 3306 /*
3386 * 7.1.29. Set or Get the default context (S 3307 * 7.1.29. Set or Get the default context (SCTP_CONTEXT)
3387 * 3308 *
3388 * The context field in the sctp_sndrcvinfo s 3309 * The context field in the sctp_sndrcvinfo structure is normally only
3389 * used when a failed message is retrieved ho 3310 * used when a failed message is retrieved holding the value that was
3390 * sent down on the actual send call. This o 3311 * sent down on the actual send call. This option allows the setting of
3391 * a default context on an association basis 3312 * a default context on an association basis that will be received on
3392 * reading messages from the peer. This is e 3313 * reading messages from the peer. This is especially helpful in the
3393 * one-2-many model for an application to kee 3314 * one-2-many model for an application to keep some reference to an
3394 * internal state machine that is processing 3315 * internal state machine that is processing messages on the
3395 * association. Note that the setting of thi 3316 * association. Note that the setting of this value only effects
3396 * received messages from the peer and does n 3317 * received messages from the peer and does not effect the value that is
3397 * saved with outbound messages. 3318 * saved with outbound messages.
3398 */ 3319 */
3399 static int sctp_setsockopt_context(struct soc !! 3320 static int sctp_setsockopt_context(struct sock *sk, char __user *optval,
3400 struct sct <<
3401 unsigned i 3321 unsigned int optlen)
3402 { 3322 {
3403 struct sctp_sock *sp = sctp_sk(sk); !! 3323 struct sctp_assoc_value params;
>> 3324 struct sctp_sock *sp;
3404 struct sctp_association *asoc; 3325 struct sctp_association *asoc;
3405 3326
3406 if (optlen != sizeof(struct sctp_asso 3327 if (optlen != sizeof(struct sctp_assoc_value))
3407 return -EINVAL; 3328 return -EINVAL;
>> 3329 if (copy_from_user(¶ms, optval, optlen))
>> 3330 return -EFAULT;
3408 3331
3409 asoc = sctp_id2assoc(sk, params->asso !! 3332 sp = sctp_sk(sk);
3410 if (!asoc && params->assoc_id > SCTP_ <<
3411 sctp_style(sk, UDP)) <<
3412 return -EINVAL; <<
3413 <<
3414 if (asoc) { <<
3415 asoc->default_rcv_context = p <<
3416 3333
3417 return 0; !! 3334 if (params.assoc_id != 0) {
>> 3335 asoc = sctp_id2assoc(sk, params.assoc_id);
>> 3336 if (!asoc)
>> 3337 return -EINVAL;
>> 3338 asoc->default_rcv_context = params.assoc_value;
>> 3339 } else {
>> 3340 sp->default_rcv_context = params.assoc_value;
3418 } 3341 }
3419 3342
3420 if (sctp_style(sk, TCP)) <<
3421 params->assoc_id = SCTP_FUTUR <<
3422 <<
3423 if (params->assoc_id == SCTP_FUTURE_A <<
3424 params->assoc_id == SCTP_ALL_ASSO <<
3425 sp->default_rcv_context = par <<
3426 <<
3427 if (params->assoc_id == SCTP_CURRENT_ <<
3428 params->assoc_id == SCTP_ALL_ASSO <<
3429 list_for_each_entry(asoc, &sp <<
3430 asoc->default_rcv_con <<
3431 <<
3432 return 0; 3343 return 0;
3433 } 3344 }
3434 3345
3435 /* 3346 /*
3436 * 7.1.24. Get or set fragmented interleave 3347 * 7.1.24. Get or set fragmented interleave (SCTP_FRAGMENT_INTERLEAVE)
3437 * 3348 *
3438 * This options will at a minimum specify if 3349 * This options will at a minimum specify if the implementation is doing
3439 * fragmented interleave. Fragmented interle 3350 * fragmented interleave. Fragmented interleave, for a one to many
3440 * socket, is when subsequent calls to receiv 3351 * socket, is when subsequent calls to receive a message may return
3441 * parts of messages from different associati 3352 * parts of messages from different associations. Some implementations
3442 * may allow you to turn this value on or off 3353 * may allow you to turn this value on or off. If so, when turned off,
3443 * no fragment interleave will occur (which w 3354 * no fragment interleave will occur (which will cause a head of line
3444 * blocking amongst multiple associations sha 3355 * blocking amongst multiple associations sharing the same one to many
3445 * socket). When this option is turned on, t 3356 * socket). When this option is turned on, then each receive call may
3446 * come from a different association (thus th 3357 * come from a different association (thus the user must receive data
3447 * with the extended calls (e.g. sctp_recvmsg 3358 * with the extended calls (e.g. sctp_recvmsg) to keep track of which
3448 * association each receive belongs to. 3359 * association each receive belongs to.
3449 * 3360 *
3450 * This option takes a boolean value. A non- 3361 * This option takes a boolean value. A non-zero value indicates that
3451 * fragmented interleave is on. A value of z 3362 * fragmented interleave is on. A value of zero indicates that
3452 * fragmented interleave is off. 3363 * fragmented interleave is off.
3453 * 3364 *
3454 * Note that it is important that an implemen 3365 * Note that it is important that an implementation that allows this
3455 * option to be turned on, have it off by def 3366 * option to be turned on, have it off by default. Otherwise an unaware
3456 * application using the one to many model ma 3367 * application using the one to many model may become confused and act
3457 * incorrectly. 3368 * incorrectly.
3458 */ 3369 */
3459 static int sctp_setsockopt_fragment_interleav !! 3370 static int sctp_setsockopt_fragment_interleave(struct sock *sk,
>> 3371 char __user *optval,
3460 3372 unsigned int optlen)
3461 { 3373 {
>> 3374 int val;
>> 3375
3462 if (optlen != sizeof(int)) 3376 if (optlen != sizeof(int))
3463 return -EINVAL; 3377 return -EINVAL;
>> 3378 if (get_user(val, (int __user *)optval))
>> 3379 return -EFAULT;
3464 3380
3465 sctp_sk(sk)->frag_interleave = !!*val !! 3381 sctp_sk(sk)->frag_interleave = (val == 0) ? 0 : 1;
3466 <<
3467 if (!sctp_sk(sk)->frag_interleave) <<
3468 sctp_sk(sk)->ep->intl_enable <<
3469 3382
3470 return 0; 3383 return 0;
3471 } 3384 }
3472 3385
3473 /* 3386 /*
3474 * 8.1.21. Set or Get the SCTP Partial Deliv 3387 * 8.1.21. Set or Get the SCTP Partial Delivery Point
3475 * (SCTP_PARTIAL_DELIVERY_POINT) 3388 * (SCTP_PARTIAL_DELIVERY_POINT)
3476 * 3389 *
3477 * This option will set or get the SCTP parti 3390 * This option will set or get the SCTP partial delivery point. This
3478 * point is the size of a message where the p 3391 * point is the size of a message where the partial delivery API will be
3479 * invoked to help free up rwnd space for the 3392 * invoked to help free up rwnd space for the peer. Setting this to a
3480 * lower value will cause partial deliveries 3393 * lower value will cause partial deliveries to happen more often. The
3481 * calls argument is an integer that sets or 3394 * calls argument is an integer that sets or gets the partial delivery
3482 * point. Note also that the call will fail 3395 * point. Note also that the call will fail if the user attempts to set
3483 * this value larger than the socket receive 3396 * this value larger than the socket receive buffer size.
3484 * 3397 *
3485 * Note that any single message having a leng 3398 * Note that any single message having a length smaller than or equal to
3486 * the SCTP partial delivery point will be de 3399 * the SCTP partial delivery point will be delivered in one single read
3487 * call as long as the user provided buffer i 3400 * call as long as the user provided buffer is large enough to hold the
3488 * message. 3401 * message.
3489 */ 3402 */
3490 static int sctp_setsockopt_partial_delivery_p !! 3403 static int sctp_setsockopt_partial_delivery_point(struct sock *sk,
>> 3404 char __user *optval,
3491 3405 unsigned int optlen)
3492 { 3406 {
>> 3407 u32 val;
>> 3408
3493 if (optlen != sizeof(u32)) 3409 if (optlen != sizeof(u32))
3494 return -EINVAL; 3410 return -EINVAL;
>> 3411 if (get_user(val, (int __user *)optval))
>> 3412 return -EFAULT;
3495 3413
3496 /* Note: We double the receive buffer 3414 /* Note: We double the receive buffer from what the user sets
3497 * it to be, also initial rwnd is bas 3415 * it to be, also initial rwnd is based on rcvbuf/2.
3498 */ 3416 */
3499 if (*val > (sk->sk_rcvbuf >> 1)) !! 3417 if (val > (sk->sk_rcvbuf >> 1))
3500 return -EINVAL; 3418 return -EINVAL;
3501 3419
3502 sctp_sk(sk)->pd_point = *val; !! 3420 sctp_sk(sk)->pd_point = val;
3503 3421
3504 return 0; /* is this the right error 3422 return 0; /* is this the right error code? */
3505 } 3423 }
3506 3424
3507 /* 3425 /*
3508 * 7.1.28. Set or Get the maximum burst (SCT 3426 * 7.1.28. Set or Get the maximum burst (SCTP_MAX_BURST)
3509 * 3427 *
3510 * This option will allow a user to change th 3428 * This option will allow a user to change the maximum burst of packets
3511 * that can be emitted by this association. 3429 * that can be emitted by this association. Note that the default value
3512 * is 4, and some implementations may restric 3430 * is 4, and some implementations may restrict this setting so that it
3513 * can only be lowered. 3431 * can only be lowered.
3514 * 3432 *
3515 * NOTE: This text doesn't seem right. Do th 3433 * NOTE: This text doesn't seem right. Do this on a socket basis with
3516 * future associations inheriting the socket 3434 * future associations inheriting the socket value.
3517 */ 3435 */
3518 static int sctp_setsockopt_maxburst(struct so 3436 static int sctp_setsockopt_maxburst(struct sock *sk,
3519 struct sc !! 3437 char __user *optval,
3520 unsigned 3438 unsigned int optlen)
3521 { 3439 {
3522 struct sctp_sock *sp = sctp_sk(sk); !! 3440 struct sctp_assoc_value params;
>> 3441 struct sctp_sock *sp;
3523 struct sctp_association *asoc; 3442 struct sctp_association *asoc;
3524 sctp_assoc_t assoc_id; !! 3443 int val;
3525 u32 assoc_value; !! 3444 int assoc_id = 0;
3526 3445
3527 if (optlen == sizeof(int)) { 3446 if (optlen == sizeof(int)) {
3528 pr_warn_ratelimited(DEPRECATE 3447 pr_warn_ratelimited(DEPRECATED
3529 "%s (pid 3448 "%s (pid %d) "
3530 "Use of i 3449 "Use of int in max_burst socket option deprecated.\n"
3531 "Use stru 3450 "Use struct sctp_assoc_value instead\n",
3532 current-> 3451 current->comm, task_pid_nr(current));
3533 assoc_id = SCTP_FUTURE_ASSOC; !! 3452 if (copy_from_user(&val, optval, optlen))
3534 assoc_value = *((int *)params !! 3453 return -EFAULT;
3535 } else if (optlen == sizeof(struct sc 3454 } else if (optlen == sizeof(struct sctp_assoc_value)) {
3536 assoc_id = params->assoc_id; !! 3455 if (copy_from_user(¶ms, optval, optlen))
3537 assoc_value = params->assoc_v !! 3456 return -EFAULT;
>> 3457 val = params.assoc_value;
>> 3458 assoc_id = params.assoc_id;
3538 } else 3459 } else
3539 return -EINVAL; 3460 return -EINVAL;
3540 3461
3541 asoc = sctp_id2assoc(sk, assoc_id); !! 3462 sp = sctp_sk(sk);
3542 if (!asoc && assoc_id > SCTP_ALL_ASSO <<
3543 return -EINVAL; <<
3544 <<
3545 if (asoc) { <<
3546 asoc->max_burst = assoc_value <<
3547 <<
3548 return 0; <<
3549 } <<
3550 <<
3551 if (sctp_style(sk, TCP)) <<
3552 assoc_id = SCTP_FUTURE_ASSOC; <<
3553 <<
3554 if (assoc_id == SCTP_FUTURE_ASSOC || <<
3555 sp->max_burst = assoc_value; <<
3556 3463
3557 if (assoc_id == SCTP_CURRENT_ASSOC || !! 3464 if (assoc_id != 0) {
3558 list_for_each_entry(asoc, &sp !! 3465 asoc = sctp_id2assoc(sk, assoc_id);
3559 asoc->max_burst = ass !! 3466 if (!asoc)
>> 3467 return -EINVAL;
>> 3468 asoc->max_burst = val;
>> 3469 } else
>> 3470 sp->max_burst = val;
3560 3471
3561 return 0; 3472 return 0;
3562 } 3473 }
3563 3474
3564 /* 3475 /*
3565 * 7.1.18. Add a chunk that must be authenti 3476 * 7.1.18. Add a chunk that must be authenticated (SCTP_AUTH_CHUNK)
3566 * 3477 *
3567 * This set option adds a chunk type that the 3478 * This set option adds a chunk type that the user is requesting to be
3568 * received only in an authenticated way. Ch 3479 * received only in an authenticated way. Changes to the list of chunks
3569 * will only effect future associations on th 3480 * will only effect future associations on the socket.
3570 */ 3481 */
3571 static int sctp_setsockopt_auth_chunk(struct 3482 static int sctp_setsockopt_auth_chunk(struct sock *sk,
3572 struct !! 3483 char __user *optval,
3573 unsigne 3484 unsigned int optlen)
3574 { 3485 {
3575 struct sctp_endpoint *ep = sctp_sk(sk 3486 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
>> 3487 struct sctp_authchunk val;
3576 3488
3577 if (!ep->auth_enable) 3489 if (!ep->auth_enable)
3578 return -EACCES; 3490 return -EACCES;
3579 3491
3580 if (optlen != sizeof(struct sctp_auth 3492 if (optlen != sizeof(struct sctp_authchunk))
3581 return -EINVAL; 3493 return -EINVAL;
>> 3494 if (copy_from_user(&val, optval, optlen))
>> 3495 return -EFAULT;
3582 3496
3583 switch (val->sauth_chunk) { !! 3497 switch (val.sauth_chunk) {
3584 case SCTP_CID_INIT: 3498 case SCTP_CID_INIT:
3585 case SCTP_CID_INIT_ACK: 3499 case SCTP_CID_INIT_ACK:
3586 case SCTP_CID_SHUTDOWN_COMPLETE: 3500 case SCTP_CID_SHUTDOWN_COMPLETE:
3587 case SCTP_CID_AUTH: 3501 case SCTP_CID_AUTH:
3588 return -EINVAL; 3502 return -EINVAL;
3589 } 3503 }
3590 3504
3591 /* add this chunk id to the endpoint 3505 /* add this chunk id to the endpoint */
3592 return sctp_auth_ep_add_chunkid(ep, v !! 3506 return sctp_auth_ep_add_chunkid(ep, val.sauth_chunk);
3593 } 3507 }
3594 3508
3595 /* 3509 /*
3596 * 7.1.19. Get or set the list of supported 3510 * 7.1.19. Get or set the list of supported HMAC Identifiers (SCTP_HMAC_IDENT)
3597 * 3511 *
3598 * This option gets or sets the list of HMAC 3512 * This option gets or sets the list of HMAC algorithms that the local
3599 * endpoint requires the peer to use. 3513 * endpoint requires the peer to use.
3600 */ 3514 */
3601 static int sctp_setsockopt_hmac_ident(struct 3515 static int sctp_setsockopt_hmac_ident(struct sock *sk,
3602 struct !! 3516 char __user *optval,
3603 unsigne 3517 unsigned int optlen)
3604 { 3518 {
3605 struct sctp_endpoint *ep = sctp_sk(sk 3519 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
>> 3520 struct sctp_hmacalgo *hmacs;
3606 u32 idents; 3521 u32 idents;
>> 3522 int err;
3607 3523
3608 if (!ep->auth_enable) 3524 if (!ep->auth_enable)
3609 return -EACCES; 3525 return -EACCES;
3610 3526
3611 if (optlen < sizeof(struct sctp_hmaca 3527 if (optlen < sizeof(struct sctp_hmacalgo))
3612 return -EINVAL; 3528 return -EINVAL;
3613 optlen = min_t(unsigned int, optlen, 3529 optlen = min_t(unsigned int, optlen, sizeof(struct sctp_hmacalgo) +
3614 3530 SCTP_AUTH_NUM_HMACS * sizeof(u16));
3615 3531
>> 3532 hmacs = memdup_user(optval, optlen);
>> 3533 if (IS_ERR(hmacs))
>> 3534 return PTR_ERR(hmacs);
>> 3535
3616 idents = hmacs->shmac_num_idents; 3536 idents = hmacs->shmac_num_idents;
3617 if (idents == 0 || idents > SCTP_AUTH 3537 if (idents == 0 || idents > SCTP_AUTH_NUM_HMACS ||
3618 (idents * sizeof(u16)) > (optlen !! 3538 (idents * sizeof(u16)) > (optlen - sizeof(struct sctp_hmacalgo))) {
3619 return -EINVAL; !! 3539 err = -EINVAL;
>> 3540 goto out;
>> 3541 }
3620 3542
3621 return sctp_auth_ep_set_hmacs(ep, hma !! 3543 err = sctp_auth_ep_set_hmacs(ep, hmacs);
>> 3544 out:
>> 3545 kfree(hmacs);
>> 3546 return err;
3622 } 3547 }
3623 3548
3624 /* 3549 /*
3625 * 7.1.20. Set a shared key (SCTP_AUTH_KEY) 3550 * 7.1.20. Set a shared key (SCTP_AUTH_KEY)
3626 * 3551 *
3627 * This option will set a shared secret key w 3552 * This option will set a shared secret key which is used to build an
3628 * association shared key. 3553 * association shared key.
3629 */ 3554 */
3630 static int sctp_setsockopt_auth_key(struct so 3555 static int sctp_setsockopt_auth_key(struct sock *sk,
3631 struct sc !! 3556 char __user *optval,
3632 unsigned 3557 unsigned int optlen)
3633 { 3558 {
3634 struct sctp_endpoint *ep = sctp_sk(sk 3559 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
>> 3560 struct sctp_authkey *authkey;
3635 struct sctp_association *asoc; 3561 struct sctp_association *asoc;
3636 int ret = -EINVAL; !! 3562 int ret;
>> 3563
>> 3564 if (!ep->auth_enable)
>> 3565 return -EACCES;
3637 3566
3638 if (optlen <= sizeof(struct sctp_auth 3567 if (optlen <= sizeof(struct sctp_authkey))
3639 return -EINVAL; 3568 return -EINVAL;
3640 /* authkey->sca_keylength is u16, so 3569 /* authkey->sca_keylength is u16, so optlen can't be bigger than
3641 * this. 3570 * this.
3642 */ 3571 */
3643 optlen = min_t(unsigned int, optlen, !! 3572 optlen = min_t(unsigned int, optlen, USHRT_MAX +
>> 3573 sizeof(struct sctp_authkey));
3644 3574
3645 if (authkey->sca_keylength > optlen - !! 3575 authkey = memdup_user(optval, optlen);
3646 goto out; !! 3576 if (IS_ERR(authkey))
>> 3577 return PTR_ERR(authkey);
3647 3578
3648 asoc = sctp_id2assoc(sk, authkey->sca !! 3579 if (authkey->sca_keylength > optlen - sizeof(struct sctp_authkey)) {
3649 if (!asoc && authkey->sca_assoc_id > !! 3580 ret = -EINVAL;
3650 sctp_style(sk, UDP)) <<
3651 goto out; <<
3652 <<
3653 if (asoc) { <<
3654 ret = sctp_auth_set_key(ep, a <<
3655 goto out; 3581 goto out;
3656 } 3582 }
3657 3583
3658 if (sctp_style(sk, TCP)) !! 3584 asoc = sctp_id2assoc(sk, authkey->sca_assoc_id);
3659 authkey->sca_assoc_id = SCTP_ !! 3585 if (!asoc && authkey->sca_assoc_id && sctp_style(sk, UDP)) {
3660 !! 3586 ret = -EINVAL;
3661 if (authkey->sca_assoc_id == SCTP_FUT !! 3587 goto out;
3662 authkey->sca_assoc_id == SCTP_ALL <<
3663 ret = sctp_auth_set_key(ep, a <<
3664 if (ret) <<
3665 goto out; <<
3666 } <<
3667 <<
3668 ret = 0; <<
3669 <<
3670 if (authkey->sca_assoc_id == SCTP_CUR <<
3671 authkey->sca_assoc_id == SCTP_ALL <<
3672 list_for_each_entry(asoc, &ep <<
3673 int res = sctp_auth_s <<
3674 <<
3675 if (res && !ret) <<
3676 ret = res; <<
3677 } <<
3678 } 3588 }
3679 3589
>> 3590 ret = sctp_auth_set_key(ep, asoc, authkey);
3680 out: 3591 out:
3681 memzero_explicit(authkey, optlen); !! 3592 kzfree(authkey);
3682 return ret; 3593 return ret;
3683 } 3594 }
3684 3595
3685 /* 3596 /*
3686 * 7.1.21. Get or set the active shared key 3597 * 7.1.21. Get or set the active shared key (SCTP_AUTH_ACTIVE_KEY)
3687 * 3598 *
3688 * This option will get or set the active sha 3599 * This option will get or set the active shared key to be used to build
3689 * the association shared key. 3600 * the association shared key.
3690 */ 3601 */
3691 static int sctp_setsockopt_active_key(struct 3602 static int sctp_setsockopt_active_key(struct sock *sk,
3692 struct !! 3603 char __user *optval,
3693 unsigne 3604 unsigned int optlen)
3694 { 3605 {
3695 struct sctp_endpoint *ep = sctp_sk(sk 3606 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
>> 3607 struct sctp_authkeyid val;
3696 struct sctp_association *asoc; 3608 struct sctp_association *asoc;
3697 int ret = 0; !! 3609
>> 3610 if (!ep->auth_enable)
>> 3611 return -EACCES;
3698 3612
3699 if (optlen != sizeof(struct sctp_auth 3613 if (optlen != sizeof(struct sctp_authkeyid))
3700 return -EINVAL; 3614 return -EINVAL;
>> 3615 if (copy_from_user(&val, optval, optlen))
>> 3616 return -EFAULT;
3701 3617
3702 asoc = sctp_id2assoc(sk, val->scact_a !! 3618 asoc = sctp_id2assoc(sk, val.scact_assoc_id);
3703 if (!asoc && val->scact_assoc_id > SC !! 3619 if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP))
3704 sctp_style(sk, UDP)) <<
3705 return -EINVAL; 3620 return -EINVAL;
3706 3621
3707 if (asoc) !! 3622 return sctp_auth_set_active_key(ep, asoc, val.scact_keynumber);
3708 return sctp_auth_set_active_k <<
3709 <<
3710 if (sctp_style(sk, TCP)) <<
3711 val->scact_assoc_id = SCTP_FU <<
3712 <<
3713 if (val->scact_assoc_id == SCTP_FUTUR <<
3714 val->scact_assoc_id == SCTP_ALL_A <<
3715 ret = sctp_auth_set_active_ke <<
3716 if (ret) <<
3717 return ret; <<
3718 } <<
3719 <<
3720 if (val->scact_assoc_id == SCTP_CURRE <<
3721 val->scact_assoc_id == SCTP_ALL_A <<
3722 list_for_each_entry(asoc, &ep <<
3723 int res = sctp_auth_s <<
3724 <<
3725 <<
3726 if (res && !ret) <<
3727 ret = res; <<
3728 } <<
3729 } <<
3730 <<
3731 return ret; <<
3732 } 3623 }
3733 3624
3734 /* 3625 /*
3735 * 7.1.22. Delete a shared key (SCTP_AUTH_DE 3626 * 7.1.22. Delete a shared key (SCTP_AUTH_DELETE_KEY)
3736 * 3627 *
3737 * This set option will delete a shared secre 3628 * This set option will delete a shared secret key from use.
3738 */ 3629 */
3739 static int sctp_setsockopt_del_key(struct soc 3630 static int sctp_setsockopt_del_key(struct sock *sk,
3740 struct sct !! 3631 char __user *optval,
3741 unsigned i 3632 unsigned int optlen)
3742 { 3633 {
3743 struct sctp_endpoint *ep = sctp_sk(sk 3634 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
>> 3635 struct sctp_authkeyid val;
3744 struct sctp_association *asoc; 3636 struct sctp_association *asoc;
3745 int ret = 0; <<
3746 <<
3747 if (optlen != sizeof(struct sctp_auth <<
3748 return -EINVAL; <<
3749 3637
3750 asoc = sctp_id2assoc(sk, val->scact_a !! 3638 if (!ep->auth_enable)
3751 if (!asoc && val->scact_assoc_id > SC !! 3639 return -EACCES;
3752 sctp_style(sk, UDP)) <<
3753 return -EINVAL; <<
3754 <<
3755 if (asoc) <<
3756 return sctp_auth_del_key_id(e <<
3757 <<
3758 if (sctp_style(sk, TCP)) <<
3759 val->scact_assoc_id = SCTP_FU <<
3760 <<
3761 if (val->scact_assoc_id == SCTP_FUTUR <<
3762 val->scact_assoc_id == SCTP_ALL_A <<
3763 ret = sctp_auth_del_key_id(ep <<
3764 if (ret) <<
3765 return ret; <<
3766 } <<
3767 <<
3768 if (val->scact_assoc_id == SCTP_CURRE <<
3769 val->scact_assoc_id == SCTP_ALL_A <<
3770 list_for_each_entry(asoc, &ep <<
3771 int res = sctp_auth_d <<
3772 <<
3773 <<
3774 if (res && !ret) <<
3775 ret = res; <<
3776 } <<
3777 } <<
3778 <<
3779 return ret; <<
3780 } <<
3781 <<
3782 /* <<
3783 * 8.3.4 Deactivate a Shared Key (SCTP_AUTH_ <<
3784 * <<
3785 * This set option will deactivate a shared s <<
3786 */ <<
3787 static int sctp_setsockopt_deactivate_key(str <<
3788 str <<
3789 uns <<
3790 { <<
3791 struct sctp_endpoint *ep = sctp_sk(sk <<
3792 struct sctp_association *asoc; <<
3793 int ret = 0; <<
3794 3640
3795 if (optlen != sizeof(struct sctp_auth 3641 if (optlen != sizeof(struct sctp_authkeyid))
3796 return -EINVAL; 3642 return -EINVAL;
>> 3643 if (copy_from_user(&val, optval, optlen))
>> 3644 return -EFAULT;
3797 3645
3798 asoc = sctp_id2assoc(sk, val->scact_a !! 3646 asoc = sctp_id2assoc(sk, val.scact_assoc_id);
3799 if (!asoc && val->scact_assoc_id > SC !! 3647 if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP))
3800 sctp_style(sk, UDP)) <<
3801 return -EINVAL; 3648 return -EINVAL;
3802 3649
3803 if (asoc) !! 3650 return sctp_auth_del_key_id(ep, asoc, val.scact_keynumber);
3804 return sctp_auth_deact_key_id <<
3805 <<
3806 if (sctp_style(sk, TCP)) <<
3807 val->scact_assoc_id = SCTP_FU <<
3808 <<
3809 if (val->scact_assoc_id == SCTP_FUTUR <<
3810 val->scact_assoc_id == SCTP_ALL_A <<
3811 ret = sctp_auth_deact_key_id( <<
3812 if (ret) <<
3813 return ret; <<
3814 } <<
3815 <<
3816 if (val->scact_assoc_id == SCTP_CURRE <<
3817 val->scact_assoc_id == SCTP_ALL_A <<
3818 list_for_each_entry(asoc, &ep <<
3819 int res = sctp_auth_d <<
3820 <<
3821 <<
3822 if (res && !ret) <<
3823 ret = res; <<
3824 } <<
3825 } <<
3826 3651
3827 return ret; <<
3828 } 3652 }
3829 3653
3830 /* 3654 /*
3831 * 8.1.23 SCTP_AUTO_ASCONF 3655 * 8.1.23 SCTP_AUTO_ASCONF
3832 * 3656 *
3833 * This option will enable or disable the use 3657 * This option will enable or disable the use of the automatic generation of
3834 * ASCONF chunks to add and delete addresses 3658 * ASCONF chunks to add and delete addresses to an existing association. Note
3835 * that this option has two caveats namely: a 3659 * that this option has two caveats namely: a) it only affects sockets that
3836 * are bound to all addresses available to th 3660 * are bound to all addresses available to the SCTP stack, and b) the system
3837 * administrator may have an overriding contr 3661 * administrator may have an overriding control that turns the ASCONF feature
3838 * off no matter what setting the socket opti 3662 * off no matter what setting the socket option may have.
3839 * This option expects an integer boolean fla 3663 * This option expects an integer boolean flag, where a non-zero value turns on
3840 * the option, and a zero value turns off the 3664 * the option, and a zero value turns off the option.
3841 * Note. In this implementation, socket opera 3665 * Note. In this implementation, socket operation overrides default parameter
3842 * being set by sysctl as well as FreeBSD imp 3666 * being set by sysctl as well as FreeBSD implementation
3843 */ 3667 */
3844 static int sctp_setsockopt_auto_asconf(struct !! 3668 static int sctp_setsockopt_auto_asconf(struct sock *sk, char __user *optval,
3845 unsig 3669 unsigned int optlen)
3846 { 3670 {
>> 3671 int val;
3847 struct sctp_sock *sp = sctp_sk(sk); 3672 struct sctp_sock *sp = sctp_sk(sk);
3848 3673
3849 if (optlen < sizeof(int)) 3674 if (optlen < sizeof(int))
3850 return -EINVAL; 3675 return -EINVAL;
3851 if (!sctp_is_ep_boundall(sk) && *val) !! 3676 if (get_user(val, (int __user *)optval))
>> 3677 return -EFAULT;
>> 3678 if (!sctp_is_ep_boundall(sk) && val)
3852 return -EINVAL; 3679 return -EINVAL;
3853 if ((*val && sp->do_auto_asconf) || ( !! 3680 if ((val && sp->do_auto_asconf) || (!val && !sp->do_auto_asconf))
3854 return 0; 3681 return 0;
3855 3682
3856 spin_lock_bh(&sock_net(sk)->sctp.addr 3683 spin_lock_bh(&sock_net(sk)->sctp.addr_wq_lock);
3857 if (*val == 0 && sp->do_auto_asconf) !! 3684 if (val == 0 && sp->do_auto_asconf) {
3858 list_del(&sp->auto_asconf_lis 3685 list_del(&sp->auto_asconf_list);
3859 sp->do_auto_asconf = 0; 3686 sp->do_auto_asconf = 0;
3860 } else if (*val && !sp->do_auto_ascon !! 3687 } else if (val && !sp->do_auto_asconf) {
3861 list_add_tail(&sp->auto_ascon 3688 list_add_tail(&sp->auto_asconf_list,
3862 &sock_net(sk)->sctp.auto_ 3689 &sock_net(sk)->sctp.auto_asconf_splist);
3863 sp->do_auto_asconf = 1; 3690 sp->do_auto_asconf = 1;
3864 } 3691 }
3865 spin_unlock_bh(&sock_net(sk)->sctp.ad 3692 spin_unlock_bh(&sock_net(sk)->sctp.addr_wq_lock);
3866 return 0; 3693 return 0;
3867 } 3694 }
3868 3695
3869 /* 3696 /*
3870 * SCTP_PEER_ADDR_THLDS 3697 * SCTP_PEER_ADDR_THLDS
3871 * 3698 *
3872 * This option allows us to alter the partial 3699 * This option allows us to alter the partially failed threshold for one or all
3873 * transports in an association. See Section 3700 * transports in an association. See Section 6.1 of:
3874 * http://www.ietf.org/id/draft-nishida-tsvwg 3701 * http://www.ietf.org/id/draft-nishida-tsvwg-sctp-failover-05.txt
3875 */ 3702 */
3876 static int sctp_setsockopt_paddr_thresholds(s 3703 static int sctp_setsockopt_paddr_thresholds(struct sock *sk,
3877 s !! 3704 char __user *optval,
3878 u !! 3705 unsigned int optlen)
3879 { 3706 {
>> 3707 struct sctp_paddrthlds val;
3880 struct sctp_transport *trans; 3708 struct sctp_transport *trans;
3881 struct sctp_association *asoc; 3709 struct sctp_association *asoc;
3882 int len; <<
3883 3710
3884 len = v2 ? sizeof(*val) : sizeof(stru !! 3711 if (optlen < sizeof(struct sctp_paddrthlds))
3885 if (optlen < len) <<
3886 return -EINVAL; 3712 return -EINVAL;
>> 3713 if (copy_from_user(&val, (struct sctp_paddrthlds __user *)optval,
>> 3714 sizeof(struct sctp_paddrthlds)))
>> 3715 return -EFAULT;
3887 3716
3888 if (v2 && val->spt_pathpfthld > val-> <<
3889 return -EINVAL; <<
3890 3717
3891 if (!sctp_is_any(sk, (const union sct !! 3718 if (sctp_is_any(sk, (const union sctp_addr *)&val.spt_address)) {
3892 trans = sctp_addr_id2transpor !! 3719 asoc = sctp_id2assoc(sk, val.spt_assoc_id);
3893 !! 3720 if (!asoc)
3894 if (!trans) <<
3895 return -ENOENT; 3721 return -ENOENT;
3896 <<
3897 if (val->spt_pathmaxrxt) <<
3898 trans->pathmaxrxt = v <<
3899 if (v2) <<
3900 trans->ps_retrans = v <<
3901 trans->pf_retrans = val->spt_ <<
3902 <<
3903 return 0; <<
3904 } <<
3905 <<
3906 asoc = sctp_id2assoc(sk, val->spt_ass <<
3907 if (!asoc && val->spt_assoc_id != SCT <<
3908 sctp_style(sk, UDP)) <<
3909 return -EINVAL; <<
3910 <<
3911 if (asoc) { <<
3912 list_for_each_entry(trans, &a 3722 list_for_each_entry(trans, &asoc->peer.transport_addr_list,
3913 transport 3723 transports) {
3914 if (val->spt_pathmaxr !! 3724 if (val.spt_pathmaxrxt)
3915 trans->pathma !! 3725 trans->pathmaxrxt = val.spt_pathmaxrxt;
3916 if (v2) !! 3726 trans->pf_retrans = val.spt_pathpfthld;
3917 trans->ps_ret <<
3918 trans->pf_retrans = v <<
3919 } 3727 }
3920 3728
3921 if (val->spt_pathmaxrxt) !! 3729 if (val.spt_pathmaxrxt)
3922 asoc->pathmaxrxt = va !! 3730 asoc->pathmaxrxt = val.spt_pathmaxrxt;
3923 if (v2) !! 3731 asoc->pf_retrans = val.spt_pathpfthld;
3924 asoc->ps_retrans = va <<
3925 asoc->pf_retrans = val->spt_p <<
3926 } else { 3732 } else {
3927 struct sctp_sock *sp = sctp_s !! 3733 trans = sctp_addr_id2transport(sk, &val.spt_address,
>> 3734 val.spt_assoc_id);
>> 3735 if (!trans)
>> 3736 return -ENOENT;
3928 3737
3929 if (val->spt_pathmaxrxt) !! 3738 if (val.spt_pathmaxrxt)
3930 sp->pathmaxrxt = val- !! 3739 trans->pathmaxrxt = val.spt_pathmaxrxt;
3931 if (v2) !! 3740 trans->pf_retrans = val.spt_pathpfthld;
3932 sp->ps_retrans = val- <<
3933 sp->pf_retrans = val->spt_pat <<
3934 } 3741 }
3935 3742
3936 return 0; 3743 return 0;
3937 } 3744 }
3938 3745
3939 static int sctp_setsockopt_recvrcvinfo(struct !! 3746 static int sctp_setsockopt_recvrcvinfo(struct sock *sk,
>> 3747 char __user *optval,
3940 unsign 3748 unsigned int optlen)
3941 { 3749 {
>> 3750 int val;
>> 3751
3942 if (optlen < sizeof(int)) 3752 if (optlen < sizeof(int))
3943 return -EINVAL; 3753 return -EINVAL;
>> 3754 if (get_user(val, (int __user *) optval))
>> 3755 return -EFAULT;
3944 3756
3945 sctp_sk(sk)->recvrcvinfo = (*val == 0 !! 3757 sctp_sk(sk)->recvrcvinfo = (val == 0) ? 0 : 1;
3946 3758
3947 return 0; 3759 return 0;
3948 } 3760 }
3949 3761
3950 static int sctp_setsockopt_recvnxtinfo(struct !! 3762 static int sctp_setsockopt_recvnxtinfo(struct sock *sk,
>> 3763 char __user *optval,
3951 unsign 3764 unsigned int optlen)
3952 { 3765 {
>> 3766 int val;
>> 3767
3953 if (optlen < sizeof(int)) 3768 if (optlen < sizeof(int))
3954 return -EINVAL; 3769 return -EINVAL;
>> 3770 if (get_user(val, (int __user *) optval))
>> 3771 return -EFAULT;
3955 3772
3956 sctp_sk(sk)->recvnxtinfo = (*val == 0 !! 3773 sctp_sk(sk)->recvnxtinfo = (val == 0) ? 0 : 1;
3957 3774
3958 return 0; 3775 return 0;
3959 } 3776 }
3960 3777
3961 static int sctp_setsockopt_pr_supported(struc 3778 static int sctp_setsockopt_pr_supported(struct sock *sk,
3962 struc !! 3779 char __user *optval,
3963 unsig 3780 unsigned int optlen)
3964 { 3781 {
3965 struct sctp_association *asoc; !! 3782 struct sctp_assoc_value params;
3966 3783
3967 if (optlen != sizeof(*params)) !! 3784 if (optlen != sizeof(params))
3968 return -EINVAL; 3785 return -EINVAL;
3969 3786
3970 asoc = sctp_id2assoc(sk, params->asso !! 3787 if (copy_from_user(¶ms, optval, optlen))
3971 if (!asoc && params->assoc_id != SCTP !! 3788 return -EFAULT;
3972 sctp_style(sk, UDP)) <<
3973 return -EINVAL; <<
3974 3789
3975 sctp_sk(sk)->ep->prsctp_enable = !!pa !! 3790 sctp_sk(sk)->ep->prsctp_enable = !!params.assoc_value;
3976 3791
3977 return 0; 3792 return 0;
3978 } 3793 }
3979 3794
3980 static int sctp_setsockopt_default_prinfo(str 3795 static int sctp_setsockopt_default_prinfo(struct sock *sk,
3981 str !! 3796 char __user *optval,
3982 uns 3797 unsigned int optlen)
3983 { 3798 {
3984 struct sctp_sock *sp = sctp_sk(sk); !! 3799 struct sctp_default_prinfo info;
3985 struct sctp_association *asoc; 3800 struct sctp_association *asoc;
3986 int retval = -EINVAL; 3801 int retval = -EINVAL;
3987 3802
3988 if (optlen != sizeof(*info)) !! 3803 if (optlen != sizeof(info))
3989 goto out; 3804 goto out;
3990 3805
3991 if (info->pr_policy & ~SCTP_PR_SCTP_M !! 3806 if (copy_from_user(&info, optval, sizeof(info))) {
>> 3807 retval = -EFAULT;
3992 goto out; 3808 goto out;
>> 3809 }
3993 3810
3994 if (info->pr_policy == SCTP_PR_SCTP_N !! 3811 if (info.pr_policy & ~SCTP_PR_SCTP_MASK)
3995 info->pr_value = 0; <<
3996 <<
3997 asoc = sctp_id2assoc(sk, info->pr_ass <<
3998 if (!asoc && info->pr_assoc_id > SCTP <<
3999 sctp_style(sk, UDP)) <<
4000 goto out; 3812 goto out;
4001 3813
4002 retval = 0; !! 3814 if (info.pr_policy == SCTP_PR_SCTP_NONE)
>> 3815 info.pr_value = 0;
4003 3816
>> 3817 asoc = sctp_id2assoc(sk, info.pr_assoc_id);
4004 if (asoc) { 3818 if (asoc) {
4005 SCTP_PR_SET_POLICY(asoc->defa !! 3819 SCTP_PR_SET_POLICY(asoc->default_flags, info.pr_policy);
4006 asoc->default_timetolive = in !! 3820 asoc->default_timetolive = info.pr_value;
4007 goto out; !! 3821 } else if (!info.pr_assoc_id) {
4008 } !! 3822 struct sctp_sock *sp = sctp_sk(sk);
4009 <<
4010 if (sctp_style(sk, TCP)) <<
4011 info->pr_assoc_id = SCTP_FUTU <<
4012 3823
4013 if (info->pr_assoc_id == SCTP_FUTURE_ !! 3824 SCTP_PR_SET_POLICY(sp->default_flags, info.pr_policy);
4014 info->pr_assoc_id == SCTP_ALL_ASS !! 3825 sp->default_timetolive = info.pr_value;
4015 SCTP_PR_SET_POLICY(sp->defaul !! 3826 } else {
4016 sp->default_timetolive = info !! 3827 goto out;
4017 } 3828 }
4018 3829
4019 if (info->pr_assoc_id == SCTP_CURRENT !! 3830 retval = 0;
4020 info->pr_assoc_id == SCTP_ALL_ASS <<
4021 list_for_each_entry(asoc, &sp <<
4022 SCTP_PR_SET_POLICY(as <<
4023 in <<
4024 asoc->default_timetol <<
4025 } <<
4026 } <<
4027 3831
4028 out: 3832 out:
4029 return retval; 3833 return retval;
4030 } 3834 }
4031 3835
4032 static int sctp_setsockopt_reconfig_supported 3836 static int sctp_setsockopt_reconfig_supported(struct sock *sk,
4033 !! 3837 char __user *optval,
4034 3838 unsigned int optlen)
4035 { 3839 {
>> 3840 struct sctp_assoc_value params;
4036 struct sctp_association *asoc; 3841 struct sctp_association *asoc;
4037 int retval = -EINVAL; 3842 int retval = -EINVAL;
4038 3843
4039 if (optlen != sizeof(*params)) !! 3844 if (optlen != sizeof(params))
4040 goto out; 3845 goto out;
4041 3846
4042 asoc = sctp_id2assoc(sk, params->asso !! 3847 if (copy_from_user(¶ms, optval, optlen)) {
4043 if (!asoc && params->assoc_id != SCTP !! 3848 retval = -EFAULT;
4044 sctp_style(sk, UDP)) <<
4045 goto out; 3849 goto out;
>> 3850 }
4046 3851
4047 sctp_sk(sk)->ep->reconf_enable = !!pa !! 3852 asoc = sctp_id2assoc(sk, params.assoc_id);
>> 3853 if (asoc) {
>> 3854 asoc->reconf_enable = !!params.assoc_value;
>> 3855 } else if (!params.assoc_id) {
>> 3856 struct sctp_sock *sp = sctp_sk(sk);
>> 3857
>> 3858 sp->ep->reconf_enable = !!params.assoc_value;
>> 3859 } else {
>> 3860 goto out;
>> 3861 }
4048 3862
4049 retval = 0; 3863 retval = 0;
4050 3864
4051 out: 3865 out:
4052 return retval; 3866 return retval;
4053 } 3867 }
4054 3868
4055 static int sctp_setsockopt_enable_strreset(st 3869 static int sctp_setsockopt_enable_strreset(struct sock *sk,
4056 st !! 3870 char __user *optval,
4057 un 3871 unsigned int optlen)
4058 { 3872 {
4059 struct sctp_endpoint *ep = sctp_sk(sk !! 3873 struct sctp_assoc_value params;
4060 struct sctp_association *asoc; 3874 struct sctp_association *asoc;
4061 int retval = -EINVAL; 3875 int retval = -EINVAL;
4062 3876
4063 if (optlen != sizeof(*params)) !! 3877 if (optlen != sizeof(params))
4064 goto out; 3878 goto out;
4065 3879
4066 if (params->assoc_value & (~SCTP_ENAB !! 3880 if (copy_from_user(¶ms, optval, optlen)) {
>> 3881 retval = -EFAULT;
4067 goto out; 3882 goto out;
>> 3883 }
4068 3884
4069 asoc = sctp_id2assoc(sk, params->asso !! 3885 if (params.assoc_value & (~SCTP_ENABLE_STRRESET_MASK))
4070 if (!asoc && params->assoc_id > SCTP_ <<
4071 sctp_style(sk, UDP)) <<
4072 goto out; 3886 goto out;
4073 3887
4074 retval = 0; !! 3888 asoc = sctp_id2assoc(sk, params.assoc_id);
4075 <<
4076 if (asoc) { 3889 if (asoc) {
4077 asoc->strreset_enable = param !! 3890 asoc->strreset_enable = params.assoc_value;
>> 3891 } else if (!params.assoc_id) {
>> 3892 struct sctp_sock *sp = sctp_sk(sk);
>> 3893
>> 3894 sp->ep->strreset_enable = params.assoc_value;
>> 3895 } else {
4078 goto out; 3896 goto out;
4079 } 3897 }
4080 3898
4081 if (sctp_style(sk, TCP)) !! 3899 retval = 0;
4082 params->assoc_id = SCTP_FUTUR <<
4083 <<
4084 if (params->assoc_id == SCTP_FUTURE_A <<
4085 params->assoc_id == SCTP_ALL_ASSO <<
4086 ep->strreset_enable = params- <<
4087 <<
4088 if (params->assoc_id == SCTP_CURRENT_ <<
4089 params->assoc_id == SCTP_ALL_ASSO <<
4090 list_for_each_entry(asoc, &ep <<
4091 asoc->strreset_enable <<
4092 3900
4093 out: 3901 out:
4094 return retval; 3902 return retval;
4095 } 3903 }
4096 3904
4097 static int sctp_setsockopt_reset_streams(stru 3905 static int sctp_setsockopt_reset_streams(struct sock *sk,
4098 stru !! 3906 char __user *optval,
4099 unsi 3907 unsigned int optlen)
4100 { 3908 {
>> 3909 struct sctp_reset_streams *params;
4101 struct sctp_association *asoc; 3910 struct sctp_association *asoc;
>> 3911 int retval = -EINVAL;
4102 3912
4103 if (optlen < sizeof(*params)) 3913 if (optlen < sizeof(*params))
4104 return -EINVAL; 3914 return -EINVAL;
4105 /* srs_number_streams is u16, so optl 3915 /* srs_number_streams is u16, so optlen can't be bigger than this. */
4106 optlen = min_t(unsigned int, optlen, 3916 optlen = min_t(unsigned int, optlen, USHRT_MAX +
4107 3917 sizeof(__u16) * sizeof(*params));
4108 3918
>> 3919 params = memdup_user(optval, optlen);
>> 3920 if (IS_ERR(params))
>> 3921 return PTR_ERR(params);
>> 3922
4109 if (params->srs_number_streams * size 3923 if (params->srs_number_streams * sizeof(__u16) >
4110 optlen - sizeof(*params)) 3924 optlen - sizeof(*params))
4111 return -EINVAL; !! 3925 goto out;
4112 3926
4113 asoc = sctp_id2assoc(sk, params->srs_ 3927 asoc = sctp_id2assoc(sk, params->srs_assoc_id);
4114 if (!asoc) 3928 if (!asoc)
4115 return -EINVAL; <<
4116 <<
4117 return sctp_send_reset_streams(asoc, <<
4118 } <<
4119 <<
4120 static int sctp_setsockopt_reset_assoc(struct <<
4121 unsign <<
4122 { <<
4123 struct sctp_association *asoc; <<
4124 <<
4125 if (optlen != sizeof(*associd)) <<
4126 return -EINVAL; <<
4127 <<
4128 asoc = sctp_id2assoc(sk, *associd); <<
4129 if (!asoc) <<
4130 return -EINVAL; <<
4131 <<
4132 return sctp_send_reset_assoc(asoc); <<
4133 } <<
4134 <<
4135 static int sctp_setsockopt_add_streams(struct <<
4136 struct <<
4137 unsign <<
4138 { <<
4139 struct sctp_association *asoc; <<
4140 <<
4141 if (optlen != sizeof(*params)) <<
4142 return -EINVAL; <<
4143 <<
4144 asoc = sctp_id2assoc(sk, params->sas_ <<
4145 if (!asoc) <<
4146 return -EINVAL; <<
4147 <<
4148 return sctp_send_add_streams(asoc, pa <<
4149 } <<
4150 <<
4151 static int sctp_setsockopt_scheduler(struct s <<
4152 struct s <<
4153 unsigned <<
4154 { <<
4155 struct sctp_sock *sp = sctp_sk(sk); <<
4156 struct sctp_association *asoc; <<
4157 int retval = 0; <<
4158 <<
4159 if (optlen < sizeof(*params)) <<
4160 return -EINVAL; <<
4161 <<
4162 if (params->assoc_value > SCTP_SS_MAX <<
4163 return -EINVAL; <<
4164 <<
4165 asoc = sctp_id2assoc(sk, params->asso <<
4166 if (!asoc && params->assoc_id > SCTP_ <<
4167 sctp_style(sk, UDP)) <<
4168 return -EINVAL; <<
4169 <<
4170 if (asoc) <<
4171 return sctp_sched_set_sched(a <<
4172 <<
4173 if (sctp_style(sk, TCP)) <<
4174 params->assoc_id = SCTP_FUTUR <<
4175 <<
4176 if (params->assoc_id == SCTP_FUTURE_A <<
4177 params->assoc_id == SCTP_ALL_ASSO <<
4178 sp->default_ss = params->asso <<
4179 <<
4180 if (params->assoc_id == SCTP_CURRENT_ <<
4181 params->assoc_id == SCTP_ALL_ASSO <<
4182 list_for_each_entry(asoc, &sp <<
4183 int ret = sctp_sched_ <<
4184 <<
4185 <<
4186 if (ret && !retval) <<
4187 retval = ret; <<
4188 } <<
4189 } <<
4190 <<
4191 return retval; <<
4192 } <<
4193 <<
4194 static int sctp_setsockopt_scheduler_value(st <<
4195 st <<
4196 un <<
4197 { <<
4198 struct sctp_association *asoc; <<
4199 int retval = -EINVAL; <<
4200 <<
4201 if (optlen < sizeof(*params)) <<
4202 goto out; <<
4203 <<
4204 asoc = sctp_id2assoc(sk, params->asso <<
4205 if (!asoc && params->assoc_id != SCTP <<
4206 sctp_style(sk, UDP)) <<
4207 goto out; <<
4208 <<
4209 if (asoc) { <<
4210 retval = sctp_sched_set_value <<
4211 <<
4212 goto out; <<
4213 } <<
4214 <<
4215 retval = 0; <<
4216 <<
4217 list_for_each_entry(asoc, &sctp_sk(sk <<
4218 int ret = sctp_sched_set_valu <<
4219 <<
4220 <<
4221 if (ret && !retval) /* try to <<
4222 retval = ret; <<
4223 } <<
4224 <<
4225 out: <<
4226 return retval; <<
4227 } <<
4228 <<
4229 static int sctp_setsockopt_interleaving_suppo <<
4230 <<
4231 <<
4232 { <<
4233 struct sctp_sock *sp = sctp_sk(sk); <<
4234 struct sctp_association *asoc; <<
4235 <<
4236 if (optlen < sizeof(*p)) <<
4237 return -EINVAL; <<
4238 <<
4239 asoc = sctp_id2assoc(sk, p->assoc_id) <<
4240 if (!asoc && p->assoc_id != SCTP_FUTU <<
4241 return -EINVAL; <<
4242 <<
4243 if (!sock_net(sk)->sctp.intl_enable | <<
4244 return -EPERM; <<
4245 } <<
4246 <<
4247 sp->ep->intl_enable = !!p->assoc_valu <<
4248 return 0; <<
4249 } <<
4250 <<
4251 static int sctp_setsockopt_reuse_port(struct <<
4252 unsigne <<
4253 { <<
4254 if (!sctp_style(sk, TCP)) <<
4255 return -EOPNOTSUPP; <<
4256 <<
4257 if (sctp_sk(sk)->ep->base.bind_addr.p <<
4258 return -EFAULT; <<
4259 <<
4260 if (optlen < sizeof(int)) <<
4261 return -EINVAL; <<
4262 <<
4263 sctp_sk(sk)->reuse = !!*val; <<
4264 <<
4265 return 0; <<
4266 } <<
4267 <<
4268 static int sctp_assoc_ulpevent_type_set(struc <<
4269 struc <<
4270 { <<
4271 struct sctp_ulpevent *event; <<
4272 <<
4273 sctp_ulpevent_type_set(&asoc->subscri <<
4274 <<
4275 if (param->se_type == SCTP_SENDER_DRY <<
4276 if (sctp_outq_is_empty(&asoc- <<
4277 event = sctp_ulpevent <<
4278 GFP_U <<
4279 if (!event) <<
4280 return -ENOME <<
4281 <<
4282 asoc->stream.si->enqu <<
4283 } <<
4284 } <<
4285 <<
4286 return 0; <<
4287 } <<
4288 <<
4289 static int sctp_setsockopt_event(struct sock <<
4290 unsigned int <<
4291 { <<
4292 struct sctp_sock *sp = sctp_sk(sk); <<
4293 struct sctp_association *asoc; <<
4294 int retval = 0; <<
4295 <<
4296 if (optlen < sizeof(*param)) <<
4297 return -EINVAL; <<
4298 <<
4299 if (param->se_type < SCTP_SN_TYPE_BAS <<
4300 param->se_type > SCTP_SN_TYPE_MAX <<
4301 return -EINVAL; <<
4302 <<
4303 asoc = sctp_id2assoc(sk, param->se_as <<
4304 if (!asoc && param->se_assoc_id > SCT <<
4305 sctp_style(sk, UDP)) <<
4306 return -EINVAL; <<
4307 <<
4308 if (asoc) <<
4309 return sctp_assoc_ulpevent_ty <<
4310 <<
4311 if (sctp_style(sk, TCP)) <<
4312 param->se_assoc_id = SCTP_FUT <<
4313 <<
4314 if (param->se_assoc_id == SCTP_FUTURE <<
4315 param->se_assoc_id == SCTP_ALL_AS <<
4316 sctp_ulpevent_type_set(&sp->s <<
4317 param- <<
4318 <<
4319 if (param->se_assoc_id == SCTP_CURREN <<
4320 param->se_assoc_id == SCTP_ALL_AS <<
4321 list_for_each_entry(asoc, &sp <<
4322 int ret = sctp_assoc_ <<
4323 <<
4324 if (ret && !retval) <<
4325 retval = ret; <<
4326 } <<
4327 } <<
4328 <<
4329 return retval; <<
4330 } <<
4331 <<
4332 static int sctp_setsockopt_asconf_supported(s <<
4333 s <<
4334 u <<
4335 { <<
4336 struct sctp_association *asoc; <<
4337 struct sctp_endpoint *ep; <<
4338 int retval = -EINVAL; <<
4339 <<
4340 if (optlen != sizeof(*params)) <<
4341 goto out; 3929 goto out;
4342 3930
4343 asoc = sctp_id2assoc(sk, params->asso !! 3931 retval = sctp_send_reset_streams(asoc, params);
4344 if (!asoc && params->assoc_id != SCTP <<
4345 sctp_style(sk, UDP)) <<
4346 goto out; <<
4347 <<
4348 ep = sctp_sk(sk)->ep; <<
4349 ep->asconf_enable = !!params->assoc_v <<
4350 <<
4351 if (ep->asconf_enable && ep->auth_ena <<
4352 sctp_auth_ep_add_chunkid(ep, <<
4353 sctp_auth_ep_add_chunkid(ep, <<
4354 } <<
4355 <<
4356 retval = 0; <<
4357 3932
4358 out: 3933 out:
>> 3934 kfree(params);
4359 return retval; 3935 return retval;
4360 } 3936 }
4361 3937
4362 static int sctp_setsockopt_auth_supported(str !! 3938 static int sctp_setsockopt_reset_assoc(struct sock *sk,
4363 str !! 3939 char __user *optval,
4364 uns !! 3940 unsigned int optlen)
4365 { 3941 {
4366 struct sctp_association *asoc; 3942 struct sctp_association *asoc;
4367 struct sctp_endpoint *ep; !! 3943 sctp_assoc_t associd;
4368 int retval = -EINVAL; 3944 int retval = -EINVAL;
4369 3945
4370 if (optlen != sizeof(*params)) !! 3946 if (optlen != sizeof(associd))
4371 goto out; 3947 goto out;
4372 3948
4373 asoc = sctp_id2assoc(sk, params->asso !! 3949 if (copy_from_user(&associd, optval, optlen)) {
4374 if (!asoc && params->assoc_id != SCTP !! 3950 retval = -EFAULT;
4375 sctp_style(sk, UDP)) <<
4376 goto out; 3951 goto out;
4377 <<
4378 ep = sctp_sk(sk)->ep; <<
4379 if (params->assoc_value) { <<
4380 retval = sctp_auth_init(ep, G <<
4381 if (retval) <<
4382 goto out; <<
4383 if (ep->asconf_enable) { <<
4384 sctp_auth_ep_add_chun <<
4385 sctp_auth_ep_add_chun <<
4386 } <<
4387 } 3952 }
4388 3953
4389 ep->auth_enable = !!params->assoc_val !! 3954 asoc = sctp_id2assoc(sk, associd);
4390 retval = 0; !! 3955 if (!asoc)
4391 <<
4392 out: <<
4393 return retval; <<
4394 } <<
4395 <<
4396 static int sctp_setsockopt_ecn_supported(stru <<
4397 stru <<
4398 unsi <<
4399 { <<
4400 struct sctp_association *asoc; <<
4401 int retval = -EINVAL; <<
4402 <<
4403 if (optlen != sizeof(*params)) <<
4404 goto out; <<
4405 <<
4406 asoc = sctp_id2assoc(sk, params->asso <<
4407 if (!asoc && params->assoc_id != SCTP <<
4408 sctp_style(sk, UDP)) <<
4409 goto out; 3956 goto out;
4410 3957
4411 sctp_sk(sk)->ep->ecn_enable = !!param !! 3958 retval = sctp_send_reset_assoc(asoc);
4412 retval = 0; <<
4413 3959
4414 out: 3960 out:
4415 return retval; 3961 return retval;
4416 } 3962 }
4417 3963
4418 static int sctp_setsockopt_pf_expose(struct s !! 3964 static int sctp_setsockopt_add_streams(struct sock *sk,
4419 struct s !! 3965 char __user *optval,
4420 unsigned !! 3966 unsigned int optlen)
4421 { 3967 {
4422 struct sctp_association *asoc; 3968 struct sctp_association *asoc;
>> 3969 struct sctp_add_streams params;
4423 int retval = -EINVAL; 3970 int retval = -EINVAL;
4424 3971
4425 if (optlen != sizeof(*params)) !! 3972 if (optlen != sizeof(params))
4426 goto out; 3973 goto out;
4427 3974
4428 if (params->assoc_value > SCTP_PF_EXP !! 3975 if (copy_from_user(¶ms, optval, optlen)) {
>> 3976 retval = -EFAULT;
4429 goto out; 3977 goto out;
>> 3978 }
4430 3979
4431 asoc = sctp_id2assoc(sk, params->asso !! 3980 asoc = sctp_id2assoc(sk, params.sas_assoc_id);
4432 if (!asoc && params->assoc_id != SCTP !! 3981 if (!asoc)
4433 sctp_style(sk, UDP)) <<
4434 goto out; 3982 goto out;
4435 3983
4436 if (asoc) !! 3984 retval = sctp_send_add_streams(asoc, ¶ms);
4437 asoc->pf_expose = params->ass <<
4438 else <<
4439 sctp_sk(sk)->pf_expose = para <<
4440 retval = 0; <<
4441 3985
4442 out: 3986 out:
4443 return retval; 3987 return retval;
4444 } 3988 }
4445 3989
4446 static int sctp_setsockopt_encap_port(struct <<
4447 struct <<
4448 unsigne <<
4449 { <<
4450 struct sctp_association *asoc; <<
4451 struct sctp_transport *t; <<
4452 __be16 encap_port; <<
4453 <<
4454 if (optlen != sizeof(*encap)) <<
4455 return -EINVAL; <<
4456 <<
4457 /* If an address other than INADDR_AN <<
4458 * no transport is found, then the re <<
4459 */ <<
4460 encap_port = (__force __be16)encap->s <<
4461 if (!sctp_is_any(sk, (union sctp_addr <<
4462 t = sctp_addr_id2transport(sk <<
4463 en <<
4464 if (!t) <<
4465 return -EINVAL; <<
4466 <<
4467 t->encap_port = encap_port; <<
4468 return 0; <<
4469 } <<
4470 <<
4471 /* Get association, if assoc_id != SC <<
4472 * socket is a one to many style sock <<
4473 * was not found, then the id was inv <<
4474 */ <<
4475 asoc = sctp_id2assoc(sk, encap->sue_a <<
4476 if (!asoc && encap->sue_assoc_id != S <<
4477 sctp_style(sk, UDP)) <<
4478 return -EINVAL; <<
4479 <<
4480 /* If changes are for association, al <<
4481 * each transport. <<
4482 */ <<
4483 if (asoc) { <<
4484 list_for_each_entry(t, &asoc- <<
4485 transport <<
4486 t->encap_port = encap <<
4487 <<
4488 asoc->encap_port = encap_port <<
4489 return 0; <<
4490 } <<
4491 <<
4492 sctp_sk(sk)->encap_port = encap_port; <<
4493 return 0; <<
4494 } <<
4495 <<
4496 static int sctp_setsockopt_probe_interval(str <<
4497 str <<
4498 uns <<
4499 { <<
4500 struct sctp_association *asoc; <<
4501 struct sctp_transport *t; <<
4502 __u32 probe_interval; <<
4503 <<
4504 if (optlen != sizeof(*params)) <<
4505 return -EINVAL; <<
4506 <<
4507 probe_interval = params->spi_interval <<
4508 if (probe_interval && probe_interval <<
4509 return -EINVAL; <<
4510 <<
4511 /* If an address other than INADDR_AN <<
4512 * no transport is found, then the re <<
4513 */ <<
4514 if (!sctp_is_any(sk, (union sctp_addr <<
4515 t = sctp_addr_id2transport(sk <<
4516 pa <<
4517 if (!t) <<
4518 return -EINVAL; <<
4519 <<
4520 t->probe_interval = msecs_to_ <<
4521 sctp_transport_pl_reset(t); <<
4522 return 0; <<
4523 } <<
4524 <<
4525 /* Get association, if assoc_id != SC <<
4526 * socket is a one to many style sock <<
4527 * was not found, then the id was inv <<
4528 */ <<
4529 asoc = sctp_id2assoc(sk, params->spi_ <<
4530 if (!asoc && params->spi_assoc_id != <<
4531 sctp_style(sk, UDP)) <<
4532 return -EINVAL; <<
4533 <<
4534 /* If changes are for association, al <<
4535 * each transport. <<
4536 */ <<
4537 if (asoc) { <<
4538 list_for_each_entry(t, &asoc- <<
4539 t->probe_interval = m <<
4540 sctp_transport_pl_res <<
4541 } <<
4542 <<
4543 asoc->probe_interval = msecs_ <<
4544 return 0; <<
4545 } <<
4546 <<
4547 sctp_sk(sk)->probe_interval = probe_i <<
4548 return 0; <<
4549 } <<
4550 <<
4551 /* API 6.2 setsockopt(), getsockopt() 3990 /* API 6.2 setsockopt(), getsockopt()
4552 * 3991 *
4553 * Applications use setsockopt() and getsocko 3992 * Applications use setsockopt() and getsockopt() to set or retrieve
4554 * socket options. Socket options are used t 3993 * socket options. Socket options are used to change the default
4555 * behavior of sockets calls. They are descr 3994 * behavior of sockets calls. They are described in Section 7.
4556 * 3995 *
4557 * The syntax is: 3996 * The syntax is:
4558 * 3997 *
4559 * ret = getsockopt(int sd, int level, int 3998 * ret = getsockopt(int sd, int level, int optname, void __user *optval,
4560 * int __user *optlen); 3999 * int __user *optlen);
4561 * ret = setsockopt(int sd, int level, int 4000 * ret = setsockopt(int sd, int level, int optname, const void __user *optval,
4562 * int optlen); 4001 * int optlen);
4563 * 4002 *
4564 * sd - the socket descript. 4003 * sd - the socket descript.
4565 * level - set to IPPROTO_SCTP for all SC 4004 * level - set to IPPROTO_SCTP for all SCTP options.
4566 * optname - the option name. 4005 * optname - the option name.
4567 * optval - the buffer to store the value 4006 * optval - the buffer to store the value of the option.
4568 * optlen - the size of the buffer. 4007 * optlen - the size of the buffer.
4569 */ 4008 */
4570 static int sctp_setsockopt(struct sock *sk, i 4009 static int sctp_setsockopt(struct sock *sk, int level, int optname,
4571 sockptr_t optval, !! 4010 char __user *optval, unsigned int optlen)
4572 { 4011 {
4573 void *kopt = NULL; <<
4574 int retval = 0; 4012 int retval = 0;
4575 4013
4576 pr_debug("%s: sk:%p, optname:%d\n", _ 4014 pr_debug("%s: sk:%p, optname:%d\n", __func__, sk, optname);
4577 4015
4578 /* I can hardly begin to describe how 4016 /* I can hardly begin to describe how wrong this is. This is
4579 * so broken as to be worse than usel 4017 * so broken as to be worse than useless. The API draft
4580 * REALLY is NOT helpful here... I a 4018 * REALLY is NOT helpful here... I am not convinced that the
4581 * semantics of setsockopt() with a l 4019 * semantics of setsockopt() with a level OTHER THAN SOL_SCTP
4582 * are at all well-founded. 4020 * are at all well-founded.
4583 */ 4021 */
4584 if (level != SOL_SCTP) { 4022 if (level != SOL_SCTP) {
4585 struct sctp_af *af = sctp_sk( 4023 struct sctp_af *af = sctp_sk(sk)->pf->af;
4586 !! 4024 retval = af->setsockopt(sk, level, optname, optval, optlen);
4587 return af->setsockopt(sk, lev !! 4025 goto out_nounlock;
4588 } <<
4589 <<
4590 if (optlen > 0) { <<
4591 /* Trim it to the biggest siz <<
4592 optlen = min_t(unsigned int, <<
4593 PAGE_ALIGN(USH <<
4594 siz <<
4595 kopt = memdup_sockptr(optval, <<
4596 if (IS_ERR(kopt)) <<
4597 return PTR_ERR(kopt); <<
4598 } 4026 }
4599 4027
4600 lock_sock(sk); 4028 lock_sock(sk);
4601 4029
4602 switch (optname) { 4030 switch (optname) {
4603 case SCTP_SOCKOPT_BINDX_ADD: 4031 case SCTP_SOCKOPT_BINDX_ADD:
4604 /* 'optlen' is the size of th 4032 /* 'optlen' is the size of the addresses buffer. */
4605 retval = sctp_setsockopt_bind !! 4033 retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval,
4606 !! 4034 optlen, SCTP_BINDX_ADD_ADDR);
4607 break; 4035 break;
4608 4036
4609 case SCTP_SOCKOPT_BINDX_REM: 4037 case SCTP_SOCKOPT_BINDX_REM:
4610 /* 'optlen' is the size of th 4038 /* 'optlen' is the size of the addresses buffer. */
4611 retval = sctp_setsockopt_bind !! 4039 retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval,
4612 !! 4040 optlen, SCTP_BINDX_REM_ADDR);
4613 break; 4041 break;
4614 4042
4615 case SCTP_SOCKOPT_CONNECTX_OLD: 4043 case SCTP_SOCKOPT_CONNECTX_OLD:
4616 /* 'optlen' is the size of th 4044 /* 'optlen' is the size of the addresses buffer. */
4617 retval = sctp_setsockopt_conn !! 4045 retval = sctp_setsockopt_connectx_old(sk,
>> 4046 (struct sockaddr __user *)optval,
>> 4047 optlen);
4618 break; 4048 break;
4619 4049
4620 case SCTP_SOCKOPT_CONNECTX: 4050 case SCTP_SOCKOPT_CONNECTX:
4621 /* 'optlen' is the size of th 4051 /* 'optlen' is the size of the addresses buffer. */
4622 retval = sctp_setsockopt_conn !! 4052 retval = sctp_setsockopt_connectx(sk,
>> 4053 (struct sockaddr __user *)optval,
>> 4054 optlen);
4623 break; 4055 break;
4624 4056
4625 case SCTP_DISABLE_FRAGMENTS: 4057 case SCTP_DISABLE_FRAGMENTS:
4626 retval = sctp_setsockopt_disa !! 4058 retval = sctp_setsockopt_disable_fragments(sk, optval, optlen);
4627 break; 4059 break;
4628 4060
4629 case SCTP_EVENTS: 4061 case SCTP_EVENTS:
4630 retval = sctp_setsockopt_even !! 4062 retval = sctp_setsockopt_events(sk, optval, optlen);
4631 break; 4063 break;
4632 4064
4633 case SCTP_AUTOCLOSE: 4065 case SCTP_AUTOCLOSE:
4634 retval = sctp_setsockopt_auto !! 4066 retval = sctp_setsockopt_autoclose(sk, optval, optlen);
4635 break; 4067 break;
4636 4068
4637 case SCTP_PEER_ADDR_PARAMS: 4069 case SCTP_PEER_ADDR_PARAMS:
4638 retval = sctp_setsockopt_peer !! 4070 retval = sctp_setsockopt_peer_addr_params(sk, optval, optlen);
4639 break; 4071 break;
4640 4072
4641 case SCTP_DELAYED_SACK: 4073 case SCTP_DELAYED_SACK:
4642 retval = sctp_setsockopt_dela !! 4074 retval = sctp_setsockopt_delayed_ack(sk, optval, optlen);
4643 break; 4075 break;
4644 case SCTP_PARTIAL_DELIVERY_POINT: 4076 case SCTP_PARTIAL_DELIVERY_POINT:
4645 retval = sctp_setsockopt_part !! 4077 retval = sctp_setsockopt_partial_delivery_point(sk, optval, optlen);
4646 break; 4078 break;
4647 4079
4648 case SCTP_INITMSG: 4080 case SCTP_INITMSG:
4649 retval = sctp_setsockopt_init !! 4081 retval = sctp_setsockopt_initmsg(sk, optval, optlen);
4650 break; 4082 break;
4651 case SCTP_DEFAULT_SEND_PARAM: 4083 case SCTP_DEFAULT_SEND_PARAM:
4652 retval = sctp_setsockopt_defa !! 4084 retval = sctp_setsockopt_default_send_param(sk, optval,
>> 4085 optlen);
4653 break; 4086 break;
4654 case SCTP_DEFAULT_SNDINFO: 4087 case SCTP_DEFAULT_SNDINFO:
4655 retval = sctp_setsockopt_defa !! 4088 retval = sctp_setsockopt_default_sndinfo(sk, optval, optlen);
4656 break; 4089 break;
4657 case SCTP_PRIMARY_ADDR: 4090 case SCTP_PRIMARY_ADDR:
4658 retval = sctp_setsockopt_prim !! 4091 retval = sctp_setsockopt_primary_addr(sk, optval, optlen);
4659 break; 4092 break;
4660 case SCTP_SET_PEER_PRIMARY_ADDR: 4093 case SCTP_SET_PEER_PRIMARY_ADDR:
4661 retval = sctp_setsockopt_peer !! 4094 retval = sctp_setsockopt_peer_primary_addr(sk, optval, optlen);
4662 break; 4095 break;
4663 case SCTP_NODELAY: 4096 case SCTP_NODELAY:
4664 retval = sctp_setsockopt_node !! 4097 retval = sctp_setsockopt_nodelay(sk, optval, optlen);
4665 break; 4098 break;
4666 case SCTP_RTOINFO: 4099 case SCTP_RTOINFO:
4667 retval = sctp_setsockopt_rtoi !! 4100 retval = sctp_setsockopt_rtoinfo(sk, optval, optlen);
4668 break; 4101 break;
4669 case SCTP_ASSOCINFO: 4102 case SCTP_ASSOCINFO:
4670 retval = sctp_setsockopt_asso !! 4103 retval = sctp_setsockopt_associnfo(sk, optval, optlen);
4671 break; 4104 break;
4672 case SCTP_I_WANT_MAPPED_V4_ADDR: 4105 case SCTP_I_WANT_MAPPED_V4_ADDR:
4673 retval = sctp_setsockopt_mapp !! 4106 retval = sctp_setsockopt_mappedv4(sk, optval, optlen);
4674 break; 4107 break;
4675 case SCTP_MAXSEG: 4108 case SCTP_MAXSEG:
4676 retval = sctp_setsockopt_maxs !! 4109 retval = sctp_setsockopt_maxseg(sk, optval, optlen);
4677 break; 4110 break;
4678 case SCTP_ADAPTATION_LAYER: 4111 case SCTP_ADAPTATION_LAYER:
4679 retval = sctp_setsockopt_adap !! 4112 retval = sctp_setsockopt_adaptation_layer(sk, optval, optlen);
4680 break; 4113 break;
4681 case SCTP_CONTEXT: 4114 case SCTP_CONTEXT:
4682 retval = sctp_setsockopt_cont !! 4115 retval = sctp_setsockopt_context(sk, optval, optlen);
4683 break; 4116 break;
4684 case SCTP_FRAGMENT_INTERLEAVE: 4117 case SCTP_FRAGMENT_INTERLEAVE:
4685 retval = sctp_setsockopt_frag !! 4118 retval = sctp_setsockopt_fragment_interleave(sk, optval, optlen);
4686 break; 4119 break;
4687 case SCTP_MAX_BURST: 4120 case SCTP_MAX_BURST:
4688 retval = sctp_setsockopt_maxb !! 4121 retval = sctp_setsockopt_maxburst(sk, optval, optlen);
4689 break; 4122 break;
4690 case SCTP_AUTH_CHUNK: 4123 case SCTP_AUTH_CHUNK:
4691 retval = sctp_setsockopt_auth !! 4124 retval = sctp_setsockopt_auth_chunk(sk, optval, optlen);
4692 break; 4125 break;
4693 case SCTP_HMAC_IDENT: 4126 case SCTP_HMAC_IDENT:
4694 retval = sctp_setsockopt_hmac !! 4127 retval = sctp_setsockopt_hmac_ident(sk, optval, optlen);
4695 break; 4128 break;
4696 case SCTP_AUTH_KEY: 4129 case SCTP_AUTH_KEY:
4697 retval = sctp_setsockopt_auth !! 4130 retval = sctp_setsockopt_auth_key(sk, optval, optlen);
4698 break; 4131 break;
4699 case SCTP_AUTH_ACTIVE_KEY: 4132 case SCTP_AUTH_ACTIVE_KEY:
4700 retval = sctp_setsockopt_acti !! 4133 retval = sctp_setsockopt_active_key(sk, optval, optlen);
4701 break; 4134 break;
4702 case SCTP_AUTH_DELETE_KEY: 4135 case SCTP_AUTH_DELETE_KEY:
4703 retval = sctp_setsockopt_del_ !! 4136 retval = sctp_setsockopt_del_key(sk, optval, optlen);
4704 break; <<
4705 case SCTP_AUTH_DEACTIVATE_KEY: <<
4706 retval = sctp_setsockopt_deac <<
4707 break; 4137 break;
4708 case SCTP_AUTO_ASCONF: 4138 case SCTP_AUTO_ASCONF:
4709 retval = sctp_setsockopt_auto !! 4139 retval = sctp_setsockopt_auto_asconf(sk, optval, optlen);
4710 break; 4140 break;
4711 case SCTP_PEER_ADDR_THLDS: 4141 case SCTP_PEER_ADDR_THLDS:
4712 retval = sctp_setsockopt_padd !! 4142 retval = sctp_setsockopt_paddr_thresholds(sk, optval, optlen);
4713 <<
4714 break; <<
4715 case SCTP_PEER_ADDR_THLDS_V2: <<
4716 retval = sctp_setsockopt_padd <<
4717 <<
4718 break; 4143 break;
4719 case SCTP_RECVRCVINFO: 4144 case SCTP_RECVRCVINFO:
4720 retval = sctp_setsockopt_recv !! 4145 retval = sctp_setsockopt_recvrcvinfo(sk, optval, optlen);
4721 break; 4146 break;
4722 case SCTP_RECVNXTINFO: 4147 case SCTP_RECVNXTINFO:
4723 retval = sctp_setsockopt_recv !! 4148 retval = sctp_setsockopt_recvnxtinfo(sk, optval, optlen);
4724 break; 4149 break;
4725 case SCTP_PR_SUPPORTED: 4150 case SCTP_PR_SUPPORTED:
4726 retval = sctp_setsockopt_pr_s !! 4151 retval = sctp_setsockopt_pr_supported(sk, optval, optlen);
4727 break; 4152 break;
4728 case SCTP_DEFAULT_PRINFO: 4153 case SCTP_DEFAULT_PRINFO:
4729 retval = sctp_setsockopt_defa !! 4154 retval = sctp_setsockopt_default_prinfo(sk, optval, optlen);
4730 break; 4155 break;
4731 case SCTP_RECONFIG_SUPPORTED: 4156 case SCTP_RECONFIG_SUPPORTED:
4732 retval = sctp_setsockopt_reco !! 4157 retval = sctp_setsockopt_reconfig_supported(sk, optval, optlen);
4733 break; 4158 break;
4734 case SCTP_ENABLE_STREAM_RESET: 4159 case SCTP_ENABLE_STREAM_RESET:
4735 retval = sctp_setsockopt_enab !! 4160 retval = sctp_setsockopt_enable_strreset(sk, optval, optlen);
4736 break; 4161 break;
4737 case SCTP_RESET_STREAMS: 4162 case SCTP_RESET_STREAMS:
4738 retval = sctp_setsockopt_rese !! 4163 retval = sctp_setsockopt_reset_streams(sk, optval, optlen);
4739 break; 4164 break;
4740 case SCTP_RESET_ASSOC: 4165 case SCTP_RESET_ASSOC:
4741 retval = sctp_setsockopt_rese !! 4166 retval = sctp_setsockopt_reset_assoc(sk, optval, optlen);
4742 break; 4167 break;
4743 case SCTP_ADD_STREAMS: 4168 case SCTP_ADD_STREAMS:
4744 retval = sctp_setsockopt_add_ !! 4169 retval = sctp_setsockopt_add_streams(sk, optval, optlen);
4745 break; <<
4746 case SCTP_STREAM_SCHEDULER: <<
4747 retval = sctp_setsockopt_sche <<
4748 break; <<
4749 case SCTP_STREAM_SCHEDULER_VALUE: <<
4750 retval = sctp_setsockopt_sche <<
4751 break; <<
4752 case SCTP_INTERLEAVING_SUPPORTED: <<
4753 retval = sctp_setsockopt_inte <<
4754 <<
4755 break; <<
4756 case SCTP_REUSE_PORT: <<
4757 retval = sctp_setsockopt_reus <<
4758 break; <<
4759 case SCTP_EVENT: <<
4760 retval = sctp_setsockopt_even <<
4761 break; <<
4762 case SCTP_ASCONF_SUPPORTED: <<
4763 retval = sctp_setsockopt_asco <<
4764 break; <<
4765 case SCTP_AUTH_SUPPORTED: <<
4766 retval = sctp_setsockopt_auth <<
4767 break; <<
4768 case SCTP_ECN_SUPPORTED: <<
4769 retval = sctp_setsockopt_ecn_ <<
4770 break; <<
4771 case SCTP_EXPOSE_POTENTIALLY_FAILED_S <<
4772 retval = sctp_setsockopt_pf_e <<
4773 break; <<
4774 case SCTP_REMOTE_UDP_ENCAPS_PORT: <<
4775 retval = sctp_setsockopt_enca <<
4776 break; <<
4777 case SCTP_PLPMTUD_PROBE_INTERVAL: <<
4778 retval = sctp_setsockopt_prob <<
4779 break; 4170 break;
4780 default: 4171 default:
4781 retval = -ENOPROTOOPT; 4172 retval = -ENOPROTOOPT;
4782 break; 4173 break;
4783 } 4174 }
4784 4175
4785 release_sock(sk); 4176 release_sock(sk);
4786 kfree(kopt); !! 4177
>> 4178 out_nounlock:
4787 return retval; 4179 return retval;
4788 } 4180 }
4789 4181
4790 /* API 3.1.6 connect() - UDP Style Syntax 4182 /* API 3.1.6 connect() - UDP Style Syntax
4791 * 4183 *
4792 * An application may use the connect() call 4184 * An application may use the connect() call in the UDP model to initiate an
4793 * association without sending data. 4185 * association without sending data.
4794 * 4186 *
4795 * The syntax is: 4187 * The syntax is:
4796 * 4188 *
4797 * ret = connect(int sd, const struct sockadd 4189 * ret = connect(int sd, const struct sockaddr *nam, socklen_t len);
4798 * 4190 *
4799 * sd: the socket descriptor to have a new as 4191 * sd: the socket descriptor to have a new association added to.
4800 * 4192 *
4801 * nam: the address structure (either struct 4193 * nam: the address structure (either struct sockaddr_in or struct
4802 * sockaddr_in6 defined in RFC2553 [7]). 4194 * sockaddr_in6 defined in RFC2553 [7]).
4803 * 4195 *
4804 * len: the size of the address. 4196 * len: the size of the address.
4805 */ 4197 */
4806 static int sctp_connect(struct sock *sk, stru 4198 static int sctp_connect(struct sock *sk, struct sockaddr *addr,
4807 int addr_len, int fla 4199 int addr_len, int flags)
4808 { 4200 {
4809 struct sctp_af *af; 4201 struct sctp_af *af;
4810 int err = -EINVAL; 4202 int err = -EINVAL;
4811 4203
4812 lock_sock(sk); 4204 lock_sock(sk);
4813 pr_debug("%s: sk:%p, sockaddr:%p, add 4205 pr_debug("%s: sk:%p, sockaddr:%p, addr_len:%d\n", __func__, sk,
4814 addr, addr_len); 4206 addr, addr_len);
4815 4207
4816 /* Validate addr_len before calling c 4208 /* Validate addr_len before calling common connect/connectx routine. */
4817 af = sctp_get_af_specific(addr->sa_fa 4209 af = sctp_get_af_specific(addr->sa_family);
4818 if (af && addr_len >= af->sockaddr_le 4210 if (af && addr_len >= af->sockaddr_len)
4819 err = __sctp_connect(sk, addr 4211 err = __sctp_connect(sk, addr, af->sockaddr_len, flags, NULL);
4820 4212
4821 release_sock(sk); 4213 release_sock(sk);
4822 return err; 4214 return err;
4823 } 4215 }
4824 4216
4825 int sctp_inet_connect(struct socket *sock, st 4217 int sctp_inet_connect(struct socket *sock, struct sockaddr *uaddr,
4826 int addr_len, int flags 4218 int addr_len, int flags)
4827 { 4219 {
4828 if (addr_len < sizeof(uaddr->sa_famil 4220 if (addr_len < sizeof(uaddr->sa_family))
4829 return -EINVAL; 4221 return -EINVAL;
4830 4222
4831 if (uaddr->sa_family == AF_UNSPEC) 4223 if (uaddr->sa_family == AF_UNSPEC)
4832 return -EOPNOTSUPP; 4224 return -EOPNOTSUPP;
4833 4225
4834 return sctp_connect(sock->sk, uaddr, 4226 return sctp_connect(sock->sk, uaddr, addr_len, flags);
4835 } 4227 }
4836 4228
4837 /* Only called when shutdown a listening SCTP !! 4229 /* FIXME: Write comments. */
4838 static int sctp_disconnect(struct sock *sk, i 4230 static int sctp_disconnect(struct sock *sk, int flags)
4839 { 4231 {
4840 if (!sctp_style(sk, TCP)) !! 4232 return -EOPNOTSUPP; /* STUB */
4841 return -EOPNOTSUPP; <<
4842 <<
4843 sk->sk_shutdown |= RCV_SHUTDOWN; <<
4844 return 0; <<
4845 } 4233 }
4846 4234
4847 /* 4.1.4 accept() - TCP Style Syntax 4235 /* 4.1.4 accept() - TCP Style Syntax
4848 * 4236 *
4849 * Applications use accept() call to remove a 4237 * Applications use accept() call to remove an established SCTP
4850 * association from the accept queue of the e 4238 * association from the accept queue of the endpoint. A new socket
4851 * descriptor will be returned from accept() 4239 * descriptor will be returned from accept() to represent the newly
4852 * formed association. 4240 * formed association.
4853 */ 4241 */
4854 static struct sock *sctp_accept(struct sock * !! 4242 static struct sock *sctp_accept(struct sock *sk, int flags, int *err, bool kern)
4855 { 4243 {
4856 struct sctp_sock *sp; 4244 struct sctp_sock *sp;
4857 struct sctp_endpoint *ep; 4245 struct sctp_endpoint *ep;
4858 struct sock *newsk = NULL; 4246 struct sock *newsk = NULL;
4859 struct sctp_association *asoc; 4247 struct sctp_association *asoc;
4860 long timeo; 4248 long timeo;
4861 int error = 0; 4249 int error = 0;
4862 4250
4863 lock_sock(sk); 4251 lock_sock(sk);
4864 4252
4865 sp = sctp_sk(sk); 4253 sp = sctp_sk(sk);
4866 ep = sp->ep; 4254 ep = sp->ep;
4867 4255
4868 if (!sctp_style(sk, TCP)) { 4256 if (!sctp_style(sk, TCP)) {
4869 error = -EOPNOTSUPP; 4257 error = -EOPNOTSUPP;
4870 goto out; 4258 goto out;
4871 } 4259 }
4872 4260
4873 if (!sctp_sstate(sk, LISTENING) || !! 4261 if (!sctp_sstate(sk, LISTENING)) {
4874 (sk->sk_shutdown & RCV_SHUTDOWN)) <<
4875 error = -EINVAL; 4262 error = -EINVAL;
4876 goto out; 4263 goto out;
4877 } 4264 }
4878 4265
4879 timeo = sock_rcvtimeo(sk, arg->flags !! 4266 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
4880 4267
4881 error = sctp_wait_for_accept(sk, time 4268 error = sctp_wait_for_accept(sk, timeo);
4882 if (error) 4269 if (error)
4883 goto out; 4270 goto out;
4884 4271
4885 /* We treat the list of associations 4272 /* We treat the list of associations on the endpoint as the accept
4886 * queue and pick the first associati 4273 * queue and pick the first association on the list.
4887 */ 4274 */
4888 asoc = list_entry(ep->asocs.next, str 4275 asoc = list_entry(ep->asocs.next, struct sctp_association, asocs);
4889 4276
4890 newsk = sp->pf->create_accept_sk(sk, !! 4277 newsk = sp->pf->create_accept_sk(sk, asoc, kern);
4891 if (!newsk) { 4278 if (!newsk) {
4892 error = -ENOMEM; 4279 error = -ENOMEM;
4893 goto out; 4280 goto out;
4894 } 4281 }
4895 4282
4896 /* Populate the fields of the newsk f 4283 /* Populate the fields of the newsk from the oldsk and migrate the
4897 * asoc to the newsk. 4284 * asoc to the newsk.
4898 */ 4285 */
4899 error = sctp_sock_migrate(sk, newsk, !! 4286 sctp_sock_migrate(sk, newsk, asoc, SCTP_SOCKET_TCP);
4900 if (error) { <<
4901 sk_common_release(newsk); <<
4902 newsk = NULL; <<
4903 } <<
4904 4287
4905 out: 4288 out:
4906 release_sock(sk); 4289 release_sock(sk);
4907 arg->err = error; !! 4290 *err = error;
4908 return newsk; 4291 return newsk;
4909 } 4292 }
4910 4293
4911 /* The SCTP ioctl handler. */ 4294 /* The SCTP ioctl handler. */
4912 static int sctp_ioctl(struct sock *sk, int cm !! 4295 static int sctp_ioctl(struct sock *sk, int cmd, unsigned long arg)
4913 { 4296 {
4914 int rc = -ENOTCONN; 4297 int rc = -ENOTCONN;
4915 4298
4916 lock_sock(sk); 4299 lock_sock(sk);
4917 4300
4918 /* 4301 /*
4919 * SEQPACKET-style sockets in LISTENI 4302 * SEQPACKET-style sockets in LISTENING state are valid, for
4920 * SCTP, so only discard TCP-style so 4303 * SCTP, so only discard TCP-style sockets in LISTENING state.
4921 */ 4304 */
4922 if (sctp_style(sk, TCP) && sctp_sstat 4305 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
4923 goto out; 4306 goto out;
4924 4307
4925 switch (cmd) { 4308 switch (cmd) {
4926 case SIOCINQ: { 4309 case SIOCINQ: {
4927 struct sk_buff *skb; 4310 struct sk_buff *skb;
4928 *karg = 0; !! 4311 unsigned int amount = 0;
4929 4312
4930 skb = skb_peek(&sk->sk_receiv 4313 skb = skb_peek(&sk->sk_receive_queue);
4931 if (skb != NULL) { 4314 if (skb != NULL) {
4932 /* 4315 /*
4933 * We will only retur 4316 * We will only return the amount of this packet since
4934 * that is all that w 4317 * that is all that will be read.
4935 */ 4318 */
4936 *karg = skb->len; !! 4319 amount = skb->len;
4937 } 4320 }
4938 rc = 0; !! 4321 rc = put_user(amount, (int __user *)arg);
4939 break; 4322 break;
4940 } 4323 }
4941 default: 4324 default:
4942 rc = -ENOIOCTLCMD; 4325 rc = -ENOIOCTLCMD;
4943 break; 4326 break;
4944 } 4327 }
4945 out: 4328 out:
4946 release_sock(sk); 4329 release_sock(sk);
4947 return rc; 4330 return rc;
4948 } 4331 }
4949 4332
4950 /* This is the function which gets called dur 4333 /* This is the function which gets called during socket creation to
4951 * initialized the SCTP-specific portion of t 4334 * initialized the SCTP-specific portion of the sock.
4952 * The sock structure should already be zero- 4335 * The sock structure should already be zero-filled memory.
4953 */ 4336 */
4954 static int sctp_init_sock(struct sock *sk) 4337 static int sctp_init_sock(struct sock *sk)
4955 { 4338 {
4956 struct net *net = sock_net(sk); 4339 struct net *net = sock_net(sk);
4957 struct sctp_sock *sp; 4340 struct sctp_sock *sp;
4958 4341
4959 pr_debug("%s: sk:%p\n", __func__, sk) 4342 pr_debug("%s: sk:%p\n", __func__, sk);
4960 4343
4961 sp = sctp_sk(sk); 4344 sp = sctp_sk(sk);
4962 4345
4963 /* Initialize the SCTP per socket are 4346 /* Initialize the SCTP per socket area. */
4964 switch (sk->sk_type) { 4347 switch (sk->sk_type) {
4965 case SOCK_SEQPACKET: 4348 case SOCK_SEQPACKET:
4966 sp->type = SCTP_SOCKET_UDP; 4349 sp->type = SCTP_SOCKET_UDP;
4967 break; 4350 break;
4968 case SOCK_STREAM: 4351 case SOCK_STREAM:
4969 sp->type = SCTP_SOCKET_TCP; 4352 sp->type = SCTP_SOCKET_TCP;
4970 break; 4353 break;
4971 default: 4354 default:
4972 return -ESOCKTNOSUPPORT; 4355 return -ESOCKTNOSUPPORT;
4973 } 4356 }
4974 4357
4975 sk->sk_gso_type = SKB_GSO_SCTP; 4358 sk->sk_gso_type = SKB_GSO_SCTP;
4976 4359
4977 /* Initialize default send parameters 4360 /* Initialize default send parameters. These parameters can be
4978 * modified with the SCTP_DEFAULT_SEN 4361 * modified with the SCTP_DEFAULT_SEND_PARAM socket option.
4979 */ 4362 */
4980 sp->default_stream = 0; 4363 sp->default_stream = 0;
4981 sp->default_ppid = 0; 4364 sp->default_ppid = 0;
4982 sp->default_flags = 0; 4365 sp->default_flags = 0;
4983 sp->default_context = 0; 4366 sp->default_context = 0;
4984 sp->default_timetolive = 0; 4367 sp->default_timetolive = 0;
4985 4368
4986 sp->default_rcv_context = 0; 4369 sp->default_rcv_context = 0;
4987 sp->max_burst = net->sctp.max_burst; 4370 sp->max_burst = net->sctp.max_burst;
4988 4371
4989 sp->sctp_hmac_alg = net->sctp.sctp_hm 4372 sp->sctp_hmac_alg = net->sctp.sctp_hmac_alg;
4990 4373
4991 /* Initialize default setup parameter 4374 /* Initialize default setup parameters. These parameters
4992 * can be modified with the SCTP_INIT 4375 * can be modified with the SCTP_INITMSG socket option or
4993 * overridden by the SCTP_INIT CMSG. 4376 * overridden by the SCTP_INIT CMSG.
4994 */ 4377 */
4995 sp->initmsg.sinit_num_ostreams = sc 4378 sp->initmsg.sinit_num_ostreams = sctp_max_outstreams;
4996 sp->initmsg.sinit_max_instreams = sc 4379 sp->initmsg.sinit_max_instreams = sctp_max_instreams;
4997 sp->initmsg.sinit_max_attempts = ne 4380 sp->initmsg.sinit_max_attempts = net->sctp.max_retrans_init;
4998 sp->initmsg.sinit_max_init_timeo = ne 4381 sp->initmsg.sinit_max_init_timeo = net->sctp.rto_max;
4999 4382
5000 /* Initialize default RTO related par 4383 /* Initialize default RTO related parameters. These parameters can
5001 * be modified for with the SCTP_RTOI 4384 * be modified for with the SCTP_RTOINFO socket option.
5002 */ 4385 */
5003 sp->rtoinfo.srto_initial = net->sctp. 4386 sp->rtoinfo.srto_initial = net->sctp.rto_initial;
5004 sp->rtoinfo.srto_max = net->sctp. 4387 sp->rtoinfo.srto_max = net->sctp.rto_max;
5005 sp->rtoinfo.srto_min = net->sctp. 4388 sp->rtoinfo.srto_min = net->sctp.rto_min;
5006 4389
5007 /* Initialize default association rel 4390 /* Initialize default association related parameters. These parameters
5008 * can be modified with the SCTP_ASSO 4391 * can be modified with the SCTP_ASSOCINFO socket option.
5009 */ 4392 */
5010 sp->assocparams.sasoc_asocmaxrxt = ne 4393 sp->assocparams.sasoc_asocmaxrxt = net->sctp.max_retrans_association;
5011 sp->assocparams.sasoc_number_peer_des 4394 sp->assocparams.sasoc_number_peer_destinations = 0;
5012 sp->assocparams.sasoc_peer_rwnd = 0; 4395 sp->assocparams.sasoc_peer_rwnd = 0;
5013 sp->assocparams.sasoc_local_rwnd = 0; 4396 sp->assocparams.sasoc_local_rwnd = 0;
5014 sp->assocparams.sasoc_cookie_life = n 4397 sp->assocparams.sasoc_cookie_life = net->sctp.valid_cookie_life;
5015 4398
5016 /* Initialize default event subscript 4399 /* Initialize default event subscriptions. By default, all the
5017 * options are off. 4400 * options are off.
5018 */ 4401 */
5019 sp->subscribe = 0; !! 4402 memset(&sp->subscribe, 0, sizeof(struct sctp_event_subscribe));
5020 4403
5021 /* Default Peer Address Parameters. 4404 /* Default Peer Address Parameters. These defaults can
5022 * be modified via SCTP_PEER_ADDR_PAR 4405 * be modified via SCTP_PEER_ADDR_PARAMS
5023 */ 4406 */
5024 sp->hbinterval = net->sctp.hb_interv 4407 sp->hbinterval = net->sctp.hb_interval;
5025 sp->udp_port = htons(net->sctp.udp <<
5026 sp->encap_port = htons(net->sctp.enc <<
5027 sp->pathmaxrxt = net->sctp.max_retra 4408 sp->pathmaxrxt = net->sctp.max_retrans_path;
5028 sp->pf_retrans = net->sctp.pf_retran <<
5029 sp->ps_retrans = net->sctp.ps_retran <<
5030 sp->pf_expose = net->sctp.pf_expose <<
5031 sp->pathmtu = 0; /* allow default 4409 sp->pathmtu = 0; /* allow default discovery */
5032 sp->sackdelay = net->sctp.sack_time 4410 sp->sackdelay = net->sctp.sack_timeout;
5033 sp->sackfreq = 2; 4411 sp->sackfreq = 2;
5034 sp->param_flags = SPP_HB_ENABLE | 4412 sp->param_flags = SPP_HB_ENABLE |
5035 SPP_PMTUD_ENABLE | 4413 SPP_PMTUD_ENABLE |
5036 SPP_SACKDELAY_ENABL 4414 SPP_SACKDELAY_ENABLE;
5037 sp->default_ss = SCTP_SS_DEFAULT; <<
5038 4415
5039 /* If enabled no SCTP message fragmen 4416 /* If enabled no SCTP message fragmentation will be performed.
5040 * Configure through SCTP_DISABLE_FRA 4417 * Configure through SCTP_DISABLE_FRAGMENTS socket option.
5041 */ 4418 */
5042 sp->disable_fragments = 0; 4419 sp->disable_fragments = 0;
5043 4420
5044 /* Enable Nagle algorithm by default. 4421 /* Enable Nagle algorithm by default. */
5045 sp->nodelay = 0; 4422 sp->nodelay = 0;
5046 4423
5047 sp->recvrcvinfo = 0; 4424 sp->recvrcvinfo = 0;
5048 sp->recvnxtinfo = 0; 4425 sp->recvnxtinfo = 0;
5049 4426
5050 /* Enable by default. */ 4427 /* Enable by default. */
5051 sp->v4mapped = 1; 4428 sp->v4mapped = 1;
5052 4429
5053 /* Auto-close idle associations after 4430 /* Auto-close idle associations after the configured
5054 * number of seconds. A value of 0 d 4431 * number of seconds. A value of 0 disables this
5055 * feature. Configure through the SC 4432 * feature. Configure through the SCTP_AUTOCLOSE socket option,
5056 * for UDP-style sockets only. 4433 * for UDP-style sockets only.
5057 */ 4434 */
5058 sp->autoclose = 0; 4435 sp->autoclose = 0;
5059 4436
5060 /* User specified fragmentation limit 4437 /* User specified fragmentation limit. */
5061 sp->user_frag = 0; 4438 sp->user_frag = 0;
5062 4439
5063 sp->adaptation_ind = 0; 4440 sp->adaptation_ind = 0;
5064 4441
5065 sp->pf = sctp_get_pf_specific(sk->sk_ 4442 sp->pf = sctp_get_pf_specific(sk->sk_family);
5066 4443
5067 /* Control variables for partial data 4444 /* Control variables for partial data delivery. */
5068 atomic_set(&sp->pd_mode, 0); 4445 atomic_set(&sp->pd_mode, 0);
5069 skb_queue_head_init(&sp->pd_lobby); 4446 skb_queue_head_init(&sp->pd_lobby);
5070 sp->frag_interleave = 0; 4447 sp->frag_interleave = 0;
5071 sp->probe_interval = net->sctp.probe_ <<
5072 4448
5073 /* Create a per socket endpoint struc 4449 /* Create a per socket endpoint structure. Even if we
5074 * change the data structure relation 4450 * change the data structure relationships, this may still
5075 * be useful for storing pre-connect 4451 * be useful for storing pre-connect address information.
5076 */ 4452 */
5077 sp->ep = sctp_endpoint_new(sk, GFP_KE 4453 sp->ep = sctp_endpoint_new(sk, GFP_KERNEL);
5078 if (!sp->ep) 4454 if (!sp->ep)
5079 return -ENOMEM; 4455 return -ENOMEM;
5080 4456
5081 sp->hmac = NULL; 4457 sp->hmac = NULL;
5082 4458
5083 sk->sk_destruct = sctp_destruct_sock; 4459 sk->sk_destruct = sctp_destruct_sock;
5084 4460
5085 SCTP_DBG_OBJCNT_INC(sock); 4461 SCTP_DBG_OBJCNT_INC(sock);
5086 4462
>> 4463 local_bh_disable();
5087 sk_sockets_allocated_inc(sk); 4464 sk_sockets_allocated_inc(sk);
5088 sock_prot_inuse_add(net, sk->sk_prot, 4465 sock_prot_inuse_add(net, sk->sk_prot, 1);
5089 4466
>> 4467 local_bh_enable();
>> 4468
5090 return 0; 4469 return 0;
5091 } 4470 }
5092 4471
5093 /* Cleanup any SCTP per socket resources. Mus 4472 /* Cleanup any SCTP per socket resources. Must be called with
5094 * sock_net(sk)->sctp.addr_wq_lock held if sp 4473 * sock_net(sk)->sctp.addr_wq_lock held if sp->do_auto_asconf is true
5095 */ 4474 */
5096 static void sctp_destroy_sock(struct sock *sk 4475 static void sctp_destroy_sock(struct sock *sk)
5097 { 4476 {
5098 struct sctp_sock *sp; 4477 struct sctp_sock *sp;
5099 4478
5100 pr_debug("%s: sk:%p\n", __func__, sk) 4479 pr_debug("%s: sk:%p\n", __func__, sk);
5101 4480
5102 /* Release our hold on the endpoint. 4481 /* Release our hold on the endpoint. */
5103 sp = sctp_sk(sk); 4482 sp = sctp_sk(sk);
5104 /* This could happen during socket in 4483 /* This could happen during socket init, thus we bail out
5105 * early, since the rest of the below 4484 * early, since the rest of the below is not setup either.
5106 */ 4485 */
5107 if (sp->ep == NULL) 4486 if (sp->ep == NULL)
5108 return; 4487 return;
5109 4488
5110 if (sp->do_auto_asconf) { 4489 if (sp->do_auto_asconf) {
5111 sp->do_auto_asconf = 0; 4490 sp->do_auto_asconf = 0;
5112 list_del(&sp->auto_asconf_lis 4491 list_del(&sp->auto_asconf_list);
5113 } 4492 }
5114 sctp_endpoint_free(sp->ep); 4493 sctp_endpoint_free(sp->ep);
>> 4494 local_bh_disable();
5115 sk_sockets_allocated_dec(sk); 4495 sk_sockets_allocated_dec(sk);
5116 sock_prot_inuse_add(sock_net(sk), sk- 4496 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
>> 4497 local_bh_enable();
5117 } 4498 }
5118 4499
5119 /* Triggered when there are no references on 4500 /* Triggered when there are no references on the socket anymore */
5120 static void sctp_destruct_common(struct sock 4501 static void sctp_destruct_common(struct sock *sk)
5121 { 4502 {
5122 struct sctp_sock *sp = sctp_sk(sk); 4503 struct sctp_sock *sp = sctp_sk(sk);
5123 4504
5124 /* Free up the HMAC transform. */ 4505 /* Free up the HMAC transform. */
5125 crypto_free_shash(sp->hmac); 4506 crypto_free_shash(sp->hmac);
5126 } 4507 }
5127 4508
5128 static void sctp_destruct_sock(struct sock *s 4509 static void sctp_destruct_sock(struct sock *sk)
5129 { 4510 {
5130 sctp_destruct_common(sk); 4511 sctp_destruct_common(sk);
5131 inet_sock_destruct(sk); 4512 inet_sock_destruct(sk);
5132 } 4513 }
5133 4514
5134 /* API 4.1.7 shutdown() - TCP Style Syntax 4515 /* API 4.1.7 shutdown() - TCP Style Syntax
5135 * int shutdown(int socket, int how); 4516 * int shutdown(int socket, int how);
5136 * 4517 *
5137 * sd - the socket descriptor of the 4518 * sd - the socket descriptor of the association to be closed.
5138 * how - Specifies the type of shutdo 4519 * how - Specifies the type of shutdown. The values are
5139 * as follows: 4520 * as follows:
5140 * SHUT_RD 4521 * SHUT_RD
5141 * Disables further recei 4522 * Disables further receive operations. No SCTP
5142 * protocol action is tak 4523 * protocol action is taken.
5143 * SHUT_WR 4524 * SHUT_WR
5144 * Disables further send 4525 * Disables further send operations, and initiates
5145 * the SCTP shutdown sequ 4526 * the SCTP shutdown sequence.
5146 * SHUT_RDWR 4527 * SHUT_RDWR
5147 * Disables further send 4528 * Disables further send and receive operations
5148 * and initiates the SCTP 4529 * and initiates the SCTP shutdown sequence.
5149 */ 4530 */
5150 static void sctp_shutdown(struct sock *sk, in 4531 static void sctp_shutdown(struct sock *sk, int how)
5151 { 4532 {
5152 struct net *net = sock_net(sk); 4533 struct net *net = sock_net(sk);
5153 struct sctp_endpoint *ep; 4534 struct sctp_endpoint *ep;
5154 4535
5155 if (!sctp_style(sk, TCP)) 4536 if (!sctp_style(sk, TCP))
5156 return; 4537 return;
5157 4538
5158 ep = sctp_sk(sk)->ep; 4539 ep = sctp_sk(sk)->ep;
5159 if (how & SEND_SHUTDOWN && !list_empt 4540 if (how & SEND_SHUTDOWN && !list_empty(&ep->asocs)) {
5160 struct sctp_association *asoc 4541 struct sctp_association *asoc;
5161 4542
5162 inet_sk_set_state(sk, SCTP_SS !! 4543 sk->sk_state = SCTP_SS_CLOSING;
5163 asoc = list_entry(ep->asocs.n 4544 asoc = list_entry(ep->asocs.next,
5164 struct sctp 4545 struct sctp_association, asocs);
5165 sctp_primitive_SHUTDOWN(net, 4546 sctp_primitive_SHUTDOWN(net, asoc, NULL);
5166 } 4547 }
5167 } 4548 }
5168 4549
5169 int sctp_get_sctp_info(struct sock *sk, struc 4550 int sctp_get_sctp_info(struct sock *sk, struct sctp_association *asoc,
5170 struct sctp_info *info 4551 struct sctp_info *info)
5171 { 4552 {
5172 struct sctp_transport *prim; 4553 struct sctp_transport *prim;
5173 struct list_head *pos; 4554 struct list_head *pos;
5174 int mask; 4555 int mask;
5175 4556
5176 memset(info, 0, sizeof(*info)); 4557 memset(info, 0, sizeof(*info));
5177 if (!asoc) { 4558 if (!asoc) {
5178 struct sctp_sock *sp = sctp_s 4559 struct sctp_sock *sp = sctp_sk(sk);
5179 4560
5180 info->sctpi_s_autoclose = sp- 4561 info->sctpi_s_autoclose = sp->autoclose;
5181 info->sctpi_s_adaptation_ind 4562 info->sctpi_s_adaptation_ind = sp->adaptation_ind;
5182 info->sctpi_s_pd_point = sp-> 4563 info->sctpi_s_pd_point = sp->pd_point;
5183 info->sctpi_s_nodelay = sp->n 4564 info->sctpi_s_nodelay = sp->nodelay;
5184 info->sctpi_s_disable_fragmen 4565 info->sctpi_s_disable_fragments = sp->disable_fragments;
5185 info->sctpi_s_v4mapped = sp-> 4566 info->sctpi_s_v4mapped = sp->v4mapped;
5186 info->sctpi_s_frag_interleave 4567 info->sctpi_s_frag_interleave = sp->frag_interleave;
5187 info->sctpi_s_type = sp->type 4568 info->sctpi_s_type = sp->type;
5188 4569
5189 return 0; 4570 return 0;
5190 } 4571 }
5191 4572
5192 info->sctpi_tag = asoc->c.my_vtag; 4573 info->sctpi_tag = asoc->c.my_vtag;
5193 info->sctpi_state = asoc->state; 4574 info->sctpi_state = asoc->state;
5194 info->sctpi_rwnd = asoc->a_rwnd; 4575 info->sctpi_rwnd = asoc->a_rwnd;
5195 info->sctpi_unackdata = asoc->unack_d 4576 info->sctpi_unackdata = asoc->unack_data;
5196 info->sctpi_penddata = sctp_tsnmap_pe 4577 info->sctpi_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map);
5197 info->sctpi_instrms = asoc->stream.in 4578 info->sctpi_instrms = asoc->stream.incnt;
5198 info->sctpi_outstrms = asoc->stream.o 4579 info->sctpi_outstrms = asoc->stream.outcnt;
5199 list_for_each(pos, &asoc->base.inqueu 4580 list_for_each(pos, &asoc->base.inqueue.in_chunk_list)
5200 info->sctpi_inqueue++; 4581 info->sctpi_inqueue++;
5201 list_for_each(pos, &asoc->outqueue.ou 4582 list_for_each(pos, &asoc->outqueue.out_chunk_list)
5202 info->sctpi_outqueue++; 4583 info->sctpi_outqueue++;
5203 info->sctpi_overall_error = asoc->ove 4584 info->sctpi_overall_error = asoc->overall_error_count;
5204 info->sctpi_max_burst = asoc->max_bur 4585 info->sctpi_max_burst = asoc->max_burst;
5205 info->sctpi_maxseg = asoc->frag_point 4586 info->sctpi_maxseg = asoc->frag_point;
5206 info->sctpi_peer_rwnd = asoc->peer.rw 4587 info->sctpi_peer_rwnd = asoc->peer.rwnd;
5207 info->sctpi_peer_tag = asoc->c.peer_v 4588 info->sctpi_peer_tag = asoc->c.peer_vtag;
5208 4589
5209 mask = asoc->peer.intl_capable << 1; !! 4590 mask = asoc->peer.ecn_capable << 1;
5210 mask = (mask | asoc->peer.ecn_capable <<
5211 mask = (mask | asoc->peer.ipv4_addres 4591 mask = (mask | asoc->peer.ipv4_address) << 1;
5212 mask = (mask | asoc->peer.ipv6_addres 4592 mask = (mask | asoc->peer.ipv6_address) << 1;
5213 mask = (mask | asoc->peer.reconf_capa !! 4593 mask = (mask | asoc->peer.hostname_address) << 1;
5214 mask = (mask | asoc->peer.asconf_capa 4594 mask = (mask | asoc->peer.asconf_capable) << 1;
5215 mask = (mask | asoc->peer.prsctp_capa 4595 mask = (mask | asoc->peer.prsctp_capable) << 1;
5216 mask = (mask | asoc->peer.auth_capabl 4596 mask = (mask | asoc->peer.auth_capable);
5217 info->sctpi_peer_capable = mask; 4597 info->sctpi_peer_capable = mask;
5218 mask = asoc->peer.sack_needed << 1; 4598 mask = asoc->peer.sack_needed << 1;
5219 mask = (mask | asoc->peer.sack_genera 4599 mask = (mask | asoc->peer.sack_generation) << 1;
5220 mask = (mask | asoc->peer.zero_window 4600 mask = (mask | asoc->peer.zero_window_announced);
5221 info->sctpi_peer_sack = mask; 4601 info->sctpi_peer_sack = mask;
5222 4602
5223 info->sctpi_isacks = asoc->stats.isac 4603 info->sctpi_isacks = asoc->stats.isacks;
5224 info->sctpi_osacks = asoc->stats.osac 4604 info->sctpi_osacks = asoc->stats.osacks;
5225 info->sctpi_opackets = asoc->stats.op 4605 info->sctpi_opackets = asoc->stats.opackets;
5226 info->sctpi_ipackets = asoc->stats.ip 4606 info->sctpi_ipackets = asoc->stats.ipackets;
5227 info->sctpi_rtxchunks = asoc->stats.r 4607 info->sctpi_rtxchunks = asoc->stats.rtxchunks;
5228 info->sctpi_outofseqtsns = asoc->stat 4608 info->sctpi_outofseqtsns = asoc->stats.outofseqtsns;
5229 info->sctpi_idupchunks = asoc->stats. 4609 info->sctpi_idupchunks = asoc->stats.idupchunks;
5230 info->sctpi_gapcnt = asoc->stats.gapc 4610 info->sctpi_gapcnt = asoc->stats.gapcnt;
5231 info->sctpi_ouodchunks = asoc->stats. 4611 info->sctpi_ouodchunks = asoc->stats.ouodchunks;
5232 info->sctpi_iuodchunks = asoc->stats. 4612 info->sctpi_iuodchunks = asoc->stats.iuodchunks;
5233 info->sctpi_oodchunks = asoc->stats.o 4613 info->sctpi_oodchunks = asoc->stats.oodchunks;
5234 info->sctpi_iodchunks = asoc->stats.i 4614 info->sctpi_iodchunks = asoc->stats.iodchunks;
5235 info->sctpi_octrlchunks = asoc->stats 4615 info->sctpi_octrlchunks = asoc->stats.octrlchunks;
5236 info->sctpi_ictrlchunks = asoc->stats 4616 info->sctpi_ictrlchunks = asoc->stats.ictrlchunks;
5237 4617
5238 prim = asoc->peer.primary_path; 4618 prim = asoc->peer.primary_path;
5239 memcpy(&info->sctpi_p_address, &prim- 4619 memcpy(&info->sctpi_p_address, &prim->ipaddr, sizeof(prim->ipaddr));
5240 info->sctpi_p_state = prim->state; 4620 info->sctpi_p_state = prim->state;
5241 info->sctpi_p_cwnd = prim->cwnd; 4621 info->sctpi_p_cwnd = prim->cwnd;
5242 info->sctpi_p_srtt = prim->srtt; 4622 info->sctpi_p_srtt = prim->srtt;
5243 info->sctpi_p_rto = jiffies_to_msecs( 4623 info->sctpi_p_rto = jiffies_to_msecs(prim->rto);
5244 info->sctpi_p_hbinterval = prim->hbin 4624 info->sctpi_p_hbinterval = prim->hbinterval;
5245 info->sctpi_p_pathmaxrxt = prim->path 4625 info->sctpi_p_pathmaxrxt = prim->pathmaxrxt;
5246 info->sctpi_p_sackdelay = jiffies_to_ 4626 info->sctpi_p_sackdelay = jiffies_to_msecs(prim->sackdelay);
5247 info->sctpi_p_ssthresh = prim->ssthre 4627 info->sctpi_p_ssthresh = prim->ssthresh;
5248 info->sctpi_p_partial_bytes_acked = p 4628 info->sctpi_p_partial_bytes_acked = prim->partial_bytes_acked;
5249 info->sctpi_p_flight_size = prim->fli 4629 info->sctpi_p_flight_size = prim->flight_size;
5250 info->sctpi_p_error = prim->error_cou 4630 info->sctpi_p_error = prim->error_count;
5251 4631
5252 return 0; 4632 return 0;
5253 } 4633 }
5254 EXPORT_SYMBOL_GPL(sctp_get_sctp_info); 4634 EXPORT_SYMBOL_GPL(sctp_get_sctp_info);
5255 4635
5256 /* use callback to avoid exporting the core s 4636 /* use callback to avoid exporting the core structure */
5257 void sctp_transport_walk_start(struct rhashta !! 4637 int sctp_transport_walk_start(struct rhashtable_iter *iter)
5258 { 4638 {
>> 4639 int err;
>> 4640
5259 rhltable_walk_enter(&sctp_transport_h 4641 rhltable_walk_enter(&sctp_transport_hashtable, iter);
5260 4642
5261 rhashtable_walk_start(iter); !! 4643 err = rhashtable_walk_start(iter);
>> 4644 if (err && err != -EAGAIN) {
>> 4645 rhashtable_walk_stop(iter);
>> 4646 rhashtable_walk_exit(iter);
>> 4647 return err;
>> 4648 }
>> 4649
>> 4650 return 0;
5262 } 4651 }
5263 4652
5264 void sctp_transport_walk_stop(struct rhashtab !! 4653 void sctp_transport_walk_stop(struct rhashtable_iter *iter)
5265 { 4654 {
5266 rhashtable_walk_stop(iter); 4655 rhashtable_walk_stop(iter);
5267 rhashtable_walk_exit(iter); 4656 rhashtable_walk_exit(iter);
5268 } 4657 }
5269 4658
5270 struct sctp_transport *sctp_transport_get_nex 4659 struct sctp_transport *sctp_transport_get_next(struct net *net,
5271 4660 struct rhashtable_iter *iter)
5272 { 4661 {
5273 struct sctp_transport *t; 4662 struct sctp_transport *t;
5274 4663
5275 t = rhashtable_walk_next(iter); 4664 t = rhashtable_walk_next(iter);
5276 for (; t; t = rhashtable_walk_next(it 4665 for (; t; t = rhashtable_walk_next(iter)) {
5277 if (IS_ERR(t)) { 4666 if (IS_ERR(t)) {
5278 if (PTR_ERR(t) == -EA 4667 if (PTR_ERR(t) == -EAGAIN)
5279 continue; 4668 continue;
5280 break; 4669 break;
5281 } 4670 }
5282 4671
5283 if (!sctp_transport_hold(t)) 4672 if (!sctp_transport_hold(t))
5284 continue; 4673 continue;
5285 4674
5286 if (net_eq(t->asoc->base.net, !! 4675 if (net_eq(sock_net(t->asoc->base.sk), net) &&
5287 t->asoc->peer.primary_pat 4676 t->asoc->peer.primary_path == t)
5288 break; 4677 break;
5289 4678
5290 sctp_transport_put(t); 4679 sctp_transport_put(t);
5291 } 4680 }
5292 4681
5293 return t; 4682 return t;
5294 } 4683 }
5295 4684
5296 struct sctp_transport *sctp_transport_get_idx 4685 struct sctp_transport *sctp_transport_get_idx(struct net *net,
5297 4686 struct rhashtable_iter *iter,
5298 4687 int pos)
5299 { 4688 {
5300 struct sctp_transport *t; 4689 struct sctp_transport *t;
5301 4690
5302 if (!pos) 4691 if (!pos)
5303 return SEQ_START_TOKEN; 4692 return SEQ_START_TOKEN;
5304 4693
5305 while ((t = sctp_transport_get_next(n 4694 while ((t = sctp_transport_get_next(net, iter)) && !IS_ERR(t)) {
5306 if (!--pos) 4695 if (!--pos)
5307 break; 4696 break;
5308 sctp_transport_put(t); 4697 sctp_transport_put(t);
5309 } 4698 }
5310 4699
5311 return t; 4700 return t;
5312 } 4701 }
5313 4702
5314 int sctp_for_each_endpoint(int (*cb)(struct s 4703 int sctp_for_each_endpoint(int (*cb)(struct sctp_endpoint *, void *),
5315 void *p) { 4704 void *p) {
5316 int err = 0; 4705 int err = 0;
5317 int hash = 0; 4706 int hash = 0;
5318 struct sctp_endpoint *ep; !! 4707 struct sctp_ep_common *epb;
5319 struct sctp_hashbucket *head; 4708 struct sctp_hashbucket *head;
5320 4709
5321 for (head = sctp_ep_hashtable; hash < 4710 for (head = sctp_ep_hashtable; hash < sctp_ep_hashsize;
5322 hash++, head++) { 4711 hash++, head++) {
5323 read_lock_bh(&head->lock); 4712 read_lock_bh(&head->lock);
5324 sctp_for_each_hentry(ep, &hea !! 4713 sctp_for_each_hentry(epb, &head->chain) {
5325 err = cb(ep, p); !! 4714 err = cb(sctp_ep(epb), p);
5326 if (err) 4715 if (err)
5327 break; 4716 break;
5328 } 4717 }
5329 read_unlock_bh(&head->lock); 4718 read_unlock_bh(&head->lock);
5330 } 4719 }
5331 4720
5332 return err; 4721 return err;
5333 } 4722 }
5334 EXPORT_SYMBOL_GPL(sctp_for_each_endpoint); 4723 EXPORT_SYMBOL_GPL(sctp_for_each_endpoint);
5335 4724
5336 int sctp_transport_lookup_process(sctp_callba !! 4725 int sctp_transport_lookup_process(int (*cb)(struct sctp_transport *, void *),
>> 4726 struct net *net,
5337 const union 4727 const union sctp_addr *laddr,
5338 const union !! 4728 const union sctp_addr *paddr, void *p)
5339 { 4729 {
5340 struct sctp_transport *transport; 4730 struct sctp_transport *transport;
5341 struct sctp_endpoint *ep; !! 4731 int err;
5342 int err = -ENOENT; <<
5343 4732
5344 rcu_read_lock(); 4733 rcu_read_lock();
5345 transport = sctp_addrs_lookup_transpo !! 4734 transport = sctp_addrs_lookup_transport(net, laddr, paddr);
5346 if (!transport) { <<
5347 rcu_read_unlock(); <<
5348 return err; <<
5349 } <<
5350 ep = transport->asoc->ep; <<
5351 if (!sctp_endpoint_hold(ep)) { /* aso <<
5352 sctp_transport_put(transport) <<
5353 rcu_read_unlock(); <<
5354 return err; <<
5355 } <<
5356 rcu_read_unlock(); 4735 rcu_read_unlock();
>> 4736 if (!transport)
>> 4737 return -ENOENT;
5357 4738
5358 err = cb(ep, transport, p); !! 4739 err = cb(transport, p);
5359 sctp_endpoint_put(ep); <<
5360 sctp_transport_put(transport); 4740 sctp_transport_put(transport);
>> 4741
5361 return err; 4742 return err;
5362 } 4743 }
5363 EXPORT_SYMBOL_GPL(sctp_transport_lookup_proce 4744 EXPORT_SYMBOL_GPL(sctp_transport_lookup_process);
5364 4745
5365 int sctp_transport_traverse_process(sctp_call 4746 int sctp_transport_traverse_process(sctp_callback_t cb, sctp_callback_t cb_done,
5366 struct ne 4747 struct net *net, int *pos, void *p)
5367 { 4748 {
5368 struct rhashtable_iter hti; 4749 struct rhashtable_iter hti;
5369 struct sctp_transport *tsp; 4750 struct sctp_transport *tsp;
5370 struct sctp_endpoint *ep; 4751 struct sctp_endpoint *ep;
5371 int ret; 4752 int ret;
5372 4753
5373 again: 4754 again:
5374 ret = 0; !! 4755 ret = sctp_transport_walk_start(&hti);
5375 sctp_transport_walk_start(&hti); !! 4756 if (ret)
>> 4757 return ret;
5376 4758
5377 tsp = sctp_transport_get_idx(net, &ht 4759 tsp = sctp_transport_get_idx(net, &hti, *pos + 1);
5378 for (; !IS_ERR_OR_NULL(tsp); tsp = sc 4760 for (; !IS_ERR_OR_NULL(tsp); tsp = sctp_transport_get_next(net, &hti)) {
5379 ep = tsp->asoc->ep; 4761 ep = tsp->asoc->ep;
5380 if (sctp_endpoint_hold(ep)) { 4762 if (sctp_endpoint_hold(ep)) { /* asoc can be peeled off */
5381 ret = cb(ep, tsp, p); 4763 ret = cb(ep, tsp, p);
5382 if (ret) 4764 if (ret)
5383 break; 4765 break;
5384 sctp_endpoint_put(ep) 4766 sctp_endpoint_put(ep);
5385 } 4767 }
5386 (*pos)++; 4768 (*pos)++;
5387 sctp_transport_put(tsp); 4769 sctp_transport_put(tsp);
5388 } 4770 }
5389 sctp_transport_walk_stop(&hti); 4771 sctp_transport_walk_stop(&hti);
5390 4772
5391 if (ret) { 4773 if (ret) {
5392 if (cb_done && !cb_done(ep, t 4774 if (cb_done && !cb_done(ep, tsp, p)) {
5393 (*pos)++; 4775 (*pos)++;
5394 sctp_endpoint_put(ep) 4776 sctp_endpoint_put(ep);
5395 sctp_transport_put(ts 4777 sctp_transport_put(tsp);
5396 goto again; 4778 goto again;
5397 } 4779 }
5398 sctp_endpoint_put(ep); 4780 sctp_endpoint_put(ep);
5399 sctp_transport_put(tsp); 4781 sctp_transport_put(tsp);
5400 } 4782 }
5401 4783
5402 return ret; 4784 return ret;
5403 } 4785 }
5404 EXPORT_SYMBOL_GPL(sctp_transport_traverse_pro 4786 EXPORT_SYMBOL_GPL(sctp_transport_traverse_process);
5405 4787
5406 /* 7.2.1 Association Status (SCTP_STATUS) 4788 /* 7.2.1 Association Status (SCTP_STATUS)
5407 4789
5408 * Applications can retrieve current status i 4790 * Applications can retrieve current status information about an
5409 * association, including association state, 4791 * association, including association state, peer receiver window size,
5410 * number of unacked data chunks, and number 4792 * number of unacked data chunks, and number of data chunks pending
5411 * receipt. This information is read-only. 4793 * receipt. This information is read-only.
5412 */ 4794 */
5413 static int sctp_getsockopt_sctp_status(struct 4795 static int sctp_getsockopt_sctp_status(struct sock *sk, int len,
5414 char _ 4796 char __user *optval,
5415 int __ 4797 int __user *optlen)
5416 { 4798 {
5417 struct sctp_status status; 4799 struct sctp_status status;
5418 struct sctp_association *asoc = NULL; 4800 struct sctp_association *asoc = NULL;
5419 struct sctp_transport *transport; 4801 struct sctp_transport *transport;
5420 sctp_assoc_t associd; 4802 sctp_assoc_t associd;
5421 int retval = 0; 4803 int retval = 0;
5422 4804
5423 if (len < sizeof(status)) { 4805 if (len < sizeof(status)) {
5424 retval = -EINVAL; 4806 retval = -EINVAL;
5425 goto out; 4807 goto out;
5426 } 4808 }
5427 4809
5428 len = sizeof(status); 4810 len = sizeof(status);
5429 if (copy_from_user(&status, optval, l 4811 if (copy_from_user(&status, optval, len)) {
5430 retval = -EFAULT; 4812 retval = -EFAULT;
5431 goto out; 4813 goto out;
5432 } 4814 }
5433 4815
5434 associd = status.sstat_assoc_id; 4816 associd = status.sstat_assoc_id;
5435 asoc = sctp_id2assoc(sk, associd); 4817 asoc = sctp_id2assoc(sk, associd);
5436 if (!asoc) { 4818 if (!asoc) {
5437 retval = -EINVAL; 4819 retval = -EINVAL;
5438 goto out; 4820 goto out;
5439 } 4821 }
5440 4822
5441 transport = asoc->peer.primary_path; 4823 transport = asoc->peer.primary_path;
5442 4824
5443 status.sstat_assoc_id = sctp_assoc2id 4825 status.sstat_assoc_id = sctp_assoc2id(asoc);
5444 status.sstat_state = sctp_assoc_to_st 4826 status.sstat_state = sctp_assoc_to_state(asoc);
5445 status.sstat_rwnd = asoc->peer.rwnd; 4827 status.sstat_rwnd = asoc->peer.rwnd;
5446 status.sstat_unackdata = asoc->unack_ 4828 status.sstat_unackdata = asoc->unack_data;
5447 4829
5448 status.sstat_penddata = sctp_tsnmap_p 4830 status.sstat_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map);
5449 status.sstat_instrms = asoc->stream.i 4831 status.sstat_instrms = asoc->stream.incnt;
5450 status.sstat_outstrms = asoc->stream. 4832 status.sstat_outstrms = asoc->stream.outcnt;
5451 status.sstat_fragmentation_point = as 4833 status.sstat_fragmentation_point = asoc->frag_point;
5452 status.sstat_primary.spinfo_assoc_id 4834 status.sstat_primary.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
5453 memcpy(&status.sstat_primary.spinfo_a 4835 memcpy(&status.sstat_primary.spinfo_address, &transport->ipaddr,
5454 transport->af_specifi 4836 transport->af_specific->sockaddr_len);
5455 /* Map ipv4 address into v4-mapped-on 4837 /* Map ipv4 address into v4-mapped-on-v6 address. */
5456 sctp_get_pf_specific(sk->sk_family)-> 4838 sctp_get_pf_specific(sk->sk_family)->addr_to_user(sctp_sk(sk),
5457 (union sctp_addr *)&status.ss 4839 (union sctp_addr *)&status.sstat_primary.spinfo_address);
5458 status.sstat_primary.spinfo_state = t 4840 status.sstat_primary.spinfo_state = transport->state;
5459 status.sstat_primary.spinfo_cwnd = tr 4841 status.sstat_primary.spinfo_cwnd = transport->cwnd;
5460 status.sstat_primary.spinfo_srtt = tr 4842 status.sstat_primary.spinfo_srtt = transport->srtt;
5461 status.sstat_primary.spinfo_rto = jif 4843 status.sstat_primary.spinfo_rto = jiffies_to_msecs(transport->rto);
5462 status.sstat_primary.spinfo_mtu = tra 4844 status.sstat_primary.spinfo_mtu = transport->pathmtu;
5463 4845
5464 if (status.sstat_primary.spinfo_state 4846 if (status.sstat_primary.spinfo_state == SCTP_UNKNOWN)
5465 status.sstat_primary.spinfo_s 4847 status.sstat_primary.spinfo_state = SCTP_ACTIVE;
5466 4848
5467 if (put_user(len, optlen)) { 4849 if (put_user(len, optlen)) {
5468 retval = -EFAULT; 4850 retval = -EFAULT;
5469 goto out; 4851 goto out;
5470 } 4852 }
5471 4853
5472 pr_debug("%s: len:%d, state:%d, rwnd: 4854 pr_debug("%s: len:%d, state:%d, rwnd:%d, assoc_id:%d\n",
5473 __func__, len, status.sstat_ 4855 __func__, len, status.sstat_state, status.sstat_rwnd,
5474 status.sstat_assoc_id); 4856 status.sstat_assoc_id);
5475 4857
5476 if (copy_to_user(optval, &status, len 4858 if (copy_to_user(optval, &status, len)) {
5477 retval = -EFAULT; 4859 retval = -EFAULT;
5478 goto out; 4860 goto out;
5479 } 4861 }
5480 4862
5481 out: 4863 out:
5482 return retval; 4864 return retval;
5483 } 4865 }
5484 4866
5485 4867
5486 /* 7.2.2 Peer Address Information (SCTP_GET_P 4868 /* 7.2.2 Peer Address Information (SCTP_GET_PEER_ADDR_INFO)
5487 * 4869 *
5488 * Applications can retrieve information abou 4870 * Applications can retrieve information about a specific peer address
5489 * of an association, including its reachabil 4871 * of an association, including its reachability state, congestion
5490 * window, and retransmission timer values. 4872 * window, and retransmission timer values. This information is
5491 * read-only. 4873 * read-only.
5492 */ 4874 */
5493 static int sctp_getsockopt_peer_addr_info(str 4875 static int sctp_getsockopt_peer_addr_info(struct sock *sk, int len,
5494 cha 4876 char __user *optval,
5495 int 4877 int __user *optlen)
5496 { 4878 {
5497 struct sctp_paddrinfo pinfo; 4879 struct sctp_paddrinfo pinfo;
5498 struct sctp_transport *transport; 4880 struct sctp_transport *transport;
5499 int retval = 0; 4881 int retval = 0;
5500 4882
5501 if (len < sizeof(pinfo)) { 4883 if (len < sizeof(pinfo)) {
5502 retval = -EINVAL; 4884 retval = -EINVAL;
5503 goto out; 4885 goto out;
5504 } 4886 }
5505 4887
5506 len = sizeof(pinfo); 4888 len = sizeof(pinfo);
5507 if (copy_from_user(&pinfo, optval, le 4889 if (copy_from_user(&pinfo, optval, len)) {
5508 retval = -EFAULT; 4890 retval = -EFAULT;
5509 goto out; 4891 goto out;
5510 } 4892 }
5511 4893
5512 transport = sctp_addr_id2transport(sk 4894 transport = sctp_addr_id2transport(sk, &pinfo.spinfo_address,
5513 pi 4895 pinfo.spinfo_assoc_id);
5514 if (!transport) { !! 4896 if (!transport)
5515 retval = -EINVAL; !! 4897 return -EINVAL;
5516 goto out; <<
5517 } <<
5518 <<
5519 if (transport->state == SCTP_PF && <<
5520 transport->asoc->pf_expose == SCT <<
5521 retval = -EACCES; <<
5522 goto out; <<
5523 } <<
5524 4898
5525 pinfo.spinfo_assoc_id = sctp_assoc2id 4899 pinfo.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
5526 pinfo.spinfo_state = transport->state 4900 pinfo.spinfo_state = transport->state;
5527 pinfo.spinfo_cwnd = transport->cwnd; 4901 pinfo.spinfo_cwnd = transport->cwnd;
5528 pinfo.spinfo_srtt = transport->srtt; 4902 pinfo.spinfo_srtt = transport->srtt;
5529 pinfo.spinfo_rto = jiffies_to_msecs(t 4903 pinfo.spinfo_rto = jiffies_to_msecs(transport->rto);
5530 pinfo.spinfo_mtu = transport->pathmtu 4904 pinfo.spinfo_mtu = transport->pathmtu;
5531 4905
5532 if (pinfo.spinfo_state == SCTP_UNKNOW 4906 if (pinfo.spinfo_state == SCTP_UNKNOWN)
5533 pinfo.spinfo_state = SCTP_ACT 4907 pinfo.spinfo_state = SCTP_ACTIVE;
5534 4908
5535 if (put_user(len, optlen)) { 4909 if (put_user(len, optlen)) {
5536 retval = -EFAULT; 4910 retval = -EFAULT;
5537 goto out; 4911 goto out;
5538 } 4912 }
5539 4913
5540 if (copy_to_user(optval, &pinfo, len) 4914 if (copy_to_user(optval, &pinfo, len)) {
5541 retval = -EFAULT; 4915 retval = -EFAULT;
5542 goto out; 4916 goto out;
5543 } 4917 }
5544 4918
5545 out: 4919 out:
5546 return retval; 4920 return retval;
5547 } 4921 }
5548 4922
5549 /* 7.1.12 Enable/Disable message fragmentatio 4923 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
5550 * 4924 *
5551 * This option is a on/off flag. If enabled 4925 * This option is a on/off flag. If enabled no SCTP message
5552 * fragmentation will be performed. Instead 4926 * fragmentation will be performed. Instead if a message being sent
5553 * exceeds the current PMTU size, the message 4927 * exceeds the current PMTU size, the message will NOT be sent and
5554 * instead a error will be indicated to the u 4928 * instead a error will be indicated to the user.
5555 */ 4929 */
5556 static int sctp_getsockopt_disable_fragments( 4930 static int sctp_getsockopt_disable_fragments(struct sock *sk, int len,
5557 char 4931 char __user *optval, int __user *optlen)
5558 { 4932 {
5559 int val; 4933 int val;
5560 4934
5561 if (len < sizeof(int)) 4935 if (len < sizeof(int))
5562 return -EINVAL; 4936 return -EINVAL;
5563 4937
5564 len = sizeof(int); 4938 len = sizeof(int);
5565 val = (sctp_sk(sk)->disable_fragments 4939 val = (sctp_sk(sk)->disable_fragments == 1);
5566 if (put_user(len, optlen)) 4940 if (put_user(len, optlen))
5567 return -EFAULT; 4941 return -EFAULT;
5568 if (copy_to_user(optval, &val, len)) 4942 if (copy_to_user(optval, &val, len))
5569 return -EFAULT; 4943 return -EFAULT;
5570 return 0; 4944 return 0;
5571 } 4945 }
5572 4946
5573 /* 7.1.15 Set notification and ancillary even 4947 /* 7.1.15 Set notification and ancillary events (SCTP_EVENTS)
5574 * 4948 *
5575 * This socket option is used to specify vari 4949 * This socket option is used to specify various notifications and
5576 * ancillary data the user wishes to receive. 4950 * ancillary data the user wishes to receive.
5577 */ 4951 */
5578 static int sctp_getsockopt_events(struct sock 4952 static int sctp_getsockopt_events(struct sock *sk, int len, char __user *optval,
5579 int __user 4953 int __user *optlen)
5580 { 4954 {
5581 struct sctp_event_subscribe subscribe <<
5582 __u8 *sn_type = (__u8 *)&subscribe; <<
5583 int i; <<
5584 <<
5585 if (len == 0) 4955 if (len == 0)
5586 return -EINVAL; 4956 return -EINVAL;
5587 if (len > sizeof(struct sctp_event_su 4957 if (len > sizeof(struct sctp_event_subscribe))
5588 len = sizeof(struct sctp_even 4958 len = sizeof(struct sctp_event_subscribe);
5589 if (put_user(len, optlen)) 4959 if (put_user(len, optlen))
5590 return -EFAULT; 4960 return -EFAULT;
5591 !! 4961 if (copy_to_user(optval, &sctp_sk(sk)->subscribe, len))
5592 for (i = 0; i < len; i++) <<
5593 sn_type[i] = sctp_ulpevent_ty <<
5594 <<
5595 <<
5596 if (copy_to_user(optval, &subscribe, <<
5597 return -EFAULT; 4962 return -EFAULT;
5598 <<
5599 return 0; 4963 return 0;
5600 } 4964 }
5601 4965
5602 /* 7.1.8 Automatic Close of associations (SCT 4966 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
5603 * 4967 *
5604 * This socket option is applicable to the UD 4968 * This socket option is applicable to the UDP-style socket only. When
5605 * set it will cause associations that are id 4969 * set it will cause associations that are idle for more than the
5606 * specified number of seconds to automatical 4970 * specified number of seconds to automatically close. An association
5607 * being idle is defined an association that 4971 * being idle is defined an association that has NOT sent or received
5608 * user data. The special value of '' indica 4972 * user data. The special value of '' indicates that no automatic
5609 * close of any associations should be perfor 4973 * close of any associations should be performed. The option expects an
5610 * integer defining the number of seconds of 4974 * integer defining the number of seconds of idle time before an
5611 * association is closed. 4975 * association is closed.
5612 */ 4976 */
5613 static int sctp_getsockopt_autoclose(struct s 4977 static int sctp_getsockopt_autoclose(struct sock *sk, int len, char __user *optval, int __user *optlen)
5614 { 4978 {
5615 /* Applicable to UDP-style socket onl 4979 /* Applicable to UDP-style socket only */
5616 if (sctp_style(sk, TCP)) 4980 if (sctp_style(sk, TCP))
5617 return -EOPNOTSUPP; 4981 return -EOPNOTSUPP;
5618 if (len < sizeof(int)) 4982 if (len < sizeof(int))
5619 return -EINVAL; 4983 return -EINVAL;
5620 len = sizeof(int); 4984 len = sizeof(int);
5621 if (put_user(len, optlen)) 4985 if (put_user(len, optlen))
5622 return -EFAULT; 4986 return -EFAULT;
5623 if (put_user(sctp_sk(sk)->autoclose, !! 4987 if (copy_to_user(optval, &sctp_sk(sk)->autoclose, len))
5624 return -EFAULT; 4988 return -EFAULT;
5625 return 0; 4989 return 0;
5626 } 4990 }
5627 4991
5628 /* Helper routine to branch off an associatio 4992 /* Helper routine to branch off an association to a new socket. */
5629 int sctp_do_peeloff(struct sock *sk, sctp_ass 4993 int sctp_do_peeloff(struct sock *sk, sctp_assoc_t id, struct socket **sockp)
5630 { 4994 {
5631 struct sctp_association *asoc = sctp_ 4995 struct sctp_association *asoc = sctp_id2assoc(sk, id);
5632 struct sctp_sock *sp = sctp_sk(sk); 4996 struct sctp_sock *sp = sctp_sk(sk);
5633 struct socket *sock; 4997 struct socket *sock;
5634 int err = 0; 4998 int err = 0;
5635 4999
5636 /* Do not peel off from one netns to 5000 /* Do not peel off from one netns to another one. */
5637 if (!net_eq(current->nsproxy->net_ns, 5001 if (!net_eq(current->nsproxy->net_ns, sock_net(sk)))
5638 return -EINVAL; 5002 return -EINVAL;
5639 5003
5640 if (!asoc) 5004 if (!asoc)
5641 return -EINVAL; 5005 return -EINVAL;
5642 5006
5643 /* An association cannot be branched 5007 /* An association cannot be branched off from an already peeled-off
5644 * socket, nor is this supported for 5008 * socket, nor is this supported for tcp style sockets.
5645 */ 5009 */
5646 if (!sctp_style(sk, UDP)) 5010 if (!sctp_style(sk, UDP))
5647 return -EINVAL; 5011 return -EINVAL;
5648 5012
5649 /* Create a new socket. */ 5013 /* Create a new socket. */
5650 err = sock_create(sk->sk_family, SOCK 5014 err = sock_create(sk->sk_family, SOCK_SEQPACKET, IPPROTO_SCTP, &sock);
5651 if (err < 0) 5015 if (err < 0)
5652 return err; 5016 return err;
5653 5017
5654 sctp_copy_sock(sock->sk, sk, asoc); 5018 sctp_copy_sock(sock->sk, sk, asoc);
5655 5019
5656 /* Make peeled-off sockets more like 5020 /* Make peeled-off sockets more like 1-1 accepted sockets.
5657 * Set the daddr and initialize id to !! 5021 * Set the daddr and initialize id to something more random
5658 * copy over any ip options. <<
5659 */ 5022 */
5660 sp->pf->to_sk_daddr(&asoc->peer.prima !! 5023 sp->pf->to_sk_daddr(&asoc->peer.primary_addr, sk);
5661 sp->pf->copy_ip_options(sk, sock->sk) <<
5662 5024
5663 /* Populate the fields of the newsk f 5025 /* Populate the fields of the newsk from the oldsk and migrate the
5664 * asoc to the newsk. 5026 * asoc to the newsk.
5665 */ 5027 */
5666 err = sctp_sock_migrate(sk, sock->sk, !! 5028 sctp_sock_migrate(sk, sock->sk, asoc, SCTP_SOCKET_UDP_HIGH_BANDWIDTH);
5667 SCTP_SOCKET_U <<
5668 if (err) { <<
5669 sock_release(sock); <<
5670 sock = NULL; <<
5671 } <<
5672 5029
5673 *sockp = sock; 5030 *sockp = sock;
5674 5031
5675 return err; 5032 return err;
5676 } 5033 }
5677 EXPORT_SYMBOL(sctp_do_peeloff); 5034 EXPORT_SYMBOL(sctp_do_peeloff);
5678 5035
5679 static int sctp_getsockopt_peeloff_common(str 5036 static int sctp_getsockopt_peeloff_common(struct sock *sk, sctp_peeloff_arg_t *peeloff,
5680 str 5037 struct file **newfile, unsigned flags)
5681 { 5038 {
5682 struct socket *newsock; 5039 struct socket *newsock;
5683 int retval; 5040 int retval;
5684 5041
5685 retval = sctp_do_peeloff(sk, peeloff- 5042 retval = sctp_do_peeloff(sk, peeloff->associd, &newsock);
5686 if (retval < 0) 5043 if (retval < 0)
5687 goto out; 5044 goto out;
5688 5045
5689 /* Map the socket to an unused fd tha 5046 /* Map the socket to an unused fd that can be returned to the user. */
5690 retval = get_unused_fd_flags(flags & 5047 retval = get_unused_fd_flags(flags & SOCK_CLOEXEC);
5691 if (retval < 0) { 5048 if (retval < 0) {
5692 sock_release(newsock); 5049 sock_release(newsock);
5693 goto out; 5050 goto out;
5694 } 5051 }
5695 5052
5696 *newfile = sock_alloc_file(newsock, 0 5053 *newfile = sock_alloc_file(newsock, 0, NULL);
5697 if (IS_ERR(*newfile)) { 5054 if (IS_ERR(*newfile)) {
5698 put_unused_fd(retval); 5055 put_unused_fd(retval);
>> 5056 sock_release(newsock);
5699 retval = PTR_ERR(*newfile); 5057 retval = PTR_ERR(*newfile);
5700 *newfile = NULL; 5058 *newfile = NULL;
5701 return retval; 5059 return retval;
5702 } 5060 }
5703 5061
5704 pr_debug("%s: sk:%p, newsk:%p, sd:%d\ 5062 pr_debug("%s: sk:%p, newsk:%p, sd:%d\n", __func__, sk, newsock->sk,
5705 retval); 5063 retval);
5706 5064
5707 peeloff->sd = retval; 5065 peeloff->sd = retval;
5708 5066
5709 if (flags & SOCK_NONBLOCK) 5067 if (flags & SOCK_NONBLOCK)
5710 (*newfile)->f_flags |= O_NONB 5068 (*newfile)->f_flags |= O_NONBLOCK;
5711 out: 5069 out:
5712 return retval; 5070 return retval;
5713 } 5071 }
5714 5072
5715 static int sctp_getsockopt_peeloff(struct soc 5073 static int sctp_getsockopt_peeloff(struct sock *sk, int len, char __user *optval, int __user *optlen)
5716 { 5074 {
5717 sctp_peeloff_arg_t peeloff; 5075 sctp_peeloff_arg_t peeloff;
5718 struct file *newfile = NULL; 5076 struct file *newfile = NULL;
5719 int retval = 0; 5077 int retval = 0;
5720 5078
5721 if (len < sizeof(sctp_peeloff_arg_t)) 5079 if (len < sizeof(sctp_peeloff_arg_t))
5722 return -EINVAL; 5080 return -EINVAL;
5723 len = sizeof(sctp_peeloff_arg_t); 5081 len = sizeof(sctp_peeloff_arg_t);
5724 if (copy_from_user(&peeloff, optval, 5082 if (copy_from_user(&peeloff, optval, len))
5725 return -EFAULT; 5083 return -EFAULT;
5726 5084
5727 retval = sctp_getsockopt_peeloff_comm 5085 retval = sctp_getsockopt_peeloff_common(sk, &peeloff, &newfile, 0);
5728 if (retval < 0) 5086 if (retval < 0)
5729 goto out; 5087 goto out;
5730 5088
5731 /* Return the fd mapped to the new so 5089 /* Return the fd mapped to the new socket. */
5732 if (put_user(len, optlen)) { 5090 if (put_user(len, optlen)) {
5733 fput(newfile); 5091 fput(newfile);
5734 put_unused_fd(retval); 5092 put_unused_fd(retval);
5735 return -EFAULT; 5093 return -EFAULT;
5736 } 5094 }
5737 5095
5738 if (copy_to_user(optval, &peeloff, le 5096 if (copy_to_user(optval, &peeloff, len)) {
5739 fput(newfile); 5097 fput(newfile);
5740 put_unused_fd(retval); 5098 put_unused_fd(retval);
5741 return -EFAULT; 5099 return -EFAULT;
5742 } 5100 }
5743 fd_install(retval, newfile); 5101 fd_install(retval, newfile);
5744 out: 5102 out:
5745 return retval; 5103 return retval;
5746 } 5104 }
5747 5105
5748 static int sctp_getsockopt_peeloff_flags(stru 5106 static int sctp_getsockopt_peeloff_flags(struct sock *sk, int len,
5749 char 5107 char __user *optval, int __user *optlen)
5750 { 5108 {
5751 sctp_peeloff_flags_arg_t peeloff; 5109 sctp_peeloff_flags_arg_t peeloff;
5752 struct file *newfile = NULL; 5110 struct file *newfile = NULL;
5753 int retval = 0; 5111 int retval = 0;
5754 5112
5755 if (len < sizeof(sctp_peeloff_flags_a 5113 if (len < sizeof(sctp_peeloff_flags_arg_t))
5756 return -EINVAL; 5114 return -EINVAL;
5757 len = sizeof(sctp_peeloff_flags_arg_t 5115 len = sizeof(sctp_peeloff_flags_arg_t);
5758 if (copy_from_user(&peeloff, optval, 5116 if (copy_from_user(&peeloff, optval, len))
5759 return -EFAULT; 5117 return -EFAULT;
5760 5118
5761 retval = sctp_getsockopt_peeloff_comm 5119 retval = sctp_getsockopt_peeloff_common(sk, &peeloff.p_arg,
5762 5120 &newfile, peeloff.flags);
5763 if (retval < 0) 5121 if (retval < 0)
5764 goto out; 5122 goto out;
5765 5123
5766 /* Return the fd mapped to the new so 5124 /* Return the fd mapped to the new socket. */
5767 if (put_user(len, optlen)) { 5125 if (put_user(len, optlen)) {
5768 fput(newfile); 5126 fput(newfile);
5769 put_unused_fd(retval); 5127 put_unused_fd(retval);
5770 return -EFAULT; 5128 return -EFAULT;
5771 } 5129 }
5772 5130
5773 if (copy_to_user(optval, &peeloff, le 5131 if (copy_to_user(optval, &peeloff, len)) {
5774 fput(newfile); 5132 fput(newfile);
5775 put_unused_fd(retval); 5133 put_unused_fd(retval);
5776 return -EFAULT; 5134 return -EFAULT;
5777 } 5135 }
5778 fd_install(retval, newfile); 5136 fd_install(retval, newfile);
5779 out: 5137 out:
5780 return retval; 5138 return retval;
5781 } 5139 }
5782 5140
5783 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ 5141 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
5784 * 5142 *
5785 * Applications can enable or disable heartbe 5143 * Applications can enable or disable heartbeats for any peer address of
5786 * an association, modify an address's heartb 5144 * an association, modify an address's heartbeat interval, force a
5787 * heartbeat to be sent immediately, and adju 5145 * heartbeat to be sent immediately, and adjust the address's maximum
5788 * number of retransmissions sent before an a 5146 * number of retransmissions sent before an address is considered
5789 * unreachable. The following structure is u 5147 * unreachable. The following structure is used to access and modify an
5790 * address's parameters: 5148 * address's parameters:
5791 * 5149 *
5792 * struct sctp_paddrparams { 5150 * struct sctp_paddrparams {
5793 * sctp_assoc_t spp_assoc_id; 5151 * sctp_assoc_t spp_assoc_id;
5794 * struct sockaddr_storage spp_address; 5152 * struct sockaddr_storage spp_address;
5795 * uint32_t spp_hbinterval 5153 * uint32_t spp_hbinterval;
5796 * uint16_t spp_pathmaxrxt 5154 * uint16_t spp_pathmaxrxt;
5797 * uint32_t spp_pathmtu; 5155 * uint32_t spp_pathmtu;
5798 * uint32_t spp_sackdelay; 5156 * uint32_t spp_sackdelay;
5799 * uint32_t spp_flags; 5157 * uint32_t spp_flags;
5800 * }; 5158 * };
5801 * 5159 *
5802 * spp_assoc_id - (one-to-many style soc 5160 * spp_assoc_id - (one-to-many style socket) This is filled in the
5803 * application, and ident 5161 * application, and identifies the association for
5804 * this query. 5162 * this query.
5805 * spp_address - This specifies which a 5163 * spp_address - This specifies which address is of interest.
5806 * spp_hbinterval - This contains the valu 5164 * spp_hbinterval - This contains the value of the heartbeat interval,
5807 * in milliseconds. If a 5165 * in milliseconds. If a value of zero
5808 * is present in this fie 5166 * is present in this field then no changes are to
5809 * be made to this parame 5167 * be made to this parameter.
5810 * spp_pathmaxrxt - This contains the maxi 5168 * spp_pathmaxrxt - This contains the maximum number of
5811 * retransmissions before 5169 * retransmissions before this address shall be
5812 * considered unreachable 5170 * considered unreachable. If a value of zero
5813 * is present in this fie 5171 * is present in this field then no changes are to
5814 * be made to this parame 5172 * be made to this parameter.
5815 * spp_pathmtu - When Path MTU discover 5173 * spp_pathmtu - When Path MTU discovery is disabled the value
5816 * specified here will be 5174 * specified here will be the "fixed" path mtu.
5817 * Note that if the spp_a 5175 * Note that if the spp_address field is empty
5818 * then all associations 5176 * then all associations on this address will
5819 * have this fixed path m 5177 * have this fixed path mtu set upon them.
5820 * 5178 *
5821 * spp_sackdelay - When delayed sack is e 5179 * spp_sackdelay - When delayed sack is enabled, this value specifies
5822 * the number of millisec 5180 * the number of milliseconds that sacks will be delayed
5823 * for. This value will a 5181 * for. This value will apply to all addresses of an
5824 * association if the spp 5182 * association if the spp_address field is empty. Note
5825 * also, that if delayed 5183 * also, that if delayed sack is enabled and this
5826 * value is set to 0, no 5184 * value is set to 0, no change is made to the last
5827 * recorded delayed sack 5185 * recorded delayed sack timer value.
5828 * 5186 *
5829 * spp_flags - These flags are used t 5187 * spp_flags - These flags are used to control various features
5830 * on an association. The 5188 * on an association. The flag field may contain
5831 * zero or more of the fo 5189 * zero or more of the following options.
5832 * 5190 *
5833 * SPP_HB_ENABLE - Enabl 5191 * SPP_HB_ENABLE - Enable heartbeats on the
5834 * specified address. Not 5192 * specified address. Note that if the address
5835 * field is empty all add 5193 * field is empty all addresses for the association
5836 * have heartbeats enable 5194 * have heartbeats enabled upon them.
5837 * 5195 *
5838 * SPP_HB_DISABLE - Disab 5196 * SPP_HB_DISABLE - Disable heartbeats on the
5839 * speicifed address. Not 5197 * speicifed address. Note that if the address
5840 * field is empty all add 5198 * field is empty all addresses for the association
5841 * will have their heartb 5199 * will have their heartbeats disabled. Note also
5842 * that SPP_HB_ENABLE and 5200 * that SPP_HB_ENABLE and SPP_HB_DISABLE are
5843 * mutually exclusive, on 5201 * mutually exclusive, only one of these two should
5844 * be specified. Enabling 5202 * be specified. Enabling both fields will have
5845 * undetermined results. 5203 * undetermined results.
5846 * 5204 *
5847 * SPP_HB_DEMAND - Reques 5205 * SPP_HB_DEMAND - Request a user initiated heartbeat
5848 * to be made immediately 5206 * to be made immediately.
5849 * 5207 *
5850 * SPP_PMTUD_ENABLE - Thi 5208 * SPP_PMTUD_ENABLE - This field will enable PMTU
5851 * discovery upon the spe 5209 * discovery upon the specified address. Note that
5852 * if the address feild i 5210 * if the address feild is empty then all addresses
5853 * on the association are 5211 * on the association are effected.
5854 * 5212 *
5855 * SPP_PMTUD_DISABLE - Th 5213 * SPP_PMTUD_DISABLE - This field will disable PMTU
5856 * discovery upon the spe 5214 * discovery upon the specified address. Note that
5857 * if the address feild i 5215 * if the address feild is empty then all addresses
5858 * on the association are 5216 * on the association are effected. Not also that
5859 * SPP_PMTUD_ENABLE and S 5217 * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
5860 * exclusive. Enabling bo 5218 * exclusive. Enabling both will have undetermined
5861 * results. 5219 * results.
5862 * 5220 *
5863 * SPP_SACKDELAY_ENABLE - 5221 * SPP_SACKDELAY_ENABLE - Setting this flag turns
5864 * on delayed sack. The t 5222 * on delayed sack. The time specified in spp_sackdelay
5865 * is used to specify the 5223 * is used to specify the sack delay for this address. Note
5866 * that if spp_address is 5224 * that if spp_address is empty then all addresses will
5867 * enable delayed sack an 5225 * enable delayed sack and take on the sack delay
5868 * value specified in spp 5226 * value specified in spp_sackdelay.
5869 * SPP_SACKDELAY_DISABLE 5227 * SPP_SACKDELAY_DISABLE - Setting this flag turns
5870 * off delayed sack. If t 5228 * off delayed sack. If the spp_address field is blank then
5871 * delayed sack is disabl 5229 * delayed sack is disabled for the entire association. Note
5872 * also that this field i 5230 * also that this field is mutually exclusive to
5873 * SPP_SACKDELAY_ENABLE, 5231 * SPP_SACKDELAY_ENABLE, setting both will have undefined
5874 * results. 5232 * results.
5875 * <<
5876 * SPP_IPV6_FLOWLABEL: S <<
5877 * setting of the IPV6 fl <<
5878 * contained in the spp_i <<
5879 * Upon retrieval, this f <<
5880 * the spp_ipv6_flowlabel <<
5881 * If a specific destinat <<
5882 * spp_address field), th <<
5883 * the address. If just <<
5884 * no address), then the <<
5885 * is returned. If neith <<
5886 * is specified, then the <<
5887 * returned. For non-IPv <<
5888 * cleared. <<
5889 * <<
5890 * SPP_DSCP: Setting thi <<
5891 * Differentiated Service <<
5892 * associated with either <<
5893 * address. The value is <<
5894 * Upon retrieval, this f <<
5895 * the spp_dscp field has <<
5896 * specific destination a <<
5897 * spp_address field), th <<
5898 * address's DSCP value i <<
5899 * is specified, then the <<
5900 * returned. If neither <<
5901 * specified, then the so <<
5902 * <<
5903 * spp_ipv6_flowlabel <<
5904 * - This field is used in <<
5905 * SPP_IPV6_FLOWLABEL fla <<
5906 * The 20 least significa <<
5907 * label. This setting h <<
5908 * setting. <<
5909 * <<
5910 * spp_dscp - This field is used in <<
5911 * and contains the DSCP. <<
5912 * used for the DSCP. Th <<
5913 * IPv4- or IPv6- layer s <<
5914 */ 5233 */
5915 static int sctp_getsockopt_peer_addr_params(s 5234 static int sctp_getsockopt_peer_addr_params(struct sock *sk, int len,
5916 c 5235 char __user *optval, int __user *optlen)
5917 { 5236 {
5918 struct sctp_paddrparams params; 5237 struct sctp_paddrparams params;
5919 struct sctp_transport *trans = NULL 5238 struct sctp_transport *trans = NULL;
5920 struct sctp_association *asoc = NULL; 5239 struct sctp_association *asoc = NULL;
5921 struct sctp_sock *sp = sctp_sk 5240 struct sctp_sock *sp = sctp_sk(sk);
5922 5241
5923 if (len >= sizeof(params)) !! 5242 if (len < sizeof(struct sctp_paddrparams))
5924 len = sizeof(params); <<
5925 else if (len >= ALIGN(offsetof(struct <<
5926 spp_ip <<
5927 len = ALIGN(offsetof(struct s <<
5928 spp_ipv6 <<
5929 else <<
5930 return -EINVAL; 5243 return -EINVAL;
5931 !! 5244 len = sizeof(struct sctp_paddrparams);
5932 if (copy_from_user(¶ms, optval, l 5245 if (copy_from_user(¶ms, optval, len))
5933 return -EFAULT; 5246 return -EFAULT;
5934 5247
5935 /* If an address other than INADDR_AN 5248 /* If an address other than INADDR_ANY is specified, and
5936 * no transport is found, then the re 5249 * no transport is found, then the request is invalid.
5937 */ 5250 */
5938 if (!sctp_is_any(sk, (union sctp_addr 5251 if (!sctp_is_any(sk, (union sctp_addr *)¶ms.spp_address)) {
5939 trans = sctp_addr_id2transpor 5252 trans = sctp_addr_id2transport(sk, ¶ms.spp_address,
5940 5253 params.spp_assoc_id);
5941 if (!trans) { 5254 if (!trans) {
5942 pr_debug("%s: failed 5255 pr_debug("%s: failed no transport\n", __func__);
5943 return -EINVAL; 5256 return -EINVAL;
5944 } 5257 }
5945 } 5258 }
5946 5259
5947 /* Get association, if assoc_id != SC !! 5260 /* Get association, if assoc_id != 0 and the socket is a one
5948 * socket is a one to many style sock !! 5261 * to many style socket, and an association was not found, then
5949 * was not found, then the id was inv !! 5262 * the id was invalid.
5950 */ 5263 */
5951 asoc = sctp_id2assoc(sk, params.spp_a 5264 asoc = sctp_id2assoc(sk, params.spp_assoc_id);
5952 if (!asoc && params.spp_assoc_id != S !! 5265 if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP)) {
5953 sctp_style(sk, UDP)) { <<
5954 pr_debug("%s: failed no assoc 5266 pr_debug("%s: failed no association\n", __func__);
5955 return -EINVAL; 5267 return -EINVAL;
5956 } 5268 }
5957 5269
5958 if (trans) { 5270 if (trans) {
5959 /* Fetch transport values. */ 5271 /* Fetch transport values. */
5960 params.spp_hbinterval = jiffi 5272 params.spp_hbinterval = jiffies_to_msecs(trans->hbinterval);
5961 params.spp_pathmtu = trans 5273 params.spp_pathmtu = trans->pathmtu;
5962 params.spp_pathmaxrxt = trans 5274 params.spp_pathmaxrxt = trans->pathmaxrxt;
5963 params.spp_sackdelay = jiffi 5275 params.spp_sackdelay = jiffies_to_msecs(trans->sackdelay);
5964 5276
5965 /*draft-11 doesn't say what t 5277 /*draft-11 doesn't say what to return in spp_flags*/
5966 params.spp_flags = trans 5278 params.spp_flags = trans->param_flags;
5967 if (trans->flowlabel & SCTP_F <<
5968 params.spp_ipv6_flowl <<
5969 <<
5970 params.spp_flags |= S <<
5971 } <<
5972 if (trans->dscp & SCTP_DSCP_S <<
5973 params.spp_dscp = tra <<
5974 params.spp_flags |= S <<
5975 } <<
5976 } else if (asoc) { 5279 } else if (asoc) {
5977 /* Fetch association values. 5280 /* Fetch association values. */
5978 params.spp_hbinterval = jiffi 5281 params.spp_hbinterval = jiffies_to_msecs(asoc->hbinterval);
5979 params.spp_pathmtu = asoc- 5282 params.spp_pathmtu = asoc->pathmtu;
5980 params.spp_pathmaxrxt = asoc- 5283 params.spp_pathmaxrxt = asoc->pathmaxrxt;
5981 params.spp_sackdelay = jiffi 5284 params.spp_sackdelay = jiffies_to_msecs(asoc->sackdelay);
5982 5285
5983 /*draft-11 doesn't say what t 5286 /*draft-11 doesn't say what to return in spp_flags*/
5984 params.spp_flags = asoc- 5287 params.spp_flags = asoc->param_flags;
5985 if (asoc->flowlabel & SCTP_FL <<
5986 params.spp_ipv6_flowl <<
5987 <<
5988 params.spp_flags |= S <<
5989 } <<
5990 if (asoc->dscp & SCTP_DSCP_SE <<
5991 params.spp_dscp = aso <<
5992 params.spp_flags |= S <<
5993 } <<
5994 } else { 5288 } else {
5995 /* Fetch socket values. */ 5289 /* Fetch socket values. */
5996 params.spp_hbinterval = sp->h 5290 params.spp_hbinterval = sp->hbinterval;
5997 params.spp_pathmtu = sp->p 5291 params.spp_pathmtu = sp->pathmtu;
5998 params.spp_sackdelay = sp->s 5292 params.spp_sackdelay = sp->sackdelay;
5999 params.spp_pathmaxrxt = sp->p 5293 params.spp_pathmaxrxt = sp->pathmaxrxt;
6000 5294
6001 /*draft-11 doesn't say what t 5295 /*draft-11 doesn't say what to return in spp_flags*/
6002 params.spp_flags = sp->p 5296 params.spp_flags = sp->param_flags;
6003 if (sp->flowlabel & SCTP_FLOW <<
6004 params.spp_ipv6_flowl <<
6005 <<
6006 params.spp_flags |= S <<
6007 } <<
6008 if (sp->dscp & SCTP_DSCP_SET_ <<
6009 params.spp_dscp = sp- <<
6010 params.spp_flags |= S <<
6011 } <<
6012 } 5297 }
6013 5298
6014 if (copy_to_user(optval, ¶ms, len 5299 if (copy_to_user(optval, ¶ms, len))
6015 return -EFAULT; 5300 return -EFAULT;
6016 5301
6017 if (put_user(len, optlen)) 5302 if (put_user(len, optlen))
6018 return -EFAULT; 5303 return -EFAULT;
6019 5304
6020 return 0; 5305 return 0;
6021 } 5306 }
6022 5307
6023 /* 5308 /*
6024 * 7.1.23. Get or set delayed ack timer (SCT 5309 * 7.1.23. Get or set delayed ack timer (SCTP_DELAYED_SACK)
6025 * 5310 *
6026 * This option will effect the way delayed ac 5311 * This option will effect the way delayed acks are performed. This
6027 * option allows you to get or set the delaye 5312 * option allows you to get or set the delayed ack time, in
6028 * milliseconds. It also allows changing the 5313 * milliseconds. It also allows changing the delayed ack frequency.
6029 * Changing the frequency to 1 disables the d 5314 * Changing the frequency to 1 disables the delayed sack algorithm. If
6030 * the assoc_id is 0, then this sets or gets 5315 * the assoc_id is 0, then this sets or gets the endpoints default
6031 * values. If the assoc_id field is non-zero 5316 * values. If the assoc_id field is non-zero, then the set or get
6032 * effects the specified association for the 5317 * effects the specified association for the one to many model (the
6033 * assoc_id field is ignored by the one to on 5318 * assoc_id field is ignored by the one to one model). Note that if
6034 * sack_delay or sack_freq are 0 when setting 5319 * sack_delay or sack_freq are 0 when setting this option, then the
6035 * current values will remain unchanged. 5320 * current values will remain unchanged.
6036 * 5321 *
6037 * struct sctp_sack_info { 5322 * struct sctp_sack_info {
6038 * sctp_assoc_t sack_assoc_id; 5323 * sctp_assoc_t sack_assoc_id;
6039 * uint32_t sack_delay; 5324 * uint32_t sack_delay;
6040 * uint32_t sack_freq; 5325 * uint32_t sack_freq;
6041 * }; 5326 * };
6042 * 5327 *
6043 * sack_assoc_id - This parameter, indicates 5328 * sack_assoc_id - This parameter, indicates which association the user
6044 * is performing an action upon. Note tha 5329 * is performing an action upon. Note that if this field's value is
6045 * zero then the endpoints default value i 5330 * zero then the endpoints default value is changed (effecting future
6046 * associations only). 5331 * associations only).
6047 * 5332 *
6048 * sack_delay - This parameter contains the 5333 * sack_delay - This parameter contains the number of milliseconds that
6049 * the user is requesting the delayed ACK 5334 * the user is requesting the delayed ACK timer be set to. Note that
6050 * this value is defined in the standard t 5335 * this value is defined in the standard to be between 200 and 500
6051 * milliseconds. 5336 * milliseconds.
6052 * 5337 *
6053 * sack_freq - This parameter contains the n 5338 * sack_freq - This parameter contains the number of packets that must
6054 * be received before a sack is sent witho 5339 * be received before a sack is sent without waiting for the delay
6055 * timer to expire. The default value for 5340 * timer to expire. The default value for this is 2, setting this
6056 * value to 1 will disable the delayed sac 5341 * value to 1 will disable the delayed sack algorithm.
6057 */ 5342 */
6058 static int sctp_getsockopt_delayed_ack(struct 5343 static int sctp_getsockopt_delayed_ack(struct sock *sk, int len,
6059 c 5344 char __user *optval,
6060 i 5345 int __user *optlen)
6061 { 5346 {
6062 struct sctp_sack_info params; 5347 struct sctp_sack_info params;
6063 struct sctp_association *asoc = NULL; 5348 struct sctp_association *asoc = NULL;
6064 struct sctp_sock *sp = sctp_sk 5349 struct sctp_sock *sp = sctp_sk(sk);
6065 5350
6066 if (len >= sizeof(struct sctp_sack_in 5351 if (len >= sizeof(struct sctp_sack_info)) {
6067 len = sizeof(struct sctp_sack 5352 len = sizeof(struct sctp_sack_info);
6068 5353
6069 if (copy_from_user(¶ms, o 5354 if (copy_from_user(¶ms, optval, len))
6070 return -EFAULT; 5355 return -EFAULT;
6071 } else if (len == sizeof(struct sctp_ 5356 } else if (len == sizeof(struct sctp_assoc_value)) {
6072 pr_warn_ratelimited(DEPRECATE 5357 pr_warn_ratelimited(DEPRECATED
6073 "%s (pid 5358 "%s (pid %d) "
6074 "Use of s 5359 "Use of struct sctp_assoc_value in delayed_ack socket option.\n"
6075 "Use stru 5360 "Use struct sctp_sack_info instead\n",
6076 current-> 5361 current->comm, task_pid_nr(current));
6077 if (copy_from_user(¶ms, o 5362 if (copy_from_user(¶ms, optval, len))
6078 return -EFAULT; 5363 return -EFAULT;
6079 } else 5364 } else
6080 return -EINVAL; 5365 return -EINVAL;
6081 5366
6082 /* Get association, if sack_assoc_id !! 5367 /* Get association, if sack_assoc_id != 0 and the socket is a one
6083 * socket is a one to many style sock !! 5368 * to many style socket, and an association was not found, then
6084 * was not found, then the id was inv !! 5369 * the id was invalid.
6085 */ 5370 */
6086 asoc = sctp_id2assoc(sk, params.sack_ 5371 asoc = sctp_id2assoc(sk, params.sack_assoc_id);
6087 if (!asoc && params.sack_assoc_id != !! 5372 if (!asoc && params.sack_assoc_id && sctp_style(sk, UDP))
6088 sctp_style(sk, UDP)) <<
6089 return -EINVAL; 5373 return -EINVAL;
6090 5374
6091 if (asoc) { 5375 if (asoc) {
6092 /* Fetch association values. 5376 /* Fetch association values. */
6093 if (asoc->param_flags & SPP_S 5377 if (asoc->param_flags & SPP_SACKDELAY_ENABLE) {
6094 params.sack_delay = j !! 5378 params.sack_delay = jiffies_to_msecs(
>> 5379 asoc->sackdelay);
6095 params.sack_freq = as 5380 params.sack_freq = asoc->sackfreq;
6096 5381
6097 } else { 5382 } else {
6098 params.sack_delay = 0 5383 params.sack_delay = 0;
6099 params.sack_freq = 1; 5384 params.sack_freq = 1;
6100 } 5385 }
6101 } else { 5386 } else {
6102 /* Fetch socket values. */ 5387 /* Fetch socket values. */
6103 if (sp->param_flags & SPP_SAC 5388 if (sp->param_flags & SPP_SACKDELAY_ENABLE) {
6104 params.sack_delay = 5389 params.sack_delay = sp->sackdelay;
6105 params.sack_freq = sp 5390 params.sack_freq = sp->sackfreq;
6106 } else { 5391 } else {
6107 params.sack_delay = 5392 params.sack_delay = 0;
6108 params.sack_freq = 1; 5393 params.sack_freq = 1;
6109 } 5394 }
6110 } 5395 }
6111 5396
6112 if (copy_to_user(optval, ¶ms, len 5397 if (copy_to_user(optval, ¶ms, len))
6113 return -EFAULT; 5398 return -EFAULT;
6114 5399
6115 if (put_user(len, optlen)) 5400 if (put_user(len, optlen))
6116 return -EFAULT; 5401 return -EFAULT;
6117 5402
6118 return 0; 5403 return 0;
6119 } 5404 }
6120 5405
6121 /* 7.1.3 Initialization Parameters (SCTP_INIT 5406 /* 7.1.3 Initialization Parameters (SCTP_INITMSG)
6122 * 5407 *
6123 * Applications can specify protocol paramete 5408 * Applications can specify protocol parameters for the default association
6124 * initialization. The option name argument 5409 * initialization. The option name argument to setsockopt() and getsockopt()
6125 * is SCTP_INITMSG. 5410 * is SCTP_INITMSG.
6126 * 5411 *
6127 * Setting initialization parameters is effec 5412 * Setting initialization parameters is effective only on an unconnected
6128 * socket (for UDP-style sockets only future 5413 * socket (for UDP-style sockets only future associations are effected
6129 * by the change). With TCP-style sockets, t 5414 * by the change). With TCP-style sockets, this option is inherited by
6130 * sockets derived from a listener socket. 5415 * sockets derived from a listener socket.
6131 */ 5416 */
6132 static int sctp_getsockopt_initmsg(struct soc 5417 static int sctp_getsockopt_initmsg(struct sock *sk, int len, char __user *optval, int __user *optlen)
6133 { 5418 {
6134 if (len < sizeof(struct sctp_initmsg) 5419 if (len < sizeof(struct sctp_initmsg))
6135 return -EINVAL; 5420 return -EINVAL;
6136 len = sizeof(struct sctp_initmsg); 5421 len = sizeof(struct sctp_initmsg);
6137 if (put_user(len, optlen)) 5422 if (put_user(len, optlen))
6138 return -EFAULT; 5423 return -EFAULT;
6139 if (copy_to_user(optval, &sctp_sk(sk) 5424 if (copy_to_user(optval, &sctp_sk(sk)->initmsg, len))
6140 return -EFAULT; 5425 return -EFAULT;
6141 return 0; 5426 return 0;
6142 } 5427 }
6143 5428
6144 5429
6145 static int sctp_getsockopt_peer_addrs(struct 5430 static int sctp_getsockopt_peer_addrs(struct sock *sk, int len,
6146 char __ 5431 char __user *optval, int __user *optlen)
6147 { 5432 {
6148 struct sctp_association *asoc; 5433 struct sctp_association *asoc;
6149 int cnt = 0; 5434 int cnt = 0;
6150 struct sctp_getaddrs getaddrs; 5435 struct sctp_getaddrs getaddrs;
6151 struct sctp_transport *from; 5436 struct sctp_transport *from;
6152 void __user *to; 5437 void __user *to;
6153 union sctp_addr temp; 5438 union sctp_addr temp;
6154 struct sctp_sock *sp = sctp_sk(sk); 5439 struct sctp_sock *sp = sctp_sk(sk);
6155 int addrlen; 5440 int addrlen;
6156 size_t space_left; 5441 size_t space_left;
6157 int bytes_copied; 5442 int bytes_copied;
6158 5443
6159 if (len < sizeof(struct sctp_getaddrs 5444 if (len < sizeof(struct sctp_getaddrs))
6160 return -EINVAL; 5445 return -EINVAL;
6161 5446
6162 if (copy_from_user(&getaddrs, optval, 5447 if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
6163 return -EFAULT; 5448 return -EFAULT;
6164 5449
6165 /* For UDP-style sockets, id specifie 5450 /* For UDP-style sockets, id specifies the association to query. */
6166 asoc = sctp_id2assoc(sk, getaddrs.ass 5451 asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
6167 if (!asoc) 5452 if (!asoc)
6168 return -EINVAL; 5453 return -EINVAL;
6169 5454
6170 to = optval + offsetof(struct sctp_ge 5455 to = optval + offsetof(struct sctp_getaddrs, addrs);
6171 space_left = len - offsetof(struct sc 5456 space_left = len - offsetof(struct sctp_getaddrs, addrs);
6172 5457
6173 list_for_each_entry(from, &asoc->peer 5458 list_for_each_entry(from, &asoc->peer.transport_addr_list,
6174 transports) { 5459 transports) {
6175 memcpy(&temp, &from->ipaddr, 5460 memcpy(&temp, &from->ipaddr, sizeof(temp));
6176 addrlen = sctp_get_pf_specifi 5461 addrlen = sctp_get_pf_specific(sk->sk_family)
6177 ->addr_to_user( 5462 ->addr_to_user(sp, &temp);
6178 if (space_left < addrlen) 5463 if (space_left < addrlen)
6179 return -ENOMEM; 5464 return -ENOMEM;
6180 if (copy_to_user(to, &temp, a 5465 if (copy_to_user(to, &temp, addrlen))
6181 return -EFAULT; 5466 return -EFAULT;
6182 to += addrlen; 5467 to += addrlen;
6183 cnt++; 5468 cnt++;
6184 space_left -= addrlen; 5469 space_left -= addrlen;
6185 } 5470 }
6186 5471
6187 if (put_user(cnt, &((struct sctp_geta 5472 if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num))
6188 return -EFAULT; 5473 return -EFAULT;
6189 bytes_copied = ((char __user *)to) - 5474 bytes_copied = ((char __user *)to) - optval;
6190 if (put_user(bytes_copied, optlen)) 5475 if (put_user(bytes_copied, optlen))
6191 return -EFAULT; 5476 return -EFAULT;
6192 5477
6193 return 0; 5478 return 0;
6194 } 5479 }
6195 5480
6196 static int sctp_copy_laddrs(struct sock *sk, 5481 static int sctp_copy_laddrs(struct sock *sk, __u16 port, void *to,
6197 size_t space_left 5482 size_t space_left, int *bytes_copied)
6198 { 5483 {
6199 struct sctp_sockaddr_entry *addr; 5484 struct sctp_sockaddr_entry *addr;
6200 union sctp_addr temp; 5485 union sctp_addr temp;
6201 int cnt = 0; 5486 int cnt = 0;
6202 int addrlen; 5487 int addrlen;
6203 struct net *net = sock_net(sk); 5488 struct net *net = sock_net(sk);
6204 5489
6205 rcu_read_lock(); 5490 rcu_read_lock();
6206 list_for_each_entry_rcu(addr, &net->s 5491 list_for_each_entry_rcu(addr, &net->sctp.local_addr_list, list) {
6207 if (!addr->valid) 5492 if (!addr->valid)
6208 continue; 5493 continue;
6209 5494
6210 if ((PF_INET == sk->sk_family 5495 if ((PF_INET == sk->sk_family) &&
6211 (AF_INET6 == addr->a.sa.s 5496 (AF_INET6 == addr->a.sa.sa_family))
6212 continue; 5497 continue;
6213 if ((PF_INET6 == sk->sk_famil 5498 if ((PF_INET6 == sk->sk_family) &&
6214 inet_v6_ipv6only(sk) && 5499 inet_v6_ipv6only(sk) &&
6215 (AF_INET == addr->a.sa.sa 5500 (AF_INET == addr->a.sa.sa_family))
6216 continue; 5501 continue;
6217 memcpy(&temp, &addr->a, sizeo 5502 memcpy(&temp, &addr->a, sizeof(temp));
6218 if (!temp.v4.sin_port) 5503 if (!temp.v4.sin_port)
6219 temp.v4.sin_port = ht 5504 temp.v4.sin_port = htons(port);
6220 5505
6221 addrlen = sctp_get_pf_specifi 5506 addrlen = sctp_get_pf_specific(sk->sk_family)
6222 ->addr_to_user( 5507 ->addr_to_user(sctp_sk(sk), &temp);
6223 5508
6224 if (space_left < addrlen) { 5509 if (space_left < addrlen) {
6225 cnt = -ENOMEM; 5510 cnt = -ENOMEM;
6226 break; 5511 break;
6227 } 5512 }
6228 memcpy(to, &temp, addrlen); 5513 memcpy(to, &temp, addrlen);
6229 5514
6230 to += addrlen; 5515 to += addrlen;
6231 cnt++; 5516 cnt++;
6232 space_left -= addrlen; 5517 space_left -= addrlen;
6233 *bytes_copied += addrlen; 5518 *bytes_copied += addrlen;
6234 } 5519 }
6235 rcu_read_unlock(); 5520 rcu_read_unlock();
6236 5521
6237 return cnt; 5522 return cnt;
6238 } 5523 }
6239 5524
6240 5525
6241 static int sctp_getsockopt_local_addrs(struct 5526 static int sctp_getsockopt_local_addrs(struct sock *sk, int len,
6242 char _ 5527 char __user *optval, int __user *optlen)
6243 { 5528 {
6244 struct sctp_bind_addr *bp; 5529 struct sctp_bind_addr *bp;
6245 struct sctp_association *asoc; 5530 struct sctp_association *asoc;
6246 int cnt = 0; 5531 int cnt = 0;
6247 struct sctp_getaddrs getaddrs; 5532 struct sctp_getaddrs getaddrs;
6248 struct sctp_sockaddr_entry *addr; 5533 struct sctp_sockaddr_entry *addr;
6249 void __user *to; 5534 void __user *to;
6250 union sctp_addr temp; 5535 union sctp_addr temp;
6251 struct sctp_sock *sp = sctp_sk(sk); 5536 struct sctp_sock *sp = sctp_sk(sk);
6252 int addrlen; 5537 int addrlen;
6253 int err = 0; 5538 int err = 0;
6254 size_t space_left; 5539 size_t space_left;
6255 int bytes_copied = 0; 5540 int bytes_copied = 0;
6256 void *addrs; 5541 void *addrs;
6257 void *buf; 5542 void *buf;
6258 5543
6259 if (len < sizeof(struct sctp_getaddrs 5544 if (len < sizeof(struct sctp_getaddrs))
6260 return -EINVAL; 5545 return -EINVAL;
6261 5546
6262 if (copy_from_user(&getaddrs, optval, 5547 if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
6263 return -EFAULT; 5548 return -EFAULT;
6264 5549
6265 /* 5550 /*
6266 * For UDP-style sockets, id specifi 5551 * For UDP-style sockets, id specifies the association to query.
6267 * If the id field is set to the val 5552 * If the id field is set to the value '' then the locally bound
6268 * addresses are returned without re 5553 * addresses are returned without regard to any particular
6269 * association. 5554 * association.
6270 */ 5555 */
6271 if (0 == getaddrs.assoc_id) { 5556 if (0 == getaddrs.assoc_id) {
6272 bp = &sctp_sk(sk)->ep->base.b 5557 bp = &sctp_sk(sk)->ep->base.bind_addr;
6273 } else { 5558 } else {
6274 asoc = sctp_id2assoc(sk, geta 5559 asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
6275 if (!asoc) 5560 if (!asoc)
6276 return -EINVAL; 5561 return -EINVAL;
6277 bp = &asoc->base.bind_addr; 5562 bp = &asoc->base.bind_addr;
6278 } 5563 }
6279 5564
6280 to = optval + offsetof(struct sctp_ge 5565 to = optval + offsetof(struct sctp_getaddrs, addrs);
6281 space_left = len - offsetof(struct sc 5566 space_left = len - offsetof(struct sctp_getaddrs, addrs);
6282 5567
6283 addrs = kmalloc(space_left, GFP_USER 5568 addrs = kmalloc(space_left, GFP_USER | __GFP_NOWARN);
6284 if (!addrs) 5569 if (!addrs)
6285 return -ENOMEM; 5570 return -ENOMEM;
6286 5571
6287 /* If the endpoint is bound to 0.0.0. 5572 /* If the endpoint is bound to 0.0.0.0 or ::0, get the valid
6288 * addresses from the global local ad 5573 * addresses from the global local address list.
6289 */ 5574 */
6290 if (sctp_list_single_entry(&bp->addre 5575 if (sctp_list_single_entry(&bp->address_list)) {
6291 addr = list_entry(bp->address 5576 addr = list_entry(bp->address_list.next,
6292 struct sctp 5577 struct sctp_sockaddr_entry, list);
6293 if (sctp_is_any(sk, &addr->a) 5578 if (sctp_is_any(sk, &addr->a)) {
6294 cnt = sctp_copy_laddr 5579 cnt = sctp_copy_laddrs(sk, bp->port, addrs,
6295 5580 space_left, &bytes_copied);
6296 if (cnt < 0) { 5581 if (cnt < 0) {
6297 err = cnt; 5582 err = cnt;
6298 goto out; 5583 goto out;
6299 } 5584 }
6300 goto copy_getaddrs; 5585 goto copy_getaddrs;
6301 } 5586 }
6302 } 5587 }
6303 5588
6304 buf = addrs; 5589 buf = addrs;
6305 /* Protection on the bound address li 5590 /* Protection on the bound address list is not needed since
6306 * in the socket option context we ho 5591 * in the socket option context we hold a socket lock and
6307 * thus the bound address list can't 5592 * thus the bound address list can't change.
6308 */ 5593 */
6309 list_for_each_entry(addr, &bp->addres 5594 list_for_each_entry(addr, &bp->address_list, list) {
6310 memcpy(&temp, &addr->a, sizeo 5595 memcpy(&temp, &addr->a, sizeof(temp));
6311 addrlen = sctp_get_pf_specifi 5596 addrlen = sctp_get_pf_specific(sk->sk_family)
6312 ->addr_to_user( 5597 ->addr_to_user(sp, &temp);
6313 if (space_left < addrlen) { 5598 if (space_left < addrlen) {
6314 err = -ENOMEM; /*fix 5599 err = -ENOMEM; /*fixme: right error?*/
6315 goto out; 5600 goto out;
6316 } 5601 }
6317 memcpy(buf, &temp, addrlen); 5602 memcpy(buf, &temp, addrlen);
6318 buf += addrlen; 5603 buf += addrlen;
6319 bytes_copied += addrlen; 5604 bytes_copied += addrlen;
6320 cnt++; 5605 cnt++;
6321 space_left -= addrlen; 5606 space_left -= addrlen;
6322 } 5607 }
6323 5608
6324 copy_getaddrs: 5609 copy_getaddrs:
6325 if (copy_to_user(to, addrs, bytes_cop 5610 if (copy_to_user(to, addrs, bytes_copied)) {
6326 err = -EFAULT; 5611 err = -EFAULT;
6327 goto out; 5612 goto out;
6328 } 5613 }
6329 if (put_user(cnt, &((struct sctp_geta 5614 if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num)) {
6330 err = -EFAULT; 5615 err = -EFAULT;
6331 goto out; 5616 goto out;
6332 } 5617 }
6333 /* XXX: We should have accounted for 5618 /* XXX: We should have accounted for sizeof(struct sctp_getaddrs) too,
6334 * but we can't change it anymore. 5619 * but we can't change it anymore.
6335 */ 5620 */
6336 if (put_user(bytes_copied, optlen)) 5621 if (put_user(bytes_copied, optlen))
6337 err = -EFAULT; 5622 err = -EFAULT;
6338 out: 5623 out:
6339 kfree(addrs); 5624 kfree(addrs);
6340 return err; 5625 return err;
6341 } 5626 }
6342 5627
6343 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_A 5628 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
6344 * 5629 *
6345 * Requests that the local SCTP stack use the 5630 * Requests that the local SCTP stack use the enclosed peer address as
6346 * the association primary. The enclosed add 5631 * the association primary. The enclosed address must be one of the
6347 * association peer's addresses. 5632 * association peer's addresses.
6348 */ 5633 */
6349 static int sctp_getsockopt_primary_addr(struc 5634 static int sctp_getsockopt_primary_addr(struct sock *sk, int len,
6350 char 5635 char __user *optval, int __user *optlen)
6351 { 5636 {
6352 struct sctp_prim prim; 5637 struct sctp_prim prim;
6353 struct sctp_association *asoc; 5638 struct sctp_association *asoc;
6354 struct sctp_sock *sp = sctp_sk(sk); 5639 struct sctp_sock *sp = sctp_sk(sk);
6355 5640
6356 if (len < sizeof(struct sctp_prim)) 5641 if (len < sizeof(struct sctp_prim))
6357 return -EINVAL; 5642 return -EINVAL;
6358 5643
6359 len = sizeof(struct sctp_prim); 5644 len = sizeof(struct sctp_prim);
6360 5645
6361 if (copy_from_user(&prim, optval, len 5646 if (copy_from_user(&prim, optval, len))
6362 return -EFAULT; 5647 return -EFAULT;
6363 5648
6364 asoc = sctp_id2assoc(sk, prim.ssp_ass 5649 asoc = sctp_id2assoc(sk, prim.ssp_assoc_id);
6365 if (!asoc) 5650 if (!asoc)
6366 return -EINVAL; 5651 return -EINVAL;
6367 5652
6368 if (!asoc->peer.primary_path) 5653 if (!asoc->peer.primary_path)
6369 return -ENOTCONN; 5654 return -ENOTCONN;
6370 5655
6371 memcpy(&prim.ssp_addr, &asoc->peer.pr 5656 memcpy(&prim.ssp_addr, &asoc->peer.primary_path->ipaddr,
6372 asoc->peer.primary_path->af_s 5657 asoc->peer.primary_path->af_specific->sockaddr_len);
6373 5658
6374 sctp_get_pf_specific(sk->sk_family)-> 5659 sctp_get_pf_specific(sk->sk_family)->addr_to_user(sp,
6375 (union sctp_addr *)&p 5660 (union sctp_addr *)&prim.ssp_addr);
6376 5661
6377 if (put_user(len, optlen)) 5662 if (put_user(len, optlen))
6378 return -EFAULT; 5663 return -EFAULT;
6379 if (copy_to_user(optval, &prim, len)) 5664 if (copy_to_user(optval, &prim, len))
6380 return -EFAULT; 5665 return -EFAULT;
6381 5666
6382 return 0; 5667 return 0;
6383 } 5668 }
6384 5669
6385 /* 5670 /*
6386 * 7.1.11 Set Adaptation Layer Indicator (SC 5671 * 7.1.11 Set Adaptation Layer Indicator (SCTP_ADAPTATION_LAYER)
6387 * 5672 *
6388 * Requests that the local endpoint set the s 5673 * Requests that the local endpoint set the specified Adaptation Layer
6389 * Indication parameter for all future INIT a 5674 * Indication parameter for all future INIT and INIT-ACK exchanges.
6390 */ 5675 */
6391 static int sctp_getsockopt_adaptation_layer(s 5676 static int sctp_getsockopt_adaptation_layer(struct sock *sk, int len,
6392 char __user 5677 char __user *optval, int __user *optlen)
6393 { 5678 {
6394 struct sctp_setadaptation adaptation; 5679 struct sctp_setadaptation adaptation;
6395 5680
6396 if (len < sizeof(struct sctp_setadapt 5681 if (len < sizeof(struct sctp_setadaptation))
6397 return -EINVAL; 5682 return -EINVAL;
6398 5683
6399 len = sizeof(struct sctp_setadaptatio 5684 len = sizeof(struct sctp_setadaptation);
6400 5685
6401 adaptation.ssb_adaptation_ind = sctp_ 5686 adaptation.ssb_adaptation_ind = sctp_sk(sk)->adaptation_ind;
6402 5687
6403 if (put_user(len, optlen)) 5688 if (put_user(len, optlen))
6404 return -EFAULT; 5689 return -EFAULT;
6405 if (copy_to_user(optval, &adaptation, 5690 if (copy_to_user(optval, &adaptation, len))
6406 return -EFAULT; 5691 return -EFAULT;
6407 5692
6408 return 0; 5693 return 0;
6409 } 5694 }
6410 5695
6411 /* 5696 /*
6412 * 5697 *
6413 * 7.1.14 Set default send parameters (SCTP_D 5698 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
6414 * 5699 *
6415 * Applications that wish to use the sendto 5700 * Applications that wish to use the sendto() system call may wish to
6416 * specify a default set of parameters that 5701 * specify a default set of parameters that would normally be supplied
6417 * through the inclusion of ancillary data. 5702 * through the inclusion of ancillary data. This socket option allows
6418 * such an application to set the default s 5703 * such an application to set the default sctp_sndrcvinfo structure.
6419 5704
6420 5705
6421 * The application that wishes to use this 5706 * The application that wishes to use this socket option simply passes
6422 * in to this call the sctp_sndrcvinfo stru 5707 * in to this call the sctp_sndrcvinfo structure defined in Section
6423 * 5.2.2) The input parameters accepted by 5708 * 5.2.2) The input parameters accepted by this call include
6424 * sinfo_stream, sinfo_flags, sinfo_ppid, s 5709 * sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
6425 * sinfo_timetolive. The user must provide 5710 * sinfo_timetolive. The user must provide the sinfo_assoc_id field in
6426 * to this call if the caller is using the 5711 * to this call if the caller is using the UDP model.
6427 * 5712 *
6428 * For getsockopt, it get the default sctp_ 5713 * For getsockopt, it get the default sctp_sndrcvinfo structure.
6429 */ 5714 */
6430 static int sctp_getsockopt_default_send_param 5715 static int sctp_getsockopt_default_send_param(struct sock *sk,
6431 int l 5716 int len, char __user *optval,
6432 int _ 5717 int __user *optlen)
6433 { 5718 {
6434 struct sctp_sock *sp = sctp_sk(sk); 5719 struct sctp_sock *sp = sctp_sk(sk);
6435 struct sctp_association *asoc; 5720 struct sctp_association *asoc;
6436 struct sctp_sndrcvinfo info; 5721 struct sctp_sndrcvinfo info;
6437 5722
6438 if (len < sizeof(info)) 5723 if (len < sizeof(info))
6439 return -EINVAL; 5724 return -EINVAL;
6440 5725
6441 len = sizeof(info); 5726 len = sizeof(info);
6442 5727
6443 if (copy_from_user(&info, optval, len 5728 if (copy_from_user(&info, optval, len))
6444 return -EFAULT; 5729 return -EFAULT;
6445 5730
6446 asoc = sctp_id2assoc(sk, info.sinfo_a 5731 asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);
6447 if (!asoc && info.sinfo_assoc_id != S !! 5732 if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP))
6448 sctp_style(sk, UDP)) <<
6449 return -EINVAL; 5733 return -EINVAL;
6450 <<
6451 if (asoc) { 5734 if (asoc) {
6452 info.sinfo_stream = asoc->def 5735 info.sinfo_stream = asoc->default_stream;
6453 info.sinfo_flags = asoc->defa 5736 info.sinfo_flags = asoc->default_flags;
6454 info.sinfo_ppid = asoc->defau 5737 info.sinfo_ppid = asoc->default_ppid;
6455 info.sinfo_context = asoc->de 5738 info.sinfo_context = asoc->default_context;
6456 info.sinfo_timetolive = asoc- 5739 info.sinfo_timetolive = asoc->default_timetolive;
6457 } else { 5740 } else {
6458 info.sinfo_stream = sp->defau 5741 info.sinfo_stream = sp->default_stream;
6459 info.sinfo_flags = sp->defaul 5742 info.sinfo_flags = sp->default_flags;
6460 info.sinfo_ppid = sp->default 5743 info.sinfo_ppid = sp->default_ppid;
6461 info.sinfo_context = sp->defa 5744 info.sinfo_context = sp->default_context;
6462 info.sinfo_timetolive = sp->d 5745 info.sinfo_timetolive = sp->default_timetolive;
6463 } 5746 }
6464 5747
6465 if (put_user(len, optlen)) 5748 if (put_user(len, optlen))
6466 return -EFAULT; 5749 return -EFAULT;
6467 if (copy_to_user(optval, &info, len)) 5750 if (copy_to_user(optval, &info, len))
6468 return -EFAULT; 5751 return -EFAULT;
6469 5752
6470 return 0; 5753 return 0;
6471 } 5754 }
6472 5755
6473 /* RFC6458, Section 8.1.31. Set/get Default S 5756 /* RFC6458, Section 8.1.31. Set/get Default Send Parameters
6474 * (SCTP_DEFAULT_SNDINFO) 5757 * (SCTP_DEFAULT_SNDINFO)
6475 */ 5758 */
6476 static int sctp_getsockopt_default_sndinfo(st 5759 static int sctp_getsockopt_default_sndinfo(struct sock *sk, int len,
6477 ch 5760 char __user *optval,
6478 in 5761 int __user *optlen)
6479 { 5762 {
6480 struct sctp_sock *sp = sctp_sk(sk); 5763 struct sctp_sock *sp = sctp_sk(sk);
6481 struct sctp_association *asoc; 5764 struct sctp_association *asoc;
6482 struct sctp_sndinfo info; 5765 struct sctp_sndinfo info;
6483 5766
6484 if (len < sizeof(info)) 5767 if (len < sizeof(info))
6485 return -EINVAL; 5768 return -EINVAL;
6486 5769
6487 len = sizeof(info); 5770 len = sizeof(info);
6488 5771
6489 if (copy_from_user(&info, optval, len 5772 if (copy_from_user(&info, optval, len))
6490 return -EFAULT; 5773 return -EFAULT;
6491 5774
6492 asoc = sctp_id2assoc(sk, info.snd_ass 5775 asoc = sctp_id2assoc(sk, info.snd_assoc_id);
6493 if (!asoc && info.snd_assoc_id != SCT !! 5776 if (!asoc && info.snd_assoc_id && sctp_style(sk, UDP))
6494 sctp_style(sk, UDP)) <<
6495 return -EINVAL; 5777 return -EINVAL;
6496 <<
6497 if (asoc) { 5778 if (asoc) {
6498 info.snd_sid = asoc->default_ 5779 info.snd_sid = asoc->default_stream;
6499 info.snd_flags = asoc->defaul 5780 info.snd_flags = asoc->default_flags;
6500 info.snd_ppid = asoc->default 5781 info.snd_ppid = asoc->default_ppid;
6501 info.snd_context = asoc->defa 5782 info.snd_context = asoc->default_context;
6502 } else { 5783 } else {
6503 info.snd_sid = sp->default_st 5784 info.snd_sid = sp->default_stream;
6504 info.snd_flags = sp->default_ 5785 info.snd_flags = sp->default_flags;
6505 info.snd_ppid = sp->default_p 5786 info.snd_ppid = sp->default_ppid;
6506 info.snd_context = sp->defaul 5787 info.snd_context = sp->default_context;
6507 } 5788 }
6508 5789
6509 if (put_user(len, optlen)) 5790 if (put_user(len, optlen))
6510 return -EFAULT; 5791 return -EFAULT;
6511 if (copy_to_user(optval, &info, len)) 5792 if (copy_to_user(optval, &info, len))
6512 return -EFAULT; 5793 return -EFAULT;
6513 5794
6514 return 0; 5795 return 0;
6515 } 5796 }
6516 5797
6517 /* 5798 /*
6518 * 5799 *
6519 * 7.1.5 SCTP_NODELAY 5800 * 7.1.5 SCTP_NODELAY
6520 * 5801 *
6521 * Turn on/off any Nagle-like algorithm. Thi 5802 * Turn on/off any Nagle-like algorithm. This means that packets are
6522 * generally sent as soon as possible and no 5803 * generally sent as soon as possible and no unnecessary delays are
6523 * introduced, at the cost of more packets in 5804 * introduced, at the cost of more packets in the network. Expects an
6524 * integer boolean flag. 5805 * integer boolean flag.
6525 */ 5806 */
6526 5807
6527 static int sctp_getsockopt_nodelay(struct soc 5808 static int sctp_getsockopt_nodelay(struct sock *sk, int len,
6528 char __use 5809 char __user *optval, int __user *optlen)
6529 { 5810 {
6530 int val; 5811 int val;
6531 5812
6532 if (len < sizeof(int)) 5813 if (len < sizeof(int))
6533 return -EINVAL; 5814 return -EINVAL;
6534 5815
6535 len = sizeof(int); 5816 len = sizeof(int);
6536 val = (sctp_sk(sk)->nodelay == 1); 5817 val = (sctp_sk(sk)->nodelay == 1);
6537 if (put_user(len, optlen)) 5818 if (put_user(len, optlen))
6538 return -EFAULT; 5819 return -EFAULT;
6539 if (copy_to_user(optval, &val, len)) 5820 if (copy_to_user(optval, &val, len))
6540 return -EFAULT; 5821 return -EFAULT;
6541 return 0; 5822 return 0;
6542 } 5823 }
6543 5824
6544 /* 5825 /*
6545 * 5826 *
6546 * 7.1.1 SCTP_RTOINFO 5827 * 7.1.1 SCTP_RTOINFO
6547 * 5828 *
6548 * The protocol parameters used to initialize 5829 * The protocol parameters used to initialize and bound retransmission
6549 * timeout (RTO) are tunable. sctp_rtoinfo st 5830 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
6550 * and modify these parameters. 5831 * and modify these parameters.
6551 * All parameters are time values, in millise 5832 * All parameters are time values, in milliseconds. A value of 0, when
6552 * modifying the parameters, indicates that t 5833 * modifying the parameters, indicates that the current value should not
6553 * be changed. 5834 * be changed.
6554 * 5835 *
6555 */ 5836 */
6556 static int sctp_getsockopt_rtoinfo(struct soc 5837 static int sctp_getsockopt_rtoinfo(struct sock *sk, int len,
6557 char __user * 5838 char __user *optval,
6558 int __user *o 5839 int __user *optlen) {
6559 struct sctp_rtoinfo rtoinfo; 5840 struct sctp_rtoinfo rtoinfo;
6560 struct sctp_association *asoc; 5841 struct sctp_association *asoc;
6561 5842
6562 if (len < sizeof (struct sctp_rtoinfo 5843 if (len < sizeof (struct sctp_rtoinfo))
6563 return -EINVAL; 5844 return -EINVAL;
6564 5845
6565 len = sizeof(struct sctp_rtoinfo); 5846 len = sizeof(struct sctp_rtoinfo);
6566 5847
6567 if (copy_from_user(&rtoinfo, optval, 5848 if (copy_from_user(&rtoinfo, optval, len))
6568 return -EFAULT; 5849 return -EFAULT;
6569 5850
6570 asoc = sctp_id2assoc(sk, rtoinfo.srto 5851 asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id);
6571 5852
6572 if (!asoc && rtoinfo.srto_assoc_id != !! 5853 if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP))
6573 sctp_style(sk, UDP)) <<
6574 return -EINVAL; 5854 return -EINVAL;
6575 5855
6576 /* Values corresponding to the specif 5856 /* Values corresponding to the specific association. */
6577 if (asoc) { 5857 if (asoc) {
6578 rtoinfo.srto_initial = jiffie 5858 rtoinfo.srto_initial = jiffies_to_msecs(asoc->rto_initial);
6579 rtoinfo.srto_max = jiffies_to 5859 rtoinfo.srto_max = jiffies_to_msecs(asoc->rto_max);
6580 rtoinfo.srto_min = jiffies_to 5860 rtoinfo.srto_min = jiffies_to_msecs(asoc->rto_min);
6581 } else { 5861 } else {
6582 /* Values corresponding to th 5862 /* Values corresponding to the endpoint. */
6583 struct sctp_sock *sp = sctp_s 5863 struct sctp_sock *sp = sctp_sk(sk);
6584 5864
6585 rtoinfo.srto_initial = sp->rt 5865 rtoinfo.srto_initial = sp->rtoinfo.srto_initial;
6586 rtoinfo.srto_max = sp->rtoinf 5866 rtoinfo.srto_max = sp->rtoinfo.srto_max;
6587 rtoinfo.srto_min = sp->rtoinf 5867 rtoinfo.srto_min = sp->rtoinfo.srto_min;
6588 } 5868 }
6589 5869
6590 if (put_user(len, optlen)) 5870 if (put_user(len, optlen))
6591 return -EFAULT; 5871 return -EFAULT;
6592 5872
6593 if (copy_to_user(optval, &rtoinfo, le 5873 if (copy_to_user(optval, &rtoinfo, len))
6594 return -EFAULT; 5874 return -EFAULT;
6595 5875
6596 return 0; 5876 return 0;
6597 } 5877 }
6598 5878
6599 /* 5879 /*
6600 * 5880 *
6601 * 7.1.2 SCTP_ASSOCINFO 5881 * 7.1.2 SCTP_ASSOCINFO
6602 * 5882 *
6603 * This option is used to tune the maximum re 5883 * This option is used to tune the maximum retransmission attempts
6604 * of the association. 5884 * of the association.
6605 * Returns an error if the new association re 5885 * Returns an error if the new association retransmission value is
6606 * greater than the sum of the retransmission 5886 * greater than the sum of the retransmission value of the peer.
6607 * See [SCTP] for more information. 5887 * See [SCTP] for more information.
6608 * 5888 *
6609 */ 5889 */
6610 static int sctp_getsockopt_associnfo(struct s 5890 static int sctp_getsockopt_associnfo(struct sock *sk, int len,
6611 char __u 5891 char __user *optval,
6612 int __us 5892 int __user *optlen)
6613 { 5893 {
6614 5894
6615 struct sctp_assocparams assocparams; 5895 struct sctp_assocparams assocparams;
6616 struct sctp_association *asoc; 5896 struct sctp_association *asoc;
6617 struct list_head *pos; 5897 struct list_head *pos;
6618 int cnt = 0; 5898 int cnt = 0;
6619 5899
6620 if (len < sizeof (struct sctp_assocpa 5900 if (len < sizeof (struct sctp_assocparams))
6621 return -EINVAL; 5901 return -EINVAL;
6622 5902
6623 len = sizeof(struct sctp_assocparams) 5903 len = sizeof(struct sctp_assocparams);
6624 5904
6625 if (copy_from_user(&assocparams, optv 5905 if (copy_from_user(&assocparams, optval, len))
6626 return -EFAULT; 5906 return -EFAULT;
6627 5907
6628 asoc = sctp_id2assoc(sk, assocparams. 5908 asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id);
6629 5909
6630 if (!asoc && assocparams.sasoc_assoc_ !! 5910 if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP))
6631 sctp_style(sk, UDP)) <<
6632 return -EINVAL; 5911 return -EINVAL;
6633 5912
6634 /* Values correspoinding to the speci 5913 /* Values correspoinding to the specific association */
6635 if (asoc) { 5914 if (asoc) {
6636 assocparams.sasoc_asocmaxrxt 5915 assocparams.sasoc_asocmaxrxt = asoc->max_retrans;
6637 assocparams.sasoc_peer_rwnd = 5916 assocparams.sasoc_peer_rwnd = asoc->peer.rwnd;
6638 assocparams.sasoc_local_rwnd 5917 assocparams.sasoc_local_rwnd = asoc->a_rwnd;
6639 assocparams.sasoc_cookie_life 5918 assocparams.sasoc_cookie_life = ktime_to_ms(asoc->cookie_life);
6640 5919
6641 list_for_each(pos, &asoc->pee 5920 list_for_each(pos, &asoc->peer.transport_addr_list) {
6642 cnt++; 5921 cnt++;
6643 } 5922 }
6644 5923
6645 assocparams.sasoc_number_peer 5924 assocparams.sasoc_number_peer_destinations = cnt;
6646 } else { 5925 } else {
6647 /* Values corresponding to th 5926 /* Values corresponding to the endpoint */
6648 struct sctp_sock *sp = sctp_s 5927 struct sctp_sock *sp = sctp_sk(sk);
6649 5928
6650 assocparams.sasoc_asocmaxrxt 5929 assocparams.sasoc_asocmaxrxt = sp->assocparams.sasoc_asocmaxrxt;
6651 assocparams.sasoc_peer_rwnd = 5930 assocparams.sasoc_peer_rwnd = sp->assocparams.sasoc_peer_rwnd;
6652 assocparams.sasoc_local_rwnd 5931 assocparams.sasoc_local_rwnd = sp->assocparams.sasoc_local_rwnd;
6653 assocparams.sasoc_cookie_life 5932 assocparams.sasoc_cookie_life =
6654 sp->a 5933 sp->assocparams.sasoc_cookie_life;
6655 assocparams.sasoc_number_peer 5934 assocparams.sasoc_number_peer_destinations =
6656 sp->a 5935 sp->assocparams.
6657 sasoc 5936 sasoc_number_peer_destinations;
6658 } 5937 }
6659 5938
6660 if (put_user(len, optlen)) 5939 if (put_user(len, optlen))
6661 return -EFAULT; 5940 return -EFAULT;
6662 5941
6663 if (copy_to_user(optval, &assocparams 5942 if (copy_to_user(optval, &assocparams, len))
6664 return -EFAULT; 5943 return -EFAULT;
6665 5944
6666 return 0; 5945 return 0;
6667 } 5946 }
6668 5947
6669 /* 5948 /*
6670 * 7.1.16 Set/clear IPv4 mapped addresses (SC 5949 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
6671 * 5950 *
6672 * This socket option is a boolean flag which 5951 * This socket option is a boolean flag which turns on or off mapped V4
6673 * addresses. If this option is turned on an 5952 * addresses. If this option is turned on and the socket is type
6674 * PF_INET6, then IPv4 addresses will be mapp 5953 * PF_INET6, then IPv4 addresses will be mapped to V6 representation.
6675 * If this option is turned off, then no mapp 5954 * If this option is turned off, then no mapping will be done of V4
6676 * addresses and a user will receive both PF_ 5955 * addresses and a user will receive both PF_INET6 and PF_INET type
6677 * addresses on the socket. 5956 * addresses on the socket.
6678 */ 5957 */
6679 static int sctp_getsockopt_mappedv4(struct so 5958 static int sctp_getsockopt_mappedv4(struct sock *sk, int len,
6680 char __us 5959 char __user *optval, int __user *optlen)
6681 { 5960 {
6682 int val; 5961 int val;
6683 struct sctp_sock *sp = sctp_sk(sk); 5962 struct sctp_sock *sp = sctp_sk(sk);
6684 5963
6685 if (len < sizeof(int)) 5964 if (len < sizeof(int))
6686 return -EINVAL; 5965 return -EINVAL;
6687 5966
6688 len = sizeof(int); 5967 len = sizeof(int);
6689 val = sp->v4mapped; 5968 val = sp->v4mapped;
6690 if (put_user(len, optlen)) 5969 if (put_user(len, optlen))
6691 return -EFAULT; 5970 return -EFAULT;
6692 if (copy_to_user(optval, &val, len)) 5971 if (copy_to_user(optval, &val, len))
6693 return -EFAULT; 5972 return -EFAULT;
6694 5973
6695 return 0; 5974 return 0;
6696 } 5975 }
6697 5976
6698 /* 5977 /*
6699 * 7.1.29. Set or Get the default context (S 5978 * 7.1.29. Set or Get the default context (SCTP_CONTEXT)
6700 * (chapter and verse is quoted at sctp_setso 5979 * (chapter and verse is quoted at sctp_setsockopt_context())
6701 */ 5980 */
6702 static int sctp_getsockopt_context(struct soc 5981 static int sctp_getsockopt_context(struct sock *sk, int len,
6703 char __use 5982 char __user *optval, int __user *optlen)
6704 { 5983 {
6705 struct sctp_assoc_value params; 5984 struct sctp_assoc_value params;
>> 5985 struct sctp_sock *sp;
6706 struct sctp_association *asoc; 5986 struct sctp_association *asoc;
6707 5987
6708 if (len < sizeof(struct sctp_assoc_va 5988 if (len < sizeof(struct sctp_assoc_value))
6709 return -EINVAL; 5989 return -EINVAL;
6710 5990
6711 len = sizeof(struct sctp_assoc_value) 5991 len = sizeof(struct sctp_assoc_value);
6712 5992
6713 if (copy_from_user(¶ms, optval, l 5993 if (copy_from_user(¶ms, optval, len))
6714 return -EFAULT; 5994 return -EFAULT;
6715 5995
6716 asoc = sctp_id2assoc(sk, params.assoc !! 5996 sp = sctp_sk(sk);
6717 if (!asoc && params.assoc_id != SCTP_ <<
6718 sctp_style(sk, UDP)) <<
6719 return -EINVAL; <<
6720 5997
6721 params.assoc_value = asoc ? asoc->def !! 5998 if (params.assoc_id != 0) {
6722 : sctp_sk(s !! 5999 asoc = sctp_id2assoc(sk, params.assoc_id);
>> 6000 if (!asoc)
>> 6001 return -EINVAL;
>> 6002 params.assoc_value = asoc->default_rcv_context;
>> 6003 } else {
>> 6004 params.assoc_value = sp->default_rcv_context;
>> 6005 }
6723 6006
6724 if (put_user(len, optlen)) 6007 if (put_user(len, optlen))
6725 return -EFAULT; 6008 return -EFAULT;
6726 if (copy_to_user(optval, ¶ms, len 6009 if (copy_to_user(optval, ¶ms, len))
6727 return -EFAULT; 6010 return -EFAULT;
6728 6011
6729 return 0; 6012 return 0;
6730 } 6013 }
6731 6014
6732 /* 6015 /*
6733 * 8.1.16. Get or Set the Maximum Fragmentat 6016 * 8.1.16. Get or Set the Maximum Fragmentation Size (SCTP_MAXSEG)
6734 * This option will get or set the maximum si 6017 * This option will get or set the maximum size to put in any outgoing
6735 * SCTP DATA chunk. If a message is larger t 6018 * SCTP DATA chunk. If a message is larger than this size it will be
6736 * fragmented by SCTP into the specified size 6019 * fragmented by SCTP into the specified size. Note that the underlying
6737 * SCTP implementation may fragment into smal 6020 * SCTP implementation may fragment into smaller sized chunks when the
6738 * PMTU of the underlying association is smal 6021 * PMTU of the underlying association is smaller than the value set by
6739 * the user. The default value for this opti 6022 * the user. The default value for this option is '' which indicates
6740 * the user is NOT limiting fragmentation and 6023 * the user is NOT limiting fragmentation and only the PMTU will effect
6741 * SCTP's choice of DATA chunk size. Note al 6024 * SCTP's choice of DATA chunk size. Note also that values set larger
6742 * than the maximum size of an IP datagram wi 6025 * than the maximum size of an IP datagram will effectively let SCTP
6743 * control fragmentation (i.e. the same as se 6026 * control fragmentation (i.e. the same as setting this option to 0).
6744 * 6027 *
6745 * The following structure is used to access 6028 * The following structure is used to access and modify this parameter:
6746 * 6029 *
6747 * struct sctp_assoc_value { 6030 * struct sctp_assoc_value {
6748 * sctp_assoc_t assoc_id; 6031 * sctp_assoc_t assoc_id;
6749 * uint32_t assoc_value; 6032 * uint32_t assoc_value;
6750 * }; 6033 * };
6751 * 6034 *
6752 * assoc_id: This parameter is ignored for o 6035 * assoc_id: This parameter is ignored for one-to-one style sockets.
6753 * For one-to-many style sockets this para 6036 * For one-to-many style sockets this parameter indicates which
6754 * association the user is performing an a 6037 * association the user is performing an action upon. Note that if
6755 * this field's value is zero then the end 6038 * this field's value is zero then the endpoints default value is
6756 * changed (effecting future associations 6039 * changed (effecting future associations only).
6757 * assoc_value: This parameter specifies the 6040 * assoc_value: This parameter specifies the maximum size in bytes.
6758 */ 6041 */
6759 static int sctp_getsockopt_maxseg(struct sock 6042 static int sctp_getsockopt_maxseg(struct sock *sk, int len,
6760 char __user 6043 char __user *optval, int __user *optlen)
6761 { 6044 {
6762 struct sctp_assoc_value params; 6045 struct sctp_assoc_value params;
6763 struct sctp_association *asoc; 6046 struct sctp_association *asoc;
6764 6047
6765 if (len == sizeof(int)) { 6048 if (len == sizeof(int)) {
6766 pr_warn_ratelimited(DEPRECATE 6049 pr_warn_ratelimited(DEPRECATED
6767 "%s (pid 6050 "%s (pid %d) "
6768 "Use of i 6051 "Use of int in maxseg socket option.\n"
6769 "Use stru 6052 "Use struct sctp_assoc_value instead\n",
6770 current-> 6053 current->comm, task_pid_nr(current));
6771 params.assoc_id = SCTP_FUTURE !! 6054 params.assoc_id = 0;
6772 } else if (len >= sizeof(struct sctp_ 6055 } else if (len >= sizeof(struct sctp_assoc_value)) {
6773 len = sizeof(struct sctp_asso 6056 len = sizeof(struct sctp_assoc_value);
6774 if (copy_from_user(¶ms, o 6057 if (copy_from_user(¶ms, optval, len))
6775 return -EFAULT; 6058 return -EFAULT;
6776 } else 6059 } else
6777 return -EINVAL; 6060 return -EINVAL;
6778 6061
6779 asoc = sctp_id2assoc(sk, params.assoc 6062 asoc = sctp_id2assoc(sk, params.assoc_id);
6780 if (!asoc && params.assoc_id != SCTP_ !! 6063 if (!asoc && params.assoc_id && sctp_style(sk, UDP))
6781 sctp_style(sk, UDP)) <<
6782 return -EINVAL; 6064 return -EINVAL;
6783 6065
6784 if (asoc) 6066 if (asoc)
6785 params.assoc_value = asoc->fr 6067 params.assoc_value = asoc->frag_point;
6786 else 6068 else
6787 params.assoc_value = sctp_sk( 6069 params.assoc_value = sctp_sk(sk)->user_frag;
6788 6070
6789 if (put_user(len, optlen)) 6071 if (put_user(len, optlen))
6790 return -EFAULT; 6072 return -EFAULT;
6791 if (len == sizeof(int)) { 6073 if (len == sizeof(int)) {
6792 if (copy_to_user(optval, &par 6074 if (copy_to_user(optval, ¶ms.assoc_value, len))
6793 return -EFAULT; 6075 return -EFAULT;
6794 } else { 6076 } else {
6795 if (copy_to_user(optval, &par 6077 if (copy_to_user(optval, ¶ms, len))
6796 return -EFAULT; 6078 return -EFAULT;
6797 } 6079 }
6798 6080
6799 return 0; 6081 return 0;
6800 } 6082 }
6801 6083
6802 /* 6084 /*
6803 * 7.1.24. Get or set fragmented interleave 6085 * 7.1.24. Get or set fragmented interleave (SCTP_FRAGMENT_INTERLEAVE)
6804 * (chapter and verse is quoted at sctp_setso 6086 * (chapter and verse is quoted at sctp_setsockopt_fragment_interleave())
6805 */ 6087 */
6806 static int sctp_getsockopt_fragment_interleav 6088 static int sctp_getsockopt_fragment_interleave(struct sock *sk, int len,
6807 6089 char __user *optval, int __user *optlen)
6808 { 6090 {
6809 int val; 6091 int val;
6810 6092
6811 if (len < sizeof(int)) 6093 if (len < sizeof(int))
6812 return -EINVAL; 6094 return -EINVAL;
6813 6095
6814 len = sizeof(int); 6096 len = sizeof(int);
6815 6097
6816 val = sctp_sk(sk)->frag_interleave; 6098 val = sctp_sk(sk)->frag_interleave;
6817 if (put_user(len, optlen)) 6099 if (put_user(len, optlen))
6818 return -EFAULT; 6100 return -EFAULT;
6819 if (copy_to_user(optval, &val, len)) 6101 if (copy_to_user(optval, &val, len))
6820 return -EFAULT; 6102 return -EFAULT;
6821 6103
6822 return 0; 6104 return 0;
6823 } 6105 }
6824 6106
6825 /* 6107 /*
6826 * 7.1.25. Set or Get the sctp partial deliv 6108 * 7.1.25. Set or Get the sctp partial delivery point
6827 * (chapter and verse is quoted at sctp_setso 6109 * (chapter and verse is quoted at sctp_setsockopt_partial_delivery_point())
6828 */ 6110 */
6829 static int sctp_getsockopt_partial_delivery_p 6111 static int sctp_getsockopt_partial_delivery_point(struct sock *sk, int len,
6830 6112 char __user *optval,
6831 6113 int __user *optlen)
6832 { 6114 {
6833 u32 val; 6115 u32 val;
6834 6116
6835 if (len < sizeof(u32)) 6117 if (len < sizeof(u32))
6836 return -EINVAL; 6118 return -EINVAL;
6837 6119
6838 len = sizeof(u32); 6120 len = sizeof(u32);
6839 6121
6840 val = sctp_sk(sk)->pd_point; 6122 val = sctp_sk(sk)->pd_point;
6841 if (put_user(len, optlen)) 6123 if (put_user(len, optlen))
6842 return -EFAULT; 6124 return -EFAULT;
6843 if (copy_to_user(optval, &val, len)) 6125 if (copy_to_user(optval, &val, len))
6844 return -EFAULT; 6126 return -EFAULT;
6845 6127
6846 return 0; 6128 return 0;
6847 } 6129 }
6848 6130
6849 /* 6131 /*
6850 * 7.1.28. Set or Get the maximum burst (SCT 6132 * 7.1.28. Set or Get the maximum burst (SCTP_MAX_BURST)
6851 * (chapter and verse is quoted at sctp_setso 6133 * (chapter and verse is quoted at sctp_setsockopt_maxburst())
6852 */ 6134 */
6853 static int sctp_getsockopt_maxburst(struct so 6135 static int sctp_getsockopt_maxburst(struct sock *sk, int len,
6854 char __us 6136 char __user *optval,
6855 int __use 6137 int __user *optlen)
6856 { 6138 {
6857 struct sctp_assoc_value params; 6139 struct sctp_assoc_value params;
>> 6140 struct sctp_sock *sp;
6858 struct sctp_association *asoc; 6141 struct sctp_association *asoc;
6859 6142
6860 if (len == sizeof(int)) { 6143 if (len == sizeof(int)) {
6861 pr_warn_ratelimited(DEPRECATE 6144 pr_warn_ratelimited(DEPRECATED
6862 "%s (pid 6145 "%s (pid %d) "
6863 "Use of i 6146 "Use of int in max_burst socket option.\n"
6864 "Use stru 6147 "Use struct sctp_assoc_value instead\n",
6865 current-> 6148 current->comm, task_pid_nr(current));
6866 params.assoc_id = SCTP_FUTURE !! 6149 params.assoc_id = 0;
6867 } else if (len >= sizeof(struct sctp_ 6150 } else if (len >= sizeof(struct sctp_assoc_value)) {
6868 len = sizeof(struct sctp_asso 6151 len = sizeof(struct sctp_assoc_value);
6869 if (copy_from_user(¶ms, o 6152 if (copy_from_user(¶ms, optval, len))
6870 return -EFAULT; 6153 return -EFAULT;
6871 } else 6154 } else
6872 return -EINVAL; 6155 return -EINVAL;
6873 6156
6874 asoc = sctp_id2assoc(sk, params.assoc !! 6157 sp = sctp_sk(sk);
6875 if (!asoc && params.assoc_id != SCTP_ <<
6876 sctp_style(sk, UDP)) <<
6877 return -EINVAL; <<
6878 6158
6879 params.assoc_value = asoc ? asoc->max !! 6159 if (params.assoc_id != 0) {
>> 6160 asoc = sctp_id2assoc(sk, params.assoc_id);
>> 6161 if (!asoc)
>> 6162 return -EINVAL;
>> 6163 params.assoc_value = asoc->max_burst;
>> 6164 } else
>> 6165 params.assoc_value = sp->max_burst;
6880 6166
6881 if (len == sizeof(int)) { 6167 if (len == sizeof(int)) {
6882 if (copy_to_user(optval, &par 6168 if (copy_to_user(optval, ¶ms.assoc_value, len))
6883 return -EFAULT; 6169 return -EFAULT;
6884 } else { 6170 } else {
6885 if (copy_to_user(optval, &par 6171 if (copy_to_user(optval, ¶ms, len))
6886 return -EFAULT; 6172 return -EFAULT;
6887 } 6173 }
6888 6174
6889 return 0; 6175 return 0;
6890 6176
6891 } 6177 }
6892 6178
6893 static int sctp_getsockopt_hmac_ident(struct 6179 static int sctp_getsockopt_hmac_ident(struct sock *sk, int len,
6894 char __us 6180 char __user *optval, int __user *optlen)
6895 { 6181 {
6896 struct sctp_endpoint *ep = sctp_sk(sk 6182 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
6897 struct sctp_hmacalgo __user *p = (vo 6183 struct sctp_hmacalgo __user *p = (void __user *)optval;
6898 struct sctp_hmac_algo_param *hmacs; 6184 struct sctp_hmac_algo_param *hmacs;
6899 __u16 data_len = 0; 6185 __u16 data_len = 0;
6900 u32 num_idents; 6186 u32 num_idents;
6901 int i; 6187 int i;
6902 6188
6903 if (!ep->auth_enable) 6189 if (!ep->auth_enable)
6904 return -EACCES; 6190 return -EACCES;
6905 6191
6906 hmacs = ep->auth_hmacs_list; 6192 hmacs = ep->auth_hmacs_list;
6907 data_len = ntohs(hmacs->param_hdr.len 6193 data_len = ntohs(hmacs->param_hdr.length) -
6908 sizeof(struct sctp_paramhd 6194 sizeof(struct sctp_paramhdr);
6909 6195
6910 if (len < sizeof(struct sctp_hmacalgo 6196 if (len < sizeof(struct sctp_hmacalgo) + data_len)
6911 return -EINVAL; 6197 return -EINVAL;
6912 6198
6913 len = sizeof(struct sctp_hmacalgo) + 6199 len = sizeof(struct sctp_hmacalgo) + data_len;
6914 num_idents = data_len / sizeof(u16); 6200 num_idents = data_len / sizeof(u16);
6915 6201
6916 if (put_user(len, optlen)) 6202 if (put_user(len, optlen))
6917 return -EFAULT; 6203 return -EFAULT;
6918 if (put_user(num_idents, &p->shmac_nu 6204 if (put_user(num_idents, &p->shmac_num_idents))
6919 return -EFAULT; 6205 return -EFAULT;
6920 for (i = 0; i < num_idents; i++) { 6206 for (i = 0; i < num_idents; i++) {
6921 __u16 hmacid = ntohs(hmacs->h 6207 __u16 hmacid = ntohs(hmacs->hmac_ids[i]);
6922 6208
6923 if (copy_to_user(&p->shmac_id 6209 if (copy_to_user(&p->shmac_idents[i], &hmacid, sizeof(__u16)))
6924 return -EFAULT; 6210 return -EFAULT;
6925 } 6211 }
6926 return 0; 6212 return 0;
6927 } 6213 }
6928 6214
6929 static int sctp_getsockopt_active_key(struct 6215 static int sctp_getsockopt_active_key(struct sock *sk, int len,
6930 char __us 6216 char __user *optval, int __user *optlen)
6931 { 6217 {
6932 struct sctp_endpoint *ep = sctp_sk(sk 6218 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
6933 struct sctp_authkeyid val; 6219 struct sctp_authkeyid val;
6934 struct sctp_association *asoc; 6220 struct sctp_association *asoc;
6935 6221
>> 6222 if (!ep->auth_enable)
>> 6223 return -EACCES;
>> 6224
6936 if (len < sizeof(struct sctp_authkeyi 6225 if (len < sizeof(struct sctp_authkeyid))
6937 return -EINVAL; 6226 return -EINVAL;
6938 6227
6939 len = sizeof(struct sctp_authkeyid); 6228 len = sizeof(struct sctp_authkeyid);
6940 if (copy_from_user(&val, optval, len) 6229 if (copy_from_user(&val, optval, len))
6941 return -EFAULT; 6230 return -EFAULT;
6942 6231
6943 asoc = sctp_id2assoc(sk, val.scact_as 6232 asoc = sctp_id2assoc(sk, val.scact_assoc_id);
6944 if (!asoc && val.scact_assoc_id && sc 6233 if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP))
6945 return -EINVAL; 6234 return -EINVAL;
6946 6235
6947 if (asoc) { !! 6236 if (asoc)
6948 if (!asoc->peer.auth_capable) <<
6949 return -EACCES; <<
6950 val.scact_keynumber = asoc->a 6237 val.scact_keynumber = asoc->active_key_id;
6951 } else { !! 6238 else
6952 if (!ep->auth_enable) <<
6953 return -EACCES; <<
6954 val.scact_keynumber = ep->act 6239 val.scact_keynumber = ep->active_key_id;
6955 } <<
6956 6240
6957 if (put_user(len, optlen)) 6241 if (put_user(len, optlen))
6958 return -EFAULT; 6242 return -EFAULT;
6959 if (copy_to_user(optval, &val, len)) 6243 if (copy_to_user(optval, &val, len))
6960 return -EFAULT; 6244 return -EFAULT;
6961 6245
6962 return 0; 6246 return 0;
6963 } 6247 }
6964 6248
6965 static int sctp_getsockopt_peer_auth_chunks(s 6249 static int sctp_getsockopt_peer_auth_chunks(struct sock *sk, int len,
6966 char __us 6250 char __user *optval, int __user *optlen)
6967 { 6251 {
>> 6252 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
6968 struct sctp_authchunks __user *p = (v 6253 struct sctp_authchunks __user *p = (void __user *)optval;
6969 struct sctp_authchunks val; 6254 struct sctp_authchunks val;
6970 struct sctp_association *asoc; 6255 struct sctp_association *asoc;
6971 struct sctp_chunks_param *ch; 6256 struct sctp_chunks_param *ch;
6972 u32 num_chunks = 0; 6257 u32 num_chunks = 0;
6973 char __user *to; 6258 char __user *to;
6974 6259
>> 6260 if (!ep->auth_enable)
>> 6261 return -EACCES;
>> 6262
6975 if (len < sizeof(struct sctp_authchun 6263 if (len < sizeof(struct sctp_authchunks))
6976 return -EINVAL; 6264 return -EINVAL;
6977 6265
6978 if (copy_from_user(&val, optval, size 6266 if (copy_from_user(&val, optval, sizeof(val)))
6979 return -EFAULT; 6267 return -EFAULT;
6980 6268
6981 to = p->gauth_chunks; 6269 to = p->gauth_chunks;
6982 asoc = sctp_id2assoc(sk, val.gauth_as 6270 asoc = sctp_id2assoc(sk, val.gauth_assoc_id);
6983 if (!asoc) 6271 if (!asoc)
6984 return -EINVAL; 6272 return -EINVAL;
6985 6273
6986 if (!asoc->peer.auth_capable) <<
6987 return -EACCES; <<
6988 <<
6989 ch = asoc->peer.peer_chunks; 6274 ch = asoc->peer.peer_chunks;
6990 if (!ch) 6275 if (!ch)
6991 goto num; 6276 goto num;
6992 6277
6993 /* See if the user provided enough ro 6278 /* See if the user provided enough room for all the data */
6994 num_chunks = ntohs(ch->param_hdr.leng 6279 num_chunks = ntohs(ch->param_hdr.length) - sizeof(struct sctp_paramhdr);
6995 if (len < num_chunks) 6280 if (len < num_chunks)
6996 return -EINVAL; 6281 return -EINVAL;
6997 6282
6998 if (copy_to_user(to, ch->chunks, num_ 6283 if (copy_to_user(to, ch->chunks, num_chunks))
6999 return -EFAULT; 6284 return -EFAULT;
7000 num: 6285 num:
7001 len = sizeof(struct sctp_authchunks) 6286 len = sizeof(struct sctp_authchunks) + num_chunks;
7002 if (put_user(len, optlen)) 6287 if (put_user(len, optlen))
7003 return -EFAULT; 6288 return -EFAULT;
7004 if (put_user(num_chunks, &p->gauth_nu 6289 if (put_user(num_chunks, &p->gauth_number_of_chunks))
7005 return -EFAULT; 6290 return -EFAULT;
7006 return 0; 6291 return 0;
7007 } 6292 }
7008 6293
7009 static int sctp_getsockopt_local_auth_chunks( 6294 static int sctp_getsockopt_local_auth_chunks(struct sock *sk, int len,
7010 char __us 6295 char __user *optval, int __user *optlen)
7011 { 6296 {
7012 struct sctp_endpoint *ep = sctp_sk(sk 6297 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
7013 struct sctp_authchunks __user *p = (v 6298 struct sctp_authchunks __user *p = (void __user *)optval;
7014 struct sctp_authchunks val; 6299 struct sctp_authchunks val;
7015 struct sctp_association *asoc; 6300 struct sctp_association *asoc;
7016 struct sctp_chunks_param *ch; 6301 struct sctp_chunks_param *ch;
7017 u32 num_chunks = 0; 6302 u32 num_chunks = 0;
7018 char __user *to; 6303 char __user *to;
7019 6304
>> 6305 if (!ep->auth_enable)
>> 6306 return -EACCES;
>> 6307
7020 if (len < sizeof(struct sctp_authchun 6308 if (len < sizeof(struct sctp_authchunks))
7021 return -EINVAL; 6309 return -EINVAL;
7022 6310
7023 if (copy_from_user(&val, optval, size 6311 if (copy_from_user(&val, optval, sizeof(val)))
7024 return -EFAULT; 6312 return -EFAULT;
7025 6313
7026 to = p->gauth_chunks; 6314 to = p->gauth_chunks;
7027 asoc = sctp_id2assoc(sk, val.gauth_as 6315 asoc = sctp_id2assoc(sk, val.gauth_assoc_id);
7028 if (!asoc && val.gauth_assoc_id != SC !! 6316 if (!asoc && val.gauth_assoc_id && sctp_style(sk, UDP))
7029 sctp_style(sk, UDP)) <<
7030 return -EINVAL; 6317 return -EINVAL;
7031 6318
7032 if (asoc) { !! 6319 if (asoc)
7033 if (!asoc->peer.auth_capable) <<
7034 return -EACCES; <<
7035 ch = (struct sctp_chunks_para 6320 ch = (struct sctp_chunks_param *)asoc->c.auth_chunks;
7036 } else { !! 6321 else
7037 if (!ep->auth_enable) <<
7038 return -EACCES; <<
7039 ch = ep->auth_chunk_list; 6322 ch = ep->auth_chunk_list;
7040 } !! 6323
7041 if (!ch) 6324 if (!ch)
7042 goto num; 6325 goto num;
7043 6326
7044 num_chunks = ntohs(ch->param_hdr.leng 6327 num_chunks = ntohs(ch->param_hdr.length) - sizeof(struct sctp_paramhdr);
7045 if (len < sizeof(struct sctp_authchun 6328 if (len < sizeof(struct sctp_authchunks) + num_chunks)
7046 return -EINVAL; 6329 return -EINVAL;
7047 6330
7048 if (copy_to_user(to, ch->chunks, num_ 6331 if (copy_to_user(to, ch->chunks, num_chunks))
7049 return -EFAULT; 6332 return -EFAULT;
7050 num: 6333 num:
7051 len = sizeof(struct sctp_authchunks) 6334 len = sizeof(struct sctp_authchunks) + num_chunks;
7052 if (put_user(len, optlen)) 6335 if (put_user(len, optlen))
7053 return -EFAULT; 6336 return -EFAULT;
7054 if (put_user(num_chunks, &p->gauth_nu 6337 if (put_user(num_chunks, &p->gauth_number_of_chunks))
7055 return -EFAULT; 6338 return -EFAULT;
7056 6339
7057 return 0; 6340 return 0;
7058 } 6341 }
7059 6342
7060 /* 6343 /*
7061 * 8.2.5. Get the Current Number of Associat 6344 * 8.2.5. Get the Current Number of Associations (SCTP_GET_ASSOC_NUMBER)
7062 * This option gets the current number of ass 6345 * This option gets the current number of associations that are attached
7063 * to a one-to-many style socket. The option 6346 * to a one-to-many style socket. The option value is an uint32_t.
7064 */ 6347 */
7065 static int sctp_getsockopt_assoc_number(struc 6348 static int sctp_getsockopt_assoc_number(struct sock *sk, int len,
7066 char __us 6349 char __user *optval, int __user *optlen)
7067 { 6350 {
7068 struct sctp_sock *sp = sctp_sk(sk); 6351 struct sctp_sock *sp = sctp_sk(sk);
7069 struct sctp_association *asoc; 6352 struct sctp_association *asoc;
7070 u32 val = 0; 6353 u32 val = 0;
7071 6354
7072 if (sctp_style(sk, TCP)) 6355 if (sctp_style(sk, TCP))
7073 return -EOPNOTSUPP; 6356 return -EOPNOTSUPP;
7074 6357
7075 if (len < sizeof(u32)) 6358 if (len < sizeof(u32))
7076 return -EINVAL; 6359 return -EINVAL;
7077 6360
7078 len = sizeof(u32); 6361 len = sizeof(u32);
7079 6362
7080 list_for_each_entry(asoc, &(sp->ep->a 6363 list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
7081 val++; 6364 val++;
7082 } 6365 }
7083 6366
7084 if (put_user(len, optlen)) 6367 if (put_user(len, optlen))
7085 return -EFAULT; 6368 return -EFAULT;
7086 if (copy_to_user(optval, &val, len)) 6369 if (copy_to_user(optval, &val, len))
7087 return -EFAULT; 6370 return -EFAULT;
7088 6371
7089 return 0; 6372 return 0;
7090 } 6373 }
7091 6374
7092 /* 6375 /*
7093 * 8.1.23 SCTP_AUTO_ASCONF 6376 * 8.1.23 SCTP_AUTO_ASCONF
7094 * See the corresponding setsockopt entry as 6377 * See the corresponding setsockopt entry as description
7095 */ 6378 */
7096 static int sctp_getsockopt_auto_asconf(struct 6379 static int sctp_getsockopt_auto_asconf(struct sock *sk, int len,
7097 char __use 6380 char __user *optval, int __user *optlen)
7098 { 6381 {
7099 int val = 0; 6382 int val = 0;
7100 6383
7101 if (len < sizeof(int)) 6384 if (len < sizeof(int))
7102 return -EINVAL; 6385 return -EINVAL;
7103 6386
7104 len = sizeof(int); 6387 len = sizeof(int);
7105 if (sctp_sk(sk)->do_auto_asconf && sc 6388 if (sctp_sk(sk)->do_auto_asconf && sctp_is_ep_boundall(sk))
7106 val = 1; 6389 val = 1;
7107 if (put_user(len, optlen)) 6390 if (put_user(len, optlen))
7108 return -EFAULT; 6391 return -EFAULT;
7109 if (copy_to_user(optval, &val, len)) 6392 if (copy_to_user(optval, &val, len))
7110 return -EFAULT; 6393 return -EFAULT;
7111 return 0; 6394 return 0;
7112 } 6395 }
7113 6396
7114 /* 6397 /*
7115 * 8.2.6. Get the Current Identifiers of Asso 6398 * 8.2.6. Get the Current Identifiers of Associations
7116 * (SCTP_GET_ASSOC_ID_LIST) 6399 * (SCTP_GET_ASSOC_ID_LIST)
7117 * 6400 *
7118 * This option gets the current list of SCTP 6401 * This option gets the current list of SCTP association identifiers of
7119 * the SCTP associations handled by a one-to- 6402 * the SCTP associations handled by a one-to-many style socket.
7120 */ 6403 */
7121 static int sctp_getsockopt_assoc_ids(struct s 6404 static int sctp_getsockopt_assoc_ids(struct sock *sk, int len,
7122 char __us 6405 char __user *optval, int __user *optlen)
7123 { 6406 {
7124 struct sctp_sock *sp = sctp_sk(sk); 6407 struct sctp_sock *sp = sctp_sk(sk);
7125 struct sctp_association *asoc; 6408 struct sctp_association *asoc;
7126 struct sctp_assoc_ids *ids; 6409 struct sctp_assoc_ids *ids;
7127 size_t ids_size; <<
7128 u32 num = 0; 6410 u32 num = 0;
7129 6411
7130 if (sctp_style(sk, TCP)) 6412 if (sctp_style(sk, TCP))
7131 return -EOPNOTSUPP; 6413 return -EOPNOTSUPP;
7132 6414
7133 if (len < sizeof(struct sctp_assoc_id 6415 if (len < sizeof(struct sctp_assoc_ids))
7134 return -EINVAL; 6416 return -EINVAL;
7135 6417
7136 list_for_each_entry(asoc, &(sp->ep->a 6418 list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
7137 num++; 6419 num++;
7138 } 6420 }
7139 6421
7140 ids_size = struct_size(ids, gaids_ass !! 6422 if (len < sizeof(struct sctp_assoc_ids) + sizeof(sctp_assoc_t) * num)
7141 if (len < ids_size) <<
7142 return -EINVAL; 6423 return -EINVAL;
7143 6424
7144 len = ids_size; !! 6425 len = sizeof(struct sctp_assoc_ids) + sizeof(sctp_assoc_t) * num;
>> 6426
7145 ids = kmalloc(len, GFP_USER | __GFP_N 6427 ids = kmalloc(len, GFP_USER | __GFP_NOWARN);
7146 if (unlikely(!ids)) 6428 if (unlikely(!ids))
7147 return -ENOMEM; 6429 return -ENOMEM;
7148 6430
7149 ids->gaids_number_of_ids = num; 6431 ids->gaids_number_of_ids = num;
7150 num = 0; 6432 num = 0;
7151 list_for_each_entry(asoc, &(sp->ep->a 6433 list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
7152 ids->gaids_assoc_id[num++] = 6434 ids->gaids_assoc_id[num++] = asoc->assoc_id;
7153 } 6435 }
7154 6436
7155 if (put_user(len, optlen) || copy_to_ 6437 if (put_user(len, optlen) || copy_to_user(optval, ids, len)) {
7156 kfree(ids); 6438 kfree(ids);
7157 return -EFAULT; 6439 return -EFAULT;
7158 } 6440 }
7159 6441
7160 kfree(ids); 6442 kfree(ids);
7161 return 0; 6443 return 0;
7162 } 6444 }
7163 6445
7164 /* 6446 /*
7165 * SCTP_PEER_ADDR_THLDS 6447 * SCTP_PEER_ADDR_THLDS
7166 * 6448 *
7167 * This option allows us to fetch the partial 6449 * This option allows us to fetch the partially failed threshold for one or all
7168 * transports in an association. See Section 6450 * transports in an association. See Section 6.1 of:
7169 * http://www.ietf.org/id/draft-nishida-tsvwg 6451 * http://www.ietf.org/id/draft-nishida-tsvwg-sctp-failover-05.txt
7170 */ 6452 */
7171 static int sctp_getsockopt_paddr_thresholds(s 6453 static int sctp_getsockopt_paddr_thresholds(struct sock *sk,
7172 c !! 6454 char __user *optval,
7173 i !! 6455 int len,
>> 6456 int __user *optlen)
7174 { 6457 {
7175 struct sctp_paddrthlds_v2 val; !! 6458 struct sctp_paddrthlds val;
7176 struct sctp_transport *trans; 6459 struct sctp_transport *trans;
7177 struct sctp_association *asoc; 6460 struct sctp_association *asoc;
7178 int min; <<
7179 6461
7180 min = v2 ? sizeof(val) : sizeof(struc !! 6462 if (len < sizeof(struct sctp_paddrthlds))
7181 if (len < min) <<
7182 return -EINVAL; 6463 return -EINVAL;
7183 len = min; !! 6464 len = sizeof(struct sctp_paddrthlds);
7184 if (copy_from_user(&val, optval, len) !! 6465 if (copy_from_user(&val, (struct sctp_paddrthlds __user *)optval, len))
7185 return -EFAULT; 6466 return -EFAULT;
7186 6467
7187 if (!sctp_is_any(sk, (const union sct !! 6468 if (sctp_is_any(sk, (const union sctp_addr *)&val.spt_address)) {
>> 6469 asoc = sctp_id2assoc(sk, val.spt_assoc_id);
>> 6470 if (!asoc)
>> 6471 return -ENOENT;
>> 6472
>> 6473 val.spt_pathpfthld = asoc->pf_retrans;
>> 6474 val.spt_pathmaxrxt = asoc->pathmaxrxt;
>> 6475 } else {
7188 trans = sctp_addr_id2transpor 6476 trans = sctp_addr_id2transport(sk, &val.spt_address,
7189 6477 val.spt_assoc_id);
7190 if (!trans) 6478 if (!trans)
7191 return -ENOENT; 6479 return -ENOENT;
7192 6480
7193 val.spt_pathmaxrxt = trans->p 6481 val.spt_pathmaxrxt = trans->pathmaxrxt;
7194 val.spt_pathpfthld = trans->p 6482 val.spt_pathpfthld = trans->pf_retrans;
7195 val.spt_pathcpthld = trans->p <<
7196 <<
7197 goto out; <<
7198 } 6483 }
7199 6484
7200 asoc = sctp_id2assoc(sk, val.spt_asso <<
7201 if (!asoc && val.spt_assoc_id != SCTP <<
7202 sctp_style(sk, UDP)) <<
7203 return -EINVAL; <<
7204 <<
7205 if (asoc) { <<
7206 val.spt_pathpfthld = asoc->pf <<
7207 val.spt_pathmaxrxt = asoc->pa <<
7208 val.spt_pathcpthld = asoc->ps <<
7209 } else { <<
7210 struct sctp_sock *sp = sctp_s <<
7211 <<
7212 val.spt_pathpfthld = sp->pf_r <<
7213 val.spt_pathmaxrxt = sp->path <<
7214 val.spt_pathcpthld = sp->ps_r <<
7215 } <<
7216 <<
7217 out: <<
7218 if (put_user(len, optlen) || copy_to_ 6485 if (put_user(len, optlen) || copy_to_user(optval, &val, len))
7219 return -EFAULT; 6486 return -EFAULT;
7220 6487
7221 return 0; 6488 return 0;
7222 } 6489 }
7223 6490
7224 /* 6491 /*
7225 * SCTP_GET_ASSOC_STATS 6492 * SCTP_GET_ASSOC_STATS
7226 * 6493 *
7227 * This option retrieves local per endpoint s 6494 * This option retrieves local per endpoint statistics. It is modeled
7228 * after OpenSolaris' implementation 6495 * after OpenSolaris' implementation
7229 */ 6496 */
7230 static int sctp_getsockopt_assoc_stats(struct 6497 static int sctp_getsockopt_assoc_stats(struct sock *sk, int len,
7231 char _ 6498 char __user *optval,
7232 int __ 6499 int __user *optlen)
7233 { 6500 {
7234 struct sctp_assoc_stats sas; 6501 struct sctp_assoc_stats sas;
7235 struct sctp_association *asoc = NULL; 6502 struct sctp_association *asoc = NULL;
7236 6503
7237 /* User must provide at least the ass 6504 /* User must provide at least the assoc id */
7238 if (len < sizeof(sctp_assoc_t)) 6505 if (len < sizeof(sctp_assoc_t))
7239 return -EINVAL; 6506 return -EINVAL;
7240 6507
7241 /* Allow the struct to grow and fill 6508 /* Allow the struct to grow and fill in as much as possible */
7242 len = min_t(size_t, len, sizeof(sas)) 6509 len = min_t(size_t, len, sizeof(sas));
7243 6510
7244 if (copy_from_user(&sas, optval, len) 6511 if (copy_from_user(&sas, optval, len))
7245 return -EFAULT; 6512 return -EFAULT;
7246 6513
7247 asoc = sctp_id2assoc(sk, sas.sas_asso 6514 asoc = sctp_id2assoc(sk, sas.sas_assoc_id);
7248 if (!asoc) 6515 if (!asoc)
7249 return -EINVAL; 6516 return -EINVAL;
7250 6517
7251 sas.sas_rtxchunks = asoc->stats.rtxch 6518 sas.sas_rtxchunks = asoc->stats.rtxchunks;
7252 sas.sas_gapcnt = asoc->stats.gapcnt; 6519 sas.sas_gapcnt = asoc->stats.gapcnt;
7253 sas.sas_outofseqtsns = asoc->stats.ou 6520 sas.sas_outofseqtsns = asoc->stats.outofseqtsns;
7254 sas.sas_osacks = asoc->stats.osacks; 6521 sas.sas_osacks = asoc->stats.osacks;
7255 sas.sas_isacks = asoc->stats.isacks; 6522 sas.sas_isacks = asoc->stats.isacks;
7256 sas.sas_octrlchunks = asoc->stats.oct 6523 sas.sas_octrlchunks = asoc->stats.octrlchunks;
7257 sas.sas_ictrlchunks = asoc->stats.ict 6524 sas.sas_ictrlchunks = asoc->stats.ictrlchunks;
7258 sas.sas_oodchunks = asoc->stats.oodch 6525 sas.sas_oodchunks = asoc->stats.oodchunks;
7259 sas.sas_iodchunks = asoc->stats.iodch 6526 sas.sas_iodchunks = asoc->stats.iodchunks;
7260 sas.sas_ouodchunks = asoc->stats.ouod 6527 sas.sas_ouodchunks = asoc->stats.ouodchunks;
7261 sas.sas_iuodchunks = asoc->stats.iuod 6528 sas.sas_iuodchunks = asoc->stats.iuodchunks;
7262 sas.sas_idupchunks = asoc->stats.idup 6529 sas.sas_idupchunks = asoc->stats.idupchunks;
7263 sas.sas_opackets = asoc->stats.opacke 6530 sas.sas_opackets = asoc->stats.opackets;
7264 sas.sas_ipackets = asoc->stats.ipacke 6531 sas.sas_ipackets = asoc->stats.ipackets;
7265 6532
7266 /* New high max rto observed, will re 6533 /* New high max rto observed, will return 0 if not a single
7267 * RTO update took place. obs_rto_ipa 6534 * RTO update took place. obs_rto_ipaddr will be bogus
7268 * in such a case 6535 * in such a case
7269 */ 6536 */
7270 sas.sas_maxrto = asoc->stats.max_obs_ 6537 sas.sas_maxrto = asoc->stats.max_obs_rto;
7271 memcpy(&sas.sas_obs_rto_ipaddr, &asoc 6538 memcpy(&sas.sas_obs_rto_ipaddr, &asoc->stats.obs_rto_ipaddr,
7272 sizeof(struct sockaddr_storag 6539 sizeof(struct sockaddr_storage));
7273 6540
7274 /* Mark beginning of a new observatio 6541 /* Mark beginning of a new observation period */
7275 asoc->stats.max_obs_rto = asoc->rto_m 6542 asoc->stats.max_obs_rto = asoc->rto_min;
7276 6543
7277 if (put_user(len, optlen)) 6544 if (put_user(len, optlen))
7278 return -EFAULT; 6545 return -EFAULT;
7279 6546
7280 pr_debug("%s: len:%d, assoc_id:%d\n", 6547 pr_debug("%s: len:%d, assoc_id:%d\n", __func__, len, sas.sas_assoc_id);
7281 6548
7282 if (copy_to_user(optval, &sas, len)) 6549 if (copy_to_user(optval, &sas, len))
7283 return -EFAULT; 6550 return -EFAULT;
7284 6551
7285 return 0; 6552 return 0;
7286 } 6553 }
7287 6554
7288 static int sctp_getsockopt_recvrcvinfo(struct 6555 static int sctp_getsockopt_recvrcvinfo(struct sock *sk, int len,
7289 char _ 6556 char __user *optval,
7290 int __ 6557 int __user *optlen)
7291 { 6558 {
7292 int val = 0; 6559 int val = 0;
7293 6560
7294 if (len < sizeof(int)) 6561 if (len < sizeof(int))
7295 return -EINVAL; 6562 return -EINVAL;
7296 6563
7297 len = sizeof(int); 6564 len = sizeof(int);
7298 if (sctp_sk(sk)->recvrcvinfo) 6565 if (sctp_sk(sk)->recvrcvinfo)
7299 val = 1; 6566 val = 1;
7300 if (put_user(len, optlen)) 6567 if (put_user(len, optlen))
7301 return -EFAULT; 6568 return -EFAULT;
7302 if (copy_to_user(optval, &val, len)) 6569 if (copy_to_user(optval, &val, len))
7303 return -EFAULT; 6570 return -EFAULT;
7304 6571
7305 return 0; 6572 return 0;
7306 } 6573 }
7307 6574
7308 static int sctp_getsockopt_recvnxtinfo(struct 6575 static int sctp_getsockopt_recvnxtinfo(struct sock *sk, int len,
7309 char _ 6576 char __user *optval,
7310 int __ 6577 int __user *optlen)
7311 { 6578 {
7312 int val = 0; 6579 int val = 0;
7313 6580
7314 if (len < sizeof(int)) 6581 if (len < sizeof(int))
7315 return -EINVAL; 6582 return -EINVAL;
7316 6583
7317 len = sizeof(int); 6584 len = sizeof(int);
7318 if (sctp_sk(sk)->recvnxtinfo) 6585 if (sctp_sk(sk)->recvnxtinfo)
7319 val = 1; 6586 val = 1;
7320 if (put_user(len, optlen)) 6587 if (put_user(len, optlen))
7321 return -EFAULT; 6588 return -EFAULT;
7322 if (copy_to_user(optval, &val, len)) 6589 if (copy_to_user(optval, &val, len))
7323 return -EFAULT; 6590 return -EFAULT;
7324 6591
7325 return 0; 6592 return 0;
7326 } 6593 }
7327 6594
7328 static int sctp_getsockopt_pr_supported(struc 6595 static int sctp_getsockopt_pr_supported(struct sock *sk, int len,
7329 char 6596 char __user *optval,
7330 int _ 6597 int __user *optlen)
7331 { 6598 {
7332 struct sctp_assoc_value params; 6599 struct sctp_assoc_value params;
7333 struct sctp_association *asoc; 6600 struct sctp_association *asoc;
7334 int retval = -EFAULT; 6601 int retval = -EFAULT;
7335 6602
7336 if (len < sizeof(params)) { 6603 if (len < sizeof(params)) {
7337 retval = -EINVAL; 6604 retval = -EINVAL;
7338 goto out; 6605 goto out;
7339 } 6606 }
7340 6607
7341 len = sizeof(params); 6608 len = sizeof(params);
7342 if (copy_from_user(¶ms, optval, l 6609 if (copy_from_user(¶ms, optval, len))
7343 goto out; 6610 goto out;
7344 6611
7345 asoc = sctp_id2assoc(sk, params.assoc 6612 asoc = sctp_id2assoc(sk, params.assoc_id);
7346 if (!asoc && params.assoc_id != SCTP_ !! 6613 if (asoc) {
7347 sctp_style(sk, UDP)) { !! 6614 params.assoc_value = asoc->prsctp_enable;
>> 6615 } else if (!params.assoc_id) {
>> 6616 struct sctp_sock *sp = sctp_sk(sk);
>> 6617
>> 6618 params.assoc_value = sp->ep->prsctp_enable;
>> 6619 } else {
7348 retval = -EINVAL; 6620 retval = -EINVAL;
7349 goto out; 6621 goto out;
7350 } 6622 }
7351 6623
7352 params.assoc_value = asoc ? asoc->pee <<
7353 : sctp_sk(s <<
7354 <<
7355 if (put_user(len, optlen)) 6624 if (put_user(len, optlen))
7356 goto out; 6625 goto out;
7357 6626
7358 if (copy_to_user(optval, ¶ms, len 6627 if (copy_to_user(optval, ¶ms, len))
7359 goto out; 6628 goto out;
7360 6629
7361 retval = 0; 6630 retval = 0;
7362 6631
7363 out: 6632 out:
7364 return retval; 6633 return retval;
7365 } 6634 }
7366 6635
7367 static int sctp_getsockopt_default_prinfo(str 6636 static int sctp_getsockopt_default_prinfo(struct sock *sk, int len,
7368 cha 6637 char __user *optval,
7369 int 6638 int __user *optlen)
7370 { 6639 {
7371 struct sctp_default_prinfo info; 6640 struct sctp_default_prinfo info;
7372 struct sctp_association *asoc; 6641 struct sctp_association *asoc;
7373 int retval = -EFAULT; 6642 int retval = -EFAULT;
7374 6643
7375 if (len < sizeof(info)) { 6644 if (len < sizeof(info)) {
7376 retval = -EINVAL; 6645 retval = -EINVAL;
7377 goto out; 6646 goto out;
7378 } 6647 }
7379 6648
7380 len = sizeof(info); 6649 len = sizeof(info);
7381 if (copy_from_user(&info, optval, len 6650 if (copy_from_user(&info, optval, len))
7382 goto out; 6651 goto out;
7383 6652
7384 asoc = sctp_id2assoc(sk, info.pr_asso 6653 asoc = sctp_id2assoc(sk, info.pr_assoc_id);
7385 if (!asoc && info.pr_assoc_id != SCTP <<
7386 sctp_style(sk, UDP)) { <<
7387 retval = -EINVAL; <<
7388 goto out; <<
7389 } <<
7390 <<
7391 if (asoc) { 6654 if (asoc) {
7392 info.pr_policy = SCTP_PR_POLI 6655 info.pr_policy = SCTP_PR_POLICY(asoc->default_flags);
7393 info.pr_value = asoc->default 6656 info.pr_value = asoc->default_timetolive;
7394 } else { !! 6657 } else if (!info.pr_assoc_id) {
7395 struct sctp_sock *sp = sctp_s 6658 struct sctp_sock *sp = sctp_sk(sk);
7396 6659
7397 info.pr_policy = SCTP_PR_POLI 6660 info.pr_policy = SCTP_PR_POLICY(sp->default_flags);
7398 info.pr_value = sp->default_t 6661 info.pr_value = sp->default_timetolive;
>> 6662 } else {
>> 6663 retval = -EINVAL;
>> 6664 goto out;
7399 } 6665 }
7400 6666
7401 if (put_user(len, optlen)) 6667 if (put_user(len, optlen))
7402 goto out; 6668 goto out;
7403 6669
7404 if (copy_to_user(optval, &info, len)) 6670 if (copy_to_user(optval, &info, len))
7405 goto out; 6671 goto out;
7406 6672
7407 retval = 0; 6673 retval = 0;
7408 6674
7409 out: 6675 out:
7410 return retval; 6676 return retval;
7411 } 6677 }
7412 6678
7413 static int sctp_getsockopt_pr_assocstatus(str 6679 static int sctp_getsockopt_pr_assocstatus(struct sock *sk, int len,
7414 cha 6680 char __user *optval,
7415 int 6681 int __user *optlen)
7416 { 6682 {
7417 struct sctp_prstatus params; 6683 struct sctp_prstatus params;
7418 struct sctp_association *asoc; 6684 struct sctp_association *asoc;
7419 int policy; 6685 int policy;
7420 int retval = -EINVAL; 6686 int retval = -EINVAL;
7421 6687
7422 if (len < sizeof(params)) 6688 if (len < sizeof(params))
7423 goto out; 6689 goto out;
7424 6690
7425 len = sizeof(params); 6691 len = sizeof(params);
7426 if (copy_from_user(¶ms, optval, l 6692 if (copy_from_user(¶ms, optval, len)) {
7427 retval = -EFAULT; 6693 retval = -EFAULT;
7428 goto out; 6694 goto out;
7429 } 6695 }
7430 6696
7431 policy = params.sprstat_policy; 6697 policy = params.sprstat_policy;
7432 if (!policy || (policy & ~(SCTP_PR_SC !! 6698 if (policy & ~SCTP_PR_SCTP_MASK)
7433 ((policy & SCTP_PR_SCTP_ALL) && ( <<
7434 goto out; 6699 goto out;
7435 6700
7436 asoc = sctp_id2assoc(sk, params.sprst 6701 asoc = sctp_id2assoc(sk, params.sprstat_assoc_id);
7437 if (!asoc) 6702 if (!asoc)
7438 goto out; 6703 goto out;
7439 6704
7440 if (policy == SCTP_PR_SCTP_ALL) { !! 6705 if (policy == SCTP_PR_SCTP_NONE) {
7441 params.sprstat_abandoned_unse 6706 params.sprstat_abandoned_unsent = 0;
7442 params.sprstat_abandoned_sent 6707 params.sprstat_abandoned_sent = 0;
7443 for (policy = 0; policy <= SC 6708 for (policy = 0; policy <= SCTP_PR_INDEX(MAX); policy++) {
7444 params.sprstat_abando 6709 params.sprstat_abandoned_unsent +=
7445 asoc->abandon 6710 asoc->abandoned_unsent[policy];
7446 params.sprstat_abando 6711 params.sprstat_abandoned_sent +=
7447 asoc->abandon 6712 asoc->abandoned_sent[policy];
7448 } 6713 }
7449 } else { 6714 } else {
7450 params.sprstat_abandoned_unse 6715 params.sprstat_abandoned_unsent =
7451 asoc->abandoned_unsen 6716 asoc->abandoned_unsent[__SCTP_PR_INDEX(policy)];
7452 params.sprstat_abandoned_sent 6717 params.sprstat_abandoned_sent =
7453 asoc->abandoned_sent[ 6718 asoc->abandoned_sent[__SCTP_PR_INDEX(policy)];
7454 } 6719 }
7455 6720
7456 if (put_user(len, optlen)) { 6721 if (put_user(len, optlen)) {
7457 retval = -EFAULT; 6722 retval = -EFAULT;
7458 goto out; 6723 goto out;
7459 } 6724 }
7460 6725
7461 if (copy_to_user(optval, ¶ms, len 6726 if (copy_to_user(optval, ¶ms, len)) {
7462 retval = -EFAULT; 6727 retval = -EFAULT;
7463 goto out; 6728 goto out;
7464 } 6729 }
7465 6730
7466 retval = 0; 6731 retval = 0;
7467 6732
7468 out: 6733 out:
7469 return retval; 6734 return retval;
7470 } 6735 }
7471 6736
7472 static int sctp_getsockopt_pr_streamstatus(st 6737 static int sctp_getsockopt_pr_streamstatus(struct sock *sk, int len,
7473 ch 6738 char __user *optval,
7474 in 6739 int __user *optlen)
7475 { 6740 {
7476 struct sctp_stream_out_ext *streamout !! 6741 struct sctp_stream_out *streamout;
7477 struct sctp_association *asoc; 6742 struct sctp_association *asoc;
7478 struct sctp_prstatus params; 6743 struct sctp_prstatus params;
7479 int retval = -EINVAL; 6744 int retval = -EINVAL;
7480 int policy; 6745 int policy;
7481 6746
7482 if (len < sizeof(params)) 6747 if (len < sizeof(params))
7483 goto out; 6748 goto out;
7484 6749
7485 len = sizeof(params); 6750 len = sizeof(params);
7486 if (copy_from_user(¶ms, optval, l 6751 if (copy_from_user(¶ms, optval, len)) {
7487 retval = -EFAULT; 6752 retval = -EFAULT;
7488 goto out; 6753 goto out;
7489 } 6754 }
7490 6755
7491 policy = params.sprstat_policy; 6756 policy = params.sprstat_policy;
7492 if (!policy || (policy & ~(SCTP_PR_SC !! 6757 if (policy & ~SCTP_PR_SCTP_MASK)
7493 ((policy & SCTP_PR_SCTP_ALL) && ( <<
7494 goto out; 6758 goto out;
7495 6759
7496 asoc = sctp_id2assoc(sk, params.sprst 6760 asoc = sctp_id2assoc(sk, params.sprstat_assoc_id);
7497 if (!asoc || params.sprstat_sid >= as 6761 if (!asoc || params.sprstat_sid >= asoc->stream.outcnt)
7498 goto out; 6762 goto out;
7499 6763
7500 streamoute = SCTP_SO(&asoc->stream, p !! 6764 streamout = &asoc->stream.out[params.sprstat_sid];
7501 if (!streamoute) { !! 6765 if (policy == SCTP_PR_SCTP_NONE) {
7502 /* Not allocated yet, means a <<
7503 params.sprstat_abandoned_unse <<
7504 params.sprstat_abandoned_sent <<
7505 retval = 0; <<
7506 goto out; <<
7507 } <<
7508 <<
7509 if (policy == SCTP_PR_SCTP_ALL) { <<
7510 params.sprstat_abandoned_unse 6766 params.sprstat_abandoned_unsent = 0;
7511 params.sprstat_abandoned_sent 6767 params.sprstat_abandoned_sent = 0;
7512 for (policy = 0; policy <= SC 6768 for (policy = 0; policy <= SCTP_PR_INDEX(MAX); policy++) {
7513 params.sprstat_abando 6769 params.sprstat_abandoned_unsent +=
7514 streamoute->a !! 6770 streamout->abandoned_unsent[policy];
7515 params.sprstat_abando 6771 params.sprstat_abandoned_sent +=
7516 streamoute->a !! 6772 streamout->abandoned_sent[policy];
7517 } 6773 }
7518 } else { 6774 } else {
7519 params.sprstat_abandoned_unse 6775 params.sprstat_abandoned_unsent =
7520 streamoute->abandoned !! 6776 streamout->abandoned_unsent[__SCTP_PR_INDEX(policy)];
7521 params.sprstat_abandoned_sent 6777 params.sprstat_abandoned_sent =
7522 streamoute->abandoned !! 6778 streamout->abandoned_sent[__SCTP_PR_INDEX(policy)];
7523 } 6779 }
7524 6780
7525 if (put_user(len, optlen) || copy_to_ 6781 if (put_user(len, optlen) || copy_to_user(optval, ¶ms, len)) {
7526 retval = -EFAULT; 6782 retval = -EFAULT;
7527 goto out; 6783 goto out;
7528 } 6784 }
7529 6785
7530 retval = 0; 6786 retval = 0;
7531 6787
7532 out: 6788 out:
7533 return retval; 6789 return retval;
7534 } 6790 }
7535 6791
7536 static int sctp_getsockopt_reconfig_supported 6792 static int sctp_getsockopt_reconfig_supported(struct sock *sk, int len,
7537 6793 char __user *optval,
7538 6794 int __user *optlen)
7539 { 6795 {
7540 struct sctp_assoc_value params; 6796 struct sctp_assoc_value params;
7541 struct sctp_association *asoc; 6797 struct sctp_association *asoc;
7542 int retval = -EFAULT; 6798 int retval = -EFAULT;
7543 6799
7544 if (len < sizeof(params)) { 6800 if (len < sizeof(params)) {
7545 retval = -EINVAL; 6801 retval = -EINVAL;
7546 goto out; 6802 goto out;
7547 } 6803 }
7548 6804
7549 len = sizeof(params); 6805 len = sizeof(params);
7550 if (copy_from_user(¶ms, optval, l 6806 if (copy_from_user(¶ms, optval, len))
7551 goto out; 6807 goto out;
7552 6808
7553 asoc = sctp_id2assoc(sk, params.assoc 6809 asoc = sctp_id2assoc(sk, params.assoc_id);
7554 if (!asoc && params.assoc_id != SCTP_ !! 6810 if (asoc) {
7555 sctp_style(sk, UDP)) { !! 6811 params.assoc_value = asoc->reconf_enable;
7556 retval = -EINVAL; !! 6812 } else if (!params.assoc_id) {
7557 goto out; !! 6813 struct sctp_sock *sp = sctp_sk(sk);
7558 } <<
7559 <<
7560 params.assoc_value = asoc ? asoc->pee <<
7561 : sctp_sk(s <<
7562 <<
7563 if (put_user(len, optlen)) <<
7564 goto out; <<
7565 <<
7566 if (copy_to_user(optval, ¶ms, len <<
7567 goto out; <<
7568 <<
7569 retval = 0; <<
7570 <<
7571 out: <<
7572 return retval; <<
7573 } <<
7574 <<
7575 static int sctp_getsockopt_enable_strreset(st <<
7576 ch <<
7577 in <<
7578 { <<
7579 struct sctp_assoc_value params; <<
7580 struct sctp_association *asoc; <<
7581 int retval = -EFAULT; <<
7582 <<
7583 if (len < sizeof(params)) { <<
7584 retval = -EINVAL; <<
7585 goto out; <<
7586 } <<
7587 <<
7588 len = sizeof(params); <<
7589 if (copy_from_user(¶ms, optval, l <<
7590 goto out; <<
7591 <<
7592 asoc = sctp_id2assoc(sk, params.assoc <<
7593 if (!asoc && params.assoc_id != SCTP_ <<
7594 sctp_style(sk, UDP)) { <<
7595 retval = -EINVAL; <<
7596 goto out; <<
7597 } <<
7598 <<
7599 params.assoc_value = asoc ? asoc->str <<
7600 : sctp_sk(s <<
7601 <<
7602 if (put_user(len, optlen)) <<
7603 goto out; <<
7604 <<
7605 if (copy_to_user(optval, ¶ms, len <<
7606 goto out; <<
7607 <<
7608 retval = 0; <<
7609 <<
7610 out: <<
7611 return retval; <<
7612 } <<
7613 <<
7614 static int sctp_getsockopt_scheduler(struct s <<
7615 char __u <<
7616 int __us <<
7617 { <<
7618 struct sctp_assoc_value params; <<
7619 struct sctp_association *asoc; <<
7620 int retval = -EFAULT; <<
7621 <<
7622 if (len < sizeof(params)) { <<
7623 retval = -EINVAL; <<
7624 goto out; <<
7625 } <<
7626 <<
7627 len = sizeof(params); <<
7628 if (copy_from_user(¶ms, optval, l <<
7629 goto out; <<
7630 6814
7631 asoc = sctp_id2assoc(sk, params.assoc !! 6815 params.assoc_value = sp->ep->reconf_enable;
7632 if (!asoc && params.assoc_id != SCTP_ !! 6816 } else {
7633 sctp_style(sk, UDP)) { <<
7634 retval = -EINVAL; 6817 retval = -EINVAL;
7635 goto out; 6818 goto out;
7636 } 6819 }
7637 6820
7638 params.assoc_value = asoc ? sctp_sche <<
7639 : sctp_sk(s <<
7640 <<
7641 if (put_user(len, optlen)) 6821 if (put_user(len, optlen))
7642 goto out; 6822 goto out;
7643 6823
7644 if (copy_to_user(optval, ¶ms, len 6824 if (copy_to_user(optval, ¶ms, len))
7645 goto out; 6825 goto out;
7646 6826
7647 retval = 0; 6827 retval = 0;
7648 6828
7649 out: 6829 out:
7650 return retval; 6830 return retval;
7651 } 6831 }
7652 6832
7653 static int sctp_getsockopt_scheduler_value(st !! 6833 static int sctp_getsockopt_enable_strreset(struct sock *sk, int len,
7654 ch 6834 char __user *optval,
7655 in 6835 int __user *optlen)
7656 { 6836 {
7657 struct sctp_stream_value params; <<
7658 struct sctp_association *asoc; <<
7659 int retval = -EFAULT; <<
7660 <<
7661 if (len < sizeof(params)) { <<
7662 retval = -EINVAL; <<
7663 goto out; <<
7664 } <<
7665 <<
7666 len = sizeof(params); <<
7667 if (copy_from_user(¶ms, optval, l <<
7668 goto out; <<
7669 <<
7670 asoc = sctp_id2assoc(sk, params.assoc <<
7671 if (!asoc) { <<
7672 retval = -EINVAL; <<
7673 goto out; <<
7674 } <<
7675 <<
7676 retval = sctp_sched_get_value(asoc, p <<
7677 ¶ms <<
7678 if (retval) <<
7679 goto out; <<
7680 <<
7681 if (put_user(len, optlen)) { <<
7682 retval = -EFAULT; <<
7683 goto out; <<
7684 } <<
7685 <<
7686 if (copy_to_user(optval, ¶ms, len <<
7687 retval = -EFAULT; <<
7688 goto out; <<
7689 } <<
7690 <<
7691 out: <<
7692 return retval; <<
7693 } <<
7694 <<
7695 static int sctp_getsockopt_interleaving_suppo <<
7696 <<
7697 <<
7698 { <<
7699 struct sctp_assoc_value params; <<
7700 struct sctp_association *asoc; <<
7701 int retval = -EFAULT; <<
7702 <<
7703 if (len < sizeof(params)) { <<
7704 retval = -EINVAL; <<
7705 goto out; <<
7706 } <<
7707 <<
7708 len = sizeof(params); <<
7709 if (copy_from_user(¶ms, optval, l <<
7710 goto out; <<
7711 <<
7712 asoc = sctp_id2assoc(sk, params.assoc <<
7713 if (!asoc && params.assoc_id != SCTP_ <<
7714 sctp_style(sk, UDP)) { <<
7715 retval = -EINVAL; <<
7716 goto out; <<
7717 } <<
7718 <<
7719 params.assoc_value = asoc ? asoc->pee <<
7720 : sctp_sk(s <<
7721 <<
7722 if (put_user(len, optlen)) <<
7723 goto out; <<
7724 <<
7725 if (copy_to_user(optval, ¶ms, len <<
7726 goto out; <<
7727 <<
7728 retval = 0; <<
7729 <<
7730 out: <<
7731 return retval; <<
7732 } <<
7733 <<
7734 static int sctp_getsockopt_reuse_port(struct <<
7735 char __ <<
7736 int __u <<
7737 { <<
7738 int val; <<
7739 <<
7740 if (len < sizeof(int)) <<
7741 return -EINVAL; <<
7742 <<
7743 len = sizeof(int); <<
7744 val = sctp_sk(sk)->reuse; <<
7745 if (put_user(len, optlen)) <<
7746 return -EFAULT; <<
7747 <<
7748 if (copy_to_user(optval, &val, len)) <<
7749 return -EFAULT; <<
7750 <<
7751 return 0; <<
7752 } <<
7753 <<
7754 static int sctp_getsockopt_event(struct sock <<
7755 int __user * <<
7756 { <<
7757 struct sctp_association *asoc; <<
7758 struct sctp_event param; <<
7759 __u16 subscribe; <<
7760 <<
7761 if (len < sizeof(param)) <<
7762 return -EINVAL; <<
7763 <<
7764 len = sizeof(param); <<
7765 if (copy_from_user(¶m, optval, le <<
7766 return -EFAULT; <<
7767 <<
7768 if (param.se_type < SCTP_SN_TYPE_BASE <<
7769 param.se_type > SCTP_SN_TYPE_MAX) <<
7770 return -EINVAL; <<
7771 <<
7772 asoc = sctp_id2assoc(sk, param.se_ass <<
7773 if (!asoc && param.se_assoc_id != SCT <<
7774 sctp_style(sk, UDP)) <<
7775 return -EINVAL; <<
7776 <<
7777 subscribe = asoc ? asoc->subscribe : <<
7778 param.se_on = sctp_ulpevent_type_enab <<
7779 <<
7780 if (put_user(len, optlen)) <<
7781 return -EFAULT; <<
7782 <<
7783 if (copy_to_user(optval, ¶m, len) <<
7784 return -EFAULT; <<
7785 <<
7786 return 0; <<
7787 } <<
7788 <<
7789 static int sctp_getsockopt_asconf_supported(s <<
7790 c <<
7791 i <<
7792 { <<
7793 struct sctp_assoc_value params; <<
7794 struct sctp_association *asoc; <<
7795 int retval = -EFAULT; <<
7796 <<
7797 if (len < sizeof(params)) { <<
7798 retval = -EINVAL; <<
7799 goto out; <<
7800 } <<
7801 <<
7802 len = sizeof(params); <<
7803 if (copy_from_user(¶ms, optval, l <<
7804 goto out; <<
7805 <<
7806 asoc = sctp_id2assoc(sk, params.assoc <<
7807 if (!asoc && params.assoc_id != SCTP_ <<
7808 sctp_style(sk, UDP)) { <<
7809 retval = -EINVAL; <<
7810 goto out; <<
7811 } <<
7812 <<
7813 params.assoc_value = asoc ? asoc->pee <<
7814 : sctp_sk(s <<
7815 <<
7816 if (put_user(len, optlen)) <<
7817 goto out; <<
7818 <<
7819 if (copy_to_user(optval, ¶ms, len <<
7820 goto out; <<
7821 <<
7822 retval = 0; <<
7823 <<
7824 out: <<
7825 return retval; <<
7826 } <<
7827 <<
7828 static int sctp_getsockopt_auth_supported(str <<
7829 cha <<
7830 int <<
7831 { <<
7832 struct sctp_assoc_value params; <<
7833 struct sctp_association *asoc; <<
7834 int retval = -EFAULT; <<
7835 <<
7836 if (len < sizeof(params)) { <<
7837 retval = -EINVAL; <<
7838 goto out; <<
7839 } <<
7840 <<
7841 len = sizeof(params); <<
7842 if (copy_from_user(¶ms, optval, l <<
7843 goto out; <<
7844 <<
7845 asoc = sctp_id2assoc(sk, params.assoc <<
7846 if (!asoc && params.assoc_id != SCTP_ <<
7847 sctp_style(sk, UDP)) { <<
7848 retval = -EINVAL; <<
7849 goto out; <<
7850 } <<
7851 <<
7852 params.assoc_value = asoc ? asoc->pee <<
7853 : sctp_sk(s <<
7854 <<
7855 if (put_user(len, optlen)) <<
7856 goto out; <<
7857 <<
7858 if (copy_to_user(optval, ¶ms, len <<
7859 goto out; <<
7860 <<
7861 retval = 0; <<
7862 <<
7863 out: <<
7864 return retval; <<
7865 } <<
7866 <<
7867 static int sctp_getsockopt_ecn_supported(stru <<
7868 char <<
7869 int <<
7870 { <<
7871 struct sctp_assoc_value params; 6837 struct sctp_assoc_value params;
7872 struct sctp_association *asoc; 6838 struct sctp_association *asoc;
7873 int retval = -EFAULT; 6839 int retval = -EFAULT;
7874 6840
7875 if (len < sizeof(params)) { 6841 if (len < sizeof(params)) {
7876 retval = -EINVAL; 6842 retval = -EINVAL;
7877 goto out; 6843 goto out;
7878 } 6844 }
7879 6845
7880 len = sizeof(params); 6846 len = sizeof(params);
7881 if (copy_from_user(¶ms, optval, l 6847 if (copy_from_user(¶ms, optval, len))
7882 goto out; 6848 goto out;
7883 6849
7884 asoc = sctp_id2assoc(sk, params.assoc 6850 asoc = sctp_id2assoc(sk, params.assoc_id);
7885 if (!asoc && params.assoc_id != SCTP_ !! 6851 if (asoc) {
7886 sctp_style(sk, UDP)) { !! 6852 params.assoc_value = asoc->strreset_enable;
7887 retval = -EINVAL; !! 6853 } else if (!params.assoc_id) {
7888 goto out; !! 6854 struct sctp_sock *sp = sctp_sk(sk);
7889 } <<
7890 <<
7891 params.assoc_value = asoc ? asoc->pee <<
7892 : sctp_sk(s <<
7893 <<
7894 if (put_user(len, optlen)) <<
7895 goto out; <<
7896 <<
7897 if (copy_to_user(optval, ¶ms, len <<
7898 goto out; <<
7899 <<
7900 retval = 0; <<
7901 <<
7902 out: <<
7903 return retval; <<
7904 } <<
7905 <<
7906 static int sctp_getsockopt_pf_expose(struct s <<
7907 char __u <<
7908 int __us <<
7909 { <<
7910 struct sctp_assoc_value params; <<
7911 struct sctp_association *asoc; <<
7912 int retval = -EFAULT; <<
7913 <<
7914 if (len < sizeof(params)) { <<
7915 retval = -EINVAL; <<
7916 goto out; <<
7917 } <<
7918 <<
7919 len = sizeof(params); <<
7920 if (copy_from_user(¶ms, optval, l <<
7921 goto out; <<
7922 6855
7923 asoc = sctp_id2assoc(sk, params.assoc !! 6856 params.assoc_value = sp->ep->strreset_enable;
7924 if (!asoc && params.assoc_id != SCTP_ !! 6857 } else {
7925 sctp_style(sk, UDP)) { <<
7926 retval = -EINVAL; 6858 retval = -EINVAL;
7927 goto out; 6859 goto out;
7928 } 6860 }
7929 6861
7930 params.assoc_value = asoc ? asoc->pf_ <<
7931 : sctp_sk(s <<
7932 <<
7933 if (put_user(len, optlen)) 6862 if (put_user(len, optlen))
7934 goto out; 6863 goto out;
7935 6864
7936 if (copy_to_user(optval, ¶ms, len 6865 if (copy_to_user(optval, ¶ms, len))
7937 goto out; 6866 goto out;
7938 6867
7939 retval = 0; 6868 retval = 0;
7940 6869
7941 out: 6870 out:
7942 return retval; 6871 return retval;
7943 } 6872 }
7944 6873
7945 static int sctp_getsockopt_encap_port(struct <<
7946 char __ <<
7947 { <<
7948 struct sctp_association *asoc; <<
7949 struct sctp_udpencaps encap; <<
7950 struct sctp_transport *t; <<
7951 __be16 encap_port; <<
7952 <<
7953 if (len < sizeof(encap)) <<
7954 return -EINVAL; <<
7955 <<
7956 len = sizeof(encap); <<
7957 if (copy_from_user(&encap, optval, le <<
7958 return -EFAULT; <<
7959 <<
7960 /* If an address other than INADDR_AN <<
7961 * no transport is found, then the re <<
7962 */ <<
7963 if (!sctp_is_any(sk, (union sctp_addr <<
7964 t = sctp_addr_id2transport(sk <<
7965 en <<
7966 if (!t) { <<
7967 pr_debug("%s: failed <<
7968 return -EINVAL; <<
7969 } <<
7970 <<
7971 encap_port = t->encap_port; <<
7972 goto out; <<
7973 } <<
7974 <<
7975 /* Get association, if assoc_id != SC <<
7976 * socket is a one to many style sock <<
7977 * was not found, then the id was inv <<
7978 */ <<
7979 asoc = sctp_id2assoc(sk, encap.sue_as <<
7980 if (!asoc && encap.sue_assoc_id != SC <<
7981 sctp_style(sk, UDP)) { <<
7982 pr_debug("%s: failed no assoc <<
7983 return -EINVAL; <<
7984 } <<
7985 <<
7986 if (asoc) { <<
7987 encap_port = asoc->encap_port <<
7988 goto out; <<
7989 } <<
7990 <<
7991 encap_port = sctp_sk(sk)->encap_port; <<
7992 <<
7993 out: <<
7994 encap.sue_port = (__force uint16_t)en <<
7995 if (copy_to_user(optval, &encap, len) <<
7996 return -EFAULT; <<
7997 <<
7998 if (put_user(len, optlen)) <<
7999 return -EFAULT; <<
8000 <<
8001 return 0; <<
8002 } <<
8003 <<
8004 static int sctp_getsockopt_probe_interval(str <<
8005 cha <<
8006 int <<
8007 { <<
8008 struct sctp_probeinterval params; <<
8009 struct sctp_association *asoc; <<
8010 struct sctp_transport *t; <<
8011 __u32 probe_interval; <<
8012 <<
8013 if (len < sizeof(params)) <<
8014 return -EINVAL; <<
8015 <<
8016 len = sizeof(params); <<
8017 if (copy_from_user(¶ms, optval, l <<
8018 return -EFAULT; <<
8019 <<
8020 /* If an address other than INADDR_AN <<
8021 * no transport is found, then the re <<
8022 */ <<
8023 if (!sctp_is_any(sk, (union sctp_addr <<
8024 t = sctp_addr_id2transport(sk <<
8025 pa <<
8026 if (!t) { <<
8027 pr_debug("%s: failed <<
8028 return -EINVAL; <<
8029 } <<
8030 <<
8031 probe_interval = jiffies_to_m <<
8032 goto out; <<
8033 } <<
8034 <<
8035 /* Get association, if assoc_id != SC <<
8036 * socket is a one to many style sock <<
8037 * was not found, then the id was inv <<
8038 */ <<
8039 asoc = sctp_id2assoc(sk, params.spi_a <<
8040 if (!asoc && params.spi_assoc_id != S <<
8041 sctp_style(sk, UDP)) { <<
8042 pr_debug("%s: failed no assoc <<
8043 return -EINVAL; <<
8044 } <<
8045 <<
8046 if (asoc) { <<
8047 probe_interval = jiffies_to_m <<
8048 goto out; <<
8049 } <<
8050 <<
8051 probe_interval = sctp_sk(sk)->probe_i <<
8052 <<
8053 out: <<
8054 params.spi_interval = probe_interval; <<
8055 if (copy_to_user(optval, ¶ms, len <<
8056 return -EFAULT; <<
8057 <<
8058 if (put_user(len, optlen)) <<
8059 return -EFAULT; <<
8060 <<
8061 return 0; <<
8062 } <<
8063 <<
8064 static int sctp_getsockopt(struct sock *sk, i 6874 static int sctp_getsockopt(struct sock *sk, int level, int optname,
8065 char __user *optva 6875 char __user *optval, int __user *optlen)
8066 { 6876 {
8067 int retval = 0; 6877 int retval = 0;
8068 int len; 6878 int len;
8069 6879
8070 pr_debug("%s: sk:%p, optname:%d\n", _ 6880 pr_debug("%s: sk:%p, optname:%d\n", __func__, sk, optname);
8071 6881
8072 /* I can hardly begin to describe how 6882 /* I can hardly begin to describe how wrong this is. This is
8073 * so broken as to be worse than usel 6883 * so broken as to be worse than useless. The API draft
8074 * REALLY is NOT helpful here... I a 6884 * REALLY is NOT helpful here... I am not convinced that the
8075 * semantics of getsockopt() with a l 6885 * semantics of getsockopt() with a level OTHER THAN SOL_SCTP
8076 * are at all well-founded. 6886 * are at all well-founded.
8077 */ 6887 */
8078 if (level != SOL_SCTP) { 6888 if (level != SOL_SCTP) {
8079 struct sctp_af *af = sctp_sk( 6889 struct sctp_af *af = sctp_sk(sk)->pf->af;
8080 6890
8081 retval = af->getsockopt(sk, l 6891 retval = af->getsockopt(sk, level, optname, optval, optlen);
8082 return retval; 6892 return retval;
8083 } 6893 }
8084 6894
8085 if (get_user(len, optlen)) 6895 if (get_user(len, optlen))
8086 return -EFAULT; 6896 return -EFAULT;
8087 6897
8088 if (len < 0) 6898 if (len < 0)
8089 return -EINVAL; 6899 return -EINVAL;
8090 6900
8091 lock_sock(sk); 6901 lock_sock(sk);
8092 6902
8093 switch (optname) { 6903 switch (optname) {
8094 case SCTP_STATUS: 6904 case SCTP_STATUS:
8095 retval = sctp_getsockopt_sctp 6905 retval = sctp_getsockopt_sctp_status(sk, len, optval, optlen);
8096 break; 6906 break;
8097 case SCTP_DISABLE_FRAGMENTS: 6907 case SCTP_DISABLE_FRAGMENTS:
8098 retval = sctp_getsockopt_disa 6908 retval = sctp_getsockopt_disable_fragments(sk, len, optval,
8099 6909 optlen);
8100 break; 6910 break;
8101 case SCTP_EVENTS: 6911 case SCTP_EVENTS:
8102 retval = sctp_getsockopt_even 6912 retval = sctp_getsockopt_events(sk, len, optval, optlen);
8103 break; 6913 break;
8104 case SCTP_AUTOCLOSE: 6914 case SCTP_AUTOCLOSE:
8105 retval = sctp_getsockopt_auto 6915 retval = sctp_getsockopt_autoclose(sk, len, optval, optlen);
8106 break; 6916 break;
8107 case SCTP_SOCKOPT_PEELOFF: 6917 case SCTP_SOCKOPT_PEELOFF:
8108 retval = sctp_getsockopt_peel 6918 retval = sctp_getsockopt_peeloff(sk, len, optval, optlen);
8109 break; 6919 break;
8110 case SCTP_SOCKOPT_PEELOFF_FLAGS: 6920 case SCTP_SOCKOPT_PEELOFF_FLAGS:
8111 retval = sctp_getsockopt_peel 6921 retval = sctp_getsockopt_peeloff_flags(sk, len, optval, optlen);
8112 break; 6922 break;
8113 case SCTP_PEER_ADDR_PARAMS: 6923 case SCTP_PEER_ADDR_PARAMS:
8114 retval = sctp_getsockopt_peer 6924 retval = sctp_getsockopt_peer_addr_params(sk, len, optval,
8115 6925 optlen);
8116 break; 6926 break;
8117 case SCTP_DELAYED_SACK: 6927 case SCTP_DELAYED_SACK:
8118 retval = sctp_getsockopt_dela 6928 retval = sctp_getsockopt_delayed_ack(sk, len, optval,
8119 6929 optlen);
8120 break; 6930 break;
8121 case SCTP_INITMSG: 6931 case SCTP_INITMSG:
8122 retval = sctp_getsockopt_init 6932 retval = sctp_getsockopt_initmsg(sk, len, optval, optlen);
8123 break; 6933 break;
8124 case SCTP_GET_PEER_ADDRS: 6934 case SCTP_GET_PEER_ADDRS:
8125 retval = sctp_getsockopt_peer 6935 retval = sctp_getsockopt_peer_addrs(sk, len, optval,
8126 6936 optlen);
8127 break; 6937 break;
8128 case SCTP_GET_LOCAL_ADDRS: 6938 case SCTP_GET_LOCAL_ADDRS:
8129 retval = sctp_getsockopt_loca 6939 retval = sctp_getsockopt_local_addrs(sk, len, optval,
8130 6940 optlen);
8131 break; 6941 break;
8132 case SCTP_SOCKOPT_CONNECTX3: 6942 case SCTP_SOCKOPT_CONNECTX3:
8133 retval = sctp_getsockopt_conn 6943 retval = sctp_getsockopt_connectx3(sk, len, optval, optlen);
8134 break; 6944 break;
8135 case SCTP_DEFAULT_SEND_PARAM: 6945 case SCTP_DEFAULT_SEND_PARAM:
8136 retval = sctp_getsockopt_defa 6946 retval = sctp_getsockopt_default_send_param(sk, len,
8137 6947 optval, optlen);
8138 break; 6948 break;
8139 case SCTP_DEFAULT_SNDINFO: 6949 case SCTP_DEFAULT_SNDINFO:
8140 retval = sctp_getsockopt_defa 6950 retval = sctp_getsockopt_default_sndinfo(sk, len,
8141 6951 optval, optlen);
8142 break; 6952 break;
8143 case SCTP_PRIMARY_ADDR: 6953 case SCTP_PRIMARY_ADDR:
8144 retval = sctp_getsockopt_prim 6954 retval = sctp_getsockopt_primary_addr(sk, len, optval, optlen);
8145 break; 6955 break;
8146 case SCTP_NODELAY: 6956 case SCTP_NODELAY:
8147 retval = sctp_getsockopt_node 6957 retval = sctp_getsockopt_nodelay(sk, len, optval, optlen);
8148 break; 6958 break;
8149 case SCTP_RTOINFO: 6959 case SCTP_RTOINFO:
8150 retval = sctp_getsockopt_rtoi 6960 retval = sctp_getsockopt_rtoinfo(sk, len, optval, optlen);
8151 break; 6961 break;
8152 case SCTP_ASSOCINFO: 6962 case SCTP_ASSOCINFO:
8153 retval = sctp_getsockopt_asso 6963 retval = sctp_getsockopt_associnfo(sk, len, optval, optlen);
8154 break; 6964 break;
8155 case SCTP_I_WANT_MAPPED_V4_ADDR: 6965 case SCTP_I_WANT_MAPPED_V4_ADDR:
8156 retval = sctp_getsockopt_mapp 6966 retval = sctp_getsockopt_mappedv4(sk, len, optval, optlen);
8157 break; 6967 break;
8158 case SCTP_MAXSEG: 6968 case SCTP_MAXSEG:
8159 retval = sctp_getsockopt_maxs 6969 retval = sctp_getsockopt_maxseg(sk, len, optval, optlen);
8160 break; 6970 break;
8161 case SCTP_GET_PEER_ADDR_INFO: 6971 case SCTP_GET_PEER_ADDR_INFO:
8162 retval = sctp_getsockopt_peer 6972 retval = sctp_getsockopt_peer_addr_info(sk, len, optval,
8163 6973 optlen);
8164 break; 6974 break;
8165 case SCTP_ADAPTATION_LAYER: 6975 case SCTP_ADAPTATION_LAYER:
8166 retval = sctp_getsockopt_adap 6976 retval = sctp_getsockopt_adaptation_layer(sk, len, optval,
8167 6977 optlen);
8168 break; 6978 break;
8169 case SCTP_CONTEXT: 6979 case SCTP_CONTEXT:
8170 retval = sctp_getsockopt_cont 6980 retval = sctp_getsockopt_context(sk, len, optval, optlen);
8171 break; 6981 break;
8172 case SCTP_FRAGMENT_INTERLEAVE: 6982 case SCTP_FRAGMENT_INTERLEAVE:
8173 retval = sctp_getsockopt_frag 6983 retval = sctp_getsockopt_fragment_interleave(sk, len, optval,
8174 6984 optlen);
8175 break; 6985 break;
8176 case SCTP_PARTIAL_DELIVERY_POINT: 6986 case SCTP_PARTIAL_DELIVERY_POINT:
8177 retval = sctp_getsockopt_part 6987 retval = sctp_getsockopt_partial_delivery_point(sk, len, optval,
8178 6988 optlen);
8179 break; 6989 break;
8180 case SCTP_MAX_BURST: 6990 case SCTP_MAX_BURST:
8181 retval = sctp_getsockopt_maxb 6991 retval = sctp_getsockopt_maxburst(sk, len, optval, optlen);
8182 break; 6992 break;
8183 case SCTP_AUTH_KEY: 6993 case SCTP_AUTH_KEY:
8184 case SCTP_AUTH_CHUNK: 6994 case SCTP_AUTH_CHUNK:
8185 case SCTP_AUTH_DELETE_KEY: 6995 case SCTP_AUTH_DELETE_KEY:
8186 case SCTP_AUTH_DEACTIVATE_KEY: <<
8187 retval = -EOPNOTSUPP; 6996 retval = -EOPNOTSUPP;
8188 break; 6997 break;
8189 case SCTP_HMAC_IDENT: 6998 case SCTP_HMAC_IDENT:
8190 retval = sctp_getsockopt_hmac 6999 retval = sctp_getsockopt_hmac_ident(sk, len, optval, optlen);
8191 break; 7000 break;
8192 case SCTP_AUTH_ACTIVE_KEY: 7001 case SCTP_AUTH_ACTIVE_KEY:
8193 retval = sctp_getsockopt_acti 7002 retval = sctp_getsockopt_active_key(sk, len, optval, optlen);
8194 break; 7003 break;
8195 case SCTP_PEER_AUTH_CHUNKS: 7004 case SCTP_PEER_AUTH_CHUNKS:
8196 retval = sctp_getsockopt_peer 7005 retval = sctp_getsockopt_peer_auth_chunks(sk, len, optval,
8197 7006 optlen);
8198 break; 7007 break;
8199 case SCTP_LOCAL_AUTH_CHUNKS: 7008 case SCTP_LOCAL_AUTH_CHUNKS:
8200 retval = sctp_getsockopt_loca 7009 retval = sctp_getsockopt_local_auth_chunks(sk, len, optval,
8201 7010 optlen);
8202 break; 7011 break;
8203 case SCTP_GET_ASSOC_NUMBER: 7012 case SCTP_GET_ASSOC_NUMBER:
8204 retval = sctp_getsockopt_asso 7013 retval = sctp_getsockopt_assoc_number(sk, len, optval, optlen);
8205 break; 7014 break;
8206 case SCTP_GET_ASSOC_ID_LIST: 7015 case SCTP_GET_ASSOC_ID_LIST:
8207 retval = sctp_getsockopt_asso 7016 retval = sctp_getsockopt_assoc_ids(sk, len, optval, optlen);
8208 break; 7017 break;
8209 case SCTP_AUTO_ASCONF: 7018 case SCTP_AUTO_ASCONF:
8210 retval = sctp_getsockopt_auto 7019 retval = sctp_getsockopt_auto_asconf(sk, len, optval, optlen);
8211 break; 7020 break;
8212 case SCTP_PEER_ADDR_THLDS: 7021 case SCTP_PEER_ADDR_THLDS:
8213 retval = sctp_getsockopt_padd !! 7022 retval = sctp_getsockopt_paddr_thresholds(sk, optval, len, optlen);
8214 <<
8215 break; <<
8216 case SCTP_PEER_ADDR_THLDS_V2: <<
8217 retval = sctp_getsockopt_padd <<
8218 <<
8219 break; 7023 break;
8220 case SCTP_GET_ASSOC_STATS: 7024 case SCTP_GET_ASSOC_STATS:
8221 retval = sctp_getsockopt_asso 7025 retval = sctp_getsockopt_assoc_stats(sk, len, optval, optlen);
8222 break; 7026 break;
8223 case SCTP_RECVRCVINFO: 7027 case SCTP_RECVRCVINFO:
8224 retval = sctp_getsockopt_recv 7028 retval = sctp_getsockopt_recvrcvinfo(sk, len, optval, optlen);
8225 break; 7029 break;
8226 case SCTP_RECVNXTINFO: 7030 case SCTP_RECVNXTINFO:
8227 retval = sctp_getsockopt_recv 7031 retval = sctp_getsockopt_recvnxtinfo(sk, len, optval, optlen);
8228 break; 7032 break;
8229 case SCTP_PR_SUPPORTED: 7033 case SCTP_PR_SUPPORTED:
8230 retval = sctp_getsockopt_pr_s 7034 retval = sctp_getsockopt_pr_supported(sk, len, optval, optlen);
8231 break; 7035 break;
8232 case SCTP_DEFAULT_PRINFO: 7036 case SCTP_DEFAULT_PRINFO:
8233 retval = sctp_getsockopt_defa 7037 retval = sctp_getsockopt_default_prinfo(sk, len, optval,
8234 7038 optlen);
8235 break; 7039 break;
8236 case SCTP_PR_ASSOC_STATUS: 7040 case SCTP_PR_ASSOC_STATUS:
8237 retval = sctp_getsockopt_pr_a 7041 retval = sctp_getsockopt_pr_assocstatus(sk, len, optval,
8238 7042 optlen);
8239 break; 7043 break;
8240 case SCTP_PR_STREAM_STATUS: 7044 case SCTP_PR_STREAM_STATUS:
8241 retval = sctp_getsockopt_pr_s 7045 retval = sctp_getsockopt_pr_streamstatus(sk, len, optval,
8242 7046 optlen);
8243 break; 7047 break;
8244 case SCTP_RECONFIG_SUPPORTED: 7048 case SCTP_RECONFIG_SUPPORTED:
8245 retval = sctp_getsockopt_reco 7049 retval = sctp_getsockopt_reconfig_supported(sk, len, optval,
8246 7050 optlen);
8247 break; 7051 break;
8248 case SCTP_ENABLE_STREAM_RESET: 7052 case SCTP_ENABLE_STREAM_RESET:
8249 retval = sctp_getsockopt_enab 7053 retval = sctp_getsockopt_enable_strreset(sk, len, optval,
8250 7054 optlen);
8251 break; 7055 break;
8252 case SCTP_STREAM_SCHEDULER: <<
8253 retval = sctp_getsockopt_sche <<
8254 <<
8255 break; <<
8256 case SCTP_STREAM_SCHEDULER_VALUE: <<
8257 retval = sctp_getsockopt_sche <<
8258 <<
8259 break; <<
8260 case SCTP_INTERLEAVING_SUPPORTED: <<
8261 retval = sctp_getsockopt_inte <<
8262 <<
8263 break; <<
8264 case SCTP_REUSE_PORT: <<
8265 retval = sctp_getsockopt_reus <<
8266 break; <<
8267 case SCTP_EVENT: <<
8268 retval = sctp_getsockopt_even <<
8269 break; <<
8270 case SCTP_ASCONF_SUPPORTED: <<
8271 retval = sctp_getsockopt_asco <<
8272 <<
8273 break; <<
8274 case SCTP_AUTH_SUPPORTED: <<
8275 retval = sctp_getsockopt_auth <<
8276 <<
8277 break; <<
8278 case SCTP_ECN_SUPPORTED: <<
8279 retval = sctp_getsockopt_ecn_ <<
8280 break; <<
8281 case SCTP_EXPOSE_POTENTIALLY_FAILED_S <<
8282 retval = sctp_getsockopt_pf_e <<
8283 break; <<
8284 case SCTP_REMOTE_UDP_ENCAPS_PORT: <<
8285 retval = sctp_getsockopt_enca <<
8286 break; <<
8287 case SCTP_PLPMTUD_PROBE_INTERVAL: <<
8288 retval = sctp_getsockopt_prob <<
8289 break; <<
8290 default: 7056 default:
8291 retval = -ENOPROTOOPT; 7057 retval = -ENOPROTOOPT;
8292 break; 7058 break;
8293 } 7059 }
8294 7060
8295 release_sock(sk); 7061 release_sock(sk);
8296 return retval; 7062 return retval;
8297 } 7063 }
8298 7064
8299 static bool sctp_bpf_bypass_getsockopt(int le <<
8300 { <<
8301 if (level == SOL_SCTP) { <<
8302 switch (optname) { <<
8303 case SCTP_SOCKOPT_PEELOFF: <<
8304 case SCTP_SOCKOPT_PEELOFF_FLA <<
8305 case SCTP_SOCKOPT_CONNECTX3: <<
8306 return true; <<
8307 default: <<
8308 return false; <<
8309 } <<
8310 } <<
8311 <<
8312 return false; <<
8313 } <<
8314 <<
8315 static int sctp_hash(struct sock *sk) 7065 static int sctp_hash(struct sock *sk)
8316 { 7066 {
8317 /* STUB */ 7067 /* STUB */
8318 return 0; 7068 return 0;
8319 } 7069 }
8320 7070
8321 static void sctp_unhash(struct sock *sk) 7071 static void sctp_unhash(struct sock *sk)
8322 { 7072 {
8323 /* STUB */ 7073 /* STUB */
8324 } 7074 }
8325 7075
8326 /* Check if port is acceptable. Possibly fin 7076 /* Check if port is acceptable. Possibly find first available port.
8327 * 7077 *
8328 * The port hash table (contained in the 'glo 7078 * The port hash table (contained in the 'global' SCTP protocol storage
8329 * returned by struct sctp_protocol *sctp_get 7079 * returned by struct sctp_protocol *sctp_get_protocol()). The hash
8330 * table is an array of 4096 lists (sctp_bind 7080 * table is an array of 4096 lists (sctp_bind_hashbucket). Each
8331 * list (the list number is the port number h 7081 * list (the list number is the port number hashed out, so as you
8332 * would expect from a hash function, all the 7082 * would expect from a hash function, all the ports in a given list have
8333 * such a number that hashes out to the same 7083 * such a number that hashes out to the same list number; you were
8334 * expecting that, right?); so each list has 7084 * expecting that, right?); so each list has a set of ports, with a
8335 * link to the socket (struct sock) that uses 7085 * link to the socket (struct sock) that uses it, the port number and
8336 * a fastreuse flag (FIXME: NPI ipg). 7086 * a fastreuse flag (FIXME: NPI ipg).
8337 */ 7087 */
8338 static struct sctp_bind_bucket *sctp_bucket_c 7088 static struct sctp_bind_bucket *sctp_bucket_create(
8339 struct sctp_bind_hashbucket *head, st 7089 struct sctp_bind_hashbucket *head, struct net *, unsigned short snum);
8340 7090
8341 static int sctp_get_port_local(struct sock *s !! 7091 static long sctp_get_port_local(struct sock *sk, union sctp_addr *addr)
8342 { 7092 {
8343 struct sctp_sock *sp = sctp_sk(sk); <<
8344 bool reuse = (sk->sk_reuse || sp->reu <<
8345 struct sctp_bind_hashbucket *head; /* 7093 struct sctp_bind_hashbucket *head; /* hash list */
8346 struct net *net = sock_net(sk); <<
8347 kuid_t uid = sock_i_uid(sk); <<
8348 struct sctp_bind_bucket *pp; 7094 struct sctp_bind_bucket *pp;
8349 unsigned short snum; 7095 unsigned short snum;
8350 int ret; 7096 int ret;
8351 7097
8352 snum = ntohs(addr->v4.sin_port); 7098 snum = ntohs(addr->v4.sin_port);
8353 7099
8354 pr_debug("%s: begins, snum:%d\n", __f 7100 pr_debug("%s: begins, snum:%d\n", __func__, snum);
8355 7101
8356 if (snum == 0) { 7102 if (snum == 0) {
8357 /* Search for an available po 7103 /* Search for an available port. */
8358 int low, high, remaining, ind 7104 int low, high, remaining, index;
8359 unsigned int rover; 7105 unsigned int rover;
>> 7106 struct net *net = sock_net(sk);
8360 7107
8361 inet_sk_get_local_port_range( !! 7108 inet_get_local_port_range(net, &low, &high);
8362 remaining = (high - low) + 1; 7109 remaining = (high - low) + 1;
8363 rover = get_random_u32_below( !! 7110 rover = prandom_u32() % remaining + low;
8364 7111
8365 do { 7112 do {
8366 rover++; 7113 rover++;
8367 if ((rover < low) || 7114 if ((rover < low) || (rover > high))
8368 rover = low; 7115 rover = low;
8369 if (inet_is_local_res 7116 if (inet_is_local_reserved_port(net, rover))
8370 continue; 7117 continue;
8371 index = sctp_phashfn( !! 7118 index = sctp_phashfn(sock_net(sk), rover);
8372 head = &sctp_port_has 7119 head = &sctp_port_hashtable[index];
8373 spin_lock_bh(&head->l 7120 spin_lock_bh(&head->lock);
8374 sctp_for_each_hentry( 7121 sctp_for_each_hentry(pp, &head->chain)
8375 if ((pp->port 7122 if ((pp->port == rover) &&
8376 net_eq(ne !! 7123 net_eq(sock_net(sk), pp->net))
8377 goto 7124 goto next;
8378 break; 7125 break;
8379 next: 7126 next:
8380 spin_unlock_bh(&head- 7127 spin_unlock_bh(&head->lock);
8381 cond_resched(); 7128 cond_resched();
8382 } while (--remaining > 0); 7129 } while (--remaining > 0);
8383 7130
8384 /* Exhausted local port range 7131 /* Exhausted local port range during search? */
8385 ret = 1; 7132 ret = 1;
8386 if (remaining <= 0) 7133 if (remaining <= 0)
8387 return ret; 7134 return ret;
8388 7135
8389 /* OK, here is the one we wil 7136 /* OK, here is the one we will use. HEAD (the port
8390 * hash table list entry) is 7137 * hash table list entry) is non-NULL and we hold it's
8391 * mutex. 7138 * mutex.
8392 */ 7139 */
8393 snum = rover; 7140 snum = rover;
8394 } else { 7141 } else {
8395 /* We are given an specific p 7142 /* We are given an specific port number; we verify
8396 * that it is not being used. 7143 * that it is not being used. If it is used, we will
8397 * exahust the search in the 7144 * exahust the search in the hash list corresponding
8398 * to the port number (snum) 7145 * to the port number (snum) - we detect that with the
8399 * port iterator, pp being NU 7146 * port iterator, pp being NULL.
8400 */ 7147 */
8401 head = &sctp_port_hashtable[s !! 7148 head = &sctp_port_hashtable[sctp_phashfn(sock_net(sk), snum)];
8402 spin_lock_bh(&head->lock); 7149 spin_lock_bh(&head->lock);
8403 sctp_for_each_hentry(pp, &hea 7150 sctp_for_each_hentry(pp, &head->chain) {
8404 if ((pp->port == snum !! 7151 if ((pp->port == snum) && net_eq(pp->net, sock_net(sk)))
8405 goto pp_found 7152 goto pp_found;
8406 } 7153 }
8407 } 7154 }
8408 pp = NULL; 7155 pp = NULL;
8409 goto pp_not_found; 7156 goto pp_not_found;
8410 pp_found: 7157 pp_found:
8411 if (!hlist_empty(&pp->owner)) { 7158 if (!hlist_empty(&pp->owner)) {
8412 /* We had a port hash table h 7159 /* We had a port hash table hit - there is an
8413 * available port (pp != NULL 7160 * available port (pp != NULL) and it is being
8414 * used by other socket (pp-> 7161 * used by other socket (pp->owner not empty); that other
8415 * socket is going to be sk2. 7162 * socket is going to be sk2.
8416 */ 7163 */
>> 7164 int reuse = sk->sk_reuse;
8417 struct sock *sk2; 7165 struct sock *sk2;
8418 7166
8419 pr_debug("%s: found a possibl 7167 pr_debug("%s: found a possible match\n", __func__);
8420 7168
8421 if ((pp->fastreuse && reuse & !! 7169 if (pp->fastreuse && sk->sk_reuse &&
8422 sk->sk_state != SCTP_SS_ !! 7170 sk->sk_state != SCTP_SS_LISTENING)
8423 (pp->fastreuseport && sk- <<
8424 uid_eq(pp->fastuid, uid) <<
8425 goto success; 7171 goto success;
8426 7172
8427 /* Run through the list of so 7173 /* Run through the list of sockets bound to the port
8428 * (pp->port) [via the pointe 7174 * (pp->port) [via the pointers bind_next and
8429 * bind_pprev in the struct s 7175 * bind_pprev in the struct sock *sk2 (pp->sk)]. On each one,
8430 * we get the endpoint they d 7176 * we get the endpoint they describe and run through
8431 * the endpoint's list of IP 7177 * the endpoint's list of IP (v4 or v6) addresses,
8432 * comparing each of the addr 7178 * comparing each of the addresses with the address of
8433 * the socket sk. If we find 7179 * the socket sk. If we find a match, then that means
8434 * that this port/socket (sk) 7180 * that this port/socket (sk) combination are already
8435 * in an endpoint. 7181 * in an endpoint.
8436 */ 7182 */
8437 sk_for_each_bound(sk2, &pp->o 7183 sk_for_each_bound(sk2, &pp->owner) {
8438 int bound_dev_if2 = R !! 7184 struct sctp_endpoint *ep2;
8439 struct sctp_sock *sp2 !! 7185 ep2 = sctp_sk(sk2)->ep;
8440 struct sctp_endpoint <<
8441 7186
8442 if (sk == sk2 || 7187 if (sk == sk2 ||
8443 (reuse && (sk2->s !! 7188 (reuse && sk2->sk_reuse &&
8444 sk2->sk_state != !! 7189 sk2->sk_state != SCTP_SS_LISTENING))
8445 (sk->sk_reuseport <<
8446 uid_eq(uid, sock <<
8447 continue; 7190 continue;
8448 7191
8449 if ((!sk->sk_bound_de !! 7192 if (sctp_bind_addr_conflict(&ep2->base.bind_addr, addr,
8450 sk->sk_bound_dev !! 7193 sctp_sk(sk2), sctp_sk(sk))) {
8451 sctp_bind_addr_co !! 7194 ret = (long)sk2;
8452 <<
8453 ret = 1; <<
8454 goto fail_unl 7195 goto fail_unlock;
8455 } 7196 }
8456 } 7197 }
8457 7198
8458 pr_debug("%s: found a match\n 7199 pr_debug("%s: found a match\n", __func__);
8459 } 7200 }
8460 pp_not_found: 7201 pp_not_found:
8461 /* If there was a hash table miss, cr 7202 /* If there was a hash table miss, create a new port. */
8462 ret = 1; 7203 ret = 1;
8463 if (!pp && !(pp = sctp_bucket_create( !! 7204 if (!pp && !(pp = sctp_bucket_create(head, sock_net(sk), snum)))
8464 goto fail_unlock; 7205 goto fail_unlock;
8465 7206
8466 /* In either case (hit or miss), make 7207 /* In either case (hit or miss), make sure fastreuse is 1 only
8467 * if sk->sk_reuse is too (that is, i 7208 * if sk->sk_reuse is too (that is, if the caller requested
8468 * SO_REUSEADDR on this socket -sk-). 7209 * SO_REUSEADDR on this socket -sk-).
8469 */ 7210 */
8470 if (hlist_empty(&pp->owner)) { 7211 if (hlist_empty(&pp->owner)) {
8471 if (reuse && sk->sk_state != !! 7212 if (sk->sk_reuse && sk->sk_state != SCTP_SS_LISTENING)
8472 pp->fastreuse = 1; 7213 pp->fastreuse = 1;
8473 else 7214 else
8474 pp->fastreuse = 0; 7215 pp->fastreuse = 0;
8475 !! 7216 } else if (pp->fastreuse &&
8476 if (sk->sk_reuseport) { !! 7217 (!sk->sk_reuse || sk->sk_state == SCTP_SS_LISTENING))
8477 pp->fastreuseport = 1 !! 7218 pp->fastreuse = 0;
8478 pp->fastuid = uid; <<
8479 } else { <<
8480 pp->fastreuseport = 0 <<
8481 } <<
8482 } else { <<
8483 if (pp->fastreuse && <<
8484 (!reuse || sk->sk_state = <<
8485 pp->fastreuse = 0; <<
8486 <<
8487 if (pp->fastreuseport && <<
8488 (!sk->sk_reuseport || !ui <<
8489 pp->fastreuseport = 0 <<
8490 } <<
8491 7219
8492 /* We are set, so fill up all the dat 7220 /* We are set, so fill up all the data in the hash table
8493 * entry, tie the socket list informa 7221 * entry, tie the socket list information with the rest of the
8494 * sockets FIXME: Blurry, NPI (ipg). 7222 * sockets FIXME: Blurry, NPI (ipg).
8495 */ 7223 */
8496 success: 7224 success:
8497 if (!sp->bind_hash) { !! 7225 if (!sctp_sk(sk)->bind_hash) {
8498 inet_sk(sk)->inet_num = snum; 7226 inet_sk(sk)->inet_num = snum;
8499 sk_add_bind_node(sk, &pp->own 7227 sk_add_bind_node(sk, &pp->owner);
8500 sp->bind_hash = pp; !! 7228 sctp_sk(sk)->bind_hash = pp;
8501 } 7229 }
8502 ret = 0; 7230 ret = 0;
8503 7231
8504 fail_unlock: 7232 fail_unlock:
8505 spin_unlock_bh(&head->lock); 7233 spin_unlock_bh(&head->lock);
8506 return ret; 7234 return ret;
8507 } 7235 }
8508 7236
8509 /* Assign a 'snum' port to the socket. If sn 7237 /* Assign a 'snum' port to the socket. If snum == 0, an ephemeral
8510 * port is requested. 7238 * port is requested.
8511 */ 7239 */
8512 static int sctp_get_port(struct sock *sk, uns 7240 static int sctp_get_port(struct sock *sk, unsigned short snum)
8513 { 7241 {
8514 union sctp_addr addr; 7242 union sctp_addr addr;
8515 struct sctp_af *af = sctp_sk(sk)->pf- 7243 struct sctp_af *af = sctp_sk(sk)->pf->af;
8516 7244
8517 /* Set up a dummy address struct from 7245 /* Set up a dummy address struct from the sk. */
8518 af->from_sk(&addr, sk); 7246 af->from_sk(&addr, sk);
8519 addr.v4.sin_port = htons(snum); 7247 addr.v4.sin_port = htons(snum);
8520 7248
8521 /* Note: sk->sk_num gets filled in if 7249 /* Note: sk->sk_num gets filled in if ephemeral port request. */
8522 return sctp_get_port_local(sk, &addr) !! 7250 return !!sctp_get_port_local(sk, &addr);
8523 } 7251 }
8524 7252
8525 /* 7253 /*
8526 * Move a socket to LISTENING state. 7254 * Move a socket to LISTENING state.
8527 */ 7255 */
8528 static int sctp_listen_start(struct sock *sk, 7256 static int sctp_listen_start(struct sock *sk, int backlog)
8529 { 7257 {
8530 struct sctp_sock *sp = sctp_sk(sk); 7258 struct sctp_sock *sp = sctp_sk(sk);
8531 struct sctp_endpoint *ep = sp->ep; 7259 struct sctp_endpoint *ep = sp->ep;
8532 struct crypto_shash *tfm = NULL; 7260 struct crypto_shash *tfm = NULL;
8533 char alg[32]; 7261 char alg[32];
8534 int err; <<
8535 7262
8536 /* Allocate HMAC for generating cooki 7263 /* Allocate HMAC for generating cookie. */
8537 if (!sp->hmac && sp->sctp_hmac_alg) { 7264 if (!sp->hmac && sp->sctp_hmac_alg) {
8538 sprintf(alg, "hmac(%s)", sp-> 7265 sprintf(alg, "hmac(%s)", sp->sctp_hmac_alg);
8539 tfm = crypto_alloc_shash(alg, 7266 tfm = crypto_alloc_shash(alg, 0, 0);
8540 if (IS_ERR(tfm)) { 7267 if (IS_ERR(tfm)) {
8541 net_info_ratelimited( 7268 net_info_ratelimited("failed to load transform for %s: %ld\n",
8542 7269 sp->sctp_hmac_alg, PTR_ERR(tfm));
8543 return -ENOSYS; 7270 return -ENOSYS;
8544 } 7271 }
8545 sctp_sk(sk)->hmac = tfm; 7272 sctp_sk(sk)->hmac = tfm;
8546 } 7273 }
8547 7274
8548 /* 7275 /*
8549 * If a bind() or sctp_bindx() is not 7276 * If a bind() or sctp_bindx() is not called prior to a listen()
8550 * call that allows new associations 7277 * call that allows new associations to be accepted, the system
8551 * picks an ephemeral port and will c 7278 * picks an ephemeral port and will choose an address set equivalent
8552 * to binding with a wildcard address 7279 * to binding with a wildcard address.
8553 * 7280 *
8554 * This is not currently spelled out 7281 * This is not currently spelled out in the SCTP sockets
8555 * extensions draft, but follows the 7282 * extensions draft, but follows the practice as seen in TCP
8556 * sockets. 7283 * sockets.
8557 * 7284 *
8558 */ 7285 */
8559 inet_sk_set_state(sk, SCTP_SS_LISTENI !! 7286 sk->sk_state = SCTP_SS_LISTENING;
8560 if (!ep->base.bind_addr.port) { 7287 if (!ep->base.bind_addr.port) {
8561 if (sctp_autobind(sk)) { !! 7288 if (sctp_autobind(sk))
8562 err = -EAGAIN; !! 7289 return -EAGAIN;
8563 goto err; <<
8564 } <<
8565 } else { 7290 } else {
8566 if (sctp_get_port(sk, inet_sk 7291 if (sctp_get_port(sk, inet_sk(sk)->inet_num)) {
8567 err = -EADDRINUSE; !! 7292 sk->sk_state = SCTP_SS_CLOSED;
8568 goto err; !! 7293 return -EADDRINUSE;
8569 } 7294 }
8570 } 7295 }
8571 7296
8572 WRITE_ONCE(sk->sk_max_ack_backlog, ba !! 7297 sk->sk_max_ack_backlog = backlog;
8573 err = sctp_hash_endpoint(ep); !! 7298 sctp_hash_endpoint(ep);
8574 if (err) <<
8575 goto err; <<
8576 <<
8577 return 0; 7299 return 0;
8578 err: <<
8579 inet_sk_set_state(sk, SCTP_SS_CLOSED) <<
8580 return err; <<
8581 } 7300 }
8582 7301
8583 /* 7302 /*
8584 * 4.1.3 / 5.1.3 listen() 7303 * 4.1.3 / 5.1.3 listen()
8585 * 7304 *
8586 * By default, new associations are not acc 7305 * By default, new associations are not accepted for UDP style sockets.
8587 * An application uses listen() to mark a s 7306 * An application uses listen() to mark a socket as being able to
8588 * accept new associations. 7307 * accept new associations.
8589 * 7308 *
8590 * On TCP style sockets, applications use l 7309 * On TCP style sockets, applications use listen() to ready the SCTP
8591 * endpoint for accepting inbound associati 7310 * endpoint for accepting inbound associations.
8592 * 7311 *
8593 * On both types of endpoints a backlog of 7312 * On both types of endpoints a backlog of '' disables listening.
8594 * 7313 *
8595 * Move a socket to LISTENING state. 7314 * Move a socket to LISTENING state.
8596 */ 7315 */
8597 int sctp_inet_listen(struct socket *sock, int 7316 int sctp_inet_listen(struct socket *sock, int backlog)
8598 { 7317 {
8599 struct sock *sk = sock->sk; 7318 struct sock *sk = sock->sk;
8600 struct sctp_endpoint *ep = sctp_sk(sk 7319 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
8601 int err = -EINVAL; 7320 int err = -EINVAL;
8602 7321
8603 if (unlikely(backlog < 0)) 7322 if (unlikely(backlog < 0))
8604 return err; 7323 return err;
8605 7324
8606 lock_sock(sk); 7325 lock_sock(sk);
8607 7326
8608 /* Peeled-off sockets are not allowed 7327 /* Peeled-off sockets are not allowed to listen(). */
8609 if (sctp_style(sk, UDP_HIGH_BANDWIDTH 7328 if (sctp_style(sk, UDP_HIGH_BANDWIDTH))
8610 goto out; 7329 goto out;
8611 7330
8612 if (sock->state != SS_UNCONNECTED) 7331 if (sock->state != SS_UNCONNECTED)
8613 goto out; 7332 goto out;
8614 7333
8615 if (!sctp_sstate(sk, LISTENING) && !s 7334 if (!sctp_sstate(sk, LISTENING) && !sctp_sstate(sk, CLOSED))
8616 goto out; 7335 goto out;
8617 7336
8618 /* If backlog is zero, disable listen 7337 /* If backlog is zero, disable listening. */
8619 if (!backlog) { 7338 if (!backlog) {
8620 if (sctp_sstate(sk, CLOSED)) 7339 if (sctp_sstate(sk, CLOSED))
8621 goto out; 7340 goto out;
8622 7341
8623 err = 0; 7342 err = 0;
8624 sctp_unhash_endpoint(ep); 7343 sctp_unhash_endpoint(ep);
8625 sk->sk_state = SCTP_SS_CLOSED 7344 sk->sk_state = SCTP_SS_CLOSED;
8626 if (sk->sk_reuse || sctp_sk(s !! 7345 if (sk->sk_reuse)
8627 sctp_sk(sk)->bind_has 7346 sctp_sk(sk)->bind_hash->fastreuse = 1;
8628 goto out; 7347 goto out;
8629 } 7348 }
8630 7349
8631 /* If we are already listening, just 7350 /* If we are already listening, just update the backlog */
8632 if (sctp_sstate(sk, LISTENING)) 7351 if (sctp_sstate(sk, LISTENING))
8633 WRITE_ONCE(sk->sk_max_ack_bac !! 7352 sk->sk_max_ack_backlog = backlog;
8634 else { 7353 else {
8635 err = sctp_listen_start(sk, b 7354 err = sctp_listen_start(sk, backlog);
8636 if (err) 7355 if (err)
8637 goto out; 7356 goto out;
8638 } 7357 }
8639 7358
8640 err = 0; 7359 err = 0;
8641 out: 7360 out:
8642 release_sock(sk); 7361 release_sock(sk);
8643 return err; 7362 return err;
8644 } 7363 }
8645 7364
8646 /* 7365 /*
8647 * This function is done by modeling the curr 7366 * This function is done by modeling the current datagram_poll() and the
8648 * tcp_poll(). Note that, based on these imp 7367 * tcp_poll(). Note that, based on these implementations, we don't
8649 * lock the socket in this function, even tho 7368 * lock the socket in this function, even though it seems that,
8650 * ideally, locking or some other mechanisms 7369 * ideally, locking or some other mechanisms can be used to ensure
8651 * the integrity of the counters (sndbuf and 7370 * the integrity of the counters (sndbuf and wmem_alloc) used
8652 * in this place. We assume that we don't ne 7371 * in this place. We assume that we don't need locks either until proven
8653 * otherwise. 7372 * otherwise.
8654 * 7373 *
8655 * Another thing to note is that we include t 7374 * Another thing to note is that we include the Async I/O support
8656 * here, again, by modeling the current TCP/U 7375 * here, again, by modeling the current TCP/UDP code. We don't have
8657 * a good way to test with it yet. 7376 * a good way to test with it yet.
8658 */ 7377 */
8659 __poll_t sctp_poll(struct file *file, struct !! 7378 unsigned int sctp_poll(struct file *file, struct socket *sock, poll_table *wait)
8660 { 7379 {
8661 struct sock *sk = sock->sk; 7380 struct sock *sk = sock->sk;
8662 struct sctp_sock *sp = sctp_sk(sk); 7381 struct sctp_sock *sp = sctp_sk(sk);
8663 __poll_t mask; !! 7382 unsigned int mask;
8664 7383
8665 poll_wait(file, sk_sleep(sk), wait); 7384 poll_wait(file, sk_sleep(sk), wait);
8666 7385
8667 sock_rps_record_flow(sk); 7386 sock_rps_record_flow(sk);
8668 7387
8669 /* A TCP-style listening socket becom 7388 /* A TCP-style listening socket becomes readable when the accept queue
8670 * is not empty. 7389 * is not empty.
8671 */ 7390 */
8672 if (sctp_style(sk, TCP) && sctp_sstat 7391 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
8673 return (!list_empty(&sp->ep-> 7392 return (!list_empty(&sp->ep->asocs)) ?
8674 (EPOLLIN | EPOLLRDNOR !! 7393 (POLLIN | POLLRDNORM) : 0;
8675 7394
8676 mask = 0; 7395 mask = 0;
8677 7396
8678 /* Is there any exceptional events? 7397 /* Is there any exceptional events? */
8679 if (sk->sk_err || !skb_queue_empty_lo 7398 if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
8680 mask |= EPOLLERR | !! 7399 mask |= POLLERR |
8681 (sock_flag(sk, SOCK_S !! 7400 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
8682 if (sk->sk_shutdown & RCV_SHUTDOWN) 7401 if (sk->sk_shutdown & RCV_SHUTDOWN)
8683 mask |= EPOLLRDHUP | EPOLLIN !! 7402 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
8684 if (sk->sk_shutdown == SHUTDOWN_MASK) 7403 if (sk->sk_shutdown == SHUTDOWN_MASK)
8685 mask |= EPOLLHUP; !! 7404 mask |= POLLHUP;
8686 7405
8687 /* Is it readable? Reconsider this c 7406 /* Is it readable? Reconsider this code with TCP-style support. */
8688 if (!skb_queue_empty_lockless(&sk->sk 7407 if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
8689 mask |= EPOLLIN | EPOLLRDNORM !! 7408 mask |= POLLIN | POLLRDNORM;
8690 7409
8691 /* The association is either gone or 7410 /* The association is either gone or not ready. */
8692 if (!sctp_style(sk, UDP) && sctp_ssta 7411 if (!sctp_style(sk, UDP) && sctp_sstate(sk, CLOSED))
8693 return mask; 7412 return mask;
8694 7413
8695 /* Is it writable? */ 7414 /* Is it writable? */
8696 if (sctp_writeable(sk)) { 7415 if (sctp_writeable(sk)) {
8697 mask |= EPOLLOUT | EPOLLWRNOR !! 7416 mask |= POLLOUT | POLLWRNORM;
8698 } else { 7417 } else {
8699 sk_set_bit(SOCKWQ_ASYNC_NOSPA 7418 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
8700 /* 7419 /*
8701 * Since the socket is not lo 7420 * Since the socket is not locked, the buffer
8702 * might be made available af 7421 * might be made available after the writeable check and
8703 * before the bit is set. Th 7422 * before the bit is set. This could cause a lost I/O
8704 * signal. tcp_poll() has a 7423 * signal. tcp_poll() has a race breaker for this race
8705 * condition. Based on their 7424 * condition. Based on their implementation, we put
8706 * in the following code to c 7425 * in the following code to cover it as well.
8707 */ 7426 */
8708 if (sctp_writeable(sk)) 7427 if (sctp_writeable(sk))
8709 mask |= EPOLLOUT | EP !! 7428 mask |= POLLOUT | POLLWRNORM;
8710 } 7429 }
8711 return mask; 7430 return mask;
8712 } 7431 }
8713 7432
8714 /******************************************** 7433 /********************************************************************
8715 * 2nd Level Abstractions 7434 * 2nd Level Abstractions
8716 ******************************************** 7435 ********************************************************************/
8717 7436
8718 static struct sctp_bind_bucket *sctp_bucket_c 7437 static struct sctp_bind_bucket *sctp_bucket_create(
8719 struct sctp_bind_hashbucket *head, st 7438 struct sctp_bind_hashbucket *head, struct net *net, unsigned short snum)
8720 { 7439 {
8721 struct sctp_bind_bucket *pp; 7440 struct sctp_bind_bucket *pp;
8722 7441
8723 pp = kmem_cache_alloc(sctp_bucket_cac 7442 pp = kmem_cache_alloc(sctp_bucket_cachep, GFP_ATOMIC);
8724 if (pp) { 7443 if (pp) {
8725 SCTP_DBG_OBJCNT_INC(bind_buck 7444 SCTP_DBG_OBJCNT_INC(bind_bucket);
8726 pp->port = snum; 7445 pp->port = snum;
8727 pp->fastreuse = 0; 7446 pp->fastreuse = 0;
8728 INIT_HLIST_HEAD(&pp->owner); 7447 INIT_HLIST_HEAD(&pp->owner);
8729 pp->net = net; 7448 pp->net = net;
8730 hlist_add_head(&pp->node, &he 7449 hlist_add_head(&pp->node, &head->chain);
8731 } 7450 }
8732 return pp; 7451 return pp;
8733 } 7452 }
8734 7453
8735 /* Caller must hold hashbucket lock for this 7454 /* Caller must hold hashbucket lock for this tb with local BH disabled */
8736 static void sctp_bucket_destroy(struct sctp_b 7455 static void sctp_bucket_destroy(struct sctp_bind_bucket *pp)
8737 { 7456 {
8738 if (pp && hlist_empty(&pp->owner)) { 7457 if (pp && hlist_empty(&pp->owner)) {
8739 __hlist_del(&pp->node); 7458 __hlist_del(&pp->node);
8740 kmem_cache_free(sctp_bucket_c 7459 kmem_cache_free(sctp_bucket_cachep, pp);
8741 SCTP_DBG_OBJCNT_DEC(bind_buck 7460 SCTP_DBG_OBJCNT_DEC(bind_bucket);
8742 } 7461 }
8743 } 7462 }
8744 7463
8745 /* Release this socket's reference to a local 7464 /* Release this socket's reference to a local port. */
8746 static inline void __sctp_put_port(struct soc 7465 static inline void __sctp_put_port(struct sock *sk)
8747 { 7466 {
8748 struct sctp_bind_hashbucket *head = 7467 struct sctp_bind_hashbucket *head =
8749 &sctp_port_hashtable[sctp_pha 7468 &sctp_port_hashtable[sctp_phashfn(sock_net(sk),
8750 7469 inet_sk(sk)->inet_num)];
8751 struct sctp_bind_bucket *pp; 7470 struct sctp_bind_bucket *pp;
8752 7471
8753 spin_lock(&head->lock); 7472 spin_lock(&head->lock);
8754 pp = sctp_sk(sk)->bind_hash; 7473 pp = sctp_sk(sk)->bind_hash;
8755 __sk_del_bind_node(sk); 7474 __sk_del_bind_node(sk);
8756 sctp_sk(sk)->bind_hash = NULL; 7475 sctp_sk(sk)->bind_hash = NULL;
8757 inet_sk(sk)->inet_num = 0; 7476 inet_sk(sk)->inet_num = 0;
8758 sctp_bucket_destroy(pp); 7477 sctp_bucket_destroy(pp);
8759 spin_unlock(&head->lock); 7478 spin_unlock(&head->lock);
8760 } 7479 }
8761 7480
8762 void sctp_put_port(struct sock *sk) 7481 void sctp_put_port(struct sock *sk)
8763 { 7482 {
8764 local_bh_disable(); 7483 local_bh_disable();
8765 __sctp_put_port(sk); 7484 __sctp_put_port(sk);
8766 local_bh_enable(); 7485 local_bh_enable();
8767 } 7486 }
8768 7487
8769 /* 7488 /*
8770 * The system picks an ephemeral port and cho 7489 * The system picks an ephemeral port and choose an address set equivalent
8771 * to binding with a wildcard address. 7490 * to binding with a wildcard address.
8772 * One of those addresses will be the primary 7491 * One of those addresses will be the primary address for the association.
8773 * This automatically enables the multihoming 7492 * This automatically enables the multihoming capability of SCTP.
8774 */ 7493 */
8775 static int sctp_autobind(struct sock *sk) 7494 static int sctp_autobind(struct sock *sk)
8776 { 7495 {
8777 union sctp_addr autoaddr; 7496 union sctp_addr autoaddr;
8778 struct sctp_af *af; 7497 struct sctp_af *af;
8779 __be16 port; 7498 __be16 port;
8780 7499
8781 /* Initialize a local sockaddr struct 7500 /* Initialize a local sockaddr structure to INADDR_ANY. */
8782 af = sctp_sk(sk)->pf->af; 7501 af = sctp_sk(sk)->pf->af;
8783 7502
8784 port = htons(inet_sk(sk)->inet_num); 7503 port = htons(inet_sk(sk)->inet_num);
8785 af->inaddr_any(&autoaddr, port); 7504 af->inaddr_any(&autoaddr, port);
8786 7505
8787 return sctp_do_bind(sk, &autoaddr, af 7506 return sctp_do_bind(sk, &autoaddr, af->sockaddr_len);
8788 } 7507 }
8789 7508
8790 /* Parse out IPPROTO_SCTP CMSG headers. Perf 7509 /* Parse out IPPROTO_SCTP CMSG headers. Perform only minimal validation.
8791 * 7510 *
8792 * From RFC 2292 7511 * From RFC 2292
8793 * 4.2 The cmsghdr Structure * 7512 * 4.2 The cmsghdr Structure *
8794 * 7513 *
8795 * When ancillary data is sent or received, a 7514 * When ancillary data is sent or received, any number of ancillary data
8796 * objects can be specified by the msg_contro 7515 * objects can be specified by the msg_control and msg_controllen members of
8797 * the msghdr structure, because each object 7516 * the msghdr structure, because each object is preceded by
8798 * a cmsghdr structure defining the object's 7517 * a cmsghdr structure defining the object's length (the cmsg_len member).
8799 * Historically Berkeley-derived implementati 7518 * Historically Berkeley-derived implementations have passed only one object
8800 * at a time, but this API allows multiple ob 7519 * at a time, but this API allows multiple objects to be
8801 * passed in a single call to sendmsg() or re 7520 * passed in a single call to sendmsg() or recvmsg(). The following example
8802 * shows two ancillary data objects in a cont 7521 * shows two ancillary data objects in a control buffer.
8803 * 7522 *
8804 * |<--------------------------- msg_contro 7523 * |<--------------------------- msg_controllen -------------------------->|
8805 * | 7524 * | |
8806 * 7525 *
8807 * |<----- ancillary data object ----->|<-- 7526 * |<----- ancillary data object ----->|<----- ancillary data object ----->|
8808 * 7527 *
8809 * |<---------- CMSG_SPACE() --------->|<-- 7528 * |<---------- CMSG_SPACE() --------->|<---------- CMSG_SPACE() --------->|
8810 * | | 7529 * | | |
8811 * 7530 *
8812 * |<---------- cmsg_len ---------->| |<-- 7531 * |<---------- cmsg_len ---------->| |<--------- cmsg_len ----------->| |
8813 * 7532 *
8814 * |<--------- CMSG_LEN() --------->| |<-- 7533 * |<--------- CMSG_LEN() --------->| |<-------- CMSG_LEN() ---------->| |
8815 * | | | 7534 * | | | | |
8816 * 7535 *
8817 * +-----+-----+-----+--+-----------+--+--- 7536 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
8818 * |cmsg_|cmsg_|cmsg_|XX| |XX|cms 7537 * |cmsg_|cmsg_|cmsg_|XX| |XX|cmsg_|cmsg_|cmsg_|XX| |XX|
8819 * 7538 *
8820 * |len |level|type |XX|cmsg_data[]|XX|len 7539 * |len |level|type |XX|cmsg_data[]|XX|len |level|type |XX|cmsg_data[]|XX|
8821 * 7540 *
8822 * +-----+-----+-----+--+-----------+--+--- 7541 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
8823 * ^ 7542 * ^
8824 * | 7543 * |
8825 * 7544 *
8826 * msg_control 7545 * msg_control
8827 * points here 7546 * points here
8828 */ 7547 */
8829 static int sctp_msghdr_parse(const struct msg 7548 static int sctp_msghdr_parse(const struct msghdr *msg, struct sctp_cmsgs *cmsgs)
8830 { 7549 {
8831 struct msghdr *my_msg = (struct msghd 7550 struct msghdr *my_msg = (struct msghdr *)msg;
8832 struct cmsghdr *cmsg; 7551 struct cmsghdr *cmsg;
8833 7552
8834 for_each_cmsghdr(cmsg, my_msg) { 7553 for_each_cmsghdr(cmsg, my_msg) {
8835 if (!CMSG_OK(my_msg, cmsg)) 7554 if (!CMSG_OK(my_msg, cmsg))
8836 return -EINVAL; 7555 return -EINVAL;
8837 7556
8838 /* Should we parse this heade 7557 /* Should we parse this header or ignore? */
8839 if (cmsg->cmsg_level != IPPRO 7558 if (cmsg->cmsg_level != IPPROTO_SCTP)
8840 continue; 7559 continue;
8841 7560
8842 /* Strictly check lengths fol 7561 /* Strictly check lengths following example in SCM code. */
8843 switch (cmsg->cmsg_type) { 7562 switch (cmsg->cmsg_type) {
8844 case SCTP_INIT: 7563 case SCTP_INIT:
8845 /* SCTP Socket API Ex 7564 /* SCTP Socket API Extension
8846 * 5.3.1 SCTP Initiat 7565 * 5.3.1 SCTP Initiation Structure (SCTP_INIT)
8847 * 7566 *
8848 * This cmsghdr struc 7567 * This cmsghdr structure provides information for
8849 * initializing new S 7568 * initializing new SCTP associations with sendmsg().
8850 * The SCTP_INITMSG s 7569 * The SCTP_INITMSG socket option uses this same data
8851 * structure. This s 7570 * structure. This structure is not used for
8852 * recvmsg(). 7571 * recvmsg().
8853 * 7572 *
8854 * cmsg_level cmsg 7573 * cmsg_level cmsg_type cmsg_data[]
8855 * ------------ ---- 7574 * ------------ ------------ ----------------------
8856 * IPPROTO_SCTP SCTP 7575 * IPPROTO_SCTP SCTP_INIT struct sctp_initmsg
8857 */ 7576 */
8858 if (cmsg->cmsg_len != 7577 if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_initmsg)))
8859 return -EINVA 7578 return -EINVAL;
8860 7579
8861 cmsgs->init = CMSG_DA 7580 cmsgs->init = CMSG_DATA(cmsg);
8862 break; 7581 break;
8863 7582
8864 case SCTP_SNDRCV: 7583 case SCTP_SNDRCV:
8865 /* SCTP Socket API Ex 7584 /* SCTP Socket API Extension
8866 * 5.3.2 SCTP Header 7585 * 5.3.2 SCTP Header Information Structure(SCTP_SNDRCV)
8867 * 7586 *
8868 * This cmsghdr struc 7587 * This cmsghdr structure specifies SCTP options for
8869 * sendmsg() and desc 7588 * sendmsg() and describes SCTP header information
8870 * about a received m 7589 * about a received message through recvmsg().
8871 * 7590 *
8872 * cmsg_level cmsg 7591 * cmsg_level cmsg_type cmsg_data[]
8873 * ------------ ---- 7592 * ------------ ------------ ----------------------
8874 * IPPROTO_SCTP SCTP 7593 * IPPROTO_SCTP SCTP_SNDRCV struct sctp_sndrcvinfo
8875 */ 7594 */
8876 if (cmsg->cmsg_len != 7595 if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_sndrcvinfo)))
8877 return -EINVA 7596 return -EINVAL;
8878 7597
8879 cmsgs->srinfo = CMSG_ 7598 cmsgs->srinfo = CMSG_DATA(cmsg);
8880 7599
8881 if (cmsgs->srinfo->si 7600 if (cmsgs->srinfo->sinfo_flags &
8882 ~(SCTP_UNORDERED 7601 ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
8883 SCTP_SACK_IMMED !! 7602 SCTP_SACK_IMMEDIATELY | SCTP_PR_SCTP_MASK |
8884 SCTP_PR_SCTP_MA !! 7603 SCTP_ABORT | SCTP_EOF))
8885 return -EINVA 7604 return -EINVAL;
8886 break; 7605 break;
8887 7606
8888 case SCTP_SNDINFO: 7607 case SCTP_SNDINFO:
8889 /* SCTP Socket API Ex 7608 /* SCTP Socket API Extension
8890 * 5.3.4 SCTP Send In 7609 * 5.3.4 SCTP Send Information Structure (SCTP_SNDINFO)
8891 * 7610 *
8892 * This cmsghdr struc 7611 * This cmsghdr structure specifies SCTP options for
8893 * sendmsg(). This st 7612 * sendmsg(). This structure and SCTP_RCVINFO replaces
8894 * SCTP_SNDRCV which 7613 * SCTP_SNDRCV which has been deprecated.
8895 * 7614 *
8896 * cmsg_level cmsg 7615 * cmsg_level cmsg_type cmsg_data[]
8897 * ------------ ---- 7616 * ------------ ------------ ---------------------
8898 * IPPROTO_SCTP SCTP 7617 * IPPROTO_SCTP SCTP_SNDINFO struct sctp_sndinfo
8899 */ 7618 */
8900 if (cmsg->cmsg_len != 7619 if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_sndinfo)))
8901 return -EINVA 7620 return -EINVAL;
8902 7621
8903 cmsgs->sinfo = CMSG_D 7622 cmsgs->sinfo = CMSG_DATA(cmsg);
8904 7623
8905 if (cmsgs->sinfo->snd 7624 if (cmsgs->sinfo->snd_flags &
8906 ~(SCTP_UNORDERED 7625 ~(SCTP_UNORDERED | SCTP_ADDR_OVER |
8907 SCTP_SACK_IMMED !! 7626 SCTP_SACK_IMMEDIATELY | SCTP_PR_SCTP_MASK |
8908 SCTP_PR_SCTP_MA !! 7627 SCTP_ABORT | SCTP_EOF))
8909 return -EINVA 7628 return -EINVAL;
8910 break; 7629 break;
8911 case SCTP_PRINFO: <<
8912 /* SCTP Socket API Ex <<
8913 * 5.3.7 SCTP PR-SCTP <<
8914 * <<
8915 * This cmsghdr struc <<
8916 * <<
8917 * cmsg_level cmsg <<
8918 * ------------ ---- <<
8919 * IPPROTO_SCTP SCTP <<
8920 */ <<
8921 if (cmsg->cmsg_len != <<
8922 return -EINVA <<
8923 <<
8924 cmsgs->prinfo = CMSG_ <<
8925 if (cmsgs->prinfo->pr <<
8926 return -EINVA <<
8927 <<
8928 if (cmsgs->prinfo->pr <<
8929 cmsgs->prinfo <<
8930 break; <<
8931 case SCTP_AUTHINFO: <<
8932 /* SCTP Socket API Ex <<
8933 * 5.3.8 SCTP AUTH In <<
8934 * <<
8935 * This cmsghdr struc <<
8936 * <<
8937 * cmsg_level cmsg <<
8938 * ------------ ---- <<
8939 * IPPROTO_SCTP SCTP <<
8940 */ <<
8941 if (cmsg->cmsg_len != <<
8942 return -EINVA <<
8943 <<
8944 cmsgs->authinfo = CMS <<
8945 break; <<
8946 case SCTP_DSTADDRV4: <<
8947 case SCTP_DSTADDRV6: <<
8948 /* SCTP Socket API Ex <<
8949 * 5.3.9/10 SCTP Dest <<
8950 * <<
8951 * This cmsghdr struc <<
8952 * <<
8953 * cmsg_level cmsg <<
8954 * ------------ ---- <<
8955 * IPPROTO_SCTP SCTP <<
8956 * ------------ ---- <<
8957 * IPPROTO_SCTP SCTP <<
8958 */ <<
8959 cmsgs->addrs_msg = my <<
8960 break; <<
8961 default: 7630 default:
8962 return -EINVAL; 7631 return -EINVAL;
8963 } 7632 }
8964 } 7633 }
8965 7634
8966 return 0; 7635 return 0;
8967 } 7636 }
8968 7637
8969 /* 7638 /*
8970 * Wait for a packet.. 7639 * Wait for a packet..
8971 * Note: This function is the same function a 7640 * Note: This function is the same function as in core/datagram.c
8972 * with a few modifications to make lksctp wo 7641 * with a few modifications to make lksctp work.
8973 */ 7642 */
8974 static int sctp_wait_for_packet(struct sock * 7643 static int sctp_wait_for_packet(struct sock *sk, int *err, long *timeo_p)
8975 { 7644 {
8976 int error; 7645 int error;
8977 DEFINE_WAIT(wait); 7646 DEFINE_WAIT(wait);
8978 7647
8979 prepare_to_wait_exclusive(sk_sleep(sk 7648 prepare_to_wait_exclusive(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
8980 7649
8981 /* Socket errors? */ 7650 /* Socket errors? */
8982 error = sock_error(sk); 7651 error = sock_error(sk);
8983 if (error) 7652 if (error)
8984 goto out; 7653 goto out;
8985 7654
8986 if (!skb_queue_empty(&sk->sk_receive_ 7655 if (!skb_queue_empty(&sk->sk_receive_queue))
8987 goto ready; 7656 goto ready;
8988 7657
8989 /* Socket shut down? */ 7658 /* Socket shut down? */
8990 if (sk->sk_shutdown & RCV_SHUTDOWN) 7659 if (sk->sk_shutdown & RCV_SHUTDOWN)
8991 goto out; 7660 goto out;
8992 7661
8993 /* Sequenced packets can come disconn 7662 /* Sequenced packets can come disconnected. If so we report the
8994 * problem. 7663 * problem.
8995 */ 7664 */
8996 error = -ENOTCONN; 7665 error = -ENOTCONN;
8997 7666
8998 /* Is there a good reason to think th 7667 /* Is there a good reason to think that we may receive some data? */
8999 if (list_empty(&sctp_sk(sk)->ep->asoc 7668 if (list_empty(&sctp_sk(sk)->ep->asocs) && !sctp_sstate(sk, LISTENING))
9000 goto out; 7669 goto out;
9001 7670
9002 /* Handle signals. */ 7671 /* Handle signals. */
9003 if (signal_pending(current)) 7672 if (signal_pending(current))
9004 goto interrupted; 7673 goto interrupted;
9005 7674
9006 /* Let another process have a go. Si 7675 /* Let another process have a go. Since we are going to sleep
9007 * anyway. Note: This may cause odd 7676 * anyway. Note: This may cause odd behaviors if the message
9008 * does not fit in the user's buffer, 7677 * does not fit in the user's buffer, but this seems to be the
9009 * only way to honor MSG_DONTWAIT rea 7678 * only way to honor MSG_DONTWAIT realistically.
9010 */ 7679 */
9011 release_sock(sk); 7680 release_sock(sk);
9012 *timeo_p = schedule_timeout(*timeo_p) 7681 *timeo_p = schedule_timeout(*timeo_p);
9013 lock_sock(sk); 7682 lock_sock(sk);
9014 7683
9015 ready: 7684 ready:
9016 finish_wait(sk_sleep(sk), &wait); 7685 finish_wait(sk_sleep(sk), &wait);
9017 return 0; 7686 return 0;
9018 7687
9019 interrupted: 7688 interrupted:
9020 error = sock_intr_errno(*timeo_p); 7689 error = sock_intr_errno(*timeo_p);
9021 7690
9022 out: 7691 out:
9023 finish_wait(sk_sleep(sk), &wait); 7692 finish_wait(sk_sleep(sk), &wait);
9024 *err = error; 7693 *err = error;
9025 return error; 7694 return error;
9026 } 7695 }
9027 7696
9028 /* Receive a datagram. 7697 /* Receive a datagram.
9029 * Note: This is pretty much the same routine 7698 * Note: This is pretty much the same routine as in core/datagram.c
9030 * with a few changes to make lksctp work. 7699 * with a few changes to make lksctp work.
9031 */ 7700 */
9032 struct sk_buff *sctp_skb_recv_datagram(struct !! 7701 struct sk_buff *sctp_skb_recv_datagram(struct sock *sk, int flags,
>> 7702 int noblock, int *err)
9033 { 7703 {
9034 int error; 7704 int error;
9035 struct sk_buff *skb; 7705 struct sk_buff *skb;
9036 long timeo; 7706 long timeo;
9037 7707
9038 timeo = sock_rcvtimeo(sk, flags & MSG !! 7708 timeo = sock_rcvtimeo(sk, noblock);
9039 7709
9040 pr_debug("%s: timeo:%ld, max:%ld\n", 7710 pr_debug("%s: timeo:%ld, max:%ld\n", __func__, timeo,
9041 MAX_SCHEDULE_TIMEOUT); 7711 MAX_SCHEDULE_TIMEOUT);
9042 7712
9043 do { 7713 do {
9044 /* Again only user level code 7714 /* Again only user level code calls this function,
9045 * so nothing interrupt level 7715 * so nothing interrupt level
9046 * will suddenly eat the rece 7716 * will suddenly eat the receive_queue.
9047 * 7717 *
9048 * Look at current nfs clien 7718 * Look at current nfs client by the way...
9049 * However, this function wa 7719 * However, this function was correct in any case. 8)
9050 */ 7720 */
9051 if (flags & MSG_PEEK) { 7721 if (flags & MSG_PEEK) {
9052 skb = skb_peek(&sk->s 7722 skb = skb_peek(&sk->sk_receive_queue);
9053 if (skb) 7723 if (skb)
9054 refcount_inc( 7724 refcount_inc(&skb->users);
9055 } else { 7725 } else {
9056 skb = __skb_dequeue(& 7726 skb = __skb_dequeue(&sk->sk_receive_queue);
9057 } 7727 }
9058 7728
9059 if (skb) 7729 if (skb)
9060 return skb; 7730 return skb;
9061 7731
9062 /* Caller is allowed not to c 7732 /* Caller is allowed not to check sk->sk_err before calling. */
9063 error = sock_error(sk); 7733 error = sock_error(sk);
9064 if (error) 7734 if (error)
9065 goto no_packet; 7735 goto no_packet;
9066 7736
9067 if (sk->sk_shutdown & RCV_SHU 7737 if (sk->sk_shutdown & RCV_SHUTDOWN)
9068 break; 7738 break;
9069 7739
>> 7740 if (sk_can_busy_loop(sk)) {
>> 7741 sk_busy_loop(sk, noblock);
>> 7742
>> 7743 if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
>> 7744 continue;
>> 7745 }
9070 7746
9071 /* User doesn't want to wait. 7747 /* User doesn't want to wait. */
9072 error = -EAGAIN; 7748 error = -EAGAIN;
9073 if (!timeo) 7749 if (!timeo)
9074 goto no_packet; 7750 goto no_packet;
9075 } while (sctp_wait_for_packet(sk, err 7751 } while (sctp_wait_for_packet(sk, err, &timeo) == 0);
9076 7752
9077 return NULL; 7753 return NULL;
9078 7754
9079 no_packet: 7755 no_packet:
9080 *err = error; 7756 *err = error;
9081 return NULL; 7757 return NULL;
9082 } 7758 }
9083 7759
9084 /* If sndbuf has changed, wake up per associa 7760 /* If sndbuf has changed, wake up per association sndbuf waiters. */
9085 static void __sctp_write_space(struct sctp_as 7761 static void __sctp_write_space(struct sctp_association *asoc)
9086 { 7762 {
9087 struct sock *sk = asoc->base.sk; 7763 struct sock *sk = asoc->base.sk;
9088 7764
9089 if (sctp_wspace(asoc) <= 0) 7765 if (sctp_wspace(asoc) <= 0)
9090 return; 7766 return;
9091 7767
9092 if (waitqueue_active(&asoc->wait)) 7768 if (waitqueue_active(&asoc->wait))
9093 wake_up_interruptible(&asoc-> 7769 wake_up_interruptible(&asoc->wait);
9094 7770
9095 if (sctp_writeable(sk)) { 7771 if (sctp_writeable(sk)) {
9096 struct socket_wq *wq; 7772 struct socket_wq *wq;
9097 7773
9098 rcu_read_lock(); 7774 rcu_read_lock();
9099 wq = rcu_dereference(sk->sk_w 7775 wq = rcu_dereference(sk->sk_wq);
9100 if (wq) { 7776 if (wq) {
9101 if (waitqueue_active( 7777 if (waitqueue_active(&wq->wait))
9102 wake_up_inter 7778 wake_up_interruptible(&wq->wait);
9103 7779
9104 /* Note that we try t 7780 /* Note that we try to include the Async I/O support
9105 * here by modeling f 7781 * here by modeling from the current TCP/UDP code.
9106 * We have not tested 7782 * We have not tested with it yet.
9107 */ 7783 */
9108 if (!(sk->sk_shutdown 7784 if (!(sk->sk_shutdown & SEND_SHUTDOWN))
9109 sock_wake_asy 7785 sock_wake_async(wq, SOCK_WAKE_SPACE, POLL_OUT);
9110 } 7786 }
9111 rcu_read_unlock(); 7787 rcu_read_unlock();
9112 } 7788 }
9113 } 7789 }
9114 7790
9115 static void sctp_wake_up_waiters(struct sock 7791 static void sctp_wake_up_waiters(struct sock *sk,
9116 struct sctp_ 7792 struct sctp_association *asoc)
9117 { 7793 {
9118 struct sctp_association *tmp = asoc; 7794 struct sctp_association *tmp = asoc;
9119 7795
9120 /* We do accounting for the sndbuf sp 7796 /* We do accounting for the sndbuf space per association,
9121 * so we only need to wake our own as 7797 * so we only need to wake our own association.
9122 */ 7798 */
9123 if (asoc->ep->sndbuf_policy) 7799 if (asoc->ep->sndbuf_policy)
9124 return __sctp_write_space(aso 7800 return __sctp_write_space(asoc);
9125 7801
9126 /* If association goes down and is ju 7802 /* If association goes down and is just flushing its
9127 * outq, then just normally notify ot 7803 * outq, then just normally notify others.
9128 */ 7804 */
9129 if (asoc->base.dead) 7805 if (asoc->base.dead)
9130 return sctp_write_space(sk); 7806 return sctp_write_space(sk);
9131 7807
9132 /* Accounting for the sndbuf space is 7808 /* Accounting for the sndbuf space is per socket, so we
9133 * need to wake up others, try to be 7809 * need to wake up others, try to be fair and in case of
9134 * other associations, let them have 7810 * other associations, let them have a go first instead
9135 * of just doing a sctp_write_space() 7811 * of just doing a sctp_write_space() call.
9136 * 7812 *
9137 * Note that we reach sctp_wake_up_wa 7813 * Note that we reach sctp_wake_up_waiters() only when
9138 * associations free up queued chunks 7814 * associations free up queued chunks, thus we are under
9139 * lock and the list of associations 7815 * lock and the list of associations on a socket is
9140 * guaranteed not to change. 7816 * guaranteed not to change.
9141 */ 7817 */
9142 for (tmp = list_next_entry(tmp, asocs 7818 for (tmp = list_next_entry(tmp, asocs); 1;
9143 tmp = list_next_entry(tmp, asocs 7819 tmp = list_next_entry(tmp, asocs)) {
9144 /* Manually skip the head ele 7820 /* Manually skip the head element. */
9145 if (&tmp->asocs == &((sctp_sk 7821 if (&tmp->asocs == &((sctp_sk(sk))->ep->asocs))
9146 continue; 7822 continue;
9147 /* Wake up association. */ 7823 /* Wake up association. */
9148 __sctp_write_space(tmp); 7824 __sctp_write_space(tmp);
9149 /* We've reached the end. */ 7825 /* We've reached the end. */
9150 if (tmp == asoc) 7826 if (tmp == asoc)
9151 break; 7827 break;
9152 } 7828 }
9153 } 7829 }
9154 7830
9155 /* Do accounting for the sndbuf space. 7831 /* Do accounting for the sndbuf space.
9156 * Decrement the used sndbuf space of the cor 7832 * Decrement the used sndbuf space of the corresponding association by the
9157 * data size which was just transmitted(freed 7833 * data size which was just transmitted(freed).
9158 */ 7834 */
9159 static void sctp_wfree(struct sk_buff *skb) 7835 static void sctp_wfree(struct sk_buff *skb)
9160 { 7836 {
9161 struct sctp_chunk *chunk = skb_shinfo 7837 struct sctp_chunk *chunk = skb_shinfo(skb)->destructor_arg;
9162 struct sctp_association *asoc = chunk 7838 struct sctp_association *asoc = chunk->asoc;
9163 struct sock *sk = asoc->base.sk; 7839 struct sock *sk = asoc->base.sk;
9164 7840
>> 7841 asoc->sndbuf_used -= SCTP_DATA_SNDSIZE(chunk) +
>> 7842 sizeof(struct sk_buff) +
>> 7843 sizeof(struct sctp_chunk);
>> 7844
>> 7845 WARN_ON(refcount_sub_and_test(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc));
>> 7846
>> 7847 /*
>> 7848 * This undoes what is done via sctp_set_owner_w and sk_mem_charge
>> 7849 */
>> 7850 sk->sk_wmem_queued -= skb->truesize;
9165 sk_mem_uncharge(sk, skb->truesize); 7851 sk_mem_uncharge(sk, skb->truesize);
9166 sk_wmem_queued_add(sk, -(skb->truesiz <<
9167 asoc->sndbuf_used -= skb->truesize + <<
9168 WARN_ON(refcount_sub_and_test(sizeof( <<
9169 &sk->sk <<
9170 <<
9171 if (chunk->shkey) { <<
9172 struct sctp_shared_key *shkey <<
9173 <<
9174 /* refcnt == 2 and !list_empt <<
9175 * not being used anywhere, a <<
9176 * that this shkey can be fre <<
9177 */ <<
9178 if (shkey->deactivated && !li <<
9179 refcount_read(&shkey->ref <<
9180 struct sctp_ulpevent <<
9181 <<
9182 ev = sctp_ulpevent_ma <<
9183 <<
9184 <<
9185 if (ev) <<
9186 asoc->stream. <<
9187 } <<
9188 sctp_auth_shkey_release(chunk <<
9189 } <<
9190 7852
9191 sock_wfree(skb); 7853 sock_wfree(skb);
9192 sctp_wake_up_waiters(sk, asoc); 7854 sctp_wake_up_waiters(sk, asoc);
9193 7855
9194 sctp_association_put(asoc); 7856 sctp_association_put(asoc);
9195 } 7857 }
9196 7858
9197 /* Do accounting for the receive space on the 7859 /* Do accounting for the receive space on the socket.
9198 * Accounting for the association is done in 7860 * Accounting for the association is done in ulpevent.c
9199 * We set this as a destructor for the cloned 7861 * We set this as a destructor for the cloned data skbs so that
9200 * accounting is done at the correct time. 7862 * accounting is done at the correct time.
9201 */ 7863 */
9202 void sctp_sock_rfree(struct sk_buff *skb) 7864 void sctp_sock_rfree(struct sk_buff *skb)
9203 { 7865 {
9204 struct sock *sk = skb->sk; 7866 struct sock *sk = skb->sk;
9205 struct sctp_ulpevent *event = sctp_sk 7867 struct sctp_ulpevent *event = sctp_skb2event(skb);
9206 7868
9207 atomic_sub(event->rmem_len, &sk->sk_r 7869 atomic_sub(event->rmem_len, &sk->sk_rmem_alloc);
9208 7870
9209 /* 7871 /*
9210 * Mimic the behavior of sock_rfree 7872 * Mimic the behavior of sock_rfree
9211 */ 7873 */
9212 sk_mem_uncharge(sk, event->rmem_len); 7874 sk_mem_uncharge(sk, event->rmem_len);
9213 } 7875 }
9214 7876
9215 7877
9216 /* Helper function to wait for space in the s 7878 /* Helper function to wait for space in the sndbuf. */
9217 static int sctp_wait_for_sndbuf(struct sctp_a 7879 static int sctp_wait_for_sndbuf(struct sctp_association *asoc, long *timeo_p,
9218 size_t msg_le 7880 size_t msg_len)
9219 { 7881 {
9220 struct sock *sk = asoc->base.sk; 7882 struct sock *sk = asoc->base.sk;
9221 long current_timeo = *timeo_p; 7883 long current_timeo = *timeo_p;
9222 DEFINE_WAIT(wait); 7884 DEFINE_WAIT(wait);
9223 int err = 0; 7885 int err = 0;
9224 7886
9225 pr_debug("%s: asoc:%p, timeo:%ld, msg 7887 pr_debug("%s: asoc:%p, timeo:%ld, msg_len:%zu\n", __func__, asoc,
9226 *timeo_p, msg_len); 7888 *timeo_p, msg_len);
9227 7889
9228 /* Increment the association's refcnt 7890 /* Increment the association's refcnt. */
9229 sctp_association_hold(asoc); 7891 sctp_association_hold(asoc);
9230 7892
9231 /* Wait on the association specific s 7893 /* Wait on the association specific sndbuf space. */
9232 for (;;) { 7894 for (;;) {
9233 prepare_to_wait_exclusive(&as 7895 prepare_to_wait_exclusive(&asoc->wait, &wait,
9234 TAS 7896 TASK_INTERRUPTIBLE);
9235 if (asoc->base.dead) 7897 if (asoc->base.dead)
9236 goto do_dead; 7898 goto do_dead;
9237 if (!*timeo_p) 7899 if (!*timeo_p)
9238 goto do_nonblock; 7900 goto do_nonblock;
9239 if (sk->sk_err || asoc->state 7901 if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING)
9240 goto do_error; 7902 goto do_error;
9241 if (signal_pending(current)) 7903 if (signal_pending(current))
9242 goto do_interrupted; 7904 goto do_interrupted;
9243 if ((int)msg_len <= sctp_wspa !! 7905 if (msg_len <= sctp_wspace(asoc))
9244 sk_wmem_schedule(sk, msg_ <<
9245 break; 7906 break;
9246 7907
9247 /* Let another process have a 7908 /* Let another process have a go. Since we are going
9248 * to sleep anyway. 7909 * to sleep anyway.
9249 */ 7910 */
9250 release_sock(sk); 7911 release_sock(sk);
9251 current_timeo = schedule_time 7912 current_timeo = schedule_timeout(current_timeo);
9252 lock_sock(sk); 7913 lock_sock(sk);
9253 if (sk != asoc->base.sk) 7914 if (sk != asoc->base.sk)
9254 goto do_error; 7915 goto do_error;
9255 7916
9256 *timeo_p = current_timeo; 7917 *timeo_p = current_timeo;
9257 } 7918 }
9258 7919
9259 out: 7920 out:
9260 finish_wait(&asoc->wait, &wait); 7921 finish_wait(&asoc->wait, &wait);
9261 7922
9262 /* Release the association's refcnt. 7923 /* Release the association's refcnt. */
9263 sctp_association_put(asoc); 7924 sctp_association_put(asoc);
9264 7925
9265 return err; 7926 return err;
9266 7927
9267 do_dead: 7928 do_dead:
9268 err = -ESRCH; 7929 err = -ESRCH;
9269 goto out; 7930 goto out;
9270 7931
9271 do_error: 7932 do_error:
9272 err = -EPIPE; 7933 err = -EPIPE;
9273 goto out; 7934 goto out;
9274 7935
9275 do_interrupted: 7936 do_interrupted:
9276 err = sock_intr_errno(*timeo_p); 7937 err = sock_intr_errno(*timeo_p);
9277 goto out; 7938 goto out;
9278 7939
9279 do_nonblock: 7940 do_nonblock:
9280 err = -EAGAIN; 7941 err = -EAGAIN;
9281 goto out; 7942 goto out;
9282 } 7943 }
9283 7944
9284 void sctp_data_ready(struct sock *sk) 7945 void sctp_data_ready(struct sock *sk)
9285 { 7946 {
9286 struct socket_wq *wq; 7947 struct socket_wq *wq;
9287 7948
9288 trace_sk_data_ready(sk); <<
9289 <<
9290 rcu_read_lock(); 7949 rcu_read_lock();
9291 wq = rcu_dereference(sk->sk_wq); 7950 wq = rcu_dereference(sk->sk_wq);
9292 if (skwq_has_sleeper(wq)) 7951 if (skwq_has_sleeper(wq))
9293 wake_up_interruptible_sync_po !! 7952 wake_up_interruptible_sync_poll(&wq->wait, POLLIN |
9294 !! 7953 POLLRDNORM | POLLRDBAND);
9295 sk_wake_async_rcu(sk, SOCK_WAKE_WAITD !! 7954 sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
9296 rcu_read_unlock(); 7955 rcu_read_unlock();
9297 } 7956 }
9298 7957
9299 /* If socket sndbuf has changed, wake up all 7958 /* If socket sndbuf has changed, wake up all per association waiters. */
9300 void sctp_write_space(struct sock *sk) 7959 void sctp_write_space(struct sock *sk)
9301 { 7960 {
9302 struct sctp_association *asoc; 7961 struct sctp_association *asoc;
9303 7962
9304 /* Wake up the tasks in each wait que 7963 /* Wake up the tasks in each wait queue. */
9305 list_for_each_entry(asoc, &((sctp_sk( 7964 list_for_each_entry(asoc, &((sctp_sk(sk))->ep->asocs), asocs) {
9306 __sctp_write_space(asoc); 7965 __sctp_write_space(asoc);
9307 } 7966 }
9308 } 7967 }
9309 7968
9310 /* Is there any sndbuf space available on the 7969 /* Is there any sndbuf space available on the socket?
9311 * 7970 *
9312 * Note that sk_wmem_alloc is the sum of the 7971 * Note that sk_wmem_alloc is the sum of the send buffers on all of the
9313 * associations on the same socket. For a UD 7972 * associations on the same socket. For a UDP-style socket with
9314 * multiple associations, it is possible for 7973 * multiple associations, it is possible for it to be "unwriteable"
9315 * prematurely. I assume that this is accept 7974 * prematurely. I assume that this is acceptable because
9316 * a premature "unwriteable" is better than a 7975 * a premature "unwriteable" is better than an accidental "writeable" which
9317 * would cause an unwanted block under certai 7976 * would cause an unwanted block under certain circumstances. For the 1-1
9318 * UDP-style sockets or TCP-style sockets, th 7977 * UDP-style sockets or TCP-style sockets, this code should work.
9319 * - Daisy 7978 * - Daisy
9320 */ 7979 */
9321 static bool sctp_writeable(const struct sock !! 7980 static int sctp_writeable(struct sock *sk)
9322 { 7981 {
9323 return READ_ONCE(sk->sk_sndbuf) > REA !! 7982 int amt = 0;
>> 7983
>> 7984 amt = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
>> 7985 if (amt < 0)
>> 7986 amt = 0;
>> 7987 return amt;
9324 } 7988 }
9325 7989
9326 /* Wait for an association to go into ESTABLI 7990 /* Wait for an association to go into ESTABLISHED state. If timeout is 0,
9327 * returns immediately with EINPROGRESS. 7991 * returns immediately with EINPROGRESS.
9328 */ 7992 */
9329 static int sctp_wait_for_connect(struct sctp_ 7993 static int sctp_wait_for_connect(struct sctp_association *asoc, long *timeo_p)
9330 { 7994 {
9331 struct sock *sk = asoc->base.sk; 7995 struct sock *sk = asoc->base.sk;
9332 int err = 0; 7996 int err = 0;
9333 long current_timeo = *timeo_p; 7997 long current_timeo = *timeo_p;
9334 DEFINE_WAIT(wait); 7998 DEFINE_WAIT(wait);
9335 7999
9336 pr_debug("%s: asoc:%p, timeo:%ld\n", 8000 pr_debug("%s: asoc:%p, timeo:%ld\n", __func__, asoc, *timeo_p);
9337 8001
9338 /* Increment the association's refcnt 8002 /* Increment the association's refcnt. */
9339 sctp_association_hold(asoc); 8003 sctp_association_hold(asoc);
9340 8004
9341 for (;;) { 8005 for (;;) {
9342 prepare_to_wait_exclusive(&as 8006 prepare_to_wait_exclusive(&asoc->wait, &wait,
9343 TAS 8007 TASK_INTERRUPTIBLE);
9344 if (!*timeo_p) 8008 if (!*timeo_p)
9345 goto do_nonblock; 8009 goto do_nonblock;
9346 if (sk->sk_shutdown & RCV_SHU 8010 if (sk->sk_shutdown & RCV_SHUTDOWN)
9347 break; 8011 break;
9348 if (sk->sk_err || asoc->state 8012 if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING ||
9349 asoc->base.dead) 8013 asoc->base.dead)
9350 goto do_error; 8014 goto do_error;
9351 if (signal_pending(current)) 8015 if (signal_pending(current))
9352 goto do_interrupted; 8016 goto do_interrupted;
9353 8017
9354 if (sctp_state(asoc, ESTABLIS 8018 if (sctp_state(asoc, ESTABLISHED))
9355 break; 8019 break;
9356 8020
9357 /* Let another process have a 8021 /* Let another process have a go. Since we are going
9358 * to sleep anyway. 8022 * to sleep anyway.
9359 */ 8023 */
9360 release_sock(sk); 8024 release_sock(sk);
9361 current_timeo = schedule_time 8025 current_timeo = schedule_timeout(current_timeo);
9362 lock_sock(sk); 8026 lock_sock(sk);
9363 8027
9364 *timeo_p = current_timeo; 8028 *timeo_p = current_timeo;
9365 } 8029 }
9366 8030
9367 out: 8031 out:
9368 finish_wait(&asoc->wait, &wait); 8032 finish_wait(&asoc->wait, &wait);
9369 8033
9370 /* Release the association's refcnt. 8034 /* Release the association's refcnt. */
9371 sctp_association_put(asoc); 8035 sctp_association_put(asoc);
9372 8036
9373 return err; 8037 return err;
9374 8038
9375 do_error: 8039 do_error:
9376 if (asoc->init_err_counter + 1 > asoc 8040 if (asoc->init_err_counter + 1 > asoc->max_init_attempts)
9377 err = -ETIMEDOUT; 8041 err = -ETIMEDOUT;
9378 else 8042 else
9379 err = -ECONNREFUSED; 8043 err = -ECONNREFUSED;
9380 goto out; 8044 goto out;
9381 8045
9382 do_interrupted: 8046 do_interrupted:
9383 err = sock_intr_errno(*timeo_p); 8047 err = sock_intr_errno(*timeo_p);
9384 goto out; 8048 goto out;
9385 8049
9386 do_nonblock: 8050 do_nonblock:
9387 err = -EINPROGRESS; 8051 err = -EINPROGRESS;
9388 goto out; 8052 goto out;
9389 } 8053 }
9390 8054
9391 static int sctp_wait_for_accept(struct sock * 8055 static int sctp_wait_for_accept(struct sock *sk, long timeo)
9392 { 8056 {
9393 struct sctp_endpoint *ep; 8057 struct sctp_endpoint *ep;
9394 int err = 0; 8058 int err = 0;
9395 DEFINE_WAIT(wait); 8059 DEFINE_WAIT(wait);
9396 8060
9397 ep = sctp_sk(sk)->ep; 8061 ep = sctp_sk(sk)->ep;
9398 8062
9399 8063
9400 for (;;) { 8064 for (;;) {
9401 prepare_to_wait_exclusive(sk_ 8065 prepare_to_wait_exclusive(sk_sleep(sk), &wait,
9402 TAS 8066 TASK_INTERRUPTIBLE);
9403 8067
9404 if (list_empty(&ep->asocs)) { 8068 if (list_empty(&ep->asocs)) {
9405 release_sock(sk); 8069 release_sock(sk);
9406 timeo = schedule_time 8070 timeo = schedule_timeout(timeo);
9407 lock_sock(sk); 8071 lock_sock(sk);
9408 } 8072 }
9409 8073
9410 err = -EINVAL; 8074 err = -EINVAL;
9411 if (!sctp_sstate(sk, LISTENIN !! 8075 if (!sctp_sstate(sk, LISTENING))
9412 (sk->sk_shutdown & RCV_SH <<
9413 break; 8076 break;
9414 8077
9415 err = 0; 8078 err = 0;
9416 if (!list_empty(&ep->asocs)) 8079 if (!list_empty(&ep->asocs))
9417 break; 8080 break;
9418 8081
9419 err = sock_intr_errno(timeo); 8082 err = sock_intr_errno(timeo);
9420 if (signal_pending(current)) 8083 if (signal_pending(current))
9421 break; 8084 break;
9422 8085
9423 err = -EAGAIN; 8086 err = -EAGAIN;
9424 if (!timeo) 8087 if (!timeo)
9425 break; 8088 break;
9426 } 8089 }
9427 8090
9428 finish_wait(sk_sleep(sk), &wait); 8091 finish_wait(sk_sleep(sk), &wait);
9429 8092
9430 return err; 8093 return err;
9431 } 8094 }
9432 8095
9433 static void sctp_wait_for_close(struct sock * 8096 static void sctp_wait_for_close(struct sock *sk, long timeout)
9434 { 8097 {
9435 DEFINE_WAIT(wait); 8098 DEFINE_WAIT(wait);
9436 8099
9437 do { 8100 do {
9438 prepare_to_wait(sk_sleep(sk), 8101 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
9439 if (list_empty(&sctp_sk(sk)-> 8102 if (list_empty(&sctp_sk(sk)->ep->asocs))
9440 break; 8103 break;
9441 release_sock(sk); 8104 release_sock(sk);
9442 timeout = schedule_timeout(ti 8105 timeout = schedule_timeout(timeout);
9443 lock_sock(sk); 8106 lock_sock(sk);
9444 } while (!signal_pending(current) && 8107 } while (!signal_pending(current) && timeout);
9445 8108
9446 finish_wait(sk_sleep(sk), &wait); 8109 finish_wait(sk_sleep(sk), &wait);
9447 } 8110 }
9448 8111
9449 static void sctp_skb_set_owner_r_frag(struct 8112 static void sctp_skb_set_owner_r_frag(struct sk_buff *skb, struct sock *sk)
9450 { 8113 {
9451 struct sk_buff *frag; 8114 struct sk_buff *frag;
9452 8115
9453 if (!skb->data_len) 8116 if (!skb->data_len)
9454 goto done; 8117 goto done;
9455 8118
9456 /* Don't forget the fragments. */ 8119 /* Don't forget the fragments. */
9457 skb_walk_frags(skb, frag) 8120 skb_walk_frags(skb, frag)
9458 sctp_skb_set_owner_r_frag(fra 8121 sctp_skb_set_owner_r_frag(frag, sk);
9459 8122
9460 done: 8123 done:
9461 sctp_skb_set_owner_r(skb, sk); 8124 sctp_skb_set_owner_r(skb, sk);
9462 } 8125 }
9463 8126
9464 void sctp_copy_sock(struct sock *newsk, struc 8127 void sctp_copy_sock(struct sock *newsk, struct sock *sk,
9465 struct sctp_association * 8128 struct sctp_association *asoc)
9466 { 8129 {
9467 struct inet_sock *inet = inet_sk(sk); 8130 struct inet_sock *inet = inet_sk(sk);
9468 struct inet_sock *newinet; 8131 struct inet_sock *newinet;
9469 struct sctp_sock *sp = sctp_sk(sk); <<
9470 8132
9471 newsk->sk_type = sk->sk_type; 8133 newsk->sk_type = sk->sk_type;
9472 newsk->sk_bound_dev_if = sk->sk_bound 8134 newsk->sk_bound_dev_if = sk->sk_bound_dev_if;
9473 newsk->sk_flags = sk->sk_flags; 8135 newsk->sk_flags = sk->sk_flags;
9474 newsk->sk_tsflags = sk->sk_tsflags; 8136 newsk->sk_tsflags = sk->sk_tsflags;
9475 newsk->sk_no_check_tx = sk->sk_no_che 8137 newsk->sk_no_check_tx = sk->sk_no_check_tx;
9476 newsk->sk_no_check_rx = sk->sk_no_che 8138 newsk->sk_no_check_rx = sk->sk_no_check_rx;
9477 newsk->sk_reuse = sk->sk_reuse; 8139 newsk->sk_reuse = sk->sk_reuse;
9478 sctp_sk(newsk)->reuse = sp->reuse; <<
9479 8140
9480 newsk->sk_shutdown = sk->sk_shutdown; 8141 newsk->sk_shutdown = sk->sk_shutdown;
9481 newsk->sk_destruct = sk->sk_destruct; 8142 newsk->sk_destruct = sk->sk_destruct;
9482 newsk->sk_family = sk->sk_family; 8143 newsk->sk_family = sk->sk_family;
9483 newsk->sk_protocol = IPPROTO_SCTP; 8144 newsk->sk_protocol = IPPROTO_SCTP;
9484 newsk->sk_backlog_rcv = sk->sk_prot-> 8145 newsk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
9485 newsk->sk_sndbuf = sk->sk_sndbuf; 8146 newsk->sk_sndbuf = sk->sk_sndbuf;
9486 newsk->sk_rcvbuf = sk->sk_rcvbuf; 8147 newsk->sk_rcvbuf = sk->sk_rcvbuf;
9487 newsk->sk_lingertime = sk->sk_lingert 8148 newsk->sk_lingertime = sk->sk_lingertime;
9488 newsk->sk_rcvtimeo = sk->sk_rcvtimeo; 8149 newsk->sk_rcvtimeo = sk->sk_rcvtimeo;
9489 newsk->sk_sndtimeo = sk->sk_sndtimeo; 8150 newsk->sk_sndtimeo = sk->sk_sndtimeo;
9490 newsk->sk_rxhash = sk->sk_rxhash; 8151 newsk->sk_rxhash = sk->sk_rxhash;
9491 8152
9492 newinet = inet_sk(newsk); 8153 newinet = inet_sk(newsk);
9493 8154
9494 /* Initialize sk's sport, dport, rcv_ 8155 /* Initialize sk's sport, dport, rcv_saddr and daddr for
9495 * getsockname() and getpeername() 8156 * getsockname() and getpeername()
9496 */ 8157 */
9497 newinet->inet_sport = inet->inet_spor 8158 newinet->inet_sport = inet->inet_sport;
9498 newinet->inet_saddr = inet->inet_sadd 8159 newinet->inet_saddr = inet->inet_saddr;
9499 newinet->inet_rcv_saddr = inet->inet_ 8160 newinet->inet_rcv_saddr = inet->inet_rcv_saddr;
9500 newinet->inet_dport = htons(asoc->pee 8161 newinet->inet_dport = htons(asoc->peer.port);
9501 newinet->pmtudisc = inet->pmtudisc; 8162 newinet->pmtudisc = inet->pmtudisc;
9502 atomic_set(&newinet->inet_id, get_ran !! 8163 newinet->inet_id = prandom_u32();
9503 8164
9504 newinet->uc_ttl = inet->uc_ttl; 8165 newinet->uc_ttl = inet->uc_ttl;
9505 inet_set_bit(MC_LOOP, newsk); !! 8166 newinet->mc_loop = 1;
9506 newinet->mc_ttl = 1; 8167 newinet->mc_ttl = 1;
9507 newinet->mc_index = 0; 8168 newinet->mc_index = 0;
9508 newinet->mc_list = NULL; 8169 newinet->mc_list = NULL;
9509 8170
9510 if (newsk->sk_flags & SK_FLAGS_TIMEST 8171 if (newsk->sk_flags & SK_FLAGS_TIMESTAMP)
9511 net_enable_timestamp(); 8172 net_enable_timestamp();
9512 8173
9513 /* Set newsk security attributes from !! 8174 security_sk_clone(sk, newsk);
9514 * security attribute from asoc. <<
9515 */ <<
9516 security_sctp_sk_clone(asoc, sk, news <<
9517 } 8175 }
9518 8176
9519 static inline void sctp_copy_descendant(struc 8177 static inline void sctp_copy_descendant(struct sock *sk_to,
9520 const 8178 const struct sock *sk_from)
9521 { 8179 {
9522 size_t ancestor_size = sizeof(struct !! 8180 int ancestor_size = sizeof(struct inet_sock) +
>> 8181 sizeof(struct sctp_sock) -
>> 8182 offsetof(struct sctp_sock, auto_asconf_list);
>> 8183
>> 8184 if (sk_from->sk_family == PF_INET6)
>> 8185 ancestor_size += sizeof(struct ipv6_pinfo);
9523 8186
9524 ancestor_size += sk_from->sk_prot->ob <<
9525 ancestor_size -= offsetof(struct sctp <<
9526 __inet_sk_copy_descendant(sk_to, sk_f 8187 __inet_sk_copy_descendant(sk_to, sk_from, ancestor_size);
9527 } 8188 }
9528 8189
9529 /* Populate the fields of the newsk from the 8190 /* Populate the fields of the newsk from the oldsk and migrate the assoc
9530 * and its messages to the newsk. 8191 * and its messages to the newsk.
9531 */ 8192 */
9532 static int sctp_sock_migrate(struct sock *old !! 8193 static void sctp_sock_migrate(struct sock *oldsk, struct sock *newsk,
9533 struct sctp_asso !! 8194 struct sctp_association *assoc,
9534 enum sctp_socket !! 8195 enum sctp_socket_type type)
9535 { 8196 {
9536 struct sctp_sock *oldsp = sctp_sk(old 8197 struct sctp_sock *oldsp = sctp_sk(oldsk);
9537 struct sctp_sock *newsp = sctp_sk(new 8198 struct sctp_sock *newsp = sctp_sk(newsk);
9538 struct sctp_bind_bucket *pp; /* hash 8199 struct sctp_bind_bucket *pp; /* hash list port iterator */
9539 struct sctp_endpoint *newep = newsp-> 8200 struct sctp_endpoint *newep = newsp->ep;
9540 struct sk_buff *skb, *tmp; 8201 struct sk_buff *skb, *tmp;
9541 struct sctp_ulpevent *event; 8202 struct sctp_ulpevent *event;
9542 struct sctp_bind_hashbucket *head; 8203 struct sctp_bind_hashbucket *head;
9543 int err; <<
9544 8204
9545 /* Migrate socket buffer sizes and al 8205 /* Migrate socket buffer sizes and all the socket level options to the
9546 * new socket. 8206 * new socket.
9547 */ 8207 */
9548 newsk->sk_sndbuf = oldsk->sk_sndbuf; 8208 newsk->sk_sndbuf = oldsk->sk_sndbuf;
9549 newsk->sk_rcvbuf = oldsk->sk_rcvbuf; 8209 newsk->sk_rcvbuf = oldsk->sk_rcvbuf;
9550 /* Brute force copy old sctp opt. */ 8210 /* Brute force copy old sctp opt. */
9551 sctp_copy_descendant(newsk, oldsk); 8211 sctp_copy_descendant(newsk, oldsk);
9552 8212
9553 /* Restore the ep value that was over 8213 /* Restore the ep value that was overwritten with the above structure
9554 * copy. 8214 * copy.
9555 */ 8215 */
9556 newsp->ep = newep; 8216 newsp->ep = newep;
9557 newsp->hmac = NULL; 8217 newsp->hmac = NULL;
9558 8218
9559 /* Hook this new socket in to the bin 8219 /* Hook this new socket in to the bind_hash list. */
9560 head = &sctp_port_hashtable[sctp_phas 8220 head = &sctp_port_hashtable[sctp_phashfn(sock_net(oldsk),
9561 8221 inet_sk(oldsk)->inet_num)];
9562 spin_lock_bh(&head->lock); 8222 spin_lock_bh(&head->lock);
9563 pp = sctp_sk(oldsk)->bind_hash; 8223 pp = sctp_sk(oldsk)->bind_hash;
9564 sk_add_bind_node(newsk, &pp->owner); 8224 sk_add_bind_node(newsk, &pp->owner);
9565 sctp_sk(newsk)->bind_hash = pp; 8225 sctp_sk(newsk)->bind_hash = pp;
9566 inet_sk(newsk)->inet_num = inet_sk(ol 8226 inet_sk(newsk)->inet_num = inet_sk(oldsk)->inet_num;
9567 spin_unlock_bh(&head->lock); 8227 spin_unlock_bh(&head->lock);
9568 8228
9569 /* Copy the bind_addr list from the o 8229 /* Copy the bind_addr list from the original endpoint to the new
9570 * endpoint so that we can handle res 8230 * endpoint so that we can handle restarts properly
9571 */ 8231 */
9572 err = sctp_bind_addr_dup(&newsp->ep-> !! 8232 sctp_bind_addr_dup(&newsp->ep->base.bind_addr,
9573 &oldsp->ep-> !! 8233 &oldsp->ep->base.bind_addr, GFP_KERNEL);
9574 if (err) <<
9575 return err; <<
9576 <<
9577 /* New ep's auth_hmacs should be set <<
9578 * that net->sctp.auth_enable has bee <<
9579 * new ep's auth_hmacs couldn't be se <<
9580 */ <<
9581 if (oldsp->ep->auth_hmacs) { <<
9582 err = sctp_auth_init_hmacs(ne <<
9583 if (err) <<
9584 return err; <<
9585 } <<
9586 8234
9587 sctp_auto_asconf_init(newsp); 8235 sctp_auto_asconf_init(newsp);
9588 8236
9589 /* Move any messages in the old socke 8237 /* Move any messages in the old socket's receive queue that are for the
9590 * peeled off association to the new 8238 * peeled off association to the new socket's receive queue.
9591 */ 8239 */
9592 sctp_skb_for_each(skb, &oldsk->sk_rec 8240 sctp_skb_for_each(skb, &oldsk->sk_receive_queue, tmp) {
9593 event = sctp_skb2event(skb); 8241 event = sctp_skb2event(skb);
9594 if (event->asoc == assoc) { 8242 if (event->asoc == assoc) {
9595 __skb_unlink(skb, &ol 8243 __skb_unlink(skb, &oldsk->sk_receive_queue);
9596 __skb_queue_tail(&new 8244 __skb_queue_tail(&newsk->sk_receive_queue, skb);
9597 sctp_skb_set_owner_r_ 8245 sctp_skb_set_owner_r_frag(skb, newsk);
9598 } 8246 }
9599 } 8247 }
9600 8248
9601 /* Clean up any messages pending deli 8249 /* Clean up any messages pending delivery due to partial
9602 * delivery. Three cases: 8250 * delivery. Three cases:
9603 * 1) No partial deliver; no work. 8251 * 1) No partial deliver; no work.
9604 * 2) Peeling off partial delivery; k 8252 * 2) Peeling off partial delivery; keep pd_lobby in new pd_lobby.
9605 * 3) Peeling off non-partial deliver 8253 * 3) Peeling off non-partial delivery; move pd_lobby to receive_queue.
9606 */ 8254 */
>> 8255 skb_queue_head_init(&newsp->pd_lobby);
9607 atomic_set(&sctp_sk(newsk)->pd_mode, 8256 atomic_set(&sctp_sk(newsk)->pd_mode, assoc->ulpq.pd_mode);
9608 8257
9609 if (atomic_read(&sctp_sk(oldsk)->pd_m 8258 if (atomic_read(&sctp_sk(oldsk)->pd_mode)) {
9610 struct sk_buff_head *queue; 8259 struct sk_buff_head *queue;
9611 8260
9612 /* Decide which queue to move 8261 /* Decide which queue to move pd_lobby skbs to. */
9613 if (assoc->ulpq.pd_mode) { 8262 if (assoc->ulpq.pd_mode) {
9614 queue = &newsp->pd_lo 8263 queue = &newsp->pd_lobby;
9615 } else 8264 } else
9616 queue = &newsk->sk_re 8265 queue = &newsk->sk_receive_queue;
9617 8266
9618 /* Walk through the pd_lobby, 8267 /* Walk through the pd_lobby, looking for skbs that
9619 * need moved to the new sock 8268 * need moved to the new socket.
9620 */ 8269 */
9621 sctp_skb_for_each(skb, &oldsp 8270 sctp_skb_for_each(skb, &oldsp->pd_lobby, tmp) {
9622 event = sctp_skb2even 8271 event = sctp_skb2event(skb);
9623 if (event->asoc == as 8272 if (event->asoc == assoc) {
9624 __skb_unlink( 8273 __skb_unlink(skb, &oldsp->pd_lobby);
9625 __skb_queue_t 8274 __skb_queue_tail(queue, skb);
9626 sctp_skb_set_ 8275 sctp_skb_set_owner_r_frag(skb, newsk);
9627 } 8276 }
9628 } 8277 }
9629 8278
9630 /* Clear up any skbs waiting 8279 /* Clear up any skbs waiting for the partial
9631 * delivery to finish. 8280 * delivery to finish.
9632 */ 8281 */
9633 if (assoc->ulpq.pd_mode) 8282 if (assoc->ulpq.pd_mode)
9634 sctp_clear_pd(oldsk, 8283 sctp_clear_pd(oldsk, NULL);
9635 8284
9636 } 8285 }
9637 8286
9638 sctp_for_each_rx_skb(assoc, newsk, sc !! 8287 sctp_skb_for_each(skb, &assoc->ulpq.reasm, tmp)
>> 8288 sctp_skb_set_owner_r_frag(skb, newsk);
>> 8289
>> 8290 sctp_skb_for_each(skb, &assoc->ulpq.lobby, tmp)
>> 8291 sctp_skb_set_owner_r_frag(skb, newsk);
9639 8292
9640 /* Set the type of socket to indicate 8293 /* Set the type of socket to indicate that it is peeled off from the
9641 * original UDP-style socket or creat 8294 * original UDP-style socket or created with the accept() call on a
9642 * TCP-style socket.. 8295 * TCP-style socket..
9643 */ 8296 */
9644 newsp->type = type; 8297 newsp->type = type;
9645 8298
9646 /* Mark the new socket "in-use" by th 8299 /* Mark the new socket "in-use" by the user so that any packets
9647 * that may arrive on the association 8300 * that may arrive on the association after we've moved it are
9648 * queued to the backlog. This preve 8301 * queued to the backlog. This prevents a potential race between
9649 * backlog processing on the old sock 8302 * backlog processing on the old socket and new-packet processing
9650 * on the new socket. 8303 * on the new socket.
9651 * 8304 *
9652 * The caller has just allocated news 8305 * The caller has just allocated newsk so we can guarantee that other
9653 * paths won't try to lock it and the 8306 * paths won't try to lock it and then oldsk.
9654 */ 8307 */
9655 lock_sock_nested(newsk, SINGLE_DEPTH_ 8308 lock_sock_nested(newsk, SINGLE_DEPTH_NESTING);
9656 sctp_for_each_tx_datachunk(assoc, tru 8309 sctp_for_each_tx_datachunk(assoc, true, sctp_clear_owner_w);
9657 sctp_assoc_migrate(assoc, newsk); 8310 sctp_assoc_migrate(assoc, newsk);
9658 sctp_for_each_tx_datachunk(assoc, fal 8311 sctp_for_each_tx_datachunk(assoc, false, sctp_set_owner_w);
9659 8312
9660 /* If the association on the newsk is 8313 /* If the association on the newsk is already closed before accept()
9661 * is called, set RCV_SHUTDOWN flag. 8314 * is called, set RCV_SHUTDOWN flag.
9662 */ 8315 */
9663 if (sctp_state(assoc, CLOSED) && sctp 8316 if (sctp_state(assoc, CLOSED) && sctp_style(newsk, TCP)) {
9664 inet_sk_set_state(newsk, SCTP !! 8317 newsk->sk_state = SCTP_SS_CLOSED;
9665 newsk->sk_shutdown |= RCV_SHU 8318 newsk->sk_shutdown |= RCV_SHUTDOWN;
9666 } else { 8319 } else {
9667 inet_sk_set_state(newsk, SCTP !! 8320 newsk->sk_state = SCTP_SS_ESTABLISHED;
9668 } 8321 }
9669 8322
9670 release_sock(newsk); 8323 release_sock(newsk);
9671 <<
9672 return 0; <<
9673 } 8324 }
9674 8325
9675 8326
9676 /* This proto struct describes the ULP interf 8327 /* This proto struct describes the ULP interface for SCTP. */
9677 struct proto sctp_prot = { 8328 struct proto sctp_prot = {
9678 .name = "SCTP", 8329 .name = "SCTP",
9679 .owner = THIS_MODULE, 8330 .owner = THIS_MODULE,
9680 .close = sctp_close, 8331 .close = sctp_close,
9681 .disconnect = sctp_disconnect, 8332 .disconnect = sctp_disconnect,
9682 .accept = sctp_accept, 8333 .accept = sctp_accept,
9683 .ioctl = sctp_ioctl, 8334 .ioctl = sctp_ioctl,
9684 .init = sctp_init_sock, 8335 .init = sctp_init_sock,
9685 .destroy = sctp_destroy_sock, 8336 .destroy = sctp_destroy_sock,
9686 .shutdown = sctp_shutdown, 8337 .shutdown = sctp_shutdown,
9687 .setsockopt = sctp_setsockopt, 8338 .setsockopt = sctp_setsockopt,
9688 .getsockopt = sctp_getsockopt, 8339 .getsockopt = sctp_getsockopt,
9689 .bpf_bypass_getsockopt = sctp_bpf_by <<
9690 .sendmsg = sctp_sendmsg, 8340 .sendmsg = sctp_sendmsg,
9691 .recvmsg = sctp_recvmsg, 8341 .recvmsg = sctp_recvmsg,
9692 .bind = sctp_bind, 8342 .bind = sctp_bind,
9693 .bind_add = sctp_bind_add, <<
9694 .backlog_rcv = sctp_backlog_rcv, 8343 .backlog_rcv = sctp_backlog_rcv,
9695 .hash = sctp_hash, 8344 .hash = sctp_hash,
9696 .unhash = sctp_unhash, 8345 .unhash = sctp_unhash,
9697 .no_autobind = true, 8346 .no_autobind = true,
9698 .obj_size = sizeof(struct sctp_so 8347 .obj_size = sizeof(struct sctp_sock),
9699 .useroffset = offsetof(struct sctp_ <<
9700 .usersize = offsetof(struct sctp_ <<
9701 offsetof(stru <<
9702 sizeof_field( <<
9703 .sysctl_mem = sysctl_sctp_mem, 8348 .sysctl_mem = sysctl_sctp_mem,
9704 .sysctl_rmem = sysctl_sctp_rmem, 8349 .sysctl_rmem = sysctl_sctp_rmem,
9705 .sysctl_wmem = sysctl_sctp_wmem, 8350 .sysctl_wmem = sysctl_sctp_wmem,
9706 .memory_pressure = &sctp_memory_press 8351 .memory_pressure = &sctp_memory_pressure,
9707 .enter_memory_pressure = sctp_enter_m 8352 .enter_memory_pressure = sctp_enter_memory_pressure,
9708 <<
9709 .memory_allocated = &sctp_memory_allo 8353 .memory_allocated = &sctp_memory_allocated,
9710 .per_cpu_fw_alloc = &sctp_memory_per_ <<
9711 <<
9712 .sockets_allocated = &sctp_sockets_al 8354 .sockets_allocated = &sctp_sockets_allocated,
9713 }; 8355 };
9714 8356
9715 #if IS_ENABLED(CONFIG_IPV6) 8357 #if IS_ENABLED(CONFIG_IPV6)
9716 8358
9717 static void sctp_v6_destruct_sock(struct sock 8359 static void sctp_v6_destruct_sock(struct sock *sk)
9718 { 8360 {
9719 sctp_destruct_common(sk); 8361 sctp_destruct_common(sk);
9720 inet6_sock_destruct(sk); 8362 inet6_sock_destruct(sk);
9721 } 8363 }
9722 8364
9723 static int sctp_v6_init_sock(struct sock *sk) 8365 static int sctp_v6_init_sock(struct sock *sk)
9724 { 8366 {
9725 int ret = sctp_init_sock(sk); 8367 int ret = sctp_init_sock(sk);
9726 8368
9727 if (!ret) 8369 if (!ret)
9728 sk->sk_destruct = sctp_v6_des 8370 sk->sk_destruct = sctp_v6_destruct_sock;
9729 8371
9730 return ret; 8372 return ret;
9731 } 8373 }
9732 8374
9733 struct proto sctpv6_prot = { 8375 struct proto sctpv6_prot = {
9734 .name = "SCTPv6", 8376 .name = "SCTPv6",
9735 .owner = THIS_MODULE, 8377 .owner = THIS_MODULE,
9736 .close = sctp_close, 8378 .close = sctp_close,
9737 .disconnect = sctp_disconnect, 8379 .disconnect = sctp_disconnect,
9738 .accept = sctp_accept, 8380 .accept = sctp_accept,
9739 .ioctl = sctp_ioctl, 8381 .ioctl = sctp_ioctl,
9740 .init = sctp_v6_init_sock, 8382 .init = sctp_v6_init_sock,
9741 .destroy = sctp_destroy_sock, 8383 .destroy = sctp_destroy_sock,
9742 .shutdown = sctp_shutdown, 8384 .shutdown = sctp_shutdown,
9743 .setsockopt = sctp_setsockopt, 8385 .setsockopt = sctp_setsockopt,
9744 .getsockopt = sctp_getsockopt, 8386 .getsockopt = sctp_getsockopt,
9745 .bpf_bypass_getsockopt = sctp_bpf_by <<
9746 .sendmsg = sctp_sendmsg, 8387 .sendmsg = sctp_sendmsg,
9747 .recvmsg = sctp_recvmsg, 8388 .recvmsg = sctp_recvmsg,
9748 .bind = sctp_bind, 8389 .bind = sctp_bind,
9749 .bind_add = sctp_bind_add, <<
9750 .backlog_rcv = sctp_backlog_rcv, 8390 .backlog_rcv = sctp_backlog_rcv,
9751 .hash = sctp_hash, 8391 .hash = sctp_hash,
9752 .unhash = sctp_unhash, 8392 .unhash = sctp_unhash,
9753 .no_autobind = true, 8393 .no_autobind = true,
9754 .obj_size = sizeof(struct sctp6 8394 .obj_size = sizeof(struct sctp6_sock),
9755 .ipv6_pinfo_offset = offsetof(struct <<
9756 .useroffset = offsetof(struct sct <<
9757 .usersize = offsetof(struct sct <<
9758 offsetof(stru <<
9759 sizeof_field( <<
9760 .sysctl_mem = sysctl_sctp_mem, 8395 .sysctl_mem = sysctl_sctp_mem,
9761 .sysctl_rmem = sysctl_sctp_rmem, 8396 .sysctl_rmem = sysctl_sctp_rmem,
9762 .sysctl_wmem = sysctl_sctp_wmem, 8397 .sysctl_wmem = sysctl_sctp_wmem,
9763 .memory_pressure = &sctp_memory_press 8398 .memory_pressure = &sctp_memory_pressure,
9764 .enter_memory_pressure = sctp_enter_m 8399 .enter_memory_pressure = sctp_enter_memory_pressure,
9765 <<
9766 .memory_allocated = &sctp_memory_allo 8400 .memory_allocated = &sctp_memory_allocated,
9767 .per_cpu_fw_alloc = &sctp_memory_per_ <<
9768 <<
9769 .sockets_allocated = &sctp_sockets_al 8401 .sockets_allocated = &sctp_sockets_allocated,
9770 }; 8402 };
9771 #endif /* IS_ENABLED(CONFIG_IPV6) */ 8403 #endif /* IS_ENABLED(CONFIG_IPV6) */
9772 8404
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.