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