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

/*++

   Copyright    (c)    2000   Microsoft Corporation

   Module Name :
     servervar.cxx

   Abstract:
     Server Variable evaluation goo
 
   Author:
     Bilal Alam (balam)             20-Feb-2000

   Environment:
     Win32 - User Mode

   Project:
     ULW3.DLL
--*/

#include "precomp.hxx"

//
// Hash table mapping variable name to a PFN_SERVER_VARIABLE_ROUTINE
//

SERVER_VARIABLE_HASH * SERVER_VARIABLE_HASH::sm_pRequestHash;

SERVER_VARIABLE_RECORD SERVER_VARIABLE_HASH::sm_rgServerRoutines[] =
{ 
    { "ALL_HTTP",             GetServerVariableAllHttp, NULL },
    { "ALL_RAW",              GetServerVariableAllRaw, NULL },
    { "APPL_MD_PATH",         GetServerVariableApplMdPath, GetServerVariableApplMdPathW },
    { "APPL_PHYSICAL_PATH",   GetServerVariableApplPhysicalPath, GetServerVariableApplPhysicalPathW  },
    { "AUTH_PASSWORD",        GetServerVariableAuthPassword, NULL },
    { "AUTH_TYPE",            GetServerVariableAuthType, NULL },
    { "AUTH_USER",            GetServerVariableRemoteUser, GetServerVariableRemoteUserW },
    { "CERT_COOKIE",          GetServerVariableClientCertCookie, NULL },
    { "CERT_FLAGS",           GetServerVariableClientCertFlags, NULL },
    { "CERT_ISSUER",          GetServerVariableClientCertIssuer, NULL },
    { "CERT_KEYSIZE",         GetServerVariableHttpsKeySize, NULL },
    { "CERT_SECRETKEYSIZE",   GetServerVariableHttpsSecretKeySize, NULL },
    { "CERT_SERIALNUMBER",    GetServerVariableClientCertSerialNumber, NULL },
    { "CERT_SERVER_ISSUER",   GetServerVariableHttpsServerIssuer, NULL },
    { "CERT_SERVER_SUBJECT",  GetServerVariableHttpsServerSubject, NULL },
    { "CERT_SUBJECT",         GetServerVariableClientCertSubject, NULL },
    { "CONTENT_LENGTH",       GetServerVariableContentLength, NULL },
    { "CONTENT_TYPE",         GetServerVariableContentType, NULL },
    { "GATEWAY_INTERFACE",    GetServerVariableGatewayInterface, NULL },
    { "LOGON_USER",           GetServerVariableLogonUser, GetServerVariableLogonUserW },
    { "HTTPS",                GetServerVariableHttps, NULL },
    { "HTTPS_KEYSIZE",        GetServerVariableHttpsKeySize, NULL },
    { "HTTPS_SECRETKEYSIZE",  GetServerVariableHttpsSecretKeySize, NULL },
    { "HTTPS_SERVER_ISSUER",  GetServerVariableHttpsServerIssuer, NULL },
    { "HTTPS_SERVER_SUBJECT", GetServerVariableHttpsServerSubject, NULL },
    { "INSTANCE_ID",          GetServerVariableInstanceId, NULL },
    { "INSTANCE_META_PATH",   GetServerVariableInstanceMetaPath, NULL },
    { "PATH_INFO",            GetServerVariablePathInfo, GetServerVariablePathInfoW },
    { "PATH_TRANSLATED",      GetServerVariablePathTranslated, GetServerVariablePathTranslatedW },
    { "QUERY_STRING",         GetServerVariableQueryString, NULL },
    { "REMOTE_ADDR",          GetServerVariableRemoteAddr, NULL },
    { "REMOTE_HOST",          GetServerVariableRemoteHost, NULL },
    { "REMOTE_USER",          GetServerVariableRemoteUser, GetServerVariableRemoteUserW },
    { "REQUEST_METHOD",       GetServerVariableRequestMethod, NULL },
    { "SCRIPT_NAME",          GetServerVariableUrl, GetServerVariableUrlW },
    { "SERVER_NAME",          GetServerVariableServerName, NULL },
    { "LOCAL_ADDR",           GetServerVariableLocalAddr, NULL },
    { "SERVER_PORT",          GetServerVariableServerPort, NULL },
    { "SERVER_PORT_SECURE",   GetServerVariableServerPortSecure, NULL },
    { "SERVER_PROTOCOL",      GetServerVariableHttpVersion, NULL },
    { "SERVER_SOFTWARE",      GetServerVariableServerSoftware, NULL },
    { "UNMAPPED_REMOTE_USER", GetServerVariableRemoteUser, GetServerVariableRemoteUserW },
    { "URL",                  GetServerVariableUrl, GetServerVariableUrlW },
    { "HTTP_URL",             GetServerVariableHttpUrl, NULL },
    { "HTTP_METHOD",          GetServerVariableRequestMethod, NULL },
    { "HTTP_VERSION",         GetServerVariableHttpVersion, NULL },
    { "APP_POOL_ID",          GetServerVariableAppPoolId, GetServerVariableAppPoolIdW },
    { "SCRIPT_TRANSLATED",    GetServerVariableScriptTranslated, GetServerVariableScriptTranslatedW },
    { "UNENCODED_URL",        GetServerVariableUnencodedUrl, NULL },
    { NULL,                   NULL, NULL }
};

//static
HRESULT
SERVER_VARIABLE_HASH::Initialize(
    VOID
)
/*++

Routine Description:

    Initialize global server variable hash table

Arguments:

    None

Return Value:

    HRESULT

--*/
{
    SERVER_VARIABLE_RECORD *        pRecord;
    LK_RETCODE                      lkrc = LK_SUCCESS;
    
    sm_pRequestHash = new SERVER_VARIABLE_HASH;
    if ( sm_pRequestHash == NULL )
    {
        return HRESULT_FROM_WIN32( ERROR_NOT_ENOUGH_MEMORY );        
    }
    
    //
    // Add every string->routine mapping
    //
    
    pRecord = sm_rgServerRoutines;
    while ( pRecord->_pszName != NULL )
    {
        lkrc = sm_pRequestHash->InsertRecord( pRecord );
        if ( lkrc != LK_SUCCESS )
        {
            break;
        }
        pRecord++;
    }
    
    //
    // If any insert failed, then fail initialization
    //
    
    if ( lkrc != LK_SUCCESS )
    {
        delete sm_pRequestHash;
        sm_pRequestHash = NULL;
        return HRESULT_FROM_WIN32( lkrc );        // ARGH
    }
    else
    {
        return NO_ERROR;
    }
}

