request.cpp

Windows CE 6.0 Server 源码

    case OBJ_ACCESS_DENIED:
        // Current user does not have access permissions to these files
        hr = E_ACCESSDENIED;
        m_pIStreamOut.SetErrorCode(Error_AccessDenied);
        return hr;
    case OBJ_STALE:
        // Files have been modified since last use here
    case OBJ_NOTFOUND:
        ASSERT(pCachedObj == NULL);
        break;
    }

    if (!pCachedObj)
    {
        // Object not in cache. We need to create one
        CHK(InitObjectForCache(&pCachedObj));
        CHK(pObjCache->Insert(m_pszWSDLFilePath, (void *) pCachedObj))
    }
    CHK(bstrSoapAction.Assign(GetHeaderParam("SOAPAction"), FALSE));
    ASSERT(pCachedObj);
    
    V_VT(&varInput) = VT_UNKNOWN;
    V_UNKNOWN(&varInput) = &m_pIStreamIn;

    CHK(m_pIStreamOut.QueryInterface(IID_IStream, (void **) &pIStrmOut));
    hr = pCachedObj->ISoapServer()->SoapInvoke(varInput, pIStrmOut, bstrSoapAction);
    
Cleanup:
    return hr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: CRequest::InitObjectForCache(CThdCachedObj ** ppCachedObj)
//
//  parameters:
//          
//  description:
//
//  returns:
//          
////////////////////////////////////////////////////////////////////////////////////////////////////

HRESULT CRequest::InitObjectForCache(CThdCachedObj ** ppCachedObj)
{
    HRESULT     hr = S_OK;
    CThdCachedObj *pCachedObj = NULL;
    CAutoRefc<ISOAPServer> pISoapServer;
    CAutoBSTR       bstrWSDL;
    CAutoBSTR       bstrWSML;
    DWORD           wchApplPath = FOURK;
    
#ifndef UNDER_CE
    WCHAR           wszApplPath[FOURK+1];
    FILETIME *      pFTWSDL;
    FILETIME *      pFTWSML;
#else
    WCHAR          *wszApplPath = new WCHAR[FOURK+1];
#endif 


    *ppCachedObj = NULL;
    
    // Create the SOAPServer object for this
    hr = CoCreateInstance(CLSID_SoapServer, NULL,
        CLSCTX_INPROC_SERVER, IID_ISOAPServer, (LPVOID*)&pISoapServer);
    if (hr != S_OK)
    {
        m_pIStreamOut.SetErrorCode(Error_ServiceUnavailable);
#ifndef UNDER_CE
        return hr;
#else
        goto Cleanup;
#endif 
    }
        
    wchApplPath = MultiByteToWideChar(
                    CP_ACP, 
                    0, 
                    m_pszWSDLFilePath, 
                   (int)strlen(m_pszWSDLFilePath) + 1, 
                    wszApplPath, 
                    (int)wchApplPath);
    if (wchApplPath < 2) 
    {
        m_pIStreamOut.SetErrorCode(Error_BadRequest);
#ifndef UNDER_CE
        return E_FAIL;
#else
        hr = E_FAIL;
        goto Cleanup;
#endif 
    }    
    
    bstrWSDL.Assign(wszApplPath);
    wszApplPath[wchApplPath - 3] = (WCHAR)'M';
    bstrWSML.Assign(wszApplPath);
    // Initialize the SoapServer object with WSDL and WSML files
    // Pass the SOAP message to the SOAP Server object    
    if (!pISoapServer || bstrWSDL.isEmpty() || bstrWSML.isEmpty())
    {
        ASSERT(FALSE);
        m_pIStreamOut.SetErrorCode(Error_ServiceUnavailable);
#ifndef UNDER_CE
        return E_FAIL;
#else
        hr = E_FAIL;
        goto Cleanup;
#endif 
    }
    
    hr = pISoapServer->Init(bstrWSDL, bstrWSML);
    if (hr != S_OK)
    {
        m_pIStreamOut.SetErrorCode(Error_ServiceUnavailable);
#ifndef UNDER_CE
        return hr;
#else
        goto Cleanup;
#endif 
    }    
    pCachedObj = new CThdCachedObj();
    if (!pCachedObj)
    {
        m_pIStreamOut.SetErrorCode(Error_ServiceUnavailable);
#ifndef UNDER_CE
        return E_OUTOFMEMORY;
#else
        hr = E_OUTOFMEMORY;
        goto Cleanup;        
#endif 
    }  
    hr = pCachedObj->Init(m_pszWSDLFilePath, m_pszWSMLFilePath,
        pISoapServer.PvReturn());
    if (hr != S_OK)
    {
        m_pIStreamOut.SetErrorCode(Error_ServiceUnavailable);
#ifndef UNDER_CE
        return hr;
#else       
        goto Cleanup;
#endif 
    } 

    // All is OK;
    *ppCachedObj = pCachedObj;
   
#ifndef UNDER_CE
    return S_OK;
#else
    hr = S_OK;
    
Cleanup:
    
    if(wszApplPath)
        delete [] wszApplPath;
        
    return hr;
#endif 
}


