/*

* Copyright (c) 2003-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: 	File server interface class representing an open directory.

*                The code in this class allows to access a specific 

*                remote directory.

*

*/

// INCLUDE FILES

#include "rsfwfsdircb.h"

#include "rsfwfsmountcb.h"

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

// static constructor

CRsfwFsDirCB* CRsfwFsDirCB::NewL()

    {

    CRsfwFsDirCB* remoteFsDirCB = new (ELeave) CRsfwFsDirCB;

    return remoteFsDirCB;

    }

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

// CRsfwFsDirCB::CRsfwFsDirCB

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CRsfwFsDirCB::CRsfwFsDirCB()

    {

    iHasBeenFetched = EFalse;

    iEntryPos = 0;

    iStreamPos = 0;

    }

// destructor

CRsfwFsDirCB::~CRsfwFsDirCB()

    { 

    delete iMatch;

    iDirContReadStream.Close();   

    }

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

// CRsfwFsDirCB::ReadL

// File Server calls this function to retrieve one entry from open directory 

// (next unread). When the last entry has been read, the function leaves with 

// User::Leave(KErrEof). All of the properties of a TEntry, other than the  UID 

// types, are always read.  The time stored in the iModified member of  anEntry 

// should be converted from UTC time to local time. When storing the iName 

// member of anEntry, the current (.), or parent marker (..) in the directory 

// should not be returned.

//

// If the KEntryAttAllowUid flag is set in the iAtt member of anEntry, then

// the entry UID type of an entry will be read. If, on reading the UID from

// a file, KErrCorrupt is generated, because the file is corrupt,

// ReadL() should not leave with this error message, but should return

// as normal.

//

// FILTERING:

// The function should read successive entries until a suitable entry is found.

// An entry is suitable if the entry attributes match the criteria set by this

// object's attributes, which are set on initialisation.  The File Server has 

// set CDirCB::iAtt (which we inherit) with the bitmask.

//

// The File Server opened the directory with a name mask (e.g. "*"). 

// This mask has been to stored to iMask of this class. We must only return entries, 

// whose name match this mask.

//

// If, on return, the entry's full file name, TEntry::iName, is longer than

// the maximum buffer size, then the entry cannot be returned to the client.

// In this case the file server will set iPending to true and will call

// StoreLongEntryName() before calling this function again.

// In this case (when iPending is true), the function should re-read

// the last entry to be read; it should also set iPending to false and

//  should not advance the current read position.

//

// (other items were commented in a header).

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

// 

void CRsfwFsDirCB::ReadL

(TEntry& anEntry)

    {       

    if (!iHasBeenFetched)

        {

        //   First read, the directory hasn't been fetched from the server

        //   yet (can't be done from open as that is always synchronous

        //   operation from UI's point of view)

        TInt totalBytes;

        User::LeaveIfError(static_cast<CRsfwFsMountCB&>

                (Mount()).RSessionL()->Fetch(iThisFid, 0, 0, totalBytes));

        iHasBeenFetched = ETrue;

        }

    TEntry entry;

    if (iPending) 

        {

        iStreamPos = iPendingPos;

        iPending = EFalse; 

        }

    MStreamBuf* contFileStreamBuf = iDirContReadStream.Source();

    // Skip over entries already read

    contFileStreamBuf->SeekL(MStreamBuf::ERead, iStreamPos);

    TDirEnt d;

    do

        {

        TInt strippedBits = 0;

        TBool matchName = EFalse;

   		TBool matchAttr = EFalse;

        iPendingPos = iStreamPos;

        // Each round must fill one TEntry (or leave with KErrEof)

        d.InternalizeL(iDirContReadStream); // leaves with KErrEof

        iEntryPos++;

        entry.iName.Des().Copy(d.iName);

        entry.iAtt = d.iAttr.iAtt;

        entry.iSize = d.iAttr.iSize;

        entry.iModified = d.iAttr.iModified;

        entry.iType = (KNullUid, KNullUid, d.iAttr.iUid3);

        // do not set KEntryAttRemote for directories

        // it is defined by Symbian to be a file attribute only

        // remote file engine uses it internally for dirs also

        if (entry.iAtt & KEntryAttDir) 

            {

            entry.iAtt &= ~KEntryAttRemote;

            }

        // Filtering:

        // compare name against the match pattern

        matchName = (entry.iName.Match(*iMatch) != KErrNotFound);

        // compare against iAtt attribute mask

        // The mask works as follows: 

        // To match files only, specify KEntryAttNormal. 

        // To match both files and directories, specify KEntryAttDir. 

        // To match directories only, specify KEntryAttDir|KEntryAttMatchExclusive. 

        // To match files with a specific attribute, then OR the attribute involved with KEntryAttMatchExclusive. 

        // For example, to match read-only files, specify KEntryAttReadOnly|KEntryAttMatchExclusive. 

        if (iAtt & KEntryAttMatchExclusive)

        	{ // files with a specific attribute only

        	matchAttr = iAtt & entry.iAtt; 

        	}

        else 

        	{

        	if (iAtt & KEntryAttDir)

       			{

       			// both files and directories

       			matchAttr = ETrue;

       			}

       		else 

       			{

       			// files only

       			if (!(entry.iAtt & KEntryAttDir)) 

       				{

       				matchAttr = ETrue;

       				}

       			}

        	}     	

        if (matchName && matchAttr)

            {

            // "reverse" bits modified to make comparison easier

            entry.iAtt |= strippedBits;

            entry.iAtt &= ~KEntryAttMatchExclusive; 

            anEntry = entry;

            break;

            }

        }

    while (1);

    iStreamPos = contFileStreamBuf->TellL(MStreamBuf::ERead);

    }

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

// CRsfwFsDirCB::SetDirL

// Opens read stream in the container file. Called in CRsfwFsMountCB when the 

// directory is opened.

// Implementation notice: As this class only reads the container file, it would

// seem sensible to open  EFileRead|EFileShareAny here, but when Remote 

// File Engine then tries to open EFileWrite|EFileShareAny it fails unless

// EFileWrite is specified here also...

//

// (other items were commented in a header).

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

//

void CRsfwFsDirCB::SetDirL(

    const TDesC& aPath, 

    const TDesC& aName)

    {

    User::LeaveIfError(iDirContReadStream.Open(*(RFs* )Dll::Tls(),

                                               aPath, EFileWrite | EFileShareAny));

    iMatch = aName.AllocL();

    }

// End of File