sys/netproto/atm/uni/sscf_uni_lower.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_lower.c,v 1.4 1999/08/28 00:48:56 peter Exp $
  27  *      @(#) $DragonFly: src/sys/netproto/atm/uni/sscf_uni_lower.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 - SSCF_UNI 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.h"
  43 #include "sscf_uni_var.h"
  44
  45 /*
  46  * Local variables
  47  */
  48 static struct sscop_parms       sscf_uni_sscop_parms = {
  49         4096,                           /* sp_maxinfo */
  50         4096,                           /* sp_maxuu */
  51         4,                              /* sp_maxcc */
  52         25,                             /* sp_maxpd */
  53         1 * ATM_HZ,                     /* sp_timecc */
  54         2 * ATM_HZ,                     /* sp_timekeep */
  55         7 * ATM_HZ,                     /* sp_timeresp */
  56         1 * ATM_HZ,                     /* sp_timepoll */
  57         15 * ATM_HZ,                    /* sp_timeidle */
  58         80                              /* sp_rcvwin */
  59 };
  60
  61
  62 /*
  63  * SSCF_UNI Lower Stack Command Handler
  64  *
  65  * This function will receive all of the stack commands issued from the
  66  * layer above SSCF UNI (ie. Q.2931).
  67  *
  68  * Arguments:
  69  *      cmd     stack command code
  70  *      tok     session token
  71  *      arg1    command specific argument
  72  *      arg2    command specific argument
  73  *
  74  * Returns:
  75  *      none
  76  *
  77  */
  78 void
  79 sscf_uni_lower(cmd, tok, arg1, arg2)
  80         int     cmd;
  81         void    *tok;
  82         int     arg1;
  83         int     arg2;
  84 {
  85         struct univcc   *uvp = (struct univcc *)tok;
  86         Atm_connvc      *cvp = uvp->uv_connvc;
  87         enum sscop_vers vers;
  88         int             err;
  89
  90         ATM_DEBUG5("sscf_uni_lower: cmd=0x%x, uvp=%p, ustate=%d, arg1=0x%x, arg2=0x%x\n",
  91                 cmd, uvp, uvp->uv_ustate, arg1, arg2);
  92
  93         switch (cmd) {
  94
  95         case SSCF_UNI_INIT:
  96                 /*
  97                  * Validate state
  98                  */
  99                 if (uvp->uv_ustate != UVU_INST) {
 100                         log(LOG_ERR, "sscf_uni_lower: SSCF_INIT in ustate=%d\n",
 101                                 uvp->uv_ustate);
 102                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 103                         break;
 104                 }
 105
 106                 /*
 107                  * Validate UNI version
 108                  */
 109                 if ((enum uni_vers)arg1 == UNI_VERS_3_0)
 110                         vers = SSCOP_VERS_QSAAL;
 111                 else if ((enum uni_vers)arg1 == UNI_VERS_3_1)
 112                         vers = SSCOP_VERS_Q2110;
 113                 else {
 114                         sscf_uni_abort(uvp, "sscf_uni: bad version\n");
 115                         break;
 116                 }
 117                 uvp->uv_vers = (enum uni_vers)arg1;
 118
 119                 /*
 120                  * Make ourselves ready and pass on the INIT
 121                  */
 122                 uvp->uv_ustate = UVU_RELEASED;
 123                 uvp->uv_lstate = UVL_IDLE;
 124
 125                 STACK_CALL(SSCOP_INIT, uvp->uv_lower, uvp->uv_tokl, cvp,
 126                         (int)vers, (int)&sscf_uni_sscop_parms, err);
 127                 if (err) {
 128                         /*
 129                          * Should never happen
 130                          */
 131                         sscf_uni_abort(uvp, "sscf_uni: INIT failure\n");
 132                 }
 133                 break;
 134
 135         case SSCF_UNI_TERM:
 136                 /*
 137                  * Set termination states
 138                  */
 139                 uvp->uv_ustate = UVU_TERM;
 140                 uvp->uv_lstate = UVL_TERM;
 141
 142                 /*
 143                  * Pass the TERM down the stack
 144                  */
 145                 STACK_CALL(SSCOP_TERM, uvp->uv_lower, uvp->uv_tokl, cvp,
 146                         0, 0, err);
 147                 if (err) {
 148                         /*
 149                          * Should never happen
 150                          */
 151                         sscf_uni_abort(uvp, "sscf_uni: TERM failure\n");
 152                         return;
 153                 }
 154                 atm_free((caddr_t)uvp);
 155                 sscf_uni_vccnt--;
 156                 break;
 157
 158         case SSCF_UNI_ESTABLISH_REQ:
 159                 /*
 160                  * Validation based on user state
 161                  */
 162                 switch (uvp->uv_ustate) {
 163
 164                 case UVU_RELEASED:
 165                 case UVU_PRELEASE:
 166                         /*
 167                          * Establishing a new connection
 168                          */
 169                         uvp->uv_ustate = UVU_PACTIVE;
 170                         uvp->uv_lstate = UVL_OUTCONN;
 171                         STACK_CALL(SSCOP_ESTABLISH_REQ, uvp->uv_lower,
 172                                 uvp->uv_tokl, cvp,
 173                                 SSCOP_UU_NULL, SSCOP_BR_YES, err);
 174                         if (err) {
 175                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 176                                 return;
 177                         }
 178                         break;
 179
 180                 case UVU_ACTIVE:
 181                         /*
 182                          * Resynchronizing a connection
 183                          */
 184                         uvp->uv_ustate = UVU_PACTIVE;
 185                         if (uvp->uv_vers == UNI_VERS_3_0) {
 186                                 uvp->uv_lstate = UVL_OUTCONN;
 187                                 STACK_CALL(SSCOP_ESTABLISH_REQ, uvp->uv_lower,
 188                                         uvp->uv_tokl, cvp,
 189                                         SSCOP_UU_NULL, SSCOP_BR_YES, err);
 190                         } else {
 191                                 uvp->uv_lstate = UVL_OUTRESYN;
 192                                 STACK_CALL(SSCOP_RESYNC_REQ, uvp->uv_lower,
 193                                         uvp->uv_tokl, cvp,
 194                                         SSCOP_UU_NULL, 0, err);
 195                         }
 196                         if (err) {
 197                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 198                                 return;
 199                         }
 200                         break;
 201
 202                 case UVU_TERM:
 203                         /* Ignore */
 204                         break;
 205
 206                 case UVU_INST:
 207                 case UVU_PACTIVE:
 208                 default:
 209                         log(LOG_ERR, "sscf_uni_lower: cmd=0x%x, ustate=%d\n",
 210                                 cmd, uvp->uv_ustate);
 211                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 212                 }
 213                 break;
 214
 215         case SSCF_UNI_RELEASE_REQ:
 216                 /*
 217                  * Validate re-establishment parameter
 218                  */
 219                 switch (arg1) {
 220
 221                 case SSCF_UNI_ESTIND_YES:
 222                         uvp->uv_flags &= ~UVF_NOESTIND;
 223                         break;
 224
 225                 case SSCF_UNI_ESTIND_NO:
 226                         uvp->uv_flags |= UVF_NOESTIND;
 227                         break;
 228
 229                 default:
 230                         sscf_uni_abort(uvp, "sscf_uni: bad estind value\n");
 231                         return;
 232                 }
 233
 234                 /*
 235                  * Validation based on user state
 236                  */
 237                 switch (uvp->uv_ustate) {
 238
 239                 case UVU_RELEASED:
 240                         /*
 241                          * Releasing a non-existant connection
 242                          */
 243                         STACK_CALL(SSCF_UNI_RELEASE_CNF, uvp->uv_upper,
 244                                 uvp->uv_toku, cvp,
 245                                 0, 0, err);
 246                         if (err) {
 247                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 248                                 return;
 249                         }
 250                         break;
 251
 252                 case UVU_PACTIVE:
 253                 case UVU_ACTIVE:
 254                         /*
 255                          * Releasing a connection
 256                          */
 257                         uvp->uv_ustate = UVU_PRELEASE;
 258                         uvp->uv_lstate = UVL_OUTDISC;
 259                         STACK_CALL(SSCOP_RELEASE_REQ, uvp->uv_lower,
 260                                 uvp->uv_tokl, cvp,
 261                                 SSCOP_UU_NULL, 0, err);
 262                         if (err) {
 263                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 264                                 return;
 265                         }
 266                         break;
 267
 268                 case UVU_TERM:
 269                         /* Ignore */
 270                         break;
 271
 272                 case UVU_INST:
 273                 case UVU_PRELEASE:
 274                 default:
 275                         log(LOG_ERR, "sscf_uni_lower: cmd=0x%x, ustate=%d\n",
 276                                 cmd, uvp->uv_ustate);
 277                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 278                 }
 279                 break;
 280
 281         case SSCF_UNI_DATA_REQ:
 282 #ifdef notdef
 283                 sscf_uni_pdu_print(uvp, (KBuffer *)arg1, "DATA_REQ");
 284 #endif
 285
 286                 /*
 287                  * Validation based on user state
 288                  */
 289                 switch (uvp->uv_ustate) {
 290
 291                 case UVU_ACTIVE:
 292                         /*
 293                          * Send assured data on connection
 294                          */
 295                         STACK_CALL(SSCOP_DATA_REQ, uvp->uv_lower,
 296                                 uvp->uv_tokl, cvp,
 297                                 arg1, 0, err);
 298                         if (err) {
 299                                 KB_FREEALL((KBuffer *)arg1);
 300                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 301                                 return;
 302                         }
 303                         break;
 304
 305                 case UVU_RELEASED:
 306                 case UVU_TERM:
 307                         /*
 308                          * Release supplied buffers and ignore
 309                          */
 310                         KB_FREEALL((KBuffer *)arg1);
 311                         break;
 312
 313                 case UVU_INST:
 314                 case UVU_PACTIVE:
 315                 case UVU_PRELEASE:
 316                 default:
 317                         KB_FREEALL((KBuffer *)arg1);
 318                         log(LOG_ERR, "sscf_uni_lower: cmd=0x%x, ustate=%d\n",
 319                                 cmd, uvp->uv_ustate);
 320                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 321                 }
 322                 break;
 323
 324         case SSCF_UNI_UNITDATA_REQ:
 325 #ifdef notdef
 326                 sscf_uni_pdu_print(uvp, (KBuffer *)arg1, "UNITDATA_REQ");
 327 #endif
 328
 329                 /*
 330                  * Validation based on user state
 331                  */
 332                 switch (uvp->uv_ustate) {
 333
 334                 case UVU_RELEASED:
 335                 case UVU_PACTIVE:
 336                 case UVU_PRELEASE:
 337                 case UVU_ACTIVE:
 338                         /*
 339                          * Send unassured data on connection
 340                          */
 341                         STACK_CALL(SSCOP_UNITDATA_REQ, uvp->uv_lower,
 342                                 uvp->uv_tokl, cvp,
 343                                 arg1, 0, err);
 344                         if (err) {
 345                                 KB_FREEALL((KBuffer *)arg1);
 346                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 347                                 return;
 348                         }
 349                         break;
 350
 351                 case UVU_TERM:
 352                         /*
 353                          * Release supplied buffers and ignore
 354                          */
 355                         KB_FREEALL((KBuffer *)arg1);
 356                         break;
 357
 358                 case UVU_INST:
 359                 default:
 360                         KB_FREEALL((KBuffer *)arg1);
 361                         log(LOG_ERR, "sscf_uni_lower: cmd=0x%x, ustate=%d\n",
 362                                 cmd, uvp->uv_ustate);
 363                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 364                 }
 365                 break;
 366
 367         default:
 368                 log(LOG_ERR, "sscf_uni_lower: unknown cmd 0x%x, uvp=%p\n",
 369                         cmd, uvp);
 370         }
 371
 372         return;
 373 }
 374