//static
VOID
SERVER_VARIABLE_HASH::Terminate(
    VOID
)
/*++

Routine Description:

    Cleanup global server variable hash table

Arguments:

    None

Return Value:

    None

--*/
{
    if ( sm_pRequestHash != NULL )
    {
        delete sm_pRequestHash;
        sm_pRequestHash = NULL;
    }
}

//static
HRESULT
SERVER_VARIABLE_HASH::GetServerVariableRoutine(
    CHAR *                          pszName,
    PFN_SERVER_VARIABLE_ROUTINE   * ppfnRoutine,
    PFN_SERVER_VARIABLE_ROUTINE_W * ppfnRoutineW
)
/*++

Routine Description:

    Lookup the hash table for a routine to evaluate the given variable

Arguments:

    pszName - Name of server variable
    ppfnRoutine - Set to the routine if successful

Return Value:

    HRESULT

--*/
{
    LK_RETCODE              lkrc;
    SERVER_VARIABLE_RECORD* pServerVariableRecord = NULL;
   
    if ( pszName == NULL ||
         ppfnRoutine == NULL ||
         ppfnRoutineW == NULL )
    {
        DBG_ASSERT( FALSE );
        return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
    }
   
    DBG_ASSERT( sm_pRequestHash != NULL );
    
    lkrc = sm_pRequestHash->FindKey( pszName,
                                     &pServerVariableRecord );
    if ( lkrc != LK_SUCCESS )
    {
        return HRESULT_FROM_WIN32( ERROR_FILE_NOT_FOUND );
    }
    else
    {
        DBG_ASSERT( pServerVariableRecord != NULL );
        
        *ppfnRoutine = pServerVariableRecord->_pfnRoutine;
        *ppfnRoutineW = pServerVariableRecord->_pfnRoutineW;
        
        return NO_ERROR;
    }
}

//static
HRESULT
SERVER_VARIABLE_HASH::GetServerVariable(
    W3_CONTEXT *            pW3Context,
    CHAR *                  pszVariableName,
    CHAR *                  pszBuffer,
    DWORD *                 pcbBuffer
)
/*++

Routine Description:

    Get server variable

Arguments:

    pW3Context - W3_CONTEXT with request state.  Can be NULL if we are
                 just determining whether the server variable requested is
                 valid.
    pszVariable - Variable name to retrieve
    pszBuffer - Filled with variable on success
    pcbBuffer - On input, the size of input buffer.  On out, the required size

Return Value:

    HRESULT

--*/
{
    HRESULT hr;

    if (pszVariableName[0] == 'U' &&
        strncmp(pszVariableName, "UNICODE_", 8) == 0)
    {
        STACK_STRU (strValW, MAX_PATH);

        if (FAILED( hr = GetServerVariableW( pW3Context,
                                             pszVariableName + 8,
                                             &strValW ) ) ||
            FAILED( hr = strValW.CopyToBuffer( (LPWSTR)pszBuffer, 
                                               pcbBuffer ) ) )
        {
            return hr;
        }
    }
    else
    {
        STACK_STRA (strVal, MAX_PATH);

        if (FAILED( hr = GetServerVariable( pW3Context,
                                            pszVariableName,
                                            &strVal ) ) ||
            FAILED( hr = strVal.CopyToBuffer( pszBuffer, 
                                              pcbBuffer ) ) )
        {
            return hr;
        }
    }

    return S_OK;
}


//static
HRESULT
SERVER_VARIABLE_HASH::GetServerVariable(
    W3_CONTEXT *            pW3Context,
    CHAR *                  pszVariableName,
    STRA *                  pstrVal
)
/*++

Routine Description:

    Get server variable

Arguments:

    pW3Context - W3_CONTEXT with request state.  Can be NULL if we are
                 just determining whether the server variable requested is
                 valid.  If NULL, we will return an empty string (and success)
                 if the variable requested is valid.
    pszVariable - Variable name to retrieve
    pstrVal - Filled with variable on success

Return Value:

    HRESULT

--*/
{
    HRESULT                         hr = S_OK;
    PFN_SERVER_VARIABLE_ROUTINE     pfnRoutine = NULL;
    PFN_SERVER_VARIABLE_ROUTINE_W   pfnRoutineW = NULL;

    //
    // First:  Is this a server variable we know about?  If so handle it
    //         by calling the appropriate server variable routine
    //

    hr = SERVER_VARIABLE_HASH::GetServerVariableRoutine( pszVariableName,
                                                         &pfnRoutine,
                                                         &pfnRoutineW );
    if ( SUCCEEDED(hr) )
    {
        DBG_ASSERT( pfnRoutine != NULL );

        if ( pW3Context != NULL )
        {
            return pfnRoutine( pW3Context, pstrVal );
        }
        else
        {
            //
            // Just return empty string to signify that the variable is 
            // valid but we just don't know the value at this time
            //
            
            return pstrVal->Copy( "", 0 );
        }
    }

    //
    // Second:  Is this a header name (prefixed with HTTP_)
    //

    if ( pW3Context != NULL &&
         pszVariableName[ 0 ] == 'H' &&
         !strncmp( pszVariableName, "HTTP_" , 5 ) )
    {   
        STACK_STRA(        strVariable, 256 );

        hr = strVariable.Copy( pszVariableName + 5 );
        if ( FAILED( hr ) )
        {
            return hr;
        }

        // Change '_' to '-'
        PCHAR pszCursor = strchr( strVariable.QueryStr(), '_' );
        while ( pszCursor != NULL )
        {
            *pszCursor++ = '-';
            pszCursor = strchr( pszCursor, '_' );
        }

        return pW3Context->QueryRequest()->GetHeader( strVariable,
                                                      pstrVal );
    }

    return HRESULT_FROM_WIN32( ERROR_INVALID_INDEX );
}

