/*

* Copyright (c) 2009 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:  Utility functions for managing mount configurations

*

*/

// INCLUDES

#include <s32file.h>

#include <uri8.h>

#include <utf.h>

#include <ecom/ecom.h>

#include <ecom/implementationinformation.h>

#include <rsfwmountentry.h>

#include "rsfwmountutils.h"

#include "rsfwremoteaccess.h"

// CONSTANTS

// These keywords must match with the entry items

_LIT(KKId, "Fname");

_LIT(KKDrive, "Fdrv");

_LIT(KKUri, "Furi");

_LIT(KKUserName, "Fuid");

_LIT(KKPassword, "Fpsw");

_LIT(KMountMessagePrefix, "//vnd.nokia.s60.mount.config\n");

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

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

// RsfwMountUtils::ImportMountEntryL

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

//

EXPORT_C void RsfwMountUtils::ImportMountEntryL(const TDesC& aMsg,

                                            CRsfwMountEntry** aEntry)

    {

    // Expected to start with

    // //vnd.nokia.s60.mount.config\n

    TPtrC prefix = aMsg.Left(KMountMessagePrefixLength);

    if (prefix.Compare(KMountMessagePrefix) != 0)

        {

        User::Leave(KErrNotFound);

        }

    // It is a mount configuration message

    CRsfwMountEntry* entry = CRsfwMountEntry::NewLC();

    TInt lineNumber = 0;

    // SMS rich text messages may be have trailing characters -

    // that looks like ')' characters

    TInt i = aMsg.Length() - 1;

    while (i > 0)

        {

        TUint8 c = static_cast<TUint8>(aMsg[i]);

        if (c != ')')

            {

            break;

            }

        i--;

        }

    TPtrC msg  = aMsg.Left(i + 1);

    TLex lex(msg);

    while (!lex.Eos())

        {

        lineNumber++;

        lex.SkipSpaceAndMark();

        while (lex.Peek() != '\n'  && !lex.Eos())

            {

            lex.Inc();

            }

        // The marked token is now the whole line

        TPtrC line = lex.MarkedToken();

        ParseLineL(line, *entry);

        if (!lex.Eos())

            {

            // Skip the '\n'

            lex.Inc();

            }

        }

    CleanupStack::Pop(entry);

    *aEntry = entry;

    }

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

// RsfwMountUtils::ImportMountEntryFromStreamL

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

//

EXPORT_C void RsfwMountUtils::ImportMountEntryFromStreamL(RReadStream& aReadStream,

													      TInt aSize,

                                                          CRsfwMountEntry** aEntry)

    {

    // the string is assumed to be 8-bit in stream, 

    // and should be converted to Unicode

    *aEntry = NULL;

    HBufC8* tempbuf = HBufC8::NewLC(aSize);

    TPtr8 tbufPtr = tempbuf->Des();

    tbufPtr.Zero();

    TRAPD(err, aReadStream.ReadL(tbufPtr));

    HBufC* buf = HBufC::NewLC(aSize);

    TPtr bufPtr = buf->Des();

    CnvUtfConverter::ConvertToUnicodeFromUtf8(bufPtr, tbufPtr);

    if ((err == KErrNone) || (err == KErrEof))

        {

        ImportMountEntryL(bufPtr, aEntry);

        }

    CleanupStack::PopAndDestroy(2, tempbuf); // buf, tempbuf 

    }

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

// RsfwMountUtils::ExportMountEntryL

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

//

EXPORT_C void RsfwMountUtils::ExportMountEntryL(const CRsfwMountEntry& aEntry,

                                                TBool aSendCredentials,

                                                TDes& aBuf)

    {

    aBuf.Copy(KMountMessagePrefix);

    TInt i;

    // smart messaging sends:

    // EMountEntryItemName

    // EMountEntryItemUri

    // if aSendCredentials sends also:

    // EMountEntryItemUserName

    // EMountEntryItemPassword 

    TInt lastToExport;

    if (aSendCredentials) 

        {

        lastToExport = EMountEntryItemPassword; 

        }

    else 

        {

        lastToExport = EMountEntryItemUri;

        }

    for (i = EMountEntryItemName; i < lastToExport + 1; i++)

        {

        if (i != EMountEntryItemDrive) 

        	{

        	const HBufC* item = aEntry.Item(i);

        	if (item && item->Length())

            	{

            	aBuf.Append(GetKeyWord(i));

            	aBuf.Append(':');

                const TPtrC ip(*item);

                aBuf.Append(ip);

            	aBuf.Append('\n');

            	}        	

        	}

       }

    }

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

// RsfwMountUtils::IsFriendlyNameValid

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

//

