/*

* 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:  State machine for creating files

*

*/

#include "rsfwcreatefilestatemachine.h"

#include "rsfwfileentry.h"

#include "rsfwfiletable.h"

#include "rsfwinterface.h"

#include "rsfwfileengine.h"

#include "rsfwlockmanager.h"

#include "mdebug.h"

#include "rsfwdirentattr.h"

#include "rsfwvolumetable.h"

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

// CRsfwCreateFileStateMachine::CRsfwCreateFileStateMachine

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

//

CRsfwCreateFileStateMachine::CRsfwCreateFileStateMachine()

    {

    }

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

// CRsfwCreateFileStateMachine::~CRsfwCreateFileStateMachine

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

//

CRsfwCreateFileStateMachine::~CRsfwCreateFileStateMachine()

    {

    delete iDirEntAttr;

    delete iLockToken;

    }

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

// CRsfwCreateFileStateMachine::CompleteRequestL

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

//

CRsfwRfeStateMachine::TState*

CRsfwCreateFileStateMachine::CompleteRequestL(TInt aError)

    {

    TRfeCreateOutArgs* outArgs =

        static_cast<TRfeCreateOutArgs*>(iOutArgs);

    if (!aError)

        { 

        // Set the return values for the create call

        TFid* kidFidp = &(outArgs->iFid);

        TDirEntAttr* oAttrp = &(outArgs->iAttr);

        *kidFidp = iKidFep->Fid();

        iKidFep->GetAttributes(*oAttrp);

        }

    if (iKidCreated && aError)

        {

        delete iKidFep;

        iKidFep = NULL;

        }

    // it may happen by chance that the new name is equal to iLastFailedLookup value

    FileEngine()->ResetFailedLookup();

    CompleteAndDestroyState()->SetErrorCode(aError);

    return CompleteAndDestroyState();

    }

// Check if exists

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

// CRsfwCreateFileStateMachine::TCheckIfExistsState::TCheckIfExistsState

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

//

CRsfwCreateFileStateMachine::

TCheckIfExistsState::TCheckIfExistsState(CRsfwCreateFileStateMachine* aParent)

    : iOperation(aParent)

    {

    }

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

// CRsfwCreateFileStateMachine::TCheckIfExistsState::EnterL

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

//

void CRsfwCreateFileStateMachine::TCheckIfExistsState::EnterL()

    {

    DEBUGSTRING(("CRsfwCreateFileStateMachine::TCheckIfExistsState::EnterL()"));

    TRfeCreateInArgs* inArgs =

        static_cast<TRfeCreateInArgs*>(iOperation->iInArgs);

    TPtrC kidName(inArgs->iEntry.iName);

    iExclp = inArgs->iExcl;

    // used to pass the file open mode

    // could be something simpler, e.g. only one int

    iOperation->iFlags = inArgs->iEntry.iAttr.iAtt;

    // Get the parent to which we are creating this

    if (!iOperation->Node())

        {

        User::Leave(KErrNotFound);

        }

    DEBUGSTRING16(("creating file '%S' in fid %d",

                   &kidName,

                   iOperation->Node()->Fid().iNodeId));

    // Do we know about the kid yet?

    iOperation->iKidFep = iOperation->Node()->FindKidByName(kidName);

    if (!iOperation->iKidFep)

        {

        // This is either a completely new file, or a file that we

        // have not yet created a file entry for.

        if (! iOperation->Volumes()->EnsureMetadataCanBeAddedL(iOperation->Node()))

            {

            User::Leave(KErrNoMemory);

            }

        iOperation->iKidFep = CRsfwFileEntry::NewL(kidName, iOperation->Node());

        iOperation->iKidCreated = ETrue;

        iOperation->iKidFep->SetNewlyCreated();

        }

    if (iOperation->FileEngine()->Disconnected())

        {

        if (iOperation->iKidFep->Type() != KNodeTypeUnknown)

            {

            // "file exists"

            iOperation->HandleRemoteAccessResponse(0, KErrNone);

            }

        else

            {

            iOperation->HandleRemoteAccessResponse(0, KErrNotFound);

            }

        }

    else

        {

        iOperation->FileEngine()->GetAttributesL(*iOperation->iKidFep,

                                                 iOperation->iDirEntAttr,

                                                 KNodeTypeFile,

                                                 iOperation);

        }

    }

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

// CRsfwCreateFileStateMachine::TCheckIfExistsState::CompleteL

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

//

CRsfwCreateFileStateMachine::TState*

CRsfwCreateFileStateMachine::TCheckIfExistsState::CompleteL()

    {

    DEBUGSTRING(("CRsfwCreateFileStateMachine::TCheckIfExistsState::CompleteL()"));

    if (iExclp)

        {

        DEBUGSTRING(("kid exists!"));

        return iOperation->CompleteRequestL(KErrAlreadyExists);

        }

    else

        { // file with the same name exists, but exclusive is false

        return new CRsfwCreateFileStateMachine::TCreateNodeState(iOperation); 

        }

    }

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

// CRsfwCreateFileStateMachine::TCheckIfExistsState::ErrorL

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

//

CRsfwCreateFileStateMachine::TState*

CRsfwCreateFileStateMachine::TCheckIfExistsState::ErrorL(TInt aCode)

    {

    DEBUGSTRING16(("CRsfwCreateFileStateMachine::TCheckIfExistsState::ErrorL error=%d", aCode));

   	return new CRsfwCreateFileStateMachine::TCreateNodeState(iOperation); 

    }

// create node

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

// CRsfwCreateFileStateMachine::TCreateNodeState::TCreateNodeState

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

//

CRsfwCreateFileStateMachine::

