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