EXPORT_C TBool RsfwMountUtils::IsFriendlyNameValid(const TDesC& aFriendlyName)

    {

    TInt err;

    TBool retValue = ETrue;

    RFs fsSession;

    err = fsSession.Connect();

    if (err)

        {

        return retValue;

        }    

    retValue = fsSession.IsValidName(aFriendlyName);

    fsSession.Close();  

    // Some names are acceptable by RFs.IsValidName(), 

    // but not acceptable by RFs.SetDriveName()

    // Those are checked below:

    // solely period characters ( e.g. "...")

    if (retValue)

        {

        retValue = EFalse;

        TChar period(46); // period (".") character

        TInt i;

        for (i = 0; i < aFriendlyName.Length(); i++)

            {   

            if (aFriendlyName[i] != period)

                {

                retValue = ETrue;

                break;

                }

            }

        }

    // period as the last character ( e.g. "myDrive.")

    if (retValue)

        {

        TChar period(46); // period (".") character

        TInt nameLength = aFriendlyName.Length();

        if (nameLength > 0 && aFriendlyName[nameLength-1] == period)

            {

            retValue = EFalse;

            }

        }    

    return retValue;    

    }

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

// RsfwMountUtils::IsDriveAddressValid

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

//

EXPORT_C TBool RsfwMountUtils::IsDriveAddressValid(const TDesC8& aDriveAddress)

    {

    // extract the protocol

    TInt err;

    TUriParser8 parser;

    err = parser.Parse(aDriveAddress);

    if (err) 

    		{

    		return EFalse;	

    		}

    TPtrC8 protocol = parser.Extract(EUriScheme);

    TBuf8<KMaxMatchStringSize> matchString;

    _LIT8(KRemoteMatchPrefix, "remoteaccess/");

    matchString.Copy(KRemoteMatchPrefix);

    // Both "http" and "https" are handled by davaccess module

    _LIT8(KHttps, "https"); 

    if (protocol.Compare(KHttps) == 0)

        {

        _LIT8(KHttp, "http");   

        matchString.Append(KHttp);

        }

    else

        {

        matchString.Append(protocol);

        }

    TEComResolverParams resolverParams;

    resolverParams.SetDataType(matchString);

    // Disable wildcard matching

    resolverParams.SetWildcardMatch(EFalse);    

    // check whether there is a remote access plugin implementation for that protocol 

    RImplInfoPtrArray implinfo;

    TRAP(err, REComSession::ListImplementationsL(

                             KCRemoteAccessUid,

                             resolverParams,

                             implinfo));

    if (err != KErrNone) 

        {

        // if fetching the list of implemenations fail,'

        // (for example a temporary out of memory situation)

        // just accept the string

		implinfo.ResetAndDestroy();

        return ETrue;

        }

    // we assume that protocol used for remote access

    //  represents hierarchical relationships within the namespace.  This

    // "generic URI" syntax consists of a sequence of four main components:

    //      <scheme>://<authority><path>?<query>

    // check that scheme is followed by "://"

    _LIT8(KDelimiter, "://");

    if (aDriveAddress.Length() < protocol.Length()+3) 

        {

		implinfo.ResetAndDestroy();

        return EFalse;

        }

    TPtrC8 test = aDriveAddress.Mid(protocol.Length(), 3);

    if (!(test.Compare(KDelimiter) == 0)) 

        {

		implinfo.ResetAndDestroy();

        return EFalse;    

        }

    TInt count = implinfo.Count();

    implinfo.ResetAndDestroy();

    if (count > 0) 

        {

        return ETrue;

        }

    else 

        {

        return EFalse;

        }

    }

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

// RsfwMountUtils::ParseLineL

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

//

void RsfwMountUtils::ParseLineL(const TDesC& aLine,

                                CRsfwMountEntry& aEntry)

    {

    TLex lex(aLine);

    // Extract Line i.e "leftToken:RightToken<LF>", then asign to TLex object

    while (lex.Peek() != ':' && lex.Peek() != '\n' && !lex.Eos())

        {

        lex.Inc();

        }

    // We are only interested in lines containing a colon delimeter ':'

    // other text lines are ignored i.e "Welcome !<LF>"

    if(lex.Peek() != ':')

        {

        // It was not a name value pair

        return;

        }

    if (lex.TokenLength() == 0)

        {

        User::Leave(KErrNotFound);

        }

    // Get the keyword

    HBufC* keyWord = lex.MarkedToken().AllocLC();

    // Go past the ':'

    lex.Inc();

    lex.SkipSpaceAndMark();

    while (lex.Peek() != '\n' && lex.Peek() != '\r' && !lex.Eos())

        {

        lex.Inc();

        }

    TInt i;

    // Keyword matching

    // password is the last possible entry that is transferred

    for (i = EMountEntryItemName; i < EMountEntryItemPassword + 1; i++)

        {

        if (GetKeyWord(i).Compare(*keyWord) == 0)

            {

            aEntry.SetItemL(i, lex.MarkedToken());

            }

        }

    CleanupStack::PopAndDestroy(keyWord);

    }

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

// RsfwMountUtils::GetKeyWord

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

//

const TDesC& RsfwMountUtils::GetKeyWord(TInt iItem)

    {

    switch (iItem)

        {

    case EMountEntryItemName:

        return KKId;

    case EMountEntryItemDrive:

        return KKDrive;

    case EMountEntryItemUri:

        return KKUri;

    case EMountEntryItemUserName:

        return KKUserName;

    case EMountEntryItemPassword:

        return KKPassword;

    default:

        return KKId;

        }

    }

// End of File