Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /* SCTP kernel implementation
0003  * (C) Copyright IBM Corp. 2001, 2004
0004  * Copyright (c) 1999 Cisco, Inc.
0005  * Copyright (c) 1999-2001 Motorola, Inc.
0006  *
0007  * This file is part of the SCTP kernel implementation
0008  *
0009  * These functions work with the state functions in sctp_sm_statefuns.c
0010  * to implement that state operations.  These functions implement the
0011  * steps which require modifying existing data structures.
0012  *
0013  * Please send any bug reports or fixes you make to the
0014  * email address(es):
0015  *    lksctp developers <linux-sctp@vger.kernel.org>
0016  *
0017  * Written or modified by:
0018  *    La Monte H.P. Yarroll <piggy@acm.org>
0019  *    Karl Knutson          <karl@athena.chicago.il.us>
0020  *    Jon Grimm             <jgrimm@austin.ibm.com>
0021  *    Hui Huang         <hui.huang@nokia.com>
0022  *    Dajiang Zhang     <dajiang.zhang@nokia.com>
0023  *    Daisy Chang       <daisyc@us.ibm.com>
0024  *    Sridhar Samudrala     <sri@us.ibm.com>
0025  *    Ardelle Fan       <ardelle.fan@intel.com>
0026  */
0027 
0028 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0029 
0030 #include <linux/skbuff.h>
0031 #include <linux/types.h>
0032 #include <linux/socket.h>
0033 #include <linux/ip.h>
0034 #include <linux/gfp.h>
0035 #include <net/sock.h>
0036 #include <net/sctp/sctp.h>
0037 #include <net/sctp/sm.h>
0038 #include <net/sctp/stream_sched.h>
0039 
0040 static int sctp_cmd_interpreter(enum sctp_event_type event_type,
0041                 union sctp_subtype subtype,
0042                 enum sctp_state state,
0043                 struct sctp_endpoint *ep,
0044                 struct sctp_association *asoc,
0045                 void *event_arg,
0046                 enum sctp_disposition status,
0047                 struct sctp_cmd_seq *commands,
0048                 gfp_t gfp);
0049 static int sctp_side_effects(enum sctp_event_type event_type,
0050                  union sctp_subtype subtype,
0051                  enum sctp_state state,
0052                  struct sctp_endpoint *ep,
0053                  struct sctp_association **asoc,
0054                  void *event_arg,
0055                  enum sctp_disposition status,
0056                  struct sctp_cmd_seq *commands,
0057                  gfp_t gfp);
0058 
0059 /********************************************************************
0060  * Helper functions
0061  ********************************************************************/
0062 
0063 /* A helper function for delayed processing of INET ECN CE bit. */
0064 static void sctp_do_ecn_ce_work(struct sctp_association *asoc,
0065                 __u32 lowest_tsn)
0066 {
0067     /* Save the TSN away for comparison when we receive CWR */
0068 
0069     asoc->last_ecne_tsn = lowest_tsn;
0070     asoc->need_ecne = 1;
0071 }
0072 
0073 /* Helper function for delayed processing of SCTP ECNE chunk.  */
0074 /* RFC 2960 Appendix A
0075  *
0076  * RFC 2481 details a specific bit for a sender to send in
0077  * the header of its next outbound TCP segment to indicate to
0078  * its peer that it has reduced its congestion window.  This
0079  * is termed the CWR bit.  For SCTP the same indication is made
0080  * by including the CWR chunk.  This chunk contains one data
0081  * element, i.e. the TSN number that was sent in the ECNE chunk.
0082  * This element represents the lowest TSN number in the datagram
0083  * that was originally marked with the CE bit.
0084  */
0085 static struct sctp_chunk *sctp_do_ecn_ecne_work(struct sctp_association *asoc,
0086                         __u32 lowest_tsn,
0087                         struct sctp_chunk *chunk)
0088 {
0089     struct sctp_chunk *repl;
0090 
0091     /* Our previously transmitted packet ran into some congestion
0092      * so we should take action by reducing cwnd and ssthresh
0093      * and then ACK our peer that we we've done so by
0094      * sending a CWR.
0095      */
0096 
0097     /* First, try to determine if we want to actually lower
0098      * our cwnd variables.  Only lower them if the ECNE looks more
0099      * recent than the last response.
0100      */
0101     if (TSN_lt(asoc->last_cwr_tsn, lowest_tsn)) {
0102         struct sctp_transport *transport;
0103 
0104         /* Find which transport's congestion variables
0105          * need to be adjusted.
0106          */
0107         transport = sctp_assoc_lookup_tsn(asoc, lowest_tsn);
0108 
0109         /* Update the congestion variables. */
0110         if (transport)
0111             sctp_transport_lower_cwnd(transport,
0112                           SCTP_LOWER_CWND_ECNE);
0113         asoc->last_cwr_tsn = lowest_tsn;
0114     }
0115 
0116     /* Always try to quiet the other end.  In case of lost CWR,
0117      * resend last_cwr_tsn.
0118      */
0119     repl = sctp_make_cwr(asoc, asoc->last_cwr_tsn, chunk);
0120 
0121     /* If we run out of memory, it will look like a lost CWR.  We'll
0122      * get back in sync eventually.
0123      */
0124     return repl;
0125 }
0126 
0127 /* Helper function to do delayed processing of ECN CWR chunk.  */
0128 static void sctp_do_ecn_cwr_work(struct sctp_association *asoc,
0129                  __u32 lowest_tsn)
0130 {
0131     /* Turn off ECNE getting auto-prepended to every outgoing
0132      * packet
0133      */
0134     asoc->need_ecne = 0;
0135 }
0136 
0137 /* Generate SACK if necessary.  We call this at the end of a packet.  */
0138 static int sctp_gen_sack(struct sctp_association *asoc, int force,
0139              struct sctp_cmd_seq *commands)
0140 {
0141     struct sctp_transport *trans = asoc->peer.last_data_from;
0142     __u32 ctsn, max_tsn_seen;
0143     struct sctp_chunk *sack;
0144     int error = 0;
0145 
0146     if (force ||
0147         (!trans && (asoc->param_flags & SPP_SACKDELAY_DISABLE)) ||
0148         (trans && (trans->param_flags & SPP_SACKDELAY_DISABLE)))
0149         asoc->peer.sack_needed = 1;
0150 
0151     ctsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map);
0152     max_tsn_seen = sctp_tsnmap_get_max_tsn_seen(&asoc->peer.tsn_map);
0153 
0154     /* From 12.2 Parameters necessary per association (i.e. the TCB):
0155      *
0156      * Ack State : This flag indicates if the next received packet
0157      *       : is to be responded to with a SACK. ...
0158      *       : When DATA chunks are out of order, SACK's
0159      *           : are not delayed (see Section 6).
0160      *
0161      * [This is actually not mentioned in Section 6, but we
0162      * implement it here anyway. --piggy]
0163      */
0164     if (max_tsn_seen != ctsn)
0165         asoc->peer.sack_needed = 1;
0166 
0167     /* From 6.2  Acknowledgement on Reception of DATA Chunks:
0168      *
0169      * Section 4.2 of [RFC2581] SHOULD be followed. Specifically,
0170      * an acknowledgement SHOULD be generated for at least every
0171      * second packet (not every second DATA chunk) received, and
0172      * SHOULD be generated within 200 ms of the arrival of any
0173      * unacknowledged DATA chunk. ...
0174      */
0175     if (!asoc->peer.sack_needed) {
0176         asoc->peer.sack_cnt++;
0177 
0178         /* Set the SACK delay timeout based on the
0179          * SACK delay for the last transport
0180          * data was received from, or the default
0181          * for the association.
0182          */
0183         if (trans) {
0184             /* We will need a SACK for the next packet.  */
0185             if (asoc->peer.sack_cnt >= trans->sackfreq - 1)
0186                 asoc->peer.sack_needed = 1;
0187 
0188             asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] =
0189                 trans->sackdelay;
0190         } else {
0191             /* We will need a SACK for the next packet.  */
0192             if (asoc->peer.sack_cnt >= asoc->sackfreq - 1)
0193                 asoc->peer.sack_needed = 1;
0194 
0195             asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] =
0196                 asoc->sackdelay;
0197         }
0198 
0199         /* Restart the SACK timer. */
0200         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
0201                 SCTP_TO(SCTP_EVENT_TIMEOUT_SACK));
0202     } else {
0203         __u32 old_a_rwnd = asoc->a_rwnd;
0204 
0205         asoc->a_rwnd = asoc->rwnd;
0206         sack = sctp_make_sack(asoc);
0207         if (!sack) {
0208             asoc->a_rwnd = old_a_rwnd;
0209             goto nomem;
0210         }
0211 
0212         asoc->peer.sack_needed = 0;
0213         asoc->peer.sack_cnt = 0;
0214 
0215         sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(sack));
0216 
0217         /* Stop the SACK timer.  */
0218         sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
0219                 SCTP_TO(SCTP_EVENT_TIMEOUT_SACK));
0220     }
0221 
0222     return error;
0223 nomem:
0224     error = -ENOMEM;
0225     return error;
0226 }
0227 
0228 /* When the T3-RTX timer expires, it calls this function to create the
0229  * relevant state machine event.
0230  */
0231 void sctp_generate_t3_rtx_event(struct timer_list *t)
0232 {
0233     struct sctp_transport *transport =
0234         from_timer(transport, t, T3_rtx_timer);
0235     struct sctp_association *asoc = transport->asoc;
0236     struct sock *sk = asoc->base.sk;
0237     struct net *net = sock_net(sk);
0238     int error;
0239 
0240     /* Check whether a task is in the sock.  */
0241 
0242     bh_lock_sock(sk);
0243     if (sock_owned_by_user(sk)) {
0244         pr_debug("%s: sock is busy\n", __func__);
0245 
0246         /* Try again later.  */
0247         if (!mod_timer(&transport->T3_rtx_timer, jiffies + (HZ/20)))
0248             sctp_transport_hold(transport);
0249         goto out_unlock;
0250     }
0251 
0252     /* Run through the state machine.  */
0253     error = sctp_do_sm(net, SCTP_EVENT_T_TIMEOUT,
0254                SCTP_ST_TIMEOUT(SCTP_EVENT_TIMEOUT_T3_RTX),
0255                asoc->state,
0256                asoc->ep, asoc,
0257                transport, GFP_ATOMIC);
0258 
0259     if (error)
0260         sk->sk_err = -error;
0261 
0262 out_unlock:
0263     bh_unlock_sock(sk);
0264     sctp_transport_put(transport);
0265 }
0266 
0267 /* This is a sa interface for producing timeout events.  It works
0268  * for timeouts which use the association as their parameter.
0269  */
0270 static void sctp_generate_timeout_event(struct sctp_association *asoc,
0271                     enum sctp_event_timeout timeout_type)
0272 {
0273     struct sock *sk = asoc->base.sk;
0274     struct net *net = sock_net(sk);
0275     int error = 0;
0276 
0277     bh_lock_sock(sk);
0278     if (sock_owned_by_user(sk)) {
0279         pr_debug("%s: sock is busy: timer %d\n", __func__,
0280              timeout_type);
0281 
0282         /* Try again later.  */
0283         if (!mod_timer(&asoc->timers[timeout_type], jiffies + (HZ/20)))
0284             sctp_association_hold(asoc);
0285         goto out_unlock;
0286     }
0287 
0288     /* Is this association really dead and just waiting around for
0289      * the timer to let go of the reference?
0290      */
0291     if (asoc->base.dead)
0292         goto out_unlock;
0293 
0294     /* Run through the state machine.  */
0295     error = sctp_do_sm(net, SCTP_EVENT_T_TIMEOUT,
0296                SCTP_ST_TIMEOUT(timeout_type),
0297                asoc->state, asoc->ep, asoc,
0298                (void *)timeout_type, GFP_ATOMIC);
0299 
0300     if (error)
0301         sk->sk_err = -error;
0302 
0303 out_unlock:
0304     bh_unlock_sock(sk);
0305     sctp_association_put(asoc);
0306 }
0307 
0308 static void sctp_generate_t1_cookie_event(struct timer_list *t)
0309 {
0310     struct sctp_association *asoc =
0311         from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_T1_COOKIE]);
0312 
0313     sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T1_COOKIE);
0314 }
0315 
0316 static void sctp_generate_t1_init_event(struct timer_list *t)
0317 {
0318     struct sctp_association *asoc =
0319         from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_T1_INIT]);
0320 
0321     sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T1_INIT);
0322 }
0323 
0324 static void sctp_generate_t2_shutdown_event(struct timer_list *t)
0325 {
0326     struct sctp_association *asoc =
0327         from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN]);
0328 
0329     sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T2_SHUTDOWN);
0330 }
0331 
0332 static void sctp_generate_t4_rto_event(struct timer_list *t)
0333 {
0334     struct sctp_association *asoc =
0335         from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_T4_RTO]);
0336 
0337     sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_T4_RTO);
0338 }
0339 
0340 static void sctp_generate_t5_shutdown_guard_event(struct timer_list *t)
0341 {
0342     struct sctp_association *asoc =
0343         from_timer(asoc, t,
0344                timers[SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]);
0345 
0346     sctp_generate_timeout_event(asoc,
0347                     SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD);
0348 
0349 } /* sctp_generate_t5_shutdown_guard_event() */
0350 
0351 static void sctp_generate_autoclose_event(struct timer_list *t)
0352 {
0353     struct sctp_association *asoc =
0354         from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_AUTOCLOSE]);
0355 
0356     sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_AUTOCLOSE);
0357 }
0358 
0359 /* Generate a heart beat event.  If the sock is busy, reschedule.   Make
0360  * sure that the transport is still valid.
0361  */
0362 void sctp_generate_heartbeat_event(struct timer_list *t)
0363 {
0364     struct sctp_transport *transport = from_timer(transport, t, hb_timer);
0365     struct sctp_association *asoc = transport->asoc;
0366     struct sock *sk = asoc->base.sk;
0367     struct net *net = sock_net(sk);
0368     u32 elapsed, timeout;
0369     int error = 0;
0370 
0371     bh_lock_sock(sk);
0372     if (sock_owned_by_user(sk)) {
0373         pr_debug("%s: sock is busy\n", __func__);
0374 
0375         /* Try again later.  */
0376         if (!mod_timer(&transport->hb_timer, jiffies + (HZ/20)))
0377             sctp_transport_hold(transport);
0378         goto out_unlock;
0379     }
0380 
0381     /* Check if we should still send the heartbeat or reschedule */
0382     elapsed = jiffies - transport->last_time_sent;
0383     timeout = sctp_transport_timeout(transport);
0384     if (elapsed < timeout) {
0385         elapsed = timeout - elapsed;
0386         if (!mod_timer(&transport->hb_timer, jiffies + elapsed))
0387             sctp_transport_hold(transport);
0388         goto out_unlock;
0389     }
0390 
0391     error = sctp_do_sm(net, SCTP_EVENT_T_TIMEOUT,
0392                SCTP_ST_TIMEOUT(SCTP_EVENT_TIMEOUT_HEARTBEAT),
0393                asoc->state, asoc->ep, asoc,
0394                transport, GFP_ATOMIC);
0395 
0396     if (error)
0397         sk->sk_err = -error;
0398 
0399 out_unlock:
0400     bh_unlock_sock(sk);
0401     sctp_transport_put(transport);
0402 }
0403 
0404 /* Handle the timeout of the ICMP protocol unreachable timer.  Trigger
0405  * the correct state machine transition that will close the association.
0406  */
0407 void sctp_generate_proto_unreach_event(struct timer_list *t)
0408 {
0409     struct sctp_transport *transport =
0410         from_timer(transport, t, proto_unreach_timer);
0411     struct sctp_association *asoc = transport->asoc;
0412     struct sock *sk = asoc->base.sk;
0413     struct net *net = sock_net(sk);
0414 
0415     bh_lock_sock(sk);
0416     if (sock_owned_by_user(sk)) {
0417         pr_debug("%s: sock is busy\n", __func__);
0418 
0419         /* Try again later.  */
0420         if (!mod_timer(&transport->proto_unreach_timer,
0421                 jiffies + (HZ/20)))
0422             sctp_transport_hold(transport);
0423         goto out_unlock;
0424     }
0425 
0426     /* Is this structure just waiting around for us to actually
0427      * get destroyed?
0428      */
0429     if (asoc->base.dead)
0430         goto out_unlock;
0431 
0432     sctp_do_sm(net, SCTP_EVENT_T_OTHER,
0433            SCTP_ST_OTHER(SCTP_EVENT_ICMP_PROTO_UNREACH),
0434            asoc->state, asoc->ep, asoc, transport, GFP_ATOMIC);
0435 
0436 out_unlock:
0437     bh_unlock_sock(sk);
0438     sctp_transport_put(transport);
0439 }
0440 
0441  /* Handle the timeout of the RE-CONFIG timer. */
0442 void sctp_generate_reconf_event(struct timer_list *t)
0443 {
0444     struct sctp_transport *transport =
0445         from_timer(transport, t, reconf_timer);
0446     struct sctp_association *asoc = transport->asoc;
0447     struct sock *sk = asoc->base.sk;
0448     struct net *net = sock_net(sk);
0449     int error = 0;
0450 
0451     bh_lock_sock(sk);
0452     if (sock_owned_by_user(sk)) {
0453         pr_debug("%s: sock is busy\n", __func__);
0454 
0455         /* Try again later.  */
0456         if (!mod_timer(&transport->reconf_timer, jiffies + (HZ / 20)))
0457             sctp_transport_hold(transport);
0458         goto out_unlock;
0459     }
0460 
0461     /* This happens when the response arrives after the timer is triggered. */
0462     if (!asoc->strreset_chunk)
0463         goto out_unlock;
0464 
0465     error = sctp_do_sm(net, SCTP_EVENT_T_TIMEOUT,
0466                SCTP_ST_TIMEOUT(SCTP_EVENT_TIMEOUT_RECONF),
0467                asoc->state, asoc->ep, asoc,
0468                transport, GFP_ATOMIC);
0469 
0470     if (error)
0471         sk->sk_err = -error;
0472 
0473 out_unlock:
0474     bh_unlock_sock(sk);
0475     sctp_transport_put(transport);
0476 }
0477 
0478 /* Handle the timeout of the probe timer. */
0479 void sctp_generate_probe_event(struct timer_list *t)
0480 {
0481     struct sctp_transport *transport = from_timer(transport, t, probe_timer);
0482     struct sctp_association *asoc = transport->asoc;
0483     struct sock *sk = asoc->base.sk;
0484     struct net *net = sock_net(sk);
0485     int error = 0;
0486 
0487     bh_lock_sock(sk);
0488     if (sock_owned_by_user(sk)) {
0489         pr_debug("%s: sock is busy\n", __func__);
0490 
0491         /* Try again later.  */
0492         if (!mod_timer(&transport->probe_timer, jiffies + (HZ / 20)))
0493             sctp_transport_hold(transport);
0494         goto out_unlock;
0495     }
0496 
0497     error = sctp_do_sm(net, SCTP_EVENT_T_TIMEOUT,
0498                SCTP_ST_TIMEOUT(SCTP_EVENT_TIMEOUT_PROBE),
0499                asoc->state, asoc->ep, asoc,
0500                transport, GFP_ATOMIC);
0501 
0502     if (error)
0503         sk->sk_err = -error;
0504 
0505 out_unlock:
0506     bh_unlock_sock(sk);
0507     sctp_transport_put(transport);
0508 }
0509 
0510 /* Inject a SACK Timeout event into the state machine.  */
0511 static void sctp_generate_sack_event(struct timer_list *t)
0512 {
0513     struct sctp_association *asoc =
0514         from_timer(asoc, t, timers[SCTP_EVENT_TIMEOUT_SACK]);
0515 
0516     sctp_generate_timeout_event(asoc, SCTP_EVENT_TIMEOUT_SACK);
0517 }
0518 
0519 sctp_timer_event_t *sctp_timer_events[SCTP_NUM_TIMEOUT_TYPES] = {
0520     [SCTP_EVENT_TIMEOUT_NONE] =     NULL,
0521     [SCTP_EVENT_TIMEOUT_T1_COOKIE] =    sctp_generate_t1_cookie_event,
0522     [SCTP_EVENT_TIMEOUT_T1_INIT] =      sctp_generate_t1_init_event,
0523     [SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] =  sctp_generate_t2_shutdown_event,
0524     [SCTP_EVENT_TIMEOUT_T3_RTX] =       NULL,
0525     [SCTP_EVENT_TIMEOUT_T4_RTO] =       sctp_generate_t4_rto_event,
0526     [SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD] =
0527                     sctp_generate_t5_shutdown_guard_event,
0528     [SCTP_EVENT_TIMEOUT_HEARTBEAT] =    NULL,
0529     [SCTP_EVENT_TIMEOUT_RECONF] =       NULL,
0530     [SCTP_EVENT_TIMEOUT_SACK] =     sctp_generate_sack_event,
0531     [SCTP_EVENT_TIMEOUT_AUTOCLOSE] =    sctp_generate_autoclose_event,
0532 };
0533 
0534 
0535 /* RFC 2960 8.2 Path Failure Detection
0536  *
0537  * When its peer endpoint is multi-homed, an endpoint should keep a
0538  * error counter for each of the destination transport addresses of the
0539  * peer endpoint.
0540  *
0541  * Each time the T3-rtx timer expires on any address, or when a
0542  * HEARTBEAT sent to an idle address is not acknowledged within a RTO,
0543  * the error counter of that destination address will be incremented.
0544  * When the value in the error counter exceeds the protocol parameter
0545  * 'Path.Max.Retrans' of that destination address, the endpoint should
0546  * mark the destination transport address as inactive, and a
0547  * notification SHOULD be sent to the upper layer.
0548  *
0549  */
0550 static void sctp_do_8_2_transport_strike(struct sctp_cmd_seq *commands,
0551                      struct sctp_association *asoc,
0552                      struct sctp_transport *transport,
0553                      int is_hb)
0554 {
0555     /* The check for association's overall error counter exceeding the
0556      * threshold is done in the state function.
0557      */
0558     /* We are here due to a timer expiration.  If the timer was
0559      * not a HEARTBEAT, then normal error tracking is done.
0560      * If the timer was a heartbeat, we only increment error counts
0561      * when we already have an outstanding HEARTBEAT that has not
0562      * been acknowledged.
0563      * Additionally, some tranport states inhibit error increments.
0564      */
0565     if (!is_hb) {
0566         asoc->overall_error_count++;
0567         if (transport->state != SCTP_INACTIVE)
0568             transport->error_count++;
0569      } else if (transport->hb_sent) {
0570         if (transport->state != SCTP_UNCONFIRMED)
0571             asoc->overall_error_count++;
0572         if (transport->state != SCTP_INACTIVE)
0573             transport->error_count++;
0574     }
0575 
0576     /* If the transport error count is greater than the pf_retrans
0577      * threshold, and less than pathmaxrtx, and if the current state
0578      * is SCTP_ACTIVE, then mark this transport as Partially Failed,
0579      * see SCTP Quick Failover Draft, section 5.1
0580      */
0581     if (asoc->base.net->sctp.pf_enable &&
0582         transport->state == SCTP_ACTIVE &&
0583         transport->error_count < transport->pathmaxrxt &&
0584         transport->error_count > transport->pf_retrans) {
0585 
0586         sctp_assoc_control_transport(asoc, transport,
0587                          SCTP_TRANSPORT_PF,
0588                          0);
0589 
0590         /* Update the hb timer to resend a heartbeat every rto */
0591         sctp_transport_reset_hb_timer(transport);
0592     }
0593 
0594     if (transport->state != SCTP_INACTIVE &&
0595         (transport->error_count > transport->pathmaxrxt)) {
0596         pr_debug("%s: association:%p transport addr:%pISpc failed\n",
0597              __func__, asoc, &transport->ipaddr.sa);
0598 
0599         sctp_assoc_control_transport(asoc, transport,
0600                          SCTP_TRANSPORT_DOWN,
0601                          SCTP_FAILED_THRESHOLD);
0602     }
0603 
0604     if (transport->error_count > transport->ps_retrans &&
0605         asoc->peer.primary_path == transport &&
0606         asoc->peer.active_path != transport)
0607         sctp_assoc_set_primary(asoc, asoc->peer.active_path);
0608 
0609     /* E2) For the destination address for which the timer
0610      * expires, set RTO <- RTO * 2 ("back off the timer").  The
0611      * maximum value discussed in rule C7 above (RTO.max) may be
0612      * used to provide an upper bound to this doubling operation.
0613      *
0614      * Special Case:  the first HB doesn't trigger exponential backoff.
0615      * The first unacknowledged HB triggers it.  We do this with a flag
0616      * that indicates that we have an outstanding HB.
0617      */
0618     if (!is_hb || transport->hb_sent) {
0619         transport->rto = min((transport->rto * 2), transport->asoc->rto_max);
0620         sctp_max_rto(asoc, transport);
0621     }
0622 }
0623 
0624 /* Worker routine to handle INIT command failure.  */
0625 static void sctp_cmd_init_failed(struct sctp_cmd_seq *commands,
0626                  struct sctp_association *asoc,
0627                  unsigned int error)
0628 {
0629     struct sctp_ulpevent *event;
0630 
0631     event = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_CANT_STR_ASSOC,
0632                         (__u16)error, 0, 0, NULL,
0633                         GFP_ATOMIC);
0634 
0635     if (event)
0636         sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
0637                 SCTP_ULPEVENT(event));
0638 
0639     sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
0640             SCTP_STATE(SCTP_STATE_CLOSED));
0641 
0642     /* SEND_FAILED sent later when cleaning up the association. */
0643     asoc->outqueue.error = error;
0644     sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
0645 }
0646 
0647 /* Worker routine to handle SCTP_CMD_ASSOC_FAILED.  */
0648 static void sctp_cmd_assoc_failed(struct sctp_cmd_seq *commands,
0649                   struct sctp_association *asoc,
0650                   enum sctp_event_type event_type,
0651                   union sctp_subtype subtype,
0652                   struct sctp_chunk *chunk,
0653                   unsigned int error)
0654 {
0655     struct sctp_ulpevent *event;
0656     struct sctp_chunk *abort;
0657 
0658     /* Cancel any partial delivery in progress. */
0659     asoc->stream.si->abort_pd(&asoc->ulpq, GFP_ATOMIC);
0660 
0661     if (event_type == SCTP_EVENT_T_CHUNK && subtype.chunk == SCTP_CID_ABORT)
0662         event = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_COMM_LOST,
0663                         (__u16)error, 0, 0, chunk,
0664                         GFP_ATOMIC);
0665     else
0666         event = sctp_ulpevent_make_assoc_change(asoc, 0, SCTP_COMM_LOST,
0667                         (__u16)error, 0, 0, NULL,
0668                         GFP_ATOMIC);
0669     if (event)
0670         sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP,
0671                 SCTP_ULPEVENT(event));
0672 
0673     if (asoc->overall_error_count >= asoc->max_retrans) {
0674         abort = sctp_make_violation_max_retrans(asoc, chunk);
0675         if (abort)
0676             sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
0677                     SCTP_CHUNK(abort));
0678     }
0679 
0680     sctp_add_cmd_sf(commands, SCTP_CMD_NEW_STATE,
0681             SCTP_STATE(SCTP_STATE_CLOSED));
0682 
0683     /* SEND_FAILED sent later when cleaning up the association. */
0684     asoc->outqueue.error = error;
0685     sctp_add_cmd_sf(commands, SCTP_CMD_DELETE_TCB, SCTP_NULL());
0686 }
0687 
0688 /* Process an init chunk (may be real INIT/INIT-ACK or an embedded INIT
0689  * inside the cookie.  In reality, this is only used for INIT-ACK processing
0690  * since all other cases use "temporary" associations and can do all
0691  * their work in statefuns directly.
0692  */
0693 static int sctp_cmd_process_init(struct sctp_cmd_seq *commands,
0694                  struct sctp_association *asoc,
0695                  struct sctp_chunk *chunk,
0696                  struct sctp_init_chunk *peer_init,
0697                  gfp_t gfp)
0698 {
0699     int error;
0700 
0701     /* We only process the init as a sideeffect in a single
0702      * case.   This is when we process the INIT-ACK.   If we
0703      * fail during INIT processing (due to malloc problems),
0704      * just return the error and stop processing the stack.
0705      */
0706     if (!sctp_process_init(asoc, chunk, sctp_source(chunk), peer_init, gfp))
0707         error = -ENOMEM;
0708     else
0709         error = 0;
0710 
0711     return error;
0712 }
0713 
0714 /* Helper function to break out starting up of heartbeat timers.  */
0715 static void sctp_cmd_hb_timers_start(struct sctp_cmd_seq *cmds,
0716                      struct sctp_association *asoc)
0717 {
0718     struct sctp_transport *t;
0719 
0720     /* Start a heartbeat timer for each transport on the association.
0721      * hold a reference on the transport to make sure none of
0722      * the needed data structures go away.
0723      */
0724     list_for_each_entry(t, &asoc->peer.transport_addr_list, transports)
0725         sctp_transport_reset_hb_timer(t);
0726 }
0727 
0728 static void sctp_cmd_hb_timers_stop(struct sctp_cmd_seq *cmds,
0729                     struct sctp_association *asoc)
0730 {
0731     struct sctp_transport *t;
0732 
0733     /* Stop all heartbeat timers. */
0734 
0735     list_for_each_entry(t, &asoc->peer.transport_addr_list,
0736             transports) {
0737         if (del_timer(&t->hb_timer))
0738             sctp_transport_put(t);
0739     }
0740 }
0741 
0742 /* Helper function to stop any pending T3-RTX timers */
0743 static void sctp_cmd_t3_rtx_timers_stop(struct sctp_cmd_seq *cmds,
0744                     struct sctp_association *asoc)
0745 {
0746     struct sctp_transport *t;
0747 
0748     list_for_each_entry(t, &asoc->peer.transport_addr_list,
0749             transports) {
0750         if (del_timer(&t->T3_rtx_timer))
0751             sctp_transport_put(t);
0752     }
0753 }
0754 
0755 
0756 /* Helper function to handle the reception of an HEARTBEAT ACK.  */
0757 static void sctp_cmd_transport_on(struct sctp_cmd_seq *cmds,
0758                   struct sctp_association *asoc,
0759                   struct sctp_transport *t,
0760                   struct sctp_chunk *chunk)
0761 {
0762     struct sctp_sender_hb_info *hbinfo;
0763     int was_unconfirmed = 0;
0764 
0765     /* 8.3 Upon the receipt of the HEARTBEAT ACK, the sender of the
0766      * HEARTBEAT should clear the error counter of the destination
0767      * transport address to which the HEARTBEAT was sent.
0768      */
0769     t->error_count = 0;
0770 
0771     /*
0772      * Although RFC4960 specifies that the overall error count must
0773      * be cleared when a HEARTBEAT ACK is received, we make an
0774      * exception while in SHUTDOWN PENDING. If the peer keeps its
0775      * window shut forever, we may never be able to transmit our
0776      * outstanding data and rely on the retransmission limit be reached
0777      * to shutdown the association.
0778      */
0779     if (t->asoc->state < SCTP_STATE_SHUTDOWN_PENDING)
0780         t->asoc->overall_error_count = 0;
0781 
0782     /* Clear the hb_sent flag to signal that we had a good
0783      * acknowledgement.
0784      */
0785     t->hb_sent = 0;
0786 
0787     /* Mark the destination transport address as active if it is not so
0788      * marked.
0789      */
0790     if ((t->state == SCTP_INACTIVE) || (t->state == SCTP_UNCONFIRMED)) {
0791         was_unconfirmed = 1;
0792         sctp_assoc_control_transport(asoc, t, SCTP_TRANSPORT_UP,
0793                          SCTP_HEARTBEAT_SUCCESS);
0794     }
0795 
0796     if (t->state == SCTP_PF)
0797         sctp_assoc_control_transport(asoc, t, SCTP_TRANSPORT_UP,
0798                          SCTP_HEARTBEAT_SUCCESS);
0799 
0800     /* HB-ACK was received for a the proper HB.  Consider this
0801      * forward progress.
0802      */
0803     if (t->dst)
0804         sctp_transport_dst_confirm(t);
0805 
0806     /* The receiver of the HEARTBEAT ACK should also perform an
0807      * RTT measurement for that destination transport address
0808      * using the time value carried in the HEARTBEAT ACK chunk.
0809      * If the transport's rto_pending variable has been cleared,
0810      * it was most likely due to a retransmit.  However, we want
0811      * to re-enable it to properly update the rto.
0812      */
0813     if (t->rto_pending == 0)
0814         t->rto_pending = 1;
0815 
0816     hbinfo = (struct sctp_sender_hb_info *)chunk->skb->data;
0817     sctp_transport_update_rto(t, (jiffies - hbinfo->sent_at));
0818 
0819     /* Update the heartbeat timer.  */
0820     sctp_transport_reset_hb_timer(t);
0821 
0822     if (was_unconfirmed && asoc->peer.transport_count == 1)
0823         sctp_transport_immediate_rtx(t);
0824 }
0825 
0826 
0827 /* Helper function to process the process SACK command.  */
0828 static int sctp_cmd_process_sack(struct sctp_cmd_seq *cmds,
0829                  struct sctp_association *asoc,
0830                  struct sctp_chunk *chunk)
0831 {
0832     int err = 0;
0833 
0834     if (sctp_outq_sack(&asoc->outqueue, chunk)) {
0835         /* There are no more TSNs awaiting SACK.  */
0836         err = sctp_do_sm(asoc->base.net, SCTP_EVENT_T_OTHER,
0837                  SCTP_ST_OTHER(SCTP_EVENT_NO_PENDING_TSN),
0838                  asoc->state, asoc->ep, asoc, NULL,
0839                  GFP_ATOMIC);
0840     }
0841 
0842     return err;
0843 }
0844 
0845 /* Helper function to set the timeout value for T2-SHUTDOWN timer and to set
0846  * the transport for a shutdown chunk.
0847  */
0848 static void sctp_cmd_setup_t2(struct sctp_cmd_seq *cmds,
0849                   struct sctp_association *asoc,
0850                   struct sctp_chunk *chunk)
0851 {
0852     struct sctp_transport *t;
0853 
0854     if (chunk->transport)
0855         t = chunk->transport;
0856     else {
0857         t = sctp_assoc_choose_alter_transport(asoc,
0858                           asoc->shutdown_last_sent_to);
0859         chunk->transport = t;
0860     }
0861     asoc->shutdown_last_sent_to = t;
0862     asoc->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] = t->rto;
0863 }
0864 
0865 /* Helper function to change the state of an association. */
0866 static void sctp_cmd_new_state(struct sctp_cmd_seq *cmds,
0867                    struct sctp_association *asoc,
0868                    enum sctp_state state)
0869 {
0870     struct sock *sk = asoc->base.sk;
0871 
0872     asoc->state = state;
0873 
0874     pr_debug("%s: asoc:%p[%s]\n", __func__, asoc, sctp_state_tbl[state]);
0875 
0876     if (sctp_style(sk, TCP)) {
0877         /* Change the sk->sk_state of a TCP-style socket that has
0878          * successfully completed a connect() call.
0879          */
0880         if (sctp_state(asoc, ESTABLISHED) && sctp_sstate(sk, CLOSED))
0881             inet_sk_set_state(sk, SCTP_SS_ESTABLISHED);
0882 
0883         /* Set the RCV_SHUTDOWN flag when a SHUTDOWN is received. */
0884         if (sctp_state(asoc, SHUTDOWN_RECEIVED) &&
0885             sctp_sstate(sk, ESTABLISHED)) {
0886             inet_sk_set_state(sk, SCTP_SS_CLOSING);
0887             sk->sk_shutdown |= RCV_SHUTDOWN;
0888         }
0889     }
0890 
0891     if (sctp_state(asoc, COOKIE_WAIT)) {
0892         /* Reset init timeouts since they may have been
0893          * increased due to timer expirations.
0894          */
0895         asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] =
0896                         asoc->rto_initial;
0897         asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] =
0898                         asoc->rto_initial;
0899     }
0900 
0901     if (sctp_state(asoc, ESTABLISHED)) {
0902         kfree(asoc->peer.cookie);
0903         asoc->peer.cookie = NULL;
0904     }
0905 
0906     if (sctp_state(asoc, ESTABLISHED) ||
0907         sctp_state(asoc, CLOSED) ||
0908         sctp_state(asoc, SHUTDOWN_RECEIVED)) {
0909         /* Wake up any processes waiting in the asoc's wait queue in
0910          * sctp_wait_for_connect() or sctp_wait_for_sndbuf().
0911          */
0912         if (waitqueue_active(&asoc->wait))
0913             wake_up_interruptible(&asoc->wait);
0914 
0915         /* Wake up any processes waiting in the sk's sleep queue of
0916          * a TCP-style or UDP-style peeled-off socket in
0917          * sctp_wait_for_accept() or sctp_wait_for_packet().
0918          * For a UDP-style socket, the waiters are woken up by the
0919          * notifications.
0920          */
0921         if (!sctp_style(sk, UDP))
0922             sk->sk_state_change(sk);
0923     }
0924 
0925     if (sctp_state(asoc, SHUTDOWN_PENDING) &&
0926         !sctp_outq_is_empty(&asoc->outqueue))
0927         sctp_outq_uncork(&asoc->outqueue, GFP_ATOMIC);
0928 }
0929 
0930 /* Helper function to delete an association. */
0931 static void sctp_cmd_delete_tcb(struct sctp_cmd_seq *cmds,
0932                 struct sctp_association *asoc)
0933 {
0934     struct sock *sk = asoc->base.sk;
0935 
0936     /* If it is a non-temporary association belonging to a TCP-style
0937      * listening socket that is not closed, do not free it so that accept()
0938      * can pick it up later.
0939      */
0940     if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING) &&
0941         (!asoc->temp) && (sk->sk_shutdown != SHUTDOWN_MASK))
0942         return;
0943 
0944     sctp_association_free(asoc);
0945 }
0946 
0947 /*
0948  * ADDIP Section 4.1 ASCONF Chunk Procedures
0949  * A4) Start a T-4 RTO timer, using the RTO value of the selected
0950  * destination address (we use active path instead of primary path just
0951  * because primary path may be inactive.
0952  */
0953 static void sctp_cmd_setup_t4(struct sctp_cmd_seq *cmds,
0954                   struct sctp_association *asoc,
0955                   struct sctp_chunk *chunk)
0956 {
0957     struct sctp_transport *t;
0958 
0959     t = sctp_assoc_choose_alter_transport(asoc, chunk->transport);
0960     asoc->timeouts[SCTP_EVENT_TIMEOUT_T4_RTO] = t->rto;
0961     chunk->transport = t;
0962 }
0963 
0964 /* Process an incoming Operation Error Chunk. */
0965 static void sctp_cmd_process_operr(struct sctp_cmd_seq *cmds,
0966                    struct sctp_association *asoc,
0967                    struct sctp_chunk *chunk)
0968 {
0969     struct sctp_errhdr *err_hdr;
0970     struct sctp_ulpevent *ev;
0971 
0972     while (chunk->chunk_end > chunk->skb->data) {
0973         err_hdr = (struct sctp_errhdr *)(chunk->skb->data);
0974 
0975         ev = sctp_ulpevent_make_remote_error(asoc, chunk, 0,
0976                              GFP_ATOMIC);
0977         if (!ev)
0978             return;
0979 
0980         asoc->stream.si->enqueue_event(&asoc->ulpq, ev);
0981 
0982         switch (err_hdr->cause) {
0983         case SCTP_ERROR_UNKNOWN_CHUNK:
0984         {
0985             struct sctp_chunkhdr *unk_chunk_hdr;
0986 
0987             unk_chunk_hdr = (struct sctp_chunkhdr *)
0988                             err_hdr->variable;
0989             switch (unk_chunk_hdr->type) {
0990             /* ADDIP 4.1 A9) If the peer responds to an ASCONF with
0991              * an ERROR chunk reporting that it did not recognized
0992              * the ASCONF chunk type, the sender of the ASCONF MUST
0993              * NOT send any further ASCONF chunks and MUST stop its
0994              * T-4 timer.
0995              */
0996             case SCTP_CID_ASCONF:
0997                 if (asoc->peer.asconf_capable == 0)
0998                     break;
0999 
1000                 asoc->peer.asconf_capable = 0;
1001                 sctp_add_cmd_sf(cmds, SCTP_CMD_TIMER_STOP,
1002                     SCTP_TO(SCTP_EVENT_TIMEOUT_T4_RTO));
1003                 break;
1004             default:
1005                 break;
1006             }
1007             break;
1008         }
1009         default:
1010             break;
1011         }
1012     }
1013 }
1014 
1015 /* Helper function to remove the association non-primary peer
1016  * transports.
1017  */
1018 static void sctp_cmd_del_non_primary(struct sctp_association *asoc)
1019 {
1020     struct sctp_transport *t;
1021     struct list_head *temp;
1022     struct list_head *pos;
1023 
1024     list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
1025         t = list_entry(pos, struct sctp_transport, transports);
1026         if (!sctp_cmp_addr_exact(&t->ipaddr,
1027                      &asoc->peer.primary_addr)) {
1028             sctp_assoc_rm_peer(asoc, t);
1029         }
1030     }
1031 }
1032 
1033 /* Helper function to set sk_err on a 1-1 style socket. */
1034 static void sctp_cmd_set_sk_err(struct sctp_association *asoc, int error)
1035 {
1036     struct sock *sk = asoc->base.sk;
1037 
1038     if (!sctp_style(sk, UDP))
1039         sk->sk_err = error;
1040 }
1041 
1042 /* Helper function to generate an association change event */
1043 static void sctp_cmd_assoc_change(struct sctp_cmd_seq *commands,
1044                   struct sctp_association *asoc,
1045                   u8 state)
1046 {
1047     struct sctp_ulpevent *ev;
1048 
1049     ev = sctp_ulpevent_make_assoc_change(asoc, 0, state, 0,
1050                         asoc->c.sinit_num_ostreams,
1051                         asoc->c.sinit_max_instreams,
1052                         NULL, GFP_ATOMIC);
1053     if (ev)
1054         asoc->stream.si->enqueue_event(&asoc->ulpq, ev);
1055 }
1056 
1057 static void sctp_cmd_peer_no_auth(struct sctp_cmd_seq *commands,
1058                   struct sctp_association *asoc)
1059 {
1060     struct sctp_ulpevent *ev;
1061 
1062     ev = sctp_ulpevent_make_authkey(asoc, 0, SCTP_AUTH_NO_AUTH, GFP_ATOMIC);
1063     if (ev)
1064         asoc->stream.si->enqueue_event(&asoc->ulpq, ev);
1065 }
1066 
1067 /* Helper function to generate an adaptation indication event */
1068 static void sctp_cmd_adaptation_ind(struct sctp_cmd_seq *commands,
1069                     struct sctp_association *asoc)
1070 {
1071     struct sctp_ulpevent *ev;
1072 
1073     ev = sctp_ulpevent_make_adaptation_indication(asoc, GFP_ATOMIC);
1074 
1075     if (ev)
1076         asoc->stream.si->enqueue_event(&asoc->ulpq, ev);
1077 }
1078 
1079 
1080 static void sctp_cmd_t1_timer_update(struct sctp_association *asoc,
1081                      enum sctp_event_timeout timer,
1082                      char *name)
1083 {
1084     struct sctp_transport *t;
1085 
1086     t = asoc->init_last_sent_to;
1087     asoc->init_err_counter++;
1088 
1089     if (t->init_sent_count > (asoc->init_cycle + 1)) {
1090         asoc->timeouts[timer] *= 2;
1091         if (asoc->timeouts[timer] > asoc->max_init_timeo) {
1092             asoc->timeouts[timer] = asoc->max_init_timeo;
1093         }
1094         asoc->init_cycle++;
1095 
1096         pr_debug("%s: T1[%s] timeout adjustment init_err_counter:%d"
1097              " cycle:%d timeout:%ld\n", __func__, name,
1098              asoc->init_err_counter, asoc->init_cycle,
1099              asoc->timeouts[timer]);
1100     }
1101 
1102 }
1103 
1104 /* Send the whole message, chunk by chunk, to the outqueue.
1105  * This way the whole message is queued up and bundling if
1106  * encouraged for small fragments.
1107  */
1108 static void sctp_cmd_send_msg(struct sctp_association *asoc,
1109                   struct sctp_datamsg *msg, gfp_t gfp)
1110 {
1111     struct sctp_chunk *chunk;
1112 
1113     list_for_each_entry(chunk, &msg->chunks, frag_list)
1114         sctp_outq_tail(&asoc->outqueue, chunk, gfp);
1115 
1116     asoc->outqueue.sched->enqueue(&asoc->outqueue, msg);
1117 }
1118 
1119 
1120 /* These three macros allow us to pull the debugging code out of the
1121  * main flow of sctp_do_sm() to keep attention focused on the real
1122  * functionality there.
1123  */
1124 #define debug_pre_sfn() \
1125     pr_debug("%s[pre-fn]: ep:%p, %s, %s, asoc:%p[%s], %s\n", __func__, \
1126          ep, sctp_evttype_tbl[event_type], (*debug_fn)(subtype),   \
1127          asoc, sctp_state_tbl[state], state_fn->name)
1128 
1129 #define debug_post_sfn() \
1130     pr_debug("%s[post-fn]: asoc:%p, status:%s\n", __func__, asoc, \
1131          sctp_status_tbl[status])
1132 
1133 #define debug_post_sfx() \
1134     pr_debug("%s[post-sfx]: error:%d, asoc:%p[%s]\n", __func__, error, \
1135          asoc, sctp_state_tbl[(asoc && sctp_id2assoc(ep->base.sk, \
1136          sctp_assoc2id(asoc))) ? asoc->state : SCTP_STATE_CLOSED])
1137 
1138 /*
1139  * This is the master state machine processing function.
1140  *
1141  * If you want to understand all of lksctp, this is a
1142  * good place to start.
1143  */
1144 int sctp_do_sm(struct net *net, enum sctp_event_type event_type,
1145            union sctp_subtype subtype, enum sctp_state state,
1146            struct sctp_endpoint *ep, struct sctp_association *asoc,
1147            void *event_arg, gfp_t gfp)
1148 {
1149     typedef const char *(printfn_t)(union sctp_subtype);
1150     static printfn_t *table[] = {
1151         NULL, sctp_cname, sctp_tname, sctp_oname, sctp_pname,
1152     };
1153     printfn_t *debug_fn  __attribute__ ((unused)) = table[event_type];
1154     const struct sctp_sm_table_entry *state_fn;
1155     struct sctp_cmd_seq commands;
1156     enum sctp_disposition status;
1157     int error = 0;
1158 
1159     /* Look up the state function, run it, and then process the
1160      * side effects.  These three steps are the heart of lksctp.
1161      */
1162     state_fn = sctp_sm_lookup_event(net, event_type, state, subtype);
1163 
1164     sctp_init_cmd_seq(&commands);
1165 
1166     debug_pre_sfn();
1167     status = state_fn->fn(net, ep, asoc, subtype, event_arg, &commands);
1168     debug_post_sfn();
1169 
1170     error = sctp_side_effects(event_type, subtype, state,
1171                   ep, &asoc, event_arg, status,
1172                   &commands, gfp);
1173     debug_post_sfx();
1174 
1175     return error;
1176 }
1177 
1178 /*****************************************************************
1179  * This the master state function side effect processing function.
1180  *****************************************************************/
1181 static int sctp_side_effects(enum sctp_event_type event_type,
1182                  union sctp_subtype subtype,
1183                  enum sctp_state state,
1184                  struct sctp_endpoint *ep,
1185                  struct sctp_association **asoc,
1186                  void *event_arg,
1187                  enum sctp_disposition status,
1188                  struct sctp_cmd_seq *commands,
1189                  gfp_t gfp)
1190 {
1191     int error;
1192 
1193     /* FIXME - Most of the dispositions left today would be categorized
1194      * as "exceptional" dispositions.  For those dispositions, it
1195      * may not be proper to run through any of the commands at all.
1196      * For example, the command interpreter might be run only with
1197      * disposition SCTP_DISPOSITION_CONSUME.
1198      */
1199     if (0 != (error = sctp_cmd_interpreter(event_type, subtype, state,
1200                            ep, *asoc,
1201                            event_arg, status,
1202                            commands, gfp)))
1203         goto bail;
1204 
1205     switch (status) {
1206     case SCTP_DISPOSITION_DISCARD:
1207         pr_debug("%s: ignored sctp protocol event - state:%d, "
1208              "event_type:%d, event_id:%d\n", __func__, state,
1209              event_type, subtype.chunk);
1210         break;
1211 
1212     case SCTP_DISPOSITION_NOMEM:
1213         /* We ran out of memory, so we need to discard this
1214          * packet.
1215          */
1216         /* BUG--we should now recover some memory, probably by
1217          * reneging...
1218          */
1219         error = -ENOMEM;
1220         break;
1221 
1222     case SCTP_DISPOSITION_DELETE_TCB:
1223     case SCTP_DISPOSITION_ABORT:
1224         /* This should now be a command. */
1225         *asoc = NULL;
1226         break;
1227 
1228     case SCTP_DISPOSITION_CONSUME:
1229         /*
1230          * We should no longer have much work to do here as the
1231          * real work has been done as explicit commands above.
1232          */
1233         break;
1234 
1235     case SCTP_DISPOSITION_VIOLATION:
1236         net_err_ratelimited("protocol violation state %d chunkid %d\n",
1237                     state, subtype.chunk);
1238         break;
1239 
1240     case SCTP_DISPOSITION_NOT_IMPL:
1241         pr_warn("unimplemented feature in state %d, event_type %d, event_id %d\n",
1242             state, event_type, subtype.chunk);
1243         break;
1244 
1245     case SCTP_DISPOSITION_BUG:
1246         pr_err("bug in state %d, event_type %d, event_id %d\n",
1247                state, event_type, subtype.chunk);
1248         BUG();
1249         break;
1250 
1251     default:
1252         pr_err("impossible disposition %d in state %d, event_type %d, event_id %d\n",
1253                status, state, event_type, subtype.chunk);
1254         BUG();
1255         break;
1256     }
1257 
1258 bail:
1259     return error;
1260 }
1261 
1262 /********************************************************************
1263  * 2nd Level Abstractions
1264  ********************************************************************/
1265 
1266 /* This is the side-effect interpreter.  */
1267 static int sctp_cmd_interpreter(enum sctp_event_type event_type,
1268                 union sctp_subtype subtype,
1269                 enum sctp_state state,
1270                 struct sctp_endpoint *ep,
1271                 struct sctp_association *asoc,
1272                 void *event_arg,
1273                 enum sctp_disposition status,
1274                 struct sctp_cmd_seq *commands,
1275                 gfp_t gfp)
1276 {
1277     struct sctp_sock *sp = sctp_sk(ep->base.sk);
1278     struct sctp_chunk *chunk = NULL, *new_obj;
1279     struct sctp_packet *packet;
1280     struct sctp_sackhdr sackh;
1281     struct timer_list *timer;
1282     struct sctp_transport *t;
1283     unsigned long timeout;
1284     struct sctp_cmd *cmd;
1285     int local_cork = 0;
1286     int error = 0;
1287     int force;
1288 
1289     if (SCTP_EVENT_T_TIMEOUT != event_type)
1290         chunk = event_arg;
1291 
1292     /* Note:  This whole file is a huge candidate for rework.
1293      * For example, each command could either have its own handler, so
1294      * the loop would look like:
1295      *     while (cmds)
1296      *         cmd->handle(x, y, z)
1297      * --jgrimm
1298      */
1299     while (NULL != (cmd = sctp_next_cmd(commands))) {
1300         switch (cmd->verb) {
1301         case SCTP_CMD_NOP:
1302             /* Do nothing. */
1303             break;
1304 
1305         case SCTP_CMD_NEW_ASOC:
1306             /* Register a new association.  */
1307             if (local_cork) {
1308                 sctp_outq_uncork(&asoc->outqueue, gfp);
1309                 local_cork = 0;
1310             }
1311 
1312             /* Register with the endpoint.  */
1313             asoc = cmd->obj.asoc;
1314             BUG_ON(asoc->peer.primary_path == NULL);
1315             sctp_endpoint_add_asoc(ep, asoc);
1316             break;
1317 
1318         case SCTP_CMD_PURGE_OUTQUEUE:
1319                sctp_outq_teardown(&asoc->outqueue);
1320                break;
1321 
1322         case SCTP_CMD_DELETE_TCB:
1323             if (local_cork) {
1324                 sctp_outq_uncork(&asoc->outqueue, gfp);
1325                 local_cork = 0;
1326             }
1327             /* Delete the current association.  */
1328             sctp_cmd_delete_tcb(commands, asoc);
1329             asoc = NULL;
1330             break;
1331 
1332         case SCTP_CMD_NEW_STATE:
1333             /* Enter a new state.  */
1334             sctp_cmd_new_state(commands, asoc, cmd->obj.state);
1335             break;
1336 
1337         case SCTP_CMD_REPORT_TSN:
1338             /* Record the arrival of a TSN.  */
1339             error = sctp_tsnmap_mark(&asoc->peer.tsn_map,
1340                          cmd->obj.u32, NULL);
1341             break;
1342 
1343         case SCTP_CMD_REPORT_FWDTSN:
1344             asoc->stream.si->report_ftsn(&asoc->ulpq, cmd->obj.u32);
1345             break;
1346 
1347         case SCTP_CMD_PROCESS_FWDTSN:
1348             asoc->stream.si->handle_ftsn(&asoc->ulpq,
1349                              cmd->obj.chunk);
1350             break;
1351 
1352         case SCTP_CMD_GEN_SACK:
1353             /* Generate a Selective ACK.
1354              * The argument tells us whether to just count
1355              * the packet and MAYBE generate a SACK, or
1356              * force a SACK out.
1357              */
1358             force = cmd->obj.i32;
1359             error = sctp_gen_sack(asoc, force, commands);
1360             break;
1361 
1362         case SCTP_CMD_PROCESS_SACK:
1363             /* Process an inbound SACK.  */
1364             error = sctp_cmd_process_sack(commands, asoc,
1365                               cmd->obj.chunk);
1366             break;
1367 
1368         case SCTP_CMD_GEN_INIT_ACK:
1369             /* Generate an INIT ACK chunk.  */
1370             new_obj = sctp_make_init_ack(asoc, chunk, GFP_ATOMIC,
1371                              0);
1372             if (!new_obj) {
1373                 error = -ENOMEM;
1374                 break;
1375             }
1376 
1377             sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1378                     SCTP_CHUNK(new_obj));
1379             break;
1380 
1381         case SCTP_CMD_PEER_INIT:
1382             /* Process a unified INIT from the peer.
1383              * Note: Only used during INIT-ACK processing.  If
1384              * there is an error just return to the outter
1385              * layer which will bail.
1386              */
1387             error = sctp_cmd_process_init(commands, asoc, chunk,
1388                               cmd->obj.init, gfp);
1389             break;
1390 
1391         case SCTP_CMD_GEN_COOKIE_ECHO:
1392             /* Generate a COOKIE ECHO chunk.  */
1393             new_obj = sctp_make_cookie_echo(asoc, chunk);
1394             if (!new_obj) {
1395                 if (cmd->obj.chunk)
1396                     sctp_chunk_free(cmd->obj.chunk);
1397                 error = -ENOMEM;
1398                 break;
1399             }
1400             sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1401                     SCTP_CHUNK(new_obj));
1402 
1403             /* If there is an ERROR chunk to be sent along with
1404              * the COOKIE_ECHO, send it, too.
1405              */
1406             if (cmd->obj.chunk)
1407                 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1408                         SCTP_CHUNK(cmd->obj.chunk));
1409 
1410             if (new_obj->transport) {
1411                 new_obj->transport->init_sent_count++;
1412                 asoc->init_last_sent_to = new_obj->transport;
1413             }
1414 
1415             /* FIXME - Eventually come up with a cleaner way to
1416              * enabling COOKIE-ECHO + DATA bundling during
1417              * multihoming stale cookie scenarios, the following
1418              * command plays with asoc->peer.retran_path to
1419              * avoid the problem of sending the COOKIE-ECHO and
1420              * DATA in different paths, which could result
1421              * in the association being ABORTed if the DATA chunk
1422              * is processed first by the server.  Checking the
1423              * init error counter simply causes this command
1424              * to be executed only during failed attempts of
1425              * association establishment.
1426              */
1427             if ((asoc->peer.retran_path !=
1428                  asoc->peer.primary_path) &&
1429                 (asoc->init_err_counter > 0)) {
1430                 sctp_add_cmd_sf(commands,
1431                         SCTP_CMD_FORCE_PRIM_RETRAN,
1432                         SCTP_NULL());
1433             }
1434 
1435             break;
1436 
1437         case SCTP_CMD_GEN_SHUTDOWN:
1438             /* Generate SHUTDOWN when in SHUTDOWN_SENT state.
1439              * Reset error counts.
1440              */
1441             asoc->overall_error_count = 0;
1442 
1443             /* Generate a SHUTDOWN chunk.  */
1444             new_obj = sctp_make_shutdown(asoc, chunk);
1445             if (!new_obj) {
1446                 error = -ENOMEM;
1447                 break;
1448             }
1449             sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1450                     SCTP_CHUNK(new_obj));
1451             break;
1452 
1453         case SCTP_CMD_CHUNK_ULP:
1454             /* Send a chunk to the sockets layer.  */
1455             pr_debug("%s: sm_sideff: chunk_up:%p, ulpq:%p\n",
1456                  __func__, cmd->obj.chunk, &asoc->ulpq);
1457 
1458             asoc->stream.si->ulpevent_data(&asoc->ulpq,
1459                                cmd->obj.chunk,
1460                                GFP_ATOMIC);
1461             break;
1462 
1463         case SCTP_CMD_EVENT_ULP:
1464             /* Send a notification to the sockets layer.  */
1465             pr_debug("%s: sm_sideff: event_up:%p, ulpq:%p\n",
1466                  __func__, cmd->obj.ulpevent, &asoc->ulpq);
1467 
1468             asoc->stream.si->enqueue_event(&asoc->ulpq,
1469                                cmd->obj.ulpevent);
1470             break;
1471 
1472         case SCTP_CMD_REPLY:
1473             /* If an caller has not already corked, do cork. */
1474             if (!asoc->outqueue.cork) {
1475                 sctp_outq_cork(&asoc->outqueue);
1476                 local_cork = 1;
1477             }
1478             /* Send a chunk to our peer.  */
1479             sctp_outq_tail(&asoc->outqueue, cmd->obj.chunk, gfp);
1480             break;
1481 
1482         case SCTP_CMD_SEND_PKT:
1483             /* Send a full packet to our peer.  */
1484             packet = cmd->obj.packet;
1485             sctp_packet_transmit(packet, gfp);
1486             sctp_ootb_pkt_free(packet);
1487             break;
1488 
1489         case SCTP_CMD_T1_RETRAN:
1490             /* Mark a transport for retransmission.  */
1491             sctp_retransmit(&asoc->outqueue, cmd->obj.transport,
1492                     SCTP_RTXR_T1_RTX);
1493             break;
1494 
1495         case SCTP_CMD_RETRAN:
1496             /* Mark a transport for retransmission.  */
1497             sctp_retransmit(&asoc->outqueue, cmd->obj.transport,
1498                     SCTP_RTXR_T3_RTX);
1499             break;
1500 
1501         case SCTP_CMD_ECN_CE:
1502             /* Do delayed CE processing.   */
1503             sctp_do_ecn_ce_work(asoc, cmd->obj.u32);
1504             break;
1505 
1506         case SCTP_CMD_ECN_ECNE:
1507             /* Do delayed ECNE processing. */
1508             new_obj = sctp_do_ecn_ecne_work(asoc, cmd->obj.u32,
1509                             chunk);
1510             if (new_obj)
1511                 sctp_add_cmd_sf(commands, SCTP_CMD_REPLY,
1512                         SCTP_CHUNK(new_obj));
1513             break;
1514 
1515         case SCTP_CMD_ECN_CWR:
1516             /* Do delayed CWR processing.  */
1517             sctp_do_ecn_cwr_work(asoc, cmd->obj.u32);
1518             break;
1519 
1520         case SCTP_CMD_SETUP_T2:
1521             sctp_cmd_setup_t2(commands, asoc, cmd->obj.chunk);
1522             break;
1523 
1524         case SCTP_CMD_TIMER_START_ONCE:
1525             timer = &asoc->timers[cmd->obj.to];
1526 
1527             if (timer_pending(timer))
1528                 break;
1529             fallthrough;
1530 
1531         case SCTP_CMD_TIMER_START:
1532             timer = &asoc->timers[cmd->obj.to];
1533             timeout = asoc->timeouts[cmd->obj.to];
1534             BUG_ON(!timeout);
1535 
1536             /*
1537              * SCTP has a hard time with timer starts.  Because we process
1538              * timer starts as side effects, it can be hard to tell if we
1539              * have already started a timer or not, which leads to BUG
1540              * halts when we call add_timer. So here, instead of just starting
1541              * a timer, if the timer is already started, and just mod
1542              * the timer with the shorter of the two expiration times
1543              */
1544             if (!timer_pending(timer))
1545                 sctp_association_hold(asoc);
1546             timer_reduce(timer, jiffies + timeout);
1547             break;
1548 
1549         case SCTP_CMD_TIMER_RESTART:
1550             timer = &asoc->timers[cmd->obj.to];
1551             timeout = asoc->timeouts[cmd->obj.to];
1552             if (!mod_timer(timer, jiffies + timeout))
1553                 sctp_association_hold(asoc);
1554             break;
1555 
1556         case SCTP_CMD_TIMER_STOP:
1557             timer = &asoc->timers[cmd->obj.to];
1558             if (del_timer(timer))
1559                 sctp_association_put(asoc);
1560             break;
1561 
1562         case SCTP_CMD_INIT_CHOOSE_TRANSPORT:
1563             chunk = cmd->obj.chunk;
1564             t = sctp_assoc_choose_alter_transport(asoc,
1565                         asoc->init_last_sent_to);
1566             asoc->init_last_sent_to = t;
1567             chunk->transport = t;
1568             t->init_sent_count++;
1569             /* Set the new transport as primary */
1570             sctp_assoc_set_primary(asoc, t);
1571             break;
1572 
1573         case SCTP_CMD_INIT_RESTART:
1574             /* Do the needed accounting and updates
1575              * associated with restarting an initialization
1576              * timer. Only multiply the timeout by two if
1577              * all transports have been tried at the current
1578              * timeout.
1579              */
1580             sctp_cmd_t1_timer_update(asoc,
1581                         SCTP_EVENT_TIMEOUT_T1_INIT,
1582                         "INIT");
1583 
1584             sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART,
1585                     SCTP_TO(SCTP_EVENT_TIMEOUT_T1_INIT));
1586             break;
1587 
1588         case SCTP_CMD_COOKIEECHO_RESTART:
1589             /* Do the needed accounting and updates
1590              * associated with restarting an initialization
1591              * timer. Only multiply the timeout by two if
1592              * all transports have been tried at the current
1593              * timeout.
1594              */
1595             sctp_cmd_t1_timer_update(asoc,
1596                         SCTP_EVENT_TIMEOUT_T1_COOKIE,
1597                         "COOKIE");
1598 
1599             /* If we've sent any data bundled with
1600              * COOKIE-ECHO we need to resend.
1601              */
1602             list_for_each_entry(t, &asoc->peer.transport_addr_list,
1603                     transports) {
1604                 sctp_retransmit_mark(&asoc->outqueue, t,
1605                         SCTP_RTXR_T1_RTX);
1606             }
1607 
1608             sctp_add_cmd_sf(commands,
1609                     SCTP_CMD_TIMER_RESTART,
1610                     SCTP_TO(SCTP_EVENT_TIMEOUT_T1_COOKIE));
1611             break;
1612 
1613         case SCTP_CMD_INIT_FAILED:
1614             sctp_cmd_init_failed(commands, asoc, cmd->obj.u16);
1615             break;
1616 
1617         case SCTP_CMD_ASSOC_FAILED:
1618             sctp_cmd_assoc_failed(commands, asoc, event_type,
1619                           subtype, chunk, cmd->obj.u16);
1620             break;
1621 
1622         case SCTP_CMD_INIT_COUNTER_INC:
1623             asoc->init_err_counter++;
1624             break;
1625 
1626         case SCTP_CMD_INIT_COUNTER_RESET:
1627             asoc->init_err_counter = 0;
1628             asoc->init_cycle = 0;
1629             list_for_each_entry(t, &asoc->peer.transport_addr_list,
1630                         transports) {
1631                 t->init_sent_count = 0;
1632             }
1633             break;
1634 
1635         case SCTP_CMD_REPORT_DUP:
1636             sctp_tsnmap_mark_dup(&asoc->peer.tsn_map,
1637                          cmd->obj.u32);
1638             break;
1639 
1640         case SCTP_CMD_REPORT_BAD_TAG:
1641             pr_debug("%s: vtag mismatch!\n", __func__);
1642             break;
1643 
1644         case SCTP_CMD_STRIKE:
1645             /* Mark one strike against a transport.  */
1646             sctp_do_8_2_transport_strike(commands, asoc,
1647                             cmd->obj.transport, 0);
1648             break;
1649 
1650         case SCTP_CMD_TRANSPORT_IDLE:
1651             t = cmd->obj.transport;
1652             sctp_transport_lower_cwnd(t, SCTP_LOWER_CWND_INACTIVE);
1653             break;
1654 
1655         case SCTP_CMD_TRANSPORT_HB_SENT:
1656             t = cmd->obj.transport;
1657             sctp_do_8_2_transport_strike(commands, asoc,
1658                              t, 1);
1659             t->hb_sent = 1;
1660             break;
1661 
1662         case SCTP_CMD_TRANSPORT_ON:
1663             t = cmd->obj.transport;
1664             sctp_cmd_transport_on(commands, asoc, t, chunk);
1665             break;
1666 
1667         case SCTP_CMD_HB_TIMERS_START:
1668             sctp_cmd_hb_timers_start(commands, asoc);
1669             break;
1670 
1671         case SCTP_CMD_HB_TIMER_UPDATE:
1672             t = cmd->obj.transport;
1673             sctp_transport_reset_hb_timer(t);
1674             break;
1675 
1676         case SCTP_CMD_HB_TIMERS_STOP:
1677             sctp_cmd_hb_timers_stop(commands, asoc);
1678             break;
1679 
1680         case SCTP_CMD_PROBE_TIMER_UPDATE:
1681             t = cmd->obj.transport;
1682             sctp_transport_reset_probe_timer(t);
1683             break;
1684 
1685         case SCTP_CMD_REPORT_ERROR:
1686             error = cmd->obj.error;
1687             break;
1688 
1689         case SCTP_CMD_PROCESS_CTSN:
1690             /* Dummy up a SACK for processing. */
1691             sackh.cum_tsn_ack = cmd->obj.be32;
1692             sackh.a_rwnd = htonl(asoc->peer.rwnd +
1693                          asoc->outqueue.outstanding_bytes);
1694             sackh.num_gap_ack_blocks = 0;
1695             sackh.num_dup_tsns = 0;
1696             chunk->subh.sack_hdr = &sackh;
1697             sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_SACK,
1698                     SCTP_CHUNK(chunk));
1699             break;
1700 
1701         case SCTP_CMD_DISCARD_PACKET:
1702             /* We need to discard the whole packet.
1703              * Uncork the queue since there might be
1704              * responses pending
1705              */
1706             chunk->pdiscard = 1;
1707             if (asoc) {
1708                 sctp_outq_uncork(&asoc->outqueue, gfp);
1709                 local_cork = 0;
1710             }
1711             break;
1712 
1713         case SCTP_CMD_RTO_PENDING:
1714             t = cmd->obj.transport;
1715             t->rto_pending = 1;
1716             break;
1717 
1718         case SCTP_CMD_PART_DELIVER:
1719             asoc->stream.si->start_pd(&asoc->ulpq, GFP_ATOMIC);
1720             break;
1721 
1722         case SCTP_CMD_RENEGE:
1723             asoc->stream.si->renege_events(&asoc->ulpq,
1724                                cmd->obj.chunk,
1725                                GFP_ATOMIC);
1726             break;
1727 
1728         case SCTP_CMD_SETUP_T4:
1729             sctp_cmd_setup_t4(commands, asoc, cmd->obj.chunk);
1730             break;
1731 
1732         case SCTP_CMD_PROCESS_OPERR:
1733             sctp_cmd_process_operr(commands, asoc, chunk);
1734             break;
1735         case SCTP_CMD_CLEAR_INIT_TAG:
1736             asoc->peer.i.init_tag = 0;
1737             break;
1738         case SCTP_CMD_DEL_NON_PRIMARY:
1739             sctp_cmd_del_non_primary(asoc);
1740             break;
1741         case SCTP_CMD_T3_RTX_TIMERS_STOP:
1742             sctp_cmd_t3_rtx_timers_stop(commands, asoc);
1743             break;
1744         case SCTP_CMD_FORCE_PRIM_RETRAN:
1745             t = asoc->peer.retran_path;
1746             asoc->peer.retran_path = asoc->peer.primary_path;
1747             sctp_outq_uncork(&asoc->outqueue, gfp);
1748             local_cork = 0;
1749             asoc->peer.retran_path = t;
1750             break;
1751         case SCTP_CMD_SET_SK_ERR:
1752             sctp_cmd_set_sk_err(asoc, cmd->obj.error);
1753             break;
1754         case SCTP_CMD_ASSOC_CHANGE:
1755             sctp_cmd_assoc_change(commands, asoc,
1756                           cmd->obj.u8);
1757             break;
1758         case SCTP_CMD_ADAPTATION_IND:
1759             sctp_cmd_adaptation_ind(commands, asoc);
1760             break;
1761         case SCTP_CMD_PEER_NO_AUTH:
1762             sctp_cmd_peer_no_auth(commands, asoc);
1763             break;
1764 
1765         case SCTP_CMD_ASSOC_SHKEY:
1766             error = sctp_auth_asoc_init_active_key(asoc,
1767                         GFP_ATOMIC);
1768             break;
1769         case SCTP_CMD_UPDATE_INITTAG:
1770             asoc->peer.i.init_tag = cmd->obj.u32;
1771             break;
1772         case SCTP_CMD_SEND_MSG:
1773             if (!asoc->outqueue.cork) {
1774                 sctp_outq_cork(&asoc->outqueue);
1775                 local_cork = 1;
1776             }
1777             sctp_cmd_send_msg(asoc, cmd->obj.msg, gfp);
1778             break;
1779         case SCTP_CMD_PURGE_ASCONF_QUEUE:
1780             sctp_asconf_queue_teardown(asoc);
1781             break;
1782 
1783         case SCTP_CMD_SET_ASOC:
1784             if (asoc && local_cork) {
1785                 sctp_outq_uncork(&asoc->outqueue, gfp);
1786                 local_cork = 0;
1787             }
1788             asoc = cmd->obj.asoc;
1789             break;
1790 
1791         default:
1792             pr_warn("Impossible command: %u\n",
1793                 cmd->verb);
1794             break;
1795         }
1796 
1797         if (error) {
1798             cmd = sctp_next_cmd(commands);
1799             while (cmd) {
1800                 if (cmd->verb == SCTP_CMD_REPLY)
1801                     sctp_chunk_free(cmd->obj.chunk);
1802                 cmd = sctp_next_cmd(commands);
1803             }
1804             break;
1805         }
1806     }
1807 
1808     /* If this is in response to a received chunk, wait until
1809      * we are done with the packet to open the queue so that we don't
1810      * send multiple packets in response to a single request.
1811      */
1812     if (asoc && SCTP_EVENT_T_CHUNK == event_type && chunk) {
1813         if (chunk->end_of_packet || chunk->singleton)
1814             sctp_outq_uncork(&asoc->outqueue, gfp);
1815     } else if (local_cork)
1816         sctp_outq_uncork(&asoc->outqueue, gfp);
1817 
1818     if (sp->data_ready_signalled)
1819         sp->data_ready_signalled = 0;
1820 
1821     return error;
1822 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!