int ooH323EpDestroy(void)
{
/* free any internal memory allocated
close trace file free context structure
*/
OOH323CallData * cur, *temp;
if(OO_TESTFLAG(gH323ep.flags, OO_M_ENDPOINTCREATED))
{
OOTRACEINFO1("Destroying H323 Endpoint\n");
if(gH323ep.callList)
{
cur = gH323ep.callList;
while(cur)
{
temp = cur;
cur = cur->next;
temp->callEndReason = OO_REASON_LOCAL_CLEARED;
ooCleanCall(temp);
}
gH323ep.callList = NULL;
}
if(gH323ep.listener)
{
ooSocketClose(*(gH323ep.listener));
gH323ep.listener = NULL;
}
ooGkClientDestroy();
if(gH323ep.fptraceFile)
{
fclose(gH323ep.fptraceFile);
gH323ep.fptraceFile = NULL;
}
freeContext(&(gH323ep.ctxt));
freeContext(&(gH323ep.msgctxt));
OO_CLRFLAG(gH323ep.flags, OO_M_ENDPOINTCREATED);
}
return OO_OK;
}
int ooH323EpSetRTPPortRange(int base, int max)
{
if(base <= 1024)
gH323ep.rtpPorts.start = 1025;
else
gH323ep.rtpPorts.start = base;
if(max > 65500)
gH323ep.rtpPorts.max = 65500;
else
gH323ep.rtpPorts.max = max;
if(gH323ep.rtpPorts.max<gH323ep.rtpPorts.start)
{
OOTRACEERR1("Error: Failed to set rtp ports- Max port number"
" less than Start port number\n");
return OO_FAILED;
}
gH323ep.rtpPorts.current = gH323ep.rtpPorts.start;
OOTRACEINFO1("RTP port range initialize - successful\n");
return OO_OK;
}
void ooH323EpPrintConfig(void)
{
OOTRACEINFO1("H.323 Endpoint Configuration is as follows:\n");
OOTRACEINFO2("\tTrace File: %s\n", gH323ep.traceFile);
if(!OO_TESTFLAG(gH323ep.flags, OO_M_FASTSTART))
{
OOTRACEINFO1("\tFastStart - disabled\n");
}
else{
OOTRACEINFO1("\tFastStart - enabled\n");
}
if(!OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING))
{
OOTRACEINFO1("\tH245 Tunneling - disabled\n");
}
else{
OOTRACEINFO1("\tH245 Tunneling - enabled\n");
}
if(!OO_TESTFLAG(gH323ep.flags, OO_M_MEDIAWAITFORCONN))
{
OOTRACEINFO1("\tMediaWaitForConnect - disabled\n");
}
else{
OOTRACEINFO1("\tMediaWaitForConnect - enabled\n");
}
if(OO_TESTFLAG(gH323ep.flags, OO_M_AUTOANSWER))
OOTRACEINFO1("\tAutoAnswer - enabled\n");
else
OOTRACEINFO1("\tAutoAnswer - disabled\n");
OOTRACEINFO2("\tTerminal Type - %d\n", gH323ep.termType);
OOTRACEINFO2("\tT35 CountryCode - %d\n", gH323ep.t35CountryCode);
OOTRACEINFO2("\tT35 Extension - %d\n", gH323ep.t35Extension);
OOTRACEINFO2("\tManufacturer Code - %d\n", gH323ep.manufacturerCode);
OOTRACEINFO2("\tProductID - %s\n", gH323ep.productID);
OOTRACEINFO2("\tVersionID - %s\n", gH323ep.versionID);
OOTRACEINFO2("\tLocal signalling IP address - %s\n", gH323ep.signallingIP);
OOTRACEINFO2("\tH225 ListenPort - %d\n", gH323ep.listenPort);
OOTRACEINFO2("\tCallerID - %s\n", gH323ep.callerid);
OOTRACEINFO2("\tCall Establishment Timeout - %d seconds\n",
gH323ep.callEstablishmentTimeout);
OOTRACEINFO2("\tMasterSlaveDetermination Timeout - %d seconds\n",
gH323ep.msdTimeout);
OOTRACEINFO2("\tTerminalCapabilityExchange Timeout - %d seconds\n",
gH323ep.tcsTimeout);
OOTRACEINFO2("\tLogicalChannel Timeout - %d seconds\n",
gH323ep.logicalChannelTimeout);
OOTRACEINFO2("\tSession Timeout - %d seconds\n", gH323ep.sessionTimeout);
return;
}
int ooReadAndProcessCallStackCommand(OOH323CallData* call)
{
unsigned char buffer[MAXMSGLEN];
unsigned char *bPoint;
int recvLen = 0;
OOStackCommand cmd;
memset(&cmd, 0, sizeof(OOStackCommand));
if (call->CmdChanLock) {
ast_mutex_lock(call->CmdChanLock);
recvLen = read(call->cmdSock, buffer, MAXMSGLEN);
ast_mutex_unlock(call->CmdChanLock);
} else {
recvLen = read(call->cmdSock, buffer, MAXMSGLEN);
}
if(recvLen <= 0)
{
OOTRACEERR1("Error:Failed to read CMD message\n");
return OO_FAILED;
}
bPoint = buffer;
while (bPoint < buffer + recvLen - sizeof(OOStackCommand)) {
memcpy(&cmd, bPoint, sizeof(OOStackCommand));
bPoint += sizeof(OOStackCommand);
if (cmd.plen1 > 0) {
cmd.param1 = malloc(cmd.plen1 + 1);
if (!cmd.param1)
return OO_FAILED;
memset(cmd.param1, 0, cmd.plen1 + 1);
memcpy(cmd.param1, bPoint, cmd.plen1);
bPoint += cmd.plen1;
}
if (cmd.plen2 > 0) {
cmd.param2 = malloc(cmd.plen2 + 1);
if (!cmd.param2)
return OO_FAILED;
memset(cmd.param2, 0, cmd.plen2 + 1);
memcpy(cmd.param2, bPoint, cmd.plen2);
bPoint += cmd.plen2;
}
if (cmd.plen3 > 0) {
cmd.param3 = malloc(cmd.plen3 + 1);
if (!cmd.param3)
return OO_FAILED;
memset(cmd.param3, 0, cmd.plen3 + 1);
memcpy(cmd.param3, bPoint, cmd.plen3);
bPoint += cmd.plen3;
}
if(cmd.type == OO_CMD_NOOP)
continue;
if(gH323ep.gkClient && gH323ep.gkClient->state != GkClientRegistered)
{
OOTRACEINFO1("Ignoring stack command as Gk Client is not registered"
" yet\n");
}
else {
switch(cmd.type) {
case OO_CMD_MAKECALL:
OOTRACEINFO2("Processing MakeCall command %s\n",
(char*)cmd.param2);
ooH323MakeCall ((char*)cmd.param1, (char*)cmd.param2,
(ooCallOptions*)cmd.param3);
break;
case OO_CMD_MANUALPROGRESS:
ooSendProgress(call);
break;
case OO_CMD_MANUALRINGBACK:
if(OO_TESTFLAG(gH323ep.flags, OO_M_MANUALRINGBACK))
{
ooSendAlerting(call);
if(OO_TESTFLAG(gH323ep.flags, OO_M_AUTOANSWER)) {
ooSendConnect(call);
}
}
break;
case OO_CMD_ANSCALL:
ooSendConnect(call);
break;
case OO_CMD_FWDCALL:
OOTRACEINFO3("Forwarding call %s to %s\n", (char*)cmd.param1,
(char*)cmd.param2);
ooH323ForwardCall((char*)cmd.param1, (char*)cmd.param2);
break;
case OO_CMD_HANGCALL:
OOTRACEINFO2("Processing Hang call command %s with q931 cause %d\n",
(char*)cmd.param1);
ooH323HangCall((char*)cmd.param1,
*(OOCallClearReason*)cmd.param2, *(int *) cmd.param3);
break;
case OO_CMD_SENDDIGIT:
if(call->jointDtmfMode & OO_CAP_DTMF_H245_alphanumeric) {
ooSendH245UserInputIndication_alphanumeric(
call, (const char*)cmd.param2);
}
else if(call->jointDtmfMode & OO_CAP_DTMF_H245_signal) {
ooSendH245UserInputIndication_signal(
call, (const char*)cmd.param2);
}
else {
ooQ931SendDTMFAsKeyPadIE(call, (const char*)cmd.param2);
}
break;
case OO_CMD_REQMODE:
OOTRACEINFO3("Processing RequestMode command %s, requested mode is %d\n",
(char *)cmd.param1, *(int *)cmd.param2);
ooSendRequestMode(call, *(int *)cmd.param2);
break;
case OO_CMD_SETANI:
OOTRACEINFO3("Processing SetANI command %s, ani is %s\n",
(char *)cmd.param1, (char *)cmd.param2);
if(cmd.param2) {
strncpy(call->ourCallerId, cmd.param2, sizeof(call->ourCallerId)-1);
call->ourCallerId[sizeof(call->ourCallerId)-1] = '\0';
}
break;
default: OOTRACEERR1("ERROR:Unknown command\n");
}
}
if(cmd.param1) free(cmd.param1);
if(cmd.param2) free(cmd.param2);
if(cmd.param3) free(cmd.param3);
}
return OO_OK;
}
int ooReadAndProcessStackCommand()
{
OOH323CallData *pCall = NULL;
unsigned char buffer[MAXMSGLEN];
int i, recvLen = 0;
OOStackCommand cmd;
memset(&cmd, 0, sizeof(OOStackCommand));
ast_mutex_lock(&gCmdChanLock);
recvLen = read(gH323ep.cmdSock, buffer, MAXMSGLEN);
ast_mutex_unlock(&gCmdChanLock);
if(recvLen <= 0)
{
OOTRACEERR1("Error:Failed to read CMD message\n");
return OO_FAILED;
}
for(i=0; (int)(i+sizeof(OOStackCommand)) <= recvLen; i += sizeof(OOStackCommand))
{
memcpy(&cmd, buffer+i, sizeof(OOStackCommand));
if(cmd.type == OO_CMD_NOOP)
continue;
if(gH323ep.gkClient && gH323ep.gkClient->state != GkClientRegistered && cmd.type != OO_CMD_STOPMONITOR)
{
OOTRACEINFO1("Ignoring stack command as Gk Client is not registered"
" yet\n");
}
else {
switch(cmd.type) {
case OO_CMD_MAKECALL:
OOTRACEINFO2("Processing MakeCall command %s\n",
(char*)cmd.param2);
ooH323NewCall ((char*)cmd.param2);
break;
case OO_CMD_MANUALPROGRESS:
pCall = ooFindCallByToken((char*)cmd.param1);
if(!pCall) {
OOTRACEINFO2("Call \"%s\" does not exist\n",
(char*)cmd.param1);
OOTRACEINFO1("Call migth be cleared/closed\n");
}
else {
ooSendProgress(ooFindCallByToken((char*)cmd.param1));
}
break;
case OO_CMD_MANUALRINGBACK:
if(OO_TESTFLAG(gH323ep.flags, OO_M_MANUALRINGBACK))
{
pCall = ooFindCallByToken((char*)cmd.param1);
if(!pCall) {
OOTRACEINFO2("Call \"%s\" does not exist\n",
(char*)cmd.param1);
OOTRACEINFO1("Call migth be cleared/closed\n");
}
else {
ooSendAlerting(ooFindCallByToken((char*)cmd.param1));
if(OO_TESTFLAG(gH323ep.flags, OO_M_AUTOANSWER)) {
ooSendConnect(ooFindCallByToken((char*)cmd.param1));
}
}
}
break;
case OO_CMD_ANSCALL:
pCall = ooFindCallByToken((char*)cmd.param1);
if(!pCall) {
OOTRACEINFO2("Call \"%s\" does not exist\n",
(char*)cmd.param1);
OOTRACEINFO1("Call might be cleared/closed\n");
}
else {
OOTRACEINFO2("Processing Answer Call command for %s\n",
(char*)cmd.param1);
ooSendConnect(pCall);
}
break;
case OO_CMD_FWDCALL:
OOTRACEINFO3("Forwarding call %s to %s\n", (char*)cmd.param1,
(char*)cmd.param2);
ooH323ForwardCall((char*)cmd.param1, (char*)cmd.param2);
break;
case OO_CMD_HANGCALL:
OOTRACEINFO3("Processing Hang call command %s with q931 cause %d\n",
(char*)cmd.param1, *(int *) cmd.param3);
ooH323HangCall((char*)cmd.param1,
*(OOCallClearReason*)cmd.param2, *(int *) cmd.param3);
break;
case OO_CMD_SENDDIGIT:
pCall = ooFindCallByToken((char*)cmd.param1);
if(!pCall) {
OOTRACEERR2("ERROR:Invalid calltoken %s\n",
(char*)cmd.param1);
break;
}
if(pCall->jointDtmfMode & OO_CAP_DTMF_H245_alphanumeric) {
ooSendH245UserInputIndication_alphanumeric(
pCall, (const char*)cmd.param2);
}
else if(pCall->jointDtmfMode & OO_CAP_DTMF_H245_signal) {
ooSendH245UserInputIndication_signal(
pCall, (const char*)cmd.param2);
}
else {
ooQ931SendDTMFAsKeyPadIE(pCall, (const char*)cmd.param2);
}
break;
case OO_CMD_STOPMONITOR:
OOTRACEINFO1("Processing StopMonitor command\n");
ooStopMonitorCalls();
break;
default: OOTRACEERR1("ERROR:Unknown command\n");
}
}
if(cmd.param1) free(cmd.param1);
if(cmd.param2) free(cmd.param2);
if(cmd.param3) free(cmd.param3);
}
return OO_OK;
}
