oleaut32: Implement ITypeLibComp::BindType.
[wine] / dlls / msi / registry.c
1 /*
2  * Implementation of the Microsoft Installer (msi.dll)
3  *
4  * Copyright 2005 Mike McCormack for CodeWeavers
5  * Copyright 2005 Aric Stewart for CodeWeavers
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include <stdarg.h>
23
24 #define COBJMACROS
25 #define NONAMELESSUNION
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "winreg.h"
30 #include "winnls.h"
31 #include "shlwapi.h"
32 #include "wine/debug.h"
33 #include "msi.h"
34 #include "msipriv.h"
35 #include "wincrypt.h"
36 #include "wine/unicode.h"
37 #include "winver.h"
38 #include "winuser.h"
39 #include "sddl.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(msi);
42
43
44 /* 
45  * This module will be all the helper functions for registry access by the
46  * installer bits. 
47  */
48 static const WCHAR szUserFeatures_fmt[] = {
49 'S','o','f','t','w','a','r','e','\\',
50 'M','i','c','r','o','s','o','f','t','\\',
51 'I','n','s','t','a','l','l','e','r','\\',
52 'F','e','a','t','u','r','e','s','\\',
53 '%','s',0};
54
55 static const WCHAR szUserDataFeatures_fmt[] = {
56 'S','o','f','t','w','a','r','e','\\',
57 'M','i','c','r','o','s','o','f','t','\\',
58 'W','i','n','d','o','w','s','\\',
59 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
60 'I','n','s','t','a','l','l','e','r','\\',
61 'U','s','e','r','D','a','t','a','\\',
62 '%','s','\\','P','r','o','d','u','c','t','s','\\',
63 '%','s','\\','F','e','a','t','u','r','e','s',0};
64
65 static const WCHAR szInstaller_Features_fmt[] = {
66 'S','o','f','t','w','a','r','e','\\',
67 'M','i','c','r','o','s','o','f','t','\\',
68 'W','i','n','d','o','w','s','\\',
69 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
70 'I','n','s','t','a','l','l','e','r','\\',
71 'F','e','a','t','u','r','e','s','\\',
72 '%','s',0};
73
74 static const WCHAR szInstaller_Components[] = {
75 'S','o','f','t','w','a','r','e','\\',
76 'M','i','c','r','o','s','o','f','t','\\',
77 'W','i','n','d','o','w','s','\\',
78 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
79 'I','n','s','t','a','l','l','e','r','\\',
80 'C','o','m','p','o','n','e','n','t','s',0 };
81
82 static const WCHAR szUser_Components_fmt[] = {
83 'S','o','f','t','w','a','r','e','\\',
84 'M','i','c','r','o','s','o','f','t','\\',
85 'I','n','s','t','a','l','l','e','r','\\',
86 'C','o','m','p','o','n','e','n','t','s','\\',
87 '%','s',0};
88
89 static const WCHAR szUserDataComp_fmt[] = {
90 'S','o','f','t','w','a','r','e','\\',
91 'M','i','c','r','o','s','o','f','t','\\',
92 'W','i','n','d','o','w','s','\\',
93 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
94 'I','n','s','t','a','l','l','e','r','\\',
95 'U','s','e','r','D','a','t','a','\\',
96 '%','s','\\','C','o','m','p','o','n','e','n','t','s','\\','%','s',0};
97
98 static const WCHAR szUninstall_fmt[] = {
99 'S','o','f','t','w','a','r','e','\\',
100 'M','i','c','r','o','s','o','f','t','\\',
101 'W','i','n','d','o','w','s','\\',
102 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
103 'U','n','i','n','s','t','a','l','l','\\',
104 '%','s',0 };
105
106 static const WCHAR szUserProduct[] = {
107 'S','o','f','t','w','a','r','e','\\',
108 'M','i','c','r','o','s','o','f','t','\\',
109 'I','n','s','t','a','l','l','e','r','\\',
110 'P','r','o','d','u','c','t','s',0};
111
112 static const WCHAR szUserProduct_fmt[] = {
113 'S','o','f','t','w','a','r','e','\\',
114 'M','i','c','r','o','s','o','f','t','\\',
115 'I','n','s','t','a','l','l','e','r','\\',
116 'P','r','o','d','u','c','t','s','\\',
117 '%','s',0};
118
119 static const WCHAR szUserPatch_fmt[] = {
120 'S','o','f','t','w','a','r','e','\\',
121 'M','i','c','r','o','s','o','f','t','\\',
122 'I','n','s','t','a','l','l','e','r','\\',
123 'P','a','t','c','h','e','s','\\',
124 '%','s',0};
125
126 static const WCHAR szInstaller_Products[] = {
127 'S','o','f','t','w','a','r','e','\\',
128 'M','i','c','r','o','s','o','f','t','\\',
129 'W','i','n','d','o','w','s','\\',
130 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
131 'I','n','s','t','a','l','l','e','r','\\',
132 'P','r','o','d','u','c','t','s',0};
133
134 static const WCHAR szInstaller_Products_fmt[] = {
135 'S','o','f','t','w','a','r','e','\\',
136 'M','i','c','r','o','s','o','f','t','\\',
137 'W','i','n','d','o','w','s','\\',
138 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
139 'I','n','s','t','a','l','l','e','r','\\',
140 'P','r','o','d','u','c','t','s','\\',
141 '%','s',0};
142
143 static const WCHAR szInstaller_Patches_fmt[] = {
144 'S','o','f','t','w','a','r','e','\\',
145 'M','i','c','r','o','s','o','f','t','\\',
146 'W','i','n','d','o','w','s','\\',
147 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
148 'I','n','s','t','a','l','l','e','r','\\',
149 'P','a','t','c','h','e','s','\\',
150 '%','s',0};
151
152 static const WCHAR szInstaller_UpgradeCodes_fmt[] = {
153 'S','o','f','t','w','a','r','e','\\',
154 'M','i','c','r','o','s','o','f','t','\\',
155 'W','i','n','d','o','w','s','\\',
156 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
157 'I','n','s','t','a','l','l','e','r','\\',
158 'U','p','g','r','a','d','e','C','o','d','e','s','\\',
159 '%','s',0};
160
161 static const WCHAR szInstaller_UserUpgradeCodes_fmt[] = {
162 'S','o','f','t','w','a','r','e','\\',
163 'M','i','c','r','o','s','o','f','t','\\',
164 'I','n','s','t','a','l','l','e','r','\\',
165 'U','p','g','r','a','d','e','C','o','d','e','s','\\',
166 '%','s',0};
167
168 static const WCHAR szUserDataProd_fmt[] = {
169 'S','o','f','t','w','a','r','e','\\',
170 'M','i','c','r','o','s','o','f','t','\\',
171 'W','i','n','d','o','w','s','\\',
172 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
173 'I','n','s','t','a','l','l','e','r','\\',
174 'U','s','e','r','D','a','t','a','\\',
175 '%','s','\\','P','r','o','d','u','c','t','s','\\','%','s',0};
176
177 static const WCHAR szUserDataPatch_fmt[] = {
178 'S','o','f','t','w','a','r','e','\\',
179 'M','i','c','r','o','s','o','f','t','\\',
180 'W','i','n','d','o','w','s','\\',
181 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
182 'I','n','s','t','a','l','l','e','r','\\',
183 'U','s','e','r','D','a','t','a','\\',
184 '%','s','\\','P','a','t','c','h','e','s','\\','%','s',0};
185
186 static const WCHAR szInstallProperties_fmt[] = {
187 'S','o','f','t','w','a','r','e','\\',
188 'M','i','c','r','o','s','o','f','t','\\',
189 'W','i','n','d','o','w','s','\\',
190 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
191 'I','n','s','t','a','l','l','e','r','\\',
192 'U','s','e','r','D','a','t','a','\\',
193 '%','s','\\','P','r','o','d','u','c','t','s','\\','%','s','\\',
194 'I','n','s','t','a','l','l','P','r','o','p','e','r','t','i','e','s',0};
195
196 static const WCHAR szInstaller_LocalClassesProd[] = {
197 'S','o','f','t','w','a','r','e','\\',
198 'C','l','a','s','s','e','s','\\',
199 'I','n','s','t','a','l','l','e','r','\\',
200 'P','r','o','d','u','c','t','s',0};
201
202 static const WCHAR szInstaller_LocalClassesProd_fmt[] = {
203 'S','o','f','t','w','a','r','e','\\',
204 'C','l','a','s','s','e','s','\\',
205 'I','n','s','t','a','l','l','e','r','\\',
206 'P','r','o','d','u','c','t','s','\\','%','s',0};
207
208 static const WCHAR szInstaller_LocalClassesFeat_fmt[] = {
209 'S','o','f','t','w','a','r','e','\\',
210 'C','l','a','s','s','e','s','\\',
211 'I','n','s','t','a','l','l','e','r','\\',
212 'F','e','a','t','u','r','e','s','\\','%','s',0};
213
214 static const WCHAR szInstaller_LocalManaged_fmt[] = {
215 'S','o','f','t','w','a','r','e','\\',
216 'M','i','c','r','o','s','o','f','t','\\',
217 'W','i','n','d','o','w','s','\\',
218 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
219 'I','n','s','t','a','l','l','e','r','\\',
220 'M','a','n','a','g','e','d','\\','%','s','\\',
221 'I','n','s','t','a','l','l','e','r','\\',
222 'P','r','o','d','u','c','t','s',0};
223
224 static const WCHAR szInstaller_LocalManagedProd_fmt[] = {
225 'S','o','f','t','w','a','r','e','\\',
226 'M','i','c','r','o','s','o','f','t','\\',
227 'W','i','n','d','o','w','s','\\',
228 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
229 'I','n','s','t','a','l','l','e','r','\\',
230 'M','a','n','a','g','e','d','\\','%','s','\\',
231 'I','n','s','t','a','l','l','e','r','\\',
232 'P','r','o','d','u','c','t','s','\\','%','s',0};
233
234 static const WCHAR szInstaller_LocalManagedFeat_fmt[] = {
235 'S','o','f','t','w','a','r','e','\\',
236 'M','i','c','r','o','s','o','f','t','\\',
237 'W','i','n','d','o','w','s','\\',
238 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
239 'I','n','s','t','a','l','l','e','r','\\',
240 'M','a','n','a','g','e','d','\\','%','s','\\',
241 'I','n','s','t','a','l','l','e','r','\\',
242 'F','e','a','t','u','r','e','s','\\','%','s',0};
243
244 static const WCHAR szInstaller_ClassesUpgrade_fmt[] = {
245 'I','n','s','t','a','l','l','e','r','\\',
246 'U','p','g','r','a','d','e','C','o','d','e','s','\\',
247 '%','s',0};
248
249 BOOL unsquash_guid(LPCWSTR in, LPWSTR out)
250 {
251     DWORD i,n=0;
252
253     if (lstrlenW(in) != 32)
254         return FALSE;
255
256     out[n++]='{';
257     for(i=0; i<8; i++)
258         out[n++] = in[7-i];
259     out[n++]='-';
260     for(i=0; i<4; i++)
261         out[n++] = in[11-i];
262     out[n++]='-';
263     for(i=0; i<4; i++)
264         out[n++] = in[15-i];
265     out[n++]='-';
266     for(i=0; i<2; i++)
267     {
268         out[n++] = in[17+i*2];
269         out[n++] = in[16+i*2];
270     }
271     out[n++]='-';
272     for( ; i<8; i++)
273     {
274         out[n++] = in[17+i*2];
275         out[n++] = in[16+i*2];
276     }
277     out[n++]='}';
278     out[n]=0;
279     return TRUE;
280 }
281
282 BOOL squash_guid(LPCWSTR in, LPWSTR out)
283 {
284     DWORD i,n=1;
285     GUID guid;
286
287     out[0] = 0;
288
289     if (FAILED(CLSIDFromString((LPOLESTR)in, &guid)))
290         return FALSE;
291
292     for(i=0; i<8; i++)
293         out[7-i] = in[n++];
294     n++;
295     for(i=0; i<4; i++)
296         out[11-i] = in[n++];
297     n++;
298     for(i=0; i<4; i++)
299         out[15-i] = in[n++];
300     n++;
301     for(i=0; i<2; i++)
302     {
303         out[17+i*2] = in[n++];
304         out[16+i*2] = in[n++];
305     }
306     n++;
307     for( ; i<8; i++)
308     {
309         out[17+i*2] = in[n++];
310         out[16+i*2] = in[n++];
311     }
312     out[32]=0;
313     return TRUE;
314 }
315
316
317 /* tables for encoding and decoding base85 */
318 static const unsigned char table_dec85[0x80] = {
319 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
320 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
321 0xff,0x00,0xff,0xff,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0xff,
322 0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0xff,0xff,0xff,0x16,0xff,0x17,
323 0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
324 0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,0x30,0x31,0x32,0x33,0xff,0x34,0x35,0x36,
325 0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,0x40,0x41,0x42,0x43,0x44,0x45,0x46,
326 0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,0x51,0x52,0xff,0x53,0x54,0xff,
327 };
328
329 static const char table_enc85[] =
330 "!$%&'()*+,-.0123456789=?@ABCDEFGHIJKLMNO"
331 "PQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwx"
332 "yz{}~";
333
334 /*
335  *  Converts a base85 encoded guid into a GUID pointer
336  *  Base85 encoded GUIDs should be 20 characters long.
337  *
338  *  returns TRUE if successful, FALSE if not
339  */
340 BOOL decode_base85_guid( LPCWSTR str, GUID *guid )
341 {
342     DWORD i, val = 0, base = 1, *p;
343
344     if (!str)
345         return FALSE;
346
347     p = (DWORD*) guid;
348     for( i=0; i<20; i++ )
349     {
350         if( (i%5) == 0 )
351         {
352             val = 0;
353             base = 1;
354         }
355         val += table_dec85[str[i]] * base;
356         if( str[i] >= 0x80 )
357             return FALSE;
358         if( table_dec85[str[i]] == 0xff )
359             return FALSE;
360         if( (i%5) == 4 )
361             p[i/5] = val;
362         base *= 85;
363     }
364     return TRUE;
365 }
366
367 /*
368  *  Encodes a base85 guid given a GUID pointer
369  *  Caller should provide a 21 character buffer for the encoded string.
370  *
371  *  returns TRUE if successful, FALSE if not
372  */
373 BOOL encode_base85_guid( GUID *guid, LPWSTR str )
374 {
375     unsigned int x, *p, i;
376
377     p = (unsigned int*) guid;
378     for( i=0; i<4; i++ )
379     {
380         x = p[i];
381         *str++ = table_enc85[x%85];
382         x = x/85;
383         *str++ = table_enc85[x%85];
384         x = x/85;
385         *str++ = table_enc85[x%85];
386         x = x/85;
387         *str++ = table_enc85[x%85];
388         x = x/85;
389         *str++ = table_enc85[x%85];
390     }
391     *str = 0;
392
393     return TRUE;
394 }
395
396 DWORD msi_version_str_to_dword(LPCWSTR p)
397 {
398     DWORD major, minor = 0, build = 0, version = 0;
399
400     if (!p)
401         return version;
402
403     major = atoiW(p);
404
405     p = strchrW(p, '.');
406     if (p)
407     {
408         minor = atoiW(p+1);
409         p = strchrW(p+1, '.');
410         if (p)
411             build = atoiW(p+1);
412     }
413
414     return MAKELONG(build, MAKEWORD(minor, major));
415 }
416
417 LONG msi_reg_set_val_str( HKEY hkey, LPCWSTR name, LPCWSTR value )
418 {
419     static const WCHAR emptyW[] = {0};
420     DWORD len;
421     if (!value) value = emptyW;
422     len = (lstrlenW(value) + 1) * sizeof (WCHAR);
423     return RegSetValueExW( hkey, name, 0, REG_SZ, (const BYTE *)value, len );
424 }
425
426 LONG msi_reg_set_val_multi_str( HKEY hkey, LPCWSTR name, LPCWSTR value )
427 {
428     LPCWSTR p = value;
429     while (*p) p += lstrlenW(p) + 1;
430     return RegSetValueExW( hkey, name, 0, REG_MULTI_SZ,
431                            (const BYTE *)value, (p + 1 - value) * sizeof(WCHAR) );
432 }
433
434 LONG msi_reg_set_val_dword( HKEY hkey, LPCWSTR name, DWORD val )
435 {
436     return RegSetValueExW( hkey, name, 0, REG_DWORD, (LPBYTE)&val, sizeof (DWORD) );
437 }
438
439 LONG msi_reg_set_subkey_val( HKEY hkey, LPCWSTR path, LPCWSTR name, LPCWSTR val )
440 {
441     HKEY hsubkey = 0;
442     LONG r;
443
444     r = RegCreateKeyW( hkey, path, &hsubkey );
445     if (r != ERROR_SUCCESS)
446         return r;
447     r = msi_reg_set_val_str( hsubkey, name, val );
448     RegCloseKey( hsubkey );
449     return r;
450 }
451
452 LPWSTR msi_reg_get_val_str( HKEY hkey, LPCWSTR name )
453 {
454     DWORD len = 0;
455     LPWSTR val;
456     LONG r;
457
458     r = RegQueryValueExW(hkey, name, NULL, NULL, NULL, &len);
459     if (r != ERROR_SUCCESS)
460         return NULL;
461
462     len += sizeof (WCHAR);
463     val = msi_alloc( len );
464     if (!val)
465         return NULL;
466     val[0] = 0;
467     RegQueryValueExW(hkey, name, NULL, NULL, (LPBYTE) val, &len);
468     return val;
469 }
470
471 BOOL msi_reg_get_val_dword( HKEY hkey, LPCWSTR name, DWORD *val)
472 {
473     DWORD type, len = sizeof (DWORD);
474     LONG r = RegQueryValueExW(hkey, name, NULL, &type, (LPBYTE) val, &len);
475     return r == ERROR_SUCCESS && type == REG_DWORD;
476 }
477
478 static UINT get_user_sid(LPWSTR *usersid)
479 {
480     HANDLE token;
481     BYTE buf[1024];
482     DWORD size;
483     PTOKEN_USER user;
484
485     if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token))
486         return ERROR_FUNCTION_FAILED;
487
488     size = sizeof(buf);
489     if (!GetTokenInformation(token, TokenUser, buf, size, &size)) {
490         CloseHandle(token);
491         return ERROR_FUNCTION_FAILED;
492     }
493
494     user = (PTOKEN_USER)buf;
495     if (!ConvertSidToStringSidW(user->User.Sid, usersid)) {
496         CloseHandle(token);
497         return ERROR_FUNCTION_FAILED;
498     }
499     CloseHandle(token);
500     return ERROR_SUCCESS;
501 }
502
503 UINT MSIREG_OpenUninstallKey(LPCWSTR szProduct, HKEY* key, BOOL create)
504 {
505     UINT rc;
506     WCHAR keypath[0x200];
507     TRACE("%s\n",debugstr_w(szProduct));
508
509     sprintfW(keypath,szUninstall_fmt,szProduct);
510
511     if (create)
512         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE, keypath, key);
513     else
514         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE, keypath, key);
515
516     return rc;
517 }
518
519 UINT MSIREG_DeleteUninstallKey(LPCWSTR szProduct)
520 {
521     WCHAR keypath[0x200];
522     TRACE("%s\n",debugstr_w(szProduct));
523
524     sprintfW(keypath,szUninstall_fmt,szProduct);
525
526     return RegDeleteTreeW(HKEY_LOCAL_MACHINE, keypath);
527 }
528
529 UINT MSIREG_OpenProductKey(LPCWSTR szProduct, LPCWSTR szUserSid,
530                            MSIINSTALLCONTEXT context, HKEY *key, BOOL create)
531 {
532     UINT r;
533     LPWSTR usersid = NULL;
534     HKEY root = HKEY_LOCAL_MACHINE;
535     WCHAR squished_pc[GUID_SIZE];
536     WCHAR keypath[MAX_PATH];
537
538     TRACE("(%s, %d, %d)\n", debugstr_w(szProduct), context, create);
539
540     if (!squash_guid(szProduct, squished_pc))
541         return ERROR_FUNCTION_FAILED;
542
543     TRACE("squished (%s)\n", debugstr_w(squished_pc));
544
545     if (context == MSIINSTALLCONTEXT_MACHINE)
546     {
547         sprintfW(keypath, szInstaller_LocalClassesProd_fmt, squished_pc);
548     }
549     else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
550     {
551         root = HKEY_CURRENT_USER;
552         sprintfW(keypath, szUserProduct_fmt, squished_pc);
553     }
554     else
555     {
556         if (!szUserSid)
557         {
558             r = get_user_sid(&usersid);
559             if (r != ERROR_SUCCESS || !usersid)
560             {
561                 ERR("Failed to retrieve user SID: %d\n", r);
562                 return r;
563             }
564
565             szUserSid = usersid;
566         }
567
568         sprintfW(keypath, szInstaller_LocalManagedProd_fmt,
569                  szUserSid, squished_pc);
570         LocalFree(usersid);
571     }
572
573     if (create)
574         return RegCreateKeyW(root, keypath, key);
575
576     return RegOpenKeyW(root, keypath, key);
577 }
578
579 UINT MSIREG_DeleteUserProductKey(LPCWSTR szProduct)
580 {
581     WCHAR squished_pc[GUID_SIZE];
582     WCHAR keypath[0x200];
583
584     TRACE("%s\n",debugstr_w(szProduct));
585     if (!squash_guid(szProduct,squished_pc))
586         return ERROR_FUNCTION_FAILED;
587     TRACE("squished (%s)\n", debugstr_w(squished_pc));
588
589     sprintfW(keypath,szUserProduct_fmt,squished_pc);
590
591     return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
592 }
593
594 UINT MSIREG_OpenUserPatchesKey(LPCWSTR szPatch, HKEY* key, BOOL create)
595 {
596     UINT rc;
597     WCHAR squished_pc[GUID_SIZE];
598     WCHAR keypath[0x200];
599
600     TRACE("%s\n",debugstr_w(szPatch));
601     if (!squash_guid(szPatch,squished_pc))
602         return ERROR_FUNCTION_FAILED;
603     TRACE("squished (%s)\n", debugstr_w(squished_pc));
604
605     sprintfW(keypath,szUserPatch_fmt,squished_pc);
606
607     if (create)
608         rc = RegCreateKeyW(HKEY_CURRENT_USER,keypath,key);
609     else
610         rc = RegOpenKeyW(HKEY_CURRENT_USER,keypath,key);
611
612     return rc;
613 }
614
615 UINT MSIREG_OpenFeaturesKey(LPCWSTR szProduct, MSIINSTALLCONTEXT context,
616                             HKEY *key, BOOL create)
617 {
618     UINT r;
619     LPWSTR usersid;
620     HKEY root = HKEY_LOCAL_MACHINE;
621     WCHAR squished_pc[GUID_SIZE];
622     WCHAR keypath[MAX_PATH];
623
624     TRACE("(%s, %d, %d)\n", debugstr_w(szProduct), context, create);
625
626     if (!squash_guid(szProduct, squished_pc))
627         return ERROR_FUNCTION_FAILED;
628
629     TRACE("squished (%s)\n", debugstr_w(squished_pc));
630
631     if (context == MSIINSTALLCONTEXT_MACHINE)
632     {
633         sprintfW(keypath, szInstaller_LocalClassesFeat_fmt, squished_pc);
634     }
635     else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
636     {
637         root = HKEY_CURRENT_USER;
638         sprintfW(keypath, szUserFeatures_fmt, squished_pc);
639     }
640     else
641     {
642         r = get_user_sid(&usersid);
643         if (r != ERROR_SUCCESS || !usersid)
644         {
645             ERR("Failed to retrieve user SID: %d\n", r);
646             return r;
647         }
648
649         sprintfW(keypath, szInstaller_LocalManagedFeat_fmt, usersid, squished_pc);
650         LocalFree(usersid);
651     }
652
653     if (create)
654         return RegCreateKeyW(root, keypath, key);
655
656     return RegOpenKeyW(root, keypath, key);
657 }
658
659 UINT MSIREG_DeleteUserFeaturesKey(LPCWSTR szProduct)
660 {
661     WCHAR squished_pc[GUID_SIZE];
662     WCHAR keypath[0x200];
663
664     TRACE("%s\n",debugstr_w(szProduct));
665     if (!squash_guid(szProduct,squished_pc))
666         return ERROR_FUNCTION_FAILED;
667     TRACE("squished (%s)\n", debugstr_w(squished_pc));
668
669     sprintfW(keypath,szUserFeatures_fmt,squished_pc);
670     return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
671 }
672
673 static UINT MSIREG_OpenInstallerFeaturesKey(LPCWSTR szProduct, HKEY* key, BOOL create)
674 {
675     UINT rc;
676     WCHAR squished_pc[GUID_SIZE];
677     WCHAR keypath[0x200];
678
679     TRACE("%s\n",debugstr_w(szProduct));
680     if (!squash_guid(szProduct,squished_pc))
681         return ERROR_FUNCTION_FAILED;
682     TRACE("squished (%s)\n", debugstr_w(squished_pc));
683
684     sprintfW(keypath,szInstaller_Features_fmt,squished_pc);
685
686     if (create)
687         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE,keypath,key);
688     else
689         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,keypath,key);
690
691     return rc;
692 }
693
694 UINT MSIREG_OpenUserDataFeaturesKey(LPCWSTR szProduct, MSIINSTALLCONTEXT context,
695                                     HKEY *key, BOOL create)
696 {
697     UINT r;
698     LPWSTR usersid;
699     WCHAR squished_pc[GUID_SIZE];
700     WCHAR keypath[0x200];
701
702     TRACE("(%s, %d, %d)\n", debugstr_w(szProduct), context, create);
703
704     if (!squash_guid(szProduct, squished_pc))
705         return ERROR_FUNCTION_FAILED;
706
707     TRACE("squished (%s)\n", debugstr_w(squished_pc));
708
709     if (context == MSIINSTALLCONTEXT_MACHINE)
710     {
711         sprintfW(keypath, szUserDataFeatures_fmt, szLocalSid, squished_pc);
712     }
713     else
714     {
715         r = get_user_sid(&usersid);
716         if (r != ERROR_SUCCESS || !usersid)
717         {
718             ERR("Failed to retrieve user SID: %d\n", r);
719             return r;
720         }
721
722         sprintfW(keypath, szUserDataFeatures_fmt, usersid, squished_pc);
723         LocalFree(usersid);
724     }
725
726     if (create)
727         return RegCreateKeyW(HKEY_LOCAL_MACHINE, keypath, key);
728
729     return RegOpenKeyW(HKEY_LOCAL_MACHINE, keypath, key);
730 }
731
732 UINT MSIREG_OpenUserComponentsKey(LPCWSTR szComponent, HKEY* key, BOOL create)
733 {
734     UINT rc;
735     WCHAR squished_cc[GUID_SIZE];
736     WCHAR keypath[0x200];
737
738     TRACE("%s\n",debugstr_w(szComponent));
739     if (!squash_guid(szComponent,squished_cc))
740         return ERROR_FUNCTION_FAILED;
741     TRACE("squished (%s)\n", debugstr_w(squished_cc));
742
743     sprintfW(keypath,szUser_Components_fmt,squished_cc);
744
745     if (create)
746         rc = RegCreateKeyW(HKEY_CURRENT_USER,keypath,key);
747     else
748         rc = RegOpenKeyW(HKEY_CURRENT_USER,keypath,key);
749
750     return rc;
751 }
752
753 UINT MSIREG_OpenUserDataComponentKey(LPCWSTR szComponent, LPCWSTR szUserSid,
754                                      HKEY *key, BOOL create)
755 {
756     UINT rc;
757     WCHAR comp[GUID_SIZE];
758     WCHAR keypath[0x200];
759     LPWSTR usersid;
760
761     TRACE("%s\n", debugstr_w(szComponent));
762     if (!squash_guid(szComponent, comp))
763         return ERROR_FUNCTION_FAILED;
764     TRACE("squished (%s)\n", debugstr_w(comp));
765
766     if (!szUserSid)
767     {
768         rc = get_user_sid(&usersid);
769         if (rc != ERROR_SUCCESS || !usersid)
770         {
771             ERR("Failed to retrieve user SID: %d\n", rc);
772             return rc;
773         }
774
775         sprintfW(keypath, szUserDataComp_fmt, usersid, comp);
776         LocalFree(usersid);
777     }
778     else
779         sprintfW(keypath, szUserDataComp_fmt, szUserSid, comp);
780
781     if (create)
782         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE, keypath, key);
783     else
784         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE, keypath, key);
785
786     return rc;
787 }
788
789 UINT MSIREG_DeleteUserDataComponentKey(LPCWSTR szComponent, LPCWSTR szUserSid)
790 {
791     UINT rc;
792     WCHAR comp[GUID_SIZE];
793     WCHAR keypath[0x200];
794     LPWSTR usersid;
795
796     TRACE("%s\n", debugstr_w(szComponent));
797     if (!squash_guid(szComponent, comp))
798         return ERROR_FUNCTION_FAILED;
799     TRACE("squished (%s)\n", debugstr_w(comp));
800
801     if (!szUserSid)
802     {
803         rc = get_user_sid(&usersid);
804         if (rc != ERROR_SUCCESS || !usersid)
805         {
806             ERR("Failed to retrieve user SID: %d\n", rc);
807             return rc;
808         }
809
810         sprintfW(keypath, szUserDataComp_fmt, usersid, comp);
811         LocalFree(usersid);
812     }
813     else
814         sprintfW(keypath, szUserDataComp_fmt, szUserSid, comp);
815
816     return RegDeleteTreeW(HKEY_LOCAL_MACHINE, keypath);
817 }
818
819 UINT MSIREG_OpenUserDataProductKey(LPCWSTR szProduct, MSIINSTALLCONTEXT dwContext,
820                                    LPCWSTR szUserSid, HKEY *key, BOOL create)
821 {
822     UINT rc;
823     WCHAR squished_pc[GUID_SIZE];
824     WCHAR keypath[0x200];
825     LPWSTR usersid;
826
827     TRACE("%s\n", debugstr_w(szProduct));
828     if (!squash_guid(szProduct, squished_pc))
829         return ERROR_FUNCTION_FAILED;
830     TRACE("squished (%s)\n", debugstr_w(squished_pc));
831
832     if (dwContext == MSIINSTALLCONTEXT_MACHINE)
833         sprintfW(keypath, szUserDataProd_fmt, szLocalSid, squished_pc);
834     else if (szUserSid)
835         sprintfW(keypath, szUserDataProd_fmt, szUserSid, squished_pc);
836     else
837     {
838         rc = get_user_sid(&usersid);
839         if (rc != ERROR_SUCCESS || !usersid)
840         {
841             ERR("Failed to retrieve user SID: %d\n", rc);
842             return rc;
843         }
844
845         sprintfW(keypath, szUserDataProd_fmt, usersid, squished_pc);
846         LocalFree(usersid);
847     }
848
849     if (create)
850         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE, keypath, key);
851     else
852         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE, keypath, key);
853
854     return rc;
855 }
856
857 UINT MSIREG_OpenUserDataPatchKey(LPCWSTR szPatch, MSIINSTALLCONTEXT dwContext,
858                                  HKEY *key, BOOL create)
859 {
860     UINT rc;
861     WCHAR squished_patch[GUID_SIZE];
862     WCHAR keypath[0x200];
863     LPWSTR usersid;
864
865     TRACE("%s\n", debugstr_w(szPatch));
866     if (!squash_guid(szPatch, squished_patch))
867         return ERROR_FUNCTION_FAILED;
868     TRACE("squished (%s)\n", debugstr_w(squished_patch));
869
870     if (dwContext == MSIINSTALLCONTEXT_MACHINE)
871         sprintfW(keypath, szUserDataPatch_fmt, szLocalSid, squished_patch);
872     else
873     {
874         rc = get_user_sid(&usersid);
875         if (rc != ERROR_SUCCESS || !usersid)
876         {
877             ERR("Failed to retrieve user SID: %d\n", rc);
878             return rc;
879         }
880
881         sprintfW(keypath, szUserDataPatch_fmt, usersid, squished_patch);
882         LocalFree(usersid);
883     }
884
885     if (create)
886         return RegCreateKeyW(HKEY_LOCAL_MACHINE, keypath, key);
887
888     return RegOpenKeyW(HKEY_LOCAL_MACHINE, keypath, key);
889 }
890
891 UINT MSIREG_OpenInstallProps(LPCWSTR szProduct, MSIINSTALLCONTEXT dwContext,
892                              LPCWSTR szUserSid, HKEY *key, BOOL create)
893 {
894     UINT rc;
895     LPWSTR usersid;
896     WCHAR squished_pc[GUID_SIZE];
897     WCHAR keypath[0x200];
898
899     TRACE("%s\n", debugstr_w(szProduct));
900     if (!squash_guid(szProduct, squished_pc))
901         return ERROR_FUNCTION_FAILED;
902     TRACE("squished (%s)\n", debugstr_w(squished_pc));
903
904     if (dwContext == MSIINSTALLCONTEXT_MACHINE)
905         sprintfW(keypath, szInstallProperties_fmt, szLocalSid, squished_pc);
906     else if (szUserSid)
907         sprintfW(keypath, szInstallProperties_fmt, szUserSid, squished_pc);
908     else
909     {
910         rc = get_user_sid(&usersid);
911         if (rc != ERROR_SUCCESS || !usersid)
912         {
913             ERR("Failed to retrieve user SID: %d\n", rc);
914             return rc;
915         }
916
917         sprintfW(keypath, szInstallProperties_fmt, usersid, squished_pc);
918         LocalFree(usersid);
919     }
920
921     if (create)
922         return RegCreateKeyW(HKEY_LOCAL_MACHINE, keypath, key);
923
924     return RegOpenKeyW(HKEY_LOCAL_MACHINE, keypath, key);
925 }
926
927 UINT MSIREG_DeleteUserDataProductKey(LPCWSTR szProduct)
928 {
929     UINT rc;
930     WCHAR squished_pc[GUID_SIZE];
931     WCHAR keypath[0x200];
932     LPWSTR usersid;
933
934     TRACE("%s\n", debugstr_w(szProduct));
935     if (!squash_guid(szProduct, squished_pc))
936         return ERROR_FUNCTION_FAILED;
937     TRACE("squished (%s)\n", debugstr_w(squished_pc));
938
939     rc = get_user_sid(&usersid);
940     if (rc != ERROR_SUCCESS || !usersid)
941     {
942         ERR("Failed to retrieve user SID: %d\n", rc);
943         return rc;
944     }
945
946     sprintfW(keypath, szUserDataProd_fmt, usersid, squished_pc);
947
948     LocalFree(usersid);
949     return RegDeleteTreeW(HKEY_LOCAL_MACHINE, keypath);
950 }
951
952 UINT MSIREG_DeleteProductKey(LPCWSTR szProduct)
953 {
954     WCHAR squished_pc[GUID_SIZE];
955     WCHAR keypath[0x200];
956
957     TRACE("%s\n", debugstr_w(szProduct));
958     if (!squash_guid(szProduct, squished_pc))
959         return ERROR_FUNCTION_FAILED;
960     TRACE("squished (%s)\n", debugstr_w(squished_pc));
961
962     sprintfW(keypath, szInstaller_Products_fmt, squished_pc);
963
964     return RegDeleteTreeW(HKEY_LOCAL_MACHINE, keypath);
965 }
966
967 UINT MSIREG_OpenPatchesKey(LPCWSTR szPatch, HKEY* key, BOOL create)
968 {
969     UINT rc;
970     WCHAR squished_pc[GUID_SIZE];
971     WCHAR keypath[0x200];
972
973     TRACE("%s\n",debugstr_w(szPatch));
974     if (!squash_guid(szPatch,squished_pc))
975         return ERROR_FUNCTION_FAILED;
976     TRACE("squished (%s)\n", debugstr_w(squished_pc));
977
978     sprintfW(keypath,szInstaller_Patches_fmt,squished_pc);
979
980     if (create)
981         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE,keypath,key);
982     else
983         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,keypath,key);
984
985     return rc;
986 }
987
988 UINT MSIREG_OpenUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY* key, BOOL create)
989 {
990     UINT rc;
991     WCHAR squished_pc[GUID_SIZE];
992     WCHAR keypath[0x200];
993
994     TRACE("%s\n",debugstr_w(szUpgradeCode));
995     if (!squash_guid(szUpgradeCode,squished_pc))
996         return ERROR_FUNCTION_FAILED;
997     TRACE("squished (%s)\n", debugstr_w(squished_pc));
998
999     sprintfW(keypath,szInstaller_UpgradeCodes_fmt,squished_pc);
1000
1001     if (create)
1002         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE,keypath,key);
1003     else
1004         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,keypath,key);
1005
1006     return rc;
1007 }
1008
1009 UINT MSIREG_OpenUserUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY* key, BOOL create)
1010 {
1011     UINT rc;
1012     WCHAR squished_pc[GUID_SIZE];
1013     WCHAR keypath[0x200];
1014
1015     TRACE("%s\n",debugstr_w(szUpgradeCode));
1016     if (!squash_guid(szUpgradeCode,squished_pc))
1017         return ERROR_FUNCTION_FAILED;
1018     TRACE("squished (%s)\n", debugstr_w(squished_pc));
1019
1020     sprintfW(keypath,szInstaller_UserUpgradeCodes_fmt,squished_pc);
1021
1022     if (create)
1023         rc = RegCreateKeyW(HKEY_CURRENT_USER,keypath,key);
1024     else
1025         rc = RegOpenKeyW(HKEY_CURRENT_USER,keypath,key);
1026
1027     return rc;
1028 }
1029
1030 UINT MSIREG_DeleteUserUpgradeCodesKey(LPCWSTR szUpgradeCode)
1031 {
1032     WCHAR squished_pc[GUID_SIZE];
1033     WCHAR keypath[0x200];
1034
1035     TRACE("%s\n",debugstr_w(szUpgradeCode));
1036     if (!squash_guid(szUpgradeCode,squished_pc))
1037         return ERROR_FUNCTION_FAILED;
1038     TRACE("squished (%s)\n", debugstr_w(squished_pc));
1039
1040     sprintfW(keypath,szInstaller_UserUpgradeCodes_fmt,squished_pc);
1041
1042     return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
1043 }
1044
1045 UINT MSIREG_DeleteLocalClassesProductKey(LPCWSTR szProductCode)
1046 {
1047     WCHAR squished_pc[GUID_SIZE];
1048     WCHAR keypath[0x200];
1049
1050     TRACE("%s\n", debugstr_w(szProductCode));
1051
1052     if (!squash_guid(szProductCode, squished_pc))
1053         return ERROR_FUNCTION_FAILED;
1054
1055     TRACE("squished (%s)\n", debugstr_w(squished_pc));
1056
1057     sprintfW(keypath, szInstaller_LocalClassesProd_fmt, squished_pc);
1058
1059     return RegDeleteTreeW(HKEY_LOCAL_MACHINE, keypath);
1060 }
1061
1062 UINT MSIREG_DeleteLocalClassesFeaturesKey(LPCWSTR szProductCode)
1063 {
1064     WCHAR squished_pc[GUID_SIZE];
1065     WCHAR keypath[0x200];
1066
1067     TRACE("%s\n", debugstr_w(szProductCode));
1068
1069     if (!squash_guid(szProductCode, squished_pc))
1070         return ERROR_FUNCTION_FAILED;
1071
1072     TRACE("squished (%s)\n", debugstr_w(squished_pc));
1073
1074     sprintfW(keypath, szInstaller_LocalClassesFeat_fmt, squished_pc);
1075
1076     return RegDeleteTreeW(HKEY_LOCAL_MACHINE, keypath);
1077 }
1078
1079 UINT MSIREG_OpenClassesUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY* key, BOOL create)
1080 {
1081     WCHAR squished_pc[GUID_SIZE];
1082     WCHAR keypath[0x200];
1083
1084     TRACE("%s\n", debugstr_w(szUpgradeCode));
1085     if (!squash_guid(szUpgradeCode, squished_pc))
1086         return ERROR_FUNCTION_FAILED;
1087     TRACE("squished (%s)\n", debugstr_w(squished_pc));
1088
1089     sprintfW(keypath, szInstaller_ClassesUpgrade_fmt, squished_pc);
1090
1091     if (create)
1092         return RegCreateKeyW(HKEY_CLASSES_ROOT, keypath, key);
1093
1094     return RegOpenKeyW(HKEY_CLASSES_ROOT, keypath, key);
1095 }
1096
1097 /*************************************************************************
1098  *  MsiDecomposeDescriptorW   [MSI.@]
1099  *
1100  * Decomposes an MSI descriptor into product, feature and component parts.
1101  * An MSI descriptor is a string of the form:
1102  *   [base 85 guid] [feature code] '>' [base 85 guid]
1103  *
1104  * PARAMS
1105  *   szDescriptor  [I]  the descriptor to decompose
1106  *   szProduct     [O]  buffer of MAX_FEATURE_CHARS+1 for the product guid
1107  *   szFeature     [O]  buffer of MAX_FEATURE_CHARS+1 for the feature code
1108  *   szComponent   [O]  buffer of MAX_FEATURE_CHARS+1 for the component guid
1109  *   pUsed         [O]  the length of the descriptor
1110  *
1111  * RETURNS
1112  *   ERROR_SUCCESS             if everything worked correctly
1113  *   ERROR_INVALID_PARAMETER   if the descriptor was invalid
1114  *
1115  */
1116 UINT WINAPI MsiDecomposeDescriptorW( LPCWSTR szDescriptor, LPWSTR szProduct,
1117                 LPWSTR szFeature, LPWSTR szComponent, LPDWORD pUsed )
1118 {
1119     UINT r, len;
1120     LPWSTR p;
1121     GUID product, component;
1122
1123     TRACE("%s %p %p %p %p\n", debugstr_w(szDescriptor), szProduct,
1124           szFeature, szComponent, pUsed);
1125
1126     r = decode_base85_guid( szDescriptor, &product );
1127     if( !r )
1128         return ERROR_INVALID_PARAMETER;
1129
1130     TRACE("product %s\n", debugstr_guid( &product ));
1131
1132     p = strchrW(&szDescriptor[20],'>');
1133     if( !p )
1134         return ERROR_INVALID_PARAMETER;
1135
1136     len = (p - &szDescriptor[20]);
1137     if( len > MAX_FEATURE_CHARS )
1138         return ERROR_INVALID_PARAMETER;
1139
1140     TRACE("feature %s\n", debugstr_wn( &szDescriptor[20], len ));
1141
1142     r = decode_base85_guid( p+1, &component );
1143     if( !r )
1144         return ERROR_INVALID_PARAMETER;
1145
1146     TRACE("component %s\n", debugstr_guid( &component ));
1147
1148     if (szProduct)
1149         StringFromGUID2( &product, szProduct, MAX_FEATURE_CHARS+1 );
1150     if (szComponent)
1151         StringFromGUID2( &component, szComponent, MAX_FEATURE_CHARS+1 );
1152     if (szFeature)
1153     {
1154         memcpy( szFeature, &szDescriptor[20], len*sizeof(WCHAR) );
1155         szFeature[len] = 0;
1156     }
1157     len = ( &p[21] - szDescriptor );
1158
1159     TRACE("length = %d\n", len);
1160     *pUsed = len;
1161
1162     return ERROR_SUCCESS;
1163 }
1164
1165 UINT WINAPI MsiDecomposeDescriptorA( LPCSTR szDescriptor, LPSTR szProduct,
1166                 LPSTR szFeature, LPSTR szComponent, LPDWORD pUsed )
1167 {
1168     WCHAR product[MAX_FEATURE_CHARS+1];
1169     WCHAR feature[MAX_FEATURE_CHARS+1];
1170     WCHAR component[MAX_FEATURE_CHARS+1];
1171     LPWSTR str = NULL, p = NULL, f = NULL, c = NULL;
1172     UINT r;
1173
1174     TRACE("%s %p %p %p %p\n", debugstr_a(szDescriptor), szProduct,
1175           szFeature, szComponent, pUsed);
1176
1177     str = strdupAtoW( szDescriptor );
1178     if( szDescriptor && !str )
1179         return ERROR_OUTOFMEMORY;
1180
1181     if (szProduct)
1182         p = product;
1183     if (szFeature)
1184         f = feature;
1185     if (szComponent)
1186         c = component;
1187
1188     r = MsiDecomposeDescriptorW( str, p, f, c, pUsed );
1189
1190     if (r == ERROR_SUCCESS)
1191     {
1192         WideCharToMultiByte( CP_ACP, 0, p, -1,
1193                              szProduct, MAX_FEATURE_CHARS+1, NULL, NULL );
1194         WideCharToMultiByte( CP_ACP, 0, f, -1,
1195                              szFeature, MAX_FEATURE_CHARS+1, NULL, NULL );
1196         WideCharToMultiByte( CP_ACP, 0, c, -1,
1197                              szComponent, MAX_FEATURE_CHARS+1, NULL, NULL );
1198     }
1199
1200     msi_free( str );
1201
1202     return r;
1203 }
1204
1205 UINT WINAPI MsiEnumProductsA(DWORD index, LPSTR lpguid)
1206 {
1207     DWORD r;
1208     WCHAR szwGuid[GUID_SIZE];
1209
1210     TRACE("%d %p\n", index, lpguid);
1211
1212     if (NULL == lpguid)
1213         return ERROR_INVALID_PARAMETER;
1214     r = MsiEnumProductsW(index, szwGuid);
1215     if( r == ERROR_SUCCESS )
1216         WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
1217
1218     return r;
1219 }
1220
1221 UINT WINAPI MsiEnumProductsW(DWORD index, LPWSTR lpguid)
1222 {
1223     UINT r;
1224     WCHAR szKeyName[SQUISH_GUID_SIZE];
1225     HKEY key;
1226     DWORD machine_count, managed_count, unmanaged_count;
1227     WCHAR keypath[MAX_PATH];
1228     LPWSTR usersid = NULL;
1229
1230     static DWORD last_index;
1231
1232     TRACE("%d %p\n", index, lpguid);
1233
1234     if (NULL == lpguid)
1235         return ERROR_INVALID_PARAMETER;
1236
1237     if (index && index - last_index != 1)
1238         return ERROR_INVALID_PARAMETER;
1239
1240     r = RegCreateKeyW(HKEY_LOCAL_MACHINE, szInstaller_LocalClassesProd, &key);
1241     if( r != ERROR_SUCCESS )
1242         return ERROR_NO_MORE_ITEMS;
1243
1244     r = RegQueryInfoKeyW(key, NULL, NULL, NULL, &machine_count, NULL, NULL,
1245                          NULL, NULL, NULL, NULL, NULL);
1246     if( r != ERROR_SUCCESS )
1247     {
1248         RegCloseKey(key);
1249         return ERROR_NO_MORE_ITEMS;
1250     }
1251
1252     if (machine_count && index <= machine_count)
1253     {
1254         r = RegEnumKeyW(key, index, szKeyName, SQUISH_GUID_SIZE);
1255         if( r == ERROR_SUCCESS )
1256         {
1257             unsquash_guid(szKeyName, lpguid);
1258             last_index = index;
1259             RegCloseKey(key);
1260             return ERROR_SUCCESS;
1261         }
1262     }
1263     RegCloseKey(key);
1264
1265     r = get_user_sid(&usersid);
1266     if (r != ERROR_SUCCESS || !usersid)
1267     {
1268         ERR("Failed to retrieve user SID: %d\n", r);
1269         return r;
1270     }
1271     sprintfW(keypath, szInstaller_LocalManaged_fmt, usersid);
1272     LocalFree(usersid);
1273
1274     r = RegCreateKeyW(HKEY_LOCAL_MACHINE, keypath, &key);
1275     if( r != ERROR_SUCCESS )
1276         return ERROR_NO_MORE_ITEMS;
1277
1278     r = RegQueryInfoKeyW(key, NULL, NULL, NULL, &managed_count, NULL, NULL,
1279                          NULL, NULL, NULL, NULL, NULL);
1280     if( r != ERROR_SUCCESS )
1281     {
1282         RegCloseKey(key);
1283         return ERROR_NO_MORE_ITEMS;
1284     }
1285
1286     if (managed_count && index <= machine_count + managed_count)
1287     {
1288         r = RegEnumKeyW(key, index - machine_count, szKeyName, SQUISH_GUID_SIZE);
1289         if( r == ERROR_SUCCESS )
1290         {
1291             unsquash_guid(szKeyName, lpguid);
1292             last_index = index;
1293             RegCloseKey(key);
1294             return ERROR_SUCCESS;
1295         }
1296     }
1297     RegCloseKey(key);
1298
1299     r = RegCreateKeyW(HKEY_CURRENT_USER, szUserProduct, &key);
1300     if( r != ERROR_SUCCESS )
1301         return ERROR_NO_MORE_ITEMS;
1302
1303     r = RegQueryInfoKeyW(key, NULL, NULL, NULL, &unmanaged_count, NULL, NULL,
1304                          NULL, NULL, NULL, NULL, NULL);
1305     if( r != ERROR_SUCCESS )
1306     {
1307         RegCloseKey(key);
1308         return ERROR_NO_MORE_ITEMS;
1309     }
1310
1311     if (unmanaged_count && index <= machine_count + managed_count + unmanaged_count)
1312     {
1313         r = RegEnumKeyW(key, index - machine_count - managed_count, szKeyName, SQUISH_GUID_SIZE);
1314         if( r == ERROR_SUCCESS )
1315         {
1316             unsquash_guid(szKeyName, lpguid);
1317             last_index = index;
1318             RegCloseKey(key);
1319             return ERROR_SUCCESS;
1320         }
1321     }
1322     RegCloseKey(key);
1323
1324     return ERROR_NO_MORE_ITEMS;
1325 }
1326
1327 UINT WINAPI MsiEnumFeaturesA(LPCSTR szProduct, DWORD index, 
1328       LPSTR szFeature, LPSTR szParent)
1329 {
1330     DWORD r;
1331     WCHAR szwFeature[GUID_SIZE], szwParent[GUID_SIZE];
1332     LPWSTR szwProduct = NULL;
1333
1334     TRACE("%s %d %p %p\n", debugstr_a(szProduct), index, szFeature, szParent);
1335
1336     if( szProduct )
1337     {
1338         szwProduct = strdupAtoW( szProduct );
1339         if( !szwProduct )
1340             return ERROR_OUTOFMEMORY;
1341     }
1342
1343     r = MsiEnumFeaturesW(szwProduct, index, szwFeature, szwParent);
1344     if( r == ERROR_SUCCESS )
1345     {
1346         WideCharToMultiByte(CP_ACP, 0, szwFeature, -1,
1347                             szFeature, GUID_SIZE, NULL, NULL);
1348         WideCharToMultiByte(CP_ACP, 0, szwParent, -1,
1349                             szParent, GUID_SIZE, NULL, NULL);
1350     }
1351
1352     msi_free( szwProduct);
1353
1354     return r;
1355 }
1356
1357 UINT WINAPI MsiEnumFeaturesW(LPCWSTR szProduct, DWORD index, 
1358       LPWSTR szFeature, LPWSTR szParent)
1359 {
1360     HKEY hkeyProduct = 0;
1361     DWORD r, sz;
1362
1363     TRACE("%s %d %p %p\n", debugstr_w(szProduct), index, szFeature, szParent);
1364
1365     if( !szProduct )
1366         return ERROR_INVALID_PARAMETER;
1367
1368     r = MSIREG_OpenInstallerFeaturesKey(szProduct,&hkeyProduct,FALSE);
1369     if( r != ERROR_SUCCESS )
1370         return ERROR_NO_MORE_ITEMS;
1371
1372     sz = GUID_SIZE;
1373     r = RegEnumValueW(hkeyProduct, index, szFeature, &sz, NULL, NULL, NULL, NULL);
1374     RegCloseKey(hkeyProduct);
1375
1376     return r;
1377 }
1378
1379 UINT WINAPI MsiEnumComponentsA(DWORD index, LPSTR lpguid)
1380 {
1381     DWORD r;
1382     WCHAR szwGuid[GUID_SIZE];
1383
1384     TRACE("%d %p\n", index, lpguid);
1385
1386     r = MsiEnumComponentsW(index, szwGuid);
1387     if( r == ERROR_SUCCESS )
1388         WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
1389
1390     return r;
1391 }
1392
1393 UINT WINAPI MsiEnumComponentsW(DWORD index, LPWSTR lpguid)
1394 {
1395     HKEY hkeyComponents = 0;
1396     DWORD r;
1397     WCHAR szKeyName[SQUISH_GUID_SIZE];
1398
1399     TRACE("%d %p\n", index, lpguid);
1400
1401     r = RegCreateKeyW(HKEY_LOCAL_MACHINE, szInstaller_Components, &hkeyComponents);
1402     if( r != ERROR_SUCCESS )
1403         return ERROR_NO_MORE_ITEMS;
1404
1405     r = RegEnumKeyW(hkeyComponents, index, szKeyName, SQUISH_GUID_SIZE);
1406     if( r == ERROR_SUCCESS )
1407         unsquash_guid(szKeyName, lpguid);
1408     RegCloseKey(hkeyComponents);
1409
1410     return r;
1411 }
1412
1413 UINT WINAPI MsiEnumClientsA(LPCSTR szComponent, DWORD index, LPSTR szProduct)
1414 {
1415     DWORD r;
1416     WCHAR szwProduct[GUID_SIZE];
1417     LPWSTR szwComponent = NULL;
1418
1419     TRACE("%s %d %p\n", debugstr_a(szComponent), index, szProduct);
1420
1421     if ( !szProduct )
1422         return ERROR_INVALID_PARAMETER;
1423
1424     if( szComponent )
1425     {
1426         szwComponent = strdupAtoW( szComponent );
1427         if( !szwComponent )
1428             return ERROR_OUTOFMEMORY;
1429     }
1430
1431     r = MsiEnumClientsW(szComponent?szwComponent:NULL, index, szwProduct);
1432     if( r == ERROR_SUCCESS )
1433     {
1434         WideCharToMultiByte(CP_ACP, 0, szwProduct, -1,
1435                             szProduct, GUID_SIZE, NULL, NULL);
1436     }
1437
1438     msi_free( szwComponent);
1439
1440     return r;
1441 }
1442
1443 UINT WINAPI MsiEnumClientsW(LPCWSTR szComponent, DWORD index, LPWSTR szProduct)
1444 {
1445     HKEY hkeyComp = 0;
1446     DWORD r, sz;
1447     WCHAR szValName[SQUISH_GUID_SIZE];
1448
1449     TRACE("%s %d %p\n", debugstr_w(szComponent), index, szProduct);
1450
1451     if (!szComponent || !*szComponent || !szProduct)
1452         return ERROR_INVALID_PARAMETER;
1453
1454     if (MSIREG_OpenUserDataComponentKey(szComponent, NULL, &hkeyComp, FALSE) != ERROR_SUCCESS &&
1455         MSIREG_OpenUserDataComponentKey(szComponent, szLocalSid, &hkeyComp, FALSE) != ERROR_SUCCESS)
1456         return ERROR_UNKNOWN_COMPONENT;
1457
1458     /* see if there are any products at all */
1459     sz = SQUISH_GUID_SIZE;
1460     r = RegEnumValueW(hkeyComp, 0, szValName, &sz, NULL, NULL, NULL, NULL);
1461     if (r != ERROR_SUCCESS)
1462     {
1463         RegCloseKey(hkeyComp);
1464
1465         if (index != 0)
1466             return ERROR_INVALID_PARAMETER;
1467
1468         return ERROR_UNKNOWN_COMPONENT;
1469     }
1470
1471     sz = SQUISH_GUID_SIZE;
1472     r = RegEnumValueW(hkeyComp, index, szValName, &sz, NULL, NULL, NULL, NULL);
1473     if( r == ERROR_SUCCESS )
1474         unsquash_guid(szValName, szProduct);
1475
1476     RegCloseKey(hkeyComp);
1477
1478     return r;
1479 }
1480
1481 static UINT MSI_EnumComponentQualifiers( LPCWSTR szComponent, DWORD iIndex,
1482                 awstring *lpQualBuf, LPDWORD pcchQual,
1483                 awstring *lpAppBuf, LPDWORD pcchAppBuf )
1484 {
1485     DWORD name_sz, val_sz, name_max, val_max, type, ofs;
1486     LPWSTR name = NULL, val = NULL;
1487     UINT r, r2;
1488     HKEY key;
1489
1490     TRACE("%s %08x %p %p %p %p\n", debugstr_w(szComponent), iIndex,
1491           lpQualBuf, pcchQual, lpAppBuf, pcchAppBuf);
1492
1493     if (!szComponent)
1494         return ERROR_INVALID_PARAMETER;
1495
1496     r = MSIREG_OpenUserComponentsKey( szComponent, &key, FALSE );
1497     if (r != ERROR_SUCCESS)
1498         return ERROR_UNKNOWN_COMPONENT;
1499
1500     /* figure out how big the name is we want to return */
1501     name_max = 0x10;
1502     r = ERROR_OUTOFMEMORY;
1503     name = msi_alloc( name_max * sizeof(WCHAR) );
1504     if (!name)
1505         goto end;
1506
1507     val_max = 0x10;
1508     r = ERROR_OUTOFMEMORY;
1509     val = msi_alloc( val_max );
1510     if (!val)
1511         goto end;
1512
1513     /* loop until we allocate enough memory */
1514     while (1)
1515     {
1516         name_sz = name_max;
1517         val_sz = val_max;
1518         r = RegEnumValueW( key, iIndex, name, &name_sz,
1519                            NULL, &type, (LPBYTE)val, &val_sz );
1520         if (r == ERROR_SUCCESS)
1521             break;
1522         if (r != ERROR_MORE_DATA)
1523             goto end;
1524  
1525         if (type != REG_MULTI_SZ)
1526         {
1527             ERR("component data has wrong type (%d)\n", type);
1528             goto end;
1529         }
1530
1531         r = ERROR_OUTOFMEMORY;
1532         if ((name_sz+1) >= name_max)
1533         {
1534             name_max *= 2;
1535             msi_free( name );
1536             name = msi_alloc( name_max * sizeof (WCHAR) );
1537             if (!name)
1538                 goto end;
1539             continue;
1540         }
1541         if (val_sz > val_max)
1542         {
1543             val_max = val_sz + sizeof (WCHAR);
1544             msi_free( val );
1545             val = msi_alloc( val_max * sizeof (WCHAR) );
1546             if (!val)
1547                 goto end;
1548             continue;
1549         }
1550         ERR("should be enough data, but isn't %d %d\n", name_sz, val_sz );
1551         goto end;
1552     }
1553
1554     ofs = 0;
1555     r = MsiDecomposeDescriptorW( val, NULL, NULL, NULL, &ofs );
1556     if (r != ERROR_SUCCESS)
1557         goto end;
1558
1559     TRACE("Providing %s and %s\n", debugstr_w(name), debugstr_w(val+ofs));
1560
1561     r = msi_strcpy_to_awstring( name, lpQualBuf, pcchQual );
1562     r2 = msi_strcpy_to_awstring( val+ofs, lpAppBuf, pcchAppBuf );
1563
1564     if (r2 != ERROR_SUCCESS)
1565         r = r2;
1566
1567 end:
1568     msi_free(val);
1569     msi_free(name);
1570     RegCloseKey(key);
1571
1572     return r;
1573 }
1574
1575 /*************************************************************************
1576  *  MsiEnumComponentQualifiersA [MSI.@]
1577  */
1578 UINT WINAPI MsiEnumComponentQualifiersA( LPCSTR szComponent, DWORD iIndex,
1579                 LPSTR lpQualifierBuf, LPDWORD pcchQualifierBuf,
1580                 LPSTR lpApplicationDataBuf, LPDWORD pcchApplicationDataBuf )
1581 {
1582     awstring qual, appdata;
1583     LPWSTR comp;
1584     UINT r;
1585
1586     TRACE("%s %08x %p %p %p %p\n", debugstr_a(szComponent), iIndex,
1587           lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf,
1588           pcchApplicationDataBuf);
1589
1590     comp = strdupAtoW( szComponent );
1591     if (szComponent && !comp)
1592         return ERROR_OUTOFMEMORY;
1593
1594     qual.unicode = FALSE;
1595     qual.str.a = lpQualifierBuf;
1596
1597     appdata.unicode = FALSE;
1598     appdata.str.a = lpApplicationDataBuf;
1599
1600     r = MSI_EnumComponentQualifiers( comp, iIndex,
1601               &qual, pcchQualifierBuf, &appdata, pcchApplicationDataBuf );
1602     msi_free( comp );
1603     return r;
1604 }
1605
1606 /*************************************************************************
1607  *  MsiEnumComponentQualifiersW [MSI.@]
1608  */
1609 UINT WINAPI MsiEnumComponentQualifiersW( LPCWSTR szComponent, DWORD iIndex,
1610                 LPWSTR lpQualifierBuf, LPDWORD pcchQualifierBuf,
1611                 LPWSTR lpApplicationDataBuf, LPDWORD pcchApplicationDataBuf )
1612 {
1613     awstring qual, appdata;
1614
1615     TRACE("%s %08x %p %p %p %p\n", debugstr_w(szComponent), iIndex,
1616           lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf,
1617           pcchApplicationDataBuf);
1618
1619     qual.unicode = TRUE;
1620     qual.str.w = lpQualifierBuf;
1621
1622     appdata.unicode = TRUE;
1623     appdata.str.w = lpApplicationDataBuf;
1624
1625     return MSI_EnumComponentQualifiers( szComponent, iIndex,
1626                  &qual, pcchQualifierBuf, &appdata, pcchApplicationDataBuf );
1627 }
1628
1629 /*************************************************************************
1630  *  MsiEnumRelatedProductsW   [MSI.@]
1631  *
1632  */
1633 UINT WINAPI MsiEnumRelatedProductsW(LPCWSTR szUpgradeCode, DWORD dwReserved,
1634                                     DWORD iProductIndex, LPWSTR lpProductBuf)
1635 {
1636     UINT r;
1637     HKEY hkey;
1638     DWORD dwSize = SQUISH_GUID_SIZE;
1639     WCHAR szKeyName[SQUISH_GUID_SIZE];
1640
1641     TRACE("%s %u %u %p\n", debugstr_w(szUpgradeCode), dwReserved,
1642           iProductIndex, lpProductBuf);
1643
1644     if (NULL == szUpgradeCode)
1645         return ERROR_INVALID_PARAMETER;
1646     if (NULL == lpProductBuf)
1647         return ERROR_INVALID_PARAMETER;
1648
1649     r = MSIREG_OpenUpgradeCodesKey(szUpgradeCode, &hkey, FALSE);
1650     if (r != ERROR_SUCCESS)
1651         return ERROR_NO_MORE_ITEMS;
1652
1653     r = RegEnumValueW(hkey, iProductIndex, szKeyName, &dwSize, NULL, NULL, NULL, NULL);
1654     if( r == ERROR_SUCCESS )
1655         unsquash_guid(szKeyName, lpProductBuf);
1656     RegCloseKey(hkey);
1657
1658     return r;
1659 }
1660
1661 /*************************************************************************
1662  *  MsiEnumRelatedProductsA   [MSI.@]
1663  *
1664  */
1665 UINT WINAPI MsiEnumRelatedProductsA(LPCSTR szUpgradeCode, DWORD dwReserved,
1666                                     DWORD iProductIndex, LPSTR lpProductBuf)
1667 {
1668     LPWSTR szwUpgradeCode = NULL;
1669     WCHAR productW[GUID_SIZE];
1670     UINT r;
1671
1672     TRACE("%s %u %u %p\n", debugstr_a(szUpgradeCode), dwReserved,
1673           iProductIndex, lpProductBuf);
1674
1675     if (szUpgradeCode)
1676     {
1677         szwUpgradeCode = strdupAtoW( szUpgradeCode );
1678         if( !szwUpgradeCode )
1679             return ERROR_OUTOFMEMORY;
1680     }
1681
1682     r = MsiEnumRelatedProductsW( szwUpgradeCode, dwReserved,
1683                                  iProductIndex, productW );
1684     if (r == ERROR_SUCCESS)
1685     {
1686         WideCharToMultiByte( CP_ACP, 0, productW, GUID_SIZE,
1687                              lpProductBuf, GUID_SIZE, NULL, NULL );
1688     }
1689     msi_free( szwUpgradeCode);
1690     return r;
1691 }
1692
1693 /***********************************************************************
1694  * MsiEnumPatchesExA            [MSI.@]
1695  */
1696 UINT WINAPI MsiEnumPatchesExA(LPCSTR szProductCode, LPCSTR szUserSid,
1697         DWORD dwContext, DWORD dwFilter, DWORD dwIndex, LPSTR szPatchCode,
1698         LPSTR szTargetProductCode, MSIINSTALLCONTEXT *pdwTargetProductContext,
1699         LPSTR szTargetUserSid, LPDWORD pcchTargetUserSid)
1700 {
1701     LPWSTR prodcode = NULL;
1702     LPWSTR usersid = NULL;
1703     LPWSTR targsid = NULL;
1704     WCHAR patch[GUID_SIZE];
1705     WCHAR targprod[GUID_SIZE];
1706     DWORD len;
1707     UINT r;
1708
1709     TRACE("(%s, %s, %d, %d, %d, %p, %p, %p, %p, %p)\n",
1710           debugstr_a(szProductCode), debugstr_a(szUserSid), dwContext, dwFilter,
1711           dwIndex, szPatchCode, szTargetProductCode, pdwTargetProductContext,
1712           szTargetUserSid, pcchTargetUserSid);
1713
1714     if (szTargetUserSid && !pcchTargetUserSid)
1715         return ERROR_INVALID_PARAMETER;
1716
1717     if (szProductCode) prodcode = strdupAtoW(szProductCode);
1718     if (szUserSid) usersid = strdupAtoW(szUserSid);
1719
1720     r = MsiEnumPatchesExW(prodcode, usersid, dwContext, dwFilter, dwIndex,
1721                           patch, targprod, pdwTargetProductContext,
1722                           NULL, &len);
1723     if (r != ERROR_SUCCESS)
1724         goto done;
1725
1726     WideCharToMultiByte(CP_ACP, 0, patch, -1, szPatchCode,
1727                         GUID_SIZE, NULL, NULL);
1728     WideCharToMultiByte(CP_ACP, 0, targprod, -1, szTargetProductCode,
1729                         GUID_SIZE, NULL, NULL);
1730
1731     if (!szTargetUserSid)
1732     {
1733         if (pcchTargetUserSid)
1734             *pcchTargetUserSid = len;
1735
1736         goto done;
1737     }
1738
1739     targsid = msi_alloc(++len * sizeof(WCHAR));
1740     if (!targsid)
1741     {
1742         r = ERROR_OUTOFMEMORY;
1743         goto done;
1744     }
1745
1746     r = MsiEnumPatchesExW(prodcode, usersid, dwContext, dwFilter, dwIndex,
1747                           patch, targprod, pdwTargetProductContext,
1748                           targsid, &len);
1749     if (r != ERROR_SUCCESS || !szTargetUserSid)
1750         goto done;
1751
1752     WideCharToMultiByte(CP_ACP, 0, targsid, -1, szTargetUserSid,
1753                         *pcchTargetUserSid, NULL, NULL);
1754
1755     len = lstrlenW(targsid);
1756     if (*pcchTargetUserSid < len + 1)
1757     {
1758         r = ERROR_MORE_DATA;
1759         *pcchTargetUserSid = len * sizeof(WCHAR);
1760     }
1761     else
1762         *pcchTargetUserSid = len;
1763
1764 done:
1765     msi_free(prodcode);
1766     msi_free(usersid);
1767     msi_free(targsid);
1768
1769     return r;
1770 }
1771
1772 static UINT msi_get_patch_state(LPCWSTR prodcode, LPCWSTR usersid,
1773                                 MSIINSTALLCONTEXT context,
1774                                 LPWSTR patch, MSIPATCHSTATE *state)
1775 {
1776     DWORD type, val, size;
1777     HKEY prod, hkey = 0;
1778     HKEY udpatch = 0;
1779     LONG res;
1780     UINT r = ERROR_NO_MORE_ITEMS;
1781
1782     static const WCHAR szPatches[] = {'P','a','t','c','h','e','s',0};
1783     static const WCHAR szState[] = {'S','t','a','t','e',0};
1784
1785     *state = MSIPATCHSTATE_INVALID;
1786
1787     r = MSIREG_OpenUserDataProductKey(prodcode, context,
1788                                       usersid, &prod, FALSE);
1789     if (r != ERROR_SUCCESS)
1790         return ERROR_NO_MORE_ITEMS;
1791
1792     res = RegOpenKeyExW(prod, szPatches, 0, KEY_READ, &hkey);
1793     if (res != ERROR_SUCCESS)
1794         goto done;
1795
1796     res = RegOpenKeyExW(hkey, patch, 0, KEY_READ, &udpatch);
1797     if (res != ERROR_SUCCESS)
1798         goto done;
1799
1800     size = sizeof(DWORD);
1801     res = RegGetValueW(udpatch, NULL, szState, RRF_RT_DWORD, &type, &val, &size);
1802     if (res != ERROR_SUCCESS ||
1803         val < MSIPATCHSTATE_APPLIED || val > MSIPATCHSTATE_REGISTERED)
1804     {
1805         r = ERROR_BAD_CONFIGURATION;
1806         goto done;
1807     }
1808
1809     *state = val;
1810     r = ERROR_SUCCESS;
1811
1812 done:
1813     RegCloseKey(udpatch);
1814     RegCloseKey(hkey);
1815     RegCloseKey(prod);
1816
1817     return r;
1818 }
1819
1820 static UINT msi_check_product_patches(LPCWSTR prodcode, LPCWSTR usersid,
1821         MSIINSTALLCONTEXT context, DWORD filter, DWORD index, DWORD *idx,
1822         LPWSTR patch, LPWSTR targetprod, MSIINSTALLCONTEXT *targetctx,
1823         LPWSTR targetsid, DWORD *sidsize, LPWSTR *transforms)
1824 {
1825     MSIPATCHSTATE state = MSIPATCHSTATE_INVALID;
1826     LPWSTR ptr, patches = NULL;
1827     HKEY prod, patchkey = 0;
1828     HKEY localprod = 0, localpatch = 0;
1829     DWORD type, size;
1830     LONG res;
1831     UINT temp, r = ERROR_NO_MORE_ITEMS;
1832
1833     static const WCHAR szPatches[] = {'P','a','t','c','h','e','s',0};
1834     static const WCHAR szState[] = {'S','t','a','t','e',0};
1835     static const WCHAR szEmpty[] = {0};
1836
1837     if (MSIREG_OpenProductKey(prodcode, usersid, context,
1838                               &prod, FALSE) != ERROR_SUCCESS)
1839         return ERROR_NO_MORE_ITEMS;
1840
1841     size = 0;
1842     res = RegGetValueW(prod, szPatches, szPatches, RRF_RT_ANY, &type, NULL,
1843                        &size);
1844     if (res != ERROR_SUCCESS)
1845         goto done;
1846
1847     if (type != REG_MULTI_SZ)
1848     {
1849         r = ERROR_BAD_CONFIGURATION;
1850         goto done;
1851     }
1852
1853     patches = msi_alloc(size);
1854     if (!patches)
1855     {
1856         r = ERROR_OUTOFMEMORY;
1857         goto done;
1858     }
1859
1860     res = RegGetValueW(prod, szPatches, szPatches, RRF_RT_ANY, &type,
1861                        patches, &size);
1862     if (res != ERROR_SUCCESS)
1863         goto done;
1864
1865     ptr = patches;
1866     for (ptr = patches; *ptr && r == ERROR_NO_MORE_ITEMS; ptr += lstrlenW(ptr))
1867     {
1868         if (!unsquash_guid(ptr, patch))
1869         {
1870             r = ERROR_BAD_CONFIGURATION;
1871             goto done;
1872         }
1873
1874         size = 0;
1875         res = RegGetValueW(prod, szPatches, ptr, RRF_RT_REG_SZ,
1876                            &type, NULL, &size);
1877         if (res != ERROR_SUCCESS)
1878             continue;
1879
1880         if (transforms)
1881         {
1882             *transforms = msi_alloc(size);
1883             if (!*transforms)
1884             {
1885                 r = ERROR_OUTOFMEMORY;
1886                 goto done;
1887             }
1888
1889             res = RegGetValueW(prod, szPatches, ptr, RRF_RT_REG_SZ,
1890                                &type, *transforms, &size);
1891             if (res != ERROR_SUCCESS)
1892                 continue;
1893         }
1894
1895         if (context == MSIINSTALLCONTEXT_USERMANAGED)
1896         {
1897             if (!(filter & MSIPATCHSTATE_APPLIED))
1898             {
1899                 temp = msi_get_patch_state(prodcode, usersid, context,
1900                                            ptr, &state);
1901                 if (temp == ERROR_BAD_CONFIGURATION)
1902                 {
1903                     r = ERROR_BAD_CONFIGURATION;
1904                     goto done;
1905                 }
1906
1907                 if (temp != ERROR_SUCCESS || !(filter & state))
1908                     continue;
1909             }
1910         }
1911         else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
1912         {
1913             if (!(filter & MSIPATCHSTATE_APPLIED))
1914             {
1915                 temp = msi_get_patch_state(prodcode, usersid, context,
1916                                            ptr, &state);
1917                 if (temp == ERROR_BAD_CONFIGURATION)
1918                 {
1919                     r = ERROR_BAD_CONFIGURATION;
1920                     goto done;
1921                 }
1922
1923                 if (temp != ERROR_SUCCESS || !(filter & state))
1924                     continue;
1925             }
1926             else
1927             {
1928                 temp = MSIREG_OpenUserDataPatchKey(patch, context,
1929                                                    &patchkey, FALSE);
1930                 RegCloseKey(patchkey);
1931                 if (temp != ERROR_SUCCESS)
1932                     continue;
1933             }
1934         }
1935         else if (context == MSIINSTALLCONTEXT_MACHINE)
1936         {
1937             usersid = szEmpty;
1938
1939             if (MSIREG_OpenUserDataProductKey(prodcode, context, NULL, &localprod, FALSE) == ERROR_SUCCESS &&
1940                 RegOpenKeyExW(localprod, szPatches, 0, KEY_READ, &localpatch) == ERROR_SUCCESS &&
1941                 RegOpenKeyExW(localpatch, ptr, 0, KEY_READ, &patchkey) == ERROR_SUCCESS)
1942             {
1943                 res = RegGetValueW(patchkey, NULL, szState, RRF_RT_REG_DWORD,
1944                                    &type, &state, &size);
1945
1946                 if (!(filter & state))
1947                     res = ERROR_NO_MORE_ITEMS;
1948
1949                 RegCloseKey(patchkey);
1950             }
1951
1952             RegCloseKey(localpatch);
1953             RegCloseKey(localprod);
1954
1955             if (res != ERROR_SUCCESS)
1956                 continue;
1957         }
1958
1959         if (*idx < index)
1960         {
1961             (*idx)++;
1962             continue;
1963         }
1964
1965         r = ERROR_SUCCESS;
1966         if (targetprod)
1967             lstrcpyW(targetprod, prodcode);
1968
1969         if (targetctx)
1970             *targetctx = context;
1971
1972         if (targetsid)
1973         {
1974             lstrcpynW(targetsid, usersid, *sidsize);
1975             if (lstrlenW(usersid) >= *sidsize)
1976                 r = ERROR_MORE_DATA;
1977         }
1978
1979         if (sidsize)
1980         {
1981             *sidsize = lstrlenW(usersid);
1982             if (!targetsid)
1983                 *sidsize *= sizeof(WCHAR);
1984         }
1985     }
1986
1987 done:
1988     RegCloseKey(prod);
1989     msi_free(patches);
1990
1991     return r;
1992 }
1993
1994 static UINT msi_enum_patches(LPCWSTR szProductCode, LPCWSTR szUserSid,
1995         DWORD dwContext, DWORD dwFilter, DWORD dwIndex, DWORD *idx,
1996         LPWSTR szPatchCode, LPWSTR szTargetProductCode,
1997         MSIINSTALLCONTEXT *pdwTargetProductContext, LPWSTR szTargetUserSid,
1998         LPDWORD pcchTargetUserSid, LPWSTR *szTransforms)
1999 {
2000     LPWSTR usersid = NULL;
2001     UINT r = ERROR_INVALID_PARAMETER;
2002
2003     if (!szUserSid)
2004     {
2005         get_user_sid(&usersid);
2006         szUserSid = usersid;
2007     }
2008
2009     if (dwContext & MSIINSTALLCONTEXT_USERMANAGED)
2010     {
2011         r = msi_check_product_patches(szProductCode, szUserSid,
2012                                       MSIINSTALLCONTEXT_USERMANAGED, dwFilter,
2013                                       dwIndex, idx, szPatchCode,
2014                                       szTargetProductCode,
2015                                       pdwTargetProductContext, szTargetUserSid,
2016                                       pcchTargetUserSid, szTransforms);
2017         if (r != ERROR_NO_MORE_ITEMS)
2018             goto done;
2019     }
2020
2021     if (dwContext & MSIINSTALLCONTEXT_USERUNMANAGED)
2022     {
2023         r = msi_check_product_patches(szProductCode, szUserSid,
2024                                       MSIINSTALLCONTEXT_USERUNMANAGED, dwFilter,
2025                                       dwIndex, idx, szPatchCode,
2026                                       szTargetProductCode,
2027                                       pdwTargetProductContext, szTargetUserSid,
2028                                       pcchTargetUserSid, szTransforms);
2029         if (r != ERROR_NO_MORE_ITEMS)
2030             goto done;
2031     }
2032
2033     if (dwContext & MSIINSTALLCONTEXT_MACHINE)
2034     {
2035         r = msi_check_product_patches(szProductCode, szUserSid,
2036                                       MSIINSTALLCONTEXT_MACHINE, dwFilter,
2037                                       dwIndex, idx, szPatchCode,
2038                                       szTargetProductCode,
2039                                       pdwTargetProductContext, szTargetUserSid,
2040                                       pcchTargetUserSid, szTransforms);
2041         if (r != ERROR_NO_MORE_ITEMS)
2042             goto done;
2043     }
2044
2045 done:
2046     LocalFree(usersid);
2047     return r;
2048 }
2049
2050 /***********************************************************************
2051  * MsiEnumPatchesExW            [MSI.@]
2052  */
2053 UINT WINAPI MsiEnumPatchesExW(LPCWSTR szProductCode, LPCWSTR szUserSid,
2054         DWORD dwContext, DWORD dwFilter, DWORD dwIndex, LPWSTR szPatchCode,
2055         LPWSTR szTargetProductCode, MSIINSTALLCONTEXT *pdwTargetProductContext,
2056         LPWSTR szTargetUserSid, LPDWORD pcchTargetUserSid)
2057 {
2058     WCHAR squished_pc[GUID_SIZE];
2059     DWORD idx = 0;
2060     UINT r;
2061
2062     static int last_index = 0;
2063
2064     TRACE("(%s, %s, %d, %d, %d, %p, %p, %p, %p, %p)\n",
2065           debugstr_w(szProductCode), debugstr_w(szUserSid), dwContext, dwFilter,
2066           dwIndex, szPatchCode, szTargetProductCode, pdwTargetProductContext,
2067           szTargetUserSid, pcchTargetUserSid);
2068
2069     if (!szProductCode || !squash_guid(szProductCode, squished_pc))
2070         return ERROR_INVALID_PARAMETER;
2071
2072     if (!lstrcmpW(szUserSid, szLocalSid))
2073         return ERROR_INVALID_PARAMETER;
2074
2075     if (dwContext & MSIINSTALLCONTEXT_MACHINE && szUserSid)
2076         return ERROR_INVALID_PARAMETER;
2077
2078     if (dwContext <= MSIINSTALLCONTEXT_NONE ||
2079         dwContext > MSIINSTALLCONTEXT_ALL)
2080         return ERROR_INVALID_PARAMETER;
2081
2082     if (dwFilter <= MSIPATCHSTATE_INVALID || dwFilter > MSIPATCHSTATE_ALL)
2083         return ERROR_INVALID_PARAMETER;
2084
2085     if (dwIndex && dwIndex - last_index != 1)
2086         return ERROR_INVALID_PARAMETER;
2087
2088     if (dwIndex == 0)
2089         last_index = 0;
2090
2091     r = msi_enum_patches(szProductCode, szUserSid, dwContext, dwFilter,
2092                          dwIndex, &idx, szPatchCode, szTargetProductCode,
2093                          pdwTargetProductContext, szTargetUserSid,
2094                          pcchTargetUserSid, NULL);
2095
2096     if (r == ERROR_SUCCESS)
2097         last_index = dwIndex;
2098
2099     return r;
2100 }
2101
2102 /***********************************************************************
2103  * MsiEnumPatchesA            [MSI.@]
2104  */
2105 UINT WINAPI MsiEnumPatchesA(LPCSTR szProduct, DWORD iPatchIndex,
2106         LPSTR lpPatchBuf, LPSTR lpTransformsBuf, LPDWORD pcchTransformsBuf)
2107 {
2108     LPWSTR product, transforms;
2109     WCHAR patch[GUID_SIZE];
2110     DWORD len;
2111     UINT r;
2112
2113     TRACE("(%s %d %p %p %p)\n", debugstr_a(szProduct), iPatchIndex,
2114           lpPatchBuf, lpTransformsBuf, pcchTransformsBuf);
2115
2116     if (!szProduct || !lpPatchBuf || !lpTransformsBuf || !pcchTransformsBuf)
2117         return ERROR_INVALID_PARAMETER;
2118
2119     product = strdupAtoW(szProduct);
2120     if (!product)
2121         return ERROR_OUTOFMEMORY;
2122
2123     len = *pcchTransformsBuf;
2124     transforms = msi_alloc( len * sizeof(WCHAR) );
2125     if (!transforms)
2126     {
2127         r = ERROR_OUTOFMEMORY;
2128         goto done;
2129     }
2130
2131     r = MsiEnumPatchesW(product, iPatchIndex, patch, transforms, &len);
2132     if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
2133         goto done;
2134
2135     WideCharToMultiByte(CP_ACP, 0, patch, -1, lpPatchBuf,
2136                         GUID_SIZE, NULL, NULL);
2137
2138     if (!WideCharToMultiByte(CP_ACP, 0, transforms, -1, lpTransformsBuf,
2139                              *pcchTransformsBuf, NULL, NULL))
2140         r = ERROR_MORE_DATA;
2141
2142     if (r == ERROR_MORE_DATA)
2143     {
2144         lpTransformsBuf[*pcchTransformsBuf - 1] = '\0';
2145         *pcchTransformsBuf = len * 2;
2146     }
2147     else
2148         *pcchTransformsBuf = strlen( lpTransformsBuf );
2149
2150 done:
2151     msi_free(transforms);
2152     msi_free(product);
2153
2154     return r;
2155 }
2156
2157 /***********************************************************************
2158  * MsiEnumPatchesW            [MSI.@]
2159  */
2160 UINT WINAPI MsiEnumPatchesW(LPCWSTR szProduct, DWORD iPatchIndex,
2161         LPWSTR lpPatchBuf, LPWSTR lpTransformsBuf, LPDWORD pcchTransformsBuf)
2162 {
2163     WCHAR squished_pc[GUID_SIZE];
2164     LPWSTR transforms = NULL;
2165     HKEY prod;
2166     DWORD idx = 0;
2167     UINT r;
2168
2169     TRACE("(%s %d %p %p %p)\n", debugstr_w(szProduct), iPatchIndex,
2170           lpPatchBuf, lpTransformsBuf, pcchTransformsBuf);
2171
2172     if (!szProduct || !squash_guid(szProduct, squished_pc))
2173         return ERROR_INVALID_PARAMETER;
2174
2175     if (!lpPatchBuf || !lpTransformsBuf || !pcchTransformsBuf)
2176         return ERROR_INVALID_PARAMETER;
2177
2178     if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
2179                               &prod, FALSE) != ERROR_SUCCESS &&
2180         MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
2181                               &prod, FALSE) != ERROR_SUCCESS &&
2182         MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
2183                               &prod, FALSE) != ERROR_SUCCESS)
2184         return ERROR_UNKNOWN_PRODUCT;
2185
2186     RegCloseKey(prod);
2187
2188     r = msi_enum_patches(szProduct, NULL, MSIINSTALLCONTEXT_ALL,
2189                          MSIPATCHSTATE_ALL, iPatchIndex, &idx, lpPatchBuf,
2190                          NULL, NULL, NULL, NULL, &transforms);
2191     if (r != ERROR_SUCCESS)
2192         goto done;
2193
2194     lstrcpynW(lpTransformsBuf, transforms, *pcchTransformsBuf);
2195     if (*pcchTransformsBuf <= lstrlenW(transforms))
2196     {
2197         r = ERROR_MORE_DATA;
2198         *pcchTransformsBuf = lstrlenW(transforms);
2199     }
2200     else
2201         *pcchTransformsBuf = lstrlenW(transforms);
2202
2203 done:
2204     msi_free(transforms);
2205     return r;
2206 }
2207
2208 UINT WINAPI MsiEnumProductsExA( LPCSTR szProductCode, LPCSTR szUserSid,
2209         DWORD dwContext, DWORD dwIndex, CHAR szInstalledProductCode[39],
2210         MSIINSTALLCONTEXT* pdwInstalledContext, LPSTR szSid, LPDWORD pcchSid)
2211 {
2212     FIXME("%s %s %d %d %p %p %p %p\n", debugstr_a(szProductCode), debugstr_a(szUserSid),
2213           dwContext, dwIndex, szInstalledProductCode, pdwInstalledContext,
2214           szSid, pcchSid);
2215     return ERROR_NO_MORE_ITEMS;
2216 }
2217
2218 UINT WINAPI MsiEnumProductsExW( LPCWSTR szProductCode, LPCWSTR szUserSid,
2219         DWORD dwContext, DWORD dwIndex, WCHAR szInstalledProductCode[39],
2220         MSIINSTALLCONTEXT* pdwInstalledContext, LPWSTR szSid, LPDWORD pcchSid)
2221 {
2222     FIXME("%s %s %d %d %p %p %p %p\n", debugstr_w(szProductCode), debugstr_w(szUserSid),
2223           dwContext, dwIndex, szInstalledProductCode, pdwInstalledContext,
2224           szSid, pcchSid);
2225     return ERROR_NO_MORE_ITEMS;
2226 }