mgcp_scm.c

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

                strcpy(mgCfg.mgcIpAddrStr, row[0]);

                if (!mgIsMyIP(mgCfg.mgcIpAddr)) {
                    scmPrint(( "Error: [%s] is not my IP address.\n", row[0]));
                    RETVALUE(RFAILED);                    
                }
                
            }

            mgCfg.port          = (U16)strtoul(row[1], &stopStr, 10);
            mgCfg.pktPeriodTime = strtoul(row[2], &stopStr, 10);
            strcpy(mgCfg.silenceSuppression, row[3]);
            strcpy(mgCfg.codec, row[4]);
            mgCfg.cfgPort = (U16)strtoul(row[5], &stopStr, 10);
            mgCfg.h323CsPort = (U16)strtoul(row[6], &stopStr, 10);
            mgCfg.maxCalls = (U16)strtoul(row[7], &stopStr, 10);
            mgCfg.startPort = (U16)strtoul(row[8], &stopStr, 10);
            mgCfg.use_rbt = (U16)strtoul(row[9], &stopStr, 10);
            strcpy(mgCfg.billSrvIpAddrStr, row[10]);
            mgCfg.authPort = (U16)strtoul(row[11], &stopStr, 10);
            mgCfg.acctPort = (U16)strtoul(row[12], &stopStr, 10);

            scmPrint(("------------------------------------------------\n"));
            scmPrint(("\tmgcp port\t=\t%s\n", row[1]));
            scmPrint(("\tpacket time\t=\t%s\n", row[2]));
            scmPrint(("\tsilence sup\t=\t%s\n", row[3]));
            scmPrint(("\tconfig port\t=\t%s\n", row[4]));
            scmPrint(("\tcodec\t\t=\t%s\n", row[5]));
            scmPrint(("\th323 port\t=\t%s\n", row[6]));
            scmPrint(("\tmax call\t=\t%s\n", row[7]));
            scmPrint(("\tproxy start\t=\t%s\n", row[8]));
            scmPrint(("------------------------------------------------\n"));
        }
        sqlClear(res);
    }
    else {
        scmPrint(( "SQL_CONN Error: Couldn't execute %s on the server !\n", szSQL));
    }    

    sqlConnPut(myData);

    RETVALUE(ROK);
}

/*
*
*       Fun:    mgScmLoadArea
*
*       Desc:   Load a VPBX into memory
*
*       Ret:    ROK
*               RFAILED
*
*       Notes:  None
*
*       File:   mgc_scm.c
*
*/
PUBLIC S16 mgScmLoadArea
(
mgArea  *area
)
{
	mgArea  *newArea;
    S16     ret;

    MGC_TRC(mgScmLoadArea)

    SGetSBuf(MGC_REG, MGC_POOL, (Data**)&newArea, sizeof(mgArea));
    cmMemcpy((U8 *)newArea, (CONSTANT U8 *)area, sizeof(mgVPBX));

    ret = cmHashListInsert(&mgAreaHashList, (PTR)newArea, (U8*)&newArea->areaCode, cmStrlen(newArea->areaCode));
    if (ret != ROK) {
        RETVALUE(RFAILED);
    }
    
    RETVALUE(ROK);
}

