windows-xp/Source/XPSP1/NT/inetsrv/iis/iisrearc/iisplus/ulw3/staticfile.cxx

/*++

   Copyright    (c)    1999    Microsoft Corporation

   Module Name :
     staticfile.cxx

   Abstract:
     Handle static file request
 
   Author:
     Bilal Alam (balam)             7-Jan-2000

   Environment:
     Win32 - User Mode

   Project:
     ULW3.DLL
--*/

#include "precomp.hxx"
#include "staticfile.hxx"

ALLOC_CACHE_HANDLER *       W3_STATIC_FILE_HANDLER::sm_pachStaticFileHandlers;

HRESULT
W3_STATIC_FILE_HANDLER::HandleDefaultLoad(
    W3_CONTEXT *            pW3Context,
    BOOL *                  pfHandled,
    BOOL *                  pfAsyncPending
)
/*++

Routine Description:

    Attempts to find a default load file applicable for this request.  If it
    does, it will switch the URL of the request and back track.

Arguments:

    pW3Context - Context
    pfHandled - Set to TRUE if this function has set a response or switched URL
                (in other words, no more processing is required)
    pfAsyncPending - Set to TRUE if async is pending so bail
    
Return Value:

    HRESULT - If not NO_ERROR, then *pfHandled is irrelevent

--*/
{
    URL_CONTEXT *           pUrlContext;
    W3_METADATA *           pMetaData;
    STACK_STRU(             strDefaultFiles, MAX_PATH );
    HRESULT                 hr = NO_ERROR;
    W3_REQUEST *            pRequest = pW3Context->QueryRequest();
    STRU *                  pstrPhysical;
    STACK_STRU(             strNextFile, MAX_PATH );
    WCHAR *                 pszNextFile;
    WCHAR *                 pszEndFile;
    W3_FILE_INFO *          pOpenFile = NULL;
    BOOL                    fFound = FALSE;
    STACK_STRU(             strNewUrl, MAX_PATH );
    WCHAR *                 pszQuery;
    CONTEXT_STATUS          status;
    FILE_CACHE_USER         FileUser;
    
    DBG_ASSERT( pW3Context != NULL );
    DBG_ASSERT( pRequest != NULL );
    DBG_ASSERT( pfHandled != NULL );
    DBG_ASSERT( pfAsyncPending != NULL );

    *pfHandled = FALSE;
    *pfAsyncPending = FALSE;

    //
    // Get the configuration info
    //
    
    pUrlContext = pW3Context->QueryUrlContext();
    DBG_ASSERT( pUrlContext != NULL );
    
    pMetaData = pUrlContext->QueryMetaData();
    DBG_ASSERT( pMetaData != NULL );
   
    pstrPhysical = pUrlContext->QueryPhysicalPath();
    DBG_ASSERT( pstrPhysical != NULL );
    
    //
    // First ensure the path is / suffixed.  Otherwise, redirect to such
    //
    if (pstrPhysical->QueryStr()[pstrPhysical->QueryCCH() - 1] != L'\\')
    {
        //
        // Before redirecting, first make sure it is a GET or a HEAD
        //
        HTTP_VERB VerbType = pRequest->QueryVerbType();
        if ( VerbType != HttpVerbGET &&
             VerbType != HttpVerbHEAD )
        {
            pW3Context->QueryResponse()->SetStatus( HttpStatusMethodNotAllowed );
            hr = pW3Context->SetupAllowHeader();
            if ( FAILED( hr ) )
            {
                return hr;
            }
            
            return S_OK;
        }

        STACK_STRU (strRedirect, MAX_PATH );

        //
        // Append the suffix '/'
        //
        if (FAILED(hr = pRequest->GetUrl(&strRedirect)) ||
            FAILED(hr = strRedirect.Append(L"/")))
        {
            return hr;
        }

        //
        // Do the HTTP redirect
        //
        if (FAILED(hr = pW3Context->SetupHttpRedirect(strRedirect,
                                                      TRUE,
                                                      HttpStatusMovedPermanently)))
        {
            return hr;
        }

        //
        // Tell callers we are finished
        //
        *pfHandled = TRUE;
        return S_OK;
    }
    
    //
    // Look for default load files
    // 
    
    hr = strDefaultFiles.Copy( *pMetaData->QueryDefaultLoadFiles() );
    if ( FAILED( hr ) )
    {
        return hr;
    }
    
    pszNextFile = strDefaultFiles.QueryStr();
    while ( pszNextFile != NULL && 
            *pszNextFile != L'\0' )
    {
        pszEndFile = wcschr( pszNextFile, L',' );
        if ( pszEndFile != NULL )
        {
            *pszEndFile = L'\0';
        }
        
        //
        // Append portion to directory to create a filename to check for
        //
        
        hr = strNextFile.Copy( *pstrPhysical );
        if ( FAILED( hr ) )
        {
            return hr;
        }

        //
        // Remove any query string
        //
        
        pszQuery = wcschr( pszNextFile, L'?' );
        if ( pszQuery != NULL )
        {
            hr = strNextFile.Append( pszNextFile,
                                     DIFF( pszQuery - pszNextFile ) );
        }
        else
        {
            hr = strNextFile.Append( pszNextFile );
        }
        if ( FAILED( hr ) )
        {
            return hr;
        }
        
        //
        // Make a FS path
        //
        
        FlipSlashes( strNextFile.QueryStr() );
        
        //
        // Open the file
        //
        
        pW3Context->QueryFileCacheUser( &FileUser );
       
        DBG_ASSERT( g_pW3Server->QueryFileCache() != NULL );
        
        hr = g_pW3Server->QueryFileCache()->GetFileInfo( 
                                            strNextFile,
                                            pMetaData->QueryDirmonConfig(),
                                            &FileUser,
                                            !( pMetaData->QueryNoCache() ),
                                            &pOpenFile );
        if ( FAILED( hr ) )
        {
            DWORD           dwError = WIN32_FROM_HRESULT( hr );
            
            DBG_ASSERT( pOpenFile == NULL );
            
            //
            // If not found, or name invalid, that's ok -> proceed to next file
            //
            
            if ( dwError != ERROR_FILE_NOT_FOUND &&
                 dwError != ERROR_PATH_NOT_FOUND &&
                 dwError != ERROR_INVALID_NAME )
            {
                return hr;
            }
            
            hr = NO_ERROR;
        }
        else
        {
            DWORD           dwAttributes;

            //
            // Great, we can open the file.  We only need it for attributes.
            //
            
            DBG_ASSERT( pOpenFile != NULL );
            
            dwAttributes = pOpenFile->QueryAttributes();

            pOpenFile->DereferenceCacheEntry(); 
            
            if ( dwAttributes & FILE_ATTRIBUTE_DIRECTORY )
            {   
                //
                // For legacy, if we see a directory, our default load file
                // search is over, and we act like we never found one
                //
            
                return NO_ERROR;
            }
            
            fFound = TRUE;
            break;
        }
        
        //
        // Goto next file
        //
        
        pszNextFile = pszEndFile ? pszEndFile + 1 : NULL;
    }
    
    //
    // Change the url and retrack
    //
   
    if ( fFound )
    {
        //
        // Ok.  We can change the URL and retrack.  Do so.
        //
        
        hr = pW3Context->QueryRequest()->GetUrl( &strNewUrl );
        if ( FAILED( hr ) ) 
        {
            return hr;
        }
        
        hr = strNewUrl.Append( pszNextFile );
        if ( FAILED( hr ) )
        {
            return hr;
        }
        
        //
        // Change the URL
        //       
        
        hr = pW3Context->QueryRequest()->SetUrl( strNewUrl, FALSE );
        if ( FAILED( hr ) )
        {
            return hr;
        }
        
        hr = pW3Context->ExecuteChildRequest( pW3Context->QueryRequest(),
                                              FALSE,
                                              W3_FLAG_ASYNC );
        if ( FAILED( hr ) )
        {
            return hr;
        }
        else
        {
            *pfHandled = TRUE;
            *pfAsyncPending = TRUE;
            return NO_ERROR;
        }
    } 
    else
    {
        //
        // If not found, the caller will continue since *pfHandled == FALSE
        // if we're here
        //
    }
    
    return NO_ERROR;
}

