Changeset 16225

Timestamp:

11/18/2008 07:28:55 PM (7 weeks ago)

Author:

jmarshallnz

Message:

added: Win32 dll loader initial code.

Location:

branches/win32dllloader/xbmc

Files:

• FileSystem/FileCurl.cpp (modified) (1 diff)
• Util.cpp (modified) (1 diff)
• Util.h (modified) (1 diff)
• cores/DllLoader/DllLoader.cpp (modified) (1 diff)
• cores/DllLoader/DllLoader.h (modified) (1 diff)
• cores/DllLoader/DllLoaderContainer.cpp (modified) (1 diff)
• cores/DllLoader/LibraryLoader.cpp (modified) (1 diff)
• cores/DllLoader/LibraryLoader.h (modified) (1 diff)
• cores/DllLoader/Win32DllLoader.cpp (modified) (5 diffs)
• cores/DllLoader/Win32DllLoader.h (modified) (2 diffs)
• cores/DllLoader/dll.cpp (modified) (1 diff)
• cores/DllLoader/exports/emu_kernel32.cpp (modified) (1 diff)
• cores/DllLoader/exports/emu_kernel32.h (modified) (1 diff)
• cores/DllLoader/exports/emu_msvcrt.cpp (modified) (3 diffs)
• cores/DllLoader/exports/emu_msvcrt.h (modified) (1 diff)
• lib/libPython/Python/PC/pyconfig.h (modified) (1 diff)
• lib/libPython/XBPython.cpp (modified) (2 diffs)
• lib/libPython/xbmcmodule/pyutil.cpp (modified) (2 diffs)
• lib/libPython/xbmcmodule/pyutil.h (modified) (2 diffs)

branches/win32dllloader/xbmc/FileSystem/FileCurl.cpp

@@ -42 +42 @@
 #define XMIN(a,b) ((a)<(b)?(a):(b))
 
-#if defined(__APPLE__)
-extern "C" int __stdcall dllselect(int ntfs, fd_set *readfds, fd_set *writefds, fd_set *errorfds, const timeval *timeout);
 #define dllselect select
-#elif defined(WIN32)
-extern "C" int __stdcall dllselect(int ntfs, fd_set *readfds, fd_set *writefds, fd_set *errorfds, const timeval *timeout);
-#else
-#define dllselect select
-#endif
 
 // curl calls this routine to debug

branches/win32dllloader/xbmc/Util.cpp

@@ -2210 +2210 @@
 }
 
-#ifndef _LINUX
-void CUtil::Stat64ToStat(struct _stat *result, struct __stat64 *stat)
-#else
 void CUtil::Stat64ToStat(struct stat *result, struct __stat64 *stat)
-#endif
 {
   result->st_dev = stat->st_dev;

branches/win32dllloader/xbmc/Util.h

@@ -286 +286 @@
   static void Stat64ToStatI64(struct _stati64 *result, struct __stat64 *stat);
   static void StatI64ToStat64(struct __stat64 *result, struct _stati64 *stat);
-#ifndef _LINUX
-  static void Stat64ToStat(struct _stat *result, struct __stat64 *stat);
-#else
   static void Stat64ToStat(struct stat *result, struct __stat64 *stat);
-#endif
   static bool CreateDirectoryEx(const CStdString& strPath);
   static CStdString MakeLegalFileName(const CStdString &strFile);

branches/win32dllloader/xbmc/cores/DllLoader/DllLoader.cpp

@@ -574 +574 @@
 }
 
-int DllLoader::ResolveExport(unsigned long ordinal, void **pAddr)
+int DllLoader::ResolveOrdinal(unsigned long ordinal, void **pAddr)
 {
   Export* pExport=GetExportByOrdinal(ordinal);

branches/win32dllloader/xbmc/cores/DllLoader/DllLoader.h

@@ -66 +66 @@
 
   virtual int ResolveExport(const char*, void** ptr);
-  virtual int ResolveExport(unsigned long ordinal, void** ptr);
+  virtual int ResolveOrdinal(unsigned long ordinal, void** ptr);
   virtual bool HasSymbols() { return m_bLoadSymbols && !m_bUnloadSymbols; }
   virtual bool IsSystemDll() { return m_bSystemDll; }
   virtual HMODULE GetHModule() { return (HMODULE)hModule; }  
   
+  Export* GetExportByFunctionName(const char* sFunctionName);
+  Export* GetExportByOrdinal(unsigned long ordinal);
 protected:  
   int Parse();
   int ResolveImports();
-
-  Export* GetExportByOrdinal(unsigned long ordinal);
-  Export* GetExportByFunctionName(const char* sFunctionName);
   
   void AddExport(unsigned long ordinal, void* function, void* track_function = NULL);

branches/win32dllloader/xbmc/cores/DllLoader/DllLoaderContainer.cpp

@@ -278 +278 @@
   else
 #elif defined(_WIN32PC)
-  if (strlen(sName) >= 4 && !strnicmp(sName + (strlen(sName) - 18), "ProjectM_win32.vis", 18))
-  {
+  if (1)
     pLoader = new Win32DllLoader(sName);
-  }
   else
 #endif

branches/win32dllloader/xbmc/cores/DllLoader/LibraryLoader.cpp

@@ -83 +83 @@
   return m_iRefCount;
 }
