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