clusapi: Don't trace the contents of output pointers.
[wine] / dlls / 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 }