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