Subversion Repositories or1k_old

/*
 * Copyright (C) 1996 Universidade de Lisboa
 * 
 * Written by Pedro Roque Marques (roque@di.fc.ul.pt)
 *
 * This software may be used and distributed according to the terms of 
 * the GNU Public License, incorporated herein by reference.
 */
 
/*        
 *        CAPI encoder/decoder for
 *        Portugal Telecom CAPI 2.0
 *
 *        Not compatible with the AVM Gmbh. CAPI 2.0
 */
 
/*
 *        Documentation:
 *        - "Common ISDN API - Perfil Português - Versão 2.1",
 *           Telecom Portugal, Fev 1992.
 *        - "Common ISDN API - Especificação de protocolos para 
 *           acesso aos canais B", Inesc, Jan 1994.
 */
 
/*
 *        TODO: better decoding of Information Elements
 *              for debug purposes mainly
 *              encode our number in CallerPN and ConnectedPN
 */
 
#define __NO_VERSION__
 
#include <linux/module.h>
 
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/kernel.h>
 
#include <linux/types.h>
#include <linux/malloc.h>
#include <linux/mm.h>
 
#include <linux/tqueue.h>
#include <linux/skbuff.h>
 
#include <asm/io.h>
#include <asm/string.h>
 
#include <linux/isdnif.h>
 
#include "pcbit.h"
#include "edss1.h"
#include "capi.h"
 
 
/*
 *  Encoding of CAPI messages
 *
 */
 
int capi_conn_req(const char * calledPN, struct sk_buff **skb, int proto)
{
        ushort len;
 
        /*
         * length
         *   AppInfoMask - 2
         *   BC0         - 3
         *   BC1         - 1
         *   Chan        - 2
         *   Keypad      - 1
         *   CPN         - 1
         *   CPSA        - 1
         *   CalledPN    - 2 + strlen
         *   CalledPSA   - 1
         *   rest...     - 4
         *   ----------------
         *   Total        18 + strlen
         */
 
        len = 18 + strlen(calledPN);
 
	if (proto == ISDN_PROTO_L2_TRANS)
		len++;
 
	if ((*skb = dev_alloc_skb(len)) == NULL) {
 
	        printk(KERN_WARNING "capi_conn_req: alloc_skb failed\n");
		return -1;
	}
 
        /* InfoElmMask */
        *((ushort*) skb_put(*skb, 2)) = AppInfoMask; 
 
	if (proto == ISDN_PROTO_L2_TRANS)
	{
		/* Bearer Capability - Mandatory*/
		*(skb_put(*skb, 1)) = 3;        /* BC0.Length		*/
		*(skb_put(*skb, 1)) = 0x80;     /* Speech		*/
		*(skb_put(*skb, 1)) = 0x10;     /* Circuit Mode		*/
		*(skb_put(*skb, 1)) = 0x23;     /* A-law		*/
	}
	else
	{
		/* Bearer Capability - Mandatory*/
		*(skb_put(*skb, 1)) = 2;        /* BC0.Length		*/
		*(skb_put(*skb, 1)) = 0x88;     /* Digital Information	*/
		*(skb_put(*skb, 1)) = 0x90;     /* BC0.Octect4		*/
	}
 
        /* Bearer Capability - Optional*/
        *(skb_put(*skb, 1)) = 0;        /* BC1.Length = 0                    */
 
        *(skb_put(*skb, 1)) = 1;        /* ChannelID.Length = 1              */
        *(skb_put(*skb, 1)) = 0x83;     /* Basic Interface - Any Channel     */
 
        *(skb_put(*skb, 1)) = 0;        /* Keypad.Length = 0                 */
 
 
        *(skb_put(*skb, 1)) = 0;        /* CallingPN.Length = 0              */
        *(skb_put(*skb, 1)) = 0;        /* CallingPSA.Length = 0             */
 
        /* Called Party Number */
        *(skb_put(*skb, 1)) = strlen(calledPN) + 1;
        *(skb_put(*skb, 1)) = 0x81;
        memcpy(skb_put(*skb, strlen(calledPN)), calledPN, strlen(calledPN));
 
        /* '#' */
 
        *(skb_put(*skb, 1)) = 0;       /* CalledPSA.Length = 0     */
 
        /* LLC.Length  = 0; */
        /* HLC0.Length = 0; */
        /* HLC1.Length = 0; */ 
        /* UTUS.Length = 0; */
        memset(skb_put(*skb, 4), 0, 4);
 
        return len;
}
 
