/*

* 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:  Implements remote access plugin API using WebDAV protocol

 *

*/

// INCLUDE FILES

#include "rsfwdavaccess.h"

#include "rsfwdavfileinfo.h"

#include "rsfwdavaccesscontext.h"

#include "rsfwdavtransaction.h"

#include "mdebug.h"

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

void CRsfwDavAccess::ConstructL()

    {

    }

CRsfwDavAccess* CRsfwDavAccess::NewL()

    {

    CRsfwDavAccess* self = new (ELeave) CRsfwDavAccess;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CRsfwDavAccess::~CRsfwDavAccess()

    {

    delete iWebDavSession;

    iDavFileInfos.ResetAndDestroy();

    iDavAccessContexts.ResetAndDestroy(); 

    }

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

// CRsfwDavAccess::DavFileInfoL

// Find the file info for the given file name.

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

//

CRsfwDavFileInfo* CRsfwDavAccess::DavFileInfoL(const TDesC& aName)

    {

    TInt index = DavFileInfoIndexL(aName);

    if (index != KErrNotFound)

        {

        return iDavFileInfos[index];

        }

    return NULL;

    }

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

// CRsfwDavAccess::AddDavFileInfo

// Add a new file info entry.

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

//

void CRsfwDavAccess::AddDavFileInfo(CRsfwDavFileInfo* aDavFileInfo)

    {

#ifdef _DEBUG

    TPtrC namePtr;

    if (aDavFileInfo->Name())

        {

        namePtr.Set(*aDavFileInfo->Name());

        }

    TPtrC8 lockPtr;

    if (aDavFileInfo->LockToken())

        {

        lockPtr.Set(*aDavFileInfo->LockToken());

        }

    DEBUGSTRING16(("Add file info: name='%S'", &namePtr));

    DEBUGSTRING8(("               lock='%S', time=%d",

                  &lockPtr,

                  aDavFileInfo->Timeout()));

#endif // DEBUG

    iDavFileInfos.Append(aDavFileInfo);

    }

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

// CRsfwDavAccess::RemoveDavFileInfoL

// Remove a file info entry.

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

//

void CRsfwDavAccess::RemoveDavFileInfoL(const TDesC& aPath)

    {

    TInt index = DavFileInfoIndexL(aPath);

    if (index != KErrNotFound)

        {

        CRsfwDavFileInfo* davFileInfo =  iDavFileInfos[index];

#ifdef _DEBUG

        TPtrC namePtr;

        if (davFileInfo->Name())

            {

            namePtr.Set(*davFileInfo->Name());

            }

        DEBUGSTRING16(("Remove file info: name='%S'", &namePtr));

#endif // DEBUG

        iDavFileInfos.Remove(index);

        delete davFileInfo;

        }

    }

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

// CRsfwDavAccess::SetupL

// Setup - should be immediately followed by NewL() call.

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

//

void CRsfwDavAccess::SetupL(MRsfwRemoteAccessObserver* aRsfwRemoteAccessObserver)

    {

    DEBUGSTRING(("DAV: SetupL"));

    MRsfwConnectionObserver* rsfwConnectionObserver = NULL;

    if (aRsfwRemoteAccessObserver)

        {

        // Cascade remote access observers

        iRsfwRemoteAccessObserver = aRsfwRemoteAccessObserver;

        rsfwConnectionObserver = this;

        }

    iWebDavSession = CRsfwDavSession::NewL(this, rsfwConnectionObserver);

    }

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

// CRsfwDavAccess::OpenL

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

//

TUint CRsfwDavAccess::OpenL(const TUriC& aUri,

                        const TDesC& /*aFriendlyName*/,

                        const TDesC& aUserName,

                        const TDesC& aPassword,

                        const TDesC& aAuxData,

                        MRsfwRemoteAccessResponseHandler* aResponseHandler)

    {

    if (!aResponseHandler)

        {

        User::Leave(KErrArgument);

        }

    HBufC* url = HBufC::NewLC(KHttpsScheme().Length() +

                              KMaxServerNameLen +

                              1 +

                              KMaxPath);

    TPtr urlPtr = url->Des();

    TInt portNumber = 0;

    if (aUri.IsPresent(EUriPort))

        {

        TLex portx(aUri.Extract(EUriPort));

        if (portx.Val(portNumber) != KErrNone)

            {

            portNumber = 0;

            }

        }

    // Check scheme and map it to port number or vice versa

    TPtrC scheme;

    if (aUri.IsPresent(EUriScheme))

        {

        scheme.Set(aUri.Extract(EUriScheme));

        }

    if (scheme.Length())

        {

        if (portNumber == 0)

            {

            if (scheme.CompareF(KHttpsScheme) == 0)

                {

                portNumber = KHttpsPortNumber;

                }

            else

                {

                portNumber = KHttpPortNumber;

                }

            }

        }

    else

        {

        if (portNumber == 0)

            {

            portNumber = KHttpPortNumber;

            }

        if (portNumber == KHttpPortNumber)

            {

            scheme.Set(KHttpScheme);

            }

        else if (portNumber == KHttpsPortNumber)

            {

            scheme.Set(KHttpsScheme);

            }

        else

            {

            User::Leave(KErrBadName);

            }

        }

    TPtrC rootDirectory;

    if (aUri.IsPresent(EUriPath))

        {

        rootDirectory.Set(aUri.Extract(EUriPath));

        }

    iRootDirectory.Copy(rootDirectory);

    if (!iRootDirectory.Length() ||

        iRootDirectory[iRootDirectory.Length() - 1] != '/')

        {

        // Append trailing '/'

        iRootDirectory.Append('/');

        }

    urlPtr.Copy(scheme);

    urlPtr.Append(':');

    urlPtr.Append('/');

    urlPtr.Append('/');

    urlPtr.Append(aUri.Extract(EUriHost));

    // There needs to be a slash between server name and the root dir

    // (we assume that there cannot be an excess of slash characters)

    if (urlPtr[urlPtr.Length() - 1] != '/')

        {

        if (!iRootDirectory.Length() || (iRootDirectory[0] != '/'))

            {

            urlPtr.Append('/');

            }

        }

    urlPtr.Append(iRootDirectory);

    DEBUGSTRING16(("DAV: OpenL to URL '%S'", &urlPtr));

    iWebDavSession->OpenL(urlPtr,

                          portNumber,

                          aUserName,

                          aPassword,

                          aAuxData);

    CleanupStack::PopAndDestroy(url);

    return OptionsL(aResponseHandler);

    }

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

// CRsfwDavAccess::GetDirectoryL

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

//

TUint CRsfwDavAccess::GetDirectoryL(const TDesC& aPathName,

                                RPointerArray<CRsfwDirEnt>& aDirEnts,

                                MRsfwRemoteAccessResponseHandler* aResponseHandler)

    {

    // Get the contents of the directory

    DEBUGSTRING16(("DAV: GetDirectory '%S'", &aPathName));

    // check that arguments are sensible

    // aPathName might here be null (mounted root directory)

    if (aPathName.Length() > KMaxPath)

        {

        User::Leave(KErrBadName);

        }

    if (!aResponseHandler)

        {

        User::Leave(KErrArgument);

        }

    CRsfwDavAccessContextPropFindDir* davAccessContextPropFindDir =

        CRsfwDavAccessContextPropFindDir::NewL(this,

                                           aResponseHandler,

                                           aPathName,

                                           1,

                                           NULL,

                                           &aDirEnts);

    TUint id = AddAccessContext(davAccessContextPropFindDir);

    davAccessContextPropFindDir->StartL();

    return id;

    }

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

// CRsfwDavAccess::GetFileL

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

//

TUint CRsfwDavAccess::GetFileL(const TDesC& aRemotePathName,

                           const TDesC& aLocalPathName,

                           TInt aOffset,

                           TInt* aLength,

                           TUint aFlags,

                           MRsfwRemoteAccessResponseHandler* aResponseHandler)

    {

#ifdef _DEBUG

    {

    TInt length;

    if (aLength)

        {

        length = *aLength;

        }

    else

        {

        length = 0;

        }

    DEBUGSTRING16(("DAV: GetFile rn='%S', ln='%S' (off=%d, len=%d)",

                   &aRemotePathName,

                   &aLocalPathName,

                   aOffset,

                   length));

    }

#endif // DEBUG

    // check that arguments are sensible

    if (aOffset < 0 ||

       (aLength && *aLength < 0) ||

       (!aResponseHandler))

        {

        User::Leave(KErrArgument);

        }

    if ((aLocalPathName.Length() == 0) ||

        (aLocalPathName.Length() > KMaxPath) ||

        (aRemotePathName.Length() == 0) ||

        (aRemotePathName.Length() > KMaxPath))

        {

        User::Leave(KErrBadName);

        }

    CRsfwDavAccessContextGet* davAccessContextGet =

        CRsfwDavAccessContextGet::NewL(this,

                                   aResponseHandler,

                                   aRemotePathName,

                                   aLocalPathName,

                                   aOffset,

                                   aLength,

                                   aFlags);

    TUint id = AddAccessContext(davAccessContextGet);

    davAccessContextGet->StartL();

    return id;

    }

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

// CRsfwDavAccess::PutFileL

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

//

TUint CRsfwDavAccess::PutFileL(const TDesC& aLocalPathName,

                           const TDesC& aRemotePathName,

                           const TDesC8& aMimeType,

                           TInt aOffset,

                           TInt aLength,

                           TInt aTotalLength,

                           MRsfwRemoteAccessResponseHandler* aResponseHandler)

    {

    // Copy file to server using PUT,

    // might require lock token, if the destination file is locked...

#ifdef _DEBUG

    {

    TInt length;

    if (aLength)

        {

        length = aLength;

        }

    else

        {

        length = 0;

        }

    DEBUGSTRING16(("DAV: PutFile ln='%S', rn='%S' (off=%d, len=%d)",

                   &aLocalPathName,

                   &aRemotePathName,

                   aOffset,

                   length));

    }

#endif // DEBUG

    // check that arguments are sensible

    if (aOffset < 0 ||

       (aLength < 0) ||

       (((aOffset + aLength) > aTotalLength) && aTotalLength > 0) ||

       (!aResponseHandler))

        {

        User::Leave(KErrArgument);

        }

    // note that aLocalPathName can be undefined

    // (CreateFile calls with null-ptr)

    if ((aLocalPathName.Length() > KMaxPath) ||

        (aRemotePathName.Length() == 0) ||

        (aRemotePathName.Length() > KMaxPath) ||

        (aMimeType.Length() > KMaxMimeTypeLength))

        {

        User::Leave(KErrBadName);

        }

    const HBufC8* lockToken = NULL;

    CRsfwDavFileInfo *davFileInfo = DavFileInfoL(aRemotePathName);

    if (davFileInfo)

        {

        lockToken = davFileInfo->LockToken();

        }

    CRsfwDavAccessContextPut* davAccessContextPut =

        CRsfwDavAccessContextPut::NewL(this,

                                   aResponseHandler,

                                   aLocalPathName,

                                   aRemotePathName,

                                   aMimeType,

                                   aOffset,

                                   aLength,

                                   aTotalLength,

                                   lockToken);

    TUint id = AddAccessContext(davAccessContextPut);

    davAccessContextPut->StartL();

    return id;

    }

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

// CRsfwDavAccess::PutFileL

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

//

TUint CRsfwDavAccess::PutFileL(const TDesC& aLocalPathName,

                           const TDesC& aRemotePathName,

                           const TDesC8& aMimeType,

                           MRsfwRemoteAccessResponseHandler* aResponseHandler)

    {

    return PutFileL(aLocalPathName,

                    aRemotePathName,

                    aMimeType,

                    0,

                    NULL,

                    0,

                    aResponseHandler);

    }

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

// CRsfwDavAccess::CreateFileL

// overwriting info not needed in HTTP PUT

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

//

TUint CRsfwDavAccess::CreateFileL(const TDesC& aPathName,

                              TBool /*aOverWriting*/,

                              MRsfwRemoteAccessResponseHandler* aResponseHandler)

    {

    DEBUGSTRING16(("DAV: CreateFile '%S'", &aPathName));

    // check that arguments are sensible

    if (!aResponseHandler)

        {

        User::Leave(KErrArgument);

        }

    if ((aPathName.Length() == 0) ||

       (aPathName.Length() >  KMaxPath))

        {

        User::Leave(KErrBadName);

        }

    // Could create the file only from LOCK,

    // but that seems to cause 500 Internal Error with several

    // Apache servers...

    TPtrC null;

    return PutFileL(null, aPathName, KTextPlain, 0, NULL, 0, aResponseHandler);

    }

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

// CRsfwDavAccess::MakeDirectoryL

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

//

TUint CRsfwDavAccess::MakeDirectoryL(

    const TDesC& aPathName,

    MRsfwRemoteAccessResponseHandler* aResponseHandler)

    {

    DEBUGSTRING16(("DAV: MakeDirectory", &aPathName));

    // check that arguments are sensible

    if (!aResponseHandler)

        {

        User::Leave(KErrArgument);

        }

    if ((aPathName.Length() == 0) ||

       (aPathName.Length() >  KMaxPath))

        {

        User::Leave(KErrBadName);

        }

    CRsfwDavAccessContextMkDir* davAccessContextMkDir =

        CRsfwDavAccessContextMkDir::NewL(this,

                                     aResponseHandler,

                                     aPathName);

    TUint id = AddAccessContext(davAccessContextMkDir);

    davAccessContextMkDir->StartL();

    return id;

    }

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

// CRsfwDavAccess::DeleteDirectoryL

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

//

TUint CRsfwDavAccess::DeleteDirectoryL(

    const TDesC& aPathName,

    MRsfwRemoteAccessResponseHandler* aResponseHandler)

    {

    DEBUGSTRING16(("DAV: DeleteDirectory '%S'", &aPathName));

    // check that arguments are sensible

    if (!aResponseHandler)

        {

        User::Leave(KErrArgument);

        }

    if ((aPathName.Length() == 0) ||

       (aPathName.Length() >  KMaxPath))

        {

        User::Leave(KErrBadName);

        }

    CRsfwDavAccessContextDelete* davAccessContextDelete =

        CRsfwDavAccessContextDelete::NewL(this,

                                      aResponseHandler,

                                      aPathName,

                                      ETrue,

                                      NULL);

    TUint id = AddAccessContext(davAccessContextDelete);

    davAccessContextDelete->StartL();

    return id;

    }

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

// CRsfwDavAccess::DeleteFileL

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

//