ntdll/tests: Fix exception test for CPUs that do segment limit checks differently.
[wine] / 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 #define COBJMACROS
22
23 #include <stdarg.h>
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winerror.h"
27 #include "msidefs.h"
28 #include "msipriv.h"
29 #include "winuser.h"
30 #include "wine/debug.h"
31 #include "wine/unicode.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(msi);
34
35 #define CUSTOM_ACTION_TYPE_MASK 0x3F
36 static const WCHAR c_collen[] = {'C',':','\\',0};
37 static const WCHAR cszTempFolder[]= {'T','e','m','p','F','o','l','d','e','r',0};
38
39 typedef struct tagMSIRUNNINGACTION
40 {
41     struct list entry;
42     HANDLE handle;
43     BOOL   process;
44     LPWSTR name;
45 } MSIRUNNINGACTION;
46
47 static UINT HANDLE_CustomType1(MSIPACKAGE *package, LPCWSTR source,
48                                LPCWSTR target, const INT type, LPCWSTR action);
49 static UINT HANDLE_CustomType2(MSIPACKAGE *package, LPCWSTR source,
50                                LPCWSTR target, const INT type, LPCWSTR action);
51 static UINT HANDLE_CustomType17(MSIPACKAGE *package, LPCWSTR source,
52                                 LPCWSTR target, const INT type, LPCWSTR action);
53 static UINT HANDLE_CustomType18(MSIPACKAGE *package, LPCWSTR source,
54                                 LPCWSTR target, const INT type, LPCWSTR action);
55 static UINT HANDLE_CustomType19(MSIPACKAGE *package, LPCWSTR source,
56                                 LPCWSTR target, const INT type, LPCWSTR action);
57 static UINT HANDLE_CustomType50(MSIPACKAGE *package, LPCWSTR source,
58                                 LPCWSTR target, const INT type, LPCWSTR action);
59 static UINT HANDLE_CustomType34(MSIPACKAGE *package, LPCWSTR source,
60                                 LPCWSTR target, const INT type, LPCWSTR action);
61
62
63 static BOOL check_execution_scheduling_options(MSIPACKAGE *package, LPCWSTR action, UINT options)
64 {
65     if (!package->script)
66         return TRUE;
67
68     if ((options & msidbCustomActionTypeClientRepeat) == 
69             msidbCustomActionTypeClientRepeat)
70     {
71         if (!(package->script->InWhatSequence & SEQUENCE_UI &&
72             package->script->InWhatSequence & SEQUENCE_EXEC))
73         {
74             TRACE("Skipping action due to dbCustomActionTypeClientRepeat option.\n");
75             return FALSE;
76         }
77     }
78     else if (options & msidbCustomActionTypeFirstSequence)
79     {
80         if (package->script->InWhatSequence & SEQUENCE_UI &&
81             package->script->InWhatSequence & SEQUENCE_EXEC )
82         {
83             TRACE("Skipping action due to msidbCustomActionTypeFirstSequence option.\n");
84             return FALSE;
85         }
86     }
87     else if (options & msidbCustomActionTypeOncePerProcess)
88     {
89         if (check_unique_action(package,action))
90         {
91             TRACE("Skipping action due to msidbCustomActionTypeOncePerProcess option.\n");
92             return FALSE;
93         }
94         else
95             register_unique_action(package,action);
96     }
97
98     return TRUE;
99 }
100
101 /* stores the CustomActionData before the action:
102  *     [CustomActionData]Action
103  */
104 static LPWSTR msi_get_deferred_action(LPCWSTR action, LPWSTR actiondata)
105 {
106     LPWSTR deferred;
107     DWORD len;
108
109     static const WCHAR begin[] = {'[',0};
110     static const WCHAR end[] = {']',0};
111
112     if (!actiondata)
113         return strdupW(action);
114
115     len = lstrlenW(action) + lstrlenW(actiondata) + 3;
116     deferred = msi_alloc(len * sizeof(WCHAR));
117
118     lstrcpyW(deferred, begin);
119     lstrcatW(deferred, actiondata);
120     lstrcatW(deferred, end);
121     lstrcatW(deferred, action);
122
123     return deferred;
124 }
125
126 UINT ACTION_CustomAction(MSIPACKAGE *package,LPCWSTR action, BOOL execute)
127 {
128     UINT rc = ERROR_SUCCESS;
129     MSIRECORD * row = 0;
130     static const WCHAR ExecSeqQuery[] =
131     {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
132      '`','C','u','s','t','o' ,'m','A','c','t','i','o','n','`',
133      ' ','W','H','E','R','E',' ','`','A','c','t','i' ,'o','n','`',' ',
134      '=',' ','\'','%','s','\'',0};
135     UINT type;
136     LPCWSTR source, target;
137     LPWSTR ptr, deferred_data = NULL;
138     LPWSTR action_copy = strdupW(action);
139     WCHAR *deformated=NULL;
140
141     /* deferred action: [CustomActionData]Action */
142     if ((ptr = strchrW(action_copy, ']')))
143     {
144         deferred_data = action_copy + 1;
145         *ptr = '\0';
146         action = ptr + 1;
147     }
148
149     row = MSI_QueryGetRecord( package->db, ExecSeqQuery, action );
150     if (!row)
151     {
152         msi_free(action_copy);
153         return ERROR_CALL_NOT_IMPLEMENTED;
154     }
155
156     type = MSI_RecordGetInteger(row,2);
157
158     source = MSI_RecordGetString(row,3);
159     target = MSI_RecordGetString(row,4);
160
161     TRACE("Handling custom action %s (%x %s %s)\n",debugstr_w(action),type,
162           debugstr_w(source), debugstr_w(target));
163
164     /* handle some of the deferred actions */
165     if (type & msidbCustomActionTypeTSAware)
166         FIXME("msidbCustomActionTypeTSAware not handled\n");
167
168     if (type & msidbCustomActionTypeInScript)
169     {
170         if (type & msidbCustomActionTypeNoImpersonate)
171             FIXME("msidbCustomActionTypeNoImpersonate not handled\n");
172
173         if (type & msidbCustomActionTypeRollback)
174         {
175             FIXME("Rollback only action... rollbacks not supported yet\n");
176             schedule_action(package, ROLLBACK_SCRIPT, action);
177             rc = ERROR_SUCCESS;
178             goto end;
179         }
180         if (!execute)
181         {
182             LPWSTR actiondata = msi_dup_property(package, action);
183             LPWSTR deferred = msi_get_deferred_action(action, actiondata);
184
185             if (type & msidbCustomActionTypeCommit)
186             {
187                 TRACE("Deferring Commit Action!\n");
188                 schedule_action(package, COMMIT_SCRIPT, deferred);
189             }
190             else
191             {
192                 TRACE("Deferring Action!\n");
193                 schedule_action(package, INSTALL_SCRIPT, deferred);
194             }
195
196             rc = ERROR_SUCCESS;
197             msi_free(deferred);
198             goto end;
199         }
200         else
201         {
202             /*Set ActionData*/
203
204             static const WCHAR szActionData[] = {
205             'C','u','s','t','o','m','A','c','t','i','o','n','D','a','t','a',0};
206             static const WCHAR szBlank[] = {0};
207             LPWSTR actiondata = msi_dup_property( package, action );
208             if (deferred_data)
209                 MSI_SetPropertyW(package,szActionData,deferred_data);
210             else if (actiondata)
211                 MSI_SetPropertyW(package,szActionData,actiondata);
212             else
213                 MSI_SetPropertyW(package,szActionData,szBlank);
214             msi_free(actiondata);
215         }
216     }
217     else if (!check_execution_scheduling_options(package,action,type))
218     {
219         rc = ERROR_SUCCESS;
220         goto end;
221     }
222
223     switch (type & CUSTOM_ACTION_TYPE_MASK)
224     {
225         case 1: /* DLL file stored in a Binary table stream */
226             rc = HANDLE_CustomType1(package,source,target,type,action);
227             break;
228         case 2: /* EXE file stored in a Binary table stream */
229             rc = HANDLE_CustomType2(package,source,target,type,action);
230             break;
231         case 18: /*EXE file installed with package */
232             rc = HANDLE_CustomType18(package,source,target,type,action);
233             break;
234         case 19: /* Error that halts install */
235             rc = HANDLE_CustomType19(package,source,target,type,action);
236             break;
237         case 17:
238             rc = HANDLE_CustomType17(package,source,target,type,action);
239             break;
240         case 50: /*EXE file specified by a property value */
241             rc = HANDLE_CustomType50(package,source,target,type,action);
242             break;
243         case 34: /*EXE to be run in specified directory */
244             rc = HANDLE_CustomType34(package,source,target,type,action);
245             break;
246         case 35: /* Directory set with formatted text. */
247             deformat_string(package,target,&deformated);
248             MSI_SetTargetPathW(package, source, deformated);
249             msi_free(deformated);
250             break;
251         case 51: /* Property set with formatted text. */
252             deformat_string(package,target,&deformated);
253             rc = MSI_SetPropertyW(package,source,deformated);
254             msi_free(deformated);
255             break;
256         default:
257             FIXME("UNHANDLED ACTION TYPE %i (%s %s)\n",
258              type & CUSTOM_ACTION_TYPE_MASK, debugstr_w(source),
259              debugstr_w(target));
260     }
261
262 end:
263     msi_free(action_copy);
264     msiobj_release(&row->hdr);
265     return rc;
266 }
267
268
269 static UINT store_binary_to_temp(MSIPACKAGE *package, LPCWSTR source,
270                                 LPWSTR tmp_file)
271 {
272     static const WCHAR query[] = {
273         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
274         '`','B','i' ,'n','a','r','y','`',' ','W','H','E','R','E',' ',
275         '`','N','a','m','e','`',' ','=',' ','\'','%','s','\'',0};
276     MSIRECORD *row = 0;
277     HANDLE file;
278     CHAR buffer[1024];
279     static const WCHAR f1[] = {'m','s','i',0};
280     WCHAR fmt[MAX_PATH];
281     DWORD sz = MAX_PATH;
282     UINT r;
283
284     if (MSI_GetPropertyW(package, cszTempFolder, fmt, &sz) != ERROR_SUCCESS)
285         GetTempPathW(MAX_PATH, fmt);
286
287     if (GetTempFileNameW(fmt, f1, 0, tmp_file) == 0)
288     {
289         TRACE("Unable to create file\n");
290         return ERROR_FUNCTION_FAILED;
291     }
292     track_tempfile(package, tmp_file);
293
294     row = MSI_QueryGetRecord(package->db, query, source);
295     if (!row)
296         return ERROR_FUNCTION_FAILED;
297
298     /* write out the file */
299     file = CreateFileW(tmp_file, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
300                        FILE_ATTRIBUTE_NORMAL, NULL);
301     if (file == INVALID_HANDLE_VALUE)
302         r = ERROR_FUNCTION_FAILED;
303     else
304     {
305         do
306         {
307             DWORD write;
308             sz = sizeof buffer;
309             r = MSI_RecordReadStream(row, 2, buffer, &sz);
310             if (r != ERROR_SUCCESS)
311             {
312                 ERR("Failed to get stream\n");
313                 break;
314             }
315             WriteFile(file, buffer, sz, &write, NULL);
316         } while (sz == sizeof buffer);
317         CloseHandle(file);
318     }
319
320     msiobj_release(&row->hdr);
321
322     return r;
323 }
324
325 static void file_running_action(MSIPACKAGE* package, HANDLE Handle, 
326                                 BOOL process, LPCWSTR name)
327 {
328     MSIRUNNINGACTION *action;
329
330     action = msi_alloc( sizeof(MSIRUNNINGACTION) );
331
332     action->handle = Handle;
333     action->process = process;
334     action->name = strdupW(name);
335
336     list_add_tail( &package->RunningActions, &action->entry );
337 }
338
339 static UINT custom_get_process_return( HANDLE process )
340 {
341     DWORD rc = 0;
342
343     GetExitCodeProcess( process, &rc );
344     if (rc != 0)
345         return ERROR_FUNCTION_FAILED;
346     return ERROR_SUCCESS;
347 }
348
349 static UINT custom_get_thread_return( HANDLE thread )
350 {
351     DWORD rc = 0;
352
353     GetExitCodeThread( thread, &rc );
354
355     switch (rc)
356     {
357     case ERROR_FUNCTION_NOT_CALLED:
358     case ERROR_SUCCESS:
359     case ERROR_INSTALL_USEREXIT:
360     case ERROR_INSTALL_FAILURE:
361         return rc;
362     case ERROR_NO_MORE_ITEMS:
363         return ERROR_SUCCESS;
364     default:
365         ERR("Invalid Return Code %d\n",rc);
366         return ERROR_INSTALL_FAILURE;
367     }
368 }
369
370 static UINT process_handle(MSIPACKAGE* package, UINT type,
371                            HANDLE ThreadHandle, HANDLE ProcessHandle,
372                            LPCWSTR Name)
373 {
374     UINT rc = ERROR_SUCCESS;
375
376     if (!(type & msidbCustomActionTypeAsync))
377     {
378         /* synchronous */
379         TRACE("Synchronous Execution of action %s\n",debugstr_w(Name));
380         if (ProcessHandle)
381             msi_dialog_check_messages(ProcessHandle);
382         else
383             msi_dialog_check_messages(ThreadHandle);
384
385         if (!(type & msidbCustomActionTypeContinue))
386         {
387             if (ProcessHandle)
388                 rc = custom_get_process_return(ProcessHandle);
389             else
390                 rc = custom_get_thread_return(ThreadHandle);
391         }
392
393         CloseHandle(ThreadHandle);
394         if (ProcessHandle)
395             CloseHandle(ProcessHandle);
396     }
397     else
398     {
399         TRACE("Asynchronous Execution of action %s\n",debugstr_w(Name));
400         /* asynchronous */
401         if (!(type & msidbCustomActionTypeContinue))
402         {
403             if (ProcessHandle)
404             {
405                 file_running_action(package, ProcessHandle, TRUE, Name);
406                 CloseHandle(ThreadHandle);
407             }
408             else
409                 file_running_action(package, ThreadHandle, FALSE, Name);
410         }
411         else
412         {
413             CloseHandle(ThreadHandle);
414             if (ProcessHandle)
415                 CloseHandle(ProcessHandle);
416         }
417     }
418
419     return rc;
420 }
421
422
423 typedef UINT __stdcall CustomEntry(MSIHANDLE);
424
425 typedef struct 
426 {
427         MSIPACKAGE *package;
428         WCHAR *target;
429         WCHAR *source;
430 } thread_struct;
431
432 static DWORD WINAPI ACTION_CallDllFunction(thread_struct *stuff)
433 {
434     HANDLE hModule;
435     LPSTR proc;
436     CustomEntry *fn;
437     DWORD rc = ERROR_SUCCESS;
438
439     TRACE("calling function (%s, %s)\n", debugstr_w(stuff->source),
440           debugstr_w(stuff->target));
441
442     hModule = LoadLibraryW(stuff->source);
443     if (hModule)
444     {
445         proc = strdupWtoA( stuff->target );
446         fn = (CustomEntry*)GetProcAddress(hModule,proc);
447         if (fn)
448         {
449             MSIHANDLE hPackage;
450             MSIPACKAGE *package = stuff->package;
451
452             TRACE("Calling function %s\n", proc);
453             hPackage = alloc_msihandle( &package->hdr );
454             if (hPackage)
455             {
456                 rc = fn( hPackage );
457                 MsiCloseHandle( hPackage );
458             }
459             else
460                 ERR("Handle for object %p not found\n", package );
461         }
462         else
463             ERR("failed to resolve functon %s\n", debugstr_a(proc));
464
465         msi_free(proc);
466         FreeLibrary(hModule);
467     }
468     else
469         ERR("failed to load dll %s\n", debugstr_w(stuff->source));
470     msiobj_release( &stuff->package->hdr );
471     msi_free(stuff->source);
472     msi_free(stuff->target);
473     msi_free(stuff);
474     return rc;
475 }
476
477 static DWORD WINAPI DllThread(LPVOID info)
478 {
479     thread_struct *stuff;
480     DWORD rc = 0;
481
482     TRACE("MSI Thread (%x) started for custom action\n", GetCurrentThreadId());
483
484     stuff = (thread_struct*)info;
485     rc = ACTION_CallDllFunction(stuff);
486
487     TRACE("MSI Thread (%x) finished (rc %i)\n",GetCurrentThreadId(), rc);
488     /* close all handles for this thread */
489     MsiCloseAllHandles();
490     return rc;
491 }
492
493 static HANDLE do_msidbCustomActionTypeDll(MSIPACKAGE *package, LPCWSTR dll, LPCWSTR target)
494 {
495     thread_struct *info;
496
497     info = msi_alloc( sizeof(*info) );
498     msiobj_addref( &package->hdr );
499     info->package = package;
500     info->target = strdupW(target);
501     info->source = strdupW(dll);
502
503     return CreateThread(NULL, 0, DllThread, info, 0, NULL);
504 }
505
506 static UINT HANDLE_CustomType1(MSIPACKAGE *package, LPCWSTR source, 
507                                LPCWSTR target, const INT type, LPCWSTR action)
508 {
509     WCHAR tmp_file[MAX_PATH];
510     UINT r = ERROR_SUCCESS;
511     HANDLE ThreadHandle;
512
513     r = store_binary_to_temp(package, source, tmp_file);
514     if (r != ERROR_SUCCESS)
515         return r;
516
517     TRACE("Calling function %s from %s\n",debugstr_w(target),
518           debugstr_w(tmp_file));
519
520     if (!strchrW(tmp_file,'.'))
521     {
522         static const WCHAR dot[]={'.',0};
523         strcatW(tmp_file,dot);
524     }
525
526     ThreadHandle = do_msidbCustomActionTypeDll( package, tmp_file, target );
527
528     r = process_handle(package, type, ThreadHandle, NULL, action);
529
530     return r;
531 }
532
533 static UINT HANDLE_CustomType2(MSIPACKAGE *package, LPCWSTR source, 
534                                LPCWSTR target, const INT type, LPCWSTR action)
535 {
536     WCHAR tmp_file[MAX_PATH];
537     STARTUPINFOW si;
538     PROCESS_INFORMATION info;
539     BOOL rc;
540     INT len;
541     WCHAR *deformated = NULL;
542     WCHAR *cmd;
543     static const WCHAR spc[] = {' ',0};
544     UINT r = ERROR_SUCCESS;
545
546     memset(&si,0,sizeof(STARTUPINFOW));
547
548     r = store_binary_to_temp(package, source, tmp_file);
549     if (r != ERROR_SUCCESS)
550         return r;
551
552     deformat_string(package,target,&deformated);
553
554     len = strlenW(tmp_file)+2;
555
556     if (deformated)
557         len += strlenW(deformated);
558
559     cmd = msi_alloc(sizeof(WCHAR)*len);
560
561     strcpyW(cmd,tmp_file);
562     if (deformated)
563     {
564         strcatW(cmd,spc);
565         strcatW(cmd,deformated);
566
567         msi_free(deformated);
568     }
569
570     TRACE("executing exe %s\n", debugstr_w(cmd));
571
572     rc = CreateProcessW(NULL, cmd, NULL, NULL, FALSE, 0, NULL,
573                   c_collen, &si, &info);
574     msi_free(cmd);
575
576     if ( !rc )
577     {
578         ERR("Unable to execute command %s\n", debugstr_w(cmd));
579         return ERROR_SUCCESS;
580     }
581
582     r = process_handle(package, type, info.hThread, info.hProcess, action);
583
584     return r;
585 }
586
587 static UINT HANDLE_CustomType17(MSIPACKAGE *package, LPCWSTR source,
588                                 LPCWSTR target, const INT type, LPCWSTR action)
589 {
590     HANDLE hThread;
591     MSIFILE *file;
592
593     TRACE("%s %s\n", debugstr_w(source), debugstr_w(target));
594
595     file = get_loaded_file( package, source );
596     if (!file)
597     {
598         ERR("invalid file key %s\n", debugstr_w( source ));
599         return ERROR_FUNCTION_FAILED;
600     }
601
602     hThread = do_msidbCustomActionTypeDll( package, file->TargetPath, target );
603
604     return process_handle(package, type, hThread, NULL, action);
605 }
606
607 static UINT HANDLE_CustomType18(MSIPACKAGE *package, LPCWSTR source,
608                                 LPCWSTR target, const INT type, LPCWSTR action)
609 {
610     STARTUPINFOW si;
611     PROCESS_INFORMATION info;
612     BOOL rc;
613     WCHAR *deformated;
614     WCHAR *cmd;
615     INT len;
616     static const WCHAR spc[] = {' ',0};
617     MSIFILE *file;
618     UINT prc;
619
620     memset(&si,0,sizeof(STARTUPINFOW));
621
622     file = get_loaded_file(package,source);
623     if( !file )
624         return ERROR_FUNCTION_FAILED;
625
626     len = lstrlenW( file->TargetPath );
627
628     deformat_string(package,target,&deformated);
629     if (deformated)
630         len += strlenW(deformated);
631     len += 2;
632
633     cmd = msi_alloc(len * sizeof(WCHAR));
634
635     lstrcpyW( cmd, file->TargetPath);
636     if (deformated)
637     {
638         strcatW(cmd, spc);
639         strcatW(cmd, deformated);
640
641         msi_free(deformated);
642     }
643
644     TRACE("executing exe %s\n", debugstr_w(cmd));
645
646     rc = CreateProcessW(NULL, cmd, NULL, NULL, FALSE, 0, NULL,
647                   c_collen, &si, &info);
648
649     
650     if ( !rc )
651     {
652         ERR("Unable to execute command %s\n", debugstr_w(cmd));
653         msi_free(cmd);
654         return ERROR_SUCCESS;
655     }
656     msi_free(cmd);
657
658     prc = process_handle(package, type, info.hThread, info.hProcess, action);
659
660     return prc;
661 }
662
663 static UINT HANDLE_CustomType19(MSIPACKAGE *package, LPCWSTR source,
664                                 LPCWSTR target, const INT type, LPCWSTR action)
665 {
666     static const WCHAR query[] = {
667       'S','E','L','E','C','T',' ','`','M','e','s','s','a','g','e','`',' ',
668       'F','R','O','M',' ','`','E','r','r','o','r','`',' ',
669       'W','H','E','R','E',' ','`','E','r','r','o','r','`',' ','=',' ',
670       '%','s',0
671     };
672     MSIRECORD *row = 0;
673     LPWSTR deformated = NULL;
674
675     deformat_string( package, target, &deformated );
676
677     /* first try treat the error as a number */
678     row = MSI_QueryGetRecord( package->db, query, deformated );
679     if( row )
680     {
681         LPCWSTR error = MSI_RecordGetString( row, 1 );
682         MessageBoxW( NULL, error, NULL, MB_OK );
683         msiobj_release( &row->hdr );
684     }
685     else
686         MessageBoxW( NULL, deformated, NULL, MB_OK );
687
688     msi_free( deformated );
689
690     return ERROR_FUNCTION_FAILED;
691 }
692
693 static UINT HANDLE_CustomType50(MSIPACKAGE *package, LPCWSTR source,
694                                 LPCWSTR target, const INT type, LPCWSTR action)
695 {
696     STARTUPINFOW si;
697     PROCESS_INFORMATION info;
698     WCHAR *prop;
699     BOOL rc;
700     WCHAR *deformated;
701     WCHAR *cmd;
702     INT len;
703     static const WCHAR spc[] = {' ',0};
704
705     memset(&si,0,sizeof(STARTUPINFOW));
706     memset(&info,0,sizeof(PROCESS_INFORMATION));
707
708     prop = msi_dup_property( package, source );
709     if (!prop)
710         return ERROR_SUCCESS;
711
712     deformat_string(package,target,&deformated);
713     len = strlenW(prop) + 2;
714     if (deformated)
715          len += strlenW(deformated);
716
717     cmd = msi_alloc(sizeof(WCHAR)*len);
718
719     strcpyW(cmd,prop);
720     if (deformated)
721     {
722         strcatW(cmd,spc);
723         strcatW(cmd,deformated);
724
725         msi_free(deformated);
726     }
727     msi_free(prop);
728
729     TRACE("executing exe %s\n", debugstr_w(cmd));
730
731     rc = CreateProcessW(NULL, cmd, NULL, NULL, FALSE, 0, NULL,
732                   c_collen, &si, &info);
733
734     
735     if ( !rc )
736     {
737         ERR("Unable to execute command %s\n", debugstr_w(cmd));
738         msi_free(cmd);
739         return ERROR_SUCCESS;
740     }
741     msi_free(cmd);
742
743     return process_handle(package, type, info.hThread, info.hProcess, action);
744 }
745
746 static UINT HANDLE_CustomType34(MSIPACKAGE *package, LPCWSTR source,
747                                 LPCWSTR target, const INT type, LPCWSTR action)
748 {
749     LPWSTR filename, deformated;
750     STARTUPINFOW si;
751     PROCESS_INFORMATION info;
752     BOOL rc;
753     UINT prc;
754
755     memset(&si,0,sizeof(STARTUPINFOW));
756
757     filename = resolve_folder(package, source, FALSE, FALSE, NULL);
758
759     if (!filename)
760         return ERROR_FUNCTION_FAILED;
761
762     SetCurrentDirectoryW(filename);
763     msi_free(filename);
764
765     deformat_string(package,target,&deformated);
766
767     if (!deformated)
768         return ERROR_FUNCTION_FAILED;
769
770     TRACE("executing exe %s\n", debugstr_w(deformated));
771
772     rc = CreateProcessW(NULL, deformated, NULL, NULL, FALSE, 0, NULL,
773                   c_collen, &si, &info);
774
775     if ( !rc )
776     {
777         ERR("Unable to execute command %s\n", debugstr_w(deformated));
778         msi_free(deformated);
779         return ERROR_SUCCESS;
780     }
781     msi_free(deformated);
782
783     prc = process_handle(package, type, info.hThread, info.hProcess, action);
784
785     return prc;
786 }
787
788
789 void ACTION_FinishCustomActions(MSIPACKAGE* package)
790 {
791     struct list *item, *cursor;
792     DWORD rc;
793
794     LIST_FOR_EACH_SAFE( item, cursor, &package->RunningActions )
795     {
796         MSIRUNNINGACTION *action = LIST_ENTRY( item, MSIRUNNINGACTION, entry );
797
798         TRACE("Checking on action %s\n", debugstr_w(action->name));
799
800         list_remove( &action->entry );
801
802         if (action->process)
803             GetExitCodeProcess( action->handle, &rc );
804         else
805             GetExitCodeThread( action->handle, &rc );
806
807         if (rc == STILL_ACTIVE)
808         {
809             TRACE("Waiting on action %s\n", debugstr_w( action->name) );
810             msi_dialog_check_messages( action->handle );
811         }
812
813         CloseHandle( action->handle );
814         msi_free( action->name );
815         msi_free( action );
816     }
817 }