drivers/isdn/divert/isdn_divert.c

   1 /* $Id: isdn_divert.c,v 1.6.6.3 2001/09/23 22:24:36 kai Exp $
   2  *
   3  * DSS1 main diversion supplementary handling for i4l.
   4  *
   5  * Copyright 1999       by Werner Cornelius (werner@isdn4linux.de)
   6  *
   7  * This software may be used and distributed according to the terms
   8  * of the GNU General Public License, incorporated herein by reference.
   9  *
  10  */
  11
  12 #include <linux/proc_fs.h>
  13
  14 #include "isdn_divert.h"
  15
  16 /**********************************/
  17 /* structure keeping calling info */
  18 /**********************************/
  19 struct call_struc
  20   { isdn_ctrl ics; /* delivered setup + driver parameters */
  21     ulong divert_id; /* Id delivered to user */
  22     unsigned char akt_state; /* actual state */
  23     char deflect_dest[35]; /* deflection destination */
  24     struct timer_list timer; /* timer control structure */
  25     char info[90]; /* device info output */
  26     struct call_struc *next; /* pointer to next entry */
  27     struct call_struc *prev;
  28   };
  29
  30
  31 /********************************************/
  32 /* structure keeping deflection table entry */
  33 /********************************************/
  34 struct deflect_struc
  35   { struct deflect_struc *next,*prev;
  36     divert_rule rule; /* used rule */
  37   };
  38
  39
  40 /*****************************************/
  41 /* variables for main diversion services */
  42 /*****************************************/
  43 /* diversion/deflection processes */
  44 static struct call_struc *divert_head = NULL; /* head of remembered entrys */
  45 static ulong next_id = 1; /* next info id */
  46 static struct deflect_struc *table_head = NULL;
  47 static struct deflect_struc *table_tail = NULL;
  48 static unsigned char extern_wait_max = 4; /* maximum wait in s for external process */
  49
  50 DEFINE_SPINLOCK(divert_lock);
  51
  52 /***************************/
  53 /* timer callback function */
  54 /***************************/
  55 static void deflect_timer_expire(ulong arg)
  56 {
  57   unsigned long flags;
  58   struct call_struc *cs = (struct call_struc *) arg;
  59
  60   spin_lock_irqsave(&divert_lock, flags);
  61   del_timer(&cs->timer); /* delete active timer */
  62   spin_unlock_irqrestore(&divert_lock, flags);
  63
  64   switch(cs->akt_state)
  65    { case DEFLECT_PROCEED:
  66        cs->ics.command = ISDN_CMD_HANGUP; /* cancel action */
  67        divert_if.ll_cmd(&cs->ics);
  68        spin_lock_irqsave(&divert_lock, flags);
  69        cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
  70        cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
  71        add_timer(&cs->timer);
  72        spin_unlock_irqrestore(&divert_lock, flags);
  73        break;
  74
  75      case DEFLECT_ALERT:
  76        cs->ics.command = ISDN_CMD_REDIR; /* protocol */
  77        strcpy(cs->ics.parm.setup.phone,cs->deflect_dest);
  78        strcpy(cs->ics.parm.setup.eazmsn,"Testtext delayed");
  79        divert_if.ll_cmd(&cs->ics);
  80        spin_lock_irqsave(&divert_lock, flags);
  81        cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
  82        cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
  83        add_timer(&cs->timer);
  84        spin_unlock_irqrestore(&divert_lock, flags);
  85        break;
  86
  87      case DEFLECT_AUTODEL:
  88      default:
  89        spin_lock_irqsave(&divert_lock, flags);
  90        if (cs->prev)
  91          cs->prev->next = cs->next; /* forward link */
  92         else
  93          divert_head = cs->next;
  94        if (cs->next)
  95          cs->next->prev = cs->prev; /* back link */
  96        spin_unlock_irqrestore(&divert_lock, flags);
  97        kfree(cs);
  98        return;
  99
 100    } /* switch */
 101 } /* deflect_timer_func */
 102
 103
 104 /*****************************************/
 105 /* handle call forwarding de/activations */
 106 /* 0 = deact, 1 = act, 2 = interrogate   */
 107 /*****************************************/
 108 int cf_command(int drvid, int mode,
 109                u_char proc, char *msn,
 110                u_char service, char *fwd_nr, ulong *procid)
 111 { unsigned long flags;
 112   int retval,msnlen;
 113   int fwd_len;
 114   char *p,*ielenp,tmp[60];
 115   struct call_struc *cs;
 116
 117   if (strchr(msn,'.')) return(-EINVAL); /* subaddress not allowed in msn */
 118   if ((proc & 0x7F) > 2) return(-EINVAL);
 119   proc &= 3;
 120   p = tmp;
 121   *p++ = 0x30; /* enumeration */
 122   ielenp = p++; /* remember total length position */
 123   *p++ = 0xa; /* proc tag */
 124   *p++ = 1;   /* length */
 125   *p++ = proc & 0x7F; /* procedure to de/activate/interrogate */
 126   *p++ = 0xa; /* service tag */
 127   *p++ = 1;   /* length */
 128   *p++ = service; /* service to handle */
 129
 130   if (mode == 1)
 131    { if (!*fwd_nr) return(-EINVAL); /* destination missing */
 132      if (strchr(fwd_nr,'.')) return(-EINVAL); /* subaddress not allowed */
 133      fwd_len = strlen(fwd_nr);
 134      *p++ = 0x30; /* number enumeration */
 135      *p++ = fwd_len + 2; /* complete forward to len */
 136      *p++ = 0x80; /* fwd to nr */
 137      *p++ = fwd_len; /* length of number */
 138      strcpy(p,fwd_nr); /* copy number */
 139      p += fwd_len; /* pointer beyond fwd */
 140    } /* activate */
 141
 142   msnlen = strlen(msn);
 143   *p++ = 0x80; /* msn number */
 144   if (msnlen > 1)
 145    { *p++ = msnlen; /* length */
 146      strcpy(p,msn);
 147      p += msnlen;
 148    }
 149   else *p++ = 0;
 150
 151   *ielenp = p - ielenp - 1; /* set total IE length */
 152
 153   /* allocate mem for information struct */
 154   if (!(cs = (struct call_struc *) kmalloc(sizeof(struct call_struc), GFP_ATOMIC)))
 155              return(-ENOMEM); /* no memory */
 156   init_timer(&cs->timer);
 157   cs->info[0] = '\0';
 158   cs->timer.function = deflect_timer_expire;
 159   cs->timer.data = (ulong) cs; /* pointer to own structure */
 160   cs->ics.driver = drvid;
 161   cs->ics.command = ISDN_CMD_PROT_IO; /* protocol specific io */
 162   cs->ics.arg = DSS1_CMD_INVOKE; /* invoke supplementary service */
 163   cs->ics.parm.dss1_io.proc = (mode == 1) ? 7: (mode == 2) ? 11:8; /* operation */
 164   cs->ics.parm.dss1_io.timeout = 4000; /* from ETS 300 207-1 */
 165   cs->ics.parm.dss1_io.datalen = p - tmp; /* total len */
 166   cs->ics.parm.dss1_io.data = tmp; /* start of buffer */
 167
 168   spin_lock_irqsave(&divert_lock, flags);
 169   cs->ics.parm.dss1_io.ll_id = next_id++; /* id for callback */
 170   spin_unlock_irqrestore(&divert_lock, flags);
 171   *procid = cs->ics.parm.dss1_io.ll_id;
 172
 173   sprintf(cs->info,"%d 0x%lx %s%s 0 %s %02x %d%s%s\n",
 174           (!mode ) ? DIVERT_DEACTIVATE : (mode == 1) ? DIVERT_ACTIVATE : DIVERT_REPORT,
 175           cs->ics.parm.dss1_io.ll_id,
 176           (mode != 2) ? "" : "0 ",
 177           divert_if.drv_to_name(cs->ics.driver),
 178           msn,
 179           service & 0xFF,
 180           proc,
 181           (mode != 1) ? "" : " 0 ",
 182           (mode != 1) ? "" : fwd_nr);
 183
 184   retval = divert_if.ll_cmd(&cs->ics); /* excute command */
 185
 186   if (!retval)
 187    { cs->prev = NULL;
 188      spin_lock_irqsave(&divert_lock, flags);
 189      cs->next = divert_head;
 190      divert_head = cs;
 191      spin_unlock_irqrestore(&divert_lock, flags);
 192    }
 193   else
 194    kfree(cs);
 195   return(retval);
 196 } /* cf_command */
 197
 198
 199 /****************************************/
 200 /* handle a external deflection command */
 201 /****************************************/
 202 int deflect_extern_action(u_char cmd, ulong callid, char *to_nr)
 203 { struct call_struc *cs;
 204   isdn_ctrl ic;
 205   unsigned long flags;
 206   int i;
 207
 208   if ((cmd & 0x7F) > 2) return(-EINVAL); /* invalid command */
 209   cs = divert_head; /* start of parameter list */
 210   while (cs)
 211    { if (cs->divert_id == callid) break; /* found */
 212      cs = cs->next;
 213    } /* search entry */
 214   if (!cs) return(-EINVAL); /* invalid callid */
 215
 216   ic.driver = cs->ics.driver;
 217   ic.arg = cs->ics.arg;
 218   i = -EINVAL;
 219   if (cs->akt_state == DEFLECT_AUTODEL) return(i); /* no valid call */
 220   switch (cmd & 0x7F)
 221    { case 0: /* hangup */
 222        del_timer(&cs->timer);
 223        ic.command = ISDN_CMD_HANGUP;
 224        i = divert_if.ll_cmd(&ic);
 225        spin_lock_irqsave(&divert_lock, flags);
 226        cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
 227        cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
 228        add_timer(&cs->timer);
 229        spin_unlock_irqrestore(&divert_lock, flags);
 230      break;
 231
 232      case 1: /* alert */
 233        if (cs->akt_state == DEFLECT_ALERT) return(0);
 234        cmd &= 0x7F; /* never wait */
 235        del_timer(&cs->timer);
 236        ic.command = ISDN_CMD_ALERT;
 237        if ((i = divert_if.ll_cmd(&ic)))
 238         {
 239           spin_lock_irqsave(&divert_lock, flags);
 240           cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
 241           cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
 242           add_timer(&cs->timer);
 243           spin_unlock_irqrestore(&divert_lock, flags);
 244         }
 245        else
 246           cs->akt_state = DEFLECT_ALERT;
 247      break;
 248
 249      case 2: /* redir */
 250        del_timer(&cs->timer);
 251        strcpy(cs->ics.parm.setup.phone, to_nr);
 252        strcpy(cs->ics.parm.setup.eazmsn, "Testtext manual");
 253        ic.command = ISDN_CMD_REDIR;
 254        if ((i = divert_if.ll_cmd(&ic)))
 255         {
 256           spin_lock_irqsave(&divert_lock, flags);
 257           cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
 258           cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
 259           add_timer(&cs->timer);
 260           spin_unlock_irqrestore(&divert_lock, flags);
 261         }
 262        else
 263           cs->akt_state = DEFLECT_ALERT;
 264      break;
 265
 266    } /* switch */
 267   return(i);
 268 } /* deflect_extern_action */
 269
 270 /********************************/
 271 /* insert a new rule before idx */
 272 /********************************/
 273 int insertrule(int idx, divert_rule *newrule)
 274 { struct deflect_struc *ds,*ds1=NULL;
 275   unsigned long flags;
 276
 277   if (!(ds = (struct deflect_struc *) kmalloc(sizeof(struct deflect_struc),
 278                                               GFP_KERNEL)))
 279     return(-ENOMEM); /* no memory */
 280
 281   ds->rule = *newrule; /* set rule */
 282
 283   spin_lock_irqsave(&divert_lock, flags);
 284
 285   if (idx >= 0)
 286    { ds1 = table_head;
 287      while ((ds1) && (idx > 0))
 288       { idx--;
 289         ds1 = ds1->next;
 290       }
 291      if (!ds1) idx = -1;
 292    }
 293
 294   if (idx < 0)
 295    { ds->prev = table_tail; /* previous entry */
 296      ds->next = NULL; /* end of chain */
 297      if (ds->prev)
 298        ds->prev->next = ds; /* last forward */
 299       else
 300         table_head = ds; /* is first entry */
 301      table_tail = ds; /* end of queue */
 302    }
 303   else
 304     { ds->next = ds1; /* next entry */
 305       ds->prev = ds1->prev; /* prev entry */
 306       ds1->prev = ds; /* backward chain old element */
 307       if (!ds->prev)
 308         table_head = ds; /* first element */
 309    }
 310
 311   spin_unlock_irqrestore(&divert_lock, flags);
 312   return(0);
 313 } /* insertrule */
 314
 315 /***********************************/
 316 /* delete the rule at position idx */
 317 /***********************************/
 318 int deleterule(int idx)
 319 { struct deflect_struc *ds,*ds1;
 320   unsigned long flags;
 321
 322   if (idx < 0)
 323    { spin_lock_irqsave(&divert_lock, flags);
 324      ds = table_head;
 325      table_head = NULL;
 326      table_tail = NULL;
 327      spin_unlock_irqrestore(&divert_lock, flags);
 328      while (ds)
 329       { ds1 = ds;
 330         ds = ds->next;
 331         kfree(ds1);
 332       }
 333      return(0);
 334    }
 335
 336   spin_lock_irqsave(&divert_lock, flags);
 337   ds = table_head;
 338
 339   while ((ds) && (idx > 0))
 340    { idx--;
 341      ds = ds->next;
 342    }
 343
 344   if (!ds)
 345    {
 346      spin_unlock_irqrestore(&divert_lock, flags);
 347      return(-EINVAL);
 348    }
 349
 350   if (ds->next)
 351     ds->next->prev = ds->prev; /* backward chain */
 352    else
 353      table_tail = ds->prev; /* end of chain */
 354
 355   if (ds->prev)
 356     ds->prev->next = ds->next; /* forward chain */
 357    else
 358      table_head = ds->next; /* start of chain */
 359
 360   spin_unlock_irqrestore(&divert_lock, flags);
 361   kfree(ds);
 362   return(0);
 363 } /* deleterule */
 364
 365 /*******************************************/
 366 /* get a pointer to a specific rule number */
 367 /*******************************************/
 368 divert_rule *getruleptr(int idx)
 369 { struct deflect_struc *ds = table_head;
 370
 371   if (idx < 0) return(NULL);
 372   while ((ds) && (idx >= 0))
 373    { if (!(idx--))
 374       { return(&ds->rule);
 375         break;
 376       }
 377      ds = ds->next;
 378    }
 379   return(NULL);
 380 } /* getruleptr */
 381
 382 /*************************************************/
 383 /* called from common module on an incoming call */
 384 /*************************************************/
 385 static int isdn_divert_icall(isdn_ctrl *ic)
 386 { int retval = 0;
 387   unsigned long flags;
 388   struct call_struc *cs = NULL;
 389   struct deflect_struc *dv;
 390   char *p,*p1;
 391   u_char accept;
 392
 393   /* first check the internal deflection table */
 394   for (dv = table_head; dv ; dv = dv->next )
 395    { /* scan table */
 396      if (((dv->rule.callopt == 1) && (ic->command == ISDN_STAT_ICALLW)) ||
 397          ((dv->rule.callopt == 2) && (ic->command == ISDN_STAT_ICALL)))
 398        continue; /* call option check */
 399      if (!(dv->rule.drvid & (1L << ic->driver)))
 400        continue; /* driver not matching */
 401      if ((dv->rule.si1) && (dv->rule.si1 != ic->parm.setup.si1))
 402        continue; /* si1 not matching */
 403      if ((dv->rule.si2) && (dv->rule.si2 != ic->parm.setup.si2))
 404        continue; /* si2 not matching */
 405
 406      p = dv->rule.my_msn;
 407      p1 = ic->parm.setup.eazmsn;
 408      accept = 0;
 409      while (*p)
 410       { /* complete compare */
 411         if (*p == '-')
 412           { accept = 1; /* call accepted */
 413             break;
 414           }
 415         if (*p++ != *p1++)
 416           break; /* not accepted */
 417         if ((!*p) && (!*p1))
 418           accept = 1;
 419       } /* complete compare */
 420      if (!accept) continue; /* not accepted */
 421
 422      if ((strcmp(dv->rule.caller,"0")) || (ic->parm.setup.phone[0]))
 423       { p = dv->rule.caller;
 424         p1 = ic->parm.setup.phone;
 425         accept = 0;
 426         while (*p)
 427          { /* complete compare */
 428            if (*p == '-')
 429             { accept = 1; /* call accepted */
 430               break;
 431             }
 432            if (*p++ != *p1++)
 433              break; /* not accepted */
 434            if ((!*p) && (!*p1))
 435              accept = 1;
 436          } /* complete compare */
 437         if (!accept) continue; /* not accepted */
 438       }
 439
 440      switch (dv->rule.action)
 441        { case DEFLECT_IGNORE:
 442            return(0);
 443            break;
 444
 445          case DEFLECT_ALERT:
 446          case DEFLECT_PROCEED:
 447          case DEFLECT_REPORT:
 448          case DEFLECT_REJECT:
 449            if (dv->rule.action == DEFLECT_PROCEED)
 450             if ((!if_used) || ((!extern_wait_max) && (!dv->rule.waittime)))
 451               return(0); /* no external deflection needed */
 452            if (!(cs = (struct call_struc *) kmalloc(sizeof(struct call_struc), GFP_ATOMIC)))
 453              return(0); /* no memory */
 454            init_timer(&cs->timer);
 455            cs->info[0] = '\0';
 456            cs->timer.function = deflect_timer_expire;
 457            cs->timer.data = (ulong) cs; /* pointer to own structure */
 458
 459            cs->ics = *ic; /* copy incoming data */
 460            if (!cs->ics.parm.setup.phone[0]) strcpy(cs->ics.parm.setup.phone,"0");
 461            if (!cs->ics.parm.setup.eazmsn[0]) strcpy(cs->ics.parm.setup.eazmsn,"0");
 462            cs->ics.parm.setup.screen = dv->rule.screen;
 463            if (dv->rule.waittime)
 464              cs->timer.expires = jiffies + (HZ * dv->rule.waittime);
 465            else
 466             if (dv->rule.action == DEFLECT_PROCEED)
 467               cs->timer.expires = jiffies + (HZ * extern_wait_max);
 468             else
 469               cs->timer.expires = 0;
 470            cs->akt_state = dv->rule.action;
 471            spin_lock_irqsave(&divert_lock, flags);
 472            cs->divert_id = next_id++; /* new sequence number */
 473            spin_unlock_irqrestore(&divert_lock, flags);
 474            cs->prev = NULL;
 475            if (cs->akt_state == DEFLECT_ALERT)
 476              { strcpy(cs->deflect_dest,dv->rule.to_nr);
 477                if (!cs->timer.expires)
 478                  { strcpy(ic->parm.setup.eazmsn,"Testtext direct");
 479                    ic->parm.setup.screen = dv->rule.screen;
 480                    strcpy(ic->parm.setup.phone,dv->rule.to_nr);
 481                    cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
 482                    cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
 483                    retval = 5;
 484                  }
 485                else
 486                  retval = 1; /* alerting */
 487              }
 488            else
 489              { cs->deflect_dest[0] = '\0';
 490                retval = 4; /* only proceed */
 491              }
 492            sprintf(cs->info,"%d 0x%lx %s %s %s %s 0x%x 0x%x %d %d %s\n",
 493                    cs->akt_state,
 494                    cs->divert_id,
 495                    divert_if.drv_to_name(cs->ics.driver),
 496                    (ic->command == ISDN_STAT_ICALLW) ? "1":"0",
 497                    cs->ics.parm.setup.phone,
 498                    cs->ics.parm.setup.eazmsn,
 499                    cs->ics.parm.setup.si1,
 500                    cs->ics.parm.setup.si2,
 501                    cs->ics.parm.setup.screen,
 502                    dv->rule.waittime,
 503                    cs->deflect_dest);
 504            if ((dv->rule.action == DEFLECT_REPORT) ||
 505                (dv->rule.action == DEFLECT_REJECT))
 506             { put_info_buffer(cs->info);
 507               kfree(cs); /* remove */
 508               return((dv->rule.action == DEFLECT_REPORT) ? 0:2); /* nothing to do */
 509             }
 510            break;
 511
 512          default:
 513            return(0); /* ignore call */
 514            break;
 515        } /* switch action */
 516      break;
 517    } /* scan_table */
 518
 519   if (cs)
 520    { cs->prev = NULL;
 521      spin_lock_irqsave(&divert_lock, flags);
 522      cs->next = divert_head;
 523      divert_head = cs;
 524      if (cs->timer.expires) add_timer(&cs->timer);
 525      spin_unlock_irqrestore(&divert_lock, flags);
 526
 527      put_info_buffer(cs->info);
 528      return(retval);
 529    }
 530   else
 531      return(0);
 532 } /* isdn_divert_icall */
 533
 534
 535 void deleteprocs(void)
 536 { struct call_struc *cs, *cs1;
 537   unsigned long flags;
 538
 539   spin_lock_irqsave(&divert_lock, flags);
 540   cs = divert_head;
 541   divert_head = NULL;
 542   while (cs)
 543    { del_timer(&cs->timer);
 544      cs1 = cs;
 545      cs = cs->next;
 546      kfree(cs1);
 547    }
 548   spin_unlock_irqrestore(&divert_lock, flags);
 549 } /* deleteprocs */
 550
 551 /****************************************************/
 552 /* put a address including address type into buffer */
 553 /****************************************************/
 554 static int put_address(char *st, u_char *p, int len)
 555 { u_char retval = 0;
 556   u_char adr_typ = 0; /* network standard */
 557
 558   if (len < 2) return(retval);
 559   if (*p == 0xA1)
 560    { retval = *(++p) + 2; /* total length */
 561      if (retval > len) return(0); /* too short */
 562      len = retval - 2; /* remaining length */
 563      if (len < 3) return(0);
 564      if ((*(++p) != 0x0A) || (*(++p) != 1)) return(0);
 565      adr_typ = *(++p);
 566      len -= 3;
 567      p++;
 568      if (len < 2) return(0);
 569      if (*p++ != 0x12) return(0);
 570      if (*p > len) return(0); /* check number length */
 571      len = *p++;
 572    }
 573   else
 574    if (*p == 0x80)
 575     { retval = *(++p) + 2; /* total length */
 576       if (retval > len) return(0);
 577       len = retval - 2;
 578       p++;
 579     }
 580    else
 581     return(0); /* invalid address information */
 582
 583   sprintf(st,"%d ",adr_typ);
 584   st += strlen(st);
 585   if (!len)
 586     *st++ = '-';
 587   else
 588    while (len--)
 589      *st++ = *p++;
 590   *st = '\0';
 591   return(retval);
 592 } /* put_address */
 593
 594 /*************************************/
 595 /* report a succesfull interrogation */
 596 /*************************************/
 597 static int interrogate_success(isdn_ctrl *ic, struct call_struc *cs)
 598 { char *src = ic->parm.dss1_io.data;
 599   int restlen = ic->parm.dss1_io.datalen;
 600   int cnt = 1;
 601   u_char n,n1;
 602   char st[90], *p, *stp;
 603
 604   if (restlen < 2) return(-100); /* frame too short */
 605   if (*src++ != 0x30) return(-101);
 606   if ((n = *src++) > 0x81) return(-102); /* invalid length field */
 607   restlen -= 2; /* remaining bytes */
 608   if (n == 0x80)
 609    { if (restlen < 2) return(-103);
 610      if ((*(src+restlen-1)) || (*(src+restlen-2))) return(-104);
 611      restlen -= 2;
 612    }
 613   else
 614    if ( n == 0x81)
 615     { n = *src++;
 616       restlen--;
 617       if (n > restlen) return(-105);
 618       restlen = n;
 619     }
 620    else
 621     if (n > restlen) return(-106);
 622      else
 623       restlen = n; /* standard format */
 624   if (restlen < 3) return(-107); /* no procedure */
 625   if ((*src++ != 2) || (*src++ != 1) || (*src++ != 0x0B)) return(-108);
 626   restlen -= 3;
 627   if (restlen < 2) return(-109); /* list missing */
 628   if (*src == 0x31)
 629    { src++;
 630      if ((n = *src++) > 0x81) return(-110); /* invalid length field */
 631      restlen -= 2; /* remaining bytes */
 632      if (n == 0x80)
 633       { if (restlen < 2) return(-111);
 634         if ((*(src+restlen-1)) || (*(src+restlen-2))) return(-112);
 635         restlen -= 2;
 636       }
 637      else
 638       if ( n == 0x81)
 639        { n = *src++;
 640          restlen--;
 641          if (n > restlen) return(-113);
 642          restlen = n;
 643        }
 644       else
 645        if (n > restlen) return(-114);
 646         else
 647          restlen = n; /* standard format */
 648    } /* result list header */
 649
 650   while (restlen >= 2)
 651    { stp = st;
 652      sprintf(stp,"%d 0x%lx %d %s ",DIVERT_REPORT, ic->parm.dss1_io.ll_id,
 653                  cnt++,divert_if.drv_to_name(ic->driver));
 654      stp += strlen(stp);
 655      if (*src++ != 0x30) return(-115); /* invalid enum */
 656      n = *src++;
 657      restlen -= 2;
 658      if (n > restlen) return(-116); /* enum length wrong */
 659      restlen -= n;
 660      p = src; /* one entry */
 661      src += n;
 662      if (!(n1 = put_address(stp,p,n & 0xFF))) continue;
 663      stp += strlen(stp);
 664      p += n1;
 665      n -= n1;
 666      if (n < 6) continue; /* no service and proc */
 667      if ((*p++ != 0x0A) || (*p++ != 1)) continue;
 668      sprintf(stp," 0x%02x ",(*p++) & 0xFF);
 669      stp += strlen(stp);
 670      if ((*p++ != 0x0A) || (*p++ != 1)) continue;
 671      sprintf(stp,"%d ",(*p++) & 0xFF);
 672      stp += strlen(stp);
 673      n -= 6;
 674      if (n > 2)
 675       { if (*p++ != 0x30) continue;
 676         if (*p > (n-2)) continue;
 677         n = *p++;
 678         if (!(n1 = put_address(stp,p,n & 0xFF))) continue;
 679         stp += strlen(stp);
 680       }
 681      sprintf(stp,"\n");
 682      put_info_buffer(st);
 683    } /* while restlen */
 684   if (restlen) return(-117);
 685   return(0);
 686 } /* interrogate_success */
 687
 688 /*********************************************/
 689 /* callback for protocol specific extensions */
 690 /*********************************************/
 691 static int prot_stat_callback(isdn_ctrl *ic)
 692 { struct call_struc *cs, *cs1;
 693   int i;
 694   unsigned long flags;
 695
 696   cs = divert_head; /* start of list */
 697   cs1 = NULL;
 698   while (cs)
 699    { if (ic->driver == cs->ics.driver)
 700       { switch (cs->ics.arg)
 701          { case DSS1_CMD_INVOKE:
 702              if ((cs->ics.parm.dss1_io.ll_id == ic->parm.dss1_io.ll_id) &&
 703                  (cs->ics.parm.dss1_io.hl_id == ic->parm.dss1_io.hl_id))
 704               { switch (ic->arg)
 705                 {  case DSS1_STAT_INVOKE_ERR:
 706                      sprintf(cs->info,"128 0x%lx 0x%x\n",
 707                              ic->parm.dss1_io.ll_id,
 708                              ic->parm.dss1_io.timeout);
 709                      put_info_buffer(cs->info);
 710                    break;
 711
 712                    case DSS1_STAT_INVOKE_RES:
 713                      switch (cs->ics.parm.dss1_io.proc)
 714                       {  case  7:
 715                          case  8:
 716                             put_info_buffer(cs->info);
 717                            break;
 718
 719                          case  11:
 720                            i = interrogate_success(ic,cs);
 721                            if (i)
 722                              sprintf(cs->info,"%d 0x%lx %d\n",DIVERT_REPORT,
 723                                      ic->parm.dss1_io.ll_id,i);
 724                            put_info_buffer(cs->info);
 725                            break;
 726
 727                          default:
 728                            printk(KERN_WARNING "dss1_divert: unknown proc %d\n",cs->ics.parm.dss1_io.proc);
 729                            break;
 730                       }
 731
 732
 733                    break;
 734
 735                    default:
 736                      printk(KERN_WARNING "dss1_divert unknown invoke answer %lx\n",ic->arg);
 737                    break;
 738                  }
 739                 cs1 = cs; /* remember structure */
 740                 cs = NULL;
 741                 continue; /* abort search */
 742               } /* id found */
 743            break;
 744
 745            case DSS1_CMD_INVOKE_ABORT:
 746              printk(KERN_WARNING "dss1_divert unhandled invoke abort\n");
 747            break;
 748
 749            default:
 750              printk(KERN_WARNING "dss1_divert unknown cmd 0x%lx\n",cs->ics.arg);
 751            break;
 752          } /* switch ics.arg */
 753         cs = cs->next;
 754       } /* driver ok */
 755    }
 756
 757   if (!cs1)
 758    { printk(KERN_WARNING "dss1_divert unhandled process\n");
 759      return(0);
 760    }
 761
 762   if (cs1->ics.driver == -1)
 763    {
 764      spin_lock_irqsave(&divert_lock, flags);
 765      del_timer(&cs1->timer);
 766      if (cs1->prev)
 767        cs1->prev->next = cs1->next; /* forward link */
 768      else
 769        divert_head = cs1->next;
 770      if (cs1->next)
 771        cs1->next->prev = cs1->prev; /* back link */
 772      spin_unlock_irqrestore(&divert_lock, flags);
 773      kfree(cs1);
 774    }
 775
 776   return(0);
 777 } /* prot_stat_callback */
 778
 779
 780 /***************************/
 781 /* status callback from HL */
 782 /***************************/
 783 static int isdn_divert_stat_callback(isdn_ctrl *ic)
 784 { struct call_struc *cs, *cs1;
 785   unsigned long flags;
 786   int retval;
 787
 788   retval = -1;
 789   cs = divert_head; /* start of list */
 790      while (cs)
 791       { if ((ic->driver == cs->ics.driver) && (ic->arg == cs->ics.arg))
 792          { switch (ic->command)
 793             { case ISDN_STAT_DHUP:
 794                 sprintf(cs->info,"129 0x%lx\n",cs->divert_id);
 795                 del_timer(&cs->timer);
 796                 cs->ics.driver = -1;
 797                 break;
 798
 799               case ISDN_STAT_CAUSE:
 800                 sprintf(cs->info,"130 0x%lx %s\n",cs->divert_id,ic->parm.num);
 801                 break;
 802
 803               case ISDN_STAT_REDIR:
 804                 sprintf(cs->info,"131 0x%lx\n",cs->divert_id);
 805                 del_timer(&cs->timer);
 806                 cs->ics.driver = -1;
 807                 break;
 808
 809               default:
 810                 sprintf(cs->info,"999 0x%lx 0x%x\n",cs->divert_id,(int)(ic->command));
 811                 break;
 812             }
 813           put_info_buffer(cs->info);
 814           retval = 0;
 815          }
 816         cs1 = cs;
 817         cs = cs->next;
 818         if (cs1->ics.driver == -1)
 819           {
 820             spin_lock_irqsave(&divert_lock, flags);
 821             if (cs1->prev)
 822               cs1->prev->next = cs1->next; /* forward link */
 823             else
 824               divert_head = cs1->next;
 825             if (cs1->next)
 826               cs1->next->prev = cs1->prev; /* back link */
 827             spin_unlock_irqrestore(&divert_lock, flags);
 828             kfree(cs1);
 829           }
 830       }
 831   return(retval); /* not found */
 832 } /* isdn_divert_stat_callback */
 833
 834
 835 /********************/
 836 /* callback from ll */
 837 /********************/
 838 int ll_callback(isdn_ctrl *ic)
 839 {
 840   switch (ic->command)
 841    { case ISDN_STAT_ICALL:
 842      case ISDN_STAT_ICALLW:
 843        return(isdn_divert_icall(ic));
 844      break;
 845
 846      case ISDN_STAT_PROT:
 847        if ((ic->arg & 0xFF) == ISDN_PTYPE_EURO)
 848         { if (ic->arg != DSS1_STAT_INVOKE_BRD)
 849             return(prot_stat_callback(ic));
 850           else
 851             return(0); /* DSS1 invoke broadcast */
 852         }
 853        else
 854          return(-1); /* protocol not euro */
 855
 856      default:
 857        return(isdn_divert_stat_callback(ic));
 858    }
 859 } /* ll_callback */
 860