git.oblomov.eu Git - wine/blob - dlls/msi/appsearch.c

   1 /*
   2  * Implementation of the AppSearch action of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2005 Juan Lang
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winreg.h"
  27 #include "msi.h"
  28 #include "msiquery.h"
  29 #include "msidefs.h"
  30 #include "winver.h"
  31 #include "wine/unicode.h"
  32 #include "wine/debug.h"
  33 #include "msipriv.h"
  34 #include "action.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  37
  38 typedef struct tagMSISIGNATURE
  39 {
  40     LPCWSTR  Name;     /* NOT owned by this structure */
  41     LPWSTR   File;
  42     DWORD    MinVersionMS;
  43     DWORD    MinVersionLS;
  44     DWORD    MaxVersionMS;
  45     DWORD    MaxVersionLS;
  46     DWORD    MinSize;
  47     DWORD    MaxSize;
  48     FILETIME MinTime;
  49     FILETIME MaxTime;
  50     LPWSTR   Languages;
  51 }MSISIGNATURE;
  52
  53 static void ACTION_VerStrToInteger(LPCWSTR verStr, PDWORD ms, PDWORD ls)
  54 {
  55     const WCHAR *ptr;
  56     int x1 = 0, x2 = 0, x3 = 0, x4 = 0;
  57
  58     x1 = atoiW(verStr);
  59     ptr = strchrW(verStr, '.');
  60     if (ptr)
  61     {
  62         x2 = atoiW(ptr + 1);
  63         ptr = strchrW(ptr + 1, '.');
  64     }
  65     if (ptr)
  66     {
  67         x3 = atoiW(ptr + 1);
  68         ptr = strchrW(ptr + 1, '.');
  69     }
  70     if (ptr)
  71         x4 = atoiW(ptr + 1);
  72     /* FIXME: byte-order dependent? */
  73     *ms = x1 << 16 | x2;
  74     *ls = x3 << 16 | x4;
  75 }
  76
  77 /* Fills in sig with the the values from the Signature table, where name is the
  78  * signature to find.  Upon return, sig->File will be NULL if the record is not
  79  * found, and not NULL if it is found.
  80  * Warning: clears all fields in sig!
  81  * Returns ERROR_SUCCESS upon success (where not finding the record counts as
  82  * success), something else on error.
  83  */
  84 static UINT ACTION_AppSearchGetSignature(MSIPACKAGE *package, MSISIGNATURE *sig,
  85  LPCWSTR name)
  86 {
  87     MSIQUERY *view;
  88     UINT rc;
  89     static const WCHAR ExecSeqQuery[] =  {
  90    's','e','l','e','c','t',' ','*',' ',
  91    'f','r','o','m',' ',
  92    'S','i','g','n','a','t','u','r','e',' ',
  93    'w','h','e','r','e',' ','S','i','g','n','a','t','u','r','e',' ','=',' ',
  94    '\'','%','s','\'',0};
  95
  96     TRACE("(package %p, sig %p)\n", package, sig);
  97     memset(sig, 0, sizeof(*sig));
  98     sig->Name = name;
  99     rc = MSI_OpenQuery(package->db, &view, ExecSeqQuery, name);
 100     if (rc == ERROR_SUCCESS)
 101     {
 102         MSIRECORD *row = 0;
 103         DWORD time;
 104         WCHAR *minVersion, *maxVersion;
 105
 106         rc = MSI_ViewExecute(view, 0);
 107         if (rc != ERROR_SUCCESS)
 108         {
 109             TRACE("MSI_ViewExecute returned %d\n", rc);
 110             goto end;
 111         }
 112         rc = MSI_ViewFetch(view,&row);
 113         if (rc != ERROR_SUCCESS)
 114         {
 115             TRACE("MSI_ViewFetch returned %d\n", rc);
 116             rc = ERROR_SUCCESS;
 117             goto end;
 118         }
 119
 120         /* get properties */
 121         sig->File = msi_dup_record_field(row,2);
 122         minVersion = msi_dup_record_field(row,3);
 123         if (minVersion)
 124         {
 125             ACTION_VerStrToInteger(minVersion, &sig->MinVersionMS,
 126              &sig->MinVersionLS);
 127             msi_free( minVersion);
 128         }
 129         maxVersion = msi_dup_record_field(row,4);
 130         if (maxVersion)
 131         {
 132             ACTION_VerStrToInteger(maxVersion, &sig->MaxVersionMS,
 133              &sig->MaxVersionLS);
 134             msi_free( maxVersion);
 135         }
 136         sig->MinSize = MSI_RecordGetInteger(row,5);
 137         if (sig->MinSize == MSI_NULL_INTEGER)
 138             sig->MinSize = 0;
 139         sig->MaxSize = MSI_RecordGetInteger(row,6);
 140         if (sig->MaxSize == MSI_NULL_INTEGER)
 141             sig->MaxSize = 0;
 142         sig->Languages = msi_dup_record_field(row,9);
 143         time = MSI_RecordGetInteger(row,7);
 144         if (time != MSI_NULL_INTEGER)
 145             DosDateTimeToFileTime(HIWORD(time), LOWORD(time), &sig->MinTime);
 146         time = MSI_RecordGetInteger(row,8);
 147         if (time != MSI_NULL_INTEGER)
 148             DosDateTimeToFileTime(HIWORD(time), LOWORD(time), &sig->MaxTime);
 149         TRACE("Found file name %s for Signature_ %s;\n",
 150          debugstr_w(sig->File), debugstr_w(name));
 151         TRACE("MinVersion is %d.%d.%d.%d\n", HIWORD(sig->MinVersionMS),
 152          LOWORD(sig->MinVersionMS), HIWORD(sig->MinVersionLS),
 153          LOWORD(sig->MinVersionLS));
 154         TRACE("MaxVersion is %d.%d.%d.%d\n", HIWORD(sig->MaxVersionMS),
 155          LOWORD(sig->MaxVersionMS), HIWORD(sig->MaxVersionLS),
 156          LOWORD(sig->MaxVersionLS));
 157         TRACE("MinSize is %d, MaxSize is %d;\n", sig->MinSize, sig->MaxSize);
 158         TRACE("Languages is %s\n", debugstr_w(sig->Languages));
 159
 160 end:
 161         if (row)
 162             msiobj_release(&row->hdr);
 163         MSI_ViewClose(view);
 164         msiobj_release(&view->hdr);
 165     }
 166     else
 167     {
 168         TRACE("MSI_OpenQuery returned %d\n", rc);
 169         rc = ERROR_SUCCESS;
 170     }
 171
 172     TRACE("returning %d\n", rc);
 173     return rc;
 174 }
 175
 176 /* Frees any memory allocated in sig */
 177 static void ACTION_FreeSignature(MSISIGNATURE *sig)
 178 {
 179     msi_free(sig->File);
 180     msi_free(sig->Languages);
 181 }
 182
 183 static UINT ACTION_AppSearchComponents(MSIPACKAGE *package, LPWSTR *appValue,
 184  MSISIGNATURE *sig)
 185 {
 186     MSIQUERY *view;
 187     UINT rc;
 188     static const WCHAR ExecSeqQuery[] =  {
 189    's','e','l','e','c','t',' ','*',' ',
 190    'f','r','o','m',' ',
 191    'C','o','m','p','L','o','c','a','t','o','r',' ',
 192    'w','h','e','r','e',' ','S','i','g','n','a','t','u','r','e','_',' ','=',' ',
 193    '\'','%','s','\'',0};
 194
 195     TRACE("(package %p, appValue %p, sig %p)\n", package, appValue, sig);
 196     *appValue = NULL;
 197     rc = MSI_OpenQuery(package->db, &view, ExecSeqQuery, sig->Name);
 198     if (rc == ERROR_SUCCESS)
 199     {
 200         MSIRECORD *row = 0;
 201         WCHAR guid[50];
 202         DWORD sz;
 203
 204         rc = MSI_ViewExecute(view, 0);
 205         if (rc != ERROR_SUCCESS)
 206         {
 207             TRACE("MSI_ViewExecute returned %d\n", rc);
 208             goto end;
 209         }
 210         rc = MSI_ViewFetch(view,&row);
 211         if (rc != ERROR_SUCCESS)
 212         {
 213             TRACE("MSI_ViewFetch returned %d\n", rc);
 214             rc = ERROR_SUCCESS;
 215             goto end;
 216         }
 217
 218         /* get GUID */
 219         guid[0] = 0;
 220         sz=sizeof(guid)/sizeof(guid[0]);
 221         rc = MSI_RecordGetStringW(row,2,guid,&sz);
 222         if (rc != ERROR_SUCCESS)
 223         {
 224             ERR("Error is %x\n",rc);
 225             goto end;
 226         }
 227         FIXME("AppSearch unimplemented for CompLocator table (GUID %s)\n",
 228          debugstr_w(guid));
 229
 230 end:
 231         if (row)
 232             msiobj_release(&row->hdr);
 233         MSI_ViewClose(view);
 234         msiobj_release(&view->hdr);
 235     }
 236     else
 237     {
 238         TRACE("MSI_OpenQuery returned %d\n", rc);
 239         rc = ERROR_SUCCESS;
 240     }
 241
 242     TRACE("returning %d\n", rc);
 243     return rc;
 244 }
 245
 246 static void ACTION_ConvertRegValue(DWORD regType, const BYTE *value, DWORD sz,
 247  LPWSTR *appValue)
 248 {
 249     static const WCHAR dwordFmt[] = { '#','%','d','\0' };
 250     static const WCHAR expandSzFmt[] = { '#','%','%','%','s','\0' };
 251     static const WCHAR binFmt[] = { '#','x','%','x','\0' };
 252     DWORD i;
 253
 254     switch (regType)
 255     {
 256         case REG_SZ:
 257             if (*(LPCWSTR)value == '#')
 258             {
 259                 /* escape leading pound with another */
 260                 *appValue = msi_alloc(sz + sizeof(WCHAR));
 261                 (*appValue)[0] = '#';
 262                 strcpyW(*appValue + 1, (LPCWSTR)value);
 263             }
 264             else
 265             {
 266                 *appValue = msi_alloc(sz);
 267                 strcpyW(*appValue, (LPCWSTR)value);
 268             }
 269             break;
 270         case REG_DWORD:
 271             /* 7 chars for digits, 1 for NULL, 1 for #, and 1 for sign
 272              * char if needed
 273              */
 274             *appValue = msi_alloc(10 * sizeof(WCHAR));
 275             sprintfW(*appValue, dwordFmt, *(const DWORD *)value);
 276             break;
 277         case REG_EXPAND_SZ:
 278             /* space for extra #% characters in front */
 279             *appValue = msi_alloc(sz + 2 * sizeof(WCHAR));
 280             sprintfW(*appValue, expandSzFmt, (LPCWSTR)value);
 281             break;
 282         case REG_BINARY:
 283             /* 3 == length of "#x<nibble>" */
 284             *appValue = msi_alloc((sz * 3 + 1) * sizeof(WCHAR));
 285             for (i = 0; i < sz; i++)
 286                 sprintfW(*appValue + i * 3, binFmt, value[i]);
 287             break;
 288         default:
 289             WARN("unimplemented for values of type %d\n", regType);
 290             *appValue = NULL;
 291     }
 292 }
 293
 294 static UINT ACTION_SearchDirectory(MSIPACKAGE *package, MSISIGNATURE *sig,
 295  LPCWSTR path, int depth, LPWSTR *appValue);
 296
 297 static UINT ACTION_AppSearchReg(MSIPACKAGE *package, LPWSTR *appValue,
 298  MSISIGNATURE *sig)
 299 {
 300     MSIQUERY *view;
 301     UINT rc;
 302     static const WCHAR ExecSeqQuery[] =  {
 303    's','e','l','e','c','t',' ','*',' ',
 304    'f','r','o','m',' ',
 305    'R','e','g','L','o','c','a','t','o','r',' ',
 306    'w','h','e','r','e',' ','S','i','g','n','a','t','u','r','e','_',' ','=',' ',
 307    '\'','%','s','\'',0};
 308
 309     TRACE("(package %p, appValue %p, sig %p)\n", package, appValue, sig);
 310     *appValue = NULL;
 311     rc = MSI_OpenQuery(package->db, &view, ExecSeqQuery, sig->Name);
 312     if (rc == ERROR_SUCCESS)
 313     {
 314         MSIRECORD *row = 0;
 315         LPWSTR keyPath = NULL, valueName = NULL;
 316         int root, type;
 317         HKEY rootKey, key = NULL;
 318         DWORD sz = 0, regType;
 319         LPBYTE value = NULL;
 320
 321         rc = MSI_ViewExecute(view, 0);
 322         if (rc != ERROR_SUCCESS)
 323         {
 324             TRACE("MSI_ViewExecute returned %d\n", rc);
 325             goto end;
 326         }
 327         rc = MSI_ViewFetch(view,&row);
 328         if (rc != ERROR_SUCCESS)
 329         {
 330             TRACE("MSI_ViewFetch returned %d\n", rc);
 331             rc = ERROR_SUCCESS;
 332             goto end;
 333         }
 334
 335         root = MSI_RecordGetInteger(row,2);
 336         keyPath = msi_dup_record_field(row,3);
 337         /* FIXME: keyPath needs to be expanded for properties */
 338         valueName = msi_dup_record_field(row,4);
 339         /* FIXME: valueName probably does too */
 340         type = MSI_RecordGetInteger(row,5);
 341
 342         switch (root)
 343         {
 344             case msidbRegistryRootClassesRoot:
 345                 rootKey = HKEY_CLASSES_ROOT;
 346                 break;
 347             case msidbRegistryRootCurrentUser:
 348                 rootKey = HKEY_CURRENT_USER;
 349                 break;
 350             case msidbRegistryRootLocalMachine:
 351                 rootKey = HKEY_LOCAL_MACHINE;
 352                 break;
 353             case msidbRegistryRootUsers:
 354                 rootKey = HKEY_USERS;
 355                 break;
 356             default:
 357                 WARN("Unknown root key %d\n", root);
 358                 goto end;
 359         }
 360
 361         rc = RegOpenKeyW(rootKey, keyPath, &key);
 362         if (rc)
 363         {
 364             TRACE("RegOpenKeyW returned %d\n", rc);
 365             rc = ERROR_SUCCESS;
 366             goto end;
 367         }
 368         rc = RegQueryValueExW(key, valueName, NULL, NULL, NULL, &sz);
 369         if (rc)
 370         {
 371             TRACE("RegQueryValueExW returned %d\n", rc);
 372             rc = ERROR_SUCCESS;
 373             goto end;
 374         }
 375         /* FIXME: sanity-check sz before allocating (is there an upper-limit
 376          * on the value of a property?)
 377          */
 378         value = msi_alloc( sz);
 379         rc = RegQueryValueExW(key, valueName, NULL, &regType, value, &sz);
 380         if (rc)
 381         {
 382             TRACE("RegQueryValueExW returned %d\n", rc);
 383             rc = ERROR_SUCCESS;
 384             goto end;
 385         }
 386
 387         /* bail out if the registry key is empty */
 388         if (sz == 0)
 389         {
 390             rc = ERROR_SUCCESS;
 391             goto end;
 392         }
 393
 394         switch (type & 0x0f)
 395         {
 396         case msidbLocatorTypeDirectory:
 397             rc = ACTION_SearchDirectory(package, sig, (LPCWSTR)value, 0,
 398              appValue);
 399             break;
 400         case msidbLocatorTypeFileName:
 401             *appValue = (LPWSTR)value;
 402             break;
 403         case msidbLocatorTypeRawValue:
 404             ACTION_ConvertRegValue(regType, value, sz, appValue);
 405             break;
 406         default:
 407             FIXME("AppSearch unimplemented for type %d (key path %s, value %s)\n",
 408              type, debugstr_w(keyPath), debugstr_w(valueName));
 409         }
 410 end:
 411         msi_free( value);
 412         RegCloseKey(key);
 413
 414         msi_free( keyPath);
 415         msi_free( valueName);
 416
 417         if (row)
 418             msiobj_release(&row->hdr);
 419         MSI_ViewClose(view);
 420         msiobj_release(&view->hdr);
 421     }
 422     else
 423     {
 424         TRACE("MSI_OpenQuery returned %d\n", rc);
 425         rc = ERROR_SUCCESS;
 426     }
 427
 428     TRACE("returning %d\n", rc);
 429     return rc;
 430 }
 431
 432 static UINT ACTION_AppSearchIni(MSIPACKAGE *package, LPWSTR *appValue,
 433  MSISIGNATURE *sig)
 434 {
 435     MSIQUERY *view;
 436     UINT rc;
 437     static const WCHAR ExecSeqQuery[] =  {
 438    's','e','l','e','c','t',' ','*',' ',
 439    'f','r','o','m',' ',
 440    'I','n','i','L','o','c','a','t','o','r',' ',
 441    'w','h','e','r','e',' ','S','i','g','n','a','t','u','r','e','_',' ','=',' ',
 442    '\'','%','s','\'',0};
 443
 444     TRACE("(package %p, appValue %p, sig %p)\n", package, appValue, sig);
 445     *appValue = NULL;
 446     rc = MSI_OpenQuery(package->db, &view, ExecSeqQuery, sig->Name);
 447     if (rc == ERROR_SUCCESS)
 448     {
 449         MSIRECORD *row = 0;
 450         LPWSTR fileName, section, key;
 451         int field, type;
 452         WCHAR buf[MAX_PATH];
 453
 454         rc = MSI_ViewExecute(view, 0);
 455         if (rc != ERROR_SUCCESS)
 456         {
 457             TRACE("MSI_ViewExecute returned %d\n", rc);
 458             goto end;
 459         }
 460         rc = MSI_ViewFetch(view,&row);
 461         if (rc != ERROR_SUCCESS)
 462         {
 463             TRACE("MSI_ViewFetch returned %d\n", rc);
 464             rc = ERROR_SUCCESS;
 465             goto end;
 466         }
 467
 468         fileName = msi_dup_record_field(row, 2);
 469         section = msi_dup_record_field(row, 3);
 470         key = msi_dup_record_field(row, 4);
 471         if ((field = MSI_RecordGetInteger(row, 5)) == MSI_NULL_INTEGER)
 472             field = 0;
 473         if ((type = MSI_RecordGetInteger(row, 6)) == MSI_NULL_INTEGER)
 474             type = 0;
 475
 476         GetPrivateProfileStringW(section, key, NULL, buf,
 477          sizeof(buf) / sizeof(WCHAR), fileName);
 478         if (buf[0])
 479         {
 480             switch (type & 0x0f)
 481             {
 482             case msidbLocatorTypeDirectory:
 483                 FIXME("unimplemented for type Directory (dir: %s)\n",
 484                  debugstr_w(buf));
 485                 break;
 486             case msidbLocatorTypeFileName:
 487                 FIXME("unimplemented for type File (file: %s)\n",
 488                  debugstr_w(buf));
 489                 break;
 490             case msidbLocatorTypeRawValue:
 491                 *appValue = strdupW(buf);
 492                 break;
 493             }
 494         }
 495
 496         msi_free(fileName);
 497         msi_free(section);
 498         msi_free(key);
 499
 500 end:
 501         if (row)
 502             msiobj_release(&row->hdr);
 503         MSI_ViewClose(view);
 504         msiobj_release(&view->hdr);
 505     }
 506     else
 507     {
 508         TRACE("MSI_OpenQuery returned %d\n", rc);
 509         rc = ERROR_SUCCESS;
 510     }
 511
 512
 513     TRACE("returning %d\n", rc);
 514     return rc;
 515 }
 516
 517 /* Expands the value in src into a path without property names and only
 518  * containing long path names into dst.  Replaces at most len characters of dst,
 519  * and always NULL-terminates dst if dst is not NULL and len >= 1.
 520  * May modify src.
 521  * Assumes src and dst are non-overlapping.
 522  * FIXME: return code probably needed:
 523  * - what does AppSearch return if the table values are invalid?
 524  * - what if dst is too small?
 525  */
 526 static void ACTION_ExpandAnyPath(MSIPACKAGE *package, WCHAR *src, WCHAR *dst,
 527  size_t len)
 528 {
 529     WCHAR *ptr;
 530     size_t copied = 0;
 531
 532     if (!src || !dst || !len)
 533     {
 534         if (dst) *dst = '\0';
 535         return;
 536     }
 537
 538     /* Ignore the short portion of the path, don't think we can use it anyway */
 539     if ((ptr = strchrW(src, '|')))
 540         ptr++;
 541     else
 542         ptr = src;
 543     while (*ptr && copied < len - 1)
 544     {
 545         WCHAR *prop = strchrW(ptr, '[');
 546
 547         if (prop)
 548         {
 549             WCHAR *propEnd = strchrW(prop + 1, ']');
 550
 551             if (!propEnd)
 552             {
 553                 WARN("Unterminated property name in AnyPath: %s\n",
 554                  debugstr_w(prop));
 555                 break;
 556             }
 557             else
 558             {
 559                 DWORD propLen;
 560
 561                 *propEnd = 0;
 562                 propLen = len - copied - 1;
 563                 MSI_GetPropertyW(package, prop + 1, dst + copied, &propLen);
 564                 ptr = propEnd + 1;
 565                 copied += propLen;
 566             }
 567         }
 568         else
 569         {
 570             size_t toCopy = min(strlenW(ptr) + 1, len - copied - 1);
 571
 572             memcpy(dst + copied, ptr, toCopy * sizeof(WCHAR));
 573             ptr += toCopy;
 574             copied += toCopy;
 575         }
 576     }
 577     *(dst + copied) = '\0';
 578 }
 579
 580 /* Sets *matches to whether the file (whose path is filePath) matches the
 581  * versions set in sig.
 582  * Return ERROR_SUCCESS in case of success (whether or not the file matches),
 583  * something else if an install-halting error occurs.
 584  */
 585 static UINT ACTION_FileVersionMatches(MSISIGNATURE *sig, LPCWSTR filePath,
 586  BOOL *matches)
 587 {
 588     UINT rc = ERROR_SUCCESS;
 589
 590     *matches = FALSE;
 591     if (sig->Languages)
 592     {
 593         FIXME(": need to check version for languages %s\n",
 594          debugstr_w(sig->Languages));
 595     }
 596     else
 597     {
 598         DWORD zero, size = GetFileVersionInfoSizeW(filePath, &zero);
 599
 600         if (size)
 601         {
 602             LPVOID buf = msi_alloc( size);
 603
 604             if (buf)
 605             {
 606                 static WCHAR rootW[] = { '\\',0 };
 607                 UINT versionLen;
 608                 LPVOID subBlock = NULL;
 609
 610                 if (GetFileVersionInfoW(filePath, 0, size, buf))
 611                     VerQueryValueW(buf, rootW, &subBlock, &versionLen);
 612                 if (subBlock)
 613                 {
 614                     VS_FIXEDFILEINFO *info =
 615                      (VS_FIXEDFILEINFO *)subBlock;
 616
 617                     TRACE("Comparing file version %d.%d.%d.%d:\n",
 618                      HIWORD(info->dwFileVersionMS),
 619                      LOWORD(info->dwFileVersionMS),
 620                      HIWORD(info->dwFileVersionLS),
 621                      LOWORD(info->dwFileVersionLS));
 622                     if (info->dwFileVersionMS < sig->MinVersionMS
 623                      || (info->dwFileVersionMS == sig->MinVersionMS &&
 624                      info->dwFileVersionLS < sig->MinVersionLS))
 625                     {
 626                         TRACE("Less than minimum version %d.%d.%d.%d\n",
 627                          HIWORD(sig->MinVersionMS),
 628                          LOWORD(sig->MinVersionMS),
 629                          HIWORD(sig->MinVersionLS),
 630                          LOWORD(sig->MinVersionLS));
 631                     }
 632                     else if (info->dwFileVersionMS < sig->MinVersionMS
 633                      || (info->dwFileVersionMS == sig->MinVersionMS &&
 634                      info->dwFileVersionLS < sig->MinVersionLS))
 635                     {
 636                         TRACE("Greater than minimum version %d.%d.%d.%d\n",
 637                          HIWORD(sig->MaxVersionMS),
 638                          LOWORD(sig->MaxVersionMS),
 639                          HIWORD(sig->MaxVersionLS),
 640                          LOWORD(sig->MaxVersionLS));
 641                     }
 642                     else
 643                         *matches = TRUE;
 644                 }
 645                 msi_free( buf);
 646             }
 647             else
 648                 rc = ERROR_OUTOFMEMORY;
 649         }
 650     }
 651     return rc;
 652 }
 653
 654 /* Sets *matches to whether the file in findData matches that in sig.
 655  * fullFilePath is assumed to be the full path of the file specified in
 656  * findData, which may be necessary to compare the version.
 657  * Return ERROR_SUCCESS in case of success (whether or not the file matches),
 658  * something else if an install-halting error occurs.
 659  */
 660 static UINT ACTION_FileMatchesSig(MSISIGNATURE *sig,
 661  LPWIN32_FIND_DATAW findData, LPCWSTR fullFilePath, BOOL *matches)
 662 {
 663     UINT rc = ERROR_SUCCESS;
 664
 665     *matches = TRUE;
 666     /* assumes the caller has already ensured the filenames match, so check
 667      * the other fields..
 668      */
 669     if (sig->MinTime.dwLowDateTime || sig->MinTime.dwHighDateTime)
 670     {
 671         if (findData->ftCreationTime.dwHighDateTime <
 672          sig->MinTime.dwHighDateTime ||
 673          (findData->ftCreationTime.dwHighDateTime == sig->MinTime.dwHighDateTime
 674          && findData->ftCreationTime.dwLowDateTime <
 675          sig->MinTime.dwLowDateTime))
 676             *matches = FALSE;
 677     }
 678     if (*matches && (sig->MaxTime.dwLowDateTime || sig->MaxTime.dwHighDateTime))
 679     {
 680         if (findData->ftCreationTime.dwHighDateTime >
 681          sig->MaxTime.dwHighDateTime ||
 682          (findData->ftCreationTime.dwHighDateTime == sig->MaxTime.dwHighDateTime
 683          && findData->ftCreationTime.dwLowDateTime >
 684          sig->MaxTime.dwLowDateTime))
 685             *matches = FALSE;
 686     }
 687     if (*matches && sig->MinSize && findData->nFileSizeLow < sig->MinSize)
 688         *matches = FALSE;
 689     if (*matches && sig->MaxSize && findData->nFileSizeLow > sig->MaxSize)
 690         *matches = FALSE;
 691     if (*matches && (sig->MinVersionMS || sig->MinVersionLS ||
 692      sig->MaxVersionMS || sig->MaxVersionLS))
 693         rc = ACTION_FileVersionMatches(sig, fullFilePath, matches);
 694     return rc;
 695 }
 696
 697 /* Recursively searches the directory dir for files that match the signature
 698  * sig, up to (depth + 1) levels deep.  That is, if depth is 0, it searches dir
 699  * (and only dir).  If depth is 1, searches dir and its immediate
 700  * subdirectories.
 701  * Assumes sig->File is not NULL.
 702  * Returns ERROR_SUCCESS on success (which may include non-critical errors),
 703  * something else on failures which should halt the install.
 704  */
 705 static UINT ACTION_RecurseSearchDirectory(MSIPACKAGE *package, LPWSTR *appValue,
 706  MSISIGNATURE *sig, LPCWSTR dir, int depth)
 707 {
 708     static const WCHAR starDotStarW[] = { '*','.','*',0 };
 709     UINT rc = ERROR_SUCCESS;
 710     size_t dirLen = lstrlenW(dir), fileLen = lstrlenW(sig->File);
 711     WCHAR *buf;
 712
 713     TRACE("Searching directory %s for file %s, depth %d\n", debugstr_w(dir),
 714      debugstr_w(sig->File), depth);
 715
 716     if (depth < 0)
 717         return ERROR_INVALID_PARAMETER;
 718
 719     *appValue = NULL;
 720     /* We need the buffer in both paths below, so go ahead and allocate it
 721      * here.  Add two because we might need to add a backslash if the dir name
 722      * isn't backslash-terminated.
 723      */
 724     buf = msi_alloc( (dirLen + max(fileLen, lstrlenW(starDotStarW)) + 2) * sizeof(WCHAR));
 725     if (buf)
 726     {
 727         /* a depth of 0 implies we should search dir, so go ahead and search */
 728         HANDLE hFind;
 729         WIN32_FIND_DATAW findData;
 730
 731         memcpy(buf, dir, dirLen * sizeof(WCHAR));
 732         if (buf[dirLen - 1] != '\\')
 733             buf[dirLen++ - 1] = '\\';
 734         memcpy(buf + dirLen, sig->File, (fileLen + 1) * sizeof(WCHAR));
 735         hFind = FindFirstFileW(buf, &findData);
 736         if (hFind != INVALID_HANDLE_VALUE)
 737         {
 738             BOOL matches;
 739
 740             /* assuming Signature can't contain wildcards for the file name,
 741              * so don't bother with FindNextFileW here.
 742              */
 743             if (!(rc = ACTION_FileMatchesSig(sig, &findData, buf, &matches))
 744              && matches)
 745             {
 746                 TRACE("found file, returning %s\n", debugstr_w(buf));
 747                 *appValue = buf;
 748             }
 749             FindClose(hFind);
 750         }
 751         if (rc == ERROR_SUCCESS && !*appValue && depth > 0)
 752         {
 753             HANDLE hFind;
 754             WIN32_FIND_DATAW findData;
 755
 756             memcpy(buf, dir, dirLen * sizeof(WCHAR));
 757             if (buf[dirLen - 1] != '\\')
 758                 buf[dirLen++ - 1] = '\\';
 759             lstrcpyW(buf + dirLen, starDotStarW);
 760             hFind = FindFirstFileW(buf, &findData);
 761             if (hFind != INVALID_HANDLE_VALUE)
 762             {
 763                 if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 764                     rc = ACTION_RecurseSearchDirectory(package, appValue, sig,
 765                      findData.cFileName, depth - 1);
 766                 while (rc == ERROR_SUCCESS && !*appValue &&
 767                  FindNextFileW(hFind, &findData) != 0)
 768                 {
 769                     if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 770                         rc = ACTION_RecurseSearchDirectory(package, appValue,
 771                          sig, findData.cFileName, depth - 1);
 772                 }
 773                 FindClose(hFind);
 774             }
 775         }
 776         if (!*appValue)
 777             msi_free(buf);
 778     }
 779     else
 780         rc = ERROR_OUTOFMEMORY;
 781
 782     return rc;
 783 }
 784
 785 static UINT ACTION_CheckDirectory(MSIPACKAGE *package, LPCWSTR dir,
 786  LPWSTR *appValue)
 787 {
 788     UINT rc = ERROR_SUCCESS;
 789
 790     if (GetFileAttributesW(dir) & FILE_ATTRIBUTE_DIRECTORY)
 791     {
 792         TRACE("directory exists, returning %s\n", debugstr_w(dir));
 793         *appValue = strdupW(dir);
 794     }
 795     return rc;
 796 }
 797
 798 static BOOL ACTION_IsFullPath(LPCWSTR path)
 799 {
 800     WCHAR first = toupperW(path[0]);
 801     BOOL ret;
 802
 803     if (first >= 'A' && first <= 'Z' && path[1] == ':')
 804         ret = TRUE;
 805     else if (path[0] == '\\' && path[1] == '\\')
 806         ret = TRUE;
 807     else
 808         ret = FALSE;
 809     return ret;
 810 }
 811
 812 static UINT ACTION_SearchDirectory(MSIPACKAGE *package, MSISIGNATURE *sig,
 813  LPCWSTR path, int depth, LPWSTR *appValue)
 814 {
 815     UINT rc;
 816
 817     TRACE("%p, %p, %s, %d, %p\n", package, sig, debugstr_w(path), depth,
 818      appValue);
 819     if (ACTION_IsFullPath(path))
 820     {
 821         if (sig->File)
 822             rc = ACTION_RecurseSearchDirectory(package, appValue, sig,
 823              path, depth);
 824         else
 825         {
 826             /* Recursively searching a directory makes no sense when the
 827              * directory to search is the thing you're trying to find.
 828              */
 829             rc = ACTION_CheckDirectory(package, path, appValue);
 830         }
 831     }
 832     else
 833     {
 834         WCHAR pathWithDrive[MAX_PATH] = { 'C',':','\\',0 };
 835         DWORD drives = GetLogicalDrives();
 836         int i;
 837
 838         rc = ERROR_SUCCESS;
 839         *appValue = NULL;
 840         for (i = 0; rc == ERROR_SUCCESS && !*appValue && i < 26; i++)
 841             if (drives & (1 << drives))
 842             {
 843                 pathWithDrive[0] = 'A' + i;
 844                 if (GetDriveTypeW(pathWithDrive) == DRIVE_FIXED)
 845                 {
 846                     lstrcpynW(pathWithDrive + 3, path,
 847                               sizeof(pathWithDrive) / sizeof(pathWithDrive[0]) - 3);
 848                     if (sig->File)
 849                         rc = ACTION_RecurseSearchDirectory(package, appValue,
 850                          sig, pathWithDrive, depth);
 851                     else
 852                         rc = ACTION_CheckDirectory(package, pathWithDrive,
 853                          appValue);
 854                 }
 855             }
 856     }
 857     TRACE("returning %d\n", rc);
 858     return rc;
 859 }
 860
 861 static UINT ACTION_AppSearchSigName(MSIPACKAGE *package, LPCWSTR sigName,
 862  MSISIGNATURE *sig, LPWSTR *appValue);
 863
 864 static UINT ACTION_AppSearchDr(MSIPACKAGE *package, LPWSTR *appValue,
 865  MSISIGNATURE *sig)
 866 {
 867     MSIQUERY *view;
 868     UINT rc;
 869     static const WCHAR ExecSeqQuery[] =  {
 870    's','e','l','e','c','t',' ','*',' ',
 871    'f','r','o','m',' ',
 872    'D','r','L','o','c','a','t','o','r',' ',
 873    'w','h','e','r','e',' ','S','i','g','n','a','t','u','r','e','_',' ','=',' ',
 874    '\'','%','s','\'',0};
 875
 876     TRACE("(package %p, sig %p)\n", package, sig);
 877     rc = MSI_OpenQuery(package->db, &view, ExecSeqQuery, sig->Name);
 878     if (rc == ERROR_SUCCESS)
 879     {
 880         MSIRECORD *row = 0;
 881         WCHAR expanded[MAX_PATH];
 882         LPWSTR parentName = NULL, path = NULL, parent = NULL;
 883         int depth;
 884
 885         rc = MSI_ViewExecute(view, 0);
 886         if (rc != ERROR_SUCCESS)
 887         {
 888             TRACE("MSI_ViewExecute returned %d\n", rc);
 889             goto end;
 890         }
 891         rc = MSI_ViewFetch(view,&row);
 892         if (rc != ERROR_SUCCESS)
 893         {
 894             TRACE("MSI_ViewFetch returned %d\n", rc);
 895             rc = ERROR_SUCCESS;
 896             goto end;
 897         }
 898
 899         /* check whether parent is set */
 900         parentName = msi_dup_record_field(row,2);
 901         if (parentName)
 902         {
 903             MSISIGNATURE parentSig;
 904
 905             rc = ACTION_AppSearchSigName(package, parentName, &parentSig,
 906              &parent);
 907             ACTION_FreeSignature(&parentSig);
 908             msi_free(parentName);
 909         }
 910         /* now look for path */
 911         path = msi_dup_record_field(row,3);
 912         if (MSI_RecordIsNull(row,4))
 913             depth = 0;
 914         else
 915             depth = MSI_RecordGetInteger(row,4);
 916         ACTION_ExpandAnyPath(package, path, expanded,
 917          sizeof(expanded) / sizeof(expanded[0]));
 918         msi_free(path);
 919         if (parent)
 920         {
 921             path = msi_alloc((strlenW(parent) + strlenW(expanded) + 1) * sizeof(WCHAR));
 922             if (!path)
 923                 goto end;
 924             strcpyW(path, parent);
 925             strcatW(path, expanded);
 926         }
 927         else
 928             path = expanded;
 929         rc = ACTION_SearchDirectory(package, sig, path, depth, appValue);
 930
 931 end:
 932         if (path != expanded)
 933             msi_free(path);
 934         msi_free(parent);
 935         if (row)
 936             msiobj_release(&row->hdr);
 937         MSI_ViewClose(view);
 938         msiobj_release(&view->hdr);
 939     }
 940     else
 941     {
 942         TRACE("MSI_OpenQuery returned %d\n", rc);
 943         rc = ERROR_SUCCESS;
 944     }
 945
 946     TRACE("returning %d\n", rc);
 947     return rc;
 948 }
 949
 950 static UINT ACTION_AppSearchSigName(MSIPACKAGE *package, LPCWSTR sigName,
 951  MSISIGNATURE *sig, LPWSTR *appValue)
 952 {
 953     UINT rc;
 954
 955     *appValue = NULL;
 956     rc = ACTION_AppSearchGetSignature(package, sig, sigName);
 957     if (rc == ERROR_SUCCESS)
 958     {
 959         rc = ACTION_AppSearchComponents(package, appValue, sig);
 960         if (rc == ERROR_SUCCESS && !*appValue)
 961         {
 962             rc = ACTION_AppSearchReg(package, appValue, sig);
 963             if (rc == ERROR_SUCCESS && !*appValue)
 964             {
 965                 rc = ACTION_AppSearchIni(package, appValue, sig);
 966                 if (rc == ERROR_SUCCESS && !*appValue)
 967                     rc = ACTION_AppSearchDr(package, appValue, sig);
 968             }
 969         }
 970     }
 971     return rc;
 972 }
 973
 974 /* http://msdn.microsoft.com/library/en-us/msi/setup/appsearch_table.asp
 975  * is the best reference for the AppSearch table and how it's used.
 976  */
 977 UINT ACTION_AppSearch(MSIPACKAGE *package)
 978 {
 979     MSIQUERY *view;
 980     UINT rc;
 981     static const WCHAR ExecSeqQuery[] =  {
 982    's','e','l','e','c','t',' ','*',' ',
 983    'f','r','o','m',' ',
 984    'A','p','p','S','e','a','r','c','h',0};
 985
 986     rc = MSI_OpenQuery(package->db, &view, ExecSeqQuery);
 987     if (rc == ERROR_SUCCESS)
 988     {
 989         MSIRECORD *row = 0;
 990         LPWSTR propName, sigName;
 991
 992         rc = MSI_ViewExecute(view, 0);
 993         if (rc != ERROR_SUCCESS)
 994             goto end;
 995
 996         while (!rc)
 997         {
 998             MSISIGNATURE sig;
 999             LPWSTR value;
1000
1001             rc = MSI_ViewFetch(view,&row);
1002             if (rc != ERROR_SUCCESS)
1003             {
1004                 rc = ERROR_SUCCESS;
1005                 break;
1006             }
1007
1008             /* get property and signature */
1009             propName = msi_dup_record_field(row,1);
1010             sigName = msi_dup_record_field(row,2);
1011
1012             TRACE("Searching for Property %s, Signature_ %s\n",
1013              debugstr_w(propName), debugstr_w(sigName));
1014
1015             rc = ACTION_AppSearchSigName(package, sigName, &sig, &value);
1016             if (value)
1017             {
1018                 MSI_SetPropertyW(package, propName, value);
1019                 msi_free(value);
1020             }
1021             ACTION_FreeSignature(&sig);
1022             msi_free(propName);
1023             msi_free(sigName);
1024             msiobj_release(&row->hdr);
1025         }
1026
1027 end:
1028         MSI_ViewClose(view);
1029         msiobj_release(&view->hdr);
1030     }
1031     else
1032         rc = ERROR_SUCCESS;
1033
1034     return rc;
1035 }