421 lines
14 KiB
C
421 lines
14 KiB
C
/*--------------------------------------------------------------------------*\
|
|
|
|
ID.C Version 1.1 1995 AVM
|
|
|
|
Functions for ConnectionID handling
|
|
|
|
\*--------------------------------------------------------------------------*/
|
|
#include <assert.h>
|
|
#include <malloc.h>
|
|
#include <string.h>
|
|
|
|
#include "id.h"
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* typedefinitions
|
|
\*--------------------------------------------------------------------------*/
|
|
const char *ConnectionStateString[7] = {"Disconnected",
|
|
"D_ConnectPending",
|
|
"D_Connected",
|
|
"B_ConnectPending",
|
|
"Connected",
|
|
"B_DisconnectPending",
|
|
"D_DisconnectPending"};
|
|
|
|
typedef struct _ConnectionDesc {
|
|
unsigned InUse;
|
|
long PLCI;
|
|
long NCCI;
|
|
long Controller;
|
|
ConnectionState State;
|
|
int Initiator;
|
|
unsigned char *CalledPartyNumberStruct; /*----- CAPI struct -----*/
|
|
unsigned char *CallingPartyNumberStruct; /*----- CAPI struct -----*/
|
|
} ConnectionDesc;
|
|
|
|
static ConnectionDesc C[maxConnections] = {0};
|
|
static unsigned char * EmptyStruct = (unsigned char *)"\0";
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* InitConnectionIDHandling: Initialisation of internal structures. Must be
|
|
* executed before using the functions in this module.
|
|
\*--------------------------------------------------------------------------*/
|
|
void InitConnectionIDHandling (void) {
|
|
unsigned Con;
|
|
|
|
/*----- init local data -----*/
|
|
for (Con=0; Con<maxConnections; Con++)
|
|
C[Con].InUse = 0;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* AllocConnection: allocates one connection structure. Returns
|
|
* INVALID_CONNECTION_ID if none free. All members are resetted.
|
|
\*--------------------------------------------------------------------------*/
|
|
ConnectionID AllocConnection (void) {
|
|
|
|
unsigned Con;
|
|
|
|
for (Con=0; Con<maxConnections; Con++) {
|
|
if (!C[Con].InUse) {
|
|
/*----- found free entry -----*/
|
|
C[Con].InUse = 1;
|
|
C[Con].PLCI = INVAL_PLCI;
|
|
C[Con].NCCI = INVAL_NCCI;
|
|
C[Con].Controller = INVAL_CONTROLLER;
|
|
C[Con].State = Disconnected;
|
|
C[Con].Initiator = 0;
|
|
C[Con].CalledPartyNumberStruct = EmptyStruct;
|
|
C[Con].CallingPartyNumberStruct = EmptyStruct;
|
|
|
|
return Con;
|
|
}
|
|
}
|
|
return INVALID_CONNECTION_ID;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* FreeNumberStruct: Frees the memory area if the specified pointer is not
|
|
* a pointer to EmptyStruct.
|
|
\*--------------------------------------------------------------------------*/
|
|
static void FreeNumberStruct (unsigned char **pStruct) {
|
|
|
|
assert (*pStruct != NULL);
|
|
|
|
if (*pStruct != EmptyStruct) {
|
|
free (*pStruct);
|
|
*pStruct = EmptyStruct;
|
|
}
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* FreeConnection: frees one connection, the ConnectionID is no longer valid
|
|
\*--------------------------------------------------------------------------*/
|
|
void FreeConnection (ConnectionID Con) {
|
|
|
|
assert (Con != INVALID_CONNECTION_ID);
|
|
assert (C[Con].InUse);
|
|
|
|
C[Con].InUse = 0;
|
|
|
|
FreeNumberStruct (&C[Con].CalledPartyNumberStruct);
|
|
FreeNumberStruct (&C[Con].CallingPartyNumberStruct);
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* SetConnectionPLCI: sets the PLCI (and controller) for one connection
|
|
\*--------------------------------------------------------------------------*/
|
|
void SetConnectionPLCI (ConnectionID Con,
|
|
long PLCI) {
|
|
|
|
assert (Con != INVALID_CONNECTION_ID);
|
|
assert (C[Con].InUse);
|
|
|
|
C[Con].PLCI = PLCI;
|
|
C[Con].Controller = (long)(PLCI & 0x000000FF);
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* GetConnectionPLCI: returns the PLCI for one connection
|
|
\*--------------------------------------------------------------------------*/
|
|
long GetConnectionPLCI (ConnectionID Con) {
|
|
|
|
assert (Con != INVALID_CONNECTION_ID);
|
|
assert (C[Con].InUse);
|
|
|
|
return C[Con].PLCI;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* GetConnectionByPLCI: Searches the connection that uses the PLCI, if none
|
|
* found, returns INVALID_CONNECTION_ID.
|
|
\*--------------------------------------------------------------------------*/
|
|
ConnectionID GetConnectionByPLCI (long PLCI) {
|
|
|
|
unsigned Con;
|
|
|
|
assert (PLCI != INVAL_PLCI);
|
|
|
|
for (Con=0; Con<maxConnections; Con++) {
|
|
if (C[Con].InUse && C[Con].PLCI == PLCI) return Con;
|
|
|
|
}
|
|
return INVALID_CONNECTION_ID;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* SetConnectionNCCI: Sets the NCCI for one connection.
|
|
\*--------------------------------------------------------------------------*/
|
|
void SetConnectionNCCI (ConnectionID Con,
|
|
long NCCI) {
|
|
|
|
assert (Con != INVALID_CONNECTION_ID);
|
|
assert (C[Con].InUse);
|
|
|
|
C[Con].NCCI = NCCI;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* GetConnectionNCCI: Returns the NCCI for one connection.
|
|
\*--------------------------------------------------------------------------*/
|
|
long GetConnectionNCCI (ConnectionID Con) {
|
|
|
|
assert (Con != INVALID_CONNECTION_ID);
|
|
assert (C[Con].InUse);
|
|
|
|
return C[Con].NCCI;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* GetConnectionByNCCI: Searches the connection that uses the NCCI, if none
|
|
* found, returns INVALID_CONNECTION_ID.
|
|
\*--------------------------------------------------------------------------*/
|
|
ConnectionID GetConnectionByNCCI (long NCCI) {
|
|
|
|
unsigned Con;
|
|
|
|
assert (NCCI != INVAL_NCCI);
|
|
|
|
for (Con=0; Con<maxConnections; Con++) {
|
|
if (C[Con].InUse && C[Con].NCCI == NCCI) return Con;
|
|
}
|
|
return INVALID_CONNECTION_ID;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* GetController: Returns the controller that is used by the specified
|
|
* connection.
|
|
\*--------------------------------------------------------------------------*/
|
|
long GetController (ConnectionID Con) {
|
|
|
|
assert (Con != INVALID_CONNECTION_ID);
|
|
assert (C[Con].InUse);
|
|
|
|
return C[Con].Controller;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* GetNumberOfConnections: Returns the number of currently active connections
|
|
* on the specified controller.
|
|
\*--------------------------------------------------------------------------*/
|
|
unsigned GetNumberOfConnections (long Controller) {
|
|
|
|
ConnectionID Con;
|
|
unsigned numConnections = 0;
|
|
|
|
assert (Controller != INVAL_CONTROLLER);
|
|
|
|
for (Con=0; Con<maxConnections; Con++) {
|
|
if (C[Con].InUse && (C[Con].Controller == Controller)) numConnections++;
|
|
}
|
|
return numConnections;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* GetState: Returns the state of the specified connection.
|
|
\*--------------------------------------------------------------------------*/
|
|
ConnectionState GetState (ConnectionID Con) {
|
|
|
|
if (Con == INVALID_CONNECTION_ID)
|
|
return (ConnectionState)INVAL_STATE;
|
|
|
|
assert (C[Con].InUse);
|
|
|
|
return C[Con].State;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* SetState: Sets the state of the specified connection.
|
|
\*--------------------------------------------------------------------------*/
|
|
void SetState (ConnectionID Con,
|
|
ConnectionState State) {
|
|
|
|
assert (Con != INVALID_CONNECTION_ID);
|
|
assert (C[Con].InUse);
|
|
|
|
/*----- internal connection state -----*/
|
|
C[Con].State = State;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* SetConnectionInitiator: Changes the Initiator flag to the specified value
|
|
\*--------------------------------------------------------------------------*/
|
|
void SetConnectionInitiator (ConnectionID Con,
|
|
int Initiator) {
|
|
|
|
assert (Con != INVALID_CONNECTION_ID);
|
|
assert (C[Con].InUse);
|
|
|
|
|
|
C[Con].Initiator = Initiator;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* GetConnectionInitiator: Returns the Initiator flag for the specified
|
|
* connection
|
|
\*--------------------------------------------------------------------------*/
|
|
int GetConnectionInitiator (ConnectionID Con) {
|
|
|
|
assert (Con != INVALID_CONNECTION_ID);
|
|
assert (C[Con].InUse);
|
|
|
|
|
|
return C[Con].Initiator;
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* SetCalledPartyNumber: Sets the CalledPartyNumber belonging to the specified
|
|
* connection. CalledPartyNumber has to be a zero terminated string containing
|
|
* only ASCII numbers.
|
|
* Note: CalledPartyNumber has to different meanings in incoming and outgoing
|
|
* call. For the outgoing call it contains the number of the party that will
|
|
* be called, in incoming calls it contains the number that has been dialed
|
|
* by the external party. On an ISDN access with multiple numbers this
|
|
* CalledPartyNumber must be used to determine which number has been called.
|
|
* Note, that this number may contain only the last one or two digits of
|
|
* the called number, but this is enough to uniquely identify the called port.
|
|
\*--------------------------------------------------------------------------*/
|
|
void SetCalledPartyNumber (ConnectionID Con,
|
|
char *CalledNumber) {
|
|
|
|
assert (Con != INVALID_CONNECTION_ID);
|
|
assert (C[Con].InUse);
|
|
|
|
|
|
FreeNumberStruct (&C[Con].CalledPartyNumberStruct);
|
|
if (CalledNumber != NULL) {
|
|
int len;
|
|
|
|
len = strlen(CalledNumber);
|
|
|
|
/*----- \xLen\x80 STRING '\0' -----*/
|
|
|
|
C[Con].CalledPartyNumberStruct = (unsigned char *)malloc(len + 2 + 1);
|
|
assert (C[Con].CalledPartyNumberStruct != NULL);
|
|
|
|
C[Con].CalledPartyNumberStruct[0] = (unsigned char)(len + 1);
|
|
C[Con].CalledPartyNumberStruct[1] = 0x80;
|
|
strcpy ((char *)&(C[Con].CalledPartyNumberStruct[2]), CalledNumber);
|
|
}
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* SetCalledPartyNumberStruct: Sets the CalledPartyNumber belonging to the
|
|
* specified connection. CalledStruct has to be a valid CAPI struct.
|
|
\*--------------------------------------------------------------------------*/
|
|
void SetCalledPartyNumberStruct (ConnectionID Con,
|
|
unsigned char *CalledStruct) {
|
|
|
|
assert (Con != INVALID_CONNECTION_ID);
|
|
assert (C[Con].InUse);
|
|
|
|
|
|
FreeNumberStruct (&C[Con].CalledPartyNumberStruct);
|
|
if (CalledStruct != NULL) {
|
|
|
|
/*----- two more for the length byte and '\0' -----*/
|
|
C[Con].CalledPartyNumberStruct = (unsigned char *)malloc((size_t)(CalledStruct[0] + 2));
|
|
assert(C[Con].CalledPartyNumberStruct != NULL);
|
|
|
|
memcpy(C[Con].CalledPartyNumberStruct, CalledStruct, (size_t)(CalledStruct[0] + 1));
|
|
C[Con].CalledPartyNumberStruct[CalledStruct[0] + 1] = '\0';
|
|
}
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* GetCalledPartyNumber: Returns the CalledPartyNumber belonging to the
|
|
* specified connection as a zero terminated string.
|
|
\*--------------------------------------------------------------------------*/
|
|
char *GetCalledPartyNumber (ConnectionID Con) {
|
|
|
|
if (C[Con].CalledPartyNumberStruct[0] > 1)
|
|
return (char *)(&(C[Con].CalledPartyNumberStruct[2]));
|
|
else
|
|
return (char *)EmptyStruct;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* GetCalledPartyNumberStruct: Returns the CalledPartyNumber belonging to the
|
|
* specified connection as a CAPI struct.
|
|
\*--------------------------------------------------------------------------*/
|
|
unsigned char *GetCalledPartyNumberStruct (ConnectionID Con) {
|
|
|
|
return C[Con].CalledPartyNumberStruct;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* SetCallingPartyNumber: Sets the CallingPartyNumber belonging to the
|
|
* specified connection. CalledPartyNumber has to be a zero terminated string
|
|
* containing only ASCII numbers.
|
|
* CallingPartyNumber contains always the number of the party that originated
|
|
* the call, if it is not needed you dont need to set it.
|
|
\*--------------------------------------------------------------------------*/
|
|
void SetCallingPartyNumber (ConnectionID Con,
|
|
char *CallingNumber) {
|
|
|
|
assert (Con != INVALID_CONNECTION_ID);
|
|
assert (C[Con].InUse);
|
|
|
|
|
|
FreeNumberStruct (&C[Con].CallingPartyNumberStruct);
|
|
if ((CallingNumber != NULL) && (*CallingNumber != 0)) {
|
|
int len;
|
|
|
|
len = strlen(CallingNumber);
|
|
|
|
/*----- \xLen\x00\x80 STRING '\0' -----*/
|
|
|
|
C[Con].CallingPartyNumberStruct = (unsigned char *)malloc(len + 3 + 1);
|
|
assert (C[Con].CallingPartyNumberStruct != NULL);
|
|
|
|
C[Con].CallingPartyNumberStruct[0] = (unsigned char)(len + 2);
|
|
C[Con].CallingPartyNumberStruct[1] = 0x00;
|
|
C[Con].CallingPartyNumberStruct[2] = 0x80;
|
|
strcpy ((char *)&(C[Con].CallingPartyNumberStruct[3]), CallingNumber);
|
|
}
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* SetCallingPartyNumberStruct: Sets the CallingPartyNumber belonging to the
|
|
* specified connection. CallingStruct has to be a valid CAPI struct.
|
|
\*--------------------------------------------------------------------------*/
|
|
void SetCallingPartyNumberStruct (ConnectionID Con,
|
|
unsigned char *CallingStruct) {
|
|
|
|
assert (Con != INVALID_CONNECTION_ID);
|
|
assert (C[Con].InUse);
|
|
|
|
|
|
FreeNumberStruct (&C[Con].CallingPartyNumberStruct);
|
|
if (CallingStruct != NULL) {
|
|
/*----- two more for the length byte and '\0' -----*/
|
|
C[Con].CallingPartyNumberStruct = (unsigned char *)malloc((size_t)(CallingStruct[0] + 2));
|
|
assert(C[Con].CallingPartyNumberStruct != NULL);
|
|
|
|
memcpy(C[Con].CallingPartyNumberStruct, CallingStruct, (size_t)(CallingStruct[0] + 1));
|
|
C[Con].CallingPartyNumberStruct[CallingStruct[0] + 1] = '\0';
|
|
}
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* GetCallingPartyNumber: Returns the CallingPartyNumber belonging to the
|
|
* specified connection as a zero terminated string.
|
|
\*--------------------------------------------------------------------------*/
|
|
char *GetCallingPartyNumber (ConnectionID Con) {
|
|
|
|
if (C[Con].CallingPartyNumberStruct[0] > 2)
|
|
return (char *)&(C[Con].CallingPartyNumberStruct[3]);
|
|
else
|
|
return (char *)EmptyStruct;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*\
|
|
* GetCallingPartyNumberStruct: Returns the CallingPartyNumber belonging to the
|
|
* specified connection as a CAPI struct.
|
|
\*--------------------------------------------------------------------------*/
|
|
unsigned char *GetCallingPartyNumberStruct (ConnectionID Con) {
|
|
|
|
return C[Con].CallingPartyNumberStruct;
|
|
}
|