/*

* Copyright (c) 1998-2004 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

/*

**-------------------------------------------------------------------------

**  Component Generic Include

**-------------------------------------------------------------------------

*/

#include <apgcli.h>

#include <apmstd.h>

#include <f32file.h>

#include "MVCShell.h"

#include "nw_object_exceptions.h"

#include "nwx_mem.h"

#include "nwx_string.h"

#include "nwx_url_utils.h"

#include "nw_nvpair.h"

#include "nw_wae_reader.h"

#include "nw_string_string.h"

#include "nwx_http_defs.h"

#include "nwx_settings.h"

#include "nwx_statuscodeconvert.h"

/*

**-------------------------------------------------------------------------

**  Module Specific Includes

**-------------------------------------------------------------------------

*/

#include "nw_loadreq.h"

#include "urlloader_urlloaderint.h"

#include "BrsrStatusCodes.h"

#include "nwx_http_defs.h"

/*

**-------------------------------------------------------------------------

**  Constants

**-------------------------------------------------------------------------

*/

//TODO STREAMING: Need to track down an API for getting these.  Initial inquiry

//didn't find one and found other apps are hard-coding these as well.  These,

//however, will not be needed when we switch to the streaming implementation.

static const NW_Ucs2 KCDrivePrefix[] = {'c', ':', '\\', '\0'};

static const NW_Ucs2 KEDrivePrefix[] = {'e', ':', '\\', '\0'};

// The boundary string generated will be done using random numbers and

// converting them to ASCII hex strings. The length should be fairly long so as

// to reduce the probability of the boundary matching any data being sent. As

// of this writing, Microsoft I.E. uses a length of 41, of which 14 chars are

// random ASCII hex chars and the rest are all dashes. In our case, all 41

// chars will be random providing a very low probability of a match. RFC2046

// states that the max length is 70.

static const int KBoundaryLen = 41;

static const NW_Uint8 KDefaultContentType[] =

{'a', 'p', 'p', 'l', 'i', 'c', 'a', 't', 'i', 'o', 'n', '/', 'o', 'c', 't', 'e', 't', '-', 's', 't', 'r', 'e', 'a', 'm'};

/*

**-------------------------------------------------------------------------

**  Internal Types

**-------------------------------------------------------------------------

*/

/*

**-------------------------------------------------------------------------

**  Macros

**-------------------------------------------------------------------------

*/

#define NW_URLENCODED_TYPE_STR (const char*)"application/x-www-form-urlencoded"

#define NW_URLENCODED_CHARSET_UTF8_TYPE_STR (const char*)"application/x-www-form-urlencoded; charset=utf-8"

#define NW_MULTIPART_TYPE_STR  (const char*)"multipart/form-data"

// The HTTP Post header is created elsewhere.  It inserts enough initial CRLFs

// already in preparation for the body; thus, the first boundary string needs

// one fewer CRLF. Inserting one too many CRLF will cause some sites to not

// work on multipart post (e.g., www.gifworks.com). Therefore, there are two

// boundary start strings, one with CRLF and one without. Note, the CRLF does

// belong in the front of and as part of the boundary string.  See RFC 1521:

// "...initial CRLF is considered to be attached to encpsulation boundary

// rather than part of the preceding part."

#define NW_BOUNDARY_FIRST_START_STR (const char*)"--"

#define NW_BOUNDARY_START_STR (const char*)"\r\n--"

#define NW_BOUNDARY_END_STR (const char*)"--\r\n"

#define NW_CONTENTTYPE_TEXTPLAIN_CHARSET_STR (const char*)"\r\nContent-Type: text/plain; charset="

#define NW_CONTENTTYPE_STR (const char*)"\r\nContent-Type: "

#define NW_CONTENTDISPOSITION_STR (const char*)"\r\nContent-Disposition: form-data; name="

#define NW_FILENAME_STR (const char*)" filename="

#define NW_HEADEREND_STR (const char*)"\r\n\r\n"

/*

**-------------------------------------------------------------------------

**  Internal Prototypes

**-------------------------------------------------------------------------

*/

/*

**-------------------------------------------------------------------------

**  File Scoped Static Variables

**-------------------------------------------------------------------------

*/

/*

**-------------------------------------------------------------------------

**  Global Variable Definitions

**-------------------------------------------------------------------------

*/

/*

**-------------------------------------------------------------------------

**  Internal Prototypes

**-------------------------------------------------------------------------

*/

TBrowserStatusCode Transcode( NW_Byte *p, const NW_Ucs2 *s, 

    NW_Http_CharSet_t http_charset, NW_Uint32 *byteLen );

NW_Uint32 TranscodedLength( const NW_Ucs2 *s,

    NW_Http_CharSet_t http_charset);

NW_Byte* TranscodeTo10646_ucs2( const NW_Ucs2 *aSrc, NW_Byte *aDst );

