/*

* 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:  API for WebDAV operations

 *

*/

// INCLUDE FILES

#include <httpstringconstants.h>

#include <http/rhttpheaders.h>

#include <escapeutils.h>

#include <xml/matchdata.h>

#include "rsfwdavsession.h"

#include "rsfwdavtransaction.h"

#include "rsfwconnectionmanager.h"

#include "rsfwpropfindparser.h"

#include "rsfwlockqueryparser.h"

#include "mdebug.h"

// CONSTANTS

// characters that will be encoded in the url

_LIT8(KSpecials8, " \"<>#%{}|\\^~[]`");

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

CRsfwDavSession* CRsfwDavSession::NewL(

    MRsfwDavResponseObserver* aWebDavResponseObserver,

    MRsfwConnectionObserver* aRsfwConnectionObserver)

    {

    CRsfwDavSession* self = new (ELeave) CRsfwDavSession;

    CleanupStack::PushL(self);

    self->ConstructL(aWebDavResponseObserver, aRsfwConnectionObserver);

    CleanupStack::Pop(self);

    return self;

    }

void CRsfwDavSession::ConstructL(

    MRsfwDavResponseObserver* aWebDavResponseObserver,

    MRsfwConnectionObserver* aRsfwConnectionObserver)

    {

    DEBUGSTRING(("DavSess: ConstructL: enter"));

    User::LeaveIfError(iFs.Connect());

    iWebDavResponseObserver = aWebDavResponseObserver;

    iRsfwConnectionObserver = aRsfwConnectionObserver;

    // Create classes needed for parsing PropFind and Lock request replies

    // Creating these later seems to cause emulator hang-ups.

    // If the problem does not exist in the real device we may want to

    // delay especially Lock parser creation as locking may not be used at all.

    Xml::CMatchData* matchData = Xml::CMatchData::NewLC();

	matchData->SetMimeTypeL(KTextXml);

	// Select libxml2 parsesr

	matchData->SetVariantL(_L8("libxml2"));

	// Select Symbian XML Parser (=Expat)

//	matchData->SetVariantL(_L8("Symbian"));

    iPropFindParserImpl = CRsfwPropFindParser::NewL();

    iPropFindParser = Xml::CParser::NewL(*matchData, *iPropFindParserImpl);

    iLockQueryParserImpl = CRsfwLockQueryParser::NewL();

    iLockQueryParser = Xml::CParser::NewL(*matchData, *iLockQueryParserImpl);

    CleanupStack::PopAndDestroy(matchData);

    // Open the RHTTPSession

    iHttpSession.OpenL();

    iHttpSession.FilterCollection().RemoveFilter( 

            iHttpSession.StringPool().StringF( HTTP::EAuthentication, RHTTPSession::GetTable() ));

    // Install this class as the callback for authentication requests:

    // it will take care of basic/digest auth, SSL

    InstallAuthenticationL(iHttpSession);

    DEBUGSTRING(("auth filter installed"));

    }

CRsfwDavSession::~CRsfwDavSession()

    {

    DEBUGSTRING(("CRsfwDavSession::~CRsfwDavSession"));

    delete iPropFindParser;

    delete iPropFindParserImpl;

    delete iLockQueryParser;

    delete iLockQueryParserImpl;

    delete iEncodedHost;

    if (iUserName) 

    {

    	delete iUserName;	

    }

    if (iPassword) 

    {

    	delete iPassword;

    }

  	iHttpSession.Close();

  	delete iRsfwConnectionManager;

    iFs.Close();

    }

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

// CRsfwDavSession::SetConnected

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

//

void CRsfwDavSession::SetConnected(TBool aConnected)

    {

    iConnected = aConnected;

    }

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

// CRsfwDavSession::SetWebDavSupportClass

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

//

void CRsfwDavSession::SetWebDavSupportClass(TInt aWebDavSupportClass)

    {

    iWebDavSupportClass = aWebDavSupportClass;

    }

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

// CRsfwDavSession::WebDavSupportClass

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

//

TInt CRsfwDavSession::WebDavSupportClass()

    {

    return iWebDavSupportClass;

    }

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

// CRsfwDavSession::OpenL

// After calling this function, use options query

// to trigger TCP level connection.

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

//

