capiclnt.c

是一个手机功能的模拟程序

            return;
        memcpy(sz, contentType, len);
    }
    var.Param8 = sz;
    var.Param9 = sendMode;
    sz = NULL;
    if (contentDisp)
    {
        len = strlen(contentDisp);
        /*  Add one extra byte for the terminating zero.*/
        sz = (CHAR*)OSConnectorAlloc(++len);
        if (!sz)
            return;
        memcpy(sz, contentDisp, len);
    }
    var.Param10 = sz;
	var.Param11 = totalSize;
    
    XMK_SEND_ENV( ENV,
                  PostContent,
                  xDefaultPrioSignal,
                  sizeof( yPDef_PostContent ),
                  &var,
                  GLOBALPID(XPTID_CONT_UA,0));
}

EXPORT_C VOID    CLNTc_postMoreContent (UINT8 urlID, const CHAR *data, UINT16 dataLen, BOOL moreData)
{
	XMK_SEND_TMP_VARS

    yPDef_PostMoreContent var;
    CHAR *pCHAR;

#if     defined LOG_EXTERNAL
    {
        CLNTa_log(0, 0, "CLNTc_postMoreContent\nUINT8 \t urlID \t %u\nUINT16 \t dataLen \t %u\nBOOL \t moreData \t %u\n", (int)urlID, (int)dataLen, (int)moreData);
    }
#endif

    var.Param1 = urlID;

    pCHAR = NULL;
    if (dataLen)
    {
        if (data)
        {
            pCHAR = (CHAR*)OSConnectorAlloc(dataLen);
            if (!pCHAR)
                return;
            memcpy(pCHAR, data, dataLen);
        }
        else
        {
            dataLen = 0;
        }
    }
    var.Param2 = pCHAR;
    var.Param3 = dataLen;
	var.Param4 = moreData;
    
    XMK_SEND_ENV( ENV,
                  PostMoreContent,
                  xDefaultPrioSignal,
                  sizeof( yPDef_PostMoreContent ),
                  &var,
                  GLOBALPID(XPTID_CONT_UA,0));
}

EXPORT_C VOID    CLNTc_acknowledgeContent (UINT8 urlID)
{
	XMK_SEND_TMP_VARS

	yPDef_AcknowledgeContent var;

#if     defined LOG_EXTERNAL
    {
        CLNTa_log(0, 0, "CLNTc_acknowledgeContent\nUINT8 \t urlID \t %u\n", (int)urlID);
    }
#endif

    var.Param1 = urlID;
    
    XMK_SEND_ENV( ENV,
                  AcknowledgeContent,
                  xDefaultPrioSignal,
                  sizeof( yPDef_AcknowledgeContent ),
                  &var,
                  GLOBALPID(XPTID_CONT_UA,0));
}

EXPORT_C VOID    CLNTc_cancelContent (UINT8 urlID)
{
	XMK_SEND_TMP_VARS

    yPDef_CancelContent var;

#if     defined LOG_EXTERNAL
    {
        CLNTa_log(0, 0, "CLNTc_cancelContent\nUINT8 \t urlID \t %u\n", (int)urlID);
    }
#endif

    var.Param1 = urlID;
    
    XMK_SEND_ENV( ENV,
                  CancelContent,
                  xDefaultPrioSignal,
                  sizeof( yPDef_CancelContent ),
                  &var,
                  GLOBALPID(XPTID_CONT_UA,0));
}


EXPORT_C VOID    CLNTc_setTranscoders (
fPtr_Iana2Unicode_canConvert canConvert,
fPtr_Iana2Unicode_calcLen calcLen,
fPtr_Iana2Unicode_convert convert,
fPtr_Iana2Unicode_getNullTermByteLen nullLen)
{
#if     defined LOG_EXTERNAL
    {
        CLNTa_log(0, 0, "CLNTc_setTranscoders\nfPtr_Iana2Unicode_canConvert \t canConvert \t %p\nfPtr_Iana2Unicode_calcLen \t calcLen \t %p\nfPtr_Iana2Unicode_convert \t convert \t %p\nfPtr_Iana2Unicode_getNullTermByteLen \t nullLen \t %p\n", canConvert, calcLen, convert, nullLen);
    }
#endif

    Iana2Unicode_setFuncPtrs(canConvert, calcLen, convert, nullLen);
}


EXPORT_C VOID    CLNTc_requestConnectionDone (UINT8 objectId, BOOL success )
{
	XMK_SEND_TMP_VARS

	yPDef_RequestConnectionDone var;

    var.Param1 = objectId;
    var.Param2 = success;

    XMK_SEND_ENV( ENV,
                  RequestConnectionDone,
                  xDefaultPrioSignal,
                  sizeof( yPDef_RequestConnectionDone ),
                  &var,
                  GLOBALPID(XPTID_RES_ME,0));
}


