endpointctrl.c

mgcp协议源代码和测试程序,还有一个编译器

  Assert(pEndpoint);
  Assert(pEventList);
  
//  memset(pCmd, 0, sizeof(MGCP_CMD_OUT));
  
  /* Get new command ID */
  pCmd->dwCmdId = GetNewCommandID(pEndpoint);
  *pdwNewCmdID = pCmd->dwCmdId;

  /* Piggyback commands */
  FillPiggybackCmdIDS(&pCmd->wPiggyCmdNum, pCmd->PiggybackCmdIDTable,
                      &pEndpoint->PendingCmdOutList);
  
  /* Endpoint handle */
  pCmd->hEndpointHandle = pEndpoint;

  /* Notified entity */
  CopyNotifiedEntity(&pCmd->NotifiedEntity, &pEndpoint->NotifiedEntity);


  {
	  struct in_addr tin_addr;
	  memset(&tin_addr, 0, sizeof(struct in_addr));
	  tin_addr.s_addr = htonl(pEndpoint->NotifiedEntity.pIPAddrList[pEndpoint->NotifiedEntity.wCurAddrIndex]);
	  printf("\r\n	  MgcpEndpointSendNtfyCmdOut( ... )");
	  printf("\r\n	  %s : %d", __FILE__, __LINE__);
	  printf("\r\n	  pEndpoint->NotifiedEntity.wCurAddrIndex == %d", pEndpoint->NotifiedEntity.wCurAddrIndex);
	  printf("\r\n	  pEndpoint->bNotifiedEntityProvided == %d", pEndpoint->bNotifiedEntityProvided);
	  printf("\r\n	  ip == %s : port == %d\r\n",
			 inet_ntoa(tin_addr), pEndpoint->NotifiedEntity.wPort);	  
  }


  

  /* RTO initial value */
  pCmd->dwInitRTO = CalculateRTOInitValue(pEndpoint);

  /* Command type and data */
  pCmd->eType = MGCP_CMD_NTFY;
  pCmd->u.pNtfyCmd = (MGCP_NTFY_CMD*)calloc(1, sizeof(MGCP_NTFY_CMD));
  Assert(pCmd->u.pNtfyCmd);
  
