isdn_divert.c 22.9 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
/* $Id: isdn_divert.c,v 1.6.6.3 2001/09/23 22:24:36 kai Exp $
 *
 * DSS1 main diversion supplementary handling for i4l.
 *
 * Copyright 1999       by Werner Cornelius (werner@isdn4linux.de)
6
 *
Linus Torvalds's avatar
Linus Torvalds committed
7
8
9
10
11
12
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 */

#include <linux/proc_fs.h>
13
#include <linux/slab.h>
Al Viro's avatar
Al Viro committed
14
15
#include <linux/timer.h>
#include <linux/jiffies.h>
Linus Torvalds's avatar
Linus Torvalds committed
16
17
18
19
20
21

#include "isdn_divert.h"

/**********************************/
/* structure keeping calling info */
/**********************************/
22
23
struct call_struc {
	isdn_ctrl ics; /* delivered setup + driver parameters */
24
25
26
27
28
29
30
31
	ulong divert_id; /* Id delivered to user */
	unsigned char akt_state; /* actual state */
	char deflect_dest[35]; /* deflection destination */
	struct timer_list timer; /* timer control structure */
	char info[90]; /* device info output */
	struct call_struc *next; /* pointer to next entry */
	struct call_struc *prev;
};
Linus Torvalds's avatar
Linus Torvalds committed
32
33
34
35
36


/********************************************/
/* structure keeping deflection table entry */
/********************************************/
37
38
struct deflect_struc {
	struct deflect_struc *next, *prev;
39
40
	divert_rule rule; /* used rule */
};
Linus Torvalds's avatar
Linus Torvalds committed
41
42
43
44
45
46
47


/*****************************************/
/* variables for main diversion services */
/*****************************************/
/* diversion/deflection processes */
static struct call_struc *divert_head = NULL; /* head of remembered entrys */
48
static ulong next_id = 1; /* next info id */
Linus Torvalds's avatar
Linus Torvalds committed
49
static struct deflect_struc *table_head = NULL;
50
51
static struct deflect_struc *table_tail = NULL;
static unsigned char extern_wait_max = 4; /* maximum wait in s for external process */
Linus Torvalds's avatar
Linus Torvalds committed
52
53
54
55
56
57
58
59

DEFINE_SPINLOCK(divert_lock);

/***************************/
/* timer callback function */
/***************************/
static void deflect_timer_expire(ulong arg)
{
60
61
62
63
64
65
66
	unsigned long flags;
	struct call_struc *cs = (struct call_struc *) arg;

	spin_lock_irqsave(&divert_lock, flags);
	del_timer(&cs->timer); /* delete active timer */
	spin_unlock_irqrestore(&divert_lock, flags);

67
68
69
70
71
72
73
74
75
76
	switch (cs->akt_state) {
	case DEFLECT_PROCEED:
		cs->ics.command = ISDN_CMD_HANGUP; /* cancel action */
		divert_if.ll_cmd(&cs->ics);
		spin_lock_irqsave(&divert_lock, flags);
		cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
		cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
		add_timer(&cs->timer);
		spin_unlock_irqrestore(&divert_lock, flags);
		break;
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

	case DEFLECT_ALERT:
		cs->ics.command = ISDN_CMD_REDIR; /* protocol */
		strlcpy(cs->ics.parm.setup.phone, cs->deflect_dest, sizeof(cs->ics.parm.setup.phone));
		strcpy(cs->ics.parm.setup.eazmsn, "Testtext delayed");
		divert_if.ll_cmd(&cs->ics);
		spin_lock_irqsave(&divert_lock, flags);
		cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
		cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
		add_timer(&cs->timer);
		spin_unlock_irqrestore(&divert_lock, flags);
		break;

	case DEFLECT_AUTODEL:
	default:
		spin_lock_irqsave(&divert_lock, flags);
		if (cs->prev)
			cs->prev->next = cs->next; /* forward link */
		else
			divert_head = cs->next;
		if (cs->next)
			cs->next->prev = cs->prev; /* back link */
		spin_unlock_irqrestore(&divert_lock, flags);
		kfree(cs);
		return;

	} /* switch */
Linus Torvalds's avatar
Linus Torvalds committed
104
105
106
107
108
109
110
} /* deflect_timer_func */