HRESULT
W3_STATIC_FILE_HANDLER::DirectoryDoWork(
    W3_CONTEXT *            pW3Context,
    BOOL *                  pfAsyncPending
)
/*++

Routine Description:

    Handle directories.  This means default loads and directory listings

Arguments:

    pW3Context - Context
    pfAsyncPending - Set to TRUE if async pending
    
Return Value:

    HRESULT

--*/
{
    DWORD               dwDirBrowseFlags;
    URL_CONTEXT *       pUrlContext;
    HRESULT             hr;
    BOOL                fHandled = FALSE;
    FILE_CACHE_USER     fileUser;
    BOOL                fImpersonated = FALSE;

    DBG_ASSERT( pW3Context != NULL );
    DBG_ASSERT( pfAsyncPending != NULL );
    
    *pfAsyncPending = FALSE;

    W3_REQUEST *pRequest = pW3Context->QueryRequest();
    DBG_ASSERT(pRequest != NULL);

    W3_RESPONSE *pResponse = pW3Context->QueryResponse();
    DBG_ASSERT(pResponse != NULL);

    pUrlContext = pW3Context->QueryUrlContext();
    DBG_ASSERT( pUrlContext != NULL );

    STRU *pstrPhysical = pUrlContext->QueryPhysicalPath();
    DBG_ASSERT( pstrPhysical != NULL );

    //
    // Get the directory browsing flags for this directory
    //
    dwDirBrowseFlags = pUrlContext->QueryMetaData()->QueryDirBrowseFlags();

    //
    // First check for a default load (by first checking whether we are 
    // allowed to serve default load)
    //
    if ( dwDirBrowseFlags & MD_DIRBROW_LOADDEFAULT )
    {
        //
        // OK.  Look for a default load
        //
        
        hr = HandleDefaultLoad( pW3Context,
                                &fHandled,
                                pfAsyncPending );
                                
        if ( FAILED( hr ) || fHandled || *pfAsyncPending )
        {
            return hr;
        }
    }
    
    //
    // If doing directory listing, first make sure it is a GET or a HEAD
    //
    HTTP_VERB VerbType = pRequest->QueryVerbType();
    if ( VerbType != HttpVerbGET &&
         VerbType != HttpVerbHEAD )
    {
        pW3Context->QueryResponse()->SetStatus( HttpStatusMethodNotAllowed );
        hr = pW3Context->SetupAllowHeader();
        if ( FAILED( hr ) )
        {
            return hr;
        }

        return S_OK;
    }

    //
    // OK.  Check for whether directory listings are enabled
    //
    if ( dwDirBrowseFlags & MD_DIRBROW_ENABLED )
    {
        //
        // We may need to impersonate some other user to open the file
        //
    
        pW3Context->QueryFileCacheUser( &fileUser );

        if ( fileUser._hToken != NULL )
        {
            if ( !SetThreadToken( NULL, fileUser._hToken ) )
            {
                return HRESULT_FROM_WIN32( GetLastError() );
            }
            fImpersonated = TRUE;
        }
    
        hr = HandleDirectoryListing( pW3Context,
                                     &fHandled );

        if( fImpersonated )
        {
            RevertToSelf();
            fImpersonated = FALSE;
        }
        
        if ( FAILED( hr ) || fHandled )
        {
            return hr;
        }
    }
    
    //
    // If we are here, then neither browsing nor default loads are enabled.
    // There is nothing we can do but return a 403.
    //
    
    pW3Context->QueryResponse()->SetStatus( HttpStatusForbidden,
                                            Http403DirBrowsingDenied );
    return NO_ERROR;
}


