diff -r 000000000000 -r a41df078684a userlibandfileserver/fatfilenameconversionplugins/src/unicodeconv.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/userlibandfileserver/fatfilenameconversionplugins/src/unicodeconv.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,202 @@
+// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "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:
+//
+
+#include <e32std.h>
+#include <e32def.h>
+#include <e32des8.h> 
+#include "unicodeconv.h"
+
+//replacement character to be used when unicode cannot be converted
+const TUint8 KForeignReplacement = 0x5F;
+
+//This function converts from Unicoded characters, to foreign characters and adds them into a descriptor
+EXPORT_C void UnicodeConv::ConvertFromUnicodeL(TDes8& aForeign, const TDesC16& aUnicode)
+    {
+    UnicodeConv::ConvertFromUnicodeL(aForeign, aUnicode, ETrue);
+    }
+
+//This function converts from Unicoded characters, to foreign characters and adds them into a descriptor
+EXPORT_C TInt UnicodeConv::ConvertFromUnicodeL(TDes8& aForeign, const TDesC16& aUnicode, TBool leaveWhenOverflow)
+	{
+	const TInt unicodeLength = aUnicode.Length();
+	
+	//loop going through the character of the unicode descriptor
+	for(TInt i=0; i<unicodeLength; i++)
+		{
+		const TUint16 unicodeChar = aUnicode[i];
+		
+		// if the output buffer is already full, leave with KErrOverflow
+		if ( aForeign.Length() >= aForeign.MaxLength() )
+		    {
+		    if (leaveWhenOverflow)
+		        User::Leave(KErrOverflow);
+		    else
+		        return KErrOverflow;
+		    }			
+
+		//charcters from 0x0000 to 0x007F, can be mapped directly
+		if(unicodeChar<0x0080)
+			{
+			aForeign.Append(static_cast<TUint8>(unicodeChar));
+			}
+		else
+			{
+			TInt trailByte = KErrNotFound;
+			TInt returnValue = TConvDataStruct::ConvertSingleUnicode(unicodeChar,trailByte);
+			
+			if(returnValue!=KErrNotFound)
+				{
+				if(trailByte!=KErrNotFound)		
+					{					
+					// as two bytes are being added check enough space for second
+					if ( aForeign.Length() + 2 <= aForeign.MaxLength() )
+					    {
+					    aForeign.Append(static_cast<TUint8>(returnValue));
+					    aForeign.Append(static_cast<TUint8>(trailByte));
+					    }
+					else
+					    {
+			            if (leaveWhenOverflow)
+			                User::Leave(KErrOverflow);
+			            else
+			                return KErrOverflow;
+					    }					
+					}
+				else
+					aForeign.Append(static_cast<TUint8>(returnValue));
+				}		
+			else
+				aForeign.Append(KForeignReplacement);
+			}
+		}
+	
+	return KErrNone;
+	}
+				
+//This function converts from foreign characters into unicode and adds them into a descriptor
+EXPORT_C void UnicodeConv::ConvertToUnicodeL(TDes16& aUnicode, const TDesC8& aForeign)
+    {
+    UnicodeConv::ConvertToUnicodeL(aUnicode, aForeign, ETrue);
+    }
+
+//This function converts from foreign characters into unicode and adds them into a descriptor
+EXPORT_C TInt UnicodeConv::ConvertToUnicodeL(TDes16& aUnicode, const TDesC8& aForeign, TBool leaveWhenOverflow)
+	{
+	const TInt foreignLength = aForeign.Length();
+
+	//loop going through the characters of the foreign descriptor
+	for(TInt i = 0; i<foreignLength; i++)
+		{
+		const TUint8 leadForeign = aForeign[i];
+		TUint8 tailForeign = 0x00;
+
+		// Check there is enough space in the output buffer, and leave with KErrOverflow if not
+		if ( aUnicode.Length() == aUnicode.MaxLength() )
+            {
+            if (leaveWhenOverflow)
+                User::Leave(KErrOverflow);
+            else
+                return KErrOverflow;
+            }
+
+		//charcters from 0x00 to 0x7F, can be mapped directly
+		if(leadForeign < 0x80)
+			aUnicode.Append(static_cast<TUint16>(leadForeign));
+		else
+			{
+			if((i+1)<foreignLength)
+				tailForeign = aForeign[i+1];
+
+			const TLeadOrSingle* structPtr = TConvDataStruct::KFirstByteConversions + (leadForeign-0x80);
+			
+			if(structPtr->iUnicodeIfSingle)
+				aUnicode.Append(structPtr->iUnicodeIfSingle);
+			else
+				{
+				if(TConvDataStruct::KMinTrailByte<=tailForeign && tailForeign<=TConvDataStruct::KMaxTrailByte)
+					aUnicode.Append(TConvDataStruct::KDoubleByteConversions[structPtr->iDoubleByteIndex+
+						(tailForeign - TConvDataStruct::KMinTrailByte)]);
+				else
+					aUnicode.Append(0xFFFD);
+				i++;
+				}
+			}
+		}
+
+	return KErrNone;
+	}
+
+EXPORT_C TBool UnicodeConv::IsLegalShortNameCharacter (TUint aCharacter)
+	{
+	//1. aCharacter >= 0x0080 
+	if (aCharacter>=0x0080)
+		{
+		if (aCharacter>0xFFFF)
+			return EFalse;
+		
+		TInt trailByte = KErrNotFound;
+		TInt returnValue = TConvDataStruct::ConvertSingleUnicode(aCharacter,trailByte);
+		
+		if(returnValue!=KErrNotFound)
+			return ETrue;
+		else
+			return EFalse;
+		}
+	
+    // For most common cases: 
+    // Note: lower case characters are considered legal DOS char here. 
+	if ((aCharacter>='a' && aCharacter<='z') || 
+	    (aCharacter>='A' && aCharacter<='Z') || 
+	    (aCharacter>='0' && aCharacter<='9'))
+			{
+			return ETrue;
+			}
+    // Checking for illegal chars: 
+    // 2. aCharacter <= 0x20 
+    // Note: leading 0x05 byte should be guarded by callers of this function 
+    //  as the information of the position of the character is required. 
+	if (aCharacter < 0x20)
+		return EFalse;
+	// Space (' ') is not considered as a legal DOS char here.
+	if (aCharacter == 0x20)
+		return EFalse;
+	
+	// 3. 0x20 < aCharacter < 0x80 
+    // According to FAT Spec, "following characters are not legal in any bytes of DIR_Name": 
+    switch (aCharacter) 
+            { 
+            case 0x22:        // '"' 
+            case 0x2A:        // '*' 
+            case 0x2B:        // '+' 
+            case 0x2C:        // ',' 
+            //case 0x2E:        // '.'   // Although '.' is not allowed in any bytes of DIR_Name, it 
+                                         // is a valid character in short file names. 
+            case 0x2F:        // '/' 
+            case 0x3A:        // ':' 
+            case 0x3B:        // ';' 
+            case 0x3C:        // '<' 
+            case 0x3D:        // '=' 
+            case 0x3E:        // '>' 
+            case 0x3F:        // '?' 
+            case 0x5B:        // '[' 
+            case 0x5C:        // '\' 
+            case 0x5D:        // ']' 
+            case 0x7C:        // '|' 
+            	return EFalse; 
+            default: 
+            	return ETrue; 
+            } 
+	}		
+