TCreateNodeState::TCreateNodeState(CRsfwCreateFileStateMachine* aParent)

    : iOperation(aParent)

    {

    }

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

// CRsfwCreateFileStateMachine::TCreateNodeState::EnterL

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

//

void CRsfwCreateFileStateMachine::TCreateNodeState::EnterL()

    {

    DEBUGSTRING(("CRsfwCreateFileStateMachine::TCreateNodeState::EnterL()"));

    if (iOperation->iKidCreated)

        {

        iOperation->iKidFep->SetType(KNodeTypeFile);

        }

    if (!iOperation->FileEngine()->WriteDisconnected())

        {

        // Create the file

        HBufC16* kidPath =

            iOperation->FileEngine()->FullNameLC(*iOperation->iKidFep);

        // iDirEntAttr exists, we know we are overwriting

        // pass this info to the access module (needed e.g. by UPnP)

        iOperation->

            FileEngine()->

            RemoteAccessL()->CreateFileL(*kidPath,

                                         (iOperation->iDirEntAttr != NULL),

                                         iOperation);

        CleanupStack::PopAndDestroy(kidPath);

        }

    }

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

// CRsfwCreateFileStateMachine::TCreateNodeState::CompleteL

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

//

CRsfwCreateFileStateMachine::TState*

CRsfwCreateFileStateMachine::TCreateNodeState::CompleteL()

    {

    DEBUGSTRING(("CRsfwCreateFileStateMachine::TCreateNodeState::CompleteL()"));

    return new CRsfwCreateFileStateMachine::TAcquireLockState(iOperation);

    }

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

// CRsfwCreateFileStateMachine::TCreateNodeState::ErrorL

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

//

CRsfwCreateFileStateMachine::TState*

CRsfwCreateFileStateMachine::TCreateNodeState::ErrorL(TInt aCode)

    {

    DEBUGSTRING16(("CRsfwCreateFileStateMachine::TCreateNodeState::ErrorL error=%d", aCode));

    DEBUGSTRING(("remote create failed!"));

    return iOperation->CompleteRequestL(aCode);

    }

// Acquire lock

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

// CRsfwCreateFileStateMachine::TAcquireLockState::TAcquireLockState

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

//

CRsfwCreateFileStateMachine::

TAcquireLockState::TAcquireLockState(CRsfwCreateFileStateMachine* aParent)

    {

    iOperation = aParent;

    iRequestedLock = EFalse;

    }

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

// CRsfwCreateFileStateMachine::TAcquireLockState::EnterL

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

//

void CRsfwCreateFileStateMachine::TAcquireLockState::EnterL()

    {

    DEBUGSTRING(("CRsfwCreateFileStateMachine::TAcquireLockState::EnterL()"));

    if (!iOperation->FileEngine()->WriteDisconnected())

        {

        // There are two state machines currently,

        // which may take a lock for a file based on the mode,

        // OpenByPath and this.

        // Currently the mode check is different which is not a good

        // thing, there is a clear risk of an error where they

        // acquire a lock in different situations.

        if (!iOperation->iKidFep->IsLocked()

            && iOperation->iFlags != KEntryAttReadOnly)

            {

            iOperation->FileEngine()->LockManager()->

                ObtainLockL(iOperation->iKidFep,

                            EFileWrite,

                            iOperation->iLockToken,

                            iOperation);

            iRequestedLock = ETrue;

            }

        else

            {

            iOperation->HandleRemoteAccessResponse(0, KErrNone);

            }

        }

    else

        {

        iOperation->HandleRemoteAccessResponse(0, KErrNone);

        }

    }

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

// CRsfwCreateFileStateMachine::TAcquireLockState::CompleteL

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

//

CRsfwCreateFileStateMachine::TState*

CRsfwCreateFileStateMachine::TAcquireLockState::CompleteL()

    {

    DEBUGSTRING(("CRsfwCreateFileStateMachine::TAcquireLockState::CompleteL()"));

    if (iRequestedLock)

        {

        iOperation->iKidFep->

            SetLockedL(iOperation->FileEngine()->LockManager(),

                       iOperation->iLockToken);

        iOperation->iLockToken = NULL;

        }

    // Note that the kid has to be attached to the file table

    // to get a NodeId before the cache file is created.

    if (iOperation->iKidCreated)

        {

        // Attach a new kid to its parent

        iOperation->FileEngine()->iFileTable->AddL(iOperation->iKidFep);

        iOperation->Node()->AddKid(*iOperation->iKidFep);

        }

    // Create an empty container file locally

    iOperation->FileEngine()->CreateContainerFileL(*iOperation->iKidFep);

    iOperation->iKidFep->SetSize(0);

    iOperation->iKidFep->SetCachedSize(0);

    iOperation->iKidFep->SetCached(ETrue);

    iOperation->iKidFep->SetAttribValidationTime();

    iOperation->FileEngine()->SetupAttributes(*iOperation->iKidFep);

    iOperation->Node()->SetLocallyDirty();

    return iOperation->CompleteRequestL(KErrNone);

    }

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

// CRsfwCreateFileStateMachine::TAcquireLockState::ErrorL

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

//

CRsfwCreateFileStateMachine::TState*

CRsfwCreateFileStateMachine::TAcquireLockState::ErrorL(TInt aCode)

    {

    DEBUGSTRING16(("CRsfwCreateFileStateMachine::TAcquireLockState::ErrorL error=%d", aCode));

    if (aCode == KErrNotSupported)

        {

        iRequestedLock = EFalse;

        return this->CompleteL();

        }

    else

        {

        return iOperation->CompleteRequestL(aCode);

        }

    }