mgcp_scm.c

一个有关MGCP协议的源程序文件

    }
    pEp->pGw = gw;

    strcpy(pEp->phoneNum, pbx->vpbxCode);
    strcat(pEp->phoneNum, pEp->extnNum);
        
    ret = cmHashListInsert(&mgPnHashList, (PTR)pEp, pEp->phoneNum, cmStrlen(pEp->phoneNum));
    if (ret != ROK) {
        scmPrint(( "Failed to insert endpoint (%s) to telephone number hash list.\n", pEp->phoneNum));
        RETVALUE(RFAILED);
    }
    cmInitTimers(pEp->timers, TMR_DEF_MAX);

    mgcEpSetValid(pEp);
 
	scmPrint(("mgScmLoadEp(name=%s@%s), memptr=%p).\n", pEp->lclName, pEp->pGw->dName, pEp));
		
    RETVALUE(ROK);
}



/*
*
*       Fun:    mgScmLoadWk 
*
*       Desc:   Load a endpoint into memory
*
*       Ret:    ROK
*               RFAILED
*
*       Notes:  None
*
*       File:   mgc_scm.c
*
*/

PUBLIC S16 mgScmLoadWorkGroup
(
mgWorkGroup *wg
)
{
    mgVPBX      *pbx = NULLP;
    mgWorkGroup *pWg = NULLP;
    S16         ret;

    /* valid checks */

    SGetSBuf(MGC_REG, MGC_POOL, (Data**)&pWg, sizeof(mgWorkGroup));
    cmMemcpy((U8 *)pWg, (CONSTANT U8 *)wg, sizeof(mgWorkGroup));

    /* Insert endpoint to VPBX hash list by ext */
    pWg->pVpbx = NULLP;
    ret = cmHashListFind(&mgVpbxHashList, (U8*)&pWg->vPBXid, sizeof(U32), 0, (PTR *)&pbx);
    if (ret != ROK) {
		SPutSBuf(MGC_REG, MGC_POOL, (Data *) pWg, sizeof(mgWorkGroup));
        scmPrint(( "Error: VPBX (%d ) was not registered.\n", pWg->vPBXid));
        RETVALUE(RFAILED);
    }

    if (pbx->vPBXid != 0) {
        ret = cmHashListInsert(&pbx->wListCp, (PTR)pWg, pWg->phone, cmStrlen(pWg->phone));
        if (ret != ROK) {
            scmPrint(( "Failed to insert endpoint (%s) to the VPBX ext list.\n", pWg->phone, pWg->vPBXid));
			SPutSBuf(MGC_REG, MGC_POOL, (Data *) pWg, sizeof(mgWorkGroup));
            RETVALUE(RFAILED);
        }
    }
    pWg->pVpbx = pbx;
        
	scmPrint(("mgScmLoadWorkGroup(phone=%s@%s), memptr=%p).\n", pWg->phone, pWg));
		
    RETVALUE(ROK);
}