void CRsfwDavSession::OpenL(const TDesC& aUri,

                           TInt aPort,

                           const TDesC& aUserName,

                           const TDesC& aPassword,

                           const TDesC& aAuxData)

    {

    // Store connection parameters

    iHost.Zero();

    iDavRoot.Zero();

    // Here we add the port using a simple approach:

    // it needs to go after http://name/

    TInt slashCnt = 0;

    TInt cnt = 0;

    while (cnt < aUri.Length())

        {

        TChar ch = aUri[cnt++];

        if (ch == '/')

            {

            slashCnt++;

            if (slashCnt == 3)

                {

                iHost.Append(':');

                iHost.AppendNum(aPort);

                // At this point we know that

                // the remainder of the uri is the root directory

                }  

            }

        if (slashCnt > 2)

            {

            iDavRoot.Append(ch);

            }

        else

            {

            iHost.Append(ch);

            }

        }

    // We elso need an encoded form of the host part

    iEncodedHost = EncodeL(iHost.Right(iHost.Length() - KProtocolPrefix));

    // iDavRoot must be a directory, and thus should end with a slash

    Slashify(iDavRoot);

    // Make the pair

    iHostRoot.Copy(iHost);

    iHostRoot.Append(iDavRoot);

    // Assume that the parameters are constant and stable across the session

    iUserName = EncodeL(aUserName);

    iPassword = EncodeL(aPassword);

    iAuxData.Copy(aAuxData);

    DEBUGSTRING16(("connecting to host='%S', port=%d, root='%S', data=%S",

                   &iHost,

                   aPort,

                   &iDavRoot,

                   &iAuxData));

   if (iAuxData.Length() == 0) 

   {

   		// in case of empty access point info, set it to '?' (ask user)

   		_LIT(KAskUser, "?");

   		iAuxData.Copy(KAskUser);

   }

   if (!iRsfwConnectionManager)

   		{

        iRsfwConnectionManager =

             CRsfwConnectionManager::NewL(iRsfwConnectionObserver);

        iRsfwConnectionManager->UseIapL(aAuxData);

        }

    }

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

// CRsfwDavSession::OptionsL

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

//

CRsfwDavTransaction* CRsfwDavSession::OptionsL()

    {

    TPtrC null;

    TUriParser8 uriParser;

    HBufC8* uri = BuildUriLC(null, EFalse, &uriParser);

    DEBUGSTRING8(("OPTIONS '%S'", &uriParser.UriDes()));

    // Establish a link-layer connection

    if (iRsfwConnectionManager)

        {

        SetupConnectionL();

        }

    RStringPool stringPool = StringPool();

    // Introducing the webdav headers for the propfind

    RStringF mOptions = stringPool.OpenFStringL(KWebDavOptions);

    CleanupClosePushL(mOptions);

    CRsfwDavTransaction* webDavTransaction =

        CRsfwDavTransaction::NewL(this,

                                 EWebDavOpOptions,

                                 uriParser,

                                 mOptions,

                                 NextWebDavTransactionId());

    CleanupStack::PopAndDestroy(); // mOptions

    CleanupStack::PushL(webDavTransaction);

    RHTTPHeaders hdr = webDavTransaction->

        HttpTransaction().Request().GetHeaderCollection(); 

 	SetBasicHeadersL(hdr, uriParser, ETrue);

    CleanupStack::Pop(2); //webDavTransaction, uri

    delete uri;

    return webDavTransaction;

    }

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

// CRsfwDavSession::PropFindL

// Implements WebDAV PROPFIND method.

// Parameters: Name of the directory or file

//             CRsfwDirEnt pointer array to be filled with directory metadata

//             PROPFIND depth

//             aIsDir, is this directory or file,

//                     some extra checks are made based on this...

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

//

