/*
* Copyright (c) 2005 - 2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  utility class for handling multipart/related HTTP responses
*                in ROAP
*
*/



// INCLUDE FILES
#include <e32base.h>
#include <hash.h>
#include "Base64.h"
#include "MultipartHandler.h"

#ifdef _DEBUG

#include <e32debug.h>
#define MULTIPART_DEBUGLIT( a ) RDebug::Print( _L ( a ) );

#else // DEBUG

#define MULTIPART_DEBUGLIT( a )

#endif // DEBUG

// CONSTANTS

_LIT8( KBoundaryPrefix, "--" );
_LIT8( KCrLf, "\r\n" );
_LIT8( KCrLfCrLf, "\r\n\r\n" );


// ============================ MEMBER FUNCTIONS ===============================

// ---------------------------------------------------------------------------
// TMultipartHandler::TMultipartHandler
// ---------------------------------------------------------------------------
//
TMultipartHandler::TMultipartHandler():
    iState( EPreamble )
    {
    MULTIPART_DEBUGLIT( "TMultipartHandler::TMultipartHandler -->" )
    iBuffer.SetLength( 0 );
    MULTIPART_DEBUGLIT( "--> TMultipartHandler::TMultipartHandler" )
    }

// ---------------------------------------------------------------------------
// TMultipartHandler::WriteL
// ---------------------------------------------------------------------------
//
void TMultipartHandler::WriteL(
    const TDesC8& aData )
    {
    MULTIPART_DEBUGLIT( "TMultipartHandler::WriteL -->" )
    switch ( iState )
        {
        case EPreamble:
            MULTIPART_DEBUGLIT( "EPreamble" )
            HandlePreambleL( aData );
            break;
        case EBodyPartHeaders:
            MULTIPART_DEBUGLIT( "EBodyPartHeaders" )
            HandleBodyPartHeadersL( aData );
            break;
        case EBodyPart:
            MULTIPART_DEBUGLIT( "EBodyPart" )
            HandleBodyPartL( aData );
            break;
        case EEpilog:
            MULTIPART_DEBUGLIT( "EEpilog" )
            break;
        }
    MULTIPART_DEBUGLIT( "--> TMultipartHandler::WriteL" )
    }

// ---------------------------------------------------------------------------
// TMultipartHandler::FindDashBoundary
// ---------------------------------------------------------------------------
//
TBool TMultipartHandler::FindDashBoundary(
    const TDesC8& aBuffer,
    TInt& aStart,
    TInt& aEnd )
    {
    MULTIPART_DEBUGLIT( "TMultipartHandler::FindDashBoundary -->" )
    TBool r( EFalse );
    const TInt KBoundaryPrefixLength( KBoundaryPrefix().Length() );
    const TInt KCrLfLength( KCrLf().Length() );
    aStart = aBuffer.Find( KBoundaryPrefix );
    if ( aStart >= 0 )
        {
        MULTIPART_DEBUGLIT( "TMultipartHandler::FindDashBoundary aStart nonnegative" )
        aEnd = aBuffer.Mid( aStart ).Find( KCrLf );
        aEnd += aStart;
        if ( aEnd > aStart + KBoundaryPrefixLength )
            {
            MULTIPART_DEBUGLIT( "TMultipartHandler::FindDashBoundary  aEnd > aStart + (boundary prefix length)" )
            const TInt delimiterLength( aEnd - aStart + KCrLfLength );
            __ASSERT_ALWAYS( KMaxBoundaryLength  >= delimiterLength, User::Invariant() );
            iDelimiter.Copy( KCrLf );
            iDelimiter.Append( KBoundaryPrefix );
            iDelimiter.Append( aBuffer.Mid(
                aStart + KBoundaryPrefixLength,
                aEnd - aStart - KBoundaryPrefixLength ) );
            r = ETrue;
            MULTIPART_DEBUGLIT( "TMultipartHandler::FindDashBoundary  found dash boundary" )
            }
        }
    MULTIPART_DEBUGLIT( "--> TMultipartHandler::FindDashBoundary" )
    return r;
    }

