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