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 /*
22 * Here are helper functions formally in action.c that are used by a variety of
23 * actions and functions.
24 */
25
26 #include <stdarg.h>
27
28 #include "windef.h"
29 #include "wine/debug.h"
30 #include "msipriv.h"
31 #include "winuser.h"
32 #include "wine/unicode.h"
33 #include "msidefs.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(msi);
36
37 static const WCHAR cszTargetDir[] = {'T','A','R','G','E','T','D','I','R',0};
38 static const WCHAR cszDatabase[]={'D','A','T','A','B','A','S','E',0};
39
40 LPWSTR build_icon_path(MSIPACKAGE *package, LPCWSTR icon_name )
41 {
42 LPWSTR SystemFolder, dest, FilePath;
43
44 static const WCHAR szInstaller[] =
45 {'M','i','c','r','o','s','o','f','t','\\',
46 'I','n','s','t','a','l','l','e','r','\\',0};
47 static const WCHAR szFolder[] =
48 {'A','p','p','D','a','t','a','F','o','l','d','e','r',0};
49
50 SystemFolder = msi_dup_property( package, szFolder );
51
52 dest = build_directory_name(3, SystemFolder, szInstaller, package->ProductCode);
53
54 create_full_pathW(dest);
55
56 FilePath = build_directory_name(2, dest, icon_name);
57
58 msi_free(SystemFolder);
59 msi_free(dest);
60 return FilePath;
61 }
62
63 LPWSTR msi_dup_record_field( MSIRECORD *rec, INT field )
64 {
65 DWORD sz = 0;
66 LPWSTR str;
67 UINT r;
68
69 if (MSI_RecordIsNull( rec, field ))
70 return NULL;
71
72 r = MSI_RecordGetStringW( rec, field, NULL, &sz );
73 if (r != ERROR_SUCCESS)
74 return NULL;
75
76 sz ++;
77 str = msi_alloc( sz * sizeof (WCHAR) );
78 if (!str)
79 return str;
80 str[0] = 0;
81 r = MSI_RecordGetStringW( rec, field, str, &sz );
82 if (r != ERROR_SUCCESS)
83 {
84 ERR("failed to get string!\n");
85 msi_free( str );
86 return NULL;
87 }
88 return str;
89 }
90
91 MSICOMPONENT* get_loaded_component( MSIPACKAGE* package, LPCWSTR Component )
92 {
93 MSICOMPONENT *comp;
94
95 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
96 {
97 if (lstrcmpW(Component,comp->Component)==0)
98 return comp;
99 }
100 return NULL;
101 }
102
103 MSIFEATURE* get_loaded_feature(MSIPACKAGE* package, LPCWSTR Feature )
104 {
105 MSIFEATURE *feature;
106
107 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
108 {
109 if (lstrcmpW( Feature, feature->Feature )==0)
110 return feature;
111 }
112 return NULL;
113 }
114
115 MSIFILE* get_loaded_file( MSIPACKAGE* package, LPCWSTR key )
116 {
117 MSIFILE *file;
118
119 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
120 {
121 if (lstrcmpW( key, file->File )==0)
122 return file;
123 }
124 return NULL;
125 }
126
127 int track_tempfile( MSIPACKAGE *package, LPCWSTR path )
128 {
129 MSITEMPFILE *temp;
130
131 TRACE("%s\n", debugstr_w(path));
132
133 LIST_FOR_EACH_ENTRY( temp, &package->tempfiles, MSITEMPFILE, entry )
134 if (!lstrcmpW( path, temp->Path ))
135 return 0;
136
137 temp = msi_alloc_zero( sizeof (MSITEMPFILE) );
138 if (!temp)
139 return -1;
140
141 list_add_head( &package->tempfiles, &temp->entry );
142 temp->Path = strdupW( path );
143
144 return 0;
145 }
146
147 MSIFOLDER *get_loaded_folder( MSIPACKAGE *package, LPCWSTR dir )
148 {
149 MSIFOLDER *folder;
150
151 LIST_FOR_EACH_ENTRY( folder, &package->folders, MSIFOLDER, entry )
152 {
153 if (lstrcmpW( dir, folder->Directory )==0)
154 return folder;
155 }
156 return NULL;
157 }
158
159 void msi_reset_folders( MSIPACKAGE *package, BOOL source )
160 {
161 MSIFOLDER *folder;
162
163 LIST_FOR_EACH_ENTRY( folder, &package->folders, MSIFOLDER, entry )
164 {
165 if ( source )
166 {
167 msi_free( folder->ResolvedSource );
168 folder->ResolvedSource = NULL;
169 }
170 else
171 {
172 msi_free( folder->ResolvedTarget );
173 folder->ResolvedTarget = NULL;
174 }
175 }
176 }
177
178 static LPWSTR get_source_root( MSIPACKAGE *package )
179 {
180 LPWSTR path, p;
181
182 path = msi_dup_property( package, cszSourceDir );
183 if (path)
184 return path;
185
186 path = msi_dup_property( package, cszDatabase );
187 if (path)
188 {
189 p = strrchrW(path,'\\');
190 if (p)
191 *(p+1) = 0;
192 }
193 return path;
194 }
195
196 /*
197 * clean_spaces_from_path()
198 *
199 * removes spaces from the beginning and end of path segments
200 * removes multiple \\ characters
201 */
202 static void clean_spaces_from_path( LPWSTR p )
203 {
204 LPWSTR q = p;
205 int n, len = 0;
206
207 while (1)
208 {
209 /* copy until the end of the string or a space */
210 while (*p != ' ' && (*q = *p))
211 {
212 p++, len++;
213 /* reduce many backslashes to one */
214 if (*p != '\\' || *q != '\\')
215 q++;
216 }
217
218 /* quit at the end of the string */
219 if (!*p)
220 break;
221
222 /* count the number of spaces */
223 n = 0;
224 while (p[n] == ' ')
225 n++;
226
227 /* if it's leading or trailing space, skip it */
228 if ( len == 0 || p[-1] == '\\' || p[n] == '\\' )
229 p += n;
230 else /* copy n spaces */
231 while (n && (*q++ = *p++)) n--;
232 }
233 }
234
235 LPWSTR resolve_file_source(MSIPACKAGE *package, MSIFILE *file)
236 {
237 LPWSTR p, path;
238
239 TRACE("Working to resolve source of file %s\n", debugstr_w(file->File));
240
241 if (file->IsCompressed)
242 return NULL;
243
244 p = resolve_folder(package, file->Component->Directory,
245 TRUE, FALSE, TRUE, NULL);
246 path = build_directory_name(2, p, file->ShortName);
247
248 if (file->LongName &&
249 GetFileAttributesW(path) == INVALID_FILE_ATTRIBUTES)
250 {
251 msi_free(path);
252 path = build_directory_name(2, p, file->LongName);
253 }
254
255 msi_free(p);
256
257 TRACE("file %s source resolves to %s\n", debugstr_w(file->File),
258 debugstr_w(path));
259
260 return path;
261 }
262
263 LPWSTR resolve_folder(MSIPACKAGE *package, LPCWSTR name, BOOL source,
264 BOOL set_prop, BOOL load_prop, MSIFOLDER **folder)
265 {
266 MSIFOLDER *f;
267 LPWSTR p, path = NULL, parent;
268
269 TRACE("Working to resolve %s\n",debugstr_w(name));
270
271 if (!name)
272 return NULL;
273
274 if (!lstrcmpW(name,cszSourceDir))
275 name = cszTargetDir;
276
277 f = get_loaded_folder( package, name );
278 if (!f)
279 return NULL;
280
281 /* special resolving for Target and Source root dir */
282 if (!strcmpW(name,cszTargetDir))
283 {
284 if (!f->ResolvedTarget && !f->Property)
285 {
286 LPWSTR check_path;
287 check_path = msi_dup_property( package, cszTargetDir );
288 if (!check_path)
289 {
290 check_path = msi_dup_property( package, cszRootDrive );
291 if (set_prop)
292 MSI_SetPropertyW(package,cszTargetDir,check_path);
293 }
294
295 /* correct misbuilt target dir */
296 path = build_directory_name(2, check_path, NULL);
297 clean_spaces_from_path( path );
298 if (strcmpiW(path,check_path)!=0)
299 MSI_SetPropertyW(package,cszTargetDir,path);
300 msi_free(check_path);
301
302 f->ResolvedTarget = path;
303 }
304
305 if (!f->ResolvedSource)
306 f->ResolvedSource = get_source_root( package );
307 }
308
309 if (folder)
310 *folder = f;
311
312 if (!source && f->ResolvedTarget)
313 {
314 path = strdupW( f->ResolvedTarget );
315 TRACE(" already resolved to %s\n",debugstr_w(path));
316 return path;
317 }
318
319 if (source && f->ResolvedSource)
320 {
321 path = strdupW( f->ResolvedSource );
322 TRACE(" (source)already resolved to %s\n",debugstr_w(path));
323 return path;
324 }
325
326 if (!source && f->Property)
327 {
328 path = build_directory_name( 2, f->Property, NULL );
329
330 TRACE(" internally set to %s\n",debugstr_w(path));
331 if (set_prop)
332 MSI_SetPropertyW( package, name, path );
333 return path;
334 }
335
336 if (!source && load_prop && (path = msi_dup_property( package, name )))
337 {
338 f->ResolvedTarget = strdupW( path );
339 TRACE(" property set to %s\n", debugstr_w(path));
340 return path;
341 }
342
343 if (!f->Parent)
344 return path;
345
346 parent = f->Parent;
347
348 TRACE(" ! Parent is %s\n", debugstr_w(parent));
349
350 p = resolve_folder(package, parent, source, set_prop, load_prop, NULL);
351 if (!source)
352 {
353 TRACE(" TargetDefault = %s\n", debugstr_w(f->TargetDefault));
354
355 path = build_directory_name( 3, p, f->TargetDefault, NULL );
356 clean_spaces_from_path( path );
357 f->ResolvedTarget = strdupW( path );
358 TRACE("target -> %s\n", debugstr_w(path));
359 if (set_prop)
360 MSI_SetPropertyW(package,name,path);
361 }
362 else
363 {
364 path = NULL;
365
366 if (package->WordCount & msidbSumInfoSourceTypeCompressed)
367 path = get_source_root( package );
368 else if (package->WordCount & msidbSumInfoSourceTypeSFN)
369 path = build_directory_name( 3, p, f->SourceShortPath, NULL );
370 else
371 path = build_directory_name( 3, p, f->SourceLongPath, NULL );
372
373 TRACE("source -> %s\n", debugstr_w(path));
374 f->ResolvedSource = strdupW( path );
375 }
376 msi_free(p);
377
378 return path;
379 }
380
381 /* wrapper to resist a need for a full rewrite right now */
382 DWORD deformat_string(MSIPACKAGE *package, LPCWSTR ptr, WCHAR** data )
383 {
384 if (ptr)
385 {
386 MSIRECORD *rec = MSI_CreateRecord(1);
387 DWORD size = 0;
388
389 MSI_RecordSetStringW(rec,0,ptr);
390 MSI_FormatRecordW(package,rec,NULL,&size);
391
392 size++;
393 *data = msi_alloc(size*sizeof(WCHAR));
394 if (size > 1)
395 MSI_FormatRecordW(package,rec,*data,&size);
396 else
397 *data[0] = 0;
398
399 msiobj_release( &rec->hdr );
400 return sizeof(WCHAR)*size;
401 }
402
403 *data = NULL;
404 return 0;
405 }
406
407 UINT schedule_action(MSIPACKAGE *package, UINT script, LPCWSTR action)
408 {
409 UINT count;
410 LPWSTR *newbuf = NULL;
411 if (script >= TOTAL_SCRIPTS)
412 {
413 FIXME("Unknown script requested %i\n",script);
414 return ERROR_FUNCTION_FAILED;
415 }
416 TRACE("Scheduling Action %s in script %i\n",debugstr_w(action), script);
417
418 count = package->script->ActionCount[script];
419 package->script->ActionCount[script]++;
420 if (count != 0)
421 newbuf = msi_realloc( package->script->Actions[script],
422 package->script->ActionCount[script]* sizeof(LPWSTR));
423 else
424 newbuf = msi_alloc( sizeof(LPWSTR));
425
426 newbuf[count] = strdupW(action);
427 package->script->Actions[script] = newbuf;
428
429 return ERROR_SUCCESS;
430 }
431
432 void msi_free_action_script(MSIPACKAGE *package, UINT script)
433 {
434 UINT i;
435 for (i = 0; i < package->script->ActionCount[script]; i++)
436 msi_free(package->script->Actions[script][i]);
437
438 msi_free(package->script->Actions[script]);
439 package->script->Actions[script] = NULL;
440 package->script->ActionCount[script] = 0;
441 }
442
443 static void remove_tracked_tempfiles(MSIPACKAGE* package)
444 {
445 struct list *item, *cursor;
446
447 LIST_FOR_EACH_SAFE( item, cursor, &package->tempfiles )
448 {
449 MSITEMPFILE *temp = LIST_ENTRY( item, MSITEMPFILE, entry );
450
451 list_remove( &temp->entry );
452 TRACE("deleting temp file %s\n", debugstr_w( temp->Path ));
453 if (!DeleteFileW( temp->Path ))
454 ERR("failed to delete %s\n", debugstr_w( temp->Path ));
455 msi_free( temp->Path );
456 msi_free( temp );
457 }
458 }
459
460 static void free_feature( MSIFEATURE *feature )
461 {
462 struct list *item, *cursor;
463
464 LIST_FOR_EACH_SAFE( item, cursor, &feature->Children )
465 {
466 FeatureList *fl = LIST_ENTRY( item, FeatureList, entry );
467 list_remove( &fl->entry );
468 msi_free( fl );
469 }
470
471 LIST_FOR_EACH_SAFE( item, cursor, &feature->Components )
472 {
473 ComponentList *cl = LIST_ENTRY( item, ComponentList, entry );
474 list_remove( &cl->entry );
475 msi_free( cl );
476 }
477 msi_free( feature->Feature );
478 msi_free( feature->Feature_Parent );
479 msi_free( feature->Directory );
480 msi_free( feature->Description );
481 msi_free( feature->Title );
482 msi_free( feature );
483 }
484
485 static void free_extension( MSIEXTENSION *ext )
486 {
487 struct list *item, *cursor;
488
489 LIST_FOR_EACH_SAFE( item, cursor, &ext->verbs )
490 {
491 MSIVERB *verb = LIST_ENTRY( item, MSIVERB, entry );
492
493 list_remove( &verb->entry );
494 msi_free( verb->Verb );
495 msi_free( verb->Command );
496 msi_free( verb->Argument );
497 msi_free( verb );
498 }
499
500 msi_free( ext->Extension );
501 msi_free( ext->ProgIDText );
502 msi_free( ext );
503 }
504
505 /* Called when the package is being closed */
506 void ACTION_free_package_structures( MSIPACKAGE* package)
507 {
508 INT i;
509 struct list *item, *cursor;
510
511 TRACE("Freeing package action data\n");
512
513 remove_tracked_tempfiles(package);
514
515 LIST_FOR_EACH_SAFE( item, cursor, &package->features )
516 {
517 MSIFEATURE *feature = LIST_ENTRY( item, MSIFEATURE, entry );
518 list_remove( &feature->entry );
519 free_feature( feature );
520 }
521
522 LIST_FOR_EACH_SAFE( item, cursor, &package->folders )
523 {
524 MSIFOLDER *folder = LIST_ENTRY( item, MSIFOLDER, entry );
525
526 list_remove( &folder->entry );
527 msi_free( folder->Parent );
528 msi_free( folder->Directory );
529 msi_free( folder->TargetDefault );
530 msi_free( folder->SourceLongPath );
531 msi_free( folder->SourceShortPath );
532 msi_free( folder->ResolvedTarget );
533 msi_free( folder->ResolvedSource );
534 msi_free( folder->Property );
535 msi_free( folder );
536 }
537
538 LIST_FOR_EACH_SAFE( item, cursor, &package->components )
539 {
540 MSICOMPONENT *comp = LIST_ENTRY( item, MSICOMPONENT, entry );
541
542 list_remove( &comp->entry );
543 msi_free( comp->Component );
544 msi_free( comp->ComponentId );
545 msi_free( comp->Directory );
546 msi_free( comp->Condition );
547 msi_free( comp->KeyPath );
548 msi_free( comp->FullKeypath );
549 msi_free( comp );
550 }
551
552 LIST_FOR_EACH_SAFE( item, cursor, &package->files )
553 {
554 MSIFILE *file = LIST_ENTRY( item, MSIFILE, entry );
555
556 list_remove( &file->entry );
557 msi_free( file->File );
558 msi_free( file->FileName );
559 msi_free( file->ShortName );
560 msi_free( file->LongName );
561 msi_free( file->Version );
562 msi_free( file->Language );
563 msi_free( file->TargetPath );
564 msi_free( file );
565 }
566
567 /* clean up extension, progid, class and verb structures */
568 LIST_FOR_EACH_SAFE( item, cursor, &package->classes )
569 {
570 MSICLASS *cls = LIST_ENTRY( item, MSICLASS, entry );
571
572 list_remove( &cls->entry );
573 msi_free( cls->clsid );
574 msi_free( cls->Context );
575 msi_free( cls->Description );
576 msi_free( cls->FileTypeMask );
577 msi_free( cls->IconPath );
578 msi_free( cls->DefInprocHandler );
579 msi_free( cls->DefInprocHandler32 );
580 msi_free( cls->Argument );
581 msi_free( cls->ProgIDText );
582 msi_free( cls );
583 }
584
585 LIST_FOR_EACH_SAFE( item, cursor, &package->extensions )
586 {
587 MSIEXTENSION *ext = LIST_ENTRY( item, MSIEXTENSION, entry );
588
589 list_remove( &ext->entry );
590 free_extension( ext );
591 }
592
593 LIST_FOR_EACH_SAFE( item, cursor, &package->progids )
594 {
595 MSIPROGID *progid = LIST_ENTRY( item, MSIPROGID, entry );
596
597 list_remove( &progid->entry );
598 msi_free( progid->ProgID );
599 msi_free( progid->Description );
600 msi_free( progid->IconPath );
601 msi_free( progid );
602 }
603
604 LIST_FOR_EACH_SAFE( item, cursor, &package->mimes )
605 {
606 MSIMIME *mt = LIST_ENTRY( item, MSIMIME, entry );
607
608 list_remove( &mt->entry );
609 msi_free( mt->clsid );
610 msi_free( mt->ContentType );
611 msi_free( mt );
612 }
613
614 LIST_FOR_EACH_SAFE( item, cursor, &package->appids )
615 {
616 MSIAPPID *appid = LIST_ENTRY( item, MSIAPPID, entry );
617
618 list_remove( &appid->entry );
619 msi_free( appid->AppID );
620 msi_free( appid->RemoteServerName );
621 msi_free( appid->LocalServer );
622 msi_free( appid->ServiceParameters );
623 msi_free( appid->DllSurrogate );
624 msi_free( appid );
625 }
626
627 LIST_FOR_EACH_SAFE( item, cursor, &package->sourcelist_info )
628 {
629 MSISOURCELISTINFO *info = LIST_ENTRY( item, MSISOURCELISTINFO, entry );
630
631 list_remove( &info->entry );
632 msi_free( info->value );
633 msi_free( info );
634 }
635
636 LIST_FOR_EACH_SAFE( item, cursor, &package->sourcelist_media )
637 {
638 MSIMEDIADISK *info = LIST_ENTRY( item, MSIMEDIADISK, entry );
639
640 list_remove( &info->entry );
641 msi_free( info->volume_label );
642 msi_free( info->disk_prompt );
643 msi_free( info );
644 }
645
646 if (package->script)
647 {
648 for (i = 0; i < TOTAL_SCRIPTS; i++)
649 msi_free_action_script(package, i);
650
651 for (i = 0; i < package->script->UniqueActionsCount; i++)
652 msi_free(package->script->UniqueActions[i]);
653
654 msi_free(package->script->UniqueActions);
655 msi_free(package->script);
656 }
657
658 if (package->patch)
659 {
660 msi_free(package->patch->patchcode);
661 msi_free(package->patch->transforms);
662 msi_free(package->patch);
663 }
664
665 msi_free(package->BaseURL);
666 msi_free(package->PackagePath);
667 msi_free(package->ProductCode);
668 msi_free(package->ActionFormat);
669 msi_free(package->LastAction);
670
671 /* cleanup control event subscriptions */
672 ControlEvent_CleanupSubscriptions(package);
673 }
674
675 /*
676 * build_directory_name()
677 *
678 * This function is to save messing round with directory names
679 * It handles adding backslashes between path segments,
680 * and can add \ at the end of the directory name if told to.
681 *
682 * It takes a variable number of arguments.
683 * It always allocates a new string for the result, so make sure
684 * to free the return value when finished with it.
685 *
686 * The first arg is the number of path segments that follow.
687 * The arguments following count are a list of path segments.
688 * A path segment may be NULL.
689 *
690 * Path segments will be added with a \ separating them.
691 * A \ will not be added after the last segment, however if the
692 * last segment is NULL, then the last character will be a \
693 *
694 */
695 LPWSTR build_directory_name(DWORD count, ...)
696 {
697 DWORD sz = 1, i;
698 LPWSTR dir;
699 va_list va;
700
701 va_start(va,count);
702 for(i=0; i<count; i++)
703 {
704 LPCWSTR str = va_arg(va,LPCWSTR);
705 if (str)
706 sz += strlenW(str) + 1;
707 }
708 va_end(va);
709
710 dir = msi_alloc(sz*sizeof(WCHAR));
711 dir[0]=0;
712
713 va_start(va,count);
714 for(i=0; i<count; i++)
715 {
716 LPCWSTR str = va_arg(va,LPCWSTR);
717 if (!str)
718 continue;
719 strcatW(dir, str);
720 if( ((i+1)!=count) && dir[strlenW(dir)-1]!='\\')
721 strcatW(dir, szBackSlash);
722 }
723 return dir;
724 }
725
726 /***********************************************************************
727 * create_full_pathW
728 *
729 * Recursively create all directories in the path.
730 *
731 * shamelessly stolen from setupapi/queue.c
732 */
733 BOOL create_full_pathW(const WCHAR *path)
734 {
735 BOOL ret = TRUE;
736 int len;
737 WCHAR *new_path;
738
739 new_path = msi_alloc( (strlenW(path) + 1) * sizeof(WCHAR));
740
741 strcpyW(new_path, path);
742
743 while((len = strlenW(new_path)) && new_path[len - 1] == '\\')
744 new_path[len - 1] = 0;
745
746 while(!CreateDirectoryW(new_path, NULL))
747 {
748 WCHAR *slash;
749 DWORD last_error = GetLastError();
750 if(last_error == ERROR_ALREADY_EXISTS)
751 break;
752
753 if(last_error != ERROR_PATH_NOT_FOUND)
754 {
755 ret = FALSE;
756 break;
757 }
758
759 if(!(slash = strrchrW(new_path, '\\')))
760 {
761 ret = FALSE;
762 break;
763 }
764
765 len = slash - new_path;
766 new_path[len] = 0;
767 if(!create_full_pathW(new_path))
768 {
769 ret = FALSE;
770 break;
771 }
772 new_path[len] = '\\';
773 }
774
775 msi_free(new_path);
776 return ret;
777 }
778
779 void ui_progress(MSIPACKAGE *package, int a, int b, int c, int d )
780 {
781 MSIRECORD * row;
782
783 row = MSI_CreateRecord(4);
784 MSI_RecordSetInteger(row,1,a);
785 MSI_RecordSetInteger(row,2,b);
786 MSI_RecordSetInteger(row,3,c);
787 MSI_RecordSetInteger(row,4,d);
788 MSI_ProcessMessage(package, INSTALLMESSAGE_PROGRESS, row);
789 msiobj_release(&row->hdr);
790
791 msi_dialog_check_messages(NULL);
792 }
793
794 void ui_actiondata(MSIPACKAGE *package, LPCWSTR action, MSIRECORD * record)
795 {
796 static const WCHAR Query_t[] =
797 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
798 '`','A','c','t','i','o', 'n','T','e','x','t','`',' ',
799 'W','H','E','R','E',' ', '`','A','c','t','i','o','n','`',' ','=',
800 ' ','\'','%','s','\'',0};
801 WCHAR message[1024];
802 MSIRECORD * row = 0;
803 DWORD size;
804
805 if (!package->LastAction || strcmpW(package->LastAction,action))
806 {
807 row = MSI_QueryGetRecord(package->db, Query_t, action);
808 if (!row)
809 return;
810
811 if (MSI_RecordIsNull(row,3))
812 {
813 msiobj_release(&row->hdr);
814 return;
815 }
816
817 /* update the cached actionformat */
818 msi_free(package->ActionFormat);
819 package->ActionFormat = msi_dup_record_field(row,3);
820
821 msi_free(package->LastAction);
822 package->LastAction = strdupW(action);
823
824 msiobj_release(&row->hdr);
825 }
826
827 MSI_RecordSetStringW(record,0,package->ActionFormat);
828 size = 1024;
829 MSI_FormatRecordW(package,record,message,&size);
830
831 row = MSI_CreateRecord(1);
832 MSI_RecordSetStringW(row,1,message);
833
834 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, row);
835
836 msiobj_release(&row->hdr);
837 }
838
839 BOOL ACTION_VerifyComponentForAction( const MSICOMPONENT* comp, INSTALLSTATE check )
840 {
841 if (!comp)
842 return FALSE;
843
844 if (comp->ActionRequest == check)
845 return TRUE;
846 else
847 return FALSE;
848 }
849
850 BOOL ACTION_VerifyFeatureForAction( const MSIFEATURE* feature, INSTALLSTATE check )
851 {
852 if (!feature)
853 return FALSE;
854
855 if (feature->ActionRequest == check)
856 return TRUE;
857 else
858 return FALSE;
859 }
860
861 void reduce_to_longfilename(WCHAR* filename)
862 {
863 LPWSTR p = strchrW(filename,'|');
864 if (p)
865 memmove(filename, p+1, (strlenW(p+1)+1)*sizeof(WCHAR));
866 }
867
868 LPWSTR create_component_advertise_string(MSIPACKAGE* package,
869 MSICOMPONENT* component, LPCWSTR feature)
870 {
871 static const WCHAR fmt[] = {'%','s','%','s','%','c','%','s',0};
872 WCHAR productid_85[21], component_85[21];
873 LPWSTR output = NULL;
874 DWORD sz = 0;
875 GUID clsid;
876
877 /* > is used if there is a component GUID and < if not. */
878
879 productid_85[0] = 0;
880 component_85[0] = 0;
881
882 CLSIDFromString(package->ProductCode, &clsid);
883 encode_base85_guid(&clsid, productid_85);
884
885 if (component)
886 {
887 CLSIDFromString(component->ComponentId, &clsid);
888 encode_base85_guid(&clsid, component_85);
889 }
890
891 TRACE("prod=%s feat=%s comp=%s\n", debugstr_w(productid_85),
892 debugstr_w(feature), debugstr_w(component_85));
893
894 sz = 20 + lstrlenW(feature) + 20 + 3;
895
896 output = msi_alloc_zero(sz*sizeof(WCHAR));
897
898 sprintfW(output, fmt, productid_85, feature,
899 component?'>':'<', component_85);
900
901 return output;
902 }
903
904 /* update component state based on a feature change */
905 void ACTION_UpdateComponentStates(MSIPACKAGE *package, LPCWSTR szFeature)
906 {
907 INSTALLSTATE newstate;
908 MSIFEATURE *feature;
909 ComponentList *cl;
910
911 feature = get_loaded_feature(package,szFeature);
912 if (!feature)
913 return;
914
915 newstate = feature->ActionRequest;
916
917 if (newstate == INSTALLSTATE_ABSENT)
918 newstate = INSTALLSTATE_UNKNOWN;
919
920 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
921 {
922 MSICOMPONENT* component = cl->component;
923
924 TRACE("MODIFYING(%i): Component %s (Installed %i, Action %i, Request %i)\n",
925 newstate, debugstr_w(component->Component), component->Installed,
926 component->Action, component->ActionRequest);
927
928 if (!component->Enabled)
929 continue;
930
931 if (newstate == INSTALLSTATE_LOCAL)
932 msi_component_set_state(package, component, INSTALLSTATE_LOCAL);
933 else
934 {
935 ComponentList *clist;
936 MSIFEATURE *f;
937
938 component->hasLocalFeature = FALSE;
939
940 msi_component_set_state(package, component, newstate);
941
942 /*if any other feature wants is local we need to set it local*/
943 LIST_FOR_EACH_ENTRY( f, &package->features, MSIFEATURE, entry )
944 {
945 if ( f->ActionRequest != INSTALLSTATE_LOCAL &&
946 f->ActionRequest != INSTALLSTATE_SOURCE )
947 {
948 continue;
949 }
950
951 LIST_FOR_EACH_ENTRY( clist, &f->Components, ComponentList, entry )
952 {
953 if ( clist->component == component &&
954 (f->ActionRequest == INSTALLSTATE_LOCAL ||
955 f->ActionRequest == INSTALLSTATE_SOURCE) )
956 {
957 TRACE("Saved by %s\n", debugstr_w(f->Feature));
958 component->hasLocalFeature = TRUE;
959
960 if (component->Attributes & msidbComponentAttributesOptional)
961 {
962 if (f->Attributes & msidbFeatureAttributesFavorSource)
963 msi_component_set_state(package, component, INSTALLSTATE_SOURCE);
964 else
965 msi_component_set_state(package, component, INSTALLSTATE_LOCAL);
966 }
967 else if (component->Attributes & msidbComponentAttributesSourceOnly)
968 msi_component_set_state(package, component, INSTALLSTATE_SOURCE);
969 else
970 msi_component_set_state(package, component, INSTALLSTATE_LOCAL);
971 }
972 }
973 }
974 }
975 TRACE("Result (%i): Component %s (Installed %i, Action %i, Request %i)\n",
976 newstate, debugstr_w(component->Component), component->Installed,
977 component->Action, component->ActionRequest);
978 }
979 }
980
981 UINT register_unique_action(MSIPACKAGE *package, LPCWSTR action)
982 {
983 UINT count;
984 LPWSTR *newbuf = NULL;
985
986 if (!package->script)
987 return FALSE;
988
989 TRACE("Registering Action %s as having fun\n",debugstr_w(action));
990
991 count = package->script->UniqueActionsCount;
992 package->script->UniqueActionsCount++;
993 if (count != 0)
994 newbuf = msi_realloc( package->script->UniqueActions,
995 package->script->UniqueActionsCount* sizeof(LPWSTR));
996 else
997 newbuf = msi_alloc( sizeof(LPWSTR));
998
999 newbuf[count] = strdupW(action);
1000 package->script->UniqueActions = newbuf;
1001
1002 return ERROR_SUCCESS;
1003 }
1004
1005 BOOL check_unique_action(const MSIPACKAGE *package, LPCWSTR action)
1006 {
1007 UINT i;
1008
1009 if (!package->script)
1010 return FALSE;
1011
1012 for (i = 0; i < package->script->UniqueActionsCount; i++)
1013 if (!strcmpW(package->script->UniqueActions[i],action))
1014 return TRUE;
1015
1016 return FALSE;
1017 }
1018
1019 WCHAR* generate_error_string(MSIPACKAGE *package, UINT error, DWORD count, ... )
1020 {
1021 static const WCHAR query[] = {'S','E','L','E','C','T',' ','`','M','e','s','s','a','g','e','`',' ','F','R','O','M',' ','`','E','r','r','o','r','`',' ','W','H','E','R','E',' ','`','E','r','r','o','r','`',' ','=',' ','%','i',0};
1022
1023 MSIRECORD *rec;
1024 MSIRECORD *row;
1025 DWORD size = 0;
1026 DWORD i;
1027 va_list va;
1028 LPCWSTR str;
1029 LPWSTR data;
1030
1031 row = MSI_QueryGetRecord(package->db, query, error);
1032 if (!row)
1033 return 0;
1034
1035 rec = MSI_CreateRecord(count+2);
1036
1037 str = MSI_RecordGetString(row,1);
1038 MSI_RecordSetStringW(rec,0,str);
1039 msiobj_release( &row->hdr );
1040 MSI_RecordSetInteger(rec,1,error);
1041
1042 va_start(va,count);
1043 for (i = 0; i < count; i++)
1044 {
1045 str = va_arg(va,LPCWSTR);
1046 MSI_RecordSetStringW(rec,(i+2),str);
1047 }
1048 va_end(va);
1049
1050 MSI_FormatRecordW(package,rec,NULL,&size);
1051
1052 size++;
1053 data = msi_alloc(size*sizeof(WCHAR));
1054 if (size > 1)
1055 MSI_FormatRecordW(package,rec,data,&size);
1056 else
1057 data[0] = 0;
1058 msiobj_release( &rec->hdr );
1059 return data;
1060 }
1061
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.