/*
*
*       Fun:    mgScmUnloadEp 
*
*       Desc:   Unload an endpoint from memory.
*
*       Ret:    ROK
*               RFAILED
*
*       Notes:  Endpoint will not be released if in call
*
*       File:   mgc_scm.c
*
*/
PUBLIC S16 mgScmUnloadEp
(
mgEndpoint *ep
)
{
    mgVPBX     *pbx = NULLP;
    mgGateway  *gw  = NULLP;
    S16         ret;

    MGC_TRC(mgScmUnloadEp)
    
    scmPrint(("mgScmUnloadEp(name=%s@%s), memptr=%p).\n", ep->lclName, ep->pGw->dName, ep));
    
    if (ep->primaryCall != NULLP) {
		(void*)smClearCall(ep);
#if 0
        mgcEpSetDeleteFlag(ep);
        scmPrint(( "Can't unload an endpoint while calling.\n"));
        RETVALUE(RFAILED);
#endif		
    }
  
    /* delete it from VPBX hash lists */
    if (ep->vPBXid != 0) {
        ret = cmHashListFind(&mgVpbxHashList, (U8*)&ep->vPBXid, sizeof(U32), 0, (PTR *)&pbx);
        if (ret == ROK) {
            ret = cmHashListDelete(&pbx->xListCp, (PTR)ep);
            if (ret != ROK) {
                scmPrint(( "Failed to delete endpoint from VPBX."));
                RETVALUE(RFAILED);
            }
        }
        else {
            scmPrint(( "Failed to locate VPBX that endpoint belong to.\n"));
            RETVALUE(RFAILED);
        }
    }
    
    ret = cmHashListFind(&mgGwHashList, ep->dName, cmStrlen(ep->dName), 0, (PTR *)&gw);
    if (ret != ROK) {
        scmPrint(( "Failed to locate gateway that endpoint belong to.\n"));
        RETVALUE(RFAILED);
    }
    
    ret = cmHashListDelete(&gw->tListCp, (PTR)ep);
    if (ret != ROK) {
        scmPrint(( "Failed to delete endpoint from gateway endpoint list.\n"));
        RETVALUE(RFAILED);
    }

    ret = cmHashListDelete(&mgPnHashList, (PTR)ep);
    if (ret != ROK) {
        scmPrint(( "Failed to delete endpoint from telephone number list.\n"));
        RETVALUE(RFAILED);
    }

    mgcEpClrValid(ep);
    
    /* Free the memory */
    SPutSBuf(MGC_REG, MGC_POOL, (Data*)ep, sizeof(mgEndpoint));

    RETVALUE(ROK);
}

/*
*
*       Fun:    mgScmGetEpByEpName 
*
*       Desc:   Get endpoint by localname and domain name.
*
*       Ret:    ROK
*               RFAILED
*
*       Notes:  <NONE>
*
*       File:   mgc_scm.c
*
*/
PUBLIC S16 mgScmGetEpByEpName
(
U8          *lclName, 
U8          *dname,
mgEndpoint  **ep
)
{
    mgGateway* gw;
    S16        ret;

    ret = cmHashListFind(&mgGwHashList, dname, cmStrlen(dname), 0, (PTR*)&gw);
    if (ret == ROK) {
        ret = cmHashListFind(&gw->tListCp, lclName, cmStrlen(lclName), 0, (PTR*)ep);
    }

    scmPrint(("mgScmGetEpByEpName(name=%s@%s), memptr=%p).\n", lclName, dname, *ep));

    RETVALUE(ret);    
}

/*
*
*       Fun:    mgScmGetTestEp
*
*       Desc:   Get an endpoint for test purpose
*
*       Ret:    pointer to endpoint or NULL
*
*       Notes:  <NONE>
*
*       File:   mgc_scm.c
*
*/
PUBLIC mgEndpoint* mgScmGetTestEp
(
void
)
{
    mgEndpoint  *ep = NULLP;

    if(cmHashListGetNext(&mgPnHashList, (PTR)NULLP, (PTR*)&ep) != ROK) {
        scmPrint(( "No endpoint registered\n"));
    }
    
    RETVALUE(ep);
}