/*****************************************/
/* handle call forwarding de/activations */
/* 0 = deact, 1 = act, 2 = interrogate   */
/*****************************************/
111
112
113
int cf_command(int drvid, int mode,
	       u_char proc, char *msn,
	       u_char service, char *fwd_nr, ulong *procid)
114
115
{
	unsigned long flags;
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
	int retval, msnlen;
	int fwd_len;
	char *p, *ielenp, tmp[60];
	struct call_struc *cs;

	if (strchr(msn, '.')) return (-EINVAL); /* subaddress not allowed in msn */
	if ((proc & 0x7F) > 2) return (-EINVAL);
	proc &= 3;
	p = tmp;
	*p++ = 0x30; /* enumeration */
	ielenp = p++; /* remember total length position */
	*p++ = 0xa; /* proc tag */
	*p++ = 1;   /* length */
	*p++ = proc & 0x7F; /* procedure to de/activate/interrogate */
	*p++ = 0xa; /* service tag */
	*p++ = 1;   /* length */
	*p++ = service; /* service to handle */

134
135
	if (mode == 1) {
		if (!*fwd_nr) return (-EINVAL); /* destination missing */
136
137
138
139
140
141
142
143
144
145
146
147
		if (strchr(fwd_nr, '.')) return (-EINVAL); /* subaddress not allowed */
		fwd_len = strlen(fwd_nr);
		*p++ = 0x30; /* number enumeration */
		*p++ = fwd_len + 2; /* complete forward to len */
		*p++ = 0x80; /* fwd to nr */
		*p++ = fwd_len; /* length of number */
		strcpy(p, fwd_nr); /* copy number */
		p += fwd_len; /* pointer beyond fwd */
	} /* activate */

	msnlen = strlen(msn);
	*p++ = 0x80; /* msn number */
148
149
	if (msnlen > 1) {
		*p++ = msnlen; /* length */
150
151
		strcpy(p, msn);
		p += msnlen;
152
153
	} else
		*p++ = 0;
154
155
156
157
158
159

	*ielenp = p - ielenp - 1; /* set total IE length */

	/* allocate mem for information struct */
	if (!(cs = kmalloc(sizeof(struct call_struc), GFP_ATOMIC)))
		return (-ENOMEM); /* no memory */
Geliang Tang's avatar
Geliang Tang committed
160
	setup_timer(&cs->timer, deflect_timer_expire, (ulong)cs);
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
	cs->info[0] = '\0';
	cs->ics.driver = drvid;
	cs->ics.command = ISDN_CMD_PROT_IO; /* protocol specific io */
	cs->ics.arg = DSS1_CMD_INVOKE; /* invoke supplementary service */
	cs->ics.parm.dss1_io.proc = (mode == 1) ? 7 : (mode == 2) ? 11 : 8; /* operation */
	cs->ics.parm.dss1_io.timeout = 4000; /* from ETS 300 207-1 */
	cs->ics.parm.dss1_io.datalen = p - tmp; /* total len */
	cs->ics.parm.dss1_io.data = tmp; /* start of buffer */

	spin_lock_irqsave(&divert_lock, flags);
	cs->ics.parm.dss1_io.ll_id = next_id++; /* id for callback */
	spin_unlock_irqrestore(&divert_lock, flags);
	*procid = cs->ics.parm.dss1_io.ll_id;

	sprintf(cs->info, "%d 0x%lx %s%s 0 %s %02x %d%s%s\n",
		(!mode) ? DIVERT_DEACTIVATE : (mode == 1) ? DIVERT_ACTIVATE : DIVERT_REPORT,
		cs->ics.parm.dss1_io.ll_id,
		(mode != 2) ? "" : "0 ",
		divert_if.drv_to_name(cs->ics.driver),
		msn,
		service & 0xFF,
		proc,
		(mode != 1) ? "" : " 0 ",
		(mode != 1) ? "" : fwd_nr);

	retval = divert_if.ll_cmd(&cs->ics); /* execute command */

188
189
	if (!retval) {
		cs->prev = NULL;
190
191
192
193
		spin_lock_irqsave(&divert_lock, flags);
		cs->next = divert_head;
		divert_head = cs;
		spin_unlock_irqrestore(&divert_lock, flags);
194
	} else
195
196
		kfree(cs);
	return (retval);
Linus Torvalds's avatar
Linus Torvalds committed
197
198
199
200
201
202
203
} /* cf_command */