// ---------------------------------------------------------------------------
// TMultipartHandler::FindHeaderEnd
// ---------------------------------------------------------------------------
//
TBool TMultipartHandler::FindHeaderEnd(
    const TDesC8& aBuffer,
    TInt& aStart,
    TInt& aEnd )
    {
    MULTIPART_DEBUGLIT( "TMultipartHandler::FindHeaderEnd -->" )
    TBool r( EFalse );

    aStart = aBuffer.Find( KCrLfCrLf );
    if ( aStart >= 0 )
        {
        aEnd = aStart + KCrLfCrLf().Length();
        r = ETrue;
        }
    MULTIPART_DEBUGLIT( "--> TMultipartHandler::FindHeaderEnd" )
    return r;
    }

// ---------------------------------------------------------------------------
// TMultipartHandler::FindDelimiter
// ---------------------------------------------------------------------------
//
TBool TMultipartHandler::FindDelimiter(
    const TDesC8& aBuffer,
    TInt& aStart,
    TInt& aEnd )
    {
    MULTIPART_DEBUGLIT( "TMultipartHandler::FindDelimiter -->" )
    TBool r( EFalse );

    aStart = aBuffer.Find( iDelimiter );
    if ( aStart >= 0 )
        {
        aEnd = aStart + iDelimiter.Length();
        r = ETrue;
        }
    MULTIPART_DEBUGLIT( "--> TMultipartHandler::FindDelimiter" )
    return r;
    }

// ---------------------------------------------------------------------------
// TMultipartHandler::HandlePreambleL
// ---------------------------------------------------------------------------
//
void TMultipartHandler::HandlePreambleL(
    const TDesC8& aData )
    {
    MULTIPART_DEBUGLIT( "TMultipartHandler::HandlePreambleL -->" )
    TInt bStart( 0 );
    TInt bEnd( 0 );
    HBufC8* buffer( NULL );

    buffer = HBufC8::NewLC( iBuffer.Length() + aData.Length() );
    buffer->Des().Copy( iBuffer );
    buffer->Des().Append( aData );
    if ( !FindDashBoundary( *buffer, bStart, bEnd ) )
        {
        iBuffer.Copy( buffer->Right( Min(
                    KMaxBoundaryLength, buffer->Length() ) ) );
        }
    else
        {
        iBuffer.SetLength( 0 );
        iState = EBodyPartHeaders;
        StartBodyPartHeadersL();
        HandleBodyPartHeadersL( buffer->Mid( bEnd + KCrLf().Length() ) );
        }
    CleanupStack::PopAndDestroy( buffer );
    MULTIPART_DEBUGLIT( "--> TMultipartHandler::HandlePreambleL" )
    }

// ---------------------------------------------------------------------------
// TMultipartHandler::HandleBodyPartHeadersL
// ---------------------------------------------------------------------------
//
void TMultipartHandler::HandleBodyPartHeadersL(
    const TDesC8& aData )
    {
    MULTIPART_DEBUGLIT( "TMultipartHandler::HandleBodyPartHeadersL -->" )
    TInt bStart( 0 );
    TInt bEnd( 0 );
    HBufC8* buffer( HBufC8::NewLC( iBuffer.Length() + aData.Length() ) );
    buffer->Des().Copy( iBuffer );
    buffer->Des().Append( aData );
    iBuffer.Copy( buffer->Right( Min(
                KMaxBoundaryLength, buffer->Length() ) ) );
    if ( !FindHeaderEnd( *buffer, bStart, bEnd ) )
        {
        const TInt lengthNoBoundary( buffer->Length() - KMaxBoundaryLength );
        if (  lengthNoBoundary > 0 )
            {
            HandleBodyHeaderDataL( buffer->Left( lengthNoBoundary ) );
            }
        }
    else
        {
        HandleBodyHeaderDataL( buffer->Left( bStart ) );
        iBuffer.SetLength( 0 );
        iState = EBodyPart;
        StartBodyPartL();
        HandleBodyPartL( buffer->Mid( bEnd ) );
        }
    CleanupStack::PopAndDestroy( buffer );
    MULTIPART_DEBUGLIT( "--> TMultipartHandler::HandleBodyPartHeadersL" )
    }

