retronetworking
/
lib-capi-adk
mirror of https://github.com/OS2World/LIB-capi-adk.git
13
0
Fork 0
Code Issues Projects Releases Wiki Activity
lib-capi-adk/SOURCE/MAIN.C

850 lines
25 KiB
C
Raw Permalink Blame History

/*--------------------------------------------------------------------------*\
MAIN.C 1995 AVM
This demo program shows how to use the CAPI 2.0 Development Kit.
When the program is started, it prompts for a number which will be
called from the CONNECT routine. After that there is the main loop where
the program handles CAPI and keystrokes.
Following is a list of available keys:
'l' Listen (CIP mask = 0x1FFF03FF) every service will be indicated
'L' Listen (CIP mask = 0x00000000) no incoming call will be indicated
Listen is sent to all available controllers
'c' Connect to specified number on slot 0
'C' Connect to specified number on slot 1
'd' Disconnect slot 0
'D' Disconnect slot 1
's' Send datablock with size "SendBlockSize" on slot 0
'S' Send datablock with size "SendBlockSize" on slot 1
'f' Transfer a file on slot 0
'F' Transfer a file on slot 1
'v' Receive a file on slot 0
'V' Receive a file on slot 1
'a' Accept incoming call on slot 0
'A' Accept incoming call on slot 1
'i' Ignore incoming call on slot 0
'I' Ignore incoming call on slot 1
'r' Reject incoming call on slot 0
'R' Reject incoming call on slot 1
Next is an example how to connect the local 2 B-channels:
!! This will cost the same as one telephone call !!
After the start press 'l' so that every incoming call will be indicated.
Press 'c' and the program asks for a number to call, then dials the number.
There should be an incoming call indication on slot 1. Press 'A' and the
program answers the call on the second slot. Now everytime you send data
with 's' or 'S' there must be an data indication on the opposite slot.
Disconnect the slot with 'd' or 'D'
\*--------------------------------------------------------------------------*/
#if !defined (NDEBUG)
#define DEBUG
#define CPROT
#endif
#include "os.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <assert.h>
#include "capi20.h"
#include "c20msg.h"
#include "capi.h"
#include "connect.h"
#include "contr.h"
#include "data.h"
#include "id.h"
#include "init.h"
/*--------------------------------------------------------------------------*\
\*--------------------------------------------------------------------------*/
static char testblock[2048];
/*----- note: you may enter your own number here, but if you -----*/
/*----- supply a wrong number, some PBXs may reject the -----*/
/*----- CAPI messages containing the wrong number -----*/
/*----- e.g.: static char *CallingPartyNumber = "1234567"; -----*/
static char *CallingPartyNumber = NULL;
static char CalledPartyNumberArr[40];
#ifdef DEBUG
static char CAPI_PROT_BUF[CAPI_PROTOCOL_INIT_BUF_SIZE];
static char ProtocolFileName[80];
static FILE *ProtocolFile;
#endif
#define INVALID_SLOT -1
#define maxSlots 2 /*----- this demo program handles max. -----*/
/*----- two connections -----*/
static ConnectionID Slot[maxSlots];
#define B1PROTOCOL 0
#define B2PROTOCOL 0
#define B3PROTOCOL 0
#define B3CONFIGURATION NULL
#define QueueSize 8
typedef struct __DataElement {
char DATA[SendBlockSize];
unsigned short DATA_LENGTH;
unsigned SENT;
} _DataElement;
typedef struct __DataQueue {
_DataElement Element[QueueSize];
unsigned Head;
unsigned Tail;
unsigned Fill;
} _DataQueue;
_DataQueue Queue;
static unsigned FileTransfer = FALSE; /*----- signals if filetransfer is in progress -----*/
static unsigned FileReceive = FALSE; /*----- signals if filetransfer is in progress -----*/
static FILE *File;
/*--------------------------------------------------------------------------*\
* Press_Key:
\*--------------------------------------------------------------------------*/
int Press_Key(void) {
int c;
if ((c = getch()) == 0)
c = getch()+256;
return c;
}
/*--------------------------------------------------------------------------*\
* GetSlot: returns the slotnumber of the ConnectionID or INVALID_SLOT
\*--------------------------------------------------------------------------*/
int GetSlot(ConnectionID Con) {
int x;
for (x=0; x<maxSlots; x++)
if (Slot[x] == Con) return x;
return INVALID_SLOT;
}
/*--------------------------------------------------------------------------*\
* AllocSlot: allocates one slot, if none free returns INVALID_SLOT
\*--------------------------------------------------------------------------*/
int AllocSlot(ConnectionID Con) {
int x;
for (x=0; x<maxSlots; x++)
if (Slot[x] == INVALID_CONNECTION_ID) {
Slot[x] = Con;
return x;
}
return INVALID_SLOT;
}
/*--------------------------------------------------------------------------*\
* FreeSlot: clear one slot
\*--------------------------------------------------------------------------*/
void FreeSlot(int index) {
Slot[index] = INVALID_CONNECTION_ID;
}
/*--------------------------------------------------------------------------*\
* MainDataAvailable: signals received data blocks
* This function is called after a DATA_B3_INDication is received. The flag
* DiscardData tells CAPI to free the memora area directly after the return
* of this function when set to TRUE (1) which is the preset. When the flag
* is set to FALSE (0) the data area MUST be freed later with ReleaseData.
* The datahandle identifies the memory area. When reaching 7 unconfirmed
* blocks, no more incoming data will be signaled until freeing at least
* one block.
\*--------------------------------------------------------------------------*/
void MainDataAvailable(ConnectionID Connection,
void __far *Data,
unsigned short DataLength,
unsigned short DataHandle,
int *DiscardData) {
assert (Connection != INVALID_CONNECTION_ID);
# ifdef DEBUG
CAPI_PROTOCOL_TEXT("***** incoming data, slot %d ID %d, size %d , handle %u *****\n",
GetSlot(Connection), Connection, DataLength, DataHandle);
# endif
if ((FileReceive) && (File != NULL)) {
fwrite(Data, 1, DataLength, File);
}
*DiscardData = TRUE;
}
/*--------------------------------------------------------------------------*\
* MainDataConf: signals the successful sending of a datablock
* This function is called after receiving a DATA_B3_CONFirmation. CAPI signals
* that the datablock identified by DataHandle has been sent and the memory
* area may be freed. The DataHandle is the same as specified in SendBlock.
\*--------------------------------------------------------------------------*/
void MainDataConf(ConnectionID Connection,
unsigned short DataHandle,
unsigned short Info) {
assert (Connection != INVALID_CONNECTION_ID);
if (Info != 0) {
# ifdef DEBUG
CAPI_PROTOCOL_TEXT("***** datablock slot %d ID %d handle %d NOT sent , error: 0x%04X *****\n",
GetSlot(Connection), Connection, DataHandle, Info);
# endif
return;
}
if (FileTransfer) {
assert (DataHandle == (unsigned short)Queue.Tail);
Queue.Element[Queue.Tail].SENT = FALSE;
if (++Queue.Tail >= QueueSize) Queue.Tail = 0;
Queue.Fill--;
}
# ifdef DEBUG
CAPI_PROTOCOL_TEXT("***** datablock slot %d ID %d handle %d has been sent *****\n",
GetSlot(Connection), Connection, DataHandle);
# endif
}
/*--------------------------------------------------------------------------*\
* MainStateChange: signals a state change on both B-channels (connected,
* disconnected). Whenever a channel changes his state this function is called
\*--------------------------------------------------------------------------*/
void MainStateChange(ConnectionID Connection,
ConnectionState State) {
int index;
assert (Connection != INVALID_CONNECTION_ID);
index = GetSlot(Connection);
# ifdef DEBUG
CAPI_PROTOCOL_TEXT("***** state change slot %d ID %d: %s *****\n", index, Connection,
ConnectionStateString[State]);
# endif
if (State == Disconnected) {
FreeSlot(index);
}
}
/*--------------------------------------------------------------------------*\
* MainIncomingCall: signals an incoming call
* This function will be executed if a CONNECT_INDication appears to
* inform the user.
\*--------------------------------------------------------------------------*/
void MainIncomingCall(ConnectionID Connection,
char *CallingPartyNumber) {
int index;
assert (Connection != INVALID_CONNECTION_ID);
# ifdef DEBUG
CAPI_PROTOCOL_TEXT("***** incoming call ,ID %d, caller: \"%s\" *****\n",Connection,CallingPartyNumber);
# endif
index = AllocSlot(Connection);
if (index == INVALID_SLOT) {
# ifdef DEBUG
CAPI_PROTOCOL_TEXT("***** no free slot available, rejecting call... *****\n");
# endif
AnswerCall(Connection, REJECT,0,0,0,NULL);
return;
}
# ifdef DEBUG
CAPI_PROTOCOL_TEXT("***** call assigned to slot %d *****\n", index);
# endif
}
#ifdef DEBUG
/*--------------------------------------------------------------------------*\
* CAPI_PROT_HANDLE: This is a callback-function that has been specified
* with CAPI_PROTOCOL_INIT. The first parameter is a pointer to the protocol-
* message which is plain ASCII-text. The parameter t contains the type of
* the message which can be CAPI_PROTOCOL_HEADER (appears only once when
* calling CAPI_PROTOCOL_INIT), CAPI_PROTOCOL_MSG (the text contains a
* decoded CAPI-message) and CAPI_PROTOCOL_TXT (the buffers contains a debug
* message or a message sent with the function CAPI_PROTOCOL_TEXT).
* If the type of the message is CAPI_PROTOCOL_MSG, the last parameter contains
* a pointer to the decoded CAPI-message.
\*--------------------------------------------------------------------------*/
void CAPI_PROT_HANDLE(char *Message,
CAPI_PROTOCOL_TYP t,
CAPI_MESSAGE m) {
fprintf(ProtocolFile,"%s",Message);
if (t != CAPI_PROTOCOL_MSG)
puts(Message);
if (t == CAPI_PROTOCOL_MSG) {
_cmsg CMSG;
CAPI_MESSAGE_2_CMSG(&CMSG, m);
if ((FileTransfer || FileReceive) &&
(CMSG.Command == CAPI_DATA_B3) && (CMSG.Info == 0) &&
(CMSG.Reason == 0) && (CMSG.Reason_B3 == 0)) {
return;
}
puts(Message);
if (CMSG.Info != 0) {
printf("Info 0x%04X: %s\n",CMSG.Info,Decode_Info(CMSG.Info));
fprintf(ProtocolFile,"Info 0x%04X: %s\n",CMSG.Info,Decode_Info(CMSG.Info));
}
if (CMSG.Reason != 0) {
printf("Reason 0x%04X: %s\n",CMSG.Reason,Decode_Info(CMSG.Reason));
fprintf(ProtocolFile,"Reason 0x%04X: %s\n",CMSG.Reason,Decode_Info(CMSG.Reason));
}
if (CMSG.Reason_B3 != 0) {
printf("Reason_B3 0x%04X: %s\n",CMSG.Reason_B3,Decode_Info(CMSG.Reason_B3));
fprintf(ProtocolFile,"Reason_B3 0x%04X: %s\n",CMSG.Reason_B3,Decode_Info(CMSG.Reason_B3));
}
}
fflush(ProtocolFile);
}
/*--------------------------------------------------------------------------*\
* Prot_Init: Initialisation of the protocol
\*--------------------------------------------------------------------------*/
int Prot_Init(char *Filename) {
char *p;
strcpy(ProtocolFileName, Filename);
p = strrchr(ProtocolFileName, '.');
if (p) *p = '\0';
strcat(ProtocolFileName, ".prt");
if ((ProtocolFile=fopen(ProtocolFileName, "w"))==NULL) {
printf("Can't open protocol-file !!\n");
return FALSE;
}
CAPI_PROTOCOL_INIT(CAPI_PROT_BUF, CAPI_PROT_HANDLE);
return TRUE;
}
#endif
/*--------------------------------------------------------------------------*\
* The following _h functions are 'h'igh level functions for the ones
* implemented in CONNECT.C . The _h functions perform some parameter tests
* that would cause an assert on the low-level functions.
\*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*\
* Connect_h: Asks for a number to call then executes 'Connect'
\*--------------------------------------------------------------------------*/
unsigned Connect_h(ConnectionID *Connection,
char *CallingPartyNumber,
unsigned long Service,
unsigned short B1Protocol,
unsigned short B2Protocol,
unsigned short B3Protocol,
unsigned char __far *B3Configuration) {
if (*Connection != INVALID_CONNECTION_ID) {
printf("Connect_h: Connection is already in use\n");
return 0xFFFF;
}
printf("Enter Number: ");
fflush (stdout);
gets(CalledPartyNumberArr);
return Connect(Connection,
CalledPartyNumberArr,
CallingPartyNumber,
Service,
B1Protocol,
B2Protocol,
B3Protocol,
B3Configuration);
}
/*--------------------------------------------------------------------------*\
* Disconnect_h: high level Disconnect
\*--------------------------------------------------------------------------*/
unsigned Disconnect_h(ConnectionID Connection) {
int index;
ConnectionState State;
if (Connection == INVALID_CONNECTION_ID) {
printf("Disconnect_h: ConnectionID is invalid\n");
return 0xFFFF;
}
State = GetState(Connection);
if ((State == Disconnected) || (State == D_DisconnectPending)) {
index = GetSlot(Connection);
printf("Disconnect_h: slot %d ID %d is disconnected\n",index, Connection);
return 0xFFFF;
}
return Disconnect(Connection);
}
/*--------------------------------------------------------------------------*\
* SendData_h: high level SendData
\*--------------------------------------------------------------------------*/
unsigned SendData_h(ConnectionID Connection,
void __far *Data,
unsigned short DataLength,
unsigned short DataHandle) {
int index;
ConnectionState State;
if (Connection == INVALID_CONNECTION_ID) {
printf("SendData_h: ConnectionID is invalid\n");
return 0xFFFF;
}
State = GetState(Connection);
if (State != Connected) {
index = GetSlot(Connection);
printf("SendData_h: slot %d ID %d is not connected\n",index, Connection);
return 0xFFFF;
}
return SendData(Connection, Data, DataLength, DataHandle);
}
/*--------------------------------------------------------------------------*\
* AnswerCall_h: high level AnswerCall
\*--------------------------------------------------------------------------*/
unsigned AnswerCall_h(ConnectionID Connection,
RejectValue Reject,
unsigned short B1Protocol,
unsigned short B2Protocol,
unsigned short B3Protocol,
unsigned char __far *B3Configuration) {
int index;
ConnectionState State;
if (Connection == INVALID_CONNECTION_ID) {
printf("AnswerCall_h: ConnectionID is invalid\n");
return 0xFFFF;
}
State = GetState(Connection);
if (State != D_ConnectPending) {
index = GetSlot(Connection);
printf("AnswerCall_h: slot %d ID %d is the wrong state for answering\n",index, Connection);
return 0xFFFF;
}
return AnswerCall(Connection,
Reject,
B1Protocol,
B2Protocol,
B3Protocol,
B3Configuration);
}
/*--------------------------------------------------------------------------*\
* InitQueue: resets the data queue
\*--------------------------------------------------------------------------*/
void InitQueue(void) {
unsigned x;
for (x=0; x<QueueSize; x++) {
Queue.Element[x].SENT = FALSE;
}
Queue.Head = 0;
Queue.Tail = 0;
Queue.Fill = 0;
}
/*--------------------------------------------------------------------------*\
* TransferData: sends datablocks from the queue to CAPI until a) all Blocks
* from the queue are sent or b) an error occurs. This functions trys to send
* the maximum of 7 unconfirmed datablocks to CAPI for maximum throughput.
\*--------------------------------------------------------------------------*/
void TransferData(int index) {
MESSAGE_EXCHANGE_ERROR error;
unsigned t;
if (Queue.Fill > 0) {
t = Queue.Tail;
do {
if (Queue.Element[t].SENT == FALSE) {
error = SendData(index,
(void __far *)Queue.Element[t].DATA,
Queue.Element[t].DATA_LENGTH,
(unsigned short)t);
if (error != 0) {
printf("Error transfering data: 0x%04X !!!",error);
break;
}
Queue.Element[t].SENT = TRUE;
}
if (++t >= QueueSize) t = 0;
} while (t != Queue.Head);
}
}
/*--------------------------------------------------------------------------*\
* SendFile: Sends a file
\*--------------------------------------------------------------------------*/
unsigned SendFile(int index) {
char Filename[80];
unsigned count;
if (Slot[index] == INVALID_CONNECTION_ID) {
printf("SendFile: ConnectionID is invalid\n");
return 1;
}
if (GetState(Slot[index]) != Connected) {
printf("SendFile: slot %d ID %d is not connected\n",index, Slot[index]);
return 2;
}
printf("Enter Filename: ");
fflush (stdout);
gets(Filename);
File = fopen(Filename, "rb");
if (! File) {
# ifdef DEBUG
CAPI_PROTOCOL_TEXT("***** file not found *****\n");
# endif
return 3;
}
InitQueue();
FileTransfer = TRUE;
# ifdef DEBUG
CAPI_PROTOCOL_TEXT("***** Starting datatransfer on slot %d, press any key to stop *****\n",index);
CAPI_PROTOCOL_TEXT("***** there is no protocol output to the screen during transfer *****\n\n");
# endif
do {
if ((! feof(File)) && (Queue.Fill < 7)) { /*----- max. 7 outstanding blocks supported by CAPI -----*/
count = fread(&(Queue.Element[Queue.Head].DATA[0]), 1, SendBlockSize, File);
if (count > 0) {
Queue.Element[Queue.Head].DATA_LENGTH = (unsigned short)count;
if (++Queue.Head >= QueueSize) Queue.Head = 0;
Queue.Fill++;
}
}
if (GetState(Slot[index]) != Connected) {
# ifdef DEBUG
CAPI_PROTOCOL_TEXT("***** connection broken *****\n");
# endif
break;
}
if (kbhit()) {
# ifdef DEBUG
CAPI_PROTOCOL_TEXT("***** interrupted by user *****\n");
# endif
break;
}
TransferData(index);
Handle_CAPI_Msg();
} while (Queue.Fill > 0);
FileTransfer = FALSE;
# ifdef DEBUG
CAPI_PROTOCOL_TEXT("***** End of filetransfer *****\n");
# endif
fclose(File);
return 0;
}
/*--------------------------------------------------------------------------*\
* ReceiveFile: Receives a file and writes it to disk
\*--------------------------------------------------------------------------*/
unsigned ReceiveFile(int index) {
char Filename[80];
if (Slot[index] == INVALID_CONNECTION_ID) {
printf("ReceiveFile: ConnectionID is invalid\n");
return 1;
}
if (GetState(Slot[index]) != Connected) {
printf("ReceiveFile: slot %d ID %d is not connected\n",index, Slot[index]);
return 2;
}
printf("Enter Filename where incoming data shall be saved: ");
fflush (stdout);
gets(Filename);
File = fopen(Filename, "wb");
if (! File) {
# ifdef DEBUG
CAPI_PROTOCOL_TEXT("***** could not open file *****\n");
# endif
return 3;
}
InitQueue();
FileReceive = TRUE;
# ifdef DEBUG
CAPI_PROTOCOL_TEXT("***** Waiting for data on slot %d, press any key to stop *****\n",index);
CAPI_PROTOCOL_TEXT("***** there is no protocol output to the screen during transfer *****\n");
# endif
do {
if (GetState(Slot[index]) != Connected) {
# ifdef DEBUG
CAPI_PROTOCOL_TEXT("***** connection broken *****\n");
# endif
break;
}
Handle_CAPI_Msg();
} while (! kbhit());
getch();
FileReceive = FALSE;
# ifdef DEBUG
CAPI_PROTOCOL_TEXT("***** End of filetransfer *****\n");
# endif
fclose(File);
return 0;
}
/*---------------------------------------------------------------------------*\
* PrintHelp: tell the user the options
\*---------------------------------------------------------------------------*/
static void PrintHelp (void) {
puts("\n\n");
puts("'ESC' Exit program");
puts("'l' Listen (CIP mask = 0x1FFF03FF) every service will be indicated");
puts("'L' Listen (CIP mask = 0x00000000) no incoming call will be indicated");
puts("'c'+'C' Connect, the specified number will be called");
puts("'d' Disconnect slot 0");
puts("'D' Disconnect slot 1");
puts("'s' Send datablock with size \"SendBlockSize\" on slot 0");
puts("'S' Send datablock with size \"SendBlockSize\" on slot 1");
puts("'f' Transfer a file on slot 0");
puts("'F' Transfer a file on slot 1");
puts("'v' Receive a file on slot 0");
puts("'V' Receive a file on slot 1");
puts("'a' Accept incoming call on slot 0");
puts("'A' Accept incoming call on slot 1");
puts("'i' Ignore incoming call on slot 0");
puts("'I' Ignore incoming call on slot 1");
puts("'r' Reject incoming call on slot 0");
puts("'R' Reject incoming call on slot 1");
puts("'?' Print this help screen");
}
/*--------------------------------------------------------------------------*\
* HandleKeyStroke: Checks the keyboard
\*--------------------------------------------------------------------------*/
int HandleKeyStroke(void) {
int i;
#if defined (TARGET_NW)
delay(50); // the netware NLM has to be cooperative
#endif
if (kbhit()) {
i = Press_Key();
switch (i) {
case 'q':
case 27: { /*----- ESCAPE -----*/
printf("Exit program ? y/n ");
fflush (stdout);
i = Press_Key();
if ((i == 'y') || (i =='Y')) {
puts("Y");
return FALSE;
}
puts("N");
return TRUE;
}
case 'l':
Listen(ALL_SERVICES);
break;
case 'L':
Listen(NO_SERVICES);
break;
case 'c':
Connect_h(&Slot[0],
CallingPartyNumber,
DATA_TRANSFER,
B1PROTOCOL,
B2PROTOCOL,
B3PROTOCOL,
B3CONFIGURATION);
break;
case 'C':
Connect_h(&Slot[1],
CallingPartyNumber,
DATA_TRANSFER,
B1PROTOCOL,
B2PROTOCOL,
B3PROTOCOL,
B3CONFIGURATION);
break;
case 'd':
Disconnect_h(Slot[0]);
break;
case 'D':
Disconnect_h(Slot[1]);
break;
case 's':
SendData_h(Slot[0], (void __far *)&testblock, SendBlockSize, 1);
break;
case 'S':
SendData_h(Slot[1], (void __far *)&testblock, SendBlockSize, 1);
break;
case 'f':
SendFile(Slot[0]);
break;
case 'F':
SendFile(Slot[1]);
break;
case 'v':
ReceiveFile(Slot[0]);
break;
case 'V':
ReceiveFile(Slot[1]);
break;
case 'a':
AnswerCall_h(Slot[0],ACCEPT,B1PROTOCOL,B2PROTOCOL,B3PROTOCOL,NULL);
break;
case 'A':
AnswerCall_h(Slot[1],ACCEPT,B1PROTOCOL,B2PROTOCOL,B3PROTOCOL,NULL);
break;
case 'i':
AnswerCall_h(Slot[0],IGNORE,0,0,0,NULL);
break;
case 'I':
AnswerCall_h(Slot[1],IGNORE,0,0,0,NULL);
break;
case 'r':
AnswerCall_h(Slot[0],REJECT,0,0,0,NULL);
break;
case 'R':
AnswerCall_h(Slot[1],REJECT,0,0,0,NULL);
break;
case 'h':
case '?':
PrintHelp();
break;
}
}
return TRUE;
}
/*--------------------------------------------------------------------------*\
* Interact: main loop, checks keystrokes and CAPI-messages
\*--------------------------------------------------------------------------*/
void Interact(void) {
int numController;
int BChannels, Contr;
numController = GetNumController ();
BChannels = 0;
for (Contr=1; Contr<=numController; Contr++)
BChannels += GetNumOfSupportedBChannels(Contr);
printf("Detected %i controllers with %i B-channels overall.\n",
numController, BChannels);
PrintHelp ();
do {
Handle_CAPI_Msg();
} while (HandleKeyStroke());
puts("\nProgram terminated\n");
}
/*--------------------------------------------------------------------------*\
* Hangup: Disconnect both channels
\*--------------------------------------------------------------------------*/
void Hangup(void) {
int i;
if ((Slot[0] != INVALID_CONNECTION_ID) &&
(GetState(Slot[0]) != Disconnected) &&
(GetState(Slot[0]) != D_DisconnectPending))
Disconnect(Slot[0]);
if ((Slot[1] != INVALID_CONNECTION_ID) &&
(GetState(Slot[1]) != Disconnected) &&
(GetState(Slot[1]) != D_DisconnectPending))
Disconnect(Slot[1]);
do {
Handle_CAPI_Msg();
if (kbhit()) {
while (kbhit()) {
getch();
}
printf("Exit program ? y/n ");
fflush (stdout);
i = Press_Key();
if ((i == 'y') || (i =='Y')) {
puts("Y");
return;
}
puts("N");
}
}
while ((Slot[0] != INVALID_CONNECTION_ID) || (Slot[1] != INVALID_CONNECTION_ID));
}
/*--------------------------------------------------------------------------*\
* ctrlchandler: exits on CTRL-C and CTRL-BREAK
\*--------------------------------------------------------------------------*/
void ctrlchandler(int sig)
{
signal( SIGINT, ctrlchandler );
exit(0);
sig = 0; /*----- suppress warning -----*/
}
/*--------------------------------------------------------------------------*\
* main: Init & exit functions
\*--------------------------------------------------------------------------*/
#ifdef DEBUG
int main(int ac, char *av[]) {
#else
int main(void) {
#endif
Slot[0] = INVALID_CONNECTION_ID;
Slot[1] = INVALID_CONNECTION_ID;
if (! RegisterCAPI ()) return 1;
atexit (ReleaseCAPI);
signal(SIGINT, ctrlchandler);
InitConnectionIDHandling ();
#ifdef DEBUG
if (! Prot_Init(av[ac-1])) return 2;
#endif
#ifdef __linux__
init_tty();
atexit (restore_tty);
#endif
Interact();
Hangup();
#ifdef DEBUG
fclose(ProtocolFile);
#endif
return 0;
}
Reference in New Issue View Git Blame Copy Permalink