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