/*

* Copyright (c) 2002-2004 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:  Handle WebDAV transactions

 *

*/

// INCLUDE FILES

//#include <HttpStringConstants.h>

#include <http/rhttpheaders.h>

#include <httperr.h>

#include <es_sock.h>

#include "rsfwremoteaccess.h"

#include "rsfwdavtransaction.h"

#include "rsfwdavsession.h"

#include "rsfwdavfileinfo.h"

#include "mdebug.h"

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

// Destructor

CRsfwDavTransaction::~CRsfwDavTransaction()

    {

    DEBUGSTRING(("WebDAV transaction %d in destructor ...", Id()));

    iHttpTransaction.Close();

    iBodyFile.Close();

    delete iRequestBodyBuffer;

    delete iPropFindPath;

    delete iResponseBuffer;

    DEBUGSTRING(("... done"));

    }

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

// CRsfwDavTransaction:::NewL

// Two-phased constructor.

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

//

CRsfwDavTransaction* CRsfwDavTransaction::NewL(CRsfwDavSession* aWebDavSession,

                                             TWebDavOp aWebDavOp,

                                             const TUriC8& aUri,

                                             RStringF aMethod,

                                             TUint aTransactionId)

    {

    CRsfwDavTransaction* self = new (ELeave) CRsfwDavTransaction;

    CleanupStack::PushL(self);

    self->ConstructL(aWebDavSession,

                     aWebDavOp,

                     aUri,

                     aMethod,

                     aTransactionId);

    CleanupStack::Pop(self);

    return self;

    }

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

// CRsfwDavTransaction::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CRsfwDavTransaction::ConstructL(CRsfwDavSession* aWebDavSession,

                                    TWebDavOp aWebDavOp,

                                    const TUriC8& aUri, 

                                    RStringF aMethod,

                                    TInt aTransactionId)

    {

    iWebDavSession = aWebDavSession;

    iTransactionId = aTransactionId;

    // Borrow the file server from the parent

    iFs = iWebDavSession->FileServerSession();

    iWebDavOp = aWebDavOp;

    // User may cancel the IAP selection

    iStatus = KErrCancel;

    iHttpTransaction = iWebDavSession->HttpSession().OpenTransactionL(aUri,

                                                                      *this,

                                                                      aMethod);

    // Set body supplier as me

    switch (aWebDavOp)

        {

    case EWebDavOpPut:

    case EWebDavOpPropFindSingle:

    case EWebDavOpPropFindMulti:

    case EWebDavOpLock:

        iHttpTransaction.Request().SetBody(*this);

        break;

    default:

        break;

        }

    }

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

// CRsfwDavTransaction::SetBodyDataL

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

//

void CRsfwDavTransaction::SetBodyData(HBufC8* aRequestBodyBuffer)

    {

    iRequestBodyBuffer = aRequestBodyBuffer;

    }

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

// CRsfwDavTransaction::SetBodyFileL

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

//

void CRsfwDavTransaction::SetBodyFileL(const TDesC& aPath,

                                      TInt aOffset,

                                      TInt* aLength,

                                      TUint aFlags)

    {

    iBodyFilePath = aPath;

    iBodyFileOffset = aOffset;

    iBodyFileFlags = aFlags;

    iParsedBodyFilePath.Set(iBodyFilePath, NULL, NULL);

    DEBUGBUFFER((iParsedBodyFilePath.FullName()));

    if (iWebDavOp == EWebDavOpPut)

        {

        if (iBodyFilePath.Length())

            {

            // Check it exists and open a file handle

            if (!iFs.IsValidName(iBodyFilePath))

                {

                User::Leave(KErrPathNotFound);

                }

            TInt err = iBodyFile.Open(iFs,

                                      iParsedBodyFilePath.FullName(),

                                      EFileRead | EFileShareAny);

            if (err != KErrNone)

                {

                DEBUGSTRING(("Cannot set body file (err=%d)", err));

                User::Leave(err);

                }

            if ((*aLength) > 0) // partial PUT

                {

                iOverallDataSize =  *aLength;

                }

            else

                {

                User::LeaveIfError(iBodyFile.Size(iOverallDataSize));

                iOverallDataSize -= iBodyFileOffset;

                }

            iRequestBodyBuffer = HBufC8::NewL(KDefaultSubmitSize);

            }

        }

    else

        {

        // EWebDavOpGet

        iClientsLength = aLength;

        if (iClientsLength)

            {

            *iClientsLength = 0;

            }

        // store pointer to client's length variable and set it to zero

        // we will later reset it based on the content-length header

        if (!iFs.IsValidName(iBodyFilePath))

            {

            User::Leave(KErrPathNotFound);

            }

        }

    }

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