+
+int LibraryLoader::ResolveOrdinal(unsigned long ordinal, void** ptr)
+{
+  CLog::Log(LOGWARNING, "%s - Unable to resolve %lu in dll %s", __FUNCTION__, ordinal, GetName());
+  return 0;
+}

branches/win32dllloader/xbmc/cores/DllLoader/LibraryLoader.h

@@ -41 +41 @@
   
   virtual int ResolveExport(const char* symbol, void** ptr) = 0;
+  virtual int ResolveOrdinal(unsigned long ordinal, void** ptr);
   virtual bool IsSystemDll() = 0;
   virtual HMODULE GetHModule() = 0;

branches/win32dllloader/xbmc/cores/DllLoader/Win32DllLoader.cpp

@@ -22 +22 @@
 #include "stdafx.h"
 #include "Win32DllLoader.h"
+#include "DllLoader.h"
+#include "DllLoaderContainer.h"
 #include "StdString.h"
 #include "Util.h"
 #include "utils/log.h"
 
+#include "dll_tracker_library.h"
+#include "dll_tracker_file.h"
+#include "exports/emu_kernel32.h"
+#include "exports/emu_msvcrt.h"
+
+// our exports
+Export win32_exports[] =
+{
+  // kernel32
+  { "FindFirstFileA",                               -1, (void*)dllFindFirstFileA,                               NULL },
+  { "GetFileAttributesA",                           -1, (void*)dllGetFileAttributesA,                        NULL },
+  { "LoadLibraryA",                                 -1, (void*)dllLoadLibraryA,                              (void*)track_LoadLibraryA },
+  { "FreeLibrary",                                  -1, (void*)dllFreeLibrary,                               (void*)track_FreeLibrary },
+  { "GetProcAddress",                               -1, (void*)dllGetProcAddress,                            NULL },
+  { "SetEvent",                                     -1, (void*)SetEvent,                                     NULL },
+  { "GetModuleHandleA",                             -1, (void*)dllGetModuleHandleA,                          NULL },
+  { "CreateFileA",                                  -1, (void*)dllCreateFileA,                               NULL },
+  { "LoadLibraryExA",                               -1, (void*)dllLoadLibraryExA,                            (void*)track_LoadLibraryExA }, 
+  { "GetModuleFileNameA",                           -1, (void*)dllGetModuleFileNameA,                        NULL },
+// potential vfs stuff
+//  { "CreateDirectoryA",                             -1, (void*)dllCreateDirectoryA,                          NULL },
+//  { "LockFile",                                     -1, (void*)dllLockFile,                                  NULL },
+//  { "LockFileEx",                                   -1, (void*)dllLockFileEx,                                NULL },
+//  { "UnlockFile",                                   -1, (void*)dllUnlockFile,                                NULL },
+//  { "CreateFileW",                                  -1, (void*)CreateFileW,                                  NULL },
+//  { "GetFullPathNameW",                             -1, (void*)GetFullPathNameW,                             NULL },
+//  { "GetTempPathW",                                 -1, (void*)GetTempPathW,                                 NULL },
+//  { "GetFileAttributesW",                           -1, (void*)GetFileAttributesW,                           NULL },
+//  { "DeleteFileW",                                  -1, (void*)DeleteFileW,                                  NULL },
+//  { "GetFileSize",                                  -1, (void*)GetFileSize,                                  NULL },
+
+// msvcrt
+  { "_close",                     -1, (void*)dll_close,                     (void*)track_close},
+  { "_lseek",                     -1, (void*)dll_lseek,                     NULL },
+  { "_read",                      -1, (void*)dll_read,                      NULL },
+  { "_write",                     -1, (void*)dll_write,                     NULL },
+  { "_lseeki64",                  -1, (void*)dll_lseeki64,                  NULL },
+  { "_open",                      -1, (void*)dll_open,                      (void*)track_open },
+  { "fflush",                     -1, (void*)dll_fflush,                    NULL },
+  { "fprintf",                    -1, (void*)dll_fprintf,                   NULL },
+  { "fwrite",                     -1, (void*)dll_fwrite,                    NULL },
+  { "putchar",                    -1, (void*)dll_putchar,                   NULL },
+  { "_fstat",                     -1, (void*)dll_fstat,                     NULL },
+  { "_mkdir",                     -1, (void*)dll_mkdir,                     NULL },
+  { "_stat",                      -1, (void*)dll_stat,                      NULL },
+  { "_findclose",                 -1, (void*)dll_findclose,                 NULL },
+  { "_findfirst",                 -1, (void*)dll_findfirst,                 NULL },
+  { "_findnext",                  -1, (void*)dll_findnext,                  NULL },
+  { "fclose",                     -1, (void*)dll_fclose,                    (void*)track_fclose},
+  { "feof",                       -1, (void*)dll_feof,                      NULL },
+  { "fgets",                      -1, (void*)dll_fgets,                     NULL },
+  { "fopen",                      -1, (void*)dll_fopen,                     (void*)track_fopen},
+  { "putc",                       -1, (void*)dll_putc,                      NULL },
+  { "fputc",                      -1, (void*)dll_fputc,                     NULL },
+  { "fputs",                      -1, (void*)dll_fputs,                     NULL },
+  { "fread",                      -1, (void*)dll_fread,                     NULL },
+  { "fseek",                      -1, (void*)dll_fseek,                     NULL },
+  { "ftell",                      -1, (void*)dll_ftell,                     NULL },
+  { "getc",                       -1, (void*)dll_getc,                      NULL },
+  { "fgetc",                      -1, (void*)dll_getc,                      NULL },
+  { "rewind",                     -1, (void*)dll_rewind,                    NULL },
+  { "vfprintf",                   -1, (void*)dll_vfprintf,                  NULL },
+  { "fgetpos",                    -1, (void*)dll_fgetpos,                   NULL },
+  { "fsetpos",                    -1, (void*)dll_fsetpos,                   NULL },
+  { "_stati64",                   -1, (void*)dll_stati64,                   NULL },
+  { "_fstati64",                  -1, (void*)dll_fstati64,                  NULL },
+  { "_telli64",                   -1, (void*)dll_telli64,                   NULL },
+  { "_tell",                      -1, (void*)dll_tell,                      NULL },
+  { "_fileno",                    -1, (void*)dll_fileno,                    NULL },
+  { "ferror",                     -1, (void*)dll_ferror,                    NULL },
+  { "freopen",                    -1, (void*)dll_freopen,                   (void*)track_freopen},
+  { "fscanf",                     -1, (void*)fscanf,                        NULL },
+  { "ungetc",                     -1, (void*)dll_ungetc,                    NULL },
+  { "_fdopen",                    -1, (void*)dll_fdopen,                    NULL },
+  { "clearerr",                   -1, (void*)dll_clearerr,                  NULL },
+  // for debugging
+  { "printf",                     -1, (void*)dllprintf,                     NULL },
+  { "vprintf",                    -1, (void*)dllvprintf,                    NULL },
+  { "perror",                     -1, (void*)dllperror,                     NULL },
+  { "puts",                       -1, (void*)dllputs,                       NULL },
+  // workarounds for non-win32 signals
+  { "signal",                     -1, (void*)dll_signal,                    NULL },
+  { NULL,                          -1, NULL,                                NULL }
+};
+
+// stuff for python
+extern "C"
+{
+  char* xbp_getcwd(char *buf, int size);
+  int xbp_chdir(const char *dirname);
+  int xbp_access(const char *path, int mode);
+  int xbp_unlink(const char *filename);
+  int xbp_chmod(const char *filename, int pmode);
+  int xbp_rmdir(const char *dirname);
+  int xbp_utime(const char *filename, struct utimbuf *times);
+  int xbp_rename(const char *oldname, const char *newname);
+  int xbp_mkdir(const char *dirname);
+  int xbp_open(const char *filename, int oflag, int pmode);
+};
+
+extern "C" void* _iob();
+
+Export win32_python_exports[] =
+{
+  // these just correct for path separators and call the base
+  { "access",                               -1, (void*)xbp_access,                               NULL },
+  { "unlink",                               -1, (void*)xbp_unlink,                               NULL },
+  { "chmod",                               -1, (void*)xbp_chmod,                               NULL },
+  { "rmdir",                               -1, (void*)xbp_rmdir,                               NULL },
+  { "utime",                               -1, (void*)xbp_utime,                               NULL },
+  { "rename",                               -1, (void*)xbp_rename,                               NULL },
+  { "mkdir",                               -1, (void*)xbp_mkdir,                               NULL },
+  { "open",                               -1, (void*)xbp_open,                               NULL },
+//  { "opendir",                               -1, (void*)xbp_opendir,                               NULL }, _LINUX only
+
+  // special workaround just for python
+  { "_chdir",                               -1, (void*)xbp_chdir,                               NULL },
+  { "_getcwd",                              -1, (void*)xbp_getcwd,                               NULL },
+  { "_putenv",                              -1, (void*)dll_putenv,                              NULL },
+  { "getenv",                              -1, (void*)dll_getenv,                              NULL },
+  { "__p__environ",               -1, (void*)dll___p__environ,              NULL },
+
+  // for stdin/stdout etc.
+  { "_iob",                       -1, (void*)_iob,                          NULL },
+  { NULL,                          -1, NULL,                                NULL }
+};
+
 Win32DllLoader::Win32DllLoader(const char *dll) : LibraryLoader(dll)
 {
   m_dllHandle = NULL;
+  DllLoaderContainer::RegisterDll(this);
 }
 
