drivers/isdn/hisax/l3ni1.c

   1 /* $Id: l3ni1.c,v 2.8.2.3 2004/01/13 14:31:25 keil Exp $
   2  *
   3  * NI1 D-channel protocol
   4  *
   5  * Author       Matt Henderson & Guy Ellis
   6  * Copyright    by Traverse Technologies Pty Ltd, www.travers.com.au
   7  *
   8  * This software may be used and distributed according to the terms
   9  * of the GNU General Public License, incorporated herein by reference.
  10  *
  11  * 2000.6.6 Initial implementation of routines for US NI1
  12  * Layer 3 protocol based on the EURO/DSS1 D-channel protocol
  13  * driver written by Karsten Keil et al.
  14  * NI-1 Hall of Fame - Thanks to....
  15  * Ragnar Paulson - for some handy code fragments
  16  * Will Scales - beta tester extraordinaire
  17  * Brett Whittacre - beta tester and remote devel system in Vegas
  18  *
  19  */
  20
  21 #include "hisax.h"
  22 #include "isdnl3.h"
  23 #include "l3ni1.h"
  24 #include <linux/ctype.h>
  25 #include <linux/slab.h>
  26
  27 extern char *HiSax_getrev(const char *revision);
  28 static const char *ni1_revision = "$Revision: 2.8.2.3 $";
  29
  30 #define EXT_BEARER_CAPS 1
  31
  32 #define MsgHead(ptr, cref, mty)                 \
  33         *ptr++ = 0x8;                           \
  34         if (cref == -1) {                       \
  35                 *ptr++ = 0x0;                   \
  36         } else {                                \
  37                 *ptr++ = 0x1;                   \
  38                 *ptr++ = cref^0x80;             \
  39         }                                       \
  40         *ptr++ = mty
  41
  42
  43 /**********************************************/
  44 /* get a new invoke id for remote operations. */
  45 /* Only a return value != 0 is valid          */
  46 /**********************************************/
  47 static unsigned char new_invoke_id(struct PStack *p)
  48 {
  49         unsigned char retval;
  50         int i;
  51
  52         i = 32; /* maximum search depth */
  53
  54         retval = p->prot.ni1.last_invoke_id + 1; /* try new id */
  55         while ((i) && (p->prot.ni1.invoke_used[retval >> 3] == 0xFF)) {
  56                 p->prot.ni1.last_invoke_id = (retval & 0xF8) + 8;
  57                 i--;
  58         }
  59         if (i) {
  60                 while (p->prot.ni1.invoke_used[retval >> 3] & (1 << (retval & 7)))
  61                         retval++;
  62         } else
  63                 retval = 0;
  64         p->prot.ni1.last_invoke_id = retval;
  65         p->prot.ni1.invoke_used[retval >> 3] |= (1 << (retval & 7));
  66         return (retval);
  67 } /* new_invoke_id */
  68
  69 /*************************/
  70 /* free a used invoke id */
  71 /*************************/
  72 static void free_invoke_id(struct PStack *p, unsigned char id)
  73 {
  74
  75         if (!id) return; /* 0 = invalid value */
  76
  77         p->prot.ni1.invoke_used[id >> 3] &= ~(1 << (id & 7));
  78 } /* free_invoke_id */
  79
  80
  81 /**********************************************************/
  82 /* create a new l3 process and fill in ni1 specific data */
  83 /**********************************************************/
  84 static struct l3_process
  85 *ni1_new_l3_process(struct PStack *st, int cr)
  86 {  struct l3_process *proc;
  87
  88         if (!(proc = new_l3_process(st, cr)))
  89                 return (NULL);
  90
  91         proc->prot.ni1.invoke_id = 0;
  92         proc->prot.ni1.remote_operation = 0;
  93         proc->prot.ni1.uus1_data[0] = '\0';
  94
  95         return (proc);
  96 } /* ni1_new_l3_process */
  97
  98 /************************************************/
  99 /* free a l3 process and all ni1 specific data */
 100 /************************************************/
 101 static void
 102 ni1_release_l3_process(struct l3_process *p)
 103 {
 104         free_invoke_id(p->st, p->prot.ni1.invoke_id);
 105         release_l3_process(p);
 106 } /* ni1_release_l3_process */
 107
 108 /********************************************************/
 109 /* search a process with invoke id id and dummy callref */
 110 /********************************************************/
 111 static struct l3_process *
 112 l3ni1_search_dummy_proc(struct PStack *st, int id)
 113 { struct l3_process *pc = st->l3.proc; /* start of processes */
 114
 115         if (!id) return (NULL);
 116
 117         while (pc)
 118         { if ((pc->callref == -1) && (pc->prot.ni1.invoke_id == id))
 119                         return (pc);
 120                 pc = pc->next;
 121         }
 122         return (NULL);
 123 } /* l3ni1_search_dummy_proc */
 124
 125 /*******************************************************************/
 126 /* called when a facility message with a dummy callref is received */
 127 /* and a return result is delivered. id specifies the invoke id.   */
 128 /*******************************************************************/
 129 static void
 130 l3ni1_dummy_return_result(struct PStack *st, int id, u_char *p, u_char nlen)
 131 { isdn_ctrl ic;
 132         struct IsdnCardState *cs;
 133         struct l3_process *pc = NULL;
 134
 135         if ((pc = l3ni1_search_dummy_proc(st, id)))
 136         { L3DelTimer(&pc->timer); /* remove timer */
 137
 138                 cs = pc->st->l1.hardware;
 139                 ic.driver = cs->myid;
 140                 ic.command = ISDN_STAT_PROT;
 141                 ic.arg = NI1_STAT_INVOKE_RES;
 142                 ic.parm.ni1_io.hl_id = pc->prot.ni1.invoke_id;
 143                 ic.parm.ni1_io.ll_id = pc->prot.ni1.ll_id;
 144                 ic.parm.ni1_io.proc = pc->prot.ni1.proc;
 145                 ic.parm.ni1_io.timeout = 0;
 146                 ic.parm.ni1_io.datalen = nlen;
 147                 ic.parm.ni1_io.data = p;
 148                 free_invoke_id(pc->st, pc->prot.ni1.invoke_id);
 149                 pc->prot.ni1.invoke_id = 0; /* reset id */
 150
 151                 cs->iif.statcallb(&ic);
 152                 ni1_release_l3_process(pc);
 153         }
 154         else
 155                 l3_debug(st, "dummy return result id=0x%x result len=%d", id, nlen);
 156 } /* l3ni1_dummy_return_result */
 157
 158 /*******************************************************************/
 159 /* called when a facility message with a dummy callref is received */
 160 /* and a return error is delivered. id specifies the invoke id.    */
 161 /*******************************************************************/
 162 static void
 163 l3ni1_dummy_error_return(struct PStack *st, int id, ulong error)
 164 { isdn_ctrl ic;
 165         struct IsdnCardState *cs;
 166         struct l3_process *pc = NULL;
 167
 168         if ((pc = l3ni1_search_dummy_proc(st, id)))
 169         { L3DelTimer(&pc->timer); /* remove timer */
 170
 171                 cs = pc->st->l1.hardware;
 172                 ic.driver = cs->myid;
 173                 ic.command = ISDN_STAT_PROT;
 174                 ic.arg = NI1_STAT_INVOKE_ERR;
 175                 ic.parm.ni1_io.hl_id = pc->prot.ni1.invoke_id;
 176                 ic.parm.ni1_io.ll_id = pc->prot.ni1.ll_id;
 177                 ic.parm.ni1_io.proc = pc->prot.ni1.proc;
 178                 ic.parm.ni1_io.timeout = error;
 179                 ic.parm.ni1_io.datalen = 0;
 180                 ic.parm.ni1_io.data = NULL;
 181                 free_invoke_id(pc->st, pc->prot.ni1.invoke_id);
 182                 pc->prot.ni1.invoke_id = 0; /* reset id */
 183
 184                 cs->iif.statcallb(&ic);
 185                 ni1_release_l3_process(pc);
 186         }
 187         else
 188                 l3_debug(st, "dummy return error id=0x%x error=0x%lx", id, error);
 189 } /* l3ni1_error_return */
 190
 191 /*******************************************************************/
 192 /* called when a facility message with a dummy callref is received */
 193 /* and a invoke is delivered. id specifies the invoke id.          */
 194 /*******************************************************************/
 195 static void
 196 l3ni1_dummy_invoke(struct PStack *st, int cr, int id,
 197                    int ident, u_char *p, u_char nlen)
 198 { isdn_ctrl ic;
 199         struct IsdnCardState *cs;
 200
 201         l3_debug(st, "dummy invoke %s id=0x%x ident=0x%x datalen=%d",
 202                  (cr == -1) ? "local" : "broadcast", id, ident, nlen);
 203         if (cr >= -1) return; /* ignore local data */
 204
 205         cs = st->l1.hardware;
 206         ic.driver = cs->myid;
 207         ic.command = ISDN_STAT_PROT;
 208         ic.arg = NI1_STAT_INVOKE_BRD;
 209         ic.parm.ni1_io.hl_id = id;
 210         ic.parm.ni1_io.ll_id = 0;
 211         ic.parm.ni1_io.proc = ident;
 212         ic.parm.ni1_io.timeout = 0;
 213         ic.parm.ni1_io.datalen = nlen;
 214         ic.parm.ni1_io.data = p;
 215
 216         cs->iif.statcallb(&ic);
 217 } /* l3ni1_dummy_invoke */
 218
 219 static void
 220 l3ni1_parse_facility(struct PStack *st, struct l3_process *pc,
 221                      int cr, u_char *p)
 222 {
 223         int qd_len = 0;
 224         unsigned char nlen = 0, ilen, cp_tag;
 225         int ident, id;
 226         ulong err_ret;
 227
 228         if (pc)
 229                 st = pc->st; /* valid Stack */
 230         else
 231                 if ((!st) || (cr >= 0)) return; /* neither pc nor st specified */
 232
 233         p++;
 234         qd_len = *p++;
 235         if (qd_len == 0) {
 236                 l3_debug(st, "qd_len == 0");
 237                 return;
 238         }
 239         if ((*p & 0x1F) != 0x11) {      /* Service discriminator, supplementary service */
 240                 l3_debug(st, "supplementary service != 0x11");
 241                 return;
 242         }
 243         while (qd_len > 0 && !(*p & 0x80)) {    /* extension ? */
 244                 p++;
 245                 qd_len--;
 246         }
 247         if (qd_len < 2) {
 248                 l3_debug(st, "qd_len < 2");
 249                 return;
 250         }
 251         p++;
 252         qd_len--;
 253         if ((*p & 0xE0) != 0xA0) {      /* class and form */
 254                 l3_debug(st, "class and form != 0xA0");
 255                 return;
 256         }
 257
 258         cp_tag = *p & 0x1F; /* remember tag value */
 259
 260         p++;
 261         qd_len--;
 262         if (qd_len < 1)
 263         { l3_debug(st, "qd_len < 1");
 264                 return;
 265         }
 266         if (*p & 0x80)
 267         { /* length format indefinite or limited */
 268                 nlen = *p++ & 0x7F; /* number of len bytes or indefinite */
 269                 if ((qd_len-- < ((!nlen) ? 3 : (1 + nlen))) ||
 270                     (nlen > 1))
 271                 { l3_debug(st, "length format error or not implemented");
 272                         return;
 273                 }
 274                 if (nlen == 1)
 275                 { nlen = *p++; /* complete length */
 276                         qd_len--;
 277                 }
 278                 else
 279                 { qd_len -= 2; /* trailing null bytes */
 280                         if ((*(p + qd_len)) || (*(p + qd_len + 1)))
 281                         { l3_debug(st, "length format indefinite error");
 282                                 return;
 283                         }
 284                         nlen = qd_len;
 285                 }
 286         }
 287         else
 288         { nlen = *p++;
 289                 qd_len--;
 290         }
 291         if (qd_len < nlen)
 292         { l3_debug(st, "qd_len < nlen");
 293                 return;
 294         }
 295         qd_len -= nlen;
 296
 297         if (nlen < 2)
 298         { l3_debug(st, "nlen < 2");
 299                 return;
 300         }
 301         if (*p != 0x02)
 302         {  /* invoke identifier tag */
 303                 l3_debug(st, "invoke identifier tag !=0x02");
 304                 return;
 305         }
 306         p++;
 307         nlen--;
 308         if (*p & 0x80)
 309         { /* length format */
 310                 l3_debug(st, "invoke id length format 2");
 311                 return;
 312         }
 313         ilen = *p++;
 314         nlen--;
 315         if (ilen > nlen || ilen == 0)
 316         { l3_debug(st, "ilen > nlen || ilen == 0");
 317                 return;
 318         }
 319         nlen -= ilen;
 320         id = 0;
 321         while (ilen > 0)
 322         { id = (id << 8) | (*p++ & 0xFF);       /* invoke identifier */
 323                 ilen--;
 324         }
 325
 326         switch (cp_tag) {       /* component tag */
 327         case 1: /* invoke */
 328                 if (nlen < 2) {
 329                         l3_debug(st, "nlen < 2 22");
 330                         return;
 331                 }
 332                 if (*p != 0x02) {       /* operation value */
 333                         l3_debug(st, "operation value !=0x02");
 334                         return;
 335                 }
 336                 p++;
 337                 nlen--;
 338                 ilen = *p++;
 339                 nlen--;
 340                 if (ilen > nlen || ilen == 0) {
 341                         l3_debug(st, "ilen > nlen || ilen == 0 22");
 342                         return;
 343                 }
 344                 nlen -= ilen;
 345                 ident = 0;
 346                 while (ilen > 0) {
 347                         ident = (ident << 8) | (*p++ & 0xFF);
 348                         ilen--;
 349                 }
 350
 351                 if (!pc)
 352                 {
 353                         l3ni1_dummy_invoke(st, cr, id, ident, p, nlen);
 354                         return;
 355                 }
 356                 l3_debug(st, "invoke break");
 357                 break;
 358         case 2: /* return result */
 359                 /* if no process available handle separately */
 360                 if (!pc)
 361                 { if (cr == -1)
 362                                 l3ni1_dummy_return_result(st, id, p, nlen);
 363                         return;
 364                 }
 365                 if ((pc->prot.ni1.invoke_id) && (pc->prot.ni1.invoke_id == id))
 366                 { /* Diversion successful */
 367                         free_invoke_id(st, pc->prot.ni1.invoke_id);
 368                         pc->prot.ni1.remote_result = 0; /* success */
 369                         pc->prot.ni1.invoke_id = 0;
 370                         pc->redir_result = pc->prot.ni1.remote_result;
 371                         st->l3.l3l4(st, CC_REDIR | INDICATION, pc); } /* Diversion successful */
 372                 else
 373                         l3_debug(st, "return error unknown identifier");
 374                 break;
 375         case 3: /* return error */
 376                 err_ret = 0;
 377                 if (nlen < 2)
 378                 { l3_debug(st, "return error nlen < 2");
 379                         return;
 380                 }
 381                 if (*p != 0x02)
 382                 { /* result tag */
 383                         l3_debug(st, "invoke error tag !=0x02");
 384                         return;
 385                 }
 386                 p++;
 387                 nlen--;
 388                 if (*p > 4)
 389                 { /* length format */
 390                         l3_debug(st, "invoke return errlen > 4 ");
 391                         return;
 392                 }
 393                 ilen = *p++;
 394                 nlen--;
 395                 if (ilen > nlen || ilen == 0)
 396                 { l3_debug(st, "error return ilen > nlen || ilen == 0");
 397                         return;
 398                 }
 399                 nlen -= ilen;
 400                 while (ilen > 0)
 401                 { err_ret = (err_ret << 8) | (*p++ & 0xFF);     /* error value */
 402                         ilen--;
 403                 }
 404                 /* if no process available handle separately */
 405                 if (!pc)
 406                 { if (cr == -1)
 407                                 l3ni1_dummy_error_return(st, id, err_ret);
 408                         return;
 409                 }
 410                 if ((pc->prot.ni1.invoke_id) && (pc->prot.ni1.invoke_id == id))
 411                 { /* Deflection error */
 412                         free_invoke_id(st, pc->prot.ni1.invoke_id);
 413                         pc->prot.ni1.remote_result = err_ret; /* result */
 414                         pc->prot.ni1.invoke_id = 0;
 415                         pc->redir_result = pc->prot.ni1.remote_result;
 416                         st->l3.l3l4(st, CC_REDIR | INDICATION, pc);
 417                 } /* Deflection error */
 418                 else
 419                         l3_debug(st, "return result unknown identifier");
 420                 break;
 421         default:
 422                 l3_debug(st, "facility default break tag=0x%02x", cp_tag);
 423                 break;
 424         }
 425 }
 426
 427 static void
 428 l3ni1_message(struct l3_process *pc, u_char mt)
 429 {
 430         struct sk_buff *skb;
 431         u_char *p;
 432
 433         if (!(skb = l3_alloc_skb(4)))
 434                 return;
 435         p = skb_put(skb, 4);
 436         MsgHead(p, pc->callref, mt);
 437         l3_msg(pc->st, DL_DATA | REQUEST, skb);
 438 }
 439
 440 static void
 441 l3ni1_message_plus_chid(struct l3_process *pc, u_char mt)
 442 /* sends an l3 messages plus channel id -  added GE 05/09/00 */
 443 {
 444         struct sk_buff *skb;
 445         u_char tmp[16];
 446         u_char *p = tmp;
 447         u_char chid;
 448
 449         chid = (u_char)(pc->para.bchannel & 0x03) | 0x88;
 450         MsgHead(p, pc->callref, mt);
 451         *p++ = IE_CHANNEL_ID;
 452         *p++ = 0x01;
 453         *p++ = chid;
 454
 455         if (!(skb = l3_alloc_skb(7)))
 456                 return;
 457         memcpy(skb_put(skb, 7), tmp, 7);
 458         l3_msg(pc->st, DL_DATA | REQUEST, skb);
 459 }
 460
 461 static void
 462 l3ni1_message_cause(struct l3_process *pc, u_char mt, u_char cause)
 463 {
 464         struct sk_buff *skb;
 465         u_char tmp[16];
 466         u_char *p = tmp;
 467         int l;
 468
 469         MsgHead(p, pc->callref, mt);
 470         *p++ = IE_CAUSE;
 471         *p++ = 0x2;
 472         *p++ = 0x80;
 473         *p++ = cause | 0x80;
 474
 475         l = p - tmp;
 476         if (!(skb = l3_alloc_skb(l)))
 477                 return;
 478         memcpy(skb_put(skb, l), tmp, l);
 479         l3_msg(pc->st, DL_DATA | REQUEST, skb);
 480 }
 481
 482 static void
 483 l3ni1_status_send(struct l3_process *pc, u_char pr, void *arg)
 484 {
 485         u_char tmp[16];
 486         u_char *p = tmp;
 487         int l;
 488         struct sk_buff *skb;
 489
 490         MsgHead(p, pc->callref, MT_STATUS);
 491
 492         *p++ = IE_CAUSE;
 493         *p++ = 0x2;
 494         *p++ = 0x80;
 495         *p++ = pc->para.cause | 0x80;
 496
 497         *p++ = IE_CALL_STATE;
 498         *p++ = 0x1;
 499         *p++ = pc->state & 0x3f;
 500
 501         l = p - tmp;
 502         if (!(skb = l3_alloc_skb(l)))
 503                 return;
 504         memcpy(skb_put(skb, l), tmp, l);
 505         l3_msg(pc->st, DL_DATA | REQUEST, skb);
 506 }
 507
 508 static void
 509 l3ni1_msg_without_setup(struct l3_process *pc, u_char pr, void *arg)
 510 {
 511         /* This routine is called if here was no SETUP made (checks in ni1up and in
 512          * l3ni1_setup) and a RELEASE_COMPLETE have to be sent with an error code
 513          * MT_STATUS_ENQUIRE in the NULL state is handled too
 514          */
 515         u_char tmp[16];
 516         u_char *p = tmp;
 517         int l;
 518         struct sk_buff *skb;
 519
 520         switch (pc->para.cause) {
 521         case 81:        /* invalid callreference */
 522         case 88:        /* incomp destination */
 523         case 96:        /* mandory IE missing */
 524         case 100:       /* invalid IE contents */
 525         case 101:       /* incompatible Callstate */
 526                 MsgHead(p, pc->callref, MT_RELEASE_COMPLETE);
 527                 *p++ = IE_CAUSE;
 528                 *p++ = 0x2;
 529                 *p++ = 0x80;
 530                 *p++ = pc->para.cause | 0x80;
 531                 break;
 532         default:
 533                 printk(KERN_ERR "HiSax l3ni1_msg_without_setup wrong cause %d\n",
 534                        pc->para.cause);
 535                 return;
 536         }
 537         l = p - tmp;
 538         if (!(skb = l3_alloc_skb(l)))
 539                 return;
 540         memcpy(skb_put(skb, l), tmp, l);
 541         l3_msg(pc->st, DL_DATA | REQUEST, skb);
 542         ni1_release_l3_process(pc);
 543 }
 544
 545 static int ie_ALERTING[] = {IE_BEARER, IE_CHANNEL_ID | IE_MANDATORY_1,
 546                             IE_FACILITY, IE_PROGRESS, IE_DISPLAY, IE_SIGNAL, IE_HLC,
 547                             IE_USER_USER, -1};
 548 static int ie_CALL_PROCEEDING[] = {IE_BEARER, IE_CHANNEL_ID | IE_MANDATORY_1,
 549                                    IE_FACILITY, IE_PROGRESS, IE_DISPLAY, IE_HLC, -1};
 550 static int ie_CONNECT[] = {IE_BEARER, IE_CHANNEL_ID | IE_MANDATORY_1,
 551                            IE_FACILITY, IE_PROGRESS, IE_DISPLAY, IE_DATE, IE_SIGNAL,
 552                            IE_CONNECT_PN, IE_CONNECT_SUB, IE_LLC, IE_HLC, IE_USER_USER, -1};
 553 static int ie_CONNECT_ACKNOWLEDGE[] = {IE_CHANNEL_ID, IE_DISPLAY, IE_SIGNAL, -1};
 554 static int ie_DISCONNECT[] = {IE_CAUSE | IE_MANDATORY, IE_FACILITY,
 555                               IE_PROGRESS, IE_DISPLAY, IE_SIGNAL, IE_USER_USER, -1};
 556 static int ie_INFORMATION[] = {IE_COMPLETE, IE_DISPLAY, IE_KEYPAD, IE_SIGNAL,
 557                                IE_CALLED_PN, -1};
 558 static int ie_NOTIFY[] = {IE_BEARER, IE_NOTIFY | IE_MANDATORY, IE_DISPLAY, -1};
 559 static int ie_PROGRESS[] = {IE_BEARER, IE_CAUSE, IE_FACILITY, IE_PROGRESS |
 560                             IE_MANDATORY, IE_DISPLAY, IE_HLC, IE_USER_USER, -1};
 561 static int ie_RELEASE[] = {IE_CAUSE | IE_MANDATORY_1, IE_FACILITY, IE_DISPLAY,
 562                            IE_SIGNAL, IE_USER_USER, -1};
 563 /* a RELEASE_COMPLETE with errors don't require special actions
 564    static int ie_RELEASE_COMPLETE[] = {IE_CAUSE | IE_MANDATORY_1, IE_DISPLAY, IE_SIGNAL, IE_USER_USER, -1};
 565 */
 566 static int ie_RESUME_ACKNOWLEDGE[] = {IE_CHANNEL_ID | IE_MANDATORY, IE_FACILITY,
 567                                       IE_DISPLAY, -1};
 568 static int ie_RESUME_REJECT[] = {IE_CAUSE | IE_MANDATORY, IE_DISPLAY, -1};
 569 static int ie_SETUP[] = {IE_COMPLETE, IE_BEARER  | IE_MANDATORY,
 570                          IE_CHANNEL_ID | IE_MANDATORY, IE_FACILITY, IE_PROGRESS,
 571                          IE_NET_FAC, IE_DISPLAY, IE_KEYPAD, IE_SIGNAL, IE_CALLING_PN,
 572                          IE_CALLING_SUB, IE_CALLED_PN, IE_CALLED_SUB, IE_REDIR_NR,
 573                          IE_LLC, IE_HLC, IE_USER_USER, -1};
 574 static int ie_SETUP_ACKNOWLEDGE[] = {IE_CHANNEL_ID | IE_MANDATORY, IE_FACILITY,
 575                                      IE_PROGRESS, IE_DISPLAY, IE_SIGNAL, -1};
 576 static int ie_STATUS[] = {IE_CAUSE | IE_MANDATORY, IE_CALL_STATE |
 577                           IE_MANDATORY, IE_DISPLAY, -1};
 578 static int ie_STATUS_ENQUIRY[] = {IE_DISPLAY, -1};
 579 static int ie_SUSPEND_ACKNOWLEDGE[] = {IE_DISPLAY, IE_FACILITY, -1};
 580 static int ie_SUSPEND_REJECT[] = {IE_CAUSE | IE_MANDATORY, IE_DISPLAY, -1};
 581 /* not used
 582  * static int ie_CONGESTION_CONTROL[] = {IE_CONGESTION | IE_MANDATORY,
 583  *              IE_CAUSE | IE_MANDATORY, IE_DISPLAY, -1};
 584  * static int ie_USER_INFORMATION[] = {IE_MORE_DATA, IE_USER_USER | IE_MANDATORY, -1};
 585  * static int ie_RESTART[] = {IE_CHANNEL_ID, IE_DISPLAY, IE_RESTART_IND |
 586  *              IE_MANDATORY, -1};
 587  */
 588 static int ie_FACILITY[] = {IE_FACILITY | IE_MANDATORY, IE_DISPLAY, -1};
 589 static int comp_required[] = {1, 2, 3, 5, 6, 7, 9, 10, 11, 14, 15, -1};
 590 static int l3_valid_states[] = {0, 1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 15, 17, 19, 25, -1};
 591
 592 struct ie_len {
 593         int ie;
 594         int len;
 595 };
 596
 597 static
 598 struct ie_len max_ie_len[] = {
 599         {IE_SEGMENT, 4},
 600         {IE_BEARER, 12},
 601         {IE_CAUSE, 32},
 602         {IE_CALL_ID, 10},
 603         {IE_CALL_STATE, 3},
 604         {IE_CHANNEL_ID, 34},
 605         {IE_FACILITY, 255},
 606         {IE_PROGRESS, 4},
 607         {IE_NET_FAC, 255},
 608         {IE_NOTIFY, 3},
 609         {IE_DISPLAY, 82},
 610         {IE_DATE, 8},
 611         {IE_KEYPAD, 34},
 612         {IE_SIGNAL, 3},
 613         {IE_INFORATE, 6},
 614         {IE_E2E_TDELAY, 11},
 615         {IE_TDELAY_SEL, 5},
 616         {IE_PACK_BINPARA, 3},
 617         {IE_PACK_WINSIZE, 4},
 618         {IE_PACK_SIZE, 4},
 619         {IE_CUG, 7},
 620         {IE_REV_CHARGE, 3},
 621         {IE_CALLING_PN, 24},
 622         {IE_CALLING_SUB, 23},
 623         {IE_CALLED_PN, 24},
 624         {IE_CALLED_SUB, 23},
 625         {IE_REDIR_NR, 255},
 626         {IE_TRANS_SEL, 255},
 627         {IE_RESTART_IND, 3},
 628         {IE_LLC, 18},
 629         {IE_HLC, 5},
 630         {IE_USER_USER, 131},
 631         {-1, 0},
 632 };
 633
 634 static int
 635 getmax_ie_len(u_char ie) {
 636         int i = 0;
 637         while (max_ie_len[i].ie != -1) {
 638                 if (max_ie_len[i].ie == ie)
 639                         return (max_ie_len[i].len);
 640                 i++;
 641         }
 642         return (255);
 643 }
 644
 645 static int
 646 ie_in_set(struct l3_process *pc, u_char ie, int *checklist) {
 647         int ret = 1;
 648
 649         while (*checklist != -1) {
 650                 if ((*checklist & 0xff) == ie) {
 651                         if (ie & 0x80)
 652                                 return (-ret);
 653                         else
 654                                 return (ret);
 655                 }
 656                 ret++;
 657                 checklist++;
 658         }
 659         return (0);
 660 }
 661
 662 static int
 663 check_infoelements(struct l3_process *pc, struct sk_buff *skb, int *checklist)
 664 {
 665         int *cl = checklist;
 666         u_char mt;
 667         u_char *p, ie;
 668         int l, newpos, oldpos;
 669         int err_seq = 0, err_len = 0, err_compr = 0, err_ureg = 0;
 670         u_char codeset = 0;
 671         u_char old_codeset = 0;
 672         u_char codelock = 1;
 673
 674         p = skb->data;
 675         /* skip cr */
 676         p++;
 677         l = (*p++) & 0xf;
 678         p += l;
 679         mt = *p++;
 680         oldpos = 0;
 681         while ((p - skb->data) < skb->len) {
 682                 if ((*p & 0xf0) == 0x90) { /* shift codeset */
 683                         old_codeset = codeset;
 684                         codeset = *p & 7;
 685                         if (*p & 0x08)
 686                                 codelock = 0;
 687                         else
 688                                 codelock = 1;
 689                         if (pc->debug & L3_DEB_CHECK)
 690                                 l3_debug(pc->st, "check IE shift%scodeset %d->%d",
 691                                          codelock ? " locking " : " ", old_codeset, codeset);
 692                         p++;
 693                         continue;
 694                 }
 695                 if (!codeset) { /* only codeset 0 */
 696                         if ((newpos = ie_in_set(pc, *p, cl))) {
 697                                 if (newpos > 0) {
 698                                         if (newpos < oldpos)
 699                                                 err_seq++;
 700                                         else
 701                                                 oldpos = newpos;
 702                                 }
 703                         } else {
 704                                 if (ie_in_set(pc, *p, comp_required))
 705                                         err_compr++;
 706                                 else
 707                                         err_ureg++;
 708                         }
 709                 }
 710                 ie = *p++;
 711                 if (ie & 0x80) {
 712                         l = 1;
 713                 } else {
 714                         l = *p++;
 715                         p += l;
 716                         l += 2;
 717                 }
 718                 if (!codeset && (l > getmax_ie_len(ie)))
 719                         err_len++;
 720                 if (!codelock) {
 721                         if (pc->debug & L3_DEB_CHECK)
 722                                 l3_debug(pc->st, "check IE shift back codeset %d->%d",
 723                                          codeset, old_codeset);
 724                         codeset = old_codeset;
 725                         codelock = 1;
 726                 }
 727         }
 728         if (err_compr | err_ureg | err_len | err_seq) {
 729                 if (pc->debug & L3_DEB_CHECK)
 730                         l3_debug(pc->st, "check IE MT(%x) %d/%d/%d/%d",
 731                                  mt, err_compr, err_ureg, err_len, err_seq);
 732                 if (err_compr)
 733                         return (ERR_IE_COMPREHENSION);
 734                 if (err_ureg)
 735                         return (ERR_IE_UNRECOGNIZED);
 736                 if (err_len)
 737                         return (ERR_IE_LENGTH);
 738                 if (err_seq)
 739                         return (ERR_IE_SEQUENCE);
 740         }
 741         return (0);
 742 }
 743
 744 /* verify if a message type exists and contain no IE error */
 745 static int
 746 l3ni1_check_messagetype_validity(struct l3_process *pc, int mt, void *arg)
 747 {
 748         switch (mt) {
 749         case MT_ALERTING:
 750         case MT_CALL_PROCEEDING:
 751         case MT_CONNECT:
 752         case MT_CONNECT_ACKNOWLEDGE:
 753         case MT_DISCONNECT:
 754         case MT_INFORMATION:
 755         case MT_FACILITY:
 756         case MT_NOTIFY:
 757         case MT_PROGRESS:
 758         case MT_RELEASE:
 759         case MT_RELEASE_COMPLETE:
 760         case MT_SETUP:
 761         case MT_SETUP_ACKNOWLEDGE:
 762         case MT_RESUME_ACKNOWLEDGE:
 763         case MT_RESUME_REJECT:
 764         case MT_SUSPEND_ACKNOWLEDGE:
 765         case MT_SUSPEND_REJECT:
 766         case MT_USER_INFORMATION:
 767         case MT_RESTART:
 768         case MT_RESTART_ACKNOWLEDGE:
 769         case MT_CONGESTION_CONTROL:
 770         case MT_STATUS:
 771         case MT_STATUS_ENQUIRY:
 772                 if (pc->debug & L3_DEB_CHECK)
 773                         l3_debug(pc->st, "l3ni1_check_messagetype_validity mt(%x) OK", mt);
 774                 break;
 775         case MT_RESUME: /* RESUME only in user->net */
 776         case MT_SUSPEND: /* SUSPEND only in user->net */
 777         default:
 778                 if (pc->debug & (L3_DEB_CHECK | L3_DEB_WARN))
 779                         l3_debug(pc->st, "l3ni1_check_messagetype_validity mt(%x) fail", mt);
 780                 pc->para.cause = 97;
 781                 l3ni1_status_send(pc, 0, NULL);
 782                 return (1);
 783         }
 784         return (0);
 785 }
 786
 787 static void
 788 l3ni1_std_ie_err(struct l3_process *pc, int ret) {
 789
 790         if (pc->debug & L3_DEB_CHECK)
 791                 l3_debug(pc->st, "check_infoelements ret %d", ret);
 792         switch (ret) {
 793         case 0:
 794                 break;
 795         case ERR_IE_COMPREHENSION:
 796                 pc->para.cause = 96;
 797                 l3ni1_status_send(pc, 0, NULL);
 798                 break;
 799         case ERR_IE_UNRECOGNIZED:
 800                 pc->para.cause = 99;
 801                 l3ni1_status_send(pc, 0, NULL);
 802                 break;
 803         case ERR_IE_LENGTH:
 804                 pc->para.cause = 100;
 805                 l3ni1_status_send(pc, 0, NULL);
 806                 break;
 807         case ERR_IE_SEQUENCE:
 808         default:
 809                 break;
 810         }
 811 }
 812
 813 static int
 814 l3ni1_get_channel_id(struct l3_process *pc, struct sk_buff *skb) {
 815         u_char *p;
 816
 817         p = skb->data;
 818         if ((p = findie(p, skb->len, IE_CHANNEL_ID, 0))) {
 819                 p++;
 820                 if (*p != 1) { /* len for BRI = 1 */
 821                         if (pc->debug & L3_DEB_WARN)
 822                                 l3_debug(pc->st, "wrong chid len %d", *p);
 823                         return (-2);
 824                 }
 825                 p++;
 826                 if (*p & 0x60) { /* only base rate interface */
 827                         if (pc->debug & L3_DEB_WARN)
 828                                 l3_debug(pc->st, "wrong chid %x", *p);
 829                         return (-3);
 830                 }
 831                 return (*p & 0x3);
 832         } else
 833                 return (-1);
 834 }
 835
 836 static int
 837 l3ni1_get_cause(struct l3_process *pc, struct sk_buff *skb) {
 838         u_char l, i = 0;
 839         u_char *p;
 840
 841         p = skb->data;
 842         pc->para.cause = 31;
 843         pc->para.loc = 0;
 844         if ((p = findie(p, skb->len, IE_CAUSE, 0))) {
 845                 p++;
 846                 l = *p++;
 847                 if (l > 30)
 848                         return (1);
 849                 if (l) {
 850                         pc->para.loc = *p++;
 851                         l--;
 852                 } else {
 853                         return (2);
 854                 }
 855                 if (l && !(pc->para.loc & 0x80)) {
 856                         l--;
 857                         p++; /* skip recommendation */
 858                 }
 859                 if (l) {
 860                         pc->para.cause = *p++;
 861                         l--;
 862                         if (!(pc->para.cause & 0x80))
 863                                 return (3);
 864                 } else
 865                         return (4);
 866                 while (l && (i < 6)) {
 867                         pc->para.diag[i++] = *p++;
 868                         l--;
 869                 }
 870         } else
 871                 return (-1);
 872         return (0);
 873 }
 874
 875 static void
 876 l3ni1_msg_with_uus(struct l3_process *pc, u_char cmd)
 877 {
 878         struct sk_buff *skb;
 879         u_char tmp[16 + 40];
 880         u_char *p = tmp;
 881         int l;
 882
 883         MsgHead(p, pc->callref, cmd);
 884
 885         if (pc->prot.ni1.uus1_data[0])
 886         { *p++ = IE_USER_USER; /* UUS info element */
 887                 *p++ = strlen(pc->prot.ni1.uus1_data) + 1;
 888                 *p++ = 0x04; /* IA5 chars */
 889                 strcpy(p, pc->prot.ni1.uus1_data);
 890                 p += strlen(pc->prot.ni1.uus1_data);
 891                 pc->prot.ni1.uus1_data[0] = '\0';
 892         }
 893
 894         l = p - tmp;
 895         if (!(skb = l3_alloc_skb(l)))
 896                 return;
 897         memcpy(skb_put(skb, l), tmp, l);
 898         l3_msg(pc->st, DL_DATA | REQUEST, skb);
 899 } /* l3ni1_msg_with_uus */
 900
 901 static void
 902 l3ni1_release_req(struct l3_process *pc, u_char pr, void *arg)
 903 {
 904         StopAllL3Timer(pc);
 905         newl3state(pc, 19);
 906         if (!pc->prot.ni1.uus1_data[0])
 907                 l3ni1_message(pc, MT_RELEASE);
 908         else
 909                 l3ni1_msg_with_uus(pc, MT_RELEASE);
 910         L3AddTimer(&pc->timer, T308, CC_T308_1);
 911 }
 912
 913 static void
 914 l3ni1_release_cmpl(struct l3_process *pc, u_char pr, void *arg)
 915 {
 916         struct sk_buff *skb = arg;
 917         int ret;
 918
 919         if ((ret = l3ni1_get_cause(pc, skb)) > 0) {
 920                 if (pc->debug & L3_DEB_WARN)
 921                         l3_debug(pc->st, "RELCMPL get_cause ret(%d)", ret);
 922         } else if (ret < 0)
 923                 pc->para.cause = NO_CAUSE;
 924         StopAllL3Timer(pc);
 925         newl3state(pc, 0);
 926         pc->st->l3.l3l4(pc->st, CC_RELEASE | CONFIRM, pc);
 927         ni1_release_l3_process(pc);
 928 }
 929
 930 #if EXT_BEARER_CAPS
 931
 932 static u_char *
 933 EncodeASyncParams(u_char *p, u_char si2)
 934 {                               // 7c 06 88  90 21 42 00 bb
 935
 936         p[0] = 0;
 937         p[1] = 0x40;            // Intermediate rate: 16 kbit/s jj 2000.02.19
 938         p[2] = 0x80;
 939         if (si2 & 32)           // 7 data bits
 940
 941                 p[2] += 16;
 942         else                    // 8 data bits
 943
 944                 p[2] += 24;
 945
 946         if (si2 & 16)           // 2 stop bits
 947
 948                 p[2] += 96;
 949         else                    // 1 stop bit
 950
 951                 p[2] += 32;
 952
 953         if (si2 & 8)            // even parity
 954
 955                 p[2] += 2;
 956         else                    // no parity
 957
 958                 p[2] += 3;
 959
 960         switch (si2 & 0x07) {
 961         case 0:
 962                 p[0] = 66;      // 1200 bit/s
 963
 964                 break;
 965         case 1:
 966                 p[0] = 88;      // 1200/75 bit/s
 967
 968                 break;
 969         case 2:
 970                 p[0] = 87;      // 75/1200 bit/s
 971
 972                 break;
 973         case 3:
 974                 p[0] = 67;      // 2400 bit/s
 975
 976                 break;
 977         case 4:
 978                 p[0] = 69;      // 4800 bit/s
 979
 980                 break;
 981         case 5:
 982                 p[0] = 72;      // 9600 bit/s
 983
 984                 break;
 985         case 6:
 986                 p[0] = 73;      // 14400 bit/s
 987
 988                 break;
 989         case 7:
 990                 p[0] = 75;      // 19200 bit/s
 991
 992                 break;
 993         }
 994         return p + 3;
 995 }
 996
 997 static u_char
 998 EncodeSyncParams(u_char si2, u_char ai)
 999 {
1000
1001         switch (si2) {
1002         case 0:
1003                 return ai + 2;  // 1200 bit/s
1004
1005         case 1:
1006                 return ai + 24;         // 1200/75 bit/s
1007
1008         case 2:
1009                 return ai + 23;         // 75/1200 bit/s
1010
1011         case 3:
1012                 return ai + 3;  // 2400 bit/s
1013
1014         case 4:
1015                 return ai + 5;  // 4800 bit/s
1016
1017         case 5:
1018                 return ai + 8;  // 9600 bit/s
1019
1020         case 6:
1021                 return ai + 9;  // 14400 bit/s
1022
1023         case 7:
1024                 return ai + 11;         // 19200 bit/s
1025
1026         case 8:
1027                 return ai + 14;         // 48000 bit/s
1028
1029         case 9:
1030                 return ai + 15;         // 56000 bit/s
1031
1032         case 15:
1033                 return ai + 40;         // negotiate bit/s
1034
1035         default:
1036                 break;
1037         }
1038         return ai;
1039 }
1040
1041
1042 static u_char
1043 DecodeASyncParams(u_char si2, u_char *p)
1044 {
1045         u_char info;
1046
1047         switch (p[5]) {
1048         case 66:        // 1200 bit/s
1049
1050                 break;  // si2 don't change
1051
1052         case 88:        // 1200/75 bit/s
1053
1054                 si2 += 1;
1055                 break;
1056         case 87:        // 75/1200 bit/s
1057
1058                 si2 += 2;
1059                 break;
1060         case 67:        // 2400 bit/s
1061
1062                 si2 += 3;
1063                 break;
1064         case 69:        // 4800 bit/s
1065
1066                 si2 += 4;
1067                 break;
1068         case 72:        // 9600 bit/s
1069
1070                 si2 += 5;
1071                 break;
1072         case 73:        // 14400 bit/s
1073
1074                 si2 += 6;
1075                 break;
1076         case 75:        // 19200 bit/s
1077
1078                 si2 += 7;
1079                 break;
1080         }
1081
1082         info = p[7] & 0x7f;
1083         if ((info & 16) && (!(info & 8)))       // 7 data bits
1084
1085                 si2 += 32;      // else 8 data bits
1086
1087         if ((info & 96) == 96)  // 2 stop bits
1088
1089                 si2 += 16;      // else 1 stop bit
1090
1091         if ((info & 2) && (!(info & 1)))        // even parity
1092
1093                 si2 += 8;       // else no parity
1094
1095         return si2;
1096 }
1097
1098
1099 static u_char
1100 DecodeSyncParams(u_char si2, u_char info)
1101 {
1102         info &= 0x7f;
1103         switch (info) {
1104         case 40:        // bit/s negotiation failed  ai := 165 not 175!
1105
1106                 return si2 + 15;
1107         case 15:        // 56000 bit/s failed, ai := 0 not 169 !
1108
1109                 return si2 + 9;
1110         case 14:        // 48000 bit/s
1111
1112                 return si2 + 8;
1113         case 11:        // 19200 bit/s
1114
1115                 return si2 + 7;
1116         case 9: // 14400 bit/s
1117
1118                 return si2 + 6;
1119         case 8: // 9600  bit/s
1120
1121                 return si2 + 5;
1122         case 5: // 4800  bit/s
1123
1124                 return si2 + 4;
1125         case 3: // 2400  bit/s
1126
1127                 return si2 + 3;
1128         case 23:        // 75/1200 bit/s
1129
1130                 return si2 + 2;
1131         case 24:        // 1200/75 bit/s
1132
1133                 return si2 + 1;
1134         default:        // 1200 bit/s
1135
1136                 return si2;
1137         }
1138 }
1139
1140 static u_char
1141 DecodeSI2(struct sk_buff *skb)
1142 {
1143         u_char *p;              //, *pend=skb->data + skb->len;
1144
1145         if ((p = findie(skb->data, skb->len, 0x7c, 0))) {
1146                 switch (p[4] & 0x0f) {
1147                 case 0x01:
1148                         if (p[1] == 0x04)       // sync. Bitratenadaption
1149
1150                                 return DecodeSyncParams(160, p[5]);     // V.110/X.30
1151
1152                         else if (p[1] == 0x06)  // async. Bitratenadaption
1153
1154                                 return DecodeASyncParams(192, p);       // V.110/X.30
1155
1156                         break;
1157                 case 0x08:      // if (p[5] == 0x02) // sync. Bitratenadaption
1158                         if (p[1] > 3)
1159                                 return DecodeSyncParams(176, p[5]);     // V.120
1160                         break;
1161                 }
1162         }
1163         return 0;
1164 }
1165
1166 #endif
1167
1168
1169 static void
1170 l3ni1_setup_req(struct l3_process *pc, u_char pr,
1171                 void *arg)
1172 {
1173         struct sk_buff *skb;
1174         u_char tmp[128];
1175         u_char *p = tmp;
1176
1177         u_char *teln;
1178         u_char *sub;
1179         u_char *sp;
1180         int l;
1181
1182         MsgHead(p, pc->callref, MT_SETUP);
1183
1184         teln = pc->para.setup.phone;
1185
1186         *p++ = 0xa1;            /* complete indicator */
1187         /*
1188          * Set Bearer Capability, Map info from 1TR6-convention to NI1
1189          */
1190         switch (pc->para.setup.si1) {
1191         case 1:                   /* Telephony                                */
1192                 *p++ = IE_BEARER;
1193                 *p++ = 0x3;       /* Length                                   */
1194                 *p++ = 0x90;      /* 3.1khz Audio                             */
1195                 *p++ = 0x90;      /* Circuit-Mode 64kbps                      */
1196                 *p++ = 0xa2;      /* u-Law Audio                              */
1197                 break;
1198         case 5:                   /* Datatransmission 64k, BTX                */
1199         case 7:                   /* Datatransmission 64k                     */
1200         default:
1201                 *p++ = IE_BEARER;
1202                 *p++ = 0x2;       /* Length                                   */
1203                 *p++ = 0x88;      /* Coding Std. CCITT, unrestr. dig. Inform. */
1204                 *p++ = 0x90;      /* Circuit-Mode 64kbps                      */
1205                 break;
1206         }
1207
1208         sub = NULL;
1209         sp = teln;
1210         while (*sp) {
1211                 if ('.' == *sp) {
1212                         sub = sp;
1213                         *sp = 0;
1214                 } else
1215                         sp++;
1216         }
1217
1218         *p++ = IE_KEYPAD;
1219         *p++ = strlen(teln);
1220         while (*teln)
1221                 *p++ = (*teln++) & 0x7F;
1222
1223         if (sub)
1224                 *sub++ = '.';
1225
1226 #if EXT_BEARER_CAPS
1227         if ((pc->para.setup.si2 >= 160) && (pc->para.setup.si2 <= 175)) {       // sync. Bitratenadaption, V.110/X.30
1228
1229                 *p++ = IE_LLC;
1230                 *p++ = 0x04;
1231                 *p++ = 0x88;
1232                 *p++ = 0x90;
1233                 *p++ = 0x21;
1234                 *p++ = EncodeSyncParams(pc->para.setup.si2 - 160, 0x80);
1235         } else if ((pc->para.setup.si2 >= 176) && (pc->para.setup.si2 <= 191)) {        // sync. Bitratenadaption, V.120
1236
1237                 *p++ = IE_LLC;
1238                 *p++ = 0x05;
1239                 *p++ = 0x88;
1240                 *p++ = 0x90;
1241                 *p++ = 0x28;
1242                 *p++ = EncodeSyncParams(pc->para.setup.si2 - 176, 0);
1243                 *p++ = 0x82;
1244         } else if (pc->para.setup.si2 >= 192) {         // async. Bitratenadaption, V.110/X.30
1245
1246                 *p++ = IE_LLC;
1247                 *p++ = 0x06;
1248                 *p++ = 0x88;
1249                 *p++ = 0x90;
1250                 *p++ = 0x21;
1251                 p = EncodeASyncParams(p, pc->para.setup.si2 - 192);
1252         } else {
1253                 switch (pc->para.setup.si1) {
1254                 case 1:                 /* Telephony                                */
1255                         *p++ = IE_LLC;
1256                         *p++ = 0x3;     /* Length                                   */
1257                         *p++ = 0x90;    /* Coding Std. CCITT, 3.1 kHz audio         */
1258                         *p++ = 0x90;    /* Circuit-Mode 64kbps                      */
1259                         *p++ = 0xa2;    /* u-Law Audio                              */
1260                         break;
1261                 case 5:                 /* Datatransmission 64k, BTX                */
1262                 case 7:                 /* Datatransmission 64k                     */
1263                 default:
1264                         *p++ = IE_LLC;
1265                         *p++ = 0x2;     /* Length                                   */
1266                         *p++ = 0x88;    /* Coding Std. CCITT, unrestr. dig. Inform. */
1267                         *p++ = 0x90;    /* Circuit-Mode 64kbps                      */
1268                         break;
1269                 }
1270         }
1271 #endif
1272         l = p - tmp;
1273         if (!(skb = l3_alloc_skb(l)))
1274         {
1275                 return;
1276         }
1277         memcpy(skb_put(skb, l), tmp, l);
1278         L3DelTimer(&pc->timer);
1279         L3AddTimer(&pc->timer, T303, CC_T303);
1280         newl3state(pc, 1);
1281         l3_msg(pc->st, DL_DATA | REQUEST, skb);
1282 }
1283
1284 static void
1285 l3ni1_call_proc(struct l3_process *pc, u_char pr, void *arg)
1286 {
1287         struct sk_buff *skb = arg;
1288         int id, ret;
1289
1290         if ((id = l3ni1_get_channel_id(pc, skb)) >= 0) {
1291                 if ((0 == id) || ((3 == id) && (0x10 == pc->para.moderate))) {
1292                         if (pc->debug & L3_DEB_WARN)
1293                                 l3_debug(pc->st, "setup answer with wrong chid %x", id);
1294                         pc->para.cause = 100;
1295                         l3ni1_status_send(pc, pr, NULL);
1296                         return;
1297                 }
1298                 pc->para.bchannel = id;
1299         } else if (1 == pc->state) {
1300                 if (pc->debug & L3_DEB_WARN)
1301                         l3_debug(pc->st, "setup answer wrong chid (ret %d)", id);
1302                 if (id == -1)
1303                         pc->para.cause = 96;
1304                 else
1305                         pc->para.cause = 100;
1306                 l3ni1_status_send(pc, pr, NULL);
1307                 return;
1308         }
1309         /* Now we are on none mandatory IEs */
1310         ret = check_infoelements(pc, skb, ie_CALL_PROCEEDING);
1311         if (ERR_IE_COMPREHENSION == ret) {
1312                 l3ni1_std_ie_err(pc, ret);
1313                 return;
1314         }
1315         L3DelTimer(&pc->timer);
1316         newl3state(pc, 3);
1317         L3AddTimer(&pc->timer, T310, CC_T310);
1318         if (ret) /* STATUS for none mandatory IE errors after actions are taken */
1319                 l3ni1_std_ie_err(pc, ret);
1320         pc->st->l3.l3l4(pc->st, CC_PROCEEDING | INDICATION, pc);
1321 }
1322
1323 static void
1324 l3ni1_setup_ack(struct l3_process *pc, u_char pr, void *arg)
1325 {
1326         struct sk_buff *skb = arg;
1327         int id, ret;
1328
1329         if ((id = l3ni1_get_channel_id(pc, skb)) >= 0) {
1330                 if ((0 == id) || ((3 == id) && (0x10 == pc->para.moderate))) {
1331                         if (pc->debug & L3_DEB_WARN)
1332                                 l3_debug(pc->st, "setup answer with wrong chid %x", id);
1333                         pc->para.cause = 100;
1334                         l3ni1_status_send(pc, pr, NULL);
1335                         return;
1336                 }
1337                 pc->para.bchannel = id;
1338         } else {
1339                 if (pc->debug & L3_DEB_WARN)
1340                         l3_debug(pc->st, "setup answer wrong chid (ret %d)", id);
1341                 if (id == -1)
1342                         pc->para.cause = 96;
1343                 else
1344                         pc->para.cause = 100;
1345                 l3ni1_status_send(pc, pr, NULL);
1346                 return;
1347         }
1348         /* Now we are on none mandatory IEs */
1349         ret = check_infoelements(pc, skb, ie_SETUP_ACKNOWLEDGE);
1350         if (ERR_IE_COMPREHENSION == ret) {
1351                 l3ni1_std_ie_err(pc, ret);
1352                 return;
1353         }
1354         L3DelTimer(&pc->timer);
1355         newl3state(pc, 2);
1356         L3AddTimer(&pc->timer, T304, CC_T304);
1357         if (ret) /* STATUS for none mandatory IE errors after actions are taken */
1358                 l3ni1_std_ie_err(pc, ret);
1359         pc->st->l3.l3l4(pc->st, CC_MORE_INFO | INDICATION, pc);
1360 }
1361
1362 static void
1363 l3ni1_disconnect(struct l3_process *pc, u_char pr, void *arg)
1364 {
1365         struct sk_buff *skb = arg;
1366         u_char *p;
1367         int ret;
1368         u_char cause = 0;
1369
1370         StopAllL3Timer(pc);
1371         if ((ret = l3ni1_get_cause(pc, skb))) {
1372                 if (pc->debug & L3_DEB_WARN)
1373                         l3_debug(pc->st, "DISC get_cause ret(%d)", ret);
1374                 if (ret < 0)
1375                         cause = 96;
1376                 else if (ret > 0)
1377                         cause = 100;
1378         }
1379         if ((p = findie(skb->data, skb->len, IE_FACILITY, 0)))
1380                 l3ni1_parse_facility(pc->st, pc, pc->callref, p);
1381         ret = check_infoelements(pc, skb, ie_DISCONNECT);
1382         if (ERR_IE_COMPREHENSION == ret)
1383                 cause = 96;
1384         else if ((!cause) && (ERR_IE_UNRECOGNIZED == ret))
1385                 cause = 99;
1386         ret = pc->state;
1387         newl3state(pc, 12);
1388         if (cause)
1389                 newl3state(pc, 19);
1390         if (11 != ret)
1391                 pc->st->l3.l3l4(pc->st, CC_DISCONNECT | INDICATION, pc);
1392         else if (!cause)
1393                 l3ni1_release_req(pc, pr, NULL);
1394         if (cause) {
1395                 l3ni1_message_cause(pc, MT_RELEASE, cause);
1396                 L3AddTimer(&pc->timer, T308, CC_T308_1);
1397         }
1398 }
1399
1400 static void
1401 l3ni1_connect(struct l3_process *pc, u_char pr, void *arg)
1402 {
1403         struct sk_buff *skb = arg;
1404         int ret;
1405
1406         ret = check_infoelements(pc, skb, ie_CONNECT);
1407         if (ERR_IE_COMPREHENSION == ret) {
1408                 l3ni1_std_ie_err(pc, ret);
1409                 return;
1410         }
1411         L3DelTimer(&pc->timer); /* T310 */
1412         newl3state(pc, 10);
1413         pc->para.chargeinfo = 0;
1414         /* here should inserted COLP handling KKe */
1415         if (ret)
1416                 l3ni1_std_ie_err(pc, ret);
1417         pc->st->l3.l3l4(pc->st, CC_SETUP | CONFIRM, pc);
1418 }
1419
1420 static void
1421 l3ni1_alerting(struct l3_process *pc, u_char pr, void *arg)
1422 {
1423         struct sk_buff *skb = arg;
1424         int ret;
1425
1426         ret = check_infoelements(pc, skb, ie_ALERTING);
1427         if (ERR_IE_COMPREHENSION == ret) {
1428                 l3ni1_std_ie_err(pc, ret);
1429                 return;
1430         }
1431         L3DelTimer(&pc->timer); /* T304 */
1432         newl3state(pc, 4);
1433         if (ret)
1434                 l3ni1_std_ie_err(pc, ret);
1435         pc->st->l3.l3l4(pc->st, CC_ALERTING | INDICATION, pc);
1436 }
1437
1438 static void
1439 l3ni1_setup(struct l3_process *pc, u_char pr, void *arg)
1440 {
1441         u_char *p;
1442         int bcfound = 0;
1443         char tmp[80];
1444         struct sk_buff *skb = arg;
1445         int id;
1446         int err = 0;
1447
1448         /*
1449          * Bearer Capabilities
1450          */
1451         p = skb->data;
1452         /* only the first occurrence 'll be detected ! */
1453         if ((p = findie(p, skb->len, 0x04, 0))) {
1454                 if ((p[1] < 2) || (p[1] > 11))
1455                         err = 1;
1456                 else {
1457                         pc->para.setup.si2 = 0;
1458                         switch (p[2] & 0x7f) {
1459                         case 0x00: /* Speech */
1460                         case 0x10: /* 3.1 Khz audio */
1461                                 pc->para.setup.si1 = 1;
1462                                 break;
1463                         case 0x08: /* Unrestricted digital information */
1464                                 pc->para.setup.si1 = 7;
1465 /* JIM, 05.11.97 I wanna set service indicator 2 */
1466 #if EXT_BEARER_CAPS
1467                                 pc->para.setup.si2 = DecodeSI2(skb);
1468 #endif
1469                                 break;
1470                         case 0x09: /* Restricted digital information */
1471                                 pc->para.setup.si1 = 2;
1472                                 break;
1473                         case 0x11:
1474                                 /* Unrestr. digital information  with
1475                                  * tones/announcements ( or 7 kHz audio
1476                                  */
1477                                 pc->para.setup.si1 = 3;
1478                                 break;
1479                         case 0x18: /* Video */
1480                                 pc->para.setup.si1 = 4;
1481                                 break;
1482                         default:
1483                                 err = 2;
1484                                 break;
1485                         }
1486                         switch (p[3] & 0x7f) {
1487                         case 0x40: /* packed mode */
1488                                 pc->para.setup.si1 = 8;
1489                                 break;
1490                         case 0x10: /* 64 kbit */
1491                         case 0x11: /* 2*64 kbit */
1492                         case 0x13: /* 384 kbit */
1493                         case 0x15: /* 1536 kbit */
1494                         case 0x17: /* 1920 kbit */
1495                                 pc->para.moderate = p[3] & 0x7f;
1496                                 break;
1497                         default:
1498                                 err = 3;
1499                                 break;
1500                         }
1501                 }
1502                 if (pc->debug & L3_DEB_SI)
1503                         l3_debug(pc->st, "SI=%d, AI=%d",
1504                                  pc->para.setup.si1, pc->para.setup.si2);
1505                 if (err) {
1506                         if (pc->debug & L3_DEB_WARN)
1507                                 l3_debug(pc->st, "setup with wrong bearer(l=%d:%x,%x)",
1508                                          p[1], p[2], p[3]);
1509                         pc->para.cause = 100;
1510                         l3ni1_msg_without_setup(pc, pr, NULL);
1511                         return;
1512                 }
1513         } else {
1514                 if (pc->debug & L3_DEB_WARN)
1515                         l3_debug(pc->st, "setup without bearer capabilities");
1516                 /* ETS 300-104 1.3.3 */
1517                 pc->para.cause = 96;
1518                 l3ni1_msg_without_setup(pc, pr, NULL);
1519                 return;
1520         }
1521         /*
1522          * Channel Identification
1523          */
1524         if ((id = l3ni1_get_channel_id(pc, skb)) >= 0) {
1525                 if ((pc->para.bchannel = id)) {
1526                         if ((3 == id) && (0x10 == pc->para.moderate)) {
1527                                 if (pc->debug & L3_DEB_WARN)
1528                                         l3_debug(pc->st, "setup with wrong chid %x",
1529                                                  id);
1530                                 pc->para.cause = 100;
1531                                 l3ni1_msg_without_setup(pc, pr, NULL);
1532                                 return;
1533                         }
1534                         bcfound++;
1535                 } else
1536                 { if (pc->debug & L3_DEB_WARN)
1537                                 l3_debug(pc->st, "setup without bchannel, call waiting");
1538                         bcfound++;
1539                 }
1540         } else {
1541                 if (pc->debug & L3_DEB_WARN)
1542                         l3_debug(pc->st, "setup with wrong chid ret %d", id);
1543                 if (id == -1)
1544                         pc->para.cause = 96;
1545                 else
1546                         pc->para.cause = 100;
1547                 l3ni1_msg_without_setup(pc, pr, NULL);
1548                 return;
1549         }
1550         /* Now we are on none mandatory IEs */
1551         err = check_infoelements(pc, skb, ie_SETUP);
1552         if (ERR_IE_COMPREHENSION == err) {
1553                 pc->para.cause = 96;
1554                 l3ni1_msg_without_setup(pc, pr, NULL);
1555                 return;
1556         }
1557         p = skb->data;
1558         if ((p = findie(p, skb->len, 0x70, 0)))
1559                 iecpy(pc->para.setup.eazmsn, p, 1);
1560         else
1561                 pc->para.setup.eazmsn[0] = 0;
1562
1563         p = skb->data;
1564         if ((p = findie(p, skb->len, 0x71, 0))) {
1565                 /* Called party subaddress */
1566                 if ((p[1] >= 2) && (p[2] == 0x80) && (p[3] == 0x50)) {
1567                         tmp[0] = '.';
1568                         iecpy(&tmp[1], p, 2);
1569                         strcat(pc->para.setup.eazmsn, tmp);
1570                 } else if (pc->debug & L3_DEB_WARN)
1571                         l3_debug(pc->st, "wrong called subaddress");
1572         }
1573         p = skb->data;
1574         if ((p = findie(p, skb->len, 0x6c, 0))) {
1575                 pc->para.setup.plan = p[2];
1576                 if (p[2] & 0x80) {
1577                         iecpy(pc->para.setup.phone, p, 1);
1578                         pc->para.setup.screen = 0;
1579                 } else {
1580                         iecpy(pc->para.setup.phone, p, 2);
1581                         pc->para.setup.screen = p[3];
1582                 }
1583         } else {
1584                 pc->para.setup.phone[0] = 0;
1585                 pc->para.setup.plan = 0;
1586                 pc->para.setup.screen = 0;
1587         }
1588         p = skb->data;
1589         if ((p = findie(p, skb->len, 0x6d, 0))) {
1590                 /* Calling party subaddress */
1591                 if ((p[1] >= 2) && (p[2] == 0x80) && (p[3] == 0x50)) {
1592                         tmp[0] = '.';
1593                         iecpy(&tmp[1], p, 2);
1594                         strcat(pc->para.setup.phone, tmp);
1595                 } else if (pc->debug & L3_DEB_WARN)
1596                         l3_debug(pc->st, "wrong calling subaddress");
1597         }
1598         newl3state(pc, 6);
1599         if (err) /* STATUS for none mandatory IE errors after actions are taken */
1600                 l3ni1_std_ie_err(pc, err);
1601         pc->st->l3.l3l4(pc->st, CC_SETUP | INDICATION, pc);
1602 }
1603
1604 static void
1605 l3ni1_reset(struct l3_process *pc, u_char pr, void *arg)
1606 {
1607         ni1_release_l3_process(pc);
1608 }
1609
1610 static void
1611 l3ni1_disconnect_req(struct l3_process *pc, u_char pr, void *arg)
1612 {
1613         struct sk_buff *skb;
1614         u_char tmp[16 + 40];
1615         u_char *p = tmp;
1616         int l;
1617         u_char cause = 16;
1618
1619         if (pc->para.cause != NO_CAUSE)
1620                 cause = pc->para.cause;
1621
1622         StopAllL3Timer(pc);
1623
1624         MsgHead(p, pc->callref, MT_DISCONNECT);
1625
1626         *p++ = IE_CAUSE;
1627         *p++ = 0x2;
1628         *p++ = 0x80;
1629         *p++ = cause | 0x80;
1630
1631         if (pc->prot.ni1.uus1_data[0])
1632         { *p++ = IE_USER_USER; /* UUS info element */
1633                 *p++ = strlen(pc->prot.ni1.uus1_data) + 1;
1634                 *p++ = 0x04; /* IA5 chars */
1635                 strcpy(p, pc->prot.ni1.uus1_data);
1636                 p += strlen(pc->prot.ni1.uus1_data);
1637                 pc->prot.ni1.uus1_data[0] = '\0';
1638         }
1639
1640         l = p - tmp;
1641         if (!(skb = l3_alloc_skb(l)))
1642                 return;
1643         memcpy(skb_put(skb, l), tmp, l);
1644         newl3state(pc, 11);
1645         l3_msg(pc->st, DL_DATA | REQUEST, skb);
1646         L3AddTimer(&pc->timer, T305, CC_T305);
1647 }
1648
1649 static void
1650 l3ni1_setup_rsp(struct l3_process *pc, u_char pr,
1651                 void *arg)
1652 {
1653         if (!pc->para.bchannel)
1654         { if (pc->debug & L3_DEB_WARN)
1655                         l3_debug(pc->st, "D-chan connect for waiting call");
1656                 l3ni1_disconnect_req(pc, pr, arg);
1657                 return;
1658         }
1659         newl3state(pc, 8);
1660         if (pc->debug & L3_DEB_WARN)
1661                 l3_debug(pc->st, "D-chan connect for waiting call");
1662         l3ni1_message_plus_chid(pc, MT_CONNECT); /* GE 05/09/00 */
1663         L3DelTimer(&pc->timer);
1664         L3AddTimer(&pc->timer, T313, CC_T313);
1665 }
1666
1667 static void
1668 l3ni1_connect_ack(struct l3_process *pc, u_char pr, void *arg)
1669 {
1670         struct sk_buff *skb = arg;
1671         int ret;
1672
1673         ret = check_infoelements(pc, skb, ie_CONNECT_ACKNOWLEDGE);
1674         if (ERR_IE_COMPREHENSION == ret) {
1675                 l3ni1_std_ie_err(pc, ret);
1676                 return;
1677         }
1678         newl3state(pc, 10);
1679         L3DelTimer(&pc->timer);
1680         if (ret)
1681                 l3ni1_std_ie_err(pc, ret);
1682         pc->st->l3.l3l4(pc->st, CC_SETUP_COMPL | INDICATION, pc);
1683 }
1684
1685 static void
1686 l3ni1_reject_req(struct l3_process *pc, u_char pr, void *arg)
1687 {
1688         struct sk_buff *skb;
1689         u_char tmp[16];
1690         u_char *p = tmp;
1691         int l;
1692         u_char cause = 21;
1693
1694         if (pc->para.cause != NO_CAUSE)
1695                 cause = pc->para.cause;
1696
1697         MsgHead(p, pc->callref, MT_RELEASE_COMPLETE);
1698
1699         *p++ = IE_CAUSE;
1700         *p++ = 0x2;
1701         *p++ = 0x80;
1702         *p++ = cause | 0x80;
1703
1704         l = p - tmp;
1705         if (!(skb = l3_alloc_skb(l)))
1706                 return;
1707         memcpy(skb_put(skb, l), tmp, l);
1708         l3_msg(pc->st, DL_DATA | REQUEST, skb);
1709         pc->st->l3.l3l4(pc->st, CC_RELEASE | INDICATION, pc);
1710         newl3state(pc, 0);
1711         ni1_release_l3_process(pc);
1712 }
1713
1714 static void
1715 l3ni1_release(struct l3_process *pc, u_char pr, void *arg)
1716 {
1717         struct sk_buff *skb = arg;
1718         u_char *p;
1719         int ret, cause = 0;
1720
1721         StopAllL3Timer(pc);
1722         if ((ret = l3ni1_get_cause(pc, skb)) > 0) {
1723                 if (pc->debug & L3_DEB_WARN)
1724                         l3_debug(pc->st, "REL get_cause ret(%d)", ret);
1725         } else if (ret < 0)
1726                 pc->para.cause = NO_CAUSE;
1727         if ((p = findie(skb->data, skb->len, IE_FACILITY, 0))) {
1728                 l3ni1_parse_facility(pc->st, pc, pc->callref, p);
1729         }
1730         if ((ret < 0) && (pc->state != 11))
1731                 cause = 96;
1732         else if (ret > 0)
1733                 cause = 100;
1734         ret = check_infoelements(pc, skb, ie_RELEASE);
1735         if (ERR_IE_COMPREHENSION == ret)
1736                 cause = 96;
1737         else if ((ERR_IE_UNRECOGNIZED == ret) && (!cause))
1738                 cause = 99;
1739         if (cause)
1740                 l3ni1_message_cause(pc, MT_RELEASE_COMPLETE, cause);
1741         else
1742                 l3ni1_message(pc, MT_RELEASE_COMPLETE);
1743         pc->st->l3.l3l4(pc->st, CC_RELEASE | INDICATION, pc);
1744         newl3state(pc, 0);
1745         ni1_release_l3_process(pc);
1746 }
1747
1748 static void
1749 l3ni1_alert_req(struct l3_process *pc, u_char pr,
1750                 void *arg)
1751 {
1752         newl3state(pc, 7);
1753         if (!pc->prot.ni1.uus1_data[0])
1754                 l3ni1_message(pc, MT_ALERTING);
1755         else
1756                 l3ni1_msg_with_uus(pc, MT_ALERTING);
1757 }
1758
1759 static void
1760 l3ni1_proceed_req(struct l3_process *pc, u_char pr,
1761                   void *arg)
1762 {
1763         newl3state(pc, 9);
1764         l3ni1_message(pc, MT_CALL_PROCEEDING);
1765         pc->st->l3.l3l4(pc->st, CC_PROCEED_SEND | INDICATION, pc);
1766 }
1767
1768 static void
1769 l3ni1_setup_ack_req(struct l3_process *pc, u_char pr,
1770                     void *arg)
1771 {
1772         newl3state(pc, 25);
1773         L3DelTimer(&pc->timer);
1774         L3AddTimer(&pc->timer, T302, CC_T302);
1775         l3ni1_message(pc, MT_SETUP_ACKNOWLEDGE);
1776 }
1777
1778 /********************************************/
1779 /* deliver a incoming display message to HL */
1780 /********************************************/
1781 static void
1782 l3ni1_deliver_display(struct l3_process *pc, int pr, u_char *infp)
1783 {       u_char len;
1784         isdn_ctrl ic;
1785         struct IsdnCardState *cs;
1786         char *p;
1787
1788         if (*infp++ != IE_DISPLAY) return;
1789         if ((len = *infp++) > 80) return; /* total length <= 82 */
1790         if (!pc->chan) return;
1791
1792         p = ic.parm.display;
1793         while (len--)
1794                 *p++ = *infp++;
1795         *p = '\0';
1796         ic.command = ISDN_STAT_DISPLAY;
1797         cs = pc->st->l1.hardware;
1798         ic.driver = cs->myid;
1799         ic.arg = pc->chan->chan;
1800         cs->iif.statcallb(&ic);
1801 } /* l3ni1_deliver_display */
1802
1803
1804 static void
1805 l3ni1_progress(struct l3_process *pc, u_char pr, void *arg)
1806 {
1807         struct sk_buff *skb = arg;
1808         int err = 0;
1809         u_char *p;
1810
1811         if ((p = findie(skb->data, skb->len, IE_PROGRESS, 0))) {
1812                 if (p[1] != 2) {
1813                         err = 1;
1814                         pc->para.cause = 100;
1815                 } else if (!(p[2] & 0x70)) {
1816                         switch (p[2]) {
1817                         case 0x80:
1818                         case 0x81:
1819                         case 0x82:
1820                         case 0x84:
1821                         case 0x85:
1822                         case 0x87:
1823                         case 0x8a:
1824                                 switch (p[3]) {
1825                                 case 0x81:
1826                                 case 0x82:
1827                                 case 0x83:
1828                                 case 0x84:
1829                                 case 0x88:
1830                                         break;
1831                                 default:
1832                                         err = 2;
1833                                         pc->para.cause = 100;
1834                                         break;
1835                                 }
1836                                 break;
1837                         default:
1838                                 err = 3;
1839                                 pc->para.cause = 100;
1840                                 break;
1841                         }
1842                 }
1843         } else {
1844                 pc->para.cause = 96;
1845                 err = 4;
1846         }
1847         if (err) {
1848                 if (pc->debug & L3_DEB_WARN)
1849                         l3_debug(pc->st, "progress error %d", err);
1850                 l3ni1_status_send(pc, pr, NULL);
1851                 return;
1852         }
1853         /* Now we are on none mandatory IEs */
1854         err = check_infoelements(pc, skb, ie_PROGRESS);
1855         if (err)
1856                 l3ni1_std_ie_err(pc, err);
1857         if (ERR_IE_COMPREHENSION != err)
1858                 pc->st->l3.l3l4(pc->st, CC_PROGRESS | INDICATION, pc);
1859 }
1860
1861 static void
1862 l3ni1_notify(struct l3_process *pc, u_char pr, void *arg)
1863 {
1864         struct sk_buff *skb = arg;
1865         int err = 0;
1866         u_char *p;
1867
1868         if ((p = findie(skb->data, skb->len, IE_NOTIFY, 0))) {
1869                 if (p[1] != 1) {
1870                         err = 1;
1871                         pc->para.cause = 100;
1872                 } else {
1873                         switch (p[2]) {
1874                         case 0x80:
1875                         case 0x81:
1876                         case 0x82:
1877                                 break;
1878                         default:
1879                                 pc->para.cause = 100;
1880                                 err = 2;
1881                                 break;
1882                         }
1883                 }
1884         } else {
1885                 pc->para.cause = 96;
1886                 err = 3;
1887         }
1888         if (err) {
1889                 if (pc->debug & L3_DEB_WARN)
1890                         l3_debug(pc->st, "notify error %d", err);
1891                 l3ni1_status_send(pc, pr, NULL);
1892                 return;
1893         }
1894         /* Now we are on none mandatory IEs */
1895         err = check_infoelements(pc, skb, ie_NOTIFY);
1896         if (err)
1897                 l3ni1_std_ie_err(pc, err);
1898         if (ERR_IE_COMPREHENSION != err)
1899                 pc->st->l3.l3l4(pc->st, CC_NOTIFY | INDICATION, pc);
1900 }
1901
1902 static void
1903 l3ni1_status_enq(struct l3_process *pc, u_char pr, void *arg)
1904 {
1905         int ret;
1906         struct sk_buff *skb = arg;
1907
1908         ret = check_infoelements(pc, skb, ie_STATUS_ENQUIRY);
1909         l3ni1_std_ie_err(pc, ret);
1910         pc->para.cause = 30; /* response to STATUS_ENQUIRY */
1911         l3ni1_status_send(pc, pr, NULL);
1912 }
1913
1914 static void
1915 l3ni1_information(struct l3_process *pc, u_char pr, void *arg)
1916 {
1917         int ret;
1918         struct sk_buff *skb = arg;
1919         u_char *p;
1920         char tmp[32];
1921
1922         ret = check_infoelements(pc, skb, ie_INFORMATION);
1923         if (ret)
1924                 l3ni1_std_ie_err(pc, ret);
1925         if (pc->state == 25) { /* overlap receiving */
1926                 L3DelTimer(&pc->timer);
1927                 p = skb->data;
1928                 if ((p = findie(p, skb->len, 0x70, 0))) {
1929                         iecpy(tmp, p, 1);
1930                         strcat(pc->para.setup.eazmsn, tmp);
1931                         pc->st->l3.l3l4(pc->st, CC_MORE_INFO | INDICATION, pc);
1932                 }
1933                 L3AddTimer(&pc->timer, T302, CC_T302);
1934         }
1935 }
1936
1937 /******************************/
1938 /* handle deflection requests */
1939 /******************************/
1940 static void l3ni1_redir_req(struct l3_process *pc, u_char pr, void *arg)
1941 {
1942         struct sk_buff *skb;
1943         u_char tmp[128];
1944         u_char *p = tmp;
1945         u_char *subp;
1946         u_char len_phone = 0;
1947         u_char len_sub = 0;
1948         int l;
1949
1950
1951         strcpy(pc->prot.ni1.uus1_data, pc->chan->setup.eazmsn); /* copy uus element if available */
1952         if (!pc->chan->setup.phone[0])
1953         { pc->para.cause = -1;
1954                 l3ni1_disconnect_req(pc, pr, arg); /* disconnect immediately */
1955                 return;
1956         } /* only uus */
1957
1958         if (pc->prot.ni1.invoke_id)
1959                 free_invoke_id(pc->st, pc->prot.ni1.invoke_id);
1960
1961         if (!(pc->prot.ni1.invoke_id = new_invoke_id(pc->st)))
1962                 return;
1963
1964         MsgHead(p, pc->callref, MT_FACILITY);
1965
1966         for (subp = pc->chan->setup.phone; (*subp) && (*subp != '.'); subp++) len_phone++; /* len of phone number */
1967         if (*subp++ == '.') len_sub = strlen(subp) + 2; /* length including info subaddress element */
1968
1969         *p++ = 0x1c;   /* Facility info element */
1970         *p++ = len_phone + len_sub + 2 + 2 + 8 + 3 + 3; /* length of element */
1971         *p++ = 0x91;  /* remote operations protocol */
1972         *p++ = 0xa1;  /* invoke component */
1973
1974         *p++ = len_phone + len_sub + 2 + 2 + 8 + 3; /* length of data */
1975         *p++ = 0x02;  /* invoke id tag, integer */
1976         *p++ = 0x01;  /* length */
1977         *p++ = pc->prot.ni1.invoke_id;  /* invoke id */
1978         *p++ = 0x02;  /* operation value tag, integer */
1979         *p++ = 0x01;  /* length */
1980         *p++ = 0x0D;  /* Call Deflect */
1981
1982         *p++ = 0x30;  /* sequence phone number */
1983         *p++ = len_phone + 2 + 2 + 3 + len_sub; /* length */
1984
1985         *p++ = 0x30;  /* Deflected to UserNumber */
1986         *p++ = len_phone + 2 + len_sub; /* length */
1987         *p++ = 0x80; /* NumberDigits */
1988         *p++ = len_phone; /* length */
1989         for (l = 0; l < len_phone; l++)
1990                 *p++ = pc->chan->setup.phone[l];
1991
1992         if (len_sub)
1993         { *p++ = 0x04; /* called party subaddress */
1994                 *p++ = len_sub - 2;
1995                 while (*subp) *p++ = *subp++;
1996         }
1997
1998         *p++ = 0x01; /* screening identifier */
1999         *p++ = 0x01;
2000         *p++ = pc->chan->setup.screen;
2001
2002         l = p - tmp;
2003         if (!(skb = l3_alloc_skb(l))) return;
2004         memcpy(skb_put(skb, l), tmp, l);
2005
2006         l3_msg(pc->st, DL_DATA | REQUEST, skb);
2007 } /* l3ni1_redir_req */
2008
2009 /********************************************/
2010 /* handle deflection request in early state */
2011 /********************************************/
2012 static void l3ni1_redir_req_early(struct l3_process *pc, u_char pr, void *arg)
2013 {
2014         l3ni1_proceed_req(pc, pr, arg);
2015         l3ni1_redir_req(pc, pr, arg);
2016 } /* l3ni1_redir_req_early */
2017
2018 /***********************************************/
2019 /* handle special commands for this protocol.  */
2020 /* Examples are call independent services like */
2021 /* remote operations with dummy  callref.      */
2022 /***********************************************/
2023 static int l3ni1_cmd_global(struct PStack *st, isdn_ctrl *ic)
2024 { u_char id;
2025         u_char temp[265];
2026         u_char *p = temp;
2027         int i, l, proc_len;
2028         struct sk_buff *skb;
2029         struct l3_process *pc = NULL;
2030
2031         switch (ic->arg)
2032         { case NI1_CMD_INVOKE:
2033                         if (ic->parm.ni1_io.datalen < 0) return (-2); /* invalid parameter */
2034
2035                         for (proc_len = 1, i = ic->parm.ni1_io.proc >> 8; i; i++)
2036                                 i = i >> 8; /* add one byte */
2037                         l = ic->parm.ni1_io.datalen + proc_len + 8; /* length excluding ie header */
2038                         if (l > 255)
2039                                 return (-2); /* too long */
2040
2041                         if (!(id = new_invoke_id(st)))
2042                                 return (0); /* first get a invoke id -> return if no available */
2043
2044                         i = -1;
2045                         MsgHead(p, i, MT_FACILITY); /* build message head */
2046                         *p++ = 0x1C; /* Facility IE */
2047                         *p++ = l; /* length of ie */
2048                         *p++ = 0x91; /* remote operations */
2049                         *p++ = 0xA1; /* invoke */
2050                         *p++ = l - 3; /* length of invoke */
2051                         *p++ = 0x02; /* invoke id tag */
2052                         *p++ = 0x01; /* length is 1 */
2053                         *p++ = id; /* invoke id */
2054                         *p++ = 0x02; /* operation */
2055                         *p++ = proc_len; /* length of operation */
2056
2057                         for (i = proc_len; i; i--)
2058                                 *p++ = (ic->parm.ni1_io.proc >> (i - 1)) & 0xFF;
2059                         memcpy(p, ic->parm.ni1_io.data, ic->parm.ni1_io.datalen); /* copy data */
2060                         l = (p - temp) + ic->parm.ni1_io.datalen; /* total length */
2061
2062                         if (ic->parm.ni1_io.timeout > 0)
2063                                 if (!(pc = ni1_new_l3_process(st, -1)))
2064                                 { free_invoke_id(st, id);
2065                                         return (-2);
2066                                 }
2067                         pc->prot.ni1.ll_id = ic->parm.ni1_io.ll_id; /* remember id */
2068                         pc->prot.ni1.proc = ic->parm.ni1_io.proc; /* and procedure */
2069
2070                         if (!(skb = l3_alloc_skb(l)))
2071                         { free_invoke_id(st, id);
2072                                 if (pc) ni1_release_l3_process(pc);
2073                                 return (-2);
2074                         }
2075                         memcpy(skb_put(skb, l), temp, l);
2076
2077                         if (pc)
2078                         { pc->prot.ni1.invoke_id = id; /* remember id */
2079                                 L3AddTimer(&pc->timer, ic->parm.ni1_io.timeout, CC_TNI1_IO | REQUEST);
2080                         }
2081
2082                         l3_msg(st, DL_DATA | REQUEST, skb);
2083                         ic->parm.ni1_io.hl_id = id; /* return id */
2084                         return (0);
2085
2086         case NI1_CMD_INVOKE_ABORT:
2087                 if ((pc = l3ni1_search_dummy_proc(st, ic->parm.ni1_io.hl_id)))
2088                 { L3DelTimer(&pc->timer); /* remove timer */
2089                         ni1_release_l3_process(pc);
2090                         return (0);
2091                 }
2092                 else
2093                 { l3_debug(st, "l3ni1_cmd_global abort unknown id");
2094                         return (-2);
2095                 }
2096                 break;
2097
2098         default:
2099                 l3_debug(st, "l3ni1_cmd_global unknown cmd 0x%lx", ic->arg);
2100                 return (-1);
2101         } /* switch ic-> arg */
2102         return (-1);
2103 } /* l3ni1_cmd_global */
2104
2105 static void
2106 l3ni1_io_timer(struct l3_process *pc)
2107 { isdn_ctrl ic;
2108         struct IsdnCardState *cs = pc->st->l1.hardware;
2109
2110         L3DelTimer(&pc->timer); /* remove timer */
2111
2112         ic.driver = cs->myid;
2113         ic.command = ISDN_STAT_PROT;
2114         ic.arg = NI1_STAT_INVOKE_ERR;
2115         ic.parm.ni1_io.hl_id = pc->prot.ni1.invoke_id;
2116         ic.parm.ni1_io.ll_id = pc->prot.ni1.ll_id;
2117         ic.parm.ni1_io.proc = pc->prot.ni1.proc;
2118         ic.parm.ni1_io.timeout = -1;
2119         ic.parm.ni1_io.datalen = 0;
2120         ic.parm.ni1_io.data = NULL;
2121         free_invoke_id(pc->st, pc->prot.ni1.invoke_id);
2122         pc->prot.ni1.invoke_id = 0; /* reset id */
2123
2124         cs->iif.statcallb(&ic);
2125
2126         ni1_release_l3_process(pc);
2127 } /* l3ni1_io_timer */
2128
2129 static void
2130 l3ni1_release_ind(struct l3_process *pc, u_char pr, void *arg)
2131 {
2132         u_char *p;
2133         struct sk_buff *skb = arg;
2134         int callState = 0;
2135         p = skb->data;
2136
2137         if ((p = findie(p, skb->len, IE_CALL_STATE, 0))) {
2138                 p++;
2139                 if (1 == *p++)
2140                         callState = *p;
2141         }
2142         if (callState == 0) {
2143                 /* ETS 300-104 7.6.1, 8.6.1, 10.6.1... and 16.1
2144                  * set down layer 3 without sending any message
2145                  */
2146                 pc->st->l3.l3l4(pc->st, CC_RELEASE | INDICATION, pc);
2147                 newl3state(pc, 0);
2148                 ni1_release_l3_process(pc);
2149         } else {
2150                 pc->st->l3.l3l4(pc->st, CC_IGNORE | INDICATION, pc);
2151         }
2152 }
2153
2154 static void
2155 l3ni1_dummy(struct l3_process *pc, u_char pr, void *arg)
2156 {
2157 }
2158
2159 static void
2160 l3ni1_t302(struct l3_process *pc, u_char pr, void *arg)
2161 {
2162         L3DelTimer(&pc->timer);
2163         pc->para.loc = 0;
2164         pc->para.cause = 28; /* invalid number */
2165         l3ni1_disconnect_req(pc, pr, NULL);
2166         pc->st->l3.l3l4(pc->st, CC_SETUP_ERR, pc);
2167 }
2168
2169 static void
2170 l3ni1_t303(struct l3_process *pc, u_char pr, void *arg)
2171 {
2172         if (pc->N303 > 0) {
2173                 pc->N303--;
2174                 L3DelTimer(&pc->timer);
2175                 l3ni1_setup_req(pc, pr, arg);
2176         } else {
2177                 L3DelTimer(&pc->timer);
2178                 l3ni1_message_cause(pc, MT_RELEASE_COMPLETE, 102);
2179                 pc->st->l3.l3l4(pc->st, CC_NOSETUP_RSP, pc);
2180                 ni1_release_l3_process(pc);
2181         }
2182 }
2183
2184 static void
2185 l3ni1_t304(struct l3_process *pc, u_char pr, void *arg)
2186 {
2187         L3DelTimer(&pc->timer);
2188         pc->para.loc = 0;
2189         pc->para.cause = 102;
2190         l3ni1_disconnect_req(pc, pr, NULL);
2191         pc->st->l3.l3l4(pc->st, CC_SETUP_ERR, pc);
2192
2193 }
2194
2195 static void
2196 l3ni1_t305(struct l3_process *pc, u_char pr, void *arg)
2197 {
2198         u_char tmp[16];
2199         u_char *p = tmp;
2200         int l;
2201         struct sk_buff *skb;
2202         u_char cause = 16;
2203
2204         L3DelTimer(&pc->timer);
2205         if (pc->para.cause != NO_CAUSE)
2206                 cause = pc->para.cause;
2207
2208         MsgHead(p, pc->callref, MT_RELEASE);
2209
2210         *p++ = IE_CAUSE;
2211         *p++ = 0x2;
2212         *p++ = 0x80;
2213         *p++ = cause | 0x80;
2214
2215         l = p - tmp;
2216         if (!(skb = l3_alloc_skb(l)))
2217                 return;
2218         memcpy(skb_put(skb, l), tmp, l);
2219         newl3state(pc, 19);
2220         l3_msg(pc->st, DL_DATA | REQUEST, skb);
2221         L3AddTimer(&pc->timer, T308, CC_T308_1);
2222 }
2223
2224 static void
2225 l3ni1_t310(struct l3_process *pc, u_char pr, void *arg)
2226 {
2227         L3DelTimer(&pc->timer);
2228         pc->para.loc = 0;
2229         pc->para.cause = 102;
2230         l3ni1_disconnect_req(pc, pr, NULL);
2231         pc->st->l3.l3l4(pc->st, CC_SETUP_ERR, pc);
2232 }
2233
2234 static void
2235 l3ni1_t313(struct l3_process *pc, u_char pr, void *arg)
2236 {
2237         L3DelTimer(&pc->timer);
2238         pc->para.loc = 0;
2239         pc->para.cause = 102;
2240         l3ni1_disconnect_req(pc, pr, NULL);
2241         pc->st->l3.l3l4(pc->st, CC_CONNECT_ERR, pc);
2242 }
2243
2244 static void
2245 l3ni1_t308_1(struct l3_process *pc, u_char pr, void *arg)
2246 {
2247         newl3state(pc, 19);
2248         L3DelTimer(&pc->timer);
2249         l3ni1_message(pc, MT_RELEASE);
2250         L3AddTimer(&pc->timer, T308, CC_T308_2);
2251 }
2252
2253 static void
2254 l3ni1_t308_2(struct l3_process *pc, u_char pr, void *arg)
2255 {
2256         L3DelTimer(&pc->timer);
2257         pc->st->l3.l3l4(pc->st, CC_RELEASE_ERR, pc);
2258         ni1_release_l3_process(pc);
2259 }
2260
2261 static void
2262 l3ni1_t318(struct l3_process *pc, u_char pr, void *arg)
2263 {
2264         L3DelTimer(&pc->timer);
2265         pc->para.cause = 102;   /* Timer expiry */
2266         pc->para.loc = 0;       /* local */
2267         pc->st->l3.l3l4(pc->st, CC_RESUME_ERR, pc);
2268         newl3state(pc, 19);
2269         l3ni1_message(pc, MT_RELEASE);
2270         L3AddTimer(&pc->timer, T308, CC_T308_1);
2271 }
2272
2273 static void
2274 l3ni1_t319(struct l3_process *pc, u_char pr, void *arg)
2275 {
2276         L3DelTimer(&pc->timer);
2277         pc->para.cause = 102;   /* Timer expiry */
2278         pc->para.loc = 0;       /* local */
2279         pc->st->l3.l3l4(pc->st, CC_SUSPEND_ERR, pc);
2280         newl3state(pc, 10);
2281 }
2282
2283 static void
2284 l3ni1_restart(struct l3_process *pc, u_char pr, void *arg)
2285 {
2286         L3DelTimer(&pc->timer);
2287         pc->st->l3.l3l4(pc->st, CC_RELEASE | INDICATION, pc);
2288         ni1_release_l3_process(pc);
2289 }
2290
2291 static void
2292 l3ni1_status(struct l3_process *pc, u_char pr, void *arg)
2293 {
2294         u_char *p;
2295         struct sk_buff *skb = arg;
2296         int ret;
2297         u_char cause = 0, callState = 0;
2298
2299         if ((ret = l3ni1_get_cause(pc, skb))) {
2300                 if (pc->debug & L3_DEB_WARN)
2301                         l3_debug(pc->st, "STATUS get_cause ret(%d)", ret);
2302                 if (ret < 0)
2303                         cause = 96;
2304                 else if (ret > 0)
2305                         cause = 100;
2306         }
2307         if ((p = findie(skb->data, skb->len, IE_CALL_STATE, 0))) {
2308                 p++;
2309                 if (1 == *p++) {
2310                         callState = *p;
2311                         if (!ie_in_set(pc, *p, l3_valid_states))
2312                                 cause = 100;
2313                 } else
2314                         cause = 100;
2315         } else
2316                 cause = 96;
2317         if (!cause) { /*  no error before */
2318                 ret = check_infoelements(pc, skb, ie_STATUS);
2319                 if (ERR_IE_COMPREHENSION == ret)
2320                         cause = 96;
2321                 else if (ERR_IE_UNRECOGNIZED == ret)
2322                         cause = 99;
2323         }
2324         if (cause) {
2325                 u_char tmp;
2326
2327                 if (pc->debug & L3_DEB_WARN)
2328                         l3_debug(pc->st, "STATUS error(%d/%d)", ret, cause);
2329                 tmp = pc->para.cause;
2330                 pc->para.cause = cause;
2331                 l3ni1_status_send(pc, 0, NULL);
2332                 if (cause == 99)
2333                         pc->para.cause = tmp;
2334                 else
2335                         return;
2336         }
2337         cause = pc->para.cause;
2338         if (((cause & 0x7f) == 111) && (callState == 0)) {
2339                 /* ETS 300-104 7.6.1, 8.6.1, 10.6.1...
2340                  * if received MT_STATUS with cause == 111 and call
2341                  * state == 0, then we must set down layer 3
2342                  */
2343                 pc->st->l3.l3l4(pc->st, CC_RELEASE | INDICATION, pc);
2344                 newl3state(pc, 0);
2345                 ni1_release_l3_process(pc);
2346         }
2347 }
2348
2349 static void
2350 l3ni1_facility(struct l3_process *pc, u_char pr, void *arg)
2351 {
2352         struct sk_buff *skb = arg;
2353         int ret;
2354
2355         ret = check_infoelements(pc, skb, ie_FACILITY);
2356         l3ni1_std_ie_err(pc, ret);
2357         {
2358                 u_char *p;
2359                 if ((p = findie(skb->data, skb->len, IE_FACILITY, 0)))
2360                         l3ni1_parse_facility(pc->st, pc, pc->callref, p);
2361         }
2362 }
2363
2364 static void
2365 l3ni1_suspend_req(struct l3_process *pc, u_char pr, void *arg)
2366 {
2367         struct sk_buff *skb;
2368         u_char tmp[32];
2369         u_char *p = tmp;
2370         u_char i, l;
2371         u_char *msg = pc->chan->setup.phone;
2372
2373         MsgHead(p, pc->callref, MT_SUSPEND);
2374         l = *msg++;
2375         if (l && (l <= 10)) {   /* Max length 10 octets */
2376                 *p++ = IE_CALL_ID;
2377                 *p++ = l;
2378                 for (i = 0; i < l; i++)
2379                         *p++ = *msg++;
2380         } else if (l) {
2381                 l3_debug(pc->st, "SUS wrong CALL_ID len %d", l);
2382                 return;
2383         }
2384         l = p - tmp;
2385         if (!(skb = l3_alloc_skb(l)))
2386                 return;
2387         memcpy(skb_put(skb, l), tmp, l);
2388         l3_msg(pc->st, DL_DATA | REQUEST, skb);
2389         newl3state(pc, 15);
2390         L3AddTimer(&pc->timer, T319, CC_T319);
2391 }
2392
2393 static void
2394 l3ni1_suspend_ack(struct l3_process *pc, u_char pr, void *arg)
2395 {
2396         struct sk_buff *skb = arg;
2397         int ret;
2398
2399         L3DelTimer(&pc->timer);
2400         newl3state(pc, 0);
2401         pc->para.cause = NO_CAUSE;
2402         pc->st->l3.l3l4(pc->st, CC_SUSPEND | CONFIRM, pc);
2403         /* We don't handle suspend_ack for IE errors now */
2404         if ((ret = check_infoelements(pc, skb, ie_SUSPEND_ACKNOWLEDGE)))
2405                 if (pc->debug & L3_DEB_WARN)
2406                         l3_debug(pc->st, "SUSPACK check ie(%d)", ret);
2407         ni1_release_l3_process(pc);
2408 }
2409
2410 static void
2411 l3ni1_suspend_rej(struct l3_process *pc, u_char pr, void *arg)
2412 {
2413         struct sk_buff *skb = arg;
2414         int ret;
2415
2416         if ((ret = l3ni1_get_cause(pc, skb))) {
2417                 if (pc->debug & L3_DEB_WARN)
2418                         l3_debug(pc->st, "SUSP_REJ get_cause ret(%d)", ret);
2419                 if (ret < 0)
2420                         pc->para.cause = 96;
2421                 else
2422                         pc->para.cause = 100;
2423                 l3ni1_status_send(pc, pr, NULL);
2424                 return;
2425         }
2426         ret = check_infoelements(pc, skb, ie_SUSPEND_REJECT);
2427         if (ERR_IE_COMPREHENSION == ret) {
2428                 l3ni1_std_ie_err(pc, ret);
2429                 return;
2430         }
2431         L3DelTimer(&pc->timer);
2432         pc->st->l3.l3l4(pc->st, CC_SUSPEND_ERR, pc);
2433         newl3state(pc, 10);
2434         if (ret) /* STATUS for none mandatory IE errors after actions are taken */
2435                 l3ni1_std_ie_err(pc, ret);
2436 }
2437
2438 static void
2439 l3ni1_resume_req(struct l3_process *pc, u_char pr, void *arg)
2440 {
2441         struct sk_buff *skb;
2442         u_char tmp[32];
2443         u_char *p = tmp;
2444         u_char i, l;
2445         u_char *msg = pc->para.setup.phone;
2446
2447         MsgHead(p, pc->callref, MT_RESUME);
2448
2449         l = *msg++;
2450         if (l && (l <= 10)) {   /* Max length 10 octets */
2451                 *p++ = IE_CALL_ID;
2452                 *p++ = l;
2453                 for (i = 0; i < l; i++)
2454                         *p++ = *msg++;
2455         } else if (l) {
2456                 l3_debug(pc->st, "RES wrong CALL_ID len %d", l);
2457                 return;
2458         }
2459         l = p - tmp;
2460         if (!(skb = l3_alloc_skb(l)))
2461                 return;
2462         memcpy(skb_put(skb, l), tmp, l);
2463         l3_msg(pc->st, DL_DATA | REQUEST, skb);
2464         newl3state(pc, 17);
2465         L3AddTimer(&pc->timer, T318, CC_T318);
2466 }
2467
2468 static void
2469 l3ni1_resume_ack(struct l3_process *pc, u_char pr, void *arg)
2470 {
2471         struct sk_buff *skb = arg;
2472         int id, ret;
2473
2474         if ((id = l3ni1_get_channel_id(pc, skb)) > 0) {
2475                 if ((0 == id) || ((3 == id) && (0x10 == pc->para.moderate))) {
2476                         if (pc->debug & L3_DEB_WARN)
2477                                 l3_debug(pc->st, "resume ack with wrong chid %x", id);
2478                         pc->para.cause = 100;
2479                         l3ni1_status_send(pc, pr, NULL);
2480                         return;
2481                 }
2482                 pc->para.bchannel = id;
2483         } else if (1 == pc->state) {
2484                 if (pc->debug & L3_DEB_WARN)
2485                         l3_debug(pc->st, "resume ack without chid (ret %d)", id);
2486                 pc->para.cause = 96;
2487                 l3ni1_status_send(pc, pr, NULL);
2488                 return;
2489         }
2490         ret = check_infoelements(pc, skb, ie_RESUME_ACKNOWLEDGE);
2491         if (ERR_IE_COMPREHENSION == ret) {
2492                 l3ni1_std_ie_err(pc, ret);
2493                 return;
2494         }
2495         L3DelTimer(&pc->timer);
2496         pc->st->l3.l3l4(pc->st, CC_RESUME | CONFIRM, pc);
2497         newl3state(pc, 10);
2498         if (ret) /* STATUS for none mandatory IE errors after actions are taken */
2499                 l3ni1_std_ie_err(pc, ret);
2500 }
2501
2502 static void
2503 l3ni1_resume_rej(struct l3_process *pc, u_char pr, void *arg)
2504 {
2505         struct sk_buff *skb = arg;
2506         int ret;
2507
2508         if ((ret = l3ni1_get_cause(pc, skb))) {
2509                 if (pc->debug & L3_DEB_WARN)
2510                         l3_debug(pc->st, "RES_REJ get_cause ret(%d)", ret);
2511                 if (ret < 0)
2512                         pc->para.cause = 96;
2513                 else
2514                         pc->para.cause = 100;
2515                 l3ni1_status_send(pc, pr, NULL);
2516                 return;
2517         }
2518         ret = check_infoelements(pc, skb, ie_RESUME_REJECT);
2519         if (ERR_IE_COMPREHENSION == ret) {
2520                 l3ni1_std_ie_err(pc, ret);
2521                 return;
2522         }
2523         L3DelTimer(&pc->timer);
2524         pc->st->l3.l3l4(pc->st, CC_RESUME_ERR, pc);
2525         newl3state(pc, 0);
2526         if (ret) /* STATUS for none mandatory IE errors after actions are taken */
2527                 l3ni1_std_ie_err(pc, ret);
2528         ni1_release_l3_process(pc);
2529 }
2530
2531 static void
2532 l3ni1_global_restart(struct l3_process *pc, u_char pr, void *arg)
2533 {
2534         u_char tmp[32];
2535         u_char *p;
2536         u_char ri, ch = 0, chan = 0;
2537         int l;
2538         struct sk_buff *skb = arg;
2539         struct l3_process *up;
2540
2541         newl3state(pc, 2);
2542         L3DelTimer(&pc->timer);
2543         p = skb->data;
2544         if ((p = findie(p, skb->len, IE_RESTART_IND, 0))) {
2545                 ri = p[2];
2546                 l3_debug(pc->st, "Restart %x", ri);
2547         } else {
2548                 l3_debug(pc->st, "Restart without restart IE");
2549                 ri = 0x86;
2550         }
2551         p = skb->data;
2552         if ((p = findie(p, skb->len, IE_CHANNEL_ID, 0))) {
2553                 chan = p[2] & 3;
2554                 ch = p[2];
2555                 if (pc->st->l3.debug)
2556                         l3_debug(pc->st, "Restart for channel %d", chan);
2557         }
2558         newl3state(pc, 2);
2559         up = pc->st->l3.proc;
2560         while (up) {
2561                 if ((ri & 7) == 7)
2562                         up->st->lli.l4l3(up->st, CC_RESTART | REQUEST, up);
2563                 else if (up->para.bchannel == chan)
2564                         up->st->lli.l4l3(up->st, CC_RESTART | REQUEST, up);
2565
2566                 up = up->next;
2567         }
2568         p = tmp;
2569         MsgHead(p, pc->callref, MT_RESTART_ACKNOWLEDGE);
2570         if (chan) {
2571                 *p++ = IE_CHANNEL_ID;
2572                 *p++ = 1;
2573                 *p++ = ch | 0x80;
2574         }
2575         *p++ = 0x79;            /* RESTART Ind */
2576         *p++ = 1;
2577         *p++ = ri;
2578         l = p - tmp;
2579         if (!(skb = l3_alloc_skb(l)))
2580                 return;
2581         memcpy(skb_put(skb, l), tmp, l);
2582         newl3state(pc, 0);
2583         l3_msg(pc->st, DL_DATA | REQUEST, skb);
2584 }
2585
2586 static void
2587 l3ni1_dl_reset(struct l3_process *pc, u_char pr, void *arg)
2588 {
2589         pc->para.cause = 0x29;          /* Temporary failure */
2590         pc->para.loc = 0;
2591         l3ni1_disconnect_req(pc, pr, NULL);
2592         pc->st->l3.l3l4(pc->st, CC_SETUP_ERR, pc);
2593 }
2594
2595 static void
2596 l3ni1_dl_release(struct l3_process *pc, u_char pr, void *arg)
2597 {
2598         newl3state(pc, 0);
2599         pc->para.cause = 0x1b;          /* Destination out of order */
2600         pc->para.loc = 0;
2601         pc->st->l3.l3l4(pc->st, CC_RELEASE | INDICATION, pc);
2602         release_l3_process(pc);
2603 }
2604
2605 static void
2606 l3ni1_dl_reestablish(struct l3_process *pc, u_char pr, void *arg)
2607 {
2608         L3DelTimer(&pc->timer);
2609         L3AddTimer(&pc->timer, T309, CC_T309);
2610         l3_msg(pc->st, DL_ESTABLISH | REQUEST, NULL);
2611 }
2612
2613 static void
2614 l3ni1_dl_reest_status(struct l3_process *pc, u_char pr, void *arg)
2615 {
2616         L3DelTimer(&pc->timer);
2617
2618         pc->para.cause = 0x1F; /* normal, unspecified */
2619         l3ni1_status_send(pc, 0, NULL);
2620 }
2621
2622 static void l3ni1_SendSpid(struct l3_process *pc, u_char pr, struct sk_buff *skb, int iNewState)
2623 {
2624         u_char *p;
2625         char *pSPID;
2626         struct Channel *pChan = pc->st->lli.userdata;
2627         int l;
2628
2629         if (skb)
2630                 dev_kfree_skb(skb);
2631
2632         if (!(pSPID = strchr(pChan->setup.eazmsn, ':')))
2633         {
2634                 printk(KERN_ERR "SPID not supplied in EAZMSN %s\n", pChan->setup.eazmsn);
2635                 newl3state(pc, 0);
2636                 pc->st->l3.l3l2(pc->st, DL_RELEASE | REQUEST, NULL);
2637                 return;
2638         }
2639
2640         l = strlen(++pSPID);
2641         if (!(skb = l3_alloc_skb(5 + l)))
2642         {
2643                 printk(KERN_ERR "HiSax can't get memory to send SPID\n");
2644                 return;
2645         }
2646
2647         p = skb_put(skb, 5);
2648         *p++ = PROTO_DIS_EURO;
2649         *p++ = 0;
2650         *p++ = MT_INFORMATION;
2651         *p++ = IE_SPID;
2652         *p++ = l;
2653
2654         memcpy(skb_put(skb, l), pSPID, l);
2655
2656         newl3state(pc, iNewState);
2657
2658         L3DelTimer(&pc->timer);
2659         L3AddTimer(&pc->timer, TSPID, CC_TSPID);
2660
2661         pc->st->l3.l3l2(pc->st, DL_DATA | REQUEST, skb);
2662 }
2663
2664 static void l3ni1_spid_send(struct l3_process *pc, u_char pr, void *arg)
2665 {
2666         l3ni1_SendSpid(pc, pr, arg, 20);
2667 }
2668
2669 static void l3ni1_spid_epid(struct l3_process *pc, u_char pr, void *arg)
2670 {
2671         struct sk_buff *skb = arg;
2672
2673         if (skb->data[1] == 0)
2674                 if (skb->data[3] == IE_ENDPOINT_ID)
2675                 {
2676                         L3DelTimer(&pc->timer);
2677                         newl3state(pc, 0);
2678                         l3_msg(pc->st, DL_ESTABLISH | CONFIRM, NULL);
2679                 }
2680         dev_kfree_skb(skb);
2681 }
2682
2683 static void l3ni1_spid_tout(struct l3_process *pc, u_char pr, void *arg)
2684 {
2685         if (pc->state < 22)
2686                 l3ni1_SendSpid(pc, pr, arg, pc->state + 1);
2687         else
2688         {
2689                 L3DelTimer(&pc->timer);
2690                 dev_kfree_skb(arg);
2691
2692                 printk(KERN_ERR "SPID not accepted\n");
2693                 newl3state(pc, 0);
2694                 pc->st->l3.l3l2(pc->st, DL_RELEASE | REQUEST, NULL);
2695         }
2696 }
2697
2698 /* *INDENT-OFF* */
2699 static struct stateentry downstatelist[] =
2700 {
2701         {SBIT(0),
2702          CC_SETUP | REQUEST, l3ni1_setup_req},
2703         {SBIT(0),
2704          CC_RESUME | REQUEST, l3ni1_resume_req},
2705         {SBIT(1) | SBIT(2) | SBIT(3) | SBIT(4) | SBIT(6) | SBIT(7) | SBIT(8) | SBIT(9) | SBIT(10) | SBIT(25),
2706          CC_DISCONNECT | REQUEST, l3ni1_disconnect_req},
2707         {SBIT(12),
2708          CC_RELEASE | REQUEST, l3ni1_release_req},
2709         {ALL_STATES,
2710          CC_RESTART | REQUEST, l3ni1_restart},
2711         {SBIT(6) | SBIT(25),
2712          CC_IGNORE | REQUEST, l3ni1_reset},
2713         {SBIT(6) | SBIT(25),
2714          CC_REJECT | REQUEST, l3ni1_reject_req},
2715         {SBIT(6) | SBIT(25),
2716          CC_PROCEED_SEND | REQUEST, l3ni1_proceed_req},
2717         {SBIT(6),
2718          CC_MORE_INFO | REQUEST, l3ni1_setup_ack_req},
2719         {SBIT(25),
2720          CC_MORE_INFO | REQUEST, l3ni1_dummy},
2721         {SBIT(6) | SBIT(9) | SBIT(25),
2722          CC_ALERTING | REQUEST, l3ni1_alert_req},
2723         {SBIT(6) | SBIT(7) | SBIT(9) | SBIT(25),
2724          CC_SETUP | RESPONSE, l3ni1_setup_rsp},
2725         {SBIT(10),
2726          CC_SUSPEND | REQUEST, l3ni1_suspend_req},
2727         {SBIT(7) | SBIT(9) | SBIT(25),
2728          CC_REDIR | REQUEST, l3ni1_redir_req},
2729         {SBIT(6),
2730          CC_REDIR | REQUEST, l3ni1_redir_req_early},
2731         {SBIT(9) | SBIT(25),
2732          CC_DISCONNECT | REQUEST, l3ni1_disconnect_req},
2733         {SBIT(25),
2734          CC_T302, l3ni1_t302},
2735         {SBIT(1),
2736          CC_T303, l3ni1_t303},
2737         {SBIT(2),
2738          CC_T304, l3ni1_t304},
2739         {SBIT(3),
2740          CC_T310, l3ni1_t310},
2741         {SBIT(8),
2742          CC_T313, l3ni1_t313},
2743         {SBIT(11),
2744          CC_T305, l3ni1_t305},
2745         {SBIT(15),
2746          CC_T319, l3ni1_t319},
2747         {SBIT(17),
2748          CC_T318, l3ni1_t318},
2749         {SBIT(19),
2750          CC_T308_1, l3ni1_t308_1},
2751         {SBIT(19),
2752          CC_T308_2, l3ni1_t308_2},
2753         {SBIT(10),
2754          CC_T309, l3ni1_dl_release},
2755         { SBIT(20) | SBIT(21) | SBIT(22),
2756           CC_TSPID, l3ni1_spid_tout },
2757 };
2758
2759 static struct stateentry datastatelist[] =
2760 {
2761         {ALL_STATES,
2762          MT_STATUS_ENQUIRY, l3ni1_status_enq},
2763         {ALL_STATES,
2764          MT_FACILITY, l3ni1_facility},
2765         {SBIT(19),
2766          MT_STATUS, l3ni1_release_ind},
2767         {ALL_STATES,
2768          MT_STATUS, l3ni1_status},
2769         {SBIT(0),
2770          MT_SETUP, l3ni1_setup},
2771         {SBIT(6) | SBIT(7) | SBIT(8) | SBIT(9) | SBIT(10) | SBIT(11) | SBIT(12) |
2772          SBIT(15) | SBIT(17) | SBIT(19) | SBIT(25),
2773          MT_SETUP, l3ni1_dummy},
2774         {SBIT(1) | SBIT(2),
2775          MT_CALL_PROCEEDING, l3ni1_call_proc},
2776         {SBIT(1),
2777          MT_SETUP_ACKNOWLEDGE, l3ni1_setup_ack},
2778         {SBIT(2) | SBIT(3),
2779          MT_ALERTING, l3ni1_alerting},
2780         {SBIT(2) | SBIT(3),
2781          MT_PROGRESS, l3ni1_progress},
2782         {SBIT(2) | SBIT(3) | SBIT(4) | SBIT(7) | SBIT(8) | SBIT(9) | SBIT(10) |
2783          SBIT(11) | SBIT(12) | SBIT(15) | SBIT(17) | SBIT(19) | SBIT(25),
2784          MT_INFORMATION, l3ni1_information},
2785         {SBIT(10) | SBIT(11) | SBIT(15),
2786          MT_NOTIFY, l3ni1_notify},
2787         {SBIT(0) | SBIT(1) | SBIT(2) | SBIT(3) | SBIT(4) | SBIT(7) | SBIT(8) | SBIT(10) |
2788          SBIT(11) | SBIT(12) | SBIT(15) | SBIT(17) | SBIT(19) | SBIT(25),
2789          MT_RELEASE_COMPLETE, l3ni1_release_cmpl},
2790         {SBIT(1) | SBIT(2) | SBIT(3) | SBIT(4) | SBIT(7) | SBIT(8) | SBIT(9) | SBIT(10) | SBIT(11) | SBIT(12) | SBIT(15) | SBIT(17) | SBIT(25),
2791          MT_RELEASE, l3ni1_release},
2792         {SBIT(19),  MT_RELEASE, l3ni1_release_ind},
2793         {SBIT(1) | SBIT(2) | SBIT(3) | SBIT(4) | SBIT(7) | SBIT(8) | SBIT(9) | SBIT(10) | SBIT(11) | SBIT(15) | SBIT(17) | SBIT(25),
2794          MT_DISCONNECT, l3ni1_disconnect},
2795         {SBIT(19),
2796          MT_DISCONNECT, l3ni1_dummy},
2797         {SBIT(1) | SBIT(2) | SBIT(3) | SBIT(4),
2798          MT_CONNECT, l3ni1_connect},
2799         {SBIT(8),
2800          MT_CONNECT_ACKNOWLEDGE, l3ni1_connect_ack},
2801         {SBIT(15),
2802          MT_SUSPEND_ACKNOWLEDGE, l3ni1_suspend_ack},
2803         {SBIT(15),
2804          MT_SUSPEND_REJECT, l3ni1_suspend_rej},
2805         {SBIT(17),
2806          MT_RESUME_ACKNOWLEDGE, l3ni1_resume_ack},
2807         {SBIT(17),
2808          MT_RESUME_REJECT, l3ni1_resume_rej},
2809 };
2810
2811 static struct stateentry globalmes_list[] =
2812 {
2813         {ALL_STATES,
2814          MT_STATUS, l3ni1_status},
2815         {SBIT(0),
2816          MT_RESTART, l3ni1_global_restart},
2817 /*      {SBIT(1),
2818         MT_RESTART_ACKNOWLEDGE, l3ni1_restart_ack},
2819 */
2820         { SBIT(0), MT_DL_ESTABLISHED, l3ni1_spid_send },
2821         { SBIT(20) | SBIT(21) | SBIT(22), MT_INFORMATION, l3ni1_spid_epid },
2822 };
2823
2824 static struct stateentry manstatelist[] =
2825 {
2826         {SBIT(2),
2827          DL_ESTABLISH | INDICATION, l3ni1_dl_reset},
2828         {SBIT(10),
2829          DL_ESTABLISH | CONFIRM, l3ni1_dl_reest_status},
2830         {SBIT(10),
2831          DL_RELEASE | INDICATION, l3ni1_dl_reestablish},
2832         {ALL_STATES,
2833          DL_RELEASE | INDICATION, l3ni1_dl_release},
2834 };
2835
2836 /* *INDENT-ON* */
2837
2838
2839 static void
2840 global_handler(struct PStack *st, int mt, struct sk_buff *skb)
2841 {
2842         u_char tmp[16];
2843         u_char *p = tmp;
2844         int l;
2845         int i;
2846         struct l3_process *proc = st->l3.global;
2847
2848         if (skb)
2849                 proc->callref = skb->data[2]; /* cr flag */
2850         else
2851                 proc->callref = 0;
2852         for (i = 0; i < ARRAY_SIZE(globalmes_list); i++)
2853                 if ((mt == globalmes_list[i].primitive) &&
2854                     ((1 << proc->state) & globalmes_list[i].state))
2855                         break;
2856         if (i == ARRAY_SIZE(globalmes_list)) {
2857                 if (st->l3.debug & L3_DEB_STATE) {
2858                         l3_debug(st, "ni1 global state %d mt %x unhandled",
2859                                  proc->state, mt);
2860                 }
2861                 MsgHead(p, proc->callref, MT_STATUS);
2862                 *p++ = IE_CAUSE;
2863                 *p++ = 0x2;
2864                 *p++ = 0x80;
2865                 *p++ = 81 | 0x80;       /* invalid cr */
2866                 *p++ = 0x14;            /* CallState */
2867                 *p++ = 0x1;
2868                 *p++ = proc->state & 0x3f;
2869                 l = p - tmp;
2870                 if (!(skb = l3_alloc_skb(l)))
2871                         return;
2872                 memcpy(skb_put(skb, l), tmp, l);
2873                 l3_msg(proc->st, DL_DATA | REQUEST, skb);
2874         } else {
2875                 if (st->l3.debug & L3_DEB_STATE) {
2876                         l3_debug(st, "ni1 global %d mt %x",
2877                                  proc->state, mt);
2878                 }
2879                 globalmes_list[i].rout(proc, mt, skb);
2880         }
2881 }
2882
2883 static void
2884 ni1up(struct PStack *st, int pr, void *arg)
2885 {
2886         int i, mt, cr, callState;
2887         char *ptr;
2888         u_char *p;
2889         struct sk_buff *skb = arg;
2890         struct l3_process *proc;
2891
2892         switch (pr) {
2893         case (DL_DATA | INDICATION):
2894         case (DL_UNIT_DATA | INDICATION):
2895                 break;
2896         case (DL_ESTABLISH | INDICATION):
2897         case (DL_RELEASE | INDICATION):
2898         case (DL_RELEASE | CONFIRM):
2899                 l3_msg(st, pr, arg);
2900                 return;
2901                 break;
2902
2903         case (DL_ESTABLISH | CONFIRM):
2904                 global_handler(st, MT_DL_ESTABLISHED, NULL);
2905                 return;
2906
2907         default:
2908                 printk(KERN_ERR "HiSax ni1up unknown pr=%04x\n", pr);
2909                 return;
2910         }
2911         if (skb->len < 3) {
2912                 l3_debug(st, "ni1up frame too short(%d)", skb->len);
2913                 dev_kfree_skb(skb);
2914                 return;
2915         }
2916
2917         if (skb->data[0] != PROTO_DIS_EURO) {
2918                 if (st->l3.debug & L3_DEB_PROTERR) {
2919                         l3_debug(st, "ni1up%sunexpected discriminator %x message len %d",
2920                                  (pr == (DL_DATA | INDICATION)) ? " " : "(broadcast) ",
2921                                  skb->data[0], skb->len);
2922                 }
2923                 dev_kfree_skb(skb);
2924                 return;
2925         }
2926         cr = getcallref(skb->data);
2927         if (skb->len < ((skb->data[1] & 0x0f) + 3)) {
2928                 l3_debug(st, "ni1up frame too short(%d)", skb->len);
2929                 dev_kfree_skb(skb);
2930                 return;
2931         }
2932         mt = skb->data[skb->data[1] + 2];
2933         if (st->l3.debug & L3_DEB_STATE)
2934                 l3_debug(st, "ni1up cr %d", cr);
2935         if (cr == -2) {  /* wrong Callref */
2936                 if (st->l3.debug & L3_DEB_WARN)
2937                         l3_debug(st, "ni1up wrong Callref");
2938                 dev_kfree_skb(skb);
2939                 return;
2940         } else if (cr == -1) {  /* Dummy Callref */
2941                 if (mt == MT_FACILITY)
2942                 {
2943                         if ((p = findie(skb->data, skb->len, IE_FACILITY, 0))) {
2944                                 l3ni1_parse_facility(st, NULL,
2945                                                      (pr == (DL_DATA | INDICATION)) ? -1 : -2, p);
2946                                 dev_kfree_skb(skb);
2947                                 return;
2948                         }
2949                 }
2950                 else
2951                 {
2952                         global_handler(st, mt, skb);
2953                         return;
2954                 }
2955
2956                 if (st->l3.debug & L3_DEB_WARN)
2957                         l3_debug(st, "ni1up dummy Callref (no facility msg or ie)");
2958                 dev_kfree_skb(skb);
2959                 return;
2960         } else if ((((skb->data[1] & 0x0f) == 1) && (0 == (cr & 0x7f))) ||
2961                    (((skb->data[1] & 0x0f) == 2) && (0 == (cr & 0x7fff)))) {    /* Global CallRef */
2962                 if (st->l3.debug & L3_DEB_STATE)
2963                         l3_debug(st, "ni1up Global CallRef");
2964                 global_handler(st, mt, skb);
2965                 dev_kfree_skb(skb);
2966                 return;
2967         } else if (!(proc = getl3proc(st, cr))) {
2968                 /* No transaction process exist, that means no call with
2969                  * this callreference is active
2970                  */
2971                 if (mt == MT_SETUP) {
2972                         /* Setup creates a new transaction process */
2973                         if (skb->data[2] & 0x80) {
2974                                 /* Setup with wrong CREF flag */
2975                                 if (st->l3.debug & L3_DEB_STATE)
2976                                         l3_debug(st, "ni1up wrong CRef flag");
2977                                 dev_kfree_skb(skb);
2978                                 return;
2979                         }
2980                         if (!(proc = ni1_new_l3_process(st, cr))) {
2981                                 /* May be to answer with RELEASE_COMPLETE and
2982                                  * CAUSE 0x2f "Resource unavailable", but this
2983                                  * need a new_l3_process too ... arghh
2984                                  */
2985                                 dev_kfree_skb(skb);
2986                                 return;
2987                         }
2988                 } else if (mt == MT_STATUS) {
2989                         if ((ptr = findie(skb->data, skb->len, IE_CAUSE, 0)) != NULL) {
2990                                 ptr++;
2991                                 if (*ptr++ == 2)
2992                                         ptr++;
2993                         }
2994                         callState = 0;
2995                         if ((ptr = findie(skb->data, skb->len, IE_CALL_STATE, 0)) != NULL) {
2996                                 ptr++;
2997                                 if (*ptr++ == 2)
2998                                         ptr++;
2999                                 callState = *ptr;
3000                         }
3001                         /* ETS 300-104 part 2.4.1
3002                          * if setup has not been made and a message type
3003                          * MT_STATUS is received with call state == 0,
3004                          * we must send nothing
3005                          */
3006                         if (callState != 0) {
3007                                 /* ETS 300-104 part 2.4.2
3008                                  * if setup has not been made and a message type
3009                                  * MT_STATUS is received with call state != 0,
3010                                  * we must send MT_RELEASE_COMPLETE cause 101
3011                                  */
3012                                 if ((proc = ni1_new_l3_process(st, cr))) {
3013                                         proc->para.cause = 101;
3014                                         l3ni1_msg_without_setup(proc, 0, NULL);
3015                                 }
3016                         }
3017                         dev_kfree_skb(skb);
3018                         return;
3019                 } else if (mt == MT_RELEASE_COMPLETE) {
3020                         dev_kfree_skb(skb);
3021                         return;
3022                 } else {
3023                         /* ETS 300-104 part 2
3024                          * if setup has not been made and a message type
3025                          * (except MT_SETUP and RELEASE_COMPLETE) is received,
3026                          * we must send MT_RELEASE_COMPLETE cause 81 */
3027                         dev_kfree_skb(skb);
3028                         if ((proc = ni1_new_l3_process(st, cr))) {
3029                                 proc->para.cause = 81;
3030                                 l3ni1_msg_without_setup(proc, 0, NULL);
3031                         }
3032                         return;
3033                 }
3034         }
3035         if (l3ni1_check_messagetype_validity(proc, mt, skb)) {
3036                 dev_kfree_skb(skb);
3037                 return;
3038         }
3039         if ((p = findie(skb->data, skb->len, IE_DISPLAY, 0)) != NULL)
3040                 l3ni1_deliver_display(proc, pr, p); /* Display IE included */
3041         for (i = 0; i < ARRAY_SIZE(datastatelist); i++)
3042                 if ((mt == datastatelist[i].primitive) &&
3043                     ((1 << proc->state) & datastatelist[i].state))
3044                         break;
3045         if (i == ARRAY_SIZE(datastatelist)) {
3046                 if (st->l3.debug & L3_DEB_STATE) {
3047                         l3_debug(st, "ni1up%sstate %d mt %#x unhandled",
3048                                  (pr == (DL_DATA | INDICATION)) ? " " : "(broadcast) ",
3049                                  proc->state, mt);
3050                 }
3051                 if ((MT_RELEASE_COMPLETE != mt) && (MT_RELEASE != mt)) {
3052                         proc->para.cause = 101;
3053                         l3ni1_status_send(proc, pr, skb);
3054                 }
3055         } else {
3056                 if (st->l3.debug & L3_DEB_STATE) {
3057                         l3_debug(st, "ni1up%sstate %d mt %x",
3058                                  (pr == (DL_DATA | INDICATION)) ? " " : "(broadcast) ",
3059                                  proc->state, mt);
3060                 }
3061                 datastatelist[i].rout(proc, pr, skb);
3062         }
3063         dev_kfree_skb(skb);
3064         return;
3065 }
3066
3067 static void
3068 ni1down(struct PStack *st, int pr, void *arg)
3069 {
3070         int i, cr;
3071         struct l3_process *proc;
3072         struct Channel *chan;
3073
3074         if ((DL_ESTABLISH | REQUEST) == pr) {
3075                 l3_msg(st, pr, NULL);
3076                 return;
3077         } else if (((CC_SETUP | REQUEST) == pr) || ((CC_RESUME | REQUEST) == pr)) {
3078                 chan = arg;
3079                 cr = newcallref();
3080                 cr |= 0x80;
3081                 if ((proc = ni1_new_l3_process(st, cr))) {
3082                         proc->chan = chan;
3083                         chan->proc = proc;
3084                         memcpy(&proc->para.setup, &chan->setup, sizeof(setup_parm));
3085                         proc->callref = cr;
3086                 }
3087         } else {
3088                 proc = arg;
3089         }
3090         if (!proc) {
3091                 printk(KERN_ERR "HiSax ni1down without proc pr=%04x\n", pr);
3092                 return;
3093         }
3094
3095         if (pr == (CC_TNI1_IO | REQUEST)) {
3096                 l3ni1_io_timer(proc); /* timer expires */
3097                 return;
3098         }
3099
3100         for (i = 0; i < ARRAY_SIZE(downstatelist); i++)
3101                 if ((pr == downstatelist[i].primitive) &&
3102                     ((1 << proc->state) & downstatelist[i].state))
3103                         break;
3104         if (i == ARRAY_SIZE(downstatelist)) {
3105                 if (st->l3.debug & L3_DEB_STATE) {
3106                         l3_debug(st, "ni1down state %d prim %#x unhandled",
3107                                  proc->state, pr);
3108                 }
3109         } else {
3110                 if (st->l3.debug & L3_DEB_STATE) {
3111                         l3_debug(st, "ni1down state %d prim %#x",
3112                                  proc->state, pr);
3113                 }
3114                 downstatelist[i].rout(proc, pr, arg);
3115         }
3116 }
3117
3118 static void
3119 ni1man(struct PStack *st, int pr, void *arg)
3120 {
3121         int i;
3122         struct l3_process *proc = arg;
3123
3124         if (!proc) {
3125                 printk(KERN_ERR "HiSax ni1man without proc pr=%04x\n", pr);
3126                 return;
3127         }
3128         for (i = 0; i < ARRAY_SIZE(manstatelist); i++)
3129                 if ((pr == manstatelist[i].primitive) &&
3130                     ((1 << proc->state) & manstatelist[i].state))
3131                         break;
3132         if (i == ARRAY_SIZE(manstatelist)) {
3133                 if (st->l3.debug & L3_DEB_STATE) {
3134                         l3_debug(st, "cr %d ni1man state %d prim %#x unhandled",
3135                                  proc->callref & 0x7f, proc->state, pr);
3136                 }
3137         } else {
3138                 if (st->l3.debug & L3_DEB_STATE) {
3139                         l3_debug(st, "cr %d ni1man state %d prim %#x",
3140                                  proc->callref & 0x7f, proc->state, pr);
3141                 }
3142                 manstatelist[i].rout(proc, pr, arg);
3143         }
3144 }
3145
3146 void
3147 setstack_ni1(struct PStack *st)
3148 {
3149         char tmp[64];
3150         int i;
3151
3152         st->lli.l4l3 = ni1down;
3153         st->lli.l4l3_proto = l3ni1_cmd_global;
3154         st->l2.l2l3 = ni1up;
3155         st->l3.l3ml3 = ni1man;
3156         st->l3.N303 = 1;
3157         st->prot.ni1.last_invoke_id = 0;
3158         st->prot.ni1.invoke_used[0] = 1; /* Bit 0 must always be set to 1 */
3159         i = 1;
3160         while (i < 32)
3161                 st->prot.ni1.invoke_used[i++] = 0;
3162
3163         if (!(st->l3.global = kmalloc(sizeof(struct l3_process), GFP_ATOMIC))) {
3164                 printk(KERN_ERR "HiSax can't get memory for ni1 global CR\n");
3165         } else {
3166                 st->l3.global->state = 0;
3167                 st->l3.global->callref = 0;
3168                 st->l3.global->next = NULL;
3169                 st->l3.global->debug = L3_DEB_WARN;
3170                 st->l3.global->st = st;
3171                 st->l3.global->N303 = 1;
3172                 st->l3.global->prot.ni1.invoke_id = 0;
3173
3174                 L3InitTimer(st->l3.global, &st->l3.global->timer);
3175         }
3176         strcpy(tmp, ni1_revision);
3177         printk(KERN_INFO "HiSax: National ISDN-1 Rev. %s\n", HiSax_getrev(tmp));
3178 }