// CRsfwDavTransaction::SetDavFileInfoL

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

//

void CRsfwDavTransaction::SetDavFileInfoL(CRsfwDavFileInfo** aDavFileInfo,

                                         const TDesC& aPath)

    {

    if (aDavFileInfo)

        {

        iDavFileInfo = CRsfwDavFileInfo::NewL();

        iDavFileInfo->SetNameL(aPath);

        *aDavFileInfo = iDavFileInfo;

        }

    }

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

// CRsfwDavTransaction::SetPropFindDirEntryArray

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

//

void CRsfwDavTransaction::SetPropFindDirEntryArray(

    RPointerArray<CRsfwDirEnt>& aDirEnts)

    {

    // We do not get the ownership

    iDirEnts = &aDirEnts;

    }

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

// CRsfwDavTransaction::SetPropfindPath

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

void CRsfwDavTransaction::SetPropFindPath(HBufC* aPropFindPath)

    {

    // We get the ownership

    iPropFindPath = aPropFindPath;

    }

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

// CRsfwDavTransaction::Submit

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

//

void CRsfwDavTransaction::SubmitL()

    {

    DEBUGSTRING(("submitting WebDav operation %d, id=%d ...",

                 iWebDavOp,

                 Id()));

    TRAPD(err, iHttpTransaction.SubmitL());

    if (err != KErrNone)

        {

        DEBUGSTRING(("WebDav transaction %d left with err %d!",

                     Id(),

                     err));

        // Release resources

        Cleanup();

        User::Leave(err);

        }

    }

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

// CRsfwDavTransaction::Cancel

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

//

void CRsfwDavTransaction::Cancel()

    {

    DEBUGSTRING(("Canceling WebDav transaction %d ...", Id()));

    iHttpTransaction.Cancel();

    // Cancel XML parsing, if ongoing

    iWebDavSession->CancelParsing(iWebDavOp);

    // We don't receive any callback from the HTTP stack,

    // as we have not registered a filter to get ECancel event,

    // so we have to initiate the cleanup process ourselves...

    iStatus = KErrCancel;

    TransactionError();

    }

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

// From MHTTPTransactionCallback

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

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

// CRsfwDavTransaction::MHFRunL

// Called when an action takes place on the transaction.

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

//

