1 /* $Id: isdn_divert.c,v 1.6.6.3 2001/09/23 22:24:36 kai Exp $
3 * DSS1 main diversion supplementary handling for i4l.
5 * Copyright 1999 by Werner Cornelius (werner@isdn4linux.de)
7 * This software may be used and distributed according to the terms
8 * of the GNU General Public License, incorporated herein by reference.
12 #include <linux/proc_fs.h>
13 #include <linux/slab.h>
14 #include <linux/timer.h>
15 #include <linux/jiffies.h>
17 #include "isdn_divert.h"
19 /**********************************/
20 /* structure keeping calling info */
21 /**********************************/
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;
34 /********************************************/
35 /* structure keeping deflection table entry */
36 /********************************************/
37 struct deflect_struc {
38 struct deflect_struc *next, *prev;
39 divert_rule rule; /* used rule */
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 */
53 DEFINE_SPINLOCK(divert_lock);
55 /***************************/
56 /* timer callback function */
57 /***************************/
58 static void deflect_timer_expire(ulong arg)
61 struct call_struc *cs = (struct call_struc *) arg;
63 spin_lock_irqsave(&divert_lock, flags);
64 del_timer(&cs->timer); /* delete active timer */
65 spin_unlock_irqrestore(&divert_lock, flags);
67 switch (cs->akt_state) {
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);
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);
92 spin_lock_irqsave(&divert_lock, flags);
94 cs->prev->next = cs->next; /* forward link */
96 divert_head = cs->next;
98 cs->next->prev = cs->prev; /* back link */
99 spin_unlock_irqrestore(&divert_lock, flags);
104 } /* deflect_timer_func */
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)
118 char *p, *ielenp, tmp[60];
119 struct call_struc *cs;
121 if (strchr(msn, '.')) return (-EINVAL); /* subaddress not allowed in msn */
122 if ((proc & 0x7F) > 2) return (-EINVAL);
125 *p++ = 0x30; /* enumeration */
126 ielenp = p++; /* remember total length position */
127 *p++ = 0xa; /* proc tag */
128 *p++ = 1; /* length */
129 *p++ = proc & 0x7F; /* procedure to de/activate/interrogate */
130 *p++ = 0xa; /* service tag */
131 *p++ = 1; /* length */
132 *p++ = service; /* service to handle */
135 if (!*fwd_nr) return (-EINVAL); /* destination missing */
136 if (strchr(fwd_nr, '.')) return (-EINVAL); /* subaddress not allowed */
137 fwd_len = strlen(fwd_nr);
138 *p++ = 0x30; /* number enumeration */
139 *p++ = fwd_len + 2; /* complete forward to len */
140 *p++ = 0x80; /* fwd to nr */
141 *p++ = fwd_len; /* length of number */
142 strcpy(p, fwd_nr); /* copy number */
143 p += fwd_len; /* pointer beyond fwd */
146 msnlen = strlen(msn);
147 *p++ = 0x80; /* msn number */
149 *p++ = msnlen; /* length */
155 *ielenp = p - ielenp - 1; /* set total IE length */
157 /* allocate mem for information struct */
158 if (!(cs = kmalloc(sizeof(struct call_struc), GFP_ATOMIC)))
159 return (-ENOMEM); /* no memory */
160 init_timer(&cs->timer);
162 cs->timer.function = deflect_timer_expire;
163 cs->timer.data = (ulong) cs; /* pointer to own structure */
164 cs->ics.driver = drvid;
165 cs->ics.command = ISDN_CMD_PROT_IO; /* protocol specific io */
166 cs->ics.arg = DSS1_CMD_INVOKE; /* invoke supplementary service */
167 cs->ics.parm.dss1_io.proc = (mode == 1) ? 7 : (mode == 2) ? 11 : 8; /* operation */
168 cs->ics.parm.dss1_io.timeout = 4000; /* from ETS 300 207-1 */
169 cs->ics.parm.dss1_io.datalen = p - tmp; /* total len */
170 cs->ics.parm.dss1_io.data = tmp; /* start of buffer */
172 spin_lock_irqsave(&divert_lock, flags);
173 cs->ics.parm.dss1_io.ll_id = next_id++; /* id for callback */
174 spin_unlock_irqrestore(&divert_lock, flags);
175 *procid = cs->ics.parm.dss1_io.ll_id;
177 sprintf(cs->info, "%d 0x%lx %s%s 0 %s %02x %d%s%s\n",
178 (!mode) ? DIVERT_DEACTIVATE : (mode == 1) ? DIVERT_ACTIVATE : DIVERT_REPORT,
179 cs->ics.parm.dss1_io.ll_id,
180 (mode != 2) ? "" : "0 ",
181 divert_if.drv_to_name(cs->ics.driver),
185 (mode != 1) ? "" : " 0 ",
186 (mode != 1) ? "" : fwd_nr);
188 retval = divert_if.ll_cmd(&cs->ics); /* execute command */
192 spin_lock_irqsave(&divert_lock, flags);
193 cs->next = divert_head;
195 spin_unlock_irqrestore(&divert_lock, flags);
202 /****************************************/
203 /* handle a external deflection command */
204 /****************************************/
205 int deflect_extern_action(u_char cmd, ulong callid, char *to_nr)
207 struct call_struc *cs;
212 if ((cmd & 0x7F) > 2) return (-EINVAL); /* invalid command */
213 cs = divert_head; /* start of parameter list */
215 if (cs->divert_id == callid) break; /* found */
218 if (!cs) return (-EINVAL); /* invalid callid */
220 ic.driver = cs->ics.driver;
221 ic.arg = cs->ics.arg;
223 if (cs->akt_state == DEFLECT_AUTODEL) return (i); /* no valid call */
224 switch (cmd & 0x7F) {
226 del_timer(&cs->timer);
227 ic.command = ISDN_CMD_HANGUP;
228 i = divert_if.ll_cmd(&ic);
229 spin_lock_irqsave(&divert_lock, flags);
230 cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
231 cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
232 add_timer(&cs->timer);
233 spin_unlock_irqrestore(&divert_lock, flags);
237 if (cs->akt_state == DEFLECT_ALERT) return (0);
238 cmd &= 0x7F; /* never wait */
239 del_timer(&cs->timer);
240 ic.command = ISDN_CMD_ALERT;
241 if ((i = divert_if.ll_cmd(&ic))) {
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);
248 cs->akt_state = DEFLECT_ALERT;
252 del_timer(&cs->timer);
253 strlcpy(cs->ics.parm.setup.phone, to_nr, sizeof(cs->ics.parm.setup.phone));
254 strcpy(cs->ics.parm.setup.eazmsn, "Testtext manual");
255 ic.command = ISDN_CMD_REDIR;
256 if ((i = divert_if.ll_cmd(&ic))) {
257 spin_lock_irqsave(&divert_lock, flags);
258 cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
259 cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
260 add_timer(&cs->timer);
261 spin_unlock_irqrestore(&divert_lock, flags);
263 cs->akt_state = DEFLECT_ALERT;
268 } /* deflect_extern_action */
270 /********************************/
271 /* insert a new rule before idx */
272 /********************************/
273 int insertrule(int idx, divert_rule *newrule)
275 struct deflect_struc *ds, *ds1 = NULL;
278 if (!(ds = kmalloc(sizeof(struct deflect_struc), GFP_KERNEL)))
279 return (-ENOMEM); /* no memory */
281 ds->rule = *newrule; /* set rule */
283 spin_lock_irqsave(&divert_lock, flags);
287 while ((ds1) && (idx > 0))
295 ds->prev = table_tail; /* previous entry */
296 ds->next = NULL; /* end of chain */
298 ds->prev->next = ds; /* last forward */
300 table_head = ds; /* is first entry */
301 table_tail = ds; /* end of queue */
303 ds->next = ds1; /* next entry */
304 ds->prev = ds1->prev; /* prev entry */
305 ds1->prev = ds; /* backward chain old element */
307 table_head = ds; /* first element */
310 spin_unlock_irqrestore(&divert_lock, flags);
314 /***********************************/
315 /* delete the rule at position idx */
316 /***********************************/
317 int deleterule(int idx)
319 struct deflect_struc *ds, *ds1;
323 spin_lock_irqsave(&divert_lock, flags);
327 spin_unlock_irqrestore(&divert_lock, flags);
336 spin_lock_irqsave(&divert_lock, flags);
339 while ((ds) && (idx > 0)) {
345 spin_unlock_irqrestore(&divert_lock, flags);
350 ds->next->prev = ds->prev; /* backward chain */
352 table_tail = ds->prev; /* end of chain */
355 ds->prev->next = ds->next; /* forward chain */
357 table_head = ds->next; /* start of chain */
359 spin_unlock_irqrestore(&divert_lock, flags);
364 /*******************************************/
365 /* get a pointer to a specific rule number */
366 /*******************************************/
367 divert_rule *getruleptr(int idx)
369 struct deflect_struc *ds = table_head;
371 if (idx < 0) return (NULL);
372 while ((ds) && (idx >= 0)) {
382 /*************************************************/
383 /* called from common module on an incoming call */
384 /*************************************************/
385 static int isdn_divert_icall(isdn_ctrl *ic)
389 struct call_struc *cs = NULL;
390 struct deflect_struc *dv;
394 /* first check the internal deflection table */
395 for (dv = table_head; dv; dv = dv->next) {
397 if (((dv->rule.callopt == 1) && (ic->command == ISDN_STAT_ICALLW)) ||
398 ((dv->rule.callopt == 2) && (ic->command == ISDN_STAT_ICALL)))
399 continue; /* call option check */
400 if (!(dv->rule.drvid & (1L << ic->driver)))
401 continue; /* driver not matching */
402 if ((dv->rule.si1) && (dv->rule.si1 != ic->parm.setup.si1))
403 continue; /* si1 not matching */
404 if ((dv->rule.si2) && (dv->rule.si2 != ic->parm.setup.si2))
405 continue; /* si2 not matching */
408 p1 = ic->parm.setup.eazmsn;
411 /* complete compare */
413 accept = 1; /* call accepted */
417 break; /* not accepted */
420 } /* complete compare */
421 if (!accept) continue; /* not accepted */
423 if ((strcmp(dv->rule.caller, "0")) ||
424 (ic->parm.setup.phone[0])) {
426 p1 = ic->parm.setup.phone;
429 /* complete compare */
431 accept = 1; /* call accepted */
435 break; /* not accepted */
438 } /* complete compare */
439 if (!accept) continue; /* not accepted */
442 switch (dv->rule.action) {
448 case DEFLECT_PROCEED:
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);
458 cs->timer.function = deflect_timer_expire;
459 cs->timer.data = (ulong) cs; /* pointer to own structure */
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 if (dv->rule.action == DEFLECT_PROCEED)
468 cs->timer.expires = jiffies + (HZ * extern_wait_max);
470 cs->timer.expires = 0;
471 cs->akt_state = dv->rule.action;
472 spin_lock_irqsave(&divert_lock, flags);
473 cs->divert_id = next_id++; /* new sequence number */
474 spin_unlock_irqrestore(&divert_lock, flags);
476 if (cs->akt_state == DEFLECT_ALERT) {
477 strcpy(cs->deflect_dest, dv->rule.to_nr);
478 if (!cs->timer.expires) {
479 strcpy(ic->parm.setup.eazmsn,
481 ic->parm.setup.screen = dv->rule.screen;
482 strlcpy(ic->parm.setup.phone, dv->rule.to_nr, sizeof(ic->parm.setup.phone));
483 cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
484 cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
487 retval = 1; /* alerting */
489 cs->deflect_dest[0] = '\0';
490 retval = 4; /* only proceed */
492 sprintf(cs->info, "%d 0x%lx %s %s %s %s 0x%x 0x%x %d %d %s\n",
495 divert_if.drv_to_name(cs->ics.driver),
496 (ic->command == ISDN_STAT_ICALLW) ? "1" : "0",
497 cs->ics.parm.setup.phone,
498 cs->ics.parm.setup.eazmsn,
499 cs->ics.parm.setup.si1,
500 cs->ics.parm.setup.si2,
501 cs->ics.parm.setup.screen,
504 if ((dv->rule.action == DEFLECT_REPORT) ||
505 (dv->rule.action == DEFLECT_REJECT)) {
506 put_info_buffer(cs->info);
507 kfree(cs); /* remove */
508 return ((dv->rule.action == DEFLECT_REPORT) ? 0 : 2); /* nothing to do */
513 return (0); /* ignore call */
515 } /* switch action */
521 spin_lock_irqsave(&divert_lock, flags);
522 cs->next = divert_head;
524 if (cs->timer.expires) add_timer(&cs->timer);
525 spin_unlock_irqrestore(&divert_lock, flags);
527 put_info_buffer(cs->info);
531 } /* isdn_divert_icall */
534 void deleteprocs(void)
536 struct call_struc *cs, *cs1;
539 spin_lock_irqsave(&divert_lock, flags);
543 del_timer(&cs->timer);
548 spin_unlock_irqrestore(&divert_lock, flags);
551 /****************************************************/
552 /* put a address including address type into buffer */
553 /****************************************************/
554 static int put_address(char *st, u_char *p, int len)
557 u_char adr_typ = 0; /* network standard */
559 if (len < 2) return (retval);
561 retval = *(++p) + 2; /* total length */
562 if (retval > len) return (0); /* too short */
563 len = retval - 2; /* remaining length */
564 if (len < 3) return (0);
565 if ((*(++p) != 0x0A) || (*(++p) != 1)) return (0);
569 if (len < 2) return (0);
570 if (*p++ != 0x12) return (0);
571 if (*p > len) return (0); /* check number length */
573 } else if (*p == 0x80) {
574 retval = *(++p) + 2; /* total length */
575 if (retval > len) return (0);
579 return (0); /* invalid address information */
581 sprintf(st, "%d ", adr_typ);
592 /*************************************/
593 /* report a successful interrogation */
594 /*************************************/
595 static int interrogate_success(isdn_ctrl *ic, struct call_struc *cs)
597 char *src = ic->parm.dss1_io.data;
598 int restlen = ic->parm.dss1_io.datalen;
601 char st[90], *p, *stp;
603 if (restlen < 2) return (-100); /* frame too short */
604 if (*src++ != 0x30) return (-101);
605 if ((n = *src++) > 0x81) return (-102); /* invalid length field */
606 restlen -= 2; /* remaining bytes */
608 if (restlen < 2) return (-103);
609 if ((*(src + restlen - 1)) || (*(src + restlen - 2))) return (-104);
611 } else if (n == 0x81) {
614 if (n > restlen) return (-105);
616 } else if (n > restlen)
619 restlen = n; /* standard format */
620 if (restlen < 3) return (-107); /* no procedure */
621 if ((*src++ != 2) || (*src++ != 1) || (*src++ != 0x0B)) return (-108);
623 if (restlen < 2) return (-109); /* list missing */
626 if ((n = *src++) > 0x81) return (-110); /* invalid length field */
627 restlen -= 2; /* remaining bytes */
629 if (restlen < 2) return (-111);
630 if ((*(src + restlen - 1)) || (*(src + restlen - 2))) return (-112);
632 } else if (n == 0x81) {
635 if (n > restlen) return (-113);
637 } else if (n > restlen)
640 restlen = n; /* standard format */
641 } /* result list header */
643 while (restlen >= 2) {
645 sprintf(stp, "%d 0x%lx %d %s ", DIVERT_REPORT, ic->parm.dss1_io.ll_id,
646 cnt++, divert_if.drv_to_name(ic->driver));
648 if (*src++ != 0x30) return (-115); /* invalid enum */
651 if (n > restlen) return (-116); /* enum length wrong */
653 p = src; /* one entry */
655 if (!(n1 = put_address(stp, p, n & 0xFF))) continue;
659 if (n < 6) continue; /* no service and proc */
660 if ((*p++ != 0x0A) || (*p++ != 1)) continue;
661 sprintf(stp, " 0x%02x ", (*p++) & 0xFF);
663 if ((*p++ != 0x0A) || (*p++ != 1)) continue;
664 sprintf(stp, "%d ", (*p++) & 0xFF);
668 if (*p++ != 0x30) continue;
669 if (*p > (n - 2)) continue;
671 if (!(n1 = put_address(stp, p, n & 0xFF))) continue;
676 } /* while restlen */
677 if (restlen) return (-117);
679 } /* interrogate_success */
681 /*********************************************/
682 /* callback for protocol specific extensions */
683 /*********************************************/
684 static int prot_stat_callback(isdn_ctrl *ic)
686 struct call_struc *cs, *cs1;
690 cs = divert_head; /* start of list */
693 if (ic->driver == cs->ics.driver) {
694 switch (cs->ics.arg) {
695 case DSS1_CMD_INVOKE:
696 if ((cs->ics.parm.dss1_io.ll_id == ic->parm.dss1_io.ll_id) &&
697 (cs->ics.parm.dss1_io.hl_id == ic->parm.dss1_io.hl_id)) {
699 case DSS1_STAT_INVOKE_ERR:
700 sprintf(cs->info, "128 0x%lx 0x%x\n",
701 ic->parm.dss1_io.ll_id,
702 ic->parm.dss1_io.timeout);
703 put_info_buffer(cs->info);
706 case DSS1_STAT_INVOKE_RES:
707 switch (cs->ics.parm.dss1_io.proc) {
710 put_info_buffer(cs->info);
714 i = interrogate_success(ic, cs);
716 sprintf(cs->info, "%d 0x%lx %d\n", DIVERT_REPORT,
717 ic->parm.dss1_io.ll_id, i);
718 put_info_buffer(cs->info);
722 printk(KERN_WARNING "dss1_divert: unknown proc %d\n", cs->ics.parm.dss1_io.proc);
729 printk(KERN_WARNING "dss1_divert unknown invoke answer %lx\n", ic->arg);
732 cs1 = cs; /* remember structure */
734 continue; /* abort search */
738 case DSS1_CMD_INVOKE_ABORT:
739 printk(KERN_WARNING "dss1_divert unhandled invoke abort\n");
743 printk(KERN_WARNING "dss1_divert unknown cmd 0x%lx\n", cs->ics.arg);
745 } /* switch ics.arg */
751 printk(KERN_WARNING "dss1_divert unhandled process\n");
755 if (cs1->ics.driver == -1) {
756 spin_lock_irqsave(&divert_lock, flags);
757 del_timer(&cs1->timer);
759 cs1->prev->next = cs1->next; /* forward link */
761 divert_head = cs1->next;
763 cs1->next->prev = cs1->prev; /* back link */
764 spin_unlock_irqrestore(&divert_lock, flags);
769 } /* prot_stat_callback */
772 /***************************/
773 /* status callback from HL */
774 /***************************/
775 static int isdn_divert_stat_callback(isdn_ctrl *ic)
777 struct call_struc *cs, *cs1;
782 cs = divert_head; /* start of list */
784 if ((ic->driver == cs->ics.driver) &&
785 (ic->arg == cs->ics.arg)) {
786 switch (ic->command) {
788 sprintf(cs->info, "129 0x%lx\n", cs->divert_id);
789 del_timer(&cs->timer);
793 case ISDN_STAT_CAUSE:
794 sprintf(cs->info, "130 0x%lx %s\n", cs->divert_id, ic->parm.num);
797 case ISDN_STAT_REDIR:
798 sprintf(cs->info, "131 0x%lx\n", cs->divert_id);
799 del_timer(&cs->timer);
804 sprintf(cs->info, "999 0x%lx 0x%x\n", cs->divert_id, (int)(ic->command));
807 put_info_buffer(cs->info);
812 if (cs1->ics.driver == -1) {
813 spin_lock_irqsave(&divert_lock, flags);
815 cs1->prev->next = cs1->next; /* forward link */
817 divert_head = cs1->next;
819 cs1->next->prev = cs1->prev; /* back link */
820 spin_unlock_irqrestore(&divert_lock, flags);
824 return (retval); /* not found */
825 } /* isdn_divert_stat_callback */
828 /********************/
829 /* callback from ll */
830 /********************/
831 int ll_callback(isdn_ctrl *ic)
833 switch (ic->command) {
834 case ISDN_STAT_ICALL:
835 case ISDN_STAT_ICALLW:
836 return (isdn_divert_icall(ic));
840 if ((ic->arg & 0xFF) == ISDN_PTYPE_EURO) {
841 if (ic->arg != DSS1_STAT_INVOKE_BRD)
842 return (prot_stat_callback(ic));
844 return (0); /* DSS1 invoke broadcast */
846 return (-1); /* protocol not euro */
849 return (isdn_divert_stat_callback(ic));