Chip 1998 February/CHIP_2_98.iso/software/pelne/optionp/iis4_07.cab/cte_enc.c

C/C++ Source or Header | 1997-10-25 | 7KB | 336 lines

/*++

Copyright (c) 1997 Microsoft Corporation

Module Name:

    cte_enc.c

Abstract:

    This module contains routines implementing Chunked Transfer
    Encoding (CTE) for ISAPI Extension DLLs. See Section 3.6
    "Transfer Codings" of RFC 2068 for details.

Functions:
    CteBeginWrite
    CteWrite
    CteEndWrite

--*/


#include "ctetest.h"


//
// Encoder context structure
//

typedef struct CTE_ENCODER_STRUCT {
    EXTENSION_CONTROL_BLOCK * pECB;         // a copy of current ECB pointer
    DWORD                     dwChunkSize;  // user-specified chunk size
    DWORD                     cbData;       // number of bytes in the buffer
    BYTE *                    pData;        // pointer to chunk data bytes
} CTE_ENCODER;

//
// Chunk header consists of HEX string for the chunk size in bytes
// (DWORD needs up to 8 bytes in HEX), followed by CRLF,
// therefore the maximum chunk header size is 10 bytes.
//

#define CTE_MAX_CHUNK_HEADER_SIZE 10

//
// Chunk data is always followed by CRLF
//

#define CTE_MAX_ENCODING_OVERHEAD (CTE_MAX_CHUNK_HEADER_SIZE + 2)

//
// Total encoder size includes:
//   the size of the encoder context structure itself,
//   the chunk data size,
//   the maximum encoding overhead (header and terminating CRLF)
//

#define CTE_ENCODER_SIZE(dwChunkSize) \
    (sizeof(CTE_ENCODER) + dwChunkSize + CTE_MAX_ENCODING_OVERHEAD)



HCTE_ENCODER
CteBeginWrite(
    IN EXTENSION_CONTROL_BLOCK * pECB,
    IN DWORD dwChunkSize
    )
/*++

Purpose:

    Allocate and initialize chunked transfer encoder context

Arguments:

    pECB - pointer to extension control as passed to HttpExtensionProc()
    dwChunkSize - the maximum size of the chunk to transmit

Returns:
    encoder context handle, or
    NULL if memory allocation failed or chunk size was zero

--*/
{
    HCTE_ENCODER h;


    //
    // reject zero-length chunk size
    //

    if( dwChunkSize == 0 ) {
        SetLastError( ERROR_INVALID_PARAMETER );
        return NULL;
    }

    //
    // allocate context structure
    //

    h = LocalAlloc( LMEM_FIXED, CTE_ENCODER_SIZE(dwChunkSize) );

    if( h != NULL ) {

        //
        // initialize context structure
        //

        h->pECB         = pECB;
        h->dwChunkSize  = dwChunkSize;
        h->cbData       = 0;

        //
        // chunk data bytes follow the context structure itself
        // and chunk header
        //

        h->pData = (BYTE *) h + sizeof( *h ) + CTE_MAX_CHUNK_HEADER_SIZE;

        //
        // this is the CRLF which follows chunk size
        // (and immediately precedes data)
        //

        h->pData[-2] = '\r';
        h->pData[-1] = '\n';

    } else {

        SetLastError( ERROR_NOT_ENOUGH_MEMORY );
    }

    return h;
}


static BOOL
CteSendChunk(
    IN HCTE_ENCODER h
)
/*++

Purpose:

    Send one chunk of data using ClientWrite()
    <hex encoded chunk size>, CRLF, data bytes, if any, CRLF

Arguments:

    h - CTE Encoder handle

Returns:

    TRUE if WriteClient succeeded
    FALSE if WriteClient failed

--*/
{
    char szChunkLength[9];
    DWORD cbChunkLength;
    BYTE *buf;
    DWORD cbToSend;
    BOOL success;

    //
    // produce hex string of the number of bytes
    // and compute the length of this string
    //
    _itoa( h->cbData, szChunkLength, 16 );
    cbChunkLength = strlen( szChunkLength );

    //
    // step back to make place for hex number and CRLF,
    // copy hex string to its location
    //

    buf = h->pData - 2 - cbChunkLength;
    memmove( buf, szChunkLength, cbChunkLength );

    //
    // compute the number of bytes to send
    // (this includes chunk data size, hex string and CRLF)
    //

    cbToSend = h->cbData + cbChunkLength + 2;

    //
    // append trailing CRLF right after the data bytes
    //

    buf[cbToSend++] = '\r';
    buf[cbToSend++] = '\n';

    //
    // issue synchronous WriteClient and return result to the caller
    //

    success = h->pECB->WriteClient(
                    h->pECB->ConnID,
                    buf,
                    &cbToSend,
                    HSE_IO_SYNC
                    );

    //
    // reset buffer pointer
    //

    h->cbData = 0;

    return success;
}


BOOL
CteWrite(
    IN HCTE_ENCODER h,
    IN PVOID pData,
    IN DWORD cbData
)
/*++

Purpose:

    Write specified number of data bytes to the chunk buffer.
    When the chunk buffer becomes full, call CteSendChunk()
    to send it out.

Arguments:

    h - CTE Encoder handle
    pData - pointer to data bytes
    cbData - number of data bytes to send

Returns:

    TRUE if bytes were successfully written
    FALSE if WriteClient() failed

--*/
{
    DWORD cbToConsume;
    PBYTE pBytesToSend = (PBYTE) pData;

    for( ;; ) {

        //
        // compute the number of bytes to consume,
        // break out of the loop, if nothing is left
        //

        cbToConsume = min( cbData, h->dwChunkSize - h->cbData );

        if( cbToConsume == 0 ) {
            break;
        }

        //
        // move bytes to the buffer, advance pointers and counters
        //

        memmove( h->pData + h->cbData, pBytesToSend, cbToConsume );

        h->cbData += cbToConsume;
        pBytesToSend += cbToConsume;
        cbData -= cbToConsume;

        //
        // if the chunk buffer is full, send it
        //

        if( h->cbData == h->dwChunkSize ) {
            if( !CteSendChunk( h ) ) {
                return FALSE;
            }
        }

    }

    return TRUE;
}


BOOL
CteEndWrite(
    IN HCTE_ENCODER h
)
/*++

Purpose:

    Complete the transfer and release the encoder context

Arguments:

    h - CTE Encoder handle

Returns:

    TRUE if transfer was successfully completed
    FALSE if WriteClient() failed

--*/
{
    BOOL success;

    //
    // if there are some bytes in the chunk, send them
    //

    if( h->cbData ) {
        if( !CteSendChunk( h ) ) {
            return FALSE;
        }
    }

    //
    // send empty chunk (which means EOF)
    //

    success = CteSendChunk( h );

    //
    // release chunk transfer context
    //

    LocalFree( h );

    return success;
}