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 "msvcrt/fcntl.h"
  43 #include "objbase.h"
  44 #include "objidl.h"
  45 #include "msipriv.h"
  46 #include "winnls.h"
  47 #include "winuser.h"
  48 #include "shlobj.h"
  49 #include "wine/unicode.h"
  50 #include "ver.h"
  51
  52 #define CUSTOM_ACTION_TYPE_MASK 0x3F
  53
  54 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  55
  56 typedef struct tagMSIFEATURE
  57 {
  58     WCHAR Feature[96];
  59     WCHAR Feature_Parent[96];
  60     WCHAR Title[0x100];
  61     WCHAR Description[0x100];
  62     INT Display;
  63     INT Level;
  64     WCHAR Directory[96];
  65     INT Attributes;
  66
  67     INSTALLSTATE Installed;
  68     INSTALLSTATE ActionRequest;
  69     INSTALLSTATE Action;
  70
  71     INT ComponentCount;
  72     INT Components[1024]; /* yes hardcoded limit.... I am bad */
  73     INT Cost;
  74 } MSIFEATURE;
  75
  76 typedef struct tagMSICOMPONENT
  77 {
  78     WCHAR Component[96];
  79     WCHAR ComponentId[96];
  80     WCHAR Directory[96];
  81     INT Attributes;
  82     WCHAR Condition[0x100];
  83     WCHAR KeyPath[96];
  84
  85     INSTALLSTATE Installed;
  86     INSTALLSTATE ActionRequest;
  87     INSTALLSTATE Action;
  88
  89     BOOL Enabled;
  90     INT  Cost;
  91 } MSICOMPONENT;
  92
  93 typedef struct tagMSIFOLDER
  94 {
  95     LPWSTR Directory;
  96     LPWSTR TargetDefault;
  97     LPWSTR SourceDefault;
  98
  99     LPWSTR ResolvedTarget;
 100     LPWSTR ResolvedSource;
 101     LPWSTR Property;   /* initially set property */
 102     INT   ParentIndex;
 103     INT   State;
 104         /* 0 = uninitialized */
 105         /* 1 = existing */
 106         /* 2 = created remove if empty */
 107         /* 3 = created persist if empty */
 108     INT   Cost;
 109     INT   Space;
 110 }MSIFOLDER;
 111
 112 typedef struct tagMSIFILE
 113 {
 114     LPWSTR File;
 115     INT ComponentIndex;
 116     LPWSTR FileName;
 117     INT FileSize;
 118     LPWSTR Version;
 119     LPWSTR Language;
 120     INT Attributes;
 121     INT Sequence;
 122
 123     INT State;
 124        /* 0 = uninitialize */
 125        /* 1 = not present */
 126        /* 2 = present but replace */
 127        /* 3 = present do not replace */
 128        /* 4 = Installed */
 129     LPWSTR  SourcePath;
 130     LPWSTR  TargetPath;
 131     BOOL    Temporary;
 132 }MSIFILE;
 133
 134 /*
 135  * Prototypes
 136  */
 137 static UINT ACTION_ProcessExecSequence(MSIPACKAGE *package, BOOL UIran);
 138 static UINT ACTION_ProcessUISequence(MSIPACKAGE *package);
 139
 140 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq);
 141 UINT ACTION_PerformAction(MSIPACKAGE *package, const WCHAR *action);
 142
 143 static UINT ACTION_LaunchConditions(MSIPACKAGE *package);
 144 static UINT ACTION_CostInitialize(MSIPACKAGE *package);
 145 static UINT ACTION_CreateFolders(MSIPACKAGE *package);
 146 static UINT ACTION_CostFinalize(MSIPACKAGE *package);
 147 static UINT ACTION_FileCost(MSIPACKAGE *package);
 148 static UINT ACTION_InstallFiles(MSIPACKAGE *package);
 149 static UINT ACTION_DuplicateFiles(MSIPACKAGE *package);
 150 static UINT ACTION_WriteRegistryValues(MSIPACKAGE *package);
 151 static UINT ACTION_CustomAction(MSIPACKAGE *package,const WCHAR *action);
 152 static UINT ACTION_InstallInitialize(MSIPACKAGE *package);
 153 static UINT ACTION_InstallValidate(MSIPACKAGE *package);
 154 static UINT ACTION_ProcessComponents(MSIPACKAGE *package);
 155 static UINT ACTION_RegisterTypeLibraries(MSIPACKAGE *package);
 156 static UINT ACTION_RegisterClassInfo(MSIPACKAGE *package);
 157 static UINT ACTION_RegisterProgIdInfo(MSIPACKAGE *package);
 158 static UINT ACTION_CreateShortcuts(MSIPACKAGE *package);
 159 static UINT ACTION_PublishProduct(MSIPACKAGE *package);
 160
 161 static UINT HANDLE_CustomType1(MSIPACKAGE *package, const LPWSTR source,
 162                                 const LPWSTR target, const INT type);
 163 static UINT HANDLE_CustomType2(MSIPACKAGE *package, const LPWSTR source,
 164                                 const LPWSTR target, const INT type);
 165 static UINT HANDLE_CustomType18(MSIPACKAGE *package, const LPWSTR source,
 166                                 const LPWSTR target, const INT type);
 167 static UINT HANDLE_CustomType50(MSIPACKAGE *package, const LPWSTR source,
 168                                 const LPWSTR target, const INT type);
 169 static UINT HANDLE_CustomType34(MSIPACKAGE *package, const LPWSTR source,
 170                                 const LPWSTR target, const INT type);
 171
 172 static DWORD deformat_string(MSIPACKAGE *package, WCHAR* ptr,WCHAR** data);
 173 static LPWSTR resolve_folder(MSIPACKAGE *package, LPCWSTR name,
 174                            BOOL source, BOOL set_prop, MSIFOLDER **folder);
 175
 176 static int track_tempfile(MSIPACKAGE *package, LPCWSTR name, LPCWSTR path);
 177
 178 /*
 179  * consts and values used
 180  */
 181 static const WCHAR cszSourceDir[] = {'S','o','u','r','c','e','D','i','r',0};
 182 static const WCHAR cszRootDrive[] = {'R','O','O','T','D','R','I','V','E',0};
 183 static const WCHAR cszTargetDir[] = {'T','A','R','G','E','T','D','I','R',0};
 184 static const WCHAR cszTempFolder[]= {'T','e','m','p','F','o','l','d','e','r',0};
 185 static const WCHAR cszDatabase[]={'D','A','T','A','B','A','S','E',0};
 186 static const WCHAR c_collen[] = {'C',':','\\',0};
 187
 188 static const WCHAR cszlsb[]={'[',0};
 189 static const WCHAR cszrsb[]={']',0};
 190 static const WCHAR cszbs[]={'\\',0};
 191
 192 const static WCHAR szCreateFolders[] =
 193     {'C','r','e','a','t','e','F','o','l','d','e','r','s',0};
 194 const static WCHAR szCostFinalize[] =
 195     {'C','o','s','t','F','i','n','a','l','i','z','e',0};
 196 const static WCHAR szInstallFiles[] =
 197     {'I','n','s','t','a','l','l','F','i','l','e','s',0};
 198 const static WCHAR szDuplicateFiles[] =
 199     {'D','u','p','l','i','c','a','t','e','F','i','l','e','s',0};
 200 const static WCHAR szWriteRegistryValues[] =
 201 {'W','r','i','t','e','R','e','g','i','s','t','r','y','V','a','l','u','e','s',0};
 202 const static WCHAR szCostInitialize[] =
 203     {'C','o','s','t','I','n','i','t','i','a','l','i','z','e',0};
 204 const static WCHAR szFileCost[] = {'F','i','l','e','C','o','s','t',0};
 205 const static WCHAR szInstallInitialize[] =
 206     {'I','n','s','t','a','l','l','I','n','i','t','i','a','l','i','z','e',0};
 207 const static WCHAR szInstallValidate[] =
 208     {'I','n','s','t','a','l','l','V','a','l','i','d','a','t','e',0};
 209 const static WCHAR szLaunchConditions[] =
 210     {'L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','s',0};
 211 const static WCHAR szProcessComponents[] =
 212     {'P','r','o','c','e','s','s','C','o','m','p','o','n','e','n','t','s',0};
 213 const static WCHAR szRegisterTypeLibraries[] =
 214 {'R','e','g','i','s','t','e','r','T','y','p','e','L','i','b','r','a','r',
 215 'i','e','s',0};
 216 const static WCHAR szRegisterClassInfo[] =
 217 {'R','e','g','i','s','t','e','r','C','l','a','s','s','I','n','f','o',0};
 218 const static WCHAR szRegisterProgIdInfo[] =
 219 {'R','e','g','i','s','t','e','r','P','r','o','g','I','d','I','n','f','o',0};
 220 const static WCHAR szCreateShortcuts[] =
 221 {'C','r','e','a','t','e','S','h','o','r','t','c','u','t','s',0};
 222 const static WCHAR szPublishProduct[] =
 223 {'P','u','b','l','i','s','h','P','r','o','d','u','c','t',0};
 224
 225 /********************************************************
 226  * helper functions to get around current HACKS and such
 227  ********************************************************/
 228 inline static void reduce_to_longfilename(WCHAR* filename)
 229 {
 230     LPWSTR p = strchrW(filename,'|');
 231     if (p)
 232         memmove(filename, p+1, (strlenW(p+1)+1)*sizeof(WCHAR));
 233 }
 234
 235 inline static char *strdupWtoA( const WCHAR *str )
 236 {
 237     char *ret = NULL;
 238     if (str)
 239     {
 240         DWORD len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL
 241 );
 242         if ((ret = HeapAlloc( GetProcessHeap(), 0, len )))
 243             WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
 244     }
 245     return ret;
 246 }
 247
 248 inline static WCHAR *strdupAtoW( const char *str )
 249 {
 250     WCHAR *ret = NULL;
 251     if (str)
 252     {
 253         DWORD len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
 254         if ((ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
 255             MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
 256     }
 257     return ret;
 258 }
 259
 260 static LPWSTR dupstrW(LPCWSTR src)
 261 {
 262     LPWSTR dest;
 263     if (!src) return NULL;
 264     dest = HeapAlloc(GetProcessHeap(), 0, (strlenW(src)+1)*sizeof(WCHAR));
 265     strcpyW(dest, src);
 266     return dest;
 267 }
 268
 269 inline static WCHAR *load_dynamic_stringW(MSIRECORD *row, INT index)
 270 {
 271     UINT rc;
 272     DWORD sz;
 273     LPWSTR ret;
 274
 275     sz = 0;
 276     if (MSI_RecordIsNull(row,index))
 277         return NULL;
 278
 279     rc = MSI_RecordGetStringW(row,index,NULL,&sz);
 280
 281     /* having an empty string is different than NULL */
 282     if (sz == 0)
 283     {
 284         ret = HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR));
 285         ret[0] = 0;
 286         return ret;
 287     }
 288
 289     sz ++;
 290     ret = HeapAlloc(GetProcessHeap(),0,sz * sizeof (WCHAR));
 291     rc = MSI_RecordGetStringW(row,index,ret,&sz);
 292     if (rc!=ERROR_SUCCESS)
 293     {
 294         ERR("Unable to load dynamic string\n");
 295         HeapFree(GetProcessHeap(), 0, ret);
 296         ret = NULL;
 297     }
 298     return ret;
 299 }
 300
 301 inline static LPWSTR load_dynamic_property(MSIPACKAGE *package, LPCWSTR prop,
 302                                            UINT* rc)
 303 {
 304     DWORD sz = 0;
 305     LPWSTR str;
 306     UINT r;
 307
 308     r = MSI_GetPropertyW(package, prop, NULL, &sz);
 309     if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
 310     {
 311         if (rc)
 312             *rc = r;
 313         return NULL;
 314     }
 315     sz++;
 316     str = HeapAlloc(GetProcessHeap(),0,sz*sizeof(WCHAR));
 317     r = MSI_GetPropertyW(package, prop, str, &sz);
 318     if (r != ERROR_SUCCESS)
 319     {
 320         HeapFree(GetProcessHeap(),0,str);
 321         str = NULL;
 322     }
 323     if (rc)
 324         *rc = r;
 325     return str;
 326 }
 327
 328 inline static int get_loaded_component(MSIPACKAGE* package, LPCWSTR Component )
 329 {
 330     int rc = -1;
 331     DWORD i;
 332
 333     for (i = 0; i < package->loaded_components; i++)
 334     {
 335         if (strcmpW(Component,package->components[i].Component)==0)
 336         {
 337             rc = i;
 338             break;
 339         }
 340     }
 341     return rc;
 342 }
 343
 344 inline static int get_loaded_feature(MSIPACKAGE* package, LPCWSTR Feature )
 345 {
 346     int rc = -1;
 347     DWORD i;
 348
 349     for (i = 0; i < package->loaded_features; i++)
 350     {
 351         if (strcmpW(Feature,package->features[i].Feature)==0)
 352         {
 353             rc = i;
 354             break;
 355         }
 356     }
 357     return rc;
 358 }
 359
 360 inline static int get_loaded_file(MSIPACKAGE* package, LPCWSTR file)
 361 {
 362     int rc = -1;
 363     DWORD i;
 364
 365     for (i = 0; i < package->loaded_files; i++)
 366     {
 367         if (strcmpW(file,package->files[i].File)==0)
 368         {
 369             rc = i;
 370             break;
 371         }
 372     }
 373     return rc;
 374 }
 375
 376
 377 static int track_tempfile(MSIPACKAGE *package, LPCWSTR name, LPCWSTR path)
 378 {
 379     DWORD i;
 380     DWORD index;
 381
 382     if (!package)
 383         return -2;
 384
 385     for (i=0; i < package->loaded_files; i++)
 386         if (strcmpW(package->files[i].File,name)==0)
 387             return -1;
 388
 389     index = package->loaded_files;
 390     package->loaded_files++;
 391     if (package->loaded_files== 1)
 392         package->files = HeapAlloc(GetProcessHeap(),0,sizeof(MSIFILE));
 393     else
 394         package->files = HeapReAlloc(GetProcessHeap(),0,
 395             package->files , package->loaded_files * sizeof(MSIFILE));
 396
 397     memset(&package->files[index],0,sizeof(MSIFILE));
 398
 399     package->files[index].File = dupstrW(name);
 400     package->files[index].TargetPath = dupstrW(path);
 401     package->files[index].Temporary = TRUE;
 402
 403     TRACE("Tracking tempfile (%s)\n",debugstr_w(package->files[index].File));
 404
 405     return 0;
 406 }
 407
 408 void ACTION_remove_tracked_tempfiles(MSIPACKAGE* package)
 409 {
 410     DWORD i;
 411
 412     if (!package)
 413         return;
 414
 415     for (i = 0; i < package->loaded_files; i++)
 416     {
 417         if (package->files[i].Temporary)
 418         {
 419             TRACE("Cleaning up %s\n",debugstr_w(package->files[i].TargetPath));
 420             DeleteFileW(package->files[i].TargetPath);
 421         }
 422
 423     }
 424 }
 425
 426 static UINT ACTION_OpenQuery( MSIDATABASE *db, MSIQUERY **view, LPCWSTR fmt, ... )
 427 {
 428     LPWSTR szQuery;
 429     LPCWSTR p;
 430     UINT sz, rc;
 431     va_list va;
 432
 433     /* figure out how much space we need to allocate */
 434     va_start(va, fmt);
 435     sz = strlenW(fmt) + 1;
 436     p = fmt;
 437     while (*p)
 438     {
 439         p = strchrW(p, '%');
 440         if (!p)
 441             break;
 442         p++;
 443         switch (*p)
 444         {
 445         case 's':  /* a string */
 446             sz += strlenW(va_arg(va,LPCWSTR));
 447             break;
 448         case 'd':
 449         case 'i':  /* an integer -2147483648 seems to be longest */
 450             sz += 3*sizeof(int);
 451             (void)va_arg(va,int);
 452             break;
 453         case '%':  /* a single % - leave it alone */
 454             break;
 455         default:
 456             FIXME("Unhandled character type %c\n",*p);
 457         }
 458         p++;
 459     }
 460     va_end(va);
 461
 462     /* construct the string */
 463     szQuery = HeapAlloc(GetProcessHeap(), 0, sz*sizeof(WCHAR));
 464     va_start(va, fmt);
 465     vsnprintfW(szQuery, sz, fmt, va);
 466     va_end(va);
 467
 468     /* perform the query */
 469     rc = MSI_DatabaseOpenViewW(db, szQuery, view);
 470     HeapFree(GetProcessHeap(), 0, szQuery);
 471     return rc;
 472 }
 473
 474 static void ui_progress(MSIPACKAGE *package, int a, int b, int c, int d )
 475 {
 476     MSIRECORD * row;
 477
 478     row = MSI_CreateRecord(4);
 479     MSI_RecordSetInteger(row,1,a);
 480     MSI_RecordSetInteger(row,2,b);
 481     MSI_RecordSetInteger(row,3,c);
 482     MSI_RecordSetInteger(row,4,d);
 483     MSI_ProcessMessage(package, INSTALLMESSAGE_PROGRESS, row);
 484     msiobj_release(&row->hdr);
 485 }
 486
 487 static void ui_actiondata(MSIPACKAGE *package, LPCWSTR action, MSIRECORD * record)
 488 {
 489     static const WCHAR Query_t[] =
 490 {'S','E','L','E','C','T',' ','*',' ','f','r','o','m',' ','A','c','t','i','o',
 491 'n','T','e','x','t',' ','w','h','e','r','e',' ','A','c','t','i','o','n',' ','=',
 492 ' ','\'','%','s','\'',0};
 493     WCHAR message[1024];
 494     UINT rc;
 495     MSIQUERY * view;
 496     MSIRECORD * row = 0;
 497     LPWSTR ptr;
 498
 499     if (!package->LastAction || strcmpW(package->LastAction,action))
 500     {
 501         rc = ACTION_OpenQuery(package->db, &view, Query_t, action);
 502         if (rc != ERROR_SUCCESS)
 503             return;
 504
 505         rc = MSI_ViewExecute(view, 0);
 506         if (rc != ERROR_SUCCESS)
 507         {
 508             MSI_ViewClose(view);
 509             return;
 510         }
 511         rc = MSI_ViewFetch(view,&row);
 512         if (rc != ERROR_SUCCESS)
 513         {
 514             MSI_ViewClose(view);
 515             return;
 516         }
 517
 518         if (MSI_RecordIsNull(row,3))
 519         {
 520             msiobj_release(&row->hdr);
 521             MSI_ViewClose(view);
 522             msiobj_release(&view->hdr);
 523             return;
 524         }
 525
 526         /* update the cached actionformat */
 527         if (package->ActionFormat)
 528             HeapFree(GetProcessHeap(),0,package->ActionFormat);
 529         package->ActionFormat = load_dynamic_stringW(row,3);
 530
 531         if (package->LastAction)
 532             HeapFree(GetProcessHeap(),0,package->LastAction);
 533         package->LastAction = dupstrW(action);
 534
 535         msiobj_release(&row->hdr);
 536         MSI_ViewClose(view);
 537         msiobj_release(&view->hdr);
 538     }
 539
 540     message[0]=0;
 541     ptr = package->ActionFormat;
 542     while (*ptr)
 543     {
 544         LPWSTR ptr2;
 545         LPWSTR data=NULL;
 546         WCHAR tmp[1023];
 547         INT field;
 548
 549         ptr2 = strchrW(ptr,'[');
 550         if (ptr2)
 551         {
 552             strncpyW(tmp,ptr,ptr2-ptr);
 553             tmp[ptr2-ptr]=0;
 554             strcatW(message,tmp);
 555             ptr2++;
 556             field = atoiW(ptr2);
 557             data = load_dynamic_stringW(record,field);
 558             if (data)
 559             {
 560                 strcatW(message,data);
 561                 HeapFree(GetProcessHeap(),0,data);
 562             }
 563             ptr=strchrW(ptr2,']');
 564             ptr++;
 565         }
 566         else
 567         {
 568             strcatW(message,ptr);
 569             break;
 570         }
 571     }
 572
 573     row = MSI_CreateRecord(1);
 574     MSI_RecordSetStringW(row,1,message);
 575
 576     MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, row);
 577     msiobj_release(&row->hdr);
 578 }
 579
 580
 581 static void ui_actionstart(MSIPACKAGE *package, LPCWSTR action)
 582 {
 583     static const WCHAR template_s[]=
 584 {'A','c','t','i','o','n',' ','%','s',':',' ','%','s','.',' ','%','s','.',0};
 585     static const WCHAR format[] =
 586 {'H','H','\'',':','\'','m','m','\'',':','\'','s','s',0};
 587     static const WCHAR Query_t[] =
 588 {'S','E','L','E','C','T',' ','*',' ','f','r','o','m',' ','A','c','t','i','o',
 589 'n','T','e','x','t',' ','w','h','e','r','e',' ','A','c','t','i','o','n',' ','=',
 590 ' ','\'','%','s','\'',0};
 591     WCHAR message[1024];
 592     WCHAR timet[0x100];
 593     UINT rc;
 594     MSIQUERY * view;
 595     MSIRECORD * row = 0;
 596     WCHAR *ActionText=NULL;
 597
 598     GetTimeFormatW(LOCALE_USER_DEFAULT, 0, NULL, format, timet, 0x100);
 599
 600     rc = ACTION_OpenQuery(package->db, &view, Query_t, action);
 601     if (rc != ERROR_SUCCESS)
 602         return;
 603     rc = MSI_ViewExecute(view, 0);
 604     if (rc != ERROR_SUCCESS)
 605     {
 606         MSI_ViewClose(view);
 607         msiobj_release(&view->hdr);
 608         return;
 609     }
 610     rc = MSI_ViewFetch(view,&row);
 611     if (rc != ERROR_SUCCESS)
 612     {
 613         MSI_ViewClose(view);
 614         msiobj_release(&view->hdr);
 615         return;
 616     }
 617
 618     ActionText = load_dynamic_stringW(row,2);
 619     msiobj_release(&row->hdr);
 620     MSI_ViewClose(view);
 621     msiobj_release(&view->hdr);
 622
 623     sprintfW(message,template_s,timet,action,ActionText);
 624
 625     row = MSI_CreateRecord(1);
 626     MSI_RecordSetStringW(row,1,message);
 627
 628     MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONSTART, row);
 629     msiobj_release(&row->hdr);
 630     HeapFree(GetProcessHeap(),0,ActionText);
 631 }
 632
 633 static void ui_actioninfo(MSIPACKAGE *package, LPCWSTR action, BOOL start,
 634                           UINT rc)
 635 {
 636     MSIRECORD * row;
 637     static const WCHAR template_s[]=
 638 {'A','c','t','i','o','n',' ','s','t','a','r','t',' ','%','s',':',' ','%','s',
 639 '.',0};
 640     static const WCHAR template_e[]=
 641 {'A','c','t','i','o','n',' ','e','n','d','e','d',' ','%','s',':',' ','%','s',
 642 '.',' ','R','e','t','u','r','n',' ','v','a','l','u','e',' ','%','i','.',0};
 643     static const WCHAR format[] =
 644 {'H','H','\'',':','\'','m','m','\'',':','\'','s','s',0};
 645     WCHAR message[1024];
 646     WCHAR timet[0x100];
 647
 648     GetTimeFormatW(LOCALE_USER_DEFAULT, 0, NULL, format, timet, 0x100);
 649     if (start)
 650         sprintfW(message,template_s,timet,action);
 651     else
 652         sprintfW(message,template_e,timet,action,rc);
 653
 654     row = MSI_CreateRecord(1);
 655     MSI_RecordSetStringW(row,1,message);
 656
 657     MSI_ProcessMessage(package, INSTALLMESSAGE_INFO, row);
 658     msiobj_release(&row->hdr);
 659 }
 660
 661 /*
 662  *  build_directory_name()
 663  *
 664  *  This function is to save messing round with directory names
 665  *  It handles adding backslashes between path segments,
 666  *   and can add \ at the end of the directory name if told to.
 667  *
 668  *  It takes a variable number of arguments.
 669  *  It always allocates a new string for the result, so make sure
 670  *   to free the return value when finished with it.
 671  *
 672  *  The first arg is the number of path segments that follow.
 673  *  The arguments following count are a list of path segments.
 674  *  A path segment may be NULL.
 675  *
 676  *  Path segments will be added with a \ seperating them.
 677  *  A \ will not be added after the last segment, however if the
 678  *    last segment is NULL, then the last character will be a \
 679  *
 680  */
 681 static LPWSTR build_directory_name(DWORD count, ...)
 682 {
 683     DWORD sz = 1, i;
 684     LPWSTR dir;
 685     va_list va;
 686
 687     va_start(va,count);
 688     for(i=0; i<count; i++)
 689     {
 690         LPCWSTR str = va_arg(va,LPCWSTR);
 691         if (str)
 692             sz += strlenW(str) + 1;
 693     }
 694     va_end(va);
 695
 696     dir = HeapAlloc(GetProcessHeap(), 0, sz*sizeof(WCHAR));
 697     dir[0]=0;
 698
 699     va_start(va,count);
 700     for(i=0; i<count; i++)
 701     {
 702         LPCWSTR str = va_arg(va,LPCWSTR);
 703         if (!str)
 704             continue;
 705         strcatW(dir, str);
 706         if( ((i+1)!=count) && dir[strlenW(dir)-1]!='\\')
 707             strcatW(dir, cszbs);
 708     }
 709     return dir;
 710 }
 711
 712
 713 /****************************************************
 714  * TOP level entry points
 715  *****************************************************/
 716
 717 UINT ACTION_DoTopLevelINSTALL(MSIPACKAGE *package, LPCWSTR szPackagePath,
 718                               LPCWSTR szCommandLine)
 719 {
 720     DWORD sz;
 721     WCHAR buffer[10];
 722     UINT rc;
 723     static const WCHAR szUILevel[] = {'U','I','L','e','v','e','l',0};
 724
 725     if (szPackagePath)
 726     {
 727         LPWSTR p, check, path;
 728
 729         path = dupstrW(szPackagePath);
 730         p = strrchrW(path,'\\');
 731         if (p)
 732         {
 733             p++;
 734             *p=0;
 735         }
 736
 737         check = load_dynamic_property(package, cszSourceDir,NULL);
 738         if (!check)
 739             MSI_SetPropertyW(package, cszSourceDir, path);
 740         else
 741             HeapFree(GetProcessHeap(), 0, check);
 742
 743         HeapFree(GetProcessHeap(), 0, path);
 744     }
 745
 746     if (szCommandLine)
 747     {
 748         LPWSTR ptr,ptr2;
 749         ptr = (LPWSTR)szCommandLine;
 750
 751         while (*ptr)
 752         {
 753             WCHAR *prop = NULL;
 754             WCHAR *val = NULL;
 755
 756             TRACE("Looking at %s\n",debugstr_w(ptr));
 757
 758             ptr2 = strchrW(ptr,'=');
 759             if (ptr2)
 760             {
 761                 BOOL quote=FALSE;
 762                 DWORD len = 0;
 763
 764                 while (*ptr == ' ') ptr++;
 765                 len = ptr2-ptr;
 766                 prop = HeapAlloc(GetProcessHeap(),0,(len+1)*sizeof(WCHAR));
 767                 strncpyW(prop,ptr,len);
 768                 prop[len]=0;
 769                 ptr2++;
 770
 771                 len = 0;
 772                 ptr = ptr2;
 773                 while (*ptr && (quote || (!quote && *ptr!=' ')))
 774                 {
 775                     if (*ptr == '"')
 776                         quote = !quote;
 777                     ptr++;
 778                     len++;
 779                 }
 780
 781                 if (*ptr2=='"')
 782                 {
 783                     ptr2++;
 784                     len -= 2;
 785                 }
 786                 val = HeapAlloc(GetProcessHeap(),0,(len+1)*sizeof(WCHAR));
 787                 strncpyW(val,ptr2,len);
 788                 val[len] = 0;
 789
 790                 if (strlenW(prop) > 0)
 791                 {
 792                     TRACE("Found commandline property (%s) = (%s)\n",
 793                                        debugstr_w(prop), debugstr_w(val));
 794                     MSI_SetPropertyW(package,prop,val);
 795                 }
 796                 HeapFree(GetProcessHeap(),0,val);
 797                 HeapFree(GetProcessHeap(),0,prop);
 798             }
 799             ptr++;
 800         }
 801     }
 802
 803     sz = 10;
 804     if (MSI_GetPropertyW(package,szUILevel,buffer,&sz) == ERROR_SUCCESS)
 805     {
 806         if (atoiW(buffer) >= INSTALLUILEVEL_REDUCED)
 807         {
 808             rc = ACTION_ProcessUISequence(package);
 809             if (rc == ERROR_SUCCESS)
 810                 rc = ACTION_ProcessExecSequence(package,TRUE);
 811         }
 812         else
 813             rc = ACTION_ProcessExecSequence(package,FALSE);
 814     }
 815     else
 816         rc = ACTION_ProcessExecSequence(package,FALSE);
 817
 818     /* process the ending type action */
 819     if (rc == ERROR_SUCCESS)
 820         rc = ACTION_PerformActionSequence(package,-1);
 821     else if (rc == ERROR_FUNCTION_FAILED)
 822         rc = ACTION_PerformActionSequence(package,-3);
 823
 824     return rc;
 825 }
 826
 827 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq)
 828 {
 829     MSIQUERY * view;
 830     UINT rc;
 831     WCHAR buffer[0x100];
 832     DWORD sz = 0x100;
 833     MSIRECORD * row = 0;
 834     static const WCHAR ExecSeqQuery[] =  {
 835    's','e','l','e','c','t',' ','*',' ',
 836    'f','r','o','m',' ',
 837        'I','n','s','t','a','l','l','E','x','e','c','u','t','e',
 838        'S','e','q','u','e','n','c','e',' ',
 839    'w','h','e','r','e',' ','S','e','q','u','e','n','c','e',' ',
 840        '=',' ','%','i',0};
 841
 842     rc = ACTION_OpenQuery(package->db, &view, ExecSeqQuery, seq);
 843
 844     if (rc == ERROR_SUCCESS)
 845     {
 846         rc = MSI_ViewExecute(view, 0);
 847
 848         if (rc != ERROR_SUCCESS)
 849         {
 850             MSI_ViewClose(view);
 851             msiobj_release(&view->hdr);
 852             goto end;
 853         }
 854
 855         TRACE("Running the actions\n");
 856
 857         rc = MSI_ViewFetch(view,&row);
 858         if (rc != ERROR_SUCCESS)
 859         {
 860             rc = ERROR_SUCCESS;
 861             goto end;
 862         }
 863
 864         /* check conditions */
 865         if (!MSI_RecordIsNull(row,2))
 866         {
 867             LPWSTR cond = NULL;
 868             cond = load_dynamic_stringW(row,2);
 869
 870             if (cond)
 871             {
 872                 /* this is a hack to skip errors in the condition code */
 873                 if (MSI_EvaluateConditionW(package, cond) == MSICONDITION_FALSE)
 874                 {
 875                     HeapFree(GetProcessHeap(),0,cond);
 876                     msiobj_release(&row->hdr);
 877                     goto end;
 878                 }
 879                 else
 880                     HeapFree(GetProcessHeap(),0,cond);
 881             }
 882         }
 883
 884         sz=0x100;
 885         rc =  MSI_RecordGetStringW(row,1,buffer,&sz);
 886         if (rc != ERROR_SUCCESS)
 887         {
 888             ERR("Error is %x\n",rc);
 889             msiobj_release(&row->hdr);
 890             goto end;
 891         }
 892
 893         rc = ACTION_PerformAction(package,buffer);
 894         msiobj_release(&row->hdr);
 895 end:
 896         MSI_ViewClose(view);
 897         msiobj_release(&view->hdr);
 898     }
 899     else
 900         rc = ERROR_SUCCESS;
 901
 902     return rc;
 903 }
 904
 905 static UINT ACTION_ProcessExecSequence(MSIPACKAGE *package, BOOL UIran)
 906 {
 907     MSIQUERY * view;
 908     UINT rc;
 909     static const WCHAR ExecSeqQuery[] =  {
 910        's','e','l','e','c','t',' ','*',' ',
 911        'f','r','o','m',' ',
 912            'I','n','s','t','a','l','l','E','x','e','c','u','t','e',
 913            'S','e','q','u','e','n','c','e',' ',
 914        'w','h','e','r','e',' ','S','e','q','u','e','n','c','e',' ',
 915            '>',' ','%','i',' ','o','r','d','e','r',' ',
 916        'b','y',' ','S','e','q','u','e','n','c','e',0 };
 917     MSIRECORD * row = 0;
 918     static const WCHAR IVQuery[] = {
 919        's','e','l','e','c','t',' ','S','e','q','u','e','n','c','e',' ',
 920        'f','r','o','m',' ','I','n','s','t','a','l','l',
 921            'E','x','e','c','u','t','e','S','e','q','u','e','n','c','e',' ',
 922        'w','h','e','r','e',' ','A','c','t','i','o','n',' ','=',' ',
 923            '`','I','n','s','t','a','l','l','V','a','l','i','d','a','t','e','`',
 924        0};
 925     INT seq = 0;
 926
 927     /* get the sequence number */
 928     if (UIran)
 929     {
 930         rc = MSI_DatabaseOpenViewW(package->db, IVQuery, &view);
 931         if (rc != ERROR_SUCCESS)
 932             return rc;
 933         rc = MSI_ViewExecute(view, 0);
 934         if (rc != ERROR_SUCCESS)
 935         {
 936             MSI_ViewClose(view);
 937             msiobj_release(&view->hdr);
 938             return rc;
 939         }
 940         rc = MSI_ViewFetch(view,&row);
 941         if (rc != ERROR_SUCCESS)
 942         {
 943             MSI_ViewClose(view);
 944             msiobj_release(&view->hdr);
 945             return rc;
 946         }
 947         seq = MSI_RecordGetInteger(row,1);
 948         msiobj_release(&row->hdr);
 949         MSI_ViewClose(view);
 950         msiobj_release(&view->hdr);
 951     }
 952
 953     rc = ACTION_OpenQuery(package->db, &view, ExecSeqQuery, seq);
 954     if (rc == ERROR_SUCCESS)
 955     {
 956         rc = MSI_ViewExecute(view, 0);
 957
 958         if (rc != ERROR_SUCCESS)
 959         {
 960             MSI_ViewClose(view);
 961             msiobj_release(&view->hdr);
 962             goto end;
 963         }
 964
 965         TRACE("Running the actions\n");
 966
 967         while (1)
 968         {
 969             WCHAR buffer[0x100];
 970             DWORD sz = 0x100;
 971
 972             rc = MSI_ViewFetch(view,&row);
 973             if (rc != ERROR_SUCCESS)
 974             {
 975                 rc = ERROR_SUCCESS;
 976                 break;
 977             }
 978
 979             /* check conditions */
 980             if (!MSI_RecordIsNull(row,2))
 981             {
 982                 LPWSTR cond = NULL;
 983                 cond = load_dynamic_stringW(row,2);
 984
 985                 if (cond)
 986                 {
 987                     /* this is a hack to skip errors in the condition code */
 988                     if (MSI_EvaluateConditionW(package, cond) ==
 989                             MSICONDITION_FALSE)
 990                     {
 991                         HeapFree(GetProcessHeap(),0,cond);
 992                         msiobj_release(&row->hdr);
 993                         continue;
 994                     }
 995                     else
 996                         HeapFree(GetProcessHeap(),0,cond);
 997                 }
 998             }
 999
1000             sz=0x100;
1001             rc =  MSI_RecordGetStringW(row,1,buffer,&sz);
1002             if (rc != ERROR_SUCCESS)
1003             {
1004                 ERR("Error is %x\n",rc);
1005                 msiobj_release(&row->hdr);
1006                 break;
1007             }
1008
1009             rc = ACTION_PerformAction(package,buffer);
1010
1011             if (rc == ERROR_FUNCTION_NOT_CALLED)
1012                 rc = ERROR_SUCCESS;
1013
1014             if (rc != ERROR_SUCCESS)
1015             {
1016                 ERR("Execution halted due to error (%i)\n",rc);
1017                 msiobj_release(&row->hdr);
1018                 break;
1019             }
1020
1021             msiobj_release(&row->hdr);
1022         }
1023
1024         MSI_ViewClose(view);
1025         msiobj_release(&view->hdr);
1026     }
1027
1028 end:
1029     return rc;
1030 }
1031
1032
1033 static UINT ACTION_ProcessUISequence(MSIPACKAGE *package)
1034 {
1035     MSIQUERY * view;
1036     UINT rc;
1037     static const WCHAR ExecSeqQuery [] = {
1038       's','e','l','e','c','t',' ','*',' ',
1039       'f','r','o','m',' ','I','n','s','t','a','l','l',
1040             'U','I','S','e','q','u','e','n','c','e',' ',
1041       'w','h','e','r','e',' ','S','e','q','u','e','n','c','e',' ', '>',' ','0',' ',
1042       'o','r','d','e','r',' ','b','y',' ','S','e','q','u','e','n','c','e',0};
1043
1044     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
1045
1046     if (rc == ERROR_SUCCESS)
1047     {
1048         rc = MSI_ViewExecute(view, 0);
1049
1050         if (rc != ERROR_SUCCESS)
1051         {
1052             MSI_ViewClose(view);
1053             msiobj_release(&view->hdr);
1054             goto end;
1055         }
1056
1057         TRACE("Running the actions \n");
1058
1059         while (1)
1060         {
1061             WCHAR buffer[0x100];
1062             DWORD sz = 0x100;
1063             MSIRECORD * row = 0;
1064
1065             rc = MSI_ViewFetch(view,&row);
1066             if (rc != ERROR_SUCCESS)
1067             {
1068                 rc = ERROR_SUCCESS;
1069                 break;
1070             }
1071
1072             /* check conditions */
1073             if (!MSI_RecordIsNull(row,2))
1074             {
1075                 LPWSTR cond = NULL;
1076                 cond = load_dynamic_stringW(row,2);
1077
1078                 if (cond)
1079                 {
1080                     /* this is a hack to skip errors in the condition code */
1081                     if (MSI_EvaluateConditionW(package, cond) ==
1082                             MSICONDITION_FALSE)
1083                     {
1084                         HeapFree(GetProcessHeap(),0,cond);
1085                         msiobj_release(&row->hdr);
1086                         continue;
1087                     }
1088                     else
1089                         HeapFree(GetProcessHeap(),0,cond);
1090                 }
1091             }
1092
1093             sz=0x100;
1094             rc =  MSI_RecordGetStringW(row,1,buffer,&sz);
1095             if (rc != ERROR_SUCCESS)
1096             {
1097                 ERR("Error is %x\n",rc);
1098                 msiobj_release(&row->hdr);
1099                 break;
1100             }
1101
1102             rc = ACTION_PerformAction(package,buffer);
1103
1104             if (rc == ERROR_FUNCTION_NOT_CALLED)
1105                 rc = ERROR_SUCCESS;
1106
1107             if (rc != ERROR_SUCCESS)
1108             {
1109                 ERR("Execution halted due to error (%i)\n",rc);
1110                 msiobj_release(&row->hdr);
1111                 break;
1112             }
1113
1114             msiobj_release(&row->hdr);
1115         }
1116
1117         MSI_ViewClose(view);
1118         msiobj_release(&view->hdr);
1119     }
1120
1121 end:
1122     return rc;
1123 }
1124
1125 /********************************************************
1126  * ACTION helper functions and functions that perform the actions
1127  *******************************************************/
1128
1129 /*
1130  * Alot of actions are really important even if they don't do anything
1131  * explicit.. Lots of properties are set at the beginning of the installation
1132  * CostFinalize does a bunch of work to translated the directories and such
1133  *
1134  * But until I get write access to the database that is hard, so I am going to
1135  * hack it to see if I can get something to run.
1136  */
1137 UINT ACTION_PerformAction(MSIPACKAGE *package, const WCHAR *action)
1138 {
1139     UINT rc = ERROR_SUCCESS;
1140
1141     TRACE("Performing action (%s)\n",debugstr_w(action));
1142     ui_actioninfo(package, action, TRUE, 0);
1143     ui_actionstart(package, action);
1144     ui_progress(package,2,1,0,0);
1145
1146     /* pre install, setup and configuration block */
1147     if (strcmpW(action,szLaunchConditions)==0)
1148         rc = ACTION_LaunchConditions(package);
1149     else if (strcmpW(action,szCostInitialize)==0)
1150         rc = ACTION_CostInitialize(package);
1151     else if (strcmpW(action,szFileCost)==0)
1152         rc = ACTION_FileCost(package);
1153     else if (strcmpW(action,szCostFinalize)==0)
1154         rc = ACTION_CostFinalize(package);
1155     else if (strcmpW(action,szInstallValidate)==0)
1156         rc = ACTION_InstallValidate(package);
1157
1158     /* install block */
1159     else if (strcmpW(action,szProcessComponents)==0)
1160         rc = ACTION_ProcessComponents(package);
1161     else if (strcmpW(action,szInstallInitialize)==0)
1162         rc = ACTION_InstallInitialize(package);
1163     else if (strcmpW(action,szCreateFolders)==0)
1164         rc = ACTION_CreateFolders(package);
1165     else if (strcmpW(action,szInstallFiles)==0)
1166         rc = ACTION_InstallFiles(package);
1167     else if (strcmpW(action,szDuplicateFiles)==0)
1168         rc = ACTION_DuplicateFiles(package);
1169     else if (strcmpW(action,szWriteRegistryValues)==0)
1170         rc = ACTION_WriteRegistryValues(package);
1171      else if (strcmpW(action,szRegisterTypeLibraries)==0)
1172         rc = ACTION_RegisterTypeLibraries(package);
1173      else if (strcmpW(action,szRegisterClassInfo)==0)
1174         rc = ACTION_RegisterClassInfo(package);
1175      else if (strcmpW(action,szRegisterProgIdInfo)==0)
1176         rc = ACTION_RegisterProgIdInfo(package);
1177      else if (strcmpW(action,szCreateShortcuts)==0)
1178         rc = ACTION_CreateShortcuts(package);
1179     else if (strcmpW(action,szPublishProduct)==0)
1180         rc = ACTION_PublishProduct(package);
1181
1182     /*
1183      Called during iTunes but unimplemented and seem important
1184
1185      ResolveSource  (sets SourceDir)
1186      RegisterProduct
1187      InstallFinalize
1188      */
1189      else if ((rc = ACTION_CustomAction(package,action)) != ERROR_SUCCESS)
1190      {
1191         FIXME("UNHANDLED MSI ACTION %s\n",debugstr_w(action));
1192         rc = ERROR_FUNCTION_NOT_CALLED;
1193      }
1194
1195     ui_actioninfo(package, action, FALSE, rc);
1196     return rc;
1197 }
1198
1199
1200 static UINT ACTION_CustomAction(MSIPACKAGE *package,const WCHAR *action)
1201 {
1202     UINT rc = ERROR_SUCCESS;
1203     MSIQUERY * view;
1204     MSIRECORD * row = 0;
1205     static const WCHAR ExecSeqQuery[] =
1206     {'s','e','l','e','c','t',' ','*',' ','f','r','o','m',' ','C','u','s','t','o'
1207         ,'m','A','c','t','i','o','n',' ','w','h','e','r','e',' ','`','A','c','t','i'
1208         ,'o','n','`',' ','=',' ','`','%','s','`',0};
1209     UINT type;
1210     LPWSTR source;
1211     LPWSTR target;
1212     WCHAR *deformated=NULL;
1213
1214     rc = ACTION_OpenQuery(package->db, &view, ExecSeqQuery, action);
1215     if (rc != ERROR_SUCCESS)
1216         return rc;
1217
1218     rc = MSI_ViewExecute(view, 0);
1219     if (rc != ERROR_SUCCESS)
1220     {
1221         MSI_ViewClose(view);
1222         msiobj_release(&view->hdr);
1223         return rc;
1224     }
1225
1226     rc = MSI_ViewFetch(view,&row);
1227     if (rc != ERROR_SUCCESS)
1228     {
1229         MSI_ViewClose(view);
1230         msiobj_release(&view->hdr);
1231         return rc;
1232     }
1233
1234     type = MSI_RecordGetInteger(row,2);
1235
1236     source = load_dynamic_stringW(row,3);
1237     target = load_dynamic_stringW(row,4);
1238
1239     TRACE("Handling custom action %s (%x %s %s)\n",debugstr_w(action),type,
1240           debugstr_w(source), debugstr_w(target));
1241
1242     /* we are ignoring ALOT of flags and important synchronization stuff */
1243     switch (type & CUSTOM_ACTION_TYPE_MASK)
1244     {
1245         case 1: /* DLL file stored in a Binary table stream */
1246             rc = HANDLE_CustomType1(package,source,target,type);
1247             break;
1248         case 2: /* EXE file stored in a Binary table strem */
1249             rc = HANDLE_CustomType2(package,source,target,type);
1250             break;
1251         case 18: /*EXE file installed with package */
1252             rc = HANDLE_CustomType18(package,source,target,type);
1253             break;
1254         case 50: /*EXE file specified by a property value */
1255             rc = HANDLE_CustomType50(package,source,target,type);
1256             break;
1257         case 34: /*EXE to be run in specified directory */
1258             rc = HANDLE_CustomType34(package,source,target,type);
1259             break;
1260         case 35: /* Directory set with formatted text. */
1261         case 51: /* Property set with formatted text. */
1262             deformat_string(package,target,&deformated);
1263             rc = MSI_SetPropertyW(package,source,deformated);
1264             HeapFree(GetProcessHeap(),0,deformated);
1265             break;
1266         default:
1267             FIXME("UNHANDLED ACTION TYPE %i (%s %s)\n",
1268              type & CUSTOM_ACTION_TYPE_MASK, debugstr_w(source),
1269              debugstr_w(target));
1270     }
1271
1272     HeapFree(GetProcessHeap(),0,source);
1273     HeapFree(GetProcessHeap(),0,target);
1274     msiobj_release(&row->hdr);
1275     MSI_ViewClose(view);
1276     msiobj_release(&view->hdr);
1277     return rc;
1278 }
1279
1280 static UINT store_binary_to_temp(MSIPACKAGE *package, const LPWSTR source,
1281                                 LPWSTR tmp_file)
1282 {
1283     DWORD sz=MAX_PATH;
1284
1285     if (MSI_GetPropertyW(package, cszTempFolder, tmp_file, &sz)
1286         != ERROR_SUCCESS)
1287         GetTempPathW(MAX_PATH,tmp_file);
1288
1289     strcatW(tmp_file,source);
1290
1291     if (GetFileAttributesW(tmp_file) != INVALID_FILE_ATTRIBUTES)
1292     {
1293         TRACE("File already exists\n");
1294         return ERROR_SUCCESS;
1295     }
1296     else
1297     {
1298         /* write out the file */
1299         UINT rc;
1300         MSIQUERY * view;
1301         MSIRECORD * row = 0;
1302         static const WCHAR fmt[] =
1303         {'s','e','l','e','c','t',' ','*',' ','f','r','o','m',' ','B','i'
1304 ,'n','a','r','y',' ','w','h','e','r','e',' ','N','a','m','e','=','`','%','s','`',0};
1305         HANDLE the_file;
1306         CHAR buffer[1024];
1307
1308         if (track_tempfile(package, source, tmp_file)!=0)
1309             FIXME("File Name in temp tracking collision\n");
1310
1311         the_file = CreateFileW(tmp_file, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
1312                            FILE_ATTRIBUTE_NORMAL, NULL);
1313
1314         if (the_file == INVALID_HANDLE_VALUE)
1315             return ERROR_FUNCTION_FAILED;
1316
1317         rc = ACTION_OpenQuery(package->db, &view, fmt, source);
1318         if (rc != ERROR_SUCCESS)
1319             return rc;
1320
1321         rc = MSI_ViewExecute(view, 0);
1322         if (rc != ERROR_SUCCESS)
1323         {
1324             MSI_ViewClose(view);
1325             msiobj_release(&view->hdr);
1326             return rc;
1327         }
1328
1329         rc = MSI_ViewFetch(view,&row);
1330         if (rc != ERROR_SUCCESS)
1331         {
1332             MSI_ViewClose(view);
1333             msiobj_release(&view->hdr);
1334             return rc;
1335         }
1336
1337         do
1338         {
1339             DWORD write;
1340             sz = 1024;
1341             rc = MSI_RecordReadStream(row,2,buffer,&sz);
1342             if (rc != ERROR_SUCCESS)
1343             {
1344                 ERR("Failed to get stream\n");
1345                 CloseHandle(the_file);
1346                 DeleteFileW(tmp_file);
1347                 break;
1348             }
1349             WriteFile(the_file,buffer,sz,&write,NULL);
1350         } while (sz == 1024);
1351
1352         CloseHandle(the_file);
1353
1354         msiobj_release(&row->hdr);
1355         MSI_ViewClose(view);
1356         msiobj_release(&view->hdr);
1357     }
1358
1359     return ERROR_SUCCESS;
1360 }
1361
1362 typedef UINT __stdcall CustomEntry(MSIHANDLE);
1363 typedef struct
1364 {
1365         MSIPACKAGE *package;
1366         WCHAR *target;
1367         WCHAR *source;
1368 } thread_struct;
1369
1370 static DWORD WINAPI DllThread(LPVOID info)
1371 {
1372     HANDLE DLL;
1373     LPSTR proc;
1374     thread_struct *stuff;
1375     CustomEntry *fn;
1376
1377     stuff = (thread_struct*)info;
1378
1379     TRACE("Asynchronous start (%s, %s) \n", debugstr_w(stuff->source),
1380           debugstr_w(stuff->target));
1381
1382     DLL = LoadLibraryW(stuff->source);
1383     if (DLL)
1384     {
1385         proc = strdupWtoA( stuff->target );
1386         fn = (CustomEntry*)GetProcAddress(DLL,proc);
1387         if (fn)
1388         {
1389             MSIHANDLE hPackage;
1390             MSIPACKAGE *package = stuff->package;
1391
1392             TRACE("Calling function\n");
1393             hPackage = msiobj_findhandle( &package->hdr );
1394             if( !hPackage )
1395                 ERR("Handle for object %p not found\n", package );
1396             fn(hPackage);
1397             msiobj_release( &package->hdr );
1398         }
1399         else
1400             ERR("Cannot load functon\n");
1401
1402         HeapFree(GetProcessHeap(),0,proc);
1403         FreeLibrary(DLL);
1404     }
1405     else
1406         ERR("Unable to load library\n");
1407     msiobj_release( &stuff->package->hdr );
1408     HeapFree(GetProcessHeap(),0,stuff->source);
1409     HeapFree(GetProcessHeap(),0,stuff->target);
1410     HeapFree(GetProcessHeap(), 0, stuff);
1411     return 0;
1412 }
1413
1414 static UINT HANDLE_CustomType1(MSIPACKAGE *package, const LPWSTR source,
1415                                 const LPWSTR target, const INT type)
1416 {
1417     WCHAR tmp_file[MAX_PATH];
1418     CustomEntry *fn;
1419     HANDLE DLL;
1420     LPSTR proc;
1421
1422     store_binary_to_temp(package, source, tmp_file);
1423
1424     TRACE("Calling function %s from %s\n",debugstr_w(target),
1425           debugstr_w(tmp_file));
1426
1427     if (!strchrW(tmp_file,'.'))
1428     {
1429         static const WCHAR dot[]={'.',0};
1430         strcatW(tmp_file,dot);
1431     }
1432
1433     if (type & 0xc0)
1434     {
1435         DWORD ThreadId;
1436         HANDLE ThreadHandle;
1437         thread_struct *info = HeapAlloc( GetProcessHeap(), 0, sizeof(*info) );
1438
1439         msiobj_addref( &package->hdr );
1440         info->package = package;
1441         info->target = dupstrW(target);
1442         info->source = dupstrW(tmp_file);
1443         TRACE("Start Asynchronous execution of dll\n");
1444         ThreadHandle = CreateThread(NULL,0,DllThread,(LPVOID)info,0,&ThreadId);
1445         CloseHandle(ThreadHandle);
1446         /* FIXME: release the package if the CreateThread fails */
1447         return ERROR_SUCCESS;
1448     }
1449
1450     DLL = LoadLibraryW(tmp_file);
1451     if (DLL)
1452     {
1453         proc = strdupWtoA( target );
1454         fn = (CustomEntry*)GetProcAddress(DLL,proc);
1455         if (fn)
1456         {
1457             MSIHANDLE hPackage;
1458
1459             TRACE("Calling function\n");
1460             hPackage = msiobj_findhandle( &package->hdr );
1461             if( !hPackage )
1462                 ERR("Handle for object %p not found\n", package );
1463             fn(hPackage);
1464             msiobj_release( &package->hdr );
1465         }
1466         else
1467             ERR("Cannot load functon\n");
1468
1469         HeapFree(GetProcessHeap(),0,proc);
1470         FreeLibrary(DLL);
1471     }
1472     else
1473         ERR("Unable to load library\n");
1474
1475     return ERROR_SUCCESS;
1476 }
1477
1478 static UINT HANDLE_CustomType2(MSIPACKAGE *package, const LPWSTR source,
1479                                 const LPWSTR target, const INT type)
1480 {
1481     WCHAR tmp_file[MAX_PATH];
1482     STARTUPINFOW si;
1483     PROCESS_INFORMATION info;
1484     BOOL rc;
1485     INT len;
1486     WCHAR *deformated;
1487     WCHAR *cmd;
1488     static const WCHAR spc[] = {' ',0};
1489
1490     memset(&si,0,sizeof(STARTUPINFOW));
1491
1492     store_binary_to_temp(package, source, tmp_file);
1493
1494     deformat_string(package,target,&deformated);
1495
1496     len = strlenW(tmp_file) + strlenW(deformated) + 2;
1497
1498     cmd = (WCHAR*)HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*len);
1499
1500     strcpyW(cmd,tmp_file);
1501     strcatW(cmd,spc);
1502     strcatW(cmd,deformated);
1503
1504     HeapFree(GetProcessHeap(),0,deformated);
1505
1506     TRACE("executing exe %s \n",debugstr_w(cmd));
1507
1508     rc = CreateProcessW(NULL, cmd, NULL, NULL, FALSE, 0, NULL,
1509                   c_collen, &si, &info);
1510
1511     HeapFree(GetProcessHeap(),0,cmd);
1512
1513     if ( !rc )
1514     {
1515         ERR("Unable to execute command\n");
1516         return ERROR_SUCCESS;
1517     }
1518
1519     if (!(type & 0xc0))
1520         WaitForSingleObject(info.hProcess,INFINITE);
1521
1522     CloseHandle( info.hProcess );
1523     CloseHandle( info.hThread );
1524     return ERROR_SUCCESS;
1525 }
1526
1527 static UINT HANDLE_CustomType18(MSIPACKAGE *package, const LPWSTR source,
1528                                 const LPWSTR target, const INT type)
1529 {
1530     STARTUPINFOW si;
1531     PROCESS_INFORMATION info;
1532     BOOL rc;
1533     WCHAR *deformated;
1534     WCHAR *cmd;
1535     INT len;
1536     static const WCHAR spc[] = {' ',0};
1537     int index;
1538
1539     memset(&si,0,sizeof(STARTUPINFOW));
1540
1541     index = get_loaded_file(package,source);
1542
1543     len = strlenW(package->files[index].TargetPath);
1544
1545     deformat_string(package,target,&deformated);
1546     len += strlenW(deformated);
1547     len += 2;
1548
1549     cmd = (WCHAR*)HeapAlloc(GetProcessHeap(),0,len * sizeof(WCHAR));
1550
1551     strcpyW(cmd, package->files[index].TargetPath);
1552     strcatW(cmd, spc);
1553     strcatW(cmd, deformated);
1554
1555     HeapFree(GetProcessHeap(),0,deformated);
1556
1557     TRACE("executing exe %s \n",debugstr_w(cmd));
1558
1559     rc = CreateProcessW(NULL, cmd, NULL, NULL, FALSE, 0, NULL,
1560                   c_collen, &si, &info);
1561
1562     HeapFree(GetProcessHeap(),0,cmd);
1563
1564     if ( !rc )
1565     {
1566         ERR("Unable to execute command\n");
1567         return ERROR_SUCCESS;
1568     }
1569
1570     if (!(type & 0xc0))
1571         WaitForSingleObject(info.hProcess,INFINITE);
1572
1573     CloseHandle( info.hProcess );
1574     CloseHandle( info.hThread );
1575     return ERROR_SUCCESS;
1576 }
1577
1578 static UINT HANDLE_CustomType50(MSIPACKAGE *package, const LPWSTR source,
1579                                 const LPWSTR target, const INT type)
1580 {
1581     STARTUPINFOW si;
1582     PROCESS_INFORMATION info;
1583     WCHAR *prop;
1584     BOOL rc;
1585     WCHAR *deformated;
1586     WCHAR *cmd;
1587     INT len;
1588     UINT prc;
1589     static const WCHAR spc[] = {' ',0};
1590
1591     memset(&si,0,sizeof(STARTUPINFOW));
1592     memset(&info,0,sizeof(PROCESS_INFORMATION));
1593
1594     prop = load_dynamic_property(package,source,&prc);
1595     if (!prop)
1596         return prc;
1597
1598     deformat_string(package,target,&deformated);
1599     len = strlenW(prop) + strlenW(deformated) + 2;
1600     cmd = (WCHAR*)HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*len);
1601
1602     strcpyW(cmd,prop);
1603     strcatW(cmd,spc);
1604     strcatW(cmd,deformated);
1605
1606     HeapFree(GetProcessHeap(),0,deformated);
1607
1608     TRACE("executing exe %s \n",debugstr_w(cmd));
1609
1610     rc = CreateProcessW(NULL, cmd, NULL, NULL, FALSE, 0, NULL,
1611                   c_collen, &si, &info);
1612
1613     HeapFree(GetProcessHeap(),0,cmd);
1614
1615     if ( !rc )
1616     {
1617         ERR("Unable to execute command\n");
1618         return ERROR_SUCCESS;
1619     }
1620
1621     if (!(type & 0xc0))
1622         WaitForSingleObject(info.hProcess,INFINITE);
1623
1624     CloseHandle( info.hProcess );
1625     CloseHandle( info.hThread );
1626     return ERROR_SUCCESS;
1627 }
1628
1629 static UINT HANDLE_CustomType34(MSIPACKAGE *package, const LPWSTR source,
1630                                 const LPWSTR target, const INT type)
1631 {
1632     LPWSTR filename, deformated;
1633     STARTUPINFOW si;
1634     PROCESS_INFORMATION info;
1635     BOOL rc;
1636
1637     memset(&si,0,sizeof(STARTUPINFOW));
1638
1639     filename = resolve_folder(package, source, FALSE, FALSE, NULL);
1640
1641     if (!filename)
1642         return ERROR_FUNCTION_FAILED;
1643
1644     SetCurrentDirectoryW(filename);
1645     HeapFree(GetProcessHeap(),0,filename);
1646
1647     deformat_string(package,target,&deformated);
1648
1649     TRACE("executing exe %s \n",debugstr_w(deformated));
1650
1651     rc = CreateProcessW(NULL, deformated, NULL, NULL, FALSE, 0, NULL,
1652                   c_collen, &si, &info);
1653     HeapFree(GetProcessHeap(),0,deformated);
1654
1655     if ( !rc )
1656     {
1657         ERR("Unable to execute command\n");
1658         return ERROR_SUCCESS;
1659     }
1660
1661     if (!(type & 0xc0))
1662         WaitForSingleObject(info.hProcess,INFINITE);
1663
1664     CloseHandle( info.hProcess );
1665     CloseHandle( info.hThread );
1666     return ERROR_SUCCESS;
1667 }
1668
1669 /***********************************************************************
1670  *            create_full_pathW
1671  *
1672  * Recursively create all directories in the path.
1673  *
1674  * shamelessly stolen from setupapi/queue.c
1675  */
1676 static BOOL create_full_pathW(const WCHAR *path)
1677 {
1678     BOOL ret = TRUE;
1679     int len;
1680     WCHAR *new_path;
1681
1682     new_path = HeapAlloc(GetProcessHeap(), 0, (strlenW(path) + 1) *
1683                                               sizeof(WCHAR));
1684
1685     strcpyW(new_path, path);
1686
1687     while((len = strlenW(new_path)) && new_path[len - 1] == '\\')
1688     new_path[len - 1] = 0;
1689
1690     while(!CreateDirectoryW(new_path, NULL))
1691     {
1692     WCHAR *slash;
1693     DWORD last_error = GetLastError();
1694     if(last_error == ERROR_ALREADY_EXISTS)
1695         break;
1696
1697     if(last_error != ERROR_PATH_NOT_FOUND)
1698     {
1699         ret = FALSE;
1700         break;
1701     }
1702
1703     if(!(slash = strrchrW(new_path, '\\')))
1704     {
1705         ret = FALSE;
1706         break;
1707     }
1708
1709     len = slash - new_path;
1710     new_path[len] = 0;
1711     if(!create_full_pathW(new_path))
1712     {
1713         ret = FALSE;
1714         break;
1715     }
1716     new_path[len] = '\\';
1717     }
1718
1719     HeapFree(GetProcessHeap(), 0, new_path);
1720     return ret;
1721 }
1722
1723 /*
1724  * Also we cannot enable/disable components either, so for now I am just going
1725  * to do all the directories for all the components.
1726  */
1727 static UINT ACTION_CreateFolders(MSIPACKAGE *package)
1728 {
1729     static const WCHAR ExecSeqQuery[] = {
1730         's','e','l','e','c','t',' ','D','i','r','e','c','t','o','r','y','_',' ',
1731         'f','r','o','m',' ','C','r','e','a','t','e','F','o','l','d','e','r',0 };
1732     UINT rc;
1733     MSIQUERY *view;
1734     MSIFOLDER *folder;
1735
1736     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view );
1737     if (rc != ERROR_SUCCESS)
1738         return ERROR_SUCCESS;
1739
1740     rc = MSI_ViewExecute(view, 0);
1741     if (rc != ERROR_SUCCESS)
1742     {
1743         MSI_ViewClose(view);
1744         msiobj_release(&view->hdr);
1745         return rc;
1746     }
1747
1748     while (1)
1749     {
1750         WCHAR dir[0x100];
1751         LPWSTR full_path;
1752         DWORD sz;
1753         MSIRECORD *row = NULL, *uirow;
1754
1755         rc = MSI_ViewFetch(view,&row);
1756         if (rc != ERROR_SUCCESS)
1757         {
1758             rc = ERROR_SUCCESS;
1759             break;
1760         }
1761
1762         sz=0x100;
1763         rc = MSI_RecordGetStringW(row,1,dir,&sz);
1764
1765         if (rc!= ERROR_SUCCESS)
1766         {
1767             ERR("Unable to get folder id \n");
1768             msiobj_release(&row->hdr);
1769             continue;
1770         }
1771
1772         sz = MAX_PATH;
1773         full_path = resolve_folder(package,dir,FALSE,FALSE,&folder);
1774         if (!full_path)
1775         {
1776             ERR("Unable to resolve folder id %s\n",debugstr_w(dir));
1777             msiobj_release(&row->hdr);
1778             continue;
1779         }
1780
1781         TRACE("Folder is %s\n",debugstr_w(full_path));
1782
1783         /* UI stuff */
1784         uirow = MSI_CreateRecord(1);
1785         MSI_RecordSetStringW(uirow,1,full_path);
1786         ui_actiondata(package,szCreateFolders,uirow);
1787         msiobj_release( &uirow->hdr );
1788
1789         if (folder->State == 0)
1790             create_full_pathW(full_path);
1791
1792         folder->State = 3;
1793
1794         msiobj_release(&row->hdr);
1795         HeapFree(GetProcessHeap(),0,full_path);
1796     }
1797     MSI_ViewClose(view);
1798     msiobj_release(&view->hdr);
1799
1800     return rc;
1801 }
1802
1803 static int load_component(MSIPACKAGE* package, MSIRECORD * row)
1804 {
1805     int index = package->loaded_components;
1806     DWORD sz;
1807
1808     /* fill in the data */
1809
1810     package->loaded_components++;
1811     if (package->loaded_components == 1)
1812         package->components = HeapAlloc(GetProcessHeap(),0,
1813                                         sizeof(MSICOMPONENT));
1814     else
1815         package->components = HeapReAlloc(GetProcessHeap(),0,
1816             package->components, package->loaded_components *
1817             sizeof(MSICOMPONENT));
1818
1819     memset(&package->components[index],0,sizeof(MSICOMPONENT));
1820
1821     sz = 96;
1822     MSI_RecordGetStringW(row,1,package->components[index].Component,&sz);
1823
1824     TRACE("Loading Component %s\n",
1825            debugstr_w(package->components[index].Component));
1826
1827     sz = 0x100;
1828     if (!MSI_RecordIsNull(row,2))
1829         MSI_RecordGetStringW(row,2,package->components[index].ComponentId,&sz);
1830
1831     sz = 96;
1832     MSI_RecordGetStringW(row,3,package->components[index].Directory,&sz);
1833
1834     package->components[index].Attributes = MSI_RecordGetInteger(row,4);
1835
1836     sz = 0x100;
1837     MSI_RecordGetStringW(row,5,package->components[index].Condition,&sz);
1838
1839     sz = 96;
1840     MSI_RecordGetStringW(row,6,package->components[index].KeyPath,&sz);
1841
1842     package->components[index].Installed = INSTALLSTATE_ABSENT;
1843     package->components[index].Action = INSTALLSTATE_UNKNOWN;
1844     package->components[index].ActionRequest = INSTALLSTATE_UNKNOWN;
1845
1846     package->components[index].Enabled = TRUE;
1847
1848     return index;
1849 }
1850
1851 static void load_feature(MSIPACKAGE* package, MSIRECORD * row)
1852 {
1853     int index = package->loaded_features;
1854     DWORD sz;
1855     static const WCHAR Query1[] = {'S','E','L','E','C','T',' ','C','o','m','p',
1856         'o','n','e','n','t','_',' ','F','R','O','M',' ','F','e','a','t','u','r','e',
1857         'C','o','m','p','o','n','e','n','t','s',' ','W','H','E','R','E',' ','F','e',
1858         'a','t','u','r','e','_','=','\'','%','s','\'',0};
1859     static const WCHAR Query2[] = {'S','E','L','E','C','T',' ','*',' ','F','R',
1860         'O','M',' ','C','o','m','p','o','n','e','n','t',' ','W','H','E','R','E',' ','C',
1861         'o','m','p','o','n','e','n','t','=','\'','%','s','\'',0};
1862     MSIQUERY * view;
1863     MSIQUERY * view2;
1864     MSIRECORD * row2;
1865     MSIRECORD * row3;
1866     UINT    rc;
1867
1868     /* fill in the data */
1869
1870     package->loaded_features ++;
1871     if (package->loaded_features == 1)
1872         package->features = HeapAlloc(GetProcessHeap(),0,sizeof(MSIFEATURE));
1873     else
1874         package->features = HeapReAlloc(GetProcessHeap(),0,package->features,
1875                                 package->loaded_features * sizeof(MSIFEATURE));
1876
1877     memset(&package->features[index],0,sizeof(MSIFEATURE));
1878
1879     sz = 96;
1880     MSI_RecordGetStringW(row,1,package->features[index].Feature,&sz);
1881
1882     TRACE("Loading feature %s\n",debugstr_w(package->features[index].Feature));
1883
1884     sz = 96;
1885     if (!MSI_RecordIsNull(row,2))
1886         MSI_RecordGetStringW(row,2,package->features[index].Feature_Parent,&sz);
1887
1888     sz = 0x100;
1889      if (!MSI_RecordIsNull(row,3))
1890         MSI_RecordGetStringW(row,3,package->features[index].Title,&sz);
1891
1892      sz = 0x100;
1893      if (!MSI_RecordIsNull(row,4))
1894         MSI_RecordGetStringW(row,4,package->features[index].Description,&sz);
1895
1896     if (!MSI_RecordIsNull(row,5))
1897         package->features[index].Display = MSI_RecordGetInteger(row,5);
1898
1899     package->features[index].Level= MSI_RecordGetInteger(row,6);
1900
1901      sz = 96;
1902      if (!MSI_RecordIsNull(row,7))
1903         MSI_RecordGetStringW(row,7,package->features[index].Directory,&sz);
1904
1905     package->features[index].Attributes= MSI_RecordGetInteger(row,8);
1906
1907     package->features[index].Installed = INSTALLSTATE_ABSENT;
1908     package->features[index].Action = INSTALLSTATE_UNKNOWN;
1909     package->features[index].ActionRequest = INSTALLSTATE_UNKNOWN;
1910
1911     /* load feature components */
1912
1913     rc = ACTION_OpenQuery(package->db, &view, Query1, package->features[index].Feature);
1914     if (rc != ERROR_SUCCESS)
1915         return;
1916     rc = MSI_ViewExecute(view,0);
1917     if (rc != ERROR_SUCCESS)
1918     {
1919         MSI_ViewClose(view);
1920         msiobj_release(&view->hdr);
1921         return;
1922     }
1923     while (1)
1924     {
1925         DWORD sz = 0x100;
1926         WCHAR buffer[0x100];
1927         DWORD rc;
1928         INT c_indx;
1929         INT cnt = package->features[index].ComponentCount;
1930
1931         rc = MSI_ViewFetch(view,&row2);
1932         if (rc != ERROR_SUCCESS)
1933             break;
1934
1935         sz = 0x100;
1936         MSI_RecordGetStringW(row2,1,buffer,&sz);
1937
1938         /* check to see if the component is already loaded */
1939         c_indx = get_loaded_component(package,buffer);
1940         if (c_indx != -1)
1941         {
1942             TRACE("Component %s already loaded at %i\n", debugstr_w(buffer),
1943                   c_indx);
1944             package->features[index].Components[cnt] = c_indx;
1945             package->features[index].ComponentCount ++;
1946         }
1947
1948         rc = ACTION_OpenQuery(package->db, &view2, Query2, buffer);
1949         if (rc != ERROR_SUCCESS)
1950         {
1951             msiobj_release( &row2->hdr );
1952             continue;
1953         }
1954         rc = MSI_ViewExecute(view2,0);
1955         if (rc != ERROR_SUCCESS)
1956         {
1957             msiobj_release( &row2->hdr );
1958             MSI_ViewClose(view2);
1959             msiobj_release( &view2->hdr );
1960             continue;
1961         }
1962         while (1)
1963         {
1964             DWORD rc;
1965
1966             rc = MSI_ViewFetch(view2,&row3);
1967             if (rc != ERROR_SUCCESS)
1968                 break;
1969             c_indx = load_component(package,row3);
1970             msiobj_release( &row3->hdr );
1971
1972             package->features[index].Components[cnt] = c_indx;
1973             package->features[index].ComponentCount ++;
1974         }
1975         MSI_ViewClose(view2);
1976         msiobj_release( &view2->hdr );
1977         msiobj_release( &row2->hdr );
1978     }
1979     MSI_ViewClose(view);
1980     msiobj_release(&view->hdr);
1981 }
1982
1983 /*
1984  * I am not doing any of the costing functionality yet.
1985  * Mostly looking at doing the Component and Feature loading
1986  *
1987  * The native MSI does ALOT of modification to tables here. Mostly adding alot
1988  * of temporary columns to the Feature and Component tables.
1989  *
1990  *    note: native msi also tracks the short filename. but I am only going to
1991  *          track the long ones.  Also looking at this directory table
1992  *          it appears that the directory table does not get the parents
1993  *          resolved base on property only based on their entrys in the
1994  *          directory table.
1995  */
1996 static UINT ACTION_CostInitialize(MSIPACKAGE *package)
1997 {
1998     MSIQUERY * view;
1999     MSIRECORD * row;
2000     UINT rc;
2001     static const WCHAR Query_all[] = {
2002        'S','E','L','E','C','T',' ','*',' ',
2003        'F','R','O','M',' ','F','e','a','t','u','r','e',0};
2004     static const WCHAR szCosting[] = {
2005        'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
2006     static const WCHAR szZero[] = { '0', 0 };
2007
2008     MSI_SetPropertyW(package, szCosting, szZero);
2009     MSI_SetPropertyW(package, cszRootDrive , c_collen);
2010
2011     rc = MSI_DatabaseOpenViewW(package->db,Query_all,&view);
2012     if (rc != ERROR_SUCCESS)
2013         return rc;
2014     rc = MSI_ViewExecute(view,0);
2015     if (rc != ERROR_SUCCESS)
2016     {
2017         MSI_ViewClose(view);
2018         msiobj_release(&view->hdr);
2019         return rc;
2020     }
2021     while (1)
2022     {
2023         DWORD rc;
2024
2025         rc = MSI_ViewFetch(view,&row);
2026         if (rc != ERROR_SUCCESS)
2027             break;
2028
2029         load_feature(package,row);
2030         msiobj_release(&row->hdr);
2031     }
2032     MSI_ViewClose(view);
2033     msiobj_release(&view->hdr);
2034
2035     return ERROR_SUCCESS;
2036 }
2037
2038 static UINT load_file(MSIPACKAGE* package, MSIRECORD * row)
2039 {
2040     DWORD index = package->loaded_files;
2041     DWORD i;
2042     LPWSTR buffer;
2043
2044     /* fill in the data */
2045
2046     package->loaded_files++;
2047     if (package->loaded_files== 1)
2048         package->files = HeapAlloc(GetProcessHeap(),0,sizeof(MSIFILE));
2049     else
2050         package->files = HeapReAlloc(GetProcessHeap(),0,
2051             package->files , package->loaded_files * sizeof(MSIFILE));
2052
2053     memset(&package->files[index],0,sizeof(MSIFILE));
2054
2055     package->files[index].File = load_dynamic_stringW(row, 1);
2056     buffer = load_dynamic_stringW(row, 2);
2057
2058     package->files[index].ComponentIndex = -1;
2059     for (i = 0; i < package->loaded_components; i++)
2060         if (strcmpW(package->components[i].Component,buffer)==0)
2061         {
2062             package->files[index].ComponentIndex = i;
2063             break;
2064         }
2065     if (package->files[index].ComponentIndex == -1)
2066         ERR("Unfound Component %s\n",debugstr_w(buffer));
2067     HeapFree(GetProcessHeap(), 0, buffer);
2068
2069     package->files[index].FileName = load_dynamic_stringW(row,3);
2070
2071     reduce_to_longfilename(package->files[index].FileName);
2072
2073     package->files[index].FileSize = MSI_RecordGetInteger(row,4);
2074     package->files[index].Version = load_dynamic_stringW(row, 5);
2075     package->files[index].Language = load_dynamic_stringW(row, 6);
2076     package->files[index].Attributes= MSI_RecordGetInteger(row,7);
2077     package->files[index].Sequence= MSI_RecordGetInteger(row,8);
2078
2079     package->files[index].Temporary = FALSE;
2080     package->files[index].State = 0;
2081
2082     TRACE("File Loaded (%s)\n",debugstr_w(package->files[index].File));
2083
2084     return ERROR_SUCCESS;
2085 }
2086
2087 static UINT ACTION_FileCost(MSIPACKAGE *package)
2088 {
2089     MSIQUERY * view;
2090     MSIRECORD * row;
2091     UINT rc;
2092     static const WCHAR Query[] = {
2093         'S','E','L','E','C','T',' ','*',' ',
2094         'F','R','O','M',' ','F','i','l','e',' ',
2095         'O','r','d','e','r',' ','b','y',' ','S','e','q','u','e','n','c','e', 0};
2096
2097     if (!package)
2098         return ERROR_INVALID_HANDLE;
2099
2100     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
2101     if (rc != ERROR_SUCCESS)
2102         return ERROR_SUCCESS;
2103
2104     rc = MSI_ViewExecute(view, 0);
2105     if (rc != ERROR_SUCCESS)
2106     {
2107         MSI_ViewClose(view);
2108         msiobj_release(&view->hdr);
2109         return ERROR_SUCCESS;
2110     }
2111
2112     while (1)
2113     {
2114         rc = MSI_ViewFetch(view,&row);
2115         if (rc != ERROR_SUCCESS)
2116         {
2117             rc = ERROR_SUCCESS;
2118             break;
2119         }
2120         load_file(package,row);
2121         msiobj_release(&row->hdr);
2122     }
2123     MSI_ViewClose(view);
2124     msiobj_release(&view->hdr);
2125
2126     return ERROR_SUCCESS;
2127 }
2128
2129 static INT load_folder(MSIPACKAGE *package, const WCHAR* dir)
2130
2131 {
2132     static const WCHAR Query[] =
2133         {'s','e','l','e','c','t',' ','*',' ','f','r','o','m',' ','D','i','r','e','c',
2134          't','o','r','y',' ','w','h','e','r','e',' ','`','D','i','r','e','c','t',
2135          'o','r','y','`',' ','=',' ','`','%','s','`',0};
2136     UINT rc;
2137     MSIQUERY * view;
2138     LPWSTR targetdir, parent, srcdir;
2139     MSIRECORD * row = 0;
2140     INT index = -1;
2141     DWORD i;
2142
2143     TRACE("Looking for dir %s\n",debugstr_w(dir));
2144
2145     for (i = 0; i < package->loaded_folders; i++)
2146     {
2147         if (strcmpW(package->folders[i].Directory,dir)==0)
2148         {
2149             TRACE(" %s retuning on index %lu\n",debugstr_w(dir),i);
2150             return i;
2151         }
2152     }
2153
2154     TRACE("Working to load %s\n",debugstr_w(dir));
2155
2156     index = package->loaded_folders++;
2157     if (package->loaded_folders==1)
2158         package->folders = HeapAlloc(GetProcessHeap(),0,
2159                                         sizeof(MSIFOLDER));
2160     else
2161         package->folders= HeapReAlloc(GetProcessHeap(),0,
2162             package->folders, package->loaded_folders*
2163             sizeof(MSIFOLDER));
2164
2165     memset(&package->folders[index],0,sizeof(MSIFOLDER));
2166
2167     package->folders[index].Directory = dupstrW(dir);
2168
2169     rc = ACTION_OpenQuery(package->db, &view, Query, dir);
2170     if (rc != ERROR_SUCCESS)
2171         return -1;
2172
2173     rc = MSI_ViewExecute(view, 0);
2174     if (rc != ERROR_SUCCESS)
2175     {
2176         MSI_ViewClose(view);
2177         msiobj_release(&view->hdr);
2178         return -1;
2179     }
2180
2181     rc = MSI_ViewFetch(view,&row);
2182     if (rc != ERROR_SUCCESS)
2183     {
2184         MSI_ViewClose(view);
2185         msiobj_release(&view->hdr);
2186         return -1;
2187     }
2188
2189     targetdir = load_dynamic_stringW(row,3);
2190
2191     /* split src and target dir */
2192     if (strchrW(targetdir,':'))
2193     {
2194         srcdir=strchrW(targetdir,':');
2195         *srcdir=0;
2196         srcdir ++;
2197     }
2198     else
2199         srcdir=NULL;
2200
2201     /* for now only pick long filename versions */
2202     if (strchrW(targetdir,'|'))
2203     {
2204         targetdir = strchrW(targetdir,'|');
2205         *targetdir = 0;
2206         targetdir ++;
2207     }
2208     if (srcdir && strchrW(srcdir,'|'))
2209     {
2210         srcdir= strchrW(srcdir,'|');
2211         *srcdir= 0;
2212         srcdir ++;
2213     }
2214
2215     /* now check for root dirs */
2216     if (targetdir[0] == '.' && targetdir[1] == 0)
2217         targetdir = NULL;
2218
2219     if (srcdir && srcdir[0] == '.' && srcdir[1] == 0)
2220         srcdir = NULL;
2221
2222     if (targetdir)
2223     {
2224         TRACE("   TargetDefault = %s\n",debugstr_w(targetdir));
2225         if (package->folders[index].TargetDefault)
2226             HeapFree(GetProcessHeap(),0, package->folders[index].TargetDefault);
2227         package->folders[index].TargetDefault = dupstrW(targetdir);
2228     }
2229
2230     if (srcdir)
2231        package->folders[index].SourceDefault = dupstrW(srcdir);
2232     else if (targetdir)
2233         package->folders[index].SourceDefault = dupstrW(targetdir);
2234     HeapFree(GetProcessHeap(), 0, targetdir);
2235
2236     parent = load_dynamic_stringW(row,2);
2237     if (parent)
2238     {
2239         i = load_folder(package,parent);
2240         package->folders[index].ParentIndex = i;
2241         TRACE("Parent is index %i... %s %s\n",
2242                     package->folders[index].ParentIndex,
2243         debugstr_w(package->folders[package->folders[index].ParentIndex].Directory),
2244                     debugstr_w(parent));
2245     }
2246     else
2247         package->folders[index].ParentIndex = -2;
2248     HeapFree(GetProcessHeap(), 0, parent);
2249
2250     package->folders[index].Property = load_dynamic_property(package, dir,NULL);
2251
2252     msiobj_release(&row->hdr);
2253     MSI_ViewClose(view);
2254     msiobj_release(&view->hdr);
2255     TRACE(" %s retuning on index %i\n",debugstr_w(dir),index);
2256     return index;
2257 }
2258
2259
2260 static LPWSTR resolve_folder(MSIPACKAGE *package, LPCWSTR name,
2261                            BOOL source, BOOL set_prop, MSIFOLDER **folder)
2262 {
2263     DWORD i;
2264     LPWSTR p, path = NULL;
2265
2266     TRACE("Working to resolve %s\n",debugstr_w(name));
2267
2268     /* special resolving for Target and Source root dir */
2269     if (strcmpW(name,cszTargetDir)==0 || strcmpW(name,cszSourceDir)==0)
2270     {
2271         if (!source)
2272         {
2273             path = load_dynamic_property(package,cszTargetDir,NULL);
2274             if (!path)
2275             {
2276                 path = load_dynamic_property(package,cszRootDrive,NULL);
2277                 if (set_prop)
2278                     MSI_SetPropertyW(package,cszTargetDir,path);
2279             }
2280             if (folder)
2281                 *folder = &(package->folders[0]);
2282             return path;
2283         }
2284         else
2285         {
2286             path = load_dynamic_property(package,cszSourceDir,NULL);
2287             if (!path)
2288             {
2289                 path = load_dynamic_property(package,cszDatabase,NULL);
2290                 if (path)
2291                 {
2292                     p = strrchrW(path,'\\');
2293                     if (p)
2294                         *(p+1) = 0;
2295                 }
2296             }
2297             if (folder)
2298                 *folder = &(package->folders[0]);
2299             return path;
2300         }
2301     }
2302
2303     for (i = 0; i < package->loaded_folders; i++)
2304     {
2305         if (strcmpW(package->folders[i].Directory,name)==0)
2306             break;
2307     }
2308
2309     if (i >= package->loaded_folders)
2310         return NULL;
2311
2312     if (folder)
2313         *folder = &(package->folders[i]);
2314
2315     if (!source && package->folders[i].ResolvedTarget)
2316     {
2317         path = dupstrW(package->folders[i].ResolvedTarget);
2318         TRACE("   already resolved to %s\n",debugstr_w(path));
2319         return path;
2320     }
2321     else if (source && package->folders[i].ResolvedSource)
2322     {
2323         path = dupstrW(package->folders[i].ResolvedSource);
2324         return path;
2325     }
2326     else if (!source && package->folders[i].Property)
2327     {
2328         path = dupstrW(package->folders[i].Property);
2329         TRACE("   internally set to %s\n",debugstr_w(path));
2330         if (set_prop)
2331             MSI_SetPropertyW(package,name,path);
2332         return path;
2333     }
2334
2335     if (package->folders[i].ParentIndex >= 0)
2336     {
2337         LPWSTR parent = package->folders[package->folders[i].ParentIndex].Directory;
2338
2339         TRACE(" ! Parent is %s\n", debugstr_w(parent));
2340
2341         p = resolve_folder(package, parent, source, set_prop, NULL);
2342         if (!source)
2343         {
2344             TRACE("   TargetDefault = %s\n",debugstr_w(package->folders[i].TargetDefault));
2345             path = build_directory_name(3, p, package->folders[i].TargetDefault, NULL);
2346             package->folders[i].ResolvedTarget = dupstrW(path);
2347             TRACE("   resolved into %s\n",debugstr_w(path));
2348             if (set_prop)
2349                 MSI_SetPropertyW(package,name,path);
2350         }
2351         else
2352         {
2353             path = build_directory_name(3, p, package->folders[i].SourceDefault, NULL);
2354             package->folders[i].ResolvedSource = dupstrW(path);
2355         }
2356         HeapFree(GetProcessHeap(),0,p);
2357     }
2358     return path;
2359 }
2360
2361 static UINT SetFeatureStates(MSIPACKAGE *package)
2362 {
2363     LPWSTR level;
2364     INT install_level;
2365     DWORD i;
2366     INT j;
2367     LPWSTR override = NULL;
2368     static const WCHAR all[]={'A','L','L',0};
2369     static const WCHAR szlevel[] = {
2370         'I','N','S','T','A','L','L','L','E','V','E','L',0};
2371     static const WCHAR szAddLocal[] = {
2372         'A','D','D','L','O','C','A','L',0};
2373
2374     /* I do not know if this is where it should happen.. but */
2375
2376     TRACE("Checking Install Level\n");
2377
2378     level = load_dynamic_property(package,szlevel,NULL);
2379     if (level)
2380     {
2381         install_level = atoiW(level);
2382         HeapFree(GetProcessHeap(), 0, level);
2383     }
2384     else
2385         install_level = 1;
2386
2387     /* ok hereis the rub
2388      * ADDLOCAL and its friend OVERRIDE INSTALLLEVLE
2389      * I have confirmed this if ADDLOCALis stated then the INSTALLLEVEL is
2390      * itnored for all the features. seems strange, epsecially since it is not
2391      * documented anywhere, but it is how it works.
2392      */
2393
2394     override = load_dynamic_property(package,szAddLocal,NULL);
2395
2396     if (override)
2397     {
2398         for(i = 0; i < package->loaded_features; i++)
2399         {
2400             if (strcmpiW(override,all)==0 ||
2401                 strstrW(override,package->features[i].Feature))
2402             {
2403                 package->features[i].ActionRequest= INSTALLSTATE_LOCAL;
2404                 package->features[i].Action = INSTALLSTATE_LOCAL;
2405             }
2406         }
2407         HeapFree(GetProcessHeap(),0,override);
2408     }
2409     else
2410     {
2411         for(i = 0; i < package->loaded_features; i++)
2412         {
2413             BOOL feature_state= ((package->features[i].Level > 0) &&
2414                              (package->features[i].Level <= install_level));
2415
2416             if (feature_state)
2417             {
2418                 package->features[i].ActionRequest= INSTALLSTATE_LOCAL;
2419                 package->features[i].Action = INSTALLSTATE_LOCAL;
2420             }
2421         }
2422     }
2423
2424     /*
2425      * now we want to enable or disable components base on feature
2426     */
2427
2428     for(i = 0; i < package->loaded_features; i++)
2429     {
2430         MSIFEATURE* feature = &package->features[i];
2431         TRACE("Examining Feature %s (Installed %i, Action %i, Request %i)\n",
2432             debugstr_w(feature->Feature), feature->Installed, feature->Action,
2433             feature->ActionRequest);
2434
2435         for( j = 0; j < feature->ComponentCount; j++)
2436         {
2437             MSICOMPONENT* component = &package->components[
2438                                                     feature->Components[j]];
2439
2440             if (!component->Enabled)
2441             {
2442                 component->Action = INSTALLSTATE_ABSENT;
2443                 component->ActionRequest = INSTALLSTATE_ABSENT;
2444             }
2445             else
2446             {
2447                 if (feature->Action == INSTALLSTATE_LOCAL)
2448                     component->Action = INSTALLSTATE_LOCAL;
2449                 if (feature->ActionRequest == INSTALLSTATE_LOCAL)
2450                     component->ActionRequest = INSTALLSTATE_LOCAL;
2451             }
2452         }
2453     }
2454
2455     for(i = 0; i < package->loaded_components; i++)
2456     {
2457         MSICOMPONENT* component= &package->components[i];
2458
2459         TRACE("Result: Component %s (Installed %i, Action %i, Request %i)\n",
2460             debugstr_w(component->Component), component->Installed,
2461             component->Action, component->ActionRequest);
2462     }
2463
2464
2465     return ERROR_SUCCESS;
2466 }
2467
2468 /*
2469  * Alot is done in this function aside from just the costing.
2470  * The costing needs to be implemented at some point but for now I am going
2471  * to focus on the directory building
2472  *
2473  */
2474 static UINT ACTION_CostFinalize(MSIPACKAGE *package)
2475 {
2476     static const WCHAR ExecSeqQuery[] = {
2477         's','e','l','e','c','t',' ','*',' ','f','r','o','m',' ',
2478         'D','i','r','e','c','t','o','r','y',0};
2479     static const WCHAR ConditionQuery[] = {
2480         's','e','l','e','c','t',' ','*',' ','f','r','o','m',' ',
2481         'C','o','n','d','i','t','i','o','n',0};
2482     static const WCHAR szCosting[] = {
2483        'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
2484     static const WCHAR szlevel[] = {
2485         'I','N','S','T','A','L','L','L','E','V','E','L',0};
2486     static const WCHAR szOne[] = { '1', 0 };
2487     UINT rc;
2488     MSIQUERY * view;
2489     DWORD i;
2490     LPWSTR level;
2491
2492     TRACE("Building Directory properties\n");
2493
2494     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2495     if (rc == ERROR_SUCCESS)
2496     {
2497         rc = MSI_ViewExecute(view, 0);
2498         if (rc != ERROR_SUCCESS)
2499         {
2500             MSI_ViewClose(view);
2501             msiobj_release(&view->hdr);
2502             return rc;
2503         }
2504
2505         while (1)
2506         {
2507             WCHAR name[0x100];
2508             LPWSTR path;
2509             MSIRECORD * row = 0;
2510             DWORD sz;
2511
2512             rc = MSI_ViewFetch(view,&row);
2513             if (rc != ERROR_SUCCESS)
2514             {
2515                 rc = ERROR_SUCCESS;
2516                 break;
2517             }
2518
2519             sz=0x100;
2520             MSI_RecordGetStringW(row,1,name,&sz);
2521
2522             /* This helper function now does ALL the work */
2523             TRACE("Dir %s ...\n",debugstr_w(name));
2524             load_folder(package,name);
2525             path = resolve_folder(package,name,FALSE,TRUE,NULL);
2526             TRACE("resolves to %s\n",debugstr_w(path));
2527             HeapFree( GetProcessHeap(), 0, path);
2528
2529             msiobj_release(&row->hdr);
2530         }
2531         MSI_ViewClose(view);
2532         msiobj_release(&view->hdr);
2533     }
2534
2535     TRACE("File calculations %i files\n",package->loaded_files);
2536
2537     for (i = 0; i < package->loaded_files; i++)
2538     {
2539         MSICOMPONENT* comp = NULL;
2540         MSIFILE* file= NULL;
2541
2542         file = &package->files[i];
2543         if (file->ComponentIndex >= 0)
2544             comp = &package->components[file->ComponentIndex];
2545
2546         if (file->Temporary == TRUE)
2547             continue;
2548
2549         if (comp)
2550         {
2551             LPWSTR p;
2552
2553             /* calculate target */
2554             p = resolve_folder(package, comp->Directory, FALSE, FALSE, NULL);
2555
2556             if (file->TargetPath)
2557                 HeapFree(GetProcessHeap(),0,file->TargetPath);
2558
2559             TRACE("file %s is named %s\n",
2560                    debugstr_w(file->File),debugstr_w(file->FileName));
2561
2562             file->TargetPath = build_directory_name(2, p, file->FileName);
2563
2564             HeapFree(GetProcessHeap(),0,p);
2565
2566             TRACE("file %s resolves to %s\n",
2567                    debugstr_w(file->File),debugstr_w(file->TargetPath));
2568
2569             if (GetFileAttributesW(file->TargetPath) == INVALID_FILE_ATTRIBUTES)
2570             {
2571                 file->State = 1;
2572                 comp->Cost += file->FileSize;
2573             }
2574             else
2575             {
2576                 if (file->Version)
2577                 {
2578                     DWORD handle;
2579                     DWORD versize;
2580                     UINT sz;
2581                     LPVOID version;
2582                     static const WCHAR name[] =
2583                     {'\\',0};
2584                     static const WCHAR name_fmt[] =
2585                     {'%','u','.','%','u','.','%','u','.','%','u',0};
2586                     WCHAR filever[0x100];
2587                     VS_FIXEDFILEINFO *lpVer;
2588
2589                     FIXME("Version comparison.. \n");
2590                     versize = GetFileVersionInfoSizeW(file->TargetPath,&handle);
2591                     version = HeapAlloc(GetProcessHeap(),0,versize);
2592                     GetFileVersionInfoW(file->TargetPath, 0, versize, version);
2593
2594                     VerQueryValueW(version, name, (LPVOID*)&lpVer, &sz);
2595
2596                     sprintfW(filever,name_fmt,
2597                         HIWORD(lpVer->dwFileVersionMS),
2598                         LOWORD(lpVer->dwFileVersionMS),
2599                         HIWORD(lpVer->dwFileVersionLS),
2600                         LOWORD(lpVer->dwFileVersionLS));
2601
2602                     TRACE("new %s old %s\n", debugstr_w(file->Version),
2603                           debugstr_w(filever));
2604                     if (strcmpiW(filever,file->Version)<0)
2605                     {
2606                         file->State = 2;
2607                         FIXME("cost should be diff in size\n");
2608                         comp->Cost += file->FileSize;
2609                     }
2610                     else
2611                         file->State = 3;
2612                     HeapFree(GetProcessHeap(),0,version);
2613                 }
2614                 else
2615                     file->State = 3;
2616             }
2617         }
2618     }
2619
2620     TRACE("Evaluating Condition Table\n");
2621
2622     rc = MSI_DatabaseOpenViewW(package->db, ConditionQuery, &view);
2623     if (rc == ERROR_SUCCESS)
2624     {
2625     rc = MSI_ViewExecute(view, 0);
2626     if (rc != ERROR_SUCCESS)
2627     {
2628         MSI_ViewClose(view);
2629         msiobj_release(&view->hdr);
2630         return rc;
2631     }
2632
2633     while (1)
2634     {
2635         WCHAR Feature[0x100];
2636         MSIRECORD * row = 0;
2637         DWORD sz;
2638         int feature_index;
2639
2640         rc = MSI_ViewFetch(view,&row);
2641
2642         if (rc != ERROR_SUCCESS)
2643         {
2644             rc = ERROR_SUCCESS;
2645             break;
2646         }
2647
2648         sz = 0x100;
2649         MSI_RecordGetStringW(row,1,Feature,&sz);
2650
2651         feature_index = get_loaded_feature(package,Feature);
2652         if (feature_index < 0)
2653             ERR("FAILED to find loaded feature %s\n",debugstr_w(Feature));
2654         else
2655         {
2656             LPWSTR Condition;
2657             Condition = load_dynamic_stringW(row,3);
2658
2659                 if (MSI_EvaluateConditionW(package,Condition) ==
2660                     MSICONDITION_TRUE)
2661             {
2662                 int level = MSI_RecordGetInteger(row,2);
2663                     TRACE("Reseting feature %s to level %i\n",
2664                            debugstr_w(Feature), level);
2665                 package->features[feature_index].Level = level;
2666             }
2667             HeapFree(GetProcessHeap(),0,Condition);
2668         }
2669
2670         msiobj_release(&row->hdr);
2671     }
2672     MSI_ViewClose(view);
2673     msiobj_release(&view->hdr);
2674     }
2675
2676     TRACE("Enabling or Disabling Components\n");
2677     for (i = 0; i < package->loaded_components; i++)
2678     {
2679         if (package->components[i].Condition[0])
2680         {
2681             if (MSI_EvaluateConditionW(package,
2682                 package->components[i].Condition) == MSICONDITION_FALSE)
2683             {
2684                 TRACE("Disabling component %s\n",
2685                       debugstr_w(package->components[i].Component));
2686                 package->components[i].Enabled = FALSE;
2687             }
2688         }
2689     }
2690
2691     MSI_SetPropertyW(package,szCosting,szOne);
2692     /* set default run level if not set */
2693     level = load_dynamic_property(package,szlevel,NULL);
2694     if (!level)
2695         MSI_SetPropertyW(package,szlevel, szOne);
2696     else
2697         HeapFree(GetProcessHeap(),0,level);
2698
2699     return SetFeatureStates(package);
2700
2701 }
2702
2703 /*
2704  * This is a helper function for handling embedded cabinet media
2705  */
2706 static UINT writeout_cabinet_stream(MSIPACKAGE *package, WCHAR* stream_name,
2707                                     WCHAR* source)
2708 {
2709     UINT rc;
2710     USHORT* data;
2711     UINT    size;
2712     DWORD   write;
2713     HANDLE  the_file;
2714     WCHAR tmp[MAX_PATH];
2715
2716     rc = read_raw_stream_data(package->db,stream_name,&data,&size);
2717     if (rc != ERROR_SUCCESS)
2718         return rc;
2719
2720     write = MAX_PATH;
2721     if (MSI_GetPropertyW(package, cszTempFolder, tmp, &write))
2722         GetTempPathW(MAX_PATH,tmp);
2723
2724     GetTempFileNameW(tmp,stream_name,0,source);
2725
2726     track_tempfile(package,strrchrW(source,'\\'), source);
2727     the_file = CreateFileW(source, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
2728                            FILE_ATTRIBUTE_NORMAL, NULL);
2729
2730     if (the_file == INVALID_HANDLE_VALUE)
2731     {
2732         rc = ERROR_FUNCTION_FAILED;
2733         goto end;
2734     }
2735
2736     WriteFile(the_file,data,size,&write,NULL);
2737     CloseHandle(the_file);
2738     TRACE("wrote %li bytes to %s\n",write,debugstr_w(source));
2739 end:
2740     HeapFree(GetProcessHeap(),0,data);
2741     return rc;
2742 }
2743
2744
2745 /* Support functions for FDI functions */
2746 typedef struct
2747 {
2748     MSIPACKAGE* package;
2749     LPCSTR cab_path;
2750 } CabData;
2751
2752 static void * cabinet_alloc(ULONG cb)
2753 {
2754     return HeapAlloc(GetProcessHeap(), 0, cb);
2755 }
2756
2757 static void cabinet_free(void *pv)
2758 {
2759     HeapFree(GetProcessHeap(), 0, pv);
2760 }
2761
2762 static INT_PTR cabinet_open(char *pszFile, int oflag, int pmode)
2763 {
2764     DWORD dwAccess = 0;
2765     DWORD dwShareMode = 0;
2766     DWORD dwCreateDisposition = OPEN_EXISTING;
2767     switch (oflag & _O_ACCMODE)
2768     {
2769     case _O_RDONLY:
2770         dwAccess = GENERIC_READ;
2771         dwShareMode = FILE_SHARE_READ | FILE_SHARE_DELETE;
2772         break;
2773     case _O_WRONLY:
2774         dwAccess = GENERIC_WRITE;
2775         dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
2776         break;
2777     case _O_RDWR:
2778         dwAccess = GENERIC_READ | GENERIC_WRITE;
2779         dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
2780         break;
2781     }
2782     if ((oflag & (_O_CREAT | _O_EXCL)) == (_O_CREAT | _O_EXCL))
2783         dwCreateDisposition = CREATE_NEW;
2784     else if (oflag & _O_CREAT)
2785         dwCreateDisposition = CREATE_ALWAYS;
2786     return (INT_PTR)CreateFileA(pszFile, dwAccess, dwShareMode, NULL, dwCreateDisposition, 0, NULL);
2787 }
2788
2789 static UINT cabinet_read(INT_PTR hf, void *pv, UINT cb)
2790 {
2791     DWORD dwRead;
2792     if (ReadFile((HANDLE)hf, pv, cb, &dwRead, NULL))
2793         return dwRead;
2794     return 0;
2795 }
2796
2797 static UINT cabinet_write(INT_PTR hf, void *pv, UINT cb)
2798 {
2799     DWORD dwWritten;
2800     if (WriteFile((HANDLE)hf, pv, cb, &dwWritten, NULL))
2801         return dwWritten;
2802     return 0;
2803 }
2804
2805 static int cabinet_close(INT_PTR hf)
2806 {
2807     return CloseHandle((HANDLE)hf) ? 0 : -1;
2808 }
2809
2810 static long cabinet_seek(INT_PTR hf, long dist, int seektype)
2811 {
2812     /* flags are compatible and so are passed straight through */
2813     return SetFilePointer((HANDLE)hf, dist, NULL, seektype);
2814 }
2815
2816 static INT_PTR cabinet_notify(FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)
2817 {
2818     /* FIXME: try to do more processing in this function */
2819     switch (fdint)
2820     {
2821     case fdintCOPY_FILE:
2822     {
2823         CabData *data = (CabData*) pfdin->pv;
2824         ULONG len = strlen(data->cab_path) + strlen(pfdin->psz1);
2825         char *file = cabinet_alloc((len+1)*sizeof(char));
2826
2827         LPWSTR trackname;
2828         LPWSTR trackpath;
2829         LPWSTR tracknametmp;
2830         static const WCHAR tmpprefix[] = {'C','A','B','T','M','P','_',0};
2831
2832         strcpy(file, data->cab_path);
2833         strcat(file, pfdin->psz1);
2834
2835         TRACE("file: %s\n", debugstr_a(file));
2836
2837         /* track this file so it can be deleted if not installed */
2838         trackpath=strdupAtoW(file);
2839         tracknametmp=strdupAtoW(strrchr(file,'\\')+1);
2840         trackname = HeapAlloc(GetProcessHeap(),0,(strlenW(tracknametmp) +
2841                                   strlenW(tmpprefix)+1) * sizeof(WCHAR));
2842
2843         strcpyW(trackname,tmpprefix);
2844         strcatW(trackname,tracknametmp);
2845
2846         track_tempfile(data->package, trackname, trackpath);
2847
2848         HeapFree(GetProcessHeap(),0,trackpath);
2849         HeapFree(GetProcessHeap(),0,trackname);
2850         HeapFree(GetProcessHeap(),0,tracknametmp);
2851
2852         return cabinet_open(file, _O_WRONLY | _O_CREAT, 0);
2853     }
2854     case fdintCLOSE_FILE_INFO:
2855     {
2856         FILETIME ft;
2857             FILETIME ftLocal;
2858         if (!DosDateTimeToFileTime(pfdin->date, pfdin->time, &ft))
2859             return -1;
2860         if (!LocalFileTimeToFileTime(&ft, &ftLocal))
2861             return -1;
2862         if (!SetFileTime((HANDLE)pfdin->hf, &ftLocal, 0, &ftLocal))
2863             return -1;
2864
2865         cabinet_close(pfdin->hf);
2866         return 1;
2867     }
2868     default:
2869         return 0;
2870     }
2871 }
2872
2873 /***********************************************************************
2874  *            extract_cabinet_file
2875  *
2876  * Extract files from a cab file.
2877  */
2878 static BOOL extract_cabinet_file(MSIPACKAGE* package, const WCHAR* source,
2879                                  const WCHAR* path)
2880 {
2881     HFDI hfdi;
2882     ERF erf;
2883     BOOL ret;
2884     char *cabinet;
2885     char *cab_path;
2886     CabData data;
2887
2888     TRACE("Extracting %s to %s\n",debugstr_w(source), debugstr_w(path));
2889
2890     hfdi = FDICreate(cabinet_alloc,
2891                      cabinet_free,
2892                      cabinet_open,
2893                      cabinet_read,
2894                      cabinet_write,
2895                      cabinet_close,
2896                      cabinet_seek,
2897                      0,
2898                      &erf);
2899     if (!hfdi)
2900     {
2901         ERR("FDICreate failed\n");
2902         return FALSE;
2903     }
2904
2905     if (!(cabinet = strdupWtoA( source )))
2906     {
2907         FDIDestroy(hfdi);
2908         return FALSE;
2909     }
2910     if (!(cab_path = strdupWtoA( path )))
2911     {
2912         FDIDestroy(hfdi);
2913         HeapFree(GetProcessHeap(), 0, cabinet);
2914         return FALSE;
2915     }
2916
2917     data.package = package;
2918     data.cab_path = cab_path;
2919
2920     ret = FDICopy(hfdi, cabinet, "", 0, cabinet_notify, NULL, &data);
2921
2922     if (!ret)
2923         ERR("FDICopy failed\n");
2924
2925     FDIDestroy(hfdi);
2926
2927     HeapFree(GetProcessHeap(), 0, cabinet);
2928     HeapFree(GetProcessHeap(), 0, cab_path);
2929
2930     return ret;
2931 }
2932
2933 static UINT ready_media_for_file(MSIPACKAGE *package, UINT sequence,
2934                                  WCHAR* path)
2935 {
2936     UINT rc;
2937     MSIQUERY * view;
2938     MSIRECORD * row = 0;
2939     WCHAR source[MAX_PATH];
2940     static const WCHAR ExecSeqQuery[] = {
2941         's','e','l','e','c','t',' ','*',' ',
2942         'f','r','o','m',' ','M','e','d','i','a',' ',
2943         'w','h','e','r','e',' ','L','a','s','t','S','e','q','u','e','n','c','e',' ','>','=',' ','%','i',' ',
2944         'o','r','d','e','r',' ','b','y',' ','L','a','s','t','S','e','q','u','e','n','c','e',0};
2945     WCHAR Query[1024];
2946     WCHAR cab[0x100];
2947     DWORD sz=0x100;
2948     INT seq;
2949     static UINT last_sequence = 0;
2950
2951     if (sequence <= last_sequence)
2952     {
2953         TRACE("Media already ready (%u, %u)\n",sequence,last_sequence);
2954         return ERROR_SUCCESS;
2955     }
2956
2957     sprintfW(Query,ExecSeqQuery,sequence);
2958
2959     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
2960     if (rc != ERROR_SUCCESS)
2961         return rc;
2962
2963     rc = MSI_ViewExecute(view, 0);
2964     if (rc != ERROR_SUCCESS)
2965     {
2966         MSI_ViewClose(view);
2967         msiobj_release(&view->hdr);
2968         return rc;
2969     }
2970
2971     rc = MSI_ViewFetch(view,&row);
2972     if (rc != ERROR_SUCCESS)
2973     {
2974         MSI_ViewClose(view);
2975         msiobj_release(&view->hdr);
2976         return rc;
2977     }
2978     seq = MSI_RecordGetInteger(row,2);
2979     last_sequence = seq;
2980
2981     if (!MSI_RecordIsNull(row,4))
2982     {
2983         sz=0x100;
2984         MSI_RecordGetStringW(row,4,cab,&sz);
2985         TRACE("Source is CAB %s\n",debugstr_w(cab));
2986         /* the stream does not contain the # character */
2987         if (cab[0]=='#')
2988         {
2989             writeout_cabinet_stream(package,&cab[1],source);
2990             strcpyW(path,source);
2991             *(strrchrW(path,'\\')+1)=0;
2992         }
2993         else
2994         {
2995             sz = MAX_PATH;
2996             if (MSI_GetPropertyW(package, cszSourceDir, source, &sz))
2997             {
2998                 ERR("No Source dir defined \n");
2999                 rc = ERROR_FUNCTION_FAILED;
3000             }
3001             else
3002             {
3003                 strcpyW(path,source);
3004                 strcatW(source,cab);
3005                 /* extract the cab file into a folder in the temp folder */
3006                 sz = MAX_PATH;
3007                 if (MSI_GetPropertyW(package, cszTempFolder,path, &sz)
3008                                     != ERROR_SUCCESS)
3009                     GetTempPathW(MAX_PATH,path);
3010             }
3011         }
3012         rc = !extract_cabinet_file(package, source,path);
3013     }
3014     msiobj_release(&row->hdr);
3015     MSI_ViewClose(view);
3016     msiobj_release(&view->hdr);
3017     return rc;
3018 }
3019
3020 inline static UINT create_component_directory ( MSIPACKAGE* package, INT component)
3021 {
3022     UINT rc;
3023     MSIFOLDER *folder;
3024     LPWSTR install_path;
3025
3026     install_path = resolve_folder(package, package->components[component].Directory,
3027                         FALSE, FALSE, &folder);
3028     if (!install_path)
3029         return ERROR_FUNCTION_FAILED;
3030
3031     /* create the path */
3032     if (folder->State == 0)
3033     {
3034         create_full_pathW(install_path);
3035         folder->State = 2;
3036     }
3037     HeapFree(GetProcessHeap(), 0, install_path);
3038
3039     return rc;
3040 }
3041
3042 static UINT ACTION_InstallFiles(MSIPACKAGE *package)
3043 {
3044     UINT rc = ERROR_SUCCESS;
3045     DWORD index;
3046     MSIRECORD * uirow;
3047     WCHAR uipath[MAX_PATH];
3048
3049     if (!package)
3050         return ERROR_INVALID_HANDLE;
3051
3052     /* increment progress bar each time action data is sent */
3053     ui_progress(package,1,1,1,0);
3054
3055     for (index = 0; index < package->loaded_files; index++)
3056     {
3057         WCHAR path_to_source[MAX_PATH];
3058         MSIFILE *file;
3059
3060         file = &package->files[index];
3061
3062         if (file->Temporary)
3063             continue;
3064
3065         if (package->components[file->ComponentIndex].ActionRequest !=
3066              INSTALLSTATE_LOCAL)
3067         {
3068             TRACE("File %s is not scheduled for install\n",
3069                    debugstr_w(file->File));
3070
3071             continue;
3072         }
3073
3074         if ((file->State == 1) || (file->State == 2))
3075         {
3076             TRACE("Installing %s\n",debugstr_w(file->File));
3077             rc = ready_media_for_file(package,file->Sequence,path_to_source);
3078             /*
3079              * WARNING!
3080              * our file table could change here because a new temp file
3081              * may have been created
3082              */
3083             file = &package->files[index];
3084             if (rc != ERROR_SUCCESS)
3085             {
3086                 ERR("Unable to ready media\n");
3087                 rc = ERROR_FUNCTION_FAILED;
3088                 break;
3089             }
3090
3091             create_component_directory( package, file->ComponentIndex);
3092
3093             strcpyW(file->SourcePath, path_to_source);
3094             strcatW(file->SourcePath, file->File);
3095
3096             TRACE("file paths %s to %s\n",debugstr_w(file->SourcePath),
3097                   debugstr_w(file->TargetPath));
3098
3099             /* the UI chunk */
3100             uirow=MSI_CreateRecord(9);
3101             MSI_RecordSetStringW(uirow,1,file->File);
3102             strcpyW(uipath,file->TargetPath);
3103             *(strrchrW(uipath,'\\')+1)=0;
3104             MSI_RecordSetStringW(uirow,9,uipath);
3105             MSI_RecordSetInteger(uirow,6,file->FileSize);
3106             ui_actiondata(package,szInstallFiles,uirow);
3107             msiobj_release( &uirow->hdr );
3108
3109             if (!MoveFileW(file->SourcePath,file->TargetPath))
3110             {
3111                 rc = GetLastError();
3112                 ERR("Unable to move file (%s -> %s) (error %d)\n",
3113                      debugstr_w(file->SourcePath), debugstr_w(file->TargetPath),
3114                       rc);
3115                 if (rc == ERROR_ALREADY_EXISTS && file->State == 2)
3116                 {
3117                     CopyFileW(file->SourcePath,file->TargetPath,FALSE);
3118                     DeleteFileW(file->SourcePath);
3119                     rc = 0;
3120                 }
3121                 else if (rc == ERROR_FILE_NOT_FOUND)
3122                 {
3123                     ERR("Source File Not Found!  Continueing\n");
3124                     rc = 0;
3125                 }
3126                 else
3127                 {
3128                     ERR("Ignoring Error and continuing...\n");
3129                     rc = 0;
3130                 }
3131             }
3132             else
3133                 file->State = 4;
3134
3135             ui_progress(package,2,0,0,0);
3136         }
3137     }
3138
3139     return rc;
3140 }
3141
3142 inline static UINT get_file_target(MSIPACKAGE *package, LPCWSTR file_key,
3143                                    LPWSTR* file_source)
3144 {
3145     DWORD index;
3146
3147     if (!package)
3148         return ERROR_INVALID_HANDLE;
3149
3150     for (index = 0; index < package->loaded_files; index ++)
3151     {
3152         if (strcmpW(file_key,package->files[index].File)==0)
3153         {
3154             if (package->files[index].State >= 3)
3155             {
3156                 *file_source = dupstrW(package->files[index].TargetPath);
3157                 return ERROR_SUCCESS;
3158             }
3159             else
3160                 return ERROR_FILE_NOT_FOUND;
3161         }
3162     }
3163
3164     return ERROR_FUNCTION_FAILED;
3165 }
3166
3167 static UINT ACTION_DuplicateFiles(MSIPACKAGE *package)
3168 {
3169     UINT rc;
3170     MSIQUERY * view;
3171     MSIRECORD * row = 0;
3172     static const WCHAR ExecSeqQuery[] = {
3173         's','e','l','e','c','t',' ','*',' ','f','r','o','m',' ',
3174         'D','u','p','l','i','c','a','t','e','F','i','l','e',0};
3175
3176     if (!package)
3177         return ERROR_INVALID_HANDLE;
3178
3179     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3180     if (rc != ERROR_SUCCESS)
3181         return ERROR_SUCCESS;
3182
3183     rc = MSI_ViewExecute(view, 0);
3184     if (rc != ERROR_SUCCESS)
3185     {
3186         MSI_ViewClose(view);
3187         msiobj_release(&view->hdr);
3188         return rc;
3189     }
3190
3191     while (1)
3192     {
3193         WCHAR file_key[0x100];
3194         WCHAR *file_source = NULL;
3195         WCHAR dest_name[0x100];
3196         LPWSTR dest_path, dest;
3197         WCHAR component[0x100];
3198         INT component_index;
3199
3200         DWORD sz=0x100;
3201
3202         rc = MSI_ViewFetch(view,&row);
3203         if (rc != ERROR_SUCCESS)
3204         {
3205             rc = ERROR_SUCCESS;
3206             break;
3207         }
3208
3209         sz=0x100;
3210         rc = MSI_RecordGetStringW(row,2,component,&sz);
3211         if (rc != ERROR_SUCCESS)
3212         {
3213             ERR("Unable to get component\n");
3214             msiobj_release(&row->hdr);
3215             break;
3216         }
3217
3218         component_index = get_loaded_component(package,component);
3219         if (package->components[component_index].ActionRequest !=
3220              INSTALLSTATE_LOCAL)
3221         {
3222             TRACE("Skipping copy due to disabled component\n");
3223             msiobj_release(&row->hdr);
3224             continue;
3225         }
3226
3227         sz=0x100;
3228         rc = MSI_RecordGetStringW(row,3,file_key,&sz);
3229         if (rc != ERROR_SUCCESS)
3230         {
3231             ERR("Unable to get file key\n");
3232             msiobj_release(&row->hdr);
3233             break;
3234         }
3235
3236         rc = get_file_target(package,file_key,&file_source);
3237
3238         if (rc != ERROR_SUCCESS)
3239         {
3240             ERR("Original file unknown %s\n",debugstr_w(file_key));
3241             msiobj_release(&row->hdr);
3242             if (file_source)
3243                 HeapFree(GetProcessHeap(),0,file_source);
3244             break;
3245         }
3246
3247         if (MSI_RecordIsNull(row,4))
3248         {
3249             strcpyW(dest_name,strrchrW(file_source,'\\')+1);
3250         }
3251         else
3252         {
3253             sz=0x100;
3254             MSI_RecordGetStringW(row,4,dest_name,&sz);
3255             reduce_to_longfilename(dest_name);
3256          }
3257
3258         if (MSI_RecordIsNull(row,5))
3259         {
3260             LPWSTR p;
3261             dest_path = dupstrW(file_source);
3262             p = strrchrW(dest_path,'\\');
3263             if (p)
3264                 *p=0;
3265         }
3266         else
3267         {
3268             WCHAR destkey[0x100];
3269             sz=0x100;
3270             MSI_RecordGetStringW(row,5,destkey,&sz);
3271             sz = 0x100;
3272             dest_path = resolve_folder(package, destkey, FALSE,FALSE,NULL);
3273             if (!dest_path)
3274             {
3275                 ERR("Unable to get destination folder\n");
3276                 msiobj_release(&row->hdr);
3277                 if (file_source)
3278                     HeapFree(GetProcessHeap(),0,file_source);
3279                 break;
3280             }
3281         }
3282
3283         dest = build_directory_name(2, dest_path, dest_name);
3284         HeapFree(GetProcessHeap(), 0, dest_path);
3285
3286         TRACE("Duplicating file %s to %s\n",debugstr_w(file_source),
3287               debugstr_w(dest));
3288
3289         if (strcmpW(file_source,dest))
3290             rc = !CopyFileW(file_source,dest,TRUE);
3291         else
3292             rc = ERROR_SUCCESS;
3293
3294         if (rc != ERROR_SUCCESS)
3295             ERR("Failed to copy file\n");
3296
3297         FIXME("We should track these duplicate files as well\n");
3298
3299         msiobj_release(&row->hdr);
3300         HeapFree(GetProcessHeap(),0,dest);
3301         HeapFree(GetProcessHeap(),0,file_source);
3302     }
3303     MSI_ViewClose(view);
3304     msiobj_release(&view->hdr);
3305     return rc;
3306 }
3307
3308
3309 /* OK this value is "interpretted" and then formatted based on the
3310    first few characters */
3311 static LPSTR parse_value(MSIPACKAGE *package, WCHAR *value, DWORD *type,
3312                          DWORD *size)
3313 {
3314     LPSTR data = NULL;
3315     if (value[0]=='#' && value[1]!='#' && value[1]!='%')
3316     {
3317         if (value[1]=='x')
3318         {
3319             LPWSTR ptr;
3320             CHAR byte[5];
3321             LPWSTR deformated;
3322             int count;
3323
3324             deformat_string(package, &value[2], &deformated);
3325
3326             /* binary value type */
3327             ptr = deformated;
3328             *type=REG_BINARY;
3329             *size = strlenW(ptr)/2;
3330             data = HeapAlloc(GetProcessHeap(),0,*size);
3331
3332             byte[0] = '0';
3333             byte[1] = 'x';
3334             byte[4] = 0;
3335             count = 0;
3336             while (*ptr)
3337             {
3338                 byte[2]= *ptr;
3339                 ptr++;
3340                 byte[3]= *ptr;
3341                 ptr++;
3342                 data[count] = (BYTE)strtol(byte,NULL,0);
3343                 count ++;
3344             }
3345             HeapFree(GetProcessHeap(),0,deformated);
3346
3347             TRACE("Data %li bytes(%i)\n",*size,count);
3348         }
3349         else
3350         {
3351             LPWSTR deformated;
3352             deformat_string(package, &value[1], &deformated);
3353
3354             *type=REG_DWORD;
3355             *size = sizeof(DWORD);
3356             data = HeapAlloc(GetProcessHeap(),0,*size);
3357             *(LPDWORD)data = atoiW(deformated);
3358             TRACE("DWORD %i\n",*data);
3359
3360             HeapFree(GetProcessHeap(),0,deformated);
3361         }
3362     }
3363     else
3364     {
3365         WCHAR *ptr;
3366         *type=REG_SZ;
3367
3368         if (value[0]=='#')
3369         {
3370             if (value[1]=='%')
3371             {
3372                 ptr = &value[2];
3373                 *type=REG_EXPAND_SZ;
3374             }
3375             else
3376                 ptr = &value[1];
3377          }
3378          else
3379             ptr=value;
3380
3381         *size = deformat_string(package, ptr,(LPWSTR*)&data);
3382     }
3383     return data;
3384 }
3385
3386 static UINT ACTION_WriteRegistryValues(MSIPACKAGE *package)
3387 {
3388     UINT rc;
3389     MSIQUERY * view;
3390     MSIRECORD * row = 0;
3391     static const WCHAR ExecSeqQuery[] = {
3392         's','e','l','e','c','t',' ','*',' ',
3393         'f','r','o','m',' ','R','e','g','i','s','t','r','y',0 };
3394
3395     if (!package)
3396         return ERROR_INVALID_HANDLE;
3397
3398     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3399     if (rc != ERROR_SUCCESS)
3400         return ERROR_SUCCESS;
3401
3402     rc = MSI_ViewExecute(view, 0);
3403     if (rc != ERROR_SUCCESS)
3404     {
3405         MSI_ViewClose(view);
3406         msiobj_release(&view->hdr);
3407         return rc;
3408     }
3409
3410     /* increment progress bar each time action data is sent */
3411     ui_progress(package,1,1,1,0);
3412
3413     while (1)
3414     {
3415         static const WCHAR szHCR[] =
3416 {'H','K','E','Y','_','C','L','A','S','S','E','S','_','R','O','O','T','\\',0};
3417         static const WCHAR szHCU[] =
3418 {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\',0};
3419         static const WCHAR szHLM[] =
3420 {'H','K','E','Y','_','L','O','C','A','L','_','M','A','C','H','I','N','E',
3421 '\\',0};
3422         static const WCHAR szHU[] =
3423 {'H','K','E','Y','_','U','S','E','R','S','\\',0};
3424
3425         LPSTR value_data = NULL;
3426         HKEY  root_key, hkey;
3427         DWORD type,size;
3428         LPWSTR value, key, name, component;
3429         LPCWSTR szRoot;
3430         INT component_index;
3431         MSIRECORD * uirow;
3432         LPWSTR uikey;
3433         INT   root;
3434
3435         rc = MSI_ViewFetch(view,&row);
3436         if (rc != ERROR_SUCCESS)
3437         {
3438             rc = ERROR_SUCCESS;
3439             break;
3440         }
3441
3442         value = NULL;
3443         key = NULL;
3444         uikey = NULL;
3445         name = NULL;
3446
3447         component = load_dynamic_stringW(row, 6);
3448         component_index = get_loaded_component(package,component);
3449
3450         if (package->components[component_index].ActionRequest !=
3451              INSTALLSTATE_LOCAL)
3452         {
3453             TRACE("Skipping write due to disabled component\n");
3454             msiobj_release(&row->hdr);
3455             goto next;
3456         }
3457
3458         /* null values have special meanings during uninstalls and such */
3459
3460         if(MSI_RecordIsNull(row,5))
3461         {
3462             msiobj_release(&row->hdr);
3463             goto next;
3464         }
3465
3466         root = MSI_RecordGetInteger(row,2);
3467         key = load_dynamic_stringW(row, 3);
3468
3469         name = load_dynamic_stringW(row, 4);
3470
3471         /* get the root key */
3472         switch (root)
3473         {
3474             case 0:  root_key = HKEY_CLASSES_ROOT;
3475                      szRoot = szHCR;
3476                      break;
3477             case 1:  root_key = HKEY_CURRENT_USER;
3478                      szRoot = szHCU;
3479                      break;
3480             case 2:  root_key = HKEY_LOCAL_MACHINE;
3481                      szRoot = szHLM;
3482                      break;
3483             case 3:  root_key = HKEY_USERS;
3484                      szRoot = szHU;
3485                      break;
3486             default:
3487                  ERR("Unknown root %i\n",root);
3488                  root_key=NULL;
3489                  szRoot = NULL;
3490                  break;
3491         }
3492         if (!root_key)
3493         {
3494             msiobj_release(&row->hdr);
3495             goto next;
3496         }
3497
3498         size = strlenW(key) + strlenW(szRoot) + 1;
3499         uikey = HeapAlloc(GetProcessHeap(), 0, size*sizeof(WCHAR));
3500         strcpyW(uikey,szRoot);
3501         strcatW(uikey,key);
3502         if (RegCreateKeyW( root_key, key, &hkey))
3503         {
3504             ERR("Could not create key %s\n",debugstr_w(key));
3505             msiobj_release(&row->hdr);
3506             goto next;
3507         }
3508
3509         value = load_dynamic_stringW(row,5);
3510         value_data = parse_value(package, value, &type, &size);
3511
3512         if (value_data)
3513         {
3514             TRACE("Setting value %s\n",debugstr_w(name));
3515             RegSetValueExW(hkey, name, 0, type, value_data, size);
3516
3517             uirow = MSI_CreateRecord(3);
3518             MSI_RecordSetStringW(uirow,2,name);
3519             MSI_RecordSetStringW(uirow,1,uikey);
3520
3521             if (type == REG_SZ)
3522                 MSI_RecordSetStringW(uirow,3,(LPWSTR)value_data);
3523             else
3524                 MSI_RecordSetStringW(uirow,3,value);
3525
3526             ui_actiondata(package,szWriteRegistryValues,uirow);
3527             ui_progress(package,2,0,0,0);
3528             msiobj_release( &uirow->hdr );
3529
3530             HeapFree(GetProcessHeap(),0,value_data);
3531         }
3532         HeapFree(GetProcessHeap(),0,value);
3533
3534         msiobj_release(&row->hdr);
3535         RegCloseKey(hkey);
3536 next:
3537         if (uikey)
3538             HeapFree(GetProcessHeap(),0,uikey);
3539         if (key)
3540             HeapFree(GetProcessHeap(),0,key);
3541         if (name)
3542             HeapFree(GetProcessHeap(),0,name);
3543         if (component)
3544             HeapFree(GetProcessHeap(),0,component);
3545     }
3546     MSI_ViewClose(view);
3547     msiobj_release(&view->hdr);
3548     return rc;
3549 }
3550
3551 /*
3552  * This helper function should probably go alot of places
3553  *
3554  * Thinking about this, maybe this should become yet another Bison file
3555  */
3556 static DWORD deformat_string(MSIPACKAGE *package, WCHAR* ptr,WCHAR** data)
3557 {
3558     WCHAR* mark=NULL;
3559     DWORD size=0;
3560     DWORD chunk=0;
3561     WCHAR key[0x100];
3562     LPWSTR value;
3563     DWORD sz;
3564     UINT rc;
3565
3566     if (ptr==NULL)
3567     {
3568         TRACE("Deformatting NULL string\n");
3569         *data = NULL;
3570         return 0;
3571     }
3572     /* scan for special characters */
3573     if (!strchrW(ptr,'[') || (strchrW(ptr,'[') && !strchrW(ptr,']')))
3574     {
3575         /* not formatted */
3576         size = (strlenW(ptr)+1) * sizeof(WCHAR);
3577         *data = HeapAlloc(GetProcessHeap(),0,size);
3578         strcpyW(*data,ptr);
3579         return size;
3580     }
3581
3582     /* formatted string located */
3583     mark = strchrW(ptr,'[');
3584     if (mark != ptr)
3585     {
3586         INT cnt = (mark - ptr);
3587         TRACE("%i  (%i) characters before marker\n",cnt,(mark-ptr));
3588         size = cnt * sizeof(WCHAR);
3589         size += sizeof(WCHAR);
3590         *data = HeapAlloc(GetProcessHeap(),0,size);
3591         strncpyW(*data,ptr,cnt);
3592         (*data)[cnt]=0;
3593     }
3594     else
3595     {
3596         size = sizeof(WCHAR);
3597         *data = HeapAlloc(GetProcessHeap(),0,size);
3598         (*data)[0]=0;
3599     }
3600     mark++;
3601     strcpyW(key,mark);
3602     *strchrW(key,']')=0;
3603     mark = strchrW(mark,']');
3604     mark++;
3605     TRACE("Current %s .. %s\n",debugstr_w(*data),debugstr_w(mark));
3606     sz = 0;
3607     rc = MSI_GetPropertyW(package, key, NULL, &sz);
3608     if ((rc == ERROR_SUCCESS) || (rc == ERROR_MORE_DATA))
3609     {
3610         LPWSTR newdata;
3611
3612         sz++;
3613         value = HeapAlloc(GetProcessHeap(),0,sz * sizeof(WCHAR));
3614         MSI_GetPropertyW(package, key, value, &sz);
3615
3616         chunk = (strlenW(value)+1) * sizeof(WCHAR);
3617         size+=chunk;
3618         newdata = HeapReAlloc(GetProcessHeap(),0,*data,size);
3619         *data = newdata;
3620         strcatW(*data,value);
3621     }
3622     TRACE("Current %s .. %s\n",debugstr_w(*data),debugstr_w(mark));
3623     if (*mark!=0)
3624     {
3625         LPWSTR newdata;
3626         chunk = (strlenW(mark)+1) * sizeof(WCHAR);
3627         size+=chunk;
3628         newdata = HeapReAlloc(GetProcessHeap(),0,*data,size);
3629         *data = newdata;
3630         strcatW(*data,mark);
3631     }
3632     (*data)[strlenW(*data)]=0;
3633     TRACE("Current %s .. %s\n",debugstr_w(*data),debugstr_w(mark));
3634
3635     /* recursively do this to clean up */
3636     mark = HeapAlloc(GetProcessHeap(),0,size);
3637     strcpyW(mark,*data);
3638     TRACE("String at this point %s\n",debugstr_w(mark));
3639     size = deformat_string(package,mark,data);
3640     HeapFree(GetProcessHeap(),0,mark);
3641     return size;
3642 }
3643
3644 static UINT ACTION_InstallInitialize(MSIPACKAGE *package)
3645 {
3646     return ERROR_SUCCESS;
3647 }
3648
3649
3650 static UINT ACTION_InstallValidate(MSIPACKAGE *package)
3651 {
3652     DWORD progress = 0;
3653     static const WCHAR q1[]={
3654         'S','E','L','E','C','T',' ','*',' ',
3655         'F','R','O','M',' ','R','e','g','i','s','t','r','y',0};
3656     UINT rc;
3657     MSIQUERY * view;
3658     MSIRECORD * row = 0;
3659
3660     TRACE(" InstallValidate \n");
3661
3662     rc = MSI_DatabaseOpenViewW(package->db, q1, &view);
3663     if (rc != ERROR_SUCCESS)
3664         return ERROR_SUCCESS;
3665
3666     rc = MSI_ViewExecute(view, 0);
3667     if (rc != ERROR_SUCCESS)
3668     {
3669         MSI_ViewClose(view);
3670         msiobj_release(&view->hdr);
3671         return rc;
3672     }
3673     while (1)
3674     {
3675         rc = MSI_ViewFetch(view,&row);
3676         if (rc != ERROR_SUCCESS)
3677         {
3678             rc = ERROR_SUCCESS;
3679             break;
3680         }
3681         progress +=1;
3682
3683         msiobj_release(&row->hdr);
3684     }
3685     MSI_ViewClose(view);
3686     msiobj_release(&view->hdr);
3687
3688     ui_progress(package,0,progress+package->loaded_files,0,0);
3689
3690     return ERROR_SUCCESS;
3691 }
3692
3693 static UINT ACTION_LaunchConditions(MSIPACKAGE *package)
3694 {
3695     UINT rc;
3696     MSIQUERY * view = NULL;
3697     MSIRECORD * row = 0;
3698     static const WCHAR ExecSeqQuery[] = {
3699         'S','E','L','E','C','T',' ','*',' ',
3700         'f','r','o','m',' ','L','a','u','n','c','h','C','o','n','d','i','t','i','o','n',0};
3701     static const WCHAR title[]=
3702             {'I','n','s','t','a','l','l',' ','F','a', 'i','l','e','d',0};
3703
3704     TRACE("Checking launch conditions\n");
3705
3706     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3707     if (rc != ERROR_SUCCESS)
3708         return ERROR_SUCCESS;
3709
3710     rc = MSI_ViewExecute(view, 0);
3711     if (rc != ERROR_SUCCESS)
3712     {
3713         MSI_ViewClose(view);
3714         msiobj_release(&view->hdr);
3715         return rc;
3716     }
3717
3718     rc = ERROR_SUCCESS;
3719     while (rc == ERROR_SUCCESS)
3720     {
3721         LPWSTR cond = NULL;
3722         LPWSTR message = NULL;
3723
3724         rc = MSI_ViewFetch(view,&row);
3725         if (rc != ERROR_SUCCESS)
3726         {
3727             rc = ERROR_SUCCESS;
3728             break;
3729         }
3730
3731         cond = load_dynamic_stringW(row,1);
3732
3733         if (MSI_EvaluateConditionW(package,cond) != MSICONDITION_TRUE)
3734         {
3735             message = load_dynamic_stringW(row,2);
3736             MessageBoxW(NULL,message,title,MB_OK);
3737             HeapFree(GetProcessHeap(),0,message);
3738             rc = ERROR_FUNCTION_FAILED;
3739         }
3740         HeapFree(GetProcessHeap(),0,cond);
3741         msiobj_release(&row->hdr);
3742     }
3743     MSI_ViewClose(view);
3744     msiobj_release(&view->hdr);
3745     return rc;
3746 }
3747
3748 static LPWSTR resolve_keypath( MSIPACKAGE* package, INT
3749                             component_index)
3750 {
3751     MSICOMPONENT* cmp = &package->components[component_index];
3752
3753     if (cmp->KeyPath[0]==0)
3754     {
3755         LPWSTR p = resolve_folder(package,cmp->Directory,FALSE,FALSE,NULL);
3756         return p;
3757     }
3758     if ((cmp->Attributes & 0x4) || (cmp->Attributes & 0x20))
3759     {
3760         FIXME("UNIMPLEMENTED keypath as Registry or ODBC Source\n");
3761         return NULL;
3762     }
3763     else
3764     {
3765         int j;
3766         j = get_loaded_file(package,cmp->KeyPath);
3767
3768         if (j>=0)
3769         {
3770             LPWSTR p = dupstrW(package->files[j].TargetPath);
3771             return p;
3772         }
3773     }
3774     return NULL;
3775 }
3776
3777 /*
3778  * Ok further analysis makes me think that this work is
3779  * actually done in the PublishComponents and PublishFeatures
3780  * step, and not here.  It appears like the keypath and all that is
3781  * resolved in this step, however actually written in the Publish steps.
3782  * But we will leave it here for now because it is unclear
3783  */
3784 static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
3785 {
3786     LPWSTR productcode;
3787     WCHAR squished_pc[0x100];
3788     WCHAR squished_cc[0x100];
3789     UINT rc;
3790     DWORD i;
3791     HKEY hkey=0,hkey2=0,hkey3=0;
3792     static const WCHAR szProductCode[]=
3793          {'P','r','o','d','u','c','t','C','o','d','e',0};
3794     static const WCHAR szInstaller[] = {
3795          'S','o','f','t','w','a','r','e','\\',
3796          'M','i','c','r','o','s','o','f','t','\\',
3797          'W','i','n','d','o','w','s','\\',
3798          'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3799          'I','n','s','t','a','l','l','e','r',0 };
3800     static const WCHAR szFeatures[] = {
3801          'F','e','a','t','u','r','e','s',0 };
3802     static const WCHAR szComponents[] = {
3803          'C','o','m','p','o','n','e','n','t','s',0 };
3804
3805     if (!package)
3806         return ERROR_INVALID_HANDLE;
3807
3808     /* writes the Component and Features values to the registry */
3809     productcode = load_dynamic_property(package,szProductCode,&rc);
3810     if (!productcode)
3811         return rc;
3812
3813     squash_guid(productcode,squished_pc);
3814     rc = RegCreateKeyW(HKEY_LOCAL_MACHINE,szInstaller,&hkey);
3815     if (rc != ERROR_SUCCESS)
3816         goto end;
3817
3818     rc = RegCreateKeyW(hkey,szFeatures,&hkey2);
3819     if (rc != ERROR_SUCCESS)
3820         goto end;
3821
3822     rc = RegCreateKeyW(hkey2,squished_pc,&hkey3);
3823     if (rc != ERROR_SUCCESS)
3824         goto end;
3825
3826     /* here the guids are base 85 encoded */
3827     for (i = 0; i < package->loaded_features; i++)
3828     {
3829         LPWSTR data = NULL;
3830         GUID clsid;
3831         int j;
3832         INT size;
3833
3834         size = package->features[i].ComponentCount*21*sizeof(WCHAR);
3835         data = HeapAlloc(GetProcessHeap(), 0, size);
3836
3837         data[0] = 0;
3838         for (j = 0; j < package->features[i].ComponentCount; j++)
3839         {
3840             WCHAR buf[21];
3841             TRACE("From %s\n",debugstr_w(package->components
3842                             [package->features[i].Components[j]].ComponentId));
3843             CLSIDFromString(package->components
3844                             [package->features[i].Components[j]].ComponentId,
3845                             &clsid);
3846             encode_base85_guid(&clsid,buf);
3847             TRACE("to %s\n",debugstr_w(buf));
3848             strcatW(data,buf);
3849         }
3850
3851         size = strlenW(data)*sizeof(WCHAR);
3852         RegSetValueExW(hkey3,package->features[i].Feature,0,REG_SZ,
3853                        (LPSTR)data,size);
3854         HeapFree(GetProcessHeap(),0,data);
3855     }
3856
3857     RegCloseKey(hkey3);
3858     RegCloseKey(hkey2);
3859
3860     rc = RegCreateKeyW(hkey,szComponents,&hkey2);
3861     if (rc != ERROR_SUCCESS)
3862         goto end;
3863
3864     for (i = 0; i < package->loaded_components; i++)
3865     {
3866         if (package->components[i].ComponentId[0]!=0)
3867         {
3868             WCHAR *keypath = NULL;
3869             MSIRECORD * uirow;
3870
3871             squash_guid(package->components[i].ComponentId,squished_cc);
3872             rc = RegCreateKeyW(hkey2,squished_cc,&hkey3);
3873             if (rc != ERROR_SUCCESS)
3874                 continue;
3875
3876             keypath = resolve_keypath(package,i);
3877             if (keypath)
3878             {
3879                 RegSetValueExW(hkey3,squished_pc,0,REG_SZ,(LPVOID)keypath,
3880                             (strlenW(keypath)+1)*sizeof(WCHAR));
3881                 RegCloseKey(hkey3);
3882
3883                 /* UI stuff */
3884                 uirow = MSI_CreateRecord(3);
3885                 MSI_RecordSetStringW(uirow,1,productcode);
3886                 MSI_RecordSetStringW(uirow,2,package->components[i].
3887                                                         ComponentId);
3888                 MSI_RecordSetStringW(uirow,3,keypath);
3889                 ui_actiondata(package,szProcessComponents,uirow);
3890                 msiobj_release( &uirow->hdr );
3891                 HeapFree(GetProcessHeap(),0,keypath);
3892             }
3893         }
3894     }
3895 end:
3896     HeapFree(GetProcessHeap(), 0, productcode);
3897     RegCloseKey(hkey2);
3898     RegCloseKey(hkey);
3899     return rc;
3900 }
3901
3902 static UINT ACTION_RegisterTypeLibraries(MSIPACKAGE *package)
3903 {
3904     /*
3905      * OK this is a bit confusing.. I am given a _Component key and I believe
3906      * that the file that is being registered as a type library is the "key file
3907      * of that component" which I interpret to mean "The file in the KeyPath of
3908      * that component".
3909      */
3910     UINT rc;
3911     MSIQUERY * view;
3912     MSIRECORD * row = 0;
3913     static const WCHAR Query[] = {
3914         'S','E','L','E','C','T',' ','*',' ',
3915         'f','r','o','m',' ','T','y','p','e','L','i','b',0};
3916     ITypeLib *ptLib;
3917     HRESULT res;
3918
3919     if (!package)
3920         return ERROR_INVALID_HANDLE;
3921
3922     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3923     if (rc != ERROR_SUCCESS)
3924         return ERROR_SUCCESS;
3925
3926     rc = MSI_ViewExecute(view, 0);
3927     if (rc != ERROR_SUCCESS)
3928     {
3929         MSI_ViewClose(view);
3930         msiobj_release(&view->hdr);
3931         return rc;
3932     }
3933
3934     while (1)
3935     {
3936         WCHAR component[0x100];
3937         DWORD sz;
3938         INT index;
3939
3940         rc = MSI_ViewFetch(view,&row);
3941         if (rc != ERROR_SUCCESS)
3942         {
3943             rc = ERROR_SUCCESS;
3944             break;
3945         }
3946
3947         sz = 0x100;
3948         MSI_RecordGetStringW(row,3,component,&sz);
3949
3950         index = get_loaded_component(package,component);
3951         if (index < 0)
3952         {
3953             msiobj_release(&row->hdr);
3954             continue;
3955         }
3956
3957         if (package->components[index].ActionRequest != INSTALLSTATE_LOCAL)
3958         {
3959             TRACE("Skipping typelib reg due to disabled component\n");
3960             msiobj_release(&row->hdr);
3961             continue;
3962         }
3963
3964         index = get_loaded_file(package,package->components[index].KeyPath);
3965
3966         if (index < 0)
3967         {
3968             msiobj_release(&row->hdr);
3969             continue;
3970         }
3971
3972         res = LoadTypeLib(package->files[index].TargetPath,&ptLib);
3973         if (SUCCEEDED(res))
3974         {
3975             LPWSTR help;
3976             WCHAR helpid[0x100];
3977
3978             sz = 0x100;
3979             MSI_RecordGetStringW(row,6,helpid,&sz);
3980
3981             help = resolve_folder(package,helpid,FALSE,FALSE,NULL);
3982             res = RegisterTypeLib(ptLib,package->files[index].TargetPath,help);
3983             HeapFree(GetProcessHeap(),0,help);
3984
3985             if (!SUCCEEDED(res))
3986                 ERR("Failed to register type library %s\n",
3987                      debugstr_w(package->files[index].TargetPath));
3988             else
3989             {
3990                 /* Yes the row has more fields than I need, but #1 is
3991                    correct and the only one I need. Why make a new row? */
3992
3993                 ui_actiondata(package,szRegisterTypeLibraries,row);
3994
3995                 TRACE("Registered %s\n",
3996                        debugstr_w(package->files[index].TargetPath));
3997             }
3998
3999             if (ptLib)
4000                 ITypeLib_Release(ptLib);
4001         }
4002         else
4003             ERR("Failed to load type library %s\n",
4004                 debugstr_w(package->files[index].TargetPath));
4005
4006         msiobj_release(&row->hdr);
4007     }
4008     MSI_ViewClose(view);
4009     msiobj_release(&view->hdr);
4010     return rc;
4011
4012 }
4013
4014 static UINT register_appid(MSIPACKAGE *package, LPCWSTR clsid, LPCWSTR app )
4015 {
4016     static const WCHAR szAppID[] = { 'A','p','p','I','D',0 };
4017     UINT rc;
4018     MSIQUERY * view;
4019     MSIRECORD * row = 0;
4020     static const WCHAR ExecSeqQuery[] =
4021         {'S','E','L','E','C','T',' ','*',' ','f','r','o','m',' ','A','p','p','I'
4022         ,'d',' ','w','h','e','r','e',' ','A','p','p','I','d','=','`','%','s','`',0};
4023     HKEY hkey2,hkey3;
4024     LPWSTR buffer=0;
4025
4026     if (!package)
4027         return ERROR_INVALID_HANDLE;
4028
4029     rc = ACTION_OpenQuery(package->db, &view, ExecSeqQuery, clsid);
4030     if (rc != ERROR_SUCCESS)
4031         return rc;
4032
4033     rc = MSI_ViewExecute(view, 0);
4034     if (rc != ERROR_SUCCESS)
4035     {
4036         MSI_ViewClose(view);
4037         msiobj_release(&view->hdr);
4038         return rc;
4039     }
4040
4041     RegCreateKeyW(HKEY_CLASSES_ROOT,szAppID,&hkey2);
4042     RegCreateKeyW(hkey2,clsid,&hkey3);
4043     RegSetValueExW(hkey3,NULL,0,REG_SZ,(LPVOID)app,
4044                    (strlenW(app)+1)*sizeof(WCHAR));
4045
4046     rc = MSI_ViewFetch(view,&row);
4047     if (rc != ERROR_SUCCESS)
4048     {
4049         MSI_ViewClose(view);
4050         msiobj_release(&view->hdr);
4051         return rc;
4052     }
4053
4054     if (!MSI_RecordIsNull(row,2))
4055     {
4056         LPWSTR deformated=0;
4057         UINT size;
4058         static const WCHAR szRemoteServerName[] =
4059              {'R','e','m','o','t','e','S','e','r','v','e','r','N','a','m','e',0};
4060         buffer = load_dynamic_stringW(row,2);
4061         size = deformat_string(package,buffer,&deformated);
4062         RegSetValueExW(hkey3,szRemoteServerName,0,REG_SZ,(LPVOID)deformated,
4063                        size);
4064         HeapFree(GetProcessHeap(),0,deformated);
4065         HeapFree(GetProcessHeap(),0,buffer);
4066     }
4067
4068     if (!MSI_RecordIsNull(row,3))
4069     {
4070         static const WCHAR szLocalService[] =
4071              {'L','o','c','a','l','S','e','r','v','i','c','e',0};
4072         UINT size;
4073         buffer = load_dynamic_stringW(row,3);
4074         size = (strlenW(buffer)+1) * sizeof(WCHAR);
4075         RegSetValueExW(hkey3,szLocalService,0,REG_SZ,(LPVOID)buffer,size);
4076         HeapFree(GetProcessHeap(),0,buffer);
4077     }
4078
4079     if (!MSI_RecordIsNull(row,4))
4080     {
4081         static const WCHAR szService[] =
4082              {'S','e','r','v','i','c','e','P','a','r','a','m','e','t','e','r','s',0};
4083         UINT size;
4084         buffer = load_dynamic_stringW(row,4);
4085         size = (strlenW(buffer)+1) * sizeof(WCHAR);
4086         RegSetValueExW(hkey3,szService,0,REG_SZ,(LPVOID)buffer,size);
4087         HeapFree(GetProcessHeap(),0,buffer);
4088     }
4089
4090     if (!MSI_RecordIsNull(row,5))
4091     {
4092         static const WCHAR szDLL[] =
4093              {'D','l','l','S','u','r','r','o','g','a','t','e',0};
4094         UINT size;
4095         buffer = load_dynamic_stringW(row,5);
4096         size = (strlenW(buffer)+1) * sizeof(WCHAR);
4097         RegSetValueExW(hkey3,szDLL,0,REG_SZ,(LPVOID)buffer,size);
4098         HeapFree(GetProcessHeap(),0,buffer);
4099     }
4100
4101     if (!MSI_RecordIsNull(row,6))
4102     {
4103         static const WCHAR szActivate[] =
4104              {'A','c','t','i','v','a','t','e','A','s','S','t','o','r','a','g','e',0};
4105         static const WCHAR szY[] = {'Y',0};
4106
4107         if (MSI_RecordGetInteger(row,6))
4108             RegSetValueExW(hkey3,szActivate,0,REG_SZ,(LPVOID)szY,4);
4109     }
4110
4111     if (!MSI_RecordIsNull(row,7))
4112     {
4113         static const WCHAR szRunAs[] = {'R','u','n','A','s',0};
4114         static const WCHAR szUser[] =
4115              {'I','n','t','e','r','a','c','t','i','v','e',' ','U','s','e','r',0};
4116
4117         if (MSI_RecordGetInteger(row,7))
4118             RegSetValueExW(hkey3,szRunAs,0,REG_SZ,(LPVOID)szUser,34);
4119     }
4120
4121     msiobj_release(&row->hdr);
4122     MSI_ViewClose(view);
4123     msiobj_release(&view->hdr);
4124     RegCloseKey(hkey3);
4125     RegCloseKey(hkey2);
4126     return rc;
4127 }
4128
4129 static UINT ACTION_RegisterClassInfo(MSIPACKAGE *package)
4130 {
4131     /*
4132      * Again I am assuming the words, "Whose key file represents" when referring
4133      * to a Component as to meaning that Components KeyPath file
4134      *
4135      * Also there is a very strong connection between ClassInfo and ProgID
4136      * that I am mostly glossing over.
4137      * What would be more propper is to load the ClassInfo and the ProgID info
4138      * into memory data structures and then be able to enable and disable them
4139      * based on component.
4140      */
4141
4142     UINT rc;
4143     MSIQUERY * view;
4144     MSIRECORD * row = 0;
4145     static const WCHAR ExecSeqQuery[] = {
4146         'S','E','L','E','C','T',' ','*',' ',
4147         'f','r','o','m',' ','C','l','a','s','s',0};
4148     static const WCHAR szCLSID[] = { 'C','L','S','I','D',0 };
4149     static const WCHAR szProgID[] = { 'P','r','o','g','I','D',0 };
4150     static const WCHAR szAppID[] = { 'A','p','p','I','D',0 };
4151     HKEY hkey,hkey2,hkey3;
4152
4153     if (!package)
4154         return ERROR_INVALID_HANDLE;
4155
4156     rc = RegCreateKeyW(HKEY_CLASSES_ROOT,szCLSID,&hkey);
4157     if (rc != ERROR_SUCCESS)
4158         return ERROR_FUNCTION_FAILED;
4159
4160     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4161     if (rc != ERROR_SUCCESS)
4162     {
4163         rc = ERROR_SUCCESS;
4164         goto end;
4165     }
4166
4167     rc = MSI_ViewExecute(view, 0);
4168     if (rc != ERROR_SUCCESS)
4169     {
4170         MSI_ViewClose(view);
4171         msiobj_release(&view->hdr);
4172         goto end;
4173     }
4174
4175     while (1)
4176     {
4177         WCHAR clsid[0x100];
4178         WCHAR buffer[0x100];
4179         WCHAR desc[0x100];
4180         DWORD sz;
4181         INT index;
4182
4183         rc = MSI_ViewFetch(view,&row);
4184         if (rc != ERROR_SUCCESS)
4185         {
4186             rc = ERROR_SUCCESS;
4187             break;
4188         }
4189
4190         sz=0x100;
4191         MSI_RecordGetStringW(row,3,buffer,&sz);
4192
4193         index = get_loaded_component(package,buffer);
4194
4195         if (index < 0)
4196         {
4197             msiobj_release(&row->hdr);
4198             continue;
4199         }
4200
4201         if (package->components[index].ActionRequest != INSTALLSTATE_LOCAL)
4202         {
4203             TRACE("Skipping class reg due to disabled component\n");
4204             msiobj_release(&row->hdr);
4205             continue;
4206         }
4207
4208         sz=0x100;
4209         MSI_RecordGetStringW(row,1,clsid,&sz);
4210         RegCreateKeyW(hkey,clsid,&hkey2);
4211
4212         if (!MSI_RecordIsNull(row,5))
4213         {
4214             sz=0x100;
4215             MSI_RecordGetStringW(row,5,desc,&sz);
4216
4217             RegSetValueExW(hkey2,NULL,0,REG_SZ,(LPVOID)desc,
4218                            (strlenW(desc)+1)*sizeof(WCHAR));
4219         }
4220         else
4221             desc[0]=0;
4222
4223         sz=0x100;
4224         MSI_RecordGetStringW(row,2,buffer,&sz);
4225
4226         RegCreateKeyW(hkey2,buffer,&hkey3);
4227
4228         index = get_loaded_file(package,package->components[index].KeyPath);
4229         RegSetValueExW(hkey3,NULL,0,REG_SZ,
4230                        (LPVOID)package->files[index].TargetPath,
4231                        (strlenW(package->files[index].TargetPath)+1)
4232                         *sizeof(WCHAR));
4233
4234         RegCloseKey(hkey3);
4235
4236         if (!MSI_RecordIsNull(row,4))
4237         {
4238             sz=0x100;
4239             MSI_RecordGetStringW(row,4,buffer,&sz);
4240
4241             RegCreateKeyW(hkey2,szProgID,&hkey3);
4242
4243             RegSetValueExW(hkey3,NULL,0,REG_SZ,(LPVOID)buffer,
4244                        (strlenW(buffer)+1)*sizeof(WCHAR));
4245
4246             RegCloseKey(hkey3);
4247         }
4248
4249         if (!MSI_RecordIsNull(row,6))
4250         {
4251             sz=0x100;
4252             MSI_RecordGetStringW(row,6,buffer,&sz);
4253
4254             RegSetValueExW(hkey2,szAppID,0,REG_SZ,(LPVOID)buffer,
4255                        (strlenW(buffer)+1)*sizeof(WCHAR));
4256
4257             register_appid(package,buffer,desc);
4258         }
4259
4260         RegCloseKey(hkey2);
4261
4262         FIXME("Process the rest of the fields >7\n");
4263
4264         ui_actiondata(package,szRegisterClassInfo,row);
4265
4266         msiobj_release(&row->hdr);
4267     }
4268     MSI_ViewClose(view);
4269     msiobj_release(&view->hdr);
4270
4271 end:
4272     RegCloseKey(hkey);
4273     return rc;
4274 }
4275
4276 static UINT register_progid_base(MSIRECORD * row, LPWSTR clsid)
4277 {
4278     static const WCHAR szCLSID[] = { 'C','L','S','I','D',0 };
4279     HKEY hkey,hkey2;
4280     WCHAR buffer[0x100];
4281     DWORD sz;
4282
4283
4284     sz = 0x100;
4285     MSI_RecordGetStringW(row,1,buffer,&sz);
4286     RegCreateKeyW(HKEY_CLASSES_ROOT,buffer,&hkey);
4287
4288     if (!MSI_RecordIsNull(row,4))
4289     {
4290         sz = 0x100;
4291         MSI_RecordGetStringW(row,4,buffer,&sz);
4292         RegSetValueExW(hkey,NULL,0,REG_SZ,(LPVOID)buffer, (strlenW(buffer)+1) *
4293                        sizeof(WCHAR));
4294     }
4295
4296     if (!MSI_RecordIsNull(row,3))
4297     {
4298         sz = 0x100;
4299
4300         MSI_RecordGetStringW(row,3,buffer,&sz);
4301         RegCreateKeyW(hkey,szCLSID,&hkey2);
4302         RegSetValueExW(hkey2,NULL,0,REG_SZ,(LPVOID)buffer, (strlenW(buffer)+1) *
4303                        sizeof(WCHAR));
4304
4305         if (clsid)
4306             strcpyW(clsid,buffer);
4307
4308         RegCloseKey(hkey2);
4309     }
4310     else
4311     {
4312         FIXME("UNHANDLED case, Parent progid but classid is NULL\n");
4313         return ERROR_FUNCTION_FAILED;
4314     }
4315     if (!MSI_RecordIsNull(row,5))
4316         FIXME ("UNHANDLED icon in Progid\n");
4317     return ERROR_SUCCESS;
4318 }
4319
4320 static UINT register_progid(MSIPACKAGE *package, MSIRECORD * row, LPWSTR clsid);
4321
4322 static UINT register_parent_progid(MSIPACKAGE *package, LPCWSTR parent,
4323                                    LPWSTR clsid)
4324 {
4325     UINT rc;
4326     MSIQUERY * view;
4327     MSIRECORD * row = 0;
4328     static const WCHAR Query_t[] =
4329         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','P','r','o','g'
4330         ,'I','d',' ','w','h','e','r','e',' ','P','r','o','g','I','d',' ','=',' ','`'
4331         ,'%','s','`',0};
4332
4333     if (!package)
4334         return ERROR_INVALID_HANDLE;
4335
4336     rc = ACTION_OpenQuery(package->db, &view, Query_t, parent);
4337     if (rc != ERROR_SUCCESS)
4338         return rc;
4339
4340     rc = MSI_ViewExecute(view, 0);
4341     if (rc != ERROR_SUCCESS)
4342     {
4343         MSI_ViewClose(view);
4344         msiobj_release(&view->hdr);
4345         return rc;
4346     }
4347
4348     rc = MSI_ViewFetch(view,&row);
4349     if (rc != ERROR_SUCCESS)
4350     {
4351         MSI_ViewClose(view);
4352         msiobj_release(&view->hdr);
4353         return rc;
4354     }
4355
4356     register_progid(package,row,clsid);
4357
4358     msiobj_release(&row->hdr);
4359     MSI_ViewClose(view);
4360     msiobj_release(&view->hdr);
4361     return rc;
4362 }
4363
4364 static UINT register_progid(MSIPACKAGE *package, MSIRECORD * row, LPWSTR clsid)
4365 {
4366     UINT rc = ERROR_SUCCESS;
4367
4368     if (MSI_RecordIsNull(row,2))
4369         rc = register_progid_base(row,clsid);
4370     else
4371     {
4372         WCHAR buffer[0x1000];
4373         DWORD sz, disp;
4374         HKEY hkey,hkey2;
4375         static const WCHAR szCLSID[] = { 'C','L','S','I','D',0 };
4376
4377         /* check if already registered */
4378         sz = 0x100;
4379         MSI_RecordGetStringW(row,1,buffer,&sz);
4380         RegCreateKeyExW(HKEY_CLASSES_ROOT, buffer, 0, NULL, 0,
4381                         KEY_ALL_ACCESS, NULL, &hkey, &disp );
4382         if (disp == REG_OPENED_EXISTING_KEY)
4383         {
4384             TRACE("Key already registered\n");
4385             RegCloseKey(hkey);
4386             return rc;
4387         }
4388         /* clsid is same as parent */
4389         RegCreateKeyW(hkey,szCLSID,&hkey2);
4390         RegSetValueExW(hkey2,NULL,0,REG_SZ,(LPVOID)clsid, (strlenW(clsid)+1) *
4391                        sizeof(WCHAR));
4392
4393         RegCloseKey(hkey2);
4394
4395         sz = 0x100;
4396         MSI_RecordGetStringW(row,2,buffer,&sz);
4397         rc = register_parent_progid(package,buffer,clsid);
4398
4399         if (!MSI_RecordIsNull(row,4))
4400         {
4401             sz = 0x100;
4402             MSI_RecordGetStringW(row,4,buffer,&sz);
4403             RegSetValueExW(hkey,NULL,0,REG_SZ,(LPVOID)buffer,
4404                            (strlenW(buffer)+1) * sizeof(WCHAR));
4405         }
4406
4407         if (!MSI_RecordIsNull(row,5))
4408             FIXME ("UNHANDLED icon in Progid\n");
4409
4410         RegCloseKey(hkey);
4411     }
4412     return rc;
4413 }
4414
4415 static UINT ACTION_RegisterProgIdInfo(MSIPACKAGE *package)
4416 {
4417     /*
4418      * Sigh, here I am just brute force registering all progids
4419      * this needs to be linked to the Classes that have been registered
4420      * but the easiest way to do that is to load all these stuff into
4421      * memory for easy checking.
4422      *
4423      * Gives me something to continue to work toward.
4424      */
4425     UINT rc;
4426     MSIQUERY * view;
4427     MSIRECORD * row = 0;
4428     static const WCHAR Query[] = {
4429         'S','E','L','E','C','T',' ','*',' ',
4430         'F','R','O','M',' ','P','r','o','g','I','d',0};
4431
4432     if (!package)
4433         return ERROR_INVALID_HANDLE;
4434
4435     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
4436     if (rc != ERROR_SUCCESS)
4437         return ERROR_SUCCESS;
4438
4439     rc = MSI_ViewExecute(view, 0);
4440     if (rc != ERROR_SUCCESS)
4441     {
4442         MSI_ViewClose(view);
4443         msiobj_release(&view->hdr);
4444         return rc;
4445     }
4446
4447     while (1)
4448     {
4449         WCHAR clsid[0x1000];
4450
4451         rc = MSI_ViewFetch(view,&row);
4452         if (rc != ERROR_SUCCESS)
4453         {
4454             rc = ERROR_SUCCESS;
4455             break;
4456         }
4457
4458         register_progid(package,row,clsid);
4459         ui_actiondata(package,szRegisterProgIdInfo,row);
4460
4461         msiobj_release(&row->hdr);
4462     }
4463     MSI_ViewClose(view);
4464     msiobj_release(&view->hdr);
4465     return rc;
4466 }
4467
4468 static UINT build_icon_path(MSIPACKAGE *package, LPCWSTR icon_name,
4469                             LPWSTR *FilePath)
4470 {
4471     LPWSTR ProductCode;
4472     LPWSTR SystemFolder;
4473     LPWSTR dest;
4474     UINT rc;
4475
4476     static const WCHAR szInstaller[] =
4477         {'I','n','s','t','a','l','l','e','r','\\',0};
4478     static const WCHAR szProductCode[] =
4479         {'P','r','o','d','u','c','t','C','o','d','e',0};
4480     static const WCHAR szFolder[] =
4481         {'W','i','n','d','o','w','s','F','o','l','d','e','r',0};
4482
4483     ProductCode = load_dynamic_property(package,szProductCode,&rc);
4484     if (!ProductCode)
4485         return rc;
4486
4487     SystemFolder = load_dynamic_property(package,szFolder,NULL);
4488
4489     dest = build_directory_name(3, SystemFolder, szInstaller, ProductCode);
4490
4491     create_full_pathW(dest);
4492
4493     *FilePath = build_directory_name(2, dest, icon_name);
4494
4495     HeapFree(GetProcessHeap(),0,SystemFolder);
4496     HeapFree(GetProcessHeap(),0,ProductCode);
4497     HeapFree(GetProcessHeap(),0,dest);
4498     return ERROR_SUCCESS;
4499 }
4500
4501 static UINT ACTION_CreateShortcuts(MSIPACKAGE *package)
4502 {
4503     UINT rc;
4504     MSIQUERY * view;
4505     MSIRECORD * row = 0;
4506     static const WCHAR Query[] = {
4507        'S','E','L','E','C','T',' ','*',' ','f','r','o','m',' ',
4508        'S','h','o','r','t','c','u','t',0};
4509     IShellLinkW *sl;
4510     IPersistFile *pf;
4511     HRESULT res;
4512
4513     if (!package)
4514         return ERROR_INVALID_HANDLE;
4515
4516     res = CoInitialize( NULL );
4517     if (FAILED (res))
4518     {
4519         ERR("CoInitialize failed\n");
4520         return ERROR_FUNCTION_FAILED;
4521     }
4522
4523     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
4524     if (rc != ERROR_SUCCESS)
4525         return ERROR_SUCCESS;
4526
4527     rc = MSI_ViewExecute(view, 0);
4528     if (rc != ERROR_SUCCESS)
4529     {
4530         MSI_ViewClose(view);
4531         msiobj_release(&view->hdr);
4532         return rc;
4533     }
4534
4535     while (1)
4536     {
4537         LPWSTR target_file, target_folder;
4538         WCHAR buffer[0x100];
4539         DWORD sz;
4540         DWORD index;
4541         static const WCHAR szlnk[]={'.','l','n','k',0};
4542
4543         rc = MSI_ViewFetch(view,&row);
4544         if (rc != ERROR_SUCCESS)
4545         {
4546             rc = ERROR_SUCCESS;
4547             break;
4548         }
4549
4550         sz = 0x100;
4551         MSI_RecordGetStringW(row,4,buffer,&sz);
4552
4553         index = get_loaded_component(package,buffer);
4554
4555         if (index < 0)
4556         {
4557             msiobj_release(&row->hdr);
4558             continue;
4559         }
4560
4561         if (package->components[index].ActionRequest != INSTALLSTATE_LOCAL)
4562         {
4563             TRACE("Skipping shortcut creation due to disabled component\n");
4564             msiobj_release(&row->hdr);
4565             continue;
4566         }
4567
4568         ui_actiondata(package,szCreateShortcuts,row);
4569
4570         res = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
4571                               &IID_IShellLinkW, (LPVOID *) &sl );
4572
4573         if (FAILED(res))
4574         {
4575             ERR("Is IID_IShellLink\n");
4576             msiobj_release(&row->hdr);
4577             continue;
4578         }
4579
4580         res = IShellLinkW_QueryInterface( sl, &IID_IPersistFile,(LPVOID*) &pf );
4581         if( FAILED( res ) )
4582         {
4583             ERR("Is IID_IPersistFile\n");
4584             msiobj_release(&row->hdr);
4585             continue;
4586         }
4587
4588         sz = 0x100;
4589         MSI_RecordGetStringW(row,2,buffer,&sz);
4590         target_folder = resolve_folder(package, buffer,FALSE,FALSE,NULL);
4591
4592         /* may be needed because of a bug somehwere else */
4593         create_full_pathW(target_folder);
4594
4595         sz = 0x100;
4596         MSI_RecordGetStringW(row,3,buffer,&sz);
4597         reduce_to_longfilename(buffer);
4598         if (!strchrW(buffer,'.'))
4599             strcatW(buffer,szlnk);
4600         target_file = build_directory_name(2, target_folder, buffer);
4601         HeapFree(GetProcessHeap(),0,target_folder);
4602
4603         sz = 0x100;
4604         MSI_RecordGetStringW(row,5,buffer,&sz);
4605         if (strchrW(buffer,'['))
4606         {
4607             LPWSTR deformated;
4608             deformat_string(package,buffer,&deformated);
4609             IShellLinkW_SetPath(sl,deformated);
4610             HeapFree(GetProcessHeap(),0,deformated);
4611         }
4612         else
4613         {
4614             FIXME("UNHANDLED shortcut format, advertised shortcut\n");
4615             IPersistFile_Release( pf );
4616             IShellLinkW_Release( sl );
4617             msiobj_release(&row->hdr);
4618             continue;
4619         }
4620
4621         if (!MSI_RecordIsNull(row,6))
4622         {
4623             LPWSTR deformated;
4624             sz = 0x100;
4625             MSI_RecordGetStringW(row,6,buffer,&sz);
4626             deformat_string(package,buffer,&deformated);
4627             IShellLinkW_SetArguments(sl,deformated);
4628             HeapFree(GetProcessHeap(),0,deformated);
4629         }
4630
4631         if (!MSI_RecordIsNull(row,7))
4632         {
4633             LPWSTR deformated;
4634             deformated = load_dynamic_stringW(row,7);
4635             IShellLinkW_SetDescription(sl,deformated);
4636             HeapFree(GetProcessHeap(),0,deformated);
4637         }
4638
4639         if (!MSI_RecordIsNull(row,8))
4640             IShellLinkW_SetHotkey(sl,MSI_RecordGetInteger(row,8));
4641
4642         if (!MSI_RecordIsNull(row,9))
4643         {
4644             WCHAR *Path = NULL;
4645             INT index;
4646
4647             sz = 0x100;
4648             MSI_RecordGetStringW(row,9,buffer,&sz);
4649
4650             build_icon_path(package,buffer,&Path);
4651             index = MSI_RecordGetInteger(row,10);
4652
4653             IShellLinkW_SetIconLocation(sl,Path,index);
4654             HeapFree(GetProcessHeap(),0,Path);
4655         }
4656
4657         if (!MSI_RecordIsNull(row,11))
4658             IShellLinkW_SetShowCmd(sl,MSI_RecordGetInteger(row,11));
4659
4660         if (!MSI_RecordIsNull(row,12))
4661         {
4662             LPWSTR Path;
4663             sz = 0x100;
4664             MSI_RecordGetStringW(row,12,buffer,&sz);
4665             Path = resolve_folder(package, buffer, FALSE, FALSE, NULL);
4666             IShellLinkW_SetWorkingDirectory(sl,Path);
4667             HeapFree(GetProcessHeap(), 0, Path);
4668         }
4669
4670         TRACE("Writing shortcut to %s\n",debugstr_w(target_file));
4671         IPersistFile_Save(pf,target_file,FALSE);
4672
4673         HeapFree(GetProcessHeap(),0,target_file);
4674
4675         IPersistFile_Release( pf );
4676         IShellLinkW_Release( sl );
4677
4678         msiobj_release(&row->hdr);
4679     }
4680     MSI_ViewClose(view);
4681     msiobj_release(&view->hdr);
4682
4683
4684     CoUninitialize();
4685
4686     return rc;
4687 }
4688
4689
4690 /*
4691  * 99% of the work done here is only done for
4692  * advertised installs. However this is where the
4693  * Icon table is processed and written out
4694  * so that is what I am going to do here.
4695  */
4696 static UINT ACTION_PublishProduct(MSIPACKAGE *package)
4697 {
4698     UINT rc;
4699     MSIQUERY * view;
4700     MSIRECORD * row = 0;
4701     static const WCHAR Query[]={
4702         'S','E','L','E','C','T',' ','*',' ',
4703         'f','r','o','m',' ','I','c','o','n',0};
4704     DWORD sz;
4705
4706     if (!package)
4707         return ERROR_INVALID_HANDLE;
4708
4709     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
4710     if (rc != ERROR_SUCCESS)
4711         return ERROR_SUCCESS;
4712
4713     rc = MSI_ViewExecute(view, 0);
4714     if (rc != ERROR_SUCCESS)
4715     {
4716         MSI_ViewClose(view);
4717         msiobj_release(&view->hdr);
4718         return rc;
4719     }
4720
4721     while (1)
4722     {
4723         HANDLE the_file;
4724         WCHAR *FilePath=NULL;
4725         WCHAR *FileName=NULL;
4726         CHAR buffer[1024];
4727
4728         rc = MSI_ViewFetch(view,&row);
4729         if (rc != ERROR_SUCCESS)
4730         {
4731             rc = ERROR_SUCCESS;
4732             break;
4733         }
4734
4735         FileName = load_dynamic_stringW(row,1);
4736         if (!FileName)
4737         {
4738             ERR("Unable to get FileName\n");
4739             msiobj_release(&row->hdr);
4740             continue;
4741         }
4742
4743         build_icon_path(package,FileName,&FilePath);
4744
4745         HeapFree(GetProcessHeap(),0,FileName);
4746
4747         TRACE("Creating icon file at %s\n",debugstr_w(FilePath));
4748
4749         the_file = CreateFileW(FilePath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
4750                            FILE_ATTRIBUTE_NORMAL, NULL);
4751
4752         if (the_file == INVALID_HANDLE_VALUE)
4753         {
4754             ERR("Unable to create file %s\n",debugstr_w(FilePath));
4755             msiobj_release(&row->hdr);
4756             HeapFree(GetProcessHeap(),0,FilePath);
4757             continue;
4758         }
4759
4760         do
4761         {
4762             DWORD write;
4763             sz = 1024;
4764             rc = MSI_RecordReadStream(row,2,buffer,&sz);
4765             if (rc != ERROR_SUCCESS)
4766             {
4767                 ERR("Failed to get stream\n");
4768                 CloseHandle(the_file);
4769                 DeleteFileW(FilePath);
4770                 break;
4771             }
4772             WriteFile(the_file,buffer,sz,&write,NULL);
4773         } while (sz == 1024);
4774
4775         HeapFree(GetProcessHeap(),0,FilePath);
4776
4777         CloseHandle(the_file);
4778         msiobj_release(&row->hdr);
4779     }
4780     MSI_ViewClose(view);
4781     msiobj_release(&view->hdr);
4782     return rc;
4783
4784 }
4785
4786 /* Msi functions that seem appropriate here */
4787 UINT WINAPI MsiDoActionA( MSIHANDLE hInstall, LPCSTR szAction )
4788 {
4789     LPWSTR szwAction;
4790     UINT rc;
4791
4792     TRACE(" exteral attempt at action %s\n",szAction);
4793
4794     if (!szAction)
4795         return ERROR_FUNCTION_FAILED;
4796     if (hInstall == 0)
4797         return ERROR_FUNCTION_FAILED;
4798
4799     szwAction = strdupAtoW(szAction);
4800
4801     if (!szwAction)
4802         return ERROR_FUNCTION_FAILED;
4803
4804
4805     rc = MsiDoActionW(hInstall, szwAction);
4806     HeapFree(GetProcessHeap(),0,szwAction);
4807     return rc;
4808 }
4809
4810 UINT WINAPI MsiDoActionW( MSIHANDLE hInstall, LPCWSTR szAction )
4811 {
4812     MSIPACKAGE *package;
4813     UINT ret = ERROR_INVALID_HANDLE;
4814
4815     TRACE(" external attempt at action %s \n",debugstr_w(szAction));
4816
4817     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
4818     if( package )
4819     {
4820         ret = ACTION_PerformAction(package,szAction);
4821         msiobj_release( &package->hdr );
4822     }
4823     return ret;
4824 }
4825
4826 UINT WINAPI MsiGetTargetPathA( MSIHANDLE hInstall, LPCSTR szFolder,
4827                                LPSTR szPathBuf, DWORD* pcchPathBuf)
4828 {
4829     LPWSTR szwFolder;
4830     LPWSTR szwPathBuf;
4831     UINT rc;
4832
4833     TRACE("getting folder %s %p %li\n",szFolder,szPathBuf, *pcchPathBuf);
4834
4835     if (!szFolder)
4836         return ERROR_FUNCTION_FAILED;
4837     if (hInstall == 0)
4838         return ERROR_FUNCTION_FAILED;
4839
4840     szwFolder = strdupAtoW(szFolder);
4841
4842     if (!szwFolder)
4843         return ERROR_FUNCTION_FAILED;
4844
4845     szwPathBuf = HeapAlloc( GetProcessHeap(), 0 , *pcchPathBuf * sizeof(WCHAR));
4846
4847     rc = MsiGetTargetPathW(hInstall, szwFolder, szwPathBuf,pcchPathBuf);
4848
4849     WideCharToMultiByte( CP_ACP, 0, szwPathBuf, *pcchPathBuf, szPathBuf,
4850                          *pcchPathBuf, NULL, NULL );
4851
4852     HeapFree(GetProcessHeap(),0,szwFolder);
4853     HeapFree(GetProcessHeap(),0,szwPathBuf);
4854
4855     return rc;
4856 }
4857
4858 UINT WINAPI MsiGetTargetPathW( MSIHANDLE hInstall, LPCWSTR szFolder, LPWSTR
4859                                 szPathBuf, DWORD* pcchPathBuf)
4860 {
4861     LPWSTR path;
4862     UINT rc = ERROR_FUNCTION_FAILED;
4863     MSIPACKAGE *package;
4864
4865     TRACE("(%s %p %li)\n",debugstr_w(szFolder),szPathBuf,*pcchPathBuf);
4866
4867     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
4868     if (!package)
4869         return ERROR_INVALID_HANDLE;
4870     path = resolve_folder(package, szFolder, FALSE, FALSE, NULL);
4871     msiobj_release( &package->hdr );
4872
4873     if (path && (strlenW(path) > *pcchPathBuf))
4874     {
4875         *pcchPathBuf = strlenW(path)+1;
4876         rc = ERROR_MORE_DATA;
4877     }
4878     else if (path)
4879     {
4880         *pcchPathBuf = strlenW(path)+1;
4881         strcpyW(szPathBuf,path);
4882         TRACE("Returning Path %s\n",debugstr_w(path));
4883         rc = ERROR_SUCCESS;
4884     }
4885     HeapFree(GetProcessHeap(),0,path);
4886
4887     return rc;
4888 }
4889
4890
4891 UINT WINAPI MsiGetSourcePathA( MSIHANDLE hInstall, LPCSTR szFolder,
4892                                LPSTR szPathBuf, DWORD* pcchPathBuf)
4893 {
4894     LPWSTR szwFolder;
4895     LPWSTR szwPathBuf;
4896     UINT rc;
4897
4898     TRACE("getting source %s %p %li\n",szFolder,szPathBuf, *pcchPathBuf);
4899
4900     if (!szFolder)
4901         return ERROR_FUNCTION_FAILED;
4902     if (hInstall == 0)
4903         return ERROR_FUNCTION_FAILED;
4904
4905     szwFolder = strdupAtoW(szFolder);
4906     if (!szwFolder)
4907         return ERROR_FUNCTION_FAILED;
4908
4909     szwPathBuf = HeapAlloc( GetProcessHeap(), 0 , *pcchPathBuf * sizeof(WCHAR));
4910
4911     rc = MsiGetSourcePathW(hInstall, szwFolder, szwPathBuf,pcchPathBuf);
4912
4913     WideCharToMultiByte( CP_ACP, 0, szwPathBuf, *pcchPathBuf, szPathBuf,
4914                          *pcchPathBuf, NULL, NULL );
4915
4916     HeapFree(GetProcessHeap(),0,szwFolder);
4917     HeapFree(GetProcessHeap(),0,szwPathBuf);
4918
4919     return rc;
4920 }
4921
4922 UINT WINAPI MsiGetSourcePathW( MSIHANDLE hInstall, LPCWSTR szFolder, LPWSTR
4923                                 szPathBuf, DWORD* pcchPathBuf)
4924 {
4925     LPWSTR path;
4926     UINT rc = ERROR_FUNCTION_FAILED;
4927     MSIPACKAGE *package;
4928
4929     TRACE("(%s %p %li)\n",debugstr_w(szFolder),szPathBuf,*pcchPathBuf);
4930
4931     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
4932     if( !package )
4933         return ERROR_INVALID_HANDLE;
4934     path = resolve_folder(package, szFolder, TRUE, FALSE, NULL);
4935     msiobj_release( &package->hdr );
4936
4937     if (path && strlenW(path) > *pcchPathBuf)
4938     {
4939         *pcchPathBuf = strlenW(path)+1;
4940         rc = ERROR_MORE_DATA;
4941     }
4942     else if (path)
4943     {
4944         *pcchPathBuf = strlenW(path)+1;
4945         strcpyW(szPathBuf,path);
4946         TRACE("Returning Path %s\n",debugstr_w(path));
4947         rc = ERROR_SUCCESS;
4948     }
4949     HeapFree(GetProcessHeap(),0,path);
4950
4951     return rc;
4952 }
4953
4954
4955 UINT WINAPI MsiSetTargetPathA(MSIHANDLE hInstall, LPCSTR szFolder,
4956                              LPCSTR szFolderPath)
4957 {
4958     LPWSTR szwFolder;
4959     LPWSTR szwFolderPath;
4960     UINT rc;
4961
4962     if (!szFolder)
4963         return ERROR_FUNCTION_FAILED;
4964     if (hInstall == 0)
4965         return ERROR_FUNCTION_FAILED;
4966
4967     szwFolder = strdupAtoW(szFolder);
4968     if (!szwFolder)
4969         return ERROR_FUNCTION_FAILED;
4970
4971     szwFolderPath = strdupAtoW(szFolderPath);
4972     if (!szwFolderPath)
4973     {
4974         HeapFree(GetProcessHeap(),0,szwFolder);
4975         return ERROR_FUNCTION_FAILED;
4976     }
4977
4978     rc = MsiSetTargetPathW(hInstall, szwFolder, szwFolderPath);
4979
4980     HeapFree(GetProcessHeap(),0,szwFolder);
4981     HeapFree(GetProcessHeap(),0,szwFolderPath);
4982
4983     return rc;
4984 }
4985
4986 UINT MSI_SetTargetPathW(MSIPACKAGE *package, LPCWSTR szFolder,
4987                              LPCWSTR szFolderPath)
4988 {
4989     DWORD i;
4990     LPWSTR path = NULL;
4991     MSIFOLDER *folder;
4992
4993     TRACE("(%p %s %s)\n",package, debugstr_w(szFolder),debugstr_w(szFolderPath));
4994
4995     if (package==NULL)
4996         return ERROR_INVALID_HANDLE;
4997
4998     if (szFolderPath[0]==0)
4999         return ERROR_FUNCTION_FAILED;
5000
5001     if (GetFileAttributesW(szFolderPath) == INVALID_FILE_ATTRIBUTES)
5002         return ERROR_FUNCTION_FAILED;
5003
5004     path = resolve_folder(package,szFolder,FALSE,FALSE,&folder);
5005     if (!path)
5006         return ERROR_INVALID_PARAMETER;
5007     HeapFree(GetProcessHeap(),0,path);
5008
5009     strcpyW(folder->Property,szFolderPath);
5010
5011     for (i = 0; i < package->loaded_folders; i++)
5012         package->folders[i].ResolvedTarget=NULL;
5013
5014     for (i = 0; i < package->loaded_folders; i++)
5015     {
5016         path = resolve_folder(package, package->folders[i].Directory, FALSE,
5017                        TRUE, NULL);
5018         HeapFree(GetProcessHeap(),0,path);
5019     }
5020
5021     return ERROR_SUCCESS;
5022 }
5023
5024 UINT WINAPI MsiSetTargetPathW(MSIHANDLE hInstall, LPCWSTR szFolder,
5025                              LPCWSTR szFolderPath)
5026 {
5027     MSIPACKAGE *package;
5028     UINT ret;
5029
5030     TRACE("(%s %s)\n",debugstr_w(szFolder),debugstr_w(szFolderPath));
5031
5032     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
5033     ret = MSI_SetTargetPathW( package, szFolder, szFolderPath );
5034     msiobj_release( &package->hdr );
5035     return ret;
5036 }
5037
5038 /***********************************************************************
5039  *           MsiGetMode    (MSI.@)
5040  *
5041  * Returns an internal installer state (if it is running in a mode iRunMode)
5042  *
5043  * PARAMS
5044  *   hInstall    [I]  Handle to the installation
5045  *   hRunMode    [I]  Checking run mode
5046  *        MSIRUNMODE_ADMIN             Administrative mode
5047  *        MSIRUNMODE_ADVERTISE         Advertisement mode
5048  *        MSIRUNMODE_MAINTENANCE       Maintenance mode
5049  *        MSIRUNMODE_ROLLBACKENABLED   Rollback is enabled
5050  *        MSIRUNMODE_LOGENABLED        Log file is writing
5051  *        MSIRUNMODE_OPERATIONS        Operations in progress??
5052  *        MSIRUNMODE_REBOOTATEND       We need to reboot after installation completed
5053  *        MSIRUNMODE_REBOOTNOW         We need to reboot to continue the installation
5054  *        MSIRUNMODE_CABINET           Files from cabinet are installed
5055  *        MSIRUNMODE_SOURCESHORTNAMES  Long names in source files is supressed
5056  *        MSIRUNMODE_TARGETSHORTNAMES  Long names in destination files is supressed
5057  *        MSIRUNMODE_RESERVED11        Reserved
5058  *        MSIRUNMODE_WINDOWS9X         Running under Windows95/98
5059  *        MSIRUNMODE_ZAWENABLED        Demand installation is supported
5060  *        MSIRUNMODE_RESERVED14        Reserved
5061  *        MSIRUNMODE_RESERVED15        Reserved
5062  *        MSIRUNMODE_SCHEDULED         called from install script
5063  *        MSIRUNMODE_ROLLBACK          called from rollback script
5064  *        MSIRUNMODE_COMMIT            called from commit script
5065  *
5066  * RETURNS
5067  *    In the state: TRUE
5068  *    Not in the state: FALSE
5069  *
5070  */
5071
5072 BOOL WINAPI MsiGetMode(MSIHANDLE hInstall, MSIRUNMODE iRunMode)
5073 {
5074     FIXME("STUB (iRunMode=%i)\n",iRunMode);
5075     return TRUE;
5076 }
5077
5078 /*
5079  * According to the docs, when this is called it immediately recalculates
5080  * all the component states as well
5081  */
5082 UINT WINAPI MsiSetFeatureStateA(MSIHANDLE hInstall, LPCSTR szFeature,
5083                                 INSTALLSTATE iState)
5084 {
5085     LPWSTR szwFeature = NULL;
5086     UINT rc;
5087
5088     szwFeature = strdupAtoW(szFeature);
5089
5090     if (!szwFeature)
5091         return ERROR_FUNCTION_FAILED;
5092
5093     rc = MsiSetFeatureStateW(hInstall,szwFeature, iState);
5094
5095     HeapFree(GetProcessHeap(),0,szwFeature);
5096
5097     return rc;
5098 }
5099
5100 UINT WINAPI MsiSetFeatureStateW(MSIHANDLE hInstall, LPCWSTR szFeature,
5101                                 INSTALLSTATE iState)
5102 {
5103     MSIPACKAGE* package;
5104     INT index;
5105
5106     TRACE(" %s to %i\n",debugstr_w(szFeature), iState);
5107
5108     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
5109     if (!package)
5110         return ERROR_INVALID_HANDLE;
5111
5112     index = get_loaded_feature(package,szFeature);
5113     if (index < 0)
5114         return ERROR_UNKNOWN_FEATURE;
5115
5116     package->features[index].ActionRequest= iState;
5117
5118     return ERROR_SUCCESS;
5119 }
5120
5121 UINT WINAPI MsiGetFeatureStateA(MSIHANDLE hInstall, LPSTR szFeature,
5122                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
5123 {
5124     LPWSTR szwFeature = NULL;
5125     UINT rc;
5126
5127     szwFeature = strdupAtoW(szFeature);
5128
5129     rc = MsiGetFeatureStateW(hInstall,szwFeature,piInstalled, piAction);
5130
5131     HeapFree( GetProcessHeap(), 0 , szwFeature);
5132
5133     return rc;
5134 }
5135
5136 UINT MSI_GetFeatureStateW(MSIPACKAGE *package, LPWSTR szFeature,
5137                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
5138 {
5139     INT index;
5140
5141     index = get_loaded_feature(package,szFeature);
5142     if (index < 0)
5143         return ERROR_UNKNOWN_FEATURE;
5144
5145     if (piInstalled)
5146         *piInstalled = package->features[index].Installed;
5147
5148     if (piAction)
5149         *piAction = package->features[index].Action;
5150
5151     TRACE("returning %i %i\n",*piInstalled,*piAction);
5152
5153     return ERROR_SUCCESS;
5154 }
5155
5156 UINT WINAPI MsiGetFeatureStateW(MSIHANDLE hInstall, LPWSTR szFeature,
5157                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
5158 {
5159     MSIPACKAGE* package;
5160     UINT ret;
5161
5162     TRACE("%ld %s %p %p\n", hInstall, debugstr_w(szFeature), piInstalled,
5163 piAction);
5164
5165     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
5166     if (!package)
5167         return ERROR_INVALID_HANDLE;
5168     ret = MSI_GetFeatureStateW(package, szFeature, piInstalled, piAction);
5169     msiobj_release( &package->hdr );
5170     return ret;
5171 }
5172
5173 UINT WINAPI MsiGetComponentStateA(MSIHANDLE hInstall, LPSTR szComponent,
5174                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
5175 {
5176     LPWSTR szwComponent= NULL;
5177     UINT rc;
5178
5179     szwComponent= strdupAtoW(szComponent);
5180
5181     rc = MsiGetComponentStateW(hInstall,szwComponent,piInstalled, piAction);
5182
5183     HeapFree( GetProcessHeap(), 0 , szwComponent);
5184
5185     return rc;
5186 }
5187
5188 UINT MSI_GetComponentStateW(MSIPACKAGE *package, LPWSTR szComponent,
5189                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
5190 {
5191     INT index;
5192
5193     TRACE("%p %s %p %p\n", package, debugstr_w(szComponent), piInstalled,
5194 piAction);
5195
5196     index = get_loaded_component(package,szComponent);
5197     if (index < 0)
5198         return ERROR_UNKNOWN_COMPONENT;
5199
5200     if (piInstalled)
5201         *piInstalled = package->components[index].Installed;
5202
5203     if (piAction)
5204         *piInstalled = package->components[index].Action;
5205
5206     return ERROR_SUCCESS;
5207 }
5208
5209 UINT WINAPI MsiGetComponentStateW(MSIHANDLE hInstall, LPWSTR szComponent,
5210                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
5211 {
5212     MSIPACKAGE* package;
5213     UINT ret;
5214
5215     TRACE("%ld %s %p %p\n", hInstall, debugstr_w(szComponent),
5216            piInstalled, piAction);
5217
5218     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
5219     if (!package)
5220         return ERROR_INVALID_HANDLE;
5221     ret = MSI_GetComponentStateW( package, szComponent, piInstalled, piAction);
5222     msiobj_release( &package->hdr );
5223     return ret;
5224 }
5225
5226 #if 0
5227 static UINT ACTION_Template(MSIPACKAGE *package)
5228 {
5229     UINT rc;
5230     MSIQUERY * view;
5231     MSIRECORD * row = 0;
5232     static const WCHAR ExecSeqQuery[] = {0};
5233
5234     rc = MsiDatabaseOpenViewW(package->db, ExecSeqQuery, &view);
5235     if (rc != ERROR_SUCCESS)
5236         return rc;
5237
5238     rc = MsiViewExecute(view, 0);
5239     if (rc != ERROR_SUCCESS)
5240     {
5241         MsiViewClose(view);
5242         msiobj_release(&view->hdr);
5243         return rc;
5244     }
5245
5246     while (1)
5247     {
5248         rc = MsiViewFetch(view,&row);
5249         if (rc != ERROR_SUCCESS)
5250         {
5251             rc = ERROR_SUCCESS;
5252             break;
5253         }
5254
5255         msiobj_release(&row->hdr);
5256     }
5257     MsiViewClose(view);
5258     msiobj_release(&view->hdr);
5259     return rc;
5260 }
5261 #endif