/* $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)
 *
 * 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>
#include <linux/slab.h>
#include <linux/timer.h>
#include <linux/jiffies.h>

#include "isdn_divert.h"

/**********************************/
/* structure keeping calling info */
/**********************************/
struct call_struc {
        isdn_ctrl ics; /* delivered setup + driver parameters */
        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;
};


/********************************************/
/* structure keeping deflection table entry */
/********************************************/
struct deflect_struc {
        struct deflect_struc *next, *prev;
        divert_rule rule; /* used rule */
};


/*****************************************/
/* variables for main diversion services */
/*****************************************/
/* diversion/deflection processes */
static struct call_struc *divert_head = NULL; /* head of remembered entrys */
static ulong next_id = 1; /* next info id */
static struct deflect_struc *table_head = NULL;
static struct deflect_struc *table_tail = NULL;
static unsigned char extern_wait_max = 4; /* maximum wait in s for external process */

DEFINE_SPINLOCK(divert_lock);

/***************************/
/* timer callback function */
/***************************/
static void deflect_timer_expire(ulong arg)
{
        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);

        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;

        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 */
} /* deflect_timer_func */


/*****************************************/
/* handle call forwarding de/activations */
/* 0 = deact, 1 = act, 2 = interrogate   */
/*****************************************/
int cf_command(int drvid, int mode,
               u_char proc, char *msn,
               u_char service, char *fwd_nr, ulong *procid)
{
        unsigned long flags;
        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 */

        if (mode == 1) {
                if (!*fwd_nr) return (-EINVAL); /* destination missing */
                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 */
        if (msnlen > 1) {
                *p++ = msnlen; /* length */
                strcpy(p, msn);
                p += msnlen;
        } else
                *p++ = 0;

        *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 */
        init_timer(&cs->timer);
        cs->info[0] = '\0';
        cs->timer.function = deflect_timer_expire;
        cs->timer.data = (ulong) cs; /* pointer to own structure */
        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 */

        if (!retval) {
                cs->prev = NULL;
                spin_lock_irqsave(&divert_lock, flags);
                cs->next = divert_head;
                divert_head = cs;
                spin_unlock_irqrestore(&divert_lock, flags);
        } else
                kfree(cs);
        return (retval);
} /* cf_command */


/****************************************/
/* handle a external deflection command */
/****************************************/
int deflect_extern_action(u_char cmd, ulong callid, char *to_nr)
{
        struct call_struc *cs;
        isdn_ctrl ic;
        unsigned long flags;
        int i;

        if ((cmd & 0x7F) > 2) return (-EINVAL); /* invalid command */
        cs = divert_head; /* start of parameter list */
        while (cs) {
                if (cs->divert_id == callid) break; /* found */
                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 */
        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;

        case 1: /* alert */
                if (cs->akt_state == DEFLECT_ALERT) return (0);
                cmd &= 0x7F; /* never wait */
                del_timer(&cs->timer);
                ic.command = ISDN_CMD_ALERT;
                if ((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);
                } else
                        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;
                if ((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);
                } else
                        cs->akt_state = DEFLECT_ALERT;
                break;

        } /* switch */
        return (i);
} /* deflect_extern_action */

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

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

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

        spin_lock_irqsave(&divert_lock, flags);

        if (idx >= 0) {
                ds1 = table_head;
                while ((ds1) && (idx > 0))
                { idx--;
                        ds1 = ds1->next;
                }
                if (!ds1) idx = -1;
        }

        if (idx < 0) {
                ds->prev = table_tail; /* previous entry */
                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 */
        } else {
                ds->next = ds1; /* next entry */
                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);
} /* insertrule */

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

        if (idx < 0) {
                spin_lock_irqsave(&divert_lock, flags);
                ds = table_head;
                table_head = NULL;
                table_tail = NULL;
                spin_unlock_irqrestore(&divert_lock, flags);
                while (ds) {
                        ds1 = ds;
                        ds = ds->next;
                        kfree(ds1);
                }
                return (0);
        }

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

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

        if (!ds) {
                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);
} /* deleterule */

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

        if (idx < 0) return (NULL);
        while ((ds) && (idx >= 0)) {
                if (!(idx--)) {
                        return (&ds->rule);
                        break;
                }
                ds = ds->next;
        }
        return (NULL);
} /* getruleptr */

