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