Export (0) Print
Expand All
Expand Minimize

IHttpContext::SetRequestHandled Method

IIS 7.0

Indicates that the handlers for the current request have completed.

virtual VOID SetRequestHandled(
   VOID
) = 0;

This method takes no parameters.

The SetRequestHandled method specifies that the handlers for the current request have finished processing. For example, if multiple request handlers are configured for a specific file type, you can use the SetRequestHandled method to indicate that processing has completed for the current request and that additional handlers should not be executed.

The following code example demonstrates how to create an HTTP module that performs the following tasks:

  1. The module registers for the RQ_PRE_EXECUTE_REQUEST_HANDLER notification.

  2. The module creates a CHttpModule class that contains an OnPreExecuteRequestHandler method.

  3. When a Web client requests a URL, IIS calls the module's OnPreExecuteRequestHandler method. This method performs the following tasks

    1. Retrieves a pointer to an IScriptMapInfo interface.

    2. Retrieves the script handler for the request by using the IScriptMapInfo::GetScriptProcessor method.

    3. If the request is for an ASP page, returns a message to the Web client that the request has been handled, and then calls the SetRequestHandled method to set the request as handled.

  4. The module removes the CHttpModule class from memory and then exits.

#define _WINSOCKAPI_
#include <windows.h>
#include <sal.h>
#include <httpserv.h>

// Create the module class.
class MyHttpModule : public CHttpModule
{
public:
    REQUEST_NOTIFICATION_STATUS
    OnPreExecuteRequestHandler(
        IN IHttpContext* pHttpContext,
        IN IHttpEventProvider* pProvider
    )
    {
        UNREFERENCED_PARAMETER( pProvider );

        // Retrieve an IScriptMapInfo interface.
        IScriptMapInfo * pScriptMapInfo = pHttpContext->GetScriptMap();

        // Test for an error.
        if (NULL != pScriptMapInfo)
        {
            // Create buffers to store the script processor path.
            PCWSTR pwszScriptProcessor;
            DWORD  cchScriptProcessor = 0;

            // Retrieve the script processor.
            pwszScriptProcessor =
                pScriptMapInfo->GetScriptProcessor(&cchScriptProcessor);

            // Test for an error.
            if ((pwszScriptProcessor != NULL) && (cchScriptProcessor > 0))
            {
                // Test for an ASP request.
                if (NULL != wcsstr(pwszScriptProcessor,L"\\asp.dll"))
                {
                    // Clear the existing response.
                    pHttpContext->GetResponse()->Clear();
                    // Set the MIME type to plain text.
                    pHttpContext->GetResponse()->SetHeader(
                        HttpHeaderContentType,"text/plain",
                        (USHORT)strlen("text/plain"),TRUE);
                    // Return a status message.
                    WriteResponseMessage(pHttpContext,
                        "ASP requests have been handled.");
                    // Indicate that handlers for this request have completed.
                    pHttpContext->SetRequestHandled();                    
                }
            }
        }         
        // Return processing to the pipeline.    
        return RQ_NOTIFICATION_CONTINUE;
    }

private:

    // Create a utility method that inserts a string value into the response.
    HRESULT WriteResponseMessage(
        IHttpContext * pHttpContext,
        PCSTR pszBuffer
    )
    {
        // Create an HRESULT to receive return values from methods.
        HRESULT hr;

        // Create a data chunk. (Defined in the Http.h file.)
        HTTP_DATA_CHUNK dataChunk;
        // Set the chunk to a chunk in memory.
        dataChunk.DataChunkType = HttpDataChunkFromMemory;
        // Buffer for bytes written of data chunk.
        DWORD cbSent;

        // Set the chunk to the buffer.
        dataChunk.FromMemory.pBuffer =
            (PVOID) pszBuffer;
        // Set the chunk size to the buffer size.
        dataChunk.FromMemory.BufferLength =
            (USHORT) strlen(pszBuffer);
        // Insert the data chunk into the response.
        hr = pHttpContext->GetResponse()->WriteEntityChunks(
            &dataChunk,1,FALSE,TRUE,&cbSent);
        // Test for an error.
        if (FAILED(hr))
        {
            // Return the error status.
            return hr;
        }

        // Return a success status.
        return S_OK;
    }
};

// Create the module's class factory.
class MyHttpModuleFactory : public IHttpModuleFactory
{
public:
    HRESULT
    GetHttpModule(
        OUT CHttpModule ** ppModule, 
        IN IModuleAllocator * pAllocator
    )
    {
        UNREFERENCED_PARAMETER( pAllocator );

        // Create a new instance.
        MyHttpModule * pModule = new MyHttpModule;

        // Test for an error.
        if (!pModule)
        {
            // Return an error if we cannot create the instance.
            return HRESULT_FROM_WIN32( ERROR_NOT_ENOUGH_MEMORY );
        }
        else
        {
            // Return a pointer to the module.
            *ppModule = pModule;
            pModule = NULL;
            // Return a success status.
            return S_OK;
        }            
    }

    void Terminate()
    {
        // Remove the class from memory.
        delete this;
    }
};

// Create the module's exported registration function.
HRESULT
__stdcall
RegisterModule(
    DWORD dwServerVersion,
    IHttpModuleRegistrationInfo * pModuleInfo,
    IHttpServer * pGlobalInfo
)
{
    UNREFERENCED_PARAMETER( dwServerVersion );
    UNREFERENCED_PARAMETER( pGlobalInfo );

    // Set the request notifications and exit.
    return pModuleInfo->SetRequestNotifications(
        new MyHttpModuleFactory,
        RQ_PRE_EXECUTE_REQUEST_HANDLER,
        0
    );
}


Your module must export the RegisterModule function. You can export this function by creating a module definition (.def) file for your project, or you can compile the module by using the /EXPORT:RegisterModule switch. For more information, see Walkthrough: Creating a Request-Level HTTP Module By Using Native Code.

You can compile the code by using the __stdcall (/Gz) calling convention instead of explicitly declaring the calling convention for each function.

Type

Description

Client

  • IIS 7.0 on Windows Vista

  • IIS 7.5 on Windows 7

  • IIS Express 7.5 on Windows XP, Windows Vista, Windows 7

  • IIS 8.0 on Windows 8 Client

Server

  • IIS 7.0 on Windows Server 2008

  • IIS 7.5 on Windows Server 2008 R2

  • IIS Express 7.5 on Windows Server 2003, Windows Server 2008, Windows Server 2008 R2

  • IIS 8.0 on Windows Server 2012

Product

IIS 7.0, IIS 7.5, IIS Express 7.5, IIS 8.0

Header

Httpserv.h

Community Additions

ADD
Show:
© 2014 Microsoft