CRsfwDavTransaction* CRsfwDavSession::PropFindL(const TDesC &aPath,

                                              TInt aDepth,

                                              TBool aIsDir,

                                              RPointerArray<CRsfwDirEnt>& aDirEnts)

    {

    if (!IsConnected())

        {

        User::Leave(KErrNotReady);

        }

    TUriParser8 uriParser;

    HBufC8* uri = BuildUriLC(aPath, aIsDir, &uriParser);

    DEBUGSTRING8(("PROPFIND '%S'", &uriParser.UriDes()));

    // This function is used from several places

    TWebDavOp op;

    if (aDepth == 1)

        {

        op = EWebDavOpPropFindMulti;

        }

    else // (aDepth == 0)

        {

        op = EWebDavOpPropFindSingle;  

        }

    RStringPool stringPool = StringPool();

    RStringF mPropFind = stringPool.OpenFStringL(KWebDavPropFind);

    CleanupClosePushL(mPropFind);

    CRsfwDavTransaction* webDavTransaction =

        CRsfwDavTransaction::NewL(this,

                                 op,

                                 uriParser,

                                 mPropFind,

                                 NextWebDavTransactionId());

    CleanupStack::PopAndDestroy(); // mPropFind

    CleanupStack::PushL(webDavTransaction);

    RHTTPHeaders hdr = webDavTransaction->

        HttpTransaction().Request().GetHeaderCollection();

    // Add headers appropriate to all methods

    SetBasicHeadersL(hdr, uriParser, ETrue);

    SetHeaderL(hdr, HTTP::EContentType, KTextXml);

    // Assumes that the target uri has been cached in an earlier connect

    SetDepthHeaderL(hdr, aDepth);

    // XML body

    HBufC8* requestBodyBuffer = HBufC8::NewL(KDefaultSubmitSize);

    TPtr8 requestBodyBufferPtr = requestBodyBuffer->Des();

    // To make things at least little bit faster,

    // let's try to get "minimal" set

    // Maybe useful one day:

    // - <D:getcontentlanguage/>

    // - <D:creationdate/>

    // Apache mod_dav 1.0.3 doesn't support:

    //  - <D:displayname/>

    _LIT8(KPropFindRequestBody, "\

<?xml version=\"1.0\"?>\

<propfind xmlns=\"DAV:\">\

<prop>\

<getcontenttype/>\

<getlastmodified/>\

<getcontentlength/>\

<resourcetype/>\

<getetag/>\

</prop>\

</propfind>\

");

    requestBodyBufferPtr.Append(KPropFindRequestBody);

    webDavTransaction->SetBodyData(requestBodyBuffer);

    webDavTransaction->SetPropFindDirEntryArray(aDirEnts);

    // We must remember the work directory,

    // as we don't want to list that when building directory listing.

    HBufC* propFindPath = HBufC::NewL(iHostRoot.Length() +

                                       KMaxPath +

                                       1);

    TPtr propFindPathPtr = propFindPath->Des();

    propFindPathPtr.Copy(iDavRoot);

    propFindPathPtr.Append(aPath);

    // The whole path must end with a slash

    Slashify(propFindPathPtr);

    // Before comparing the path from the server is decoded,

    // so we can compare against the original 16-bit string.

    webDavTransaction->SetPropFindPath(propFindPath);

    CleanupStack::Pop(2); // webdavtransaction, uri

    delete uri;

    return webDavTransaction;

    }

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

// CRsfwDavSession::GetL

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

//

CRsfwDavTransaction* CRsfwDavSession::GetL(const TDesC& aSrcPath,

                                         const TDesC& aDstPath,

                                         TInt aOffset,

                                         TInt* aLength,

                                         TUint aFlags)

    {

    // Basically just a HTTP get with some local processing

    if (!IsConnected())

        {

        User::Leave(KErrNotReady);

        }

    TUriParser8 uriParser;

    HBufC8* uri = BuildUriLC(aSrcPath, EFalse, &uriParser);

#ifdef _DEBUG

    {

    TInt length;

    if (aLength)

        {

        length = *aLength;

        }

    else

        {

        length = 0;

        }

    DEBUGSTRING8(("GET '%S' (off=%d, len=%d)",

                  &uriParser.UriDes(),

                  aOffset,

                  length));

    }

#endif // DEBUG

    // Introducing the webdav headers for GET

    RStringPool stringPool = StringPool();

    RStringF mGet = stringPool.StringF(HTTP::EGET,

                                       RHTTPSession::GetTable());  

    CRsfwDavTransaction* webDavTransaction =

        CRsfwDavTransaction::NewL(this,

                                 EWebDavOpGet,

                                 uriParser,

                                 mGet,

                                 NextWebDavTransactionId());

    CleanupStack::PushL(webDavTransaction);

    // Not sure if this is needed: we are setting conditions

    // which mod_dav never gets, cos this is a GET..

    RHTTPHeaders hdr =

        webDavTransaction->HttpTransaction().Request().GetHeaderCollection();

    // Add headers appropriate to all methods

    SetBasicHeadersL(hdr, uriParser, ETrue);

    if (aLength && (*aLength > 0)) // partial get

        {

        TBuf8<KMaxFieldValueLength> rangeHeader;

        _LIT8(KBytesEquals, "bytes=");

        rangeHeader.Append(KBytesEquals);

        rangeHeader.AppendNum(aOffset);

        rangeHeader.Append('-');

        rangeHeader.AppendNum(aOffset + *aLength - 1);

        SetHeaderL(hdr, HTTP::ERange, rangeHeader);

        }

    webDavTransaction->SetBodyFileL(aDstPath, aOffset, aLength, aFlags);

    CleanupStack::Pop(webDavTransaction);

    CleanupStack::PopAndDestroy(uri);

    return webDavTransaction;

    }

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

// CRsfwDavSession::PutL

// This amounts to a PUT sending the src data to the destination.

// Expects that the aSrcPath param is relative to iDavRoot.

// If aSrcPath is empty, an empty file will be created.

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

//

CRsfwDavTransaction* CRsfwDavSession::PutL(const TDesC& aSrcPath,

                                         const TDesC& aDstPath,

                                         const TDesC8& aMimeType,

                                         TInt aOffset,

                                         TInt aLength,

                                         TInt aTotalLength,

                                         TBool aUseContentRange,

                                         const TDesC8* aLockToken)

    {  

    if (!IsConnected())

        {

        User::Leave(KErrNotReady);

        }

    TUriParser8 uriParser;

    HBufC8* uri = BuildUriLC(aDstPath, EFalse, &uriParser);

    DEBUGSTRING8(("PUT '%S'", &uriParser.UriDes()));

    RStringPool stringPool = StringPool();

    RStringF mPut = stringPool.OpenFStringL(KWebDavPut);

    CleanupClosePushL(mPut);

    CRsfwDavTransaction* webDavTransaction =

        CRsfwDavTransaction::NewL(this,

                                 EWebDavOpPut,

                                 uriParser,

                                 mPut,

                                 NextWebDavTransactionId());

    CleanupStack::PopAndDestroy(); // mPut

    CleanupStack::PushL(webDavTransaction);

    RHTTPHeaders hdr =

        webDavTransaction->HttpTransaction().Request().GetHeaderCollection(); 

    // Add headers appropriate to all methods

    SetBasicHeadersL(hdr, uriParser, ETrue);  

    SetHeaderL(hdr, HTTP::EContentType, aMimeType);

    if (aLength > 0) // partial put

        {

        if (aUseContentRange)

            {

            TBuf8<KMaxFieldValueLength> rangeHeader;

            _LIT8(KBytes, "bytes ");

            rangeHeader.Append(KBytes);

            rangeHeader.AppendNum(aOffset);

            rangeHeader.Append('-');

            rangeHeader.AppendNum(aOffset + aLength - 1);

            rangeHeader.Append('/');

            if (aTotalLength == 0) 

                {

                // The asterisk "*" character means that 

                // the instance-length is unknown at the time when 

                // the message was generated. 

                rangeHeader.Append('*');

                }

            else

                {

                rangeHeader.AppendNum(aTotalLength);

                }

            SetHeaderL(hdr, HTTP::EContentRange, rangeHeader);

            }

        else

            {

            // server doesn't support Content-Range

            // Leave with KrrNotSupported

            // *aLength = aTotalLength;

            }  

        }

    if (aLockToken)

        {  

        SetLockTokenHeaderL(hdr, uri, aLockToken, ETrue);

        }

    webDavTransaction->SetBodyFileL(aSrcPath, aOffset, &aLength, 0);

    CleanupStack::Pop(webDavTransaction);

    CleanupStack::PopAndDestroy(uri);

    return webDavTransaction;

    }

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

// CRsfwDavSession::DeleteL

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

//

CRsfwDavTransaction* CRsfwDavSession::DeleteL(const TDesC& aPath,

                                            TBool aIsDir,

                                            const TDesC8* aLockToken)

    {