//static
HRESULT
SERVER_VARIABLE_HASH::GetServerVariableW(
    W3_CONTEXT *            pW3Context,
    CHAR *                  pszVariableName,
    STRU *                  pstrVal
)
/*++

Routine Description:

    Get server variable

Arguments:

    pW3Context - W3_CONTEXT with request state.  Can be NULL if we are
                 just determining whether the server variable requested is
                 valid.  If NULL, we will return an empty string (and success)
                 if the variable requested is valid.
    pszVariable - Variable name to retrieve
    pstrVal - Filled with variable on success

Return Value:

    HRESULT

--*/
{
    HRESULT                         hr = S_OK;
    PFN_SERVER_VARIABLE_ROUTINE  pfnRoutine = NULL;
    PFN_SERVER_VARIABLE_ROUTINE_W   pfnRoutineW = NULL;

    hr = SERVER_VARIABLE_HASH::GetServerVariableRoutine( pszVariableName,
                                                         &pfnRoutine,
                                                         &pfnRoutineW );
    if ( SUCCEEDED(hr) )
    {
        if (pW3Context == NULL)
        {
            //
            // Just return empty string to signify that the variable is 
            // valid but we just don't know the value at this time
            //

            return pstrVal->Copy( L"", 0 );
        }

        if (pfnRoutineW != NULL)
        {
            //
            // This server-variable contains real unicode data and there
            // is a unicode ServerVariable routine for this
            //

            return pfnRoutineW( pW3Context, pstrVal );
        }
        else
        {
            //
            // No unicode version, use the ANSI version and just wide'ize it
            //
            STACK_STRA( straVal, 256);

            DBG_ASSERT( pfnRoutine != NULL );

            if (FAILED(hr = pfnRoutine( pW3Context, &straVal )) ||
                FAILED(hr = pstrVal->CopyA( straVal.QueryStr(),
                                            straVal.QueryCCH() )))
            {
                return hr;
            }

            return S_OK;
        }
    }

    return HRESULT_FROM_WIN32( ERROR_INVALID_INDEX );
}

//
// Server variable functions
//

HRESULT
GetServerVariableQueryString(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );

    return pW3Context->QueryRequest()->GetQueryStringA(pstrVal);
}

HRESULT
GetServerVariableAllHttp(   
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );
    
    return pW3Context->QueryRequest()->GetAllHeaders( pstrVal, TRUE );
}

HRESULT
GetServerVariableAllRaw(   
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );
    
    return pW3Context->QueryRequest()->GetAllHeaders( pstrVal, FALSE );
}

HRESULT
GetServerVariableContentLength(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );
    
    PCHAR   pszContentLength;
    CHAR    szMinusOne[33];  // Max documented size of _ultoa

    if ( pW3Context->QueryRequest()->IsChunkedRequest() )
    {
        _ultoa( (unsigned long) -1, szMinusOne, 10 );
        pszContentLength = szMinusOne;
    }
    else
    {
        pszContentLength = pW3Context->QueryRequest()->
            GetHeader( HttpHeaderContentLength );
    }

    if ( pszContentLength == NULL )
    {
        pszContentLength = "0";
    }   

    return pstrVal->Copy( pszContentLength );
}

HRESULT
GetServerVariableContentType(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );
    
    PCHAR pszContentType = pW3Context->QueryRequest()->
        GetHeader( HttpHeaderContentType );
    if ( pszContentType == NULL )
    {
        pszContentType = "";
    }   

    return pstrVal->Copy( pszContentType );
}

HRESULT
GetServerVariableInstanceId(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );
    
    CHAR      pszId[16];
    _itoa( pW3Context->QueryRequest()->QuerySiteId(), pszId, 10 );

    return pstrVal->Copy( pszId );
}

HRESULT
GetServerVariableRemoteHost(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    HRESULT         hr;
    
    DBG_ASSERT( pW3Context != NULL );

    //
    // If we have a resolved DNS name, then use it.  Otherwise just
    // return the address
    //

    hr = pW3Context->QueryMainContext()->GetRemoteDNSName( pstrVal );
    if ( hr == HRESULT_FROM_WIN32( ERROR_NOT_SUPPORTED ) )
    {
        hr = GetServerVariableRemoteAddr( pW3Context, pstrVal );
    }
    
    return hr;
}

HRESULT
GetServerVariableRemoteAddr(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );
    
    DWORD dwAddr = pW3Context->QueryRequest()->QueryRemoteAddress();

    //
    // The dwAddr is reverse order from in_addr...
    //

    in_addr     inAddr;
    inAddr.S_un.S_un_b.s_b1 = (u_char)(( dwAddr & 0xff000000 ) >> 24);
    inAddr.S_un.S_un_b.s_b2 = (u_char)(( dwAddr & 0x00ff0000 ) >> 16);
    inAddr.S_un.S_un_b.s_b3 = (u_char)(( dwAddr & 0x0000ff00 ) >> 8);
    inAddr.S_un.S_un_b.s_b4 = (u_char) ( dwAddr & 0x000000ff );

    LPSTR pszAddr = inet_ntoa( inAddr );
    if ( pszAddr == NULL )
    {
        return HRESULT_FROM_WIN32( GetLastError() );
    }

    return pstrVal->Copy( pszAddr );
}

HRESULT
GetServerVariableServerName(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );

    //
    // If the client send a host name, use it.
    //

    CHAR *szHost = pW3Context->QueryRequest()->GetHeader( HttpHeaderHost );

    if ( szHost )
    {
        CHAR *pszColon = strchr( szHost, ':' );

        if (pszColon == NULL)
        {
            return pstrVal->Copy( szHost );
        }
        else
        {
            return pstrVal->Copy( szHost,
                                  DIFF( pszColon - szHost ) );
        }
    }

    //
    // No host from the client, so populate the buffer with
    // the IP address.
    //

    DWORD dwAddr = pW3Context->QueryRequest()->QueryLocalAddress();

    //
    // The dwAddr is reverse order from in_addr...
    //

    in_addr inAddr;
    inAddr.S_un.S_un_b.s_b1 = (u_char)(( dwAddr & 0xff000000 ) >> 24);
    inAddr.S_un.S_un_b.s_b2 = (u_char)(( dwAddr & 0x00ff0000 ) >> 16);
    inAddr.S_un.S_un_b.s_b3 = (u_char)(( dwAddr & 0x0000ff00 ) >> 8);
    inAddr.S_un.S_un_b.s_b4 = (u_char) ( dwAddr & 0x000000ff );

    LPSTR pszAddr = inet_ntoa( inAddr );
    if ( pszAddr == NULL )
    {
        return HRESULT_FROM_WIN32( GetLastError() );
    }

    return pstrVal->Copy( pszAddr );
}

