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