automationproxy.cpp

Windows CE 6.0 Server 源码

            break;
        }
    }

    if (pua)
    {
        TraceTag(ttidAutomationProxy,
                 "CUPnPAutomationProxy::LookupActionByName(): "
                 "Found %S in action table",
                 pua->strName);
    }
    else
    {
        TraceTag(ttidAutomationProxy,
                 "CUPnPAutomationProxy::LookupActionByName(): "
                 "%S does not match any action in action table",
                 pwszName);
    }

    return pua;
}


HRESULT 
CUPnPAutomationProxy::HrBuildFaultResponse(
    UPNP_CONTROL_RESPONSE_DATA * pucrd,
    LPCWSTR                    pcszFaultCode,
    LPCWSTR                    pcszFaultString,
    LPCWSTR                    pcszUPnPErrorCode,
    LPCWSTR                    pcszUPnPErrorString)
{
    HRESULT hr = S_OK;

    pucrd->Fault.bstrFaultCode = SysAllocString(pcszFaultCode);

    if (pucrd->Fault.bstrFaultCode)
    {
        pucrd->Fault.bstrFaultString = SysAllocString(pcszFaultString);

        if (pucrd->Fault.bstrFaultString)
        {
            pucrd->Fault.bstrUPnPErrorCode = SysAllocString(pcszUPnPErrorCode);

            if (pucrd->Fault.bstrUPnPErrorCode)
            {
                pucrd->Fault.bstrUPnPErrorString = SysAllocString(pcszUPnPErrorString);

                if (pucrd->Fault.bstrUPnPErrorString)
                {
                    TraceTag(ttidAutomationProxy,
                             "CUPnPAutomationProxy::HrBuildFaultResponse(): "
                             "Successfully built fault response: \n"
                             "\tFaultCode: %S\n"
                             "\tFaultString: %S\n"
                             "\tUPnPErrorCode: %S\n"
                             "\tUPnPErrorString: %S",
                             pucrd->Fault.bstrFaultCode,
                             pucrd->Fault.bstrFaultString,
                             pucrd->Fault.bstrUPnPErrorCode,
                             pucrd->Fault.bstrUPnPErrorString);
                }
                else
                {
                    hr = E_OUTOFMEMORY;
                    TraceError("CUPnPAutomationProxy::HrBuildFaultResponse(): "
                               "Failed to allocate UPnP error string",
                               hr);
                }
            }
            else
            {
                hr = E_OUTOFMEMORY;
                TraceError("CUPnPAutomationProxy::HrBuildFaultResponse(): "
                           "Failed to allocate UPnP Error code string",
                           hr);
            }
        }
        else
        {
            hr = E_OUTOFMEMORY;
            TraceError("CUPnPAutomationProxy::HrBuildFaultResponse(): "
                       "Failed to allocate fault string",
                       hr);
        }
    }
    else
    {
        hr = E_OUTOFMEMORY;
        TraceError("CUPnPAutomationProxy::HrBuildFaultResponse(): "
                   "Failed to allocate fault code string",
                   hr);
    }

    TraceError("CUPnPAutomationProxy::HrBuildFaultResponse(): "
               "Exiting",
               hr);
    return hr;
}


HRESULT 
CUPnPAutomationProxy::HrVariantInitForXMLType(VARIANT * pvar,
                                              LPCWSTR pcszDataTypeString)
{
    pvar->vt = GetVarTypeFromString(pcszDataTypeString);
    pvar->dblVal = 0;

    Assert(pvar->vt != VT_EMPTY);

    return S_OK;
}    
    