//  memset(pCmd->u.pNtfyCmd, 0, sizeof(MGCP_NTFY_CMD));
  
  /* Fill Notified Entity, only if the CA has provided */
  if (pEndpoint->bNotifiedEntityProvided)
  {
    pCmd->u.pNtfyCmd->pNotifiedEntity
      = (NOTIFIED_ENTITY*)calloc(1, sizeof(NOTIFIED_ENTITY));
    Assert(pCmd->u.pNtfyCmd->pNotifiedEntity);
	
    CopyNotifiedEntity(pCmd->u.pNtfyCmd->pNotifiedEntity,
                       &pEndpoint->NotifiedEntity);
  }

  /* Requested ID */
  Assert(pEndpoint->pcRequestedID);
  StrClone(&pCmd->u.pNtfyCmd->pcRequestIdentifier, pEndpoint->pcRequestedID);

  /* Fill observed events */
  if (pEventList->count > 0)
  {
    MGCP_OBSERVED_EVENT *pObservedEvent;

    pCmd->u.pNtfyCmd->pObservedEvents
      = (OBSERVED_EVENTS*)calloc(1, sizeof(OBSERVED_EVENTS));
    Assert(pCmd->u.pNtfyCmd->pObservedEvents);
    pCmd->u.pNtfyCmd->pObservedEvents->wNum = (WORD)pEventList->count;

    pCmd->u.pNtfyCmd->pObservedEvents->pSigReqList
      = (SIGNAL_REQUEST*)calloc((WORD)pEventList->count, sizeof(SIGNAL_REQUEST));
    Assert(pCmd->u.pNtfyCmd->pObservedEvents->pSigReqList);
    /* Fill every observed event */
    SListReset(pEventList);
    while((pObservedEvent = SListGetCurData(pEventList)) != NULL)
    {
      MGCP_EVENT_ID EventID;
      MGCP_CONNEC_ID ConnectionID;
      
	  memset(&EventID, 0, sizeof(MGCP_EVENT_ID));
	  memset(&ConnectionID, 0, sizeof(MGCP_CONNEC_ID));
	  
      EventID.eEventIdType = MGCP_EVENT_ID_SPECI;
      EventID.u.eEventID = pObservedEvent->eEventID;

      /* If connection ID of the observed event is 0, ignore it ! */
      if (pObservedEvent->dwConnecID != 0)
      {
        ConnectionID.eConnecType = CONNEC_SPECIFIC;
        ConnectionID.dwConnecID = pObservedEvent->dwConnecID;
      }
      else
      {
        ConnectionID.eConnecType = CONNEC_UNDEFINE;
      }
      
      /* Fill event name */
      TranslateMgcpEventName(&pCmd->u.pNtfyCmd->pObservedEvents->pSigReqList[i].SignalName,
                             pObservedEvent->ePkgID, &EventID, &ConnectionID);

      /* Fill event parameters (Such as OC/OF event parameters) */
      CopyEventParameters(&pCmd->u.pNtfyCmd->pObservedEvents->pSigReqList[i].SigParamList,
                          &pObservedEvent->EventParams);

      i++;
      SListNextNode(pEventList);
    }
  }
  

  /* Add the NTFY command ID into pending command out list */
  SListAppend(&pEndpoint->PendingCmdOutList, pdwNewCmdID);

  /* Check if the endpoint state is DISCONNECTED, if yes, buffer the 
     NTFY command */
  if (pEndpoint->eState == SM_DISCONNECTED)
  {
    MGCP_BUF_CMD *pBufCmd = (MGCP_BUF_CMD*)calloc(1, sizeof(MGCP_BUF_CMD));
    Assert(pBufCmd);

//	memset(pBufCmd, 0, sizeof(MGCP_BUF_CMD));
	
    pBufCmd->dwTimwDuration = TRANSAC_MANAGER_HANDLE(pEndpoint)->dwTimerMax;
    pBufCmd->pCmdOut = pCmd;
    SListAppend(&pEndpoint->BuffedCmdInDisconected, pBufCmd);
  }
  else
  {   
    MGCP_STACK_MSG Msg;

	memset(&Msg, 0, sizeof(MGCP_STACK_MSG));
    /* Fill stack message */
    Msg.eMsgCode = M_OUTGOING_CMD;
    Msg.pMsgData = pCmd;
    SendMsgToTransationManager(TRANSAC_MANAGER_HANDLE(pEndpoint), &Msg);
  }
}

/******************************************************************************
 * Function          : FillPiggybackCmdIDS
 *
 * Description       : Fill the piggybacking command ID table according to the
 *                     PendingOutCmdID list.
 *                     
 * Input parameters  : pSrc - Pointer to the PendingOutCmdID list.
 *
 * Output parameters : pwCmdNum - Piggybacking command ID number. 
 *                     pdwCmdIdTable - Piggybacking command ID table.
 *
 * Return value      : None
 *
 * Comments          : 
 *
 * History           :
 *  2005/09/20       : Creation
 *
 * Date              : Sep 20 2005, Frank Zhang
 ******************************************************************************/
void FillPiggybackCmdIDS(WORD *pwCmdNum, DWORD *pdwCmdIdTable, SLIST *pSrc)
{
  DWORD *pdwCmdID = NULL;
  
  Assert(pwCmdNum);
  Assert(pdwCmdIdTable);
  Assert(pSrc);
  Assert(*pwCmdNum == 0);

  if (pSrc != NULL && pSrc->count > 0)
  {
    SListReset(pSrc);
    while ((pdwCmdID = SListGetCurData(pSrc)) != NULL)
    {
      pdwCmdIdTable[*pwCmdNum] = *pdwCmdID;
      (*pwCmdNum)++;
      
      /* Check if piggybacking command number reach upper limit */
      if ((*pwCmdNum) >= MAX_PIGGY_MSG_NUM)
        break;

      SListNextNode(pSrc);
    }
  }
}
/******************************************************************************
 * Function          : MgcpEndpointCtrlSendRspOut
 *
 * Description       : Construct a MGCP response message and send it to
 *                     TransacMng. This function is only used when EndpointCtrl
 *                     receive a invalid MGCP command and no need to transfer it
 *                     it specific endpoint for further process.
 *                     
 * Input parameters  : pEndpntCtrl - EndpointCtrl handle.
 *                     wRspCode - Response code of the MGCP response.
 *                     pcRspString - Descripting string of the MGCP response.
 *                     dwTranID - Transaction ID of the MGCP response.
 *                     dwDesIpAddr - Destination IP address of the response.
 *                     wDesPort - Destination port of the response.
 *                     eRspType - Response type.
 *                     pRspData - Pointer to the response data.
 *
 * Output parameters : 
 *
 * Return value      : None
 *
 * Comments          : 
 *
 * History           :
 *  2005/09/21       : Creation
 *
 * Date              : Sep 21 2005, Frank Zhang
 ******************************************************************************/
