dlls/msi/custom.c

   1 /*
   2  * Custom Action processing for the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2005 Aric Stewart for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #define COBJMACROS
  25
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winerror.h"
  31 #include "msidefs.h"
  32 #include "winuser.h"
  33 #include "objbase.h"
  34 #include "oleauto.h"
  35
  36 #include "msipriv.h"
  37 #include "winemsi.h"
  38 #include "wine/heap.h"
  39 #include "wine/debug.h"
  40 #include "wine/unicode.h"
  41 #include "wine/exception.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  44
  45 #define CUSTOM_ACTION_TYPE_MASK 0x3F
  46
  47 typedef struct tagMSIRUNNINGACTION
  48 {
  49     struct list entry;
  50     HANDLE handle;
  51     BOOL   process;
  52     LPWSTR name;
  53 } MSIRUNNINGACTION;
  54
  55 typedef UINT (WINAPI *MsiCustomActionEntryPoint)( MSIHANDLE );
  56
  57 static CRITICAL_SECTION msi_custom_action_cs;
  58 static CRITICAL_SECTION_DEBUG msi_custom_action_cs_debug =
  59 {
  60     0, 0, &msi_custom_action_cs,
  61     { &msi_custom_action_cs_debug.ProcessLocksList,
  62       &msi_custom_action_cs_debug.ProcessLocksList },
  63       0, 0, { (DWORD_PTR)(__FILE__ ": msi_custom_action_cs") }
  64 };
  65 static CRITICAL_SECTION msi_custom_action_cs = { &msi_custom_action_cs_debug, -1, 0, 0, 0, 0 };
  66
  67 static struct list msi_pending_custom_actions = LIST_INIT( msi_pending_custom_actions );
  68
  69 void  __RPC_FAR * __RPC_USER MIDL_user_allocate(SIZE_T len)
  70 {
  71     return heap_alloc(len);
  72 }
  73
  74 void __RPC_USER MIDL_user_free(void __RPC_FAR * ptr)
  75 {
  76     heap_free(ptr);
  77 }
  78
  79 UINT msi_schedule_action( MSIPACKAGE *package, UINT script, const WCHAR *action )
  80 {
  81     UINT count;
  82     WCHAR **newbuf = NULL;
  83
  84     if (script >= SCRIPT_MAX)
  85     {
  86         FIXME("Unknown script requested %u\n", script);
  87         return ERROR_FUNCTION_FAILED;
  88     }
  89     TRACE("Scheduling action %s in script %u\n", debugstr_w(action), script);
  90
  91     count = package->script_actions_count[script];
  92     package->script_actions_count[script]++;
  93     if (count != 0) newbuf = msi_realloc( package->script_actions[script],
  94                                           package->script_actions_count[script] * sizeof(WCHAR *) );
  95     else newbuf = msi_alloc( sizeof(WCHAR *) );
  96
  97     newbuf[count] = strdupW( action );
  98     package->script_actions[script] = newbuf;
  99     return ERROR_SUCCESS;
 100 }
 101
 102 UINT msi_register_unique_action( MSIPACKAGE *package, const WCHAR *action )
 103 {
 104     UINT count;
 105     WCHAR **newbuf = NULL;
 106
 107     TRACE("Registering %s as unique action\n", debugstr_w(action));
 108
 109     count = package->unique_actions_count;
 110     package->unique_actions_count++;
 111     if (count != 0) newbuf = msi_realloc( package->unique_actions,
 112                                           package->unique_actions_count * sizeof(WCHAR *) );
 113     else newbuf = msi_alloc( sizeof(WCHAR *) );
 114
 115     newbuf[count] = strdupW( action );
 116     package->unique_actions = newbuf;
 117     return ERROR_SUCCESS;
 118 }
 119
 120 BOOL msi_action_is_unique( const MSIPACKAGE *package, const WCHAR *action )
 121 {
 122     UINT i;
 123
 124     for (i = 0; i < package->unique_actions_count; i++)
 125     {
 126         if (!strcmpW( package->unique_actions[i], action )) return TRUE;
 127     }
 128     return FALSE;
 129 }
 130
 131 static BOOL check_execution_scheduling_options(MSIPACKAGE *package, LPCWSTR action, UINT options)
 132 {
 133     if ((options & msidbCustomActionTypeClientRepeat) ==
 134             msidbCustomActionTypeClientRepeat)
 135     {
 136         if (!(package->InWhatSequence & SEQUENCE_UI &&
 137             package->InWhatSequence & SEQUENCE_EXEC))
 138         {
 139             TRACE("Skipping action due to dbCustomActionTypeClientRepeat option.\n");
 140             return FALSE;
 141         }
 142     }
 143     else if (options & msidbCustomActionTypeFirstSequence)
 144     {
 145         if (package->InWhatSequence & SEQUENCE_UI &&
 146             package->InWhatSequence & SEQUENCE_EXEC )
 147         {
 148             TRACE("Skipping action due to msidbCustomActionTypeFirstSequence option.\n");
 149             return FALSE;
 150         }
 151     }
 152     else if (options & msidbCustomActionTypeOncePerProcess)
 153     {
 154         if (msi_action_is_unique(package, action))
 155         {
 156             TRACE("Skipping action due to msidbCustomActionTypeOncePerProcess option.\n");
 157             return FALSE;
 158         }
 159         else
 160             msi_register_unique_action(package, action);
 161     }
 162
 163     return TRUE;
 164 }
 165
 166 /* stores the following properties before the action:
 167  *
 168  *    [CustomActionData<=>UserSID<=>ProductCode]Action
 169  */
 170 static LPWSTR msi_get_deferred_action(LPCWSTR action, LPCWSTR actiondata,
 171                                       LPCWSTR usersid, LPCWSTR prodcode)
 172 {
 173     LPWSTR deferred;
 174     DWORD len;
 175
 176     static const WCHAR format[] = {
 177             '[','%','s','<','=','>','%','s','<','=','>','%','s',']','%','s',0
 178     };
 179
 180     if (!actiondata)
 181         return strdupW(action);
 182
 183     len = lstrlenW(action) + lstrlenW(actiondata) +
 184           lstrlenW(usersid) + lstrlenW(prodcode) +
 185           lstrlenW(format) - 7;
 186     deferred = msi_alloc(len * sizeof(WCHAR));
 187
 188     sprintfW(deferred, format, actiondata, usersid, prodcode, action);
 189     return deferred;
 190 }
 191
 192 static void set_deferred_action_props( MSIPACKAGE *package, const WCHAR *deferred_data )
 193 {
 194     static const WCHAR sep[] = {'<','=','>',0};
 195     const WCHAR *end, *beg = deferred_data + 1;
 196
 197     end = strstrW(beg, sep);
 198     msi_set_property( package->db, szCustomActionData, beg, end - beg );
 199     beg = end + 3;
 200
 201     end = strstrW(beg, sep);
 202     msi_set_property( package->db, szUserSID, beg, end - beg );
 203     beg = end + 3;
 204
 205     end = strchrW(beg, ']');
 206     msi_set_property( package->db, szProductCode, beg, end - beg );
 207 }
 208
 209 WCHAR *msi_create_temp_file( MSIDATABASE *db )
 210 {
 211     WCHAR *ret;
 212
 213     if (!db->tempfolder)
 214     {
 215         WCHAR tmp[MAX_PATH];
 216         UINT len = sizeof(tmp)/sizeof(tmp[0]);
 217
 218         if (msi_get_property( db, szTempFolder, tmp, &len ) ||
 219             GetFileAttributesW( tmp ) != FILE_ATTRIBUTE_DIRECTORY)
 220         {
 221             GetTempPathW( MAX_PATH, tmp );
 222         }
 223         if (!(db->tempfolder = strdupW( tmp ))) return NULL;
 224     }
 225
 226     if ((ret = msi_alloc( (strlenW( db->tempfolder ) + 20) * sizeof(WCHAR) )))
 227     {
 228         if (!GetTempFileNameW( db->tempfolder, szMsi, 0, ret ))
 229         {
 230             msi_free( ret );
 231             return NULL;
 232         }
 233     }
 234
 235     return ret;
 236 }
 237
 238 static MSIBINARY *create_temp_binary(MSIPACKAGE *package, LPCWSTR source)
 239 {
 240     static const WCHAR query[] = {
 241         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 242         '`','B','i' ,'n','a','r','y','`',' ','W','H','E','R','E',' ',
 243         '`','N','a','m','e','`',' ','=',' ','\'','%','s','\'',0};
 244     MSIRECORD *row;
 245     MSIBINARY *binary = NULL;
 246     HANDLE file;
 247     CHAR buffer[1024];
 248     WCHAR *tmpfile;
 249     DWORD sz, write;
 250     UINT r;
 251
 252     if (!(tmpfile = msi_create_temp_file( package->db ))) return NULL;
 253
 254     if (!(row = MSI_QueryGetRecord( package->db, query, source ))) goto error;
 255     if (!(binary = msi_alloc_zero( sizeof(MSIBINARY) ))) goto error;
 256
 257     file = CreateFileW( tmpfile, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
 258     if (file == INVALID_HANDLE_VALUE) goto error;
 259
 260     do
 261     {
 262         sz = sizeof(buffer);
 263         r = MSI_RecordReadStream( row, 2, buffer, &sz );
 264         if (r != ERROR_SUCCESS)
 265         {
 266             ERR("Failed to get stream\n");
 267             break;
 268         }
 269         WriteFile( file, buffer, sz, &write, NULL );
 270     } while (sz == sizeof buffer);
 271
 272     CloseHandle( file );
 273     if (r != ERROR_SUCCESS) goto error;
 274
 275     binary->source = strdupW( source );
 276     binary->tmpfile = tmpfile;
 277     list_add_tail( &package->binaries, &binary->entry );
 278
 279     msiobj_release( &row->hdr );
 280     return binary;
 281
 282 error:
 283     if (row) msiobj_release( &row->hdr );
 284     DeleteFileW( tmpfile );
 285     msi_free( tmpfile );
 286     msi_free( binary );
 287     return NULL;
 288 }
 289
 290 static MSIBINARY *get_temp_binary(MSIPACKAGE *package, LPCWSTR source)
 291 {
 292     MSIBINARY *binary;
 293
 294     LIST_FOR_EACH_ENTRY( binary, &package->binaries, MSIBINARY, entry )
 295     {
 296         if (!strcmpW( binary->source, source ))
 297             return binary;
 298     }
 299
 300     return create_temp_binary(package, source);
 301 }
 302
 303 static void file_running_action(MSIPACKAGE* package, HANDLE Handle,
 304                                 BOOL process, LPCWSTR name)
 305 {
 306     MSIRUNNINGACTION *action;
 307
 308     action = msi_alloc( sizeof(MSIRUNNINGACTION) );
 309
 310     action->handle = Handle;
 311     action->process = process;
 312     action->name = strdupW(name);
 313
 314     list_add_tail( &package->RunningActions, &action->entry );
 315 }
 316
 317 static UINT custom_get_process_return( HANDLE process )
 318 {
 319     DWORD rc = 0;
 320
 321     GetExitCodeProcess( process, &rc );
 322     TRACE("exit code is %u\n", rc);
 323     if (rc != 0)
 324         return ERROR_FUNCTION_FAILED;
 325     return ERROR_SUCCESS;
 326 }
 327
 328 static UINT custom_get_thread_return( MSIPACKAGE *package, HANDLE thread )
 329 {
 330     DWORD rc = 0;
 331
 332     GetExitCodeThread( thread, &rc );
 333
 334     switch (rc)
 335     {
 336     case ERROR_FUNCTION_NOT_CALLED:
 337     case ERROR_SUCCESS:
 338     case ERROR_INSTALL_USEREXIT:
 339     case ERROR_INSTALL_FAILURE:
 340         return rc;
 341     case ERROR_NO_MORE_ITEMS:
 342         return ERROR_SUCCESS;
 343     case ERROR_INSTALL_SUSPEND:
 344         ACTION_ForceReboot( package );
 345         return ERROR_SUCCESS;
 346     default:
 347         ERR("Invalid Return Code %d\n",rc);
 348         return ERROR_INSTALL_FAILURE;
 349     }
 350 }
 351
 352 static UINT wait_process_handle(MSIPACKAGE* package, UINT type,
 353                            HANDLE ProcessHandle, LPCWSTR name)
 354 {
 355     UINT rc = ERROR_SUCCESS;
 356
 357     if (!(type & msidbCustomActionTypeAsync))
 358     {
 359         TRACE("waiting for %s\n", debugstr_w(name));
 360
 361         msi_dialog_check_messages(ProcessHandle);
 362
 363         if (!(type & msidbCustomActionTypeContinue))
 364             rc = custom_get_process_return(ProcessHandle);
 365
 366         CloseHandle(ProcessHandle);
 367     }
 368     else
 369     {
 370         TRACE("%s running in background\n", debugstr_w(name));
 371
 372         if (!(type & msidbCustomActionTypeContinue))
 373             file_running_action(package, ProcessHandle, TRUE, name);
 374         else
 375             CloseHandle(ProcessHandle);
 376     }
 377
 378     return rc;
 379 }
 380
 381 typedef struct _msi_custom_action_info {
 382     struct list entry;
 383     LONG refs;
 384     MSIPACKAGE *package;
 385     LPWSTR source;
 386     LPWSTR target;
 387     HANDLE handle;
 388     LPWSTR action;
 389     INT type;
 390     GUID guid;
 391 } msi_custom_action_info;
 392
 393 static void release_custom_action_data( msi_custom_action_info *info )
 394 {
 395     EnterCriticalSection( &msi_custom_action_cs );
 396
 397     if (!--info->refs)
 398     {
 399         list_remove( &info->entry );
 400         if (info->handle)
 401             CloseHandle( info->handle );
 402         msi_free( info->action );
 403         msi_free( info->source );
 404         msi_free( info->target );
 405         msiobj_release( &info->package->hdr );
 406         msi_free( info );
 407     }
 408
 409     LeaveCriticalSection( &msi_custom_action_cs );
 410 }
 411
 412 /* must be called inside msi_custom_action_cs if info is in the pending custom actions list */
 413 static void addref_custom_action_data( msi_custom_action_info *info )
 414 {
 415     info->refs++;
 416  }
 417
 418 static UINT wait_thread_handle( msi_custom_action_info *info )
 419 {
 420     UINT rc = ERROR_SUCCESS;
 421
 422     if (!(info->type & msidbCustomActionTypeAsync))
 423     {
 424         TRACE("waiting for %s\n", debugstr_w( info->action ));
 425
 426         msi_dialog_check_messages( info->handle );
 427
 428         if (!(info->type & msidbCustomActionTypeContinue))
 429             rc = custom_get_thread_return( info->package, info->handle );
 430
 431         release_custom_action_data( info );
 432     }
 433     else
 434     {
 435         TRACE("%s running in background\n", debugstr_w( info->action ));
 436     }
 437
 438     return rc;
 439 }
 440
 441 static msi_custom_action_info *find_action_by_guid( const GUID *guid )
 442 {
 443     msi_custom_action_info *info;
 444     BOOL found = FALSE;
 445
 446     EnterCriticalSection( &msi_custom_action_cs );
 447
 448     LIST_FOR_EACH_ENTRY( info, &msi_pending_custom_actions, msi_custom_action_info, entry )
 449     {
 450         if (IsEqualGUID( &info->guid, guid ))
 451         {
 452             addref_custom_action_data( info );
 453             found = TRUE;
 454             break;
 455         }
 456     }
 457
 458     LeaveCriticalSection( &msi_custom_action_cs );
 459
 460     if (!found)
 461         return NULL;
 462
 463     return info;
 464 }
 465
 466 static void handle_msi_break(LPCSTR target)
 467 {
 468     char format[] = "To debug your custom action, attach your debugger to "
 469                     "process %i (0x%X) and press OK";
 470     char val[MAX_PATH];
 471     char msg[100];
 472
 473     if (!GetEnvironmentVariableA("MsiBreak", val, MAX_PATH))
 474         return;
 475
 476     if (strcasecmp(val, target))
 477         return;
 478
 479     sprintf(msg, format, GetCurrentProcessId(), GetCurrentProcessId());
 480     MessageBoxA(NULL, msg, "Windows Installer", MB_OK);
 481     DebugBreak();
 482 }
 483
 484 static WCHAR ncalrpcW[] = {'n','c','a','l','r','p','c',0};
 485 static WCHAR endpoint_lrpcW[] = {'m','s','i',0};
 486
 487 #ifdef __i386__
 488 /* wrapper for apps that don't declare the thread function correctly */
 489 extern UINT custom_proc_wrapper( MsiCustomActionEntryPoint entry, MSIHANDLE hinst );
 490 __ASM_GLOBAL_FUNC(custom_proc_wrapper,
 491                   "pushl %ebp\n\t"
 492                   __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
 493                   __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
 494                   "movl %esp,%ebp\n\t"
 495                   __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
 496                   "subl $4,%esp\n\t"
 497                   "pushl 12(%ebp)\n\t"
 498                   "call *8(%ebp)\n\t"
 499                   "leave\n\t"
 500                   __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
 501                   __ASM_CFI(".cfi_same_value %ebp\n\t")
 502                   "ret" )
 503 #else
 504 static UINT custom_proc_wrapper( MsiCustomActionEntryPoint entry, MSIHANDLE hinst )
 505 {
 506     return entry(hinst);
 507 }
 508 #endif
 509
 510 UINT CDECL __wine_msi_call_dll_function(const GUID *guid)
 511 {
 512     MsiCustomActionEntryPoint fn;
 513     MSIHANDLE remote_package = 0;
 514     RPC_WSTR binding_str;
 515     MSIHANDLE hPackage;
 516     RPC_STATUS status;
 517     LPWSTR dll = NULL;
 518     LPSTR proc = NULL;
 519     HANDLE hModule;
 520     INT type;
 521     UINT r;
 522
 523     TRACE("%s\n", debugstr_guid( guid ));
 524
 525     if (!rpc_handle)
 526     {
 527         status = RpcStringBindingComposeW(NULL, ncalrpcW, NULL, endpoint_lrpcW, NULL, &binding_str);
 528         if (status != RPC_S_OK)
 529         {
 530             ERR("RpcStringBindingCompose failed: %#x\n", status);
 531             return status;
 532         }
 533         status = RpcBindingFromStringBindingW(binding_str, &rpc_handle);
 534         if (status != RPC_S_OK)
 535         {
 536             ERR("RpcBindingFromStringBinding failed: %#x\n", status);
 537             return status;
 538         }
 539         RpcStringFreeW(&binding_str);
 540     }
 541
 542     r = remote_GetActionInfo(guid, &type, &dll, &proc, &remote_package);
 543     if (r != ERROR_SUCCESS)
 544         return r;
 545
 546     hModule = LoadLibraryW( dll );
 547     if (!hModule)
 548     {
 549         ERR( "failed to load dll %s (%u)\n", debugstr_w( dll ), GetLastError() );
 550         return ERROR_SUCCESS;
 551     }
 552
 553     fn = (MsiCustomActionEntryPoint) GetProcAddress( hModule, proc );
 554     if (fn)
 555     {
 556         hPackage = alloc_msi_remote_handle( remote_package );
 557         if (hPackage)
 558         {
 559             TRACE("calling %s\n", debugstr_a(proc));
 560             handle_msi_break(proc);
 561
 562             __TRY
 563             {
 564                 r = custom_proc_wrapper(fn, hPackage);
 565             }
 566             __EXCEPT_PAGE_FAULT
 567             {
 568                 ERR("Custom action (%s:%s) caused a page fault: %08x\n",
 569                     debugstr_w(dll), debugstr_a(proc), GetExceptionCode());
 570                 r = ERROR_SUCCESS;
 571             }
 572             __ENDTRY;
 573
 574             MsiCloseHandle( hPackage );
 575         }
 576         else
 577             ERR("failed to create handle for %x\n", remote_package );
 578     }
 579     else
 580         ERR("GetProcAddress(%s) failed\n", debugstr_a(proc));
 581
 582     FreeLibrary(hModule);
 583
 584     midl_user_free(dll);
 585     midl_user_free(proc);
 586
 587     return r;
 588 }
 589
 590 static DWORD custom_start_server(MSIPACKAGE *package, DWORD arch)
 591 {
 592     static const WCHAR pipe_name[] = {'\\','\\','.','\\','p','i','p','e','\\','m','s','i','c','a','_','%','x',0};
 593     static const WCHAR msiexecW[] = {'\\','m','s','i','e','x','e','c','.','e','x','e',0};
 594     static const WCHAR argsW[] = {'%','s',' ','-','E','m','b','e','d','d','i','n','g',' ','%','d',0};
 595
 596     WCHAR path[MAX_PATH], cmdline[MAX_PATH + 23];
 597     PROCESS_INFORMATION pi = {0};
 598     STARTUPINFOW si = {0};
 599     WCHAR buffer[24];
 600     void *cookie;
 601     HANDLE pipe;
 602     BOOL wow64;
 603
 604     if ((arch == SCS_32BIT_BINARY && package->custom_server_32_process) ||
 605         (arch == SCS_64BIT_BINARY && package->custom_server_64_process))
 606         return ERROR_SUCCESS;
 607
 608     sprintfW(buffer, pipe_name, GetCurrentProcessId());
 609     pipe = CreateNamedPipeW(buffer, PIPE_ACCESS_DUPLEX, 0, 1, sizeof(DWORD64),
 610         sizeof(GUID), 0, NULL);
 611
 612     if (sizeof(void *) == 8 && arch == SCS_32BIT_BINARY)
 613         GetSystemWow64DirectoryW(path, MAX_PATH - sizeof(msiexecW)/sizeof(WCHAR));
 614     else
 615         GetSystemDirectoryW(path, MAX_PATH - sizeof(msiexecW)/sizeof(WCHAR));
 616     strcatW(path, msiexecW);
 617     sprintfW(cmdline, argsW, path, GetCurrentProcessId());
 618
 619     if (IsWow64Process(GetCurrentProcess(), &wow64) && wow64 && arch == SCS_64BIT_BINARY)
 620     {
 621         Wow64DisableWow64FsRedirection(&cookie);
 622         CreateProcessW(path, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
 623         Wow64RevertWow64FsRedirection(cookie);
 624     }
 625     else
 626         CreateProcessW(path, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
 627
 628     CloseHandle(pi.hThread);
 629
 630     if (arch == SCS_32BIT_BINARY)
 631     {
 632         package->custom_server_32_process = pi.hProcess;
 633         package->custom_server_32_pipe = pipe;
 634     }
 635     else
 636     {
 637         package->custom_server_64_process = pi.hProcess;
 638         package->custom_server_64_pipe = pipe;
 639     }
 640
 641     if (!ConnectNamedPipe(pipe, NULL))
 642     {
 643         ERR("Failed to connect to custom action server: %u\n", GetLastError());
 644         return GetLastError();
 645     }
 646
 647     return ERROR_SUCCESS;
 648 }
 649
 650 void custom_stop_server(HANDLE process, HANDLE pipe)
 651 {
 652     DWORD size;
 653
 654     WriteFile(pipe, &GUID_NULL, sizeof(GUID_NULL), &size, NULL);
 655     WaitForSingleObject(process, INFINITE);
 656     CloseHandle(process);
 657     CloseHandle(pipe);
 658 }
 659
 660 static DWORD WINAPI custom_client_thread(void *arg)
 661 {
 662     msi_custom_action_info *info = arg;
 663     RPC_STATUS status;
 664     DWORD64 thread64;
 665     HANDLE process;
 666     HANDLE thread;
 667     HANDLE pipe;
 668     DWORD arch;
 669     DWORD size;
 670     BOOL ret;
 671     UINT rc;
 672
 673     CoInitializeEx(NULL, COINIT_MULTITHREADED); /* needed to marshal streams */
 674
 675     if (!info->package->rpc_server_started)
 676     {
 677         status = RpcServerUseProtseqEpW(ncalrpcW, RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
 678             endpoint_lrpcW, NULL);
 679         if (status != RPC_S_OK)
 680         {
 681             ERR("RpcServerUseProtseqEp failed: %#x\n", status);
 682             return status;
 683         }
 684
 685         status = RpcServerRegisterIfEx(s_IWineMsiRemote_v0_0_s_ifspec, NULL, NULL,
 686             RPC_IF_AUTOLISTEN, RPC_C_LISTEN_MAX_CALLS_DEFAULT, NULL);
 687         if (status != RPC_S_OK)
 688         {
 689             ERR("RpcServerRegisterIfEx failed: %#x\n", status);
 690             return status;
 691         }
 692
 693         info->package->rpc_server_started = 1;
 694     }
 695
 696     ret = GetBinaryTypeW(info->source, &arch);
 697     if (!ret)
 698         arch = (sizeof(void *) == 8 ? SCS_64BIT_BINARY : SCS_32BIT_BINARY);
 699
 700     custom_start_server(info->package, arch);
 701     if (arch == SCS_32BIT_BINARY)
 702     {
 703         process = info->package->custom_server_32_process;
 704         pipe = info->package->custom_server_32_pipe;
 705     }
 706     else
 707     {
 708         process = info->package->custom_server_64_process;
 709         pipe = info->package->custom_server_64_pipe;
 710     }
 711
 712     if (!WriteFile(pipe, &info->guid, sizeof(info->guid), &size, NULL) ||
 713         size != sizeof(info->guid))
 714     {
 715         ERR("Failed to write to custom action client pipe: %u\n", GetLastError());
 716         return GetLastError();
 717     }
 718     if (!ReadFile(pipe, &thread64, sizeof(thread64), &size, NULL) || size != sizeof(thread64))
 719     {
 720         ERR("Failed to read from custom action client pipe: %u\n", GetLastError());
 721         return GetLastError();
 722     }
 723
 724     if (DuplicateHandle(process, (HANDLE)(DWORD_PTR)thread64, GetCurrentProcess(),
 725         &thread, 0, FALSE, DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE))
 726     {
 727         WaitForSingleObject(thread, INFINITE);
 728         GetExitCodeThread(thread, &rc);
 729         CloseHandle(thread);
 730     }
 731     else
 732         rc = GetLastError();
 733
 734     CoUninitialize();
 735     return rc;
 736 }
 737
 738 static msi_custom_action_info *do_msidbCustomActionTypeDll(
 739     MSIPACKAGE *package, INT type, LPCWSTR source, LPCWSTR target, LPCWSTR action )
 740 {
 741     msi_custom_action_info *info;
 742
 743     info = msi_alloc( sizeof *info );
 744     if (!info)
 745         return NULL;
 746
 747     msiobj_addref( &package->hdr );
 748     info->refs = 2; /* 1 for our caller and 1 for thread we created */
 749     info->package = package;
 750     info->type = type;
 751     info->target = strdupW( target );
 752     info->source = strdupW( source );
 753     info->action = strdupW( action );
 754     CoCreateGuid( &info->guid );
 755
 756     EnterCriticalSection( &msi_custom_action_cs );
 757     list_add_tail( &msi_pending_custom_actions, &info->entry );
 758     LeaveCriticalSection( &msi_custom_action_cs );
 759
 760     info->handle = CreateThread(NULL, 0, custom_client_thread, info, 0, NULL);
 761     if (!info->handle)
 762     {
 763         /* release both references */
 764         release_custom_action_data( info );
 765         release_custom_action_data( info );
 766         return NULL;
 767     }
 768
 769     return info;
 770 }
 771
 772 static UINT HANDLE_CustomType1( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
 773                                 INT type, const WCHAR *action )
 774 {
 775     msi_custom_action_info *info;
 776     MSIBINARY *binary;
 777
 778     if (!(binary = get_temp_binary(package, source)))
 779         return ERROR_FUNCTION_FAILED;
 780
 781     TRACE("Calling function %s from %s\n", debugstr_w(target), debugstr_w(binary->tmpfile));
 782
 783     info = do_msidbCustomActionTypeDll( package, type, binary->tmpfile, target, action );
 784     return wait_thread_handle( info );
 785 }
 786
 787 static HANDLE execute_command( const WCHAR *app, WCHAR *arg, const WCHAR *dir )
 788 {
 789     static const WCHAR dotexeW[] = {'.','e','x','e',0};
 790     STARTUPINFOW si;
 791     PROCESS_INFORMATION info;
 792     WCHAR *exe = NULL, *cmd = NULL, *p;
 793     BOOL ret;
 794
 795     if (app)
 796     {
 797         int len_arg = 0;
 798         DWORD len_exe;
 799
 800         if (!(exe = msi_alloc( MAX_PATH * sizeof(WCHAR) ))) return INVALID_HANDLE_VALUE;
 801         len_exe = SearchPathW( NULL, app, dotexeW, MAX_PATH, exe, NULL );
 802         if (len_exe >= MAX_PATH)
 803         {
 804             msi_free( exe );
 805             if (!(exe = msi_alloc( len_exe * sizeof(WCHAR) ))) return INVALID_HANDLE_VALUE;
 806             len_exe = SearchPathW( NULL, app, dotexeW, len_exe, exe, NULL );
 807         }
 808         if (!len_exe)
 809         {
 810             ERR("can't find executable %u\n", GetLastError());
 811             msi_free( exe );
 812             return INVALID_HANDLE_VALUE;
 813         }
 814
 815         if (arg) len_arg = strlenW( arg );
 816         if (!(cmd = msi_alloc( (len_exe + len_arg + 4) * sizeof(WCHAR) )))
 817         {
 818             msi_free( exe );
 819             return INVALID_HANDLE_VALUE;
 820         }
 821         p = cmd;
 822         if (strchrW( exe, ' ' ))
 823         {
 824             *p++ = '\"';
 825             memcpy( p, exe, len_exe * sizeof(WCHAR) );
 826             p += len_exe;
 827             *p++ = '\"';
 828             *p = 0;
 829         }
 830         else
 831         {
 832             strcpyW( p, exe );
 833             p += len_exe;
 834         }
 835         if (arg)
 836         {
 837             *p++ = ' ';
 838             memcpy( p, arg, len_arg * sizeof(WCHAR) );
 839             p[len_arg] = 0;
 840         }
 841     }
 842     memset( &si, 0, sizeof(STARTUPINFOW) );
 843     ret = CreateProcessW( exe, exe ? cmd : arg, NULL, NULL, FALSE, 0, NULL, dir, &si, &info );
 844     msi_free( cmd );
 845     msi_free( exe );
 846     if (!ret)
 847     {
 848         ERR("unable to execute command %u\n", GetLastError());
 849         return INVALID_HANDLE_VALUE;
 850     }
 851     CloseHandle( info.hThread );
 852     return info.hProcess;
 853 }
 854
 855 static UINT HANDLE_CustomType2( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
 856                                 INT type, const WCHAR *action )
 857 {
 858     MSIBINARY *binary;
 859     HANDLE handle;
 860     WCHAR *arg;
 861
 862     if (!(binary = get_temp_binary(package, source)))
 863         return ERROR_FUNCTION_FAILED;
 864
 865     deformat_string( package, target, &arg );
 866     TRACE("exe %s arg %s\n", debugstr_w(binary->tmpfile), debugstr_w(arg));
 867
 868     handle = execute_command( binary->tmpfile, arg, szCRoot );
 869     msi_free( arg );
 870     if (handle == INVALID_HANDLE_VALUE) return ERROR_SUCCESS;
 871     return wait_process_handle( package, type, handle, action );
 872 }
 873
 874 static UINT HANDLE_CustomType17( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
 875                                  INT type, const WCHAR *action )
 876 {
 877     msi_custom_action_info *info;
 878     MSIFILE *file;
 879
 880     TRACE("%s %s\n", debugstr_w(source), debugstr_w(target));
 881
 882     file = msi_get_loaded_file( package, source );
 883     if (!file)
 884     {
 885         ERR("invalid file key %s\n", debugstr_w( source ));
 886         return ERROR_FUNCTION_FAILED;
 887     }
 888
 889     info = do_msidbCustomActionTypeDll( package, type, file->TargetPath, target, action );
 890     return wait_thread_handle( info );
 891 }
 892
 893 static UINT HANDLE_CustomType18( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
 894                                  INT type, const WCHAR *action )
 895 {
 896     MSIFILE *file;
 897     HANDLE handle;
 898     WCHAR *arg;
 899
 900     if (!(file = msi_get_loaded_file( package, source ))) return ERROR_FUNCTION_FAILED;
 901
 902     deformat_string( package, target, &arg );
 903     TRACE("exe %s arg %s\n", debugstr_w(file->TargetPath), debugstr_w(arg));
 904
 905     handle = execute_command( file->TargetPath, arg, szCRoot );
 906     msi_free( arg );
 907     if (handle == INVALID_HANDLE_VALUE) return ERROR_SUCCESS;
 908     return wait_process_handle( package, type, handle, action );
 909 }
 910
 911 static UINT HANDLE_CustomType19( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
 912                                  INT type, const WCHAR *action )
 913 {
 914     static const WCHAR query[] = {
 915       'S','E','L','E','C','T',' ','`','M','e','s','s','a','g','e','`',' ',
 916       'F','R','O','M',' ','`','E','r','r','o','r','`',' ',
 917       'W','H','E','R','E',' ','`','E','r','r','o','r','`',' ','=',' ',
 918       '%','s',0
 919     };
 920     MSIRECORD *row = 0;
 921     LPWSTR deformated = NULL;
 922
 923     deformat_string( package, target, &deformated );
 924
 925     /* first try treat the error as a number */
 926     row = MSI_QueryGetRecord( package->db, query, deformated );
 927     if( row )
 928     {
 929         LPCWSTR error = MSI_RecordGetString( row, 1 );
 930         if ((package->ui_level & INSTALLUILEVEL_MASK) != INSTALLUILEVEL_NONE)
 931             MessageBoxW( NULL, error, NULL, MB_OK );
 932         msiobj_release( &row->hdr );
 933     }
 934     else if ((package->ui_level & INSTALLUILEVEL_MASK) != INSTALLUILEVEL_NONE)
 935         MessageBoxW( NULL, deformated, NULL, MB_OK );
 936
 937     msi_free( deformated );
 938
 939     return ERROR_INSTALL_FAILURE;
 940 }
 941
 942 static UINT HANDLE_CustomType23( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
 943                                  INT type, const WCHAR *action )
 944 {
 945     static const WCHAR msiexecW[] = {'m','s','i','e','x','e','c',0};
 946     static const WCHAR paramsW[] = {'/','q','b',' ','/','i',' '};
 947     WCHAR *dir, *arg, *p;
 948     UINT len_src, len_dir, len_tgt, len = sizeof(paramsW)/sizeof(paramsW[0]);
 949     HANDLE handle;
 950
 951     if (!(dir = msi_dup_property( package->db, szOriginalDatabase ))) return ERROR_OUTOFMEMORY;
 952     if (!(p = strrchrW( dir, '\\' )) && !(p = strrchrW( dir, '/' )))
 953     {
 954         msi_free( dir );
 955         return ERROR_FUNCTION_FAILED;
 956     }
 957     *p = 0;
 958     len_dir = p - dir;
 959     len_src = strlenW( source );
 960     len_tgt = strlenW( target );
 961     if (!(arg = msi_alloc( (len + len_dir + len_src + len_tgt + 5) * sizeof(WCHAR) )))
 962     {
 963         msi_free( dir );
 964         return ERROR_OUTOFMEMORY;
 965     }
 966     memcpy( arg, paramsW, sizeof(paramsW) );
 967     arg[len++] = '"';
 968     memcpy( arg + len, dir, len_dir * sizeof(WCHAR) );
 969     len += len_dir;
 970     arg[len++] = '\\';
 971     memcpy( arg + len, source, len_src * sizeof(WCHAR) );
 972     len += len_src;
 973     arg[len++] = '"';
 974     arg[len++] = ' ';
 975     strcpyW( arg + len, target );
 976
 977     TRACE("installing %s concurrently\n", debugstr_w(source));
 978
 979     handle = execute_command( msiexecW, arg, dir );
 980     msi_free( dir );
 981     msi_free( arg );
 982     if (handle == INVALID_HANDLE_VALUE) return ERROR_SUCCESS;
 983     return wait_process_handle( package, type, handle, action );
 984 }
 985
 986 static UINT HANDLE_CustomType50( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
 987                                  INT type, const WCHAR *action )
 988 {
 989     WCHAR *exe, *arg;
 990     HANDLE handle;
 991
 992     if (!(exe = msi_dup_property( package->db, source ))) return ERROR_SUCCESS;
 993
 994     deformat_string( package, target, &arg );
 995     TRACE("exe %s arg %s\n", debugstr_w(exe), debugstr_w(arg));
 996
 997     handle = execute_command( exe, arg, szCRoot );
 998     msi_free( exe );
 999     msi_free( arg );
1000     if (handle == INVALID_HANDLE_VALUE) return ERROR_SUCCESS;
1001     return wait_process_handle( package, type, handle, action );
1002 }
1003
1004 static UINT HANDLE_CustomType34( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
1005                                  INT type, const WCHAR *action )
1006 {
1007     const WCHAR *workingdir = NULL;
1008     HANDLE handle;
1009     WCHAR *cmd;
1010
1011     if (source)
1012     {
1013         workingdir = msi_get_target_folder( package, source );
1014         if (!workingdir) return ERROR_FUNCTION_FAILED;
1015     }
1016     deformat_string( package, target, &cmd );
1017     if (!cmd) return ERROR_FUNCTION_FAILED;
1018
1019     TRACE("cmd %s dir %s\n", debugstr_w(cmd), debugstr_w(workingdir));
1020
1021     handle = execute_command( NULL, cmd, workingdir );
1022     msi_free( cmd );
1023     if (handle == INVALID_HANDLE_VALUE) return ERROR_SUCCESS;
1024     return wait_process_handle( package, type, handle, action );
1025 }
1026
1027 static DWORD ACTION_CallScript( const GUID *guid )
1028 {
1029     msi_custom_action_info *info;
1030     MSIHANDLE hPackage;
1031     UINT r = ERROR_FUNCTION_FAILED;
1032
1033     info = find_action_by_guid( guid );
1034     if (!info)
1035     {
1036         ERR("failed to find action %s\n", debugstr_guid( guid) );
1037         return ERROR_FUNCTION_FAILED;
1038     }
1039
1040     TRACE("function %s, script %s\n", debugstr_w( info->target ), debugstr_w( info->source ) );
1041
1042     hPackage = alloc_msihandle( &info->package->hdr );
1043     if (hPackage)
1044     {
1045         r = call_script( hPackage, info->type, info->source, info->target, info->action );
1046         TRACE("script returned %u\n", r);
1047         MsiCloseHandle( hPackage );
1048     }
1049     else
1050         ERR("failed to create handle for %p\n", info->package );
1051
1052     release_custom_action_data( info );
1053     return r;
1054 }
1055
1056 static DWORD WINAPI ScriptThread( LPVOID arg )
1057 {
1058     LPGUID guid = arg;
1059     DWORD rc;
1060
1061     TRACE("custom action (%x) started\n", GetCurrentThreadId() );
1062
1063     rc = ACTION_CallScript( guid );
1064
1065     TRACE("custom action (%x) returned %i\n", GetCurrentThreadId(), rc );
1066
1067     MsiCloseAllHandles();
1068     return rc;
1069 }
1070
1071 static msi_custom_action_info *do_msidbCustomActionTypeScript(
1072     MSIPACKAGE *package, INT type, LPCWSTR script, LPCWSTR function, LPCWSTR action )
1073 {
1074     msi_custom_action_info *info;
1075
1076     info = msi_alloc( sizeof *info );
1077     if (!info)
1078         return NULL;
1079
1080     msiobj_addref( &package->hdr );
1081     info->refs = 2; /* 1 for our caller and 1 for thread we created */
1082     info->package = package;
1083     info->type = type;
1084     info->target = strdupW( function );
1085     info->source = strdupW( script );
1086     info->action = strdupW( action );
1087     CoCreateGuid( &info->guid );
1088
1089     EnterCriticalSection( &msi_custom_action_cs );
1090     list_add_tail( &msi_pending_custom_actions, &info->entry );
1091     LeaveCriticalSection( &msi_custom_action_cs );
1092
1093     info->handle = CreateThread( NULL, 0, ScriptThread, &info->guid, 0, NULL );
1094     if (!info->handle)
1095     {
1096         /* release both references */
1097         release_custom_action_data( info );
1098         release_custom_action_data( info );
1099         return NULL;
1100     }
1101
1102     return info;
1103 }
1104
1105 static UINT HANDLE_CustomType37_38( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
1106                                     INT type, const WCHAR *action )
1107 {
1108     msi_custom_action_info *info;
1109
1110     TRACE("%s %s\n", debugstr_w(source), debugstr_w(target));
1111
1112     info = do_msidbCustomActionTypeScript( package, type, target, NULL, action );
1113     return wait_thread_handle( info );
1114 }
1115
1116 static UINT HANDLE_CustomType5_6( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
1117                                   INT type, const WCHAR *action )
1118 {
1119     static const WCHAR query[] = {
1120         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1121         '`','B','i' ,'n','a','r','y','`',' ','W','H','E','R','E',' ',
1122         '`','N','a','m','e','`',' ','=',' ','\'','%','s','\'',0};
1123     MSIRECORD *row = NULL;
1124     msi_custom_action_info *info;
1125     CHAR *buffer = NULL;
1126     WCHAR *bufferw = NULL;
1127     DWORD sz = 0;
1128     UINT r;
1129
1130     TRACE("%s %s\n", debugstr_w(source), debugstr_w(target));
1131
1132     row = MSI_QueryGetRecord(package->db, query, source);
1133     if (!row)
1134         return ERROR_FUNCTION_FAILED;
1135
1136     r = MSI_RecordReadStream(row, 2, NULL, &sz);
1137     if (r != ERROR_SUCCESS) goto done;
1138
1139     buffer = msi_alloc( sz + 1 );
1140     if (!buffer)
1141     {
1142        r = ERROR_FUNCTION_FAILED;
1143        goto done;
1144     }
1145
1146     r = MSI_RecordReadStream(row, 2, buffer, &sz);
1147     if (r != ERROR_SUCCESS)
1148         goto done;
1149
1150     buffer[sz] = 0;
1151     bufferw = strdupAtoW(buffer);
1152     if (!bufferw)
1153     {
1154         r = ERROR_FUNCTION_FAILED;
1155         goto done;
1156     }
1157
1158     info = do_msidbCustomActionTypeScript( package, type, bufferw, target, action );
1159     r = wait_thread_handle( info );
1160
1161 done:
1162     msi_free(bufferw);
1163     msi_free(buffer);
1164     msiobj_release(&row->hdr);
1165     return r;
1166 }
1167
1168 static UINT HANDLE_CustomType21_22( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
1169                                     INT type, const WCHAR *action )
1170 {
1171     msi_custom_action_info *info;
1172     MSIFILE *file;
1173     HANDLE hFile;
1174     DWORD sz, szHighWord = 0, read;
1175     CHAR *buffer=NULL;
1176     WCHAR *bufferw=NULL;
1177     BOOL bRet;
1178     UINT r;
1179
1180     TRACE("%s %s\n", debugstr_w(source), debugstr_w(target));
1181
1182     file = msi_get_loaded_file(package, source);
1183     if (!file)
1184     {
1185         ERR("invalid file key %s\n", debugstr_w(source));
1186         return ERROR_FUNCTION_FAILED;
1187     }
1188
1189     hFile = CreateFileW(file->TargetPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
1190     if (hFile == INVALID_HANDLE_VALUE) return ERROR_FUNCTION_FAILED;
1191
1192     sz = GetFileSize(hFile, &szHighWord);
1193     if (sz == INVALID_FILE_SIZE || szHighWord != 0)
1194     {
1195         CloseHandle(hFile);
1196         return ERROR_FUNCTION_FAILED;
1197     }
1198     buffer = msi_alloc( sz + 1 );
1199     if (!buffer)
1200     {
1201         CloseHandle(hFile);
1202         return ERROR_FUNCTION_FAILED;
1203     }
1204     bRet = ReadFile(hFile, buffer, sz, &read, NULL);
1205     CloseHandle(hFile);
1206     if (!bRet)
1207     {
1208         r = ERROR_FUNCTION_FAILED;
1209         goto done;
1210     }
1211     buffer[read] = 0;
1212     bufferw = strdupAtoW(buffer);
1213     if (!bufferw)
1214     {
1215         r = ERROR_FUNCTION_FAILED;
1216         goto done;
1217     }
1218     info = do_msidbCustomActionTypeScript( package, type, bufferw, target, action );
1219     r = wait_thread_handle( info );
1220
1221 done:
1222     msi_free(bufferw);
1223     msi_free(buffer);
1224     return r;
1225 }
1226
1227 static UINT HANDLE_CustomType53_54( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
1228                                     INT type, const WCHAR *action )
1229 {
1230     msi_custom_action_info *info;
1231     WCHAR *prop;
1232
1233     TRACE("%s %s\n", debugstr_w(source), debugstr_w(target));
1234
1235     prop = msi_dup_property( package->db, source );
1236     if (!prop) return ERROR_SUCCESS;
1237
1238     info = do_msidbCustomActionTypeScript( package, type, prop, NULL, action );
1239     msi_free(prop);
1240     return wait_thread_handle( info );
1241 }
1242
1243 static BOOL action_type_matches_script( UINT type, UINT script )
1244 {
1245     switch (script)
1246     {
1247     case SCRIPT_NONE:
1248         return FALSE;
1249     case SCRIPT_INSTALL:
1250         return !(type & msidbCustomActionTypeCommit) && !(type & msidbCustomActionTypeRollback);
1251     case SCRIPT_COMMIT:
1252         return (type & msidbCustomActionTypeCommit);
1253     case SCRIPT_ROLLBACK:
1254         return (type & msidbCustomActionTypeRollback);
1255     default:
1256         ERR("unhandled script %u\n", script);
1257     }
1258     return FALSE;
1259 }
1260
1261 static UINT defer_custom_action( MSIPACKAGE *package, const WCHAR *action, UINT type )
1262 {
1263     WCHAR *actiondata = msi_dup_property( package->db, action );
1264     WCHAR *usersid = msi_dup_property( package->db, szUserSID );
1265     WCHAR *prodcode = msi_dup_property( package->db, szProductCode );
1266     WCHAR *deferred = msi_get_deferred_action( action, actiondata, usersid, prodcode );
1267
1268     if (!deferred)
1269     {
1270         msi_free( actiondata );
1271         msi_free( usersid );
1272         msi_free( prodcode );
1273         return ERROR_OUTOFMEMORY;
1274     }
1275     if (type & msidbCustomActionTypeCommit)
1276     {
1277         TRACE("deferring commit action\n");
1278         msi_schedule_action( package, SCRIPT_COMMIT, deferred );
1279     }
1280     else if (type & msidbCustomActionTypeRollback)
1281     {
1282         TRACE("deferring rollback action\n");
1283         msi_schedule_action( package, SCRIPT_ROLLBACK, deferred );
1284     }
1285     else
1286     {
1287         TRACE("deferring install action\n");
1288         msi_schedule_action( package, SCRIPT_INSTALL, deferred );
1289     }
1290
1291     msi_free( actiondata );
1292     msi_free( usersid );
1293     msi_free( prodcode );
1294     msi_free( deferred );
1295     return ERROR_SUCCESS;
1296 }
1297
1298 UINT ACTION_CustomAction(MSIPACKAGE *package, const WCHAR *action)
1299 {
1300     static const WCHAR query[] = {
1301         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1302         '`','C','u','s','t','o','m','A','c','t','i','o','n','`',' ','W','H','E','R','E',' ',
1303         '`','A','c','t','i' ,'o','n','`',' ','=',' ','\'','%','s','\'',0};
1304     UINT rc = ERROR_SUCCESS;
1305     MSIRECORD *row;
1306     UINT type;
1307     const WCHAR *source, *target, *ptr, *deferred_data = NULL;
1308     WCHAR *deformated = NULL;
1309     int len;
1310
1311     /* deferred action: [properties]Action */
1312     if ((ptr = strrchrW(action, ']')))
1313     {
1314         deferred_data = action;
1315         action = ptr + 1;
1316     }
1317
1318     row = MSI_QueryGetRecord( package->db, query, action );
1319     if (!row)
1320         return ERROR_FUNCTION_NOT_CALLED;
1321
1322     type = MSI_RecordGetInteger(row,2);
1323     source = MSI_RecordGetString(row,3);
1324     target = MSI_RecordGetString(row,4);
1325
1326     TRACE("Handling custom action %s (%x %s %s)\n",debugstr_w(action),type,
1327           debugstr_w(source), debugstr_w(target));
1328
1329     /* handle some of the deferred actions */
1330     if (type & msidbCustomActionTypeTSAware)
1331         FIXME("msidbCustomActionTypeTSAware not handled\n");
1332
1333     if (type & msidbCustomActionTypeInScript)
1334     {
1335         if (type & msidbCustomActionTypeNoImpersonate)
1336             WARN("msidbCustomActionTypeNoImpersonate not handled\n");
1337
1338         if (!action_type_matches_script(type, package->script))
1339         {
1340             rc = defer_custom_action( package, action, type );
1341             goto end;
1342         }
1343         else
1344         {
1345             LPWSTR actiondata = msi_dup_property( package->db, action );
1346
1347             if (type & msidbCustomActionTypeInScript)
1348                 package->scheduled_action_running = TRUE;
1349
1350             if (type & msidbCustomActionTypeCommit)
1351                 package->commit_action_running = TRUE;
1352
1353             if (type & msidbCustomActionTypeRollback)
1354                 package->rollback_action_running = TRUE;
1355
1356             if (deferred_data)
1357                 set_deferred_action_props(package, deferred_data);
1358             else if (actiondata)
1359                 msi_set_property( package->db, szCustomActionData, actiondata, -1 );
1360             else
1361                 msi_set_property( package->db, szCustomActionData, szEmpty, -1 );
1362
1363             msi_free(actiondata);
1364         }
1365     }
1366     else if (!check_execution_scheduling_options(package,action,type))
1367     {
1368         rc = ERROR_SUCCESS;
1369         goto end;
1370     }
1371
1372     switch (type & CUSTOM_ACTION_TYPE_MASK)
1373     {
1374         case 1: /* DLL file stored in a Binary table stream */
1375             rc = HANDLE_CustomType1(package,source,target,type,action);
1376             break;
1377         case 2: /* EXE file stored in a Binary table stream */
1378             rc = HANDLE_CustomType2(package,source,target,type,action);
1379             break;
1380         case 18: /*EXE file installed with package */
1381             rc = HANDLE_CustomType18(package,source,target,type,action);
1382             break;
1383         case 19: /* Error that halts install */
1384             rc = HANDLE_CustomType19(package,source,target,type,action);
1385             break;
1386         case 17:
1387             rc = HANDLE_CustomType17(package,source,target,type,action);
1388             break;
1389         case 23: /* installs another package in the source tree */
1390             deformat_string(package,target,&deformated);
1391             rc = HANDLE_CustomType23(package,source,deformated,type,action);
1392             msi_free(deformated);
1393             break;
1394         case 50: /*EXE file specified by a property value */
1395             rc = HANDLE_CustomType50(package,source,target,type,action);
1396             break;
1397         case 34: /*EXE to be run in specified directory */
1398             rc = HANDLE_CustomType34(package,source,target,type,action);
1399             break;
1400         case 35: /* Directory set with formatted text. */
1401             deformat_string(package,target,&deformated);
1402             MSI_SetTargetPathW(package, source, deformated);
1403             msi_free(deformated);
1404             break;
1405         case 51: /* Property set with formatted text. */
1406             if (!source)
1407                 break;
1408
1409             len = deformat_string( package, target, &deformated );
1410             rc = msi_set_property( package->db, source, deformated, len );
1411             if (rc == ERROR_SUCCESS && !strcmpW( source, szSourceDir ))
1412                 msi_reset_folders( package, TRUE );
1413             msi_free(deformated);
1414             break;
1415     case 37: /* JScript/VBScript text stored in target column. */
1416     case 38:
1417         rc = HANDLE_CustomType37_38(package,source,target,type,action);
1418         break;
1419     case 5:
1420     case 6: /* JScript/VBScript file stored in a Binary table stream. */
1421         rc = HANDLE_CustomType5_6(package,source,target,type,action);
1422         break;
1423     case 21: /* JScript/VBScript file installed with the product. */
1424     case 22:
1425         rc = HANDLE_CustomType21_22(package,source,target,type,action);
1426         break;
1427     case 53: /* JScript/VBScript text specified by a property value. */
1428     case 54:
1429         rc = HANDLE_CustomType53_54(package,source,target,type,action);
1430         break;
1431     default:
1432         FIXME("unhandled action type %u (%s %s)\n", type & CUSTOM_ACTION_TYPE_MASK,
1433               debugstr_w(source), debugstr_w(target));
1434     }
1435
1436 end:
1437     package->scheduled_action_running = FALSE;
1438     package->commit_action_running = FALSE;
1439     package->rollback_action_running = FALSE;
1440     msiobj_release(&row->hdr);
1441     return rc;
1442 }
1443
1444 void ACTION_FinishCustomActions(const MSIPACKAGE* package)
1445 {
1446     struct list *item;
1447     HANDLE *wait_handles;
1448     unsigned int handle_count, i;
1449     msi_custom_action_info *info, *cursor;
1450
1451     while ((item = list_head( &package->RunningActions )))
1452     {
1453         MSIRUNNINGACTION *action = LIST_ENTRY( item, MSIRUNNINGACTION, entry );
1454
1455         list_remove( &action->entry );
1456
1457         TRACE("waiting for %s\n", debugstr_w( action->name ) );
1458         msi_dialog_check_messages( action->handle );
1459
1460         CloseHandle( action->handle );
1461         msi_free( action->name );
1462         msi_free( action );
1463     }
1464
1465     EnterCriticalSection( &msi_custom_action_cs );
1466
1467     handle_count = list_count( &msi_pending_custom_actions );
1468     wait_handles = msi_alloc( handle_count * sizeof(HANDLE) );
1469
1470     handle_count = 0;
1471     LIST_FOR_EACH_ENTRY_SAFE( info, cursor, &msi_pending_custom_actions, msi_custom_action_info, entry )
1472     {
1473         if (info->package == package )
1474         {
1475             if (DuplicateHandle(GetCurrentProcess(), info->handle, GetCurrentProcess(), &wait_handles[handle_count], SYNCHRONIZE, FALSE, 0))
1476                 handle_count++;
1477         }
1478     }
1479
1480     LeaveCriticalSection( &msi_custom_action_cs );
1481
1482     for (i = 0; i < handle_count; i++)
1483     {
1484         msi_dialog_check_messages( wait_handles[i] );
1485         CloseHandle( wait_handles[i] );
1486     }
1487     msi_free( wait_handles );
1488
1489     EnterCriticalSection( &msi_custom_action_cs );
1490     LIST_FOR_EACH_ENTRY_SAFE( info, cursor, &msi_pending_custom_actions, msi_custom_action_info, entry )
1491     {
1492         if (info->package == package) release_custom_action_data( info );
1493     }
1494     LeaveCriticalSection( &msi_custom_action_cs );
1495 }
1496
1497 UINT __cdecl s_remote_GetActionInfo(const GUID *guid, int *type, LPWSTR *dll, LPSTR *func, MSIHANDLE *hinst)
1498 {
1499     msi_custom_action_info *info;
1500
1501     info = find_action_by_guid(guid);
1502     if (!info)
1503         return ERROR_INVALID_DATA;
1504
1505     *type = info->type;
1506     *hinst = alloc_msihandle(&info->package->hdr);
1507     *dll = strdupW(info->source);
1508     *func = strdupWtoA(info->target);
1509
1510     release_custom_action_data(info);
1511     return ERROR_SUCCESS;
1512 }