-sync msi with wine 1.1.32
[reactos.git] / reactos / dll / win32 / msi / source.c
1 /*
2 * Implementation of the Microsoft Installer (msi.dll)
3 *
4 * Copyright 2005 Aric Stewart for CodeWeavers
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdarg.h>
22
23 #define COBJMACROS
24 #define NONAMELESSUNION
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winreg.h"
29 #include "winnls.h"
30 #include "shlwapi.h"
31 #include "wine/debug.h"
32 #include "msi.h"
33 #include "msiquery.h"
34 #include "msipriv.h"
35 #include "wincrypt.h"
36 #include "winver.h"
37 #include "winuser.h"
38 #include "wine/unicode.h"
39 #include "sddl.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(msi);
42
43 /*
44 * These apis are defined in MSI 3.0
45 */
46
47 typedef struct tagMediaInfo
48 {
49 struct list entry;
50 LPWSTR path;
51 WCHAR szIndex[10];
52 DWORD index;
53 } media_info;
54
55 static UINT OpenSourceKey(LPCWSTR szProduct, HKEY* key, DWORD dwOptions,
56 MSIINSTALLCONTEXT context, BOOL create)
57 {
58 HKEY rootkey = 0;
59 UINT rc = ERROR_FUNCTION_FAILED;
60
61 if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
62 {
63 if (dwOptions & MSICODE_PATCH)
64 rc = MSIREG_OpenUserPatchesKey(szProduct, &rootkey, create);
65 else
66 rc = MSIREG_OpenProductKey(szProduct, NULL, context,
67 &rootkey, create);
68 }
69 else if (context == MSIINSTALLCONTEXT_USERMANAGED)
70 {
71 if (dwOptions & MSICODE_PATCH)
72 rc = MSIREG_OpenUserPatchesKey(szProduct, &rootkey, create);
73 else
74 rc = MSIREG_OpenProductKey(szProduct, NULL, context,
75 &rootkey, create);
76 }
77 else if (context == MSIINSTALLCONTEXT_MACHINE)
78 {
79 if (dwOptions & MSICODE_PATCH)
80 rc = MSIREG_OpenPatchesKey(szProduct, &rootkey, create);
81 else
82 rc = MSIREG_OpenProductKey(szProduct, NULL, context,
83 &rootkey, create);
84 }
85
86 if (rc != ERROR_SUCCESS)
87 {
88 if (dwOptions & MSICODE_PATCH)
89 return ERROR_UNKNOWN_PATCH;
90 else
91 return ERROR_UNKNOWN_PRODUCT;
92 }
93
94 if (create)
95 rc = RegCreateKeyW(rootkey, szSourceList, key);
96 else
97 {
98 rc = RegOpenKeyW(rootkey,szSourceList, key);
99 if (rc != ERROR_SUCCESS)
100 rc = ERROR_BAD_CONFIGURATION;
101 }
102
103 return rc;
104 }
105
106 static UINT OpenMediaSubkey(HKEY rootkey, HKEY *key, BOOL create)
107 {
108 UINT rc;
109 static const WCHAR media[] = {'M','e','d','i','a',0};
110
111 if (create)
112 rc = RegCreateKeyW(rootkey, media, key);
113 else
114 rc = RegOpenKeyW(rootkey,media, key);
115
116 return rc;
117 }
118
119 static UINT OpenNetworkSubkey(HKEY rootkey, HKEY *key, BOOL create)
120 {
121 UINT rc;
122 static const WCHAR net[] = {'N','e','t',0};
123
124 if (create)
125 rc = RegCreateKeyW(rootkey, net, key);
126 else
127 rc = RegOpenKeyW(rootkey, net, key);
128
129 return rc;
130 }
131
132 static UINT OpenURLSubkey(HKEY rootkey, HKEY *key, BOOL create)
133 {
134 UINT rc;
135 static const WCHAR URL[] = {'U','R','L',0};
136
137 if (create)
138 rc = RegCreateKeyW(rootkey, URL, key);
139 else
140 rc = RegOpenKeyW(rootkey, URL, key);
141
142 return rc;
143 }
144
145 /******************************************************************
146 * MsiSourceListEnumMediaDisksA (MSI.@)
147 */
148 UINT WINAPI MsiSourceListEnumMediaDisksA(LPCSTR szProductCodeOrPatchCode,
149 LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext,
150 DWORD dwOptions, DWORD dwIndex, LPDWORD pdwDiskId,
151 LPSTR szVolumeLabel, LPDWORD pcchVolumeLabel,
152 LPSTR szDiskPrompt, LPDWORD pcchDiskPrompt)
153 {
154 LPWSTR product = NULL;
155 LPWSTR usersid = NULL;
156 LPWSTR volume = NULL;
157 LPWSTR prompt = NULL;
158 UINT r = ERROR_INVALID_PARAMETER;
159
160 TRACE("(%s, %s, %d, %d, %d, %p, %p, %p, %p, %p)\n", debugstr_a(szProductCodeOrPatchCode),
161 debugstr_a(szUserSid), dwContext, dwOptions, dwIndex, pdwDiskId,
162 szVolumeLabel, pcchVolumeLabel, szDiskPrompt, pcchDiskPrompt);
163
164 if (szDiskPrompt && !pcchDiskPrompt)
165 return ERROR_INVALID_PARAMETER;
166
167 if (szProductCodeOrPatchCode) product = strdupAtoW(szProductCodeOrPatchCode);
168 if (szUserSid) usersid = strdupAtoW(szUserSid);
169
170 /* FIXME: add tests for an invalid format */
171
172 if (pcchVolumeLabel)
173 volume = msi_alloc(*pcchVolumeLabel * sizeof(WCHAR));
174
175 if (pcchDiskPrompt)
176 prompt = msi_alloc(*pcchDiskPrompt * sizeof(WCHAR));
177
178 if (volume) *volume = '\0';
179 if (prompt) *prompt = '\0';
180 r = MsiSourceListEnumMediaDisksW(product, usersid, dwContext, dwOptions,
181 dwIndex, pdwDiskId, volume, pcchVolumeLabel,
182 prompt, pcchDiskPrompt);
183 if (r != ERROR_SUCCESS)
184 goto done;
185
186 if (szVolumeLabel && pcchVolumeLabel)
187 WideCharToMultiByte(CP_ACP, 0, volume, -1, szVolumeLabel,
188 *pcchVolumeLabel + 1, NULL, NULL);
189
190 if (szDiskPrompt)
191 WideCharToMultiByte(CP_ACP, 0, prompt, -1, szDiskPrompt,
192 *pcchDiskPrompt + 1, NULL, NULL);
193
194 done:
195 msi_free(product);
196 msi_free(usersid);
197 msi_free(volume);
198 msi_free(prompt);
199
200 return r;
201 }
202
203 /******************************************************************
204 * MsiSourceListEnumMediaDisksW (MSI.@)
205 */
206 UINT WINAPI MsiSourceListEnumMediaDisksW(LPCWSTR szProductCodeOrPatchCode,
207 LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext,
208 DWORD dwOptions, DWORD dwIndex, LPDWORD pdwDiskId,
209 LPWSTR szVolumeLabel, LPDWORD pcchVolumeLabel,
210 LPWSTR szDiskPrompt, LPDWORD pcchDiskPrompt)
211 {
212 WCHAR squished_pc[GUID_SIZE];
213 WCHAR convert[11];
214 LPWSTR value = NULL;
215 LPWSTR data = NULL;
216 LPWSTR ptr, ptr2;
217 HKEY source, media;
218 DWORD valuesz, datasz = 0;
219 DWORD type;
220 DWORD numvals, size;
221 LONG res;
222 UINT r;
223 static DWORD index = 0;
224
225 static const WCHAR fmt[] = {'#','%','d',0};
226
227 TRACE("(%s, %s, %d, %d, %d, %p, %p, %p, %p)\n", debugstr_w(szProductCodeOrPatchCode),
228 debugstr_w(szUserSid), dwContext, dwOptions, dwIndex, szVolumeLabel,
229 pcchVolumeLabel, szDiskPrompt, pcchDiskPrompt);
230
231 if (!szProductCodeOrPatchCode ||
232 !squash_guid(szProductCodeOrPatchCode, squished_pc))
233 return ERROR_INVALID_PARAMETER;
234
235 if (dwContext == MSIINSTALLCONTEXT_MACHINE && szUserSid)
236 return ERROR_INVALID_PARAMETER;
237
238 if (dwOptions != MSICODE_PRODUCT && dwOptions != MSICODE_PATCH)
239 return ERROR_INVALID_PARAMETER;
240
241 if (szDiskPrompt && !pcchDiskPrompt)
242 return ERROR_INVALID_PARAMETER;
243
244 if (dwIndex == 0)
245 index = 0;
246
247 if (dwIndex != index)
248 return ERROR_INVALID_PARAMETER;
249
250 r = OpenSourceKey(szProductCodeOrPatchCode, &source,
251 dwOptions, dwContext, FALSE);
252 if (r != ERROR_SUCCESS)
253 return r;
254
255 r = OpenMediaSubkey(source, &media, FALSE);
256 if (r != ERROR_SUCCESS)
257 {
258 RegCloseKey(source);
259 return ERROR_NO_MORE_ITEMS;
260 }
261
262 if (!pcchVolumeLabel && !pcchDiskPrompt)
263 {
264 r = RegEnumValueW(media, dwIndex, NULL, NULL, NULL,
265 &type, NULL, NULL);
266 goto done;
267 }
268
269 res = RegQueryInfoKeyW(media, NULL, NULL, NULL, NULL, NULL,
270 NULL, &numvals, &valuesz, &datasz, NULL, NULL);
271 if (res != ERROR_SUCCESS)
272 {
273 r = ERROR_BAD_CONFIGURATION;
274 goto done;
275 }
276
277 value = msi_alloc(++valuesz * sizeof(WCHAR));
278 data = msi_alloc(++datasz * sizeof(WCHAR));
279 if (!value || !data)
280 {
281 r = ERROR_OUTOFMEMORY;
282 goto done;
283 }
284
285 r = RegEnumValueW(media, dwIndex, value, &valuesz,
286 NULL, &type, (LPBYTE)data, &datasz);
287 if (r != ERROR_SUCCESS)
288 goto done;
289
290 if (pdwDiskId)
291 *pdwDiskId = atolW(value);
292
293 ptr2 = data;
294 ptr = strchrW(data, ';');
295 if (!ptr)
296 ptr = data;
297 else
298 *ptr = '\0';
299
300 if (pcchVolumeLabel)
301 {
302 if (type == REG_DWORD)
303 {
304 sprintfW(convert, fmt, *data);
305 size = lstrlenW(convert);
306 ptr2 = convert;
307 }
308 else
309 size = lstrlenW(data);
310
311 if (size >= *pcchVolumeLabel)
312 r = ERROR_MORE_DATA;
313 else if (szVolumeLabel)
314 lstrcpyW(szVolumeLabel, ptr2);
315
316 *pcchVolumeLabel = size;
317 }
318
319 if (pcchDiskPrompt)
320 {
321 if (!*ptr)
322 ptr++;
323
324 if (type == REG_DWORD)
325 {
326 sprintfW(convert, fmt, *ptr);
327 size = lstrlenW(convert);
328 ptr = convert;
329 }
330 else
331 size = lstrlenW(ptr);
332
333 size = lstrlenW(ptr);
334 if (size >= *pcchDiskPrompt)
335 r = ERROR_MORE_DATA;
336 else if (szDiskPrompt)
337 lstrcpyW(szDiskPrompt, ptr);
338
339 *pcchDiskPrompt = size;
340 }
341
342 index++;
343
344 done:
345 msi_free(value);
346 msi_free(data);
347 RegCloseKey(source);
348
349 return r;
350 }
351
352 /******************************************************************
353 * MsiSourceListEnumSourcesA (MSI.@)
354 */
355 UINT WINAPI MsiSourceListEnumSourcesA(LPCSTR szProductCodeOrPatch, LPCSTR szUserSid,
356 MSIINSTALLCONTEXT dwContext,
357 DWORD dwOptions, DWORD dwIndex,
358 LPSTR szSource, LPDWORD pcchSource)
359 {
360 LPWSTR product = NULL;
361 LPWSTR usersid = NULL;
362 LPWSTR source = NULL;
363 DWORD len = 0;
364 UINT r = ERROR_INVALID_PARAMETER;
365 static DWORD index = 0;
366
367 TRACE("(%s, %s, %d, %d, %d, %p, %p)\n", debugstr_a(szProductCodeOrPatch),
368 debugstr_a(szUserSid), dwContext, dwOptions, dwIndex, szSource, pcchSource);
369
370 if (dwIndex == 0)
371 index = 0;
372
373 if (szSource && !pcchSource)
374 goto done;
375
376 if (dwIndex != index)
377 goto done;
378
379 if (szProductCodeOrPatch) product = strdupAtoW(szProductCodeOrPatch);
380 if (szUserSid) usersid = strdupAtoW(szUserSid);
381
382 r = MsiSourceListEnumSourcesW(product, usersid, dwContext, dwOptions,
383 dwIndex, NULL, &len);
384 if (r != ERROR_SUCCESS)
385 goto done;
386
387 source = msi_alloc(++len * sizeof(WCHAR));
388 if (!source)
389 {
390 r = ERROR_OUTOFMEMORY;
391 goto done;
392 }
393
394 *source = '\0';
395 r = MsiSourceListEnumSourcesW(product, usersid, dwContext, dwOptions,
396 dwIndex, source, &len);
397 if (r != ERROR_SUCCESS)
398 goto done;
399
400 len = WideCharToMultiByte(CP_ACP, 0, source, -1, NULL, 0, NULL, NULL);
401 if (pcchSource && *pcchSource >= len)
402 WideCharToMultiByte(CP_ACP, 0, source, -1, szSource, len, NULL, NULL);
403 else if (szSource)
404 r = ERROR_MORE_DATA;
405
406 if (pcchSource)
407 *pcchSource = len - 1;
408
409 done:
410 msi_free(product);
411 msi_free(usersid);
412 msi_free(source);
413
414 if (r == ERROR_SUCCESS)
415 {
416 if (szSource || !pcchSource) index++;
417 }
418 else if (dwIndex > index)
419 index = 0;
420
421 return r;
422 }
423
424 /******************************************************************
425 * MsiSourceListEnumSourcesW (MSI.@)
426 */
427 UINT WINAPI MsiSourceListEnumSourcesW(LPCWSTR szProductCodeOrPatch, LPCWSTR szUserSid,
428 MSIINSTALLCONTEXT dwContext,
429 DWORD dwOptions, DWORD dwIndex,
430 LPWSTR szSource, LPDWORD pcchSource)
431 {
432 WCHAR squished_pc[GUID_SIZE];
433 WCHAR name[32];
434 HKEY source = NULL;
435 HKEY subkey = NULL;
436 LONG res;
437 UINT r = ERROR_INVALID_PARAMETER;
438 static DWORD index = 0;
439
440 static const WCHAR format[] = {'%','d',0};
441
442 TRACE("(%s, %s, %d, %d, %d, %p, %p)\n", debugstr_w(szProductCodeOrPatch),
443 debugstr_w(szUserSid), dwContext, dwOptions, dwIndex, szSource, pcchSource);
444
445 if (dwIndex == 0)
446 index = 0;
447
448 if (!szProductCodeOrPatch || !squash_guid(szProductCodeOrPatch, squished_pc))
449 goto done;
450
451 if (szSource && !pcchSource)
452 goto done;
453
454 if (!(dwOptions & (MSISOURCETYPE_NETWORK | MSISOURCETYPE_URL)))
455 goto done;
456
457 if ((dwOptions & MSISOURCETYPE_NETWORK) && (dwOptions & MSISOURCETYPE_URL))
458 goto done;
459
460 if (dwContext == MSIINSTALLCONTEXT_MACHINE && szUserSid)
461 goto done;
462
463 if (dwIndex != index)
464 goto done;
465
466 r = OpenSourceKey(szProductCodeOrPatch, &source,
467 dwOptions, dwContext, FALSE);
468 if (r != ERROR_SUCCESS)
469 goto done;
470
471 if (dwOptions & MSISOURCETYPE_NETWORK)
472 r = OpenNetworkSubkey(source, &subkey, FALSE);
473 else if (dwOptions & MSISOURCETYPE_URL)
474 r = OpenURLSubkey(source, &subkey, FALSE);
475
476 if (r != ERROR_SUCCESS)
477 {
478 r = ERROR_NO_MORE_ITEMS;
479 goto done;
480 }
481
482 sprintfW(name, format, dwIndex + 1);
483
484 res = RegQueryValueExW(subkey, name, 0, 0, (LPBYTE)szSource, pcchSource);
485 if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
486 r = ERROR_NO_MORE_ITEMS;
487
488 done:
489 RegCloseKey(subkey);
490 RegCloseKey(source);
491
492 if (r == ERROR_SUCCESS)
493 {
494 if (szSource || !pcchSource) index++;
495 }
496 else if (dwIndex > index)
497 index = 0;
498
499 return r;
500 }
501
502 /******************************************************************
503 * MsiSourceListGetInfoA (MSI.@)
504 */
505 UINT WINAPI MsiSourceListGetInfoA( LPCSTR szProduct, LPCSTR szUserSid,
506 MSIINSTALLCONTEXT dwContext, DWORD dwOptions,
507 LPCSTR szProperty, LPSTR szValue,
508 LPDWORD pcchValue)
509 {
510 UINT ret;
511 LPWSTR product = NULL;
512 LPWSTR usersid = NULL;
513 LPWSTR property = NULL;
514 LPWSTR value = NULL;
515 DWORD len = 0;
516
517 if (szValue && !pcchValue)
518 return ERROR_INVALID_PARAMETER;
519
520 if (szProduct) product = strdupAtoW(szProduct);
521 if (szUserSid) usersid = strdupAtoW(szUserSid);
522 if (szProperty) property = strdupAtoW(szProperty);
523
524 ret = MsiSourceListGetInfoW(product, usersid, dwContext, dwOptions,
525 property, NULL, &len);
526 if (ret != ERROR_SUCCESS)
527 goto done;
528
529 value = msi_alloc(++len * sizeof(WCHAR));
530 if (!value)
531 return ERROR_OUTOFMEMORY;
532
533 *value = '\0';
534 ret = MsiSourceListGetInfoW(product, usersid, dwContext, dwOptions,
535 property, value, &len);
536 if (ret != ERROR_SUCCESS)
537 goto done;
538
539 len = WideCharToMultiByte(CP_ACP, 0, value, -1, NULL, 0, NULL, NULL);
540 if (*pcchValue >= len)
541 WideCharToMultiByte(CP_ACP, 0, value, -1, szValue, len, NULL, NULL);
542 else if (szValue)
543 ret = ERROR_MORE_DATA;
544
545 *pcchValue = len - 1;
546
547 done:
548 msi_free(product);
549 msi_free(usersid);
550 msi_free(property);
551 msi_free(value);
552 return ret;
553 }
554
555 /******************************************************************
556 * MsiSourceListGetInfoW (MSI.@)
557 */
558 UINT WINAPI MsiSourceListGetInfoW( LPCWSTR szProduct, LPCWSTR szUserSid,
559 MSIINSTALLCONTEXT dwContext, DWORD dwOptions,
560 LPCWSTR szProperty, LPWSTR szValue,
561 LPDWORD pcchValue)
562 {
563 WCHAR squished_pc[GUID_SIZE];
564 HKEY sourcekey, media;
565 LPWSTR source, ptr;
566 DWORD size;
567 UINT rc;
568
569 static const WCHAR mediapack[] = {
570 'M','e','d','i','a','P','a','c','k','a','g','e',0};
571
572 TRACE("%s %s\n", debugstr_w(szProduct), debugstr_w(szProperty));
573
574 if (!szProduct || !squash_guid(szProduct, squished_pc))
575 return ERROR_INVALID_PARAMETER;
576
577 if (szValue && !pcchValue)
578 return ERROR_INVALID_PARAMETER;
579
580 if (dwContext != MSIINSTALLCONTEXT_USERMANAGED &&
581 dwContext != MSIINSTALLCONTEXT_USERUNMANAGED &&
582 dwContext != MSIINSTALLCONTEXT_MACHINE)
583 return ERROR_INVALID_PARAMETER;
584
585 if (!szProperty)
586 return ERROR_INVALID_PARAMETER;
587
588 if (szUserSid)
589 FIXME("Unhandled UserSid %s\n",debugstr_w(szUserSid));
590
591 if (dwContext != MSIINSTALLCONTEXT_USERUNMANAGED)
592 FIXME("Unhandled context %d\n", dwContext);
593
594 rc = OpenSourceKey(szProduct, &sourcekey, dwOptions, dwContext, FALSE);
595 if (rc != ERROR_SUCCESS)
596 return rc;
597
598 if (!lstrcmpW(szProperty, INSTALLPROPERTY_MEDIAPACKAGEPATHW) ||
599 !lstrcmpW(szProperty, INSTALLPROPERTY_DISKPROMPTW))
600 {
601 rc = OpenMediaSubkey(sourcekey, &media, FALSE);
602 if (rc != ERROR_SUCCESS)
603 {
604 RegCloseKey(sourcekey);
605 return ERROR_SUCCESS;
606 }
607
608 if (!lstrcmpW(szProperty, INSTALLPROPERTY_MEDIAPACKAGEPATHW))
609 szProperty = mediapack;
610
611 RegQueryValueExW(media, szProperty, 0, 0, (LPBYTE)szValue, pcchValue);
612 RegCloseKey(media);
613 }
614 else if (!lstrcmpW(szProperty, INSTALLPROPERTY_LASTUSEDSOURCEW) ||
615 !lstrcmpW(szProperty, INSTALLPROPERTY_LASTUSEDTYPEW))
616 {
617 rc = RegQueryValueExW(sourcekey, INSTALLPROPERTY_LASTUSEDSOURCEW,
618 0, 0, NULL, &size);
619 if (rc != ERROR_SUCCESS)
620 {
621 RegCloseKey(sourcekey);
622 return ERROR_SUCCESS;
623 }
624
625 source = msi_alloc(size);
626 RegQueryValueExW(sourcekey, INSTALLPROPERTY_LASTUSEDSOURCEW,
627 0, 0, (LPBYTE)source, &size);
628
629 if (!*source)
630 {
631 msi_free(source);
632 RegCloseKey(sourcekey);
633 return ERROR_SUCCESS;
634 }
635
636 if (!lstrcmpW(szProperty, INSTALLPROPERTY_LASTUSEDTYPEW))
637 {
638 if (*source != 'n' && *source != 'u' && *source != 'm')
639 {
640 msi_free(source);
641 RegCloseKey(sourcekey);
642 return ERROR_SUCCESS;
643 }
644
645 ptr = source;
646 source[1] = '\0';
647 }
648 else
649 {
650 ptr = strrchrW(source, ';');
651 if (!ptr)
652 ptr = source;
653 else
654 ptr++;
655 }
656
657 if (szValue)
658 {
659 if (strlenW(ptr) < *pcchValue)
660 lstrcpyW(szValue, ptr);
661 else
662 rc = ERROR_MORE_DATA;
663 }
664
665 *pcchValue = lstrlenW(ptr);
666 msi_free(source);
667 }
668 else if (strcmpW(INSTALLPROPERTY_PACKAGENAMEW, szProperty)==0)
669 {
670 *pcchValue = *pcchValue * sizeof(WCHAR);
671 rc = RegQueryValueExW(sourcekey, INSTALLPROPERTY_PACKAGENAMEW, 0, 0,
672 (LPBYTE)szValue, pcchValue);
673 if (rc != ERROR_SUCCESS && rc != ERROR_MORE_DATA)
674 {
675 *pcchValue = 0;
676 rc = ERROR_SUCCESS;
677 }
678 else
679 {
680 if (*pcchValue)
681 *pcchValue = (*pcchValue - 1) / sizeof(WCHAR);
682 if (szValue)
683 szValue[*pcchValue] = '\0';
684 }
685 }
686 else
687 {
688 FIXME("Unknown property %s\n",debugstr_w(szProperty));
689 rc = ERROR_UNKNOWN_PROPERTY;
690 }
691
692 RegCloseKey(sourcekey);
693 return rc;
694 }
695
696 /******************************************************************
697 * MsiSourceListSetInfoA (MSI.@)
698 */
699 UINT WINAPI MsiSourceListSetInfoA(LPCSTR szProduct, LPCSTR szUserSid,
700 MSIINSTALLCONTEXT dwContext, DWORD dwOptions,
701 LPCSTR szProperty, LPCSTR szValue)
702 {
703 UINT ret;
704 LPWSTR product = NULL;
705 LPWSTR usersid = NULL;
706 LPWSTR property = NULL;
707 LPWSTR value = NULL;
708
709 if (szProduct) product = strdupAtoW(szProduct);
710 if (szUserSid) usersid = strdupAtoW(szUserSid);
711 if (szProperty) property = strdupAtoW(szProperty);
712 if (szValue) value = strdupAtoW(szValue);
713
714 ret = MsiSourceListSetInfoW(product, usersid, dwContext, dwOptions,
715 property, value);
716
717 msi_free(product);
718 msi_free(usersid);
719 msi_free(property);
720 msi_free(value);
721
722 return ret;
723 }
724
725 UINT msi_set_last_used_source(LPCWSTR product, LPCWSTR usersid,
726 MSIINSTALLCONTEXT context, DWORD options,
727 LPCWSTR value)
728 {
729 HKEY source;
730 LPWSTR buffer;
731 WCHAR typechar;
732 DWORD size;
733 UINT r;
734 int index = 1;
735
736 static const WCHAR format[] = {'%','c',';','%','i',';','%','s',0};
737
738 if (options & MSISOURCETYPE_NETWORK)
739 typechar = 'n';
740 else if (options & MSISOURCETYPE_URL)
741 typechar = 'u';
742 else if (options & MSISOURCETYPE_MEDIA)
743 typechar = 'm';
744 else
745 return ERROR_INVALID_PARAMETER;
746
747 if (!(options & MSISOURCETYPE_MEDIA))
748 {
749 r = MsiSourceListAddSourceExW(product, usersid, context,
750 options, value, 0);
751 if (r != ERROR_SUCCESS)
752 return r;
753
754 index = 0;
755 while ((r = MsiSourceListEnumSourcesW(product, usersid, context, options,
756 index, NULL, NULL)) == ERROR_SUCCESS)
757 index++;
758
759 if (r != ERROR_NO_MORE_ITEMS)
760 return r;
761 }
762
763 size = (lstrlenW(format) + lstrlenW(value) + 7) * sizeof(WCHAR);
764 buffer = msi_alloc(size);
765 if (!buffer)
766 return ERROR_OUTOFMEMORY;
767
768 r = OpenSourceKey(product, &source, MSICODE_PRODUCT, context, FALSE);
769 if (r != ERROR_SUCCESS)
770 return r;
771
772 sprintfW(buffer, format, typechar, index, value);
773
774 size = (lstrlenW(buffer) + 1) * sizeof(WCHAR);
775 r = RegSetValueExW(source, INSTALLPROPERTY_LASTUSEDSOURCEW, 0,
776 REG_SZ, (LPBYTE)buffer, size);
777 msi_free(buffer);
778
779 RegCloseKey(source);
780 return r;
781 }
782
783 /******************************************************************
784 * MsiSourceListSetInfoW (MSI.@)
785 */
786 UINT WINAPI MsiSourceListSetInfoW( LPCWSTR szProduct, LPCWSTR szUserSid,
787 MSIINSTALLCONTEXT dwContext, DWORD dwOptions,
788 LPCWSTR szProperty, LPCWSTR szValue)
789 {
790 WCHAR squished_pc[GUID_SIZE];
791 HKEY sourcekey, media;
792 LPCWSTR property;
793 UINT rc;
794
795 static const WCHAR media_package[] = {
796 'M','e','d','i','a','P','a','c','k','a','g','e',0
797 };
798
799 TRACE("%s %s %x %x %s %s\n", debugstr_w(szProduct), debugstr_w(szUserSid),
800 dwContext, dwOptions, debugstr_w(szProperty), debugstr_w(szValue));
801
802 if (!szProduct || !squash_guid(szProduct, squished_pc))
803 return ERROR_INVALID_PARAMETER;
804
805 if (!szProperty)
806 return ERROR_INVALID_PARAMETER;
807
808 if (!szValue)
809 return ERROR_UNKNOWN_PROPERTY;
810
811 if (dwContext == MSIINSTALLCONTEXT_MACHINE && szUserSid)
812 return ERROR_INVALID_PARAMETER;
813
814 if (dwOptions & MSICODE_PATCH)
815 {
816 FIXME("Unhandled options MSICODE_PATCH\n");
817 return ERROR_UNKNOWN_PATCH;
818 }
819
820 property = szProperty;
821 if (!lstrcmpW(szProperty, INSTALLPROPERTY_MEDIAPACKAGEPATHW))
822 property = media_package;
823
824 rc = OpenSourceKey(szProduct, &sourcekey, MSICODE_PRODUCT, dwContext, FALSE);
825 if (rc != ERROR_SUCCESS)
826 return rc;
827
828 if (lstrcmpW(szProperty, INSTALLPROPERTY_LASTUSEDSOURCEW) &&
829 dwOptions & (MSISOURCETYPE_NETWORK | MSISOURCETYPE_URL))
830 {
831 RegCloseKey(sourcekey);
832 return ERROR_INVALID_PARAMETER;
833 }
834
835 if (!lstrcmpW(szProperty, INSTALLPROPERTY_MEDIAPACKAGEPATHW) ||
836 !lstrcmpW(szProperty, INSTALLPROPERTY_DISKPROMPTW))
837 {
838 rc = OpenMediaSubkey(sourcekey, &media, TRUE);
839 if (rc == ERROR_SUCCESS)
840 {
841 rc = msi_reg_set_val_str(media, property, szValue);
842 RegCloseKey(media);
843 }
844 }
845 else if (strcmpW(INSTALLPROPERTY_PACKAGENAMEW, szProperty)==0)
846 {
847 DWORD size = (lstrlenW(szValue) + 1) * sizeof(WCHAR);
848 rc = RegSetValueExW(sourcekey, INSTALLPROPERTY_PACKAGENAMEW, 0,
849 REG_SZ, (const BYTE *)szValue, size);
850 if (rc != ERROR_SUCCESS)
851 rc = ERROR_UNKNOWN_PROPERTY;
852 }
853 else if (!lstrcmpW(szProperty, INSTALLPROPERTY_LASTUSEDSOURCEW))
854 {
855 if (!(dwOptions & (MSISOURCETYPE_NETWORK | MSISOURCETYPE_URL)))
856 rc = ERROR_INVALID_PARAMETER;
857 else
858 rc = msi_set_last_used_source(szProduct, szUserSid, dwContext,
859 dwOptions, szValue);
860 }
861 else
862 rc = ERROR_UNKNOWN_PROPERTY;
863
864 RegCloseKey(sourcekey);
865 return rc;
866 }
867
868 /******************************************************************
869 * MsiSourceListAddSourceW (MSI.@)
870 */
871 UINT WINAPI MsiSourceListAddSourceW( LPCWSTR szProduct, LPCWSTR szUserName,
872 DWORD dwReserved, LPCWSTR szSource)
873 {
874 WCHAR squished_pc[GUID_SIZE];
875 INT ret;
876 LPWSTR sidstr = NULL;
877 DWORD sidsize = 0;
878 DWORD domsize = 0;
879 DWORD context;
880 HKEY hkey = 0;
881 UINT r;
882
883 TRACE("%s %s %s\n", debugstr_w(szProduct), debugstr_w(szUserName), debugstr_w(szSource));
884
885 if (!szSource || !*szSource)
886 return ERROR_INVALID_PARAMETER;
887
888 if (dwReserved != 0)
889 return ERROR_INVALID_PARAMETER;
890
891 if (!szProduct || !squash_guid(szProduct, squished_pc))
892 return ERROR_INVALID_PARAMETER;
893
894 if (!szUserName || !*szUserName)
895 context = MSIINSTALLCONTEXT_MACHINE;
896 else
897 {
898 if (LookupAccountNameW(NULL, szUserName, NULL, &sidsize, NULL, &domsize, NULL))
899 {
900 PSID psid = msi_alloc(sidsize);
901
902 if (LookupAccountNameW(NULL, szUserName, psid, &sidsize, NULL, &domsize, NULL))
903 ConvertSidToStringSidW(psid, &sidstr);
904
905 msi_free(psid);
906 }
907
908 r = MSIREG_OpenProductKey(szProduct, NULL,
909 MSIINSTALLCONTEXT_USERMANAGED, &hkey, FALSE);
910 if (r == ERROR_SUCCESS)
911 context = MSIINSTALLCONTEXT_USERMANAGED;
912 else
913 {
914 r = MSIREG_OpenProductKey(szProduct, NULL,
915 MSIINSTALLCONTEXT_USERUNMANAGED,
916 &hkey, FALSE);
917 if (r != ERROR_SUCCESS)
918 return ERROR_UNKNOWN_PRODUCT;
919
920 context = MSIINSTALLCONTEXT_USERUNMANAGED;
921 }
922
923 RegCloseKey(hkey);
924 }
925
926 ret = MsiSourceListAddSourceExW(szProduct, sidstr,
927 context, MSISOURCETYPE_NETWORK, szSource, 0);
928
929 if (sidstr)
930 LocalFree(sidstr);
931
932 return ret;
933 }
934
935 /******************************************************************
936 * MsiSourceListAddSourceA (MSI.@)
937 */
938 UINT WINAPI MsiSourceListAddSourceA( LPCSTR szProduct, LPCSTR szUserName,
939 DWORD dwReserved, LPCSTR szSource)
940 {
941 INT ret;
942 LPWSTR szwproduct;
943 LPWSTR szwusername;
944 LPWSTR szwsource;
945
946 szwproduct = strdupAtoW( szProduct );
947 szwusername = strdupAtoW( szUserName );
948 szwsource = strdupAtoW( szSource );
949
950 ret = MsiSourceListAddSourceW(szwproduct, szwusername, dwReserved, szwsource);
951
952 msi_free(szwproduct);
953 msi_free(szwusername);
954 msi_free(szwsource);
955
956 return ret;
957 }
958
959 /******************************************************************
960 * MsiSourceListAddSourceExA (MSI.@)
961 */
962 UINT WINAPI MsiSourceListAddSourceExA(LPCSTR szProduct, LPCSTR szUserSid,
963 MSIINSTALLCONTEXT dwContext, DWORD dwOptions, LPCSTR szSource, DWORD dwIndex)
964 {
965 UINT ret;
966 LPWSTR product, usersid, source;
967
968 product = strdupAtoW(szProduct);
969 usersid = strdupAtoW(szUserSid);
970 source = strdupAtoW(szSource);
971
972 ret = MsiSourceListAddSourceExW(product, usersid, dwContext,
973 dwOptions, source, dwIndex);
974
975 msi_free(product);
976 msi_free(usersid);
977 msi_free(source);
978
979 return ret;
980 }
981
982 static void free_source_list(struct list *sourcelist)
983 {
984 while (!list_empty(sourcelist))
985 {
986 media_info *info = LIST_ENTRY(list_head(sourcelist), media_info, entry);
987 list_remove(&info->entry);
988 msi_free(info->path);
989 msi_free(info);
990 }
991 }
992
993 static void add_source_to_list(struct list *sourcelist, media_info *info,
994 DWORD *index)
995 {
996 media_info *iter;
997 BOOL found = FALSE;
998 static const WCHAR fmt[] = {'%','i',0};
999
1000 if (index) *index = 0;
1001
1002 if (list_empty(sourcelist))
1003 {
1004 list_add_head(sourcelist, &info->entry);
1005 return;
1006 }
1007
1008 LIST_FOR_EACH_ENTRY(iter, sourcelist, media_info, entry)
1009 {
1010 if (!found && info->index < iter->index)
1011 {
1012 found = TRUE;
1013 list_add_before(&iter->entry, &info->entry);
1014 }
1015
1016 /* update the rest of the list */
1017 if (found)
1018 sprintfW(iter->szIndex, fmt, ++iter->index);
1019 else if (index)
1020 (*index)++;
1021 }
1022
1023 if (!found)
1024 list_add_after(&iter->entry, &info->entry);
1025 }
1026
1027 static UINT fill_source_list(struct list *sourcelist, HKEY sourcekey, DWORD *count)
1028 {
1029 UINT r = ERROR_SUCCESS;
1030 DWORD index = 0;
1031 WCHAR name[10];
1032 DWORD size, val_size;
1033 media_info *entry;
1034
1035 *count = 0;
1036
1037 while (r == ERROR_SUCCESS)
1038 {
1039 size = sizeof(name) / sizeof(name[0]);
1040 r = RegEnumValueW(sourcekey, index, name, &size, NULL, NULL, NULL, &val_size);
1041 if (r != ERROR_SUCCESS)
1042 return r;
1043
1044 entry = msi_alloc(sizeof(media_info));
1045 if (!entry)
1046 goto error;
1047
1048 entry->path = msi_alloc(val_size);
1049 if (!entry->path)
1050 {
1051 msi_free(entry);
1052 goto error;
1053 }
1054
1055 lstrcpyW(entry->szIndex, name);
1056 entry->index = atoiW(name);
1057
1058 size++;
1059 r = RegEnumValueW(sourcekey, index, name, &size, NULL,
1060 NULL, (LPBYTE)entry->path, &val_size);
1061 if (r != ERROR_SUCCESS)
1062 {
1063 msi_free(entry->path);
1064 msi_free(entry);
1065 goto error;
1066 }
1067
1068 index = ++(*count);
1069 add_source_to_list(sourcelist, entry, NULL);
1070 }
1071
1072 error:
1073 *count = -1;
1074 free_source_list(sourcelist);
1075 return ERROR_OUTOFMEMORY;
1076 }
1077
1078 /******************************************************************
1079 * MsiSourceListAddSourceExW (MSI.@)
1080 */
1081 UINT WINAPI MsiSourceListAddSourceExW( LPCWSTR szProduct, LPCWSTR szUserSid,
1082 MSIINSTALLCONTEXT dwContext, DWORD dwOptions, LPCWSTR szSource,
1083 DWORD dwIndex)
1084 {
1085 HKEY sourcekey;
1086 HKEY typekey;
1087 UINT rc;
1088 struct list sourcelist;
1089 media_info *info;
1090 WCHAR squished_pc[GUID_SIZE];
1091 WCHAR name[10];
1092 LPWSTR source;
1093 LPCWSTR postfix;
1094 DWORD size, count;
1095 DWORD index;
1096
1097 static const WCHAR fmt[] = {'%','i',0};
1098
1099 TRACE("%s %s %x %x %s %i\n", debugstr_w(szProduct), debugstr_w(szUserSid),
1100 dwContext, dwOptions, debugstr_w(szSource), dwIndex);
1101
1102 if (!szProduct || !squash_guid(szProduct, squished_pc))
1103 return ERROR_INVALID_PARAMETER;
1104
1105 if (!szSource || !*szSource)
1106 return ERROR_INVALID_PARAMETER;
1107
1108 if (!(dwOptions & (MSISOURCETYPE_NETWORK | MSISOURCETYPE_URL)))
1109 return ERROR_INVALID_PARAMETER;
1110
1111 if (dwOptions & MSICODE_PATCH)
1112 {
1113 FIXME("Unhandled options MSICODE_PATCH\n");
1114 return ERROR_FUNCTION_FAILED;
1115 }
1116
1117 if (szUserSid && (dwContext & MSIINSTALLCONTEXT_MACHINE))
1118 return ERROR_INVALID_PARAMETER;
1119
1120 rc = OpenSourceKey(szProduct, &sourcekey, MSICODE_PRODUCT, dwContext, FALSE);
1121 if (rc != ERROR_SUCCESS)
1122 return rc;
1123
1124 if (dwOptions & MSISOURCETYPE_NETWORK)
1125 rc = OpenNetworkSubkey(sourcekey, &typekey, TRUE);
1126 else if (dwOptions & MSISOURCETYPE_URL)
1127 rc = OpenURLSubkey(sourcekey, &typekey, TRUE);
1128 else if (dwOptions & MSISOURCETYPE_MEDIA)
1129 rc = OpenMediaSubkey(sourcekey, &typekey, TRUE);
1130 else
1131 {
1132 ERR("unknown media type: %08x\n", dwOptions);
1133 RegCloseKey(sourcekey);
1134 return ERROR_FUNCTION_FAILED;
1135 }
1136
1137 postfix = (dwOptions & MSISOURCETYPE_NETWORK) ? szBackSlash : szForwardSlash;
1138 if (szSource[lstrlenW(szSource) - 1] == *postfix)
1139 source = strdupW(szSource);
1140 else
1141 {
1142 size = lstrlenW(szSource) + 2;
1143 source = msi_alloc(size * sizeof(WCHAR));
1144 lstrcpyW(source, szSource);
1145 lstrcatW(source, postfix);
1146 }
1147
1148 list_init(&sourcelist);
1149 rc = fill_source_list(&sourcelist, typekey, &count);
1150 if (rc != ERROR_NO_MORE_ITEMS)
1151 return rc;
1152
1153 size = (lstrlenW(source) + 1) * sizeof(WCHAR);
1154
1155 if (count == 0)
1156 {
1157 rc = RegSetValueExW(typekey, szOne, 0, REG_EXPAND_SZ, (LPBYTE)source, size);
1158 goto done;
1159 }
1160 else if (dwIndex > count || dwIndex == 0)
1161 {
1162 sprintfW(name, fmt, count + 1);
1163 rc = RegSetValueExW(typekey, name, 0, REG_EXPAND_SZ, (LPBYTE)source, size);
1164 goto done;
1165 }
1166 else
1167 {
1168 sprintfW(name, fmt, dwIndex);
1169 info = msi_alloc(sizeof(media_info));
1170 if (!info)
1171 {
1172 rc = ERROR_OUTOFMEMORY;
1173 goto done;
1174 }
1175
1176 info->path = strdupW(source);
1177 lstrcpyW(info->szIndex, name);
1178 info->index = dwIndex;
1179 add_source_to_list(&sourcelist, info, &index);
1180
1181 LIST_FOR_EACH_ENTRY(info, &sourcelist, media_info, entry)
1182 {
1183 if (info->index < index)
1184 continue;
1185
1186 size = (lstrlenW(info->path) + 1) * sizeof(WCHAR);
1187 rc = RegSetValueExW(typekey, info->szIndex, 0,
1188 REG_EXPAND_SZ, (LPBYTE)info->path, size);
1189 if (rc != ERROR_SUCCESS)
1190 goto done;
1191 }
1192 }
1193
1194 done:
1195 free_source_list(&sourcelist);
1196 msi_free(source);
1197 RegCloseKey(typekey);
1198 RegCloseKey(sourcekey);
1199 return rc;
1200 }
1201
1202 /******************************************************************
1203 * MsiSourceListAddMediaDiskA (MSI.@)
1204 */
1205 UINT WINAPI MsiSourceListAddMediaDiskA(LPCSTR szProduct, LPCSTR szUserSid,
1206 MSIINSTALLCONTEXT dwContext, DWORD dwOptions, DWORD dwDiskId,
1207 LPCSTR szVolumeLabel, LPCSTR szDiskPrompt)
1208 {
1209 UINT r;
1210 LPWSTR product = NULL;
1211 LPWSTR usersid = NULL;
1212 LPWSTR volume = NULL;
1213 LPWSTR prompt = NULL;
1214
1215 if (szProduct) product = strdupAtoW(szProduct);
1216 if (szUserSid) usersid = strdupAtoW(szUserSid);
1217 if (szVolumeLabel) volume = strdupAtoW(szVolumeLabel);
1218 if (szDiskPrompt) prompt = strdupAtoW(szDiskPrompt);
1219
1220 r = MsiSourceListAddMediaDiskW(product, usersid, dwContext, dwOptions,
1221 dwDiskId, volume, prompt);
1222
1223 msi_free(product);
1224 msi_free(usersid);
1225 msi_free(volume);
1226 msi_free(prompt);
1227
1228 return r;
1229 }
1230
1231 /******************************************************************
1232 * MsiSourceListAddMediaDiskW (MSI.@)
1233 */
1234 UINT WINAPI MsiSourceListAddMediaDiskW(LPCWSTR szProduct, LPCWSTR szUserSid,
1235 MSIINSTALLCONTEXT dwContext, DWORD dwOptions, DWORD dwDiskId,
1236 LPCWSTR szVolumeLabel, LPCWSTR szDiskPrompt)
1237 {
1238 HKEY sourcekey;
1239 HKEY mediakey;
1240 UINT rc;
1241 WCHAR szIndex[10];
1242 WCHAR squished_pc[GUID_SIZE];
1243 LPWSTR buffer;
1244 DWORD size;
1245
1246 static const WCHAR fmt[] = {'%','i',0};
1247
1248 TRACE("%s %s %x %x %i %s %s\n", debugstr_w(szProduct),
1249 debugstr_w(szUserSid), dwContext, dwOptions, dwDiskId,
1250 debugstr_w(szVolumeLabel), debugstr_w(szDiskPrompt));
1251
1252 if (!szProduct || !squash_guid(szProduct, squished_pc))
1253 return ERROR_INVALID_PARAMETER;
1254
1255 if (dwOptions != MSICODE_PRODUCT && dwOptions != MSICODE_PATCH)
1256 return ERROR_INVALID_PARAMETER;
1257
1258 if ((szVolumeLabel && !*szVolumeLabel) || (szDiskPrompt && !*szDiskPrompt))
1259 return ERROR_INVALID_PARAMETER;
1260
1261 if ((dwContext & MSIINSTALLCONTEXT_MACHINE) && szUserSid)
1262 return ERROR_INVALID_PARAMETER;
1263
1264 if (dwOptions & MSICODE_PATCH)
1265 {
1266 FIXME("Unhandled options MSICODE_PATCH\n");
1267 return ERROR_FUNCTION_FAILED;
1268 }
1269
1270 rc = OpenSourceKey(szProduct, &sourcekey, MSICODE_PRODUCT, dwContext, FALSE);
1271 if (rc != ERROR_SUCCESS)
1272 return rc;
1273
1274 OpenMediaSubkey(sourcekey, &mediakey, TRUE);
1275
1276 sprintfW(szIndex, fmt, dwDiskId);
1277
1278 size = 2;
1279 if (szVolumeLabel) size += lstrlenW(szVolumeLabel);
1280 if (szDiskPrompt) size += lstrlenW(szDiskPrompt);
1281
1282 size *= sizeof(WCHAR);
1283 buffer = msi_alloc(size);
1284 *buffer = '\0';
1285
1286 if (szVolumeLabel) lstrcpyW(buffer, szVolumeLabel);
1287 lstrcatW(buffer, szSemiColon);
1288 if (szDiskPrompt) lstrcatW(buffer, szDiskPrompt);
1289
1290 RegSetValueExW(mediakey, szIndex, 0, REG_SZ, (LPBYTE)buffer, size);
1291 msi_free(buffer);
1292
1293 RegCloseKey(sourcekey);
1294 RegCloseKey(mediakey);
1295
1296 return ERROR_SUCCESS;
1297 }
1298
1299 /******************************************************************
1300 * MsiSourceListClearAllA (MSI.@)
1301 */
1302 UINT WINAPI MsiSourceListClearAllA( LPCSTR szProduct, LPCSTR szUserName, DWORD dwReserved )
1303 {
1304 FIXME("(%s %s %d)\n", debugstr_a(szProduct), debugstr_a(szUserName), dwReserved);
1305 return ERROR_SUCCESS;
1306 }
1307
1308 /******************************************************************
1309 * MsiSourceListClearAllW (MSI.@)
1310 */
1311 UINT WINAPI MsiSourceListClearAllW( LPCWSTR szProduct, LPCWSTR szUserName, DWORD dwReserved )
1312 {
1313 FIXME("(%s %s %d)\n", debugstr_w(szProduct), debugstr_w(szUserName), dwReserved);
1314 return ERROR_SUCCESS;
1315 }
1316
1317 /******************************************************************
1318 * MsiSourceListClearAllExA (MSI.@)
1319 */
1320 UINT WINAPI MsiSourceListClearAllExA( LPCSTR szProduct, LPCSTR szUserSid,
1321 MSIINSTALLCONTEXT dwContext, DWORD dwOptions )
1322 {
1323 FIXME("(%s %s %d %08x)\n", debugstr_a(szProduct), debugstr_a(szUserSid),
1324 dwContext, dwOptions);
1325 return ERROR_SUCCESS;
1326 }
1327
1328 /******************************************************************
1329 * MsiSourceListClearAllExW (MSI.@)
1330 */
1331 UINT WINAPI MsiSourceListClearAllExW( LPCWSTR szProduct, LPCWSTR szUserSid,
1332 MSIINSTALLCONTEXT dwContext, DWORD dwOptions )
1333 {
1334 FIXME("(%s %s %d %08x)\n", debugstr_w(szProduct), debugstr_w(szUserSid),
1335 dwContext, dwOptions);
1336 return ERROR_SUCCESS;
1337 }
1338
1339 /******************************************************************
1340 * MsiSourceListClearSourceA (MSI.@)
1341 */
1342 UINT WINAPI MsiSourceListClearSourceA(LPCSTR szProductCodeOrPatchCode, LPCSTR szUserSid,
1343 MSIINSTALLCONTEXT dwContext, DWORD dwOptions,
1344 LPCSTR szSource)
1345 {
1346 FIXME("(%s %s %x %x %s)\n", debugstr_a(szProductCodeOrPatchCode), debugstr_a(szUserSid),
1347 dwContext, dwOptions, debugstr_a(szSource));
1348 return ERROR_SUCCESS;
1349 }
1350
1351 /******************************************************************
1352 * MsiSourceListClearSourceW (MSI.@)
1353 */
1354 UINT WINAPI MsiSourceListClearSourceW(LPCWSTR szProductCodeOrPatchCode, LPCWSTR szUserSid,
1355 MSIINSTALLCONTEXT dwContext, DWORD dwOptions,
1356 LPCWSTR szSource)
1357 {
1358 FIXME("(%s %s %x %x %s)\n", debugstr_w(szProductCodeOrPatchCode), debugstr_w(szUserSid),
1359 dwContext, dwOptions, debugstr_w(szSource));
1360 return ERROR_SUCCESS;
1361 }