HRESULT
GetServerVariableServerPort(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );

    USHORT port = pW3Context->QueryRequest()->QueryLocalPort();

    CHAR szPort[8];
    _itoa( port, szPort, 10 );

    return pstrVal->Copy( szPort );
}

HRESULT
GetServerVariablePathInfo(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );

    URL_CONTEXT *pUrlContext;
    pUrlContext = pW3Context->QueryUrlContext();

    //
    // We might be called in an early filter where URL context isn't available
    //

    if ( pUrlContext == NULL )
    {
        pstrVal->Reset();
        return NO_ERROR;
    }

    W3_URL_INFO *pUrlInfo;
    DBG_REQUIRE( pUrlInfo = pUrlContext->QueryUrlInfo() );

    W3_SITE *pSite;
    DBG_REQUIRE( pSite = pW3Context->QuerySite() );

    W3_HANDLER *pHandler;
    pHandler = pW3Context->QueryHandler();

    HRESULT hr;

    //
    // In the case of script maps, if AllowPathInfoForScriptMappings
    // is not set for the site, we ignore path info, it is
    // just the URL
    //

    if ( pHandler != NULL &&
         pHandler->QueryScriptMapEntry() &&
         !pSite->QueryAllowPathInfoForScriptMappings() )
    {
        STACK_STRU (strUrl, MAX_PATH);
        if (FAILED(hr = pW3Context->QueryRequest()->GetUrl( &strUrl )) ||
            FAILED(hr = pstrVal->CopyW( strUrl.QueryStr() )))
        {
            return hr;
        }

        return S_OK;
    }
    else
    {
        // BUGBUG: do real conversion?
        return pstrVal->CopyW( pUrlInfo->QueryPathInfo()->QueryStr() );
    }
}

HRESULT
GetServerVariablePathInfoW(
    W3_CONTEXT *pW3Context,
    STRU       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );

    URL_CONTEXT *pUrlContext;
    pUrlContext = pW3Context->QueryUrlContext();

    //
    // We might be called in an early filter where URL context isn't available
    //

    if ( pUrlContext == NULL )
    {
        pstrVal->Reset();
        return NO_ERROR;
    }

    W3_URL_INFO *pUrlInfo;
    DBG_REQUIRE( pUrlInfo = pUrlContext->QueryUrlInfo() );

    W3_SITE *pSite;
    DBG_REQUIRE( pSite = pW3Context->QuerySite() );

    W3_HANDLER *pHandler;
    pHandler = pW3Context->QueryHandler();

    //
    // In the case of script maps, if AllowPathInfoForScriptMappings
    // is not set for the site, we ignore path info, it is
    // just the URL
    //

    if ( pHandler != NULL &&
         pHandler->QueryScriptMapEntry() &&
         !pSite->QueryAllowPathInfoForScriptMappings() )
    {
        return pW3Context->QueryRequest()->GetUrl( pstrVal );
    }
    else
    {
        return pstrVal->Copy( pUrlInfo->QueryPathInfo()->QueryStr() );
    }
}

HRESULT
GetServerVariablePathTranslated(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );

    HRESULT hr;

    URL_CONTEXT *pUrlContext;
    pUrlContext = pW3Context->QueryUrlContext();

    W3_URL_INFO *pUrlInfo;
    DBG_REQUIRE( pUrlInfo = pUrlContext->QueryUrlInfo() );

    W3_SITE *pSite;
    DBG_REQUIRE( pSite = pW3Context->QuerySite() );

    W3_HANDLER *pHandler;
    pHandler = pW3Context->QueryHandler();

    BOOL fUsePathInfo;
    if ( pHandler != NULL &&
         pHandler->QueryScriptMapEntry() &&
         !pSite->QueryAllowPathInfoForScriptMappings() )
    {
        fUsePathInfo = FALSE;
    }
    else
    {
        fUsePathInfo = TRUE;
    }

    STACK_STRU (struPathTranslated, 256);
    //
    // This is a new virtual path to have filters map
    //

    hr = pUrlInfo->GetPathTranslated( pW3Context,
                                      fUsePathInfo,
                                      &struPathTranslated );

    if (SUCCEEDED(hr))
    {
        // BUGBUG: do proper conversion?
        hr = pstrVal->CopyW( struPathTranslated.QueryStr() );
    }

    return hr;
}

HRESULT
GetServerVariablePathTranslatedW(
    W3_CONTEXT *pW3Context,
    STRU       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );

    URL_CONTEXT *pUrlContext;
    pUrlContext = pW3Context->QueryUrlContext();

    W3_URL_INFO *pUrlInfo;
    DBG_REQUIRE( pUrlInfo = pUrlContext->QueryUrlInfo() );

    W3_SITE *pSite;
    DBG_REQUIRE( pSite = pW3Context->QuerySite() );

    W3_HANDLER *pHandler;
    pHandler = pW3Context->QueryHandler();

    BOOL fUsePathInfo;
    if ( pHandler != NULL &&
         pHandler->QueryScriptMapEntry() &&
         !pSite->QueryAllowPathInfoForScriptMappings() )
    {
        fUsePathInfo = FALSE;
    }
    else
    {
        fUsePathInfo = TRUE;
    }

    //
    // This is a new virtual path to have filters map
    //

    return pUrlInfo->GetPathTranslated( pW3Context,
                                        fUsePathInfo,
                                        pstrVal );
}

HRESULT
GetServerVariableRequestMethod(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );
    
    return pW3Context->QueryRequest()->GetVerbString( pstrVal );
}

HRESULT
GetServerVariableServerPortSecure(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );
    
    if ( pW3Context->QueryRequest()->IsSecureRequest() )
    {
        return pstrVal->Copy("1", 1);
    }

    return pstrVal->Copy("0", 1);
}