void MgcpEndpointCtrlSendRspOut(H_MGCP_ENDPOINT_CONTROL pEndpntCtrl,
                                WORD wRspCode, char *pcRspString,
                                DWORD dwTranID, DWORD dwDesIpAddr,
                                WORD wDesPort, E_MGCP_RSP eRspType,
                                void *pRspData)
{
  MGCP_STACK_MSG Msg;
  MGCP_RSP_OUT *pRsp = (MGCP_RSP_OUT*)calloc(1, sizeof(MGCP_RSP_OUT));
  Assert(pRsp);
  Assert(pEndpntCtrl);

//  memset(pRsp, 0, sizeof(MGCP_RSP_OUT));
  memset(&Msg, 0, sizeof(MGCP_STACK_MSG));
  
  /* Response code */
  pRsp->wRspCode = wRspCode;

  /* Response string */
  if (pcRspString != NULL)
    StrClone(&pRsp->pcRspString, pcRspString);
  else
    StrClone(&pRsp->pcRspString, FindRspStringByCode(pRsp->wRspCode));

  /* Transaction ID */
  pRsp->dwTransacId = dwTranID;

  /* Destination address */
  pRsp->dwDesIpAddr = dwDesIpAddr;
  pRsp->wDesPort = wDesPort;

  pRsp->eType = eRspType;
  pRsp->u.pEpcfRsp = pRspData;

  Msg.eMsgCode = M_OUTGOING_RSP;
  Msg.pMsgData = pRsp;
  
  SendMsgToTransationManager((H_MGCP_TRANSAC_MANAGER)
                              pEndpntCtrl->pStack->pTransacMng, &Msg);      
}
/******************************************************************************
 * Function          : EndpointReturnSupportedPackages
 *
 * Description       : Copy the SupportedPackages of the endpoint into the
 *                     PackageList and return.
 *                     
 * Input parameters  : pEndpoint - Endpoint handle 
 *
 * Output parameters : ppPkgList - Pointer to the SupportedPackages of the
 *                                 endpoint.
 *
 * Return value      : None
 *
 * Comments          : 
 *
 * History           :
 *  2005/09/21       : Creation
 *
 * Date              : Sep 21 2005, Frank Zhang
 ******************************************************************************/
