sys/netproto/atm/uni/sscf_uni_upper.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: src/sys/netatm/uni/sscf_uni_upper.c,v 1.5 2000/01/17 20:49:50 mks Exp $
  27  *      @(#) $DragonFly: src/sys/netproto/atm/uni/sscf_uni_upper.c,v 1.3 2003/08/07 21:17:35 dillon Exp $
  28  */
  29
  30 /*
  31  * ATM Forum UNI Support
  32  * ---------------------
  33  *
  34  * SSCF UNI - SSCOP SAP interface processing
  35  *
  36  */
  37
  38 #include <netatm/kern_include.h>
  39
  40 #include "uni.h"
  41 #include "sscop.h"
  42 #include "sscf_uni_var.h"
  43
  44 /*
  45  * SSCF_UNI Upper Stack Command Handler
  46  *
  47  * This function will receive all of the stack commands issued from the
  48  * layer below SSCF UNI (ie. SSCOP).
  49  *
  50  * Arguments:
  51  *      cmd     stack command code
  52  *      tok     session token
  53  *      arg1    command specific argument
  54  *      arg2    command specific argument
  55  *
  56  * Returns:
  57  *      none
  58  *
  59  */
  60 void
  61 sscf_uni_upper(cmd, tok, arg1, arg2)
  62         int     cmd;
  63         void    *tok;
  64         int     arg1;
  65         int     arg2;
  66 {
  67         struct univcc   *uvp = (struct univcc *)tok;
  68         Atm_connvc      *cvp = uvp->uv_connvc;
  69         int             err;
  70
  71         ATM_DEBUG5("sscf_uni_upper: cmd=0x%x, uvp=%p, lstate=%d, arg1=0x%x, arg2=0x%x\n",
  72                 cmd, uvp, uvp->uv_lstate, arg1, arg2);
  73
  74         switch (cmd) {
  75
  76         case SSCOP_ESTABLISH_IND:
  77                 /*
  78                  * We don't support SSCOP User-to-User data, so just
  79                  * get rid of any supplied to us
  80                  */
  81                 if (arg1 != SSCOP_UU_NULL)
  82                         KB_FREEALL((KBuffer *)arg1);
  83
  84                 /*
  85                  * Validation based on sscop state
  86                  */
  87                 switch (uvp->uv_lstate) {
  88
  89                 case UVL_READY:
  90                         if (uvp->uv_vers != UNI_VERS_3_0) {
  91                                 goto seqerr;
  92                         }
  93                         goto doestind;
  94
  95                 case UVL_IDLE:
  96                         /*
  97                          * Incoming connection establishment request
  98                          */
  99
 100                         /*
 101                          * If user doesn't want any more incoming sessions
 102                          * accepted, then refuse request
 103                          */
 104                         if (uvp->uv_flags & UVF_NOESTIND) {
 105                                 STACK_CALL(SSCOP_RELEASE_REQ, uvp->uv_lower,
 106                                         uvp->uv_tokl, cvp,
 107                                         SSCOP_UU_NULL, 0, err);
 108                                 if (err) {
 109                                         sscf_uni_abort(uvp,
 110                                                 "sscf_uni: stack memory\n");
 111                                         return;
 112                                 }
 113                                 break;
 114                         }
 115
 116 doestind:
 117                         /*
 118                          * Tell sscop we've accepted the new connection
 119                          */
 120                         uvp->uv_lstate = UVL_READY;
 121                         STACK_CALL(SSCOP_ESTABLISH_RSP, uvp->uv_lower,
 122                                 uvp->uv_tokl, cvp,
 123                                 SSCOP_UU_NULL, SSCOP_BR_YES, err);
 124                         if (err) {
 125                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 126                                 return;
 127                         }
 128
 129                         /*
 130                          * Now notify the user of the new connection
 131                          */
 132                         uvp->uv_ustate = UVU_ACTIVE;
 133                         STACK_CALL(SSCF_UNI_ESTABLISH_IND, uvp->uv_upper,
 134                                 uvp->uv_toku, cvp,
 135                                 SSCOP_UU_NULL, 0, err);
 136                         if (err) {
 137                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 138                                 return;
 139                         }
 140                         break;
 141
 142                 case UVL_TERM:
 143                         /*
 144                          * Ignoring everything
 145                          */
 146                         break;
 147
 148                 case UVL_INST:
 149                 case UVL_OUTCONN:
 150                 case UVL_INCONN:
 151                 case UVL_OUTDISC:
 152                 case UVL_OUTRESYN:
 153                 case UVL_INRESYN:
 154                 case UVL_RECOVERY:
 155                 default:
 156 seqerr:
 157                         log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n",
 158                                 cmd, uvp->uv_lstate);
 159                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 160                 }
 161                 break;
 162
 163         case SSCOP_ESTABLISH_CNF:
 164                 /*
 165                  * We don't support SSCOP User-to-User data, so just
 166                  * get rid of any supplied to us
 167                  */
 168                 if (arg1 != SSCOP_UU_NULL)
 169                         KB_FREEALL((KBuffer *)arg1);
 170
 171                 /*
 172                  * Validation based on sscop state
 173                  */
 174                 switch (uvp->uv_lstate) {
 175
 176                 case UVL_OUTCONN:
 177                         /*
 178                          * Outgoing connection establishment completed
 179                          */
 180
 181                         /*
 182                          * Tell the user that the connection is established
 183                          */
 184                         uvp->uv_ustate = UVU_ACTIVE;
 185                         uvp->uv_lstate = UVL_READY;
 186                         STACK_CALL(SSCF_UNI_ESTABLISH_CNF, uvp->uv_upper,
 187                                 uvp->uv_toku, cvp,
 188                                 SSCOP_UU_NULL, 0, err);
 189                         if (err) {
 190                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 191                                 return;
 192                         }
 193                         break;
 194
 195                 case UVL_TERM:
 196                         /*
 197                          * Ignoring everything
 198                          */
 199                         break;
 200
 201                 case UVL_INST:
 202                 case UVL_IDLE:
 203                 case UVL_INCONN:
 204                 case UVL_OUTDISC:
 205                 case UVL_OUTRESYN:
 206                 case UVL_INRESYN:
 207                 case UVL_RECOVERY:
 208                 case UVL_READY:
 209                 default:
 210                         log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n",
 211                                 cmd, uvp->uv_lstate);
 212                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 213                 }
 214                 break;
 215
 216         case SSCOP_RELEASE_IND:
 217                 /*
 218                  * We don't support SSCOP User-to-User data, so just
 219                  * get rid of any supplied to us
 220                  */
 221                 if (arg1 != SSCOP_UU_NULL)
 222                         KB_FREEALL((KBuffer *)arg1);
 223
 224                 /*
 225                  * Validation based on sscop state
 226                  */
 227                 switch (uvp->uv_lstate) {
 228
 229                 case UVL_OUTCONN:
 230                 case UVL_OUTRESYN:
 231                 case UVL_READY:
 232                         /*
 233                          * Peer requesting connection termination
 234                          */
 235
 236                         /*
 237                          * Notify the user that the connection
 238                          * has been terminated
 239                          */
 240                         uvp->uv_ustate = UVU_RELEASED;
 241                         uvp->uv_lstate = UVL_IDLE;
 242                         STACK_CALL(SSCF_UNI_RELEASE_IND, uvp->uv_upper,
 243                                 uvp->uv_toku, cvp,
 244                                 SSCOP_UU_NULL, 0, err);
 245                         if (err) {
 246                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 247                                 return;
 248                         }
 249                         break;
 250
 251                 case UVL_TERM:
 252                         /*
 253                          * Ignoring everything
 254                          */
 255                         break;
 256
 257                 case UVL_INST:
 258                 case UVL_IDLE:
 259                 case UVL_INCONN:
 260                 case UVL_OUTDISC:
 261                 case UVL_INRESYN:
 262                 case UVL_RECOVERY:
 263                 default:
 264                         log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n",
 265                                 cmd, uvp->uv_lstate);
 266                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 267                 }
 268                 break;
 269
 270         case SSCOP_RELEASE_CNF:
 271                 /*
 272                  * Validation based on sscop state
 273                  */
 274                 switch (uvp->uv_lstate) {
 275
 276                 case UVL_OUTDISC:
 277                         /*
 278                          * Peer acknowledging connection termination
 279                          */
 280
 281                         /*
 282                          * Notify the user that the connection
 283                          * termination is completed
 284                          */
 285                         uvp->uv_ustate = UVU_RELEASED;
 286                         uvp->uv_lstate = UVL_IDLE;
 287                         STACK_CALL(SSCF_UNI_RELEASE_CNF, uvp->uv_upper,
 288                                 uvp->uv_toku, cvp,
 289                                 SSCOP_UU_NULL, 0, err);
 290                         if (err) {
 291                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 292                                 return;
 293                         }
 294                         break;
 295
 296                 case UVL_TERM:
 297                         /*
 298                          * Ignoring everything
 299                          */
 300                         break;
 301
 302                 case UVL_INST:
 303                 case UVL_IDLE:
 304                 case UVL_OUTCONN:
 305                 case UVL_INCONN:
 306                 case UVL_OUTRESYN:
 307                 case UVL_INRESYN:
 308                 case UVL_RECOVERY:
 309                 case UVL_READY:
 310                 default:
 311                         log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n",
 312                                 cmd, uvp->uv_lstate);
 313                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 314                 }
 315                 break;
 316
 317         case SSCOP_DATA_IND:
 318 #ifdef notdef
 319                 sscf_uni_pdu_print(uvp, (KBuffer *)arg1, "DATA_IND");
 320 #endif
 321
 322                 /*
 323                  * Validation based on sscop state
 324                  */
 325                 switch (uvp->uv_lstate) {
 326
 327                 case UVL_READY:
 328                         /*
 329                          * Incoming assured data from peer
 330                          */
 331
 332                         /*
 333                          * Pass the data up to the user
 334                          */
 335                         STACK_CALL(SSCF_UNI_DATA_IND, uvp->uv_upper,
 336                                 uvp->uv_toku, cvp,
 337                                 arg1, 0, err);
 338                         if (err) {
 339                                 KB_FREEALL((KBuffer *)arg1);
 340                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 341                                 return;
 342                         }
 343                         break;
 344
 345                 case UVL_TERM:
 346                         /*
 347                          * Ignoring everything
 348                          */
 349                         KB_FREEALL((KBuffer *)arg1);
 350                         break;
 351
 352                 case UVL_INST:
 353                 case UVL_IDLE:
 354                 case UVL_OUTCONN:
 355                 case UVL_INCONN:
 356                 case UVL_OUTDISC:
 357                 case UVL_OUTRESYN:
 358                 case UVL_INRESYN:
 359                 case UVL_RECOVERY:
 360                 default:
 361                         KB_FREEALL((KBuffer *)arg1);
 362                         log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n",
 363                                 cmd, uvp->uv_lstate);
 364                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 365                 }
 366                 break;
 367
 368         case SSCOP_RESYNC_IND:
 369                 /*
 370                  * We don't support SSCOP User-to-User data, so just
 371                  * get rid of any supplied to us
 372                  */
 373                 if (arg1 != SSCOP_UU_NULL)
 374                         KB_FREEALL((KBuffer *)arg1);
 375
 376                 /*
 377                  * Validation based on sscop state
 378                  */
 379                 switch (uvp->uv_lstate) {
 380
 381                 case UVL_READY:
 382                         /*
 383                          * Incoming connection resynchronization request
 384                          */
 385
 386                         /*
 387                          * Send resynch acknowledgement to sscop
 388                          */
 389                         STACK_CALL(SSCOP_RESYNC_RSP, uvp->uv_lower,
 390                                 uvp->uv_tokl, cvp,
 391                                 0, 0, err);
 392                         if (err) {
 393                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 394                                 return;
 395                         }
 396
 397                         if (uvp->uv_vers != UNI_VERS_3_0) {
 398
 399                                 /*
 400                                  * Notify the user that the connection
 401                                  * has been resynced
 402                                  */
 403                                 STACK_CALL(SSCF_UNI_ESTABLISH_IND,
 404                                         uvp->uv_upper, uvp->uv_toku, cvp,
 405                                         SSCOP_UU_NULL, 0, err);
 406                                 if (err) {
 407                                         sscf_uni_abort(uvp,
 408                                                 "sscf_uni: stack memory\n");
 409                                         return;
 410                                 }
 411                         }
 412                         break;
 413
 414                 case UVL_TERM:
 415                         /*
 416                          * Ignoring everything
 417                          */
 418                         break;
 419
 420                 case UVL_INST:
 421                 case UVL_IDLE:
 422                 case UVL_OUTCONN:
 423                 case UVL_INCONN:
 424                 case UVL_OUTDISC:
 425                 case UVL_OUTRESYN:
 426                 case UVL_INRESYN:
 427                 case UVL_RECOVERY:
 428                 default:
 429                         log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n",
 430                                 cmd, uvp->uv_lstate);
 431                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 432                 }
 433                 break;
 434
 435         case SSCOP_RESYNC_CNF:
 436                 /*
 437                  * Not supported in version 3.0
 438                  */
 439                 if (uvp->uv_vers == UNI_VERS_3_0) {
 440                         sscf_uni_abort(uvp,
 441                                 "sscf_uni: SSCOP_RESYNC_CNF in 3.0\n");
 442                         return;
 443                 }
 444
 445                 /*
 446                  * Validation based on sscop state
 447                  */
 448                 switch (uvp->uv_lstate) {
 449
 450                 case UVL_OUTRESYN:
 451                         /*
 452                          * Peer acknowledging connection resynchronization
 453                          */
 454
 455                         /*
 456                          * Now notify the user that the connection
 457                          * has been resynced
 458                          */
 459                         uvp->uv_ustate = UVU_ACTIVE;
 460                         uvp->uv_lstate = UVL_READY;
 461                         STACK_CALL(SSCF_UNI_ESTABLISH_CNF, uvp->uv_upper,
 462                                 uvp->uv_toku, cvp,
 463                                 SSCOP_UU_NULL, 0, err);
 464                         if (err) {
 465                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 466                                 return;
 467                         }
 468                         break;
 469
 470                 case UVL_TERM:
 471                         /*
 472                          * Ignoring everything
 473                          */
 474                         break;
 475
 476                 case UVL_INST:
 477                 case UVL_IDLE:
 478                 case UVL_OUTCONN:
 479                 case UVL_INCONN:
 480                 case UVL_OUTDISC:
 481                 case UVL_INRESYN:
 482                 case UVL_RECOVERY:
 483                 case UVL_READY:
 484                 default:
 485                         log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n",
 486                                 cmd, uvp->uv_lstate);
 487                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 488                 }
 489                 break;
 490
 491         case SSCOP_RECOVER_IND:
 492                 /*
 493                  * Not supported in version 3.0
 494                  */
 495                 if (uvp->uv_vers == UNI_VERS_3_0) {
 496                         sscf_uni_abort(uvp,
 497                                 "sscf_uni: SSCOP_RECOVER_IND in 3.0\n");
 498                         return;
 499                 }
 500
 501                 /*
 502                  * Validation based on sscop state
 503                  */
 504                 switch (uvp->uv_lstate) {
 505
 506                 case UVL_READY:
 507                         /*
 508                          * Recover connection due to internal problems
 509                          */
 510
 511                         /*
 512                          * Send recovery acknowledgement to sscop
 513                          */
 514                         STACK_CALL(SSCOP_RECOVER_RSP, uvp->uv_lower,
 515                                 uvp->uv_tokl, cvp,
 516                                 0, 0, err);
 517                         if (err) {
 518                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 519                                 return;
 520                         }
 521
 522                         /*
 523                          * Now notify the user that the connection
 524                          * has been recovered
 525                          */
 526                         STACK_CALL(SSCF_UNI_ESTABLISH_IND, uvp->uv_upper,
 527                                 uvp->uv_toku, cvp,
 528                                 SSCOP_UU_NULL, 0, err);
 529                         if (err) {
 530                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 531                                 return;
 532                         }
 533                         break;
 534
 535                 case UVL_TERM:
 536                         /*
 537                          * Ignoring everything
 538                          */
 539                         break;
 540
 541                 case UVL_INST:
 542                 case UVL_IDLE:
 543                 case UVL_OUTCONN:
 544                 case UVL_INCONN:
 545                 case UVL_OUTDISC:
 546                 case UVL_OUTRESYN:
 547                 case UVL_INRESYN:
 548                 case UVL_RECOVERY:
 549                 default:
 550                         log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n",
 551                                 cmd, uvp->uv_lstate);
 552                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 553                 }
 554                 break;
 555
 556         case SSCOP_UNITDATA_IND:
 557 #ifdef notdef
 558                 sscf_uni_pdu_print(uvp, (KBuffer *)arg1, "UNITDATA_IND");
 559 #endif
 560
 561                 /*
 562                  * Validation based on sscop state
 563                  */
 564                 switch (uvp->uv_lstate) {
 565
 566                 case UVL_IDLE:
 567                 case UVL_OUTCONN:
 568                 case UVL_INCONN:
 569                 case UVL_OUTDISC:
 570                 case UVL_OUTRESYN:
 571                 case UVL_INRESYN:
 572                 case UVL_RECOVERY:
 573                 case UVL_READY:
 574                         /*
 575                          * Incoming unassured data from peer
 576                          */
 577
 578                         /*
 579                          * Pass the data up to the user
 580                          */
 581                         STACK_CALL(SSCF_UNI_UNITDATA_IND, uvp->uv_upper,
 582                                 uvp->uv_toku, cvp,
 583                                 arg1, 0, err);
 584                         if (err) {
 585                                 KB_FREEALL((KBuffer *)arg1);
 586                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 587                                 return;
 588                         }
 589                         break;
 590
 591                 case UVL_TERM:
 592                         /*
 593                          * Ignoring everything
 594                          */
 595                         KB_FREEALL((KBuffer *)arg1);
 596                         break;
 597
 598                 case UVL_INST:
 599                 default:
 600                         KB_FREEALL((KBuffer *)arg1);
 601                         log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n",
 602                                 cmd, uvp->uv_lstate);
 603                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 604                 }
 605                 break;
 606
 607         case SSCOP_RETRIEVE_IND:
 608         case SSCOP_RETRIEVECMP_IND:
 609                 /*
 610                  * Not supported
 611                  */
 612         default:
 613                 log(LOG_ERR, "sscf_uni_upper: unknown cmd 0x%x, uvp=%p\n",
 614                         cmd, uvp);
 615         }
 616
 617         return;
 618 }
 619