int capi_conn_resp(struct pcbit_chan* chan, struct sk_buff **skb)
{
 
	if ((*skb = dev_alloc_skb(5)) == NULL) {
 
		printk(KERN_WARNING "capi_conn_resp: alloc_skb failed\n");
		return -1;
	}
 
        SET_SKB_FREE((*skb));
 
 
        *((ushort*) skb_put(*skb, 2) ) = chan->callref;  
        *(skb_put(*skb, 1)) = 0x01;  /* ACCEPT_CALL */
        *(skb_put(*skb, 1)) = 0;
        *(skb_put(*skb, 1)) = 0;
 
        return 5;
}
 
int capi_conn_active_req(struct pcbit_chan* chan, struct sk_buff **skb)
{
        /*
         * 8 bytes
         */
 
	if ((*skb = dev_alloc_skb(8)) == NULL) {
 
		printk(KERN_WARNING "capi_conn_active_req: alloc_skb failed\n");
		return -1;
	}
 
        SET_SKB_FREE((*skb));
 
        *((ushort*) skb_put(*skb, 2) ) = chan->callref;  
 
#ifdef DEBUG
	printk(KERN_DEBUG "Call Reference: %04x\n", chan->callref); 
#endif
 
        *(skb_put(*skb, 1)) = 0;       /*  BC.Length = 0;          */
        *(skb_put(*skb, 1)) = 0;       /*  ConnectedPN.Length = 0  */
        *(skb_put(*skb, 1)) = 0;       /*  PSA.Length              */
        *(skb_put(*skb, 1)) = 0;       /*  LLC.Length = 0;         */
        *(skb_put(*skb, 1)) = 0;       /*  HLC.Length = 0;         */
        *(skb_put(*skb, 1)) = 0;       /*  UTUS.Length = 0;        */
 
	return 8;
}
 
