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