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