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.5 2006/01/14 13:36:39 swildner Exp $
  28  */
  29
  30 /*
  31  * ATM Forum UNI Support
  32  * ---------------------
  33  *
  34  * SSCF UNI - SSCF_UNI 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.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(int cmd, void *tok, int arg1, int arg2)
  80 {
  81         struct univcc   *uvp = (struct univcc *)tok;
  82         Atm_connvc      *cvp = uvp->uv_connvc;
  83         enum sscop_vers vers;
  84         int             err;
  85
  86         ATM_DEBUG5("sscf_uni_lower: cmd=0x%x, uvp=%p, ustate=%d, arg1=0x%x, arg2=0x%x\n",
  87                 cmd, uvp, uvp->uv_ustate, arg1, arg2);
  88
  89         switch (cmd) {
  90
  91         case SSCF_UNI_INIT:
  92                 /*
  93                  * Validate state
  94                  */
  95                 if (uvp->uv_ustate != UVU_INST) {
  96                         log(LOG_ERR, "sscf_uni_lower: SSCF_INIT in ustate=%d\n",
  97                                 uvp->uv_ustate);
  98                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
  99                         break;
 100                 }
 101
 102                 /*
 103                  * Validate UNI version
 104                  */
 105                 if ((enum uni_vers)arg1 == UNI_VERS_3_0)
 106                         vers = SSCOP_VERS_QSAAL;
 107                 else if ((enum uni_vers)arg1 == UNI_VERS_3_1)
 108                         vers = SSCOP_VERS_Q2110;
 109                 else {
 110                         sscf_uni_abort(uvp, "sscf_uni: bad version\n");
 111                         break;
 112                 }
 113                 uvp->uv_vers = (enum uni_vers)arg1;
 114
 115                 /*
 116                  * Make ourselves ready and pass on the INIT
 117                  */
 118                 uvp->uv_ustate = UVU_RELEASED;
 119                 uvp->uv_lstate = UVL_IDLE;
 120
 121                 STACK_CALL(SSCOP_INIT, uvp->uv_lower, uvp->uv_tokl, cvp,
 122                         (int)vers, (int)&sscf_uni_sscop_parms, err);
 123                 if (err) {
 124                         /*
 125                          * Should never happen
 126                          */
 127                         sscf_uni_abort(uvp, "sscf_uni: INIT failure\n");
 128                 }
 129                 break;
 130
 131         case SSCF_UNI_TERM:
 132                 /*
 133                  * Set termination states
 134                  */
 135                 uvp->uv_ustate = UVU_TERM;
 136                 uvp->uv_lstate = UVL_TERM;
 137
 138                 /*
 139                  * Pass the TERM down the stack
 140                  */
 141                 STACK_CALL(SSCOP_TERM, uvp->uv_lower, uvp->uv_tokl, cvp,
 142                         0, 0, err);
 143                 if (err) {
 144                         /*
 145                          * Should never happen
 146                          */
 147                         sscf_uni_abort(uvp, "sscf_uni: TERM failure\n");
 148                         return;
 149                 }
 150                 atm_free((caddr_t)uvp);
 151                 sscf_uni_vccnt--;
 152                 break;
 153
 154         case SSCF_UNI_ESTABLISH_REQ:
 155                 /*
 156                  * Validation based on user state
 157                  */
 158                 switch (uvp->uv_ustate) {
 159
 160                 case UVU_RELEASED:
 161                 case UVU_PRELEASE:
 162                         /*
 163                          * Establishing a new connection
 164                          */
 165                         uvp->uv_ustate = UVU_PACTIVE;
 166                         uvp->uv_lstate = UVL_OUTCONN;
 167                         STACK_CALL(SSCOP_ESTABLISH_REQ, uvp->uv_lower,
 168                                 uvp->uv_tokl, cvp,
 169                                 SSCOP_UU_NULL, SSCOP_BR_YES, err);
 170                         if (err) {
 171                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 172                                 return;
 173                         }
 174                         break;
 175
 176                 case UVU_ACTIVE:
 177                         /*
 178                          * Resynchronizing a connection
 179                          */
 180                         uvp->uv_ustate = UVU_PACTIVE;
 181                         if (uvp->uv_vers == UNI_VERS_3_0) {
 182                                 uvp->uv_lstate = UVL_OUTCONN;
 183                                 STACK_CALL(SSCOP_ESTABLISH_REQ, uvp->uv_lower,
 184                                         uvp->uv_tokl, cvp,
 185                                         SSCOP_UU_NULL, SSCOP_BR_YES, err);
 186                         } else {
 187                                 uvp->uv_lstate = UVL_OUTRESYN;
 188                                 STACK_CALL(SSCOP_RESYNC_REQ, uvp->uv_lower,
 189                                         uvp->uv_tokl, cvp,
 190                                         SSCOP_UU_NULL, 0, err);
 191                         }
 192                         if (err) {
 193                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 194                                 return;
 195                         }
 196                         break;
 197
 198                 case UVU_TERM:
 199                         /* Ignore */
 200                         break;
 201
 202                 case UVU_INST:
 203                 case UVU_PACTIVE:
 204                 default:
 205                         log(LOG_ERR, "sscf_uni_lower: cmd=0x%x, ustate=%d\n",
 206                                 cmd, uvp->uv_ustate);
 207                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 208                 }
 209                 break;
 210
 211         case SSCF_UNI_RELEASE_REQ:
 212                 /*
 213                  * Validate re-establishment parameter
 214                  */
 215                 switch (arg1) {
 216
 217                 case SSCF_UNI_ESTIND_YES:
 218                         uvp->uv_flags &= ~UVF_NOESTIND;
 219                         break;
 220
 221                 case SSCF_UNI_ESTIND_NO:
 222                         uvp->uv_flags |= UVF_NOESTIND;
 223                         break;
 224
 225                 default:
 226                         sscf_uni_abort(uvp, "sscf_uni: bad estind value\n");
 227                         return;
 228                 }
 229
 230                 /*
 231                  * Validation based on user state
 232                  */
 233                 switch (uvp->uv_ustate) {
 234
 235                 case UVU_RELEASED:
 236                         /*
 237                          * Releasing a non-existant connection
 238                          */
 239                         STACK_CALL(SSCF_UNI_RELEASE_CNF, uvp->uv_upper,
 240                                 uvp->uv_toku, cvp,
 241                                 0, 0, err);
 242                         if (err) {
 243                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 244                                 return;
 245                         }
 246                         break;
 247
 248                 case UVU_PACTIVE:
 249                 case UVU_ACTIVE:
 250                         /*
 251                          * Releasing a connection
 252                          */
 253                         uvp->uv_ustate = UVU_PRELEASE;
 254                         uvp->uv_lstate = UVL_OUTDISC;
 255                         STACK_CALL(SSCOP_RELEASE_REQ, uvp->uv_lower,
 256                                 uvp->uv_tokl, cvp,
 257                                 SSCOP_UU_NULL, 0, err);
 258                         if (err) {
 259                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 260                                 return;
 261                         }
 262                         break;
 263
 264                 case UVU_TERM:
 265                         /* Ignore */
 266                         break;
 267
 268                 case UVU_INST:
 269                 case UVU_PRELEASE:
 270                 default:
 271                         log(LOG_ERR, "sscf_uni_lower: cmd=0x%x, ustate=%d\n",
 272                                 cmd, uvp->uv_ustate);
 273                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 274                 }
 275                 break;
 276
 277         case SSCF_UNI_DATA_REQ:
 278 #ifdef notdef
 279                 sscf_uni_pdu_print(uvp, (KBuffer *)arg1, "DATA_REQ");
 280 #endif
 281
 282                 /*
 283                  * Validation based on user state
 284                  */
 285                 switch (uvp->uv_ustate) {
 286
 287                 case UVU_ACTIVE:
 288                         /*
 289                          * Send assured data on connection
 290                          */
 291                         STACK_CALL(SSCOP_DATA_REQ, uvp->uv_lower,
 292                                 uvp->uv_tokl, cvp,
 293                                 arg1, 0, err);
 294                         if (err) {
 295                                 KB_FREEALL((KBuffer *)arg1);
 296                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 297                                 return;
 298                         }
 299                         break;
 300
 301                 case UVU_RELEASED:
 302                 case UVU_TERM:
 303                         /*
 304                          * Release supplied buffers and ignore
 305                          */
 306                         KB_FREEALL((KBuffer *)arg1);
 307                         break;
 308
 309                 case UVU_INST:
 310                 case UVU_PACTIVE:
 311                 case UVU_PRELEASE:
 312                 default:
 313                         KB_FREEALL((KBuffer *)arg1);
 314                         log(LOG_ERR, "sscf_uni_lower: cmd=0x%x, ustate=%d\n",
 315                                 cmd, uvp->uv_ustate);
 316                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 317                 }
 318                 break;
 319
 320         case SSCF_UNI_UNITDATA_REQ:
 321 #ifdef notdef
 322                 sscf_uni_pdu_print(uvp, (KBuffer *)arg1, "UNITDATA_REQ");
 323 #endif
 324
 325                 /*
 326                  * Validation based on user state
 327                  */
 328                 switch (uvp->uv_ustate) {
 329
 330                 case UVU_RELEASED:
 331                 case UVU_PACTIVE:
 332                 case UVU_PRELEASE:
 333                 case UVU_ACTIVE:
 334                         /*
 335                          * Send unassured data on connection
 336                          */
 337                         STACK_CALL(SSCOP_UNITDATA_REQ, uvp->uv_lower,
 338                                 uvp->uv_tokl, cvp,
 339                                 arg1, 0, err);
 340                         if (err) {
 341                                 KB_FREEALL((KBuffer *)arg1);
 342                                 sscf_uni_abort(uvp, "sscf_uni: stack memory\n");
 343                                 return;
 344                         }
 345                         break;
 346
 347                 case UVU_TERM:
 348                         /*
 349                          * Release supplied buffers and ignore
 350                          */
 351                         KB_FREEALL((KBuffer *)arg1);
 352                         break;
 353
 354                 case UVU_INST:
 355                 default:
 356                         KB_FREEALL((KBuffer *)arg1);
 357                         log(LOG_ERR, "sscf_uni_lower: cmd=0x%x, ustate=%d\n",
 358                                 cmd, uvp->uv_ustate);
 359                         sscf_uni_abort(uvp, "sscf_uni: sequence err\n");
 360                 }
 361                 break;
 362
 363         default:
 364                 log(LOG_ERR, "sscf_uni_lower: unknown cmd 0x%x, uvp=%p\n",
 365                         cmd, uvp);
 366         }
 367
 368         return;
 369 }
 370