////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: CRequest::ProcessGet(BOOL isHead)
//
//  parameters:
//          
//  description:
//          Executes the given GET or HEAD request
//  returns:
//          
////////////////////////////////////////////////////////////////////////////////////////////////////

HRESULT CRequest::ProcessGet(BOOL isHead)
{
    HRESULT     hr = S_OK;
    char *      pszPathInfo = m_pECB->lpszPathInfo; 
    char *      pszPathTranslated = m_pECB->lpszPathTranslated;
    DWORD       cchApplPath;
    HANDLE      hFile = INVALID_HANDLE_VALUE;
    CFileStream *pFileStrm = NULL;
#ifndef UNDER_CE
    char *      tempbuf[FOURK + 1];
#endif 
    DWORD       cbFileHigh;
    DWORD       cbFileLow;
    ULARGE_INTEGER  ucbFile;

    if (!pszPathInfo || !(*pszPathInfo))
    {
        m_pIStreamOut.SetErrorCode(Error_NotFound);
        return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
    }   
    // We must have a .wsdl file in the URL
    cchApplPath = strlen(pszPathTranslated);
    if ((cchApplPath > FOURK) || (cchApplPath < 5) ||   
            (_strnicmp(&(pszPathTranslated[cchApplPath - 5]), ".WSDL", 5)))
    {
        m_pIStreamOut.SetErrorCode(Error_BadRequest);
        return E_FAIL;
    }        
    
    hFile = CreateFileA(pszPathTranslated, GENERIC_READ,
            FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);            
    if (hFile == INVALID_HANDLE_VALUE)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        switch(HRESULT_CODE(hr))
        {
            case ERROR_FILE_NOT_FOUND:
            case ERROR_PATH_NOT_FOUND:
                m_pIStreamOut.SetErrorCode(Error_NotFound);
                break;
            case ERROR_ACCESS_DENIED:
                m_pIStreamOut.SetErrorCode(Error_AccessDenied);
                break;
            default:
                m_pIStreamOut.SetErrorCode(Error_BadRequest);
                break;
        }
        CHK(hr);
    }    
    cbFileLow = GetFileSize(hFile, &cbFileHigh);
    if ((cbFileLow == 0) && (cbFileHigh == 0))
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        m_pIStreamOut.SetErrorCode(Error_BadRequest);
        CHK(hr);
    }
    ucbFile.LowPart = cbFileLow;
    ucbFile.HighPart = (ULONG)cbFileHigh;
    m_pIStreamOut.SetSize(ucbFile);
    
    if (isHead)
    {
        m_pIStreamOut.SetHeadersOnly();
    }
    else
    {
        pFileStrm = new CSoapObject<CFileStream>(INITIAL_REFERENCE);
        
#ifdef UNDER_CE
       if(!pFileStrm)
       {
            hr = E_OUTOFMEMORY;
            goto Cleanup;
       }     
#endif 
        hr = pFileStrm->Initialize(hFile); 
        hFile = INVALID_HANDLE_VALUE;
        CHK(m_pIStreamOut.Write((IStream *)pFileStrm));
    }
    hr = S_OK;
    
Cleanup:
    if (hFile != INVALID_HANDLE_VALUE)
        CloseHandle(hFile);
    ::ReleaseInterface((const CFileStream*&)pFileStrm);
    return hr;
}    

////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: CRequest::SetErrorCode(ERROR_CODE errcode)
//
//  parameters:
//          
//  description:
//          Sets up for http error return to the client
//  returns:
//          
////////////////////////////////////////////////////////////////////////////////////////////////////
void CRequest::SetErrorCode(ERROR_CODE errcode)
{
    m_pIStreamOut.SetErrorCode(errcode);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: CRequest::FlushContents()
//
//  parameters:
//          
//  description:
//          Flushes out the contents
//  returns:
//          
////////////////////////////////////////////////////////////////////////////////////////////////////
void CRequest::FlushContents()
{
    m_pIStreamOut.FlushBuffer();
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: CRequest::WriteFaultMessage()
//
//  parameters:
//          
//  description:
//          Flushes out the contents
//  returns:
//          
////////////////////////////////////////////////////////////////////////////////////////////////////
void CRequest::WriteFaultMessage(HRESULT hr, BSTR bstrActor)
{

    // An error occured and we have to send the client back an error fault.
    m_pIStreamOut.WriteFaultMessage(hr, bstrActor);
    
}