HRESULT
GetServerVariableServerSoftware(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );

    //
    // BUGBUG - probably don't want this hardcoded...
    //
    return pstrVal->Copy( SERVER_SOFTWARE_STRING );
}

HRESULT
GetServerVariableUrl(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    URL_CONTEXT *       pUrlContext;
    W3_URL_INFO *       pUrlInfo;
    STACK_STRU(         strUrl, 256 );
    HRESULT             hr;
    
    DBG_ASSERT( pW3Context != NULL );
    
    //
    // URL context can be NULL if an early filter is called GetServerVar()
    //
    
    pUrlContext = pW3Context->QueryUrlContext();
    if ( pUrlContext != NULL )
    {
        pUrlInfo = pUrlContext->QueryUrlInfo();
        DBG_ASSERT( pUrlInfo != NULL );
        
        return pstrVal->CopyW( pUrlInfo->QueryProcessedUrl()->QueryStr() );
    }
    else
    {
        hr = pW3Context->QueryRequest()->GetUrl( &strUrl );
        if ( FAILED( hr ) )
        {
            return hr;
        }
        
        return pstrVal->CopyW( strUrl.QueryStr() );
    }
}

HRESULT
GetServerVariableUrlW(
    W3_CONTEXT *pW3Context,
    STRU       *pstrVal
)
{
    URL_CONTEXT *       pUrlContext;
    W3_URL_INFO *       pUrlInfo;
    
    DBG_ASSERT( pW3Context != NULL );
    
    //
    // URL context can be NULL if an early filter is called GetServerVar()
    //
    
    pUrlContext = pW3Context->QueryUrlContext();
    if ( pUrlContext != NULL )
    {
        pUrlInfo = pUrlContext->QueryUrlInfo();
        DBG_ASSERT( pUrlInfo != NULL );
        
        return pstrVal->Copy( pUrlInfo->QueryProcessedUrl()->QueryStr() );
    }
    else
    {
        return pW3Context->QueryRequest()->GetUrl( pstrVal );
    }
}

HRESULT
GetServerVariableInstanceMetaPath(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );

    STRU *pstrMetaPath = pW3Context->QuerySite()->QueryMBPath();
    DBG_ASSERT( pstrMetaPath );

    // BUGBUG: do proper conversion?
    return pstrVal->CopyW( pstrMetaPath->QueryStr() );
}

HRESULT
GetServerVariableLogonUser(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );
    
    W3_USER_CONTEXT *pUserContext;
    pUserContext = pW3Context->QueryUserContext();
    
    if ( pUserContext == NULL )
    {
        return pW3Context->QueryRequest()->GetRequestUserName( pstrVal );
    }
    else
    {
        return pstrVal->CopyW( pUserContext->QueryUserName() );
    }
}

HRESULT
GetServerVariableLogonUserW(
    W3_CONTEXT *pW3Context,
    STRU       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );
    
    W3_USER_CONTEXT *pUserContext;
    pUserContext = pW3Context->QueryUserContext();
    
    if ( pUserContext == NULL )
    {
        return pstrVal->CopyA( pW3Context->QueryRequest()->QueryRequestUserName()->QueryStr() );
    }
    else
    {
        return pstrVal->Copy( pUserContext->QueryUserName() );
    }

    return S_OK;
}

HRESULT
GetServerVariableRemoteUser(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    HRESULT                     hr;
    
    DBG_ASSERT( pW3Context != NULL );
    
    hr = pW3Context->QueryRequest()->GetRequestUserName( pstrVal );
    if ( FAILED( hr ) )
    {
        return hr;
    }
    
    if ( pstrVal->IsEmpty() )
    {
        W3_USER_CONTEXT *pUserContext;
        pUserContext = pW3Context->QueryUserContext();
        
        if ( pUserContext != NULL )
        {
            hr = pstrVal->CopyW( pUserContext->QueryRemoteUserName() );
        }
        else
        {
            hr = NO_ERROR;
        }
    }

    return hr;
}

HRESULT
GetServerVariableRemoteUserW(
    W3_CONTEXT *pW3Context,
    STRU       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );
    
    STRA *pstrUserName = pW3Context->QueryRequest()->QueryRequestUserName();
    
    if ( pstrUserName->IsEmpty() )
    {
        W3_USER_CONTEXT *pUserContext;
        pUserContext = pW3Context->QueryUserContext();
        
        if ( pUserContext != NULL )
        {
            return pstrVal->Copy( pUserContext->QueryRemoteUserName() );
        }
    }
    else
    {
        return pstrVal->CopyA( pstrUserName->QueryStr() );
    }

    return S_OK;
}

HRESULT
GetServerVariableAuthType(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );
    DBG_ASSERT( pstrVal != NULL );

    HRESULT hr = S_OK;

    W3_USER_CONTEXT *pUserContext = pW3Context->QueryUserContext();

    if ( pUserContext != NULL )
    {
        if ( pUserContext->QueryAuthType() == MD_ACCESS_MAP_CERT )
        {
            pstrVal->Copy( "SSL/PCT" );
        }
        else if ( pUserContext->QueryAuthType() == MD_AUTH_ANONYMOUS )
        {
            pstrVal->Copy( "" );
        }
        else
        {
            hr = pW3Context->QueryRequest()->GetAuthType( pstrVal );
        }
    }
    else
    {
        DBG_ASSERT ( FALSE );
        hr = HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
    }
    return hr;
}

HRESULT
GetServerVariableAuthPassword(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    W3_USER_CONTEXT *           pUserContext;
    
    DBG_ASSERT( pW3Context != NULL );
    pUserContext = pW3Context->QueryUserContext();
    DBG_ASSERT( pUserContext != NULL );

    return pstrVal->CopyW( pUserContext->QueryPassword() );
}

//
// CODEWORK
//
// GetServerVariableApplMdPath & GetServerVariableApplPhysicalPath
// both try to deal with missing or invalid MD_APP_PATH data. In IIS5
// they never had to, because MD_APP_PATH was used by wam when
// initiallizing the CWamInfo object. If/When we include applications
// into the isapi handler, these functions should be simplified.
// 
// TaylorW 3-27-00
//