@@ -35 +165 @@
   if (m_dllHandle)
     Unload();
+  DllLoaderContainer::UnRegisterDll(this);
 }
 
@@ -54 +185 @@
   }
 
+  // handle functions that the dll imports
+  OverrideImports(strFileName);
+
   return true;
 }
@@ -60 +194 @@
 {
   CLog::Log(LOGDEBUG, "NativeDllLoader: Unloading: %s\n", GetName());
+
+  // restore our imports
+  RestoreImports();
 
   if (m_dllHandle)
@@ -104 +241 @@
   return false;
 }
+
+void Win32DllLoader::OverrideImports(const CStdString &dll)
+{
+  BYTE* image_base = (BYTE*)GetModuleHandle(dll.c_str());
+
+  if (!image_base)
+  {
+    CLog::Log(LOGERROR, "%s - unable to GetModuleHandle for dll %s", dll.c_str());
+    return;
+  }
+
+  PIMAGE_DOS_HEADER dos_header = (PIMAGE_DOS_HEADER)image_base;
+  PIMAGE_NT_HEADERS nt_header = (PIMAGE_NT_HEADERS)(image_base + dos_header->e_lfanew); // e_lfanew = value at 0x3c
+
+  PIMAGE_IMPORT_DESCRIPTOR imp_desc = (PIMAGE_IMPORT_DESCRIPTOR)(
+    image_base + nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
+
+  if (!imp_desc)
+  {
+    CLog::Log(LOGERROR, "%s - unable to get import directory for dll %s", dll.c_str());
+    return;
+  }
+
+  // loop over all imported dlls 
+  for (int i = 0; imp_desc[i].Characteristics != 0; i++)
+  {
+    char *dllName = (char*)(image_base + imp_desc[i].Name);
+
+    PIMAGE_THUNK_DATA orig_first_thunk = (PIMAGE_THUNK_DATA)(image_base + imp_desc[i].OriginalFirstThunk);
+    PIMAGE_THUNK_DATA first_thunk = (PIMAGE_THUNK_DATA)(image_base + imp_desc[i].FirstThunk);
+
+    // and then loop over all imported functions
+    for (int j = 0; orig_first_thunk[j].u1.Function != 0; j++)
+    {
+      void *fixup = NULL;
+      if (orig_first_thunk[j].u1.Function & 0x80000000)
+        ResolveOrdinal(dllName, (orig_first_thunk[j].u1.Ordinal & 0x7fffffff), &fixup);
+      else
+      { // resolve by name
+        PIMAGE_IMPORT_BY_NAME orig_imports_by_name = (PIMAGE_IMPORT_BY_NAME)(
+          image_base + orig_first_thunk[j].u1.AddressOfData);
+
+        ResolveImport(dllName, (char*)orig_imports_by_name->Name, &fixup);
+      }/*
+      if (!fixup)
+      { // create a dummy function for tracking purposes
+        PIMAGE_IMPORT_BY_NAME orig_imports_by_name = (PIMAGE_IMPORT_BY_NAME)(
+          image_base + orig_first_thunk[j].u1.AddressOfData);
+        fixup = CreateDummyFunction(dllName, (char*)orig_imports_by_name->Name);
+      }*/
+      if (fixup)
+      {
+        // save the old function
+        Import import;
+        import.table = &first_thunk[j].u1.Function;
+        import.function = first_thunk[j].u1.Function;
+        m_overriddenImports.push_back(import);
+
+        DWORD old_prot = 0;
+
+        // change to protection settings so we can write to memory area
+        VirtualProtect((PVOID)&first_thunk[j].u1.Function, 4, PAGE_EXECUTE_READWRITE, &old_prot);
+
+        // patch the address of function to point to our overridden version
+        first_thunk[j].u1.Function = (DWORD)fixup;
+
+        // reset to old settings
+        VirtualProtect((PVOID)&first_thunk[j].u1.Function, 4, old_prot, &old_prot);
+      }
+    }
+  }
+}
+
+void Win32DllLoader::RestoreImports()
+{
+  for (unsigned int i = 0; i < m_overriddenImports.size(); i++)
+  {
+    Import &import = m_overriddenImports[i];
+
+    // change to protection settings so we can write to memory area
+    DWORD old_prot = 0;
+    VirtualProtect(import.table, 4, PAGE_EXECUTE_READWRITE, &old_prot);
+
+    *(DWORD *)import.table = import.function;
+
+    // reset to old settings
+    VirtualProtect(import.table, 4, old_prot, &old_prot);
+  }
+}
+
+bool Win32DllLoader::ResolveImport(const char *dllName, const char *functionName, void **fixup)
+{
+  char *dll = GetName();
+  if (strstr(dll, "python24.dll") || strstr(dll, ".pyd"))
+  { // special case for python
+    Export *exp = win32_python_exports;
+    while (exp->name)
+    {
+      if (strcmp(exp->name, functionName) == 0)
+      {
+        *fixup = exp->function;
+        return true;
+      }
+      exp++;
+    }
+  }
+  Export *exp = win32_exports;
+  while (exp->name)
+  {
+    if (strcmp(exp->name, functionName) == 0)
+    { // TODO: Should we be tracking stuff?
+      if (0)
+        *fixup = exp->track_function;
+      else
+        *fixup = exp->function;
+      return true;
+    }
+    exp++;
+  }
+  return false;
+}
+
+bool Win32DllLoader::ResolveOrdinal(const char *dllName, unsigned long ordinal, void **fixup)
+{
+  Export *exp = win32_exports;
+  while (exp->name)
+  {
+    if (exp->ordinal == ordinal)
+    { // TODO: Should we be tracking stuff?
+      if (0)
+        *fixup = exp->track_function;
+      else
+        *fixup = exp->function;
+      return true;
+    }
+    exp++;
+  }
+  return false;
+}

branches/win32dllloader/xbmc/cores/DllLoader/Win32DllLoader.h

@@ -28 +28 @@
 {
 public:
+  class Import
+  {
+  public:
+    void *table;
+    DWORD function;
+  };
+
   Win32DllLoader(const char *dll);
   ~Win32DllLoader();
@@ -40 +47 @@
 
 private:
+  void OverrideImports(const CStdString &dll);
+  void RestoreImports();
+  bool ResolveImport(const char *dllName, const char *functionName, void **fixup);
+  bool ResolveOrdinal(const char *dllName, unsigned long ordinal, void **fixup);
+
   HMODULE m_dllHandle;
+
+  std::vector<Import> m_overriddenImports;
 };
 

branches/win32dllloader/xbmc/cores/DllLoader/dll.cpp

@@ -169 +169 @@
   if( HIGH_WORD(function) == 0 && LOW_WORD(function) < 1000)
   {
-    if( ((DllLoader*) dll)->ResolveExport(LOW_WORD(function), &address) )
+    if( dll->ResolveOrdinal(LOW_WORD(function), &address) )
     {
       CLog::Log(LOGDEBUG, "%s(%p(%s), %d) => %p", __FUNCTION__, hModule, dll->GetName(), LOW_WORD(function), address);

branches/win32dllloader/xbmc/cores/DllLoader/exports/emu_kernel32.cpp

@@ -81 +81 @@
 {
   return FindClose(hFile);
+}
+
+#ifdef _WIN32
+#define CORRECT_SEP_STR(str) \
+    int iSize_##str = strlen(str); \
+    for (int pos = 0; pos < iSize_##str; pos++) if (str[pos] == '/') str[pos] = '\\';
+#else
+#define CORRECT_SEP_STR(str)
+#endif
+
+extern "C" HANDLE WINAPI dllFindFirstFileA(LPCTSTR lpFileName, LPWIN32_FIND_DATA lpFindFileData)
+{
+  char* p = strdup(lpFileName);
+  CORRECT_SEP_STR(p);
+  
+  // change default \\*.* into \\* which the xbox is using
+  char* e = strrchr(p, '.');
+  if (e != NULL && strlen(e) > 1 && e[1] == '*')
+  {
+    e[0] = '\0';
+  }
+
+  int test = sizeof(WIN32_FIND_DATA);
+  
+  HANDLE res = FindFirstFile(_P(p).c_str(), lpFindFileData);
+  free(p);
+  return res;
 }
 

branches/win32dllloader/xbmc/cores/DllLoader/exports/emu_kernel32.h

@@ -590 +590 @@
 //When doing emulation or interception, the calling convention should
 //match exactly the target dlls suppose to use.   Monkeyhappy
+extern "C" HANDLE WINAPI dllFindFirstFileA(LPCTSTR lpFileName, LPWIN32_FIND_DATA lpFindFileData);
 extern "C" BOOL WINAPI dllFindClose(HANDLE hFile);
 extern "C" UINT WINAPI dllGetAtomNameA( ATOM nAtom, LPTSTR lpBuffer, int nSize);

branches/win32dllloader/xbmc/cores/DllLoader/exports/emu_msvcrt.cpp

@@ -126 +126 @@
   dll_putenv("PATH=.;Q:\\;Q:\\system\\python");
   //dll_putenv("PYTHONCASEOK=1");
-  //dll_putenv("PYTHONDEBUG=1");
-  //dll_putenv("PYTHONVERBOSE=2"); // "1" for normal verbose, "2" for more verbose ?
+  dll_putenv("PYTHONDEBUG=1");
+  dll_putenv("PYTHONVERBOSE=2"); // "1" for normal verbose, "2" for more verbose ?
   dll_putenv("PYTHONOPTIMIZE=1");
   //dll_putenv("PYTHONDUMPREFS=1");
@@ -1419 +1419 @@
 
   //SLOW CODE SHOULD BE REVISED
-  int dll_stat(const char *path, struct _stat *buffer)
+  int dll_stat(const char *path, struct stat *buffer)
   {
 #ifndef _LINUX
@@ -1526 +1526 @@
     if (pFile != NULL)
     {
-      CLog::Log(LOGINFO, "Stating open file");
-    
-      __int64 size = pFile->GetLength();
-#ifdef _WIN32PC
-      if (size <= LONG_MAX) 
-#else
-      if (sizeof(size) <= sizeof(buffer->st_size) )
-#endif
-        buffer->st_size = (_off_t)size;
-      else
-      {
-        buffer->st_size = 0;
-        CLog::Log(LOGWARNING, "WARNING: File is larger than 32bit stat can handle, file size will be reported as 0 bytes");
-      }
-      buffer->st_mode = _S_IFREG;
-
-      return 0;
+      struct __stat64 tStat;
+      if (pFile->Stat(&tStat) == 0)
+      {
+        CUtil::Stat64ToStat(buffer, &tStat);
+        return 0;
+      }
     }
     else if (!IS_STD_DESCRIPTOR(fd))

branches/win32dllloader/xbmc/cores/DllLoader/exports/emu_msvcrt.h

@@ -117 +117 @@
   int dll_stati64(const char *path, struct _stati64 *buffer);
   int dll_stat64(const char *path, struct __stat64 *buffer);
-  int dll_stat(const char *path, struct _stat *buffer);
+  int dll_stat(const char *path, struct stat *buffer);
   int dll_fstat(int fd, struct stat *buffer);
   int dll_fstati64(int fd, struct _stati64 *buffer);

branches/win32dllloader/xbmc/lib/libPython/Python/PC/pyconfig.h

@@ -205 +205 @@
 /* For Windows the Python core is in a DLL by default.  Test
 Py_NO_ENABLE_SHARED to find out.  Also support MS_NO_COREDLL for b/w compat */
-#if !defined(MS_NO_COREDLL) && !defined(Py_NO_ENABLE_SHARED) && !defined(_XBOX) && !defined(_WIN32)
+#if !defined(MS_NO_COREDLL) && !defined(Py_NO_ENABLE_SHARED) && !defined(_XBOX)