// ---------------------------------------------------------------------------
// TMultipartHandler::HandleBodyPartL
// ---------------------------------------------------------------------------
//
void TMultipartHandler::HandleBodyPartL(
    const TDesC8& aData )
    {
    MULTIPART_DEBUGLIT( "TMultipartHandler::HandleBodyPartL -->" )
    TInt bStart( 0 );
    TInt bEnd( 0 );

    HBufC8* buffer( HBufC8::NewLC( iBuffer.Length() + aData.Length() ) );
    buffer->Des().Copy( iBuffer );
    buffer->Des().Append( aData );

    iBuffer.Copy( buffer->Right( Min(
                KMaxBoundaryLength, buffer->Length() ) ) );

    if ( !FindDelimiter( *buffer, bStart, bEnd ) )
        {
        const TInt lengthNoBoundary( buffer->Length() - KMaxBoundaryLength );
        if ( lengthNoBoundary > 0 )
            {
            HandleBodyDataL( buffer->Left( lengthNoBoundary ) );
            }
        }
    else
        {
        HandleBodyDataL( buffer->Left( bStart ) );
        iBuffer.SetLength( 0 );
        if ( ( *buffer )[ bEnd ] == '-' && ( *buffer )[ bEnd + 1 ] == '-' )
            {
            EndBodyPartL();
            iState = EEpilog;
            }
        else
            {
            iState = EBodyPartHeaders;
            StartBodyPartHeadersL();
            HandleBodyPartHeadersL( buffer->Mid( bEnd + KCrLf().Length() ) );
            }
        }
    CleanupStack::PopAndDestroy( buffer );
    MULTIPART_DEBUGLIT( "--> TMultipartHandler::HandleBodyPartL" )
    }

// ---------------------------------------------------------------------------
// TMultipartHandler::StartBodyPartHeadersL
// ---------------------------------------------------------------------------
//
void TMultipartHandler::StartBodyPartHeadersL()
    {
    MULTIPART_DEBUGLIT( "--> TMultipartHandler::StartBodyPartHeadersL -->" )
    }

// ---------------------------------------------------------------------------
// TMultipartHandler::EndBodyPartHeadersL
// ---------------------------------------------------------------------------
//
void TMultipartHandler::EndBodyPartHeadersL()
    {
    MULTIPART_DEBUGLIT( "--> TMultipartHandler::EndBodyPartHeadersL -->" )
    }

// ---------------------------------------------------------------------------
// TMultipartHandler::HandleBodyHeaderDataL
// ---------------------------------------------------------------------------
//
void TMultipartHandler::HandleBodyHeaderDataL(
    const TDesC8& /*aData*/ )
    {
    MULTIPART_DEBUGLIT( "--> TMultipartHandler::HandleBodyHeaderDataL -->" )
    }

// ---------------------------------------------------------------------------
// TMultipartHandler::StartBodyPartL
// ---------------------------------------------------------------------------
//
void TMultipartHandler::StartBodyPartL()
    {
    MULTIPART_DEBUGLIT( "--> TMultipartHandler::StartBodyPartL -->" )
    }

// ---------------------------------------------------------------------------
// TMultipartHandler::EndBodyPartL
// ---------------------------------------------------------------------------
//
void TMultipartHandler::EndBodyPartL()
    {
    MULTIPART_DEBUGLIT( "--> TMultipartHandler::EndBodyPartL -->" )
    }

// ---------------------------------------------------------------------------
// TMultipartHandler::HandleBodyDataL
// ---------------------------------------------------------------------------
//
void TMultipartHandler::HandleBodyDataL(
    const TDesC8& /*aData*/ )
    {
    MULTIPART_DEBUGLIT( "--> TMultipartHandler::HandleBodyDataL -->" )
    }