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