/****************************************/
/* handle a external deflection command */
/****************************************/
int deflect_extern_action(u_char cmd, ulong callid, char *to_nr)
204
205
{
	struct call_struc *cs;
206
207
208
209
210
211
	isdn_ctrl ic;
	unsigned long flags;
	int i;

	if ((cmd & 0x7F) > 2) return (-EINVAL); /* invalid command */
	cs = divert_head; /* start of parameter list */
212
213
	while (cs) {
		if (cs->divert_id == callid) break; /* found */
214
215
216
217
218
219
220
221
		cs = cs->next;
	} /* search entry */
	if (!cs) return (-EINVAL); /* invalid callid */

	ic.driver = cs->ics.driver;
	ic.arg = cs->ics.arg;
	i = -EINVAL;
	if (cs->akt_state == DEFLECT_AUTODEL) return (i); /* no valid call */
222
223
224
225
226
227
228
229
230
231
232
	switch (cmd & 0x7F) {
	case 0: /* hangup */
		del_timer(&cs->timer);
		ic.command = ISDN_CMD_HANGUP;
		i = divert_if.ll_cmd(&ic);
		spin_lock_irqsave(&divert_lock, flags);
		cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
		cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
		add_timer(&cs->timer);
		spin_unlock_irqrestore(&divert_lock, flags);
		break;
233
234
235
236
237
238

	case 1: /* alert */
		if (cs->akt_state == DEFLECT_ALERT) return (0);
		cmd &= 0x7F; /* never wait */
		del_timer(&cs->timer);
		ic.command = ISDN_CMD_ALERT;
239
		if ((i = divert_if.ll_cmd(&ic))) {
240
241
242
243
244
			spin_lock_irqsave(&divert_lock, flags);
			cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
			cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
			add_timer(&cs->timer);
			spin_unlock_irqrestore(&divert_lock, flags);
245
		} else
246
247
248
249
250
251
252
253
			cs->akt_state = DEFLECT_ALERT;
		break;

	case 2: /* redir */
		del_timer(&cs->timer);
		strlcpy(cs->ics.parm.setup.phone, to_nr, sizeof(cs->ics.parm.setup.phone));
		strcpy(cs->ics.parm.setup.eazmsn, "Testtext manual");
		ic.command = ISDN_CMD_REDIR;
254
		if ((i = divert_if.ll_cmd(&ic))) {
255
256
257
258
259
			spin_lock_irqsave(&divert_lock, flags);
			cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
			cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
			add_timer(&cs->timer);
			spin_unlock_irqrestore(&divert_lock, flags);
260
		} else
261
262
263
264
265
			cs->akt_state = DEFLECT_ALERT;
		break;

	} /* switch */
	return (i);
Linus Torvalds's avatar
Linus Torvalds committed
266
267
268
269
270
271
} /* deflect_extern_action */

/********************************/
/* insert a new rule before idx */
/********************************/
int insertrule(int idx, divert_rule *newrule)
272
273
{
	struct deflect_struc *ds, *ds1 = NULL;
274
275
	unsigned long flags;

276
	if (!(ds = kmalloc(sizeof(struct deflect_struc), GFP_KERNEL)))
277
278
279
280
281
282
		return (-ENOMEM); /* no memory */

	ds->rule = *newrule; /* set rule */

	spin_lock_irqsave(&divert_lock, flags);

283
284
	if (idx >= 0) {
		ds1 = table_head;
285
286
287
288
289
290
291
		while ((ds1) && (idx > 0))
		{ idx--;
			ds1 = ds1->next;
		}
		if (!ds1) idx = -1;
	}

292
293
	if (idx < 0) {
		ds->prev = table_tail; /* previous entry */
294
295
296
297
298
299
		ds->next = NULL; /* end of chain */
		if (ds->prev)
			ds->prev->next = ds; /* last forward */
		else
			table_head = ds; /* is first entry */
		table_tail = ds; /* end of queue */
300
301
	} else {
		ds->next = ds1; /* next entry */
302
303
304
305
306
307
308
309
		ds->prev = ds1->prev; /* prev entry */
		ds1->prev = ds; /* backward chain old element */
		if (!ds->prev)
			table_head = ds; /* first element */
	}

	spin_unlock_irqrestore(&divert_lock, flags);
	return (0);
Linus Torvalds's avatar
Linus Torvalds committed
310
311
312
313
314
315
} /* insertrule */

