ReactOS 0.4.15-dev-8236-g99f0937
install.c
Go to the documentation of this file.
1/*
2 * Implementation of 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/* Msi top level apis directly related to installs */
22
23#define COBJMACROS
24
25#include <stdarg.h>
26
27#include "windef.h"
28#include "winbase.h"
29#include "winerror.h"
30#include "msi.h"
31#include "msidefs.h"
32#include "objbase.h"
33#include "oleauto.h"
34
35#include "msipriv.h"
36#include "winemsi_s.h"
37#include "wine/debug.h"
38#include "wine/exception.h"
39
41
42/***********************************************************************
43 * MsiDoActionA (MSI.@)
44 */
46{
47 LPWSTR szwAction;
48 UINT ret;
49
50 TRACE("%s\n", debugstr_a(szAction));
51
52 szwAction = strdupAtoW(szAction);
53 if (szAction && !szwAction)
55
56 ret = MsiDoActionW( hInstall, szwAction );
57 msi_free( szwAction );
58 return ret;
59}
60
61/***********************************************************************
62 * MsiDoActionW (MSI.@)
63 */
65{
66 MSIPACKAGE *package;
67 UINT ret;
68
69 TRACE("%s\n",debugstr_w(szAction));
70
71 if (!szAction)
73
74 package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
75 if (!package)
76 {
77 MSIHANDLE remote;
78
79 if (!(remote = msi_get_remote(hInstall)))
81
82 __TRY
83 {
84 ret = remote_DoAction(remote, szAction);
85 }
87 {
89 }
91
92 return ret;
93 }
94
95 ret = ACTION_PerformAction(package, szAction);
96 msiobj_release( &package->hdr );
97
98 return ret;
99}
100
101/***********************************************************************
102 * MsiSequenceA (MSI.@)
103 */
104UINT WINAPI MsiSequenceA( MSIHANDLE hInstall, LPCSTR szTable, INT iSequenceMode )
105{
106 LPWSTR szwTable;
107 UINT ret;
108
109 TRACE("%s, %d\n", debugstr_a(szTable), iSequenceMode);
110
111 szwTable = strdupAtoW(szTable);
112 if (szTable && !szwTable)
114
115 ret = MsiSequenceW( hInstall, szwTable, iSequenceMode );
116 msi_free( szwTable );
117 return ret;
118}
119
120/***********************************************************************
121 * MsiSequenceW (MSI.@)
122 */
123UINT WINAPI MsiSequenceW( MSIHANDLE hInstall, LPCWSTR szTable, INT iSequenceMode )
124{
125 MSIPACKAGE *package;
126 UINT ret;
127
128 TRACE("%s, %d\n", debugstr_w(szTable), iSequenceMode);
129
130 if (!szTable)
132
133 package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
134 if (!package)
135 {
136 MSIHANDLE remote;
137
138 if (!(remote = msi_get_remote(hInstall)))
140
141 __TRY
142 {
143 ret = remote_Sequence(remote, szTable, iSequenceMode);
144 }
146 {
148 }
150
151 return ret;
152 }
153 ret = MSI_Sequence( package, szTable );
154 msiobj_release( &package->hdr );
155 return ret;
156}
157
159{
161
162 if (awbuf->str.w && !sz)
164 if (!sz)
165 return ERROR_SUCCESS;
166
167 if (len < 0) len = lstrlenW( str );
168
169 if (awbuf->unicode && awbuf->str.w)
170 {
171 memcpy( awbuf->str.w, str, min(len + 1, *sz) * sizeof(WCHAR) );
172 if (*sz && len >= *sz)
173 awbuf->str.w[*sz - 1] = 0;
174 }
175 else
176 {
177 int lenA = WideCharToMultiByte( CP_ACP, 0, str, len + 1, NULL, 0, NULL, NULL );
178 if (lenA) lenA--;
179 WideCharToMultiByte( CP_ACP, 0, str, len + 1, awbuf->str.a, *sz, NULL, NULL );
180 if (awbuf->str.a && *sz && lenA >= *sz)
181 awbuf->str.a[*sz - 1] = 0;
182 len = lenA;
183 }
184 if (awbuf->str.w && len >= *sz)
186 *sz = len;
187 return r;
188}
189
190UINT msi_strncpyWtoA(const WCHAR *str, int lenW, char *buf, DWORD *sz, BOOL remote)
191{
193 DWORD lenA;
194
195 if (!sz)
197
198 if (lenW < 0) lenW = lstrlenW(str);
199 lenA = WideCharToMultiByte(CP_ACP, 0, str, lenW + 1, NULL, 0, NULL, NULL);
200 WideCharToMultiByte(CP_ACP, 0, str, lenW + 1, buf, *sz, NULL, NULL);
201 lenA--;
202 if (buf && lenA >= *sz)
203 {
204 if (*sz) buf[*sz - 1] = 0;
206 }
207 if (remote && lenA >= *sz)
208 lenA *= 2;
209 *sz = lenA;
210 return r;
211}
212
214{
216
217 if (!sz)
219
220 if (len < 0) len = lstrlenW(str);
221 if (buf)
222 memcpy(buf, str, min(len + 1, *sz) * sizeof(WCHAR));
223 if (buf && len >= *sz)
224 {
225 if (*sz) buf[*sz - 1] = 0;
227 }
228 *sz = len;
229 return r;
230}
231
233{
235
236 if (!folder) return NULL;
237 if (!folder->ResolvedTarget)
238 {
240 while (parent->Parent && wcscmp( parent->Parent, parent->Directory ))
241 {
242 parent = msi_get_loaded_folder( package, parent->Parent );
243 }
244 msi_resolve_target_folder( package, parent->Directory, TRUE );
245 }
246 return folder->ResolvedTarget;
247}
248
249/***********************************************************************
250 * MsiGetTargetPathA (MSI.@)
251 */
253{
254 MSIPACKAGE *package;
255 const WCHAR *path;
256 WCHAR *folderW;
257 UINT r;
258
259 TRACE("%s %p %p\n", debugstr_a(folder), buf, sz);
260
261 if (!folder)
263
264 if (!(folderW = strdupAtoW(folder)))
265 return ERROR_OUTOFMEMORY;
266
267 package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
268 if (!package)
269 {
270 WCHAR *path = NULL;
271 MSIHANDLE remote;
272
273 if (!(remote = msi_get_remote(hinst)))
274 {
275 free(folderW);
277 }
278
279 __TRY
280 {
281 r = remote_GetTargetPath(remote, folderW, &path);
282 }
284 {
286 }
288
289 if (!r)
290 r = msi_strncpyWtoA(path, -1, buf, sz, TRUE);
291
293 free(folderW);
294 return r;
295 }
296
297 path = msi_get_target_folder(package, folderW);
298 if (path)
299 r = msi_strncpyWtoA(path, -1, buf, sz, FALSE);
300 else
302
303 free(folderW);
304 msiobj_release(&package->hdr);
305 return r;
306}
307
308/***********************************************************************
309 * MsiGetTargetPathW (MSI.@)
310 */
312{
313 MSIPACKAGE *package;
314 const WCHAR *path;
315 UINT r;
316
317 TRACE("%s %p %p\n", debugstr_w(folder), buf, sz);
318
319 if (!folder)
321
322 package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
323 if (!package)
324 {
325 WCHAR *path = NULL;
326 MSIHANDLE remote;
327
328 if (!(remote = msi_get_remote(hinst)))
330
331 __TRY
332 {
333 r = remote_GetTargetPath(remote, folder, &path);
334 }
336 {
338 }
340
341 if (!r)
342 r = msi_strncpyW(path, -1, buf, sz);
343
345 return r;
346 }
347
349 if (path)
350 r = msi_strncpyW(path, -1, buf, sz);
351 else
353
354 msiobj_release(&package->hdr);
355 return r;
356}
357
359{
360 msi_set_sourcedir_props( package, FALSE );
361 return msi_dup_property( package->db, L"SourceDir" );
362}
363
365{
366 MSIFOLDER *f;
367 LPWSTR p, path = NULL, parent;
368
369 TRACE("working to resolve %s\n", debugstr_w(name));
370
371 if (!wcscmp( name, L"SourceDir" )) name = L"TARGETDIR";
372 if (!(f = msi_get_loaded_folder( package, name ))) return NULL;
373
374 /* special resolving for root dir */
375 if (!wcscmp( name, L"TARGETDIR" ) && !f->ResolvedSource)
376 {
377 f->ResolvedSource = get_source_root( package );
378 }
379 if (folder) *folder = f;
380 if (f->ResolvedSource)
381 {
382 path = strdupW( f->ResolvedSource );
383 TRACE(" already resolved to %s\n", debugstr_w(path));
384 return path;
385 }
386 if (!f->Parent) return path;
387 parent = f->Parent;
388 TRACE(" ! parent is %s\n", debugstr_w(parent));
389
390 p = msi_resolve_source_folder( package, parent, NULL );
391
393 path = get_source_root( package );
394 else if (package->WordCount & msidbSumInfoSourceTypeSFN)
395 path = msi_build_directory_name( 3, p, f->SourceShortPath, NULL );
396 else
397 path = msi_build_directory_name( 3, p, f->SourceLongPath, NULL );
398
399 TRACE("-> %s\n", debugstr_w(path));
400 f->ResolvedSource = strdupW( path );
401 msi_free( p );
402
403 return path;
404}
405
406/***********************************************************************
407 * MsiGetSourcePathA (MSI.@)
408 */
410{
411 MSIPACKAGE *package;
412 WCHAR *path, *folderW;
413 UINT r;
414
415 TRACE("%s %p %p\n", debugstr_a(folder), buf, sz);
416
417 if (!folder)
419
420 if (!(folderW = strdupAtoW(folder)))
421 return ERROR_OUTOFMEMORY;
422
423 package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
424 if (!package)
425 {
426 WCHAR *path = NULL;
427 MSIHANDLE remote;
428
429 if (!(remote = msi_get_remote(hinst)))
430 {
431 free(folderW);
433 }
434
435 __TRY
436 {
437 r = remote_GetSourcePath(remote, folderW, &path);
438 }
440 {
442 }
444
445 if (!r)
446 r = msi_strncpyWtoA(path, -1, buf, sz, TRUE);
447
449 free(folderW);
450 return r;
451 }
452
453 path = msi_resolve_source_folder(package, folderW, NULL);
454 if (path)
455 r = msi_strncpyWtoA(path, -1, buf, sz, FALSE);
456 else
458
459 free(path);
460 free(folderW);
461 msiobj_release(&package->hdr);
462 return r;
463}
464
465/***********************************************************************
466 * MsiGetSourcePathW (MSI.@)
467 */
469{
470 MSIPACKAGE *package;
471 WCHAR *path;
472 UINT r;
473
474 TRACE("%s %p %p\n", debugstr_w(folder), buf, sz);
475
476 if (!folder)
478
479 package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
480 if (!package)
481 {
482 WCHAR *path = NULL;
483 MSIHANDLE remote;
484
485 if (!(remote = msi_get_remote(hinst)))
487
488 __TRY
489 {
490 r = remote_GetSourcePath(remote, folder, &path);
491 }
493 {
495 }
497
498 if (!r)
499 r = msi_strncpyW(path, -1, buf, sz);
500
502 return r;
503 }
504
506 if (path)
507 r = msi_strncpyW(path, -1, buf, sz);
508 else
510
511 free(path);
512 msiobj_release(&package->hdr);
513 return r;
514}
515
516/***********************************************************************
517 * MsiSetTargetPathA (MSI.@)
518 */
520 LPCSTR szFolderPath )
521{
522 LPWSTR szwFolder = NULL, szwFolderPath = NULL;
524
525 if ( !szFolder || !szFolderPath )
527
528 szwFolder = strdupAtoW(szFolder);
529 szwFolderPath = strdupAtoW(szFolderPath);
530 if (!szwFolder || !szwFolderPath)
531 goto end;
532
533 rc = MsiSetTargetPathW( hInstall, szwFolder, szwFolderPath );
534
535end:
536 msi_free(szwFolder);
537 msi_free(szwFolderPath);
538
539 return rc;
540}
541
542static void set_target_path( MSIPACKAGE *package, MSIFOLDER *folder, const WCHAR *path )
543{
544 FolderList *fl;
546 WCHAR *target_path;
547
548 if (!(target_path = msi_normalize_path( path ))) return;
549 if (wcscmp( target_path, folder->ResolvedTarget ))
550 {
551 msi_free( folder->ResolvedTarget );
552 folder->ResolvedTarget = target_path;
553 msi_set_property( package->db, folder->Directory, folder->ResolvedTarget, -1 );
554
556 {
557 child = fl->folder;
558 msi_resolve_target_folder( package, child->Directory, FALSE );
559 }
560 }
561 else msi_free( target_path );
562}
563
564UINT MSI_SetTargetPathW( MSIPACKAGE *package, LPCWSTR szFolder, LPCWSTR szFolderPath )
565{
566 DWORD attrib;
568 MSIFILE *file;
569
570 TRACE("%p %s %s\n", package, debugstr_w(szFolder), debugstr_w(szFolderPath));
571
572 attrib = msi_get_file_attributes( package, szFolderPath );
573 /* native MSI tests writeability by making temporary files at each drive */
574 if (attrib != INVALID_FILE_ATTRIBUTES &&
575 (attrib & FILE_ATTRIBUTE_OFFLINE || attrib & FILE_ATTRIBUTE_READONLY))
576 {
578 }
579 if (!(folder = msi_get_loaded_folder( package, szFolder ))) return ERROR_DIRECTORY;
580
581 set_target_path( package, folder, szFolderPath );
582
584 {
585 const WCHAR *dir;
586 MSICOMPONENT *comp = file->Component;
587
588 if (!comp->Enabled || msi_is_global_assembly( comp )) continue;
589
590 dir = msi_get_target_folder( package, comp->Directory );
591 msi_free( file->TargetPath );
592 file->TargetPath = msi_build_directory_name( 2, dir, file->FileName );
593 }
594 return ERROR_SUCCESS;
595}
596
597/***********************************************************************
598 * MsiSetTargetPathW (MSI.@)
599 */
601 LPCWSTR szFolderPath)
602{
603 MSIPACKAGE *package;
604 UINT ret;
605
606 TRACE("%s %s\n",debugstr_w(szFolder),debugstr_w(szFolderPath));
607
608 if ( !szFolder || !szFolderPath )
610
611 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
612 if (!package)
613 {
614 MSIHANDLE remote;
615
616 if (!(remote = msi_get_remote(hInstall)))
618
619 __TRY
620 {
621 ret = remote_SetTargetPath(remote, szFolder, szFolderPath);
622 }
624 {
626 }
628
629 return ret;
630 }
631
632 ret = MSI_SetTargetPathW( package, szFolder, szFolderPath );
633 msiobj_release( &package->hdr );
634 return ret;
635}
636
637/***********************************************************************
638 * MsiGetMode (MSI.@)
639 *
640 * Returns an internal installer state (if it is running in a mode iRunMode)
641 *
642 * PARAMS
643 * hInstall [I] Handle to the installation
644 * hRunMode [I] Checking run mode
645 * MSIRUNMODE_ADMIN Administrative mode
646 * MSIRUNMODE_ADVERTISE Advertisement mode
647 * MSIRUNMODE_MAINTENANCE Maintenance mode
648 * MSIRUNMODE_ROLLBACKENABLED Rollback is enabled
649 * MSIRUNMODE_LOGENABLED Log file is writing
650 * MSIRUNMODE_OPERATIONS Operations in progress??
651 * MSIRUNMODE_REBOOTATEND We need to reboot after installation completed
652 * MSIRUNMODE_REBOOTNOW We need to reboot to continue the installation
653 * MSIRUNMODE_CABINET Files from cabinet are installed
654 * MSIRUNMODE_SOURCESHORTNAMES Long names in source files is suppressed
655 * MSIRUNMODE_TARGETSHORTNAMES Long names in destination files is suppressed
656 * MSIRUNMODE_RESERVED11 Reserved
657 * MSIRUNMODE_WINDOWS9X Running under Windows95/98
658 * MSIRUNMODE_ZAWENABLED Demand installation is supported
659 * MSIRUNMODE_RESERVED14 Reserved
660 * MSIRUNMODE_RESERVED15 Reserved
661 * MSIRUNMODE_SCHEDULED called from install script
662 * MSIRUNMODE_ROLLBACK called from rollback script
663 * MSIRUNMODE_COMMIT called from commit script
664 *
665 * RETURNS
666 * In the state: TRUE
667 * Not in the state: FALSE
668 *
669 */
671{
672 MSIPACKAGE *package;
673 BOOL r = FALSE;
674
675 TRACE( "%lu, %d\n", hInstall, iRunMode );
676
677 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
678 if (!package)
679 {
680 MSIHANDLE remote;
681
682 if (!(remote = msi_get_remote(hInstall)))
683 return FALSE;
684
685 __TRY
686 {
687 r = remote_GetMode(remote, iRunMode);
688 }
690 {
691 r = FALSE;
692 }
694
695 return r;
696 }
697
698 switch (iRunMode)
699 {
700 case MSIRUNMODE_ADMIN:
701 FIXME("no support for administrative installs\n");
702 break;
703
705 FIXME("no support for advertised installs\n");
706 break;
707
709 if (GetVersion() & 0x80000000)
710 r = TRUE;
711 break;
712
717 break;
718
720 r = package->scheduled_action_running;
721 break;
722
724 r = package->rollback_action_running;
725 break;
726
728 r = package->commit_action_running;
729 break;
730
732 r = msi_get_property_int( package->db, L"Installed", 0 ) != 0;
733 break;
734
736 r = msi_get_property_int( package->db, L"RollbackDisabled", 0 ) == 0;
737 break;
738
740 r = package->need_reboot_at_end;
741 break;
742
744 r = package->need_reboot_now;
745 break;
746
748 r = (package->log_file != INVALID_HANDLE_VALUE);
749 break;
750
751 default:
752 FIXME("unimplemented run mode: %d\n", iRunMode);
753 r = TRUE;
754 }
755
756 msiobj_release( &package->hdr );
757 return r;
758}
759
760/***********************************************************************
761 * MsiSetMode (MSI.@)
762 */
763UINT WINAPI MsiSetMode(MSIHANDLE hInstall, MSIRUNMODE iRunMode, BOOL fState)
764{
765 MSIPACKAGE *package;
766 UINT r;
767
768 TRACE( "%lu, %d, %d\n", hInstall, iRunMode, fState );
769
770 package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
771 if (!package)
772 {
773 MSIHANDLE remote;
774
775 if (!(remote = msi_get_remote(hInstall)))
776 return FALSE;
777
778 __TRY
779 {
780 r = remote_SetMode(remote, iRunMode, fState);
781 }
783 {
785 }
787
788 return r;
789 }
790
791 switch (iRunMode)
792 {
794 package->need_reboot_at_end = (fState != 0);
796 break;
797
799 package->need_reboot_now = (fState != 0);
801 break;
802
803 default:
805 }
806
807 msiobj_release( &package->hdr );
808 return r;
809}
810
811/***********************************************************************
812 * MsiSetFeatureStateA (MSI.@)
813 *
814 * According to the docs, when this is called it immediately recalculates
815 * all the component states as well
816 */
818 INSTALLSTATE iState)
819{
820 LPWSTR szwFeature = NULL;
821 UINT rc;
822
823 szwFeature = strdupAtoW(szFeature);
824
825 rc = MsiSetFeatureStateW(hInstall,szwFeature, iState);
826
827 msi_free(szwFeature);
828
829 return rc;
830}
831
832/* update component state based on a feature change */
834{
835 INSTALLSTATE newstate;
836 ComponentList *cl;
837
838 newstate = feature->ActionRequest;
839 if (newstate == INSTALLSTATE_ABSENT) newstate = INSTALLSTATE_UNKNOWN;
840
842 {
843 MSICOMPONENT *component = cl->component;
844
845 if (!component->Enabled) continue;
846
847 TRACE("Modifying (%d): Component %s (Installed %d, Action %d, Request %d)\n",
848 newstate, debugstr_w(component->Component), component->Installed,
849 component->Action, component->ActionRequest);
850
851 if (newstate == INSTALLSTATE_LOCAL)
852 {
853 component->Action = INSTALLSTATE_LOCAL;
855 }
856 else
857 {
858 ComponentList *clist;
859 MSIFEATURE *f;
860
861 component->hasLocalFeature = FALSE;
862
863 component->Action = newstate;
864 component->ActionRequest = newstate;
865 /* if any other feature wants it local we need to set it local */
867 {
868 if ( f->ActionRequest != INSTALLSTATE_LOCAL &&
869 f->ActionRequest != INSTALLSTATE_SOURCE )
870 {
871 continue;
872 }
873 LIST_FOR_EACH_ENTRY(clist, &f->Components, ComponentList, entry)
874 {
875 if (clist->component == component &&
876 (f->ActionRequest == INSTALLSTATE_LOCAL ||
877 f->ActionRequest == INSTALLSTATE_SOURCE))
878 {
879 TRACE("Saved by %s\n", debugstr_w(f->Feature));
880 component->hasLocalFeature = TRUE;
881
883 {
884 if (f->Attributes & msidbFeatureAttributesFavorSource)
885 {
886 component->Action = INSTALLSTATE_SOURCE;
888 }
889 else
890 {
891 component->Action = INSTALLSTATE_LOCAL;
893 }
894 }
896 {
897 component->Action = INSTALLSTATE_SOURCE;
899 }
900 else
901 {
902 component->Action = INSTALLSTATE_LOCAL;
904 }
905 }
906 }
907 }
908 }
909 TRACE("Result (%d): Component %s (Installed %d, Action %d, Request %d)\n",
910 newstate, debugstr_w(component->Component), component->Installed,
911 component->Action, component->ActionRequest);
912 }
913}
914
916{
917 UINT rc = ERROR_SUCCESS;
919
920 TRACE("%s %i\n", debugstr_w(szFeature), iState);
921
922 feature = msi_get_loaded_feature( package, szFeature );
923 if (!feature)
925
926 if (iState == INSTALLSTATE_ADVERTISED &&
929
930 feature->ActionRequest = iState;
931
933
934 /* update all the features that are children of this feature */
936 {
937 if (child->Feature_Parent && !wcscmp( szFeature, child->Feature_Parent ))
938 MSI_SetFeatureStateW(package, child->Feature, iState);
939 }
940
941 return rc;
942}
943
944/***********************************************************************
945 * MsiSetFeatureStateW (MSI.@)
946 */
948 INSTALLSTATE iState)
949{
950 MSIPACKAGE* package;
951 UINT rc = ERROR_SUCCESS;
952
953 TRACE("%s %i\n",debugstr_w(szFeature), iState);
954
955 if (!szFeature)
957
958 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
959 if (!package)
960 {
961 MSIHANDLE remote;
962
963 if (!(remote = msi_get_remote(hInstall)))
965
966 __TRY
967 {
968 rc = remote_SetFeatureState(remote, szFeature, iState);
969 }
971 {
972 rc = GetExceptionCode();
973 }
975
976 return rc;
977 }
978
979 rc = MSI_SetFeatureStateW(package,szFeature,iState);
980
981 msiobj_release( &package->hdr );
982 return rc;
983}
984
985/***********************************************************************
986* MsiSetFeatureAttributesA (MSI.@)
987*/
989{
990 UINT r;
991 WCHAR *featureW = NULL;
992
993 TRACE( "%lu, %s, %#lx\n", handle, debugstr_a(feature), attrs );
994
995 if (feature && !(featureW = strdupAtoW( feature ))) return ERROR_OUTOFMEMORY;
996
997 r = MsiSetFeatureAttributesW( handle, featureW, attrs );
998 msi_free( featureW );
999 return r;
1000}
1001
1003{
1004 DWORD ret = 0;
1005
1012 return ret;
1013}
1014
1015/***********************************************************************
1016* MsiSetFeatureAttributesW (MSI.@)
1017*/
1019{
1020 MSIPACKAGE *package;
1022 WCHAR *costing;
1023
1024 TRACE( "%lu, %s, %#lx\n", handle, debugstr_w(name), attrs );
1025
1026 if (!name || !name[0]) return ERROR_UNKNOWN_FEATURE;
1027
1028 if (!(package = msihandle2msiinfo( handle, MSIHANDLETYPE_PACKAGE )))
1029 return ERROR_INVALID_HANDLE;
1030
1031 costing = msi_dup_property( package->db, L"CostingComplete" );
1032 if (!costing || !wcscmp( costing, L"1" ))
1033 {
1034 msi_free( costing );
1035 msiobj_release( &package->hdr );
1036 return ERROR_FUNCTION_FAILED;
1037 }
1038 msi_free( costing );
1039 if (!(feature = msi_get_loaded_feature( package, name )))
1040 {
1041 msiobj_release( &package->hdr );
1042 return ERROR_UNKNOWN_FEATURE;
1043 }
1044 feature->Attributes = unmap_feature_attributes( attrs );
1045 msiobj_release( &package->hdr );
1046 return ERROR_SUCCESS;
1047}
1048
1049/***********************************************************************
1050* MsiGetFeatureStateA (MSI.@)
1051*/
1053 INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
1054{
1055 LPWSTR szwFeature = NULL;
1056 UINT rc;
1057
1058 if (szFeature && !(szwFeature = strdupAtoW(szFeature))) return ERROR_OUTOFMEMORY;
1059
1060 rc = MsiGetFeatureStateW(hInstall, szwFeature, piInstalled, piAction);
1061 msi_free( szwFeature);
1062 return rc;
1063}
1064
1066 INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
1067{
1069
1070 feature = msi_get_loaded_feature(package,szFeature);
1071 if (!feature)
1072 return ERROR_UNKNOWN_FEATURE;
1073
1074 if (piInstalled)
1075 *piInstalled = feature->Installed;
1076
1077 if (piAction)
1078 *piAction = feature->ActionRequest;
1079
1080 TRACE("returning %i %i\n", feature->Installed, feature->ActionRequest);
1081
1082 return ERROR_SUCCESS;
1083}
1084
1085/***********************************************************************
1086* MsiGetFeatureStateW (MSI.@)
1087*/
1088UINT WINAPI MsiGetFeatureStateW( MSIHANDLE hInstall, const WCHAR *szFeature, INSTALLSTATE *piInstalled,
1089 INSTALLSTATE *piAction )
1090{
1091 MSIPACKAGE* package;
1092 UINT ret;
1093
1094 TRACE( "%lu, %s, %p, %p\n", hInstall, debugstr_w(szFeature), piInstalled, piAction );
1095
1096 if (!szFeature)
1097 return ERROR_UNKNOWN_FEATURE;
1098
1099 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1100 if (!package)
1101 {
1102 MSIHANDLE remote;
1103
1104 if (!(remote = msi_get_remote(hInstall)))
1105 return ERROR_INVALID_HANDLE;
1106
1107 __TRY
1108 {
1109 ret = remote_GetFeatureState(remote, szFeature, piInstalled, piAction);
1110 }
1112 {
1114 }
1115 __ENDTRY
1116
1117 return ret;
1118 }
1119
1120 ret = MSI_GetFeatureStateW(package, szFeature, piInstalled, piAction);
1121 msiobj_release( &package->hdr );
1122 return ret;
1123}
1124
1125/***********************************************************************
1126* MsiGetFeatureCostA (MSI.@)
1127*/
1129 MSICOSTTREE iCostTree, INSTALLSTATE iState, LPINT piCost)
1130{
1131 LPWSTR szwFeature = NULL;
1132 UINT rc;
1133
1134 szwFeature = strdupAtoW(szFeature);
1135
1136 rc = MsiGetFeatureCostW(hInstall, szwFeature, iCostTree, iState, piCost);
1137
1138 msi_free(szwFeature);
1139
1140 return rc;
1141}
1142
1144{
1145 INT cost = 0;
1146 ComponentList *cl;
1147
1148 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1149 {
1150 cost += cl->component->Cost;
1151 }
1152 return cost;
1153}
1154
1156 INSTALLSTATE state, LPINT cost )
1157{
1158 TRACE("%s, %u, %d, %p\n", debugstr_w(feature->Feature), tree, state, cost);
1159
1160 *cost = 0;
1161 switch (tree)
1162 {
1164 {
1166
1168 {
1169 if (child->ActionRequest == state)
1170 *cost += feature_cost( child );
1171 }
1172 break;
1173 }
1175 {
1176 const WCHAR *feature_parent = feature->Feature_Parent;
1177 for (;;)
1178 {
1179 MSIFEATURE *parent = msi_get_loaded_feature( package, feature_parent );
1180 if (!parent)
1181 break;
1182
1183 if (parent->ActionRequest == state)
1184 *cost += feature_cost( parent );
1185
1186 feature_parent = parent->Feature_Parent;
1187 }
1188 break;
1189 }
1191 if (feature->ActionRequest == state)
1192 *cost = feature_cost( feature );
1193 break;
1194
1195 default:
1196 WARN("unhandled cost tree %u\n", tree);
1197 break;
1198 }
1199
1200 *cost /= 512;
1201 return ERROR_SUCCESS;
1202}
1203
1204/***********************************************************************
1205* MsiGetFeatureCostW (MSI.@)
1206*/
1207UINT WINAPI MsiGetFeatureCostW( MSIHANDLE hInstall, const WCHAR *szFeature, MSICOSTTREE iCostTree,
1208 INSTALLSTATE iState, INT *piCost )
1209{
1210 MSIPACKAGE *package;
1212 UINT ret;
1213
1214 TRACE( "%lu, %s, %d, %d, %p\n", hInstall, debugstr_w(szFeature), iCostTree, iState, piCost );
1215
1216 if (!szFeature)
1218
1219 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1220 if (!package)
1221 {
1222 MSIHANDLE remote;
1223
1224 if (!(remote = msi_get_remote(hInstall)))
1225 return ERROR_INVALID_HANDLE;
1226
1227 __TRY
1228 {
1229 ret = remote_GetFeatureCost(remote, szFeature, iCostTree, iState, piCost);
1230 }
1232 {
1234 }
1235 __ENDTRY
1236
1237 return ret;
1238 }
1239
1240 if (!piCost)
1241 {
1242 msiobj_release( &package->hdr );
1244 }
1245
1246 feature = msi_get_loaded_feature(package, szFeature);
1247
1248 if (feature)
1249 ret = MSI_GetFeatureCost(package, feature, iCostTree, iState, piCost);
1250 else
1252
1253 msiobj_release( &package->hdr );
1254 return ret;
1255}
1256
1257/***********************************************************************
1258* MsiGetFeatureInfoA (MSI.@)
1259*/
1261 char *title, DWORD *title_len, char *help, DWORD *help_len )
1262{
1263 UINT r;
1264 WCHAR *titleW = NULL, *helpW = NULL, *featureW = NULL;
1265
1266 TRACE( "%lu, %s, %p, %p, %p, %p, %p\n", handle, debugstr_a(feature), attrs, title,
1267 title_len, help, help_len );
1268
1269 if (feature && !(featureW = strdupAtoW( feature ))) return ERROR_OUTOFMEMORY;
1270
1271 if (title && title_len && !(titleW = msi_alloc( *title_len * sizeof(WCHAR) )))
1272 {
1273 msi_free( featureW );
1274 return ERROR_OUTOFMEMORY;
1275 }
1276 if (help && help_len && !(helpW = msi_alloc( *help_len * sizeof(WCHAR) )))
1277 {
1278 msi_free( featureW );
1279 msi_free( titleW );
1280 return ERROR_OUTOFMEMORY;
1281 }
1282 r = MsiGetFeatureInfoW( handle, featureW, attrs, titleW, title_len, helpW, help_len );
1283 if (r == ERROR_SUCCESS)
1284 {
1285 if (titleW) WideCharToMultiByte( CP_ACP, 0, titleW, -1, title, *title_len + 1, NULL, NULL );
1286 if (helpW) WideCharToMultiByte( CP_ACP, 0, helpW, -1, help, *help_len + 1, NULL, NULL );
1287 }
1288 msi_free( titleW );
1289 msi_free( helpW );
1290 msi_free( featureW );
1291 return r;
1292}
1293
1295{
1296 DWORD ret = 0;
1297
1304 return ret;
1305}
1306
1308 LPWSTR title, LPDWORD title_len, LPWSTR help, LPDWORD help_len )
1309{
1312 int len;
1313
1314 if (!feature) return ERROR_UNKNOWN_FEATURE;
1315 if (attrs) *attrs = map_feature_attributes( feature->Attributes );
1316 if (title_len)
1317 {
1318 if (feature->Title) len = lstrlenW( feature->Title );
1319 else len = 0;
1320 if (*title_len <= len)
1321 {
1322 *title_len = len;
1323 if (title) r = ERROR_MORE_DATA;
1324 }
1325 else if (title)
1326 {
1327 if (feature->Title) lstrcpyW( title, feature->Title );
1328 else *title = 0;
1329 *title_len = len;
1330 }
1331 }
1332 if (help_len)
1333 {
1334 if (feature->Description) len = lstrlenW( feature->Description );
1335 else len = 0;
1336 if (*help_len <= len)
1337 {
1338 *help_len = len;
1339 if (help) r = ERROR_MORE_DATA;
1340 }
1341 else if (help)
1342 {
1343 if (feature->Description) lstrcpyW( help, feature->Description );
1344 else *help = 0;
1345 *help_len = len;
1346 }
1347 }
1348 return r;
1349}
1350
1351/***********************************************************************
1352* MsiGetFeatureInfoW (MSI.@)
1353*/
1355 WCHAR *title, DWORD *title_len, WCHAR *help, DWORD *help_len )
1356{
1357 UINT r;
1358 MSIPACKAGE *package;
1359
1360 TRACE( "%lu, %s, %p, %p, %p, %p, %p\n", handle, debugstr_w(feature), attrs, title,
1361 title_len, help, help_len );
1362
1363 if (!feature) return ERROR_INVALID_PARAMETER;
1364
1365 if (!(package = msihandle2msiinfo( handle, MSIHANDLETYPE_PACKAGE )))
1366 return ERROR_INVALID_HANDLE;
1367
1368 /* features may not have been loaded yet */
1369 msi_load_all_components( package );
1370 msi_load_all_features( package );
1371
1372 r = MSI_GetFeatureInfo( package, feature, attrs, title, title_len, help, help_len );
1373 msiobj_release( &package->hdr );
1374 return r;
1375}
1376
1377/***********************************************************************
1378 * MsiSetComponentStateA (MSI.@)
1379 */
1381 INSTALLSTATE iState)
1382{
1383 UINT rc;
1384 LPWSTR szwComponent = strdupAtoW(szComponent);
1385
1386 rc = MsiSetComponentStateW(hInstall, szwComponent, iState);
1387
1388 msi_free(szwComponent);
1389
1390 return rc;
1391}
1392
1393/***********************************************************************
1394 * MsiGetComponentStateA (MSI.@)
1395 */
1397 INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
1398{
1399 LPWSTR szwComponent= NULL;
1400 UINT rc;
1401
1402 szwComponent= strdupAtoW(szComponent);
1403
1404 rc = MsiGetComponentStateW(hInstall,szwComponent,piInstalled, piAction);
1405
1406 msi_free( szwComponent);
1407
1408 return rc;
1409}
1410
1411static UINT MSI_SetComponentStateW(MSIPACKAGE *package, LPCWSTR szComponent,
1412 INSTALLSTATE iState)
1413{
1414 MSICOMPONENT *comp;
1415
1416 TRACE("%p %s %d\n", package, debugstr_w(szComponent), iState);
1417
1418 comp = msi_get_loaded_component(package, szComponent);
1419 if (!comp)
1421
1422 if (comp->Enabled)
1423 comp->Action = iState;
1424
1425 return ERROR_SUCCESS;
1426}
1427
1429 INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
1430{
1431 MSICOMPONENT *comp;
1432
1433 TRACE("%p %s %p %p\n", package, debugstr_w(szComponent),
1434 piInstalled, piAction);
1435
1436 comp = msi_get_loaded_component(package,szComponent);
1437 if (!comp)
1439
1440 if (piInstalled)
1441 {
1442 if (comp->Enabled)
1443 *piInstalled = comp->Installed;
1444 else
1445 *piInstalled = INSTALLSTATE_UNKNOWN;
1446 }
1447
1448 if (piAction)
1449 {
1450 if (comp->Enabled)
1451 *piAction = comp->Action;
1452 else
1453 *piAction = INSTALLSTATE_UNKNOWN;
1454 }
1455
1456 TRACE("states (%i, %i)\n", comp->Installed, comp->Action );
1457 return ERROR_SUCCESS;
1458}
1459
1460/***********************************************************************
1461 * MsiSetComponentStateW (MSI.@)
1462 */
1464 INSTALLSTATE iState)
1465{
1466 MSIPACKAGE* package;
1467 UINT ret;
1468
1469 if (!szComponent)
1471
1472 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1473 if (!package)
1474 {
1475 MSIHANDLE remote;
1476
1477 if (!(remote = msi_get_remote(hInstall)))
1478 return ERROR_INVALID_HANDLE;
1479
1480 __TRY
1481 {
1482 ret = remote_SetComponentState(remote, szComponent, iState);
1483 }
1485 {
1487 }
1488 __ENDTRY
1489
1490 return ret;
1491 }
1492
1493 ret = MSI_SetComponentStateW(package, szComponent, iState);
1494 msiobj_release(&package->hdr);
1495 return ret;
1496}
1497
1498/***********************************************************************
1499 * MsiGetComponentStateW (MSI.@)
1500 */
1501UINT WINAPI MsiGetComponentStateW( MSIHANDLE hInstall, const WCHAR *szComponent, INSTALLSTATE *piInstalled,
1502 INSTALLSTATE *piAction )
1503{
1504 MSIPACKAGE* package;
1505 UINT ret;
1506
1507 TRACE( "%lu, %s, %p, %p\n", hInstall, debugstr_w(szComponent), piInstalled, piAction );
1508
1509 if (!szComponent)
1511
1512 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1513 if (!package)
1514 {
1515 MSIHANDLE remote;
1516
1517 if (!(remote = msi_get_remote(hInstall)))
1518 return ERROR_INVALID_HANDLE;
1519
1520 __TRY
1521 {
1522 ret = remote_GetComponentState(remote, szComponent, piInstalled, piAction);
1523 }
1525 {
1527 }
1528 __ENDTRY
1529
1530 return ret;
1531 }
1532
1533 ret = MSI_GetComponentStateW( package, szComponent, piInstalled, piAction);
1534 msiobj_release( &package->hdr );
1535 return ret;
1536}
1537
1538/***********************************************************************
1539 * MsiGetLanguage (MSI.@)
1540 */
1542{
1543 MSIPACKAGE* package;
1544 LANGID langid;
1545
1546 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1547 if (!package)
1548 {
1549 MSIHANDLE remote;
1550
1551 if (!(remote = msi_get_remote(hInstall)))
1552 return ERROR_INVALID_HANDLE;
1553
1554 __TRY
1555 {
1556 langid = remote_GetLanguage(remote);
1557 }
1559 {
1560 langid = 0;
1561 }
1562 __ENDTRY
1563
1564 return langid;
1565 }
1566
1567 langid = msi_get_property_int( package->db, L"ProductLanguage", 0 );
1568 msiobj_release( &package->hdr );
1569 return langid;
1570}
1571
1572UINT MSI_SetInstallLevel( MSIPACKAGE *package, int iInstallLevel )
1573{
1574 WCHAR level[6];
1575 int len;
1576 UINT r;
1577
1578 TRACE("%p %i\n", package, iInstallLevel);
1579
1580 if (iInstallLevel > 32767)
1582
1583 if (iInstallLevel < 1)
1584 return MSI_SetFeatureStates( package );
1585
1586 len = swprintf( level, ARRAY_SIZE(level), L"%d", iInstallLevel );
1587 r = msi_set_property( package->db, L"INSTALLLEVEL", level, len );
1588 if ( r == ERROR_SUCCESS )
1589 r = MSI_SetFeatureStates( package );
1590
1591 return r;
1592}
1593
1594/***********************************************************************
1595 * MsiSetInstallLevel (MSI.@)
1596 */
1597UINT WINAPI MsiSetInstallLevel(MSIHANDLE hInstall, int iInstallLevel)
1598{
1599 MSIPACKAGE* package;
1600 UINT r;
1601
1602 TRACE( "%lu %d\n", hInstall, iInstallLevel );
1603
1604 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1605 if (!package)
1606 {
1607 MSIHANDLE remote;
1608
1609 if (!(remote = msi_get_remote(hInstall)))
1610 return ERROR_INVALID_HANDLE;
1611
1612 __TRY
1613 {
1614 r = remote_SetInstallLevel(remote, iInstallLevel);
1615 }
1617 {
1618 r = GetExceptionCode();
1619 }
1620 __ENDTRY
1621
1622 return r;
1623 }
1624
1625 r = MSI_SetInstallLevel( package, iInstallLevel );
1626
1627 msiobj_release( &package->hdr );
1628
1629 return r;
1630}
1631
1632/***********************************************************************
1633 * MsiGetFeatureValidStatesW (MSI.@)
1634 */
1635UINT WINAPI MsiGetFeatureValidStatesW( MSIHANDLE hInstall, const WCHAR *szFeature, DWORD *pInstallState )
1636{
1637 if (pInstallState) *pInstallState = 1 << INSTALLSTATE_LOCAL;
1638 FIXME( "%lu, %s, %p stub returning %lu\n", hInstall, debugstr_w(szFeature), pInstallState,
1639 pInstallState ? *pInstallState : 0 );
1640 return ERROR_SUCCESS;
1641}
1642
1643/***********************************************************************
1644 * MsiGetFeatureValidStatesA (MSI.@)
1645 */
1646UINT WINAPI MsiGetFeatureValidStatesA( MSIHANDLE hInstall, const char *szFeature, DWORD *pInstallState )
1647{
1648 UINT ret;
1649 WCHAR *szwFeature = strdupAtoW(szFeature);
1650 ret = MsiGetFeatureValidStatesW(hInstall, szwFeature, pInstallState);
1651 msi_free(szwFeature);
1652 return ret;
1653}
static int state
Definition: maze.c:121
unsigned int dir
Definition: maze.c:112
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
int help
Definition: sort.c:20
static WCHAR * strdupW(const WCHAR *src)
Definition: main.c:92
#define ARRAY_SIZE(A)
Definition: main.h:33
#define FIXME(fmt,...)
Definition: debug.h:114
#define WARN(fmt,...)
Definition: debug.h:115
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define free
Definition: debug_ros.c:5
#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
static WCHAR * strdupAtoW(const char *str)
Definition: main.c:65
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define CP_ACP
Definition: compat.h:109
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define __TRY
Definition: compat.h:80
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
#define __ENDTRY
Definition: compat.h:82
#define lstrcpyW
Definition: compat.h:749
#define WideCharToMultiByte
Definition: compat.h:111
#define ERROR_ACCESS_DENIED
Definition: compat.h:97
#define lstrlenW
Definition: compat.h:750
UINT msi_load_all_components(MSIPACKAGE *package)
Definition: action.c:809
BOOL msi_is_global_assembly(MSICOMPONENT *comp)
Definition: action.c:2037
UINT msi_set_sourcedir_props(MSIPACKAGE *package, BOOL replace)
Definition: action.c:354
MSIFOLDER * msi_get_loaded_folder(MSIPACKAGE *package, const WCHAR *dir)
Definition: action.c:585
UINT MSI_Sequence(MSIPACKAGE *package, LPCWSTR table)
Definition: action.c:452
WCHAR * msi_normalize_path(const WCHAR *in)
Definition: action.c:2118
UINT MSI_SetFeatureStates(MSIPACKAGE *package)
Definition: action.c:1640
MSIFEATURE * msi_get_loaded_feature(MSIPACKAGE *package, const WCHAR *Feature)
Definition: action.c:563
UINT ACTION_PerformAction(MSIPACKAGE *package, const WCHAR *action)
Definition: action.c:7610
MSICOMPONENT * msi_get_loaded_component(MSIPACKAGE *package, const WCHAR *Component)
Definition: action.c:552
UINT msi_load_all_features(MSIPACKAGE *package)
Definition: action.c:951
void msi_resolve_target_folder(MSIPACKAGE *package, const WCHAR *name, BOOL load_prop)
Definition: action.c:2178
WCHAR *WINAPIV msi_build_directory_name(DWORD count,...)
Definition: action.c:2008
LONG WINAPI rpc_filter(EXCEPTION_POINTERS *eptr)
Definition: custom.c:85
DWORD msi_get_file_attributes(MSIPACKAGE *package, const WCHAR *path)
Definition: files.c:106
MSIHANDLE msi_get_remote(MSIHANDLE handle)
Definition: handle.c:183
int msiobj_release(MSIOBJECTHDR *info)
Definition: handle.c:241
void * msihandle2msiinfo(MSIHANDLE handle, UINT type)
Definition: handle.c:158
UINT WINAPI MsiGetSourcePathA(MSIHANDLE hinst, const char *folder, char *buf, DWORD *sz)
Definition: install.c:409
UINT WINAPI MsiSetFeatureAttributesA(MSIHANDLE handle, LPCSTR feature, DWORD attrs)
Definition: install.c:988
static DWORD unmap_feature_attributes(DWORD attrs)
Definition: install.c:1002
UINT msi_strncpyW(const WCHAR *str, int len, WCHAR *buf, DWORD *sz)
Definition: install.c:213
UINT MSI_SetFeatureStateW(MSIPACKAGE *package, LPCWSTR szFeature, INSTALLSTATE iState)
Definition: install.c:915
WCHAR * msi_resolve_source_folder(MSIPACKAGE *package, const WCHAR *name, MSIFOLDER **folder)
Definition: install.c:364
static UINT MSI_GetFeatureInfo(MSIPACKAGE *package, LPCWSTR name, LPDWORD attrs, LPWSTR title, LPDWORD title_len, LPWSTR help, LPDWORD help_len)
Definition: install.c:1307
UINT WINAPI MsiDoActionW(MSIHANDLE hInstall, LPCWSTR szAction)
Definition: install.c:64
UINT WINAPI MsiGetFeatureValidStatesW(MSIHANDLE hInstall, const WCHAR *szFeature, DWORD *pInstallState)
Definition: install.c:1635
UINT WINAPI MsiGetComponentStateA(MSIHANDLE hInstall, LPCSTR szComponent, INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
Definition: install.c:1396
UINT WINAPI MsiSetComponentStateW(MSIHANDLE hInstall, LPCWSTR szComponent, INSTALLSTATE iState)
Definition: install.c:1463
static void set_target_path(MSIPACKAGE *package, MSIFOLDER *folder, const WCHAR *path)
Definition: install.c:542
UINT WINAPI MsiGetFeatureCostW(MSIHANDLE hInstall, const WCHAR *szFeature, MSICOSTTREE iCostTree, INSTALLSTATE iState, INT *piCost)
Definition: install.c:1207
LANGID WINAPI MsiGetLanguage(MSIHANDLE hInstall)
Definition: install.c:1541
UINT WINAPI MsiSetInstallLevel(MSIHANDLE hInstall, int iInstallLevel)
Definition: install.c:1597
UINT WINAPI MsiSetFeatureStateW(MSIHANDLE hInstall, LPCWSTR szFeature, INSTALLSTATE iState)
Definition: install.c:947
static INT feature_cost(MSIFEATURE *feature)
Definition: install.c:1143
UINT WINAPI MsiSequenceW(MSIHANDLE hInstall, LPCWSTR szTable, INT iSequenceMode)
Definition: install.c:123
static UINT MSI_SetComponentStateW(MSIPACKAGE *package, LPCWSTR szComponent, INSTALLSTATE iState)
Definition: install.c:1411
UINT msi_strncpyWtoA(const WCHAR *str, int lenW, char *buf, DWORD *sz, BOOL remote)
Definition: install.c:190
const WCHAR * msi_get_target_folder(MSIPACKAGE *package, const WCHAR *name)
Definition: install.c:232
UINT WINAPI MsiGetTargetPathW(MSIHANDLE hinst, const WCHAR *folder, WCHAR *buf, DWORD *sz)
Definition: install.c:311
UINT WINAPI MsiGetFeatureStateW(MSIHANDLE hInstall, const WCHAR *szFeature, INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
Definition: install.c:1088
UINT WINAPI MsiDoActionA(MSIHANDLE hInstall, LPCSTR szAction)
Definition: install.c:45
UINT WINAPI MsiGetTargetPathA(MSIHANDLE hinst, const char *folder, char *buf, DWORD *sz)
Definition: install.c:252
UINT WINAPI MsiSequenceA(MSIHANDLE hInstall, LPCSTR szTable, INT iSequenceMode)
Definition: install.c:104
UINT MSI_SetTargetPathW(MSIPACKAGE *package, LPCWSTR szFolder, LPCWSTR szFolderPath)
Definition: install.c:564
UINT WINAPI MsiGetSourcePathW(MSIHANDLE hinst, const WCHAR *folder, WCHAR *buf, DWORD *sz)
Definition: install.c:468
UINT MSI_GetComponentStateW(MSIPACKAGE *package, LPCWSTR szComponent, INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
Definition: install.c:1428
UINT WINAPI MsiSetTargetPathW(MSIHANDLE hInstall, LPCWSTR szFolder, LPCWSTR szFolderPath)
Definition: install.c:600
void ACTION_UpdateComponentStates(MSIPACKAGE *package, MSIFEATURE *feature)
Definition: install.c:833
UINT WINAPI MsiGetFeatureInfoA(MSIHANDLE handle, const char *feature, DWORD *attrs, char *title, DWORD *title_len, char *help, DWORD *help_len)
Definition: install.c:1260
UINT WINAPI MsiGetComponentStateW(MSIHANDLE hInstall, const WCHAR *szComponent, INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
Definition: install.c:1501
static WCHAR * get_source_root(MSIPACKAGE *package)
Definition: install.c:358
UINT WINAPI MsiSetFeatureStateA(MSIHANDLE hInstall, LPCSTR szFeature, INSTALLSTATE iState)
Definition: install.c:817
UINT MSI_GetFeatureCost(MSIPACKAGE *package, MSIFEATURE *feature, MSICOSTTREE tree, INSTALLSTATE state, LPINT cost)
Definition: install.c:1155
UINT WINAPI MsiSetTargetPathA(MSIHANDLE hInstall, LPCSTR szFolder, LPCSTR szFolderPath)
Definition: install.c:519
UINT WINAPI MsiSetMode(MSIHANDLE hInstall, MSIRUNMODE iRunMode, BOOL fState)
Definition: install.c:763
UINT MSI_GetFeatureStateW(MSIPACKAGE *package, LPCWSTR szFeature, INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
Definition: install.c:1065
UINT WINAPI MsiGetFeatureInfoW(MSIHANDLE handle, const WCHAR *feature, DWORD *attrs, WCHAR *title, DWORD *title_len, WCHAR *help, DWORD *help_len)
Definition: install.c:1354
UINT WINAPI MsiSetFeatureAttributesW(MSIHANDLE handle, LPCWSTR name, DWORD attrs)
Definition: install.c:1018
UINT WINAPI MsiGetFeatureCostA(MSIHANDLE hInstall, LPCSTR szFeature, MSICOSTTREE iCostTree, INSTALLSTATE iState, LPINT piCost)
Definition: install.c:1128
UINT WINAPI MsiGetFeatureValidStatesA(MSIHANDLE hInstall, const char *szFeature, DWORD *pInstallState)
Definition: install.c:1646
UINT MSI_SetInstallLevel(MSIPACKAGE *package, int iInstallLevel)
Definition: install.c:1572
UINT WINAPI MsiGetFeatureStateA(MSIHANDLE hInstall, LPCSTR szFeature, INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
Definition: install.c:1052
UINT WINAPI MsiSetComponentStateA(MSIHANDLE hInstall, LPCSTR szComponent, INSTALLSTATE iState)
Definition: install.c:1380
static DWORD map_feature_attributes(DWORD attrs)
Definition: install.c:1294
UINT msi_strcpy_to_awstring(const WCHAR *str, int len, awstring *awbuf, DWORD *sz)
Definition: install.c:158
BOOL WINAPI MsiGetMode(MSIHANDLE hInstall, MSIRUNMODE iRunMode)
Definition: install.c:670
#define swprintf
Definition: precomp.h:40
r parent
Definition: btrfs.c:3010
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
GLint level
Definition: gl.h:1546
GLuint GLuint end
Definition: gl.h:1545
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLfloat f
Definition: glext.h:7540
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLsizei len
Definition: glext.h:6722
static const WCHAR titleW[]
Definition: htmlelem.c:1067
static const WCHAR helpW[]
Definition: htmlevent.c:70
uint32_t entry
Definition: isohybrid.c:63
#define f
Definition: ke_i.h:83
#define debugstr_a
Definition: kernel32.h:31
#define debugstr_w
Definition: kernel32.h:32
USHORT LANGID
Definition: mui.h:9
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static HINSTANCE hinst
Definition: edit.c:551
INTERNETFEATURELIST feature
Definition: misc.c:1719
static HWND child
Definition: cursoricon.c:298
#define min(a, b)
Definition: monoChain.cc:55
LANGID langid
Definition: msctf.idl:644
@ INSTALLFEATUREATTRIBUTE_FAVORSOURCE
Definition: msi.h:222
@ INSTALLFEATUREATTRIBUTE_NOUNSUPPORTEDADVERTISE
Definition: msi.h:226
@ INSTALLFEATUREATTRIBUTE_FAVORLOCAL
Definition: msi.h:221
@ INSTALLFEATUREATTRIBUTE_DISALLOWADVERTISE
Definition: msi.h:225
@ INSTALLFEATUREATTRIBUTE_FAVORADVERTISE
Definition: msi.h:224
@ INSTALLFEATUREATTRIBUTE_FOLLOWPARENT
Definition: msi.h:223
@ INSTALLSTATE_UNKNOWN
Definition: msi.h:42
@ INSTALLSTATE_LOCAL
Definition: msi.h:46
@ INSTALLSTATE_ABSENT
Definition: msi.h:45
@ INSTALLSTATE_SOURCE
Definition: msi.h:47
@ INSTALLSTATE_ADVERTISED
Definition: msi.h:44
@ msidbComponentAttributesOptional
Definition: msidefs.h:161
@ msidbComponentAttributesSourceOnly
Definition: msidefs.h:160
@ msidbFeatureAttributesFavorAdvertise
Definition: msidefs.h:151
@ msidbFeatureAttributesFollowParent
Definition: msidefs.h:150
@ msidbFeatureAttributesFavorSource
Definition: msidefs.h:149
@ msidbFeatureAttributesDisallowAdvertise
Definition: msidefs.h:152
@ msidbFeatureAttributesNoUnsupportedAdvertise
Definition: msidefs.h:154
@ msidbFeatureAttributesFavorLocal
Definition: msidefs.h:148
@ msidbSumInfoSourceTypeSFN
Definition: msidefs.h:221
@ msidbSumInfoSourceTypeCompressed
Definition: msidefs.h:222
UINT msi_set_property(MSIDATABASE *, const WCHAR *, const WCHAR *, int) DECLSPEC_HIDDEN
Definition: package.c:2100
static void msi_free(void *mem)
Definition: msipriv.h:1159
static void * msi_alloc(size_t len) __WINE_ALLOC_SIZE(1)
Definition: msipriv.h:1142
int msi_get_property_int(MSIDATABASE *package, LPCWSTR prop, int def) DECLSPEC_HIDDEN
Definition: package.c:2305
LPWSTR msi_dup_property(MSIDATABASE *db, LPCWSTR prop) DECLSPEC_HIDDEN
Definition: package.c:2283
#define MSIHANDLETYPE_PACKAGE
Definition: msipriv.h:726
@ MSICOSTTREE_PARENTS
Definition: msiquery.h:44
@ MSICOSTTREE_CHILDREN
Definition: msiquery.h:43
@ MSICOSTTREE_SELFONLY
Definition: msiquery.h:42
@ MSIRUNMODE_SCHEDULED
Definition: msiquery.h:99
@ MSIRUNMODE_ADVERTISE
Definition: msiquery.h:84
@ MSIRUNMODE_WINDOWS9X
Definition: msiquery.h:95
@ MSIRUNMODE_RESERVED15
Definition: msiquery.h:98
@ MSIRUNMODE_MAINTENANCE
Definition: msiquery.h:85
@ MSIRUNMODE_RESERVED14
Definition: msiquery.h:97
@ MSIRUNMODE_REBOOTATEND
Definition: msiquery.h:89
@ MSIRUNMODE_REBOOTNOW
Definition: msiquery.h:90
@ MSIRUNMODE_ROLLBACK
Definition: msiquery.h:100
@ MSIRUNMODE_LOGENABLED
Definition: msiquery.h:87
@ MSIRUNMODE_OPERATIONS
Definition: msiquery.h:88
@ MSIRUNMODE_ADMIN
Definition: msiquery.h:83
@ MSIRUNMODE_COMMIT
Definition: msiquery.h:101
@ MSIRUNMODE_RESERVED11
Definition: msiquery.h:94
@ MSIRUNMODE_ROLLBACKENABLED
Definition: msiquery.h:86
unsigned int UINT
Definition: ndis.h:50
#define FILE_ATTRIBUTE_READONLY
Definition: nt_native.h:702
#define FILE_ATTRIBUTE_OFFLINE
Definition: nt_native.h:712
#define L(x)
Definition: ntvdm.h:50
static char title[]
Definition: ps.c:92
#define __EXCEPT(func)
Definition: exception.h:84
DWORD WINAPI GetVersion()
Definition: redirtest.c:5
const WCHAR * str
_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 LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
#define GetExceptionCode()
Definition: seh.h:27
#define TRACE(s)
Definition: solgame.cpp:4
LPWSTR w
Definition: msipriv.h:743
LPSTR a
Definition: msipriv.h:742
union awstring::@508 str
BOOL unicode
Definition: msipriv.h:740
Definition: fci.c:127
Definition: fci.c:116
Definition: name.c:39
MSICOMPONENT * component
Definition: msipriv.h:554
unsigned int hasLocalFeature
Definition: msipriv.h:545
LPWSTR Component
Definition: msipriv.h:525
INSTALLSTATE Action
Definition: msipriv.h:533
INSTALLSTATE ActionRequest
Definition: msipriv.h:532
INSTALLSTATE Installed
Definition: msipriv.h:531
LPWSTR Directory
Definition: msipriv.h:527
UINT WordCount
Definition: msipriv.h:458
unsigned char commit_action_running
Definition: msipriv.h:467
struct list features
Definition: msipriv.h:402
MSIOBJECTHDR hdr
Definition: msipriv.h:393
struct list files
Definition: msipriv.h:403
MSIDATABASE * db
Definition: msipriv.h:394
unsigned char rollback_action_running
Definition: msipriv.h:468
HANDLE log_file
Definition: msipriv.h:414
unsigned char scheduled_action_running
Definition: msipriv.h:466
unsigned char need_reboot_now
Definition: msipriv.h:470
unsigned char need_reboot_at_end
Definition: msipriv.h:469
uint32_t * LPDWORD
Definition: typedefs.h:59
int32_t INT
Definition: typedefs.h:58
#define INVALID_FILE_ATTRIBUTES
Definition: vfdcmd.c:23
int ret
_In_ FLONG fl
Definition: winddi.h:1279
int * LPINT
Definition: windef.h:178
#define WINAPI
Definition: msvc.h:6
int INSTALLSTATE
Definition: winemsi.idl:31
int MSIRUNMODE
Definition: winemsi.idl:30
int MSICOSTTREE
Definition: winemsi.idl:34
unsigned long MSIHANDLE
Definition: winemsi.idl:27
#define ERROR_DIRECTORY
Definition: winerror.h:295
#define ERROR_UNKNOWN_COMPONENT
Definition: winerror.h:965
#define ERROR_UNKNOWN_FEATURE
Definition: winerror.h:964
#define ERROR_FUNCTION_FAILED
Definition: winerror.h:985
const char * LPCSTR
Definition: xmlstorage.h:183
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185