?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msi: Add an offset to sequence numbers belonging to files added by a patch.
[wine.git] / dlls / msi / action.c
blob145a1a6725d805dd0b1881c57a7ae30af296e65e
1 /*
2 * Implementation of the Microsoft Installer (msi.dll)
3 *
4 * Copyright 2004,2005 Aric Stewart for CodeWeavers
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdarg.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winerror.h"
28 #include "winreg.h"
29 #include "winsvc.h"
30 #include "odbcinst.h"
31 #include "wine/debug.h"
32 #include "msidefs.h"
33 #include "msipriv.h"
34 #include "winuser.h"
35 #include "shlobj.h"
36 #include "objbase.h"
37 #include "mscoree.h"
38 #include "shlwapi.h"
39 #include "wine/unicode.h"
40 #include "winver.h"
41
42 #define REG_PROGRESS_VALUE 13200
43 #define COMPONENT_PROGRESS_VALUE 24000
44
45 WINE_DEFAULT_DEBUG_CHANNEL(msi);
46
47 /*
48 * consts and values used
49 */
50 static const WCHAR c_colon[] = {'C',':','\\',0};
51
52 static const WCHAR szCreateFolders[] =
53 {'C','r','e','a','t','e','F','o','l','d','e','r','s',0};
54 static const WCHAR szCostFinalize[] =
55 {'C','o','s','t','F','i','n','a','l','i','z','e',0};
56 static const WCHAR szWriteRegistryValues[] =
57 {'W','r','i','t','e','R','e','g','i','s','t','r','y','V','a','l','u','e','s',0};
58 static const WCHAR szCostInitialize[] =
59 {'C','o','s','t','I','n','i','t','i','a','l','i','z','e',0};
60 static const WCHAR szFileCost[] =
61 {'F','i','l','e','C','o','s','t',0};
62 static const WCHAR szInstallInitialize[] =
63 {'I','n','s','t','a','l','l','I','n','i','t','i','a','l','i','z','e',0};
64 static const WCHAR szInstallValidate[] =
65 {'I','n','s','t','a','l','l','V','a','l','i','d','a','t','e',0};
66 static const WCHAR szLaunchConditions[] =
67 {'L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','s',0};
68 static const WCHAR szProcessComponents[] =
69 {'P','r','o','c','e','s','s','C','o','m','p','o','n','e','n','t','s',0};
70 static const WCHAR szRegisterTypeLibraries[] =
71 {'R','e','g','i','s','t','e','r','T','y','p','e','L','i','b','r','a','r','i','e','s',0};
72 static const WCHAR szCreateShortcuts[] =
73 {'C','r','e','a','t','e','S','h','o','r','t','c','u','t','s',0};
74 static const WCHAR szPublishProduct[] =
75 {'P','u','b','l','i','s','h','P','r','o','d','u','c','t',0};
76 static const WCHAR szWriteIniValues[] =
77 {'W','r','i','t','e','I','n','i','V','a','l','u','e','s',0};
78 static const WCHAR szSelfRegModules[] =
79 {'S','e','l','f','R','e','g','M','o','d','u','l','e','s',0};
80 static const WCHAR szPublishFeatures[] =
81 {'P','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
82 static const WCHAR szRegisterProduct[] =
83 {'R','e','g','i','s','t','e','r','P','r','o','d','u','c','t',0};
84 static const WCHAR szInstallExecute[] =
85 {'I','n','s','t','a','l','l','E','x','e','c','u','t','e',0};
86 static const WCHAR szInstallExecuteAgain[] =
87 {'I','n','s','t','a','l','l','E','x','e','c','u','t','e','A','g','a','i','n',0};
88 static const WCHAR szInstallFinalize[] =
89 {'I','n','s','t','a','l','l','F','i','n','a','l','i','z','e',0};
90 static const WCHAR szForceReboot[] =
91 {'F','o','r','c','e','R','e','b','o','o','t',0};
92 static const WCHAR szResolveSource[] =
93 {'R','e','s','o','l','v','e','S','o','u','r','c','e',0};
94 static const WCHAR szAllocateRegistrySpace[] =
95 {'A','l','l','o','c','a','t','e','R','e','g','i','s','t','r','y','S','p','a','c','e',0};
96 static const WCHAR szBindImage[] =
97 {'B','i','n','d','I','m','a','g','e',0};
98 static const WCHAR szDeleteServices[] =
99 {'D','e','l','e','t','e','S','e','r','v','i','c','e','s',0};
100 static const WCHAR szDisableRollback[] =
101 {'D','i','s','a','b','l','e','R','o','l','l','b','a','c','k',0};
102 static const WCHAR szExecuteAction[] =
103 {'E','x','e','c','u','t','e','A','c','t','i','o','n',0};
104 static const WCHAR szInstallAdminPackage[] =
105 {'I','n','s','t','a','l','l','A','d','m','i','n','P','a','c','k','a','g','e',0};
106 static const WCHAR szInstallSFPCatalogFile[] =
107 {'I','n','s','t','a','l','l','S','F','P','C','a','t','a','l','o','g','F','i','l','e',0};
108 static const WCHAR szIsolateComponents[] =
109 {'I','s','o','l','a','t','e','C','o','m','p','o','n','e','n','t','s',0};
110 static const WCHAR szMigrateFeatureStates[] =
111 {'M','i','g','r','a','t','e','F','e','a','t','u','r','e','S','t','a','t','e','s',0};
112 static const WCHAR szMsiUnpublishAssemblies[] =
113 {'M','s','i','U','n','p','u','b','l','i','s','h','A','s','s','e','m','b','l','i','e','s',0};
114 static const WCHAR szInstallODBC[] =
115 {'I','n','s','t','a','l','l','O','D','B','C',0};
116 static const WCHAR szInstallServices[] =
117 {'I','n','s','t','a','l','l','S','e','r','v','i','c','e','s',0};
118 static const WCHAR szPatchFiles[] =
119 {'P','a','t','c','h','F','i','l','e','s',0};
120 static const WCHAR szPublishComponents[] =
121 {'P','u','b','l','i','s','h','C','o','m','p','o','n','e','n','t','s',0};
122 static const WCHAR szRegisterComPlus[] =
123 {'R','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
124 static const WCHAR szRegisterUser[] =
125 {'R','e','g','i','s','t','e','r','U','s','e','r',0};
126 static const WCHAR szRemoveEnvironmentStrings[] =
127 {'R','e','m','o','v','e','E','n','v','i','r','o','n','m','e','n','t','S','t','r','i','n','g','s',0};
128 static const WCHAR szRemoveExistingProducts[] =
129 {'R','e','m','o','v','e','E','x','i','s','t','i','n','g','P','r','o','d','u','c','t','s',0};
130 static const WCHAR szRemoveFolders[] =
131 {'R','e','m','o','v','e','F','o','l','d','e','r','s',0};
132 static const WCHAR szRemoveIniValues[] =
133 {'R','e','m','o','v','e','I','n','i','V','a','l','u','e','s',0};
134 static const WCHAR szRemoveODBC[] =
135 {'R','e','m','o','v','e','O','D','B','C',0};
136 static const WCHAR szRemoveRegistryValues[] =
137 {'R','e','m','o','v','e','R','e','g','i','s','t','r','y','V','a','l','u','e','s',0};
138 static const WCHAR szRemoveShortcuts[] =
139 {'R','e','m','o','v','e','S','h','o','r','t','c','u','t','s',0};
140 static const WCHAR szRMCCPSearch[] =
141 {'R','M','C','C','P','S','e','a','r','c','h',0};
142 static const WCHAR szScheduleReboot[] =
143 {'S','c','h','e','d','u','l','e','R','e','b','o','o','t',0};
144 static const WCHAR szSelfUnregModules[] =
145 {'S','e','l','f','U','n','r','e','g','M','o','d','u','l','e','s',0};
146 static const WCHAR szSetODBCFolders[] =
147 {'S','e','t','O','D','B','C','F','o','l','d','e','r','s',0};
148 static const WCHAR szStartServices[] =
149 {'S','t','a','r','t','S','e','r','v','i','c','e','s',0};
150 static const WCHAR szStopServices[] =
151 {'S','t','o','p','S','e','r','v','i','c','e','s',0};
152 static const WCHAR szUnpublishComponents[] =
153 {'U','n','p','u','b','l','i','s','h', 'C','o','m','p','o','n','e','n','t','s',0};
154 static const WCHAR szUnpublishFeatures[] =
155 {'U','n','p','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
156 static const WCHAR szUnregisterComPlus[] =
157 {'U','n','r','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
158 static const WCHAR szUnregisterTypeLibraries[] =
159 {'U','n','r','e','g','i','s','t','e','r','T','y','p','e','L','i','b','r','a','r','i','e','s',0};
160 static const WCHAR szValidateProductID[] =
161 {'V','a','l','i','d','a','t','e','P','r','o','d','u','c','t','I','D',0};
162 static const WCHAR szWriteEnvironmentStrings[] =
163 {'W','r','i','t','e','E','n','v','i','r','o','n','m','e','n','t','S','t','r','i','n','g','s',0};
164
165 static void ui_actionstart(MSIPACKAGE *package, LPCWSTR action)
166 {
167 static const WCHAR Query_t[] =
168 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
169 '`','A','c','t','i','o', 'n','T','e','x','t','`',' ',
170 'W','H','E','R','E', ' ','`','A','c','t','i','o','n','`',' ','=',
171 ' ','\'','%','s','\'',0};
172 MSIRECORD * row;
173
174 row = MSI_QueryGetRecord( package->db, Query_t, action );
175 if (!row)
176 return;
177 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONSTART, row);
178 msiobj_release(&row->hdr);
179 }
180
181 static void ui_actioninfo(MSIPACKAGE *package, LPCWSTR action, BOOL start,
182 UINT rc)
183 {
184 MSIRECORD * row;
185 static const WCHAR template_s[]=
186 {'A','c','t','i','o','n',' ','s','t','a','r','t',' ','%','s',':',' ',
187 '%','s', '.',0};
188 static const WCHAR template_e[]=
189 {'A','c','t','i','o','n',' ','e','n','d','e','d',' ','%','s',':',' ',
190 '%','s', '.',' ','R','e','t','u','r','n',' ','v','a','l','u','e',' ',
191 '%','i','.',0};
192 static const WCHAR format[] =
193 {'H','H','\'',':','\'','m','m','\'',':','\'','s','s',0};
194 WCHAR message[1024];
195 WCHAR timet[0x100];
196
197 GetTimeFormatW(LOCALE_USER_DEFAULT, 0, NULL, format, timet, 0x100);
198 if (start)
199 sprintfW(message,template_s,timet,action);
200 else
201 sprintfW(message,template_e,timet,action,rc);
202
203 row = MSI_CreateRecord(1);
204 MSI_RecordSetStringW(row,1,message);
205
206 MSI_ProcessMessage(package, INSTALLMESSAGE_INFO, row);
207 msiobj_release(&row->hdr);
208 }
209
210 enum parse_state
211 {
212 state_whitespace,
213 state_token,
214 state_quote
215 };
216
217 static int parse_prop( const WCHAR *str, WCHAR *value, int *quotes )
218 {
219 enum parse_state state = state_quote;
220 const WCHAR *p;
221 WCHAR *out = value;
222 int ignore, in_quotes = 0, count = 0, len = 0;
223
224 for (p = str; *p; p++)
225 {
226 ignore = 0;
227 switch (state)
228 {
229 case state_whitespace:
230 switch (*p)
231 {
232 case ' ':
233 if (!count) goto done;
234 in_quotes = 1;
235 ignore = 1;
236 break;
237 case '"':
238 state = state_quote;
239 if (in_quotes) count--;
240 else count++;
241 break;
242 default:
243 state = state_token;
244 if (!count) in_quotes = 0;
245 else in_quotes = 1;
246 len++;
247 break;
248 }
249 break;
250
251 case state_token:
252 switch (*p)
253 {
254 case '"':
255 state = state_quote;
256 if (in_quotes) count--;
257 else count++;
258 break;
259 case ' ':
260 state = state_whitespace;
261 if (!count) goto done;
262 in_quotes = 1;
263 break;
264 default:
265 if (!count) in_quotes = 0;
266 else in_quotes = 1;
267 len++;
268 break;
269 }
270 break;
271
272 case state_quote:
273 switch (*p)
274 {
275 case '"':
276 if (in_quotes) count--;
277 else count++;
278 break;
279 case ' ':
280 state = state_whitespace;
281 if (!count || !len) goto done;
282 in_quotes = 1;
283 break;
284 default:
285 state = state_token;
286 if (!count) in_quotes = 0;
287 else in_quotes = 1;
288 len++;
289 break;
290 }
291 break;
292
293 default: break;
294 }
295 if (!ignore) *out++ = *p;
296 }
297
298 done:
299 if (!len) *value = 0;
300 else *out = 0;
301
302 *quotes = count;
303 return p - str;
304 }
305
306 static void remove_quotes( WCHAR *str )
307 {
308 WCHAR *p = str;
309 int len = strlenW( str );
310
311 while ((p = strchrW( p, '"' )))
312 {
313 memmove( p, p + 1, (len - (p - str)) * sizeof(WCHAR) );
314 p++;
315 }
316 }
317
318 UINT msi_parse_command_line( MSIPACKAGE *package, LPCWSTR szCommandLine,
319 BOOL preserve_case )
320 {
321 LPCWSTR ptr, ptr2;
322 int quotes;
323 DWORD len;
324 WCHAR *prop, *val;
325 UINT r;
326
327 if (!szCommandLine)
328 return ERROR_SUCCESS;
329
330 ptr = szCommandLine;
331 while (*ptr)
332 {
333 while (*ptr == ' ') ptr++;
334 if (!*ptr) break;
335
336 ptr2 = strchrW( ptr, '=' );
337 if (!ptr2) return ERROR_INVALID_COMMAND_LINE;
338
339 len = ptr2 - ptr;
340 if (!len) return ERROR_INVALID_COMMAND_LINE;
341
342 prop = msi_alloc( (len + 1) * sizeof(WCHAR) );
343 memcpy( prop, ptr, len * sizeof(WCHAR) );
344 prop[len] = 0;
345 if (!preserve_case) struprW( prop );
346
347 ptr2++;
348 while (*ptr2 == ' ') ptr2++;
349
350 quotes = 0;
351 val = msi_alloc( (strlenW( ptr2 ) + 1) * sizeof(WCHAR) );
352 len = parse_prop( ptr2, val, &quotes );
353 if (quotes % 2)
354 {
355 WARN("unbalanced quotes\n");
356 msi_free( val );
357 msi_free( prop );
358 return ERROR_INVALID_COMMAND_LINE;
359 }
360 remove_quotes( val );
361 TRACE("Found commandline property %s = %s\n", debugstr_w(prop), debugstr_w(val));
362
363 r = msi_set_property( package->db, prop, val );
364 if (r == ERROR_SUCCESS && !strcmpW( prop, cszSourceDir ))
365 msi_reset_folders( package, TRUE );
366
367 msi_free( val );
368 msi_free( prop );
369
370 ptr = ptr2 + len;
371 }
372
373 return ERROR_SUCCESS;
374 }
375
376 WCHAR **msi_split_string( const WCHAR *str, WCHAR sep )
377 {
378 LPCWSTR pc;
379 LPWSTR p, *ret = NULL;
380 UINT count = 0;
381
382 if (!str)
383 return ret;
384
385 /* count the number of substrings */
386 for ( pc = str, count = 0; pc; count++ )
387 {
388 pc = strchrW( pc, sep );
389 if (pc)
390 pc++;
391 }
392
393 /* allocate space for an array of substring pointers and the substrings */
394 ret = msi_alloc( (count+1) * sizeof (LPWSTR) +
395 (lstrlenW(str)+1) * sizeof(WCHAR) );
396 if (!ret)
397 return ret;
398
399 /* copy the string and set the pointers */
400 p = (LPWSTR) &ret[count+1];
401 lstrcpyW( p, str );
402 for( count = 0; (ret[count] = p); count++ )
403 {
404 p = strchrW( p, sep );
405 if (p)
406 *p++ = 0;
407 }
408
409 return ret;
410 }
411
412 static UINT msi_check_transform_applicable( MSIPACKAGE *package, IStorage *patch )
413 {
414 static const WCHAR szSystemLanguageID[] =
415 { 'S','y','s','t','e','m','L','a','n','g','u','a','g','e','I','D',0 };
416
417 LPWSTR prod_code, patch_product, langid = NULL, template = NULL;
418 UINT ret = ERROR_FUNCTION_FAILED;
419
420 prod_code = msi_dup_property( package->db, szProductCode );
421 patch_product = msi_get_suminfo_product( patch );
422
423 TRACE("db = %s patch = %s\n", debugstr_w(prod_code), debugstr_w(patch_product));
424
425 if ( strstrW( patch_product, prod_code ) )
426 {
427 MSISUMMARYINFO *si;
428 const WCHAR *p;
429
430 si = MSI_GetSummaryInformationW( patch, 0 );
431 if (!si)
432 {
433 ERR("no summary information!\n");
434 goto end;
435 }
436
437 template = msi_suminfo_dup_string( si, PID_TEMPLATE );
438 if (!template)
439 {
440 ERR("no template property!\n");
441 msiobj_release( &si->hdr );
442 goto end;
443 }
444
445 if (!template[0])
446 {
447 ret = ERROR_SUCCESS;
448 msiobj_release( &si->hdr );
449 goto end;
450 }
451
452 langid = msi_dup_property( package->db, szSystemLanguageID );
453 if (!langid)
454 {
455 msiobj_release( &si->hdr );
456 goto end;
457 }
458
459 p = strchrW( template, ';' );
460 if (p && (!strcmpW( p + 1, langid ) || !strcmpW( p + 1, szZero )))
461 {
462 TRACE("applicable transform\n");
463 ret = ERROR_SUCCESS;
464 }
465
466 /* FIXME: check platform */
467
468 msiobj_release( &si->hdr );
469 }
470
471 end:
472 msi_free( patch_product );
473 msi_free( prod_code );
474 msi_free( template );
475 msi_free( langid );
476
477 return ret;
478 }
479
480 static UINT msi_apply_substorage_transform( MSIPACKAGE *package,
481 MSIDATABASE *patch_db, LPCWSTR name )
482 {
483 UINT ret = ERROR_FUNCTION_FAILED;
484 IStorage *stg = NULL;
485 HRESULT r;
486
487 TRACE("%p %s\n", package, debugstr_w(name) );
488
489 if (*name++ != ':')
490 {
491 ERR("expected a colon in %s\n", debugstr_w(name));
492 return ERROR_FUNCTION_FAILED;
493 }
494
495 r = IStorage_OpenStorage( patch_db->storage, name, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &stg );
496 if (SUCCEEDED(r))
497 {
498 ret = msi_check_transform_applicable( package, stg );
499 if (ret == ERROR_SUCCESS)
500 msi_table_apply_transform( package->db, stg );
501 else
502 TRACE("substorage transform %s wasn't applicable\n", debugstr_w(name));
503 IStorage_Release( stg );
504 }
505 else
506 ERR("failed to open substorage %s\n", debugstr_w(name));
507
508 return ERROR_SUCCESS;
509 }
510
511 UINT msi_check_patch_applicable( MSIPACKAGE *package, MSISUMMARYINFO *si )
512 {
513 LPWSTR guid_list, *guids, product_code;
514 UINT i, ret = ERROR_FUNCTION_FAILED;
515
516 product_code = msi_dup_property( package->db, szProductCode );
517 if (!product_code)
518 {
519 /* FIXME: the property ProductCode should be written into the DB somewhere */
520 ERR("no product code to check\n");
521 return ERROR_SUCCESS;
522 }
523
524 guid_list = msi_suminfo_dup_string( si, PID_TEMPLATE );
525 guids = msi_split_string( guid_list, ';' );
526 for ( i = 0; guids[i] && ret != ERROR_SUCCESS; i++ )
527 {
528 if (!strcmpW( guids[i], product_code ))
529 ret = ERROR_SUCCESS;
530 }
531 msi_free( guids );
532 msi_free( guid_list );
533 msi_free( product_code );
534
535 return ret;
536 }
537
538 static UINT msi_set_media_source_prop(MSIPACKAGE *package)
539 {
540 MSIQUERY *view;
541 MSIRECORD *rec = NULL;
542 LPWSTR patch;
543 LPCWSTR prop;
544 UINT r;
545
546 static const WCHAR query[] = {'S','E','L','E','C','T',' ',
547 '`','S','o','u','r','c','e','`',' ','F','R','O','M',' ',
548 '`','M','e','d','i','a','`',' ','W','H','E','R','E',' ',
549 '`','S','o','u','r','c','e','`',' ','I','S',' ',
550 'N','O','T',' ','N','U','L','L',0};
551
552 r = MSI_DatabaseOpenViewW(package->db, query, &view);
553 if (r != ERROR_SUCCESS)
554 return r;
555
556 r = MSI_ViewExecute(view, 0);
557 if (r != ERROR_SUCCESS)
558 goto done;
559
560 if (MSI_ViewFetch(view, &rec) == ERROR_SUCCESS)
561 {
562 prop = MSI_RecordGetString(rec, 1);
563 patch = msi_dup_property(package->db, szPatch);
564 msi_set_property(package->db, prop, patch);
565 msi_free(patch);
566 }
567
568 done:
569 if (rec) msiobj_release(&rec->hdr);
570 msiobj_release(&view->hdr);
571
572 return r;
573 }
574
575 UINT msi_parse_patch_summary( MSISUMMARYINFO *si, MSIPATCHINFO **patch )
576 {
577 MSIPATCHINFO *pi;
578 UINT r = ERROR_SUCCESS;
579 WCHAR *p;
580
581 pi = msi_alloc_zero( sizeof(MSIPATCHINFO) );
582 if (!pi)
583 return ERROR_OUTOFMEMORY;
584
585 pi->patchcode = msi_suminfo_dup_string( si, PID_REVNUMBER );
586 if (!pi->patchcode)
587 {
588 msi_free( pi );
589 return ERROR_OUTOFMEMORY;
590 }
591
592 p = pi->patchcode;
593 if (*p != '{')
594 {
595 msi_free( pi->patchcode );
596 msi_free( pi );
597 return ERROR_PATCH_PACKAGE_INVALID;
598 }
599
600 p = strchrW( p + 1, '}' );
601 if (!p)
602 {
603 msi_free( pi->patchcode );
604 msi_free( pi );
605 return ERROR_PATCH_PACKAGE_INVALID;
606 }
607
608 if (p[1])
609 {
610 FIXME("patch obsoletes %s\n", debugstr_w(p + 1));
611 p[1] = 0;
612 }
613
614 TRACE("patch code %s\n", debugstr_w(pi->patchcode));
615
616 pi->transforms = msi_suminfo_dup_string( si, PID_LASTAUTHOR );
617 if (!pi->transforms)
618 {
619 msi_free( pi->patchcode );
620 msi_free( pi );
621 return ERROR_OUTOFMEMORY;
622 }
623
624 *patch = pi;
625 return r;
626 }
627
628 struct msi_patch_offset
629 {
630 struct list entry;
631 LPWSTR Name;
632 UINT Sequence;
633 };
634
635 struct msi_patch_offset_list
636 {
637 struct list files;
638 UINT count, min, max;
639 UINT offset_to_apply;
640 };
641
642 static struct msi_patch_offset_list *msi_patch_offset_list_create(void)
643 {
644 struct msi_patch_offset_list *pos = msi_alloc(sizeof(struct msi_patch_offset_list));
645 list_init( &pos->files );
646 pos->count = pos->max = 0;
647 pos->min = 999999;
648
649 return pos;
650 }
651
652 static void msi_patch_offset_list_free(struct msi_patch_offset_list *pos)
653 {
654 struct msi_patch_offset *po, *po2;
655
656 LIST_FOR_EACH_ENTRY_SAFE( po, po2, &pos->files, struct msi_patch_offset, entry )
657 {
658 msi_free( po->Name );
659 msi_free( po );
660 }
661
662 msi_free( pos );
663 }
664
665 static void msi_patch_offset_get_patches(MSIDATABASE *db, UINT last_sequence, struct msi_patch_offset_list *pos)
666 {
667 MSIQUERY *view;
668 MSIRECORD *rec;
669 UINT r;
670 static const WCHAR query_patch[] = {
671 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','P','a','t','c','h',' ',
672 'W','H','E','R','E',' ','S','e','q','u','e','n','c','e',' ','<','=',' ','?',' ',
673 'O','R','D','E','R',' ','B','Y',' ','S','e','q','u','e','n','c','e',0};
674
675 r = MSI_DatabaseOpenViewW( db, query_patch, &view );
676 if (r != ERROR_SUCCESS)
677 return;
678
679 rec = MSI_CreateRecord( 1 );
680 MSI_RecordSetInteger(rec, 1, last_sequence);
681
682 r = MSI_ViewExecute( view, rec );
683 msiobj_release( &rec->hdr );
684 if (r != ERROR_SUCCESS)
685 return;
686
687 while (MSI_ViewFetch(view, &rec) == ERROR_SUCCESS)
688 {
689 UINT sequence = MSI_RecordGetInteger( rec, 2 );
690
691 /* FIXME:
692 * We only use the max/min sequence numbers for now.
693 */
694
695 pos->min = min(pos->min, sequence);
696 pos->max = max(pos->max, sequence);
697 pos->count++;
698
699 msiobj_release( &rec->hdr );
700 }
701
702 msiobj_release( &view->hdr );
703 }
704
705 static void msi_patch_offset_get_files(MSIDATABASE *db, UINT last_sequence, struct msi_patch_offset_list *pos)
706 {
707 MSIQUERY *view;
708 MSIRECORD *rec;
709 UINT r;
710 static const WCHAR query_files[] = {
711 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','F','i','l','e',' ',
712 'W','H','E','R','E',' ','S','e','q','u','e','n','c','e',' ','<','=',' ','?',' ',
713 'O','R','D','E','R',' ','B','Y',' ','S','e','q','u','e','n','c','e',0};
714
715 r = MSI_DatabaseOpenViewW( db, query_files, &view );
716 if (r != ERROR_SUCCESS)
717 return;
718
719 rec = MSI_CreateRecord( 1 );
720 MSI_RecordSetInteger(rec, 1, last_sequence);
721
722 r = MSI_ViewExecute( view, rec );
723 msiobj_release( &rec->hdr );
724 if (r != ERROR_SUCCESS)
725 return;
726
727 while (MSI_ViewFetch(view, &rec) == ERROR_SUCCESS)
728 {
729 UINT attributes = MSI_RecordGetInteger( rec, 7 );
730 if (attributes & msidbFileAttributesPatchAdded)
731 {
732 struct msi_patch_offset *po = msi_alloc(sizeof(struct msi_patch_offset));
733
734 po->Name = msi_dup_record_field( rec, 1 );
735 po->Sequence = MSI_RecordGetInteger( rec, 8 );
736
737 pos->min = min(pos->min, po->Sequence);
738 pos->max = max(pos->max, po->Sequence);
739
740 list_add_tail( &pos->files, &po->entry );
741 pos->count++;
742 }
743 msiobj_release( &rec->hdr );
744 }
745
746 msiobj_release( &view->hdr );
747 }
748
749 static UINT msi_patch_offset_modify_db(MSIDATABASE *db, struct msi_patch_offset_list *pos)
750 {
751 static const WCHAR query_files[] =
752 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','F','i','l','e',' ',
753 'W','H','E','R','E',' ','S','e','q','u','e','n','c','e',' ','>','=',' ','?',' ',
754 'A','N','D',' ','S','e','q','u','e','n','c','e',' ','<','=',' ','?',' ',
755 'O','R','D','E','R',' ','B','Y',' ','S','e','q','u','e','n','c','e',0};
756 struct msi_patch_offset *po;
757 MSIQUERY *view;
758 MSIRECORD *rec;
759 UINT r;
760
761 r = MSI_DatabaseOpenViewW( db, query_files, &view );
762 if (r != ERROR_SUCCESS)
763 return ERROR_SUCCESS;
764
765 rec = MSI_CreateRecord( 2 );
766 MSI_RecordSetInteger( rec, 1, pos->min );
767 MSI_RecordSetInteger( rec, 2, pos->max );
768
769 r = MSI_ViewExecute( view, rec );
770 msiobj_release( &rec->hdr );
771 if (r != ERROR_SUCCESS)
772 goto done;
773
774 LIST_FOR_EACH_ENTRY( po, &pos->files, struct msi_patch_offset, entry )
775 {
776 UINT r_fetch;
777 while ( (r_fetch = MSI_ViewFetch( view, &rec )) == ERROR_SUCCESS )
778 {
779 LPCWSTR file = MSI_RecordGetString( rec, 1 );
780 UINT seq;
781
782 if (!strcmpiW(file, po->Name))
783 {
784 /* Update record */
785 seq = MSI_RecordGetInteger( rec, 8 );
786 MSI_RecordSetInteger( rec, 8, seq + pos->offset_to_apply );
787 r = MSI_ViewModify( view, MSIMODIFY_UPDATE, rec );
788 if (r != ERROR_SUCCESS)
789 ERR("Failed to update offset for file %s.\n", debugstr_w(file));
790
791 msiobj_release( &rec->hdr );
792 break;
793 }
794
795 msiobj_release( &rec->hdr );
796 }
797
798 if (r_fetch != ERROR_SUCCESS)
799 break;
800 }
801
802 done:
803 msiobj_release( &view->hdr );
804
805 return ERROR_SUCCESS;
806 }
807
808 static UINT msi_set_patch_offsets(MSIDATABASE *db)
809 {
810 static const WCHAR query_media[] = {
811 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','M','e','d','i','a',' ',
812 'W','H','E','R','E',' ','S','o','u','r','c','e',' ','I','S',' ','N','O','T',' ','N','U','L','L',
813 ' ','A','N','D',' ','C','a','b','i','n','e','t',' ','I','S',' ','N','O','T',' ','N','U','L','L',' ',
814 'O','R','D','E','R',' ','B','Y',' ','D','i','s','k','I','d',0};
815 MSIQUERY *view = NULL;
816 MSIRECORD *rec = NULL;
817 UINT r;
818
819 r = MSI_DatabaseOpenViewW( db, query_media, &view );
820 if (r != ERROR_SUCCESS)
821 return r;
822
823 r = MSI_ViewExecute( view, 0 );
824 if (r != ERROR_SUCCESS)
825 goto done;
826
827 while (MSI_ViewFetch( view, &rec ) == ERROR_SUCCESS)
828 {
829 UINT last_sequence = MSI_RecordGetInteger( rec, 2 );
830 struct msi_patch_offset_list *pos;
831
832 /* FIXME: Set/Check Source field instead? */
833 if (last_sequence >= MSI_INITIAL_MEDIA_TRANSFORM_OFFSET)
834 {
835 msiobj_release( &rec->hdr );
836 continue;
837 }
838
839 pos = msi_patch_offset_list_create();
840
841 msi_patch_offset_get_files( db, last_sequence, pos );
842 msi_patch_offset_get_patches( db, last_sequence, pos );
843
844 if (pos->count)
845 {
846 UINT offset = db->media_transform_offset - pos->min;
847 last_sequence = offset + pos->max;
848
849 /* FIXME:
850 * This is for the patch table, which is not yet properly transformed.
851 */
852 last_sequence += pos->min;
853
854 pos->offset_to_apply = offset;
855 msi_patch_offset_modify_db( db, pos );
856
857 MSI_RecordSetInteger( rec, 2, last_sequence );
858 r = MSI_ViewModify( view, MSIMODIFY_UPDATE, rec );
859 if (r != ERROR_SUCCESS)
860 ERR("Failed to update Media table entry, expect breakage (%u).\n", r);
861
862 db->media_transform_offset = last_sequence + 1;
863 }
864
865 msi_patch_offset_list_free( pos );
866 msiobj_release( &rec->hdr );
867 }
868
869 done:
870 msiobj_release( &view->hdr );
871
872 return r;
873 }
874
875 UINT msi_apply_patch_db( MSIPACKAGE *package, MSIDATABASE *patch_db, MSIPATCHINFO *patch )
876 {
877 UINT i, r = ERROR_SUCCESS;
878 WCHAR **substorage;
879
880 /* apply substorage transforms */
881 substorage = msi_split_string( patch->transforms, ';' );
882 for (i = 0; substorage && substorage[i] && r == ERROR_SUCCESS; i++)
883 {
884 r = msi_apply_substorage_transform( package, patch_db, substorage[i] );
885 if (r == ERROR_SUCCESS)
886 msi_set_patch_offsets( package->db );
887 }
888
889 msi_free( substorage );
890 if (r != ERROR_SUCCESS)
891 return r;
892
893 msi_set_media_source_prop( package );
894
895 /*
896 * There might be a CAB file in the patch package,
897 * so append it to the list of storages to search for streams.
898 */
899 append_storage_to_db( package->db, patch_db->storage );
900
901 patch->state = MSIPATCHSTATE_APPLIED;
902 list_add_tail( &package->patches, &patch->entry );
903 return ERROR_SUCCESS;
904 }
905
906 static UINT msi_apply_patch_package( MSIPACKAGE *package, LPCWSTR file )
907 {
908 static const WCHAR dotmsp[] = {'.','m','s','p',0};
909 MSIDATABASE *patch_db = NULL;
910 WCHAR localfile[MAX_PATH];
911 MSISUMMARYINFO *si;
912 MSIPATCHINFO *patch = NULL;
913 UINT r = ERROR_SUCCESS;
914
915 TRACE("%p %s\n", package, debugstr_w( file ) );
916
917 r = MSI_OpenDatabaseW( file, MSIDBOPEN_READONLY + MSIDBOPEN_PATCHFILE, &patch_db );
918 if ( r != ERROR_SUCCESS )
919 {
920 ERR("failed to open patch collection %s\n", debugstr_w( file ) );
921 return r;
922 }
923
924 si = MSI_GetSummaryInformationW( patch_db->storage, 0 );
925 if (!si)
926 {
927 msiobj_release( &patch_db->hdr );
928 return ERROR_FUNCTION_FAILED;
929 }
930
931 r = msi_check_patch_applicable( package, si );
932 if (r != ERROR_SUCCESS)
933 {
934 TRACE("patch not applicable\n");
935 r = ERROR_SUCCESS;
936 goto done;
937 }
938
939 r = msi_parse_patch_summary( si, &patch );
940 if ( r != ERROR_SUCCESS )
941 goto done;
942
943 r = msi_get_local_package_name( localfile, dotmsp );
944 if ( r != ERROR_SUCCESS )
945 goto done;
946
947 TRACE("copying to local package %s\n", debugstr_w(localfile));
948
949 if (!CopyFileW( file, localfile, FALSE ))
950 {
951 ERR("Unable to copy package (%s -> %s) (error %u)\n",
952 debugstr_w(file), debugstr_w(localfile), GetLastError());
953 r = GetLastError();
954 goto done;
955 }
956 patch->localfile = strdupW( localfile );
957
958 r = msi_apply_patch_db( package, patch_db, patch );
959 if ( r != ERROR_SUCCESS )
960 WARN("patch failed to apply %u\n", r);
961
962 done:
963 msiobj_release( &si->hdr );
964 msiobj_release( &patch_db->hdr );
965 if (patch && r != ERROR_SUCCESS)
966 {
967 if (patch->localfile)
968 DeleteFileW( patch->localfile );
969
970 msi_free( patch->patchcode );
971 msi_free( patch->transforms );
972 msi_free( patch->localfile );
973 msi_free( patch );
974 }
975 return r;
976 }
977
978 /* get the PATCH property, and apply all the patches it specifies */
979 static UINT msi_apply_patches( MSIPACKAGE *package )
980 {
981 LPWSTR patch_list, *patches;
982 UINT i, r = ERROR_SUCCESS;
983
984 patch_list = msi_dup_property( package->db, szPatch );
985
986 TRACE("patches to be applied: %s\n", debugstr_w( patch_list ) );
987
988 patches = msi_split_string( patch_list, ';' );
989 for( i=0; patches && patches[i] && r == ERROR_SUCCESS; i++ )
990 r = msi_apply_patch_package( package, patches[i] );
991
992 msi_free( patches );
993 msi_free( patch_list );
994
995 return r;
996 }
997
998 static UINT msi_apply_transforms( MSIPACKAGE *package )
999 {
1000 static const WCHAR szTransforms[] = {
1001 'T','R','A','N','S','F','O','R','M','S',0 };
1002 LPWSTR xform_list, *xforms;
1003 UINT i, r = ERROR_SUCCESS;
1004
1005 xform_list = msi_dup_property( package->db, szTransforms );
1006 xforms = msi_split_string( xform_list, ';' );
1007
1008 for( i=0; xforms && xforms[i] && r == ERROR_SUCCESS; i++ )
1009 {
1010 if (xforms[i][0] == ':')
1011 r = msi_apply_substorage_transform( package, package->db, xforms[i] );
1012 else
1013 {
1014 WCHAR *transform;
1015
1016 if (!PathIsRelativeW( xforms[i] )) transform = xforms[i];
1017 else
1018 {
1019 WCHAR *p = strrchrW( package->PackagePath, '\\' );
1020 DWORD len = p - package->PackagePath + 1;
1021
1022 if (!(transform = msi_alloc( (len + strlenW( xforms[i] ) + 1) * sizeof(WCHAR)) ))
1023 {
1024 msi_free( xforms );
1025 msi_free( xform_list );
1026 return ERROR_OUTOFMEMORY;
1027 }
1028 memcpy( transform, package->PackagePath, len * sizeof(WCHAR) );
1029 memcpy( transform + len, xforms[i], (strlenW( xforms[i] ) + 1) * sizeof(WCHAR) );
1030 }
1031 r = MSI_DatabaseApplyTransformW( package->db, transform, 0 );
1032 if (transform != xforms[i]) msi_free( transform );
1033 }
1034 }
1035
1036 msi_free( xforms );
1037 msi_free( xform_list );
1038
1039 return r;
1040 }
1041
1042 static BOOL ui_sequence_exists( MSIPACKAGE *package )
1043 {
1044 MSIQUERY *view;
1045 UINT rc;
1046
1047 static const WCHAR ExecSeqQuery [] =
1048 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1049 '`','I','n','s','t','a','l','l',
1050 'U','I','S','e','q','u','e','n','c','e','`',
1051 ' ','W','H','E','R','E',' ',
1052 '`','S','e','q','u','e','n','c','e','`',' ',
1053 '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
1054 '`','S','e','q','u','e','n','c','e','`',0};
1055
1056 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
1057 if (rc == ERROR_SUCCESS)
1058 {
1059 msiobj_release(&view->hdr);
1060 return TRUE;
1061 }
1062
1063 return FALSE;
1064 }
1065
1066 UINT msi_set_sourcedir_props(MSIPACKAGE *package, BOOL replace)
1067 {
1068 LPWSTR source, check;
1069
1070 if (msi_get_property_int( package->db, szInstalled, 0 ))
1071 {
1072 HKEY hkey;
1073
1074 MSIREG_OpenInstallProps( package->ProductCode, package->Context, NULL, &hkey, FALSE );
1075 source = msi_reg_get_val_str( hkey, INSTALLPROPERTY_INSTALLSOURCEW );
1076 RegCloseKey( hkey );
1077 }
1078 else
1079 {
1080 LPWSTR p, db;
1081 DWORD len;
1082
1083 db = msi_dup_property( package->db, szOriginalDatabase );
1084 if (!db)
1085 return ERROR_OUTOFMEMORY;
1086
1087 p = strrchrW( db, '\\' );
1088 if (!p)
1089 {
1090 p = strrchrW( db, '/' );
1091 if (!p)
1092 {
1093 msi_free(db);
1094 return ERROR_SUCCESS;
1095 }
1096 }
1097
1098 len = p - db + 2;
1099 source = msi_alloc( len * sizeof(WCHAR) );
1100 lstrcpynW( source, db, len );
1101 msi_free( db );
1102 }
1103
1104 check = msi_dup_property( package->db, cszSourceDir );
1105 if (!check || replace)
1106 {
1107 UINT r = msi_set_property( package->db, cszSourceDir, source );
1108 if (r == ERROR_SUCCESS)
1109 msi_reset_folders( package, TRUE );
1110 }
1111 msi_free( check );
1112
1113 check = msi_dup_property( package->db, cszSOURCEDIR );
1114 if (!check || replace)
1115 msi_set_property( package->db, cszSOURCEDIR, source );
1116
1117 msi_free( check );
1118 msi_free( source );
1119
1120 return ERROR_SUCCESS;
1121 }
1122
1123 static BOOL needs_ui_sequence(MSIPACKAGE *package)
1124 {
1125 INT level = msi_get_property_int(package->db, szUILevel, 0);
1126 return (level & INSTALLUILEVEL_MASK) >= INSTALLUILEVEL_REDUCED;
1127 }
1128
1129 UINT msi_set_context(MSIPACKAGE *package)
1130 {
1131 int num;
1132
1133 package->Context = MSIINSTALLCONTEXT_USERUNMANAGED;
1134
1135 num = msi_get_property_int(package->db, szAllUsers, 0);
1136 if (num == 1 || num == 2)
1137 package->Context = MSIINSTALLCONTEXT_MACHINE;
1138
1139 return ERROR_SUCCESS;
1140 }
1141
1142 static UINT ITERATE_Actions(MSIRECORD *row, LPVOID param)
1143 {
1144 UINT rc;
1145 LPCWSTR cond, action;
1146 MSIPACKAGE *package = param;
1147
1148 action = MSI_RecordGetString(row,1);
1149 if (!action)
1150 {
1151 ERR("Error is retrieving action name\n");
1152 return ERROR_FUNCTION_FAILED;
1153 }
1154
1155 /* check conditions */
1156 cond = MSI_RecordGetString(row,2);
1157
1158 /* this is a hack to skip errors in the condition code */
1159 if (MSI_EvaluateConditionW(package, cond) == MSICONDITION_FALSE)
1160 {
1161 TRACE("Skipping action: %s (condition is false)\n", debugstr_w(action));
1162 return ERROR_SUCCESS;
1163 }
1164
1165 if (needs_ui_sequence(package))
1166 rc = ACTION_PerformUIAction(package, action, -1);
1167 else
1168 rc = ACTION_PerformAction(package, action, -1);
1169
1170 msi_dialog_check_messages( NULL );
1171
1172 if (package->CurrentInstallState != ERROR_SUCCESS)
1173 rc = package->CurrentInstallState;
1174
1175 if (rc == ERROR_FUNCTION_NOT_CALLED)
1176 rc = ERROR_SUCCESS;
1177
1178 if (rc != ERROR_SUCCESS)
1179 ERR("Execution halted, action %s returned %i\n", debugstr_w(action), rc);
1180
1181 return rc;
1182 }
1183
1184 UINT MSI_Sequence( MSIPACKAGE *package, LPCWSTR szTable, INT iSequenceMode )
1185 {
1186 MSIQUERY * view;
1187 UINT r;
1188 static const WCHAR query[] =
1189 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1190 '`','%','s','`',
1191 ' ','W','H','E','R','E',' ',
1192 '`','S','e','q','u','e','n','c','e','`',' ',
1193 '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
1194 '`','S','e','q','u','e','n','c','e','`',0};
1195
1196 TRACE("%p %s %i\n", package, debugstr_w(szTable), iSequenceMode );
1197
1198 r = MSI_OpenQuery( package->db, &view, query, szTable );
1199 if (r == ERROR_SUCCESS)
1200 {
1201 r = MSI_IterateRecords( view, NULL, ITERATE_Actions, package );
1202 msiobj_release(&view->hdr);
1203 }
1204
1205 return r;
1206 }
1207
1208 static UINT ACTION_ProcessExecSequence(MSIPACKAGE *package, BOOL UIran)
1209 {
1210 MSIQUERY * view;
1211 UINT rc;
1212 static const WCHAR ExecSeqQuery[] =
1213 {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1214 '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
1215 'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
1216 '`','S','e','q','u','e','n','c','e','`',' ', '>',' ','%','i',' ',
1217 'O','R','D','E','R',' ', 'B','Y',' ',
1218 '`','S','e','q','u','e','n','c','e','`',0 };
1219 static const WCHAR IVQuery[] =
1220 {'S','E','L','E','C','T',' ','`','S','e','q','u','e','n','c','e','`',
1221 ' ', 'F','R','O','M',' ','`','I','n','s','t','a','l','l',
1222 'E','x','e','c','u','t','e','S','e','q','u','e','n','c','e','`',' ',
1223 'W','H','E','R','E',' ','`','A','c','t','i','o','n','`',' ','=',
1224 ' ','\'', 'I','n','s','t','a','l','l',
1225 'V','a','l','i','d','a','t','e','\'', 0};
1226 INT seq = 0;
1227
1228 if (package->script->ExecuteSequenceRun)
1229 {
1230 TRACE("Execute Sequence already Run\n");
1231 return ERROR_SUCCESS;
1232 }
1233
1234 package->script->ExecuteSequenceRun = TRUE;
1235
1236 /* get the sequence number */
1237 if (UIran)
1238 {
1239 MSIRECORD *row = MSI_QueryGetRecord(package->db, IVQuery);
1240 if( !row )
1241 return ERROR_FUNCTION_FAILED;
1242 seq = MSI_RecordGetInteger(row,1);
1243 msiobj_release(&row->hdr);
1244 }
1245
1246 rc = MSI_OpenQuery(package->db, &view, ExecSeqQuery, seq);
1247 if (rc == ERROR_SUCCESS)
1248 {
1249 TRACE("Running the actions\n");
1250
1251 msi_set_property(package->db, cszSourceDir, NULL);
1252
1253 rc = MSI_IterateRecords(view, NULL, ITERATE_Actions, package);
1254 msiobj_release(&view->hdr);
1255 }
1256
1257 return rc;
1258 }
1259
1260 static UINT ACTION_ProcessUISequence(MSIPACKAGE *package)
1261 {
1262 MSIQUERY * view;
1263 UINT rc;
1264 static const WCHAR ExecSeqQuery [] =
1265 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1266 '`','I','n','s','t','a','l','l',
1267 'U','I','S','e','q','u','e','n','c','e','`',
1268 ' ','W','H','E','R','E',' ',
1269 '`','S','e','q','u','e','n','c','e','`',' ',
1270 '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
1271 '`','S','e','q','u','e','n','c','e','`',0};
1272
1273 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
1274 if (rc == ERROR_SUCCESS)
1275 {
1276 TRACE("Running the actions\n");
1277
1278 rc = MSI_IterateRecords(view, NULL, ITERATE_Actions, package);
1279 msiobj_release(&view->hdr);
1280 }
1281
1282 return rc;
1283 }
1284
1285 /********************************************************
1286 * ACTION helper functions and functions that perform the actions
1287 *******************************************************/
1288 static BOOL ACTION_HandleCustomAction( MSIPACKAGE* package, LPCWSTR action,
1289 UINT* rc, UINT script, BOOL force )
1290 {
1291 BOOL ret=FALSE;
1292 UINT arc;
1293
1294 arc = ACTION_CustomAction(package, action, script, force);
1295
1296 if (arc != ERROR_CALL_NOT_IMPLEMENTED)
1297 {
1298 *rc = arc;
1299 ret = TRUE;
1300 }
1301 return ret;
1302 }
1303
1304 /*
1305 * Actual Action Handlers
1306 */
1307
1308 static UINT ITERATE_CreateFolders(MSIRECORD *row, LPVOID param)
1309 {
1310 MSIPACKAGE *package = param;
1311 LPCWSTR dir, component;
1312 LPWSTR full_path;
1313 MSIRECORD *uirow;
1314 MSIFOLDER *folder;
1315 MSICOMPONENT *comp;
1316
1317 component = MSI_RecordGetString(row, 2);
1318 if (!component)
1319 return ERROR_SUCCESS;
1320
1321 comp = get_loaded_component(package, component);
1322 if (!comp)
1323 return ERROR_SUCCESS;
1324
1325 if (!comp->Enabled)
1326 {
1327 TRACE("component is disabled\n");
1328 return ERROR_SUCCESS;
1329 }
1330
1331 if (comp->ActionRequest != INSTALLSTATE_LOCAL)
1332 {
1333 TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
1334 comp->Action = comp->Installed;
1335 return ERROR_SUCCESS;
1336 }
1337 comp->Action = INSTALLSTATE_LOCAL;
1338
1339 dir = MSI_RecordGetString(row,1);
1340 if (!dir)
1341 {
1342 ERR("Unable to get folder id\n");
1343 return ERROR_SUCCESS;
1344 }
1345
1346 uirow = MSI_CreateRecord(1);
1347 MSI_RecordSetStringW(uirow, 1, dir);
1348 ui_actiondata(package, szCreateFolders, uirow);
1349 msiobj_release(&uirow->hdr);
1350
1351 full_path = resolve_target_folder( package, dir, FALSE, TRUE, &folder );
1352 if (!full_path)
1353 {
1354 ERR("Unable to resolve folder id %s\n",debugstr_w(dir));
1355 return ERROR_SUCCESS;
1356 }
1357
1358 TRACE("Folder is %s\n",debugstr_w(full_path));
1359
1360 if (folder->State == 0)
1361 create_full_pathW(full_path);
1362
1363 folder->State = 3;
1364
1365 msi_free(full_path);
1366 return ERROR_SUCCESS;
1367 }
1368
1369 static UINT ACTION_CreateFolders(MSIPACKAGE *package)
1370 {
1371 static const WCHAR query[] =
1372 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1373 '`','C','r','e','a','t','e','F','o','l','d','e','r','`',0};
1374 UINT rc;
1375 MSIQUERY *view;
1376
1377 /* create all the empty folders specified in the CreateFolder table */
1378 rc = MSI_DatabaseOpenViewW(package->db, query, &view );
1379 if (rc != ERROR_SUCCESS)
1380 return ERROR_SUCCESS;
1381
1382 rc = MSI_IterateRecords(view, NULL, ITERATE_CreateFolders, package);
1383 msiobj_release(&view->hdr);
1384
1385 return rc;
1386 }
1387
1388 static UINT ITERATE_RemoveFolders( MSIRECORD *row, LPVOID param )
1389 {
1390 MSIPACKAGE *package = param;
1391 LPCWSTR dir, component;
1392 LPWSTR full_path;
1393 MSIRECORD *uirow;
1394 MSIFOLDER *folder;
1395 MSICOMPONENT *comp;
1396
1397 component = MSI_RecordGetString(row, 2);
1398 if (!component)
1399 return ERROR_SUCCESS;
1400
1401 comp = get_loaded_component(package, component);
1402 if (!comp)
1403 return ERROR_SUCCESS;
1404
1405 if (!comp->Enabled)
1406 {
1407 TRACE("component is disabled\n");
1408 return ERROR_SUCCESS;
1409 }
1410
1411 if (comp->ActionRequest != INSTALLSTATE_ABSENT)
1412 {
1413 TRACE("Component not scheduled for removal: %s\n", debugstr_w(component));
1414 comp->Action = comp->Installed;
1415 return ERROR_SUCCESS;
1416 }
1417 comp->Action = INSTALLSTATE_ABSENT;
1418
1419 dir = MSI_RecordGetString( row, 1 );
1420 if (!dir)
1421 {
1422 ERR("Unable to get folder id\n");
1423 return ERROR_SUCCESS;
1424 }
1425
1426 full_path = resolve_target_folder( package, dir, FALSE, TRUE, &folder );
1427 if (!full_path)
1428 {
1429 ERR("Unable to resolve folder id %s\n", debugstr_w(dir));
1430 return ERROR_SUCCESS;
1431 }
1432
1433 TRACE("folder is %s\n", debugstr_w(full_path));
1434
1435 uirow = MSI_CreateRecord( 1 );
1436 MSI_RecordSetStringW( uirow, 1, dir );
1437 ui_actiondata( package, szRemoveFolders, uirow );
1438 msiobj_release( &uirow->hdr );
1439
1440 RemoveDirectoryW( full_path );
1441 folder->State = 0;
1442
1443 msi_free( full_path );
1444 return ERROR_SUCCESS;
1445 }
1446
1447 static UINT ACTION_RemoveFolders( MSIPACKAGE *package )
1448 {
1449 static const WCHAR query[] =
1450 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1451 '`','C','r','e','a','t','e','F','o','l','d','e','r','`',0};
1452
1453 MSIQUERY *view;
1454 UINT rc;
1455
1456 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
1457 if (rc != ERROR_SUCCESS)
1458 return ERROR_SUCCESS;
1459
1460 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveFolders, package );
1461 msiobj_release( &view->hdr );
1462
1463 return rc;
1464 }
1465
1466 static UINT load_component( MSIRECORD *row, LPVOID param )
1467 {
1468 MSIPACKAGE *package = param;
1469 MSICOMPONENT *comp;
1470
1471 comp = msi_alloc_zero( sizeof(MSICOMPONENT) );
1472 if (!comp)
1473 return ERROR_FUNCTION_FAILED;
1474
1475 list_add_tail( &package->components, &comp->entry );
1476
1477 /* fill in the data */
1478 comp->Component = msi_dup_record_field( row, 1 );
1479
1480 TRACE("Loading Component %s\n", debugstr_w(comp->Component));
1481
1482 comp->ComponentId = msi_dup_record_field( row, 2 );
1483 comp->Directory = msi_dup_record_field( row, 3 );
1484 comp->Attributes = MSI_RecordGetInteger(row,4);
1485 comp->Condition = msi_dup_record_field( row, 5 );
1486 comp->KeyPath = msi_dup_record_field( row, 6 );
1487
1488 comp->Installed = INSTALLSTATE_UNKNOWN;
1489 comp->Action = INSTALLSTATE_UNKNOWN;
1490 comp->ActionRequest = INSTALLSTATE_UNKNOWN;
1491
1492 comp->assembly = load_assembly( package, comp );
1493 return ERROR_SUCCESS;
1494 }
1495
1496 static UINT load_all_components( MSIPACKAGE *package )
1497 {
1498 static const WCHAR query[] = {
1499 'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
1500 '`','C','o','m','p','o','n','e','n','t','`',0 };
1501 MSIQUERY *view;
1502 UINT r;
1503
1504 if (!list_empty(&package->components))
1505 return ERROR_SUCCESS;
1506
1507 r = MSI_DatabaseOpenViewW( package->db, query, &view );
1508 if (r != ERROR_SUCCESS)
1509 return r;
1510
1511 r = MSI_IterateRecords(view, NULL, load_component, package);
1512 msiobj_release(&view->hdr);
1513 return r;
1514 }
1515
1516 typedef struct {
1517 MSIPACKAGE *package;
1518 MSIFEATURE *feature;
1519 } _ilfs;
1520
1521 static UINT add_feature_component( MSIFEATURE *feature, MSICOMPONENT *comp )
1522 {
1523 ComponentList *cl;
1524
1525 cl = msi_alloc( sizeof (*cl) );
1526 if ( !cl )
1527 return ERROR_NOT_ENOUGH_MEMORY;
1528 cl->component = comp;
1529 list_add_tail( &feature->Components, &cl->entry );
1530
1531 return ERROR_SUCCESS;
1532 }
1533
1534 static UINT add_feature_child( MSIFEATURE *parent, MSIFEATURE *child )
1535 {
1536 FeatureList *fl;
1537
1538 fl = msi_alloc( sizeof(*fl) );
1539 if ( !fl )
1540 return ERROR_NOT_ENOUGH_MEMORY;
1541 fl->feature = child;
1542 list_add_tail( &parent->Children, &fl->entry );
1543
1544 return ERROR_SUCCESS;
1545 }
1546
1547 static UINT iterate_load_featurecomponents(MSIRECORD *row, LPVOID param)
1548 {
1549 _ilfs* ilfs = param;
1550 LPCWSTR component;
1551 MSICOMPONENT *comp;
1552
1553 component = MSI_RecordGetString(row,1);
1554
1555 /* check to see if the component is already loaded */
1556 comp = get_loaded_component( ilfs->package, component );
1557 if (!comp)
1558 {
1559 ERR("unknown component %s\n", debugstr_w(component));
1560 return ERROR_FUNCTION_FAILED;
1561 }
1562
1563 add_feature_component( ilfs->feature, comp );
1564 comp->Enabled = TRUE;
1565
1566 return ERROR_SUCCESS;
1567 }
1568
1569 static MSIFEATURE *find_feature_by_name( MSIPACKAGE *package, LPCWSTR name )
1570 {
1571 MSIFEATURE *feature;
1572
1573 if ( !name )
1574 return NULL;
1575
1576 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1577 {
1578 if ( !strcmpW( feature->Feature, name ) )
1579 return feature;
1580 }
1581
1582 return NULL;
1583 }
1584
1585 static UINT load_feature(MSIRECORD * row, LPVOID param)
1586 {
1587 MSIPACKAGE* package = param;
1588 MSIFEATURE* feature;
1589 static const WCHAR Query1[] =
1590 {'S','E','L','E','C','T',' ',
1591 '`','C','o','m','p','o','n','e','n','t','_','`',
1592 ' ','F','R','O','M',' ','`','F','e','a','t','u','r','e',
1593 'C','o','m','p','o','n','e','n','t','s','`',' ',
1594 'W','H','E','R','E',' ',
1595 '`','F','e', 'a','t','u','r','e','_','`',' ','=','\'','%','s','\'',0};
1596 MSIQUERY * view;
1597 UINT rc;
1598 _ilfs ilfs;
1599
1600 /* fill in the data */
1601
1602 feature = msi_alloc_zero( sizeof (MSIFEATURE) );
1603 if (!feature)
1604 return ERROR_NOT_ENOUGH_MEMORY;
1605
1606 list_init( &feature->Children );
1607 list_init( &feature->Components );
1608
1609 feature->Feature = msi_dup_record_field( row, 1 );
1610
1611 TRACE("Loading feature %s\n",debugstr_w(feature->Feature));
1612
1613 feature->Feature_Parent = msi_dup_record_field( row, 2 );
1614 feature->Title = msi_dup_record_field( row, 3 );
1615 feature->Description = msi_dup_record_field( row, 4 );
1616
1617 if (!MSI_RecordIsNull(row,5))
1618 feature->Display = MSI_RecordGetInteger(row,5);
1619
1620 feature->Level= MSI_RecordGetInteger(row,6);
1621 feature->Directory = msi_dup_record_field( row, 7 );
1622 feature->Attributes = MSI_RecordGetInteger(row,8);
1623
1624 feature->Installed = INSTALLSTATE_UNKNOWN;
1625 feature->Action = INSTALLSTATE_UNKNOWN;
1626 feature->ActionRequest = INSTALLSTATE_UNKNOWN;
1627
1628 list_add_tail( &package->features, &feature->entry );
1629
1630 /* load feature components */
1631
1632 rc = MSI_OpenQuery( package->db, &view, Query1, feature->Feature );
1633 if (rc != ERROR_SUCCESS)
1634 return ERROR_SUCCESS;
1635
1636 ilfs.package = package;
1637 ilfs.feature = feature;
1638
1639 MSI_IterateRecords(view, NULL, iterate_load_featurecomponents , &ilfs);
1640 msiobj_release(&view->hdr);
1641
1642 return ERROR_SUCCESS;
1643 }
1644
1645 static UINT find_feature_children(MSIRECORD * row, LPVOID param)
1646 {
1647 MSIPACKAGE* package = param;
1648 MSIFEATURE *parent, *child;
1649
1650 child = find_feature_by_name( package, MSI_RecordGetString( row, 1 ) );
1651 if (!child)
1652 return ERROR_FUNCTION_FAILED;
1653
1654 if (!child->Feature_Parent)
1655 return ERROR_SUCCESS;
1656
1657 parent = find_feature_by_name( package, child->Feature_Parent );
1658 if (!parent)
1659 return ERROR_FUNCTION_FAILED;
1660
1661 add_feature_child( parent, child );
1662 return ERROR_SUCCESS;
1663 }
1664
1665 static UINT load_all_features( MSIPACKAGE *package )
1666 {
1667 static const WCHAR query[] = {
1668 'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1669 '`','F','e','a','t','u','r','e','`',' ','O','R','D','E','R',
1670 ' ','B','Y',' ','`','D','i','s','p','l','a','y','`',0};
1671 MSIQUERY *view;
1672 UINT r;
1673
1674 if (!list_empty(&package->features))
1675 return ERROR_SUCCESS;
1676
1677 r = MSI_DatabaseOpenViewW( package->db, query, &view );
1678 if (r != ERROR_SUCCESS)
1679 return r;
1680
1681 r = MSI_IterateRecords( view, NULL, load_feature, package );
1682 if (r != ERROR_SUCCESS)
1683 return r;
1684
1685 r = MSI_IterateRecords( view, NULL, find_feature_children, package );
1686 msiobj_release( &view->hdr );
1687
1688 return r;
1689 }
1690
1691 static LPWSTR folder_split_path(LPWSTR p, WCHAR ch)
1692 {
1693 if (!p)
1694 return p;
1695 p = strchrW(p, ch);
1696 if (!p)
1697 return p;
1698 *p = 0;
1699 return p+1;
1700 }
1701
1702 static UINT load_file_hash(MSIPACKAGE *package, MSIFILE *file)
1703 {
1704 static const WCHAR query[] = {
1705 'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1706 '`','M','s','i','F','i','l','e','H','a','s','h','`',' ',
1707 'W','H','E','R','E',' ','`','F','i','l','e','_','`',' ','=',' ','\'','%','s','\'',0};
1708 MSIQUERY *view = NULL;
1709 MSIRECORD *row = NULL;
1710 UINT r;
1711
1712 TRACE("%s\n", debugstr_w(file->File));
1713
1714 r = MSI_OpenQuery(package->db, &view, query, file->File);
1715 if (r != ERROR_SUCCESS)
1716 goto done;
1717
1718 r = MSI_ViewExecute(view, NULL);
1719 if (r != ERROR_SUCCESS)
1720 goto done;
1721
1722 r = MSI_ViewFetch(view, &row);
1723 if (r != ERROR_SUCCESS)
1724 goto done;
1725
1726 file->hash.dwFileHashInfoSize = sizeof(MSIFILEHASHINFO);
1727 file->hash.dwData[0] = MSI_RecordGetInteger(row, 3);
1728 file->hash.dwData[1] = MSI_RecordGetInteger(row, 4);
1729 file->hash.dwData[2] = MSI_RecordGetInteger(row, 5);
1730 file->hash.dwData[3] = MSI_RecordGetInteger(row, 6);
1731
1732 done:
1733 if (view) msiobj_release(&view->hdr);
1734 if (row) msiobj_release(&row->hdr);
1735 return r;
1736 }
1737
1738 static UINT load_file_disk_id( MSIPACKAGE *package, MSIFILE *file )
1739 {
1740 MSIRECORD *row;
1741 static const WCHAR query[] = {
1742 'S','E','L','E','C','T',' ','`','D','i','s','k','I','d','`',' ', 'F','R','O','M',' ',
1743 '`','M','e','d','i','a','`',' ','W','H','E','R','E',' ',
1744 '`','L','a','s','t','S','e','q','u','e','n','c','e','`',' ','>','=',' ','%','i',0};
1745
1746 row = MSI_QueryGetRecord( package->db, query, file->Sequence );
1747 if (!row)
1748 {
1749 WARN("query failed\n");
1750 return ERROR_FUNCTION_FAILED;
1751 }
1752
1753 file->disk_id = MSI_RecordGetInteger( row, 1 );
1754 msiobj_release( &row->hdr );
1755 return ERROR_SUCCESS;
1756 }
1757
1758 static UINT load_file(MSIRECORD *row, LPVOID param)
1759 {
1760 MSIPACKAGE* package = param;
1761 LPCWSTR component;
1762 MSIFILE *file;
1763
1764 /* fill in the data */
1765
1766 file = msi_alloc_zero( sizeof (MSIFILE) );
1767 if (!file)
1768 return ERROR_NOT_ENOUGH_MEMORY;
1769
1770 file->File = msi_dup_record_field( row, 1 );
1771
1772 component = MSI_RecordGetString( row, 2 );
1773 file->Component = get_loaded_component( package, component );
1774
1775 if (!file->Component)
1776 {
1777 WARN("Component not found: %s\n", debugstr_w(component));
1778 msi_free(file->File);
1779 msi_free(file);
1780 return ERROR_SUCCESS;
1781 }
1782
1783 file->FileName = msi_dup_record_field( row, 3 );
1784 reduce_to_longfilename( file->FileName );
1785
1786 file->ShortName = msi_dup_record_field( row, 3 );
1787 file->LongName = strdupW( folder_split_path(file->ShortName, '|'));
1788
1789 file->FileSize = MSI_RecordGetInteger( row, 4 );
1790 file->Version = msi_dup_record_field( row, 5 );
1791 file->Language = msi_dup_record_field( row, 6 );
1792 file->Attributes = MSI_RecordGetInteger( row, 7 );
1793 file->Sequence = MSI_RecordGetInteger( row, 8 );
1794
1795 file->state = msifs_invalid;
1796
1797 /* if the compressed bits are not set in the file attributes,
1798 * then read the information from the package word count property
1799 */
1800 if (package->WordCount & msidbSumInfoSourceTypeAdminImage)
1801 {
1802 file->IsCompressed = FALSE;
1803 }
1804 else if (file->Attributes &
1805 (msidbFileAttributesCompressed | msidbFileAttributesPatchAdded))
1806 {
1807 file->IsCompressed = TRUE;
1808 }
1809 else if (file->Attributes & msidbFileAttributesNoncompressed)
1810 {
1811 file->IsCompressed = FALSE;
1812 }
1813 else
1814 {
1815 file->IsCompressed = package->WordCount & msidbSumInfoSourceTypeCompressed;
1816 }
1817
1818 load_file_hash(package, file);
1819 load_file_disk_id(package, file);
1820
1821 TRACE("File Loaded (%s)\n",debugstr_w(file->File));
1822
1823 list_add_tail( &package->files, &file->entry );
1824
1825 return ERROR_SUCCESS;
1826 }
1827
1828 static UINT load_all_files(MSIPACKAGE *package)
1829 {
1830 MSIQUERY * view;
1831 UINT rc;
1832 static const WCHAR Query[] =
1833 {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1834 '`','F','i','l','e','`',' ', 'O','R','D','E','R',' ','B','Y',' ',
1835 '`','S','e','q','u','e','n','c','e','`', 0};
1836
1837 if (!list_empty(&package->files))
1838 return ERROR_SUCCESS;
1839
1840 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
1841 if (rc != ERROR_SUCCESS)
1842 return ERROR_SUCCESS;
1843
1844 rc = MSI_IterateRecords(view, NULL, load_file, package);
1845 msiobj_release(&view->hdr);
1846
1847 return ERROR_SUCCESS;
1848 }
1849
1850 static UINT load_folder( MSIRECORD *row, LPVOID param )
1851 {
1852 MSIPACKAGE *package = param;
1853 static WCHAR szEmpty[] = { 0 };
1854 LPWSTR p, tgt_short, tgt_long, src_short, src_long;
1855 MSIFOLDER *folder;
1856
1857 folder = msi_alloc_zero( sizeof (MSIFOLDER) );
1858 if (!folder)
1859 return ERROR_NOT_ENOUGH_MEMORY;
1860
1861 folder->Directory = msi_dup_record_field( row, 1 );
1862
1863 TRACE("%s\n", debugstr_w(folder->Directory));
1864
1865 p = msi_dup_record_field(row, 3);
1866
1867 /* split src and target dir */
1868 tgt_short = p;
1869 src_short = folder_split_path( p, ':' );
1870
1871 /* split the long and short paths */
1872 tgt_long = folder_split_path( tgt_short, '|' );
1873 src_long = folder_split_path( src_short, '|' );
1874
1875 /* check for no-op dirs */
1876 if (tgt_short && !strcmpW( szDot, tgt_short ))
1877 tgt_short = szEmpty;
1878 if (src_short && !strcmpW( szDot, src_short ))
1879 src_short = szEmpty;
1880
1881 if (!tgt_long)
1882 tgt_long = tgt_short;
1883
1884 if (!src_short) {
1885 src_short = tgt_short;
1886 src_long = tgt_long;
1887 }
1888
1889 if (!src_long)
1890 src_long = src_short;
1891
1892 /* FIXME: use the target short path too */
1893 folder->TargetDefault = strdupW(tgt_long);
1894 folder->SourceShortPath = strdupW(src_short);
1895 folder->SourceLongPath = strdupW(src_long);
1896 msi_free(p);
1897
1898 TRACE("TargetDefault = %s\n",debugstr_w( folder->TargetDefault ));
1899 TRACE("SourceLong = %s\n", debugstr_w( folder->SourceLongPath ));
1900 TRACE("SourceShort = %s\n", debugstr_w( folder->SourceShortPath ));
1901
1902 folder->Parent = msi_dup_record_field( row, 2 );
1903
1904 folder->Property = msi_dup_property( package->db, folder->Directory );
1905
1906 list_add_tail( &package->folders, &folder->entry );
1907
1908 TRACE("returning %p\n", folder);
1909
1910 return ERROR_SUCCESS;
1911 }
1912
1913 static UINT load_all_folders( MSIPACKAGE *package )
1914 {
1915 static const WCHAR query[] = {
1916 'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
1917 '`','D','i','r','e','c','t','o','r','y','`',0 };
1918 MSIQUERY *view;
1919 UINT r;
1920
1921 if (!list_empty(&package->folders))
1922 return ERROR_SUCCESS;
1923
1924 r = MSI_DatabaseOpenViewW( package->db, query, &view );
1925 if (r != ERROR_SUCCESS)
1926 return r;
1927
1928 r = MSI_IterateRecords(view, NULL, load_folder, package);
1929 msiobj_release(&view->hdr);
1930 return r;
1931 }
1932
1933 /*
1934 * I am not doing any of the costing functionality yet.
1935 * Mostly looking at doing the Component and Feature loading
1936 *
1937 * The native MSI does A LOT of modification to tables here. Mostly adding
1938 * a lot of temporary columns to the Feature and Component tables.
1939 *
1940 * note: Native msi also tracks the short filename. But I am only going to
1941 * track the long ones. Also looking at this directory table
1942 * it appears that the directory table does not get the parents
1943 * resolved base on property only based on their entries in the
1944 * directory table.
1945 */
1946 static UINT ACTION_CostInitialize(MSIPACKAGE *package)
1947 {
1948 static const WCHAR szCosting[] =
1949 {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
1950
1951 msi_set_property( package->db, szCosting, szZero );
1952 msi_set_property( package->db, cszRootDrive, c_colon );
1953
1954 load_all_folders( package );
1955 load_all_components( package );
1956 load_all_features( package );
1957 load_all_files( package );
1958
1959 return ERROR_SUCCESS;
1960 }
1961
1962 static UINT execute_script(MSIPACKAGE *package, UINT script )
1963 {
1964 UINT i;
1965 UINT rc = ERROR_SUCCESS;
1966
1967 TRACE("Executing Script %i\n",script);
1968
1969 if (!package->script)
1970 {
1971 ERR("no script!\n");
1972 return ERROR_FUNCTION_FAILED;
1973 }
1974
1975 for (i = 0; i < package->script->ActionCount[script]; i++)
1976 {
1977 LPWSTR action;
1978 action = package->script->Actions[script][i];
1979 ui_actionstart(package, action);
1980 TRACE("Executing Action (%s)\n",debugstr_w(action));
1981 rc = ACTION_PerformAction(package, action, script);
1982 if (rc != ERROR_SUCCESS)
1983 break;
1984 }
1985 msi_free_action_script(package, script);
1986 return rc;
1987 }
1988
1989 static UINT ACTION_FileCost(MSIPACKAGE *package)
1990 {
1991 return ERROR_SUCCESS;
1992 }
1993
1994 static void ACTION_GetComponentInstallStates(MSIPACKAGE *package)
1995 {
1996 MSICOMPONENT *comp;
1997 UINT r;
1998
1999 LIST_FOR_EACH_ENTRY(comp, &package->components, MSICOMPONENT, entry)
2000 {
2001 if (!comp->ComponentId) continue;
2002
2003 r = MsiQueryComponentStateW( package->ProductCode, NULL,
2004 MSIINSTALLCONTEXT_USERMANAGED, comp->ComponentId,
2005 &comp->Installed );
2006 if (r != ERROR_SUCCESS)
2007 r = MsiQueryComponentStateW( package->ProductCode, NULL,
2008 MSIINSTALLCONTEXT_USERUNMANAGED, comp->ComponentId,
2009 &comp->Installed );
2010 if (r != ERROR_SUCCESS)
2011 r = MsiQueryComponentStateW( package->ProductCode, NULL,
2012 MSIINSTALLCONTEXT_MACHINE, comp->ComponentId,
2013 &comp->Installed );
2014 if (r != ERROR_SUCCESS)
2015 comp->Installed = INSTALLSTATE_ABSENT;
2016 }
2017 }
2018
2019 static void ACTION_GetFeatureInstallStates(MSIPACKAGE *package)
2020 {
2021 MSIFEATURE *feature;
2022
2023 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2024 {
2025 INSTALLSTATE state = MsiQueryFeatureStateW( package->ProductCode, feature->Feature );
2026
2027 if (state == INSTALLSTATE_UNKNOWN || state == INSTALLSTATE_INVALIDARG)
2028 feature->Installed = INSTALLSTATE_ABSENT;
2029 else
2030 feature->Installed = state;
2031 }
2032 }
2033
2034 static inline BOOL is_feature_selected( MSIFEATURE *feature, INT level )
2035 {
2036 return (feature->Level > 0 && feature->Level <= level);
2037 }
2038
2039 static BOOL process_state_property(MSIPACKAGE* package, int level,
2040 LPCWSTR property, INSTALLSTATE state)
2041 {
2042 LPWSTR override;
2043 MSIFEATURE *feature;
2044
2045 override = msi_dup_property( package->db, property );
2046 if (!override)
2047 return FALSE;
2048
2049 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2050 {
2051 if (strcmpW( property, szRemove ) && !is_feature_selected( feature, level ))
2052 continue;
2053
2054 if (!strcmpW(property, szReinstall)) state = feature->Installed;
2055
2056 if (!strcmpiW( override, szAll ))
2057 {
2058 if (feature->Installed != state)
2059 {
2060 feature->Action = state;
2061 feature->ActionRequest = state;
2062 }
2063 }
2064 else
2065 {
2066 LPWSTR ptr = override;
2067 LPWSTR ptr2 = strchrW(override,',');
2068
2069 while (ptr)
2070 {
2071 int len = ptr2 - ptr;
2072
2073 if ((ptr2 && strlenW(feature->Feature) == len && !strncmpW(ptr, feature->Feature, len))
2074 || (!ptr2 && !strcmpW(ptr, feature->Feature)))
2075 {
2076 if (feature->Installed != state)
2077 {
2078 feature->Action = state;
2079 feature->ActionRequest = state;
2080 }
2081 break;
2082 }
2083 if (ptr2)
2084 {
2085 ptr=ptr2+1;
2086 ptr2 = strchrW(ptr,',');
2087 }
2088 else
2089 break;
2090 }
2091 }
2092 }
2093 msi_free(override);
2094 return TRUE;
2095 }
2096
2097 static BOOL process_overrides( MSIPACKAGE *package, int level )
2098 {
2099 static const WCHAR szAddLocal[] =
2100 {'A','D','D','L','O','C','A','L',0};
2101 static const WCHAR szAddSource[] =
2102 {'A','D','D','S','O','U','R','C','E',0};
2103 static const WCHAR szAdvertise[] =
2104 {'A','D','V','E','R','T','I','S','E',0};
2105 BOOL ret = FALSE;
2106
2107 /* all these activation/deactivation things happen in order and things
2108 * later on the list override things earlier on the list.
2109 *
2110 * 0 INSTALLLEVEL processing
2111 * 1 ADDLOCAL
2112 * 2 REMOVE
2113 * 3 ADDSOURCE
2114 * 4 ADDDEFAULT
2115 * 5 REINSTALL
2116 * 6 ADVERTISE
2117 * 7 COMPADDLOCAL
2118 * 8 COMPADDSOURCE
2119 * 9 FILEADDLOCAL
2120 * 10 FILEADDSOURCE
2121 * 11 FILEADDDEFAULT
2122 */
2123 ret |= process_state_property( package, level, szAddLocal, INSTALLSTATE_LOCAL );
2124 ret |= process_state_property( package, level, szRemove, INSTALLSTATE_ABSENT );
2125 ret |= process_state_property( package, level, szAddSource, INSTALLSTATE_SOURCE );
2126 ret |= process_state_property( package, level, szReinstall, INSTALLSTATE_UNKNOWN );
2127 ret |= process_state_property( package, level, szAdvertise, INSTALLSTATE_ADVERTISED );
2128
2129 if (ret)
2130 msi_set_property( package->db, szPreselected, szOne );
2131
2132 return ret;
2133 }
2134
2135 UINT MSI_SetFeatureStates(MSIPACKAGE *package)
2136 {
2137 int level;
2138 static const WCHAR szlevel[] =
2139 {'I','N','S','T','A','L','L','L','E','V','E','L',0};
2140 MSICOMPONENT* component;
2141 MSIFEATURE *feature;
2142
2143 TRACE("Checking Install Level\n");
2144
2145 level = msi_get_property_int(package->db, szlevel, 1);
2146
2147 if (!msi_get_property_int( package->db, szPreselected, 0 ))
2148 {
2149 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2150 {
2151 if (!is_feature_selected( feature, level )) continue;
2152
2153 if (feature->ActionRequest == INSTALLSTATE_UNKNOWN)
2154 {
2155 if (feature->Attributes & msidbFeatureAttributesFavorSource)
2156 {
2157 feature->Action = INSTALLSTATE_SOURCE;
2158 feature->ActionRequest = INSTALLSTATE_SOURCE;
2159 }
2160 else if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
2161 {
2162 feature->Action = INSTALLSTATE_ADVERTISED;
2163 feature->ActionRequest = INSTALLSTATE_ADVERTISED;
2164 }
2165 else
2166 {
2167 feature->Action = INSTALLSTATE_LOCAL;
2168 feature->ActionRequest = INSTALLSTATE_LOCAL;
2169 }
2170 }
2171 }
2172
2173 /* disable child features of unselected parent features */
2174 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2175 {
2176 FeatureList *fl;
2177
2178 if (is_feature_selected( feature, level )) continue;
2179
2180 LIST_FOR_EACH_ENTRY( fl, &feature->Children, FeatureList, entry )
2181 {
2182 fl->feature->Action = INSTALLSTATE_UNKNOWN;
2183 fl->feature->ActionRequest = INSTALLSTATE_UNKNOWN;
2184 }
2185 }
2186 }
2187 else /* preselected */
2188 {
2189 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2190 {
2191 if (!is_feature_selected( feature, level )) continue;
2192
2193 if (feature->ActionRequest == INSTALLSTATE_UNKNOWN)
2194 {
2195 if (feature->Installed == INSTALLSTATE_ABSENT)
2196 {
2197 feature->Action = INSTALLSTATE_UNKNOWN;
2198 feature->ActionRequest = INSTALLSTATE_UNKNOWN;
2199 }
2200 else
2201 {
2202 feature->Action = feature->Installed;
2203 feature->ActionRequest = feature->Installed;
2204 }
2205 }
2206 }
2207 }
2208
2209 /* now we want to set component state based based on feature state */
2210 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2211 {
2212 ComponentList *cl;
2213
2214 TRACE("Examining Feature %s (Level %d Installed %d Request %d Action %d)\n",
2215 debugstr_w(feature->Feature), feature->Level, feature->Installed,
2216 feature->ActionRequest, feature->Action);
2217
2218 if (!is_feature_selected( feature, level )) continue;
2219
2220 /* features with components that have compressed files are made local */
2221 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
2222 {
2223 if (cl->component->ForceLocalState &&
2224 feature->ActionRequest == INSTALLSTATE_SOURCE)
2225 {
2226 feature->Action = INSTALLSTATE_LOCAL;
2227 feature->ActionRequest = INSTALLSTATE_LOCAL;
2228 break;
2229 }
2230 }
2231
2232 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
2233 {
2234 component = cl->component;
2235
2236 switch (feature->ActionRequest)
2237 {
2238 case INSTALLSTATE_ABSENT:
2239 component->anyAbsent = 1;
2240 break;
2241 case INSTALLSTATE_ADVERTISED:
2242 component->hasAdvertiseFeature = 1;
2243 break;
2244 case INSTALLSTATE_SOURCE:
2245 component->hasSourceFeature = 1;
2246 break;
2247 case INSTALLSTATE_LOCAL:
2248 component->hasLocalFeature = 1;
2249 break;
2250 case INSTALLSTATE_DEFAULT:
2251 if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
2252 component->hasAdvertiseFeature = 1;
2253 else if (feature->Attributes & msidbFeatureAttributesFavorSource)
2254 component->hasSourceFeature = 1;
2255 else
2256 component->hasLocalFeature = 1;
2257 break;
2258 default:
2259 break;
2260 }
2261 }
2262 }
2263
2264 LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
2265 {
2266 /* check if it's local or source */
2267 if (!(component->Attributes & msidbComponentAttributesOptional) &&
2268 (component->hasLocalFeature || component->hasSourceFeature))
2269 {
2270 if ((component->Attributes & msidbComponentAttributesSourceOnly) &&
2271 !component->ForceLocalState)
2272 {
2273 component->Action = INSTALLSTATE_SOURCE;
2274 component->ActionRequest = INSTALLSTATE_SOURCE;
2275 }
2276 else
2277 {
2278 component->Action = INSTALLSTATE_LOCAL;
2279 component->ActionRequest = INSTALLSTATE_LOCAL;
2280 }
2281 continue;
2282 }
2283
2284 /* if any feature is local, the component must be local too */
2285 if (component->hasLocalFeature)
2286 {
2287 component->Action = INSTALLSTATE_LOCAL;
2288 component->ActionRequest = INSTALLSTATE_LOCAL;
2289 continue;
2290 }
2291 if (component->hasSourceFeature)
2292 {
2293 component->Action = INSTALLSTATE_SOURCE;
2294 component->ActionRequest = INSTALLSTATE_SOURCE;
2295 continue;
2296 }
2297 if (component->hasAdvertiseFeature)
2298 {
2299 component->Action = INSTALLSTATE_ADVERTISED;
2300 component->ActionRequest = INSTALLSTATE_ADVERTISED;
2301 continue;
2302 }
2303 TRACE("nobody wants component %s\n", debugstr_w(component->Component));
2304 if (component->anyAbsent &&
2305 (component->Installed == INSTALLSTATE_LOCAL || component->Installed == INSTALLSTATE_SOURCE))
2306 {
2307 component->Action = INSTALLSTATE_ABSENT;
2308 component->ActionRequest = INSTALLSTATE_ABSENT;
2309 }
2310 }
2311
2312 LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
2313 {
2314 if (component->ActionRequest == INSTALLSTATE_DEFAULT)
2315 {
2316 TRACE("%s was default, setting to local\n", debugstr_w(component->Component));
2317 component->Action = INSTALLSTATE_LOCAL;
2318 component->ActionRequest = INSTALLSTATE_LOCAL;
2319 }
2320
2321 if (component->ActionRequest == INSTALLSTATE_SOURCE &&
2322 component->Installed == INSTALLSTATE_SOURCE &&
2323 component->hasSourceFeature)
2324 {
2325 component->Action = INSTALLSTATE_UNKNOWN;
2326 component->ActionRequest = INSTALLSTATE_UNKNOWN;
2327 }
2328
2329 TRACE("Result: Component %s (Installed %d Request %d Action %d)\n",
2330 debugstr_w(component->Component), component->Installed, component->ActionRequest, component->Action);
2331 }
2332
2333 return ERROR_SUCCESS;
2334 }
2335
2336 static UINT ITERATE_CostFinalizeDirectories(MSIRECORD *row, LPVOID param)
2337 {
2338 MSIPACKAGE *package = param;
2339 LPCWSTR name;
2340 LPWSTR path;
2341 MSIFOLDER *f;
2342
2343 name = MSI_RecordGetString(row,1);
2344
2345 f = get_loaded_folder(package, name);
2346 if (!f) return ERROR_SUCCESS;
2347
2348 /* reset the ResolvedTarget */
2349 msi_free(f->ResolvedTarget);
2350 f->ResolvedTarget = NULL;
2351
2352 TRACE("directory %s ...\n", debugstr_w(name));
2353 path = resolve_target_folder( package, name, TRUE, TRUE, NULL );
2354 TRACE("resolves to %s\n", debugstr_w(path));
2355 msi_free(path);
2356
2357 return ERROR_SUCCESS;
2358 }
2359
2360 static UINT ITERATE_CostFinalizeConditions(MSIRECORD *row, LPVOID param)
2361 {
2362 MSIPACKAGE *package = param;
2363 LPCWSTR name;
2364 MSIFEATURE *feature;
2365
2366 name = MSI_RecordGetString( row, 1 );
2367
2368 feature = get_loaded_feature( package, name );
2369 if (!feature)
2370 ERR("FAILED to find loaded feature %s\n",debugstr_w(name));
2371 else
2372 {
2373 LPCWSTR Condition;
2374 Condition = MSI_RecordGetString(row,3);
2375
2376 if (MSI_EvaluateConditionW(package,Condition) == MSICONDITION_TRUE)
2377 {
2378 int level = MSI_RecordGetInteger(row,2);
2379 TRACE("Resetting feature %s to level %i\n", debugstr_w(name), level);
2380 feature->Level = level;
2381 }
2382 }
2383 return ERROR_SUCCESS;
2384 }
2385
2386 VS_FIXEDFILEINFO *msi_get_disk_file_version( LPCWSTR filename )
2387 {
2388 static const WCHAR name[] = {'\\',0};
2389 VS_FIXEDFILEINFO *ptr, *ret;
2390 LPVOID version;
2391 DWORD versize, handle;
2392 UINT sz;
2393
2394 TRACE("%s\n", debugstr_w(filename));
2395
2396 versize = GetFileVersionInfoSizeW( filename, &handle );
2397 if (!versize)
2398 return NULL;
2399
2400 version = msi_alloc( versize );
2401 if (!version)
2402 return NULL;
2403
2404 GetFileVersionInfoW( filename, 0, versize, version );
2405
2406 if (!VerQueryValueW( version, name, (LPVOID *)&ptr, &sz ))
2407 {
2408 msi_free( version );
2409 return NULL;
2410 }
2411
2412 ret = msi_alloc( sz );
2413 memcpy( ret, ptr, sz );
2414
2415 msi_free( version );
2416 return ret;
2417 }
2418
2419 int msi_compare_file_versions( VS_FIXEDFILEINFO *fi, const WCHAR *version )
2420 {
2421 DWORD ms, ls;
2422
2423 msi_parse_version_string( version, &ms, &ls );
2424
2425 if (fi->dwFileVersionMS > ms) return 1;
2426 else if (fi->dwFileVersionMS < ms) return -1;
2427 else if (fi->dwFileVersionLS > ls) return 1;
2428 else if (fi->dwFileVersionLS < ls) return -1;
2429 return 0;
2430 }
2431
2432 int msi_compare_font_versions( const WCHAR *ver1, const WCHAR *ver2 )
2433 {
2434 DWORD ms1, ms2;
2435
2436 msi_parse_version_string( ver1, &ms1, NULL );
2437 msi_parse_version_string( ver2, &ms2, NULL );
2438
2439 if (ms1 > ms2) return 1;
2440 else if (ms1 < ms2) return -1;
2441 return 0;
2442 }
2443
2444 DWORD msi_get_disk_file_size( LPCWSTR filename )
2445 {
2446 HANDLE file;
2447 DWORD size;
2448
2449 TRACE("%s\n", debugstr_w(filename));
2450
2451 file = CreateFileW( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
2452 if (file == INVALID_HANDLE_VALUE)
2453 return INVALID_FILE_SIZE;
2454
2455 size = GetFileSize( file, NULL );
2456 CloseHandle( file );
2457 return size;
2458 }
2459
2460 BOOL msi_file_hash_matches( MSIFILE *file )
2461 {
2462 UINT r;
2463 MSIFILEHASHINFO hash;
2464
2465 hash.dwFileHashInfoSize = sizeof(MSIFILEHASHINFO);
2466 r = MsiGetFileHashW( file->TargetPath, 0, &hash );
2467 if (r != ERROR_SUCCESS)
2468 return FALSE;
2469
2470 return !memcmp( &hash, &file->hash, sizeof(MSIFILEHASHINFO) );
2471 }
2472
2473 static WCHAR *get_temp_dir( void )
2474 {
2475 static UINT id;
2476 WCHAR tmp[MAX_PATH], dir[MAX_PATH];
2477
2478 GetTempPathW( MAX_PATH, tmp );
2479 for (;;)
2480 {
2481 if (!GetTempFileNameW( tmp, szMsi, ++id, dir )) return NULL;
2482 if (CreateDirectoryW( dir, NULL )) break;
2483 }
2484 return strdupW( dir );
2485 }
2486
2487 static void set_target_path( MSIPACKAGE *package, MSIFILE *file )
2488 {
2489 MSIASSEMBLY *assembly = file->Component->assembly;
2490
2491 TRACE("file %s is named %s\n", debugstr_w(file->File), debugstr_w(file->FileName));
2492
2493 msi_free( file->TargetPath );
2494 if (assembly && !assembly->application)
2495 {
2496 if (!assembly->tempdir) assembly->tempdir = get_temp_dir();
2497 file->TargetPath = build_directory_name( 2, assembly->tempdir, file->FileName );
2498 track_tempfile( package, file->TargetPath );
2499 }
2500 else
2501 {
2502 WCHAR *dir = resolve_target_folder( package, file->Component->Directory, FALSE, TRUE, NULL );
2503 file->TargetPath = build_directory_name( 2, dir, file->FileName );
2504 msi_free( dir );
2505 }
2506
2507 TRACE("resolves to %s\n", debugstr_w(file->TargetPath));
2508 }
2509
2510 static UINT calculate_file_cost( MSIPACKAGE *package )
2511 {
2512 VS_FIXEDFILEINFO *file_version;
2513 WCHAR *font_version;
2514 MSIFILE *file;
2515
2516 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2517 {
2518 MSICOMPONENT *comp = file->Component;
2519 DWORD file_size;
2520
2521 if (!comp->Enabled) continue;
2522
2523 if (file->IsCompressed)
2524 comp->ForceLocalState = TRUE;
2525
2526 set_target_path( package, file );
2527
2528 if ((comp->assembly && !comp->assembly->installed) ||
2529 GetFileAttributesW(file->TargetPath) == INVALID_FILE_ATTRIBUTES)
2530 {
2531 comp->Cost += file->FileSize;
2532 continue;
2533 }
2534 file_size = msi_get_disk_file_size( file->TargetPath );
2535
2536 if (file->Version)
2537 {
2538 if ((file_version = msi_get_disk_file_version( file->TargetPath )))
2539 {
2540 if (msi_compare_file_versions( file_version, file->Version ) < 0)
2541 {
2542 comp->Cost += file->FileSize - file_size;
2543 }
2544 msi_free( file_version );
2545 continue;
2546 }
2547 else if ((font_version = font_version_from_file( file->TargetPath )))
2548 {
2549 if (msi_compare_font_versions( font_version, file->Version ) < 0)
2550 {
2551 comp->Cost += file->FileSize - file_size;
2552 }
2553 msi_free( font_version );
2554 continue;
2555 }
2556 }
2557 if (file_size != file->FileSize)
2558 {
2559 comp->Cost += file->FileSize - file_size;
2560 }
2561 }
2562 return ERROR_SUCCESS;
2563 }
2564
2565 /*
2566 * A lot is done in this function aside from just the costing.
2567 * The costing needs to be implemented at some point but for now I am going
2568 * to focus on the directory building
2569 *
2570 */
2571 static UINT ACTION_CostFinalize(MSIPACKAGE *package)
2572 {
2573 static const WCHAR ExecSeqQuery[] =
2574 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2575 '`','D','i','r','e','c','t','o','r','y','`',0};
2576 static const WCHAR ConditionQuery[] =
2577 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2578 '`','C','o','n','d','i','t','i','o','n','`',0};
2579 static const WCHAR szCosting[] =
2580 {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
2581 static const WCHAR szlevel[] =
2582 {'I','N','S','T','A','L','L','L','E','V','E','L',0};
2583 static const WCHAR szOutOfDiskSpace[] =
2584 {'O','u','t','O','f','D','i','s','k','S','p','a','c','e',0};
2585 MSICOMPONENT *comp;
2586 UINT rc = ERROR_SUCCESS;
2587 MSIQUERY * view;
2588 LPWSTR level;
2589
2590 TRACE("Building Directory properties\n");
2591
2592 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2593 if (rc == ERROR_SUCCESS)
2594 {
2595 rc = MSI_IterateRecords(view, NULL, ITERATE_CostFinalizeDirectories,
2596 package);
2597 msiobj_release(&view->hdr);
2598 }
2599
2600 TRACE("Evaluating component conditions\n");
2601 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2602 {
2603 if (MSI_EvaluateConditionW( package, comp->Condition ) == MSICONDITION_FALSE)
2604 {
2605 TRACE("Disabling component %s\n", debugstr_w(comp->Component));
2606 comp->Enabled = FALSE;
2607 }
2608 else
2609 comp->Enabled = TRUE;
2610 }
2611
2612 /* read components states from the registry */
2613 ACTION_GetComponentInstallStates(package);
2614 ACTION_GetFeatureInstallStates(package);
2615
2616 if (!process_overrides( package, msi_get_property_int( package->db, szlevel, 1 ) ))
2617 {
2618 TRACE("Evaluating feature conditions\n");
2619
2620 rc = MSI_DatabaseOpenViewW( package->db, ConditionQuery, &view );
2621 if (rc == ERROR_SUCCESS)
2622 {
2623 rc = MSI_IterateRecords( view, NULL, ITERATE_CostFinalizeConditions, package );
2624 msiobj_release( &view->hdr );
2625 }
2626 }
2627
2628 TRACE("Calculating file cost\n");
2629 calculate_file_cost( package );
2630
2631 msi_set_property( package->db, szCosting, szOne );
2632 /* set default run level if not set */
2633 level = msi_dup_property( package->db, szlevel );
2634 if (!level)
2635 msi_set_property( package->db, szlevel, szOne );
2636 msi_free(level);
2637
2638 /* FIXME: check volume disk space */
2639 msi_set_property( package->db, szOutOfDiskSpace, szZero );
2640
2641 return MSI_SetFeatureStates(package);
2642 }
2643
2644 /* OK this value is "interpreted" and then formatted based on the
2645 first few characters */
2646 static LPSTR parse_value(MSIPACKAGE *package, LPCWSTR value, DWORD *type,
2647 DWORD *size)
2648 {
2649 LPSTR data = NULL;
2650
2651 if (value[0]=='#' && value[1]!='#' && value[1]!='%')
2652 {
2653 if (value[1]=='x')
2654 {
2655 LPWSTR ptr;
2656 CHAR byte[5];
2657 LPWSTR deformated = NULL;
2658 int count;
2659
2660 deformat_string(package, &value[2], &deformated);
2661
2662 /* binary value type */
2663 ptr = deformated;
2664 *type = REG_BINARY;
2665 if (strlenW(ptr)%2)
2666 *size = (strlenW(ptr)/2)+1;
2667 else
2668 *size = strlenW(ptr)/2;
2669
2670 data = msi_alloc(*size);
2671
2672 byte[0] = '0';
2673 byte[1] = 'x';
2674 byte[4] = 0;
2675 count = 0;
2676 /* if uneven pad with a zero in front */
2677 if (strlenW(ptr)%2)
2678 {
2679 byte[2]= '0';
2680 byte[3]= *ptr;
2681 ptr++;
2682 data[count] = (BYTE)strtol(byte,NULL,0);
2683 count ++;
2684 TRACE("Uneven byte count\n");
2685 }
2686 while (*ptr)
2687 {
2688 byte[2]= *ptr;
2689 ptr++;
2690 byte[3]= *ptr;
2691 ptr++;
2692 data[count] = (BYTE)strtol(byte,NULL,0);
2693 count ++;
2694 }
2695 msi_free(deformated);
2696
2697 TRACE("Data %i bytes(%i)\n",*size,count);
2698 }
2699 else
2700 {
2701 LPWSTR deformated;
2702 LPWSTR p;
2703 DWORD d = 0;
2704 deformat_string(package, &value[1], &deformated);
2705
2706 *type=REG_DWORD;
2707 *size = sizeof(DWORD);
2708 data = msi_alloc(*size);
2709 p = deformated;
2710 if (*p == '-')
2711 p++;
2712 while (*p)
2713 {
2714 if ( (*p < '0') || (*p > '9') )
2715 break;
2716 d *= 10;
2717 d += (*p - '0');
2718 p++;
2719 }
2720 if (deformated[0] == '-')
2721 d = -d;
2722 *(LPDWORD)data = d;
2723 TRACE("DWORD %i\n",*(LPDWORD)data);
2724
2725 msi_free(deformated);
2726 }
2727 }
2728 else
2729 {
2730 static const WCHAR szMulti[] = {'[','~',']',0};
2731 LPCWSTR ptr;
2732 *type=REG_SZ;
2733
2734 if (value[0]=='#')
2735 {
2736 if (value[1]=='%')
2737 {
2738 ptr = &value[2];
2739 *type=REG_EXPAND_SZ;
2740 }
2741 else
2742 ptr = &value[1];
2743 }
2744 else
2745 ptr=value;
2746
2747 if (strstrW(value, szMulti))
2748 *type = REG_MULTI_SZ;
2749
2750 /* remove initial delimiter */
2751 if (!strncmpW(value, szMulti, 3))
2752 ptr = value + 3;
2753
2754 *size = deformat_string(package, ptr,(LPWSTR*)&data);
2755
2756 /* add double NULL terminator */
2757 if (*type == REG_MULTI_SZ)
2758 {
2759 *size += 2 * sizeof(WCHAR); /* two NULL terminators */
2760 data = msi_realloc_zero(data, *size);
2761 }
2762 }
2763 return data;
2764 }
2765
2766 static const WCHAR *get_root_key( MSIPACKAGE *package, INT root, HKEY *root_key )
2767 {
2768 const WCHAR *ret;
2769
2770 switch (root)
2771 {
2772 case -1:
2773 if (msi_get_property_int( package->db, szAllUsers, 0 ))
2774 {
2775 *root_key = HKEY_LOCAL_MACHINE;
2776 ret = szHLM;
2777 }
2778 else
2779 {
2780 *root_key = HKEY_CURRENT_USER;
2781 ret = szHCU;
2782 }
2783 break;
2784 case 0:
2785 *root_key = HKEY_CLASSES_ROOT;
2786 ret = szHCR;
2787 break;
2788 case 1:
2789 *root_key = HKEY_CURRENT_USER;
2790 ret = szHCU;
2791 break;
2792 case 2:
2793 *root_key = HKEY_LOCAL_MACHINE;
2794 ret = szHLM;
2795 break;
2796 case 3:
2797 *root_key = HKEY_USERS;
2798 ret = szHU;
2799 break;
2800 default:
2801 ERR("Unknown root %i\n", root);
2802 return NULL;
2803 }
2804
2805 return ret;
2806 }
2807
2808 static WCHAR *get_keypath( MSIPACKAGE *package, HKEY root, const WCHAR *path )
2809 {
2810 static const WCHAR prefixW[] = {'S','O','F','T','W','A','R','E','\\'};
2811 static const UINT len = sizeof(prefixW) / sizeof(prefixW[0]);
2812
2813 if (is_64bit && package->platform == PLATFORM_INTEL &&
2814 root == HKEY_LOCAL_MACHINE && !strncmpiW( path, prefixW, len ))
2815 {
2816 UINT size;
2817 WCHAR *path_32node;
2818
2819 size = (strlenW( path ) + strlenW( szWow6432Node ) + 1) * sizeof(WCHAR);
2820 path_32node = msi_alloc( size );
2821 if (!path_32node)
2822 return NULL;
2823
2824 memcpy( path_32node, path, len * sizeof(WCHAR) );
2825 path_32node[len] = 0;
2826 strcatW( path_32node, szWow6432Node );
2827 strcatW( path_32node, szBackSlash );
2828 strcatW( path_32node, path + len );
2829 return path_32node;
2830 }
2831
2832 return strdupW( path );
2833 }
2834
2835 static UINT ITERATE_WriteRegistryValues(MSIRECORD *row, LPVOID param)
2836 {
2837 MSIPACKAGE *package = param;
2838 LPSTR value_data = NULL;
2839 HKEY root_key, hkey;
2840 DWORD type,size;
2841 LPWSTR deformated, uikey, keypath;
2842 LPCWSTR szRoot, component, name, key, value;
2843 MSICOMPONENT *comp;
2844 MSIRECORD * uirow;
2845 INT root;
2846 BOOL check_first = FALSE;
2847 UINT rc;
2848
2849 ui_progress(package,2,0,0,0);
2850
2851 component = MSI_RecordGetString(row, 6);
2852 comp = get_loaded_component(package,component);
2853 if (!comp)
2854 return ERROR_SUCCESS;
2855
2856 if (!comp->Enabled)
2857 {
2858 TRACE("component is disabled\n");
2859 return ERROR_SUCCESS;
2860 }
2861
2862 if (comp->ActionRequest != INSTALLSTATE_LOCAL)
2863 {
2864 TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
2865 comp->Action = comp->Installed;
2866 return ERROR_SUCCESS;
2867 }
2868 comp->Action = INSTALLSTATE_LOCAL;
2869
2870 name = MSI_RecordGetString(row, 4);
2871 if( MSI_RecordIsNull(row,5) && name )
2872 {
2873 /* null values can have special meanings */
2874 if (name[0]=='-' && name[1] == 0)
2875 return ERROR_SUCCESS;
2876 else if ((name[0]=='+' && name[1] == 0) ||
2877 (name[0] == '*' && name[1] == 0))
2878 name = NULL;
2879 check_first = TRUE;
2880 }
2881
2882 root = MSI_RecordGetInteger(row,2);
2883 key = MSI_RecordGetString(row, 3);
2884
2885 szRoot = get_root_key( package, root, &root_key );
2886 if (!szRoot)
2887 return ERROR_SUCCESS;
2888
2889 deformat_string(package, key , &deformated);
2890 size = strlenW(deformated) + strlenW(szRoot) + 1;
2891 uikey = msi_alloc(size*sizeof(WCHAR));
2892 strcpyW(uikey,szRoot);
2893 strcatW(uikey,deformated);
2894
2895 keypath = get_keypath( package, root_key, deformated );
2896 msi_free( deformated );
2897 if (RegCreateKeyW( root_key, keypath, &hkey ))
2898 {
2899 ERR("Could not create key %s\n", debugstr_w(keypath));
2900 msi_free(uikey);
2901 msi_free(keypath);
2902 return ERROR_SUCCESS;
2903 }
2904
2905 value = MSI_RecordGetString(row,5);
2906 if (value)
2907 value_data = parse_value(package, value, &type, &size);
2908 else
2909 {
2910 value_data = (LPSTR)strdupW(szEmpty);
2911 size = sizeof(szEmpty);
2912 type = REG_SZ;
2913 }
2914
2915 deformat_string(package, name, &deformated);
2916
2917 if (!check_first)
2918 {
2919 TRACE("Setting value %s of %s\n",debugstr_w(deformated),
2920 debugstr_w(uikey));
2921 RegSetValueExW(hkey, deformated, 0, type, (LPBYTE)value_data, size);
2922 }
2923 else
2924 {
2925 DWORD sz = 0;
2926 rc = RegQueryValueExW(hkey, deformated, NULL, NULL, NULL, &sz);
2927 if (rc == ERROR_SUCCESS || rc == ERROR_MORE_DATA)
2928 {
2929 TRACE("value %s of %s checked already exists\n",
2930 debugstr_w(deformated), debugstr_w(uikey));
2931 }
2932 else
2933 {
2934 TRACE("Checked and setting value %s of %s\n",
2935 debugstr_w(deformated), debugstr_w(uikey));
2936 if (deformated || size)
2937 RegSetValueExW(hkey, deformated, 0, type, (LPBYTE) value_data, size);
2938 }
2939 }
2940 RegCloseKey(hkey);
2941
2942 uirow = MSI_CreateRecord(3);
2943 MSI_RecordSetStringW(uirow,2,deformated);
2944 MSI_RecordSetStringW(uirow,1,uikey);
2945 if (type == REG_SZ || type == REG_EXPAND_SZ)
2946 MSI_RecordSetStringW(uirow,3,(LPWSTR)value_data);
2947 ui_actiondata(package,szWriteRegistryValues,uirow);
2948 msiobj_release( &uirow->hdr );
2949
2950 msi_free(value_data);
2951 msi_free(deformated);
2952 msi_free(uikey);
2953 msi_free(keypath);
2954
2955 return ERROR_SUCCESS;
2956 }
2957
2958 static UINT ACTION_WriteRegistryValues(MSIPACKAGE *package)
2959 {
2960 UINT rc;
2961 MSIQUERY * view;
2962 static const WCHAR ExecSeqQuery[] =
2963 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2964 '`','R','e','g','i','s','t','r','y','`',0 };
2965
2966 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2967 if (rc != ERROR_SUCCESS)
2968 return ERROR_SUCCESS;
2969
2970 /* increment progress bar each time action data is sent */
2971 ui_progress(package,1,REG_PROGRESS_VALUE,1,0);
2972
2973 rc = MSI_IterateRecords(view, NULL, ITERATE_WriteRegistryValues, package);
2974
2975 msiobj_release(&view->hdr);
2976 return rc;
2977 }
2978
2979 static void delete_reg_key_or_value( HKEY hkey_root, LPCWSTR key, LPCWSTR value, BOOL delete_key )
2980 {
2981 LONG res;
2982 HKEY hkey;
2983 DWORD num_subkeys, num_values;
2984
2985 if (delete_key)
2986 {
2987 if ((res = RegDeleteTreeW( hkey_root, key )))
2988 {
2989 TRACE("Failed to delete key %s (%d)\n", debugstr_w(key), res);
2990 }
2991 return;
2992 }
2993
2994 if (!(res = RegOpenKeyW( hkey_root, key, &hkey )))
2995 {
2996 if ((res = RegDeleteValueW( hkey, value )))
2997 {
2998 TRACE("Failed to delete value %s (%d)\n", debugstr_w(value), res);
2999 }
3000 res = RegQueryInfoKeyW( hkey, NULL, NULL, NULL, &num_subkeys, NULL, NULL, &num_values,
3001 NULL, NULL, NULL, NULL );
3002 RegCloseKey( hkey );
3003 if (!res && !num_subkeys && !num_values)
3004 {
3005 TRACE("Removing empty key %s\n", debugstr_w(key));
3006 RegDeleteKeyW( hkey_root, key );
3007 }
3008 return;
3009 }
3010 TRACE("Failed to open key %s (%d)\n", debugstr_w(key), res);
3011 }
3012
3013
3014 static UINT ITERATE_RemoveRegistryValuesOnUninstall( MSIRECORD *row, LPVOID param )
3015 {
3016 MSIPACKAGE *package = param;
3017 LPCWSTR component, name, key_str, root_key_str;
3018 LPWSTR deformated_key, deformated_name, ui_key_str, keypath;
3019 MSICOMPONENT *comp;
3020 MSIRECORD *uirow;
3021 BOOL delete_key = FALSE;
3022 HKEY hkey_root;
3023 UINT size;
3024 INT root;
3025
3026 ui_progress( package, 2, 0, 0, 0 );
3027
3028 component = MSI_RecordGetString( row, 6 );
3029 comp = get_loaded_component( package, component );
3030 if (!comp)
3031 return ERROR_SUCCESS;
3032
3033 if (!comp->Enabled)
3034 {
3035 TRACE("component is disabled\n");
3036 return ERROR_SUCCESS;
3037 }
3038
3039 if (comp->ActionRequest != INSTALLSTATE_ABSENT)
3040 {
3041 TRACE("Component not scheduled for removal: %s\n", debugstr_w(component));
3042 comp->Action = comp->Installed;
3043 return ERROR_SUCCESS;
3044 }
3045 comp->Action = INSTALLSTATE_ABSENT;
3046
3047 name = MSI_RecordGetString( row, 4 );
3048 if (MSI_RecordIsNull( row, 5 ) && name )
3049 {
3050 if (name[0] == '+' && !name[1])
3051 return ERROR_SUCCESS;
3052 else if ((name[0] == '-' && !name[1]) || (name[0] == '*' && !name[1]))
3053 {
3054 delete_key = TRUE;
3055 name = NULL;
3056 }
3057 }
3058
3059 root = MSI_RecordGetInteger( row, 2 );
3060 key_str = MSI_RecordGetString( row, 3 );
3061
3062 root_key_str = get_root_key( package, root, &hkey_root );
3063 if (!root_key_str)
3064 return ERROR_SUCCESS;
3065
3066 deformat_string( package, key_str, &deformated_key );
3067 size = strlenW( deformated_key ) + strlenW( root_key_str ) + 1;
3068 ui_key_str = msi_alloc( size * sizeof(WCHAR) );
3069 strcpyW( ui_key_str, root_key_str );
3070 strcatW( ui_key_str, deformated_key );
3071
3072 deformat_string( package, name, &deformated_name );
3073
3074 keypath = get_keypath( package, hkey_root, deformated_key );
3075 msi_free( deformated_key );
3076 delete_reg_key_or_value( hkey_root, keypath, deformated_name, delete_key );
3077 msi_free( keypath );
3078
3079 uirow = MSI_CreateRecord( 2 );
3080 MSI_RecordSetStringW( uirow, 1, ui_key_str );
3081 MSI_RecordSetStringW( uirow, 2, deformated_name );
3082
3083 ui_actiondata( package, szRemoveRegistryValues, uirow );
3084 msiobj_release( &uirow->hdr );
3085
3086 msi_free( ui_key_str );
3087 msi_free( deformated_name );
3088 return ERROR_SUCCESS;
3089 }
3090
3091 static UINT ITERATE_RemoveRegistryValuesOnInstall( MSIRECORD *row, LPVOID param )
3092 {
3093 MSIPACKAGE *package = param;
3094 LPCWSTR component, name, key_str, root_key_str;
3095 LPWSTR deformated_key, deformated_name, ui_key_str, keypath;
3096 MSICOMPONENT *comp;
3097 MSIRECORD *uirow;
3098 BOOL delete_key = FALSE;
3099 HKEY hkey_root;
3100 UINT size;
3101 INT root;
3102
3103 ui_progress( package, 2, 0, 0, 0 );
3104
3105 component = MSI_RecordGetString( row, 5 );
3106 comp = get_loaded_component( package, component );
3107 if (!comp)
3108 return ERROR_SUCCESS;
3109
3110 if (!comp->Enabled)
3111 {
3112 TRACE("component is disabled\n");
3113 return ERROR_SUCCESS;
3114 }
3115
3116 if (comp->ActionRequest != INSTALLSTATE_LOCAL)
3117 {
3118 TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
3119 comp->Action = comp->Installed;
3120 return ERROR_SUCCESS;
3121 }
3122 comp->Action = INSTALLSTATE_LOCAL;
3123
3124 if ((name = MSI_RecordGetString( row, 4 )))
3125 {
3126 if (name[0] == '-' && !name[1])
3127 {
3128 delete_key = TRUE;
3129 name = NULL;
3130 }
3131 }
3132
3133 root = MSI_RecordGetInteger( row, 2 );
3134 key_str = MSI_RecordGetString( row, 3 );
3135
3136 root_key_str = get_root_key( package, root, &hkey_root );
3137 if (!root_key_str)
3138 return ERROR_SUCCESS;
3139
3140 deformat_string( package, key_str, &deformated_key );
3141 size = strlenW( deformated_key ) + strlenW( root_key_str ) + 1;
3142 ui_key_str = msi_alloc( size * sizeof(WCHAR) );
3143 strcpyW( ui_key_str, root_key_str );
3144 strcatW( ui_key_str, deformated_key );
3145
3146 deformat_string( package, name, &deformated_name );
3147
3148 keypath = get_keypath( package, hkey_root, deformated_key );
3149 msi_free( deformated_key );
3150 delete_reg_key_or_value( hkey_root, keypath, deformated_name, delete_key );
3151 msi_free( keypath );
3152
3153 uirow = MSI_CreateRecord( 2 );
3154 MSI_RecordSetStringW( uirow, 1, ui_key_str );
3155 MSI_RecordSetStringW( uirow, 2, deformated_name );
3156
3157 ui_actiondata( package, szRemoveRegistryValues, uirow );
3158 msiobj_release( &uirow->hdr );
3159
3160 msi_free( ui_key_str );
3161 msi_free( deformated_name );
3162 return ERROR_SUCCESS;
3163 }
3164
3165 static UINT ACTION_RemoveRegistryValues( MSIPACKAGE *package )
3166 {
3167 UINT rc;
3168 MSIQUERY *view;
3169 static const WCHAR registry_query[] =
3170 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3171 '`','R','e','g','i','s','t','r','y','`',0 };
3172 static const WCHAR remove_registry_query[] =
3173 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3174 '`','R','e','m','o','v','e','R','e','g','i','s','t','r','y','`',0 };
3175
3176 /* increment progress bar each time action data is sent */
3177 ui_progress( package, 1, REG_PROGRESS_VALUE, 1, 0 );
3178
3179 rc = MSI_DatabaseOpenViewW( package->db, registry_query, &view );
3180 if (rc == ERROR_SUCCESS)
3181 {
3182 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveRegistryValuesOnUninstall, package );
3183 msiobj_release( &view->hdr );
3184 if (rc != ERROR_SUCCESS)
3185 return rc;
3186 }
3187
3188 rc = MSI_DatabaseOpenViewW( package->db, remove_registry_query, &view );
3189 if (rc == ERROR_SUCCESS)
3190 {
3191 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveRegistryValuesOnInstall, package );
3192 msiobj_release( &view->hdr );
3193 if (rc != ERROR_SUCCESS)
3194 return rc;
3195 }
3196
3197 return ERROR_SUCCESS;
3198 }
3199
3200 static UINT ACTION_InstallInitialize(MSIPACKAGE *package)
3201 {
3202 package->script->CurrentlyScripting = TRUE;
3203
3204 return ERROR_SUCCESS;
3205 }
3206
3207
3208 static UINT ACTION_InstallValidate(MSIPACKAGE *package)
3209 {
3210 MSICOMPONENT *comp;
3211 DWORD progress = 0;
3212 DWORD total = 0;
3213 static const WCHAR q1[]=
3214 {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
3215 '`','R','e','g','i','s','t','r','y','`',0};
3216 UINT rc;
3217 MSIQUERY * view;
3218 MSIFEATURE *feature;
3219 MSIFILE *file;
3220
3221 TRACE("InstallValidate\n");
3222
3223 rc = MSI_DatabaseOpenViewW(package->db, q1, &view);
3224 if (rc == ERROR_SUCCESS)
3225 {
3226 MSI_IterateRecords( view, &progress, NULL, package );
3227 msiobj_release( &view->hdr );
3228 total += progress * REG_PROGRESS_VALUE;
3229 }
3230
3231 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
3232 total += COMPONENT_PROGRESS_VALUE;
3233
3234 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
3235 total += file->FileSize;
3236
3237 ui_progress(package,0,total,0,0);
3238
3239 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
3240 {
3241 TRACE("Feature: %s Installed %d Request %d Action %d\n",
3242 debugstr_w(feature->Feature), feature->Installed,
3243 feature->ActionRequest, feature->Action);
3244 }
3245
3246 return ERROR_SUCCESS;
3247 }
3248
3249 static UINT ITERATE_LaunchConditions(MSIRECORD *row, LPVOID param)
3250 {
3251 MSIPACKAGE* package = param;
3252 LPCWSTR cond = NULL;
3253 LPCWSTR message = NULL;
3254 UINT r;
3255
3256 static const WCHAR title[]=
3257 {'I','n','s','t','a','l','l',' ','F','a', 'i','l','e','d',0};
3258
3259 cond = MSI_RecordGetString(row,1);
3260
3261 r = MSI_EvaluateConditionW(package,cond);
3262 if (r == MSICONDITION_FALSE)
3263 {
3264 if ((gUILevel & INSTALLUILEVEL_MASK) != INSTALLUILEVEL_NONE)
3265 {
3266 LPWSTR deformated;
3267 message = MSI_RecordGetString(row,2);
3268 deformat_string(package,message,&deformated);
3269 MessageBoxW(NULL,deformated,title,MB_OK);
3270 msi_free(deformated);
3271 }
3272
3273 return ERROR_INSTALL_FAILURE;
3274 }
3275
3276 return ERROR_SUCCESS;
3277 }
3278
3279 static UINT ACTION_LaunchConditions(MSIPACKAGE *package)
3280 {
3281 UINT rc;
3282 MSIQUERY * view = NULL;
3283 static const WCHAR ExecSeqQuery[] =
3284 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3285 '`','L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','`',0};
3286
3287 TRACE("Checking launch conditions\n");
3288
3289 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3290 if (rc != ERROR_SUCCESS)
3291 return ERROR_SUCCESS;
3292
3293 rc = MSI_IterateRecords(view, NULL, ITERATE_LaunchConditions, package);
3294 msiobj_release(&view->hdr);
3295
3296 return rc;
3297 }
3298
3299 static LPWSTR resolve_keypath( MSIPACKAGE* package, MSICOMPONENT *cmp )
3300 {
3301
3302 if (!cmp->KeyPath)
3303 return resolve_target_folder( package, cmp->Directory, FALSE, TRUE, NULL );
3304
3305 if (cmp->Attributes & msidbComponentAttributesRegistryKeyPath)
3306 {
3307 MSIRECORD * row = 0;
3308 UINT root,len;
3309 LPWSTR deformated,buffer,deformated_name;
3310 LPCWSTR key,name;
3311 static const WCHAR ExecSeqQuery[] =
3312 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3313 '`','R','e','g','i','s','t','r','y','`',' ',
3314 'W','H','E','R','E',' ', '`','R','e','g','i','s','t','r','y','`',
3315 ' ','=',' ' ,'\'','%','s','\'',0 };
3316 static const WCHAR fmt[]={'%','0','2','i',':','\\','%','s','\\',0};
3317 static const WCHAR fmt2[]=
3318 {'%','0','2','i',':','\\','%','s','\\','%','s',0};
3319
3320 row = MSI_QueryGetRecord(package->db, ExecSeqQuery,cmp->KeyPath);
3321 if (!row)
3322 return NULL;
3323
3324 root = MSI_RecordGetInteger(row,2);
3325 key = MSI_RecordGetString(row, 3);
3326 name = MSI_RecordGetString(row, 4);
3327 deformat_string(package, key , &deformated);
3328 deformat_string(package, name, &deformated_name);
3329
3330 len = strlenW(deformated) + 6;
3331 if (deformated_name)
3332 len+=strlenW(deformated_name);
3333
3334 buffer = msi_alloc( len *sizeof(WCHAR));
3335
3336 if (deformated_name)
3337 sprintfW(buffer,fmt2,root,deformated,deformated_name);
3338 else
3339 sprintfW(buffer,fmt,root,deformated);
3340
3341 msi_free(deformated);
3342 msi_free(deformated_name);
3343 msiobj_release(&row->hdr);
3344
3345 return buffer;
3346 }
3347 else if (cmp->Attributes & msidbComponentAttributesODBCDataSource)
3348 {
3349 FIXME("UNIMPLEMENTED keypath as ODBC Source\n");
3350 return NULL;
3351 }
3352 else
3353 {
3354 MSIFILE *file = get_loaded_file( package, cmp->KeyPath );
3355
3356 if (file)
3357 return strdupW( file->TargetPath );
3358 }
3359 return NULL;
3360 }
3361
3362 static HKEY openSharedDLLsKey(void)
3363 {
3364 HKEY hkey=0;
3365 static const WCHAR path[] =
3366 {'S','o','f','t','w','a','r','e','\\',
3367 'M','i','c','r','o','s','o','f','t','\\',
3368 'W','i','n','d','o','w','s','\\',
3369 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3370 'S','h','a','r','e','d','D','L','L','s',0};
3371
3372 RegCreateKeyW(HKEY_LOCAL_MACHINE,path,&hkey);
3373 return hkey;
3374 }
3375
3376 static UINT ACTION_GetSharedDLLsCount(LPCWSTR dll)
3377 {
3378 HKEY hkey;
3379 DWORD count=0;
3380 DWORD type;
3381 DWORD sz = sizeof(count);
3382 DWORD rc;
3383
3384 hkey = openSharedDLLsKey();
3385 rc = RegQueryValueExW(hkey, dll, NULL, &type, (LPBYTE)&count, &sz);
3386 if (rc != ERROR_SUCCESS)
3387 count = 0;
3388 RegCloseKey(hkey);
3389 return count;
3390 }
3391
3392 static UINT ACTION_WriteSharedDLLsCount(LPCWSTR path, UINT count)
3393 {
3394 HKEY hkey;
3395
3396 hkey = openSharedDLLsKey();
3397 if (count > 0)
3398 msi_reg_set_val_dword( hkey, path, count );
3399 else
3400 RegDeleteValueW(hkey,path);
3401 RegCloseKey(hkey);
3402 return count;
3403 }
3404
3405 static void ACTION_RefCountComponent( MSIPACKAGE* package, MSICOMPONENT *comp )
3406 {
3407 MSIFEATURE *feature;
3408 INT count = 0;
3409 BOOL write = FALSE;
3410
3411 /* only refcount DLLs */
3412 if (comp->KeyPath == NULL ||
3413 comp->assembly ||
3414 comp->Attributes & msidbComponentAttributesRegistryKeyPath ||
3415 comp->Attributes & msidbComponentAttributesODBCDataSource)
3416 write = FALSE;
3417 else
3418 {
3419 count = ACTION_GetSharedDLLsCount( comp->FullKeypath);
3420 write = (count > 0);
3421
3422 if (comp->Attributes & msidbComponentAttributesSharedDllRefCount)
3423 write = TRUE;
3424 }
3425
3426 /* increment counts */
3427 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
3428 {
3429 ComponentList *cl;
3430
3431 if (feature->ActionRequest != INSTALLSTATE_LOCAL)
3432 continue;
3433
3434 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3435 {
3436 if ( cl->component == comp )
3437 count++;
3438 }
3439 }
3440
3441 /* decrement counts */
3442 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
3443 {
3444 ComponentList *cl;
3445
3446 if (feature->ActionRequest != INSTALLSTATE_ABSENT)
3447 continue;
3448
3449 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3450 {
3451 if ( cl->component == comp )
3452 count--;
3453 }
3454 }
3455
3456 /* ref count all the files in the component */
3457 if (write)
3458 {
3459 MSIFILE *file;
3460
3461 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
3462 {
3463 if (file->Component == comp)
3464 ACTION_WriteSharedDLLsCount( file->TargetPath, count );
3465 }
3466 }
3467
3468 /* add a count for permanent */
3469 if (comp->Attributes & msidbComponentAttributesPermanent)
3470 count ++;
3471
3472 comp->RefCount = count;
3473
3474 if (write)
3475 ACTION_WriteSharedDLLsCount( comp->FullKeypath, comp->RefCount );
3476 }
3477
3478 static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
3479 {
3480 WCHAR squished_pc[GUID_SIZE];
3481 WCHAR squished_cc[GUID_SIZE];
3482 UINT rc;
3483 MSICOMPONENT *comp;
3484 HKEY hkey;
3485
3486 TRACE("\n");
3487
3488 squash_guid(package->ProductCode,squished_pc);
3489 ui_progress(package,1,COMPONENT_PROGRESS_VALUE,1,0);
3490
3491 msi_set_sourcedir_props(package, FALSE);
3492
3493 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
3494 {
3495 MSIRECORD * uirow;
3496
3497 ui_progress(package,2,0,0,0);
3498 if (!comp->ComponentId)
3499 continue;
3500
3501 squash_guid(comp->ComponentId,squished_cc);
3502
3503 msi_free(comp->FullKeypath);
3504 if (comp->assembly)
3505 {
3506 const WCHAR prefixW[] = {'<','\\',0};
3507 DWORD len = strlenW( prefixW ) + strlenW( comp->assembly->display_name );
3508
3509 comp->FullKeypath = msi_alloc( (len + 1) * sizeof(WCHAR) );
3510 if (comp->FullKeypath)
3511 {
3512 strcpyW( comp->FullKeypath, prefixW );
3513 strcatW( comp->FullKeypath, comp->assembly->display_name );
3514 }
3515 }
3516 else comp->FullKeypath = resolve_keypath( package, comp );
3517
3518 ACTION_RefCountComponent( package, comp );
3519
3520 TRACE("Component %s (%s), Keypath=%s, RefCount=%i Request=%u\n",
3521 debugstr_w(comp->Component),
3522 debugstr_w(squished_cc),
3523 debugstr_w(comp->FullKeypath),
3524 comp->RefCount,
3525 comp->ActionRequest);
3526
3527 if (comp->ActionRequest == INSTALLSTATE_LOCAL ||
3528 comp->ActionRequest == INSTALLSTATE_SOURCE)
3529 {
3530 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3531 rc = MSIREG_OpenUserDataComponentKey(comp->ComponentId, szLocalSid, &hkey, TRUE);
3532 else
3533 rc = MSIREG_OpenUserDataComponentKey(comp->ComponentId, NULL, &hkey, TRUE);
3534
3535 if (rc != ERROR_SUCCESS)
3536 continue;
3537
3538 if (comp->Attributes & msidbComponentAttributesPermanent)
3539 {
3540 static const WCHAR szPermKey[] =
3541 { '0','0','0','0','0','0','0','0','0','0','0','0',
3542 '0','0','0','0','0','0','0','0','0','0','0','0',
3543 '0','0','0','0','0','0','0','0',0 };
3544
3545 msi_reg_set_val_str(hkey, szPermKey, comp->FullKeypath);
3546 }
3547
3548 if (comp->ActionRequest == INSTALLSTATE_LOCAL)
3549 msi_reg_set_val_str(hkey, squished_pc, comp->FullKeypath);
3550 else
3551 {
3552 MSIFILE *file;
3553 MSIRECORD *row;
3554 LPWSTR ptr, ptr2;
3555 WCHAR source[MAX_PATH];
3556 WCHAR base[MAX_PATH];
3557 LPWSTR sourcepath;
3558
3559 static const WCHAR fmt[] = {'%','0','2','d','\\',0};
3560 static const WCHAR query[] = {
3561 'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
3562 '`','M','e','d','i','a','`',' ','W','H','E','R','E',' ',
3563 '`','L','a','s','t','S','e','q','u','e','n','c','e','`',' ',
3564 '>','=',' ','%','i',' ','O','R','D','E','R',' ','B','Y',' ',
3565 '`','D','i','s','k','I','d','`',0};
3566
3567 if (!comp->KeyPath || !(file = get_loaded_file(package, comp->KeyPath)))
3568 continue;
3569
3570 row = MSI_QueryGetRecord(package->db, query, file->Sequence);
3571 sprintfW(source, fmt, MSI_RecordGetInteger(row, 1));
3572 ptr2 = strrchrW(source, '\\') + 1;
3573 msiobj_release(&row->hdr);
3574
3575 lstrcpyW(base, package->PackagePath);
3576 ptr = strrchrW(base, '\\');
3577 *(ptr + 1) = '\0';
3578
3579 sourcepath = resolve_file_source(package, file);
3580 ptr = sourcepath + lstrlenW(base);
3581 lstrcpyW(ptr2, ptr);
3582 msi_free(sourcepath);
3583
3584 msi_reg_set_val_str(hkey, squished_pc, source);
3585 }
3586 RegCloseKey(hkey);
3587 }
3588 else if (comp->ActionRequest == INSTALLSTATE_ABSENT)
3589 {
3590 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3591 MSIREG_DeleteUserDataComponentKey(comp->ComponentId, szLocalSid);
3592 else
3593 MSIREG_DeleteUserDataComponentKey(comp->ComponentId, NULL);
3594 }
3595 comp->Action = comp->ActionRequest;
3596
3597 /* UI stuff */
3598 uirow = MSI_CreateRecord(3);
3599 MSI_RecordSetStringW(uirow,1,package->ProductCode);
3600 MSI_RecordSetStringW(uirow,2,comp->ComponentId);
3601 MSI_RecordSetStringW(uirow,3,comp->FullKeypath);
3602 ui_actiondata(package,szProcessComponents,uirow);
3603 msiobj_release( &uirow->hdr );
3604 }
3605
3606 return ERROR_SUCCESS;
3607 }
3608
3609 typedef struct {
3610 CLSID clsid;
3611 LPWSTR source;
3612
3613 LPWSTR path;
3614 ITypeLib *ptLib;
3615 } typelib_struct;
3616
3617 static BOOL CALLBACK Typelib_EnumResNameProc( HMODULE hModule, LPCWSTR lpszType,
3618 LPWSTR lpszName, LONG_PTR lParam)
3619 {
3620 TLIBATTR *attr;
3621 typelib_struct *tl_struct = (typelib_struct*) lParam;
3622 static const WCHAR fmt[] = {'%','s','\\','%','i',0};
3623 int sz;
3624 HRESULT res;
3625
3626 if (!IS_INTRESOURCE(lpszName))
3627 {
3628 ERR("Not Int Resource Name %s\n",debugstr_w(lpszName));
3629 return TRUE;
3630 }
3631
3632 sz = strlenW(tl_struct->source)+4;
3633 sz *= sizeof(WCHAR);
3634
3635 if ((INT_PTR)lpszName == 1)
3636 tl_struct->path = strdupW(tl_struct->source);
3637 else
3638 {
3639 tl_struct->path = msi_alloc(sz);
3640 sprintfW(tl_struct->path,fmt,tl_struct->source, lpszName);
3641 }
3642
3643 TRACE("trying %s\n", debugstr_w(tl_struct->path));
3644 res = LoadTypeLib(tl_struct->path,&tl_struct->ptLib);
3645 if (FAILED(res))
3646 {
3647 msi_free(tl_struct->path);
3648 tl_struct->path = NULL;
3649
3650 return TRUE;
3651 }
3652
3653 ITypeLib_GetLibAttr(tl_struct->ptLib, &attr);
3654 if (IsEqualGUID(&(tl_struct->clsid),&(attr->guid)))
3655 {
3656 ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
3657 return FALSE;
3658 }
3659
3660 msi_free(tl_struct->path);
3661 tl_struct->path = NULL;
3662
3663 ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
3664 ITypeLib_Release(tl_struct->ptLib);
3665
3666 return TRUE;
3667 }
3668
3669 static UINT ITERATE_RegisterTypeLibraries(MSIRECORD *row, LPVOID param)
3670 {
3671 MSIPACKAGE* package = param;
3672 LPCWSTR component;
3673 MSICOMPONENT *comp;
3674 MSIFILE *file;
3675 typelib_struct tl_struct;
3676 ITypeLib *tlib;
3677 HMODULE module;
3678 HRESULT hr;
3679
3680 component = MSI_RecordGetString(row,3);
3681 comp = get_loaded_component(package,component);
3682 if (!comp)
3683 return ERROR_SUCCESS;
3684
3685 if (!comp->Enabled)
3686 {
3687 TRACE("component is disabled\n");
3688 return ERROR_SUCCESS;
3689 }
3690
3691 if (comp->ActionRequest != INSTALLSTATE_LOCAL)
3692 {
3693 TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
3694 comp->Action = comp->Installed;
3695 return ERROR_SUCCESS;
3696 }
3697 comp->Action = INSTALLSTATE_LOCAL;
3698
3699 if (!comp->KeyPath || !(file = get_loaded_file( package, comp->KeyPath )))
3700 {
3701 TRACE("component has no key path\n");
3702 return ERROR_SUCCESS;
3703 }
3704 ui_actiondata( package, szRegisterTypeLibraries, row );
3705
3706 module = LoadLibraryExW( file->TargetPath, NULL, LOAD_LIBRARY_AS_DATAFILE );
3707 if (module)
3708 {
3709 LPCWSTR guid;
3710 guid = MSI_RecordGetString(row,1);
3711 CLSIDFromString((LPCWSTR)guid, &tl_struct.clsid);
3712 tl_struct.source = strdupW( file->TargetPath );
3713 tl_struct.path = NULL;
3714
3715 EnumResourceNamesW(module, szTYPELIB, Typelib_EnumResNameProc,
3716 (LONG_PTR)&tl_struct);
3717
3718 if (tl_struct.path)
3719 {
3720 LPWSTR help = NULL;
3721 LPCWSTR helpid;
3722 HRESULT res;
3723
3724 helpid = MSI_RecordGetString(row,6);
3725
3726 if (helpid) help = resolve_target_folder( package, helpid, FALSE, TRUE, NULL );
3727 res = RegisterTypeLib(tl_struct.ptLib,tl_struct.path,help);
3728 msi_free(help);
3729
3730 if (FAILED(res))
3731 ERR("Failed to register type library %s\n",
3732 debugstr_w(tl_struct.path));
3733 else
3734 TRACE("Registered %s\n", debugstr_w(tl_struct.path));
3735
3736 ITypeLib_Release(tl_struct.ptLib);
3737 msi_free(tl_struct.path);
3738 }
3739 else
3740 ERR("Failed to load type library %s\n",
3741 debugstr_w(tl_struct.source));
3742
3743 FreeLibrary(module);
3744 msi_free(tl_struct.source);
3745 }
3746 else
3747 {
3748 hr = LoadTypeLibEx(file->TargetPath, REGKIND_REGISTER, &tlib);
3749 if (FAILED(hr))
3750 {
3751 ERR("Failed to load type library: %08x\n", hr);
3752 return ERROR_INSTALL_FAILURE;
3753 }
3754
3755 ITypeLib_Release(tlib);
3756 }
3757
3758 return ERROR_SUCCESS;
3759 }
3760
3761 static UINT ACTION_RegisterTypeLibraries(MSIPACKAGE *package)
3762 {
3763 /*
3764 * OK this is a bit confusing.. I am given a _Component key and I believe
3765 * that the file that is being registered as a type library is the "key file
3766 * of that component" which I interpret to mean "The file in the KeyPath of
3767 * that component".
3768 */
3769 UINT rc;
3770 MSIQUERY * view;
3771 static const WCHAR Query[] =
3772 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3773 '`','T','y','p','e','L','i','b','`',0};
3774
3775 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3776 if (rc != ERROR_SUCCESS)
3777 return ERROR_SUCCESS;
3778
3779 rc = MSI_IterateRecords(view, NULL, ITERATE_RegisterTypeLibraries, package);
3780 msiobj_release(&view->hdr);
3781 return rc;
3782 }
3783
3784 static UINT ITERATE_UnregisterTypeLibraries( MSIRECORD *row, LPVOID param )
3785 {
3786 MSIPACKAGE *package = param;
3787 LPCWSTR component, guid;
3788 MSICOMPONENT *comp;
3789 GUID libid;
3790 UINT version;
3791 LCID language;
3792 SYSKIND syskind;
3793 HRESULT hr;
3794
3795 component = MSI_RecordGetString( row, 3 );
3796 comp = get_loaded_component( package, component );
3797 if (!comp)
3798 return ERROR_SUCCESS;
3799
3800 if (!comp->Enabled)
3801 {
3802 TRACE("component is disabled\n");
3803 return ERROR_SUCCESS;
3804 }
3805
3806 if (comp->ActionRequest != INSTALLSTATE_ABSENT)
3807 {
3808 TRACE("Component not scheduled for removal %s\n", debugstr_w(component));
3809 comp->Action = comp->Installed;
3810 return ERROR_SUCCESS;
3811 }
3812 comp->Action = INSTALLSTATE_ABSENT;
3813
3814 ui_actiondata( package, szUnregisterTypeLibraries, row );
3815
3816 guid = MSI_RecordGetString( row, 1 );
3817 CLSIDFromString( (LPCWSTR)guid, &libid );
3818 version = MSI_RecordGetInteger( row, 4 );
3819 language = MSI_RecordGetInteger( row, 2 );
3820
3821 #ifdef _WIN64
3822 syskind = SYS_WIN64;
3823 #else
3824 syskind = SYS_WIN32;
3825 #endif
3826
3827 hr = UnRegisterTypeLib( &libid, (version >> 8) & 0xffff, version & 0xff, language, syskind );
3828 if (FAILED(hr))
3829 {
3830 WARN("Failed to unregister typelib: %08x\n", hr);
3831 }
3832
3833 return ERROR_SUCCESS;
3834 }
3835
3836 static UINT ACTION_UnregisterTypeLibraries( MSIPACKAGE *package )
3837 {
3838 UINT rc;
3839 MSIQUERY *view;
3840 static const WCHAR query[] =
3841 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3842 '`','T','y','p','e','L','i','b','`',0};
3843
3844 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
3845 if (rc != ERROR_SUCCESS)
3846 return ERROR_SUCCESS;
3847
3848 rc = MSI_IterateRecords( view, NULL, ITERATE_UnregisterTypeLibraries, package );
3849 msiobj_release( &view->hdr );
3850 return rc;
3851 }
3852
3853 static WCHAR *get_link_file( MSIPACKAGE *package, MSIRECORD *row )
3854 {
3855 static const WCHAR szlnk[] = {'.','l','n','k',0};
3856 LPCWSTR directory, extension;
3857 LPWSTR link_folder, link_file, filename;
3858
3859 directory = MSI_RecordGetString( row, 2 );
3860 link_folder = resolve_target_folder( package, directory, FALSE, TRUE, NULL );
3861
3862 /* may be needed because of a bug somewhere else */
3863 create_full_pathW( link_folder );
3864
3865 filename = msi_dup_record_field( row, 3 );
3866 reduce_to_longfilename( filename );
3867
3868 extension = strchrW( filename, '.' );
3869 if (!extension || strcmpiW( extension, szlnk ))
3870 {
3871 int len = strlenW( filename );
3872 filename = msi_realloc( filename, len * sizeof(WCHAR) + sizeof(szlnk) );
3873 memcpy( filename + len, szlnk, sizeof(szlnk) );
3874 }
3875 link_file = build_directory_name( 2, link_folder, filename );
3876 msi_free( link_folder );
3877 msi_free( filename );
3878
3879 return link_file;
3880 }
3881
3882 static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
3883 {
3884 MSIPACKAGE *package = param;
3885 LPWSTR link_file, deformated, path;
3886 LPCWSTR component, target;
3887 MSICOMPONENT *comp;
3888 IShellLinkW *sl = NULL;
3889 IPersistFile *pf = NULL;
3890 HRESULT res;
3891
3892 component = MSI_RecordGetString(row, 4);
3893 comp = get_loaded_component(package, component);
3894 if (!comp)
3895 return ERROR_SUCCESS;
3896
3897 if (!comp->Enabled)
3898 {
3899 TRACE("component is disabled\n");
3900 return ERROR_SUCCESS;
3901 }
3902
3903 if (comp->ActionRequest != INSTALLSTATE_LOCAL)
3904 {
3905 TRACE("Component not scheduled for installation %s\n", debugstr_w(component));
3906 comp->Action = comp->Installed;
3907 return ERROR_SUCCESS;
3908 }
3909 comp->Action = INSTALLSTATE_LOCAL;
3910
3911 ui_actiondata(package,szCreateShortcuts,row);
3912
3913 res = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
3914 &IID_IShellLinkW, (LPVOID *) &sl );
3915
3916 if (FAILED( res ))
3917 {
3918 ERR("CLSID_ShellLink not available\n");
3919 goto err;
3920 }
3921
3922 res = IShellLinkW_QueryInterface( sl, &IID_IPersistFile,(LPVOID*) &pf );
3923 if (FAILED( res ))
3924 {
3925 ERR("QueryInterface(IID_IPersistFile) failed\n");
3926 goto err;
3927 }
3928
3929 target = MSI_RecordGetString(row, 5);
3930 if (strchrW(target, '['))
3931 {
3932 deformat_string(package, target, &deformated);
3933 IShellLinkW_SetPath(sl,deformated);
3934 msi_free(deformated);
3935 }
3936 else
3937 {
3938 FIXME("poorly handled shortcut format, advertised shortcut\n");
3939 IShellLinkW_SetPath(sl,comp->FullKeypath);
3940 }
3941
3942 if (!MSI_RecordIsNull(row,6))
3943 {
3944 LPCWSTR arguments = MSI_RecordGetString(row, 6);
3945 deformat_string(package, arguments, &deformated);
3946 IShellLinkW_SetArguments(sl,deformated);
3947 msi_free(deformated);
3948 }
3949
3950 if (!MSI_RecordIsNull(row,7))
3951 {
3952 LPCWSTR description = MSI_RecordGetString(row, 7);
3953 IShellLinkW_SetDescription(sl, description);
3954 }
3955
3956 if (!MSI_RecordIsNull(row,8))
3957 IShellLinkW_SetHotkey(sl,MSI_RecordGetInteger(row,8));
3958
3959 if (!MSI_RecordIsNull(row,9))
3960 {
3961 INT index;
3962 LPCWSTR icon = MSI_RecordGetString(row, 9);
3963
3964 path = build_icon_path(package, icon);
3965 index = MSI_RecordGetInteger(row,10);
3966
3967 /* no value means 0 */
3968 if (index == MSI_NULL_INTEGER)
3969 index = 0;
3970
3971 IShellLinkW_SetIconLocation(sl, path, index);
3972 msi_free(path);
3973 }
3974
3975 if (!MSI_RecordIsNull(row,11))
3976 IShellLinkW_SetShowCmd(sl,MSI_RecordGetInteger(row,11));
3977
3978 if (!MSI_RecordIsNull(row,12))
3979 {
3980 LPCWSTR wkdir = MSI_RecordGetString(row, 12);
3981 path = resolve_target_folder( package, wkdir, FALSE, TRUE, NULL );
3982 if (path)
3983 IShellLinkW_SetWorkingDirectory(sl, path);
3984 msi_free(path);
3985 }
3986
3987 link_file = get_link_file(package, row);
3988
3989 TRACE("Writing shortcut to %s\n", debugstr_w(link_file));
3990 IPersistFile_Save(pf, link_file, FALSE);
3991
3992 msi_free(link_file);
3993
3994 err:
3995 if (pf)
3996 IPersistFile_Release( pf );
3997 if (sl)
3998 IShellLinkW_Release( sl );
3999
4000 return ERROR_SUCCESS;
4001 }
4002
4003 static UINT ACTION_CreateShortcuts(MSIPACKAGE *package)
4004 {
4005 UINT rc;
4006 HRESULT res;
4007 MSIQUERY * view;
4008 static const WCHAR Query[] =
4009 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4010 '`','S','h','o','r','t','c','u','t','`',0};
4011
4012 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
4013 if (rc != ERROR_SUCCESS)
4014 return ERROR_SUCCESS;
4015
4016 res = CoInitialize( NULL );
4017
4018 rc = MSI_IterateRecords(view, NULL, ITERATE_CreateShortcuts, package);
4019 msiobj_release(&view->hdr);
4020
4021 if (SUCCEEDED(res))
4022 CoUninitialize();
4023
4024 return rc;
4025 }
4026
4027 static UINT ITERATE_RemoveShortcuts( MSIRECORD *row, LPVOID param )
4028 {
4029 MSIPACKAGE *package = param;
4030 LPWSTR link_file;
4031 LPCWSTR component;
4032 MSICOMPONENT *comp;
4033
4034 component = MSI_RecordGetString( row, 4 );
4035 comp = get_loaded_component( package, component );
4036 if (!comp)
4037 return ERROR_SUCCESS;
4038
4039 if (!comp->Enabled)
4040 {
4041 TRACE("component is disabled\n");
4042 return ERROR_SUCCESS;
4043 }
4044
4045 if (comp->ActionRequest != INSTALLSTATE_ABSENT)
4046 {
4047 TRACE("Component not scheduled for removal %s\n", debugstr_w(component));
4048 comp->Action = comp->Installed;
4049 return ERROR_SUCCESS;
4050 }
4051 comp->Action = INSTALLSTATE_ABSENT;
4052
4053 ui_actiondata( package, szRemoveShortcuts, row );
4054
4055 link_file = get_link_file( package, row );
4056
4057 TRACE("Removing shortcut file %s\n", debugstr_w( link_file ));
4058 if (!DeleteFileW( link_file ))
4059 {
4060 WARN("Failed to remove shortcut file %u\n", GetLastError());
4061 }
4062 msi_free( link_file );
4063
4064 return ERROR_SUCCESS;
4065 }
4066
4067 static UINT ACTION_RemoveShortcuts( MSIPACKAGE *package )
4068 {
4069 UINT rc;
4070 MSIQUERY *view;
4071 static const WCHAR query[] =
4072 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4073 '`','S','h','o','r','t','c','u','t','`',0};
4074
4075 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
4076 if (rc != ERROR_SUCCESS)
4077 return ERROR_SUCCESS;
4078
4079 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveShortcuts, package );
4080 msiobj_release( &view->hdr );
4081
4082 return rc;
4083 }
4084
4085 static UINT ITERATE_PublishIcon(MSIRECORD *row, LPVOID param)
4086 {
4087 MSIPACKAGE* package = param;
4088 HANDLE the_file;
4089 LPWSTR FilePath;
4090 LPCWSTR FileName;
4091 CHAR buffer[1024];
4092 DWORD sz;
4093 UINT rc;
4094
4095 FileName = MSI_RecordGetString(row,1);
4096 if (!FileName)
4097 {
4098 ERR("Unable to get FileName\n");
4099 return ERROR_SUCCESS;
4100 }
4101
4102 FilePath = build_icon_path(package,FileName);
4103
4104 TRACE("Creating icon file at %s\n",debugstr_w(FilePath));
4105
4106 the_file = CreateFileW(FilePath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
4107 FILE_ATTRIBUTE_NORMAL, NULL);
4108
4109 if (the_file == INVALID_HANDLE_VALUE)
4110 {
4111 ERR("Unable to create file %s\n",debugstr_w(FilePath));
4112 msi_free(FilePath);
4113 return ERROR_SUCCESS;
4114 }
4115
4116 do
4117 {
4118 DWORD write;
4119 sz = 1024;
4120 rc = MSI_RecordReadStream(row,2,buffer,&sz);
4121 if (rc != ERROR_SUCCESS)
4122 {
4123 ERR("Failed to get stream\n");
4124 CloseHandle(the_file);
4125 DeleteFileW(FilePath);
4126 break;
4127 }
4128 WriteFile(the_file,buffer,sz,&write,NULL);
4129 } while (sz == 1024);
4130
4131 msi_free(FilePath);
4132 CloseHandle(the_file);
4133
4134 return ERROR_SUCCESS;
4135 }
4136
4137 static UINT msi_publish_icons(MSIPACKAGE *package)
4138 {
4139 UINT r;
4140 MSIQUERY *view;
4141
4142 static const WCHAR query[]= {
4143 'S','E','L','E','C','T',' ','*',' ',
4144 'F','R','O','M',' ','`','I','c','o','n','`',0};
4145
4146 r = MSI_DatabaseOpenViewW(package->db, query, &view);
4147 if (r == ERROR_SUCCESS)
4148 {
4149 MSI_IterateRecords(view, NULL, ITERATE_PublishIcon, package);
4150 msiobj_release(&view->hdr);
4151 }
4152
4153 return ERROR_SUCCESS;
4154 }
4155
4156 static UINT msi_publish_sourcelist(MSIPACKAGE *package, HKEY hkey)
4157 {
4158 UINT r;
4159 HKEY source;
4160 LPWSTR buffer;
4161 MSIMEDIADISK *disk;
4162 MSISOURCELISTINFO *info;
4163
4164 r = RegCreateKeyW(hkey, szSourceList, &source);
4165 if (r != ERROR_SUCCESS)
4166 return r;
4167
4168 RegCloseKey(source);
4169
4170 buffer = strrchrW(package->PackagePath, '\\') + 1;
4171 r = MsiSourceListSetInfoW(package->ProductCode, NULL,
4172 package->Context, MSICODE_PRODUCT,
4173 INSTALLPROPERTY_PACKAGENAMEW, buffer);
4174 if (r != ERROR_SUCCESS)
4175 return r;
4176
4177 r = MsiSourceListSetInfoW(package->ProductCode, NULL,
4178 package->Context, MSICODE_PRODUCT,
4179 INSTALLPROPERTY_MEDIAPACKAGEPATHW, szEmpty);
4180 if (r != ERROR_SUCCESS)
4181 return r;
4182
4183 r = MsiSourceListSetInfoW(package->ProductCode, NULL,
4184 package->Context, MSICODE_PRODUCT,
4185 INSTALLPROPERTY_DISKPROMPTW, szEmpty);
4186 if (r != ERROR_SUCCESS)
4187 return r;
4188
4189 LIST_FOR_EACH_ENTRY(info, &package->sourcelist_info, MSISOURCELISTINFO, entry)
4190 {
4191 if (!strcmpW( info->property, INSTALLPROPERTY_LASTUSEDSOURCEW ))
4192 msi_set_last_used_source(package->ProductCode, NULL, info->context,
4193 info->options, info->value);
4194 else
4195 MsiSourceListSetInfoW(package->ProductCode, NULL,
4196 info->context, info->options,
4197 info->property, info->value);
4198 }
4199
4200 LIST_FOR_EACH_ENTRY(disk, &package->sourcelist_media, MSIMEDIADISK, entry)
4201 {
4202 MsiSourceListAddMediaDiskW(package->ProductCode, NULL,
4203 disk->context, disk->options,
4204 disk->disk_id, disk->volume_label, disk->disk_prompt);
4205 }
4206
4207 return ERROR_SUCCESS;
4208 }
4209
4210 static UINT msi_publish_product_properties(MSIPACKAGE *package, HKEY hkey)
4211 {
4212 MSIHANDLE hdb, suminfo;
4213 WCHAR guids[MAX_PATH];
4214 WCHAR packcode[SQUISH_GUID_SIZE];
4215 LPWSTR buffer;
4216 LPWSTR ptr;
4217 DWORD langid;
4218 DWORD size;
4219 UINT r;
4220
4221 static const WCHAR szProductLanguage[] =
4222 {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
4223 static const WCHAR szARPProductIcon[] =
4224 {'A','R','P','P','R','O','D','U','C','T','I','C','O','N',0};
4225 static const WCHAR szProductVersion[] =
4226 {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
4227 static const WCHAR szAssignment[] =
4228 {'A','s','s','i','g','n','m','e','n','t',0};
4229 static const WCHAR szAdvertiseFlags[] =
4230 {'A','d','v','e','r','t','i','s','e','F','l','a','g','s',0};
4231 static const WCHAR szClients[] =
4232 {'C','l','i','e','n','t','s',0};
4233 static const WCHAR szColon[] = {':',0};
4234
4235 buffer = msi_dup_property(package->db, INSTALLPROPERTY_PRODUCTNAMEW);
4236 msi_reg_set_val_str(hkey, INSTALLPROPERTY_PRODUCTNAMEW, buffer);
4237 msi_free(buffer);
4238
4239 langid = msi_get_property_int(package->db, szProductLanguage, 0);
4240 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_LANGUAGEW, langid);
4241
4242 /* FIXME */
4243 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_AUTHORIZED_LUA_APPW, 0);
4244
4245 buffer = msi_dup_property(package->db, szARPProductIcon);
4246 if (buffer)
4247 {
4248 LPWSTR path = build_icon_path(package,buffer);
4249 msi_reg_set_val_str(hkey, INSTALLPROPERTY_PRODUCTICONW, path);
4250 msi_free(path);
4251 msi_free(buffer);
4252 }
4253
4254 buffer = msi_dup_property(package->db, szProductVersion);
4255 if (buffer)
4256 {
4257 DWORD verdword = msi_version_str_to_dword(buffer);
4258 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONW, verdword);
4259 msi_free(buffer);
4260 }
4261
4262 msi_reg_set_val_dword(hkey, szAssignment, 0);
4263 msi_reg_set_val_dword(hkey, szAdvertiseFlags, 0x184);
4264 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_INSTANCETYPEW, 0);
4265 msi_reg_set_val_str(hkey, szClients, szColon);
4266
4267 hdb = alloc_msihandle(&package->db->hdr);
4268 if (!hdb)
4269 return ERROR_NOT_ENOUGH_MEMORY;
4270
4271 r = MsiGetSummaryInformationW(hdb, NULL, 0, &suminfo);
4272 MsiCloseHandle(hdb);
4273 if (r != ERROR_SUCCESS)
4274 goto done;
4275
4276 size = MAX_PATH;
4277 r = MsiSummaryInfoGetPropertyW(suminfo, PID_REVNUMBER, NULL, NULL,
4278 NULL, guids, &size);
4279 if (r != ERROR_SUCCESS)
4280 goto done;
4281
4282 ptr = strchrW(guids, ';');
4283 if (ptr) *ptr = 0;
4284 squash_guid(guids, packcode);
4285 msi_reg_set_val_str(hkey, INSTALLPROPERTY_PACKAGECODEW, packcode);
4286
4287 done:
4288 MsiCloseHandle(suminfo);
4289 return ERROR_SUCCESS;
4290 }
4291
4292 static UINT msi_publish_upgrade_code(MSIPACKAGE *package)
4293 {
4294 UINT r;
4295 HKEY hkey;
4296 LPWSTR upgrade;
4297 WCHAR squashed_pc[SQUISH_GUID_SIZE];
4298
4299 upgrade = msi_dup_property(package->db, szUpgradeCode);
4300 if (!upgrade)
4301 return ERROR_SUCCESS;
4302
4303 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
4304 {
4305 r = MSIREG_OpenClassesUpgradeCodesKey(upgrade, &hkey, TRUE);
4306 if (r != ERROR_SUCCESS)
4307 goto done;
4308 }
4309 else
4310 {
4311 r = MSIREG_OpenUserUpgradeCodesKey(upgrade, &hkey, TRUE);
4312 if (r != ERROR_SUCCESS)
4313 goto done;
4314 }
4315
4316 squash_guid(package->ProductCode, squashed_pc);
4317 msi_reg_set_val_str(hkey, squashed_pc, NULL);
4318
4319 RegCloseKey(hkey);
4320
4321 done:
4322 msi_free(upgrade);
4323 return r;
4324 }
4325
4326 static BOOL msi_check_publish(MSIPACKAGE *package)
4327 {
4328 MSIFEATURE *feature;
4329
4330 LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
4331 {
4332 if (feature->ActionRequest == INSTALLSTATE_LOCAL)
4333 return TRUE;
4334 }
4335
4336 return FALSE;
4337 }
4338
4339 static BOOL msi_check_unpublish(MSIPACKAGE *package)
4340 {
4341 MSIFEATURE *feature;
4342
4343 LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
4344 {
4345 if (feature->ActionRequest != INSTALLSTATE_ABSENT)
4346 return FALSE;
4347 }
4348
4349 return TRUE;
4350 }
4351
4352 static UINT msi_publish_patches( MSIPACKAGE *package )
4353 {
4354 static const WCHAR szAllPatches[] = {'A','l','l','P','a','t','c','h','e','s',0};
4355 WCHAR patch_squashed[GUID_SIZE];
4356 HKEY patches_key = NULL, product_patches_key = NULL, product_key;
4357 LONG res;
4358 MSIPATCHINFO *patch;
4359 UINT r;
4360 WCHAR *p, *all_patches = NULL;
4361 DWORD len = 0;
4362
4363 r = MSIREG_OpenProductKey( package->ProductCode, NULL, package->Context, &product_key, TRUE );
4364 if (r != ERROR_SUCCESS)
4365 return ERROR_FUNCTION_FAILED;
4366
4367 res = RegCreateKeyExW( product_key, szPatches, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &patches_key, NULL );
4368 if (res != ERROR_SUCCESS)
4369 {
4370 r = ERROR_FUNCTION_FAILED;
4371 goto done;
4372 }
4373
4374 r = MSIREG_OpenUserDataProductPatchesKey( package->ProductCode, package->Context, &product_patches_key, TRUE );
4375 if (r != ERROR_SUCCESS)
4376 goto done;
4377
4378 LIST_FOR_EACH_ENTRY( patch, &package->patches, MSIPATCHINFO, entry )
4379 {
4380 squash_guid( patch->patchcode, patch_squashed );
4381 len += strlenW( patch_squashed ) + 1;
4382 }
4383
4384 p = all_patches = msi_alloc( (len + 1) * sizeof(WCHAR) );
4385 if (!all_patches)
4386 goto done;
4387
4388 LIST_FOR_EACH_ENTRY( patch, &package->patches, MSIPATCHINFO, entry )
4389 {
4390 HKEY patch_key;
4391
4392 squash_guid( patch->patchcode, p );
4393 p += strlenW( p ) + 1;
4394
4395 res = RegSetValueExW( patches_key, patch_squashed, 0, REG_SZ,
4396 (const BYTE *)patch->transforms,
4397 (strlenW(patch->transforms) + 1) * sizeof(WCHAR) );
4398 if (res != ERROR_SUCCESS)
4399 goto done;
4400
4401 r = MSIREG_OpenUserDataPatchKey( patch->patchcode, package->Context, &patch_key, TRUE );
4402 if (r != ERROR_SUCCESS)
4403 goto done;
4404
4405 res = RegSetValueExW( patch_key, szLocalPackage, 0, REG_SZ,
4406 (const BYTE *)patch->localfile,
4407 (strlenW(patch->localfile) + 1) * sizeof(WCHAR) );
4408 RegCloseKey( patch_key );
4409 if (res != ERROR_SUCCESS)
4410 goto done;
4411
4412 res = RegCreateKeyExW( product_patches_key, patch_squashed, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &patch_key, NULL );
4413 if (res != ERROR_SUCCESS)
4414 goto done;
4415
4416 res = RegSetValueExW( patch_key, szState, 0, REG_DWORD, (const BYTE *)&patch->state, sizeof(patch->state) );
4417 RegCloseKey( patch_key );
4418 if (res != ERROR_SUCCESS)
4419 goto done;
4420 }
4421
4422 all_patches[len] = 0;
4423 res = RegSetValueExW( patches_key, szPatches, 0, REG_MULTI_SZ,
4424 (const BYTE *)all_patches, (len + 1) * sizeof(WCHAR) );
4425 if (res != ERROR_SUCCESS)
4426 goto done;
4427
4428 res = RegSetValueExW( product_patches_key, szAllPatches, 0, REG_MULTI_SZ,
4429 (const BYTE *)all_patches, (len + 1) * sizeof(WCHAR) );
4430 if (res != ERROR_SUCCESS)
4431 r = ERROR_FUNCTION_FAILED;
4432
4433 done:
4434 RegCloseKey( product_patches_key );
4435 RegCloseKey( patches_key );
4436 RegCloseKey( product_key );
4437 msi_free( all_patches );
4438 return r;
4439 }
4440
4441 /*
4442 * 99% of the work done here is only done for
4443 * advertised installs. However this is where the
4444 * Icon table is processed and written out
4445 * so that is what I am going to do here.
4446 */
4447 static UINT ACTION_PublishProduct(MSIPACKAGE *package)
4448 {
4449 UINT rc;
4450 HKEY hukey = NULL, hudkey = NULL;
4451 MSIRECORD *uirow;
4452
4453 if (!list_empty(&package->patches))
4454 {
4455 rc = msi_publish_patches(package);
4456 if (rc != ERROR_SUCCESS)
4457 goto end;
4458 }
4459
4460 /* FIXME: also need to publish if the product is in advertise mode */
4461 if (!msi_check_publish(package))
4462 return ERROR_SUCCESS;
4463
4464 rc = MSIREG_OpenProductKey(package->ProductCode, NULL, package->Context,
4465 &hukey, TRUE);
4466 if (rc != ERROR_SUCCESS)
4467 goto end;
4468
4469 rc = MSIREG_OpenUserDataProductKey(package->ProductCode, package->Context,
4470 NULL, &hudkey, TRUE);
4471 if (rc != ERROR_SUCCESS)
4472 goto end;
4473
4474 rc = msi_publish_upgrade_code(package);
4475 if (rc != ERROR_SUCCESS)
4476 goto end;
4477
4478 rc = msi_publish_product_properties(package, hukey);
4479 if (rc != ERROR_SUCCESS)
4480 goto end;
4481
4482 rc = msi_publish_sourcelist(package, hukey);
4483 if (rc != ERROR_SUCCESS)
4484 goto end;
4485
4486 rc = msi_publish_icons(package);
4487
4488 end:
4489 uirow = MSI_CreateRecord( 1 );
4490 MSI_RecordSetStringW( uirow, 1, package->ProductCode );
4491 ui_actiondata( package, szPublishProduct, uirow );
4492 msiobj_release( &uirow->hdr );
4493
4494 RegCloseKey(hukey);
4495 RegCloseKey(hudkey);
4496
4497 return rc;
4498 }
4499
4500 static WCHAR *get_ini_file_name( MSIPACKAGE *package, MSIRECORD *row )
4501 {
4502 WCHAR *filename, *ptr, *folder, *ret;
4503 const WCHAR *dirprop;
4504
4505 filename = msi_dup_record_field( row, 2 );
4506 if (filename && (ptr = strchrW( filename, '|' )))
4507 ptr++;
4508 else
4509 ptr = filename;
4510
4511 dirprop = MSI_RecordGetString( row, 3 );
4512 if (dirprop)
4513 {
4514 folder = resolve_target_folder( package, dirprop, FALSE, TRUE, NULL );
4515 if (!folder)
4516 folder = msi_dup_property( package->db, dirprop );
4517 }
4518 else
4519 folder = msi_dup_property( package->db, szWindowsFolder );
4520
4521 if (!folder)
4522 {
4523 ERR("Unable to resolve folder %s\n", debugstr_w(dirprop));
4524 msi_free( filename );
4525 return NULL;
4526 }
4527
4528 ret = build_directory_name( 2, folder, ptr );
4529
4530 msi_free( filename );
4531 msi_free( folder );
4532 return ret;
4533 }
4534
4535 static UINT ITERATE_WriteIniValues(MSIRECORD *row, LPVOID param)
4536 {
4537 MSIPACKAGE *package = param;
4538 LPCWSTR component, section, key, value, identifier;
4539 LPWSTR deformated_section, deformated_key, deformated_value, fullname;
4540 MSIRECORD * uirow;
4541 INT action;
4542 MSICOMPONENT *comp;
4543
4544 component = MSI_RecordGetString(row, 8);
4545 comp = get_loaded_component(package,component);
4546 if (!comp)
4547 return ERROR_SUCCESS;
4548
4549 if (!comp->Enabled)
4550 {
4551 TRACE("component is disabled\n");
4552 return ERROR_SUCCESS;
4553 }
4554
4555 if (comp->ActionRequest != INSTALLSTATE_LOCAL)
4556 {
4557 TRACE("Component not scheduled for installation %s\n", debugstr_w(component));
4558 comp->Action = comp->Installed;
4559 return ERROR_SUCCESS;
4560 }
4561 comp->Action = INSTALLSTATE_LOCAL;
4562
4563 identifier = MSI_RecordGetString(row,1);
4564 section = MSI_RecordGetString(row,4);
4565 key = MSI_RecordGetString(row,5);
4566 value = MSI_RecordGetString(row,6);
4567 action = MSI_RecordGetInteger(row,7);
4568
4569 deformat_string(package,section,&deformated_section);
4570 deformat_string(package,key,&deformated_key);
4571 deformat_string(package,value,&deformated_value);
4572
4573 fullname = get_ini_file_name(package, row);
4574
4575 if (action == 0)
4576 {
4577 TRACE("Adding value %s to section %s in %s\n",
4578 debugstr_w(deformated_key), debugstr_w(deformated_section),
4579 debugstr_w(fullname));
4580 WritePrivateProfileStringW(deformated_section, deformated_key,
4581 deformated_value, fullname);
4582 }
4583 else if (action == 1)
4584 {
4585 WCHAR returned[10];
4586 GetPrivateProfileStringW(deformated_section, deformated_key, NULL,
4587 returned, 10, fullname);
4588 if (returned[0] == 0)
4589 {
4590 TRACE("Adding value %s to section %s in %s\n",
4591 debugstr_w(deformated_key), debugstr_w(deformated_section),
4592 debugstr_w(fullname));
4593
4594 WritePrivateProfileStringW(deformated_section, deformated_key,
4595 deformated_value, fullname);
4596 }
4597 }
4598 else if (action == 3)
4599 FIXME("Append to existing section not yet implemented\n");
4600
4601 uirow = MSI_CreateRecord(4);
4602 MSI_RecordSetStringW(uirow,1,identifier);
4603 MSI_RecordSetStringW(uirow,2,deformated_section);
4604 MSI_RecordSetStringW(uirow,3,deformated_key);
4605 MSI_RecordSetStringW(uirow,4,deformated_value);
4606 ui_actiondata(package,szWriteIniValues,uirow);
4607 msiobj_release( &uirow->hdr );
4608
4609 msi_free(fullname);
4610 msi_free(deformated_key);
4611 msi_free(deformated_value);
4612 msi_free(deformated_section);
4613 return ERROR_SUCCESS;
4614 }
4615
4616 static UINT ACTION_WriteIniValues(MSIPACKAGE *package)
4617 {
4618 UINT rc;
4619 MSIQUERY * view;
4620 static const WCHAR ExecSeqQuery[] =
4621 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4622 '`','I','n','i','F','i','l','e','`',0};
4623
4624 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4625 if (rc != ERROR_SUCCESS)
4626 {
4627 TRACE("no IniFile table\n");
4628 return ERROR_SUCCESS;
4629 }
4630
4631 rc = MSI_IterateRecords(view, NULL, ITERATE_WriteIniValues, package);
4632 msiobj_release(&view->hdr);
4633 return rc;
4634 }
4635
4636 static UINT ITERATE_RemoveIniValuesOnUninstall( MSIRECORD *row, LPVOID param )
4637 {
4638 MSIPACKAGE *package = param;
4639 LPCWSTR component, section, key, value, identifier;
4640 LPWSTR deformated_section, deformated_key, deformated_value, filename;
4641 MSICOMPONENT *comp;
4642 MSIRECORD *uirow;
4643 INT action;
4644
4645 component = MSI_RecordGetString( row, 8 );
4646 comp = get_loaded_component( package, component );
4647 if (!comp)
4648 return ERROR_SUCCESS;
4649
4650 if (!comp->Enabled)
4651 {
4652 TRACE("component is disabled\n");
4653 return ERROR_SUCCESS;
4654 }
4655
4656 if (comp->ActionRequest != INSTALLSTATE_ABSENT)
4657 {
4658 TRACE("Component not scheduled for removal %s\n", debugstr_w(component));
4659 comp->Action = comp->Installed;
4660 return ERROR_SUCCESS;
4661 }
4662 comp->Action = INSTALLSTATE_ABSENT;
4663
4664 identifier = MSI_RecordGetString( row, 1 );
4665 section = MSI_RecordGetString( row, 4 );
4666 key = MSI_RecordGetString( row, 5 );
4667 value = MSI_RecordGetString( row, 6 );
4668 action = MSI_RecordGetInteger( row, 7 );
4669
4670 deformat_string( package, section, &deformated_section );
4671 deformat_string( package, key, &deformated_key );
4672 deformat_string( package, value, &deformated_value );
4673
4674 if (action == msidbIniFileActionAddLine || action == msidbIniFileActionCreateLine)
4675 {
4676 filename = get_ini_file_name( package, row );
4677
4678 TRACE("Removing key %s from section %s in %s\n",
4679 debugstr_w(deformated_key), debugstr_w(deformated_section), debugstr_w(filename));
4680
4681 if (!WritePrivateProfileStringW( deformated_section, deformated_key, NULL, filename ))
4682 {
4683 WARN("Unable to remove key %u\n", GetLastError());
4684 }
4685 msi_free( filename );
4686 }
4687 else
4688 FIXME("Unsupported action %d\n", action);
4689
4690
4691 uirow = MSI_CreateRecord( 4 );
4692 MSI_RecordSetStringW( uirow, 1, identifier );
4693 MSI_RecordSetStringW( uirow, 2, deformated_section );
4694 MSI_RecordSetStringW( uirow, 3, deformated_key );
4695 MSI_RecordSetStringW( uirow, 4, deformated_value );
4696 ui_actiondata( package, szRemoveIniValues, uirow );
4697 msiobj_release( &uirow->hdr );
4698
4699 msi_free( deformated_key );
4700 msi_free( deformated_value );
4701 msi_free( deformated_section );
4702 return ERROR_SUCCESS;
4703 }
4704
4705 static UINT ITERATE_RemoveIniValuesOnInstall( MSIRECORD *row, LPVOID param )
4706 {
4707 MSIPACKAGE *package = param;
4708 LPCWSTR component, section, key, value, identifier;
4709 LPWSTR deformated_section, deformated_key, deformated_value, filename;
4710 MSICOMPONENT *comp;
4711 MSIRECORD *uirow;
4712 INT action;
4713
4714 component = MSI_RecordGetString( row, 8 );
4715 comp = get_loaded_component( package, component );
4716 if (!comp)
4717 return ERROR_SUCCESS;
4718
4719 if (!comp->Enabled)
4720 {
4721 TRACE("component is disabled\n");
4722 return ERROR_SUCCESS;
4723 }
4724
4725 if (comp->ActionRequest != INSTALLSTATE_LOCAL)
4726 {
4727 TRACE("Component not scheduled for installation %s\n", debugstr_w(component));
4728 comp->Action = comp->Installed;
4729 return ERROR_SUCCESS;
4730 }
4731 comp->Action = INSTALLSTATE_LOCAL;
4732
4733 identifier = MSI_RecordGetString( row, 1 );
4734 section = MSI_RecordGetString( row, 4 );
4735 key = MSI_RecordGetString( row, 5 );
4736 value = MSI_RecordGetString( row, 6 );
4737 action = MSI_RecordGetInteger( row, 7 );
4738
4739 deformat_string( package, section, &deformated_section );
4740 deformat_string( package, key, &deformated_key );
4741 deformat_string( package, value, &deformated_value );
4742
4743 if (action == msidbIniFileActionRemoveLine)
4744 {
4745 filename = get_ini_file_name( package, row );
4746
4747 TRACE("Removing key %s from section %s in %s\n",
4748 debugstr_w(deformated_key), debugstr_w(deformated_section), debugstr_w(filename));
4749
4750 if (!WritePrivateProfileStringW( deformated_section, deformated_key, NULL, filename ))
4751 {
4752 WARN("Unable to remove key %u\n", GetLastError());
4753 }
4754 msi_free( filename );
4755 }
4756 else
4757 FIXME("Unsupported action %d\n", action);
4758
4759 uirow = MSI_CreateRecord( 4 );
4760 MSI_RecordSetStringW( uirow, 1, identifier );
4761 MSI_RecordSetStringW( uirow, 2, deformated_section );
4762 MSI_RecordSetStringW( uirow, 3, deformated_key );
4763 MSI_RecordSetStringW( uirow, 4, deformated_value );
4764 ui_actiondata( package, szRemoveIniValues, uirow );
4765 msiobj_release( &uirow->hdr );
4766
4767 msi_free( deformated_key );
4768 msi_free( deformated_value );
4769 msi_free( deformated_section );
4770 return ERROR_SUCCESS;
4771 }
4772
4773 static UINT ACTION_RemoveIniValues( MSIPACKAGE *package )
4774 {
4775 UINT rc;
4776 MSIQUERY *view;
4777 static const WCHAR query[] =
4778 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4779 '`','I','n','i','F','i','l','e','`',0};
4780 static const WCHAR remove_query[] =
4781 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4782 '`','R','e','m','o','v','e','I','n','i','F','i','l','e','`',0};
4783
4784 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
4785 if (rc == ERROR_SUCCESS)
4786 {
4787 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveIniValuesOnUninstall, package );
4788 msiobj_release( &view->hdr );
4789 if (rc != ERROR_SUCCESS)
4790 return rc;
4791 }
4792
4793 rc = MSI_DatabaseOpenViewW( package->db, remove_query, &view );
4794 if (rc == ERROR_SUCCESS)
4795 {
4796 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveIniValuesOnInstall, package );
4797 msiobj_release( &view->hdr );
4798 if (rc != ERROR_SUCCESS)
4799 return rc;
4800 }
4801
4802 return ERROR_SUCCESS;
4803 }
4804
4805 static void register_dll( const WCHAR *dll, BOOL unregister )
4806 {
4807 HMODULE hmod;
4808
4809 hmod = LoadLibraryExW( dll, 0, LOAD_WITH_ALTERED_SEARCH_PATH );
4810 if (hmod)
4811 {
4812 HRESULT (WINAPI *func_ptr)( void );
4813 const char *func = unregister ? "DllUnregisterServer" : "DllRegisterServer";
4814
4815 func_ptr = (void *)GetProcAddress( hmod, func );
4816 if (func_ptr)
4817 {
4818 HRESULT hr = func_ptr();
4819 if (FAILED( hr ))
4820 WARN("failed to register dll 0x%08x\n", hr);
4821 }
4822 else
4823 WARN("entry point %s not found\n", func);
4824 FreeLibrary( hmod );
4825 return;
4826 }
4827 WARN("failed to load library %u\n", GetLastError());
4828 }
4829
4830 static UINT ITERATE_SelfRegModules(MSIRECORD *row, LPVOID param)
4831 {
4832 MSIPACKAGE *package = param;
4833 LPCWSTR filename;
4834 MSIFILE *file;
4835 MSIRECORD *uirow;
4836
4837 filename = MSI_RecordGetString(row,1);
4838 file = get_loaded_file( package, filename );
4839
4840 if (!file)
4841 {
4842 ERR("Unable to find file id %s\n",debugstr_w(filename));
4843 return ERROR_SUCCESS;
4844 }
4845
4846 TRACE("Registering %s\n", debugstr_w( file->TargetPath ));
4847
4848 register_dll( file->TargetPath, FALSE );
4849
4850 uirow = MSI_CreateRecord( 2 );
4851 MSI_RecordSetStringW( uirow, 1, filename );
4852 MSI_RecordSetStringW( uirow, 2, file->Component->Directory );
4853 ui_actiondata( package, szSelfRegModules, uirow );
4854 msiobj_release( &uirow->hdr );
4855
4856 return ERROR_SUCCESS;
4857 }
4858
4859 static UINT ACTION_SelfRegModules(MSIPACKAGE *package)
4860 {
4861 UINT rc;
4862 MSIQUERY * view;
4863 static const WCHAR ExecSeqQuery[] =
4864 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4865 '`','S','e','l','f','R','e','g','`',0};
4866
4867 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4868 if (rc != ERROR_SUCCESS)
4869 {
4870 TRACE("no SelfReg table\n");
4871 return ERROR_SUCCESS;
4872 }
4873
4874 MSI_IterateRecords(view, NULL, ITERATE_SelfRegModules, package);
4875 msiobj_release(&view->hdr);
4876
4877 return ERROR_SUCCESS;
4878 }
4879
4880 static UINT ITERATE_SelfUnregModules( MSIRECORD *row, LPVOID param )
4881 {
4882 MSIPACKAGE *package = param;
4883 LPCWSTR filename;
4884 MSIFILE *file;
4885 MSIRECORD *uirow;
4886
4887 filename = MSI_RecordGetString( row, 1 );
4888 file = get_loaded_file( package, filename );
4889
4890 if (!file)
4891 {
4892 ERR("Unable to find file id %s\n", debugstr_w(filename));
4893 return ERROR_SUCCESS;
4894 }
4895
4896 TRACE("Unregistering %s\n", debugstr_w( file->TargetPath ));
4897
4898 register_dll( file->TargetPath, TRUE );
4899
4900 uirow = MSI_CreateRecord( 2 );
4901 MSI_RecordSetStringW( uirow, 1, filename );
4902 MSI_RecordSetStringW( uirow, 2, file->Component->Directory );
4903 ui_actiondata( package, szSelfUnregModules, uirow );
4904 msiobj_release( &uirow->hdr );
4905
4906 return ERROR_SUCCESS;
4907 }
4908
4909 static UINT ACTION_SelfUnregModules( MSIPACKAGE *package )
4910 {
4911 UINT rc;
4912 MSIQUERY *view;
4913 static const WCHAR query[] =
4914 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4915 '`','S','e','l','f','R','e','g','`',0};
4916
4917 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
4918 if (rc != ERROR_SUCCESS)
4919 {
4920 TRACE("no SelfReg table\n");
4921 return ERROR_SUCCESS;
4922 }
4923
4924 MSI_IterateRecords( view, NULL, ITERATE_SelfUnregModules, package );
4925 msiobj_release( &view->hdr );
4926
4927 return ERROR_SUCCESS;
4928 }
4929
4930 static UINT ACTION_PublishFeatures(MSIPACKAGE *package)
4931 {
4932 MSIFEATURE *feature;
4933 UINT rc;
4934 HKEY hkey = NULL, userdata = NULL;
4935
4936 if (!msi_check_publish(package))
4937 return ERROR_SUCCESS;
4938
4939 rc = MSIREG_OpenFeaturesKey(package->ProductCode, package->Context,
4940 &hkey, TRUE);
4941 if (rc != ERROR_SUCCESS)
4942 goto end;
4943
4944 rc = MSIREG_OpenUserDataFeaturesKey(package->ProductCode, package->Context,
4945 &userdata, TRUE);
4946 if (rc != ERROR_SUCCESS)
4947 goto end;
4948
4949 /* here the guids are base 85 encoded */
4950 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
4951 {
4952 ComponentList *cl;
4953 LPWSTR data = NULL;
4954 GUID clsid;
4955 INT size;
4956 BOOL absent = FALSE;
4957 MSIRECORD *uirow;
4958
4959 if (feature->ActionRequest != INSTALLSTATE_LOCAL &&
4960 feature->ActionRequest != INSTALLSTATE_SOURCE &&
4961 feature->ActionRequest != INSTALLSTATE_ADVERTISED) absent = TRUE;
4962
4963 size = 1;
4964 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
4965 {
4966 size += 21;
4967 }
4968 if (feature->Feature_Parent)
4969 size += strlenW( feature->Feature_Parent )+2;
4970
4971 data = msi_alloc(size * sizeof(WCHAR));
4972
4973 data[0] = 0;
4974 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
4975 {
4976 MSICOMPONENT* component = cl->component;
4977 WCHAR buf[21];
4978
4979 buf[0] = 0;
4980 if (component->ComponentId)
4981 {
4982 TRACE("From %s\n",debugstr_w(component->ComponentId));
4983 CLSIDFromString(component->ComponentId, &clsid);
4984 encode_base85_guid(&clsid,buf);
4985 TRACE("to %s\n",debugstr_w(buf));
4986 strcatW(data,buf);
4987 }
4988 }
4989
4990 if (feature->Feature_Parent)
4991 {
4992 static const WCHAR sep[] = {'\2',0};
4993 strcatW(data,sep);
4994 strcatW(data,feature->Feature_Parent);
4995 }
4996
4997 msi_reg_set_val_str( userdata, feature->Feature, data );
4998 msi_free(data);
4999
5000 size = 0;
5001 if (feature->Feature_Parent)
5002 size = strlenW(feature->Feature_Parent)*sizeof(WCHAR);
5003 if (!absent)
5004 {
5005 size += sizeof(WCHAR);
5006 RegSetValueExW(hkey,feature->Feature,0,REG_SZ,
5007 (const BYTE*)(feature->Feature_Parent ? feature->Feature_Parent : szEmpty),size);
5008 }
5009 else
5010 {
5011 size += 2*sizeof(WCHAR);
5012 data = msi_alloc(size);
5013 data[0] = 0x6;
5014 data[1] = 0;
5015 if (feature->Feature_Parent)
5016 strcpyW( &data[1], feature->Feature_Parent );
5017 RegSetValueExW(hkey,feature->Feature,0,REG_SZ,
5018 (LPBYTE)data,size);
5019 msi_free(data);
5020 }
5021
5022 /* the UI chunk */
5023 uirow = MSI_CreateRecord( 1 );
5024 MSI_RecordSetStringW( uirow, 1, feature->Feature );
5025 ui_actiondata( package, szPublishFeatures, uirow);
5026 msiobj_release( &uirow->hdr );
5027 /* FIXME: call ui_progress? */
5028 }
5029
5030 end:
5031 RegCloseKey(hkey);
5032 RegCloseKey(userdata);
5033 return rc;
5034 }
5035
5036 static UINT msi_unpublish_feature(MSIPACKAGE *package, MSIFEATURE *feature)
5037 {
5038 UINT r;
5039 HKEY hkey;
5040 MSIRECORD *uirow;
5041
5042 TRACE("unpublishing feature %s\n", debugstr_w(feature->Feature));
5043
5044 r = MSIREG_OpenFeaturesKey(package->ProductCode, package->Context,
5045 &hkey, FALSE);
5046 if (r == ERROR_SUCCESS)
5047 {
5048 RegDeleteValueW(hkey, feature->Feature);
5049 RegCloseKey(hkey);
5050 }
5051
5052 r = MSIREG_OpenUserDataFeaturesKey(package->ProductCode, package->Context,
5053 &hkey, FALSE);
5054 if (r == ERROR_SUCCESS)
5055 {
5056 RegDeleteValueW(hkey, feature->Feature);
5057 RegCloseKey(hkey);
5058 }
5059
5060 uirow = MSI_CreateRecord( 1 );
5061 MSI_RecordSetStringW( uirow, 1, feature->Feature );
5062 ui_actiondata( package, szUnpublishFeatures, uirow );
5063 msiobj_release( &uirow->hdr );
5064
5065 return ERROR_SUCCESS;
5066 }
5067
5068 static UINT ACTION_UnpublishFeatures(MSIPACKAGE *package)
5069 {
5070 MSIFEATURE *feature;
5071
5072 if (!msi_check_unpublish(package))
5073 return ERROR_SUCCESS;
5074
5075 LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
5076 {
5077 msi_unpublish_feature(package, feature);
5078 }
5079
5080 return ERROR_SUCCESS;
5081 }
5082
5083 static UINT msi_publish_install_properties(MSIPACKAGE *package, HKEY hkey)
5084 {
5085 SYSTEMTIME systime;
5086 DWORD size, langid;
5087 WCHAR date[9], *val, *buffer;
5088 const WCHAR *prop, *key;
5089
5090 static const WCHAR date_fmt[] = {'%','i','%','0','2','i','%','0','2','i',0};
5091 static const WCHAR szWindowsInstaller[] =
5092 {'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
5093 static const WCHAR modpath_fmt[] =
5094 {'M','s','i','E','x','e','c','.','e','x','e',' ',
5095 '/','I','[','P','r','o','d','u','c','t','C','o','d','e',']',0};
5096 static const WCHAR szModifyPath[] =
5097 {'M','o','d','i','f','y','P','a','t','h',0};
5098 static const WCHAR szUninstallString[] =
5099 {'U','n','i','n','s','t','a','l','l','S','t','r','i','n','g',0};
5100 static const WCHAR szEstimatedSize[] =
5101 {'E','s','t','i','m','a','t','e','d','S','i','z','e',0};
5102 static const WCHAR szProductLanguage[] =
5103 {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
5104 static const WCHAR szProductVersion[] =
5105 {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
5106 static const WCHAR szDisplayVersion[] =
5107 {'D','i','s','p','l','a','y','V','e','r','s','i','o','n',0};
5108 static const WCHAR szInstallSource[] =
5109 {'I','n','s','t','a','l','l','S','o','u','r','c','e',0};
5110 static const WCHAR szARPAUTHORIZEDCDFPREFIX[] =
5111 {'A','R','P','A','U','T','H','O','R','I','Z','E','D','C','D','F','P','R','E','F','I','X',0};
5112 static const WCHAR szAuthorizedCDFPrefix[] =
5113 {'A','u','t','h','o','r','i','z','e','d','C','D','F','P','r','e','f','i','x',0};
5114 static const WCHAR szARPCONTACT[] =
5115 {'A','R','P','C','O','N','T','A','C','T',0};
5116 static const WCHAR szContact[] =
5117 {'C','o','n','t','a','c','t',0};
5118 static const WCHAR szARPCOMMENTS[] =
5119 {'A','R','P','C','O','M','M','E','N','T','S',0};
5120 static const WCHAR szComments[] =
5121 {'C','o','m','m','e','n','t','s',0};
5122 static const WCHAR szProductName[] =
5123 {'P','r','o','d','u','c','t','N','a','m','e',0};
5124 static const WCHAR szDisplayName[] =
5125 {'D','i','s','p','l','a','y','N','a','m','e',0};
5126 static const WCHAR szARPHELPLINK[] =
5127 {'A','R','P','H','E','L','P','L','I','N','K',0};
5128 static const WCHAR szHelpLink[] =
5129 {'H','e','l','p','L','i','n','k',0};
5130 static const WCHAR szARPHELPTELEPHONE[] =
5131 {'A','R','P','H','E','L','P','T','E','L','E','P','H','O','N','E',0};
5132 static const WCHAR szHelpTelephone[] =
5133 {'H','e','l','p','T','e','l','e','p','h','o','n','e',0};
5134 static const WCHAR szARPINSTALLLOCATION[] =
5135 {'A','R','P','I','N','S','T','A','L','L','L','O','C','A','T','I','O','N',0};
5136 static const WCHAR szInstallLocation[] =
5137 {'I','n','s','t','a','l','l','L','o','c','a','t','i','o','n',0};
5138 static const WCHAR szManufacturer[] =
5139 {'M','a','n','u','f','a','c','t','u','r','e','r',0};
5140 static const WCHAR szPublisher[] =
5141 {'P','u','b','l','i','s','h','e','r',0};
5142 static const WCHAR szARPREADME[] =
5143 {'A','R','P','R','E','A','D','M','E',0};
5144 static const WCHAR szReadme[] =
5145 {'R','e','a','d','M','e',0};
5146 static const WCHAR szARPSIZE[] =
5147 {'A','R','P','S','I','Z','E',0};
5148 static const WCHAR szSize[] =
5149 {'S','i','z','e',0};
5150 static const WCHAR szARPURLINFOABOUT[] =
5151 {'A','R','P','U','R','L','I','N','F','O','A','B','O','U','T',0};
5152 static const WCHAR szURLInfoAbout[] =
5153 {'U','R','L','I','n','f','o','A','b','o','u','t',0};
5154 static const WCHAR szARPURLUPDATEINFO[] =
5155 {'A','R','P','U','R','L','U','P','D','A','T','E','I','N','F','O',0};
5156 static const WCHAR szURLUpdateInfo[] =
5157 {'U','R','L','U','p','d','a','t','e','I','n','f','o',0};
5158
5159 static const WCHAR *propval[] = {
5160 szARPAUTHORIZEDCDFPREFIX, szAuthorizedCDFPrefix,
5161 szARPCONTACT, szContact,
5162 szARPCOMMENTS, szComments,
5163 szProductName, szDisplayName,
5164 szARPHELPLINK, szHelpLink,
5165 szARPHELPTELEPHONE, szHelpTelephone,
5166 szARPINSTALLLOCATION, szInstallLocation,
5167 cszSourceDir, szInstallSource,
5168 szManufacturer, szPublisher,
5169 szARPREADME, szReadme,
5170 szARPSIZE, szSize,
5171 szARPURLINFOABOUT, szURLInfoAbout,
5172 szARPURLUPDATEINFO, szURLUpdateInfo,
5173 NULL
5174 };
5175 const WCHAR **p = propval;
5176
5177 while (*p)
5178 {
5179 prop = *p++;
5180 key = *p++;
5181 val = msi_dup_property(package->db, prop);
5182 msi_reg_set_val_str(hkey, key, val);
5183 msi_free(val);
5184 }
5185
5186 msi_reg_set_val_dword(hkey, szWindowsInstaller, 1);
5187
5188 size = deformat_string(package, modpath_fmt, &buffer);
5189 RegSetValueExW(hkey, szModifyPath, 0, REG_EXPAND_SZ, (LPBYTE)buffer, size);
5190 RegSetValueExW(hkey, szUninstallString, 0, REG_EXPAND_SZ, (LPBYTE)buffer, size);
5191 msi_free(buffer);
5192
5193 /* FIXME: Write real Estimated Size when we have it */
5194 msi_reg_set_val_dword(hkey, szEstimatedSize, 0);
5195
5196 GetLocalTime(&systime);
5197 sprintfW(date, date_fmt, systime.wYear, systime.wMonth, systime.wDay);
5198 msi_reg_set_val_str(hkey, INSTALLPROPERTY_INSTALLDATEW, date);
5199
5200 langid = msi_get_property_int(package->db, szProductLanguage, 0);
5201 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_LANGUAGEW, langid);
5202
5203 buffer = msi_dup_property(package->db, szProductVersion);
5204 msi_reg_set_val_str(hkey, szDisplayVersion, buffer);
5205 if (buffer)
5206 {
5207 DWORD verdword = msi_version_str_to_dword(buffer);
5208
5209 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONW, verdword);
5210 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONMAJORW, verdword >> 24);
5211 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONMINORW, (verdword >> 16) & 0xFF);
5212 msi_free(buffer);
5213 }
5214
5215 return ERROR_SUCCESS;
5216 }
5217
5218 static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
5219 {
5220 WCHAR squashed_pc[SQUISH_GUID_SIZE];
5221 MSIRECORD *uirow;
5222 LPWSTR upgrade_code;
5223 HKEY hkey, props;
5224 HKEY upgrade;
5225 UINT rc;
5226
5227 /* FIXME: also need to publish if the product is in advertise mode */
5228 if (!msi_check_publish(package))
5229 return ERROR_SUCCESS;
5230
5231 rc = MSIREG_OpenUninstallKey(package, &hkey, TRUE);
5232 if (rc != ERROR_SUCCESS)
5233 return rc;
5234
5235 rc = MSIREG_OpenInstallProps(package->ProductCode, package->Context,
5236 NULL, &props, TRUE);
5237 if (rc != ERROR_SUCCESS)
5238 goto done;
5239
5240 msi_reg_set_val_str( props, INSTALLPROPERTY_LOCALPACKAGEW, package->db->localfile );
5241 msi_free( package->db->localfile );
5242 package->db->localfile = NULL;
5243
5244 rc = msi_publish_install_properties(package, hkey);
5245 if (rc != ERROR_SUCCESS)
5246 goto done;
5247
5248 rc = msi_publish_install_properties(package, props);
5249 if (rc != ERROR_SUCCESS)
5250 goto done;
5251
5252 upgrade_code = msi_dup_property(package->db, szUpgradeCode);
5253 if (upgrade_code)
5254 {
5255 MSIREG_OpenUpgradeCodesKey(upgrade_code, &upgrade, TRUE);
5256 squash_guid(package->ProductCode, squashed_pc);
5257 msi_reg_set_val_str(upgrade, squashed_pc, NULL);
5258 RegCloseKey(upgrade);
5259 msi_free(upgrade_code);
5260 }
5261
5262 done:
5263 uirow = MSI_CreateRecord( 1 );
5264 MSI_RecordSetStringW( uirow, 1, package->ProductCode );
5265 ui_actiondata( package, szRegisterProduct, uirow );
5266 msiobj_release( &uirow->hdr );
5267
5268 RegCloseKey(hkey);
5269 return ERROR_SUCCESS;
5270 }
5271
5272 static UINT ACTION_InstallExecute(MSIPACKAGE *package)
5273 {
5274 return execute_script(package,INSTALL_SCRIPT);
5275 }
5276
5277 static UINT msi_unpublish_product(MSIPACKAGE *package, WCHAR *remove)
5278 {
5279 WCHAR *upgrade, **features;
5280 BOOL full_uninstall = TRUE;
5281 MSIFEATURE *feature;
5282 MSIPATCHINFO *patch;
5283
5284 static const WCHAR szUpgradeCode[] =
5285 {'U','p','g','r','a','d','e','C','o','d','e',0};
5286
5287 features = msi_split_string(remove, ',');
5288 if (!features)
5289 {
5290 ERR("REMOVE feature list is empty!\n");
5291 return ERROR_FUNCTION_FAILED;
5292 }
5293
5294 if (!strcmpW( features[0], szAll ))
5295 full_uninstall = TRUE;
5296 else
5297 {
5298 LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
5299 {
5300 if (feature->Action != INSTALLSTATE_ABSENT)
5301 full_uninstall = FALSE;
5302 }
5303 }
5304 msi_free(features);
5305
5306 if (!full_uninstall)
5307 return ERROR_SUCCESS;
5308
5309 MSIREG_DeleteProductKey(package->ProductCode);
5310 MSIREG_DeleteUserDataProductKey(package->ProductCode);
5311 MSIREG_DeleteUninstallKey(package);
5312
5313 MSIREG_DeleteLocalClassesProductKey(package->ProductCode);
5314 MSIREG_DeleteLocalClassesFeaturesKey(package->ProductCode);
5315 MSIREG_DeleteUserProductKey(package->ProductCode);
5316 MSIREG_DeleteUserFeaturesKey(package->ProductCode);
5317
5318 upgrade = msi_dup_property(package->db, szUpgradeCode);
5319 if (upgrade)
5320 {
5321 MSIREG_DeleteUserUpgradeCodesKey(upgrade);
5322 MSIREG_DeleteClassesUpgradeCodesKey(upgrade);
5323 msi_free(upgrade);
5324 }
5325
5326 LIST_FOR_EACH_ENTRY(patch, &package->patches, MSIPATCHINFO, entry)
5327 {
5328 MSIREG_DeleteUserDataPatchKey(patch->patchcode, package->Context);
5329 }
5330
5331 return ERROR_SUCCESS;
5332 }
5333
5334 static UINT ACTION_InstallFinalize(MSIPACKAGE *package)
5335 {
5336 UINT rc;
5337 WCHAR *remove;
5338
5339 /* turn off scheduling */
5340 package->script->CurrentlyScripting= FALSE;
5341
5342 /* first do the same as an InstallExecute */
5343 rc = ACTION_InstallExecute(package);
5344 if (rc != ERROR_SUCCESS)
5345 return rc;
5346
5347 /* then handle Commit Actions */
5348 rc = execute_script(package,COMMIT_SCRIPT);
5349 if (rc != ERROR_SUCCESS)
5350 return rc;
5351
5352 remove = msi_dup_property(package->db, szRemove);
5353 if (remove)
5354 rc = msi_unpublish_product(package, remove);
5355
5356 msi_free(remove);
5357 return rc;
5358 }
5359
5360 UINT ACTION_ForceReboot(MSIPACKAGE *package)
5361 {
5362 static const WCHAR RunOnce[] = {
5363 'S','o','f','t','w','a','r','e','\\',
5364 'M','i','c','r','o','s','o','f','t','\\',
5365 'W','i','n','d','o','w','s','\\',
5366 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
5367 'R','u','n','O','n','c','e',0};
5368 static const WCHAR InstallRunOnce[] = {
5369 'S','o','f','t','w','a','r','e','\\',
5370 'M','i','c','r','o','s','o','f','t','\\',
5371 'W','i','n','d','o','w','s','\\',
5372 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
5373 'I','n','s','t','a','l','l','e','r','\\',
5374 'R','u','n','O','n','c','e','E','n','t','r','i','e','s',0};
5375
5376 static const WCHAR msiexec_fmt[] = {
5377 '%','s',
5378 '\\','M','s','i','E','x','e','c','.','e','x','e',' ','/','@',' ',
5379 '\"','%','s','\"',0};
5380 static const WCHAR install_fmt[] = {
5381 '/','I',' ','\"','%','s','\"',' ',
5382 'A','F','T','E','R','R','E','B','O','O','T','=','1',' ',
5383 'R','U','N','O','N','C','E','E','N','T','R','Y','=','\"','%','s','\"',0};
5384 WCHAR buffer[256], sysdir[MAX_PATH];
5385 HKEY hkey;
5386 WCHAR squished_pc[100];
5387
5388 squash_guid(package->ProductCode,squished_pc);
5389
5390 GetSystemDirectoryW(sysdir, sizeof(sysdir)/sizeof(sysdir[0]));
5391 RegCreateKeyW(HKEY_LOCAL_MACHINE,RunOnce,&hkey);
5392 snprintfW(buffer,sizeof(buffer)/sizeof(buffer[0]),msiexec_fmt,sysdir,
5393 squished_pc);
5394
5395 msi_reg_set_val_str( hkey, squished_pc, buffer );
5396 RegCloseKey(hkey);
5397
5398 TRACE("Reboot command %s\n",debugstr_w(buffer));
5399
5400 RegCreateKeyW(HKEY_LOCAL_MACHINE,InstallRunOnce,&hkey);
5401 sprintfW(buffer,install_fmt,package->ProductCode,squished_pc);
5402
5403 msi_reg_set_val_str( hkey, squished_pc, buffer );
5404 RegCloseKey(hkey);
5405
5406 return ERROR_INSTALL_SUSPEND;
5407 }
5408
5409 static UINT ACTION_ResolveSource(MSIPACKAGE* package)
5410 {
5411 DWORD attrib;
5412 UINT rc;
5413
5414 /*
5415 * We are currently doing what should be done here in the top level Install
5416 * however for Administrative and uninstalls this step will be needed
5417 */
5418 if (!package->PackagePath)
5419 return ERROR_SUCCESS;
5420
5421 msi_set_sourcedir_props(package, TRUE);
5422
5423 attrib = GetFileAttributesW(package->db->path);
5424 if (attrib == INVALID_FILE_ATTRIBUTES)
5425 {
5426 LPWSTR prompt;
5427 LPWSTR msg;
5428 DWORD size = 0;
5429
5430 rc = MsiSourceListGetInfoW(package->ProductCode, NULL,
5431 package->Context, MSICODE_PRODUCT,
5432 INSTALLPROPERTY_DISKPROMPTW,NULL,&size);
5433 if (rc == ERROR_MORE_DATA)
5434 {
5435 prompt = msi_alloc(size * sizeof(WCHAR));
5436 MsiSourceListGetInfoW(package->ProductCode, NULL,
5437 package->Context, MSICODE_PRODUCT,
5438 INSTALLPROPERTY_DISKPROMPTW,prompt,&size);
5439 }
5440 else
5441 prompt = strdupW(package->db->path);
5442
5443 msg = generate_error_string(package,1302,1,prompt);
5444 while(attrib == INVALID_FILE_ATTRIBUTES)
5445 {
5446 rc = MessageBoxW(NULL,msg,NULL,MB_OKCANCEL);
5447 if (rc == IDCANCEL)
5448 {
5449 rc = ERROR_INSTALL_USEREXIT;
5450 break;
5451 }
5452 attrib = GetFileAttributesW(package->db->path);
5453 }
5454 msi_free(prompt);
5455 rc = ERROR_SUCCESS;
5456 }
5457 else
5458 return ERROR_SUCCESS;
5459
5460 return rc;
5461 }
5462
5463 static UINT ACTION_RegisterUser(MSIPACKAGE *package)
5464 {
5465 HKEY hkey = 0;
5466 LPWSTR buffer, productid = NULL;
5467 UINT i, rc = ERROR_SUCCESS;
5468 MSIRECORD *uirow;
5469
5470 static const WCHAR szPropKeys[][80] =
5471 {
5472 {'P','r','o','d','u','c','t','I','D',0},
5473 {'U','S','E','R','N','A','M','E',0},
5474 {'C','O','M','P','A','N','Y','N','A','M','E',0},
5475 {0},
5476 };
5477
5478 static const WCHAR szRegKeys[][80] =
5479 {
5480 {'P','r','o','d','u','c','t','I','D',0},
5481 {'R','e','g','O','w','n','e','r',0},
5482 {'R','e','g','C','o','m','p','a','n','y',0},
5483 {0},
5484 };
5485
5486 if (msi_check_unpublish(package))
5487 {
5488 MSIREG_DeleteUserDataProductKey(package->ProductCode);
5489 goto end;
5490 }
5491
5492 productid = msi_dup_property( package->db, INSTALLPROPERTY_PRODUCTIDW );
5493 if (!productid)
5494 goto end;
5495
5496 rc = MSIREG_OpenInstallProps(package->ProductCode, package->Context,
5497 NULL, &hkey, TRUE);
5498 if (rc != ERROR_SUCCESS)
5499 goto end;
5500
5501 for( i = 0; szPropKeys[i][0]; i++ )
5502 {
5503 buffer = msi_dup_property( package->db, szPropKeys[i] );
5504 msi_reg_set_val_str( hkey, szRegKeys[i], buffer );
5505 msi_free( buffer );
5506 }
5507
5508 end:
5509 uirow = MSI_CreateRecord( 1 );
5510 MSI_RecordSetStringW( uirow, 1, productid );
5511 ui_actiondata( package, szRegisterUser, uirow );
5512 msiobj_release( &uirow->hdr );
5513
5514 msi_free(productid);
5515 RegCloseKey(hkey);
5516 return rc;
5517 }
5518
5519
5520 static UINT ACTION_ExecuteAction(MSIPACKAGE *package)
5521 {
5522 UINT rc;
5523
5524 package->script->InWhatSequence |= SEQUENCE_EXEC;
5525 rc = ACTION_ProcessExecSequence(package,FALSE);
5526 return rc;
5527 }
5528
5529
5530 static UINT ITERATE_PublishComponent(MSIRECORD *rec, LPVOID param)
5531 {
5532 MSIPACKAGE *package = param;
5533 LPCWSTR compgroupid, component, feature, qualifier, text;
5534 LPWSTR advertise = NULL, output = NULL, existing = NULL, p, q;
5535 HKEY hkey = NULL;
5536 UINT rc;
5537 MSICOMPONENT *comp;
5538 MSIFEATURE *feat;
5539 DWORD sz;
5540 MSIRECORD *uirow;
5541 int len;
5542
5543 feature = MSI_RecordGetString(rec, 5);
5544 feat = get_loaded_feature(package, feature);
5545 if (!feat)
5546 return ERROR_SUCCESS;
5547
5548 if (feat->ActionRequest != INSTALLSTATE_LOCAL &&
5549 feat->ActionRequest != INSTALLSTATE_SOURCE &&
5550 feat->ActionRequest != INSTALLSTATE_ADVERTISED)
5551 {
5552 TRACE("Feature %s not scheduled for installation\n", debugstr_w(feature));
5553 feat->Action = feat->Installed;
5554 return ERROR_SUCCESS;
5555 }
5556
5557 component = MSI_RecordGetString(rec, 3);
5558 comp = get_loaded_component(package, component);
5559 if (!comp)
5560 return ERROR_SUCCESS;
5561
5562 compgroupid = MSI_RecordGetString(rec,1);
5563 qualifier = MSI_RecordGetString(rec,2);
5564
5565 rc = MSIREG_OpenUserComponentsKey(compgroupid, &hkey, TRUE);
5566 if (rc != ERROR_SUCCESS)
5567 goto end;
5568
5569 advertise = create_component_advertise_string( package, comp, feature );
5570 text = MSI_RecordGetString( rec, 4 );
5571 if (text)
5572 {
5573 p = msi_alloc( (strlenW( advertise ) + strlenW( text ) + 1) * sizeof(WCHAR) );
5574 strcpyW( p, advertise );
5575 strcatW( p, text );
5576 msi_free( advertise );
5577 advertise = p;
5578 }
5579 existing = msi_reg_get_val_str( hkey, qualifier );
5580
5581 sz = strlenW( advertise ) + 1;
5582 if (existing)
5583 {
5584 for (p = existing; *p; p += len)
5585 {
5586 len = strlenW( p ) + 1;
5587 if (strcmpW( advertise, p )) sz += len;
5588 }
5589 }
5590 if (!(output = msi_alloc( (sz + 1) * sizeof(WCHAR) )))
5591 {
5592 rc = ERROR_OUTOFMEMORY;
5593 goto end;
5594 }
5595 q = output;
5596 if (existing)
5597 {
5598 for (p = existing; *p; p += len)
5599 {
5600 len = strlenW( p ) + 1;
5601 if (strcmpW( advertise, p ))
5602 {
5603 memcpy( q, p, len * sizeof(WCHAR) );
5604 q += len;
5605 }
5606 }
5607 }
5608 strcpyW( q, advertise );
5609 q[strlenW( q ) + 1] = 0;
5610
5611 msi_reg_set_val_multi_str( hkey, qualifier, output );
5612
5613 end:
5614 RegCloseKey(hkey);
5615 msi_free( output );
5616 msi_free( advertise );
5617 msi_free( existing );
5618
5619 /* the UI chunk */
5620 uirow = MSI_CreateRecord( 2 );
5621 MSI_RecordSetStringW( uirow, 1, compgroupid );
5622 MSI_RecordSetStringW( uirow, 2, qualifier);
5623 ui_actiondata( package, szPublishComponents, uirow);
5624 msiobj_release( &uirow->hdr );
5625 /* FIXME: call ui_progress? */
5626
5627 return rc;
5628 }
5629
5630 /*
5631 * At present I am ignorning the advertised components part of this and only
5632 * focusing on the qualified component sets
5633 */
5634 static UINT ACTION_PublishComponents(MSIPACKAGE *package)
5635 {
5636 UINT rc;
5637 MSIQUERY * view;
5638 static const WCHAR ExecSeqQuery[] =
5639 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5640 '`','P','u','b','l','i','s','h',
5641 'C','o','m','p','o','n','e','n','t','`',0};
5642
5643 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
5644 if (rc != ERROR_SUCCESS)
5645 return ERROR_SUCCESS;
5646
5647 rc = MSI_IterateRecords(view, NULL, ITERATE_PublishComponent, package);
5648 msiobj_release(&view->hdr);
5649
5650 return rc;
5651 }
5652
5653 static UINT ITERATE_UnpublishComponent( MSIRECORD *rec, LPVOID param )
5654 {
5655 static const WCHAR szInstallerComponents[] = {
5656 'S','o','f','t','w','a','r','e','\\',
5657 'M','i','c','r','o','s','o','f','t','\\',
5658 'I','n','s','t','a','l','l','e','r','\\',
5659 'C','o','m','p','o','n','e','n','t','s','\\',0};
5660
5661 MSIPACKAGE *package = param;
5662 LPCWSTR compgroupid, component, feature, qualifier;
5663 MSICOMPONENT *comp;
5664 MSIFEATURE *feat;
5665 MSIRECORD *uirow;
5666 WCHAR squashed[GUID_SIZE], keypath[MAX_PATH];
5667 LONG res;
5668
5669 feature = MSI_RecordGetString( rec, 5 );
5670 feat = get_loaded_feature( package, feature );
5671 if (!feat)
5672 return ERROR_SUCCESS;
5673
5674 if (feat->ActionRequest != INSTALLSTATE_ABSENT)
5675 {
5676 TRACE("Feature %s not scheduled for removal\n", debugstr_w(feature));
5677 feat->Action = feat->Installed;
5678 return ERROR_SUCCESS;
5679 }
5680
5681 component = MSI_RecordGetString( rec, 3 );
5682 comp = get_loaded_component( package, component );
5683 if (!comp)
5684 return ERROR_SUCCESS;
5685
5686 compgroupid = MSI_RecordGetString( rec, 1 );
5687 qualifier = MSI_RecordGetString( rec, 2 );
5688
5689 squash_guid( compgroupid, squashed );
5690 strcpyW( keypath, szInstallerComponents );
5691 strcatW( keypath, squashed );
5692
5693 res = RegDeleteKeyW( HKEY_CURRENT_USER, keypath );
5694 if (res != ERROR_SUCCESS)
5695 {
5696 WARN("Unable to delete component key %d\n", res);
5697 }
5698
5699 uirow = MSI_CreateRecord( 2 );
5700 MSI_RecordSetStringW( uirow, 1, compgroupid );
5701 MSI_RecordSetStringW( uirow, 2, qualifier );
5702 ui_actiondata( package, szUnpublishComponents, uirow );
5703 msiobj_release( &uirow->hdr );
5704
5705 return ERROR_SUCCESS;
5706 }
5707
5708 static UINT ACTION_UnpublishComponents( MSIPACKAGE *package )
5709 {
5710 UINT rc;
5711 MSIQUERY *view;
5712 static const WCHAR query[] =
5713 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5714 '`','P','u','b','l','i','s','h',
5715 'C','o','m','p','o','n','e','n','t','`',0};
5716
5717 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
5718 if (rc != ERROR_SUCCESS)
5719 return ERROR_SUCCESS;
5720
5721 rc = MSI_IterateRecords( view, NULL, ITERATE_UnpublishComponent, package );
5722 msiobj_release( &view->hdr );
5723
5724 return rc;
5725 }
5726
5727 static UINT ITERATE_InstallService(MSIRECORD *rec, LPVOID param)
5728 {
5729 MSIPACKAGE *package = param;
5730 MSIRECORD *row;
5731 MSIFILE *file;
5732 SC_HANDLE hscm, service = NULL;
5733 LPCWSTR comp, key;
5734 LPWSTR name = NULL, disp = NULL, load_order = NULL, serv_name = NULL;
5735 LPWSTR depends = NULL, pass = NULL, args = NULL, image_path = NULL;
5736 DWORD serv_type, start_type, err_control;
5737 SERVICE_DESCRIPTIONW sd = {NULL};
5738
5739 static const WCHAR query[] =
5740 {'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
5741 '`','C','o','m','p','o','n','e','n','t','`',' ',
5742 'W','H','E','R','E',' ',
5743 '`','C','o','m','p','o','n','e','n','t','`',' ',
5744 '=','\'','%','s','\'',0};
5745
5746 hscm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, GENERIC_WRITE);
5747 if (!hscm)
5748 {
5749 ERR("Failed to open the SC Manager!\n");
5750 goto done;
5751 }
5752
5753 comp = MSI_RecordGetString( rec, 12 );
5754 if (!get_loaded_component( package, comp ))
5755 goto done;
5756
5757 start_type = MSI_RecordGetInteger(rec, 5);
5758 if (start_type == SERVICE_BOOT_START || start_type == SERVICE_SYSTEM_START)
5759 goto done;
5760
5761 deformat_string(package, MSI_RecordGetString(rec, 2), &name);
5762 deformat_string(package, MSI_RecordGetString(rec, 3), &disp);
5763 serv_type = MSI_RecordGetInteger(rec, 4);
5764 err_control = MSI_RecordGetInteger(rec, 6);
5765 deformat_string(package, MSI_RecordGetString(rec, 7), &load_order);
5766 deformat_string(package, MSI_RecordGetString(rec, 8), &depends);
5767 deformat_string(package, MSI_RecordGetString(rec, 9), &serv_name);
5768 deformat_string(package, MSI_RecordGetString(rec, 10), &pass);
5769 deformat_string(package, MSI_RecordGetString(rec, 11), &args);
5770 deformat_string(package, MSI_RecordGetString(rec, 13), &sd.lpDescription);
5771
5772 /* fetch the service path */
5773 row = MSI_QueryGetRecord(package->db, query, comp);
5774 if (!row)
5775 {
5776 ERR("Control query failed!\n");
5777 goto done;
5778 }
5779 key = MSI_RecordGetString(row, 6);
5780
5781 file = get_loaded_file(package, key);
5782 msiobj_release(&row->hdr);
5783 if (!file)
5784 {
5785 ERR("Failed to load the service file\n");
5786 goto done;
5787 }
5788
5789 if (!args || !args[0]) image_path = file->TargetPath;
5790 else
5791 {
5792 int len = strlenW(file->TargetPath) + strlenW(args) + 2;
5793 if (!(image_path = msi_alloc(len * sizeof(WCHAR))))
5794 return ERROR_OUTOFMEMORY;
5795
5796 strcpyW(image_path, file->TargetPath);
5797 strcatW(image_path, szSpace);
5798 strcatW(image_path, args);
5799 }
5800 service = CreateServiceW(hscm, name, disp, GENERIC_ALL, serv_type,
5801 start_type, err_control, image_path, load_order,
5802 NULL, depends, serv_name, pass);
5803
5804 if (!service)
5805 {
5806 if (GetLastError() != ERROR_SERVICE_EXISTS)
5807 ERR("Failed to create service %s: %d\n", debugstr_w(name), GetLastError());
5808 }
5809 else if (sd.lpDescription)
5810 {
5811 if (!ChangeServiceConfig2W(service, SERVICE_CONFIG_DESCRIPTION, &sd))
5812 WARN("failed to set service description %u\n", GetLastError());
5813 }
5814
5815 if (image_path != file->TargetPath) msi_free(image_path);
5816 done:
5817 CloseServiceHandle(service);
5818 CloseServiceHandle(hscm);
5819 msi_free(name);
5820 msi_free(disp);
5821 msi_free(sd.lpDescription);
5822 msi_free(load_order);
5823 msi_free(serv_name);
5824 msi_free(pass);
5825 msi_free(depends);
5826 msi_free(args);
5827
5828 return ERROR_SUCCESS;
5829 }
5830
5831 static UINT ACTION_InstallServices( MSIPACKAGE *package )
5832 {
5833 UINT rc;
5834 MSIQUERY * view;
5835 static const WCHAR ExecSeqQuery[] =
5836 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5837 'S','e','r','v','i','c','e','I','n','s','t','a','l','l',0};
5838
5839 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
5840 if (rc != ERROR_SUCCESS)
5841 return ERROR_SUCCESS;
5842
5843 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallService, package);
5844 msiobj_release(&view->hdr);
5845
5846 return rc;
5847 }
5848
5849 /* converts arg1[~]arg2[~]arg3 to a list of ptrs to the strings */
5850 static LPCWSTR *msi_service_args_to_vector(LPWSTR args, DWORD *numargs)
5851 {
5852 LPCWSTR *vector, *temp_vector;
5853 LPWSTR p, q;
5854 DWORD sep_len;
5855
5856 static const WCHAR separator[] = {'[','~',']',0};
5857
5858 *numargs = 0;
5859 sep_len = sizeof(separator) / sizeof(WCHAR) - 1;
5860
5861 if (!args)
5862 return NULL;
5863
5864 vector = msi_alloc(sizeof(LPWSTR));
5865 if (!vector)
5866 return NULL;
5867
5868 p = args;
5869 do
5870 {
5871 (*numargs)++;
5872 vector[*numargs - 1] = p;
5873
5874 if ((q = strstrW(p, separator)))
5875 {
5876 *q = '\0';
5877
5878 temp_vector = msi_realloc(vector, (*numargs + 1) * sizeof(LPWSTR));
5879 if (!temp_vector)
5880 {
5881 msi_free(vector);
5882 return NULL;
5883 }
5884 vector = temp_vector;
5885
5886 p = q + sep_len;
5887 }
5888 } while (q);
5889
5890 return vector;
5891 }
5892
5893 static UINT ITERATE_StartService(MSIRECORD *rec, LPVOID param)
5894 {
5895 MSIPACKAGE *package = param;
5896 MSICOMPONENT *comp;
5897 MSIRECORD *uirow;
5898 SC_HANDLE scm = NULL, service = NULL;
5899 LPCWSTR component, *vector = NULL;
5900 LPWSTR name, args, display_name = NULL;
5901 DWORD event, numargs, len;
5902 UINT r = ERROR_FUNCTION_FAILED;
5903
5904 component = MSI_RecordGetString(rec, 6);
5905 comp = get_loaded_component(package, component);
5906 if (!comp)
5907 return ERROR_SUCCESS;
5908
5909 if (!comp->Enabled)
5910 {
5911 TRACE("component is disabled\n");
5912 return ERROR_SUCCESS;
5913 }
5914
5915 if (comp->ActionRequest != INSTALLSTATE_LOCAL)
5916 {
5917 TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
5918 comp->Action = comp->Installed;
5919 return ERROR_SUCCESS;
5920 }
5921 comp->Action = INSTALLSTATE_LOCAL;
5922
5923 deformat_string(package, MSI_RecordGetString(rec, 2), &name);
5924 deformat_string(package, MSI_RecordGetString(rec, 4), &args);
5925 event = MSI_RecordGetInteger(rec, 3);
5926
5927 if (!(event & msidbServiceControlEventStart))
5928 {
5929 r = ERROR_SUCCESS;
5930 goto done;
5931 }
5932
5933 scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
5934 if (!scm)
5935 {
5936 ERR("Failed to open the service control manager\n");
5937 goto done;
5938 }
5939
5940 len = 0;
5941 if (!GetServiceDisplayNameW( scm, name, NULL, &len ) &&
5942 GetLastError() == ERROR_INSUFFICIENT_BUFFER)
5943 {
5944 if ((display_name = msi_alloc( ++len * sizeof(WCHAR ))))
5945 GetServiceDisplayNameW( scm, name, display_name, &len );
5946 }
5947
5948 service = OpenServiceW(scm, name, SERVICE_START);
5949 if (!service)
5950 {
5951 ERR("Failed to open service %s (%u)\n", debugstr_w(name), GetLastError());
5952 goto done;
5953 }
5954
5955 vector = msi_service_args_to_vector(args, &numargs);
5956
5957 if (!StartServiceW(service, numargs, vector) &&
5958 GetLastError() != ERROR_SERVICE_ALREADY_RUNNING)
5959 {
5960 ERR("Failed to start service %s (%u)\n", debugstr_w(name), GetLastError());
5961 goto done;
5962 }
5963
5964 r = ERROR_SUCCESS;
5965
5966 done:
5967 uirow = MSI_CreateRecord( 2 );
5968 MSI_RecordSetStringW( uirow, 1, display_name );
5969 MSI_RecordSetStringW( uirow, 2, name );
5970 ui_actiondata( package, szStartServices, uirow );
5971 msiobj_release( &uirow->hdr );
5972
5973 CloseServiceHandle(service);
5974 CloseServiceHandle(scm);
5975
5976 msi_free(name);
5977 msi_free(args);
5978 msi_free(vector);
5979 msi_free(display_name);
5980 return r;
5981 }
5982
5983 static UINT ACTION_StartServices( MSIPACKAGE *package )
5984 {
5985 UINT rc;
5986 MSIQUERY *view;
5987
5988 static const WCHAR query[] = {
5989 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5990 'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
5991
5992 rc = MSI_DatabaseOpenViewW(package->db, query, &view);
5993 if (rc != ERROR_SUCCESS)
5994 return ERROR_SUCCESS;
5995
5996 rc = MSI_IterateRecords(view, NULL, ITERATE_StartService, package);
5997 msiobj_release(&view->hdr);
5998
5999 return rc;
6000 }
6001
6002 static BOOL stop_service_dependents(SC_HANDLE scm, SC_HANDLE service)
6003 {
6004 DWORD i, needed, count;
6005 ENUM_SERVICE_STATUSW *dependencies;
6006 SERVICE_STATUS ss;
6007 SC_HANDLE depserv;
6008
6009 if (EnumDependentServicesW(service, SERVICE_ACTIVE, NULL,
6010 0, &needed, &count))
6011 return TRUE;
6012
6013 if (GetLastError() != ERROR_MORE_DATA)
6014 return FALSE;
6015
6016 dependencies = msi_alloc(needed);
6017 if (!dependencies)
6018 return FALSE;
6019
6020 if (!EnumDependentServicesW(service, SERVICE_ACTIVE, dependencies,
6021 needed, &needed, &count))
6022 goto error;
6023
6024 for (i = 0; i < count; i++)
6025 {
6026 depserv = OpenServiceW(scm, dependencies[i].lpServiceName,
6027 SERVICE_STOP | SERVICE_QUERY_STATUS);
6028 if (!depserv)
6029 goto error;
6030
6031 if (!ControlService(depserv, SERVICE_CONTROL_STOP, &ss))
6032 goto error;
6033 }
6034
6035 return TRUE;
6036
6037 error:
6038 msi_free(dependencies);
6039 return FALSE;
6040 }
6041
6042 static UINT stop_service( LPCWSTR name )
6043 {
6044 SC_HANDLE scm = NULL, service = NULL;
6045 SERVICE_STATUS status;
6046 SERVICE_STATUS_PROCESS ssp;
6047 DWORD needed;
6048
6049 scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);
6050 if (!scm)
6051 {
6052 WARN("Failed to open the SCM: %d\n", GetLastError());
6053 goto done;
6054 }
6055
6056 service = OpenServiceW(scm, name,
6057 SERVICE_STOP |
6058 SERVICE_QUERY_STATUS |
6059 SERVICE_ENUMERATE_DEPENDENTS);
6060 if (!service)
6061 {
6062 WARN("Failed to open service (%s): %d\n", debugstr_w(name), GetLastError());
6063 goto done;
6064 }
6065
6066 if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp,
6067 sizeof(SERVICE_STATUS_PROCESS), &needed))
6068 {
6069 WARN("Failed to query service status (%s): %d\n", debugstr_w(name), GetLastError());
6070 goto done;
6071 }
6072
6073 if (ssp.dwCurrentState == SERVICE_STOPPED)
6074 goto done;
6075
6076 stop_service_dependents(scm, service);
6077
6078 if (!ControlService(service, SERVICE_CONTROL_STOP, &status))
6079 WARN("Failed to stop service (%s): %d\n", debugstr_w(name), GetLastError());
6080
6081 done:
6082 CloseServiceHandle(service);
6083 CloseServiceHandle(scm);
6084
6085 return ERROR_SUCCESS;
6086 }
6087
6088 static UINT ITERATE_StopService( MSIRECORD *rec, LPVOID param )
6089 {
6090 MSIPACKAGE *package = param;
6091 MSICOMPONENT *comp;
6092 MSIRECORD *uirow;
6093 LPCWSTR component;
6094 LPWSTR name = NULL, display_name = NULL;
6095 DWORD event, len;
6096 SC_HANDLE scm;
6097
6098 event = MSI_RecordGetInteger( rec, 3 );
6099 if (!(event & msidbServiceControlEventStop))
6100 return ERROR_SUCCESS;
6101
6102 component = MSI_RecordGetString( rec, 6 );
6103 comp = get_loaded_component( package, component );
6104 if (!comp)
6105 return ERROR_SUCCESS;
6106
6107 if (!comp->Enabled)
6108 {
6109 TRACE("component is disabled\n");
6110 return ERROR_SUCCESS;
6111 }
6112
6113 if (comp->ActionRequest != INSTALLSTATE_ABSENT)
6114 {
6115 TRACE("Component not scheduled for removal: %s\n", debugstr_w(component));
6116 comp->Action = comp->Installed;
6117 return ERROR_SUCCESS;
6118 }
6119 comp->Action = INSTALLSTATE_ABSENT;
6120
6121 scm = OpenSCManagerW( NULL, NULL, SC_MANAGER_CONNECT );
6122 if (!scm)
6123 {
6124 ERR("Failed to open the service control manager\n");
6125 goto done;
6126 }
6127
6128 len = 0;
6129 if (!GetServiceDisplayNameW( scm, name, NULL, &len ) &&
6130 GetLastError() == ERROR_INSUFFICIENT_BUFFER)
6131 {
6132 if ((display_name = msi_alloc( ++len * sizeof(WCHAR ))))
6133 GetServiceDisplayNameW( scm, name, display_name, &len );
6134 }
6135 CloseServiceHandle( scm );
6136
6137 deformat_string( package, MSI_RecordGetString( rec, 2 ), &name );
6138 stop_service( name );
6139
6140 done:
6141 uirow = MSI_CreateRecord( 2 );
6142 MSI_RecordSetStringW( uirow, 1, display_name );
6143 MSI_RecordSetStringW( uirow, 2, name );
6144 ui_actiondata( package, szStopServices, uirow );
6145 msiobj_release( &uirow->hdr );
6146
6147 msi_free( name );
6148 msi_free( display_name );
6149 return ERROR_SUCCESS;
6150 }
6151
6152 static UINT ACTION_StopServices( MSIPACKAGE *package )
6153 {
6154 UINT rc;
6155 MSIQUERY *view;
6156
6157 static const WCHAR query[] = {
6158 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6159 'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
6160
6161 rc = MSI_DatabaseOpenViewW(package->db, query, &view);
6162 if (rc != ERROR_SUCCESS)
6163 return ERROR_SUCCESS;
6164
6165 rc = MSI_IterateRecords(view, NULL, ITERATE_StopService, package);
6166 msiobj_release(&view->hdr);
6167
6168 return rc;
6169 }
6170
6171 static UINT ITERATE_DeleteService( MSIRECORD *rec, LPVOID param )
6172 {
6173 MSIPACKAGE *package = param;
6174 MSICOMPONENT *comp;
6175 MSIRECORD *uirow;
6176 LPCWSTR component;
6177 LPWSTR name = NULL, display_name = NULL;
6178 DWORD event, len;
6179 SC_HANDLE scm = NULL, service = NULL;
6180
6181 event = MSI_RecordGetInteger( rec, 3 );
6182 if (!(event & msidbServiceControlEventDelete))
6183 return ERROR_SUCCESS;
6184
6185 component = MSI_RecordGetString(rec, 6);
6186 comp = get_loaded_component(package, component);
6187 if (!comp)
6188 return ERROR_SUCCESS;
6189
6190 if (!comp->Enabled)
6191 {
6192 TRACE("component is disabled\n");
6193 return ERROR_SUCCESS;
6194 }
6195
6196 if (comp->ActionRequest != INSTALLSTATE_ABSENT)
6197 {
6198 TRACE("Component not scheduled for removal: %s\n", debugstr_w(component));
6199 comp->Action = comp->Installed;
6200 return ERROR_SUCCESS;
6201 }
6202 comp->Action = INSTALLSTATE_ABSENT;
6203
6204 deformat_string( package, MSI_RecordGetString(rec, 2), &name );
6205 stop_service( name );
6206
6207 scm = OpenSCManagerW( NULL, NULL, SC_MANAGER_ALL_ACCESS );
6208 if (!scm)
6209 {
6210 WARN("Failed to open the SCM: %d\n", GetLastError());
6211 goto done;
6212 }
6213
6214 len = 0;
6215 if (!GetServiceDisplayNameW( scm, name, NULL, &len ) &&
6216 GetLastError() == ERROR_INSUFFICIENT_BUFFER)
6217 {
6218 if ((display_name = msi_alloc( ++len * sizeof(WCHAR ))))
6219 GetServiceDisplayNameW( scm, name, display_name, &len );
6220 }
6221
6222 service = OpenServiceW( scm, name, DELETE );
6223 if (!service)
6224 {
6225 WARN("Failed to open service (%s): %u\n", debugstr_w(name), GetLastError());
6226 goto done;
6227 }
6228
6229 if (!DeleteService( service ))
6230 WARN("Failed to delete service (%s): %u\n", debugstr_w(name), GetLastError());
6231
6232 done:
6233 uirow = MSI_CreateRecord( 2 );
6234 MSI_RecordSetStringW( uirow, 1, display_name );
6235 MSI_RecordSetStringW( uirow, 2, name );
6236 ui_actiondata( package, szDeleteServices, uirow );
6237 msiobj_release( &uirow->hdr );
6238
6239 CloseServiceHandle( service );
6240 CloseServiceHandle( scm );
6241 msi_free( name );
6242 msi_free( display_name );
6243
6244 return ERROR_SUCCESS;
6245 }
6246
6247 static UINT ACTION_DeleteServices( MSIPACKAGE *package )
6248 {
6249 UINT rc;
6250 MSIQUERY *view;
6251
6252 static const WCHAR query[] = {
6253 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6254 'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
6255
6256 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
6257 if (rc != ERROR_SUCCESS)
6258 return ERROR_SUCCESS;
6259
6260 rc = MSI_IterateRecords( view, NULL, ITERATE_DeleteService, package );
6261 msiobj_release( &view->hdr );
6262
6263 return rc;
6264 }
6265
6266 static UINT ITERATE_InstallODBCDriver( MSIRECORD *rec, LPVOID param )
6267 {
6268 MSIPACKAGE *package = param;
6269 LPWSTR driver, driver_path, ptr;
6270 WCHAR outpath[MAX_PATH];
6271 MSIFILE *driver_file = NULL, *setup_file = NULL;
6272 MSICOMPONENT *comp;
6273 MSIRECORD *uirow;
6274 LPCWSTR desc, file_key, component;
6275 DWORD len, usage;
6276 UINT r = ERROR_SUCCESS;
6277
6278 static const WCHAR driver_fmt[] = {
6279 'D','r','i','v','e','r','=','%','s',0};
6280 static const WCHAR setup_fmt[] = {
6281 'S','e','t','u','p','=','%','s',0};
6282 static const WCHAR usage_fmt[] = {
6283 'F','i','l','e','U','s','a','g','e','=','1',0};
6284
6285 component = MSI_RecordGetString( rec, 2 );
6286 comp = get_loaded_component( package, component );
6287 if (!comp)
6288 return ERROR_SUCCESS;
6289
6290 if (!comp->Enabled)
6291 {
6292 TRACE("component is disabled\n");
6293 return ERROR_SUCCESS;
6294 }
6295
6296 desc = MSI_RecordGetString(rec, 3);
6297
6298 file_key = MSI_RecordGetString( rec, 4 );
6299 if (file_key) driver_file = get_loaded_file( package, file_key );
6300
6301 file_key = MSI_RecordGetString( rec, 5 );
6302 if (file_key) setup_file = get_loaded_file( package, file_key );
6303
6304 if (!driver_file)
6305 {
6306 ERR("ODBC Driver entry not found!\n");
6307 return ERROR_FUNCTION_FAILED;
6308 }
6309
6310 len = lstrlenW(desc) + lstrlenW(driver_fmt) + lstrlenW(driver_file->FileName);
6311 if (setup_file)
6312 len += lstrlenW(setup_fmt) + lstrlenW(setup_file->FileName);
6313 len += lstrlenW(usage_fmt) + 2; /* \0\0 */
6314
6315 driver = msi_alloc(len * sizeof(WCHAR));
6316 if (!driver)
6317 return ERROR_OUTOFMEMORY;
6318
6319 ptr = driver;
6320 lstrcpyW(ptr, desc);
6321 ptr += lstrlenW(ptr) + 1;
6322
6323 len = sprintfW(ptr, driver_fmt, driver_file->FileName);
6324 ptr += len + 1;
6325
6326 if (setup_file)
6327 {
6328 len = sprintfW(ptr, setup_fmt, setup_file->FileName);
6329 ptr += len + 1;
6330 }
6331
6332 lstrcpyW(ptr, usage_fmt);
6333 ptr += lstrlenW(ptr) + 1;
6334 *ptr = '\0';
6335
6336 driver_path = strdupW(driver_file->TargetPath);
6337 ptr = strrchrW(driver_path, '\\');
6338 if (ptr) *ptr = '\0';
6339
6340 if (!SQLInstallDriverExW(driver, driver_path, outpath, MAX_PATH,
6341 NULL, ODBC_INSTALL_COMPLETE, &usage))
6342 {
6343 ERR("Failed to install SQL driver!\n");
6344 r = ERROR_FUNCTION_FAILED;
6345 }
6346
6347 uirow = MSI_CreateRecord( 5 );
6348 MSI_RecordSetStringW( uirow, 1, desc );
6349 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6350 MSI_RecordSetStringW( uirow, 3, driver_file->Component->Directory );
6351 ui_actiondata( package, szInstallODBC, uirow );
6352 msiobj_release( &uirow->hdr );
6353
6354 msi_free(driver);
6355 msi_free(driver_path);
6356
6357 return r;
6358 }
6359
6360 static UINT ITERATE_InstallODBCTranslator( MSIRECORD *rec, LPVOID param )
6361 {
6362 MSIPACKAGE *package = param;
6363 LPWSTR translator, translator_path, ptr;
6364 WCHAR outpath[MAX_PATH];
6365 MSIFILE *translator_file = NULL, *setup_file = NULL;
6366 MSICOMPONENT *comp;
6367 MSIRECORD *uirow;
6368 LPCWSTR desc, file_key, component;
6369 DWORD len, usage;
6370 UINT r = ERROR_SUCCESS;
6371
6372 static const WCHAR translator_fmt[] = {
6373 'T','r','a','n','s','l','a','t','o','r','=','%','s',0};
6374 static const WCHAR setup_fmt[] = {
6375 'S','e','t','u','p','=','%','s',0};
6376
6377 component = MSI_RecordGetString( rec, 2 );
6378 comp = get_loaded_component( package, component );
6379 if (!comp)
6380 return ERROR_SUCCESS;
6381
6382 if (!comp->Enabled)
6383 {
6384 TRACE("component is disabled\n");
6385 return ERROR_SUCCESS;
6386 }
6387
6388 desc = MSI_RecordGetString(rec, 3);
6389
6390 file_key = MSI_RecordGetString( rec, 4 );
6391 if (file_key) translator_file = get_loaded_file( package, file_key );
6392
6393 file_key = MSI_RecordGetString( rec, 5 );
6394 if (file_key) setup_file = get_loaded_file( package, file_key );
6395
6396 if (!translator_file)
6397 {
6398 ERR("ODBC Translator entry not found!\n");
6399 return ERROR_FUNCTION_FAILED;
6400 }
6401
6402 len = lstrlenW(desc) + lstrlenW(translator_fmt) + lstrlenW(translator_file->FileName) + 2; /* \0\0 */
6403 if (setup_file)
6404 len += lstrlenW(setup_fmt) + lstrlenW(setup_file->FileName);
6405
6406 translator = msi_alloc(len * sizeof(WCHAR));
6407 if (!translator)
6408 return ERROR_OUTOFMEMORY;
6409
6410 ptr = translator;
6411 lstrcpyW(ptr, desc);
6412 ptr += lstrlenW(ptr) + 1;
6413
6414 len = sprintfW(ptr, translator_fmt, translator_file->FileName);
6415 ptr += len + 1;
6416
6417 if (setup_file)
6418 {
6419 len = sprintfW(ptr, setup_fmt, setup_file->FileName);
6420 ptr += len + 1;
6421 }
6422 *ptr = '\0';
6423
6424 translator_path = strdupW(translator_file->TargetPath);
6425 ptr = strrchrW(translator_path, '\\');
6426 if (ptr) *ptr = '\0';
6427
6428 if (!SQLInstallTranslatorExW(translator, translator_path, outpath, MAX_PATH,
6429 NULL, ODBC_INSTALL_COMPLETE, &usage))
6430 {
6431 ERR("Failed to install SQL translator!\n");
6432 r = ERROR_FUNCTION_FAILED;
6433 }
6434
6435 uirow = MSI_CreateRecord( 5 );
6436 MSI_RecordSetStringW( uirow, 1, desc );
6437 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6438 MSI_RecordSetStringW( uirow, 3, translator_file->Component->Directory );
6439 ui_actiondata( package, szInstallODBC, uirow );
6440 msiobj_release( &uirow->hdr );
6441
6442 msi_free(translator);
6443 msi_free(translator_path);
6444
6445 return r;
6446 }
6447
6448 static UINT ITERATE_InstallODBCDataSource( MSIRECORD *rec, LPVOID param )
6449 {
6450 MSIPACKAGE *package = param;
6451 MSICOMPONENT *comp;
6452 LPWSTR attrs;
6453 LPCWSTR desc, driver, component;
6454 WORD request = ODBC_ADD_SYS_DSN;
6455 INT registration;
6456 DWORD len;
6457 UINT r = ERROR_SUCCESS;
6458 MSIRECORD *uirow;
6459
6460 static const WCHAR attrs_fmt[] = {
6461 'D','S','N','=','%','s',0 };
6462
6463 component = MSI_RecordGetString( rec, 2 );
6464 comp = get_loaded_component( package, component );
6465 if (!comp)
6466 return ERROR_SUCCESS;
6467
6468 if (!comp->Enabled)
6469 {
6470 TRACE("component is disabled\n");
6471 return ERROR_SUCCESS;
6472 }
6473
6474 desc = MSI_RecordGetString(rec, 3);
6475 driver = MSI_RecordGetString(rec, 4);
6476 registration = MSI_RecordGetInteger(rec, 5);
6477
6478 if (registration == msidbODBCDataSourceRegistrationPerMachine) request = ODBC_ADD_SYS_DSN;
6479 else if (registration == msidbODBCDataSourceRegistrationPerUser) request = ODBC_ADD_DSN;
6480
6481 len = lstrlenW(attrs_fmt) + lstrlenW(desc) + 2; /* \0\0 */
6482 attrs = msi_alloc(len * sizeof(WCHAR));
6483 if (!attrs)
6484 return ERROR_OUTOFMEMORY;
6485
6486 len = sprintfW(attrs, attrs_fmt, desc);
6487 attrs[len + 1] = 0;
6488
6489 if (!SQLConfigDataSourceW(NULL, request, driver, attrs))
6490 {
6491 ERR("Failed to install SQL data source!\n");
6492 r = ERROR_FUNCTION_FAILED;
6493 }
6494
6495 uirow = MSI_CreateRecord( 5 );
6496 MSI_RecordSetStringW( uirow, 1, desc );
6497 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6498 MSI_RecordSetInteger( uirow, 3, request );
6499 ui_actiondata( package, szInstallODBC, uirow );
6500 msiobj_release( &uirow->hdr );
6501
6502 msi_free(attrs);
6503
6504 return r;
6505 }
6506
6507 static UINT ACTION_InstallODBC( MSIPACKAGE *package )
6508 {
6509 UINT rc;
6510 MSIQUERY *view;
6511
6512 static const WCHAR driver_query[] = {
6513 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6514 'O','D','B','C','D','r','i','v','e','r',0 };
6515
6516 static const WCHAR translator_query[] = {
6517 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6518 'O','D','B','C','T','r','a','n','s','l','a','t','o','r',0 };
6519
6520 static const WCHAR source_query[] = {
6521 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6522 'O','D','B','C','D','a','t','a','S','o','u','r','c','e',0 };
6523
6524 rc = MSI_DatabaseOpenViewW(package->db, driver_query, &view);
6525 if (rc != ERROR_SUCCESS)
6526 return ERROR_SUCCESS;
6527
6528 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCDriver, package);
6529 msiobj_release(&view->hdr);
6530
6531 rc = MSI_DatabaseOpenViewW(package->db, translator_query, &view);
6532 if (rc != ERROR_SUCCESS)
6533 return ERROR_SUCCESS;
6534
6535 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCTranslator, package);
6536 msiobj_release(&view->hdr);
6537
6538 rc = MSI_DatabaseOpenViewW(package->db, source_query, &view);
6539 if (rc != ERROR_SUCCESS)
6540 return ERROR_SUCCESS;
6541
6542 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCDataSource, package);
6543 msiobj_release(&view->hdr);
6544
6545 return rc;
6546 }
6547
6548 static UINT ITERATE_RemoveODBCDriver( MSIRECORD *rec, LPVOID param )
6549 {
6550 MSIPACKAGE *package = param;
6551 MSICOMPONENT *comp;
6552 MSIRECORD *uirow;
6553 DWORD usage;
6554 LPCWSTR desc, component;
6555
6556 component = MSI_RecordGetString( rec, 2 );
6557 comp = get_loaded_component( package, component );
6558 if (!comp)
6559 return ERROR_SUCCESS;
6560
6561 if (!comp->Enabled)
6562 {
6563 TRACE("component is disabled\n");
6564 return ERROR_SUCCESS;
6565 }
6566
6567 desc = MSI_RecordGetString( rec, 3 );
6568 if (!SQLRemoveDriverW( desc, FALSE, &usage ))
6569 {
6570 WARN("Failed to remove ODBC driver\n");
6571 }
6572 else if (!usage)
6573 {
6574 FIXME("Usage count reached 0\n");
6575 }
6576
6577 uirow = MSI_CreateRecord( 2 );
6578 MSI_RecordSetStringW( uirow, 1, desc );
6579 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6580 ui_actiondata( package, szRemoveODBC, uirow );
6581 msiobj_release( &uirow->hdr );
6582
6583 return ERROR_SUCCESS;
6584 }
6585
6586 static UINT ITERATE_RemoveODBCTranslator( MSIRECORD *rec, LPVOID param )
6587 {
6588 MSIPACKAGE *package = param;
6589 MSICOMPONENT *comp;
6590 MSIRECORD *uirow;
6591 DWORD usage;
6592 LPCWSTR desc, component;
6593
6594 component = MSI_RecordGetString( rec, 2 );
6595 comp = get_loaded_component( package, component );
6596 if (!comp)
6597 return ERROR_SUCCESS;
6598
6599 if (!comp->Enabled)
6600 {
6601 TRACE("component is disabled\n");
6602 return ERROR_SUCCESS;
6603 }
6604
6605 desc = MSI_RecordGetString( rec, 3 );
6606 if (!SQLRemoveTranslatorW( desc, &usage ))
6607 {
6608 WARN("Failed to remove ODBC translator\n");
6609 }
6610 else if (!usage)
6611 {
6612 FIXME("Usage count reached 0\n");
6613 }
6614
6615 uirow = MSI_CreateRecord( 2 );
6616 MSI_RecordSetStringW( uirow, 1, desc );
6617 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6618 ui_actiondata( package, szRemoveODBC, uirow );
6619 msiobj_release( &uirow->hdr );
6620
6621 return ERROR_SUCCESS;
6622 }
6623
6624 static UINT ITERATE_RemoveODBCDataSource( MSIRECORD *rec, LPVOID param )
6625 {
6626 MSIPACKAGE *package = param;
6627 MSICOMPONENT *comp;
6628 MSIRECORD *uirow;
6629 LPWSTR attrs;
6630 LPCWSTR desc, driver, component;
6631 WORD request = ODBC_REMOVE_SYS_DSN;
6632 INT registration;
6633 DWORD len;
6634
6635 static const WCHAR attrs_fmt[] = {
6636 'D','S','N','=','%','s',0 };
6637
6638 component = MSI_RecordGetString( rec, 2 );
6639 comp = get_loaded_component( package, component );
6640 if (!comp)
6641 return ERROR_SUCCESS;
6642
6643 if (!comp->Enabled)
6644 {
6645 TRACE("component is disabled\n");
6646 return ERROR_SUCCESS;
6647 }
6648
6649 desc = MSI_RecordGetString( rec, 3 );
6650 driver = MSI_RecordGetString( rec, 4 );
6651 registration = MSI_RecordGetInteger( rec, 5 );
6652
6653 if (registration == msidbODBCDataSourceRegistrationPerMachine) request = ODBC_REMOVE_SYS_DSN;
6654 else if (registration == msidbODBCDataSourceRegistrationPerUser) request = ODBC_REMOVE_DSN;
6655
6656 len = strlenW( attrs_fmt ) + strlenW( desc ) + 2; /* \0\0 */
6657 attrs = msi_alloc( len * sizeof(WCHAR) );
6658 if (!attrs)
6659 return ERROR_OUTOFMEMORY;
6660
6661 FIXME("Use ODBCSourceAttribute table\n");
6662
6663 len = sprintfW( attrs, attrs_fmt, desc );
6664 attrs[len + 1] = 0;
6665
6666 if (!SQLConfigDataSourceW( NULL, request, driver, attrs ))
6667 {
6668 WARN("Failed to remove ODBC data source\n");
6669 }
6670 msi_free( attrs );
6671
6672 uirow = MSI_CreateRecord( 3 );
6673 MSI_RecordSetStringW( uirow, 1, desc );
6674 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6675 MSI_RecordSetInteger( uirow, 3, request );
6676 ui_actiondata( package, szRemoveODBC, uirow );
6677 msiobj_release( &uirow->hdr );
6678
6679 return ERROR_SUCCESS;
6680 }
6681
6682 static UINT ACTION_RemoveODBC( MSIPACKAGE *package )
6683 {
6684 UINT rc;
6685 MSIQUERY *view;
6686
6687 static const WCHAR driver_query[] = {
6688 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6689 'O','D','B','C','D','r','i','v','e','r',0 };
6690
6691 static const WCHAR translator_query[] = {
6692 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6693 'O','D','B','C','T','r','a','n','s','l','a','t','o','r',0 };
6694
6695 static const WCHAR source_query[] = {
6696 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6697 'O','D','B','C','D','a','t','a','S','o','u','r','c','e',0 };
6698
6699 rc = MSI_DatabaseOpenViewW( package->db, driver_query, &view );
6700 if (rc != ERROR_SUCCESS)
6701 return ERROR_SUCCESS;
6702
6703 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveODBCDriver, package );
6704 msiobj_release( &view->hdr );
6705
6706 rc = MSI_DatabaseOpenViewW( package->db, translator_query, &view );
6707 if (rc != ERROR_SUCCESS)
6708 return ERROR_SUCCESS;
6709
6710 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveODBCTranslator, package );
6711 msiobj_release( &view->hdr );
6712
6713 rc = MSI_DatabaseOpenViewW( package->db, source_query, &view );
6714 if (rc != ERROR_SUCCESS)
6715 return ERROR_SUCCESS;
6716
6717 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveODBCDataSource, package );
6718 msiobj_release( &view->hdr );
6719
6720 return rc;
6721 }
6722
6723 #define ENV_ACT_SETALWAYS 0x1
6724 #define ENV_ACT_SETABSENT 0x2
6725 #define ENV_ACT_REMOVE 0x4
6726 #define ENV_ACT_REMOVEMATCH 0x8
6727
6728 #define ENV_MOD_MACHINE 0x20000000
6729 #define ENV_MOD_APPEND 0x40000000
6730 #define ENV_MOD_PREFIX 0x80000000
6731 #define ENV_MOD_MASK 0xC0000000
6732
6733 #define check_flag_combo(x, y) ((x) & ~(y)) == (y)
6734
6735 static UINT env_parse_flags( LPCWSTR *name, LPCWSTR *value, DWORD *flags )
6736 {
6737 LPCWSTR cptr = *name;
6738
6739 static const WCHAR prefix[] = {'[','~',']',0};
6740 static const int prefix_len = 3;
6741
6742 *flags = 0;
6743 while (*cptr)
6744 {
6745 if (*cptr == '=')
6746 *flags |= ENV_ACT_SETALWAYS;
6747 else if (*cptr == '+')
6748 *flags |= ENV_ACT_SETABSENT;
6749 else if (*cptr == '-')
6750 *flags |= ENV_ACT_REMOVE;
6751 else if (*cptr == '!')
6752 *flags |= ENV_ACT_REMOVEMATCH;
6753 else if (*cptr == '*')
6754 *flags |= ENV_MOD_MACHINE;
6755 else
6756 break;
6757
6758 cptr++;
6759 (*name)++;
6760 }
6761
6762 if (!*cptr)
6763 {
6764 ERR("Missing environment variable\n");
6765 return ERROR_FUNCTION_FAILED;
6766 }
6767
6768 if (*value)
6769 {
6770 LPCWSTR ptr = *value;
6771 if (!strncmpW(ptr, prefix, prefix_len))
6772 {
6773 if (ptr[prefix_len] == szSemiColon[0])
6774 {
6775 *flags |= ENV_MOD_APPEND;
6776 *value += lstrlenW(prefix);
6777 }
6778 else
6779 {
6780 *value = NULL;
6781 }
6782 }
6783 else if (lstrlenW(*value) >= prefix_len)
6784 {
6785 ptr += lstrlenW(ptr) - prefix_len;
6786 if (!strcmpW( ptr, prefix ))
6787 {
6788 if ((ptr-1) > *value && *(ptr-1) == szSemiColon[0])
6789 {
6790 *flags |= ENV_MOD_PREFIX;
6791 /* the "[~]" will be removed by deformat_string */;
6792 }
6793 else
6794 {
6795 *value = NULL;
6796 }
6797 }
6798 }
6799 }
6800
6801 if (check_flag_combo(*flags, ENV_ACT_SETALWAYS | ENV_ACT_SETABSENT) ||
6802 check_flag_combo(*flags, ENV_ACT_REMOVEMATCH | ENV_ACT_SETABSENT) ||
6803 check_flag_combo(*flags, ENV_ACT_REMOVEMATCH | ENV_ACT_SETALWAYS) ||
6804 check_flag_combo(*flags, ENV_ACT_SETABSENT | ENV_MOD_MASK))
6805 {
6806 ERR("Invalid flags: %08x\n", *flags);
6807 return ERROR_FUNCTION_FAILED;
6808 }
6809
6810 if (!*flags)
6811 *flags = ENV_ACT_SETALWAYS | ENV_ACT_REMOVE;
6812
6813 return ERROR_SUCCESS;
6814 }
6815
6816 static UINT open_env_key( DWORD flags, HKEY *key )
6817 {
6818 static const WCHAR user_env[] =
6819 {'E','n','v','i','r','o','n','m','e','n','t',0};
6820 static const WCHAR machine_env[] =
6821 {'S','y','s','t','e','m','\\',
6822 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
6823 'C','o','n','t','r','o','l','\\',
6824 'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
6825 'E','n','v','i','r','o','n','m','e','n','t',0};
6826 const WCHAR *env;
6827 HKEY root;
6828 LONG res;
6829
6830 if (flags & ENV_MOD_MACHINE)
6831 {
6832 env = machine_env;
6833 root = HKEY_LOCAL_MACHINE;
6834 }
6835 else
6836 {
6837 env = user_env;
6838 root = HKEY_CURRENT_USER;
6839 }
6840
6841 res = RegOpenKeyExW( root, env, 0, KEY_ALL_ACCESS, key );
6842 if (res != ERROR_SUCCESS)
6843 {
6844 WARN("Failed to open key %s (%d)\n", debugstr_w(env), res);
6845 return ERROR_FUNCTION_FAILED;
6846 }
6847
6848 return ERROR_SUCCESS;
6849 }
6850
6851 static UINT ITERATE_WriteEnvironmentString( MSIRECORD *rec, LPVOID param )
6852 {
6853 MSIPACKAGE *package = param;
6854 LPCWSTR name, value, component;
6855 LPWSTR data = NULL, newval = NULL, deformatted = NULL, ptr;
6856 DWORD flags, type, size;
6857 UINT res;
6858 HKEY env = NULL;
6859 MSICOMPONENT *comp;
6860 MSIRECORD *uirow;
6861 int action = 0;
6862
6863 component = MSI_RecordGetString(rec, 4);
6864 comp = get_loaded_component(package, component);
6865 if (!comp)
6866 return ERROR_SUCCESS;
6867
6868 if (!comp->Enabled)
6869 {
6870 TRACE("component is disabled\n");
6871 return ERROR_SUCCESS;
6872 }
6873
6874 if (comp->ActionRequest != INSTALLSTATE_LOCAL)
6875 {
6876 TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
6877 comp->Action = comp->Installed;
6878 return ERROR_SUCCESS;
6879 }
6880 comp->Action = INSTALLSTATE_LOCAL;
6881
6882 name = MSI_RecordGetString(rec, 2);
6883 value = MSI_RecordGetString(rec, 3);
6884
6885 TRACE("name %s value %s\n", debugstr_w(name), debugstr_w(value));
6886
6887 res = env_parse_flags(&name, &value, &flags);
6888 if (res != ERROR_SUCCESS || !value)
6889 goto done;
6890
6891 if (value && !deformat_string(package, value, &deformatted))
6892 {
6893 res = ERROR_OUTOFMEMORY;
6894 goto done;
6895 }
6896
6897 value = deformatted;
6898
6899 res = open_env_key( flags, &env );
6900 if (res != ERROR_SUCCESS)
6901 goto done;
6902
6903 if (flags & ENV_MOD_MACHINE)
6904 action |= 0x20000000;
6905
6906 size = 0;
6907 type = REG_SZ;
6908 res = RegQueryValueExW(env, name, NULL, &type, NULL, &size);
6909 if ((res != ERROR_SUCCESS && res != ERROR_FILE_NOT_FOUND) ||
6910 (res == ERROR_SUCCESS && type != REG_SZ && type != REG_EXPAND_SZ))
6911 goto done;
6912
6913 if ((res == ERROR_FILE_NOT_FOUND || !(flags & ENV_MOD_MASK)))
6914 {
6915 action = 0x2;
6916
6917 /* Nothing to do. */
6918 if (!value)
6919 {
6920 res = ERROR_SUCCESS;
6921 goto done;
6922 }
6923
6924 /* If we are appending but the string was empty, strip ; */
6925 if ((flags & ENV_MOD_APPEND) && (value[0] == szSemiColon[0])) value++;
6926
6927 size = (lstrlenW(value) + 1) * sizeof(WCHAR);
6928 newval = strdupW(value);
6929 if (!newval)
6930 {
6931 res = ERROR_OUTOFMEMORY;
6932 goto done;
6933 }
6934 }
6935 else
6936 {
6937 action = 0x1;
6938
6939 /* Contrary to MSDN, +-variable to [~];path works */
6940 if (flags & ENV_ACT_SETABSENT && !(flags & ENV_MOD_MASK))
6941 {
6942 res = ERROR_SUCCESS;
6943 goto done;
6944 }
6945
6946 data = msi_alloc(size);
6947 if (!data)
6948 {
6949 RegCloseKey(env);
6950 return ERROR_OUTOFMEMORY;
6951 }
6952
6953 res = RegQueryValueExW(env, name, NULL, &type, (LPVOID)data, &size);
6954 if (res != ERROR_SUCCESS)
6955 goto done;
6956
6957 if (flags & ENV_ACT_REMOVEMATCH && (!value || !strcmpW( data, value )))
6958 {
6959 action = 0x4;
6960 res = RegDeleteValueW(env, name);
6961 if (res != ERROR_SUCCESS)
6962 WARN("Failed to remove value %s (%d)\n", debugstr_w(name), res);
6963 goto done;
6964 }
6965
6966 size = (lstrlenW(data) + 1) * sizeof(WCHAR);
6967 if (flags & ENV_MOD_MASK)
6968 {
6969 DWORD mod_size;
6970 int multiplier = 0;
6971 if (flags & ENV_MOD_APPEND) multiplier++;
6972 if (flags & ENV_MOD_PREFIX) multiplier++;
6973 mod_size = lstrlenW(value) * multiplier;
6974 size += mod_size * sizeof(WCHAR);
6975 }
6976
6977 newval = msi_alloc(size);
6978 ptr = newval;
6979 if (!newval)
6980 {
6981 res = ERROR_OUTOFMEMORY;
6982 goto done;
6983 }
6984
6985 if (flags & ENV_MOD_PREFIX)
6986 {
6987 lstrcpyW(newval, value);
6988 ptr = newval + lstrlenW(value);
6989 action |= 0x80000000;
6990 }
6991
6992 lstrcpyW(ptr, data);
6993
6994 if (flags & ENV_MOD_APPEND)
6995 {
6996 lstrcatW(newval, value);
6997 action |= 0x40000000;
6998 }
6999 }
7000 TRACE("setting %s to %s\n", debugstr_w(name), debugstr_w(newval));
7001 res = RegSetValueExW(env, name, 0, type, (LPVOID)newval, size);
7002 if (res)
7003 {
7004 WARN("Failed to set %s to %s (%d)\n", debugstr_w(name), debugstr_w(newval), res);
7005 }
7006
7007 done:
7008 uirow = MSI_CreateRecord( 3 );
7009 MSI_RecordSetStringW( uirow, 1, name );
7010 MSI_RecordSetStringW( uirow, 2, newval );
7011 MSI_RecordSetInteger( uirow, 3, action );
7012 ui_actiondata( package, szWriteEnvironmentStrings, uirow );
7013 msiobj_release( &uirow->hdr );
7014
7015 if (env) RegCloseKey(env);
7016 msi_free(deformatted);
7017 msi_free(data);
7018 msi_free(newval);
7019 return res;
7020 }
7021
7022 static UINT ACTION_WriteEnvironmentStrings( MSIPACKAGE *package )
7023 {
7024 UINT rc;
7025 MSIQUERY * view;
7026 static const WCHAR ExecSeqQuery[] =
7027 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
7028 '`','E','n','v','i','r','o','n','m','e','n','t','`',0};
7029 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
7030 if (rc != ERROR_SUCCESS)
7031 return ERROR_SUCCESS;
7032
7033 rc = MSI_IterateRecords(view, NULL, ITERATE_WriteEnvironmentString, package);
7034 msiobj_release(&view->hdr);
7035
7036 return rc;
7037 }
7038
7039 static UINT ITERATE_RemoveEnvironmentString( MSIRECORD *rec, LPVOID param )
7040 {
7041 MSIPACKAGE *package = param;
7042 LPCWSTR name, value, component;
7043 LPWSTR deformatted = NULL;
7044 DWORD flags;
7045 HKEY env;
7046 MSICOMPONENT *comp;
7047 MSIRECORD *uirow;
7048 int action = 0;
7049 LONG res;
7050 UINT r;
7051
7052 component = MSI_RecordGetString( rec, 4 );
7053 comp = get_loaded_component( package, component );
7054 if (!comp)
7055 return ERROR_SUCCESS;
7056
7057 if (!comp->Enabled)
7058 {
7059 TRACE("component is disabled\n");
7060 return ERROR_SUCCESS;
7061 }
7062
7063 if (comp->ActionRequest != INSTALLSTATE_ABSENT)
7064 {
7065 TRACE("Component not scheduled for removal: %s\n", debugstr_w(component));
7066 comp->Action = comp->Installed;
7067 return ERROR_SUCCESS;
7068 }
7069 comp->Action = INSTALLSTATE_ABSENT;
7070
7071 name = MSI_RecordGetString( rec, 2 );
7072 value = MSI_RecordGetString( rec, 3 );
7073
7074 TRACE("name %s value %s\n", debugstr_w(name), debugstr_w(value));
7075
7076 r = env_parse_flags( &name, &value, &flags );
7077 if (r != ERROR_SUCCESS)
7078 return r;
7079
7080 if (!(flags & ENV_ACT_REMOVE))
7081 {
7082 TRACE("Environment variable %s not marked for removal\n", debugstr_w(name));
7083 return ERROR_SUCCESS;
7084 }
7085
7086 if (value && !deformat_string( package, value, &deformatted ))
7087 return ERROR_OUTOFMEMORY;
7088
7089 value = deformatted;
7090
7091 r = open_env_key( flags, &env );
7092 if (r != ERROR_SUCCESS)
7093 {
7094 r = ERROR_SUCCESS;
7095 goto done;
7096 }
7097
7098 if (flags & ENV_MOD_MACHINE)
7099 action |= 0x20000000;
7100
7101 TRACE("Removing %s\n", debugstr_w(name));
7102
7103 res = RegDeleteValueW( env, name );
7104 if (res != ERROR_SUCCESS)
7105 {
7106 WARN("Failed to delete value %s (%d)\n", debugstr_w(name), res);
7107 r = ERROR_SUCCESS;
7108 }
7109
7110 done:
7111 uirow = MSI_CreateRecord( 3 );
7112 MSI_RecordSetStringW( uirow, 1, name );
7113 MSI_RecordSetStringW( uirow, 2, value );
7114 MSI_RecordSetInteger( uirow, 3, action );
7115 ui_actiondata( package, szRemoveEnvironmentStrings, uirow );
7116 msiobj_release( &uirow->hdr );
7117
7118 if (env) RegCloseKey( env );
7119 msi_free( deformatted );
7120 return r;
7121 }
7122
7123 static UINT ACTION_RemoveEnvironmentStrings( MSIPACKAGE *package )
7124 {
7125 UINT rc;
7126 MSIQUERY *view;
7127 static const WCHAR query[] =
7128 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
7129 '`','E','n','v','i','r','o','n','m','e','n','t','`',0};
7130
7131 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
7132 if (rc != ERROR_SUCCESS)
7133 return ERROR_SUCCESS;
7134
7135 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveEnvironmentString, package );
7136 msiobj_release( &view->hdr );
7137
7138 return rc;
7139 }
7140
7141 static UINT ACTION_ValidateProductID( MSIPACKAGE *package )
7142 {
7143 LPWSTR key, template, id;
7144 UINT r = ERROR_SUCCESS;
7145
7146 id = msi_dup_property( package->db, szProductID );
7147 if (id)
7148 {
7149 msi_free( id );
7150 return ERROR_SUCCESS;
7151 }
7152 template = msi_dup_property( package->db, szPIDTemplate );
7153 key = msi_dup_property( package->db, szPIDKEY );
7154
7155 if (key && template)
7156 {
7157 FIXME( "partial stub: template %s key %s\n", debugstr_w(template), debugstr_w(key) );
7158 r = msi_set_property( package->db, szProductID, key );
7159 }
7160 msi_free( template );
7161 msi_free( key );
7162 return r;
7163 }
7164
7165 static UINT ACTION_ScheduleReboot( MSIPACKAGE *package )
7166 {
7167 TRACE("\n");
7168 package->need_reboot = 1;
7169 return ERROR_SUCCESS;
7170 }
7171
7172 static UINT ACTION_AllocateRegistrySpace( MSIPACKAGE *package )
7173 {
7174 static const WCHAR szAvailableFreeReg[] =
7175 {'A','V','A','I','L','A','B','L','E','F','R','E','E','R','E','G',0};
7176 MSIRECORD *uirow;
7177 int space = msi_get_property_int( package->db, szAvailableFreeReg, 0 );
7178
7179 TRACE("%p %d kilobytes\n", package, space);
7180
7181 uirow = MSI_CreateRecord( 1 );
7182 MSI_RecordSetInteger( uirow, 1, space );
7183 ui_actiondata( package, szAllocateRegistrySpace, uirow );
7184 msiobj_release( &uirow->hdr );
7185
7186 return ERROR_SUCCESS;
7187 }
7188
7189 static UINT ACTION_DisableRollback( MSIPACKAGE *package )
7190 {
7191 FIXME("%p\n", package);
7192 return ERROR_SUCCESS;
7193 }
7194
7195 static UINT ACTION_InstallAdminPackage( MSIPACKAGE *package )
7196 {
7197 FIXME("%p\n", package);
7198 return ERROR_SUCCESS;
7199 }
7200
7201 static UINT ACTION_SetODBCFolders( MSIPACKAGE *package )
7202 {
7203 UINT r, count;
7204 MSIQUERY *view;
7205
7206 static const WCHAR driver_query[] = {
7207 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
7208 'O','D','B','C','D','r','i','v','e','r',0 };
7209
7210 static const WCHAR translator_query[] = {
7211 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
7212 'O','D','B','C','T','r','a','n','s','l','a','t','o','r',0 };
7213
7214 r = MSI_DatabaseOpenViewW( package->db, driver_query, &view );
7215 if (r == ERROR_SUCCESS)
7216 {
7217 count = 0;
7218 r = MSI_IterateRecords( view, &count, NULL, package );
7219 msiobj_release( &view->hdr );
7220 if (count) FIXME("ignored %u rows in ODBCDriver table\n", count);
7221 }
7222
7223 r = MSI_DatabaseOpenViewW( package->db, translator_query, &view );
7224 if (r == ERROR_SUCCESS)
7225 {
7226 count = 0;
7227 r = MSI_IterateRecords( view, &count, NULL, package );
7228 msiobj_release( &view->hdr );
7229 if (count) FIXME("ignored %u rows in ODBCTranslator table\n", count);
7230 }
7231
7232 return ERROR_SUCCESS;
7233 }
7234
7235 static UINT ITERATE_RemoveExistingProducts( MSIRECORD *rec, LPVOID param )
7236 {
7237 MSIPACKAGE *package = param;
7238 const WCHAR *property = MSI_RecordGetString( rec, 1 );
7239 WCHAR *value;
7240
7241 if ((value = msi_dup_property( package->db, property )))
7242 {
7243 FIXME("remove %s\n", debugstr_w(value));
7244 msi_free( value );
7245 }
7246 return ERROR_SUCCESS;
7247 }
7248
7249 static UINT ACTION_RemoveExistingProducts( MSIPACKAGE *package )
7250 {
7251 UINT r;
7252 MSIQUERY *view;
7253
7254 static const WCHAR query[] =
7255 {'S','E','L','E','C','T',' ','A','c','t','i','o','n','P','r','o','p','e','r','t','y',
7256 ' ','F','R','O','M',' ','U','p','g','r','a','d','e',0};
7257
7258 r = MSI_DatabaseOpenViewW( package->db, query, &view );
7259 if (r == ERROR_SUCCESS)
7260 {
7261 r = MSI_IterateRecords( view, NULL, ITERATE_RemoveExistingProducts, package );
7262 msiobj_release( &view->hdr );
7263 }
7264 return ERROR_SUCCESS;
7265 }
7266
7267 static UINT ITERATE_MigrateFeatureStates( MSIRECORD *rec, LPVOID param )
7268 {
7269 MSIPACKAGE *package = param;
7270 int attributes = MSI_RecordGetInteger( rec, 5 );
7271
7272 if (attributes & msidbUpgradeAttributesMigrateFeatures)
7273 {
7274 const WCHAR *upgrade_code = MSI_RecordGetString( rec, 1 );
7275 const WCHAR *version_min = MSI_RecordGetString( rec, 2 );
7276 const WCHAR *version_max = MSI_RecordGetString( rec, 3 );
7277 const WCHAR *language = MSI_RecordGetString( rec, 4 );
7278 HKEY hkey;
7279 UINT r;
7280
7281 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
7282 {
7283 r = MSIREG_OpenClassesUpgradeCodesKey( upgrade_code, &hkey, FALSE );
7284 if (r != ERROR_SUCCESS)
7285 return ERROR_SUCCESS;
7286 }
7287 else
7288 {
7289 r = MSIREG_OpenUserUpgradeCodesKey( upgrade_code, &hkey, FALSE );
7290 if (r != ERROR_SUCCESS)
7291 return ERROR_SUCCESS;
7292 }
7293 RegCloseKey( hkey );
7294
7295 FIXME("migrate feature states from %s version min %s version max %s language %s\n",
7296 debugstr_w(upgrade_code), debugstr_w(version_min),
7297 debugstr_w(version_max), debugstr_w(language));
7298 }
7299 return ERROR_SUCCESS;
7300 }
7301
7302 static UINT ACTION_MigrateFeatureStates( MSIPACKAGE *package )
7303 {
7304 UINT r;
7305 MSIQUERY *view;
7306
7307 static const WCHAR query[] =
7308 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','U','p','g','r','a','d','e',0};
7309
7310 if (msi_get_property_int( package->db, szInstalled, 0 ))
7311 {
7312 TRACE("product is installed, skipping action\n");
7313 return ERROR_SUCCESS;
7314 }
7315 if (msi_get_property_int( package->db, szPreselected, 0 ))
7316 {
7317 TRACE("Preselected property is set, not migrating feature states\n");
7318 return ERROR_SUCCESS;
7319 }
7320
7321 r = MSI_DatabaseOpenViewW( package->db, query, &view );
7322 if (r == ERROR_SUCCESS)
7323 {
7324 r = MSI_IterateRecords( view, NULL, ITERATE_MigrateFeatureStates, package );
7325 msiobj_release( &view->hdr );
7326 }
7327 return ERROR_SUCCESS;
7328 }
7329
7330 static UINT msi_unimplemented_action_stub( MSIPACKAGE *package,
7331 LPCSTR action, LPCWSTR table )
7332 {
7333 static const WCHAR query[] = {
7334 'S','E','L','E','C','T',' ','*',' ',
7335 'F','R','O','M',' ','`','%','s','`',0 };
7336 MSIQUERY *view = NULL;
7337 DWORD count = 0;
7338 UINT r;
7339
7340 r = MSI_OpenQuery( package->db, &view, query, table );
7341 if (r == ERROR_SUCCESS)
7342 {
7343 r = MSI_IterateRecords(view, &count, NULL, package);
7344 msiobj_release(&view->hdr);
7345 }
7346
7347 if (count)
7348 FIXME("%s -> %u ignored %s table values\n",
7349 action, count, debugstr_w(table));
7350
7351 return ERROR_SUCCESS;
7352 }
7353
7354 static UINT ACTION_PatchFiles( MSIPACKAGE *package )
7355 {
7356 static const WCHAR table[] = { 'P','a','t','c','h',0 };
7357 return msi_unimplemented_action_stub( package, "PatchFiles", table );
7358 }
7359
7360 static UINT ACTION_BindImage( MSIPACKAGE *package )
7361 {
7362 static const WCHAR table[] = { 'B','i','n','d','I','m','a','g','e',0 };
7363 return msi_unimplemented_action_stub( package, "BindImage", table );
7364 }
7365
7366 static UINT ACTION_IsolateComponents( MSIPACKAGE *package )
7367 {
7368 static const WCHAR table[] = {
7369 'I','s','o','l','a','t','e','d','C','o','m','p','o','n','e','n','t',0 };
7370 return msi_unimplemented_action_stub( package, "IsolateComponents", table );
7371 }
7372
7373 static UINT ACTION_RMCCPSearch( MSIPACKAGE *package )
7374 {
7375 static const WCHAR table[] = { 'C','C','P','S','e','a','r','c','h',0 };
7376 return msi_unimplemented_action_stub( package, "RMCCPSearch", table );
7377 }
7378
7379 static UINT ACTION_RegisterComPlus( MSIPACKAGE *package )
7380 {
7381 static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
7382 return msi_unimplemented_action_stub( package, "RegisterComPlus", table );
7383 }
7384
7385 static UINT ACTION_UnregisterComPlus( MSIPACKAGE *package )
7386 {
7387 static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
7388 return msi_unimplemented_action_stub( package, "UnregisterComPlus", table );
7389 }
7390
7391 static UINT ACTION_InstallSFPCatalogFile( MSIPACKAGE *package )
7392 {
7393 static const WCHAR table[] = { 'S','F','P','C','a','t','a','l','o','g',0 };
7394 return msi_unimplemented_action_stub( package, "InstallSFPCatalogFile", table );
7395 }
7396
7397 typedef UINT (*STANDARDACTIONHANDLER)(MSIPACKAGE*);
7398
7399 static const struct
7400 {
7401 const WCHAR *action;
7402 UINT (*handler)(MSIPACKAGE *);
7403 }
7404 StandardActions[] =
7405 {
7406 { szAllocateRegistrySpace, ACTION_AllocateRegistrySpace },
7407 { szAppSearch, ACTION_AppSearch },
7408 { szBindImage, ACTION_BindImage },
7409 { szCCPSearch, ACTION_CCPSearch },
7410 { szCostFinalize, ACTION_CostFinalize },
7411 { szCostInitialize, ACTION_CostInitialize },
7412 { szCreateFolders, ACTION_CreateFolders },
7413 { szCreateShortcuts, ACTION_CreateShortcuts },
7414 { szDeleteServices, ACTION_DeleteServices },
7415 { szDisableRollback, ACTION_DisableRollback },
7416 { szDuplicateFiles, ACTION_DuplicateFiles },
7417 { szExecuteAction, ACTION_ExecuteAction },
7418 { szFileCost, ACTION_FileCost },
7419 { szFindRelatedProducts, ACTION_FindRelatedProducts },
7420 { szForceReboot, ACTION_ForceReboot },
7421 { szInstallAdminPackage, ACTION_InstallAdminPackage },
7422 { szInstallExecute, ACTION_InstallExecute },
7423 { szInstallExecuteAgain, ACTION_InstallExecute },
7424 { szInstallFiles, ACTION_InstallFiles},
7425 { szInstallFinalize, ACTION_InstallFinalize },
7426 { szInstallInitialize, ACTION_InstallInitialize },
7427 { szInstallSFPCatalogFile, ACTION_InstallSFPCatalogFile },
7428 { szInstallValidate, ACTION_InstallValidate },
7429 { szIsolateComponents, ACTION_IsolateComponents },
7430 { szLaunchConditions, ACTION_LaunchConditions },
7431 { szMigrateFeatureStates, ACTION_MigrateFeatureStates },
7432 { szMoveFiles, ACTION_MoveFiles },
7433 { szMsiPublishAssemblies, ACTION_MsiPublishAssemblies },
7434 { szMsiUnpublishAssemblies, ACTION_MsiUnpublishAssemblies },
7435 { szInstallODBC, ACTION_InstallODBC },
7436 { szInstallServices, ACTION_InstallServices },
7437 { szPatchFiles, ACTION_PatchFiles },
7438 { szProcessComponents, ACTION_ProcessComponents },
7439 { szPublishComponents, ACTION_PublishComponents },
7440 { szPublishFeatures, ACTION_PublishFeatures },
7441 { szPublishProduct, ACTION_PublishProduct },
7442 { szRegisterClassInfo, ACTION_RegisterClassInfo },
7443 { szRegisterComPlus, ACTION_RegisterComPlus},
7444 { szRegisterExtensionInfo, ACTION_RegisterExtensionInfo },
7445 { szRegisterFonts, ACTION_RegisterFonts },
7446 { szRegisterMIMEInfo, ACTION_RegisterMIMEInfo },
7447 { szRegisterProduct, ACTION_RegisterProduct },
7448 { szRegisterProgIdInfo, ACTION_RegisterProgIdInfo },
7449 { szRegisterTypeLibraries, ACTION_RegisterTypeLibraries },
7450 { szRegisterUser, ACTION_RegisterUser },
7451 { szRemoveDuplicateFiles, ACTION_RemoveDuplicateFiles },
7452 { szRemoveEnvironmentStrings, ACTION_RemoveEnvironmentStrings },
7453 { szRemoveExistingProducts, ACTION_RemoveExistingProducts },
7454 { szRemoveFiles, ACTION_RemoveFiles },
7455 { szRemoveFolders, ACTION_RemoveFolders },
7456 { szRemoveIniValues, ACTION_RemoveIniValues },
7457 { szRemoveODBC, ACTION_RemoveODBC },
7458 { szRemoveRegistryValues, ACTION_RemoveRegistryValues },
7459 { szRemoveShortcuts, ACTION_RemoveShortcuts },
7460 { szResolveSource, ACTION_ResolveSource },
7461 { szRMCCPSearch, ACTION_RMCCPSearch },
7462 { szScheduleReboot, ACTION_ScheduleReboot },
7463 { szSelfRegModules, ACTION_SelfRegModules },
7464 { szSelfUnregModules, ACTION_SelfUnregModules },
7465 { szSetODBCFolders, ACTION_SetODBCFolders },
7466 { szStartServices, ACTION_StartServices },
7467 { szStopServices, ACTION_StopServices },
7468 { szUnpublishComponents, ACTION_UnpublishComponents },
7469 { szUnpublishFeatures, ACTION_UnpublishFeatures },
7470 { szUnregisterClassInfo, ACTION_UnregisterClassInfo },
7471 { szUnregisterComPlus, ACTION_UnregisterComPlus },
7472 { szUnregisterExtensionInfo, ACTION_UnregisterExtensionInfo },
7473 { szUnregisterFonts, ACTION_UnregisterFonts },
7474 { szUnregisterMIMEInfo, ACTION_UnregisterMIMEInfo },
7475 { szUnregisterProgIdInfo, ACTION_UnregisterProgIdInfo },
7476 { szUnregisterTypeLibraries, ACTION_UnregisterTypeLibraries },
7477 { szValidateProductID, ACTION_ValidateProductID },
7478 { szWriteEnvironmentStrings, ACTION_WriteEnvironmentStrings },
7479 { szWriteIniValues, ACTION_WriteIniValues },
7480 { szWriteRegistryValues, ACTION_WriteRegistryValues },
7481 { NULL, NULL },
7482 };
7483
7484 static BOOL ACTION_HandleStandardAction( MSIPACKAGE *package, LPCWSTR action, UINT *rc )
7485 {
7486 BOOL ret = FALSE;
7487 UINT i;
7488
7489 i = 0;
7490 while (StandardActions[i].action != NULL)
7491 {
7492 if (!strcmpW( StandardActions[i].action, action ))
7493 {
7494 ui_actionstart( package, action );
7495 if (StandardActions[i].handler)
7496 {
7497 ui_actioninfo( package, action, TRUE, 0 );
7498 *rc = StandardActions[i].handler( package );
7499 ui_actioninfo( package, action, FALSE, *rc );
7500 }
7501 else
7502 {
7503 FIXME("unhandled standard action %s\n", debugstr_w(action));
7504 *rc = ERROR_SUCCESS;
7505 }
7506 ret = TRUE;
7507 break;
7508 }
7509 i++;
7510 }
7511 return ret;
7512 }
7513
7514 UINT ACTION_PerformAction(MSIPACKAGE *package, const WCHAR *action, UINT script)
7515 {
7516 UINT rc = ERROR_SUCCESS;
7517 BOOL handled;
7518
7519 TRACE("Performing action (%s)\n", debugstr_w(action));
7520
7521 handled = ACTION_HandleStandardAction(package, action, &rc);
7522
7523 if (!handled)
7524 handled = ACTION_HandleCustomAction(package, action, &rc, script, TRUE);
7525
7526 if (!handled)
7527 {
7528 WARN("unhandled msi action %s\n", debugstr_w(action));
7529 rc = ERROR_FUNCTION_NOT_CALLED;
7530 }
7531
7532 return rc;
7533 }
7534
7535 UINT ACTION_PerformUIAction(MSIPACKAGE *package, const WCHAR *action, UINT script)
7536 {
7537 UINT rc = ERROR_SUCCESS;
7538 BOOL handled = FALSE;
7539
7540 TRACE("Performing action (%s)\n", debugstr_w(action));
7541
7542 handled = ACTION_HandleStandardAction(package, action, &rc);
7543
7544 if (!handled)
7545 handled = ACTION_HandleCustomAction(package, action, &rc, script, FALSE);
7546
7547 if( !handled && ACTION_DialogBox(package, action) == ERROR_SUCCESS )
7548 handled = TRUE;
7549
7550 if (!handled)
7551 {
7552 WARN("unhandled msi action %s\n", debugstr_w(action));
7553 rc = ERROR_FUNCTION_NOT_CALLED;
7554 }
7555
7556 return rc;
7557 }
7558
7559 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq)
7560 {
7561 UINT rc = ERROR_SUCCESS;
7562 MSIRECORD *row;
7563
7564 static const WCHAR ExecSeqQuery[] =
7565 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
7566 '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
7567 'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
7568 '`','S','e','q','u','e','n','c','e','`',' ', '=',' ','%','i',0};
7569 static const WCHAR UISeqQuery[] =
7570 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
7571 '`','I','n','s','t','a','l','l','U','I','S','e','q','u','e','n','c','e',
7572 '`', ' ', 'W','H','E','R','E',' ','`','S','e','q','u','e','n','c','e','`',
7573 ' ', '=',' ','%','i',0};
7574
7575 if (needs_ui_sequence(package))
7576 row = MSI_QueryGetRecord(package->db, UISeqQuery, seq);
7577 else
7578 row = MSI_QueryGetRecord(package->db, ExecSeqQuery, seq);
7579
7580 if (row)
7581 {
7582 LPCWSTR action, cond;
7583
7584 TRACE("Running the actions\n");
7585
7586 /* check conditions */
7587 cond = MSI_RecordGetString(row, 2);
7588
7589 /* this is a hack to skip errors in the condition code */
7590 if (MSI_EvaluateConditionW(package, cond) == MSICONDITION_FALSE)
7591 {
7592 msiobj_release(&row->hdr);
7593 return ERROR_SUCCESS;
7594 }
7595
7596 action = MSI_RecordGetString(row, 1);
7597 if (!action)
7598 {
7599 ERR("failed to fetch action\n");
7600 msiobj_release(&row->hdr);
7601 return ERROR_FUNCTION_FAILED;
7602 }
7603
7604 if (needs_ui_sequence(package))
7605 rc = ACTION_PerformUIAction(package, action, -1);
7606 else
7607 rc = ACTION_PerformAction(package, action, -1);
7608
7609 msiobj_release(&row->hdr);
7610 }
7611
7612 return rc;
7613 }
7614
7615 /****************************************************
7616 * TOP level entry points
7617 *****************************************************/
7618
7619 UINT MSI_InstallPackage( MSIPACKAGE *package, LPCWSTR szPackagePath,
7620 LPCWSTR szCommandLine )
7621 {
7622 UINT rc;
7623 BOOL ui_exists;
7624
7625 static const WCHAR szAction[] = {'A','C','T','I','O','N',0};
7626 static const WCHAR szInstall[] = {'I','N','S','T','A','L','L',0};
7627
7628 msi_set_property( package->db, szAction, szInstall );
7629
7630 package->script->InWhatSequence = SEQUENCE_INSTALL;
7631
7632 if (szPackagePath)
7633 {
7634 LPWSTR p, dir;
7635 LPCWSTR file;
7636
7637 dir = strdupW(szPackagePath);
7638 p = strrchrW(dir, '\\');
7639 if (p)
7640 {
7641 *(++p) = 0;
7642 file = szPackagePath + (p - dir);
7643 }
7644 else
7645 {
7646 msi_free(dir);
7647 dir = msi_alloc(MAX_PATH * sizeof(WCHAR));
7648 GetCurrentDirectoryW(MAX_PATH, dir);
7649 lstrcatW(dir, szBackSlash);
7650 file = szPackagePath;
7651 }
7652
7653 msi_free( package->PackagePath );
7654 package->PackagePath = msi_alloc((lstrlenW(dir) + lstrlenW(file) + 1) * sizeof(WCHAR));
7655 if (!package->PackagePath)
7656 {
7657 msi_free(dir);
7658 return ERROR_OUTOFMEMORY;
7659 }
7660
7661 lstrcpyW(package->PackagePath, dir);
7662 lstrcatW(package->PackagePath, file);
7663 msi_free(dir);
7664
7665 msi_set_sourcedir_props(package, FALSE);
7666 }
7667
7668 rc = msi_parse_command_line( package, szCommandLine, FALSE );
7669 if (rc != ERROR_SUCCESS)
7670 return rc;
7671
7672 msi_apply_transforms( package );
7673 msi_apply_patches( package );
7674
7675 if (!szCommandLine && msi_get_property_int( package->db, szInstalled, 0 ))
7676 {
7677 TRACE("setting reinstall property\n");
7678 msi_set_property( package->db, szReinstall, szAll );
7679 }
7680
7681 /* properties may have been added by a transform */
7682 msi_clone_properties( package );
7683
7684 msi_parse_command_line( package, szCommandLine, FALSE );
7685 msi_adjust_privilege_properties( package );
7686 msi_set_context( package );
7687
7688 if (needs_ui_sequence( package))
7689 {
7690 package->script->InWhatSequence |= SEQUENCE_UI;
7691 rc = ACTION_ProcessUISequence(package);
7692 ui_exists = ui_sequence_exists(package);
7693 if (rc == ERROR_SUCCESS || !ui_exists)
7694 {
7695 package->script->InWhatSequence |= SEQUENCE_EXEC;
7696 rc = ACTION_ProcessExecSequence(package, ui_exists);
7697 }
7698 }
7699 else
7700 rc = ACTION_ProcessExecSequence(package, FALSE);
7701
7702 package->script->CurrentlyScripting = FALSE;
7703
7704 /* process the ending type action */
7705 if (rc == ERROR_SUCCESS)
7706 ACTION_PerformActionSequence(package, -1);
7707 else if (rc == ERROR_INSTALL_USEREXIT)
7708 ACTION_PerformActionSequence(package, -2);
7709 else if (rc == ERROR_INSTALL_SUSPEND)
7710 ACTION_PerformActionSequence(package, -4);
7711 else /* failed */
7712 ACTION_PerformActionSequence(package, -3);
7713
7714 /* finish up running custom actions */
7715 ACTION_FinishCustomActions(package);
7716
7717 if (rc == ERROR_SUCCESS && package->need_reboot)
7718 return ERROR_SUCCESS_REBOOT_REQUIRED;
7719
7720 return rc;
7721 }
Windows API implementation