ReactOS 0.4.15-dev-8100-g1887773
custom.c
Go to the documentation of this file.
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 <stdio.h>
25
26#include "ntstatus.h"
27#define WIN32_NO_STATUS
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_s.h"
38#include "wine/asm.h"
39#include "wine/debug.h"
40#include "wine/unicode.h"
41#include "wine/exception.h"
42
43#ifdef __REACTOS__
44#undef WIN32_NO_STATUS
45#include <psdk/ntstatus.h>
46#include <ndk/mmfuncs.h>
47#endif
48
50
51#define CUSTOM_ACTION_TYPE_MASK 0x3F
52
53typedef struct tagMSIRUNNINGACTION
54{
55 struct list entry;
60
62
65{
69 0, 0, { (DWORD_PTR)(__FILE__ ": msi_custom_action_cs") }
70};
72
74
76{
77 return malloc(len);
78}
79
81{
82 free(ptr);
83}
84
86{
88}
89
91{
92 UINT count;
93 WCHAR **newbuf = NULL;
94
95 if (script >= SCRIPT_MAX)
96 {
97 FIXME("Unknown script requested %u\n", script);
99 }
100 TRACE("Scheduling action %s in script %u\n", debugstr_w(action), script);
101
103 package->script_actions_count[script]++;
104 if (count != 0) newbuf = msi_realloc( package->script_actions[script],
105 package->script_actions_count[script] * sizeof(WCHAR *) );
106 else newbuf = msi_alloc( sizeof(WCHAR *) );
107
108 newbuf[count] = strdupW( action );
109 package->script_actions[script] = newbuf;
110 return ERROR_SUCCESS;
111}
112
114{
115 UINT count;
116 WCHAR **newbuf = NULL;
117
118 TRACE("Registering %s as unique action\n", debugstr_w(action));
119
120 count = package->unique_actions_count;
121 package->unique_actions_count++;
122 if (count != 0) newbuf = msi_realloc( package->unique_actions,
123 package->unique_actions_count * sizeof(WCHAR *) );
124 else newbuf = msi_alloc( sizeof(WCHAR *) );
125
126 newbuf[count] = strdupW( action );
127 package->unique_actions = newbuf;
128 return ERROR_SUCCESS;
129}
130
132{
133 UINT i;
134
135 for (i = 0; i < package->unique_actions_count; i++)
136 {
137 if (!wcscmp( package->unique_actions[i], action )) return TRUE;
138 }
139 return FALSE;
140}
141
143{
146 {
147 if (!(package->InWhatSequence & SEQUENCE_UI &&
148 package->InWhatSequence & SEQUENCE_EXEC))
149 {
150 TRACE("Skipping action due to dbCustomActionTypeClientRepeat option.\n");
151 return FALSE;
152 }
153 }
155 {
156 if (package->InWhatSequence & SEQUENCE_UI &&
157 package->InWhatSequence & SEQUENCE_EXEC )
158 {
159 TRACE("Skipping action due to msidbCustomActionTypeFirstSequence option.\n");
160 return FALSE;
161 }
162 }
164 {
165 if (msi_action_is_unique(package, action))
166 {
167 TRACE("Skipping action due to msidbCustomActionTypeOncePerProcess option.\n");
168 return FALSE;
169 }
170 else
172 }
173
174 return TRUE;
175}
176
177/* stores the following properties before the action:
178 *
179 * [CustomActionData<=>UserSID<=>ProductCode]Action
180 */
182 LPCWSTR usersid, LPCWSTR prodcode)
183{
184 LPWSTR deferred;
185 DWORD len;
186
187 if (!actiondata)
188 return strdupW(action);
189
190 len = lstrlenW(action) + lstrlenW(actiondata) +
191 lstrlenW(usersid) + lstrlenW(prodcode) +
192 lstrlenW(L"[%s<=>%s<=>%s]%s") - 7;
193 deferred = msi_alloc(len * sizeof(WCHAR));
194
195 swprintf(deferred, len, L"[%s<=>%s<=>%s]%s", actiondata, usersid, prodcode, action);
196 return deferred;
197}
198
199static void set_deferred_action_props( MSIPACKAGE *package, const WCHAR *deferred_data )
200{
201 const WCHAR *end, *beg = deferred_data + 1;
202
203 end = wcsstr(beg, L"<=>");
204 msi_set_property( package->db, L"CustomActionData", beg, end - beg );
205 beg = end + 3;
206
207 end = wcsstr(beg, L"<=>");
208 msi_set_property( package->db, L"UserSID", beg, end - beg );
209 beg = end + 3;
210
211 end = wcschr(beg, ']');
212 msi_set_property( package->db, L"ProductCode", beg, end - beg );
213}
214
216{
217 WCHAR *ret;
218
219 if (!db->tempfolder)
220 {
221 WCHAR tmp[MAX_PATH];
222 DWORD len = ARRAY_SIZE( tmp );
223
224 if (msi_get_property( db, L"TempFolder", tmp, &len ) ||
226 {
227 GetTempPathW( MAX_PATH, tmp );
228 }
229 if (!(db->tempfolder = strdupW( tmp ))) return NULL;
230 }
231
232 if ((ret = msi_alloc( (lstrlenW( db->tempfolder ) + 20) * sizeof(WCHAR) )))
233 {
234 if (!GetTempFileNameW( db->tempfolder, L"msi", 0, ret ))
235 {
236 msi_free( ret );
237 return NULL;
238 }
239 }
240
241 return ret;
242}
243
245{
246 MSIRECORD *row;
248 HANDLE file;
249 CHAR buffer[1024];
250 WCHAR *tmpfile;
251 DWORD sz, write;
252 UINT r;
253
254 if (!(tmpfile = msi_create_temp_file( package->db ))) return NULL;
255
256 if (!(row = MSI_QueryGetRecord( package->db, L"SELECT * FROM `Binary` WHERE `Name` = '%s'", source ))) goto error;
257 if (!(binary = msi_alloc_zero( sizeof(MSIBINARY) ))) goto error;
258
260 if (file == INVALID_HANDLE_VALUE) goto error;
261
262 do
263 {
264 sz = sizeof(buffer);
265 r = MSI_RecordReadStream( row, 2, buffer, &sz );
266 if (r != ERROR_SUCCESS)
267 {
268 ERR("Failed to get stream\n");
269 break;
270 }
271 WriteFile( file, buffer, sz, &write, NULL );
272 } while (sz == sizeof buffer);
273
274 CloseHandle( file );
275 if (r != ERROR_SUCCESS) goto error;
276
277 binary->source = strdupW( source );
278 binary->tmpfile = tmpfile;
279 list_add_tail( &package->binaries, &binary->entry );
280
281 msiobj_release( &row->hdr );
282 return binary;
283
284error:
285 if (row) msiobj_release( &row->hdr );
287 msi_free( tmpfile );
288 msi_free( binary );
289 return NULL;
290}
291
293{
295
297 {
298 if (!wcscmp( binary->source, source ))
299 return binary;
300 }
301
302 return create_temp_binary(package, source);
303}
304
307{
309
310 action = msi_alloc( sizeof(MSIRUNNINGACTION) );
311
312 action->handle = Handle;
313 action->process = process;
314 action->name = strdupW(name);
315
316 list_add_tail( &package->RunningActions, &action->entry );
317}
318
320{
321 DWORD rc = 0;
322
324 TRACE( "exit code is %lu\n", rc );
325 if (rc != 0)
327 return ERROR_SUCCESS;
328}
329
331{
332 DWORD rc = 0;
333
335
336 switch (rc)
337 {
339 case ERROR_SUCCESS:
342 return rc;
344 return ERROR_SUCCESS;
346 ACTION_ForceReboot( package );
347 return ERROR_SUCCESS;
348 default:
349 ERR( "invalid Return Code %lu\n", rc );
351 }
352}
353
356{
357 UINT rc = ERROR_SUCCESS;
358
360 {
361 TRACE("waiting for %s\n", debugstr_w(name));
362
364
367
369 }
370 else
371 {
372 TRACE("%s running in background\n", debugstr_w(name));
373
376 else
378 }
379
380 return rc;
381}
382
384 struct list entry;
394
396{
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
409}
410
412{
413 UINT rc = ERROR_SUCCESS;
414
415 if (!(info->type & msidbCustomActionTypeAsync))
416 {
417 TRACE("waiting for %s\n", debugstr_w( info->action ));
418
420
421 if (!(info->type & msidbCustomActionTypeContinue))
422 rc = custom_get_thread_return( info->package, info->handle );
423
425 }
426 else
427 {
428 TRACE("%s running in background\n", debugstr_w( info->action ));
429 }
430
431 return rc;
432}
433
435{
437 BOOL found = FALSE;
438
440
442 {
443 if (IsEqualGUID( &info->guid, guid ))
444 {
445 found = TRUE;
446 break;
447 }
448 }
449
451
452 if (!found)
453 return NULL;
454
455 return info;
456}
457
458static void handle_msi_break( const WCHAR *action )
459{
460 const WCHAR fmt[] = L"To debug your custom action, attach your debugger to process %u (0x%x) and press OK";
461 WCHAR val[MAX_PATH], msg[100];
462
463 if (!GetEnvironmentVariableW( L"MsiBreak", val, MAX_PATH ) || wcscmp( val, action )) return;
464
466 MessageBoxW( NULL, msg, L"Windows Installer", MB_OK );
467 DebugBreak();
468}
469
470#if defined __i386__ && defined _MSC_VER
472{
473 __asm
474 {
475 push ebp
476 mov ebp, esp
477 sub esp, 4
478 push [ebp+12]
479 call [ebp+8]
480 leave
481 ret
482 }
483}
484#elif defined __i386__ && defined __GNUC__
485/* wrapper for apps that don't declare the thread function correctly */
488 "pushl %ebp\n\t"
489 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
490 __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
491 "movl %esp,%ebp\n\t"
492 __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
493 "subl $4,%esp\n\t"
494 "pushl 12(%ebp)\n\t"
495 "call *8(%ebp)\n\t"
496 "leave\n\t"
497 __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
498 __ASM_CFI(".cfi_same_value %ebp\n\t")
499 "ret" )
500#else
502{
503 return entry(hinst);
504}
505#endif
506
508{
510 MSIHANDLE remote_package = 0;
511 RPC_WSTR binding_str;
512 MSIHANDLE hPackage;
514 WCHAR *dll = NULL, *action = NULL;
515 LPSTR proc = NULL;
517 INT type;
518 UINT r;
519
520 TRACE("%s\n", debugstr_guid( guid ));
521
522 if (!rpc_handle)
523 {
524 WCHAR endpoint[12];
525
527 status = RpcStringBindingComposeW(NULL, (WCHAR *)L"ncalrpc", NULL, endpoint, NULL, &binding_str);
528 if (status != RPC_S_OK)
529 {
530 ERR("RpcStringBindingCompose failed: %#lx\n", status);
531 return status;
532 }
533 status = RpcBindingFromStringBindingW(binding_str, &rpc_handle);
534 if (status != RPC_S_OK)
535 {
536 ERR("RpcBindingFromStringBinding failed: %#lx\n", status);
537 return status;
538 }
539 RpcStringFreeW(&binding_str);
540 }
541
542 r = remote_GetActionInfo(guid, &action, &type, &dll, &proc, &remote_package);
543 if (r != ERROR_SUCCESS)
544 return r;
545
546 hPackage = alloc_msi_remote_handle( remote_package );
547 if (!hPackage)
548 {
549 ERR( "failed to create handle for %#lx\n", remote_package );
554 }
555
557 if (!hModule)
558 {
559 ERR( "failed to load dll %s (%lu)\n", debugstr_w( dll ), GetLastError() );
563 MsiCloseHandle( hPackage );
564 return ERROR_SUCCESS;
565 }
566
568 if (!fn) WARN( "GetProcAddress(%s) failed\n", debugstr_a(proc) );
569 else
570 {
572
573 __TRY
574 {
575 r = custom_proc_wrapper( fn, hPackage );
576 }
578 {
579 ERR( "Custom action (%s:%s) caused a page fault: %#lx\n",
582 }
583 __ENDTRY;
584 }
585
587
591
593 return r;
594}
595
597{
599 TOKEN_LINKED_TOKEN linked;
600 DWORD size;
601
602#ifdef __REACTOS__
603#ifndef GetCurrentThreadEffectiveToken
604#define GetCurrentProcessToken() ((HANDLE)~(ULONG_PTR)3)
605#define GetCurrentThreadEffectiveToken() GetCurrentProcessToken()
606#endif
607#endif
608
611 return NULL;
612
614 return NULL;
615 return linked.LinkedToken;
616}
617
619{
622 STARTUPINFOW si = {0};
623 WCHAR buffer[24];
625 void *cookie;
626 HANDLE pipe;
627
628 if ((arch == SCS_32BIT_BINARY && package->custom_server_32_process) ||
629 (arch == SCS_64BIT_BINARY && package->custom_server_64_process))
630 return ERROR_SUCCESS;
631
632 swprintf(buffer, ARRAY_SIZE(buffer), L"\\\\.\\pipe\\msica_%x_%d",
633 GetCurrentProcessId(), arch == SCS_32BIT_BINARY ? 32 : 64);
634 pipe = CreateNamedPipeW(buffer, PIPE_ACCESS_DUPLEX, 0, 1, sizeof(DWORD64),
635 sizeof(GUID), 0, NULL);
636 if (pipe == INVALID_HANDLE_VALUE)
637 ERR("failed to create custom action client pipe: %lu\n", GetLastError());
638
639 if ((sizeof(void *) == 8 || is_wow64) && arch == SCS_32BIT_BINARY)
641 else
642 GetSystemDirectoryW(path, MAX_PATH - ARRAY_SIZE(L"\\msiexec.exe"));
643 lstrcatW(path, L"\\msiexec.exe");
644 swprintf(cmdline, ARRAY_SIZE(cmdline), L"%s -Embedding %d", path, GetCurrentProcessId());
645
647
648 if (is_wow64 && arch == SCS_64BIT_BINARY)
649 {
653 }
654 else
656
657 if (token) CloseHandle(token);
658
659 CloseHandle(pi.hThread);
660
661 if (arch == SCS_32BIT_BINARY)
662 {
663 package->custom_server_32_process = pi.hProcess;
664 package->custom_server_32_pipe = pipe;
665 }
666 else
667 {
668 package->custom_server_64_process = pi.hProcess;
669 package->custom_server_64_pipe = pipe;
670 }
671
672 if (!ConnectNamedPipe(pipe, NULL))
673 {
674 ERR("failed to connect to custom action server: %lu\n", GetLastError());
675 return GetLastError();
676 }
677
678 return ERROR_SUCCESS;
679}
680
682{
683 DWORD size;
684
685 WriteFile(pipe, &GUID_NULL, sizeof(GUID_NULL), &size, NULL);
688 CloseHandle(pipe);
689}
690
692{
694 DWORD64 thread64;
697 HANDLE pipe;
698 DWORD size;
699 DWORD rc;
700
701 CoInitializeEx(NULL, COINIT_MULTITHREADED); /* needed to marshal streams */
702
703 if (info->arch == SCS_32BIT_BINARY)
704 {
705 process = info->package->custom_server_32_process;
706 pipe = info->package->custom_server_32_pipe;
707 }
708 else
709 {
710 process = info->package->custom_server_64_process;
711 pipe = info->package->custom_server_64_pipe;
712 }
713
715
716 if (!WriteFile(pipe, &info->guid, sizeof(info->guid), &size, NULL) ||
717 size != sizeof(info->guid))
718 {
719 ERR("failed to write to custom action client pipe: %lu\n", GetLastError());
721 return GetLastError();
722 }
723 if (!ReadFile(pipe, &thread64, sizeof(thread64), &size, NULL) || size != sizeof(thread64))
724 {
725 ERR("failed to read from custom action client pipe: %lu\n", GetLastError());
727 return GetLastError();
728 }
729
731
734 {
738 }
739 else
740 rc = GetLastError();
741
743 return rc;
744}
745
746/* based on kernel32.GetBinaryTypeW() */
748{
749 HANDLE hfile, mapping;
751
753 if (hfile == INVALID_HANDLE_VALUE)
754 return FALSE;
755
757 SEC_IMAGE, hfile );
758 CloseHandle( hfile );
759
760 switch (status)
761 {
762 case STATUS_SUCCESS:
763 {
765
768 if (status) return FALSE;
769 switch (info.Machine)
770 {
774 return TRUE;
778 return TRUE;
779 default:
780 return FALSE;
781 }
782 }
785 return TRUE;
786 default:
787 return FALSE;
788 }
789}
790
793{
796 BOOL ret;
797
798 info = msi_alloc( sizeof *info );
799 if (!info)
800 return NULL;
801
802 msiobj_addref( &package->hdr );
803 info->package = package;
804 info->type = type;
805 info->target = strdupW( target );
806 info->source = strdupW( source );
807 info->action = strdupW( action );
808 CoCreateGuid( &info->guid );
809
813
814 if (!package->rpc_server_started)
815 {
816 WCHAR endpoint[12];
817
820 endpoint, NULL);
821 if (status != RPC_S_OK)
822 {
823 ERR("RpcServerUseProtseqEp failed: %#lx\n", status);
824 return NULL;
825 }
826
827 status = RpcServerRegisterIfEx(s_IWineMsiRemote_v0_0_s_ifspec, NULL, NULL,
829 if (status != RPC_S_OK)
830 {
831 ERR("RpcServerRegisterIfEx failed: %#lx\n", status);
832 return NULL;
833 }
834
835 info->package->rpc_server_started = 1;
836 }
837
838 ret = get_binary_type(source, &info->arch);
839 if (!ret)
840 info->arch = (sizeof(void *) == 8 ? SCS_64BIT_BINARY : SCS_32BIT_BINARY);
841
842 if (info->arch == SCS_64BIT_BINARY && sizeof(void *) == 4 && !is_wow64)
843 {
844 ERR("Attempt to run a 64-bit custom action inside a 32-bit WINEPREFIX.\n");
846 return NULL;
847 }
848
849 custom_start_server(package, info->arch);
850
852 if (!info->handle)
853 {
855 return NULL;
856 }
857
858 return info;
859}
860
861static UINT HANDLE_CustomType1( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
862 INT type, const WCHAR *action )
863{
866
867 if (!(binary = get_temp_binary(package, source)))
869
870 TRACE("Calling function %s from %s\n", debugstr_w(target), debugstr_w(binary->tmpfile));
871
872 if (!(info = do_msidbCustomActionTypeDll( package, type, binary->tmpfile, target, action )))
874 return wait_thread_handle( info );
875}
876
877static HANDLE execute_command( const WCHAR *app, WCHAR *arg, const WCHAR *dir )
878{
879 STARTUPINFOW si;
881 WCHAR *exe = NULL, *cmd = NULL, *p;
882 BOOL ret;
883
884 if (app)
885 {
886 int len_arg = 0;
887 DWORD len_exe;
888
889 if (!(exe = msi_alloc( MAX_PATH * sizeof(WCHAR) ))) return INVALID_HANDLE_VALUE;
890 len_exe = SearchPathW( NULL, app, L".exe", MAX_PATH, exe, NULL );
891 if (len_exe >= MAX_PATH)
892 {
893 msi_free( exe );
894 if (!(exe = msi_alloc( len_exe * sizeof(WCHAR) ))) return INVALID_HANDLE_VALUE;
895 len_exe = SearchPathW( NULL, app, L".exe", len_exe, exe, NULL );
896 }
897 if (!len_exe)
898 {
899 ERR("can't find executable %lu\n", GetLastError());
900 msi_free( exe );
902 }
903
904 if (arg) len_arg = lstrlenW( arg );
905 if (!(cmd = msi_alloc( (len_exe + len_arg + 4) * sizeof(WCHAR) )))
906 {
907 msi_free( exe );
909 }
910 p = cmd;
911 if (wcschr( exe, ' ' ))
912 {
913 *p++ = '\"';
914 memcpy( p, exe, len_exe * sizeof(WCHAR) );
915 p += len_exe;
916 *p++ = '\"';
917 *p = 0;
918 }
919 else
920 {
921 lstrcpyW( p, exe );
922 p += len_exe;
923 }
924 if (arg)
925 {
926 *p++ = ' ';
927 memcpy( p, arg, len_arg * sizeof(WCHAR) );
928 p[len_arg] = 0;
929 }
930 }
931 memset( &si, 0, sizeof(STARTUPINFOW) );
932 ret = CreateProcessW( exe, exe ? cmd : arg, NULL, NULL, FALSE, 0, NULL, dir, &si, &info );
933 msi_free( cmd );
934 msi_free( exe );
935 if (!ret)
936 {
937 ERR("unable to execute command %lu\n", GetLastError());
939 }
940 CloseHandle( info.hThread );
941 return info.hProcess;
942}
943
944static UINT HANDLE_CustomType2( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
945 INT type, const WCHAR *action )
946{
949 WCHAR *arg;
950
951 if (!(binary = get_temp_binary(package, source)))
953
954 deformat_string( package, target, &arg );
955 TRACE("exe %s arg %s\n", debugstr_w(binary->tmpfile), debugstr_w(arg));
956
957 handle = execute_command( binary->tmpfile, arg, L"C:\\" );
958 msi_free( arg );
960 return wait_process_handle( package, type, handle, action );
961}
962
963static UINT HANDLE_CustomType17( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
964 INT type, const WCHAR *action )
965{
967 MSIFILE *file;
968
969 TRACE("%s %s\n", debugstr_w(source), debugstr_w(target));
970
971 file = msi_get_loaded_file( package, source );
972 if (!file)
973 {
974 ERR("invalid file key %s\n", debugstr_w( source ));
976 }
977
978 if (!(info = do_msidbCustomActionTypeDll( package, type, file->TargetPath, target, action )))
980 return wait_thread_handle( info );
981}
982
983static UINT HANDLE_CustomType18( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
984 INT type, const WCHAR *action )
985{
986 MSIFILE *file;
988 WCHAR *arg;
989
990 if (!(file = msi_get_loaded_file( package, source ))) return ERROR_FUNCTION_FAILED;
991
992 deformat_string( package, target, &arg );
993 TRACE("exe %s arg %s\n", debugstr_w(file->TargetPath), debugstr_w(arg));
994
995 handle = execute_command( file->TargetPath, arg, L"C:\\" );
996 msi_free( arg );
998 return wait_process_handle( package, type, handle, action );
999}
1000
1001static UINT HANDLE_CustomType19( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
1002 INT type, const WCHAR *action )
1003{
1004 MSIRECORD *row = 0;
1005 LPWSTR deformated = NULL;
1006
1007 deformat_string( package, target, &deformated );
1008
1009 /* first try treat the error as a number */
1010 row = MSI_QueryGetRecord( package->db, L"SELECT `Message` FROM `Error` WHERE `Error` = '%s'", deformated );
1011 if( row )
1012 {
1016 msiobj_release( &row->hdr );
1017 }
1018 else if ((package->ui_level & INSTALLUILEVEL_MASK) != INSTALLUILEVEL_NONE)
1019 MessageBoxW( NULL, deformated, NULL, MB_OK );
1020
1021 msi_free( deformated );
1022
1023 return ERROR_INSTALL_FAILURE;
1024}
1025
1027{
1028 UINT len_filename = lstrlenW( filename ), len_params = lstrlenW( params );
1029 UINT len = ARRAY_SIZE(L"/qb /i ") - 1;
1030 WCHAR *ret;
1031
1032 if (!(ret = msi_alloc( (len + len_filename + len_params + 4) * sizeof(WCHAR) ))) return NULL;
1033 memcpy( ret, L"/qb /i ", sizeof(L"/qb /i ") );
1034 ret[len++] = '"';
1035 memcpy( ret + len, filename, len_filename * sizeof(WCHAR) );
1036 len += len_filename;
1037 ret[len++] = '"';
1038 ret[len++] = ' ';
1039 lstrcpyW( ret + len, params );
1040 return ret;
1041}
1042
1043static UINT HANDLE_CustomType23( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
1044 INT type, const WCHAR *action )
1045{
1046 WCHAR *dir, *filename, *args, *p;
1047 UINT len_dir, len_source = lstrlenW( source );
1048 HANDLE handle;
1049
1050 if (!(dir = msi_dup_property( package->db, L"OriginalDatabase" ))) return ERROR_OUTOFMEMORY;
1051 if (!(p = wcsrchr( dir, '\\' )) && !(p = wcsrchr( dir, '/' )))
1052 {
1053 msi_free( dir );
1054 return ERROR_FUNCTION_FAILED;
1055 }
1056 *p = 0;
1057 len_dir = p - dir;
1058 if (!(filename = msi_alloc( (len_dir + len_source + 2) * sizeof(WCHAR) )))
1059 {
1060 msi_free( dir );
1061 return ERROR_OUTOFMEMORY;
1062 }
1063 memcpy( filename, dir, len_dir * sizeof(WCHAR) );
1064 filename[len_dir++] = '\\';
1065 memcpy( filename + len_dir, source, len_source * sizeof(WCHAR) );
1066 filename[len_dir + len_source] = 0;
1067
1069 {
1070 msi_free( dir );
1071 return ERROR_OUTOFMEMORY;
1072 }
1073
1074 TRACE("installing %s concurrently\n", debugstr_w(source));
1075
1076 handle = execute_command( L"msiexec", args, dir );
1077 msi_free( dir );
1078 msi_free( args );
1080 return wait_process_handle( package, type, handle, action );
1081}
1082
1084{
1085 IStorage *src = NULL, *dst = NULL;
1087 HRESULT hr;
1088
1090 if (FAILED( hr ))
1091 {
1092 WARN( "can't open destination storage %s (%#lx)\n", debugstr_w(filename), hr );
1093 goto done;
1094 }
1095
1096 hr = IStorage_OpenStorage( package->db->storage, source, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &src );
1097 if (FAILED( hr ))
1098 {
1099 WARN( "can't open source storage %s (%#lx)\n", debugstr_w(source), hr );
1100 goto done;
1101 }
1102
1103 hr = IStorage_CopyTo( src, 0, NULL, NULL, dst );
1104 if (FAILED( hr ))
1105 {
1106 ERR( "failed to copy storage %s (%#lx)\n", debugstr_w(source), hr );
1107 goto done;
1108 }
1109
1110 hr = IStorage_Commit( dst, 0 );
1111 if (FAILED( hr ))
1112 ERR( "failed to commit storage (%#lx)\n", hr );
1113 else
1114 r = ERROR_SUCCESS;
1115
1116done:
1117 if (src) IStorage_Release( src );
1118 if (dst) IStorage_Release( dst );
1119 return r;
1120}
1121
1122static UINT HANDLE_CustomType7( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
1123 INT type, const WCHAR *action )
1124{
1125 WCHAR *tmpfile, *args;
1127 HANDLE handle;
1128 UINT r;
1129
1130 if (!(tmpfile = msi_create_temp_file( package->db ))) return ERROR_FUNCTION_FAILED;
1131
1133 if (r != ERROR_SUCCESS)
1134 goto error;
1135
1136 if (!(binary = msi_alloc( sizeof(*binary) ))) goto error;
1137 binary->source = NULL;
1138 binary->tmpfile = tmpfile;
1139 list_add_tail( &package->binaries, &binary->entry );
1140
1142
1143 TRACE("installing %s concurrently\n", debugstr_w(source));
1144
1145 handle = execute_command( L"msiexec", args, L"C:\\" );
1146 msi_free( args );
1148 return wait_process_handle( package, type, handle, action );
1149
1150error:
1152 msi_free( tmpfile );
1153 return ERROR_FUNCTION_FAILED;
1154}
1155
1156static UINT HANDLE_CustomType50( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
1157 INT type, const WCHAR *action )
1158{
1159 WCHAR *exe, *arg;
1160 HANDLE handle;
1161
1162 if (!(exe = msi_dup_property( package->db, source ))) return ERROR_SUCCESS;
1163
1164 deformat_string( package, target, &arg );
1165 TRACE("exe %s arg %s\n", debugstr_w(exe), debugstr_w(arg));
1166
1167 handle = execute_command( exe, arg, L"C:\\" );
1168 msi_free( exe );
1169 msi_free( arg );
1171 return wait_process_handle( package, type, handle, action );
1172}
1173
1174static UINT HANDLE_CustomType34( MSIPACKAGE *package, const WCHAR *source, const WCHAR *target,
1175 INT type, const WCHAR *action )
1176{
1177 const WCHAR *workingdir = NULL;
1178 HANDLE handle;
1179 WCHAR *cmd;
1180
1181 if (source)
1182 {
1183 workingdir = msi_get_target_folder( package, source );
1184 if (!workingdir) return ERROR_FUNCTION_FAILED;
1185 }
1186 deformat_string( package, target, &cmd );
1187 if (!cmd) return ERROR_FUNCTION_FAILED;
1188
1189 TRACE("cmd %s dir %s\n", debugstr_w(cmd), debugstr_w(workingdir));
1190
1191 handle = execute_command( NULL, cmd, workingdir );
1192 msi_free( cmd );
1194 return wait_process_handle( package, type, handle, action );
1195}
1196
1198{
1200 MSIHANDLE hPackage;
1202
1204 if (!info)
1205 {
1206 ERR("failed to find action %s\n", debugstr_guid( guid) );
1207 return ERROR_FUNCTION_FAILED;
1208 }
1209
1210 TRACE("function %s, script %s\n", debugstr_w( info->target ), debugstr_w( info->source ) );
1211
1212 hPackage = alloc_msihandle( &info->package->hdr );
1213 if (hPackage)
1214 {
1215 r = call_script( hPackage, info->type, info->source, info->target, info->action );
1216 TRACE("script returned %u\n", r);
1217 MsiCloseHandle( hPackage );
1218 }
1219 else
1220 ERR("failed to create handle for %p\n", info->package );
1221
1222 return r;
1223}
1224
1226{
1227 LPGUID guid = arg;
1228 DWORD rc;
1229
1230 TRACE("custom action (%#lx) started\n", GetCurrentThreadId() );
1231
1232 rc = ACTION_CallScript( guid );
1233
1234 TRACE("custom action (%#lx) returned %lu\n", GetCurrentThreadId(), rc );
1235
1237 return rc;
1238}
1239
1241 MSIPACKAGE *package, INT type, LPCWSTR script, LPCWSTR function, LPCWSTR action )
1242{
1244
1245 info = msi_alloc( sizeof *info );
1246 if (!info)
1247 return NULL;
1248
1249 msiobj_addref( &package->hdr );
1250 info->package = package;
1251 info->type = type;
1252 info->target = strdupW( function );
1253 info->source = strdupW( script );
1254 info->action = strdupW( action );
1255 CoCreateGuid( &info->guid );
1256
1260
1261 info->handle = CreateThread( NULL, 0, ScriptThread, &info->guid, 0, NULL );
1262 if (!info->handle)
1263 {
1265 return NULL;
1266 }
1267
1268 return info;
1269}
1270
1272 INT type, const WCHAR *action )
1273{
1275
1276 TRACE("%s %s\n", debugstr_w(source), debugstr_w(target));
1277
1279 return wait_thread_handle( info );
1280}
1281
1283 INT type, const WCHAR *action )
1284{
1285 MSIRECORD *row = NULL;
1287 CHAR *buffer = NULL;
1288 WCHAR *bufferw = NULL;
1289 DWORD sz = 0;
1290 UINT r;
1291
1292 TRACE("%s %s\n", debugstr_w(source), debugstr_w(target));
1293
1294 row = MSI_QueryGetRecord(package->db, L"SELECT * FROM `Binary` WHERE `Name` = '%s'", source);
1295 if (!row)
1296 return ERROR_FUNCTION_FAILED;
1297
1298 r = MSI_RecordReadStream(row, 2, NULL, &sz);
1299 if (r != ERROR_SUCCESS) goto done;
1300
1301 buffer = msi_alloc( sz + 1 );
1302 if (!buffer)
1303 {
1305 goto done;
1306 }
1307
1308 r = MSI_RecordReadStream(row, 2, buffer, &sz);
1309 if (r != ERROR_SUCCESS)
1310 goto done;
1311
1312 buffer[sz] = 0;
1313 bufferw = strdupAtoW(buffer);
1314 if (!bufferw)
1315 {
1317 goto done;
1318 }
1319
1320 info = do_msidbCustomActionTypeScript( package, type, bufferw, target, action );
1322
1323done:
1324 msi_free(bufferw);
1326 msiobj_release(&row->hdr);
1327 return r;
1328}
1329
1331 INT type, const WCHAR *action )
1332{
1334 MSIFILE *file;
1335 HANDLE hFile;
1336 DWORD sz, szHighWord = 0, read;
1337 CHAR *buffer=NULL;
1338 WCHAR *bufferw=NULL;
1339 BOOL bRet;
1340 UINT r;
1341
1342 TRACE("%s %s\n", debugstr_w(source), debugstr_w(target));
1343
1344 file = msi_get_loaded_file(package, source);
1345 if (!file)
1346 {
1347 ERR("invalid file key %s\n", debugstr_w(source));
1348 return ERROR_FUNCTION_FAILED;
1349 }
1350
1351 hFile = msi_create_file( package, file->TargetPath, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, 0 );
1353
1354 sz = GetFileSize(hFile, &szHighWord);
1355 if (sz == INVALID_FILE_SIZE || szHighWord != 0)
1356 {
1358 return ERROR_FUNCTION_FAILED;
1359 }
1360 buffer = msi_alloc( sz + 1 );
1361 if (!buffer)
1362 {
1364 return ERROR_FUNCTION_FAILED;
1365 }
1366 bRet = ReadFile(hFile, buffer, sz, &read, NULL);
1368 if (!bRet)
1369 {
1371 goto done;
1372 }
1373 buffer[read] = 0;
1374 bufferw = strdupAtoW(buffer);
1375 if (!bufferw)
1376 {
1378 goto done;
1379 }
1380 info = do_msidbCustomActionTypeScript( package, type, bufferw, target, action );
1382
1383done:
1384 msi_free(bufferw);
1386 return r;
1387}
1388
1390 INT type, const WCHAR *action )
1391{
1393 WCHAR *prop;
1394
1395 TRACE("%s %s\n", debugstr_w(source), debugstr_w(target));
1396
1397 prop = msi_dup_property( package->db, source );
1398 if (!prop) return ERROR_SUCCESS;
1399
1400 info = do_msidbCustomActionTypeScript( package, type, prop, NULL, action );
1401 msi_free(prop);
1402 return wait_thread_handle( info );
1403}
1404
1406{
1407 switch (script)
1408 {
1409 case SCRIPT_NONE:
1410 return FALSE;
1411 case SCRIPT_INSTALL:
1413 case SCRIPT_COMMIT:
1415 case SCRIPT_ROLLBACK:
1417 default:
1418 ERR("unhandled script %u\n", script);
1419 }
1420 return FALSE;
1421}
1422
1424{
1425 WCHAR *actiondata = msi_dup_property( package->db, action );
1426 WCHAR *usersid = msi_dup_property( package->db, L"UserSID" );
1427 WCHAR *prodcode = msi_dup_property( package->db, L"ProductCode" );
1428 WCHAR *deferred = msi_get_deferred_action( action, actiondata, usersid, prodcode );
1429
1430 if (!deferred)
1431 {
1432 msi_free( actiondata );
1433 msi_free( usersid );
1434 msi_free( prodcode );
1435 return ERROR_OUTOFMEMORY;
1436 }
1438 {
1439 TRACE("deferring commit action\n");
1440 msi_schedule_action( package, SCRIPT_COMMIT, deferred );
1441 }
1443 {
1444 TRACE("deferring rollback action\n");
1445 msi_schedule_action( package, SCRIPT_ROLLBACK, deferred );
1446 }
1447 else
1448 {
1449 TRACE("deferring install action\n");
1450 msi_schedule_action( package, SCRIPT_INSTALL, deferred );
1451 }
1452
1453 msi_free( actiondata );
1454 msi_free( usersid );
1455 msi_free( prodcode );
1456 msi_free( deferred );
1457 return ERROR_SUCCESS;
1458}
1459
1461{
1462 UINT rc = ERROR_SUCCESS;
1463 MSIRECORD *row;
1464 UINT type;
1465 const WCHAR *source, *target, *ptr, *deferred_data = NULL;
1466 WCHAR *deformated = NULL;
1467 int len;
1468
1469 /* deferred action: [properties]Action */
1470 if ((ptr = wcsrchr(action, ']')))
1471 {
1472 deferred_data = action;
1473 action = ptr + 1;
1474 }
1475
1476 row = MSI_QueryGetRecord( package->db, L"SELECT * FROM `CustomAction` WHERE `Action` = '%s'", action );
1477 if (!row)
1479
1483
1484 TRACE("Handling custom action %s (%x %s %s)\n",debugstr_w(action),type,
1486
1487 /* handle some of the deferred actions */
1489 FIXME("msidbCustomActionTypeTSAware not handled\n");
1490
1492 {
1494 WARN("msidbCustomActionTypeNoImpersonate not handled\n");
1495
1496 if (!action_type_matches_script(type, package->script))
1497 {
1498 rc = defer_custom_action( package, action, type );
1499 goto end;
1500 }
1501 else
1502 {
1503 LPWSTR actiondata = msi_dup_property( package->db, action );
1504
1506 package->scheduled_action_running = TRUE;
1507
1509 package->commit_action_running = TRUE;
1510
1512 package->rollback_action_running = TRUE;
1513
1514 if (deferred_data)
1515 set_deferred_action_props(package, deferred_data);
1516 else if (actiondata)
1517 msi_set_property( package->db, L"CustomActionData", actiondata, -1 );
1518 else
1519 msi_set_property( package->db, L"CustomActionData", L"", -1 );
1520
1521 msi_free(actiondata);
1522 }
1523 }
1525 {
1526 rc = ERROR_SUCCESS;
1527 goto end;
1528 }
1529
1530 switch (type & CUSTOM_ACTION_TYPE_MASK)
1531 {
1532 case 1: /* DLL file stored in a Binary table stream */
1533 rc = HANDLE_CustomType1( package, source, target, type, action );
1534 break;
1535 case 2: /* EXE file stored in a Binary table stream */
1536 rc = HANDLE_CustomType2( package, source, target, type, action );
1537 break;
1538 case 5:
1539 case 6: /* JScript/VBScript file stored in a Binary table stream */
1540 rc = HANDLE_CustomType5_6( package, source, target, type, action );
1541 break;
1542 case 7: /* Concurrent install from substorage */
1543 deformat_string( package, target, &deformated );
1544 rc = HANDLE_CustomType7( package, source, target, type, action );
1545 msi_free( deformated );
1546 break;
1547 case 17:
1548 rc = HANDLE_CustomType17( package, source, target, type, action );
1549 break;
1550 case 18: /* EXE file installed with package */
1551 rc = HANDLE_CustomType18( package, source, target, type, action );
1552 break;
1553 case 19: /* Error that halts install */
1554 rc = HANDLE_CustomType19( package, source, target, type, action );
1555 break;
1556 case 21: /* JScript/VBScript file installed with the product */
1557 case 22:
1558 rc = HANDLE_CustomType21_22( package, source, target, type, action );
1559 break;
1560 case 23: /* Installs another package in the source tree */
1561 deformat_string( package, target, &deformated );
1562 rc = HANDLE_CustomType23( package, source, deformated, type, action );
1563 msi_free( deformated );
1564 break;
1565 case 34: /* EXE to be run in specified directory */
1566 rc = HANDLE_CustomType34( package, source, target, type, action );
1567 break;
1568 case 35: /* Directory set with formatted text */
1569 deformat_string( package, target, &deformated );
1570 MSI_SetTargetPathW( package, source, deformated );
1571 msi_free( deformated );
1572 break;
1573 case 37: /* JScript/VBScript text stored in target column */
1574 case 38:
1575 rc = HANDLE_CustomType37_38( package, source, target, type, action );
1576 break;
1577 case 50: /* EXE file specified by a property value */
1578 rc = HANDLE_CustomType50( package, source, target, type, action );
1579 break;
1580 case 51: /* Property set with formatted text */
1581 if (!source) break;
1582 len = deformat_string( package, target, &deformated );
1583 rc = msi_set_property( package->db, source, deformated, len );
1584 if (rc == ERROR_SUCCESS && !wcscmp( source, L"SourceDir" )) msi_reset_source_folders( package );
1585 msi_free( deformated );
1586 break;
1587 case 53: /* JScript/VBScript text specified by a property value */
1588 case 54:
1589 rc = HANDLE_CustomType53_54( package, source, target, type, action );
1590 break;
1591 default:
1592 FIXME( "unhandled action type %u (%s %s)\n", type & CUSTOM_ACTION_TYPE_MASK, debugstr_w(source),
1593 debugstr_w(target) );
1594 }
1595
1596end:
1598 package->commit_action_running = FALSE;
1599 package->rollback_action_running = FALSE;
1600 msiobj_release(&row->hdr);
1601 return rc;
1602}
1603
1605{
1606 struct list *item;
1607 HANDLE *wait_handles;
1608 unsigned int handle_count, i;
1610
1611 while ((item = list_head( &package->RunningActions )))
1612 {
1614
1615 list_remove( &action->entry );
1616
1617 TRACE("waiting for %s\n", debugstr_w( action->name ) );
1619
1620 CloseHandle( action->handle );
1621 msi_free( action->name );
1622 msi_free( action );
1623 }
1624
1626
1627 handle_count = list_count( &msi_pending_custom_actions );
1628 wait_handles = msi_alloc( handle_count * sizeof(HANDLE) );
1629
1630 handle_count = 0;
1632 {
1633 if (info->package == package )
1634 {
1635 if (DuplicateHandle(GetCurrentProcess(), info->handle, GetCurrentProcess(), &wait_handles[handle_count], SYNCHRONIZE, FALSE, 0))
1636 handle_count++;
1637 }
1638 }
1639
1641
1642 for (i = 0; i < handle_count; i++)
1643 {
1644 msi_dialog_check_messages( wait_handles[i] );
1645 CloseHandle( wait_handles[i] );
1646 }
1647 msi_free( wait_handles );
1648
1651 {
1652 if (info->package == package)
1654 }
1656}
1657
1659{
1661
1663 if (!info)
1664 return ERROR_INVALID_DATA;
1665
1666 *name = strdupW(info->action);
1667 *type = info->type;
1668 *hinst = alloc_msihandle(&info->package->hdr);
1669 *dll = strdupW(info->source);
1670 *func = strdupWtoA(info->target);
1671
1672 return ERROR_SUCCESS;
1673}
NTSTATUS NTAPI NtCreateSection(OUT PHANDLE SectionHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN PLARGE_INTEGER MaximumSize OPTIONAL, IN ULONG SectionPageProtection OPTIONAL, IN ULONG AllocationAttributes, IN HANDLE FileHandle OPTIONAL)
Definition: section.c:3441
#define __cdecl
Definition: accygwin.h:79
#define read
Definition: acwin.h:96
#define write
Definition: acwin.h:97
unsigned int dir
Definition: maze.c:112
#define msg(x)
Definition: auth_time.c:54
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
static WCHAR * strdupW(const WCHAR *src)
Definition: main.c:92
LONG NTSTATUS
Definition: precomp.h:26
#define ARRAY_SIZE(A)
Definition: main.h:33
static void list_remove(struct list_entry *entry)
Definition: list.h:90
static void list_add_tail(struct list_entry *head, struct list_entry *entry)
Definition: list.h:83
static HANDLE thread
Definition: service.c:33
#define FIXME(fmt,...)
Definition: debug.h:114
#define WARN(fmt,...)
Definition: debug.h:115
#define ERR(fmt,...)
Definition: debug.h:113
#define leave
Definition: btrfs_drv.h:138
Definition: list.h:37
#define free
Definition: debug_ros.c:5
#define malloc
Definition: debug_ros.c:4
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessAsUserW(_In_opt_ HANDLE hToken, _In_opt_ LPCWSTR lpApplicationName, _Inout_opt_ LPWSTR lpCommandLine, _In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes, _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes, _In_ BOOL bInheritHandles, _In_ DWORD dwCreationFlags, _In_opt_ LPVOID lpEnvironment, _In_opt_ LPCWSTR lpCurrentDirectory, _In_ LPSTARTUPINFOW lpStartupInfo, _Out_ LPPROCESS_INFORMATION lpProcessInformation)
Definition: logon.c:993
BOOL WINAPI GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength, PDWORD ReturnLength)
Definition: security.c:411
HMODULE hModule
Definition: animate.c:44
static WCHAR * strdupAtoW(const char *str)
Definition: main.c:65
#define CDECL
Definition: compat.h:29
#define CloseHandle
Definition: compat.h:739
#define wcschr
Definition: compat.h:17
#define IMAGE_FILE_MACHINE_ARMNT
Definition: compat.h:127
#define PAGE_READONLY
Definition: compat.h:138
#define wcsrchr
Definition: compat.h:16
#define GetEnvironmentVariableW(x, y, z)
Definition: compat.h:755
#define OPEN_EXISTING
Definition: compat.h:775
#define ReadFile(a, b, c, d, e)
Definition: compat.h:742
#define GetProcAddress(x, y)
Definition: compat.h:753
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define __TRY
Definition: compat.h:80
#define FreeLibrary(x)
Definition: compat.h:748
#define GetCurrentProcess()
Definition: compat.h:759
#define ERROR_NO_MORE_ITEMS
Definition: compat.h:105
#define GENERIC_READ
Definition: compat.h:135
#define MAX_PATH
Definition: compat.h:34
#define CreateFileW
Definition: compat.h:741
#define IMAGE_FILE_MACHINE_ARM64
Definition: compat.h:129
#define __ENDTRY
Definition: compat.h:82
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
#define lstrcpyW
Definition: compat.h:749
#define LoadLibraryW(x)
Definition: compat.h:747
#define FILE_SHARE_READ
Definition: compat.h:136
#define __EXCEPT_PAGE_FAULT
Definition: compat.h:81
#define lstrlenW
Definition: compat.h:750
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
Definition: delete.c:39
DWORD WINAPI GetFileAttributesW(LPCWSTR lpFileName)
Definition: fileinfo.c:652
DWORD WINAPI GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh)
Definition: fileinfo.c:331
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
BOOL WINAPI DuplicateHandle(IN HANDLE hSourceProcessHandle, IN HANDLE hSourceHandle, IN HANDLE hTargetProcessHandle, OUT LPHANDLE lpTargetHandle, IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwOptions)
Definition: handle.c:149
DWORD WINAPI GetTempPathW(IN DWORD count, OUT LPWSTR path)
Definition: path.c:2080
UINT WINAPI GetSystemWow64DirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2421
DWORD WINAPI SearchPathW(IN LPCWSTR lpPath OPTIONAL, IN LPCWSTR lpFileName, IN LPCWSTR lpExtension OPTIONAL, IN DWORD nBufferLength, OUT LPWSTR lpBuffer, OUT LPWSTR *lpFilePart OPTIONAL)
Definition: path.c:1298
UINT WINAPI GetSystemDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2313
BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessW(LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
Definition: proc.c:4592
BOOL WINAPI GetExitCodeProcess(IN HANDLE hProcess, IN LPDWORD lpExitCode)
Definition: proc.c:1168
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
BOOL WINAPI GetExitCodeThread(IN HANDLE hThread, OUT LPDWORD lpExitCode)
Definition: thread.c:541
BOOL WINAPI Wow64RevertWow64FsRedirection(IN PVOID OldValue)
Definition: utils.c:808
BOOL WINAPI Wow64DisableWow64FsRedirection(IN PVOID *OldValue)
Definition: utils.c:785
const WCHAR * action
Definition: action.c:7479
UINT ACTION_ForceReboot(MSIPACKAGE *package)
Definition: action.c:5183
MSIFILE * msi_get_loaded_file(MSIPACKAGE *package, const WCHAR *key)
Definition: action.c:574
static DWORD custom_start_server(MSIPACKAGE *package, DWORD arch)
Definition: custom.c:618
static HANDLE get_admin_token(void)
Definition: custom.c:596
static msi_custom_action_info * do_msidbCustomActionTypeDll(MSIPACKAGE *package, INT type, LPCWSTR source, LPCWSTR target, LPCWSTR action)
Definition: custom.c:791
static void handle_msi_break(const WCHAR *action)
Definition: custom.c:458
static msi_custom_action_info * do_msidbCustomActionTypeScript(MSIPACKAGE *package, INT type, LPCWSTR script, LPCWSTR function, LPCWSTR action)
Definition: custom.c:1240
static UINT HANDLE_CustomType1(MSIPACKAGE *package, const WCHAR *source, const WCHAR *target, INT type, const WCHAR *action)
Definition: custom.c:861
static WCHAR * build_msiexec_args(const WCHAR *filename, const WCHAR *params)
Definition: custom.c:1026
static UINT defer_custom_action(MSIPACKAGE *package, const WCHAR *action, UINT type)
Definition: custom.c:1423
UINT(WINAPI * MsiCustomActionEntryPoint)(MSIHANDLE)
Definition: custom.c:61
static UINT HANDLE_CustomType7(MSIPACKAGE *package, const WCHAR *source, const WCHAR *target, INT type, const WCHAR *action)
Definition: custom.c:1122
static MSIBINARY * create_temp_binary(MSIPACKAGE *package, LPCWSTR source)
Definition: custom.c:244
static struct list msi_pending_custom_actions
Definition: custom.c:73
#define CUSTOM_ACTION_TYPE_MASK
Definition: custom.c:51
static UINT HANDLE_CustomType37_38(MSIPACKAGE *package, const WCHAR *source, const WCHAR *target, INT type, const WCHAR *action)
Definition: custom.c:1271
struct _msi_custom_action_info msi_custom_action_info
UINT msi_schedule_action(MSIPACKAGE *package, UINT script, const WCHAR *action)
Definition: custom.c:90
static msi_custom_action_info * find_action_by_guid(const GUID *guid)
Definition: custom.c:434
static DWORD WINAPI ScriptThread(LPVOID arg)
Definition: custom.c:1225
void __RPC_USER MIDL_user_free(void __RPC_FAR *ptr)
Definition: custom.c:80
static BOOL check_execution_scheduling_options(MSIPACKAGE *package, LPCWSTR action, UINT options)
Definition: custom.c:142
static UINT HANDLE_CustomType21_22(MSIPACKAGE *package, const WCHAR *source, const WCHAR *target, INT type, const WCHAR *action)
Definition: custom.c:1330
static HANDLE execute_command(const WCHAR *app, WCHAR *arg, const WCHAR *dir)
Definition: custom.c:877
static CRITICAL_SECTION msi_custom_action_cs
Definition: custom.c:63
static UINT HANDLE_CustomType23(MSIPACKAGE *package, const WCHAR *source, const WCHAR *target, INT type, const WCHAR *action)
Definition: custom.c:1043
static MSIBINARY * get_temp_binary(MSIPACKAGE *package, LPCWSTR source)
Definition: custom.c:292
void custom_stop_server(HANDLE process, HANDLE pipe)
Definition: custom.c:681
struct tagMSIRUNNINGACTION MSIRUNNINGACTION
static UINT custom_get_process_return(HANDLE process)
Definition: custom.c:319
UINT CDECL __wine_msi_call_dll_function(DWORD client_pid, const GUID *guid)
Definition: custom.c:507
static UINT HANDLE_CustomType17(MSIPACKAGE *package, const WCHAR *source, const WCHAR *target, INT type, const WCHAR *action)
Definition: custom.c:963
static UINT HANDLE_CustomType2(MSIPACKAGE *package, const WCHAR *source, const WCHAR *target, INT type, const WCHAR *action)
Definition: custom.c:944
void ACTION_FinishCustomActions(const MSIPACKAGE *package)
Definition: custom.c:1604
UINT msi_register_unique_action(MSIPACKAGE *package, const WCHAR *action)
Definition: custom.c:113
static void set_deferred_action_props(MSIPACKAGE *package, const WCHAR *deferred_data)
Definition: custom.c:199
static DWORD WINAPI custom_client_thread(void *arg)
Definition: custom.c:691
static BOOL action_type_matches_script(UINT type, UINT script)
Definition: custom.c:1405
static UINT custom_get_thread_return(MSIPACKAGE *package, HANDLE thread)
Definition: custom.c:330
LONG WINAPI rpc_filter(EXCEPTION_POINTERS *eptr)
Definition: custom.c:85
static BOOL get_binary_type(const WCHAR *name, DWORD *type)
Definition: custom.c:747
static UINT wait_process_handle(MSIPACKAGE *package, UINT type, HANDLE ProcessHandle, LPCWSTR name)
Definition: custom.c:354
static void free_custom_action_data(msi_custom_action_info *info)
Definition: custom.c:395
static UINT write_substorage_to_file(MSIPACKAGE *package, const WCHAR *source, const WCHAR *filename)
Definition: custom.c:1083
static CRITICAL_SECTION_DEBUG msi_custom_action_cs_debug
Definition: custom.c:64
WCHAR * msi_create_temp_file(MSIDATABASE *db)
Definition: custom.c:215
static UINT HANDLE_CustomType34(MSIPACKAGE *package, const WCHAR *source, const WCHAR *target, INT type, const WCHAR *action)
Definition: custom.c:1174
static DWORD ACTION_CallScript(const GUID *guid)
Definition: custom.c:1197
static UINT HANDLE_CustomType5_6(MSIPACKAGE *package, const WCHAR *source, const WCHAR *target, INT type, const WCHAR *action)
Definition: custom.c:1282
BOOL msi_action_is_unique(const MSIPACKAGE *package, const WCHAR *action)
Definition: custom.c:131
UINT ACTION_CustomAction(MSIPACKAGE *package, const WCHAR *action)
Definition: custom.c:1460
static UINT HANDLE_CustomType18(MSIPACKAGE *package, const WCHAR *source, const WCHAR *target, INT type, const WCHAR *action)
Definition: custom.c:983
static void file_running_action(MSIPACKAGE *package, HANDLE Handle, BOOL process, LPCWSTR name)
Definition: custom.c:305
static UINT HANDLE_CustomType50(MSIPACKAGE *package, const WCHAR *source, const WCHAR *target, INT type, const WCHAR *action)
Definition: custom.c:1156
void __RPC_FAR *__RPC_USER MIDL_user_allocate(SIZE_T len)
Definition: custom.c:75
UINT __cdecl s_remote_GetActionInfo(const GUID *guid, WCHAR **name, int *type, WCHAR **dll, char **func, MSIHANDLE *hinst)
Definition: custom.c:1658
static LPWSTR msi_get_deferred_action(LPCWSTR action, LPCWSTR actiondata, LPCWSTR usersid, LPCWSTR prodcode)
Definition: custom.c:181
static UINT custom_proc_wrapper(MsiCustomActionEntryPoint entry, MSIHANDLE hinst)
Definition: custom.c:501
static UINT wait_thread_handle(msi_custom_action_info *info)
Definition: custom.c:411
static UINT HANDLE_CustomType53_54(MSIPACKAGE *package, const WCHAR *source, const WCHAR *target, INT type, const WCHAR *action)
Definition: custom.c:1389
static UINT HANDLE_CustomType19(MSIPACKAGE *package, const WCHAR *source, const WCHAR *target, INT type, const WCHAR *action)
Definition: custom.c:1001
void msi_dialog_check_messages(HANDLE handle)
Definition: dialog.c:4072
HANDLE msi_create_file(MSIPACKAGE *package, const WCHAR *filename, DWORD access, DWORD sharing, DWORD creation, DWORD flags)
Definition: files.c:51
DWORD deformat_string(MSIPACKAGE *package, const WCHAR *fmt, WCHAR **data)
Definition: format.c:1016
MSIHANDLE alloc_msihandle(MSIOBJECTHDR *obj)
Definition: handle.c:111
void msiobj_addref(MSIOBJECTHDR *info)
Definition: handle.c:217
UINT WINAPI MsiCloseHandle(MSIHANDLE handle)
Definition: handle.c:269
MSIHANDLE alloc_msi_remote_handle(MSIHANDLE remote)
Definition: handle.c:135
int msiobj_release(MSIOBJECTHDR *info)
Definition: handle.c:241
UINT WINAPI MsiCloseAllHandles(void)
Definition: handle.c:325
const WCHAR * msi_get_target_folder(MSIPACKAGE *package, const WCHAR *name)
Definition: install.c:232
UINT MSI_SetTargetPathW(MSIPACKAGE *package, LPCWSTR szFolder, LPCWSTR szFolderPath)
Definition: install.c:564
BOOL is_wow64
Definition: msi.c:54
HRESULT WINAPI DECLSPEC_HOTPATCH CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
Definition: compobj.c:2002
HRESULT WINAPI CoCreateGuid(GUID *pguid)
Definition: compobj.c:2206
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
HRESULT WINAPI StgCreateDocfile(LPCOLESTR pwcsName, DWORD grfMode, DWORD reserved, IStorage **ppstgOpen)
Definition: storage32.c:8636
struct png_info_def *typedef unsigned char **typedef struct png_info_def *typedef struct png_info_def *typedef struct png_info_def *typedef unsigned char ** row
Definition: typeof.h:78
#define swprintf
Definition: precomp.h:40
#define INFINITE
Definition: serial.h:102
__declspec(noinline) int TestFunc(int
Definition: ehthrow.cxx:232
UINT WINAPI GetTempFileNameW(IN LPCWSTR lpPathName, IN LPCWSTR lpPrefixString, IN UINT uUnique, OUT LPWSTR lpTempFileName)
Definition: filename.c:84
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
ULONG Handle
Definition: gdb_input.c:15
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLuint GLuint end
Definition: gl.h:1545
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLsizeiptr size
Definition: glext.h:5919
GLenum func
Definition: glext.h:6028
GLenum src
Definition: glext.h:6340
GLuint buffer
Definition: glext.h:5915
GLenum const GLfloat * params
Definition: glext.h:5645
GLenum GLenum dst
Definition: glext.h:6340
GLuint GLfloat * val
Definition: glext.h:7180
GLenum GLenum GLenum GLenum mapping
Definition: glext.h:9031
GLfloat GLfloat p
Definition: glext.h:8902
const GLuint GLenum const GLvoid * binary
Definition: glext.h:7538
GLenum GLsizei len
Definition: glext.h:6722
GLenum target
Definition: glext.h:7315
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat token
Definition: glfuncs.h:210
static LPSTR strdupWtoA(LPCWSTR str)
Definition: hhctrl.h:299
const char cursor[]
Definition: icontest.c:13
_Check_return_ _CRTIMP FILE *__cdecl tmpfile(void)
Definition: file.c:3914
_CONST_RETURN wchar_t *__cdecl wcsstr(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_SubStr)
#define FAILED(hr)
Definition: intsafe.h:51
const char * filename
Definition: ioapi.h:137
uint32_t entry
Definition: isohybrid.c:63
#define debugstr_guid
Definition: kernel32.h:35
#define debugstr_a
Definition: kernel32.h:31
#define debugstr_w
Definition: kernel32.h:32
#define GUID_NULL
Definition: ks.h:106
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
const GUID * guid
#define error(str)
Definition: mkdosfs.c:1605
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static PVOID ptr
Definition: dispmode.c:27
#define GetCurrentThreadEffectiveToken()
Definition: security.c:42
static HINSTANCE hinst
Definition: edit.c:551
static HMODULE dll
Definition: str.c:188
static refpint_t pi[]
Definition: server.c:96
static ATOM item
Definition: dde.c:856
#define __ASM_GLOBAL_FUNC(name, code)
Definition: port.h:201
@ INSTALLUILEVEL_NONE
Definition: msi.h:66
@ msidbCustomActionTypeContinue
Definition: msidefs.h:128
@ msidbCustomActionTypeCommit
Definition: msidefs.h:137
@ msidbCustomActionTypeNoImpersonate
Definition: msidefs.h:139
@ msidbCustomActionTypeAsync
Definition: msidefs.h:129
@ msidbCustomActionTypeOncePerProcess
Definition: msidefs.h:132
@ msidbCustomActionTypeClientRepeat
Definition: msidefs.h:133
@ msidbCustomActionTypeFirstSequence
Definition: msidefs.h:131
@ msidbCustomActionTypeTSAware
Definition: msidefs.h:140
@ msidbCustomActionTypeRollback
Definition: msidefs.h:136
@ msidbCustomActionTypeInScript
Definition: msidefs.h:134
static DWORD client_pid
Definition: msiexec.c:386
#define SEQUENCE_UI
Definition: msipriv.h:718
static void * msi_realloc(void *mem, size_t len) __WINE_ALLOC_SIZE(2)
Definition: msipriv.h:1154
UINT msi_set_property(MSIDATABASE *, const WCHAR *, const WCHAR *, int) DECLSPEC_HIDDEN
Definition: package.c:2100
MSIRECORD *WINAPIV MSI_QueryGetRecord(MSIDATABASE *db, LPCWSTR query,...) DECLSPEC_HIDDEN
Definition: msiquery.c:201
static void * msi_alloc_zero(size_t len) __WINE_ALLOC_SIZE(1)
Definition: msipriv.h:1148
#define INSTALLUILEVEL_MASK
Definition: msipriv.h:60
UINT MSI_RecordReadStream(MSIRECORD *, UINT, char *, LPDWORD) DECLSPEC_HIDDEN
Definition: record.c:761
static void msi_free(void *mem)
Definition: msipriv.h:1159
script
Definition: msipriv.h:383
@ SCRIPT_INSTALL
Definition: msipriv.h:385
@ SCRIPT_ROLLBACK
Definition: msipriv.h:387
@ SCRIPT_NONE
Definition: msipriv.h:384
@ SCRIPT_COMMIT
Definition: msipriv.h:386
@ SCRIPT_MAX
Definition: msipriv.h:388
int MSI_RecordGetInteger(MSIRECORD *, UINT) DECLSPEC_HIDDEN
Definition: record.c:213
UINT msi_get_property(MSIDATABASE *, LPCWSTR, LPWSTR, LPDWORD) DECLSPEC_HIDDEN
Definition: package.c:2250
void msi_reset_source_folders(MSIPACKAGE *package) DECLSPEC_HIDDEN
Definition: package.c:2089
const WCHAR * MSI_RecordGetString(const MSIRECORD *, UINT) DECLSPEC_HIDDEN
Definition: record.c:433
DWORD call_script(MSIHANDLE hPackage, INT type, LPCWSTR script, LPCWSTR function, LPCWSTR action) DECLSPEC_HIDDEN
Definition: script.c:288
static void * msi_alloc(size_t len) __WINE_ALLOC_SIZE(1)
Definition: msipriv.h:1142
LPWSTR msi_dup_property(MSIDATABASE *db, LPCWSTR prop) DECLSPEC_HIDDEN
Definition: package.c:2283
#define SEQUENCE_EXEC
Definition: msipriv.h:719
_In_ HANDLE hFile
Definition: mswsock.h:90
unsigned int UINT
Definition: ndis.h:50
_In_ HANDLE ProcessHandle
Definition: mmfuncs.h:403
#define SEC_IMAGE
Definition: mmtypes.h:97
@ SectionImageInformation
Definition: mmtypes.h:196
BOOL WINAPI ConnectNamedPipe(IN HANDLE hNamedPipe, IN LPOVERLAPPED lpOverlapped)
Definition: npipe.c:701
HANDLE WINAPI CreateNamedPipeW(LPCWSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes)
Definition: npipe.c:246
#define SYNCHRONIZE
Definition: nt_native.h:61
#define SECTION_QUERY
Definition: nt_native.h:1287
#define FILE_ATTRIBUTE_DIRECTORY
Definition: nt_native.h:705
#define GENERIC_WRITE
Definition: nt_native.h:90
#define STANDARD_RIGHTS_REQUIRED
Definition: nt_native.h:63
#define IMAGE_FILE_MACHINE_AMD64
Definition: ntimage.h:17
#define STATUS_INVALID_IMAGE_WIN_64
Definition: ntstatus.h:901
#define L(x)
Definition: ntvdm.h:50
#define STGM_CREATE
Definition: objbase.h:926
#define STGM_TRANSACTED
Definition: objbase.h:915
#define STGM_SHARE_EXCLUSIVE
Definition: objbase.h:923
@ COINIT_MULTITHREADED
Definition: objbase.h:279
#define STGM_WRITE
Definition: objbase.h:918
static HANDLE proc()
Definition: pdb.c:34
#define IMAGE_FILE_MACHINE_I386
Definition: pedump.c:174
long LONG
Definition: pedump.c:60
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
#define __ASM_CFI(str)
Definition: asm.h:39
RPC_STATUS WINAPI RpcBindingFromStringBindingW(RPC_WSTR StringBinding, RPC_BINDING_HANDLE *Binding)
Definition: rpc_binding.c:880
RPC_STATUS WINAPI RpcStringBindingComposeW(RPC_WSTR ObjUuid, RPC_WSTR Protseq, RPC_WSTR NetworkAddr, RPC_WSTR Endpoint, RPC_WSTR Options, RPC_WSTR *StringBinding)
Definition: rpc_binding.c:510
RPC_STATUS WINAPI RpcServerRegisterIfEx(RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, RPC_MGR_EPV *MgrEpv, UINT Flags, UINT MaxCalls, RPC_IF_CALLBACK_FN *IfCallbackFn)
Definition: rpc_server.c:1125
RPC_STATUS WINAPI RpcServerUseProtseqEpW(RPC_WSTR Protseq, UINT MaxCalls, RPC_WSTR Endpoint, LPVOID SecurityDescriptor)
Definition: rpc_server.c:927
RPCRTAPI int RPC_ENTRY I_RpcExceptionFilter(ULONG)
#define RPC_C_LISTEN_MAX_CALLS_DEFAULT
Definition: rpcdce.h:122
#define RPC_C_PROTSEQ_MAX_REQS_DEFAULT
Definition: rpcdce.h:123
unsigned short * RPC_WSTR
Definition: rpcdce.h:46
#define RPC_IF_AUTOLISTEN
Definition: rpcdce.h:313
#define RPC_S_OK
Definition: rpcnterr.h:22
RPC_STATUS WINAPI RpcStringFreeW(RPC_WSTR *String)
Definition: rpcrt4_main.c:175
static void push(calc_node_t *op)
Definition: rpn_ieee.c:113
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
#define midl_user_free
Definition: rpc.h:45
#define __RPC_FAR
Definition: rpc.h:56
long RPC_STATUS
Definition: rpc.h:52
#define __RPC_USER
Definition: rpc.h:65
__WINE_SERVER_LIST_INLINE unsigned int list_count(const struct list *list)
Definition: list.h:155
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
#define memset(x, y, z)
Definition: compat.h:39
#define args
Definition: format.c:66
NTSTATUS NTAPI NtQuerySection(_In_ HANDLE SectionHandle, _In_ SECTION_INFORMATION_CLASS SectionInformationClass, _Out_ PVOID SectionInformation, _In_ SIZE_T SectionInformationLength, _Out_opt_ PSIZE_T ResultLength)
Definition: section.c:3768
#define GetExceptionCode()
Definition: seh.h:27
#define STATUS_SUCCESS
Definition: shellext.h:65
HRESULT hr
Definition: shlfolder.c:183
#define TRACE(s)
Definition: solgame.cpp:4
TCHAR * cmdline
Definition: stretchblt.cpp:32
LIST_ENTRY ProcessLocksList
Definition: winbase.h:883
PEXCEPTION_RECORD ExceptionRecord
Definition: rtltypes.h:200
DWORD ExceptionCode
Definition: compat.h:208
struct list entry
Definition: custom.c:384
MSIPACKAGE * package
Definition: custom.c:385
Definition: match.c:390
Definition: ftp_var.h:139
Definition: cookie.c:34
Definition: nis.h:10
Definition: fci.c:127
Definition: dsound.c:943
Definition: list.h:15
Definition: name.c:39
Definition: ps.c:97
IStorage * storage
Definition: msipriv.h:109
LPWSTR tempfolder
Definition: msipriv.h:114
HANDLE custom_server_64_process
Definition: msipriv.h:443
UINT InWhatSequence
Definition: msipriv.h:438
int unique_actions_count
Definition: msipriv.h:436
HANDLE custom_server_32_pipe
Definition: msipriv.h:444
unsigned char commit_action_running
Definition: msipriv.h:467
struct list RunningActions
Definition: msipriv.h:440
MSIOBJECTHDR hdr
Definition: msipriv.h:393
MSIDATABASE * db
Definition: msipriv.h:394
unsigned char rollback_action_running
Definition: msipriv.h:468
HANDLE custom_server_64_pipe
Definition: msipriv.h:445
LPWSTR * unique_actions
Definition: msipriv.h:435
unsigned char rpc_server_started
Definition: msipriv.h:472
INSTALLUILEVEL ui_level
Definition: msipriv.h:452
enum script script
Definition: msipriv.h:432
LPWSTR * script_actions[SCRIPT_MAX]
Definition: msipriv.h:433
unsigned char scheduled_action_running
Definition: msipriv.h:466
struct list binaries
Definition: msipriv.h:407
HANDLE custom_server_32_process
Definition: msipriv.h:442
int script_actions_count[SCRIPT_MAX]
Definition: msipriv.h:434
struct list entry
Definition: custom.c:55
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
ecx edi movl ebx edx edi decl ecx esi eax jecxz decl eax andl eax esi movl edx movl TEMP incl eax andl eax ecx incl ebx testl eax jnz xchgl ecx incl TEMP esp ecx subl ebx pushl ecx ecx edx ecx shrl ecx mm0 mm4 mm0 mm4 mm1 mm5 mm1 mm5 mm2 mm6 mm2 mm6 mm3 mm7 mm3 mm7 paddd mm0 paddd mm4 paddd mm0 paddd mm4 paddd mm0 paddd mm4 movq mm1 movq mm5 psrlq mm1 psrlq mm5 paddd mm0 paddd mm4 psrad mm0 psrad mm4 packssdw mm0 packssdw mm4 mm1 punpckldq mm0 pand mm1 pand mm0 por mm1 movq edi esi edx edi decl ecx jnz popl ecx andl ecx jecxz mm0 mm0 mm1 mm1 mm2 mm2 mm3 mm3 paddd mm0 paddd mm0 paddd mm0 movq mm1 psrlq mm1 paddd mm0 psrad mm0 packssdw mm0 movd eax movw edi esi edx esi movl ecx mm0 mm4 mm0 mm4 mm1 mm5 mm1 mm5 mm2 mm6 mm2 mm6 mm3 mm7 mm3 mm7 paddd mm0 paddd mm4 paddd mm0 paddd mm4 paddd mm0 paddd mm4 movq mm1 movq mm5 psrlq mm1 psrlq mm5 paddd mm1 paddd mm5 psrad mm1 psrad mm5 packssdw mm1 packssdw mm5 psubd mm0 psubd mm4 psubsw mm0 psubsw mm4 mm1 punpckldq mm0 pand mm1 pand mm0 por mm1 movq edi subl esi addl edx edi decl ecx jnz mm0 mm0 mm1 mm1 mm2 mm2 mm3 mm3 paddd mm0 paddd mm0 paddd mm0 movq mm1 psrlq mm1 paddd mm1 psrad mm1 packssdw mm1 psubd mm0 psubsw mm0 movd eax movw edi emms popl ebx popl esi popl edi mov ebp
Definition: synth_sse3d.h:266
#define LIST_INIT(head)
Definition: queue.h:197
#define LIST_ENTRY(type)
Definition: queue.h:175
#define DWORD_PTR
Definition: treelist.c:76
uint32_t DWORD_PTR
Definition: typedefs.h:65
uint64_t DWORD64
Definition: typedefs.h:67
ULONG_PTR SIZE_T
Definition: typedefs.h:80
int32_t INT
Definition: typedefs.h:58
int ret
static GLenum _GLUfuncptr fn
Definition: wgl_font.c:159
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define PIPE_ACCESS_DUPLEX
Definition: winbase.h:164
DWORD WINAPI GetCurrentThreadId(void)
Definition: thread.c:459
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
DWORD WINAPI GetCurrentProcessId(void)
Definition: proc.c:1158
void WINAPI DebugBreak(void)
#define INVALID_FILE_SIZE
Definition: winbase.h:548
#define SCS_32BIT_BINARY
Definition: winbase.h:236
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
#define SCS_64BIT_BINARY
Definition: winbase.h:237
void * arg
Definition: msvc.h:10
#define WINAPI
Definition: msvc.h:6
unsigned long MSIHANDLE
Definition: winemsi.idl:27
#define ERROR_INSTALL_FAILURE
Definition: winerror.h:961
#define ERROR_INSTALL_USEREXIT
Definition: winerror.h:960
#define ERROR_FUNCTION_FAILED
Definition: winerror.h:985
#define ERROR_INSTALL_SUSPEND
Definition: winerror.h:962
#define ERROR_FUNCTION_NOT_CALLED
Definition: winerror.h:984
#define ERROR_INVALID_DATA
Definition: winerror.h:116
enum _TOKEN_ELEVATION_TYPE TOKEN_ELEVATION_TYPE
@ TokenElevationTypeFull
Definition: winnt_old.h:2487
int WINAPI MessageBoxW(_In_opt_ HWND hWnd, _In_opt_ LPCWSTR lpText, _In_opt_ LPCWSTR lpCaption, _In_ UINT uType)
#define MB_OK
Definition: winuser.h:790
#define DUPLICATE_SAME_ACCESS
#define DUPLICATE_CLOSE_SOURCE
@ TokenElevationType
Definition: setypes.h:983
@ TokenLinkedToken
Definition: setypes.h:984
char * LPSTR
Definition: xmlstorage.h:182
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
char CHAR
Definition: xmlstorage.h:175