11da177e4SLinus Torvalds /* SCTP kernel reference Implementation 21da177e4SLinus Torvalds * Copyright (c) 1999-2000 Cisco, Inc. 31da177e4SLinus Torvalds * Copyright (c) 1999-2001 Motorola, Inc. 41da177e4SLinus Torvalds * Copyright (c) 2001-2002 International Business Machines, Corp. 51da177e4SLinus Torvalds * Copyright (c) 2001 Intel Corp. 61da177e4SLinus Torvalds * Copyright (c) 2001 Nokia, Inc. 71da177e4SLinus Torvalds * Copyright (c) 2001 La Monte H.P. Yarroll 81da177e4SLinus Torvalds * 91da177e4SLinus Torvalds * This file is part of the SCTP kernel reference Implementation 101da177e4SLinus Torvalds * 111da177e4SLinus Torvalds * This abstraction represents an SCTP endpoint. 121da177e4SLinus Torvalds * 131da177e4SLinus Torvalds * This file is part of the implementation of the add-IP extension, 141da177e4SLinus Torvalds * based on <draft-ietf-tsvwg-addip-sctp-02.txt> June 29, 2001, 151da177e4SLinus Torvalds * for the SCTP kernel reference Implementation. 161da177e4SLinus Torvalds * 171da177e4SLinus Torvalds * The SCTP reference implementation is free software; 181da177e4SLinus Torvalds * you can redistribute it and/or modify it under the terms of 191da177e4SLinus Torvalds * the GNU General Public License as published by 201da177e4SLinus Torvalds * the Free Software Foundation; either version 2, or (at your option) 211da177e4SLinus Torvalds * any later version. 221da177e4SLinus Torvalds * 231da177e4SLinus Torvalds * The SCTP reference implementation is distributed in the hope that it 241da177e4SLinus Torvalds * will be useful, but WITHOUT ANY WARRANTY; without even the implied 251da177e4SLinus Torvalds * ************************ 261da177e4SLinus Torvalds * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 271da177e4SLinus Torvalds * See the GNU General Public License for more details. 281da177e4SLinus Torvalds * 291da177e4SLinus Torvalds * You should have received a copy of the GNU General Public License 301da177e4SLinus Torvalds * along with GNU CC; see the file COPYING. If not, write to 311da177e4SLinus Torvalds * the Free Software Foundation, 59 Temple Place - Suite 330, 321da177e4SLinus Torvalds * Boston, MA 02111-1307, USA. 331da177e4SLinus Torvalds * 341da177e4SLinus Torvalds * Please send any bug reports or fixes you make to the 351da177e4SLinus Torvalds * email address(es): 361da177e4SLinus Torvalds * lksctp developers <lksctp-developers@lists.sourceforge.net> 371da177e4SLinus Torvalds * 381da177e4SLinus Torvalds * Or submit a bug report through the following website: 391da177e4SLinus Torvalds * http://www.sf.net/projects/lksctp 401da177e4SLinus Torvalds * 411da177e4SLinus Torvalds * Written or modified by: 421da177e4SLinus Torvalds * La Monte H.P. Yarroll <piggy@acm.org> 431da177e4SLinus Torvalds * Karl Knutson <karl@athena.chicago.il.us> 441da177e4SLinus Torvalds * Jon Grimm <jgrimm@austin.ibm.com> 451da177e4SLinus Torvalds * Daisy Chang <daisyc@us.ibm.com> 461da177e4SLinus Torvalds * Dajiang Zhang <dajiang.zhang@nokia.com> 471da177e4SLinus Torvalds * 481da177e4SLinus Torvalds * Any bugs reported given to us we will try to fix... any fixes shared will 491da177e4SLinus Torvalds * be incorporated into the next SCTP release. 501da177e4SLinus Torvalds */ 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds #include <linux/types.h> 531da177e4SLinus Torvalds #include <linux/sched.h> 541da177e4SLinus Torvalds #include <linux/slab.h> 551da177e4SLinus Torvalds #include <linux/in.h> 561da177e4SLinus Torvalds #include <linux/random.h> /* get_random_bytes() */ 571da177e4SLinus Torvalds #include <linux/crypto.h> 581da177e4SLinus Torvalds #include <net/sock.h> 591da177e4SLinus Torvalds #include <net/ipv6.h> 601da177e4SLinus Torvalds #include <net/sctp/sctp.h> 611da177e4SLinus Torvalds #include <net/sctp/sm.h> 621da177e4SLinus Torvalds 631da177e4SLinus Torvalds /* Forward declarations for internal helpers. */ 64c4028958SDavid Howells static void sctp_endpoint_bh_rcv(struct work_struct *work); 651da177e4SLinus Torvalds 661da177e4SLinus Torvalds /* 671da177e4SLinus Torvalds * Initialize the base fields of the endpoint structure. 681da177e4SLinus Torvalds */ 691da177e4SLinus Torvalds static struct sctp_endpoint *sctp_endpoint_init(struct sctp_endpoint *ep, 703182cd84SAlexey Dobriyan struct sock *sk, 71dd0fc66fSAl Viro gfp_t gfp) 721da177e4SLinus Torvalds { 731da177e4SLinus Torvalds memset(ep, 0, sizeof(struct sctp_endpoint)); 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds /* Initialize the base structure. */ 761da177e4SLinus Torvalds /* What type of endpoint are we? */ 771da177e4SLinus Torvalds ep->base.type = SCTP_EP_TYPE_SOCKET; 781da177e4SLinus Torvalds 791da177e4SLinus Torvalds /* Initialize the basic object fields. */ 801da177e4SLinus Torvalds atomic_set(&ep->base.refcnt, 1); 811da177e4SLinus Torvalds ep->base.dead = 0; 821da177e4SLinus Torvalds ep->base.malloced = 1; 831da177e4SLinus Torvalds 841da177e4SLinus Torvalds /* Create an input queue. */ 851da177e4SLinus Torvalds sctp_inq_init(&ep->base.inqueue); 861da177e4SLinus Torvalds 871da177e4SLinus Torvalds /* Set its top-half handler */ 88c4028958SDavid Howells sctp_inq_set_th_handler(&ep->base.inqueue, sctp_endpoint_bh_rcv); 891da177e4SLinus Torvalds 901da177e4SLinus Torvalds /* Initialize the bind addr area */ 911da177e4SLinus Torvalds sctp_bind_addr_init(&ep->base.bind_addr, 0); 921da177e4SLinus Torvalds rwlock_init(&ep->base.addr_lock); 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds /* Remember who we are attached to. */ 951da177e4SLinus Torvalds ep->base.sk = sk; 961da177e4SLinus Torvalds sock_hold(ep->base.sk); 971da177e4SLinus Torvalds 981da177e4SLinus Torvalds /* Create the lists of associations. */ 991da177e4SLinus Torvalds INIT_LIST_HEAD(&ep->asocs); 1001da177e4SLinus Torvalds 1011da177e4SLinus Torvalds /* Use SCTP specific send buffer space queues. */ 1024eb701dfSNeil Horman ep->sndbuf_policy = sctp_sndbuf_policy; 1031da177e4SLinus Torvalds sk->sk_write_space = sctp_write_space; 1041da177e4SLinus Torvalds sock_set_flag(sk, SOCK_USE_WRITE_QUEUE); 1051da177e4SLinus Torvalds 106049b3ff5SNeil Horman /* Get the receive buffer policy for this endpoint */ 107049b3ff5SNeil Horman ep->rcvbuf_policy = sctp_rcvbuf_policy; 108049b3ff5SNeil Horman 1091da177e4SLinus Torvalds /* Initialize the secret key used with cookie. */ 1101da177e4SLinus Torvalds get_random_bytes(&ep->secret_key[0], SCTP_SECRET_SIZE); 1111da177e4SLinus Torvalds ep->last_key = ep->current_key = 0; 1121da177e4SLinus Torvalds ep->key_changed_at = jiffies; 1131da177e4SLinus Torvalds 1141da177e4SLinus Torvalds return ep; 1151da177e4SLinus Torvalds } 1161da177e4SLinus Torvalds 1171da177e4SLinus Torvalds /* Create a sctp_endpoint with all that boring stuff initialized. 1181da177e4SLinus Torvalds * Returns NULL if there isn't enough memory. 1191da177e4SLinus Torvalds */ 120dd0fc66fSAl Viro struct sctp_endpoint *sctp_endpoint_new(struct sock *sk, gfp_t gfp) 1211da177e4SLinus Torvalds { 1221da177e4SLinus Torvalds struct sctp_endpoint *ep; 1231da177e4SLinus Torvalds 1241da177e4SLinus Torvalds /* Build a local endpoint. */ 1251da177e4SLinus Torvalds ep = t_new(struct sctp_endpoint, gfp); 1261da177e4SLinus Torvalds if (!ep) 1271da177e4SLinus Torvalds goto fail; 1281da177e4SLinus Torvalds if (!sctp_endpoint_init(ep, sk, gfp)) 1291da177e4SLinus Torvalds goto fail_init; 1301da177e4SLinus Torvalds ep->base.malloced = 1; 1311da177e4SLinus Torvalds SCTP_DBG_OBJCNT_INC(ep); 1321da177e4SLinus Torvalds return ep; 1331da177e4SLinus Torvalds 1341da177e4SLinus Torvalds fail_init: 1351da177e4SLinus Torvalds kfree(ep); 1361da177e4SLinus Torvalds fail: 1371da177e4SLinus Torvalds return NULL; 1381da177e4SLinus Torvalds } 1391da177e4SLinus Torvalds 1401da177e4SLinus Torvalds /* Add an association to an endpoint. */ 1411da177e4SLinus Torvalds void sctp_endpoint_add_asoc(struct sctp_endpoint *ep, 1421da177e4SLinus Torvalds struct sctp_association *asoc) 1431da177e4SLinus Torvalds { 1441da177e4SLinus Torvalds struct sock *sk = ep->base.sk; 1451da177e4SLinus Torvalds 146de76e695SVlad Yasevich /* If this is a temporary association, don't bother 147de76e695SVlad Yasevich * since we'll be removing it shortly and don't 148de76e695SVlad Yasevich * want anyone to find it anyway. 149de76e695SVlad Yasevich */ 150de76e695SVlad Yasevich if (asoc->temp) 151de76e695SVlad Yasevich return; 152de76e695SVlad Yasevich 1531da177e4SLinus Torvalds /* Now just add it to our list of asocs */ 1541da177e4SLinus Torvalds list_add_tail(&asoc->asocs, &ep->asocs); 1551da177e4SLinus Torvalds 1561da177e4SLinus Torvalds /* Increment the backlog value for a TCP-style listening socket. */ 1571da177e4SLinus Torvalds if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)) 1581da177e4SLinus Torvalds sk->sk_ack_backlog++; 1591da177e4SLinus Torvalds } 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds /* Free the endpoint structure. Delay cleanup until 1621da177e4SLinus Torvalds * all users have released their reference count on this structure. 1631da177e4SLinus Torvalds */ 1641da177e4SLinus Torvalds void sctp_endpoint_free(struct sctp_endpoint *ep) 1651da177e4SLinus Torvalds { 1661da177e4SLinus Torvalds ep->base.dead = 1; 167cfdeef32SVlad Yasevich 168cfdeef32SVlad Yasevich ep->base.sk->sk_state = SCTP_SS_CLOSED; 169cfdeef32SVlad Yasevich 170cfdeef32SVlad Yasevich /* Unlink this endpoint, so we can't find it again! */ 171cfdeef32SVlad Yasevich sctp_unhash_endpoint(ep); 172cfdeef32SVlad Yasevich 1731da177e4SLinus Torvalds sctp_endpoint_put(ep); 1741da177e4SLinus Torvalds } 1751da177e4SLinus Torvalds 1761da177e4SLinus Torvalds /* Final destructor for endpoint. */ 1771da177e4SLinus Torvalds static void sctp_endpoint_destroy(struct sctp_endpoint *ep) 1781da177e4SLinus Torvalds { 1791da177e4SLinus Torvalds SCTP_ASSERT(ep->base.dead, "Endpoint is not dead", return); 1801da177e4SLinus Torvalds 1811da177e4SLinus Torvalds /* Free up the HMAC transform. */ 1821b489e11SHerbert Xu crypto_free_hash(sctp_sk(ep->base.sk)->hmac); 1831da177e4SLinus Torvalds 1841da177e4SLinus Torvalds /* Cleanup. */ 1851da177e4SLinus Torvalds sctp_inq_free(&ep->base.inqueue); 1861da177e4SLinus Torvalds sctp_bind_addr_free(&ep->base.bind_addr); 1871da177e4SLinus Torvalds 1881da177e4SLinus Torvalds /* Remove and free the port */ 1891da177e4SLinus Torvalds if (sctp_sk(ep->base.sk)->bind_hash) 1901da177e4SLinus Torvalds sctp_put_port(ep->base.sk); 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds /* Give up our hold on the sock. */ 1931da177e4SLinus Torvalds if (ep->base.sk) 1941da177e4SLinus Torvalds sock_put(ep->base.sk); 1951da177e4SLinus Torvalds 1961da177e4SLinus Torvalds /* Finally, free up our memory. */ 1971da177e4SLinus Torvalds if (ep->base.malloced) { 1981da177e4SLinus Torvalds kfree(ep); 1991da177e4SLinus Torvalds SCTP_DBG_OBJCNT_DEC(ep); 2001da177e4SLinus Torvalds } 2011da177e4SLinus Torvalds } 2021da177e4SLinus Torvalds 2031da177e4SLinus Torvalds /* Hold a reference to an endpoint. */ 2041da177e4SLinus Torvalds void sctp_endpoint_hold(struct sctp_endpoint *ep) 2051da177e4SLinus Torvalds { 2061da177e4SLinus Torvalds atomic_inc(&ep->base.refcnt); 2071da177e4SLinus Torvalds } 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds /* Release a reference to an endpoint and clean up if there are 2101da177e4SLinus Torvalds * no more references. 2111da177e4SLinus Torvalds */ 2121da177e4SLinus Torvalds void sctp_endpoint_put(struct sctp_endpoint *ep) 2131da177e4SLinus Torvalds { 2141da177e4SLinus Torvalds if (atomic_dec_and_test(&ep->base.refcnt)) 2151da177e4SLinus Torvalds sctp_endpoint_destroy(ep); 2161da177e4SLinus Torvalds } 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds /* Is this the endpoint we are looking for? */ 2191da177e4SLinus Torvalds struct sctp_endpoint *sctp_endpoint_is_match(struct sctp_endpoint *ep, 2201da177e4SLinus Torvalds const union sctp_addr *laddr) 2211da177e4SLinus Torvalds { 2221da177e4SLinus Torvalds struct sctp_endpoint *retval; 2231da177e4SLinus Torvalds 2241da177e4SLinus Torvalds sctp_read_lock(&ep->base.addr_lock); 2251da177e4SLinus Torvalds if (ep->base.bind_addr.port == laddr->v4.sin_port) { 2261da177e4SLinus Torvalds if (sctp_bind_addr_match(&ep->base.bind_addr, laddr, 2271da177e4SLinus Torvalds sctp_sk(ep->base.sk))) { 2281da177e4SLinus Torvalds retval = ep; 2291da177e4SLinus Torvalds goto out; 2301da177e4SLinus Torvalds } 2311da177e4SLinus Torvalds } 2321da177e4SLinus Torvalds 2331da177e4SLinus Torvalds retval = NULL; 2341da177e4SLinus Torvalds 2351da177e4SLinus Torvalds out: 2361da177e4SLinus Torvalds sctp_read_unlock(&ep->base.addr_lock); 2371da177e4SLinus Torvalds return retval; 2381da177e4SLinus Torvalds } 2391da177e4SLinus Torvalds 2401da177e4SLinus Torvalds /* Find the association that goes with this chunk. 2411da177e4SLinus Torvalds * We do a linear search of the associations for this endpoint. 2421da177e4SLinus Torvalds * We return the matching transport address too. 2431da177e4SLinus Torvalds */ 2441da177e4SLinus Torvalds static struct sctp_association *__sctp_endpoint_lookup_assoc( 2451da177e4SLinus Torvalds const struct sctp_endpoint *ep, 2461da177e4SLinus Torvalds const union sctp_addr *paddr, 2471da177e4SLinus Torvalds struct sctp_transport **transport) 2481da177e4SLinus Torvalds { 2491da177e4SLinus Torvalds int rport; 2501da177e4SLinus Torvalds struct sctp_association *asoc; 2511da177e4SLinus Torvalds struct list_head *pos; 2521da177e4SLinus Torvalds 2531da177e4SLinus Torvalds rport = paddr->v4.sin_port; 2541da177e4SLinus Torvalds 2551da177e4SLinus Torvalds list_for_each(pos, &ep->asocs) { 2561da177e4SLinus Torvalds asoc = list_entry(pos, struct sctp_association, asocs); 2571da177e4SLinus Torvalds if (rport == asoc->peer.port) { 2581da177e4SLinus Torvalds sctp_read_lock(&asoc->base.addr_lock); 2591da177e4SLinus Torvalds *transport = sctp_assoc_lookup_paddr(asoc, paddr); 2601da177e4SLinus Torvalds sctp_read_unlock(&asoc->base.addr_lock); 2611da177e4SLinus Torvalds 2621da177e4SLinus Torvalds if (*transport) 2631da177e4SLinus Torvalds return asoc; 2641da177e4SLinus Torvalds } 2651da177e4SLinus Torvalds } 2661da177e4SLinus Torvalds 2671da177e4SLinus Torvalds *transport = NULL; 2681da177e4SLinus Torvalds return NULL; 2691da177e4SLinus Torvalds } 2701da177e4SLinus Torvalds 2711da177e4SLinus Torvalds /* Lookup association on an endpoint based on a peer address. BH-safe. */ 2721da177e4SLinus Torvalds struct sctp_association *sctp_endpoint_lookup_assoc( 2731da177e4SLinus Torvalds const struct sctp_endpoint *ep, 2741da177e4SLinus Torvalds const union sctp_addr *paddr, 2751da177e4SLinus Torvalds struct sctp_transport **transport) 2761da177e4SLinus Torvalds { 2771da177e4SLinus Torvalds struct sctp_association *asoc; 2781da177e4SLinus Torvalds 2791da177e4SLinus Torvalds sctp_local_bh_disable(); 2801da177e4SLinus Torvalds asoc = __sctp_endpoint_lookup_assoc(ep, paddr, transport); 2811da177e4SLinus Torvalds sctp_local_bh_enable(); 2821da177e4SLinus Torvalds 2831da177e4SLinus Torvalds return asoc; 2841da177e4SLinus Torvalds } 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds /* Look for any peeled off association from the endpoint that matches the 2871da177e4SLinus Torvalds * given peer address. 2881da177e4SLinus Torvalds */ 2891da177e4SLinus Torvalds int sctp_endpoint_is_peeled_off(struct sctp_endpoint *ep, 2901da177e4SLinus Torvalds const union sctp_addr *paddr) 2911da177e4SLinus Torvalds { 2921da177e4SLinus Torvalds struct list_head *pos; 2931da177e4SLinus Torvalds struct sctp_sockaddr_entry *addr; 2941da177e4SLinus Torvalds struct sctp_bind_addr *bp; 2951da177e4SLinus Torvalds 2961da177e4SLinus Torvalds sctp_read_lock(&ep->base.addr_lock); 2971da177e4SLinus Torvalds bp = &ep->base.bind_addr; 2981da177e4SLinus Torvalds list_for_each(pos, &bp->address_list) { 2991da177e4SLinus Torvalds addr = list_entry(pos, struct sctp_sockaddr_entry, list); 3001da177e4SLinus Torvalds if (sctp_has_association(&addr->a, paddr)) { 3011da177e4SLinus Torvalds sctp_read_unlock(&ep->base.addr_lock); 3021da177e4SLinus Torvalds return 1; 3031da177e4SLinus Torvalds } 3041da177e4SLinus Torvalds } 3051da177e4SLinus Torvalds sctp_read_unlock(&ep->base.addr_lock); 3061da177e4SLinus Torvalds 3071da177e4SLinus Torvalds return 0; 3081da177e4SLinus Torvalds } 3091da177e4SLinus Torvalds 3101da177e4SLinus Torvalds /* Do delayed input processing. This is scheduled by sctp_rcv(). 3111da177e4SLinus Torvalds * This may be called on BH or task time. 3121da177e4SLinus Torvalds */ 313c4028958SDavid Howells static void sctp_endpoint_bh_rcv(struct work_struct *work) 3141da177e4SLinus Torvalds { 315c4028958SDavid Howells struct sctp_endpoint *ep = 316c4028958SDavid Howells container_of(work, struct sctp_endpoint, 317c4028958SDavid Howells base.inqueue.immediate); 3181da177e4SLinus Torvalds struct sctp_association *asoc; 3191da177e4SLinus Torvalds struct sock *sk; 3201da177e4SLinus Torvalds struct sctp_transport *transport; 3211da177e4SLinus Torvalds struct sctp_chunk *chunk; 3221da177e4SLinus Torvalds struct sctp_inq *inqueue; 3231da177e4SLinus Torvalds sctp_subtype_t subtype; 3241da177e4SLinus Torvalds sctp_state_t state; 3251da177e4SLinus Torvalds int error = 0; 3261da177e4SLinus Torvalds 3271da177e4SLinus Torvalds if (ep->base.dead) 3281da177e4SLinus Torvalds return; 3291da177e4SLinus Torvalds 3301da177e4SLinus Torvalds asoc = NULL; 3311da177e4SLinus Torvalds inqueue = &ep->base.inqueue; 3321da177e4SLinus Torvalds sk = ep->base.sk; 3331da177e4SLinus Torvalds 3341da177e4SLinus Torvalds while (NULL != (chunk = sctp_inq_pop(inqueue))) { 3351da177e4SLinus Torvalds subtype = SCTP_ST_CHUNK(chunk->chunk_hdr->type); 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds /* We might have grown an association since last we 3381da177e4SLinus Torvalds * looked, so try again. 3391da177e4SLinus Torvalds * 3401da177e4SLinus Torvalds * This happens when we've just processed our 3411da177e4SLinus Torvalds * COOKIE-ECHO chunk. 3421da177e4SLinus Torvalds */ 3431da177e4SLinus Torvalds if (NULL == chunk->asoc) { 3441da177e4SLinus Torvalds asoc = sctp_endpoint_lookup_assoc(ep, 3451da177e4SLinus Torvalds sctp_source(chunk), 3461da177e4SLinus Torvalds &transport); 3471da177e4SLinus Torvalds chunk->asoc = asoc; 3481da177e4SLinus Torvalds chunk->transport = transport; 3491da177e4SLinus Torvalds } 3501da177e4SLinus Torvalds 3511da177e4SLinus Torvalds state = asoc ? asoc->state : SCTP_STATE_CLOSED; 3521da177e4SLinus Torvalds 3531da177e4SLinus Torvalds /* Remember where the last DATA chunk came from so we 3541da177e4SLinus Torvalds * know where to send the SACK. 3551da177e4SLinus Torvalds */ 3561da177e4SLinus Torvalds if (asoc && sctp_chunk_is_data(chunk)) 3571da177e4SLinus Torvalds asoc->peer.last_data_from = chunk->transport; 3581da177e4SLinus Torvalds else 3591da177e4SLinus Torvalds SCTP_INC_STATS(SCTP_MIB_INCTRLCHUNKS); 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds if (chunk->transport) 3621da177e4SLinus Torvalds chunk->transport->last_time_heard = jiffies; 3631da177e4SLinus Torvalds 3641da177e4SLinus Torvalds error = sctp_do_sm(SCTP_EVENT_T_CHUNK, subtype, state, 3651da177e4SLinus Torvalds ep, asoc, chunk, GFP_ATOMIC); 3661da177e4SLinus Torvalds 3671da177e4SLinus Torvalds if (error && chunk) 3681da177e4SLinus Torvalds chunk->pdiscard = 1; 3691da177e4SLinus Torvalds 3701da177e4SLinus Torvalds /* Check to see if the endpoint is freed in response to 3711da177e4SLinus Torvalds * the incoming chunk. If so, get out of the while loop. 3721da177e4SLinus Torvalds */ 3731da177e4SLinus Torvalds if (!sctp_sk(sk)->ep) 3741da177e4SLinus Torvalds break; 3751da177e4SLinus Torvalds } 3761da177e4SLinus Torvalds } 377