msi: Add tests for enumerating the source list after publishing.
[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     static const WCHAR szSourceList[] = {'S','o','u','r','c','e','L','i','s','t',0};
61
62     if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
63     {
64         if (dwOptions == MSICODE_PATCH)
65             rc = MSIREG_OpenUserPatchesKey(szProduct, &rootkey, create);
66         else
67             rc = MSIREG_OpenUserProductsKey(szProduct, &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_OpenLocalManagedProductKey(szProduct, &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_OpenLocalClassesProductKey(szProduct, &rootkey, create);
82     }
83
84     if (rc)
85     {
86         if (dwOptions == MSICODE_PATCH)
87             return ERROR_UNKNOWN_PATCH;
88         else
89             return ERROR_UNKNOWN_PRODUCT;
90     }
91
92     if (create)
93         rc = RegCreateKeyW(rootkey, szSourceList, key);
94     else
95     {
96         rc = RegOpenKeyW(rootkey,szSourceList, key);
97         if (rc != ERROR_SUCCESS)
98             rc = ERROR_BAD_CONFIGURATION;
99     }
100
101     return rc;
102 }
103
104 static UINT OpenMediaSubkey(HKEY rootkey, HKEY *key, BOOL create)
105 {
106     UINT rc;
107     static const WCHAR media[] = {'M','e','d','i','a',0};
108
109     if (create)
110         rc = RegCreateKeyW(rootkey, media, key);
111     else
112         rc = RegOpenKeyW(rootkey,media, key); 
113
114     return rc;
115 }
116
117 static UINT OpenNetworkSubkey(HKEY rootkey, HKEY *key, BOOL create)
118 {
119     UINT rc;
120     static const WCHAR net[] = {'N','e','t',0};
121
122     if (create)
123         rc = RegCreateKeyW(rootkey, net, key);
124     else
125         rc = RegOpenKeyW(rootkey, net, key); 
126
127     return rc;
128 }
129
130 static UINT OpenURLSubkey(HKEY rootkey, HKEY *key, BOOL create)
131 {
132     UINT rc;
133     static const WCHAR URL[] = {'U','R','L',0};
134
135     if (create)
136         rc = RegCreateKeyW(rootkey, URL, key);
137     else
138         rc = RegOpenKeyW(rootkey, URL, key); 
139
140     return rc;
141 }
142
143 /******************************************************************
144  *  MsiSourceListEnumSourcesA   (MSI.@)
145  */
146 UINT WINAPI MsiSourceListEnumSourcesA(LPCSTR szProductCodeOrPatch, LPCSTR szUserSid,
147                                       MSIINSTALLCONTEXT dwContext,
148                                       DWORD dwOptions, DWORD dwIndex,
149                                       LPSTR szSource, LPDWORD pcchSource)
150 {
151     FIXME("(%s, %s, %d, %d, %d, %p, %p): stub!\n", szProductCodeOrPatch, szUserSid,
152           dwContext, dwOptions, dwIndex, szSource, pcchSource);
153     return ERROR_CALL_NOT_IMPLEMENTED;
154 }
155
156 /******************************************************************
157  *  MsiSourceListGetInfoA   (MSI.@)
158  */
159 UINT WINAPI MsiSourceListGetInfoA( LPCSTR szProduct, LPCSTR szUserSid,
160                                    MSIINSTALLCONTEXT dwContext, DWORD dwOptions,
161                                    LPCSTR szProperty, LPSTR szValue,
162                                    LPDWORD pcchValue)
163 {
164     UINT ret;
165     LPWSTR product = NULL;
166     LPWSTR usersid = NULL;
167     LPWSTR property = NULL;
168     LPWSTR value = NULL;
169     DWORD len = 0;
170
171     if (szValue && !pcchValue)
172         return ERROR_INVALID_PARAMETER;
173
174     if (szProduct) product = strdupAtoW(szProduct);
175     if (szUserSid) usersid = strdupAtoW(szUserSid);
176     if (szProperty) property = strdupAtoW(szProperty);
177
178     ret = MsiSourceListGetInfoW(product, usersid, dwContext, dwOptions,
179                                 property, NULL, &len);
180     if (ret != ERROR_SUCCESS)
181         goto done;
182
183     value = msi_alloc(++len * sizeof(WCHAR));
184     if (!value)
185         return ERROR_OUTOFMEMORY;
186
187     *value = '\0';
188     ret = MsiSourceListGetInfoW(product, usersid, dwContext, dwOptions,
189                                 property, value, &len);
190     if (ret != ERROR_SUCCESS)
191         goto done;
192
193     len = WideCharToMultiByte(CP_ACP, 0, value, -1, NULL, 0, NULL, NULL);
194     if (*pcchValue >= len)
195         WideCharToMultiByte(CP_ACP, 0, value, -1, szValue, len, NULL, NULL);
196     else if (szValue)
197         ret = ERROR_MORE_DATA;
198
199     *pcchValue = len - 1;
200
201 done:
202     msi_free(product);
203     msi_free(usersid);
204     msi_free(property);
205     msi_free(value);
206     return ret;
207 }
208
209 /******************************************************************
210  *  MsiSourceListGetInfoW   (MSI.@)
211  */
212 UINT WINAPI MsiSourceListGetInfoW( LPCWSTR szProduct, LPCWSTR szUserSid,
213                                    MSIINSTALLCONTEXT dwContext, DWORD dwOptions,
214                                    LPCWSTR szProperty, LPWSTR szValue, 
215                                    LPDWORD pcchValue) 
216 {
217     HKEY sourcekey;
218     UINT rc;
219
220     TRACE("%s %s\n", debugstr_w(szProduct), debugstr_w(szProperty));
221
222     if (!szProduct || !*szProduct)
223         return ERROR_INVALID_PARAMETER;
224
225     if (lstrlenW(szProduct) != GUID_SIZE - 1 ||
226         (szProduct[0] != '{' && szProduct[GUID_SIZE - 2] != '}'))
227         return ERROR_INVALID_PARAMETER;
228
229     if (szValue && !pcchValue)
230         return ERROR_INVALID_PARAMETER;
231
232     if (dwContext != MSIINSTALLCONTEXT_USERMANAGED &&
233         dwContext != MSIINSTALLCONTEXT_USERUNMANAGED &&
234         dwContext != MSIINSTALLCONTEXT_MACHINE)
235         return ERROR_INVALID_PARAMETER;
236
237     if (!szProperty)
238         return ERROR_INVALID_PARAMETER;
239
240     if (szUserSid)
241         FIXME("Unhandled UserSid %s\n",debugstr_w(szUserSid));
242
243     if (dwContext != MSIINSTALLCONTEXT_USERUNMANAGED)
244         FIXME("Unhandled context %d\n", dwContext);
245
246     rc = OpenSourceKey(szProduct, &sourcekey, dwOptions, dwContext, FALSE);
247     if (rc != ERROR_SUCCESS)
248         return rc;
249
250     if (strcmpW(szProperty, INSTALLPROPERTY_MEDIAPACKAGEPATHW) == 0)
251     {
252         HKEY key;
253         rc = OpenMediaSubkey(sourcekey, &key, FALSE);
254         if (rc == ERROR_SUCCESS)
255             rc = RegQueryValueExW(key, INSTALLPROPERTY_MEDIAPACKAGEPATHW,
256                     0, 0, (LPBYTE)szValue, pcchValue);
257         if (rc != ERROR_SUCCESS && rc != ERROR_MORE_DATA)
258             rc = ERROR_UNKNOWN_PROPERTY;
259         RegCloseKey(key);
260     }
261     else if (strcmpW(szProperty, INSTALLPROPERTY_DISKPROMPTW) ==0)
262     {
263         HKEY key;
264         rc = OpenMediaSubkey(sourcekey, &key, FALSE);
265         if (rc == ERROR_SUCCESS)
266             rc = RegQueryValueExW(key, INSTALLPROPERTY_DISKPROMPTW, 0, 0,
267                     (LPBYTE)szValue, pcchValue);
268         if (rc != ERROR_SUCCESS && rc != ERROR_MORE_DATA)
269             rc = ERROR_UNKNOWN_PROPERTY;
270         RegCloseKey(key);
271     }
272     else if (strcmpW(szProperty, INSTALLPROPERTY_LASTUSEDSOURCEW)==0)
273     {
274         LPWSTR buffer;
275         DWORD size = 0;
276
277         RegQueryValueExW(sourcekey, INSTALLPROPERTY_LASTUSEDSOURCEW, 0, 0,
278                 NULL, &size);
279         if (size == 0)
280             rc = ERROR_UNKNOWN_PROPERTY;
281         else
282         {
283             LPWSTR ptr;
284             buffer = msi_alloc(size);
285             rc = RegQueryValueExW(sourcekey, INSTALLPROPERTY_LASTUSEDSOURCEW,
286                     0, 0, (LPBYTE)buffer,&size); 
287             ptr = strchrW(buffer,';');
288             if (ptr) ptr = strchrW(ptr+1,';');
289             if (!ptr)
290                 rc = ERROR_UNKNOWN_PROPERTY;
291             else
292             {
293                 ptr ++;
294                 lstrcpynW(szValue, ptr, *pcchValue);
295                 if (lstrlenW(ptr) > *pcchValue)
296                 {
297                     *pcchValue = lstrlenW(ptr)+1;
298                     rc = ERROR_MORE_DATA;
299                 }
300                 else
301                     rc = ERROR_SUCCESS;
302             }
303             msi_free(buffer);
304         }
305     }
306     else if (strcmpW(INSTALLPROPERTY_LASTUSEDTYPEW, szProperty)==0)
307     {
308         LPWSTR buffer;
309         DWORD size = 0;
310
311         RegQueryValueExW(sourcekey, INSTALLPROPERTY_LASTUSEDSOURCEW, 0, 0,
312                 NULL, &size);
313         if (size == 0)
314             rc = ERROR_UNKNOWN_PROPERTY;
315         else
316         {
317             buffer = msi_alloc(size);
318             rc = RegQueryValueExW(sourcekey, INSTALLPROPERTY_LASTUSEDSOURCEW,
319                     0, 0, (LPBYTE)buffer,&size); 
320             if (*pcchValue < 1)
321             {
322                 rc = ERROR_MORE_DATA;
323                 *pcchValue = 1;
324             }
325             else
326             {
327                 szValue[0] = buffer[0];
328                 rc = ERROR_SUCCESS;
329             }
330             msi_free(buffer);
331         }
332     }
333     else if (strcmpW(INSTALLPROPERTY_PACKAGENAMEW, szProperty)==0)
334     {
335         *pcchValue = *pcchValue * sizeof(WCHAR);
336         rc = RegQueryValueExW(sourcekey, INSTALLPROPERTY_PACKAGENAMEW, 0, 0,
337                               (LPBYTE)szValue, pcchValue);
338         if (rc != ERROR_SUCCESS && rc != ERROR_MORE_DATA)
339         {
340             *pcchValue = 0;
341             rc = ERROR_SUCCESS;
342         }
343         else
344         {
345             if (*pcchValue)
346                 *pcchValue = (*pcchValue - 1) / sizeof(WCHAR);
347             if (szValue)
348                 szValue[*pcchValue] = '\0';
349         }
350     }
351     else
352     {
353         FIXME("Unknown property %s\n",debugstr_w(szProperty));
354         rc = ERROR_UNKNOWN_PROPERTY;
355     }
356
357     RegCloseKey(sourcekey);
358     return rc;
359 }
360
361 /******************************************************************
362  *  MsiSourceListSetInfoW   (MSI.@)
363  */
364 UINT WINAPI MsiSourceListSetInfoW( LPCWSTR szProduct, LPCWSTR szUserSid,
365                                    MSIINSTALLCONTEXT dwContext, DWORD dwOptions,
366                                    LPCWSTR szProperty, LPCWSTR szValue)
367 {
368     HKEY sourcekey;
369     UINT rc;
370
371     TRACE("%s %s %x %x %s %s\n", debugstr_w(szProduct), debugstr_w(szUserSid),
372             dwContext, dwOptions, debugstr_w(szProperty), debugstr_w(szValue));
373
374     if (!szProduct || lstrlenW(szProduct) > 39)
375         return ERROR_INVALID_PARAMETER;
376
377     if (dwOptions & MSICODE_PATCH)
378     {
379         FIXME("Unhandled options MSICODE_PATCH\n");
380         return ERROR_FUNCTION_FAILED;
381     }
382     
383     if (szUserSid)
384         FIXME("Unhandled UserSid %s\n",debugstr_w(szUserSid));
385
386     if (dwContext == MSIINSTALLCONTEXT_USERUNMANAGED)
387         FIXME("Unknown context MSIINSTALLCONTEXT_USERUNMANAGED\n");
388
389     rc = OpenSourceKey(szProduct, &sourcekey, MSICODE_PRODUCT, dwContext, TRUE);
390     if (rc != ERROR_SUCCESS)
391         return ERROR_UNKNOWN_PRODUCT;
392
393
394     if (strcmpW(szProperty, INSTALLPROPERTY_MEDIAPACKAGEPATHW) == 0)
395     {
396         HKEY key;
397         DWORD size = lstrlenW(szValue)*sizeof(WCHAR);
398         rc = OpenMediaSubkey(sourcekey, &key, FALSE);
399         if (rc == ERROR_SUCCESS)
400             rc = RegSetValueExW(key, INSTALLPROPERTY_MEDIAPACKAGEPATHW, 0,
401                     REG_SZ, (const BYTE *)szValue, size);
402         if (rc != ERROR_SUCCESS)
403             rc = ERROR_UNKNOWN_PROPERTY;
404         RegCloseKey(key);
405     }
406     else if (strcmpW(szProperty, INSTALLPROPERTY_DISKPROMPTW) == 0)
407     {
408         HKEY key;
409         DWORD size = lstrlenW(szValue)*sizeof(WCHAR);
410         rc = OpenMediaSubkey(sourcekey, &key, FALSE);
411         if (rc == ERROR_SUCCESS)
412             rc = RegSetValueExW(key, INSTALLPROPERTY_DISKPROMPTW, 0,
413                     REG_SZ, (const BYTE *)szValue, size);
414         if (rc != ERROR_SUCCESS)
415             rc = ERROR_UNKNOWN_PROPERTY;
416         RegCloseKey(key);
417     }
418     else if (strcmpW(szProperty, INSTALLPROPERTY_LASTUSEDSOURCEW)==0)
419     {
420         LPWSTR buffer = NULL;
421         DWORD size;
422         WCHAR typechar = 'n';
423         static const WCHAR LastUsedSource_Fmt[] = {'%','c',';','%','i',';','%','s',0};
424
425         /* make sure the source is registered */
426         MsiSourceListAddSourceExW(szProduct, szUserSid, dwContext, 
427                 dwOptions, szValue, 0); 
428
429         if (dwOptions & MSISOURCETYPE_NETWORK)
430             typechar = 'n';
431         else if (dwOptions & MSISOURCETYPE_URL)
432             typechar = 'u';
433         else if (dwOptions & MSISOURCETYPE_MEDIA)
434             typechar = 'm';
435         else
436             ERR("Unknown source type! %x\n", dwOptions);
437
438         size = (lstrlenW(szValue)+5)*sizeof(WCHAR);
439         buffer = msi_alloc(size);
440         sprintfW(buffer, LastUsedSource_Fmt, typechar, 1, szValue);
441         rc = RegSetValueExW(sourcekey, INSTALLPROPERTY_LASTUSEDSOURCEW, 0, 
442                 REG_EXPAND_SZ, (LPBYTE)buffer, size);
443         if (rc != ERROR_SUCCESS)
444             rc = ERROR_UNKNOWN_PROPERTY;
445         msi_free( buffer );
446     }
447     else if (strcmpW(INSTALLPROPERTY_PACKAGENAMEW, szProperty)==0)
448     {
449         DWORD size = lstrlenW(szValue)*sizeof(WCHAR);
450         rc = RegSetValueExW(sourcekey, INSTALLPROPERTY_PACKAGENAMEW, 0,
451                 REG_SZ, (const BYTE *)szValue, size);
452         if (rc != ERROR_SUCCESS)
453             rc = ERROR_UNKNOWN_PROPERTY;
454     }
455     else
456     {
457         FIXME("Unknown property %s\n",debugstr_w(szProperty));
458         rc = ERROR_UNKNOWN_PROPERTY;
459     }
460
461     RegCloseKey(sourcekey);
462     return rc;
463
464 }
465
466 /******************************************************************
467  *  MsiSourceListAddSourceW (MSI.@)
468  */
469 UINT WINAPI MsiSourceListAddSourceW( LPCWSTR szProduct, LPCWSTR szUserName,
470         DWORD dwReserved, LPCWSTR szSource)
471 {
472     INT ret;
473     LPWSTR sidstr = NULL;
474     DWORD sidsize = 0;
475     DWORD domsize = 0;
476
477     TRACE("%s %s %s\n", debugstr_w(szProduct), debugstr_w(szUserName), debugstr_w(szSource));
478
479     if (LookupAccountNameW(NULL, szUserName, NULL, &sidsize, NULL, &domsize, NULL))
480     {
481         PSID psid = msi_alloc(sidsize);
482
483         if (LookupAccountNameW(NULL, szUserName, psid, &sidsize, NULL, &domsize, NULL))
484             ConvertSidToStringSidW(psid, &sidstr);
485
486         msi_free(psid);
487     }
488
489     ret = MsiSourceListAddSourceExW(szProduct, sidstr, 
490         MSIINSTALLCONTEXT_USERMANAGED, MSISOURCETYPE_NETWORK, szSource, 0);
491
492     if (sidstr)
493         LocalFree(sidstr);
494
495     return ret;
496 }
497
498 /******************************************************************
499  *  MsiSourceListAddSourceA (MSI.@)
500  */
501 UINT WINAPI MsiSourceListAddSourceA( LPCSTR szProduct, LPCSTR szUserName,
502         DWORD dwReserved, LPCSTR szSource)
503 {
504     INT ret;
505     LPWSTR szwproduct;
506     LPWSTR szwusername;
507     LPWSTR szwsource;
508
509     szwproduct = strdupAtoW( szProduct );
510     szwusername = strdupAtoW( szUserName );
511     szwsource = strdupAtoW( szSource );
512
513     ret = MsiSourceListAddSourceW(szwproduct, szwusername, 0, szwsource);
514
515     msi_free(szwproduct);
516     msi_free(szwusername);
517     msi_free(szwsource);
518
519     return ret;
520 }
521
522 /******************************************************************
523  *  MsiSourceListAddSourceExA (MSI.@)
524  */
525 UINT WINAPI MsiSourceListAddSourceExA(LPCSTR szProduct, LPCSTR szUserSid,
526         MSIINSTALLCONTEXT dwContext, DWORD dwOptions, LPCSTR szSource, DWORD dwIndex)
527 {
528     UINT ret;
529     LPWSTR product, usersid, source;
530
531     product = strdupAtoW(szProduct);
532     usersid = strdupAtoW(szUserSid);
533     source = strdupAtoW(szSource);
534
535     ret = MsiSourceListAddSourceExW(product, usersid, dwContext,
536                                     dwOptions, source, dwIndex);
537
538     msi_free(product);
539     msi_free(usersid);
540     msi_free(source);
541
542     return ret;
543 }
544
545 static void free_source_list(struct list *sourcelist)
546 {
547     while (!list_empty(sourcelist))
548     {
549         media_info *info = LIST_ENTRY(list_head(sourcelist), media_info, entry);
550         list_remove(&info->entry);
551         msi_free(info->path);
552         msi_free(info);
553     }
554 }
555
556 static void add_source_to_list(struct list *sourcelist, media_info *info)
557 {
558     media_info *iter;
559     BOOL found = FALSE;
560     static const WCHAR fmt[] = {'%','i',0};
561
562     if (list_empty(sourcelist))
563     {
564         list_add_head(sourcelist, &info->entry);
565         return;
566     }
567
568     LIST_FOR_EACH_ENTRY(iter, sourcelist, media_info, entry)
569     {
570         if (!found && info->index < iter->index)
571         {
572             found = TRUE;
573             list_add_before(&iter->entry, &info->entry);
574         }
575
576         /* update the rest of the list */
577         if (found)
578             sprintfW(iter->szIndex, fmt, ++iter->index);
579     }
580
581     if (!found)
582         list_add_after(&iter->entry, &info->entry);
583 }
584
585 static UINT fill_source_list(struct list *sourcelist, HKEY sourcekey, DWORD *count)
586 {
587     UINT r = ERROR_SUCCESS;
588     DWORD index = 0;
589     WCHAR name[10];
590     DWORD size, val_size;
591     media_info *entry;
592
593     *count = 0;
594
595     while (r == ERROR_SUCCESS)
596     {
597         size = sizeof(name) / sizeof(name[0]);
598         r = RegEnumValueW(sourcekey, index, name, &size, NULL, NULL, NULL, &val_size);
599         if (r != ERROR_SUCCESS)
600             return r;
601
602         entry = msi_alloc(sizeof(media_info));
603         if (!entry)
604             goto error;
605
606         entry->path = msi_alloc(val_size);
607         if (!entry->path)
608         {
609             msi_free(entry);
610             goto error;
611         }
612
613         lstrcpyW(entry->szIndex, name);
614         entry->index = atoiW(name);
615
616         size++;
617         r = RegEnumValueW(sourcekey, index, name, &size, NULL,
618                           NULL, (LPBYTE)entry->path, &val_size);
619         if (r != ERROR_SUCCESS)
620         {
621             msi_free(entry->path);
622             msi_free(entry);
623             goto error;
624         }
625
626         index = ++(*count);
627         add_source_to_list(sourcelist, entry);
628     }
629
630 error:
631     *count = -1;
632     free_source_list(sourcelist);
633     return ERROR_OUTOFMEMORY;
634 }
635
636 /******************************************************************
637  *  MsiSourceListAddSourceExW (MSI.@)
638  */
639 UINT WINAPI MsiSourceListAddSourceExW( LPCWSTR szProduct, LPCWSTR szUserSid,
640         MSIINSTALLCONTEXT dwContext, DWORD dwOptions, LPCWSTR szSource, 
641         DWORD dwIndex)
642 {
643     HKEY sourcekey;
644     HKEY typekey;
645     UINT rc;
646     struct list sourcelist;
647     media_info *info;
648     WCHAR squished_pc[GUID_SIZE];
649     WCHAR name[10];
650     LPWSTR source;
651     LPCWSTR postfix;
652     DWORD size, count;
653
654     static const WCHAR fmt[] = {'%','i',0};
655     static const WCHAR one[] = {'1',0};
656     static const WCHAR backslash[] = {'\\',0};
657     static const WCHAR forwardslash[] = {'/',0};
658
659     TRACE("%s %s %x %x %s %i\n", debugstr_w(szProduct), debugstr_w(szUserSid),
660           dwContext, dwOptions, debugstr_w(szSource), dwIndex);
661
662     if (!szProduct || !squash_guid(szProduct, squished_pc))
663         return ERROR_INVALID_PARAMETER;
664
665     if (!szSource || !*szSource)
666         return ERROR_INVALID_PARAMETER;
667
668     if (!(dwOptions & (MSISOURCETYPE_NETWORK | MSISOURCETYPE_URL)))
669         return ERROR_INVALID_PARAMETER;
670
671     if (dwOptions & MSICODE_PATCH)
672     {
673         FIXME("Unhandled options MSICODE_PATCH\n");
674         return ERROR_FUNCTION_FAILED;
675     }
676
677     if (szUserSid && (dwContext & MSIINSTALLCONTEXT_MACHINE))
678         return ERROR_INVALID_PARAMETER;
679
680     rc = OpenSourceKey(szProduct, &sourcekey, MSICODE_PRODUCT, dwContext, FALSE);
681     if (rc != ERROR_SUCCESS)
682         return rc;
683
684     if (dwOptions & MSISOURCETYPE_NETWORK)
685         rc = OpenNetworkSubkey(sourcekey, &typekey, TRUE);
686     else if (dwOptions & MSISOURCETYPE_URL)
687         rc = OpenURLSubkey(sourcekey, &typekey, TRUE);
688     else if (dwOptions & MSISOURCETYPE_MEDIA)
689         rc = OpenMediaSubkey(sourcekey, &typekey, TRUE);
690     else
691     {
692         ERR("unknown media type: %08x\n", dwOptions);
693         RegCloseKey(sourcekey);
694         return ERROR_FUNCTION_FAILED;
695     }
696
697     postfix = (dwOptions & MSISOURCETYPE_NETWORK) ? backslash : forwardslash;
698     if (szSource[lstrlenW(szSource) - 1] == *postfix)
699         source = strdupW(szSource);
700     else
701     {
702         size = lstrlenW(szSource) + 2;
703         source = msi_alloc(size * sizeof(WCHAR));
704         lstrcpyW(source, szSource);
705         lstrcatW(source, postfix);
706     }
707
708     list_init(&sourcelist);
709     rc = fill_source_list(&sourcelist, typekey, &count);
710     if (rc != ERROR_NO_MORE_ITEMS)
711         return rc;
712
713     size = (lstrlenW(source) + 1) * sizeof(WCHAR);
714
715     if (count == 0)
716     {
717         rc = RegSetValueExW(typekey, one, 0, REG_EXPAND_SZ, (LPBYTE)source, size);
718         goto done;
719     }
720     else if (dwIndex > count)
721     {
722         sprintfW(name, fmt, count + 1);
723         rc = RegSetValueExW(typekey, name, 0, REG_EXPAND_SZ, (LPBYTE)source, size);
724         goto done;
725     }
726     else
727     {
728         /* add to the end of the list */
729         if (dwIndex == 0)
730             dwIndex = count + 1;
731
732         sprintfW(name, fmt, dwIndex);
733         info = msi_alloc(sizeof(media_info));
734         if (!info)
735         {
736             rc = ERROR_OUTOFMEMORY;
737             goto done;
738         }
739
740         info->path = strdupW(source);
741         lstrcpyW(info->szIndex, name);
742         info->index = dwIndex;
743         add_source_to_list(&sourcelist, info);
744
745         LIST_FOR_EACH_ENTRY(info, &sourcelist, media_info, entry)
746         {
747             size = (lstrlenW(info->path) + 1) * sizeof(WCHAR);
748             rc = RegSetValueExW(typekey, info->szIndex, 0,
749                                 REG_EXPAND_SZ, (LPBYTE)info->path, size);
750             if (rc != ERROR_SUCCESS)
751                 goto done;
752         }
753     }
754
755 done:
756     free_source_list(&sourcelist);
757     msi_free(source);
758     RegCloseKey(typekey);
759     RegCloseKey(sourcekey);
760     return rc;
761 }
762
763 /******************************************************************
764  *  MsiSourceListAddMediaDisk(MSI.@)
765  */
766 UINT WINAPI MsiSourceListAddMediaDiskW(LPCWSTR szProduct, LPCWSTR szUserSid, 
767         MSIINSTALLCONTEXT dwContext, DWORD dwOptions, DWORD dwDiskId, 
768         LPCWSTR szVolumeLabel, LPCWSTR szDiskPrompt)
769 {
770     HKEY sourcekey;
771     HKEY mediakey;
772     UINT rc;
773     WCHAR szIndex[10];
774     static const WCHAR fmt[] = {'%','i',0};
775     static const WCHAR disk_fmt[] = {'%','s',';','%','s',0};
776     static const WCHAR empty[1] = {0};
777     LPCWSTR pt1,pt2;
778     LPWSTR buffer;
779     DWORD size;
780
781     TRACE("%s %s %x %x %i %s %s\n", debugstr_w(szProduct),
782             debugstr_w(szUserSid), dwContext, dwOptions, dwDiskId,
783             debugstr_w(szVolumeLabel), debugstr_w(szDiskPrompt));
784
785     if (!szProduct || lstrlenW(szProduct) > 39)
786         return ERROR_INVALID_PARAMETER;
787
788     if (dwOptions & MSICODE_PATCH)
789     {
790         FIXME("Unhandled options MSICODE_PATCH\n");
791         return ERROR_FUNCTION_FAILED;
792     }
793     
794     if (szUserSid)
795         FIXME("Unhandled UserSid %s\n",debugstr_w(szUserSid));
796
797     if (dwContext == MSIINSTALLCONTEXT_USERUNMANAGED)
798         FIXME("Unknown context MSIINSTALLCONTEXT_USERUNMANAGED\n");
799
800     rc = OpenSourceKey(szProduct, &sourcekey, MSICODE_PRODUCT, dwContext, TRUE);
801     if (rc != ERROR_SUCCESS)
802         return ERROR_UNKNOWN_PRODUCT;
803
804     OpenMediaSubkey(sourcekey,&mediakey,TRUE);
805
806     sprintfW(szIndex,fmt,dwDiskId);
807
808     size = 2;
809     if (szVolumeLabel)
810     {
811         size +=lstrlenW(szVolumeLabel);
812         pt1 = szVolumeLabel;
813     }
814     else
815         pt1 = empty;
816     if (szDiskPrompt)
817     {
818         size +=lstrlenW(szDiskPrompt);
819         pt2 = szDiskPrompt;
820     }
821     else
822         pt2 = empty;
823
824     size *=sizeof(WCHAR);
825
826     buffer = msi_alloc(size);
827     sprintfW(buffer,disk_fmt,pt1,pt2);
828
829     RegSetValueExW(mediakey, szIndex, 0, REG_SZ, (LPBYTE)buffer, size);
830     msi_free( buffer );
831
832     RegCloseKey(sourcekey);
833     RegCloseKey(mediakey);
834
835     return ERROR_SUCCESS;
836 }
837
838 /******************************************************************
839  *  MsiSourceListClearAllA (MSI.@)
840  */
841 UINT WINAPI MsiSourceListClearAllA( LPCSTR szProduct, LPCSTR szUserName, DWORD dwReserved )
842 {
843     FIXME("(%s %s %d)\n", debugstr_a(szProduct), debugstr_a(szUserName), dwReserved);
844     return ERROR_SUCCESS;
845 }
846
847 /******************************************************************
848  *  MsiSourceListClearAllW (MSI.@)
849  */
850 UINT WINAPI MsiSourceListClearAllW( LPCWSTR szProduct, LPCWSTR szUserName, DWORD dwReserved )
851 {
852     FIXME("(%s %s %d)\n", debugstr_w(szProduct), debugstr_w(szUserName), dwReserved);
853     return ERROR_SUCCESS;
854 }