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 /***************************/
deflect_timer_expire(ulong arg)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 /*****************************************/
cf_command(int drvid,int mode,u_char proc,char * msn,u_char service,char * fwd_nr,ulong * procid)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); /* excute 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 /****************************************/
deflect_extern_action(u_char cmd,ulong callid,char * to_nr)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 /********************************/
insertrule(int idx,divert_rule * newrule)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 /***********************************/
deleterule(int idx)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 /*******************************************/
getruleptr(int idx)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 /*************************************************/
isdn_divert_icall(isdn_ctrl * ic)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
deleteprocs(void)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 /****************************************************/
put_address(char * st,u_char * p,int len)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 /*************************************/
interrogate_success(isdn_ctrl * ic,struct call_struc * cs)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 /*********************************************/
prot_stat_callback(isdn_ctrl * ic)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 /***************************/
isdn_divert_stat_callback(isdn_ctrl * ic)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 /********************/
ll_callback(isdn_ctrl * ic)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
863