void CRsfwDavTransaction::MHFRunL(RHTTPTransaction aTransaction,

                                 const THTTPEvent& aEvent)

    {

    DEBUGSTRING(("MHFRunL() transaction %d (http id = %d) status: %d",

                 iTransactionId,

                 aTransaction.Id(),

                 aEvent.iStatus));

    TBool done = EFalse;

    TBool ok = EFalse;

    switch (aEvent.iStatus)

        {

    case THTTPEvent::EGotResponseHeaders:     // process the headers

        {

        // HTTP response headers have been received.

        // We can determine now if there is

        // going to be a response body to save.

        RHTTPResponse response = aTransaction.Response();

        iStatus = response.StatusCode();

        DEBUGSTRING(("MHFRunL() THTTPEvent::EGotResponseHeaders, status %d",

                     iStatus));

        if (iWebDavOp == EWebDavOpOptions)

            {

            // Get a pointer to the session owned by WebDavSession

            RHTTPSession session = aTransaction.Session();

            RHTTPHeaders hdr = response.GetHeaderCollection();

            // Get DAV:- header,

            // which should be DAV: 1 if WebDAV v. 1 supported

            // or DAV: 1, 2 if also WebDAV v. 2 is supported

            TBuf8<KMaxDavVersionValue> davBuffer;

            _LIT8(KDav, "DAV");

            davBuffer.Append(KDav);

            RStringF davString =

                session.StringPool().OpenFStringL(davBuffer); 

            THTTPHdrVal val;

            TInt r = hdr.GetField(davString, 0, val);

            davString.Close();

            if (r == KErrNone)

                {

                RStringF valStr;

                valStr = val.StrF();

                TPtrC8 davTag = valStr.DesC();

                DEBUGSTRING8(("DAV: DAV=%S", &davTag));

                TLex8 lex(davTag);        

                // Skip over non-numeric chars as long as the list continues...

                TChar theChar;

                TInt supportedLevel = -1;

                while (lex.Peek()) 

                    {

                    theChar = lex.Get();

                    if (theChar.IsDigit()) 

                    	{

                    	supportedLevel = theChar.GetNumericValue();

                    	}

                    }

                if (supportedLevel == -1) 

                	{

               		// DAV not supported...

                    User::Leave(KErrNotSupported);	

                	}

                iWebDavSession->SetWebDavSupportClass(supportedLevel);

                }

            else

                {

                DEBUGSTRING(("DAV=<empty>"));

                if (iStatus == HTTPStatus::EUnauthorized)

                    {

                    User::Leave(KErrAccessDenied);

                    }

                else

                    {

                    if (iStatus == HTTPStatus::EOk) 

                    	{

                    	// everything seemed to be ok,

                    	// but no DAV: header

                    	User::Leave(KErrNotSupported);

                    	}

                    else 

                    	{

                    	User::Leave(iStatus);

                   		}

                    }

                }

            }

        // Get the content length and create iResponseBuffer,

        // where the body will be stored.

        // However, if we are copying file from the server,

        // the body (file) will just be stored into

        // the container file, no memory buffer is needed

        if (response.HasBody() &&

            // iStatus must be in 'Successful' range of HTTP codes 2xx

            (iStatus >= 200) && 

            (iStatus < 300) &&

            (iStatus != HTTPStatus::ENoContent))

            {

            DEBUGSTRING(("MHFRunL() response has a body..."));

            MHTTPDataSupplier* responseBody = response.Body();

            switch (iWebDavOp)

                {

            case EWebDavOpGet:

                {

                // Prepare to dump the body to container file

                TInt err;

                if (iStatus == HTTPStatus::EPartialContent) 

                    {

                    err = iBodyFile.Open(iFs,

                                         iParsedBodyFilePath.FullName(),

                                         EFileWrite | EFileShareAny);

                    if (err == KErrNone)

                        {

                        if (!(iBodyFileFlags &

                              KRemoteAccessOptionGetToStartOfFile))

                            {

                            TInt pos = iBodyFileOffset;

                            DEBUGSTRING(("Get: partial content received, seek to %d", pos));

                            iBodyFile.Seek(ESeekStart, pos);

                            if (pos != iBodyFileOffset)

                                {

                                // Should never happen

                                DEBUGSTRING(("Get: seek to %d failed (pos=%d)",

                                             iBodyFileOffset,

                                             pos));

                                User::Leave(KErrArgument);

                                }

                            }

                        }

                    else 

                        {

                        DEBUGSTRING(("Get: partial content received, will overwrite the cache file, err=%d", err));

                        User::LeaveIfError(

                            iBodyFile.Replace(

                                iFs,

                                iParsedBodyFilePath.FullName(),

                                EFileWrite | EFileShareAny));

                        }

                    }

                else // overwrite...

                    {

                    DEBUGSTRING(("Get: full content received"));

                    User::LeaveIfError(

                        iBodyFile.Replace(

                            iFs,

                            iParsedBodyFilePath.FullName(),

                            EFileStream | EFileWrite | EFileShareAny));

                    }

                // larger memory buffer

                TInt dataSize = responseBody->OverallDataSize();

                DEBUGSTRING(("MHFRunL() creating a response buffer, size=%d",

                             dataSize));

                if (dataSize <= KDefaultFileBufferSize) // 40k

                    {

                    iResponseBuffer = HBufC8::NewL(dataSize);

                    }

                else

                    {

                    iResponseBuffer = HBufC8::NewL(KDefaultFileBufferSize);

                    }

                }

                break;

            case EWebDavOpPropFindSingle:

            case EWebDavOpPropFindMulti:

            case EWebDavOpLock:

            case EWebDavOpRefreshLock:

                {

                if (iWebDavOp == EWebDavOpPropFindMulti)

                    {

                    PropFindResponseBeginL(KDavResourceTypeCollection);

                    }

                else if (iWebDavOp == EWebDavOpPropFindSingle)

                    {

                    PropFindResponseBeginL(KDavResourceTypeOther);

                    }

                else

                    {

                    LockQueryResponseBegin();

                    }

                }

                break;

            default:

                {

                // We are not interested in any body

                iDiscardBody = ETrue;

                }

                break;

                }

            }

        else

            {

            DEBUGSTRING(("MHFRunL() response does not have a body..."));

            iDiscardBody = ETrue;

            }

        }

        break;

    case THTTPEvent::EGotResponseBodyData:

        {

        DEBUGSTRING(("MHFRunL() THTTPEvent::EGotResponseBodyData"));

        // Get the body data supplier

        TBool allDone;

        MHTTPDataSupplier* responseBody = aTransaction.Response().Body();

        ASSERT(responseBody);

        // Some (more) body data has been received (in the HTTP response)   

        TPtrC8 bodyData;

        allDone = responseBody->GetNextDataPart(bodyData);

        DEBUGSTRING(("MHFRunL() body size = %d (all=%d)",

                     bodyData.Length(),

                     allDone));

        if (!iDiscardBody)

            {

            switch (iWebDavOp) 

                {

            case EWebDavOpPropFindSingle:

            case EWebDavOpPropFindMulti:

                {

                ParsePropFindResponseL(bodyData);

                if (allDone)

                    {

                    PropFindResponseEndL();

                    }             

                }

                break;

            case EWebDavOpLock:

            case EWebDavOpRefreshLock:

                {

                ParseLockResponseL(bodyData);

                if (allDone)

                    {

                    LockResponseEndL();

                    }             

                }

                break;

            case EWebDavOpGet: 

                {

                // set client's length variable

                // based on the amount of data fetched

                if (iClientsLength) 

                    {

                    *iClientsLength += bodyData.Length();

                    }

                TPtr8 responseBodyPtr = iResponseBuffer->Des();

                if ((responseBodyPtr.Length() + bodyData.Length()) <=

                    KDefaultFileBufferSize)

                    {

                    responseBodyPtr.Append(bodyData);

                    }

                else 

                    {

                    DEBUGSTRING(("Get: writing to cache file: %d bytes",

                                 responseBodyPtr.Length()));

                    User::LeaveIfError(iBodyFile.Write(responseBodyPtr));

                    // Reset buffer with new data

                    responseBodyPtr.Copy(bodyData);

                    }

                if (allDone) // this was the last chunk

                    {

                    DEBUGSTRING(("Get: writing to cache file %d bytes and closing",

                                 responseBodyPtr.Length()));

                    User::LeaveIfError(iBodyFile.Write(responseBodyPtr));

                    iBodyFile.Close();

                    }