1 /* SCTP kernel reference Implementation 2 * (C) Copyright IBM Corp. 2001, 2004 3 * Copyright (c) 1999-2000 Cisco, Inc. 4 * Copyright (c) 1999-2001 Motorola, Inc. 5 * Copyright (c) 2001-2003 Intel Corp. 6 * Copyright (c) 2001-2002 Nokia, Inc. 7 * Copyright (c) 2001 La Monte H.P. Yarroll 8 * 9 * This file is part of the SCTP kernel reference Implementation 10 * 11 * These functions interface with the sockets layer to implement the 12 * SCTP Extensions for the Sockets API. 13 * 14 * Note that the descriptions from the specification are USER level 15 * functions--this file is the functions which populate the struct proto 16 * for SCTP which is the BOTTOM of the sockets interface. 17 * 18 * The SCTP reference 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 * The SCTP reference 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, write to 32 * the Free Software Foundation, 59 Temple Place - Suite 330, 33 * Boston, MA 02111-1307, USA. 34 * 35 * Please send any bug reports or fixes you make to the 36 * email address(es): 37 * lksctp developers <lksctp-developers@lists.sourceforge.net> 38 * 39 * Or submit a bug report through the following website: 40 * http://www.sf.net/projects/lksctp 41 * 42 * Written or modified by: 43 * La Monte H.P. Yarroll <piggy@acm.org> 44 * Narasimha Budihal <narsi@refcode.org> 45 * Karl Knutson <karl@athena.chicago.il.us> 46 * Jon Grimm <jgrimm@us.ibm.com> 47 * Xingang Guo <xingang.guo@intel.com> 48 * Daisy Chang <daisyc@us.ibm.com> 49 * Sridhar Samudrala <samudrala@us.ibm.com> 50 * Inaky Perez-Gonzalez <inaky.gonzalez@intel.com> 51 * Ardelle Fan <ardelle.fan@intel.com> 52 * Ryan Layer <rmlayer@us.ibm.com> 53 * Anup Pemmaiah <pemmaiah@cc.usu.edu> 54 * Kevin Gao <kevin.gao@intel.com> 55 * 56 * Any bugs reported given to us we will try to fix... any fixes shared will 57 * be incorporated into the next SCTP release. 58 */ 59 60 #include <linux/types.h> 61 #include <linux/kernel.h> 62 #include <linux/wait.h> 63 #include <linux/time.h> 64 #include <linux/ip.h> 65 #include <linux/capability.h> 66 #include <linux/fcntl.h> 67 #include <linux/poll.h> 68 #include <linux/init.h> 69 #include <linux/crypto.h> 70 71 #include <net/ip.h> 72 #include <net/icmp.h> 73 #include <net/route.h> 74 #include <net/ipv6.h> 75 #include <net/inet_common.h> 76 77 #include <linux/socket.h> /* for sa_family_t */ 78 #include <net/sock.h> 79 #include <net/sctp/sctp.h> 80 #include <net/sctp/sm.h> 81 82 /* WARNING: Please do not remove the SCTP_STATIC attribute to 83 * any of the functions below as they are used to export functions 84 * used by a project regression testsuite. 85 */ 86 87 /* Forward declarations for internal helper functions. */ 88 static int sctp_writeable(struct sock *sk); 89 static void sctp_wfree(struct sk_buff *skb); 90 static int sctp_wait_for_sndbuf(struct sctp_association *, long *timeo_p, 91 size_t msg_len); 92 static int sctp_wait_for_packet(struct sock * sk, int *err, long *timeo_p); 93 static int sctp_wait_for_connect(struct sctp_association *, long *timeo_p); 94 static int sctp_wait_for_accept(struct sock *sk, long timeo); 95 static void sctp_wait_for_close(struct sock *sk, long timeo); 96 static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt, 97 union sctp_addr *addr, int len); 98 static int sctp_bindx_add(struct sock *, struct sockaddr *, int); 99 static int sctp_bindx_rem(struct sock *, struct sockaddr *, int); 100 static int sctp_send_asconf_add_ip(struct sock *, struct sockaddr *, int); 101 static int sctp_send_asconf_del_ip(struct sock *, struct sockaddr *, int); 102 static int sctp_send_asconf(struct sctp_association *asoc, 103 struct sctp_chunk *chunk); 104 static int sctp_do_bind(struct sock *, union sctp_addr *, int); 105 static int sctp_autobind(struct sock *sk); 106 static void sctp_sock_migrate(struct sock *, struct sock *, 107 struct sctp_association *, sctp_socket_type_t); 108 static char *sctp_hmac_alg = SCTP_COOKIE_HMAC_ALG; 109 110 extern kmem_cache_t *sctp_bucket_cachep; 111 112 /* Get the sndbuf space available at the time on the association. */ 113 static inline int sctp_wspace(struct sctp_association *asoc) 114 { 115 struct sock *sk = asoc->base.sk; 116 int amt = 0; 117 118 if (asoc->ep->sndbuf_policy) { 119 /* make sure that no association uses more than sk_sndbuf */ 120 amt = sk->sk_sndbuf - asoc->sndbuf_used; 121 } else { 122 /* do socket level accounting */ 123 amt = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc); 124 } 125 126 if (amt < 0) 127 amt = 0; 128 129 return amt; 130 } 131 132 /* Increment the used sndbuf space count of the corresponding association by 133 * the size of the outgoing data chunk. 134 * Also, set the skb destructor for sndbuf accounting later. 135 * 136 * Since it is always 1-1 between chunk and skb, and also a new skb is always 137 * allocated for chunk bundling in sctp_packet_transmit(), we can use the 138 * destructor in the data chunk skb for the purpose of the sndbuf space 139 * tracking. 140 */ 141 static inline void sctp_set_owner_w(struct sctp_chunk *chunk) 142 { 143 struct sctp_association *asoc = chunk->asoc; 144 struct sock *sk = asoc->base.sk; 145 146 /* The sndbuf space is tracked per association. */ 147 sctp_association_hold(asoc); 148 149 skb_set_owner_w(chunk->skb, sk); 150 151 chunk->skb->destructor = sctp_wfree; 152 /* Save the chunk pointer in skb for sctp_wfree to use later. */ 153 *((struct sctp_chunk **)(chunk->skb->cb)) = chunk; 154 155 asoc->sndbuf_used += SCTP_DATA_SNDSIZE(chunk) + 156 sizeof(struct sk_buff) + 157 sizeof(struct sctp_chunk); 158 159 atomic_add(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc); 160 } 161 162 /* Verify that this is a valid address. */ 163 static inline int sctp_verify_addr(struct sock *sk, union sctp_addr *addr, 164 int len) 165 { 166 struct sctp_af *af; 167 168 /* Verify basic sockaddr. */ 169 af = sctp_sockaddr_af(sctp_sk(sk), addr, len); 170 if (!af) 171 return -EINVAL; 172 173 /* Is this a valid SCTP address? */ 174 if (!af->addr_valid(addr, sctp_sk(sk), NULL)) 175 return -EINVAL; 176 177 if (!sctp_sk(sk)->pf->send_verify(sctp_sk(sk), (addr))) 178 return -EINVAL; 179 180 return 0; 181 } 182 183 /* Look up the association by its id. If this is not a UDP-style 184 * socket, the ID field is always ignored. 185 */ 186 struct sctp_association *sctp_id2assoc(struct sock *sk, sctp_assoc_t id) 187 { 188 struct sctp_association *asoc = NULL; 189 190 /* If this is not a UDP-style socket, assoc id should be ignored. */ 191 if (!sctp_style(sk, UDP)) { 192 /* Return NULL if the socket state is not ESTABLISHED. It 193 * could be a TCP-style listening socket or a socket which 194 * hasn't yet called connect() to establish an association. 195 */ 196 if (!sctp_sstate(sk, ESTABLISHED)) 197 return NULL; 198 199 /* Get the first and the only association from the list. */ 200 if (!list_empty(&sctp_sk(sk)->ep->asocs)) 201 asoc = list_entry(sctp_sk(sk)->ep->asocs.next, 202 struct sctp_association, asocs); 203 return asoc; 204 } 205 206 /* Otherwise this is a UDP-style socket. */ 207 if (!id || (id == (sctp_assoc_t)-1)) 208 return NULL; 209 210 spin_lock_bh(&sctp_assocs_id_lock); 211 asoc = (struct sctp_association *)idr_find(&sctp_assocs_id, (int)id); 212 spin_unlock_bh(&sctp_assocs_id_lock); 213 214 if (!asoc || (asoc->base.sk != sk) || asoc->base.dead) 215 return NULL; 216 217 return asoc; 218 } 219 220 /* Look up the transport from an address and an assoc id. If both address and 221 * id are specified, the associations matching the address and the id should be 222 * the same. 223 */ 224 static struct sctp_transport *sctp_addr_id2transport(struct sock *sk, 225 struct sockaddr_storage *addr, 226 sctp_assoc_t id) 227 { 228 struct sctp_association *addr_asoc = NULL, *id_asoc = NULL; 229 struct sctp_transport *transport; 230 union sctp_addr *laddr = (union sctp_addr *)addr; 231 232 laddr->v4.sin_port = ntohs(laddr->v4.sin_port); 233 addr_asoc = sctp_endpoint_lookup_assoc(sctp_sk(sk)->ep, 234 (union sctp_addr *)addr, 235 &transport); 236 laddr->v4.sin_port = htons(laddr->v4.sin_port); 237 238 if (!addr_asoc) 239 return NULL; 240 241 id_asoc = sctp_id2assoc(sk, id); 242 if (id_asoc && (id_asoc != addr_asoc)) 243 return NULL; 244 245 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk), 246 (union sctp_addr *)addr); 247 248 return transport; 249 } 250 251 /* API 3.1.2 bind() - UDP Style Syntax 252 * The syntax of bind() is, 253 * 254 * ret = bind(int sd, struct sockaddr *addr, int addrlen); 255 * 256 * sd - the socket descriptor returned by socket(). 257 * addr - the address structure (struct sockaddr_in or struct 258 * sockaddr_in6 [RFC 2553]), 259 * addr_len - the size of the address structure. 260 */ 261 SCTP_STATIC int sctp_bind(struct sock *sk, struct sockaddr *addr, int addr_len) 262 { 263 int retval = 0; 264 265 sctp_lock_sock(sk); 266 267 SCTP_DEBUG_PRINTK("sctp_bind(sk: %p, addr: %p, addr_len: %d)\n", 268 sk, addr, addr_len); 269 270 /* Disallow binding twice. */ 271 if (!sctp_sk(sk)->ep->base.bind_addr.port) 272 retval = sctp_do_bind(sk, (union sctp_addr *)addr, 273 addr_len); 274 else 275 retval = -EINVAL; 276 277 sctp_release_sock(sk); 278 279 return retval; 280 } 281 282 static long sctp_get_port_local(struct sock *, union sctp_addr *); 283 284 /* Verify this is a valid sockaddr. */ 285 static struct sctp_af *sctp_sockaddr_af(struct sctp_sock *opt, 286 union sctp_addr *addr, int len) 287 { 288 struct sctp_af *af; 289 290 /* Check minimum size. */ 291 if (len < sizeof (struct sockaddr)) 292 return NULL; 293 294 /* Does this PF support this AF? */ 295 if (!opt->pf->af_supported(addr->sa.sa_family, opt)) 296 return NULL; 297 298 /* If we get this far, af is valid. */ 299 af = sctp_get_af_specific(addr->sa.sa_family); 300 301 if (len < af->sockaddr_len) 302 return NULL; 303 304 return af; 305 } 306 307 /* Bind a local address either to an endpoint or to an association. */ 308 SCTP_STATIC int sctp_do_bind(struct sock *sk, union sctp_addr *addr, int len) 309 { 310 struct sctp_sock *sp = sctp_sk(sk); 311 struct sctp_endpoint *ep = sp->ep; 312 struct sctp_bind_addr *bp = &ep->base.bind_addr; 313 struct sctp_af *af; 314 unsigned short snum; 315 int ret = 0; 316 317 /* Common sockaddr verification. */ 318 af = sctp_sockaddr_af(sp, addr, len); 319 if (!af) { 320 SCTP_DEBUG_PRINTK("sctp_do_bind(sk: %p, newaddr: %p, len: %d) EINVAL\n", 321 sk, addr, len); 322 return -EINVAL; 323 } 324 325 snum = ntohs(addr->v4.sin_port); 326 327 SCTP_DEBUG_PRINTK_IPADDR("sctp_do_bind(sk: %p, new addr: ", 328 ", port: %d, new port: %d, len: %d)\n", 329 sk, 330 addr, 331 bp->port, snum, 332 len); 333 334 /* PF specific bind() address verification. */ 335 if (!sp->pf->bind_verify(sp, addr)) 336 return -EADDRNOTAVAIL; 337 338 /* We must either be unbound, or bind to the same port. */ 339 if (bp->port && (snum != bp->port)) { 340 SCTP_DEBUG_PRINTK("sctp_do_bind:" 341 " New port %d does not match existing port " 342 "%d.\n", snum, bp->port); 343 return -EINVAL; 344 } 345 346 if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE)) 347 return -EACCES; 348 349 /* Make sure we are allowed to bind here. 350 * The function sctp_get_port_local() does duplicate address 351 * detection. 352 */ 353 if ((ret = sctp_get_port_local(sk, addr))) { 354 if (ret == (long) sk) { 355 /* This endpoint has a conflicting address. */ 356 return -EINVAL; 357 } else { 358 return -EADDRINUSE; 359 } 360 } 361 362 /* Refresh ephemeral port. */ 363 if (!bp->port) 364 bp->port = inet_sk(sk)->num; 365 366 /* Add the address to the bind address list. */ 367 sctp_local_bh_disable(); 368 sctp_write_lock(&ep->base.addr_lock); 369 370 /* Use GFP_ATOMIC since BHs are disabled. */ 371 addr->v4.sin_port = ntohs(addr->v4.sin_port); 372 ret = sctp_add_bind_addr(bp, addr, 1, GFP_ATOMIC); 373 addr->v4.sin_port = htons(addr->v4.sin_port); 374 sctp_write_unlock(&ep->base.addr_lock); 375 sctp_local_bh_enable(); 376 377 /* Copy back into socket for getsockname() use. */ 378 if (!ret) { 379 inet_sk(sk)->sport = htons(inet_sk(sk)->num); 380 af->to_sk_saddr(addr, sk); 381 } 382 383 return ret; 384 } 385 386 /* ADDIP Section 4.1.1 Congestion Control of ASCONF Chunks 387 * 388 * R1) One and only one ASCONF Chunk MAY be in transit and unacknowledged 389 * at any one time. If a sender, after sending an ASCONF chunk, decides 390 * it needs to transfer another ASCONF Chunk, it MUST wait until the 391 * ASCONF-ACK Chunk returns from the previous ASCONF Chunk before sending a 392 * subsequent ASCONF. Note this restriction binds each side, so at any 393 * time two ASCONF may be in-transit on any given association (one sent 394 * from each endpoint). 395 */ 396 static int sctp_send_asconf(struct sctp_association *asoc, 397 struct sctp_chunk *chunk) 398 { 399 int retval = 0; 400 401 /* If there is an outstanding ASCONF chunk, queue it for later 402 * transmission. 403 */ 404 if (asoc->addip_last_asconf) { 405 list_add_tail(&chunk->list, &asoc->addip_chunk_list); 406 goto out; 407 } 408 409 /* Hold the chunk until an ASCONF_ACK is received. */ 410 sctp_chunk_hold(chunk); 411 retval = sctp_primitive_ASCONF(asoc, chunk); 412 if (retval) 413 sctp_chunk_free(chunk); 414 else 415 asoc->addip_last_asconf = chunk; 416 417 out: 418 return retval; 419 } 420 421 /* Add a list of addresses as bind addresses to local endpoint or 422 * association. 423 * 424 * Basically run through each address specified in the addrs/addrcnt 425 * array/length pair, determine if it is IPv6 or IPv4 and call 426 * sctp_do_bind() on it. 427 * 428 * If any of them fails, then the operation will be reversed and the 429 * ones that were added will be removed. 430 * 431 * Only sctp_setsockopt_bindx() is supposed to call this function. 432 */ 433 int sctp_bindx_add(struct sock *sk, struct sockaddr *addrs, int addrcnt) 434 { 435 int cnt; 436 int retval = 0; 437 void *addr_buf; 438 struct sockaddr *sa_addr; 439 struct sctp_af *af; 440 441 SCTP_DEBUG_PRINTK("sctp_bindx_add (sk: %p, addrs: %p, addrcnt: %d)\n", 442 sk, addrs, addrcnt); 443 444 addr_buf = addrs; 445 for (cnt = 0; cnt < addrcnt; cnt++) { 446 /* The list may contain either IPv4 or IPv6 address; 447 * determine the address length for walking thru the list. 448 */ 449 sa_addr = (struct sockaddr *)addr_buf; 450 af = sctp_get_af_specific(sa_addr->sa_family); 451 if (!af) { 452 retval = -EINVAL; 453 goto err_bindx_add; 454 } 455 456 retval = sctp_do_bind(sk, (union sctp_addr *)sa_addr, 457 af->sockaddr_len); 458 459 addr_buf += af->sockaddr_len; 460 461 err_bindx_add: 462 if (retval < 0) { 463 /* Failed. Cleanup the ones that have been added */ 464 if (cnt > 0) 465 sctp_bindx_rem(sk, addrs, cnt); 466 return retval; 467 } 468 } 469 470 return retval; 471 } 472 473 /* Send an ASCONF chunk with Add IP address parameters to all the peers of the 474 * associations that are part of the endpoint indicating that a list of local 475 * addresses are added to the endpoint. 476 * 477 * If any of the addresses is already in the bind address list of the 478 * association, we do not send the chunk for that association. But it will not 479 * affect other associations. 480 * 481 * Only sctp_setsockopt_bindx() is supposed to call this function. 482 */ 483 static int sctp_send_asconf_add_ip(struct sock *sk, 484 struct sockaddr *addrs, 485 int addrcnt) 486 { 487 struct sctp_sock *sp; 488 struct sctp_endpoint *ep; 489 struct sctp_association *asoc; 490 struct sctp_bind_addr *bp; 491 struct sctp_chunk *chunk; 492 struct sctp_sockaddr_entry *laddr; 493 union sctp_addr *addr; 494 union sctp_addr saveaddr; 495 void *addr_buf; 496 struct sctp_af *af; 497 struct list_head *pos; 498 struct list_head *p; 499 int i; 500 int retval = 0; 501 502 if (!sctp_addip_enable) 503 return retval; 504 505 sp = sctp_sk(sk); 506 ep = sp->ep; 507 508 SCTP_DEBUG_PRINTK("%s: (sk: %p, addrs: %p, addrcnt: %d)\n", 509 __FUNCTION__, sk, addrs, addrcnt); 510 511 list_for_each(pos, &ep->asocs) { 512 asoc = list_entry(pos, struct sctp_association, asocs); 513 514 if (!asoc->peer.asconf_capable) 515 continue; 516 517 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_ADD_IP) 518 continue; 519 520 if (!sctp_state(asoc, ESTABLISHED)) 521 continue; 522 523 /* Check if any address in the packed array of addresses is 524 * in the bind address list of the association. If so, 525 * do not send the asconf chunk to its peer, but continue with 526 * other associations. 527 */ 528 addr_buf = addrs; 529 for (i = 0; i < addrcnt; i++) { 530 addr = (union sctp_addr *)addr_buf; 531 af = sctp_get_af_specific(addr->v4.sin_family); 532 if (!af) { 533 retval = -EINVAL; 534 goto out; 535 } 536 537 if (sctp_assoc_lookup_laddr(asoc, addr)) 538 break; 539 540 addr_buf += af->sockaddr_len; 541 } 542 if (i < addrcnt) 543 continue; 544 545 /* Use the first address in bind addr list of association as 546 * Address Parameter of ASCONF CHUNK. 547 */ 548 sctp_read_lock(&asoc->base.addr_lock); 549 bp = &asoc->base.bind_addr; 550 p = bp->address_list.next; 551 laddr = list_entry(p, struct sctp_sockaddr_entry, list); 552 sctp_read_unlock(&asoc->base.addr_lock); 553 554 chunk = sctp_make_asconf_update_ip(asoc, &laddr->a, addrs, 555 addrcnt, SCTP_PARAM_ADD_IP); 556 if (!chunk) { 557 retval = -ENOMEM; 558 goto out; 559 } 560 561 retval = sctp_send_asconf(asoc, chunk); 562 if (retval) 563 goto out; 564 565 /* Add the new addresses to the bind address list with 566 * use_as_src set to 0. 567 */ 568 sctp_local_bh_disable(); 569 sctp_write_lock(&asoc->base.addr_lock); 570 addr_buf = addrs; 571 for (i = 0; i < addrcnt; i++) { 572 addr = (union sctp_addr *)addr_buf; 573 af = sctp_get_af_specific(addr->v4.sin_family); 574 memcpy(&saveaddr, addr, af->sockaddr_len); 575 saveaddr.v4.sin_port = ntohs(saveaddr.v4.sin_port); 576 retval = sctp_add_bind_addr(bp, &saveaddr, 0, 577 GFP_ATOMIC); 578 addr_buf += af->sockaddr_len; 579 } 580 sctp_write_unlock(&asoc->base.addr_lock); 581 sctp_local_bh_enable(); 582 } 583 584 out: 585 return retval; 586 } 587 588 /* Remove a list of addresses from bind addresses list. Do not remove the 589 * last address. 590 * 591 * Basically run through each address specified in the addrs/addrcnt 592 * array/length pair, determine if it is IPv6 or IPv4 and call 593 * sctp_del_bind() on it. 594 * 595 * If any of them fails, then the operation will be reversed and the 596 * ones that were removed will be added back. 597 * 598 * At least one address has to be left; if only one address is 599 * available, the operation will return -EBUSY. 600 * 601 * Only sctp_setsockopt_bindx() is supposed to call this function. 602 */ 603 int sctp_bindx_rem(struct sock *sk, struct sockaddr *addrs, int addrcnt) 604 { 605 struct sctp_sock *sp = sctp_sk(sk); 606 struct sctp_endpoint *ep = sp->ep; 607 int cnt; 608 struct sctp_bind_addr *bp = &ep->base.bind_addr; 609 int retval = 0; 610 union sctp_addr saveaddr; 611 void *addr_buf; 612 struct sockaddr *sa_addr; 613 struct sctp_af *af; 614 615 SCTP_DEBUG_PRINTK("sctp_bindx_rem (sk: %p, addrs: %p, addrcnt: %d)\n", 616 sk, addrs, addrcnt); 617 618 addr_buf = addrs; 619 for (cnt = 0; cnt < addrcnt; cnt++) { 620 /* If the bind address list is empty or if there is only one 621 * bind address, there is nothing more to be removed (we need 622 * at least one address here). 623 */ 624 if (list_empty(&bp->address_list) || 625 (sctp_list_single_entry(&bp->address_list))) { 626 retval = -EBUSY; 627 goto err_bindx_rem; 628 } 629 630 /* The list may contain either IPv4 or IPv6 address; 631 * determine the address length to copy the address to 632 * saveaddr. 633 */ 634 sa_addr = (struct sockaddr *)addr_buf; 635 af = sctp_get_af_specific(sa_addr->sa_family); 636 if (!af) { 637 retval = -EINVAL; 638 goto err_bindx_rem; 639 } 640 memcpy(&saveaddr, sa_addr, af->sockaddr_len); 641 saveaddr.v4.sin_port = ntohs(saveaddr.v4.sin_port); 642 if (saveaddr.v4.sin_port != bp->port) { 643 retval = -EINVAL; 644 goto err_bindx_rem; 645 } 646 647 /* FIXME - There is probably a need to check if sk->sk_saddr and 648 * sk->sk_rcv_addr are currently set to one of the addresses to 649 * be removed. This is something which needs to be looked into 650 * when we are fixing the outstanding issues with multi-homing 651 * socket routing and failover schemes. Refer to comments in 652 * sctp_do_bind(). -daisy 653 */ 654 sctp_local_bh_disable(); 655 sctp_write_lock(&ep->base.addr_lock); 656 657 retval = sctp_del_bind_addr(bp, &saveaddr); 658 659 sctp_write_unlock(&ep->base.addr_lock); 660 sctp_local_bh_enable(); 661 662 addr_buf += af->sockaddr_len; 663 err_bindx_rem: 664 if (retval < 0) { 665 /* Failed. Add the ones that has been removed back */ 666 if (cnt > 0) 667 sctp_bindx_add(sk, addrs, cnt); 668 return retval; 669 } 670 } 671 672 return retval; 673 } 674 675 /* Send an ASCONF chunk with Delete IP address parameters to all the peers of 676 * the associations that are part of the endpoint indicating that a list of 677 * local addresses are removed from the endpoint. 678 * 679 * If any of the addresses is already in the bind address list of the 680 * association, we do not send the chunk for that association. But it will not 681 * affect other associations. 682 * 683 * Only sctp_setsockopt_bindx() is supposed to call this function. 684 */ 685 static int sctp_send_asconf_del_ip(struct sock *sk, 686 struct sockaddr *addrs, 687 int addrcnt) 688 { 689 struct sctp_sock *sp; 690 struct sctp_endpoint *ep; 691 struct sctp_association *asoc; 692 struct sctp_transport *transport; 693 struct sctp_bind_addr *bp; 694 struct sctp_chunk *chunk; 695 union sctp_addr *laddr; 696 union sctp_addr saveaddr; 697 void *addr_buf; 698 struct sctp_af *af; 699 struct list_head *pos, *pos1; 700 struct sctp_sockaddr_entry *saddr; 701 int i; 702 int retval = 0; 703 704 if (!sctp_addip_enable) 705 return retval; 706 707 sp = sctp_sk(sk); 708 ep = sp->ep; 709 710 SCTP_DEBUG_PRINTK("%s: (sk: %p, addrs: %p, addrcnt: %d)\n", 711 __FUNCTION__, sk, addrs, addrcnt); 712 713 list_for_each(pos, &ep->asocs) { 714 asoc = list_entry(pos, struct sctp_association, asocs); 715 716 if (!asoc->peer.asconf_capable) 717 continue; 718 719 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_DEL_IP) 720 continue; 721 722 if (!sctp_state(asoc, ESTABLISHED)) 723 continue; 724 725 /* Check if any address in the packed array of addresses is 726 * not present in the bind address list of the association. 727 * If so, do not send the asconf chunk to its peer, but 728 * continue with other associations. 729 */ 730 addr_buf = addrs; 731 for (i = 0; i < addrcnt; i++) { 732 laddr = (union sctp_addr *)addr_buf; 733 af = sctp_get_af_specific(laddr->v4.sin_family); 734 if (!af) { 735 retval = -EINVAL; 736 goto out; 737 } 738 739 if (!sctp_assoc_lookup_laddr(asoc, laddr)) 740 break; 741 742 addr_buf += af->sockaddr_len; 743 } 744 if (i < addrcnt) 745 continue; 746 747 /* Find one address in the association's bind address list 748 * that is not in the packed array of addresses. This is to 749 * make sure that we do not delete all the addresses in the 750 * association. 751 */ 752 sctp_read_lock(&asoc->base.addr_lock); 753 bp = &asoc->base.bind_addr; 754 laddr = sctp_find_unmatch_addr(bp, (union sctp_addr *)addrs, 755 addrcnt, sp); 756 sctp_read_unlock(&asoc->base.addr_lock); 757 if (!laddr) 758 continue; 759 760 chunk = sctp_make_asconf_update_ip(asoc, laddr, addrs, addrcnt, 761 SCTP_PARAM_DEL_IP); 762 if (!chunk) { 763 retval = -ENOMEM; 764 goto out; 765 } 766 767 /* Reset use_as_src flag for the addresses in the bind address 768 * list that are to be deleted. 769 */ 770 sctp_local_bh_disable(); 771 sctp_write_lock(&asoc->base.addr_lock); 772 addr_buf = addrs; 773 for (i = 0; i < addrcnt; i++) { 774 laddr = (union sctp_addr *)addr_buf; 775 af = sctp_get_af_specific(laddr->v4.sin_family); 776 memcpy(&saveaddr, laddr, af->sockaddr_len); 777 saveaddr.v4.sin_port = ntohs(saveaddr.v4.sin_port); 778 list_for_each(pos1, &bp->address_list) { 779 saddr = list_entry(pos1, 780 struct sctp_sockaddr_entry, 781 list); 782 if (sctp_cmp_addr_exact(&saddr->a, &saveaddr)) 783 saddr->use_as_src = 0; 784 } 785 addr_buf += af->sockaddr_len; 786 } 787 sctp_write_unlock(&asoc->base.addr_lock); 788 sctp_local_bh_enable(); 789 790 /* Update the route and saddr entries for all the transports 791 * as some of the addresses in the bind address list are 792 * about to be deleted and cannot be used as source addresses. 793 */ 794 list_for_each(pos1, &asoc->peer.transport_addr_list) { 795 transport = list_entry(pos1, struct sctp_transport, 796 transports); 797 dst_release(transport->dst); 798 sctp_transport_route(transport, NULL, 799 sctp_sk(asoc->base.sk)); 800 } 801 802 retval = sctp_send_asconf(asoc, chunk); 803 } 804 out: 805 return retval; 806 } 807 808 /* Helper for tunneling sctp_bindx() requests through sctp_setsockopt() 809 * 810 * API 8.1 811 * int sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt, 812 * int flags); 813 * 814 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses. 815 * If the sd is an IPv6 socket, the addresses passed can either be IPv4 816 * or IPv6 addresses. 817 * 818 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see 819 * Section 3.1.2 for this usage. 820 * 821 * addrs is a pointer to an array of one or more socket addresses. Each 822 * address is contained in its appropriate structure (i.e. struct 823 * sockaddr_in or struct sockaddr_in6) the family of the address type 824 * must be used to distengish the address length (note that this 825 * representation is termed a "packed array" of addresses). The caller 826 * specifies the number of addresses in the array with addrcnt. 827 * 828 * On success, sctp_bindx() returns 0. On failure, sctp_bindx() returns 829 * -1, and sets errno to the appropriate error code. 830 * 831 * For SCTP, the port given in each socket address must be the same, or 832 * sctp_bindx() will fail, setting errno to EINVAL. 833 * 834 * The flags parameter is formed from the bitwise OR of zero or more of 835 * the following currently defined flags: 836 * 837 * SCTP_BINDX_ADD_ADDR 838 * 839 * SCTP_BINDX_REM_ADDR 840 * 841 * SCTP_BINDX_ADD_ADDR directs SCTP to add the given addresses to the 842 * association, and SCTP_BINDX_REM_ADDR directs SCTP to remove the given 843 * addresses from the association. The two flags are mutually exclusive; 844 * if both are given, sctp_bindx() will fail with EINVAL. A caller may 845 * not remove all addresses from an association; sctp_bindx() will 846 * reject such an attempt with EINVAL. 847 * 848 * An application can use sctp_bindx(SCTP_BINDX_ADD_ADDR) to associate 849 * additional addresses with an endpoint after calling bind(). Or use 850 * sctp_bindx(SCTP_BINDX_REM_ADDR) to remove some addresses a listening 851 * socket is associated with so that no new association accepted will be 852 * associated with those addresses. If the endpoint supports dynamic 853 * address a SCTP_BINDX_REM_ADDR or SCTP_BINDX_ADD_ADDR may cause a 854 * endpoint to send the appropriate message to the peer to change the 855 * peers address lists. 856 * 857 * Adding and removing addresses from a connected association is 858 * optional functionality. Implementations that do not support this 859 * functionality should return EOPNOTSUPP. 860 * 861 * Basically do nothing but copying the addresses from user to kernel 862 * land and invoking either sctp_bindx_add() or sctp_bindx_rem() on the sk. 863 * This is used for tunneling the sctp_bindx() request through sctp_setsockopt() 864 * from userspace. 865 * 866 * We don't use copy_from_user() for optimization: we first do the 867 * sanity checks (buffer size -fast- and access check-healthy 868 * pointer); if all of those succeed, then we can alloc the memory 869 * (expensive operation) needed to copy the data to kernel. Then we do 870 * the copying without checking the user space area 871 * (__copy_from_user()). 872 * 873 * On exit there is no need to do sockfd_put(), sys_setsockopt() does 874 * it. 875 * 876 * sk The sk of the socket 877 * addrs The pointer to the addresses in user land 878 * addrssize Size of the addrs buffer 879 * op Operation to perform (add or remove, see the flags of 880 * sctp_bindx) 881 * 882 * Returns 0 if ok, <0 errno code on error. 883 */ 884 SCTP_STATIC int sctp_setsockopt_bindx(struct sock* sk, 885 struct sockaddr __user *addrs, 886 int addrs_size, int op) 887 { 888 struct sockaddr *kaddrs; 889 int err; 890 int addrcnt = 0; 891 int walk_size = 0; 892 struct sockaddr *sa_addr; 893 void *addr_buf; 894 struct sctp_af *af; 895 896 SCTP_DEBUG_PRINTK("sctp_setsocktopt_bindx: sk %p addrs %p" 897 " addrs_size %d opt %d\n", sk, addrs, addrs_size, op); 898 899 if (unlikely(addrs_size <= 0)) 900 return -EINVAL; 901 902 /* Check the user passed a healthy pointer. */ 903 if (unlikely(!access_ok(VERIFY_READ, addrs, addrs_size))) 904 return -EFAULT; 905 906 /* Alloc space for the address array in kernel memory. */ 907 kaddrs = kmalloc(addrs_size, GFP_KERNEL); 908 if (unlikely(!kaddrs)) 909 return -ENOMEM; 910 911 if (__copy_from_user(kaddrs, addrs, addrs_size)) { 912 kfree(kaddrs); 913 return -EFAULT; 914 } 915 916 /* Walk through the addrs buffer and count the number of addresses. */ 917 addr_buf = kaddrs; 918 while (walk_size < addrs_size) { 919 sa_addr = (struct sockaddr *)addr_buf; 920 af = sctp_get_af_specific(sa_addr->sa_family); 921 922 /* If the address family is not supported or if this address 923 * causes the address buffer to overflow return EINVAL. 924 */ 925 if (!af || (walk_size + af->sockaddr_len) > addrs_size) { 926 kfree(kaddrs); 927 return -EINVAL; 928 } 929 addrcnt++; 930 addr_buf += af->sockaddr_len; 931 walk_size += af->sockaddr_len; 932 } 933 934 /* Do the work. */ 935 switch (op) { 936 case SCTP_BINDX_ADD_ADDR: 937 err = sctp_bindx_add(sk, kaddrs, addrcnt); 938 if (err) 939 goto out; 940 err = sctp_send_asconf_add_ip(sk, kaddrs, addrcnt); 941 break; 942 943 case SCTP_BINDX_REM_ADDR: 944 err = sctp_bindx_rem(sk, kaddrs, addrcnt); 945 if (err) 946 goto out; 947 err = sctp_send_asconf_del_ip(sk, kaddrs, addrcnt); 948 break; 949 950 default: 951 err = -EINVAL; 952 break; 953 }; 954 955 out: 956 kfree(kaddrs); 957 958 return err; 959 } 960 961 /* __sctp_connect(struct sock* sk, struct sockaddr *kaddrs, int addrs_size) 962 * 963 * Common routine for handling connect() and sctp_connectx(). 964 * Connect will come in with just a single address. 965 */ 966 static int __sctp_connect(struct sock* sk, 967 struct sockaddr *kaddrs, 968 int addrs_size) 969 { 970 struct sctp_sock *sp; 971 struct sctp_endpoint *ep; 972 struct sctp_association *asoc = NULL; 973 struct sctp_association *asoc2; 974 struct sctp_transport *transport; 975 union sctp_addr to; 976 struct sctp_af *af; 977 sctp_scope_t scope; 978 long timeo; 979 int err = 0; 980 int addrcnt = 0; 981 int walk_size = 0; 982 struct sockaddr *sa_addr; 983 void *addr_buf; 984 985 sp = sctp_sk(sk); 986 ep = sp->ep; 987 988 /* connect() cannot be done on a socket that is already in ESTABLISHED 989 * state - UDP-style peeled off socket or a TCP-style socket that 990 * is already connected. 991 * It cannot be done even on a TCP-style listening socket. 992 */ 993 if (sctp_sstate(sk, ESTABLISHED) || 994 (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))) { 995 err = -EISCONN; 996 goto out_free; 997 } 998 999 /* Walk through the addrs buffer and count the number of addresses. */ 1000 addr_buf = kaddrs; 1001 while (walk_size < addrs_size) { 1002 sa_addr = (struct sockaddr *)addr_buf; 1003 af = sctp_get_af_specific(sa_addr->sa_family); 1004 1005 /* If the address family is not supported or if this address 1006 * causes the address buffer to overflow return EINVAL. 1007 */ 1008 if (!af || (walk_size + af->sockaddr_len) > addrs_size) { 1009 err = -EINVAL; 1010 goto out_free; 1011 } 1012 1013 err = sctp_verify_addr(sk, (union sctp_addr *)sa_addr, 1014 af->sockaddr_len); 1015 if (err) 1016 goto out_free; 1017 1018 memcpy(&to, sa_addr, af->sockaddr_len); 1019 to.v4.sin_port = ntohs(to.v4.sin_port); 1020 1021 /* Check if there already is a matching association on the 1022 * endpoint (other than the one created here). 1023 */ 1024 asoc2 = sctp_endpoint_lookup_assoc(ep, &to, &transport); 1025 if (asoc2 && asoc2 != asoc) { 1026 if (asoc2->state >= SCTP_STATE_ESTABLISHED) 1027 err = -EISCONN; 1028 else 1029 err = -EALREADY; 1030 goto out_free; 1031 } 1032 1033 /* If we could not find a matching association on the endpoint, 1034 * make sure that there is no peeled-off association matching 1035 * the peer address even on another socket. 1036 */ 1037 if (sctp_endpoint_is_peeled_off(ep, &to)) { 1038 err = -EADDRNOTAVAIL; 1039 goto out_free; 1040 } 1041 1042 if (!asoc) { 1043 /* If a bind() or sctp_bindx() is not called prior to 1044 * an sctp_connectx() call, the system picks an 1045 * ephemeral port and will choose an address set 1046 * equivalent to binding with a wildcard address. 1047 */ 1048 if (!ep->base.bind_addr.port) { 1049 if (sctp_autobind(sk)) { 1050 err = -EAGAIN; 1051 goto out_free; 1052 } 1053 } else { 1054 /* 1055 * If an unprivileged user inherits a 1-many 1056 * style socket with open associations on a 1057 * privileged port, it MAY be permitted to 1058 * accept new associations, but it SHOULD NOT 1059 * be permitted to open new associations. 1060 */ 1061 if (ep->base.bind_addr.port < PROT_SOCK && 1062 !capable(CAP_NET_BIND_SERVICE)) { 1063 err = -EACCES; 1064 goto out_free; 1065 } 1066 } 1067 1068 scope = sctp_scope(&to); 1069 asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL); 1070 if (!asoc) { 1071 err = -ENOMEM; 1072 goto out_free; 1073 } 1074 } 1075 1076 /* Prime the peer's transport structures. */ 1077 transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL, 1078 SCTP_UNKNOWN); 1079 if (!transport) { 1080 err = -ENOMEM; 1081 goto out_free; 1082 } 1083 1084 addrcnt++; 1085 addr_buf += af->sockaddr_len; 1086 walk_size += af->sockaddr_len; 1087 } 1088 1089 err = sctp_assoc_set_bind_addr_from_ep(asoc, GFP_KERNEL); 1090 if (err < 0) { 1091 goto out_free; 1092 } 1093 1094 err = sctp_primitive_ASSOCIATE(asoc, NULL); 1095 if (err < 0) { 1096 goto out_free; 1097 } 1098 1099 /* Initialize sk's dport and daddr for getpeername() */ 1100 inet_sk(sk)->dport = htons(asoc->peer.port); 1101 af = sctp_get_af_specific(to.sa.sa_family); 1102 af->to_sk_daddr(&to, sk); 1103 sk->sk_err = 0; 1104 1105 timeo = sock_sndtimeo(sk, sk->sk_socket->file->f_flags & O_NONBLOCK); 1106 err = sctp_wait_for_connect(asoc, &timeo); 1107 1108 /* Don't free association on exit. */ 1109 asoc = NULL; 1110 1111 out_free: 1112 1113 SCTP_DEBUG_PRINTK("About to exit __sctp_connect() free asoc: %p" 1114 " kaddrs: %p err: %d\n", 1115 asoc, kaddrs, err); 1116 if (asoc) 1117 sctp_association_free(asoc); 1118 return err; 1119 } 1120 1121 /* Helper for tunneling sctp_connectx() requests through sctp_setsockopt() 1122 * 1123 * API 8.9 1124 * int sctp_connectx(int sd, struct sockaddr *addrs, int addrcnt); 1125 * 1126 * If sd is an IPv4 socket, the addresses passed must be IPv4 addresses. 1127 * If the sd is an IPv6 socket, the addresses passed can either be IPv4 1128 * or IPv6 addresses. 1129 * 1130 * A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see 1131 * Section 3.1.2 for this usage. 1132 * 1133 * addrs is a pointer to an array of one or more socket addresses. Each 1134 * address is contained in its appropriate structure (i.e. struct 1135 * sockaddr_in or struct sockaddr_in6) the family of the address type 1136 * must be used to distengish the address length (note that this 1137 * representation is termed a "packed array" of addresses). The caller 1138 * specifies the number of addresses in the array with addrcnt. 1139 * 1140 * On success, sctp_connectx() returns 0. On failure, sctp_connectx() returns 1141 * -1, and sets errno to the appropriate error code. 1142 * 1143 * For SCTP, the port given in each socket address must be the same, or 1144 * sctp_connectx() will fail, setting errno to EINVAL. 1145 * 1146 * An application can use sctp_connectx to initiate an association with 1147 * an endpoint that is multi-homed. Much like sctp_bindx() this call 1148 * allows a caller to specify multiple addresses at which a peer can be 1149 * reached. The way the SCTP stack uses the list of addresses to set up 1150 * the association is implementation dependant. This function only 1151 * specifies that the stack will try to make use of all the addresses in 1152 * the list when needed. 1153 * 1154 * Note that the list of addresses passed in is only used for setting up 1155 * the association. It does not necessarily equal the set of addresses 1156 * the peer uses for the resulting association. If the caller wants to 1157 * find out the set of peer addresses, it must use sctp_getpaddrs() to 1158 * retrieve them after the association has been set up. 1159 * 1160 * Basically do nothing but copying the addresses from user to kernel 1161 * land and invoking either sctp_connectx(). This is used for tunneling 1162 * the sctp_connectx() request through sctp_setsockopt() from userspace. 1163 * 1164 * We don't use copy_from_user() for optimization: we first do the 1165 * sanity checks (buffer size -fast- and access check-healthy 1166 * pointer); if all of those succeed, then we can alloc the memory 1167 * (expensive operation) needed to copy the data to kernel. Then we do 1168 * the copying without checking the user space area 1169 * (__copy_from_user()). 1170 * 1171 * On exit there is no need to do sockfd_put(), sys_setsockopt() does 1172 * it. 1173 * 1174 * sk The sk of the socket 1175 * addrs The pointer to the addresses in user land 1176 * addrssize Size of the addrs buffer 1177 * 1178 * Returns 0 if ok, <0 errno code on error. 1179 */ 1180 SCTP_STATIC int sctp_setsockopt_connectx(struct sock* sk, 1181 struct sockaddr __user *addrs, 1182 int addrs_size) 1183 { 1184 int err = 0; 1185 struct sockaddr *kaddrs; 1186 1187 SCTP_DEBUG_PRINTK("%s - sk %p addrs %p addrs_size %d\n", 1188 __FUNCTION__, sk, addrs, addrs_size); 1189 1190 if (unlikely(addrs_size <= 0)) 1191 return -EINVAL; 1192 1193 /* Check the user passed a healthy pointer. */ 1194 if (unlikely(!access_ok(VERIFY_READ, addrs, addrs_size))) 1195 return -EFAULT; 1196 1197 /* Alloc space for the address array in kernel memory. */ 1198 kaddrs = kmalloc(addrs_size, GFP_KERNEL); 1199 if (unlikely(!kaddrs)) 1200 return -ENOMEM; 1201 1202 if (__copy_from_user(kaddrs, addrs, addrs_size)) { 1203 err = -EFAULT; 1204 } else { 1205 err = __sctp_connect(sk, kaddrs, addrs_size); 1206 } 1207 1208 kfree(kaddrs); 1209 return err; 1210 } 1211 1212 /* API 3.1.4 close() - UDP Style Syntax 1213 * Applications use close() to perform graceful shutdown (as described in 1214 * Section 10.1 of [SCTP]) on ALL the associations currently represented 1215 * by a UDP-style socket. 1216 * 1217 * The syntax is 1218 * 1219 * ret = close(int sd); 1220 * 1221 * sd - the socket descriptor of the associations to be closed. 1222 * 1223 * To gracefully shutdown a specific association represented by the 1224 * UDP-style socket, an application should use the sendmsg() call, 1225 * passing no user data, but including the appropriate flag in the 1226 * ancillary data (see Section xxxx). 1227 * 1228 * If sd in the close() call is a branched-off socket representing only 1229 * one association, the shutdown is performed on that association only. 1230 * 1231 * 4.1.6 close() - TCP Style Syntax 1232 * 1233 * Applications use close() to gracefully close down an association. 1234 * 1235 * The syntax is: 1236 * 1237 * int close(int sd); 1238 * 1239 * sd - the socket descriptor of the association to be closed. 1240 * 1241 * After an application calls close() on a socket descriptor, no further 1242 * socket operations will succeed on that descriptor. 1243 * 1244 * API 7.1.4 SO_LINGER 1245 * 1246 * An application using the TCP-style socket can use this option to 1247 * perform the SCTP ABORT primitive. The linger option structure is: 1248 * 1249 * struct linger { 1250 * int l_onoff; // option on/off 1251 * int l_linger; // linger time 1252 * }; 1253 * 1254 * To enable the option, set l_onoff to 1. If the l_linger value is set 1255 * to 0, calling close() is the same as the ABORT primitive. If the 1256 * value is set to a negative value, the setsockopt() call will return 1257 * an error. If the value is set to a positive value linger_time, the 1258 * close() can be blocked for at most linger_time ms. If the graceful 1259 * shutdown phase does not finish during this period, close() will 1260 * return but the graceful shutdown phase continues in the system. 1261 */ 1262 SCTP_STATIC void sctp_close(struct sock *sk, long timeout) 1263 { 1264 struct sctp_endpoint *ep; 1265 struct sctp_association *asoc; 1266 struct list_head *pos, *temp; 1267 1268 SCTP_DEBUG_PRINTK("sctp_close(sk: 0x%p, timeout:%ld)\n", sk, timeout); 1269 1270 sctp_lock_sock(sk); 1271 sk->sk_shutdown = SHUTDOWN_MASK; 1272 1273 ep = sctp_sk(sk)->ep; 1274 1275 /* Walk all associations on an endpoint. */ 1276 list_for_each_safe(pos, temp, &ep->asocs) { 1277 asoc = list_entry(pos, struct sctp_association, asocs); 1278 1279 if (sctp_style(sk, TCP)) { 1280 /* A closed association can still be in the list if 1281 * it belongs to a TCP-style listening socket that is 1282 * not yet accepted. If so, free it. If not, send an 1283 * ABORT or SHUTDOWN based on the linger options. 1284 */ 1285 if (sctp_state(asoc, CLOSED)) { 1286 sctp_unhash_established(asoc); 1287 sctp_association_free(asoc); 1288 continue; 1289 } 1290 } 1291 1292 if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) { 1293 struct sctp_chunk *chunk; 1294 1295 chunk = sctp_make_abort_user(asoc, NULL, 0); 1296 if (chunk) 1297 sctp_primitive_ABORT(asoc, chunk); 1298 } else 1299 sctp_primitive_SHUTDOWN(asoc, NULL); 1300 } 1301 1302 /* Clean up any skbs sitting on the receive queue. */ 1303 sctp_queue_purge_ulpevents(&sk->sk_receive_queue); 1304 sctp_queue_purge_ulpevents(&sctp_sk(sk)->pd_lobby); 1305 1306 /* On a TCP-style socket, block for at most linger_time if set. */ 1307 if (sctp_style(sk, TCP) && timeout) 1308 sctp_wait_for_close(sk, timeout); 1309 1310 /* This will run the backlog queue. */ 1311 sctp_release_sock(sk); 1312 1313 /* Supposedly, no process has access to the socket, but 1314 * the net layers still may. 1315 */ 1316 sctp_local_bh_disable(); 1317 sctp_bh_lock_sock(sk); 1318 1319 /* Hold the sock, since sk_common_release() will put sock_put() 1320 * and we have just a little more cleanup. 1321 */ 1322 sock_hold(sk); 1323 sk_common_release(sk); 1324 1325 sctp_bh_unlock_sock(sk); 1326 sctp_local_bh_enable(); 1327 1328 sock_put(sk); 1329 1330 SCTP_DBG_OBJCNT_DEC(sock); 1331 } 1332 1333 /* Handle EPIPE error. */ 1334 static int sctp_error(struct sock *sk, int flags, int err) 1335 { 1336 if (err == -EPIPE) 1337 err = sock_error(sk) ? : -EPIPE; 1338 if (err == -EPIPE && !(flags & MSG_NOSIGNAL)) 1339 send_sig(SIGPIPE, current, 0); 1340 return err; 1341 } 1342 1343 /* API 3.1.3 sendmsg() - UDP Style Syntax 1344 * 1345 * An application uses sendmsg() and recvmsg() calls to transmit data to 1346 * and receive data from its peer. 1347 * 1348 * ssize_t sendmsg(int socket, const struct msghdr *message, 1349 * int flags); 1350 * 1351 * socket - the socket descriptor of the endpoint. 1352 * message - pointer to the msghdr structure which contains a single 1353 * user message and possibly some ancillary data. 1354 * 1355 * See Section 5 for complete description of the data 1356 * structures. 1357 * 1358 * flags - flags sent or received with the user message, see Section 1359 * 5 for complete description of the flags. 1360 * 1361 * Note: This function could use a rewrite especially when explicit 1362 * connect support comes in. 1363 */ 1364 /* BUG: We do not implement the equivalent of sk_stream_wait_memory(). */ 1365 1366 SCTP_STATIC int sctp_msghdr_parse(const struct msghdr *, sctp_cmsgs_t *); 1367 1368 SCTP_STATIC int sctp_sendmsg(struct kiocb *iocb, struct sock *sk, 1369 struct msghdr *msg, size_t msg_len) 1370 { 1371 struct sctp_sock *sp; 1372 struct sctp_endpoint *ep; 1373 struct sctp_association *new_asoc=NULL, *asoc=NULL; 1374 struct sctp_transport *transport, *chunk_tp; 1375 struct sctp_chunk *chunk; 1376 union sctp_addr to; 1377 struct sockaddr *msg_name = NULL; 1378 struct sctp_sndrcvinfo default_sinfo = { 0 }; 1379 struct sctp_sndrcvinfo *sinfo; 1380 struct sctp_initmsg *sinit; 1381 sctp_assoc_t associd = 0; 1382 sctp_cmsgs_t cmsgs = { NULL }; 1383 int err; 1384 sctp_scope_t scope; 1385 long timeo; 1386 __u16 sinfo_flags = 0; 1387 struct sctp_datamsg *datamsg; 1388 struct list_head *pos; 1389 int msg_flags = msg->msg_flags; 1390 1391 SCTP_DEBUG_PRINTK("sctp_sendmsg(sk: %p, msg: %p, msg_len: %zu)\n", 1392 sk, msg, msg_len); 1393 1394 err = 0; 1395 sp = sctp_sk(sk); 1396 ep = sp->ep; 1397 1398 SCTP_DEBUG_PRINTK("Using endpoint: %p.\n", ep); 1399 1400 /* We cannot send a message over a TCP-style listening socket. */ 1401 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)) { 1402 err = -EPIPE; 1403 goto out_nounlock; 1404 } 1405 1406 /* Parse out the SCTP CMSGs. */ 1407 err = sctp_msghdr_parse(msg, &cmsgs); 1408 1409 if (err) { 1410 SCTP_DEBUG_PRINTK("msghdr parse err = %x\n", err); 1411 goto out_nounlock; 1412 } 1413 1414 /* Fetch the destination address for this packet. This 1415 * address only selects the association--it is not necessarily 1416 * the address we will send to. 1417 * For a peeled-off socket, msg_name is ignored. 1418 */ 1419 if (!sctp_style(sk, UDP_HIGH_BANDWIDTH) && msg->msg_name) { 1420 int msg_namelen = msg->msg_namelen; 1421 1422 err = sctp_verify_addr(sk, (union sctp_addr *)msg->msg_name, 1423 msg_namelen); 1424 if (err) 1425 return err; 1426 1427 if (msg_namelen > sizeof(to)) 1428 msg_namelen = sizeof(to); 1429 memcpy(&to, msg->msg_name, msg_namelen); 1430 SCTP_DEBUG_PRINTK("Just memcpy'd. msg_name is " 1431 "0x%x:%u.\n", 1432 to.v4.sin_addr.s_addr, to.v4.sin_port); 1433 1434 to.v4.sin_port = ntohs(to.v4.sin_port); 1435 msg_name = msg->msg_name; 1436 } 1437 1438 sinfo = cmsgs.info; 1439 sinit = cmsgs.init; 1440 1441 /* Did the user specify SNDRCVINFO? */ 1442 if (sinfo) { 1443 sinfo_flags = sinfo->sinfo_flags; 1444 associd = sinfo->sinfo_assoc_id; 1445 } 1446 1447 SCTP_DEBUG_PRINTK("msg_len: %zu, sinfo_flags: 0x%x\n", 1448 msg_len, sinfo_flags); 1449 1450 /* SCTP_EOF or SCTP_ABORT cannot be set on a TCP-style socket. */ 1451 if (sctp_style(sk, TCP) && (sinfo_flags & (SCTP_EOF | SCTP_ABORT))) { 1452 err = -EINVAL; 1453 goto out_nounlock; 1454 } 1455 1456 /* If SCTP_EOF is set, no data can be sent. Disallow sending zero 1457 * length messages when SCTP_EOF|SCTP_ABORT is not set. 1458 * If SCTP_ABORT is set, the message length could be non zero with 1459 * the msg_iov set to the user abort reason. 1460 */ 1461 if (((sinfo_flags & SCTP_EOF) && (msg_len > 0)) || 1462 (!(sinfo_flags & (SCTP_EOF|SCTP_ABORT)) && (msg_len == 0))) { 1463 err = -EINVAL; 1464 goto out_nounlock; 1465 } 1466 1467 /* If SCTP_ADDR_OVER is set, there must be an address 1468 * specified in msg_name. 1469 */ 1470 if ((sinfo_flags & SCTP_ADDR_OVER) && (!msg->msg_name)) { 1471 err = -EINVAL; 1472 goto out_nounlock; 1473 } 1474 1475 transport = NULL; 1476 1477 SCTP_DEBUG_PRINTK("About to look up association.\n"); 1478 1479 sctp_lock_sock(sk); 1480 1481 /* If a msg_name has been specified, assume this is to be used. */ 1482 if (msg_name) { 1483 /* Look for a matching association on the endpoint. */ 1484 asoc = sctp_endpoint_lookup_assoc(ep, &to, &transport); 1485 if (!asoc) { 1486 /* If we could not find a matching association on the 1487 * endpoint, make sure that it is not a TCP-style 1488 * socket that already has an association or there is 1489 * no peeled-off association on another socket. 1490 */ 1491 if ((sctp_style(sk, TCP) && 1492 sctp_sstate(sk, ESTABLISHED)) || 1493 sctp_endpoint_is_peeled_off(ep, &to)) { 1494 err = -EADDRNOTAVAIL; 1495 goto out_unlock; 1496 } 1497 } 1498 } else { 1499 asoc = sctp_id2assoc(sk, associd); 1500 if (!asoc) { 1501 err = -EPIPE; 1502 goto out_unlock; 1503 } 1504 } 1505 1506 if (asoc) { 1507 SCTP_DEBUG_PRINTK("Just looked up association: %p.\n", asoc); 1508 1509 /* We cannot send a message on a TCP-style SCTP_SS_ESTABLISHED 1510 * socket that has an association in CLOSED state. This can 1511 * happen when an accepted socket has an association that is 1512 * already CLOSED. 1513 */ 1514 if (sctp_state(asoc, CLOSED) && sctp_style(sk, TCP)) { 1515 err = -EPIPE; 1516 goto out_unlock; 1517 } 1518 1519 if (sinfo_flags & SCTP_EOF) { 1520 SCTP_DEBUG_PRINTK("Shutting down association: %p\n", 1521 asoc); 1522 sctp_primitive_SHUTDOWN(asoc, NULL); 1523 err = 0; 1524 goto out_unlock; 1525 } 1526 if (sinfo_flags & SCTP_ABORT) { 1527 struct sctp_chunk *chunk; 1528 1529 chunk = sctp_make_abort_user(asoc, msg, msg_len); 1530 if (!chunk) { 1531 err = -ENOMEM; 1532 goto out_unlock; 1533 } 1534 1535 SCTP_DEBUG_PRINTK("Aborting association: %p\n", asoc); 1536 sctp_primitive_ABORT(asoc, chunk); 1537 err = 0; 1538 goto out_unlock; 1539 } 1540 } 1541 1542 /* Do we need to create the association? */ 1543 if (!asoc) { 1544 SCTP_DEBUG_PRINTK("There is no association yet.\n"); 1545 1546 if (sinfo_flags & (SCTP_EOF | SCTP_ABORT)) { 1547 err = -EINVAL; 1548 goto out_unlock; 1549 } 1550 1551 /* Check for invalid stream against the stream counts, 1552 * either the default or the user specified stream counts. 1553 */ 1554 if (sinfo) { 1555 if (!sinit || (sinit && !sinit->sinit_num_ostreams)) { 1556 /* Check against the defaults. */ 1557 if (sinfo->sinfo_stream >= 1558 sp->initmsg.sinit_num_ostreams) { 1559 err = -EINVAL; 1560 goto out_unlock; 1561 } 1562 } else { 1563 /* Check against the requested. */ 1564 if (sinfo->sinfo_stream >= 1565 sinit->sinit_num_ostreams) { 1566 err = -EINVAL; 1567 goto out_unlock; 1568 } 1569 } 1570 } 1571 1572 /* 1573 * API 3.1.2 bind() - UDP Style Syntax 1574 * If a bind() or sctp_bindx() is not called prior to a 1575 * sendmsg() call that initiates a new association, the 1576 * system picks an ephemeral port and will choose an address 1577 * set equivalent to binding with a wildcard address. 1578 */ 1579 if (!ep->base.bind_addr.port) { 1580 if (sctp_autobind(sk)) { 1581 err = -EAGAIN; 1582 goto out_unlock; 1583 } 1584 } else { 1585 /* 1586 * If an unprivileged user inherits a one-to-many 1587 * style socket with open associations on a privileged 1588 * port, it MAY be permitted to accept new associations, 1589 * but it SHOULD NOT be permitted to open new 1590 * associations. 1591 */ 1592 if (ep->base.bind_addr.port < PROT_SOCK && 1593 !capable(CAP_NET_BIND_SERVICE)) { 1594 err = -EACCES; 1595 goto out_unlock; 1596 } 1597 } 1598 1599 scope = sctp_scope(&to); 1600 new_asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL); 1601 if (!new_asoc) { 1602 err = -ENOMEM; 1603 goto out_unlock; 1604 } 1605 asoc = new_asoc; 1606 1607 /* If the SCTP_INIT ancillary data is specified, set all 1608 * the association init values accordingly. 1609 */ 1610 if (sinit) { 1611 if (sinit->sinit_num_ostreams) { 1612 asoc->c.sinit_num_ostreams = 1613 sinit->sinit_num_ostreams; 1614 } 1615 if (sinit->sinit_max_instreams) { 1616 asoc->c.sinit_max_instreams = 1617 sinit->sinit_max_instreams; 1618 } 1619 if (sinit->sinit_max_attempts) { 1620 asoc->max_init_attempts 1621 = sinit->sinit_max_attempts; 1622 } 1623 if (sinit->sinit_max_init_timeo) { 1624 asoc->max_init_timeo = 1625 msecs_to_jiffies(sinit->sinit_max_init_timeo); 1626 } 1627 } 1628 1629 /* Prime the peer's transport structures. */ 1630 transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL, SCTP_UNKNOWN); 1631 if (!transport) { 1632 err = -ENOMEM; 1633 goto out_free; 1634 } 1635 err = sctp_assoc_set_bind_addr_from_ep(asoc, GFP_KERNEL); 1636 if (err < 0) { 1637 err = -ENOMEM; 1638 goto out_free; 1639 } 1640 } 1641 1642 /* ASSERT: we have a valid association at this point. */ 1643 SCTP_DEBUG_PRINTK("We have a valid association.\n"); 1644 1645 if (!sinfo) { 1646 /* If the user didn't specify SNDRCVINFO, make up one with 1647 * some defaults. 1648 */ 1649 default_sinfo.sinfo_stream = asoc->default_stream; 1650 default_sinfo.sinfo_flags = asoc->default_flags; 1651 default_sinfo.sinfo_ppid = asoc->default_ppid; 1652 default_sinfo.sinfo_context = asoc->default_context; 1653 default_sinfo.sinfo_timetolive = asoc->default_timetolive; 1654 default_sinfo.sinfo_assoc_id = sctp_assoc2id(asoc); 1655 sinfo = &default_sinfo; 1656 } 1657 1658 /* API 7.1.7, the sndbuf size per association bounds the 1659 * maximum size of data that can be sent in a single send call. 1660 */ 1661 if (msg_len > sk->sk_sndbuf) { 1662 err = -EMSGSIZE; 1663 goto out_free; 1664 } 1665 1666 /* If fragmentation is disabled and the message length exceeds the 1667 * association fragmentation point, return EMSGSIZE. The I-D 1668 * does not specify what this error is, but this looks like 1669 * a great fit. 1670 */ 1671 if (sctp_sk(sk)->disable_fragments && (msg_len > asoc->frag_point)) { 1672 err = -EMSGSIZE; 1673 goto out_free; 1674 } 1675 1676 if (sinfo) { 1677 /* Check for invalid stream. */ 1678 if (sinfo->sinfo_stream >= asoc->c.sinit_num_ostreams) { 1679 err = -EINVAL; 1680 goto out_free; 1681 } 1682 } 1683 1684 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT); 1685 if (!sctp_wspace(asoc)) { 1686 err = sctp_wait_for_sndbuf(asoc, &timeo, msg_len); 1687 if (err) 1688 goto out_free; 1689 } 1690 1691 /* If an address is passed with the sendto/sendmsg call, it is used 1692 * to override the primary destination address in the TCP model, or 1693 * when SCTP_ADDR_OVER flag is set in the UDP model. 1694 */ 1695 if ((sctp_style(sk, TCP) && msg_name) || 1696 (sinfo_flags & SCTP_ADDR_OVER)) { 1697 chunk_tp = sctp_assoc_lookup_paddr(asoc, &to); 1698 if (!chunk_tp) { 1699 err = -EINVAL; 1700 goto out_free; 1701 } 1702 } else 1703 chunk_tp = NULL; 1704 1705 /* Auto-connect, if we aren't connected already. */ 1706 if (sctp_state(asoc, CLOSED)) { 1707 err = sctp_primitive_ASSOCIATE(asoc, NULL); 1708 if (err < 0) 1709 goto out_free; 1710 SCTP_DEBUG_PRINTK("We associated primitively.\n"); 1711 } 1712 1713 /* Break the message into multiple chunks of maximum size. */ 1714 datamsg = sctp_datamsg_from_user(asoc, sinfo, msg, msg_len); 1715 if (!datamsg) { 1716 err = -ENOMEM; 1717 goto out_free; 1718 } 1719 1720 /* Now send the (possibly) fragmented message. */ 1721 list_for_each(pos, &datamsg->chunks) { 1722 chunk = list_entry(pos, struct sctp_chunk, frag_list); 1723 sctp_datamsg_track(chunk); 1724 1725 /* Do accounting for the write space. */ 1726 sctp_set_owner_w(chunk); 1727 1728 chunk->transport = chunk_tp; 1729 1730 /* Send it to the lower layers. Note: all chunks 1731 * must either fail or succeed. The lower layer 1732 * works that way today. Keep it that way or this 1733 * breaks. 1734 */ 1735 err = sctp_primitive_SEND(asoc, chunk); 1736 /* Did the lower layer accept the chunk? */ 1737 if (err) 1738 sctp_chunk_free(chunk); 1739 SCTP_DEBUG_PRINTK("We sent primitively.\n"); 1740 } 1741 1742 sctp_datamsg_free(datamsg); 1743 if (err) 1744 goto out_free; 1745 else 1746 err = msg_len; 1747 1748 /* If we are already past ASSOCIATE, the lower 1749 * layers are responsible for association cleanup. 1750 */ 1751 goto out_unlock; 1752 1753 out_free: 1754 if (new_asoc) 1755 sctp_association_free(asoc); 1756 out_unlock: 1757 sctp_release_sock(sk); 1758 1759 out_nounlock: 1760 return sctp_error(sk, msg_flags, err); 1761 1762 #if 0 1763 do_sock_err: 1764 if (msg_len) 1765 err = msg_len; 1766 else 1767 err = sock_error(sk); 1768 goto out; 1769 1770 do_interrupted: 1771 if (msg_len) 1772 err = msg_len; 1773 goto out; 1774 #endif /* 0 */ 1775 } 1776 1777 /* This is an extended version of skb_pull() that removes the data from the 1778 * start of a skb even when data is spread across the list of skb's in the 1779 * frag_list. len specifies the total amount of data that needs to be removed. 1780 * when 'len' bytes could be removed from the skb, it returns 0. 1781 * If 'len' exceeds the total skb length, it returns the no. of bytes that 1782 * could not be removed. 1783 */ 1784 static int sctp_skb_pull(struct sk_buff *skb, int len) 1785 { 1786 struct sk_buff *list; 1787 int skb_len = skb_headlen(skb); 1788 int rlen; 1789 1790 if (len <= skb_len) { 1791 __skb_pull(skb, len); 1792 return 0; 1793 } 1794 len -= skb_len; 1795 __skb_pull(skb, skb_len); 1796 1797 for (list = skb_shinfo(skb)->frag_list; list; list = list->next) { 1798 rlen = sctp_skb_pull(list, len); 1799 skb->len -= (len-rlen); 1800 skb->data_len -= (len-rlen); 1801 1802 if (!rlen) 1803 return 0; 1804 1805 len = rlen; 1806 } 1807 1808 return len; 1809 } 1810 1811 /* API 3.1.3 recvmsg() - UDP Style Syntax 1812 * 1813 * ssize_t recvmsg(int socket, struct msghdr *message, 1814 * int flags); 1815 * 1816 * socket - the socket descriptor of the endpoint. 1817 * message - pointer to the msghdr structure which contains a single 1818 * user message and possibly some ancillary data. 1819 * 1820 * See Section 5 for complete description of the data 1821 * structures. 1822 * 1823 * flags - flags sent or received with the user message, see Section 1824 * 5 for complete description of the flags. 1825 */ 1826 static struct sk_buff *sctp_skb_recv_datagram(struct sock *, int, int, int *); 1827 1828 SCTP_STATIC int sctp_recvmsg(struct kiocb *iocb, struct sock *sk, 1829 struct msghdr *msg, size_t len, int noblock, 1830 int flags, int *addr_len) 1831 { 1832 struct sctp_ulpevent *event = NULL; 1833 struct sctp_sock *sp = sctp_sk(sk); 1834 struct sk_buff *skb; 1835 int copied; 1836 int err = 0; 1837 int skb_len; 1838 1839 SCTP_DEBUG_PRINTK("sctp_recvmsg(%s: %p, %s: %p, %s: %zd, %s: %d, %s: " 1840 "0x%x, %s: %p)\n", "sk", sk, "msghdr", msg, 1841 "len", len, "knoblauch", noblock, 1842 "flags", flags, "addr_len", addr_len); 1843 1844 sctp_lock_sock(sk); 1845 1846 if (sctp_style(sk, TCP) && !sctp_sstate(sk, ESTABLISHED)) { 1847 err = -ENOTCONN; 1848 goto out; 1849 } 1850 1851 skb = sctp_skb_recv_datagram(sk, flags, noblock, &err); 1852 if (!skb) 1853 goto out; 1854 1855 /* Get the total length of the skb including any skb's in the 1856 * frag_list. 1857 */ 1858 skb_len = skb->len; 1859 1860 copied = skb_len; 1861 if (copied > len) 1862 copied = len; 1863 1864 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 1865 1866 event = sctp_skb2event(skb); 1867 1868 if (err) 1869 goto out_free; 1870 1871 sock_recv_timestamp(msg, sk, skb); 1872 if (sctp_ulpevent_is_notification(event)) { 1873 msg->msg_flags |= MSG_NOTIFICATION; 1874 sp->pf->event_msgname(event, msg->msg_name, addr_len); 1875 } else { 1876 sp->pf->skb_msgname(skb, msg->msg_name, addr_len); 1877 } 1878 1879 /* Check if we allow SCTP_SNDRCVINFO. */ 1880 if (sp->subscribe.sctp_data_io_event) 1881 sctp_ulpevent_read_sndrcvinfo(event, msg); 1882 #if 0 1883 /* FIXME: we should be calling IP/IPv6 layers. */ 1884 if (sk->sk_protinfo.af_inet.cmsg_flags) 1885 ip_cmsg_recv(msg, skb); 1886 #endif 1887 1888 err = copied; 1889 1890 /* If skb's length exceeds the user's buffer, update the skb and 1891 * push it back to the receive_queue so that the next call to 1892 * recvmsg() will return the remaining data. Don't set MSG_EOR. 1893 */ 1894 if (skb_len > copied) { 1895 msg->msg_flags &= ~MSG_EOR; 1896 if (flags & MSG_PEEK) 1897 goto out_free; 1898 sctp_skb_pull(skb, copied); 1899 skb_queue_head(&sk->sk_receive_queue, skb); 1900 1901 /* When only partial message is copied to the user, increase 1902 * rwnd by that amount. If all the data in the skb is read, 1903 * rwnd is updated when the event is freed. 1904 */ 1905 sctp_assoc_rwnd_increase(event->asoc, copied); 1906 goto out; 1907 } else if ((event->msg_flags & MSG_NOTIFICATION) || 1908 (event->msg_flags & MSG_EOR)) 1909 msg->msg_flags |= MSG_EOR; 1910 else 1911 msg->msg_flags &= ~MSG_EOR; 1912 1913 out_free: 1914 if (flags & MSG_PEEK) { 1915 /* Release the skb reference acquired after peeking the skb in 1916 * sctp_skb_recv_datagram(). 1917 */ 1918 kfree_skb(skb); 1919 } else { 1920 /* Free the event which includes releasing the reference to 1921 * the owner of the skb, freeing the skb and updating the 1922 * rwnd. 1923 */ 1924 sctp_ulpevent_free(event); 1925 } 1926 out: 1927 sctp_release_sock(sk); 1928 return err; 1929 } 1930 1931 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS) 1932 * 1933 * This option is a on/off flag. If enabled no SCTP message 1934 * fragmentation will be performed. Instead if a message being sent 1935 * exceeds the current PMTU size, the message will NOT be sent and 1936 * instead a error will be indicated to the user. 1937 */ 1938 static int sctp_setsockopt_disable_fragments(struct sock *sk, 1939 char __user *optval, int optlen) 1940 { 1941 int val; 1942 1943 if (optlen < sizeof(int)) 1944 return -EINVAL; 1945 1946 if (get_user(val, (int __user *)optval)) 1947 return -EFAULT; 1948 1949 sctp_sk(sk)->disable_fragments = (val == 0) ? 0 : 1; 1950 1951 return 0; 1952 } 1953 1954 static int sctp_setsockopt_events(struct sock *sk, char __user *optval, 1955 int optlen) 1956 { 1957 if (optlen != sizeof(struct sctp_event_subscribe)) 1958 return -EINVAL; 1959 if (copy_from_user(&sctp_sk(sk)->subscribe, optval, optlen)) 1960 return -EFAULT; 1961 return 0; 1962 } 1963 1964 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE) 1965 * 1966 * This socket option is applicable to the UDP-style socket only. When 1967 * set it will cause associations that are idle for more than the 1968 * specified number of seconds to automatically close. An association 1969 * being idle is defined an association that has NOT sent or received 1970 * user data. The special value of '0' indicates that no automatic 1971 * close of any associations should be performed. The option expects an 1972 * integer defining the number of seconds of idle time before an 1973 * association is closed. 1974 */ 1975 static int sctp_setsockopt_autoclose(struct sock *sk, char __user *optval, 1976 int optlen) 1977 { 1978 struct sctp_sock *sp = sctp_sk(sk); 1979 1980 /* Applicable to UDP-style socket only */ 1981 if (sctp_style(sk, TCP)) 1982 return -EOPNOTSUPP; 1983 if (optlen != sizeof(int)) 1984 return -EINVAL; 1985 if (copy_from_user(&sp->autoclose, optval, optlen)) 1986 return -EFAULT; 1987 1988 return 0; 1989 } 1990 1991 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS) 1992 * 1993 * Applications can enable or disable heartbeats for any peer address of 1994 * an association, modify an address's heartbeat interval, force a 1995 * heartbeat to be sent immediately, and adjust the address's maximum 1996 * number of retransmissions sent before an address is considered 1997 * unreachable. The following structure is used to access and modify an 1998 * address's parameters: 1999 * 2000 * struct sctp_paddrparams { 2001 * sctp_assoc_t spp_assoc_id; 2002 * struct sockaddr_storage spp_address; 2003 * uint32_t spp_hbinterval; 2004 * uint16_t spp_pathmaxrxt; 2005 * uint32_t spp_pathmtu; 2006 * uint32_t spp_sackdelay; 2007 * uint32_t spp_flags; 2008 * }; 2009 * 2010 * spp_assoc_id - (one-to-many style socket) This is filled in the 2011 * application, and identifies the association for 2012 * this query. 2013 * spp_address - This specifies which address is of interest. 2014 * spp_hbinterval - This contains the value of the heartbeat interval, 2015 * in milliseconds. If a value of zero 2016 * is present in this field then no changes are to 2017 * be made to this parameter. 2018 * spp_pathmaxrxt - This contains the maximum number of 2019 * retransmissions before this address shall be 2020 * considered unreachable. If a value of zero 2021 * is present in this field then no changes are to 2022 * be made to this parameter. 2023 * spp_pathmtu - When Path MTU discovery is disabled the value 2024 * specified here will be the "fixed" path mtu. 2025 * Note that if the spp_address field is empty 2026 * then all associations on this address will 2027 * have this fixed path mtu set upon them. 2028 * 2029 * spp_sackdelay - When delayed sack is enabled, this value specifies 2030 * the number of milliseconds that sacks will be delayed 2031 * for. This value will apply to all addresses of an 2032 * association if the spp_address field is empty. Note 2033 * also, that if delayed sack is enabled and this 2034 * value is set to 0, no change is made to the last 2035 * recorded delayed sack timer value. 2036 * 2037 * spp_flags - These flags are used to control various features 2038 * on an association. The flag field may contain 2039 * zero or more of the following options. 2040 * 2041 * SPP_HB_ENABLE - Enable heartbeats on the 2042 * specified address. Note that if the address 2043 * field is empty all addresses for the association 2044 * have heartbeats enabled upon them. 2045 * 2046 * SPP_HB_DISABLE - Disable heartbeats on the 2047 * speicifed address. Note that if the address 2048 * field is empty all addresses for the association 2049 * will have their heartbeats disabled. Note also 2050 * that SPP_HB_ENABLE and SPP_HB_DISABLE are 2051 * mutually exclusive, only one of these two should 2052 * be specified. Enabling both fields will have 2053 * undetermined results. 2054 * 2055 * SPP_HB_DEMAND - Request a user initiated heartbeat 2056 * to be made immediately. 2057 * 2058 * SPP_PMTUD_ENABLE - This field will enable PMTU 2059 * discovery upon the specified address. Note that 2060 * if the address feild is empty then all addresses 2061 * on the association are effected. 2062 * 2063 * SPP_PMTUD_DISABLE - This field will disable PMTU 2064 * discovery upon the specified address. Note that 2065 * if the address feild is empty then all addresses 2066 * on the association are effected. Not also that 2067 * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually 2068 * exclusive. Enabling both will have undetermined 2069 * results. 2070 * 2071 * SPP_SACKDELAY_ENABLE - Setting this flag turns 2072 * on delayed sack. The time specified in spp_sackdelay 2073 * is used to specify the sack delay for this address. Note 2074 * that if spp_address is empty then all addresses will 2075 * enable delayed sack and take on the sack delay 2076 * value specified in spp_sackdelay. 2077 * SPP_SACKDELAY_DISABLE - Setting this flag turns 2078 * off delayed sack. If the spp_address field is blank then 2079 * delayed sack is disabled for the entire association. Note 2080 * also that this field is mutually exclusive to 2081 * SPP_SACKDELAY_ENABLE, setting both will have undefined 2082 * results. 2083 */ 2084 static int sctp_apply_peer_addr_params(struct sctp_paddrparams *params, 2085 struct sctp_transport *trans, 2086 struct sctp_association *asoc, 2087 struct sctp_sock *sp, 2088 int hb_change, 2089 int pmtud_change, 2090 int sackdelay_change) 2091 { 2092 int error; 2093 2094 if (params->spp_flags & SPP_HB_DEMAND && trans) { 2095 error = sctp_primitive_REQUESTHEARTBEAT (trans->asoc, trans); 2096 if (error) 2097 return error; 2098 } 2099 2100 if (params->spp_hbinterval) { 2101 if (trans) { 2102 trans->hbinterval = msecs_to_jiffies(params->spp_hbinterval); 2103 } else if (asoc) { 2104 asoc->hbinterval = msecs_to_jiffies(params->spp_hbinterval); 2105 } else { 2106 sp->hbinterval = params->spp_hbinterval; 2107 } 2108 } 2109 2110 if (hb_change) { 2111 if (trans) { 2112 trans->param_flags = 2113 (trans->param_flags & ~SPP_HB) | hb_change; 2114 } else if (asoc) { 2115 asoc->param_flags = 2116 (asoc->param_flags & ~SPP_HB) | hb_change; 2117 } else { 2118 sp->param_flags = 2119 (sp->param_flags & ~SPP_HB) | hb_change; 2120 } 2121 } 2122 2123 if (params->spp_pathmtu) { 2124 if (trans) { 2125 trans->pathmtu = params->spp_pathmtu; 2126 sctp_assoc_sync_pmtu(asoc); 2127 } else if (asoc) { 2128 asoc->pathmtu = params->spp_pathmtu; 2129 sctp_frag_point(sp, params->spp_pathmtu); 2130 } else { 2131 sp->pathmtu = params->spp_pathmtu; 2132 } 2133 } 2134 2135 if (pmtud_change) { 2136 if (trans) { 2137 int update = (trans->param_flags & SPP_PMTUD_DISABLE) && 2138 (params->spp_flags & SPP_PMTUD_ENABLE); 2139 trans->param_flags = 2140 (trans->param_flags & ~SPP_PMTUD) | pmtud_change; 2141 if (update) { 2142 sctp_transport_pmtu(trans); 2143 sctp_assoc_sync_pmtu(asoc); 2144 } 2145 } else if (asoc) { 2146 asoc->param_flags = 2147 (asoc->param_flags & ~SPP_PMTUD) | pmtud_change; 2148 } else { 2149 sp->param_flags = 2150 (sp->param_flags & ~SPP_PMTUD) | pmtud_change; 2151 } 2152 } 2153 2154 if (params->spp_sackdelay) { 2155 if (trans) { 2156 trans->sackdelay = 2157 msecs_to_jiffies(params->spp_sackdelay); 2158 } else if (asoc) { 2159 asoc->sackdelay = 2160 msecs_to_jiffies(params->spp_sackdelay); 2161 } else { 2162 sp->sackdelay = params->spp_sackdelay; 2163 } 2164 } 2165 2166 if (sackdelay_change) { 2167 if (trans) { 2168 trans->param_flags = 2169 (trans->param_flags & ~SPP_SACKDELAY) | 2170 sackdelay_change; 2171 } else if (asoc) { 2172 asoc->param_flags = 2173 (asoc->param_flags & ~SPP_SACKDELAY) | 2174 sackdelay_change; 2175 } else { 2176 sp->param_flags = 2177 (sp->param_flags & ~SPP_SACKDELAY) | 2178 sackdelay_change; 2179 } 2180 } 2181 2182 if (params->spp_pathmaxrxt) { 2183 if (trans) { 2184 trans->pathmaxrxt = params->spp_pathmaxrxt; 2185 } else if (asoc) { 2186 asoc->pathmaxrxt = params->spp_pathmaxrxt; 2187 } else { 2188 sp->pathmaxrxt = params->spp_pathmaxrxt; 2189 } 2190 } 2191 2192 return 0; 2193 } 2194 2195 static int sctp_setsockopt_peer_addr_params(struct sock *sk, 2196 char __user *optval, int optlen) 2197 { 2198 struct sctp_paddrparams params; 2199 struct sctp_transport *trans = NULL; 2200 struct sctp_association *asoc = NULL; 2201 struct sctp_sock *sp = sctp_sk(sk); 2202 int error; 2203 int hb_change, pmtud_change, sackdelay_change; 2204 2205 if (optlen != sizeof(struct sctp_paddrparams)) 2206 return - EINVAL; 2207 2208 if (copy_from_user(¶ms, optval, optlen)) 2209 return -EFAULT; 2210 2211 /* Validate flags and value parameters. */ 2212 hb_change = params.spp_flags & SPP_HB; 2213 pmtud_change = params.spp_flags & SPP_PMTUD; 2214 sackdelay_change = params.spp_flags & SPP_SACKDELAY; 2215 2216 if (hb_change == SPP_HB || 2217 pmtud_change == SPP_PMTUD || 2218 sackdelay_change == SPP_SACKDELAY || 2219 params.spp_sackdelay > 500 || 2220 (params.spp_pathmtu 2221 && params.spp_pathmtu < SCTP_DEFAULT_MINSEGMENT)) 2222 return -EINVAL; 2223 2224 /* If an address other than INADDR_ANY is specified, and 2225 * no transport is found, then the request is invalid. 2226 */ 2227 if (!sctp_is_any(( union sctp_addr *)¶ms.spp_address)) { 2228 trans = sctp_addr_id2transport(sk, ¶ms.spp_address, 2229 params.spp_assoc_id); 2230 if (!trans) 2231 return -EINVAL; 2232 } 2233 2234 /* Get association, if assoc_id != 0 and the socket is a one 2235 * to many style socket, and an association was not found, then 2236 * the id was invalid. 2237 */ 2238 asoc = sctp_id2assoc(sk, params.spp_assoc_id); 2239 if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP)) 2240 return -EINVAL; 2241 2242 /* Heartbeat demand can only be sent on a transport or 2243 * association, but not a socket. 2244 */ 2245 if (params.spp_flags & SPP_HB_DEMAND && !trans && !asoc) 2246 return -EINVAL; 2247 2248 /* Process parameters. */ 2249 error = sctp_apply_peer_addr_params(¶ms, trans, asoc, sp, 2250 hb_change, pmtud_change, 2251 sackdelay_change); 2252 2253 if (error) 2254 return error; 2255 2256 /* If changes are for association, also apply parameters to each 2257 * transport. 2258 */ 2259 if (!trans && asoc) { 2260 struct list_head *pos; 2261 2262 list_for_each(pos, &asoc->peer.transport_addr_list) { 2263 trans = list_entry(pos, struct sctp_transport, 2264 transports); 2265 sctp_apply_peer_addr_params(¶ms, trans, asoc, sp, 2266 hb_change, pmtud_change, 2267 sackdelay_change); 2268 } 2269 } 2270 2271 return 0; 2272 } 2273 2274 /* 7.1.24. Delayed Ack Timer (SCTP_DELAYED_ACK_TIME) 2275 * 2276 * This options will get or set the delayed ack timer. The time is set 2277 * in milliseconds. If the assoc_id is 0, then this sets or gets the 2278 * endpoints default delayed ack timer value. If the assoc_id field is 2279 * non-zero, then the set or get effects the specified association. 2280 * 2281 * struct sctp_assoc_value { 2282 * sctp_assoc_t assoc_id; 2283 * uint32_t assoc_value; 2284 * }; 2285 * 2286 * assoc_id - This parameter, indicates which association the 2287 * user is preforming an action upon. Note that if 2288 * this field's value is zero then the endpoints 2289 * default value is changed (effecting future 2290 * associations only). 2291 * 2292 * assoc_value - This parameter contains the number of milliseconds 2293 * that the user is requesting the delayed ACK timer 2294 * be set to. Note that this value is defined in 2295 * the standard to be between 200 and 500 milliseconds. 2296 * 2297 * Note: a value of zero will leave the value alone, 2298 * but disable SACK delay. A non-zero value will also 2299 * enable SACK delay. 2300 */ 2301 2302 static int sctp_setsockopt_delayed_ack_time(struct sock *sk, 2303 char __user *optval, int optlen) 2304 { 2305 struct sctp_assoc_value params; 2306 struct sctp_transport *trans = NULL; 2307 struct sctp_association *asoc = NULL; 2308 struct sctp_sock *sp = sctp_sk(sk); 2309 2310 if (optlen != sizeof(struct sctp_assoc_value)) 2311 return - EINVAL; 2312 2313 if (copy_from_user(¶ms, optval, optlen)) 2314 return -EFAULT; 2315 2316 /* Validate value parameter. */ 2317 if (params.assoc_value > 500) 2318 return -EINVAL; 2319 2320 /* Get association, if assoc_id != 0 and the socket is a one 2321 * to many style socket, and an association was not found, then 2322 * the id was invalid. 2323 */ 2324 asoc = sctp_id2assoc(sk, params.assoc_id); 2325 if (!asoc && params.assoc_id && sctp_style(sk, UDP)) 2326 return -EINVAL; 2327 2328 if (params.assoc_value) { 2329 if (asoc) { 2330 asoc->sackdelay = 2331 msecs_to_jiffies(params.assoc_value); 2332 asoc->param_flags = 2333 (asoc->param_flags & ~SPP_SACKDELAY) | 2334 SPP_SACKDELAY_ENABLE; 2335 } else { 2336 sp->sackdelay = params.assoc_value; 2337 sp->param_flags = 2338 (sp->param_flags & ~SPP_SACKDELAY) | 2339 SPP_SACKDELAY_ENABLE; 2340 } 2341 } else { 2342 if (asoc) { 2343 asoc->param_flags = 2344 (asoc->param_flags & ~SPP_SACKDELAY) | 2345 SPP_SACKDELAY_DISABLE; 2346 } else { 2347 sp->param_flags = 2348 (sp->param_flags & ~SPP_SACKDELAY) | 2349 SPP_SACKDELAY_DISABLE; 2350 } 2351 } 2352 2353 /* If change is for association, also apply to each transport. */ 2354 if (asoc) { 2355 struct list_head *pos; 2356 2357 list_for_each(pos, &asoc->peer.transport_addr_list) { 2358 trans = list_entry(pos, struct sctp_transport, 2359 transports); 2360 if (params.assoc_value) { 2361 trans->sackdelay = 2362 msecs_to_jiffies(params.assoc_value); 2363 trans->param_flags = 2364 (trans->param_flags & ~SPP_SACKDELAY) | 2365 SPP_SACKDELAY_ENABLE; 2366 } else { 2367 trans->param_flags = 2368 (trans->param_flags & ~SPP_SACKDELAY) | 2369 SPP_SACKDELAY_DISABLE; 2370 } 2371 } 2372 } 2373 2374 return 0; 2375 } 2376 2377 /* 7.1.3 Initialization Parameters (SCTP_INITMSG) 2378 * 2379 * Applications can specify protocol parameters for the default association 2380 * initialization. The option name argument to setsockopt() and getsockopt() 2381 * is SCTP_INITMSG. 2382 * 2383 * Setting initialization parameters is effective only on an unconnected 2384 * socket (for UDP-style sockets only future associations are effected 2385 * by the change). With TCP-style sockets, this option is inherited by 2386 * sockets derived from a listener socket. 2387 */ 2388 static int sctp_setsockopt_initmsg(struct sock *sk, char __user *optval, int optlen) 2389 { 2390 struct sctp_initmsg sinit; 2391 struct sctp_sock *sp = sctp_sk(sk); 2392 2393 if (optlen != sizeof(struct sctp_initmsg)) 2394 return -EINVAL; 2395 if (copy_from_user(&sinit, optval, optlen)) 2396 return -EFAULT; 2397 2398 if (sinit.sinit_num_ostreams) 2399 sp->initmsg.sinit_num_ostreams = sinit.sinit_num_ostreams; 2400 if (sinit.sinit_max_instreams) 2401 sp->initmsg.sinit_max_instreams = sinit.sinit_max_instreams; 2402 if (sinit.sinit_max_attempts) 2403 sp->initmsg.sinit_max_attempts = sinit.sinit_max_attempts; 2404 if (sinit.sinit_max_init_timeo) 2405 sp->initmsg.sinit_max_init_timeo = sinit.sinit_max_init_timeo; 2406 2407 return 0; 2408 } 2409 2410 /* 2411 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM) 2412 * 2413 * Applications that wish to use the sendto() system call may wish to 2414 * specify a default set of parameters that would normally be supplied 2415 * through the inclusion of ancillary data. This socket option allows 2416 * such an application to set the default sctp_sndrcvinfo structure. 2417 * The application that wishes to use this socket option simply passes 2418 * in to this call the sctp_sndrcvinfo structure defined in Section 2419 * 5.2.2) The input parameters accepted by this call include 2420 * sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context, 2421 * sinfo_timetolive. The user must provide the sinfo_assoc_id field in 2422 * to this call if the caller is using the UDP model. 2423 */ 2424 static int sctp_setsockopt_default_send_param(struct sock *sk, 2425 char __user *optval, int optlen) 2426 { 2427 struct sctp_sndrcvinfo info; 2428 struct sctp_association *asoc; 2429 struct sctp_sock *sp = sctp_sk(sk); 2430 2431 if (optlen != sizeof(struct sctp_sndrcvinfo)) 2432 return -EINVAL; 2433 if (copy_from_user(&info, optval, optlen)) 2434 return -EFAULT; 2435 2436 asoc = sctp_id2assoc(sk, info.sinfo_assoc_id); 2437 if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP)) 2438 return -EINVAL; 2439 2440 if (asoc) { 2441 asoc->default_stream = info.sinfo_stream; 2442 asoc->default_flags = info.sinfo_flags; 2443 asoc->default_ppid = info.sinfo_ppid; 2444 asoc->default_context = info.sinfo_context; 2445 asoc->default_timetolive = info.sinfo_timetolive; 2446 } else { 2447 sp->default_stream = info.sinfo_stream; 2448 sp->default_flags = info.sinfo_flags; 2449 sp->default_ppid = info.sinfo_ppid; 2450 sp->default_context = info.sinfo_context; 2451 sp->default_timetolive = info.sinfo_timetolive; 2452 } 2453 2454 return 0; 2455 } 2456 2457 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR) 2458 * 2459 * Requests that the local SCTP stack use the enclosed peer address as 2460 * the association primary. The enclosed address must be one of the 2461 * association peer's addresses. 2462 */ 2463 static int sctp_setsockopt_primary_addr(struct sock *sk, char __user *optval, 2464 int optlen) 2465 { 2466 struct sctp_prim prim; 2467 struct sctp_transport *trans; 2468 2469 if (optlen != sizeof(struct sctp_prim)) 2470 return -EINVAL; 2471 2472 if (copy_from_user(&prim, optval, sizeof(struct sctp_prim))) 2473 return -EFAULT; 2474 2475 trans = sctp_addr_id2transport(sk, &prim.ssp_addr, prim.ssp_assoc_id); 2476 if (!trans) 2477 return -EINVAL; 2478 2479 sctp_assoc_set_primary(trans->asoc, trans); 2480 2481 return 0; 2482 } 2483 2484 /* 2485 * 7.1.5 SCTP_NODELAY 2486 * 2487 * Turn on/off any Nagle-like algorithm. This means that packets are 2488 * generally sent as soon as possible and no unnecessary delays are 2489 * introduced, at the cost of more packets in the network. Expects an 2490 * integer boolean flag. 2491 */ 2492 static int sctp_setsockopt_nodelay(struct sock *sk, char __user *optval, 2493 int optlen) 2494 { 2495 int val; 2496 2497 if (optlen < sizeof(int)) 2498 return -EINVAL; 2499 if (get_user(val, (int __user *)optval)) 2500 return -EFAULT; 2501 2502 sctp_sk(sk)->nodelay = (val == 0) ? 0 : 1; 2503 return 0; 2504 } 2505 2506 /* 2507 * 2508 * 7.1.1 SCTP_RTOINFO 2509 * 2510 * The protocol parameters used to initialize and bound retransmission 2511 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access 2512 * and modify these parameters. 2513 * All parameters are time values, in milliseconds. A value of 0, when 2514 * modifying the parameters, indicates that the current value should not 2515 * be changed. 2516 * 2517 */ 2518 static int sctp_setsockopt_rtoinfo(struct sock *sk, char __user *optval, int optlen) { 2519 struct sctp_rtoinfo rtoinfo; 2520 struct sctp_association *asoc; 2521 2522 if (optlen != sizeof (struct sctp_rtoinfo)) 2523 return -EINVAL; 2524 2525 if (copy_from_user(&rtoinfo, optval, optlen)) 2526 return -EFAULT; 2527 2528 asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id); 2529 2530 /* Set the values to the specific association */ 2531 if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP)) 2532 return -EINVAL; 2533 2534 if (asoc) { 2535 if (rtoinfo.srto_initial != 0) 2536 asoc->rto_initial = 2537 msecs_to_jiffies(rtoinfo.srto_initial); 2538 if (rtoinfo.srto_max != 0) 2539 asoc->rto_max = msecs_to_jiffies(rtoinfo.srto_max); 2540 if (rtoinfo.srto_min != 0) 2541 asoc->rto_min = msecs_to_jiffies(rtoinfo.srto_min); 2542 } else { 2543 /* If there is no association or the association-id = 0 2544 * set the values to the endpoint. 2545 */ 2546 struct sctp_sock *sp = sctp_sk(sk); 2547 2548 if (rtoinfo.srto_initial != 0) 2549 sp->rtoinfo.srto_initial = rtoinfo.srto_initial; 2550 if (rtoinfo.srto_max != 0) 2551 sp->rtoinfo.srto_max = rtoinfo.srto_max; 2552 if (rtoinfo.srto_min != 0) 2553 sp->rtoinfo.srto_min = rtoinfo.srto_min; 2554 } 2555 2556 return 0; 2557 } 2558 2559 /* 2560 * 2561 * 7.1.2 SCTP_ASSOCINFO 2562 * 2563 * This option is used to tune the the maximum retransmission attempts 2564 * of the association. 2565 * Returns an error if the new association retransmission value is 2566 * greater than the sum of the retransmission value of the peer. 2567 * See [SCTP] for more information. 2568 * 2569 */ 2570 static int sctp_setsockopt_associnfo(struct sock *sk, char __user *optval, int optlen) 2571 { 2572 2573 struct sctp_assocparams assocparams; 2574 struct sctp_association *asoc; 2575 2576 if (optlen != sizeof(struct sctp_assocparams)) 2577 return -EINVAL; 2578 if (copy_from_user(&assocparams, optval, optlen)) 2579 return -EFAULT; 2580 2581 asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id); 2582 2583 if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP)) 2584 return -EINVAL; 2585 2586 /* Set the values to the specific association */ 2587 if (asoc) { 2588 if (assocparams.sasoc_asocmaxrxt != 0) { 2589 __u32 path_sum = 0; 2590 int paths = 0; 2591 struct list_head *pos; 2592 struct sctp_transport *peer_addr; 2593 2594 list_for_each(pos, &asoc->peer.transport_addr_list) { 2595 peer_addr = list_entry(pos, 2596 struct sctp_transport, 2597 transports); 2598 path_sum += peer_addr->pathmaxrxt; 2599 paths++; 2600 } 2601 2602 /* Only validate asocmaxrxt if we have more then 2603 * one path/transport. We do this because path 2604 * retransmissions are only counted when we have more 2605 * then one path. 2606 */ 2607 if (paths > 1 && 2608 assocparams.sasoc_asocmaxrxt > path_sum) 2609 return -EINVAL; 2610 2611 asoc->max_retrans = assocparams.sasoc_asocmaxrxt; 2612 } 2613 2614 if (assocparams.sasoc_cookie_life != 0) { 2615 asoc->cookie_life.tv_sec = 2616 assocparams.sasoc_cookie_life / 1000; 2617 asoc->cookie_life.tv_usec = 2618 (assocparams.sasoc_cookie_life % 1000) 2619 * 1000; 2620 } 2621 } else { 2622 /* Set the values to the endpoint */ 2623 struct sctp_sock *sp = sctp_sk(sk); 2624 2625 if (assocparams.sasoc_asocmaxrxt != 0) 2626 sp->assocparams.sasoc_asocmaxrxt = 2627 assocparams.sasoc_asocmaxrxt; 2628 if (assocparams.sasoc_cookie_life != 0) 2629 sp->assocparams.sasoc_cookie_life = 2630 assocparams.sasoc_cookie_life; 2631 } 2632 return 0; 2633 } 2634 2635 /* 2636 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR) 2637 * 2638 * This socket option is a boolean flag which turns on or off mapped V4 2639 * addresses. If this option is turned on and the socket is type 2640 * PF_INET6, then IPv4 addresses will be mapped to V6 representation. 2641 * If this option is turned off, then no mapping will be done of V4 2642 * addresses and a user will receive both PF_INET6 and PF_INET type 2643 * addresses on the socket. 2644 */ 2645 static int sctp_setsockopt_mappedv4(struct sock *sk, char __user *optval, int optlen) 2646 { 2647 int val; 2648 struct sctp_sock *sp = sctp_sk(sk); 2649 2650 if (optlen < sizeof(int)) 2651 return -EINVAL; 2652 if (get_user(val, (int __user *)optval)) 2653 return -EFAULT; 2654 if (val) 2655 sp->v4mapped = 1; 2656 else 2657 sp->v4mapped = 0; 2658 2659 return 0; 2660 } 2661 2662 /* 2663 * 7.1.17 Set the maximum fragrmentation size (SCTP_MAXSEG) 2664 * 2665 * This socket option specifies the maximum size to put in any outgoing 2666 * SCTP chunk. If a message is larger than this size it will be 2667 * fragmented by SCTP into the specified size. Note that the underlying 2668 * SCTP implementation may fragment into smaller sized chunks when the 2669 * PMTU of the underlying association is smaller than the value set by 2670 * the user. 2671 */ 2672 static int sctp_setsockopt_maxseg(struct sock *sk, char __user *optval, int optlen) 2673 { 2674 struct sctp_association *asoc; 2675 struct list_head *pos; 2676 struct sctp_sock *sp = sctp_sk(sk); 2677 int val; 2678 2679 if (optlen < sizeof(int)) 2680 return -EINVAL; 2681 if (get_user(val, (int __user *)optval)) 2682 return -EFAULT; 2683 if ((val != 0) && ((val < 8) || (val > SCTP_MAX_CHUNK_LEN))) 2684 return -EINVAL; 2685 sp->user_frag = val; 2686 2687 /* Update the frag_point of the existing associations. */ 2688 list_for_each(pos, &(sp->ep->asocs)) { 2689 asoc = list_entry(pos, struct sctp_association, asocs); 2690 asoc->frag_point = sctp_frag_point(sp, asoc->pathmtu); 2691 } 2692 2693 return 0; 2694 } 2695 2696 2697 /* 2698 * 7.1.9 Set Peer Primary Address (SCTP_SET_PEER_PRIMARY_ADDR) 2699 * 2700 * Requests that the peer mark the enclosed address as the association 2701 * primary. The enclosed address must be one of the association's 2702 * locally bound addresses. The following structure is used to make a 2703 * set primary request: 2704 */ 2705 static int sctp_setsockopt_peer_primary_addr(struct sock *sk, char __user *optval, 2706 int optlen) 2707 { 2708 struct sctp_sock *sp; 2709 struct sctp_endpoint *ep; 2710 struct sctp_association *asoc = NULL; 2711 struct sctp_setpeerprim prim; 2712 struct sctp_chunk *chunk; 2713 int err; 2714 2715 sp = sctp_sk(sk); 2716 ep = sp->ep; 2717 2718 if (!sctp_addip_enable) 2719 return -EPERM; 2720 2721 if (optlen != sizeof(struct sctp_setpeerprim)) 2722 return -EINVAL; 2723 2724 if (copy_from_user(&prim, optval, optlen)) 2725 return -EFAULT; 2726 2727 asoc = sctp_id2assoc(sk, prim.sspp_assoc_id); 2728 if (!asoc) 2729 return -EINVAL; 2730 2731 if (!asoc->peer.asconf_capable) 2732 return -EPERM; 2733 2734 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_SET_PRIMARY) 2735 return -EPERM; 2736 2737 if (!sctp_state(asoc, ESTABLISHED)) 2738 return -ENOTCONN; 2739 2740 if (!sctp_assoc_lookup_laddr(asoc, (union sctp_addr *)&prim.sspp_addr)) 2741 return -EADDRNOTAVAIL; 2742 2743 /* Create an ASCONF chunk with SET_PRIMARY parameter */ 2744 chunk = sctp_make_asconf_set_prim(asoc, 2745 (union sctp_addr *)&prim.sspp_addr); 2746 if (!chunk) 2747 return -ENOMEM; 2748 2749 err = sctp_send_asconf(asoc, chunk); 2750 2751 SCTP_DEBUG_PRINTK("We set peer primary addr primitively.\n"); 2752 2753 return err; 2754 } 2755 2756 static int sctp_setsockopt_adaption_layer(struct sock *sk, char __user *optval, 2757 int optlen) 2758 { 2759 struct sctp_setadaption adaption; 2760 2761 if (optlen != sizeof(struct sctp_setadaption)) 2762 return -EINVAL; 2763 if (copy_from_user(&adaption, optval, optlen)) 2764 return -EFAULT; 2765 2766 sctp_sk(sk)->adaption_ind = adaption.ssb_adaption_ind; 2767 2768 return 0; 2769 } 2770 2771 /* API 6.2 setsockopt(), getsockopt() 2772 * 2773 * Applications use setsockopt() and getsockopt() to set or retrieve 2774 * socket options. Socket options are used to change the default 2775 * behavior of sockets calls. They are described in Section 7. 2776 * 2777 * The syntax is: 2778 * 2779 * ret = getsockopt(int sd, int level, int optname, void __user *optval, 2780 * int __user *optlen); 2781 * ret = setsockopt(int sd, int level, int optname, const void __user *optval, 2782 * int optlen); 2783 * 2784 * sd - the socket descript. 2785 * level - set to IPPROTO_SCTP for all SCTP options. 2786 * optname - the option name. 2787 * optval - the buffer to store the value of the option. 2788 * optlen - the size of the buffer. 2789 */ 2790 SCTP_STATIC int sctp_setsockopt(struct sock *sk, int level, int optname, 2791 char __user *optval, int optlen) 2792 { 2793 int retval = 0; 2794 2795 SCTP_DEBUG_PRINTK("sctp_setsockopt(sk: %p... optname: %d)\n", 2796 sk, optname); 2797 2798 /* I can hardly begin to describe how wrong this is. This is 2799 * so broken as to be worse than useless. The API draft 2800 * REALLY is NOT helpful here... I am not convinced that the 2801 * semantics of setsockopt() with a level OTHER THAN SOL_SCTP 2802 * are at all well-founded. 2803 */ 2804 if (level != SOL_SCTP) { 2805 struct sctp_af *af = sctp_sk(sk)->pf->af; 2806 retval = af->setsockopt(sk, level, optname, optval, optlen); 2807 goto out_nounlock; 2808 } 2809 2810 sctp_lock_sock(sk); 2811 2812 switch (optname) { 2813 case SCTP_SOCKOPT_BINDX_ADD: 2814 /* 'optlen' is the size of the addresses buffer. */ 2815 retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval, 2816 optlen, SCTP_BINDX_ADD_ADDR); 2817 break; 2818 2819 case SCTP_SOCKOPT_BINDX_REM: 2820 /* 'optlen' is the size of the addresses buffer. */ 2821 retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval, 2822 optlen, SCTP_BINDX_REM_ADDR); 2823 break; 2824 2825 case SCTP_SOCKOPT_CONNECTX: 2826 /* 'optlen' is the size of the addresses buffer. */ 2827 retval = sctp_setsockopt_connectx(sk, (struct sockaddr __user *)optval, 2828 optlen); 2829 break; 2830 2831 case SCTP_DISABLE_FRAGMENTS: 2832 retval = sctp_setsockopt_disable_fragments(sk, optval, optlen); 2833 break; 2834 2835 case SCTP_EVENTS: 2836 retval = sctp_setsockopt_events(sk, optval, optlen); 2837 break; 2838 2839 case SCTP_AUTOCLOSE: 2840 retval = sctp_setsockopt_autoclose(sk, optval, optlen); 2841 break; 2842 2843 case SCTP_PEER_ADDR_PARAMS: 2844 retval = sctp_setsockopt_peer_addr_params(sk, optval, optlen); 2845 break; 2846 2847 case SCTP_DELAYED_ACK_TIME: 2848 retval = sctp_setsockopt_delayed_ack_time(sk, optval, optlen); 2849 break; 2850 2851 case SCTP_INITMSG: 2852 retval = sctp_setsockopt_initmsg(sk, optval, optlen); 2853 break; 2854 case SCTP_DEFAULT_SEND_PARAM: 2855 retval = sctp_setsockopt_default_send_param(sk, optval, 2856 optlen); 2857 break; 2858 case SCTP_PRIMARY_ADDR: 2859 retval = sctp_setsockopt_primary_addr(sk, optval, optlen); 2860 break; 2861 case SCTP_SET_PEER_PRIMARY_ADDR: 2862 retval = sctp_setsockopt_peer_primary_addr(sk, optval, optlen); 2863 break; 2864 case SCTP_NODELAY: 2865 retval = sctp_setsockopt_nodelay(sk, optval, optlen); 2866 break; 2867 case SCTP_RTOINFO: 2868 retval = sctp_setsockopt_rtoinfo(sk, optval, optlen); 2869 break; 2870 case SCTP_ASSOCINFO: 2871 retval = sctp_setsockopt_associnfo(sk, optval, optlen); 2872 break; 2873 case SCTP_I_WANT_MAPPED_V4_ADDR: 2874 retval = sctp_setsockopt_mappedv4(sk, optval, optlen); 2875 break; 2876 case SCTP_MAXSEG: 2877 retval = sctp_setsockopt_maxseg(sk, optval, optlen); 2878 break; 2879 case SCTP_ADAPTION_LAYER: 2880 retval = sctp_setsockopt_adaption_layer(sk, optval, optlen); 2881 break; 2882 2883 default: 2884 retval = -ENOPROTOOPT; 2885 break; 2886 }; 2887 2888 sctp_release_sock(sk); 2889 2890 out_nounlock: 2891 return retval; 2892 } 2893 2894 /* API 3.1.6 connect() - UDP Style Syntax 2895 * 2896 * An application may use the connect() call in the UDP model to initiate an 2897 * association without sending data. 2898 * 2899 * The syntax is: 2900 * 2901 * ret = connect(int sd, const struct sockaddr *nam, socklen_t len); 2902 * 2903 * sd: the socket descriptor to have a new association added to. 2904 * 2905 * nam: the address structure (either struct sockaddr_in or struct 2906 * sockaddr_in6 defined in RFC2553 [7]). 2907 * 2908 * len: the size of the address. 2909 */ 2910 SCTP_STATIC int sctp_connect(struct sock *sk, struct sockaddr *addr, 2911 int addr_len) 2912 { 2913 int err = 0; 2914 struct sctp_af *af; 2915 2916 sctp_lock_sock(sk); 2917 2918 SCTP_DEBUG_PRINTK("%s - sk: %p, sockaddr: %p, addr_len: %d\n", 2919 __FUNCTION__, sk, addr, addr_len); 2920 2921 /* Validate addr_len before calling common connect/connectx routine. */ 2922 af = sctp_get_af_specific(addr->sa_family); 2923 if (!af || addr_len < af->sockaddr_len) { 2924 err = -EINVAL; 2925 } else { 2926 /* Pass correct addr len to common routine (so it knows there 2927 * is only one address being passed. 2928 */ 2929 err = __sctp_connect(sk, addr, af->sockaddr_len); 2930 } 2931 2932 sctp_release_sock(sk); 2933 return err; 2934 } 2935 2936 /* FIXME: Write comments. */ 2937 SCTP_STATIC int sctp_disconnect(struct sock *sk, int flags) 2938 { 2939 return -EOPNOTSUPP; /* STUB */ 2940 } 2941 2942 /* 4.1.4 accept() - TCP Style Syntax 2943 * 2944 * Applications use accept() call to remove an established SCTP 2945 * association from the accept queue of the endpoint. A new socket 2946 * descriptor will be returned from accept() to represent the newly 2947 * formed association. 2948 */ 2949 SCTP_STATIC struct sock *sctp_accept(struct sock *sk, int flags, int *err) 2950 { 2951 struct sctp_sock *sp; 2952 struct sctp_endpoint *ep; 2953 struct sock *newsk = NULL; 2954 struct sctp_association *asoc; 2955 long timeo; 2956 int error = 0; 2957 2958 sctp_lock_sock(sk); 2959 2960 sp = sctp_sk(sk); 2961 ep = sp->ep; 2962 2963 if (!sctp_style(sk, TCP)) { 2964 error = -EOPNOTSUPP; 2965 goto out; 2966 } 2967 2968 if (!sctp_sstate(sk, LISTENING)) { 2969 error = -EINVAL; 2970 goto out; 2971 } 2972 2973 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK); 2974 2975 error = sctp_wait_for_accept(sk, timeo); 2976 if (error) 2977 goto out; 2978 2979 /* We treat the list of associations on the endpoint as the accept 2980 * queue and pick the first association on the list. 2981 */ 2982 asoc = list_entry(ep->asocs.next, struct sctp_association, asocs); 2983 2984 newsk = sp->pf->create_accept_sk(sk, asoc); 2985 if (!newsk) { 2986 error = -ENOMEM; 2987 goto out; 2988 } 2989 2990 /* Populate the fields of the newsk from the oldsk and migrate the 2991 * asoc to the newsk. 2992 */ 2993 sctp_sock_migrate(sk, newsk, asoc, SCTP_SOCKET_TCP); 2994 2995 out: 2996 sctp_release_sock(sk); 2997 *err = error; 2998 return newsk; 2999 } 3000 3001 /* The SCTP ioctl handler. */ 3002 SCTP_STATIC int sctp_ioctl(struct sock *sk, int cmd, unsigned long arg) 3003 { 3004 return -ENOIOCTLCMD; 3005 } 3006 3007 /* This is the function which gets called during socket creation to 3008 * initialized the SCTP-specific portion of the sock. 3009 * The sock structure should already be zero-filled memory. 3010 */ 3011 SCTP_STATIC int sctp_init_sock(struct sock *sk) 3012 { 3013 struct sctp_endpoint *ep; 3014 struct sctp_sock *sp; 3015 3016 SCTP_DEBUG_PRINTK("sctp_init_sock(sk: %p)\n", sk); 3017 3018 sp = sctp_sk(sk); 3019 3020 /* Initialize the SCTP per socket area. */ 3021 switch (sk->sk_type) { 3022 case SOCK_SEQPACKET: 3023 sp->type = SCTP_SOCKET_UDP; 3024 break; 3025 case SOCK_STREAM: 3026 sp->type = SCTP_SOCKET_TCP; 3027 break; 3028 default: 3029 return -ESOCKTNOSUPPORT; 3030 } 3031 3032 /* Initialize default send parameters. These parameters can be 3033 * modified with the SCTP_DEFAULT_SEND_PARAM socket option. 3034 */ 3035 sp->default_stream = 0; 3036 sp->default_ppid = 0; 3037 sp->default_flags = 0; 3038 sp->default_context = 0; 3039 sp->default_timetolive = 0; 3040 3041 /* Initialize default setup parameters. These parameters 3042 * can be modified with the SCTP_INITMSG socket option or 3043 * overridden by the SCTP_INIT CMSG. 3044 */ 3045 sp->initmsg.sinit_num_ostreams = sctp_max_outstreams; 3046 sp->initmsg.sinit_max_instreams = sctp_max_instreams; 3047 sp->initmsg.sinit_max_attempts = sctp_max_retrans_init; 3048 sp->initmsg.sinit_max_init_timeo = sctp_rto_max; 3049 3050 /* Initialize default RTO related parameters. These parameters can 3051 * be modified for with the SCTP_RTOINFO socket option. 3052 */ 3053 sp->rtoinfo.srto_initial = sctp_rto_initial; 3054 sp->rtoinfo.srto_max = sctp_rto_max; 3055 sp->rtoinfo.srto_min = sctp_rto_min; 3056 3057 /* Initialize default association related parameters. These parameters 3058 * can be modified with the SCTP_ASSOCINFO socket option. 3059 */ 3060 sp->assocparams.sasoc_asocmaxrxt = sctp_max_retrans_association; 3061 sp->assocparams.sasoc_number_peer_destinations = 0; 3062 sp->assocparams.sasoc_peer_rwnd = 0; 3063 sp->assocparams.sasoc_local_rwnd = 0; 3064 sp->assocparams.sasoc_cookie_life = sctp_valid_cookie_life; 3065 3066 /* Initialize default event subscriptions. By default, all the 3067 * options are off. 3068 */ 3069 memset(&sp->subscribe, 0, sizeof(struct sctp_event_subscribe)); 3070 3071 /* Default Peer Address Parameters. These defaults can 3072 * be modified via SCTP_PEER_ADDR_PARAMS 3073 */ 3074 sp->hbinterval = sctp_hb_interval; 3075 sp->pathmaxrxt = sctp_max_retrans_path; 3076 sp->pathmtu = 0; // allow default discovery 3077 sp->sackdelay = sctp_sack_timeout; 3078 sp->param_flags = SPP_HB_ENABLE | 3079 SPP_PMTUD_ENABLE | 3080 SPP_SACKDELAY_ENABLE; 3081 3082 /* If enabled no SCTP message fragmentation will be performed. 3083 * Configure through SCTP_DISABLE_FRAGMENTS socket option. 3084 */ 3085 sp->disable_fragments = 0; 3086 3087 /* Turn on/off any Nagle-like algorithm. */ 3088 sp->nodelay = 1; 3089 3090 /* Enable by default. */ 3091 sp->v4mapped = 1; 3092 3093 /* Auto-close idle associations after the configured 3094 * number of seconds. A value of 0 disables this 3095 * feature. Configure through the SCTP_AUTOCLOSE socket option, 3096 * for UDP-style sockets only. 3097 */ 3098 sp->autoclose = 0; 3099 3100 /* User specified fragmentation limit. */ 3101 sp->user_frag = 0; 3102 3103 sp->adaption_ind = 0; 3104 3105 sp->pf = sctp_get_pf_specific(sk->sk_family); 3106 3107 /* Control variables for partial data delivery. */ 3108 sp->pd_mode = 0; 3109 skb_queue_head_init(&sp->pd_lobby); 3110 3111 /* Create a per socket endpoint structure. Even if we 3112 * change the data structure relationships, this may still 3113 * be useful for storing pre-connect address information. 3114 */ 3115 ep = sctp_endpoint_new(sk, GFP_KERNEL); 3116 if (!ep) 3117 return -ENOMEM; 3118 3119 sp->ep = ep; 3120 sp->hmac = NULL; 3121 3122 SCTP_DBG_OBJCNT_INC(sock); 3123 return 0; 3124 } 3125 3126 /* Cleanup any SCTP per socket resources. */ 3127 SCTP_STATIC int sctp_destroy_sock(struct sock *sk) 3128 { 3129 struct sctp_endpoint *ep; 3130 3131 SCTP_DEBUG_PRINTK("sctp_destroy_sock(sk: %p)\n", sk); 3132 3133 /* Release our hold on the endpoint. */ 3134 ep = sctp_sk(sk)->ep; 3135 sctp_endpoint_free(ep); 3136 3137 return 0; 3138 } 3139 3140 /* API 4.1.7 shutdown() - TCP Style Syntax 3141 * int shutdown(int socket, int how); 3142 * 3143 * sd - the socket descriptor of the association to be closed. 3144 * how - Specifies the type of shutdown. The values are 3145 * as follows: 3146 * SHUT_RD 3147 * Disables further receive operations. No SCTP 3148 * protocol action is taken. 3149 * SHUT_WR 3150 * Disables further send operations, and initiates 3151 * the SCTP shutdown sequence. 3152 * SHUT_RDWR 3153 * Disables further send and receive operations 3154 * and initiates the SCTP shutdown sequence. 3155 */ 3156 SCTP_STATIC void sctp_shutdown(struct sock *sk, int how) 3157 { 3158 struct sctp_endpoint *ep; 3159 struct sctp_association *asoc; 3160 3161 if (!sctp_style(sk, TCP)) 3162 return; 3163 3164 if (how & SEND_SHUTDOWN) { 3165 ep = sctp_sk(sk)->ep; 3166 if (!list_empty(&ep->asocs)) { 3167 asoc = list_entry(ep->asocs.next, 3168 struct sctp_association, asocs); 3169 sctp_primitive_SHUTDOWN(asoc, NULL); 3170 } 3171 } 3172 } 3173 3174 /* 7.2.1 Association Status (SCTP_STATUS) 3175 3176 * Applications can retrieve current status information about an 3177 * association, including association state, peer receiver window size, 3178 * number of unacked data chunks, and number of data chunks pending 3179 * receipt. This information is read-only. 3180 */ 3181 static int sctp_getsockopt_sctp_status(struct sock *sk, int len, 3182 char __user *optval, 3183 int __user *optlen) 3184 { 3185 struct sctp_status status; 3186 struct sctp_association *asoc = NULL; 3187 struct sctp_transport *transport; 3188 sctp_assoc_t associd; 3189 int retval = 0; 3190 3191 if (len != sizeof(status)) { 3192 retval = -EINVAL; 3193 goto out; 3194 } 3195 3196 if (copy_from_user(&status, optval, sizeof(status))) { 3197 retval = -EFAULT; 3198 goto out; 3199 } 3200 3201 associd = status.sstat_assoc_id; 3202 asoc = sctp_id2assoc(sk, associd); 3203 if (!asoc) { 3204 retval = -EINVAL; 3205 goto out; 3206 } 3207 3208 transport = asoc->peer.primary_path; 3209 3210 status.sstat_assoc_id = sctp_assoc2id(asoc); 3211 status.sstat_state = asoc->state; 3212 status.sstat_rwnd = asoc->peer.rwnd; 3213 status.sstat_unackdata = asoc->unack_data; 3214 3215 status.sstat_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map); 3216 status.sstat_instrms = asoc->c.sinit_max_instreams; 3217 status.sstat_outstrms = asoc->c.sinit_num_ostreams; 3218 status.sstat_fragmentation_point = asoc->frag_point; 3219 status.sstat_primary.spinfo_assoc_id = sctp_assoc2id(transport->asoc); 3220 memcpy(&status.sstat_primary.spinfo_address, 3221 &(transport->ipaddr), sizeof(union sctp_addr)); 3222 /* Map ipv4 address into v4-mapped-on-v6 address. */ 3223 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk), 3224 (union sctp_addr *)&status.sstat_primary.spinfo_address); 3225 status.sstat_primary.spinfo_state = transport->state; 3226 status.sstat_primary.spinfo_cwnd = transport->cwnd; 3227 status.sstat_primary.spinfo_srtt = transport->srtt; 3228 status.sstat_primary.spinfo_rto = jiffies_to_msecs(transport->rto); 3229 status.sstat_primary.spinfo_mtu = transport->pathmtu; 3230 3231 if (status.sstat_primary.spinfo_state == SCTP_UNKNOWN) 3232 status.sstat_primary.spinfo_state = SCTP_ACTIVE; 3233 3234 if (put_user(len, optlen)) { 3235 retval = -EFAULT; 3236 goto out; 3237 } 3238 3239 SCTP_DEBUG_PRINTK("sctp_getsockopt_sctp_status(%d): %d %d %d\n", 3240 len, status.sstat_state, status.sstat_rwnd, 3241 status.sstat_assoc_id); 3242 3243 if (copy_to_user(optval, &status, len)) { 3244 retval = -EFAULT; 3245 goto out; 3246 } 3247 3248 out: 3249 return (retval); 3250 } 3251 3252 3253 /* 7.2.2 Peer Address Information (SCTP_GET_PEER_ADDR_INFO) 3254 * 3255 * Applications can retrieve information about a specific peer address 3256 * of an association, including its reachability state, congestion 3257 * window, and retransmission timer values. This information is 3258 * read-only. 3259 */ 3260 static int sctp_getsockopt_peer_addr_info(struct sock *sk, int len, 3261 char __user *optval, 3262 int __user *optlen) 3263 { 3264 struct sctp_paddrinfo pinfo; 3265 struct sctp_transport *transport; 3266 int retval = 0; 3267 3268 if (len != sizeof(pinfo)) { 3269 retval = -EINVAL; 3270 goto out; 3271 } 3272 3273 if (copy_from_user(&pinfo, optval, sizeof(pinfo))) { 3274 retval = -EFAULT; 3275 goto out; 3276 } 3277 3278 transport = sctp_addr_id2transport(sk, &pinfo.spinfo_address, 3279 pinfo.spinfo_assoc_id); 3280 if (!transport) 3281 return -EINVAL; 3282 3283 pinfo.spinfo_assoc_id = sctp_assoc2id(transport->asoc); 3284 pinfo.spinfo_state = transport->state; 3285 pinfo.spinfo_cwnd = transport->cwnd; 3286 pinfo.spinfo_srtt = transport->srtt; 3287 pinfo.spinfo_rto = jiffies_to_msecs(transport->rto); 3288 pinfo.spinfo_mtu = transport->pathmtu; 3289 3290 if (pinfo.spinfo_state == SCTP_UNKNOWN) 3291 pinfo.spinfo_state = SCTP_ACTIVE; 3292 3293 if (put_user(len, optlen)) { 3294 retval = -EFAULT; 3295 goto out; 3296 } 3297 3298 if (copy_to_user(optval, &pinfo, len)) { 3299 retval = -EFAULT; 3300 goto out; 3301 } 3302 3303 out: 3304 return (retval); 3305 } 3306 3307 /* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS) 3308 * 3309 * This option is a on/off flag. If enabled no SCTP message 3310 * fragmentation will be performed. Instead if a message being sent 3311 * exceeds the current PMTU size, the message will NOT be sent and 3312 * instead a error will be indicated to the user. 3313 */ 3314 static int sctp_getsockopt_disable_fragments(struct sock *sk, int len, 3315 char __user *optval, int __user *optlen) 3316 { 3317 int val; 3318 3319 if (len < sizeof(int)) 3320 return -EINVAL; 3321 3322 len = sizeof(int); 3323 val = (sctp_sk(sk)->disable_fragments == 1); 3324 if (put_user(len, optlen)) 3325 return -EFAULT; 3326 if (copy_to_user(optval, &val, len)) 3327 return -EFAULT; 3328 return 0; 3329 } 3330 3331 /* 7.1.15 Set notification and ancillary events (SCTP_EVENTS) 3332 * 3333 * This socket option is used to specify various notifications and 3334 * ancillary data the user wishes to receive. 3335 */ 3336 static int sctp_getsockopt_events(struct sock *sk, int len, char __user *optval, 3337 int __user *optlen) 3338 { 3339 if (len != sizeof(struct sctp_event_subscribe)) 3340 return -EINVAL; 3341 if (copy_to_user(optval, &sctp_sk(sk)->subscribe, len)) 3342 return -EFAULT; 3343 return 0; 3344 } 3345 3346 /* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE) 3347 * 3348 * This socket option is applicable to the UDP-style socket only. When 3349 * set it will cause associations that are idle for more than the 3350 * specified number of seconds to automatically close. An association 3351 * being idle is defined an association that has NOT sent or received 3352 * user data. The special value of '0' indicates that no automatic 3353 * close of any associations should be performed. The option expects an 3354 * integer defining the number of seconds of idle time before an 3355 * association is closed. 3356 */ 3357 static int sctp_getsockopt_autoclose(struct sock *sk, int len, char __user *optval, int __user *optlen) 3358 { 3359 /* Applicable to UDP-style socket only */ 3360 if (sctp_style(sk, TCP)) 3361 return -EOPNOTSUPP; 3362 if (len != sizeof(int)) 3363 return -EINVAL; 3364 if (copy_to_user(optval, &sctp_sk(sk)->autoclose, len)) 3365 return -EFAULT; 3366 return 0; 3367 } 3368 3369 /* Helper routine to branch off an association to a new socket. */ 3370 SCTP_STATIC int sctp_do_peeloff(struct sctp_association *asoc, 3371 struct socket **sockp) 3372 { 3373 struct sock *sk = asoc->base.sk; 3374 struct socket *sock; 3375 int err = 0; 3376 3377 /* An association cannot be branched off from an already peeled-off 3378 * socket, nor is this supported for tcp style sockets. 3379 */ 3380 if (!sctp_style(sk, UDP)) 3381 return -EINVAL; 3382 3383 /* Create a new socket. */ 3384 err = sock_create(sk->sk_family, SOCK_SEQPACKET, IPPROTO_SCTP, &sock); 3385 if (err < 0) 3386 return err; 3387 3388 /* Populate the fields of the newsk from the oldsk and migrate the 3389 * asoc to the newsk. 3390 */ 3391 sctp_sock_migrate(sk, sock->sk, asoc, SCTP_SOCKET_UDP_HIGH_BANDWIDTH); 3392 *sockp = sock; 3393 3394 return err; 3395 } 3396 3397 static int sctp_getsockopt_peeloff(struct sock *sk, int len, char __user *optval, int __user *optlen) 3398 { 3399 sctp_peeloff_arg_t peeloff; 3400 struct socket *newsock; 3401 int retval = 0; 3402 struct sctp_association *asoc; 3403 3404 if (len != sizeof(sctp_peeloff_arg_t)) 3405 return -EINVAL; 3406 if (copy_from_user(&peeloff, optval, len)) 3407 return -EFAULT; 3408 3409 asoc = sctp_id2assoc(sk, peeloff.associd); 3410 if (!asoc) { 3411 retval = -EINVAL; 3412 goto out; 3413 } 3414 3415 SCTP_DEBUG_PRINTK("%s: sk: %p asoc: %p\n", __FUNCTION__, sk, asoc); 3416 3417 retval = sctp_do_peeloff(asoc, &newsock); 3418 if (retval < 0) 3419 goto out; 3420 3421 /* Map the socket to an unused fd that can be returned to the user. */ 3422 retval = sock_map_fd(newsock); 3423 if (retval < 0) { 3424 sock_release(newsock); 3425 goto out; 3426 } 3427 3428 SCTP_DEBUG_PRINTK("%s: sk: %p asoc: %p newsk: %p sd: %d\n", 3429 __FUNCTION__, sk, asoc, newsock->sk, retval); 3430 3431 /* Return the fd mapped to the new socket. */ 3432 peeloff.sd = retval; 3433 if (copy_to_user(optval, &peeloff, len)) 3434 retval = -EFAULT; 3435 3436 out: 3437 return retval; 3438 } 3439 3440 /* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS) 3441 * 3442 * Applications can enable or disable heartbeats for any peer address of 3443 * an association, modify an address's heartbeat interval, force a 3444 * heartbeat to be sent immediately, and adjust the address's maximum 3445 * number of retransmissions sent before an address is considered 3446 * unreachable. The following structure is used to access and modify an 3447 * address's parameters: 3448 * 3449 * struct sctp_paddrparams { 3450 * sctp_assoc_t spp_assoc_id; 3451 * struct sockaddr_storage spp_address; 3452 * uint32_t spp_hbinterval; 3453 * uint16_t spp_pathmaxrxt; 3454 * uint32_t spp_pathmtu; 3455 * uint32_t spp_sackdelay; 3456 * uint32_t spp_flags; 3457 * }; 3458 * 3459 * spp_assoc_id - (one-to-many style socket) This is filled in the 3460 * application, and identifies the association for 3461 * this query. 3462 * spp_address - This specifies which address is of interest. 3463 * spp_hbinterval - This contains the value of the heartbeat interval, 3464 * in milliseconds. If a value of zero 3465 * is present in this field then no changes are to 3466 * be made to this parameter. 3467 * spp_pathmaxrxt - This contains the maximum number of 3468 * retransmissions before this address shall be 3469 * considered unreachable. If a value of zero 3470 * is present in this field then no changes are to 3471 * be made to this parameter. 3472 * spp_pathmtu - When Path MTU discovery is disabled the value 3473 * specified here will be the "fixed" path mtu. 3474 * Note that if the spp_address field is empty 3475 * then all associations on this address will 3476 * have this fixed path mtu set upon them. 3477 * 3478 * spp_sackdelay - When delayed sack is enabled, this value specifies 3479 * the number of milliseconds that sacks will be delayed 3480 * for. This value will apply to all addresses of an 3481 * association if the spp_address field is empty. Note 3482 * also, that if delayed sack is enabled and this 3483 * value is set to 0, no change is made to the last 3484 * recorded delayed sack timer value. 3485 * 3486 * spp_flags - These flags are used to control various features 3487 * on an association. The flag field may contain 3488 * zero or more of the following options. 3489 * 3490 * SPP_HB_ENABLE - Enable heartbeats on the 3491 * specified address. Note that if the address 3492 * field is empty all addresses for the association 3493 * have heartbeats enabled upon them. 3494 * 3495 * SPP_HB_DISABLE - Disable heartbeats on the 3496 * speicifed address. Note that if the address 3497 * field is empty all addresses for the association 3498 * will have their heartbeats disabled. Note also 3499 * that SPP_HB_ENABLE and SPP_HB_DISABLE are 3500 * mutually exclusive, only one of these two should 3501 * be specified. Enabling both fields will have 3502 * undetermined results. 3503 * 3504 * SPP_HB_DEMAND - Request a user initiated heartbeat 3505 * to be made immediately. 3506 * 3507 * SPP_PMTUD_ENABLE - This field will enable PMTU 3508 * discovery upon the specified address. Note that 3509 * if the address feild is empty then all addresses 3510 * on the association are effected. 3511 * 3512 * SPP_PMTUD_DISABLE - This field will disable PMTU 3513 * discovery upon the specified address. Note that 3514 * if the address feild is empty then all addresses 3515 * on the association are effected. Not also that 3516 * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually 3517 * exclusive. Enabling both will have undetermined 3518 * results. 3519 * 3520 * SPP_SACKDELAY_ENABLE - Setting this flag turns 3521 * on delayed sack. The time specified in spp_sackdelay 3522 * is used to specify the sack delay for this address. Note 3523 * that if spp_address is empty then all addresses will 3524 * enable delayed sack and take on the sack delay 3525 * value specified in spp_sackdelay. 3526 * SPP_SACKDELAY_DISABLE - Setting this flag turns 3527 * off delayed sack. If the spp_address field is blank then 3528 * delayed sack is disabled for the entire association. Note 3529 * also that this field is mutually exclusive to 3530 * SPP_SACKDELAY_ENABLE, setting both will have undefined 3531 * results. 3532 */ 3533 static int sctp_getsockopt_peer_addr_params(struct sock *sk, int len, 3534 char __user *optval, int __user *optlen) 3535 { 3536 struct sctp_paddrparams params; 3537 struct sctp_transport *trans = NULL; 3538 struct sctp_association *asoc = NULL; 3539 struct sctp_sock *sp = sctp_sk(sk); 3540 3541 if (len != sizeof(struct sctp_paddrparams)) 3542 return -EINVAL; 3543 3544 if (copy_from_user(¶ms, optval, len)) 3545 return -EFAULT; 3546 3547 /* If an address other than INADDR_ANY is specified, and 3548 * no transport is found, then the request is invalid. 3549 */ 3550 if (!sctp_is_any(( union sctp_addr *)¶ms.spp_address)) { 3551 trans = sctp_addr_id2transport(sk, ¶ms.spp_address, 3552 params.spp_assoc_id); 3553 if (!trans) { 3554 SCTP_DEBUG_PRINTK("Failed no transport\n"); 3555 return -EINVAL; 3556 } 3557 } 3558 3559 /* Get association, if assoc_id != 0 and the socket is a one 3560 * to many style socket, and an association was not found, then 3561 * the id was invalid. 3562 */ 3563 asoc = sctp_id2assoc(sk, params.spp_assoc_id); 3564 if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP)) { 3565 SCTP_DEBUG_PRINTK("Failed no association\n"); 3566 return -EINVAL; 3567 } 3568 3569 if (trans) { 3570 /* Fetch transport values. */ 3571 params.spp_hbinterval = jiffies_to_msecs(trans->hbinterval); 3572 params.spp_pathmtu = trans->pathmtu; 3573 params.spp_pathmaxrxt = trans->pathmaxrxt; 3574 params.spp_sackdelay = jiffies_to_msecs(trans->sackdelay); 3575 3576 /*draft-11 doesn't say what to return in spp_flags*/ 3577 params.spp_flags = trans->param_flags; 3578 } else if (asoc) { 3579 /* Fetch association values. */ 3580 params.spp_hbinterval = jiffies_to_msecs(asoc->hbinterval); 3581 params.spp_pathmtu = asoc->pathmtu; 3582 params.spp_pathmaxrxt = asoc->pathmaxrxt; 3583 params.spp_sackdelay = jiffies_to_msecs(asoc->sackdelay); 3584 3585 /*draft-11 doesn't say what to return in spp_flags*/ 3586 params.spp_flags = asoc->param_flags; 3587 } else { 3588 /* Fetch socket values. */ 3589 params.spp_hbinterval = sp->hbinterval; 3590 params.spp_pathmtu = sp->pathmtu; 3591 params.spp_sackdelay = sp->sackdelay; 3592 params.spp_pathmaxrxt = sp->pathmaxrxt; 3593 3594 /*draft-11 doesn't say what to return in spp_flags*/ 3595 params.spp_flags = sp->param_flags; 3596 } 3597 3598 if (copy_to_user(optval, ¶ms, len)) 3599 return -EFAULT; 3600 3601 if (put_user(len, optlen)) 3602 return -EFAULT; 3603 3604 return 0; 3605 } 3606 3607 /* 7.1.24. Delayed Ack Timer (SCTP_DELAYED_ACK_TIME) 3608 * 3609 * This options will get or set the delayed ack timer. The time is set 3610 * in milliseconds. If the assoc_id is 0, then this sets or gets the 3611 * endpoints default delayed ack timer value. If the assoc_id field is 3612 * non-zero, then the set or get effects the specified association. 3613 * 3614 * struct sctp_assoc_value { 3615 * sctp_assoc_t assoc_id; 3616 * uint32_t assoc_value; 3617 * }; 3618 * 3619 * assoc_id - This parameter, indicates which association the 3620 * user is preforming an action upon. Note that if 3621 * this field's value is zero then the endpoints 3622 * default value is changed (effecting future 3623 * associations only). 3624 * 3625 * assoc_value - This parameter contains the number of milliseconds 3626 * that the user is requesting the delayed ACK timer 3627 * be set to. Note that this value is defined in 3628 * the standard to be between 200 and 500 milliseconds. 3629 * 3630 * Note: a value of zero will leave the value alone, 3631 * but disable SACK delay. A non-zero value will also 3632 * enable SACK delay. 3633 */ 3634 static int sctp_getsockopt_delayed_ack_time(struct sock *sk, int len, 3635 char __user *optval, 3636 int __user *optlen) 3637 { 3638 struct sctp_assoc_value params; 3639 struct sctp_association *asoc = NULL; 3640 struct sctp_sock *sp = sctp_sk(sk); 3641 3642 if (len != sizeof(struct sctp_assoc_value)) 3643 return - EINVAL; 3644 3645 if (copy_from_user(¶ms, optval, len)) 3646 return -EFAULT; 3647 3648 /* Get association, if assoc_id != 0 and the socket is a one 3649 * to many style socket, and an association was not found, then 3650 * the id was invalid. 3651 */ 3652 asoc = sctp_id2assoc(sk, params.assoc_id); 3653 if (!asoc && params.assoc_id && sctp_style(sk, UDP)) 3654 return -EINVAL; 3655 3656 if (asoc) { 3657 /* Fetch association values. */ 3658 if (asoc->param_flags & SPP_SACKDELAY_ENABLE) 3659 params.assoc_value = jiffies_to_msecs( 3660 asoc->sackdelay); 3661 else 3662 params.assoc_value = 0; 3663 } else { 3664 /* Fetch socket values. */ 3665 if (sp->param_flags & SPP_SACKDELAY_ENABLE) 3666 params.assoc_value = sp->sackdelay; 3667 else 3668 params.assoc_value = 0; 3669 } 3670 3671 if (copy_to_user(optval, ¶ms, len)) 3672 return -EFAULT; 3673 3674 if (put_user(len, optlen)) 3675 return -EFAULT; 3676 3677 return 0; 3678 } 3679 3680 /* 7.1.3 Initialization Parameters (SCTP_INITMSG) 3681 * 3682 * Applications can specify protocol parameters for the default association 3683 * initialization. The option name argument to setsockopt() and getsockopt() 3684 * is SCTP_INITMSG. 3685 * 3686 * Setting initialization parameters is effective only on an unconnected 3687 * socket (for UDP-style sockets only future associations are effected 3688 * by the change). With TCP-style sockets, this option is inherited by 3689 * sockets derived from a listener socket. 3690 */ 3691 static int sctp_getsockopt_initmsg(struct sock *sk, int len, char __user *optval, int __user *optlen) 3692 { 3693 if (len != sizeof(struct sctp_initmsg)) 3694 return -EINVAL; 3695 if (copy_to_user(optval, &sctp_sk(sk)->initmsg, len)) 3696 return -EFAULT; 3697 return 0; 3698 } 3699 3700 static int sctp_getsockopt_peer_addrs_num_old(struct sock *sk, int len, 3701 char __user *optval, 3702 int __user *optlen) 3703 { 3704 sctp_assoc_t id; 3705 struct sctp_association *asoc; 3706 struct list_head *pos; 3707 int cnt = 0; 3708 3709 if (len != sizeof(sctp_assoc_t)) 3710 return -EINVAL; 3711 3712 if (copy_from_user(&id, optval, sizeof(sctp_assoc_t))) 3713 return -EFAULT; 3714 3715 /* For UDP-style sockets, id specifies the association to query. */ 3716 asoc = sctp_id2assoc(sk, id); 3717 if (!asoc) 3718 return -EINVAL; 3719 3720 list_for_each(pos, &asoc->peer.transport_addr_list) { 3721 cnt ++; 3722 } 3723 3724 return cnt; 3725 } 3726 3727 /* 3728 * Old API for getting list of peer addresses. Does not work for 32-bit 3729 * programs running on a 64-bit kernel 3730 */ 3731 static int sctp_getsockopt_peer_addrs_old(struct sock *sk, int len, 3732 char __user *optval, 3733 int __user *optlen) 3734 { 3735 struct sctp_association *asoc; 3736 struct list_head *pos; 3737 int cnt = 0; 3738 struct sctp_getaddrs_old getaddrs; 3739 struct sctp_transport *from; 3740 void __user *to; 3741 union sctp_addr temp; 3742 struct sctp_sock *sp = sctp_sk(sk); 3743 int addrlen; 3744 3745 if (len != sizeof(struct sctp_getaddrs_old)) 3746 return -EINVAL; 3747 3748 if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs_old))) 3749 return -EFAULT; 3750 3751 if (getaddrs.addr_num <= 0) return -EINVAL; 3752 3753 /* For UDP-style sockets, id specifies the association to query. */ 3754 asoc = sctp_id2assoc(sk, getaddrs.assoc_id); 3755 if (!asoc) 3756 return -EINVAL; 3757 3758 to = (void __user *)getaddrs.addrs; 3759 list_for_each(pos, &asoc->peer.transport_addr_list) { 3760 from = list_entry(pos, struct sctp_transport, transports); 3761 memcpy(&temp, &from->ipaddr, sizeof(temp)); 3762 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp); 3763 addrlen = sctp_get_af_specific(sk->sk_family)->sockaddr_len; 3764 temp.v4.sin_port = htons(temp.v4.sin_port); 3765 if (copy_to_user(to, &temp, addrlen)) 3766 return -EFAULT; 3767 to += addrlen ; 3768 cnt ++; 3769 if (cnt >= getaddrs.addr_num) break; 3770 } 3771 getaddrs.addr_num = cnt; 3772 if (copy_to_user(optval, &getaddrs, sizeof(struct sctp_getaddrs_old))) 3773 return -EFAULT; 3774 3775 return 0; 3776 } 3777 3778 static int sctp_getsockopt_peer_addrs(struct sock *sk, int len, 3779 char __user *optval, int __user *optlen) 3780 { 3781 struct sctp_association *asoc; 3782 struct list_head *pos; 3783 int cnt = 0; 3784 struct sctp_getaddrs getaddrs; 3785 struct sctp_transport *from; 3786 void __user *to; 3787 union sctp_addr temp; 3788 struct sctp_sock *sp = sctp_sk(sk); 3789 int addrlen; 3790 size_t space_left; 3791 int bytes_copied; 3792 3793 if (len < sizeof(struct sctp_getaddrs)) 3794 return -EINVAL; 3795 3796 if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs))) 3797 return -EFAULT; 3798 3799 /* For UDP-style sockets, id specifies the association to query. */ 3800 asoc = sctp_id2assoc(sk, getaddrs.assoc_id); 3801 if (!asoc) 3802 return -EINVAL; 3803 3804 to = optval + offsetof(struct sctp_getaddrs,addrs); 3805 space_left = len - sizeof(struct sctp_getaddrs) - 3806 offsetof(struct sctp_getaddrs,addrs); 3807 3808 list_for_each(pos, &asoc->peer.transport_addr_list) { 3809 from = list_entry(pos, struct sctp_transport, transports); 3810 memcpy(&temp, &from->ipaddr, sizeof(temp)); 3811 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp); 3812 addrlen = sctp_get_af_specific(sk->sk_family)->sockaddr_len; 3813 if(space_left < addrlen) 3814 return -ENOMEM; 3815 temp.v4.sin_port = htons(temp.v4.sin_port); 3816 if (copy_to_user(to, &temp, addrlen)) 3817 return -EFAULT; 3818 to += addrlen; 3819 cnt++; 3820 space_left -= addrlen; 3821 } 3822 3823 if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num)) 3824 return -EFAULT; 3825 bytes_copied = ((char __user *)to) - optval; 3826 if (put_user(bytes_copied, optlen)) 3827 return -EFAULT; 3828 3829 return 0; 3830 } 3831 3832 static int sctp_getsockopt_local_addrs_num_old(struct sock *sk, int len, 3833 char __user *optval, 3834 int __user *optlen) 3835 { 3836 sctp_assoc_t id; 3837 struct sctp_bind_addr *bp; 3838 struct sctp_association *asoc; 3839 struct list_head *pos; 3840 struct sctp_sockaddr_entry *addr; 3841 rwlock_t *addr_lock; 3842 unsigned long flags; 3843 int cnt = 0; 3844 3845 if (len != sizeof(sctp_assoc_t)) 3846 return -EINVAL; 3847 3848 if (copy_from_user(&id, optval, sizeof(sctp_assoc_t))) 3849 return -EFAULT; 3850 3851 /* 3852 * For UDP-style sockets, id specifies the association to query. 3853 * If the id field is set to the value '0' then the locally bound 3854 * addresses are returned without regard to any particular 3855 * association. 3856 */ 3857 if (0 == id) { 3858 bp = &sctp_sk(sk)->ep->base.bind_addr; 3859 addr_lock = &sctp_sk(sk)->ep->base.addr_lock; 3860 } else { 3861 asoc = sctp_id2assoc(sk, id); 3862 if (!asoc) 3863 return -EINVAL; 3864 bp = &asoc->base.bind_addr; 3865 addr_lock = &asoc->base.addr_lock; 3866 } 3867 3868 sctp_read_lock(addr_lock); 3869 3870 /* If the endpoint is bound to 0.0.0.0 or ::0, count the valid 3871 * addresses from the global local address list. 3872 */ 3873 if (sctp_list_single_entry(&bp->address_list)) { 3874 addr = list_entry(bp->address_list.next, 3875 struct sctp_sockaddr_entry, list); 3876 if (sctp_is_any(&addr->a)) { 3877 sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags); 3878 list_for_each(pos, &sctp_local_addr_list) { 3879 addr = list_entry(pos, 3880 struct sctp_sockaddr_entry, 3881 list); 3882 if ((PF_INET == sk->sk_family) && 3883 (AF_INET6 == addr->a.sa.sa_family)) 3884 continue; 3885 cnt++; 3886 } 3887 sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, 3888 flags); 3889 } else { 3890 cnt = 1; 3891 } 3892 goto done; 3893 } 3894 3895 list_for_each(pos, &bp->address_list) { 3896 cnt ++; 3897 } 3898 3899 done: 3900 sctp_read_unlock(addr_lock); 3901 return cnt; 3902 } 3903 3904 /* Helper function that copies local addresses to user and returns the number 3905 * of addresses copied. 3906 */ 3907 static int sctp_copy_laddrs_to_user_old(struct sock *sk, __u16 port, int max_addrs, 3908 void __user *to) 3909 { 3910 struct list_head *pos; 3911 struct sctp_sockaddr_entry *addr; 3912 unsigned long flags; 3913 union sctp_addr temp; 3914 int cnt = 0; 3915 int addrlen; 3916 3917 sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags); 3918 list_for_each(pos, &sctp_local_addr_list) { 3919 addr = list_entry(pos, struct sctp_sockaddr_entry, list); 3920 if ((PF_INET == sk->sk_family) && 3921 (AF_INET6 == addr->a.sa.sa_family)) 3922 continue; 3923 memcpy(&temp, &addr->a, sizeof(temp)); 3924 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk), 3925 &temp); 3926 addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len; 3927 temp.v4.sin_port = htons(port); 3928 if (copy_to_user(to, &temp, addrlen)) { 3929 sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, 3930 flags); 3931 return -EFAULT; 3932 } 3933 to += addrlen; 3934 cnt ++; 3935 if (cnt >= max_addrs) break; 3936 } 3937 sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, flags); 3938 3939 return cnt; 3940 } 3941 3942 static int sctp_copy_laddrs_to_user(struct sock *sk, __u16 port, 3943 void __user **to, size_t space_left) 3944 { 3945 struct list_head *pos; 3946 struct sctp_sockaddr_entry *addr; 3947 unsigned long flags; 3948 union sctp_addr temp; 3949 int cnt = 0; 3950 int addrlen; 3951 3952 sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags); 3953 list_for_each(pos, &sctp_local_addr_list) { 3954 addr = list_entry(pos, struct sctp_sockaddr_entry, list); 3955 if ((PF_INET == sk->sk_family) && 3956 (AF_INET6 == addr->a.sa.sa_family)) 3957 continue; 3958 memcpy(&temp, &addr->a, sizeof(temp)); 3959 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk), 3960 &temp); 3961 addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len; 3962 if(space_left<addrlen) 3963 return -ENOMEM; 3964 temp.v4.sin_port = htons(port); 3965 if (copy_to_user(*to, &temp, addrlen)) { 3966 sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, 3967 flags); 3968 return -EFAULT; 3969 } 3970 *to += addrlen; 3971 cnt ++; 3972 space_left -= addrlen; 3973 } 3974 sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, flags); 3975 3976 return cnt; 3977 } 3978 3979 /* Old API for getting list of local addresses. Does not work for 32-bit 3980 * programs running on a 64-bit kernel 3981 */ 3982 static int sctp_getsockopt_local_addrs_old(struct sock *sk, int len, 3983 char __user *optval, int __user *optlen) 3984 { 3985 struct sctp_bind_addr *bp; 3986 struct sctp_association *asoc; 3987 struct list_head *pos; 3988 int cnt = 0; 3989 struct sctp_getaddrs_old getaddrs; 3990 struct sctp_sockaddr_entry *addr; 3991 void __user *to; 3992 union sctp_addr temp; 3993 struct sctp_sock *sp = sctp_sk(sk); 3994 int addrlen; 3995 rwlock_t *addr_lock; 3996 int err = 0; 3997 3998 if (len != sizeof(struct sctp_getaddrs_old)) 3999 return -EINVAL; 4000 4001 if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs_old))) 4002 return -EFAULT; 4003 4004 if (getaddrs.addr_num <= 0) return -EINVAL; 4005 /* 4006 * For UDP-style sockets, id specifies the association to query. 4007 * If the id field is set to the value '0' then the locally bound 4008 * addresses are returned without regard to any particular 4009 * association. 4010 */ 4011 if (0 == getaddrs.assoc_id) { 4012 bp = &sctp_sk(sk)->ep->base.bind_addr; 4013 addr_lock = &sctp_sk(sk)->ep->base.addr_lock; 4014 } else { 4015 asoc = sctp_id2assoc(sk, getaddrs.assoc_id); 4016 if (!asoc) 4017 return -EINVAL; 4018 bp = &asoc->base.bind_addr; 4019 addr_lock = &asoc->base.addr_lock; 4020 } 4021 4022 to = getaddrs.addrs; 4023 4024 sctp_read_lock(addr_lock); 4025 4026 /* If the endpoint is bound to 0.0.0.0 or ::0, get the valid 4027 * addresses from the global local address list. 4028 */ 4029 if (sctp_list_single_entry(&bp->address_list)) { 4030 addr = list_entry(bp->address_list.next, 4031 struct sctp_sockaddr_entry, list); 4032 if (sctp_is_any(&addr->a)) { 4033 cnt = sctp_copy_laddrs_to_user_old(sk, bp->port, 4034 getaddrs.addr_num, 4035 to); 4036 if (cnt < 0) { 4037 err = cnt; 4038 goto unlock; 4039 } 4040 goto copy_getaddrs; 4041 } 4042 } 4043 4044 list_for_each(pos, &bp->address_list) { 4045 addr = list_entry(pos, struct sctp_sockaddr_entry, list); 4046 memcpy(&temp, &addr->a, sizeof(temp)); 4047 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp); 4048 addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len; 4049 temp.v4.sin_port = htons(temp.v4.sin_port); 4050 if (copy_to_user(to, &temp, addrlen)) { 4051 err = -EFAULT; 4052 goto unlock; 4053 } 4054 to += addrlen; 4055 cnt ++; 4056 if (cnt >= getaddrs.addr_num) break; 4057 } 4058 4059 copy_getaddrs: 4060 getaddrs.addr_num = cnt; 4061 if (copy_to_user(optval, &getaddrs, sizeof(struct sctp_getaddrs_old))) 4062 err = -EFAULT; 4063 4064 unlock: 4065 sctp_read_unlock(addr_lock); 4066 return err; 4067 } 4068 4069 static int sctp_getsockopt_local_addrs(struct sock *sk, int len, 4070 char __user *optval, int __user *optlen) 4071 { 4072 struct sctp_bind_addr *bp; 4073 struct sctp_association *asoc; 4074 struct list_head *pos; 4075 int cnt = 0; 4076 struct sctp_getaddrs getaddrs; 4077 struct sctp_sockaddr_entry *addr; 4078 void __user *to; 4079 union sctp_addr temp; 4080 struct sctp_sock *sp = sctp_sk(sk); 4081 int addrlen; 4082 rwlock_t *addr_lock; 4083 int err = 0; 4084 size_t space_left; 4085 int bytes_copied; 4086 4087 if (len <= sizeof(struct sctp_getaddrs)) 4088 return -EINVAL; 4089 4090 if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs))) 4091 return -EFAULT; 4092 4093 /* 4094 * For UDP-style sockets, id specifies the association to query. 4095 * If the id field is set to the value '0' then the locally bound 4096 * addresses are returned without regard to any particular 4097 * association. 4098 */ 4099 if (0 == getaddrs.assoc_id) { 4100 bp = &sctp_sk(sk)->ep->base.bind_addr; 4101 addr_lock = &sctp_sk(sk)->ep->base.addr_lock; 4102 } else { 4103 asoc = sctp_id2assoc(sk, getaddrs.assoc_id); 4104 if (!asoc) 4105 return -EINVAL; 4106 bp = &asoc->base.bind_addr; 4107 addr_lock = &asoc->base.addr_lock; 4108 } 4109 4110 to = optval + offsetof(struct sctp_getaddrs,addrs); 4111 space_left = len - sizeof(struct sctp_getaddrs) - 4112 offsetof(struct sctp_getaddrs,addrs); 4113 4114 sctp_read_lock(addr_lock); 4115 4116 /* If the endpoint is bound to 0.0.0.0 or ::0, get the valid 4117 * addresses from the global local address list. 4118 */ 4119 if (sctp_list_single_entry(&bp->address_list)) { 4120 addr = list_entry(bp->address_list.next, 4121 struct sctp_sockaddr_entry, list); 4122 if (sctp_is_any(&addr->a)) { 4123 cnt = sctp_copy_laddrs_to_user(sk, bp->port, 4124 &to, space_left); 4125 if (cnt < 0) { 4126 err = cnt; 4127 goto unlock; 4128 } 4129 goto copy_getaddrs; 4130 } 4131 } 4132 4133 list_for_each(pos, &bp->address_list) { 4134 addr = list_entry(pos, struct sctp_sockaddr_entry, list); 4135 memcpy(&temp, &addr->a, sizeof(temp)); 4136 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp); 4137 addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len; 4138 if(space_left < addrlen) 4139 return -ENOMEM; /*fixme: right error?*/ 4140 temp.v4.sin_port = htons(temp.v4.sin_port); 4141 if (copy_to_user(to, &temp, addrlen)) { 4142 err = -EFAULT; 4143 goto unlock; 4144 } 4145 to += addrlen; 4146 cnt ++; 4147 space_left -= addrlen; 4148 } 4149 4150 copy_getaddrs: 4151 if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num)) 4152 return -EFAULT; 4153 bytes_copied = ((char __user *)to) - optval; 4154 if (put_user(bytes_copied, optlen)) 4155 return -EFAULT; 4156 4157 unlock: 4158 sctp_read_unlock(addr_lock); 4159 return err; 4160 } 4161 4162 /* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR) 4163 * 4164 * Requests that the local SCTP stack use the enclosed peer address as 4165 * the association primary. The enclosed address must be one of the 4166 * association peer's addresses. 4167 */ 4168 static int sctp_getsockopt_primary_addr(struct sock *sk, int len, 4169 char __user *optval, int __user *optlen) 4170 { 4171 struct sctp_prim prim; 4172 struct sctp_association *asoc; 4173 struct sctp_sock *sp = sctp_sk(sk); 4174 4175 if (len != sizeof(struct sctp_prim)) 4176 return -EINVAL; 4177 4178 if (copy_from_user(&prim, optval, sizeof(struct sctp_prim))) 4179 return -EFAULT; 4180 4181 asoc = sctp_id2assoc(sk, prim.ssp_assoc_id); 4182 if (!asoc) 4183 return -EINVAL; 4184 4185 if (!asoc->peer.primary_path) 4186 return -ENOTCONN; 4187 4188 asoc->peer.primary_path->ipaddr.v4.sin_port = 4189 htons(asoc->peer.primary_path->ipaddr.v4.sin_port); 4190 memcpy(&prim.ssp_addr, &asoc->peer.primary_path->ipaddr, 4191 sizeof(union sctp_addr)); 4192 asoc->peer.primary_path->ipaddr.v4.sin_port = 4193 ntohs(asoc->peer.primary_path->ipaddr.v4.sin_port); 4194 4195 sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, 4196 (union sctp_addr *)&prim.ssp_addr); 4197 4198 if (copy_to_user(optval, &prim, sizeof(struct sctp_prim))) 4199 return -EFAULT; 4200 4201 return 0; 4202 } 4203 4204 /* 4205 * 7.1.11 Set Adaption Layer Indicator (SCTP_ADAPTION_LAYER) 4206 * 4207 * Requests that the local endpoint set the specified Adaption Layer 4208 * Indication parameter for all future INIT and INIT-ACK exchanges. 4209 */ 4210 static int sctp_getsockopt_adaption_layer(struct sock *sk, int len, 4211 char __user *optval, int __user *optlen) 4212 { 4213 struct sctp_setadaption adaption; 4214 4215 if (len != sizeof(struct sctp_setadaption)) 4216 return -EINVAL; 4217 4218 adaption.ssb_adaption_ind = sctp_sk(sk)->adaption_ind; 4219 if (copy_to_user(optval, &adaption, len)) 4220 return -EFAULT; 4221 4222 return 0; 4223 } 4224 4225 /* 4226 * 4227 * 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM) 4228 * 4229 * Applications that wish to use the sendto() system call may wish to 4230 * specify a default set of parameters that would normally be supplied 4231 * through the inclusion of ancillary data. This socket option allows 4232 * such an application to set the default sctp_sndrcvinfo structure. 4233 4234 4235 * The application that wishes to use this socket option simply passes 4236 * in to this call the sctp_sndrcvinfo structure defined in Section 4237 * 5.2.2) The input parameters accepted by this call include 4238 * sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context, 4239 * sinfo_timetolive. The user must provide the sinfo_assoc_id field in 4240 * to this call if the caller is using the UDP model. 4241 * 4242 * For getsockopt, it get the default sctp_sndrcvinfo structure. 4243 */ 4244 static int sctp_getsockopt_default_send_param(struct sock *sk, 4245 int len, char __user *optval, 4246 int __user *optlen) 4247 { 4248 struct sctp_sndrcvinfo info; 4249 struct sctp_association *asoc; 4250 struct sctp_sock *sp = sctp_sk(sk); 4251 4252 if (len != sizeof(struct sctp_sndrcvinfo)) 4253 return -EINVAL; 4254 if (copy_from_user(&info, optval, sizeof(struct sctp_sndrcvinfo))) 4255 return -EFAULT; 4256 4257 asoc = sctp_id2assoc(sk, info.sinfo_assoc_id); 4258 if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP)) 4259 return -EINVAL; 4260 4261 if (asoc) { 4262 info.sinfo_stream = asoc->default_stream; 4263 info.sinfo_flags = asoc->default_flags; 4264 info.sinfo_ppid = asoc->default_ppid; 4265 info.sinfo_context = asoc->default_context; 4266 info.sinfo_timetolive = asoc->default_timetolive; 4267 } else { 4268 info.sinfo_stream = sp->default_stream; 4269 info.sinfo_flags = sp->default_flags; 4270 info.sinfo_ppid = sp->default_ppid; 4271 info.sinfo_context = sp->default_context; 4272 info.sinfo_timetolive = sp->default_timetolive; 4273 } 4274 4275 if (copy_to_user(optval, &info, sizeof(struct sctp_sndrcvinfo))) 4276 return -EFAULT; 4277 4278 return 0; 4279 } 4280 4281 /* 4282 * 4283 * 7.1.5 SCTP_NODELAY 4284 * 4285 * Turn on/off any Nagle-like algorithm. This means that packets are 4286 * generally sent as soon as possible and no unnecessary delays are 4287 * introduced, at the cost of more packets in the network. Expects an 4288 * integer boolean flag. 4289 */ 4290 4291 static int sctp_getsockopt_nodelay(struct sock *sk, int len, 4292 char __user *optval, int __user *optlen) 4293 { 4294 int val; 4295 4296 if (len < sizeof(int)) 4297 return -EINVAL; 4298 4299 len = sizeof(int); 4300 val = (sctp_sk(sk)->nodelay == 1); 4301 if (put_user(len, optlen)) 4302 return -EFAULT; 4303 if (copy_to_user(optval, &val, len)) 4304 return -EFAULT; 4305 return 0; 4306 } 4307 4308 /* 4309 * 4310 * 7.1.1 SCTP_RTOINFO 4311 * 4312 * The protocol parameters used to initialize and bound retransmission 4313 * timeout (RTO) are tunable. sctp_rtoinfo structure is used to access 4314 * and modify these parameters. 4315 * All parameters are time values, in milliseconds. A value of 0, when 4316 * modifying the parameters, indicates that the current value should not 4317 * be changed. 4318 * 4319 */ 4320 static int sctp_getsockopt_rtoinfo(struct sock *sk, int len, 4321 char __user *optval, 4322 int __user *optlen) { 4323 struct sctp_rtoinfo rtoinfo; 4324 struct sctp_association *asoc; 4325 4326 if (len != sizeof (struct sctp_rtoinfo)) 4327 return -EINVAL; 4328 4329 if (copy_from_user(&rtoinfo, optval, sizeof (struct sctp_rtoinfo))) 4330 return -EFAULT; 4331 4332 asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id); 4333 4334 if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP)) 4335 return -EINVAL; 4336 4337 /* Values corresponding to the specific association. */ 4338 if (asoc) { 4339 rtoinfo.srto_initial = jiffies_to_msecs(asoc->rto_initial); 4340 rtoinfo.srto_max = jiffies_to_msecs(asoc->rto_max); 4341 rtoinfo.srto_min = jiffies_to_msecs(asoc->rto_min); 4342 } else { 4343 /* Values corresponding to the endpoint. */ 4344 struct sctp_sock *sp = sctp_sk(sk); 4345 4346 rtoinfo.srto_initial = sp->rtoinfo.srto_initial; 4347 rtoinfo.srto_max = sp->rtoinfo.srto_max; 4348 rtoinfo.srto_min = sp->rtoinfo.srto_min; 4349 } 4350 4351 if (put_user(len, optlen)) 4352 return -EFAULT; 4353 4354 if (copy_to_user(optval, &rtoinfo, len)) 4355 return -EFAULT; 4356 4357 return 0; 4358 } 4359 4360 /* 4361 * 4362 * 7.1.2 SCTP_ASSOCINFO 4363 * 4364 * This option is used to tune the the maximum retransmission attempts 4365 * of the association. 4366 * Returns an error if the new association retransmission value is 4367 * greater than the sum of the retransmission value of the peer. 4368 * See [SCTP] for more information. 4369 * 4370 */ 4371 static int sctp_getsockopt_associnfo(struct sock *sk, int len, 4372 char __user *optval, 4373 int __user *optlen) 4374 { 4375 4376 struct sctp_assocparams assocparams; 4377 struct sctp_association *asoc; 4378 struct list_head *pos; 4379 int cnt = 0; 4380 4381 if (len != sizeof (struct sctp_assocparams)) 4382 return -EINVAL; 4383 4384 if (copy_from_user(&assocparams, optval, 4385 sizeof (struct sctp_assocparams))) 4386 return -EFAULT; 4387 4388 asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id); 4389 4390 if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP)) 4391 return -EINVAL; 4392 4393 /* Values correspoinding to the specific association */ 4394 if (asoc) { 4395 assocparams.sasoc_asocmaxrxt = asoc->max_retrans; 4396 assocparams.sasoc_peer_rwnd = asoc->peer.rwnd; 4397 assocparams.sasoc_local_rwnd = asoc->a_rwnd; 4398 assocparams.sasoc_cookie_life = (asoc->cookie_life.tv_sec 4399 * 1000) + 4400 (asoc->cookie_life.tv_usec 4401 / 1000); 4402 4403 list_for_each(pos, &asoc->peer.transport_addr_list) { 4404 cnt ++; 4405 } 4406 4407 assocparams.sasoc_number_peer_destinations = cnt; 4408 } else { 4409 /* Values corresponding to the endpoint */ 4410 struct sctp_sock *sp = sctp_sk(sk); 4411 4412 assocparams.sasoc_asocmaxrxt = sp->assocparams.sasoc_asocmaxrxt; 4413 assocparams.sasoc_peer_rwnd = sp->assocparams.sasoc_peer_rwnd; 4414 assocparams.sasoc_local_rwnd = sp->assocparams.sasoc_local_rwnd; 4415 assocparams.sasoc_cookie_life = 4416 sp->assocparams.sasoc_cookie_life; 4417 assocparams.sasoc_number_peer_destinations = 4418 sp->assocparams. 4419 sasoc_number_peer_destinations; 4420 } 4421 4422 if (put_user(len, optlen)) 4423 return -EFAULT; 4424 4425 if (copy_to_user(optval, &assocparams, len)) 4426 return -EFAULT; 4427 4428 return 0; 4429 } 4430 4431 /* 4432 * 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR) 4433 * 4434 * This socket option is a boolean flag which turns on or off mapped V4 4435 * addresses. If this option is turned on and the socket is type 4436 * PF_INET6, then IPv4 addresses will be mapped to V6 representation. 4437 * If this option is turned off, then no mapping will be done of V4 4438 * addresses and a user will receive both PF_INET6 and PF_INET type 4439 * addresses on the socket. 4440 */ 4441 static int sctp_getsockopt_mappedv4(struct sock *sk, int len, 4442 char __user *optval, int __user *optlen) 4443 { 4444 int val; 4445 struct sctp_sock *sp = sctp_sk(sk); 4446 4447 if (len < sizeof(int)) 4448 return -EINVAL; 4449 4450 len = sizeof(int); 4451 val = sp->v4mapped; 4452 if (put_user(len, optlen)) 4453 return -EFAULT; 4454 if (copy_to_user(optval, &val, len)) 4455 return -EFAULT; 4456 4457 return 0; 4458 } 4459 4460 /* 4461 * 7.1.17 Set the maximum fragrmentation size (SCTP_MAXSEG) 4462 * 4463 * This socket option specifies the maximum size to put in any outgoing 4464 * SCTP chunk. If a message is larger than this size it will be 4465 * fragmented by SCTP into the specified size. Note that the underlying 4466 * SCTP implementation may fragment into smaller sized chunks when the 4467 * PMTU of the underlying association is smaller than the value set by 4468 * the user. 4469 */ 4470 static int sctp_getsockopt_maxseg(struct sock *sk, int len, 4471 char __user *optval, int __user *optlen) 4472 { 4473 int val; 4474 4475 if (len < sizeof(int)) 4476 return -EINVAL; 4477 4478 len = sizeof(int); 4479 4480 val = sctp_sk(sk)->user_frag; 4481 if (put_user(len, optlen)) 4482 return -EFAULT; 4483 if (copy_to_user(optval, &val, len)) 4484 return -EFAULT; 4485 4486 return 0; 4487 } 4488 4489 SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname, 4490 char __user *optval, int __user *optlen) 4491 { 4492 int retval = 0; 4493 int len; 4494 4495 SCTP_DEBUG_PRINTK("sctp_getsockopt(sk: %p... optname: %d)\n", 4496 sk, optname); 4497 4498 /* I can hardly begin to describe how wrong this is. This is 4499 * so broken as to be worse than useless. The API draft 4500 * REALLY is NOT helpful here... I am not convinced that the 4501 * semantics of getsockopt() with a level OTHER THAN SOL_SCTP 4502 * are at all well-founded. 4503 */ 4504 if (level != SOL_SCTP) { 4505 struct sctp_af *af = sctp_sk(sk)->pf->af; 4506 4507 retval = af->getsockopt(sk, level, optname, optval, optlen); 4508 return retval; 4509 } 4510 4511 if (get_user(len, optlen)) 4512 return -EFAULT; 4513 4514 sctp_lock_sock(sk); 4515 4516 switch (optname) { 4517 case SCTP_STATUS: 4518 retval = sctp_getsockopt_sctp_status(sk, len, optval, optlen); 4519 break; 4520 case SCTP_DISABLE_FRAGMENTS: 4521 retval = sctp_getsockopt_disable_fragments(sk, len, optval, 4522 optlen); 4523 break; 4524 case SCTP_EVENTS: 4525 retval = sctp_getsockopt_events(sk, len, optval, optlen); 4526 break; 4527 case SCTP_AUTOCLOSE: 4528 retval = sctp_getsockopt_autoclose(sk, len, optval, optlen); 4529 break; 4530 case SCTP_SOCKOPT_PEELOFF: 4531 retval = sctp_getsockopt_peeloff(sk, len, optval, optlen); 4532 break; 4533 case SCTP_PEER_ADDR_PARAMS: 4534 retval = sctp_getsockopt_peer_addr_params(sk, len, optval, 4535 optlen); 4536 break; 4537 case SCTP_DELAYED_ACK_TIME: 4538 retval = sctp_getsockopt_delayed_ack_time(sk, len, optval, 4539 optlen); 4540 break; 4541 case SCTP_INITMSG: 4542 retval = sctp_getsockopt_initmsg(sk, len, optval, optlen); 4543 break; 4544 case SCTP_GET_PEER_ADDRS_NUM_OLD: 4545 retval = sctp_getsockopt_peer_addrs_num_old(sk, len, optval, 4546 optlen); 4547 break; 4548 case SCTP_GET_LOCAL_ADDRS_NUM_OLD: 4549 retval = sctp_getsockopt_local_addrs_num_old(sk, len, optval, 4550 optlen); 4551 break; 4552 case SCTP_GET_PEER_ADDRS_OLD: 4553 retval = sctp_getsockopt_peer_addrs_old(sk, len, optval, 4554 optlen); 4555 break; 4556 case SCTP_GET_LOCAL_ADDRS_OLD: 4557 retval = sctp_getsockopt_local_addrs_old(sk, len, optval, 4558 optlen); 4559 break; 4560 case SCTP_GET_PEER_ADDRS: 4561 retval = sctp_getsockopt_peer_addrs(sk, len, optval, 4562 optlen); 4563 break; 4564 case SCTP_GET_LOCAL_ADDRS: 4565 retval = sctp_getsockopt_local_addrs(sk, len, optval, 4566 optlen); 4567 break; 4568 case SCTP_DEFAULT_SEND_PARAM: 4569 retval = sctp_getsockopt_default_send_param(sk, len, 4570 optval, optlen); 4571 break; 4572 case SCTP_PRIMARY_ADDR: 4573 retval = sctp_getsockopt_primary_addr(sk, len, optval, optlen); 4574 break; 4575 case SCTP_NODELAY: 4576 retval = sctp_getsockopt_nodelay(sk, len, optval, optlen); 4577 break; 4578 case SCTP_RTOINFO: 4579 retval = sctp_getsockopt_rtoinfo(sk, len, optval, optlen); 4580 break; 4581 case SCTP_ASSOCINFO: 4582 retval = sctp_getsockopt_associnfo(sk, len, optval, optlen); 4583 break; 4584 case SCTP_I_WANT_MAPPED_V4_ADDR: 4585 retval = sctp_getsockopt_mappedv4(sk, len, optval, optlen); 4586 break; 4587 case SCTP_MAXSEG: 4588 retval = sctp_getsockopt_maxseg(sk, len, optval, optlen); 4589 break; 4590 case SCTP_GET_PEER_ADDR_INFO: 4591 retval = sctp_getsockopt_peer_addr_info(sk, len, optval, 4592 optlen); 4593 break; 4594 case SCTP_ADAPTION_LAYER: 4595 retval = sctp_getsockopt_adaption_layer(sk, len, optval, 4596 optlen); 4597 break; 4598 default: 4599 retval = -ENOPROTOOPT; 4600 break; 4601 }; 4602 4603 sctp_release_sock(sk); 4604 return retval; 4605 } 4606 4607 static void sctp_hash(struct sock *sk) 4608 { 4609 /* STUB */ 4610 } 4611 4612 static void sctp_unhash(struct sock *sk) 4613 { 4614 /* STUB */ 4615 } 4616 4617 /* Check if port is acceptable. Possibly find first available port. 4618 * 4619 * The port hash table (contained in the 'global' SCTP protocol storage 4620 * returned by struct sctp_protocol *sctp_get_protocol()). The hash 4621 * table is an array of 4096 lists (sctp_bind_hashbucket). Each 4622 * list (the list number is the port number hashed out, so as you 4623 * would expect from a hash function, all the ports in a given list have 4624 * such a number that hashes out to the same list number; you were 4625 * expecting that, right?); so each list has a set of ports, with a 4626 * link to the socket (struct sock) that uses it, the port number and 4627 * a fastreuse flag (FIXME: NPI ipg). 4628 */ 4629 static struct sctp_bind_bucket *sctp_bucket_create( 4630 struct sctp_bind_hashbucket *head, unsigned short snum); 4631 4632 static long sctp_get_port_local(struct sock *sk, union sctp_addr *addr) 4633 { 4634 struct sctp_bind_hashbucket *head; /* hash list */ 4635 struct sctp_bind_bucket *pp; /* hash list port iterator */ 4636 unsigned short snum; 4637 int ret; 4638 4639 /* NOTE: Remember to put this back to net order. */ 4640 addr->v4.sin_port = ntohs(addr->v4.sin_port); 4641 snum = addr->v4.sin_port; 4642 4643 SCTP_DEBUG_PRINTK("sctp_get_port() begins, snum=%d\n", snum); 4644 sctp_local_bh_disable(); 4645 4646 if (snum == 0) { 4647 /* Search for an available port. 4648 * 4649 * 'sctp_port_rover' was the last port assigned, so 4650 * we start to search from 'sctp_port_rover + 4651 * 1'. What we do is first check if port 'rover' is 4652 * already in the hash table; if not, we use that; if 4653 * it is, we try next. 4654 */ 4655 int low = sysctl_local_port_range[0]; 4656 int high = sysctl_local_port_range[1]; 4657 int remaining = (high - low) + 1; 4658 int rover; 4659 int index; 4660 4661 sctp_spin_lock(&sctp_port_alloc_lock); 4662 rover = sctp_port_rover; 4663 do { 4664 rover++; 4665 if ((rover < low) || (rover > high)) 4666 rover = low; 4667 index = sctp_phashfn(rover); 4668 head = &sctp_port_hashtable[index]; 4669 sctp_spin_lock(&head->lock); 4670 for (pp = head->chain; pp; pp = pp->next) 4671 if (pp->port == rover) 4672 goto next; 4673 break; 4674 next: 4675 sctp_spin_unlock(&head->lock); 4676 } while (--remaining > 0); 4677 sctp_port_rover = rover; 4678 sctp_spin_unlock(&sctp_port_alloc_lock); 4679 4680 /* Exhausted local port range during search? */ 4681 ret = 1; 4682 if (remaining <= 0) 4683 goto fail; 4684 4685 /* OK, here is the one we will use. HEAD (the port 4686 * hash table list entry) is non-NULL and we hold it's 4687 * mutex. 4688 */ 4689 snum = rover; 4690 } else { 4691 /* We are given an specific port number; we verify 4692 * that it is not being used. If it is used, we will 4693 * exahust the search in the hash list corresponding 4694 * to the port number (snum) - we detect that with the 4695 * port iterator, pp being NULL. 4696 */ 4697 head = &sctp_port_hashtable[sctp_phashfn(snum)]; 4698 sctp_spin_lock(&head->lock); 4699 for (pp = head->chain; pp; pp = pp->next) { 4700 if (pp->port == snum) 4701 goto pp_found; 4702 } 4703 } 4704 pp = NULL; 4705 goto pp_not_found; 4706 pp_found: 4707 if (!hlist_empty(&pp->owner)) { 4708 /* We had a port hash table hit - there is an 4709 * available port (pp != NULL) and it is being 4710 * used by other socket (pp->owner not empty); that other 4711 * socket is going to be sk2. 4712 */ 4713 int reuse = sk->sk_reuse; 4714 struct sock *sk2; 4715 struct hlist_node *node; 4716 4717 SCTP_DEBUG_PRINTK("sctp_get_port() found a possible match\n"); 4718 if (pp->fastreuse && sk->sk_reuse) 4719 goto success; 4720 4721 /* Run through the list of sockets bound to the port 4722 * (pp->port) [via the pointers bind_next and 4723 * bind_pprev in the struct sock *sk2 (pp->sk)]. On each one, 4724 * we get the endpoint they describe and run through 4725 * the endpoint's list of IP (v4 or v6) addresses, 4726 * comparing each of the addresses with the address of 4727 * the socket sk. If we find a match, then that means 4728 * that this port/socket (sk) combination are already 4729 * in an endpoint. 4730 */ 4731 sk_for_each_bound(sk2, node, &pp->owner) { 4732 struct sctp_endpoint *ep2; 4733 ep2 = sctp_sk(sk2)->ep; 4734 4735 if (reuse && sk2->sk_reuse) 4736 continue; 4737 4738 if (sctp_bind_addr_match(&ep2->base.bind_addr, addr, 4739 sctp_sk(sk))) { 4740 ret = (long)sk2; 4741 goto fail_unlock; 4742 } 4743 } 4744 SCTP_DEBUG_PRINTK("sctp_get_port(): Found a match\n"); 4745 } 4746 pp_not_found: 4747 /* If there was a hash table miss, create a new port. */ 4748 ret = 1; 4749 if (!pp && !(pp = sctp_bucket_create(head, snum))) 4750 goto fail_unlock; 4751 4752 /* In either case (hit or miss), make sure fastreuse is 1 only 4753 * if sk->sk_reuse is too (that is, if the caller requested 4754 * SO_REUSEADDR on this socket -sk-). 4755 */ 4756 if (hlist_empty(&pp->owner)) 4757 pp->fastreuse = sk->sk_reuse ? 1 : 0; 4758 else if (pp->fastreuse && !sk->sk_reuse) 4759 pp->fastreuse = 0; 4760 4761 /* We are set, so fill up all the data in the hash table 4762 * entry, tie the socket list information with the rest of the 4763 * sockets FIXME: Blurry, NPI (ipg). 4764 */ 4765 success: 4766 inet_sk(sk)->num = snum; 4767 if (!sctp_sk(sk)->bind_hash) { 4768 sk_add_bind_node(sk, &pp->owner); 4769 sctp_sk(sk)->bind_hash = pp; 4770 } 4771 ret = 0; 4772 4773 fail_unlock: 4774 sctp_spin_unlock(&head->lock); 4775 4776 fail: 4777 sctp_local_bh_enable(); 4778 addr->v4.sin_port = htons(addr->v4.sin_port); 4779 return ret; 4780 } 4781 4782 /* Assign a 'snum' port to the socket. If snum == 0, an ephemeral 4783 * port is requested. 4784 */ 4785 static int sctp_get_port(struct sock *sk, unsigned short snum) 4786 { 4787 long ret; 4788 union sctp_addr addr; 4789 struct sctp_af *af = sctp_sk(sk)->pf->af; 4790 4791 /* Set up a dummy address struct from the sk. */ 4792 af->from_sk(&addr, sk); 4793 addr.v4.sin_port = htons(snum); 4794 4795 /* Note: sk->sk_num gets filled in if ephemeral port request. */ 4796 ret = sctp_get_port_local(sk, &addr); 4797 4798 return (ret ? 1 : 0); 4799 } 4800 4801 /* 4802 * 3.1.3 listen() - UDP Style Syntax 4803 * 4804 * By default, new associations are not accepted for UDP style sockets. 4805 * An application uses listen() to mark a socket as being able to 4806 * accept new associations. 4807 */ 4808 SCTP_STATIC int sctp_seqpacket_listen(struct sock *sk, int backlog) 4809 { 4810 struct sctp_sock *sp = sctp_sk(sk); 4811 struct sctp_endpoint *ep = sp->ep; 4812 4813 /* Only UDP style sockets that are not peeled off are allowed to 4814 * listen(). 4815 */ 4816 if (!sctp_style(sk, UDP)) 4817 return -EINVAL; 4818 4819 /* If backlog is zero, disable listening. */ 4820 if (!backlog) { 4821 if (sctp_sstate(sk, CLOSED)) 4822 return 0; 4823 4824 sctp_unhash_endpoint(ep); 4825 sk->sk_state = SCTP_SS_CLOSED; 4826 } 4827 4828 /* Return if we are already listening. */ 4829 if (sctp_sstate(sk, LISTENING)) 4830 return 0; 4831 4832 /* 4833 * If a bind() or sctp_bindx() is not called prior to a listen() 4834 * call that allows new associations to be accepted, the system 4835 * picks an ephemeral port and will choose an address set equivalent 4836 * to binding with a wildcard address. 4837 * 4838 * This is not currently spelled out in the SCTP sockets 4839 * extensions draft, but follows the practice as seen in TCP 4840 * sockets. 4841 */ 4842 if (!ep->base.bind_addr.port) { 4843 if (sctp_autobind(sk)) 4844 return -EAGAIN; 4845 } 4846 sk->sk_state = SCTP_SS_LISTENING; 4847 sctp_hash_endpoint(ep); 4848 return 0; 4849 } 4850 4851 /* 4852 * 4.1.3 listen() - TCP Style Syntax 4853 * 4854 * Applications uses listen() to ready the SCTP endpoint for accepting 4855 * inbound associations. 4856 */ 4857 SCTP_STATIC int sctp_stream_listen(struct sock *sk, int backlog) 4858 { 4859 struct sctp_sock *sp = sctp_sk(sk); 4860 struct sctp_endpoint *ep = sp->ep; 4861 4862 /* If backlog is zero, disable listening. */ 4863 if (!backlog) { 4864 if (sctp_sstate(sk, CLOSED)) 4865 return 0; 4866 4867 sctp_unhash_endpoint(ep); 4868 sk->sk_state = SCTP_SS_CLOSED; 4869 } 4870 4871 if (sctp_sstate(sk, LISTENING)) 4872 return 0; 4873 4874 /* 4875 * If a bind() or sctp_bindx() is not called prior to a listen() 4876 * call that allows new associations to be accepted, the system 4877 * picks an ephemeral port and will choose an address set equivalent 4878 * to binding with a wildcard address. 4879 * 4880 * This is not currently spelled out in the SCTP sockets 4881 * extensions draft, but follows the practice as seen in TCP 4882 * sockets. 4883 */ 4884 if (!ep->base.bind_addr.port) { 4885 if (sctp_autobind(sk)) 4886 return -EAGAIN; 4887 } 4888 sk->sk_state = SCTP_SS_LISTENING; 4889 sk->sk_max_ack_backlog = backlog; 4890 sctp_hash_endpoint(ep); 4891 return 0; 4892 } 4893 4894 /* 4895 * Move a socket to LISTENING state. 4896 */ 4897 int sctp_inet_listen(struct socket *sock, int backlog) 4898 { 4899 struct sock *sk = sock->sk; 4900 struct crypto_hash *tfm = NULL; 4901 int err = -EINVAL; 4902 4903 if (unlikely(backlog < 0)) 4904 goto out; 4905 4906 sctp_lock_sock(sk); 4907 4908 if (sock->state != SS_UNCONNECTED) 4909 goto out; 4910 4911 /* Allocate HMAC for generating cookie. */ 4912 if (sctp_hmac_alg) { 4913 tfm = crypto_alloc_hash(sctp_hmac_alg, 0, CRYPTO_ALG_ASYNC); 4914 if (!tfm) { 4915 err = -ENOSYS; 4916 goto out; 4917 } 4918 } 4919 4920 switch (sock->type) { 4921 case SOCK_SEQPACKET: 4922 err = sctp_seqpacket_listen(sk, backlog); 4923 break; 4924 case SOCK_STREAM: 4925 err = sctp_stream_listen(sk, backlog); 4926 break; 4927 default: 4928 break; 4929 }; 4930 if (err) 4931 goto cleanup; 4932 4933 /* Store away the transform reference. */ 4934 sctp_sk(sk)->hmac = tfm; 4935 out: 4936 sctp_release_sock(sk); 4937 return err; 4938 cleanup: 4939 crypto_free_hash(tfm); 4940 goto out; 4941 } 4942 4943 /* 4944 * This function is done by modeling the current datagram_poll() and the 4945 * tcp_poll(). Note that, based on these implementations, we don't 4946 * lock the socket in this function, even though it seems that, 4947 * ideally, locking or some other mechanisms can be used to ensure 4948 * the integrity of the counters (sndbuf and wmem_alloc) used 4949 * in this place. We assume that we don't need locks either until proven 4950 * otherwise. 4951 * 4952 * Another thing to note is that we include the Async I/O support 4953 * here, again, by modeling the current TCP/UDP code. We don't have 4954 * a good way to test with it yet. 4955 */ 4956 unsigned int sctp_poll(struct file *file, struct socket *sock, poll_table *wait) 4957 { 4958 struct sock *sk = sock->sk; 4959 struct sctp_sock *sp = sctp_sk(sk); 4960 unsigned int mask; 4961 4962 poll_wait(file, sk->sk_sleep, wait); 4963 4964 /* A TCP-style listening socket becomes readable when the accept queue 4965 * is not empty. 4966 */ 4967 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)) 4968 return (!list_empty(&sp->ep->asocs)) ? 4969 (POLLIN | POLLRDNORM) : 0; 4970 4971 mask = 0; 4972 4973 /* Is there any exceptional events? */ 4974 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue)) 4975 mask |= POLLERR; 4976 if (sk->sk_shutdown & RCV_SHUTDOWN) 4977 mask |= POLLRDHUP; 4978 if (sk->sk_shutdown == SHUTDOWN_MASK) 4979 mask |= POLLHUP; 4980 4981 /* Is it readable? Reconsider this code with TCP-style support. */ 4982 if (!skb_queue_empty(&sk->sk_receive_queue) || 4983 (sk->sk_shutdown & RCV_SHUTDOWN)) 4984 mask |= POLLIN | POLLRDNORM; 4985 4986 /* The association is either gone or not ready. */ 4987 if (!sctp_style(sk, UDP) && sctp_sstate(sk, CLOSED)) 4988 return mask; 4989 4990 /* Is it writable? */ 4991 if (sctp_writeable(sk)) { 4992 mask |= POLLOUT | POLLWRNORM; 4993 } else { 4994 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags); 4995 /* 4996 * Since the socket is not locked, the buffer 4997 * might be made available after the writeable check and 4998 * before the bit is set. This could cause a lost I/O 4999 * signal. tcp_poll() has a race breaker for this race 5000 * condition. Based on their implementation, we put 5001 * in the following code to cover it as well. 5002 */ 5003 if (sctp_writeable(sk)) 5004 mask |= POLLOUT | POLLWRNORM; 5005 } 5006 return mask; 5007 } 5008 5009 /******************************************************************** 5010 * 2nd Level Abstractions 5011 ********************************************************************/ 5012 5013 static struct sctp_bind_bucket *sctp_bucket_create( 5014 struct sctp_bind_hashbucket *head, unsigned short snum) 5015 { 5016 struct sctp_bind_bucket *pp; 5017 5018 pp = kmem_cache_alloc(sctp_bucket_cachep, SLAB_ATOMIC); 5019 SCTP_DBG_OBJCNT_INC(bind_bucket); 5020 if (pp) { 5021 pp->port = snum; 5022 pp->fastreuse = 0; 5023 INIT_HLIST_HEAD(&pp->owner); 5024 if ((pp->next = head->chain) != NULL) 5025 pp->next->pprev = &pp->next; 5026 head->chain = pp; 5027 pp->pprev = &head->chain; 5028 } 5029 return pp; 5030 } 5031 5032 /* Caller must hold hashbucket lock for this tb with local BH disabled */ 5033 static void sctp_bucket_destroy(struct sctp_bind_bucket *pp) 5034 { 5035 if (pp && hlist_empty(&pp->owner)) { 5036 if (pp->next) 5037 pp->next->pprev = pp->pprev; 5038 *(pp->pprev) = pp->next; 5039 kmem_cache_free(sctp_bucket_cachep, pp); 5040 SCTP_DBG_OBJCNT_DEC(bind_bucket); 5041 } 5042 } 5043 5044 /* Release this socket's reference to a local port. */ 5045 static inline void __sctp_put_port(struct sock *sk) 5046 { 5047 struct sctp_bind_hashbucket *head = 5048 &sctp_port_hashtable[sctp_phashfn(inet_sk(sk)->num)]; 5049 struct sctp_bind_bucket *pp; 5050 5051 sctp_spin_lock(&head->lock); 5052 pp = sctp_sk(sk)->bind_hash; 5053 __sk_del_bind_node(sk); 5054 sctp_sk(sk)->bind_hash = NULL; 5055 inet_sk(sk)->num = 0; 5056 sctp_bucket_destroy(pp); 5057 sctp_spin_unlock(&head->lock); 5058 } 5059 5060 void sctp_put_port(struct sock *sk) 5061 { 5062 sctp_local_bh_disable(); 5063 __sctp_put_port(sk); 5064 sctp_local_bh_enable(); 5065 } 5066 5067 /* 5068 * The system picks an ephemeral port and choose an address set equivalent 5069 * to binding with a wildcard address. 5070 * One of those addresses will be the primary address for the association. 5071 * This automatically enables the multihoming capability of SCTP. 5072 */ 5073 static int sctp_autobind(struct sock *sk) 5074 { 5075 union sctp_addr autoaddr; 5076 struct sctp_af *af; 5077 unsigned short port; 5078 5079 /* Initialize a local sockaddr structure to INADDR_ANY. */ 5080 af = sctp_sk(sk)->pf->af; 5081 5082 port = htons(inet_sk(sk)->num); 5083 af->inaddr_any(&autoaddr, port); 5084 5085 return sctp_do_bind(sk, &autoaddr, af->sockaddr_len); 5086 } 5087 5088 /* Parse out IPPROTO_SCTP CMSG headers. Perform only minimal validation. 5089 * 5090 * From RFC 2292 5091 * 4.2 The cmsghdr Structure * 5092 * 5093 * When ancillary data is sent or received, any number of ancillary data 5094 * objects can be specified by the msg_control and msg_controllen members of 5095 * the msghdr structure, because each object is preceded by 5096 * a cmsghdr structure defining the object's length (the cmsg_len member). 5097 * Historically Berkeley-derived implementations have passed only one object 5098 * at a time, but this API allows multiple objects to be 5099 * passed in a single call to sendmsg() or recvmsg(). The following example 5100 * shows two ancillary data objects in a control buffer. 5101 * 5102 * |<--------------------------- msg_controllen -------------------------->| 5103 * | | 5104 * 5105 * |<----- ancillary data object ----->|<----- ancillary data object ----->| 5106 * 5107 * |<---------- CMSG_SPACE() --------->|<---------- CMSG_SPACE() --------->| 5108 * | | | 5109 * 5110 * |<---------- cmsg_len ---------->| |<--------- cmsg_len ----------->| | 5111 * 5112 * |<--------- CMSG_LEN() --------->| |<-------- CMSG_LEN() ---------->| | 5113 * | | | | | 5114 * 5115 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+ 5116 * |cmsg_|cmsg_|cmsg_|XX| |XX|cmsg_|cmsg_|cmsg_|XX| |XX| 5117 * 5118 * |len |level|type |XX|cmsg_data[]|XX|len |level|type |XX|cmsg_data[]|XX| 5119 * 5120 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+ 5121 * ^ 5122 * | 5123 * 5124 * msg_control 5125 * points here 5126 */ 5127 SCTP_STATIC int sctp_msghdr_parse(const struct msghdr *msg, 5128 sctp_cmsgs_t *cmsgs) 5129 { 5130 struct cmsghdr *cmsg; 5131 5132 for (cmsg = CMSG_FIRSTHDR(msg); 5133 cmsg != NULL; 5134 cmsg = CMSG_NXTHDR((struct msghdr*)msg, cmsg)) { 5135 if (!CMSG_OK(msg, cmsg)) 5136 return -EINVAL; 5137 5138 /* Should we parse this header or ignore? */ 5139 if (cmsg->cmsg_level != IPPROTO_SCTP) 5140 continue; 5141 5142 /* Strictly check lengths following example in SCM code. */ 5143 switch (cmsg->cmsg_type) { 5144 case SCTP_INIT: 5145 /* SCTP Socket API Extension 5146 * 5.2.1 SCTP Initiation Structure (SCTP_INIT) 5147 * 5148 * This cmsghdr structure provides information for 5149 * initializing new SCTP associations with sendmsg(). 5150 * The SCTP_INITMSG socket option uses this same data 5151 * structure. This structure is not used for 5152 * recvmsg(). 5153 * 5154 * cmsg_level cmsg_type cmsg_data[] 5155 * ------------ ------------ ---------------------- 5156 * IPPROTO_SCTP SCTP_INIT struct sctp_initmsg 5157 */ 5158 if (cmsg->cmsg_len != 5159 CMSG_LEN(sizeof(struct sctp_initmsg))) 5160 return -EINVAL; 5161 cmsgs->init = (struct sctp_initmsg *)CMSG_DATA(cmsg); 5162 break; 5163 5164 case SCTP_SNDRCV: 5165 /* SCTP Socket API Extension 5166 * 5.2.2 SCTP Header Information Structure(SCTP_SNDRCV) 5167 * 5168 * This cmsghdr structure specifies SCTP options for 5169 * sendmsg() and describes SCTP header information 5170 * about a received message through recvmsg(). 5171 * 5172 * cmsg_level cmsg_type cmsg_data[] 5173 * ------------ ------------ ---------------------- 5174 * IPPROTO_SCTP SCTP_SNDRCV struct sctp_sndrcvinfo 5175 */ 5176 if (cmsg->cmsg_len != 5177 CMSG_LEN(sizeof(struct sctp_sndrcvinfo))) 5178 return -EINVAL; 5179 5180 cmsgs->info = 5181 (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg); 5182 5183 /* Minimally, validate the sinfo_flags. */ 5184 if (cmsgs->info->sinfo_flags & 5185 ~(SCTP_UNORDERED | SCTP_ADDR_OVER | 5186 SCTP_ABORT | SCTP_EOF)) 5187 return -EINVAL; 5188 break; 5189 5190 default: 5191 return -EINVAL; 5192 }; 5193 } 5194 return 0; 5195 } 5196 5197 /* 5198 * Wait for a packet.. 5199 * Note: This function is the same function as in core/datagram.c 5200 * with a few modifications to make lksctp work. 5201 */ 5202 static int sctp_wait_for_packet(struct sock * sk, int *err, long *timeo_p) 5203 { 5204 int error; 5205 DEFINE_WAIT(wait); 5206 5207 prepare_to_wait_exclusive(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 5208 5209 /* Socket errors? */ 5210 error = sock_error(sk); 5211 if (error) 5212 goto out; 5213 5214 if (!skb_queue_empty(&sk->sk_receive_queue)) 5215 goto ready; 5216 5217 /* Socket shut down? */ 5218 if (sk->sk_shutdown & RCV_SHUTDOWN) 5219 goto out; 5220 5221 /* Sequenced packets can come disconnected. If so we report the 5222 * problem. 5223 */ 5224 error = -ENOTCONN; 5225 5226 /* Is there a good reason to think that we may receive some data? */ 5227 if (list_empty(&sctp_sk(sk)->ep->asocs) && !sctp_sstate(sk, LISTENING)) 5228 goto out; 5229 5230 /* Handle signals. */ 5231 if (signal_pending(current)) 5232 goto interrupted; 5233 5234 /* Let another process have a go. Since we are going to sleep 5235 * anyway. Note: This may cause odd behaviors if the message 5236 * does not fit in the user's buffer, but this seems to be the 5237 * only way to honor MSG_DONTWAIT realistically. 5238 */ 5239 sctp_release_sock(sk); 5240 *timeo_p = schedule_timeout(*timeo_p); 5241 sctp_lock_sock(sk); 5242 5243 ready: 5244 finish_wait(sk->sk_sleep, &wait); 5245 return 0; 5246 5247 interrupted: 5248 error = sock_intr_errno(*timeo_p); 5249 5250 out: 5251 finish_wait(sk->sk_sleep, &wait); 5252 *err = error; 5253 return error; 5254 } 5255 5256 /* Receive a datagram. 5257 * Note: This is pretty much the same routine as in core/datagram.c 5258 * with a few changes to make lksctp work. 5259 */ 5260 static struct sk_buff *sctp_skb_recv_datagram(struct sock *sk, int flags, 5261 int noblock, int *err) 5262 { 5263 int error; 5264 struct sk_buff *skb; 5265 long timeo; 5266 5267 timeo = sock_rcvtimeo(sk, noblock); 5268 5269 SCTP_DEBUG_PRINTK("Timeout: timeo: %ld, MAX: %ld.\n", 5270 timeo, MAX_SCHEDULE_TIMEOUT); 5271 5272 do { 5273 /* Again only user level code calls this function, 5274 * so nothing interrupt level 5275 * will suddenly eat the receive_queue. 5276 * 5277 * Look at current nfs client by the way... 5278 * However, this function was corrent in any case. 8) 5279 */ 5280 if (flags & MSG_PEEK) { 5281 spin_lock_bh(&sk->sk_receive_queue.lock); 5282 skb = skb_peek(&sk->sk_receive_queue); 5283 if (skb) 5284 atomic_inc(&skb->users); 5285 spin_unlock_bh(&sk->sk_receive_queue.lock); 5286 } else { 5287 skb = skb_dequeue(&sk->sk_receive_queue); 5288 } 5289 5290 if (skb) 5291 return skb; 5292 5293 /* Caller is allowed not to check sk->sk_err before calling. */ 5294 error = sock_error(sk); 5295 if (error) 5296 goto no_packet; 5297 5298 if (sk->sk_shutdown & RCV_SHUTDOWN) 5299 break; 5300 5301 /* User doesn't want to wait. */ 5302 error = -EAGAIN; 5303 if (!timeo) 5304 goto no_packet; 5305 } while (sctp_wait_for_packet(sk, err, &timeo) == 0); 5306 5307 return NULL; 5308 5309 no_packet: 5310 *err = error; 5311 return NULL; 5312 } 5313 5314 /* If sndbuf has changed, wake up per association sndbuf waiters. */ 5315 static void __sctp_write_space(struct sctp_association *asoc) 5316 { 5317 struct sock *sk = asoc->base.sk; 5318 struct socket *sock = sk->sk_socket; 5319 5320 if ((sctp_wspace(asoc) > 0) && sock) { 5321 if (waitqueue_active(&asoc->wait)) 5322 wake_up_interruptible(&asoc->wait); 5323 5324 if (sctp_writeable(sk)) { 5325 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 5326 wake_up_interruptible(sk->sk_sleep); 5327 5328 /* Note that we try to include the Async I/O support 5329 * here by modeling from the current TCP/UDP code. 5330 * We have not tested with it yet. 5331 */ 5332 if (sock->fasync_list && 5333 !(sk->sk_shutdown & SEND_SHUTDOWN)) 5334 sock_wake_async(sock, 2, POLL_OUT); 5335 } 5336 } 5337 } 5338 5339 /* Do accounting for the sndbuf space. 5340 * Decrement the used sndbuf space of the corresponding association by the 5341 * data size which was just transmitted(freed). 5342 */ 5343 static void sctp_wfree(struct sk_buff *skb) 5344 { 5345 struct sctp_association *asoc; 5346 struct sctp_chunk *chunk; 5347 struct sock *sk; 5348 5349 /* Get the saved chunk pointer. */ 5350 chunk = *((struct sctp_chunk **)(skb->cb)); 5351 asoc = chunk->asoc; 5352 sk = asoc->base.sk; 5353 asoc->sndbuf_used -= SCTP_DATA_SNDSIZE(chunk) + 5354 sizeof(struct sk_buff) + 5355 sizeof(struct sctp_chunk); 5356 5357 atomic_sub(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc); 5358 5359 sock_wfree(skb); 5360 __sctp_write_space(asoc); 5361 5362 sctp_association_put(asoc); 5363 } 5364 5365 /* Helper function to wait for space in the sndbuf. */ 5366 static int sctp_wait_for_sndbuf(struct sctp_association *asoc, long *timeo_p, 5367 size_t msg_len) 5368 { 5369 struct sock *sk = asoc->base.sk; 5370 int err = 0; 5371 long current_timeo = *timeo_p; 5372 DEFINE_WAIT(wait); 5373 5374 SCTP_DEBUG_PRINTK("wait_for_sndbuf: asoc=%p, timeo=%ld, msg_len=%zu\n", 5375 asoc, (long)(*timeo_p), msg_len); 5376 5377 /* Increment the association's refcnt. */ 5378 sctp_association_hold(asoc); 5379 5380 /* Wait on the association specific sndbuf space. */ 5381 for (;;) { 5382 prepare_to_wait_exclusive(&asoc->wait, &wait, 5383 TASK_INTERRUPTIBLE); 5384 if (!*timeo_p) 5385 goto do_nonblock; 5386 if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING || 5387 asoc->base.dead) 5388 goto do_error; 5389 if (signal_pending(current)) 5390 goto do_interrupted; 5391 if (msg_len <= sctp_wspace(asoc)) 5392 break; 5393 5394 /* Let another process have a go. Since we are going 5395 * to sleep anyway. 5396 */ 5397 sctp_release_sock(sk); 5398 current_timeo = schedule_timeout(current_timeo); 5399 BUG_ON(sk != asoc->base.sk); 5400 sctp_lock_sock(sk); 5401 5402 *timeo_p = current_timeo; 5403 } 5404 5405 out: 5406 finish_wait(&asoc->wait, &wait); 5407 5408 /* Release the association's refcnt. */ 5409 sctp_association_put(asoc); 5410 5411 return err; 5412 5413 do_error: 5414 err = -EPIPE; 5415 goto out; 5416 5417 do_interrupted: 5418 err = sock_intr_errno(*timeo_p); 5419 goto out; 5420 5421 do_nonblock: 5422 err = -EAGAIN; 5423 goto out; 5424 } 5425 5426 /* If socket sndbuf has changed, wake up all per association waiters. */ 5427 void sctp_write_space(struct sock *sk) 5428 { 5429 struct sctp_association *asoc; 5430 struct list_head *pos; 5431 5432 /* Wake up the tasks in each wait queue. */ 5433 list_for_each(pos, &((sctp_sk(sk))->ep->asocs)) { 5434 asoc = list_entry(pos, struct sctp_association, asocs); 5435 __sctp_write_space(asoc); 5436 } 5437 } 5438 5439 /* Is there any sndbuf space available on the socket? 5440 * 5441 * Note that sk_wmem_alloc is the sum of the send buffers on all of the 5442 * associations on the same socket. For a UDP-style socket with 5443 * multiple associations, it is possible for it to be "unwriteable" 5444 * prematurely. I assume that this is acceptable because 5445 * a premature "unwriteable" is better than an accidental "writeable" which 5446 * would cause an unwanted block under certain circumstances. For the 1-1 5447 * UDP-style sockets or TCP-style sockets, this code should work. 5448 * - Daisy 5449 */ 5450 static int sctp_writeable(struct sock *sk) 5451 { 5452 int amt = 0; 5453 5454 amt = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc); 5455 if (amt < 0) 5456 amt = 0; 5457 return amt; 5458 } 5459 5460 /* Wait for an association to go into ESTABLISHED state. If timeout is 0, 5461 * returns immediately with EINPROGRESS. 5462 */ 5463 static int sctp_wait_for_connect(struct sctp_association *asoc, long *timeo_p) 5464 { 5465 struct sock *sk = asoc->base.sk; 5466 int err = 0; 5467 long current_timeo = *timeo_p; 5468 DEFINE_WAIT(wait); 5469 5470 SCTP_DEBUG_PRINTK("%s: asoc=%p, timeo=%ld\n", __FUNCTION__, asoc, 5471 (long)(*timeo_p)); 5472 5473 /* Increment the association's refcnt. */ 5474 sctp_association_hold(asoc); 5475 5476 for (;;) { 5477 prepare_to_wait_exclusive(&asoc->wait, &wait, 5478 TASK_INTERRUPTIBLE); 5479 if (!*timeo_p) 5480 goto do_nonblock; 5481 if (sk->sk_shutdown & RCV_SHUTDOWN) 5482 break; 5483 if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING || 5484 asoc->base.dead) 5485 goto do_error; 5486 if (signal_pending(current)) 5487 goto do_interrupted; 5488 5489 if (sctp_state(asoc, ESTABLISHED)) 5490 break; 5491 5492 /* Let another process have a go. Since we are going 5493 * to sleep anyway. 5494 */ 5495 sctp_release_sock(sk); 5496 current_timeo = schedule_timeout(current_timeo); 5497 sctp_lock_sock(sk); 5498 5499 *timeo_p = current_timeo; 5500 } 5501 5502 out: 5503 finish_wait(&asoc->wait, &wait); 5504 5505 /* Release the association's refcnt. */ 5506 sctp_association_put(asoc); 5507 5508 return err; 5509 5510 do_error: 5511 if (asoc->init_err_counter + 1 > asoc->max_init_attempts) 5512 err = -ETIMEDOUT; 5513 else 5514 err = -ECONNREFUSED; 5515 goto out; 5516 5517 do_interrupted: 5518 err = sock_intr_errno(*timeo_p); 5519 goto out; 5520 5521 do_nonblock: 5522 err = -EINPROGRESS; 5523 goto out; 5524 } 5525 5526 static int sctp_wait_for_accept(struct sock *sk, long timeo) 5527 { 5528 struct sctp_endpoint *ep; 5529 int err = 0; 5530 DEFINE_WAIT(wait); 5531 5532 ep = sctp_sk(sk)->ep; 5533 5534 5535 for (;;) { 5536 prepare_to_wait_exclusive(sk->sk_sleep, &wait, 5537 TASK_INTERRUPTIBLE); 5538 5539 if (list_empty(&ep->asocs)) { 5540 sctp_release_sock(sk); 5541 timeo = schedule_timeout(timeo); 5542 sctp_lock_sock(sk); 5543 } 5544 5545 err = -EINVAL; 5546 if (!sctp_sstate(sk, LISTENING)) 5547 break; 5548 5549 err = 0; 5550 if (!list_empty(&ep->asocs)) 5551 break; 5552 5553 err = sock_intr_errno(timeo); 5554 if (signal_pending(current)) 5555 break; 5556 5557 err = -EAGAIN; 5558 if (!timeo) 5559 break; 5560 } 5561 5562 finish_wait(sk->sk_sleep, &wait); 5563 5564 return err; 5565 } 5566 5567 void sctp_wait_for_close(struct sock *sk, long timeout) 5568 { 5569 DEFINE_WAIT(wait); 5570 5571 do { 5572 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 5573 if (list_empty(&sctp_sk(sk)->ep->asocs)) 5574 break; 5575 sctp_release_sock(sk); 5576 timeout = schedule_timeout(timeout); 5577 sctp_lock_sock(sk); 5578 } while (!signal_pending(current) && timeout); 5579 5580 finish_wait(sk->sk_sleep, &wait); 5581 } 5582 5583 /* Populate the fields of the newsk from the oldsk and migrate the assoc 5584 * and its messages to the newsk. 5585 */ 5586 static void sctp_sock_migrate(struct sock *oldsk, struct sock *newsk, 5587 struct sctp_association *assoc, 5588 sctp_socket_type_t type) 5589 { 5590 struct sctp_sock *oldsp = sctp_sk(oldsk); 5591 struct sctp_sock *newsp = sctp_sk(newsk); 5592 struct sctp_bind_bucket *pp; /* hash list port iterator */ 5593 struct sctp_endpoint *newep = newsp->ep; 5594 struct sk_buff *skb, *tmp; 5595 struct sctp_ulpevent *event; 5596 int flags = 0; 5597 5598 /* Migrate socket buffer sizes and all the socket level options to the 5599 * new socket. 5600 */ 5601 newsk->sk_sndbuf = oldsk->sk_sndbuf; 5602 newsk->sk_rcvbuf = oldsk->sk_rcvbuf; 5603 /* Brute force copy old sctp opt. */ 5604 inet_sk_copy_descendant(newsk, oldsk); 5605 5606 /* Restore the ep value that was overwritten with the above structure 5607 * copy. 5608 */ 5609 newsp->ep = newep; 5610 newsp->hmac = NULL; 5611 5612 /* Hook this new socket in to the bind_hash list. */ 5613 pp = sctp_sk(oldsk)->bind_hash; 5614 sk_add_bind_node(newsk, &pp->owner); 5615 sctp_sk(newsk)->bind_hash = pp; 5616 inet_sk(newsk)->num = inet_sk(oldsk)->num; 5617 5618 /* Copy the bind_addr list from the original endpoint to the new 5619 * endpoint so that we can handle restarts properly 5620 */ 5621 if (PF_INET6 == assoc->base.sk->sk_family) 5622 flags = SCTP_ADDR6_ALLOWED; 5623 if (assoc->peer.ipv4_address) 5624 flags |= SCTP_ADDR4_PEERSUPP; 5625 if (assoc->peer.ipv6_address) 5626 flags |= SCTP_ADDR6_PEERSUPP; 5627 sctp_bind_addr_copy(&newsp->ep->base.bind_addr, 5628 &oldsp->ep->base.bind_addr, 5629 SCTP_SCOPE_GLOBAL, GFP_KERNEL, flags); 5630 5631 /* Move any messages in the old socket's receive queue that are for the 5632 * peeled off association to the new socket's receive queue. 5633 */ 5634 sctp_skb_for_each(skb, &oldsk->sk_receive_queue, tmp) { 5635 event = sctp_skb2event(skb); 5636 if (event->asoc == assoc) { 5637 sock_rfree(skb); 5638 __skb_unlink(skb, &oldsk->sk_receive_queue); 5639 __skb_queue_tail(&newsk->sk_receive_queue, skb); 5640 skb_set_owner_r(skb, newsk); 5641 } 5642 } 5643 5644 /* Clean up any messages pending delivery due to partial 5645 * delivery. Three cases: 5646 * 1) No partial deliver; no work. 5647 * 2) Peeling off partial delivery; keep pd_lobby in new pd_lobby. 5648 * 3) Peeling off non-partial delivery; move pd_lobby to receive_queue. 5649 */ 5650 skb_queue_head_init(&newsp->pd_lobby); 5651 sctp_sk(newsk)->pd_mode = assoc->ulpq.pd_mode; 5652 5653 if (sctp_sk(oldsk)->pd_mode) { 5654 struct sk_buff_head *queue; 5655 5656 /* Decide which queue to move pd_lobby skbs to. */ 5657 if (assoc->ulpq.pd_mode) { 5658 queue = &newsp->pd_lobby; 5659 } else 5660 queue = &newsk->sk_receive_queue; 5661 5662 /* Walk through the pd_lobby, looking for skbs that 5663 * need moved to the new socket. 5664 */ 5665 sctp_skb_for_each(skb, &oldsp->pd_lobby, tmp) { 5666 event = sctp_skb2event(skb); 5667 if (event->asoc == assoc) { 5668 sock_rfree(skb); 5669 __skb_unlink(skb, &oldsp->pd_lobby); 5670 __skb_queue_tail(queue, skb); 5671 skb_set_owner_r(skb, newsk); 5672 } 5673 } 5674 5675 /* Clear up any skbs waiting for the partial 5676 * delivery to finish. 5677 */ 5678 if (assoc->ulpq.pd_mode) 5679 sctp_clear_pd(oldsk); 5680 5681 } 5682 5683 /* Set the type of socket to indicate that it is peeled off from the 5684 * original UDP-style socket or created with the accept() call on a 5685 * TCP-style socket.. 5686 */ 5687 newsp->type = type; 5688 5689 /* Mark the new socket "in-use" by the user so that any packets 5690 * that may arrive on the association after we've moved it are 5691 * queued to the backlog. This prevents a potential race between 5692 * backlog processing on the old socket and new-packet processing 5693 * on the new socket. 5694 */ 5695 sctp_lock_sock(newsk); 5696 sctp_assoc_migrate(assoc, newsk); 5697 5698 /* If the association on the newsk is already closed before accept() 5699 * is called, set RCV_SHUTDOWN flag. 5700 */ 5701 if (sctp_state(assoc, CLOSED) && sctp_style(newsk, TCP)) 5702 newsk->sk_shutdown |= RCV_SHUTDOWN; 5703 5704 newsk->sk_state = SCTP_SS_ESTABLISHED; 5705 sctp_release_sock(newsk); 5706 } 5707 5708 /* This proto struct describes the ULP interface for SCTP. */ 5709 struct proto sctp_prot = { 5710 .name = "SCTP", 5711 .owner = THIS_MODULE, 5712 .close = sctp_close, 5713 .connect = sctp_connect, 5714 .disconnect = sctp_disconnect, 5715 .accept = sctp_accept, 5716 .ioctl = sctp_ioctl, 5717 .init = sctp_init_sock, 5718 .destroy = sctp_destroy_sock, 5719 .shutdown = sctp_shutdown, 5720 .setsockopt = sctp_setsockopt, 5721 .getsockopt = sctp_getsockopt, 5722 .sendmsg = sctp_sendmsg, 5723 .recvmsg = sctp_recvmsg, 5724 .bind = sctp_bind, 5725 .backlog_rcv = sctp_backlog_rcv, 5726 .hash = sctp_hash, 5727 .unhash = sctp_unhash, 5728 .get_port = sctp_get_port, 5729 .obj_size = sizeof(struct sctp_sock), 5730 }; 5731 5732 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) 5733 struct proto sctpv6_prot = { 5734 .name = "SCTPv6", 5735 .owner = THIS_MODULE, 5736 .close = sctp_close, 5737 .connect = sctp_connect, 5738 .disconnect = sctp_disconnect, 5739 .accept = sctp_accept, 5740 .ioctl = sctp_ioctl, 5741 .init = sctp_init_sock, 5742 .destroy = sctp_destroy_sock, 5743 .shutdown = sctp_shutdown, 5744 .setsockopt = sctp_setsockopt, 5745 .getsockopt = sctp_getsockopt, 5746 .sendmsg = sctp_sendmsg, 5747 .recvmsg = sctp_recvmsg, 5748 .bind = sctp_bind, 5749 .backlog_rcv = sctp_backlog_rcv, 5750 .hash = sctp_hash, 5751 .unhash = sctp_unhash, 5752 .get_port = sctp_get_port, 5753 .obj_size = sizeof(struct sctp6_sock), 5754 }; 5755 #endif /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */ 5756