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