EXPORT_C VOID    CLNTc_setupConnectionDone (UINT8 objectId, UINT8 channelId, BOOL success )
{
	XMK_SEND_TMP_VARS

	yPDef_SetupConnectionDone var;

    var.Param1 = objectId;
	var.Param2 = channelId;
    var.Param3 = success;

    XMK_SEND_ENV( ENV,
                  SetupConnectionDone,
                  xDefaultPrioSignal,
                  sizeof( yPDef_SetupConnectionDone ),
                  &var,
                  GLOBALPID(XPTID_RES_ME,0));
}

EXPORT_C VOID    CLNTc_closeConnection (UINT8 objectId, UINT8 channelId, BOOL deleteChannel )
{
	XMK_SEND_TMP_VARS

	yPDef_CloseConnection var;
 
    var.Param1 = objectId;
	var.Param2 = channelId;
    var.Param3 = deleteChannel;

    XMK_SEND_ENV( ENV,
                  CloseConnection,
                  xDefaultPrioSignal,
                  sizeof( yPDef_CloseConnection ),
                  &var,
                  GLOBALPID(XPTID_RES_ME,0));
}

/* Provisioning connectors */

EXPORT_C VOID    CLNTc_decodeProvisioningData (const CHAR *data, UINT32 dataLen)
{
	XMK_SEND_TMP_VARS

	 CHAR    *pCHAR;

	yPDef_InputStringProvE2Esec var;

	pCHAR = NULL;
    if (dataLen)
    {
        if (data)
        {
            pCHAR = (CHAR*)OSConnectorAlloc(dataLen);
            if (!pCHAR)
                return;
            memcpy(pCHAR, data, (UINT16)dataLen);
        }
        else
        {
            dataLen = 0;
        }
    }

    var.Param1 = pCHAR;
    var.Param2 = dataLen;
	var.Param3 = -1;
	var.Param4 = -1;
	var.Param5 = 0;
	var.Param6 = 0;
	var.Param7 = NULL;

    XMK_SEND_ENV( ENV,
                  InputStringProvE2Esec,
                  xDefaultPrioSignal,
                  sizeof( yPDef_InputStringProvE2Esec ),
                  &var,
                  GLOBALPID(XPTID_PROV_UA,0));
}


EXPORT_C VOID    CLNTc_e2eSecurityCnfgrd (UINT8 id, BOOL success )
{
	XMK_SEND_TMP_VARS

	yPDef_E2ESecurityConfigured var;
 
    var.Param1 = id;
	var.Param2 = success;

    XMK_SEND_ENV( ENV,
                  E2ESecurityConfigured,
                  xDefaultPrioSignal,
                  sizeof( yPDef_E2ESecurityConfigured ),
                  &var,
                  GLOBALPID(XPTID_RES_ME,0));
}


EXPORT_C VOID    CLNTc_provSharedSecret (UINT16 iListID, CHAR* vcSharedSecret, UINT16 iLenSharedSecret, BOOL bLastTry)
{
	XMK_SEND_TMP_VARS

	 CHAR    *pCHAR;

	yPDef_ProvSharedSecret var;

	pCHAR = NULL;
    if (iLenSharedSecret)
    {
        if (vcSharedSecret)
        {
            pCHAR = (CHAR*)OSConnectorAlloc(iLenSharedSecret);
            if (!pCHAR)
                return;
            memcpy(pCHAR, vcSharedSecret, (UINT16)iLenSharedSecret);
        }
        else
        {
            iLenSharedSecret = 0;
        }
    }

    var.Param1 = iListID;
    var.Param2 = pCHAR;
	var.Param3 = iLenSharedSecret;
	var.Param4 = bLastTry;

    XMK_SEND_ENV( ENV,
                  ProvSharedSecret,
                  xDefaultPrioSignal,
                  sizeof( yPDef_ProvSharedSecret ),
                  &var,
                  GLOBALPID(XPTID_PROV_UA,0));
}
/* End provisioning connectors */


#ifdef USE_PROPRIETARY_WMLS_LIBS