PRIVATE S16 mgScmGetAreaByCode
(
U8* areaCode,
mgArea **area
)
{
    RETVALUE(cmHashListFind(&mgAreaHashList, areaCode, cmStrlen(areaCode), 0, (PTR*)area));
}
/*
*
*       Fun:    mgScmLoadVpbx 
*
*       Desc:   Load a VPBX into memory
*
*       Ret:    ROK
*               RFAILED
*
*       Notes:  None
*
*       File:   mgc_scm.c
*
*/
PUBLIC S16 mgScmLoadVpbx
(
mgVPBX  *pbx
)
{
    mgVPBX  *vpbx; 
    S16     ret;

    MGC_TRC(mgScmLoadVpbx)


    SGetSBuf(MGC_REG, MGC_POOL, (Data**)&vpbx, sizeof(mgVPBX));
    cmMemcpy((U8 *)vpbx, (CONSTANT U8 *)pbx, sizeof(mgVPBX));

    scmPrint(("mgScmLoadVpbx(name=%s), memptr=%p).\n", pbx->name, vpbx));
    if (vpbx->dgtMap[0] == 'x') {
        vpbx->extMaxCode = '9';
        vpbx->extMinCode = '1';
    } else
    if (vpbx->dgtMap[0] == '[') {
        vpbx->extMinCode = vpbx->dgtMap[1];

        if (vpbx->dgtMap[2] == '-') {
            vpbx->extMaxCode = vpbx->dgtMap[3];
        } else {
            S16 i = 2;

            while (vpbx->dgtMap[i] != '\0') {
                if (vpbx->dgtMap[i] == ']') {
                    vpbx->extMaxCode = vpbx->dgtMap[i-1];
                    break;
                } 
                i++;    
            }
        }        
    } else {
        vpbx->extMaxCode = vpbx->extMinCode = vpbx->dgtMap[0];
	}
    
    ret = cmHashListInit(&vpbx->xListCp, 
                         32,
                         MG_GET_OFFSET(mgEndpoint, xList),
                         FALSE,
                         CM_HASH_KEYTYPE_STR,
                         MGC_REG,
                         MGC_POOL
                         );
    if (ret != ROK) {
        RETVALUE(RFAILED);
    }
    ret = cmHashListInit(&vpbx->gListCp, 
                         32,
                         MG_GET_OFFSET(mgGateway, vList),
                         FALSE,
                         CM_HASH_KEYTYPE_U32MOD,
                         MGC_REG,
                         MGC_POOL
                         );
    if (ret != ROK) {
        RETVALUE(RFAILED);
    }
    ret = cmHashListInit(&vpbx->wListCp, 
                         32,
                         MG_GET_OFFSET(mgWorkGroup, wList),
                         FALSE,
                         CM_HASH_KEYTYPE_STR,
                         MGC_REG,
                         MGC_POOL
                         );
    if (ret != ROK) {
        RETVALUE(RFAILED);
    }

    ret = cmHashListInsert(&mgVpbxHashList, (PTR)vpbx, (U8*)&vpbx->vPBXid, sizeof(U32));
    if (ret != ROK) {
        RETVALUE(RFAILED);
    }
    
    RETVALUE(ROK);
}

/*
*
*       Fun:    mgScmUnloadVpbx 
*
*       Desc:   Unload a VPBX from memory, the endpoints belong to
*               this VPBX will be moved to NULL VPBX.
*
*       Ret:    ROK
*               RFAILED
*
*       Notes:  <NONE>
*
*       File:   mgc_scm.c
*
*/
PUBLIC S16 mgScmUnloadVpbx
(
mgVPBX  *pbx
)
{
    mgGateway   *pGw;
    U32          nullId = 0;
    S16          ret;

    MGC_TRC(mgScmUnloadVpbx)

    scmPrint(("mgScmUnloadVpbx(name=%s), memptr=%p).\n", pbx->name, pbx));
 
    if (pbx->vPBXid == 0) {
        scmPrint(( "NULL VPBX cannot be unloaded.\n"));
        RETVALUE(RFAILED);
    }
    while(cmHashListGetNext(&pbx->gListCp, (PTR)NULLP, (PTR*)&pGw) == ROK) {
        ret = mgScmUnloadGw(pGw);
        if (ret != ROK) {
            scmPrint(( "Failed to unload gateway (%s) \n", pGw->dName));
            RETVALUE(RFAILED);
        }
    }
    
    ret = cmHashListDelete(&mgVpbxHashList, (PTR)pbx);
    if (ret != ROK) {
        RETVALUE(RFAILED);
    }

#if 0
    ret = cmHashListFind(&mgVpbxHashList, (U8*)&nullId, sizeof(U32), 0, (PTR *)&nullVpbx);
    if (ret != ROK) {
        scmPrint(( "OOPS: can't locate null VPBX.\n"));
        RETVALUE(RFAILED);
    }

    /* move endpoint to null VPBX */
    while(cmHashListGetNext(&pbx->xListCp, (PTR)NULLP, (PTR*)&ep) == ROK) {
        cmHashListDelete(&pbx->xListCp, (PTR) ep);
        ep->pVpbx = nullVpbx;
    }
#endif
    
    cmHashListDeinit(&pbx->xListCp);

    /* Free the memory */
    SPutSBuf(MGC_REG, MGC_POOL, (Data*)pbx, sizeof(mgVPBX));

    RETVALUE(ROK);
}