int capi_conn_active_resp(struct pcbit_chan* chan, struct sk_buff **skb)
{
        /*
         * 2 bytes
         */
 
	if ((*skb = dev_alloc_skb(2)) == NULL) {
 
		printk(KERN_WARNING "capi_conn_active_resp: alloc_skb failed\n");
		return -1;
	}
 
        SET_SKB_FREE((*skb));
 
        *((ushort*) skb_put(*skb, 2) ) = chan->callref;  
 
        return 2;
}
 
 
int capi_select_proto_req(struct pcbit_chan *chan, struct sk_buff **skb, 
                          int outgoing)
{
 
        /*
         * 18 bytes
         */
 
	if ((*skb = dev_alloc_skb(18)) == NULL) {
 
		printk(KERN_WARNING "capi_select_proto_req: alloc_skb failed\n");
		return -1;
	}
 
        SET_SKB_FREE((*skb));
 
        *((ushort*) skb_put(*skb, 2) ) = chan->callref;  
 
        /* Layer2 protocol */
 
        switch (chan->proto) {
        case ISDN_PROTO_L2_X75I: 
                *(skb_put(*skb, 1)) = 0x05;            /* LAPB */
                break;
        case ISDN_PROTO_L2_HDLC:
                *(skb_put(*skb, 1)) = 0x02;
                break;
	case ISDN_PROTO_L2_TRANS:
		/* 
		 *	Voice (a-law)
		 */
		*(skb_put(*skb, 1)) = 0x06;
		break;
        default:
#ifdef DEBUG 
                printk(KERN_DEBUG "Transparent\n");
#endif
                *(skb_put(*skb, 1)) = 0x03;
                break;
        }
 
        *(skb_put(*skb, 1)) = (outgoing ? 0x02 : 0x42);    /* Don't ask */
        *(skb_put(*skb, 1)) = 0x00;
 
        *((ushort *) skb_put(*skb, 2)) = MRU;
 
 
        *(skb_put(*skb, 1)) = 0x08;           /* Modulo */
        *(skb_put(*skb, 1)) = 0x07;           /* Max Window */
 
        *(skb_put(*skb, 1)) = 0x01;           /* No Layer3 Protocol */
 
        /*
         * 2 - layer3 MTU       [10]
         *   - Modulo           [12]
         *   - Window           
         *   - layer1 proto     [14]
         *   - bitrate
         *   - sub-channel      [16]
         *   - layer1dataformat [17]
         */
 
        memset(skb_put(*skb, 8), 0, 8);
 
        return 18;
}
 
 
int capi_activate_transp_req(struct pcbit_chan *chan, struct sk_buff **skb)
{
 
	if ((*skb = dev_alloc_skb(7)) == NULL) {
 
		printk(KERN_WARNING "capi_activate_transp_req: alloc_skb failed\n");
		return -1;
	}
 
        SET_SKB_FREE((*skb));
 
        *((ushort*) skb_put(*skb, 2) ) = chan->callref;  
 
 
        *(skb_put(*skb, 1)) = chan->layer2link; /* Layer2 id */
        *(skb_put(*skb, 1)) = 0x00;             /* Transmit by default */
 
        *((ushort *) skb_put(*skb, 2)) = MRU;
 
        *(skb_put(*skb, 1)) = 0x01;             /* Enables reception*/
 
        return 7;
}
 
int capi_tdata_req(struct pcbit_chan* chan, struct sk_buff *skb)
{
	ushort data_len;
 
 
	/*  
	 * callref      - 2  
	 * layer2link   - 1
	 * wBlockLength - 2 
	 * data         - 4
	 * sernum       - 1
	 */
 
	data_len = skb->len;
 
	skb_push(skb, 10);
 
	*((u16 *) (skb->data)) = chan->callref;
	skb->data[2] = chan->layer2link;
	*((u16 *) (skb->data + 3)) = data_len;
 
	chan->s_refnum = (chan->s_refnum + 1) % 8;
	*((u32 *) (skb->data + 5)) = chan->s_refnum;
 
	skb->data[9] = 0;                           /* HDLC frame number */
 
	return 10;
}
 
int capi_tdata_resp(struct pcbit_chan *chan, struct sk_buff ** skb)
 
{
	if ((*skb = dev_alloc_skb(4)) == NULL) {
 
		printk(KERN_WARNING "capi_tdata_resp: alloc_skb failed\n");
		return -1;
	}
 
        SET_SKB_FREE((*skb));
 
        *((ushort*) skb_put(*skb, 2) ) = chan->callref;  
 
        *(skb_put(*skb, 1)) = chan->layer2link;
        *(skb_put(*skb, 1)) = chan->r_refnum;
 
        return (*skb)->len;
}
 
int capi_disc_req(ushort callref, struct sk_buff **skb, u_char cause)
{
 
	if ((*skb = dev_alloc_skb(6)) == NULL) {
 
		printk(KERN_WARNING "capi_disc_req: alloc_skb failed\n");
		return -1;
	}
 
        SET_SKB_FREE((*skb));
 
        *((ushort*) skb_put(*skb, 2) ) = callref;  
 
        *(skb_put(*skb, 1)) = 2;                  /* Cause.Length = 2; */
        *(skb_put(*skb, 1)) = 0x80;
        *(skb_put(*skb, 1)) = 0x80 | cause;           
 
        /* 
         * Change it: we should send 'Sic transit gloria Mundi' here ;-) 
         */
 
        *(skb_put(*skb, 1)) = 0;                   /* UTUS.Length = 0;  */
 
        return 6;
}
 