EXPORT_C VOID    CLNTc_WMLSLibFuncResponse(UINT16 invokeId, const WMLSvar *resultVar)
{
	XMK_SEND_TMP_VARS

	yPDef_WMLSLibFuncResponse var;
    WMLSvar *pWMLSvar;

#if     defined LOG_EXTERNAL
    {
        char    szFormat[256];
        size_t  strlength, end = 0;
        const char  *csz;

        strlength = strlen(csz = "CLNTc_WMLSLibFuncResponse\nUINT16 \t invokeId \t %u\nconst \t WMLSvar * \t resultVar \t %p\n \t ");
        strncpy(&szFormat[end], csz, strlength);
        end += strlength;
        if (resultVar)
        {
            strlength = strlen(csz = "UINT8 \t type \t %u\n \t ");
            strncpy(&szFormat[end], csz, strlength);
            end += strlength;
            switch (resultVar->type)
            {
                case 0: /* = integer */
                    strlength = strlen(csz = "INT32 \t intVal \t %i\n");
                    strncpy(&szFormat[end], csz, strlength);
                    end += strlength;
                    szFormat[end] = '\0';
                    CLNTa_log(0, 0, szFormat, (int)invokeId, resultVar, (int)resultVar->type, (int)resultVar->intVal);
                    break;
                case 1: /* = float */
                    strlength = strlen(csz = "FLOAT32 \t floatVal \t %f\n");
                    strncpy(&szFormat[end], csz, strlength);
                    end += strlength;
                    szFormat[end] = '\0';
                    CLNTa_log(0, 0, szFormat, (int)invokeId, resultVar, (int)resultVar->type, (float)resultVar->floatVal);
                    break;
                case 2: /* = string */
                    strlength = strlen(csz = "INT16 \t stringIANAcharset \t %i\n \t UINT32 \t stringLengthInBytes \t %u\n \t CHAR * \t stringVal \t %p\n");
                    strncpy(&szFormat[end], csz, strlength);
                    end += strlength;
                    if (!resultVar->stringVal)
                    {
                        strlength = strlen(csz = " \t ");
                        strncpy(&szFormat[end], csz, strlength);
                        end += strlength;
                        strlength = strlen(csz = cszNULL);
                        strncpy(&szFormat[end], csz, strlength);
                        end += strlength;
                    }
                    szFormat[end] = '\0';
                    CLNTa_log(0, 0, szFormat, (int)invokeId, resultVar, (int)resultVar->type, (int)resultVar->stringIANAcharset, (int)resultVar->stringLengthInBytes, resultVar->stringVal);
                    break;
                case 3: /* = boolean */
                    strlength = strlen(csz = "BOOL \t boolVal \t %u\n");
                    strncpy(&szFormat[end], csz, strlength);
                    end += strlength;
                    szFormat[end] = '\0';
                    CLNTa_log(0, 0, szFormat, (int)invokeId, resultVar, (int)resultVar->type, (int)resultVar->boolVal);
                    break;
                case 4: /* = invalid */
                    strlength = strlen(csz = " \t (invalid)\n");
                    strncpy(&szFormat[end], csz, strlength);
                    end += strlength;
                    szFormat[end] = '\0';
                    CLNTa_log(0, 0, szFormat, (int)invokeId, resultVar, (int)resultVar->type);
                    break;
                default:
                    strlength = strlen(csz = " \t (Currently not a supported type.)\n");
                    strncpy(&szFormat[end], csz, strlength);
                    end += strlength;
                    szFormat[end] = '\0';
                    CLNTa_log(0, 0, szFormat, (int)invokeId, resultVar, (int)resultVar->type);
                    break;
            }
        }
        else
        {
            strlength = strlen(csz = cszNULL);
            strncpy(&szFormat[end], csz, strlength);
            end += strlength;
        }

        szFormat[end] = '\0';
        CLNTa_log(0, 0, szFormat, (int)invokeId, resultVar);
    }
#endif

    var.Param1 = invokeId;

    pWMLSvar = (WMLSvar*)OSConnectorAlloc(sizeof(WMLSvar));
    if (!pWMLSvar)
        return;
    memcpy(pWMLSvar, resultVar, sizeof(WMLSvar));
    pWMLSvar->stringVal = NULL; /*  Is this necessary? See declaration of struct in tapiclnt.h */
    if (resultVar->type == 2)
    {
        size_t  len = (size_t)(resultVar->stringLengthInBytes) * sizeof(CHAR);  /* memcpy only accepts size_t anyway */
        CHAR    *pCHAR = (CHAR*)OSConnectorAlloc(len);
        if (!pCHAR)
            return;
        memcpy(pCHAR, resultVar->stringVal, len);
        pWMLSvar->stringVal = pCHAR;
    }
    var.Param2 = pWMLSvar;

    XMK_SEND_ENV( ENV,
                  WMLSLibFuncResponse,
                  xDefaultPrioSignal,
                  sizeof( yPDef_WMLSLibFuncResponse ),
                  &var,
                  GLOBALPID(XPTID_WMLS_SM,0));
}

#endif