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 "shlwapi.h"
  32 #include "wine/unicode.h"
  33 #include "wine/debug.h"
  34 #include "msipriv.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 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, LPCWSTR name)
  85 {
  86     static const WCHAR query[] = {
  87         's','e','l','e','c','t',' ','*',' ',
  88         'f','r','o','m',' ',
  89         'S','i','g','n','a','t','u','r','e',' ',
  90         'w','h','e','r','e',' ','S','i','g','n','a','t','u','r','e',' ','=',' ',
  91         '\'','%','s','\'',0};
  92     LPWSTR minVersion, maxVersion;
  93     MSIRECORD *row;
  94     DWORD time;
  95
  96     TRACE("package %p, sig %p\n", package, sig);
  97
  98     memset(sig, 0, sizeof(*sig));
  99     sig->Name = name;
 100     row = MSI_QueryGetRecord( package->db, query, name );
 101     if (!row)
 102     {
 103         TRACE("failed to query signature for %s\n", debugstr_w(name));
 104         return ERROR_SUCCESS;
 105     }
 106
 107     /* get properties */
 108     sig->File = msi_dup_record_field(row,2);
 109     minVersion = msi_dup_record_field(row,3);
 110     if (minVersion)
 111     {
 112         ACTION_VerStrToInteger(minVersion, &sig->MinVersionMS, &sig->MinVersionLS);
 113         msi_free( minVersion );
 114     }
 115     maxVersion = msi_dup_record_field(row,4);
 116     if (maxVersion)
 117     {
 118         ACTION_VerStrToInteger(maxVersion, &sig->MaxVersionMS, &sig->MaxVersionLS);
 119         msi_free( maxVersion );
 120     }
 121     sig->MinSize = MSI_RecordGetInteger(row,5);
 122     if (sig->MinSize == MSI_NULL_INTEGER)
 123         sig->MinSize = 0;
 124     sig->MaxSize = MSI_RecordGetInteger(row,6);
 125     if (sig->MaxSize == MSI_NULL_INTEGER)
 126         sig->MaxSize = 0;
 127     sig->Languages = msi_dup_record_field(row,9);
 128     time = MSI_RecordGetInteger(row,7);
 129     if (time != MSI_NULL_INTEGER)
 130         DosDateTimeToFileTime(HIWORD(time), LOWORD(time), &sig->MinTime);
 131     time = MSI_RecordGetInteger(row,8);
 132     if (time != MSI_NULL_INTEGER)
 133         DosDateTimeToFileTime(HIWORD(time), LOWORD(time), &sig->MaxTime);
 134
 135     TRACE("Found file name %s for Signature_ %s;\n",
 136           debugstr_w(sig->File), debugstr_w(name));
 137     TRACE("MinVersion is %d.%d.%d.%d\n", HIWORD(sig->MinVersionMS),
 138           LOWORD(sig->MinVersionMS), HIWORD(sig->MinVersionLS),
 139           LOWORD(sig->MinVersionLS));
 140     TRACE("MaxVersion is %d.%d.%d.%d\n", HIWORD(sig->MaxVersionMS),
 141           LOWORD(sig->MaxVersionMS), HIWORD(sig->MaxVersionLS),
 142           LOWORD(sig->MaxVersionLS));
 143     TRACE("MinSize is %d, MaxSize is %d;\n", sig->MinSize, sig->MaxSize);
 144     TRACE("Languages is %s\n", debugstr_w(sig->Languages));
 145
 146     msiobj_release( &row->hdr );
 147
 148     return ERROR_SUCCESS;
 149 }
 150
 151 /* Frees any memory allocated in sig */
 152 static void ACTION_FreeSignature(MSISIGNATURE *sig)
 153 {
 154     msi_free(sig->File);
 155     msi_free(sig->Languages);
 156 }
 157
 158 static LPWSTR app_search_file(LPWSTR path, MSISIGNATURE *sig)
 159 {
 160     VS_FIXEDFILEINFO *info;
 161     DWORD attr, handle, size;
 162     LPWSTR val = NULL;
 163     LPBYTE buffer;
 164
 165     if (!sig->File)
 166     {
 167         PathRemoveFileSpecW(path);
 168         PathAddBackslashW(path);
 169
 170         attr = GetFileAttributesW(path);
 171         if (attr != INVALID_FILE_ATTRIBUTES &&
 172             (attr & FILE_ATTRIBUTE_DIRECTORY))
 173             return strdupW(path);
 174
 175         return NULL;
 176     }
 177
 178     attr = GetFileAttributesW(path);
 179     if (attr == INVALID_FILE_ATTRIBUTES ||
 180         (attr & FILE_ATTRIBUTE_DIRECTORY))
 181         return NULL;
 182
 183     size = GetFileVersionInfoSizeW(path, &handle);
 184     if (!size)
 185         return strdupW(path);
 186
 187     buffer = msi_alloc(size);
 188     if (!buffer)
 189         return NULL;
 190
 191     if (!GetFileVersionInfoW(path, 0, size, buffer))
 192         goto done;
 193
 194     if (!VerQueryValueW(buffer, szBackSlash, (LPVOID)&info, &size) || !info)
 195         goto done;
 196
 197     if (sig->MinVersionLS || sig->MinVersionMS)
 198     {
 199         if (info->dwFileVersionMS < sig->MinVersionMS)
 200             goto done;
 201
 202         if (info->dwFileVersionMS == sig->MinVersionMS &&
 203             info->dwFileVersionLS < sig->MinVersionLS)
 204             goto done;
 205     }
 206
 207     if (sig->MaxVersionLS || sig->MaxVersionMS)
 208     {
 209         if (info->dwFileVersionMS > sig->MaxVersionMS)
 210             goto done;
 211
 212         if (info->dwFileVersionMS == sig->MaxVersionMS &&
 213             info->dwFileVersionLS > sig->MaxVersionLS)
 214             goto done;
 215     }
 216
 217     val = strdupW(path);
 218
 219 done:
 220     msi_free(buffer);
 221     return val;
 222 }
 223
 224 static UINT ACTION_AppSearchComponents(MSIPACKAGE *package, LPWSTR *appValue, MSISIGNATURE *sig)
 225 {
 226     static const WCHAR query[] =  {
 227         'S','E','L','E','C','T',' ','*',' ',
 228         'F','R','O','M',' ',
 229         '`','C','o','m','p','L','o','c','a','t','o','r','`',' ',
 230         'W','H','E','R','E',' ','`','S','i','g','n','a','t','u','r','e','_','`',' ','=',' ',
 231         '\'','%','s','\'',0};
 232     static const WCHAR sigquery[] = {
 233         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 234         '`','S','i','g','n','a','t','u','r','e','`',' ',
 235         'W','H','E','R','E',' ','`','S','i','g','n','a','t','u','r','e','`',' ','=',' ',
 236         '\'','%','s','\'',0};
 237
 238     MSIRECORD *row, *rec;
 239     LPCWSTR signature, guid;
 240     BOOL sigpresent = TRUE;
 241     BOOL isdir;
 242     UINT type;
 243     WCHAR path[MAX_PATH];
 244     DWORD size = MAX_PATH;
 245     LPWSTR ptr;
 246     DWORD attr;
 247
 248     TRACE("%s\n", debugstr_w(sig->Name));
 249
 250     *appValue = NULL;
 251
 252     row = MSI_QueryGetRecord(package->db, query, sig->Name);
 253     if (!row)
 254     {
 255         TRACE("failed to query CompLocator for %s\n", debugstr_w(sig->Name));
 256         return ERROR_SUCCESS;
 257     }
 258
 259     signature = MSI_RecordGetString(row, 1);
 260     guid = MSI_RecordGetString(row, 2);
 261     type = MSI_RecordGetInteger(row, 3);
 262
 263     rec = MSI_QueryGetRecord(package->db, sigquery, signature);
 264     if (!rec)
 265         sigpresent = FALSE;
 266
 267     *path = '\0';
 268     MsiLocateComponentW(guid, path, &size);
 269     if (!*path)
 270         goto done;
 271
 272     attr = GetFileAttributesW(path);
 273     if (attr == INVALID_FILE_ATTRIBUTES)
 274         goto done;
 275
 276     isdir = (attr & FILE_ATTRIBUTE_DIRECTORY);
 277
 278     if (type != msidbLocatorTypeDirectory && sigpresent && !isdir)
 279     {
 280         *appValue = app_search_file(path, sig);
 281     }
 282     else if (!sigpresent && (type != msidbLocatorTypeDirectory || isdir))
 283     {
 284         if (type == msidbLocatorTypeFileName)
 285         {
 286             ptr = strrchrW(path, '\\');
 287             *(ptr + 1) = '\0';
 288         }
 289         else
 290             PathAddBackslashW(path);
 291
 292         *appValue = strdupW(path);
 293     }
 294     else if (sigpresent)
 295     {
 296         PathAddBackslashW(path);
 297         lstrcatW(path, MSI_RecordGetString(rec, 2));
 298
 299         attr = GetFileAttributesW(path);
 300         if (attr != INVALID_FILE_ATTRIBUTES &&
 301             !(attr & FILE_ATTRIBUTE_DIRECTORY))
 302             *appValue = strdupW(path);
 303     }
 304
 305 done:
 306     if (rec) msiobj_release(&rec->hdr);
 307     msiobj_release(&row->hdr);
 308     return ERROR_SUCCESS;
 309 }
 310
 311 static void ACTION_ConvertRegValue(DWORD regType, const BYTE *value, DWORD sz,
 312  LPWSTR *appValue)
 313 {
 314     static const WCHAR dwordFmt[] = { '#','%','d','\0' };
 315     static const WCHAR binPre[] = { '#','x','\0' };
 316     static const WCHAR binFmt[] = { '%','0','2','X','\0' };
 317     LPWSTR ptr;
 318     DWORD i;
 319
 320     switch (regType)
 321     {
 322         case REG_SZ:
 323             if (*(LPCWSTR)value == '#')
 324             {
 325                 /* escape leading pound with another */
 326                 *appValue = msi_alloc(sz + sizeof(WCHAR));
 327                 (*appValue)[0] = '#';
 328                 strcpyW(*appValue + 1, (LPCWSTR)value);
 329             }
 330             else
 331             {
 332                 *appValue = msi_alloc(sz);
 333                 strcpyW(*appValue, (LPCWSTR)value);
 334             }
 335             break;
 336         case REG_DWORD:
 337             /* 7 chars for digits, 1 for NULL, 1 for #, and 1 for sign
 338              * char if needed
 339              */
 340             *appValue = msi_alloc(10 * sizeof(WCHAR));
 341             sprintfW(*appValue, dwordFmt, *(const DWORD *)value);
 342             break;
 343         case REG_EXPAND_SZ:
 344             sz = ExpandEnvironmentStringsW((LPCWSTR)value, NULL, 0);
 345             *appValue = msi_alloc(sz * sizeof(WCHAR));
 346             ExpandEnvironmentStringsW((LPCWSTR)value, *appValue, sz);
 347             break;
 348         case REG_BINARY:
 349             /* #x<nibbles>\0 */
 350             *appValue = msi_alloc((sz * 2 + 3) * sizeof(WCHAR));
 351             lstrcpyW(*appValue, binPre);
 352             ptr = *appValue + lstrlenW(binPre);
 353             for (i = 0; i < sz; i++, ptr += 2)
 354                 sprintfW(ptr, binFmt, value[i]);
 355             break;
 356         default:
 357             WARN("unimplemented for values of type %d\n", regType);
 358             *appValue = NULL;
 359     }
 360 }
 361
 362 static UINT ACTION_SearchDirectory(MSIPACKAGE *package, MSISIGNATURE *sig,
 363  LPCWSTR path, int depth, LPWSTR *appValue);
 364
 365 static UINT ACTION_AppSearchReg(MSIPACKAGE *package, LPWSTR *appValue, MSISIGNATURE *sig)
 366 {
 367     static const WCHAR query[] =  {
 368         's','e','l','e','c','t',' ','*',' ',
 369         'f','r','o','m',' ',
 370         'R','e','g','L','o','c','a','t','o','r',' ',
 371         'w','h','e','r','e',' ',
 372         'S','i','g','n','a','t','u','r','e','_',' ','=',' ', '\'','%','s','\'',0};
 373     LPWSTR keyPath = NULL, valueName = NULL;
 374     LPWSTR deformatted = NULL;
 375     LPWSTR ptr = NULL, end;
 376     int root, type;
 377     HKEY rootKey, key = NULL;
 378     DWORD sz = 0, regType;
 379     LPBYTE value = NULL;
 380     MSIRECORD *row;
 381     UINT rc;
 382
 383     TRACE("%s\n", debugstr_w(sig->Name));
 384
 385     *appValue = NULL;
 386
 387     row = MSI_QueryGetRecord( package->db, query, sig->Name );
 388     if (!row)
 389     {
 390         TRACE("failed to query RegLocator for %s\n", debugstr_w(sig->Name));
 391         return ERROR_SUCCESS;
 392     }
 393
 394     root = MSI_RecordGetInteger(row,2);
 395     keyPath = msi_dup_record_field(row,3);
 396     valueName = msi_dup_record_field(row,4);
 397     type = MSI_RecordGetInteger(row,5);
 398
 399     deformat_string(package, keyPath, &deformatted);
 400
 401     switch (root)
 402     {
 403     case msidbRegistryRootClassesRoot:
 404         rootKey = HKEY_CLASSES_ROOT;
 405         break;
 406     case msidbRegistryRootCurrentUser:
 407         rootKey = HKEY_CURRENT_USER;
 408         break;
 409     case msidbRegistryRootLocalMachine:
 410         rootKey = HKEY_LOCAL_MACHINE;
 411         break;
 412     case msidbRegistryRootUsers:
 413         rootKey = HKEY_USERS;
 414         break;
 415     default:
 416         WARN("Unknown root key %d\n", root);
 417         goto end;
 418     }
 419
 420     rc = RegOpenKeyW(rootKey, deformatted, &key);
 421     if (rc)
 422     {
 423         TRACE("RegOpenKeyW returned %d\n", rc);
 424         goto end;
 425     }
 426
 427     rc = RegQueryValueExW(key, valueName, NULL, NULL, NULL, &sz);
 428     if (rc)
 429     {
 430         TRACE("RegQueryValueExW returned %d\n", rc);
 431         goto end;
 432     }
 433     /* FIXME: sanity-check sz before allocating (is there an upper-limit
 434      * on the value of a property?)
 435      */
 436     value = msi_alloc( sz );
 437     rc = RegQueryValueExW(key, valueName, NULL, &regType, value, &sz);
 438     if (rc)
 439     {
 440         TRACE("RegQueryValueExW returned %d\n", rc);
 441         goto end;
 442     }
 443
 444     /* bail out if the registry key is empty */
 445     if (sz == 0)
 446         goto end;
 447
 448     if ((regType == REG_SZ || regType == REG_EXPAND_SZ) &&
 449         (ptr = strchrW((LPWSTR)value, '"')) && (end = strchrW(++ptr, '"')))
 450         *end = '\0';
 451     else
 452         ptr = (LPWSTR)value;
 453
 454     switch (type & 0x0f)
 455     {
 456     case msidbLocatorTypeDirectory:
 457         rc = ACTION_SearchDirectory(package, sig, ptr, 0, appValue);
 458         break;
 459     case msidbLocatorTypeFileName:
 460         *appValue = app_search_file(ptr, sig);
 461         break;
 462     case msidbLocatorTypeRawValue:
 463         ACTION_ConvertRegValue(regType, value, sz, appValue);
 464         break;
 465     default:
 466         FIXME("unimplemented for type %d (key path %s, value %s)\n",
 467               type, debugstr_w(keyPath), debugstr_w(valueName));
 468     }
 469 end:
 470     msi_free( value );
 471     RegCloseKey( key );
 472
 473     msi_free( keyPath );
 474     msi_free( valueName );
 475     msi_free( deformatted );
 476
 477     msiobj_release(&row->hdr);
 478
 479     return ERROR_SUCCESS;
 480 }
 481
 482 static LPWSTR get_ini_field(LPWSTR buf, int field)
 483 {
 484     LPWSTR beg, end;
 485     int i = 1;
 486
 487     if (field == 0)
 488         return strdupW(buf);
 489
 490     beg = buf;
 491     while ((end = strchrW(beg, ',')) && i < field)
 492     {
 493         beg = end + 1;
 494         while (*beg && *beg == ' ')
 495             beg++;
 496
 497         i++;
 498     }
 499
 500     end = strchrW(beg, ',');
 501     if (!end)
 502         end = beg + lstrlenW(beg);
 503
 504     *end = '\0';
 505     return strdupW(beg);
 506 }
 507
 508 static UINT ACTION_AppSearchIni(MSIPACKAGE *package, LPWSTR *appValue,
 509  MSISIGNATURE *sig)
 510 {
 511     static const WCHAR query[] =  {
 512         's','e','l','e','c','t',' ','*',' ',
 513         'f','r','o','m',' ',
 514         'I','n','i','L','o','c','a','t','o','r',' ',
 515         'w','h','e','r','e',' ',
 516         'S','i','g','n','a','t','u','r','e','_',' ','=',' ','\'','%','s','\'',0};
 517     MSIRECORD *row;
 518     LPWSTR fileName, section, key;
 519     int field, type;
 520     WCHAR buf[MAX_PATH];
 521
 522     TRACE("%s\n", debugstr_w(sig->Name));
 523
 524     *appValue = NULL;
 525
 526     row = MSI_QueryGetRecord( package->db, query, sig->Name );
 527     if (!row)
 528     {
 529         TRACE("failed to query IniLocator for %s\n", debugstr_w(sig->Name));
 530         return ERROR_SUCCESS;
 531     }
 532
 533     fileName = msi_dup_record_field(row, 2);
 534     section = msi_dup_record_field(row, 3);
 535     key = msi_dup_record_field(row, 4);
 536     field = MSI_RecordGetInteger(row, 5);
 537     type = MSI_RecordGetInteger(row, 6);
 538     if (field == MSI_NULL_INTEGER)
 539         field = 0;
 540     if (type == MSI_NULL_INTEGER)
 541         type = 0;
 542
 543     GetPrivateProfileStringW(section, key, NULL, buf, MAX_PATH, fileName);
 544     if (buf[0])
 545     {
 546         switch (type & 0x0f)
 547         {
 548         case msidbLocatorTypeDirectory:
 549             ACTION_SearchDirectory(package, sig, buf, 0, appValue);
 550             break;
 551         case msidbLocatorTypeFileName:
 552             *appValue = app_search_file(buf, sig);
 553             break;
 554         case msidbLocatorTypeRawValue:
 555             *appValue = get_ini_field(buf, field);
 556             break;
 557         }
 558     }
 559
 560     msi_free(fileName);
 561     msi_free(section);
 562     msi_free(key);
 563
 564     msiobj_release(&row->hdr);
 565
 566     return ERROR_SUCCESS;
 567 }
 568
 569 /* Expands the value in src into a path without property names and only
 570  * containing long path names into dst.  Replaces at most len characters of dst,
 571  * and always NULL-terminates dst if dst is not NULL and len >= 1.
 572  * May modify src.
 573  * Assumes src and dst are non-overlapping.
 574  * FIXME: return code probably needed:
 575  * - what does AppSearch return if the table values are invalid?
 576  * - what if dst is too small?
 577  */
 578 static void ACTION_ExpandAnyPath(MSIPACKAGE *package, WCHAR *src, WCHAR *dst,
 579  size_t len)
 580 {
 581     WCHAR *ptr, *deformatted;
 582
 583     if (!src || !dst || !len)
 584     {
 585         if (dst) *dst = '\0';
 586         return;
 587     }
 588
 589     dst[0] = '\0';
 590
 591     /* Ignore the short portion of the path */
 592     if ((ptr = strchrW(src, '|')))
 593         ptr++;
 594     else
 595         ptr = src;
 596
 597     deformat_string(package, ptr, &deformatted);
 598     if (!deformatted || strlenW(deformatted) > len - 1)
 599     {
 600         msi_free(deformatted);
 601         return;
 602     }
 603
 604     lstrcpyW(dst, deformatted);
 605     dst[lstrlenW(deformatted)] = '\0';
 606     msi_free(deformatted);
 607 }
 608
 609 /* Sets *matches to whether the file (whose path is filePath) matches the
 610  * versions set in sig.
 611  * Return ERROR_SUCCESS in case of success (whether or not the file matches),
 612  * something else if an install-halting error occurs.
 613  */
 614 static UINT ACTION_FileVersionMatches(const MSISIGNATURE *sig, LPCWSTR filePath,
 615  BOOL *matches)
 616 {
 617     UINT rc = ERROR_SUCCESS;
 618
 619     *matches = FALSE;
 620     if (sig->Languages)
 621     {
 622         FIXME(": need to check version for languages %s\n",
 623          debugstr_w(sig->Languages));
 624     }
 625     else
 626     {
 627         DWORD zero, size = GetFileVersionInfoSizeW(filePath, &zero);
 628
 629         if (size)
 630         {
 631             LPVOID buf = msi_alloc( size);
 632
 633             if (buf)
 634             {
 635                 UINT versionLen;
 636                 LPVOID subBlock = NULL;
 637
 638                 if (GetFileVersionInfoW(filePath, 0, size, buf))
 639                     VerQueryValueW(buf, szBackSlash, &subBlock, &versionLen);
 640                 if (subBlock)
 641                 {
 642                     VS_FIXEDFILEINFO *info = subBlock;
 643
 644                     TRACE("Comparing file version %d.%d.%d.%d:\n",
 645                      HIWORD(info->dwFileVersionMS),
 646                      LOWORD(info->dwFileVersionMS),
 647                      HIWORD(info->dwFileVersionLS),
 648                      LOWORD(info->dwFileVersionLS));
 649                     if (info->dwFileVersionMS < sig->MinVersionMS
 650                      || (info->dwFileVersionMS == sig->MinVersionMS &&
 651                      info->dwFileVersionLS < sig->MinVersionLS))
 652                     {
 653                         TRACE("Less than minimum version %d.%d.%d.%d\n",
 654                          HIWORD(sig->MinVersionMS),
 655                          LOWORD(sig->MinVersionMS),
 656                          HIWORD(sig->MinVersionLS),
 657                          LOWORD(sig->MinVersionLS));
 658                     }
 659                     else if ((sig->MaxVersionMS || sig->MaxVersionLS) &&
 660                              (info->dwFileVersionMS > sig->MaxVersionMS ||
 661                               (info->dwFileVersionMS == sig->MaxVersionMS &&
 662                                info->dwFileVersionLS > sig->MaxVersionLS)))
 663                     {
 664                         TRACE("Greater than maximum version %d.%d.%d.%d\n",
 665                          HIWORD(sig->MaxVersionMS),
 666                          LOWORD(sig->MaxVersionMS),
 667                          HIWORD(sig->MaxVersionLS),
 668                          LOWORD(sig->MaxVersionLS));
 669                     }
 670                     else
 671                         *matches = TRUE;
 672                 }
 673                 msi_free( buf);
 674             }
 675             else
 676                 rc = ERROR_OUTOFMEMORY;
 677         }
 678     }
 679     return rc;
 680 }
 681
 682 /* Sets *matches to whether the file in findData matches that in sig.
 683  * fullFilePath is assumed to be the full path of the file specified in
 684  * findData, which may be necessary to compare the version.
 685  * Return ERROR_SUCCESS in case of success (whether or not the file matches),
 686  * something else if an install-halting error occurs.
 687  */
 688 static UINT ACTION_FileMatchesSig(const MSISIGNATURE *sig,
 689  const WIN32_FIND_DATAW *findData, LPCWSTR fullFilePath, BOOL *matches)
 690 {
 691     UINT rc = ERROR_SUCCESS;
 692
 693     *matches = TRUE;
 694     /* assumes the caller has already ensured the filenames match, so check
 695      * the other fields..
 696      */
 697     if (sig->MinTime.dwLowDateTime || sig->MinTime.dwHighDateTime)
 698     {
 699         if (findData->ftCreationTime.dwHighDateTime <
 700          sig->MinTime.dwHighDateTime ||
 701          (findData->ftCreationTime.dwHighDateTime == sig->MinTime.dwHighDateTime
 702          && findData->ftCreationTime.dwLowDateTime <
 703          sig->MinTime.dwLowDateTime))
 704             *matches = FALSE;
 705     }
 706     if (*matches && (sig->MaxTime.dwLowDateTime || sig->MaxTime.dwHighDateTime))
 707     {
 708         if (findData->ftCreationTime.dwHighDateTime >
 709          sig->MaxTime.dwHighDateTime ||
 710          (findData->ftCreationTime.dwHighDateTime == sig->MaxTime.dwHighDateTime
 711          && findData->ftCreationTime.dwLowDateTime >
 712          sig->MaxTime.dwLowDateTime))
 713             *matches = FALSE;
 714     }
 715     if (*matches && sig->MinSize && findData->nFileSizeLow < sig->MinSize)
 716         *matches = FALSE;
 717     if (*matches && sig->MaxSize && findData->nFileSizeLow > sig->MaxSize)
 718         *matches = FALSE;
 719     if (*matches && (sig->MinVersionMS || sig->MinVersionLS ||
 720      sig->MaxVersionMS || sig->MaxVersionLS))
 721         rc = ACTION_FileVersionMatches(sig, fullFilePath, matches);
 722     return rc;
 723 }
 724
 725 /* Recursively searches the directory dir for files that match the signature
 726  * sig, up to (depth + 1) levels deep.  That is, if depth is 0, it searches dir
 727  * (and only dir).  If depth is 1, searches dir and its immediate
 728  * subdirectories.
 729  * Assumes sig->File is not NULL.
 730  * Returns ERROR_SUCCESS on success (which may include non-critical errors),
 731  * something else on failures which should halt the install.
 732  */
 733 static UINT ACTION_RecurseSearchDirectory(MSIPACKAGE *package, LPWSTR *appValue,
 734  MSISIGNATURE *sig, LPCWSTR dir, int depth)
 735 {
 736     HANDLE hFind;
 737     WIN32_FIND_DATAW findData;
 738     UINT rc = ERROR_SUCCESS;
 739     size_t dirLen = lstrlenW(dir), fileLen = lstrlenW(sig->File);
 740     WCHAR subpath[MAX_PATH];
 741     WCHAR *buf;
 742     DWORD len;
 743
 744     static const WCHAR starDotStarW[] = { '*','.','*',0 };
 745
 746     TRACE("Searching directory %s for file %s, depth %d\n", debugstr_w(dir),
 747           debugstr_w(sig->File), depth);
 748
 749     if (depth < 0)
 750         return ERROR_SUCCESS;
 751
 752     *appValue = NULL;
 753     /* We need the buffer in both paths below, so go ahead and allocate it
 754      * here.  Add two because we might need to add a backslash if the dir name
 755      * isn't backslash-terminated.
 756      */
 757     len = dirLen + max(fileLen, strlenW(starDotStarW)) + 2;
 758     buf = msi_alloc(len * sizeof(WCHAR));
 759     if (!buf)
 760         return ERROR_OUTOFMEMORY;
 761
 762     lstrcpyW(buf, dir);
 763     PathAddBackslashW(buf);
 764     lstrcatW(buf, sig->File);
 765
 766     hFind = FindFirstFileW(buf, &findData);
 767     if (hFind != INVALID_HANDLE_VALUE)
 768     {
 769         if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
 770         {
 771             BOOL matches;
 772
 773             rc = ACTION_FileMatchesSig(sig, &findData, buf, &matches);
 774             if (rc == ERROR_SUCCESS && matches)
 775             {
 776                 TRACE("found file, returning %s\n", debugstr_w(buf));
 777                 *appValue = buf;
 778             }
 779         }
 780         FindClose(hFind);
 781     }
 782
 783     if (rc == ERROR_SUCCESS && !*appValue)
 784     {
 785         lstrcpyW(buf, dir);
 786         PathAddBackslashW(buf);
 787         lstrcatW(buf, starDotStarW);
 788
 789         hFind = FindFirstFileW(buf, &findData);
 790         if (hFind != INVALID_HANDLE_VALUE)
 791         {
 792             if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY &&
 793                 lstrcmpW(findData.cFileName, szDot) &&
 794                 lstrcmpW(findData.cFileName, szDotDot))
 795             {
 796                 lstrcpyW(subpath, dir);
 797                 PathAppendW(subpath, findData.cFileName);
 798                 rc = ACTION_RecurseSearchDirectory(package, appValue, sig,
 799                                                    subpath, depth - 1);
 800             }
 801
 802             while (rc == ERROR_SUCCESS && !*appValue &&
 803                    FindNextFileW(hFind, &findData) != 0)
 804             {
 805                 if (!lstrcmpW(findData.cFileName, szDot) ||
 806                     !lstrcmpW(findData.cFileName, szDotDot))
 807                     continue;
 808
 809                 lstrcpyW(subpath, dir);
 810                 PathAppendW(subpath, findData.cFileName);
 811                 if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 812                     rc = ACTION_RecurseSearchDirectory(package, appValue,
 813                                                        sig, subpath, depth - 1);
 814             }
 815
 816             FindClose(hFind);
 817         }
 818     }
 819
 820     if (*appValue != buf)
 821         msi_free(buf);
 822
 823     return rc;
 824 }
 825
 826 static UINT ACTION_CheckDirectory(MSIPACKAGE *package, LPCWSTR dir,
 827  LPWSTR *appValue)
 828 {
 829     DWORD attr = GetFileAttributesW(dir);
 830
 831     if (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY))
 832     {
 833         TRACE("directory exists, returning %s\n", debugstr_w(dir));
 834         *appValue = strdupW(dir);
 835     }
 836
 837     return ERROR_SUCCESS;
 838 }
 839
 840 static BOOL ACTION_IsFullPath(LPCWSTR path)
 841 {
 842     WCHAR first = toupperW(path[0]);
 843     BOOL ret;
 844
 845     if (first >= 'A' && first <= 'Z' && path[1] == ':')
 846         ret = TRUE;
 847     else if (path[0] == '\\' && path[1] == '\\')
 848         ret = TRUE;
 849     else
 850         ret = FALSE;
 851     return ret;
 852 }
 853
 854 static UINT ACTION_SearchDirectory(MSIPACKAGE *package, MSISIGNATURE *sig,
 855  LPCWSTR path, int depth, LPWSTR *appValue)
 856 {
 857     UINT rc;
 858     DWORD attr;
 859     LPWSTR val = NULL;
 860
 861     TRACE("%p, %p, %s, %d, %p\n", package, sig, debugstr_w(path), depth,
 862      appValue);
 863
 864     if (ACTION_IsFullPath(path))
 865     {
 866         if (sig->File)
 867             rc = ACTION_RecurseSearchDirectory(package, &val, sig, path, depth);
 868         else
 869         {
 870             /* Recursively searching a directory makes no sense when the
 871              * directory to search is the thing you're trying to find.
 872              */
 873             rc = ACTION_CheckDirectory(package, path, &val);
 874         }
 875     }
 876     else
 877     {
 878         WCHAR pathWithDrive[MAX_PATH] = { 'C',':','\\',0 };
 879         DWORD drives = GetLogicalDrives();
 880         int i;
 881
 882         rc = ERROR_SUCCESS;
 883         for (i = 0; rc == ERROR_SUCCESS && !val && i < 26; i++)
 884         {
 885             if (!(drives & (1 << i)))
 886                 continue;
 887
 888             pathWithDrive[0] = 'A' + i;
 889             if (GetDriveTypeW(pathWithDrive) != DRIVE_FIXED)
 890                 continue;
 891
 892             lstrcpynW(pathWithDrive + 3, path,
 893                       sizeof(pathWithDrive) / sizeof(pathWithDrive[0]) - 3);
 894
 895             if (sig->File)
 896                 rc = ACTION_RecurseSearchDirectory(package, &val, sig,
 897                                                    pathWithDrive, depth);
 898             else
 899                 rc = ACTION_CheckDirectory(package, pathWithDrive, &val);
 900         }
 901     }
 902
 903     attr = GetFileAttributesW(val);
 904     if (attr != INVALID_FILE_ATTRIBUTES &&
 905         (attr & FILE_ATTRIBUTE_DIRECTORY) &&
 906         val && val[lstrlenW(val) - 1] != '\\')
 907     {
 908         val = msi_realloc(val, (lstrlenW(val) + 2) * sizeof(WCHAR));
 909         if (!val)
 910             rc = ERROR_OUTOFMEMORY;
 911         else
 912             PathAddBackslashW(val);
 913     }
 914
 915     *appValue = val;
 916
 917     TRACE("returning %d\n", rc);
 918     return rc;
 919 }
 920
 921 static UINT ACTION_AppSearchSigName(MSIPACKAGE *package, LPCWSTR sigName,
 922  MSISIGNATURE *sig, LPWSTR *appValue);
 923
 924 static UINT ACTION_AppSearchDr(MSIPACKAGE *package, LPWSTR *appValue, MSISIGNATURE *sig)
 925 {
 926     static const WCHAR query[] =  {
 927         's','e','l','e','c','t',' ','*',' ',
 928         'f','r','o','m',' ',
 929         'D','r','L','o','c','a','t','o','r',' ',
 930         'w','h','e','r','e',' ',
 931         'S','i','g','n','a','t','u','r','e','_',' ','=',' ', '\'','%','s','\'',0};
 932     LPWSTR parentName = NULL, parent = NULL;
 933     WCHAR path[MAX_PATH];
 934     WCHAR expanded[MAX_PATH];
 935     MSIRECORD *row;
 936     int depth;
 937     DWORD sz, attr;
 938     UINT rc;
 939
 940     TRACE("%s\n", debugstr_w(sig->Name));
 941
 942     *appValue = NULL;
 943
 944     row = MSI_QueryGetRecord( package->db, query, sig->Name );
 945     if (!row)
 946     {
 947         TRACE("failed to query DrLocator for %s\n", debugstr_w(sig->Name));
 948         return ERROR_SUCCESS;
 949     }
 950
 951     /* check whether parent is set */
 952     parentName = msi_dup_record_field(row,2);
 953     if (parentName)
 954     {
 955         MSISIGNATURE parentSig;
 956
 957         rc = ACTION_AppSearchSigName(package, parentName, &parentSig, &parent);
 958         ACTION_FreeSignature(&parentSig);
 959         msi_free(parentName);
 960     }
 961
 962     sz = MAX_PATH;
 963     MSI_RecordGetStringW(row, 3, path, &sz);
 964
 965     if (MSI_RecordIsNull(row,4))
 966         depth = 0;
 967     else
 968         depth = MSI_RecordGetInteger(row,4);
 969
 970     if (sz)
 971         ACTION_ExpandAnyPath(package, path, expanded, MAX_PATH);
 972     else
 973         strcpyW(expanded, path);
 974
 975     if (parent)
 976     {
 977         attr = GetFileAttributesW(parent);
 978         if (attr != INVALID_FILE_ATTRIBUTES &&
 979             !(attr & FILE_ATTRIBUTE_DIRECTORY))
 980         {
 981             PathRemoveFileSpecW(parent);
 982             PathAddBackslashW(parent);
 983         }
 984
 985         strcpyW(path, parent);
 986         strcatW(path, expanded);
 987     }
 988     else if (sz)
 989         strcpyW(path, expanded);
 990
 991     PathAddBackslashW(path);
 992
 993     rc = ACTION_SearchDirectory(package, sig, path, depth, appValue);
 994
 995     msi_free(parent);
 996     msiobj_release(&row->hdr);
 997
 998     TRACE("returning %d\n", rc);
 999     return rc;
1000 }
1001
1002 static UINT ACTION_AppSearchSigName(MSIPACKAGE *package, LPCWSTR sigName,
1003  MSISIGNATURE *sig, LPWSTR *appValue)
1004 {
1005     UINT rc;
1006
1007     *appValue = NULL;
1008     rc = ACTION_AppSearchGetSignature(package, sig, sigName);
1009     if (rc == ERROR_SUCCESS)
1010     {
1011         rc = ACTION_AppSearchComponents(package, appValue, sig);
1012         if (rc == ERROR_SUCCESS && !*appValue)
1013         {
1014             rc = ACTION_AppSearchReg(package, appValue, sig);
1015             if (rc == ERROR_SUCCESS && !*appValue)
1016             {
1017                 rc = ACTION_AppSearchIni(package, appValue, sig);
1018                 if (rc == ERROR_SUCCESS && !*appValue)
1019                     rc = ACTION_AppSearchDr(package, appValue, sig);
1020             }
1021         }
1022     }
1023     return rc;
1024 }
1025
1026 static UINT iterate_appsearch(MSIRECORD *row, LPVOID param)
1027 {
1028     MSIPACKAGE *package = param;
1029     LPCWSTR propName, sigName;
1030     LPWSTR value = NULL;
1031     MSISIGNATURE sig;
1032     MSIRECORD *uirow;
1033     UINT r;
1034
1035     /* get property and signature */
1036     propName = MSI_RecordGetString(row, 1);
1037     sigName = MSI_RecordGetString(row, 2);
1038
1039     TRACE("%s %s\n", debugstr_w(propName), debugstr_w(sigName));
1040
1041     r = ACTION_AppSearchSigName(package, sigName, &sig, &value);
1042     if (value)
1043     {
1044         MSI_SetPropertyW(package, propName, value);
1045         msi_free(value);
1046     }
1047     ACTION_FreeSignature(&sig);
1048
1049     uirow = MSI_CreateRecord( 2 );
1050     MSI_RecordSetStringW( uirow, 1, propName );
1051     MSI_RecordSetStringW( uirow, 2, sigName );
1052     ui_actiondata( package, szAppSearch, uirow );
1053     msiobj_release( &uirow->hdr );
1054
1055     return r;
1056 }
1057
1058 UINT ACTION_AppSearch(MSIPACKAGE *package)
1059 {
1060     static const WCHAR query[] =  {
1061         's','e','l','e','c','t',' ','*',' ',
1062         'f','r','o','m',' ',
1063         'A','p','p','S','e','a','r','c','h',0};
1064     MSIQUERY *view = NULL;
1065     UINT r;
1066
1067     r = MSI_OpenQuery( package->db, &view, query );
1068     if (r != ERROR_SUCCESS)
1069         return ERROR_SUCCESS;
1070
1071     r = MSI_IterateRecords( view, NULL, iterate_appsearch, package );
1072     msiobj_release( &view->hdr );
1073
1074     return r;
1075 }
1076
1077 static UINT ITERATE_CCPSearch(MSIRECORD *row, LPVOID param)
1078 {
1079     MSIPACKAGE *package = param;
1080     LPCWSTR signature;
1081     LPWSTR value = NULL;
1082     MSISIGNATURE sig;
1083     UINT r = ERROR_SUCCESS;
1084
1085     static const WCHAR success[] = {'C','C','P','_','S','u','c','c','e','s','s',0};
1086
1087     signature = MSI_RecordGetString(row, 1);
1088
1089     TRACE("%s\n", debugstr_w(signature));
1090
1091     ACTION_AppSearchSigName(package, signature, &sig, &value);
1092     if (value)
1093     {
1094         TRACE("Found signature %s\n", debugstr_w(signature));
1095         MSI_SetPropertyW(package, success, szOne);
1096         msi_free(value);
1097         r = ERROR_NO_MORE_ITEMS;
1098     }
1099
1100     ACTION_FreeSignature(&sig);
1101
1102     return r;
1103 }
1104
1105 UINT ACTION_CCPSearch(MSIPACKAGE *package)
1106 {
1107     static const WCHAR query[] =  {
1108         's','e','l','e','c','t',' ','*',' ',
1109         'f','r','o','m',' ',
1110         'C','C','P','S','e','a','r','c','h',0};
1111     MSIQUERY *view = NULL;
1112     UINT r;
1113
1114     r = MSI_OpenQuery(package->db, &view, query);
1115     if (r != ERROR_SUCCESS)
1116         return ERROR_SUCCESS;
1117
1118     r = MSI_IterateRecords(view, NULL, ITERATE_CCPSearch, package);
1119     msiobj_release(&view->hdr);
1120
1121     return r;
1122 }