dll/win32/msi/assembly.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2010 Hans Leidekker for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "msipriv.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  24
  25 static HRESULT (WINAPI *pCreateAssemblyCacheNet10)( IAssemblyCache **, DWORD );
  26 static HRESULT (WINAPI *pCreateAssemblyCacheNet11)( IAssemblyCache **, DWORD );
  27 static HRESULT (WINAPI *pCreateAssemblyCacheNet20)( IAssemblyCache **, DWORD );
  28 static HRESULT (WINAPI *pCreateAssemblyCacheNet40)( IAssemblyCache **, DWORD );
  29 static HRESULT (WINAPI *pCreateAssemblyCacheSxs)( IAssemblyCache **, DWORD );
  30 static HRESULT (WINAPI *pLoadLibraryShim)( LPCWSTR, LPCWSTR, LPVOID, HMODULE * );
  31 static HRESULT (WINAPI *pGetFileVersion)( LPCWSTR, LPWSTR, DWORD, DWORD * );
  32 static HRESULT (WINAPI *pCreateAssemblyNameObject)( IAssemblyName **, LPCWSTR, DWORD, LPVOID );
  33 static HRESULT (WINAPI *pCreateAssemblyEnum)( IAssemblyEnum **, IUnknown *, IAssemblyName *, DWORD, LPVOID );
  34
  35 static HMODULE hfusion10, hfusion11, hfusion20, hfusion40, hmscoree, hsxs;
  36
  37 static BOOL init_function_pointers( void )
  38 {
  39     static const WCHAR szFusion[]    = {'f','u','s','i','o','n','.','d','l','l',0};
  40     static const WCHAR szMscoree[]   = {'\\','m','s','c','o','r','e','e','.','d','l','l',0};
  41     static const WCHAR szSxs[]       = {'s','x','s','.','d','l','l',0};
  42     static const WCHAR szVersion10[] = {'v','1','.','0','.','3','7','0','5',0};
  43     static const WCHAR szVersion11[] = {'v','1','.','1','.','4','3','2','2',0};
  44     static const WCHAR szVersion20[] = {'v','2','.','0','.','5','0','7','2','7',0};
  45     static const WCHAR szVersion40[] = {'v','4','.','0','.','3','0','3','1','9',0};
  46     WCHAR path[MAX_PATH];
  47     DWORD len = GetSystemDirectoryW( path, MAX_PATH );
  48
  49     if (!hsxs && !(hsxs = LoadLibraryW( szSxs ))) return FALSE;
  50     if (!(pCreateAssemblyCacheSxs = (void *)GetProcAddress( hsxs, "CreateAssemblyCache" )))
  51     {
  52         FreeLibrary( hsxs );
  53         hsxs = NULL;
  54         return FALSE;
  55     }
  56     strcpyW( path + len, szMscoree );
  57     if (hmscoree || !(hmscoree = LoadLibraryW( path ))) return TRUE;
  58     pGetFileVersion = (void *)GetProcAddress( hmscoree, "GetFileVersion" ); /* missing from v1.0.3705 */
  59     if (!(pLoadLibraryShim = (void *)GetProcAddress( hmscoree, "LoadLibraryShim" )))
  60     {
  61         FreeLibrary( hmscoree );
  62         hmscoree = NULL;
  63         return TRUE;
  64     }
  65     if (!pLoadLibraryShim( szFusion, szVersion10, NULL, &hfusion10 ))
  66         pCreateAssemblyCacheNet10 = (void *)GetProcAddress( hfusion10, "CreateAssemblyCache" );
  67
  68     if (!pLoadLibraryShim( szFusion, szVersion11, NULL, &hfusion11 ))
  69         pCreateAssemblyCacheNet11 = (void *)GetProcAddress( hfusion11, "CreateAssemblyCache" );
  70
  71     if (!pLoadLibraryShim( szFusion, szVersion20, NULL, &hfusion20 ))
  72         pCreateAssemblyCacheNet20 = (void *)GetProcAddress( hfusion20, "CreateAssemblyCache" );
  73
  74     if (!pLoadLibraryShim( szFusion, szVersion40, NULL, &hfusion40 ))
  75     {
  76         pCreateAssemblyCacheNet40 = (void *)GetProcAddress( hfusion40, "CreateAssemblyCache" );
  77         pCreateAssemblyNameObject = (void *)GetProcAddress( hfusion40, "CreateAssemblyNameObject" );
  78         pCreateAssemblyEnum = (void *)GetProcAddress( hfusion40, "CreateAssemblyEnum" );
  79     }
  80     return TRUE;
  81 }
  82
  83 BOOL msi_init_assembly_caches( MSIPACKAGE *package )
  84 {
  85     if (!init_function_pointers()) return FALSE;
  86     if (pCreateAssemblyCacheSxs( &package->cache_sxs, 0 ) != S_OK) return FALSE;
  87     if (pCreateAssemblyCacheNet10) pCreateAssemblyCacheNet10( &package->cache_net[CLR_VERSION_V10], 0 );
  88     if (pCreateAssemblyCacheNet11) pCreateAssemblyCacheNet11( &package->cache_net[CLR_VERSION_V11], 0 );
  89     if (pCreateAssemblyCacheNet20) pCreateAssemblyCacheNet20( &package->cache_net[CLR_VERSION_V20], 0 );
  90     if (pCreateAssemblyCacheNet40) pCreateAssemblyCacheNet40( &package->cache_net[CLR_VERSION_V40], 0 );
  91     return TRUE;
  92 }
  93
  94 void msi_destroy_assembly_caches( MSIPACKAGE *package )
  95 {
  96     UINT i;
  97
  98     if (package->cache_sxs)
  99     {
 100         IAssemblyCache_Release( package->cache_sxs );
 101         package->cache_sxs = NULL;
 102     }
 103     for (i = 0; i < CLR_VERSION_MAX; i++)
 104     {
 105         if (package->cache_net[i])
 106         {
 107             IAssemblyCache_Release( package->cache_net[i] );
 108             package->cache_net[i] = NULL;
 109         }
 110     }
 111     pCreateAssemblyCacheNet10 = NULL;
 112     pCreateAssemblyCacheNet11 = NULL;
 113     pCreateAssemblyCacheNet20 = NULL;
 114     pCreateAssemblyCacheNet40 = NULL;
 115     FreeLibrary( hfusion10 );
 116     FreeLibrary( hfusion11 );
 117     FreeLibrary( hfusion20 );
 118     FreeLibrary( hfusion40 );
 119     FreeLibrary( hmscoree );
 120     FreeLibrary( hsxs );
 121     hfusion10 = NULL;
 122     hfusion11 = NULL;
 123     hfusion20 = NULL;
 124     hfusion40 = NULL;
 125     hmscoree = NULL;
 126     hsxs = NULL;
 127 }
 128
 129 static MSIRECORD *get_assembly_record( MSIPACKAGE *package, const WCHAR *comp )
 130 {
 131     static const WCHAR query[] = {
 132         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 133          '`','M','s','i','A','s','s','e','m','b','l','y','`',' ',
 134          'W','H','E','R','E',' ','`','C','o','m','p','o','n','e','n','t','_','`',
 135          ' ','=',' ','\'','%','s','\'',0};
 136     MSIQUERY *view;
 137     MSIRECORD *rec;
 138     UINT r;
 139
 140     r = MSI_OpenQuery( package->db, &view, query, comp );
 141     if (r != ERROR_SUCCESS)
 142         return NULL;
 143
 144     r = MSI_ViewExecute( view, NULL );
 145     if (r != ERROR_SUCCESS)
 146     {
 147         msiobj_release( &view->hdr );
 148         return NULL;
 149     }
 150     r = MSI_ViewFetch( view, &rec );
 151     if (r != ERROR_SUCCESS)
 152     {
 153         msiobj_release( &view->hdr );
 154         return NULL;
 155     }
 156     if (!MSI_RecordGetString( rec, 4 ))
 157         TRACE("component is a global assembly\n");
 158
 159     msiobj_release( &view->hdr );
 160     return rec;
 161 }
 162
 163 struct assembly_name
 164 {
 165     UINT    count;
 166     UINT    index;
 167     WCHAR **attrs;
 168 };
 169
 170 static UINT get_assembly_name_attribute( MSIRECORD *rec, LPVOID param )
 171 {
 172     static const WCHAR fmtW[] = {'%','s','=','"','%','s','"',0};
 173     static const WCHAR nameW[] = {'n','a','m','e',0};
 174     struct assembly_name *name = param;
 175     const WCHAR *attr = MSI_RecordGetString( rec, 2 );
 176     const WCHAR *value = MSI_RecordGetString( rec, 3 );
 177     int len = strlenW( fmtW ) + strlenW( attr ) + strlenW( value );
 178
 179     if (!(name->attrs[name->index] = msi_alloc( len * sizeof(WCHAR) )))
 180         return ERROR_OUTOFMEMORY;
 181
 182     if (!strcmpiW( attr, nameW )) strcpyW( name->attrs[name->index++], value );
 183     else sprintfW( name->attrs[name->index++], fmtW, attr, value );
 184     return ERROR_SUCCESS;
 185 }
 186
 187 static WCHAR *get_assembly_display_name( MSIDATABASE *db, const WCHAR *comp, MSIASSEMBLY *assembly )
 188 {
 189     static const WCHAR commaW[] = {',',0};
 190     static const WCHAR queryW[] = {
 191         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 192         '`','M','s','i','A','s','s','e','m','b','l','y','N','a','m','e','`',' ',
 193         'W','H','E','R','E',' ','`','C','o','m','p','o','n','e','n','t','_','`',
 194         ' ','=',' ','\'','%','s','\'',0};
 195     struct assembly_name name;
 196     WCHAR *display_name = NULL;
 197     MSIQUERY *view;
 198     UINT i, r;
 199     int len;
 200
 201     r = MSI_OpenQuery( db, &view, queryW, comp );
 202     if (r != ERROR_SUCCESS)
 203         return NULL;
 204
 205     name.count = 0;
 206     name.index = 0;
 207     name.attrs = NULL;
 208     MSI_IterateRecords( view, &name.count, NULL, NULL );
 209     if (!name.count) goto done;
 210
 211     name.attrs = msi_alloc( name.count * sizeof(WCHAR *) );
 212     if (!name.attrs) goto done;
 213
 214     MSI_IterateRecords( view, NULL, get_assembly_name_attribute, &name );
 215
 216     len = 0;
 217     for (i = 0; i < name.count; i++) len += strlenW( name.attrs[i] ) + 1;
 218
 219     display_name = msi_alloc( (len + 1) * sizeof(WCHAR) );
 220     if (display_name)
 221     {
 222         display_name[0] = 0;
 223         for (i = 0; i < name.count; i++)
 224         {
 225             strcatW( display_name, name.attrs[i] );
 226             if (i < name.count - 1) strcatW( display_name, commaW );
 227         }
 228     }
 229
 230 done:
 231     msiobj_release( &view->hdr );
 232     if (name.attrs)
 233     {
 234         for (i = 0; i < name.count; i++) msi_free( name.attrs[i] );
 235         msi_free( name.attrs );
 236     }
 237     return display_name;
 238 }
 239
 240 static BOOL is_assembly_installed( IAssemblyCache *cache, const WCHAR *display_name )
 241 {
 242     HRESULT hr;
 243     ASSEMBLY_INFO info;
 244
 245     if (!cache) return FALSE;
 246
 247     memset( &info, 0, sizeof(info) );
 248     info.cbAssemblyInfo = sizeof(info);
 249     hr = IAssemblyCache_QueryAssemblyInfo( cache, 0, display_name, &info );
 250     if (hr == S_OK /* sxs version */ || hr == E_NOT_SUFFICIENT_BUFFER)
 251     {
 252         return (info.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED);
 253     }
 254     TRACE("QueryAssemblyInfo returned 0x%08x\n", hr);
 255     return FALSE;
 256 }
 257
 258 WCHAR *msi_get_assembly_path( MSIPACKAGE *package, const WCHAR *displayname )
 259 {
 260     HRESULT hr;
 261     ASSEMBLY_INFO info;
 262     IAssemblyCache *cache = package->cache_net[CLR_VERSION_V40];
 263
 264     if (!cache) return NULL;
 265
 266     memset( &info, 0, sizeof(info) );
 267     info.cbAssemblyInfo = sizeof(info);
 268     hr = IAssemblyCache_QueryAssemblyInfo( cache, 0, displayname, &info );
 269     if (hr != E_NOT_SUFFICIENT_BUFFER) return NULL;
 270
 271     if (!(info.pszCurrentAssemblyPathBuf = msi_alloc( info.cchBuf * sizeof(WCHAR) ))) return NULL;
 272
 273     hr = IAssemblyCache_QueryAssemblyInfo( cache, 0, displayname, &info );
 274     if (FAILED( hr ))
 275     {
 276         msi_free( info.pszCurrentAssemblyPathBuf );
 277         return NULL;
 278     }
 279     TRACE("returning %s\n", debugstr_w(info.pszCurrentAssemblyPathBuf));
 280     return info.pszCurrentAssemblyPathBuf;
 281 }
 282
 283 IAssemblyEnum *msi_create_assembly_enum( MSIPACKAGE *package, const WCHAR *displayname )
 284 {
 285     HRESULT hr;
 286     IAssemblyName *name;
 287     IAssemblyEnum *ret;
 288     WCHAR *str;
 289     UINT len = 0;
 290
 291     if (!pCreateAssemblyNameObject || !pCreateAssemblyEnum) return NULL;
 292
 293     hr = pCreateAssemblyNameObject( &name, displayname, CANOF_PARSE_DISPLAY_NAME, NULL );
 294     if (FAILED( hr )) return NULL;
 295
 296     hr = IAssemblyName_GetName( name, &len, NULL );
 297     if (hr != E_NOT_SUFFICIENT_BUFFER || !(str = msi_alloc( len * sizeof(WCHAR) )))
 298     {
 299         IAssemblyName_Release( name );
 300         return NULL;
 301     }
 302
 303     hr = IAssemblyName_GetName( name, &len, str );
 304     IAssemblyName_Release( name );
 305     if (FAILED( hr ))
 306     {
 307         msi_free( str );
 308         return NULL;
 309     }
 310
 311     hr = pCreateAssemblyNameObject( &name, str, 0, NULL );
 312     msi_free( str );
 313     if (FAILED( hr )) return NULL;
 314
 315     hr = pCreateAssemblyEnum( &ret, NULL, name, ASM_CACHE_GAC, NULL );
 316     IAssemblyName_Release( name );
 317     if (FAILED( hr )) return NULL;
 318
 319     return ret;
 320 }
 321
 322 static const WCHAR clr_version_v10[] = {'v','1','.','0','.','3','7','0','5',0};
 323 static const WCHAR clr_version_v11[] = {'v','1','.','1','.','4','3','2','2',0};
 324 static const WCHAR clr_version_v20[] = {'v','2','.','0','.','5','0','7','2','7',0};
 325 static const WCHAR clr_version_v40[] = {'v','4','.','0','.','3','0','3','1','9',0};
 326 static const WCHAR clr_version_unknown[] = {'u','n','k','n','o','w','n',0};
 327
 328 static const WCHAR *clr_version[] =
 329 {
 330     clr_version_v10,
 331     clr_version_v11,
 332     clr_version_v20,
 333     clr_version_v40
 334 };
 335
 336 static const WCHAR *get_clr_version_str( enum clr_version version )
 337 {
 338     if (version >= sizeof(clr_version)/sizeof(clr_version[0])) return clr_version_unknown;
 339     return clr_version[version];
 340 }
 341
 342 /* assembly caches must be initialized */
 343 MSIASSEMBLY *msi_load_assembly( MSIPACKAGE *package, MSICOMPONENT *comp )
 344 {
 345     MSIRECORD *rec;
 346     MSIASSEMBLY *a;
 347
 348     if (!(rec = get_assembly_record( package, comp->Component ))) return NULL;
 349     if (!(a = msi_alloc_zero( sizeof(MSIASSEMBLY) )))
 350     {
 351         msiobj_release( &rec->hdr );
 352         return NULL;
 353     }
 354     a->feature = strdupW( MSI_RecordGetString( rec, 2 ) );
 355     TRACE("feature %s\n", debugstr_w(a->feature));
 356
 357     a->manifest = strdupW( MSI_RecordGetString( rec, 3 ) );
 358     TRACE("manifest %s\n", debugstr_w(a->manifest));
 359
 360     a->application = strdupW( MSI_RecordGetString( rec, 4 ) );
 361     TRACE("application %s\n", debugstr_w(a->application));
 362
 363     a->attributes = MSI_RecordGetInteger( rec, 5 );
 364     TRACE("attributes %u\n", a->attributes);
 365
 366     if (!(a->display_name = get_assembly_display_name( package->db, comp->Component, a )))
 367     {
 368         WARN("can't get display name\n");
 369         msiobj_release( &rec->hdr );
 370         msi_free( a->feature );
 371         msi_free( a->manifest );
 372         msi_free( a->application );
 373         msi_free( a );
 374         return NULL;
 375     }
 376     TRACE("display name %s\n", debugstr_w(a->display_name));
 377
 378     if (a->application)
 379     {
 380         /* We can't check the manifest here because the target path may still change.
 381            So we assume that the assembly is not installed and lean on the InstallFiles
 382            action to determine which files need to be installed.
 383          */
 384         a->installed = FALSE;
 385     }
 386     else
 387     {
 388         if (a->attributes == msidbAssemblyAttributesWin32)
 389             a->installed = is_assembly_installed( package->cache_sxs, a->display_name );
 390         else
 391         {
 392             UINT i;
 393             for (i = 0; i < CLR_VERSION_MAX; i++)
 394             {
 395                 a->clr_version[i] = is_assembly_installed( package->cache_net[i], a->display_name );
 396                 if (a->clr_version[i])
 397                 {
 398                     TRACE("runtime version %s\n", debugstr_w(get_clr_version_str( i )));
 399                     a->installed = TRUE;
 400                     break;
 401                 }
 402             }
 403         }
 404     }
 405     TRACE("assembly is %s\n", a->installed ? "installed" : "not installed");
 406     msiobj_release( &rec->hdr );
 407     return a;
 408 }
 409
 410 static enum clr_version get_clr_version( const WCHAR *filename )
 411 {
 412     DWORD len;
 413     HRESULT hr;
 414     enum clr_version version = CLR_VERSION_V11;
 415     WCHAR *strW;
 416
 417     if (!pGetFileVersion) return CLR_VERSION_V10;
 418
 419     hr = pGetFileVersion( filename, NULL, 0, &len );
 420     if (hr != E_NOT_SUFFICIENT_BUFFER) return CLR_VERSION_V11;
 421     if ((strW = msi_alloc( len * sizeof(WCHAR) )))
 422     {
 423         hr = pGetFileVersion( filename, strW, len, &len );
 424         if (hr == S_OK)
 425         {
 426             UINT i;
 427             for (i = 0; i < CLR_VERSION_MAX; i++)
 428                 if (!strcmpW( strW, clr_version[i] )) version = i;
 429         }
 430         msi_free( strW );
 431     }
 432     return version;
 433 }
 434
 435 UINT msi_install_assembly( MSIPACKAGE *package, MSICOMPONENT *comp )
 436 {
 437     HRESULT hr;
 438     const WCHAR *manifest;
 439     IAssemblyCache *cache;
 440     MSIASSEMBLY *assembly = comp->assembly;
 441     MSIFEATURE *feature = NULL;
 442
 443     if (comp->assembly->feature)
 444         feature = msi_get_loaded_feature( package, comp->assembly->feature );
 445
 446     if (assembly->application)
 447     {
 448         if (feature) feature->Action = INSTALLSTATE_LOCAL;
 449         return ERROR_SUCCESS;
 450     }
 451     if (assembly->attributes == msidbAssemblyAttributesWin32)
 452     {
 453         if (!assembly->manifest)
 454         {
 455             WARN("no manifest\n");
 456             return ERROR_FUNCTION_FAILED;
 457         }
 458         manifest = msi_get_loaded_file( package, assembly->manifest )->TargetPath;
 459         cache = package->cache_sxs;
 460     }
 461     else
 462     {
 463         manifest = msi_get_loaded_file( package, comp->KeyPath )->TargetPath;
 464         cache = package->cache_net[get_clr_version( manifest )];
 465         if (!cache) return ERROR_SUCCESS;
 466     }
 467     TRACE("installing assembly %s\n", debugstr_w(manifest));
 468
 469     hr = IAssemblyCache_InstallAssembly( cache, 0, manifest, NULL );
 470     if (hr != S_OK)
 471     {
 472         ERR("Failed to install assembly %s (0x%08x)\n", debugstr_w(manifest), hr);
 473         return ERROR_FUNCTION_FAILED;
 474     }
 475     if (feature) feature->Action = INSTALLSTATE_LOCAL;
 476     assembly->installed = TRUE;
 477     return ERROR_SUCCESS;
 478 }
 479
 480 UINT msi_uninstall_assembly( MSIPACKAGE *package, MSICOMPONENT *comp )
 481 {
 482     HRESULT hr;
 483     IAssemblyCache *cache;
 484     MSIASSEMBLY *assembly = comp->assembly;
 485     MSIFEATURE *feature = NULL;
 486
 487     if (comp->assembly->feature)
 488         feature = msi_get_loaded_feature( package, comp->assembly->feature );
 489
 490     if (assembly->application)
 491     {
 492         if (feature) feature->Action = INSTALLSTATE_ABSENT;
 493         return ERROR_SUCCESS;
 494     }
 495     TRACE("removing %s\n", debugstr_w(assembly->display_name));
 496
 497     if (assembly->attributes == msidbAssemblyAttributesWin32)
 498     {
 499         cache = package->cache_sxs;
 500         hr = IAssemblyCache_UninstallAssembly( cache, 0, assembly->display_name, NULL, NULL );
 501         if (FAILED( hr )) WARN("failed to uninstall assembly 0x%08x\n", hr);
 502     }
 503     else
 504     {
 505         unsigned int i;
 506         for (i = 0; i < CLR_VERSION_MAX; i++)
 507         {
 508             if (!assembly->clr_version[i]) continue;
 509             cache = package->cache_net[i];
 510             if (cache)
 511             {
 512                 hr = IAssemblyCache_UninstallAssembly( cache, 0, assembly->display_name, NULL, NULL );
 513                 if (FAILED( hr )) WARN("failed to uninstall assembly 0x%08x\n", hr);
 514             }
 515         }
 516     }
 517     if (feature) feature->Action = INSTALLSTATE_ABSENT;
 518     assembly->installed = FALSE;
 519     return ERROR_SUCCESS;
 520 }
 521
 522 static WCHAR *build_local_assembly_path( const WCHAR *filename )
 523 {
 524     UINT i;
 525     WCHAR *ret;
 526
 527     if (!(ret = msi_alloc( (strlenW( filename ) + 1) * sizeof(WCHAR) )))
 528         return NULL;
 529
 530     for (i = 0; filename[i]; i++)
 531     {
 532         if (filename[i] == '\\' || filename[i] == '/') ret[i] = '|';
 533         else ret[i] = filename[i];
 534     }
 535     ret[i] = 0;
 536     return ret;
 537 }
 538
 539 static LONG open_assemblies_key( UINT context, BOOL win32, HKEY *hkey )
 540 {
 541     static const WCHAR path_win32[] =
 542         {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 543           'I','n','s','t','a','l','l','e','r','\\','W','i','n','3','2','A','s','s','e','m','b','l','i','e','s','\\',0};
 544     static const WCHAR path_dotnet[] =
 545         {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 546          'I','n','s','t','a','l','l','e','r','\\','A','s','s','e','m','b','l','i','e','s','\\',0};
 547     static const WCHAR classes_path_win32[] =
 548         {'I','n','s','t','a','l','l','e','r','\\','W','i','n','3','2','A','s','s','e','m','b','l','i','e','s','\\',0};
 549     static const WCHAR classes_path_dotnet[] =
 550         {'I','n','s','t','a','l','l','e','r','\\','A','s','s','e','m','b','l','i','e','s','\\',0};
 551     HKEY root;
 552     const WCHAR *path;
 553
 554     if (context == MSIINSTALLCONTEXT_MACHINE)
 555     {
 556         root = HKEY_CLASSES_ROOT;
 557         if (win32) path = classes_path_win32;
 558         else path = classes_path_dotnet;
 559     }
 560     else
 561     {
 562         root = HKEY_CURRENT_USER;
 563         if (win32) path = path_win32;
 564         else path = path_dotnet;
 565     }
 566     return RegCreateKeyW( root, path, hkey );
 567 }
 568
 569 static LONG open_local_assembly_key( UINT context, BOOL win32, const WCHAR *filename, HKEY *hkey )
 570 {
 571     LONG res;
 572     HKEY root;
 573     WCHAR *path;
 574
 575     if (!(path = build_local_assembly_path( filename )))
 576         return ERROR_OUTOFMEMORY;
 577
 578     if ((res = open_assemblies_key( context, win32, &root )))
 579     {
 580         msi_free( path );
 581         return res;
 582     }
 583     res = RegCreateKeyW( root, path, hkey );
 584     RegCloseKey( root );
 585     msi_free( path );
 586     return res;
 587 }
 588
 589 static LONG delete_local_assembly_key( UINT context, BOOL win32, const WCHAR *filename )
 590 {
 591     LONG res;
 592     HKEY root;
 593     WCHAR *path;
 594
 595     if (!(path = build_local_assembly_path( filename )))
 596         return ERROR_OUTOFMEMORY;
 597
 598     if ((res = open_assemblies_key( context, win32, &root )))
 599     {
 600         msi_free( path );
 601         return res;
 602     }
 603     res = RegDeleteKeyW( root, path );
 604     RegCloseKey( root );
 605     msi_free( path );
 606     return res;
 607 }
 608
 609 static LONG open_global_assembly_key( UINT context, BOOL win32, HKEY *hkey )
 610 {
 611     static const WCHAR path_win32[] =
 612         {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 613          'I','n','s','t','a','l','l','e','r','\\','W','i','n','3','2','A','s','s','e','m','b','l','i','e','s','\\',
 614          'G','l','o','b','a','l',0};
 615     static const WCHAR path_dotnet[] =
 616         {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 617          'I','n','s','t','a','l','l','e','r','\\','A','s','s','e','m','b','l','i','e','s','\\',
 618          'G','l','o','b','a','l',0};
 619     static const WCHAR classes_path_win32[] =
 620         {'I','n','s','t','a','l','l','e','r','\\','W','i','n','3','2','A','s','s','e','m','b','l','i','e','s','\\',
 621          'G','l','o','b','a','l',0};
 622     static const WCHAR classes_path_dotnet[] =
 623         {'I','n','s','t','a','l','l','e','r','\\','A','s','s','e','m','b','l','i','e','s','\\','G','l','o','b','a','l',0};
 624     HKEY root;
 625     const WCHAR *path;
 626
 627     if (context == MSIINSTALLCONTEXT_MACHINE)
 628     {
 629         root = HKEY_CLASSES_ROOT;
 630         if (win32) path = classes_path_win32;
 631         else path = classes_path_dotnet;
 632     }
 633     else
 634     {
 635         root = HKEY_CURRENT_USER;
 636         if (win32) path = path_win32;
 637         else path = path_dotnet;
 638     }
 639     return RegCreateKeyW( root, path, hkey );
 640 }
 641
 642 UINT ACTION_MsiPublishAssemblies( MSIPACKAGE *package )
 643 {
 644     MSICOMPONENT *comp;
 645
 646     LIST_FOR_EACH_ENTRY(comp, &package->components, MSICOMPONENT, entry)
 647     {
 648         LONG res;
 649         HKEY hkey;
 650         GUID guid;
 651         DWORD size;
 652         WCHAR buffer[43];
 653         MSIRECORD *uirow;
 654         MSIASSEMBLY *assembly = comp->assembly;
 655         BOOL win32;
 656
 657         if (!assembly || !comp->ComponentId) continue;
 658
 659         comp->Action = msi_get_component_action( package, comp );
 660         if (comp->Action != INSTALLSTATE_LOCAL)
 661         {
 662             TRACE("component not scheduled for installation %s\n", debugstr_w(comp->Component));
 663             continue;
 664         }
 665         TRACE("publishing %s\n", debugstr_w(comp->Component));
 666
 667         CLSIDFromString( package->ProductCode, &guid );
 668         encode_base85_guid( &guid, buffer );
 669         buffer[20] = '>';
 670         CLSIDFromString( comp->ComponentId, &guid );
 671         encode_base85_guid( &guid, buffer + 21 );
 672         buffer[42] = 0;
 673
 674         win32 = assembly->attributes & msidbAssemblyAttributesWin32;
 675         if (assembly->application)
 676         {
 677             MSIFILE *file = msi_get_loaded_file( package, assembly->application );
 678             if ((res = open_local_assembly_key( package->Context, win32, file->TargetPath, &hkey )))
 679             {
 680                 WARN("failed to open local assembly key %d\n", res);
 681                 return ERROR_FUNCTION_FAILED;
 682             }
 683         }
 684         else
 685         {
 686             if ((res = open_global_assembly_key( package->Context, win32, &hkey )))
 687             {
 688                 WARN("failed to open global assembly key %d\n", res);
 689                 return ERROR_FUNCTION_FAILED;
 690             }
 691         }
 692         size = sizeof(buffer);
 693         if ((res = RegSetValueExW( hkey, assembly->display_name, 0, REG_MULTI_SZ, (const BYTE *)buffer, size )))
 694         {
 695             WARN("failed to set assembly value %d\n", res);
 696         }
 697         RegCloseKey( hkey );
 698
 699         uirow = MSI_CreateRecord( 2 );
 700         MSI_RecordSetStringW( uirow, 2, assembly->display_name );
 701         MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
 702         msiobj_release( &uirow->hdr );
 703     }
 704     return ERROR_SUCCESS;
 705 }
 706
 707 UINT ACTION_MsiUnpublishAssemblies( MSIPACKAGE *package )
 708 {
 709     MSICOMPONENT *comp;
 710
 711     LIST_FOR_EACH_ENTRY(comp, &package->components, MSICOMPONENT, entry)
 712     {
 713         LONG res;
 714         MSIRECORD *uirow;
 715         MSIASSEMBLY *assembly = comp->assembly;
 716         BOOL win32;
 717
 718         if (!assembly || !comp->ComponentId) continue;
 719
 720         comp->Action = msi_get_component_action( package, comp );
 721         if (comp->Action != INSTALLSTATE_ABSENT)
 722         {
 723             TRACE("component not scheduled for removal %s\n", debugstr_w(comp->Component));
 724             continue;
 725         }
 726         TRACE("unpublishing %s\n", debugstr_w(comp->Component));
 727
 728         win32 = assembly->attributes & msidbAssemblyAttributesWin32;
 729         if (assembly->application)
 730         {
 731             MSIFILE *file = msi_get_loaded_file( package, assembly->application );
 732             if ((res = delete_local_assembly_key( package->Context, win32, file->TargetPath )))
 733                 WARN("failed to delete local assembly key %d\n", res);
 734         }
 735         else
 736         {
 737             HKEY hkey;
 738             if ((res = open_global_assembly_key( package->Context, win32, &hkey )))
 739                 WARN("failed to delete global assembly key %d\n", res);
 740             else
 741             {
 742                 if ((res = RegDeleteValueW( hkey, assembly->display_name )))
 743                     WARN("failed to delete global assembly value %d\n", res);
 744                 RegCloseKey( hkey );
 745             }
 746         }
 747
 748         uirow = MSI_CreateRecord( 2 );
 749         MSI_RecordSetStringW( uirow, 2, assembly->display_name );
 750         MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
 751         msiobj_release( &uirow->hdr );
 752     }
 753     return ERROR_SUCCESS;
 754 }