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