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