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

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