client.cpp

Windows CE 6.0 Server 源码

                    FAILED(hr = ::CLSIDFromProgID(V_BSTR(&PropertyValue), &m_CLSIDConnector)) ||
                    FAILED(hr = ::AtomicFreeAndCopyBSTR(m_bstrCLSIDConnector, V_BSTR(&PropertyValue))))
                {
                    ::FreeAndStoreBSTR(m_bstrCLSIDConnector, 0);
                    m_CLSIDConnector = CLSID_NULL;
                }
            }
        }
        else if (wcscmp(PropertyName, g_pwstrEncodingAttribute) == 0)
        {
            if (V_VT(&PropertyValue) == VT_BSTR)
            {
                CHK(m_bstrpreferredEncoding.Assign(V_BSTR(&PropertyValue)));
            }
        }
        else
        {       // Unknown property

            pFaultInfo->FaultMsgFromResourceHr(SOAP_IDS_CLIENT,
                SOAP_UNKNOWN_PROPERTY, CLIENT_UNKNOWN_PROPERTY, NULL, NULL);
            CHK(CLIENT_UNKNOWN_PROPERTY);

        }

    Cleanup:
        if (FAILED(hr) && pFaultInfo)
        {
            pFaultInfo->FaultMsgFromResourceHr(SOAP_IDS_CLIENT, 0, hr, NULL, NULL);
        }
        return hr;
    }        
#ifndef CE_NO_EXCEPTIONS
    catch (...)
#else
    __except(1)
#endif    
    {
        ASSERTTEXT (FALSE, "CSoapClient::put_ClientProperty - Unhandled Exception");
        return E_FAIL;
    }
}



////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CSoapClient::putref_HeaderHandler(IDispatch *pHeaderHandler)
//
//  parameters:
//
//  description:
//        Sets the header handler
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CSoapClient::putref_HeaderHandler(IDispatch *pHeaderHandler)
{
    HRESULT hr = S_OK;

    // release the old guy
    m_pHeaderHandler.Clear();

    if (pHeaderHandler)
    {
        CHK(pHeaderHandler->QueryInterface(IID_IHeaderHandler, (void**) &m_pHeaderHandler));
    }

Cleanup:
    if (FAILED(hr))
    {
        hr = E_INVALIDARG;
    }

    return (hr);
}
/////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CSoapClient::EnsureTI(LCID lcid)
//
//  parameters:
//
//  description:
//        Ensure that TypeLibrary is loaded
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CSoapClient::EnsureTI(LCID lcid)
{
    HRESULT hr = S_OK;

    if (m_pSoapClientTypeInfo == NULL)
        hr = GetTI1(lcid);

    return hr;
}


////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CSoapClient::GetTI1(LCID lcid)
//
//  parameters:
//
//  description:
//        Initializes TypeInfo
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CSoapClient::GetTI1(LCID lcid)
{
    HRESULT hr = E_FAIL;

    if (m_pSoapClientTypeInfo != NULL)
        return S_OK;

    if (m_pSoapClientTypeInfo == NULL)
    {
        CAutoRefc<ITypeLib> pTypeLib;
        hr = LoadRegTypeLib(LIBID_MSSOAPLib, 1, 0, NULL, &pTypeLib);
        if (SUCCEEDED(hr))
        {
            CAutoRefc<ITypeInfo> spTypeInfo;
            hr = pTypeLib->GetTypeInfoOfGuid(IID_ISOAPClient, &spTypeInfo);
            if (SUCCEEDED(hr))
            {
                CAutoRefc<ITypeInfo2> spTypeInfo2;
#ifndef UNDER_CE
                if (SUCCEEDED(spTypeInfo->QueryInterface(&spTypeInfo2)))
#else
                if (SUCCEEDED(spTypeInfo->QueryInterface(IID_ISOAPClient, (void **)&spTypeInfo2)))
#endif

                {
                    (spTypeInfo.PvReturn())->Release();
                    spTypeInfo = spTypeInfo2.PvReturn();
                }

#ifndef UNDER_CE
                LoadNameCache(spTypeInfo);
#else
                hr = LoadNameCache(spTypeInfo);
                if(FAILED(hr))
                    return hr;
#endif 
                if (InterlockedCompareExchange((LPLONG) &m_pSoapClientTypeInfo, (LONG) (ITypeInfo*)spTypeInfo, 0)==0)
                   {
                       m_pSoapClientTypeInfo->AddRef();
                   }
            }
        }
    }

    return hr;
}


