/** @file

 * Copyright (c) 2005-2006 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:  Declares HttpServer class.

 *

 */

// INCLUDE FILES

#include <in_sock.h>

#include <e32std.h>

#include <apgcli.h> // For RApaLsSession

#include <apmstd.h>

#include <escapeutils.h>

#include <bautils.h>

#include "upnphttpserver.h"

#include "upnpstring.h"

#include "upnpcons.h"

#include "upnphttpsession.h"

#include "upnphttpbuffer.h"

#include "upnphttpfiletransferreader.h"

#include "upnphttpfiletransferwriter.h"

#include "upnphttpmessagefactory.h"

#include "upnphttpheader.h"

#include "upnperrors.h"

#include "upnpcommonupnplits.h"

#include "upnpfileutils.h"

#define KLogFile _L("DLNAWebServer.txt")

#include "upnpcustomlog.h"

#include "upnphttpfileaccess.h"

#include "httperr.h"

#include "upnphttpservertransactioncreator.h"

#include "upnprangeheaderparser.h"

#include "upnphttpservertransaction.h"

// CONSTANTS

_LIT8( KTransferPending801, "HTTP/1.1 801 Transfer Pending");

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

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

// CUpnpHttpSession::NewL

// Two-phased constructor

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

//

CUpnpHttpSession* CUpnpHttpSession::NewL( RSocket aSocket,

    CUpnpHttpServer* aServer, TInt aSessionId, TThreadPriority aPriority )

    {

    LOGS1(  "%i, CUpnpHttpSession::NewL - creating session for incoming connection",

            aSessionId );

    CUpnpHttpSession* self = new (ELeave) CUpnpHttpSession( aSocket, aServer,

        aSessionId, aPriority );

    CleanupStack::PushL( self );

    self->TcpConstructL( aSocket, KRcvBufSizeDefault,

        aServer->FileReadBufferSize() );

    self->ConstructL();

    CleanupStack::Pop( self );

    LOGS1( "%i, CUpnpHttpSession::NewL - HTTP *** Created new session.",

            self->Id( ) );

    return self;

    }

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

// CUpnpHttpSession::CUpnpHttpSession

// C++ default constructor

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

//

CUpnpHttpSession::CUpnpHttpSession( RSocket aSocket,

    CUpnpHttpServer* aServer, TInt aSessionId, TThreadPriority aPriority ) :

    CUpnpTcpSession( aSocket, aPriority )

    {

    iId = aSessionId;

    iServer = aServer;

    iRequestedTransferNotifySent = EFalse;

    // Assume that session should be kept alive unless the request

    // with HTTP header "Connection: close" comes.

    iSessionKeepAlive = ETrue;

    iSessionIsDeletedAfterResponse = EFalse;

    iUsesConnectionClose = EFalse;

    iSaveToFile = EFalse;

    iOverwriteExisting = EFalse;

    iOffset = 0;

    iLength = 0;

    iSaveAtOffset = EFalse;

    iMaximumSizeChecked = EFalse;

    iHeadersCompleted = EFalse;

    }

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

// CUpnpHttpSession::ConstructL

// Two-phased constructor

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

//

void CUpnpHttpSession::ConstructL()

    {

    LOGS1( "%i, CUpnpHttpSession::ConstructL", iId );

    iFileServe = NULL;

    iDestinationPath = HBufC8::NewL( 0 );

    iSenderPath = HBufC8::NewL( 0 );

    iInFilename = HBufC8::NewL( 0 );

    iOutFilename = HBufC8::NewL( 0 );

    iPendingRequests = new (ELeave) RPointerArray<CUpnpHttpMessage> ( 1 );

    }

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

// CUpnpHttpSession::~CUpnpHttpSession

// C++ default destructor

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

//

CUpnpHttpSession::~CUpnpHttpSession()

    {

    LOGS1( "%i, CUpnpHttpSession::~CUpnpHttpSession()", iId );

    delete iFileServe;

    delete iInFilename;

    delete iOutFilename;

    delete iDestinationPath;

    delete iSenderPath;

    if ( iPendingRequests )

        {

        iPendingRequests->ResetAndDestroy();

        iPendingRequests->Close();

        delete iPendingRequests;

        }

    // no deleting of iPendingRequest, it's not owned

    iPendingRequest = NULL;

    }

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