/***********************************/
/* delete the rule at position idx */
/***********************************/
int deleterule(int idx)
316
317
{
	struct deflect_struc *ds, *ds1;
318
319
	unsigned long flags;

320
321
	if (idx < 0) {
		spin_lock_irqsave(&divert_lock, flags);
322
323
324
325
		ds = table_head;
		table_head = NULL;
		table_tail = NULL;
		spin_unlock_irqrestore(&divert_lock, flags);
326
327
		while (ds) {
			ds1 = ds;
328
329
330
331
332
333
334
335
336
			ds = ds->next;
			kfree(ds1);
		}
		return (0);
	}

	spin_lock_irqsave(&divert_lock, flags);
	ds = table_head;

337
338
	while ((ds) && (idx > 0)) {
		idx--;
339
340
341
		ds = ds->next;
	}

342
	if (!ds) {
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
		spin_unlock_irqrestore(&divert_lock, flags);
		return (-EINVAL);
	}

	if (ds->next)
		ds->next->prev = ds->prev; /* backward chain */
	else
		table_tail = ds->prev; /* end of chain */

	if (ds->prev)
		ds->prev->next = ds->next; /* forward chain */
	else
		table_head = ds->next; /* start of chain */

	spin_unlock_irqrestore(&divert_lock, flags);
	kfree(ds);
	return (0);
Linus Torvalds's avatar
Linus Torvalds committed
360
361
362
363
364
365
} /* deleterule */

/*******************************************/
/* get a pointer to a specific rule number */
/*******************************************/
divert_rule *getruleptr(int idx)
366
367
{
	struct deflect_struc *ds = table_head;
368
369

	if (idx < 0) return (NULL);
370
371
372
	while ((ds) && (idx >= 0)) {
		if (!(idx--)) {
			return (&ds->rule);
373
374
375
376
377
			break;
		}
		ds = ds->next;
	}
	return (NULL);
Linus Torvalds's avatar
Linus Torvalds committed
378
379
380
381
382
} /* getruleptr */