/*
*
*       Fun:    mgScmLoadGw 
*
*       Desc:   Load a Gateway into memory
*
*       Ret:    ROK
*               RFAILED
*
*       Notes:  None
*
*       File:   mgc_scm.c
*
*/
PUBLIC S16 mgScmAddGw(mgGateway *pGw) 
{
    S16     ret;

//	cmHashListDelete(&mgGwHashListId, (PTR)pGw);
    ret = cmHashListInsert(&mgGwHashListId, (PTR)pGw, (U8*)&pGw->peer.id.val, sizeof(U32));
    if (ret != ROK) {
        scmPrint(("mgScmAddGw(pGw=%p) failed\n", pGw));
        RETVALUE(RFAILED);
    } else {
        scmPrint(("mgScmAddGw(pGw=%p) sucessful, peerId=%d\n", pGw, pGw->peer.id.val));
	    RETVALUE(ROK);
    }
}

PUBLIC S16 mgScmDelGw(mgGateway *pGw) 
{
    S16     ret;
    ret = cmHashListDelete(&mgGwHashListId, (PTR)pGw);
    if (ret != ROK) {
        scmPrint(("mgScmDelGw(pGw=%p) failed\n", pGw));
        RETVALUE(RFAILED);
    } else {
        scmPrint(("mgScmDelGw(pGw=%p) sucessful, peerId=%d\n", pGw, pGw->peer.id.val));
	    RETVALUE(ROK);
    }
}

PUBLIC S16 mgScmGetGw(U32 id, mgGateway **ppGw)
{
    RETVALUE(cmHashListFind(&mgGwHashListId, (U8*)&id, sizeof(U32), 0, (PTR*)ppGw));
}

PUBLIC S16 mgScmLoadGw
(
mgGateway   *gw
)
{
    mgVPBX      *pbx = NULLP;
    mgGateway   *pGw;
    S16         ret;

    MGC_TRC(mgScmLoadGw)

    SGetSBuf(MGC_REG, MGC_POOL, (Data**)&pGw, sizeof(mgGateway));
    cmMemcpy((U8 *)pGw, (CONSTANT U8 *)gw, sizeof(mgGateway));

    scmPrint(("mgScmLoadGw(name=%s, area=%s, ptr=%p)\n", gw->dName, pGw->areaCode, pGw));

    /* Gateway IP is not set and it's not in private network */
    if ((pGw->ipAddr == 0) && pGw->bStatic) {
		/*
        CmInetIpAddrTbl addrTbl;
        ret = cmInetGetHostByName(pGw->dName, &addrTbl);
        if (ret != ROK) {
            scmPrint(( "cmInetGetHostByName for (%s) failed\n", pGw->dName));
            RETVALUE(RFAILED);
        }
        pGw->ipAddr = addrTbl.netAddr[0];
		*/
        pGw->ipAddr = (U32)rand();
    }

    if (pGw->port == 0) {
        pGw->port = MG_DEFAULT_MG_PORT;
    }
    pGw->gwid = gw->gwid;
    
    ret = cmHashListInit(&pGw->tListCp,
                         32,
                         MG_GET_OFFSET(mgEndpoint, tList),
                         FALSE,
                         CM_HASH_KEYTYPE_STR,
                         MGC_REG,
                         MGC_POOL
                         );
    if (ret != ROK) {
        RETVALUE(RFAILED);
    }

    pGw->reg        = FALSE;
    cmMemset((U8*)&pGw->peer, 0, sizeof(MgPeerInfo));
	ret = cmHashListInsert(&mgGwHashList, (PTR)pGw, _strlwr(pGw->dName), cmStrlen(pGw->dName));

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

    if (pbx->vPBXid != 0) {
        ret = cmHashListInsert(&pbx->gListCp, (PTR)pGw, &pGw->gwid, sizeof(pGw->vPBXid));
        if (ret != ROK) {
            scmPrint(( "Failed to insert gateway (%s) to the VPBX ext list.\n", pGw->dName));
            RETVALUE(RFAILED);
        }
    }
		
    pGw->pVpbx = pbx;
    RETVALUE(ROK);
}

