Return to tp.trans CVS log

Up to [Net/2] / Net2 / netiso

Annotation of Net2/netiso/tp.trans, revision 1.1

1.1     ! root        1: /*-
        !             2:  * Copyright (c) 1991 The Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * Redistribution and use in source and binary forms, with or without
        !             6:  * modification, are permitted provided that the following conditions
        !             7:  * are met:
        !             8:  * 1. Redistributions of source code must retain the above copyright
        !             9:  *    notice, this list of conditions and the following disclaimer.
        !            10:  * 2. Redistributions in binary form must reproduce the above copyright
        !            11:  *    notice, this list of conditions and the following disclaimer in the
        !            12:  *    documentation and/or other materials provided with the distribution.
        !            13:  * 3. All advertising materials mentioning features or use of this software
        !            14:  *    must display the following acknowledgement:
        !            15:  *     This product includes software developed by the University of
        !            16:  *     California, Berkeley and its contributors.
        !            17:  * 4. Neither the name of the University nor the names of its contributors
        !            18:  *    may be used to endorse or promote products derived from this software
        !            19:  *    without specific prior written permission.
        !            20:  *
        !            21:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
        !            22:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            23:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            24:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            25:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            26:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            27:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            28:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            29:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            30:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            31:  * SUCH DAMAGE.
        !            32:  *
        !            33:  *     @(#)tp.trans    7.9 (Berkeley) 5/7/91
        !            34:  */
        !            35: 
        !            36: /***********************************************************
        !            37:                Copyright IBM Corporation 1987
        !            38: 
        !            39:                       All Rights Reserved
        !            40: 
        !            41: Permission to use, copy, modify, and distribute this software and its 
        !            42: documentation for any purpose and without fee is hereby granted, 
        !            43: provided that the above copyright notice appear in all copies and that
        !            44: both that copyright notice and this permission notice appear in 
        !            45: supporting documentation, and that the name of IBM not be
        !            46: used in advertising or publicity pertaining to distribution of the
        !            47: software without specific, written prior permission.  
        !            48: 
        !            49: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
        !            50: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
        !            51: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
        !            52: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
        !            53: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
        !            54: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
        !            55: SOFTWARE.
        !            56: 
        !            57: ******************************************************************/
        !            58: 
        !            59: /*
        !            60:  * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
        !            61:  */
        !            62: /* $Header: tp.trans,v 5.1 88/10/12 12:22:07 root Exp $
        !            63:  *
        !            64:  * Transition file for TP.
        !            65:  *
        !            66:  * DO NOT:
        !            67:  * - change the order of any of the events or states.  to do so will
        !            68:  *   make tppt, netstat, etc. cease working.
        !            69:  *
        !            70:  * NOTE:
        !            71:  * some hooks exist for data on (dis)connect, but it's ***NOT***SUPPORTED***
        !            72:  * (read: may not work!)
        !            73:  *
        !            74:  * I tried to put everything that causes a change of state in here, hence 
        !            75:  * there are some seemingly trivial events  like T_DETACH and T_LISTEN_req.
        !            76:  *
        !            77:  * Almost everything having to do w/ setting & cancelling timers is here
        !            78:  * but once it was debugged, I moved the setting of the 
        !            79:  * keepalive (sendack) timer to tp_emit(), where an AK_TPDU is sent.
        !            80:  * This is so the code wouldn't be duplicated all over creation in here.
        !            81:  *
        !            82:  */
        !            83: *PROTOCOL tp
        !            84: 
        !            85: *INCLUDE
        !            86: {
        !            87: /* @(#)tp.trans        7.9 (Berkeley) 5/7/91 */
        !            88: #include "param.h"
        !            89: #include "socket.h"
        !            90: #include "socketvar.h"
        !            91: #include "protosw.h"
        !            92: #include "mbuf.h"
        !            93: #include "time.h"
        !            94: #include "errno.h"
        !            95: #include "../netiso/tp_param.h"
        !            96: #include "../netiso/tp_stat.h"
        !            97: #include "../netiso/tp_pcb.h"
        !            98: #include "../netiso/tp_tpdu.h"
        !            99: #include "../netiso/argo_debug.h"
        !           100: #include "../netiso/tp_trace.h"
        !           101: #include "../netiso/iso_errno.h"
        !           102: #include "../netiso/tp_seq.h"
        !           103: #include "../netiso/cons.h"
        !           104: 
        !           105: #define DRIVERTRACE TPPTdriver
        !           106: #define sbwakeup(sb)   sowakeup(p->tp_sock, sb);
        !           107: #define MCPY(d, w) (d ? m_copym(d, 0, (int)M_COPYALL, w): 0)
        !           108: 
        !           109: static         trick_hc = 1;
        !           110: 
        !           111: int    tp_emit(),
        !           112:                tp_goodack(),                           tp_goodXack(),
        !           113:                tp_stash()
        !           114: ;
        !           115: void   tp_indicate(),                          tp_getoptions(),        
        !           116:                tp_soisdisconnecting(),         tp_soisdisconnected(),
        !           117:                tp_recycle_tsuffix(),           
        !           118:                tp_etimeout(),                          tp_euntimeout(),
        !           119:                tp_euntimeout_lss(),            tp_ctimeout(),
        !           120:                tp_cuntimeout(),                        tp_ctimeout_MIN(),
        !           121:                tp_freeref(),                           tp_detach(),
        !           122:                tp0_stash(),                            tp0_send(),
        !           123:                tp_netcmd(),                            tp_send()
        !           124: ;
        !           125: 
        !           126: typedef  struct tp_pcb tpcb_struct;
        !           127: 
        !           128: 
        !           129: }
        !           130: 
        !           131: *PCB    tpcb_struct    SYNONYM  P
        !           132: 
        !           133: *STATES
        !           134: 
        !           135: TP_CLOSED      
        !           136: TP_CRSENT
        !           137: TP_AKWAIT
        !           138: TP_OPEN
        !           139: TP_CLOSING 
        !           140: TP_REFWAIT
        !           141: TP_LISTENING   /* Local to this implementation */
        !           142: TP_CONFIRMING  /* Local to this implementation */
        !           143: 
        !           144: *EVENTS                { struct timeval e_time; }              SYNONYM  E
        !           145: 
        !           146:  /*
        !           147:   * C (typically cancelled) timers  - 
        !           148:   *
        !           149:   * let these be the first ones so for the sake of convenience
        !           150:   * their values are 0--> n-1
        !           151:   * DO NOT CHANGE THE ORDER OF THESE TIMER EVENTS!! 
        !           152:   */
        !           153:  TM_inact              
        !           154:  TM_retrans            
        !           155:                                /* TM_retrans is used for all 
        !           156:                                 * simple retransmissions - CR,CC,XPD,DR 
        !           157:                                 */
        !           158: 
        !           159:  TM_sendack            
        !           160:                                /* TM_sendack does dual duty - keepalive AND sendack.
        !           161:                                 * It's set w/ keepalive-ticks every time an ack is sent.
        !           162:                                 * (this is done in (void) tp_emit() ).
        !           163:                                 * It's cancelled and reset whenever a DT
        !           164:                                 * arrives and it doesn't require immediate acking.
        !           165:                                 * Note that in this case it's set w/ the minimum of
        !           166:                                 * its prev value and the sendack-ticks value so the 
        !           167:                                 * purpose of the keepalive is preserved.
        !           168:                                 */
        !           169:  TM_notused    
        !           170: 
        !           171:  /* 
        !           172:   * E (typically expired) timers - these may be in any order. 
        !           173:   * These cause procedures to be executed directly; may not
        !           174:   * cause an 'event' as we know them here.
        !           175:   */
        !           176:  TM_reference          { SeqNum e_low; SeqNum e_high; int e_retrans; }
        !           177:  TM_data_retrans       { SeqNum e_low; SeqNum e_high; int e_retrans; }
        !           178: 
        !           179: /* NOTE: in tp_input is a minor optimization that assumes that
        !           180:  * for all tpdu types that can take e_data and e_datalen, these
        !           181:  * fields fall in the same place in the event structure, that is,
        !           182:  * e_data is the first field and e_datalen is the 2nd field.
        !           183:  */
        !           184: 
        !           185:  ER_TPDU               {
        !           186:                                  u_char                e_reason;
        !           187:                                }
        !           188:  CR_TPDU               { struct mbuf   *e_data;        /* first field */
        !           189:                                  int                   e_datalen; /* 2nd field */
        !           190:                                  u_int                 e_cdt;
        !           191:                                }
        !           192:  DR_TPDU               { struct mbuf   *e_data;        /* first field */
        !           193:                                  int                   e_datalen; /* 2nd field */
        !           194:                                  u_short               e_sref;
        !           195:                                  u_char                e_reason;
        !           196:                                }
        !           197:  DC_TPDU               
        !           198:  CC_TPDU               { struct mbuf   *e_data;        /* first field */
        !           199:                                  int                   e_datalen; /* 2nd field */
        !           200:                                  u_short               e_sref;
        !           201:                                  u_int                 e_cdt;
        !           202:                                }
        !           203:  AK_TPDU               { u_int                 e_cdt;  
        !           204:                                  SeqNum                e_seq;          
        !           205:                                  SeqNum                e_subseq;               
        !           206:                                  u_char                e_fcc_present;          
        !           207:                                }
        !           208:  DT_TPDU               { struct mbuf   *e_data;        /* first field */
        !           209:                                  int                   e_datalen; /* 2nd field */
        !           210:                                  u_int                 e_eot;
        !           211:                                  SeqNum                e_seq; 
        !           212:                                }
        !           213:  XPD_TPDU              { struct mbuf   *e_data;        /* first field */
        !           214:                                  int                   e_datalen;      /* 2nd field */
        !           215:                                  SeqNum                e_seq;  
        !           216:                                }
        !           217:  XAK_TPDU              { SeqNum                e_seq;          }
        !           218: 
        !           219:  T_CONN_req 
        !           220:  T_DISC_req            { u_char                e_reason;       }
        !           221:  T_LISTEN_req
        !           222:  T_DATA_req
        !           223:  T_XPD_req     
        !           224:  T_USR_rcvd    
        !           225:  T_USR_Xrcvd   
        !           226:  T_DETACH
        !           227:  T_NETRESET
        !           228:  T_ACPT_req
        !           229: 
        !           230: 
        !           231: *TRANSITIONS
        !           232: 
        !           233: 
        !           234: /* TP_AKWAIT doesn't exist in TP 0 */
        !           235: SAME                   <==                     TP_AKWAIT                       [ CC_TPDU, DC_TPDU, XAK_TPDU ]
        !           236:        DEFAULT
        !           237:        NULLACTION
        !           238: ;
        !           239: 
        !           240: 
        !           241: /* applicable in TP4, TP0 */
        !           242: SAME                   <==                     TP_REFWAIT                                                              DR_TPDU
        !           243:        ( $$.e_sref !=  0 ) 
        !           244:        {
        !           245:                (void) tp_emit(DC_TPDU_type, $P, 0, 0, MNULL);
        !           246:        }
        !           247: ;
        !           248:        
        !           249: /* applicable in TP4, TP0 */
        !           250: SAME                   <==                     TP_REFWAIT                      [ CR_TPDU, CC_TPDU, DT_TPDU, 
        !           251:                                        DR_TPDU, XPD_TPDU, AK_TPDU, XAK_TPDU, DC_TPDU, ER_TPDU ]
        !           252:        DEFAULT
        !           253:        {
        !           254: #              ifdef TP_DEBUG
        !           255:                if( $E.ev_number != AK_TPDU )
        !           256:                        printf("TPDU 0x%x in REFWAIT!!!!\n", $E.ev_number);
        !           257: #              endif TP_DEBUG
        !           258:        }
        !           259: ;
        !           260: 
        !           261: /* applicable in TP4, TP0 */
        !           262: SAME                   <==                     TP_REFWAIT                              [ T_DETACH, T_DISC_req ]
        !           263:        DEFAULT
        !           264:        NULLACTION
        !           265: ;
        !           266: 
        !           267: /* applicable in TP4, TP0 */
        !           268: SAME                   <==                     TP_CRSENT                                                                AK_TPDU
        !           269:        ($P.tp_class == TP_CLASS_0)
        !           270:        {
        !           271:                /* oh, man is this grotesque or what? */
        !           272:                (void) tp_goodack($P, $$.e_cdt, $$.e_seq,  $$.e_subseq);
        !           273:                /* but it's necessary because this pseudo-ack may happen
        !           274:                 * before the CC arrives, but we HAVE to adjust the
        !           275:                 * snduna as a result of the ack, WHENEVER it arrives
        !           276:                 */
        !           277:        }
        !           278: ;
        !           279: 
        !           280: /* applicable in TP4, TP0 */
        !           281: SAME                   <==                     TP_CRSENT       
        !           282:                                        [ CR_TPDU, DC_TPDU, DT_TPDU, XPD_TPDU,  XAK_TPDU ]
        !           283:        DEFAULT
        !           284:        NULLACTION
        !           285: ;
        !           286: 
        !           287: /* applicable in TP4, TP0 */
        !           288: SAME                   <==                     TP_CLOSED                                       [ DT_TPDU, XPD_TPDU,
        !           289:                                                                                ER_TPDU, DC_TPDU, AK_TPDU, XAK_TPDU ] 
        !           290:        DEFAULT
        !           291:        NULLACTION
        !           292: ;
        !           293: 
        !           294: /* TP_CLOSING doesn't exist in TP 0 */
        !           295: SAME                   <==             TP_CLOSING
        !           296:                                        [ CC_TPDU, CR_TPDU, DT_TPDU, XPD_TPDU, AK_TPDU, XAK_TPDU ]
        !           297:        DEFAULT
        !           298:        NULLACTION
        !           299: ;
        !           300: 
        !           301: 
        !           302: /* DC_TPDU doesn't exist in TP 0 */
        !           303: SAME                   <==                     TP_OPEN                                           DC_TPDU
        !           304:        DEFAULT
        !           305:        NULLACTION
        !           306: ;
        !           307: 
        !           308: /* applicable in TP4, TP0 */
        !           309: SAME                   <==                     TP_LISTENING  [DR_TPDU, CC_TPDU, DT_TPDU, XPD_TPDU,
        !           310:                                                                                 ER_TPDU, DC_TPDU, AK_TPDU, XAK_TPDU ] 
        !           311:        DEFAULT 
        !           312:        NULLACTION
        !           313: ;
        !           314: 
        !           315: /* applicable in TP4, TP0 */
        !           316: TP_LISTENING   <==                     TP_CLOSED                                                       T_LISTEN_req 
        !           317:        DEFAULT
        !           318:        NULLACTION
        !           319: ;
        !           320: 
        !           321: /* applicable in TP4, TP0 */
        !           322: TP_CLOSED              <==             [ TP_LISTENING, TP_CLOSED ]                     T_DETACH
        !           323:        DEFAULT
        !           324:        {
        !           325:                tp_detach($P);
        !           326:        }
        !           327: ;
        !           328: 
        !           329: TP_CONFIRMING  <==              TP_LISTENING                                                           CR_TPDU 
        !           330:        ( $P.tp_class == TP_CLASS_0)
        !           331:        {
        !           332:                $P.tp_refp->tpr_state = REF_OPEN; /* has timers ??? */
        !           333:        }
        !           334: ;
        !           335: 
        !           336: TP_CONFIRMING          <==              TP_LISTENING                                                   CR_TPDU 
        !           337:        DEFAULT
        !           338:        {
        !           339:                IFTRACE(D_CONN)
        !           340:                        tptrace(TPPTmisc, "CR datalen data", $$.e_datalen, $$.e_data,0,0);
        !           341:                ENDTRACE
        !           342:                IFDEBUG(D_CONN)
        !           343:                        printf("CR datalen 0x%x data 0x%x", $$.e_datalen, $$.e_data);
        !           344:                ENDDEBUG
        !           345:                $P.tp_refp->tpr_state = REF_OPEN; /* has timers */
        !           346:                $P.tp_fcredit = $$.e_cdt;
        !           347: 
        !           348:                if ($$.e_datalen > 0) {
        !           349:                        /* n/a for class 0 */
        !           350:                        ASSERT($P.tp_Xrcv.sb_cc == 0); 
        !           351:                        sbappendrecord(&$P.tp_Xrcv, $$.e_data);
        !           352:                        $$.e_data = MNULL; 
        !           353:                } 
        !           354:        }
        !           355: ;
        !           356: 
        !           357: TP_OPEN                <==              TP_CONFIRMING                                                                  T_ACPT_req 
        !           358:        ( $P.tp_class == TP_CLASS_0 )
        !           359:        {
        !           360:                IncStat(ts_tp0_conn);
        !           361:                IFTRACE(D_CONN)
        !           362:                        tptrace(TPPTmisc, "Confiming", $P, 0,0,0);
        !           363:                ENDTRACE
        !           364:                IFDEBUG(D_CONN)
        !           365:                        printf("Confirming connection: $P" );
        !           366:                ENDDEBUG
        !           367:                soisconnected($P.tp_sock);
        !           368:                (void) tp_emit(CC_TPDU_type, $P, 0,0, MNULL) ;
        !           369:                $P.tp_fcredit = 1;
        !           370:        }
        !           371: ;
        !           372: 
        !           373: TP_AKWAIT              <==              TP_CONFIRMING                                                          T_ACPT_req
        !           374:        (tp_emit(CC_TPDU_type, $P, 0,0, MCPY($P.tp_ucddata, M_NOWAIT)) == 0)
        !           375:        {
        !           376:                IncStat(ts_tp4_conn); /* even though not quite open */
        !           377:                IFTRACE(D_CONN)
        !           378:                        tptrace(TPPTmisc, "Confiming", $P, 0,0,0);
        !           379:                ENDTRACE
        !           380:                IFDEBUG(D_CONN)
        !           381:                        printf("Confirming connection: $P" );
        !           382:                ENDDEBUG
        !           383:                soisconnecting($P.tp_sock);
        !           384:                if (($P.tp_rx_strat & TPRX_FASTSTART) && ($P.tp_fcredit > 0))
        !           385:                        $P.tp_cong_win = $P.tp_fcredit;
        !           386:                $P.tp_retrans = $P.tp_Nretrans;
        !           387:                tp_ctimeout($P.tp_refp, TM_retrans, (int)$P.tp_cc_ticks);
        !           388:        }
        !           389: ;
        !           390: 
        !           391: /* TP4 only */
        !           392: TP_CLOSED              <==              TP_CONFIRMING                                                          T_ACPT_req
        !           393:        DEFAULT /* emit failed */
        !           394:        {
        !           395:                register struct tp_ref *r = $P.tp_refp;
        !           396: 
        !           397:                IFDEBUG(D_CONN)
        !           398:                        printf("event: CR_TPDU emit CC failed done " );
        !           399:                ENDDEBUG
        !           400:                soisdisconnected($P.tp_sock);
        !           401:                tp_recycle_tsuffix( $P );
        !           402:                tp_freeref(r);
        !           403:                tp_detach($P);
        !           404:        }
        !           405: ;
        !           406: 
        !           407: /* applicable in TP4, TP0 */
        !           408: TP_CRSENT              <==             TP_CLOSED                                                               T_CONN_req 
        !           409:        DEFAULT
        !           410:        {
        !           411:                int error;
        !           412:                struct mbuf *data = MNULL;
        !           413: 
        !           414:                IFTRACE(D_CONN)
        !           415:                        tptrace(TPPTmisc, "T_CONN_req flags ucddata", (int)$P.tp_flags,
        !           416:                        $P.tp_ucddata, 0, 0);
        !           417:                ENDTRACE
        !           418:                data =  MCPY($P.tp_ucddata, M_WAIT);
        !           419:                if (data) {
        !           420:                        IFDEBUG(D_CONN)
        !           421:                                printf("T_CONN_req.trans m_copy cc 0x%x\n", 
        !           422:                                        $P.tp_ucddata);
        !           423:                                dump_mbuf(data, "sosnd @ T_CONN_req");
        !           424:                        ENDDEBUG
        !           425:                }
        !           426: 
        !           427:                if (error = tp_emit(CR_TPDU_type, $P, 0, 0, data) )
        !           428:                        return error; /* driver WON'T change state; will return error */
        !           429:                
        !           430:                $P.tp_refp->tpr_state = REF_OPEN; /* has timers */
        !           431:                if($P.tp_class != TP_CLASS_0) {
        !           432:                        $P.tp_retrans = $P.tp_Nretrans;
        !           433:                        tp_ctimeout($P.tp_refp, TM_retrans, (int)$P.tp_cr_ticks);
        !           434:                }
        !           435:        }
        !           436: ;
        !           437: 
        !           438: /* applicable in TP4, TP0, but state TP_AKWAIT doesn't apply to TP0 */
        !           439: TP_REFWAIT             <==             [ TP_CRSENT, TP_AKWAIT, TP_OPEN ]                       DR_TPDU 
        !           440:        DEFAULT
        !           441:        {
        !           442:                sbflush(&$P.tp_Xrcv); /* purge non-delivered data data */
        !           443:                if ($$.e_datalen > 0) {
        !           444:                        sbappendrecord(&$P.tp_Xrcv, $$.e_data);
        !           445:                        $$.e_data = MNULL;
        !           446:                } 
        !           447:                tp_indicate(T_DISCONNECT, $P, 0);
        !           448:                tp_soisdisconnected($P);
        !           449:                if ($P.tp_class != TP_CLASS_0) {
        !           450:                        if ($P.tp_state == TP_OPEN ) {
        !           451:                                tp_euntimeout($P.tp_refp, TM_data_retrans); /* all */
        !           452:                                tp_cuntimeout($P.tp_refp, TM_retrans);
        !           453:                                tp_cuntimeout($P.tp_refp, TM_inact);
        !           454:                                tp_cuntimeout($P.tp_refp, TM_sendack);
        !           455:                        }
        !           456:                        tp_cuntimeout($P.tp_refp, TM_retrans);
        !           457:                        if( $$.e_sref !=  0 ) 
        !           458:                                (void) tp_emit(DC_TPDU_type, $P, 0, 0, MNULL);
        !           459:                }
        !           460:        }
        !           461: ;
        !           462: 
        !           463: SAME                   <==             TP_CLOSED                                                                       DR_TPDU 
        !           464:        DEFAULT
        !           465:        {
        !           466:                if( $$.e_sref != 0 )
        !           467:                        (void) tp_emit(DC_TPDU_type, $P, 0, 0, MNULL); 
        !           468:                /* reference timer already set - reset it to be safe (???) */
        !           469:                tp_euntimeout($P.tp_refp, TM_reference); /* all */
        !           470:                tp_etimeout($P.tp_refp, TM_reference, 0, 0, 0, (int)$P.tp_refer_ticks);
        !           471:        }
        !           472: ;
        !           473: 
        !           474: /* NBS(34) */
        !           475: TP_REFWAIT             <==     TP_CRSENT                                                                       ER_TPDU
        !           476:        DEFAULT
        !           477:        {       
        !           478:                tp_cuntimeout($P.tp_refp, TM_retrans);
        !           479:                tp_indicate(ER_TPDU, $P, $$.e_reason);
        !           480:                tp_soisdisconnected($P);
        !           481:        }
        !           482: ;
        !           483: 
        !           484: /* NBS(27) */
        !           485: TP_REFWAIT             <==             TP_CLOSING                                                                      DR_TPDU
        !           486:        DEFAULT
        !           487:        {        
        !           488:                tp_cuntimeout($P.tp_refp, TM_retrans);
        !           489:                tp_soisdisconnected($P);
        !           490:        }
        !           491: ;
        !           492: /* these two transitions are the same but can't be combined because xebec
        !           493:  * can't handle the use of $$.e_reason if they're combined
        !           494:  */
        !           495: /* NBS(27) */
        !           496: TP_REFWAIT             <==             TP_CLOSING                                                                      ER_TPDU
        !           497:        DEFAULT
        !           498:        {        
        !           499:                tp_indicate(ER_TPDU, $P, $$.e_reason);
        !           500:                tp_cuntimeout($P.tp_refp, TM_retrans);
        !           501:                tp_soisdisconnected($P);
        !           502:        }
        !           503: ;
        !           504: /* NBS(27) */
        !           505: TP_REFWAIT             <==             TP_CLOSING                                                                      DC_TPDU 
        !           506:        DEFAULT
        !           507:        {        
        !           508:                tp_cuntimeout($P.tp_refp, TM_retrans);
        !           509:                tp_soisdisconnected($P);
        !           510:        }
        !           511: ;
        !           512: 
        !           513: /* NBS(21) */
        !           514: SAME                   <==     TP_CLOSED                                               [ CC_TPDU, CR_TPDU ]
        !           515:        DEFAULT
        !           516:        {       /* don't ask me why we have to do this - spec says so */
        !           517:                (void) tp_emit(DR_TPDU_type, $P, 0, E_TP_NO_SESSION, MNULL);
        !           518:                /* don't bother with retransmissions of the DR */
        !           519:        }
        !           520: ;
        !           521: 
        !           522: /* NBS(34) */
        !           523: TP_REFWAIT             <==     TP_OPEN                                                                         ER_TPDU
        !           524:        ($P.tp_class == TP_CLASS_0)
        !           525:        {
        !           526:                tp_soisdisconnecting($P.tp_sock);
        !           527:                tp_indicate(ER_TPDU, $P, $$.e_reason);
        !           528:                tp_soisdisconnected($P);
        !           529:                tp_netcmd( $P, CONN_CLOSE );
        !           530:        }
        !           531: ;
        !           532: 
        !           533: TP_CLOSING             <==     [ TP_AKWAIT, TP_OPEN ]                                          ER_TPDU
        !           534:        DEFAULT
        !           535:        {
        !           536:                if ($P.tp_state == TP_OPEN) {
        !           537:                        tp_euntimeout($P.tp_refp, TM_data_retrans); /* all */
        !           538:                        tp_cuntimeout($P.tp_refp, TM_inact);
        !           539:                        tp_cuntimeout($P.tp_refp, TM_sendack);
        !           540:                }
        !           541:                tp_soisdisconnecting($P.tp_sock);
        !           542:                tp_indicate(ER_TPDU, $P, $$.e_reason);
        !           543:                $P.tp_retrans = $P.tp_Nretrans;
        !           544:                tp_ctimeout($P.tp_refp, TM_retrans, (int)$P.tp_dr_ticks);
        !           545:                (void) tp_emit(DR_TPDU_type, $P, 0, E_TP_PROTO_ERR, MNULL);
        !           546:        }
        !           547: ;
        !           548: /* NBS(6) */
        !           549: TP_OPEN                        <==             TP_CRSENT                                                                       CC_TPDU 
        !           550:        ($P.tp_class == TP_CLASS_0) 
        !           551:        {       
        !           552:                tp_cuntimeout($P.tp_refp, TM_retrans);
        !           553:                IncStat(ts_tp0_conn);
        !           554:                $P.tp_fcredit = 1;
        !           555:                soisconnected($P.tp_sock);
        !           556:        }
        !           557: ;
        !           558: 
        !           559: TP_OPEN                        <==             TP_CRSENT                                                                       CC_TPDU 
        !           560:        DEFAULT
        !           561:        {       
        !           562:                IFDEBUG(D_CONN)
        !           563:                        printf("trans: CC_TPDU in CRSENT state flags 0x%x\n", 
        !           564:                                (int)$P.tp_flags);
        !           565:                ENDDEBUG
        !           566:                IncStat(ts_tp4_conn);
        !           567:                $P.tp_fref = $$.e_sref;
        !           568:                $P.tp_fcredit = $$.e_cdt;
        !           569:                $P.tp_ackrcvd = 0;
        !           570:                if (($P.tp_rx_strat & TPRX_FASTSTART) && ($$.e_cdt > 0))
        !           571:                        $P.tp_cong_win = $$.e_cdt;
        !           572:                tp_getoptions($P);
        !           573:                tp_cuntimeout($P.tp_refp, TM_retrans);
        !           574:                if ($P.tp_ucddata) {
        !           575:                        IFDEBUG(D_CONN)
        !           576:                                printf("dropping user connect data cc 0x%x\n",
        !           577:                                        $P.tp_ucddata->m_len);
        !           578:                        ENDDEBUG
        !           579:                        m_freem($P.tp_ucddata);
        !           580:                        $P.tp_ucddata = 0;
        !           581:                }
        !           582:                soisconnected($P.tp_sock);
        !           583:                if ($$.e_datalen > 0) {
        !           584:                        ASSERT($P.tp_Xrcv.sb_cc == 0); /* should be empty */
        !           585:                        sbappendrecord(&$P.tp_Xrcv, $$.e_data);
        !           586:                        $$.e_data = MNULL;
        !           587:                }
        !           588: 
        !           589:                (void) tp_emit(AK_TPDU_type, $P, $P.tp_rcvnxt, 0, MNULL);
        !           590:                tp_ctimeout($P.tp_refp, TM_inact, (int)$P.tp_inact_ticks);
        !           591:        }
        !           592: ;
        !           593: 
        !           594: /* TP4 only */
        !           595: SAME                   <==             TP_CRSENT                                                                       TM_retrans 
        !           596:        (       $P.tp_retrans > 0 )
        !           597:        {
        !           598:                struct mbuf *data = MNULL;
        !           599:                int error;
        !           600: 
        !           601:                IncStat(ts_retrans_cr);
        !           602:                $P.tp_cong_win = 1;
        !           603:                $P.tp_ackrcvd = 0;
        !           604:                data = MCPY($P.tp_ucddata, M_NOWAIT);
        !           605:                if($P.tp_ucddata) {
        !           606:                        IFDEBUG(D_CONN)
        !           607:                                printf("TM_retrans.trans m_copy cc 0x%x\n", data);
        !           608:                                dump_mbuf($P.tp_ucddata, "sosnd @ TM_retrans");
        !           609:                        ENDDEBUG
        !           610:                        if( data == MNULL )
        !           611:                                return ENOBUFS;
        !           612:                }
        !           613: 
        !           614:                $P.tp_retrans --;
        !           615:                if( error = tp_emit(CR_TPDU_type, $P, 0, 0, data) ) {
        !           616:                        $P.tp_sock->so_error = error;
        !           617:                }
        !           618:                tp_ctimeout($P.tp_refp, TM_retrans, (int)$P.tp_cr_ticks);
        !           619:        }
        !           620: ;
        !           621: 
        !           622: /* TP4 only  */
        !           623: TP_REFWAIT             <==             TP_CRSENT                                                                       TM_retrans 
        !           624:        DEFAULT /* no more CR retransmissions */
        !           625:        {       
        !           626:                IncStat(ts_conn_gaveup);
        !           627:                $P.tp_sock->so_error = ETIMEDOUT;
        !           628:                tp_indicate(T_DISCONNECT, $P, ETIMEDOUT);
        !           629:                tp_soisdisconnected($P);
        !           630:        }
        !           631: ;
        !           632: 
        !           633: /* TP4 only */
        !           634: SAME                   <==      TP_AKWAIT                                                                                      CR_TPDU 
        !           635:        DEFAULT
        !           636:        /* duplicate CR (which doesn't really exist in the context of
        !           637:         * a connectionless network layer) 
        !           638:         * Doesn't occur in class 0.
        !           639:         */
        !           640:        {       
        !           641:                int error;
        !           642:                struct mbuf *data = MCPY($P.tp_ucddata, M_WAIT);
        !           643: 
        !           644:                if( error = tp_emit(CC_TPDU_type, $P, 0, 0, data) ) {
        !           645:                        $P.tp_sock->so_error = error;
        !           646:                }
        !           647:                $P.tp_retrans = $P.tp_Nretrans;
        !           648:                tp_ctimeout($P.tp_refp, TM_retrans, (int)$P.tp_cc_ticks);
        !           649:        }
        !           650: ;
        !           651: 
        !           652: /* TP4 only */
        !           653: TP_OPEN                        <==             TP_AKWAIT                                                                               DT_TPDU 
        !           654:        ( IN_RWINDOW( $P, $$.e_seq,
        !           655:                                        $P.tp_rcvnxt, SEQ($P, $P.tp_rcvnxt + $P.tp_lcredit)) )
        !           656:        {
        !           657:                int doack;
        !           658: 
        !           659:                /*
        !           660:                 * Get rid of any confirm or connect data, so that if we
        !           661:                 * crash or close, it isn't thought of as disconnect data.
        !           662:                 */
        !           663:                if ($P.tp_ucddata) {
        !           664:                        m_freem($P.tp_ucddata);
        !           665:                        $P.tp_ucddata = 0;
        !           666:                }
        !           667:                tp_ctimeout($P.tp_refp, TM_inact, (int)$P.tp_inact_ticks);
        !           668:                tp_cuntimeout($P.tp_refp, TM_retrans);
        !           669:                soisconnected($P.tp_sock);
        !           670:                tp_getoptions($P);
        !           671:                tp_ctimeout($P.tp_refp, TM_inact, (int)$P.tp_inact_ticks);
        !           672: 
        !           673:                /* see also next 2 transitions, if you make any changes */
        !           674: 
        !           675:                doack = tp_stash($P, $E);
        !           676:                IFDEBUG(D_DATA)
        !           677:                        printf("tp_stash returns %d\n",doack);
        !           678:                ENDDEBUG
        !           679: 
        !           680:                if(doack) {
        !           681:                        (void) tp_emit(AK_TPDU_type, $P, $P.tp_rcvnxt, 0, MNULL ); 
        !           682:                        tp_ctimeout($P.tp_refp, TM_sendack, (int)$P.tp_keepalive_ticks);
        !           683:                } else
        !           684:                        tp_ctimeout( $P.tp_refp, TM_sendack, (int)$P.tp_sendack_ticks);
        !           685:                
        !           686:                IFDEBUG(D_DATA)
        !           687:                        printf("after stash calling sbwakeup\n");
        !           688:                ENDDEBUG
        !           689:        }
        !           690: ;
        !           691: 
        !           692: SAME                   <==             TP_OPEN                                                                         DT_TPDU 
        !           693:        ( $P.tp_class == TP_CLASS_0 )
        !           694:        {
        !           695:                tp0_stash($P, $E);
        !           696:                sbwakeup( &$P.tp_sock->so_rcv );
        !           697: 
        !           698:                IFDEBUG(D_DATA)
        !           699:                        printf("after stash calling sbwakeup\n");
        !           700:                ENDDEBUG
        !           701:        }
        !           702: ;
        !           703: 
        !           704: /* TP4 only */
        !           705: SAME                   <==             TP_OPEN                                                                         DT_TPDU 
        !           706:        ( IN_RWINDOW( $P, $$.e_seq,
        !           707:                                        $P.tp_rcvnxt, SEQ($P, $P.tp_rcvnxt + $P.tp_lcredit)) )
        !           708:        {
        !           709:                int doack; /* tells if we must ack immediately */
        !           710: 
        !           711:                tp_ctimeout($P.tp_refp, TM_inact, (int)$P.tp_inact_ticks);
        !           712:                sbwakeup( &$P.tp_sock->so_rcv );
        !           713: 
        !           714:                doack = tp_stash($P, $E);
        !           715:                IFDEBUG(D_DATA)
        !           716:                        printf("tp_stash returns %d\n",doack);
        !           717:                ENDDEBUG
        !           718: 
        !           719:                if(doack)
        !           720:                        (void) tp_emit(AK_TPDU_type, $P, $P.tp_rcvnxt, 0, MNULL ); 
        !           721:                else
        !           722:                        tp_ctimeout_MIN( $P.tp_refp, TM_sendack, (int)$P.tp_sendack_ticks);
        !           723:                
        !           724:                IFDEBUG(D_DATA)
        !           725:                        printf("after stash calling sbwakeup\n");
        !           726:                ENDDEBUG
        !           727:        }
        !           728: ;
        !           729: 
        !           730: /* Not in window  - we must ack under certain circumstances, namely
        !           731:  * a) if the seq number is below lwe but > lwe - (max credit ever given)
        !           732:  * (to handle lost acks) Can use max-possible-credit for this ^^^.
        !           733:  * and 
        !           734:  * b) seq number is > uwe but < uwe + previously sent & withdrawn credit
        !           735:  *
        !           736:  * (see 12.2.3.8.1 of ISO spec, p. 73)
        !           737:  * We just always ack.
        !           738:  */
        !           739: /* TP4 only */
        !           740: SAME                   <==     [ TP_OPEN, TP_AKWAIT ]                                                  DT_TPDU
        !           741:        DEFAULT /* Not in window */
        !           742:        {       
        !           743:                IFTRACE(D_DATA)
        !           744:                        tptrace(TPPTmisc, "NIW seq rcvnxt lcredit ",
        !           745:                                $$.e_seq, $P.tp_rcvnxt, $P.tp_lcredit, 0);
        !           746:                ENDTRACE
        !           747:                IncStat(ts_dt_niw);
        !           748:                m_freem($$.e_data);
        !           749:                tp_ctimeout($P.tp_refp, TM_inact, (int)$P.tp_inact_ticks);
        !           750:                (void) tp_emit(AK_TPDU_type, $P, $P.tp_rcvnxt, 0, MNULL ); 
        !           751:        }
        !           752: ;
        !           753: 
        !           754: /* TP4 only */
        !           755: TP_OPEN                        <==             TP_AKWAIT                                                                               AK_TPDU
        !           756:        DEFAULT
        !           757:        {
        !           758:                if ($P.tp_ucddata) {
        !           759:                        m_freem($P.tp_ucddata);
        !           760:                        $P.tp_ucddata = 0;
        !           761:                }
        !           762:                (void) tp_goodack($P, $$.e_cdt, $$.e_seq, $$.e_subseq);
        !           763:                tp_cuntimeout($P.tp_refp, TM_retrans);
        !           764: 
        !           765:                tp_getoptions($P);
        !           766:                soisconnected($P.tp_sock);
        !           767:                IFTRACE(D_CONN)
        !           768:                        struct socket *so = $P.tp_sock;
        !           769:                        tptrace(TPPTmisc, 
        !           770:                        "called sosiconn: so so_state rcv.sb_sel rcv.sb_flags",
        !           771:                                so, so->so_state, so->so_rcv.sb_sel, so->so_rcv.sb_flags);
        !           772:                        tptrace(TPPTmisc, 
        !           773:                        "called sosiconn 2: so_qlen so_error so_rcv.sb_cc so_head",
        !           774:                                so->so_qlen, so->so_error, so->so_rcv.sb_cc, so->so_head);
        !           775:                ENDTRACE
        !           776: 
        !           777:                tp_ctimeout($P.tp_refp, TM_sendack, (int)$P.tp_keepalive_ticks);
        !           778:                tp_ctimeout($P.tp_refp, TM_inact, (int)$P.tp_inact_ticks);
        !           779:        }
        !           780: ;
        !           781: 
        !           782: /* TP4 only */
        !           783: TP_OPEN                <==     [ TP_OPEN, TP_AKWAIT ]                                          XPD_TPDU
        !           784:        ($P.tp_Xrcvnxt == $$.e_seq)
        !           785:        {
        !           786:                if( $P.tp_state == TP_AKWAIT ) {
        !           787:                        if ($P.tp_ucddata) {
        !           788:                                m_freem($P.tp_ucddata);
        !           789:                                $P.tp_ucddata = 0;
        !           790:                        }
        !           791:                        tp_cuntimeout($P.tp_refp, TM_retrans);
        !           792:                        tp_getoptions($P);
        !           793:                        soisconnected($P.tp_sock);
        !           794:                        tp_ctimeout($P.tp_refp, TM_sendack, (int)$P.tp_keepalive_ticks);
        !           795:                        tp_ctimeout($P.tp_refp, TM_inact, (int)$P.tp_inact_ticks);
        !           796:                } 
        !           797:                IFTRACE(D_XPD)
        !           798:                tptrace(TPPTmisc, "XPD tpdu accepted Xrcvnxt, e_seq datalen m_len\n",
        !           799:                                $P.tp_Xrcvnxt,$$.e_seq,  $$.e_datalen, $$.e_data->m_len);
        !           800:                ENDTRACE
        !           801: 
        !           802:                $P.tp_sock->so_state |= SS_RCVATMARK;
        !           803:                $$.e_data->m_flags |= M_EOR;
        !           804:                sbinsertoob(&$P.tp_Xrcv, $$.e_data);
        !           805:                IFDEBUG(D_XPD)
        !           806:                        dump_mbuf($$.e_data, "XPD TPDU: tp_Xrcv");
        !           807:                ENDDEBUG
        !           808:                tp_indicate(T_XDATA, $P, 0);
        !           809:                sbwakeup( &$P.tp_Xrcv );
        !           810: 
        !           811:                (void) tp_emit(XAK_TPDU_type, $P, $P.tp_Xrcvnxt, 0, MNULL);
        !           812:                SEQ_INC($P, $P.tp_Xrcvnxt);
        !           813:        }
        !           814: ;
        !           815: 
        !           816: /* TP4 only */
        !           817: SAME                   <==             TP_OPEN                                                                         T_USR_Xrcvd
        !           818:        DEFAULT
        !           819:        {
        !           820:                if( $P.tp_Xrcv.sb_cc == 0 ) {
        !           821:                        /* kludge for select(): */ 
        !           822:                        /* $P.tp_sock->so_state &= ~SS_OOBAVAIL; */
        !           823:                }
        !           824:        }
        !           825:        /* OLD WAY:
        !           826:         * Ack only after the user receives the XPD.  This is better for 
        !           827:         * users that use one XPD right after another.
        !           828:         * Acking right away (the NEW WAY, see the prev. transition) is 
        !           829:         * better for occasional * XPD, when the receiving user doesn't 
        !           830:         * want to read the XPD immediately (which is session's behavior).
        !           831:         *
        !           832:                int error = tp_emit(XAK_TPDU_type, $P, $P.tp_Xrcvnxt, 0, MNULL);
        !           833:                SEQ_INC($P, $P.tp_Xrcvnxt);
        !           834:                return error;
        !           835:        */
        !           836: ;
        !           837: 
        !           838: /* NOTE: presently if the user doesn't read the connection data
        !           839:  * before and expedited data PDU comes in, the connection data will
        !           840:  * be dropped. This is a bug.  To avoid it, we need somewhere else
        !           841:  * to put the connection data.
        !           842:  * On the other hand, we need not to have it sitting around forever.
        !           843:  * This is a problem with the idea of trying to accommodate
        !           844:  * data on connect w/ a passive-open user interface. 
        !           845:  */
        !           846: /* TP4 only */
        !           847: 
        !           848: SAME                   <==     [ TP_AKWAIT, TP_OPEN ]                                                  XPD_TPDU
        !           849:        DEFAULT /* not in window or cdt==0 */
        !           850:        {
        !           851:                IFTRACE(D_XPD)
        !           852:                        tptrace(TPPTmisc, "XPD tpdu niw (Xrcvnxt, e_seq) or not cdt (cc)\n",
        !           853:                                $P.tp_Xrcvnxt, $$.e_seq,  $P.tp_Xrcv.sb_cc , 0);
        !           854:                ENDTRACE
        !           855:                if( $P.tp_Xrcvnxt != $$.e_seq )
        !           856:                        IncStat(ts_xpd_niw);
        !           857:                if( $P.tp_Xrcv.sb_cc ) {
        !           858:                        /* might as well kick 'em again */
        !           859:                        tp_indicate(T_XDATA, $P, 0);
        !           860:                        IncStat(ts_xpd_dup);
        !           861:                }
        !           862:                m_freem($$.e_data);
        !           863:                tp_ctimeout($P.tp_refp, TM_inact, (int)$P.tp_inact_ticks);
        !           864:                /* don't send an xack because the xak gives "last one received", not
        !           865:                 * "next one i expect" (dumb)
        !           866:                 */
        !           867:        }
        !           868: ;
        !           869: 
        !           870: /* Occurs (AKWAIT, OPEN) when parent (listening) socket gets aborted, and tries
        !           871:  * to detach all its "children"
        !           872:  * Also (CRSENT) when user kills a job that's doing a connect()
        !           873:  */
        !           874: TP_REFWAIT             <==     TP_CRSENT                                                                               T_DETACH
        !           875:        ($P.tp_class == TP_CLASS_0)
        !           876:        {
        !           877:                struct socket *so = $P.tp_sock;
        !           878: 
        !           879:                /* detach from parent socket so it can finish closing */
        !           880:                if (so->so_head) {
        !           881:                        if (!soqremque(so, 0) && !soqremque(so, 1))
        !           882:                                panic("tp: T_DETACH");
        !           883:                        so->so_head = 0;
        !           884:                }
        !           885:                tp_soisdisconnecting($P.tp_sock);
        !           886:                tp_netcmd( $P, CONN_CLOSE);
        !           887:                tp_soisdisconnected($P);
        !           888:        }
        !           889: ;
        !           890: 
        !           891: /* TP4 only */
        !           892: TP_CLOSING             <== [ TP_CLOSING, TP_AKWAIT, TP_CRSENT, TP_CONFIRMING ] T_DETACH
        !           893:        DEFAULT
        !           894:        {
        !           895:                struct socket *so = $P.tp_sock;
        !           896:                struct mbuf *data = MNULL;
        !           897: 
        !           898:                /* detach from parent socket so it can finish closing */
        !           899:                if (so->so_head) {
        !           900:                        if (!soqremque(so, 0) && !soqremque(so, 1))
        !           901:                                panic("tp: T_DETACH");
        !           902:                        so->so_head = 0;
        !           903:                }
        !           904:                if ($P.tp_state != TP_CLOSING) {
        !           905:                        tp_soisdisconnecting($P.tp_sock);
        !           906:                        data = MCPY($P.tp_ucddata, M_NOWAIT);
        !           907:                        (void) tp_emit(DR_TPDU_type, $P, 0, E_TP_NORMAL_DISC, data);
        !           908:                        $P.tp_retrans = $P.tp_Nretrans;
        !           909:                        tp_ctimeout($P.tp_refp, TM_retrans, (int)$P.tp_dr_ticks);
        !           910:                }
        !           911:        }
        !           912: ;
        !           913: 
        !           914: TP_REFWAIT             <==             [ TP_OPEN, TP_CRSENT ]                                          T_DISC_req
        !           915:        ( $P.tp_class == TP_CLASS_0 )
        !           916:        {
        !           917:                tp_soisdisconnecting($P.tp_sock);
        !           918:                tp_netcmd( $P, CONN_CLOSE);
        !           919:                tp_soisdisconnected($P);
        !           920:        }
        !           921: ;
        !           922: 
        !           923: /* TP4 only */
        !           924: TP_CLOSING             <==     [ TP_AKWAIT, TP_OPEN, TP_CRSENT, TP_CONFIRMING ]  T_DISC_req
        !           925:        DEFAULT
        !           926:        {
        !           927:                struct mbuf *data = MCPY($P.tp_ucddata, M_WAIT);
        !           928: 
        !           929:                if($P.tp_state == TP_OPEN) {
        !           930:                        tp_euntimeout($P.tp_refp, TM_data_retrans); /* all */
        !           931:                        tp_cuntimeout($P.tp_refp, TM_inact);
        !           932:                        tp_cuntimeout($P.tp_refp, TM_sendack);
        !           933:                }
        !           934:                if (data) {
        !           935:                        IFDEBUG(D_CONN)
        !           936:                                printf("T_DISC_req.trans tp_ucddata 0x%x\n", 
        !           937:                                        $P.tp_ucddata);
        !           938:                                dump_mbuf(data, "ucddata @ T_DISC_req");
        !           939:                        ENDDEBUG
        !           940:                }
        !           941:                tp_soisdisconnecting($P.tp_sock);
        !           942:                $P.tp_retrans = $P.tp_Nretrans;
        !           943:                tp_ctimeout($P.tp_refp, TM_retrans, (int)$P.tp_dr_ticks);
        !           944: 
        !           945:                if( trick_hc )
        !           946:                        return tp_emit(DR_TPDU_type, $P, 0, $$.e_reason, data);
        !           947:        }
        !           948: ;
        !           949: 
        !           950: /* TP4 only */
        !           951: SAME                   <==             TP_AKWAIT                                                                       TM_retrans
        !           952:        ( $P.tp_retrans > 0 )
        !           953:        {
        !           954:                int error;
        !           955:                struct mbuf *data = MCPY($P.tp_ucddata, M_WAIT);
        !           956: 
        !           957:                IncStat(ts_retrans_cc);
        !           958:                $P.tp_retrans --;
        !           959:                $P.tp_cong_win = 1;
        !           960:                $P.tp_ackrcvd = 0;
        !           961: 
        !           962:                if( error = tp_emit(CC_TPDU_type, $P, 0, 0, data) ) 
        !           963:                        $P.tp_sock->so_error = error;
        !           964:                tp_ctimeout($P.tp_refp, TM_retrans, (int)$P.tp_cc_ticks);
        !           965:        }
        !           966: ;
        !           967: 
        !           968: /* TP4 only */
        !           969: TP_CLOSING             <==             TP_AKWAIT                                                                       TM_retrans
        !           970:        DEFAULT  /* out of time */
        !           971:        {
        !           972:                IncStat(ts_conn_gaveup);
        !           973:                tp_soisdisconnecting($P.tp_sock);
        !           974:                $P.tp_sock->so_error = ETIMEDOUT;
        !           975:                tp_indicate(T_DISCONNECT, $P, ETIMEDOUT);
        !           976:                (void) tp_emit(DR_TPDU_type, $P, 0, E_TP_CONGEST, MNULL);
        !           977:                $P.tp_retrans = $P.tp_Nretrans;
        !           978:                tp_ctimeout($P.tp_refp, TM_retrans, (int)$P.tp_dr_ticks);
        !           979:        }
        !           980: ;
        !           981: 
        !           982: /* the retrans timers had better go off BEFORE the inactivity timer does,
        !           983:  * if transmissions are going on.
        !           984:  * (i.e., TM_inact should be greater than timer for all retrans plus ack
        !           985:  * turnaround)
        !           986:  */
        !           987: /* TP4 only */
        !           988: TP_CLOSING             <==             TP_OPEN            [ TM_inact, TM_retrans, TM_data_retrans ]
        !           989:        DEFAULT
        !           990:        {
        !           991:                tp_euntimeout($P.tp_refp, TM_data_retrans); /* all */
        !           992:                tp_cuntimeout($P.tp_refp, TM_inact); 
        !           993:                tp_cuntimeout($P.tp_refp, TM_sendack);
        !           994: 
        !           995:                IncStat(ts_conn_gaveup);
        !           996:                tp_soisdisconnecting($P.tp_sock);
        !           997:                $P.tp_sock->so_error = ETIMEDOUT;
        !           998:                tp_indicate(T_DISCONNECT, $P, ETIMEDOUT);
        !           999:                (void) tp_emit(DR_TPDU_type, $P, 0, E_TP_CONGEST_2, MNULL);
        !          1000:                $P.tp_retrans = $P.tp_Nretrans;
        !          1001:                tp_ctimeout($P.tp_refp, TM_retrans, (int)$P.tp_dr_ticks);
        !          1002:        }
        !          1003: ;
        !          1004: 
        !          1005: /* TP4 only */
        !          1006: SAME                   <==             TP_OPEN                                                                         TM_retrans
        !          1007:        ( $P.tp_retrans > 0 )
        !          1008:        {
        !          1009:                $P.tp_cong_win = 1;
        !          1010:                $P.tp_ackrcvd = 0;
        !          1011:                /* resume XPD */
        !          1012:                if      ( $P.tp_Xsnd.sb_mb )  {
        !          1013:                        struct mbuf *m = m_copy($P.tp_Xsnd.sb_mb, 0, (int)$P.tp_Xsnd.sb_cc);
        !          1014:                        /* m_copy doesn't preserve the m_xlink field, but at this pt.
        !          1015:                         * that doesn't matter
        !          1016:                         */
        !          1017: 
        !          1018:                        IFTRACE(D_XPD)
        !          1019:                                tptrace(TPPTmisc, "XPD retrans: Xuna Xsndnxt sndhiwat snduna",
        !          1020:                                        $P.tp_Xuna, $P.tp_Xsndnxt, $P.tp_sndhiwat, 
        !          1021:                                        $P.tp_snduna); 
        !          1022:                        ENDTRACE
        !          1023:                        IFDEBUG(D_XPD)
        !          1024:                                dump_mbuf(m, "XPD retrans emitting M");
        !          1025:                        ENDDEBUG
        !          1026:                        IncStat(ts_retrans_xpd);
        !          1027:                        $P.tp_retrans --;
        !          1028:                        (void) tp_emit(XPD_TPDU_type, $P, $P.tp_Xuna, 1, m);
        !          1029:                        tp_ctimeout($P.tp_refp, TM_retrans, (int)$P.tp_xpd_ticks);
        !          1030:                }
        !          1031:        }
        !          1032: ;
        !          1033: 
        !          1034: /* TP4 only */
        !          1035: SAME                   <==             TP_OPEN                                                                 TM_data_retrans
        !          1036:        ( $$.e_retrans > 0 )
        !          1037:        {       
        !          1038:                register        SeqNum                  low, lowsave = 0;
        !          1039:                register        struct tp_rtc   *r = $P.tp_snduna_rtc;
        !          1040:                register        struct mbuf     *m;
        !          1041:                register        SeqNum                  high = $$.e_high;
        !          1042: 
        !          1043:                low = $P.tp_snduna;
        !          1044:                lowsave = high = low;
        !          1045: 
        !          1046:                tp_euntimeout_lss($P.tp_refp, TM_data_retrans,
        !          1047:                        SEQ_ADD($P, $P.tp_sndhiwat, 1));
        !          1048:                $P.tp_retrans_hiwat = $P.tp_sndhiwat;
        !          1049: 
        !          1050:                if (($P.tp_rx_strat & TPRX_EACH) == 0)
        !          1051:                        high = (high>low)?low:high;
        !          1052: 
        !          1053:                if( $P.tp_rx_strat & TPRX_USE_CW ) {
        !          1054:                        register int i;
        !          1055: 
        !          1056:                        $P.tp_cong_win = 1;
        !          1057:                        $P.tp_ackrcvd = 0;
        !          1058:                        i = SEQ_ADD($P, low, $P.tp_cong_win);
        !          1059: 
        !          1060:                        high = SEQ_MIN($P, high, $P.tp_sndhiwat);
        !          1061: 
        !          1062:                }
        !          1063: 
        !          1064:                while( SEQ_LEQ($P, low, high) ){
        !          1065:                        if ( r == (struct tp_rtc *)0 ){
        !          1066:                                IFDEBUG(D_RTC)
        !          1067:                                        printf( "tp: retrans rtc list is GONE!\n");
        !          1068:                                ENDDEBUG
        !          1069:                                break;
        !          1070:                        }
        !          1071:                        if ( r->tprt_seq == low ){
        !          1072:                                if(( m = m_copy(r->tprt_data, 0, r->tprt_octets ))== MNULL)
        !          1073:                                        break;
        !          1074:                                (void) tp_emit(DT_TPDU_type, $P, low, r->tprt_eot, m);
        !          1075:                                IncStat(ts_retrans_dt);
        !          1076:                                SEQ_INC($P, low );
        !          1077:                        }
        !          1078:                        r = r->tprt_next;
        !          1079:                }
        !          1080: /* CE_BIT
        !          1081:                if ( SEQ_LEQ($P, lowsave, high) ){
        !          1082: */
        !          1083:                        $$.e_retrans --;
        !          1084:                        tp_etimeout($P.tp_refp, TM_data_retrans, (caddr_t)lowsave,
        !          1085:                                        (caddr_t)high, $$.e_retrans,
        !          1086:                                        ($P.tp_Nretrans - $$.e_retrans) * (int)$P.tp_dt_ticks);
        !          1087: /* CE_BIT
        !          1088:                }
        !          1089: */
        !          1090:        }
        !          1091: ;
        !          1092: 
        !          1093: /* TP4 only */
        !          1094: SAME                   <==             TP_CLOSING                                                                      TM_retrans
        !          1095:        (       $P.tp_retrans > 0 )
        !          1096:        {       
        !          1097:                $P.tp_retrans --;
        !          1098:                (void) tp_emit(DR_TPDU_type, $P, 0, E_TP_DR_NO_REAS, MNULL);
        !          1099:                IncStat(ts_retrans_dr);
        !          1100:                tp_ctimeout($P.tp_refp, TM_retrans, (int)$P.tp_dr_ticks);
        !          1101:        }
        !          1102: ;
        !          1103: 
        !          1104: /* TP4 only */
        !          1105: TP_REFWAIT             <==             TP_CLOSING                                                                      TM_retrans
        !          1106:        DEFAULT /* no more retrans - gave up */
        !          1107:        {       
        !          1108:                $P.tp_sock->so_error = ETIMEDOUT;
        !          1109:                $P.tp_refp->tpr_state = REF_FROZEN;
        !          1110:                tp_recycle_tsuffix( $P );
        !          1111:                tp_etimeout($P.tp_refp, TM_reference, 0,0,0, (int)$P.tp_refer_ticks);
        !          1112:        }
        !          1113: ;
        !          1114: 
        !          1115: /*
        !          1116:  * The resources are kept around until the ref timer goes off.
        !          1117:  * The suffices are wiped out sooner so they can be reused right away.
        !          1118:  */
        !          1119: /* applicable in TP4, TP0 */
        !          1120: TP_CLOSED              <==             TP_REFWAIT                                                                      TM_reference
        !          1121:        DEFAULT
        !          1122:        {
        !          1123:                tp_freeref($P.tp_refp);
        !          1124:                tp_detach($P);
        !          1125:        }
        !          1126: ;
        !          1127: 
        !          1128: /* applicable in TP4, TP0 */
        !          1129: /* A duplicate CR from connectionless network layer can't happen */
        !          1130: SAME                   <==     TP_OPEN                                                         [ CR_TPDU, CC_TPDU ]
        !          1131:        DEFAULT
        !          1132:        {       
        !          1133:                if( $P.tp_class != TP_CLASS_0) {
        !          1134:                        tp_ctimeout($P.tp_refp, TM_inact, (int)$P.tp_inact_ticks);
        !          1135:                        if ( $E.ev_number == CC_TPDU )
        !          1136:                                (void) tp_emit(AK_TPDU_type, $P, $P.tp_rcvnxt, 0, MNULL); 
        !          1137:                }
        !          1138:                /* ignore it if class 0 - state tables are blank for this */
        !          1139:        }
        !          1140: ;
        !          1141: 
        !          1142: /* applicable in TP4, TP0 */
        !          1143: SAME                   <==     TP_OPEN                                                                 T_DATA_req
        !          1144:        DEFAULT
        !          1145:        {
        !          1146:                IFTRACE(D_DATA)
        !          1147:                        tptrace(TPPTmisc, "T_DATA_req sndhiwat snduna fcredit, tpcb",
        !          1148:                                $P.tp_sndhiwat, $P.tp_snduna, $P.tp_fcredit, $P);
        !          1149:                ENDTRACE
        !          1150: 
        !          1151:                tp_send($P);
        !          1152:        }
        !          1153: ;
        !          1154: 
        !          1155: /* TP4 only */
        !          1156: SAME                   <==             TP_OPEN                                                                         T_XPD_req
        !          1157:        DEFAULT
        !          1158:                /* T_XPD_req was issued by sosend iff xpd socket buf was empty
        !          1159:                 * at time of sosend(), 
        !          1160:                 * AND (which means) there were no unacknowledged XPD tpdus outstanding!
        !          1161:                 */
        !          1162:        {
        !          1163:                int error = 0;
        !          1164: 
        !          1165:                /* resume XPD */
        !          1166:                if      ( $P.tp_Xsnd.sb_mb )  {
        !          1167:                        struct mbuf *m = m_copy($P.tp_Xsnd.sb_mb, 0, (int)$P.tp_Xsnd.sb_cc);
        !          1168:                        /* m_copy doesn't preserve the m_xlink field, but at this pt.
        !          1169:                         * that doesn't matter
        !          1170:                         */
        !          1171: 
        !          1172:                        IFTRACE(D_XPD)
        !          1173:                                tptrace(TPPTmisc, "XPD req: Xuna Xsndnxt sndhiwat snduna",
        !          1174:                                        $P.tp_Xuna, $P.tp_Xsndnxt, $P.tp_sndhiwat, 
        !          1175:                                        $P.tp_snduna); 
        !          1176:                        ENDTRACE
        !          1177:                        IFDEBUG(D_XPD)
        !          1178:                                printf("T_XPD_req: sb_cc 0x%x\n", $P.tp_Xsnd.sb_cc);
        !          1179:                                dump_mbuf(m, "XPD req emitting M");
        !          1180:                        ENDDEBUG
        !          1181:                        error = 
        !          1182:                                tp_emit(XPD_TPDU_type, $P, $P.tp_Xuna, 1, m);
        !          1183:                        $P.tp_retrans = $P.tp_Nretrans;
        !          1184:                        tp_ctimeout($P.tp_refp, TM_retrans, (int)$P.tp_xpd_ticks);
        !          1185:                        SEQ_INC($P, $P.tp_Xsndnxt);
        !          1186:                } 
        !          1187:                if(trick_hc)
        !          1188:                        return error;
        !          1189:        }
        !          1190: ;
        !          1191: 
        !          1192: /* TP4, faked ack in TP0 when cons send completes */
        !          1193: SAME                   <==             TP_OPEN                                                                         AK_TPDU
        !          1194:        ( tp_goodack($P, $$.e_cdt, $$.e_seq, $$.e_subseq)  )
        !          1195: 
        !          1196:        /* tp_goodack == true means 
        !          1197:         * EITHER it actually acked something heretofore unacknowledged
        !          1198:         * OR no news but the credit should be processed.
        !          1199:         */
        !          1200:        {
        !          1201:                IFDEBUG(D_ACKRECV)
        !          1202:                        printf("GOOD ACK seq 0x%x cdt 0x%x\n", $$.e_seq, $$.e_cdt);
        !          1203:                ENDDEBUG
        !          1204:                if( $P.tp_class != TP_CLASS_0) {
        !          1205:                        tp_ctimeout($P.tp_refp, TM_inact, (int)$P.tp_inact_ticks);
        !          1206:                        tp_euntimeout_lss($P.tp_refp, TM_data_retrans, $$.e_seq);
        !          1207:                }
        !          1208:                sbwakeup( &$P.tp_sock->so_snd );
        !          1209: 
        !          1210:                if ($P.tp_sndhiwat <= $P.tp_retrans_hiwat &&
        !          1211:                        $P.tp_snduna <= $P.tp_retrans_hiwat) {
        !          1212: 
        !          1213:                        register    struct mbuf     *m;
        !          1214:                        /* extern      struct mbuf     *m_copy(); */
        !          1215:                        register    struct tp_rtc   *r;
        !          1216:                        SeqNum      high, retrans, low_save;
        !          1217: 
        !          1218:                        high = SEQ_MIN($P, SEQ_ADD($P, $P.tp_snduna,
        !          1219:                                        MIN($P.tp_cong_win, $P.tp_fcredit)) - 1,
        !          1220:                                        $P.tp_sndhiwat);
        !          1221:                        low_save = retrans = SEQ_MAX($P, SEQ_ADD($P, $P.tp_last_retrans, 1),
        !          1222:                                        $P.tp_snduna);
        !          1223:                        for (; SEQ_LEQ($P, retrans, high); SEQ_INC($P, retrans)) {
        !          1224: 
        !          1225:                                for (r = $P.tp_snduna_rtc; r; r = r->tprt_next){
        !          1226:                                        if ( r->tprt_seq == retrans ){
        !          1227:                                                if(( m = m_copy(r->tprt_data, 0, r->tprt_octets ))
        !          1228:                                                                == MNULL)
        !          1229:                                                        break;
        !          1230:                                                (void) tp_emit(DT_TPDU_type, $P, retrans,
        !          1231:                                                        r->tprt_eot, m);
        !          1232:                                                $P.tp_last_retrans = retrans;
        !          1233:                                                IncStat(ts_retrans_dt);
        !          1234:                                                break;
        !          1235:                                        }
        !          1236:                                }
        !          1237:                                if ( r == (struct tp_rtc *)0 ){
        !          1238:                                        IFDEBUG(D_RTC)
        !          1239:                                                printf( "tp: retrans rtc list is GONE!\n");
        !          1240:                                        ENDDEBUG
        !          1241:                                        break;
        !          1242:                                }
        !          1243:                        }
        !          1244:                        tp_etimeout($P.tp_refp, TM_data_retrans, (caddr_t)low_save,
        !          1245:                                        (caddr_t)high, $P.tp_retrans, (int)$P.tp_dt_ticks);
        !          1246:                        if (SEQ_DEC($P, retrans) == $P.tp_retrans_hiwat)
        !          1247:                                tp_send($P);
        !          1248:                }
        !          1249:                else {
        !          1250:                        tp_send($P);
        !          1251:                }
        !          1252:                IFDEBUG(D_ACKRECV)
        !          1253:                        printf("GOOD ACK new sndhiwat 0x%x\n", $P.tp_sndhiwat);
        !          1254:                ENDDEBUG
        !          1255:        }
        !          1256: ;
        !          1257: 
        !          1258: /* TP4, and TP0 after sending a CC or possibly a CR */
        !          1259: SAME                   <==             TP_OPEN                                                                          AK_TPDU
        !          1260:        DEFAULT
        !          1261:        {
        !          1262:                IFTRACE(D_ACKRECV)
        !          1263:                        tptrace(TPPTmisc, "BOGUS ACK fcc_present, tp_r_subseq e_subseq", 
        !          1264:                                $$.e_fcc_present, $P.tp_r_subseq, $$.e_subseq, 0);
        !          1265:                ENDTRACE
        !          1266:                if( $P.tp_class != TP_CLASS_0 ) {
        !          1267: 
        !          1268:                        if ( !$$.e_fcc_present ) {
        !          1269:                                /* send ACK with FCC */
        !          1270:                                IncStat( ts_ackreason[_ACK_FCC_] );
        !          1271:                                (void) tp_emit(AK_TPDU_type, $P, $P.tp_rcvnxt, 1, MNULL);
        !          1272:                        }
        !          1273:                        tp_ctimeout($P.tp_refp, TM_inact, (int)$P.tp_inact_ticks);
        !          1274:                } 
        !          1275:        }
        !          1276: ;
        !          1277: 
        !          1278: /* NBS(47) */
        !          1279:        /* goes in at *** */
        !          1280:                /* just so happens that this is never true now, because we allow
        !          1281:                 * only 1 packet in the queue at once (this could be changed)
        !          1282:                if      ( $P.tp_Xsnd.sb_mb )  {
        !          1283:                        struct mbuf *m = m_copy($P.tp_Xsnd.sb_mb, 0, ??);
        !          1284: 
        !          1285:                        (void) tp_emit(XPD_TPDU_type, $P, $P.tp_Xuna, 1, m);
        !          1286:                        $P.tp_retrans = $P.tp_Nretrans;
        !          1287:                        tp_ctimeout($P.tp_refp, TM_retrans, (int)$P.tp_xpd_ticks);
        !          1288:                        SEQ_INC($P, $P.tp_Xsndnxt);
        !          1289:                }
        !          1290:                 */
        !          1291:        /* end of the above hack */
        !          1292: 
        !          1293: /* TP4 only */
        !          1294: SAME                   <==     TP_OPEN                                                                         XAK_TPDU
        !          1295:        ( tp_goodXack($P, $$.e_seq) )
        !          1296:        /* tp_goodXack checks for good ack, removes the correct 
        !          1297:         * tpdu from the queue and  returns 1 if ack was legit, 0 if not.
        !          1298:         * also updates tp_Xuna
        !          1299:         */
        !          1300:        {       
        !          1301:                tp_ctimeout($P.tp_refp, TM_inact, (int)$P.tp_inact_ticks);
        !          1302:                tp_cuntimeout($P.tp_refp, TM_retrans);
        !          1303: 
        !          1304:                sbwakeup( &$P.tp_sock->so_snd );
        !          1305: 
        !          1306:                /* resume normal data */
        !          1307:                tp_send($P);
        !          1308:        }
        !          1309: ;
        !          1310: 
        !          1311: /* TP4, and TP0 after sending a CC or possibly a CR */
        !          1312: SAME                   <==             TP_OPEN                                                                         XAK_TPDU
        !          1313:        DEFAULT
        !          1314:        {
        !          1315:                IFTRACE(D_ACKRECV)
        !          1316:                        tptrace(TPPTmisc, "BOGUS XACK eventtype ", $E.ev_number, 0, 0,0);
        !          1317:                ENDTRACE
        !          1318:                if( $P.tp_class != TP_CLASS_0 ) {
        !          1319:                        tp_ctimeout($P.tp_refp, TM_inact, (int)$P.tp_inact_ticks);
        !          1320:                } 
        !          1321:        }
        !          1322: ;
        !          1323: 
        !          1324: /* TP4 only */
        !          1325: SAME                   <==             TP_OPEN                                                                 TM_sendack 
        !          1326:        DEFAULT
        !          1327:        {       
        !          1328:                IFTRACE(D_TIMER)
        !          1329:                        tptrace(TPPTsendack, -1, $P.tp_lcredit, $P.tp_sent_uwe, 
        !          1330:                        $P.tp_sent_lcdt, 0);
        !          1331:                ENDTRACE
        !          1332:                IncPStat($P, tps_n_TMsendack);
        !          1333:                (void) tp_emit(AK_TPDU_type, $P, $P.tp_rcvnxt, 0, MNULL);
        !          1334:        }
        !          1335: ;
        !          1336: 
        !          1337: /* TP0 only */
        !          1338: SAME                   <==             TP_OPEN                                                                         T_USR_rcvd
        !          1339:        ($P.tp_class == TP_CLASS_0)
        !          1340:        {
        !          1341:                if (sbspace(&$P.tp_sock->so_rcv) > 0)
        !          1342:                        tp0_openflow($P);
        !          1343:        }
        !          1344: ;
        !          1345: 
        !          1346: /* TP4 only */
        !          1347:                /* If old credit was zero, 
        !          1348:                 * we'd better inform other side that we now have space
        !          1349:                 * But this is not enough.  Sender might not yet have
        !          1350:                 * seen an ack with cdt 0 but it might still think the
        !          1351:                 * window is closed, so it's going to wait.
        !          1352:                 * Best to send an ack each time.
        !          1353:                 * Strictly speaking, this ought to be a function of the
        !          1354:                 * general ack strategy.
        !          1355:                 */
        !          1356: SAME                   <==             TP_OPEN                                                                         T_USR_rcvd
        !          1357:        DEFAULT
        !          1358:        {       
        !          1359:                if( trick_hc ) {
        !          1360:                        IncStat(ts_ackreason[_ACK_USRRCV_]);
        !          1361: 
        !          1362:                        /* send an ACK only if there's new information */
        !          1363:                        LOCAL_CREDIT( $P );
        !          1364:                        if (($P.tp_rcvnxt != $P.tp_sent_rcvnxt) ||
        !          1365:                                ($P.tp_lcredit != $P.tp_sent_lcdt))
        !          1366: 
        !          1367:                                return tp_emit(AK_TPDU_type, $P, $P.tp_rcvnxt, 0, MNULL);
        !          1368:                }
        !          1369:        }
        !          1370: ;
        !          1371: 
        !          1372: /* applicable in TP4, TP0 */
        !          1373: SAME                   <==             TP_REFWAIT                              [ T_USR_rcvd, T_USR_Xrcvd ]
        !          1374:        DEFAULT
        !          1375:        /* This happens if other end sent a DR when  the user was waiting 
        !          1376:         * on a receive.  
        !          1377:         * Processing the DR includes putting us in REFWAIT state.
        !          1378:         */
        !          1379:        {
        !          1380:                if(trick_hc)
        !          1381:                return ECONNABORTED;
        !          1382:        }
        !          1383: ;
        !          1384: 
        !          1385: /* TP0 only */
        !          1386: TP_REFWAIT             <==             [ TP_OPEN, TP_CRSENT, TP_LISTENING ]    T_NETRESET
        !          1387:        ( $P.tp_class != TP_CLASS_4 ) 
        !          1388:                /* 0 or (4 and 0) */
        !          1389:                /* in OPEN class will be 0 or 4 but not both */
        !          1390:                /* in CRSENT or LISTENING it could be in negotiation, hence both */
        !          1391:                /* Actually, this shouldn't ever happen in LISTENING */
        !          1392:        {
        !          1393:                ASSERT( $P.tp_state != TP_LISTENING );
        !          1394:                tp_indicate(T_DISCONNECT, $P, ECONNRESET);
        !          1395:                tp_soisdisconnected($P);
        !          1396:        }
        !          1397: ;
        !          1398: 
        !          1399: /* TP4: ignore resets */
        !          1400: SAME           <==             [ TP_OPEN, TP_CRSENT, TP_AKWAIT,
        !          1401:                                                TP_CLOSING, TP_LISTENING ]                              T_NETRESET
        !          1402:        DEFAULT
        !          1403:        NULLACTION
        !          1404: ;
        !          1405:  
        !          1406: /* applicable in TP4, TP0 */
        !          1407: SAME                   <==             [ TP_CLOSED, TP_REFWAIT ]                               T_NETRESET
        !          1408:        DEFAULT
        !          1409:        NULLACTION
        !          1410: ;
        !          1411: 
        !          1412: /* C'EST TOUT */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.