HRESULT
GetServerVariableApplMdPath(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    //
    // CODEWORK - Child Execute
    //
    DBG_ASSERT( pW3Context != NULL );

    URL_CONTEXT *pUrlContext = pW3Context->QueryUrlContext();
    if (pUrlContext == NULL)
    {
        return E_FAIL;
    }

    W3_METADATA *pMetaData = pUrlContext->QueryMetaData();
    if (pMetaData == NULL)
    {
        return E_FAIL;
    }

    STRU *  pstrAppMetaPath = pMetaData->QueryAppMetaPath();
    HRESULT hr;

    if( pstrAppMetaPath->IsEmpty() )
    {
        //
        // This really shouldn't be necessary, because we should not
        // even start up if there is no application defined, but we
        // do right now and stress does not property call AppCreate.
        //

        W3_SITE * pSite = pW3Context->QuerySite();
        DBG_ASSERT( pSite );

        STRU * pstrSiteMetaRoot = pSite->QueryMBRoot();
        
        hr = pstrVal->CopyW( pstrSiteMetaRoot->QueryStr() );
    }
    else
    {
        hr = pstrVal->CopyW( pstrAppMetaPath->QueryStr() );
    }

    return hr;
}

HRESULT
GetServerVariableApplMdPathW(
    W3_CONTEXT *pW3Context,
    STRU       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );

    URL_CONTEXT *pUrlContext = pW3Context->QueryUrlContext();
    if (pUrlContext == NULL)
    {
        return E_FAIL;
    }

    W3_METADATA *pMetaData = pUrlContext->QueryMetaData();
    if (pMetaData == NULL)
    {
        return E_FAIL;
    }

    STRU *  pstrAppMetaPath = pMetaData->QueryAppMetaPath();
    HRESULT hr;

    if( pstrAppMetaPath->IsEmpty() )
    {
        //
        // This really shouldn't be necessary, because we should not
        // even start up if there is no application defined, but we
        // do right now and stress does not property call AppCreate.
        //

        W3_SITE * pSite = pW3Context->QuerySite();
        DBG_ASSERT( pSite );

        STRU * pstrSiteMetaRoot = pSite->QueryMBRoot();
        
        hr = pstrVal->Copy( pstrSiteMetaRoot->QueryStr() );
    }
    else
    {
        hr = pstrVal->Copy( pstrAppMetaPath->QueryStr() );
    }

    return hr;
}

HRESULT
GetServerVariableApplPhysicalPath(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );
    DBG_ASSERT( pstrVal );

    STACK_STRA( strAppMetaPath, MAX_PATH );
    STACK_STRU( strAppUrl, MAX_PATH );
    HRESULT     hr = E_FAIL;

    hr = GetServerVariableApplMdPath( pW3Context, &strAppMetaPath );

    if( SUCCEEDED(hr) )
    {
        //
        // pstrAppMetaPath is a full metabase path:
        //      /LM/W3SVC/<site>/Root/...
        //
        // To convert it to a physical path we will use 
        // W3_STATE_URLINFO::MapPath, but this requires 
        // that we remove the metabase prefixes and build 
        // a Url string.
        //

        //
        // Get the metabase path for the site root
        //

        W3_SITE *pSite = pW3Context->QuerySite();
        DBG_ASSERT( pSite );

        STRU *pstrSiteRoot = pSite->QueryMBRoot();
        DBG_ASSERT( pstrSiteRoot );

        //
        // Make some assumptions about the site path and the AppMetaPath 
        // being well-formed. The AppMetaPath may not have a terminating 
        // /, but the site root will.
        //
    
        DBG_ASSERT( pstrSiteRoot->QueryCCH() >= 
                    sizeof("/LM/W3SVC/1/Root/") - 1 
                    );

        if( strAppMetaPath.QueryCCH() < pstrSiteRoot->QueryCCH() - 1 )
        {
            //
            // This indicates an invalid value for MD_APP_ROOT is sitting
            // around. We need to bail if this is the case.
            //

            DBGPRINTF(( DBG_CONTEXT,
                        "Invalid MD_APP_ROOT detected (%s)\n",
                        strAppMetaPath.QueryStr()
                        ));
            
            return HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
        }

        DBG_ASSERT( strAppMetaPath.QueryCCH() >= 
                    sizeof("/LM/W3SVC/1/Root/") - 2 
                    );

        //
        // The AppUrl will be the metabase path - 
        // all the /LM/W3SVC/1/ROOT goo
        //

        CHAR * pszStartAppUrl = strAppMetaPath.QueryStr() + 
            (pstrSiteRoot->QueryCCH() - 1);

        //
        // The AppMetaPath may not have a terminating /, so if it is 
        // a site root pszStartAppUrl will be empty.
        //
    
        if( *pszStartAppUrl != '\0' )
        {
            if( *pszStartAppUrl != '/' )
            {
                DBGPRINTF(( DBG_CONTEXT,
                            "Invalid MD_APP_ROOT detected (%s)\n",
                            strAppMetaPath.QueryStr()
                            ));
            
                return HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
            }

            hr = strAppUrl.CopyA(
                    pszStartAppUrl,
                    strAppMetaPath.QueryCCH() - (pstrSiteRoot->QueryCCH() - 1)
                    );
        }
        else
        {
            hr = strAppUrl.Copy( L"/", 1 );
        }

        if( SUCCEEDED(hr) )
        {
            STACK_STRU (strAppPath, MAX_PATH);
            //
            // Convert to a physical path
            //

            hr = W3_STATE_URLINFO::MapPath( pW3Context,
                                            strAppUrl,
                                            &strAppPath,
                                            NULL,
                                            NULL,
                                            NULL
                                            );
            if (SUCCEEDED(hr))
            {
                hr = pstrVal->CopyW(strAppPath.QueryStr());

                //
                // Ensure that the last character in the path
                // is '\\'.  There are legacy scripts that will
                // concatenate filenames to this path, and many
                // of them will break if we don't do this.
                //

                if ( SUCCEEDED( hr ) &&
                     *(pstrVal->QueryStr()+pstrVal->QueryCCH()-1) != '\\' )
                {
                    hr = pstrVal->Append( "\\" );
                }
            }
        }
    }

    return hr;
}

