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