// CUpnpHttpSession::SendL

// Send HTTP message.

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

//

void CUpnpHttpSession::SendL( CUpnpHttpMessage* aMessage )

    {

    LOGS1( "%i, CUpnpHttpSession::SendL(CUpnpHttpMessage*)", iId );

    if ( !IsConnected() )

        {

        return;

        }

    iSessionNeedsErrorReply = EFalse;

    // Set senders and destination path

    delete iSenderPath;

    iSenderPath = NULL;

    delete iDestinationPath;

    iDestinationPath = NULL;

    if ( aMessage->Method().Find( KHttp11WithoutSpace ) == 0 )

        {

        iSenderPath = HBufC8::NewL( 0 );

        aMessage->AddPairL( UpnpHTTP::KHdrServer(),

            iServer->ServerDescription() );

        }

    else

        {

        iSenderPath = aMessage->SenderPathFromHeader().AllocL();

        }

    iDestinationPath = aMessage->SenderPath().AllocL();

    // Set other properties

    iRequestType = aMessage->Type();

    iRetryCounter = aMessage->RetryCounter();

    if ( aMessage->PendingRequest() )

        {

        iPendingRequest = aMessage->PendingRequest();

        }

    //we assume that converting to UTF8 is already done by upper layers

    HBufC8* buf = aMessage->ToStringL();

    CleanupStack::PushL( buf );

    WriteL( *buf );

    CleanupStack::PopAndDestroy( buf );

    if ( !iIsPersistent )

        {

        iSessionKeepAlive = EFalse;

        }

    }

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

// CUpnpHttpSession::DeleteThisSessionL

// Delete the session.

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

//

void CUpnpHttpSession::DeleteThisSessionL( CUpnpTcpSession* /*aSession*/)

    {

    LOGS1( "%i, CUpnpHttpSession::DeleteThisSessionL", iId );

    if ( iReceivedMessage )

        {

        if ( iReceivedMessage->BytesInBuffer() > 0

                && iReceivedMessage->IsReadyL() )

            {

            TPtrC8 content = iReceivedMessage->Content();

            CUpnpHttpMessage* msg = CUpnpHttpMessage::NewL( content,

                RemoteHost(), iId );

            CleanupStack::PushL( msg );

            msg->SetType( iRequestType );

            msg->SetRetryCounter( iRetryCounter );

            THttpInvalidMessage aVal;

            aVal = IsValidMessage( msg );

            switch ( aVal )

                {

                case EMessageOk:

                    //HandleQuery will take ownership of msg object

                    CleanupStack::Pop( msg );

                    // Pass the message forward

                    HandleQueryL( msg );

                    break;

                default:

                    CleanupStack::PopAndDestroy( msg );

                    break;

                }

            }

        }

    ShutdownStop();

    }

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

// CUpnpHttpSession::DeleteFileIfExists

//

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

//

void CUpnpHttpSession::DeleteFileIfExists( TDesC16& aFilename )

    {

    iServer->FileSession().Delete( aFilename );

    }

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

// CUpnpHttpSession::MatchHttpError

//

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

//

TInt CUpnpHttpSession::MatchHttpError( TInt error )

    {

    TInt httpError = KErrNone;

    if ( error == KErrDiskFull )

        httpError = EHttpInsufficientStorage;

    else if ( error == KErrOverflow ) //one of the reason can be if chunk value is > 2^32

        httpError = EHttpInsufficientStorage;

    else if ( error == KErrAbort ) //POST HTTP/1.1

        httpError = EHttpBadRequest;

    else if ( error == KErrGeneral || error == KErrHttpUnknownParseState ) // this error may occur e.g when ContentLengthL() leaves

        httpError = EHttpBadRequest;

    else if ( -error >= EHttpBadRequest ) // HTTP errors

        httpError = -error;

    else if ( error == KErrNoMemory )

        httpError = EHttpEntityTooLarge; // OOM handling

    else if ( error == KErrNotSupported )

        httpError = EHttpNotFound; // no transaction

    else

        httpError = EHttpInternalServerError;

    return httpError;

    }

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

// CUpnpHttpSession::BufferReceivedL

//

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

//

