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