/*
*
*       Fun:    mgScmGetEpByEpName 
*
*       Desc:   Get endpoint by phone number.
*
*       Ret:    ROK
*               RFAILED
*
*       Notes:  <NONE>
*
*       File:   mgc_scm.c
*
*/
PUBLIC S16 mgScmGetEpByPhoneNum
(
U8          *cpn, 
mgEndpoint  **ep
)
{
    mgEndpoint *pEndpoint;
    S16         ret;

    *ep = NULLP;
    ret = cmHashListFind(&mgPnHashList, cpn, cmStrlen(cpn), 0, (PTR*)&pEndpoint);
    if (ret == ROK) {
#if 0		
        if (pEndpoint->proto == PROTOCOL_MGCP_IVR) {
            mgIvrEndpoint *ivrEp = (mgIvrEndpoint *)pEndpoint;
            U8            ssType = ivrEp->ssType;
            
            ret = mgScmCreateDynEp("$", pEndpoint->dName,
                pEndpoint->phoneNum, pEndpoint->proto,
                sizeof(mgIvrEndpoint), (mgEndpoint **)&ivrEp);
            if (ret == ROK) {
                ivrEp->ep.pGw   = pEndpoint->pGw;
                ivrEp->ep.pVpbx = pEndpoint->pVpbx;
                ivrEp->ssType   = ssType;
                *ep = &ivrEp->ep;
            }
        } 
        else if (!mgcEpIsOccupied(pEndpoint) && mgcEpIsAvailable(pEndpoint)) {
#endif			
            *ep = pEndpoint;
		    scmPrint(("mgScmGetEpByPhoneNum(phone=%s), ep=%s@%s.\n", cpn, pEndpoint->dName, pEndpoint->lclName));
    }
	else {
		    scmPrint(("mgScmGetEpByPhoneNum(phone=%s) Failed.\n", cpn));
	}
    
    RETVALUE(ret);
}

/*
*
*       Fun:    mgScmGetEpByExtNum 
*
*       Desc:   Get endpoint by extension number from
*               a VPBX.
*
*       Ret:    ROK
*               RFAILED
*
*       Notes:  <NONE>
*
*       File:   mgc_scm.c
*
*/
PUBLIC S16 mgScmGetEpByExtNum
(
mgVPBX      *pbx, 
U8          *ext,
mgEndpoint  **ep
)
{
    RETVALUE(cmHashListFind(&pbx->xListCp, ext, cmStrlen(ext), 0, (PTR*)ep));
}

PUBLIC S16 mgScmGetWorkGroupByExtNum
(
mgVPBX      *pbx, 
U8          *ext,
mgWorkGroup **wg
)
{
    RETVALUE(cmHashListFind(&pbx->wListCp, ext, cmStrlen(ext), 0, (PTR*)wg));
}


/*
*
*       Fun:    mgScmGetGwByName 
*
*       Desc:   Get gateway by domain name.
*
*       Ret:    ROK
*               RFAILED
*
*       Notes:  <NONE>
*
*       File:   mgc_scm.c
*
*/
S16 mgScmGetGwByName
(
U8* dName, 
mgGateway** ppGw
)
{
    RETVALUE(cmHashListFind(&mgGwHashList, dName, cmStrlen(dName), 0, (PTR*)ppGw));
}

/*
*
*       Fun:    mgScmGetEpByName 
*
*       Desc:   Get endpoint by local name from a gateway
*
*       Ret:    ROK
*               RFAILED
*
*       Notes:  <NONE>
*
*       File:   mgc_scm.c
*
*/
PUBLIC S16 mgScmGetEpByName
(
mgGateway   *pGw,
U8          *lclName,
mgEndpoint  **ep
)
{
    RETVALUE(cmHashListFind(&pGw->tListCp, lclName, cmStrlen(lclName), 0, (PTR*)ep));
}

PRIVATE S16 mgScmRegSystemUpTime
(
)
{
    Txt         szSQL[1024], timeStr[64], ip_addrStr[16];
    SQL_CONN	*myData;  
    SQL_RES	    *res;
	DateTime    upTime;

	SGetDateTime(&upTime);
    DTPBUF(upTime, timeStr);
    
    myData = sqlConnGet();
    sprintf(szSQL, 
        "update gencfg_tbl set uptime=\'%s\', sysstate='0'", 
        timeStr);

    scmPrint(("[SQL] %s\n",szSQL));
    
    sqlQuery(myData, szSQL, &res); 

    sprintf(szSQL, 
        "update gateway_tbl set state='离线'");

    scmPrint(("[SQL] %s\n",szSQL));
    
    sqlQuery(myData, szSQL, &res); 

    sqlConnPut(myData);
    
}

PRIVATE S16 mgScmSetSystemUp
(
)
{
    Txt         szSQL[1024], timeStr[64], ip_addrStr[16];
    SQL_CONN	*myData;  
    SQL_RES	    *res;
	DateTime    upTime;

	SGetDateTime(&upTime);
    DTPBUF(upTime, timeStr);
    
    myData = sqlConnGet();
    sprintf(szSQL, 
        "update gencfg_tbl set sysstate='1'");

    scmPrint(("[SQL] %s\n",szSQL));
    
    sqlQuery(myData, szSQL, &res); 

    sqlConnPut(myData);
    
}

PRIVATE S16 mgScmRegGwDB
(
mgGateway *gw
)
{
    Txt         szSQL[1024], timeStr[64], ip_addrStr[16];
    SQL_CONN	*myData;  
    SQL_RES	    *res;
	U8			*byte = &gw->ipAddr;
    
    DTPBUF(gw->upTime, timeStr);
    
    myData = sqlConnGet();
	sprintf(ip_addrStr, "%d.%d.%d.%d", byte[3], byte[2], byte[1], byte[0]);
    sprintf(szSQL, 
        "update gateway_tbl set uptime=\'%s\', state=\'%s\', ip_addr=\'%s\', port=\'%d\', firmware_version= \'%s\' where dname=\'%s\'", 
        timeStr, "在线", ip_addrStr, gw->port, gw->verStr, gw->dName);

    scmPrint(("[SQL] %s\n",szSQL));
    
    sqlQuery(myData, szSQL, &res); 

    sqlConnPut(myData);
    
}

/*
*
*       Fun:    mgScmRegGw
*
*       Desc:   Register an active gateway
*
*       Ret:    ROK
*               RFAILED
*
*       Notes:  <NONE>               
*               Test case: MG register with RSIP, MG change IP, restart MG,
*               What will happen?
*
*       File:   mgc_scm.c
*
*/


PUBLIC S16 mgScmRegGw
(
mgGateway   *pGw,
MgPeerInfo  *peer
)
{

    MGC_TRC(mgScmRegGw)

    scmPrint(("mgScmRegGw(dName=%s, reg=%s).\n", pGw->dName, pGw->reg ? "yes" : "no"));
    
    if (pGw->reg == FALSE) {
        S16     ret;
        Ticks       tick;
        SGetSysTime(&tick);

        mgScmRegGwDB(pGw);
        pGw->reg = TRUE;
        pGw->auditTime = tick + GW_AUDIT_TIME_RES * TICKS_PER_SECOND;
		if (peer->id.pres == PRSNT_NODEF) {
			pGw->peer.id.val = peer->id.val;
		}
        ret = cmHashListInsert(&mgActiveGwHashList, (PTR)pGw, (U8*)&pGw->peer.id.val, sizeof(U32));
        if (ret != ROK) {
            scmPrint(("Failed to register gateway to active gateway list.\n"));
            RETVALUE(RFAILED);
        }
    }
    RETVALUE(ROK);
}
/*
PUBLIC S16 mgScmUpdateAuditTime
(
mgGateway   *pGw,
Ticks       *tick
)
{
    pGw->auditTime = tick + GW_AUDIT_TIME_RES * TICKS_PER_SECOND;
}
*/
/*
*
*       Fun:    mgScmUpdatePeer
*
*       Desc:   Update peer information and audit time for gateway
*
*       Ret:   ROK
*              RFAILED
*
*       Notes:  <NONE>               
*
*       File:   mgc_scm.c
*
*/

PUBLIC S16 mgScmUpdatePeer
(
mgGateway   *pGw,
CmTptAddr   *srcAddr
)
{
	Txt	buf[64];
	
    if (pGw == NULLP) {
        scmPrint(( "Failed to update peer information.\n"));
        RETVALUE(RFAILED);
    }

    if ( (srcAddr->u.ipv4TptAddr.address != pGw->ipAddr) || 
         (srcAddr->u.ipv4TptAddr.port != pGw->port) ||
         (pGw->reg == FALSE)) {

         SGetDateTime(&pGw->upTime);
	     DTPBUF(pGw->upTime, buf);
         scmPrint(("%s Gateway=%s Change tptAddr from %x:%d to %x:%d.\n", buf, 
                pGw->dName, pGw->ipAddr, pGw->port, srcAddr->u.ipv4TptAddr.address, srcAddr->u.ipv4TptAddr.port));
         pGw->ipAddr = srcAddr->u.ipv4TptAddr.address;
         pGw->port = srcAddr->u.ipv4TptAddr.port;
         // should write to the database later