/*************************************************/
/* called from common module on an incoming call */
/*************************************************/
383
static int isdn_divert_icall(isdn_ctrl *ic)
384
385
{
	int retval = 0;
386
387
388
389
390
391
392
	unsigned long flags;
	struct call_struc *cs = NULL;
	struct deflect_struc *dv;
	char *p, *p1;
	u_char accept;

	/* first check the internal deflection table */
393
394
	for (dv = table_head; dv; dv = dv->next) {
		/* scan table */
395
396
397
398
399
400
401
402
403
404
405
406
407
		if (((dv->rule.callopt == 1) && (ic->command == ISDN_STAT_ICALLW)) ||
		    ((dv->rule.callopt == 2) && (ic->command == ISDN_STAT_ICALL)))
			continue; /* call option check */
		if (!(dv->rule.drvid & (1L << ic->driver)))
			continue; /* driver not matching */
		if ((dv->rule.si1) && (dv->rule.si1 != ic->parm.setup.si1))
			continue; /* si1 not matching */
		if ((dv->rule.si2) && (dv->rule.si2 != ic->parm.setup.si2))
			continue; /* si2 not matching */

		p = dv->rule.my_msn;
		p1 = ic->parm.setup.eazmsn;
		accept = 0;
408
409
410
411
		while (*p) {
			/* complete compare */
			if (*p == '-') {
				accept = 1; /* call accepted */
412
413
414
415
416
417
418
419
420
				break;
			}
			if (*p++ != *p1++)
				break; /* not accepted */
			if ((!*p) && (!*p1))
				accept = 1;
		} /* complete compare */
		if (!accept) continue; /* not accepted */

421
422
423
		if ((strcmp(dv->rule.caller, "0")) ||
		    (ic->parm.setup.phone[0])) {
			p = dv->rule.caller;
424
425
			p1 = ic->parm.setup.phone;
			accept = 0;
426
427
428
429
			while (*p) {
				/* complete compare */
				if (*p == '-') {
					accept = 1; /* call accepted */
430
431
432
433
434
435
436
437
438
439
					break;
				}
				if (*p++ != *p1++)
					break; /* not accepted */
				if ((!*p) && (!*p1))
					accept = 1;
			} /* complete compare */
			if (!accept) continue; /* not accepted */
		}

440
441
		switch (dv->rule.action) {
		case DEFLECT_IGNORE:
442
			return 0;
443
444
445
446
447
448
449
450
451
452

		case DEFLECT_ALERT:
		case DEFLECT_PROCEED:
		case DEFLECT_REPORT:
		case DEFLECT_REJECT:
			if (dv->rule.action == DEFLECT_PROCEED)
				if ((!if_used) || ((!extern_wait_max) && (!dv->rule.waittime)))
					return (0); /* no external deflection needed */
			if (!(cs = kmalloc(sizeof(struct call_struc), GFP_ATOMIC)))
				return (0); /* no memory */
Geliang Tang's avatar
Geliang Tang committed
453
454
			setup_timer(&cs->timer, deflect_timer_expire,
				    (ulong)cs);
455
456
457
458
459
460
461
462
			cs->info[0] = '\0';

			cs->ics = *ic; /* copy incoming data */
			if (!cs->ics.parm.setup.phone[0]) strcpy(cs->ics.parm.setup.phone, "0");
			if (!cs->ics.parm.setup.eazmsn[0]) strcpy(cs->ics.parm.setup.eazmsn, "0");
			cs->ics.parm.setup.screen = dv->rule.screen;
			if (dv->rule.waittime)
				cs->timer.expires = jiffies + (HZ * dv->rule.waittime);
463
464
			else if (dv->rule.action == DEFLECT_PROCEED)
				cs->timer.expires = jiffies + (HZ * extern_wait_max);
465
			else
466
				cs->timer.expires = 0;
467
468
469
470
471
			cs->akt_state = dv->rule.action;
			spin_lock_irqsave(&divert_lock, flags);
			cs->divert_id = next_id++; /* new sequence number */
			spin_unlock_irqrestore(&divert_lock, flags);
			cs->prev = NULL;
472
473
474
475
476
			if (cs->akt_state == DEFLECT_ALERT) {
				strcpy(cs->deflect_dest, dv->rule.to_nr);
				if (!cs->timer.expires) {
					strcpy(ic->parm.setup.eazmsn,
					       "Testtext direct");
477
478
479
480
481
					ic->parm.setup.screen = dv->rule.screen;
					strlcpy(ic->parm.setup.phone, dv->rule.to_nr, sizeof(ic->parm.setup.phone));
					cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
					cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
					retval = 5;
482
				} else
483
					retval = 1; /* alerting */
484
485
			} else {
				cs->deflect_dest[0] = '\0';
486
487
				retval = 4; /* only proceed */
			}
488
489
490
491
492
493
494
495
496
497
498
499
500
			snprintf(cs->info, sizeof(cs->info),
				 "%d 0x%lx %s %s %s %s 0x%x 0x%x %d %d %s\n",
				 cs->akt_state,
				 cs->divert_id,
				 divert_if.drv_to_name(cs->ics.driver),
				 (ic->command == ISDN_STAT_ICALLW) ? "1" : "0",
				 cs->ics.parm.setup.phone,
				 cs->ics.parm.setup.eazmsn,
				 cs->ics.parm.setup.si1,
				 cs->ics.parm.setup.si2,
				 cs->ics.parm.setup.screen,
				 dv->rule.waittime,
				 cs->deflect_dest);
501
			if ((dv->rule.action == DEFLECT_REPORT) ||
502
503
			    (dv->rule.action == DEFLECT_REJECT)) {
				put_info_buffer(cs->info);
504
505
506
507
508
509
				kfree(cs); /* remove */
				return ((dv->rule.action == DEFLECT_REPORT) ? 0 : 2); /* nothing to do */
			}
			break;

		default:
510
			return 0; /* ignore call */
511
		} /* switch action */
512
		break; /* will break the 'for' looping */
513
514
	} /* scan_table */

515
516
	if (cs) {
		cs->prev = NULL;
517
518
519
520
521
522
523
524
		spin_lock_irqsave(&divert_lock, flags);
		cs->next = divert_head;
		divert_head = cs;
		if (cs->timer.expires) add_timer(&cs->timer);
		spin_unlock_irqrestore(&divert_lock, flags);

		put_info_buffer(cs->info);
		return (retval);
525
	} else
526
		return (0);
Linus Torvalds's avatar
Linus Torvalds committed
527
528
529
530
} /* isdn_divert_icall */