HRESULT
GetTypeAndSubType(
    CHAR *                  pszType,
    STRA *                  pstrMainType,
    STRA *                  pstrSubType,
    BOOL *                  pfTypeOk
)
/*++

Routine Description:

    Given a mimetype of "foobar/barfoo", return "foobar" as the main type 
    and "barfoo" as the subtype.

Arguments:
    
    pszType - Whole mime type
    pstrMainType - Filled with main type
    pstrSubType - Filled with sub type
    pfTypeOk - Is this mime type ok?
    
Return Value:

    HRESULT

--*/
{
    HRESULT hr;

    CHAR * pszSlash = strchr( pszType, '/' );
    if (pszSlash == NULL)
    {
        *pfTypeOk = FALSE;
        return S_OK;
    }

    hr = pstrMainType->Copy( pszType,
                             DIFF( pszSlash - pszType ) );
    hr = pstrSubType->Copy( pszSlash + 1 );

    *pfTypeOk = TRUE;
    return hr;
}


HRESULT
IsAcceptable(
    CHAR *              pszContentType,
    CHAR *              pszAcceptHeader,
    BOOL *              pfIsAcceptAble
)
/*++

Routine Description:

    Return whether given content type is acceptable for the given
    Accept: header

Arguments:

    pszContentType - Content type
    pszAcceptHeader - Accept header to check    
    pfIsAcceptAble - Filled with bool indicating whether type is acceptable
    
Return Value:

    HRESULT

--*/
{
    HRESULT         hr;
    BOOL            fTypeOk;

    //
    // Quickly handle the */* case
    //
    
    if ( pszAcceptHeader[ 0 ] == '*' &&
         pszAcceptHeader[ 1 ] == '/' &&
         pszAcceptHeader[ 2 ] == '*' &&
         pszAcceptHeader[ 3 ] == '\0' )
    {
        *pfIsAcceptAble = TRUE;
        return S_OK;
    }

    //
    // Break the Content-Type into the main- and sub-content-type
    //
    STACK_STRA ( strMainContentType, 32);
    STACK_STRA ( strSubContentType, 32);
    if ( FAILED( hr = GetTypeAndSubType( pszContentType,
                                         &strMainContentType,
                                         &strSubContentType,
                                         &fTypeOk ) ) )
    {
        return hr;
    }
    if ( !fTypeOk )
    {
        *pfIsAcceptAble = FALSE;
        return S_OK;
    }

    //
    // Skip over any spaces
    //
    while ( *pszAcceptHeader == ' ' )
    {
        pszAcceptHeader++;
    }

    STACK_STRA (strAcceptType, 64);
    STACK_STRA (strMainAcceptType, 32);
    STACK_STRA (strSubAcceptType, 32);

    while (TRUE)
    {
        //
        // Multiple Acceptable Types are ',' separated, get the next one
        //
        CHAR * pszComma = strchr( pszAcceptHeader, L',' );
        if ( pszComma == NULL )
        {
            if ( FAILED( hr = strAcceptType.Copy( pszAcceptHeader ) ) )
            {
                return hr;
            }
        }
        else
        {
            if ( FAILED( hr = strAcceptType.Copy( pszAcceptHeader,
                                  DIFF( pszComma - pszAcceptHeader ) ) ) )
            {
                return hr;
            }
        }

        //
        // Trim out any quality specifier specified after a ';'
        //
        CHAR * pszQuality = strchr( strAcceptType.QueryStr(), ';' );
        if ( pszQuality != NULL )
        {
            strAcceptType.SetLen(DIFF(pszQuality - strAcceptType.QueryStr()));
        }

        //
        // Trim any spaces at the end
        //
        INT iSpace = strAcceptType.QueryCCH() - 1;
        while ( iSpace >= 0 &&
                strAcceptType.QueryStr()[iSpace] == ' ' )
        {
            iSpace--;
        }
        strAcceptType.SetLen( iSpace + 1 );

        //
        // Just check if this Type is */*
        //
        if ( !strcmp( strAcceptType.QueryStr(), "*/*" ) )
        {
            *pfIsAcceptAble = TRUE;
            return S_OK;
        }

        //
        // Get the main- and sub-Accept types for this type
        //
        if ( FAILED(hr = GetTypeAndSubType( strAcceptType.QueryStr(),
                                            &strMainAcceptType,
                                            &strSubAcceptType,
                                            &fTypeOk ) ) )
        {
            return hr;
        }
        if ( !fTypeOk )
        {
            *pfIsAcceptAble = TRUE;
            return S_OK;
        }

        //
        // Now actually find out if this type is acceptable
        //
        if ( !_stricmp( strMainAcceptType.QueryStr(),
                        strMainContentType.QueryStr() ) )
        {
            if ( !strcmp( strSubAcceptType.QueryStr(), "*" ) ||
                 !_stricmp( strSubAcceptType.QueryStr(),
                            strSubContentType.QueryStr() ) )
            {
                *pfIsAcceptAble = TRUE;
                return S_OK;
            }
        }

        //
        // Set AcceptHeader to the start of the next type
        //
        if (pszComma == NULL)
        {
            *pfIsAcceptAble = FALSE;
            return S_OK;
        }
        pszAcceptHeader = pszComma + 1;
        while ( *pszAcceptHeader == ' ' )
        {
            pszAcceptHeader++;
        }
    }
}


