ooh323.c

来自「一个非常美妙的proxy。功能强大。基于sip的协议。如果还要的话」· C语言 代码 · 共 1,721 行 · 第 1/5 页

            pmsg = (H245Message*)memAlloc(pctxt, sizeof(H245Message));
            if(!pmsg)
            {
               OOTRACEERR3("Error:Memory - ooHandleH245TunneledMessages - pmsg"
                          "(%s, %s)\n", call->callType, call->callToken);
               return OO_FAILED;
            }

	    setPERBuffer(pctxt, 
			 (ASN1OCTET*)pH323UUPdu->h245Control.elem[i].data,
                         pH323UUPdu->h245Control.elem[i].numocts, 1);  

            initializePrintHandler(&printHandler, "Tunneled H.245 Message");
	    memset(pmsg, 0, sizeof(H245Message));
            /* Set event handler */
            setEventHandler (pctxt, &printHandler);
            OOTRACEDBGC4("Decoding %d tunneled H245 message. (%s, %s)\n", 
                          i+1, call->callType, call->callToken);
            ret = asn1PD_H245MultimediaSystemControlMessage(pctxt, 
                                                            &(pmsg->h245Msg));
            if(ret != ASN_OK)
            {
               OOTRACEERR3("Error decoding H245 message (%s, %s)\n", 
                            call->callType, call->callToken);
               ooFreeH245Message(call,pmsg);
               return OO_FAILED;
            }
            finishPrint();
            removeEventHandler (pctxt);
            ooHandleH245Message(call, pmsg);
            memFreePtr(pctxt, pmsg);
            pmsg = NULL;
         }/* End of For loop */
      }/* End of if(h245Tunneling) */
   }
   return OO_OK;
}

