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; 1091b0b8114SXin Long ep->ecn_enable = net->sctp.ecn_enable; 110a29a5bd4SVlad Yasevich 11125bff6d5SXin Long /* Remember who we are attached to. */ 11225bff6d5SXin Long ep->base.sk = sk; 11331243461SXin Long ep->base.net = sock_net(sk); 11425bff6d5SXin Long sock_hold(ep->base.sk); 11525bff6d5SXin Long 1161da177e4SLinus Torvalds return ep; 117a29a5bd4SVlad Yasevich 11860208f79SXin Long nomem_shkey: 11903f96127SXin Long sctp_auth_free(ep); 120a29a5bd4SVlad Yasevich nomem: 121a29a5bd4SVlad Yasevich kfree(ep->digest); 122a29a5bd4SVlad Yasevich return NULL; 123a29a5bd4SVlad Yasevich 1241da177e4SLinus Torvalds } 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds /* Create a sctp_endpoint with all that boring stuff initialized. 1271da177e4SLinus Torvalds * Returns NULL if there isn't enough memory. 1281da177e4SLinus Torvalds */ 129dd0fc66fSAl Viro struct sctp_endpoint *sctp_endpoint_new(struct sock *sk, gfp_t gfp) 1301da177e4SLinus Torvalds { 1311da177e4SLinus Torvalds struct sctp_endpoint *ep; 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds /* Build a local endpoint. */ 134939cfa75SDaniel Borkmann ep = kzalloc(sizeof(*ep), gfp); 1351da177e4SLinus Torvalds if (!ep) 1361da177e4SLinus Torvalds goto fail; 137939cfa75SDaniel Borkmann 1381da177e4SLinus Torvalds if (!sctp_endpoint_init(ep, sk, gfp)) 1391da177e4SLinus Torvalds goto fail_init; 140ff2266cdSDaniel Borkmann 1411da177e4SLinus Torvalds SCTP_DBG_OBJCNT_INC(ep); 1421da177e4SLinus Torvalds return ep; 1431da177e4SLinus Torvalds 1441da177e4SLinus Torvalds fail_init: 1451da177e4SLinus Torvalds kfree(ep); 1461da177e4SLinus Torvalds fail: 1471da177e4SLinus Torvalds return NULL; 1481da177e4SLinus Torvalds } 1491da177e4SLinus Torvalds 1501da177e4SLinus Torvalds /* Add an association to an endpoint. */ 1511da177e4SLinus Torvalds void sctp_endpoint_add_asoc(struct sctp_endpoint *ep, 1521da177e4SLinus Torvalds struct sctp_association *asoc) 1531da177e4SLinus Torvalds { 1541da177e4SLinus Torvalds struct sock *sk = ep->base.sk; 1551da177e4SLinus Torvalds 156de76e695SVlad Yasevich /* If this is a temporary association, don't bother 157de76e695SVlad Yasevich * since we'll be removing it shortly and don't 158de76e695SVlad Yasevich * want anyone to find it anyway. 159de76e695SVlad Yasevich */ 160de76e695SVlad Yasevich if (asoc->temp) 161de76e695SVlad Yasevich return; 162de76e695SVlad Yasevich 1631da177e4SLinus Torvalds /* Now just add it to our list of asocs */ 1641da177e4SLinus Torvalds list_add_tail(&asoc->asocs, &ep->asocs); 1651da177e4SLinus Torvalds 1661da177e4SLinus Torvalds /* Increment the backlog value for a TCP-style listening socket. */ 1671da177e4SLinus Torvalds if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)) 1687976a11bSEric Dumazet sk_acceptq_added(sk); 1691da177e4SLinus Torvalds } 1701da177e4SLinus Torvalds 1711da177e4SLinus Torvalds /* Free the endpoint structure. Delay cleanup until 1721da177e4SLinus Torvalds * all users have released their reference count on this structure. 1731da177e4SLinus Torvalds */ 1741da177e4SLinus Torvalds void sctp_endpoint_free(struct sctp_endpoint *ep) 1751da177e4SLinus Torvalds { 1760022d2ddSDaniel Borkmann ep->base.dead = true; 177cfdeef32SVlad Yasevich 178cbabf463SYafang Shao inet_sk_set_state(ep->base.sk, SCTP_SS_CLOSED); 179cfdeef32SVlad Yasevich 180cfdeef32SVlad Yasevich /* Unlink this endpoint, so we can't find it again! */ 181cfdeef32SVlad Yasevich sctp_unhash_endpoint(ep); 182cfdeef32SVlad Yasevich 1831da177e4SLinus Torvalds sctp_endpoint_put(ep); 1841da177e4SLinus Torvalds } 1851da177e4SLinus Torvalds 1861da177e4SLinus Torvalds /* Final destructor for endpoint. */ 1871da177e4SLinus Torvalds static void sctp_endpoint_destroy(struct sctp_endpoint *ep) 1881da177e4SLinus Torvalds { 1890a2fbac1SDaniel Borkmann struct sock *sk; 1901da177e4SLinus Torvalds 191bb33381dSDaniel Borkmann if (unlikely(!ep->base.dead)) { 192bb33381dSDaniel Borkmann WARN(1, "Attempt to destroy undead endpoint %p!\n", ep); 193bb33381dSDaniel Borkmann return; 194bb33381dSDaniel Borkmann } 1951da177e4SLinus Torvalds 196b68dbcabSVlad Yasevich /* Free the digest buffer */ 197b68dbcabSVlad Yasevich kfree(ep->digest); 198b68dbcabSVlad Yasevich 199a29a5bd4SVlad Yasevich /* SCTP-AUTH: Free up AUTH releated data such as shared keys 200a29a5bd4SVlad Yasevich * chunks and hmacs arrays that were allocated 201a29a5bd4SVlad Yasevich */ 202a29a5bd4SVlad Yasevich sctp_auth_destroy_keys(&ep->endpoint_shared_keys); 20303f96127SXin Long sctp_auth_free(ep); 204a29a5bd4SVlad Yasevich 2051da177e4SLinus Torvalds /* Cleanup. */ 2061da177e4SLinus Torvalds sctp_inq_free(&ep->base.inqueue); 2071da177e4SLinus Torvalds sctp_bind_addr_free(&ep->base.bind_addr); 2081da177e4SLinus Torvalds 209570617e7SDaniel Borkmann memset(ep->secret_key, 0, sizeof(ep->secret_key)); 210b5c37fe6SDaniel Borkmann 2110a2fbac1SDaniel Borkmann sk = ep->base.sk; 2120a2fbac1SDaniel Borkmann /* Remove and free the port */ 2130a2fbac1SDaniel Borkmann if (sctp_sk(sk)->bind_hash) 2140a2fbac1SDaniel Borkmann sctp_put_port(sk); 2150a2fbac1SDaniel Borkmann 21686fdb344SXin Long sctp_sk(sk)->ep = NULL; 2177f304b9eSXin Long /* Give up our hold on the sock */ 2180a2fbac1SDaniel Borkmann sock_put(sk); 2191da177e4SLinus Torvalds 2201da177e4SLinus Torvalds kfree(ep); 2211da177e4SLinus Torvalds SCTP_DBG_OBJCNT_DEC(ep); 2221da177e4SLinus Torvalds } 2231da177e4SLinus Torvalds 2241da177e4SLinus Torvalds /* Hold a reference to an endpoint. */ 2251da177e4SLinus Torvalds void sctp_endpoint_hold(struct sctp_endpoint *ep) 2261da177e4SLinus Torvalds { 227c638457aSReshetova, Elena refcount_inc(&ep->base.refcnt); 2281da177e4SLinus Torvalds } 2291da177e4SLinus Torvalds 2301da177e4SLinus Torvalds /* Release a reference to an endpoint and clean up if there are 2311da177e4SLinus Torvalds * no more references. 2321da177e4SLinus Torvalds */ 2331da177e4SLinus Torvalds void sctp_endpoint_put(struct sctp_endpoint *ep) 2341da177e4SLinus Torvalds { 235c638457aSReshetova, Elena if (refcount_dec_and_test(&ep->base.refcnt)) 2361da177e4SLinus Torvalds sctp_endpoint_destroy(ep); 2371da177e4SLinus Torvalds } 2381da177e4SLinus Torvalds 2391da177e4SLinus Torvalds /* Is this the endpoint we are looking for? */ 2401da177e4SLinus Torvalds struct sctp_endpoint *sctp_endpoint_is_match(struct sctp_endpoint *ep, 2414cdadcbcSEric W. Biederman struct net *net, 2421da177e4SLinus Torvalds const union sctp_addr *laddr) 2431da177e4SLinus Torvalds { 244559cf710SVlad Yasevich struct sctp_endpoint *retval = NULL; 2451da177e4SLinus Torvalds 2464cdadcbcSEric W. Biederman if ((htons(ep->base.bind_addr.port) == laddr->v4.sin_port) && 2474e7696d9SXin Long net_eq(ep->base.net, net)) { 2481da177e4SLinus Torvalds if (sctp_bind_addr_match(&ep->base.bind_addr, laddr, 249559cf710SVlad Yasevich sctp_sk(ep->base.sk))) 2501da177e4SLinus Torvalds retval = ep; 2511da177e4SLinus Torvalds } 2521da177e4SLinus Torvalds 2531da177e4SLinus Torvalds return retval; 2541da177e4SLinus Torvalds } 2551da177e4SLinus Torvalds 2561da177e4SLinus Torvalds /* Find the association that goes with this chunk. 2574f008781SXin Long * We lookup the transport from hashtable at first, then get association 2584f008781SXin Long * through t->assoc. 2591da177e4SLinus Torvalds */ 260c79c0666SXin Long struct sctp_association *sctp_endpoint_lookup_assoc( 2611da177e4SLinus Torvalds const struct sctp_endpoint *ep, 2621da177e4SLinus Torvalds const union sctp_addr *paddr, 2631da177e4SLinus Torvalds struct sctp_transport **transport) 2641da177e4SLinus Torvalds { 265123ed979SVlad Yasevich struct sctp_association *asoc = NULL; 2664f008781SXin Long struct sctp_transport *t; 2671da177e4SLinus Torvalds 2681da177e4SLinus Torvalds *transport = NULL; 269deb85a6eSVlad Yasevich 270deb85a6eSVlad Yasevich /* If the local port is not set, there can't be any associations 271deb85a6eSVlad Yasevich * on this endpoint. 272deb85a6eSVlad Yasevich */ 273deb85a6eSVlad Yasevich if (!ep->base.bind_addr.port) 2745cb2cd68SXin Long return NULL; 2755cb2cd68SXin Long 2765cb2cd68SXin Long rcu_read_lock(); 2774f008781SXin Long t = sctp_epaddr_lookup_transport(ep, paddr); 278dd7445adSXin Long if (!t) 2794f008781SXin Long goto out; 280deb85a6eSVlad Yasevich 281123ed979SVlad Yasevich *transport = t; 2824f008781SXin Long asoc = t->asoc; 283deb85a6eSVlad Yasevich out: 2845cb2cd68SXin Long rcu_read_unlock(); 285123ed979SVlad Yasevich return asoc; 2861da177e4SLinus Torvalds } 2871da177e4SLinus Torvalds 2881da177e4SLinus Torvalds /* Look for any peeled off association from the endpoint that matches the 2891da177e4SLinus Torvalds * given peer address. 2901da177e4SLinus Torvalds */ 29153066538SXin Long bool sctp_endpoint_is_peeled_off(struct sctp_endpoint *ep, 2921da177e4SLinus Torvalds const union sctp_addr *paddr) 2931da177e4SLinus Torvalds { 2941da177e4SLinus Torvalds struct sctp_sockaddr_entry *addr; 2954e7696d9SXin Long struct net *net = ep->base.net; 2961da177e4SLinus Torvalds struct sctp_bind_addr *bp; 2971da177e4SLinus Torvalds 2981da177e4SLinus Torvalds bp = &ep->base.bind_addr; 299559cf710SVlad Yasevich /* This function is called with the socket lock held, 300559cf710SVlad Yasevich * so the address_list can not change. 301559cf710SVlad Yasevich */ 302559cf710SVlad Yasevich list_for_each_entry(addr, &bp->address_list, list) { 3034110cc25SEric W. Biederman if (sctp_has_association(net, &addr->a, paddr)) 30453066538SXin Long return true; 3051da177e4SLinus Torvalds } 3061da177e4SLinus Torvalds 30753066538SXin Long return false; 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; 32055e26eb9SEric W. Biederman struct net *net; 3211da177e4SLinus Torvalds struct sctp_transport *transport; 3221da177e4SLinus Torvalds struct sctp_chunk *chunk; 3231da177e4SLinus Torvalds struct sctp_inq *inqueue; 324bfc6f827SXin Long union sctp_subtype subtype; 32552106019SXin Long enum sctp_state state; 3261da177e4SLinus Torvalds int error = 0; 32742b2aa86SJustin P. Mattock int first_time = 1; /* is this the first time through the loop */ 3281da177e4SLinus Torvalds 3291da177e4SLinus Torvalds if (ep->base.dead) 3301da177e4SLinus Torvalds return; 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds asoc = NULL; 3331da177e4SLinus Torvalds inqueue = &ep->base.inqueue; 3341da177e4SLinus Torvalds sk = ep->base.sk; 33555e26eb9SEric W. Biederman net = sock_net(sk); 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds while (NULL != (chunk = sctp_inq_pop(inqueue))) { 3381da177e4SLinus Torvalds subtype = SCTP_ST_CHUNK(chunk->chunk_hdr->type); 3391da177e4SLinus Torvalds 340bbd0d598SVlad Yasevich /* If the first chunk in the packet is AUTH, do special 341bbd0d598SVlad Yasevich * processing specified in Section 6.3 of SCTP-AUTH spec 342bbd0d598SVlad Yasevich */ 343bbd0d598SVlad Yasevich if (first_time && (subtype.chunk == SCTP_CID_AUTH)) { 344bbd0d598SVlad Yasevich struct sctp_chunkhdr *next_hdr; 345bbd0d598SVlad Yasevich 346bbd0d598SVlad Yasevich next_hdr = sctp_inq_peek(inqueue); 347bbd0d598SVlad Yasevich if (!next_hdr) 348bbd0d598SVlad Yasevich goto normal; 349bbd0d598SVlad Yasevich 350bbd0d598SVlad Yasevich /* If the next chunk is COOKIE-ECHO, skip the AUTH 351bbd0d598SVlad Yasevich * chunk while saving a pointer to it so we can do 352bbd0d598SVlad Yasevich * Authentication later (during cookie-echo 353bbd0d598SVlad Yasevich * processing). 354bbd0d598SVlad Yasevich */ 355bbd0d598SVlad Yasevich if (next_hdr->type == SCTP_CID_COOKIE_ECHO) { 356bbd0d598SVlad Yasevich chunk->auth_chunk = skb_clone(chunk->skb, 357bbd0d598SVlad Yasevich GFP_ATOMIC); 358bbd0d598SVlad Yasevich chunk->auth = 1; 359bbd0d598SVlad Yasevich continue; 360bbd0d598SVlad Yasevich } 361bbd0d598SVlad Yasevich } 362bbd0d598SVlad Yasevich normal: 3631da177e4SLinus Torvalds /* We might have grown an association since last we 3641da177e4SLinus Torvalds * looked, so try again. 3651da177e4SLinus Torvalds * 3661da177e4SLinus Torvalds * This happens when we've just processed our 3671da177e4SLinus Torvalds * COOKIE-ECHO chunk. 3681da177e4SLinus Torvalds */ 3691da177e4SLinus Torvalds if (NULL == chunk->asoc) { 3701da177e4SLinus Torvalds asoc = sctp_endpoint_lookup_assoc(ep, 3711da177e4SLinus Torvalds sctp_source(chunk), 3721da177e4SLinus Torvalds &transport); 3731da177e4SLinus Torvalds chunk->asoc = asoc; 3741da177e4SLinus Torvalds chunk->transport = transport; 3751da177e4SLinus Torvalds } 3761da177e4SLinus Torvalds 3771da177e4SLinus Torvalds state = asoc ? asoc->state : SCTP_STATE_CLOSED; 378bbd0d598SVlad Yasevich if (sctp_auth_recv_cid(subtype.chunk, asoc) && !chunk->auth) 379bbd0d598SVlad Yasevich continue; 3801da177e4SLinus Torvalds 3811da177e4SLinus Torvalds /* Remember where the last DATA chunk came from so we 3821da177e4SLinus Torvalds * know where to send the SACK. 3831da177e4SLinus Torvalds */ 3841da177e4SLinus Torvalds if (asoc && sctp_chunk_is_data(chunk)) 3851da177e4SLinus Torvalds asoc->peer.last_data_from = chunk->transport; 386196d6759SMichele Baldessari else { 3874e7696d9SXin Long SCTP_INC_STATS(ep->base.net, SCTP_MIB_INCTRLCHUNKS); 388196d6759SMichele Baldessari if (asoc) 389196d6759SMichele Baldessari asoc->stats.ictrlchunks++; 390196d6759SMichele Baldessari } 3911da177e4SLinus Torvalds 3921da177e4SLinus Torvalds if (chunk->transport) 393e575235fSDaniel Borkmann chunk->transport->last_time_heard = ktime_get(); 3941da177e4SLinus Torvalds 39555e26eb9SEric W. Biederman error = sctp_do_sm(net, SCTP_EVENT_T_CHUNK, subtype, state, 3961da177e4SLinus Torvalds ep, asoc, chunk, GFP_ATOMIC); 3971da177e4SLinus Torvalds 3981da177e4SLinus Torvalds if (error && chunk) 3991da177e4SLinus Torvalds chunk->pdiscard = 1; 4001da177e4SLinus Torvalds 4011da177e4SLinus Torvalds /* Check to see if the endpoint is freed in response to 4021da177e4SLinus Torvalds * the incoming chunk. If so, get out of the while loop. 4031da177e4SLinus Torvalds */ 4041da177e4SLinus Torvalds if (!sctp_sk(sk)->ep) 4051da177e4SLinus Torvalds break; 406bbd0d598SVlad Yasevich 407bbd0d598SVlad Yasevich if (first_time) 408bbd0d598SVlad Yasevich first_time = 0; 4091da177e4SLinus Torvalds } 4101da177e4SLinus Torvalds } 411