HRESULT
W3_STATIC_FILE_HANDLER::FileDoWork(
    W3_CONTEXT *                pW3Context,
    W3_FILE_INFO *              pOpenFile
)
/*++

Routine Description:

    Handle files (non-directories).

Arguments:

    pW3Context - Context
    pOpenFile - W3_FILE_INFO with the file to send
    
Return Value:

    HRESULT

--*/
{
    LARGE_INTEGER       liFileSize;
    W3_RESPONSE *       pResponse;
    W3_REQUEST  *       pRequest;
    W3_URL_INFO *       pUrlInfo;
    W3_METADATA *       pMetaData;
    BOOL                fRet;
    HRESULT             hr;
    STACK_STRU        ( strUrl, MAX_PATH );
    CHAR *              pszRange;
    BOOL                fHandled = FALSE;
    FILE_CACHE_USER     fileUser;

    DBG_ASSERT( pW3Context != NULL );
    DBG_ASSERT( pOpenFile != NULL );
    pResponse = pW3Context->QueryResponse();
    DBG_ASSERT( pResponse != NULL );
    pRequest = pW3Context->QueryRequest();
    DBG_ASSERT( pRequest != NULL );
    pUrlInfo = pW3Context->QueryUrlContext()->QueryUrlInfo();
    DBG_ASSERT( pUrlInfo != NULL );
    pMetaData = pW3Context->QueryUrlContext()->QueryMetaData();
    DBG_ASSERT( pMetaData != NULL );


    //
    // First make sure it a GET or a HEAD
    //
    HTTP_VERB VerbType = pRequest->QueryVerbType();
    if ( VerbType != HttpVerbGET &&
         VerbType != HttpVerbHEAD )
    {
        pW3Context->QueryResponse()->SetStatus( HttpStatusMethodNotAllowed );
        hr = pW3Context->SetupAllowHeader();
        if ( FAILED( hr ) )
        {
            return hr;
        }

        return S_OK;
    }

    //
    // If this an image-map file, do the image-map stuff
    //
    if (pUrlInfo->QueryGateway() == GATEWAY_MAP)
    {
        fHandled = FALSE;
        hr = MapFileDoWork(pW3Context, pOpenFile, &fHandled);
        if (FAILED(hr) ||
            fHandled)
        {
            return hr;
        }

        //
        // fHandled was false, so this is a .map file which wasn't really
        // an image-map file, handle it as any other static file
        //
    }

    //
    // Do compression, if so configured
    //
    if (pMetaData->QueryDoStaticCompression() &&
        !pW3Context->QueryDoneWithCompression())
    {
        //
        // If this file is compressible, don't let UL store the uncompressed
        // version in its cache
        //
        pW3Context->DisableUlCache();

        if (FAILED(hr = HTTP_COMPRESSION::DoStaticFileCompression(
                            pW3Context, &pOpenFile)))
        {
            return hr;
        }
        m_pOpenFile = pOpenFile;
    }

    //
    // First see if the Content-Type is acceptable to the client
    //

    STRA *pstrContentType = pUrlInfo->QueryContentType();
    CHAR * pszAccept      = pRequest->GetHeader( HttpHeaderAccept );
    if ( pszAccept != NULL && *pszAccept != L'\0' )
    {
        BOOL fIsAcceptAble;

        if ( FAILED( hr = IsAcceptable( pstrContentType->QueryStr(),
                                        pszAccept,
                                        &fIsAcceptAble ) ) )
        {
            return hr;
        }

        if ( !fIsAcceptAble )
        {
            pResponse->ClearHeaders();
            pResponse->SetStatus( HttpStatusNotAcceptable );
            return S_OK;
        }
    }

    //
    // Setup the response headers.  First ETag
    //

    hr = pResponse->SetHeaderByReference( HttpHeaderEtag,
                                          pOpenFile->QueryETag(),
                                          pOpenFile->QueryETagSize() );
    if ( FAILED( hr ) )
    {
        goto Failure;
    }

    //
    // Next is Last-Modified
    //
    
    hr = pResponse->SetHeaderByReference( HttpHeaderLastModified,
                                          pOpenFile->QueryLastModifiedString(),
                                          GMT_STRING_SIZE - 1 );
    if ( FAILED( hr ) )
    {
        goto Failure;
    }
    
    //
    // Next is Content-Location.  We only need to send this header if 
    // we have internally changed the URL of the request.  In other words,
    // if this is a child execute
    //
    
    if ( pW3Context->QuerySendLocation() )
    {
        STACK_STRA (strContentLocation, MAX_PATH);
        STACK_STRA (strRawUrl, MAX_PATH);

        if (FAILED(hr = pRequest->GetRawUrl(&strRawUrl)) ||
            FAILED(hr = pRequest->BuildFullUrl(strRawUrl,
                                               &strContentLocation,
                                               FALSE)) ||
            FAILED(hr = pResponse->SetHeader(HttpHeaderContentLocation,
                                             strContentLocation.QueryStr(),
                                             strContentLocation.QueryCCH())))
        {
            return hr;
        }
    }
    
    //
    // Next is Accept-Ranges
    //
    if ( FAILED( hr = pResponse->SetHeaderByReference( HttpHeaderAcceptRanges,
                                                       "bytes", 5 ) ) )
    {
        goto Failure;
    }

    //
    // Handle the If-* (except If-Range) headers if present
    //
    fHandled = FALSE;
    if ( FAILED( hr = CacheValidationDoWork( pW3Context,
                                             pOpenFile,
                                             &fHandled ) ) )
    {
        goto Failure;
    }

    if ( fHandled )
    {
        return hr;
    }

    //
    // Now handle If-Range and Range headers
    //
    pszRange = pRequest->GetHeader( HttpHeaderRange );
    if ( ( pszRange != NULL ) &&
         ( !_strnicmp ( pszRange, "bytes", 5 ) ) )
    {
        //
        // Handle range request
        //
        fHandled = FALSE;
        if ( FAILED( hr = RangeDoWork( pW3Context, pOpenFile, &fHandled ) ) )
        {
            goto Failure;
        }

        if ( fHandled )
        {
            return hr;
        }
    }

    //
    // If we fell thru, then we are sending out the entire file
    //

    //
    // Setup Content-Type
    //
    if ( FAILED( hr = pResponse->SetHeaderByReference(
                          HttpHeaderContentType,
                          pstrContentType->QueryStr(),
                          pstrContentType->QueryCCH() ) ) )
    {
        goto Failure;
    }

    //
    // Setup the response chunks
    //
    pOpenFile->QuerySize( &liFileSize );

    if (liFileSize.QuadPart > 0)
    {
        if ( pOpenFile->QueryFileBuffer() != NULL &&
             liFileSize.HighPart == 0 )
        {
            hr = pResponse->AddMemoryChunkByReference( 
                                pOpenFile->QueryFileBuffer(),
                                liFileSize.LowPart );
        }
        else
        {
            hr = pResponse->AddFileHandleChunk( pOpenFile->QueryFileHandle(),
                                                0,
                                                liFileSize.QuadPart );
        }

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

    // perf ctr
    pW3Context->QuerySite()->IncFilesSent();

    // Setup the document footer
    if (pMetaData->QueryIsFooterEnabled())
    {
        if (!pMetaData->QueryFooterString()->IsEmpty() )
        {
            STRA *pFooterString = pMetaData->QueryFooterString();
            if (pFooterString->QueryCCH())
            {
                if (FAILED(hr = pResponse->AddMemoryChunkByReference(
                                               pFooterString->QueryStr(),
                                               pFooterString->QueryCCH())))
                {
                    goto Failure;
                }
            }
        }
        else if (!pMetaData->QueryFooterDocument()->IsEmpty() )
        {
            DBG_ASSERT( m_pFooterDocument == NULL );
            
            DBG_ASSERT( g_pW3Server->QueryFileCache() );
            
            hr = g_pW3Server->QueryFileCache()->GetFileInfo( 
                                        *(pMetaData->QueryFooterDocument()),
                                        NULL,
                                        &fileUser,
                                        TRUE,
                                        &m_pFooterDocument );
            if ( SUCCEEDED( hr ) )
            {
                DBG_ASSERT( m_pFooterDocument != NULL );
                
                m_pFooterDocument->QuerySize( &liFileSize );

                if (liFileSize.QuadPart > 0)
                {
                    if ( m_pFooterDocument->QueryFileBuffer() != NULL &&
                         liFileSize.HighPart == 0 )
                    {
                        hr = pResponse->AddMemoryChunkByReference( 
                                        m_pFooterDocument->QueryFileBuffer(),
                                        liFileSize.LowPart );
                    }
                    else
                    {
                        hr = pResponse->AddFileHandleChunk(
                                        m_pFooterDocument->QueryFileHandle(),
                                        0,
                                        liFileSize.QuadPart );
                    }

                    if ( FAILED( hr ) )
                    {
                        goto Failure;
                    }
                }
            }
            else
            {
                //
                // Could not open the footer document.  Sub in a error string
                //

                CHAR achErrorString[ 512 ];
                DWORD cbErrorString = sizeof( achErrorString );

                hr = g_pW3Server->LoadString( IDS_ERROR_FOOTER,
                                              achErrorString,
                                              &cbErrorString );
                if ( FAILED( hr ) ) 
                {
                    goto Failure;
                }
                
                hr = m_strFooterString.Copy( achErrorString, cbErrorString );
                if ( FAILED( hr ) )
                {
                    goto Failure;
                }
                
                hr = pResponse->AddMemoryChunkByReference( 
                                        m_strFooterString.QueryStr(),
                                        m_strFooterString.QueryCCH() );
                if ( FAILED( hr ) )
                {
                    goto Failure;
                }
            }
        }
    }
    
    return S_OK;
    
Failure:
    //
    // It is our responsibility to ensure that there is no incomplete response
    //
    
    pResponse->Clear();
    return hr;
}

CONTEXT_STATUS
W3_STATIC_FILE_HANDLER::DoWork(
    VOID
)
/*++

Routine Description:

    Execute the static file handler

Return Value:

    CONTEXT_STATUS_PENDING or CONTEXT_STATUS_CONTINUE

--*/
{
    W3_CONTEXT *pW3Context = QueryW3Context();
    DBG_ASSERT( pW3Context != NULL );

    HRESULT             hr = NO_ERROR;
    W3_RESPONSE *       pResponse = pW3Context->QueryResponse();
    W3_REQUEST *        pRequest = pW3Context->QueryRequest();
    W3_METADATA *       pMetaData;
    URL_CONTEXT *       pUrlContext;
    W3_FILE_INFO *      pOpenFile = NULL;
    BOOL                fRet;
    DWORD               dwFilePerms;
    BOOL                fAccess;
    BOOL                fAsyncPending = FALSE;
    FILE_CACHE_USER     fileUser;

    //
    // Get the metadata, in particular the cached W3_URL_INFO off which we
    // we attempt to open the file
    //
   
    pUrlContext = pW3Context->QueryUrlContext();
    DBG_ASSERT( pUrlContext != NULL );

    pMetaData = pUrlContext->QueryMetaData();
    DBG_ASSERT( pMetaData != NULL );

    //
    // Check web permissions.
    // Will fail, if no VROOT_MASK_READ, or if we forbid remote access and
    // the request is remote
    //
    
    dwFilePerms = pMetaData->QueryAccessPerms();

    if ( !IS_ACCESS_ALLOWED(pRequest, dwFilePerms, READ) )
    {
        pResponse->SetStatus( HttpStatusForbidden,
                              Http403ReadAccessDenied );
        goto Failure;
    }

    //
    // Now try to open the file
    //
    
    pW3Context->QueryFileCacheUser( &fileUser );

    hr = pUrlContext->OpenFile( &fileUser, &pOpenFile );
    if (FAILED(hr))
    {
        DWORD           dwError;

        IF_DEBUG( STATICFILE )
        {      
            DBGPRINTF(( DBG_CONTEXT,
                        "Error opening file %ws.  hr = %x\n",
                        pUrlContext->QueryPhysicalPath()->QueryStr(),
                        hr ));
        }
        
        dwError = WIN32_FROM_HRESULT( hr );
        switch( dwError )
        {
        case ERROR_FILE_NOT_FOUND:
        case ERROR_PATH_NOT_FOUND:
        case ERROR_INVALID_NAME:
            hr = NO_ERROR;
            pResponse->SetStatus( HttpStatusNotFound );
            break;
        
        case ERROR_LOGON_FAILURE:
        case ERROR_ACCOUNT_DISABLED:
        case ERROR_ACCESS_DENIED:
            hr = NO_ERROR;
            pResponse->SetStatus( HttpStatusUnauthorized,
                                  Http401Resource );
            break;
        
        case ERROR_INSUFFICIENT_BUFFER:
            hr = NO_ERROR;
            pResponse->SetStatus( HttpStatusUrlTooLong );
            break;
        }
        
        goto Failure;
    }
    
    DBG_ASSERT( pOpenFile != NULL );
    
    //
    // Is the file hidden?  If so, don't serve it out for legacy reasons
    // 
    
    if ( pOpenFile->QueryAttributes() & FILE_ATTRIBUTE_HIDDEN ) 
    {
        pOpenFile->DereferenceCacheEntry();
        pResponse->SetStatus( HttpStatusNotFound );
        goto Failure;
    }
    
    //
    // Is this a file or directory?  
    //
    
    if ( pOpenFile->QueryAttributes() & FILE_ATTRIBUTE_DIRECTORY )
    {
        //
        // At this point, we will do one of the following:
        // a) Send a directory listing
        // b) Send a default load file
        // c) Send a 302 (to redirect to a slash suffixed URL)
        // d) Send a 403 (forbidden)
        // 
        
        pOpenFile->DereferenceCacheEntry();
        pOpenFile = NULL;
        
        hr = DirectoryDoWork( pW3Context,
                              &fAsyncPending );
        if ( fAsyncPending )
        {
            return CONTEXT_STATUS_PENDING;
        }

        //
        // If access denied, then send the response now
        //
        
        if ( WIN32_FROM_HRESULT( hr ) == ERROR_ACCESS_DENIED )
        {
            pW3Context->SetErrorStatus( hr ); 
            pW3Context->QueryResponse()->SetStatus( HttpStatusUnauthorized,
                                                    Http401Resource );

            hr = NO_ERROR;
        }                
    }
    else
    {
        //
        // This is just a regular file.  Serve it out
        //
        
        //
        // Save away the file now.  We will clean it up at the end of the
        // request when this current context is cleaned up
        //
        
        m_pOpenFile = pOpenFile;

        hr = FileDoWork( pW3Context,
                         pOpenFile );
    }

    //
    // If there was an error here, then generate a 500.  If successful, it
    // is assumed that the response status is already set
    //

Failure:

    if ( FAILED( hr ) )
    {
        pResponse->Clear();
        pW3Context->SetErrorStatus( hr ); 
        pResponse->SetStatus( HttpStatusServerError );
    }
    
    hr = pW3Context->SendResponse( W3_FLAG_ASYNC );
    if ( FAILED( hr ) )
    {
        pW3Context->SetErrorStatus( hr );
        return CONTEXT_STATUS_CONTINUE;
    }
    
    return CONTEXT_STATUS_PENDING;
}

HRESULT
W3_STATIC_FILE_HANDLER::SetupUlCachedResponse(
    W3_CONTEXT *                pW3Context
)
/*++

Routine Description:

    Setup a response to be cached by UL.  In this case we will muck with
    the cached file object to 
    a) Remove its TTL
    b) Associate the current request's URL with the file object so that when
       the file object goes away, we will be called with enough info to
       flush the appropriate UL cache entry

Arguments:

    pW3Context - Context
    
Return Value:

    HRESULT

--*/
{
    STACK_STRU(             strFlushUrl, MAX_PATH );
    STACK_STRU(             strPhysicalPath, MAX_PATH );
    TOKEN_CACHE_ENTRY *     pToken;
    HRESULT                 hr;
    FILE_CACHE_USER         fileUser;
    W3_METADATA *           pMetaData;

    if ( pW3Context == NULL )
    {
        DBG_ASSERT( FALSE );
        return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
    }
    
    if ( m_pOpenFile == NULL )
    {
        return HRESULT_FROM_WIN32( ERROR_FILE_NOT_FOUND );
    }
    
    //
    // If the file wasn't cached, then don't use UL cache
    //
    
    if ( m_pOpenFile->QueryCached() == FALSE )
    {
        return HRESULT_FROM_WIN32( ERROR_NOT_SUPPORTED );
    }
    
    //
    // If this file was not accessed anonymously, then we need to do access
    // check anonymously before putting into cache
    //
    
    if ( pW3Context->QueryUserContext()->QueryAuthType() != MD_AUTH_ANONYMOUS )
    {
        pMetaData = pW3Context->QueryUrlContext()->QueryMetaData();
        DBG_ASSERT( pMetaData != NULL );
        
        pToken = pMetaData->QueryVrAccessToken();
        if ( pToken == NULL )
        {
            pToken = pMetaData->QueryAnonymousToken();
        }
        
        if ( pToken == NULL )
        {
            return HRESULT_FROM_WIN32( ERROR_ACCESS_DENIED );
        }
        
        fileUser._hToken = pToken->QueryImpersonationToken();
        fileUser._pSid = pToken->QuerySid();
        
        hr = m_pOpenFile->DoAccessCheck( &fileUser );
        if ( FAILED( hr ) )
        {
            return hr;
        }
    }
    
    //
    // Get the exact URL used to flush UL cache
    //
    
    hr = pW3Context->QueryMainContext()->QueryRequest()->GetOriginalFullUrl( 
                                                            &strFlushUrl );
    if ( FAILED( hr ) )
    {
        return hr;
    }
    
    //
    // Get the physical path
    //
    
    hr = strPhysicalPath.Copy( m_pOpenFile->QueryPhysicalPath() );
    if ( FAILED( hr ) )
    {
        return hr;
    }
    
    //
    // Setup UL cache response token
    //
    
    DBG_ASSERT( g_pW3Server->QueryUlCache() != NULL );
    
    hr = g_pW3Server->QueryUlCache()->SetupUlCachedResponse( 
                                        pW3Context,
                                        strFlushUrl,
                                        strPhysicalPath );
    
    return hr;
}