msi: ValidateProductID action stub.
[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
40 WINE_DEFAULT_DEBUG_CHANNEL(msi);
41
42
43 /* 
44  * This module will be all the helper functions for registry access by the
45  * installer bits. 
46  */
47 static const WCHAR szUserFeatures_fmt[] = {
48 'S','o','f','t','w','a','r','e','\\',
49 'M','i','c','r','o','s','o','f','t','\\',
50 'I','n','s','t','a','l','l','e','r','\\',
51 'F','e','a','t','u','r','e','s','\\',
52 '%','s',0};
53
54 static const WCHAR szInstaller_Features[] = {
55 'S','o','f','t','w','a','r','e','\\',
56 'M','i','c','r','o','s','o','f','t','\\',
57 'W','i','n','d','o','w','s','\\',
58 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
59 'I','n','s','t','a','l','l','e','r','\\',
60 'F','e','a','t','u','r','e','s',0 };
61
62 static const WCHAR szInstaller_Features_fmt[] = {
63 'S','o','f','t','w','a','r','e','\\',
64 'M','i','c','r','o','s','o','f','t','\\',
65 'W','i','n','d','o','w','s','\\',
66 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
67 'I','n','s','t','a','l','l','e','r','\\',
68 'F','e','a','t','u','r','e','s','\\',
69 '%','s',0};
70
71 static const WCHAR szInstaller_Components[] = {
72 'S','o','f','t','w','a','r','e','\\',
73 'M','i','c','r','o','s','o','f','t','\\',
74 'W','i','n','d','o','w','s','\\',
75 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
76 'I','n','s','t','a','l','l','e','r','\\',
77 'C','o','m','p','o','n','e','n','t','s',0 };
78
79 static const WCHAR szInstaller_Components_fmt[] = {
80 'S','o','f','t','w','a','r','e','\\',
81 'M','i','c','r','o','s','o','f','t','\\',
82 'W','i','n','d','o','w','s','\\',
83 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
84 'I','n','s','t','a','l','l','e','r','\\',
85 'C','o','m','p','o','n','e','n','t','s','\\',
86 '%','s',0};
87
88 static const WCHAR szUser_Components_fmt[] = {
89 'S','o','f','t','w','a','r','e','\\',
90 'M','i','c','r','o','s','o','f','t','\\',
91 'I','n','s','t','a','l','l','e','r','\\',
92 'C','o','m','p','o','n','e','n','t','s','\\',
93 '%','s',0};
94
95 static const WCHAR szUninstall_fmt[] = {
96 'S','o','f','t','w','a','r','e','\\',
97 'M','i','c','r','o','s','o','f','t','\\',
98 'W','i','n','d','o','w','s','\\',
99 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
100 'U','n','i','n','s','t','a','l','l','\\',
101 '%','s',0 };
102
103 static const WCHAR szUserProduct_fmt[] = {
104 'S','o','f','t','w','a','r','e','\\',
105 'M','i','c','r','o','s','o','f','t','\\',
106 'I','n','s','t','a','l','l','e','r','\\',
107 'P','r','o','d','u','c','t','s','\\',
108 '%','s',0};
109
110 static const WCHAR szInstaller_Products_fmt[] = {
111 'S','o','f','t','w','a','r','e','\\',
112 'M','i','c','r','o','s','o','f','t','\\',
113 'W','i','n','d','o','w','s','\\',
114 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
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 szInstaller_UpgradeCodes_fmt[] = {
120 'S','o','f','t','w','a','r','e','\\',
121 'M','i','c','r','o','s','o','f','t','\\',
122 'W','i','n','d','o','w','s','\\',
123 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
124 'I','n','s','t','a','l','l','e','r','\\',
125 'U','p','g','r','a','d','e','C','o','d','e','s','\\',
126 '%','s',0};
127
128 static const WCHAR szInstaller_UserUpgradeCodes_fmt[] = {
129 'S','o','f','t','w','a','r','e','\\',
130 'M','i','c','r','o','s','o','f','t','\\',
131 'I','n','s','t','a','l','l','e','r','\\',
132 'U','p','g','r','a','d','e','C','o','d','e','s','\\',
133 '%','s',0};
134
135
136 #define SQUISH_GUID_SIZE 33
137
138 BOOL unsquash_guid(LPCWSTR in, LPWSTR out)
139 {
140     DWORD i,n=0;
141
142     out[n++]='{';
143     for(i=0; i<8; i++)
144         out[n++] = in[7-i];
145     out[n++]='-';
146     for(i=0; i<4; i++)
147         out[n++] = in[11-i];
148     out[n++]='-';
149     for(i=0; i<4; i++)
150         out[n++] = in[15-i];
151     out[n++]='-';
152     for(i=0; i<2; i++)
153     {
154         out[n++] = in[17+i*2];
155         out[n++] = in[16+i*2];
156     }
157     out[n++]='-';
158     for( ; i<8; i++)
159     {
160         out[n++] = in[17+i*2];
161         out[n++] = in[16+i*2];
162     }
163     out[n++]='}';
164     out[n]=0;
165     return TRUE;
166 }
167
168 BOOL squash_guid(LPCWSTR in, LPWSTR out)
169 {
170     DWORD i,n=1;
171     GUID guid;
172
173     if (FAILED(CLSIDFromString((LPOLESTR)in, &guid)))
174         return FALSE;
175
176     for(i=0; i<8; i++)
177         out[7-i] = in[n++];
178     n++;
179     for(i=0; i<4; i++)
180         out[11-i] = in[n++];
181     n++;
182     for(i=0; i<4; i++)
183         out[15-i] = in[n++];
184     n++;
185     for(i=0; i<2; i++)
186     {
187         out[17+i*2] = in[n++];
188         out[16+i*2] = in[n++];
189     }
190     n++;
191     for( ; i<8; i++)
192     {
193         out[17+i*2] = in[n++];
194         out[16+i*2] = in[n++];
195     }
196     out[32]=0;
197     return TRUE;
198 }
199
200
201 /* tables for encoding and decoding base85 */
202 static const unsigned char table_dec85[0x80] = {
203 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
204 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
205 0xff,0x00,0xff,0xff,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0xff,
206 0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0xff,0xff,0xff,0x16,0xff,0x17,
207 0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
208 0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,0x30,0x31,0x32,0x33,0xff,0x34,0x35,0x36,
209 0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,0x40,0x41,0x42,0x43,0x44,0x45,0x46,
210 0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,0x51,0x52,0xff,0x53,0x54,0xff,
211 };
212
213 static const char table_enc85[] =
214 "!$%&'()*+,-.0123456789=?@ABCDEFGHIJKLMNO"
215 "PQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwx"
216 "yz{}~";
217
218 /*
219  *  Converts a base85 encoded guid into a GUID pointer
220  *  Base85 encoded GUIDs should be 20 characters long.
221  *
222  *  returns TRUE if successful, FALSE if not
223  */
224 BOOL decode_base85_guid( LPCWSTR str, GUID *guid )
225 {
226     DWORD i, val = 0, base = 1, *p;
227
228     if (!str)
229         return FALSE;
230
231     p = (DWORD*) guid;
232     for( i=0; i<20; i++ )
233     {
234         if( (i%5) == 0 )
235         {
236             val = 0;
237             base = 1;
238         }
239         val += table_dec85[str[i]] * base;
240         if( str[i] >= 0x80 )
241             return FALSE;
242         if( table_dec85[str[i]] == 0xff )
243             return FALSE;
244         if( (i%5) == 4 )
245             p[i/5] = val;
246         base *= 85;
247     }
248     return TRUE;
249 }
250
251 /*
252  *  Encodes a base85 guid given a GUID pointer
253  *  Caller should provide a 21 character buffer for the encoded string.
254  *
255  *  returns TRUE if successful, FALSE if not
256  */
257 BOOL encode_base85_guid( GUID *guid, LPWSTR str )
258 {
259     unsigned int x, *p, i;
260
261     p = (unsigned int*) guid;
262     for( i=0; i<4; i++ )
263     {
264         x = p[i];
265         *str++ = table_enc85[x%85];
266         x = x/85;
267         *str++ = table_enc85[x%85];
268         x = x/85;
269         *str++ = table_enc85[x%85];
270         x = x/85;
271         *str++ = table_enc85[x%85];
272         x = x/85;
273         *str++ = table_enc85[x%85];
274     }
275     *str = 0;
276
277     return TRUE;
278 }
279
280 DWORD msi_version_str_to_dword(LPCWSTR p)
281 {
282     DWORD major, minor = 0, build = 0, version = 0;
283
284     if (!p)
285         return version;
286
287     major = atoiW(p);
288
289     p = strchrW(p, '.');
290     if (p)
291     {
292         minor = atoiW(p+1);
293         p = strchrW(p+1, '.');
294         if (p)
295             build = atoiW(p+1);
296     }
297
298     return MAKELONG(build, MAKEWORD(minor, major));
299 }
300
301 LPWSTR msi_version_dword_to_str(DWORD version)
302 {
303     const WCHAR fmt[] = { '%','u','.','%','u','.','%','u',0 };
304     LPWSTR str = msi_alloc(20);
305     sprintfW(str, fmt,
306              (version&0xff000000)>>24,
307              (version&0x00ff0000)>>16,
308               version&0x0000ffff);
309     return str;
310 }
311
312 LONG msi_reg_set_val_str( HKEY hkey, LPCWSTR name, LPCWSTR value )
313 {
314     DWORD len = value ? (lstrlenW(value) + 1) * sizeof (WCHAR) : 0;
315     return RegSetValueExW( hkey, name, 0, REG_SZ, (const BYTE *)value, len );
316 }
317
318 LONG msi_reg_set_val_multi_str( HKEY hkey, LPCWSTR name, LPCWSTR value )
319 {
320     LPCWSTR p = value;
321     while (*p) p += lstrlenW(p) + 1;
322     return RegSetValueExW( hkey, name, 0, REG_MULTI_SZ,
323                            (const BYTE *)value, (p + 1 - value) * sizeof(WCHAR) );
324 }
325
326 LONG msi_reg_set_val_dword( HKEY hkey, LPCWSTR name, DWORD val )
327 {
328     return RegSetValueExW( hkey, name, 0, REG_DWORD, (LPBYTE)&val, sizeof (DWORD) );
329 }
330
331 LONG msi_reg_set_subkey_val( HKEY hkey, LPCWSTR path, LPCWSTR name, LPCWSTR val )
332 {
333     HKEY hsubkey = 0;
334     LONG r;
335
336     r = RegCreateKeyW( hkey, path, &hsubkey );
337     if (r != ERROR_SUCCESS)
338         return r;
339     r = msi_reg_set_val_str( hsubkey, name, val );
340     RegCloseKey( hsubkey );
341     return r;
342 }
343
344 LPWSTR msi_reg_get_val_str( HKEY hkey, LPCWSTR name )
345 {
346     DWORD len = 0;
347     LPWSTR val;
348     LONG r;
349
350     r = RegQueryValueExW(hkey, name, NULL, NULL, NULL, &len);
351     if (r != ERROR_SUCCESS)
352         return NULL;
353
354     len += sizeof (WCHAR);
355     val = msi_alloc( len );
356     if (!val)
357         return NULL;
358     val[0] = 0;
359     RegQueryValueExW(hkey, name, NULL, NULL, (LPBYTE) val, &len);
360     return val;
361 }
362
363 BOOL msi_reg_get_val_dword( HKEY hkey, LPCWSTR name, DWORD *val)
364 {
365     DWORD type, len = sizeof (DWORD);
366     LONG r = RegQueryValueExW(hkey, name, NULL, &type, (LPBYTE) val, &len);
367     return r == ERROR_SUCCESS && type == REG_DWORD;
368 }
369
370 UINT MSIREG_OpenUninstallKey(LPCWSTR szProduct, HKEY* key, BOOL create)
371 {
372     UINT rc;
373     WCHAR keypath[0x200];
374     TRACE("%s\n",debugstr_w(szProduct));
375
376     sprintfW(keypath,szUninstall_fmt,szProduct);
377
378     if (create)
379         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE, keypath, key);
380     else
381         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE, keypath, key);
382
383     return rc;
384 }
385
386 UINT MSIREG_OpenUserProductsKey(LPCWSTR szProduct, HKEY* key, BOOL create)
387 {
388     UINT rc;
389     WCHAR squished_pc[GUID_SIZE];
390     WCHAR keypath[0x200];
391
392     TRACE("%s\n",debugstr_w(szProduct));
393     squash_guid(szProduct,squished_pc);
394     TRACE("squished (%s)\n", debugstr_w(squished_pc));
395
396     sprintfW(keypath,szUserProduct_fmt,squished_pc);
397
398     if (create)
399         rc = RegCreateKeyW(HKEY_CURRENT_USER,keypath,key);
400     else
401         rc = RegOpenKeyW(HKEY_CURRENT_USER,keypath,key);
402
403     return rc;
404 }
405
406 UINT MSIREG_OpenUserFeaturesKey(LPCWSTR szProduct, HKEY* key, BOOL create)
407 {
408     UINT rc;
409     WCHAR squished_pc[GUID_SIZE];
410     WCHAR keypath[0x200];
411
412     TRACE("%s\n",debugstr_w(szProduct));
413     squash_guid(szProduct,squished_pc);
414     TRACE("squished (%s)\n", debugstr_w(squished_pc));
415
416     sprintfW(keypath,szUserFeatures_fmt,squished_pc);
417
418     if (create)
419         rc = RegCreateKeyW(HKEY_CURRENT_USER,keypath,key);
420     else
421         rc = RegOpenKeyW(HKEY_CURRENT_USER,keypath,key);
422
423     return rc;
424 }
425
426 UINT MSIREG_OpenFeatures(HKEY* key)
427 {
428     return RegCreateKeyW(HKEY_LOCAL_MACHINE,szInstaller_Features,key);
429 }
430
431 UINT MSIREG_OpenFeaturesKey(LPCWSTR szProduct, HKEY* key, BOOL create)
432 {
433     UINT rc;
434     WCHAR squished_pc[GUID_SIZE];
435     WCHAR keypath[0x200];
436
437     TRACE("%s\n",debugstr_w(szProduct));
438     squash_guid(szProduct,squished_pc);
439     TRACE("squished (%s)\n", debugstr_w(squished_pc));
440
441     sprintfW(keypath,szInstaller_Features_fmt,squished_pc);
442
443     if (create)
444         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE,keypath,key);
445     else
446         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,keypath,key);
447
448     return rc;
449 }
450
451 UINT MSIREG_OpenComponents(HKEY* key)
452 {
453     return RegCreateKeyW(HKEY_LOCAL_MACHINE,szInstaller_Components,key);
454 }
455
456 UINT MSIREG_OpenComponentsKey(LPCWSTR szComponent, HKEY* key, BOOL create)
457 {
458     UINT rc;
459     WCHAR squished_cc[GUID_SIZE];
460     WCHAR keypath[0x200];
461
462     TRACE("%s\n",debugstr_w(szComponent));
463     squash_guid(szComponent,squished_cc);
464     TRACE("squished (%s)\n", debugstr_w(squished_cc));
465
466     sprintfW(keypath,szInstaller_Components_fmt,squished_cc);
467
468     if (create)
469         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE,keypath,key);
470     else
471         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,keypath,key);
472
473     return rc;
474 }
475
476 UINT MSIREG_OpenUserComponentsKey(LPCWSTR szComponent, HKEY* key, BOOL create)
477 {
478     UINT rc;
479     WCHAR squished_cc[GUID_SIZE];
480     WCHAR keypath[0x200];
481
482     TRACE("%s\n",debugstr_w(szComponent));
483     squash_guid(szComponent,squished_cc);
484     TRACE("squished (%s)\n", debugstr_w(squished_cc));
485
486     sprintfW(keypath,szUser_Components_fmt,squished_cc);
487
488     if (create)
489         rc = RegCreateKeyW(HKEY_CURRENT_USER,keypath,key);
490     else
491         rc = RegOpenKeyW(HKEY_CURRENT_USER,keypath,key);
492
493     return rc;
494 }
495
496 UINT MSIREG_OpenProductsKey(LPCWSTR szProduct, HKEY* key, BOOL create)
497 {
498     UINT rc;
499     WCHAR squished_pc[GUID_SIZE];
500     WCHAR keypath[0x200];
501
502     TRACE("%s\n",debugstr_w(szProduct));
503     squash_guid(szProduct,squished_pc);
504     TRACE("squished (%s)\n", debugstr_w(squished_pc));
505
506     sprintfW(keypath,szInstaller_Products_fmt,squished_pc);
507
508     if (create)
509         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE,keypath,key);
510     else
511         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,keypath,key);
512
513     return rc;
514 }
515
516 UINT MSIREG_OpenUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY* key, BOOL create)
517 {
518     UINT rc;
519     WCHAR squished_pc[GUID_SIZE];
520     WCHAR keypath[0x200];
521
522     TRACE("%s\n",debugstr_w(szUpgradeCode));
523     squash_guid(szUpgradeCode,squished_pc);
524     TRACE("squished (%s)\n", debugstr_w(squished_pc));
525
526     sprintfW(keypath,szInstaller_UpgradeCodes_fmt,squished_pc);
527
528     if (create)
529         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE,keypath,key);
530     else
531         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,keypath,key);
532
533     return rc;
534 }
535
536 UINT MSIREG_OpenUserUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY* key, BOOL create)
537 {
538     UINT rc;
539     WCHAR squished_pc[GUID_SIZE];
540     WCHAR keypath[0x200];
541
542     TRACE("%s\n",debugstr_w(szUpgradeCode));
543     squash_guid(szUpgradeCode,squished_pc);
544     TRACE("squished (%s)\n", debugstr_w(squished_pc));
545
546     sprintfW(keypath,szInstaller_UserUpgradeCodes_fmt,squished_pc);
547
548     if (create)
549         rc = RegCreateKeyW(HKEY_CURRENT_USER,keypath,key);
550     else
551         rc = RegOpenKeyW(HKEY_CURRENT_USER,keypath,key);
552
553     return rc;
554 }
555
556
557 /*************************************************************************
558  *  MsiDecomposeDescriptorW   [MSI.@]
559  *
560  * Decomposes an MSI descriptor into product, feature and component parts.
561  * An MSI descriptor is a string of the form:
562  *   [base 85 guid] [feature code] '>' [base 85 guid]
563  *
564  * PARAMS
565  *   szDescriptor  [I]  the descriptor to decompose
566  *   szProduct     [O]  buffer of MAX_FEATURE_CHARS+1 for the product guid
567  *   szFeature     [O]  buffer of MAX_FEATURE_CHARS+1 for the feature code
568  *   szComponent   [O]  buffer of MAX_FEATURE_CHARS+1 for the component guid
569  *   pUsed         [O]  the length of the descriptor
570  *
571  * RETURNS
572  *   ERROR_SUCCESS             if everything worked correctly
573  *   ERROR_INVALID_PARAMETER   if the descriptor was invalid
574  *
575  */
576 UINT WINAPI MsiDecomposeDescriptorW( LPCWSTR szDescriptor, LPWSTR szProduct,
577                 LPWSTR szFeature, LPWSTR szComponent, DWORD *pUsed )
578 {
579     UINT r, len;
580     LPWSTR p;
581     GUID product, component;
582
583     TRACE("%s %p %p %p %p\n", debugstr_w(szDescriptor), szProduct,
584           szFeature, szComponent, pUsed);
585
586     r = decode_base85_guid( szDescriptor, &product );
587     if( !r )
588         return ERROR_INVALID_PARAMETER;
589
590     TRACE("product %s\n", debugstr_guid( &product ));
591
592     p = strchrW(&szDescriptor[20],'>');
593     if( !p )
594         return ERROR_INVALID_PARAMETER;
595
596     len = (p - &szDescriptor[20]);
597     if( len > MAX_FEATURE_CHARS )
598         return ERROR_INVALID_PARAMETER;
599
600     TRACE("feature %s\n", debugstr_wn( &szDescriptor[20], len ));
601
602     r = decode_base85_guid( p+1, &component );
603     if( !r )
604         return ERROR_INVALID_PARAMETER;
605
606     TRACE("component %s\n", debugstr_guid( &component ));
607
608     if (szProduct)
609         StringFromGUID2( &product, szProduct, MAX_FEATURE_CHARS+1 );
610     if (szComponent)
611         StringFromGUID2( &component, szComponent, MAX_FEATURE_CHARS+1 );
612     if (szFeature)
613     {
614         memcpy( szFeature, &szDescriptor[20], len*sizeof(WCHAR) );
615         szFeature[len] = 0;
616     }
617     len = ( &p[21] - szDescriptor );
618
619     TRACE("length = %d\n", len);
620     *pUsed = len;
621
622     return ERROR_SUCCESS;
623 }
624
625 UINT WINAPI MsiDecomposeDescriptorA( LPCSTR szDescriptor, LPSTR szProduct,
626                 LPSTR szFeature, LPSTR szComponent, DWORD *pUsed )
627 {
628     WCHAR product[MAX_FEATURE_CHARS+1];
629     WCHAR feature[MAX_FEATURE_CHARS+1];
630     WCHAR component[MAX_FEATURE_CHARS+1];
631     LPWSTR str = NULL, p = NULL, f = NULL, c = NULL;
632     UINT r;
633
634     TRACE("%s %p %p %p %p\n", debugstr_a(szDescriptor), szProduct,
635           szFeature, szComponent, pUsed);
636
637     str = strdupAtoW( szDescriptor );
638     if( szDescriptor && !str )
639         return ERROR_OUTOFMEMORY;
640
641     if (szProduct)
642         p = product;
643     if (szFeature)
644         f = feature;
645     if (szComponent)
646         c = component;
647
648     r = MsiDecomposeDescriptorW( str, p, f, c, pUsed );
649
650     if (r == ERROR_SUCCESS)
651     {
652         WideCharToMultiByte( CP_ACP, 0, p, -1,
653                              szProduct, MAX_FEATURE_CHARS+1, NULL, NULL );
654         WideCharToMultiByte( CP_ACP, 0, f, -1,
655                              szFeature, MAX_FEATURE_CHARS+1, NULL, NULL );
656         WideCharToMultiByte( CP_ACP, 0, c, -1,
657                              szComponent, MAX_FEATURE_CHARS+1, NULL, NULL );
658     }
659
660     msi_free( str );
661
662     return r;
663 }
664
665 UINT WINAPI MsiEnumProductsA(DWORD index, LPSTR lpguid)
666 {
667     DWORD r;
668     WCHAR szwGuid[GUID_SIZE];
669
670     TRACE("%d %p\n", index, lpguid);
671
672     if (NULL == lpguid)
673         return ERROR_INVALID_PARAMETER;
674     r = MsiEnumProductsW(index, szwGuid);
675     if( r == ERROR_SUCCESS )
676         WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
677
678     return r;
679 }
680
681 UINT WINAPI MsiEnumProductsW(DWORD index, LPWSTR lpguid)
682 {
683     HKEY hkeyFeatures = 0;
684     DWORD r;
685     WCHAR szKeyName[SQUISH_GUID_SIZE];
686
687     TRACE("%d %p\n", index, lpguid);
688
689     if (NULL == lpguid)
690         return ERROR_INVALID_PARAMETER;
691
692     r = MSIREG_OpenFeatures(&hkeyFeatures);
693     if( r != ERROR_SUCCESS )
694         return ERROR_NO_MORE_ITEMS;
695
696     r = RegEnumKeyW(hkeyFeatures, index, szKeyName, SQUISH_GUID_SIZE);
697     if( r == ERROR_SUCCESS )
698         unsquash_guid(szKeyName, lpguid);
699     RegCloseKey(hkeyFeatures);
700
701     return r;
702 }
703
704 UINT WINAPI MsiEnumFeaturesA(LPCSTR szProduct, DWORD index, 
705       LPSTR szFeature, LPSTR szParent)
706 {
707     DWORD r;
708     WCHAR szwFeature[GUID_SIZE], szwParent[GUID_SIZE];
709     LPWSTR szwProduct = NULL;
710
711     TRACE("%s %d %p %p\n", debugstr_a(szProduct), index, szFeature, szParent);
712
713     if( szProduct )
714     {
715         szwProduct = strdupAtoW( szProduct );
716         if( !szwProduct )
717             return ERROR_OUTOFMEMORY;
718     }
719
720     r = MsiEnumFeaturesW(szwProduct, index, szwFeature, szwParent);
721     if( r == ERROR_SUCCESS )
722     {
723         WideCharToMultiByte(CP_ACP, 0, szwFeature, -1,
724                             szFeature, GUID_SIZE, NULL, NULL);
725         WideCharToMultiByte(CP_ACP, 0, szwParent, -1,
726                             szParent, GUID_SIZE, NULL, NULL);
727     }
728
729     msi_free( szwProduct);
730
731     return r;
732 }
733
734 UINT WINAPI MsiEnumFeaturesW(LPCWSTR szProduct, DWORD index, 
735       LPWSTR szFeature, LPWSTR szParent)
736 {
737     HKEY hkeyProduct = 0;
738     DWORD r, sz;
739
740     TRACE("%s %d %p %p\n", debugstr_w(szProduct), index, szFeature, szParent);
741
742     if( !szProduct )
743         return ERROR_INVALID_PARAMETER;
744
745     r = MSIREG_OpenFeaturesKey(szProduct,&hkeyProduct,FALSE);
746     if( r != ERROR_SUCCESS )
747         return ERROR_NO_MORE_ITEMS;
748
749     sz = GUID_SIZE;
750     r = RegEnumValueW(hkeyProduct, index, szFeature, &sz, NULL, NULL, NULL, NULL);
751     RegCloseKey(hkeyProduct);
752
753     return r;
754 }
755
756 UINT WINAPI MsiEnumComponentsA(DWORD index, LPSTR lpguid)
757 {
758     DWORD r;
759     WCHAR szwGuid[GUID_SIZE];
760
761     TRACE("%d %p\n", index, lpguid);
762
763     r = MsiEnumComponentsW(index, szwGuid);
764     if( r == ERROR_SUCCESS )
765         WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
766
767     return r;
768 }
769
770 UINT WINAPI MsiEnumComponentsW(DWORD index, LPWSTR lpguid)
771 {
772     HKEY hkeyComponents = 0;
773     DWORD r;
774     WCHAR szKeyName[SQUISH_GUID_SIZE];
775
776     TRACE("%d %p\n", index, lpguid);
777
778     r = MSIREG_OpenComponents(&hkeyComponents);
779     if( r != ERROR_SUCCESS )
780         return ERROR_NO_MORE_ITEMS;
781
782     r = RegEnumKeyW(hkeyComponents, index, szKeyName, SQUISH_GUID_SIZE);
783     if( r == ERROR_SUCCESS )
784         unsquash_guid(szKeyName, lpguid);
785     RegCloseKey(hkeyComponents);
786
787     return r;
788 }
789
790 UINT WINAPI MsiEnumClientsA(LPCSTR szComponent, DWORD index, LPSTR szProduct)
791 {
792     DWORD r;
793     WCHAR szwProduct[GUID_SIZE];
794     LPWSTR szwComponent = NULL;
795
796     TRACE("%s %d %p\n", debugstr_a(szComponent), index, szProduct);
797
798     if( szComponent )
799     {
800         szwComponent = strdupAtoW( szComponent );
801         if( !szwComponent )
802             return ERROR_OUTOFMEMORY;
803     }
804
805     r = MsiEnumClientsW(szComponent?szwComponent:NULL, index, szwProduct);
806     if( r == ERROR_SUCCESS )
807     {
808         WideCharToMultiByte(CP_ACP, 0, szwProduct, -1,
809                             szProduct, GUID_SIZE, NULL, NULL);
810     }
811
812     msi_free( szwComponent);
813
814     return r;
815 }
816
817 UINT WINAPI MsiEnumClientsW(LPCWSTR szComponent, DWORD index, LPWSTR szProduct)
818 {
819     HKEY hkeyComp = 0;
820     DWORD r, sz;
821     WCHAR szValName[SQUISH_GUID_SIZE];
822
823     TRACE("%s %d %p\n", debugstr_w(szComponent), index, szProduct);
824
825     r = MSIREG_OpenComponentsKey(szComponent,&hkeyComp,FALSE);
826     if( r != ERROR_SUCCESS )
827         return ERROR_NO_MORE_ITEMS;
828
829     sz = SQUISH_GUID_SIZE;
830     r = RegEnumValueW(hkeyComp, index, szValName, &sz, NULL, NULL, NULL, NULL);
831     if( r == ERROR_SUCCESS )
832         unsquash_guid(szValName, szProduct);
833
834     RegCloseKey(hkeyComp);
835
836     return r;
837 }
838
839 static UINT WINAPI MSI_EnumComponentQualifiers( LPCWSTR szComponent, DWORD iIndex,
840                 awstring *lpQualBuf, DWORD* pcchQual,
841                 awstring *lpAppBuf, DWORD* pcchAppBuf )
842 {
843     DWORD name_sz, val_sz, name_max, val_max, type, ofs;
844     LPWSTR name = NULL, val = NULL;
845     UINT r, r2;
846     HKEY key;
847
848     TRACE("%s %08x %p %p %p %p\n", debugstr_w(szComponent), iIndex,
849           lpQualBuf, pcchQual, lpAppBuf, pcchAppBuf);
850
851     if (!szComponent)
852         return ERROR_INVALID_PARAMETER;
853
854     r = MSIREG_OpenUserComponentsKey( szComponent, &key, FALSE );
855     if (r != ERROR_SUCCESS)
856         return ERROR_UNKNOWN_COMPONENT;
857
858     /* figure out how big the name is we want to return */
859     name_max = 0x10;
860     r = ERROR_OUTOFMEMORY;
861     name = msi_alloc( name_max * sizeof(WCHAR) );
862     if (!name)
863         goto end;
864
865     val_max = 0x10;
866     r = ERROR_OUTOFMEMORY;
867     val = msi_alloc( val_max );
868     if (!val)
869         goto end;
870
871     /* loop until we allocate enough memory */
872     while (1)
873     {
874         name_sz = name_max;
875         val_sz = val_max;
876         r = RegEnumValueW( key, iIndex, name, &name_sz,
877                            NULL, &type, (LPBYTE)val, &val_sz );
878         if (r == ERROR_SUCCESS)
879             break;
880         if (r != ERROR_MORE_DATA)
881             goto end;
882  
883         if (type != REG_MULTI_SZ)
884         {
885             ERR("component data has wrong type (%d)\n", type);
886             goto end;
887         }
888
889         r = ERROR_OUTOFMEMORY;
890         if ((name_sz+1) >= name_max)
891         {
892             name_max *= 2;
893             msi_free( name );
894             name = msi_alloc( name_max * sizeof (WCHAR) );
895             if (!name)
896                 goto end;
897             continue;
898         }
899         if (val_sz > val_max)
900         {
901             val_max = val_sz + sizeof (WCHAR);
902             msi_free( val );
903             val = msi_alloc( val_max * sizeof (WCHAR) );
904             if (!val)
905                 goto end;
906             continue;
907         }
908         ERR("should be enough data, but isn't %d %d\n", name_sz, val_sz );
909         goto end;
910     }
911
912     ofs = 0;
913     r = MsiDecomposeDescriptorW( val, NULL, NULL, NULL, &ofs );
914     if (r != ERROR_SUCCESS)
915         goto end;
916
917     TRACE("Providing %s and %s\n", debugstr_w(name), debugstr_w(val+ofs));
918
919     r = msi_strcpy_to_awstring( name, lpQualBuf, pcchQual );
920     r2 = msi_strcpy_to_awstring( val+ofs, lpAppBuf, pcchAppBuf );
921
922     if (r2 != ERROR_SUCCESS)
923         r = r2;
924
925 end:
926     msi_free(val);
927     msi_free(name);
928     RegCloseKey(key);
929
930     return r;
931 }
932
933 /*************************************************************************
934  *  MsiEnumComponentQualifiersA [MSI.@]
935  */
936 UINT WINAPI MsiEnumComponentQualifiersA( LPCSTR szComponent, DWORD iIndex,
937                 LPSTR lpQualifierBuf, DWORD* pcchQualifierBuf,
938                 LPSTR lpApplicationDataBuf, DWORD* pcchApplicationDataBuf )
939 {
940     awstring qual, appdata;
941     LPWSTR comp;
942     UINT r;
943
944     TRACE("%s %08x %p %p %p %p\n", debugstr_a(szComponent), iIndex,
945           lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf,
946           pcchApplicationDataBuf);
947
948     comp = strdupAtoW( szComponent );
949     if (szComponent && !comp)
950         return ERROR_OUTOFMEMORY;
951
952     qual.unicode = FALSE;
953     qual.str.a = lpQualifierBuf;
954
955     appdata.unicode = FALSE;
956     appdata.str.a = lpApplicationDataBuf;
957
958     r = MSI_EnumComponentQualifiers( comp, iIndex,
959               &qual, pcchQualifierBuf, &appdata, pcchApplicationDataBuf );
960     msi_free( comp );
961     return r;
962 }
963
964 /*************************************************************************
965  *  MsiEnumComponentQualifiersW [MSI.@]
966  */
967 UINT WINAPI MsiEnumComponentQualifiersW( LPCWSTR szComponent, DWORD iIndex,
968                 LPWSTR lpQualifierBuf, DWORD* pcchQualifierBuf,
969                 LPWSTR lpApplicationDataBuf, DWORD* pcchApplicationDataBuf )
970 {
971     awstring qual, appdata;
972
973     TRACE("%s %08x %p %p %p %p\n", debugstr_w(szComponent), iIndex,
974           lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf,
975           pcchApplicationDataBuf);
976
977     qual.unicode = TRUE;
978     qual.str.w = lpQualifierBuf;
979
980     appdata.unicode = TRUE;
981     appdata.str.w = lpApplicationDataBuf;
982
983     return MSI_EnumComponentQualifiers( szComponent, iIndex,
984                  &qual, pcchQualifierBuf, &appdata, pcchApplicationDataBuf );
985 }
986
987 /*************************************************************************
988  *  MsiEnumRelatedProductsW   [MSI.@]
989  *
990  */
991 UINT WINAPI MsiEnumRelatedProductsW(LPCWSTR szUpgradeCode, DWORD dwReserved,
992                                     DWORD iProductIndex, LPWSTR lpProductBuf)
993 {
994     UINT r;
995     HKEY hkey;
996     WCHAR szKeyName[SQUISH_GUID_SIZE];
997
998     TRACE("%s %u %u %p\n", debugstr_w(szUpgradeCode), dwReserved,
999           iProductIndex, lpProductBuf);
1000
1001     if (NULL == szUpgradeCode)
1002         return ERROR_INVALID_PARAMETER;
1003     if (NULL == lpProductBuf)
1004         return ERROR_INVALID_PARAMETER;
1005
1006     r = MSIREG_OpenUpgradeCodesKey(szUpgradeCode, &hkey, FALSE);
1007     if (r != ERROR_SUCCESS)
1008         return ERROR_NO_MORE_ITEMS;
1009
1010     r = RegEnumKeyW(hkey, iProductIndex, szKeyName, SQUISH_GUID_SIZE);
1011     if( r == ERROR_SUCCESS )
1012         unsquash_guid(szKeyName, lpProductBuf);
1013     RegCloseKey(hkey);
1014
1015     return r;
1016 }
1017
1018 /*************************************************************************
1019  *  MsiEnumRelatedProductsA   [MSI.@]
1020  *
1021  */
1022 UINT WINAPI MsiEnumRelatedProductsA(LPCSTR szUpgradeCode, DWORD dwReserved,
1023                                     DWORD iProductIndex, LPSTR lpProductBuf)
1024 {
1025     LPWSTR szwUpgradeCode = NULL;
1026     WCHAR productW[GUID_SIZE];
1027     UINT r;
1028
1029     TRACE("%s %u %u %p\n", debugstr_a(szUpgradeCode), dwReserved,
1030           iProductIndex, lpProductBuf);
1031
1032     if (szUpgradeCode)
1033     {
1034         szwUpgradeCode = strdupAtoW( szUpgradeCode );
1035         if( !szwUpgradeCode )
1036             return ERROR_OUTOFMEMORY;
1037     }
1038
1039     r = MsiEnumRelatedProductsW( szwUpgradeCode, dwReserved,
1040                                  iProductIndex, productW );
1041     if (r == ERROR_SUCCESS)
1042     {
1043         WideCharToMultiByte( CP_ACP, 0, productW, GUID_SIZE,
1044                              lpProductBuf, GUID_SIZE, NULL, NULL );
1045     }
1046     msi_free( szwUpgradeCode);
1047     return r;
1048 }
1049
1050 /***********************************************************************
1051  * MsiEnumPatchesA            [MSI.@]
1052  */
1053 UINT WINAPI MsiEnumPatchesA( LPCSTR szProduct, DWORD iPatchIndex,
1054         LPSTR lpPatchBuf, LPSTR lpTransformsBuf, DWORD* pcchTransformsBuf)
1055 {
1056     FIXME("%s %d %p %p %p\n", debugstr_a(szProduct),
1057           iPatchIndex, lpPatchBuf, lpTransformsBuf, pcchTransformsBuf);
1058     return ERROR_NO_MORE_ITEMS;
1059 }
1060
1061 /***********************************************************************
1062  * MsiEnumPatchesW            [MSI.@]
1063  */
1064 UINT WINAPI MsiEnumPatchesW( LPCWSTR szProduct, DWORD iPatchIndex,
1065         LPWSTR lpPatchBuf, LPWSTR lpTransformsBuf, DWORD* pcchTransformsBuf)
1066 {
1067     FIXME("%s %d %p %p %p\n", debugstr_w(szProduct),
1068           iPatchIndex, lpPatchBuf, lpTransformsBuf, pcchTransformsBuf);
1069     return ERROR_NO_MORE_ITEMS;
1070 }