httpconnector.cpp

Windows CE 6.0 Server 源码

#else
        hr = E_FAIL;
        goto Cleanup;
#endif
    }

#ifndef UNDER_CE
    pCreate = reinterpret_cast<pfnCreateConnector>(GetProcAddress(hModDll, "CreateConnector"));
    pUnload = reinterpret_cast<pfnDllCanUnloadNow>(GetProcAddress(hModDll, "DllCanUnloadNow"));
#else
    pCreate = reinterpret_cast<pfnCreateConnector>(GetProcAddress(hModDll, L"CreateConnector"));
    pUnload = reinterpret_cast<pfnDllCanUnloadNow>(GetProcAddress(hModDll, L"DllCanUnloadNow"));
#endif

    if (pCreate == 0 || pUnload == 0)
    {
        hr = E_FAIL;
        goto Cleanup;
    }

    pRecord->bLoaded = true;
    pRecord->hModDll = hModDll; 
    pRecord->pCreate = pCreate;
    pRecord->pUnload = pUnload;
    hModDll          = 0;

Cleanup:
    if (hModDll != 0)
        ::FreeLibrary(hModDll);

    return hr;
}


////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CHttpConnector::LoadConnectorLibrary()
//
//  parameters:
//          
//  description:
//          Makes sure the appropriate HTTP connector library is loaded
//  returns:
//          
////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CHttpConnector::LoadConnectorLibrary()
{
    HRESULT                hr = E_FAIL;

    ConnectorLibraryRecord record;

    record.Clear();
   
#ifndef UNDER_CE
    OSVERSIONINFOA         vi;
    vi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
    
    if (::GetVersionExA(&vi) && vi.dwPlatformId == VER_PLATFORM_WIN32_NT)
    {
        TRACE(("Loading HttpLib Connector"));
        hr = LoadConnectorLibrary(s_HttpLibLibrary, &record);
    }

    if (FAILED(hr))
    {
        TRACE(("Loading WinInet Connector"));
        hr = LoadConnectorLibrary(s_WinInetLibrary, &record);
    }

    if (FAILED(hr))
    {
        TRACE(("Loading XmlHttp Connector"));
        hr = LoadConnectorLibrary(s_XmlHttpLibrary, &record);
    }
#else
    TRACE(("Loading WinInet Connector"));
    hr = LoadConnectorLibrary(s_WinInetLibrary, &record);
    
    if (FAILED(hr))
    {
        TRACE(("Loading XmlHttp Connector"));
        hr = LoadConnectorLibrary(s_XmlHttpLibrary, &record);
    }
#endif


    if (FAILED(hr))
    {
        goto Cleanup;
    }

    ASSERT(record.bLoaded);
    ASSERT(record.hModDll);
    ASSERT(record.pCreate);
    ASSERT(record.pUnload);

    ASSERT(s_ConnLibRec.bLoaded == false);
    ASSERT(s_ConnLibRec.hModDll == 0);
    ASSERT(s_ConnLibRec.pCreate == 0);
    ASSERT(s_ConnLibRec.pUnload == 0);

    s_ConnLibRec = record;

    hr = S_OK;

Cleanup:
    return hr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CHttpConnector::CreateConnector(REFCLSID rclsid, IUnknown *pUnkOuter, REFIID riid, void **ppvObject)
//
//  parameters:
//          
//  description:
//          Function to create platform specific HTTP connector (inner one)
//  returns:
//          
////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CHttpConnector::CreateConnector(REFCLSID rclsid, IUnknown *pUnkOuter, REFIID riid, void **ppvObject)
{
    ASSERT(pUnkOuter);
    ASSERT(ppvObject);

    HRESULT hr = S_OK;

    s_rwLock.AcquireReaderLock();

    if (s_ConnLibRec.bLoaded == false)
    {
        s_rwLock.UpgradeToWriterLock();

        if (s_ConnLibRec.bLoaded == false)              // Nobody loaded in-between
        {
#ifdef CE_NO_EXCEPTIONS
            __try{
            hr = LoadConnectorLibrary();
            }
            __except(1)
            {
                hr = E_FAIL;
            }
#else
            try   
            {
                hr = LoadConnectorLibrary();
            }

            catch(...)
            {
            }
#endif

        }

        if (FAILED(hr))
        {
            s_rwLock.ReleaseWriterLock();
            goto Cleanup;
        }
        else
        {
            s_rwLock.DowngradeFromWriterLock();
        }
    }

    // Still have reader lock

    ASSERT(s_ConnLibRec.bLoaded);
    ASSERT(s_ConnLibRec.hModDll);
    ASSERT(s_ConnLibRec.pCreate);
    ASSERT(s_ConnLibRec.pUnload);
    
#ifdef CE_NO_EXCEPTIONS
    __try
#else
    try
#endif
    {
        hr = s_ConnLibRec.pCreate(rclsid, pUnkOuter, riid, ppvObject);
    }

#ifdef CE_NO_EXCEPTIONS
    __except(1)
#else
    catch(...)
#endif

    {
    }

    s_rwLock.ReleaseReaderLock();

Cleanup:
    return hr;
}


////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT WINAPI CHttpConnector::CreateObject(IUnknown *pUnkOuter, REFIID riid, void **ppvObject)
//
//  parameters:
//          
//  description:
//          Create and ininitialize CHttpConnector depending on the plaftorm
//  returns:
//          
////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT WINAPI CHttpConnector::CreateObject(IUnknown *pUnkOuter, REFIID riid, void **ppvObject)
{
    if (! ppvObject)
        return E_INVALIDARG;
    if (pUnkOuter && riid != IID_IUnknown)
        return CLASS_E_NOAGGREGATION;

    *ppvObject = 0;

    HRESULT         hr    = S_OK;
    IUnknown       *pConn = 0;
    CHttpConnector *pObj  = new CHttpConnector(pUnkOuter, INITIAL_REFERENCE);
    if (!pObj)
        return E_OUTOFMEMORY;

    if (pUnkOuter == 0)
    {
        pUnkOuter = static_cast<IUnknown *>(pObj);
    }

    CHK(CreateConnector(CLSID_NULL, pUnkOuter, IID_IUnknown, reinterpret_cast<void **>(&pConn)));
    CHK(pObj->InitializeConnector(pConn));
    CHK(pObj->QueryInterface(riid, ppvObject));

Cleanup:
    ::ReleaseInterface((const CHttpConnector*&)pObj);
    ::ReleaseInterface((const IUnknown*&)pConn);
    return hr;
}


////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CHttpConnector::CanUnloadNow()
//
//  parameters:
//          
//  description:
//          Decides whether Connector platform specific DLL can be unloaded
//  returns:
//          
////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CHttpConnector::CanUnloadNow()
{
    HRESULT hr = S_OK;

    s_rwLock.AcquireWriterLock();

    if (s_ConnLibRec.bLoaded)
    {
        ASSERT(s_ConnLibRec.hModDll);
        ASSERT(s_ConnLibRec.pCreate);
        ASSERT(s_ConnLibRec.pUnload);

#ifdef CE_NO_EXCEPTIONS
        __try
#else
        try
#endif
        {
            hr = s_ConnLibRec.pUnload();
        }
#ifdef CE_NO_EXCEPTIONS
        __except(1)
#else
        catch (...)
#endif
        {
            s_ConnLibRec.Clear();
            hr = S_OK;
        }

        if (hr == S_OK)
        {
            if (s_ConnLibRec.hModDll)
                ::FreeLibrary(s_ConnLibRec.hModDll);

            s_ConnLibRec.Clear();
        }
    }

    s_rwLock.ReleaseWriterLock();

    return hr;
}