static TBrowserStatusCode getEscapedPostdataL(NW_NVPair_t *postfields,

                                      NW_Ucs2 ** escapedPostdata,

                                      NW_HED_AppServices_t* appServices,

                                      void * appCtx);

/*

**-------------------------------------------------------------------------

**  Internal Functions

**-------------------------------------------------------------------------

*/

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

// getConvertedStringL():

//    aString:          A NW_Ucs2* that needs url-escaping and/or foreign charset conversion.

//    aConvertedString: Gets filled in with a (NW_Ucs2*) pointing to the result of those operations.

//                      *aConvertedString is NULL-terminated.

//    aConvertedLen:    Set to the length of aConvertedString, not including the NULL-terminator

//

static TBrowserStatusCode getConvertedStringL(const NW_Ucs2* aString,

                                               NW_HED_AppServices_t* appServices,

                                               void * appCtx,

                                               NW_Ucs2** convertedString,

                                               NW_Uint32* convertedLen)

{

NW_Ucs2*  escapedString = NULL;

NW_Uint32 escapedLen = 0;

NW_Uint32 originalStringLen = NW_Str_Strlen(aString);

NW_Uint32 copyPos = 0;

NW_Uint32 convertPos = 0;

CBufFlat* buffer = CBufFlat::NewL(20);  // arbitrary granularity.

*convertedString = NULL;

*convertedLen = 0;

NW_TRY( status )

    {

    escapedLen = (3 * originalStringLen + 1);

    escapedString = NW_Str_New(escapedLen);

    NW_THROW_OOM_ON_NULL(escapedString, status);

    (void)NW_Mem_memset(escapedString, 0, escapedLen * sizeof(NW_Ucs2));

    // protect the URL from thinking field-data is a delimiter character.

    NW_Url_EscapeString(aString, escapedString);

    /* convert the value to foreign charset if necessary */

    if (appServices && appCtx)

        {

        NW_String_t text;

        NW_Uint32 origEscapedLen = NW_Str_Strlen(escapedString);

        NW_Uint32 i = 0;

        while (i < origEscapedLen)

            {

            // Each interation copies 1 ascii sub-string and/or 

            // converts 1 non-ascii sub string.

            // Copy ascii chars

            copyPos = i;

            while (i < origEscapedLen && escapedString[i] <= 127)

                {

                i++;

                }

            if (i != copyPos)

                {

                buffer->InsertL(buffer->Size(), escapedString + copyPos, (i - copyPos) * sizeof(NW_Ucs2));

                }

            convertPos = i;

            while (i < origEscapedLen && escapedString[i] > 127)

                {

                // gather non-ascii chars for conversion.

                i++;

                }

            if (i != convertPos)

                {

                // Need to convert foreign char string.

                NW_Uint32 foreignLen = i - convertPos ;

                NW_Ucs2*  foreignString = NW_Str_New( foreignLen);

                NW_Ucs2*  transmitString = NULL;

                NW_Mem_memcpy( foreignString, escapedString + convertPos, foreignLen * sizeof(NW_Ucs2));

                foreignString[ foreignLen ] = 0;

                // convert the ucs2 into byte* from charset conversion process*/

                status = StatusCodeConvert(NW_String_ucs2CharToString (&text, foreignString, HTTP_iso_10646_ucs_2));

                NW_Mem_Free(foreignString);

                NW_THROW_ON_ERROR(status);

                // convert to the foreign charset */

                status = appServices->characterConversionAPI.convertToForeignCharSet(appCtx, &text);

                NW_THROW_ON_ERROR(status);

                // TODO: Apply Utf8 encoding here if appropriate.

                // Apply %HH encoding to the foreign charset string.

                status = NW_Url_HHEscape((const char*)text.storage, &transmitString);

                NW_String_deleteStorage(&text);

                NW_THROW_ON_ERROR(status);

                buffer->InsertL(buffer->Size(), transmitString, NW_Str_Strsize(transmitString) - sizeof(NW_Ucs2));

                NW_Mem_Free(transmitString);

                }

            }

        buffer->Compress();

        *convertedLen = buffer->Size();

        *convertedString = NW_Str_New( *convertedLen );

        NW_THROW_OOM_ON_NULL( *convertedString, status );

        NW_Mem_memcpy( *convertedString, buffer->Ptr(0).Ptr(), *convertedLen );        

        }

    else 

        {

        NW_Uint32 charCount = NW_Str_Strlen(escapedString);

        *convertedLen =  charCount * sizeof(NW_Ucs2);

        *convertedString = NW_Str_New(charCount);

        NW_THROW_OOM_ON_NULL( *convertedString, status );        

        NW_Str_Strcpy( *convertedString, escapedString);

        }    

    }

NW_CATCH( status )

    {

    }

NW_FINALLY

    {

    buffer->Reset();

    delete buffer;

    NW_Str_Delete(escapedString);

    return status;

    }

NW_END_TRY

}

