Changeset 10296 for trunk/src

Timestamp:

Oct 24, 2003, 4:47:25 PM (22 years ago)

Author:

sandervl

Message:

Wine resync

Location:

trunk/src/version

Files:

• LICENSE.TXT (modified) (1 diff)
• VERSION.DEF (modified) (2 diffs)
• dbgwrap.cpp (added)
• info.c (modified) (29 diffs)
• install.c (modified) (17 diffs)
• makefile (modified) (3 diffs)
• resource.c (added)
• version.cpp (deleted)

trunk/src/version/LICENSE.TXT

@@ -1 @@
-$Id: LICENSE.TXT,v 1.1 2001-07-21 08:51:25 sandervl Exp $
-@c This is an additional Odin license agreement.
-@c It supercedes the main Odin license, but is only valid in 
-@c the source directory in which it is present.
+$Id: LICENSE.TXT,v 1.2 2003-10-24 14:47:24 sandervl Exp $
+This is an additional Odin license agreement.
+It supercedes the main Odin license, but is only valid in 
+the source directory in which it is present.
 
-@c This file is processed by GNU's TeXinfo
-@c If you modify it or move it to another location, make sure that
-@c TeXinfo works (type `make' in directory documentation).
-
-Copyright (c) 1993-2000 the Wine project authors (see the file AUTHORS
+Copyright (c) 1993-2002 the Wine project authors (see the file AUTHORS
 for a complete list)
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+Wine is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 2.1 of the License, or (at
+your option) any later version. 
 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+A copy of the GNU Lesser General Public License is included in the
+Wine distribution in the file COPYING.LIB. If you did not receive this
+copy, write to the Free Software Foundation, Inc., 59 Temple Place,
+Suite 330, Boston, MA 02111-1307 USA.

trunk/src/version/VERSION.DEF

@@ -1 @@
-; $Id: VERSION.DEF,v 1.8 2000-01-06 20:10:06 sandervl Exp $
+; $Id: VERSION.DEF,v 1.9 2003-10-24 14:47:25 sandervl Exp $
 
 ;
@@ -22 +22 @@
 ;    VerQueryValueIndexA        = _VerQueryValueIndexA@16     @12
 ;    VerQueryValueIndexW        = _VerQueryValueIndexW@16     @13
-;    VerQueryValueW             = _VerQueryValueW@16          @14

trunk/src/version/info.c

@@ -1 @@
-/* $Id: info.c,v 1.4 2003-01-15 10:42:34 sandervl Exp $ */
-/* 
- * Implementation of VERSION.DLL - Version Info access (Wine 991212)
- * 
+/*
+ * Implementation of VERSION.DLL - Version Info access
+ *
  * Copyright 1996,1997 Marcus Meissner
  * Copyright 1997 David Cuthbert
  * Copyright 1999 Ulrich Weigand
- */
-
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * TODO
+ *   o Verify VerQueryValue()
+ */
+
+#include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include "windef.h"
+#include "winbase.h"
 #include "winreg.h"
 #include "winver.h"
-#include "wine/winestring.h"
+#include "wine/winuser16.h"
+#include "wine/unicode.h"
 #include "winerror.h"
-#include "heap.h"
-#include "crtdll.h"
-#include "debugtools.h"
-#include <misc.h>
-#include <unicode.h>
-
-DEFAULT_DEBUG_CHANNEL(ver)
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(ver);
 
 
@@ -32 +48 @@
  *
  *****************************************************************************/
+#ifdef DEBUG
 static void print_vffi_debug(VS_FIXEDFILEINFO *vffi)
 {
@@ -50 +67 @@
 
         TRACE("(");
-        DPRINTF(" OS=0x%x.0x%x ",
+        TRACE(" OS=0x%x.0x%x ",
                 HIWORD(vffi->dwFileOS),
                 LOWORD(vffi->dwFileOS)
         );
         switch (vffi->dwFileOS&0xFFFF0000) {
-        case VOS_DOS:DPRINTF("DOS,");break;
-        case VOS_OS216:DPRINTF("OS/2-16,");break;
-        case VOS_OS232:DPRINTF("OS/2-32,");break;
-        case VOS_NT:DPRINTF("NT,");break;
+        case VOS_DOS:TRACE("DOS,");break;
+        case VOS_OS216:TRACE("OS/2-16,");break;
+        case VOS_OS232:TRACE("OS/2-32,");break;
+        case VOS_NT:TRACE("NT,");break;
         case VOS_UNKNOWN:
         default:
-                DPRINTF("UNKNOWN(0x%lx),",vffi->dwFileOS&0xFFFF0000);break;
+                TRACE("UNKNOWN(0x%lx),",vffi->dwFileOS&0xFFFF0000);break;
         }
         switch (LOWORD(vffi->dwFileOS)) {
-        case VOS__BASE:DPRINTF("BASE");break;
-        case VOS__WINDOWS16:DPRINTF("WIN16");break;
-        case VOS__WINDOWS32:DPRINTF("WIN32");break;
-        case VOS__PM16:DPRINTF("PM16");break;
-        case VOS__PM32:DPRINTF("PM32");break;
-        default:DPRINTF("UNKNOWN(0x%x)",LOWORD(vffi->dwFileOS));break;
+        case VOS__BASE:TRACE("BASE");break;
+        case VOS__WINDOWS16:TRACE("WIN16");break;
+        case VOS__WINDOWS32:TRACE("WIN32");break;
+        case VOS__PM16:TRACE("PM16");break;
+        case VOS__PM32:TRACE("PM32");break;
+        default:TRACE("UNKNOWN(0x%x)",LOWORD(vffi->dwFileOS));break;
         }
-        DPRINTF(")\n");
+        TRACE(")\n");
 
         switch (vffi->dwFileType) {
@@ -85 +102 @@
                 default:
                 case VFT2_UNKNOWN:
-                        DPRINTF("UNKNOWN(0x%lx)",vffi->dwFileSubtype);
+                        TRACE("UNKNOWN(0x%lx)",vffi->dwFileSubtype);
                         break;
                 case VFT2_DRV_PRINTER:
-                        DPRINTF("PRINTER");
+                        TRACE("PRINTER");
                         break;
                 case VFT2_DRV_KEYBOARD:
-                        DPRINTF("KEYBOARD");
+                        TRACE("KEYBOARD");
                         break;
                 case VFT2_DRV_LANGUAGE:
-                        DPRINTF("LANGUAGE");
+                        TRACE("LANGUAGE");
                         break;
                 case VFT2_DRV_DISPLAY:
-                        DPRINTF("DISPLAY");
+                        TRACE("DISPLAY");
                         break;
                 case VFT2_DRV_MOUSE:
-                        DPRINTF("MOUSE");
+                        TRACE("MOUSE");
                         break;
                 case VFT2_DRV_NETWORK:
-                        DPRINTF("NETWORK");
+                        TRACE("NETWORK");
                         break;
                 case VFT2_DRV_SYSTEM:
-                        DPRINTF("SYSTEM");
+                        TRACE("SYSTEM");
                         break;
                 case VFT2_DRV_INSTALLABLE:
-                        DPRINTF("INSTALLABLE");
+                        TRACE("INSTALLABLE");
                         break;
                 case VFT2_DRV_SOUND:
-                        DPRINTF("SOUND");
+                        TRACE("SOUND");
                         break;
                 case VFT2_DRV_COMM:
-                        DPRINTF("COMM");
+                        TRACE("COMM");
                         break;
                 case VFT2_DRV_INPUTMETHOD:
-                        DPRINTF("INPUTMETHOD");
+                        TRACE("INPUTMETHOD");
                         break;
                 }
@@ -126 +143 @@
                 switch (vffi->dwFileSubtype) {
                 default:
-                        DPRINTF("UNKNOWN(0x%lx)",vffi->dwFileSubtype);
-                        break;
-                case VFT2_FONT_RASTER:DPRINTF("RASTER");break;
-                case VFT2_FONT_VECTOR:DPRINTF("VECTOR");break;
-                case VFT2_FONT_TRUETYPE:DPRINTF("TRUETYPE");break;
+                        TRACE("UNKNOWN(0x%lx)",vffi->dwFileSubtype);
+                        break;
+                case VFT2_FONT_RASTER:TRACE("RASTER");break;
+                case VFT2_FONT_VECTOR:TRACE("VECTOR");break;
+                case VFT2_FONT_TRUETYPE:TRACE("TRUETYPE");break;
                 }
                 break;
@@ -136 +153 @@
         case VFT_STATIC_LIB:TRACE("filetype=STATIC_LIB");break;
         }
-        DPRINTF("\n");
+        TRACE("\n");
         TRACE("  filedata=0x%lx.0x%lx\n",
                     vffi->dwFileDateMS,vffi->dwFileDateLS);
 }
-
+#else
+#define print_vffi_debug(a)
+#endif
 
 /***********************************************************************
@@ -176 +195 @@
     ( ((VS_VERSION_INFO_STRUCT16 *)ver)->szKey[0] >= ' ' )
 
-#define DWORD_ALIGN( ptr ) ((LPBYTE)( (((DWORD)(ptr)) + 3) & ~3 ))
+#define DWORD_ALIGN( base, ptr ) \
+    ( (LPBYTE)(base) + ((((LPBYTE)(ptr) - (LPBYTE)(base)) + 3) & ~3) )
 
 #define VersionInfo16_Value( ver )  \
-    DWORD_ALIGN( (ver)->szKey + lstrlenA((ver)->szKey) + 1 )
+    DWORD_ALIGN( (ver), (ver)->szKey + strlen((ver)->szKey) + 1 )
 #define VersionInfo32_Value( ver )  \
-    DWORD_ALIGN( (ver)->szKey + lstrlenW((ver)->szKey) + 1 )
+    DWORD_ALIGN( (ver), (ver)->szKey + strlenW((ver)->szKey) + 1 )
 
 #define VersionInfo16_Children( ver )  \
@@ -196 +216 @@
     (VS_VERSION_INFO_STRUCT32 *)( (LPBYTE)ver + (((ver)->wLength + 3) & ~3) )
 
-#ifndef __WIN32OS2__
 /***********************************************************************
  *           ConvertVersionInfo32To16        [internal]
  */
-void ConvertVersionInfo32To16( VS_VERSION_INFO_STRUCT32 *info32, 
+void ConvertVersionInfo32To16( VS_VERSION_INFO_STRUCT32 *info32,
                                VS_VERSION_INFO_STRUCT16 *info16 )
 {
@@ -211 +230 @@
     VS_VERSION_INFO_STRUCT16 *child16;
 
-    TRACE("Converting %p to %p\n", info32, info16 );
-    TRACE("wLength %d, wValueLength %d, bText %d, value %p, child %p\n",
-                wLength, wValueLength, bText, lpValue, child32 );
+    dprintf(("Converting %p to %p\n", info32, info16 ));
+    dprintf(("wLength %d, wValueLength %d, bText %d, value %p, child %p\n",
+                wLength, wValueLength, bText, lpValue, child32 ));
 
     /* Convert key */
-    lstrcpyWtoA( info16->szKey, info32->szKey );
-
-    TRACE("Copied key from %p to %p: %s\n", info32->szKey, info16->szKey,
-                debugstr_a(info16->szKey) );
+    WideCharToMultiByte( CP_ACP, 0, info32->szKey, -1, info16->szKey, 0x7fffffff, NULL, NULL );
+
+    dprintf(("Copied key from %p to %p: %s\n", info32->szKey, info16->szKey,
+                debugstr_a(info16->szKey) ));
 
     /* Convert value */
@@ -225 +244 @@
     {
         info16->wValueLength = 0;
-        TRACE("No value present\n" );
+        dprintf(("No value present\n" ));
     }
     else if ( bText )
     {
-        info16->wValueLength = lstrlenW( (LPCWSTR)lpValue ) + 1;
-        lstrcpyWtoA( VersionInfo16_Value( info16 ), (LPCWSTR)lpValue );
-
-        TRACE("Copied value from %p to %p: %s\n", lpValue, 
-                    VersionInfo16_Value( info16 ), 
+        info16->wValueLength = WideCharToMultiByte( CP_ACP, 0, (LPCWSTR)lpValue, -1, NULL, 0, NULL, NULL );
+        WideCharToMultiByte( CP_ACP, 0, (LPCWSTR)lpValue, -1,
+                             VersionInfo16_Value( info16 ), info16->wValueLength, NULL, NULL );
+
+        dprintf(("Copied value from %p to %p: %s\n", lpValue,
+                    VersionInfo16_Value( info16 )),
                     debugstr_a(VersionInfo16_Value( info16 )) );
     }
@@ -241 +261 @@
         memmove( VersionInfo16_Value( info16 ), lpValue, wValueLength );
 
-        TRACE("Copied value from %p to %p: %d bytes\n", lpValue, 
-                     VersionInfo16_Value( info16 ), wValueLength );
+        dprintf(("Copied value from %p to %p: %d bytes\n", lpValue,
+                     VersionInfo16_Value( info16 ), wValueLength ));
     }
 
     /* Convert children */
     child16 = VersionInfo16_Children( info16 );
-    while ( (DWORD)child32 < (DWORD)info32 + wLength )
+    while ( (DWORD)child32 < (DWORD)info32 + wLength && child32->wLength != 0 )
     {
         VS_VERSION_INFO_STRUCT32 *nextChild = VersionInfo32_Next( child32 );
@@ -260 +280 @@
     info16->wLength = (DWORD)child16 - (DWORD)info16;
 
-    TRACE("Finished, length is %d (%p - %p)\n", 
-                info16->wLength, info16, child16 );
-}
-
-
-/***********************************************************************
- *           GetFileVersionInfoSize32A         [VERSION.2]
+    dprintf(("Finished, length is %d (%p - %p)\n",
+                info16->wLength, info16, child16 ));
+}
+
+/***********************************************************************
+ *           VERSION_GetFileVersionInfo_PE             [internal]
+ *
+ *    NOTE: returns size of the PE VERSION resource or 0xFFFFFFFF
+ *    in the case if file exists, but VERSION_INFO not found.
+ *    FIXME: handle is not used.
+ */
+static DWORD VERSION_GetFileVersionInfo_PE( LPCSTR filename, LPDWORD handle,
+                                    DWORD datasize, LPVOID data )
+{
+    VS_FIXEDFILEINFO *vffi;
+    DWORD len;
+    BYTE *buf;
+    HMODULE hModule;
+    HRSRC hRsrc;
+    HGLOBAL hMem;
+
+    dprintf(("(%s,%p)\n", debugstr_a(filename), handle ));
+
+    hModule = GetModuleHandleA(filename);
+    if(!hModule)
+        hModule = LoadLibraryExA(filename, 0, LOAD_LIBRARY_AS_DATAFILE);
+    else
+        hModule = LoadLibraryExA(filename, 0, 0);
+    if(!hModule)
+    {
+        WARN("Could not load %s\n", debugstr_a(filename));
+        return 0;
+    }
+    hRsrc = FindResourceW(hModule,
+                          MAKEINTRESOURCEW(VS_VERSION_INFO),
+                          MAKEINTRESOURCEW(VS_FILE_INFO));
+    if(!hRsrc)
+    {
+        WARN("Could not find VS_VERSION_INFO in %s\n", debugstr_a(filename));
+        FreeLibrary(hModule);
+        return 0xFFFFFFFF;
+    }
+    len = SizeofResource(hModule, hRsrc);
+    hMem = LoadResource(hModule, hRsrc);
+    if(!hMem)
+    {
+        WARN("Could not load VS_VERSION_INFO from %s\n", debugstr_a(filename));
+        FreeLibrary(hModule);
+        return 0xFFFFFFFF;
+    }
+    buf = LockResource(hMem);
+
+    vffi = (VS_FIXEDFILEINFO *)VersionInfo32_Value( (VS_VERSION_INFO_STRUCT32 *)buf );
+
+    if ( vffi->dwSignature != VS_FFI_SIGNATURE )
+    {
+        WARN("vffi->dwSignature is 0x%08lx, but not 0x%08lx!\n",
+                   vffi->dwSignature, VS_FFI_SIGNATURE );
+        len = 0xFFFFFFFF;
+        goto END;
+    }
+#ifdef DEBUG
+    if ( TRACE_ON(ver) )
+        print_vffi_debug( vffi );
+#endif
+    if(data)
+    {
+        if(datasize < len)
+            len = datasize; /* truncate data */
+        if(len)
+            memcpy(data, buf, len);
+        else
+            len = 0xFFFFFFFF;
+    }
+END:
+    FreeResource(hMem);
+    FreeLibrary(hModule);
+
+    return len;
+}
+
+#ifndef __WIN32OS2__
+/***********************************************************************
+ *           VERSION_GetFileVersionInfo_16             [internal]
+ *
+ *    NOTE: returns size of the 16-bit VERSION resource or 0xFFFFFFFF
+ *    in the case if file exists, but VERSION_INFO not found.
+ *    FIXME: handle is not used.
+ */
+static DWORD VERSION_GetFileVersionInfo_16( LPCSTR filename, LPDWORD handle,
+                                    DWORD datasize, LPVOID data )
+{
+    VS_FIXEDFILEINFO *vffi;
+    DWORD len;
+    BYTE *buf;
+    HMODULE16 hModule;
+    HRSRC16 hRsrc;
+    HGLOBAL16 hMem;
+
+    TRACE("(%s,%p)\n", debugstr_a(filename), handle );
+
+    hModule = LoadLibrary16(filename);
+    if(hModule < 32)
+    {
+        WARN("Could not load %s\n", debugstr_a(filename));
+        return 0;
+    }
+    hRsrc = FindResource16(hModule,
+                          MAKEINTRESOURCEA(VS_VERSION_INFO),
+                          MAKEINTRESOURCEA(VS_FILE_INFO));
+    if(!hRsrc)
+    {
+        WARN("Could not find VS_VERSION_INFO in %s\n", debugstr_a(filename));
+        FreeLibrary16(hModule);
+        return 0xFFFFFFFF;
+    }
+    len = SizeofResource16(hModule, hRsrc);
+    hMem = LoadResource16(hModule, hRsrc);
+    if(!hMem)
+    {
+        WARN("Could not load VS_VERSION_INFO from %s\n", debugstr_a(filename));
+        FreeLibrary16(hModule);
+        return 0xFFFFFFFF;
+    }
+    buf = LockResource16(hMem);
+
+    if(!VersionInfoIs16(buf))
+        goto END;
+
+    vffi = (VS_FIXEDFILEINFO *)VersionInfo16_Value( (VS_VERSION_INFO_STRUCT16 *)buf );
+
+    if ( vffi->dwSignature != VS_FFI_SIGNATURE )
+    {
+        WARN("vffi->dwSignature is 0x%08lx, but not 0x%08lx!\n",
+                   vffi->dwSignature, VS_FFI_SIGNATURE );
+        len = 0xFFFFFFFF;
+        goto END;
+    }
+
+    if ( TRACE_ON(ver) )
+        print_vffi_debug( vffi );
+
+    if(data)
+    {
+        if(datasize < len)
+            len = datasize; /* truncate data */
+        if(len)
+            memcpy(data, buf, len);
+        else
+            len = 0xFFFFFFFF;
+    }
+END:
+    FreeResource16(hMem);
+    FreeLibrary16(hModule);
+
+    return len;
+}
+#endif
+
+/***********************************************************************
+ *           GetFileVersionInfoSizeA         [VERSION.@]
  */
 DWORD WINAPI GetFileVersionInfoSizeA( LPCSTR filename, LPDWORD handle )
@@ -274 +448 @@
     BYTE buf[144];
 
-    TRACE("(%s,%p)\n", debugstr_a(filename), handle );
-
-    len = GetFileResourceSize( filename,
+    dprintf(("(%s,%p)\n", debugstr_a(filename), handle ));
+
+    len = VERSION_GetFileVersionInfo_PE(filename, handle, 0, NULL);
+    /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */
+    if(len == 0xFFFFFFFF)
+    {
+        SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
+        return 0;
+    }
+    if(len) return len;
+#ifndef __WIN32OS2__
+    len = VERSION_GetFileVersionInfo_16(filename, handle, 0, NULL);
+    /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */
+    if(len == 0xFFFFFFFF)
+    {
+        SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
+        return 0;
+    }
+    if(len) return len;
+#endif
+    len = GetFileResourceSize16( filename,
                                  MAKEINTRESOURCEA(VS_FILE_INFO),
                                  MAKEINTRESOURCEA(VS_VERSION_INFO),
@@ -282 +474 @@
     if (!len) return 0;
 
-    ret = GetFileResource( filename,
+    ret = GetFileResource16( filename,
                              MAKEINTRESOURCEA(VS_FILE_INFO),
                              MAKEINTRESOURCEA(VS_VERSION_INFO),
@@ -289 +481 @@
 
     if ( handle ) *handle = offset;
-    
+
     if ( VersionInfoIs16( buf ) )
         vffi = (VS_FIXEDFILEINFO *)VersionInfo16_Value( (VS_VERSION_INFO_STRUCT16 *)buf );
@@ -297 +489 @@
     if ( vffi->dwSignature != VS_FFI_SIGNATURE )
     {
-        WARN("vffi->dwSignature is 0x%08lx, but not 0x%08lx!\n",
-                   vffi->dwSignature, VS_FFI_SIGNATURE );
+        dprintf(("vffi->dwSignature is 0x%08lx, but not 0x%08lx!\n",
+                   vffi->dwSignature, VS_FFI_SIGNATURE ));
         return 0;
     }
@@ -305 +497 @@
         len = ((VS_VERSION_INFO_STRUCT16 *)buf)->wLength;
 
+#ifdef DEBUG
     if ( TRACE_ON(ver) )
         print_vffi_debug( vffi );
+#endif
 
     return len;
@@ -312 +506 @@
 
 /***********************************************************************
- *           GetFileVersionInfoSize32W         [VERSION.3]
+ *           GetFileVersionInfoSizeW         [VERSION.@]
  */
 DWORD WINAPI GetFileVersionInfoSizeW( LPCWSTR filename, LPDWORD handle )
 {
-    LPSTR fn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
-    DWORD ret = GetFileVersionInfoSizeA( fn, handle );
+    DWORD ret, len = WideCharToMultiByte( CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL );
+    LPSTR fn = HeapAlloc( GetProcessHeap(), 0, len );
+    WideCharToMultiByte( CP_ACP, 0, filename, -1, fn, len, NULL, NULL );
+    ret = GetFileVersionInfoSizeA( fn, handle );
     HeapFree( GetProcessHeap(), 0, fn );
     return ret;
@@ -323 +519 @@
 
 /***********************************************************************
- *           GetFileVersionInfo32A             [VERSION.1]
- */
-DWORD WINAPI GetFileVersionInfoA( LPCSTR filename, DWORD handle,
+ *           GetFileVersionInfoA             [VERSION.@]
+ */
+BOOL WINAPI GetFileVersionInfoA( LPCSTR filename, DWORD handle,
                                     DWORD datasize, LPVOID data )
 {
-    TRACE("(%s,%ld,size=%ld,data=%p)\n",
-                debugstr_a(filename), handle, datasize, data );
-
-    if ( !GetFileResource( filename, MAKEINTRESOURCEA(VS_FILE_INFO),
+    DWORD len;
+
+    dprintf(("(%s,%ld,size=%ld,data=%p)\n",
+                debugstr_a(filename), handle, datasize, data ));
+
+    len = VERSION_GetFileVersionInfo_PE(filename, &handle, datasize, data);
+    /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */
+    if(len == 0xFFFFFFFF) return FALSE;
+    if(len)
+        goto DO_CONVERT;
+#ifndef __WIN32OS2__
+    len = VERSION_GetFileVersionInfo_16(filename, &handle, datasize, data);
+    /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */
+    if(len == 0xFFFFFFFF) return FALSE;
+    if(len)
+        goto DO_CONVERT;
+#endif
+
+    if ( !GetFileResource16( filename, MAKEINTRESOURCEA(VS_FILE_INFO),
                                        MAKEINTRESOURCEA(VS_VERSION_INFO),
                                        handle, datasize, data ) )
         return FALSE;
-
+DO_CONVERT:
     if (    datasize >= sizeof(VS_VERSION_INFO_STRUCT16)
-         && datasize >= ((VS_VERSION_INFO_STRUCT16 *)data)->wLength  
+         && datasize >= ((VS_VERSION_INFO_STRUCT16 *)data)->wLength
          && !VersionInfoIs16( data ) )
     {
         /* convert resource from PE format to NE format */
-        ConvertVersionInfo32To16( (VS_VERSION_INFO_STRUCT32 *)data, 
+        ConvertVersionInfo32To16( (VS_VERSION_INFO_STRUCT32 *)data,
                                   (VS_VERSION_INFO_STRUCT16 *)data );
     }
@@ -349 +560 @@
 
 /***********************************************************************
- *           GetFileVersionInfo32W             [VERSION.4]
- */
-DWORD WINAPI GetFileVersionInfoW( LPCWSTR filename, DWORD handle,
+ *           GetFileVersionInfoW             [VERSION.@]
+ */
+BOOL WINAPI GetFileVersionInfoW( LPCWSTR filename, DWORD handle,
                                     DWORD datasize, LPVOID data )
 {
-    LPSTR fn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
+    DWORD len = WideCharToMultiByte( CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL );
+    LPSTR fn = HeapAlloc( GetProcessHeap(), 0, len );
     DWORD retv = TRUE;
 
-    TRACE("(%s,%ld,size=%ld,data=%p)\n",
-                debugstr_a(fn), handle, datasize, data );
-
-    if ( !GetFileResource( fn, MAKEINTRESOURCEA(VS_FILE_INFO),
+    WideCharToMultiByte( CP_ACP, 0, filename, -1, fn, len, NULL, NULL );
+
+    dprintf(("(%s,%ld,size=%ld,data=%p)\n",
+                debugstr_w(filename), handle, datasize, data ));
+
+    if(VERSION_GetFileVersionInfo_PE(fn, &handle, datasize, data))
+        goto END;
+#ifndef __WIN32OS2__
+    if(VERSION_GetFileVersionInfo_16(fn, &handle, datasize, data))
+        goto END;
+#endif
+    if ( !GetFileResource16( fn, MAKEINTRESOURCEA(VS_FILE_INFO),
                                  MAKEINTRESOURCEA(VS_VERSION_INFO),
                                  handle, datasize, data ) )
@@ -366 +586 @@
 
     else if (    datasize >= sizeof(VS_VERSION_INFO_STRUCT16)
-              && datasize >= ((VS_VERSION_INFO_STRUCT16 *)data)->wLength 
+              && datasize >= ((VS_VERSION_INFO_STRUCT16 *)data)->wLength
               && VersionInfoIs16( data ) )
     {
-        ERR("Cannot access NE resource in %s\n", debugstr_a(fn) );
+        dprintf(("Cannot access NE resource in %s\n", debugstr_a(fn) ));
         retv =  FALSE;
     }
-
+END:
     HeapFree( GetProcessHeap(), 0, fn );
     return retv;
 }
-#endif //!__WIN32OS2__
+
 
 /***********************************************************************
  *           VersionInfo16_FindChild             [internal]
  */
-VS_VERSION_INFO_STRUCT16 *VersionInfo16_FindChild( VS_VERSION_INFO_STRUCT16 *info, 
+static VS_VERSION_INFO_STRUCT16 *VersionInfo16_FindChild( VS_VERSION_INFO_STRUCT16 *info,
                                             LPCSTR szKey, UINT cbKey )
 {
@@ -388 +608 @@
     while ( (DWORD)child < (DWORD)info + info->wLength )
     {
-        if ( !lstrncmpiA( child->szKey, szKey, cbKey ) )
+        if ( !strncasecmp( child->szKey, szKey, cbKey ) )
             return child;
 
@@ -401 +621 @@
  *           VersionInfo32_FindChild             [internal]
  */
-VS_VERSION_INFO_STRUCT32 *VersionInfo32_FindChild( VS_VERSION_INFO_STRUCT32 *info, 
+static VS_VERSION_INFO_STRUCT32 *VersionInfo32_FindChild( VS_VERSION_INFO_STRUCT32 *info,
                                             LPCWSTR szKey, UINT cbKey )
 {
@@ -408 +628 @@
     while ( (DWORD)child < (DWORD)info + info->wLength )
     {
-#ifdef __WIN32OS2__
-        if ( !lstrncmpiW( child->szKey, szKey, cbKey ) )
-#else
-        if ( !CRTDLL_wcsnicmp( child->szKey, szKey, cbKey ) )
-#endif
+        if ( !strncmpiW( child->szKey, szKey, cbKey ) )
             return child;
 
@@ -422 +638 @@
 
 /***********************************************************************
- *           VerQueryValue32W              [VERSION.13]
- */
-DWORD VerQueryValue32W( LPVOID pBlock, LPCWSTR lpSubBlock,
-                        LPVOID *lplpBuffer, UINT *puLen, BOOL *bText)
-{
-    VS_VERSION_INFO_STRUCT32 *info = (VS_VERSION_INFO_STRUCT32 *)pBlock;
-    if ( VersionInfoIs16( info ) )
-    {
-        ERR("called on NE resource!\n" );
-        return FALSE;
-    }
-
-#if defined(__WIN32OS2__)
-    dprintf(("VerQueryValueW %x %x %x %x", pBlock, lpSubBlock, lplpBuffer, puLen));
-#else
-    TRACE("(%p,%s,%p,%p)\n",
-                pBlock, debugstr_w(lpSubBlock), lplpBuffer, puLen );
-#endif
+ *           VerQueryValueA              [VERSION.@]
+ */
+DWORD WINAPI VerQueryValueA( LPVOID pBlock, LPCSTR lpSubBlock,
+                               LPVOID *lplpBuffer, UINT *puLen )
+{
+    VS_VERSION_INFO_STRUCT16 *info = (VS_VERSION_INFO_STRUCT16 *)pBlock;
+    if ( !VersionInfoIs16( info ) )
+    {
+        INT len;
+        LPWSTR wide_str;
+        DWORD give;
+
+        /* <lawson_whitney@juno.com> Feb 2001 */
+        /* AOL 5.0 does this, expecting to get this: */
+        len = MultiByteToWideChar(CP_ACP, 0, lpSubBlock, -1, NULL, 0);
+        wide_str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+        MultiByteToWideChar(CP_ACP, 0, lpSubBlock, -1, wide_str, len);
+
+        give = VerQueryValueW(pBlock, wide_str, lplpBuffer, puLen);
+        HeapFree(GetProcessHeap(), 0, wide_str);
+        return give;
+    }
+
+    dprintf(("(%p,%s,%p,%p)\n",
+                pBlock, debugstr_a(lpSubBlock), lplpBuffer, puLen ));
 
     while ( *lpSubBlock )
     {
         /* Find next path component */
-        LPCWSTR lpNextSlash;
+        LPCSTR lpNextSlash;
         for ( lpNextSlash = lpSubBlock; *lpNextSlash; lpNextSlash++ )
             if ( *lpNextSlash == '\\' )
@@ -457 +680 @@
 
         /* We have a non-empty component: search info for key */
-        info = VersionInfo32_FindChild( info, lpSubBlock, lpNextSlash-lpSubBlock );
+        info = VersionInfo16_FindChild( info, lpSubBlock, lpNextSlash-lpSubBlock );
         if ( !info ) return FALSE;
 
@@ -465 +688 @@
 
     /* Return value */
-    *lplpBuffer = VersionInfo32_Value( info );
+    *lplpBuffer = VersionInfo16_Value( info );
     *puLen = info->wValueLength;
-    *bText = info->bText;
-
-#if defined(__WIN32OS2__)
-    dprintf(("VerQueryValueW successful"));
-#endif
+
     return TRUE;
 }
 
-
-#if defined(__WIN32OS2__)
-DWORD VerQueryValueW( LPVOID pBlock, LPCWSTR lpSubBlock,
-                      LPVOID *lplpBuffer, UINT *puLen)
-{
- BOOL bText;
-
-    return VerQueryValue32W(pBlock, lpSubBlock, lplpBuffer, puLen, &bText);
-}
-#endif
-
-/***********************************************************************
- *           VerQueryValue32A              [VERSION.12]
- */
-DWORD WINAPI VerQueryValueA( LPVOID pBlock, LPCSTR lpSubBlock,
+/***********************************************************************
+ *           VerQueryValueW              [VERSION.@]
+ */
+DWORD WINAPI VerQueryValueW( LPVOID pBlock, LPCWSTR lpSubBlock,
                                LPVOID *lplpBuffer, UINT *puLen )
 {
-    VS_VERSION_INFO_STRUCT16 *info = (VS_VERSION_INFO_STRUCT16 *)pBlock;
-    if ( !VersionInfoIs16( info ) )
-    {
-#ifdef __WIN32OS2__
-        // this is a quick hack, not much tested
-        WCHAR *ustring = (WCHAR *)malloc(strlen((char *)lpSubBlock)*2+2);
-        LPVOID ubuffer;
-        char *abuffer;
-        UINT len = *puLen * 2;
-        BOOL rc, bText;
-
-        dprintf(("VERSION: called on PE unicode resource!\n" ));
-
-        AsciiToUnicode((char *)lpSubBlock, ustring);
-        rc = VerQueryValue32W( pBlock, (LPWSTR)ustring, &ubuffer, &len, &bText);
-        if(rc == 0) {
-                free(ustring);
-                return 0;
-        }
-        if(!bText) {
-          *lplpBuffer = ubuffer;
-        }
-        else
-        {
-          *lplpBuffer = malloc(len+1); // FIXME: no free, memory leak!!
-          UnicodeToAsciiN((WCHAR *)ubuffer, (char *)*lplpBuffer, len);
-        }
-        *puLen = len;
-        free(ustring);
-        return rc;
-#else
-        ERR("called on PE resource!\n" );
+    VS_VERSION_INFO_STRUCT32 *info = (VS_VERSION_INFO_STRUCT32 *)pBlock;
+    if ( VersionInfoIs16( info ) )
+    {
+        dprintf(("called on NE resource!\n" ));
         return FALSE;
-#endif //__WIN32OS2__
-    }
-
-    TRACE("(%p,%s,%p,%p)\n",
-                pBlock, debugstr_a(lpSubBlock), lplpBuffer, puLen );
+    }
+
+    dprintf(("(%p,%s,%p,%p)\n",
+                pBlock, debugstr_w(lpSubBlock), lplpBuffer, puLen ));
 
     while ( *lpSubBlock )
     {
         /* Find next path component */
-        LPCSTR lpNextSlash;
+        LPCWSTR lpNextSlash;
         for ( lpNextSlash = lpSubBlock; *lpNextSlash; lpNextSlash++ )
             if ( *lpNextSlash == '\\' )
@@ -547 +726 @@
 
         /* We have a non-empty component: search info for key */
-        info = VersionInfo16_FindChild( info, lpSubBlock, lpNextSlash-lpSubBlock );
+        info = VersionInfo32_FindChild( info, lpSubBlock, lpNextSlash-lpSubBlock );
         if ( !info ) return FALSE;
 
@@ -555 +734 @@
 
     /* Return value */
-    *lplpBuffer = VersionInfo16_Value( info );
+    *lplpBuffer = VersionInfo32_Value( info );
     *puLen = info->wValueLength;
 

trunk/src/version/install.c

@@ -1 @@
-/* $Id: install.c,v 1.2 2000-01-08 14:27:33 sandervl Exp $ */
-/* 
- * Implementation of VERSION.DLL - File Installer routines (Wine 991212)
- * 
+/*
+ * Implementation of VERSION.DLL - File Installer routines
+ *
  * Copyright 1996,1997 Marcus Meissner
  * Copyright 1997 David Cuthbert
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * TODO
+ *   o Check the installation functions.
  */
 
 #include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
 #include <string.h>
 
 #include "windef.h"
+#include "winbase.h"
 #include "winver.h"
-#include "wine/winestring.h"
+#include "winnls.h"
+#include "wine/unicode.h"
 #include "winerror.h"
-#include "heap.h"
 #include "lzexpand.h"
-#include "xmalloc.h"
-#include "debugtools.h"
-#include <misc.h>
-
-DEFAULT_DEBUG_CHANNEL(ver)
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(ver);
 
 
 /******************************************************************************
- *
- *   void  ver_dstring(
- *      char const * prologue,
- *      char const * teststring,
- *      char const * epilogue )
- *
- *   This function will print via dprintf[_]ver to stddeb the prologue string,
- *   followed by the address of teststring and the string it contains if
- *   teststring is non-null or "(null)" otherwise, and then the epilogue
- *   string followed by a new line.
- *
- *   Revision history
- *      30-May-1997 Dave Cuthbert (dacut@ece.cmu.edu)
- *         Original implementation as dprintf[_]ver_string
- *      05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
- *         Fixed problem that caused bug with tools/make_debug -- renaming
- *         this function should fix the problem.
- *      15-Feb-1998 Dimitrie Paun (dimi@cs.toronto.edu)
- *         Modified it to make it print the message using only one
- *         dprintf[_]ver call.
- *
- *****************************************************************************/
-
-static void  ver_dstring(
-    char const * prologue,
-    char const * teststring,
-    char const * epilogue )
-{
-    TRACE("%s %p (\"%s\") %s\n", prologue,
-                (void const *) teststring,
-                teststring ? teststring : "(null)",
-                epilogue);
-}
-
-/******************************************************************************
- *
- *   int  testFileExistence(
- *      char const * path,
- *      char const * file )
+ *   testFileExistenceA
  *
  *   Tests whether a given path/file combination exists.  If the file does
@@ -72 +51 @@
  *         Original implementation
  *
- *****************************************************************************/
-
-static int  testFileExistence(
-   char const * path,
-   char const * file )
+ */
+static int testFileExistenceA( char const * path, char const * file, BOOL excl )
 {
     char  filename[1024];
     int  filenamelen;
     OFSTRUCT  fileinfo;
-    int  retval;
 
     fileinfo.cBytes = sizeof(OFSTRUCT);
@@ -99 +74 @@
     strcat(filename, file);
 
-    if(OpenFile(filename, &fileinfo, OF_EXIST) == HFILE_ERROR)
-        retval = 0;
-    else
-        retval = 1;
-
-    return  retval;
+    return (OpenFile(filename, &fileinfo,
+                     OF_EXIST | (excl ? OF_SHARE_EXCLUSIVE : 0)) != HFILE_ERROR);
 }
 
 /******************************************************************************
- *
- *   int  testFileExclusiveExistence(
- *      char const * path,
- *      char const * file )
- *
- *   Tests whether a given path/file combination exists and ensures that no
- *   other programs have handles to the given file.  If the file does not
- *   exist or is open, the return value is zero.  If it does exist, the
- *   return value is non-zero.
- *
- *   Revision history
- *      30-May-1997 Dave Cuthbert (dacut@ece.cmu.edu)
- *         Original implementation
- *
- *****************************************************************************/
-
-static int  testFileExclusiveExistence(
-   char const * path,
-   char const * file )
+ *   testFileExistenceW
+ */
+static int testFileExistenceW( const WCHAR *path, const WCHAR *file, BOOL excl )
 {
-    char  filename[1024];
-    int  filenamelen;
-    OFSTRUCT  fileinfo;
-    int  retval;
+    char *filename;
+    DWORD pathlen, filelen;
+    int ret;
+    OFSTRUCT fileinfo;
 
     fileinfo.cBytes = sizeof(OFSTRUCT);
 
-    strcpy(filename, path);
-    filenamelen = strlen(filename);
-
+    pathlen = WideCharToMultiByte( CP_ACP, 0, path, -1, NULL, 0, NULL, NULL );
+    filelen = WideCharToMultiByte( CP_ACP, 0, file, -1, NULL, 0, NULL, NULL );
+    filename = HeapAlloc( GetProcessHeap(), 0, pathlen+filelen+2 );
+
+    WideCharToMultiByte( CP_ACP, 0, path, -1, filename, pathlen, NULL, NULL );
     /* Add a trailing \ if necessary */
-    if(filenamelen) {
-        if(filename[filenamelen - 1] != '\\')
-            strcat(filename, "\\");
+    if (pathlen > 1)
+    {
+        if (filename[pathlen-2] != '\\') strcpy( &filename[pathlen-1], "\\" );
     }
     else /* specify the current directory */
-        strcpy(filename, ".\\");
-
-    /* Create the full pathname */
-    strcat(filename, file);
-
-    if(OpenFile(filename, &fileinfo, OF_EXIST | OF_SHARE_EXCLUSIVE) ==
-       HFILE_ERROR)
-        retval = 0;
-    else
-        retval = 1;
-
-    return retval;
+        strcpy(filename, ".\\");
+
+    WideCharToMultiByte( CP_ACP, 0, file, -1, filename+strlen(filename), filelen, NULL, NULL );
+
+    ret = (OpenFile(filename, &fileinfo,
+                    OF_EXIST | (excl ? OF_SHARE_EXCLUSIVE : 0)) != HFILE_ERROR);
+    HeapFree( GetProcessHeap(), 0, filename );
+    return ret;
 }
 
 /*****************************************************************************
- *
- *   VerFindFile() [VER.8]
+ *   VerFindFileA [VERSION.@]
+ *
  *   Determines where to install a file based on whether it locates another
  *   version of the file in the system.  The values VerFindFile returns are
@@ -168 +121 @@
  *      30-May-1997   Dave Cuthbert (dacut@ece.cmu.edu)
  *         Reimplementation of VerFindFile from original stub.
- *
- ****************************************************************************/
-
-/* VerFindFile32A                                               [VERSION.5] */
+ */
 DWORD WINAPI VerFindFileA(
     UINT flags,
@@ -182 +132 @@
     UINT *lpuDestDirLen )
 {
-    DWORD  retval;
-    char  curDir[256];
-    char  destDir[256];
+    DWORD  retval = 0;
+    const char *curDir;
+    const char *destDir;
     unsigned int  curDirSizeReq;
     unsigned int  destDirSizeReq;
-
-    retval = 0;
+    char  systemDir[MAX_PATH];
 
     /* Print out debugging information */
-    TRACE("called with parameters:\n"
-                 "\tflags = %x", flags);
-    if(flags & VFFF_ISSHAREDFILE)
-        TRACE(" (VFFF_ISSHAREDFILE)\n");
-    else
-        TRACE("\n");
-
-    ver_dstring("\tlpszFilename = ", lpszFilename, "");
-    ver_dstring("\tlpszWinDir = ", lpszWinDir, "");
-    ver_dstring("\tlpszAppDir = ", lpszAppDir, "");
-
-    TRACE("\tlpszCurDir = %p\n", lpszCurDir);
-    if(lpuCurDirLen)
-        TRACE("\tlpuCurDirLen = %p (%u)\n",
-                    lpuCurDirLen, *lpuCurDirLen);
-    else
-        TRACE("\tlpuCurDirLen = (null)\n");
-
-    TRACE("\tlpszDestDir = %p\n", lpszDestDir);
-    if(lpuDestDirLen)
-        TRACE("\tlpuDestDirLen = %p (%u)\n",
-                    lpuDestDirLen, *lpuDestDirLen);
+    TRACE("flags = %x filename=%s windir=%s appdir=%s curdirlen=%p(%u) destdirlen=%p(%u)\n",
+          flags, debugstr_a(lpszFilename), debugstr_a(lpszWinDir), debugstr_a(lpszAppDir),
+          lpuCurDirLen, lpuCurDirLen ? *lpuCurDirLen : 0,
+          lpuDestDirLen, lpuDestDirLen ? *lpuDestDirLen : 0 );
 
     /* Figure out where the file should go; shared files default to the
        system directory */
 
-    strcpy(curDir, "");
-    strcpy(destDir, "");
-
-    if(flags & VFFF_ISSHAREDFILE) {
-        GetSystemDirectoryA(destDir, 256);
-
-        /* Were we given a filename?  If so, try to find the file. */
-        if(lpszFilename) {
-            if(testFileExistence(destDir, lpszFilename)) {
-                strcpy(curDir, destDir);
-
-                if(!testFileExclusiveExistence(destDir, lpszFilename))
-                    retval |= VFF_FILEINUSE;
-            }
-            else if(lpszAppDir && testFileExistence(lpszAppDir,
-                                                    lpszFilename)) {
-                strcpy(curDir, lpszAppDir);
-                retval |= VFF_CURNEDEST;
-
-                if(!testFileExclusiveExistence(lpszAppDir, lpszFilename))
-                    retval |= VFF_FILEINUSE;
-            }
-        }
-    }
-    else if(!(flags & VFFF_ISSHAREDFILE)) { /* not a shared file */
-        if(lpszAppDir) {
-            char  systemDir[256];
-            GetSystemDirectoryA(systemDir, 256);
-
-            strcpy(destDir, lpszAppDir);
-
-            if(lpszFilename) {
-                if(testFileExistence(lpszAppDir, lpszFilename)) {
-                    strcpy(curDir, lpszAppDir);
-
-                    if(!testFileExclusiveExistence(lpszAppDir, lpszFilename))
-                        retval |= VFF_FILEINUSE;
-                }
-                else if(testFileExistence(systemDir, lpszFilename)) {
-                    strcpy(curDir, systemDir);
-                    retval |= VFF_CURNEDEST;
-
-                    if(!testFileExclusiveExistence(systemDir, lpszFilename))
-                        retval |= VFF_FILEINUSE;
-                }
-            }
-        }
-    }
+    GetSystemDirectoryA(systemDir, sizeof(systemDir));
+    curDir = "";
+    destDir = "";
+
+    if(flags & VFFF_ISSHAREDFILE)
+    {
+        destDir = systemDir;
+        /* Were we given a filename?  If so, try to find the file. */
+        if(lpszFilename)
+        {
+            if(testFileExistenceA(destDir, lpszFilename, FALSE)) curDir = destDir;
+            else if(lpszAppDir && testFileExistenceA(lpszAppDir, lpszFilename, FALSE))
+            {
+                curDir = lpszAppDir;
+                retval |= VFF_CURNEDEST;
+            }
+        }
+    }
+    else /* not a shared file */
+    {
+        if(lpszAppDir)
+        {
+            destDir = lpszAppDir;
+            if(lpszFilename)
+            {
+                if(testFileExistenceA(destDir, lpszFilename, FALSE)) curDir = destDir;
+                else if(testFileExistenceA(systemDir, lpszFilename, FALSE))
+                {
+                    curDir = systemDir;
+                    retval |= VFF_CURNEDEST;
+                }
+            }
+        }
+    }
+
+    if (lpszFilename && !testFileExistenceA(curDir, lpszFilename, TRUE))
+        retval |= VFF_FILEINUSE;
 
     curDirSizeReq = strlen(curDir) + 1;
     destDirSizeReq = strlen(destDir) + 1;
-
-
 
     /* Make sure that the pointers to the size of the buffers are
@@ -275 +193 @@
        is valid, then make sure that the buffer pointer is valid, too! */
 
-    if(lpuDestDirLen && lpszDestDir) {
-        if(*lpuDestDirLen < destDirSizeReq) {
-            retval |= VFF_BUFFTOOSMALL;
-            if (*lpuDestDirLen) {
-            lstrcpynA(lpszDestDir, destDir, *lpuDestDirLen);
-        }
-        }
-        else
-            strcpy(lpszDestDir, destDir);
-
-        *lpuDestDirLen = destDirSizeReq;
-    }
-    
-    if(lpuCurDirLen && lpszCurDir) {
-        if(*lpuCurDirLen < curDirSizeReq) {
-            retval |= VFF_BUFFTOOSMALL;
-            if (*lpuCurDirLen) {
-            lstrcpynA(lpszCurDir, curDir, *lpuCurDirLen);
-            }
-        }
-        else
-            strcpy(lpszCurDir, curDir);
-
-        *lpuCurDirLen = curDirSizeReq;
-    }
-
-    TRACE("ret = %lu (%s%s%s)\n", retval,
-                 (retval & VFF_CURNEDEST) ? "VFF_CURNEDEST " : "",
-                 (retval & VFF_FILEINUSE) ? "VFF_FILEINUSE " : "",
-                 (retval & VFF_BUFFTOOSMALL) ? "VFF_BUFFTOOSMALL " : "");
-
-    ver_dstring("\t(Exit) lpszCurDir = ", lpszCurDir, "");
-    if(lpuCurDirLen)
-        TRACE("\t(Exit) lpuCurDirLen = %p (%u)\n",
-                    lpuCurDirLen, *lpuCurDirLen);
-    else
-        TRACE("\t(Exit) lpuCurDirLen = (null)\n");
-
-    ver_dstring("\t(Exit) lpszDestDir = ", lpszDestDir, "");
-    if(lpuDestDirLen)
-        TRACE("\t(Exit) lpuDestDirLen = %p (%u)\n",
-                    lpuDestDirLen, *lpuDestDirLen);
+    if(lpuDestDirLen && lpszDestDir)
+    {
+        if (*lpuDestDirLen < destDirSizeReq) retval |= VFF_BUFFTOOSMALL;
+        lstrcpynA(lpszDestDir, destDir, *lpuDestDirLen);
+        *lpuDestDirLen = destDirSizeReq;
+    }
+    if(lpuCurDirLen && lpszCurDir)
+    {
+        if(*lpuCurDirLen < curDirSizeReq) retval |= VFF_BUFFTOOSMALL;
+        lstrcpynA(lpszCurDir, curDir, *lpuCurDirLen);
+        *lpuCurDirLen = curDirSizeReq;
+    }
+
+    TRACE("ret = %lu (%s%s%s) curdir=%s destdir=%s\n", retval,
+          (retval & VFF_CURNEDEST) ? "VFF_CURNEDEST " : "",
+          (retval & VFF_FILEINUSE) ? "VFF_FILEINUSE " : "",
+          (retval & VFF_BUFFTOOSMALL) ? "VFF_BUFFTOOSMALL " : "",
+          debugstr_a(lpszCurDir), debugstr_a(lpszDestDir));
 
     return retval;
 }
 
-/* VerFindFile32W                                               [VERSION.6] */
-DWORD WINAPI VerFindFileW(
-        UINT flags,LPCWSTR filename,LPCWSTR windir,LPCWSTR appdir,
-        LPWSTR curdir,UINT *pcurdirlen,LPWSTR destdir,UINT *pdestdirlen )
+/*****************************************************************************
+ * VerFindFileW                                         [VERSION.@]
+ */
+DWORD WINAPI VerFindFileW( UINT flags,LPCWSTR lpszFilename,LPCWSTR lpszWinDir,
+                           LPCWSTR lpszAppDir, LPWSTR lpszCurDir,UINT *lpuCurDirLen,
+                           LPWSTR lpszDestDir,UINT *lpuDestDirLen )
 {
-    UINT curdirlen, destdirlen;
-    LPSTR wfn,wwd,wad,wdd,wcd;
-    DWORD ret;
-
-    wfn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
-    wwd = HEAP_strdupWtoA( GetProcessHeap(), 0, windir );
-    wad = HEAP_strdupWtoA( GetProcessHeap(), 0, appdir );
-    wcd = HeapAlloc( GetProcessHeap(), 0, *pcurdirlen );
-    wdd = HeapAlloc( GetProcessHeap(), 0, *pdestdirlen );
-    ret = VerFindFileA(flags,wfn,wwd,wad,wcd,&curdirlen,wdd,&destdirlen);
-    lstrcpynAtoW(curdir,wcd,*pcurdirlen);
-    lstrcpynAtoW(destdir,wdd,*pdestdirlen);
-    *pcurdirlen = strlen(wcd);
-    *pdestdirlen = strlen(wdd);
-    HeapFree( GetProcessHeap(), 0, wfn );
-    HeapFree( GetProcessHeap(), 0, wwd );
-    HeapFree( GetProcessHeap(), 0, wad );
-    HeapFree( GetProcessHeap(), 0, wcd );
-    HeapFree( GetProcessHeap(), 0, wdd );
-    return ret;
+    static const WCHAR emptyW;
+    DWORD retval = 0;
+    const WCHAR *curDir;
+    const WCHAR *destDir;
+    unsigned int curDirSizeReq;
+    unsigned int destDirSizeReq;
+    WCHAR systemDir[MAX_PATH];
+
+    /* Print out debugging information */
+    TRACE("flags = %x filename=%s windir=%s appdir=%s curdirlen=%p(%u) destdirlen=%p(%u)\n",
+          flags, debugstr_w(lpszFilename), debugstr_w(lpszWinDir), debugstr_w(lpszAppDir),
+          lpuCurDirLen, lpuCurDirLen ? *lpuCurDirLen : 0,
+          lpuDestDirLen, lpuDestDirLen ? *lpuDestDirLen : 0 );
+
+    /* Figure out where the file should go; shared files default to the
+       system directory */
+
+    GetSystemDirectoryW(systemDir, sizeof(systemDir)/sizeof(WCHAR));
+    curDir = &emptyW;
+    destDir = &emptyW;
+
+    if(flags & VFFF_ISSHAREDFILE)
+    {
+        destDir = systemDir;
+        /* Were we given a filename?  If so, try to find the file. */
+        if(lpszFilename)
+        {
+            if(testFileExistenceW(destDir, lpszFilename, FALSE)) curDir = destDir;
+            else if(lpszAppDir && testFileExistenceW(lpszAppDir, lpszFilename, FALSE))
+            {
+                curDir = lpszAppDir;
+                retval |= VFF_CURNEDEST;
+            }
+        }
+    }
+    else /* not a shared file */
+    {
+        if(lpszAppDir)
+        {
+            destDir = lpszAppDir;
+            if(lpszFilename)
+            {
+                if(testFileExistenceW(destDir, lpszFilename, FALSE)) curDir = destDir;
+                else if(testFileExistenceW(systemDir, lpszFilename, FALSE))
+                {
+                    curDir = systemDir;
+                    retval |= VFF_CURNEDEST;
+                }
+            }
+        }
+    }
+
+    if (lpszFilename && !testFileExistenceW(curDir, lpszFilename, TRUE))
+        retval |= VFF_FILEINUSE;
+
+    curDirSizeReq = strlenW(curDir) + 1;
+    destDirSizeReq = strlenW(destDir) + 1;
+
+    /* Make sure that the pointers to the size of the buffers are
+       valid; if not, do NOTHING with that buffer.  If that pointer
+       is valid, then make sure that the buffer pointer is valid, too! */
+
+    if(lpuDestDirLen && lpszDestDir)
+    {
+        if (*lpuDestDirLen < destDirSizeReq) retval |= VFF_BUFFTOOSMALL;
+        lstrcpynW(lpszDestDir, destDir, *lpuDestDirLen);
+        *lpuDestDirLen = destDirSizeReq;
+    }
+    if(lpuCurDirLen && lpszCurDir)
+    {
+        if(*lpuCurDirLen < curDirSizeReq) retval |= VFF_BUFFTOOSMALL;
+        lstrcpynW(lpszCurDir, curDir, *lpuCurDirLen);
+        *lpuCurDirLen = curDirSizeReq;
+    }
+
+    TRACE("ret = %lu (%s%s%s) curdir=%s destdir=%s\n", retval,
+          (retval & VFF_CURNEDEST) ? "VFF_CURNEDEST " : "",
+          (retval & VFF_FILEINUSE) ? "VFF_FILEINUSE " : "",
+          (retval & VFF_BUFFTOOSMALL) ? "VFF_BUFFTOOSMALL " : "",
+          debugstr_w(lpszCurDir), debugstr_w(lpszDestDir));
+    return retval;
 }
 
@@ -355 +312 @@
 
     alloclen = 1000;
-    buf= xmalloc(alloclen);
+    buf=HeapAlloc(GetProcessHeap(), 0, alloclen);
+    if(buf == NULL) {
+        WARN("Memory exausted while fetching version info!\n");
+        return NULL;
+    }
     while (1) {
         ret = GetFileVersionInfoA(fn,0,alloclen,buf);
         if (!ret) {
-            free(buf);
-            return 0;
+            HeapFree(GetProcessHeap(), 0, buf);
+            return NULL;
         }
         if (alloclen<*(WORD*)buf) {
-            free(buf);
             alloclen = *(WORD*)buf;
-            buf = xmalloc(alloclen);
+            HeapFree(GetProcessHeap(), 0, buf);
+            buf = HeapAlloc(GetProcessHeap(), 0, alloclen);
+            if(buf == NULL) {
+               WARN("Memory exausted while fetching version info!\n");
+               return NULL;
+            }
         } else {
             *vffi = (VS_FIXEDFILEINFO*)(buf+0x14);
@@ -391 +356 @@
 
 /******************************************************************************
- * VerInstallFile32A [VERSION.7]
+ * VerInstallFileA [VERSION.@]
  */
 DWORD WINAPI VerInstallFileA(
@@ -413 +378 @@
     sprintf(destfn,"%s\\%s",pdest,destfilename);
     hfsrc=LZOpenFileA(srcfn,&ofs,OF_READ);
-    if (hfsrc==HFILE_ERROR)
+    if (hfsrc < 0)
         return VIF_CANNOTREADSRC;
     sprintf(tmpfn,"%s\\%s",pdest,destfilename);
     tmplast=strlen(pdest)+1;
     attr = GetFileAttributesA(tmpfn);
-    if (attr!=-1) {
+    if (attr != INVALID_FILE_ATTRIBUTES) {
         if (attr & FILE_ATTRIBUTE_READONLY) {
             LZClose(hfsrc);
@@ -425 +390 @@
         /* FIXME: check if file currently in use and return VIF_FILEINUSE */
     }
-    attr = -1;
+    attr = INVALID_FILE_ATTRIBUTES;
     if (flags & VIFF_FORCEINSTALL) {
         if (tmpfile[0]) {
@@ -432 +397 @@
             attr = GetFileAttributesA(tmpfn);
             /* if it exists, it has been copied by the call before.
-             * we jump over the copy part... 
+             * we jump over the copy part...
              */
         }
     }
-    if (attr == -1) {
+    if (attr == INVALID_FILE_ATTRIBUTES) {
         char    *s;
 
@@ -463 +428 @@
             case LZERROR_BADOUTHANDLE:
             case LZERROR_WRITE:
-                ret = VIF_OUTOFMEMORY; /* FIXME: correct? */
+                ret = VIF_OUTOFSPACE;
                 break;
             case LZERROR_GLOBALLOC:
             case LZERROR_GLOBLOCK:
-                ret = VIF_OUTOFSPACE;
+                ret = VIF_OUTOFMEMORY;
                 break;
             default: /* unknown error, should not happen */
@@ -506 +471 @@
                     VerQueryValueA(buf2,"\\VarFileInfo\\Translation",(LPVOID*)&tbuf2,&len2)
                 ) {
-                    /* irgendwas mit tbuf1 und tbuf2 machen 
+                    /* irgendwas mit tbuf1 und tbuf2 machen
                      * generiert DIFFLANG|MISMATCH
                      */
                 }
-                free(buf2);
+                HeapFree(GetProcessHeap(), 0, buf2);
             } else
                 xret=VIF_MISMATCH|VIF_SRCOLD;
-            free(buf1);
+            HeapFree(GetProcessHeap(), 0, buf1);
         }
     }
@@ -533 +498 @@
                 return xret;
             }
-        if ((!(flags & VIFF_DONTDELETEOLD))     && 
-            curdir                              && 
+        if ((!(flags & VIFF_DONTDELETEOLD))     &&
+            curdir                              &&
             *curdir                             &&
             lstrcmpiA(curdir,pdest)
@@ -541 +506 @@
 
             sprintf(curfn,"%s\\%s",curdir,destfilename);
-            if (-1!=GetFileAttributesA(curfn)) {
+            if (INVALID_FILE_ATTRIBUTES != GetFileAttributesA(curfn)) {
                 /* FIXME: check if in use ... if it is, VIF_CANNOTDELETECUR */
                 if (!DeleteFileA(curfn))
@@ -557 +522 @@
 
 
-/* VerInstallFile32W                            [VERSION.8] */
+/******************************************************************************
+ * VerInstallFileW                              [VERSION.@]
+ */
 DWORD WINAPI VerInstallFileW(
         UINT flags,LPCWSTR srcfilename,LPCWSTR destfilename,LPCWSTR srcdir,
         LPCWSTR destdir,LPCWSTR curdir,LPWSTR tmpfile,UINT *tmpfilelen )
 {
-    LPSTR wsrcf,wsrcd,wdestf,wdestd,wtmpf,wcurd;
+    LPSTR wsrcf = NULL, wsrcd = NULL, wdestf = NULL, wdestd = NULL, wtmpf = NULL, wcurd = NULL;
     DWORD ret;
-
-    wsrcf  = HEAP_strdupWtoA( GetProcessHeap(), 0, srcfilename );
-    wsrcd  = HEAP_strdupWtoA( GetProcessHeap(), 0, srcdir );
-    wdestf = HEAP_strdupWtoA( GetProcessHeap(), 0, destfilename );
-    wdestd = HEAP_strdupWtoA( GetProcessHeap(), 0, destdir );
-    wtmpf  = HEAP_strdupWtoA( GetProcessHeap(), 0, tmpfile );
-    wcurd  = HEAP_strdupWtoA( GetProcessHeap(), 0, curdir );
-    ret = VerInstallFileA(flags,wsrcf,wdestf,wsrcd,wdestd,wcurd,wtmpf,tmpfilelen);
+    UINT len;
+
+    if (srcfilename)
+    {
+        len = WideCharToMultiByte( CP_ACP, 0, srcfilename, -1, NULL, 0, NULL, NULL );
+        if ((wsrcf = HeapAlloc( GetProcessHeap(), 0, len )))
+            WideCharToMultiByte( CP_ACP, 0, srcfilename, -1, wsrcf, len, NULL, NULL );
+    }
+    if (srcdir)
+    {
+        len = WideCharToMultiByte( CP_ACP, 0, srcdir, -1, NULL, 0, NULL, NULL );
+        if ((wsrcd = HeapAlloc( GetProcessHeap(), 0, len )))
+            WideCharToMultiByte( CP_ACP, 0, srcdir, -1, wsrcd, len, NULL, NULL );
+    }
+    if (destfilename)
+    {
+        len = WideCharToMultiByte( CP_ACP, 0, destfilename, -1, NULL, 0, NULL, NULL );
+        if ((wdestf = HeapAlloc( GetProcessHeap(), 0, len )))
+            WideCharToMultiByte( CP_ACP, 0, destfilename, -1, wdestf, len, NULL, NULL );
+    }
+    if (destdir)
+    {
+        len = WideCharToMultiByte( CP_ACP, 0, destdir, -1, NULL, 0, NULL, NULL );
+        if ((wdestd = HeapAlloc( GetProcessHeap(), 0, len )))
+            WideCharToMultiByte( CP_ACP, 0, destdir, -1, wdestd, len, NULL, NULL );
+    }
+    if (curdir)
+    {
+        len = WideCharToMultiByte( CP_ACP, 0, curdir, -1, NULL, 0, NULL, NULL );
+        if ((wcurd = HeapAlloc( GetProcessHeap(), 0, len )))
+            WideCharToMultiByte( CP_ACP, 0, curdir, -1, wcurd, len, NULL, NULL );
+    }
+    len = *tmpfilelen * sizeof(WCHAR);
+    wtmpf = HeapAlloc( GetProcessHeap(), 0, len );
+    ret = VerInstallFileA(flags,wsrcf,wdestf,wsrcd,wdestd,wcurd,wtmpf,&len);
     if (!ret)
-        lstrcpynAtoW(tmpfile,wtmpf,*tmpfilelen);
+        *tmpfilelen = MultiByteToWideChar( CP_ACP, 0, wtmpf, -1, tmpfile, *tmpfilelen );
+    else if (ret & VIF_BUFFTOOSMALL)
+        *tmpfilelen = len;  /* FIXME: not correct */
+
     HeapFree( GetProcessHeap(), 0, wsrcf );
     HeapFree( GetProcessHeap(), 0, wsrcd );
@@ -579 +576 @@
     HeapFree( GetProcessHeap(), 0, wdestd );
     HeapFree( GetProcessHeap(), 0, wtmpf );
-    if (wcurd) 
-        HeapFree( GetProcessHeap(), 0, wcurd );
+    HeapFree( GetProcessHeap(), 0, wcurd );
     return ret;
 }
-

trunk/src/version/makefile

@@ -1 @@
-# $Id: makefile,v 1.20 2003-01-15 10:42:50 sandervl Exp $
+# $Id: makefile,v 1.21 2003-10-24 14:47:25 sandervl Exp $
 
 #
@@ -6 +6 @@
 #       version.dll makefile
 #
+
+!if "$(DEBUG)" == "1"
+DEFFILE    = versiondbg.def
+ORGDEFFILE = version.def
+!endif
 
 
@@ -18 +23 @@
 #
 OBJS = \
-$(OBJDIR)\version.obj \
 $(OBJDIR)\install.obj \
 $(OBJDIR)\info.obj \
+$(OBJDIR)\resource.obj \
+!ifdef DEBUG
+$(OBJDIR)\dbgwrap.obj \
+!endif
 $(OBJDIR)\versionrsrc.obj \
 $(DLLENTRY)