int capi_disc_resp(struct pcbit_chan *chan, struct sk_buff **skb)
{
	if ((*skb = dev_alloc_skb(2)) == NULL) {
 
		printk(KERN_WARNING "capi_disc_resp: alloc_skb failed\n");
		return -1;
	}
 
        SET_SKB_FREE((*skb));
 
        *((ushort*) skb_put(*skb, 2)) = chan->callref;  
 
        return 2;
}
 
 
/*
 *  Decoding of CAPI messages
 *
 */
 
int capi_decode_conn_ind(struct pcbit_chan * chan, 
                         struct sk_buff *skb,
                         struct callb_data *info) 
{
        int CIlen, len;
 
        /* Call Reference [CAPI] */
        chan->callref = *((ushort*) skb->data);
        skb_pull(skb, 2);
 
#ifdef DEBUG
	printk(KERN_DEBUG "Call Reference: %04x\n", chan->callref); 
#endif
 
        /* Channel Identification */
 
        /* Expect  
           Len = 1 
           Octect 3 = 0100 10CC - [ 7 Basic, 4 , 2-1 chan ]
           */
 
        CIlen = skb->data[0];
#ifdef DEBUG
        if (CIlen == 1) {
 
                if ( ((skb->data[1]) & 0xFC) == 0x48 )
                        printk(KERN_DEBUG "decode_conn_ind: chan ok\n");
                printk(KERN_DEBUG "phyChan = %d\n", skb->data[1] & 0x03); 
        }
	else
		printk(KERN_DEBUG "conn_ind: CIlen = %d\n", CIlen);
#endif
        skb_pull(skb, CIlen + 1);
 
        /* Calling Party Number */
        /* An "additional service" as far as Portugal Telecom is concerned */
 
        len = skb->data[0];
 
	if (len > 0) {
		int count = 1;
 
#ifdef DEBUG
		printk(KERN_DEBUG "CPN: Octect 3 %02x\n", skb->data[1]);
#endif
		if ((skb->data[1] & 0x80) == 0)
			count = 2;
 
		if (!(info->data.setup.CallingPN = kmalloc(len - count + 1, GFP_ATOMIC)))
			return -1;
 
		memcpy(info->data.setup.CallingPN, skb->data + count + 1, 
		       len - count);
		info->data.setup.CallingPN[len - count] = 0;
 
	}
	else {
		info->data.setup.CallingPN = NULL;
		printk(KERN_DEBUG "NULL CallingPN\n");
	}
 
	skb_pull(skb, len + 1);
 
        /* Calling Party Subaddress */
        skb_pull(skb, skb->data[0] + 1);
 
        /* Called Party Number */
 
        len = skb->data[0];
 
	if (len > 0) {
		int count = 1;
 
		if ((skb->data[1] & 0x80) == 0)
			count = 2;
 
		if (!(info->data.setup.CalledPN = kmalloc(len - count + 1, GFP_ATOMIC)))
			return -1;
 
		memcpy(info->data.setup.CalledPN, skb->data + count + 1, 
		       len - count); 
		info->data.setup.CalledPN[len - count] = 0;
 
	}
	else {
		info->data.setup.CalledPN = NULL;
		printk(KERN_DEBUG "NULL CalledPN\n");
	}
 
	skb_pull(skb, len + 1);
 
        /* Called Party Subaddress */
        skb_pull(skb, skb->data[0] + 1);
 
        /* LLC */
        skb_pull(skb, skb->data[0] + 1);
 
        /* HLC */
        skb_pull(skb, skb->data[0] + 1);
 
        /* U2U */
        skb_pull(skb, skb->data[0] + 1);
 
        return 0;
}
 
/*
 *  returns errcode
 */
 