int ooH323RetrieveAliases
   (OOH323CallData *call, H225_SeqOfH225AliasAddress *pAddresses, 
    OOAliases **aliasList)
{
   int i=0,j=0,k=0;
   DListNode* pNode=NULL;
   H225AliasAddress *pAliasAddress=NULL;
   OOAliases *newAlias=NULL;
   H225TransportAddress *pTransportAddrss=NULL;

   if(!pAddresses)
   {
      OOTRACEWARN3("Warn:No Aliases present (%s, %s)\n", call->callType, 
                    call->callToken);
      return OO_OK;
   }
   /* check for aliases */
   if(pAddresses->count<=0)
      return OO_OK;
   
   for(i=0; i<(int)pAddresses->count; i++)
   {
      pNode = dListFindByIndex (pAddresses, i);

      if(!pNode)
         continue;

      pAliasAddress = (H225AliasAddress*)pNode->data;

      if(!pAliasAddress)
         continue;

      newAlias = (OOAliases*)memAlloc(call->pctxt, sizeof(OOAliases));
      if(!newAlias)
      {
         OOTRACEERR3("ERROR:Memory - ooH323RetrieveAliases - newAlias "
                     "(%s, %s)\n", call->callType, call->callToken);
         return OO_FAILED;
      }
      memset(newAlias, 0, sizeof(OOAliases));
      switch(pAliasAddress->t)
      {
      case T_H225AliasAddress_dialedDigits:
         newAlias->type = T_H225AliasAddress_dialedDigits;
         newAlias->value = (char*) memAlloc(call->pctxt, 
                         strlen(pAliasAddress->u.dialedDigits)*sizeof(char)+1);
         if(!newAlias->value)
         {
            OOTRACEERR3("ERROR:Memory - ooH323RetrieveAliases - "
                        "newAlias->value(dialedDigits) (%s, %s)\n", 
                         call->callType, call->callToken);
            memFreePtr(call->pctxt, newAlias);  
            return OO_FAILED;
         }

         memcpy(newAlias->value, pAliasAddress->u.dialedDigits,
                           strlen(pAliasAddress->u.dialedDigits)*sizeof(char));
         newAlias->value[strlen(pAliasAddress->u.dialedDigits)*sizeof(char)]='\0';
         break;
      case T_H225AliasAddress_h323_ID:
         newAlias->type = T_H225AliasAddress_h323_ID;
         newAlias->value = (char*)memAlloc(call->pctxt, 
                         (pAliasAddress->u.h323_ID.nchars+1)*sizeof(char)+1);
         if(!newAlias->value)
         {
            OOTRACEERR3("ERROR:Memory - ooH323RetrieveAliases - "
                        "newAlias->value(h323id) (%s, %s)\n", call->callType, 
                         call->callToken);
            memFreePtr(call->pctxt, newAlias);  
            return OO_FAILED;
         }

         for(j=0, k=0; j<(int)pAliasAddress->u.h323_ID.nchars; j++)
         {
            if(pAliasAddress->u.h323_ID.data[j] < 256)
            {
               newAlias->value[k++] = (char) pAliasAddress->u.h323_ID.data[j];
            }
         }
         newAlias->value[k] = '\0';
         break;   
      case T_H225AliasAddress_url_ID:
         newAlias->type = T_H225AliasAddress_url_ID;
         newAlias->value = (char*)memAlloc(call->pctxt,
                              strlen(pAliasAddress->u.url_ID)*sizeof(char)+1);
         if(!newAlias->value)
         {
            OOTRACEERR3("ERROR:Memory - ooH323RetrieveAliases - "
                        "newAlias->value(urlid) (%s, %s)\n", call->callType, 
                         call->callToken);
            memFreePtr(call->pctxt, newAlias);  
            return OO_FAILED;
         }

         memcpy(newAlias->value, pAliasAddress->u.url_ID,
                               strlen(pAliasAddress->u.url_ID)*sizeof(char));
         newAlias->value[strlen(pAliasAddress->u.url_ID)*sizeof(char)]='\0';
         break;
      case T_H225AliasAddress_transportID:
         newAlias->type = T_H225AliasAddress_transportID;
         pTransportAddrss = pAliasAddress->u.transportID;
         if(pTransportAddrss->t != T_H225TransportAddress_ipAddress)
         {
            OOTRACEERR3("Error:Alias transportID not an IP address"
                        "(%s, %s)\n", call->callType, call->callToken);
            memFreePtr(call->pctxt, newAlias);
            break;
         }
         /* hopefully ip:port value can't exceed more than 30 
            characters */
         newAlias->value = (char*)memAlloc(call->pctxt, 
                                                      30*sizeof(char));
         sprintf(newAlias->value, "%d.%d.%d.%d:%d", 
                                  pTransportAddrss->u.ipAddress->ip.data[0],
                                  pTransportAddrss->u.ipAddress->ip.data[1],
                                  pTransportAddrss->u.ipAddress->ip.data[2],
                                  pTransportAddrss->u.ipAddress->ip.data[3],
                                  pTransportAddrss->u.ipAddress->port);
         break;
      case T_H225AliasAddress_email_ID:
         newAlias->type = T_H225AliasAddress_email_ID;
         newAlias->value = (char*)memAlloc(call->pctxt, 
                             strlen(pAliasAddress->u.email_ID)*sizeof(char)+1);
         if(!newAlias->value)
         {
            OOTRACEERR3("ERROR:Memory - ooH323RetrieveAliases - "
                        "newAlias->value(emailid) (%s, %s)\n", call->callType, 
                         call->callToken);
            memFreePtr(call->pctxt, newAlias);  
            return OO_FAILED;
         }

         memcpy(newAlias->value, pAliasAddress->u.email_ID,
                              strlen(pAliasAddress->u.email_ID)*sizeof(char));
         newAlias->value[strlen(pAliasAddress->u.email_ID)*sizeof(char)]='\0';
         break;
      default:
         OOTRACEERR3("Error:Unhandled Alias type (%s, %s)\n", 
                       call->callType, call->callToken);
         memFreePtr(call->pctxt, newAlias);
         continue;
      }

      newAlias->next = *aliasList;
      *aliasList = newAlias;

      newAlias = NULL;
     
     pAliasAddress = NULL;
     pNode = NULL;
   }/* endof: for */
   return OO_OK;
}