/*************************************************/
/* called from common module on an incoming call */
/*************************************************/
static int isdn_divert_icall(isdn_ctrl *ic)
{
        int retval = 0;
        unsigned long flags;
        struct call_struc *cs = NULL;
        struct deflect_struc *dv;
        char *p, *p1;
        u_char accept;

        /* first check the internal deflection table */
        for (dv = table_head; dv; dv = dv->next) {
                /* scan table */
                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;
                while (*p) {
                        /* complete compare */
                        if (*p == '-') {
                                accept = 1; /* call accepted */
                                break;
                        }
                        if (*p++ != *p1++)
                                break; /* not accepted */
                        if ((!*p) && (!*p1))
                                accept = 1;
                } /* complete compare */
                if (!accept) continue; /* not accepted */

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

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

                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 */
                        init_timer(&cs->timer);
                        cs->info[0] = '\0';
                        cs->timer.function = deflect_timer_expire;
                        cs->timer.data = (ulong) cs; /* pointer to own structure */

                        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);
                        else if (dv->rule.action == DEFLECT_PROCEED)
                                cs->timer.expires = jiffies + (HZ * extern_wait_max);
                        else
                                cs->timer.expires = 0;
                        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;
                        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");
                                        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;
                                } else
                                        retval = 1; /* alerting */
                        } else {
                                cs->deflect_dest[0] = '\0';
                                retval = 4; /* only proceed */
                        }
                        sprintf(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);
                        if ((dv->rule.action == DEFLECT_REPORT) ||
                            (dv->rule.action == DEFLECT_REJECT)) {
                                put_info_buffer(cs->info);
                                kfree(cs); /* remove */
                                return ((dv->rule.action == DEFLECT_REPORT) ? 0 : 2); /* nothing to do */
                        }
                        break;

                default:
                        return (0); /* ignore call */
                        break;
                } /* switch action */
                break;
        } /* scan_table */

        if (cs) {
                cs->prev = NULL;
                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);
        } else
                return (0);
} /* isdn_divert_icall */


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

        spin_lock_irqsave(&divert_lock, flags);
        cs = divert_head;
        divert_head = NULL;
        while (cs) {
                del_timer(&cs->timer);
                cs1 = cs;
                cs = cs->next;
                kfree(cs1);
        }
        spin_unlock_irqrestore(&divert_lock, flags);
} /* deleteprocs */

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

        if (len < 2) return (retval);
        if (*p == 0xA1) {
                retval = *(++p) + 2; /* total length */
                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++;
        } else if (*p == 0x80) {
                retval = *(++p) + 2; /* total length */
                if (retval > len) return (0);
                len = retval - 2;
                p++;
        } else
                return (0); /* invalid address information */

        sprintf(st, "%d ", adr_typ);
        st += strlen(st);
        if (!len)
                *st++ = '-';
        else
                while (len--)
                        *st++ = *p++;
        *st = '\0';
        return (retval);
} /* put_address */

/*************************************/
/* report a successful interrogation */
/*************************************/
static int interrogate_success(isdn_ctrl *ic, struct call_struc *cs)
{
        char *src = ic->parm.dss1_io.data;
        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 */
        if (n == 0x80) {
                if (restlen < 2) return (-103);
                if ((*(src + restlen - 1)) || (*(src + restlen - 2))) return (-104);
                restlen -= 2;
        } else if (n == 0x81) {
                n = *src++;
                restlen--;
                if (n > restlen) return (-105);
                restlen = n;
        } else if (n > restlen)
                return (-106);
        else
                restlen = n; /* standard format */
        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 */
        if (*src == 0x31) {
                src++;
                if ((n = *src++) > 0x81) return (-110); /* invalid length field */
                restlen -= 2; /* remaining bytes */
                if (n == 0x80) {
                        if (restlen < 2) return (-111);
                        if ((*(src + restlen - 1)) || (*(src + restlen - 2))) return (-112);
                        restlen -= 2;
                } else if (n == 0x81) {
                        n = *src++;
                        restlen--;
                        if (n > restlen) return (-113);
                        restlen = n;
                } else if (n > restlen)
                        return (-114);
                else
                        restlen = n; /* standard format */
        } /* result list header */

        while (restlen >= 2) {
                stp = st;
                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;
                if (n > 2) {
                        if (*p++ != 0x30) continue;
                        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);
} /* interrogate_success */

/*********************************************/
/* callback for protocol specific extensions */
/*********************************************/
static int prot_stat_callback(isdn_ctrl *ic)
{
        struct call_struc *cs, *cs1;
        int i;
        unsigned long flags;

        cs = divert_head; /* start of list */
        cs1 = NULL;
        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;

                                                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);
                                                        break;

                                                default:
                                                        printk(KERN_WARNING "dss1_divert: unknown proc %d\n", cs->ics.parm.dss1_io.proc);
                                                        break;
                                                }

                                                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;

                        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 */
        }

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

        if (cs1->ics.driver == -1) {
                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);
} /* prot_stat_callback */


/***************************/
/* status callback from HL */
/***************************/
static int isdn_divert_stat_callback(isdn_ctrl *ic)
{
        struct call_struc *cs, *cs1;
        unsigned long flags;
        int retval;

        retval = -1;
        cs = divert_head; /* start of list */
        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;

                        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;
                if (cs1->ics.driver == -1) {
                        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 */


/********************/
/* callback from ll */
/********************/
int ll_callback(isdn_ctrl *ic)
{
        switch (ic->command) {
        case ISDN_STAT_ICALL:
        case ISDN_STAT_ICALLW:
                return (isdn_divert_icall(ic));
                break;

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

        default:
                return (isdn_divert_stat_callback(ic));
        }
} /* ll_callback */