int ooH323EpAddAliasEmailID(const char * email)
{
ooAliases * psNewAlias=NULL;
psNewAlias = (ooAliases*)memAlloc(&gH323ep.ctxt, sizeof(ooAliases));
if(!psNewAlias)
{
OOTRACEERR1("Error: Failed to allocate memory for new Email-ID alias\n");
return OO_FAILED;
}
psNewAlias->type = T_H225AliasAddress_email_ID;
psNewAlias->registered = FALSE;
psNewAlias->value = (char*) memAlloc(&gH323ep.ctxt, strlen(email)+1);
if(!psNewAlias->value)
{
OOTRACEERR1("Error: Failed to allocate memory for the new Email-ID alias"
" value\n");
memFreePtr(&gH323ep.ctxt, psNewAlias);
return OO_FAILED;
}
strcpy(psNewAlias->value, email);
psNewAlias->next = gH323ep.aliases;
gH323ep.aliases = psNewAlias;
OOTRACEDBGA2("Added alias: Email-ID - %s\n", email);
return OO_OK;
}
EXTRTMETHOD ASN1CSeqOfList::~ASN1CSeqOfList()
{
if(!wasAssigned) {
clear();
memFreePtr (pList);
}
}
int ooCallClearAliases(OOH323CallData *call)
{
if(call->ourAliases)
memFreePtr(call->pctxt, call->ourAliases);
call->ourAliases = NULL;
return OO_OK;
}
int ooH323EpAddAliasDialedDigits(const char* dialedDigits)
{
ooAliases * psNewAlias=NULL;
psNewAlias = (ooAliases*)memAlloc(&gH323ep.ctxt, sizeof(ooAliases));
if(!psNewAlias)
{
OOTRACEERR1("Error: Failed to allocate memory for new DialedDigits "
"alias\n");
return OO_FAILED;
}
psNewAlias->type = T_H225AliasAddress_dialedDigits;
psNewAlias->registered = FALSE;
psNewAlias->value = (char*) memAlloc(&gH323ep.ctxt, strlen(dialedDigits)+1);
if(!psNewAlias->value)
{
OOTRACEERR1("Error: Failed to allocate memory for the new DialedDigits"
" alias value\n");
memFreePtr(&gH323ep.ctxt, psNewAlias);
return OO_FAILED;
}
strcpy(psNewAlias->value, dialedDigits);
psNewAlias->next = gH323ep.aliases;
gH323ep.aliases = psNewAlias;
OOTRACEDBGA2("Added alias: DialedDigits - %s\n", dialedDigits);
return OO_OK;
}
void* dListDeleteHead (OOCTXT* pctxt, DList* pList)
{
DListNode* pNode = (0 != pList) ? pList->head : 0;
if (0 != pNode) {
void* pdata = pNode->data;
dListRemove (pList, pNode);
memFreePtr (pctxt, pNode);
return pdata;
}
return 0;
}
/* Free all nodes, but not the data */
void dListFreeNodes (OOCTXT* pctxt, DList* pList)
{
DListNode* pNode, *pNextNode;
for (pNode = pList->head; pNode != 0; pNode = pNextNode) {
pNextNode = pNode->next;
memFreePtr (pctxt, pNode);
}
pList->count = 0;
pList->head = pList->tail = 0;
}
int ooH323EpSetProductID (const char* productID)
{
if (0 != productID) {
char* pstr = (char*) memAlloc (&gH323ep.ctxt, strlen(productID)+1);
strcpy (pstr, productID);
if(gH323ep.productID)
memFreePtr(&gH323ep.ctxt, gH323ep.productID);
gH323ep.productID = pstr;
return OO_OK;
}
else return OO_FAILED;
}
int ooH323EpSetVersionID (const char* versionID)
{
if (0 != versionID) {
char* pstr = (char*) memAlloc (&gH323ep.ctxt, strlen(versionID)+1);
strcpy (pstr, versionID);
if(gH323ep.versionID)
memFreePtr(&gH323ep.ctxt, gH323ep.versionID);
gH323ep.versionID = pstr;
return OO_OK;
}
else return OO_FAILED;
}
int ooH323EpSetCallerID (const char* callerID)
{
if (0 != callerID) {
char* pstr = (char*) memAlloc (&gH323ep.ctxt, strlen(callerID)+1);
strcpy (pstr, callerID);
if(gH323ep.callerid)
memFreePtr(&gH323ep.ctxt, gH323ep.callerid);
gH323ep.callerid = pstr;
return OO_OK;
}
else return OO_FAILED;
}
void dListFindAndRemove(struct OOCTXT* pctxt, DList* pList, void *data)
{
DListNode *pNode, *pNextNode;
for(pNode = pList->head; pNode !=0; pNode = pNextNode){
pNextNode = pNode->next;
if(pNode->data == data) /* pointer comparison*/
break;
}
if(pNode) {
dListRemove(pList, pNode);
memFreePtr(pctxt, pNode);
}
}
int ooCallH245ConnectionRetryTimerExpired(void *data)
{
ooTimerCallback *cbData = (ooTimerCallback*) data;
OOH323CallData *call = cbData->call;
OOTRACEINFO3("H245 connection retry timer expired. (%s, %s)\n",
call->callType, call->callToken);
memFreePtr(call->pctxt, cbData);
call->h245ConnectionAttempts++;
ooCreateH245Connection(call);
return OO_OK;
}
int ooH323EpClearAllAliases(void)
{
ooAliases *pAlias = NULL, *pTemp;
if(gH323ep.aliases)
{
pAlias = gH323ep.aliases;
while(pAlias)
{
pTemp = pAlias;
pAlias = pAlias->next;
memFreePtr(&gH323ep.ctxt, pTemp);
}
gH323ep.aliases = NULL;
}
return OO_OK;
}
int ooCallSetCalledPartyNumber(OOH323CallData *call, const char *number)
{
if(call->calledPartyNumber)
memFreePtr(call->pctxt, call->calledPartyNumber);
call->calledPartyNumber = (char*) memAlloc(call->pctxt, strlen(number)+1);
if(call->calledPartyNumber)
{
strcpy(call->calledPartyNumber, number);
}
else{
OOTRACEERR3("Error:Memory - ooCallSetCalledPartyNumber - "
"calledPartyNumber.(%s, %s)\n", call->callType,
call->callToken);
return OO_FAILED;
}
return OO_OK;
}
int ooCallSetCallingPartyNumber(OOH323CallData *call, const char *number)
{
if(call->callingPartyNumber)
memFreePtr(call->pctxt, call->callingPartyNumber);
call->callingPartyNumber = (char*) memAlloc(call->pctxt, strlen(number)+1);
if(call->callingPartyNumber)
{
strcpy(call->callingPartyNumber, number);
}
else{
OOTRACEERR3("Error:Memory - ooCallSetCallingPartyNumber - "
"callingPartyNumber.(%s, %s)\n", call->callType,
call->callToken);
return OO_FAILED;
}
/* Set dialed digits alias */
/* if(!strcmp(call->callType, "outgoing"))
{
ooCallAddAliasDialedDigits(call, number);
}*/
return OO_OK;
}
int ooCallAddAlias
(OOH323CallData *call, int aliasType, const char *value, OOBOOL local)
{
ooAliases * psNewAlias=NULL;
psNewAlias = (ooAliases*)memAlloc(call->pctxt, sizeof(ooAliases));
if(!psNewAlias)
{
OOTRACEERR3("Error:Memory - ooCallAddAlias - psNewAlias"
"(%s, %s)\n", call->callType, call->callToken);
return OO_FAILED;
}
psNewAlias->type = aliasType;
psNewAlias->value = (char*) memAlloc(call->pctxt, strlen(value)+1);
if(!psNewAlias->value)
{
OOTRACEERR3("Error:Memory - ooCallAddAlias - psNewAlias->value"
" (%s, %s)\n", call->callType, call->callToken);
memFreePtr(call->pctxt, psNewAlias);
return OO_FAILED;
}
strcpy(psNewAlias->value, value);
if(local)
{
psNewAlias->next = call->ourAliases;
call->ourAliases = psNewAlias;
}
else {
psNewAlias->next = call->remoteAliases;
call->remoteAliases = psNewAlias;
}
OOTRACEDBGC5("Added %s alias %s to call. (%s, %s)\n",
local?"local":"remote", value, call->callType, call->callToken);
return OO_OK;
}
static struct session *h225_ras_callback(struct session *ras, u_char *data, uint32_t len)
{
OOCTXT ctxt;
H225RasMessage *pRasMsg;
struct session *cs;
struct session *rasbkp;
initContext(&ctxt);
if (ASN_OK != setPERBuffer(&ctxt, data, len, TRUE))
return ras;
rasbkp = ras;
pRasMsg = (H225RasMessage *)memAlloc(&ctxt, sizeof (H225RasMessage));
if (ASN_OK == asn1PD_H225RasMessage(&ctxt, pRasMsg))
switch (pRasMsg->t) {
case T_H225RasMessage_admissionRequest:
if (bonus_time)
break;
if ('\0' != ras->u.ras_params.call_id[0])
ras = sessions_add(TYPE_UDP | TYPE_H225_RAS, &ras->addr, NULL);
memcpy(ras->u.ras_params.call_id, pRasMsg->u.admissionRequest->conferenceID.data, 16);
ras->u.ras_params.seqnum = pRasMsg->u.admissionRequest->requestSeqNum;
ras->timeout = nids_last_pcap_header->ts.tv_sec + 60;
/* 60 seconds for the gatekeeper to confirm admission */
break;
case T_H225RasMessage_admissionConfirm:
if (bonus_time)
break;
while ((NULL != ras) && (ras->u.ras_params.seqnum != pRasMsg->u.admissionConfirm->requestSeqNum))
ras = sessions_find(ras->next, TYPE_UDP | TYPE_H225_RAS, 0, &ras->addr);
if (NULL == ras) {
ras = rasbkp;
break;
}
if (pRasMsg->u.admissionConfirm->destCallSignalAddress.t != T_H225TransportAddress_ipAddress) {
ras->timeout = nids_last_pcap_header->ts.tv_sec; /* delete after dumping frame */
break;
}
ras->u.ras_params.cs_addr.dest = pRasMsg->u.admissionConfirm->destCallSignalAddress.u.ipAddress->port;
ras->u.ras_params.cs_addr.daddr = *((u_int *)pRasMsg->u.admissionConfirm->destCallSignalAddress.u.ipAddress->ip.data);
if (NULL != (cs = sessions_add(TYPE_TCP | TYPE_H225_CS, &ras->u.ras_params.cs_addr, ras)))
cs->timeout = nids_last_pcap_header->ts.tv_sec + 60;
/* 60 seconds to establish the Call Signaling stream */
break;
case T_H225RasMessage_admissionReject:
while ((NULL != ras) && (ras->u.ras_params.seqnum != pRasMsg->u.admissionReject->requestSeqNum))
ras = sessions_find(ras->next, TYPE_UDP | TYPE_H225_RAS, 0, &ras->addr);
if (NULL == ras) {
ras = rasbkp;
break;
}
ras->timeout = nids_last_pcap_header->ts.tv_sec; /* delete after dumping frame */
break;
case T_H225RasMessage_disengageRequest:
while ((NULL != ras) && memcmp(ras->u.ras_params.call_id, pRasMsg->u.disengageRequest->conferenceID.data, 16))
ras = sessions_find(ras->next, TYPE_UDP | TYPE_H225_RAS, 0, &ras->addr);
if (NULL == ras) {
ras = rasbkp;
break;
}
ras->u.ras_params.seqnum = pRasMsg->u.disengageRequest->requestSeqNum;
break;
case T_H225RasMessage_disengageConfirm:
while ((NULL != ras) && (ras->u.ras_params.seqnum != pRasMsg->u.disengageConfirm->requestSeqNum))
ras = sessions_find(ras->next, TYPE_UDP | TYPE_H225_RAS, 0, &ras->addr);
if (NULL == ras) {
ras = rasbkp;
break;
}
ras->timeout = nids_last_pcap_header->ts.tv_sec; /* delete after dumping frame */
}
memFreePtr(&ctxt, pRasMsg);
freeContext(&ctxt);
return ras;
}
int ooCleanCall(OOH323CallData *call)
{
OOCTXT *pctxt;
OOTRACEWARN4 ("Cleaning Call (%s, %s)- reason:%s\n",
call->callType, call->callToken,
ooGetReasonCodeText (call->callEndReason));
/* First clean all the logical channels, if not already cleaned. */
if(call->logicalChans)
ooClearAllLogicalChannels(call);
/* Close H.245 connection, if not already closed */
if(call->h245SessionState != OO_H245SESSION_CLOSED)
ooCloseH245Connection(call);
else{
if(call->pH245Channel && call->pH245Channel->outQueue.count > 0)
{
dListFreeAll(call->pctxt, &(call->pH245Channel->outQueue));
memFreePtr(call->pctxt, call->pH245Channel);
}
}
/* Close H.245 listener, if not already closed */
if(call->h245listener)
{
ooCloseH245Listener(call);
}
/* Close H225 connection, if not already closed. */
if (0 != call->pH225Channel && 0 != call->pH225Channel->sock)
{
ooCloseH225Connection(call);
}
/* Clean timers */
if(call->timerList.count > 0)
{
dListFreeAll(call->pctxt, &(call->timerList));
}
if(gH323ep.gkClient && !OO_TESTFLAG(call->flags, OO_M_DISABLEGK))
{
ooGkClientCleanCall(gH323ep.gkClient, call);
}
ooRemoveCallFromList (call);
OOTRACEINFO3("Removed call (%s, %s) from list\n", call->callType,
call->callToken);
if(call->pCallFwdData && call->pCallFwdData->fwdedByRemote)
{
if(gH323ep.h323Callbacks.onCallForwarded)
gH323ep.h323Callbacks.onCallForwarded(call);
if(ooH323HandleCallFwdRequest(call)!= OO_OK)
{
OOTRACEERR3("Error:Failed to forward call (%s, %s)\n", call->callType,
call->callToken);
}
}
else {
if(gH323ep.h323Callbacks.onCallCleared)
gH323ep.h323Callbacks.onCallCleared(call);
}
pctxt = call->pctxt;
freeContext(pctxt);
ASN1CRTFREE0(pctxt);
return OO_OK;
}
int ooSocketGetInterfaceList(OOCTXT *pctxt, OOInterface **ifList)
{
OOSOCKET sock;
struct ifconf ifc;
int ifNum;
OOInterface *pIf=NULL;
struct sockaddr_in sin;
OOTRACEDBGA1("Retrieving local interfaces\n");
if(ooSocketCreateUDP(&sock, 4)!= ASN_OK)
{
OOTRACEERR1("Error:Failed to create udp socket - "
"ooSocketGetInterfaceList\n");
return -1;
}
#ifdef SIOCGIFNUM
if(ioctl(sock, SIOCGIFNUM, &ifNum) >= 0)
{
OOTRACEERR1("Error: ioctl for ifNum failed\n");
return -1;
}
#else
ifNum = 50;
#endif
ifc.ifc_len = ifNum * sizeof(struct ifreq);
ifc.ifc_req = (struct ifreq *)memAlloc(pctxt, ifNum *sizeof(struct ifreq));
if(!ifc.ifc_req)
{
OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - ifc.ifc_req\n");
return -1;
}
if (ioctl(sock, SIOCGIFCONF, &ifc) >= 0) {
void * ifEndList = (char *)ifc.ifc_req + ifc.ifc_len;
struct ifreq *ifName;
struct ifreq ifReq;
int flags;
for (ifName = ifc.ifc_req; (void*)ifName < ifEndList; ifName++) {
char *pName=NULL;
char addr[50];
#ifdef ifr_netmask
char mask[50];
#endif
pIf = (struct OOInterface*)memAlloc(pctxt, sizeof(struct OOInterface));
pName = (char*)memAlloc(pctxt, strlen(ifName->ifr_name)+1);
if(!pIf)
{
OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - "
"pIf/pName\n");
return -1;
}
OOTRACEDBGA2("\tInterface name: %s\n", ifName->ifr_name);
strcpy(ifReq.ifr_name, ifName->ifr_name);
strcpy(pName, ifName->ifr_name);
pIf->name = pName;
/* Check whether the interface is up*/
if (ioctl(sock, SIOCGIFFLAGS, &ifReq) < 0) {
OOTRACEERR2("Error:Unable to determine status of interface %s\n",
pName);
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf);
continue;
}
flags = ifReq.ifr_flags;
if (!(flags & IFF_UP)) {
OOTRACEWARN2("Warn:Interface %s is not up\n", pName);
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf);
continue;
}
/* Retrieve interface address */
if (ioctl(sock, SIOCGIFADDR, &ifReq) < 0)
{
OOTRACEWARN2("Warn:Unable to determine address of interface %s\n",
pName);
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf);
continue;
}
memcpy(&sin, &ifReq.ifr_addr, sizeof(struct sockaddr_in));
strcpy(addr, ast_inet_ntoa(sin.sin_addr));
OOTRACEDBGA2("\tIP address is %s\n", addr);
pIf->addr = (char*)memAlloc(pctxt, strlen(addr)+1);
if(!pIf->addr)
{
OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - "
"pIf->addr\n");
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf);
return -1;
}
strcpy(pIf->addr, addr);
#ifdef ifr_netmask
if (ioctl(sock, SIOCGIFNETMASK, &ifReq) < 0)
{
OOTRACEWARN2("Warn:Unable to determine mask for interface %s\n",
pName);
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf->addr);
memFreePtr(pctxt, pIf);
continue;
}
memcpy(&sin, &ifReq.ifr_netmask, sizeof(struct sockaddr_in));
strcpy(mask, ast_inet_ntoa(sin.sin_addr));
OOTRACEDBGA2("\tMask is %s\n", mask);
pIf->mask = (char*)memAlloc(pctxt, strlen(mask)+1);
if(!pIf->mask)
{
OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - "
"pIf->mask\n");
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf->addr);
memFreePtr(pctxt, pIf);
return -1;
}
strcpy(pIf->mask, mask);
#endif
pIf->next = NULL;
/* Add to the list */
if(!*ifList)
{
*ifList = pIf;
pIf = NULL;
}
else{
pIf->next = *ifList;
*ifList = pIf;
pIf=NULL;
}
/*
#if defined(OO_FREEBSD) || defined(OO_OPENBSD) || defined(OO_NETBSD) || defined(OO_MACOSX) || defined(OO_VXWORKS) || defined(OO_RTEMS) || defined(OO_QNX)
#ifndef _SIZEOF_ADDR_IFREQ
#define _SIZEOF_ADDR_IFREQ(ifr) \
((ifr).ifr_addr.sa_len > sizeof(struct sockaddr) ? \
(sizeof(struct ifreq) - sizeof(struct sockaddr) + \
(ifr).ifr_addr.sa_len) : sizeof(struct ifreq))
#endif
ifName = (struct ifreq *)((char *)ifName + _SIZEOF_ADDR_IFREQ(*ifName));
#else
ifName++;
*/
}
}
return ASN_OK;
}
void ooTimerDelete (OOCTXT* pctxt, DList *pList, OOTimer* pTimer)
{
dListFindAndRemove (pList, pTimer);
memFreePtr (pctxt, pTimer);
}
