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