sys/netatm/uni/qsaal1_sigcpcs.c

   1 /*
   2  *
   3  * ===================================
   4  * HARP  |  Host ATM Research Platform
   5  * ===================================
   6  *
   7  *
   8  * This Host ATM Research Platform ("HARP") file (the "Software") is
   9  * made available by Network Computing Services, Inc. ("NetworkCS")
  10  * "AS IS".  NetworkCS does not provide maintenance, improvements or
  11  * support of any kind.
  12  *
  13  * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
  14  * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
  15  * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
  16  * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
  17  * In no event shall NetworkCS be responsible for any damages, including
  18  * but not limited to consequential damages, arising from or relating to
  19  * any use of the Software or related support.
  20  *
  21  * Copyright 1994-1998 Network Computing Services, Inc.
  22  *
  23  * Copies of this Software may be made, however, the above copyright
  24  * notice must be reproduced on all copies.
  25  *
  26  *      @(#) $FreeBSD$
  27  *
  28  */
  29
  30 /*
  31  * ATM Forum UNI Support
  32  * ---------------------
  33  *
  34  * ITU-T Q.SAAL1 - Process CPCS-signals (SSCOP PDUs)
  35  *
  36  */
  37
  38 #include <netatm/kern_include.h>
  39
  40 #include <netatm/uni/sscop.h>
  41 #include <netatm/uni/sscop_misc.h>
  42 #include <netatm/uni/sscop_pdu.h>
  43 #include <netatm/uni/sscop_var.h>
  44
  45 #ifndef lint
  46 __RCSID("@(#) $FreeBSD$");
  47 #endif
  48
  49
  50 /*
  51  * Local functions
  52  */
  53 static void     sscop_bgn_outconn __P((struct sscop *, KBuffer *, caddr_t));
  54 static void     sscop_end_outresyn __P((struct sscop *, KBuffer *, caddr_t));
  55 static void     sscop_end_conresyn __P((struct sscop *, KBuffer *, caddr_t));
  56 static void     sscop_end_ready __P((struct sscop *, KBuffer *, caddr_t));
  57 static void     sscop_endak_outresyn __P((struct sscop *, KBuffer *, caddr_t));
  58 static void     sscop_rs_outresyn __P((struct sscop *, KBuffer *, caddr_t));
  59 static void     sscop_rs_ready __P((struct sscop *, KBuffer *, caddr_t));
  60 static void     sscop_rsak_conresyn __P((struct sscop *, KBuffer *, caddr_t));
  61 static void     sscop_sd_inresyn __P((struct sscop *, KBuffer *, caddr_t));
  62 static void     sscop_sd_conresyn __P((struct sscop *, KBuffer *, caddr_t));
  63 static void     sscop_sd_process __P((struct sscop *, KBuffer *, caddr_t, int));
  64 static void     sscop_sd_ready __P((struct sscop *, KBuffer *, caddr_t));
  65 static void     sscop_sdp_ready __P((struct sscop *, KBuffer *, caddr_t));
  66 static void     sscop_poll_inresyn __P((struct sscop *, KBuffer *, caddr_t));
  67 static void     sscop_poll_conresyn __P((struct sscop *, KBuffer *, caddr_t));
  68 static void     sscop_poll_ready __P((struct sscop *, KBuffer *, caddr_t));
  69 static void     sscop_stat_conresyn __P((struct sscop *, KBuffer *, caddr_t));
  70 static void     sscop_ustat_conresyn __P((struct sscop *, KBuffer *, caddr_t));
  71
  72
  73 /*
  74  * PDU type state lookup tables
  75  */
  76 /* BGN PDU */
  77 static void     (*sscop_bgn_tab[SOS_NUMSTATES])
  78                                 __P((struct sscop *, KBuffer *, caddr_t)) = {
  79                         NULL,                   /* SOS_INST */
  80                         sscop_bgn_idle,         /* SOS_IDLE */
  81                         sscop_bgn_outconn,      /* SOS_OUTCONN */
  82                         sscop_noop,             /* SOS_INCONN */
  83                         sscop_bgn_outdisc,      /* SOS_OUTDISC */
  84                         sscop_bgn_outresyn,     /* SOS_OUTRESYN */
  85                         sscop_bgn_inresyn,      /* SOS_INRESYN */
  86                         sscop_bgn_outresyn,     /* SOS_CONRESYN */
  87                         NULL,                   /* invalid */
  88                         NULL,                   /* invalid */
  89                         sscop_bgn_inresyn,      /* SOS_READY */
  90                         sscop_noop              /* SOS_TERM */
  91 };
  92
  93 /* BGAK PDU */
  94 static void     (*sscop_bgak_tab[SOS_NUMSTATES])
  95                                 __P((struct sscop *, KBuffer *, caddr_t)) = {
  96                         NULL,                   /* SOS_INST */
  97                         sscop_bgak_idle,        /* SOS_IDLE */
  98                         sscop_bgak_outconn,     /* SOS_OUTCONN */
  99                         sscop_bgak_error,       /* SOS_INCONN */
 100                         sscop_noop,             /* SOS_OUTDISC */
 101                         sscop_bgak_error,       /* SOS_OUTRESYN */
 102                         sscop_bgak_error,       /* SOS_INRESYN */
 103                         sscop_bgak_error,       /* SOS_CONRESYN */
 104                         NULL,                   /* invalid */
 105                         NULL,                   /* invalid */
 106                         sscop_noop,             /* SOS_READY */
 107                         sscop_noop              /* SOS_TERM */
 108 };
 109
 110 /* BGREJ PDU */
 111 static void     (*sscop_bgrej_tab[SOS_NUMSTATES])
 112                                 __P((struct sscop *, KBuffer *, caddr_t)) = {
 113                         NULL,                   /* SOS_INST */
 114                         sscop_bgrej_error,      /* SOS_IDLE */
 115                         sscop_bgrej_outconn,    /* SOS_OUTCONN */
 116                         sscop_bgrej_inconn,     /* SOS_INCONN */
 117                         sscop_noop,             /* SOS_OUTDISC */
 118                         sscop_bgrej_outresyn,   /* SOS_OUTRESYN */
 119                         sscop_bgrej_ready,      /* SOS_INRESYN */
 120                         sscop_bgrej_outresyn,   /* SOS_CONRESYN */
 121                         NULL,                   /* invalid */
 122                         NULL,                   /* invalid */
 123                         sscop_bgrej_ready,      /* SOS_READY */
 124                         sscop_noop              /* SOS_TERM */
 125 };
 126
 127 /* END PDU */
 128 static void     (*sscop_end_tab[SOS_NUMSTATES])
 129                                 __P((struct sscop *, KBuffer *, caddr_t)) = {
 130                         NULL,                   /* SOS_INST */
 131                         sscop_end_idle,         /* SOS_IDLE */
 132                         sscop_noop,             /* SOS_OUTCONN */
 133                         sscop_end_inconn,       /* SOS_INCONN */
 134                         sscop_end_outdisc,      /* SOS_OUTDISC */
 135                         sscop_end_outresyn,     /* SOS_OUTRESYN */
 136                         sscop_end_ready,        /* SOS_INRESYN */
 137                         sscop_end_conresyn,     /* SOS_CONRESYN */
 138                         NULL,                   /* invalid */
 139                         NULL,                   /* invalid */
 140                         sscop_end_ready,        /* SOS_READY */
 141                         sscop_noop              /* SOS_TERM */
 142 };
 143
 144 /* ENDAK PDU */
 145 static void     (*sscop_endak_tab[SOS_NUMSTATES])
 146                                 __P((struct sscop *, KBuffer *, caddr_t)) = {
 147                         NULL,                   /* SOS_INST */
 148                         sscop_noop,             /* SOS_IDLE */
 149                         sscop_noop,             /* SOS_OUTCONN */
 150                         sscop_endak_inconn,     /* SOS_INCONN */
 151                         sscop_endak_outdisc,    /* SOS_OUTDISC */
 152                         sscop_endak_outresyn,   /* SOS_OUTRESYN */
 153                         sscop_endak_ready,      /* SOS_INRESYN */
 154                         sscop_endak_outresyn,   /* SOS_CONRESYN */
 155                         NULL,                   /* invalid */
 156                         NULL,                   /* invalid */
 157                         sscop_endak_ready,      /* SOS_READY */
 158                         sscop_noop              /* SOS_TERM */
 159 };
 160
 161 /* RS PDU */
 162 static void     (*sscop_rs_tab[SOS_NUMSTATES])
 163                                 __P((struct sscop *, KBuffer *, caddr_t)) = {
 164                         NULL,                   /* SOS_INST */
 165                         sscop_rs_idle,          /* SOS_IDLE */
 166                         sscop_noop,             /* SOS_OUTCONN */
 167                         sscop_rs_error,         /* SOS_INCONN */
 168                         sscop_noop,             /* SOS_OUTDISC */
 169                         sscop_rs_outresyn,      /* SOS_OUTRESYN */
 170                         sscop_noop,             /* SOS_INRESYN */
 171                         sscop_noop,             /* SOS_CONRESYN */
 172                         NULL,                   /* invalid */
 173                         NULL,                   /* invalid */
 174                         sscop_rs_ready,         /* SOS_READY */
 175                         sscop_noop              /* SOS_TERM */
 176 };
 177
 178 /* RSAK PDU */
 179 static void     (*sscop_rsak_tab[SOS_NUMSTATES])
 180                                 __P((struct sscop *, KBuffer *, caddr_t)) = {
 181                         NULL,                   /* SOS_INST */
 182                         sscop_rsak_idle,        /* SOS_IDLE */
 183                         sscop_noop,             /* SOS_OUTCONN */
 184                         sscop_rsak_error,       /* SOS_INCONN */
 185                         sscop_noop,             /* SOS_OUTDISC */
 186                         sscop_rsak_outresyn,    /* SOS_OUTRESYN */
 187                         sscop_rsak_error,       /* SOS_INRESYN */
 188                         sscop_rsak_conresyn,    /* SOS_CONRESYN */
 189                         NULL,                   /* invalid */
 190                         NULL,                   /* invalid */
 191                         sscop_rsak_error,       /* SOS_READY */
 192                         sscop_noop              /* SOS_TERM */
 193 };
 194
 195 /* SD PDU */
 196 static void     (*sscop_sd_tab[SOS_NUMSTATES])
 197                                 __P((struct sscop *, KBuffer *, caddr_t)) = {
 198                         NULL,                   /* SOS_INST */
 199                         sscop_sd_idle,          /* SOS_IDLE */
 200                         sscop_noop,             /* SOS_OUTCONN */
 201                         sscop_sd_inconn,        /* SOS_INCONN */
 202                         sscop_noop,             /* SOS_OUTDISC */
 203                         sscop_sd_ready,         /* SOS_OUTRESYN */
 204                         sscop_sd_inresyn,       /* SOS_INRESYN */
 205                         sscop_sd_conresyn,      /* SOS_CONRESYN */
 206                         NULL,                   /* invalid */
 207                         NULL,                   /* invalid */
 208                         sscop_sd_ready,         /* SOS_READY */
 209                         sscop_noop              /* SOS_TERM */
 210 };
 211
 212 /* SDP PDU */
 213 static void     (*sscop_sdp_tab[SOS_NUMSTATES])
 214                                 __P((struct sscop *, KBuffer *, caddr_t)) = {
 215                         NULL,                   /* SOS_INST */
 216                         sscop_sd_idle,          /* SOS_IDLE */
 217                         sscop_noop,             /* SOS_OUTCONN */
 218                         sscop_sd_inconn,        /* SOS_INCONN */
 219                         sscop_noop,             /* SOS_OUTDISC */
 220                         sscop_sdp_ready,        /* SOS_OUTRESYN */
 221                         sscop_sd_inresyn,       /* SOS_INRESYN */
 222                         sscop_sd_conresyn,      /* SOS_CONRESYN */
 223                         NULL,                   /* invalid */
 224                         NULL,                   /* invalid */
 225                         sscop_sdp_ready,        /* SOS_READY */
 226                         sscop_noop              /* SOS_TERM */
 227 };
 228
 229 /* POLL PDU */
 230 static void     (*sscop_poll_tab[SOS_NUMSTATES])
 231                                 __P((struct sscop *, KBuffer *, caddr_t)) = {
 232                         NULL,                   /* SOS_INST */
 233                         sscop_poll_idle,        /* SOS_IDLE */
 234                         sscop_noop,             /* SOS_OUTCONN */
 235                         sscop_poll_inconn,      /* SOS_INCONN */
 236                         sscop_noop,             /* SOS_OUTDISC */
 237                         sscop_poll_ready,       /* SOS_OUTRESYN */
 238                         sscop_poll_inresyn,     /* SOS_INRESYN */
 239                         sscop_poll_conresyn,    /* SOS_CONRESYN */
 240                         NULL,                   /* invalid */
 241                         NULL,                   /* invalid */
 242                         sscop_poll_ready,       /* SOS_READY */
 243                         sscop_noop              /* SOS_TERM */
 244 };
 245
 246 /* STAT PDU */
 247 static void     (*sscop_stat_tab[SOS_NUMSTATES])
 248                                 __P((struct sscop *, KBuffer *, caddr_t)) = {
 249                         NULL,                   /* SOS_INST */
 250                         sscop_stat_idle,        /* SOS_IDLE */
 251                         sscop_noop,             /* SOS_OUTCONN */
 252                         sscop_stat_inconn,      /* SOS_INCONN */
 253                         sscop_noop,             /* SOS_OUTDISC */
 254                         sscop_noop,             /* SOS_OUTRESYN */
 255                         sscop_stat_ready,       /* SOS_INRESYN */
 256                         sscop_stat_conresyn,    /* SOS_CONRESYN */
 257                         NULL,                   /* invalid */
 258                         NULL,                   /* invalid */
 259                         sscop_stat_ready,       /* SOS_READY */
 260                         sscop_noop              /* SOS_TERM */
 261 };
 262
 263 /* USTAT PDU */
 264 static void     (*sscop_ustat_tab[SOS_NUMSTATES])
 265                                 __P((struct sscop *, KBuffer *, caddr_t)) = {
 266                         NULL,                   /* SOS_INST */
 267                         sscop_ustat_idle,       /* SOS_IDLE */
 268                         sscop_noop,             /* SOS_OUTCONN */
 269                         sscop_ustat_inconn,     /* SOS_INCONN */
 270                         sscop_noop,             /* SOS_OUTDISC */
 271                         sscop_noop,             /* SOS_OUTRESYN */
 272                         sscop_ustat_ready,      /* SOS_INRESYN */
 273                         sscop_ustat_conresyn,   /* SOS_CONRESYN */
 274                         NULL,                   /* invalid */
 275                         NULL,                   /* invalid */
 276                         sscop_ustat_ready,      /* SOS_READY */
 277                         sscop_noop              /* SOS_TERM */
 278 };
 279
 280 /* UD PDU */
 281 static void     (*sscop_ud_tab[SOS_NUMSTATES])
 282                                 __P((struct sscop *, KBuffer *, caddr_t)) = {
 283                         NULL,                   /* SOS_INST */
 284                         sscop_ud_all,           /* SOS_IDLE */
 285                         sscop_ud_all,           /* SOS_OUTCONN */
 286                         sscop_ud_all,           /* SOS_INCONN */
 287                         sscop_ud_all,           /* SOS_OUTDISC */
 288                         sscop_ud_all,           /* SOS_OUTRESYN */
 289                         sscop_ud_all,           /* SOS_INRESYN */
 290                         sscop_ud_all,           /* SOS_CONRESYN */
 291                         NULL,                   /* invalid */
 292                         NULL,                   /* invalid */
 293                         sscop_ud_all,           /* SOS_READY */
 294                         sscop_noop              /* SOS_TERM */
 295 };
 296
 297 /* MD PDU */
 298 static void     (*sscop_md_tab[SOS_NUMSTATES])
 299                                 __P((struct sscop *, KBuffer *, caddr_t)) = {
 300                         NULL,                   /* SOS_INST */
 301                         sscop_md_all,           /* SOS_IDLE */
 302                         sscop_md_all,           /* SOS_OUTCONN */
 303                         sscop_md_all,           /* SOS_INCONN */
 304                         sscop_md_all,           /* SOS_OUTDISC */
 305                         sscop_md_all,           /* SOS_OUTRESYN */
 306                         sscop_md_all,           /* SOS_INRESYN */
 307                         sscop_md_all,           /* SOS_CONRESYN */
 308                         NULL,                   /* invalid */
 309                         NULL,                   /* invalid */
 310                         sscop_md_all,           /* SOS_READY */
 311                         sscop_noop              /* SOS_TERM */
 312 };
 313
 314
 315 /*
 316  * PDU type lookup table
 317  */
 318 void    (*(*sscop_qsaal_pdutab[]))
 319                                 __P((struct sscop *, KBuffer *, caddr_t)) = {
 320                 NULL,
 321                 sscop_bgn_tab,
 322                 sscop_bgak_tab,
 323                 sscop_end_tab,
 324                 sscop_endak_tab,
 325                 sscop_rs_tab,
 326                 sscop_rsak_tab,
 327                 sscop_bgrej_tab,
 328                 sscop_sd_tab,
 329                 sscop_sdp_tab,
 330                 sscop_poll_tab,
 331                 sscop_stat_tab,
 332                 sscop_ustat_tab,
 333                 sscop_ud_tab,
 334                 sscop_md_tab,
 335                 NULL
 336 };
 337
 338
 339 /*
 340  * BGN PDU / SOS_OUTCONN Processor
 341  *
 342  * Arguments:
 343  *      sop     pointer to sscop connection block
 344  *      m       pointer to PDU buffer (without trailer)
 345  *      trlr    pointer to PDU trailer
 346  *
 347  * Returns:
 348  *      none
 349  *
 350  */
 351 static void
 352 sscop_bgn_outconn(sop, m, trlr)
 353         struct sscop    *sop;
 354         KBuffer         *m;
 355         caddr_t         trlr;
 356 {
 357         struct bgn_pdu  *bp = (struct bgn_pdu *)trlr;
 358         int             err;
 359
 360         /*
 361          * Initialize transmit window
 362          */
 363         SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_nmr));
 364
 365         /*
 366          * Notify user of connection establishment
 367          */
 368         if (sop->so_flags & SOF_REESTAB) {
 369                 KB_FREEALL(m);
 370                 STACK_CALL(SSCOP_ESTABLISH_IND, sop->so_upper, sop->so_toku,
 371                         sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
 372                 if (err) {
 373                         sscop_abort(sop, "sscop_bgn_outconn: stack memory\n");
 374                         return;
 375                 }
 376                 sop->so_flags &= ~SOF_REESTAB;
 377         } else {
 378                 STACK_CALL(SSCOP_ESTABLISH_CNF, sop->so_upper, sop->so_toku,
 379                         sop->so_connvc, (int)m, 0, err);
 380                 if (err) {
 381                         KB_FREEALL(m);
 382                         sscop_abort(sop, "sscop_bgn_outconn: stack memory\n");
 383                         return;
 384                 }
 385         }
 386
 387         /*
 388          * Return an ACK to peer
 389          */
 390         (void) sscop_send_bgak(sop);
 391
 392         /*
 393          * Stop retransmit timer
 394          */
 395         sop->so_timer[SSCOP_T_CC] = 0;
 396
 397         /*
 398          * Reset receiver variables
 399          */
 400         qsaal1_reset_rcvr(sop);
 401
 402         /*
 403          * Start polling timer
 404          */
 405         sscop_set_poll(sop);
 406
 407         /*
 408          * Start lost poll/stat timer
 409          */
 410         sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp;
 411
 412         /*
 413          * OK, we're ready for data
 414          */
 415         sop->so_state = SOS_READY;
 416
 417         /*
 418          * See if transmit queues need servicing
 419          */
 420         if (sop->so_flags & SOF_XMITSRVC)
 421                 sscop_service_xmit(sop);
 422
 423         return;
 424 }
 425
 426
 427 /*
 428  * END PDU / SOS_OUTRESYN Processor
 429  *
 430  * Arguments:
 431  *      sop     pointer to sscop connection block
 432  *      m       pointer to PDU buffer (without trailer)
 433  *      trlr    pointer to PDU trailer
 434  *
 435  * Returns:
 436  *      none
 437  *
 438  */
 439 static void
 440 sscop_end_outresyn(sop, m, trlr)
 441         struct sscop    *sop;
 442         KBuffer         *m;
 443         caddr_t         trlr;
 444 {
 445         struct end_pdu  *ep = (struct end_pdu *)trlr;
 446         int             err, source;
 447
 448         /*
 449          * Stop retransmit timer
 450          */
 451         sop->so_timer[SSCOP_T_CC] = 0;
 452
 453         /*
 454          * Acknowledge END
 455          */
 456         (void) sscop_send_endak(sop);
 457
 458         /*
 459          * Get Source value
 460          */
 461         if (ep->end_type & PT_SOURCE_SSCOP)
 462                 source = SSCOP_SOURCE_SSCOP;
 463         else
 464                 source = SSCOP_SOURCE_USER;
 465
 466         /*
 467          * Notify user of connection termination
 468          */
 469         STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
 470                 sop->so_connvc, (int)m, source, err);
 471         if (err) {
 472                 KB_FREEALL(m);
 473                 sscop_abort(sop, "sscop_end_outresyn: stack memory\n");
 474                 return;
 475         }
 476
 477         /*
 478          * Clear connection data
 479          */
 480         qsaal1_clear_connection(sop);
 481
 482         /*
 483          * Back to idle state
 484          */
 485         sop->so_state = SOS_IDLE;
 486
 487         return;
 488 }
 489
 490
 491 /*
 492  * END PDU / SOS_CONRESYN Processor
 493  *
 494  * Arguments:
 495  *      sop     pointer to sscop connection block
 496  *      m       pointer to PDU buffer (without trailer)
 497  *      trlr    pointer to PDU trailer
 498  *
 499  * Returns:
 500  *      none
 501  *
 502  */
 503 static void
 504 sscop_end_conresyn(sop, m, trlr)
 505         struct sscop    *sop;
 506         KBuffer         *m;
 507         caddr_t         trlr;
 508 {
 509         int             err;
 510
 511         /*
 512          * Stop retransmit timer
 513          */
 514         sop->so_timer[SSCOP_T_CC] = 0;
 515
 516         /*
 517          * Free up buffers
 518          */
 519         KB_FREEALL(m);
 520
 521         /*
 522          * Acknowledge END
 523          */
 524         (void) sscop_send_endak(sop);
 525
 526         /*
 527          * Notify user of connection termination
 528          */
 529         STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
 530                 sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
 531         if (err) {
 532                 sscop_abort(sop, "sscop_end_conresyn: stack memory\n");
 533                 return;
 534         }
 535
 536         /*
 537          * Clear connection data
 538          */
 539         qsaal1_clear_connection(sop);
 540
 541         /*
 542          * Back to idle state
 543          */
 544         sop->so_state = SOS_IDLE;
 545
 546         return;
 547 }
 548
 549
 550 /*
 551  * END PDU / SOS_READY Processor
 552  *
 553  * Arguments:
 554  *      sop     pointer to sscop connection block
 555  *      m       pointer to PDU buffer (without trailer)
 556  *      trlr    pointer to PDU trailer
 557  *
 558  * Returns:
 559  *      none
 560  *
 561  */
 562 static void
 563 sscop_end_ready(sop, m, trlr)
 564         struct sscop    *sop;
 565         KBuffer         *m;
 566         caddr_t         trlr;
 567 {
 568         struct end_pdu  *ep = (struct end_pdu *)trlr;
 569         int             err, source;
 570
 571         /*
 572          * Stop poll timer
 573          */
 574         sop->so_timer[SSCOP_T_POLL] = 0;
 575         sop->so_flags &= ~SOF_KEEPALIVE;
 576
 577         /*
 578          * Stop lost poll/stat timer
 579          */
 580         sop->so_timer[SSCOP_T_NORESP] = 0;
 581
 582         /*
 583          * Acknowledge END
 584          */
 585         (void) sscop_send_endak(sop);
 586
 587         /*
 588          * Get Source value
 589          */
 590         if (ep->end_type & PT_SOURCE_SSCOP)
 591                 source = SSCOP_SOURCE_SSCOP;
 592         else
 593                 source = SSCOP_SOURCE_USER;
 594
 595         /*
 596          * Notify user of connection termination
 597          */
 598         STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
 599                 sop->so_connvc, (int)m, source, err);
 600         if (err) {
 601                 KB_FREEALL(m);
 602                 sscop_abort(sop, "sscop_end_ready: stack memory\n");
 603                 return;
 604         }
 605
 606         /*
 607          * Clear connection data
 608          */
 609         qsaal1_clear_connection(sop);
 610
 611         /*
 612          * Back to idle state
 613          */
 614         sop->so_state = SOS_IDLE;
 615
 616         return;
 617 }
 618
 619
 620 /*
 621  * ENDAK PDU / SOS_OUTRESYN Processor
 622  *
 623  * Arguments:
 624  *      sop     pointer to sscop connection block
 625  *      m       pointer to PDU buffer (without trailer)
 626  *      trlr    pointer to PDU trailer
 627  *
 628  * Returns:
 629  *      none
 630  *
 631  */
 632 static void
 633 sscop_endak_outresyn(sop, m, trlr)
 634         struct sscop    *sop;
 635         KBuffer         *m;
 636         caddr_t         trlr;
 637 {
 638         int             err;
 639
 640         /*
 641          * Stop retransmit timer
 642          */
 643         sop->so_timer[SSCOP_T_CC] = 0;
 644
 645         /*
 646          * Report protocol error
 647          */
 648         sscop_endak_error(sop, m, trlr);
 649
 650         /*
 651          * Notify user of connection failure
 652          */
 653         STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
 654                 sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
 655         if (err) {
 656                 sscop_abort(sop, "sscop_endak_outresyn: stack memory\n");
 657                 return;
 658         }
 659
 660         /*
 661          * Clear connection data
 662          */
 663         qsaal1_clear_connection(sop);
 664
 665         /*
 666          * Back to idle state
 667          */
 668         sop->so_state = SOS_IDLE;
 669
 670         return;
 671 }
 672
 673
 674 /*
 675  * RS PDU / SOS_OUTRESYN Processor
 676  *
 677  * Arguments:
 678  *      sop     pointer to sscop connection block
 679  *      m       pointer to PDU buffer (without trailer)
 680  *      trlr    pointer to PDU trailer
 681  *
 682  * Returns:
 683  *      none
 684  *
 685  */
 686 static void
 687 sscop_rs_outresyn(sop, m, trlr)
 688         struct sscop    *sop;
 689         KBuffer         *m;
 690         caddr_t         trlr;
 691 {
 692         int             err;
 693
 694         /*
 695          * Notify user of resynchronization
 696          */
 697         STACK_CALL(SSCOP_RESYNC_IND, sop->so_upper, sop->so_toku,
 698                 sop->so_connvc, (int)m, 0, err);
 699         if (err) {
 700                 KB_FREEALL(m);
 701                 sscop_abort(sop, "sscop_rs_outresyn: stack memory\n");
 702                 return;
 703         }
 704
 705         /*
 706          * Reset receiver state variables
 707          */
 708         qsaal1_reset_rcvr(sop);
 709
 710         /*
 711          * Wait for both peer and user responses
 712          */
 713         sop->so_state = SOS_CONRESYN;
 714
 715         return;
 716 }
 717
 718
 719 /*
 720  * RS PDU / SOS_READY Processor
 721  *
 722  * Arguments:
 723  *      sop     pointer to sscop connection block
 724  *      m       pointer to PDU buffer (without trailer)
 725  *      trlr    pointer to PDU trailer
 726  *
 727  * Returns:
 728  *      none
 729  *
 730  */
 731 static void
 732 sscop_rs_ready(sop, m, trlr)
 733         struct sscop    *sop;
 734         KBuffer         *m;
 735         caddr_t         trlr;
 736 {
 737         int             err;
 738
 739         /*
 740          * Notify user of resynchronization
 741          */
 742         STACK_CALL(SSCOP_RESYNC_IND, sop->so_upper, sop->so_toku,
 743                 sop->so_connvc, (int)m, 0, err);
 744         if (err) {
 745                 KB_FREEALL(m);
 746                 sscop_abort(sop, "sscop_rs_ready: stack memory\n");
 747                 return;
 748         }
 749
 750         /*
 751          * Reset receiver state variables
 752          */
 753         qsaal1_reset_rcvr(sop);
 754
 755         /*
 756          * Wait for user response
 757          */
 758         sop->so_state = SOS_INRESYN;
 759
 760         return;
 761 }
 762
 763
 764 /*
 765  * RSAK PDU / SOS_CONRESYN Processor
 766  *
 767  * Arguments:
 768  *      sop     pointer to sscop connection block
 769  *      m       pointer to PDU buffer (without trailer)
 770  *      trlr    pointer to PDU trailer
 771  *
 772  * Returns:
 773  *      none
 774  *
 775  */
 776 static void
 777 sscop_rsak_conresyn(sop, m, trlr)
 778         struct sscop    *sop;
 779         KBuffer         *m;
 780         caddr_t         trlr;
 781 {
 782         int             err;
 783
 784         /*
 785          * Stop retransmit timer
 786          */
 787         sop->so_timer[SSCOP_T_CC] = 0;
 788
 789         /*
 790          * Free buffers
 791          */
 792         KB_FREEALL(m);
 793
 794         /*
 795          * Notify user of resynchronization completion
 796          */
 797         STACK_CALL(SSCOP_RESYNC_CNF, sop->so_upper, sop->so_toku,
 798                 sop->so_connvc, 0, 0, err);
 799         if (err) {
 800                 sscop_abort(sop, "sscop_rsak_conresyn: stack memory\n");
 801                 return;
 802         }
 803
 804         /*
 805          * Start the polling timer
 806          */
 807         sscop_set_poll(sop);
 808
 809         /*
 810          * Start lost poll/stat timer
 811          */
 812         sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp;
 813
 814         /*
 815          * Continue waiting for user response
 816          */
 817         sop->so_state = SOS_INRESYN;
 818
 819         /*
 820          * See if transmit queues need servicing
 821          */
 822         if (sop->so_flags & SOF_XMITSRVC)
 823                 sscop_service_xmit(sop);
 824
 825         return;
 826 }
 827
 828
 829 /*
 830  * SD PDU / SOS_INRESYN Processor
 831  *
 832  * Arguments:
 833  *      sop     pointer to sscop connection block
 834  *      m       pointer to PDU buffer (without trailer)
 835  *      trlr    pointer to PDU trailer
 836  *
 837  * Returns:
 838  *      none
 839  *
 840  */
 841 static void
 842 sscop_sd_inresyn(sop, m, trlr)
 843         struct sscop    *sop;
 844         KBuffer         *m;
 845         caddr_t         trlr;
 846 {
 847         int             err;
 848
 849         /*
 850          * Stop poll timer
 851          */
 852         sop->so_timer[SSCOP_T_POLL] = 0;
 853         sop->so_flags &= ~SOF_KEEPALIVE;
 854
 855         /*
 856          * Stop lost poll/stat timer
 857          */
 858         sop->so_timer[SSCOP_T_NORESP] = 0;
 859
 860         /*
 861          * Record error condition
 862          */
 863         sscop_sd_error(sop, m, trlr);
 864
 865         /*
 866          * Return an END to peer
 867          */
 868         (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
 869
 870         /*
 871          * Notify user of connection failure
 872          */
 873         STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
 874                 sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
 875         if (err) {
 876                 sscop_abort(sop, "sscop_sd_inresyn: stack memory\n");
 877                 return;
 878         }
 879
 880         /*
 881          * Clear connection data
 882          */
 883         qsaal1_clear_connection(sop);
 884
 885         /*
 886          * Go back to idle state
 887          */
 888         sop->so_state = SOS_IDLE;
 889
 890         return;
 891 }
 892
 893
 894 /*
 895  * SD PDU / SOS_CONRESYN Processor
 896  *
 897  * Arguments:
 898  *      sop     pointer to sscop connection block
 899  *      m       pointer to PDU buffer (without trailer)
 900  *      trlr    pointer to PDU trailer
 901  *
 902  * Returns:
 903  *      none
 904  *
 905  */
 906 static void
 907 sscop_sd_conresyn(sop, m, trlr)
 908         struct sscop    *sop;
 909         KBuffer         *m;
 910         caddr_t         trlr;
 911 {
 912         int             err;
 913
 914         /*
 915          * Stop retransmit timer
 916          */
 917         sop->so_timer[SSCOP_T_CC] = 0;
 918
 919         /*
 920          * Record error condition
 921          */
 922         sscop_sd_error(sop, m, trlr);
 923
 924         /*
 925          * Return an END to peer
 926          */
 927         (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
 928
 929         /*
 930          * Notify user of connection failure
 931          */
 932         STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
 933                 sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
 934         if (err) {
 935                 sscop_abort(sop, "sscop_sd_conresyn: stack memory\n");
 936                 return;
 937         }
 938
 939         /*
 940          * Clear connection data
 941          */
 942         qsaal1_clear_connection(sop);
 943
 944         /*
 945          * Go back to idle state
 946          */
 947         sop->so_state = SOS_IDLE;
 948
 949         return;
 950 }
 951
 952
 953 /*
 954  * SD/SDP PDU Common Processor
 955  *
 956  * Arguments:
 957  *      sop     pointer to sscop connection block
 958  *      m       pointer to PDU user data buffer chain
 959  *      trlr    pointer to PDU trailer
 960  *      type    PDU type (SD or SDP)
 961  *
 962  * Returns:
 963  *      none
 964  *
 965  */
 966 static void
 967 sscop_sd_process(sop, m, trlr, type)
 968         struct sscop    *sop;
 969         KBuffer         *m;
 970         caddr_t         trlr;
 971         int             type;
 972 {
 973         struct sd_pdu   *sp;
 974         struct sdp_pdu  *spp;
 975         struct poll_pdu poll;
 976         struct pdu_hdr  *php;
 977         KBuffer         *n;
 978         sscop_seq       ns, nps;
 979         int             err, space;
 980
 981         /*
 982          * Get PDU sequence number(s)
 983          */
 984         if (type == PT_SD) {
 985                 sp = (struct sd_pdu *)trlr;
 986                 SEQ_SET(ns, ntohl(sp->sd_ns));
 987                 SEQ_SET(nps, 0);
 988         } else {
 989                 spp = (struct sdp_pdu *)trlr;
 990                 SEQ_SET(ns, ntohl(spp->sdp_ns));
 991                 SEQ_SET(nps, ntohl(spp->sdp_nps));
 992         }
 993
 994         /*
 995          * Ensure that the sequence number fits within the window
 996          */
 997         if (SEQ_GEQ(ns, sop->so_rcvmax, sop->so_rcvnext)) {
 998                 KB_FREEALL(m);
 999                 return;
1000         }
1001
1002         /*
1003          * If this is the next in-sequence PDU, hand it to user
1004          */
1005         if (ns == sop->so_rcvnext) {
1006                 STACK_CALL(SSCOP_DATA_IND, sop->so_upper, sop->so_toku,
1007                         sop->so_connvc, (int)m, ns, err);
1008                 if (err) {
1009                         KB_FREEALL(m);
1010                         return;
1011                 }
1012
1013                 /*
1014                  * Bump next expected sequence number
1015                  */
1016                 SEQ_INCR(sop->so_rcvnext, 1);
1017
1018                 /*
1019                  * Slide receive window down
1020                  */
1021                 SEQ_INCR(sop->so_rcvmax, 1);
1022
1023                 /*
1024                  * Is this the highest sequence PDU we've received??
1025                  */
1026                 if (ns == sop->so_rcvhigh) {
1027                         /*
1028                          * Yes, bump the limit and exit
1029                          */
1030                         sop->so_rcvhigh = sop->so_rcvnext;
1031                         if (type == PT_SDP)
1032                                 goto dopoll;
1033                         return;
1034                 }
1035
1036                 /*
1037                  * This is a retransmitted PDU, so see if we have
1038                  * more in-sequence PDUs already queued up
1039                  */
1040                 while ((php = sop->so_recv_hd) &&
1041                        (php->ph_ns == sop->so_rcvnext)) {
1042
1043                         /*
1044                          * Yup we do, so remove next PDU from queue and
1045                          * pass it up to the user as well
1046                          */
1047                         sop->so_recv_hd = php->ph_recv_lk;
1048                         if (sop->so_recv_hd == NULL)
1049                                 sop->so_recv_tl = NULL;
1050                         STACK_CALL(SSCOP_DATA_IND, sop->so_upper, sop->so_toku,
1051                                 sop->so_connvc, (int)php->ph_buf, php->ph_ns,
1052                                 err);
1053                         if (err) {
1054                                 /*
1055                                  * Should never happen, but...
1056                                  */
1057                                 KB_FREEALL(php->ph_buf);
1058                                 sscop_abort(sop,
1059                                         "sscop_sd_process: stack memory\n");
1060                                 return;
1061                         }
1062
1063                         /*
1064                          * Bump next expected sequence number
1065                          */
1066                         SEQ_INCR(sop->so_rcvnext, 1);
1067
1068                         /*
1069                          * Slide receive window down
1070                          */
1071                         SEQ_INCR(sop->so_rcvmax, 1);
1072                 }
1073
1074                 /*
1075                  * Finished with data...see if we need to poll
1076                  */
1077                 if (type == PT_SDP)
1078                         goto dopoll;
1079                 return;
1080         }
1081
1082         /*
1083          * We're gonna have to queue this PDU, so find space
1084          * for the PDU header
1085          */
1086         KB_HEADROOM(m, space);
1087
1088         /*
1089          * If there's not enough room in the received buffer,
1090          * allocate & link a new buffer for the header
1091          */
1092         if (space < sizeof(struct pdu_hdr)) {
1093
1094                 KB_ALLOC(n, sizeof(struct pdu_hdr), KB_F_NOWAIT, KB_T_HEADER);
1095                 if (n == NULL) {
1096                         KB_FREEALL(m);
1097                         return;
1098                 }
1099                 KB_HEADSET(n, sizeof(struct pdu_hdr));
1100                 KB_LEN(n) = 0;
1101                 KB_LINKHEAD(n, m);
1102                 m = n;
1103         }
1104
1105         /*
1106          * Build PDU header
1107          *
1108          * We can at least assume/require that the start of
1109          * the user data is aligned.  Also note that we don't
1110          * include this header in the buffer len/offset fields.
1111          */
1112         KB_DATASTART(m, php, struct pdu_hdr *);
1113         php--;
1114         php->ph_ns = ns;
1115         php->ph_buf = m;
1116
1117         /*
1118          * Insert PDU into the receive queue
1119          */
1120         if (sscop_recv_insert(sop, php)) {
1121                 /*
1122                  * Oops, a duplicate sequence number PDU is already on
1123                  * the queue, somethings wrong here.
1124                  */
1125                 sscop_maa_error(sop, 'Q');
1126
1127                 /*
1128                  * Free buffers
1129                  */
1130                 KB_FREEALL(m);
1131
1132                 /*
1133                  * Reestablish a new connection
1134                  */
1135                 qsaal1_reestablish(sop);
1136
1137                 return;
1138         }
1139
1140         /*
1141          * Are we at the high-water mark??
1142          */
1143         if (ns == sop->so_rcvhigh) {
1144                 /*
1145                  * Yes, just bump the mark
1146                  */
1147                 SEQ_INCR(sop->so_rcvhigh, 1);
1148
1149                 if (type == PT_SDP)
1150                         goto dopoll;
1151                 return;
1152         }
1153
1154         /*
1155          * Are we beyond the high-water mark??
1156          */
1157         if (SEQ_GT(ns, sop->so_rcvhigh, sop->so_rcvnext)) {
1158                 /*
1159                  * Yes, then there's a missing PDU, so inform the transmitter
1160                  */
1161                 if (type == PT_SD)
1162                         (void) sscop_send_ustat(sop, ns);
1163
1164                 /*
1165                  * Update high-water mark
1166                  */
1167                 sop->so_rcvhigh = SEQ_ADD(ns, 1);
1168         }
1169
1170         if (type == PT_SD)
1171                 return;
1172
1173 dopoll:
1174         /*
1175          * Do the "poll" part of an SDP PDU
1176          */
1177         poll.poll_nps = htonl(nps);
1178         poll.poll_ns = htonl((PT_POLL << PT_TYPE_SHIFT) | ns);
1179         sscop_poll_ready(sop, NULL, (caddr_t)&poll);
1180         return;
1181 }
1182
1183
1184 /*
1185  * SD PDU / SOS_READY Processor
1186  *
1187  * Arguments:
1188  *      sop     pointer to sscop connection block
1189  *      m       pointer to PDU buffer (without trailer)
1190  *      trlr    pointer to PDU trailer
1191  *
1192  * Returns:
1193  *      none
1194  *
1195  */
1196 static void
1197 sscop_sd_ready(sop, m, trlr)
1198         struct sscop    *sop;
1199         KBuffer         *m;
1200         caddr_t         trlr;
1201 {
1202         /*
1203          * Just call common SD/SDP processor
1204          */
1205         sscop_sd_process(sop, m, trlr, PT_SD);
1206
1207         return;
1208 }
1209
1210
1211 /*
1212  * SDP PDU / SOS_READY Processor
1213  *
1214  * Arguments:
1215  *      sop     pointer to sscop connection block
1216  *      m       pointer to PDU buffer (without trailer)
1217  *      trlr    pointer to PDU trailer
1218  *
1219  * Returns:
1220  *      none
1221  *
1222  */
1223 static void
1224 sscop_sdp_ready(sop, m, trlr)
1225         struct sscop    *sop;
1226         KBuffer         *m;
1227         caddr_t         trlr;
1228 {
1229         /*
1230          * Just call common SD/SDP processor
1231          */
1232         sscop_sd_process(sop, m, trlr, PT_SDP);
1233
1234         return;
1235 }
1236
1237
1238 /*
1239  * POLL PDU / SOS_INRESYN Processor
1240  *
1241  * Arguments:
1242  *      sop     pointer to sscop connection block
1243  *      m       pointer to PDU buffer (without trailer)
1244  *      trlr    pointer to PDU trailer
1245  *
1246  * Returns:
1247  *      none
1248  *
1249  */
1250 static void
1251 sscop_poll_inresyn(sop, m, trlr)
1252         struct sscop    *sop;
1253         KBuffer         *m;
1254         caddr_t         trlr;
1255 {
1256         int             err;
1257
1258         /*
1259          * Stop poll timer
1260          */
1261         sop->so_timer[SSCOP_T_POLL] = 0;
1262         sop->so_flags &= ~SOF_KEEPALIVE;
1263
1264         /*
1265          * Stop lost poll/stat timer
1266          */
1267         sop->so_timer[SSCOP_T_NORESP] = 0;
1268
1269         /*
1270          * Report protocol error
1271          */
1272         sscop_poll_error(sop, m, trlr);
1273
1274         /*
1275          * Return an END to peer
1276          */
1277         (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
1278
1279         /*
1280          * Notify user of connection failure
1281          */
1282         STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
1283                 sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
1284         if (err) {
1285                 sscop_abort(sop, "sscop_poll_inresyn: stack memory\n");
1286                 return;
1287         }
1288
1289         /*
1290          * Clear connection data
1291          */
1292         qsaal1_clear_connection(sop);
1293
1294         /*
1295          * Back to idle state
1296          */
1297         sop->so_state = SOS_IDLE;
1298
1299         return;
1300 }
1301
1302
1303 /*
1304  * POLL PDU / SOS_CONRESYN Processor
1305  *
1306  * Arguments:
1307  *      sop     pointer to sscop connection block
1308  *      m       pointer to PDU buffer (without trailer)
1309  *      trlr    pointer to PDU trailer
1310  *
1311  * Returns:
1312  *      none
1313  *
1314  */
1315 static void
1316 sscop_poll_conresyn(sop, m, trlr)
1317         struct sscop    *sop;
1318         KBuffer         *m;
1319         caddr_t         trlr;
1320 {
1321         int             err;
1322
1323         /*
1324          * Stop retransmit timer
1325          */
1326         sop->so_timer[SSCOP_T_CC] = 0;
1327
1328         /*
1329          * Record error condition
1330          */
1331         sscop_poll_error(sop, m, trlr);
1332
1333         /*
1334          * Return an END to peer
1335          */
1336         (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
1337
1338         /*
1339          * Notify user of connection failure
1340          */
1341         STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
1342                 sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
1343         if (err) {
1344                 sscop_abort(sop, "sscop_poll_conresyn: stack memory\n");
1345                 return;
1346         }
1347
1348         /*
1349          * Clear connection data
1350          */
1351         qsaal1_clear_connection(sop);
1352
1353         /*
1354          * Go back to idle state
1355          */
1356         sop->so_state = SOS_IDLE;
1357
1358         return;
1359 }
1360
1361
1362 /*
1363  * POLL PDU / SOS_READY Processor
1364  *
1365  * Arguments:
1366  *      sop     pointer to sscop connection block
1367  *      m       pointer to PDU buffer (without trailer)
1368  *      trlr    pointer to PDU trailer
1369  *
1370  * Returns:
1371  *      none
1372  *
1373  */
1374 static void
1375 sscop_poll_ready(sop, m, trlr)
1376         struct sscop    *sop;
1377         KBuffer         *m;
1378         caddr_t         trlr;
1379 {
1380         struct poll_pdu *pp = (struct poll_pdu *)trlr;
1381         sscop_seq       nps;
1382
1383         NTOHL(pp->poll_ns);
1384
1385         /*
1386          * If the poll sequence number is less than highest number
1387          * we've already seen, something's wrong - so attempt to
1388          * reestablish a new connection.
1389          */
1390         if (SEQ_LT(pp->poll_ns, sop->so_rcvhigh, sop->so_rcvnext)) {
1391                 /*
1392                  * Record error condition
1393                  */
1394                 sscop_maa_error(sop, 'Q');
1395
1396                 /*
1397                  * Free buffers
1398                  */
1399                 KB_FREEALL(m);
1400
1401                 /*
1402                  * Reestablish a new connection
1403                  */
1404                 qsaal1_reestablish(sop);
1405
1406                 return;
1407         }
1408
1409         /*
1410          * Set a new "next highest" sequence number expected
1411          */
1412         if (SEQ_LT(pp->poll_ns, sop->so_rcvmax, sop->so_rcvnext))
1413                 SEQ_SET(sop->so_rcvhigh, pp->poll_ns);
1414         else
1415                 sop->so_rcvhigh = sop->so_rcvmax;
1416
1417         /*
1418          * Return a STAT PDU to peer
1419          */
1420         SEQ_SET(nps, ntohl(pp->poll_nps));
1421         KB_FREEALL(m);
1422         (void) sscop_send_stat(sop, nps);
1423
1424         return;
1425 }
1426
1427
1428 /*
1429  * STAT PDU / SOS_CONRESYN Processor
1430  *
1431  * Arguments:
1432  *      sop     pointer to sscop connection block
1433  *      m       pointer to PDU buffer (without trailer)
1434  *      trlr    pointer to PDU trailer
1435  *
1436  * Returns:
1437  *      none
1438  *
1439  */
1440 static void
1441 sscop_stat_conresyn(sop, m, trlr)
1442         struct sscop    *sop;
1443         KBuffer         *m;
1444         caddr_t         trlr;
1445 {
1446         int             err;
1447
1448         /*
1449          * Stop retransmit timer
1450          */
1451         sop->so_timer[SSCOP_T_CC] = 0;
1452
1453         /*
1454          * Record error condition
1455          */
1456         sscop_stat_error(sop, m, trlr);
1457
1458         /*
1459          * Return an END to peer
1460          */
1461         (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
1462
1463         /*
1464          * Notify user of connection failure
1465          */
1466         STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
1467                 sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
1468         if (err) {
1469                 sscop_abort(sop, "sscop_stat_conresyn: stack memory\n");
1470                 return;
1471         }
1472
1473         /*
1474          * Clear connection data
1475          */
1476         qsaal1_clear_connection(sop);
1477
1478         /*
1479          * Go back to idle state
1480          */
1481         sop->so_state = SOS_IDLE;
1482
1483         return;
1484 }
1485
1486
1487 /*
1488  * USTAT PDU / SOS_CONRESYN Processor
1489  *
1490  * Arguments:
1491  *      sop     pointer to sscop connection block
1492  *      m       pointer to PDU buffer (without trailer)
1493  *      trlr    pointer to PDU trailer
1494  *
1495  * Returns:
1496  *      none
1497  *
1498  */
1499 static void
1500 sscop_ustat_conresyn(sop, m, trlr)
1501         struct sscop    *sop;
1502         KBuffer         *m;
1503         caddr_t         trlr;
1504 {
1505         int             err;
1506
1507         /*
1508          * Stop retransmit timer
1509          */
1510         sop->so_timer[SSCOP_T_CC] = 0;
1511
1512         /*
1513          * Record error condition
1514          */
1515         sscop_ustat_error(sop, m, trlr);
1516
1517         /*
1518          * Return an END to peer
1519          */
1520         (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
1521
1522         /*
1523          * Notify user of connection failure
1524          */
1525         STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
1526                 sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
1527         if (err) {
1528                 sscop_abort(sop, "sscop_ustat_conresyn: stack memory\n");
1529                 return;
1530         }
1531
1532         /*
1533          * Clear connection data
1534          */
1535         qsaal1_clear_connection(sop);
1536
1537         /*
1538          * Go back to idle state
1539          */
1540         sop->so_state = SOS_IDLE;
1541
1542         return;
1543 }
1544