HRESULT
GetServerVariableApplPhysicalPathW(
    W3_CONTEXT *pW3Context,
    STRU       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );
    DBG_ASSERT( pstrVal );

    STACK_STRU( strAppMetaPath, MAX_PATH );
    STACK_STRU( strAppUrl, MAX_PATH );
    HRESULT     hr = E_FAIL;

    hr = GetServerVariableApplMdPathW( pW3Context, &strAppMetaPath );

    if( SUCCEEDED(hr) )
    {
        //
        // pstrAppMetaPath is a full metabase path:
        //      /LM/W3SVC/<site>/Root/...
        //
        // To convert it to a physical path we will use 
        // W3_STATE_URLINFO::MapPath, but this requires 
        // that we remove the metabase prefixes and build 
        // a Url string.
        //

        //
        // Get the metabase path for the site root
        //

        W3_SITE *pSite = pW3Context->QuerySite();
        DBG_ASSERT( pSite );

        STRU *pstrSiteRoot = pSite->QueryMBRoot();
        DBG_ASSERT( pstrSiteRoot );

        //
        // Make some assumptions about the site path and the AppMetaPath 
        // being well-formed. The AppMetaPath may not have a terminating 
        // /, but the site root will.
        //
    
        DBG_ASSERT( pstrSiteRoot->QueryCCH() >= 
                    sizeof("/LM/W3SVC/1/Root/") - 1 
                    );

        if( strAppMetaPath.QueryCCH() < pstrSiteRoot->QueryCCH() - 1 )
        {
            //
            // This indicates an invalid value for MD_APP_ROOT is sitting
            // around. We need to bail if this is the case.
            //

            DBGPRINTF(( DBG_CONTEXT,
                        "Invalid MD_APP_ROOT detected (%S)\n",
                        strAppMetaPath.QueryStr()
                        ));
            
            return HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
        }

        DBG_ASSERT( strAppMetaPath.QueryCCH() >= 
                    sizeof("/LM/W3SVC/1/Root/") - 2 
                    );

        //
        // The AppUrl will be the metabase path - 
        // all the /LM/W3SVC/1/ROOT goo
        //

        WCHAR * pszStartAppUrl = strAppMetaPath.QueryStr() + 
            (pstrSiteRoot->QueryCCH() - 1);

        //
        // The AppMetaPath may not have a terminating /, so if it is 
        // a site root pszStartAppUrl will be empty.
        //
    
        if( *pszStartAppUrl != L'\0' )
        {
            if( *pszStartAppUrl != L'/' )
            {
                DBGPRINTF(( DBG_CONTEXT,
                            "Invalid MD_APP_ROOT detected (%s)\n",
                            strAppMetaPath.QueryStr()
                            ));
            
                return HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
            }

            hr = strAppUrl.Copy(
                    pszStartAppUrl,
                    strAppMetaPath.QueryCCH() - (pstrSiteRoot->QueryCCH() - 1)
                    );
        }
        else
        {
            hr = strAppUrl.Copy( L"/", 1 );
        }

        if( SUCCEEDED(hr) )
        {
            hr =  W3_STATE_URLINFO::MapPath( pW3Context,
                                              strAppUrl,
                                              pstrVal,
                                              NULL,
                                              NULL,
                                              NULL
                                              );

            //
            // Ensure that the last character in the path
            // is '\\'.  There are legacy scripts that will
            // concatenate filenames to this path, and many
            // of them will break if we don't do this.
            //

            if ( SUCCEEDED( hr ) &&
                 *(pstrVal->QueryStr()+pstrVal->QueryCCH()-1) != L'\\' )
            {
                hr = pstrVal->Append( L"\\" );
            }
        }
    }

    return hr;
}

HRESULT
GetServerVariableGatewayInterface(
    W3_CONTEXT *pW3Context,
    STRA       *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );

    return pstrVal->Copy("CGI/1.1", 7);
}

HRESULT GetServerVariableLocalAddr(
    W3_CONTEXT *pW3Context,
    STRA *pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );

    DWORD dwAddr = pW3Context->QueryRequest()->QueryLocalAddress();

    //
    // The dwAddr is reverse order from in_addr...
    //

    in_addr inAddr;
    inAddr.S_un.S_un_b.s_b1 = (u_char)(( dwAddr & 0xff000000 ) >> 24);
    inAddr.S_un.S_un_b.s_b2 = (u_char)(( dwAddr & 0x00ff0000 ) >> 16);
    inAddr.S_un.S_un_b.s_b3 = (u_char)(( dwAddr & 0x0000ff00 ) >> 8);
    inAddr.S_un.S_un_b.s_b4 = (u_char) ( dwAddr & 0x000000ff );

    LPSTR pszAddr = inet_ntoa( inAddr );
    if ( pszAddr == NULL )
    {
        return HRESULT_FROM_WIN32( GetLastError() );
    }

    return pstrVal->Copy( pszAddr );
}

HRESULT GetServerVariableHttps(
    W3_CONTEXT *pW3Context,
    STRA *pstrVal)
{
    DBG_ASSERT( pW3Context != NULL );

    if (pW3Context->QueryRequest()->IsSecureRequest())
    {
        return pstrVal->Copy("on", 2);
    }

    return pstrVal->Copy("off", 3);
}

HRESULT
GetServerVariableHttpsKeySize(
    W3_CONTEXT *            pW3Context,
    STRA *                  pstrVal
)
{
    HTTP_SSL_INFO *         pSslInfo;
    CHAR                    achNum[ 64 ];
    
    pSslInfo = pW3Context->QueryRequest()->QuerySslInfo();
    if ( pSslInfo == NULL )
    {
        achNum[ 0 ] = '\0';
    }
    else
    {
        _itoa( pSslInfo->ConnectionKeySize,
               achNum,
               10 );
    }
    
    return pstrVal->Copy( achNum );
}

HRESULT
GetServerVariableClientCertIssuer(
    W3_CONTEXT *            pW3Context,
    STRA *                  pstrVal
)
{
    CERTIFICATE_CONTEXT *       pCertContext;
    
    pCertContext = pW3Context->QueryMainContext()->QueryCertificateContext();
    if ( pCertContext == NULL )
    {
        return pstrVal->Copy( "", 0 ); 
    }
    else
    {
        return pCertContext->GetIssuer( pstrVal );
    }
}