//TODO CHARSET: These character-handling functions should be in a common

//character translation module.  Currently, this type of functionality is

//spread throughout the code rather than centralized where it can be more

//easily maintained and controlled.

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

// GetMaxTranscodedByteLength

// Gets the max number of bytes required to hold the transcoded version of the

// specified source string. This is not precise. It is an upper bounds. The

// actual transcoded string length may end up being less than this max length.

// @param aSrc Pointer to source string, for which the max transcoded length is

//  determined. The source string must be HTTP_iso_10646_ucs_2.

// @param aHttpCharSet Char set to use for transcoding.

// @return Max number of bytes in the transcoded string.

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

//

NW_Uint32 GetMaxTranscodedByteLength( const NW_Ucs2 *aSrc,

    NW_Http_CharSet_t aHttpCharSet )

    {

    NW_Uint32 len = 0;

    // Return 0 length for NULL pointer or empty string.

    if ( ( aSrc == NULL ) || ( aSrc[0] == 0 ) )

        {

        return len;

        }

    // Get the length (in characters) of the UCS2 source string.

    len = NW_Str_Strlen( aSrc );

    // For performance reasons, the exact byte length is returned for a few

    // simple and quick cases. For all the rest, an upper bounds is calculated

    // as being 3 byte-sized chars per every UCS2 char.

    switch ( aHttpCharSet )

        {

        case HTTP_us_ascii:         // 1 byte per char; length already set

        case HTTP_iso_8859_1:

            break;

        case HTTP_iso_10646_ucs_2:  // 2 bytes per char

            len *= sizeof(NW_Ucs2);

            break;

        default:                    // upper bounds is 3 byte-sized chars per char

            len *= 3;

            break;

        }

    return len;

    }

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

// TranscodeTo10646_ucs2

// Transcodes from a UCS2 string to a UCS2 byte stream for HTTP posts, which

// results in changing the two-byte chars from little endian to big endian.

// @param aSrc Pointer to source string, which is to be transcoded.

// @param aDst Pointer to destination for the transcoded results.

// @return Pointer to the next available byte within the destination buffer.

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

//

NW_Byte* TranscodeTo10646_ucs2( const NW_Ucs2* aSrc, NW_Byte* aDst )

{

    while ( *aSrc )

        {

        aDst += NW_Reader_WriteUcs2CharBuff( *aSrc, aDst);

        aSrc++;

        }

    return aDst;

}

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

// Transcode

// Translates string from NW_Ucs2 to specified charset (does not append a

// null-terminator).

// @param aDst Pointer to destination into which transcoded string is returned.

//  The size of the destination buffer should be large enough to contain the

//  transcoded string and as such the buffer needs to be allocated large enough

//  when it is created.

// @param aSrc Pointer to source string, which is to be transcoded into the

//  destination. The source string must be HTTP_iso_10646_ucs_2.

// @param aHttpCharSet Pointer to charset name (e.g. "utf-8").

// @param aBufLen Length of destination buffer (amount of space available for

//  transcoded string).

// @param aByteLen Pointer at which the byte length of the transcoded string is

//  returned.

// @return  KBrsrSuccess: if success.

//          KBrsrOutOfMemory: if out of memory.

//          KBrsrFailure: any other failure.

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

//

TBrowserStatusCode Transcode( NW_Byte *aDst, const NW_Ucs2 *aSrc, 

    NW_Http_CharSet_t aHttpCharSet, NW_Uint32 aBufLen, NW_Uint32* aByteLen )

    {

    NW_String_t text;

    NW_Uint32 srcByteLen;

    // Parameter assertion block.

    NW_ASSERT( aDst );

    NW_ASSERT( aByteLen );

    text.storage = NULL;

    // Initialize returned length to zero for now, in case an error occurs.

    *aByteLen = 0;

    NW_TRY( status )

        {

        // If there is no source, just return.

        if ( aSrc == NULL )

            {

            NW_THROW( KBrsrSuccess );

            }

        srcByteLen = NW_Str_Strlen( aSrc ) * sizeof( NW_Ucs2 );

        // Special case UCS2 for performance reasons - if both source and

        // destination are UCS2 then no intermediate buffer needed.

        if ( aHttpCharSet == HTTP_iso_10646_ucs_2 )

            {

            // Verify that there is sufficient space for the text.

            if ( srcByteLen > aBufLen )

                {

                NW_THROW( KBrsrFailure );

                }

            aDst = TranscodeTo10646_ucs2( aSrc, aDst );

            // Return the length of transcoded text in destination.

            *aByteLen = srcByteLen;

            NW_THROW( KBrsrSuccess );

            }

        // Allocate an intermediate buffer. All other char sets go through the 

        // transcoding methods which unfortunately require an intermediate

        // buffer.

        text.storage = (NW_Byte*)NW_Mem_Malloc( srcByteLen );

        NW_THROW_OOM_ON_NULL( text.storage, status );

        // Copy the source into the intermediate buffer.

        NW_Mem_memcpy( text.storage, aSrc, srcByteLen );

        text.length = srcByteLen;

        // Tanscode. Note, this assumes transcoding to original character set.

//TODO CHARSET: Make the API more flexible to take the charset as a parameter.

        status = CShell::ConvertToForeignCharSet( &text );

        _NW_THROW_ON_ERROR( status );

        // Verify that there is sufficient space for the text.

        if ( text.length > aBufLen )

            {

            NW_THROW( KBrsrFailure );

        }

        // Copy the transcoded text into the destination buffer. Note, the

        // transcoded length always includes 2 null bytes.

//TODO CHARSET: Fix ConvertToForeignCharSet and any code that uses it to not

//use 2 extra null bytes. Not as easy as it sounds. That will lead into a

//tangled web.

	    NW_Mem_memcpy( aDst, text.storage, text.length - 2 );

        // Return the length of transcoded text in destination.

        *aByteLen = text.length - 2;

        }

    // status = KBrsrSuccess; // set by NW_CATCH

    NW_CATCH( status )

        {

        }

    NW_FINALLY

        {

        NW_String_deleteStorage( &text );

        return status;

        }

    NW_END_TRY

    }