int capi_decode_conn_conf(struct pcbit_chan * chan, struct sk_buff *skb,
			  int *complete) 
{
        int errcode;
 
        chan->callref = *((ushort *) skb->data);     /* Update CallReference */
        skb_pull(skb, 2);
 
        errcode = *((ushort *) skb->data);   /* read errcode */
        skb_pull(skb, 2);
 
        *complete = *(skb->data);
        skb_pull(skb, 1);
 
        /* FIX ME */
        /* This is actually a firmware bug */
        if (!*complete)
        {
                printk(KERN_DEBUG "complete=%02x\n", *complete);
                *complete = 1;
        }
 
 
        /* Optional Bearer Capability */
        skb_pull(skb, *(skb->data) + 1);
 
        /* Channel Identification */
        skb_pull(skb, *(skb->data) + 1);
 
        /* High Layer Compatibility follows */
        skb_pull(skb, *(skb->data) + 1);
 
        return errcode;
}
 
int capi_decode_conn_actv_ind(struct pcbit_chan * chan, struct sk_buff *skb)
{
        ushort len;
#ifdef DEBUG
        char str[32];
#endif
 
        /* Yet Another Bearer Capability */
        skb_pull(skb, *(skb->data) + 1);
 
 
        /* Connected Party Number */
        len=*(skb->data);
 
#ifdef DEBUG
	if (len > 1 && len < 31) {
		memcpy(str, skb->data + 2, len - 1);
		str[len] = 0;
		printk(KERN_DEBUG "Connected Party Number: %s\n", str);
	}
	else
		printk(KERN_DEBUG "actv_ind CPN len = %d\n", len);
#endif
 
        skb_pull(skb, len + 1);
 
        /* Connected Subaddress */
        skb_pull(skb, *(skb->data) + 1);
 
        /* Low Layer Capability */
        skb_pull(skb, *(skb->data) + 1);
 
        /* High Layer Capability */
        skb_pull(skb, *(skb->data) + 1);
 
        return 0;
}
 
int capi_decode_conn_actv_conf(struct pcbit_chan * chan, struct sk_buff *skb)
{
        ushort errcode;
 
        errcode = *((ushort*) skb->data);
        skb_pull(skb, 2);
 
        /* Channel Identification 
        skb_pull(skb, skb->data[0] + 1);
        */
        return errcode;
}
 
 
int capi_decode_sel_proto_conf(struct pcbit_chan *chan, struct sk_buff *skb)
{
        ushort errcode;
 
        chan->layer2link = *(skb->data);
        skb_pull(skb, 1);
 
        errcode = *((ushort*) skb->data);
        skb_pull(skb, 2);
 
        return errcode;
}
 
int capi_decode_actv_trans_conf(struct pcbit_chan *chan, struct sk_buff *skb)
{
        ushort errcode;
 
        if (chan->layer2link != *(skb->data) )
                printk("capi_decode_actv_trans_conf: layer2link doesn't match\n");
 
        skb_pull(skb, 1);
 
        errcode = *((ushort*) skb->data);
        skb_pull(skb, 2);
 
        return errcode;        
}
 
int capi_decode_disc_ind(struct pcbit_chan *chan, struct sk_buff *skb)
{
        ushort len;
#ifdef DEBUG
        int i;
#endif
        /* Cause */
 
        len = *(skb->data);
        skb_pull(skb, 1);
 
#ifdef DEBUG
 
        for (i=0; i<len; i++)
                printk(KERN_DEBUG "Cause Octect %d: %02x\n", i+3, 
                       *(skb->data + i));
#endif
 
        skb_pull(skb, len);
 
        return 0;
}
 
int capi_decode_disc_conf(struct pcbit_chan *chan, struct sk_buff *skb)
{
        ushort errcode;
 
        errcode = *((ushort*) skb->data);
        skb_pull(skb, 2);
 
        return errcode;                
}
 
#ifdef DEBUG
int capi_decode_debug_188(u_char *hdr, ushort hdrlen)
{
        char str[64];
        int len;
 
        len = hdr[0];
 
        if (len < 64 && len == hdrlen - 1) {        
                memcpy(str, hdr + 1, hdrlen - 1);
                str[hdrlen - 1] = 0;
                printk("%s\n", str);
        }
        else
                printk("debug message incorrect\n");
 
        return 0;
}
#endif