////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CSoapClient::LoadNameCache(ITypeInfo* pTypeInfo)
//
//  parameters:
//
//  description:
//        Initializes TypeInfoMap list
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CSoapClient::LoadNameCache(ITypeInfo* pTypeInfo)
{
    TYPEATTR* pta;
    HRESULT hr = pTypeInfo->GetTypeAttr(&pta);

    if (SUCCEEDED(hr))
    {
        if (m_pTypeInfoMap == NULL)
            m_pTypeInfoMap = new CTypeInfoMap;
            
#ifdef CE_NO_EXCEPTIONS
        if(!m_pTypeInfoMap)
            return E_OUTOFMEMORY;
#endif

        for (int i = 0; i < pta->cFuncs; i++)
        {
            FUNCDESC* pfd;
            if (SUCCEEDED(pTypeInfo->GetFuncDesc(i, &pfd)))
            {
                CAutoBSTR bstrName;
                if (SUCCEEDED(pTypeInfo->GetDocumentation(pfd->memid, &bstrName, NULL, NULL, NULL)))
                {
                    LONG    clen = ::SysStringLen(bstrName);
                    m_pTypeInfoMap->Add(bstrName.PvReturn(), clen, pfd->memid);
                }
                pTypeInfo->ReleaseFuncDesc(pfd);
            }
        }
        pTypeInfo->ReleaseTypeAttr(pta);
    }

    return hr;
}



////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: STDMETHODIMP CSoapClient::GetIDsOfNames (REFIID riid, LPOLESTR* rgszNames, UINT cNames,
//                                          LCID lcid, DISPID* rgdispid)
//  parameters:
//
//  description:
//        Returns Dispid of a method, making up one as needed
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CSoapClient::GetIDsOfNames(
                REFIID riid,
                LPOLESTR* rgszNames,
                UINT cNames,
                LCID lcid,
                DISPID* rgdispid)
{
    CTypeInfoMapInfo* pTypeInfo;
    CLinkedList *pLinkIndex;

#ifndef CE_NO_EXCEPTIONS
    try
#else
    __try
#endif 
    {
        HRESULT hr = S_FALSE;

        CHK (EnsureTI(lcid));

        // process array of names
        if (m_pSoapClientTypeInfo != NULL)
        {
            // find names and fill DISPID array
            hr = S_FALSE;
            for (int i = 0; i < (int)cNames; i++)
            {
                int n = wcslen(rgszNames[i]);
                if (m_pTypeInfoMap)
                {
                    pTypeInfo = m_pTypeInfoMap->First(&pLinkIndex);
                    while (pTypeInfo)
                    {
                        if ((n == pTypeInfo->m_nLen)
                            &&
                            (wcsicmp(pTypeInfo->m_bstr, rgszNames[i]) == 0))
                        {
                            rgdispid[i] = pTypeInfo->m_id;
                            break;
                        }
                        pTypeInfo = m_pTypeInfoMap->Next(&pLinkIndex);
                    }
                    if (pTypeInfo)
                    {
                        hr = m_pSoapClientTypeInfo->GetIDsOfNames(rgszNames + i, 1, &rgdispid[i]);
                        if (FAILED(hr))
                            break;
                    }
                    else
                        hr = S_FALSE;
                }
            }
        }

        // if no method found we need to scan the current operationlist
        if (hr == S_FALSE)
        {
            ClearErrors();

            // preset result with failures...
            rgdispid[0] = DISPID_UNKNOWN;
            long lOffset = 0;
            hr = m_abstrNames.FindName( rgszNames[0], &lOffset );
            if (SUCCEEDED(hr))
            {
                // create our dispid out of the resulting offset
                rgdispid[0] = DISPID_SOAPCLIENT_UNKNOWNSTART + lOffset;
            }
            else
            {
                hr = DISP_E_UNKNOWNNAME;
            }
        }

    Cleanup:
        return hr;
    }        
#ifndef CE_NO_EXCEPTIONS
    catch (...)
#else
    __except(1)
#endif    
    {
        ASSERTTEXT (FALSE, "CSoapClient::GetIDsOfNames - Unhandled Exception");
        return E_FAIL;
    }
}


