// Copyright (c) 2005-2009 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:

//

// INCLUDE FILES

#include <e32def.h>           // First to avoid NULL redefine warning (no #ifndef NULL).

#include <e32std.h>

#include <string.h>

#include <ezdecompressor.h>   // Ezlib.lib, GZip decoders

#include <uri8.h>

#include <uri16.h>

#include <uricommon.h>

#include <bafl/multipartparser.h>

#include "gzipbufmgr.h"

#include "tinternetdate.h"

#include <bafl/qpcodec.h>

#include <bsul/clientmessage.h>

// CONSTANTS

const char Multipart_Mixed[] = {"multipart/mixed"};

const char Multipart_Related[] = {"multipart/related"};

const char Multipart_Boundary_Text[] = {"boundary="};

const char Multipart_Content_Base_Text[] = {"Content-Base:"};

const char Multipart_Content_Location_Text[] = {"Content-Location:"};

const char Multipart_Content_Type_Text[] = {"Content-Type:"};

const char Multipart_Content_Transfer_Encoding_Text[] = {"Content-Transfer-Encoding:"};

// violate RFC2045; but upon customer request

const char Multipart_Content_Encoding_Text[] = {"Content-Encoding:"};

const char Multipart_Content_ID_Text[] = {"Content-ID:"};

const char Multipart_Hypens_Text[] = {"--"};

const char Multipart_CRLF_Text[] = {"\r\n"};

const char Multipart_LF_Text[] = {"\n"};

const char Multipart_DoubleCRLF_Text[] = {"\r\n\r\n"};

const char Multipart_DoubleLF_Text[] = {"\n\n"};

const char Multipart_Charset_Text[] = {"charset="};

const char Multipart_ContentTypeString_Delimiter_Text[] = {";"};

const char Multipart_ContentTypeString_Quotes_Text[] = {"\""};

const char Multipart_Content_Transfer_Encoding_Base64[] = {"base64"};

const char Multipart_Content_Transfer_Encoding_QuotedPrintable[] = {"quoted-printable"};

const char Multipart_Content_Transfer_Encoding_7bit[] = {"7bit"};

const char Multipart_Content_Transfer_Encoding_8bit[] = {"8bit"};

const char Multipart_Content_Transfer_Encoding_binary[] = {"binary"};

const char Multipart_Content_Encoding_GZip[] = {"gzip"};

const char Multipart_Content_Type_GZip[] = {"application/x-gzip"};

// MACROS

#define MULTIPART_CONTENT_BASE_LENGTH               13

#define MULTIPART_CONTENT_LOCATION_LENGTH           17

#define MULTIPART_CONTENT_TYPE_LENGTH               13

#define MULTIPART_CONTENT_TRANSFER_ENCODING_LENGTH  26

// violates RFC2045; but upon vodafone request

#define MULTIPART_CONTENT_ENCODING_LENGTH           17

#define MULTIPART_CONTENT_LENGTH_LENGTH             15

#define MULTIPART_LAST_MODIFIED_LENGTH              14

#define MULTIPART_CONTENT_ID_LENGTH                 11

#define MULTIPART_CONTENT_BASE               1

#define MULTIPART_CONTENT_LOCATION           2

#define MULTIPART_CONTENT_TRANSFER_ENCODING  3

#define MULTIPART_CONTENT_TYPE               4

#define MULTIPART_CONTENT_ID                 5

#define MULTIPART_INTERNET_DATE_STRING_LENGTH       29

#define SLASH_CHAR    '/'

#define DOT_CHAR      '.'

#define AT_CHAR       '@'

#define COLON_CHAR    ':'

// <scheme>://

#define SCHEME_SEPARATOR_LENGTH               3

// ============================= LOCAL FUNCTIONS ===============================

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

// ------------------------------------------------------------------------- 

// Parse and put each body part to the body part array

// ------------------------------------------------------------------------- 

