18e8caf97SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later 260c778b2SVlad Yasevich /* SCTP kernel implementation 31da177e4SLinus Torvalds * Copyright (c) 1999-2000 Cisco, Inc. 41da177e4SLinus Torvalds * Copyright (c) 1999-2001 Motorola, Inc. 51da177e4SLinus Torvalds * Copyright (c) 2001-2002 International Business Machines, Corp. 61da177e4SLinus Torvalds * Copyright (c) 2001 Intel Corp. 71da177e4SLinus Torvalds * Copyright (c) 2001 Nokia, Inc. 81da177e4SLinus Torvalds * Copyright (c) 2001 La Monte H.P. Yarroll 91da177e4SLinus Torvalds * 1060c778b2SVlad Yasevich * This file is part of the SCTP kernel implementation 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * This abstraction represents an SCTP endpoint. 131da177e4SLinus Torvalds * 141da177e4SLinus Torvalds * Please send any bug reports or fixes you make to the 151da177e4SLinus Torvalds * email address(es): 1691705c61SDaniel Borkmann * lksctp developers <linux-sctp@vger.kernel.org> 171da177e4SLinus Torvalds * 181da177e4SLinus Torvalds * Written or modified by: 191da177e4SLinus Torvalds * La Monte H.P. Yarroll <piggy@acm.org> 201da177e4SLinus Torvalds * Karl Knutson <karl@athena.chicago.il.us> 211da177e4SLinus Torvalds * Jon Grimm <jgrimm@austin.ibm.com> 221da177e4SLinus Torvalds * Daisy Chang <daisyc@us.ibm.com> 231da177e4SLinus Torvalds * Dajiang Zhang <dajiang.zhang@nokia.com> 241da177e4SLinus Torvalds */ 251da177e4SLinus Torvalds 261da177e4SLinus Torvalds #include <linux/types.h> 271da177e4SLinus Torvalds #include <linux/slab.h> 281da177e4SLinus Torvalds #include <linux/in.h> 291da177e4SLinus Torvalds #include <linux/random.h> /* get_random_bytes() */ 301da177e4SLinus Torvalds #include <net/sock.h> 311da177e4SLinus Torvalds #include <net/ipv6.h> 321da177e4SLinus Torvalds #include <net/sctp/sctp.h> 331da177e4SLinus Torvalds #include <net/sctp/sm.h> 341da177e4SLinus Torvalds 351da177e4SLinus Torvalds /* Forward declarations for internal helpers. */ 36c4028958SDavid Howells static void sctp_endpoint_bh_rcv(struct work_struct *work); 371da177e4SLinus Torvalds 381da177e4SLinus Torvalds /* 391da177e4SLinus Torvalds * Initialize the base fields of the endpoint structure. 401da177e4SLinus Torvalds */ 411da177e4SLinus Torvalds static struct sctp_endpoint *sctp_endpoint_init(struct sctp_endpoint *ep, 423182cd84SAlexey Dobriyan struct sock *sk, 43dd0fc66fSAl Viro gfp_t gfp) 441da177e4SLinus Torvalds { 45e1fc3b14SEric W. Biederman struct net *net = sock_net(sk); 46a29a5bd4SVlad Yasevich struct sctp_shared_key *null_key; 47a29a5bd4SVlad Yasevich 48b68dbcabSVlad Yasevich ep->digest = kzalloc(SCTP_SIGNATURE_SIZE, gfp); 49b68dbcabSVlad Yasevich if (!ep->digest) 50b68dbcabSVlad Yasevich return NULL; 51b68dbcabSVlad Yasevich 524e27428fSXin Long ep->asconf_enable = net->sctp.addip_enable; 53b14878ccSVlad Yasevich ep->auth_enable = net->sctp.auth_enable; 54b14878ccSVlad Yasevich if (ep->auth_enable) { 5503f96127SXin Long if (sctp_auth_init(ep, gfp)) 56a29a5bd4SVlad Yasevich goto nomem; 574e27428fSXin Long if (ep->asconf_enable) { 5803f96127SXin Long sctp_auth_ep_add_chunkid(ep, SCTP_CID_ASCONF); 5903f96127SXin Long sctp_auth_ep_add_chunkid(ep, SCTP_CID_ASCONF_ACK); 60a29a5bd4SVlad Yasevich } 61a29a5bd4SVlad Yasevich } 62a29a5bd4SVlad Yasevich 631da177e4SLinus Torvalds /* Initialize the base structure. */ 641da177e4SLinus Torvalds /* What type of endpoint are we? */ 651da177e4SLinus Torvalds ep->base.type = SCTP_EP_TYPE_SOCKET; 661da177e4SLinus Torvalds 671da177e4SLinus Torvalds /* Initialize the basic object fields. */ 68c638457aSReshetova, Elena refcount_set(&ep->base.refcnt, 1); 690022d2ddSDaniel Borkmann ep->base.dead = false; 701da177e4SLinus Torvalds 711da177e4SLinus Torvalds /* Create an input queue. */ 721da177e4SLinus Torvalds sctp_inq_init(&ep->base.inqueue); 731da177e4SLinus Torvalds 741da177e4SLinus Torvalds /* Set its top-half handler */ 75c4028958SDavid Howells sctp_inq_set_th_handler(&ep->base.inqueue, sctp_endpoint_bh_rcv); 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds /* Initialize the bind addr area */ 781da177e4SLinus Torvalds sctp_bind_addr_init(&ep->base.bind_addr, 0); 791da177e4SLinus Torvalds 801da177e4SLinus Torvalds /* Create the lists of associations. */ 811da177e4SLinus Torvalds INIT_LIST_HEAD(&ep->asocs); 821da177e4SLinus Torvalds 831da177e4SLinus Torvalds /* Use SCTP specific send buffer space queues. */ 84e1fc3b14SEric W. Biederman ep->sndbuf_policy = net->sctp.sndbuf_policy; 854d93df0aSNeil Horman 86561b1733SWei Yongjun sk->sk_data_ready = sctp_data_ready; 871da177e4SLinus Torvalds sk->sk_write_space = sctp_write_space; 881da177e4SLinus Torvalds sock_set_flag(sk, SOCK_USE_WRITE_QUEUE); 891da177e4SLinus Torvalds 90049b3ff5SNeil Horman /* Get the receive buffer policy for this endpoint */ 91e1fc3b14SEric W. Biederman ep->rcvbuf_policy = net->sctp.rcvbuf_policy; 92049b3ff5SNeil Horman 931da177e4SLinus Torvalds /* Initialize the secret key used with cookie. */ 94570617e7SDaniel Borkmann get_random_bytes(ep->secret_key, sizeof(ep->secret_key)); 951da177e4SLinus Torvalds 96a29a5bd4SVlad Yasevich /* SCTP-AUTH extensions*/ 97a29a5bd4SVlad Yasevich INIT_LIST_HEAD(&ep->endpoint_shared_keys); 9881ce0dbcSDan Carpenter null_key = sctp_auth_shkey_create(0, gfp); 99a29a5bd4SVlad Yasevich if (!null_key) 10060208f79SXin Long goto nomem_shkey; 101a29a5bd4SVlad Yasevich 102a29a5bd4SVlad Yasevich list_add(&null_key->key_list, &ep->endpoint_shared_keys); 103a29a5bd4SVlad Yasevich 104a29a5bd4SVlad Yasevich /* Add the null key to the endpoint shared keys list and 105a29a5bd4SVlad Yasevich * set the hmcas and chunks pointers. 106a29a5bd4SVlad Yasevich */ 10728aa4c26SXin Long ep->prsctp_enable = net->sctp.prsctp_enable; 108c28445c3SXin Long ep->reconf_enable = net->sctp.reconf_enable; 109a29a5bd4SVlad Yasevich 11025bff6d5SXin Long /* Remember who we are attached to. */ 11125bff6d5SXin Long ep->base.sk = sk; 11225bff6d5SXin Long sock_hold(ep->base.sk); 11325bff6d5SXin Long 1141da177e4SLinus Torvalds return ep; 115a29a5bd4SVlad Yasevich 11660208f79SXin Long nomem_shkey: 11703f96127SXin Long sctp_auth_free(ep); 118a29a5bd4SVlad Yasevich nomem: 119a29a5bd4SVlad Yasevich kfree(ep->digest); 120a29a5bd4SVlad Yasevich return NULL; 121a29a5bd4SVlad Yasevich 1221da177e4SLinus Torvalds } 1231da177e4SLinus Torvalds 1241da177e4SLinus Torvalds /* Create a sctp_endpoint with all that boring stuff initialized. 1251da177e4SLinus Torvalds * Returns NULL if there isn't enough memory. 1261da177e4SLinus Torvalds */ 127dd0fc66fSAl Viro struct sctp_endpoint *sctp_endpoint_new(struct sock *sk, gfp_t gfp) 1281da177e4SLinus Torvalds { 1291da177e4SLinus Torvalds struct sctp_endpoint *ep; 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds /* Build a local endpoint. */ 132939cfa75SDaniel Borkmann ep = kzalloc(sizeof(*ep), gfp); 1331da177e4SLinus Torvalds if (!ep) 1341da177e4SLinus Torvalds goto fail; 135939cfa75SDaniel Borkmann 1361da177e4SLinus Torvalds if (!sctp_endpoint_init(ep, sk, gfp)) 1371da177e4SLinus Torvalds goto fail_init; 138ff2266cdSDaniel Borkmann 1391da177e4SLinus Torvalds SCTP_DBG_OBJCNT_INC(ep); 1401da177e4SLinus Torvalds return ep; 1411da177e4SLinus Torvalds 1421da177e4SLinus Torvalds fail_init: 1431da177e4SLinus Torvalds kfree(ep); 1441da177e4SLinus Torvalds fail: 1451da177e4SLinus Torvalds return NULL; 1461da177e4SLinus Torvalds } 1471da177e4SLinus Torvalds 1481da177e4SLinus Torvalds /* Add an association to an endpoint. */ 1491da177e4SLinus Torvalds void sctp_endpoint_add_asoc(struct sctp_endpoint *ep, 1501da177e4SLinus Torvalds struct sctp_association *asoc) 1511da177e4SLinus Torvalds { 1521da177e4SLinus Torvalds struct sock *sk = ep->base.sk; 1531da177e4SLinus Torvalds 154de76e695SVlad Yasevich /* If this is a temporary association, don't bother 155de76e695SVlad Yasevich * since we'll be removing it shortly and don't 156de76e695SVlad Yasevich * want anyone to find it anyway. 157de76e695SVlad Yasevich */ 158de76e695SVlad Yasevich if (asoc->temp) 159de76e695SVlad Yasevich return; 160de76e695SVlad Yasevich 1611da177e4SLinus Torvalds /* Now just add it to our list of asocs */ 1621da177e4SLinus Torvalds list_add_tail(&asoc->asocs, &ep->asocs); 1631da177e4SLinus Torvalds 1641da177e4SLinus Torvalds /* Increment the backlog value for a TCP-style listening socket. */ 1651da177e4SLinus Torvalds if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)) 1661da177e4SLinus Torvalds sk->sk_ack_backlog++; 1671da177e4SLinus Torvalds } 1681da177e4SLinus Torvalds 1691da177e4SLinus Torvalds /* Free the endpoint structure. Delay cleanup until 1701da177e4SLinus Torvalds * all users have released their reference count on this structure. 1711da177e4SLinus Torvalds */ 1721da177e4SLinus Torvalds void sctp_endpoint_free(struct sctp_endpoint *ep) 1731da177e4SLinus Torvalds { 1740022d2ddSDaniel Borkmann ep->base.dead = true; 175cfdeef32SVlad Yasevich 176cbabf463SYafang Shao inet_sk_set_state(ep->base.sk, SCTP_SS_CLOSED); 177cfdeef32SVlad Yasevich 178cfdeef32SVlad Yasevich /* Unlink this endpoint, so we can't find it again! */ 179cfdeef32SVlad Yasevich sctp_unhash_endpoint(ep); 180cfdeef32SVlad Yasevich 1811da177e4SLinus Torvalds sctp_endpoint_put(ep); 1821da177e4SLinus Torvalds } 1831da177e4SLinus Torvalds 1841da177e4SLinus Torvalds /* Final destructor for endpoint. */ 1851da177e4SLinus Torvalds static void sctp_endpoint_destroy(struct sctp_endpoint *ep) 1861da177e4SLinus Torvalds { 1870a2fbac1SDaniel Borkmann struct sock *sk; 1881da177e4SLinus Torvalds 189bb33381dSDaniel Borkmann if (unlikely(!ep->base.dead)) { 190bb33381dSDaniel Borkmann WARN(1, "Attempt to destroy undead endpoint %p!\n", ep); 191bb33381dSDaniel Borkmann return; 192bb33381dSDaniel Borkmann } 1931da177e4SLinus Torvalds 194b68dbcabSVlad Yasevich /* Free the digest buffer */ 195b68dbcabSVlad Yasevich kfree(ep->digest); 196b68dbcabSVlad Yasevich 197a29a5bd4SVlad Yasevich /* SCTP-AUTH: Free up AUTH releated data such as shared keys 198a29a5bd4SVlad Yasevich * chunks and hmacs arrays that were allocated 199a29a5bd4SVlad Yasevich */ 200a29a5bd4SVlad Yasevich sctp_auth_destroy_keys(&ep->endpoint_shared_keys); 20103f96127SXin Long sctp_auth_free(ep); 202a29a5bd4SVlad Yasevich 2031da177e4SLinus Torvalds /* Cleanup. */ 2041da177e4SLinus Torvalds sctp_inq_free(&ep->base.inqueue); 2051da177e4SLinus Torvalds sctp_bind_addr_free(&ep->base.bind_addr); 2061da177e4SLinus Torvalds 207570617e7SDaniel Borkmann memset(ep->secret_key, 0, sizeof(ep->secret_key)); 208b5c37fe6SDaniel Borkmann 2090a2fbac1SDaniel Borkmann sk = ep->base.sk; 2100a2fbac1SDaniel Borkmann /* Remove and free the port */ 2110a2fbac1SDaniel Borkmann if (sctp_sk(sk)->bind_hash) 2120a2fbac1SDaniel Borkmann sctp_put_port(sk); 2130a2fbac1SDaniel Borkmann 21486fdb344SXin Long sctp_sk(sk)->ep = NULL; 2157f304b9eSXin Long /* Give up our hold on the sock */ 2160a2fbac1SDaniel Borkmann sock_put(sk); 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds kfree(ep); 2191da177e4SLinus Torvalds SCTP_DBG_OBJCNT_DEC(ep); 2201da177e4SLinus Torvalds } 2211da177e4SLinus Torvalds 2221da177e4SLinus Torvalds /* Hold a reference to an endpoint. */ 2231da177e4SLinus Torvalds void sctp_endpoint_hold(struct sctp_endpoint *ep) 2241da177e4SLinus Torvalds { 225c638457aSReshetova, Elena refcount_inc(&ep->base.refcnt); 2261da177e4SLinus Torvalds } 2271da177e4SLinus Torvalds 2281da177e4SLinus Torvalds /* Release a reference to an endpoint and clean up if there are 2291da177e4SLinus Torvalds * no more references. 2301da177e4SLinus Torvalds */ 2311da177e4SLinus Torvalds void sctp_endpoint_put(struct sctp_endpoint *ep) 2321da177e4SLinus Torvalds { 233c638457aSReshetova, Elena if (refcount_dec_and_test(&ep->base.refcnt)) 2341da177e4SLinus Torvalds sctp_endpoint_destroy(ep); 2351da177e4SLinus Torvalds } 2361da177e4SLinus Torvalds 2371da177e4SLinus Torvalds /* Is this the endpoint we are looking for? */ 2381da177e4SLinus Torvalds struct sctp_endpoint *sctp_endpoint_is_match(struct sctp_endpoint *ep, 2394cdadcbcSEric W. Biederman struct net *net, 2401da177e4SLinus Torvalds const union sctp_addr *laddr) 2411da177e4SLinus Torvalds { 242559cf710SVlad Yasevich struct sctp_endpoint *retval = NULL; 2431da177e4SLinus Torvalds 2444cdadcbcSEric W. Biederman if ((htons(ep->base.bind_addr.port) == laddr->v4.sin_port) && 2454cdadcbcSEric W. Biederman net_eq(sock_net(ep->base.sk), net)) { 2461da177e4SLinus Torvalds if (sctp_bind_addr_match(&ep->base.bind_addr, laddr, 247559cf710SVlad Yasevich sctp_sk(ep->base.sk))) 2481da177e4SLinus Torvalds retval = ep; 2491da177e4SLinus Torvalds } 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds return retval; 2521da177e4SLinus Torvalds } 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds /* Find the association that goes with this chunk. 2554f008781SXin Long * We lookup the transport from hashtable at first, then get association 2564f008781SXin Long * through t->assoc. 2571da177e4SLinus Torvalds */ 258c79c0666SXin Long struct sctp_association *sctp_endpoint_lookup_assoc( 2591da177e4SLinus Torvalds const struct sctp_endpoint *ep, 2601da177e4SLinus Torvalds const union sctp_addr *paddr, 2611da177e4SLinus Torvalds struct sctp_transport **transport) 2621da177e4SLinus Torvalds { 263123ed979SVlad Yasevich struct sctp_association *asoc = NULL; 2644f008781SXin Long struct sctp_transport *t; 2651da177e4SLinus Torvalds 2661da177e4SLinus Torvalds *transport = NULL; 267deb85a6eSVlad Yasevich 268deb85a6eSVlad Yasevich /* If the local port is not set, there can't be any associations 269deb85a6eSVlad Yasevich * on this endpoint. 270deb85a6eSVlad Yasevich */ 271deb85a6eSVlad Yasevich if (!ep->base.bind_addr.port) 2725cb2cd68SXin Long return NULL; 2735cb2cd68SXin Long 2745cb2cd68SXin Long rcu_read_lock(); 2754f008781SXin Long t = sctp_epaddr_lookup_transport(ep, paddr); 276dd7445adSXin Long if (!t) 2774f008781SXin Long goto out; 278deb85a6eSVlad Yasevich 279123ed979SVlad Yasevich *transport = t; 2804f008781SXin Long asoc = t->asoc; 281deb85a6eSVlad Yasevich out: 2825cb2cd68SXin Long rcu_read_unlock(); 283123ed979SVlad Yasevich 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 */ 28953066538SXin Long bool sctp_endpoint_is_peeled_off(struct sctp_endpoint *ep, 2901da177e4SLinus Torvalds const union sctp_addr *paddr) 2911da177e4SLinus Torvalds { 2921da177e4SLinus Torvalds struct sctp_sockaddr_entry *addr; 2931da177e4SLinus Torvalds struct sctp_bind_addr *bp; 2944110cc25SEric W. Biederman struct net *net = sock_net(ep->base.sk); 2951da177e4SLinus Torvalds 2961da177e4SLinus Torvalds bp = &ep->base.bind_addr; 297559cf710SVlad Yasevich /* This function is called with the socket lock held, 298559cf710SVlad Yasevich * so the address_list can not change. 299559cf710SVlad Yasevich */ 300559cf710SVlad Yasevich list_for_each_entry(addr, &bp->address_list, list) { 3014110cc25SEric W. Biederman if (sctp_has_association(net, &addr->a, paddr)) 30253066538SXin Long return true; 3031da177e4SLinus Torvalds } 3041da177e4SLinus Torvalds 30553066538SXin Long return false; 3061da177e4SLinus Torvalds } 3071da177e4SLinus Torvalds 3081da177e4SLinus Torvalds /* Do delayed input processing. This is scheduled by sctp_rcv(). 3091da177e4SLinus Torvalds * This may be called on BH or task time. 3101da177e4SLinus Torvalds */ 311c4028958SDavid Howells static void sctp_endpoint_bh_rcv(struct work_struct *work) 3121da177e4SLinus Torvalds { 313c4028958SDavid Howells struct sctp_endpoint *ep = 314c4028958SDavid Howells container_of(work, struct sctp_endpoint, 315c4028958SDavid Howells base.inqueue.immediate); 3161da177e4SLinus Torvalds struct sctp_association *asoc; 3171da177e4SLinus Torvalds struct sock *sk; 31855e26eb9SEric W. Biederman struct net *net; 3191da177e4SLinus Torvalds struct sctp_transport *transport; 3201da177e4SLinus Torvalds struct sctp_chunk *chunk; 3211da177e4SLinus Torvalds struct sctp_inq *inqueue; 322bfc6f827SXin Long union sctp_subtype subtype; 32352106019SXin Long enum sctp_state state; 3241da177e4SLinus Torvalds int error = 0; 32542b2aa86SJustin P. Mattock int first_time = 1; /* is this the first time through the loop */ 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; 33355e26eb9SEric W. Biederman net = sock_net(sk); 3341da177e4SLinus Torvalds 3351da177e4SLinus Torvalds while (NULL != (chunk = sctp_inq_pop(inqueue))) { 3361da177e4SLinus Torvalds subtype = SCTP_ST_CHUNK(chunk->chunk_hdr->type); 3371da177e4SLinus Torvalds 338bbd0d598SVlad Yasevich /* If the first chunk in the packet is AUTH, do special 339bbd0d598SVlad Yasevich * processing specified in Section 6.3 of SCTP-AUTH spec 340bbd0d598SVlad Yasevich */ 341bbd0d598SVlad Yasevich if (first_time && (subtype.chunk == SCTP_CID_AUTH)) { 342bbd0d598SVlad Yasevich struct sctp_chunkhdr *next_hdr; 343bbd0d598SVlad Yasevich 344bbd0d598SVlad Yasevich next_hdr = sctp_inq_peek(inqueue); 345bbd0d598SVlad Yasevich if (!next_hdr) 346bbd0d598SVlad Yasevich goto normal; 347bbd0d598SVlad Yasevich 348bbd0d598SVlad Yasevich /* If the next chunk is COOKIE-ECHO, skip the AUTH 349bbd0d598SVlad Yasevich * chunk while saving a pointer to it so we can do 350bbd0d598SVlad Yasevich * Authentication later (during cookie-echo 351bbd0d598SVlad Yasevich * processing). 352bbd0d598SVlad Yasevich */ 353bbd0d598SVlad Yasevich if (next_hdr->type == SCTP_CID_COOKIE_ECHO) { 354bbd0d598SVlad Yasevich chunk->auth_chunk = skb_clone(chunk->skb, 355bbd0d598SVlad Yasevich GFP_ATOMIC); 356bbd0d598SVlad Yasevich chunk->auth = 1; 357bbd0d598SVlad Yasevich continue; 358bbd0d598SVlad Yasevich } 359bbd0d598SVlad Yasevich } 360bbd0d598SVlad Yasevich normal: 3611da177e4SLinus Torvalds /* We might have grown an association since last we 3621da177e4SLinus Torvalds * looked, so try again. 3631da177e4SLinus Torvalds * 3641da177e4SLinus Torvalds * This happens when we've just processed our 3651da177e4SLinus Torvalds * COOKIE-ECHO chunk. 3661da177e4SLinus Torvalds */ 3671da177e4SLinus Torvalds if (NULL == chunk->asoc) { 3681da177e4SLinus Torvalds asoc = sctp_endpoint_lookup_assoc(ep, 3691da177e4SLinus Torvalds sctp_source(chunk), 3701da177e4SLinus Torvalds &transport); 3711da177e4SLinus Torvalds chunk->asoc = asoc; 3721da177e4SLinus Torvalds chunk->transport = transport; 3731da177e4SLinus Torvalds } 3741da177e4SLinus Torvalds 3751da177e4SLinus Torvalds state = asoc ? asoc->state : SCTP_STATE_CLOSED; 376bbd0d598SVlad Yasevich if (sctp_auth_recv_cid(subtype.chunk, asoc) && !chunk->auth) 377bbd0d598SVlad Yasevich continue; 3781da177e4SLinus Torvalds 3791da177e4SLinus Torvalds /* Remember where the last DATA chunk came from so we 3801da177e4SLinus Torvalds * know where to send the SACK. 3811da177e4SLinus Torvalds */ 3821da177e4SLinus Torvalds if (asoc && sctp_chunk_is_data(chunk)) 3831da177e4SLinus Torvalds asoc->peer.last_data_from = chunk->transport; 384196d6759SMichele Baldessari else { 385b01a2407SEric W. Biederman SCTP_INC_STATS(sock_net(ep->base.sk), SCTP_MIB_INCTRLCHUNKS); 386196d6759SMichele Baldessari if (asoc) 387196d6759SMichele Baldessari asoc->stats.ictrlchunks++; 388196d6759SMichele Baldessari } 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds if (chunk->transport) 391e575235fSDaniel Borkmann chunk->transport->last_time_heard = ktime_get(); 3921da177e4SLinus Torvalds 39355e26eb9SEric W. Biederman error = sctp_do_sm(net, SCTP_EVENT_T_CHUNK, subtype, state, 3941da177e4SLinus Torvalds ep, asoc, chunk, GFP_ATOMIC); 3951da177e4SLinus Torvalds 3961da177e4SLinus Torvalds if (error && chunk) 3971da177e4SLinus Torvalds chunk->pdiscard = 1; 3981da177e4SLinus Torvalds 3991da177e4SLinus Torvalds /* Check to see if the endpoint is freed in response to 4001da177e4SLinus Torvalds * the incoming chunk. If so, get out of the while loop. 4011da177e4SLinus Torvalds */ 4021da177e4SLinus Torvalds if (!sctp_sk(sk)->ep) 4031da177e4SLinus Torvalds break; 404bbd0d598SVlad Yasevich 405bbd0d598SVlad Yasevich if (first_time) 406bbd0d598SVlad Yasevich first_time = 0; 4071da177e4SLinus Torvalds } 4081da177e4SLinus Torvalds } 409