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