void deleteprocs(void)
531
532
{
	struct call_struc *cs, *cs1;
533
534
535
536
537
	unsigned long flags;

	spin_lock_irqsave(&divert_lock, flags);
	cs = divert_head;
	divert_head = NULL;
538
539
	while (cs) {
		del_timer(&cs->timer);
540
541
542
543
544
		cs1 = cs;
		cs = cs->next;
		kfree(cs1);
	}
	spin_unlock_irqrestore(&divert_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
545
546
547
548
549
} /* deleteprocs */

/****************************************************/
/* put a address including address type into buffer */
/****************************************************/
550
static int put_address(char *st, u_char *p, int len)
551
552
{
	u_char retval = 0;
553
554
555
	u_char adr_typ = 0; /* network standard */

	if (len < 2) return (retval);
556
557
	if (*p == 0xA1) {
		retval = *(++p) + 2; /* total length */
558
559
560
561
562
563
564
565
566
567
568
		if (retval > len) return (0); /* too short */
		len = retval - 2; /* remaining length */
		if (len < 3) return (0);
		if ((*(++p) != 0x0A) || (*(++p) != 1)) return (0);
		adr_typ = *(++p);
		len -= 3;
		p++;
		if (len < 2) return (0);
		if (*p++ != 0x12) return (0);
		if (*p > len) return (0); /* check number length */
		len = *p++;
569
570
571
572
573
574
575
	} else if (*p == 0x80) {
		retval = *(++p) + 2; /* total length */
		if (retval > len) return (0);
		len = retval - 2;
		p++;
	} else
		return (0); /* invalid address information */
576
577
578
579
580
581
582
583
584
585

	sprintf(st, "%d ", adr_typ);
	st += strlen(st);
	if (!len)
		*st++ = '-';
	else
		while (len--)
			*st++ = *p++;
	*st = '\0';
	return (retval);
Linus Torvalds's avatar
Linus Torvalds committed
586
587
588
} /* put_address */

/*************************************/
Andreas Mohr's avatar
Andreas Mohr committed
589
/* report a successful interrogation */
Linus Torvalds's avatar
Linus Torvalds committed
590
/*************************************/
591
static int interrogate_success(isdn_ctrl *ic, struct call_struc *cs)
592
593
{
	char *src = ic->parm.dss1_io.data;
594
595
596
597
598
599
600
601
602
	int restlen = ic->parm.dss1_io.datalen;
	int cnt = 1;
	u_char n, n1;
	char st[90], *p, *stp;

	if (restlen < 2) return (-100); /* frame too short */
	if (*src++ != 0x30) return (-101);
	if ((n = *src++) > 0x81) return (-102); /* invalid length field */
	restlen -= 2; /* remaining bytes */
603
604
	if (n == 0x80) {
		if (restlen < 2) return (-103);
605
606
		if ((*(src + restlen - 1)) || (*(src + restlen - 2))) return (-104);
		restlen -= 2;
607
608
609
610
611
612
613
	} else if (n == 0x81) {
		n = *src++;
		restlen--;
		if (n > restlen) return (-105);
		restlen = n;
	} else if (n > restlen)
		return (-106);
614
	else
615
		restlen = n; /* standard format */
616
617
618
619
	if (restlen < 3) return (-107); /* no procedure */
	if ((*src++ != 2) || (*src++ != 1) || (*src++ != 0x0B)) return (-108);
	restlen -= 3;
	if (restlen < 2) return (-109); /* list missing */
620
621
	if (*src == 0x31) {
		src++;
622
623
		if ((n = *src++) > 0x81) return (-110); /* invalid length field */
		restlen -= 2; /* remaining bytes */
624
625
		if (n == 0x80) {
			if (restlen < 2) return (-111);
626
627
			if ((*(src + restlen - 1)) || (*(src + restlen - 2))) return (-112);
			restlen -= 2;
628
629
630
631
632
633
634
		} else if (n == 0x81) {
			n = *src++;
			restlen--;
			if (n > restlen) return (-113);
			restlen = n;
		} else if (n > restlen)
			return (-114);
635
		else
636
			restlen = n; /* standard format */
637
638
	} /* result list header */

639
640
	while (restlen >= 2) {
		stp = st;
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
		sprintf(stp, "%d 0x%lx %d %s ", DIVERT_REPORT, ic->parm.dss1_io.ll_id,
			cnt++, divert_if.drv_to_name(ic->driver));
		stp += strlen(stp);
		if (*src++ != 0x30) return (-115); /* invalid enum */
		n = *src++;
		restlen -= 2;
		if (n > restlen) return (-116); /* enum length wrong */
		restlen -= n;
		p = src; /* one entry */
		src += n;
		if (!(n1 = put_address(stp, p, n & 0xFF))) continue;
		stp += strlen(stp);
		p += n1;
		n -= n1;
		if (n < 6) continue; /* no service and proc */
		if ((*p++ != 0x0A) || (*p++ != 1)) continue;
		sprintf(stp, " 0x%02x ", (*p++) & 0xFF);
		stp += strlen(stp);
		if ((*p++ != 0x0A) || (*p++ != 1)) continue;
		sprintf(stp, "%d ", (*p++) & 0xFF);
		stp += strlen(stp);
		n -= 6;
663
664
		if (n > 2) {
			if (*p++ != 0x30) continue;
665
666
667
668
669
670
671
672
673
674
			if (*p > (n - 2)) continue;
			n = *p++;
			if (!(n1 = put_address(stp, p, n & 0xFF))) continue;
			stp += strlen(stp);
		}
		sprintf(stp, "\n");
		put_info_buffer(st);
	} /* while restlen */
	if (restlen) return (-117);
	return (0);
Linus Torvalds's avatar
Linus Torvalds committed
675
676
677
678
679
} /* interrogate_success */

/*********************************************/
/* callback for protocol specific extensions */
/*********************************************/
680
static int prot_stat_callback(isdn_ctrl *ic)
681
682
{
	struct call_struc *cs, *cs1;
683
684
685
686
687
	int i;
	unsigned long flags;

	cs = divert_head; /* start of list */
	cs1 = NULL;
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
	while (cs) {
		if (ic->driver == cs->ics.driver) {
			switch (cs->ics.arg) {
			case DSS1_CMD_INVOKE:
				if ((cs->ics.parm.dss1_io.ll_id == ic->parm.dss1_io.ll_id) &&
				    (cs->ics.parm.dss1_io.hl_id == ic->parm.dss1_io.hl_id)) {
					switch (ic->arg) {
					case DSS1_STAT_INVOKE_ERR:
						sprintf(cs->info, "128 0x%lx 0x%x\n",
							ic->parm.dss1_io.ll_id,
							ic->parm.dss1_io.timeout);
						put_info_buffer(cs->info);
						break;

					case DSS1_STAT_INVOKE_RES:
						switch (cs->ics.parm.dss1_io.proc) {
						case  7:
						case  8:
							put_info_buffer(cs->info);
							break;
708

709
710
711
712
713
714
						case  11:
							i = interrogate_success(ic, cs);
							if (i)
								sprintf(cs->info, "%d 0x%lx %d\n", DIVERT_REPORT,
									ic->parm.dss1_io.ll_id, i);
							put_info_buffer(cs->info);
715
716
717
							break;

						default:
718
							printk(KERN_WARNING "dss1_divert: unknown proc %d\n", cs->ics.parm.dss1_io.proc);
719
720
							break;
						}
721
722
723
724
725
726
727
728
729
730
731
732

						break;

					default:
						printk(KERN_WARNING "dss1_divert unknown invoke answer %lx\n", ic->arg);
						break;
					}
					cs1 = cs; /* remember structure */
					cs = NULL;
					continue; /* abort search */
				} /* id found */
				break;
733
734
735
736
737
738
739
740
741
742
743
744
745

			case DSS1_CMD_INVOKE_ABORT:
				printk(KERN_WARNING "dss1_divert unhandled invoke abort\n");
				break;

			default:
				printk(KERN_WARNING "dss1_divert unknown cmd 0x%lx\n", cs->ics.arg);
				break;
			} /* switch ics.arg */
			cs = cs->next;
		} /* driver ok */
	}

746
747
	if (!cs1) {
		printk(KERN_WARNING "dss1_divert unhandled process\n");
748
749
750
		return (0);
	}

751
	if (cs1->ics.driver == -1) {
752
753
754
755
756
757
758
759
760
761
762
763
764
		spin_lock_irqsave(&divert_lock, flags);
		del_timer(&cs1->timer);
		if (cs1->prev)
			cs1->prev->next = cs1->next; /* forward link */
		else
			divert_head = cs1->next;
		if (cs1->next)
			cs1->next->prev = cs1->prev; /* back link */
		spin_unlock_irqrestore(&divert_lock, flags);
		kfree(cs1);
	}

	return (0);
Linus Torvalds's avatar
Linus Torvalds committed
765
766
767
768
769
770
} /* prot_stat_callback */


/***************************/
/* status callback from HL */
/***************************/
771
static int isdn_divert_stat_callback(isdn_ctrl *ic)
772
773
{
	struct call_struc *cs, *cs1;
774
775
776
777
778
	unsigned long flags;
	int retval;

	retval = -1;
	cs = divert_head; /* start of list */
779
780
781
782
783
784
785
786
787
	while (cs) {
		if ((ic->driver == cs->ics.driver) &&
		    (ic->arg == cs->ics.arg)) {
			switch (ic->command) {
			case ISDN_STAT_DHUP:
				sprintf(cs->info, "129 0x%lx\n", cs->divert_id);
				del_timer(&cs->timer);
				cs->ics.driver = -1;
				break;
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807

			case ISDN_STAT_CAUSE:
				sprintf(cs->info, "130 0x%lx %s\n", cs->divert_id, ic->parm.num);
				break;

			case ISDN_STAT_REDIR:
				sprintf(cs->info, "131 0x%lx\n", cs->divert_id);
				del_timer(&cs->timer);
				cs->ics.driver = -1;
				break;

			default:
				sprintf(cs->info, "999 0x%lx 0x%x\n", cs->divert_id, (int)(ic->command));
				break;
			}
			put_info_buffer(cs->info);
			retval = 0;
		}
		cs1 = cs;
		cs = cs->next;
808
		if (cs1->ics.driver == -1) {
809
810
811
812
813
814
815
816
817
818
819
820
821
			spin_lock_irqsave(&divert_lock, flags);
			if (cs1->prev)
				cs1->prev->next = cs1->next; /* forward link */
			else
				divert_head = cs1->next;
			if (cs1->next)
				cs1->next->prev = cs1->prev; /* back link */
			spin_unlock_irqrestore(&divert_lock, flags);
			kfree(cs1);
		}
	}
	return (retval); /* not found */
} /* isdn_divert_stat_callback */
Linus Torvalds's avatar
Linus Torvalds committed
822
823
824
825


/********************/
/* callback from ll */
826
/********************/
Linus Torvalds's avatar
Linus Torvalds committed
827
828
int ll_callback(isdn_ctrl *ic)
{
829
830
	switch (ic->command) {
	case ISDN_STAT_ICALL:
831
832
833
834
835
	case ISDN_STAT_ICALLW:
		return (isdn_divert_icall(ic));
		break;

	case ISDN_STAT_PROT:
836
837
		if ((ic->arg & 0xFF) == ISDN_PTYPE_EURO) {
			if (ic->arg != DSS1_STAT_INVOKE_BRD)
838
839
840
				return (prot_stat_callback(ic));
			else
				return (0); /* DSS1 invoke broadcast */
841
		} else
842
843
844
845
846
			return (-1); /* protocol not euro */

	default:
		return (isdn_divert_stat_callback(ic));
	}
Linus Torvalds's avatar
Linus Torvalds committed
847
} /* ll_callback */