?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wbemprox: Tweak a comment.
[wine.git] / dlls / msi / registry.c
blobcbc8d8d6f0a58d5855f0db971d909e463e71ac5f
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 HKEY root = HKEY_LOCAL_MACHINE;
495 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
496 WCHAR *usersid = NULL, squashed_pc[SQUASHED_GUID_SIZE], keypath[MAX_PATH];
497
498 if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
499 TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
500
501 if (context == MSIINSTALLCONTEXT_MACHINE)
502 {
503 strcpyW(keypath, szInstaller_LocalClassesProd);
504 strcatW( keypath, squashed_pc );
505 }
506 else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
507 {
508 root = HKEY_CURRENT_USER;
509 strcpyW(keypath, szUserProducts);
510 strcatW( keypath, squashed_pc );
511 }
512 else
513 {
514 if (!szUserSid)
515 {
516 if (!(usersid = get_user_sid()))
517 {
518 ERR("Failed to retrieve user SID\n");
519 return ERROR_FUNCTION_FAILED;
520 }
521 szUserSid = usersid;
522 }
523 sprintfW( keypath, szInstaller_LocalManagedProd_fmt, szUserSid, squashed_pc );
524 LocalFree(usersid);
525 }
526 if (create) return RegCreateKeyExW(root, keypath, 0, NULL, 0, access, NULL, key, NULL);
527 return RegOpenKeyExW(root, keypath, 0, access, key);
528 }
529
530 UINT MSIREG_DeleteUserProductKey(LPCWSTR szProduct)
531 {
532 WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
533
534 if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
535 TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
536
537 strcpyW(keypath, szUserProducts);
538 strcatW( keypath, squashed_pc );
539 return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
540 }
541
542 UINT MSIREG_OpenUserPatchesKey(LPCWSTR szPatch, HKEY *key, BOOL create)
543 {
544 WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
545
546 if (!squash_guid( szPatch, squashed_pc )) return ERROR_FUNCTION_FAILED;
547 TRACE("%s squashed %s\n", debugstr_w(szPatch), debugstr_w(squashed_pc));
548
549 strcpyW(keypath, szUserPatches);
550 strcatW( keypath, squashed_pc );
551
552 if (create) return RegCreateKeyW(HKEY_CURRENT_USER, keypath, key);
553 return RegOpenKeyW(HKEY_CURRENT_USER, keypath, key);
554 }
555
556 UINT MSIREG_OpenFeaturesKey(LPCWSTR szProduct, LPCWSTR szUserSid, MSIINSTALLCONTEXT context,
557 HKEY *key, BOOL create)
558 {
559 HKEY root = HKEY_LOCAL_MACHINE;
560 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
561 WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[MAX_PATH], *usersid = NULL;
562
563 if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
564 TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
565
566 if (context == MSIINSTALLCONTEXT_MACHINE)
567 {
568 strcpyW(keypath, szInstaller_LocalClassesFeat);
569 strcatW( keypath, squashed_pc );
570 }
571 else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
572 {
573 root = HKEY_CURRENT_USER;
574 strcpyW(keypath, szUserFeatures);
575 strcatW( keypath, squashed_pc );
576 }
577 else
578 {
579 if (!szUserSid)
580 {
581 if (!(usersid = get_user_sid()))
582 {
583 ERR("Failed to retrieve user SID\n");
584 return ERROR_FUNCTION_FAILED;
585 }
586 szUserSid = usersid;
587 }
588 sprintfW( keypath, szInstaller_LocalManagedFeat_fmt, szUserSid, squashed_pc );
589 LocalFree(usersid);
590 }
591 if (create) return RegCreateKeyExW(root, keypath, 0, NULL, 0, access, NULL, key, NULL);
592 return RegOpenKeyExW(root, keypath, 0, access, key);
593 }
594
595 UINT MSIREG_DeleteUserFeaturesKey(LPCWSTR szProduct)
596 {
597 WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
598
599 if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
600 TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
601
602 strcpyW(keypath, szUserFeatures);
603 strcatW( keypath, squashed_pc );
604 return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
605 }
606
607 static UINT MSIREG_OpenInstallerFeaturesKey(LPCWSTR szProduct, HKEY *key, BOOL create)
608 {
609 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
610 WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
611
612 if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
613 TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
614
615 strcpyW(keypath, szInstaller_Features);
616 strcatW( keypath, squashed_pc );
617
618 if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
619 return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
620 }
621
622 UINT MSIREG_OpenUserDataFeaturesKey(LPCWSTR szProduct, LPCWSTR szUserSid, MSIINSTALLCONTEXT context,
623 HKEY *key, BOOL create)
624 {
625 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
626 WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200], *usersid = NULL;
627
628 if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
629 TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
630
631 if (context == MSIINSTALLCONTEXT_MACHINE)
632 {
633 sprintfW( keypath, szUserDataFeatures_fmt, szLocalSid, squashed_pc );
634 }
635 else
636 {
637 if (!szUserSid)
638 {
639 if (!(usersid = get_user_sid()))
640 {
641 ERR("Failed to retrieve user SID\n");
642 return ERROR_FUNCTION_FAILED;
643 }
644 szUserSid = usersid;
645 }
646 sprintfW( keypath, szUserDataFeatures_fmt, szUserSid, squashed_pc );
647 LocalFree(usersid);
648 }
649 if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
650 return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
651 }
652
653 UINT MSIREG_OpenUserComponentsKey(LPCWSTR szComponent, HKEY *key, BOOL create)
654 {
655 WCHAR squashed_cc[SQUASHED_GUID_SIZE], keypath[0x200];
656 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
657 UINT ret;
658
659 if (!squash_guid( szComponent, squashed_cc)) return ERROR_FUNCTION_FAILED;
660 TRACE("%s squashed %s\n", debugstr_w(szComponent), debugstr_w(squashed_cc));
661
662 strcpyW(keypath, szUserComponents);
663 strcatW( keypath, squashed_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, squashed_cc );
671 return RegOpenKeyExW( HKEY_LOCAL_MACHINE, keypath, 0, access, 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 *usersid, squashed_comp[SQUASHED_GUID_SIZE], keypath[0x200];
678
679 if (!squash_guid( szComponent, squashed_comp )) return ERROR_FUNCTION_FAILED;
680 TRACE("%s squashed %s\n", debugstr_w(szComponent), debugstr_w(squashed_comp));
681
682 if (!szUserSid)
683 {
684 if (!(usersid = get_user_sid()))
685 {
686 ERR("Failed to retrieve user SID\n");
687 return ERROR_FUNCTION_FAILED;
688 }
689 sprintfW( keypath, szUserDataComp_fmt, usersid, squashed_comp );
690 LocalFree(usersid);
691 }
692 else
693 sprintfW( keypath, szUserDataComp_fmt, szUserSid, squashed_comp );
694
695 if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
696 return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
697 }
698
699 UINT MSIREG_DeleteUserDataComponentKey(LPCWSTR szComponent, LPCWSTR szUserSid)
700 {
701 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
702 WCHAR *usersid, squashed_comp[SQUASHED_GUID_SIZE], keypath[0x200];
703 HKEY hkey;
704 LONG r;
705
706 if (!squash_guid( szComponent, squashed_comp )) return ERROR_FUNCTION_FAILED;
707 TRACE("%s squashed %s\n", debugstr_w(szComponent), debugstr_w(squashed_comp));
708
709 if (!szUserSid)
710 {
711 if (!(usersid = get_user_sid()))
712 {
713 ERR("Failed to retrieve user SID\n");
714 return ERROR_FUNCTION_FAILED;
715 }
716 sprintfW(keypath, szUserDataComponents_fmt, usersid);
717 LocalFree(usersid);
718 }
719 else
720 sprintfW(keypath, szUserDataComponents_fmt, szUserSid);
721
722 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, &hkey)) return ERROR_SUCCESS;
723 r = RegDeleteTreeW( hkey, squashed_comp );
724 RegCloseKey(hkey);
725 return r;
726 }
727
728 UINT MSIREG_OpenUserDataProductKey(LPCWSTR szProduct, MSIINSTALLCONTEXT dwContext, LPCWSTR szUserSid, HKEY *key, BOOL create)
729 {
730 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
731 WCHAR *usersid, squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
732
733 if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
734 TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
735
736 if (dwContext == MSIINSTALLCONTEXT_MACHINE)
737 sprintfW( keypath, szUserDataProd_fmt, szLocalSid, squashed_pc );
738 else if (szUserSid)
739 sprintfW( keypath, szUserDataProd_fmt, szUserSid, squashed_pc );
740 else
741 {
742 if (!(usersid = get_user_sid()))
743 {
744 ERR("Failed to retrieve user SID\n");
745 return ERROR_FUNCTION_FAILED;
746 }
747 sprintfW( keypath, szUserDataProd_fmt, usersid, squashed_pc );
748 LocalFree(usersid);
749 }
750 if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
751 return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
752 }
753
754 UINT MSIREG_OpenUserDataPatchKey(LPCWSTR szPatch, MSIINSTALLCONTEXT dwContext, HKEY *key, BOOL create)
755 {
756 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
757 WCHAR *usersid, squashed_patch[SQUASHED_GUID_SIZE], keypath[0x200];
758
759 if (!squash_guid( szPatch, squashed_patch )) return ERROR_FUNCTION_FAILED;
760 TRACE("%s squashed %s\n", debugstr_w(szPatch), debugstr_w(squashed_patch));
761
762 if (dwContext == MSIINSTALLCONTEXT_MACHINE)
763 sprintfW( keypath, szUserDataPatch_fmt, szLocalSid, squashed_patch );
764 else
765 {
766 if (!(usersid = get_user_sid()))
767 {
768 ERR("Failed to retrieve user SID\n");
769 return ERROR_FUNCTION_FAILED;
770 }
771 sprintfW( keypath, szUserDataPatch_fmt, usersid, squashed_patch );
772 LocalFree(usersid);
773 }
774 if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
775 return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
776 }
777
778 UINT MSIREG_DeleteUserDataPatchKey(LPCWSTR patch, MSIINSTALLCONTEXT context)
779 {
780 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
781 WCHAR *usersid, squashed_patch[SQUASHED_GUID_SIZE], keypath[0x200];
782 HKEY hkey;
783 LONG r;
784
785 if (!squash_guid( patch, squashed_patch )) return ERROR_FUNCTION_FAILED;
786 TRACE("%s squashed %s\n", debugstr_w(patch), debugstr_w(squashed_patch));
787
788 if (context == MSIINSTALLCONTEXT_MACHINE)
789 sprintfW(keypath, szUserDataPatches_fmt, szLocalSid);
790 else
791 {
792 if (!(usersid = get_user_sid()))
793 {
794 ERR("Failed to retrieve user SID\n");
795 return ERROR_FUNCTION_FAILED;
796 }
797 sprintfW(keypath, szUserDataPatches_fmt, usersid);
798 LocalFree(usersid);
799 }
800 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, &hkey)) return ERROR_SUCCESS;
801 r = RegDeleteTreeW( hkey, squashed_patch );
802 RegCloseKey(hkey);
803 return r;
804 }
805
806 UINT MSIREG_OpenUserDataProductPatchesKey(LPCWSTR product, MSIINSTALLCONTEXT context, HKEY *key, BOOL create)
807 {
808 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
809 WCHAR *usersid, squashed_product[SQUASHED_GUID_SIZE], keypath[0x200];
810
811 if (!squash_guid( product, squashed_product )) return ERROR_FUNCTION_FAILED;
812 TRACE("%s squashed %s\n", debugstr_w(product), debugstr_w(squashed_product));
813
814 if (context == MSIINSTALLCONTEXT_MACHINE)
815 sprintfW( keypath, szUserDataProductPatches_fmt, szLocalSid, squashed_product );
816 else
817 {
818 if (!(usersid = get_user_sid()))
819 {
820 ERR("Failed to retrieve user SID\n");
821 return ERROR_FUNCTION_FAILED;
822 }
823 sprintfW( keypath, szUserDataProductPatches_fmt, usersid, squashed_product );
824 LocalFree(usersid);
825 }
826 if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
827 return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
828 }
829
830 UINT MSIREG_OpenInstallProps(LPCWSTR szProduct, MSIINSTALLCONTEXT dwContext, LPCWSTR szUserSid, HKEY *key, BOOL create)
831 {
832 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
833 WCHAR *usersid, squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
834
835 if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
836 TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
837
838 if (dwContext == MSIINSTALLCONTEXT_MACHINE)
839 sprintfW( keypath, szInstallProperties_fmt, szLocalSid, squashed_pc );
840 else if (szUserSid)
841 sprintfW( keypath, szInstallProperties_fmt, szUserSid, squashed_pc );
842 else
843 {
844 if (!(usersid = get_user_sid()))
845 {
846 ERR("Failed to retrieve user SID\n");
847 return ERROR_FUNCTION_FAILED;
848 }
849 sprintfW( keypath, szInstallProperties_fmt, usersid, squashed_pc );
850 LocalFree(usersid);
851 }
852 if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
853 return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
854 }
855
856 UINT MSIREG_DeleteUserDataProductKey(LPCWSTR szProduct, MSIINSTALLCONTEXT context)
857 {
858 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
859 WCHAR *usersid, squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
860 HKEY hkey;
861 LONG r;
862
863 if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
864 TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
865
866 if (context == MSIINSTALLCONTEXT_MACHINE)
867 sprintfW(keypath, szUserDataProducts_fmt, szLocalSid);
868 else
869 {
870 if (!(usersid = get_user_sid()))
871 {
872 ERR("Failed to retrieve user SID\n");
873 return ERROR_FUNCTION_FAILED;
874 }
875 sprintfW(keypath, szUserDataProducts_fmt, usersid);
876 LocalFree(usersid);
877 }
878
879 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, &hkey)) return ERROR_SUCCESS;
880 r = RegDeleteTreeW( hkey, squashed_pc );
881 RegCloseKey(hkey);
882 return r;
883 }
884
885 UINT MSIREG_DeleteProductKey(LPCWSTR szProduct)
886 {
887 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
888 WCHAR squashed_pc[SQUASHED_GUID_SIZE];
889 HKEY hkey;
890 LONG r;
891
892 if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
893 TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
894
895 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szInstaller_Products, 0, access, &hkey)) return ERROR_SUCCESS;
896 r = RegDeleteTreeW( hkey, squashed_pc );
897 RegCloseKey(hkey);
898 return r;
899 }
900
901 UINT MSIREG_OpenPatchesKey(LPCWSTR szPatch, HKEY *key, BOOL create)
902 {
903 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
904 WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
905
906 if (!squash_guid( szPatch, squashed_pc )) return ERROR_FUNCTION_FAILED;
907 TRACE("%s squashed %s\n", debugstr_w(szPatch), debugstr_w(squashed_pc));
908
909 sprintfW( keypath, szInstaller_Patches, squashed_pc );
910
911 if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
912 return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
913 }
914
915 UINT MSIREG_OpenUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY *key, BOOL create)
916 {
917 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
918 WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
919
920 if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
921 TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
922
923 strcpyW(keypath, szInstaller_UpgradeCodes);
924 strcatW( keypath, squashed_uc );
925
926 if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
927 return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
928 }
929
930 UINT MSIREG_OpenUserUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY* key, BOOL create)
931 {
932 WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
933
934 if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
935 TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
936
937 strcpyW(keypath, szInstaller_UserUpgradeCodes);
938 strcatW( keypath, squashed_uc );
939
940 if (create) return RegCreateKeyW(HKEY_CURRENT_USER, keypath, key);
941 return RegOpenKeyW(HKEY_CURRENT_USER, keypath, key);
942 }
943
944 UINT MSIREG_DeleteUpgradeCodesKey( const WCHAR *code )
945 {
946 WCHAR squashed_code[SQUASHED_GUID_SIZE];
947 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
948 HKEY hkey;
949 LONG ret;
950
951 if (!squash_guid( code, squashed_code )) return ERROR_FUNCTION_FAILED;
952 TRACE( "%s squashed %s\n", debugstr_w(code), debugstr_w(squashed_code) );
953
954 if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, szInstaller_UpgradeCodes, 0, access, &hkey )) return ERROR_SUCCESS;
955 ret = RegDeleteTreeW( hkey, squashed_code );
956 RegCloseKey( hkey );
957 return ret;
958 }
959
960 UINT MSIREG_DeleteUserUpgradeCodesKey(LPCWSTR szUpgradeCode)
961 {
962 WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
963
964 if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
965 TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
966
967 strcpyW(keypath, szInstaller_UserUpgradeCodes);
968 strcatW( keypath, squashed_uc );
969 return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
970 }
971
972 UINT MSIREG_DeleteLocalClassesProductKey(LPCWSTR szProductCode)
973 {
974 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
975 WCHAR squashed_pc[SQUASHED_GUID_SIZE];
976 HKEY hkey;
977 LONG r;
978
979 if (!squash_guid( szProductCode, squashed_pc )) return ERROR_FUNCTION_FAILED;
980 TRACE("%s squashed %s\n", debugstr_w(szProductCode), debugstr_w(squashed_pc));
981
982 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szInstaller_LocalClassesProducts, 0, access, &hkey)) return ERROR_SUCCESS;
983 r = RegDeleteTreeW( hkey, squashed_pc );
984 RegCloseKey(hkey);
985 return r;
986 }
987
988 UINT MSIREG_DeleteLocalClassesFeaturesKey(LPCWSTR szProductCode)
989 {
990 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
991 WCHAR squashed_pc[SQUASHED_GUID_SIZE];
992 HKEY hkey;
993 LONG r;
994
995 if (!squash_guid( szProductCode, squashed_pc )) return ERROR_FUNCTION_FAILED;
996 TRACE("%s squashed %s\n", debugstr_w(szProductCode), debugstr_w(squashed_pc));
997
998 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szInstaller_LocalClassesFeatures, 0, access, &hkey)) return ERROR_SUCCESS;
999 r = RegDeleteTreeW( hkey, squashed_pc );
1000 RegCloseKey(hkey);
1001 return r;
1002 }
1003
1004 UINT MSIREG_OpenClassesUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY *key, BOOL create)
1005 {
1006 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
1007 WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
1008
1009 if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
1010 TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
1011
1012 strcpyW(keypath, szInstaller_ClassesUpgradeCode);
1013 strcatW( keypath, squashed_uc );
1014
1015 if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
1016 return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
1017 }
1018
1019 UINT MSIREG_DeleteClassesUpgradeCodesKey(LPCWSTR szUpgradeCode)
1020 {
1021 REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
1022 WCHAR squashed_uc[SQUASHED_GUID_SIZE];
1023 HKEY hkey;
1024 LONG r;
1025
1026 if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
1027 TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
1028
1029 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szInstaller_ClassesUpgradeCodes, 0, access, &hkey)) return ERROR_SUCCESS;
1030 r = RegDeleteTreeW( hkey, squashed_uc );
1031 RegCloseKey(hkey);
1032 return r;
1033 }
1034
1035 /*************************************************************************
1036 * MsiDecomposeDescriptorW [MSI.@]
1037 *
1038 * Decomposes an MSI descriptor into product, feature and component parts.
1039 * An MSI descriptor is a string of the form:
1040 * [base 85 guid] [feature code] '>' [base 85 guid] or
1041 * [base 85 guid] [feature code] '<'
1042 *
1043 * PARAMS
1044 * szDescriptor [I] the descriptor to decompose
1045 * szProduct [O] buffer of MAX_FEATURE_CHARS+1 for the product guid
1046 * szFeature [O] buffer of MAX_FEATURE_CHARS+1 for the feature code
1047 * szComponent [O] buffer of MAX_FEATURE_CHARS+1 for the component guid
1048 * pUsed [O] the length of the descriptor
1049 *
1050 * RETURNS
1051 * ERROR_SUCCESS if everything worked correctly
1052 * ERROR_INVALID_PARAMETER if the descriptor was invalid
1053 *
1054 */
1055 UINT WINAPI MsiDecomposeDescriptorW( LPCWSTR szDescriptor, LPWSTR szProduct,
1056 LPWSTR szFeature, LPWSTR szComponent, LPDWORD pUsed )
1057 {
1058 UINT len;
1059 const WCHAR *p;
1060 GUID product, component;
1061
1062 TRACE("%s %p %p %p %p\n", debugstr_w(szDescriptor), szProduct,
1063 szFeature, szComponent, pUsed);
1064
1065 if (!decode_base85_guid( szDescriptor, &product ))
1066 return ERROR_INVALID_PARAMETER;
1067
1068 TRACE("product %s\n", debugstr_guid( &product ));
1069
1070 if (!(p = strchrW( &szDescriptor[20], '>' )))
1071 p = strchrW( &szDescriptor[20], '<' );
1072 if (!p)
1073 return ERROR_INVALID_PARAMETER;
1074
1075 len = (p - &szDescriptor[20]);
1076 if( len > MAX_FEATURE_CHARS )
1077 return ERROR_INVALID_PARAMETER;
1078
1079 TRACE("feature %s\n", debugstr_wn( &szDescriptor[20], len ));
1080
1081 if (*p == '>')
1082 {
1083 if (!decode_base85_guid( p+1, &component ))
1084 return ERROR_INVALID_PARAMETER;
1085 TRACE( "component %s\n", debugstr_guid(&component) );
1086 }
1087
1088 if (szProduct)
1089 StringFromGUID2( &product, szProduct, MAX_FEATURE_CHARS+1 );
1090 if (szComponent)
1091 {
1092 if (*p == '>')
1093 StringFromGUID2( &component, szComponent, MAX_FEATURE_CHARS+1 );
1094 else
1095 szComponent[0] = 0;
1096 }
1097 if (szFeature)
1098 {
1099 memcpy( szFeature, &szDescriptor[20], len*sizeof(WCHAR) );
1100 szFeature[len] = 0;
1101 }
1102
1103 len = p - szDescriptor + 1;
1104 if (*p == '>') len += 20;
1105
1106 TRACE("length = %d\n", len);
1107 if (pUsed) *pUsed = len;
1108
1109 return ERROR_SUCCESS;
1110 }
1111
1112 UINT WINAPI MsiDecomposeDescriptorA( LPCSTR szDescriptor, LPSTR szProduct,
1113 LPSTR szFeature, LPSTR szComponent, LPDWORD pUsed )
1114 {
1115 WCHAR product[MAX_FEATURE_CHARS+1];
1116 WCHAR feature[MAX_FEATURE_CHARS+1];
1117 WCHAR component[MAX_FEATURE_CHARS+1];
1118 LPWSTR str = NULL, p = NULL, f = NULL, c = NULL;
1119 UINT r;
1120
1121 TRACE("%s %p %p %p %p\n", debugstr_a(szDescriptor), szProduct,
1122 szFeature, szComponent, pUsed);
1123
1124 str = strdupAtoW( szDescriptor );
1125 if( szDescriptor && !str )
1126 return ERROR_OUTOFMEMORY;
1127
1128 if (szProduct)
1129 p = product;
1130 if (szFeature)
1131 f = feature;
1132 if (szComponent)
1133 c = component;
1134
1135 r = MsiDecomposeDescriptorW( str, p, f, c, pUsed );
1136
1137 if (r == ERROR_SUCCESS)
1138 {
1139 WideCharToMultiByte( CP_ACP, 0, p, -1,
1140 szProduct, MAX_FEATURE_CHARS+1, NULL, NULL );
1141 WideCharToMultiByte( CP_ACP, 0, f, -1,
1142 szFeature, MAX_FEATURE_CHARS+1, NULL, NULL );
1143 WideCharToMultiByte( CP_ACP, 0, c, -1,
1144 szComponent, MAX_FEATURE_CHARS+1, NULL, NULL );
1145 }
1146
1147 msi_free( str );
1148
1149 return r;
1150 }
1151
1152 UINT WINAPI MsiEnumProductsA(DWORD index, LPSTR lpguid)
1153 {
1154 DWORD r;
1155 WCHAR szwGuid[GUID_SIZE];
1156
1157 TRACE("%d %p\n", index, lpguid);
1158
1159 if (NULL == lpguid)
1160 return ERROR_INVALID_PARAMETER;
1161 r = MsiEnumProductsW(index, szwGuid);
1162 if( r == ERROR_SUCCESS )
1163 WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
1164
1165 return r;
1166 }
1167
1168 UINT WINAPI MsiEnumProductsW(DWORD index, LPWSTR lpguid)
1169 {
1170 TRACE("%d %p\n", index, lpguid);
1171
1172 if (NULL == lpguid)
1173 return ERROR_INVALID_PARAMETER;
1174
1175 return MsiEnumProductsExW( NULL, szAllSid, MSIINSTALLCONTEXT_ALL, index, lpguid,
1176 NULL, NULL, NULL );
1177 }
1178
1179 UINT WINAPI MsiEnumFeaturesA(LPCSTR szProduct, DWORD index,
1180 LPSTR szFeature, LPSTR szParent)
1181 {
1182 DWORD r;
1183 WCHAR szwFeature[GUID_SIZE], szwParent[GUID_SIZE];
1184 LPWSTR szwProduct = NULL;
1185
1186 TRACE("%s %d %p %p\n", debugstr_a(szProduct), index, szFeature, szParent);
1187
1188 if( szProduct )
1189 {
1190 szwProduct = strdupAtoW( szProduct );
1191 if( !szwProduct )
1192 return ERROR_OUTOFMEMORY;
1193 }
1194
1195 r = MsiEnumFeaturesW(szwProduct, index, szwFeature, szwParent);
1196 if( r == ERROR_SUCCESS )
1197 {
1198 WideCharToMultiByte(CP_ACP, 0, szwFeature, -1,
1199 szFeature, GUID_SIZE, NULL, NULL);
1200 WideCharToMultiByte(CP_ACP, 0, szwParent, -1,
1201 szParent, GUID_SIZE, NULL, NULL);
1202 }
1203
1204 msi_free( szwProduct);
1205
1206 return r;
1207 }
1208
1209 UINT WINAPI MsiEnumFeaturesW(LPCWSTR szProduct, DWORD index,
1210 LPWSTR szFeature, LPWSTR szParent)
1211 {
1212 HKEY hkeyProduct = 0;
1213 DWORD r, sz;
1214
1215 TRACE("%s %d %p %p\n", debugstr_w(szProduct), index, szFeature, szParent);
1216
1217 if( !szProduct )
1218 return ERROR_INVALID_PARAMETER;
1219
1220 r = MSIREG_OpenInstallerFeaturesKey(szProduct,&hkeyProduct,FALSE);
1221 if( r != ERROR_SUCCESS )
1222 return ERROR_NO_MORE_ITEMS;
1223
1224 sz = GUID_SIZE;
1225 r = RegEnumValueW(hkeyProduct, index, szFeature, &sz, NULL, NULL, NULL, NULL);
1226 RegCloseKey(hkeyProduct);
1227
1228 return r;
1229 }
1230
1231 UINT WINAPI MsiEnumComponentsA(DWORD index, LPSTR lpguid)
1232 {
1233 DWORD r;
1234 WCHAR szwGuid[GUID_SIZE];
1235
1236 TRACE("%u, %p\n", index, lpguid);
1237
1238 if (!lpguid) return ERROR_INVALID_PARAMETER;
1239
1240 r = MsiEnumComponentsW(index, szwGuid);
1241 if( r == ERROR_SUCCESS )
1242 WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
1243
1244 return r;
1245 }
1246
1247 UINT WINAPI MsiEnumComponentsW(DWORD index, LPWSTR lpguid)
1248 {
1249 TRACE("%u, %p\n", index, lpguid);
1250
1251 if (!lpguid) return ERROR_INVALID_PARAMETER;
1252
1253 return MsiEnumComponentsExW( szAllSid, MSIINSTALLCONTEXT_ALL, index, lpguid, NULL, NULL, NULL );
1254 }
1255
1256 UINT WINAPI MsiEnumComponentsExA( LPCSTR user_sid, DWORD ctx, DWORD index, CHAR guid[39],
1257 MSIINSTALLCONTEXT *installed_ctx, LPSTR sid, LPDWORD sid_len )
1258 {
1259 UINT r;
1260 WCHAR *user_sidW = NULL, *sidW = NULL, guidW[GUID_SIZE];
1261
1262 TRACE("%s, %u, %u, %p, %p, %p, %p\n", debugstr_a(user_sid), ctx, index, guid, installed_ctx,
1263 sid, sid_len);
1264
1265 if (sid && !sid_len) return ERROR_INVALID_PARAMETER;
1266 if (user_sid && !(user_sidW = strdupAtoW( user_sid ))) return ERROR_OUTOFMEMORY;
1267 if (sid && !(sidW = msi_alloc( *sid_len * sizeof(WCHAR) )))
1268 {
1269 msi_free( user_sidW );
1270 return ERROR_OUTOFMEMORY;
1271 }
1272 r = MsiEnumComponentsExW( user_sidW, ctx, index, guidW, installed_ctx, sidW, sid_len );
1273 if (r == ERROR_SUCCESS)
1274 {
1275 if (guid) WideCharToMultiByte( CP_ACP, 0, guidW, GUID_SIZE, guid, GUID_SIZE, NULL, NULL );
1276 if (sid) WideCharToMultiByte( CP_ACP, 0, sidW, *sid_len + 1, sid, *sid_len + 1, NULL, NULL );
1277 }
1278 msi_free( user_sidW );
1279 msi_free( sidW );
1280 return r;
1281 }
1282
1283 static UINT fetch_machine_component( DWORD ctx, DWORD index, DWORD *idx, WCHAR guid[39],
1284 MSIINSTALLCONTEXT *installed_ctx, LPWSTR sid, LPDWORD sid_len )
1285 {
1286 static const WCHAR componentsW[] =
1287 {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
1288 'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
1289 'I','n','s','t','a','l','l','e','r','\\','U','s','e','r','D','a','t','a','\\',
1290 'S','-','1','-','5','-','1','8','\\','C','o','m','p','o','n','e','n','t','s',0};
1291 UINT r = ERROR_SUCCESS;
1292 WCHAR component[SQUASHED_GUID_SIZE];
1293 DWORD i = 0, len_component;
1294 REGSAM access = KEY_ENUMERATE_SUB_KEYS | KEY_WOW64_64KEY;
1295 HKEY key_components;
1296
1297 if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, componentsW, 0, access, &key_components ))
1298 return ERROR_NO_MORE_ITEMS;
1299
1300 len_component = sizeof(component)/sizeof(component[0]);
1301 while (!RegEnumKeyExW( key_components, i, component, &len_component, NULL, NULL, NULL, NULL ))
1302 {
1303 if (*idx == index) goto found;
1304 (*idx)++;
1305 len_component = sizeof(component)/sizeof(component[0]);
1306 i++;
1307 }
1308 RegCloseKey( key_components );
1309 return ERROR_NO_MORE_ITEMS;
1310
1311 found:
1312 if (sid_len)
1313 {
1314 if (*sid_len < 1)
1315 {
1316 *sid_len = 1;
1317 r = ERROR_MORE_DATA;
1318 }
1319 else if (sid)
1320 {
1321 *sid_len = 0;
1322 sid[0] = 0;
1323 }
1324 }
1325 if (guid) unsquash_guid( component, guid );
1326 if (installed_ctx) *installed_ctx = MSIINSTALLCONTEXT_MACHINE;
1327 RegCloseKey( key_components );
1328 return r;
1329 }
1330
1331 static UINT fetch_user_component( const WCHAR *usersid, DWORD ctx, DWORD index, DWORD *idx,
1332 WCHAR guid[39], MSIINSTALLCONTEXT *installed_ctx, LPWSTR sid,
1333 LPDWORD sid_len )
1334 {
1335 static const WCHAR userdataW[] =
1336 {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
1337 'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
1338 'I','n','s','t','a','l','l','e','r','\\','U','s','e','r','D','a','t','a',0};
1339 static const WCHAR componentsW[] = {'\\','C','o','m','p','o','n','e','n','t','s',0};
1340 UINT r = ERROR_SUCCESS;
1341 WCHAR path[MAX_PATH], component[SQUASHED_GUID_SIZE], user[128];
1342 DWORD i = 0, j = 0, len_component, len_user;
1343 REGSAM access = KEY_ENUMERATE_SUB_KEYS | KEY_WOW64_64KEY;
1344 HKEY key_users, key_components;
1345
1346 if (ctx == MSIINSTALLCONTEXT_USERMANAGED) /* FIXME: where to find these? */
1347 return ERROR_NO_MORE_ITEMS;
1348
1349 if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, userdataW, 0, access, &key_users ))
1350 return ERROR_NO_MORE_ITEMS;
1351
1352 len_user = sizeof(user)/sizeof(user[0]);
1353 while (!RegEnumKeyExW( key_users, i, user, &len_user, NULL, NULL, NULL, NULL ))
1354 {
1355 if ((strcmpW( usersid, szAllSid ) && strcmpW( usersid, user )) ||
1356 !strcmpW( szLocalSid, user ))
1357 {
1358 i++;
1359 len_user = sizeof(user)/sizeof(user[0]);
1360 continue;
1361 }
1362 strcpyW( path, user );
1363 strcatW( path, componentsW );
1364 if (RegOpenKeyExW( key_users, path, 0, access, &key_components ))
1365 {
1366 i++;
1367 len_user = sizeof(user)/sizeof(user[0]);
1368 continue;
1369 }
1370 len_component = sizeof(component)/sizeof(component[0]);
1371 while (!RegEnumKeyExW( key_components, j, component, &len_component, NULL, NULL, NULL, NULL ))
1372 {
1373 if (*idx == index) goto found;
1374 (*idx)++;
1375 len_component = sizeof(component)/sizeof(component[0]);
1376 j++;
1377 }
1378 RegCloseKey( key_components );
1379 len_user = sizeof(user)/sizeof(user[0]);
1380 i++;
1381 }
1382 RegCloseKey( key_users );
1383 return ERROR_NO_MORE_ITEMS;
1384
1385 found:
1386 if (sid_len)
1387 {
1388 if (*sid_len < len_user + 1)
1389 {
1390 *sid_len = len_user + 1;
1391 r = ERROR_MORE_DATA;
1392 }
1393 else if (sid)
1394 {
1395 *sid_len = len_user;
1396 strcpyW( sid, user );
1397 }
1398 }
1399 if (guid) unsquash_guid( component, guid );
1400 if (installed_ctx) *installed_ctx = ctx;
1401 RegCloseKey( key_components );
1402 RegCloseKey( key_users );
1403 return r;
1404 }
1405
1406 static UINT enum_components( const WCHAR *usersid, DWORD ctx, DWORD index, DWORD *idx, WCHAR guid[39],
1407 MSIINSTALLCONTEXT *installed_ctx, LPWSTR sid, LPDWORD sid_len )
1408 {
1409 UINT r = ERROR_NO_MORE_ITEMS;
1410 WCHAR *user = NULL;
1411
1412 if (!usersid)
1413 {
1414 usersid = user = get_user_sid();
1415 if (!user) return ERROR_FUNCTION_FAILED;
1416 }
1417 if (ctx & MSIINSTALLCONTEXT_USERMANAGED)
1418 {
1419 r = fetch_user_component( usersid, MSIINSTALLCONTEXT_USERMANAGED, index, idx, guid,
1420 installed_ctx, sid, sid_len );
1421 if (r != ERROR_NO_MORE_ITEMS) goto done;
1422 }
1423 if (ctx & MSIINSTALLCONTEXT_USERUNMANAGED)
1424 {
1425 r = fetch_user_component( usersid, MSIINSTALLCONTEXT_USERUNMANAGED, index, idx, guid,
1426 installed_ctx, sid, sid_len );
1427 if (r != ERROR_NO_MORE_ITEMS) goto done;
1428 }
1429 if (ctx & MSIINSTALLCONTEXT_MACHINE)
1430 {
1431 r = fetch_machine_component( MSIINSTALLCONTEXT_MACHINE, index, idx, guid, installed_ctx,
1432 sid, sid_len );
1433 if (r != ERROR_NO_MORE_ITEMS) goto done;
1434 }
1435
1436 done:
1437 LocalFree( user );
1438 return r;
1439 }
1440
1441 UINT WINAPI MsiEnumComponentsExW( LPCWSTR user_sid, DWORD ctx, DWORD index, WCHAR guid[39],
1442 MSIINSTALLCONTEXT *installed_ctx, LPWSTR sid, LPDWORD sid_len )
1443 {
1444 UINT r;
1445 DWORD idx = 0;
1446 static DWORD last_index;
1447
1448 TRACE("%s, %u, %u, %p, %p, %p, %p\n", debugstr_w(user_sid), ctx, index, guid, installed_ctx,
1449 sid, sid_len);
1450
1451 if ((sid && !sid_len) || !ctx || (user_sid && ctx == MSIINSTALLCONTEXT_MACHINE))
1452 return ERROR_INVALID_PARAMETER;
1453
1454 if (index && index - last_index != 1)
1455 return ERROR_INVALID_PARAMETER;
1456
1457 if (!index) last_index = 0;
1458
1459 r = enum_components( user_sid, ctx, index, &idx, guid, installed_ctx, sid, sid_len );
1460 if (r == ERROR_SUCCESS)
1461 last_index = index;
1462 else
1463 last_index = 0;
1464
1465 return r;
1466 }
1467
1468 UINT WINAPI MsiEnumClientsA(LPCSTR szComponent, DWORD index, LPSTR szProduct)
1469 {
1470 DWORD r;
1471 WCHAR szwProduct[GUID_SIZE];
1472 LPWSTR szwComponent = NULL;
1473
1474 TRACE("%s %d %p\n", debugstr_a(szComponent), index, szProduct);
1475
1476 if ( !szProduct )
1477 return ERROR_INVALID_PARAMETER;
1478
1479 if( szComponent )
1480 {
1481 szwComponent = strdupAtoW( szComponent );
1482 if( !szwComponent )
1483 return ERROR_OUTOFMEMORY;
1484 }
1485
1486 r = MsiEnumClientsW(szComponent?szwComponent:NULL, index, szwProduct);
1487 if( r == ERROR_SUCCESS )
1488 {
1489 WideCharToMultiByte(CP_ACP, 0, szwProduct, -1,
1490 szProduct, GUID_SIZE, NULL, NULL);
1491 }
1492
1493 msi_free( szwComponent);
1494
1495 return r;
1496 }
1497
1498 UINT WINAPI MsiEnumClientsW(LPCWSTR szComponent, DWORD index, LPWSTR szProduct)
1499 {
1500 HKEY hkeyComp = 0;
1501 DWORD r, sz;
1502 WCHAR szValName[SQUASHED_GUID_SIZE];
1503
1504 TRACE("%s %d %p\n", debugstr_w(szComponent), index, szProduct);
1505
1506 if (!szComponent || !*szComponent || !szProduct)
1507 return ERROR_INVALID_PARAMETER;
1508
1509 if (MSIREG_OpenUserDataComponentKey(szComponent, NULL, &hkeyComp, FALSE) != ERROR_SUCCESS &&
1510 MSIREG_OpenUserDataComponentKey(szComponent, szLocalSid, &hkeyComp, FALSE) != ERROR_SUCCESS)
1511 return ERROR_UNKNOWN_COMPONENT;
1512
1513 /* see if there are any products at all */
1514 sz = SQUASHED_GUID_SIZE;
1515 r = RegEnumValueW(hkeyComp, 0, szValName, &sz, NULL, NULL, NULL, NULL);
1516 if (r != ERROR_SUCCESS)
1517 {
1518 RegCloseKey(hkeyComp);
1519
1520 if (index != 0)
1521 return ERROR_INVALID_PARAMETER;
1522
1523 return ERROR_UNKNOWN_COMPONENT;
1524 }
1525
1526 sz = SQUASHED_GUID_SIZE;
1527 r = RegEnumValueW(hkeyComp, index, szValName, &sz, NULL, NULL, NULL, NULL);
1528 if( r == ERROR_SUCCESS )
1529 {
1530 unsquash_guid(szValName, szProduct);
1531 TRACE("-> %s\n", debugstr_w(szProduct));
1532 }
1533 RegCloseKey(hkeyComp);
1534 return r;
1535 }
1536
1537 UINT WINAPI MsiEnumClientsExA(LPCSTR component, LPCSTR usersid, DWORD ctx, DWORD index,
1538 CHAR installed_product[GUID_SIZE],
1539 MSIINSTALLCONTEXT *installed_ctx, LPSTR sid, LPDWORD sid_len)
1540 {
1541 FIXME("%s, %s, %u, %u, %p, %p, %p, %p\n", debugstr_a(component), debugstr_a(usersid),
1542 ctx, index, installed_product, installed_ctx, sid, sid_len);
1543 return ERROR_ACCESS_DENIED;
1544 }
1545
1546 UINT WINAPI MsiEnumClientsExW(LPCWSTR component, LPCWSTR usersid, DWORD ctx, DWORD index,
1547 WCHAR installed_product[GUID_SIZE],
1548 MSIINSTALLCONTEXT *installed_ctx, LPWSTR sid, LPDWORD sid_len)
1549 {
1550 FIXME("%s, %s, %u, %u, %p, %p, %p, %p\n", debugstr_w(component), debugstr_w(usersid),
1551 ctx, index, installed_product, installed_ctx, sid, sid_len);
1552 return ERROR_ACCESS_DENIED;
1553 }
1554
1555 static UINT MSI_EnumComponentQualifiers( LPCWSTR szComponent, DWORD iIndex,
1556 awstring *lpQualBuf, LPDWORD pcchQual,
1557 awstring *lpAppBuf, LPDWORD pcchAppBuf )
1558 {
1559 DWORD name_sz, val_sz, name_max, val_max, type, ofs;
1560 LPWSTR name = NULL, val = NULL;
1561 UINT r, r2;
1562 HKEY key;
1563
1564 TRACE("%s %08x %p %p %p %p\n", debugstr_w(szComponent), iIndex,
1565 lpQualBuf, pcchQual, lpAppBuf, pcchAppBuf);
1566
1567 if (!szComponent)
1568 return ERROR_INVALID_PARAMETER;
1569
1570 r = MSIREG_OpenUserComponentsKey( szComponent, &key, FALSE );
1571 if (r != ERROR_SUCCESS)
1572 return ERROR_UNKNOWN_COMPONENT;
1573
1574 /* figure out how big the name is we want to return */
1575 name_max = 0x10;
1576 r = ERROR_OUTOFMEMORY;
1577 name = msi_alloc( name_max * sizeof(WCHAR) );
1578 if (!name)
1579 goto end;
1580
1581 val_max = 0x10;
1582 r = ERROR_OUTOFMEMORY;
1583 val = msi_alloc( val_max );
1584 if (!val)
1585 goto end;
1586
1587 /* loop until we allocate enough memory */
1588 while (1)
1589 {
1590 name_sz = name_max;
1591 val_sz = val_max;
1592 r = RegEnumValueW( key, iIndex, name, &name_sz,
1593 NULL, &type, (LPBYTE)val, &val_sz );
1594 if (r == ERROR_SUCCESS)
1595 break;
1596 if (r != ERROR_MORE_DATA)
1597 goto end;
1598
1599 if (type != REG_MULTI_SZ)
1600 {
1601 ERR("component data has wrong type (%d)\n", type);
1602 goto end;
1603 }
1604
1605 r = ERROR_OUTOFMEMORY;
1606 if (name_sz + 1 >= name_max)
1607 {
1608 name_max *= 2;
1609 msi_free( name );
1610 name = msi_alloc( name_max * sizeof (WCHAR) );
1611 if (!name)
1612 goto end;
1613 continue;
1614 }
1615 if (val_sz > val_max)
1616 {
1617 val_max = val_sz + sizeof (WCHAR);
1618 msi_free( val );
1619 val = msi_alloc( val_max * sizeof (WCHAR) );
1620 if (!val)
1621 goto end;
1622 continue;
1623 }
1624 ERR("should be enough data, but isn't %d %d\n", name_sz, val_sz );
1625 goto end;
1626 }
1627
1628 ofs = 0;
1629 r = MsiDecomposeDescriptorW( val, NULL, NULL, NULL, &ofs );
1630 if (r != ERROR_SUCCESS)
1631 goto end;
1632
1633 TRACE("Providing %s and %s\n", debugstr_w(name), debugstr_w(val+ofs));
1634
1635 r = msi_strcpy_to_awstring( name, -1, lpQualBuf, pcchQual );
1636 r2 = msi_strcpy_to_awstring( val+ofs, -1, lpAppBuf, pcchAppBuf );
1637
1638 if (r2 != ERROR_SUCCESS)
1639 r = r2;
1640
1641 end:
1642 msi_free(val);
1643 msi_free(name);
1644 RegCloseKey(key);
1645 return r;
1646 }
1647
1648 /*************************************************************************
1649 * MsiEnumComponentQualifiersA [MSI.@]
1650 */
1651 UINT WINAPI MsiEnumComponentQualifiersA( LPCSTR szComponent, DWORD iIndex,
1652 LPSTR lpQualifierBuf, LPDWORD pcchQualifierBuf,
1653 LPSTR lpApplicationDataBuf, LPDWORD pcchApplicationDataBuf )
1654 {
1655 awstring qual, appdata;
1656 LPWSTR comp;
1657 UINT r;
1658
1659 TRACE("%s %08x %p %p %p %p\n", debugstr_a(szComponent), iIndex,
1660 lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf,
1661 pcchApplicationDataBuf);
1662
1663 comp = strdupAtoW( szComponent );
1664 if (szComponent && !comp)
1665 return ERROR_OUTOFMEMORY;
1666
1667 qual.unicode = FALSE;
1668 qual.str.a = lpQualifierBuf;
1669
1670 appdata.unicode = FALSE;
1671 appdata.str.a = lpApplicationDataBuf;
1672
1673 r = MSI_EnumComponentQualifiers( comp, iIndex,
1674 &qual, pcchQualifierBuf, &appdata, pcchApplicationDataBuf );
1675 msi_free( comp );
1676 return r;
1677 }
1678
1679 /*************************************************************************
1680 * MsiEnumComponentQualifiersW [MSI.@]
1681 */
1682 UINT WINAPI MsiEnumComponentQualifiersW( LPCWSTR szComponent, DWORD iIndex,
1683 LPWSTR lpQualifierBuf, LPDWORD pcchQualifierBuf,
1684 LPWSTR lpApplicationDataBuf, LPDWORD pcchApplicationDataBuf )
1685 {
1686 awstring qual, appdata;
1687
1688 TRACE("%s %08x %p %p %p %p\n", debugstr_w(szComponent), iIndex,
1689 lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf,
1690 pcchApplicationDataBuf);
1691
1692 qual.unicode = TRUE;
1693 qual.str.w = lpQualifierBuf;
1694
1695 appdata.unicode = TRUE;
1696 appdata.str.w = lpApplicationDataBuf;
1697
1698 return MSI_EnumComponentQualifiers( szComponent, iIndex,
1699 &qual, pcchQualifierBuf, &appdata, pcchApplicationDataBuf );
1700 }
1701
1702 /*************************************************************************
1703 * MsiEnumRelatedProductsW [MSI.@]
1704 *
1705 */
1706 UINT WINAPI MsiEnumRelatedProductsW(LPCWSTR szUpgradeCode, DWORD dwReserved,
1707 DWORD iProductIndex, LPWSTR lpProductBuf)
1708 {
1709 UINT r;
1710 HKEY hkey;
1711 WCHAR szKeyName[SQUASHED_GUID_SIZE];
1712 DWORD dwSize = sizeof(szKeyName)/sizeof(szKeyName[0]);
1713
1714 TRACE("%s %u %u %p\n", debugstr_w(szUpgradeCode), dwReserved,
1715 iProductIndex, lpProductBuf);
1716
1717 if (NULL == szUpgradeCode)
1718 return ERROR_INVALID_PARAMETER;
1719 if (NULL == lpProductBuf)
1720 return ERROR_INVALID_PARAMETER;
1721
1722 r = MSIREG_OpenUpgradeCodesKey(szUpgradeCode, &hkey, FALSE);
1723 if (r != ERROR_SUCCESS)
1724 return ERROR_NO_MORE_ITEMS;
1725
1726 r = RegEnumValueW(hkey, iProductIndex, szKeyName, &dwSize, NULL, NULL, NULL, NULL);
1727 if( r == ERROR_SUCCESS )
1728 unsquash_guid(szKeyName, lpProductBuf);
1729 RegCloseKey(hkey);
1730
1731 return r;
1732 }
1733
1734 /*************************************************************************
1735 * MsiEnumRelatedProductsA [MSI.@]
1736 *
1737 */
1738 UINT WINAPI MsiEnumRelatedProductsA(LPCSTR szUpgradeCode, DWORD dwReserved,
1739 DWORD iProductIndex, LPSTR lpProductBuf)
1740 {
1741 LPWSTR szwUpgradeCode = NULL;
1742 WCHAR productW[GUID_SIZE];
1743 UINT r;
1744
1745 TRACE("%s %u %u %p\n", debugstr_a(szUpgradeCode), dwReserved,
1746 iProductIndex, lpProductBuf);
1747
1748 if (szUpgradeCode)
1749 {
1750 szwUpgradeCode = strdupAtoW( szUpgradeCode );
1751 if( !szwUpgradeCode )
1752 return ERROR_OUTOFMEMORY;
1753 }
1754
1755 r = MsiEnumRelatedProductsW( szwUpgradeCode, dwReserved,
1756 iProductIndex, productW );
1757 if (r == ERROR_SUCCESS)
1758 {
1759 WideCharToMultiByte( CP_ACP, 0, productW, GUID_SIZE,
1760 lpProductBuf, GUID_SIZE, NULL, NULL );
1761 }
1762 msi_free( szwUpgradeCode);
1763 return r;
1764 }
1765
1766 /***********************************************************************
1767 * MsiEnumPatchesExA [MSI.@]
1768 */
1769 UINT WINAPI MsiEnumPatchesExA(LPCSTR szProductCode, LPCSTR szUserSid,
1770 DWORD dwContext, DWORD dwFilter, DWORD dwIndex, LPSTR szPatchCode,
1771 LPSTR szTargetProductCode, MSIINSTALLCONTEXT *pdwTargetProductContext,
1772 LPSTR szTargetUserSid, LPDWORD pcchTargetUserSid)
1773 {
1774 LPWSTR prodcode = NULL;
1775 LPWSTR usersid = NULL;
1776 LPWSTR targsid = NULL;
1777 WCHAR patch[GUID_SIZE];
1778 WCHAR targprod[GUID_SIZE];
1779 DWORD len;
1780 UINT r;
1781
1782 TRACE("(%s, %s, %d, %d, %d, %p, %p, %p, %p, %p)\n",
1783 debugstr_a(szProductCode), debugstr_a(szUserSid), dwContext, dwFilter,
1784 dwIndex, szPatchCode, szTargetProductCode, pdwTargetProductContext,
1785 szTargetUserSid, pcchTargetUserSid);
1786
1787 if (szTargetUserSid && !pcchTargetUserSid)
1788 return ERROR_INVALID_PARAMETER;
1789
1790 if (szProductCode) prodcode = strdupAtoW(szProductCode);
1791 if (szUserSid) usersid = strdupAtoW(szUserSid);
1792
1793 r = MsiEnumPatchesExW(prodcode, usersid, dwContext, dwFilter, dwIndex,
1794 patch, targprod, pdwTargetProductContext,
1795 NULL, &len);
1796 if (r != ERROR_SUCCESS)
1797 goto done;
1798
1799 WideCharToMultiByte(CP_ACP, 0, patch, -1, szPatchCode,
1800 GUID_SIZE, NULL, NULL);
1801 WideCharToMultiByte(CP_ACP, 0, targprod, -1, szTargetProductCode,
1802 GUID_SIZE, NULL, NULL);
1803
1804 if (!szTargetUserSid)
1805 {
1806 if (pcchTargetUserSid)
1807 *pcchTargetUserSid = len;
1808
1809 goto done;
1810 }
1811
1812 targsid = msi_alloc(++len * sizeof(WCHAR));
1813 if (!targsid)
1814 {
1815 r = ERROR_OUTOFMEMORY;
1816 goto done;
1817 }
1818
1819 r = MsiEnumPatchesExW(prodcode, usersid, dwContext, dwFilter, dwIndex,
1820 patch, targprod, pdwTargetProductContext,
1821 targsid, &len);
1822 if (r != ERROR_SUCCESS || !szTargetUserSid)
1823 goto done;
1824
1825 WideCharToMultiByte(CP_ACP, 0, targsid, -1, szTargetUserSid,
1826 *pcchTargetUserSid, NULL, NULL);
1827
1828 len = lstrlenW(targsid);
1829 if (*pcchTargetUserSid < len + 1)
1830 {
1831 r = ERROR_MORE_DATA;
1832 *pcchTargetUserSid = len * sizeof(WCHAR);
1833 }
1834 else
1835 *pcchTargetUserSid = len;
1836
1837 done:
1838 msi_free(prodcode);
1839 msi_free(usersid);
1840 msi_free(targsid);
1841
1842 return r;
1843 }
1844
1845 static UINT msi_get_patch_state(LPCWSTR prodcode, LPCWSTR usersid,
1846 MSIINSTALLCONTEXT context,
1847 LPWSTR patch, MSIPATCHSTATE *state)
1848 {
1849 DWORD type, val, size;
1850 HKEY prod, hkey = 0;
1851 HKEY udpatch = 0;
1852 LONG res;
1853 UINT r = ERROR_NO_MORE_ITEMS;
1854
1855 *state = MSIPATCHSTATE_INVALID;
1856
1857 r = MSIREG_OpenUserDataProductKey(prodcode, context,
1858 usersid, &prod, FALSE);
1859 if (r != ERROR_SUCCESS)
1860 return ERROR_NO_MORE_ITEMS;
1861
1862 res = RegOpenKeyExW(prod, szPatches, 0, KEY_READ, &hkey);
1863 if (res != ERROR_SUCCESS)
1864 goto done;
1865
1866 res = RegOpenKeyExW(hkey, patch, 0, KEY_READ, &udpatch);
1867 if (res != ERROR_SUCCESS)
1868 goto done;
1869
1870 size = sizeof(DWORD);
1871 res = RegGetValueW(udpatch, NULL, szState, RRF_RT_DWORD, &type, &val, &size);
1872 if (res != ERROR_SUCCESS ||
1873 val < MSIPATCHSTATE_APPLIED || val > MSIPATCHSTATE_REGISTERED)
1874 {
1875 r = ERROR_BAD_CONFIGURATION;
1876 goto done;
1877 }
1878
1879 *state = val;
1880 r = ERROR_SUCCESS;
1881
1882 done:
1883 RegCloseKey(udpatch);
1884 RegCloseKey(hkey);
1885 RegCloseKey(prod);
1886
1887 return r;
1888 }
1889
1890 static UINT msi_check_product_patches(LPCWSTR prodcode, LPCWSTR usersid,
1891 MSIINSTALLCONTEXT context, DWORD filter, DWORD index, DWORD *idx,
1892 LPWSTR patch, LPWSTR targetprod, MSIINSTALLCONTEXT *targetctx,
1893 LPWSTR targetsid, DWORD *sidsize, LPWSTR *transforms)
1894 {
1895 MSIPATCHSTATE state = MSIPATCHSTATE_INVALID;
1896 LPWSTR ptr, patches = NULL;
1897 HKEY prod, patchkey = 0;
1898 HKEY localprod = 0, localpatch = 0;
1899 DWORD type, size;
1900 LONG res;
1901 UINT temp, r = ERROR_NO_MORE_ITEMS;
1902
1903 if (MSIREG_OpenProductKey(prodcode, usersid, context,
1904 &prod, FALSE) != ERROR_SUCCESS)
1905 return ERROR_NO_MORE_ITEMS;
1906
1907 size = 0;
1908 res = RegGetValueW(prod, szPatches, szPatches, RRF_RT_ANY, &type, NULL,
1909 &size);
1910 if (res != ERROR_SUCCESS)
1911 goto done;
1912
1913 if (type != REG_MULTI_SZ)
1914 {
1915 r = ERROR_BAD_CONFIGURATION;
1916 goto done;
1917 }
1918
1919 patches = msi_alloc(size);
1920 if (!patches)
1921 {
1922 r = ERROR_OUTOFMEMORY;
1923 goto done;
1924 }
1925
1926 res = RegGetValueW(prod, szPatches, szPatches, RRF_RT_ANY, &type,
1927 patches, &size);
1928 if (res != ERROR_SUCCESS)
1929 goto done;
1930
1931 for (ptr = patches; *ptr && r == ERROR_NO_MORE_ITEMS; ptr += lstrlenW(ptr) + 1)
1932 {
1933 if (!unsquash_guid(ptr, patch))
1934 {
1935 r = ERROR_BAD_CONFIGURATION;
1936 goto done;
1937 }
1938
1939 size = 0;
1940 res = RegGetValueW(prod, szPatches, ptr, RRF_RT_REG_SZ,
1941 &type, NULL, &size);
1942 if (res != ERROR_SUCCESS)
1943 continue;
1944
1945 if (transforms)
1946 {
1947 *transforms = msi_alloc(size);
1948 if (!*transforms)
1949 {
1950 r = ERROR_OUTOFMEMORY;
1951 goto done;
1952 }
1953
1954 res = RegGetValueW(prod, szPatches, ptr, RRF_RT_REG_SZ,
1955 &type, *transforms, &size);
1956 if (res != ERROR_SUCCESS)
1957 continue;
1958 }
1959
1960 if (context == MSIINSTALLCONTEXT_USERMANAGED)
1961 {
1962 if (!(filter & MSIPATCHSTATE_APPLIED))
1963 {
1964 temp = msi_get_patch_state(prodcode, usersid, context,
1965 ptr, &state);
1966 if (temp == ERROR_BAD_CONFIGURATION)
1967 {
1968 r = ERROR_BAD_CONFIGURATION;
1969 goto done;
1970 }
1971
1972 if (temp != ERROR_SUCCESS || !(filter & state))
1973 continue;
1974 }
1975 }
1976 else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
1977 {
1978 if (!(filter & MSIPATCHSTATE_APPLIED))
1979 {
1980 temp = msi_get_patch_state(prodcode, usersid, context,
1981 ptr, &state);
1982 if (temp == ERROR_BAD_CONFIGURATION)
1983 {
1984 r = ERROR_BAD_CONFIGURATION;
1985 goto done;
1986 }
1987
1988 if (temp != ERROR_SUCCESS || !(filter & state))
1989 continue;
1990 }
1991 else
1992 {
1993 temp = MSIREG_OpenUserDataPatchKey(patch, context,
1994 &patchkey, FALSE);
1995 RegCloseKey(patchkey);
1996 if (temp != ERROR_SUCCESS)
1997 continue;
1998 }
1999 }
2000 else if (context == MSIINSTALLCONTEXT_MACHINE)
2001 {
2002 usersid = szEmpty;
2003
2004 if (MSIREG_OpenUserDataProductKey(prodcode, context, NULL, &localprod, FALSE) == ERROR_SUCCESS &&
2005 RegOpenKeyExW(localprod, szPatches, 0, KEY_READ, &localpatch) == ERROR_SUCCESS &&
2006 RegOpenKeyExW(localpatch, ptr, 0, KEY_READ, &patchkey) == ERROR_SUCCESS)
2007 {
2008 res = RegGetValueW(patchkey, NULL, szState, RRF_RT_REG_DWORD,
2009 &type, &state, &size);
2010
2011 if (!(filter & state))
2012 res = ERROR_NO_MORE_ITEMS;
2013
2014 RegCloseKey(patchkey);
2015 }
2016
2017 RegCloseKey(localpatch);
2018 RegCloseKey(localprod);
2019
2020 if (res != ERROR_SUCCESS)
2021 continue;
2022 }
2023
2024 if (*idx < index)
2025 {
2026 (*idx)++;
2027 continue;
2028 }
2029
2030 r = ERROR_SUCCESS;
2031 if (targetprod)
2032 lstrcpyW(targetprod, prodcode);
2033
2034 if (targetctx)
2035 *targetctx = context;
2036
2037 if (targetsid)
2038 {
2039 lstrcpynW(targetsid, usersid, *sidsize);
2040 if (lstrlenW(usersid) >= *sidsize)
2041 r = ERROR_MORE_DATA;
2042 }
2043
2044 if (sidsize)
2045 {
2046 *sidsize = lstrlenW(usersid);
2047 if (!targetsid)
2048 *sidsize *= sizeof(WCHAR);
2049 }
2050 }
2051
2052 done:
2053 RegCloseKey(prod);
2054 msi_free(patches);
2055
2056 return r;
2057 }
2058
2059 static UINT msi_enum_patches(LPCWSTR szProductCode, LPCWSTR szUserSid,
2060 DWORD dwContext, DWORD dwFilter, DWORD dwIndex, DWORD *idx,
2061 LPWSTR szPatchCode, LPWSTR szTargetProductCode,
2062 MSIINSTALLCONTEXT *pdwTargetProductContext, LPWSTR szTargetUserSid,
2063 LPDWORD pcchTargetUserSid, LPWSTR *szTransforms)
2064 {
2065 LPWSTR usersid = NULL;
2066 UINT r = ERROR_INVALID_PARAMETER;
2067
2068 if (!szUserSid)
2069 {
2070 szUserSid = usersid = get_user_sid();
2071 if (!usersid) return ERROR_FUNCTION_FAILED;
2072 }
2073
2074 if (dwContext & MSIINSTALLCONTEXT_USERMANAGED)
2075 {
2076 r = msi_check_product_patches(szProductCode, szUserSid,
2077 MSIINSTALLCONTEXT_USERMANAGED, dwFilter,
2078 dwIndex, idx, szPatchCode,
2079 szTargetProductCode,
2080 pdwTargetProductContext, szTargetUserSid,
2081 pcchTargetUserSid, szTransforms);
2082 if (r != ERROR_NO_MORE_ITEMS)
2083 goto done;
2084 }
2085
2086 if (dwContext & MSIINSTALLCONTEXT_USERUNMANAGED)
2087 {
2088 r = msi_check_product_patches(szProductCode, szUserSid,
2089 MSIINSTALLCONTEXT_USERUNMANAGED, dwFilter,
2090 dwIndex, idx, szPatchCode,
2091 szTargetProductCode,
2092 pdwTargetProductContext, szTargetUserSid,
2093 pcchTargetUserSid, szTransforms);
2094 if (r != ERROR_NO_MORE_ITEMS)
2095 goto done;
2096 }
2097
2098 if (dwContext & MSIINSTALLCONTEXT_MACHINE)
2099 {
2100 r = msi_check_product_patches(szProductCode, szUserSid,
2101 MSIINSTALLCONTEXT_MACHINE, dwFilter,
2102 dwIndex, idx, szPatchCode,
2103 szTargetProductCode,
2104 pdwTargetProductContext, szTargetUserSid,
2105 pcchTargetUserSid, szTransforms);
2106 if (r != ERROR_NO_MORE_ITEMS)
2107 goto done;
2108 }
2109
2110 done:
2111 LocalFree(usersid);
2112 return r;
2113 }
2114
2115 /***********************************************************************
2116 * MsiEnumPatchesExW [MSI.@]
2117 */
2118 UINT WINAPI MsiEnumPatchesExW(LPCWSTR szProductCode, LPCWSTR szUserSid,
2119 DWORD dwContext, DWORD dwFilter, DWORD dwIndex, LPWSTR szPatchCode,
2120 LPWSTR szTargetProductCode, MSIINSTALLCONTEXT *pdwTargetProductContext,
2121 LPWSTR szTargetUserSid, LPDWORD pcchTargetUserSid)
2122 {
2123 WCHAR squashed_pc[SQUASHED_GUID_SIZE];
2124 DWORD idx = 0;
2125 UINT r;
2126
2127 static DWORD last_index;
2128
2129 TRACE("(%s, %s, %d, %d, %d, %p, %p, %p, %p, %p)\n",
2130 debugstr_w(szProductCode), debugstr_w(szUserSid), dwContext, dwFilter,
2131 dwIndex, szPatchCode, szTargetProductCode, pdwTargetProductContext,
2132 szTargetUserSid, pcchTargetUserSid);
2133
2134 if (!szProductCode || !squash_guid( szProductCode, squashed_pc ))
2135 return ERROR_INVALID_PARAMETER;
2136
2137 if (szUserSid && !strcmpW( szUserSid, szLocalSid ))
2138 return ERROR_INVALID_PARAMETER;
2139
2140 if (dwContext & MSIINSTALLCONTEXT_MACHINE && szUserSid)
2141 return ERROR_INVALID_PARAMETER;
2142
2143 if (dwContext <= MSIINSTALLCONTEXT_NONE ||
2144 dwContext > MSIINSTALLCONTEXT_ALL)
2145 return ERROR_INVALID_PARAMETER;
2146
2147 if (dwFilter <= MSIPATCHSTATE_INVALID || dwFilter > MSIPATCHSTATE_ALL)
2148 return ERROR_INVALID_PARAMETER;
2149
2150 if (dwIndex && dwIndex - last_index != 1)
2151 return ERROR_INVALID_PARAMETER;
2152
2153 if (dwIndex == 0)
2154 last_index = 0;
2155
2156 r = msi_enum_patches(szProductCode, szUserSid, dwContext, dwFilter,
2157 dwIndex, &idx, szPatchCode, szTargetProductCode,
2158 pdwTargetProductContext, szTargetUserSid,
2159 pcchTargetUserSid, NULL);
2160
2161 if (r == ERROR_SUCCESS)
2162 last_index = dwIndex;
2163 else
2164 last_index = 0;
2165
2166 return r;
2167 }
2168
2169 /***********************************************************************
2170 * MsiEnumPatchesA [MSI.@]
2171 */
2172 UINT WINAPI MsiEnumPatchesA(LPCSTR szProduct, DWORD iPatchIndex,
2173 LPSTR lpPatchBuf, LPSTR lpTransformsBuf, LPDWORD pcchTransformsBuf)
2174 {
2175 LPWSTR product, transforms;
2176 WCHAR patch[GUID_SIZE];
2177 DWORD len;
2178 UINT r;
2179
2180 TRACE("(%s %d %p %p %p)\n", debugstr_a(szProduct), iPatchIndex,
2181 lpPatchBuf, lpTransformsBuf, pcchTransformsBuf);
2182
2183 if (!szProduct || !lpPatchBuf || !lpTransformsBuf || !pcchTransformsBuf)
2184 return ERROR_INVALID_PARAMETER;
2185
2186 product = strdupAtoW(szProduct);
2187 if (!product)
2188 return ERROR_OUTOFMEMORY;
2189
2190 len = *pcchTransformsBuf;
2191 transforms = msi_alloc( len * sizeof(WCHAR) );
2192 if (!transforms)
2193 {
2194 r = ERROR_OUTOFMEMORY;
2195 goto done;
2196 }
2197
2198 r = MsiEnumPatchesW(product, iPatchIndex, patch, transforms, &len);
2199 if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
2200 goto done;
2201
2202 WideCharToMultiByte(CP_ACP, 0, patch, -1, lpPatchBuf,
2203 GUID_SIZE, NULL, NULL);
2204
2205 if (!WideCharToMultiByte(CP_ACP, 0, transforms, -1, lpTransformsBuf,
2206 *pcchTransformsBuf, NULL, NULL))
2207 r = ERROR_MORE_DATA;
2208
2209 if (r == ERROR_MORE_DATA)
2210 {
2211 lpTransformsBuf[*pcchTransformsBuf - 1] = '\0';
2212 *pcchTransformsBuf = len * 2;
2213 }
2214 else
2215 *pcchTransformsBuf = strlen( lpTransformsBuf );
2216
2217 done:
2218 msi_free(transforms);
2219 msi_free(product);
2220
2221 return r;
2222 }
2223
2224 /***********************************************************************
2225 * MsiEnumPatchesW [MSI.@]
2226 */
2227 UINT WINAPI MsiEnumPatchesW(LPCWSTR szProduct, DWORD iPatchIndex,
2228 LPWSTR lpPatchBuf, LPWSTR lpTransformsBuf, LPDWORD pcchTransformsBuf)
2229 {
2230 WCHAR *transforms = NULL, squashed_pc[SQUASHED_GUID_SIZE];
2231 HKEY prod;
2232 DWORD idx = 0;
2233 UINT r;
2234
2235 TRACE("(%s %d %p %p %p)\n", debugstr_w(szProduct), iPatchIndex,
2236 lpPatchBuf, lpTransformsBuf, pcchTransformsBuf);
2237
2238 if (!szProduct || !squash_guid( szProduct, squashed_pc ))
2239 return ERROR_INVALID_PARAMETER;
2240
2241 if (!lpPatchBuf || !lpTransformsBuf || !pcchTransformsBuf)
2242 return ERROR_INVALID_PARAMETER;
2243
2244 if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
2245 &prod, FALSE) != ERROR_SUCCESS &&
2246 MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
2247 &prod, FALSE) != ERROR_SUCCESS &&
2248 MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
2249 &prod, FALSE) != ERROR_SUCCESS)
2250 return ERROR_UNKNOWN_PRODUCT;
2251
2252 RegCloseKey(prod);
2253
2254 r = msi_enum_patches(szProduct, NULL, MSIINSTALLCONTEXT_ALL,
2255 MSIPATCHSTATE_ALL, iPatchIndex, &idx, lpPatchBuf,
2256 NULL, NULL, NULL, NULL, &transforms);
2257 if (r != ERROR_SUCCESS)
2258 goto done;
2259
2260 lstrcpynW(lpTransformsBuf, transforms, *pcchTransformsBuf);
2261 if (*pcchTransformsBuf <= lstrlenW(transforms))
2262 {
2263 r = ERROR_MORE_DATA;
2264 *pcchTransformsBuf = lstrlenW(transforms);
2265 }
2266 else
2267 *pcchTransformsBuf = lstrlenW(transforms);
2268
2269 done:
2270 msi_free(transforms);
2271 return r;
2272 }
2273
2274 UINT WINAPI MsiEnumProductsExA( LPCSTR product, LPCSTR usersid, DWORD ctx, DWORD index,
2275 CHAR installed_product[GUID_SIZE],
2276 MSIINSTALLCONTEXT *installed_ctx, LPSTR sid, LPDWORD sid_len )
2277 {
2278 UINT r;
2279 WCHAR installed_productW[GUID_SIZE], *productW = NULL, *usersidW = NULL, *sidW = NULL;
2280
2281 TRACE("%s, %s, %u, %u, %p, %p, %p, %p\n", debugstr_a(product), debugstr_a(usersid),
2282 ctx, index, installed_product, installed_ctx, sid, sid_len);
2283
2284 if (sid && !sid_len) return ERROR_INVALID_PARAMETER;
2285 if (product && !(productW = strdupAtoW( product ))) return ERROR_OUTOFMEMORY;
2286 if (usersid && !(usersidW = strdupAtoW( usersid )))
2287 {
2288 msi_free( productW );
2289 return ERROR_OUTOFMEMORY;
2290 }
2291 if (sid && !(sidW = msi_alloc( *sid_len * sizeof(WCHAR) )))
2292 {
2293 msi_free( usersidW );
2294 msi_free( productW );
2295 return ERROR_OUTOFMEMORY;
2296 }
2297 r = MsiEnumProductsExW( productW, usersidW, ctx, index, installed_productW,
2298 installed_ctx, sidW, sid_len );
2299 if (r == ERROR_SUCCESS)
2300 {
2301 if (installed_product) WideCharToMultiByte( CP_ACP, 0, installed_productW, GUID_SIZE,
2302 installed_product, GUID_SIZE, NULL, NULL );
2303 if (sid) WideCharToMultiByte( CP_ACP, 0, sidW, *sid_len + 1, sid, *sid_len + 1, NULL, NULL );
2304 }
2305 msi_free( productW );
2306 msi_free( usersidW );
2307 msi_free( sidW );
2308 return r;
2309 }
2310
2311 static UINT fetch_machine_product( const WCHAR *match, DWORD index, DWORD *idx,
2312 WCHAR installed_product[GUID_SIZE],
2313 MSIINSTALLCONTEXT *installed_ctx, WCHAR *sid, DWORD *sid_len )
2314 {
2315 static const WCHAR productsW[] =
2316 {'S','o','f','t','w','a','r','e','\\','C','l','a','s','s','e','s','\\',
2317 'I','n','s','t','a','l','l','e','r','\\','P','r','o','d','u','c','t','s',0};
2318 UINT r;
2319 WCHAR product[SQUASHED_GUID_SIZE];
2320 DWORD i = 0, len;
2321 REGSAM access = KEY_ENUMERATE_SUB_KEYS | KEY_WOW64_64KEY;
2322 HKEY key;
2323
2324 if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, productsW, 0, access, &key ))
2325 return ERROR_NO_MORE_ITEMS;
2326
2327 len = sizeof(product)/sizeof(product[0]);
2328 while (!RegEnumKeyExW( key, i, product, &len, NULL, NULL, NULL, NULL ))
2329 {
2330 if (match && strcmpW( match, product ))
2331 {
2332 i++;
2333 len = sizeof(product)/sizeof(product[0]);
2334 continue;
2335 }
2336 if (*idx == index) goto found;
2337 (*idx)++;
2338 len = sizeof(product)/sizeof(product[0]);
2339 i++;
2340 }
2341 RegCloseKey( key );
2342 return ERROR_NO_MORE_ITEMS;
2343
2344 found:
2345 if (sid_len && *sid_len < 1)
2346 {
2347 *sid_len = 1;
2348 r = ERROR_MORE_DATA;
2349 }
2350 else
2351 {
2352 if (installed_product) unsquash_guid( product, installed_product );
2353 if (installed_ctx) *installed_ctx = MSIINSTALLCONTEXT_MACHINE;
2354 if (sid)
2355 {
2356 sid[0] = 0;
2357 *sid_len = 0;
2358 }
2359 r = ERROR_SUCCESS;
2360 }
2361 RegCloseKey( key );
2362 return r;
2363 }
2364
2365 static UINT fetch_user_product( const WCHAR *match, const WCHAR *usersid, DWORD ctx, DWORD index,
2366 DWORD *idx, WCHAR installed_product[GUID_SIZE],
2367 MSIINSTALLCONTEXT *installed_ctx, WCHAR *sid, DWORD *sid_len )
2368 {
2369 static const WCHAR managedW[] =
2370 {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
2371 'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s',
2372 'i','o','n','\\','I','n','s','t','a','l','l','e','r','\\','M','a','n','a','g','e','d',0};
2373 static const WCHAR managed_productsW[] =
2374 {'\\','I','n','s','t','a','l','l','e','r','\\','P','r','o','d','u','c','t','s',0};
2375 static const WCHAR unmanaged_productsW[] =
2376 {'\\','S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
2377 'I','n','s','t','a','l','l','e','r','\\','P','r','o','d','u','c','t','s',0};
2378 UINT r;
2379 const WCHAR *subkey;
2380 WCHAR path[MAX_PATH], product[SQUASHED_GUID_SIZE], user[128];
2381 DWORD i = 0, j = 0, len_product, len_user;
2382 REGSAM access = KEY_ENUMERATE_SUB_KEYS | KEY_WOW64_64KEY;
2383 HKEY key_users, key_products;
2384
2385 if (ctx == MSIINSTALLCONTEXT_USERMANAGED)
2386 {
2387 subkey = managed_productsW;
2388 if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, managedW, 0, access, &key_users ))
2389 return ERROR_NO_MORE_ITEMS;
2390 }
2391 else if (ctx == MSIINSTALLCONTEXT_USERUNMANAGED)
2392 {
2393 subkey = unmanaged_productsW;
2394 if (RegOpenKeyExW( HKEY_USERS, NULL, 0, access, &key_users ))
2395 return ERROR_NO_MORE_ITEMS;
2396 }
2397 else return ERROR_INVALID_PARAMETER;
2398
2399 len_user = sizeof(user)/sizeof(user[0]);
2400 while (!RegEnumKeyExW( key_users, i, user, &len_user, NULL, NULL, NULL, NULL ))
2401 {
2402 if (strcmpW( usersid, user ) && strcmpW( usersid, szAllSid ))
2403 {
2404 i++;
2405 len_user = sizeof(user)/sizeof(user[0]);
2406 continue;
2407 }
2408 strcpyW( path, user );
2409 strcatW( path, subkey );
2410 if (RegOpenKeyExW( key_users, path, 0, access, &key_products ))
2411 {
2412 i++;
2413 len_user = sizeof(user)/sizeof(user[0]);
2414 continue;
2415 }
2416 len_product = sizeof(product)/sizeof(product[0]);
2417 while (!RegEnumKeyExW( key_products, j, product, &len_product, NULL, NULL, NULL, NULL ))
2418 {
2419 if (match && strcmpW( match, product ))
2420 {
2421 j++;
2422 len_product = sizeof(product)/sizeof(product[0]);
2423 continue;
2424 }
2425 if (*idx == index) goto found;
2426 (*idx)++;
2427 len_product = sizeof(product)/sizeof(product[0]);
2428 j++;
2429 }
2430 RegCloseKey( key_products );
2431 len_user = sizeof(user)/sizeof(user[0]);
2432 i++;
2433 }
2434 RegCloseKey( key_users );
2435 return ERROR_NO_MORE_ITEMS;
2436
2437 found:
2438 if (sid_len && *sid_len <= len_user)
2439 {
2440 *sid_len = len_user;
2441 r = ERROR_MORE_DATA;
2442 }
2443 else
2444 {
2445 if (installed_product) unsquash_guid( product, installed_product );
2446 if (installed_ctx) *installed_ctx = ctx;
2447 if (sid)
2448 {
2449 strcpyW( sid, user );
2450 *sid_len = len_user;
2451 }
2452 r = ERROR_SUCCESS;
2453 }
2454 RegCloseKey( key_products );
2455 RegCloseKey( key_users );
2456 return r;
2457 }
2458
2459 static UINT enum_products( const WCHAR *product, const WCHAR *usersid, DWORD ctx, DWORD index,
2460 DWORD *idx, WCHAR installed_product[GUID_SIZE],
2461 MSIINSTALLCONTEXT *installed_ctx, WCHAR *sid, DWORD *sid_len )
2462 {
2463 UINT r = ERROR_NO_MORE_ITEMS;
2464 WCHAR *user = NULL;
2465
2466 if (!usersid)
2467 {
2468 usersid = user = get_user_sid();
2469 if (!user) return ERROR_FUNCTION_FAILED;
2470 }
2471 if (ctx & MSIINSTALLCONTEXT_MACHINE)
2472 {
2473 r = fetch_machine_product( product, index, idx, installed_product, installed_ctx,
2474 sid, sid_len );
2475 if (r != ERROR_NO_MORE_ITEMS) goto done;
2476 }
2477 if (ctx & MSIINSTALLCONTEXT_USERUNMANAGED)
2478 {
2479 r = fetch_user_product( product, usersid, MSIINSTALLCONTEXT_USERUNMANAGED, index,
2480 idx, installed_product, installed_ctx, sid, sid_len );
2481 if (r != ERROR_NO_MORE_ITEMS) goto done;
2482 }
2483 if (ctx & MSIINSTALLCONTEXT_USERMANAGED)
2484 {
2485 r = fetch_user_product( product, usersid, MSIINSTALLCONTEXT_USERMANAGED, index,
2486 idx, installed_product, installed_ctx, sid, sid_len );
2487 if (r != ERROR_NO_MORE_ITEMS) goto done;
2488 }
2489
2490 done:
2491 LocalFree( user );
2492 return r;
2493 }
2494
2495 UINT WINAPI MsiEnumProductsExW( LPCWSTR product, LPCWSTR usersid, DWORD ctx, DWORD index,
2496 WCHAR installed_product[GUID_SIZE],
2497 MSIINSTALLCONTEXT *installed_ctx, LPWSTR sid, LPDWORD sid_len )
2498 {
2499 UINT r;
2500 DWORD idx = 0;
2501 static DWORD last_index;
2502
2503 TRACE("%s, %s, %u, %u, %p, %p, %p, %p\n", debugstr_w(product), debugstr_w(usersid),
2504 ctx, index, installed_product, installed_ctx, sid, sid_len);
2505
2506 if ((sid && !sid_len) || !ctx || (usersid && ctx == MSIINSTALLCONTEXT_MACHINE))
2507 return ERROR_INVALID_PARAMETER;
2508
2509 if (index && index - last_index != 1)
2510 return ERROR_INVALID_PARAMETER;
2511
2512 if (!index) last_index = 0;
2513
2514 r = enum_products( product, usersid, ctx, index, &idx, installed_product, installed_ctx,
2515 sid, sid_len );
2516 if (r == ERROR_SUCCESS)
2517 last_index = index;
2518 else
2519 last_index = 0;
2520
2521 return r;
2522 }
Windows API implementation