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 /*
  22  * Pages I need
  23  *
  24 http://msdn.microsoft.com/library/default.asp?url=/library/en-us/msi/setup/installexecutesequence_table.asp
  25
  26 http://msdn.microsoft.com/library/default.asp?url=/library/en-us/msi/setup/standard_actions_reference.asp
  27  */
  28
  29 #include <stdarg.h>
  30
  31 #define COBJMACROS
  32
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "winerror.h"
  36 #include "winreg.h"
  37 #include "wine/debug.h"
  38 #include "msidefs.h"
  39 #include "msipriv.h"
  40 #include "winuser.h"
  41 #include "shlobj.h"
  42 #include "wine/unicode.h"
  43 #include "winver.h"
  44 #include "action.h"
  45
  46 #define REG_PROGRESS_VALUE 13200
  47 #define COMPONENT_PROGRESS_VALUE 24000
  48
  49 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  50
  51 /*
  52  * Prototypes
  53  */
  54 static UINT ACTION_ProcessExecSequence(MSIPACKAGE *package, BOOL UIran);
  55 static UINT ACTION_ProcessUISequence(MSIPACKAGE *package);
  56 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq, BOOL UI);
  57
  58 /*
  59  * consts and values used
  60  */
  61 static const WCHAR c_colon[] = {'C',':','\\',0};
  62
  63 static const WCHAR szCreateFolders[] =
  64     {'C','r','e','a','t','e','F','o','l','d','e','r','s',0};
  65 static const WCHAR szCostFinalize[] =
  66     {'C','o','s','t','F','i','n','a','l','i','z','e',0};
  67 const WCHAR szInstallFiles[] =
  68     {'I','n','s','t','a','l','l','F','i','l','e','s',0};
  69 const WCHAR szDuplicateFiles[] =
  70     {'D','u','p','l','i','c','a','t','e','F','i','l','e','s',0};
  71 static const WCHAR szWriteRegistryValues[] =
  72     {'W','r','i','t','e','R','e','g','i','s','t','r','y',
  73             'V','a','l','u','e','s',0};
  74 static const WCHAR szCostInitialize[] =
  75     {'C','o','s','t','I','n','i','t','i','a','l','i','z','e',0};
  76 static const WCHAR szFileCost[] =
  77     {'F','i','l','e','C','o','s','t',0};
  78 static const WCHAR szInstallInitialize[] =
  79     {'I','n','s','t','a','l','l','I','n','i','t','i','a','l','i','z','e',0};
  80 static const WCHAR szInstallValidate[] =
  81     {'I','n','s','t','a','l','l','V','a','l','i','d','a','t','e',0};
  82 static const WCHAR szLaunchConditions[] =
  83     {'L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','s',0};
  84 static const WCHAR szProcessComponents[] =
  85     {'P','r','o','c','e','s','s','C','o','m','p','o','n','e','n','t','s',0};
  86 static const WCHAR szRegisterTypeLibraries[] =
  87     {'R','e','g','i','s','t','e','r','T','y','p','e',
  88             'L','i','b','r','a','r','i','e','s',0};
  89 const WCHAR szRegisterClassInfo[] =
  90     {'R','e','g','i','s','t','e','r','C','l','a','s','s','I','n','f','o',0};
  91 const WCHAR szRegisterProgIdInfo[] =
  92     {'R','e','g','i','s','t','e','r','P','r','o','g','I','d','I','n','f','o',0};
  93 static const WCHAR szCreateShortcuts[] =
  94     {'C','r','e','a','t','e','S','h','o','r','t','c','u','t','s',0};
  95 static const WCHAR szPublishProduct[] =
  96     {'P','u','b','l','i','s','h','P','r','o','d','u','c','t',0};
  97 static const WCHAR szWriteIniValues[] =
  98     {'W','r','i','t','e','I','n','i','V','a','l','u','e','s',0};
  99 static const WCHAR szSelfRegModules[] =
 100     {'S','e','l','f','R','e','g','M','o','d','u','l','e','s',0};
 101 static const WCHAR szPublishFeatures[] =
 102     {'P','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
 103 static const WCHAR szRegisterProduct[] =
 104     {'R','e','g','i','s','t','e','r','P','r','o','d','u','c','t',0};
 105 static const WCHAR szInstallExecute[] =
 106     {'I','n','s','t','a','l','l','E','x','e','c','u','t','e',0};
 107 static const WCHAR szInstallExecuteAgain[] =
 108     {'I','n','s','t','a','l','l','E','x','e','c','u','t','e',
 109             'A','g','a','i','n',0};
 110 static const WCHAR szInstallFinalize[] =
 111     {'I','n','s','t','a','l','l','F','i','n','a','l','i','z','e',0};
 112 static const WCHAR szForceReboot[] =
 113     {'F','o','r','c','e','R','e','b','o','o','t',0};
 114 static const WCHAR szResolveSource[] =
 115     {'R','e','s','o','l','v','e','S','o','u','r','c','e',0};
 116 static const WCHAR szAppSearch[] =
 117     {'A','p','p','S','e','a','r','c','h',0};
 118 static const WCHAR szAllocateRegistrySpace[] =
 119     {'A','l','l','o','c','a','t','e','R','e','g','i','s','t','r','y',
 120             'S','p','a','c','e',0};
 121 static const WCHAR szBindImage[] =
 122     {'B','i','n','d','I','m','a','g','e',0};
 123 static const WCHAR szCCPSearch[] =
 124     {'C','C','P','S','e','a','r','c','h',0};
 125 static const WCHAR szDeleteServices[] =
 126     {'D','e','l','e','t','e','S','e','r','v','i','c','e','s',0};
 127 static const WCHAR szDisableRollback[] =
 128     {'D','i','s','a','b','l','e','R','o','l','l','b','a','c','k',0};
 129 static const WCHAR szExecuteAction[] =
 130     {'E','x','e','c','u','t','e','A','c','t','i','o','n',0};
 131 const WCHAR szFindRelatedProducts[] =
 132     {'F','i','n','d','R','e','l','a','t','e','d',
 133             'P','r','o','d','u','c','t','s',0};
 134 static const WCHAR szInstallAdminPackage[] =
 135     {'I','n','s','t','a','l','l','A','d','m','i','n',
 136             'P','a','c','k','a','g','e',0};
 137 static const WCHAR szInstallSFPCatalogFile[] =
 138     {'I','n','s','t','a','l','l','S','F','P','C','a','t','a','l','o','g',
 139             'F','i','l','e',0};
 140 static const WCHAR szIsolateComponents[] =
 141     {'I','s','o','l','a','t','e','C','o','m','p','o','n','e','n','t','s',0};
 142 const WCHAR szMigrateFeatureStates[] =
 143     {'M','i','g','r','a','t','e','F','e','a','t','u','r','e',
 144             'S','t','a','t','e','s',0};
 145 const WCHAR szMoveFiles[] =
 146     {'M','o','v','e','F','i','l','e','s',0};
 147 static const WCHAR szMsiPublishAssemblies[] =
 148     {'M','s','i','P','u','b','l','i','s','h',
 149             'A','s','s','e','m','b','l','i','e','s',0};
 150 static const WCHAR szMsiUnpublishAssemblies[] =
 151     {'M','s','i','U','n','p','u','b','l','i','s','h',
 152             'A','s','s','e','m','b','l','i','e','s',0};
 153 static const WCHAR szInstallODBC[] =
 154     {'I','n','s','t','a','l','l','O','D','B','C',0};
 155 static const WCHAR szInstallServices[] =
 156     {'I','n','s','t','a','l','l','S','e','r','v','i','c','e','s',0};
 157 const WCHAR szPatchFiles[] =
 158     {'P','a','t','c','h','F','i','l','e','s',0};
 159 static const WCHAR szPublishComponents[] =
 160     {'P','u','b','l','i','s','h','C','o','m','p','o','n','e','n','t','s',0};
 161 static const WCHAR szRegisterComPlus[] =
 162     {'R','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
 163 const WCHAR szRegisterExtensionInfo[] =
 164     {'R','e','g','i','s','t','e','r','E','x','t','e','n','s','i','o','n',
 165             'I','n','f','o',0};
 166 static const WCHAR szRegisterFonts[] =
 167     {'R','e','g','i','s','t','e','r','F','o','n','t','s',0};
 168 const WCHAR szRegisterMIMEInfo[] =
 169     {'R','e','g','i','s','t','e','r','M','I','M','E','I','n','f','o',0};
 170 static const WCHAR szRegisterUser[] =
 171     {'R','e','g','i','s','t','e','r','U','s','e','r',0};
 172 const WCHAR szRemoveDuplicateFiles[] =
 173     {'R','e','m','o','v','e','D','u','p','l','i','c','a','t','e',
 174             'F','i','l','e','s',0};
 175 static const WCHAR szRemoveEnvironmentStrings[] =
 176     {'R','e','m','o','v','e','E','n','v','i','r','o','n','m','e','n','t',
 177             'S','t','r','i','n','g','s',0};
 178 const WCHAR szRemoveExistingProducts[] =
 179     {'R','e','m','o','v','e','E','x','i','s','t','i','n','g',
 180             'P','r','o','d','u','c','t','s',0};
 181 const WCHAR szRemoveFiles[] =
 182     {'R','e','m','o','v','e','F','i','l','e','s',0};
 183 static const WCHAR szRemoveFolders[] =
 184     {'R','e','m','o','v','e','F','o','l','d','e','r','s',0};
 185 static const WCHAR szRemoveIniValues[] =
 186     {'R','e','m','o','v','e','I','n','i','V','a','l','u','e','s',0};
 187 static const WCHAR szRemoveODBC[] =
 188     {'R','e','m','o','v','e','O','D','B','C',0};
 189 static const WCHAR szRemoveRegistryValues[] =
 190     {'R','e','m','o','v','e','R','e','g','i','s','t','r','y',
 191             'V','a','l','u','e','s',0};
 192 static const WCHAR szRemoveShortcuts[] =
 193     {'R','e','m','o','v','e','S','h','o','r','t','c','u','t','s',0};
 194 static const WCHAR szRMCCPSearch[] =
 195     {'R','M','C','C','P','S','e','a','r','c','h',0};
 196 static const WCHAR szScheduleReboot[] =
 197     {'S','c','h','e','d','u','l','e','R','e','b','o','o','t',0};
 198 static const WCHAR szSelfUnregModules[] =
 199     {'S','e','l','f','U','n','r','e','g','M','o','d','u','l','e','s',0};
 200 static const WCHAR szSetODBCFolders[] =
 201     {'S','e','t','O','D','B','C','F','o','l','d','e','r','s',0};
 202 static const WCHAR szStartServices[] =
 203     {'S','t','a','r','t','S','e','r','v','i','c','e','s',0};
 204 static const WCHAR szStopServices[] =
 205     {'S','t','o','p','S','e','r','v','i','c','e','s',0};
 206 static const WCHAR szUnpublishComponents[] =
 207     {'U','n','p','u','b','l','i','s','h',
 208             'C','o','m','p','o','n','e','n','t','s',0};
 209 static const WCHAR szUnpublishFeatures[] =
 210     {'U','n','p','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
 211 const WCHAR szUnregisterClassInfo[] =
 212     {'U','n','r','e','g','i','s','t','e','r','C','l','a','s','s',
 213             'I','n','f','o',0};
 214 static const WCHAR szUnregisterComPlus[] =
 215     {'U','n','r','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
 216 const WCHAR szUnregisterExtensionInfo[] =
 217     {'U','n','r','e','g','i','s','t','e','r',
 218             'E','x','t','e','n','s','i','o','n','I','n','f','o',0};
 219 static const WCHAR szUnregisterFonts[] =
 220     {'U','n','r','e','g','i','s','t','e','r','F','o','n','t','s',0};
 221 const WCHAR szUnregisterMIMEInfo[] =
 222     {'U','n','r','e','g','i','s','t','e','r','M','I','M','E','I','n','f','o',0};
 223 const WCHAR szUnregisterProgIdInfo[] =
 224     {'U','n','r','e','g','i','s','t','e','r','P','r','o','g','I','d',
 225             'I','n','f','o',0};
 226 static const WCHAR szUnregisterTypeLibraries[] =
 227     {'U','n','r','e','g','i','s','t','e','r','T','y','p','e',
 228             'L','i','b','r','a','r','i','e','s',0};
 229 static const WCHAR szValidateProductID[] =
 230     {'V','a','l','i','d','a','t','e','P','r','o','d','u','c','t','I','D',0};
 231 static const WCHAR szWriteEnvironmentStrings[] =
 232     {'W','r','i','t','e','E','n','v','i','r','o','n','m','e','n','t',
 233             'S','t','r','i','n','g','s',0};
 234
 235 /* action handlers */
 236 typedef UINT (*STANDARDACTIONHANDLER)(MSIPACKAGE*);
 237
 238 struct _actions {
 239     LPCWSTR action;
 240     STANDARDACTIONHANDLER handler;
 241 };
 242
 243 static struct _actions StandardActions[];
 244
 245
 246 /********************************************************
 247  * helper functions
 248  ********************************************************/
 249
 250 static void ui_actionstart(MSIPACKAGE *package, LPCWSTR action)
 251 {
 252     static const WCHAR Query_t[] =
 253         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 254          '`','A','c','t','i','o', 'n','T','e','x','t','`',' ',
 255          'W','H','E','R','E', ' ','`','A','c','t','i','o','n','`',' ','=',
 256          ' ','\'','%','s','\'',0};
 257     MSIRECORD * row;
 258
 259     row = MSI_QueryGetRecord( package->db, Query_t, action );
 260     if (!row)
 261         return;
 262     MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONSTART, row);
 263     msiobj_release(&row->hdr);
 264 }
 265
 266 static void ui_actioninfo(MSIPACKAGE *package, LPCWSTR action, BOOL start,
 267                           UINT rc)
 268 {
 269     MSIRECORD * row;
 270     static const WCHAR template_s[]=
 271         {'A','c','t','i','o','n',' ','s','t','a','r','t',' ','%','s',':',' ',
 272          '%','s', '.',0};
 273     static const WCHAR template_e[]=
 274         {'A','c','t','i','o','n',' ','e','n','d','e','d',' ','%','s',':',' ',
 275          '%','s', '.',' ','R','e','t','u','r','n',' ','v','a','l','u','e',' ',
 276          '%','i','.',0};
 277     static const WCHAR format[] =
 278         {'H','H','\'',':','\'','m','m','\'',':','\'','s','s',0};
 279     WCHAR message[1024];
 280     WCHAR timet[0x100];
 281
 282     GetTimeFormatW(LOCALE_USER_DEFAULT, 0, NULL, format, timet, 0x100);
 283     if (start)
 284         sprintfW(message,template_s,timet,action);
 285     else
 286         sprintfW(message,template_e,timet,action,rc);
 287
 288     row = MSI_CreateRecord(1);
 289     MSI_RecordSetStringW(row,1,message);
 290
 291     MSI_ProcessMessage(package, INSTALLMESSAGE_INFO, row);
 292     msiobj_release(&row->hdr);
 293 }
 294
 295 static UINT msi_parse_command_line( MSIPACKAGE *package, LPCWSTR szCommandLine )
 296 {
 297     LPCWSTR ptr,ptr2;
 298     BOOL quote;
 299     DWORD len;
 300     LPWSTR prop = NULL, val = NULL;
 301
 302     if (!szCommandLine)
 303         return ERROR_SUCCESS;
 304
 305     ptr = szCommandLine;
 306
 307     while (*ptr)
 308     {
 309         if (*ptr==' ')
 310         {
 311             ptr++;
 312             continue;
 313         }
 314
 315         TRACE("Looking at %s\n",debugstr_w(ptr));
 316
 317         ptr2 = strchrW(ptr,'=');
 318         if (!ptr2)
 319         {
 320             ERR("command line contains unknown string : %s\n", debugstr_w(ptr));
 321             break;
 322         }
 323
 324         quote = FALSE;
 325
 326         len = ptr2-ptr;
 327         prop = msi_alloc((len+1)*sizeof(WCHAR));
 328         memcpy(prop,ptr,len*sizeof(WCHAR));
 329         prop[len]=0;
 330         ptr2++;
 331
 332         len = 0;
 333         ptr = ptr2;
 334         while (*ptr && (quote || (!quote && *ptr!=' ')))
 335         {
 336             if (*ptr == '"')
 337                 quote = !quote;
 338             ptr++;
 339             len++;
 340         }
 341
 342         if (*ptr2=='"')
 343         {
 344             ptr2++;
 345             len -= 2;
 346         }
 347         val = msi_alloc((len+1)*sizeof(WCHAR));
 348         memcpy(val,ptr2,len*sizeof(WCHAR));
 349         val[len] = 0;
 350
 351         if (lstrlenW(prop) > 0)
 352         {
 353             TRACE("Found commandline property (%s) = (%s)\n",
 354                    debugstr_w(prop), debugstr_w(val));
 355             MSI_SetPropertyW(package,prop,val);
 356         }
 357         msi_free(val);
 358         msi_free(prop);
 359     }
 360
 361     return ERROR_SUCCESS;
 362 }
 363
 364
 365 static LPWSTR* msi_split_string( LPCWSTR str, WCHAR sep )
 366 {
 367     LPWSTR p, *ret = NULL;
 368     UINT count = 0;
 369
 370     if (!str)
 371         return ret;
 372
 373     /* count the number of substrings */
 374     for ( p = (LPWSTR)str, count = 0; p; count++ )
 375     {
 376         p = strchrW( p, sep );
 377         if (p)
 378             p++;
 379     }
 380
 381     /* allocate space for an array of substring pointers and the substrings */
 382     ret = msi_alloc( (count+1) * sizeof (LPWSTR) +
 383                      (lstrlenW(str)+1) * sizeof(WCHAR) );
 384     if (!ret)
 385         return ret;
 386
 387     /* copy the string and set the pointers */
 388     p = (LPWSTR) &ret[count+1];
 389     lstrcpyW( p, str );
 390     for( count = 0; (ret[count] = p); count++ )
 391     {
 392         p = strchrW( p, sep );
 393         if (p)
 394             *p++ = 0;
 395     }
 396
 397     return ret;
 398 }
 399
 400 static UINT msi_apply_substorage_transform( MSIPACKAGE *package,
 401                                  MSIDATABASE *patch_db, LPCWSTR name )
 402 {
 403     UINT ret = ERROR_FUNCTION_FAILED;
 404     IStorage *stg = NULL;
 405     HRESULT r;
 406
 407     TRACE("%p %s\n", package, debugstr_w(name) );
 408
 409     if (*name++ != ':')
 410     {
 411         ERR("expected a colon in %s\n", debugstr_w(name));
 412         return ERROR_FUNCTION_FAILED;
 413     }
 414
 415     r = IStorage_OpenStorage( patch_db->storage, name, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &stg );
 416     if (SUCCEEDED(r))
 417     {
 418         ret = msi_table_apply_transform( package->db, stg );
 419         IStorage_Release( stg );
 420         ret = ERROR_SUCCESS;
 421     }
 422     else
 423         ERR("failed to open substorage %s\n", debugstr_w(name));
 424
 425     return ret;
 426 }
 427
 428 static UINT msi_check_patch_applicable( MSIPACKAGE *package, MSISUMMARYINFO *si )
 429 {
 430     static const WCHAR szProdID[] = { 'P','r','o','d','u','c','t','I','D',0 };
 431     LPWSTR guid_list, *guids, product_id;
 432     UINT i, ret = ERROR_FUNCTION_FAILED;
 433
 434     product_id = msi_dup_property( package, szProdID );
 435     if (!product_id)
 436     {
 437         /* FIXME: the property ProductID should be written into the DB somewhere */
 438         ERR("no product ID to check\n");
 439         return ERROR_SUCCESS;
 440     }
 441
 442     guid_list = msi_suminfo_dup_string( si, PID_TEMPLATE );
 443     guids = msi_split_string( guid_list, ';' );
 444     for ( i = 0; guids[i] && ret != ERROR_SUCCESS; i++ )
 445     {
 446         if (!lstrcmpW( guids[i], product_id ))
 447             ret = ERROR_SUCCESS;
 448     }
 449     msi_free( guids );
 450     msi_free( guid_list );
 451     msi_free( product_id );
 452
 453     return ret;
 454 }
 455
 456 static UINT msi_parse_patch_summary( MSIPACKAGE *package, MSIDATABASE *patch_db )
 457 {
 458     MSISUMMARYINFO *si;
 459     LPWSTR str, *substorage;
 460     UINT i, r = ERROR_SUCCESS;
 461
 462     si = MSI_GetSummaryInformationW( patch_db, 0 );
 463     if (!si)
 464         return ERROR_FUNCTION_FAILED;
 465
 466     msi_check_patch_applicable( package, si );
 467
 468     /* enumerate the substorage */
 469     str = msi_suminfo_dup_string( si, PID_LASTAUTHOR );
 470     substorage = msi_split_string( str, ';' );
 471     for ( i = 0; substorage && substorage[i] && r == ERROR_SUCCESS; i++ )
 472         r = msi_apply_substorage_transform( package, patch_db, substorage[i] );
 473     msi_free( substorage );
 474     msi_free( str );
 475
 476     /* FIXME: parse the sources in PID_REVNUMBER and do something with them... */
 477
 478     msiobj_release( &si->hdr );
 479
 480     return r;
 481 }
 482
 483 static UINT msi_apply_patch_package( MSIPACKAGE *package, LPCWSTR file )
 484 {
 485     MSIDATABASE *patch_db = NULL;
 486     UINT r;
 487
 488     TRACE("%p %s\n", package, debugstr_w( file ) );
 489
 490     /* FIXME:
 491      *  We probably want to make sure we only open a patch collection here.
 492      *  Patch collections (.msp) and databases (.msi) have different GUIDs
 493      *  but currently MSI_OpenDatabaseW will accept both.
 494      */
 495     r = MSI_OpenDatabaseW( file, MSIDBOPEN_READONLY, &patch_db );
 496     if ( r != ERROR_SUCCESS )
 497     {
 498         ERR("failed to open patch collection %s\n", debugstr_w( file ) );
 499         return r;
 500     }
 501
 502     msi_parse_patch_summary( package, patch_db );
 503     msiobj_release( &patch_db->hdr );
 504
 505     return ERROR_SUCCESS;
 506 }
 507
 508 /* get the PATCH property, and apply all the patches it specifies */
 509 static UINT msi_apply_patches( MSIPACKAGE *package )
 510 {
 511     static const WCHAR szPatch[] = { 'P','A','T','C','H',0 };
 512     LPWSTR patch_list, *patches;
 513     UINT i, r = ERROR_SUCCESS;
 514
 515     patch_list = msi_dup_property( package, szPatch );
 516
 517     TRACE("patches to be applied: %s\n", debugstr_w( patch_list ) );
 518
 519     patches = msi_split_string( patch_list, ';' );
 520     for( i=0; patches && patches[i] && r == ERROR_SUCCESS; i++ )
 521         r = msi_apply_patch_package( package, patches[i] );
 522
 523     msi_free( patches );
 524     msi_free( patch_list );
 525
 526     return r;
 527 }
 528
 529 static UINT msi_apply_transforms( MSIPACKAGE *package )
 530 {
 531     static const WCHAR szTransforms[] = {
 532         'T','R','A','N','S','F','O','R','M','S',0 };
 533     LPWSTR xform_list, *xforms;
 534     UINT i, r = ERROR_SUCCESS;
 535
 536     xform_list = msi_dup_property( package, szTransforms );
 537     xforms = msi_split_string( xform_list, ';' );
 538
 539     for( i=0; xforms && xforms[i] && r == ERROR_SUCCESS; i++ )
 540     {
 541         if (xforms[i][0] == ':')
 542             r = msi_apply_substorage_transform( package, package->db, &xforms[i][1] );
 543         else
 544             r = MSI_DatabaseApplyTransformW( package->db, xforms[i], 0 );
 545     }
 546
 547     msi_free( xforms );
 548     msi_free( xform_list );
 549
 550     return r;
 551 }
 552
 553 /****************************************************
 554  * TOP level entry points
 555  *****************************************************/
 556
 557 UINT MSI_InstallPackage( MSIPACKAGE *package, LPCWSTR szPackagePath,
 558                          LPCWSTR szCommandLine )
 559 {
 560     UINT rc;
 561     BOOL ui = FALSE;
 562     static const WCHAR szUILevel[] = {'U','I','L','e','v','e','l',0};
 563     static const WCHAR szAction[] = {'A','C','T','I','O','N',0};
 564     static const WCHAR szInstall[] = {'I','N','S','T','A','L','L',0};
 565
 566     MSI_SetPropertyW(package, szAction, szInstall);
 567
 568     package->script = msi_alloc_zero(sizeof(MSISCRIPT));
 569
 570     package->script->InWhatSequence = SEQUENCE_INSTALL;
 571
 572     if (szPackagePath)
 573     {
 574         LPWSTR p, check, path;
 575
 576         package->PackagePath = strdupW(szPackagePath);
 577         path = strdupW(szPackagePath);
 578         p = strrchrW(path,'\\');
 579         if (p)
 580         {
 581             p++;
 582             *p=0;
 583         }
 584         else
 585         {
 586             msi_free(path);
 587             path = msi_alloc(MAX_PATH*sizeof(WCHAR));
 588             GetCurrentDirectoryW(MAX_PATH,path);
 589             strcatW(path,cszbs);
 590         }
 591
 592         check = msi_dup_property( package, cszSourceDir );
 593         if (!check)
 594             MSI_SetPropertyW(package, cszSourceDir, path);
 595         msi_free(check);
 596         msi_free(path);
 597     }
 598
 599     msi_parse_command_line( package, szCommandLine );
 600
 601     msi_apply_transforms( package );
 602     msi_apply_patches( package );
 603
 604     if ( msi_get_property_int(package, szUILevel, 0) >= INSTALLUILEVEL_REDUCED )
 605     {
 606         package->script->InWhatSequence |= SEQUENCE_UI;
 607         rc = ACTION_ProcessUISequence(package);
 608         ui = TRUE;
 609         if (rc == ERROR_SUCCESS)
 610         {
 611             package->script->InWhatSequence |= SEQUENCE_EXEC;
 612             rc = ACTION_ProcessExecSequence(package,TRUE);
 613         }
 614     }
 615     else
 616         rc = ACTION_ProcessExecSequence(package,FALSE);
 617
 618     if (rc == -1)
 619     {
 620         /* install was halted but should be considered a success */
 621         rc = ERROR_SUCCESS;
 622     }
 623
 624     package->script->CurrentlyScripting= FALSE;
 625
 626     /* process the ending type action */
 627     if (rc == ERROR_SUCCESS)
 628         ACTION_PerformActionSequence(package,-1,ui);
 629     else if (rc == ERROR_INSTALL_USEREXIT)
 630         ACTION_PerformActionSequence(package,-2,ui);
 631     else if (rc == ERROR_INSTALL_SUSPEND)
 632         ACTION_PerformActionSequence(package,-4,ui);
 633     else  /* failed */
 634         ACTION_PerformActionSequence(package,-3,ui);
 635
 636     /* finish up running custom actions */
 637     ACTION_FinishCustomActions(package);
 638
 639     return rc;
 640 }
 641
 642 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq, BOOL UI)
 643 {
 644     UINT rc = ERROR_SUCCESS;
 645     MSIRECORD * row = 0;
 646     static const WCHAR ExecSeqQuery[] =
 647         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 648          '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
 649          'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
 650          '`','S','e','q','u','e','n','c','e','`',' ', '=',' ','%','i',0};
 651
 652     static const WCHAR UISeqQuery[] =
 653         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 654      '`','I','n','s','t','a','l','l','U','I','S','e','q','u','e','n','c','e',
 655      '`', ' ', 'W','H','E','R','E',' ','`','S','e','q','u','e','n','c','e','`',
 656          ' ', '=',' ','%','i',0};
 657
 658     if (UI)
 659         row = MSI_QueryGetRecord(package->db, UISeqQuery, seq);
 660     else
 661         row = MSI_QueryGetRecord(package->db, ExecSeqQuery, seq);
 662
 663     if (row)
 664     {
 665         LPCWSTR action, cond;
 666
 667         TRACE("Running the actions\n");
 668
 669         /* check conditions */
 670         cond = MSI_RecordGetString(row,2);
 671         if (cond)
 672         {
 673             /* this is a hack to skip errors in the condition code */
 674             if (MSI_EvaluateConditionW(package, cond) == MSICONDITION_FALSE)
 675                 goto end;
 676         }
 677
 678         action = MSI_RecordGetString(row,1);
 679         if (!action)
 680         {
 681             ERR("failed to fetch action\n");
 682             rc = ERROR_FUNCTION_FAILED;
 683             goto end;
 684         }
 685
 686         if (UI)
 687             rc = ACTION_PerformUIAction(package,action);
 688         else
 689             rc = ACTION_PerformAction(package,action,FALSE);
 690 end:
 691         msiobj_release(&row->hdr);
 692     }
 693     else
 694         rc = ERROR_SUCCESS;
 695
 696     return rc;
 697 }
 698
 699 typedef struct {
 700     MSIPACKAGE* package;
 701     BOOL UI;
 702 } iterate_action_param;
 703
 704 static UINT ITERATE_Actions(MSIRECORD *row, LPVOID param)
 705 {
 706     iterate_action_param *iap= (iterate_action_param*)param;
 707     UINT rc;
 708     LPCWSTR cond, action;
 709
 710     action = MSI_RecordGetString(row,1);
 711     if (!action)
 712     {
 713         ERR("Error is retrieving action name\n");
 714         return  ERROR_FUNCTION_FAILED;
 715     }
 716
 717     /* check conditions */
 718     cond = MSI_RecordGetString(row,2);
 719     if (cond)
 720     {
 721         /* this is a hack to skip errors in the condition code */
 722         if (MSI_EvaluateConditionW(iap->package, cond) == MSICONDITION_FALSE)
 723         {
 724             TRACE("Skipping action: %s (condition is false)\n",
 725                             debugstr_w(action));
 726             return ERROR_SUCCESS;
 727         }
 728     }
 729
 730     if (iap->UI)
 731         rc = ACTION_PerformUIAction(iap->package,action);
 732     else
 733         rc = ACTION_PerformAction(iap->package,action,FALSE);
 734
 735     msi_dialog_check_messages( NULL );
 736
 737     if (iap->package->CurrentInstallState != ERROR_SUCCESS )
 738         rc = iap->package->CurrentInstallState;
 739
 740     if (rc == ERROR_FUNCTION_NOT_CALLED)
 741         rc = ERROR_SUCCESS;
 742
 743     if (rc != ERROR_SUCCESS)
 744         ERR("Execution halted, action %s returned %i\n", debugstr_w(action), rc);
 745
 746     return rc;
 747 }
 748
 749 UINT MSI_Sequence( MSIPACKAGE *package, LPCWSTR szTable, INT iSequenceMode )
 750 {
 751     MSIQUERY * view;
 752     UINT r;
 753     static const WCHAR query[] =
 754         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 755          '`','%','s','`',
 756          ' ','W','H','E','R','E',' ',
 757          '`','S','e','q','u','e','n','c','e','`',' ',
 758          '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
 759          '`','S','e','q','u','e','n','c','e','`',0};
 760     iterate_action_param iap;
 761
 762     /*
 763      * FIXME: probably should be checking UILevel in the
 764      *       ACTION_PerformUIAction/ACTION_PerformAction
 765      *       rather than saving the UI level here. Those
 766      *       two functions can be merged too.
 767      */
 768     iap.package = package;
 769     iap.UI = TRUE;
 770
 771     TRACE("%p %s %i\n", package, debugstr_w(szTable), iSequenceMode );
 772
 773     r = MSI_OpenQuery( package->db, &view, query, szTable );
 774     if (r == ERROR_SUCCESS)
 775     {
 776         r = MSI_IterateRecords( view, NULL, ITERATE_Actions, &iap );
 777         msiobj_release(&view->hdr);
 778     }
 779
 780     return r;
 781 }
 782
 783 static UINT ACTION_ProcessExecSequence(MSIPACKAGE *package, BOOL UIran)
 784 {
 785     MSIQUERY * view;
 786     UINT rc;
 787     static const WCHAR ExecSeqQuery[] =
 788         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
 789          '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
 790          'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
 791          '`','S','e','q','u','e','n','c','e','`',' ', '>',' ','%','i',' ',
 792          'O','R','D','E','R',' ', 'B','Y',' ',
 793          '`','S','e','q','u','e','n','c','e','`',0 };
 794     MSIRECORD * row = 0;
 795     static const WCHAR IVQuery[] =
 796         {'S','E','L','E','C','T',' ','`','S','e','q','u','e','n','c','e','`',
 797          ' ', 'F','R','O','M',' ','`','I','n','s','t','a','l','l',
 798          'E','x','e','c','u','t','e','S','e','q','u','e','n','c','e','`',' ',
 799          'W','H','E','R','E',' ','`','A','c','t','i','o','n','`',' ','=',
 800          ' ','\'', 'I','n','s','t','a','l','l',
 801          'V','a','l','i','d','a','t','e','\'', 0};
 802     INT seq = 0;
 803     iterate_action_param iap;
 804
 805     iap.package = package;
 806     iap.UI = FALSE;
 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         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, &iap);
 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     iterate_action_param iap;
 851
 852     iap.package = package;
 853     iap.UI = TRUE;
 854
 855     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
 856
 857     if (rc == ERROR_SUCCESS)
 858     {
 859         TRACE("Running the actions\n");
 860
 861         rc = MSI_IterateRecords(view, NULL, ITERATE_Actions, &iap);
 862         msiobj_release(&view->hdr);
 863     }
 864
 865     return rc;
 866 }
 867
 868 /********************************************************
 869  * ACTION helper functions and functions that perform the actions
 870  *******************************************************/
 871 static BOOL ACTION_HandleStandardAction(MSIPACKAGE *package, LPCWSTR action,
 872                                         UINT* rc, BOOL force )
 873 {
 874     BOOL ret = FALSE;
 875     BOOL run = force;
 876     int i;
 877
 878     if (!run && !package->script->CurrentlyScripting)
 879         run = TRUE;
 880
 881     if (!run)
 882     {
 883         if (strcmpW(action,szInstallFinalize) == 0 ||
 884             strcmpW(action,szInstallExecute) == 0 ||
 885             strcmpW(action,szInstallExecuteAgain) == 0)
 886                 run = TRUE;
 887     }
 888
 889     i = 0;
 890     while (StandardActions[i].action != NULL)
 891     {
 892         if (strcmpW(StandardActions[i].action, action)==0)
 893         {
 894             if (!run)
 895             {
 896                 ui_actioninfo(package, action, TRUE, 0);
 897                 *rc = schedule_action(package,INSTALL_SCRIPT,action);
 898                 ui_actioninfo(package, action, FALSE, *rc);
 899             }
 900             else
 901             {
 902                 ui_actionstart(package, action);
 903                 if (StandardActions[i].handler)
 904                 {
 905                     *rc = StandardActions[i].handler(package);
 906                 }
 907                 else
 908                 {
 909                     FIXME("unhandled standard action %s\n",debugstr_w(action));
 910                     *rc = ERROR_SUCCESS;
 911                 }
 912             }
 913             ret = TRUE;
 914             break;
 915         }
 916         i++;
 917     }
 918     return ret;
 919 }
 920
 921 static BOOL ACTION_HandleCustomAction( MSIPACKAGE* package, LPCWSTR action,
 922                                        UINT* rc, BOOL force )
 923 {
 924     BOOL ret=FALSE;
 925     UINT arc;
 926
 927     arc = ACTION_CustomAction(package,action, force);
 928
 929     if (arc != ERROR_CALL_NOT_IMPLEMENTED)
 930     {
 931         *rc = arc;
 932         ret = TRUE;
 933     }
 934     return ret;
 935 }
 936
 937 /*
 938  * A lot of actions are really important even if they don't do anything
 939  * explicit... Lots of properties are set at the beginning of the installation
 940  * CostFinalize does a bunch of work to translate the directories and such
 941  *
 942  * But until I get write access to the database that is hard, so I am going to
 943  * hack it to see if I can get something to run.
 944  */
 945 UINT ACTION_PerformAction(MSIPACKAGE *package, const WCHAR *action, BOOL force)
 946 {
 947     UINT rc = ERROR_SUCCESS;
 948     BOOL handled;
 949
 950     TRACE("Performing action (%s)\n",debugstr_w(action));
 951
 952     handled = ACTION_HandleStandardAction(package, action, &rc, force);
 953
 954     if (!handled)
 955         handled = ACTION_HandleCustomAction(package, action, &rc, force);
 956
 957     if (!handled)
 958     {
 959         FIXME("unhandled msi action %s\n",debugstr_w(action));
 960         rc = ERROR_FUNCTION_NOT_CALLED;
 961     }
 962
 963     return rc;
 964 }
 965
 966 UINT ACTION_PerformUIAction(MSIPACKAGE *package, const WCHAR *action)
 967 {
 968     UINT rc = ERROR_SUCCESS;
 969     BOOL handled = FALSE;
 970
 971     TRACE("Performing action (%s)\n",debugstr_w(action));
 972
 973     handled = ACTION_HandleStandardAction(package, action, &rc,TRUE);
 974
 975     if (!handled)
 976         handled = ACTION_HandleCustomAction(package, action, &rc, FALSE);
 977
 978     if( !handled && ACTION_DialogBox(package,action) == ERROR_SUCCESS )
 979         handled = TRUE;
 980
 981     if (!handled)
 982     {
 983         FIXME("unhandled msi action %s\n",debugstr_w(action));
 984         rc = ERROR_FUNCTION_NOT_CALLED;
 985     }
 986
 987     return rc;
 988 }
 989
 990
 991 /*
 992  * Actual Action Handlers
 993  */
 994
 995 static UINT ITERATE_CreateFolders(MSIRECORD *row, LPVOID param)
 996 {
 997     MSIPACKAGE *package = (MSIPACKAGE*)param;
 998     LPCWSTR dir;
 999     LPWSTR full_path;
1000     MSIRECORD *uirow;
1001     MSIFOLDER *folder;
1002
1003     dir = MSI_RecordGetString(row,1);
1004     if (!dir)
1005     {
1006         ERR("Unable to get folder id\n");
1007         return ERROR_SUCCESS;
1008     }
1009
1010     full_path = resolve_folder(package,dir,FALSE,FALSE,&folder);
1011     if (!full_path)
1012     {
1013         ERR("Unable to resolve folder id %s\n",debugstr_w(dir));
1014         return ERROR_SUCCESS;
1015     }
1016
1017     TRACE("Folder is %s\n",debugstr_w(full_path));
1018
1019     /* UI stuff */
1020     uirow = MSI_CreateRecord(1);
1021     MSI_RecordSetStringW(uirow,1,full_path);
1022     ui_actiondata(package,szCreateFolders,uirow);
1023     msiobj_release( &uirow->hdr );
1024
1025     if (folder->State == 0)
1026         create_full_pathW(full_path);
1027
1028     folder->State = 3;
1029
1030     msi_free(full_path);
1031     return ERROR_SUCCESS;
1032 }
1033
1034 /* FIXME: probably should merge this with the above function */
1035 static UINT msi_create_directory( MSIPACKAGE* package, LPCWSTR dir )
1036 {
1037     UINT rc = ERROR_SUCCESS;
1038     MSIFOLDER *folder;
1039     LPWSTR install_path;
1040
1041     install_path = resolve_folder(package, dir, FALSE, FALSE, &folder);
1042     if (!install_path)
1043         return ERROR_FUNCTION_FAILED;
1044
1045     /* create the path */
1046     if (folder->State == 0)
1047     {
1048         create_full_pathW(install_path);
1049         folder->State = 2;
1050     }
1051     msi_free(install_path);
1052
1053     return rc;
1054 }
1055
1056 UINT msi_create_component_directories( MSIPACKAGE *package )
1057 {
1058     MSICOMPONENT *comp;
1059
1060     /* create all the folders required by the components are going to install */
1061     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
1062     {
1063         if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
1064             continue;
1065         msi_create_directory( package, comp->Directory );
1066     }
1067
1068     return ERROR_SUCCESS;
1069 }
1070
1071 /*
1072  * Also we cannot enable/disable components either, so for now I am just going
1073  * to do all the directories for all the components.
1074  */
1075 static UINT ACTION_CreateFolders(MSIPACKAGE *package)
1076 {
1077     static const WCHAR ExecSeqQuery[] =
1078         {'S','E','L','E','C','T',' ',
1079          '`','D','i','r','e','c','t','o','r','y','_','`',
1080          ' ','F','R','O','M',' ',
1081          '`','C','r','e','a','t','e','F','o','l','d','e','r','`',0 };
1082     UINT rc;
1083     MSIQUERY *view;
1084
1085     /* create all the empty folders specified in the CreateFolder table */
1086     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view );
1087     if (rc != ERROR_SUCCESS)
1088         return ERROR_SUCCESS;
1089
1090     rc = MSI_IterateRecords(view, NULL, ITERATE_CreateFolders, package);
1091     msiobj_release(&view->hdr);
1092
1093     msi_create_component_directories( package );
1094
1095     return rc;
1096 }
1097
1098 static MSICOMPONENT* load_component( MSIRECORD * row )
1099 {
1100     MSICOMPONENT *comp;
1101
1102     comp = msi_alloc_zero( sizeof(MSICOMPONENT) );
1103     if (!comp)
1104         return comp;
1105
1106     /* fill in the data */
1107     comp->Component = msi_dup_record_field( row, 1 );
1108
1109     TRACE("Loading Component %s\n", debugstr_w(comp->Component));
1110
1111     comp->ComponentId = msi_dup_record_field( row, 2 );
1112     comp->Directory = msi_dup_record_field( row, 3 );
1113     comp->Attributes = MSI_RecordGetInteger(row,4);
1114     comp->Condition = msi_dup_record_field( row, 5 );
1115     comp->KeyPath = msi_dup_record_field( row, 6 );
1116
1117     comp->Installed = INSTALLSTATE_ABSENT;
1118     comp->Action = INSTALLSTATE_UNKNOWN;
1119     comp->ActionRequest = INSTALLSTATE_UNKNOWN;
1120
1121     comp->Enabled = TRUE;
1122
1123     return comp;
1124 }
1125
1126 typedef struct {
1127     MSIPACKAGE *package;
1128     MSIFEATURE *feature;
1129 } _ilfs;
1130
1131 static UINT add_feature_component( MSIFEATURE *feature, MSICOMPONENT *comp )
1132 {
1133     ComponentList *cl;
1134
1135     cl = msi_alloc( sizeof (*cl) );
1136     if ( !cl )
1137         return ERROR_NOT_ENOUGH_MEMORY;
1138     cl->component = comp;
1139     list_add_tail( &feature->Components, &cl->entry );
1140
1141     return ERROR_SUCCESS;
1142 }
1143
1144 static UINT iterate_component_check( MSIRECORD *row, LPVOID param )
1145 {
1146     _ilfs* ilfs= (_ilfs*)param;
1147     MSIPACKAGE *package = ilfs->package;
1148     MSIFEATURE *feature = ilfs->feature;
1149     MSICOMPONENT *comp;
1150
1151     comp = load_component( row );
1152     if (!comp)
1153         return ERROR_FUNCTION_FAILED;
1154
1155     list_add_tail( &package->components, &comp->entry );
1156     add_feature_component( feature, comp );
1157
1158     TRACE("Loaded new component %p\n", comp);
1159
1160     return ERROR_SUCCESS;
1161 }
1162
1163 static UINT iterate_load_featurecomponents(MSIRECORD *row, LPVOID param)
1164 {
1165     _ilfs* ilfs= (_ilfs*)param;
1166     LPCWSTR component;
1167     DWORD rc;
1168     MSICOMPONENT *comp;
1169     MSIQUERY * view;
1170     static const WCHAR Query[] =
1171         {'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
1172          '`','C','o','m','p','o','n','e','n','t','`',' ',
1173          'W','H','E','R','E',' ',
1174          '`','C','o','m','p','o','n','e','n','t','`',' ',
1175          '=','\'','%','s','\'',0};
1176
1177     component = MSI_RecordGetString(row,1);
1178
1179     /* check to see if the component is already loaded */
1180     comp = get_loaded_component( ilfs->package, component );
1181     if (comp)
1182     {
1183         TRACE("Component %s already loaded\n", debugstr_w(component) );
1184         add_feature_component( ilfs->feature, comp );
1185         return ERROR_SUCCESS;
1186     }
1187
1188     rc = MSI_OpenQuery(ilfs->package->db, &view, Query, component);
1189     if (rc != ERROR_SUCCESS)
1190         return ERROR_SUCCESS;
1191
1192     rc = MSI_IterateRecords(view, NULL, iterate_component_check, ilfs);
1193     msiobj_release( &view->hdr );
1194
1195     return ERROR_SUCCESS;
1196 }
1197
1198 static UINT load_feature(MSIRECORD * row, LPVOID param)
1199 {
1200     MSIPACKAGE* package = (MSIPACKAGE*)param;
1201     MSIFEATURE* feature;
1202     static const WCHAR Query1[] =
1203         {'S','E','L','E','C','T',' ',
1204          '`','C','o','m','p','o','n','e','n','t','_','`',
1205          ' ','F','R','O','M',' ','`','F','e','a','t','u','r','e',
1206          'C','o','m','p','o','n','e','n','t','s','`',' ',
1207          'W','H','E','R','E',' ',
1208          '`','F','e', 'a','t','u','r','e','_','`',' ','=','\'','%','s','\'',0};
1209     MSIQUERY * view;
1210     UINT    rc;
1211     _ilfs ilfs;
1212
1213     /* fill in the data */
1214
1215     feature = msi_alloc_zero( sizeof (MSIFEATURE) );
1216     if (!feature)
1217         return ERROR_NOT_ENOUGH_MEMORY;
1218
1219     list_init( &feature->Components );
1220
1221     feature->Feature = msi_dup_record_field( row, 1 );
1222
1223     TRACE("Loading feature %s\n",debugstr_w(feature->Feature));
1224
1225     feature->Feature_Parent = msi_dup_record_field( row, 2 );
1226     feature->Title = msi_dup_record_field( row, 3 );
1227     feature->Description = msi_dup_record_field( row, 4 );
1228
1229     if (!MSI_RecordIsNull(row,5))
1230         feature->Display = MSI_RecordGetInteger(row,5);
1231
1232     feature->Level= MSI_RecordGetInteger(row,6);
1233     feature->Directory = msi_dup_record_field( row, 7 );
1234     feature->Attributes = MSI_RecordGetInteger(row,8);
1235
1236     feature->Installed = INSTALLSTATE_ABSENT;
1237     feature->Action = INSTALLSTATE_UNKNOWN;
1238     feature->ActionRequest = INSTALLSTATE_UNKNOWN;
1239
1240     list_add_tail( &package->features, &feature->entry );
1241
1242     /* load feature components */
1243
1244     rc = MSI_OpenQuery( package->db, &view, Query1, feature->Feature );
1245     if (rc != ERROR_SUCCESS)
1246         return ERROR_SUCCESS;
1247
1248     ilfs.package = package;
1249     ilfs.feature = feature;
1250
1251     MSI_IterateRecords(view, NULL, iterate_load_featurecomponents , &ilfs);
1252     msiobj_release(&view->hdr);
1253
1254     return ERROR_SUCCESS;
1255 }
1256
1257 static LPWSTR folder_split_path(LPWSTR p, WCHAR ch)
1258 {
1259     if (!p)
1260         return p;
1261     p = strchrW(p, ch);
1262     if (!p)
1263         return p;
1264     *p = 0;
1265     return p+1;
1266 }
1267
1268 static UINT load_file(MSIRECORD *row, LPVOID param)
1269 {
1270     MSIPACKAGE* package = (MSIPACKAGE*)param;
1271     LPCWSTR component;
1272     MSIFILE *file;
1273
1274     /* fill in the data */
1275
1276     file = msi_alloc_zero( sizeof (MSIFILE) );
1277     if (!file)
1278         return ERROR_NOT_ENOUGH_MEMORY;
1279
1280     file->File = msi_dup_record_field( row, 1 );
1281
1282     component = MSI_RecordGetString( row, 2 );
1283     file->Component = get_loaded_component( package, component );
1284
1285     if (!file->Component)
1286         ERR("Unfound Component %s\n",debugstr_w(component));
1287
1288     file->FileName = msi_dup_record_field( row, 3 );
1289     reduce_to_longfilename( file->FileName );
1290
1291     file->ShortName = msi_dup_record_field( row, 3 );
1292     file->LongName = strdupW( folder_split_path(file->ShortName, '|'));
1293
1294     file->FileSize = MSI_RecordGetInteger( row, 4 );
1295     file->Version = msi_dup_record_field( row, 5 );
1296     file->Language = msi_dup_record_field( row, 6 );
1297     file->Attributes = MSI_RecordGetInteger( row, 7 );
1298     file->Sequence = MSI_RecordGetInteger( row, 8 );
1299
1300     file->state = msifs_invalid;
1301
1302     TRACE("File Loaded (%s)\n",debugstr_w(file->File));
1303
1304     list_add_tail( &package->files, &file->entry );
1305
1306     return ERROR_SUCCESS;
1307 }
1308
1309 static UINT load_all_files(MSIPACKAGE *package)
1310 {
1311     MSIQUERY * view;
1312     UINT rc;
1313     static const WCHAR Query[] =
1314         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1315          '`','F','i','l','e','`',' ', 'O','R','D','E','R',' ','B','Y',' ',
1316          '`','S','e','q','u','e','n','c','e','`', 0};
1317
1318     if (!list_empty(&package->files))
1319         return ERROR_SUCCESS;
1320
1321     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
1322     if (rc != ERROR_SUCCESS)
1323         return ERROR_SUCCESS;
1324
1325     rc = MSI_IterateRecords(view, NULL, load_file, package);
1326     msiobj_release(&view->hdr);
1327
1328     return ERROR_SUCCESS;
1329 }
1330
1331
1332 /*
1333  * I am not doing any of the costing functionality yet.
1334  * Mostly looking at doing the Component and Feature loading
1335  *
1336  * The native MSI does A LOT of modification to tables here. Mostly adding
1337  * a lot of temporary columns to the Feature and Component tables.
1338  *
1339  *    note: Native msi also tracks the short filename. But I am only going to
1340  *          track the long ones.  Also looking at this directory table
1341  *          it appears that the directory table does not get the parents
1342  *          resolved base on property only based on their entries in the
1343  *          directory table.
1344  */
1345 static UINT ACTION_CostInitialize(MSIPACKAGE *package)
1346 {
1347     MSIQUERY * view;
1348     UINT rc;
1349     static const WCHAR Query_all[] =
1350         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1351          '`','F','e','a','t','u','r','e','`',' ','O','R','D','E','R',
1352          ' ','B','Y',' ','`','D','i','s','p','l','a','y','`',0};
1353     static const WCHAR szCosting[] =
1354         {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
1355     static const WCHAR szZero[] = { '0', 0 };
1356
1357     if ( 1 == msi_get_property_int( package, szCosting, 0 ) )
1358         return ERROR_SUCCESS;
1359
1360     MSI_SetPropertyW(package, szCosting, szZero);
1361     MSI_SetPropertyW(package, cszRootDrive , c_colon);
1362
1363     rc = MSI_DatabaseOpenViewW(package->db,Query_all,&view);
1364     if (rc != ERROR_SUCCESS)
1365         return rc;
1366
1367     if (list_empty(&package->features))
1368     {
1369         rc = MSI_IterateRecords(view, NULL, load_feature, package);
1370         msiobj_release(&view->hdr);
1371     }
1372
1373     load_all_files(package);
1374
1375     return ERROR_SUCCESS;
1376 }
1377
1378 static UINT execute_script(MSIPACKAGE *package, UINT script )
1379 {
1380     int i;
1381     UINT rc = ERROR_SUCCESS;
1382
1383     TRACE("Executing Script %i\n",script);
1384
1385     if (!package->script)
1386     {
1387         ERR("no script!\n");
1388         return ERROR_FUNCTION_FAILED;
1389     }
1390
1391     for (i = 0; i < package->script->ActionCount[script]; i++)
1392     {
1393         LPWSTR action;
1394         action = package->script->Actions[script][i];
1395         ui_actionstart(package, action);
1396         TRACE("Executing Action (%s)\n",debugstr_w(action));
1397         rc = ACTION_PerformAction(package, action, TRUE);
1398         msi_free(package->script->Actions[script][i]);
1399         if (rc != ERROR_SUCCESS)
1400             break;
1401     }
1402     msi_free(package->script->Actions[script]);
1403
1404     package->script->ActionCount[script] = 0;
1405     package->script->Actions[script] = NULL;
1406     return rc;
1407 }
1408
1409 static UINT ACTION_FileCost(MSIPACKAGE *package)
1410 {
1411     return ERROR_SUCCESS;
1412 }
1413
1414 static MSIFOLDER *load_folder( MSIPACKAGE *package, LPCWSTR dir )
1415 {
1416     static const WCHAR Query[] =
1417         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1418          '`','D','i','r','e','c', 't','o','r','y','`',' ',
1419          'W','H','E','R','E',' ', '`', 'D','i','r','e','c','t', 'o','r','y','`',
1420          ' ','=',' ','\'','%','s','\'',
1421          0};
1422     static const WCHAR szDot[] = { '.',0 };
1423     static WCHAR szEmpty[] = { 0 };
1424     LPWSTR p, tgt_short, tgt_long, src_short, src_long;
1425     LPCWSTR parent;
1426     MSIRECORD *row;
1427     MSIFOLDER *folder;
1428
1429     TRACE("Looking for dir %s\n",debugstr_w(dir));
1430
1431     folder = get_loaded_folder( package, dir );
1432     if (folder)
1433         return folder;
1434
1435     TRACE("Working to load %s\n",debugstr_w(dir));
1436
1437     folder = msi_alloc_zero( sizeof (MSIFOLDER) );
1438     if (!folder)
1439         return NULL;
1440
1441     folder->Directory = strdupW(dir);
1442
1443     row = MSI_QueryGetRecord(package->db, Query, dir);
1444     if (!row)
1445         return NULL;
1446
1447     p = msi_dup_record_field(row, 3);
1448
1449     /* split src and target dir */
1450     tgt_short = p;
1451     src_short = folder_split_path( p, ':' );
1452
1453     /* split the long and short paths */
1454     tgt_long = folder_split_path( tgt_short, '|' );
1455     src_long = folder_split_path( src_short, '|' );
1456
1457     /* check for no-op dirs */
1458     if (!lstrcmpW(szDot, tgt_short))
1459         tgt_short = szEmpty;
1460     if (!lstrcmpW(szDot, src_short))
1461         src_short = szEmpty;
1462
1463     if (!tgt_long)
1464         tgt_long = tgt_short;
1465
1466     if (!src_short) {
1467         src_short = tgt_short;
1468         src_long = tgt_long;
1469     }
1470
1471     if (!src_long)
1472         src_long = src_short;
1473
1474     /* FIXME: use the target short path too */
1475     folder->TargetDefault = strdupW(tgt_long);
1476     folder->SourceShortPath = strdupW(src_short);
1477     folder->SourceLongPath = strdupW(src_long);
1478     msi_free(p);
1479
1480     TRACE("TargetDefault = %s\n",debugstr_w( folder->TargetDefault ));
1481     TRACE("SourceLong = %s\n", debugstr_w( folder->SourceLongPath ));
1482     TRACE("SourceShort = %s\n", debugstr_w( folder->SourceShortPath ));
1483
1484     parent = MSI_RecordGetString(row, 2);
1485     if (parent)
1486     {
1487         folder->Parent = load_folder( package, parent );
1488         if ( folder->Parent )
1489             TRACE("loaded parent %p %s\n", folder->Parent,
1490                   debugstr_w(folder->Parent->Directory));
1491         else
1492             ERR("failed to load parent folder %s\n", debugstr_w(parent));
1493     }
1494
1495     folder->Property = msi_dup_property( package, dir );
1496
1497     msiobj_release(&row->hdr);
1498
1499     list_add_tail( &package->folders, &folder->entry );
1500
1501     TRACE("%s returning %p\n",debugstr_w(dir),folder);
1502
1503     return folder;
1504 }
1505
1506 /* scan for and update current install states */
1507 static void ACTION_UpdateInstallStates(MSIPACKAGE *package)
1508 {
1509     MSICOMPONENT *comp;
1510     MSIFEATURE *feature;
1511
1512     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
1513     {
1514         INSTALLSTATE res;
1515         res = MsiGetComponentPathW( package->ProductCode,
1516                                     comp->ComponentId, NULL, NULL);
1517         if (res < 0)
1518             res = INSTALLSTATE_ABSENT;
1519         comp->Installed = res;
1520     }
1521
1522     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1523     {
1524         ComponentList *cl;
1525         INSTALLSTATE res = -10;
1526
1527         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1528         {
1529             comp= cl->component;
1530
1531             if (res == -10)
1532                 res = comp->Installed;
1533             else
1534             {
1535                 if (res == comp->Installed)
1536                     continue;
1537
1538                 if (res != comp->Installed)
1539                         res = INSTALLSTATE_INCOMPLETE;
1540             }
1541         }
1542         feature->Installed = res;
1543     }
1544 }
1545
1546 static BOOL process_state_property (MSIPACKAGE* package, LPCWSTR property,
1547                                     INSTALLSTATE state)
1548 {
1549     static const WCHAR all[]={'A','L','L',0};
1550     LPWSTR override;
1551     MSIFEATURE *feature;
1552
1553     override = msi_dup_property( package, property );
1554     if (!override)
1555         return FALSE;
1556
1557     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1558     {
1559         if (strcmpiW(override,all)==0)
1560         {
1561             feature->ActionRequest= state;
1562             feature->Action = state;
1563         }
1564         else
1565         {
1566             LPWSTR ptr = override;
1567             LPWSTR ptr2 = strchrW(override,',');
1568
1569             while (ptr)
1570             {
1571                 if ((ptr2 && strncmpW(ptr,feature->Feature, ptr2-ptr)==0)
1572                     || (!ptr2 && strcmpW(ptr,feature->Feature)==0))
1573                 {
1574                     feature->ActionRequest= state;
1575                     feature->Action = state;
1576                     break;
1577                 }
1578                 if (ptr2)
1579                 {
1580                     ptr=ptr2+1;
1581                     ptr2 = strchrW(ptr,',');
1582                 }
1583                 else
1584                     break;
1585             }
1586         }
1587     }
1588     msi_free(override);
1589
1590     return TRUE;
1591 }
1592
1593 static UINT SetFeatureStates(MSIPACKAGE *package)
1594 {
1595     int install_level;
1596     static const WCHAR szlevel[] =
1597         {'I','N','S','T','A','L','L','L','E','V','E','L',0};
1598     static const WCHAR szAddLocal[] =
1599         {'A','D','D','L','O','C','A','L',0};
1600     static const WCHAR szRemove[] =
1601         {'R','E','M','O','V','E',0};
1602     static const WCHAR szReinstall[] =
1603         {'R','E','I','N','S','T','A','L','L',0};
1604     BOOL override = FALSE;
1605     MSICOMPONENT* component;
1606     MSIFEATURE *feature;
1607
1608
1609     /* I do not know if this is where it should happen.. but */
1610
1611     TRACE("Checking Install Level\n");
1612
1613     install_level = msi_get_property_int( package, szlevel, 1 );
1614
1615     /* ok hereis the _real_ rub
1616      * all these activation/deactivation things happen in order and things
1617      * later on the list override things earlier on the list.
1618      * 1) INSTALLLEVEL processing
1619      * 2) ADDLOCAL
1620      * 3) REMOVE
1621      * 4) ADDSOURCE
1622      * 5) ADDDEFAULT
1623      * 6) REINSTALL
1624      * 7) COMPADDLOCAL
1625      * 8) COMPADDSOURCE
1626      * 9) FILEADDLOCAL
1627      * 10) FILEADDSOURCE
1628      * 11) FILEADDDEFAULT
1629      * I have confirmed that if ADDLOCAL is stated then the INSTALLLEVEL is
1630      * ignored for all the features. seems strange, especially since it is not
1631      * documented anywhere, but it is how it works.
1632      *
1633      * I am still ignoring a lot of these. But that is ok for now, ADDLOCAL and
1634      * REMOVE are the big ones, since we don't handle administrative installs
1635      * yet anyway.
1636      */
1637     override |= process_state_property(package,szAddLocal,INSTALLSTATE_LOCAL);
1638     override |= process_state_property(package,szRemove,INSTALLSTATE_ABSENT);
1639     override |= process_state_property(package,szReinstall,INSTALLSTATE_LOCAL);
1640
1641     if (!override)
1642     {
1643         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1644         {
1645             BOOL feature_state = ((feature->Level > 0) &&
1646                              (feature->Level <= install_level));
1647
1648             if ((feature_state) && (feature->Action == INSTALLSTATE_UNKNOWN))
1649             {
1650                 if (feature->Attributes & msidbFeatureAttributesFavorSource)
1651                 {
1652                     feature->ActionRequest = INSTALLSTATE_SOURCE;
1653                     feature->Action = INSTALLSTATE_SOURCE;
1654                 }
1655                 else if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
1656                 {
1657                     feature->ActionRequest = INSTALLSTATE_ADVERTISED;
1658                     feature->Action = INSTALLSTATE_ADVERTISED;
1659                 }
1660                 else
1661                 {
1662                     feature->ActionRequest = INSTALLSTATE_LOCAL;
1663                     feature->Action = INSTALLSTATE_LOCAL;
1664                 }
1665             }
1666         }
1667     }
1668     else
1669     {
1670         /* set the Preselected Property */
1671         static const WCHAR szPreselected[] = {'P','r','e','s','e','l','e','c','t','e','d',0};
1672         static const WCHAR szOne[] = { '1', 0 };
1673
1674         MSI_SetPropertyW(package,szPreselected,szOne);
1675     }
1676
1677     /*
1678      * now we want to enable or disable components base on feature
1679     */
1680
1681     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1682     {
1683         ComponentList *cl;
1684
1685         TRACE("Examining Feature %s (Installed %i, Action %i, Request %i)\n",
1686             debugstr_w(feature->Feature), feature->Installed, feature->Action,
1687             feature->ActionRequest);
1688
1689         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1690         {
1691             component = cl->component;
1692
1693             if (!component->Enabled)
1694             {
1695                 component->Action = INSTALLSTATE_UNKNOWN;
1696                 component->ActionRequest = INSTALLSTATE_UNKNOWN;
1697             }
1698             else
1699             {
1700                 if (feature->Action == INSTALLSTATE_LOCAL)
1701                 {
1702                     component->Action = INSTALLSTATE_LOCAL;
1703                     component->ActionRequest = INSTALLSTATE_LOCAL;
1704                 }
1705                 else if (feature->ActionRequest == INSTALLSTATE_SOURCE)
1706                 {
1707                     if ((component->Action == INSTALLSTATE_UNKNOWN) ||
1708                         (component->Action == INSTALLSTATE_ABSENT) ||
1709                         (component->Action == INSTALLSTATE_ADVERTISED))
1710
1711                     {
1712                         component->Action = INSTALLSTATE_SOURCE;
1713                         component->ActionRequest = INSTALLSTATE_SOURCE;
1714                     }
1715                 }
1716                 else if (feature->ActionRequest == INSTALLSTATE_ADVERTISED)
1717                 {
1718                     if ((component->Action == INSTALLSTATE_UNKNOWN) ||
1719                         (component->Action == INSTALLSTATE_ABSENT))
1720
1721                     {
1722                         component->Action = INSTALLSTATE_ADVERTISED;
1723                         component->ActionRequest = INSTALLSTATE_ADVERTISED;
1724                     }
1725                 }
1726                 else if (feature->ActionRequest == INSTALLSTATE_ABSENT)
1727                 {
1728                     if (component->Action == INSTALLSTATE_UNKNOWN)
1729                     {
1730                         component->Action = INSTALLSTATE_ABSENT;
1731                         component->ActionRequest = INSTALLSTATE_ABSENT;
1732                     }
1733                 }
1734             }
1735         }
1736     }
1737
1738     LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
1739     {
1740         TRACE("Result: Component %s (Installed %i, Action %i, Request %i)\n",
1741             debugstr_w(component->Component), component->Installed,
1742             component->Action, component->ActionRequest);
1743     }
1744
1745
1746     return ERROR_SUCCESS;
1747 }
1748
1749 static UINT ITERATE_CostFinalizeDirectories(MSIRECORD *row, LPVOID param)
1750 {
1751     MSIPACKAGE *package = (MSIPACKAGE*)param;
1752     LPCWSTR name;
1753     LPWSTR path;
1754
1755     name = MSI_RecordGetString(row,1);
1756
1757     /* This helper function now does ALL the work */
1758     TRACE("Dir %s ...\n",debugstr_w(name));
1759     load_folder(package,name);
1760     path = resolve_folder(package,name,FALSE,TRUE,NULL);
1761     TRACE("resolves to %s\n",debugstr_w(path));
1762     msi_free(path);
1763
1764     return ERROR_SUCCESS;
1765 }
1766
1767 static UINT ITERATE_CostFinalizeConditions(MSIRECORD *row, LPVOID param)
1768 {
1769     MSIPACKAGE *package = (MSIPACKAGE*)param;
1770     LPCWSTR name;
1771     MSIFEATURE *feature;
1772
1773     name = MSI_RecordGetString( row, 1 );
1774
1775     feature = get_loaded_feature( package, name );
1776     if (!feature)
1777         ERR("FAILED to find loaded feature %s\n",debugstr_w(name));
1778     else
1779     {
1780         LPCWSTR Condition;
1781         Condition = MSI_RecordGetString(row,3);
1782
1783         if (MSI_EvaluateConditionW(package,Condition) == MSICONDITION_TRUE)
1784         {
1785             int level = MSI_RecordGetInteger(row,2);
1786             TRACE("Reseting feature %s to level %i\n", debugstr_w(name), level);
1787             feature->Level = level;
1788         }
1789     }
1790     return ERROR_SUCCESS;
1791 }
1792
1793
1794 /*
1795  * A lot is done in this function aside from just the costing.
1796  * The costing needs to be implemented at some point but for now I am going
1797  * to focus on the directory building
1798  *
1799  */
1800 static UINT ACTION_CostFinalize(MSIPACKAGE *package)
1801 {
1802     static const WCHAR ExecSeqQuery[] =
1803         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1804          '`','D','i','r','e','c','t','o','r','y','`',0};
1805     static const WCHAR ConditionQuery[] =
1806         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1807          '`','C','o','n','d','i','t','i','o','n','`',0};
1808     static const WCHAR szCosting[] =
1809         {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
1810     static const WCHAR szlevel[] =
1811         {'I','N','S','T','A','L','L','L','E','V','E','L',0};
1812     static const WCHAR szOne[] = { '1', 0 };
1813     MSICOMPONENT *comp;
1814     MSIFILE *file;
1815     UINT rc;
1816     MSIQUERY * view;
1817     LPWSTR level;
1818
1819     if ( 1 == msi_get_property_int( package, szCosting, 0 ) )
1820         return ERROR_SUCCESS;
1821
1822     TRACE("Building Directory properties\n");
1823
1824     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
1825     if (rc == ERROR_SUCCESS)
1826     {
1827         rc = MSI_IterateRecords(view, NULL, ITERATE_CostFinalizeDirectories,
1828                         package);
1829         msiobj_release(&view->hdr);
1830     }
1831
1832     TRACE("File calculations\n");
1833
1834     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
1835     {
1836         MSICOMPONENT* comp = file->Component;
1837         LPWSTR p;
1838
1839         if (!comp)
1840             continue;
1841
1842         /* calculate target */
1843         p = resolve_folder(package, comp->Directory, FALSE, FALSE, NULL);
1844
1845         msi_free(file->TargetPath);
1846
1847         TRACE("file %s is named %s\n",
1848                debugstr_w(file->File),debugstr_w(file->FileName));
1849
1850         file->TargetPath = build_directory_name(2, p, file->FileName);
1851
1852         msi_free(p);
1853
1854         TRACE("file %s resolves to %s\n",
1855                debugstr_w(file->File),debugstr_w(file->TargetPath));
1856
1857         if (GetFileAttributesW(file->TargetPath) == INVALID_FILE_ATTRIBUTES)
1858         {
1859             file->state = msifs_missing;
1860             comp->Cost += file->FileSize;
1861             continue;
1862         }
1863
1864         if (file->Version)
1865         {
1866             DWORD handle;
1867             DWORD versize;
1868             UINT sz;
1869             LPVOID version;
1870             static WCHAR name[] = {'\\',0};
1871             static const WCHAR name_fmt[] =
1872                 {'%','u','.','%','u','.','%','u','.','%','u',0};
1873             WCHAR filever[0x100];
1874             VS_FIXEDFILEINFO *lpVer;
1875
1876             TRACE("Version comparison..\n");
1877             versize = GetFileVersionInfoSizeW(file->TargetPath,&handle);
1878             version = msi_alloc(versize);
1879             GetFileVersionInfoW(file->TargetPath, 0, versize, version);
1880
1881             VerQueryValueW(version, name, (LPVOID*)&lpVer, &sz);
1882
1883             sprintfW(filever,name_fmt,
1884                 HIWORD(lpVer->dwFileVersionMS),
1885                 LOWORD(lpVer->dwFileVersionMS),
1886                 HIWORD(lpVer->dwFileVersionLS),
1887                 LOWORD(lpVer->dwFileVersionLS));
1888
1889             TRACE("new %s old %s\n", debugstr_w(file->Version),
1890                   debugstr_w(filever));
1891             if (strcmpiW(filever,file->Version)<0)
1892             {
1893                 file->state = msifs_overwrite;
1894                 /* FIXME: cost should be diff in size */
1895                 comp->Cost += file->FileSize;
1896             }
1897             else
1898                 file->state = msifs_present;
1899             msi_free(version);
1900         }
1901         else
1902             file->state = msifs_present;
1903     }
1904
1905     TRACE("Evaluating Condition Table\n");
1906
1907     rc = MSI_DatabaseOpenViewW(package->db, ConditionQuery, &view);
1908     if (rc == ERROR_SUCCESS)
1909     {
1910         rc = MSI_IterateRecords(view, NULL, ITERATE_CostFinalizeConditions,
1911                     package);
1912         msiobj_release(&view->hdr);
1913     }
1914
1915     TRACE("Enabling or Disabling Components\n");
1916     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
1917     {
1918         if (comp->Condition)
1919         {
1920             if (MSI_EvaluateConditionW(package,
1921                 comp->Condition) == MSICONDITION_FALSE)
1922             {
1923                 TRACE("Disabling component %s\n", debugstr_w(comp->Component));
1924                 comp->Enabled = FALSE;
1925             }
1926         }
1927     }
1928
1929     MSI_SetPropertyW(package,szCosting,szOne);
1930     /* set default run level if not set */
1931     level = msi_dup_property( package, szlevel );
1932     if (!level)
1933         MSI_SetPropertyW(package,szlevel, szOne);
1934     msi_free(level);
1935
1936     ACTION_UpdateInstallStates(package);
1937
1938     return SetFeatureStates(package);
1939 }
1940
1941 /* OK this value is "interpreted" and then formatted based on the
1942    first few characters */
1943 static LPSTR parse_value(MSIPACKAGE *package, LPCWSTR value, DWORD *type,
1944                          DWORD *size)
1945 {
1946     LPSTR data = NULL;
1947     if (value[0]=='#' && value[1]!='#' && value[1]!='%')
1948     {
1949         if (value[1]=='x')
1950         {
1951             LPWSTR ptr;
1952             CHAR byte[5];
1953             LPWSTR deformated = NULL;
1954             int count;
1955
1956             deformat_string(package, &value[2], &deformated);
1957
1958             /* binary value type */
1959             ptr = deformated;
1960             *type = REG_BINARY;
1961             if (strlenW(ptr)%2)
1962                 *size = (strlenW(ptr)/2)+1;
1963             else
1964                 *size = strlenW(ptr)/2;
1965
1966             data = msi_alloc(*size);
1967
1968             byte[0] = '0';
1969             byte[1] = 'x';
1970             byte[4] = 0;
1971             count = 0;
1972             /* if uneven pad with a zero in front */
1973             if (strlenW(ptr)%2)
1974             {
1975                 byte[2]= '0';
1976                 byte[3]= *ptr;
1977                 ptr++;
1978                 data[count] = (BYTE)strtol(byte,NULL,0);
1979                 count ++;
1980                 TRACE("Uneven byte count\n");
1981             }
1982             while (*ptr)
1983             {
1984                 byte[2]= *ptr;
1985                 ptr++;
1986                 byte[3]= *ptr;
1987                 ptr++;
1988                 data[count] = (BYTE)strtol(byte,NULL,0);
1989                 count ++;
1990             }
1991             msi_free(deformated);
1992
1993             TRACE("Data %li bytes(%i)\n",*size,count);
1994         }
1995         else
1996         {
1997             LPWSTR deformated;
1998             LPWSTR p;
1999             DWORD d = 0;
2000             deformat_string(package, &value[1], &deformated);
2001
2002             *type=REG_DWORD;
2003             *size = sizeof(DWORD);
2004             data = msi_alloc(*size);
2005             p = deformated;
2006             if (*p == '-')
2007                 p++;
2008             while (*p)
2009             {
2010                 if ( (*p < '0') || (*p > '9') )
2011                     break;
2012                 d *= 10;
2013                 d += (*p - '0');
2014                 p++;
2015             }
2016             if (deformated[0] == '-')
2017                 d = -d;
2018             *(LPDWORD)data = d;
2019             TRACE("DWORD %li\n",*(LPDWORD)data);
2020
2021             msi_free(deformated);
2022         }
2023     }
2024     else
2025     {
2026         static const WCHAR szMulti[] = {'[','~',']',0};
2027         LPCWSTR ptr;
2028         *type=REG_SZ;
2029
2030         if (value[0]=='#')
2031         {
2032             if (value[1]=='%')
2033             {
2034                 ptr = &value[2];
2035                 *type=REG_EXPAND_SZ;
2036             }
2037             else
2038                 ptr = &value[1];
2039          }
2040          else
2041             ptr=value;
2042
2043         if (strstrW(value,szMulti))
2044             *type = REG_MULTI_SZ;
2045
2046         *size = deformat_string(package, ptr,(LPWSTR*)&data);
2047     }
2048     return data;
2049 }
2050
2051 static UINT ITERATE_WriteRegistryValues(MSIRECORD *row, LPVOID param)
2052 {
2053     MSIPACKAGE *package = (MSIPACKAGE*)param;
2054     static const WCHAR szHCR[] =
2055         {'H','K','E','Y','_','C','L','A','S','S','E','S','_',
2056          'R','O','O','T','\\',0};
2057     static const WCHAR szHCU[] =
2058         {'H','K','E','Y','_','C','U','R','R','E','N','T','_',
2059          'U','S','E','R','\\',0};
2060     static const WCHAR szHLM[] =
2061         {'H','K','E','Y','_','L','O','C','A','L','_',
2062          'M','A','C','H','I','N','E','\\',0};
2063     static const WCHAR szHU[] =
2064         {'H','K','E','Y','_','U','S','E','R','S','\\',0};
2065
2066     LPSTR value_data = NULL;
2067     HKEY  root_key, hkey;
2068     DWORD type,size;
2069     LPWSTR  deformated;
2070     LPCWSTR szRoot, component, name, key, value;
2071     MSICOMPONENT *comp;
2072     MSIRECORD * uirow;
2073     LPWSTR uikey;
2074     INT   root;
2075     BOOL check_first = FALSE;
2076     UINT rc;
2077
2078     ui_progress(package,2,0,0,0);
2079
2080     value = NULL;
2081     key = NULL;
2082     uikey = NULL;
2083     name = NULL;
2084
2085     component = MSI_RecordGetString(row, 6);
2086     comp = get_loaded_component(package,component);
2087     if (!comp)
2088         return ERROR_SUCCESS;
2089
2090     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2091     {
2092         TRACE("Skipping write due to disabled component %s\n",
2093                         debugstr_w(component));
2094
2095         comp->Action = comp->Installed;
2096
2097         return ERROR_SUCCESS;
2098     }
2099
2100     comp->Action = INSTALLSTATE_LOCAL;
2101
2102     name = MSI_RecordGetString(row, 4);
2103     if( MSI_RecordIsNull(row,5) && name )
2104     {
2105         /* null values can have special meanings */
2106         if (name[0]=='-' && name[1] == 0)
2107                 return ERROR_SUCCESS;
2108         else if ((name[0]=='+' && name[1] == 0) ||
2109                  (name[0] == '*' && name[1] == 0))
2110                 name = NULL;
2111         check_first = TRUE;
2112     }
2113
2114     root = MSI_RecordGetInteger(row,2);
2115     key = MSI_RecordGetString(row, 3);
2116
2117     /* get the root key */
2118     switch (root)
2119     {
2120         case -1:
2121             {
2122                 static const WCHAR szALLUSER[] = {'A','L','L','U','S','E','R','S',0};
2123                 LPWSTR all_users = msi_dup_property( package, szALLUSER );
2124                 if (all_users && all_users[0] == '1')
2125                 {
2126                     root_key = HKEY_LOCAL_MACHINE;
2127                     szRoot = szHLM;
2128                 }
2129                 else
2130                 {
2131                     root_key = HKEY_CURRENT_USER;
2132                     szRoot = szHCU;
2133                 }
2134                 msi_free(all_users);
2135             }
2136                  break;
2137         case 0:  root_key = HKEY_CLASSES_ROOT;
2138                  szRoot = szHCR;
2139                  break;
2140         case 1:  root_key = HKEY_CURRENT_USER;
2141                  szRoot = szHCU;
2142                  break;
2143         case 2:  root_key = HKEY_LOCAL_MACHINE;
2144                  szRoot = szHLM;
2145                  break;
2146         case 3:  root_key = HKEY_USERS;
2147                  szRoot = szHU;
2148                  break;
2149         default:
2150                  ERR("Unknown root %i\n",root);
2151                  root_key=NULL;
2152                  szRoot = NULL;
2153                  break;
2154     }
2155     if (!root_key)
2156         return ERROR_SUCCESS;
2157
2158     deformat_string(package, key , &deformated);
2159     size = strlenW(deformated) + strlenW(szRoot) + 1;
2160     uikey = msi_alloc(size*sizeof(WCHAR));
2161     strcpyW(uikey,szRoot);
2162     strcatW(uikey,deformated);
2163
2164     if (RegCreateKeyW( root_key, deformated, &hkey))
2165     {
2166         ERR("Could not create key %s\n",debugstr_w(deformated));
2167         msi_free(deformated);
2168         msi_free(uikey);
2169         return ERROR_SUCCESS;
2170     }
2171     msi_free(deformated);
2172
2173     value = MSI_RecordGetString(row,5);
2174     if (value)
2175         value_data = parse_value(package, value, &type, &size);
2176     else
2177     {
2178         static const WCHAR szEmpty[] = {0};
2179         value_data = (LPSTR)strdupW(szEmpty);
2180         size = 0;
2181         type = REG_SZ;
2182     }
2183
2184     deformat_string(package, name, &deformated);
2185
2186     /* get the double nulls to terminate SZ_MULTI */
2187     if (type == REG_MULTI_SZ)
2188         size +=sizeof(WCHAR);
2189
2190     if (!check_first)
2191     {
2192         TRACE("Setting value %s of %s\n",debugstr_w(deformated),
2193                         debugstr_w(uikey));
2194         RegSetValueExW(hkey, deformated, 0, type, (LPBYTE)value_data, size);
2195     }
2196     else
2197     {
2198         DWORD sz = 0;
2199         rc = RegQueryValueExW(hkey, deformated, NULL, NULL, NULL, &sz);
2200         if (rc == ERROR_SUCCESS || rc == ERROR_MORE_DATA)
2201         {
2202             TRACE("value %s of %s checked already exists\n",
2203                             debugstr_w(deformated), debugstr_w(uikey));
2204         }
2205         else
2206         {
2207             TRACE("Checked and setting value %s of %s\n",
2208                             debugstr_w(deformated), debugstr_w(uikey));
2209             if (deformated || size)
2210                 RegSetValueExW(hkey, deformated, 0, type, (LPBYTE) value_data, size);
2211         }
2212     }
2213     RegCloseKey(hkey);
2214
2215     uirow = MSI_CreateRecord(3);
2216     MSI_RecordSetStringW(uirow,2,deformated);
2217     MSI_RecordSetStringW(uirow,1,uikey);
2218
2219     if (type == REG_SZ)
2220         MSI_RecordSetStringW(uirow,3,(LPWSTR)value_data);
2221     else
2222         MSI_RecordSetStringW(uirow,3,value);
2223
2224     ui_actiondata(package,szWriteRegistryValues,uirow);
2225     msiobj_release( &uirow->hdr );
2226
2227     msi_free(value_data);
2228     msi_free(deformated);
2229     msi_free(uikey);
2230
2231     return ERROR_SUCCESS;
2232 }
2233
2234 static UINT ACTION_WriteRegistryValues(MSIPACKAGE *package)
2235 {
2236     UINT rc;
2237     MSIQUERY * view;
2238     static const WCHAR ExecSeqQuery[] =
2239         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2240          '`','R','e','g','i','s','t','r','y','`',0 };
2241
2242     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2243     if (rc != ERROR_SUCCESS)
2244         return ERROR_SUCCESS;
2245
2246     /* increment progress bar each time action data is sent */
2247     ui_progress(package,1,REG_PROGRESS_VALUE,1,0);
2248
2249     rc = MSI_IterateRecords(view, NULL, ITERATE_WriteRegistryValues, package);
2250
2251     msiobj_release(&view->hdr);
2252     return rc;
2253 }
2254
2255 static UINT ACTION_InstallInitialize(MSIPACKAGE *package)
2256 {
2257     package->script->CurrentlyScripting = TRUE;
2258
2259     return ERROR_SUCCESS;
2260 }
2261
2262
2263 static UINT ACTION_InstallValidate(MSIPACKAGE *package)
2264 {
2265     MSICOMPONENT *comp;
2266     DWORD progress = 0;
2267     DWORD total = 0;
2268     static const WCHAR q1[]=
2269         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
2270          '`','R','e','g','i','s','t','r','y','`',0};
2271     UINT rc;
2272     MSIQUERY * view;
2273     MSIFEATURE *feature;
2274     MSIFILE *file;
2275
2276     TRACE("InstallValidate\n");
2277
2278     rc = MSI_DatabaseOpenViewW(package->db, q1, &view);
2279     if (rc == ERROR_SUCCESS)
2280     {
2281         MSI_IterateRecords( view, &progress, NULL, package );
2282         msiobj_release( &view->hdr );
2283         total += progress * REG_PROGRESS_VALUE;
2284     }
2285
2286     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2287         total += COMPONENT_PROGRESS_VALUE;
2288
2289     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2290         total += file->FileSize;
2291
2292     ui_progress(package,0,total,0,0);
2293
2294     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2295     {
2296         TRACE("Feature: %s; Installed: %i; Action %i; Request %i\n",
2297             debugstr_w(feature->Feature), feature->Installed, feature->Action,
2298             feature->ActionRequest);
2299     }
2300
2301     return ERROR_SUCCESS;
2302 }
2303
2304 static UINT ITERATE_LaunchConditions(MSIRECORD *row, LPVOID param)
2305 {
2306     MSIPACKAGE* package = (MSIPACKAGE*)param;
2307     LPCWSTR cond = NULL;
2308     LPCWSTR message = NULL;
2309     static const WCHAR title[]=
2310         {'I','n','s','t','a','l','l',' ','F','a', 'i','l','e','d',0};
2311
2312     cond = MSI_RecordGetString(row,1);
2313
2314     if (MSI_EvaluateConditionW(package,cond) != MSICONDITION_TRUE)
2315     {
2316         LPWSTR deformated;
2317         message = MSI_RecordGetString(row,2);
2318         deformat_string(package,message,&deformated);
2319         MessageBoxW(NULL,deformated,title,MB_OK);
2320         msi_free(deformated);
2321         return ERROR_FUNCTION_FAILED;
2322     }
2323
2324     return ERROR_SUCCESS;
2325 }
2326
2327 static UINT ACTION_LaunchConditions(MSIPACKAGE *package)
2328 {
2329     UINT rc;
2330     MSIQUERY * view = NULL;
2331     static const WCHAR ExecSeqQuery[] =
2332         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2333          '`','L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','`',0};
2334
2335     TRACE("Checking launch conditions\n");
2336
2337     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2338     if (rc != ERROR_SUCCESS)
2339         return ERROR_SUCCESS;
2340
2341     rc = MSI_IterateRecords(view, NULL, ITERATE_LaunchConditions, package);
2342     msiobj_release(&view->hdr);
2343
2344     return rc;
2345 }
2346
2347 static LPWSTR resolve_keypath( MSIPACKAGE* package, MSICOMPONENT *cmp )
2348 {
2349
2350     if (!cmp->KeyPath)
2351         return resolve_folder(package,cmp->Directory,FALSE,FALSE,NULL);
2352
2353     if (cmp->Attributes & msidbComponentAttributesRegistryKeyPath)
2354     {
2355         MSIRECORD * row = 0;
2356         UINT root,len;
2357         LPWSTR deformated,buffer,deformated_name;
2358         LPCWSTR key,name;
2359         static const WCHAR ExecSeqQuery[] =
2360             {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2361              '`','R','e','g','i','s','t','r','y','`',' ',
2362              'W','H','E','R','E',' ', '`','R','e','g','i','s','t','r','y','`',
2363              ' ','=',' ' ,'\'','%','s','\'',0 };
2364         static const WCHAR fmt[]={'%','0','2','i',':','\\','%','s','\\',0};
2365         static const WCHAR fmt2[]=
2366             {'%','0','2','i',':','\\','%','s','\\','%','s',0};
2367
2368         row = MSI_QueryGetRecord(package->db, ExecSeqQuery,cmp->KeyPath);
2369         if (!row)
2370             return NULL;
2371
2372         root = MSI_RecordGetInteger(row,2);
2373         key = MSI_RecordGetString(row, 3);
2374         name = MSI_RecordGetString(row, 4);
2375         deformat_string(package, key , &deformated);
2376         deformat_string(package, name, &deformated_name);
2377
2378         len = strlenW(deformated) + 6;
2379         if (deformated_name)
2380             len+=strlenW(deformated_name);
2381
2382         buffer = msi_alloc( len *sizeof(WCHAR));
2383
2384         if (deformated_name)
2385             sprintfW(buffer,fmt2,root,deformated,deformated_name);
2386         else
2387             sprintfW(buffer,fmt,root,deformated);
2388
2389         msi_free(deformated);
2390         msi_free(deformated_name);
2391         msiobj_release(&row->hdr);
2392
2393         return buffer;
2394     }
2395     else if (cmp->Attributes & msidbComponentAttributesODBCDataSource)
2396     {
2397         FIXME("UNIMPLEMENTED keypath as ODBC Source\n");
2398         return NULL;
2399     }
2400     else
2401     {
2402         MSIFILE *file = get_loaded_file( package, cmp->KeyPath );
2403
2404         if (file)
2405             return strdupW( file->TargetPath );
2406     }
2407     return NULL;
2408 }
2409
2410 static HKEY openSharedDLLsKey(void)
2411 {
2412     HKEY hkey=0;
2413     static const WCHAR path[] =
2414         {'S','o','f','t','w','a','r','e','\\',
2415          'M','i','c','r','o','s','o','f','t','\\',
2416          'W','i','n','d','o','w','s','\\',
2417          'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
2418          'S','h','a','r','e','d','D','L','L','s',0};
2419
2420     RegCreateKeyW(HKEY_LOCAL_MACHINE,path,&hkey);
2421     return hkey;
2422 }
2423
2424 static UINT ACTION_GetSharedDLLsCount(LPCWSTR dll)
2425 {
2426     HKEY hkey;
2427     DWORD count=0;
2428     DWORD type;
2429     DWORD sz = sizeof(count);
2430     DWORD rc;
2431
2432     hkey = openSharedDLLsKey();
2433     rc = RegQueryValueExW(hkey, dll, NULL, &type, (LPBYTE)&count, &sz);
2434     if (rc != ERROR_SUCCESS)
2435         count = 0;
2436     RegCloseKey(hkey);
2437     return count;
2438 }
2439
2440 static UINT ACTION_WriteSharedDLLsCount(LPCWSTR path, UINT count)
2441 {
2442     HKEY hkey;
2443
2444     hkey = openSharedDLLsKey();
2445     if (count > 0)
2446         msi_reg_set_val_dword( hkey, path, count );
2447     else
2448         RegDeleteValueW(hkey,path);
2449     RegCloseKey(hkey);
2450     return count;
2451 }
2452
2453 /*
2454  * Return TRUE if the count should be written out and FALSE if not
2455  */
2456 static void ACTION_RefCountComponent( MSIPACKAGE* package, MSICOMPONENT *comp )
2457 {
2458     MSIFEATURE *feature;
2459     INT count = 0;
2460     BOOL write = FALSE;
2461
2462     /* only refcount DLLs */
2463     if (comp->KeyPath == NULL ||
2464         comp->Attributes & msidbComponentAttributesRegistryKeyPath ||
2465         comp->Attributes & msidbComponentAttributesODBCDataSource)
2466         write = FALSE;
2467     else
2468     {
2469         count = ACTION_GetSharedDLLsCount( comp->FullKeypath);
2470         write = (count > 0);
2471
2472         if (comp->Attributes & msidbComponentAttributesSharedDllRefCount)
2473             write = TRUE;
2474     }
2475
2476     /* increment counts */
2477     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2478     {
2479         ComponentList *cl;
2480
2481         if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_LOCAL ))
2482             continue;
2483
2484         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
2485         {
2486             if ( cl->component == comp )
2487                 count++;
2488         }
2489     }
2490
2491     /* decrement counts */
2492     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2493     {
2494         ComponentList *cl;
2495
2496         if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_ABSENT ))
2497             continue;
2498
2499         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
2500         {
2501             if ( cl->component == comp )
2502                 count--;
2503         }
2504     }
2505
2506     /* ref count all the files in the component */
2507     if (write)
2508     {
2509         MSIFILE *file;
2510
2511         LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2512         {
2513             if (file->Component == comp)
2514                 ACTION_WriteSharedDLLsCount( file->TargetPath, count );
2515         }
2516     }
2517
2518     /* add a count for permenent */
2519     if (comp->Attributes & msidbComponentAttributesPermanent)
2520         count ++;
2521
2522     comp->RefCount = count;
2523
2524     if (write)
2525         ACTION_WriteSharedDLLsCount( comp->FullKeypath, comp->RefCount );
2526 }
2527
2528 /*
2529  * Ok further analysis makes me think that this work is
2530  * actually done in the PublishComponents and PublishFeatures
2531  * step, and not here.  It appears like the keypath and all that is
2532  * resolved in this step, however actually written in the Publish steps.
2533  * But we will leave it here for now because it is unclear
2534  */
2535 static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
2536 {
2537     WCHAR squished_pc[GUID_SIZE];
2538     WCHAR squished_cc[GUID_SIZE];
2539     UINT rc;
2540     MSICOMPONENT *comp;
2541     HKEY hkey=0,hkey2=0;
2542
2543     /* writes the Component and Features values to the registry */
2544
2545     rc = MSIREG_OpenComponents(&hkey);
2546     if (rc != ERROR_SUCCESS)
2547         return rc;
2548
2549     squash_guid(package->ProductCode,squished_pc);
2550     ui_progress(package,1,COMPONENT_PROGRESS_VALUE,1,0);
2551
2552     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2553     {
2554         MSIRECORD * uirow;
2555
2556         ui_progress(package,2,0,0,0);
2557         if (!comp->ComponentId)
2558             continue;
2559
2560         squash_guid(comp->ComponentId,squished_cc);
2561
2562         msi_free(comp->FullKeypath);
2563         comp->FullKeypath = resolve_keypath( package, comp );
2564
2565         /* do the refcounting */
2566         ACTION_RefCountComponent( package, comp );
2567
2568         TRACE("Component %s (%s), Keypath=%s, RefCount=%i\n",
2569                             debugstr_w(comp->Component),
2570                             debugstr_w(squished_cc),
2571                             debugstr_w(comp->FullKeypath),
2572                             comp->RefCount);
2573         /*
2574          * Write the keypath out if the component is to be registered
2575          * and delete the key if the component is to be deregistered
2576          */
2577         if (ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2578         {
2579             rc = RegCreateKeyW(hkey,squished_cc,&hkey2);
2580             if (rc != ERROR_SUCCESS)
2581                 continue;
2582
2583             if (!comp->FullKeypath)
2584                 continue;
2585
2586             msi_reg_set_val_str( hkey2, squished_pc, comp->FullKeypath );
2587
2588             if (comp->Attributes & msidbComponentAttributesPermanent)
2589             {
2590                 static const WCHAR szPermKey[] =
2591                     { '0','0','0','0','0','0','0','0','0','0','0','0',
2592                       '0','0','0','0','0','0','0','0','0','0','0','0',
2593                       '0','0','0','0','0','0','0','0',0 };
2594
2595                 msi_reg_set_val_str( hkey2, szPermKey, comp->FullKeypath );
2596             }
2597
2598             RegCloseKey(hkey2);
2599
2600             /* UI stuff */
2601             uirow = MSI_CreateRecord(3);
2602             MSI_RecordSetStringW(uirow,1,package->ProductCode);
2603             MSI_RecordSetStringW(uirow,2,comp->ComponentId);
2604             MSI_RecordSetStringW(uirow,3,comp->FullKeypath);
2605             ui_actiondata(package,szProcessComponents,uirow);
2606             msiobj_release( &uirow->hdr );
2607         }
2608         else if (ACTION_VerifyComponentForAction( comp, INSTALLSTATE_ABSENT))
2609         {
2610             DWORD res;
2611
2612             rc = RegOpenKeyW(hkey,squished_cc,&hkey2);
2613             if (rc != ERROR_SUCCESS)
2614                 continue;
2615
2616             RegDeleteValueW(hkey2,squished_pc);
2617
2618             /* if the key is empty delete it */
2619             res = RegEnumKeyExW(hkey2,0,NULL,0,0,NULL,0,NULL);
2620             RegCloseKey(hkey2);
2621             if (res == ERROR_NO_MORE_ITEMS)
2622                 RegDeleteKeyW(hkey,squished_cc);
2623
2624             /* UI stuff */
2625             uirow = MSI_CreateRecord(2);
2626             MSI_RecordSetStringW(uirow,1,package->ProductCode);
2627             MSI_RecordSetStringW(uirow,2,comp->ComponentId);
2628             ui_actiondata(package,szProcessComponents,uirow);
2629             msiobj_release( &uirow->hdr );
2630         }
2631     }
2632     RegCloseKey(hkey);
2633     return rc;
2634 }
2635
2636 typedef struct {
2637     CLSID       clsid;
2638     LPWSTR      source;
2639
2640     LPWSTR      path;
2641     ITypeLib    *ptLib;
2642 } typelib_struct;
2643
2644 static BOOL CALLBACK Typelib_EnumResNameProc( HMODULE hModule, LPCWSTR lpszType,
2645                                        LPWSTR lpszName, LONG_PTR lParam)
2646 {
2647     TLIBATTR *attr;
2648     typelib_struct *tl_struct = (typelib_struct*) lParam;
2649     static const WCHAR fmt[] = {'%','s','\\','%','i',0};
2650     int sz;
2651     HRESULT res;
2652
2653     if (!IS_INTRESOURCE(lpszName))
2654     {
2655         ERR("Not Int Resource Name %s\n",debugstr_w(lpszName));
2656         return TRUE;
2657     }
2658
2659     sz = strlenW(tl_struct->source)+4;
2660     sz *= sizeof(WCHAR);
2661
2662     if ((INT_PTR)lpszName == 1)
2663         tl_struct->path = strdupW(tl_struct->source);
2664     else
2665     {
2666         tl_struct->path = msi_alloc(sz);
2667         sprintfW(tl_struct->path,fmt,tl_struct->source, lpszName);
2668     }
2669
2670     TRACE("trying %s\n", debugstr_w(tl_struct->path));
2671     res = LoadTypeLib(tl_struct->path,&tl_struct->ptLib);
2672     if (!SUCCEEDED(res))
2673     {
2674         msi_free(tl_struct->path);
2675         tl_struct->path = NULL;
2676
2677         return TRUE;
2678     }
2679
2680     ITypeLib_GetLibAttr(tl_struct->ptLib, &attr);
2681     if (IsEqualGUID(&(tl_struct->clsid),&(attr->guid)))
2682     {
2683         ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
2684         return FALSE;
2685     }
2686
2687     msi_free(tl_struct->path);
2688     tl_struct->path = NULL;
2689
2690     ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
2691     ITypeLib_Release(tl_struct->ptLib);
2692
2693     return TRUE;
2694 }
2695
2696 static UINT ITERATE_RegisterTypeLibraries(MSIRECORD *row, LPVOID param)
2697 {
2698     MSIPACKAGE* package = (MSIPACKAGE*)param;
2699     LPCWSTR component;
2700     MSICOMPONENT *comp;
2701     MSIFILE *file;
2702     typelib_struct tl_struct;
2703     HMODULE module;
2704     static const WCHAR szTYPELIB[] = {'T','Y','P','E','L','I','B',0};
2705
2706     component = MSI_RecordGetString(row,3);
2707     comp = get_loaded_component(package,component);
2708     if (!comp)
2709         return ERROR_SUCCESS;
2710
2711     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2712     {
2713         TRACE("Skipping typelib reg due to disabled component\n");
2714
2715         comp->Action = comp->Installed;
2716
2717         return ERROR_SUCCESS;
2718     }
2719
2720     comp->Action = INSTALLSTATE_LOCAL;
2721
2722     file = get_loaded_file( package, comp->KeyPath );
2723     if (!file)
2724         return ERROR_SUCCESS;
2725
2726     module = LoadLibraryExW( file->TargetPath, NULL, LOAD_LIBRARY_AS_DATAFILE );
2727     if (module)
2728     {
2729         LPCWSTR guid;
2730         guid = MSI_RecordGetString(row,1);
2731         CLSIDFromString((LPWSTR)guid, &tl_struct.clsid);
2732         tl_struct.source = strdupW( file->TargetPath );
2733         tl_struct.path = NULL;
2734
2735         EnumResourceNamesW(module, szTYPELIB, Typelib_EnumResNameProc,
2736                         (LONG_PTR)&tl_struct);
2737
2738         if (tl_struct.path)
2739         {
2740             LPWSTR help = NULL;
2741             LPCWSTR helpid;
2742             HRESULT res;
2743
2744             helpid = MSI_RecordGetString(row,6);
2745
2746             if (helpid)
2747                 help = resolve_folder(package,helpid,FALSE,FALSE,NULL);
2748             res = RegisterTypeLib(tl_struct.ptLib,tl_struct.path,help);
2749             msi_free(help);
2750
2751             if (!SUCCEEDED(res))
2752                 ERR("Failed to register type library %s\n",
2753                         debugstr_w(tl_struct.path));
2754             else
2755             {
2756                 ui_actiondata(package,szRegisterTypeLibraries,row);
2757
2758                 TRACE("Registered %s\n", debugstr_w(tl_struct.path));
2759             }
2760
2761             ITypeLib_Release(tl_struct.ptLib);
2762             msi_free(tl_struct.path);
2763         }
2764         else
2765             ERR("Failed to load type library %s\n",
2766                     debugstr_w(tl_struct.source));
2767
2768         FreeLibrary(module);
2769         msi_free(tl_struct.source);
2770     }
2771     else
2772         ERR("Could not load file! %s\n", debugstr_w(file->TargetPath));
2773
2774     return ERROR_SUCCESS;
2775 }
2776
2777 static UINT ACTION_RegisterTypeLibraries(MSIPACKAGE *package)
2778 {
2779     /*
2780      * OK this is a bit confusing.. I am given a _Component key and I believe
2781      * that the file that is being registered as a type library is the "key file
2782      * of that component" which I interpret to mean "The file in the KeyPath of
2783      * that component".
2784      */
2785     UINT rc;
2786     MSIQUERY * view;
2787     static const WCHAR Query[] =
2788         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2789          '`','T','y','p','e','L','i','b','`',0};
2790
2791     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
2792     if (rc != ERROR_SUCCESS)
2793         return ERROR_SUCCESS;
2794
2795     rc = MSI_IterateRecords(view, NULL, ITERATE_RegisterTypeLibraries, package);
2796     msiobj_release(&view->hdr);
2797     return rc;
2798 }
2799
2800 static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
2801 {
2802     MSIPACKAGE *package = (MSIPACKAGE*)param;
2803     LPWSTR target_file, target_folder, filename;
2804     LPCWSTR buffer, extension;
2805     MSICOMPONENT *comp;
2806     static const WCHAR szlnk[]={'.','l','n','k',0};
2807     IShellLinkW *sl = NULL;
2808     IPersistFile *pf = NULL;
2809     HRESULT res;
2810
2811     buffer = MSI_RecordGetString(row,4);
2812     comp = get_loaded_component(package,buffer);
2813     if (!comp)
2814         return ERROR_SUCCESS;
2815
2816     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL ))
2817     {
2818         TRACE("Skipping shortcut creation due to disabled component\n");
2819
2820         comp->Action = comp->Installed;
2821
2822         return ERROR_SUCCESS;
2823     }
2824
2825     comp->Action = INSTALLSTATE_LOCAL;
2826
2827     ui_actiondata(package,szCreateShortcuts,row);
2828
2829     res = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
2830                     &IID_IShellLinkW, (LPVOID *) &sl );
2831
2832     if (FAILED( res ))
2833     {
2834         ERR("CLSID_ShellLink not available\n");
2835         goto err;
2836     }
2837
2838     res = IShellLinkW_QueryInterface( sl, &IID_IPersistFile,(LPVOID*) &pf );
2839     if (FAILED( res ))
2840     {
2841         ERR("QueryInterface(IID_IPersistFile) failed\n");
2842         goto err;
2843     }
2844
2845     buffer = MSI_RecordGetString(row,2);
2846     target_folder = resolve_folder(package, buffer,FALSE,FALSE,NULL);
2847
2848     /* may be needed because of a bug somehwere else */
2849     create_full_pathW(target_folder);
2850
2851     filename = msi_dup_record_field( row, 3 );
2852     reduce_to_longfilename(filename);
2853
2854     extension = strchrW(filename,'.');
2855     if (!extension || strcmpiW(extension,szlnk))
2856     {
2857         int len = strlenW(filename);
2858         filename = msi_realloc(filename, len * sizeof(WCHAR) + sizeof(szlnk));
2859         memcpy(filename + len, szlnk, sizeof(szlnk));
2860     }
2861     target_file = build_directory_name(2, target_folder, filename);
2862     msi_free(target_folder);
2863     msi_free(filename);
2864
2865     buffer = MSI_RecordGetString(row,5);
2866     if (strchrW(buffer,'['))
2867     {
2868         LPWSTR deformated;
2869         deformat_string(package,buffer,&deformated);
2870         IShellLinkW_SetPath(sl,deformated);
2871         msi_free(deformated);
2872     }
2873     else
2874     {
2875         FIXME("poorly handled shortcut format, advertised shortcut\n");
2876         IShellLinkW_SetPath(sl,comp->FullKeypath);
2877     }
2878
2879     if (!MSI_RecordIsNull(row,6))
2880     {
2881         LPWSTR deformated;
2882         buffer = MSI_RecordGetString(row,6);
2883         deformat_string(package,buffer,&deformated);
2884         IShellLinkW_SetArguments(sl,deformated);
2885         msi_free(deformated);
2886     }
2887
2888     if (!MSI_RecordIsNull(row,7))
2889     {
2890         buffer = MSI_RecordGetString(row,7);
2891         IShellLinkW_SetDescription(sl,buffer);
2892     }
2893
2894     if (!MSI_RecordIsNull(row,8))
2895         IShellLinkW_SetHotkey(sl,MSI_RecordGetInteger(row,8));
2896
2897     if (!MSI_RecordIsNull(row,9))
2898     {
2899         LPWSTR Path;
2900         INT index;
2901
2902         buffer = MSI_RecordGetString(row,9);
2903
2904         Path = build_icon_path(package,buffer);
2905         index = MSI_RecordGetInteger(row,10);
2906
2907         IShellLinkW_SetIconLocation(sl,Path,index);
2908         msi_free(Path);
2909     }
2910
2911     if (!MSI_RecordIsNull(row,11))
2912         IShellLinkW_SetShowCmd(sl,MSI_RecordGetInteger(row,11));
2913
2914     if (!MSI_RecordIsNull(row,12))
2915     {
2916         LPWSTR Path;
2917         buffer = MSI_RecordGetString(row,12);
2918         Path = resolve_folder(package, buffer, FALSE, FALSE, NULL);
2919         IShellLinkW_SetWorkingDirectory(sl,Path);
2920         msi_free(Path);
2921     }
2922
2923     TRACE("Writing shortcut to %s\n",debugstr_w(target_file));
2924     IPersistFile_Save(pf,target_file,FALSE);
2925
2926     msi_free(target_file);
2927
2928 err:
2929     if (pf)
2930         IPersistFile_Release( pf );
2931     if (sl)
2932         IShellLinkW_Release( sl );
2933
2934     return ERROR_SUCCESS;
2935 }
2936
2937 static UINT ACTION_CreateShortcuts(MSIPACKAGE *package)
2938 {
2939     UINT rc;
2940     HRESULT res;
2941     MSIQUERY * view;
2942     static const WCHAR Query[] =
2943         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2944          '`','S','h','o','r','t','c','u','t','`',0};
2945
2946     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
2947     if (rc != ERROR_SUCCESS)
2948         return ERROR_SUCCESS;
2949
2950     res = CoInitialize( NULL );
2951     if (FAILED (res))
2952     {
2953         ERR("CoInitialize failed\n");
2954         return ERROR_FUNCTION_FAILED;
2955     }
2956
2957     rc = MSI_IterateRecords(view, NULL, ITERATE_CreateShortcuts, package);
2958     msiobj_release(&view->hdr);
2959
2960     CoUninitialize();
2961
2962     return rc;
2963 }
2964
2965 static UINT ITERATE_PublishProduct(MSIRECORD *row, LPVOID param)
2966 {
2967     MSIPACKAGE* package = (MSIPACKAGE*)param;
2968     HANDLE the_file;
2969     LPWSTR FilePath;
2970     LPCWSTR FileName;
2971     CHAR buffer[1024];
2972     DWORD sz;
2973     UINT rc;
2974     MSIRECORD *uirow;
2975
2976     FileName = MSI_RecordGetString(row,1);
2977     if (!FileName)
2978     {
2979         ERR("Unable to get FileName\n");
2980         return ERROR_SUCCESS;
2981     }
2982
2983     FilePath = build_icon_path(package,FileName);
2984
2985     TRACE("Creating icon file at %s\n",debugstr_w(FilePath));
2986
2987     the_file = CreateFileW(FilePath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
2988                         FILE_ATTRIBUTE_NORMAL, NULL);
2989
2990     if (the_file == INVALID_HANDLE_VALUE)
2991     {
2992         ERR("Unable to create file %s\n",debugstr_w(FilePath));
2993         msi_free(FilePath);
2994         return ERROR_SUCCESS;
2995     }
2996
2997     do
2998     {
2999         DWORD write;
3000         sz = 1024;
3001         rc = MSI_RecordReadStream(row,2,buffer,&sz);
3002         if (rc != ERROR_SUCCESS)
3003         {
3004             ERR("Failed to get stream\n");
3005             CloseHandle(the_file);
3006             DeleteFileW(FilePath);
3007             break;
3008         }
3009         WriteFile(the_file,buffer,sz,&write,NULL);
3010     } while (sz == 1024);
3011
3012     msi_free(FilePath);
3013
3014     CloseHandle(the_file);
3015
3016     uirow = MSI_CreateRecord(1);
3017     MSI_RecordSetStringW(uirow,1,FileName);
3018     ui_actiondata(package,szPublishProduct,uirow);
3019     msiobj_release( &uirow->hdr );
3020
3021     return ERROR_SUCCESS;
3022 }
3023
3024 /*
3025  * 99% of the work done here is only done for
3026  * advertised installs. However this is where the
3027  * Icon table is processed and written out
3028  * so that is what I am going to do here.
3029  */
3030 static UINT ACTION_PublishProduct(MSIPACKAGE *package)
3031 {
3032     UINT rc;
3033     MSIQUERY * view;
3034     static const WCHAR Query[]=
3035         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3036          '`','I','c','o','n','`',0};
3037     /* for registry stuff */
3038     HKEY hkey=0;
3039     HKEY hukey=0;
3040     static const WCHAR szProductLanguage[] =
3041         {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
3042     static const WCHAR szARPProductIcon[] =
3043         {'A','R','P','P','R','O','D','U','C','T','I','C','O','N',0};
3044     static const WCHAR szProductVersion[] =
3045         {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
3046     DWORD langid;
3047     LPWSTR buffer;
3048     DWORD size;
3049     MSIHANDLE hDb, hSumInfo;
3050
3051     /* write out icon files */
3052
3053     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3054     if (rc == ERROR_SUCCESS)
3055     {
3056         MSI_IterateRecords(view, NULL, ITERATE_PublishProduct, package);
3057         msiobj_release(&view->hdr);
3058     }
3059
3060     /* ok there is a lot more done here but i need to figure out what */
3061
3062     rc = MSIREG_OpenProductsKey(package->ProductCode,&hkey,TRUE);
3063     if (rc != ERROR_SUCCESS)
3064         goto end;
3065
3066     rc = MSIREG_OpenUserProductsKey(package->ProductCode,&hukey,TRUE);
3067     if (rc != ERROR_SUCCESS)
3068         goto end;
3069
3070
3071     buffer = msi_dup_property( package, INSTALLPROPERTY_PRODUCTNAMEW );
3072     msi_reg_set_val_str( hukey, INSTALLPROPERTY_PRODUCTNAMEW, buffer );
3073     msi_free(buffer);
3074
3075     langid = msi_get_property_int( package, szProductLanguage, 0 );
3076     msi_reg_set_val_dword( hkey, INSTALLPROPERTY_LANGUAGEW, langid );
3077
3078     buffer = msi_dup_property( package, szARPProductIcon );
3079     if (buffer)
3080     {
3081         LPWSTR path = build_icon_path(package,buffer);
3082         msi_reg_set_val_str( hukey, INSTALLPROPERTY_PRODUCTICONW, path );
3083         msi_free( path );
3084     }
3085     msi_free(buffer);
3086
3087     buffer = msi_dup_property( package, szProductVersion );
3088     if (buffer)
3089     {
3090         DWORD verdword = msi_version_str_to_dword(buffer);
3091         msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONW, verdword );
3092     }
3093     msi_free(buffer);
3094
3095     /* FIXME: Need to write more keys to the user registry */
3096
3097     hDb= alloc_msihandle( &package->db->hdr );
3098     rc = MsiGetSummaryInformationW(hDb, NULL, 0, &hSumInfo);
3099     MsiCloseHandle(hDb);
3100     if (rc == ERROR_SUCCESS)
3101     {
3102         WCHAR guidbuffer[0x200];
3103         size = 0x200;
3104         rc = MsiSummaryInfoGetPropertyW(hSumInfo, 9, NULL, NULL, NULL,
3105                                         guidbuffer, &size);
3106         if (rc == ERROR_SUCCESS)
3107         {
3108             WCHAR squashed[GUID_SIZE];
3109             /* for now we only care about the first guid */
3110             LPWSTR ptr = strchrW(guidbuffer,';');
3111             if (ptr) *ptr = 0;
3112             squash_guid(guidbuffer,squashed);
3113             msi_reg_set_val_str( hukey, INSTALLPROPERTY_PACKAGECODEW, squashed );
3114         }
3115         else
3116         {
3117             ERR("Unable to query Revision_Number...\n");
3118             rc = ERROR_SUCCESS;
3119         }
3120         MsiCloseHandle(hSumInfo);
3121     }
3122     else
3123     {
3124         ERR("Unable to open Summary Information\n");
3125         rc = ERROR_SUCCESS;
3126     }
3127
3128 end:
3129
3130     RegCloseKey(hkey);
3131     RegCloseKey(hukey);
3132
3133     return rc;
3134 }
3135
3136 static UINT ITERATE_WriteIniValues(MSIRECORD *row, LPVOID param)
3137 {
3138     MSIPACKAGE *package = (MSIPACKAGE*)param;
3139     LPCWSTR component,section,key,value,identifier,filename,dirproperty;
3140     LPWSTR deformated_section, deformated_key, deformated_value;
3141     LPWSTR folder, fullname = NULL;
3142     MSIRECORD * uirow;
3143     INT action;
3144     MSICOMPONENT *comp;
3145     static const WCHAR szWindowsFolder[] =
3146           {'W','i','n','d','o','w','s','F','o','l','d','e','r',0};
3147
3148     component = MSI_RecordGetString(row, 8);
3149     comp = get_loaded_component(package,component);
3150
3151     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
3152     {
3153         TRACE("Skipping ini file due to disabled component %s\n",
3154                         debugstr_w(component));
3155
3156         comp->Action = comp->Installed;
3157
3158         return ERROR_SUCCESS;
3159     }
3160
3161     comp->Action = INSTALLSTATE_LOCAL;
3162
3163     identifier = MSI_RecordGetString(row,1);
3164     filename = MSI_RecordGetString(row,2);
3165     dirproperty = MSI_RecordGetString(row,3);
3166     section = MSI_RecordGetString(row,4);
3167     key = MSI_RecordGetString(row,5);
3168     value = MSI_RecordGetString(row,6);
3169     action = MSI_RecordGetInteger(row,7);
3170
3171     deformat_string(package,section,&deformated_section);
3172     deformat_string(package,key,&deformated_key);
3173     deformat_string(package,value,&deformated_value);
3174
3175     if (dirproperty)
3176     {
3177         folder = resolve_folder(package, dirproperty, FALSE, FALSE, NULL);
3178         if (!folder)
3179             folder = msi_dup_property( package, dirproperty );
3180     }
3181     else
3182         folder = msi_dup_property( package, szWindowsFolder );
3183
3184     if (!folder)
3185     {
3186         ERR("Unable to resolve folder! (%s)\n",debugstr_w(dirproperty));
3187         goto cleanup;
3188     }
3189
3190     fullname = build_directory_name(2, folder, filename);
3191
3192     if (action == 0)
3193     {
3194         TRACE("Adding value %s to section %s in %s\n",
3195                 debugstr_w(deformated_key), debugstr_w(deformated_section),
3196                 debugstr_w(fullname));
3197         WritePrivateProfileStringW(deformated_section, deformated_key,
3198                                    deformated_value, fullname);
3199     }
3200     else if (action == 1)
3201     {
3202         WCHAR returned[10];
3203         GetPrivateProfileStringW(deformated_section, deformated_key, NULL,
3204                                  returned, 10, fullname);
3205         if (returned[0] == 0)
3206         {
3207             TRACE("Adding value %s to section %s in %s\n",
3208                     debugstr_w(deformated_key), debugstr_w(deformated_section),
3209                     debugstr_w(fullname));
3210
3211             WritePrivateProfileStringW(deformated_section, deformated_key,
3212                                        deformated_value, fullname);
3213         }
3214     }
3215     else if (action == 3)
3216         FIXME("Append to existing section not yet implemented\n");
3217
3218     uirow = MSI_CreateRecord(4);
3219     MSI_RecordSetStringW(uirow,1,identifier);
3220     MSI_RecordSetStringW(uirow,2,deformated_section);
3221     MSI_RecordSetStringW(uirow,3,deformated_key);
3222     MSI_RecordSetStringW(uirow,4,deformated_value);
3223     ui_actiondata(package,szWriteIniValues,uirow);
3224     msiobj_release( &uirow->hdr );
3225 cleanup:
3226     msi_free(fullname);
3227     msi_free(folder);
3228     msi_free(deformated_key);
3229     msi_free(deformated_value);
3230     msi_free(deformated_section);
3231     return ERROR_SUCCESS;
3232 }
3233
3234 static UINT ACTION_WriteIniValues(MSIPACKAGE *package)
3235 {
3236     UINT rc;
3237     MSIQUERY * view;
3238     static const WCHAR ExecSeqQuery[] =
3239         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3240          '`','I','n','i','F','i','l','e','`',0};
3241
3242     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3243     if (rc != ERROR_SUCCESS)
3244     {
3245         TRACE("no IniFile table\n");
3246         return ERROR_SUCCESS;
3247     }
3248
3249     rc = MSI_IterateRecords(view, NULL, ITERATE_WriteIniValues, package);
3250     msiobj_release(&view->hdr);
3251     return rc;
3252 }
3253
3254 static UINT ITERATE_SelfRegModules(MSIRECORD *row, LPVOID param)
3255 {
3256     MSIPACKAGE *package = (MSIPACKAGE*)param;
3257     LPCWSTR filename;
3258     LPWSTR FullName;
3259     MSIFILE *file;
3260     DWORD len;
3261     static const WCHAR ExeStr[] =
3262         {'r','e','g','s','v','r','3','2','.','e','x','e',' ','\"',0};
3263     static const WCHAR close[] =  {'\"',0};
3264     STARTUPINFOW si;
3265     PROCESS_INFORMATION info;
3266     BOOL brc;
3267     MSIRECORD *uirow;
3268     LPWSTR uipath, p;
3269
3270     memset(&si,0,sizeof(STARTUPINFOW));
3271
3272     filename = MSI_RecordGetString(row,1);
3273     file = get_loaded_file( package, filename );
3274
3275     if (!file)
3276     {
3277         ERR("Unable to find file id %s\n",debugstr_w(filename));
3278         return ERROR_SUCCESS;
3279     }
3280
3281     len = strlenW(ExeStr) + strlenW( file->TargetPath ) + 2;
3282
3283     FullName = msi_alloc(len*sizeof(WCHAR));
3284     strcpyW(FullName,ExeStr);
3285     strcatW( FullName, file->TargetPath );
3286     strcatW(FullName,close);
3287
3288     TRACE("Registering %s\n",debugstr_w(FullName));
3289     brc = CreateProcessW(NULL, FullName, NULL, NULL, FALSE, 0, NULL, c_colon,
3290                     &si, &info);
3291
3292     if (brc)
3293         msi_dialog_check_messages(info.hProcess);
3294
3295     msi_free(FullName);
3296
3297     /* the UI chunk */
3298     uirow = MSI_CreateRecord( 2 );
3299     uipath = strdupW( file->TargetPath );
3300     p = strrchrW(uipath,'\\');
3301     if (p)
3302         p[1]=0;
3303     MSI_RecordSetStringW( uirow, 1, &p[2] );
3304     MSI_RecordSetStringW( uirow, 2, uipath);
3305     ui_actiondata( package, szSelfRegModules, uirow);
3306     msiobj_release( &uirow->hdr );
3307     msi_free( uipath );
3308     /* FIXME: call ui_progress? */
3309
3310     return ERROR_SUCCESS;
3311 }
3312
3313 static UINT ACTION_SelfRegModules(MSIPACKAGE *package)
3314 {
3315     UINT rc;
3316     MSIQUERY * view;
3317     static const WCHAR ExecSeqQuery[] =
3318         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3319          '`','S','e','l','f','R','e','g','`',0};
3320
3321     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3322     if (rc != ERROR_SUCCESS)
3323     {
3324         TRACE("no SelfReg table\n");
3325         return ERROR_SUCCESS;
3326     }
3327
3328     MSI_IterateRecords(view, NULL, ITERATE_SelfRegModules, package);
3329     msiobj_release(&view->hdr);
3330
3331     return ERROR_SUCCESS;
3332 }
3333
3334 static UINT ACTION_PublishFeatures(MSIPACKAGE *package)
3335 {
3336     MSIFEATURE *feature;
3337     UINT rc;
3338     HKEY hkey=0;
3339     HKEY hukey=0;
3340
3341     rc = MSIREG_OpenFeaturesKey(package->ProductCode,&hkey,TRUE);
3342     if (rc != ERROR_SUCCESS)
3343         goto end;
3344
3345     rc = MSIREG_OpenUserFeaturesKey(package->ProductCode,&hukey,TRUE);
3346     if (rc != ERROR_SUCCESS)
3347         goto end;
3348
3349     /* here the guids are base 85 encoded */
3350     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
3351     {
3352         ComponentList *cl;
3353         LPWSTR data = NULL;
3354         GUID clsid;
3355         INT size;
3356         BOOL absent = FALSE;
3357         MSIRECORD *uirow;
3358
3359         if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_LOCAL ) &&
3360             !ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_SOURCE ) &&
3361             !ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_ADVERTISED ))
3362             absent = TRUE;
3363
3364         size = 1;
3365         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3366         {
3367             size += 21;
3368         }
3369         if (feature->Feature_Parent)
3370             size += strlenW( feature->Feature_Parent )+2;
3371
3372         data = msi_alloc(size * sizeof(WCHAR));
3373
3374         data[0] = 0;
3375         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3376         {
3377             MSICOMPONENT* component = cl->component;
3378             WCHAR buf[21];
3379
3380             buf[0] = 0;
3381             if (component->ComponentId)
3382             {
3383                 TRACE("From %s\n",debugstr_w(component->ComponentId));
3384                 CLSIDFromString(component->ComponentId, &clsid);
3385                 encode_base85_guid(&clsid,buf);
3386                 TRACE("to %s\n",debugstr_w(buf));
3387                 strcatW(data,buf);
3388             }
3389         }
3390         if (feature->Feature_Parent)
3391         {
3392             static const WCHAR sep[] = {'\2',0};
3393             strcatW(data,sep);
3394             strcatW(data,feature->Feature_Parent);
3395         }
3396
3397         msi_reg_set_val_str( hkey, feature->Feature, data );
3398         msi_free(data);
3399
3400         size = 0;
3401         if (feature->Feature_Parent)
3402             size = strlenW(feature->Feature_Parent)*sizeof(WCHAR);
3403         if (!absent)
3404         {
3405             RegSetValueExW(hukey,feature->Feature,0,REG_SZ,
3406                        (LPBYTE)feature->Feature_Parent,size);
3407         }
3408         else
3409         {
3410             size += 2*sizeof(WCHAR);
3411             data = msi_alloc(size);
3412             data[0] = 0x6;
3413             data[1] = 0;
3414             if (feature->Feature_Parent)
3415                 strcpyW( &data[1], feature->Feature_Parent );
3416             RegSetValueExW(hukey,feature->Feature,0,REG_SZ,
3417                        (LPBYTE)data,size);
3418             msi_free(data);
3419         }
3420
3421         /* the UI chunk */
3422         uirow = MSI_CreateRecord( 1 );
3423         MSI_RecordSetStringW( uirow, 1, feature->Feature );
3424         ui_actiondata( package, szPublishFeatures, uirow);
3425         msiobj_release( &uirow->hdr );
3426         /* FIXME: call ui_progress? */
3427     }
3428
3429 end:
3430     RegCloseKey(hkey);
3431     RegCloseKey(hukey);
3432     return rc;
3433 }
3434
3435 static UINT msi_make_package_local( MSIPACKAGE *package, HKEY hkey )
3436 {
3437     static const WCHAR installerPathFmt[] = {
3438         '%','s','\\','I','n','s','t','a','l','l','e','r','\\',0};
3439     static const WCHAR fmt[] = {
3440         '%','s','\\',
3441         'I','n','s','t','a','l','l','e','r','\\',
3442         '%','x','.','m','s','i',0};
3443     static const WCHAR szOriginalDatabase[] =
3444         {'O','r','i','g','i','n','a','l','D','a','t','a','b','a','s','e',0};
3445     WCHAR windir[MAX_PATH], path[MAX_PATH], packagefile[MAX_PATH];
3446     INT num, start;
3447     LPWSTR msiFilePath;
3448     BOOL r;
3449
3450     /* copy the package locally */
3451     num = GetTickCount() & 0xffff;
3452     if (!num)
3453         num = 1;
3454     start = num;
3455     GetWindowsDirectoryW( windir, MAX_PATH );
3456     snprintfW( packagefile, MAX_PATH, fmt, windir, num );
3457     do
3458     {
3459         HANDLE handle = CreateFileW(packagefile,GENERIC_WRITE, 0, NULL,
3460                                   CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
3461         if (handle != INVALID_HANDLE_VALUE)
3462         {
3463             CloseHandle(handle);
3464             break;
3465         }
3466         if (GetLastError() != ERROR_FILE_EXISTS &&
3467             GetLastError() != ERROR_SHARING_VIOLATION)
3468             break;
3469         if (!(++num & 0xffff)) num = 1;
3470         sprintfW(packagefile,fmt,num);
3471     } while (num != start);
3472
3473     snprintfW( path, MAX_PATH, installerPathFmt, windir );
3474     create_full_pathW(path);
3475
3476     TRACE("Copying to local package %s\n",debugstr_w(packagefile));
3477
3478     msiFilePath = msi_dup_property( package, szOriginalDatabase );
3479     r = CopyFileW( msiFilePath, packagefile, FALSE);
3480     msi_free( msiFilePath );
3481
3482     if (!r)
3483     {
3484         ERR("Unable to copy package (%s -> %s) (error %ld)\n",
3485             debugstr_w(msiFilePath), debugstr_w(packagefile), GetLastError());
3486         return ERROR_FUNCTION_FAILED;
3487     }
3488
3489     /* FIXME: maybe set this key in ACTION_RegisterProduct instead */
3490     msi_reg_set_val_str( hkey, INSTALLPROPERTY_LOCALPACKAGEW, packagefile );
3491     return ERROR_SUCCESS;
3492 }
3493
3494 static UINT msi_write_uninstall_property_vals( MSIPACKAGE *package, HKEY hkey )
3495 {
3496     LPWSTR prop, val, key;
3497     static const LPCSTR propval[] = {
3498         "ARPAUTHORIZEDCDFPREFIX", "AuthorizedCDFPrefix",
3499         "ARPCONTACT",             "Contact",
3500         "ARPCOMMENTS",            "Comments",
3501         "ProductName",            "DisplayName",
3502         "ProductVersion",         "DisplayVersion",
3503         "ARPHELPLINK",            "HelpLink",
3504         "ARPHELPTELEPHONE",       "HelpTelephone",
3505         "ARPINSTALLLOCATION",     "InstallLocation",
3506         "SourceDir",              "InstallSource",
3507         "Manufacturer",           "Publisher",
3508         "ARPREADME",              "Readme",
3509         "ARPSIZE",                "Size",
3510         "ARPURLINFOABOUT",        "URLInfoAbout",
3511         "ARPURLUPDATEINFO",       "URLUpdateInfo",
3512         NULL,
3513     };
3514     const LPCSTR *p = propval;
3515
3516     while( *p )
3517     {
3518         prop = strdupAtoW( *p++ );
3519         key = strdupAtoW( *p++ );
3520         val = msi_dup_property( package, prop );
3521         msi_reg_set_val_str( hkey, key, val );
3522         msi_free(val);
3523         msi_free(key);
3524         msi_free(prop);
3525     }
3526     return ERROR_SUCCESS;
3527 }
3528
3529 static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
3530 {
3531     HKEY hkey=0;
3532     LPWSTR buffer = NULL;
3533     UINT rc;
3534     DWORD size, langid;
3535     static const WCHAR szWindowsInstaller[] =
3536         {'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
3537     static const WCHAR szUpgradeCode[] =
3538         {'U','p','g','r','a','d','e','C','o','d','e',0};
3539     static const WCHAR modpath_fmt[] =
3540         {'M','s','i','E','x','e','c','.','e','x','e',' ',
3541          '/','I','[','P','r','o','d','u','c','t','C','o','d','e',']',0};
3542     static const WCHAR szModifyPath[] =
3543         {'M','o','d','i','f','y','P','a','t','h',0};
3544     static const WCHAR szUninstallString[] =
3545         {'U','n','i','n','s','t','a','l','l','S','t','r','i','n','g',0};
3546     static const WCHAR szEstimatedSize[] =
3547         {'E','s','t','i','m','a','t','e','d','S','i','z','e',0};
3548     static const WCHAR szProductLanguage[] =
3549         {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
3550     static const WCHAR szProductVersion[] =
3551         {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
3552
3553     SYSTEMTIME systime;
3554     static const WCHAR date_fmt[] = {'%','i','%','i','%','i',0};
3555     LPWSTR upgrade_code;
3556     WCHAR szDate[9];
3557
3558     rc = MSIREG_OpenUninstallKey(package->ProductCode,&hkey,TRUE);
3559     if (rc != ERROR_SUCCESS)
3560         return rc;
3561
3562     /* dump all the info i can grab */
3563     /* FIXME: Flesh out more information */
3564
3565     msi_write_uninstall_property_vals( package, hkey );
3566
3567     msi_reg_set_val_dword( hkey, szWindowsInstaller, 1 );
3568
3569     msi_make_package_local( package, hkey );
3570
3571     /* do ModifyPath and UninstallString */
3572     size = deformat_string(package,modpath_fmt,&buffer);
3573     RegSetValueExW(hkey,szModifyPath,0,REG_EXPAND_SZ,(LPBYTE)buffer,size);
3574     RegSetValueExW(hkey,szUninstallString,0,REG_EXPAND_SZ,(LPBYTE)buffer,size);
3575     msi_free(buffer);
3576
3577     /* FIXME: Write real Estimated Size when we have it */
3578     msi_reg_set_val_dword( hkey, szEstimatedSize, 0 );
3579
3580     GetLocalTime(&systime);
3581     sprintfW(szDate,date_fmt,systime.wYear,systime.wMonth,systime.wDay);
3582     msi_reg_set_val_str( hkey, INSTALLPROPERTY_INSTALLDATEW, szDate );
3583
3584     langid = msi_get_property_int( package, szProductLanguage, 0 );
3585     msi_reg_set_val_dword( hkey, INSTALLPROPERTY_LANGUAGEW, langid );
3586
3587     buffer = msi_dup_property( package, szProductVersion );
3588     if (buffer)
3589     {
3590         DWORD verdword = msi_version_str_to_dword(buffer);
3591
3592         msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONW, verdword );
3593         msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONMAJORW, verdword>>24 );
3594         msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONMINORW, (verdword>>16)&0x00FF );
3595     }
3596     msi_free(buffer);
3597
3598     /* Handle Upgrade Codes */
3599     upgrade_code = msi_dup_property( package, szUpgradeCode );
3600     if (upgrade_code)
3601     {
3602         HKEY hkey2;
3603         WCHAR squashed[33];
3604         MSIREG_OpenUpgradeCodesKey(upgrade_code, &hkey2, TRUE);
3605         squash_guid(package->ProductCode,squashed);
3606         msi_reg_set_val_str( hkey2, squashed, NULL );
3607         RegCloseKey(hkey2);
3608         MSIREG_OpenUserUpgradeCodesKey(upgrade_code, &hkey2, TRUE);
3609         squash_guid(package->ProductCode,squashed);
3610         msi_reg_set_val_str( hkey2, squashed, NULL );
3611         RegCloseKey(hkey2);
3612
3613         msi_free(upgrade_code);
3614     }
3615
3616     RegCloseKey(hkey);
3617
3618     /* FIXME: call ui_actiondata */
3619
3620     return ERROR_SUCCESS;
3621 }
3622
3623 static UINT ACTION_InstallExecute(MSIPACKAGE *package)
3624 {
3625     return execute_script(package,INSTALL_SCRIPT);
3626 }
3627
3628 static UINT ACTION_InstallFinalize(MSIPACKAGE *package)
3629 {
3630     UINT rc;
3631
3632     /* turn off scheduleing */
3633     package->script->CurrentlyScripting= FALSE;
3634
3635     /* first do the same as an InstallExecute */
3636     rc = ACTION_InstallExecute(package);
3637     if (rc != ERROR_SUCCESS)
3638         return rc;
3639
3640     /* then handle Commit Actions */
3641     rc = execute_script(package,COMMIT_SCRIPT);
3642
3643     return rc;
3644 }
3645
3646 static UINT ACTION_ForceReboot(MSIPACKAGE *package)
3647 {
3648     static const WCHAR RunOnce[] = {
3649     'S','o','f','t','w','a','r','e','\\',
3650     'M','i','c','r','o','s','o','f','t','\\',
3651     'W','i','n','d','o','w','s','\\',
3652     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3653     'R','u','n','O','n','c','e',0};
3654     static const WCHAR InstallRunOnce[] = {
3655     'S','o','f','t','w','a','r','e','\\',
3656     'M','i','c','r','o','s','o','f','t','\\',
3657     'W','i','n','d','o','w','s','\\',
3658     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3659     'I','n','s','t','a','l','l','e','r','\\',
3660     'R','u','n','O','n','c','e','E','n','t','r','i','e','s',0};
3661
3662     static const WCHAR msiexec_fmt[] = {
3663     '%','s',
3664     '\\','M','s','i','E','x','e','c','.','e','x','e',' ','/','@',' ',
3665     '\"','%','s','\"',0};
3666     static const WCHAR install_fmt[] = {
3667     '/','I',' ','\"','%','s','\"',' ',
3668     'A','F','T','E','R','R','E','B','O','O','T','=','1',' ',
3669     'R','U','N','O','N','C','E','E','N','T','R','Y','=','\"','%','s','\"',0};
3670     WCHAR buffer[256], sysdir[MAX_PATH];
3671     HKEY hkey;
3672     WCHAR squished_pc[100];
3673
3674     squash_guid(package->ProductCode,squished_pc);
3675
3676     GetSystemDirectoryW(sysdir, sizeof(sysdir)/sizeof(sysdir[0]));
3677     RegCreateKeyW(HKEY_LOCAL_MACHINE,RunOnce,&hkey);
3678     snprintfW(buffer,sizeof(buffer)/sizeof(buffer[0]),msiexec_fmt,sysdir,
3679      squished_pc);
3680
3681     msi_reg_set_val_str( hkey, squished_pc, buffer );
3682     RegCloseKey(hkey);
3683
3684     TRACE("Reboot command %s\n",debugstr_w(buffer));
3685
3686     RegCreateKeyW(HKEY_LOCAL_MACHINE,InstallRunOnce,&hkey);
3687     sprintfW(buffer,install_fmt,package->ProductCode,squished_pc);
3688
3689     msi_reg_set_val_str( hkey, squished_pc, buffer );
3690     RegCloseKey(hkey);
3691
3692     return ERROR_INSTALL_SUSPEND;
3693 }
3694
3695 UINT ACTION_ResolveSource(MSIPACKAGE* package)
3696 {
3697     DWORD attrib;
3698     UINT rc;
3699     /*
3700      * we are currently doing what should be done here in the top level Install
3701      * however for Adminastrative and uninstalls this step will be needed
3702      */
3703     if (!package->PackagePath)
3704         return ERROR_SUCCESS;
3705
3706     attrib = GetFileAttributesW(package->PackagePath);
3707     if (attrib == INVALID_FILE_ATTRIBUTES)
3708     {
3709         LPWSTR prompt;
3710         LPWSTR msg;
3711         DWORD size = 0;
3712
3713         rc = MsiSourceListGetInfoW(package->ProductCode, NULL,
3714                 MSIINSTALLCONTEXT_USERMANAGED, MSICODE_PRODUCT,
3715                 INSTALLPROPERTY_DISKPROMPTW,NULL,&size);
3716         if (rc == ERROR_MORE_DATA)
3717         {
3718             prompt = msi_alloc(size * sizeof(WCHAR));
3719             MsiSourceListGetInfoW(package->ProductCode, NULL,
3720                     MSIINSTALLCONTEXT_USERMANAGED, MSICODE_PRODUCT,
3721                     INSTALLPROPERTY_DISKPROMPTW,prompt,&size);
3722         }
3723         else
3724             prompt = strdupW(package->PackagePath);
3725
3726         msg = generate_error_string(package,1302,1,prompt);
3727         while(attrib == INVALID_FILE_ATTRIBUTES)
3728         {
3729             rc = MessageBoxW(NULL,msg,NULL,MB_OKCANCEL);
3730             if (rc == IDCANCEL)
3731             {
3732                 rc = ERROR_INSTALL_USEREXIT;
3733                 break;
3734             }
3735             attrib = GetFileAttributesW(package->PackagePath);
3736         }
3737         msi_free(prompt);
3738         rc = ERROR_SUCCESS;
3739     }
3740     else
3741         return ERROR_SUCCESS;
3742
3743     return rc;
3744 }
3745
3746 static UINT ACTION_RegisterUser(MSIPACKAGE *package)
3747 {
3748     HKEY hkey=0;
3749     LPWSTR buffer;
3750     LPWSTR productid;
3751     UINT rc,i;
3752
3753     static const WCHAR szPropKeys[][80] =
3754     {
3755         {'P','r','o','d','u','c','t','I','D',0},
3756         {'U','S','E','R','N','A','M','E',0},
3757         {'C','O','M','P','A','N','Y','N','A','M','E',0},
3758         {0},
3759     };
3760
3761     static const WCHAR szRegKeys[][80] =
3762     {
3763         {'P','r','o','d','u','c','t','I','D',0},
3764         {'R','e','g','O','w','n','e','r',0},
3765         {'R','e','g','C','o','m','p','a','n','y',0},
3766         {0},
3767     };
3768
3769     productid = msi_dup_property( package, INSTALLPROPERTY_PRODUCTIDW );
3770     if (!productid)
3771         return ERROR_SUCCESS;
3772
3773     rc = MSIREG_OpenUninstallKey(package->ProductCode,&hkey,TRUE);
3774     if (rc != ERROR_SUCCESS)
3775         goto end;
3776
3777     for( i = 0; szPropKeys[i][0]; i++ )
3778     {
3779         buffer = msi_dup_property( package, szPropKeys[i] );
3780         msi_reg_set_val_str( hkey, szRegKeys[i], buffer );
3781         msi_free( buffer );
3782     }
3783
3784 end:
3785     msi_free(productid);
3786     RegCloseKey(hkey);
3787
3788     /* FIXME: call ui_actiondata */
3789
3790     return ERROR_SUCCESS;
3791 }
3792
3793
3794 static UINT ACTION_ExecuteAction(MSIPACKAGE *package)
3795 {
3796     UINT rc;
3797
3798     package->script->InWhatSequence |= SEQUENCE_EXEC;
3799     rc = ACTION_ProcessExecSequence(package,FALSE);
3800     return rc;
3801 }
3802
3803
3804 /*
3805  * Code based off of code located here
3806  * http://www.codeproject.com/gdi/fontnamefromfile.asp
3807  *
3808  * Using string index 4 (full font name) instead of 1 (family name)
3809  */
3810 static LPWSTR load_ttfname_from(LPCWSTR filename)
3811 {
3812     HANDLE handle;
3813     LPWSTR ret = NULL;
3814     int i;
3815
3816     typedef struct _tagTT_OFFSET_TABLE{
3817         USHORT uMajorVersion;
3818         USHORT uMinorVersion;
3819         USHORT uNumOfTables;
3820         USHORT uSearchRange;
3821         USHORT uEntrySelector;
3822         USHORT uRangeShift;
3823     }TT_OFFSET_TABLE;
3824
3825     typedef struct _tagTT_TABLE_DIRECTORY{
3826         char szTag[4]; /* table name */
3827         ULONG uCheckSum; /* Check sum */
3828         ULONG uOffset; /* Offset from beginning of file */
3829         ULONG uLength; /* length of the table in bytes */
3830     }TT_TABLE_DIRECTORY;
3831
3832     typedef struct _tagTT_NAME_TABLE_HEADER{
3833     USHORT uFSelector; /* format selector. Always 0 */
3834     USHORT uNRCount; /* Name Records count */
3835     USHORT uStorageOffset; /* Offset for strings storage,
3836                             * from start of the table */
3837     }TT_NAME_TABLE_HEADER;
3838
3839     typedef struct _tagTT_NAME_RECORD{
3840         USHORT uPlatformID;
3841         USHORT uEncodingID;
3842         USHORT uLanguageID;
3843         USHORT uNameID;
3844         USHORT uStringLength;
3845         USHORT uStringOffset; /* from start of storage area */
3846     }TT_NAME_RECORD;
3847
3848 #define SWAPWORD(x) MAKEWORD(HIBYTE(x), LOBYTE(x))
3849 #define SWAPLONG(x) MAKELONG(SWAPWORD(HIWORD(x)), SWAPWORD(LOWORD(x)))
3850
3851     handle = CreateFileW(filename ,GENERIC_READ, 0, NULL, OPEN_EXISTING,
3852                     FILE_ATTRIBUTE_NORMAL, 0 );
3853     if (handle != INVALID_HANDLE_VALUE)
3854     {
3855         TT_TABLE_DIRECTORY tblDir;
3856         BOOL bFound = FALSE;
3857         TT_OFFSET_TABLE ttOffsetTable;
3858         DWORD dwRead;
3859
3860         ReadFile(handle,&ttOffsetTable, sizeof(TT_OFFSET_TABLE),&dwRead,NULL);
3861         ttOffsetTable.uNumOfTables = SWAPWORD(ttOffsetTable.uNumOfTables);
3862         ttOffsetTable.uMajorVersion = SWAPWORD(ttOffsetTable.uMajorVersion);
3863         ttOffsetTable.uMinorVersion = SWAPWORD(ttOffsetTable.uMinorVersion);
3864
3865         if (ttOffsetTable.uMajorVersion != 1 ||
3866                         ttOffsetTable.uMinorVersion != 0)
3867             return NULL;
3868
3869         for (i=0; i< ttOffsetTable.uNumOfTables; i++)
3870         {
3871             ReadFile(handle,&tblDir, sizeof(TT_TABLE_DIRECTORY),&dwRead,NULL);
3872             if (strncmp(tblDir.szTag,"name",4)==0)
3873             {
3874                 bFound = TRUE;
3875                 tblDir.uLength = SWAPLONG(tblDir.uLength);
3876                 tblDir.uOffset = SWAPLONG(tblDir.uOffset);
3877                 break;
3878             }
3879         }
3880
3881         if (bFound)
3882         {
3883             TT_NAME_TABLE_HEADER ttNTHeader;
3884             TT_NAME_RECORD ttRecord;
3885
3886             SetFilePointer(handle, tblDir.uOffset, NULL, FILE_BEGIN);
3887             ReadFile(handle,&ttNTHeader, sizeof(TT_NAME_TABLE_HEADER),
3888                             &dwRead,NULL);
3889
3890             ttNTHeader.uNRCount = SWAPWORD(ttNTHeader.uNRCount);
3891             ttNTHeader.uStorageOffset = SWAPWORD(ttNTHeader.uStorageOffset);
3892             bFound = FALSE;
3893             for(i=0; i<ttNTHeader.uNRCount; i++)
3894             {
3895                 ReadFile(handle,&ttRecord, sizeof(TT_NAME_RECORD),&dwRead,NULL);
3896                 ttRecord.uNameID = SWAPWORD(ttRecord.uNameID);
3897                 /* 4 is the Full Font Name */
3898                 if(ttRecord.uNameID == 4)
3899                 {
3900                     int nPos;
3901                     LPSTR buf;
3902                     static LPCSTR tt = " (TrueType)";
3903
3904                     ttRecord.uStringLength = SWAPWORD(ttRecord.uStringLength);
3905                     ttRecord.uStringOffset = SWAPWORD(ttRecord.uStringOffset);
3906                     nPos = SetFilePointer(handle, 0, NULL, FILE_CURRENT);
3907                     SetFilePointer(handle, tblDir.uOffset +
3908                                     ttRecord.uStringOffset +
3909                                     ttNTHeader.uStorageOffset,
3910                                     NULL, FILE_BEGIN);
3911                     buf = msi_alloc_zero( ttRecord.uStringLength + 1 + strlen(tt) );
3912                     ReadFile(handle, buf, ttRecord.uStringLength, &dwRead, NULL);
3913                     if (strlen(buf) > 0)
3914                     {
3915                         strcat(buf,tt);
3916                         ret = strdupAtoW(buf);
3917                         msi_free(buf);
3918                         break;
3919                     }
3920
3921                     msi_free(buf);
3922                     SetFilePointer(handle,nPos, NULL, FILE_BEGIN);
3923                 }
3924             }
3925         }
3926         CloseHandle(handle);
3927     }
3928     else
3929         ERR("Unable to open font file %s\n", debugstr_w(filename));
3930
3931     TRACE("Returning fontname %s\n",debugstr_w(ret));
3932     return ret;
3933 }
3934
3935 static UINT ITERATE_RegisterFonts(MSIRECORD *row, LPVOID param)
3936 {
3937     MSIPACKAGE *package = (MSIPACKAGE*)param;
3938     LPWSTR name;
3939     LPCWSTR filename;
3940     MSIFILE *file;
3941     static const WCHAR regfont1[] =
3942         {'S','o','f','t','w','a','r','e','\\',
3943          'M','i','c','r','o','s','o','f','t','\\',
3944          'W','i','n','d','o','w','s',' ','N','T','\\',
3945          'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3946          'F','o','n','t','s',0};
3947     static const WCHAR regfont2[] =
3948         {'S','o','f','t','w','a','r','e','\\',
3949          'M','i','c','r','o','s','o','f','t','\\',
3950          'W','i','n','d','o','w','s','\\',
3951          'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3952          'F','o','n','t','s',0};
3953     HKEY hkey1;
3954     HKEY hkey2;
3955     MSIRECORD *uirow;
3956     LPWSTR uipath, p;
3957
3958     filename = MSI_RecordGetString( row, 1 );
3959     file = get_loaded_file( package, filename );
3960     if (!file)
3961     {
3962         ERR("Unable to load file\n");
3963         return ERROR_SUCCESS;
3964     }
3965
3966     /* check to make sure that component is installed */
3967     if (!ACTION_VerifyComponentForAction( file->Component, INSTALLSTATE_LOCAL))
3968     {
3969         TRACE("Skipping: Component not scheduled for install\n");
3970         return ERROR_SUCCESS;
3971     }
3972
3973     RegCreateKeyW(HKEY_LOCAL_MACHINE,regfont1,&hkey1);
3974     RegCreateKeyW(HKEY_LOCAL_MACHINE,regfont2,&hkey2);
3975
3976     if (MSI_RecordIsNull(row,2))
3977         name = load_ttfname_from( file->TargetPath );
3978     else
3979         name = msi_dup_record_field(row,2);
3980
3981     if (name)
3982     {
3983         msi_reg_set_val_str( hkey1, name, file->FileName );
3984         msi_reg_set_val_str( hkey2, name, file->FileName );
3985     }
3986
3987     msi_free(name);
3988     RegCloseKey(hkey1);
3989     RegCloseKey(hkey2);
3990
3991     /* the UI chunk */
3992     uirow = MSI_CreateRecord( 1 );
3993     uipath = strdupW( file->TargetPath );
3994     p = strrchrW(uipath,'\\');
3995     if (p) p++;
3996     else p = uipath;
3997     MSI_RecordSetStringW( uirow, 1, p );
3998     ui_actiondata( package, szRegisterFonts, uirow);
3999     msiobj_release( &uirow->hdr );
4000     msi_free( uipath );
4001     /* FIXME: call ui_progress? */
4002
4003     return ERROR_SUCCESS;
4004 }
4005
4006 static UINT ACTION_RegisterFonts(MSIPACKAGE *package)
4007 {
4008     UINT rc;
4009     MSIQUERY * view;
4010     static const WCHAR ExecSeqQuery[] =
4011         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4012          '`','F','o','n','t','`',0};
4013
4014     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4015     if (rc != ERROR_SUCCESS)
4016     {
4017         TRACE("MSI_DatabaseOpenViewW failed: %d\n", rc);
4018         return ERROR_SUCCESS;
4019     }
4020
4021     MSI_IterateRecords(view, NULL, ITERATE_RegisterFonts, package);
4022     msiobj_release(&view->hdr);
4023
4024     return ERROR_SUCCESS;
4025 }
4026
4027 static UINT ITERATE_PublishComponent(MSIRECORD *rec, LPVOID param)
4028 {
4029     MSIPACKAGE *package = (MSIPACKAGE*)param;
4030     LPCWSTR compgroupid=NULL;
4031     LPCWSTR feature=NULL;
4032     LPCWSTR text = NULL;
4033     LPCWSTR qualifier = NULL;
4034     LPCWSTR component = NULL;
4035     LPWSTR advertise = NULL;
4036     LPWSTR output = NULL;
4037     HKEY hkey;
4038     UINT rc = ERROR_SUCCESS;
4039     MSICOMPONENT *comp;
4040     DWORD sz = 0;
4041     MSIRECORD *uirow;
4042
4043     component = MSI_RecordGetString(rec,3);
4044     comp = get_loaded_component(package,component);
4045
4046     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL ) &&
4047        !ACTION_VerifyComponentForAction( comp, INSTALLSTATE_SOURCE ) &&
4048        !ACTION_VerifyComponentForAction( comp, INSTALLSTATE_ADVERTISED ))
4049     {
4050         TRACE("Skipping: Component %s not scheduled for install\n",
4051                         debugstr_w(component));
4052
4053         return ERROR_SUCCESS;
4054     }
4055
4056     compgroupid = MSI_RecordGetString(rec,1);
4057     qualifier = MSI_RecordGetString(rec,2);
4058
4059     rc = MSIREG_OpenUserComponentsKey(compgroupid, &hkey, TRUE);
4060     if (rc != ERROR_SUCCESS)
4061         goto end;
4062
4063     text = MSI_RecordGetString(rec,4);
4064     feature = MSI_RecordGetString(rec,5);
4065
4066     advertise = create_component_advertise_string(package, comp, feature);
4067
4068     sz = strlenW(advertise);
4069
4070     if (text)
4071         sz += lstrlenW(text);
4072
4073     sz+=3;
4074     sz *= sizeof(WCHAR);
4075
4076     output = msi_alloc_zero(sz);
4077     strcpyW(output,advertise);
4078     msi_free(advertise);
4079
4080     if (text)
4081         strcatW(output,text);
4082
4083     msi_reg_set_val_multi_str( hkey, qualifier, output );
4084
4085 end:
4086     RegCloseKey(hkey);
4087     msi_free(output);
4088
4089     /* the UI chunk */
4090     uirow = MSI_CreateRecord( 2 );
4091     MSI_RecordSetStringW( uirow, 1, compgroupid );
4092     MSI_RecordSetStringW( uirow, 2, qualifier);
4093     ui_actiondata( package, szPublishComponents, uirow);
4094     msiobj_release( &uirow->hdr );
4095     /* FIXME: call ui_progress? */
4096
4097     return rc;
4098 }
4099
4100 /*
4101  * At present I am ignorning the advertised components part of this and only
4102  * focusing on the qualified component sets
4103  */
4104 static UINT ACTION_PublishComponents(MSIPACKAGE *package)
4105 {
4106     UINT rc;
4107     MSIQUERY * view;
4108     static const WCHAR ExecSeqQuery[] =
4109         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4110          '`','P','u','b','l','i','s','h',
4111          'C','o','m','p','o','n','e','n','t','`',0};
4112
4113     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4114     if (rc != ERROR_SUCCESS)
4115         return ERROR_SUCCESS;
4116
4117     rc = MSI_IterateRecords(view, NULL, ITERATE_PublishComponent, package);
4118     msiobj_release(&view->hdr);
4119
4120     return rc;
4121 }
4122
4123 static UINT msi_unimplemented_action_stub( MSIPACKAGE *package,
4124                                            LPCSTR action, LPCWSTR table )
4125 {
4126     static const WCHAR query[] = {
4127         'S','E','L','E','C','T',' ','*',' ',
4128         'F','R','O','M',' ','`','%','s','`',0 };
4129     MSIQUERY *view = NULL;
4130     DWORD count = 0;
4131     UINT r;
4132
4133     r = MSI_OpenQuery( package->db, &view, query, table );
4134     if (r == ERROR_SUCCESS)
4135     {
4136         r = MSI_IterateRecords(view, &count, NULL, package);
4137         msiobj_release(&view->hdr);
4138     }
4139
4140     if (count)
4141         FIXME("%s -> %lu ignored %s table values\n",
4142               action, count, debugstr_w(table));
4143
4144     return ERROR_SUCCESS;
4145 }
4146
4147 static UINT ACTION_AllocateRegistrySpace( MSIPACKAGE *package )
4148 {
4149     TRACE("%p\n", package);
4150     return ERROR_SUCCESS;
4151 }
4152
4153 static UINT ACTION_RemoveIniValues( MSIPACKAGE *package )
4154 {
4155     static const WCHAR table[] =
4156          {'R','e','m','o','v','e','I','n','i','F','i','l','e',0 };
4157     return msi_unimplemented_action_stub( package, "RemoveIniValues", table );
4158 }
4159
4160 static UINT ACTION_MoveFiles( MSIPACKAGE *package )
4161 {
4162     static const WCHAR table[] = { 'M','o','v','e','F','i','l','e',0 };
4163     return msi_unimplemented_action_stub( package, "MoveFiles", table );
4164 }
4165
4166 static UINT ACTION_PatchFiles( MSIPACKAGE *package )
4167 {
4168     static const WCHAR table[] = { 'P','a','t','c','h',0 };
4169     return msi_unimplemented_action_stub( package, "PatchFiles", table );
4170 }
4171
4172 static UINT ACTION_BindImage( MSIPACKAGE *package )
4173 {
4174     static const WCHAR table[] = { 'B','i','n','d','I','m','a','g','e',0 };
4175     return msi_unimplemented_action_stub( package, "BindImage", table );
4176 }
4177
4178 static UINT ACTION_IsolateComponents( MSIPACKAGE *package )
4179 {
4180     static const WCHAR table[] = {
4181         'I','s','o','l','a','t','e','C','o','m','p','o','n','e','n','t',0 };
4182     return msi_unimplemented_action_stub( package, "IsolateComponents", table );
4183 }
4184
4185 static UINT ACTION_MigrateFeatureStates( MSIPACKAGE *package )
4186 {
4187     static const WCHAR table[] = { 'U','p','g','r','a','d','e',0 };
4188     return msi_unimplemented_action_stub( package, "MigrateFeatureStates", table );
4189 }
4190
4191 static UINT ACTION_SelfUnregModules( MSIPACKAGE *package )
4192 {
4193     static const WCHAR table[] = { 'S','e','l','f','R','e','g',0 };
4194     return msi_unimplemented_action_stub( package, "SelfUnregModules", table );
4195 }
4196
4197 static UINT ACTION_InstallServices( MSIPACKAGE *package )
4198 {
4199     static const WCHAR table[] = {
4200         'S','e','r','v','i','c','e','I','n','s','t','a','l','l',0 };
4201     return msi_unimplemented_action_stub( package, "InstallServices", table );
4202 }
4203
4204 static UINT ACTION_StartServices( MSIPACKAGE *package )
4205 {
4206     static const WCHAR table[] = {
4207         'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
4208     return msi_unimplemented_action_stub( package, "StartServices", table );
4209 }
4210
4211 static UINT ACTION_StopServices( MSIPACKAGE *package )
4212 {
4213     static const WCHAR table[] = {
4214         'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
4215     return msi_unimplemented_action_stub( package, "StopServices", table );
4216 }
4217
4218 static UINT ACTION_DeleteServices( MSIPACKAGE *package )
4219 {
4220     static const WCHAR table[] = {
4221         'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
4222     return msi_unimplemented_action_stub( package, "DeleteServices", table );
4223 }
4224
4225 static UINT ACTION_WriteEnvironmentStrings( MSIPACKAGE *package )
4226 {
4227     static const WCHAR table[] = {
4228         'E','n','v','i','r','o','n','m','e','n','t',0 };
4229     return msi_unimplemented_action_stub( package, "WriteEnvironmentStrings", table );
4230 }
4231
4232 static UINT ACTION_RemoveEnvironmentStrings( MSIPACKAGE *package )
4233 {
4234     static const WCHAR table[] = {
4235         'E','n','v','i','r','o','n','m','e','n','t',0 };
4236     return msi_unimplemented_action_stub( package, "RemoveEnvironmentStrings", table );
4237 }
4238
4239 static UINT ACTION_MsiPublishAssemblies( MSIPACKAGE *package )
4240 {
4241     static const WCHAR table[] = {
4242         'M','s','i','A','s','s','e','m','b','l','y',0 };
4243     return msi_unimplemented_action_stub( package, "MsiPublishAssemblies", table );
4244 }
4245
4246 static UINT ACTION_MsiUnpublishAssemblies( MSIPACKAGE *package )
4247 {
4248     static const WCHAR table[] = {
4249         'M','s','i','A','s','s','e','m','b','l','y',0 };
4250     return msi_unimplemented_action_stub( package, "MsiUnpublishAssemblies", table );
4251 }
4252
4253 static UINT ACTION_UnregisterFonts( MSIPACKAGE *package )
4254 {
4255     static const WCHAR table[] = { 'F','o','n','t',0 };
4256     return msi_unimplemented_action_stub( package, "UnregisterFonts", table );
4257 }
4258
4259 static UINT ACTION_CCPSearch( MSIPACKAGE *package )
4260 {
4261     static const WCHAR table[] = { 'C','C','P','S','e','a','r','c','h',0 };
4262     return msi_unimplemented_action_stub( package, "CCPSearch", table );
4263 }
4264
4265 static UINT ACTION_RMCCPSearch( MSIPACKAGE *package )
4266 {
4267     static const WCHAR table[] = { 'C','C','P','S','e','a','r','c','h',0 };
4268     return msi_unimplemented_action_stub( package, "RMCCPSearch", table );
4269 }
4270
4271 static UINT ACTION_RegisterComPlus( MSIPACKAGE *package )
4272 {
4273     static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
4274     return msi_unimplemented_action_stub( package, "RegisterComPlus", table );
4275 }
4276
4277 static UINT ACTION_UnregisterComPlus( MSIPACKAGE *package )
4278 {
4279     static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
4280     return msi_unimplemented_action_stub( package, "UnregisterComPlus", table );
4281 }
4282
4283 static struct _actions StandardActions[] = {
4284     { szAllocateRegistrySpace, ACTION_AllocateRegistrySpace },
4285     { szAppSearch, ACTION_AppSearch },
4286     { szBindImage, ACTION_BindImage },
4287     { szCCPSearch, ACTION_CCPSearch},
4288     { szCostFinalize, ACTION_CostFinalize },
4289     { szCostInitialize, ACTION_CostInitialize },
4290     { szCreateFolders, ACTION_CreateFolders },
4291     { szCreateShortcuts, ACTION_CreateShortcuts },
4292     { szDeleteServices, ACTION_DeleteServices },
4293     { szDisableRollback, NULL},
4294     { szDuplicateFiles, ACTION_DuplicateFiles },
4295     { szExecuteAction, ACTION_ExecuteAction },
4296     { szFileCost, ACTION_FileCost },
4297     { szFindRelatedProducts, ACTION_FindRelatedProducts },
4298     { szForceReboot, ACTION_ForceReboot },
4299     { szInstallAdminPackage, NULL},
4300     { szInstallExecute, ACTION_InstallExecute },
4301     { szInstallExecuteAgain, ACTION_InstallExecute },
4302     { szInstallFiles, ACTION_InstallFiles},
4303     { szInstallFinalize, ACTION_InstallFinalize },
4304     { szInstallInitialize, ACTION_InstallInitialize },
4305     { szInstallSFPCatalogFile, NULL},
4306     { szInstallValidate, ACTION_InstallValidate },
4307     { szIsolateComponents, ACTION_IsolateComponents },
4308     { szLaunchConditions, ACTION_LaunchConditions },
4309     { szMigrateFeatureStates, ACTION_MigrateFeatureStates },
4310     { szMoveFiles, ACTION_MoveFiles },
4311     { szMsiPublishAssemblies, ACTION_MsiPublishAssemblies },
4312     { szMsiUnpublishAssemblies, ACTION_MsiUnpublishAssemblies },
4313     { szInstallODBC, NULL},
4314     { szInstallServices, ACTION_InstallServices },
4315     { szPatchFiles, ACTION_PatchFiles },
4316     { szProcessComponents, ACTION_ProcessComponents },
4317     { szPublishComponents, ACTION_PublishComponents },
4318     { szPublishFeatures, ACTION_PublishFeatures },
4319     { szPublishProduct, ACTION_PublishProduct },
4320     { szRegisterClassInfo, ACTION_RegisterClassInfo },
4321     { szRegisterComPlus, ACTION_RegisterComPlus},
4322     { szRegisterExtensionInfo, ACTION_RegisterExtensionInfo },
4323     { szRegisterFonts, ACTION_RegisterFonts },
4324     { szRegisterMIMEInfo, ACTION_RegisterMIMEInfo },
4325     { szRegisterProduct, ACTION_RegisterProduct },
4326     { szRegisterProgIdInfo, ACTION_RegisterProgIdInfo },
4327     { szRegisterTypeLibraries, ACTION_RegisterTypeLibraries },
4328     { szRegisterUser, ACTION_RegisterUser},
4329     { szRemoveDuplicateFiles, NULL},
4330     { szRemoveEnvironmentStrings, ACTION_RemoveEnvironmentStrings },
4331     { szRemoveExistingProducts, NULL},
4332     { szRemoveFiles, ACTION_RemoveFiles},
4333     { szRemoveFolders, NULL},
4334     { szRemoveIniValues, ACTION_RemoveIniValues },
4335     { szRemoveODBC, NULL},
4336     { szRemoveRegistryValues, NULL},
4337     { szRemoveShortcuts, NULL},
4338     { szResolveSource, ACTION_ResolveSource},
4339     { szRMCCPSearch, ACTION_RMCCPSearch},
4340     { szScheduleReboot, NULL},
4341     { szSelfRegModules, ACTION_SelfRegModules },
4342     { szSelfUnregModules, ACTION_SelfUnregModules },
4343     { szSetODBCFolders, NULL},
4344     { szStartServices, ACTION_StartServices },
4345     { szStopServices, ACTION_StopServices },
4346     { szUnpublishComponents, NULL},
4347     { szUnpublishFeatures, NULL},
4348     { szUnregisterClassInfo, NULL},
4349     { szUnregisterComPlus, ACTION_UnregisterComPlus},
4350     { szUnregisterExtensionInfo, NULL},
4351     { szUnregisterFonts, ACTION_UnregisterFonts },
4352     { szUnregisterMIMEInfo, NULL},
4353     { szUnregisterProgIdInfo, NULL},
4354     { szUnregisterTypeLibraries, NULL},
4355     { szValidateProductID, NULL},
4356     { szWriteEnvironmentStrings, ACTION_WriteEnvironmentStrings },
4357     { szWriteIniValues, ACTION_WriteIniValues },
4358     { szWriteRegistryValues, ACTION_WriteRegistryValues},
4359     { NULL, NULL},
4360 };