EXPORT_C void MultipartParser::ParseL( const TDesC8& aMultipartBody, 

                                       const TDesC8& aContentType,

                                       const TDesC8& aBoundary,

                                       const TDesC16& aUrl,

                                       RPointerArray <CBodyPart>& aBodyPartsArray,

                                       TInt aMaxToParse )

    {

    // check on required parameters

    __ASSERT_ALWAYS( aMultipartBody.Ptr() != NULL,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    __ASSERT_ALWAYS( aContentType.Ptr() != NULL,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    __ASSERT_ALWAYS( aBoundary.Ptr() != NULL,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    __ASSERT_ALWAYS( aUrl.Ptr() != NULL,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    const TUint8* multipartBuffer = aMultipartBody.Ptr();

    TUint32 multipartLen = aMultipartBody.Length();

    __ASSERT_ALWAYS( multipartLen != 0,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    TUint8* bodyPartBuffer = NULL;

    TUint32 bodyPartBufferLength = 0;

    TUint32 startPosition = 0;

    char* singleEolChar = NULL;

    char* doubleEolChar = NULL;

    CBodyPart* bodyPart = NULL;

    // currently only support mixed and related.

    char* contentType = (char*)aContentType.Ptr();

    if( strncasecmp( contentType, Multipart_Mixed, strlen(Multipart_Mixed) ) != 0 && 

        strncasecmp( contentType, Multipart_Related, strlen(Multipart_Related) ) != 0 )

        {

        User::Leave( KErrNotSupported );

        }

    // get singleEol and doubleEol

    MultipartParser::SetEolCharacters( multipartBuffer,

                                       multipartLen,

                                       aBoundary,

                                       &singleEolChar,

                                       &doubleEolChar );

    // get body parts one by one

    // null bodyPartBuffer indicates the end of the multipart body

    int counter = 0;

    do

        {

        // stop when we get required number of parse done

        if( aMaxToParse != -1 && counter >= aMaxToParse )

            {

            break;

            }

        // update counter

        counter++;

        // get the next body part

        bodyPartBufferLength = MultipartParser::GetNextBodyPartBuffer( startPosition, 

                                                                       multipartBuffer,

                                                                       multipartLen,

                                                                       aBoundary,

                                                                       singleEolChar,

                                                                       &bodyPartBuffer );

        // break if we are at end

        if( bodyPartBuffer == NULL )

            {

            break;

            }

        // update start position

        startPosition += bodyPartBufferLength;

        // create new body part

        bodyPart = CBodyPart::NewL();

        // parse each body part buffer to fill in body part

        MultipartParser::ParseBodyPartL( bodyPartBuffer, 

                                         bodyPartBufferLength,

                                         singleEolChar,

                                         doubleEolChar,

                                         aUrl, 

                                         bodyPart );  

        // add the body part to the array

        aBodyPartsArray.Append( bodyPart );

        }

    while( bodyPartBuffer != NULL );

    }

// ------------------------------------------------------------------------- 

// Composes RFC1521 compliant multipart document with given bodyparts

// Actual task of creating the document is delegated to specialized composer

// for each of the subtypes

// ------------------------------------------------------------------------- 

EXPORT_C HBufC8* MultipartParser::ComposeL( RPointerArray<CBodyPart>& aBodyPartsArray,

                                            const TDesC8& aBoundary,

                                            TMultipartSubtype aSubtype,

                                            TInt aHeaderMask )

    {

    // check on required parameters

    if ( !aBoundary.Ptr() || !aBoundary.Length() )

        {

        User::Leave( KErrArgument );

        }

    HBufC8* multipartDoc = NULL;

    switch(aSubtype)

        {

        case EMultipartSubtypeMixed:

            {

            multipartDoc = ComposeMixedL( aBodyPartsArray,

                                          aBoundary,

                                          aHeaderMask );

            }

        break;

        default:

            {

            User::Leave( KErrArgument );

            }

        }

    return multipartDoc;

    }

// ------------------------------------------------------------------------- 

// Default constructor

// ------------------------------------------------------------------------- 

MultipartParser::MultipartParser()

	{

	}

// ------------------------------------------------------------------------- 

// Returns with the next body part buffer from start position (offset)

// ------------------------------------------------------------------------- 

TUint32

MultipartParser::GetNextBodyPartBuffer( TUint32 aStartPosition, 

                                        const TUint8* aMultipartBody,

                                        TUint32 aMultipartLen,

                                        const TDesC8& aBoundary,

                                        char* aSingleEolChar,

                                        TUint8** aBodyPartBuffer )

    {

    // check on required parameters

    __ASSERT_ALWAYS( aMultipartBody != NULL,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    __ASSERT_ALWAYS( aBoundary.Ptr() != NULL,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    __ASSERT_ALWAYS( aSingleEolChar != NULL,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    long startOffset = -1;

    long endOffset = -1;

    TUint32 length = 0;

    TBool badContent = EFalse;

    TUint32 offset = 0;

    const char* boundaryStr = (const char*) aBoundary.Ptr();

    int boundaryLength = aBoundary.Length();

    int hypensLength = strlen( Multipart_Hypens_Text );

    int singleEolLength = strlen( aSingleEolChar );

    TUint32 i = aStartPosition;

    // from RFC 1341 7.2

    // Overall, the body of a multipart entity may be specified as follows:

    // multipart-body := preamble 1*encapsulation close-delimiter epilogue

    // encapsulation := delimiter CRLF body-part

    // delimiter := CRLF "--" boundary   ; taken from Content-Type field.

    // when content-type is multipart.

    // There must be no space between "--" and boundary.

    // close-delimiter := delimiter "--" ; Again, no  space  before

    // "--"

    // boundary = 12xy

    // body: here comes some text that we ignore

    //       --12xy

    //       first body

    //       --12xy

    //       second body

    //       --12xy--

    //       closing boundary. we ignore this text here

    while( i < (aMultipartLen - hypensLength + 1 ) )

        {

        // get the first two hypens

        // using char comparison to compare "--"

        // hopefully this is faster

        if( (char)aMultipartBody[ i ] == '-' && 

            (char)aMultipartBody[ i+1 ] == '-' )

          {

          char* boundary = (char*)&aMultipartBody[ i + hypensLength ];

          // check if the body is long enough first and then check if boundary matches

          if( aMultipartLen >= i + hypensLength + boundaryLength )

            {

            if( strncasecmp( boundary, boundaryStr, boundaryLength ) == 0 )

              {

              // we've got the boundary

              offset = i + hypensLength + boundaryLength;

              // Next two chars must be either two hypens (closing boundary - 2 bytes),

              // or single Eol characters (new body).

              // Eol = CRLF (2 bytes - windows) or LF (1 byte - unix/mac).

              char* eolBuf = (char*)&aMultipartBody[ offset ];

              // Check if buffer is long enough for hypens [2 bytes], or eol [1 or 2 bytes]

              if( aMultipartLen >= offset + hypensLength )

                {

                 if( strncmp( eolBuf, aSingleEolChar, singleEolLength ) == 0|| 

                     eolBuf[0] == Multipart_LF_Text[0])

                  {

                  // We found Eol, so this is a new multipart body (header and content)

                  if( startOffset == -1 )

                    {

                    // this is the beginning.

                    startOffset = offset;

                    // let's looking for the end of this body part which either could

                    // be closing boundary or an opening boundary for the next body part

                    // jump over the boundary information

                    i = startOffset + singleEolLength;

                    }

                  else

                    {

                    // We found the next boundary marker, so this is the

                    // beginning of the next body part

                    endOffset = offset - boundaryLength - hypensLength;

                    // we've got both start and end offset

                    break;

                    }

                  }

                 else if( strncmp( eolBuf, Multipart_Hypens_Text, hypensLength ) == 0 )

                   {

                    // We found the closing boundary marker

                    endOffset = offset - boundaryLength - hypensLength;

                    break;

                   }

                 else

                   {

                   // it's neither Eol nor two hypens "--"

                   badContent = ETrue;

                   break;

                   }

                }

              else

                {

                // the buffer is too short and not closed properly

                endOffset = i;

                break;

                }

              }

            }

          else

            {

            // the buffer is far too short

            endOffset = i;

            break;

            }

          }

        i++;

        } // end of while loop

    // missing closing boundary check

    if( endOffset == -1 )

        {

        // take the end of the body as closing boundary

        endOffset = i - 1;

        }

    if( badContent )

        {

        endOffset = -1;

        startOffset = -1;

        }

    if( startOffset != -1 && endOffset != -1 )

        {

        *aBodyPartBuffer = (TUint8*)&aMultipartBody[ startOffset ];

        length = endOffset - startOffset;

        }

    else

        {

        *aBodyPartBuffer = NULL;

        length = 0;

        }

    return length;

    }

// ------------------------------------------------------------------------- 

// Set End-Of-Line characters.  Look at the eol character after the boundary to

// determine if it is a CRLF (2 bytes used by windows), or LF (1 byte used by

// unix/mac).

// NOTE: CR = 0x0D = '\r', LF = 0x0A = '\n'

// Multipart entity is specified as follows:

// --boundary123[eol]

// Content-type: text/html[eol]

// Content-location: http:\\www.example.com\index.html[eol]

// [eol]

// <html><body>...example...</html>[eol]

// --boundary123--[eol]

// ------------------------------------------------------------------------- 

void

MultipartParser::SetEolCharacters( const TUint8* aMultipartBody,

                                   TUint32 aMultipartLen,

                                   const TDesC8& aBoundary,

                                   char** aSingleEolChar,

                                   char** aDoubleEolChar )

    {

    // check on required parameters

    __ASSERT_ALWAYS( aMultipartBody != NULL,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    __ASSERT_ALWAYS( aBoundary.Ptr() != NULL,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    __ASSERT_ALWAYS( aSingleEolChar != NULL,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    __ASSERT_ALWAYS( aDoubleEolChar != NULL,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    TUint32 i = 0;

    const char* boundaryStr = (const char*) aBoundary.Ptr();

    int boundaryLength = aBoundary.Length();

    int hypensLength = strlen( Multipart_Hypens_Text );

    int lfLength = strlen( Multipart_LF_Text );

    // Set the default eol (CRLF)

    *aSingleEolChar = (char *)Multipart_CRLF_Text;

    *aDoubleEolChar = (char *)Multipart_DoubleCRLF_Text;

    while (i < (aMultipartLen - hypensLength + 1))

        {

        // Get the first two hypens

        char* bodyPart = (char*)&aMultipartBody[ i ];

        if (strncmp(bodyPart, Multipart_Hypens_Text, hypensLength) == 0)

            {

            char* boundary = (char*)&aMultipartBody[ i + hypensLength ];

            // Check if the body is long enough first and then check if boundary matches

            if (aMultipartLen >= i + hypensLength + boundaryLength )

                {

                if (strncasecmp(boundary, boundaryStr, boundaryLength) == 0)

                    {

                    // We've got the boundary

                    i = i + hypensLength + boundaryLength;

                    // Next two chars should be the single Eol characters.

                    // Eol = CRLF (2 bytes - windows), or LF (1 byte - unix/mac).

                    char* eolBuf = (char*)&aMultipartBody[ i ];

                    // Check if buffer is long enough for eol [1 byte LF]

                    if (aMultipartLen >= i + lfLength)

                        {

                        if (strncmp(eolBuf, Multipart_LF_Text, lfLength) == 0)

                            {

                            // We found LF Eol (unix/mac)

                            *aSingleEolChar = (char *)Multipart_LF_Text;

                            *aDoubleEolChar = (char *)Multipart_DoubleLF_Text;

                            } // end of if compare eol to LF

                        } // end of if buffer size ok

                    // Break in all cases, we will use the default CRLF if we don't

                    // find eol=LF, or the remaining buffer is too small

                    break;

                    } // end of compare/found boundary

                }

            } // end of looking for first two hypens

        ++i;

        } // end of while

    }

// ------------------------------------------------------------------------- 

// parse body

// The bodyPart parameter can contain the optional headers and response, or

// just the response.  In the case of both the (optional) header(s) and the

// response, let's cut off header(s) and return the response body.  The

// header is seperated from the response by two End-of-line (Eol) characters,

// i.e. two CRLF's (windows) or two LF's (unix/mac).

// --boundary123 (omitted from bodyPart parameter, starts next line)

// Content-type: text/html[eol]

// Content-location: http:\\www.example.com\index.html[eol]

// [eol]

// <html><body>example</body></html>

//

// In the case of no headers, there may be only one (or more) Eol characters.

// --boundary123 (omitted from bodyPart parameter, starts on next line)

// [eol]

// <html><body>example</body></html>

// ------------------------------------------------------------------------- 

void

MultipartParser::ParseBodyPartL( TUint8* aBodyPartBuffer,

                                 TUint32 aBodyPartBufferLength,

                                 char* aSingleEolChar,

                                 char* aDoubleEolChar,

                                 const TDesC16& aResponseUrl,

                                 CBodyPart* aBodyPart )

    {

    // check on required parameters

    __ASSERT_ALWAYS( aBodyPartBuffer != NULL,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    __ASSERT_ALWAYS( aSingleEolChar != NULL,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    __ASSERT_ALWAYS( aDoubleEolChar != NULL,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    __ASSERT_ALWAYS( aBodyPart != NULL,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    __ASSERT_ALWAYS( aResponseUrl.Ptr() != NULL,

                     User::Panic(_L("MultipartParser Panic"), KErrArgument) );

    // headers look something like this

    // we need to return "text/html" if the requested header is "Content-type"

    // --boundary123

    // Content-type: text/html

    // Content-location: http:\\www.example.com\index.html

    //

    // <html>

    // <body>

    // example

    int contentHeaderValueCharLen = 0;

    TPtrC8 contentHeaderValuePtr( NULL, 0 );

    int contentHeaderNameLength = 0;

    /*lint -e{668} Possibly passing a null pointer to function */

    int singleEolLength = strlen( aSingleEolChar );

    int doubleEolLength = strlen( aDoubleEolChar );

    // start looking for the header name

    for( TUint32 i = 0; i < aBodyPartBufferLength ; i++ )

        {

        int found = 0;

        const char* tempBodyPartBuffer = (char*)&aBodyPartBuffer[ i ];

        // Did we find the Content Header Value

	    if (strncasecmp( tempBodyPartBuffer, Multipart_Content_Base_Text, MULTIPART_CONTENT_BASE_LENGTH ) == 0)

            {

            contentHeaderNameLength = MULTIPART_CONTENT_BASE_LENGTH;

            found = MULTIPART_CONTENT_BASE;

            }

	    else if (strncasecmp( tempBodyPartBuffer, Multipart_Content_Location_Text, MULTIPART_CONTENT_LOCATION_LENGTH ) == 0)

            {

            contentHeaderNameLength = MULTIPART_CONTENT_LOCATION_LENGTH;

            found = MULTIPART_CONTENT_LOCATION;

            }

	    else if (strncasecmp( tempBodyPartBuffer, Multipart_Content_Transfer_Encoding_Text, MULTIPART_CONTENT_TRANSFER_ENCODING_LENGTH ) == 0)