HRESULT
CUPnPAutomationProxy::StringizeVariant(VARIANT *pVar, LPCWSTR pwszType)
{
    Assert(pVar != NULL);
    Assert(pwszType != NULL);

    HRESULT         hr = S_OK;
    VARTYPE         vt = VT_ERROR;
    SST_DATA_TYPE   sdt = SDT_INVALID;

    if(!pVar)
        return E_POINTER;

    if(!pwszType)
        return E_POINTER;

    vt = GetVarTypeFromString(pwszType);
    sdt = GetTypeFromString(pwszType);

    // first make sure the variant contains a valid value
    if(FAILED(hr = VariantChangeType(pVar, pVar, 0, vt)))
        return hr;
    
    // encode the value as string
    switch(sdt)
    {
        case SDT_STRING:
        case SDT_NUMBER:
        case SDT_INT:
        case SDT_FIXED_14_4:
        case SDT_I1:
        case SDT_I2:
        case SDT_I4:
        case SDT_UI1:
        case SDT_UI2:
        case SDT_UI4:
        case SDT_R4:
        case SDT_R8:
        case SDT_FLOAT:
        case SDT_UUID:
        case SDT_URI:       // for these types standard VariantChangeType convertion is fine
                            hr = VariantChangeType(pVar, pVar, 0, VT_BSTR);
                            break;
        
        case SDT_CHAR:      Assert(pVar->vt == VT_UI2);

                            pVar->vt = VT_BSTR;
                            pVar->bstrVal = SysAllocStringLen(&V_UI2(pVar), 1);
                            
                            if(pVar->bstrVal == NULL)
                                hr = E_OUTOFMEMORY;
                            break;

        case SDT_BOOLEAN:   Assert(pVar->vt == VT_BOOL);
                            
                            // VARIANT_TRUE is -1 so change VT_BOOL variant to a VT_I4 with 1 or 0
                            if(V_BOOL(pVar) != VARIANT_FALSE)
                                pVar->lVal = 1;
                            else
                                pVar->lVal = 0;

                            pVar->vt = VT_I4;
                            
                            hr = VariantChangeType(pVar, pVar, 0, VT_BSTR);
                            break;

        case SDT_DATE_ISO8601:
        case SDT_DATETIME_ISO8601:
        case SDT_DATETIME_ISO8601TZ:
        case SDT_TIME_ISO8601:
        case SDT_TIME_ISO8601TZ:
                            
                            {
                                DataType dt = DT_NONE;

                                switch(sdt)
                                {
                                    case SDT_DATE_ISO8601:          dt = DT_DATE_ISO8601;
                                                                    break;

                                    case SDT_DATETIME_ISO8601:      dt = DT_DATETIME_ISO8601;
                                                                    break;

                                    case SDT_DATETIME_ISO8601TZ:    dt = DT_DATETIME_ISO8601TZ;
                                                                    break;

                                    case SDT_TIME_ISO8601:          dt = DT_TIME_ISO8601;
                                                                    break;

                                    case SDT_TIME_ISO8601TZ:        dt = DT_TIME_ISO8601TZ;
                                                                    break;
                                }
                            
                                Assert(dt != DT_NONE);
                                Assert(pVar->vt == VT_DATE);
                            
                                ce::wstring strValue;
                            
                                hr = UnparseISO8601(&strValue, dt, &V_DATE(pVar));

                                pVar->vt = VT_BSTR;
                                pVar->bstrVal = SysAllocString(strValue);

                                if(pVar->bstrVal == NULL)
                                    hr = E_OUTOFMEMORY;
                            }
                            break;

        case SDT_BIN_BASE64:
        case SDT_BIN_HEX:
                            {
                                Assert(pVar->vt == (VT_ARRAY | VT_UI1));
                            
                                BYTE        *pData;
                                int         cbData;
                                long        lBound, uBound;
                                ce::wstring strValue;

                                SafeArrayGetLBound(pVar->parray, 1, &lBound);
                                SafeArrayGetUBound(pVar->parray, 1, &uBound);

                                cbData = uBound - lBound + 1;

                                SafeArrayAccessData(pVar->parray, (void**)&pData);

                                if(SDT_BIN_HEX == sdt)
                                {
                                    UnparseBinHex(&strValue, pData, cbData);
                                }
                                else
                                {
                                    Assert(SDT_BIN_BASE64 == sdt);

                                    UnparseBase64(pData, cbData, &strValue);
                                }

                                SafeArrayUnaccessData(pVar->parray);

                                VariantClear(pVar);

                                pVar->vt = VT_BSTR;
                                pVar->bstrVal = SysAllocString(strValue);

                                if(pVar->bstrVal == NULL)
                                    hr = E_OUTOFMEMORY;
                            }
                            break;
    }                       

    Assert(pVar->vt == VT_BSTR);

    return hr;  
}


