Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
d85c1e4043
NetBSD/sys/netisdn/i4b_q932fac.c
martin 5171d409a5 First step to cleanup the hardware driver <-> upper layers interface. 
This now provides slightly more functionality than the FreeBSD layer1-newbus
interface. It was meant to be a simple change to one header and a few
c files, but the change rippled all through various stuff.

To prevent a change to the kernel<->userland interface right now the kernel
is now lying about card types to userland (but who cares). This will be fixed
when the userland interface changes, after layer 3 <-> layer 4 has been
fixed.

Functional changes:

Provide a clean interface for hardware drivers to attach to the upper
layers. This will need another small change in the B-channel handling
when a similar change to the layer 3 <-> layer 4 interface happens.

Avoid passing indices into global arrays of pointers around, instead pass
the pointers itself. Don't code hardware driver types by predefined magic
numbers (think LKM). Prepare for detachable drivers (think pcmcia).

While there remove some sets of function pointers always pointing to the
same function (meant to be the configurable set of D channel protocol
handlers). It is unlikely another supported D-channel protocol will fit into
that (maximal layer interface) abstraction. When we get support for another
protocol, we will need to come up with a workable interface. Besides, the
old implementation was, uhm, strange.
2001-03-24 12:40:29 +00:00

570 lines
13 KiB
C
Raw Blame History

