--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/secureswitools/swisistools/source/interpretsislib/utils_win32.cpp	Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,343 @@
+/*
+* 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: 
+*
+*/
+
+
+
+#define WIN32_LEAN_AND_MEAN 1
+
+#ifdef _MSC_VER
+#pragma warning (disable: 4786)
+#endif // _MSC_VER
+
+#include <windows.h>
+#include <fstream>
+#include <stdio.h>
+#include <io.h>
+#include <fcntl.h>
+#include <iostream>
+#include <sstream>
+#include <sys/stat.h>
+
+#include "logger.h"
+#include "stringutils.h"
+#include "is_utils.h"
+
+
+int GetStat(const std::wstring& aFile, struct stat* s)
+{
+	return _wstat(aFile.c_str(), reinterpret_cast<struct _stat*>(s));
+}
+
+bool IsDirectory(std::wstring& aStr)
+{
+    bool ret = false;
+    //
+    if ( aStr.length() > 0 )
+        {
+	    struct stat x;
+        //
+	    int err = GetStat(aStr,&x );
+        //
+        if ( err != 0 )
+            {
+            wchar_t lastChar = aStr[ aStr.length() - 1 ];
+
+            if ( lastChar == L'\\' || lastChar == '/' )
+                {
+                // Try again, but without the trailing backslash
+                std::wstring path = aStr.substr( 0, aStr.length() - 1 );
+                err = GetStat( path, &x );
+                if ( err == 0 && (x.st_mode & S_IFDIR) > 0 )
+                    {
+                    aStr = path;
+                    }
+                }
+            }
+        //
+        ret = ( err == 0 && (x.st_mode & S_IFDIR) > 0 );
+        }
+    //
+	return ret;
+}
+
+
+bool FileExists(const std::wstring& aFile)
+{
+	struct stat x;
+	int err = GetStat(aFile,&x );
+	return err == 0; 
+}
+
+
+bool RemoveFile(const std::wstring& aFile)
+{
+	return _wunlink(aFile.c_str()) == 0;
+}
+
+void RemoveHashForFile(const std::wstring& aFile, const int aDriveLetter, const std::wstring& aPath)
+{
+	std::wstring hashdir = L"$:\\sys\\hash\\";
+	std::wstring basename = aFile.substr( aFile.rfind( KDirectorySeparator ) + 1) ;
+	if (basename.size() == 0)
+	{
+		basename = aFile.substr(aFile.rfind(L"\\"));
+	}
+
+	hashdir[0] = aDriveLetter;
+	std::wstring hashFile = aPath + L"\\sys\\hash\\" + basename;
+	if (FileExists(hashFile))
+	{
+		RemoveFile(hashFile);
+	}
+}
+
+bool OpenFile(const std::wstring& aFile, std::fstream& aStream,
+			  std::ios_base::open_mode aMode)
+{
+	std::string s;
+	aStream.open(Ucs2ToUtf8(aFile, s).c_str(), aMode);
+	return aStream.good();
+}
+
+bool MakeDir(const std::wstring& aDir)
+{
+	// This function makes all the directories in a subdirectory hierarchy.
+  	// If the first character in aDir is a backslash, then we assume it refers
+  	// to the root of a drive, hence we start the index below at 1 to skip over
+  	// this initial root directory.
+    size_t index = aDir.find(L':', 0);
+    if(std::wstring::npos == index)
+    	{
+    	index = 0;
+    	}
+    else
+    	{// Skip creation of root directory
+    	index = aDir.find(L'\\', index);
+    	}
+	do
+		{
+    	index += 1;
+		// Try to make each directory in the path. If ERR_ALREADY_EXISTS is returned
+  	  	// then this is okay. Other errors are fatal.
+		index = aDir.find(L'\\', index);
+		std::wstring dir = aDir.substr( 0, index );
+		if(dir == L".")
+			{
+			continue;
+			}
+		if (!CreateDirectory(dir.c_str(),0) && GetLastError() != ERROR_ALREADY_EXISTS)
+            {
+			int lastErr = GetLastError();
+  	  	    (void) lastErr;
+			return false;
+            }
+
+		} while (index != std::wstring::npos);
+
+    return true;
+	}
+
+#ifndef _MSC_VER
+
+void GetDirContents(const std::wstring& path, 
+					std::list<std::wstring>& contents)
+	{
+	_WDIR* currDir =  _wopendir(path.c_str());
+	if(currDir == NULL)
+		{
+		return;
+		}
+	
+	_wdirent* currElem = _wreaddir(currDir);
+	
+	while (currElem)
+		{
+		contents.push_back(currElem->d_name);
+		currElem = _wreaddir(currDir);
+		}
+	_wclosedir(currDir);
+	}
+
+#else
+
+// missing structures for the posix directory calls 
+struct dirent 
+{
+	wchar_t* d_name;
+};
+
+struct DIR 
+{
+	WIN32_FIND_DATA iWinData;
+	HANDLE          iHandle;
+	dirent          iEntry;
+	std::wstring     iName;	
+};
+
+DIR* opendir(const wchar_t* dirname) 
+	{
+	static DIR dir;
+	
+	std::wstring s(dirname);
+	std::wstring wildcard = strchr("/\\", s[s.length()-1]) ? L"*" : L"/*";
+	dir.iName = s.append(wildcard);
+	dir.iHandle = FindFirstFile(dir.iName.c_str(), &dir.iWinData);
+	if (dir.iHandle != INVALID_HANDLE_VALUE )
+		return &dir;
+	else
+		return 0;
+	};
+
+
+dirent* readdir(DIR* aDir)
+{
+	int result = FindNextFile(aDir->iHandle, &aDir->iWinData);
+	if (result != 0)
+	{
+		aDir->iEntry.d_name = aDir->iWinData.cFileName;
+		return &aDir->iEntry;
+	}
+	return 0;
+}
+
+void closedir(DIR* aDir)
+{
+	FindClose(aDir->iHandle);
+	aDir = 0;
+}
+
+
+void GetDirContents(const std::wstring& path, 
+					std::list<std::wstring>& contents)
+{
+
+	DIR* currDir =  opendir(path.c_str());
+	
+	while (currDir)
+	{
+		dirent* currElem = readdir(currDir);
+		if (currElem == 0)
+		{
+			closedir(currDir);
+			currDir = 0;
+		}
+		else
+		{
+			contents.push_back(currElem->d_name);
+		}
+	}
+}
+
+#endif
+
+
+
+bool CheckSisRegistryDirPresent(const std::wstring& aDrivePath, TUint32 aUid)
+{
+    std::wstring ret = StringUtils::MakePathFromSID( aDrivePath + L"/sys/install/sisregistry/", aUid );
+
+	return IsDirectory(ret);
+}
+
+
+int GetAugmentationsNumber(const std::wstring& aFile)
+{
+	for (int index = 1; index < 0xFFFFFFFF; index++)
+	{
+		std::wstringstream s2;
+		s2 << std::hex << index;
+
+		// e.g. 12345678_x.sis
+		std::wstring fileName = aFile + s2.str() + L".sis";
+
+		if ( !FileExists(fileName) )
+		{
+			// return the next available index
+			return index;
+		}
+	}
+
+	return 0;
+}
+std::string Utils::wstring2string (const std::wstring& aWide)
+	{
+	int max = WideCharToMultiByte(CP_OEMCP,0,aWide.c_str(),aWide.length(),0,0,0,0);
+	std::string reply;
+	if (max > 0 )
+		{
+		char* buffer = new char [max];
+		try
+			{
+			WideCharToMultiByte(CP_OEMCP,0,aWide.c_str(),aWide.length(),buffer,max,0,0);
+			reply = std::string (buffer, max);
+			}
+		catch (...)
+			{
+			}
+		delete [] buffer;
+		}
+	return reply;
+	}
+
+std::wstring Utils::string2wstring (const std::string& aNarrow)
+	{
+	int max = MultiByteToWideChar(CP_OEMCP,0,aNarrow.c_str(),aNarrow.length(),0,0);
+	std::wstring reply;
+	if (max > 0 )
+		{
+		wchar_t* buffer = new wchar_t [max];
+		try
+			{
+			MultiByteToWideChar(CP_OEMCP,0,aNarrow.c_str(),aNarrow.length(),buffer,max);
+			reply = std::wstring (buffer, max);
+			}
+		catch (...)
+			{
+			}
+		delete [] buffer;
+		}
+	return reply;
+	}
+
+const std::wstring Utils::IntegerToWideString(int aInt)
+	{
+	std::wstringstream wstream;
+	wstream << aInt;
+	return wstream.str();
+	}
+
+std::wstring Utils::Int64ToWideString(TInt64 aInt)
+	{
+	wchar_t wint[20];
+	
+#ifdef _MSC_VER
+	swprintf(wint, L"%I64u", aInt);
+#else
+	swprintf(wint, 20, L"%I64u", aInt);
+#endif // _MSC_VER
+	
+	std::wstring strInt64(wint);
+	return strInt64;
+	}
+
+int Utils::WideStringToInteger(const std::wstring& aWideString)
+	{
+	unsigned long int value=0;
+	std::wstringstream str(aWideString);
+	str >> value;
+	return value;
+	}