/*
* 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:  Mount configuration entry
 *
*/


// INCLUDE FILES
#include <uri16.h>
#include <rsfwmountentry.h>
#include "rsfwmountutils.h"

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

// ----------------------------------------------------------------------------
// CRsfwMountEntry::NewLC
// ----------------------------------------------------------------------------
//
EXPORT_C CRsfwMountEntry* CRsfwMountEntry::NewLC()
    {
    CRsfwMountEntry* self = new (ELeave) CRsfwMountEntry();
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

// ----------------------------------------------------------------------------
// CRsfwMountEntry::NewL
// ----------------------------------------------------------------------------
//
EXPORT_C CRsfwMountEntry* CRsfwMountEntry::NewL()
    {
    CRsfwMountEntry* self = NewLC();
    CleanupStack::Pop(self);
    return self;
    }

// ----------------------------------------------------------------------------
// CRsfwMountEntry::CRsfwMountEntry
// ----------------------------------------------------------------------------
//
CRsfwMountEntry::CRsfwMountEntry()
    {
    }

// ----------------------------------------------------------------------------
// CRsfwMountEntry::~CRsfwMountEntry
// ----------------------------------------------------------------------------
//
EXPORT_C CRsfwMountEntry::~CRsfwMountEntry()
    {
    Clear();
    iFs.Close();
    }

// ----------------------------------------------------------------------------
// CRsfwMountEntry::SetItemL
// ----------------------------------------------------------------------------
//
EXPORT_C void CRsfwMountEntry::SetItemL(TInt aIndex, const TDesC& aValue)
    {
    TChar driveChar;
     
    if ((aIndex < EMountEntryItemIndex) || (aIndex >= EMountEntryItemCount))
        {
        User::Leave(KErrArgument);
        }

    switch (aIndex) 
        {
        case EMountEntryItemName:
            if (aValue.Length() > KMaxMountNameLength) 
                {
                User::Leave(KErrArgument);
                }      
            // name must not contain chars not allowed in Symbian file names
            // as the name will be stored as drive friendly name
            // (rules for allowed chars are the same)
            if (!(RsfwMountUtils::IsFriendlyNameValid(aValue))) 
                {
                User::Leave(KErrArgument);
                }
            break;
        case EMountEntryItemUri:
            if (aValue.Length() > KMaxMountUriLength)
                {
                User::Leave(KErrArgument);
                }
            break;
        case EMountEntryItemUserName:
            if (aValue.Length() > KMaxMountUserNameLength)
                {
                User::Leave(KErrArgument);
                }
            break;   
        case EMountEntryItemPassword:
             if (aValue.Length() > KMaxMountPasswordLength)
                {
                User::Leave(KErrArgument);
                } 
            break;
        case EMountEntryItemDrive:
            // remote drives can take drive letters from  J through Y
            // (see documentation for RFs::DriveList())
            driveChar = aValue[0];
            TInt driveNumber;
            User::LeaveIfError(iFs.CharToDrive(driveChar, driveNumber));
            if (!((driveNumber >= EDriveJ) && (driveNumber < EDriveZ)))
                {
                User::Leave(KErrArgument);
                }
            break;
        default:
            // check that the value is not too long
            if (aValue.Length() > KMaxMountConfItemLength) 
                {
                User::Leave(KErrArgument);
                }
            break;            
        }
        
    HBufC*& p = iMountEntryItems[aIndex];
    if (p)
        {
        delete p;
        p = NULL;
        }
    p = aValue.AllocL();
    }

// ----------------------------------------------------------------------------
// CRsfwMountEntry::SetItemL
// ----------------------------------------------------------------------------
//
EXPORT_C void CRsfwMountEntry::SetItemL(TInt aIndex, const TDesC8& aValue)
    {
    HBufC* p = HBufC::NewLC(aValue.Length());
    TPtr pPtr = p->Des();
    pPtr.Copy(aValue);
    SetItemL(aIndex, pPtr);
    CleanupStack::PopAndDestroy(p);
    }

// ----------------------------------------------------------------------------
// CRsfwMountEntry::SetEntryL
// ----------------------------------------------------------------------------
//
EXPORT_C void CRsfwMountEntry::SetEntryL(TInt aIndex,
                                     const TDesC& aName,
                                     TChar aDriveLetter,
                                     const TDesC& aUri,
                                     const TDesC& aUserName,
                                     const TDesC& aPassword,
                                     const TDesC& aIap)
    {
    TBuf<KIndexAsStringLength> index;
    index.Num(aIndex);
    SetItemL(EMountEntryItemIndex, index);
    SetItemL(EMountEntryItemName, aName);
    TBuf<KIndexAsStringLength> drive;
    drive.Append(aDriveLetter);
    SetItemL(EMountEntryItemDrive, drive);
    SetItemL(EMountEntryItemUri, aUri);
    SetItemL(EMountEntryItemUserName, aUserName);
    SetItemL(EMountEntryItemPassword, aPassword);
    SetItemL(EMountEntryItemIap, aIap);
    }

// ----------------------------------------------------------------------------
// CRsfwMountEntry::Item
// ----------------------------------------------------------------------------
//
EXPORT_C const HBufC* CRsfwMountEntry::Item(TInt aIndex) const
    {
    if ((aIndex >= EMountEntryItemIndex) && (aIndex < EMountEntryItemCount))
        {
        return iMountEntryItems[aIndex];
        }
    return NULL;
    }

// ----------------------------------------------------------------------------
// CRsfwMountEntry::Clear
// ----------------------------------------------------------------------------
//
EXPORT_C void CRsfwMountEntry::Clear()
    {
    TInt i;
    for (i = EMountEntryItemIndex;  i < EMountEntryItemCount;  i++)
        {
        if (iMountEntryItems[i])
            {
            delete iMountEntryItems[i];
            iMountEntryItems[i] = NULL;
            }
        }
    }

// ----------------------------------------------------------------------------
// CRsfwMountEntry::CloneL
// ----------------------------------------------------------------------------
//
EXPORT_C CRsfwMountEntry* CRsfwMountEntry::CloneL() const
    {
    CRsfwMountEntry* entry = CRsfwMountEntry::NewLC();
    TInt i;
    for (i = EMountEntryItemIndex;  i < EMountEntryItemCount;  i++)
        {
        HBufC* item = iMountEntryItems[i];
        if (item)
            {
            entry->iMountEntryItems[i] = (*item).AllocL();
            }
        }
    CleanupStack::Pop(entry);
    return entry;
    }

// ----------------------------------------------------------------------------
// CRsfwMountEntry::ConstructL
// ----------------------------------------------------------------------------
//
void CRsfwMountEntry::ConstructL()
    {
    User::LeaveIfError(iFs.Connect());
    }

//  End of File