git.oblomov.eu Git - wine/blob - dlls/msi/action.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2004,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
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winerror.h"
  28 #include "winreg.h"
  29 #include "winsvc.h"
  30 #include "odbcinst.h"
  31 #include "wine/debug.h"
  32 #include "msidefs.h"
  33 #include "msipriv.h"
  34 #include "winuser.h"
  35 #include "shlobj.h"
  36 #include "objbase.h"
  37 #include "mscoree.h"
  38 #include "fusion.h"
  39 #include "shlwapi.h"
  40 #include "wine/unicode.h"
  41 #include "winver.h"
  42
  43 #define REG_PROGRESS_VALUE 13200
  44 #define COMPONENT_PROGRESS_VALUE 24000
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  47
  48 /*
  49  * consts and values used
  50  */
  51 static const WCHAR c_colon[] = {'C',':','\\',0};
  52
  53 static const WCHAR szCreateFolders[] =
  54     {'C','r','e','a','t','e','F','o','l','d','e','r','s',0};
  55 static const WCHAR szCostFinalize[] =
  56     {'C','o','s','t','F','i','n','a','l','i','z','e',0};
  57 static const WCHAR szWriteRegistryValues[] =
  58     {'W','r','i','t','e','R','e','g','i','s','t','r','y','V','a','l','u','e','s',0};
  59 static const WCHAR szCostInitialize[] =
  60     {'C','o','s','t','I','n','i','t','i','a','l','i','z','e',0};
  61 static const WCHAR szFileCost[] =
  62     {'F','i','l','e','C','o','s','t',0};
  63 static const WCHAR szInstallInitialize[] =
  64     {'I','n','s','t','a','l','l','I','n','i','t','i','a','l','i','z','e',0};
  65 static const WCHAR szInstallValidate[] =
  66     {'I','n','s','t','a','l','l','V','a','l','i','d','a','t','e',0};
  67 static const WCHAR szLaunchConditions[] =
  68     {'L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','s',0};
  69 static const WCHAR szProcessComponents[] =
  70     {'P','r','o','c','e','s','s','C','o','m','p','o','n','e','n','t','s',0};
  71 static const WCHAR szRegisterTypeLibraries[] =
  72     {'R','e','g','i','s','t','e','r','T','y','p','e','L','i','b','r','a','r','i','e','s',0};
  73 static const WCHAR szCreateShortcuts[] =
  74     {'C','r','e','a','t','e','S','h','o','r','t','c','u','t','s',0};
  75 static const WCHAR szPublishProduct[] =
  76     {'P','u','b','l','i','s','h','P','r','o','d','u','c','t',0};
  77 static const WCHAR szWriteIniValues[] =
  78     {'W','r','i','t','e','I','n','i','V','a','l','u','e','s',0};
  79 static const WCHAR szSelfRegModules[] =
  80     {'S','e','l','f','R','e','g','M','o','d','u','l','e','s',0};
  81 static const WCHAR szPublishFeatures[] =
  82     {'P','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
  83 static const WCHAR szRegisterProduct[] =
  84     {'R','e','g','i','s','t','e','r','P','r','o','d','u','c','t',0};
  85 static const WCHAR szInstallExecute[] =
  86     {'I','n','s','t','a','l','l','E','x','e','c','u','t','e',0};
  87 static const WCHAR szInstallExecuteAgain[] =
  88     {'I','n','s','t','a','l','l','E','x','e','c','u','t','e','A','g','a','i','n',0};
  89 static const WCHAR szInstallFinalize[] =
  90     {'I','n','s','t','a','l','l','F','i','n','a','l','i','z','e',0};
  91 static const WCHAR szForceReboot[] =
  92     {'F','o','r','c','e','R','e','b','o','o','t',0};
  93 static const WCHAR szResolveSource[] =
  94     {'R','e','s','o','l','v','e','S','o','u','r','c','e',0};
  95 static const WCHAR szAllocateRegistrySpace[] =
  96     {'A','l','l','o','c','a','t','e','R','e','g','i','s','t','r','y','S','p','a','c','e',0};
  97 static const WCHAR szBindImage[] =
  98     {'B','i','n','d','I','m','a','g','e',0};
  99 static const WCHAR szDeleteServices[] =
 100     {'D','e','l','e','t','e','S','e','r','v','i','c','e','s',0};
 101 static const WCHAR szDisableRollback[] =
 102     {'D','i','s','a','b','l','e','R','o','l','l','b','a','c','k',0};
 103 static const WCHAR szExecuteAction[] =
 104     {'E','x','e','c','u','t','e','A','c','t','i','o','n',0};
 105 static const WCHAR szInstallAdminPackage[] =
 106     {'I','n','s','t','a','l','l','A','d','m','i','n','P','a','c','k','a','g','e',0};
 107 static const WCHAR szInstallSFPCatalogFile[] =
 108     {'I','n','s','t','a','l','l','S','F','P','C','a','t','a','l','o','g','F','i','l','e',0};
 109 static const WCHAR szIsolateComponents[] =
 110     {'I','s','o','l','a','t','e','C','o','m','p','o','n','e','n','t','s',0};
 111 static const WCHAR szMigrateFeatureStates[] =
 112     {'M','i','g','r','a','t','e','F','e','a','t','u','r','e','S','t','a','t','e','s',0};
 113 static const WCHAR szMsiPublishAssemblies[] =
 114     {'M','s','i','P','u','b','l','i','s','h','A','s','s','e','m','b','l','i','e','s',0};
 115 static const WCHAR szMsiUnpublishAssemblies[] =
 116     {'M','s','i','U','n','p','u','b','l','i','s','h','A','s','s','e','m','b','l','i','e','s',0};
 117 static const WCHAR szInstallODBC[] =
 118     {'I','n','s','t','a','l','l','O','D','B','C',0};
 119 static const WCHAR szInstallServices[] =
 120     {'I','n','s','t','a','l','l','S','e','r','v','i','c','e','s',0};
 121 static const WCHAR szPatchFiles[] =
 122     {'P','a','t','c','h','F','i','l','e','s',0};
 123 static const WCHAR szPublishComponents[] =
 124     {'P','u','b','l','i','s','h','C','o','m','p','o','n','e','n','t','s',0};
 125 static const WCHAR szRegisterComPlus[] =
 126     {'R','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
 127 static const WCHAR szRegisterUser[] =
 128     {'R','e','g','i','s','t','e','r','U','s','e','r',0};
 129 static const WCHAR szRemoveEnvironmentStrings[] =
 130     {'R','e','m','o','v','e','E','n','v','i','r','o','n','m','e','n','t','S','t','r','i','n','g','s',0};
 131 static const WCHAR szRemoveExistingProducts[] =
 132     {'R','e','m','o','v','e','E','x','i','s','t','i','n','g','P','r','o','d','u','c','t','s',0};
 133 static const WCHAR szRemoveFolders[] =
 134     {'R','e','m','o','v','e','F','o','l','d','e','r','s',0};
 135 static const WCHAR szRemoveIniValues[] =
 136     {'R','e','m','o','v','e','I','n','i','V','a','l','u','e','s',0};
 137 static const WCHAR szRemoveODBC[] =
 138     {'R','e','m','o','v','e','O','D','B','C',0};
 139 static const WCHAR szRemoveRegistryValues[] =
 140     {'R','e','m','o','v','e','R','e','g','i','s','t','r','y','V','a','l','u','e','s',0};
 141 static const WCHAR szRemoveShortcuts[] =
 142     {'R','e','m','o','v','e','S','h','o','r','t','c','u','t','s',0};
 143 static const WCHAR szRMCCPSearch[] =
 144     {'R','M','C','C','P','S','e','a','r','c','h',0};
 145 static const WCHAR szScheduleReboot[] =
 146     {'S','c','h','e','d','u','l','e','R','e','b','o','o','t',0};
 147 static const WCHAR szSelfUnregModules[] =
 148     {'S','e','l','f','U','n','r','e','g','M','o','d','u','l','e','s',0};
 149 static const WCHAR szSetODBCFolders[] =
 150     {'S','e','t','O','D','B','C','F','o','l','d','e','r','s',0};
 151 static const WCHAR szStartServices[] =
 152     {'S','t','a','r','t','S','e','r','v','i','c','e','s',0};
 153 static const WCHAR szStopServices[] =
 154     {'S','t','o','p','S','e','r','v','i','c','e','s',0};
 155 static const WCHAR szUnpublishComponents[] =
 156     {'U','n','p','u','b','l','i','s','h', 'C','o','m','p','o','n','e','n','t','s',0};
 157 static const WCHAR szUnpublishFeatures[] =
 158     {'U','n','p','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
 159 static const WCHAR szUnregisterComPlus[] =
 160     {'U','n','r','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
 161 static const WCHAR szUnregisterTypeLibraries[] =
 162     {'U','n','r','e','g','i','s','t','e','r','T','y','p','e','L','i','b','r','a','r','i','e','s',0};
 163 static const WCHAR szValidateProductID[] =
 164     {'V','a','l','i','d','a','t','e','P','r','o','d','u','c','t','I','D',0};
 165 static const WCHAR szWriteEnvironmentStrings[] =
 166     {'W','r','i','t','e','E','n','v','i','r','o','n','m','e','n','t','S','t','r','i','n','g','s',0};
 167
 168 /********************************************************
 169  * helper functions
 170  ********************************************************/
 171
 172 static void ui_actionstart(MSIPACKAGE *package, LPCWSTR action)
 173 {
 174     static const WCHAR Query_t[] =
 175         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 176          '`','A','c','t','i','o', 'n','T','e','x','t','`',' ',
 177          'W','H','E','R','E', ' ','`','A','c','t','i','o','n','`',' ','=',
 178          ' ','\'','%','s','\'',0};
 179     MSIRECORD * row;
 180
 181     row = MSI_QueryGetRecord( package->db, Query_t, action );
 182     if (!row)
 183         return;
 184     MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONSTART, row);
 185     msiobj_release(&row->hdr);
 186 }
 187
 188 static void ui_actioninfo(MSIPACKAGE *package, LPCWSTR action, BOOL start,
 189                           UINT rc)
 190 {
 191     MSIRECORD * row;
 192     static const WCHAR template_s[]=
 193         {'A','c','t','i','o','n',' ','s','t','a','r','t',' ','%','s',':',' ',
 194          '%','s', '.',0};
 195     static const WCHAR template_e[]=
 196         {'A','c','t','i','o','n',' ','e','n','d','e','d',' ','%','s',':',' ',
 197          '%','s', '.',' ','R','e','t','u','r','n',' ','v','a','l','u','e',' ',
 198          '%','i','.',0};
 199     static const WCHAR format[] =
 200         {'H','H','\'',':','\'','m','m','\'',':','\'','s','s',0};
 201     WCHAR message[1024];
 202     WCHAR timet[0x100];
 203
 204     GetTimeFormatW(LOCALE_USER_DEFAULT, 0, NULL, format, timet, 0x100);
 205     if (start)
 206         sprintfW(message,template_s,timet,action);
 207     else
 208         sprintfW(message,template_e,timet,action,rc);
 209
 210     row = MSI_CreateRecord(1);
 211     MSI_RecordSetStringW(row,1,message);
 212
 213     MSI_ProcessMessage(package, INSTALLMESSAGE_INFO, row);
 214     msiobj_release(&row->hdr);
 215 }
 216
 217 UINT msi_parse_command_line( MSIPACKAGE *package, LPCWSTR szCommandLine,
 218                              BOOL preserve_case )
 219 {
 220     LPCWSTR ptr,ptr2;
 221     BOOL quote;
 222     DWORD len;
 223     LPWSTR prop = NULL, val = NULL;
 224
 225     if (!szCommandLine)
 226         return ERROR_SUCCESS;
 227
 228     ptr = szCommandLine;
 229
 230     while (*ptr)
 231     {
 232         if (*ptr==' ')
 233         {
 234             ptr++;
 235             continue;
 236         }
 237
 238         TRACE("Looking at %s\n",debugstr_w(ptr));
 239
 240         ptr2 = strchrW(ptr,'=');
 241         if (!ptr2)
 242         {
 243             ERR("command line contains unknown string : %s\n", debugstr_w(ptr));
 244             break;
 245         }
 246
 247         quote = FALSE;
 248
 249         len = ptr2-ptr;
 250         prop = msi_alloc((len+1)*sizeof(WCHAR));
 251         memcpy(prop,ptr,len*sizeof(WCHAR));
 252         prop[len]=0;
 253
 254         if (!preserve_case)
 255             struprW(prop);
 256
 257         ptr2++;
 258
 259         len = 0;
 260         ptr = ptr2;
 261         while (*ptr && (quote || (!quote && *ptr!=' ')))
 262         {
 263             if (*ptr == '"')
 264                 quote = !quote;
 265             ptr++;
 266             len++;
 267         }
 268
 269         if (*ptr2=='"')
 270         {
 271             ptr2++;
 272             len -= 2;
 273         }
 274         val = msi_alloc((len+1)*sizeof(WCHAR));
 275         memcpy(val,ptr2,len*sizeof(WCHAR));
 276         val[len] = 0;
 277
 278         if (lstrlenW(prop) > 0)
 279         {
 280             UINT r = msi_set_property( package->db, prop, val );
 281
 282             TRACE("Found commandline property (%s) = (%s)\n",
 283                    debugstr_w(prop), debugstr_w(val));
 284
 285             if (r == ERROR_SUCCESS && !strcmpW( prop, cszSourceDir ))
 286                 msi_reset_folders( package, TRUE );
 287         }
 288         msi_free(val);
 289         msi_free(prop);
 290     }
 291
 292     return ERROR_SUCCESS;
 293 }
 294
 295
 296 static LPWSTR* msi_split_string( LPCWSTR str, WCHAR sep )
 297 {
 298     LPCWSTR pc;
 299     LPWSTR p, *ret = NULL;
 300     UINT count = 0;
 301
 302     if (!str)
 303         return ret;
 304
 305     /* count the number of substrings */
 306     for ( pc = str, count = 0; pc; count++ )
 307     {
 308         pc = strchrW( pc, sep );
 309         if (pc)
 310             pc++;
 311     }
 312
 313     /* allocate space for an array of substring pointers and the substrings */
 314     ret = msi_alloc( (count+1) * sizeof (LPWSTR) +
 315                      (lstrlenW(str)+1) * sizeof(WCHAR) );
 316     if (!ret)
 317         return ret;
 318
 319     /* copy the string and set the pointers */
 320     p = (LPWSTR) &ret[count+1];
 321     lstrcpyW( p, str );
 322     for( count = 0; (ret[count] = p); count++ )
 323     {
 324         p = strchrW( p, sep );
 325         if (p)
 326             *p++ = 0;
 327     }
 328
 329     return ret;
 330 }
 331
 332 static UINT msi_check_transform_applicable( MSIPACKAGE *package, IStorage *patch )
 333 {
 334     static const WCHAR szSystemLanguageID[] =
 335         { 'S','y','s','t','e','m','L','a','n','g','u','a','g','e','I','D',0 };
 336
 337     LPWSTR prod_code, patch_product, langid = NULL, template = NULL;
 338     UINT ret = ERROR_FUNCTION_FAILED;
 339
 340     prod_code = msi_dup_property( package->db, szProductCode );
 341     patch_product = msi_get_suminfo_product( patch );
 342
 343     TRACE("db = %s patch = %s\n", debugstr_w(prod_code), debugstr_w(patch_product));
 344
 345     if ( strstrW( patch_product, prod_code ) )
 346     {
 347         MSISUMMARYINFO *si;
 348         const WCHAR *p;
 349
 350         si = MSI_GetSummaryInformationW( patch, 0 );
 351         if (!si)
 352         {
 353             ERR("no summary information!\n");
 354             goto end;
 355         }
 356
 357         template = msi_suminfo_dup_string( si, PID_TEMPLATE );
 358         if (!template)
 359         {
 360             ERR("no template property!\n");
 361             msiobj_release( &si->hdr );
 362             goto end;
 363         }
 364
 365         if (!template[0])
 366         {
 367             ret = ERROR_SUCCESS;
 368             msiobj_release( &si->hdr );
 369             goto end;
 370         }
 371
 372         langid = msi_dup_property( package->db, szSystemLanguageID );
 373         if (!langid)
 374         {
 375             msiobj_release( &si->hdr );
 376             goto end;
 377         }
 378
 379         p = strchrW( template, ';' );
 380         if (p && (!strcmpW( p + 1, langid ) || !strcmpW( p + 1, szZero )))
 381         {
 382             TRACE("applicable transform\n");
 383             ret = ERROR_SUCCESS;
 384         }
 385
 386         /* FIXME: check platform */
 387
 388         msiobj_release( &si->hdr );
 389     }
 390
 391 end:
 392     msi_free( patch_product );
 393     msi_free( prod_code );
 394     msi_free( template );
 395     msi_free( langid );
 396
 397     return ret;
 398 }
 399
 400 static UINT msi_apply_substorage_transform( MSIPACKAGE *package,
 401                                  MSIDATABASE *patch_db, LPCWSTR name )
 402 {
 403     UINT ret = ERROR_FUNCTION_FAILED;
 404     IStorage *stg = NULL;
 405     HRESULT r;
 406
 407     TRACE("%p %s\n", package, debugstr_w(name) );
 408
 409     if (*name++ != ':')
 410     {
 411         ERR("expected a colon in %s\n", debugstr_w(name));
 412         return ERROR_FUNCTION_FAILED;
 413     }
 414
 415     r = IStorage_OpenStorage( patch_db->storage, name, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &stg );
 416     if (SUCCEEDED(r))
 417     {
 418         ret = msi_check_transform_applicable( package, stg );
 419         if (ret == ERROR_SUCCESS)
 420             msi_table_apply_transform( package->db, stg );
 421         else
 422             TRACE("substorage transform %s wasn't applicable\n", debugstr_w(name));
 423         IStorage_Release( stg );
 424     }
 425     else
 426         ERR("failed to open substorage %s\n", debugstr_w(name));
 427
 428     return ERROR_SUCCESS;
 429 }
 430
 431 UINT msi_check_patch_applicable( MSIPACKAGE *package, MSISUMMARYINFO *si )
 432 {
 433     LPWSTR guid_list, *guids, product_code;
 434     UINT i, ret = ERROR_FUNCTION_FAILED;
 435
 436     product_code = msi_dup_property( package->db, szProductCode );
 437     if (!product_code)
 438     {
 439         /* FIXME: the property ProductCode should be written into the DB somewhere */
 440         ERR("no product code to check\n");
 441         return ERROR_SUCCESS;
 442     }
 443
 444     guid_list = msi_suminfo_dup_string( si, PID_TEMPLATE );
 445     guids = msi_split_string( guid_list, ';' );
 446     for ( i = 0; guids[i] && ret != ERROR_SUCCESS; i++ )
 447     {
 448         if (!lstrcmpW( guids[i], product_code ))
 449             ret = ERROR_SUCCESS;
 450     }
 451     msi_free( guids );
 452     msi_free( guid_list );
 453     msi_free( product_code );
 454
 455     return ret;
 456 }
 457
 458 static UINT msi_set_media_source_prop(MSIPACKAGE *package)
 459 {
 460     MSIQUERY *view;
 461     MSIRECORD *rec = NULL;
 462     LPWSTR patch;
 463     LPCWSTR prop;
 464     UINT r;
 465
 466     static const WCHAR query[] = {'S','E','L','E','C','T',' ',
 467         '`','S','o','u','r','c','e','`',' ','F','R','O','M',' ',
 468         '`','M','e','d','i','a','`',' ','W','H','E','R','E',' ',
 469         '`','S','o','u','r','c','e','`',' ','I','S',' ',
 470         'N','O','T',' ','N','U','L','L',0};
 471
 472     r = MSI_DatabaseOpenViewW(package->db, query, &view);
 473     if (r != ERROR_SUCCESS)
 474         return r;
 475
 476     r = MSI_ViewExecute(view, 0);
 477     if (r != ERROR_SUCCESS)
 478         goto done;
 479
 480     if (MSI_ViewFetch(view, &rec) == ERROR_SUCCESS)
 481     {
 482         prop = MSI_RecordGetString(rec, 1);
 483         patch = msi_dup_property(package->db, szPatch);
 484         msi_set_property(package->db, prop, patch);
 485         msi_free(patch);
 486     }
 487
 488 done:
 489     if (rec) msiobj_release(&rec->hdr);
 490     msiobj_release(&view->hdr);
 491
 492     return r;
 493 }
 494
 495 UINT msi_parse_patch_summary( MSISUMMARYINFO *si, MSIPATCHINFO **patch )
 496 {
 497     MSIPATCHINFO *pi;
 498     UINT r = ERROR_SUCCESS;
 499     WCHAR *p;
 500
 501     pi = msi_alloc_zero( sizeof(MSIPATCHINFO) );
 502     if (!pi)
 503         return ERROR_OUTOFMEMORY;
 504
 505     pi->patchcode = msi_suminfo_dup_string( si, PID_REVNUMBER );
 506     if (!pi->patchcode)
 507     {
 508         msi_free( pi );
 509         return ERROR_OUTOFMEMORY;
 510     }
 511
 512     p = pi->patchcode;
 513     if (*p != '{')
 514     {
 515         msi_free( pi->patchcode );
 516         msi_free( pi );
 517         return ERROR_PATCH_PACKAGE_INVALID;
 518     }
 519
 520     p = strchrW( p + 1, '}' );
 521     if (!p)
 522     {
 523         msi_free( pi->patchcode );
 524         msi_free( pi );
 525         return ERROR_PATCH_PACKAGE_INVALID;
 526     }
 527
 528     if (p[1])
 529     {
 530         FIXME("patch obsoletes %s\n", debugstr_w(p + 1));
 531         p[1] = 0;
 532     }
 533
 534     TRACE("patch code %s\n", debugstr_w(pi->patchcode));
 535
 536     pi->transforms = msi_suminfo_dup_string( si, PID_LASTAUTHOR );
 537     if (!pi->transforms)
 538     {
 539         msi_free( pi->patchcode );
 540         msi_free( pi );
 541         return ERROR_OUTOFMEMORY;
 542     }
 543
 544     *patch = pi;
 545     return r;
 546 }
 547
 548 UINT msi_apply_patch_db( MSIPACKAGE *package, MSIDATABASE *patch_db, MSIPATCHINFO *patch )
 549 {
 550     UINT i, r = ERROR_SUCCESS;
 551     WCHAR **substorage;
 552
 553     /* apply substorage transforms */
 554     substorage = msi_split_string( patch->transforms, ';' );
 555     for (i = 0; substorage && substorage[i] && r == ERROR_SUCCESS; i++)
 556         r = msi_apply_substorage_transform( package, patch_db, substorage[i] );
 557
 558     msi_free( substorage );
 559     if (r != ERROR_SUCCESS)
 560         return r;
 561
 562     msi_set_media_source_prop( package );
 563
 564     /*
 565      * There might be a CAB file in the patch package,
 566      * so append it to the list of storages to search for streams.
 567      */
 568     append_storage_to_db( package->db, patch_db->storage );
 569
 570     patch->state = MSIPATCHSTATE_APPLIED;
 571     list_add_tail( &package->patches, &patch->entry );
 572     return ERROR_SUCCESS;
 573 }
 574
 575 static UINT msi_apply_patch_package( MSIPACKAGE *package, LPCWSTR file )
 576 {
 577     static const WCHAR dotmsp[] = {'.','m','s','p',0};
 578     MSIDATABASE *patch_db = NULL;
 579     WCHAR localfile[MAX_PATH];
 580     MSISUMMARYINFO *si;
 581     MSIPATCHINFO *patch = NULL;
 582     UINT r = ERROR_SUCCESS;
 583
 584     TRACE("%p %s\n", package, debugstr_w( file ) );
 585
 586     r = MSI_OpenDatabaseW( file, MSIDBOPEN_READONLY + MSIDBOPEN_PATCHFILE, &patch_db );
 587     if ( r != ERROR_SUCCESS )
 588     {
 589         ERR("failed to open patch collection %s\n", debugstr_w( file ) );
 590         return r;
 591     }
 592
 593     si = MSI_GetSummaryInformationW( patch_db->storage, 0 );
 594     if (!si)
 595     {
 596         msiobj_release( &patch_db->hdr );
 597         return ERROR_FUNCTION_FAILED;
 598     }
 599
 600     r = msi_check_patch_applicable( package, si );
 601     if (r != ERROR_SUCCESS)
 602     {
 603         TRACE("patch not applicable\n");
 604         r = ERROR_SUCCESS;
 605         goto done;
 606     }
 607
 608     r = msi_parse_patch_summary( si, &patch );
 609     if ( r != ERROR_SUCCESS )
 610         goto done;
 611
 612     r = msi_get_local_package_name( localfile, dotmsp );
 613     if ( r != ERROR_SUCCESS )
 614         goto done;
 615
 616     TRACE("copying to local package %s\n", debugstr_w(localfile));
 617
 618     if (!CopyFileW( file, localfile, FALSE ))
 619     {
 620         ERR("Unable to copy package (%s -> %s) (error %u)\n",
 621             debugstr_w(file), debugstr_w(localfile), GetLastError());
 622         r = GetLastError();
 623         goto done;
 624     }
 625     patch->localfile = strdupW( localfile );
 626
 627     r = msi_apply_patch_db( package, patch_db, patch );
 628     if ( r != ERROR_SUCCESS )
 629         WARN("patch failed to apply %u\n", r);
 630
 631 done:
 632     msiobj_release( &si->hdr );
 633     msiobj_release( &patch_db->hdr );
 634     if (patch && r != ERROR_SUCCESS)
 635     {
 636         if (patch->localfile)
 637             DeleteFileW( patch->localfile );
 638
 639         msi_free( patch->patchcode );
 640         msi_free( patch->transforms );
 641         msi_free( patch->localfile );
 642         msi_free( patch );
 643     }
 644     return r;
 645 }
 646
 647 /* get the PATCH property, and apply all the patches it specifies */
 648 static UINT msi_apply_patches( MSIPACKAGE *package )
 649 {
 650     LPWSTR patch_list, *patches;
 651     UINT i, r = ERROR_SUCCESS;
 652
 653     patch_list = msi_dup_property( package->db, szPatch );
 654
 655     TRACE("patches to be applied: %s\n", debugstr_w( patch_list ) );
 656
 657     patches = msi_split_string( patch_list, ';' );
 658     for( i=0; patches && patches[i] && r == ERROR_SUCCESS; i++ )
 659         r = msi_apply_patch_package( package, patches[i] );
 660
 661     msi_free( patches );
 662     msi_free( patch_list );
 663
 664     return r;
 665 }
 666
 667 static UINT msi_apply_transforms( MSIPACKAGE *package )
 668 {
 669     static const WCHAR szTransforms[] = {
 670         'T','R','A','N','S','F','O','R','M','S',0 };
 671     LPWSTR xform_list, *xforms;
 672     UINT i, r = ERROR_SUCCESS;
 673
 674     xform_list = msi_dup_property( package->db, szTransforms );
 675     xforms = msi_split_string( xform_list, ';' );
 676
 677     for( i=0; xforms && xforms[i] && r == ERROR_SUCCESS; i++ )
 678     {
 679         if (xforms[i][0] == ':')
 680             r = msi_apply_substorage_transform( package, package->db, xforms[i] );
 681         else
 682             r = MSI_DatabaseApplyTransformW( package->db, xforms[i], 0 );
 683     }
 684
 685     msi_free( xforms );
 686     msi_free( xform_list );
 687
 688     return r;
 689 }
 690
 691 static BOOL ui_sequence_exists( MSIPACKAGE *package )
 692 {
 693     MSIQUERY *view;
 694     UINT rc;
 695
 696     static const WCHAR ExecSeqQuery [] =
 697         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 698          '`','I','n','s','t','a','l','l',
 699          'U','I','S','e','q','u','e','n','c','e','`',
 700          ' ','W','H','E','R','E',' ',
 701          '`','S','e','q','u','e','n','c','e','`',' ',
 702          '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
 703          '`','S','e','q','u','e','n','c','e','`',0};
 704
 705     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
 706     if (rc == ERROR_SUCCESS)
 707     {
 708         msiobj_release(&view->hdr);
 709         return TRUE;
 710     }
 711
 712     return FALSE;
 713 }
 714
 715 UINT msi_set_sourcedir_props(MSIPACKAGE *package, BOOL replace)
 716 {
 717     LPWSTR source, check;
 718
 719     if (msi_get_property_int( package->db, szInstalled, 0 ))
 720     {
 721         HKEY hkey;
 722
 723         MSIREG_OpenInstallProps( package->ProductCode, package->Context, NULL, &hkey, FALSE );
 724         source = msi_reg_get_val_str( hkey, INSTALLPROPERTY_INSTALLSOURCEW );
 725         RegCloseKey( hkey );
 726     }
 727     else
 728     {
 729         LPWSTR p, db;
 730         DWORD len;
 731
 732         db = msi_dup_property( package->db, szOriginalDatabase );
 733         if (!db)
 734             return ERROR_OUTOFMEMORY;
 735
 736         p = strrchrW( db, '\\' );
 737         if (!p)
 738         {
 739             p = strrchrW( db, '/' );
 740             if (!p)
 741             {
 742                 msi_free(db);
 743                 return ERROR_SUCCESS;
 744             }
 745         }
 746
 747         len = p - db + 2;
 748         source = msi_alloc( len * sizeof(WCHAR) );
 749         lstrcpynW( source, db, len );
 750         msi_free( db );
 751     }
 752
 753     check = msi_dup_property( package->db, cszSourceDir );
 754     if (!check || replace)
 755     {
 756         UINT r = msi_set_property( package->db, cszSourceDir, source );
 757         if (r == ERROR_SUCCESS)
 758             msi_reset_folders( package, TRUE );
 759     }
 760     msi_free( check );
 761
 762     check = msi_dup_property( package->db, cszSOURCEDIR );
 763     if (!check || replace)
 764         msi_set_property( package->db, cszSOURCEDIR, source );
 765
 766     msi_free( check );
 767     msi_free( source );
 768
 769     return ERROR_SUCCESS;
 770 }
 771
 772 static BOOL needs_ui_sequence(MSIPACKAGE *package)
 773 {
 774     INT level = msi_get_property_int(package->db, szUILevel, 0);
 775     return (level & INSTALLUILEVEL_MASK) >= INSTALLUILEVEL_REDUCED;
 776 }
 777
 778 UINT msi_set_context(MSIPACKAGE *package)
 779 {
 780     int num;
 781
 782     package->Context = MSIINSTALLCONTEXT_USERUNMANAGED;
 783
 784     num = msi_get_property_int(package->db, szAllUsers, 0);
 785     if (num == 1 || num == 2)
 786         package->Context = MSIINSTALLCONTEXT_MACHINE;
 787
 788     return ERROR_SUCCESS;
 789 }
 790
 791 static UINT ITERATE_Actions(MSIRECORD *row, LPVOID param)
 792 {
 793     UINT rc;
 794     LPCWSTR cond, action;
 795     MSIPACKAGE *package = param;
 796
 797     action = MSI_RecordGetString(row,1);
 798     if (!action)
 799     {
 800         ERR("Error is retrieving action name\n");
 801         return ERROR_FUNCTION_FAILED;
 802     }
 803
 804     /* check conditions */
 805     cond = MSI_RecordGetString(row,2);
 806
 807     /* this is a hack to skip errors in the condition code */
 808     if (MSI_EvaluateConditionW(package, cond) == MSICONDITION_FALSE)
 809     {
 810         TRACE("Skipping action: %s (condition is false)\n", debugstr_w(action));
 811         return ERROR_SUCCESS;
 812     }
 813
 814     if (needs_ui_sequence(package))
 815         rc = ACTION_PerformUIAction(package, action, -1);
 816     else
 817         rc = ACTION_PerformAction(package, action, -1);
 818
 819     msi_dialog_check_messages( NULL );
 820
 821     if (package->CurrentInstallState != ERROR_SUCCESS)
 822         rc = package->CurrentInstallState;
 823
 824     if (rc == ERROR_FUNCTION_NOT_CALLED)
 825         rc = ERROR_SUCCESS;
 826
 827     if (rc != ERROR_SUCCESS)
 828         ERR("Execution halted, action %s returned %i\n", debugstr_w(action), rc);
 829
 830     return rc;
 831 }
 832
 833 UINT MSI_Sequence( MSIPACKAGE *package, LPCWSTR szTable, INT iSequenceMode )
 834 {
 835     MSIQUERY * view;
 836     UINT r;
 837     static const WCHAR query[] =
 838         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 839          '`','%','s','`',
 840          ' ','W','H','E','R','E',' ',
 841          '`','S','e','q','u','e','n','c','e','`',' ',
 842          '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
 843          '`','S','e','q','u','e','n','c','e','`',0};
 844
 845     TRACE("%p %s %i\n", package, debugstr_w(szTable), iSequenceMode );
 846
 847     r = MSI_OpenQuery( package->db, &view, query, szTable );
 848     if (r == ERROR_SUCCESS)
 849     {
 850         r = MSI_IterateRecords( view, NULL, ITERATE_Actions, package );
 851         msiobj_release(&view->hdr);
 852     }
 853
 854     return r;
 855 }
 856
 857 static UINT ACTION_ProcessExecSequence(MSIPACKAGE *package, BOOL UIran)
 858 {
 859     MSIQUERY * view;
 860     UINT rc;
 861     static const WCHAR ExecSeqQuery[] =
 862         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
 863          '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
 864          'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
 865          '`','S','e','q','u','e','n','c','e','`',' ', '>',' ','%','i',' ',
 866          'O','R','D','E','R',' ', 'B','Y',' ',
 867          '`','S','e','q','u','e','n','c','e','`',0 };
 868     static const WCHAR IVQuery[] =
 869         {'S','E','L','E','C','T',' ','`','S','e','q','u','e','n','c','e','`',
 870          ' ', 'F','R','O','M',' ','`','I','n','s','t','a','l','l',
 871          'E','x','e','c','u','t','e','S','e','q','u','e','n','c','e','`',' ',
 872          'W','H','E','R','E',' ','`','A','c','t','i','o','n','`',' ','=',
 873          ' ','\'', 'I','n','s','t','a','l','l',
 874          'V','a','l','i','d','a','t','e','\'', 0};
 875     INT seq = 0;
 876
 877     if (package->script->ExecuteSequenceRun)
 878     {
 879         TRACE("Execute Sequence already Run\n");
 880         return ERROR_SUCCESS;
 881     }
 882
 883     package->script->ExecuteSequenceRun = TRUE;
 884
 885     /* get the sequence number */
 886     if (UIran)
 887     {
 888         MSIRECORD *row = MSI_QueryGetRecord(package->db, IVQuery);
 889         if( !row )
 890             return ERROR_FUNCTION_FAILED;
 891         seq = MSI_RecordGetInteger(row,1);
 892         msiobj_release(&row->hdr);
 893     }
 894
 895     rc = MSI_OpenQuery(package->db, &view, ExecSeqQuery, seq);
 896     if (rc == ERROR_SUCCESS)
 897     {
 898         TRACE("Running the actions\n");
 899
 900         msi_set_property(package->db, cszSourceDir, NULL);
 901
 902         rc = MSI_IterateRecords(view, NULL, ITERATE_Actions, package);
 903         msiobj_release(&view->hdr);
 904     }
 905
 906     return rc;
 907 }
 908
 909 static UINT ACTION_ProcessUISequence(MSIPACKAGE *package)
 910 {
 911     MSIQUERY * view;
 912     UINT rc;
 913     static const WCHAR ExecSeqQuery [] =
 914         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 915          '`','I','n','s','t','a','l','l',
 916          'U','I','S','e','q','u','e','n','c','e','`',
 917          ' ','W','H','E','R','E',' ',
 918          '`','S','e','q','u','e','n','c','e','`',' ',
 919          '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
 920          '`','S','e','q','u','e','n','c','e','`',0};
 921
 922     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
 923     if (rc == ERROR_SUCCESS)
 924     {
 925         TRACE("Running the actions\n");
 926
 927         rc = MSI_IterateRecords(view, NULL, ITERATE_Actions, package);
 928         msiobj_release(&view->hdr);
 929     }
 930
 931     return rc;
 932 }
 933
 934 /********************************************************
 935  * ACTION helper functions and functions that perform the actions
 936  *******************************************************/
 937 static BOOL ACTION_HandleCustomAction( MSIPACKAGE* package, LPCWSTR action,
 938                                        UINT* rc, UINT script, BOOL force )
 939 {
 940     BOOL ret=FALSE;
 941     UINT arc;
 942
 943     arc = ACTION_CustomAction(package, action, script, force);
 944
 945     if (arc != ERROR_CALL_NOT_IMPLEMENTED)
 946     {
 947         *rc = arc;
 948         ret = TRUE;
 949     }
 950     return ret;
 951 }
 952
 953 /*
 954  * Actual Action Handlers
 955  */
 956
 957 static UINT ITERATE_CreateFolders(MSIRECORD *row, LPVOID param)
 958 {
 959     MSIPACKAGE *package = param;
 960     LPCWSTR dir, component;
 961     LPWSTR full_path;
 962     MSIRECORD *uirow;
 963     MSIFOLDER *folder;
 964     MSICOMPONENT *comp;
 965
 966     component = MSI_RecordGetString(row, 2);
 967     comp = get_loaded_component(package, component);
 968     if (!comp)
 969         return ERROR_SUCCESS;
 970
 971     if (!comp->Enabled)
 972     {
 973         TRACE("component is disabled\n");
 974         return ERROR_SUCCESS;
 975     }
 976
 977     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
 978     {
 979         TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
 980         comp->Action = comp->Installed;
 981         return ERROR_SUCCESS;
 982     }
 983     comp->Action = INSTALLSTATE_LOCAL;
 984
 985     dir = MSI_RecordGetString(row,1);
 986     if (!dir)
 987     {
 988         ERR("Unable to get folder id\n");
 989         return ERROR_SUCCESS;
 990     }
 991
 992     uirow = MSI_CreateRecord(1);
 993     MSI_RecordSetStringW(uirow, 1, dir);
 994     ui_actiondata(package, szCreateFolders, uirow);
 995     msiobj_release(&uirow->hdr);
 996
 997     full_path = resolve_folder(package,dir,FALSE,FALSE,TRUE,&folder);
 998     if (!full_path)
 999     {
1000         ERR("Unable to resolve folder id %s\n",debugstr_w(dir));
1001         return ERROR_SUCCESS;
1002     }
1003
1004     TRACE("Folder is %s\n",debugstr_w(full_path));
1005
1006     if (folder->State == 0)
1007         create_full_pathW(full_path);
1008
1009     folder->State = 3;
1010
1011     msi_free(full_path);
1012     return ERROR_SUCCESS;
1013 }
1014
1015 static UINT ACTION_CreateFolders(MSIPACKAGE *package)
1016 {
1017     static const WCHAR ExecSeqQuery[] =
1018         {'S','E','L','E','C','T',' ',
1019          '`','D','i','r','e','c','t','o','r','y','_','`',
1020          ' ','F','R','O','M',' ',
1021          '`','C','r','e','a','t','e','F','o','l','d','e','r','`',0 };
1022     UINT rc;
1023     MSIQUERY *view;
1024
1025     /* create all the empty folders specified in the CreateFolder table */
1026     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view );
1027     if (rc != ERROR_SUCCESS)
1028         return ERROR_SUCCESS;
1029
1030     rc = MSI_IterateRecords(view, NULL, ITERATE_CreateFolders, package);
1031     msiobj_release(&view->hdr);
1032
1033     return rc;
1034 }
1035
1036 static UINT ITERATE_RemoveFolders( MSIRECORD *row, LPVOID param )
1037 {
1038     MSIPACKAGE *package = param;
1039     LPCWSTR dir, component;
1040     LPWSTR full_path;
1041     MSIRECORD *uirow;
1042     MSIFOLDER *folder;
1043     MSICOMPONENT *comp;
1044
1045     component = MSI_RecordGetString(row, 2);
1046     comp = get_loaded_component(package, component);
1047     if (!comp)
1048         return ERROR_SUCCESS;
1049
1050     if (!comp->Enabled)
1051     {
1052         TRACE("component is disabled\n");
1053         return ERROR_SUCCESS;
1054     }
1055
1056     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
1057     {
1058         TRACE("Component not scheduled for removal: %s\n", debugstr_w(component));
1059         comp->Action = comp->Installed;
1060         return ERROR_SUCCESS;
1061     }
1062     comp->Action = INSTALLSTATE_ABSENT;
1063
1064     dir = MSI_RecordGetString( row, 1 );
1065     if (!dir)
1066     {
1067         ERR("Unable to get folder id\n");
1068         return ERROR_SUCCESS;
1069     }
1070
1071     full_path = resolve_folder( package, dir, FALSE, FALSE, TRUE, &folder );
1072     if (!full_path)
1073     {
1074         ERR("Unable to resolve folder id %s\n", debugstr_w(dir));
1075         return ERROR_SUCCESS;
1076     }
1077
1078     TRACE("folder is %s\n", debugstr_w(full_path));
1079
1080     uirow = MSI_CreateRecord( 1 );
1081     MSI_RecordSetStringW( uirow, 1, dir );
1082     ui_actiondata( package, szRemoveFolders, uirow );
1083     msiobj_release( &uirow->hdr );
1084
1085     RemoveDirectoryW( full_path );
1086     folder->State = 0;
1087
1088     msi_free( full_path );
1089     return ERROR_SUCCESS;
1090 }
1091
1092 static UINT ACTION_RemoveFolders( MSIPACKAGE *package )
1093 {
1094     static const WCHAR query[] =
1095         {'S','E','L','E','C','T',' ', '`','D','i','r','e','c','t','o','r','y','_','`',
1096          ' ','F','R','O','M',' ', '`','C','r','e','a','t','e','F','o','l','d','e','r','`',0};
1097
1098     MSIQUERY *view;
1099     UINT rc;
1100
1101     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
1102     if (rc != ERROR_SUCCESS)
1103         return ERROR_SUCCESS;
1104
1105     rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveFolders, package );
1106     msiobj_release( &view->hdr );
1107
1108     return rc;
1109 }
1110
1111 static UINT load_component( MSIRECORD *row, LPVOID param )
1112 {
1113     MSIPACKAGE *package = param;
1114     MSICOMPONENT *comp;
1115
1116     comp = msi_alloc_zero( sizeof(MSICOMPONENT) );
1117     if (!comp)
1118         return ERROR_FUNCTION_FAILED;
1119
1120     list_add_tail( &package->components, &comp->entry );
1121
1122     /* fill in the data */
1123     comp->Component = msi_dup_record_field( row, 1 );
1124
1125     TRACE("Loading Component %s\n", debugstr_w(comp->Component));
1126
1127     comp->ComponentId = msi_dup_record_field( row, 2 );
1128     comp->Directory = msi_dup_record_field( row, 3 );
1129     comp->Attributes = MSI_RecordGetInteger(row,4);
1130     comp->Condition = msi_dup_record_field( row, 5 );
1131     comp->KeyPath = msi_dup_record_field( row, 6 );
1132
1133     comp->Installed = INSTALLSTATE_UNKNOWN;
1134     msi_component_set_state(package, comp, INSTALLSTATE_UNKNOWN);
1135
1136     return ERROR_SUCCESS;
1137 }
1138
1139 static UINT load_all_components( MSIPACKAGE *package )
1140 {
1141     static const WCHAR query[] = {
1142         'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
1143          '`','C','o','m','p','o','n','e','n','t','`',0 };
1144     MSIQUERY *view;
1145     UINT r;
1146
1147     if (!list_empty(&package->components))
1148         return ERROR_SUCCESS;
1149
1150     r = MSI_DatabaseOpenViewW( package->db, query, &view );
1151     if (r != ERROR_SUCCESS)
1152         return r;
1153
1154     r = MSI_IterateRecords(view, NULL, load_component, package);
1155     msiobj_release(&view->hdr);
1156     return r;
1157 }
1158
1159 typedef struct {
1160     MSIPACKAGE *package;
1161     MSIFEATURE *feature;
1162 } _ilfs;
1163
1164 static UINT add_feature_component( MSIFEATURE *feature, MSICOMPONENT *comp )
1165 {
1166     ComponentList *cl;
1167
1168     cl = msi_alloc( sizeof (*cl) );
1169     if ( !cl )
1170         return ERROR_NOT_ENOUGH_MEMORY;
1171     cl->component = comp;
1172     list_add_tail( &feature->Components, &cl->entry );
1173
1174     return ERROR_SUCCESS;
1175 }
1176
1177 static UINT add_feature_child( MSIFEATURE *parent, MSIFEATURE *child )
1178 {
1179     FeatureList *fl;
1180
1181     fl = msi_alloc( sizeof(*fl) );
1182     if ( !fl )
1183         return ERROR_NOT_ENOUGH_MEMORY;
1184     fl->feature = child;
1185     list_add_tail( &parent->Children, &fl->entry );
1186
1187     return ERROR_SUCCESS;
1188 }
1189
1190 static UINT iterate_load_featurecomponents(MSIRECORD *row, LPVOID param)
1191 {
1192     _ilfs* ilfs = param;
1193     LPCWSTR component;
1194     MSICOMPONENT *comp;
1195
1196     component = MSI_RecordGetString(row,1);
1197
1198     /* check to see if the component is already loaded */
1199     comp = get_loaded_component( ilfs->package, component );
1200     if (!comp)
1201     {
1202         ERR("unknown component %s\n", debugstr_w(component));
1203         return ERROR_FUNCTION_FAILED;
1204     }
1205
1206     add_feature_component( ilfs->feature, comp );
1207     comp->Enabled = TRUE;
1208
1209     return ERROR_SUCCESS;
1210 }
1211
1212 static MSIFEATURE *find_feature_by_name( MSIPACKAGE *package, LPCWSTR name )
1213 {
1214     MSIFEATURE *feature;
1215
1216     if ( !name )
1217         return NULL;
1218
1219     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1220     {
1221         if ( !lstrcmpW( feature->Feature, name ) )
1222             return feature;
1223     }
1224
1225     return NULL;
1226 }
1227
1228 static UINT load_feature(MSIRECORD * row, LPVOID param)
1229 {
1230     MSIPACKAGE* package = param;
1231     MSIFEATURE* feature;
1232     static const WCHAR Query1[] =
1233         {'S','E','L','E','C','T',' ',
1234          '`','C','o','m','p','o','n','e','n','t','_','`',
1235          ' ','F','R','O','M',' ','`','F','e','a','t','u','r','e',
1236          'C','o','m','p','o','n','e','n','t','s','`',' ',
1237          'W','H','E','R','E',' ',
1238          '`','F','e', 'a','t','u','r','e','_','`',' ','=','\'','%','s','\'',0};
1239     MSIQUERY * view;
1240     UINT    rc;
1241     _ilfs ilfs;
1242
1243     /* fill in the data */
1244
1245     feature = msi_alloc_zero( sizeof (MSIFEATURE) );
1246     if (!feature)
1247         return ERROR_NOT_ENOUGH_MEMORY;
1248
1249     list_init( &feature->Children );
1250     list_init( &feature->Components );
1251
1252     feature->Feature = msi_dup_record_field( row, 1 );
1253
1254     TRACE("Loading feature %s\n",debugstr_w(feature->Feature));
1255
1256     feature->Feature_Parent = msi_dup_record_field( row, 2 );
1257     feature->Title = msi_dup_record_field( row, 3 );
1258     feature->Description = msi_dup_record_field( row, 4 );
1259
1260     if (!MSI_RecordIsNull(row,5))
1261         feature->Display = MSI_RecordGetInteger(row,5);
1262
1263     feature->Level= MSI_RecordGetInteger(row,6);
1264     feature->Directory = msi_dup_record_field( row, 7 );
1265     feature->Attributes = MSI_RecordGetInteger(row,8);
1266
1267     feature->Installed = INSTALLSTATE_UNKNOWN;
1268     msi_feature_set_state(package, feature, INSTALLSTATE_UNKNOWN);
1269
1270     list_add_tail( &package->features, &feature->entry );
1271
1272     /* load feature components */
1273
1274     rc = MSI_OpenQuery( package->db, &view, Query1, feature->Feature );
1275     if (rc != ERROR_SUCCESS)
1276         return ERROR_SUCCESS;
1277
1278     ilfs.package = package;
1279     ilfs.feature = feature;
1280
1281     MSI_IterateRecords(view, NULL, iterate_load_featurecomponents , &ilfs);
1282     msiobj_release(&view->hdr);
1283
1284     return ERROR_SUCCESS;
1285 }
1286
1287 static UINT find_feature_children(MSIRECORD * row, LPVOID param)
1288 {
1289     MSIPACKAGE* package = param;
1290     MSIFEATURE *parent, *child;
1291
1292     child = find_feature_by_name( package, MSI_RecordGetString( row, 1 ) );
1293     if (!child)
1294         return ERROR_FUNCTION_FAILED;
1295
1296     if (!child->Feature_Parent)
1297         return ERROR_SUCCESS;
1298
1299     parent = find_feature_by_name( package, child->Feature_Parent );
1300     if (!parent)
1301         return ERROR_FUNCTION_FAILED;
1302
1303     add_feature_child( parent, child );
1304     return ERROR_SUCCESS;
1305 }
1306
1307 static UINT load_all_features( MSIPACKAGE *package )
1308 {
1309     static const WCHAR query[] = {
1310         'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1311         '`','F','e','a','t','u','r','e','`',' ','O','R','D','E','R',
1312         ' ','B','Y',' ','`','D','i','s','p','l','a','y','`',0};
1313     MSIQUERY *view;
1314     UINT r;
1315
1316     if (!list_empty(&package->features))
1317         return ERROR_SUCCESS;
1318
1319     r = MSI_DatabaseOpenViewW( package->db, query, &view );
1320     if (r != ERROR_SUCCESS)
1321         return r;
1322
1323     r = MSI_IterateRecords( view, NULL, load_feature, package );
1324     if (r != ERROR_SUCCESS)
1325         return r;
1326
1327     r = MSI_IterateRecords( view, NULL, find_feature_children, package );
1328     msiobj_release( &view->hdr );
1329
1330     return r;
1331 }
1332
1333 static LPWSTR folder_split_path(LPWSTR p, WCHAR ch)
1334 {
1335     if (!p)
1336         return p;
1337     p = strchrW(p, ch);
1338     if (!p)
1339         return p;
1340     *p = 0;
1341     return p+1;
1342 }
1343
1344 static UINT load_file_hash(MSIPACKAGE *package, MSIFILE *file)
1345 {
1346     static const WCHAR query[] = {
1347         'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1348         '`','M','s','i','F','i','l','e','H','a','s','h','`',' ',
1349         'W','H','E','R','E',' ','`','F','i','l','e','_','`',' ','=',' ','\'','%','s','\'',0};
1350     MSIQUERY *view = NULL;
1351     MSIRECORD *row = NULL;
1352     UINT r;
1353
1354     TRACE("%s\n", debugstr_w(file->File));
1355
1356     r = MSI_OpenQuery(package->db, &view, query, file->File);
1357     if (r != ERROR_SUCCESS)
1358         goto done;
1359
1360     r = MSI_ViewExecute(view, NULL);
1361     if (r != ERROR_SUCCESS)
1362         goto done;
1363
1364     r = MSI_ViewFetch(view, &row);
1365     if (r != ERROR_SUCCESS)
1366         goto done;
1367
1368     file->hash.dwFileHashInfoSize = sizeof(MSIFILEHASHINFO);
1369     file->hash.dwData[0] = MSI_RecordGetInteger(row, 3);
1370     file->hash.dwData[1] = MSI_RecordGetInteger(row, 4);
1371     file->hash.dwData[2] = MSI_RecordGetInteger(row, 5);
1372     file->hash.dwData[3] = MSI_RecordGetInteger(row, 6);
1373
1374 done:
1375     if (view) msiobj_release(&view->hdr);
1376     if (row) msiobj_release(&row->hdr);
1377     return r;
1378 }
1379
1380 static UINT load_file_disk_id( MSIPACKAGE *package, MSIFILE *file )
1381 {
1382     MSIRECORD *row;
1383     static const WCHAR query[] = {
1384         'S','E','L','E','C','T',' ','`','D','i','s','k','I','d','`',' ', 'F','R','O','M',' ',
1385         '`','M','e','d','i','a','`',' ','W','H','E','R','E',' ',
1386         '`','L','a','s','t','S','e','q','u','e','n','c','e','`',' ','>','=',' ','%','i',0};
1387
1388     row = MSI_QueryGetRecord( package->db, query, file->Sequence );
1389     if (!row)
1390     {
1391         WARN("query failed\n");
1392         return ERROR_FUNCTION_FAILED;
1393     }
1394
1395     file->disk_id = MSI_RecordGetInteger( row, 1 );
1396     msiobj_release( &row->hdr );
1397     return ERROR_SUCCESS;
1398 }
1399
1400 static UINT load_file(MSIRECORD *row, LPVOID param)
1401 {
1402     MSIPACKAGE* package = param;
1403     LPCWSTR component;
1404     MSIFILE *file;
1405
1406     /* fill in the data */
1407
1408     file = msi_alloc_zero( sizeof (MSIFILE) );
1409     if (!file)
1410         return ERROR_NOT_ENOUGH_MEMORY;
1411
1412     file->File = msi_dup_record_field( row, 1 );
1413
1414     component = MSI_RecordGetString( row, 2 );
1415     file->Component = get_loaded_component( package, component );
1416
1417     if (!file->Component)
1418     {
1419         WARN("Component not found: %s\n", debugstr_w(component));
1420         msi_free(file->File);
1421         msi_free(file);
1422         return ERROR_SUCCESS;
1423     }
1424
1425     file->FileName = msi_dup_record_field( row, 3 );
1426     reduce_to_longfilename( file->FileName );
1427
1428     file->ShortName = msi_dup_record_field( row, 3 );
1429     file->LongName = strdupW( folder_split_path(file->ShortName, '|'));
1430
1431     file->FileSize = MSI_RecordGetInteger( row, 4 );
1432     file->Version = msi_dup_record_field( row, 5 );
1433     file->Language = msi_dup_record_field( row, 6 );
1434     file->Attributes = MSI_RecordGetInteger( row, 7 );
1435     file->Sequence = MSI_RecordGetInteger( row, 8 );
1436
1437     file->state = msifs_invalid;
1438
1439     /* if the compressed bits are not set in the file attributes,
1440      * then read the information from the package word count property
1441      */
1442     if (package->WordCount & msidbSumInfoSourceTypeAdminImage)
1443     {
1444         file->IsCompressed = FALSE;
1445     }
1446     else if (file->Attributes &
1447              (msidbFileAttributesCompressed | msidbFileAttributesPatchAdded))
1448     {
1449         file->IsCompressed = TRUE;
1450     }
1451     else if (file->Attributes & msidbFileAttributesNoncompressed)
1452     {
1453         file->IsCompressed = FALSE;
1454     }
1455     else
1456     {
1457         file->IsCompressed = package->WordCount & msidbSumInfoSourceTypeCompressed;
1458     }
1459
1460     load_file_hash(package, file);
1461     load_file_disk_id(package, file);
1462
1463     TRACE("File Loaded (%s)\n",debugstr_w(file->File));
1464
1465     list_add_tail( &package->files, &file->entry );
1466
1467     return ERROR_SUCCESS;
1468 }
1469
1470 static UINT load_all_files(MSIPACKAGE *package)
1471 {
1472     MSIQUERY * view;
1473     UINT rc;
1474     static const WCHAR Query[] =
1475         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1476          '`','F','i','l','e','`',' ', 'O','R','D','E','R',' ','B','Y',' ',
1477          '`','S','e','q','u','e','n','c','e','`', 0};
1478
1479     if (!list_empty(&package->files))
1480         return ERROR_SUCCESS;
1481
1482     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
1483     if (rc != ERROR_SUCCESS)
1484         return ERROR_SUCCESS;
1485
1486     rc = MSI_IterateRecords(view, NULL, load_file, package);
1487     msiobj_release(&view->hdr);
1488
1489     return ERROR_SUCCESS;
1490 }
1491
1492 static UINT load_folder( MSIRECORD *row, LPVOID param )
1493 {
1494     MSIPACKAGE *package = param;
1495     static WCHAR szEmpty[] = { 0 };
1496     LPWSTR p, tgt_short, tgt_long, src_short, src_long;
1497     MSIFOLDER *folder;
1498
1499     folder = msi_alloc_zero( sizeof (MSIFOLDER) );
1500     if (!folder)
1501         return ERROR_NOT_ENOUGH_MEMORY;
1502
1503     folder->Directory = msi_dup_record_field( row, 1 );
1504
1505     TRACE("%s\n", debugstr_w(folder->Directory));
1506
1507     p = msi_dup_record_field(row, 3);
1508
1509     /* split src and target dir */
1510     tgt_short = p;
1511     src_short = folder_split_path( p, ':' );
1512
1513     /* split the long and short paths */
1514     tgt_long = folder_split_path( tgt_short, '|' );
1515     src_long = folder_split_path( src_short, '|' );
1516
1517     /* check for no-op dirs */
1518     if (!lstrcmpW(szDot, tgt_short))
1519         tgt_short = szEmpty;
1520     if (!lstrcmpW(szDot, src_short))
1521         src_short = szEmpty;
1522
1523     if (!tgt_long)
1524         tgt_long = tgt_short;
1525
1526     if (!src_short) {
1527         src_short = tgt_short;
1528         src_long = tgt_long;
1529     }
1530
1531     if (!src_long)
1532         src_long = src_short;
1533
1534     /* FIXME: use the target short path too */
1535     folder->TargetDefault = strdupW(tgt_long);
1536     folder->SourceShortPath = strdupW(src_short);
1537     folder->SourceLongPath = strdupW(src_long);
1538     msi_free(p);
1539
1540     TRACE("TargetDefault = %s\n",debugstr_w( folder->TargetDefault ));
1541     TRACE("SourceLong = %s\n", debugstr_w( folder->SourceLongPath ));
1542     TRACE("SourceShort = %s\n", debugstr_w( folder->SourceShortPath ));
1543
1544     folder->Parent = msi_dup_record_field( row, 2 );
1545
1546     folder->Property = msi_dup_property( package->db, folder->Directory );
1547
1548     list_add_tail( &package->folders, &folder->entry );
1549
1550     TRACE("returning %p\n", folder);
1551
1552     return ERROR_SUCCESS;
1553 }
1554
1555 static UINT load_all_folders( MSIPACKAGE *package )
1556 {
1557     static const WCHAR query[] = {
1558         'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
1559          '`','D','i','r','e','c','t','o','r','y','`',0 };
1560     MSIQUERY *view;
1561     UINT r;
1562
1563     if (!list_empty(&package->folders))
1564         return ERROR_SUCCESS;
1565
1566     r = MSI_DatabaseOpenViewW( package->db, query, &view );
1567     if (r != ERROR_SUCCESS)
1568         return r;
1569
1570     r = MSI_IterateRecords(view, NULL, load_folder, package);
1571     msiobj_release(&view->hdr);
1572     return r;
1573 }
1574
1575 /*
1576  * I am not doing any of the costing functionality yet.
1577  * Mostly looking at doing the Component and Feature loading
1578  *
1579  * The native MSI does A LOT of modification to tables here. Mostly adding
1580  * a lot of temporary columns to the Feature and Component tables.
1581  *
1582  *    note: Native msi also tracks the short filename. But I am only going to
1583  *          track the long ones.  Also looking at this directory table
1584  *          it appears that the directory table does not get the parents
1585  *          resolved base on property only based on their entries in the
1586  *          directory table.
1587  */
1588 static UINT ACTION_CostInitialize(MSIPACKAGE *package)
1589 {
1590     static const WCHAR szCosting[] =
1591         {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
1592
1593     msi_set_property( package->db, szCosting, szZero );
1594     msi_set_property( package->db, cszRootDrive, c_colon );
1595
1596     load_all_folders( package );
1597     load_all_components( package );
1598     load_all_features( package );
1599     load_all_files( package );
1600
1601     return ERROR_SUCCESS;
1602 }
1603
1604 static UINT execute_script(MSIPACKAGE *package, UINT script )
1605 {
1606     UINT i;
1607     UINT rc = ERROR_SUCCESS;
1608
1609     TRACE("Executing Script %i\n",script);
1610
1611     if (!package->script)
1612     {
1613         ERR("no script!\n");
1614         return ERROR_FUNCTION_FAILED;
1615     }
1616
1617     for (i = 0; i < package->script->ActionCount[script]; i++)
1618     {
1619         LPWSTR action;
1620         action = package->script->Actions[script][i];
1621         ui_actionstart(package, action);
1622         TRACE("Executing Action (%s)\n",debugstr_w(action));
1623         rc = ACTION_PerformAction(package, action, script);
1624         if (rc != ERROR_SUCCESS)
1625             break;
1626     }
1627     msi_free_action_script(package, script);
1628     return rc;
1629 }
1630
1631 static UINT ACTION_FileCost(MSIPACKAGE *package)
1632 {
1633     return ERROR_SUCCESS;
1634 }
1635
1636 static void ACTION_GetComponentInstallStates(MSIPACKAGE *package)
1637 {
1638     MSICOMPONENT *comp;
1639     INSTALLSTATE state;
1640     UINT r;
1641
1642     state = MsiQueryProductStateW(package->ProductCode);
1643
1644     LIST_FOR_EACH_ENTRY(comp, &package->components, MSICOMPONENT, entry)
1645     {
1646         if (!comp->ComponentId)
1647             continue;
1648
1649         if (state != INSTALLSTATE_LOCAL && state != INSTALLSTATE_DEFAULT)
1650             comp->Installed = INSTALLSTATE_ABSENT;
1651         else
1652         {
1653             r = MsiQueryComponentStateW(package->ProductCode, NULL,
1654                                         package->Context, comp->ComponentId,
1655                                         &comp->Installed);
1656             if (r != ERROR_SUCCESS)
1657                 comp->Installed = INSTALLSTATE_ABSENT;
1658         }
1659     }
1660 }
1661
1662 static void ACTION_GetFeatureInstallStates(MSIPACKAGE *package)
1663 {
1664     MSIFEATURE *feature;
1665     INSTALLSTATE state;
1666
1667     state = MsiQueryProductStateW(package->ProductCode);
1668
1669     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1670     {
1671         if (state != INSTALLSTATE_LOCAL && state != INSTALLSTATE_DEFAULT)
1672             feature->Installed = INSTALLSTATE_ABSENT;
1673         else
1674         {
1675             feature->Installed = MsiQueryFeatureStateW(package->ProductCode,
1676                                                        feature->Feature);
1677         }
1678     }
1679 }
1680
1681 static BOOL process_state_property(MSIPACKAGE* package, int level,
1682                                    LPCWSTR property, INSTALLSTATE state)
1683 {
1684     LPWSTR override;
1685     MSIFEATURE *feature;
1686
1687     override = msi_dup_property( package->db, property );
1688     if (!override)
1689         return FALSE;
1690
1691     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1692     {
1693         if (lstrcmpW(property, szRemove) &&
1694             (feature->Level <= 0 || feature->Level > level))
1695             continue;
1696
1697         if (!strcmpW(property, szReinstall)) state = feature->Installed;
1698
1699         if (strcmpiW(override, szAll)==0)
1700             msi_feature_set_state(package, feature, state);
1701         else
1702         {
1703             LPWSTR ptr = override;
1704             LPWSTR ptr2 = strchrW(override,',');
1705
1706             while (ptr)
1707             {
1708                 int len = ptr2 - ptr;
1709
1710                 if ((ptr2 && strlenW(feature->Feature) == len && !strncmpW(ptr, feature->Feature, len))
1711                     || (!ptr2 && !strcmpW(ptr, feature->Feature)))
1712                 {
1713                     msi_feature_set_state(package, feature, state);
1714                     break;
1715                 }
1716                 if (ptr2)
1717                 {
1718                     ptr=ptr2+1;
1719                     ptr2 = strchrW(ptr,',');
1720                 }
1721                 else
1722                     break;
1723             }
1724         }
1725     }
1726     msi_free(override);
1727
1728     return TRUE;
1729 }
1730
1731 static BOOL process_overrides( MSIPACKAGE *package, int level )
1732 {
1733     static const WCHAR szAddLocal[] =
1734         {'A','D','D','L','O','C','A','L',0};
1735     static const WCHAR szAddSource[] =
1736         {'A','D','D','S','O','U','R','C','E',0};
1737     static const WCHAR szAdvertise[] =
1738         {'A','D','V','E','R','T','I','S','E',0};
1739     BOOL ret = FALSE;
1740
1741     /* all these activation/deactivation things happen in order and things
1742      * later on the list override things earlier on the list.
1743      *
1744      *  0  INSTALLLEVEL processing
1745      *  1  ADDLOCAL
1746      *  2  REMOVE
1747      *  3  ADDSOURCE
1748      *  4  ADDDEFAULT
1749      *  5  REINSTALL
1750      *  6  ADVERTISE
1751      *  7  COMPADDLOCAL
1752      *  8  COMPADDSOURCE
1753      *  9  FILEADDLOCAL
1754      * 10  FILEADDSOURCE
1755      * 11  FILEADDDEFAULT
1756      */
1757     ret |= process_state_property( package, level, szAddLocal, INSTALLSTATE_LOCAL );
1758     ret |= process_state_property( package, level, szRemove, INSTALLSTATE_ABSENT );
1759     ret |= process_state_property( package, level, szAddSource, INSTALLSTATE_SOURCE );
1760     ret |= process_state_property( package, level, szReinstall, INSTALLSTATE_UNKNOWN );
1761     ret |= process_state_property( package, level, szAdvertise, INSTALLSTATE_ADVERTISED );
1762
1763     if (ret)
1764         msi_set_property( package->db, szPreselected, szOne );
1765
1766     return ret;
1767 }
1768
1769 UINT MSI_SetFeatureStates(MSIPACKAGE *package)
1770 {
1771     int level;
1772     static const WCHAR szlevel[] =
1773         {'I','N','S','T','A','L','L','L','E','V','E','L',0};
1774     MSICOMPONENT* component;
1775     MSIFEATURE *feature;
1776
1777     TRACE("Checking Install Level\n");
1778
1779     level = msi_get_property_int(package->db, szlevel, 1);
1780
1781     if (!msi_get_property_int( package->db, szPreselected, 0 ))
1782     {
1783         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1784         {
1785             BOOL feature_state = ((feature->Level > 0) &&
1786                                   (feature->Level <= level));
1787
1788             if ((feature_state) && (feature->Action == INSTALLSTATE_UNKNOWN))
1789             {
1790                 if (feature->Attributes & msidbFeatureAttributesFavorSource)
1791                     msi_feature_set_state(package, feature, INSTALLSTATE_SOURCE);
1792                 else if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
1793                     msi_feature_set_state(package, feature, INSTALLSTATE_ADVERTISED);
1794                 else
1795                     msi_feature_set_state(package, feature, INSTALLSTATE_LOCAL);
1796             }
1797         }
1798
1799         /* disable child features of unselected parent features */
1800         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1801         {
1802             FeatureList *fl;
1803
1804             if (feature->Level > 0 && feature->Level <= level)
1805                 continue;
1806
1807             LIST_FOR_EACH_ENTRY( fl, &feature->Children, FeatureList, entry )
1808                 msi_feature_set_state(package, fl->feature, INSTALLSTATE_UNKNOWN);
1809         }
1810     }
1811     else
1812     {
1813         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1814         {
1815             BOOL selected = feature->Level > 0 && feature->Level <= level;
1816
1817             if (selected && feature->Action == INSTALLSTATE_UNKNOWN)
1818             {
1819                  msi_feature_set_state(package, feature, feature->Installed);
1820             }
1821         }
1822     }
1823
1824     /*
1825      * now we want to enable or disable components based on feature
1826      */
1827     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1828     {
1829         ComponentList *cl;
1830
1831         TRACE("Examining Feature %s (Level %d Installed %d Request %d Action %d)\n",
1832               debugstr_w(feature->Feature), feature->Level, feature->Installed,
1833               feature->ActionRequest, feature->Action);
1834
1835         if (!feature->Level)
1836             continue;
1837
1838         /* features with components that have compressed files are made local */
1839         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1840         {
1841             if (cl->component->ForceLocalState &&
1842                 feature->Action == INSTALLSTATE_SOURCE)
1843             {
1844                 msi_feature_set_state(package, feature, INSTALLSTATE_LOCAL);
1845                 break;
1846             }
1847         }
1848
1849         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1850         {
1851             component = cl->component;
1852
1853             switch (feature->Action)
1854             {
1855             case INSTALLSTATE_ABSENT:
1856                 component->anyAbsent = 1;
1857                 break;
1858             case INSTALLSTATE_ADVERTISED:
1859                 component->hasAdvertiseFeature = 1;
1860                 break;
1861             case INSTALLSTATE_SOURCE:
1862                 component->hasSourceFeature = 1;
1863                 break;
1864             case INSTALLSTATE_LOCAL:
1865                 component->hasLocalFeature = 1;
1866                 break;
1867             case INSTALLSTATE_DEFAULT:
1868                 if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
1869                     component->hasAdvertiseFeature = 1;
1870                 else if (feature->Attributes & msidbFeatureAttributesFavorSource)
1871                     component->hasSourceFeature = 1;
1872                 else
1873                     component->hasLocalFeature = 1;
1874                 break;
1875             default:
1876                 break;
1877             }
1878         }
1879     }
1880
1881     LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
1882     {
1883         /* check if it's local or source */
1884         if (!(component->Attributes & msidbComponentAttributesOptional) &&
1885              (component->hasLocalFeature || component->hasSourceFeature))
1886         {
1887             if ((component->Attributes & msidbComponentAttributesSourceOnly) &&
1888                  !component->ForceLocalState)
1889                 msi_component_set_state(package, component, INSTALLSTATE_SOURCE);
1890             else
1891                 msi_component_set_state(package, component, INSTALLSTATE_LOCAL);
1892             continue;
1893         }
1894
1895         /* if any feature is local, the component must be local too */
1896         if (component->hasLocalFeature)
1897         {
1898             msi_component_set_state(package, component, INSTALLSTATE_LOCAL);
1899             continue;
1900         }
1901
1902         if (component->hasSourceFeature)
1903         {
1904             msi_component_set_state(package, component, INSTALLSTATE_SOURCE);
1905             continue;
1906         }
1907
1908         if (component->hasAdvertiseFeature)
1909         {
1910             msi_component_set_state(package, component, INSTALLSTATE_ADVERTISED);
1911             continue;
1912         }
1913
1914         TRACE("nobody wants component %s\n", debugstr_w(component->Component));
1915         if (component->anyAbsent)
1916             msi_component_set_state(package, component, INSTALLSTATE_ABSENT);
1917     }
1918
1919     LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
1920     {
1921         if (component->ActionRequest == INSTALLSTATE_DEFAULT)
1922         {
1923             TRACE("%s was default, setting to local\n", debugstr_w(component->Component));
1924             msi_component_set_state(package, component, INSTALLSTATE_LOCAL);
1925         }
1926
1927         TRACE("Result: Component %s (Installed %d Request %d Action %d)\n",
1928               debugstr_w(component->Component), component->Installed, component->ActionRequest, component->Action);
1929     }
1930
1931     return ERROR_SUCCESS;
1932 }
1933
1934 static UINT ITERATE_CostFinalizeDirectories(MSIRECORD *row, LPVOID param)
1935 {
1936     MSIPACKAGE *package = param;
1937     LPCWSTR name;
1938     LPWSTR path;
1939     MSIFOLDER *f;
1940
1941     name = MSI_RecordGetString(row,1);
1942
1943     f = get_loaded_folder(package, name);
1944     if (!f) return ERROR_SUCCESS;
1945
1946     /* reset the ResolvedTarget */
1947     msi_free(f->ResolvedTarget);
1948     f->ResolvedTarget = NULL;
1949
1950     /* This helper function now does ALL the work */
1951     TRACE("Dir %s ...\n",debugstr_w(name));
1952     path = resolve_folder(package,name,FALSE,TRUE,TRUE,NULL);
1953     TRACE("resolves to %s\n",debugstr_w(path));
1954     msi_free(path);
1955
1956     return ERROR_SUCCESS;
1957 }
1958
1959 static UINT ITERATE_CostFinalizeConditions(MSIRECORD *row, LPVOID param)
1960 {
1961     MSIPACKAGE *package = param;
1962     LPCWSTR name;
1963     MSIFEATURE *feature;
1964
1965     name = MSI_RecordGetString( row, 1 );
1966
1967     feature = get_loaded_feature( package, name );
1968     if (!feature)
1969         ERR("FAILED to find loaded feature %s\n",debugstr_w(name));
1970     else
1971     {
1972         LPCWSTR Condition;
1973         Condition = MSI_RecordGetString(row,3);
1974
1975         if (MSI_EvaluateConditionW(package,Condition) == MSICONDITION_TRUE)
1976         {
1977             int level = MSI_RecordGetInteger(row,2);
1978             TRACE("Resetting feature %s to level %i\n", debugstr_w(name), level);
1979             feature->Level = level;
1980         }
1981     }
1982     return ERROR_SUCCESS;
1983 }
1984
1985 VS_FIXEDFILEINFO *msi_get_disk_file_version( LPCWSTR filename )
1986 {
1987     static const WCHAR name[] = {'\\',0};
1988     VS_FIXEDFILEINFO *ret;
1989     LPVOID version;
1990     DWORD versize, handle;
1991     UINT sz;
1992
1993     TRACE("%s\n", debugstr_w(filename));
1994
1995     versize = GetFileVersionInfoSizeW( filename, &handle );
1996     if (!versize)
1997         return NULL;
1998
1999     version = msi_alloc( versize );
2000     if (!version)
2001         return NULL;
2002
2003     GetFileVersionInfoW( filename, 0, versize, version );
2004
2005     if (!VerQueryValueW( version, name, (LPVOID *)&ret, &sz ))
2006     {
2007         msi_free( version );
2008         return NULL;
2009     }
2010
2011     msi_free( version );
2012     return ret;
2013 }
2014
2015 int msi_compare_file_versions( VS_FIXEDFILEINFO *fi, const WCHAR *version )
2016 {
2017     DWORD ms, ls;
2018
2019     msi_parse_version_string( version, &ms, &ls );
2020
2021     if (fi->dwFileVersionMS > ms) return 1;
2022     else if (fi->dwFileVersionMS < ms) return -1;
2023     else if (fi->dwFileVersionLS > ls) return 1;
2024     else if (fi->dwFileVersionLS < ls) return -1;
2025     return 0;
2026 }
2027
2028 static DWORD get_disk_file_size( LPCWSTR filename )
2029 {
2030     HANDLE file;
2031     DWORD size;
2032
2033     TRACE("%s\n", debugstr_w(filename));
2034
2035     file = CreateFileW( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
2036     if (file == INVALID_HANDLE_VALUE)
2037         return INVALID_FILE_SIZE;
2038
2039     size = GetFileSize( file, NULL );
2040     CloseHandle( file );
2041     return size;
2042 }
2043
2044 static BOOL hash_matches( MSIFILE *file )
2045 {
2046     UINT r;
2047     MSIFILEHASHINFO hash;
2048
2049     hash.dwFileHashInfoSize = sizeof(MSIFILEHASHINFO);
2050     r = MsiGetFileHashW( file->TargetPath, 0, &hash );
2051     if (r != ERROR_SUCCESS)
2052         return FALSE;
2053
2054     return !memcmp( &hash, &file->hash, sizeof(MSIFILEHASHINFO) );
2055 }
2056
2057 static UINT set_file_install_states( MSIPACKAGE *package )
2058 {
2059     VS_FIXEDFILEINFO *file_version;
2060     MSIFILE *file;
2061
2062     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2063     {
2064         MSICOMPONENT* comp = file->Component;
2065         DWORD file_size;
2066         LPWSTR p;
2067
2068         if (!comp)
2069             continue;
2070
2071         if (file->IsCompressed)
2072             comp->ForceLocalState = TRUE;
2073
2074         /* calculate target */
2075         p = resolve_folder(package, comp->Directory, FALSE, FALSE, TRUE, NULL);
2076         msi_free(file->TargetPath);
2077
2078         TRACE("file %s is named %s\n", debugstr_w(file->File), debugstr_w(file->FileName));
2079
2080         file->TargetPath = build_directory_name(2, p, file->FileName);
2081         msi_free(p);
2082
2083         TRACE("file %s resolves to %s\n", debugstr_w(file->File), debugstr_w(file->TargetPath));
2084
2085         if (GetFileAttributesW(file->TargetPath) == INVALID_FILE_ATTRIBUTES)
2086         {
2087             file->state = msifs_missing;
2088             comp->Cost += file->FileSize;
2089             continue;
2090         }
2091         if (file->Version && (file_version = msi_get_disk_file_version( file->TargetPath )))
2092         {
2093             TRACE("new %s old %u.%u.%u.%u\n", debugstr_w(file->Version),
2094                   HIWORD(file_version->dwFileVersionMS),
2095                   LOWORD(file_version->dwFileVersionMS),
2096                   HIWORD(file_version->dwFileVersionLS),
2097                   LOWORD(file_version->dwFileVersionLS));
2098
2099             if (msi_compare_file_versions( file_version, file->Version ) < 0)
2100             {
2101                 file->state = msifs_overwrite;
2102                 comp->Cost += file->FileSize;
2103             }
2104             else
2105             {
2106                 TRACE("Destination file version equal or greater, not overwriting\n");
2107                 file->state = msifs_present;
2108             }
2109             msi_free( file_version );
2110             continue;
2111         }
2112         if ((file_size = get_disk_file_size( file->TargetPath )) != file->FileSize)
2113         {
2114             file->state = msifs_overwrite;
2115             comp->Cost += file->FileSize - file_size;
2116             continue;
2117         }
2118         if (file->hash.dwFileHashInfoSize && hash_matches( file ))
2119         {
2120             TRACE("File hashes match, not overwriting\n");
2121             file->state = msifs_present;
2122             continue;
2123         }
2124         file->state = msifs_overwrite;
2125         comp->Cost += file->FileSize - file_size;
2126     }
2127
2128     return ERROR_SUCCESS;
2129 }
2130
2131 /*
2132  * A lot is done in this function aside from just the costing.
2133  * The costing needs to be implemented at some point but for now I am going
2134  * to focus on the directory building
2135  *
2136  */
2137 static UINT ACTION_CostFinalize(MSIPACKAGE *package)
2138 {
2139     static const WCHAR ExecSeqQuery[] =
2140         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2141          '`','D','i','r','e','c','t','o','r','y','`',0};
2142     static const WCHAR ConditionQuery[] =
2143         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2144          '`','C','o','n','d','i','t','i','o','n','`',0};
2145     static const WCHAR szCosting[] =
2146         {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
2147     static const WCHAR szlevel[] =
2148         {'I','N','S','T','A','L','L','L','E','V','E','L',0};
2149     static const WCHAR szOutOfDiskSpace[] =
2150         {'O','u','t','O','f','D','i','s','k','S','p','a','c','e',0};
2151     MSICOMPONENT *comp;
2152     UINT rc = ERROR_SUCCESS;
2153     MSIQUERY * view;
2154     LPWSTR level;
2155
2156     TRACE("Building Directory properties\n");
2157
2158     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2159     if (rc == ERROR_SUCCESS)
2160     {
2161         rc = MSI_IterateRecords(view, NULL, ITERATE_CostFinalizeDirectories,
2162                         package);
2163         msiobj_release(&view->hdr);
2164     }
2165
2166     /* read components states from the registry */
2167     ACTION_GetComponentInstallStates(package);
2168     ACTION_GetFeatureInstallStates(package);
2169
2170     TRACE("Calculating file install states\n");
2171     set_file_install_states( package );
2172
2173     if (!process_overrides( package, msi_get_property_int( package->db, szlevel, 1 ) ))
2174     {
2175         TRACE("Evaluating feature conditions\n");
2176
2177         rc = MSI_DatabaseOpenViewW( package->db, ConditionQuery, &view );
2178         if (rc == ERROR_SUCCESS)
2179         {
2180             rc = MSI_IterateRecords( view, NULL, ITERATE_CostFinalizeConditions, package );
2181             msiobj_release( &view->hdr );
2182         }
2183     }
2184     TRACE("Evaluating component conditions\n");
2185
2186     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2187     {
2188         if (MSI_EvaluateConditionW( package, comp->Condition ) == MSICONDITION_FALSE)
2189         {
2190             TRACE("Disabling component %s\n", debugstr_w(comp->Component));
2191             comp->Enabled = FALSE;
2192         }
2193         else
2194             comp->Enabled = TRUE;
2195     }
2196
2197     msi_set_property( package->db, szCosting, szOne );
2198     /* set default run level if not set */
2199     level = msi_dup_property( package->db, szlevel );
2200     if (!level)
2201         msi_set_property( package->db, szlevel, szOne );
2202     msi_free(level);
2203
2204     /* FIXME: check volume disk space */
2205     msi_set_property( package->db, szOutOfDiskSpace, szZero );
2206
2207     return MSI_SetFeatureStates(package);
2208 }
2209
2210 /* OK this value is "interpreted" and then formatted based on the
2211    first few characters */
2212 static LPSTR parse_value(MSIPACKAGE *package, LPCWSTR value, DWORD *type,
2213                          DWORD *size)
2214 {
2215     LPSTR data = NULL;
2216
2217     if (value[0]=='#' && value[1]!='#' && value[1]!='%')
2218     {
2219         if (value[1]=='x')
2220         {
2221             LPWSTR ptr;
2222             CHAR byte[5];
2223             LPWSTR deformated = NULL;
2224             int count;
2225
2226             deformat_string(package, &value[2], &deformated);
2227
2228             /* binary value type */
2229             ptr = deformated;
2230             *type = REG_BINARY;
2231             if (strlenW(ptr)%2)
2232                 *size = (strlenW(ptr)/2)+1;
2233             else
2234                 *size = strlenW(ptr)/2;
2235
2236             data = msi_alloc(*size);
2237
2238             byte[0] = '0';
2239             byte[1] = 'x';
2240             byte[4] = 0;
2241             count = 0;
2242             /* if uneven pad with a zero in front */
2243             if (strlenW(ptr)%2)
2244             {
2245                 byte[2]= '0';
2246                 byte[3]= *ptr;
2247                 ptr++;
2248                 data[count] = (BYTE)strtol(byte,NULL,0);
2249                 count ++;
2250                 TRACE("Uneven byte count\n");
2251             }
2252             while (*ptr)
2253             {
2254                 byte[2]= *ptr;
2255                 ptr++;
2256                 byte[3]= *ptr;
2257                 ptr++;
2258                 data[count] = (BYTE)strtol(byte,NULL,0);
2259                 count ++;
2260             }
2261             msi_free(deformated);
2262
2263             TRACE("Data %i bytes(%i)\n",*size,count);
2264         }
2265         else
2266         {
2267             LPWSTR deformated;
2268             LPWSTR p;
2269             DWORD d = 0;
2270             deformat_string(package, &value[1], &deformated);
2271
2272             *type=REG_DWORD;
2273             *size = sizeof(DWORD);
2274             data = msi_alloc(*size);
2275             p = deformated;
2276             if (*p == '-')
2277                 p++;
2278             while (*p)
2279             {
2280                 if ( (*p < '0') || (*p > '9') )
2281                     break;
2282                 d *= 10;
2283                 d += (*p - '0');
2284                 p++;
2285             }
2286             if (deformated[0] == '-')
2287                 d = -d;
2288             *(LPDWORD)data = d;
2289             TRACE("DWORD %i\n",*(LPDWORD)data);
2290
2291             msi_free(deformated);
2292         }
2293     }
2294     else
2295     {
2296         static const WCHAR szMulti[] = {'[','~',']',0};
2297         LPCWSTR ptr;
2298         *type=REG_SZ;
2299
2300         if (value[0]=='#')
2301         {
2302             if (value[1]=='%')
2303             {
2304                 ptr = &value[2];
2305                 *type=REG_EXPAND_SZ;
2306             }
2307             else
2308                 ptr = &value[1];
2309          }
2310          else
2311             ptr=value;
2312
2313         if (strstrW(value,szMulti))
2314             *type = REG_MULTI_SZ;
2315
2316         /* remove initial delimiter */
2317         if (!strncmpW(value, szMulti, 3))
2318             ptr = value + 3;
2319
2320         *size = deformat_string(package, ptr,(LPWSTR*)&data);
2321
2322         /* add double NULL terminator */
2323         if (*type == REG_MULTI_SZ)
2324         {
2325             *size += 2 * sizeof(WCHAR); /* two NULL terminators */
2326             data = msi_realloc_zero(data, *size);
2327         }
2328     }
2329     return data;
2330 }
2331
2332 static const WCHAR *get_root_key( MSIPACKAGE *package, INT root, HKEY *root_key )
2333 {
2334     const WCHAR *ret;
2335
2336     switch (root)
2337     {
2338     case -1:
2339         if (msi_get_property_int( package->db, szAllUsers, 0 ))
2340         {
2341             *root_key = HKEY_LOCAL_MACHINE;
2342             ret = szHLM;
2343         }
2344         else
2345         {
2346             *root_key = HKEY_CURRENT_USER;
2347             ret = szHCU;
2348         }
2349         break;
2350     case 0:
2351         *root_key = HKEY_CLASSES_ROOT;
2352         ret = szHCR;
2353         break;
2354     case 1:
2355         *root_key = HKEY_CURRENT_USER;
2356         ret = szHCU;
2357         break;
2358     case 2:
2359         *root_key = HKEY_LOCAL_MACHINE;
2360         ret = szHLM;
2361         break;
2362     case 3:
2363         *root_key = HKEY_USERS;
2364         ret = szHU;
2365         break;
2366     default:
2367         ERR("Unknown root %i\n", root);
2368         return NULL;
2369     }
2370
2371     return ret;
2372 }
2373
2374 static UINT ITERATE_WriteRegistryValues(MSIRECORD *row, LPVOID param)
2375 {
2376     MSIPACKAGE *package = param;
2377     LPSTR value_data = NULL;
2378     HKEY  root_key, hkey;
2379     DWORD type,size;
2380     LPWSTR  deformated;
2381     LPCWSTR szRoot, component, name, key, value;
2382     MSICOMPONENT *comp;
2383     MSIRECORD * uirow;
2384     LPWSTR uikey;
2385     INT   root;
2386     BOOL check_first = FALSE;
2387     UINT rc;
2388
2389     ui_progress(package,2,0,0,0);
2390
2391     component = MSI_RecordGetString(row, 6);
2392     comp = get_loaded_component(package,component);
2393     if (!comp)
2394         return ERROR_SUCCESS;
2395
2396     if (!comp->Enabled)
2397     {
2398         TRACE("component is disabled\n");
2399         return ERROR_SUCCESS;
2400     }
2401
2402     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
2403     {
2404         TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
2405         comp->Action = comp->Installed;
2406         return ERROR_SUCCESS;
2407     }
2408     comp->Action = INSTALLSTATE_LOCAL;
2409
2410     name = MSI_RecordGetString(row, 4);
2411     if( MSI_RecordIsNull(row,5) && name )
2412     {
2413         /* null values can have special meanings */
2414         if (name[0]=='-' && name[1] == 0)
2415                 return ERROR_SUCCESS;
2416         else if ((name[0]=='+' && name[1] == 0) ||
2417                  (name[0] == '*' && name[1] == 0))
2418                 name = NULL;
2419         check_first = TRUE;
2420     }
2421
2422     root = MSI_RecordGetInteger(row,2);
2423     key = MSI_RecordGetString(row, 3);
2424
2425     szRoot = get_root_key( package, root, &root_key );
2426     if (!szRoot)
2427         return ERROR_SUCCESS;
2428
2429     deformat_string(package, key , &deformated);
2430     size = strlenW(deformated) + strlenW(szRoot) + 1;
2431     uikey = msi_alloc(size*sizeof(WCHAR));
2432     strcpyW(uikey,szRoot);
2433     strcatW(uikey,deformated);
2434
2435     if (RegCreateKeyW( root_key, deformated, &hkey))
2436     {
2437         ERR("Could not create key %s\n",debugstr_w(deformated));
2438         msi_free(deformated);
2439         msi_free(uikey);
2440         return ERROR_SUCCESS;
2441     }
2442     msi_free(deformated);
2443
2444     value = MSI_RecordGetString(row,5);
2445     if (value)
2446         value_data = parse_value(package, value, &type, &size);
2447     else
2448     {
2449         value_data = (LPSTR)strdupW(szEmpty);
2450         size = sizeof(szEmpty);
2451         type = REG_SZ;
2452     }
2453
2454     deformat_string(package, name, &deformated);
2455
2456     if (!check_first)
2457     {
2458         TRACE("Setting value %s of %s\n",debugstr_w(deformated),
2459                         debugstr_w(uikey));
2460         RegSetValueExW(hkey, deformated, 0, type, (LPBYTE)value_data, size);
2461     }
2462     else
2463     {
2464         DWORD sz = 0;
2465         rc = RegQueryValueExW(hkey, deformated, NULL, NULL, NULL, &sz);
2466         if (rc == ERROR_SUCCESS || rc == ERROR_MORE_DATA)
2467         {
2468             TRACE("value %s of %s checked already exists\n",
2469                             debugstr_w(deformated), debugstr_w(uikey));
2470         }
2471         else
2472         {
2473             TRACE("Checked and setting value %s of %s\n",
2474                             debugstr_w(deformated), debugstr_w(uikey));
2475             if (deformated || size)
2476                 RegSetValueExW(hkey, deformated, 0, type, (LPBYTE) value_data, size);
2477         }
2478     }
2479     RegCloseKey(hkey);
2480
2481     uirow = MSI_CreateRecord(3);
2482     MSI_RecordSetStringW(uirow,2,deformated);
2483     MSI_RecordSetStringW(uirow,1,uikey);
2484     if (type == REG_SZ || type == REG_EXPAND_SZ)
2485         MSI_RecordSetStringW(uirow,3,(LPWSTR)value_data);
2486     ui_actiondata(package,szWriteRegistryValues,uirow);
2487     msiobj_release( &uirow->hdr );
2488
2489     msi_free(value_data);
2490     msi_free(deformated);
2491     msi_free(uikey);
2492
2493     return ERROR_SUCCESS;
2494 }
2495
2496 static UINT ACTION_WriteRegistryValues(MSIPACKAGE *package)
2497 {
2498     UINT rc;
2499     MSIQUERY * view;
2500     static const WCHAR ExecSeqQuery[] =
2501         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2502          '`','R','e','g','i','s','t','r','y','`',0 };
2503
2504     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2505     if (rc != ERROR_SUCCESS)
2506         return ERROR_SUCCESS;
2507
2508     /* increment progress bar each time action data is sent */
2509     ui_progress(package,1,REG_PROGRESS_VALUE,1,0);
2510
2511     rc = MSI_IterateRecords(view, NULL, ITERATE_WriteRegistryValues, package);
2512
2513     msiobj_release(&view->hdr);
2514     return rc;
2515 }
2516
2517 static void delete_reg_key_or_value( HKEY hkey_root, LPCWSTR key, LPCWSTR value, BOOL delete_key )
2518 {
2519     LONG res;
2520     HKEY hkey;
2521     DWORD num_subkeys, num_values;
2522
2523     if (delete_key)
2524     {
2525         if ((res = RegDeleteTreeW( hkey_root, key )))
2526         {
2527             WARN("Failed to delete key %s (%d)\n", debugstr_w(key), res);
2528         }
2529         return;
2530     }
2531
2532     if (!(res = RegOpenKeyW( hkey_root, key, &hkey )))
2533     {
2534         if ((res = RegDeleteValueW( hkey, value )))
2535         {
2536             WARN("Failed to delete value %s (%d)\n", debugstr_w(value), res);
2537         }
2538         res = RegQueryInfoKeyW( hkey, NULL, NULL, NULL, &num_subkeys, NULL, NULL, &num_values,
2539                                 NULL, NULL, NULL, NULL );
2540         RegCloseKey( hkey );
2541
2542         if (!res && !num_subkeys && !num_values)
2543         {
2544             TRACE("Removing empty key %s\n", debugstr_w(key));
2545             RegDeleteKeyW( hkey_root, key );
2546         }
2547         return;
2548     }
2549     WARN("Failed to open key %s (%d)\n", debugstr_w(key), res);
2550 }
2551
2552
2553 static UINT ITERATE_RemoveRegistryValuesOnUninstall( MSIRECORD *row, LPVOID param )
2554 {
2555     MSIPACKAGE *package = param;
2556     LPCWSTR component, name, key_str, root_key_str;
2557     LPWSTR deformated_key, deformated_name, ui_key_str;
2558     MSICOMPONENT *comp;
2559     MSIRECORD *uirow;
2560     BOOL delete_key = FALSE;
2561     HKEY hkey_root;
2562     UINT size;
2563     INT root;
2564
2565     ui_progress( package, 2, 0, 0, 0 );
2566
2567     component = MSI_RecordGetString( row, 6 );
2568     comp = get_loaded_component( package, component );
2569     if (!comp)
2570         return ERROR_SUCCESS;
2571
2572     if (!comp->Enabled)
2573     {
2574         TRACE("component is disabled\n");
2575         return ERROR_SUCCESS;
2576     }
2577
2578     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
2579     {
2580         TRACE("Component not scheduled for removal: %s\n", debugstr_w(component));
2581         comp->Action = comp->Installed;
2582         return ERROR_SUCCESS;
2583     }
2584     comp->Action = INSTALLSTATE_ABSENT;
2585
2586     name = MSI_RecordGetString( row, 4 );
2587     if (MSI_RecordIsNull( row, 5 ) && name )
2588     {
2589         if (name[0] == '+' && !name[1])
2590             return ERROR_SUCCESS;
2591         else if ((name[0] == '-' && !name[1]) || (name[0] == '*' && !name[1]))
2592         {
2593             delete_key = TRUE;
2594             name = NULL;
2595         }
2596     }
2597
2598     root = MSI_RecordGetInteger( row, 2 );
2599     key_str = MSI_RecordGetString( row, 3 );
2600
2601     root_key_str = get_root_key( package, root, &hkey_root );
2602     if (!root_key_str)
2603         return ERROR_SUCCESS;
2604
2605     deformat_string( package, key_str, &deformated_key );
2606     size = strlenW( deformated_key ) + strlenW( root_key_str ) + 1;
2607     ui_key_str = msi_alloc( size * sizeof(WCHAR) );
2608     strcpyW( ui_key_str, root_key_str );
2609     strcatW( ui_key_str, deformated_key );
2610
2611     deformat_string( package, name, &deformated_name );
2612
2613     delete_reg_key_or_value( hkey_root, deformated_key, deformated_name, delete_key );
2614     msi_free( deformated_key );
2615
2616     uirow = MSI_CreateRecord( 2 );
2617     MSI_RecordSetStringW( uirow, 1, ui_key_str );
2618     MSI_RecordSetStringW( uirow, 2, deformated_name );
2619
2620     ui_actiondata( package, szRemoveRegistryValues, uirow );
2621     msiobj_release( &uirow->hdr );
2622
2623     msi_free( ui_key_str );
2624     msi_free( deformated_name );
2625     return ERROR_SUCCESS;
2626 }
2627
2628 static UINT ITERATE_RemoveRegistryValuesOnInstall( MSIRECORD *row, LPVOID param )
2629 {
2630     MSIPACKAGE *package = param;
2631     LPCWSTR component, name, key_str, root_key_str;
2632     LPWSTR deformated_key, deformated_name, ui_key_str;
2633     MSICOMPONENT *comp;
2634     MSIRECORD *uirow;
2635     BOOL delete_key = FALSE;
2636     HKEY hkey_root;
2637     UINT size;
2638     INT root;
2639
2640     ui_progress( package, 2, 0, 0, 0 );
2641
2642     component = MSI_RecordGetString( row, 5 );
2643     comp = get_loaded_component( package, component );
2644     if (!comp)
2645         return ERROR_SUCCESS;
2646
2647     if (!comp->Enabled)
2648     {
2649         TRACE("component is disabled\n");
2650         return ERROR_SUCCESS;
2651     }
2652
2653     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
2654     {
2655         TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
2656         comp->Action = comp->Installed;
2657         return ERROR_SUCCESS;
2658     }
2659     comp->Action = INSTALLSTATE_LOCAL;
2660
2661     if ((name = MSI_RecordGetString( row, 4 )))
2662     {
2663         if (name[0] == '-' && !name[1])
2664         {
2665             delete_key = TRUE;
2666             name = NULL;
2667         }
2668     }
2669
2670     root = MSI_RecordGetInteger( row, 2 );
2671     key_str = MSI_RecordGetString( row, 3 );
2672
2673     root_key_str = get_root_key( package, root, &hkey_root );
2674     if (!root_key_str)
2675         return ERROR_SUCCESS;
2676
2677     deformat_string( package, key_str, &deformated_key );
2678     size = strlenW( deformated_key ) + strlenW( root_key_str ) + 1;
2679     ui_key_str = msi_alloc( size * sizeof(WCHAR) );
2680     strcpyW( ui_key_str, root_key_str );
2681     strcatW( ui_key_str, deformated_key );
2682
2683     deformat_string( package, name, &deformated_name );
2684
2685     delete_reg_key_or_value( hkey_root, deformated_key, deformated_name, delete_key );
2686     msi_free( deformated_key );
2687
2688     uirow = MSI_CreateRecord( 2 );
2689     MSI_RecordSetStringW( uirow, 1, ui_key_str );
2690     MSI_RecordSetStringW( uirow, 2, deformated_name );
2691
2692     ui_actiondata( package, szRemoveRegistryValues, uirow );
2693     msiobj_release( &uirow->hdr );
2694
2695     msi_free( ui_key_str );
2696     msi_free( deformated_name );
2697     return ERROR_SUCCESS;
2698 }
2699
2700 static UINT ACTION_RemoveRegistryValues( MSIPACKAGE *package )
2701 {
2702     UINT rc;
2703     MSIQUERY *view;
2704     static const WCHAR registry_query[] =
2705         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2706          '`','R','e','g','i','s','t','r','y','`',0 };
2707     static const WCHAR remove_registry_query[] =
2708         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2709          '`','R','e','m','o','v','e','R','e','g','i','s','t','r','y','`',0 };
2710
2711     /* increment progress bar each time action data is sent */
2712     ui_progress( package, 1, REG_PROGRESS_VALUE, 1, 0 );
2713
2714     rc = MSI_DatabaseOpenViewW( package->db, registry_query, &view );
2715     if (rc == ERROR_SUCCESS)
2716     {
2717         rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveRegistryValuesOnUninstall, package );
2718         msiobj_release( &view->hdr );
2719         if (rc != ERROR_SUCCESS)
2720             return rc;
2721     }
2722
2723     rc = MSI_DatabaseOpenViewW( package->db, remove_registry_query, &view );
2724     if (rc == ERROR_SUCCESS)
2725     {
2726         rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveRegistryValuesOnInstall, package );
2727         msiobj_release( &view->hdr );
2728         if (rc != ERROR_SUCCESS)
2729             return rc;
2730     }
2731
2732     return ERROR_SUCCESS;
2733 }
2734
2735 static UINT ACTION_InstallInitialize(MSIPACKAGE *package)
2736 {
2737     package->script->CurrentlyScripting = TRUE;
2738
2739     return ERROR_SUCCESS;
2740 }
2741
2742
2743 static UINT ACTION_InstallValidate(MSIPACKAGE *package)
2744 {
2745     MSICOMPONENT *comp;
2746     DWORD progress = 0;
2747     DWORD total = 0;
2748     static const WCHAR q1[]=
2749         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
2750          '`','R','e','g','i','s','t','r','y','`',0};
2751     UINT rc;
2752     MSIQUERY * view;
2753     MSIFEATURE *feature;
2754     MSIFILE *file;
2755
2756     TRACE("InstallValidate\n");
2757
2758     rc = MSI_DatabaseOpenViewW(package->db, q1, &view);
2759     if (rc == ERROR_SUCCESS)
2760     {
2761         MSI_IterateRecords( view, &progress, NULL, package );
2762         msiobj_release( &view->hdr );
2763         total += progress * REG_PROGRESS_VALUE;
2764     }
2765
2766     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2767         total += COMPONENT_PROGRESS_VALUE;
2768
2769     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2770         total += file->FileSize;
2771
2772     ui_progress(package,0,total,0,0);
2773
2774     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2775     {
2776         TRACE("Feature: %s Installed %d Request %d Action %d\n",
2777               debugstr_w(feature->Feature), feature->Installed,
2778               feature->ActionRequest, feature->Action);
2779     }
2780
2781     return ERROR_SUCCESS;
2782 }
2783
2784 static UINT ITERATE_LaunchConditions(MSIRECORD *row, LPVOID param)
2785 {
2786     MSIPACKAGE* package = param;
2787     LPCWSTR cond = NULL;
2788     LPCWSTR message = NULL;
2789     UINT r;
2790
2791     static const WCHAR title[]=
2792         {'I','n','s','t','a','l','l',' ','F','a', 'i','l','e','d',0};
2793
2794     cond = MSI_RecordGetString(row,1);
2795
2796     r = MSI_EvaluateConditionW(package,cond);
2797     if (r == MSICONDITION_FALSE)
2798     {
2799         if ((gUILevel & INSTALLUILEVEL_MASK) != INSTALLUILEVEL_NONE)
2800         {
2801             LPWSTR deformated;
2802             message = MSI_RecordGetString(row,2);
2803             deformat_string(package,message,&deformated);
2804             MessageBoxW(NULL,deformated,title,MB_OK);
2805             msi_free(deformated);
2806         }
2807
2808         return ERROR_INSTALL_FAILURE;
2809     }
2810
2811     return ERROR_SUCCESS;
2812 }
2813
2814 static UINT ACTION_LaunchConditions(MSIPACKAGE *package)
2815 {
2816     UINT rc;
2817     MSIQUERY * view = NULL;
2818     static const WCHAR ExecSeqQuery[] =
2819         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2820          '`','L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','`',0};
2821
2822     TRACE("Checking launch conditions\n");
2823
2824     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2825     if (rc != ERROR_SUCCESS)
2826         return ERROR_SUCCESS;
2827
2828     rc = MSI_IterateRecords(view, NULL, ITERATE_LaunchConditions, package);
2829     msiobj_release(&view->hdr);
2830
2831     return rc;
2832 }
2833
2834 static LPWSTR resolve_keypath( MSIPACKAGE* package, MSICOMPONENT *cmp )
2835 {
2836
2837     if (!cmp->KeyPath)
2838         return resolve_folder(package,cmp->Directory,FALSE,FALSE,TRUE,NULL);
2839
2840     if (cmp->Attributes & msidbComponentAttributesRegistryKeyPath)
2841     {
2842         MSIRECORD * row = 0;
2843         UINT root,len;
2844         LPWSTR deformated,buffer,deformated_name;
2845         LPCWSTR key,name;
2846         static const WCHAR ExecSeqQuery[] =
2847             {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2848              '`','R','e','g','i','s','t','r','y','`',' ',
2849              'W','H','E','R','E',' ', '`','R','e','g','i','s','t','r','y','`',
2850              ' ','=',' ' ,'\'','%','s','\'',0 };
2851         static const WCHAR fmt[]={'%','0','2','i',':','\\','%','s','\\',0};
2852         static const WCHAR fmt2[]=
2853             {'%','0','2','i',':','\\','%','s','\\','%','s',0};
2854
2855         row = MSI_QueryGetRecord(package->db, ExecSeqQuery,cmp->KeyPath);
2856         if (!row)
2857             return NULL;
2858
2859         root = MSI_RecordGetInteger(row,2);
2860         key = MSI_RecordGetString(row, 3);
2861         name = MSI_RecordGetString(row, 4);
2862         deformat_string(package, key , &deformated);
2863         deformat_string(package, name, &deformated_name);
2864
2865         len = strlenW(deformated) + 6;
2866         if (deformated_name)
2867             len+=strlenW(deformated_name);
2868
2869         buffer = msi_alloc( len *sizeof(WCHAR));
2870
2871         if (deformated_name)
2872             sprintfW(buffer,fmt2,root,deformated,deformated_name);
2873         else
2874             sprintfW(buffer,fmt,root,deformated);
2875
2876         msi_free(deformated);
2877         msi_free(deformated_name);
2878         msiobj_release(&row->hdr);
2879
2880         return buffer;
2881     }
2882     else if (cmp->Attributes & msidbComponentAttributesODBCDataSource)
2883     {
2884         FIXME("UNIMPLEMENTED keypath as ODBC Source\n");
2885         return NULL;
2886     }
2887     else
2888     {
2889         MSIFILE *file = get_loaded_file( package, cmp->KeyPath );
2890
2891         if (file)
2892             return strdupW( file->TargetPath );
2893     }
2894     return NULL;
2895 }
2896
2897 static HKEY openSharedDLLsKey(void)
2898 {
2899     HKEY hkey=0;
2900     static const WCHAR path[] =
2901         {'S','o','f','t','w','a','r','e','\\',
2902          'M','i','c','r','o','s','o','f','t','\\',
2903          'W','i','n','d','o','w','s','\\',
2904          'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
2905          'S','h','a','r','e','d','D','L','L','s',0};
2906
2907     RegCreateKeyW(HKEY_LOCAL_MACHINE,path,&hkey);
2908     return hkey;
2909 }
2910
2911 static UINT ACTION_GetSharedDLLsCount(LPCWSTR dll)
2912 {
2913     HKEY hkey;
2914     DWORD count=0;
2915     DWORD type;
2916     DWORD sz = sizeof(count);
2917     DWORD rc;
2918
2919     hkey = openSharedDLLsKey();
2920     rc = RegQueryValueExW(hkey, dll, NULL, &type, (LPBYTE)&count, &sz);
2921     if (rc != ERROR_SUCCESS)
2922         count = 0;
2923     RegCloseKey(hkey);
2924     return count;
2925 }
2926
2927 static UINT ACTION_WriteSharedDLLsCount(LPCWSTR path, UINT count)
2928 {
2929     HKEY hkey;
2930
2931     hkey = openSharedDLLsKey();
2932     if (count > 0)
2933         msi_reg_set_val_dword( hkey, path, count );
2934     else
2935         RegDeleteValueW(hkey,path);
2936     RegCloseKey(hkey);
2937     return count;
2938 }
2939
2940 /*
2941  * Return TRUE if the count should be written out and FALSE if not
2942  */
2943 static void ACTION_RefCountComponent( MSIPACKAGE* package, MSICOMPONENT *comp )
2944 {
2945     MSIFEATURE *feature;
2946     INT count = 0;
2947     BOOL write = FALSE;
2948
2949     /* only refcount DLLs */
2950     if (comp->KeyPath == NULL ||
2951         comp->Attributes & msidbComponentAttributesRegistryKeyPath ||
2952         comp->Attributes & msidbComponentAttributesODBCDataSource)
2953         write = FALSE;
2954     else
2955     {
2956         count = ACTION_GetSharedDLLsCount( comp->FullKeypath);
2957         write = (count > 0);
2958
2959         if (comp->Attributes & msidbComponentAttributesSharedDllRefCount)
2960             write = TRUE;
2961     }
2962
2963     /* increment counts */
2964     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2965     {
2966         ComponentList *cl;
2967
2968         if (feature->ActionRequest != INSTALLSTATE_LOCAL)
2969             continue;
2970
2971         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
2972         {
2973             if ( cl->component == comp )
2974                 count++;
2975         }
2976     }
2977
2978     /* decrement counts */
2979     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2980     {
2981         ComponentList *cl;
2982
2983         if (feature->ActionRequest != INSTALLSTATE_ABSENT)
2984             continue;
2985
2986         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
2987         {
2988             if ( cl->component == comp )
2989                 count--;
2990         }
2991     }
2992
2993     /* ref count all the files in the component */
2994     if (write)
2995     {
2996         MSIFILE *file;
2997
2998         LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2999         {
3000             if (file->Component == comp)
3001                 ACTION_WriteSharedDLLsCount( file->TargetPath, count );
3002         }
3003     }
3004
3005     /* add a count for permanent */
3006     if (comp->Attributes & msidbComponentAttributesPermanent)
3007         count ++;
3008
3009     comp->RefCount = count;
3010
3011     if (write)
3012         ACTION_WriteSharedDLLsCount( comp->FullKeypath, comp->RefCount );
3013 }
3014
3015 static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
3016 {
3017     WCHAR squished_pc[GUID_SIZE];
3018     WCHAR squished_cc[GUID_SIZE];
3019     UINT rc;
3020     MSICOMPONENT *comp;
3021     HKEY hkey;
3022
3023     TRACE("\n");
3024
3025     squash_guid(package->ProductCode,squished_pc);
3026     ui_progress(package,1,COMPONENT_PROGRESS_VALUE,1,0);
3027
3028     msi_set_sourcedir_props(package, FALSE);
3029
3030     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
3031     {
3032         MSIRECORD * uirow;
3033
3034         ui_progress(package,2,0,0,0);
3035         if (!comp->ComponentId)
3036             continue;
3037
3038         squash_guid(comp->ComponentId,squished_cc);
3039
3040         msi_free(comp->FullKeypath);
3041         comp->FullKeypath = resolve_keypath( package, comp );
3042
3043         ACTION_RefCountComponent( package, comp );
3044
3045         TRACE("Component %s (%s), Keypath=%s, RefCount=%i Request=%u\n",
3046                             debugstr_w(comp->Component),
3047                             debugstr_w(squished_cc),
3048                             debugstr_w(comp->FullKeypath),
3049                             comp->RefCount,
3050                             comp->ActionRequest);
3051
3052         if (comp->ActionRequest == INSTALLSTATE_LOCAL ||
3053             comp->ActionRequest == INSTALLSTATE_SOURCE)
3054         {
3055             if (!comp->FullKeypath)
3056                 continue;
3057
3058             if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3059                 rc = MSIREG_OpenUserDataComponentKey(comp->ComponentId, szLocalSid,
3060                                                      &hkey, TRUE);
3061             else
3062                 rc = MSIREG_OpenUserDataComponentKey(comp->ComponentId, NULL,
3063                                                      &hkey, TRUE);
3064
3065             if (rc != ERROR_SUCCESS)
3066                 continue;
3067
3068             if (comp->Attributes & msidbComponentAttributesPermanent)
3069             {
3070                 static const WCHAR szPermKey[] =
3071                     { '0','0','0','0','0','0','0','0','0','0','0','0',
3072                       '0','0','0','0','0','0','0','0','0','0','0','0',
3073                       '0','0','0','0','0','0','0','0',0 };
3074
3075                 msi_reg_set_val_str(hkey, szPermKey, comp->FullKeypath);
3076             }
3077
3078             if (comp->ActionRequest == INSTALLSTATE_LOCAL)
3079                 msi_reg_set_val_str(hkey, squished_pc, comp->FullKeypath);
3080             else
3081             {
3082                 MSIFILE *file;
3083                 MSIRECORD *row;
3084                 LPWSTR ptr, ptr2;
3085                 WCHAR source[MAX_PATH];
3086                 WCHAR base[MAX_PATH];
3087                 LPWSTR sourcepath;
3088
3089                 static const WCHAR fmt[] = {'%','0','2','d','\\',0};
3090                 static const WCHAR query[] = {
3091                     'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
3092                     '`','M','e','d','i','a','`',' ','W','H','E','R','E',' ',
3093                     '`','L','a','s','t','S','e','q','u','e','n','c','e','`',' ',
3094                     '>','=',' ','%','i',' ','O','R','D','E','R',' ','B','Y',' ',
3095                     '`','D','i','s','k','I','d','`',0};
3096
3097                 file = get_loaded_file(package, comp->KeyPath);
3098                 if (!file)
3099                     continue;
3100
3101                 row = MSI_QueryGetRecord(package->db, query, file->Sequence);
3102                 sprintfW(source, fmt, MSI_RecordGetInteger(row, 1));
3103                 ptr2 = strrchrW(source, '\\') + 1;
3104                 msiobj_release(&row->hdr);
3105
3106                 lstrcpyW(base, package->PackagePath);
3107                 ptr = strrchrW(base, '\\');
3108                 *(ptr + 1) = '\0';
3109
3110                 sourcepath = resolve_file_source(package, file);
3111                 ptr = sourcepath + lstrlenW(base);
3112                 lstrcpyW(ptr2, ptr);
3113                 msi_free(sourcepath);
3114
3115                 msi_reg_set_val_str(hkey, squished_pc, source);
3116             }
3117             RegCloseKey(hkey);
3118         }
3119         else if (comp->ActionRequest == INSTALLSTATE_ABSENT)
3120         {
3121             if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3122                 MSIREG_DeleteUserDataComponentKey(comp->ComponentId, szLocalSid);
3123             else
3124                 MSIREG_DeleteUserDataComponentKey(comp->ComponentId, NULL);
3125         }
3126         comp->Action = comp->ActionRequest;
3127
3128         /* UI stuff */
3129         uirow = MSI_CreateRecord(3);
3130         MSI_RecordSetStringW(uirow,1,package->ProductCode);
3131         MSI_RecordSetStringW(uirow,2,comp->ComponentId);
3132         MSI_RecordSetStringW(uirow,3,comp->FullKeypath);
3133         ui_actiondata(package,szProcessComponents,uirow);
3134         msiobj_release( &uirow->hdr );
3135     }
3136
3137     return ERROR_SUCCESS;
3138 }
3139
3140 typedef struct {
3141     CLSID       clsid;
3142     LPWSTR      source;
3143
3144     LPWSTR      path;
3145     ITypeLib    *ptLib;
3146 } typelib_struct;
3147
3148 static BOOL CALLBACK Typelib_EnumResNameProc( HMODULE hModule, LPCWSTR lpszType,
3149                                        LPWSTR lpszName, LONG_PTR lParam)
3150 {
3151     TLIBATTR *attr;
3152     typelib_struct *tl_struct = (typelib_struct*) lParam;
3153     static const WCHAR fmt[] = {'%','s','\\','%','i',0};
3154     int sz;
3155     HRESULT res;
3156
3157     if (!IS_INTRESOURCE(lpszName))
3158     {
3159         ERR("Not Int Resource Name %s\n",debugstr_w(lpszName));
3160         return TRUE;
3161     }
3162
3163     sz = strlenW(tl_struct->source)+4;
3164     sz *= sizeof(WCHAR);
3165
3166     if ((INT_PTR)lpszName == 1)
3167         tl_struct->path = strdupW(tl_struct->source);
3168     else
3169     {
3170         tl_struct->path = msi_alloc(sz);
3171         sprintfW(tl_struct->path,fmt,tl_struct->source, lpszName);
3172     }
3173
3174     TRACE("trying %s\n", debugstr_w(tl_struct->path));
3175     res = LoadTypeLib(tl_struct->path,&tl_struct->ptLib);
3176     if (FAILED(res))
3177     {
3178         msi_free(tl_struct->path);
3179         tl_struct->path = NULL;
3180
3181         return TRUE;
3182     }
3183
3184     ITypeLib_GetLibAttr(tl_struct->ptLib, &attr);
3185     if (IsEqualGUID(&(tl_struct->clsid),&(attr->guid)))
3186     {
3187         ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
3188         return FALSE;
3189     }
3190
3191     msi_free(tl_struct->path);
3192     tl_struct->path = NULL;
3193
3194     ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
3195     ITypeLib_Release(tl_struct->ptLib);
3196
3197     return TRUE;
3198 }
3199
3200 static UINT ITERATE_RegisterTypeLibraries(MSIRECORD *row, LPVOID param)
3201 {
3202     MSIPACKAGE* package = param;
3203     LPCWSTR component;
3204     MSICOMPONENT *comp;
3205     MSIFILE *file;
3206     typelib_struct tl_struct;
3207     ITypeLib *tlib;
3208     HMODULE module;
3209     HRESULT hr;
3210
3211     component = MSI_RecordGetString(row,3);
3212     comp = get_loaded_component(package,component);
3213     if (!comp)
3214         return ERROR_SUCCESS;
3215
3216     if (!comp->Enabled)
3217     {
3218         TRACE("component is disabled\n");
3219         return ERROR_SUCCESS;
3220     }
3221
3222     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
3223     {
3224         TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
3225         comp->Action = comp->Installed;
3226         return ERROR_SUCCESS;
3227     }
3228     comp->Action = INSTALLSTATE_LOCAL;
3229
3230     file = get_loaded_file( package, comp->KeyPath );
3231     if (!file)
3232         return ERROR_SUCCESS;
3233
3234     ui_actiondata( package, szRegisterTypeLibraries, row );
3235
3236     module = LoadLibraryExW( file->TargetPath, NULL, LOAD_LIBRARY_AS_DATAFILE );
3237     if (module)
3238     {
3239         LPCWSTR guid;
3240         guid = MSI_RecordGetString(row,1);
3241         CLSIDFromString((LPCWSTR)guid, &tl_struct.clsid);
3242         tl_struct.source = strdupW( file->TargetPath );
3243         tl_struct.path = NULL;
3244
3245         EnumResourceNamesW(module, szTYPELIB, Typelib_EnumResNameProc,
3246                         (LONG_PTR)&tl_struct);
3247
3248         if (tl_struct.path)
3249         {
3250             LPWSTR help = NULL;
3251             LPCWSTR helpid;
3252             HRESULT res;
3253
3254             helpid = MSI_RecordGetString(row,6);
3255
3256             if (helpid)
3257                 help = resolve_folder(package,helpid,FALSE,FALSE,TRUE,NULL);
3258             res = RegisterTypeLib(tl_struct.ptLib,tl_struct.path,help);
3259             msi_free(help);
3260
3261             if (FAILED(res))
3262                 ERR("Failed to register type library %s\n",
3263                         debugstr_w(tl_struct.path));
3264             else
3265                 TRACE("Registered %s\n", debugstr_w(tl_struct.path));
3266
3267             ITypeLib_Release(tl_struct.ptLib);
3268             msi_free(tl_struct.path);
3269         }
3270         else
3271             ERR("Failed to load type library %s\n",
3272                     debugstr_w(tl_struct.source));
3273
3274         FreeLibrary(module);
3275         msi_free(tl_struct.source);
3276     }
3277     else
3278     {
3279         hr = LoadTypeLibEx(file->TargetPath, REGKIND_REGISTER, &tlib);
3280         if (FAILED(hr))
3281         {
3282             ERR("Failed to load type library: %08x\n", hr);
3283             return ERROR_INSTALL_FAILURE;
3284         }
3285
3286         ITypeLib_Release(tlib);
3287     }
3288
3289     return ERROR_SUCCESS;
3290 }
3291
3292 static UINT ACTION_RegisterTypeLibraries(MSIPACKAGE *package)
3293 {
3294     /*
3295      * OK this is a bit confusing.. I am given a _Component key and I believe
3296      * that the file that is being registered as a type library is the "key file
3297      * of that component" which I interpret to mean "The file in the KeyPath of
3298      * that component".
3299      */
3300     UINT rc;
3301     MSIQUERY * view;
3302     static const WCHAR Query[] =
3303         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3304          '`','T','y','p','e','L','i','b','`',0};
3305
3306     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3307     if (rc != ERROR_SUCCESS)
3308         return ERROR_SUCCESS;
3309
3310     rc = MSI_IterateRecords(view, NULL, ITERATE_RegisterTypeLibraries, package);
3311     msiobj_release(&view->hdr);
3312     return rc;
3313 }
3314
3315 static UINT ITERATE_UnregisterTypeLibraries( MSIRECORD *row, LPVOID param )
3316 {
3317     MSIPACKAGE *package = param;
3318     LPCWSTR component, guid;
3319     MSICOMPONENT *comp;
3320     GUID libid;
3321     UINT version;
3322     LCID language;
3323     SYSKIND syskind;
3324     HRESULT hr;
3325
3326     component = MSI_RecordGetString( row, 3 );
3327     comp = get_loaded_component( package, component );
3328     if (!comp)
3329         return ERROR_SUCCESS;
3330
3331     if (!comp->Enabled)
3332     {
3333         TRACE("component is disabled\n");
3334         return ERROR_SUCCESS;
3335     }
3336
3337     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
3338     {
3339         TRACE("Component not scheduled for removal %s\n", debugstr_w(component));
3340         comp->Action = comp->Installed;
3341         return ERROR_SUCCESS;
3342     }
3343     comp->Action = INSTALLSTATE_ABSENT;
3344
3345     ui_actiondata( package, szUnregisterTypeLibraries, row );
3346
3347     guid = MSI_RecordGetString( row, 1 );
3348     CLSIDFromString( (LPCWSTR)guid, &libid );
3349     version = MSI_RecordGetInteger( row, 4 );
3350     language = MSI_RecordGetInteger( row, 2 );
3351
3352 #ifdef _WIN64
3353     syskind = SYS_WIN64;
3354 #else
3355     syskind = SYS_WIN32;
3356 #endif
3357
3358     hr = UnRegisterTypeLib( &libid, (version >> 8) & 0xffff, version & 0xff, language, syskind );
3359     if (FAILED(hr))
3360     {
3361         WARN("Failed to unregister typelib: %08x\n", hr);
3362     }
3363
3364     return ERROR_SUCCESS;
3365 }
3366
3367 static UINT ACTION_UnregisterTypeLibraries( MSIPACKAGE *package )
3368 {
3369     UINT rc;
3370     MSIQUERY *view;
3371     static const WCHAR query[] =
3372         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3373          '`','T','y','p','e','L','i','b','`',0};
3374
3375     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
3376     if (rc != ERROR_SUCCESS)
3377         return ERROR_SUCCESS;
3378
3379     rc = MSI_IterateRecords( view, NULL, ITERATE_UnregisterTypeLibraries, package );
3380     msiobj_release( &view->hdr );
3381     return rc;
3382 }
3383
3384 static WCHAR *get_link_file( MSIPACKAGE *package, MSIRECORD *row )
3385 {
3386     static const WCHAR szlnk[] = {'.','l','n','k',0};
3387     LPCWSTR directory, extension;
3388     LPWSTR link_folder, link_file, filename;
3389
3390     directory = MSI_RecordGetString( row, 2 );
3391     link_folder = resolve_folder( package, directory, FALSE, FALSE, TRUE, NULL );
3392
3393     /* may be needed because of a bug somewhere else */
3394     create_full_pathW( link_folder );
3395
3396     filename = msi_dup_record_field( row, 3 );
3397     reduce_to_longfilename( filename );
3398
3399     extension = strchrW( filename, '.' );
3400     if (!extension || strcmpiW( extension, szlnk ))
3401     {
3402         int len = strlenW( filename );
3403         filename = msi_realloc( filename, len * sizeof(WCHAR) + sizeof(szlnk) );
3404         memcpy( filename + len, szlnk, sizeof(szlnk) );
3405     }
3406     link_file = build_directory_name( 2, link_folder, filename );
3407     msi_free( link_folder );
3408     msi_free( filename );
3409
3410     return link_file;
3411 }
3412
3413 static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
3414 {
3415     MSIPACKAGE *package = param;
3416     LPWSTR link_file, deformated, path;
3417     LPCWSTR component, target;
3418     MSICOMPONENT *comp;
3419     IShellLinkW *sl = NULL;
3420     IPersistFile *pf = NULL;
3421     HRESULT res;
3422
3423     component = MSI_RecordGetString(row, 4);
3424     comp = get_loaded_component(package, component);
3425     if (!comp)
3426         return ERROR_SUCCESS;
3427
3428     if (!comp->Enabled)
3429     {
3430         TRACE("component is disabled\n");
3431         return ERROR_SUCCESS;
3432     }
3433
3434     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
3435     {
3436         TRACE("Component not scheduled for installation %s\n", debugstr_w(component));
3437         comp->Action = comp->Installed;
3438         return ERROR_SUCCESS;
3439     }
3440     comp->Action = INSTALLSTATE_LOCAL;
3441
3442     ui_actiondata(package,szCreateShortcuts,row);
3443
3444     res = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
3445                     &IID_IShellLinkW, (LPVOID *) &sl );
3446
3447     if (FAILED( res ))
3448     {
3449         ERR("CLSID_ShellLink not available\n");
3450         goto err;
3451     }
3452
3453     res = IShellLinkW_QueryInterface( sl, &IID_IPersistFile,(LPVOID*) &pf );
3454     if (FAILED( res ))
3455     {
3456         ERR("QueryInterface(IID_IPersistFile) failed\n");
3457         goto err;
3458     }
3459
3460     target = MSI_RecordGetString(row, 5);
3461     if (strchrW(target, '['))
3462     {
3463         deformat_string(package, target, &deformated);
3464         IShellLinkW_SetPath(sl,deformated);
3465         msi_free(deformated);
3466     }
3467     else
3468     {
3469         FIXME("poorly handled shortcut format, advertised shortcut\n");
3470         IShellLinkW_SetPath(sl,comp->FullKeypath);
3471     }
3472
3473     if (!MSI_RecordIsNull(row,6))
3474     {
3475         LPCWSTR arguments = MSI_RecordGetString(row, 6);
3476         deformat_string(package, arguments, &deformated);
3477         IShellLinkW_SetArguments(sl,deformated);
3478         msi_free(deformated);
3479     }
3480
3481     if (!MSI_RecordIsNull(row,7))
3482     {
3483         LPCWSTR description = MSI_RecordGetString(row, 7);
3484         IShellLinkW_SetDescription(sl, description);
3485     }
3486
3487     if (!MSI_RecordIsNull(row,8))
3488         IShellLinkW_SetHotkey(sl,MSI_RecordGetInteger(row,8));
3489
3490     if (!MSI_RecordIsNull(row,9))
3491     {
3492         INT index;
3493         LPCWSTR icon = MSI_RecordGetString(row, 9);
3494
3495         path = build_icon_path(package, icon);
3496         index = MSI_RecordGetInteger(row,10);
3497
3498         /* no value means 0 */
3499         if (index == MSI_NULL_INTEGER)
3500             index = 0;
3501
3502         IShellLinkW_SetIconLocation(sl, path, index);
3503         msi_free(path);
3504     }
3505
3506     if (!MSI_RecordIsNull(row,11))
3507         IShellLinkW_SetShowCmd(sl,MSI_RecordGetInteger(row,11));
3508
3509     if (!MSI_RecordIsNull(row,12))
3510     {
3511         LPCWSTR wkdir = MSI_RecordGetString(row, 12);
3512         path = resolve_folder(package, wkdir, FALSE, FALSE, TRUE, NULL);
3513         if (path)
3514             IShellLinkW_SetWorkingDirectory(sl, path);
3515         msi_free(path);
3516     }
3517
3518     link_file = get_link_file(package, row);
3519
3520     TRACE("Writing shortcut to %s\n", debugstr_w(link_file));
3521     IPersistFile_Save(pf, link_file, FALSE);
3522
3523     msi_free(link_file);
3524
3525 err:
3526     if (pf)
3527         IPersistFile_Release( pf );
3528     if (sl)
3529         IShellLinkW_Release( sl );
3530
3531     return ERROR_SUCCESS;
3532 }
3533
3534 static UINT ACTION_CreateShortcuts(MSIPACKAGE *package)
3535 {
3536     UINT rc;
3537     HRESULT res;
3538     MSIQUERY * view;
3539     static const WCHAR Query[] =
3540         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3541          '`','S','h','o','r','t','c','u','t','`',0};
3542
3543     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3544     if (rc != ERROR_SUCCESS)
3545         return ERROR_SUCCESS;
3546
3547     res = CoInitialize( NULL );
3548
3549     rc = MSI_IterateRecords(view, NULL, ITERATE_CreateShortcuts, package);
3550     msiobj_release(&view->hdr);
3551
3552     if (SUCCEEDED(res))
3553         CoUninitialize();
3554
3555     return rc;
3556 }
3557
3558 static UINT ITERATE_RemoveShortcuts( MSIRECORD *row, LPVOID param )
3559 {
3560     MSIPACKAGE *package = param;
3561     LPWSTR link_file;
3562     LPCWSTR component;
3563     MSICOMPONENT *comp;
3564
3565     component = MSI_RecordGetString( row, 4 );
3566     comp = get_loaded_component( package, component );
3567     if (!comp)
3568         return ERROR_SUCCESS;
3569
3570     if (!comp->Enabled)
3571     {
3572         TRACE("component is disabled\n");
3573         return ERROR_SUCCESS;
3574     }
3575
3576     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
3577     {
3578         TRACE("Component not scheduled for removal %s\n", debugstr_w(component));
3579         comp->Action = comp->Installed;
3580         return ERROR_SUCCESS;
3581     }
3582     comp->Action = INSTALLSTATE_ABSENT;
3583
3584     ui_actiondata( package, szRemoveShortcuts, row );
3585
3586     link_file = get_link_file( package, row );
3587
3588     TRACE("Removing shortcut file %s\n", debugstr_w( link_file ));
3589     if (!DeleteFileW( link_file ))
3590     {
3591         WARN("Failed to remove shortcut file %u\n", GetLastError());
3592     }
3593     msi_free( link_file );
3594
3595     return ERROR_SUCCESS;
3596 }
3597
3598 static UINT ACTION_RemoveShortcuts( MSIPACKAGE *package )
3599 {
3600     UINT rc;
3601     MSIQUERY *view;
3602     static const WCHAR query[] =
3603         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3604          '`','S','h','o','r','t','c','u','t','`',0};
3605
3606     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
3607     if (rc != ERROR_SUCCESS)
3608         return ERROR_SUCCESS;
3609
3610     rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveShortcuts, package );
3611     msiobj_release( &view->hdr );
3612
3613     return rc;
3614 }
3615
3616 static UINT ITERATE_PublishIcon(MSIRECORD *row, LPVOID param)
3617 {
3618     MSIPACKAGE* package = param;
3619     HANDLE the_file;
3620     LPWSTR FilePath;
3621     LPCWSTR FileName;
3622     CHAR buffer[1024];
3623     DWORD sz;
3624     UINT rc;
3625
3626     FileName = MSI_RecordGetString(row,1);
3627     if (!FileName)
3628     {
3629         ERR("Unable to get FileName\n");
3630         return ERROR_SUCCESS;
3631     }
3632
3633     FilePath = build_icon_path(package,FileName);
3634
3635     TRACE("Creating icon file at %s\n",debugstr_w(FilePath));
3636
3637     the_file = CreateFileW(FilePath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
3638                         FILE_ATTRIBUTE_NORMAL, NULL);
3639
3640     if (the_file == INVALID_HANDLE_VALUE)
3641     {
3642         ERR("Unable to create file %s\n",debugstr_w(FilePath));
3643         msi_free(FilePath);
3644         return ERROR_SUCCESS;
3645     }
3646
3647     do
3648     {
3649         DWORD write;
3650         sz = 1024;
3651         rc = MSI_RecordReadStream(row,2,buffer,&sz);
3652         if (rc != ERROR_SUCCESS)
3653         {
3654             ERR("Failed to get stream\n");
3655             CloseHandle(the_file);
3656             DeleteFileW(FilePath);
3657             break;
3658         }
3659         WriteFile(the_file,buffer,sz,&write,NULL);
3660     } while (sz == 1024);
3661
3662     msi_free(FilePath);
3663     CloseHandle(the_file);
3664
3665     return ERROR_SUCCESS;
3666 }
3667
3668 static UINT msi_publish_icons(MSIPACKAGE *package)
3669 {
3670     UINT r;
3671     MSIQUERY *view;
3672
3673     static const WCHAR query[]= {
3674         'S','E','L','E','C','T',' ','*',' ',
3675         'F','R','O','M',' ','`','I','c','o','n','`',0};
3676
3677     r = MSI_DatabaseOpenViewW(package->db, query, &view);
3678     if (r == ERROR_SUCCESS)
3679     {
3680         MSI_IterateRecords(view, NULL, ITERATE_PublishIcon, package);
3681         msiobj_release(&view->hdr);
3682     }
3683
3684     return ERROR_SUCCESS;
3685 }
3686
3687 static UINT msi_publish_sourcelist(MSIPACKAGE *package, HKEY hkey)
3688 {
3689     UINT r;
3690     HKEY source;
3691     LPWSTR buffer;
3692     MSIMEDIADISK *disk;
3693     MSISOURCELISTINFO *info;
3694
3695     r = RegCreateKeyW(hkey, szSourceList, &source);
3696     if (r != ERROR_SUCCESS)
3697         return r;
3698
3699     RegCloseKey(source);
3700
3701     buffer = strrchrW(package->PackagePath, '\\') + 1;
3702     r = MsiSourceListSetInfoW(package->ProductCode, NULL,
3703                               package->Context, MSICODE_PRODUCT,
3704                               INSTALLPROPERTY_PACKAGENAMEW, buffer);
3705     if (r != ERROR_SUCCESS)
3706         return r;
3707
3708     r = MsiSourceListSetInfoW(package->ProductCode, NULL,
3709                               package->Context, MSICODE_PRODUCT,
3710                               INSTALLPROPERTY_MEDIAPACKAGEPATHW, szEmpty);
3711     if (r != ERROR_SUCCESS)
3712         return r;
3713
3714     r = MsiSourceListSetInfoW(package->ProductCode, NULL,
3715                               package->Context, MSICODE_PRODUCT,
3716                               INSTALLPROPERTY_DISKPROMPTW, szEmpty);
3717     if (r != ERROR_SUCCESS)
3718         return r;
3719
3720     LIST_FOR_EACH_ENTRY(info, &package->sourcelist_info, MSISOURCELISTINFO, entry)
3721     {
3722         if (!lstrcmpW(info->property, INSTALLPROPERTY_LASTUSEDSOURCEW))
3723             msi_set_last_used_source(package->ProductCode, NULL, info->context,
3724                                      info->options, info->value);
3725         else
3726             MsiSourceListSetInfoW(package->ProductCode, NULL,
3727                                   info->context, info->options,
3728                                   info->property, info->value);
3729     }
3730
3731     LIST_FOR_EACH_ENTRY(disk, &package->sourcelist_media, MSIMEDIADISK, entry)
3732     {
3733         MsiSourceListAddMediaDiskW(package->ProductCode, NULL,
3734                                    disk->context, disk->options,
3735                                    disk->disk_id, disk->volume_label, disk->disk_prompt);
3736     }
3737
3738     return ERROR_SUCCESS;
3739 }
3740
3741 static UINT msi_publish_product_properties(MSIPACKAGE *package, HKEY hkey)
3742 {
3743     MSIHANDLE hdb, suminfo;
3744     WCHAR guids[MAX_PATH];
3745     WCHAR packcode[SQUISH_GUID_SIZE];
3746     LPWSTR buffer;
3747     LPWSTR ptr;
3748     DWORD langid;
3749     DWORD size;
3750     UINT r;
3751
3752     static const WCHAR szProductLanguage[] =
3753         {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
3754     static const WCHAR szARPProductIcon[] =
3755         {'A','R','P','P','R','O','D','U','C','T','I','C','O','N',0};
3756     static const WCHAR szProductVersion[] =
3757         {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
3758     static const WCHAR szAssignment[] =
3759         {'A','s','s','i','g','n','m','e','n','t',0};
3760     static const WCHAR szAdvertiseFlags[] =
3761         {'A','d','v','e','r','t','i','s','e','F','l','a','g','s',0};
3762     static const WCHAR szClients[] =
3763         {'C','l','i','e','n','t','s',0};
3764     static const WCHAR szColon[] = {':',0};
3765
3766     buffer = msi_dup_property(package->db, INSTALLPROPERTY_PRODUCTNAMEW);
3767     msi_reg_set_val_str(hkey, INSTALLPROPERTY_PRODUCTNAMEW, buffer);
3768     msi_free(buffer);
3769
3770     langid = msi_get_property_int(package->db, szProductLanguage, 0);
3771     msi_reg_set_val_dword(hkey, INSTALLPROPERTY_LANGUAGEW, langid);
3772
3773     /* FIXME */
3774     msi_reg_set_val_dword(hkey, INSTALLPROPERTY_AUTHORIZED_LUA_APPW, 0);
3775
3776     buffer = msi_dup_property(package->db, szARPProductIcon);
3777     if (buffer)
3778     {
3779         LPWSTR path = build_icon_path(package,buffer);
3780         msi_reg_set_val_str(hkey, INSTALLPROPERTY_PRODUCTICONW, path);
3781         msi_free(path);
3782         msi_free(buffer);
3783     }
3784
3785     buffer = msi_dup_property(package->db, szProductVersion);
3786     if (buffer)
3787     {
3788         DWORD verdword = msi_version_str_to_dword(buffer);
3789         msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONW, verdword);
3790         msi_free(buffer);
3791     }
3792
3793     msi_reg_set_val_dword(hkey, szAssignment, 0);
3794     msi_reg_set_val_dword(hkey, szAdvertiseFlags, 0x184);
3795     msi_reg_set_val_dword(hkey, INSTALLPROPERTY_INSTANCETYPEW, 0);
3796     msi_reg_set_val_str(hkey, szClients, szColon);
3797
3798     hdb = alloc_msihandle(&package->db->hdr);
3799     if (!hdb)
3800         return ERROR_NOT_ENOUGH_MEMORY;
3801
3802     r = MsiGetSummaryInformationW(hdb, NULL, 0, &suminfo);
3803     MsiCloseHandle(hdb);
3804     if (r != ERROR_SUCCESS)
3805         goto done;
3806
3807     size = MAX_PATH;
3808     r = MsiSummaryInfoGetPropertyW(suminfo, PID_REVNUMBER, NULL, NULL,
3809                                    NULL, guids, &size);
3810     if (r != ERROR_SUCCESS)
3811         goto done;
3812
3813     ptr = strchrW(guids, ';');
3814     if (ptr) *ptr = 0;
3815     squash_guid(guids, packcode);
3816     msi_reg_set_val_str(hkey, INSTALLPROPERTY_PACKAGECODEW, packcode);
3817
3818 done:
3819     MsiCloseHandle(suminfo);
3820     return ERROR_SUCCESS;
3821 }
3822
3823 static UINT msi_publish_upgrade_code(MSIPACKAGE *package)
3824 {
3825     UINT r;
3826     HKEY hkey;
3827     LPWSTR upgrade;
3828     WCHAR squashed_pc[SQUISH_GUID_SIZE];
3829
3830     upgrade = msi_dup_property(package->db, szUpgradeCode);
3831     if (!upgrade)
3832         return ERROR_SUCCESS;
3833
3834     if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3835     {
3836         r = MSIREG_OpenClassesUpgradeCodesKey(upgrade, &hkey, TRUE);
3837         if (r != ERROR_SUCCESS)
3838             goto done;
3839     }
3840     else
3841     {
3842         r = MSIREG_OpenUserUpgradeCodesKey(upgrade, &hkey, TRUE);
3843         if (r != ERROR_SUCCESS)
3844             goto done;
3845     }
3846
3847     squash_guid(package->ProductCode, squashed_pc);
3848     msi_reg_set_val_str(hkey, squashed_pc, NULL);
3849
3850     RegCloseKey(hkey);
3851
3852 done:
3853     msi_free(upgrade);
3854     return r;
3855 }
3856
3857 static BOOL msi_check_publish(MSIPACKAGE *package)
3858 {
3859     MSIFEATURE *feature;
3860
3861     LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
3862     {
3863         if (feature->ActionRequest == INSTALLSTATE_LOCAL)
3864             return TRUE;
3865     }
3866
3867     return FALSE;
3868 }
3869
3870 static BOOL msi_check_unpublish(MSIPACKAGE *package)
3871 {
3872     MSIFEATURE *feature;
3873
3874     LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
3875     {
3876         if (feature->ActionRequest != INSTALLSTATE_ABSENT)
3877             return FALSE;
3878     }
3879
3880     return TRUE;
3881 }
3882
3883 static UINT msi_publish_patches( MSIPACKAGE *package )
3884 {
3885     static const WCHAR szAllPatches[] = {'A','l','l','P','a','t','c','h','e','s',0};
3886     WCHAR patch_squashed[GUID_SIZE];
3887     HKEY patches_key = NULL, product_patches_key = NULL, product_key;
3888     LONG res;
3889     MSIPATCHINFO *patch;
3890     UINT r;
3891     WCHAR *p, *all_patches = NULL;
3892     DWORD len = 0;
3893
3894     r = MSIREG_OpenProductKey( package->ProductCode, NULL, package->Context, &product_key, TRUE );
3895     if (r != ERROR_SUCCESS)
3896         return ERROR_FUNCTION_FAILED;
3897
3898     res = RegCreateKeyExW( product_key, szPatches, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &patches_key, NULL );
3899     if (res != ERROR_SUCCESS)
3900     {
3901         r = ERROR_FUNCTION_FAILED;
3902         goto done;
3903     }
3904
3905     r = MSIREG_OpenUserDataProductPatchesKey( package->ProductCode, package->Context, &product_patches_key, TRUE );
3906     if (r != ERROR_SUCCESS)
3907         goto done;
3908
3909     LIST_FOR_EACH_ENTRY( patch, &package->patches, MSIPATCHINFO, entry )
3910     {
3911         squash_guid( patch->patchcode, patch_squashed );
3912         len += strlenW( patch_squashed ) + 1;
3913     }
3914
3915     p = all_patches = msi_alloc( (len + 1) * sizeof(WCHAR) );
3916     if (!all_patches)
3917         goto done;
3918
3919     LIST_FOR_EACH_ENTRY( patch, &package->patches, MSIPATCHINFO, entry )
3920     {
3921         HKEY patch_key;
3922
3923         squash_guid( patch->patchcode, p );
3924         p += strlenW( p ) + 1;
3925
3926         res = RegSetValueExW( patches_key, patch_squashed, 0, REG_SZ,
3927                               (const BYTE *)patch->transforms,
3928                               (strlenW(patch->transforms) + 1) * sizeof(WCHAR) );
3929         if (res != ERROR_SUCCESS)
3930             goto done;
3931
3932         r = MSIREG_OpenUserDataPatchKey( patch->patchcode, package->Context, &patch_key, TRUE );
3933         if (r != ERROR_SUCCESS)
3934             goto done;
3935
3936         res = RegSetValueExW( patch_key, szLocalPackage, 0, REG_SZ,
3937                               (const BYTE *)patch->localfile,
3938                               (strlenW(patch->localfile) + 1) * sizeof(WCHAR) );
3939         RegCloseKey( patch_key );
3940         if (res != ERROR_SUCCESS)
3941             goto done;
3942
3943         res = RegCreateKeyExW( product_patches_key, patch_squashed, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &patch_key, NULL );
3944         if (res != ERROR_SUCCESS)
3945             goto done;
3946
3947         res = RegSetValueExW( patch_key, szState, 0, REG_DWORD, (const BYTE *)&patch->state, sizeof(patch->state) );
3948         RegCloseKey( patch_key );
3949         if (res != ERROR_SUCCESS)
3950             goto done;
3951     }
3952
3953     all_patches[len] = 0;
3954     res = RegSetValueExW( patches_key, szPatches, 0, REG_MULTI_SZ,
3955                           (const BYTE *)all_patches, (len + 1) * sizeof(WCHAR) );
3956     if (res != ERROR_SUCCESS)
3957         goto done;
3958
3959     res = RegSetValueExW( product_patches_key, szAllPatches, 0, REG_MULTI_SZ,
3960                           (const BYTE *)all_patches, (len + 1) * sizeof(WCHAR) );
3961     if (res != ERROR_SUCCESS)
3962         r = ERROR_FUNCTION_FAILED;
3963
3964 done:
3965     RegCloseKey( product_patches_key );
3966     RegCloseKey( patches_key );
3967     RegCloseKey( product_key );
3968     msi_free( all_patches );
3969     return r;
3970 }
3971
3972 /*
3973  * 99% of the work done here is only done for
3974  * advertised installs. However this is where the
3975  * Icon table is processed and written out
3976  * so that is what I am going to do here.
3977  */
3978 static UINT ACTION_PublishProduct(MSIPACKAGE *package)
3979 {
3980     UINT rc;
3981     HKEY hukey = NULL, hudkey = NULL;
3982     MSIRECORD *uirow;
3983
3984     if (!list_empty(&package->patches))
3985     {
3986         rc = msi_publish_patches(package);
3987         if (rc != ERROR_SUCCESS)
3988             goto end;
3989     }
3990
3991     /* FIXME: also need to publish if the product is in advertise mode */
3992     if (!msi_check_publish(package))
3993         return ERROR_SUCCESS;
3994
3995     rc = MSIREG_OpenProductKey(package->ProductCode, NULL, package->Context,
3996                                &hukey, TRUE);
3997     if (rc != ERROR_SUCCESS)
3998         goto end;
3999
4000     rc = MSIREG_OpenUserDataProductKey(package->ProductCode, package->Context,
4001                                        NULL, &hudkey, TRUE);
4002     if (rc != ERROR_SUCCESS)
4003         goto end;
4004
4005     rc = msi_publish_upgrade_code(package);
4006     if (rc != ERROR_SUCCESS)
4007         goto end;
4008
4009     rc = msi_publish_product_properties(package, hukey);
4010     if (rc != ERROR_SUCCESS)
4011         goto end;
4012
4013     rc = msi_publish_sourcelist(package, hukey);
4014     if (rc != ERROR_SUCCESS)
4015         goto end;
4016
4017     rc = msi_publish_icons(package);
4018
4019 end:
4020     uirow = MSI_CreateRecord( 1 );
4021     MSI_RecordSetStringW( uirow, 1, package->ProductCode );
4022     ui_actiondata( package, szPublishProduct, uirow );
4023     msiobj_release( &uirow->hdr );
4024
4025     RegCloseKey(hukey);
4026     RegCloseKey(hudkey);
4027
4028     return rc;
4029 }
4030
4031 static WCHAR *get_ini_file_name( MSIPACKAGE *package, MSIRECORD *row )
4032 {
4033     WCHAR *filename, *ptr, *folder, *ret;
4034     const WCHAR *dirprop;
4035
4036     filename = msi_dup_record_field( row, 2 );
4037     if (filename && (ptr = strchrW( filename, '|' )))
4038         ptr++;
4039     else
4040         ptr = filename;
4041
4042     dirprop = MSI_RecordGetString( row, 3 );
4043     if (dirprop)
4044     {
4045         folder = resolve_folder( package, dirprop, FALSE, FALSE, TRUE, NULL );
4046         if (!folder)
4047             folder = msi_dup_property( package->db, dirprop );
4048     }
4049     else
4050         folder = msi_dup_property( package->db, szWindowsFolder );
4051
4052     if (!folder)
4053     {
4054         ERR("Unable to resolve folder %s\n", debugstr_w(dirprop));
4055         msi_free( filename );
4056         return NULL;
4057     }
4058
4059     ret = build_directory_name( 2, folder, ptr );
4060
4061     msi_free( filename );
4062     msi_free( folder );
4063     return ret;
4064 }
4065
4066 static UINT ITERATE_WriteIniValues(MSIRECORD *row, LPVOID param)
4067 {
4068     MSIPACKAGE *package = param;
4069     LPCWSTR component, section, key, value, identifier;
4070     LPWSTR deformated_section, deformated_key, deformated_value, fullname;
4071     MSIRECORD * uirow;
4072     INT action;
4073     MSICOMPONENT *comp;
4074
4075     component = MSI_RecordGetString(row, 8);
4076     comp = get_loaded_component(package,component);
4077     if (!comp)
4078         return ERROR_SUCCESS;
4079
4080     if (!comp->Enabled)
4081     {
4082         TRACE("component is disabled\n");
4083         return ERROR_SUCCESS;
4084     }
4085
4086     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
4087     {
4088         TRACE("Component not scheduled for installation %s\n", debugstr_w(component));
4089         comp->Action = comp->Installed;
4090         return ERROR_SUCCESS;
4091     }
4092     comp->Action = INSTALLSTATE_LOCAL;
4093
4094     identifier = MSI_RecordGetString(row,1);
4095     section = MSI_RecordGetString(row,4);
4096     key = MSI_RecordGetString(row,5);
4097     value = MSI_RecordGetString(row,6);
4098     action = MSI_RecordGetInteger(row,7);
4099
4100     deformat_string(package,section,&deformated_section);
4101     deformat_string(package,key,&deformated_key);
4102     deformat_string(package,value,&deformated_value);
4103
4104     fullname = get_ini_file_name(package, row);
4105
4106     if (action == 0)
4107     {
4108         TRACE("Adding value %s to section %s in %s\n",
4109                 debugstr_w(deformated_key), debugstr_w(deformated_section),
4110                 debugstr_w(fullname));
4111         WritePrivateProfileStringW(deformated_section, deformated_key,
4112                                    deformated_value, fullname);
4113     }
4114     else if (action == 1)
4115     {
4116         WCHAR returned[10];
4117         GetPrivateProfileStringW(deformated_section, deformated_key, NULL,
4118                                  returned, 10, fullname);
4119         if (returned[0] == 0)
4120         {
4121             TRACE("Adding value %s to section %s in %s\n",
4122                     debugstr_w(deformated_key), debugstr_w(deformated_section),
4123                     debugstr_w(fullname));
4124
4125             WritePrivateProfileStringW(deformated_section, deformated_key,
4126                                        deformated_value, fullname);
4127         }
4128     }
4129     else if (action == 3)
4130         FIXME("Append to existing section not yet implemented\n");
4131
4132     uirow = MSI_CreateRecord(4);
4133     MSI_RecordSetStringW(uirow,1,identifier);
4134     MSI_RecordSetStringW(uirow,2,deformated_section);
4135     MSI_RecordSetStringW(uirow,3,deformated_key);
4136     MSI_RecordSetStringW(uirow,4,deformated_value);
4137     ui_actiondata(package,szWriteIniValues,uirow);
4138     msiobj_release( &uirow->hdr );
4139
4140     msi_free(fullname);
4141     msi_free(deformated_key);
4142     msi_free(deformated_value);
4143     msi_free(deformated_section);
4144     return ERROR_SUCCESS;
4145 }
4146
4147 static UINT ACTION_WriteIniValues(MSIPACKAGE *package)
4148 {
4149     UINT rc;
4150     MSIQUERY * view;
4151     static const WCHAR ExecSeqQuery[] =
4152         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4153          '`','I','n','i','F','i','l','e','`',0};
4154
4155     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4156     if (rc != ERROR_SUCCESS)
4157     {
4158         TRACE("no IniFile table\n");
4159         return ERROR_SUCCESS;
4160     }
4161
4162     rc = MSI_IterateRecords(view, NULL, ITERATE_WriteIniValues, package);
4163     msiobj_release(&view->hdr);
4164     return rc;
4165 }
4166
4167 static UINT ITERATE_RemoveIniValuesOnUninstall( MSIRECORD *row, LPVOID param )
4168 {
4169     MSIPACKAGE *package = param;
4170     LPCWSTR component, section, key, value, identifier;
4171     LPWSTR deformated_section, deformated_key, deformated_value, filename;
4172     MSICOMPONENT *comp;
4173     MSIRECORD *uirow;
4174     INT action;
4175
4176     component = MSI_RecordGetString( row, 8 );
4177     comp = get_loaded_component( package, component );
4178     if (!comp)
4179         return ERROR_SUCCESS;
4180
4181     if (!comp->Enabled)
4182     {
4183         TRACE("component is disabled\n");
4184         return ERROR_SUCCESS;
4185     }
4186
4187     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
4188     {
4189         TRACE("Component not scheduled for removal %s\n", debugstr_w(component));
4190         comp->Action = comp->Installed;
4191         return ERROR_SUCCESS;
4192     }
4193     comp->Action = INSTALLSTATE_ABSENT;
4194
4195     identifier = MSI_RecordGetString( row, 1 );
4196     section = MSI_RecordGetString( row, 4 );
4197     key = MSI_RecordGetString( row, 5 );
4198     value = MSI_RecordGetString( row, 6 );
4199     action = MSI_RecordGetInteger( row, 7 );
4200
4201     deformat_string( package, section, &deformated_section );
4202     deformat_string( package, key, &deformated_key );
4203     deformat_string( package, value, &deformated_value );
4204
4205     if (action == msidbIniFileActionAddLine || action == msidbIniFileActionCreateLine)
4206     {
4207         filename = get_ini_file_name( package, row );
4208
4209         TRACE("Removing key %s from section %s in %s\n",
4210                debugstr_w(deformated_key), debugstr_w(deformated_section), debugstr_w(filename));
4211
4212         if (!WritePrivateProfileStringW( deformated_section, deformated_key, NULL, filename ))
4213         {
4214             WARN("Unable to remove key %u\n", GetLastError());
4215         }
4216         msi_free( filename );
4217     }
4218     else
4219         FIXME("Unsupported action %d\n", action);
4220
4221
4222     uirow = MSI_CreateRecord( 4 );
4223     MSI_RecordSetStringW( uirow, 1, identifier );
4224     MSI_RecordSetStringW( uirow, 2, deformated_section );
4225     MSI_RecordSetStringW( uirow, 3, deformated_key );
4226     MSI_RecordSetStringW( uirow, 4, deformated_value );
4227     ui_actiondata( package, szRemoveIniValues, uirow );
4228     msiobj_release( &uirow->hdr );
4229
4230     msi_free( deformated_key );
4231     msi_free( deformated_value );
4232     msi_free( deformated_section );
4233     return ERROR_SUCCESS;
4234 }
4235
4236 static UINT ITERATE_RemoveIniValuesOnInstall( MSIRECORD *row, LPVOID param )
4237 {
4238     MSIPACKAGE *package = param;
4239     LPCWSTR component, section, key, value, identifier;
4240     LPWSTR deformated_section, deformated_key, deformated_value, filename;
4241     MSICOMPONENT *comp;
4242     MSIRECORD *uirow;
4243     INT action;
4244
4245     component = MSI_RecordGetString( row, 8 );
4246     comp = get_loaded_component( package, component );
4247     if (!comp)
4248         return ERROR_SUCCESS;
4249
4250     if (!comp->Enabled)
4251     {
4252         TRACE("component is disabled\n");
4253         return ERROR_SUCCESS;
4254     }
4255
4256     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
4257     {
4258         TRACE("Component not scheduled for installation %s\n", debugstr_w(component));
4259         comp->Action = comp->Installed;
4260         return ERROR_SUCCESS;
4261     }
4262     comp->Action = INSTALLSTATE_LOCAL;
4263
4264     identifier = MSI_RecordGetString( row, 1 );
4265     section = MSI_RecordGetString( row, 4 );
4266     key = MSI_RecordGetString( row, 5 );
4267     value = MSI_RecordGetString( row, 6 );
4268     action = MSI_RecordGetInteger( row, 7 );
4269
4270     deformat_string( package, section, &deformated_section );
4271     deformat_string( package, key, &deformated_key );
4272     deformat_string( package, value, &deformated_value );
4273
4274     if (action == msidbIniFileActionRemoveLine)
4275     {
4276         filename = get_ini_file_name( package, row );
4277
4278         TRACE("Removing key %s from section %s in %s\n",
4279                debugstr_w(deformated_key), debugstr_w(deformated_section), debugstr_w(filename));
4280
4281         if (!WritePrivateProfileStringW( deformated_section, deformated_key, NULL, filename ))
4282         {
4283             WARN("Unable to remove key %u\n", GetLastError());
4284         }
4285         msi_free( filename );
4286     }
4287     else
4288         FIXME("Unsupported action %d\n", action);
4289
4290     uirow = MSI_CreateRecord( 4 );
4291     MSI_RecordSetStringW( uirow, 1, identifier );
4292     MSI_RecordSetStringW( uirow, 2, deformated_section );
4293     MSI_RecordSetStringW( uirow, 3, deformated_key );
4294     MSI_RecordSetStringW( uirow, 4, deformated_value );
4295     ui_actiondata( package, szRemoveIniValues, uirow );
4296     msiobj_release( &uirow->hdr );
4297
4298     msi_free( deformated_key );
4299     msi_free( deformated_value );
4300     msi_free( deformated_section );
4301     return ERROR_SUCCESS;
4302 }
4303
4304 static UINT ACTION_RemoveIniValues( MSIPACKAGE *package )
4305 {
4306     UINT rc;
4307     MSIQUERY *view;
4308     static const WCHAR query[] =
4309         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4310          '`','I','n','i','F','i','l','e','`',0};
4311     static const WCHAR remove_query[] =
4312         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4313          '`','R','e','m','o','v','e','I','n','i','F','i','l','e','`',0};
4314
4315     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
4316     if (rc == ERROR_SUCCESS)
4317     {
4318         rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveIniValuesOnUninstall, package );
4319         msiobj_release( &view->hdr );
4320         if (rc != ERROR_SUCCESS)
4321             return rc;
4322     }
4323
4324     rc = MSI_DatabaseOpenViewW( package->db, remove_query, &view );
4325     if (rc == ERROR_SUCCESS)
4326     {
4327         rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveIniValuesOnInstall, package );
4328         msiobj_release( &view->hdr );
4329         if (rc != ERROR_SUCCESS)
4330             return rc;
4331     }
4332
4333     return ERROR_SUCCESS;
4334 }
4335
4336 static void register_dll( const WCHAR *dll, BOOL unregister )
4337 {
4338     HMODULE hmod;
4339
4340     hmod = LoadLibraryExW( dll, 0, LOAD_WITH_ALTERED_SEARCH_PATH );
4341     if (hmod)
4342     {
4343         HRESULT (WINAPI *func_ptr)( void );
4344         const char *func = unregister ? "DllUnregisterServer" : "DllRegisterServer";
4345
4346         func_ptr = (void *)GetProcAddress( hmod, func );
4347         if (func_ptr)
4348         {
4349             HRESULT hr = func_ptr();
4350             if (FAILED( hr ))
4351                 WARN("failed to register dll 0x%08x\n", hr);
4352         }
4353         else
4354             WARN("entry point %s not found\n", func);
4355         FreeLibrary( hmod );
4356         return;
4357     }
4358     WARN("failed to load library %u\n", GetLastError());
4359 }
4360
4361 static UINT ITERATE_SelfRegModules(MSIRECORD *row, LPVOID param)
4362 {
4363     MSIPACKAGE *package = param;
4364     LPCWSTR filename;
4365     MSIFILE *file;
4366     MSIRECORD *uirow;
4367
4368     filename = MSI_RecordGetString(row,1);
4369     file = get_loaded_file( package, filename );
4370
4371     if (!file)
4372     {
4373         ERR("Unable to find file id %s\n",debugstr_w(filename));
4374         return ERROR_SUCCESS;
4375     }
4376
4377     TRACE("Registering %s\n", debugstr_w( file->TargetPath ));
4378
4379     register_dll( file->TargetPath, FALSE );
4380
4381     uirow = MSI_CreateRecord( 2 );
4382     MSI_RecordSetStringW( uirow, 1, filename );
4383     MSI_RecordSetStringW( uirow, 2, file->Component->Directory );
4384     ui_actiondata( package, szSelfRegModules, uirow );
4385     msiobj_release( &uirow->hdr );
4386
4387     return ERROR_SUCCESS;
4388 }
4389
4390 static UINT ACTION_SelfRegModules(MSIPACKAGE *package)
4391 {
4392     UINT rc;
4393     MSIQUERY * view;
4394     static const WCHAR ExecSeqQuery[] =
4395         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4396          '`','S','e','l','f','R','e','g','`',0};
4397
4398     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4399     if (rc != ERROR_SUCCESS)
4400     {
4401         TRACE("no SelfReg table\n");
4402         return ERROR_SUCCESS;
4403     }
4404
4405     MSI_IterateRecords(view, NULL, ITERATE_SelfRegModules, package);
4406     msiobj_release(&view->hdr);
4407
4408     return ERROR_SUCCESS;
4409 }
4410
4411 static UINT ITERATE_SelfUnregModules( MSIRECORD *row, LPVOID param )
4412 {
4413     MSIPACKAGE *package = param;
4414     LPCWSTR filename;
4415     MSIFILE *file;
4416     MSIRECORD *uirow;
4417
4418     filename = MSI_RecordGetString( row, 1 );
4419     file = get_loaded_file( package, filename );
4420
4421     if (!file)
4422     {
4423         ERR("Unable to find file id %s\n", debugstr_w(filename));
4424         return ERROR_SUCCESS;
4425     }
4426
4427     TRACE("Unregistering %s\n", debugstr_w( file->TargetPath ));
4428
4429     register_dll( file->TargetPath, TRUE );
4430
4431     uirow = MSI_CreateRecord( 2 );
4432     MSI_RecordSetStringW( uirow, 1, filename );
4433     MSI_RecordSetStringW( uirow, 2, file->Component->Directory );
4434     ui_actiondata( package, szSelfUnregModules, uirow );
4435     msiobj_release( &uirow->hdr );
4436
4437     return ERROR_SUCCESS;
4438 }
4439
4440 static UINT ACTION_SelfUnregModules( MSIPACKAGE *package )
4441 {
4442     UINT rc;
4443     MSIQUERY *view;
4444     static const WCHAR query[] =
4445         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4446          '`','S','e','l','f','R','e','g','`',0};
4447
4448     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
4449     if (rc != ERROR_SUCCESS)
4450     {
4451         TRACE("no SelfReg table\n");
4452         return ERROR_SUCCESS;
4453     }
4454
4455     MSI_IterateRecords( view, NULL, ITERATE_SelfUnregModules, package );
4456     msiobj_release( &view->hdr );
4457
4458     return ERROR_SUCCESS;
4459 }
4460
4461 static UINT ACTION_PublishFeatures(MSIPACKAGE *package)
4462 {
4463     MSIFEATURE *feature;
4464     UINT rc;
4465     HKEY hkey = NULL, userdata = NULL;
4466
4467     if (!msi_check_publish(package))
4468         return ERROR_SUCCESS;
4469
4470     rc = MSIREG_OpenFeaturesKey(package->ProductCode, package->Context,
4471                                 &hkey, TRUE);
4472     if (rc != ERROR_SUCCESS)
4473         goto end;
4474
4475     rc = MSIREG_OpenUserDataFeaturesKey(package->ProductCode, package->Context,
4476                                         &userdata, TRUE);
4477     if (rc != ERROR_SUCCESS)
4478         goto end;
4479
4480     /* here the guids are base 85 encoded */
4481     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
4482     {
4483         ComponentList *cl;
4484         LPWSTR data = NULL;
4485         GUID clsid;
4486         INT size;
4487         BOOL absent = FALSE;
4488         MSIRECORD *uirow;
4489
4490         if (feature->ActionRequest != INSTALLSTATE_LOCAL &&
4491             feature->ActionRequest != INSTALLSTATE_SOURCE &&
4492             feature->ActionRequest != INSTALLSTATE_ADVERTISED) absent = TRUE;
4493
4494         size = 1;
4495         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
4496         {
4497             size += 21;
4498         }
4499         if (feature->Feature_Parent)
4500             size += strlenW( feature->Feature_Parent )+2;
4501
4502         data = msi_alloc(size * sizeof(WCHAR));
4503
4504         data[0] = 0;
4505         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
4506         {
4507             MSICOMPONENT* component = cl->component;
4508             WCHAR buf[21];
4509
4510             buf[0] = 0;
4511             if (component->ComponentId)
4512             {
4513                 TRACE("From %s\n",debugstr_w(component->ComponentId));
4514                 CLSIDFromString(component->ComponentId, &clsid);
4515                 encode_base85_guid(&clsid,buf);
4516                 TRACE("to %s\n",debugstr_w(buf));
4517                 strcatW(data,buf);
4518             }
4519         }
4520
4521         if (feature->Feature_Parent)
4522         {
4523             static const WCHAR sep[] = {'\2',0};
4524             strcatW(data,sep);
4525             strcatW(data,feature->Feature_Parent);
4526         }
4527
4528         msi_reg_set_val_str( userdata, feature->Feature, data );
4529         msi_free(data);
4530
4531         size = 0;
4532         if (feature->Feature_Parent)
4533             size = strlenW(feature->Feature_Parent)*sizeof(WCHAR);
4534         if (!absent)
4535         {
4536             size += sizeof(WCHAR);
4537             RegSetValueExW(hkey,feature->Feature,0,REG_SZ,
4538                            (const BYTE*)(feature->Feature_Parent ? feature->Feature_Parent : szEmpty),size);
4539         }
4540         else
4541         {
4542             size += 2*sizeof(WCHAR);
4543             data = msi_alloc(size);
4544             data[0] = 0x6;
4545             data[1] = 0;
4546             if (feature->Feature_Parent)
4547                 strcpyW( &data[1], feature->Feature_Parent );
4548             RegSetValueExW(hkey,feature->Feature,0,REG_SZ,
4549                        (LPBYTE)data,size);
4550             msi_free(data);
4551         }
4552
4553         /* the UI chunk */
4554         uirow = MSI_CreateRecord( 1 );
4555         MSI_RecordSetStringW( uirow, 1, feature->Feature );
4556         ui_actiondata( package, szPublishFeatures, uirow);
4557         msiobj_release( &uirow->hdr );
4558         /* FIXME: call ui_progress? */
4559     }
4560
4561 end:
4562     RegCloseKey(hkey);
4563     RegCloseKey(userdata);
4564     return rc;
4565 }
4566
4567 static UINT msi_unpublish_feature(MSIPACKAGE *package, MSIFEATURE *feature)
4568 {
4569     UINT r;
4570     HKEY hkey;
4571     MSIRECORD *uirow;
4572
4573     TRACE("unpublishing feature %s\n", debugstr_w(feature->Feature));
4574
4575     r = MSIREG_OpenFeaturesKey(package->ProductCode, package->Context,
4576                                &hkey, FALSE);
4577     if (r == ERROR_SUCCESS)
4578     {
4579         RegDeleteValueW(hkey, feature->Feature);
4580         RegCloseKey(hkey);
4581     }
4582
4583     r = MSIREG_OpenUserDataFeaturesKey(package->ProductCode, package->Context,
4584                                        &hkey, FALSE);
4585     if (r == ERROR_SUCCESS)
4586     {
4587         RegDeleteValueW(hkey, feature->Feature);
4588         RegCloseKey(hkey);
4589     }
4590
4591     uirow = MSI_CreateRecord( 1 );
4592     MSI_RecordSetStringW( uirow, 1, feature->Feature );
4593     ui_actiondata( package, szUnpublishFeatures, uirow );
4594     msiobj_release( &uirow->hdr );
4595
4596     return ERROR_SUCCESS;
4597 }
4598
4599 static UINT ACTION_UnpublishFeatures(MSIPACKAGE *package)
4600 {
4601     MSIFEATURE *feature;
4602
4603     if (!msi_check_unpublish(package))
4604         return ERROR_SUCCESS;
4605
4606     LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
4607     {
4608         msi_unpublish_feature(package, feature);
4609     }
4610
4611     return ERROR_SUCCESS;
4612 }
4613
4614 static UINT msi_publish_install_properties(MSIPACKAGE *package, HKEY hkey)
4615 {
4616     SYSTEMTIME systime;
4617     DWORD size, langid;
4618     WCHAR date[9], *val, *buffer;
4619     const WCHAR *prop, *key;
4620
4621     static const WCHAR date_fmt[] = {'%','i','%','0','2','i','%','0','2','i',0};
4622     static const WCHAR szWindowsInstaller[] =
4623         {'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
4624     static const WCHAR modpath_fmt[] =
4625         {'M','s','i','E','x','e','c','.','e','x','e',' ',
4626          '/','I','[','P','r','o','d','u','c','t','C','o','d','e',']',0};
4627     static const WCHAR szModifyPath[] =
4628         {'M','o','d','i','f','y','P','a','t','h',0};
4629     static const WCHAR szUninstallString[] =
4630         {'U','n','i','n','s','t','a','l','l','S','t','r','i','n','g',0};
4631     static const WCHAR szEstimatedSize[] =
4632         {'E','s','t','i','m','a','t','e','d','S','i','z','e',0};
4633     static const WCHAR szProductLanguage[] =
4634         {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
4635     static const WCHAR szProductVersion[] =
4636         {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
4637     static const WCHAR szDisplayVersion[] =
4638         {'D','i','s','p','l','a','y','V','e','r','s','i','o','n',0};
4639     static const WCHAR szInstallSource[] =
4640         {'I','n','s','t','a','l','l','S','o','u','r','c','e',0};
4641     static const WCHAR szARPAUTHORIZEDCDFPREFIX[] =
4642         {'A','R','P','A','U','T','H','O','R','I','Z','E','D','C','D','F','P','R','E','F','I','X',0};
4643     static const WCHAR szAuthorizedCDFPrefix[] =
4644         {'A','u','t','h','o','r','i','z','e','d','C','D','F','P','r','e','f','i','x',0};
4645     static const WCHAR szARPCONTACT[] =
4646         {'A','R','P','C','O','N','T','A','C','T',0};
4647     static const WCHAR szContact[] =
4648         {'C','o','n','t','a','c','t',0};
4649     static const WCHAR szARPCOMMENTS[] =
4650         {'A','R','P','C','O','M','M','E','N','T','S',0};
4651     static const WCHAR szComments[] =
4652         {'C','o','m','m','e','n','t','s',0};
4653     static const WCHAR szProductName[] =
4654         {'P','r','o','d','u','c','t','N','a','m','e',0};
4655     static const WCHAR szDisplayName[] =
4656         {'D','i','s','p','l','a','y','N','a','m','e',0};
4657     static const WCHAR szARPHELPLINK[] =
4658         {'A','R','P','H','E','L','P','L','I','N','K',0};
4659     static const WCHAR szHelpLink[] =
4660         {'H','e','l','p','L','i','n','k',0};
4661     static const WCHAR szARPHELPTELEPHONE[] =
4662         {'A','R','P','H','E','L','P','T','E','L','E','P','H','O','N','E',0};
4663     static const WCHAR szHelpTelephone[] =
4664         {'H','e','l','p','T','e','l','e','p','h','o','n','e',0};
4665     static const WCHAR szARPINSTALLLOCATION[] =
4666         {'A','R','P','I','N','S','T','A','L','L','L','O','C','A','T','I','O','N',0};
4667     static const WCHAR szInstallLocation[] =
4668         {'I','n','s','t','a','l','l','L','o','c','a','t','i','o','n',0};
4669     static const WCHAR szManufacturer[] =
4670         {'M','a','n','u','f','a','c','t','u','r','e','r',0};
4671     static const WCHAR szPublisher[] =
4672         {'P','u','b','l','i','s','h','e','r',0};
4673     static const WCHAR szARPREADME[] =
4674         {'A','R','P','R','E','A','D','M','E',0};
4675     static const WCHAR szReadme[] =
4676         {'R','e','a','d','M','e',0};
4677     static const WCHAR szARPSIZE[] =
4678         {'A','R','P','S','I','Z','E',0};
4679     static const WCHAR szSize[] =
4680         {'S','i','z','e',0};
4681     static const WCHAR szARPURLINFOABOUT[] =
4682         {'A','R','P','U','R','L','I','N','F','O','A','B','O','U','T',0};
4683     static const WCHAR szURLInfoAbout[] =
4684         {'U','R','L','I','n','f','o','A','b','o','u','t',0};
4685     static const WCHAR szARPURLUPDATEINFO[] =
4686         {'A','R','P','U','R','L','U','P','D','A','T','E','I','N','F','O',0};
4687     static const WCHAR szURLUpdateInfo[] =
4688         {'U','R','L','U','p','d','a','t','e','I','n','f','o',0};
4689
4690     static const WCHAR *propval[] = {
4691         szARPAUTHORIZEDCDFPREFIX, szAuthorizedCDFPrefix,
4692         szARPCONTACT,             szContact,
4693         szARPCOMMENTS,            szComments,
4694         szProductName,            szDisplayName,
4695         szARPHELPLINK,            szHelpLink,
4696         szARPHELPTELEPHONE,       szHelpTelephone,
4697         szARPINSTALLLOCATION,     szInstallLocation,
4698         cszSourceDir,             szInstallSource,
4699         szManufacturer,           szPublisher,
4700         szARPREADME,              szReadme,
4701         szARPSIZE,                szSize,
4702         szARPURLINFOABOUT,        szURLInfoAbout,
4703         szARPURLUPDATEINFO,       szURLUpdateInfo,
4704         NULL
4705     };
4706     const WCHAR **p = propval;
4707
4708     while (*p)
4709     {
4710         prop = *p++;
4711         key = *p++;
4712         val = msi_dup_property(package->db, prop);
4713         msi_reg_set_val_str(hkey, key, val);
4714         msi_free(val);
4715     }
4716
4717     msi_reg_set_val_dword(hkey, szWindowsInstaller, 1);
4718
4719     size = deformat_string(package, modpath_fmt, &buffer);
4720     RegSetValueExW(hkey, szModifyPath, 0, REG_EXPAND_SZ, (LPBYTE)buffer, size);
4721     RegSetValueExW(hkey, szUninstallString, 0, REG_EXPAND_SZ, (LPBYTE)buffer, size);
4722     msi_free(buffer);
4723
4724     /* FIXME: Write real Estimated Size when we have it */
4725     msi_reg_set_val_dword(hkey, szEstimatedSize, 0);
4726
4727     GetLocalTime(&systime);
4728     sprintfW(date, date_fmt, systime.wYear, systime.wMonth, systime.wDay);
4729     msi_reg_set_val_str(hkey, INSTALLPROPERTY_INSTALLDATEW, date);
4730
4731     langid = msi_get_property_int(package->db, szProductLanguage, 0);
4732     msi_reg_set_val_dword(hkey, INSTALLPROPERTY_LANGUAGEW, langid);
4733
4734     buffer = msi_dup_property(package->db, szProductVersion);
4735     msi_reg_set_val_str(hkey, szDisplayVersion, buffer);
4736     if (buffer)
4737     {
4738         DWORD verdword = msi_version_str_to_dword(buffer);
4739
4740         msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONW, verdword);
4741         msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONMAJORW, verdword >> 24);
4742         msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONMINORW, (verdword >> 16) & 0xFF);
4743         msi_free(buffer);
4744     }
4745
4746     return ERROR_SUCCESS;
4747 }
4748
4749 static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
4750 {
4751     WCHAR squashed_pc[SQUISH_GUID_SIZE];
4752     MSIRECORD *uirow;
4753     LPWSTR upgrade_code;
4754     HKEY hkey, props;
4755     HKEY upgrade;
4756     UINT rc;
4757
4758     /* FIXME: also need to publish if the product is in advertise mode */
4759     if (!msi_check_publish(package))
4760         return ERROR_SUCCESS;
4761
4762     rc = MSIREG_OpenUninstallKey(package->ProductCode, &hkey, TRUE);
4763     if (rc != ERROR_SUCCESS)
4764         return rc;
4765
4766     rc = MSIREG_OpenInstallProps(package->ProductCode, package->Context,
4767                                  NULL, &props, TRUE);
4768     if (rc != ERROR_SUCCESS)
4769         goto done;
4770
4771     msi_reg_set_val_str( props, INSTALLPROPERTY_LOCALPACKAGEW, package->db->localfile );
4772     msi_free( package->db->localfile );
4773     package->db->localfile = NULL;
4774
4775     rc = msi_publish_install_properties(package, hkey);
4776     if (rc != ERROR_SUCCESS)
4777         goto done;
4778
4779     rc = msi_publish_install_properties(package, props);
4780     if (rc != ERROR_SUCCESS)
4781         goto done;
4782
4783     upgrade_code = msi_dup_property(package->db, szUpgradeCode);
4784     if (upgrade_code)
4785     {
4786         MSIREG_OpenUpgradeCodesKey(upgrade_code, &upgrade, TRUE);
4787         squash_guid(package->ProductCode, squashed_pc);
4788         msi_reg_set_val_str(upgrade, squashed_pc, NULL);
4789         RegCloseKey(upgrade);
4790         msi_free(upgrade_code);
4791     }
4792
4793 done:
4794     uirow = MSI_CreateRecord( 1 );
4795     MSI_RecordSetStringW( uirow, 1, package->ProductCode );
4796     ui_actiondata( package, szRegisterProduct, uirow );
4797     msiobj_release( &uirow->hdr );
4798
4799     RegCloseKey(hkey);
4800     return ERROR_SUCCESS;
4801 }
4802
4803 static UINT ACTION_InstallExecute(MSIPACKAGE *package)
4804 {
4805     return execute_script(package,INSTALL_SCRIPT);
4806 }
4807
4808 static UINT msi_unpublish_product(MSIPACKAGE *package, WCHAR *remove)
4809 {
4810     WCHAR *upgrade, **features;
4811     BOOL full_uninstall = TRUE;
4812     MSIFEATURE *feature;
4813     MSIPATCHINFO *patch;
4814
4815     static const WCHAR szUpgradeCode[] =
4816         {'U','p','g','r','a','d','e','C','o','d','e',0};
4817
4818     features = msi_split_string(remove, ',');
4819     if (!features)
4820     {
4821         ERR("REMOVE feature list is empty!\n");
4822         return ERROR_FUNCTION_FAILED;
4823     }
4824
4825     if (!lstrcmpW(features[0], szAll))
4826         full_uninstall = TRUE;
4827     else
4828     {
4829         LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
4830         {
4831             if (feature->Action != INSTALLSTATE_ABSENT)
4832                 full_uninstall = FALSE;
4833         }
4834     }
4835     msi_free(features);
4836
4837     if (!full_uninstall)
4838         return ERROR_SUCCESS;
4839
4840     MSIREG_DeleteProductKey(package->ProductCode);
4841     MSIREG_DeleteUserDataProductKey(package->ProductCode);
4842     MSIREG_DeleteUninstallKey(package->ProductCode);
4843
4844     if (package->Context == MSIINSTALLCONTEXT_MACHINE)
4845     {
4846         MSIREG_DeleteLocalClassesProductKey(package->ProductCode);
4847         MSIREG_DeleteLocalClassesFeaturesKey(package->ProductCode);
4848     }
4849     else
4850     {
4851         MSIREG_DeleteUserProductKey(package->ProductCode);
4852         MSIREG_DeleteUserFeaturesKey(package->ProductCode);
4853     }
4854
4855     upgrade = msi_dup_property(package->db, szUpgradeCode);
4856     if (upgrade)
4857     {
4858         MSIREG_DeleteUserUpgradeCodesKey(upgrade);
4859         msi_free(upgrade);
4860     }
4861
4862     LIST_FOR_EACH_ENTRY(patch, &package->patches, MSIPATCHINFO, entry)
4863     {
4864         MSIREG_DeleteUserDataPatchKey(patch->patchcode, package->Context);
4865     }
4866
4867     return ERROR_SUCCESS;
4868 }
4869
4870 static UINT ACTION_InstallFinalize(MSIPACKAGE *package)
4871 {
4872     UINT rc;
4873     WCHAR *remove;
4874
4875     /* turn off scheduling */
4876     package->script->CurrentlyScripting= FALSE;
4877
4878     /* first do the same as an InstallExecute */
4879     rc = ACTION_InstallExecute(package);
4880     if (rc != ERROR_SUCCESS)
4881         return rc;
4882
4883     /* then handle Commit Actions */
4884     rc = execute_script(package,COMMIT_SCRIPT);
4885     if (rc != ERROR_SUCCESS)
4886         return rc;
4887
4888     remove = msi_dup_property(package->db, szRemove);
4889     if (remove)
4890         rc = msi_unpublish_product(package, remove);
4891
4892     msi_free(remove);
4893     return rc;
4894 }
4895
4896 UINT ACTION_ForceReboot(MSIPACKAGE *package)
4897 {
4898     static const WCHAR RunOnce[] = {
4899     'S','o','f','t','w','a','r','e','\\',
4900     'M','i','c','r','o','s','o','f','t','\\',
4901     'W','i','n','d','o','w','s','\\',
4902     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
4903     'R','u','n','O','n','c','e',0};
4904     static const WCHAR InstallRunOnce[] = {
4905     'S','o','f','t','w','a','r','e','\\',
4906     'M','i','c','r','o','s','o','f','t','\\',
4907     'W','i','n','d','o','w','s','\\',
4908     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
4909     'I','n','s','t','a','l','l','e','r','\\',
4910     'R','u','n','O','n','c','e','E','n','t','r','i','e','s',0};
4911
4912     static const WCHAR msiexec_fmt[] = {
4913     '%','s',
4914     '\\','M','s','i','E','x','e','c','.','e','x','e',' ','/','@',' ',
4915     '\"','%','s','\"',0};
4916     static const WCHAR install_fmt[] = {
4917     '/','I',' ','\"','%','s','\"',' ',
4918     'A','F','T','E','R','R','E','B','O','O','T','=','1',' ',
4919     'R','U','N','O','N','C','E','E','N','T','R','Y','=','\"','%','s','\"',0};
4920     WCHAR buffer[256], sysdir[MAX_PATH];
4921     HKEY hkey;
4922     WCHAR squished_pc[100];
4923
4924     squash_guid(package->ProductCode,squished_pc);
4925
4926     GetSystemDirectoryW(sysdir, sizeof(sysdir)/sizeof(sysdir[0]));
4927     RegCreateKeyW(HKEY_LOCAL_MACHINE,RunOnce,&hkey);
4928     snprintfW(buffer,sizeof(buffer)/sizeof(buffer[0]),msiexec_fmt,sysdir,
4929      squished_pc);
4930
4931     msi_reg_set_val_str( hkey, squished_pc, buffer );
4932     RegCloseKey(hkey);
4933
4934     TRACE("Reboot command %s\n",debugstr_w(buffer));
4935
4936     RegCreateKeyW(HKEY_LOCAL_MACHINE,InstallRunOnce,&hkey);
4937     sprintfW(buffer,install_fmt,package->ProductCode,squished_pc);
4938
4939     msi_reg_set_val_str( hkey, squished_pc, buffer );
4940     RegCloseKey(hkey);
4941
4942     return ERROR_INSTALL_SUSPEND;
4943 }
4944
4945 static UINT ACTION_ResolveSource(MSIPACKAGE* package)
4946 {
4947     DWORD attrib;
4948     UINT rc;
4949
4950     /*
4951      * We are currently doing what should be done here in the top level Install
4952      * however for Administrative and uninstalls this step will be needed
4953      */
4954     if (!package->PackagePath)
4955         return ERROR_SUCCESS;
4956
4957     msi_set_sourcedir_props(package, TRUE);
4958
4959     attrib = GetFileAttributesW(package->db->path);
4960     if (attrib == INVALID_FILE_ATTRIBUTES)
4961     {
4962         LPWSTR prompt;
4963         LPWSTR msg;
4964         DWORD size = 0;
4965
4966         rc = MsiSourceListGetInfoW(package->ProductCode, NULL,
4967                 package->Context, MSICODE_PRODUCT,
4968                 INSTALLPROPERTY_DISKPROMPTW,NULL,&size);
4969         if (rc == ERROR_MORE_DATA)
4970         {
4971             prompt = msi_alloc(size * sizeof(WCHAR));
4972             MsiSourceListGetInfoW(package->ProductCode, NULL,
4973                     package->Context, MSICODE_PRODUCT,
4974                     INSTALLPROPERTY_DISKPROMPTW,prompt,&size);
4975         }
4976         else
4977             prompt = strdupW(package->db->path);
4978
4979         msg = generate_error_string(package,1302,1,prompt);
4980         while(attrib == INVALID_FILE_ATTRIBUTES)
4981         {
4982             rc = MessageBoxW(NULL,msg,NULL,MB_OKCANCEL);
4983             if (rc == IDCANCEL)
4984             {
4985                 rc = ERROR_INSTALL_USEREXIT;
4986                 break;
4987             }
4988             attrib = GetFileAttributesW(package->db->path);
4989         }
4990         msi_free(prompt);
4991         rc = ERROR_SUCCESS;
4992     }
4993     else
4994         return ERROR_SUCCESS;
4995
4996     return rc;
4997 }
4998
4999 static UINT ACTION_RegisterUser(MSIPACKAGE *package)
5000 {
5001     HKEY hkey = 0;
5002     LPWSTR buffer, productid = NULL;
5003     UINT i, rc = ERROR_SUCCESS;
5004     MSIRECORD *uirow;
5005
5006     static const WCHAR szPropKeys[][80] =
5007     {
5008         {'P','r','o','d','u','c','t','I','D',0},
5009         {'U','S','E','R','N','A','M','E',0},
5010         {'C','O','M','P','A','N','Y','N','A','M','E',0},
5011         {0},
5012     };
5013
5014     static const WCHAR szRegKeys[][80] =
5015     {
5016         {'P','r','o','d','u','c','t','I','D',0},
5017         {'R','e','g','O','w','n','e','r',0},
5018         {'R','e','g','C','o','m','p','a','n','y',0},
5019         {0},
5020     };
5021
5022     if (msi_check_unpublish(package))
5023     {
5024         MSIREG_DeleteUserDataProductKey(package->ProductCode);
5025         goto end;
5026     }
5027
5028     productid = msi_dup_property( package->db, INSTALLPROPERTY_PRODUCTIDW );
5029     if (!productid)
5030         goto end;
5031
5032     rc = MSIREG_OpenInstallProps(package->ProductCode, package->Context,
5033                                  NULL, &hkey, TRUE);
5034     if (rc != ERROR_SUCCESS)
5035         goto end;
5036
5037     for( i = 0; szPropKeys[i][0]; i++ )
5038     {
5039         buffer = msi_dup_property( package->db, szPropKeys[i] );
5040         msi_reg_set_val_str( hkey, szRegKeys[i], buffer );
5041         msi_free( buffer );
5042     }
5043
5044 end:
5045     uirow = MSI_CreateRecord( 1 );
5046     MSI_RecordSetStringW( uirow, 1, productid );
5047     ui_actiondata( package, szRegisterUser, uirow );
5048     msiobj_release( &uirow->hdr );
5049
5050     msi_free(productid);
5051     RegCloseKey(hkey);
5052     return rc;
5053 }
5054
5055
5056 static UINT ACTION_ExecuteAction(MSIPACKAGE *package)
5057 {
5058     UINT rc;
5059
5060     package->script->InWhatSequence |= SEQUENCE_EXEC;
5061     rc = ACTION_ProcessExecSequence(package,FALSE);
5062     return rc;
5063 }
5064
5065
5066 static UINT ITERATE_PublishComponent(MSIRECORD *rec, LPVOID param)
5067 {
5068     MSIPACKAGE *package = param;
5069     LPCWSTR compgroupid, component, feature, qualifier, text;
5070     LPWSTR advertise = NULL, output = NULL;
5071     HKEY hkey = NULL;
5072     UINT rc;
5073     MSICOMPONENT *comp;
5074     MSIFEATURE *feat;
5075     DWORD sz;
5076     MSIRECORD *uirow;
5077
5078     feature = MSI_RecordGetString(rec, 5);
5079     feat = get_loaded_feature(package, feature);
5080     if (!feat)
5081         return ERROR_SUCCESS;
5082
5083     if (feat->ActionRequest != INSTALLSTATE_LOCAL &&
5084         feat->ActionRequest != INSTALLSTATE_SOURCE &&
5085         feat->ActionRequest != INSTALLSTATE_ADVERTISED)
5086     {
5087         TRACE("Feature %s not scheduled for installation\n", debugstr_w(feature));
5088         feat->Action = feat->Installed;
5089         return ERROR_SUCCESS;
5090     }
5091
5092     component = MSI_RecordGetString(rec, 3);
5093     comp = get_loaded_component(package, component);
5094     if (!comp)
5095         return ERROR_SUCCESS;
5096
5097     compgroupid = MSI_RecordGetString(rec,1);
5098     qualifier = MSI_RecordGetString(rec,2);
5099
5100     rc = MSIREG_OpenUserComponentsKey(compgroupid, &hkey, TRUE);
5101     if (rc != ERROR_SUCCESS)
5102         goto end;
5103
5104     text = MSI_RecordGetString(rec,4);
5105     advertise = create_component_advertise_string(package, comp, feature);
5106
5107     sz = strlenW(advertise);
5108
5109     if (text)
5110         sz += lstrlenW(text);
5111
5112     sz+=3;
5113     sz *= sizeof(WCHAR);
5114
5115     output = msi_alloc_zero(sz);
5116     strcpyW(output,advertise);
5117     msi_free(advertise);
5118
5119     if (text)
5120         strcatW(output,text);
5121
5122     msi_reg_set_val_multi_str( hkey, qualifier, output );
5123
5124 end:
5125     RegCloseKey(hkey);
5126     msi_free(output);
5127
5128     /* the UI chunk */
5129     uirow = MSI_CreateRecord( 2 );
5130     MSI_RecordSetStringW( uirow, 1, compgroupid );
5131     MSI_RecordSetStringW( uirow, 2, qualifier);
5132     ui_actiondata( package, szPublishComponents, uirow);
5133     msiobj_release( &uirow->hdr );
5134     /* FIXME: call ui_progress? */
5135
5136     return rc;
5137 }
5138
5139 /*
5140  * At present I am ignorning the advertised components part of this and only
5141  * focusing on the qualified component sets
5142  */
5143 static UINT ACTION_PublishComponents(MSIPACKAGE *package)
5144 {
5145     UINT rc;
5146     MSIQUERY * view;
5147     static const WCHAR ExecSeqQuery[] =
5148         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5149          '`','P','u','b','l','i','s','h',
5150          'C','o','m','p','o','n','e','n','t','`',0};
5151
5152     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
5153     if (rc != ERROR_SUCCESS)
5154         return ERROR_SUCCESS;
5155
5156     rc = MSI_IterateRecords(view, NULL, ITERATE_PublishComponent, package);
5157     msiobj_release(&view->hdr);
5158
5159     return rc;
5160 }
5161
5162 static UINT ITERATE_UnpublishComponent( MSIRECORD *rec, LPVOID param )
5163 {
5164     static const WCHAR szInstallerComponents[] = {
5165         'S','o','f','t','w','a','r','e','\\',
5166         'M','i','c','r','o','s','o','f','t','\\',
5167         'I','n','s','t','a','l','l','e','r','\\',
5168         'C','o','m','p','o','n','e','n','t','s','\\',0};
5169
5170     MSIPACKAGE *package = param;
5171     LPCWSTR compgroupid, component, feature, qualifier;
5172     MSICOMPONENT *comp;
5173     MSIFEATURE *feat;
5174     MSIRECORD *uirow;
5175     WCHAR squashed[GUID_SIZE], keypath[MAX_PATH];
5176     LONG res;
5177
5178     feature = MSI_RecordGetString( rec, 5 );
5179     feat = get_loaded_feature( package, feature );
5180     if (!feat)
5181         return ERROR_SUCCESS;
5182
5183     if (feat->ActionRequest != INSTALLSTATE_ABSENT)
5184     {
5185         TRACE("Feature %s not scheduled for removal\n", debugstr_w(feature));
5186         feat->Action = feat->Installed;
5187         return ERROR_SUCCESS;
5188     }
5189
5190     component = MSI_RecordGetString( rec, 3 );
5191     comp = get_loaded_component( package, component );
5192     if (!comp)
5193         return ERROR_SUCCESS;
5194
5195     compgroupid = MSI_RecordGetString( rec, 1 );
5196     qualifier = MSI_RecordGetString( rec, 2 );
5197
5198     squash_guid( compgroupid, squashed );
5199     strcpyW( keypath, szInstallerComponents );
5200     strcatW( keypath, squashed );
5201
5202     res = RegDeleteKeyW( HKEY_CURRENT_USER, keypath );
5203     if (res != ERROR_SUCCESS)
5204     {
5205         WARN("Unable to delete component key %d\n", res);
5206     }
5207
5208     uirow = MSI_CreateRecord( 2 );
5209     MSI_RecordSetStringW( uirow, 1, compgroupid );
5210     MSI_RecordSetStringW( uirow, 2, qualifier );
5211     ui_actiondata( package, szUnpublishComponents, uirow );
5212     msiobj_release( &uirow->hdr );
5213
5214     return ERROR_SUCCESS;
5215 }
5216
5217 static UINT ACTION_UnpublishComponents( MSIPACKAGE *package )
5218 {
5219     UINT rc;
5220     MSIQUERY *view;
5221     static const WCHAR query[] =
5222         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5223          '`','P','u','b','l','i','s','h',
5224          'C','o','m','p','o','n','e','n','t','`',0};
5225
5226     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
5227     if (rc != ERROR_SUCCESS)
5228         return ERROR_SUCCESS;
5229
5230     rc = MSI_IterateRecords( view, NULL, ITERATE_UnpublishComponent, package );
5231     msiobj_release( &view->hdr );
5232
5233     return rc;
5234 }
5235
5236 static UINT ITERATE_InstallService(MSIRECORD *rec, LPVOID param)
5237 {
5238     MSIPACKAGE *package = param;
5239     MSIRECORD *row;
5240     MSIFILE *file;
5241     SC_HANDLE hscm, service = NULL;
5242     LPCWSTR comp, depends, pass;
5243     LPWSTR name = NULL, disp = NULL;
5244     LPCWSTR load_order, serv_name, key;
5245     DWORD serv_type, start_type;
5246     DWORD err_control;
5247
5248     static const WCHAR query[] =
5249         {'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
5250          '`','C','o','m','p','o','n','e','n','t','`',' ',
5251          'W','H','E','R','E',' ',
5252          '`','C','o','m','p','o','n','e','n','t','`',' ',
5253          '=','\'','%','s','\'',0};
5254
5255     hscm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, GENERIC_WRITE);
5256     if (!hscm)
5257     {
5258         ERR("Failed to open the SC Manager!\n");
5259         goto done;
5260     }
5261
5262     start_type = MSI_RecordGetInteger(rec, 5);
5263     if (start_type == SERVICE_BOOT_START || start_type == SERVICE_SYSTEM_START)
5264         goto done;
5265
5266     depends = MSI_RecordGetString(rec, 8);
5267     if (depends && *depends)
5268         FIXME("Dependency list unhandled!\n");
5269
5270     deformat_string(package, MSI_RecordGetString(rec, 2), &name);
5271     deformat_string(package, MSI_RecordGetString(rec, 3), &disp);
5272     serv_type = MSI_RecordGetInteger(rec, 4);
5273     err_control = MSI_RecordGetInteger(rec, 6);
5274     load_order = MSI_RecordGetString(rec, 7);
5275     serv_name = MSI_RecordGetString(rec, 9);
5276     pass = MSI_RecordGetString(rec, 10);
5277     comp = MSI_RecordGetString(rec, 12);
5278
5279     /* fetch the service path */
5280     row = MSI_QueryGetRecord(package->db, query, comp);
5281     if (!row)
5282     {
5283         ERR("Control query failed!\n");
5284         goto done;
5285     }
5286
5287     key = MSI_RecordGetString(row, 6);
5288
5289     file = get_loaded_file(package, key);
5290     msiobj_release(&row->hdr);
5291     if (!file)
5292     {
5293         ERR("Failed to load the service file\n");
5294         goto done;
5295     }
5296
5297     service = CreateServiceW(hscm, name, disp, GENERIC_ALL, serv_type,
5298                              start_type, err_control, file->TargetPath,
5299                              load_order, NULL, NULL, serv_name, pass);
5300     if (!service)
5301     {
5302         if (GetLastError() != ERROR_SERVICE_EXISTS)
5303             ERR("Failed to create service %s: %d\n", debugstr_w(name), GetLastError());
5304     }
5305
5306 done:
5307     CloseServiceHandle(service);
5308     CloseServiceHandle(hscm);
5309     msi_free(name);
5310     msi_free(disp);
5311
5312     return ERROR_SUCCESS;
5313 }
5314
5315 static UINT ACTION_InstallServices( MSIPACKAGE *package )
5316 {
5317     UINT rc;
5318     MSIQUERY * view;
5319     static const WCHAR ExecSeqQuery[] =
5320         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5321          'S','e','r','v','i','c','e','I','n','s','t','a','l','l',0};
5322
5323     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
5324     if (rc != ERROR_SUCCESS)
5325         return ERROR_SUCCESS;
5326
5327     rc = MSI_IterateRecords(view, NULL, ITERATE_InstallService, package);
5328     msiobj_release(&view->hdr);
5329
5330     return rc;
5331 }
5332
5333 /* converts arg1[~]arg2[~]arg3 to a list of ptrs to the strings */
5334 static LPCWSTR *msi_service_args_to_vector(LPWSTR args, DWORD *numargs)
5335 {
5336     LPCWSTR *vector, *temp_vector;
5337     LPWSTR p, q;
5338     DWORD sep_len;
5339
5340     static const WCHAR separator[] = {'[','~',']',0};
5341
5342     *numargs = 0;
5343     sep_len = sizeof(separator) / sizeof(WCHAR) - 1;
5344
5345     if (!args)
5346         return NULL;
5347
5348     vector = msi_alloc(sizeof(LPWSTR));
5349     if (!vector)
5350         return NULL;
5351
5352     p = args;
5353     do
5354     {
5355         (*numargs)++;
5356         vector[*numargs - 1] = p;
5357
5358         if ((q = strstrW(p, separator)))
5359         {
5360             *q = '\0';
5361
5362             temp_vector = msi_realloc(vector, (*numargs + 1) * sizeof(LPWSTR));
5363             if (!temp_vector)
5364             {
5365                 msi_free(vector);
5366                 return NULL;
5367             }
5368             vector = temp_vector;
5369
5370             p = q + sep_len;
5371         }
5372     } while (q);
5373
5374     return vector;
5375 }
5376
5377 static UINT ITERATE_StartService(MSIRECORD *rec, LPVOID param)
5378 {
5379     MSIPACKAGE *package = param;
5380     MSICOMPONENT *comp;
5381     MSIRECORD *uirow;
5382     SC_HANDLE scm = NULL, service = NULL;
5383     LPCWSTR component, *vector = NULL;
5384     LPWSTR name, args, display_name = NULL;
5385     DWORD event, numargs, len;
5386     UINT r = ERROR_FUNCTION_FAILED;
5387
5388     component = MSI_RecordGetString(rec, 6);
5389     comp = get_loaded_component(package, component);
5390     if (!comp)
5391         return ERROR_SUCCESS;
5392
5393     if (!comp->Enabled)
5394     {
5395         TRACE("component is disabled\n");
5396         return ERROR_SUCCESS;
5397     }
5398
5399     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
5400     {
5401         TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
5402         comp->Action = comp->Installed;
5403         return ERROR_SUCCESS;
5404     }
5405     comp->Action = INSTALLSTATE_LOCAL;
5406
5407     deformat_string(package, MSI_RecordGetString(rec, 2), &name);
5408     deformat_string(package, MSI_RecordGetString(rec, 4), &args);
5409     event = MSI_RecordGetInteger(rec, 3);
5410
5411     if (!(event & msidbServiceControlEventStart))
5412     {
5413         r = ERROR_SUCCESS;
5414         goto done;
5415     }
5416
5417     scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
5418     if (!scm)
5419     {
5420         ERR("Failed to open the service control manager\n");
5421         goto done;
5422     }
5423
5424     len = 0;
5425     if (!GetServiceDisplayNameW( scm, name, NULL, &len ) &&
5426         GetLastError() == ERROR_INSUFFICIENT_BUFFER)
5427     {
5428         if ((display_name = msi_alloc( ++len * sizeof(WCHAR ))))
5429             GetServiceDisplayNameW( scm, name, display_name, &len );
5430     }
5431
5432     service = OpenServiceW(scm, name, SERVICE_START);
5433     if (!service)
5434     {
5435         ERR("Failed to open service %s (%u)\n", debugstr_w(name), GetLastError());
5436         goto done;
5437     }
5438
5439     vector = msi_service_args_to_vector(args, &numargs);
5440
5441     if (!StartServiceW(service, numargs, vector) &&
5442         GetLastError() != ERROR_SERVICE_ALREADY_RUNNING)
5443     {
5444         ERR("Failed to start service %s (%u)\n", debugstr_w(name), GetLastError());
5445         goto done;
5446     }
5447
5448     r = ERROR_SUCCESS;
5449
5450 done:
5451     uirow = MSI_CreateRecord( 2 );
5452     MSI_RecordSetStringW( uirow, 1, display_name );
5453     MSI_RecordSetStringW( uirow, 2, name );
5454     ui_actiondata( package, szStartServices, uirow );
5455     msiobj_release( &uirow->hdr );
5456
5457     CloseServiceHandle(service);
5458     CloseServiceHandle(scm);
5459
5460     msi_free(name);
5461     msi_free(args);
5462     msi_free(vector);
5463     msi_free(display_name);
5464     return r;
5465 }
5466
5467 static UINT ACTION_StartServices( MSIPACKAGE *package )
5468 {
5469     UINT rc;
5470     MSIQUERY *view;
5471
5472     static const WCHAR query[] = {
5473         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5474         'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
5475
5476     rc = MSI_DatabaseOpenViewW(package->db, query, &view);
5477     if (rc != ERROR_SUCCESS)
5478         return ERROR_SUCCESS;
5479
5480     rc = MSI_IterateRecords(view, NULL, ITERATE_StartService, package);
5481     msiobj_release(&view->hdr);
5482
5483     return rc;
5484 }
5485
5486 static BOOL stop_service_dependents(SC_HANDLE scm, SC_HANDLE service)
5487 {
5488     DWORD i, needed, count;
5489     ENUM_SERVICE_STATUSW *dependencies;
5490     SERVICE_STATUS ss;
5491     SC_HANDLE depserv;
5492
5493     if (EnumDependentServicesW(service, SERVICE_ACTIVE, NULL,
5494                                0, &needed, &count))
5495         return TRUE;
5496
5497     if (GetLastError() != ERROR_MORE_DATA)
5498         return FALSE;
5499
5500     dependencies = msi_alloc(needed);
5501     if (!dependencies)
5502         return FALSE;
5503
5504     if (!EnumDependentServicesW(service, SERVICE_ACTIVE, dependencies,
5505                                 needed, &needed, &count))
5506         goto error;
5507
5508     for (i = 0; i < count; i++)
5509     {
5510         depserv = OpenServiceW(scm, dependencies[i].lpServiceName,
5511                                SERVICE_STOP | SERVICE_QUERY_STATUS);
5512         if (!depserv)
5513             goto error;
5514
5515         if (!ControlService(depserv, SERVICE_CONTROL_STOP, &ss))
5516             goto error;
5517     }
5518
5519     return TRUE;
5520
5521 error:
5522     msi_free(dependencies);
5523     return FALSE;
5524 }
5525
5526 static UINT stop_service( LPCWSTR name )
5527 {
5528     SC_HANDLE scm = NULL, service = NULL;
5529     SERVICE_STATUS status;
5530     SERVICE_STATUS_PROCESS ssp;
5531     DWORD needed;
5532
5533     scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);
5534     if (!scm)
5535     {
5536         WARN("Failed to open the SCM: %d\n", GetLastError());
5537         goto done;
5538     }
5539
5540     service = OpenServiceW(scm, name,
5541                            SERVICE_STOP |
5542                            SERVICE_QUERY_STATUS |
5543                            SERVICE_ENUMERATE_DEPENDENTS);
5544     if (!service)
5545     {
5546         WARN("Failed to open service (%s): %d\n", debugstr_w(name), GetLastError());
5547         goto done;
5548     }
5549
5550     if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp,
5551                               sizeof(SERVICE_STATUS_PROCESS), &needed))
5552     {
5553         WARN("Failed to query service status (%s): %d\n", debugstr_w(name), GetLastError());
5554         goto done;
5555     }
5556
5557     if (ssp.dwCurrentState == SERVICE_STOPPED)
5558         goto done;
5559
5560     stop_service_dependents(scm, service);
5561
5562     if (!ControlService(service, SERVICE_CONTROL_STOP, &status))
5563         WARN("Failed to stop service (%s): %d\n", debugstr_w(name), GetLastError());
5564
5565 done:
5566     CloseServiceHandle(service);
5567     CloseServiceHandle(scm);
5568
5569     return ERROR_SUCCESS;
5570 }
5571
5572 static UINT ITERATE_StopService( MSIRECORD *rec, LPVOID param )
5573 {
5574     MSIPACKAGE *package = param;
5575     MSICOMPONENT *comp;
5576     MSIRECORD *uirow;
5577     LPCWSTR component;
5578     LPWSTR name = NULL, display_name = NULL;
5579     DWORD event, len;
5580     SC_HANDLE scm;
5581
5582     event = MSI_RecordGetInteger( rec, 3 );
5583     if (!(event & msidbServiceControlEventStop))
5584         return ERROR_SUCCESS;
5585
5586     component = MSI_RecordGetString( rec, 6 );
5587     comp = get_loaded_component( package, component );
5588     if (!comp)
5589         return ERROR_SUCCESS;
5590
5591     if (!comp->Enabled)
5592     {
5593         TRACE("component is disabled\n");
5594         return ERROR_SUCCESS;
5595     }
5596
5597     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
5598     {
5599         TRACE("Component not scheduled for removal: %s\n", debugstr_w(component));
5600         comp->Action = comp->Installed;
5601         return ERROR_SUCCESS;
5602     }
5603     comp->Action = INSTALLSTATE_ABSENT;
5604
5605     scm = OpenSCManagerW( NULL, NULL, SC_MANAGER_CONNECT );
5606     if (!scm)
5607     {
5608         ERR("Failed to open the service control manager\n");
5609         goto done;
5610     }
5611
5612     len = 0;
5613     if (!GetServiceDisplayNameW( scm, name, NULL, &len ) &&
5614         GetLastError() == ERROR_INSUFFICIENT_BUFFER)
5615     {
5616         if ((display_name = msi_alloc( ++len * sizeof(WCHAR ))))
5617             GetServiceDisplayNameW( scm, name, display_name, &len );
5618     }
5619     CloseServiceHandle( scm );
5620
5621     deformat_string( package, MSI_RecordGetString( rec, 2 ), &name );
5622     stop_service( name );
5623
5624 done:
5625     uirow = MSI_CreateRecord( 2 );
5626     MSI_RecordSetStringW( uirow, 1, display_name );
5627     MSI_RecordSetStringW( uirow, 2, name );
5628     ui_actiondata( package, szStopServices, uirow );
5629     msiobj_release( &uirow->hdr );
5630
5631     msi_free( name );
5632     msi_free( display_name );
5633     return ERROR_SUCCESS;
5634 }
5635
5636 static UINT ACTION_StopServices( MSIPACKAGE *package )
5637 {
5638     UINT rc;
5639     MSIQUERY *view;
5640
5641     static const WCHAR query[] = {
5642         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5643         'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
5644
5645     rc = MSI_DatabaseOpenViewW(package->db, query, &view);
5646     if (rc != ERROR_SUCCESS)
5647         return ERROR_SUCCESS;
5648
5649     rc = MSI_IterateRecords(view, NULL, ITERATE_StopService, package);
5650     msiobj_release(&view->hdr);
5651
5652     return rc;
5653 }
5654
5655 static UINT ITERATE_DeleteService( MSIRECORD *rec, LPVOID param )
5656 {
5657     MSIPACKAGE *package = param;
5658     MSICOMPONENT *comp;
5659     MSIRECORD *uirow;
5660     LPCWSTR component;
5661     LPWSTR name = NULL, display_name = NULL;
5662     DWORD event, len;
5663     SC_HANDLE scm = NULL, service = NULL;
5664
5665     event = MSI_RecordGetInteger( rec, 3 );
5666     if (!(event & msidbServiceControlEventDelete))
5667         return ERROR_SUCCESS;
5668
5669     component = MSI_RecordGetString(rec, 6);
5670     comp = get_loaded_component(package, component);
5671     if (!comp)
5672         return ERROR_SUCCESS;
5673
5674     if (!comp->Enabled)
5675     {
5676         TRACE("component is disabled\n");
5677         return ERROR_SUCCESS;
5678     }
5679
5680     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
5681     {
5682         TRACE("Component not scheduled for removal: %s\n", debugstr_w(component));
5683         comp->Action = comp->Installed;
5684         return ERROR_SUCCESS;
5685     }
5686     comp->Action = INSTALLSTATE_ABSENT;
5687
5688     deformat_string( package, MSI_RecordGetString(rec, 2), &name );
5689     stop_service( name );
5690
5691     scm = OpenSCManagerW( NULL, NULL, SC_MANAGER_ALL_ACCESS );
5692     if (!scm)
5693     {
5694         WARN("Failed to open the SCM: %d\n", GetLastError());
5695         goto done;
5696     }
5697
5698     len = 0;
5699     if (!GetServiceDisplayNameW( scm, name, NULL, &len ) &&
5700         GetLastError() == ERROR_INSUFFICIENT_BUFFER)
5701     {
5702         if ((display_name = msi_alloc( ++len * sizeof(WCHAR ))))
5703             GetServiceDisplayNameW( scm, name, display_name, &len );
5704     }
5705
5706     service = OpenServiceW( scm, name, DELETE );
5707     if (!service)
5708     {
5709         WARN("Failed to open service (%s): %u\n", debugstr_w(name), GetLastError());
5710         goto done;
5711     }
5712
5713     if (!DeleteService( service ))
5714         WARN("Failed to delete service (%s): %u\n", debugstr_w(name), GetLastError());
5715
5716 done:
5717     uirow = MSI_CreateRecord( 2 );
5718     MSI_RecordSetStringW( uirow, 1, display_name );
5719     MSI_RecordSetStringW( uirow, 2, name );
5720     ui_actiondata( package, szDeleteServices, uirow );
5721     msiobj_release( &uirow->hdr );
5722
5723     CloseServiceHandle( service );
5724     CloseServiceHandle( scm );
5725     msi_free( name );
5726     msi_free( display_name );
5727
5728     return ERROR_SUCCESS;
5729 }
5730
5731 static UINT ACTION_DeleteServices( MSIPACKAGE *package )
5732 {
5733     UINT rc;
5734     MSIQUERY *view;
5735
5736     static const WCHAR query[] = {
5737         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5738         'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
5739
5740     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
5741     if (rc != ERROR_SUCCESS)
5742         return ERROR_SUCCESS;
5743
5744     rc = MSI_IterateRecords( view, NULL, ITERATE_DeleteService, package );
5745     msiobj_release( &view->hdr );
5746
5747     return rc;
5748 }
5749
5750 static MSIFILE *msi_find_file( MSIPACKAGE *package, LPCWSTR filename )
5751 {
5752     MSIFILE *file;
5753
5754     LIST_FOR_EACH_ENTRY(file, &package->files, MSIFILE, entry)
5755     {
5756         if (!lstrcmpW(file->File, filename))
5757             return file;
5758     }
5759
5760     return NULL;
5761 }
5762
5763 static UINT ITERATE_InstallODBCDriver( MSIRECORD *rec, LPVOID param )
5764 {
5765     MSIPACKAGE *package = param;
5766     LPWSTR driver, driver_path, ptr;
5767     WCHAR outpath[MAX_PATH];
5768     MSIFILE *driver_file, *setup_file;
5769     MSIRECORD *uirow;
5770     LPCWSTR desc;
5771     DWORD len, usage;
5772     UINT r = ERROR_SUCCESS;
5773
5774     static const WCHAR driver_fmt[] = {
5775         'D','r','i','v','e','r','=','%','s',0};
5776     static const WCHAR setup_fmt[] = {
5777         'S','e','t','u','p','=','%','s',0};
5778     static const WCHAR usage_fmt[] = {
5779         'F','i','l','e','U','s','a','g','e','=','1',0};
5780
5781     desc = MSI_RecordGetString(rec, 3);
5782
5783     driver_file = msi_find_file(package, MSI_RecordGetString(rec, 4));
5784     setup_file = msi_find_file(package, MSI_RecordGetString(rec, 5));
5785
5786     if (!driver_file)
5787     {
5788         ERR("ODBC Driver entry not found!\n");
5789         return ERROR_FUNCTION_FAILED;
5790     }
5791
5792     len = lstrlenW(desc) + lstrlenW(driver_fmt) + lstrlenW(driver_file->FileName);
5793     if (setup_file)
5794         len += lstrlenW(setup_fmt) + lstrlenW(setup_file->FileName);
5795     len += lstrlenW(usage_fmt) + 2; /* \0\0 */
5796
5797     driver = msi_alloc(len * sizeof(WCHAR));
5798     if (!driver)
5799         return ERROR_OUTOFMEMORY;
5800
5801     ptr = driver;
5802     lstrcpyW(ptr, desc);
5803     ptr += lstrlenW(ptr) + 1;
5804
5805     len = sprintfW(ptr, driver_fmt, driver_file->FileName);
5806     ptr += len + 1;
5807
5808     if (setup_file)
5809     {
5810         len = sprintfW(ptr, setup_fmt, setup_file->FileName);
5811         ptr += len + 1;
5812     }
5813
5814     lstrcpyW(ptr, usage_fmt);
5815     ptr += lstrlenW(ptr) + 1;
5816     *ptr = '\0';
5817
5818     driver_path = strdupW(driver_file->TargetPath);
5819     ptr = strrchrW(driver_path, '\\');
5820     if (ptr) *ptr = '\0';
5821
5822     if (!SQLInstallDriverExW(driver, driver_path, outpath, MAX_PATH,
5823                              NULL, ODBC_INSTALL_COMPLETE, &usage))
5824     {
5825         ERR("Failed to install SQL driver!\n");
5826         r = ERROR_FUNCTION_FAILED;
5827     }
5828
5829     uirow = MSI_CreateRecord( 5 );
5830     MSI_RecordSetStringW( uirow, 1, desc );
5831     MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
5832     MSI_RecordSetStringW( uirow, 3, driver_file->Component->Directory );
5833     ui_actiondata( package, szInstallODBC, uirow );
5834     msiobj_release( &uirow->hdr );
5835
5836     msi_free(driver);
5837     msi_free(driver_path);
5838
5839     return r;
5840 }
5841
5842 static UINT ITERATE_InstallODBCTranslator( MSIRECORD *rec, LPVOID param )
5843 {
5844     MSIPACKAGE *package = param;
5845     LPWSTR translator, translator_path, ptr;
5846     WCHAR outpath[MAX_PATH];
5847     MSIFILE *translator_file, *setup_file;
5848     MSIRECORD *uirow;
5849     LPCWSTR desc;
5850     DWORD len, usage;
5851     UINT r = ERROR_SUCCESS;
5852
5853     static const WCHAR translator_fmt[] = {
5854         'T','r','a','n','s','l','a','t','o','r','=','%','s',0};
5855     static const WCHAR setup_fmt[] = {
5856         'S','e','t','u','p','=','%','s',0};
5857
5858     desc = MSI_RecordGetString(rec, 3);
5859
5860     translator_file = msi_find_file(package, MSI_RecordGetString(rec, 4));
5861     setup_file = msi_find_file(package, MSI_RecordGetString(rec, 5));
5862
5863     if (!translator_file)
5864     {
5865         ERR("ODBC Translator entry not found!\n");
5866         return ERROR_FUNCTION_FAILED;
5867     }
5868
5869     len = lstrlenW(desc) + lstrlenW(translator_fmt) + lstrlenW(translator_file->FileName) + 2; /* \0\0 */
5870     if (setup_file)
5871         len += lstrlenW(setup_fmt) + lstrlenW(setup_file->FileName);
5872
5873     translator = msi_alloc(len * sizeof(WCHAR));
5874     if (!translator)
5875         return ERROR_OUTOFMEMORY;
5876
5877     ptr = translator;
5878     lstrcpyW(ptr, desc);
5879     ptr += lstrlenW(ptr) + 1;
5880
5881     len = sprintfW(ptr, translator_fmt, translator_file->FileName);
5882     ptr += len + 1;
5883
5884     if (setup_file)
5885     {
5886         len = sprintfW(ptr, setup_fmt, setup_file->FileName);
5887         ptr += len + 1;
5888     }
5889     *ptr = '\0';
5890
5891     translator_path = strdupW(translator_file->TargetPath);
5892     ptr = strrchrW(translator_path, '\\');
5893     if (ptr) *ptr = '\0';
5894
5895     if (!SQLInstallTranslatorExW(translator, translator_path, outpath, MAX_PATH,
5896                                  NULL, ODBC_INSTALL_COMPLETE, &usage))
5897     {
5898         ERR("Failed to install SQL translator!\n");
5899         r = ERROR_FUNCTION_FAILED;
5900     }
5901
5902     uirow = MSI_CreateRecord( 5 );
5903     MSI_RecordSetStringW( uirow, 1, desc );
5904     MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
5905     MSI_RecordSetStringW( uirow, 3, translator_file->Component->Directory );
5906     ui_actiondata( package, szInstallODBC, uirow );
5907     msiobj_release( &uirow->hdr );
5908
5909     msi_free(translator);
5910     msi_free(translator_path);
5911
5912     return r;
5913 }
5914
5915 static UINT ITERATE_InstallODBCDataSource( MSIRECORD *rec, LPVOID param )
5916 {
5917     MSIPACKAGE *package = param;
5918     LPWSTR attrs;
5919     LPCWSTR desc, driver;
5920     WORD request = ODBC_ADD_SYS_DSN;
5921     INT registration;
5922     DWORD len;
5923     UINT r = ERROR_SUCCESS;
5924     MSIRECORD *uirow;
5925
5926     static const WCHAR attrs_fmt[] = {
5927         'D','S','N','=','%','s',0 };
5928
5929     desc = MSI_RecordGetString(rec, 3);
5930     driver = MSI_RecordGetString(rec, 4);
5931     registration = MSI_RecordGetInteger(rec, 5);
5932
5933     if (registration == msidbODBCDataSourceRegistrationPerMachine) request = ODBC_ADD_SYS_DSN;
5934     else if (registration == msidbODBCDataSourceRegistrationPerUser) request = ODBC_ADD_DSN;
5935
5936     len = lstrlenW(attrs_fmt) + lstrlenW(desc) + 2; /* \0\0 */
5937     attrs = msi_alloc(len * sizeof(WCHAR));
5938     if (!attrs)
5939         return ERROR_OUTOFMEMORY;
5940
5941     len = sprintfW(attrs, attrs_fmt, desc);
5942     attrs[len + 1] = 0;
5943
5944     if (!SQLConfigDataSourceW(NULL, request, driver, attrs))
5945     {
5946         ERR("Failed to install SQL data source!\n");
5947         r = ERROR_FUNCTION_FAILED;
5948     }
5949
5950     uirow = MSI_CreateRecord( 5 );
5951     MSI_RecordSetStringW( uirow, 1, desc );
5952     MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
5953     MSI_RecordSetInteger( uirow, 3, request );
5954     ui_actiondata( package, szInstallODBC, uirow );
5955     msiobj_release( &uirow->hdr );
5956
5957     msi_free(attrs);
5958
5959     return r;
5960 }
5961
5962 static UINT ACTION_InstallODBC( MSIPACKAGE *package )
5963 {
5964     UINT rc;
5965     MSIQUERY *view;
5966
5967     static const WCHAR driver_query[] = {
5968         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5969         'O','D','B','C','D','r','i','v','e','r',0 };
5970
5971     static const WCHAR translator_query[] = {
5972         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5973         'O','D','B','C','T','r','a','n','s','l','a','t','o','r',0 };
5974
5975     static const WCHAR source_query[] = {
5976         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5977         'O','D','B','C','D','a','t','a','S','o','u','r','c','e',0 };
5978
5979     rc = MSI_DatabaseOpenViewW(package->db, driver_query, &view);
5980     if (rc != ERROR_SUCCESS)
5981         return ERROR_SUCCESS;
5982
5983     rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCDriver, package);
5984     msiobj_release(&view->hdr);
5985
5986     rc = MSI_DatabaseOpenViewW(package->db, translator_query, &view);
5987     if (rc != ERROR_SUCCESS)
5988         return ERROR_SUCCESS;
5989
5990     rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCTranslator, package);
5991     msiobj_release(&view->hdr);
5992
5993     rc = MSI_DatabaseOpenViewW(package->db, source_query, &view);
5994     if (rc != ERROR_SUCCESS)
5995         return ERROR_SUCCESS;
5996
5997     rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCDataSource, package);
5998     msiobj_release(&view->hdr);
5999
6000     return rc;
6001 }
6002
6003 static UINT ITERATE_RemoveODBCDriver( MSIRECORD *rec, LPVOID param )
6004 {
6005     MSIPACKAGE *package = param;
6006     MSIRECORD *uirow;
6007     DWORD usage;
6008     LPCWSTR desc;
6009
6010     desc = MSI_RecordGetString( rec, 3 );
6011     if (!SQLRemoveDriverW( desc, FALSE, &usage ))
6012     {
6013         WARN("Failed to remove ODBC driver\n");
6014     }
6015     else if (!usage)
6016     {
6017         FIXME("Usage count reached 0\n");
6018     }
6019
6020     uirow = MSI_CreateRecord( 2 );
6021     MSI_RecordSetStringW( uirow, 1, desc );
6022     MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6023     ui_actiondata( package, szRemoveODBC, uirow );
6024     msiobj_release( &uirow->hdr );
6025
6026     return ERROR_SUCCESS;
6027 }
6028
6029 static UINT ITERATE_RemoveODBCTranslator( MSIRECORD *rec, LPVOID param )
6030 {
6031     MSIPACKAGE *package = param;
6032     MSIRECORD *uirow;
6033     DWORD usage;
6034     LPCWSTR desc;
6035
6036     desc = MSI_RecordGetString( rec, 3 );
6037     if (!SQLRemoveTranslatorW( desc, &usage ))
6038     {
6039         WARN("Failed to remove ODBC translator\n");
6040     }
6041     else if (!usage)
6042     {
6043         FIXME("Usage count reached 0\n");
6044     }
6045
6046     uirow = MSI_CreateRecord( 2 );
6047     MSI_RecordSetStringW( uirow, 1, desc );
6048     MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6049     ui_actiondata( package, szRemoveODBC, uirow );
6050     msiobj_release( &uirow->hdr );
6051
6052     return ERROR_SUCCESS;
6053 }
6054
6055 static UINT ITERATE_RemoveODBCDataSource( MSIRECORD *rec, LPVOID param )
6056 {
6057     MSIPACKAGE *package = param;
6058     MSIRECORD *uirow;
6059     LPWSTR attrs;
6060     LPCWSTR desc, driver;
6061     WORD request = ODBC_REMOVE_SYS_DSN;
6062     INT registration;
6063     DWORD len;
6064
6065     static const WCHAR attrs_fmt[] = {
6066         'D','S','N','=','%','s',0 };
6067
6068     desc = MSI_RecordGetString( rec, 3 );
6069     driver = MSI_RecordGetString( rec, 4 );
6070     registration = MSI_RecordGetInteger( rec, 5 );
6071
6072     if (registration == msidbODBCDataSourceRegistrationPerMachine) request = ODBC_REMOVE_SYS_DSN;
6073     else if (registration == msidbODBCDataSourceRegistrationPerUser) request = ODBC_REMOVE_DSN;
6074
6075     len = strlenW( attrs_fmt ) + strlenW( desc ) + 2; /* \0\0 */
6076     attrs = msi_alloc( len * sizeof(WCHAR) );
6077     if (!attrs)
6078         return ERROR_OUTOFMEMORY;
6079
6080     FIXME("Use ODBCSourceAttribute table\n");
6081
6082     len = sprintfW( attrs, attrs_fmt, desc );
6083     attrs[len + 1] = 0;
6084
6085     if (!SQLConfigDataSourceW( NULL, request, driver, attrs ))
6086     {
6087         WARN("Failed to remove ODBC data source\n");
6088     }
6089     msi_free( attrs );
6090
6091     uirow = MSI_CreateRecord( 3 );
6092     MSI_RecordSetStringW( uirow, 1, desc );
6093     MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6094     MSI_RecordSetInteger( uirow, 3, request );
6095     ui_actiondata( package, szRemoveODBC, uirow );
6096     msiobj_release( &uirow->hdr );
6097
6098     return ERROR_SUCCESS;
6099 }
6100
6101 static UINT ACTION_RemoveODBC( MSIPACKAGE *package )
6102 {
6103     UINT rc;
6104     MSIQUERY *view;
6105
6106     static const WCHAR driver_query[] = {
6107         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6108         'O','D','B','C','D','r','i','v','e','r',0 };
6109
6110     static const WCHAR translator_query[] = {
6111         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6112         'O','D','B','C','T','r','a','n','s','l','a','t','o','r',0 };
6113
6114     static const WCHAR source_query[] = {
6115         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6116         'O','D','B','C','D','a','t','a','S','o','u','r','c','e',0 };
6117
6118     rc = MSI_DatabaseOpenViewW( package->db, driver_query, &view );
6119     if (rc != ERROR_SUCCESS)
6120         return ERROR_SUCCESS;
6121
6122     rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveODBCDriver, package );
6123     msiobj_release( &view->hdr );
6124
6125     rc = MSI_DatabaseOpenViewW( package->db, translator_query, &view );
6126     if (rc != ERROR_SUCCESS)
6127         return ERROR_SUCCESS;
6128
6129     rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveODBCTranslator, package );
6130     msiobj_release( &view->hdr );
6131
6132     rc = MSI_DatabaseOpenViewW( package->db, source_query, &view );
6133     if (rc != ERROR_SUCCESS)
6134         return ERROR_SUCCESS;
6135
6136     rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveODBCDataSource, package );
6137     msiobj_release( &view->hdr );
6138
6139     return rc;
6140 }
6141
6142 #define ENV_ACT_SETALWAYS   0x1
6143 #define ENV_ACT_SETABSENT   0x2
6144 #define ENV_ACT_REMOVE      0x4
6145 #define ENV_ACT_REMOVEMATCH 0x8
6146
6147 #define ENV_MOD_MACHINE     0x20000000
6148 #define ENV_MOD_APPEND      0x40000000
6149 #define ENV_MOD_PREFIX      0x80000000
6150 #define ENV_MOD_MASK        0xC0000000
6151
6152 #define check_flag_combo(x, y) ((x) & ~(y)) == (y)
6153
6154 static UINT env_parse_flags( LPCWSTR *name, LPCWSTR *value, DWORD *flags )
6155 {
6156     LPCWSTR cptr = *name;
6157
6158     static const WCHAR prefix[] = {'[','~',']',0};
6159     static const int prefix_len = 3;
6160
6161     *flags = 0;
6162     while (*cptr)
6163     {
6164         if (*cptr == '=')
6165             *flags |= ENV_ACT_SETALWAYS;
6166         else if (*cptr == '+')
6167             *flags |= ENV_ACT_SETABSENT;
6168         else if (*cptr == '-')
6169             *flags |= ENV_ACT_REMOVE;
6170         else if (*cptr == '!')
6171             *flags |= ENV_ACT_REMOVEMATCH;
6172         else if (*cptr == '*')
6173             *flags |= ENV_MOD_MACHINE;
6174         else
6175             break;
6176
6177         cptr++;
6178         (*name)++;
6179     }
6180
6181     if (!*cptr)
6182     {
6183         ERR("Missing environment variable\n");
6184         return ERROR_FUNCTION_FAILED;
6185     }
6186
6187     if (*value)
6188     {
6189         LPCWSTR ptr = *value;
6190         if (!strncmpW(ptr, prefix, prefix_len))
6191         {
6192             if (ptr[prefix_len] == szSemiColon[0])
6193             {
6194                 *flags |= ENV_MOD_APPEND;
6195                 *value += lstrlenW(prefix);
6196             }
6197             else
6198             {
6199                 *value = NULL;
6200             }
6201         }
6202         else if (lstrlenW(*value) >= prefix_len)
6203         {
6204             ptr += lstrlenW(ptr) - prefix_len;
6205             if (!lstrcmpW(ptr, prefix))
6206             {
6207                 if ((ptr-1) > *value && *(ptr-1) == szSemiColon[0])
6208                 {
6209                     *flags |= ENV_MOD_PREFIX;
6210                     /* the "[~]" will be removed by deformat_string */;
6211                 }
6212                 else
6213                 {
6214                     *value = NULL;
6215                 }
6216             }
6217         }
6218     }
6219
6220     if (check_flag_combo(*flags, ENV_ACT_SETALWAYS | ENV_ACT_SETABSENT) ||
6221         check_flag_combo(*flags, ENV_ACT_REMOVEMATCH | ENV_ACT_SETABSENT) ||
6222         check_flag_combo(*flags, ENV_ACT_REMOVEMATCH | ENV_ACT_SETALWAYS) ||
6223         check_flag_combo(*flags, ENV_ACT_SETABSENT | ENV_MOD_MASK))
6224     {
6225         ERR("Invalid flags: %08x\n", *flags);
6226         return ERROR_FUNCTION_FAILED;
6227     }
6228
6229     if (!*flags)
6230         *flags = ENV_ACT_SETALWAYS | ENV_ACT_REMOVE;
6231
6232     return ERROR_SUCCESS;
6233 }
6234
6235 static UINT open_env_key( DWORD flags, HKEY *key )
6236 {
6237     static const WCHAR user_env[] =
6238         {'E','n','v','i','r','o','n','m','e','n','t',0};
6239     static const WCHAR machine_env[] =
6240         {'S','y','s','t','e','m','\\',
6241          'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
6242          'C','o','n','t','r','o','l','\\',
6243          'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
6244          'E','n','v','i','r','o','n','m','e','n','t',0};
6245     const WCHAR *env;
6246     HKEY root;
6247     LONG res;
6248
6249     if (flags & ENV_MOD_MACHINE)
6250     {
6251         env = machine_env;
6252         root = HKEY_LOCAL_MACHINE;
6253     }
6254     else
6255     {
6256         env = user_env;
6257         root = HKEY_CURRENT_USER;
6258     }
6259
6260     res = RegOpenKeyExW( root, env, 0, KEY_ALL_ACCESS, key );
6261     if (res != ERROR_SUCCESS)
6262     {
6263         WARN("Failed to open key %s (%d)\n", debugstr_w(env), res);
6264         return ERROR_FUNCTION_FAILED;
6265     }
6266
6267     return ERROR_SUCCESS;
6268 }
6269
6270 static UINT ITERATE_WriteEnvironmentString( MSIRECORD *rec, LPVOID param )
6271 {
6272     MSIPACKAGE *package = param;
6273     LPCWSTR name, value, component;
6274     LPWSTR data = NULL, newval = NULL, deformatted = NULL, ptr;
6275     DWORD flags, type, size;
6276     UINT res;
6277     HKEY env = NULL;
6278     MSICOMPONENT *comp;
6279     MSIRECORD *uirow;
6280     int action = 0;
6281
6282     component = MSI_RecordGetString(rec, 4);
6283     comp = get_loaded_component(package, component);
6284     if (!comp)
6285         return ERROR_SUCCESS;
6286
6287     if (!comp->Enabled)
6288     {
6289         TRACE("component is disabled\n");
6290         return ERROR_SUCCESS;
6291     }
6292
6293     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
6294     {
6295         TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
6296         comp->Action = comp->Installed;
6297         return ERROR_SUCCESS;
6298     }
6299     comp->Action = INSTALLSTATE_LOCAL;
6300
6301     name = MSI_RecordGetString(rec, 2);
6302     value = MSI_RecordGetString(rec, 3);
6303
6304     TRACE("name %s value %s\n", debugstr_w(name), debugstr_w(value));
6305
6306     res = env_parse_flags(&name, &value, &flags);
6307     if (res != ERROR_SUCCESS || !value)
6308        goto done;
6309
6310     if (value && !deformat_string(package, value, &deformatted))
6311     {
6312         res = ERROR_OUTOFMEMORY;
6313         goto done;
6314     }
6315
6316     value = deformatted;
6317
6318     res = open_env_key( flags, &env );
6319     if (res != ERROR_SUCCESS)
6320         goto done;
6321
6322     if (flags & ENV_MOD_MACHINE)
6323         action |= 0x20000000;
6324
6325     size = 0;
6326     type = REG_SZ;
6327     res = RegQueryValueExW(env, name, NULL, &type, NULL, &size);
6328     if ((res != ERROR_SUCCESS && res != ERROR_FILE_NOT_FOUND) ||
6329         (res == ERROR_SUCCESS && type != REG_SZ && type != REG_EXPAND_SZ))
6330         goto done;
6331
6332     if ((res == ERROR_FILE_NOT_FOUND || !(flags & ENV_MOD_MASK)))
6333     {
6334         action = 0x2;
6335
6336         /* Nothing to do. */
6337         if (!value)
6338         {
6339             res = ERROR_SUCCESS;
6340             goto done;
6341         }
6342
6343         /* If we are appending but the string was empty, strip ; */
6344         if ((flags & ENV_MOD_APPEND) && (value[0] == szSemiColon[0])) value++;
6345
6346         size = (lstrlenW(value) + 1) * sizeof(WCHAR);
6347         newval = strdupW(value);
6348         if (!newval)
6349         {
6350             res = ERROR_OUTOFMEMORY;
6351             goto done;
6352         }
6353     }
6354     else
6355     {
6356         action = 0x1;
6357
6358         /* Contrary to MSDN, +-variable to [~];path works */
6359         if (flags & ENV_ACT_SETABSENT && !(flags & ENV_MOD_MASK))
6360         {
6361             res = ERROR_SUCCESS;
6362             goto done;
6363         }
6364
6365         data = msi_alloc(size);
6366         if (!data)
6367         {
6368             RegCloseKey(env);
6369             return ERROR_OUTOFMEMORY;
6370         }
6371
6372         res = RegQueryValueExW(env, name, NULL, &type, (LPVOID)data, &size);
6373         if (res != ERROR_SUCCESS)
6374             goto done;
6375
6376         if (flags & ENV_ACT_REMOVEMATCH && (!value || !lstrcmpW(data, value)))
6377         {
6378             action = 0x4;
6379             res = RegDeleteValueW(env, name);
6380             if (res != ERROR_SUCCESS)
6381                 WARN("Failed to remove value %s (%d)\n", debugstr_w(name), res);
6382             goto done;
6383         }
6384
6385         size = (lstrlenW(data) + 1) * sizeof(WCHAR);
6386         if (flags & ENV_MOD_MASK)
6387         {
6388             DWORD mod_size;
6389             int multiplier = 0;
6390             if (flags & ENV_MOD_APPEND) multiplier++;
6391             if (flags & ENV_MOD_PREFIX) multiplier++;
6392             mod_size = lstrlenW(value) * multiplier;
6393             size += mod_size * sizeof(WCHAR);
6394         }
6395
6396         newval = msi_alloc(size);
6397         ptr = newval;
6398         if (!newval)
6399         {
6400             res = ERROR_OUTOFMEMORY;
6401             goto done;
6402         }
6403
6404         if (flags & ENV_MOD_PREFIX)
6405         {
6406             lstrcpyW(newval, value);
6407             ptr = newval + lstrlenW(value);
6408             action |= 0x80000000;
6409         }
6410
6411         lstrcpyW(ptr, data);
6412
6413         if (flags & ENV_MOD_APPEND)
6414         {
6415             lstrcatW(newval, value);
6416             action |= 0x40000000;
6417         }
6418     }
6419     TRACE("setting %s to %s\n", debugstr_w(name), debugstr_w(newval));
6420     res = RegSetValueExW(env, name, 0, type, (LPVOID)newval, size);
6421     if (res)
6422     {
6423         WARN("Failed to set %s to %s (%d)\n",  debugstr_w(name), debugstr_w(newval), res);
6424     }
6425
6426 done:
6427     uirow = MSI_CreateRecord( 3 );
6428     MSI_RecordSetStringW( uirow, 1, name );
6429     MSI_RecordSetStringW( uirow, 2, newval );
6430     MSI_RecordSetInteger( uirow, 3, action );
6431     ui_actiondata( package, szWriteEnvironmentStrings, uirow );
6432     msiobj_release( &uirow->hdr );
6433
6434     if (env) RegCloseKey(env);
6435     msi_free(deformatted);
6436     msi_free(data);
6437     msi_free(newval);
6438     return res;
6439 }
6440
6441 static UINT ACTION_WriteEnvironmentStrings( MSIPACKAGE *package )
6442 {
6443     UINT rc;
6444     MSIQUERY * view;
6445     static const WCHAR ExecSeqQuery[] =
6446         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6447          '`','E','n','v','i','r','o','n','m','e','n','t','`',0};
6448     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
6449     if (rc != ERROR_SUCCESS)
6450         return ERROR_SUCCESS;
6451
6452     rc = MSI_IterateRecords(view, NULL, ITERATE_WriteEnvironmentString, package);
6453     msiobj_release(&view->hdr);
6454
6455     return rc;
6456 }
6457
6458 static UINT ITERATE_RemoveEnvironmentString( MSIRECORD *rec, LPVOID param )
6459 {
6460     MSIPACKAGE *package = param;
6461     LPCWSTR name, value, component;
6462     LPWSTR deformatted = NULL;
6463     DWORD flags;
6464     HKEY env;
6465     MSICOMPONENT *comp;
6466     MSIRECORD *uirow;
6467     int action = 0;
6468     LONG res;
6469     UINT r;
6470
6471     component = MSI_RecordGetString( rec, 4 );
6472     comp = get_loaded_component( package, component );
6473     if (!comp)
6474         return ERROR_SUCCESS;
6475
6476     if (!comp->Enabled)
6477     {
6478         TRACE("component is disabled\n");
6479         return ERROR_SUCCESS;
6480     }
6481
6482     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
6483     {
6484         TRACE("Component not scheduled for removal: %s\n", debugstr_w(component));
6485         comp->Action = comp->Installed;
6486         return ERROR_SUCCESS;
6487     }
6488     comp->Action = INSTALLSTATE_ABSENT;
6489
6490     name = MSI_RecordGetString( rec, 2 );
6491     value = MSI_RecordGetString( rec, 3 );
6492
6493     TRACE("name %s value %s\n", debugstr_w(name), debugstr_w(value));
6494
6495     r = env_parse_flags( &name, &value, &flags );
6496     if (r != ERROR_SUCCESS)
6497        return r;
6498
6499     if (!(flags & ENV_ACT_REMOVE))
6500     {
6501         TRACE("Environment variable %s not marked for removal\n", debugstr_w(name));
6502         return ERROR_SUCCESS;
6503     }
6504
6505     if (value && !deformat_string( package, value, &deformatted ))
6506         return ERROR_OUTOFMEMORY;
6507
6508     value = deformatted;
6509
6510     r = open_env_key( flags, &env );
6511     if (r != ERROR_SUCCESS)
6512     {
6513         r = ERROR_SUCCESS;
6514         goto done;
6515     }
6516
6517     if (flags & ENV_MOD_MACHINE)
6518         action |= 0x20000000;
6519
6520     TRACE("Removing %s\n", debugstr_w(name));
6521
6522     res = RegDeleteValueW( env, name );
6523     if (res != ERROR_SUCCESS)
6524     {
6525         WARN("Failed to delete value %s (%d)\n", debugstr_w(name), res);
6526         r = ERROR_SUCCESS;
6527     }
6528
6529 done:
6530     uirow = MSI_CreateRecord( 3 );
6531     MSI_RecordSetStringW( uirow, 1, name );
6532     MSI_RecordSetStringW( uirow, 2, value );
6533     MSI_RecordSetInteger( uirow, 3, action );
6534     ui_actiondata( package, szRemoveEnvironmentStrings, uirow );
6535     msiobj_release( &uirow->hdr );
6536
6537     if (env) RegCloseKey( env );
6538     msi_free( deformatted );
6539     return r;
6540 }
6541
6542 static UINT ACTION_RemoveEnvironmentStrings( MSIPACKAGE *package )
6543 {
6544     UINT rc;
6545     MSIQUERY *view;
6546     static const WCHAR query[] =
6547         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6548          '`','E','n','v','i','r','o','n','m','e','n','t','`',0};
6549
6550     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
6551     if (rc != ERROR_SUCCESS)
6552         return ERROR_SUCCESS;
6553
6554     rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveEnvironmentString, package );
6555     msiobj_release( &view->hdr );
6556
6557     return rc;
6558 }
6559
6560 typedef struct tagMSIASSEMBLY
6561 {
6562     struct list entry;
6563     MSICOMPONENT *component;
6564     MSIFEATURE *feature;
6565     MSIFILE *file;
6566     LPWSTR manifest;
6567     LPWSTR application;
6568     LPWSTR display_name;
6569     DWORD attributes;
6570     BOOL installed;
6571 } MSIASSEMBLY;
6572
6573 static HRESULT (WINAPI *pCreateAssemblyCache)(IAssemblyCache **ppAsmCache,
6574                                               DWORD dwReserved);
6575 static HRESULT (WINAPI *pLoadLibraryShim)(LPCWSTR szDllName, LPCWSTR szVersion,
6576                                           LPVOID pvReserved, HMODULE *phModDll);
6577
6578 static BOOL init_functionpointers(void)
6579 {
6580     HRESULT hr;
6581     HMODULE hfusion;
6582     HMODULE hmscoree;
6583
6584     static const WCHAR szFusion[] = {'f','u','s','i','o','n','.','d','l','l',0};
6585
6586     hmscoree = LoadLibraryA("mscoree.dll");
6587     if (!hmscoree)
6588     {
6589         WARN("mscoree.dll not available\n");
6590         return FALSE;
6591     }
6592
6593     pLoadLibraryShim = (void *)GetProcAddress(hmscoree, "LoadLibraryShim");
6594     if (!pLoadLibraryShim)
6595     {
6596         WARN("LoadLibraryShim not available\n");
6597         FreeLibrary(hmscoree);
6598         return FALSE;
6599     }
6600
6601     hr = pLoadLibraryShim(szFusion, NULL, NULL, &hfusion);
6602     if (FAILED(hr))
6603     {
6604         WARN("fusion.dll not available\n");
6605         FreeLibrary(hmscoree);
6606         return FALSE;
6607     }
6608
6609     pCreateAssemblyCache = (void *)GetProcAddress(hfusion, "CreateAssemblyCache");
6610
6611     FreeLibrary(hmscoree);
6612     return TRUE;
6613 }
6614
6615 static UINT install_assembly(MSIPACKAGE *package, MSIASSEMBLY *assembly,
6616                              LPWSTR path)
6617 {
6618     IAssemblyCache *cache;
6619     MSIRECORD *uirow;
6620     HRESULT hr;
6621     UINT r = ERROR_FUNCTION_FAILED;
6622
6623     TRACE("installing assembly: %s\n", debugstr_w(path));
6624
6625     uirow = MSI_CreateRecord( 2 );
6626     MSI_RecordSetStringW( uirow, 2, assembly->display_name );
6627     ui_actiondata( package, szMsiPublishAssemblies, uirow );
6628     msiobj_release( &uirow->hdr );
6629
6630     if (assembly->feature)
6631         msi_feature_set_state(package, assembly->feature, INSTALLSTATE_LOCAL);
6632
6633     if (assembly->manifest)
6634         FIXME("Manifest unhandled\n");
6635
6636     if (assembly->application)
6637     {
6638         FIXME("Assembly should be privately installed\n");
6639         return ERROR_SUCCESS;
6640     }
6641
6642     if (assembly->attributes == msidbAssemblyAttributesWin32)
6643     {
6644         FIXME("Win32 assemblies not handled\n");
6645         return ERROR_SUCCESS;
6646     }
6647
6648     hr = pCreateAssemblyCache(&cache, 0);
6649     if (FAILED(hr))
6650         goto done;
6651
6652     hr = IAssemblyCache_InstallAssembly(cache, 0, path, NULL);
6653     if (FAILED(hr))
6654         ERR("Failed to install assembly: %s %08x\n", debugstr_w(path), hr);
6655
6656     r = ERROR_SUCCESS;
6657
6658 done:
6659     IAssemblyCache_Release(cache);
6660     return r;
6661 }
6662
6663 typedef struct tagASSEMBLY_LIST
6664 {
6665     MSIPACKAGE *package;
6666     IAssemblyCache *cache;
6667     struct list *assemblies;
6668 } ASSEMBLY_LIST;
6669
6670 typedef struct tagASSEMBLY_NAME
6671 {
6672     LPWSTR name;
6673     LPWSTR version;
6674     LPWSTR culture;
6675     LPWSTR pubkeytoken;
6676 } ASSEMBLY_NAME;
6677
6678 static UINT parse_assembly_name(MSIRECORD *rec, LPVOID param)
6679 {
6680     ASSEMBLY_NAME *asmname = param;
6681     LPCWSTR name = MSI_RecordGetString(rec, 2);
6682     LPWSTR val = msi_dup_record_field(rec, 3);
6683
6684     static const WCHAR Name[] = {'N','a','m','e',0};
6685     static const WCHAR Version[] = {'V','e','r','s','i','o','n',0};
6686     static const WCHAR Culture[] = {'C','u','l','t','u','r','e',0};
6687     static const WCHAR PublicKeyToken[] = {
6688         'P','u','b','l','i','c','K','e','y','T','o','k','e','n',0};
6689
6690     if (!strcmpiW(name, Name))
6691         asmname->name = val;
6692     else if (!strcmpiW(name, Version))
6693         asmname->version = val;
6694     else if (!strcmpiW(name, Culture))
6695         asmname->culture = val;
6696     else if (!strcmpiW(name, PublicKeyToken))
6697         asmname->pubkeytoken = val;
6698     else
6699         msi_free(val);
6700
6701     return ERROR_SUCCESS;
6702 }
6703
6704 static void append_str(LPWSTR *str, DWORD *size, LPCWSTR append)
6705 {
6706     if (!*str)
6707     {
6708         *size = lstrlenW(append) + 1;
6709         *str = msi_alloc((*size) * sizeof(WCHAR));
6710         lstrcpyW(*str, append);
6711         return;
6712     }
6713
6714     (*size) += lstrlenW(append);
6715     *str = msi_realloc(*str, (*size) * sizeof(WCHAR));
6716     lstrcatW(*str, append);
6717 }
6718
6719 static WCHAR *get_assembly_display_name( MSIDATABASE *db, MSICOMPONENT *comp )
6720 {
6721     static const WCHAR separator[] = {',',' ',0};
6722     static const WCHAR Version[] = {'V','e','r','s','i','o','n','=',0};
6723     static const WCHAR Culture[] = {'C','u','l','t','u','r','e','=',0};
6724     static const WCHAR PublicKeyToken[] = {'P','u','b','l','i','c','K','e','y','T','o','k','e','n','=',0};
6725     static const WCHAR query[] = {
6726         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6727         '`','M','s','i','A','s','s','e','m','b','l','y','N','a','m','e','`',' ',
6728         'W','H','E','R','E',' ','`','C','o','m','p','o','n','e','n','t','_','`',
6729         '=','\'','%','s','\'',0};
6730     ASSEMBLY_NAME name;
6731     MSIQUERY *view;
6732     LPWSTR display_name;
6733     DWORD size;
6734     UINT r;
6735
6736     display_name = NULL;
6737     memset( &name, 0, sizeof(ASSEMBLY_NAME) );
6738
6739     r = MSI_OpenQuery( db, &view, query, comp->Component );
6740     if (r != ERROR_SUCCESS)
6741         return NULL;
6742
6743     MSI_IterateRecords( view, NULL, parse_assembly_name, &name );
6744     msiobj_release( &view->hdr );
6745
6746     if (!name.name)
6747     {
6748         ERR("No assembly name specified!\n");
6749         return NULL;
6750     }
6751
6752     append_str( &display_name, &size, name.name );
6753
6754     if (name.version)
6755     {
6756         append_str( &display_name, &size, separator );
6757         append_str( &display_name, &size, Version );
6758         append_str( &display_name, &size, name.version );
6759     }
6760     if (name.culture)
6761     {
6762         append_str( &display_name, &size, separator );
6763         append_str( &display_name, &size, Culture );
6764         append_str( &display_name, &size, name.culture );
6765     }
6766     if (name.pubkeytoken)
6767     {
6768         append_str( &display_name, &size, separator );
6769         append_str( &display_name, &size, PublicKeyToken );
6770         append_str( &display_name, &size, name.pubkeytoken );
6771     }
6772
6773     msi_free( name.name );
6774     msi_free( name.version );
6775     msi_free( name.culture );
6776     msi_free( name.pubkeytoken );
6777
6778     return display_name;
6779 }
6780
6781 static BOOL check_assembly_installed( MSIDATABASE *db, IAssemblyCache *cache, MSICOMPONENT *comp )
6782 {
6783     ASSEMBLY_INFO asminfo;
6784     LPWSTR disp;
6785     BOOL found = FALSE;
6786     HRESULT hr;
6787
6788     disp = get_assembly_display_name( db, comp );
6789     if (!disp)
6790         return FALSE;
6791
6792     memset( &asminfo, 0, sizeof(ASSEMBLY_INFO) );
6793     asminfo.cbAssemblyInfo = sizeof(ASSEMBLY_INFO);
6794
6795     hr = IAssemblyCache_QueryAssemblyInfo( cache, QUERYASMINFO_FLAG_VALIDATE, disp, &asminfo );
6796     if (SUCCEEDED(hr))
6797         found = (asminfo.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED);
6798
6799     msi_free( disp );
6800     return found;
6801 }
6802
6803 static UINT load_assembly(MSIRECORD *rec, LPVOID param)
6804 {
6805     ASSEMBLY_LIST *list = param;
6806     MSIASSEMBLY *assembly;
6807     LPCWSTR component;
6808
6809     assembly = msi_alloc_zero(sizeof(MSIASSEMBLY));
6810     if (!assembly)
6811         return ERROR_OUTOFMEMORY;
6812
6813     component = MSI_RecordGetString(rec, 1);
6814     assembly->component = get_loaded_component(list->package, component);
6815     if (!assembly->component)
6816         return ERROR_SUCCESS;
6817
6818     if (assembly->component->ActionRequest != INSTALLSTATE_LOCAL &&
6819         assembly->component->ActionRequest != INSTALLSTATE_SOURCE)
6820     {
6821         TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
6822         assembly->component->Action = assembly->component->Installed;
6823         return ERROR_SUCCESS;
6824     }
6825     assembly->component->Action = assembly->component->ActionRequest;
6826
6827     assembly->feature = find_feature_by_name(list->package, MSI_RecordGetString(rec, 2));
6828     assembly->file = msi_find_file(list->package, assembly->component->KeyPath);
6829
6830     if (!assembly->file)
6831     {
6832         ERR("File %s not found\n", debugstr_w(assembly->component->KeyPath));
6833         return ERROR_FUNCTION_FAILED;
6834     }
6835
6836     assembly->manifest = strdupW(MSI_RecordGetString(rec, 3));
6837     assembly->application = strdupW(MSI_RecordGetString(rec, 4));
6838     assembly->attributes = MSI_RecordGetInteger(rec, 5);
6839
6840     if (assembly->application)
6841     {
6842         WCHAR version[24];
6843         DWORD size = sizeof(version)/sizeof(WCHAR);
6844
6845         /* FIXME: we should probably check the manifest file here */
6846
6847         if (!MsiGetFileVersionW(assembly->file->TargetPath, version, &size, NULL, NULL) &&
6848             (!assembly->file->Version || strcmpW(version, assembly->file->Version) >= 0))
6849         {
6850             assembly->installed = TRUE;
6851         }
6852     }
6853     else
6854         assembly->installed = check_assembly_installed(list->package->db,
6855                                                        list->cache,
6856                                                        assembly->component);
6857
6858     list_add_head(list->assemblies, &assembly->entry);
6859     return ERROR_SUCCESS;
6860 }
6861
6862 static UINT load_assemblies(MSIPACKAGE *package, struct list *assemblies)
6863 {
6864     IAssemblyCache *cache = NULL;
6865     ASSEMBLY_LIST list;
6866     MSIQUERY *view;
6867     HRESULT hr;
6868     UINT r;
6869
6870     static const WCHAR query[] =
6871         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6872          '`','M','s','i','A','s','s','e','m','b','l','y','`',0};
6873
6874     r = MSI_DatabaseOpenViewW(package->db, query, &view);
6875     if (r != ERROR_SUCCESS)
6876         return ERROR_SUCCESS;
6877
6878     hr = pCreateAssemblyCache(&cache, 0);
6879     if (FAILED(hr))
6880         return ERROR_FUNCTION_FAILED;
6881
6882     list.package = package;
6883     list.cache = cache;
6884     list.assemblies = assemblies;
6885
6886     r = MSI_IterateRecords(view, NULL, load_assembly, &list);
6887     msiobj_release(&view->hdr);
6888
6889     IAssemblyCache_Release(cache);
6890
6891     return r;
6892 }
6893
6894 static void free_assemblies(struct list *assemblies)
6895 {
6896     struct list *item, *cursor;
6897
6898     LIST_FOR_EACH_SAFE(item, cursor, assemblies)
6899     {
6900         MSIASSEMBLY *assembly = LIST_ENTRY(item, MSIASSEMBLY, entry);
6901
6902         list_remove(&assembly->entry);
6903         msi_free(assembly->application);
6904         msi_free(assembly->manifest);
6905         msi_free(assembly->display_name);
6906         msi_free(assembly);
6907     }
6908 }
6909
6910 static BOOL find_assembly(struct list *assemblies, LPCWSTR file, MSIASSEMBLY **out)
6911 {
6912     MSIASSEMBLY *assembly;
6913
6914     LIST_FOR_EACH_ENTRY(assembly, assemblies, MSIASSEMBLY, entry)
6915     {
6916         if (!lstrcmpW(assembly->file->File, file))
6917         {
6918             *out = assembly;
6919             return TRUE;
6920         }
6921     }
6922
6923     return FALSE;
6924 }
6925
6926 static BOOL installassembly_cb(MSIPACKAGE *package, LPCWSTR file, DWORD action,
6927                                LPWSTR *path, DWORD *attrs, PVOID user)
6928 {
6929     MSIASSEMBLY *assembly;
6930     WCHAR temppath[MAX_PATH];
6931     struct list *assemblies = user;
6932     UINT r;
6933
6934     if (!find_assembly(assemblies, file, &assembly))
6935         return FALSE;
6936
6937     GetTempPathW(MAX_PATH, temppath);
6938     PathAddBackslashW(temppath);
6939     lstrcatW(temppath, assembly->file->FileName);
6940
6941     if (action == MSICABEXTRACT_BEGINEXTRACT)
6942     {
6943         if (assembly->installed)
6944             return FALSE;
6945
6946         *path = strdupW(temppath);
6947         *attrs = assembly->file->Attributes;
6948     }
6949     else if (action == MSICABEXTRACT_FILEEXTRACTED)
6950     {
6951         assembly->installed = TRUE;
6952
6953         r = install_assembly(package, assembly, temppath);
6954         if (r != ERROR_SUCCESS)
6955             ERR("Failed to install assembly\n");
6956     }
6957
6958     return TRUE;
6959 }
6960
6961 static UINT ACTION_MsiPublishAssemblies( MSIPACKAGE *package )
6962 {
6963     UINT r;
6964     struct list assemblies = LIST_INIT(assemblies);
6965     MSIASSEMBLY *assembly;
6966     MSIMEDIAINFO *mi;
6967
6968     if (!init_functionpointers() || !pCreateAssemblyCache)
6969         return ERROR_FUNCTION_FAILED;
6970
6971     r = load_assemblies(package, &assemblies);
6972     if (r != ERROR_SUCCESS)
6973         goto done;
6974
6975     if (list_empty(&assemblies))
6976         goto done;
6977
6978     mi = msi_alloc_zero(sizeof(MSIMEDIAINFO));
6979     if (!mi)
6980     {
6981         r = ERROR_OUTOFMEMORY;
6982         goto done;
6983     }
6984
6985     LIST_FOR_EACH_ENTRY(assembly, &assemblies, MSIASSEMBLY, entry)
6986     {
6987         if (assembly->installed && !mi->is_continuous)
6988             continue;
6989
6990         if (assembly->file->IsCompressed)
6991         {
6992             if (assembly->file->disk_id != mi->disk_id || mi->is_continuous)
6993             {
6994                 MSICABDATA data;
6995
6996                 r = ready_media(package, assembly->file, mi);
6997                 if (r != ERROR_SUCCESS)
6998                 {
6999                     ERR("Failed to ready media\n");
7000                     break;
7001                 }
7002
7003                 data.mi = mi;
7004                 data.package = package;
7005                 data.cb = installassembly_cb;
7006                 data.user = &assemblies;
7007
7008                 if (!msi_cabextract(package, mi, &data))
7009                 {
7010                     ERR("Failed to extract cabinet: %s\n", debugstr_w(mi->cabinet));
7011                     r = ERROR_FUNCTION_FAILED;
7012                     break;
7013                 }
7014             }
7015         }
7016         else
7017         {
7018             LPWSTR source = resolve_file_source(package, assembly->file);
7019
7020             r = install_assembly(package, assembly, source);
7021             if (r != ERROR_SUCCESS)
7022                 ERR("Failed to install assembly\n");
7023
7024             msi_free(source);
7025         }
7026
7027         /* FIXME: write Installer assembly reg values */
7028     }
7029
7030 done:
7031     free_assemblies(&assemblies);
7032     return r;
7033 }
7034
7035 static UINT ACTION_ValidateProductID( MSIPACKAGE *package )
7036 {
7037     LPWSTR key, template, id;
7038     UINT r = ERROR_SUCCESS;
7039
7040     id = msi_dup_property( package->db, szProductID );
7041     if (id)
7042     {
7043         msi_free( id );
7044         return ERROR_SUCCESS;
7045     }
7046     template = msi_dup_property( package->db, szPIDTemplate );
7047     key = msi_dup_property( package->db, szPIDKEY );
7048
7049     if (key && template)
7050     {
7051         FIXME( "partial stub: template %s key %s\n", debugstr_w(template), debugstr_w(key) );
7052         r = msi_set_property( package->db, szProductID, key );
7053     }
7054     msi_free( template );
7055     msi_free( key );
7056     return r;
7057 }
7058
7059 static UINT ACTION_ScheduleReboot( MSIPACKAGE *package )
7060 {
7061     TRACE("\n");
7062     package->need_reboot = 1;
7063     return ERROR_SUCCESS;
7064 }
7065
7066 static UINT ACTION_AllocateRegistrySpace( MSIPACKAGE *package )
7067 {
7068     static const WCHAR szAvailableFreeReg[] =
7069         {'A','V','A','I','L','A','B','L','E','F','R','E','E','R','E','G',0};
7070     MSIRECORD *uirow;
7071     int space = msi_get_property_int( package->db, szAvailableFreeReg, 0 );
7072
7073     TRACE("%p %d kilobytes\n", package, space);
7074
7075     uirow = MSI_CreateRecord( 1 );
7076     MSI_RecordSetInteger( uirow, 1, space );
7077     ui_actiondata( package, szAllocateRegistrySpace, uirow );
7078     msiobj_release( &uirow->hdr );
7079
7080     return ERROR_SUCCESS;
7081 }
7082
7083 static UINT ACTION_DisableRollback( MSIPACKAGE *package )
7084 {
7085     FIXME("%p\n", package);
7086     return ERROR_SUCCESS;
7087 }
7088
7089 static UINT ACTION_InstallAdminPackage( MSIPACKAGE *package )
7090 {
7091     FIXME("%p\n", package);
7092     return ERROR_SUCCESS;
7093 }
7094
7095 static UINT ACTION_SetODBCFolders( MSIPACKAGE *package )
7096 {
7097     UINT r, count;
7098     MSIQUERY *view;
7099
7100     static const WCHAR driver_query[] = {
7101         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
7102         'O','D','B','C','D','r','i','v','e','r',0 };
7103
7104     static const WCHAR translator_query[] = {
7105         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
7106         'O','D','B','C','T','r','a','n','s','l','a','t','o','r',0 };
7107
7108     r = MSI_DatabaseOpenViewW( package->db, driver_query, &view );
7109     if (r == ERROR_SUCCESS)
7110     {
7111         count = 0;
7112         r = MSI_IterateRecords( view, &count, NULL, package );
7113         msiobj_release( &view->hdr );
7114         if (count) FIXME("ignored %u rows in ODBCDriver table\n", count);
7115     }
7116
7117     r = MSI_DatabaseOpenViewW( package->db, translator_query, &view );
7118     if (r == ERROR_SUCCESS)
7119     {
7120         count = 0;
7121         r = MSI_IterateRecords( view, &count, NULL, package );
7122         msiobj_release( &view->hdr );
7123         if (count) FIXME("ignored %u rows in ODBCTranslator table\n", count);
7124     }
7125
7126     return ERROR_SUCCESS;
7127 }
7128
7129 static UINT msi_unimplemented_action_stub( MSIPACKAGE *package,
7130                                            LPCSTR action, LPCWSTR table )
7131 {
7132     static const WCHAR query[] = {
7133         'S','E','L','E','C','T',' ','*',' ',
7134         'F','R','O','M',' ','`','%','s','`',0 };
7135     MSIQUERY *view = NULL;
7136     DWORD count = 0;
7137     UINT r;
7138
7139     r = MSI_OpenQuery( package->db, &view, query, table );
7140     if (r == ERROR_SUCCESS)
7141     {
7142         r = MSI_IterateRecords(view, &count, NULL, package);
7143         msiobj_release(&view->hdr);
7144     }
7145
7146     if (count)
7147         FIXME("%s -> %u ignored %s table values\n",
7148               action, count, debugstr_w(table));
7149
7150     return ERROR_SUCCESS;
7151 }
7152
7153 static UINT ACTION_PatchFiles( MSIPACKAGE *package )
7154 {
7155     static const WCHAR table[] = { 'P','a','t','c','h',0 };
7156     return msi_unimplemented_action_stub( package, "PatchFiles", table );
7157 }
7158
7159 static UINT ACTION_BindImage( MSIPACKAGE *package )
7160 {
7161     static const WCHAR table[] = { 'B','i','n','d','I','m','a','g','e',0 };
7162     return msi_unimplemented_action_stub( package, "BindImage", table );
7163 }
7164
7165 static UINT ACTION_IsolateComponents( MSIPACKAGE *package )
7166 {
7167     static const WCHAR table[] = {
7168         'I','s','o','l','a','t','e','d','C','o','m','p','o','n','e','n','t',0 };
7169     return msi_unimplemented_action_stub( package, "IsolateComponents", table );
7170 }
7171
7172 static UINT ACTION_MigrateFeatureStates( MSIPACKAGE *package )
7173 {
7174     static const WCHAR table[] = { 'U','p','g','r','a','d','e',0 };
7175     return msi_unimplemented_action_stub( package, "MigrateFeatureStates", table );
7176 }
7177
7178 static UINT ACTION_MsiUnpublishAssemblies( MSIPACKAGE *package )
7179 {
7180     static const WCHAR table[] = {
7181         'M','s','i','A','s','s','e','m','b','l','y',0 };
7182     return msi_unimplemented_action_stub( package, "MsiUnpublishAssemblies", table );
7183 }
7184
7185 static UINT ACTION_RMCCPSearch( MSIPACKAGE *package )
7186 {
7187     static const WCHAR table[] = { 'C','C','P','S','e','a','r','c','h',0 };
7188     return msi_unimplemented_action_stub( package, "RMCCPSearch", table );
7189 }
7190
7191 static UINT ACTION_RegisterComPlus( MSIPACKAGE *package )
7192 {
7193     static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
7194     return msi_unimplemented_action_stub( package, "RegisterComPlus", table );
7195 }
7196
7197 static UINT ACTION_UnregisterComPlus( MSIPACKAGE *package )
7198 {
7199     static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
7200     return msi_unimplemented_action_stub( package, "UnregisterComPlus", table );
7201 }
7202
7203 static UINT ACTION_InstallSFPCatalogFile( MSIPACKAGE *package )
7204 {
7205     static const WCHAR table[] = { 'S','F','P','C','a','t','a','l','o','g',0 };
7206     return msi_unimplemented_action_stub( package, "InstallSFPCatalogFile", table );
7207 }
7208
7209 static UINT ACTION_RemoveExistingProducts( MSIPACKAGE *package )
7210 {
7211     static const WCHAR table[] = { 'U','p','g','r','a','d','e',0 };
7212     return msi_unimplemented_action_stub( package, "RemoveExistingProducts", table );
7213 }
7214
7215 typedef UINT (*STANDARDACTIONHANDLER)(MSIPACKAGE*);
7216
7217 static const struct
7218 {
7219     const WCHAR *action;
7220     UINT (*handler)(MSIPACKAGE *);
7221 }
7222 StandardActions[] =
7223 {
7224     { szAllocateRegistrySpace, ACTION_AllocateRegistrySpace },
7225     { szAppSearch, ACTION_AppSearch },
7226     { szBindImage, ACTION_BindImage },
7227     { szCCPSearch, ACTION_CCPSearch },
7228     { szCostFinalize, ACTION_CostFinalize },
7229     { szCostInitialize, ACTION_CostInitialize },
7230     { szCreateFolders, ACTION_CreateFolders },
7231     { szCreateShortcuts, ACTION_CreateShortcuts },
7232     { szDeleteServices, ACTION_DeleteServices },
7233     { szDisableRollback, ACTION_DisableRollback },
7234     { szDuplicateFiles, ACTION_DuplicateFiles },
7235     { szExecuteAction, ACTION_ExecuteAction },
7236     { szFileCost, ACTION_FileCost },
7237     { szFindRelatedProducts, ACTION_FindRelatedProducts },
7238     { szForceReboot, ACTION_ForceReboot },
7239     { szInstallAdminPackage, ACTION_InstallAdminPackage },
7240     { szInstallExecute, ACTION_InstallExecute },
7241     { szInstallExecuteAgain, ACTION_InstallExecute },
7242     { szInstallFiles, ACTION_InstallFiles},
7243     { szInstallFinalize, ACTION_InstallFinalize },
7244     { szInstallInitialize, ACTION_InstallInitialize },
7245     { szInstallSFPCatalogFile, ACTION_InstallSFPCatalogFile },
7246     { szInstallValidate, ACTION_InstallValidate },
7247     { szIsolateComponents, ACTION_IsolateComponents },
7248     { szLaunchConditions, ACTION_LaunchConditions },
7249     { szMigrateFeatureStates, ACTION_MigrateFeatureStates },
7250     { szMoveFiles, ACTION_MoveFiles },
7251     { szMsiPublishAssemblies, ACTION_MsiPublishAssemblies },
7252     { szMsiUnpublishAssemblies, ACTION_MsiUnpublishAssemblies },
7253     { szInstallODBC, ACTION_InstallODBC },
7254     { szInstallServices, ACTION_InstallServices },
7255     { szPatchFiles, ACTION_PatchFiles },
7256     { szProcessComponents, ACTION_ProcessComponents },
7257     { szPublishComponents, ACTION_PublishComponents },
7258     { szPublishFeatures, ACTION_PublishFeatures },
7259     { szPublishProduct, ACTION_PublishProduct },
7260     { szRegisterClassInfo, ACTION_RegisterClassInfo },
7261     { szRegisterComPlus, ACTION_RegisterComPlus},
7262     { szRegisterExtensionInfo, ACTION_RegisterExtensionInfo },
7263     { szRegisterFonts, ACTION_RegisterFonts },
7264     { szRegisterMIMEInfo, ACTION_RegisterMIMEInfo },
7265     { szRegisterProduct, ACTION_RegisterProduct },
7266     { szRegisterProgIdInfo, ACTION_RegisterProgIdInfo },
7267     { szRegisterTypeLibraries, ACTION_RegisterTypeLibraries },
7268     { szRegisterUser, ACTION_RegisterUser },
7269     { szRemoveDuplicateFiles, ACTION_RemoveDuplicateFiles },
7270     { szRemoveEnvironmentStrings, ACTION_RemoveEnvironmentStrings },
7271     { szRemoveExistingProducts, ACTION_RemoveExistingProducts },
7272     { szRemoveFiles, ACTION_RemoveFiles },
7273     { szRemoveFolders, ACTION_RemoveFolders },
7274     { szRemoveIniValues, ACTION_RemoveIniValues },
7275     { szRemoveODBC, ACTION_RemoveODBC },
7276     { szRemoveRegistryValues, ACTION_RemoveRegistryValues },
7277     { szRemoveShortcuts, ACTION_RemoveShortcuts },
7278     { szResolveSource, ACTION_ResolveSource },
7279     { szRMCCPSearch, ACTION_RMCCPSearch },
7280     { szScheduleReboot, ACTION_ScheduleReboot },
7281     { szSelfRegModules, ACTION_SelfRegModules },
7282     { szSelfUnregModules, ACTION_SelfUnregModules },
7283     { szSetODBCFolders, ACTION_SetODBCFolders },
7284     { szStartServices, ACTION_StartServices },
7285     { szStopServices, ACTION_StopServices },
7286     { szUnpublishComponents, ACTION_UnpublishComponents },
7287     { szUnpublishFeatures, ACTION_UnpublishFeatures },
7288     { szUnregisterClassInfo, ACTION_UnregisterClassInfo },
7289     { szUnregisterComPlus, ACTION_UnregisterComPlus },
7290     { szUnregisterExtensionInfo, ACTION_UnregisterExtensionInfo },
7291     { szUnregisterFonts, ACTION_UnregisterFonts },
7292     { szUnregisterMIMEInfo, ACTION_UnregisterMIMEInfo },
7293     { szUnregisterProgIdInfo, ACTION_UnregisterProgIdInfo },
7294     { szUnregisterTypeLibraries, ACTION_UnregisterTypeLibraries },
7295     { szValidateProductID, ACTION_ValidateProductID },
7296     { szWriteEnvironmentStrings, ACTION_WriteEnvironmentStrings },
7297     { szWriteIniValues, ACTION_WriteIniValues },
7298     { szWriteRegistryValues, ACTION_WriteRegistryValues },
7299     { NULL, NULL },
7300 };
7301
7302 static BOOL ACTION_HandleStandardAction( MSIPACKAGE *package, LPCWSTR action, UINT *rc )
7303 {
7304     BOOL ret = FALSE;
7305     UINT i;
7306
7307     i = 0;
7308     while (StandardActions[i].action != NULL)
7309     {
7310         if (!strcmpW( StandardActions[i].action, action ))
7311         {
7312             ui_actionstart( package, action );
7313             if (StandardActions[i].handler)
7314             {
7315                 ui_actioninfo( package, action, TRUE, 0 );
7316                 *rc = StandardActions[i].handler( package );
7317                 ui_actioninfo( package, action, FALSE, *rc );
7318             }
7319             else
7320             {
7321                 FIXME("unhandled standard action %s\n", debugstr_w(action));
7322                 *rc = ERROR_SUCCESS;
7323             }
7324             ret = TRUE;
7325             break;
7326         }
7327         i++;
7328     }
7329     return ret;
7330 }
7331
7332 UINT ACTION_PerformAction(MSIPACKAGE *package, const WCHAR *action, UINT script)
7333 {
7334     UINT rc = ERROR_SUCCESS;
7335     BOOL handled;
7336
7337     TRACE("Performing action (%s)\n", debugstr_w(action));
7338
7339     handled = ACTION_HandleStandardAction(package, action, &rc);
7340
7341     if (!handled)
7342         handled = ACTION_HandleCustomAction(package, action, &rc, script, TRUE);
7343
7344     if (!handled)
7345     {
7346         WARN("unhandled msi action %s\n", debugstr_w(action));
7347         rc = ERROR_FUNCTION_NOT_CALLED;
7348     }
7349
7350     return rc;
7351 }
7352
7353 UINT ACTION_PerformUIAction(MSIPACKAGE *package, const WCHAR *action, UINT script)
7354 {
7355     UINT rc = ERROR_SUCCESS;
7356     BOOL handled = FALSE;
7357
7358     TRACE("Performing action (%s)\n", debugstr_w(action));
7359
7360     handled = ACTION_HandleStandardAction(package, action, &rc);
7361
7362     if (!handled)
7363         handled = ACTION_HandleCustomAction(package, action, &rc, script, FALSE);
7364
7365     if( !handled && ACTION_DialogBox(package, action) == ERROR_SUCCESS )
7366         handled = TRUE;
7367
7368     if (!handled)
7369     {
7370         WARN("unhandled msi action %s\n", debugstr_w(action));
7371         rc = ERROR_FUNCTION_NOT_CALLED;
7372     }
7373
7374     return rc;
7375 }
7376
7377 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq)
7378 {
7379     UINT rc = ERROR_SUCCESS;
7380     MSIRECORD *row;
7381
7382     static const WCHAR ExecSeqQuery[] =
7383         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
7384          '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
7385          'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
7386          '`','S','e','q','u','e','n','c','e','`',' ', '=',' ','%','i',0};
7387     static const WCHAR UISeqQuery[] =
7388         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
7389      '`','I','n','s','t','a','l','l','U','I','S','e','q','u','e','n','c','e',
7390      '`', ' ', 'W','H','E','R','E',' ','`','S','e','q','u','e','n','c','e','`',
7391          ' ', '=',' ','%','i',0};
7392
7393     if (needs_ui_sequence(package))
7394         row = MSI_QueryGetRecord(package->db, UISeqQuery, seq);
7395     else
7396         row = MSI_QueryGetRecord(package->db, ExecSeqQuery, seq);
7397
7398     if (row)
7399     {
7400         LPCWSTR action, cond;
7401
7402         TRACE("Running the actions\n");
7403
7404         /* check conditions */
7405         cond = MSI_RecordGetString(row, 2);
7406
7407         /* this is a hack to skip errors in the condition code */
7408         if (MSI_EvaluateConditionW(package, cond) == MSICONDITION_FALSE)
7409         {
7410             msiobj_release(&row->hdr);
7411             return ERROR_SUCCESS;
7412         }
7413
7414         action = MSI_RecordGetString(row, 1);
7415         if (!action)
7416         {
7417             ERR("failed to fetch action\n");
7418             msiobj_release(&row->hdr);
7419             return ERROR_FUNCTION_FAILED;
7420         }
7421
7422         if (needs_ui_sequence(package))
7423             rc = ACTION_PerformUIAction(package, action, -1);
7424         else
7425             rc = ACTION_PerformAction(package, action, -1);
7426
7427         msiobj_release(&row->hdr);
7428     }
7429
7430     return rc;
7431 }
7432
7433 /****************************************************
7434  * TOP level entry points
7435  *****************************************************/
7436
7437 UINT MSI_InstallPackage( MSIPACKAGE *package, LPCWSTR szPackagePath,
7438                          LPCWSTR szCommandLine )
7439 {
7440     UINT rc;
7441     BOOL ui_exists;
7442
7443     static const WCHAR szAction[] = {'A','C','T','I','O','N',0};
7444     static const WCHAR szInstall[] = {'I','N','S','T','A','L','L',0};
7445
7446     msi_set_property( package->db, szAction, szInstall );
7447
7448     package->script->InWhatSequence = SEQUENCE_INSTALL;
7449
7450     if (szPackagePath)
7451     {
7452         LPWSTR p, dir;
7453         LPCWSTR file;
7454
7455         dir = strdupW(szPackagePath);
7456         p = strrchrW(dir, '\\');
7457         if (p)
7458         {
7459             *(++p) = 0;
7460             file = szPackagePath + (p - dir);
7461         }
7462         else
7463         {
7464             msi_free(dir);
7465             dir = msi_alloc(MAX_PATH * sizeof(WCHAR));
7466             GetCurrentDirectoryW(MAX_PATH, dir);
7467             lstrcatW(dir, szBackSlash);
7468             file = szPackagePath;
7469         }
7470
7471         msi_free( package->PackagePath );
7472         package->PackagePath = msi_alloc((lstrlenW(dir) + lstrlenW(file) + 1) * sizeof(WCHAR));
7473         if (!package->PackagePath)
7474         {
7475             msi_free(dir);
7476             return ERROR_OUTOFMEMORY;
7477         }
7478
7479         lstrcpyW(package->PackagePath, dir);
7480         lstrcatW(package->PackagePath, file);
7481         msi_free(dir);
7482
7483         msi_set_sourcedir_props(package, FALSE);
7484     }
7485
7486     msi_parse_command_line( package, szCommandLine, FALSE );
7487
7488     msi_apply_transforms( package );
7489     msi_apply_patches( package );
7490
7491     if (!szCommandLine && msi_get_property_int( package->db, szInstalled, 0 ))
7492     {
7493         TRACE("setting reinstall property\n");
7494         msi_set_property( package->db, szReinstall, szAll );
7495     }
7496
7497     /* properties may have been added by a transform */
7498     msi_clone_properties( package );
7499
7500     msi_parse_command_line( package, szCommandLine, FALSE );
7501     msi_adjust_allusers_property( package );
7502     msi_set_context( package );
7503
7504     if (needs_ui_sequence( package))
7505     {
7506         package->script->InWhatSequence |= SEQUENCE_UI;
7507         rc = ACTION_ProcessUISequence(package);
7508         ui_exists = ui_sequence_exists(package);
7509         if (rc == ERROR_SUCCESS || !ui_exists)
7510         {
7511             package->script->InWhatSequence |= SEQUENCE_EXEC;
7512             rc = ACTION_ProcessExecSequence(package, ui_exists);
7513         }
7514     }
7515     else
7516         rc = ACTION_ProcessExecSequence(package, FALSE);
7517
7518     package->script->CurrentlyScripting = FALSE;
7519
7520     /* process the ending type action */
7521     if (rc == ERROR_SUCCESS)
7522         ACTION_PerformActionSequence(package, -1);
7523     else if (rc == ERROR_INSTALL_USEREXIT)
7524         ACTION_PerformActionSequence(package, -2);
7525     else if (rc == ERROR_INSTALL_SUSPEND)
7526         ACTION_PerformActionSequence(package, -4);
7527     else  /* failed */
7528         ACTION_PerformActionSequence(package, -3);
7529
7530     /* finish up running custom actions */
7531     ACTION_FinishCustomActions(package);
7532
7533     if (rc == ERROR_SUCCESS && package->need_reboot)
7534         return ERROR_SUCCESS_REBOOT_REQUIRED;
7535
7536     return rc;
7537 }