int ooPopulateAliasList(OOCTXT *pctxt, OOAliases *pAliases,
                           H225_SeqOfH225AliasAddress *pAliasList )
{
   H225AliasAddress *pAliasEntry=NULL;
   OOAliases * pAlias=NULL;
   ASN1BOOL bValid=FALSE;
   int i = 0;

   dListInit(pAliasList);
   if(pAliases)
   {
      pAlias = pAliases;
      while(pAlias)
      {
         pAliasEntry = (H225AliasAddress*)memAlloc(pctxt, 
                                                     sizeof(H225AliasAddress));
         if(!pAliasEntry)
         {
            OOTRACEERR1("ERROR:Memory - ooPopulateAliasList - pAliasEntry\n");
            return OO_FAILED;
         }
         switch(pAlias->type)
         {
         case T_H225AliasAddress_dialedDigits:
            pAliasEntry->t = T_H225AliasAddress_dialedDigits;
            pAliasEntry->u.dialedDigits = (ASN1IA5String)memAlloc(pctxt,
                                                     strlen(pAlias->value)+1);
            if(!pAliasEntry->u.dialedDigits)
            {
               OOTRACEERR1("ERROR:Memory - ooPopulateAliasList - "
                           "dialedDigits\n");
               memFreePtr(pctxt, pAliasEntry);
               return OO_FAILED;
            }
            strcpy((char*)pAliasEntry->u.dialedDigits, pAlias->value);
            bValid = TRUE;
            break;
         case T_H225AliasAddress_h323_ID:
            pAliasEntry->t = T_H225AliasAddress_h323_ID;
            pAliasEntry->u.h323_ID.nchars = strlen(pAlias->value);
            pAliasEntry->u.h323_ID.data = (ASN116BITCHAR*)memAllocZ
                     (pctxt, strlen(pAlias->value)*sizeof(ASN116BITCHAR));
            
            if(!pAliasEntry->u.h323_ID.data)
            {
               OOTRACEERR1("ERROR:Memory - ooPopulateAliasList - h323_id\n");
               memFreePtr(pctxt, pAliasEntry);
               return OO_FAILED;
            }
            for(i=0; *(pAlias->value+i) != '\0'; i++)
               pAliasEntry->u.h323_ID.data[i] =(ASN116BITCHAR)pAlias->value[i];
            bValid = TRUE;
            break;
         case T_H225AliasAddress_url_ID:
            pAliasEntry->t = T_H225AliasAddress_url_ID;
            pAliasEntry->u.url_ID = (ASN1IA5String)memAlloc(pctxt, 
                                                     strlen(pAlias->value)+1);
            if(!pAliasEntry->u.url_ID)
            {
               OOTRACEERR1("ERROR:Memory - ooPopulateAliasList - url_id\n");
               memFreePtr(pctxt, pAliasEntry);               
               return OO_FAILED;
            }
            strcpy((char*)pAliasEntry->u.url_ID, pAlias->value);
            bValid = TRUE;
            break;
         case T_H225AliasAddress_email_ID:
            pAliasEntry->t = T_H225AliasAddress_email_ID;
            pAliasEntry->u.email_ID = (ASN1IA5String)memAlloc(pctxt, 
                                                     strlen(pAlias->value)+1);
            if(!pAliasEntry->u.email_ID)
            {
               OOTRACEERR1("ERROR: Failed to allocate memory for EmailID "
                           "alias entry \n");
               return OO_FAILED;
            }
            strcpy((char*)pAliasEntry->u.email_ID, pAlias->value);
            bValid = TRUE;
            break;
         default:
            OOTRACEERR1("ERROR: Unhandled alias type\n");
            bValid = FALSE;                  
         }
         
         if(bValid)
            dListAppend( pctxt, pAliasList, (void*)pAliasEntry );
         else
            memFreePtr(pctxt, pAliasEntry);
         
         pAlias = pAlias->next;
      }
   }
   return OO_OK;
}


OOAliases* ooH323GetAliasFromList(OOAliases *aliasList, int type, char *value)
{

   OOAliases *pAlias = NULL;

   if(!aliasList)
   {
      OOTRACEDBGC1("No alias List to search\n");
      return NULL;
   }

   pAlias = aliasList;

   while(pAlias)
   {
     if(type != 0 && value)/* Search by type and value */
      {
	 if(pAlias->type == type && !strcmp(pAlias->value, value))
         {
            return pAlias;
         }
      }else if(type != 0 && !value)/* search by type */
      {
         if(pAlias->type == type)
            return pAlias;
      }
      else if(type == 0 && value) /* search by value */
      {
         if(!strcmp(pAlias->value, value))
            return pAlias;
      }
      else{
         OOTRACEDBGC1("No criteria to search the alias list\n");
         return NULL;
      }
      pAlias = pAlias->next;
   }

   return NULL;
}

OOAliases* ooH323AddAliasToList
(OOAliases **pAliasList, OOCTXT *pctxt, H225AliasAddress *pAliasAddress)
{
   int j=0,k=0;
   OOAliases *newAlias=NULL;
   H225TransportAddress *pTransportAddrss=NULL;
   
   newAlias = (OOAliases*) memAlloc(pctxt, sizeof(OOAliases));
   if(!newAlias)
   {
      OOTRACEERR1("Error: Failed to alloc