void EndpointReturnSupportedPackages(H_MGCP_ENDPOINT pEndpoint, PACKAGE_LIST **ppPkgList)
{
  PACKAGE_LIST *pTmpPkgList = NULL;
  E_MGCP_PACKAGE *pPkgID = NULL;
  MGCP_PACKAGE Package;
  WORD i = 0;

  Assert(pEndpoint);
  Assert(ppPkgList);
  Assert(pEndpoint->CapabilityList.SupportedPackages.count > 0);

  memset(&Package, 0, sizeof(MGCP_PACKAGE));
  
  /* Allocate momeries */
  pTmpPkgList = (PACKAGE_LIST*)calloc(1, sizeof(PACKAGE_LIST));
  Assert(pTmpPkgList);
//  memset(pTmpPkgList, 0, sizeof(PACKAGE_LIST));
  pTmpPkgList->wNum = (WORD)pEndpoint->CapabilityList.SupportedPackages.count;
  pTmpPkgList->pPackageList  = (PKG_NAME_AND_VERS*)calloc(pTmpPkgList->wNum,
                                                    sizeof(PKG_NAME_AND_VERS));
  Assert(pTmpPkgList->pPackageList);
//  memset(pTmpPkgList->pPackageList, 0, pTmpPkgList->wNum * sizeof(PKG_NAME_AND_VERS));
  /* Fill supported packages */
  SListReset(&pEndpoint->CapabilityList.SupportedPackages);
  while((pPkgID = SListGetCurData(&pEndpoint->CapabilityList.SupportedPackages)) != NULL)
  {
    if (FindMgcpPackageByID(&Package, *pPkgID) == OK)
    {
      StrClone(&pTmpPkgList->pPackageList[i].pcPackageName, Package.Name);
      pTmpPkgList->pPackageList[i].dwVersion = Package.dwPackageVersion;
    }

    i++;
    SListNextNode(&pEndpoint->CapabilityList.SupportedPackages);
	memset(&Package, 0, sizeof(Package));
  }

  Assert(i == pTmpPkgList->wNum);

  *ppPkgList = pTmpPkgList;
}
/******************************************************************************
 * Function          : MgcpEndpointSendRspOut
 *
 * Description       : Construct a MGCP response message and send it to
 *                     TransacMng.
 *                     
 * Input parameters  : pEndpoint - Endpoint handle.
 *                     wRspCode - Response code of the MGCP response.
 *                     pcRspString - Descripting string of the MGCP response.
 *                     dwTranID - Transaction ID of the MGCP response.
 *                     dwDesIpAddr - Destination IP address of the response.
 *                     wDesPort - Destination port of the response.
 *                     eRspType - Response type.
 *                     pRspData - Response data.
 *
 * Output parameters : 
 *
 * Return value      : None
 *
 * Comments          : 
 *
 * History           :
 *  2005/09/22       : Creation
 *
 * Date              : Sep 22 2005, Frank Zhang
 ******************************************************************************/
void MgcpEndpointSendRspOut(H_MGCP_ENDPOINT pEndpoint, WORD wRspCode,
                            char *pcRspString, DWORD dwTranID,
                            DWORD dwDesIpAddr, WORD wDesPort,
                            E_MGCP_RSP eRspType, void *pRspData)
{
  MGCP_STACK_MSG Msg;
  MGCP_RSP_OUT *pRsp = (MGCP_RSP_OUT*)calloc(1, sizeof(MGCP_RSP_OUT));
  Assert(pRsp);
  Assert(pEndpoint);

//  memset(pRsp, 0, sizeof(MGCP_RSP_OUT));
  memset(&Msg, 0, sizeof(MGCP_STACK_MSG));
  
	printf("\r\n    %s : L%d", __FILE__, __LINE__);
	printf("\r\n    MgcpEndpointSendRspOut( ... )");

  /* Response code */
  pRsp->wRspCode = wRspCode;

  /* Response string */
  if (pcRspString != NULL)
    StrClone(&pRsp->pcRspString, pcRspString);
  else
    StrClone(&pRsp->pcRspString, FindRspStringByCode(pRsp->wRspCode));

  /* Transaction ID */
  pRsp->dwTransacId = dwTranID;

  /* Piggybacking commands */
  FillPiggybackCmdIDS(&pRsp->wPiggyCmdNum, pRsp->PiggybackCmdIDTable,
                      &pEndpoint->PendingCmdOutList);
  
  /* Destination address */
  pRsp->dwDesIpAddr = dwDesIpAddr;
  pRsp->wDesPort = wDesPort;

  pRsp->eType = eRspType;
  pRsp->u.pEpcfRsp = pRspData;

  /* Check if need add the supported package list in the response; if Response
     data is NULL, firstly allocate a new response data */
  if (wRspCode == RSP_UNSUPPORTED_PACKAGE
      && ENDPOINT_CTRL_HANDLE(pEndpoint)->bReturnPackageList)
  {
    switch (pRsp->eType)
    {
      case MGCP_RSP_EPCF:        
        if (pRsp->u.pEpcfRsp == NULL)
          pRsp->u.pEpcfRsp = (MGCP_EPCF_RSP*)calloc(1, sizeof(MGCP_EPCF_RSP));