////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: STDMETHODIMP CSoapClient::Invoke(DISPID dispidMember, REFIID riid, LCID lcid,
//                                      WORD wFlags, DISPPARAMS * pdispparams, VARIANT * pvarResult,
//                                      EXCEPINFO * pexcepinfo, UINT * puArgErr)
//
//  parameters:
//
//  description:
//        Invokes the requested method
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CSoapClient::Invoke(
                DISPID dispidMember,
                REFIID riid,
                LCID lcid,
                WORD wFlags,
                DISPPARAMS * pdispparams,
                VARIANT * pvarResult,
                EXCEPINFO * pexcepinfo,
                UINT * puArgErr)
{
#ifndef CE_NO_EXCEPTIONS
    try
#else
    __try
#endif 
    {
        HRESULT hr;
        hr = EnsureTI(lcid);


        if (m_pSoapClientTypeInfo != NULL)
        {
            if (dispidMember >= DISPID_SOAPCLIENT_UNKNOWNSTART && dispidMember <= DISPID_SOAPCLIENT_UNKNOWNSTART + m_abstrNames.GetSize())
            {
                // that's our range....
                hr = InvokeUnknownMethod(
                            dispidMember,
                            pdispparams,
                            pvarResult,
                            pexcepinfo,
                            puArgErr);

            }

            else
                hr = m_pSoapClientTypeInfo->Invoke(
                            (IDispatch*)this,
                            dispidMember,
                            wFlags,
                            pdispparams,
                            pvarResult,
                            pexcepinfo,
                            puArgErr);
        }
        hr = FailedError(hr, pexcepinfo);

        return hr;
    }        
#ifndef CE_NO_EXCEPTIONS
    catch (...)
#else
    __except(1)
#endif    
    {
        ASSERTTEXT (FALSE, "SoapClient - Invoke() - Unhandled Exception");
        return E_FAIL;
    }
}


////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CSoapClient::InvokeUnknownMethod(DISPID dispid, DISPPARAMS * pdispparams,
//                          VARIANT * pvarResult, EXCEPINFO * pexcepinfo, UINT * puArgErr)
//
//  parameters:
//
//  description:
//        Invokes a method that is not in the object's type library, obtains the necessary
//        information from the WSDL file.
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CSoapClient::InvokeUnknownMethod(
                        DISPID dispid,
                        DISPPARAMS * pdispparams,
                        VARIANT * pvarResult,
                        EXCEPINFO * pexcepinfo,
                        UINT * puArgErr)
{
    HRESULT hr = S_OK;
    CAutoRefc<IWSDLOperation> pIWSDLOp;
    CAutoRefc<IStream> pIStreamIn;
    CAutoRefc<IStream> pIStreamOut;
    CAutoRefc<ISoapReader> pISoapRead;
    CAutoRefc<ISoapConnector> pSoapConnector;
    VARIANT_BOOL bSuccess;
    BOOL bHasFault;
    VARIANTARG varArg;
#ifdef UNDER_CE    
    ce::auto_bstr bstrAbstractNames = NULL;
#endif    
    CClientThreadStore *pStore = NULL;

    TRACE(("Entering Client::InvokeUnknownMethod\n"));

    VariantInit(&varArg);

    CHK(RetrieveThreadStore(&pStore, true));
    CHK(RetrieveConnector(&pSoapConnector));

    ClearErrors();

    if (!m_bflInitSuccess)
    {
        CHK(OLE_E_BLANK);    // We map this to 'not initialized error'
    }

    if (!m_pIEnumWSDLOps)
    {
        CHK(DISP_E_MEMBERNOTFOUND);
    }

    ASSERT((dispid >= DISPID_SOAPCLIENT_UNKNOWNSTART && dispid <= DISPID_SOAPCLIENT_UNKNOWNSTART + m_abstrNames.GetSize()));