/*
* Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*---------------------------------------------------------------------------
*
* i4b_q932fac.c - Q932 facility handling
* --------------------------------------
*
* $Id: i4b_q932fac.c,v 1.2 2001/03/24 12:40:32 martin Exp $
*
* $FreeBSD$
*
* last edit-date: [Fri Jan 5 11:33:47 2001]
*
*---------------------------------------------------------------------------*/
#ifdef __FreeBSD__
#include "i4bq931.h"
#else
#define NI4BQ931 1
#endif
#if NI4BQ931 > 0
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <net/if.h>
#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
#include <sys/callout.h>
#endif
#ifdef __FreeBSD__
#include <machine/i4b_debug.h>
#include <machine/i4b_ioctl.h>
#else
#include <netisdn/i4b_debug.h>
#include <netisdn/i4b_ioctl.h>
#endif
#include <netisdn/i4b_isdnq931.h>
#include <netisdn/i4b_l3l4.h>
#include <netisdn/i4b_mbuf.h>
#include <netisdn/i4b_l3.h>
#include <netisdn/i4b_l3fsm.h>
#include <netisdn/i4b_q931.h>
#include <netisdn/i4b_q932fac.h>
#include <netisdn/i4b_l4.h>
static int do_component(int length);
static void next_state(int class, int form, int code, int val);
static int byte_len;
static unsigned char *byte_buf;
static int state;
static int units;
static int operation_value;
/*---------------------------------------------------------------------------*
* decode Q.931/Q.932 facility info element
*---------------------------------------------------------------------------*/
int
i4b_aoc(unsigned char *buf, call_desc_t *cd)
{
int len;
cd->units_type = CHARGE_INVALID;
cd->units = -1;
buf++; /* length */
len = *buf;
buf++; /* protocol profile */
switch(*buf & 0x1f)
{
case FAC_PROTO_ROP:
break;
case FAC_PROTO_CMIP:
NDBGL3(L3_A_MSG, "CMIP Protocol (Q.941), UNSUPPORTED");
return(-1);
break;
case FAC_PROTO_ACSE:
NDBGL3(L3_A_MSG, "ACSE Protocol (X.217/X.227), UNSUPPORTED!");
return(-1);
break;
default:
NDBGL3(L3_A_ERR, "Unknown Protocol, UNSUPPORTED!");
return(-1);
break;
}
NDBGL3(L3_A_MSG, "Remote Operations Protocol");
/* next byte */
buf++;
len--;
/* initialize variables for do_component */
byte_len = 0;
byte_buf = buf;
state = ST_EXP_COMP_TYP;
/* decode facility */
do_component(len);
switch(operation_value)
{
case FAC_OPVAL_AOC_D_CUR:
cd->units_type = CHARGE_AOCD;
cd->units = 0;
return(0);
break;
case FAC_OPVAL_AOC_D_UNIT:
cd->units_type = CHARGE_AOCD;
cd->units = units;
return(0);
break;
case FAC_OPVAL_AOC_E_CUR:
cd->units_type = CHARGE_AOCE;
cd->units = 0;
return(0);
break;
case FAC_OPVAL_AOC_E_UNIT:
cd->units_type = CHARGE_AOCE;
cd->units = units;
return(0);
break;
default:
cd->units_type = CHARGE_INVALID;
cd->units = -1;
return(-1);
break;
}
return(-1);
}
/*---------------------------------------------------------------------------*
* handle a component recursively
*---------------------------------------------------------------------------*/
static int
do_component(int length)
{
int comp_tag_class; /* component tag class */
int comp_tag_form; /* component form: constructor or primitive */
int comp_tag_code; /* component code depending on class */
int comp_length = 0; /* component length */
again:
/*----------------------------------------*/
/* first component element: component tag */
/*----------------------------------------*/
/* tag class bits */
comp_tag_class = (*byte_buf & 0xc0) >> 6;
switch(comp_tag_class)
{
case FAC_TAGCLASS_UNI:
break;
case FAC_TAGCLASS_APW:
break;
case FAC_TAGCLASS_COS:
break;
case FAC_TAGCLASS_PRU:
break;
}
/* tag form bit */
comp_tag_form = (*byte_buf & 0x20) > 5;
/* tag code bits */
comp_tag_code = *byte_buf & 0x1f;
if(comp_tag_code == 0x1f)
{
comp_tag_code = 0;
byte_buf++;
byte_len++;
while(*byte_buf & 0x80)
{
comp_tag_code += (*byte_buf & 0x7f);
byte_buf++;
byte_len++;
}
comp_tag_code += (*byte_buf & 0x7f);
}
else
{
comp_tag_code = (*byte_buf & 0x1f);
}
byte_buf++;
byte_len++;
/*--------------------------------------------*/
/* second component element: component length */
/*--------------------------------------------*/
comp_length = 0;
if(*byte_buf & 0x80)
{
int i = *byte_buf & 0x7f;
byte_len += i;
for(;i > 0;i++)
{
byte_buf++;
comp_length += (*byte_buf * (i*256));
}
}
else
{
comp_length = *byte_buf & 0x7f;
}
next_state(comp_tag_class, comp_tag_form, comp_tag_code, -1);
byte_len++;
byte_buf++;
/*---------------------------------------------*/
/* third component element: component contents */
/*---------------------------------------------*/
if(comp_tag_form) /* == constructor */
{
do_component(comp_length);
}
else
{
int val = 0;
if(comp_tag_class == FAC_TAGCLASS_UNI)
{
switch(comp_tag_code)
{
case FAC_CODEUNI_INT:
case FAC_CODEUNI_ENUM:
case FAC_CODEUNI_BOOL:
if(comp_length)
{
int i;
for(i = comp_length-1; i >= 0; i--)
{
val += (*byte_buf + (i*255));
byte_buf++;
byte_len++;
}
}
break;
default:
if(comp_length)
{
int i;
for(i = comp_length-1; i >= 0; i--)
{
byte_buf++;
byte_len++;
}
}
break;
}
}
else /* comp_tag_class != FAC_TAGCLASS_UNI */
{
if(comp_length)
{
int i;
for(i = comp_length-1; i >= 0; i--)
{
val += (*byte_buf + (i*255));
byte_buf++;
byte_len++;
}
}
}
next_state(comp_tag_class, comp_tag_form, comp_tag_code, val);
}
if(byte_len < length)
goto again;
return(byte_len);
}
/*---------------------------------------------------------------------------*
* invoke component
*---------------------------------------------------------------------------*/
static void
F_1_1(int val)
{
if(val == -1)
{
state = ST_EXP_INV_ID;
}
}
/*---------------------------------------------------------------------------*
* return result
*---------------------------------------------------------------------------*/
static void
F_1_2(int val)
{
if(val == -1)
state = ST_EXP_NIX;
}
/*---------------------------------------------------------------------------*
* return error
*---------------------------------------------------------------------------*/
static void
F_1_3(int val)
{
if(val == -1)
state = ST_EXP_NIX;
}
/*---------------------------------------------------------------------------*
* reject
*---------------------------------------------------------------------------*/
static void
F_1_4(int val)
{
if(val == -1)
state = ST_EXP_NIX;
}
/*---------------------------------------------------------------------------*
* invoke id
*---------------------------------------------------------------------------*/
static void
F_2(int val)
{
if(val != -1)
{
NDBGL3(L3_A_MSG, "Invoke ID = %d", val);
state = ST_EXP_OP_VAL;
}
}
/*---------------------------------------------------------------------------*
* operation value
*---------------------------------------------------------------------------*/
static void
F_3(int val)
{
if(val != -1)
{
NDBGL3(L3_A_MSG, "Operation Value = %d", val);
operation_value = val;
if((val == FAC_OPVAL_AOC_D_UNIT) || (val == FAC_OPVAL_AOC_E_UNIT))
{
units = 0;
state = ST_EXP_INFO;
}
else
{
state = ST_EXP_NIX;
}
}
}
/*---------------------------------------------------------------------------*
* specific charging units
*---------------------------------------------------------------------------*/
static void
F_4(int val)
{
if(val == -1)
state = ST_EXP_RUL;
}
/*---------------------------------------------------------------------------*
* free of charge
*---------------------------------------------------------------------------*/
static void
F_4_1(int val)
{
if(val == -1)
{
NDBGL3(L3_A_MSG, "Free of Charge");
/* units = 0; XXXX */
state = ST_EXP_NIX;
}
}
/*---------------------------------------------------------------------------*
* charge not available
*---------------------------------------------------------------------------*/
static void
F_4_2(int val)
{
if(val == -1)
{
NDBGL3(L3_A_MSG, "Charge not available");
/* units = -1; XXXXXX ??? */
state = ST_EXP_NIX;
}
}
/*---------------------------------------------------------------------------*
* recorded units list
*---------------------------------------------------------------------------*/
static void
F_5(int val)
{
if(val == -1)
state = ST_EXP_RU;
}
/*---------------------------------------------------------------------------*
* recorded units
*---------------------------------------------------------------------------*/
static void
F_6(int val)
{
if(val == -1)
state = ST_EXP_RNOU;
}
/*---------------------------------------------------------------------------*
* number of units
*---------------------------------------------------------------------------*/
static void
F_7(int val)
{
if(val != -1)
{
NDBGL3(L3_A_MSG, "Number of Units = %d", val);
units = val;
state = ST_EXP_TOCI;
}
}
/*---------------------------------------------------------------------------*
* subtotal/total
*---------------------------------------------------------------------------*/
static void
F_8(int val)
{
if(val != -1)
{
NDBGL3(L3_A_MSG, "Subtotal/Total = %d", val);
/* type_of_charge = val; */
state = ST_EXP_DBID;
}
}
/*---------------------------------------------------------------------------*
* billing_id
*---------------------------------------------------------------------------*/
static void
F_9(int val)
{
if(val != -1)
{
NDBGL3(L3_A_MSG, "Billing ID = %d", val);
/* billing_id = val; */
state = ST_EXP_NIX;
}
}
/*---------------------------------------------------------------------------*
*
*---------------------------------------------------------------------------*/
static struct statetab {
int currstate; /* input: current state we are in */
int form; /* input: current tag form */
int class; /* input: current tag class */
int code; /* input: current tag code */
void (*func)(int); /* output: func to exec */
} statetab[] = {
/* current state tag form tag class tag code function */
/* --------------------- ---------------------- ---------------------- ---------------------- ----------------*/
{ST_EXP_COMP_TYP, FAC_TAGFORM_CON, FAC_TAGCLASS_COS, 1, F_1_1 },
{ST_EXP_COMP_TYP, FAC_TAGFORM_CON, FAC_TAGCLASS_COS, 2, F_1_2 },
{ST_EXP_COMP_TYP, FAC_TAGFORM_CON, FAC_TAGCLASS_COS, 3, F_1_3 },
{ST_EXP_COMP_TYP, FAC_TAGFORM_CON, FAC_TAGCLASS_COS, 4, F_1_4 },
{ST_EXP_INV_ID, FAC_TAGFORM_PRI, FAC_TAGCLASS_UNI, FAC_CODEUNI_INT, F_2 },
{ST_EXP_OP_VAL, FAC_TAGFORM_PRI, FAC_TAGCLASS_UNI, FAC_CODEUNI_INT, F_3 },
{ST_EXP_INFO, FAC_TAGFORM_CON, FAC_TAGCLASS_UNI, FAC_CODEUNI_SEQ, F_4 },
{ST_EXP_INFO, FAC_TAGFORM_PRI, FAC_TAGCLASS_UNI, FAC_CODEUNI_NULL, F_4_1 },
{ST_EXP_INFO, FAC_TAGFORM_PRI, FAC_TAGCLASS_COS, 1, F_4_2 },
{ST_EXP_RUL, FAC_TAGFORM_CON, FAC_TAGCLASS_COS, 1, F_5 },
{ST_EXP_RU, FAC_TAGFORM_CON, FAC_TAGCLASS_UNI, FAC_CODEUNI_SEQ, F_6 },
{ST_EXP_RNOU, FAC_TAGFORM_PRI, FAC_TAGCLASS_UNI, FAC_CODEUNI_INT, F_7 },
{ST_EXP_TOCI, FAC_TAGFORM_PRI, FAC_TAGCLASS_COS, 2, F_8 },
{ST_EXP_DBID, FAC_TAGFORM_PRI, FAC_TAGCLASS_COS, 3, F_9 },
{-1, -1, -1, -1, NULL }
};
/*---------------------------------------------------------------------------*
* state decode for do_component
*---------------------------------------------------------------------------*/
static void
next_state(int class, int form, int code, int val)
{
int i;
for(i=0; ; i++)
{
if((statetab[i].currstate > state) ||
(statetab[i].currstate == -1))
{
break;
}
if((statetab[i].currstate == state) &&
(statetab[i].form == form) &&
(statetab[i].class == class) &&
(statetab[i].code == code))
{
(*statetab[i].func)(val);
break;
}
}
}
#endif /* NI4BQ931 > 0 */
Reference in New Issue View Git Blame Copy Permalink