void CUpnpHttpSession::BufferReceivedL( TDesC8& aBuffer )

    {

    TInt index = 0;

    TPtrC8 ptrIn( aBuffer );

    iPendingPostRequests = ETrue;

    //handling requests on the server-side

    if ( ptrIn.Length() > KHttpPost().Length() )

        {

        TPtrC8 ptrInOffset( ptrIn.Mid( KHttpPost().Length() ) );

        //this loop splits buffer if it includes more than one POST message

        while ( (index = ptrInOffset.Find( KHttpPost() )) >= 0 )

            {

            TPtrC8 ptrL = ptrIn.Left( index + KHttpPost().Length() );

            SinglePostBufferReceivedL( ptrL );

            ptrIn.Set( ptrIn.Mid( index + KHttpPost().Length() ) );

            ptrInOffset.Set( ptrIn.Mid( KHttpPost().Length() ) );

            }

        }

    SinglePostBufferReceivedL( ptrIn );

    iPendingPostRequests = EFalse;

    }

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

// CUpnpHttpSession::SinglePostBufferReceivedL

//

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

//

void CUpnpHttpSession::SinglePostBufferReceivedL( TDesC8& aBuffer )

    {

    TInt error = KErrNone;

        TRAP( error, BufferReceivedProcessL( aBuffer ) )

    LOGS2( "%i, CUpnpHttpSession::BufferReceivedL finished with error %i", iId, error );

    if ( error != KErrNone )

        {

        //if session left - no continuation of file transfer

        if ( iFTReader && iFTReader->Activated() )

            {

            iFTReader->SetActivated( EFalse );

            if ( iFileServe )

                iFileServe->DeleteFile();

            }

        TInt httpError = MatchHttpError( error );

        if ( httpError != KErrNone )

            {// If we act as a server side

            ResponseErrorL( httpError );

            if ( httpError == EHttpEntityTooLarge )

                {

                NotifyErrorL( httpError, error );

                }

            ShutdownStop();

            return;

            }

        }

    }

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

// CUpnpHttpSession::BufferReceivedCheckingHeadersL

//

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

//

