You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
663 lines
15 KiB
663 lines
15 KiB
/*
|
|
* CAPI encoder/decoder for
|
|
* Portugal Telecom CAPI 2.0
|
|
*
|
|
* 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 General Public License, incorporated herein by reference.
|
|
*
|
|
* 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
|
|
*/
|
|
|
|
#include <linux/sched.h>
|
|
#include <linux/string.h>
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/mm.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;
|
|
}
|
|
|
|
*((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;
|
|
}
|
|
|
|
*((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;
|
|
}
|
|
|
|
*((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;
|
|
}
|
|
|
|
*((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;
|
|
}
|
|
|
|
*((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;
|
|
|
|
if(skb_headroom(skb) < 10)
|
|
{
|
|
printk(KERN_CRIT "No headspace (%u) on headroom %p for capi header\n", skb_headroom(skb), skb);
|
|
}
|
|
else
|
|
{
|
|
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;
|
|
}
|
|
|
|
*((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;
|
|
}
|
|
|
|
*((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;
|
|
}
|
|
|
|
*((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
|
|
|
|
|
|
|
|
|
|
|
|
|