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