HRESULT
GetServerVariableClientCertSubject(
    W3_CONTEXT *            pW3Context,
    STRA *                  pstrVal
)
{
    CERTIFICATE_CONTEXT *       pCertContext;
    
    pCertContext = pW3Context->QueryMainContext()->QueryCertificateContext();
    if ( pCertContext == NULL )
    {
        return pstrVal->Copy( "", 0 ); 
    }
    else
    {
        return pCertContext->GetSubject( pstrVal );
    }
}

HRESULT
GetServerVariableClientCertCookie(
    W3_CONTEXT *            pW3Context,
    STRA *                  pstrVal
)
{
    CERTIFICATE_CONTEXT *       pCertContext;
    
    pCertContext = pW3Context->QueryMainContext()->QueryCertificateContext();
    if ( pCertContext == NULL )
    {
        return pstrVal->Copy( "", 0 ); 
    }
    else
    {
        return pCertContext->GetCookie( pstrVal );
    }
}

HRESULT
GetServerVariableClientCertSerialNumber(
    W3_CONTEXT *            pW3Context,
    STRA *                  pstrVal
)
{
    CERTIFICATE_CONTEXT *       pCertContext;
    
    pCertContext = pW3Context->QueryMainContext()->QueryCertificateContext();
    if ( pCertContext == NULL )
    {
        return pstrVal->Copy( "", 0 ); 
    }
    else
    {
        return pCertContext->GetSerialNumber( pstrVal );
    }
}

HRESULT
GetServerVariableClientCertFlags(
    W3_CONTEXT *            pW3Context,
    STRA *                  pstrVal
)
{
    CERTIFICATE_CONTEXT *       pCertContext;
    
    pCertContext = pW3Context->QueryMainContext()->QueryCertificateContext();
    if ( pCertContext == NULL )
    {
        return pstrVal->Copy( "0", 1 ); 
    }
    else
    {
        return pCertContext->GetFlags( pstrVal );
    }
}

HRESULT
GetServerVariableHttpsSecretKeySize(
    W3_CONTEXT *            pW3Context,
    STRA *                  pstrVal
)
{
    HTTP_SSL_INFO *         pSslInfo;
    CHAR                    achNum[ 64 ];

    pSslInfo = pW3Context->QueryRequest()->QuerySslInfo();
    if ( pSslInfo == NULL )
    {
        achNum[ 0 ] = '\0';
    }
    else
    {
        _itoa( pSslInfo->ServerCertKeySize,
              achNum,
              10 );
    }
    
    return pstrVal->Copy( achNum );
}

HRESULT
GetServerVariableHttpsServerIssuer(
    W3_CONTEXT *            pW3Context,
    STRA *                  pstrVal
)
{
    HTTP_SSL_INFO *         pSslInfo;
    CHAR *                  pszVariable;
    
    pSslInfo = pW3Context->QueryRequest()->QuerySslInfo();
    if ( pSslInfo == NULL )
    {
        pszVariable = "";
    }
    else
    {
        DBG_ASSERT( pSslInfo->pServerCertIssuer != NULL );
        pszVariable = pSslInfo->pServerCertIssuer;
    }
    
    return pstrVal->Copy( pszVariable );
}

HRESULT
GetServerVariableHttpsServerSubject(
    W3_CONTEXT *            pW3Context,
    STRA *                  pstrVal
)
{
    HTTP_SSL_INFO *         pSslInfo;
    CHAR *                  pszVariable;
    
    pSslInfo = pW3Context->QueryRequest()->QuerySslInfo();
    if ( pSslInfo == NULL )
    {
        pszVariable = "";
    }
    else
    {
        DBG_ASSERT( pSslInfo->pServerCertSubject != NULL );
        pszVariable = pSslInfo->pServerCertSubject;
    }
    
    return pstrVal->Copy( pszVariable );
}

HRESULT
GetServerVariableHttpUrl(
    W3_CONTEXT *            pW3Context,
    STRA *                  pstrVal
)
{
    //
    // HTTP_URL gets the raw url for the request. If a filter has
    // modified the url the request object handles redirecting the
    // RawUrl variable 
    //

    DBG_ASSERT( pW3Context != NULL );
        
    return pW3Context->QueryRequest()->GetRawUrl( pstrVal );
}

HRESULT
GetServerVariableHttpVersion(
    W3_CONTEXT *            pW3Context,
    STRA *                  pstrVal
)
{
    //
    // HTTP_VERSION returns the client version string
    //

    DBG_ASSERT( pW3Context != NULL );

    return pW3Context->QueryRequest()->GetVersionString( pstrVal );
}

HRESULT
GetServerVariableAppPoolId(
    W3_CONTEXT *            pW3Context,
    STRA *                  pstrVal
)
{
    //
    // APP_POOL_ID returns the AppPoolId WAS started us with
    //

    DBG_ASSERT( pW3Context != NULL );

    return pstrVal->CopyW( (LPWSTR)UlAtqGetContextProperty(NULL,
                                                           ULATQ_PROPERTY_APP_POOL_ID) );
}

HRESULT
GetServerVariableAppPoolIdW(
    W3_CONTEXT *            pW3Context,
    STRU *                  pstrVal
)
{
    //
    // APP_POOL_ID returns the AppPoolId WAS started us with
    //

    DBG_ASSERT( pW3Context != NULL );

    return pstrVal->Copy( (LPWSTR)UlAtqGetContextProperty(NULL,
                                                          ULATQ_PROPERTY_APP_POOL_ID) );
}

HRESULT
GetServerVariableScriptTranslated(
    W3_CONTEXT *            pW3Context,
    STRA *                  pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );

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

    return pstrVal->CopyW( pUrlContext->QueryPhysicalPath()->QueryStr() );
}

HRESULT
GetServerVariableScriptTranslatedW(
    W3_CONTEXT *            pW3Context,
    STRU *                  pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );

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

    return pstrVal->Copy( *pUrlContext->QueryPhysicalPath() );
}

HRESULT
GetServerVariableUnencodedUrl(
    W3_CONTEXT *            pW3Context,
    STRA *                  pstrVal
)
{
    DBG_ASSERT( pW3Context != NULL );

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

    return pW3Request->GetRawUrl(pstrVal);
}