/*
*
*       Fun:    mgScmUnloadGw 
*
*       Desc:   Unload a gateway from memory.
*
*       Ret:    ROK
*               RFAILED
*
*       Notes:  Gateway will not be released if some endpoints
*               are in call.
*
*       File:   mgc_scm.c
*
*/
PUBLIC S16 mgScmUnloadGw
(
mgGateway* gw
)
{
    mgEndpoint   *ep, *prevEp = NULLP;    
    S16          ret;
    mgVPBX     *pbx = NULLP;

    MGC_TRC(mgScmUnloadGw)

    scmPrint(("mgScmUnloadGw(name=%s, memptr=%p)\n", gw->dName, gw));
    
    GcpRmvMg(gw);
#if 0
    /* If some endpoints are in a call */
    while(cmHashListGetNext(&gw->tListCp, (PTR)prevEp, (PTR*)&ep) == ROK) {
        if(ep->primaryCall != NULLP) {
            scmPrint(( "Sorry, Can't delete a gateway while calling.\n"));
            RETVALUE(RFAILED);
        }
        prevEp = ep;
    }
#endif
    /* delete it from VPBX hash lists */
    if (gw->vPBXid != 0) {
        ret = cmHashListFind(&mgVpbxHashList, (U8*)&gw->vPBXid, sizeof(U32), 0, (PTR *)&pbx);
        if (ret == ROK) {
            ret = cmHashListDelete(&pbx->gListCp, (PTR)gw);
            if (ret != ROK) {
                scmPrint(( "Failed to delete gateway from VPBX."));
                RETVALUE(RFAILED);
            }
        }
        else {
            scmPrint(( "Failed to locate VPBX that gateway belong to.\n"));
            RETVALUE(RFAILED);
        }
    }

    while(cmHashListGetNext(&gw->tListCp, (PTR)NULLP, (PTR*)&ep) == ROK) {
        /* Note: mgScmUnloadEp will delete endpoint from termination list of the gateway.*/
        ret = mgScmUnloadEp(ep);
        if (ret != ROK) {
            scmPrint(( "Failed to unload endpoint (%s@%s) \n", ep->lclName, ep->dName));
            RETVALUE(RFAILED);
        }
    }

    if (gw->reg) {
		gw->reg = FALSE;
        ret = cmHashListDelete(&mgActiveGwHashList, (PTR)gw);
        if (ret != ROK) {
            scmPrint(("OOPS: Can't delete the gateway from active gateway list.\n"));
            RETVALUE(RFAILED);
        }
    }

    ret = cmHashListDelete(&mgGwHashList, (PTR)gw);
    if (ret != ROK) {
        scmPrint(("OOPS: Can't delete the gateway from gateway list.\n"));
        RETVALUE(RFAILED);
    }

	mgScmDelGw(gw);
	
    cmHashListDeinit(&gw->tListCp);

    /* Free the memory */
    SPutSBuf(MGC_REG, MGC_POOL, (Data*)gw, sizeof(mgGateway));

    RETVALUE(ROK);
}



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

PUBLIC S16 mgScmLoadEp
(
mgEndpoint *ep
)
{
    mgVPBX      *pbx = NULLP;
    mgGateway   *gw  = NULLP;
    mgEndpoint  *pEp = NULLP;
    S16         ret;

    /* valid checks */
    if (ep->proto >= PROTOCOL_BUTT) {
        scmPrint(( "Error: Unsupported protocol type, load canceled.\n"));
        RETVALUE(RFAILED);
    }

    SGetSBuf(MGC_REG, MGC_POOL, (Data**)&pEp, sizeof(mgEndpoint));
    cmMemcpy((U8 *)pEp, (CONSTANT U8 *)ep, sizeof(mgEndpoint));

    mgScmClearEpDynPar(pEp);

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

    if (pbx->vPBXid != 0) {
        ret = cmHashListInsert(&pbx->xListCp, (PTR)pEp, pEp->extnNum, cmStrlen(pEp->extnNum));
        if (ret != ROK) {
            scmPrint(( "Failed to insert endpoint (%s) to the VPBX ext list.\n", pEp->extnNum, pEp->vPBXid));
            RETVALUE(RFAILED);
        }
    }
    pEp->pVpbx = pbx;
        
    /* Insert endpoint to gateway hash list by local name */
    pEp->pGw = NULLP;
    ret = cmHashListFind(&mgGwHashList, _strlwr(pEp->dName), cmStrlen(pEp->dName), 0, (PTR *)&gw);
    if (ret != ROK) {
        scmPrint(( "Error, Gateway (%s) was not registered.\n", pEp->dName));
        RETVALUE(RFAILED);
    }
    
    ret = cmHashListInsert(&gw->tListCp, (PTR)pEp, _strlwr(pEp->lclName), cmStrlen(pEp->lclName));
    if (ret != ROK) {
        scmPrint(( "Failed to insert endpoint (%s) to gateway hashlist.\n", pEp->lclName));
        RETVALUE(RFAILED);