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