/************************************************************************

  Function: GetHttpCharsetAsAsciiText

  Description:  Returns the string of the character set.

  Parameters:   httpCharset - in: HTTP charset.

  Return Value: Pointer to the charset string.

**************************************************************************/

static const char* GetHttpCharsetAsAsciiText(NW_Http_CharSet_t httpCharset)

{

    switch (httpCharset)

    {

        case HTTP_utf_8:

            return NW_Utf8_CharsetStr;

        case HTTP_us_ascii:

            return NW_UsAscii_CharsetStr;

        case HTTP_iso_10646_ucs_2:

            return NW_Iso10646Ucs2_CharsetStr;

        case HTTP_windows_1255:

            return NW_Windows1255_CharsetStr;

        case HTTP_windows_1256:

            return NW_Windows1256_CharsetStr;

        case HTTP_windows_1250:

            return NW_Windows1250_CharsetStr;

        case HTTP_windows_1251:

            return NW_Windows1251_CharsetStr;

        case HTTP_windows_1253:

            return NW_Windows1253_CharsetStr;

        case HTTP_windows_1254:

            return NW_Windows1254_CharsetStr;

        case HTTP_windows_1257:

            return NW_Windows1257_CharsetStr;

        case HTTP_big5:

            return NW_Big5_CharsetStr;

        case HTTP_gb2312:

            return NW_Gb2312_CharsetStr;

        case HTTP_iso_8859_1:

            return NW_Iso88591_CharsetStr;

        case HTTP_iso_8859_2:

            return NW_Iso88592_CharsetStr;

        case HTTP_iso_8859_3:

            return NW_Iso88593_CharsetStr;

        case HTTP_iso_8859_4:

            return NW_Iso88594_CharsetStr;

        case HTTP_iso_8859_5:

            return NW_Iso88595_CharsetStr;

        case HTTP_iso_8859_6:

            return NW_Iso88596_CharsetStr;

        case HTTP_iso_8859_7:

            return NW_Iso88597_CharsetStr;

        case HTTP_iso_8859_8:

            return NW_Iso88598_CharsetStr;

        case HTTP_iso_8859_9:

            return NW_Iso88599_CharsetStr;

        case HTTP_tis_620:  // not flagged because we will not get here unless tis_620 is enabled

            return NW_Tis_620_CharsetStr;

        case HTTP_shift_JIS:

            return NW_ShiftJis_CharsetStr;

        case HTTP_jis_x0201_1997:

            return NW_JisX0201_1997_CharsetStr;

        case HTTP_jis_x0208_1997:

            return NW_JisX0208_1997_CharsetStr;

        case HTTP_euc_jp:

            return NW_EucJp_CharsetStr;

        case HTTP_iso_2022_jp:

            return NW_Iso2022Jp_CharsetStr;

        case HTTP_windows_874:

            return NW_Windows874_CharsetStr;

        case HTTP_Koi8_r:

            return NW_Koi8r_CharsetStr;

        case HTTP_Koi8_u:

            return NW_Koi8u_CharsetStr;

    }

    NW_ASSERT(NW_FALSE);

    return NULL; /* Make compiler happy */

}

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

// getPostDataCharset

// Gets the charset to be used for posting data. This is currently the encoding

// of the original document.

// @return Charset to be used or HTTP_iso_8859_1 if no known value.

//  HTTP_iso_8859_1 was chosen as the "default" since it is a very common