// Decode
HRESULT CUPnPAutomationProxy::Decode(LPCWSTR pwszValue, LPCWSTR pwszType, VARIANT* pvarValue) const
{
    Assert(pvarValue);
    Assert(pwszType);
    Assert(pwszValue);

    if(!pwszValue)
        return E_POINTER;

    if(!pwszType)
        return E_POINTER;

    if(!pvarValue)
        return E_POINTER;

    HRESULT         hr = DISP_E_TYPEMISMATCH;
    VARTYPE         vt = VT_ERROR;
    SST_DATA_TYPE   sdt = SDT_INVALID;
    ce::variant     varTemp;
    int             cch;

    vt = GetVarTypeFromString(pwszType);
    sdt = GetTypeFromString(pwszType);

    cch = wcslen(pwszValue);

    VariantClear(pvarValue);

    switch(sdt)
    {
        case SDT_STRING:
        case SDT_NUMBER:
        case SDT_INT:
        case SDT_FIXED_14_4:
        case SDT_I1:
        case SDT_I2:
        case SDT_I4:
        case SDT_UI1:
        case SDT_UI2:
        case SDT_UI4:
        case SDT_R4:
        case SDT_R8:
        case SDT_FLOAT:
        case SDT_UUID:
        case SDT_URI:       // for these types standard VariantChangeType convertion is fine
                            varTemp = pwszValue;
                            hr = VariantChangeType(pvarValue, &varTemp, 0, vt);
                            break;

        case SDT_CHAR:      Assert(pvarValue->vt == VT_EMPTY);

                            pvarValue->vt = VT_UI2;
                            V_UI2(pvarValue) = *pwszValue;

                            hr = S_OK;
                            break;

        case SDT_DATE_ISO8601:
        case SDT_DATETIME_ISO8601:
        case SDT_DATETIME_ISO8601TZ:
        case SDT_TIME_ISO8601:
        case SDT_TIME_ISO8601TZ:
                            {
                                DataType        dt  = DT_NONE;
                                const wchar_t*  pwcNext;

                                switch(sdt)
                                {
                                    case SDT_DATE_ISO8601:          dt = DT_DATE_ISO8601;
                                                                    break;

                                    case SDT_DATETIME_ISO8601:      dt = DT_DATETIME_ISO8601;
                                                                    break;

                                    case SDT_DATETIME_ISO8601TZ:    dt = DT_DATETIME_ISO8601TZ;
                                                                    break;

                                    case SDT_TIME_ISO8601:          dt = DT_TIME_ISO8601;
                                                                    break;

                                    case SDT_TIME_ISO8601TZ:        dt = DT_TIME_ISO8601TZ;
                                                                    break;
                                }
                            
                                Assert(dt != DT_NONE);

                                if(SUCCEEDED(hr = ParseISO8601(pwszValue, cch, dt, &V_DATE(pvarValue), &pwcNext)))
                                    pvarValue->vt = VT_DATE;
                            }
                            break;

        case SDT_BIN_BASE64:
        case SDT_BIN_HEX:   {
                                Assert(pvarValue->vt == VT_EMPTY);
                            
                                SAFEARRAY       *psa;
                                SAFEARRAYBOUND  rgsabound[1];
                                BYTE            *pData;
                                int             cbData;
                                const wchar_t*  pwcNext;
                                
                                if(SDT_BIN_HEX == sdt)
                                {
                                    cbData = (cch + 1)/2;
                                }
                                else
                                {
                                    Assert(SDT_BIN_BASE64 == sdt);

                                    cbData = cch;
                                }
                                
                                rgsabound[0].lLbound = 0;
                                rgsabound[0].cElements = cbData;