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 Intel Corp. 6 * Copyright (c) 2001 La Monte H.P. Yarroll 7 * 8 * This file is part of the SCTP kernel reference Implementation 9 * 10 * This module provides the abstraction for an SCTP association. 11 * 12 * The SCTP reference implementation is free software; 13 * you can redistribute it and/or modify it under the terms of 14 * the GNU General Public License as published by 15 * the Free Software Foundation; either version 2, or (at your option) 16 * any later version. 17 * 18 * The SCTP reference implementation is distributed in the hope that it 19 * will be useful, but WITHOUT ANY WARRANTY; without even the implied 20 * ************************ 21 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 22 * See the GNU General Public License for more details. 23 * 24 * You should have received a copy of the GNU General Public License 25 * along with GNU CC; see the file COPYING. If not, write to 26 * the Free Software Foundation, 59 Temple Place - Suite 330, 27 * Boston, MA 02111-1307, USA. 28 * 29 * Please send any bug reports or fixes you make to the 30 * email address(es): 31 * lksctp developers <lksctp-developers@lists.sourceforge.net> 32 * 33 * Or submit a bug report through the following website: 34 * http://www.sf.net/projects/lksctp 35 * 36 * Written or modified by: 37 * La Monte H.P. Yarroll <piggy@acm.org> 38 * Karl Knutson <karl@athena.chicago.il.us> 39 * Jon Grimm <jgrimm@us.ibm.com> 40 * Xingang Guo <xingang.guo@intel.com> 41 * Hui Huang <hui.huang@nokia.com> 42 * Sridhar Samudrala <sri@us.ibm.com> 43 * Daisy Chang <daisyc@us.ibm.com> 44 * Ryan Layer <rmlayer@us.ibm.com> 45 * Kevin Gao <kevin.gao@intel.com> 46 * 47 * Any bugs reported given to us we will try to fix... any fixes shared will 48 * be incorporated into the next SCTP release. 49 */ 50 51 #include <linux/types.h> 52 #include <linux/fcntl.h> 53 #include <linux/poll.h> 54 #include <linux/init.h> 55 56 #include <linux/slab.h> 57 #include <linux/in.h> 58 #include <net/ipv6.h> 59 #include <net/sctp/sctp.h> 60 #include <net/sctp/sm.h> 61 62 /* Forward declarations for internal functions. */ 63 static void sctp_assoc_bh_rcv(struct work_struct *work); 64 static void sctp_assoc_free_asconf_acks(struct sctp_association *asoc); 65 66 67 /* 1st Level Abstractions. */ 68 69 /* Initialize a new association from provided memory. */ 70 static struct sctp_association *sctp_association_init(struct sctp_association *asoc, 71 const struct sctp_endpoint *ep, 72 const struct sock *sk, 73 sctp_scope_t scope, 74 gfp_t gfp) 75 { 76 struct sctp_sock *sp; 77 int i; 78 sctp_paramhdr_t *p; 79 int err; 80 81 /* Retrieve the SCTP per socket area. */ 82 sp = sctp_sk((struct sock *)sk); 83 84 /* Init all variables to a known value. */ 85 memset(asoc, 0, sizeof(struct sctp_association)); 86 87 /* Discarding const is appropriate here. */ 88 asoc->ep = (struct sctp_endpoint *)ep; 89 sctp_endpoint_hold(asoc->ep); 90 91 /* Hold the sock. */ 92 asoc->base.sk = (struct sock *)sk; 93 sock_hold(asoc->base.sk); 94 95 /* Initialize the common base substructure. */ 96 asoc->base.type = SCTP_EP_TYPE_ASSOCIATION; 97 98 /* Initialize the object handling fields. */ 99 atomic_set(&asoc->base.refcnt, 1); 100 asoc->base.dead = 0; 101 asoc->base.malloced = 0; 102 103 /* Initialize the bind addr area. */ 104 sctp_bind_addr_init(&asoc->base.bind_addr, ep->base.bind_addr.port); 105 106 asoc->state = SCTP_STATE_CLOSED; 107 108 /* Set these values from the socket values, a conversion between 109 * millsecons to seconds/microseconds must also be done. 110 */ 111 asoc->cookie_life.tv_sec = sp->assocparams.sasoc_cookie_life / 1000; 112 asoc->cookie_life.tv_usec = (sp->assocparams.sasoc_cookie_life % 1000) 113 * 1000; 114 asoc->frag_point = 0; 115 116 /* Set the association max_retrans and RTO values from the 117 * socket values. 118 */ 119 asoc->max_retrans = sp->assocparams.sasoc_asocmaxrxt; 120 asoc->rto_initial = msecs_to_jiffies(sp->rtoinfo.srto_initial); 121 asoc->rto_max = msecs_to_jiffies(sp->rtoinfo.srto_max); 122 asoc->rto_min = msecs_to_jiffies(sp->rtoinfo.srto_min); 123 124 asoc->overall_error_count = 0; 125 126 /* Initialize the association's heartbeat interval based on the 127 * sock configured value. 128 */ 129 asoc->hbinterval = msecs_to_jiffies(sp->hbinterval); 130 131 /* Initialize path max retrans value. */ 132 asoc->pathmaxrxt = sp->pathmaxrxt; 133 134 /* Initialize default path MTU. */ 135 asoc->pathmtu = sp->pathmtu; 136 137 /* Set association default SACK delay */ 138 asoc->sackdelay = msecs_to_jiffies(sp->sackdelay); 139 140 /* Set the association default flags controlling 141 * Heartbeat, SACK delay, and Path MTU Discovery. 142 */ 143 asoc->param_flags = sp->param_flags; 144 145 /* Initialize the maximum mumber of new data packets that can be sent 146 * in a burst. 147 */ 148 asoc->max_burst = sp->max_burst; 149 150 /* initialize association timers */ 151 asoc->timeouts[SCTP_EVENT_TIMEOUT_NONE] = 0; 152 asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] = asoc->rto_initial; 153 asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] = asoc->rto_initial; 154 asoc->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] = asoc->rto_initial; 155 asoc->timeouts[SCTP_EVENT_TIMEOUT_T3_RTX] = 0; 156 asoc->timeouts[SCTP_EVENT_TIMEOUT_T4_RTO] = 0; 157 158 /* sctpimpguide Section 2.12.2 159 * If the 'T5-shutdown-guard' timer is used, it SHOULD be set to the 160 * recommended value of 5 times 'RTO.Max'. 161 */ 162 asoc->timeouts[SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD] 163 = 5 * asoc->rto_max; 164 165 asoc->timeouts[SCTP_EVENT_TIMEOUT_HEARTBEAT] = 0; 166 asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] = asoc->sackdelay; 167 asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE] = 168 sp->autoclose * HZ; 169 170 /* Initilizes the timers */ 171 for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i) 172 setup_timer(&asoc->timers[i], sctp_timer_events[i], 173 (unsigned long)asoc); 174 175 /* Pull default initialization values from the sock options. 176 * Note: This assumes that the values have already been 177 * validated in the sock. 178 */ 179 asoc->c.sinit_max_instreams = sp->initmsg.sinit_max_instreams; 180 asoc->c.sinit_num_ostreams = sp->initmsg.sinit_num_ostreams; 181 asoc->max_init_attempts = sp->initmsg.sinit_max_attempts; 182 183 asoc->max_init_timeo = 184 msecs_to_jiffies(sp->initmsg.sinit_max_init_timeo); 185 186 /* Allocate storage for the ssnmap after the inbound and outbound 187 * streams have been negotiated during Init. 188 */ 189 asoc->ssnmap = NULL; 190 191 /* Set the local window size for receive. 192 * This is also the rcvbuf space per association. 193 * RFC 6 - A SCTP receiver MUST be able to receive a minimum of 194 * 1500 bytes in one SCTP packet. 195 */ 196 if ((sk->sk_rcvbuf/2) < SCTP_DEFAULT_MINWINDOW) 197 asoc->rwnd = SCTP_DEFAULT_MINWINDOW; 198 else 199 asoc->rwnd = sk->sk_rcvbuf/2; 200 201 asoc->a_rwnd = asoc->rwnd; 202 203 asoc->rwnd_over = 0; 204 205 /* Use my own max window until I learn something better. */ 206 asoc->peer.rwnd = SCTP_DEFAULT_MAXWINDOW; 207 208 /* Set the sndbuf size for transmit. */ 209 asoc->sndbuf_used = 0; 210 211 /* Initialize the receive memory counter */ 212 atomic_set(&asoc->rmem_alloc, 0); 213 214 init_waitqueue_head(&asoc->wait); 215 216 asoc->c.my_vtag = sctp_generate_tag(ep); 217 asoc->peer.i.init_tag = 0; /* INIT needs a vtag of 0. */ 218 asoc->c.peer_vtag = 0; 219 asoc->c.my_ttag = 0; 220 asoc->c.peer_ttag = 0; 221 asoc->c.my_port = ep->base.bind_addr.port; 222 223 asoc->c.initial_tsn = sctp_generate_tsn(ep); 224 225 asoc->next_tsn = asoc->c.initial_tsn; 226 227 asoc->ctsn_ack_point = asoc->next_tsn - 1; 228 asoc->adv_peer_ack_point = asoc->ctsn_ack_point; 229 asoc->highest_sacked = asoc->ctsn_ack_point; 230 asoc->last_cwr_tsn = asoc->ctsn_ack_point; 231 asoc->unack_data = 0; 232 233 /* ADDIP Section 4.1 Asconf Chunk Procedures 234 * 235 * When an endpoint has an ASCONF signaled change to be sent to the 236 * remote endpoint it should do the following: 237 * ... 238 * A2) a serial number should be assigned to the chunk. The serial 239 * number SHOULD be a monotonically increasing number. The serial 240 * numbers SHOULD be initialized at the start of the 241 * association to the same value as the initial TSN. 242 */ 243 asoc->addip_serial = asoc->c.initial_tsn; 244 245 INIT_LIST_HEAD(&asoc->addip_chunk_list); 246 INIT_LIST_HEAD(&asoc->asconf_ack_list); 247 248 /* Make an empty list of remote transport addresses. */ 249 INIT_LIST_HEAD(&asoc->peer.transport_addr_list); 250 asoc->peer.transport_count = 0; 251 252 /* RFC 2960 5.1 Normal Establishment of an Association 253 * 254 * After the reception of the first data chunk in an 255 * association the endpoint must immediately respond with a 256 * sack to acknowledge the data chunk. Subsequent 257 * acknowledgements should be done as described in Section 258 * 6.2. 259 * 260 * [We implement this by telling a new association that it 261 * already received one packet.] 262 */ 263 asoc->peer.sack_needed = 1; 264 265 /* Assume that the peer will tell us if he recognizes ASCONF 266 * as part of INIT exchange. 267 * The sctp_addip_noauth option is there for backward compatibilty 268 * and will revert old behavior. 269 */ 270 asoc->peer.asconf_capable = 0; 271 if (sctp_addip_noauth) 272 asoc->peer.asconf_capable = 1; 273 274 /* Create an input queue. */ 275 sctp_inq_init(&asoc->base.inqueue); 276 sctp_inq_set_th_handler(&asoc->base.inqueue, sctp_assoc_bh_rcv); 277 278 /* Create an output queue. */ 279 sctp_outq_init(asoc, &asoc->outqueue); 280 281 if (!sctp_ulpq_init(&asoc->ulpq, asoc)) 282 goto fail_init; 283 284 /* Set up the tsn tracking. */ 285 sctp_tsnmap_init(&asoc->peer.tsn_map, SCTP_TSN_MAP_SIZE, 0); 286 287 asoc->need_ecne = 0; 288 289 asoc->assoc_id = 0; 290 291 /* Assume that peer would support both address types unless we are 292 * told otherwise. 293 */ 294 asoc->peer.ipv4_address = 1; 295 asoc->peer.ipv6_address = 1; 296 INIT_LIST_HEAD(&asoc->asocs); 297 298 asoc->autoclose = sp->autoclose; 299 300 asoc->default_stream = sp->default_stream; 301 asoc->default_ppid = sp->default_ppid; 302 asoc->default_flags = sp->default_flags; 303 asoc->default_context = sp->default_context; 304 asoc->default_timetolive = sp->default_timetolive; 305 asoc->default_rcv_context = sp->default_rcv_context; 306 307 /* AUTH related initializations */ 308 INIT_LIST_HEAD(&asoc->endpoint_shared_keys); 309 err = sctp_auth_asoc_copy_shkeys(ep, asoc, gfp); 310 if (err) 311 goto fail_init; 312 313 asoc->active_key_id = ep->active_key_id; 314 asoc->asoc_shared_key = NULL; 315 316 asoc->default_hmac_id = 0; 317 /* Save the hmacs and chunks list into this association */ 318 if (ep->auth_hmacs_list) 319 memcpy(asoc->c.auth_hmacs, ep->auth_hmacs_list, 320 ntohs(ep->auth_hmacs_list->param_hdr.length)); 321 if (ep->auth_chunk_list) 322 memcpy(asoc->c.auth_chunks, ep->auth_chunk_list, 323 ntohs(ep->auth_chunk_list->param_hdr.length)); 324 325 /* Get the AUTH random number for this association */ 326 p = (sctp_paramhdr_t *)asoc->c.auth_random; 327 p->type = SCTP_PARAM_RANDOM; 328 p->length = htons(sizeof(sctp_paramhdr_t) + SCTP_AUTH_RANDOM_LENGTH); 329 get_random_bytes(p+1, SCTP_AUTH_RANDOM_LENGTH); 330 331 return asoc; 332 333 fail_init: 334 sctp_endpoint_put(asoc->ep); 335 sock_put(asoc->base.sk); 336 return NULL; 337 } 338 339 /* Allocate and initialize a new association */ 340 struct sctp_association *sctp_association_new(const struct sctp_endpoint *ep, 341 const struct sock *sk, 342 sctp_scope_t scope, 343 gfp_t gfp) 344 { 345 struct sctp_association *asoc; 346 347 asoc = t_new(struct sctp_association, gfp); 348 if (!asoc) 349 goto fail; 350 351 if (!sctp_association_init(asoc, ep, sk, scope, gfp)) 352 goto fail_init; 353 354 asoc->base.malloced = 1; 355 SCTP_DBG_OBJCNT_INC(assoc); 356 SCTP_DEBUG_PRINTK("Created asoc %p\n", asoc); 357 358 return asoc; 359 360 fail_init: 361 kfree(asoc); 362 fail: 363 return NULL; 364 } 365 366 /* Free this association if possible. There may still be users, so 367 * the actual deallocation may be delayed. 368 */ 369 void sctp_association_free(struct sctp_association *asoc) 370 { 371 struct sock *sk = asoc->base.sk; 372 struct sctp_transport *transport; 373 struct list_head *pos, *temp; 374 int i; 375 376 /* Only real associations count against the endpoint, so 377 * don't bother for if this is a temporary association. 378 */ 379 if (!asoc->temp) { 380 list_del(&asoc->asocs); 381 382 /* Decrement the backlog value for a TCP-style listening 383 * socket. 384 */ 385 if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)) 386 sk->sk_ack_backlog--; 387 } 388 389 /* Mark as dead, so other users can know this structure is 390 * going away. 391 */ 392 asoc->base.dead = 1; 393 394 /* Dispose of any data lying around in the outqueue. */ 395 sctp_outq_free(&asoc->outqueue); 396 397 /* Dispose of any pending messages for the upper layer. */ 398 sctp_ulpq_free(&asoc->ulpq); 399 400 /* Dispose of any pending chunks on the inqueue. */ 401 sctp_inq_free(&asoc->base.inqueue); 402 403 /* Free ssnmap storage. */ 404 sctp_ssnmap_free(asoc->ssnmap); 405 406 /* Clean up the bound address list. */ 407 sctp_bind_addr_free(&asoc->base.bind_addr); 408 409 /* Do we need to go through all of our timers and 410 * delete them? To be safe we will try to delete all, but we 411 * should be able to go through and make a guess based 412 * on our state. 413 */ 414 for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i) { 415 if (timer_pending(&asoc->timers[i]) && 416 del_timer(&asoc->timers[i])) 417 sctp_association_put(asoc); 418 } 419 420 /* Free peer's cached cookie. */ 421 kfree(asoc->peer.cookie); 422 kfree(asoc->peer.peer_random); 423 kfree(asoc->peer.peer_chunks); 424 kfree(asoc->peer.peer_hmacs); 425 426 /* Release the transport structures. */ 427 list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) { 428 transport = list_entry(pos, struct sctp_transport, transports); 429 list_del(pos); 430 sctp_transport_free(transport); 431 } 432 433 asoc->peer.transport_count = 0; 434 435 /* Free any cached ASCONF_ACK chunk. */ 436 sctp_assoc_free_asconf_acks(asoc); 437 438 /* Free any cached ASCONF chunk. */ 439 if (asoc->addip_last_asconf) 440 sctp_chunk_free(asoc->addip_last_asconf); 441 442 /* AUTH - Free the endpoint shared keys */ 443 sctp_auth_destroy_keys(&asoc->endpoint_shared_keys); 444 445 /* AUTH - Free the association shared key */ 446 sctp_auth_key_put(asoc->asoc_shared_key); 447 448 sctp_association_put(asoc); 449 } 450 451 /* Cleanup and free up an association. */ 452 static void sctp_association_destroy(struct sctp_association *asoc) 453 { 454 SCTP_ASSERT(asoc->base.dead, "Assoc is not dead", return); 455 456 sctp_endpoint_put(asoc->ep); 457 sock_put(asoc->base.sk); 458 459 if (asoc->assoc_id != 0) { 460 spin_lock_bh(&sctp_assocs_id_lock); 461 idr_remove(&sctp_assocs_id, asoc->assoc_id); 462 spin_unlock_bh(&sctp_assocs_id_lock); 463 } 464 465 BUG_TRAP(!atomic_read(&asoc->rmem_alloc)); 466 467 if (asoc->base.malloced) { 468 kfree(asoc); 469 SCTP_DBG_OBJCNT_DEC(assoc); 470 } 471 } 472 473 /* Change the primary destination address for the peer. */ 474 void sctp_assoc_set_primary(struct sctp_association *asoc, 475 struct sctp_transport *transport) 476 { 477 asoc->peer.primary_path = transport; 478 479 /* Set a default msg_name for events. */ 480 memcpy(&asoc->peer.primary_addr, &transport->ipaddr, 481 sizeof(union sctp_addr)); 482 483 /* If the primary path is changing, assume that the 484 * user wants to use this new path. 485 */ 486 if ((transport->state == SCTP_ACTIVE) || 487 (transport->state == SCTP_UNKNOWN)) 488 asoc->peer.active_path = transport; 489 490 /* 491 * SFR-CACC algorithm: 492 * Upon the receipt of a request to change the primary 493 * destination address, on the data structure for the new 494 * primary destination, the sender MUST do the following: 495 * 496 * 1) If CHANGEOVER_ACTIVE is set, then there was a switch 497 * to this destination address earlier. The sender MUST set 498 * CYCLING_CHANGEOVER to indicate that this switch is a 499 * double switch to the same destination address. 500 */ 501 if (transport->cacc.changeover_active) 502 transport->cacc.cycling_changeover = 1; 503 504 /* 2) The sender MUST set CHANGEOVER_ACTIVE to indicate that 505 * a changeover has occurred. 506 */ 507 transport->cacc.changeover_active = 1; 508 509 /* 3) The sender MUST store the next TSN to be sent in 510 * next_tsn_at_change. 511 */ 512 transport->cacc.next_tsn_at_change = asoc->next_tsn; 513 } 514 515 /* Remove a transport from an association. */ 516 void sctp_assoc_rm_peer(struct sctp_association *asoc, 517 struct sctp_transport *peer) 518 { 519 struct list_head *pos; 520 struct sctp_transport *transport; 521 522 SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_rm_peer:association %p addr: ", 523 " port: %d\n", 524 asoc, 525 (&peer->ipaddr), 526 ntohs(peer->ipaddr.v4.sin_port)); 527 528 /* If we are to remove the current retran_path, update it 529 * to the next peer before removing this peer from the list. 530 */ 531 if (asoc->peer.retran_path == peer) 532 sctp_assoc_update_retran_path(asoc); 533 534 /* Remove this peer from the list. */ 535 list_del(&peer->transports); 536 537 /* Get the first transport of asoc. */ 538 pos = asoc->peer.transport_addr_list.next; 539 transport = list_entry(pos, struct sctp_transport, transports); 540 541 /* Update any entries that match the peer to be deleted. */ 542 if (asoc->peer.primary_path == peer) 543 sctp_assoc_set_primary(asoc, transport); 544 if (asoc->peer.active_path == peer) 545 asoc->peer.active_path = transport; 546 if (asoc->peer.last_data_from == peer) 547 asoc->peer.last_data_from = transport; 548 549 /* If we remove the transport an INIT was last sent to, set it to 550 * NULL. Combined with the update of the retran path above, this 551 * will cause the next INIT to be sent to the next available 552 * transport, maintaining the cycle. 553 */ 554 if (asoc->init_last_sent_to == peer) 555 asoc->init_last_sent_to = NULL; 556 557 asoc->peer.transport_count--; 558 559 sctp_transport_free(peer); 560 } 561 562 /* Add a transport address to an association. */ 563 struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *asoc, 564 const union sctp_addr *addr, 565 const gfp_t gfp, 566 const int peer_state) 567 { 568 struct sctp_transport *peer; 569 struct sctp_sock *sp; 570 unsigned short port; 571 572 sp = sctp_sk(asoc->base.sk); 573 574 /* AF_INET and AF_INET6 share common port field. */ 575 port = ntohs(addr->v4.sin_port); 576 577 SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_add_peer:association %p addr: ", 578 " port: %d state:%d\n", 579 asoc, 580 addr, 581 port, 582 peer_state); 583 584 /* Set the port if it has not been set yet. */ 585 if (0 == asoc->peer.port) 586 asoc->peer.port = port; 587 588 /* Check to see if this is a duplicate. */ 589 peer = sctp_assoc_lookup_paddr(asoc, addr); 590 if (peer) { 591 if (peer->state == SCTP_UNKNOWN) { 592 if (peer_state == SCTP_ACTIVE) 593 peer->state = SCTP_ACTIVE; 594 if (peer_state == SCTP_UNCONFIRMED) 595 peer->state = SCTP_UNCONFIRMED; 596 } 597 return peer; 598 } 599 600 peer = sctp_transport_new(addr, gfp); 601 if (!peer) 602 return NULL; 603 604 sctp_transport_set_owner(peer, asoc); 605 606 /* Initialize the peer's heartbeat interval based on the 607 * association configured value. 608 */ 609 peer->hbinterval = asoc->hbinterval; 610 611 /* Set the path max_retrans. */ 612 peer->pathmaxrxt = asoc->pathmaxrxt; 613 614 /* Initialize the peer's SACK delay timeout based on the 615 * association configured value. 616 */ 617 peer->sackdelay = asoc->sackdelay; 618 619 /* Enable/disable heartbeat, SACK delay, and path MTU discovery 620 * based on association setting. 621 */ 622 peer->param_flags = asoc->param_flags; 623 624 /* Initialize the pmtu of the transport. */ 625 if (peer->param_flags & SPP_PMTUD_ENABLE) 626 sctp_transport_pmtu(peer); 627 else if (asoc->pathmtu) 628 peer->pathmtu = asoc->pathmtu; 629 else 630 peer->pathmtu = SCTP_DEFAULT_MAXSEGMENT; 631 632 /* If this is the first transport addr on this association, 633 * initialize the association PMTU to the peer's PMTU. 634 * If not and the current association PMTU is higher than the new 635 * peer's PMTU, reset the association PMTU to the new peer's PMTU. 636 */ 637 if (asoc->pathmtu) 638 asoc->pathmtu = min_t(int, peer->pathmtu, asoc->pathmtu); 639 else 640 asoc->pathmtu = peer->pathmtu; 641 642 SCTP_DEBUG_PRINTK("sctp_assoc_add_peer:association %p PMTU set to " 643 "%d\n", asoc, asoc->pathmtu); 644 645 asoc->frag_point = sctp_frag_point(sp, asoc->pathmtu); 646 647 /* The asoc->peer.port might not be meaningful yet, but 648 * initialize the packet structure anyway. 649 */ 650 sctp_packet_init(&peer->packet, peer, asoc->base.bind_addr.port, 651 asoc->peer.port); 652 653 /* 7.2.1 Slow-Start 654 * 655 * o The initial cwnd before DATA transmission or after a sufficiently 656 * long idle period MUST be set to 657 * min(4*MTU, max(2*MTU, 4380 bytes)) 658 * 659 * o The initial value of ssthresh MAY be arbitrarily high 660 * (for example, implementations MAY use the size of the 661 * receiver advertised window). 662 */ 663 peer->cwnd = min(4*asoc->pathmtu, max_t(__u32, 2*asoc->pathmtu, 4380)); 664 665 /* At this point, we may not have the receiver's advertised window, 666 * so initialize ssthresh to the default value and it will be set 667 * later when we process the INIT. 668 */ 669 peer->ssthresh = SCTP_DEFAULT_MAXWINDOW; 670 671 peer->partial_bytes_acked = 0; 672 peer->flight_size = 0; 673 674 /* Set the transport's RTO.initial value */ 675 peer->rto = asoc->rto_initial; 676 677 /* Set the peer's active state. */ 678 peer->state = peer_state; 679 680 /* Attach the remote transport to our asoc. */ 681 list_add_tail(&peer->transports, &asoc->peer.transport_addr_list); 682 asoc->peer.transport_count++; 683 684 /* If we do not yet have a primary path, set one. */ 685 if (!asoc->peer.primary_path) { 686 sctp_assoc_set_primary(asoc, peer); 687 asoc->peer.retran_path = peer; 688 } 689 690 if (asoc->peer.active_path == asoc->peer.retran_path) { 691 asoc->peer.retran_path = peer; 692 } 693 694 return peer; 695 } 696 697 /* Delete a transport address from an association. */ 698 void sctp_assoc_del_peer(struct sctp_association *asoc, 699 const union sctp_addr *addr) 700 { 701 struct list_head *pos; 702 struct list_head *temp; 703 struct sctp_transport *transport; 704 705 list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) { 706 transport = list_entry(pos, struct sctp_transport, transports); 707 if (sctp_cmp_addr_exact(addr, &transport->ipaddr)) { 708 /* Do book keeping for removing the peer and free it. */ 709 sctp_assoc_rm_peer(asoc, transport); 710 break; 711 } 712 } 713 } 714 715 /* Lookup a transport by address. */ 716 struct sctp_transport *sctp_assoc_lookup_paddr( 717 const struct sctp_association *asoc, 718 const union sctp_addr *address) 719 { 720 struct sctp_transport *t; 721 struct list_head *pos; 722 723 /* Cycle through all transports searching for a peer address. */ 724 725 list_for_each(pos, &asoc->peer.transport_addr_list) { 726 t = list_entry(pos, struct sctp_transport, transports); 727 if (sctp_cmp_addr_exact(address, &t->ipaddr)) 728 return t; 729 } 730 731 return NULL; 732 } 733 734 /* Remove all transports except a give one */ 735 void sctp_assoc_del_nonprimary_peers(struct sctp_association *asoc, 736 struct sctp_transport *primary) 737 { 738 struct sctp_transport *temp; 739 struct sctp_transport *t; 740 741 list_for_each_entry_safe(t, temp, &asoc->peer.transport_addr_list, 742 transports) { 743 /* if the current transport is not the primary one, delete it */ 744 if (t != primary) 745 sctp_assoc_rm_peer(asoc, t); 746 } 747 748 return; 749 } 750 751 /* Engage in transport control operations. 752 * Mark the transport up or down and send a notification to the user. 753 * Select and update the new active and retran paths. 754 */ 755 void sctp_assoc_control_transport(struct sctp_association *asoc, 756 struct sctp_transport *transport, 757 sctp_transport_cmd_t command, 758 sctp_sn_error_t error) 759 { 760 struct sctp_transport *t = NULL; 761 struct sctp_transport *first; 762 struct sctp_transport *second; 763 struct sctp_ulpevent *event; 764 struct sockaddr_storage addr; 765 struct list_head *pos; 766 int spc_state = 0; 767 768 /* Record the transition on the transport. */ 769 switch (command) { 770 case SCTP_TRANSPORT_UP: 771 /* If we are moving from UNCONFIRMED state due 772 * to heartbeat success, report the SCTP_ADDR_CONFIRMED 773 * state to the user, otherwise report SCTP_ADDR_AVAILABLE. 774 */ 775 if (SCTP_UNCONFIRMED == transport->state && 776 SCTP_HEARTBEAT_SUCCESS == error) 777 spc_state = SCTP_ADDR_CONFIRMED; 778 else 779 spc_state = SCTP_ADDR_AVAILABLE; 780 transport->state = SCTP_ACTIVE; 781 break; 782 783 case SCTP_TRANSPORT_DOWN: 784 /* if the transort was never confirmed, do not transition it 785 * to inactive state. 786 */ 787 if (transport->state != SCTP_UNCONFIRMED) 788 transport->state = SCTP_INACTIVE; 789 790 spc_state = SCTP_ADDR_UNREACHABLE; 791 break; 792 793 default: 794 return; 795 } 796 797 /* Generate and send a SCTP_PEER_ADDR_CHANGE notification to the 798 * user. 799 */ 800 memset(&addr, 0, sizeof(struct sockaddr_storage)); 801 memcpy(&addr, &transport->ipaddr, transport->af_specific->sockaddr_len); 802 event = sctp_ulpevent_make_peer_addr_change(asoc, &addr, 803 0, spc_state, error, GFP_ATOMIC); 804 if (event) 805 sctp_ulpq_tail_event(&asoc->ulpq, event); 806 807 /* Select new active and retran paths. */ 808 809 /* Look for the two most recently used active transports. 810 * 811 * This code produces the wrong ordering whenever jiffies 812 * rolls over, but we still get usable transports, so we don't 813 * worry about it. 814 */ 815 first = NULL; second = NULL; 816 817 list_for_each(pos, &asoc->peer.transport_addr_list) { 818 t = list_entry(pos, struct sctp_transport, transports); 819 820 if ((t->state == SCTP_INACTIVE) || 821 (t->state == SCTP_UNCONFIRMED)) 822 continue; 823 if (!first || t->last_time_heard > first->last_time_heard) { 824 second = first; 825 first = t; 826 } 827 if (!second || t->last_time_heard > second->last_time_heard) 828 second = t; 829 } 830 831 /* RFC 2960 6.4 Multi-Homed SCTP Endpoints 832 * 833 * By default, an endpoint should always transmit to the 834 * primary path, unless the SCTP user explicitly specifies the 835 * destination transport address (and possibly source 836 * transport address) to use. 837 * 838 * [If the primary is active but not most recent, bump the most 839 * recently used transport.] 840 */ 841 if (((asoc->peer.primary_path->state == SCTP_ACTIVE) || 842 (asoc->peer.primary_path->state == SCTP_UNKNOWN)) && 843 first != asoc->peer.primary_path) { 844 second = first; 845 first = asoc->peer.primary_path; 846 } 847 848 /* If we failed to find a usable transport, just camp on the 849 * primary, even if it is inactive. 850 */ 851 if (!first) { 852 first = asoc->peer.primary_path; 853 second = asoc->peer.primary_path; 854 } 855 856 /* Set the active and retran transports. */ 857 asoc->peer.active_path = first; 858 asoc->peer.retran_path = second; 859 } 860 861 /* Hold a reference to an association. */ 862 void sctp_association_hold(struct sctp_association *asoc) 863 { 864 atomic_inc(&asoc->base.refcnt); 865 } 866 867 /* Release a reference to an association and cleanup 868 * if there are no more references. 869 */ 870 void sctp_association_put(struct sctp_association *asoc) 871 { 872 if (atomic_dec_and_test(&asoc->base.refcnt)) 873 sctp_association_destroy(asoc); 874 } 875 876 /* Allocate the next TSN, Transmission Sequence Number, for the given 877 * association. 878 */ 879 __u32 sctp_association_get_next_tsn(struct sctp_association *asoc) 880 { 881 /* From Section 1.6 Serial Number Arithmetic: 882 * Transmission Sequence Numbers wrap around when they reach 883 * 2**32 - 1. That is, the next TSN a DATA chunk MUST use 884 * after transmitting TSN = 2*32 - 1 is TSN = 0. 885 */ 886 __u32 retval = asoc->next_tsn; 887 asoc->next_tsn++; 888 asoc->unack_data++; 889 890 return retval; 891 } 892 893 /* Compare two addresses to see if they match. Wildcard addresses 894 * only match themselves. 895 */ 896 int sctp_cmp_addr_exact(const union sctp_addr *ss1, 897 const union sctp_addr *ss2) 898 { 899 struct sctp_af *af; 900 901 af = sctp_get_af_specific(ss1->sa.sa_family); 902 if (unlikely(!af)) 903 return 0; 904 905 return af->cmp_addr(ss1, ss2); 906 } 907 908 /* Return an ecne chunk to get prepended to a packet. 909 * Note: We are sly and return a shared, prealloced chunk. FIXME: 910 * No we don't, but we could/should. 911 */ 912 struct sctp_chunk *sctp_get_ecne_prepend(struct sctp_association *asoc) 913 { 914 struct sctp_chunk *chunk; 915 916 /* Send ECNE if needed. 917 * Not being able to allocate a chunk here is not deadly. 918 */ 919 if (asoc->need_ecne) 920 chunk = sctp_make_ecne(asoc, asoc->last_ecne_tsn); 921 else 922 chunk = NULL; 923 924 return chunk; 925 } 926 927 /* 928 * Find which transport this TSN was sent on. 929 */ 930 struct sctp_transport *sctp_assoc_lookup_tsn(struct sctp_association *asoc, 931 __u32 tsn) 932 { 933 struct sctp_transport *active; 934 struct sctp_transport *match; 935 struct list_head *entry, *pos; 936 struct sctp_transport *transport; 937 struct sctp_chunk *chunk; 938 __be32 key = htonl(tsn); 939 940 match = NULL; 941 942 /* 943 * FIXME: In general, find a more efficient data structure for 944 * searching. 945 */ 946 947 /* 948 * The general strategy is to search each transport's transmitted 949 * list. Return which transport this TSN lives on. 950 * 951 * Let's be hopeful and check the active_path first. 952 * Another optimization would be to know if there is only one 953 * outbound path and not have to look for the TSN at all. 954 * 955 */ 956 957 active = asoc->peer.active_path; 958 959 list_for_each(entry, &active->transmitted) { 960 chunk = list_entry(entry, struct sctp_chunk, transmitted_list); 961 962 if (key == chunk->subh.data_hdr->tsn) { 963 match = active; 964 goto out; 965 } 966 } 967 968 /* If not found, go search all the other transports. */ 969 list_for_each(pos, &asoc->peer.transport_addr_list) { 970 transport = list_entry(pos, struct sctp_transport, transports); 971 972 if (transport == active) 973 break; 974 list_for_each(entry, &transport->transmitted) { 975 chunk = list_entry(entry, struct sctp_chunk, 976 transmitted_list); 977 if (key == chunk->subh.data_hdr->tsn) { 978 match = transport; 979 goto out; 980 } 981 } 982 } 983 out: 984 return match; 985 } 986 987 /* Is this the association we are looking for? */ 988 struct sctp_transport *sctp_assoc_is_match(struct sctp_association *asoc, 989 const union sctp_addr *laddr, 990 const union sctp_addr *paddr) 991 { 992 struct sctp_transport *transport; 993 994 if ((htons(asoc->base.bind_addr.port) == laddr->v4.sin_port) && 995 (htons(asoc->peer.port) == paddr->v4.sin_port)) { 996 transport = sctp_assoc_lookup_paddr(asoc, paddr); 997 if (!transport) 998 goto out; 999 1000 if (sctp_bind_addr_match(&asoc->base.bind_addr, laddr, 1001 sctp_sk(asoc->base.sk))) 1002 goto out; 1003 } 1004 transport = NULL; 1005 1006 out: 1007 return transport; 1008 } 1009 1010 /* Do delayed input processing. This is scheduled by sctp_rcv(). */ 1011 static void sctp_assoc_bh_rcv(struct work_struct *work) 1012 { 1013 struct sctp_association *asoc = 1014 container_of(work, struct sctp_association, 1015 base.inqueue.immediate); 1016 struct sctp_endpoint *ep; 1017 struct sctp_chunk *chunk; 1018 struct sock *sk; 1019 struct sctp_inq *inqueue; 1020 int state; 1021 sctp_subtype_t subtype; 1022 int error = 0; 1023 1024 /* The association should be held so we should be safe. */ 1025 ep = asoc->ep; 1026 sk = asoc->base.sk; 1027 1028 inqueue = &asoc->base.inqueue; 1029 sctp_association_hold(asoc); 1030 while (NULL != (chunk = sctp_inq_pop(inqueue))) { 1031 state = asoc->state; 1032 subtype = SCTP_ST_CHUNK(chunk->chunk_hdr->type); 1033 1034 /* SCTP-AUTH, Section 6.3: 1035 * The receiver has a list of chunk types which it expects 1036 * to be received only after an AUTH-chunk. This list has 1037 * been sent to the peer during the association setup. It 1038 * MUST silently discard these chunks if they are not placed 1039 * after an AUTH chunk in the packet. 1040 */ 1041 if (sctp_auth_recv_cid(subtype.chunk, asoc) && !chunk->auth) 1042 continue; 1043 1044 /* Remember where the last DATA chunk came from so we 1045 * know where to send the SACK. 1046 */ 1047 if (sctp_chunk_is_data(chunk)) 1048 asoc->peer.last_data_from = chunk->transport; 1049 else 1050 SCTP_INC_STATS(SCTP_MIB_INCTRLCHUNKS); 1051 1052 if (chunk->transport) 1053 chunk->transport->last_time_heard = jiffies; 1054 1055 /* Run through the state machine. */ 1056 error = sctp_do_sm(SCTP_EVENT_T_CHUNK, subtype, 1057 state, ep, asoc, chunk, GFP_ATOMIC); 1058 1059 /* Check to see if the association is freed in response to 1060 * the incoming chunk. If so, get out of the while loop. 1061 */ 1062 if (asoc->base.dead) 1063 break; 1064 1065 /* If there is an error on chunk, discard this packet. */ 1066 if (error && chunk) 1067 chunk->pdiscard = 1; 1068 } 1069 sctp_association_put(asoc); 1070 } 1071 1072 /* This routine moves an association from its old sk to a new sk. */ 1073 void sctp_assoc_migrate(struct sctp_association *assoc, struct sock *newsk) 1074 { 1075 struct sctp_sock *newsp = sctp_sk(newsk); 1076 struct sock *oldsk = assoc->base.sk; 1077 1078 /* Delete the association from the old endpoint's list of 1079 * associations. 1080 */ 1081 list_del_init(&assoc->asocs); 1082 1083 /* Decrement the backlog value for a TCP-style socket. */ 1084 if (sctp_style(oldsk, TCP)) 1085 oldsk->sk_ack_backlog--; 1086 1087 /* Release references to the old endpoint and the sock. */ 1088 sctp_endpoint_put(assoc->ep); 1089 sock_put(assoc->base.sk); 1090 1091 /* Get a reference to the new endpoint. */ 1092 assoc->ep = newsp->ep; 1093 sctp_endpoint_hold(assoc->ep); 1094 1095 /* Get a reference to the new sock. */ 1096 assoc->base.sk = newsk; 1097 sock_hold(assoc->base.sk); 1098 1099 /* Add the association to the new endpoint's list of associations. */ 1100 sctp_endpoint_add_asoc(newsp->ep, assoc); 1101 } 1102 1103 /* Update an association (possibly from unexpected COOKIE-ECHO processing). */ 1104 void sctp_assoc_update(struct sctp_association *asoc, 1105 struct sctp_association *new) 1106 { 1107 struct sctp_transport *trans; 1108 struct list_head *pos, *temp; 1109 1110 /* Copy in new parameters of peer. */ 1111 asoc->c = new->c; 1112 asoc->peer.rwnd = new->peer.rwnd; 1113 asoc->peer.sack_needed = new->peer.sack_needed; 1114 asoc->peer.i = new->peer.i; 1115 sctp_tsnmap_init(&asoc->peer.tsn_map, SCTP_TSN_MAP_SIZE, 1116 asoc->peer.i.initial_tsn); 1117 1118 /* Remove any peer addresses not present in the new association. */ 1119 list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) { 1120 trans = list_entry(pos, struct sctp_transport, transports); 1121 if (!sctp_assoc_lookup_paddr(new, &trans->ipaddr)) 1122 sctp_assoc_del_peer(asoc, &trans->ipaddr); 1123 1124 if (asoc->state >= SCTP_STATE_ESTABLISHED) 1125 sctp_transport_reset(trans); 1126 } 1127 1128 /* If the case is A (association restart), use 1129 * initial_tsn as next_tsn. If the case is B, use 1130 * current next_tsn in case data sent to peer 1131 * has been discarded and needs retransmission. 1132 */ 1133 if (asoc->state >= SCTP_STATE_ESTABLISHED) { 1134 asoc->next_tsn = new->next_tsn; 1135 asoc->ctsn_ack_point = new->ctsn_ack_point; 1136 asoc->adv_peer_ack_point = new->adv_peer_ack_point; 1137 1138 /* Reinitialize SSN for both local streams 1139 * and peer's streams. 1140 */ 1141 sctp_ssnmap_clear(asoc->ssnmap); 1142 1143 /* Flush the ULP reassembly and ordered queue. 1144 * Any data there will now be stale and will 1145 * cause problems. 1146 */ 1147 sctp_ulpq_flush(&asoc->ulpq); 1148 1149 /* reset the overall association error count so 1150 * that the restarted association doesn't get torn 1151 * down on the next retransmission timer. 1152 */ 1153 asoc->overall_error_count = 0; 1154 1155 } else { 1156 /* Add any peer addresses from the new association. */ 1157 list_for_each(pos, &new->peer.transport_addr_list) { 1158 trans = list_entry(pos, struct sctp_transport, 1159 transports); 1160 if (!sctp_assoc_lookup_paddr(asoc, &trans->ipaddr)) 1161 sctp_assoc_add_peer(asoc, &trans->ipaddr, 1162 GFP_ATOMIC, trans->state); 1163 } 1164 1165 asoc->ctsn_ack_point = asoc->next_tsn - 1; 1166 asoc->adv_peer_ack_point = asoc->ctsn_ack_point; 1167 if (!asoc->ssnmap) { 1168 /* Move the ssnmap. */ 1169 asoc->ssnmap = new->ssnmap; 1170 new->ssnmap = NULL; 1171 } 1172 1173 if (!asoc->assoc_id) { 1174 /* get a new association id since we don't have one 1175 * yet. 1176 */ 1177 sctp_assoc_set_id(asoc, GFP_ATOMIC); 1178 } 1179 } 1180 1181 /* SCTP-AUTH: Save the peer parameters from the new assocaitions 1182 * and also move the association shared keys over 1183 */ 1184 kfree(asoc->peer.peer_random); 1185 asoc->peer.peer_random = new->peer.peer_random; 1186 new->peer.peer_random = NULL; 1187 1188 kfree(asoc->peer.peer_chunks); 1189 asoc->peer.peer_chunks = new->peer.peer_chunks; 1190 new->peer.peer_chunks = NULL; 1191 1192 kfree(asoc->peer.peer_hmacs); 1193 asoc->peer.peer_hmacs = new->peer.peer_hmacs; 1194 new->peer.peer_hmacs = NULL; 1195 1196 sctp_auth_key_put(asoc->asoc_shared_key); 1197 sctp_auth_asoc_init_active_key(asoc, GFP_ATOMIC); 1198 } 1199 1200 /* Update the retran path for sending a retransmitted packet. 1201 * Round-robin through the active transports, else round-robin 1202 * through the inactive transports as this is the next best thing 1203 * we can try. 1204 */ 1205 void sctp_assoc_update_retran_path(struct sctp_association *asoc) 1206 { 1207 struct sctp_transport *t, *next; 1208 struct list_head *head = &asoc->peer.transport_addr_list; 1209 struct list_head *pos; 1210 1211 /* Find the next transport in a round-robin fashion. */ 1212 t = asoc->peer.retran_path; 1213 pos = &t->transports; 1214 next = NULL; 1215 1216 while (1) { 1217 /* Skip the head. */ 1218 if (pos->next == head) 1219 pos = head->next; 1220 else 1221 pos = pos->next; 1222 1223 t = list_entry(pos, struct sctp_transport, transports); 1224 1225 /* Try to find an active transport. */ 1226 1227 if ((t->state == SCTP_ACTIVE) || 1228 (t->state == SCTP_UNKNOWN)) { 1229 break; 1230 } else { 1231 /* Keep track of the next transport in case 1232 * we don't find any active transport. 1233 */ 1234 if (!next) 1235 next = t; 1236 } 1237 1238 /* We have exhausted the list, but didn't find any 1239 * other active transports. If so, use the next 1240 * transport. 1241 */ 1242 if (t == asoc->peer.retran_path) { 1243 t = next; 1244 break; 1245 } 1246 } 1247 1248 asoc->peer.retran_path = t; 1249 1250 SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_update_retran_path:association" 1251 " %p addr: ", 1252 " port: %d\n", 1253 asoc, 1254 (&t->ipaddr), 1255 ntohs(t->ipaddr.v4.sin_port)); 1256 } 1257 1258 /* Choose the transport for sending a INIT packet. */ 1259 struct sctp_transport *sctp_assoc_choose_init_transport( 1260 struct sctp_association *asoc) 1261 { 1262 struct sctp_transport *t; 1263 1264 /* Use the retran path. If the last INIT was sent over the 1265 * retran path, update the retran path and use it. 1266 */ 1267 if (!asoc->init_last_sent_to) { 1268 t = asoc->peer.active_path; 1269 } else { 1270 if (asoc->init_last_sent_to == asoc->peer.retran_path) 1271 sctp_assoc_update_retran_path(asoc); 1272 t = asoc->peer.retran_path; 1273 } 1274 1275 SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_update_retran_path:association" 1276 " %p addr: ", 1277 " port: %d\n", 1278 asoc, 1279 (&t->ipaddr), 1280 ntohs(t->ipaddr.v4.sin_port)); 1281 1282 return t; 1283 } 1284 1285 /* Choose the transport for sending a SHUTDOWN packet. */ 1286 struct sctp_transport *sctp_assoc_choose_shutdown_transport( 1287 struct sctp_association *asoc) 1288 { 1289 /* If this is the first time SHUTDOWN is sent, use the active path, 1290 * else use the retran path. If the last SHUTDOWN was sent over the 1291 * retran path, update the retran path and use it. 1292 */ 1293 if (!asoc->shutdown_last_sent_to) 1294 return asoc->peer.active_path; 1295 else { 1296 if (asoc->shutdown_last_sent_to == asoc->peer.retran_path) 1297 sctp_assoc_update_retran_path(asoc); 1298 return asoc->peer.retran_path; 1299 } 1300 1301 } 1302 1303 /* Update the association's pmtu and frag_point by going through all the 1304 * transports. This routine is called when a transport's PMTU has changed. 1305 */ 1306 void sctp_assoc_sync_pmtu(struct sctp_association *asoc) 1307 { 1308 struct sctp_transport *t; 1309 struct list_head *pos; 1310 __u32 pmtu = 0; 1311 1312 if (!asoc) 1313 return; 1314 1315 /* Get the lowest pmtu of all the transports. */ 1316 list_for_each(pos, &asoc->peer.transport_addr_list) { 1317 t = list_entry(pos, struct sctp_transport, transports); 1318 if (t->pmtu_pending && t->dst) { 1319 sctp_transport_update_pmtu(t, dst_mtu(t->dst)); 1320 t->pmtu_pending = 0; 1321 } 1322 if (!pmtu || (t->pathmtu < pmtu)) 1323 pmtu = t->pathmtu; 1324 } 1325 1326 if (pmtu) { 1327 struct sctp_sock *sp = sctp_sk(asoc->base.sk); 1328 asoc->pathmtu = pmtu; 1329 asoc->frag_point = sctp_frag_point(sp, pmtu); 1330 } 1331 1332 SCTP_DEBUG_PRINTK("%s: asoc:%p, pmtu:%d, frag_point:%d\n", 1333 __FUNCTION__, asoc, asoc->pathmtu, asoc->frag_point); 1334 } 1335 1336 /* Should we send a SACK to update our peer? */ 1337 static inline int sctp_peer_needs_update(struct sctp_association *asoc) 1338 { 1339 switch (asoc->state) { 1340 case SCTP_STATE_ESTABLISHED: 1341 case SCTP_STATE_SHUTDOWN_PENDING: 1342 case SCTP_STATE_SHUTDOWN_RECEIVED: 1343 case SCTP_STATE_SHUTDOWN_SENT: 1344 if ((asoc->rwnd > asoc->a_rwnd) && 1345 ((asoc->rwnd - asoc->a_rwnd) >= 1346 min_t(__u32, (asoc->base.sk->sk_rcvbuf >> 1), asoc->pathmtu))) 1347 return 1; 1348 break; 1349 default: 1350 break; 1351 } 1352 return 0; 1353 } 1354 1355 /* Increase asoc's rwnd by len and send any window update SACK if needed. */ 1356 void sctp_assoc_rwnd_increase(struct sctp_association *asoc, unsigned len) 1357 { 1358 struct sctp_chunk *sack; 1359 struct timer_list *timer; 1360 1361 if (asoc->rwnd_over) { 1362 if (asoc->rwnd_over >= len) { 1363 asoc->rwnd_over -= len; 1364 } else { 1365 asoc->rwnd += (len - asoc->rwnd_over); 1366 asoc->rwnd_over = 0; 1367 } 1368 } else { 1369 asoc->rwnd += len; 1370 } 1371 1372 SCTP_DEBUG_PRINTK("%s: asoc %p rwnd increased by %d to (%u, %u) " 1373 "- %u\n", __FUNCTION__, asoc, len, asoc->rwnd, 1374 asoc->rwnd_over, asoc->a_rwnd); 1375 1376 /* Send a window update SACK if the rwnd has increased by at least the 1377 * minimum of the association's PMTU and half of the receive buffer. 1378 * The algorithm used is similar to the one described in 1379 * Section 4.2.3.3 of RFC 1122. 1380 */ 1381 if (sctp_peer_needs_update(asoc)) { 1382 asoc->a_rwnd = asoc->rwnd; 1383 SCTP_DEBUG_PRINTK("%s: Sending window update SACK- asoc: %p " 1384 "rwnd: %u a_rwnd: %u\n", __FUNCTION__, 1385 asoc, asoc->rwnd, asoc->a_rwnd); 1386 sack = sctp_make_sack(asoc); 1387 if (!sack) 1388 return; 1389 1390 asoc->peer.sack_needed = 0; 1391 1392 sctp_outq_tail(&asoc->outqueue, sack); 1393 1394 /* Stop the SACK timer. */ 1395 timer = &asoc->timers[SCTP_EVENT_TIMEOUT_SACK]; 1396 if (timer_pending(timer) && del_timer(timer)) 1397 sctp_association_put(asoc); 1398 } 1399 } 1400 1401 /* Decrease asoc's rwnd by len. */ 1402 void sctp_assoc_rwnd_decrease(struct sctp_association *asoc, unsigned len) 1403 { 1404 SCTP_ASSERT(asoc->rwnd, "rwnd zero", return); 1405 SCTP_ASSERT(!asoc->rwnd_over, "rwnd_over not zero", return); 1406 if (asoc->rwnd >= len) { 1407 asoc->rwnd -= len; 1408 } else { 1409 asoc->rwnd_over = len - asoc->rwnd; 1410 asoc->rwnd = 0; 1411 } 1412 SCTP_DEBUG_PRINTK("%s: asoc %p rwnd decreased by %d to (%u, %u)\n", 1413 __FUNCTION__, asoc, len, asoc->rwnd, 1414 asoc->rwnd_over); 1415 } 1416 1417 /* Build the bind address list for the association based on info from the 1418 * local endpoint and the remote peer. 1419 */ 1420 int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *asoc, 1421 gfp_t gfp) 1422 { 1423 sctp_scope_t scope; 1424 int flags; 1425 1426 /* Use scoping rules to determine the subset of addresses from 1427 * the endpoint. 1428 */ 1429 scope = sctp_scope(&asoc->peer.active_path->ipaddr); 1430 flags = (PF_INET6 == asoc->base.sk->sk_family) ? SCTP_ADDR6_ALLOWED : 0; 1431 if (asoc->peer.ipv4_address) 1432 flags |= SCTP_ADDR4_PEERSUPP; 1433 if (asoc->peer.ipv6_address) 1434 flags |= SCTP_ADDR6_PEERSUPP; 1435 1436 return sctp_bind_addr_copy(&asoc->base.bind_addr, 1437 &asoc->ep->base.bind_addr, 1438 scope, gfp, flags); 1439 } 1440 1441 /* Build the association's bind address list from the cookie. */ 1442 int sctp_assoc_set_bind_addr_from_cookie(struct sctp_association *asoc, 1443 struct sctp_cookie *cookie, 1444 gfp_t gfp) 1445 { 1446 int var_size2 = ntohs(cookie->peer_init->chunk_hdr.length); 1447 int var_size3 = cookie->raw_addr_list_len; 1448 __u8 *raw = (__u8 *)cookie->peer_init + var_size2; 1449 1450 return sctp_raw_to_bind_addrs(&asoc->base.bind_addr, raw, var_size3, 1451 asoc->ep->base.bind_addr.port, gfp); 1452 } 1453 1454 /* Lookup laddr in the bind address list of an association. */ 1455 int sctp_assoc_lookup_laddr(struct sctp_association *asoc, 1456 const union sctp_addr *laddr) 1457 { 1458 int found = 0; 1459 1460 if ((asoc->base.bind_addr.port == ntohs(laddr->v4.sin_port)) && 1461 sctp_bind_addr_match(&asoc->base.bind_addr, laddr, 1462 sctp_sk(asoc->base.sk))) 1463 found = 1; 1464 1465 return found; 1466 } 1467 1468 /* Set an association id for a given association */ 1469 int sctp_assoc_set_id(struct sctp_association *asoc, gfp_t gfp) 1470 { 1471 int assoc_id; 1472 int error = 0; 1473 retry: 1474 if (unlikely(!idr_pre_get(&sctp_assocs_id, gfp))) 1475 return -ENOMEM; 1476 1477 spin_lock_bh(&sctp_assocs_id_lock); 1478 error = idr_get_new_above(&sctp_assocs_id, (void *)asoc, 1479 1, &assoc_id); 1480 spin_unlock_bh(&sctp_assocs_id_lock); 1481 if (error == -EAGAIN) 1482 goto retry; 1483 else if (error) 1484 return error; 1485 1486 asoc->assoc_id = (sctp_assoc_t) assoc_id; 1487 return error; 1488 } 1489 1490 /* Free asconf_ack cache */ 1491 static void sctp_assoc_free_asconf_acks(struct sctp_association *asoc) 1492 { 1493 struct sctp_chunk *ack; 1494 struct sctp_chunk *tmp; 1495 1496 list_for_each_entry_safe(ack, tmp, &asoc->asconf_ack_list, 1497 transmitted_list) { 1498 list_del_init(&ack->transmitted_list); 1499 sctp_chunk_free(ack); 1500 } 1501 } 1502 1503 /* Clean up the ASCONF_ACK queue */ 1504 void sctp_assoc_clean_asconf_ack_cache(const struct sctp_association *asoc) 1505 { 1506 struct sctp_chunk *ack; 1507 struct sctp_chunk *tmp; 1508 1509 /* We can remove all the entries from the queue upto 1510 * the "Peer-Sequence-Number". 1511 */ 1512 list_for_each_entry_safe(ack, tmp, &asoc->asconf_ack_list, 1513 transmitted_list) { 1514 if (ack->subh.addip_hdr->serial == 1515 htonl(asoc->peer.addip_serial)) 1516 break; 1517 1518 list_del_init(&ack->transmitted_list); 1519 sctp_chunk_free(ack); 1520 } 1521 } 1522 1523 /* Find the ASCONF_ACK whose serial number matches ASCONF */ 1524 struct sctp_chunk *sctp_assoc_lookup_asconf_ack( 1525 const struct sctp_association *asoc, 1526 __be32 serial) 1527 { 1528 struct sctp_chunk *ack = NULL; 1529 1530 /* Walk through the list of cached ASCONF-ACKs and find the 1531 * ack chunk whose serial number matches that of the request. 1532 */ 1533 list_for_each_entry(ack, &asoc->asconf_ack_list, transmitted_list) { 1534 if (ack->subh.addip_hdr->serial == serial) { 1535 sctp_chunk_hold(ack); 1536 break; 1537 } 1538 } 1539 1540 return ack; 1541 } 1542