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