/*++

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;
}