Ignore:
Timestamp:
Jun 9, 1999, 6:37:10 PM (26 years ago)
Author:
phaller
Message:

Add: ported VERSION from WINE, enables a few installers to run

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/version/version.cpp

    r53 r78  
    1 /*
    2  *
    3  * Project Odin Software License can be found in LICENSE.TXT
    4  *
    5  */
    61/*
    72 * Win32 Version resource APIs for OS/2
    83 *
    9  * 18-07-1998 SvL: Initial version
    10  *
    11  * Copyright 1998 Sander van Leeuwen (sandervl@xs4all.nl)
    12  *
     4 * Implementation of VERSION.DLL - File Installer routines
     5 * Copyright 1996,1997 Marcus Meissner
     6 * Copyright 1997      David Cuthbert
     7 * Copyright 1998      Sander van Leeuwen (sandervl@xs4all.nl)
     8 *
     9 * Project Odin Software License can be found in LICENSE.TXT
    1310 */
     11
     12
    1413#include <os2win.h>
    1514#include <stdio.h>
    1615#include <stdlib.h>
    1716#include <string.h>
    18 #include "misc.h"
    19 #include "unicode.h"
    20 
    21 /******************************************************************************/
    22 /******************************************************************************/
    23 BOOL WIN32API GetFileVersionInfoA(LPTSTR lpszFile, DWORD dwHandle, DWORD cbBuf, LPVOID lpvData)
    24 {
    25    dprintf(("GetFileVersionInfoA %s\n", lpszFile));
    26    return GetVersionStruct(lpszFile, (char *)lpvData, cbBuf);
    27 }
    28 /******************************************************************************/
    29 /******************************************************************************/
    30 BOOL WIN32API GetFileVersionInfoW(LPWSTR lpszFile, DWORD dwHandle, DWORD cbBuf, LPVOID lpvData)
    31 {
    32  BOOL  rc;
    33  char *astring = UnicodeToAsciiString(lpszFile);
    34 
    35    dprintf(("GetFileVersionInfoW\n"));
    36    rc = GetVersionStruct(astring, (char *)lpvData, cbBuf);
    37    FreeAsciiString(astring);
    38    return(rc);
    39 }
    40 /******************************************************************************/
    41 /******************************************************************************/
    42 DWORD WIN32API GetFileVersionInfoSizeA(LPTSTR lpszFile, LPDWORD lpdwHandle)
    43 {
    44    dprintf(("GetFileVersionInfoSizeA %s\n", lpszFile));
    45    
    46    if(lpdwHandle) {
    47         lpdwHandle = 0;
     17#include <misc.h>
     18#include <unicode.h>
     19#include "version.h"
     20
     21#include "lzexpand.h"
     22
     23
     24/*
     25#include "winver.h"
     26#include "windef.h"
     27*/
     28
     29
     30/******************************************************************************/
     31/******************************************************************************/
     32BOOL WIN32API VERSION_GetFileVersionInfoA(LPTSTR lpszFile,
     33                                          DWORD  dwHandle,
     34                                          DWORD  cbBuf,
     35                                          LPVOID lpvData)
     36{
     37   dprintf(("VERSION: GetFileVersionInfoA %s\n",
     38            lpszFile));
     39
     40   return GetVersionStruct(lpszFile,
     41                           (char *)lpvData,
     42                           cbBuf);
     43}
     44/******************************************************************************/
     45/******************************************************************************/
     46BOOL WIN32API VERSION_GetFileVersionInfoW(LPWSTR lpszFile,
     47                                          DWORD  dwHandle,
     48                                          DWORD  cbBuf,
     49                                          LPVOID lpvData)
     50{
     51  BOOL  rc;
     52  char *astring = UnicodeToAsciiString(lpszFile);
     53
     54  dprintf(("VERSION: GetFileVersionInfoW (%s,%08xh,%08xh,%08xh)\n",
     55           lpszFile,
     56           dwHandle,
     57           cbBuf,
     58           lpvData));
     59
     60  rc = GetVersionStruct(astring, (char *)lpvData, cbBuf);
     61  FreeAsciiString(astring);
     62  return(rc);
     63}
     64/******************************************************************************/
     65/******************************************************************************/
     66DWORD WIN32API VERSION_GetFileVersionInfoSizeA(LPTSTR  lpszFile,
     67                                               LPDWORD lpdwHandle)
     68{
     69  dprintf(("VERSION: GetFileVersionInfoSizeA(%s,%08xh)\n",
     70           lpszFile,
     71           lpdwHandle));
     72
     73  if(lpdwHandle)
     74    lpdwHandle = 0;
     75
     76  return GetVersionSize(lpszFile);
     77}
     78/******************************************************************************/
     79/******************************************************************************/
     80DWORD WIN32API VERSION_GetFileVersionInfoSizeW(LPWSTR  lpszFile,
     81                                               LPDWORD lpdwHandle)
     82{
     83 char  *astring = UnicodeToAsciiString(lpszFile);
     84 DWORD rc;
     85
     86 dprintf(("VERSION: GetFileVersionInfoSizeW(%08xh,%08xh)\n",
     87          lpszFile,
     88          lpdwHandle));
     89
     90 if(lpdwHandle)
     91   lpdwHandle = 0;
     92
     93 rc = GetVersionSize(astring);
     94 FreeAsciiString(astring);
     95 return(rc);
     96}
     97/******************************************************************************/
     98/******************************************************************************/
     99BOOL WIN32API VERSION_VerQueryValueA(const LPVOID pBlock,
     100                                     LPTSTR       lpSubBlock,
     101                                     LPVOID       lplpBuffer,
     102                                     PUINT        puLen)
     103{
     104  dprintf(("VERSION: VerQueryValueA(%08xh,%08xh,%08xh,%08xh) not implemented\n",
     105           pBlock,
     106           lpSubBlock,
     107           lplpBuffer,
     108           puLen));
     109
     110   return TRUE;
     111}
     112/******************************************************************************/
     113/******************************************************************************/
     114/*KSO Sun 24.05.1998*/
     115BOOL WIN32API VERSION_VerQueryValueW(const LPVOID pBlock,
     116                                     LPWSTR       lpSubBlock,
     117                                     LPVOID       lplpBuffer,
     118                                     PUINT        puLen)
     119{
     120   dprintf(("VERSION: VerQueryValueW(%08xh,%08xh,%08xh,%08xh) not implemented\n",
     121            pBlock,
     122            lpSubBlock,
     123            lplpBuffer,
     124            puLen));
     125
     126   return TRUE;
     127}
     128/******************************************************************************/
     129/******************************************************************************/
     130
     131
     132
     133/******************************************************************************
     134 *
     135 *   void  ver_dstring(
     136 *      char const * prologue,
     137 *      char const * teststring,
     138 *      char const * epilogue )
     139 *
     140 *   This function will print via dprintf[_]ver to stddeb the prologue string,
     141 *   followed by the address of teststring and the string it contains if
     142 *   teststring is non-null or "(null)" otherwise, and then the epilogue
     143 *   string followed by a new line.
     144 *
     145 *   Revision history
     146 *      30-May-1997 Dave Cuthbert (dacut@ece.cmu.edu)
     147 *         Original implementation as dprintf[_]ver_string
     148 *      05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
     149 *         Fixed problem that caused bug with tools/make_debug -- renaming
     150 *         this function should fix the problem.
     151 *      15-Feb-1998 Dimitrie Paun (dimi@cs.toronto.edu)
     152 *         Modified it to make it print the message using only one
     153 *         dprintf[_]ver call.
     154 *
     155 *****************************************************************************/
     156
     157static void  ver_dstring(char const * prologue,
     158                         char const * teststring,
     159                         char const * epilogue )
     160{
     161  dprintf(("VERSION: ver_dstring(%s, %s, %s)\n",
     162           prologue,
     163           teststring,
     164           epilogue));
     165}
     166
     167
     168/******************************************************************************
     169 *
     170 *   int  testFileExistence(
     171 *      char const * path,
     172 *      char const * file )
     173 *
     174 *   Tests whether a given path/file combination exists.  If the file does
     175 *   not exist, the return value is zero.  If it does exist, the return
     176 *   value is non-zero.
     177 *
     178 *   Revision history
     179 *      30-May-1997 Dave Cuthbert (dacut@ece.cmu.edu)
     180 *         Original implementation
     181 *
     182 *****************************************************************************/
     183
     184static int  testFileExistence(char const * path,
     185                              char const * file )
     186{
     187  char      filename[1024];
     188  int       filenamelen;
     189  OFSTRUCT  fileinfo;
     190  int       retval;
     191
     192  fileinfo.cBytes = sizeof(OFSTRUCT);
     193
     194  strcpy(filename, path);
     195  filenamelen = strlen(filename);
     196
     197  /* Add a trailing \ if necessary */
     198  if(filenamelen)
     199  {
     200    if(filename[filenamelen - 1] != '\\')
     201      strcat(filename, "\\");
     202  }
     203  else /* specify the current directory */
     204    strcpy(filename, ".\\");
     205
     206  /* Create the full pathname */
     207  strcat(filename, file);
     208
     209  if(OpenFile(filename, &fileinfo, OF_EXIST) == HFILE_ERROR)
     210    retval = 0;
     211  else
     212    retval = 1;
     213
     214  return  retval;
     215}
     216
     217
     218/******************************************************************************
     219 *
     220 *   int  testFileExclusiveExistence(
     221 *      char const * path,
     222 *      char const * file )
     223 *
     224 *   Tests whether a given path/file combination exists and ensures that no
     225 *   other programs have handles to the given file.  If the file does not
     226 *   exist or is open, the return value is zero.  If it does exist, the
     227 *   return value is non-zero.
     228 *
     229 *   Revision history
     230 *      30-May-1997 Dave Cuthbert (dacut@ece.cmu.edu)
     231 *         Original implementation
     232 *
     233 *****************************************************************************/
     234
     235static int  testFileExclusiveExistence(char const * path,
     236                                       char const * file )
     237{
     238  char      filename[1024];
     239  int       filenamelen;
     240  OFSTRUCT  fileinfo;
     241  int       retval;
     242
     243  fileinfo.cBytes = sizeof(OFSTRUCT);
     244
     245  strcpy(filename, path);
     246  filenamelen = strlen(filename);
     247
     248  /* Add a trailing \ if necessary */
     249  if(filenamelen)
     250  {
     251    if(filename[filenamelen - 1] != '\\')
     252      strcat(filename, "\\");
     253  }
     254  else /* specify the current directory */
     255    strcpy(filename, ".\\");
     256
     257  /* Create the full pathname */
     258  strcat(filename, file);
     259
     260  if(OpenFile(filename,
     261              &fileinfo,
     262              OF_EXIST | OF_SHARE_EXCLUSIVE) == HFILE_ERROR)
     263    retval = 0;
     264  else
     265    retval = 1;
     266
     267  return retval;
     268}
     269
     270
     271/*****************************************************************************
     272 *
     273 *   VerFindFile() [VER.8]
     274 *   Determines where to install a file based on whether it locates another
     275 *   version of the file in the system.  The values VerFindFile returns are
     276 *   used in a subsequent call to the VerInstallFile function.
     277 *
     278 *   Revision history:
     279 *      30-May-1997   Dave Cuthbert (dacut@ece.cmu.edu)
     280 *         Reimplementation of VerFindFile from original stub.
     281 *
     282 ****************************************************************************/
     283
     284/* VerFindFile32A                                    [VERSION.5] */
     285DWORD WIN32API VERSION_VerFindFileA(UINT flags,
     286                                    LPCSTR lpszFilename,
     287                                    LPCSTR lpszWinDir,
     288                                    LPCSTR lpszAppDir,
     289                                    LPSTR lpszCurDir,
     290                                    UINT *lpuCurDirLen,
     291                                    LPSTR lpszDestDir,
     292                                    UINT *lpuDestDirLen )
     293{
     294  DWORD  retval;
     295  char  curDir[256];
     296  char  destDir[256];
     297  unsigned int  curDirSizeReq;
     298  unsigned int  destDirSizeReq;
     299
     300  retval = 0;
     301
     302  /* Print out debugging information */
     303  dprintf(("VERSION: VerFindFileA(%08xh,%s,%s,%s,%08xh,%08xh,%08xh,%08xh)\n",
     304           flags,
     305           lpszFilename,
     306           lpszWinDir,
     307           lpszAppDir,
     308           lpszCurDir,
     309           lpuCurDirLen,
     310           lpszDestDir,
     311           lpuDestDirLen));
     312
     313  ver_dstring("\tlpszFilename = ", lpszFilename, "");
     314  ver_dstring("\tlpszWinDir = ", lpszWinDir, "");
     315  ver_dstring("\tlpszAppDir = ", lpszAppDir, "");
     316
     317  /* Figure out where the file should go; shared files default to the
     318     system directory */
     319
     320  strcpy(curDir, "");
     321  strcpy(destDir, "");
     322
     323  if(flags & VFFF_ISSHAREDFILE)
     324  {
     325    GetSystemDirectoryA(destDir, 256);
     326
     327    /* Were we given a filename?  If so, try to find the file. */
     328    if(lpszFilename)
     329    {
     330      if(testFileExistence(destDir, lpszFilename))
     331      {
     332        strcpy(curDir, destDir);
     333
     334        if(!testFileExclusiveExistence(destDir, lpszFilename))
     335          retval |= VFF_FILEINUSE;
     336      }
     337      else
     338        if(lpszAppDir && testFileExistence(lpszAppDir,
     339                      lpszFilename))
     340        {
     341          strcpy(curDir, lpszAppDir);
     342          retval |= VFF_CURNEDEST;
     343
     344          if(!testFileExclusiveExistence(lpszAppDir, lpszFilename))
     345            retval |= VFF_FILEINUSE;
     346        }
     347    }
     348  }
     349  else
     350    if(!(flags & VFFF_ISSHAREDFILE))
     351    { /* not a shared file */
     352      if(lpszAppDir)
     353      {
     354        char  systemDir[256];
     355        GetSystemDirectoryA(systemDir, 256);
     356
     357        strcpy(destDir, lpszAppDir);
     358
     359        if(lpszFilename)
     360        {
     361          if(testFileExistence(lpszAppDir, lpszFilename))
     362          {
     363            strcpy(curDir, lpszAppDir);
     364
     365            if(!testFileExclusiveExistence(lpszAppDir, lpszFilename))
     366              retval |= VFF_FILEINUSE;
     367          }
     368          else
     369            if(testFileExistence(systemDir, lpszFilename))
     370            {
     371              strcpy(curDir, systemDir);
     372              retval |= VFF_CURNEDEST;
     373
     374              if(!testFileExclusiveExistence(systemDir, lpszFilename))
     375                retval |= VFF_FILEINUSE;
     376            }
     377        }
     378      }
     379    }
     380
     381  curDirSizeReq = strlen(curDir) + 1;
     382  destDirSizeReq = strlen(destDir) + 1;
     383
     384
     385
     386  /* Make sure that the pointers to the size of the buffers are
     387     valid; if not, do NOTHING with that buffer.  If that pointer
     388     is valid, then make sure that the buffer pointer is valid, too! */
     389
     390  if(lpuDestDirLen && lpszDestDir)
     391  {
     392    if(*lpuDestDirLen < destDirSizeReq)
     393    {
     394      retval |= VFF_BUFFTOOSMALL;
     395      if (*lpuDestDirLen)
     396      {
     397        strncpy(lpszDestDir, destDir, *lpuDestDirLen - 1);
     398        lpszDestDir[*lpuDestDirLen - 1] = '\0';
     399      }
     400    }
     401    else
     402      strcpy(lpszDestDir, destDir);
     403
     404    *lpuDestDirLen = destDirSizeReq;
     405  }
     406
     407  if(lpuCurDirLen && lpszCurDir)
     408  {
     409    if(*lpuCurDirLen < curDirSizeReq)
     410    {
     411      retval |= VFF_BUFFTOOSMALL;
     412      if (*lpuCurDirLen)
     413      {
     414        strncpy(lpszCurDir, curDir, *lpuCurDirLen - 1);
     415        lpszCurDir[*lpuCurDirLen - 1] = '\0';
     416      }
     417    }
     418    else
     419      strcpy(lpszCurDir, curDir);
     420
     421    *lpuCurDirLen = curDirSizeReq;
     422  }
     423
     424  dprintf(("VERSION: VerFindFileA ret = %lu (%s%s%s)\n", retval,
     425     (retval & VFF_CURNEDEST) ? "VFF_CURNEDEST " : "",
     426     (retval & VFF_FILEINUSE) ? "VFF_FILEINUSE " : "",
     427     (retval & VFF_BUFFTOOSMALL) ? "VFF_BUFFTOOSMALL " : ""));
     428
     429  ver_dstring("\t(Exit) lpszCurDir = ", lpszCurDir, "");
     430
     431  return retval;
     432}
     433
     434/* VerFindFile32W                                    [VERSION.6] */
     435DWORD WIN32API VERSION_VerFindFileW(UINT   flags,
     436                                    LPWSTR filename,
     437                                    LPWSTR windir,
     438                                    LPWSTR appdir,
     439                                    LPWSTR curdir,
     440                                    UINT   *pcurdirlen,
     441                                    LPWSTR destdir,
     442                                    UINT   *pdestdirlen)
     443{
     444    UINT  curdirlen,
     445          destdirlen;
     446    LPSTR wfn,
     447          wwd,
     448          wad,
     449          wdd,
     450          wcd;
     451    DWORD ret;
     452
     453    wfn = UnicodeToAsciiString(filename );
     454    wwd = UnicodeToAsciiString(windir );
     455    wad = UnicodeToAsciiString(appdir );
     456    wcd = (LPSTR)HeapAlloc( GetProcessHeap(), 0, *pcurdirlen );
     457    wdd = (LPSTR)HeapAlloc( GetProcessHeap(), 0, *pdestdirlen );
     458
     459    ret = VERSION_VerFindFileA(flags,
     460                               wfn,
     461                               wwd,
     462                               wad,
     463                               wcd,
     464                               &curdirlen,
     465                               wdd,
     466                               &destdirlen);
     467
     468    AsciiToUnicodeN(wcd,curdir,*pcurdirlen);
     469    AsciiToUnicodeN(wdd,destdir,*pdestdirlen);
     470    *pcurdirlen = strlen(wcd);
     471    *pdestdirlen = strlen(wdd);
     472
     473    FreeAsciiString(wfn );
     474    FreeAsciiString(wwd );
     475    FreeAsciiString(wad );
     476    FreeAsciiString(wcd );
     477    FreeAsciiString(wdd );
     478    return ret;
     479}
     480
     481static LPBYTE _fetch_versioninfo(LPSTR fn,VS_FIXEDFILEINFO **vffi)
     482{
     483  DWORD   alloclen;
     484  LPBYTE  buf;
     485  DWORD   ret;
     486
     487  alloclen = 1000;
     488  buf = (LPBYTE)malloc(alloclen);
     489
     490  while (1)
     491  {
     492    ret = VERSION_GetFileVersionInfoA(fn,
     493                                      0,
     494                                      alloclen,
     495                                      buf);
     496    if (!ret)
     497    {
     498      free(buf);
     499      return 0;
     500    }
     501
     502    if (alloclen<*(WORD*)buf)
     503    {
     504      free(buf);
     505      alloclen = *(WORD*)buf;
     506      buf = (LPBYTE)malloc(alloclen);
     507    }
     508    else
     509    {
     510      *vffi = (VS_FIXEDFILEINFO*)(buf+0x14);
     511
     512      if ((*vffi)->dwSignature == 0x004f0049) /* hack to detect unicode */
     513        *vffi = (VS_FIXEDFILEINFO*)(buf+0x28);
     514
     515      if ((*vffi)->dwSignature != VS_FFI_SIGNATURE)
     516        dprintf(("VERSION: _fetch_versioninfo: Bad VS_FIXEDFILEINFO signature 0x%08lx\n",
     517                 (*vffi)->dwSignature));
     518
     519      return buf;
    48520   }
    49    return GetVersionSize(lpszFile);
    50 }
    51 /******************************************************************************/
    52 /******************************************************************************/
    53 DWORD WIN32API GetFileVersionInfoSizeW(LPWSTR lpszFile, LPDWORD lpdwHandle)
    54 {
    55  char *astring = UnicodeToAsciiString(lpszFile);
    56  DWORD rc;
    57 
    58    dprintf(("GetFileVersionInfoSizeW\n"));
    59    if(lpdwHandle) {
    60         lpdwHandle = 0;
     521  }
     522}
     523
     524static DWORD _error2vif(DWORD error)
     525{
     526  switch (error)
     527  {
     528    case ERROR_ACCESS_DENIED:
     529      return VIF_ACCESSVIOLATION;
     530
     531    case ERROR_SHARING_VIOLATION:
     532      return VIF_SHARINGVIOLATION;
     533
     534    default:
     535      return 0;
     536  }
     537}
     538
     539
     540/******************************************************************************
     541 * VerInstallFile32A [VERSION.7]
     542 */
     543DWORD WIN32API VERSION_VerInstallFileA(UINT   flags,
     544                                       LPCSTR srcfilename,
     545                                       LPCSTR destfilename,
     546                                       LPCSTR srcdir,
     547                                       LPCSTR destdir,
     548                                       LPCSTR curdir,
     549                                       LPSTR  tmpfile,
     550                                       UINT   *tmpfilelen )
     551{
     552    LPCSTR   pdest;
     553    char     destfn[260],
     554             tmpfn[260],
     555             srcfn[260];
     556    HFILE    hfsrc,
     557             hfdst;
     558    DWORD    attr,
     559             ret,
     560             xret,
     561             tmplast;
     562    LPBYTE   buf1,buf2;
     563    OFSTRUCT ofs;
     564
     565    dprintf(("VERSION: VerInstallFileA(%x,%s,%s,%s,%s,%s,%p,%d)\n",
     566             flags,
     567             srcfilename,
     568             destfilename,
     569             srcdir,
     570             destdir,
     571             curdir,
     572             tmpfile,
     573             *tmpfilelen));
     574
     575#if 1
     576  dprintf(("VERSION: VersInstallFileA not implemented\n"));
     577
     578  return 0;
     579#else
     580    xret = 0;
     581
     582    sprintf(srcfn,
     583            "%s\\%s",
     584            srcdir,
     585            srcfilename);
     586
     587    if (!destdir || !*destdir)
     588      pdest = srcdir;
     589    else
     590      pdest = destdir;
     591
     592    sprintf(destfn,
     593            "%s\\%s",
     594            pdest,
     595            destfilename);
     596
     597    hfsrc=LZOpenFileA(srcfn,
     598                      &ofs,
     599                      OF_READ);
     600
     601    if (hfsrc==HFILE_ERROR)
     602      return VIF_CANNOTREADSRC;
     603
     604    sprintf(tmpfn,"%s\\%s",pdest,destfilename);
     605    tmplast=strlen(pdest)+1;
     606    attr = GetFileAttributesA(tmpfn);
     607    if (attr!=-1) {
     608   if (attr & FILE_ATTRIBUTE_READONLY) {
     609       LZClose(hfsrc);
     610       return VIF_WRITEPROT;
    61611   }
    62    rc = GetVersionSize(astring);
    63    FreeAsciiString(astring);
    64    return(rc);
    65 }
    66 /******************************************************************************/
    67 /******************************************************************************/
    68 BOOL WIN32API VerQueryValueA(const LPVOID pBlock, LPTSTR lpSubBlock,
    69                                  LPVOID lplpBuffer, PUINT puLen)
    70 {
    71    dprintf(("VerQueryValueA Not implemented\n"));
    72    return TRUE;
    73 }
    74 /******************************************************************************/
    75 /******************************************************************************/
    76 /*KSO Sun 24.05.1998*/
    77 BOOL WIN32API VerQueryValueW(const LPVOID pBlock, LPWSTR lpSubBlock,
    78                                  LPVOID lplpBuffer, PUINT puLen)
    79 {
    80    dprintf(("VerQueryValueW Not implemented\n"));
    81    return TRUE;
    82 }
    83 /******************************************************************************/
    84 /******************************************************************************/
    85 
    86 
    87 
     612   /* FIXME: check if file currently in use and return VIF_FILEINUSE */
     613    }
     614    attr = -1;
     615    if (flags & VIFF_FORCEINSTALL) {
     616      if (tmpfile[0]) {
     617       sprintf(tmpfn,"%s\\%s",pdest,tmpfile);
     618       tmplast = strlen(pdest)+1;
     619       attr = GetFileAttributesA(tmpfn);
     620       /* if it exists, it has been copied by the call before.
     621        * we jump over the copy part...
     622        */
     623   }
     624    }
     625    if (attr == -1) {
     626      char  *s;
     627
     628   GetTempFileNameA(pdest,"ver",0,tmpfn); /* should not fail ... */
     629   s=strrchr(tmpfn,'\\');
     630   if (s)
     631       tmplast = s-tmpfn;
     632   else
     633       tmplast = 0;
     634   hfdst = OpenFile(tmpfn,&ofs,OF_CREATE);
     635   if (hfdst == HFILE_ERROR) {
     636       LZClose(hfsrc);
     637       return VIF_CANNOTCREATE; /* | translated dos error */
     638   }
     639   ret = LZCopy(hfsrc,hfdst);
     640   _lclose(hfdst);
     641   if (((long) ret) < 0) {
     642       /* translate LZ errors into VIF_xxx */
     643       switch (ret) {
     644       case LZERROR_BADINHANDLE:
     645       case LZERROR_READ:
     646       case LZERROR_BADVALUE:
     647       case LZERROR_UNKNOWNALG:
     648      ret = VIF_CANNOTREADSRC;
     649      break;
     650       case LZERROR_BADOUTHANDLE:
     651       case LZERROR_WRITE:
     652      ret = VIF_OUTOFMEMORY; /* FIXME: correct? */
     653      break;
     654       case LZERROR_GLOBALLOC:
     655       case LZERROR_GLOBLOCK:
     656      ret = VIF_OUTOFSPACE;
     657      break;
     658       default: /* unknown error, should not happen */
     659      ret = 0;
     660      break;
     661       }
     662       if (ret) {
     663      LZClose(hfsrc);
     664      return ret;
     665       }
     666   }
     667    }
     668    xret = 0;
     669    if (!(flags & VIFF_FORCEINSTALL)) {
     670   VS_FIXEDFILEINFO *destvffi,*tmpvffi;
     671      buf1 = _fetch_versioninfo(destfn,&destvffi);
     672   if (buf1) {
     673       buf2 = _fetch_versioninfo(tmpfn,&tmpvffi);
     674       if (buf2) {
     675         char  *tbuf1,*tbuf2;
     676      UINT  len1,len2;
     677
     678      len1=len2=40;
     679
     680      /* compare file versions */
     681      if ((destvffi->dwFileVersionMS > tmpvffi->dwFileVersionMS)||
     682          ((destvffi->dwFileVersionMS==tmpvffi->dwFileVersionMS)&&
     683           (destvffi->dwFileVersionLS > tmpvffi->dwFileVersionLS)
     684          )
     685      )
     686          xret |= VIF_MISMATCH|VIF_SRCOLD;
     687      /* compare filetypes and filesubtypes */
     688      if ((destvffi->dwFileType!=tmpvffi->dwFileType) ||
     689          (destvffi->dwFileSubtype!=tmpvffi->dwFileSubtype)
     690      )
     691          xret |= VIF_MISMATCH|VIF_DIFFTYPE;
     692      if (VerQueryValueA(buf1,"\\VarFileInfo\\Translation",(LPVOID*)&tbuf1,&len1) &&
     693          VerQueryValueA(buf2,"\\VarFileInfo\\Translation",(LPVOID*)&tbuf2,&len2)
     694      ) {
     695          /* irgendwas mit tbuf1 und tbuf2 machen
     696           * generiert DIFFLANG|MISMATCH
     697           */
     698      }
     699      free(buf2);
     700       } else
     701      xret=VIF_MISMATCH|VIF_SRCOLD;
     702       free(buf1);
     703   }
     704    }
     705    if (xret) {
     706   if (*tmpfilelen<strlen(tmpfn+tmplast)) {
     707       xret|=VIF_BUFFTOOSMALL;
     708       DeleteFileA(tmpfn);
     709   } else {
     710       strcpy(tmpfile,tmpfn+tmplast);
     711       *tmpfilelen = strlen(tmpfn+tmplast)+1;
     712       xret|=VIF_TEMPFILE;
     713   }
     714    } else {
     715      if (-1!=GetFileAttributesA(destfn))
     716       if (!DeleteFileA(destfn)) {
     717      xret|=_error2vif(GetLastError())|VIF_CANNOTDELETE;
     718      DeleteFileA(tmpfn);
     719      LZClose(hfsrc);
     720      return xret;
     721       }
     722   if ((!(flags & VIFF_DONTDELETEOLD))   &&
     723       curdir                               &&
     724       *curdir                              &&
     725       lstrcmpiA(curdir,pdest)
     726   ) {
     727       char curfn[260];
     728
     729       sprintf(curfn,"%s\\%s",curdir,destfilename);
     730       if (-1!=GetFileAttributesA(curfn)) {
     731      /* FIXME: check if in use ... if it is, VIF_CANNOTDELETECUR */
     732      if (!DeleteFileA(curfn))
     733             xret|=_error2vif(GetLastError())|VIF_CANNOTDELETECUR;
     734       }
     735   }
     736   if (!MoveFileA(tmpfn,destfn)) {
     737       xret|=_error2vif(GetLastError())|VIF_CANNOTRENAME;
     738       DeleteFileA(tmpfn);
     739   }
     740    }
     741    LZClose(hfsrc);
     742    return xret;
     743#endif
     744}
     745
     746
     747/* VerInstallFile32W                              [VERSION.8] */
     748DWORD WIN32API VERSION_VerInstallFileW(UINT   flags,
     749                                       LPWSTR srcfilename,
     750                                       LPWSTR destfilename,
     751                                       LPWSTR srcdir,
     752                                       LPWSTR destdir,
     753                                       LPWSTR curdir,
     754                                       LPWSTR tmpfile,
     755                                       UINT   *tmpfilelen )
     756{
     757    LPSTR wsrcf,
     758          wsrcd,
     759          wdestf,
     760          wdestd,
     761          wtmpf,
     762          wcurd;
     763    DWORD ret;
     764
     765    wsrcf  = UnicodeToAsciiString(srcfilename );
     766    wsrcd  = UnicodeToAsciiString(srcdir );
     767    wdestf = UnicodeToAsciiString(destfilename );
     768    wdestd = UnicodeToAsciiString(destdir );
     769    wtmpf  = UnicodeToAsciiString(tmpfile );
     770    wcurd  = UnicodeToAsciiString(curdir );
     771
     772    ret = VERSION_VerInstallFileA(flags,
     773                                  wsrcf,
     774                                  wdestf,
     775                                  wsrcd,
     776                                  wdestd,
     777                                  wcurd,
     778                                  wtmpf,
     779                                  tmpfilelen);
     780    if (!ret)
     781      AsciiToUnicodeN(wtmpf,
     782                      tmpfile,
     783                      *tmpfilelen);
     784
     785    FreeAsciiString(wsrcf);
     786    FreeAsciiString(wsrcd);
     787    FreeAsciiString(wdestf);
     788    FreeAsciiString(wdestd);
     789    FreeAsciiString(wtmpf);
     790
     791    if (wcurd)
     792      FreeAsciiString(wcurd);
     793
     794    return ret;
     795}
     796
     797
     798/***********************************************************************
     799 *           VerLanguageName32A              [VERSION.9]
     800 */
     801DWORD WIN32API VERSION_VerLanguageNameA(UINT  wLang,
     802                                        LPSTR szLang,
     803                                        UINT  nSize)
     804{
     805  char    buffer[80];
     806  LPCSTR  name;
     807  DWORD   result;
     808
     809  dprintf(("VERSION: VerLanguageNameA(%08xh,%08xh,%08xh) not implemented.\n",
     810           wLang,
     811           szLang,
     812           nSize));
     813
     814#if 0
     815  /*
     816   * First, check \System\CurrentControlSet\control\Nls\Locale\<langid>
     817   * from the registry.
     818   */
     819
     820  sprintf( buffer,
     821           "\\System\\CurrentControlSet\\control\\Nls\\Locale\\%08x",
     822           wLang );
     823
     824  result = RegQueryValueA(HKEY_LOCAL_MACHINE,
     825                          buffer,
     826                          szLang,
     827                          (LPDWORD)&nSize );
     828  if (result == ERROR_SUCCESS ||
     829      result == ERROR_MORE_DATA)
     830    return nSize;
     831
     832  /*
     833   * If that fails, use the internal table
     834   * (actually, Windows stores the names in a string table resource ...)
     835   */
     836
     837  name = WINE_GetLanguageName( wLang );
     838  lstrcpynA( szLang, name, nSize );
     839  return lstrlenA( name );
     840#endif
     841
     842  return 0;
     843}
     844
     845/***********************************************************************
     846 *           VerLanguageName32W              [VERSION.10]
     847 */
     848DWORD WIN32API VERSION_VerLanguageNameW(UINT   wLang,
     849                                        LPWSTR szLang,
     850                                        UINT   nSize )
     851{
     852  char    buffer[80];
     853  LPWSTR  keyname;
     854  LPCSTR  name;
     855  DWORD   result;
     856
     857  dprintf(("VERSION: VerLanguageNameW(%08xh,%08xh,%08xh) not implemented.\n",
     858           wLang,
     859           szLang,
     860           nSize));
     861
     862#if 0
     863  /*
     864   * First, check \System\CurrentControlSet\control\Nls\Locale\<langid>
     865   * from the registry.
     866   */
     867
     868  sprintf( buffer,
     869           "\\System\\CurrentControlSet\\control\\Nls\\Locale\\%08x",
     870           wLang );
     871
     872  keyname = HEAP_strdupAtoW( GetProcessHeap(), 0, buffer );
     873  result = RegQueryValueW( HKEY_LOCAL_MACHINE, keyname, szLang, (LPDWORD)&nSize );
     874  HeapFree( GetProcessHeap(), 0, keyname );
     875
     876  if (result == ERROR_SUCCESS ||
     877      result == ERROR_MORE_DATA)
     878    return nSize;
     879
     880  /*
     881   * If that fails, use the internal table
     882   * (actually, Windows stores the names in a string table resource ...)
     883   */
     884
     885  name = WINE_GetLanguageName( wLang );
     886  lstrcpynAtoW( szLang, name, nSize );
     887  return lstrlenA( name );
     888#else
     889  return 0;
     890#endif
     891}
     892
     893
Note: See TracChangeset for help on using the changeset viewer.