diff -r 88ee4cf65e19 -r 1aa8c82cb4cb remotestoragefw/mountmanager/src/rsfwmountutils.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/remotestoragefw/mountmanager/src/rsfwmountutils.cpp	Wed Sep 01 12:15:08 2010 +0100
@@ -0,0 +1,381 @@
+/*
+* 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