git.oblomov.eu Git - wine/blob - 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 }