void CUpnpHttpSession::BufferReceivedCheckingHeadersL( TDesC8& aBuffer )

    {

    // If iInFilename is defined, data should be saved in to a file,

    // this is the case of incoming GET response and for following parts of POST request.

    if ( iInFilename && iInFilename->Length() > 0 )

        {

        iSaveToFile = ETrue;

        // If this flag was set it means that even previously message was not ment

        // to be saved to file, now when the body is downloaded it will be saved to file.

        if ( iContinuedMessageDownload && !iReceivedMessage->IsToFile() )

            {

            iReceivedMessage->SetToFile( ETrue );

            }

        // Check Maximum Size requirement, but do this only once

        if ( !iMaximumSizeChecked )

            {

            //Make temp buffer to check content of incoming data,

            //its possible that content-Length is too huge (>2^32)

            CUpnpHttpBuffer* checkBuf = CUpnpHttpBuffer::NewL( this, EFalse );

            CleanupStack::PushL( checkBuf );

            //leaves in case of problems with string operation, no HTTP error

            checkBuf->AppendHeadersL( aBuffer, iSaveToFile );

            if ( checkBuf->IsHeaderReady() )

                {

                // Now headers were checked

                iHeadersCompleted = ETrue;

                TRAPD( error, checkBuf->ContentLengthL( ) );

                if ( error )

                    {

                    iSaveToFile = EFalse;

                    }

                iMaximumSizeChecked = ETrue;

                //mark chunked encoding

                iIsChunked = checkBuf->IsChunked();

                //mark if persistent connection

                if ( IsPersistentConnection() )

                    iIsPersistent = !checkBuf->UsesConnectionClose();

                }

            else

                {

                iSaveToFile = EFalse;

                }

            CleanupStack::PopAndDestroy( checkBuf );

            }

        }

    // Checking that if file is a POST that needs to be saved to a file. Only check this

    // for the first time (iFileServe does not exist only on receiving the first buffer of data)

    else if ( !iFileServe )

        {

        // making temp buffer to check content of incoming data

        CUpnpHttpBuffer* checkBuf = CUpnpHttpBuffer::NewL( this, EFalse );

        CleanupStack::PushL( checkBuf );

        //leaves in case of problems with string operation, no HTTP error

        checkBuf->AppendHeadersL( aBuffer, iSaveToFile );

        if ( checkBuf->IsHeaderReady() )

            {

            // Now headers were checked

            iHeadersCompleted = ETrue;

            TPtrC8 headers = checkBuf->Headers();

            CUpnpHttpMessage* tempMsg = NULL;

            TRAPD( err, tempMsg = CUpnpHttpMessage::NewL( (TDesC8&) headers,

                            RemoteHost( ), iId ) );

            //POST HTTP/1.1

            if ( err == KErrAbort )

                {

                if ( checkBuf->Method().Find( KHttpPost ) == 0 )

                    //leaves in case of HTTP error for a POST

                    User::Leave( KErrAbort );

                }

            else if ( err < KErrNone )

                {

                User::Leave( err );

                }

            else if ( err == KErrNone )

                {

                CleanupStack::PushL( tempMsg );

                // Check method and make decision about handling message.

                // It's a POST message

                if ( tempMsg->Method().Find( KHttpPost ) == 0 )

                    {

                    // 100-Continue check should be done for all types of POST reqests, even for GENAs and SOAPs

                    // First thing to do in case of upload is to chceck if there

                    // is sufficient disk space to save incoming file.

                    TUint fileSize = 0;

                    TBool hasCL;

                    TLex8 cntLength( tempMsg->IsHeader(

                        UpnpHTTP::KHdrContentLength, hasCL ) );

                    if ( hasCL )

                        {

                        TInt errorLength = cntLength.Val( fileSize );

                        if ( errorLength == KErrOverflow )

                            {

                            iSaveToFile = EFalse;

                            //leaves in case of HTTP error

                            User::Leave( -EHttpInsufficientStorage );

                            }

                        else if ( errorLength != KErrNone )

                            {

                            iSaveToFile = EFalse;

                            //leaves in case of HTTP error

                            User::Leave( errorLength );

                            }

                        }

                    //First check URI, because there is no sense in sending 100 continue for invalid URI

                    if (!(tempMsg->IsGena()) && !(tempMsg->IsSoap()))

                        {

                        //response is sent inside function

                        delete iInFilename;

                        iInFilename = NULL;

                        if ( !iServer->TransactionCreator() )

                            {

                            User::Leave( KErrNotSupported );

                            }

                        if ( UpnpFileUtil::ParseUri( tempMsg->SenderPathFromHeader() ) 

                             != KErrNone )

                            {

                            iInFilename = KNullDesC8().AllocL();

                            iSaveToFile = EFalse;

                            User::Leave( -EHttpBadRequest );

                            }

                        TPtrC8 relativeUri = PrepareRelativeUriL( tempMsg->SenderPathFromHeader() );

                        CUpnpHttpServerTransaction* transactionOut;

                        iServer->TransactionCreator()->NewTransactionL(

                                tempMsg->Method(), relativeUri,

                                tempMsg->Sender(), transactionOut );

                        CleanupStack::PushL( transactionOut );

                        transactionOut->SetRequest(tempMsg);

                        transactionOut->OnCallbackL( CUpnpHttpServerTransaction::EOnRequestStart );

                        iSaveToFile = EFalse;

                        User::LeaveIfError( transactionOut->Error() );

                        RBuf fileName;

                        fileName.CreateL( KMaxFileName );

                        CleanupClosePushL( fileName );

                        User::LeaveIfError( transactionOut->DataSink().FullName( fileName ) );

                        iInFilename = UpnpString::FromUnicodeL( fileName );

                        iSaveToFile = ETrue;

                        CleanupStack::PopAndDestroy(&fileName);

                        transactionOut->OnCallbackL( CUpnpHttpServerTransaction::EOnComplete );

                        CleanupStack::PopAndDestroy( transactionOut );

                        }

                    //Maximum size was checked already so don't do this again

                    iMaximumSizeChecked = ETrue;

                    // If client sends Expect: 100-continue header then it must be checked

                    // if file can be saved and if so, server should responds with 100.

                    if ( tempMsg->GetHeaderValue( UpnpHTTP::KHdrExpect ).FindC(

                        UpnpHTTP::K100Continue ) == 0 )

                        {

                        // Check disk space and ContentLength limit (2^32) and if it's not sufficient send 507 response and

                        // close connection - sugested behaviour from DLNA 1.5 spec.

                        HBufC16* pathTmp = NULL;

                        pathTmp = UpnpString::ToUnicodeL( iInFilename->Des() );

                        CleanupStack::PushL( pathTmp );