isdn/divert: fix readability damage (03f18285) · Commits · e / devices / android_kernel_teracube_2e

drivers/isdn/divert/divert_init.c

+17 −16

Original line number	Original line	Diff line number	Diff line
	@@ -22,8 +22,8 @@ MODULE_LICENSE("GPL");
	/****************************************/		/****************************************/
	/* structure containing interface to hl */		/* structure containing interface to hl */
	/****************************************/		/****************************************/
	isdn_divert_if divert_if =		isdn_divert_if divert_if = {
	{ DIVERT_IF_MAGIC, /* magic value */		DIVERT_IF_MAGIC, /* magic value */
	DIVERT_CMD_REG, /* register cmd */		DIVERT_CMD_REG, /* register cmd */
	ll_callback, /* callback routine from ll */		ll_callback, /* callback routine from ll */
	NULL, /* command still not specified */		NULL, /* command still not specified */
	@@ -36,14 +36,15 @@ isdn_divert_if divert_if =
	/* no cmd line parms */		/* no cmd line parms */
	/*************************/		/*************************/
	static int __init divert_init(void)		static int __init divert_init(void)
	{ int i;		{
			int i;

	if (divert_dev_init())		if (divert_dev_init()) {
	{ printk(KERN_WARNING "dss1_divert: cannot install device, not loaded\n");		printk(KERN_WARNING "dss1_divert: cannot install device, not loaded\n");
	return (-EIO);		return (-EIO);
	}		}
	if ((i = DIVERT_REG_NAME(&divert_if)) != DIVERT_NO_ERR)		if ((i = DIVERT_REG_NAME(&divert_if)) != DIVERT_NO_ERR) {
	{ divert_dev_deinit();		divert_dev_deinit();
	printk(KERN_WARNING "dss1_divert: error %d registering module, not loaded\n", i);		printk(KERN_WARNING "dss1_divert: error %d registering module, not loaded\n", i);
	return (-EIO);		return (-EIO);
	}		}
	@@ -61,13 +62,13 @@ static void __exit divert_exit(void)

	spin_lock_irqsave(&divert_lock, flags);		spin_lock_irqsave(&divert_lock, flags);
	divert_if.cmd = DIVERT_CMD_REL; /* release */		divert_if.cmd = DIVERT_CMD_REL; /* release */
	if ((i = DIVERT_REG_NAME(&divert_if)) != DIVERT_NO_ERR)		if ((i = DIVERT_REG_NAME(&divert_if)) != DIVERT_NO_ERR) {
	{ printk(KERN_WARNING "dss1_divert: error %d releasing module\n", i);		printk(KERN_WARNING "dss1_divert: error %d releasing module\n", i);
	spin_unlock_irqrestore(&divert_lock, flags);		spin_unlock_irqrestore(&divert_lock, flags);
	return;		return;
	}		}
	if (divert_dev_deinit())		if (divert_dev_deinit()) {
	{ printk(KERN_WARNING "dss1_divert: device busy, remove cancelled\n");		printk(KERN_WARNING "dss1_divert: device busy, remove cancelled\n");
	spin_unlock_irqrestore(&divert_lock, flags);		spin_unlock_irqrestore(&divert_lock, flags);
	return;		return;
	}		}

drivers/isdn/divert/isdn_divert.c

+206 −217

Original line number	Original line	Diff line number	Diff line
	@@ -19,8 +19,8 @@
	/**********************************/		/**********************************/
	/* structure keeping calling info */		/* structure keeping calling info */
	/**********************************/		/**********************************/
	struct call_struc		struct call_struc {
	{ isdn_ctrl ics; /* delivered setup + driver parameters */		isdn_ctrl ics; /* delivered setup + driver parameters */
	ulong divert_id; /* Id delivered to user */		ulong divert_id; /* Id delivered to user */
	unsigned char akt_state; /* actual state */		unsigned char akt_state; /* actual state */
	char deflect_dest[35]; /* deflection destination */		char deflect_dest[35]; /* deflection destination */
	@@ -34,8 +34,8 @@ struct call_struc
	/********************************************/		/********************************************/
	/* structure keeping deflection table entry */		/* structure keeping deflection table entry */
	/********************************************/		/********************************************/
	struct deflect_struc		struct deflect_struc {
	{ struct deflect_struc next, prev;		struct deflect_struc next, prev;
	divert_rule rule; /* used rule */		divert_rule rule; /* used rule */
	};		};

	@@ -64,8 +64,8 @@ static void deflect_timer_expire(ulong arg)
	del_timer(&cs->timer); /* delete active timer */		del_timer(&cs->timer); /* delete active timer */
	spin_unlock_irqrestore(&divert_lock, flags);		spin_unlock_irqrestore(&divert_lock, flags);

	switch (cs->akt_state)		switch (cs->akt_state) {
	{ case DEFLECT_PROCEED:		case DEFLECT_PROCEED:
	cs->ics.command = ISDN_CMD_HANGUP; /* cancel action */		cs->ics.command = ISDN_CMD_HANGUP; /* cancel action */
	divert_if.ll_cmd(&cs->ics);		divert_if.ll_cmd(&cs->ics);
	spin_lock_irqsave(&divert_lock, flags);		spin_lock_irqsave(&divert_lock, flags);
	@@ -111,7 +111,8 @@ static void deflect_timer_expire(ulong arg)
	int cf_command(int drvid, int mode,		int cf_command(int drvid, int mode,
	u_char proc, char *msn,		u_char proc, char *msn,
	u_char service, char fwd_nr, ulong procid)		u_char service, char fwd_nr, ulong procid)
	{ unsigned long flags;		{
			unsigned long flags;
	int retval, msnlen;		int retval, msnlen;
	int fwd_len;		int fwd_len;
	char p, ielenp, tmp[60];		char p, ielenp, tmp[60];
	@@ -130,8 +131,8 @@ int cf_command(int drvid, int mode,
	p++ = 1; / length */		p++ = 1; / length */
	p++ = service; / service to handle */		p++ = service; / service to handle */

	if (mode == 1)		if (mode == 1) {
	{ if (!fwd_nr) return (-EINVAL); / destination missing */		if (!fwd_nr) return (-EINVAL); / destination missing */
	if (strchr(fwd_nr, '.')) return (-EINVAL); /* subaddress not allowed */		if (strchr(fwd_nr, '.')) return (-EINVAL); /* subaddress not allowed */
	fwd_len = strlen(fwd_nr);		fwd_len = strlen(fwd_nr);
	p++ = 0x30; / number enumeration */		p++ = 0x30; / number enumeration */
	@@ -144,12 +145,12 @@ int cf_command(int drvid, int mode,

	msnlen = strlen(msn);		msnlen = strlen(msn);
	p++ = 0x80; / msn number */		p++ = 0x80; / msn number */
	if (msnlen > 1)		if (msnlen > 1) {
	{ p++ = msnlen; / length */		p++ = msnlen; / length */
	strcpy(p, msn);		strcpy(p, msn);
	p += msnlen;		p += msnlen;
	}		} else
	else *p++ = 0;		*p++ = 0;

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

	@@ -186,14 +187,13 @@ int cf_command(int drvid, int mode,

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

	if (!retval)		if (!retval) {
	{ cs->prev = NULL;		cs->prev = NULL;
	spin_lock_irqsave(&divert_lock, flags);		spin_lock_irqsave(&divert_lock, flags);
	cs->next = divert_head;		cs->next = divert_head;
	divert_head = cs;		divert_head = cs;
	spin_unlock_irqrestore(&divert_lock, flags);		spin_unlock_irqrestore(&divert_lock, flags);
	}		} else
	else
	kfree(cs);		kfree(cs);
	return (retval);		return (retval);
	} /* cf_command */		} /* cf_command */
	@@ -203,15 +203,16 @@ int cf_command(int drvid, int mode,
	/* handle a external deflection command */		/* handle a external deflection command */
	/****************************************/		/****************************************/
	int deflect_extern_action(u_char cmd, ulong callid, char *to_nr)		int deflect_extern_action(u_char cmd, ulong callid, char *to_nr)
	{ struct call_struc *cs;		{
			struct call_struc *cs;
	isdn_ctrl ic;		isdn_ctrl ic;
	unsigned long flags;		unsigned long flags;
	int i;		int i;

	if ((cmd & 0x7F) > 2) return (-EINVAL); /* invalid command */		if ((cmd & 0x7F) > 2) return (-EINVAL); /* invalid command */
	cs = divert_head; /* start of parameter list */		cs = divert_head; /* start of parameter list */
	while (cs)		while (cs) {
	{ if (cs->divert_id == callid) break; /* found */		if (cs->divert_id == callid) break; /* found */
	cs = cs->next;		cs = cs->next;
	} /* search entry */		} /* search entry */
	if (!cs) return (-EINVAL); /* invalid callid */		if (!cs) return (-EINVAL); /* invalid callid */
	@@ -220,8 +221,8 @@ int deflect_extern_action(u_char cmd, ulong callid, char *to_nr)
	ic.arg = cs->ics.arg;		ic.arg = cs->ics.arg;
	i = -EINVAL;		i = -EINVAL;
	if (cs->akt_state == DEFLECT_AUTODEL) return (i); /* no valid call */		if (cs->akt_state == DEFLECT_AUTODEL) return (i); /* no valid call */
	switch (cmd & 0x7F)		switch (cmd & 0x7F) {
	{ case 0: /* hangup */		case 0: /* hangup */
	del_timer(&cs->timer);		del_timer(&cs->timer);
	ic.command = ISDN_CMD_HANGUP;		ic.command = ISDN_CMD_HANGUP;
	i = divert_if.ll_cmd(&ic);		i = divert_if.ll_cmd(&ic);
	@@ -237,15 +238,13 @@ int deflect_extern_action(u_char cmd, ulong callid, char *to_nr)
	cmd &= 0x7F; /* never wait */		cmd &= 0x7F; /* never wait */
	del_timer(&cs->timer);		del_timer(&cs->timer);
	ic.command = ISDN_CMD_ALERT;		ic.command = ISDN_CMD_ALERT;
	if ((i = divert_if.ll_cmd(&ic)))		if ((i = divert_if.ll_cmd(&ic))) {
	{
	spin_lock_irqsave(&divert_lock, flags);		spin_lock_irqsave(&divert_lock, flags);
	cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */		cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
	cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);		cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
	add_timer(&cs->timer);		add_timer(&cs->timer);
	spin_unlock_irqrestore(&divert_lock, flags);		spin_unlock_irqrestore(&divert_lock, flags);
	}		} else
	else
	cs->akt_state = DEFLECT_ALERT;		cs->akt_state = DEFLECT_ALERT;
	break;		break;

	@@ -254,15 +253,13 @@ int deflect_extern_action(u_char cmd, ulong callid, char *to_nr)
	strlcpy(cs->ics.parm.setup.phone, to_nr, sizeof(cs->ics.parm.setup.phone));		strlcpy(cs->ics.parm.setup.phone, to_nr, sizeof(cs->ics.parm.setup.phone));
	strcpy(cs->ics.parm.setup.eazmsn, "Testtext manual");		strcpy(cs->ics.parm.setup.eazmsn, "Testtext manual");
	ic.command = ISDN_CMD_REDIR;		ic.command = ISDN_CMD_REDIR;
	if ((i = divert_if.ll_cmd(&ic)))		if ((i = divert_if.ll_cmd(&ic))) {
	{
	spin_lock_irqsave(&divert_lock, flags);		spin_lock_irqsave(&divert_lock, flags);
	cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */		cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
	cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);		cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
	add_timer(&cs->timer);		add_timer(&cs->timer);
	spin_unlock_irqrestore(&divert_lock, flags);		spin_unlock_irqrestore(&divert_lock, flags);
	}		} else
	else
	cs->akt_state = DEFLECT_ALERT;		cs->akt_state = DEFLECT_ALERT;
	break;		break;

	@@ -274,19 +271,19 @@ int deflect_extern_action(u_char cmd, ulong callid, char *to_nr)
	/* insert a new rule before idx */		/* insert a new rule before idx */
	/********************************/		/********************************/
	int insertrule(int idx, divert_rule *newrule)		int insertrule(int idx, divert_rule *newrule)
	{ struct deflect_struc ds, ds1 = NULL;		{
			struct deflect_struc ds, ds1 = NULL;
	unsigned long flags;		unsigned long flags;

	if (!(ds = kmalloc(sizeof(struct deflect_struc),		if (!(ds = kmalloc(sizeof(struct deflect_struc), GFP_KERNEL)))
	GFP_KERNEL)))
	return (-ENOMEM); /* no memory */		return (-ENOMEM); /* no memory */

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

	spin_lock_irqsave(&divert_lock, flags);		spin_lock_irqsave(&divert_lock, flags);

	if (idx >= 0)		if (idx >= 0) {
	{ ds1 = table_head;		ds1 = table_head;
	while ((ds1) && (idx > 0))		while ((ds1) && (idx > 0))
	{ idx--;		{ idx--;
	ds1 = ds1->next;		ds1 = ds1->next;
	@@ -294,17 +291,16 @@ int insertrule(int idx, divert_rule *newrule)
	if (!ds1) idx = -1;		if (!ds1) idx = -1;
	}		}

	if (idx < 0)		if (idx < 0) {
	{ ds->prev = table_tail; /* previous entry */		ds->prev = table_tail; /* previous entry */
	ds->next = NULL; /* end of chain */		ds->next = NULL; /* end of chain */
	if (ds->prev)		if (ds->prev)
	ds->prev->next = ds; /* last forward */		ds->prev->next = ds; /* last forward */
	else		else
	table_head = ds; /* is first entry */		table_head = ds; /* is first entry */
	table_tail = ds; /* end of queue */		table_tail = ds; /* end of queue */
	}		} else {
	else		ds->next = ds1; /* next entry */
	{ ds->next = ds1; /* next entry */
	ds->prev = ds1->prev; /* prev entry */		ds->prev = ds1->prev; /* prev entry */
	ds1->prev = ds; /* backward chain old element */		ds1->prev = ds; /* backward chain old element */
	if (!ds->prev)		if (!ds->prev)
	@@ -319,17 +315,18 @@ int insertrule(int idx, divert_rule *newrule)
	/* delete the rule at position idx */		/* delete the rule at position idx */
	/***********************************/		/***********************************/
	int deleterule(int idx)		int deleterule(int idx)
	{ struct deflect_struc ds, ds1;		{
			struct deflect_struc ds, ds1;
	unsigned long flags;		unsigned long flags;

	if (idx < 0)		if (idx < 0) {
	{ spin_lock_irqsave(&divert_lock, flags);		spin_lock_irqsave(&divert_lock, flags);
	ds = table_head;		ds = table_head;
	table_head = NULL;		table_head = NULL;
	table_tail = NULL;		table_tail = NULL;
	spin_unlock_irqrestore(&divert_lock, flags);		spin_unlock_irqrestore(&divert_lock, flags);
	while (ds)		while (ds) {
	{ ds1 = ds;		ds1 = ds;
	ds = ds->next;		ds = ds->next;
	kfree(ds1);		kfree(ds1);
	}		}
	@@ -339,13 +336,12 @@ int deleterule(int idx)
	spin_lock_irqsave(&divert_lock, flags);		spin_lock_irqsave(&divert_lock, flags);
	ds = table_head;		ds = table_head;

	while ((ds) && (idx > 0))		while ((ds) && (idx > 0)) {
	{ idx--;		idx--;
	ds = ds->next;		ds = ds->next;
	}		}

	if (!ds)		if (!ds) {
	{
	spin_unlock_irqrestore(&divert_lock, flags);		spin_unlock_irqrestore(&divert_lock, flags);
	return (-EINVAL);		return (-EINVAL);
	}		}
	@@ -369,12 +365,13 @@ int deleterule(int idx)
	/* get a pointer to a specific rule number */		/* get a pointer to a specific rule number */
	/*******************************************/		/*******************************************/
	divert_rule *getruleptr(int idx)		divert_rule *getruleptr(int idx)
	{ struct deflect_struc *ds = table_head;		{
			struct deflect_struc *ds = table_head;

	if (idx < 0) return (NULL);		if (idx < 0) return (NULL);
	while ((ds) && (idx >= 0))		while ((ds) && (idx >= 0)) {
	{ if (!(idx--))		if (!(idx--)) {
	{ return (&ds->rule);		return (&ds->rule);
	break;		break;
	}		}
	ds = ds->next;		ds = ds->next;
	@@ -386,7 +383,8 @@ divert_rule *getruleptr(int idx)
	/* called from common module on an incoming call */		/* called from common module on an incoming call */
	/*************************************************/		/*************************************************/
	static int isdn_divert_icall(isdn_ctrl *ic)		static int isdn_divert_icall(isdn_ctrl *ic)
	{ int retval = 0;		{
			int retval = 0;
	unsigned long flags;		unsigned long flags;
	struct call_struc *cs = NULL;		struct call_struc *cs = NULL;
	struct deflect_struc *dv;		struct deflect_struc *dv;
	@@ -394,8 +392,8 @@ static int isdn_divert_icall(isdn_ctrl *ic)
	u_char accept;		u_char accept;

	/* first check the internal deflection table */		/* first check the internal deflection table */
	for (dv = table_head; dv; dv = dv->next)		for (dv = table_head; dv; dv = dv->next) {
	{ /* scan table */		/* scan table */
	if (((dv->rule.callopt == 1) && (ic->command == ISDN_STAT_ICALLW)) \|\|		if (((dv->rule.callopt == 1) && (ic->command == ISDN_STAT_ICALLW)) \|\|
	((dv->rule.callopt == 2) && (ic->command == ISDN_STAT_ICALL)))		((dv->rule.callopt == 2) && (ic->command == ISDN_STAT_ICALL)))
	continue; /* call option check */		continue; /* call option check */
	@@ -409,10 +407,10 @@ static int isdn_divert_icall(isdn_ctrl *ic)
	p = dv->rule.my_msn;		p = dv->rule.my_msn;
	p1 = ic->parm.setup.eazmsn;		p1 = ic->parm.setup.eazmsn;
	accept = 0;		accept = 0;
	while (*p)		while (*p) {
	{ /* complete compare */		/* complete compare */
	if (*p == '-')		if (*p == '-') {
	{ accept = 1; /* call accepted */		accept = 1; /* call accepted */
	break;		break;
	}		}
	if (p++ != p1++)		if (p++ != p1++)
	@@ -422,14 +420,15 @@ static int isdn_divert_icall(isdn_ctrl *ic)
	} /* complete compare */		} /* complete compare */
	if (!accept) continue; /* not accepted */		if (!accept) continue; /* not accepted */

	if ((strcmp(dv->rule.caller, "0")) \|\| (ic->parm.setup.phone[0]))		if ((strcmp(dv->rule.caller, "0")) \|\|
	{ p = dv->rule.caller;		(ic->parm.setup.phone[0])) {
			p = dv->rule.caller;
	p1 = ic->parm.setup.phone;		p1 = ic->parm.setup.phone;
	accept = 0;		accept = 0;
	while (*p)		while (*p) {
	{ /* complete compare */		/* complete compare */
	if (*p == '-')		if (*p == '-') {
	{ accept = 1; /* call accepted */		accept = 1; /* call accepted */
	break;		break;
	}		}
	if (p++ != p1++)		if (p++ != p1++)
	@@ -440,8 +439,8 @@ static int isdn_divert_icall(isdn_ctrl *ic)
	if (!accept) continue; /* not accepted */		if (!accept) continue; /* not accepted */
	}		}

	switch (dv->rule.action)		switch (dv->rule.action) {
	{ case DEFLECT_IGNORE:		case DEFLECT_IGNORE:
	return (0);		return (0);
	break;		break;

	@@ -465,8 +464,7 @@ static int isdn_divert_icall(isdn_ctrl *ic)
	cs->ics.parm.setup.screen = dv->rule.screen;		cs->ics.parm.setup.screen = dv->rule.screen;
	if (dv->rule.waittime)		if (dv->rule.waittime)
	cs->timer.expires = jiffies + (HZ * dv->rule.waittime);		cs->timer.expires = jiffies + (HZ * dv->rule.waittime);
	else		else if (dv->rule.action == DEFLECT_PROCEED)
	if (dv->rule.action == DEFLECT_PROCEED)
	cs->timer.expires = jiffies + (HZ * extern_wait_max);		cs->timer.expires = jiffies + (HZ * extern_wait_max);
	else		else
	cs->timer.expires = 0;		cs->timer.expires = 0;
	@@ -475,21 +473,20 @@ static int isdn_divert_icall(isdn_ctrl *ic)
	cs->divert_id = next_id++; /* new sequence number */		cs->divert_id = next_id++; /* new sequence number */
	spin_unlock_irqrestore(&divert_lock, flags);		spin_unlock_irqrestore(&divert_lock, flags);
	cs->prev = NULL;		cs->prev = NULL;
	if (cs->akt_state == DEFLECT_ALERT)		if (cs->akt_state == DEFLECT_ALERT) {
	{ strcpy(cs->deflect_dest, dv->rule.to_nr);		strcpy(cs->deflect_dest, dv->rule.to_nr);
	if (!cs->timer.expires)		if (!cs->timer.expires) {
	{ strcpy(ic->parm.setup.eazmsn, "Testtext direct");		strcpy(ic->parm.setup.eazmsn,
			"Testtext direct");
	ic->parm.setup.screen = dv->rule.screen;		ic->parm.setup.screen = dv->rule.screen;
	strlcpy(ic->parm.setup.phone, dv->rule.to_nr, sizeof(ic->parm.setup.phone));		strlcpy(ic->parm.setup.phone, dv->rule.to_nr, sizeof(ic->parm.setup.phone));
	cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */		cs->akt_state = DEFLECT_AUTODEL; /* delete after timeout */
	cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);		cs->timer.expires = jiffies + (HZ * AUTODEL_TIME);
	retval = 5;		retval = 5;
	}		} else
	else
	retval = 1; /* alerting */		retval = 1; /* alerting */
	}		} else {
	else		cs->deflect_dest[0] = '\0';
	{ cs->deflect_dest[0] = '\0';
	retval = 4; /* only proceed */		retval = 4; /* only proceed */
	}		}
	sprintf(cs->info, "%d 0x%lx %s %s %s %s 0x%x 0x%x %d %d %s\n",		sprintf(cs->info, "%d 0x%lx %s %s %s %s 0x%x 0x%x %d %d %s\n",
	@@ -505,8 +502,8 @@ static int isdn_divert_icall(isdn_ctrl *ic)
	dv->rule.waittime,		dv->rule.waittime,
	cs->deflect_dest);		cs->deflect_dest);
	if ((dv->rule.action == DEFLECT_REPORT) \|\|		if ((dv->rule.action == DEFLECT_REPORT) \|\|
	(dv->rule.action == DEFLECT_REJECT))		(dv->rule.action == DEFLECT_REJECT)) {
	{ put_info_buffer(cs->info);		put_info_buffer(cs->info);
	kfree(cs); /* remove */		kfree(cs); /* remove */
	return ((dv->rule.action == DEFLECT_REPORT) ? 0 : 2); /* nothing to do */		return ((dv->rule.action == DEFLECT_REPORT) ? 0 : 2); /* nothing to do */
	}		}
	@@ -519,8 +516,8 @@ static int isdn_divert_icall(isdn_ctrl *ic)
	break;		break;
	} /* scan_table */		} /* scan_table */

	if (cs)		if (cs) {
	{ cs->prev = NULL;		cs->prev = NULL;
	spin_lock_irqsave(&divert_lock, flags);		spin_lock_irqsave(&divert_lock, flags);
	cs->next = divert_head;		cs->next = divert_head;
	divert_head = cs;		divert_head = cs;
	@@ -529,21 +526,21 @@ static int isdn_divert_icall(isdn_ctrl *ic)

	put_info_buffer(cs->info);		put_info_buffer(cs->info);
	return (retval);		return (retval);
	}		} else
	else
	return (0);		return (0);
	} /* isdn_divert_icall */		} /* isdn_divert_icall */


	void deleteprocs(void)		void deleteprocs(void)
	{ struct call_struc cs, cs1;		{
			struct call_struc cs, cs1;
	unsigned long flags;		unsigned long flags;

	spin_lock_irqsave(&divert_lock, flags);		spin_lock_irqsave(&divert_lock, flags);
	cs = divert_head;		cs = divert_head;
	divert_head = NULL;		divert_head = NULL;
	while (cs)		while (cs) {
	{ del_timer(&cs->timer);		del_timer(&cs->timer);
	cs1 = cs;		cs1 = cs;
	cs = cs->next;		cs = cs->next;
	kfree(cs1);		kfree(cs1);
	@@ -555,12 +552,13 @@ void deleteprocs(void)
	/* put a address including address type into buffer */		/* put a address including address type into buffer */
	/****************************************************/		/****************************************************/
	static int put_address(char st, u_char p, int len)		static int put_address(char st, u_char p, int len)
	{ u_char retval = 0;		{
			u_char retval = 0;
	u_char adr_typ = 0; /* network standard */		u_char adr_typ = 0; /* network standard */

	if (len < 2) return (retval);		if (len < 2) return (retval);
	if (*p == 0xA1)		if (*p == 0xA1) {
	{ retval = (++p) + 2; / total length */		retval = (++p) + 2; / total length */
	if (retval > len) return (0); /* too short */		if (retval > len) return (0); /* too short */
	len = retval - 2; /* remaining length */		len = retval - 2; /* remaining length */
	if (len < 3) return (0);		if (len < 3) return (0);
	@@ -572,15 +570,12 @@ static int put_address(char st, u_char p, int len)
	if (*p++ != 0x12) return (0);		if (*p++ != 0x12) return (0);
	if (p > len) return (0); / check number length */		if (p > len) return (0); / check number length */
	len = *p++;		len = *p++;
	}		} else if (*p == 0x80) {
	else		retval = (++p) + 2; / total length */
	if (*p == 0x80)
	{ retval = (++p) + 2; / total length */
	if (retval > len) return (0);		if (retval > len) return (0);
	len = retval - 2;		len = retval - 2;
	p++;		p++;
	}		} else
	else
	return (0); /* invalid address information */		return (0); /* invalid address information */

	sprintf(st, "%d ", adr_typ);		sprintf(st, "%d ", adr_typ);
	@@ -598,7 +593,8 @@ static int put_address(char st, u_char p, int len)
	/* report a successful interrogation */		/* report a successful interrogation */
	/*************************************/		/*************************************/
	static int interrogate_success(isdn_ctrl ic, struct call_struc cs)		static int interrogate_success(isdn_ctrl ic, struct call_struc cs)
	{ char *src = ic->parm.dss1_io.data;		{
			char *src = ic->parm.dss1_io.data;
	int restlen = ic->parm.dss1_io.datalen;		int restlen = ic->parm.dss1_io.datalen;
	int cnt = 1;		int cnt = 1;
	u_char n, n1;		u_char n, n1;
	@@ -608,50 +604,44 @@ static int interrogate_success(isdn_ctrl ic, struct call_struc cs)
	if (*src++ != 0x30) return (-101);		if (*src++ != 0x30) return (-101);
	if ((n = src++) > 0x81) return (-102); / invalid length field */		if ((n = src++) > 0x81) return (-102); / invalid length field */
	restlen -= 2; /* remaining bytes */		restlen -= 2; /* remaining bytes */
	if (n == 0x80)		if (n == 0x80) {
	{ if (restlen < 2) return (-103);		if (restlen < 2) return (-103);
	if (((src + restlen - 1)) \|\| ((src + restlen - 2))) return (-104);		if (((src + restlen - 1)) \|\| ((src + restlen - 2))) return (-104);
	restlen -= 2;		restlen -= 2;
	}		} else if (n == 0x81) {
	else		n = *src++;
	if (n == 0x81)
	{ n = *src++;
	restlen--;		restlen--;
	if (n > restlen) return (-105);		if (n > restlen) return (-105);
	restlen = n;		restlen = n;
	}		} else if (n > restlen)
	else		return (-106);
	if (n > restlen) return (-106);
	else		else
	restlen = n; /* standard format */		restlen = n; /* standard format */
	if (restlen < 3) return (-107); /* no procedure */		if (restlen < 3) return (-107); /* no procedure */
	if ((src++ != 2) \|\| (src++ != 1) \|\| (*src++ != 0x0B)) return (-108);		if ((src++ != 2) \|\| (src++ != 1) \|\| (*src++ != 0x0B)) return (-108);
	restlen -= 3;		restlen -= 3;
	if (restlen < 2) return (-109); /* list missing */		if (restlen < 2) return (-109); /* list missing */
	if (*src == 0x31)		if (*src == 0x31) {
	{ src++;		src++;
	if ((n = src++) > 0x81) return (-110); / invalid length field */		if ((n = src++) > 0x81) return (-110); / invalid length field */
	restlen -= 2; /* remaining bytes */		restlen -= 2; /* remaining bytes */
	if (n == 0x80)		if (n == 0x80) {
	{ if (restlen < 2) return (-111);		if (restlen < 2) return (-111);
	if (((src + restlen - 1)) \|\| ((src + restlen - 2))) return (-112);		if (((src + restlen - 1)) \|\| ((src + restlen - 2))) return (-112);
	restlen -= 2;		restlen -= 2;
	}		} else if (n == 0x81) {
	else		n = *src++;
	if (n == 0x81)
	{ n = *src++;
	restlen--;		restlen--;
	if (n > restlen) return (-113);		if (n > restlen) return (-113);
	restlen = n;		restlen = n;
	}		} else if (n > restlen)
	else		return (-114);
	if (n > restlen) return (-114);
	else		else
	restlen = n; /* standard format */		restlen = n; /* standard format */
	} /* result list header */		} /* result list header */

	while (restlen >= 2)		while (restlen >= 2) {
	{ stp = st;		stp = st;
	sprintf(stp, "%d 0x%lx %d %s ", DIVERT_REPORT, ic->parm.dss1_io.ll_id,		sprintf(stp, "%d 0x%lx %d %s ", DIVERT_REPORT, ic->parm.dss1_io.ll_id,
	cnt++, divert_if.drv_to_name(ic->driver));		cnt++, divert_if.drv_to_name(ic->driver));
	stp += strlen(stp);		stp += strlen(stp);
	@@ -674,8 +664,8 @@ static int interrogate_success(isdn_ctrl ic, struct call_struc cs)
	sprintf(stp, "%d ", (*p++) & 0xFF);		sprintf(stp, "%d ", (*p++) & 0xFF);
	stp += strlen(stp);		stp += strlen(stp);
	n -= 6;		n -= 6;
	if (n > 2)		if (n > 2) {
	{ if (*p++ != 0x30) continue;		if (*p++ != 0x30) continue;
	if (*p > (n - 2)) continue;		if (*p > (n - 2)) continue;
	n = *p++;		n = *p++;
	if (!(n1 = put_address(stp, p, n & 0xFF))) continue;		if (!(n1 = put_address(stp, p, n & 0xFF))) continue;
	@@ -692,20 +682,21 @@ static int interrogate_success(isdn_ctrl ic, struct call_struc cs)
	/* callback for protocol specific extensions */		/* callback for protocol specific extensions */
	/*********************************************/		/*********************************************/
	static int prot_stat_callback(isdn_ctrl *ic)		static int prot_stat_callback(isdn_ctrl *ic)
	{ struct call_struc cs, cs1;		{
			struct call_struc cs, cs1;
	int i;		int i;
	unsigned long flags;		unsigned long flags;

	cs = divert_head; /* start of list */		cs = divert_head; /* start of list */
	cs1 = NULL;		cs1 = NULL;
	while (cs)		while (cs) {
	{ if (ic->driver == cs->ics.driver)		if (ic->driver == cs->ics.driver) {
	{ switch (cs->ics.arg)		switch (cs->ics.arg) {
	{ case DSS1_CMD_INVOKE:		case DSS1_CMD_INVOKE:
	if ((cs->ics.parm.dss1_io.ll_id == ic->parm.dss1_io.ll_id) &&		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))		(cs->ics.parm.dss1_io.hl_id == ic->parm.dss1_io.hl_id)) {
	{ switch (ic->arg)		switch (ic->arg) {
	{ case DSS1_STAT_INVOKE_ERR:		case DSS1_STAT_INVOKE_ERR:
	sprintf(cs->info, "128 0x%lx 0x%x\n",		sprintf(cs->info, "128 0x%lx 0x%x\n",
	ic->parm.dss1_io.ll_id,		ic->parm.dss1_io.ll_id,
	ic->parm.dss1_io.timeout);		ic->parm.dss1_io.timeout);
	@@ -713,8 +704,8 @@ static int prot_stat_callback(isdn_ctrl *ic)
	break;		break;

	case DSS1_STAT_INVOKE_RES:		case DSS1_STAT_INVOKE_RES:
	switch (cs->ics.parm.dss1_io.proc)		switch (cs->ics.parm.dss1_io.proc) {
	{ case 7:		case 7:
	case 8:		case 8:
	put_info_buffer(cs->info);		put_info_buffer(cs->info);
	break;		break;
	@@ -732,7 +723,6 @@ static int prot_stat_callback(isdn_ctrl *ic)
	break;		break;
	}		}


	break;		break;

	default:		default:
	@@ -757,13 +747,12 @@ static int prot_stat_callback(isdn_ctrl *ic)
	} /* driver ok */		} /* driver ok */
	}		}

	if (!cs1)		if (!cs1) {
	{ printk(KERN_WARNING "dss1_divert unhandled process\n");		printk(KERN_WARNING "dss1_divert unhandled process\n");
	return (0);		return (0);
	}		}

	if (cs1->ics.driver == -1)		if (cs1->ics.driver == -1) {
	{
	spin_lock_irqsave(&divert_lock, flags);		spin_lock_irqsave(&divert_lock, flags);
	del_timer(&cs1->timer);		del_timer(&cs1->timer);
	if (cs1->prev)		if (cs1->prev)
	@@ -784,16 +773,18 @@ static int prot_stat_callback(isdn_ctrl *ic)
	/* status callback from HL */		/* status callback from HL */
	/***************************/		/***************************/
	static int isdn_divert_stat_callback(isdn_ctrl *ic)		static int isdn_divert_stat_callback(isdn_ctrl *ic)
	{ struct call_struc cs, cs1;		{
			struct call_struc cs, cs1;
	unsigned long flags;		unsigned long flags;
	int retval;		int retval;

	retval = -1;		retval = -1;
	cs = divert_head; /* start of list */		cs = divert_head; /* start of list */
	while (cs)		while (cs) {
	{ if ((ic->driver == cs->ics.driver) && (ic->arg == cs->ics.arg))		if ((ic->driver == cs->ics.driver) &&
	{ switch (ic->command)		(ic->arg == cs->ics.arg)) {
	{ case ISDN_STAT_DHUP:		switch (ic->command) {
			case ISDN_STAT_DHUP:
	sprintf(cs->info, "129 0x%lx\n", cs->divert_id);		sprintf(cs->info, "129 0x%lx\n", cs->divert_id);
	del_timer(&cs->timer);		del_timer(&cs->timer);
	cs->ics.driver = -1;		cs->ics.driver = -1;
	@@ -818,8 +809,7 @@ static int isdn_divert_stat_callback(isdn_ctrl *ic)
	}		}
	cs1 = cs;		cs1 = cs;
	cs = cs->next;		cs = cs->next;
	if (cs1->ics.driver == -1)		if (cs1->ics.driver == -1) {
	{
	spin_lock_irqsave(&divert_lock, flags);		spin_lock_irqsave(&divert_lock, flags);
	if (cs1->prev)		if (cs1->prev)
	cs1->prev->next = cs1->next; /* forward link */		cs1->prev->next = cs1->next; /* forward link */
	@@ -840,20 +830,19 @@ static int isdn_divert_stat_callback(isdn_ctrl *ic)
	/********************/		/********************/
	int ll_callback(isdn_ctrl *ic)		int ll_callback(isdn_ctrl *ic)
	{		{
	switch (ic->command)		switch (ic->command) {
	{ case ISDN_STAT_ICALL:		case ISDN_STAT_ICALL:
	case ISDN_STAT_ICALLW:		case ISDN_STAT_ICALLW:
	return (isdn_divert_icall(ic));		return (isdn_divert_icall(ic));
	break;		break;

	case ISDN_STAT_PROT:		case ISDN_STAT_PROT:
	if ((ic->arg & 0xFF) == ISDN_PTYPE_EURO)		if ((ic->arg & 0xFF) == ISDN_PTYPE_EURO) {
	{ if (ic->arg != DSS1_STAT_INVOKE_BRD)		if (ic->arg != DSS1_STAT_INVOKE_BRD)
	return (prot_stat_callback(ic));		return (prot_stat_callback(ic));
	else		else
	return (0); /* DSS1 invoke broadcast */		return (0); /* DSS1 invoke broadcast */
	}		} else
	else
	return (-1); /* protocol not euro */		return (-1); /* protocol not euro */

	default:		default:

drivers/isdn/divert/isdn_divert.h

+14 −14

Original line number	Original line	Diff line number	Diff line
	@@ -43,8 +43,8 @@

	#define DEFLECT_ALL_IDS 0xFFFFFFFF /* all drivers selected */		#define DEFLECT_ALL_IDS 0xFFFFFFFF /* all drivers selected */

	typedef struct		typedef struct {
	{ ulong drvid; /* driver ids, bit mapped */		ulong drvid; /* driver ids, bit mapped */
	char my_msn[35]; /* desired msn, subaddr allowed */		char my_msn[35]; /* desired msn, subaddr allowed */
	char caller[35]; /* caller id, partial string with * + subaddr allowed */		char caller[35]; /* caller id, partial string with * + subaddr allowed */
	char to_nr[35]; /* deflected to number incl. subaddress */		char to_nr[35]; /* deflected to number incl. subaddress */
	@@ -65,18 +65,18 @@ typedef struct
	u_char waittime; /* maximum wait time for proceeding */		u_char waittime; /* maximum wait time for proceeding */
	} divert_rule;		} divert_rule;

	typedef union		typedef union {
	{ int drv_version; /* return of driver version */		int drv_version; /* return of driver version */
	struct		struct {
	{ int drvid; /* id of driver */		int drvid; /* id of driver */
	char drvnam[30]; /* name of driver */		char drvnam[30]; /* name of driver */
	} getid;		} getid;
	struct		struct {
	{ int ruleidx; /* index of rule */		int ruleidx; /* index of rule */
	divert_rule rule; /* rule parms */		divert_rule rule; /* rule parms */
	} getsetrule;		} getsetrule;
	struct		struct {
	{ u_char subcmd; /* 0 = hangup/reject,		u_char subcmd; /* 0 = hangup/reject,
	1 = alert,		1 = alert,
	2 = deflect */		2 = deflect */
	ulong callid; /* id of call delivered by ascii output */		ulong callid; /* id of call delivered by ascii output */
	@@ -84,8 +84,8 @@ typedef union
	else uus1 string (maxlen 31),		else uus1 string (maxlen 31),
	data from rule used if empty */		data from rule used if empty */
	} fwd_ctrl;		} fwd_ctrl;
	struct		struct {
	{ int drvid; /* id of driver */		int drvid; /* id of driver */
	u_char cfproc; /* cfu = 0, cfb = 1, cfnr = 2 */		u_char cfproc; /* cfu = 0, cfb = 1, cfnr = 2 */
	ulong procid; /* process id returned when no error */		ulong procid; /* process id returned when no error */
	u_char service; /* basically coded service, 0 = all */		u_char service; /* basically coded service, 0 = all */
	@@ -104,8 +104,8 @@ typedef union
	/**************************************************/		/**************************************************/
	/* structure keeping ascii info for device output */		/* structure keeping ascii info for device output */
	/**************************************************/		/**************************************************/
	struct divert_info		struct divert_info {
	{ struct divert_info *next;		struct divert_info *next;
	ulong usage_cnt; /* number of files still to work */		ulong usage_cnt; /* number of files still to work */
	char info_start[2]; /* info string start */		char info_start[2]; /* info string start */
	};		};