?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msxml3: Block ::add() if collection is read-only.
[wine/multimedia.git] / dlls / msi / action.c
blob59e7b6d4c3df8355063df2fd9d3e9e08c0192aa7
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, SCRIPT_NONE);
528 else
529 rc = ACTION_PerformAction(package, action, SCRIPT_NONE);
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 == SCRIPT_ROLLBACK)
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 }
1825
1826 /* now we want to set component state based based on feature state */
1827 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1828 {
1829 ComponentList *cl;
1830
1831 TRACE("Examining Feature %s (Level %d Installed %d Request %d Action %d)\n",
1832 debugstr_w(feature->Feature), feature->Level, feature->Installed,
1833 feature->ActionRequest, feature->Action);
1834
1835 if (!is_feature_selected( feature, level )) continue;
1836
1837 /* features with components that have compressed files are made local */
1838 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1839 {
1840 if (cl->component->ForceLocalState &&
1841 feature->ActionRequest == INSTALLSTATE_SOURCE)
1842 {
1843 feature->Action = INSTALLSTATE_LOCAL;
1844 feature->ActionRequest = INSTALLSTATE_LOCAL;
1845 break;
1846 }
1847 }
1848
1849 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1850 {
1851 component = cl->component;
1852
1853 switch (feature->ActionRequest)
1854 {
1855 case INSTALLSTATE_ABSENT:
1856 component->anyAbsent = 1;
1857 break;
1858 case INSTALLSTATE_ADVERTISED:
1859 component->hasAdvertiseFeature = 1;
1860 break;
1861 case INSTALLSTATE_SOURCE:
1862 component->hasSourceFeature = 1;
1863 break;
1864 case INSTALLSTATE_LOCAL:
1865 component->hasLocalFeature = 1;
1866 break;
1867 case INSTALLSTATE_DEFAULT:
1868 if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
1869 component->hasAdvertiseFeature = 1;
1870 else if (feature->Attributes & msidbFeatureAttributesFavorSource)
1871 component->hasSourceFeature = 1;
1872 else
1873 component->hasLocalFeature = 1;
1874 break;
1875 default:
1876 break;
1877 }
1878 }
1879 }
1880
1881 LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
1882 {
1883 /* check if it's local or source */
1884 if (!(component->Attributes & msidbComponentAttributesOptional) &&
1885 (component->hasLocalFeature || component->hasSourceFeature))
1886 {
1887 if ((component->Attributes & msidbComponentAttributesSourceOnly) &&
1888 !component->ForceLocalState)
1889 {
1890 component->Action = INSTALLSTATE_SOURCE;
1891 component->ActionRequest = INSTALLSTATE_SOURCE;
1892 }
1893 else
1894 {
1895 component->Action = INSTALLSTATE_LOCAL;
1896 component->ActionRequest = INSTALLSTATE_LOCAL;
1897 }
1898 continue;
1899 }
1900
1901 /* if any feature is local, the component must be local too */
1902 if (component->hasLocalFeature)
1903 {
1904 component->Action = INSTALLSTATE_LOCAL;
1905 component->ActionRequest = INSTALLSTATE_LOCAL;
1906 continue;
1907 }
1908 if (component->hasSourceFeature)
1909 {
1910 component->Action = INSTALLSTATE_SOURCE;
1911 component->ActionRequest = INSTALLSTATE_SOURCE;
1912 continue;
1913 }
1914 if (component->hasAdvertiseFeature)
1915 {
1916 component->Action = INSTALLSTATE_ADVERTISED;
1917 component->ActionRequest = INSTALLSTATE_ADVERTISED;
1918 continue;
1919 }
1920 TRACE("nobody wants component %s\n", debugstr_w(component->Component));
1921 if (component->anyAbsent &&
1922 (component->Installed == INSTALLSTATE_LOCAL || component->Installed == INSTALLSTATE_SOURCE))
1923 {
1924 component->Action = INSTALLSTATE_ABSENT;
1925 component->ActionRequest = INSTALLSTATE_ABSENT;
1926 }
1927 }
1928
1929 LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
1930 {
1931 if (component->ActionRequest == INSTALLSTATE_DEFAULT)
1932 {
1933 TRACE("%s was default, setting to local\n", debugstr_w(component->Component));
1934 component->Action = INSTALLSTATE_LOCAL;
1935 component->ActionRequest = INSTALLSTATE_LOCAL;
1936 }
1937
1938 if (component->ActionRequest == INSTALLSTATE_SOURCE &&
1939 component->Installed == INSTALLSTATE_SOURCE &&
1940 component->hasSourceFeature)
1941 {
1942 component->Action = INSTALLSTATE_UNKNOWN;
1943 component->ActionRequest = INSTALLSTATE_UNKNOWN;
1944 }
1945
1946 TRACE("Result: Component %s (Installed %d Request %d Action %d)\n",
1947 debugstr_w(component->Component), component->Installed, component->ActionRequest, component->Action);
1948 }
1949
1950 return ERROR_SUCCESS;
1951 }
1952
1953 static UINT ITERATE_CostFinalizeConditions(MSIRECORD *row, LPVOID param)
1954 {
1955 MSIPACKAGE *package = param;
1956 LPCWSTR name;
1957 MSIFEATURE *feature;
1958
1959 name = MSI_RecordGetString( row, 1 );
1960
1961 feature = msi_get_loaded_feature( package, name );
1962 if (!feature)
1963 ERR("FAILED to find loaded feature %s\n",debugstr_w(name));
1964 else
1965 {
1966 LPCWSTR Condition;
1967 Condition = MSI_RecordGetString(row,3);
1968
1969 if (MSI_EvaluateConditionW(package,Condition) == MSICONDITION_TRUE)
1970 {
1971 int level = MSI_RecordGetInteger(row,2);
1972 TRACE("Resetting feature %s to level %i\n", debugstr_w(name), level);
1973 feature->Level = level;
1974 }
1975 }
1976 return ERROR_SUCCESS;
1977 }
1978
1979 VS_FIXEDFILEINFO *msi_get_disk_file_version( LPCWSTR filename )
1980 {
1981 static const WCHAR name[] = {'\\',0};
1982 VS_FIXEDFILEINFO *ptr, *ret;
1983 LPVOID version;
1984 DWORD versize, handle;
1985 UINT sz;
1986
1987 versize = GetFileVersionInfoSizeW( filename, &handle );
1988 if (!versize)
1989 return NULL;
1990
1991 version = msi_alloc( versize );
1992 if (!version)
1993 return NULL;
1994
1995 GetFileVersionInfoW( filename, 0, versize, version );
1996
1997 if (!VerQueryValueW( version, name, (LPVOID *)&ptr, &sz ))
1998 {
1999 msi_free( version );
2000 return NULL;
2001 }
2002
2003 ret = msi_alloc( sz );
2004 memcpy( ret, ptr, sz );
2005
2006 msi_free( version );
2007 return ret;
2008 }
2009
2010 int msi_compare_file_versions( VS_FIXEDFILEINFO *fi, const WCHAR *version )
2011 {
2012 DWORD ms, ls;
2013
2014 msi_parse_version_string( version, &ms, &ls );
2015
2016 if (fi->dwFileVersionMS > ms) return 1;
2017 else if (fi->dwFileVersionMS < ms) return -1;
2018 else if (fi->dwFileVersionLS > ls) return 1;
2019 else if (fi->dwFileVersionLS < ls) return -1;
2020 return 0;
2021 }
2022
2023 int msi_compare_font_versions( const WCHAR *ver1, const WCHAR *ver2 )
2024 {
2025 DWORD ms1, ms2;
2026
2027 msi_parse_version_string( ver1, &ms1, NULL );
2028 msi_parse_version_string( ver2, &ms2, NULL );
2029
2030 if (ms1 > ms2) return 1;
2031 else if (ms1 < ms2) return -1;
2032 return 0;
2033 }
2034
2035 DWORD msi_get_disk_file_size( LPCWSTR filename )
2036 {
2037 HANDLE file;
2038 DWORD size;
2039
2040 file = CreateFileW( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
2041 if (file == INVALID_HANDLE_VALUE)
2042 return INVALID_FILE_SIZE;
2043
2044 size = GetFileSize( file, NULL );
2045 TRACE("size is %u\n", size);
2046 CloseHandle( file );
2047 return size;
2048 }
2049
2050 BOOL msi_file_hash_matches( MSIFILE *file )
2051 {
2052 UINT r;
2053 MSIFILEHASHINFO hash;
2054
2055 hash.dwFileHashInfoSize = sizeof(MSIFILEHASHINFO);
2056 r = MsiGetFileHashW( file->TargetPath, 0, &hash );
2057 if (r != ERROR_SUCCESS)
2058 return FALSE;
2059
2060 return !memcmp( &hash, &file->hash, sizeof(MSIFILEHASHINFO) );
2061 }
2062
2063 static WCHAR *get_temp_dir( void )
2064 {
2065 static UINT id;
2066 WCHAR tmp[MAX_PATH], dir[MAX_PATH];
2067
2068 GetTempPathW( MAX_PATH, tmp );
2069 for (;;)
2070 {
2071 if (!GetTempFileNameW( tmp, szMsi, ++id, dir )) return NULL;
2072 if (CreateDirectoryW( dir, NULL )) break;
2073 }
2074 return strdupW( dir );
2075 }
2076
2077 /*
2078 * msi_build_directory_name()
2079 *
2080 * This function is to save messing round with directory names
2081 * It handles adding backslashes between path segments,
2082 * and can add \ at the end of the directory name if told to.
2083 *
2084 * It takes a variable number of arguments.
2085 * It always allocates a new string for the result, so make sure
2086 * to free the return value when finished with it.
2087 *
2088 * The first arg is the number of path segments that follow.
2089 * The arguments following count are a list of path segments.
2090 * A path segment may be NULL.
2091 *
2092 * Path segments will be added with a \ separating them.
2093 * A \ will not be added after the last segment, however if the
2094 * last segment is NULL, then the last character will be a \
2095 */
2096 WCHAR *msi_build_directory_name( DWORD count, ... )
2097 {
2098 DWORD sz = 1, i;
2099 WCHAR *dir;
2100 va_list va;
2101
2102 va_start( va, count );
2103 for (i = 0; i < count; i++)
2104 {
2105 const WCHAR *str = va_arg( va, const WCHAR * );
2106 if (str) sz += strlenW( str ) + 1;
2107 }
2108 va_end( va );
2109
2110 dir = msi_alloc( sz * sizeof(WCHAR) );
2111 dir[0] = 0;
2112
2113 va_start( va, count );
2114 for (i = 0; i < count; i++)
2115 {
2116 const WCHAR *str = va_arg( va, const WCHAR * );
2117 if (!str) continue;
2118 strcatW( dir, str );
2119 if ( i + 1 != count && dir[strlenW( dir ) - 1] != '\\') strcatW( dir, szBackSlash );
2120 }
2121 va_end( va );
2122 return dir;
2123 }
2124
2125 static void set_target_path( MSIPACKAGE *package, MSIFILE *file )
2126 {
2127 MSIASSEMBLY *assembly = file->Component->assembly;
2128
2129 TRACE("file %s is named %s\n", debugstr_w(file->File), debugstr_w(file->FileName));
2130
2131 msi_free( file->TargetPath );
2132 if (assembly && !assembly->application)
2133 {
2134 if (!assembly->tempdir) assembly->tempdir = get_temp_dir();
2135 file->TargetPath = msi_build_directory_name( 2, assembly->tempdir, file->FileName );
2136 msi_track_tempfile( package, file->TargetPath );
2137 }
2138 else
2139 {
2140 const WCHAR *dir = msi_get_target_folder( package, file->Component->Directory );
2141 file->TargetPath = msi_build_directory_name( 2, dir, file->FileName );
2142 }
2143
2144 TRACE("resolves to %s\n", debugstr_w(file->TargetPath));
2145 }
2146
2147 static UINT calculate_file_cost( MSIPACKAGE *package )
2148 {
2149 VS_FIXEDFILEINFO *file_version;
2150 WCHAR *font_version;
2151 MSIFILE *file;
2152
2153 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2154 {
2155 MSICOMPONENT *comp = file->Component;
2156 DWORD file_size;
2157
2158 if (!comp->Enabled) continue;
2159
2160 if (file->IsCompressed)
2161 comp->ForceLocalState = TRUE;
2162
2163 set_target_path( package, file );
2164
2165 if ((comp->assembly && !comp->assembly->installed) ||
2166 GetFileAttributesW(file->TargetPath) == INVALID_FILE_ATTRIBUTES)
2167 {
2168 comp->Cost += file->FileSize;
2169 continue;
2170 }
2171 file_size = msi_get_disk_file_size( file->TargetPath );
2172
2173 if (file->Version)
2174 {
2175 if ((file_version = msi_get_disk_file_version( file->TargetPath )))
2176 {
2177 if (msi_compare_file_versions( file_version, file->Version ) < 0)
2178 {
2179 comp->Cost += file->FileSize - file_size;
2180 }
2181 msi_free( file_version );
2182 continue;
2183 }
2184 else if ((font_version = msi_font_version_from_file( file->TargetPath )))
2185 {
2186 if (msi_compare_font_versions( font_version, file->Version ) < 0)
2187 {
2188 comp->Cost += file->FileSize - file_size;
2189 }
2190 msi_free( font_version );
2191 continue;
2192 }
2193 }
2194 if (file_size != file->FileSize)
2195 {
2196 comp->Cost += file->FileSize - file_size;
2197 }
2198 }
2199 return ERROR_SUCCESS;
2200 }
2201
2202 WCHAR *msi_normalize_path( const WCHAR *in )
2203 {
2204 const WCHAR *p = in;
2205 WCHAR *q, *ret;
2206 int n, len = strlenW( in ) + 2;
2207
2208 if (!(q = ret = msi_alloc( len * sizeof(WCHAR) ))) return NULL;
2209
2210 len = 0;
2211 while (1)
2212 {
2213 /* copy until the end of the string or a space */
2214 while (*p != ' ' && (*q = *p))
2215 {
2216 p++, len++;
2217 /* reduce many backslashes to one */
2218 if (*p != '\\' || *q != '\\')
2219 q++;
2220 }
2221
2222 /* quit at the end of the string */
2223 if (!*p)
2224 break;
2225
2226 /* count the number of spaces */
2227 n = 0;
2228 while (p[n] == ' ')
2229 n++;
2230
2231 /* if it's leading or trailing space, skip it */
2232 if ( len == 0 || p[-1] == '\\' || p[n] == '\\' )
2233 p += n;
2234 else /* copy n spaces */
2235 while (n && (*q++ = *p++)) n--;
2236 }
2237 while (q - ret > 0 && q[-1] == ' ') q--;
2238 if (q - ret > 0 && q[-1] != '\\')
2239 {
2240 q[0] = '\\';
2241 q[1] = 0;
2242 }
2243 return ret;
2244 }
2245
2246 void msi_resolve_target_folder( MSIPACKAGE *package, const WCHAR *name, BOOL load_prop )
2247 {
2248 FolderList *fl;
2249 MSIFOLDER *folder, *parent, *child;
2250 WCHAR *path, *normalized_path;
2251
2252 TRACE("resolving %s\n", debugstr_w(name));
2253
2254 if (!(folder = msi_get_loaded_folder( package, name ))) return;
2255
2256 if (!strcmpW( folder->Directory, szTargetDir )) /* special resolving for target root dir */
2257 {
2258 if (!load_prop || !(path = msi_dup_property( package->db, szTargetDir )))
2259 {
2260 path = msi_dup_property( package->db, szRootDrive );
2261 }
2262 }
2263 else if (!load_prop || !(path = msi_dup_property( package->db, folder->Directory )))
2264 {
2265 if (folder->Parent && strcmpW( folder->Directory, folder->Parent ))
2266 {
2267 parent = msi_get_loaded_folder( package, folder->Parent );
2268 path = msi_build_directory_name( 3, parent->ResolvedTarget, folder->TargetDefault, NULL );
2269 }
2270 else
2271 path = msi_build_directory_name( 2, folder->TargetDefault, NULL );
2272 }
2273 normalized_path = msi_normalize_path( path );
2274 msi_free( path );
2275 if (folder->ResolvedTarget && !strcmpiW( normalized_path, folder->ResolvedTarget ))
2276 {
2277 TRACE("%s already resolved to %s\n", debugstr_w(name), debugstr_w(folder->ResolvedTarget));
2278 msi_free( normalized_path );
2279 return;
2280 }
2281 msi_set_property( package->db, folder->Directory, normalized_path );
2282 msi_free( folder->ResolvedTarget );
2283 folder->ResolvedTarget = normalized_path;
2284
2285 LIST_FOR_EACH_ENTRY( fl, &folder->children, FolderList, entry )
2286 {
2287 child = fl->folder;
2288 msi_resolve_target_folder( package, child->Directory, load_prop );
2289 }
2290 TRACE("%s resolves to %s\n", debugstr_w(name), debugstr_w(folder->ResolvedTarget));
2291 }
2292
2293 static UINT ACTION_CostFinalize(MSIPACKAGE *package)
2294 {
2295 static const WCHAR query[] = {
2296 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2297 '`','C','o','n','d','i','t','i','o','n','`',0};
2298 static const WCHAR szOutOfDiskSpace[] = {
2299 'O','u','t','O','f','D','i','s','k','S','p','a','c','e',0};
2300 MSICOMPONENT *comp;
2301 MSIQUERY *view;
2302 LPWSTR level;
2303 UINT rc;
2304
2305 TRACE("Building directory properties\n");
2306 msi_resolve_target_folder( package, szTargetDir, TRUE );
2307
2308 TRACE("Evaluating component conditions\n");
2309 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2310 {
2311 if (MSI_EvaluateConditionW( package, comp->Condition ) == MSICONDITION_FALSE)
2312 {
2313 TRACE("Disabling component %s\n", debugstr_w(comp->Component));
2314 comp->Enabled = FALSE;
2315 }
2316 else
2317 comp->Enabled = TRUE;
2318 }
2319
2320 /* read components states from the registry */
2321 ACTION_GetComponentInstallStates(package);
2322 ACTION_GetFeatureInstallStates(package);
2323
2324 if (!process_overrides( package, msi_get_property_int( package->db, szInstallLevel, 1 ) ))
2325 {
2326 TRACE("Evaluating feature conditions\n");
2327
2328 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
2329 if (rc == ERROR_SUCCESS)
2330 {
2331 rc = MSI_IterateRecords( view, NULL, ITERATE_CostFinalizeConditions, package );
2332 msiobj_release( &view->hdr );
2333 if (rc != ERROR_SUCCESS)
2334 return rc;
2335 }
2336 }
2337
2338 TRACE("Calculating file cost\n");
2339 calculate_file_cost( package );
2340
2341 msi_set_property( package->db, szCostingComplete, szOne );
2342 /* set default run level if not set */
2343 level = msi_dup_property( package->db, szInstallLevel );
2344 if (!level)
2345 msi_set_property( package->db, szInstallLevel, szOne );
2346 msi_free(level);
2347
2348 /* FIXME: check volume disk space */
2349 msi_set_property( package->db, szOutOfDiskSpace, szZero );
2350
2351 return MSI_SetFeatureStates(package);
2352 }
2353
2354 /* OK this value is "interpreted" and then formatted based on the
2355 first few characters */
2356 static LPSTR parse_value(MSIPACKAGE *package, LPCWSTR value, DWORD *type,
2357 DWORD *size)
2358 {
2359 LPSTR data = NULL;
2360
2361 if (value[0]=='#' && value[1]!='#' && value[1]!='%')
2362 {
2363 if (value[1]=='x')
2364 {
2365 LPWSTR ptr;
2366 CHAR byte[5];
2367 LPWSTR deformated = NULL;
2368 int count;
2369
2370 deformat_string(package, &value[2], &deformated);
2371
2372 /* binary value type */
2373 ptr = deformated;
2374 *type = REG_BINARY;
2375 if (strlenW(ptr)%2)
2376 *size = (strlenW(ptr)/2)+1;
2377 else
2378 *size = strlenW(ptr)/2;
2379
2380 data = msi_alloc(*size);
2381
2382 byte[0] = '0';
2383 byte[1] = 'x';
2384 byte[4] = 0;
2385 count = 0;
2386 /* if uneven pad with a zero in front */
2387 if (strlenW(ptr)%2)
2388 {
2389 byte[2]= '0';
2390 byte[3]= *ptr;
2391 ptr++;
2392 data[count] = (BYTE)strtol(byte,NULL,0);
2393 count ++;
2394 TRACE("Uneven byte count\n");
2395 }
2396 while (*ptr)
2397 {
2398 byte[2]= *ptr;
2399 ptr++;
2400 byte[3]= *ptr;
2401 ptr++;
2402 data[count] = (BYTE)strtol(byte,NULL,0);
2403 count ++;
2404 }
2405 msi_free(deformated);
2406
2407 TRACE("Data %i bytes(%i)\n",*size,count);
2408 }
2409 else
2410 {
2411 LPWSTR deformated;
2412 LPWSTR p;
2413 DWORD d = 0;
2414 deformat_string(package, &value[1], &deformated);
2415
2416 *type=REG_DWORD;
2417 *size = sizeof(DWORD);
2418 data = msi_alloc(*size);
2419 p = deformated;
2420 if (*p == '-')
2421 p++;
2422 while (*p)
2423 {
2424 if ( (*p < '0') || (*p > '9') )
2425 break;
2426 d *= 10;
2427 d += (*p - '0');
2428 p++;
2429 }
2430 if (deformated[0] == '-')
2431 d = -d;
2432 *(LPDWORD)data = d;
2433 TRACE("DWORD %i\n",*(LPDWORD)data);
2434
2435 msi_free(deformated);
2436 }
2437 }
2438 else
2439 {
2440 static const WCHAR szMulti[] = {'[','~',']',0};
2441 LPCWSTR ptr;
2442 *type=REG_SZ;
2443
2444 if (value[0]=='#')
2445 {
2446 if (value[1]=='%')
2447 {
2448 ptr = &value[2];
2449 *type=REG_EXPAND_SZ;
2450 }
2451 else
2452 ptr = &value[1];
2453 }
2454 else
2455 ptr=value;
2456
2457 if (strstrW(value, szMulti))
2458 *type = REG_MULTI_SZ;
2459
2460 /* remove initial delimiter */
2461 if (!strncmpW(value, szMulti, 3))
2462 ptr = value + 3;
2463
2464 *size = deformat_string(package, ptr,(LPWSTR*)&data);
2465
2466 /* add double NULL terminator */
2467 if (*type == REG_MULTI_SZ)
2468 {
2469 *size += 2 * sizeof(WCHAR); /* two NULL terminators */
2470 data = msi_realloc_zero(data, *size);
2471 }
2472 }
2473 return data;
2474 }
2475
2476 static const WCHAR *get_root_key( MSIPACKAGE *package, INT root, HKEY *root_key )
2477 {
2478 const WCHAR *ret;
2479
2480 switch (root)
2481 {
2482 case -1:
2483 if (msi_get_property_int( package->db, szAllUsers, 0 ))
2484 {
2485 *root_key = HKEY_LOCAL_MACHINE;
2486 ret = szHLM;
2487 }
2488 else
2489 {
2490 *root_key = HKEY_CURRENT_USER;
2491 ret = szHCU;
2492 }
2493 break;
2494 case 0:
2495 *root_key = HKEY_CLASSES_ROOT;
2496 ret = szHCR;
2497 break;
2498 case 1:
2499 *root_key = HKEY_CURRENT_USER;
2500 ret = szHCU;
2501 break;
2502 case 2:
2503 *root_key = HKEY_LOCAL_MACHINE;
2504 ret = szHLM;
2505 break;
2506 case 3:
2507 *root_key = HKEY_USERS;
2508 ret = szHU;
2509 break;
2510 default:
2511 ERR("Unknown root %i\n", root);
2512 return NULL;
2513 }
2514
2515 return ret;
2516 }
2517
2518 static WCHAR *get_keypath( MSIPACKAGE *package, HKEY root, const WCHAR *path )
2519 {
2520 static const WCHAR prefixW[] = {'S','O','F','T','W','A','R','E','\\'};
2521 static const UINT len = sizeof(prefixW) / sizeof(prefixW[0]);
2522
2523 if (is_64bit && package->platform == PLATFORM_INTEL &&
2524 root == HKEY_LOCAL_MACHINE && !strncmpiW( path, prefixW, len ))
2525 {
2526 UINT size;
2527 WCHAR *path_32node;
2528
2529 size = (strlenW( path ) + strlenW( szWow6432Node ) + 2) * sizeof(WCHAR);
2530 if (!(path_32node = msi_alloc( size ))) return NULL;
2531
2532 memcpy( path_32node, path, len * sizeof(WCHAR) );
2533 strcpyW( path_32node + len, szWow6432Node );
2534 strcatW( path_32node, szBackSlash );
2535 strcatW( path_32node, path + len );
2536 return path_32node;
2537 }
2538
2539 return strdupW( path );
2540 }
2541
2542 static UINT ITERATE_WriteRegistryValues(MSIRECORD *row, LPVOID param)
2543 {
2544 MSIPACKAGE *package = param;
2545 LPSTR value_data = NULL;
2546 HKEY root_key, hkey;
2547 DWORD type,size;
2548 LPWSTR deformated, uikey, keypath;
2549 LPCWSTR szRoot, component, name, key, value;
2550 MSICOMPONENT *comp;
2551 MSIRECORD * uirow;
2552 INT root;
2553 BOOL check_first = FALSE;
2554 UINT rc;
2555
2556 msi_ui_progress( package, 2, REG_PROGRESS_VALUE, 0, 0 );
2557
2558 component = MSI_RecordGetString(row, 6);
2559 comp = msi_get_loaded_component(package,component);
2560 if (!comp)
2561 return ERROR_SUCCESS;
2562
2563 comp->Action = msi_get_component_action( package, comp );
2564 if (comp->Action != INSTALLSTATE_LOCAL)
2565 {
2566 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
2567 return ERROR_SUCCESS;
2568 }
2569
2570 name = MSI_RecordGetString(row, 4);
2571 if( MSI_RecordIsNull(row,5) && name )
2572 {
2573 /* null values can have special meanings */
2574 if (name[0]=='-' && name[1] == 0)
2575 return ERROR_SUCCESS;
2576 else if ((name[0]=='+' && name[1] == 0) ||
2577 (name[0] == '*' && name[1] == 0))
2578 name = NULL;
2579 check_first = TRUE;
2580 }
2581
2582 root = MSI_RecordGetInteger(row,2);
2583 key = MSI_RecordGetString(row, 3);
2584
2585 szRoot = get_root_key( package, root, &root_key );
2586 if (!szRoot)
2587 return ERROR_SUCCESS;
2588
2589 deformat_string(package, key , &deformated);
2590 size = strlenW(deformated) + strlenW(szRoot) + 1;
2591 uikey = msi_alloc(size*sizeof(WCHAR));
2592 strcpyW(uikey,szRoot);
2593 strcatW(uikey,deformated);
2594
2595 keypath = get_keypath( package, root_key, deformated );
2596 msi_free( deformated );
2597 if (RegCreateKeyW( root_key, keypath, &hkey ))
2598 {
2599 ERR("Could not create key %s\n", debugstr_w(keypath));
2600 msi_free(uikey);
2601 msi_free(keypath);
2602 return ERROR_SUCCESS;
2603 }
2604
2605 value = MSI_RecordGetString(row,5);
2606 if (value)
2607 value_data = parse_value(package, value, &type, &size);
2608 else
2609 {
2610 value_data = (LPSTR)strdupW(szEmpty);
2611 size = sizeof(szEmpty);
2612 type = REG_SZ;
2613 }
2614
2615 deformat_string(package, name, &deformated);
2616
2617 if (!check_first)
2618 {
2619 TRACE("Setting value %s of %s\n",debugstr_w(deformated),
2620 debugstr_w(uikey));
2621 RegSetValueExW(hkey, deformated, 0, type, (LPBYTE)value_data, size);
2622 }
2623 else
2624 {
2625 DWORD sz = 0;
2626 rc = RegQueryValueExW(hkey, deformated, NULL, NULL, NULL, &sz);
2627 if (rc == ERROR_SUCCESS || rc == ERROR_MORE_DATA)
2628 {
2629 TRACE("value %s of %s checked already exists\n",
2630 debugstr_w(deformated), debugstr_w(uikey));
2631 }
2632 else
2633 {
2634 TRACE("Checked and setting value %s of %s\n",
2635 debugstr_w(deformated), debugstr_w(uikey));
2636 if (deformated || size)
2637 RegSetValueExW(hkey, deformated, 0, type, (LPBYTE) value_data, size);
2638 }
2639 }
2640 RegCloseKey(hkey);
2641
2642 uirow = MSI_CreateRecord(3);
2643 MSI_RecordSetStringW(uirow,2,deformated);
2644 MSI_RecordSetStringW(uirow,1,uikey);
2645 if (type == REG_SZ || type == REG_EXPAND_SZ)
2646 MSI_RecordSetStringW(uirow,3,(LPWSTR)value_data);
2647 msi_ui_actiondata( package, szWriteRegistryValues, uirow );
2648 msiobj_release( &uirow->hdr );
2649
2650 msi_free(value_data);
2651 msi_free(deformated);
2652 msi_free(uikey);
2653 msi_free(keypath);
2654
2655 return ERROR_SUCCESS;
2656 }
2657
2658 static UINT ACTION_WriteRegistryValues(MSIPACKAGE *package)
2659 {
2660 static const WCHAR query[] = {
2661 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2662 '`','R','e','g','i','s','t','r','y','`',0};
2663 MSIQUERY *view;
2664 UINT rc;
2665
2666 rc = MSI_DatabaseOpenViewW(package->db, query, &view);
2667 if (rc != ERROR_SUCCESS)
2668 return ERROR_SUCCESS;
2669
2670 rc = MSI_IterateRecords(view, NULL, ITERATE_WriteRegistryValues, package);
2671 msiobj_release(&view->hdr);
2672 return rc;
2673 }
2674
2675 static void delete_reg_value( HKEY root, const WCHAR *keypath, const WCHAR *value )
2676 {
2677 LONG res;
2678 HKEY hkey;
2679 DWORD num_subkeys, num_values;
2680
2681 if (!(res = RegOpenKeyW( root, keypath, &hkey )))
2682 {
2683 if ((res = RegDeleteValueW( hkey, value )))
2684 {
2685 TRACE("failed to delete value %s (%d)\n", debugstr_w(value), res);
2686 }
2687 res = RegQueryInfoKeyW( hkey, NULL, NULL, NULL, &num_subkeys, NULL, NULL, &num_values,
2688 NULL, NULL, NULL, NULL );
2689 RegCloseKey( hkey );
2690 if (!res && !num_subkeys && !num_values)
2691 {
2692 TRACE("removing empty key %s\n", debugstr_w(keypath));
2693 RegDeleteKeyW( root, keypath );
2694 }
2695 return;
2696 }
2697 TRACE("failed to open key %s (%d)\n", debugstr_w(keypath), res);
2698 }
2699
2700 static void delete_reg_key( HKEY root, const WCHAR *keypath )
2701 {
2702 LONG res = RegDeleteTreeW( root, keypath );
2703 if (res) TRACE("failed to delete key %s (%d)\n", debugstr_w(keypath), res);
2704 }
2705
2706 static UINT ITERATE_RemoveRegistryValuesOnUninstall( MSIRECORD *row, LPVOID param )
2707 {
2708 MSIPACKAGE *package = param;
2709 LPCWSTR component, name, key_str, root_key_str;
2710 LPWSTR deformated_key, deformated_name, ui_key_str, keypath;
2711 MSICOMPONENT *comp;
2712 MSIRECORD *uirow;
2713 BOOL delete_key = FALSE;
2714 HKEY hkey_root;
2715 UINT size;
2716 INT root;
2717
2718 msi_ui_progress( package, 2, REG_PROGRESS_VALUE, 0, 0 );
2719
2720 component = MSI_RecordGetString( row, 6 );
2721 comp = msi_get_loaded_component( package, component );
2722 if (!comp)
2723 return ERROR_SUCCESS;
2724
2725 comp->Action = msi_get_component_action( package, comp );
2726 if (comp->Action != INSTALLSTATE_ABSENT)
2727 {
2728 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
2729 return ERROR_SUCCESS;
2730 }
2731
2732 name = MSI_RecordGetString( row, 4 );
2733 if (MSI_RecordIsNull( row, 5 ) && name )
2734 {
2735 if (name[0] == '+' && !name[1])
2736 return ERROR_SUCCESS;
2737 else if ((name[0] == '-' && !name[1]) || (name[0] == '*' && !name[1]))
2738 {
2739 delete_key = TRUE;
2740 name = NULL;
2741 }
2742 }
2743
2744 root = MSI_RecordGetInteger( row, 2 );
2745 key_str = MSI_RecordGetString( row, 3 );
2746
2747 root_key_str = get_root_key( package, root, &hkey_root );
2748 if (!root_key_str)
2749 return ERROR_SUCCESS;
2750
2751 deformat_string( package, key_str, &deformated_key );
2752 size = strlenW( deformated_key ) + strlenW( root_key_str ) + 1;
2753 ui_key_str = msi_alloc( size * sizeof(WCHAR) );
2754 strcpyW( ui_key_str, root_key_str );
2755 strcatW( ui_key_str, deformated_key );
2756
2757 deformat_string( package, name, &deformated_name );
2758
2759 keypath = get_keypath( package, hkey_root, deformated_key );
2760 msi_free( deformated_key );
2761 if (delete_key) delete_reg_key( hkey_root, keypath );
2762 else delete_reg_value( hkey_root, keypath, deformated_name );
2763 msi_free( keypath );
2764
2765 uirow = MSI_CreateRecord( 2 );
2766 MSI_RecordSetStringW( uirow, 1, ui_key_str );
2767 MSI_RecordSetStringW( uirow, 2, deformated_name );
2768 msi_ui_actiondata( package, szRemoveRegistryValues, uirow );
2769 msiobj_release( &uirow->hdr );
2770
2771 msi_free( ui_key_str );
2772 msi_free( deformated_name );
2773 return ERROR_SUCCESS;
2774 }
2775
2776 static UINT ITERATE_RemoveRegistryValuesOnInstall( MSIRECORD *row, LPVOID param )
2777 {
2778 MSIPACKAGE *package = param;
2779 LPCWSTR component, name, key_str, root_key_str;
2780 LPWSTR deformated_key, deformated_name, ui_key_str, keypath;
2781 MSICOMPONENT *comp;
2782 MSIRECORD *uirow;
2783 BOOL delete_key = FALSE;
2784 HKEY hkey_root;
2785 UINT size;
2786 INT root;
2787
2788 component = MSI_RecordGetString( row, 5 );
2789 comp = msi_get_loaded_component( package, component );
2790 if (!comp)
2791 return ERROR_SUCCESS;
2792
2793 comp->Action = msi_get_component_action( package, comp );
2794 if (comp->Action != INSTALLSTATE_LOCAL)
2795 {
2796 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
2797 return ERROR_SUCCESS;
2798 }
2799
2800 if ((name = MSI_RecordGetString( row, 4 )))
2801 {
2802 if (name[0] == '-' && !name[1])
2803 {
2804 delete_key = TRUE;
2805 name = NULL;
2806 }
2807 }
2808
2809 root = MSI_RecordGetInteger( row, 2 );
2810 key_str = MSI_RecordGetString( row, 3 );
2811
2812 root_key_str = get_root_key( package, root, &hkey_root );
2813 if (!root_key_str)
2814 return ERROR_SUCCESS;
2815
2816 deformat_string( package, key_str, &deformated_key );
2817 size = strlenW( deformated_key ) + strlenW( root_key_str ) + 1;
2818 ui_key_str = msi_alloc( size * sizeof(WCHAR) );
2819 strcpyW( ui_key_str, root_key_str );
2820 strcatW( ui_key_str, deformated_key );
2821
2822 deformat_string( package, name, &deformated_name );
2823
2824 keypath = get_keypath( package, hkey_root, deformated_key );
2825 msi_free( deformated_key );
2826 if (delete_key) delete_reg_key( hkey_root, keypath );
2827 else delete_reg_value( hkey_root, keypath, deformated_name );
2828 msi_free( keypath );
2829
2830 uirow = MSI_CreateRecord( 2 );
2831 MSI_RecordSetStringW( uirow, 1, ui_key_str );
2832 MSI_RecordSetStringW( uirow, 2, deformated_name );
2833 msi_ui_actiondata( package, szRemoveRegistryValues, uirow );
2834 msiobj_release( &uirow->hdr );
2835
2836 msi_free( ui_key_str );
2837 msi_free( deformated_name );
2838 return ERROR_SUCCESS;
2839 }
2840
2841 static UINT ACTION_RemoveRegistryValues( MSIPACKAGE *package )
2842 {
2843 static const WCHAR registry_query[] = {
2844 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2845 '`','R','e','g','i','s','t','r','y','`',0};
2846 static const WCHAR remove_registry_query[] = {
2847 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2848 '`','R','e','m','o','v','e','R','e','g','i','s','t','r','y','`',0};
2849 MSIQUERY *view;
2850 UINT rc;
2851
2852 rc = MSI_DatabaseOpenViewW( package->db, registry_query, &view );
2853 if (rc == ERROR_SUCCESS)
2854 {
2855 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveRegistryValuesOnUninstall, package );
2856 msiobj_release( &view->hdr );
2857 if (rc != ERROR_SUCCESS)
2858 return rc;
2859 }
2860 rc = MSI_DatabaseOpenViewW( package->db, remove_registry_query, &view );
2861 if (rc == ERROR_SUCCESS)
2862 {
2863 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveRegistryValuesOnInstall, package );
2864 msiobj_release( &view->hdr );
2865 if (rc != ERROR_SUCCESS)
2866 return rc;
2867 }
2868 return ERROR_SUCCESS;
2869 }
2870
2871 static UINT ACTION_InstallInitialize(MSIPACKAGE *package)
2872 {
2873 package->script->CurrentlyScripting = TRUE;
2874
2875 return ERROR_SUCCESS;
2876 }
2877
2878
2879 static UINT ACTION_InstallValidate(MSIPACKAGE *package)
2880 {
2881 static const WCHAR query[]= {
2882 'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
2883 '`','R','e','g','i','s','t','r','y','`',0};
2884 MSICOMPONENT *comp;
2885 DWORD total = 0, count = 0;
2886 MSIQUERY *view;
2887 MSIFEATURE *feature;
2888 MSIFILE *file;
2889 UINT rc;
2890
2891 TRACE("InstallValidate\n");
2892
2893 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
2894 if (rc == ERROR_SUCCESS)
2895 {
2896 rc = MSI_IterateRecords( view, &count, NULL, package );
2897 msiobj_release( &view->hdr );
2898 if (rc != ERROR_SUCCESS)
2899 return rc;
2900 total += count * REG_PROGRESS_VALUE;
2901 }
2902 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2903 total += COMPONENT_PROGRESS_VALUE;
2904
2905 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2906 total += file->FileSize;
2907
2908 msi_ui_progress( package, 0, total, 0, 0 );
2909
2910 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2911 {
2912 TRACE("Feature: %s Installed %d Request %d Action %d\n",
2913 debugstr_w(feature->Feature), feature->Installed,
2914 feature->ActionRequest, feature->Action);
2915 }
2916 return ERROR_SUCCESS;
2917 }
2918
2919 static UINT ITERATE_LaunchConditions(MSIRECORD *row, LPVOID param)
2920 {
2921 MSIPACKAGE* package = param;
2922 LPCWSTR cond = NULL;
2923 LPCWSTR message = NULL;
2924 UINT r;
2925
2926 static const WCHAR title[]=
2927 {'I','n','s','t','a','l','l',' ','F','a', 'i','l','e','d',0};
2928
2929 cond = MSI_RecordGetString(row,1);
2930
2931 r = MSI_EvaluateConditionW(package,cond);
2932 if (r == MSICONDITION_FALSE)
2933 {
2934 if ((gUILevel & INSTALLUILEVEL_MASK) != INSTALLUILEVEL_NONE)
2935 {
2936 LPWSTR deformated;
2937 message = MSI_RecordGetString(row,2);
2938 deformat_string(package,message,&deformated);
2939 MessageBoxW(NULL,deformated,title,MB_OK);
2940 msi_free(deformated);
2941 }
2942
2943 return ERROR_INSTALL_FAILURE;
2944 }
2945
2946 return ERROR_SUCCESS;
2947 }
2948
2949 static UINT ACTION_LaunchConditions(MSIPACKAGE *package)
2950 {
2951 static const WCHAR query[] = {
2952 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2953 '`','L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','`',0};
2954 MSIQUERY *view;
2955 UINT rc;
2956
2957 TRACE("Checking launch conditions\n");
2958
2959 rc = MSI_DatabaseOpenViewW(package->db, query, &view);
2960 if (rc != ERROR_SUCCESS)
2961 return ERROR_SUCCESS;
2962
2963 rc = MSI_IterateRecords(view, NULL, ITERATE_LaunchConditions, package);
2964 msiobj_release(&view->hdr);
2965 return rc;
2966 }
2967
2968 static LPWSTR resolve_keypath( MSIPACKAGE* package, MSICOMPONENT *cmp )
2969 {
2970
2971 if (!cmp->KeyPath)
2972 return strdupW( msi_get_target_folder( package, cmp->Directory ) );
2973
2974 if (cmp->Attributes & msidbComponentAttributesRegistryKeyPath)
2975 {
2976 static const WCHAR query[] = {
2977 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2978 '`','R','e','g','i','s','t','r','y','`',' ','W','H','E','R','E',' ',
2979 '`','R','e','g','i','s','t','r','y','`',' ','=',' ' ,'\'','%','s','\'',0};
2980 static const WCHAR fmt[] = {'%','0','2','i',':','\\','%','s','\\',0};
2981 static const WCHAR fmt2[]= {'%','0','2','i',':','\\','%','s','\\','%','s',0};
2982 MSIRECORD *row;
2983 UINT root, len;
2984 LPWSTR deformated, buffer, deformated_name;
2985 LPCWSTR key, name;
2986
2987 row = MSI_QueryGetRecord(package->db, query, cmp->KeyPath);
2988 if (!row)
2989 return NULL;
2990
2991 root = MSI_RecordGetInteger(row,2);
2992 key = MSI_RecordGetString(row, 3);
2993 name = MSI_RecordGetString(row, 4);
2994 deformat_string(package, key , &deformated);
2995 deformat_string(package, name, &deformated_name);
2996
2997 len = strlenW(deformated) + 6;
2998 if (deformated_name)
2999 len+=strlenW(deformated_name);
3000
3001 buffer = msi_alloc( len *sizeof(WCHAR));
3002
3003 if (deformated_name)
3004 sprintfW(buffer,fmt2,root,deformated,deformated_name);
3005 else
3006 sprintfW(buffer,fmt,root,deformated);
3007
3008 msi_free(deformated);
3009 msi_free(deformated_name);
3010 msiobj_release(&row->hdr);
3011
3012 return buffer;
3013 }
3014 else if (cmp->Attributes & msidbComponentAttributesODBCDataSource)
3015 {
3016 FIXME("UNIMPLEMENTED keypath as ODBC Source\n");
3017 return NULL;
3018 }
3019 else
3020 {
3021 MSIFILE *file = msi_get_loaded_file( package, cmp->KeyPath );
3022
3023 if (file)
3024 return strdupW( file->TargetPath );
3025 }
3026 return NULL;
3027 }
3028
3029 static HKEY openSharedDLLsKey(void)
3030 {
3031 HKEY hkey=0;
3032 static const WCHAR path[] =
3033 {'S','o','f','t','w','a','r','e','\\',
3034 'M','i','c','r','o','s','o','f','t','\\',
3035 'W','i','n','d','o','w','s','\\',
3036 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3037 'S','h','a','r','e','d','D','L','L','s',0};
3038
3039 RegCreateKeyW(HKEY_LOCAL_MACHINE,path,&hkey);
3040 return hkey;
3041 }
3042
3043 static UINT ACTION_GetSharedDLLsCount(LPCWSTR dll)
3044 {
3045 HKEY hkey;
3046 DWORD count=0;
3047 DWORD type;
3048 DWORD sz = sizeof(count);
3049 DWORD rc;
3050
3051 hkey = openSharedDLLsKey();
3052 rc = RegQueryValueExW(hkey, dll, NULL, &type, (LPBYTE)&count, &sz);
3053 if (rc != ERROR_SUCCESS)
3054 count = 0;
3055 RegCloseKey(hkey);
3056 return count;
3057 }
3058
3059 static UINT ACTION_WriteSharedDLLsCount(LPCWSTR path, UINT count)
3060 {
3061 HKEY hkey;
3062
3063 hkey = openSharedDLLsKey();
3064 if (count > 0)
3065 msi_reg_set_val_dword( hkey, path, count );
3066 else
3067 RegDeleteValueW(hkey,path);
3068 RegCloseKey(hkey);
3069 return count;
3070 }
3071
3072 static void ACTION_RefCountComponent( MSIPACKAGE* package, MSICOMPONENT *comp )
3073 {
3074 MSIFEATURE *feature;
3075 INT count = 0;
3076 BOOL write = FALSE;
3077
3078 /* only refcount DLLs */
3079 if (comp->KeyPath == NULL ||
3080 comp->assembly ||
3081 comp->Attributes & msidbComponentAttributesRegistryKeyPath ||
3082 comp->Attributes & msidbComponentAttributesODBCDataSource)
3083 write = FALSE;
3084 else
3085 {
3086 count = ACTION_GetSharedDLLsCount( comp->FullKeypath);
3087 write = (count > 0);
3088
3089 if (comp->Attributes & msidbComponentAttributesSharedDllRefCount)
3090 write = TRUE;
3091 }
3092
3093 /* increment counts */
3094 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
3095 {
3096 ComponentList *cl;
3097
3098 if (msi_get_feature_action( package, feature ) != INSTALLSTATE_LOCAL)
3099 continue;
3100
3101 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3102 {
3103 if ( cl->component == comp )
3104 count++;
3105 }
3106 }
3107
3108 /* decrement counts */
3109 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
3110 {
3111 ComponentList *cl;
3112
3113 if (msi_get_feature_action( package, feature ) != INSTALLSTATE_ABSENT)
3114 continue;
3115
3116 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3117 {
3118 if ( cl->component == comp )
3119 count--;
3120 }
3121 }
3122
3123 /* ref count all the files in the component */
3124 if (write)
3125 {
3126 MSIFILE *file;
3127
3128 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
3129 {
3130 if (file->Component == comp)
3131 ACTION_WriteSharedDLLsCount( file->TargetPath, count );
3132 }
3133 }
3134
3135 /* add a count for permanent */
3136 if (comp->Attributes & msidbComponentAttributesPermanent)
3137 count ++;
3138
3139 comp->RefCount = count;
3140
3141 if (write)
3142 ACTION_WriteSharedDLLsCount( comp->FullKeypath, comp->RefCount );
3143 }
3144
3145 static WCHAR *build_full_keypath( MSIPACKAGE *package, MSICOMPONENT *comp )
3146 {
3147 if (comp->assembly)
3148 {
3149 const WCHAR prefixW[] = {'<','\\',0};
3150 DWORD len = strlenW( prefixW ) + strlenW( comp->assembly->display_name );
3151 WCHAR *keypath = msi_alloc( (len + 1) * sizeof(WCHAR) );
3152
3153 if (keypath)
3154 {
3155 strcpyW( keypath, prefixW );
3156 strcatW( keypath, comp->assembly->display_name );
3157 }
3158 return keypath;
3159 }
3160 return resolve_keypath( package, comp );
3161 }
3162
3163 static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
3164 {
3165 WCHAR squished_pc[GUID_SIZE], squished_cc[GUID_SIZE];
3166 UINT rc;
3167 MSICOMPONENT *comp;
3168 HKEY hkey;
3169
3170 TRACE("\n");
3171
3172 squash_guid(package->ProductCode,squished_pc);
3173 msi_set_sourcedir_props(package, FALSE);
3174
3175 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
3176 {
3177 MSIRECORD *uirow;
3178 INSTALLSTATE action;
3179
3180 msi_ui_progress( package, 2, COMPONENT_PROGRESS_VALUE, 0, 0 );
3181 if (!comp->ComponentId)
3182 continue;
3183
3184 squash_guid( comp->ComponentId, squished_cc );
3185 msi_free( comp->FullKeypath );
3186 comp->FullKeypath = build_full_keypath( package, comp );
3187
3188 ACTION_RefCountComponent( package, comp );
3189
3190 if (package->need_rollback) action = comp->Installed;
3191 else action = comp->ActionRequest;
3192
3193 TRACE("Component %s (%s), Keypath=%s, RefCount=%u Action=%u\n",
3194 debugstr_w(comp->Component), debugstr_w(squished_cc),
3195 debugstr_w(comp->FullKeypath), comp->RefCount, action);
3196
3197 if (action == INSTALLSTATE_LOCAL || action == INSTALLSTATE_SOURCE)
3198 {
3199 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3200 rc = MSIREG_OpenUserDataComponentKey(comp->ComponentId, szLocalSid, &hkey, TRUE);
3201 else
3202 rc = MSIREG_OpenUserDataComponentKey(comp->ComponentId, NULL, &hkey, TRUE);
3203
3204 if (rc != ERROR_SUCCESS)
3205 continue;
3206
3207 if (comp->Attributes & msidbComponentAttributesPermanent)
3208 {
3209 static const WCHAR szPermKey[] =
3210 { '0','0','0','0','0','0','0','0','0','0','0','0',
3211 '0','0','0','0','0','0','0','0','0','0','0','0',
3212 '0','0','0','0','0','0','0','0',0 };
3213
3214 msi_reg_set_val_str(hkey, szPermKey, comp->FullKeypath);
3215 }
3216 if (action == INSTALLSTATE_LOCAL)
3217 msi_reg_set_val_str(hkey, squished_pc, comp->FullKeypath);
3218 else
3219 {
3220 MSIFILE *file;
3221 MSIRECORD *row;
3222 LPWSTR ptr, ptr2;
3223 WCHAR source[MAX_PATH];
3224 WCHAR base[MAX_PATH];
3225 LPWSTR sourcepath;
3226
3227 static const WCHAR fmt[] = {'%','0','2','d','\\',0};
3228 static const WCHAR query[] = {
3229 'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
3230 '`','M','e','d','i','a','`',' ','W','H','E','R','E',' ',
3231 '`','L','a','s','t','S','e','q','u','e','n','c','e','`',' ',
3232 '>','=',' ','%','i',' ','O','R','D','E','R',' ','B','Y',' ',
3233 '`','D','i','s','k','I','d','`',0};
3234
3235 if (!comp->KeyPath || !(file = msi_get_loaded_file(package, comp->KeyPath)))
3236 continue;
3237
3238 row = MSI_QueryGetRecord(package->db, query, file->Sequence);
3239 sprintfW(source, fmt, MSI_RecordGetInteger(row, 1));
3240 ptr2 = strrchrW(source, '\\') + 1;
3241 msiobj_release(&row->hdr);
3242
3243 lstrcpyW(base, package->PackagePath);
3244 ptr = strrchrW(base, '\\');
3245 *(ptr + 1) = '\0';
3246
3247 sourcepath = msi_resolve_file_source(package, file);
3248 ptr = sourcepath + lstrlenW(base);
3249 lstrcpyW(ptr2, ptr);
3250 msi_free(sourcepath);
3251
3252 msi_reg_set_val_str(hkey, squished_pc, source);
3253 }
3254 RegCloseKey(hkey);
3255 }
3256 else if (action == INSTALLSTATE_ABSENT)
3257 {
3258 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3259 MSIREG_DeleteUserDataComponentKey(comp->ComponentId, szLocalSid);
3260 else
3261 MSIREG_DeleteUserDataComponentKey(comp->ComponentId, NULL);
3262 }
3263
3264 /* UI stuff */
3265 uirow = MSI_CreateRecord(3);
3266 MSI_RecordSetStringW(uirow,1,package->ProductCode);
3267 MSI_RecordSetStringW(uirow,2,comp->ComponentId);
3268 MSI_RecordSetStringW(uirow,3,comp->FullKeypath);
3269 msi_ui_actiondata( package, szProcessComponents, uirow );
3270 msiobj_release( &uirow->hdr );
3271 }
3272 return ERROR_SUCCESS;
3273 }
3274
3275 typedef struct {
3276 CLSID clsid;
3277 LPWSTR source;
3278
3279 LPWSTR path;
3280 ITypeLib *ptLib;
3281 } typelib_struct;
3282
3283 static BOOL CALLBACK Typelib_EnumResNameProc( HMODULE hModule, LPCWSTR lpszType,
3284 LPWSTR lpszName, LONG_PTR lParam)
3285 {
3286 TLIBATTR *attr;
3287 typelib_struct *tl_struct = (typelib_struct*) lParam;
3288 static const WCHAR fmt[] = {'%','s','\\','%','i',0};
3289 int sz;
3290 HRESULT res;
3291
3292 if (!IS_INTRESOURCE(lpszName))
3293 {
3294 ERR("Not Int Resource Name %s\n",debugstr_w(lpszName));
3295 return TRUE;
3296 }
3297
3298 sz = strlenW(tl_struct->source)+4;
3299 sz *= sizeof(WCHAR);
3300
3301 if ((INT_PTR)lpszName == 1)
3302 tl_struct->path = strdupW(tl_struct->source);
3303 else
3304 {
3305 tl_struct->path = msi_alloc(sz);
3306 sprintfW(tl_struct->path,fmt,tl_struct->source, lpszName);
3307 }
3308
3309 TRACE("trying %s\n", debugstr_w(tl_struct->path));
3310 res = LoadTypeLib(tl_struct->path,&tl_struct->ptLib);
3311 if (FAILED(res))
3312 {
3313 msi_free(tl_struct->path);
3314 tl_struct->path = NULL;
3315
3316 return TRUE;
3317 }
3318
3319 ITypeLib_GetLibAttr(tl_struct->ptLib, &attr);
3320 if (IsEqualGUID(&(tl_struct->clsid),&(attr->guid)))
3321 {
3322 ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
3323 return FALSE;
3324 }
3325
3326 msi_free(tl_struct->path);
3327 tl_struct->path = NULL;
3328
3329 ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
3330 ITypeLib_Release(tl_struct->ptLib);
3331
3332 return TRUE;
3333 }
3334
3335 static UINT ITERATE_RegisterTypeLibraries(MSIRECORD *row, LPVOID param)
3336 {
3337 MSIPACKAGE* package = param;
3338 LPCWSTR component;
3339 MSICOMPONENT *comp;
3340 MSIFILE *file;
3341 typelib_struct tl_struct;
3342 ITypeLib *tlib;
3343 HMODULE module;
3344 HRESULT hr;
3345
3346 component = MSI_RecordGetString(row,3);
3347 comp = msi_get_loaded_component(package,component);
3348 if (!comp)
3349 return ERROR_SUCCESS;
3350
3351 comp->Action = msi_get_component_action( package, comp );
3352 if (comp->Action != INSTALLSTATE_LOCAL)
3353 {
3354 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
3355 return ERROR_SUCCESS;
3356 }
3357
3358 if (!comp->KeyPath || !(file = msi_get_loaded_file( package, comp->KeyPath )))
3359 {
3360 TRACE("component has no key path\n");
3361 return ERROR_SUCCESS;
3362 }
3363 msi_ui_actiondata( package, szRegisterTypeLibraries, row );
3364
3365 module = LoadLibraryExW( file->TargetPath, NULL, LOAD_LIBRARY_AS_DATAFILE );
3366 if (module)
3367 {
3368 LPCWSTR guid;
3369 guid = MSI_RecordGetString(row,1);
3370 CLSIDFromString( guid, &tl_struct.clsid);
3371 tl_struct.source = strdupW( file->TargetPath );
3372 tl_struct.path = NULL;
3373
3374 EnumResourceNamesW(module, szTYPELIB, Typelib_EnumResNameProc,
3375 (LONG_PTR)&tl_struct);
3376
3377 if (tl_struct.path)
3378 {
3379 LPCWSTR helpid, help_path = NULL;
3380 HRESULT res;
3381
3382 helpid = MSI_RecordGetString(row,6);
3383
3384 if (helpid) help_path = msi_get_target_folder( package, helpid );
3385 res = RegisterTypeLib( tl_struct.ptLib, tl_struct.path, (OLECHAR *)help_path );
3386
3387 if (FAILED(res))
3388 ERR("Failed to register type library %s\n", debugstr_w(tl_struct.path));
3389 else
3390 TRACE("Registered %s\n", debugstr_w(tl_struct.path));
3391
3392 ITypeLib_Release(tl_struct.ptLib);
3393 msi_free(tl_struct.path);
3394 }
3395 else ERR("Failed to load type library %s\n", debugstr_w(tl_struct.source));
3396
3397 FreeLibrary(module);
3398 msi_free(tl_struct.source);
3399 }
3400 else
3401 {
3402 hr = LoadTypeLibEx(file->TargetPath, REGKIND_REGISTER, &tlib);
3403 if (FAILED(hr))
3404 {
3405 ERR("Failed to load type library: %08x\n", hr);
3406 return ERROR_INSTALL_FAILURE;
3407 }
3408
3409 ITypeLib_Release(tlib);
3410 }
3411
3412 return ERROR_SUCCESS;
3413 }
3414
3415 static UINT ACTION_RegisterTypeLibraries(MSIPACKAGE *package)
3416 {
3417 static const WCHAR query[] = {
3418 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3419 '`','T','y','p','e','L','i','b','`',0};
3420 MSIQUERY *view;
3421 UINT rc;
3422
3423 rc = MSI_DatabaseOpenViewW(package->db, query, &view);
3424 if (rc != ERROR_SUCCESS)
3425 return ERROR_SUCCESS;
3426
3427 rc = MSI_IterateRecords(view, NULL, ITERATE_RegisterTypeLibraries, package);
3428 msiobj_release(&view->hdr);
3429 return rc;
3430 }
3431
3432 static UINT ITERATE_UnregisterTypeLibraries( MSIRECORD *row, LPVOID param )
3433 {
3434 MSIPACKAGE *package = param;
3435 LPCWSTR component, guid;
3436 MSICOMPONENT *comp;
3437 GUID libid;
3438 UINT version;
3439 LCID language;
3440 SYSKIND syskind;
3441 HRESULT hr;
3442
3443 component = MSI_RecordGetString( row, 3 );
3444 comp = msi_get_loaded_component( package, component );
3445 if (!comp)
3446 return ERROR_SUCCESS;
3447
3448 comp->Action = msi_get_component_action( package, comp );
3449 if (comp->Action != INSTALLSTATE_ABSENT)
3450 {
3451 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
3452 return ERROR_SUCCESS;
3453 }
3454 msi_ui_actiondata( package, szUnregisterTypeLibraries, row );
3455
3456 guid = MSI_RecordGetString( row, 1 );
3457 CLSIDFromString( guid, &libid );
3458 version = MSI_RecordGetInteger( row, 4 );
3459 language = MSI_RecordGetInteger( row, 2 );
3460
3461 #ifdef _WIN64
3462 syskind = SYS_WIN64;
3463 #else
3464 syskind = SYS_WIN32;
3465 #endif
3466
3467 hr = UnRegisterTypeLib( &libid, (version >> 8) & 0xffff, version & 0xff, language, syskind );
3468 if (FAILED(hr))
3469 {
3470 WARN("Failed to unregister typelib: %08x\n", hr);
3471 }
3472
3473 return ERROR_SUCCESS;
3474 }
3475
3476 static UINT ACTION_UnregisterTypeLibraries( MSIPACKAGE *package )
3477 {
3478 static const WCHAR query[] = {
3479 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3480 '`','T','y','p','e','L','i','b','`',0};
3481 MSIQUERY *view;
3482 UINT rc;
3483
3484 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
3485 if (rc != ERROR_SUCCESS)
3486 return ERROR_SUCCESS;
3487
3488 rc = MSI_IterateRecords( view, NULL, ITERATE_UnregisterTypeLibraries, package );
3489 msiobj_release( &view->hdr );
3490 return rc;
3491 }
3492
3493 static WCHAR *get_link_file( MSIPACKAGE *package, MSIRECORD *row )
3494 {
3495 static const WCHAR szlnk[] = {'.','l','n','k',0};
3496 LPCWSTR directory, extension, link_folder;
3497 LPWSTR link_file, filename;
3498
3499 directory = MSI_RecordGetString( row, 2 );
3500 link_folder = msi_get_target_folder( package, directory );
3501 if (!link_folder)
3502 {
3503 ERR("unable to resolve folder %s\n", debugstr_w(directory));
3504 return NULL;
3505 }
3506 /* may be needed because of a bug somewhere else */
3507 msi_create_full_path( link_folder );
3508
3509 filename = msi_dup_record_field( row, 3 );
3510 msi_reduce_to_long_filename( filename );
3511
3512 extension = strchrW( filename, '.' );
3513 if (!extension || strcmpiW( extension, szlnk ))
3514 {
3515 int len = strlenW( filename );
3516 filename = msi_realloc( filename, len * sizeof(WCHAR) + sizeof(szlnk) );
3517 memcpy( filename + len, szlnk, sizeof(szlnk) );
3518 }
3519 link_file = msi_build_directory_name( 2, link_folder, filename );
3520 msi_free( filename );
3521
3522 return link_file;
3523 }
3524
3525 WCHAR *msi_build_icon_path( MSIPACKAGE *package, const WCHAR *icon_name )
3526 {
3527 static const WCHAR szMicrosoft[] = {'M','i','c','r','o','s','o','f','t','\\',0};
3528 static const WCHAR szInstaller[] = {'I','n','s','t','a','l','l','e','r','\\',0};
3529 WCHAR *folder, *dest, *path;
3530
3531 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3532 folder = msi_dup_property( package->db, szWindowsFolder );
3533 else
3534 {
3535 WCHAR *appdata = msi_dup_property( package->db, szAppDataFolder );
3536 folder = msi_build_directory_name( 2, appdata, szMicrosoft );
3537 msi_free( appdata );
3538 }
3539 dest = msi_build_directory_name( 3, folder, szInstaller, package->ProductCode );
3540 msi_create_full_path( dest );
3541 path = msi_build_directory_name( 2, dest, icon_name );
3542 msi_free( folder );
3543 msi_free( dest );
3544 return path;
3545 }
3546
3547 static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
3548 {
3549 MSIPACKAGE *package = param;
3550 LPWSTR link_file, deformated, path;
3551 LPCWSTR component, target;
3552 MSICOMPONENT *comp;
3553 IShellLinkW *sl = NULL;
3554 IPersistFile *pf = NULL;
3555 HRESULT res;
3556
3557 component = MSI_RecordGetString(row, 4);
3558 comp = msi_get_loaded_component(package, component);
3559 if (!comp)
3560 return ERROR_SUCCESS;
3561
3562 comp->Action = msi_get_component_action( package, comp );
3563 if (comp->Action != INSTALLSTATE_LOCAL)
3564 {
3565 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
3566 return ERROR_SUCCESS;
3567 }
3568 msi_ui_actiondata( package, szCreateShortcuts, row );
3569
3570 res = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
3571 &IID_IShellLinkW, (LPVOID *) &sl );
3572
3573 if (FAILED( res ))
3574 {
3575 ERR("CLSID_ShellLink not available\n");
3576 goto err;
3577 }
3578
3579 res = IShellLinkW_QueryInterface( sl, &IID_IPersistFile,(LPVOID*) &pf );
3580 if (FAILED( res ))
3581 {
3582 ERR("QueryInterface(IID_IPersistFile) failed\n");
3583 goto err;
3584 }
3585
3586 target = MSI_RecordGetString(row, 5);
3587 if (strchrW(target, '['))
3588 {
3589 deformat_string( package, target, &path );
3590 TRACE("target path is %s\n", debugstr_w(path));
3591 IShellLinkW_SetPath( sl, path );
3592 msi_free( path );
3593 }
3594 else
3595 {
3596 FIXME("poorly handled shortcut format, advertised shortcut\n");
3597 IShellLinkW_SetPath(sl,comp->FullKeypath);
3598 }
3599
3600 if (!MSI_RecordIsNull(row,6))
3601 {
3602 LPCWSTR arguments = MSI_RecordGetString(row, 6);
3603 deformat_string(package, arguments, &deformated);
3604 IShellLinkW_SetArguments(sl,deformated);
3605 msi_free(deformated);
3606 }
3607
3608 if (!MSI_RecordIsNull(row,7))
3609 {
3610 LPCWSTR description = MSI_RecordGetString(row, 7);
3611 IShellLinkW_SetDescription(sl, description);
3612 }
3613
3614 if (!MSI_RecordIsNull(row,8))
3615 IShellLinkW_SetHotkey(sl,MSI_RecordGetInteger(row,8));
3616
3617 if (!MSI_RecordIsNull(row,9))
3618 {
3619 INT index;
3620 LPCWSTR icon = MSI_RecordGetString(row, 9);
3621
3622 path = msi_build_icon_path(package, icon);
3623 index = MSI_RecordGetInteger(row,10);
3624
3625 /* no value means 0 */
3626 if (index == MSI_NULL_INTEGER)
3627 index = 0;
3628
3629 IShellLinkW_SetIconLocation(sl, path, index);
3630 msi_free(path);
3631 }
3632
3633 if (!MSI_RecordIsNull(row,11))
3634 IShellLinkW_SetShowCmd(sl,MSI_RecordGetInteger(row,11));
3635
3636 if (!MSI_RecordIsNull(row,12))
3637 {
3638 LPCWSTR full_path, wkdir = MSI_RecordGetString( row, 12 );
3639 full_path = msi_get_target_folder( package, wkdir );
3640 if (full_path) IShellLinkW_SetWorkingDirectory( sl, full_path );
3641 }
3642 link_file = get_link_file(package, row);
3643
3644 TRACE("Writing shortcut to %s\n", debugstr_w(link_file));
3645 IPersistFile_Save(pf, link_file, FALSE);
3646 msi_free(link_file);
3647
3648 err:
3649 if (pf)
3650 IPersistFile_Release( pf );
3651 if (sl)
3652 IShellLinkW_Release( sl );
3653
3654 return ERROR_SUCCESS;
3655 }
3656
3657 static UINT ACTION_CreateShortcuts(MSIPACKAGE *package)
3658 {
3659 static const WCHAR query[] = {
3660 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3661 '`','S','h','o','r','t','c','u','t','`',0};
3662 MSIQUERY *view;
3663 HRESULT res;
3664 UINT rc;
3665
3666 rc = MSI_DatabaseOpenViewW(package->db, query, &view);
3667 if (rc != ERROR_SUCCESS)
3668 return ERROR_SUCCESS;
3669
3670 res = CoInitialize( NULL );
3671
3672 rc = MSI_IterateRecords(view, NULL, ITERATE_CreateShortcuts, package);
3673 msiobj_release(&view->hdr);
3674
3675 if (SUCCEEDED(res)) CoUninitialize();
3676 return rc;
3677 }
3678
3679 static UINT ITERATE_RemoveShortcuts( MSIRECORD *row, LPVOID param )
3680 {
3681 MSIPACKAGE *package = param;
3682 LPWSTR link_file;
3683 LPCWSTR component;
3684 MSICOMPONENT *comp;
3685
3686 component = MSI_RecordGetString( row, 4 );
3687 comp = msi_get_loaded_component( package, component );
3688 if (!comp)
3689 return ERROR_SUCCESS;
3690
3691 comp->Action = msi_get_component_action( package, comp );
3692 if (comp->Action != INSTALLSTATE_ABSENT)
3693 {
3694 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
3695 return ERROR_SUCCESS;
3696 }
3697 msi_ui_actiondata( package, szRemoveShortcuts, row );
3698
3699 link_file = get_link_file( package, row );
3700
3701 TRACE("Removing shortcut file %s\n", debugstr_w( link_file ));
3702 if (!DeleteFileW( link_file ))
3703 {
3704 WARN("Failed to remove shortcut file %u\n", GetLastError());
3705 }
3706 msi_free( link_file );
3707
3708 return ERROR_SUCCESS;
3709 }
3710
3711 static UINT ACTION_RemoveShortcuts( MSIPACKAGE *package )
3712 {
3713 static const WCHAR query[] = {
3714 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3715 '`','S','h','o','r','t','c','u','t','`',0};
3716 MSIQUERY *view;
3717 UINT rc;
3718
3719 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
3720 if (rc != ERROR_SUCCESS)
3721 return ERROR_SUCCESS;
3722
3723 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveShortcuts, package );
3724 msiobj_release( &view->hdr );
3725 return rc;
3726 }
3727
3728 static UINT ITERATE_PublishIcon(MSIRECORD *row, LPVOID param)
3729 {
3730 MSIPACKAGE* package = param;
3731 HANDLE the_file;
3732 LPWSTR FilePath;
3733 LPCWSTR FileName;
3734 CHAR buffer[1024];
3735 DWORD sz;
3736 UINT rc;
3737
3738 FileName = MSI_RecordGetString(row,1);
3739 if (!FileName)
3740 {
3741 ERR("Unable to get FileName\n");
3742 return ERROR_SUCCESS;
3743 }
3744
3745 FilePath = msi_build_icon_path(package, FileName);
3746
3747 TRACE("Creating icon file at %s\n",debugstr_w(FilePath));
3748
3749 the_file = CreateFileW(FilePath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
3750 FILE_ATTRIBUTE_NORMAL, NULL);
3751
3752 if (the_file == INVALID_HANDLE_VALUE)
3753 {
3754 ERR("Unable to create file %s\n",debugstr_w(FilePath));
3755 msi_free(FilePath);
3756 return ERROR_SUCCESS;
3757 }
3758
3759 do
3760 {
3761 DWORD write;
3762 sz = 1024;
3763 rc = MSI_RecordReadStream(row,2,buffer,&sz);
3764 if (rc != ERROR_SUCCESS)
3765 {
3766 ERR("Failed to get stream\n");
3767 CloseHandle(the_file);
3768 DeleteFileW(FilePath);
3769 break;
3770 }
3771 WriteFile(the_file,buffer,sz,&write,NULL);
3772 } while (sz == 1024);
3773
3774 msi_free(FilePath);
3775 CloseHandle(the_file);
3776
3777 return ERROR_SUCCESS;
3778 }
3779
3780 static UINT msi_publish_icons(MSIPACKAGE *package)
3781 {
3782 static const WCHAR query[]= {
3783 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3784 '`','I','c','o','n','`',0};
3785 MSIQUERY *view;
3786 UINT r;
3787
3788 r = MSI_DatabaseOpenViewW(package->db, query, &view);
3789 if (r == ERROR_SUCCESS)
3790 {
3791 r = MSI_IterateRecords(view, NULL, ITERATE_PublishIcon, package);
3792 msiobj_release(&view->hdr);
3793 if (r != ERROR_SUCCESS)
3794 return r;
3795 }
3796 return ERROR_SUCCESS;
3797 }
3798
3799 static UINT msi_publish_sourcelist(MSIPACKAGE *package, HKEY hkey)
3800 {
3801 UINT r;
3802 HKEY source;
3803 LPWSTR buffer;
3804 MSIMEDIADISK *disk;
3805 MSISOURCELISTINFO *info;
3806
3807 r = RegCreateKeyW(hkey, szSourceList, &source);
3808 if (r != ERROR_SUCCESS)
3809 return r;
3810
3811 RegCloseKey(source);
3812
3813 buffer = strrchrW(package->PackagePath, '\\') + 1;
3814 r = MsiSourceListSetInfoW(package->ProductCode, NULL,
3815 package->Context, MSICODE_PRODUCT,
3816 INSTALLPROPERTY_PACKAGENAMEW, buffer);
3817 if (r != ERROR_SUCCESS)
3818 return r;
3819
3820 r = MsiSourceListSetInfoW(package->ProductCode, NULL,
3821 package->Context, MSICODE_PRODUCT,
3822 INSTALLPROPERTY_MEDIAPACKAGEPATHW, szEmpty);
3823 if (r != ERROR_SUCCESS)
3824 return r;
3825
3826 r = MsiSourceListSetInfoW(package->ProductCode, NULL,
3827 package->Context, MSICODE_PRODUCT,
3828 INSTALLPROPERTY_DISKPROMPTW, szEmpty);
3829 if (r != ERROR_SUCCESS)
3830 return r;
3831
3832 LIST_FOR_EACH_ENTRY(info, &package->sourcelist_info, MSISOURCELISTINFO, entry)
3833 {
3834 if (!strcmpW( info->property, INSTALLPROPERTY_LASTUSEDSOURCEW ))
3835 msi_set_last_used_source(package->ProductCode, NULL, info->context,
3836 info->options, info->value);
3837 else
3838 MsiSourceListSetInfoW(package->ProductCode, NULL,
3839 info->context, info->options,
3840 info->property, info->value);
3841 }
3842
3843 LIST_FOR_EACH_ENTRY(disk, &package->sourcelist_media, MSIMEDIADISK, entry)
3844 {
3845 MsiSourceListAddMediaDiskW(package->ProductCode, NULL,
3846 disk->context, disk->options,
3847 disk->disk_id, disk->volume_label, disk->disk_prompt);
3848 }
3849
3850 return ERROR_SUCCESS;
3851 }
3852
3853 static UINT msi_publish_product_properties(MSIPACKAGE *package, HKEY hkey)
3854 {
3855 MSIHANDLE hdb, suminfo;
3856 WCHAR guids[MAX_PATH];
3857 WCHAR packcode[SQUISH_GUID_SIZE];
3858 LPWSTR buffer;
3859 LPWSTR ptr;
3860 DWORD langid;
3861 DWORD size;
3862 UINT r;
3863
3864 static const WCHAR szARPProductIcon[] =
3865 {'A','R','P','P','R','O','D','U','C','T','I','C','O','N',0};
3866 static const WCHAR szAssignment[] =
3867 {'A','s','s','i','g','n','m','e','n','t',0};
3868 static const WCHAR szAdvertiseFlags[] =
3869 {'A','d','v','e','r','t','i','s','e','F','l','a','g','s',0};
3870 static const WCHAR szClients[] =
3871 {'C','l','i','e','n','t','s',0};
3872 static const WCHAR szColon[] = {':',0};
3873
3874 buffer = msi_dup_property(package->db, INSTALLPROPERTY_PRODUCTNAMEW);
3875 msi_reg_set_val_str(hkey, INSTALLPROPERTY_PRODUCTNAMEW, buffer);
3876 msi_free(buffer);
3877
3878 langid = msi_get_property_int(package->db, szProductLanguage, 0);
3879 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_LANGUAGEW, langid);
3880
3881 /* FIXME */
3882 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_AUTHORIZED_LUA_APPW, 0);
3883
3884 buffer = msi_dup_property(package->db, szARPProductIcon);
3885 if (buffer)
3886 {
3887 LPWSTR path = msi_build_icon_path(package, buffer);
3888 msi_reg_set_val_str(hkey, INSTALLPROPERTY_PRODUCTICONW, path);
3889 msi_free(path);
3890 msi_free(buffer);
3891 }
3892
3893 buffer = msi_dup_property(package->db, szProductVersion);
3894 if (buffer)
3895 {
3896 DWORD verdword = msi_version_str_to_dword(buffer);
3897 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONW, verdword);
3898 msi_free(buffer);
3899 }
3900
3901 msi_reg_set_val_dword(hkey, szAssignment, 0);
3902 msi_reg_set_val_dword(hkey, szAdvertiseFlags, 0x184);
3903 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_INSTANCETYPEW, 0);
3904 msi_reg_set_val_str(hkey, szClients, szColon);
3905
3906 hdb = alloc_msihandle(&package->db->hdr);
3907 if (!hdb)
3908 return ERROR_NOT_ENOUGH_MEMORY;
3909
3910 r = MsiGetSummaryInformationW(hdb, NULL, 0, &suminfo);
3911 MsiCloseHandle(hdb);
3912 if (r != ERROR_SUCCESS)
3913 goto done;
3914
3915 size = MAX_PATH;
3916 r = MsiSummaryInfoGetPropertyW(suminfo, PID_REVNUMBER, NULL, NULL,
3917 NULL, guids, &size);
3918 if (r != ERROR_SUCCESS)
3919 goto done;
3920
3921 ptr = strchrW(guids, ';');
3922 if (ptr) *ptr = 0;
3923 squash_guid(guids, packcode);
3924 msi_reg_set_val_str(hkey, INSTALLPROPERTY_PACKAGECODEW, packcode);
3925
3926 done:
3927 MsiCloseHandle(suminfo);
3928 return ERROR_SUCCESS;
3929 }
3930
3931 static UINT msi_publish_upgrade_code(MSIPACKAGE *package)
3932 {
3933 UINT r;
3934 HKEY hkey;
3935 LPWSTR upgrade;
3936 WCHAR squashed_pc[SQUISH_GUID_SIZE];
3937
3938 upgrade = msi_dup_property(package->db, szUpgradeCode);
3939 if (!upgrade)
3940 return ERROR_SUCCESS;
3941
3942 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3943 r = MSIREG_OpenClassesUpgradeCodesKey(upgrade, &hkey, TRUE);
3944 else
3945 r = MSIREG_OpenUserUpgradeCodesKey(upgrade, &hkey, TRUE);
3946
3947 if (r != ERROR_SUCCESS)
3948 {
3949 WARN("failed to open upgrade code key\n");
3950 msi_free(upgrade);
3951 return ERROR_SUCCESS;
3952 }
3953 squash_guid(package->ProductCode, squashed_pc);
3954 msi_reg_set_val_str(hkey, squashed_pc, NULL);
3955 RegCloseKey(hkey);
3956 msi_free(upgrade);
3957 return ERROR_SUCCESS;
3958 }
3959
3960 static BOOL msi_check_publish(MSIPACKAGE *package)
3961 {
3962 MSIFEATURE *feature;
3963
3964 LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
3965 {
3966 feature->Action = msi_get_feature_action( package, feature );
3967 if (feature->Action == INSTALLSTATE_LOCAL)
3968 return TRUE;
3969 }
3970
3971 return FALSE;
3972 }
3973
3974 static BOOL msi_check_unpublish(MSIPACKAGE *package)
3975 {
3976 MSIFEATURE *feature;
3977
3978 LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
3979 {
3980 feature->Action = msi_get_feature_action( package, feature );
3981 if (feature->Action != INSTALLSTATE_ABSENT)
3982 return FALSE;
3983 }
3984
3985 return TRUE;
3986 }
3987
3988 static UINT msi_publish_patches( MSIPACKAGE *package )
3989 {
3990 static const WCHAR szAllPatches[] = {'A','l','l','P','a','t','c','h','e','s',0};
3991 WCHAR patch_squashed[GUID_SIZE];
3992 HKEY patches_key = NULL, product_patches_key = NULL, product_key;
3993 LONG res;
3994 MSIPATCHINFO *patch;
3995 UINT r;
3996 WCHAR *p, *all_patches = NULL;
3997 DWORD len = 0;
3998
3999 r = MSIREG_OpenProductKey( package->ProductCode, NULL, package->Context, &product_key, TRUE );
4000 if (r != ERROR_SUCCESS)
4001 return ERROR_FUNCTION_FAILED;
4002
4003 res = RegCreateKeyExW( product_key, szPatches, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &patches_key, NULL );
4004 if (res != ERROR_SUCCESS)
4005 {
4006 r = ERROR_FUNCTION_FAILED;
4007 goto done;
4008 }
4009
4010 r = MSIREG_OpenUserDataProductPatchesKey( package->ProductCode, package->Context, &product_patches_key, TRUE );
4011 if (r != ERROR_SUCCESS)
4012 goto done;
4013
4014 LIST_FOR_EACH_ENTRY( patch, &package->patches, MSIPATCHINFO, entry )
4015 {
4016 squash_guid( patch->patchcode, patch_squashed );
4017 len += strlenW( patch_squashed ) + 1;
4018 }
4019
4020 p = all_patches = msi_alloc( (len + 1) * sizeof(WCHAR) );
4021 if (!all_patches)
4022 goto done;
4023
4024 LIST_FOR_EACH_ENTRY( patch, &package->patches, MSIPATCHINFO, entry )
4025 {
4026 HKEY patch_key;
4027
4028 squash_guid( patch->patchcode, p );
4029 p += strlenW( p ) + 1;
4030
4031 res = RegSetValueExW( patches_key, patch_squashed, 0, REG_SZ,
4032 (const BYTE *)patch->transforms,
4033 (strlenW(patch->transforms) + 1) * sizeof(WCHAR) );
4034 if (res != ERROR_SUCCESS)
4035 goto done;
4036
4037 r = MSIREG_OpenUserDataPatchKey( patch->patchcode, package->Context, &patch_key, TRUE );
4038 if (r != ERROR_SUCCESS)
4039 goto done;
4040
4041 res = RegSetValueExW( patch_key, szLocalPackage, 0, REG_SZ, (const BYTE *)patch->localfile,
4042 (strlenW( patch->localfile ) + 1) * sizeof(WCHAR) );
4043 RegCloseKey( patch_key );
4044 if (res != ERROR_SUCCESS)
4045 goto done;
4046
4047 if (patch->filename && !CopyFileW( patch->filename, patch->localfile, FALSE ))
4048 {
4049 res = GetLastError();
4050 ERR("Unable to copy patch package %d\n", res);
4051 goto done;
4052 }
4053 res = RegCreateKeyExW( product_patches_key, patch_squashed, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &patch_key, NULL );
4054 if (res != ERROR_SUCCESS)
4055 goto done;
4056
4057 res = RegSetValueExW( patch_key, szState, 0, REG_DWORD, (const BYTE *)&patch->state, sizeof(patch->state) );
4058 RegCloseKey( patch_key );
4059 if (res != ERROR_SUCCESS)
4060 goto done;
4061 }
4062
4063 all_patches[len] = 0;
4064 res = RegSetValueExW( patches_key, szPatches, 0, REG_MULTI_SZ,
4065 (const BYTE *)all_patches, (len + 1) * sizeof(WCHAR) );
4066 if (res != ERROR_SUCCESS)
4067 goto done;
4068
4069 res = RegSetValueExW( product_patches_key, szAllPatches, 0, REG_MULTI_SZ,
4070 (const BYTE *)all_patches, (len + 1) * sizeof(WCHAR) );
4071 if (res != ERROR_SUCCESS)
4072 r = ERROR_FUNCTION_FAILED;
4073
4074 done:
4075 RegCloseKey( product_patches_key );
4076 RegCloseKey( patches_key );
4077 RegCloseKey( product_key );
4078 msi_free( all_patches );
4079 return r;
4080 }
4081
4082 static UINT ACTION_PublishProduct(MSIPACKAGE *package)
4083 {
4084 UINT rc;
4085 HKEY hukey = NULL, hudkey = NULL;
4086 MSIRECORD *uirow;
4087
4088 if (!list_empty(&package->patches))
4089 {
4090 rc = msi_publish_patches(package);
4091 if (rc != ERROR_SUCCESS)
4092 goto end;
4093 }
4094
4095 /* FIXME: also need to publish if the product is in advertise mode */
4096 if (!msi_check_publish(package))
4097 return ERROR_SUCCESS;
4098
4099 rc = MSIREG_OpenProductKey(package->ProductCode, NULL, package->Context,
4100 &hukey, TRUE);
4101 if (rc != ERROR_SUCCESS)
4102 goto end;
4103
4104 rc = MSIREG_OpenUserDataProductKey(package->ProductCode, package->Context,
4105 NULL, &hudkey, TRUE);
4106 if (rc != ERROR_SUCCESS)
4107 goto end;
4108
4109 rc = msi_publish_upgrade_code(package);
4110 if (rc != ERROR_SUCCESS)
4111 goto end;
4112
4113 rc = msi_publish_product_properties(package, hukey);
4114 if (rc != ERROR_SUCCESS)
4115 goto end;
4116
4117 rc = msi_publish_sourcelist(package, hukey);
4118 if (rc != ERROR_SUCCESS)
4119 goto end;
4120
4121 rc = msi_publish_icons(package);
4122
4123 end:
4124 uirow = MSI_CreateRecord( 1 );
4125 MSI_RecordSetStringW( uirow, 1, package->ProductCode );
4126 msi_ui_actiondata( package, szPublishProduct, uirow );
4127 msiobj_release( &uirow->hdr );
4128
4129 RegCloseKey(hukey);
4130 RegCloseKey(hudkey);
4131 return rc;
4132 }
4133
4134 static WCHAR *get_ini_file_name( MSIPACKAGE *package, MSIRECORD *row )
4135 {
4136 WCHAR *filename, *ptr, *folder, *ret;
4137 const WCHAR *dirprop;
4138
4139 filename = msi_dup_record_field( row, 2 );
4140 if (filename && (ptr = strchrW( filename, '|' )))
4141 ptr++;
4142 else
4143 ptr = filename;
4144
4145 dirprop = MSI_RecordGetString( row, 3 );
4146 if (dirprop)
4147 {
4148 folder = strdupW( msi_get_target_folder( package, dirprop ) );
4149 if (!folder) folder = msi_dup_property( package->db, dirprop );
4150 }
4151 else
4152 folder = msi_dup_property( package->db, szWindowsFolder );
4153
4154 if (!folder)
4155 {
4156 ERR("Unable to resolve folder %s\n", debugstr_w(dirprop));
4157 msi_free( filename );
4158 return NULL;
4159 }
4160
4161 ret = msi_build_directory_name( 2, folder, ptr );
4162
4163 msi_free( filename );
4164 msi_free( folder );
4165 return ret;
4166 }
4167
4168 static UINT ITERATE_WriteIniValues(MSIRECORD *row, LPVOID param)
4169 {
4170 MSIPACKAGE *package = param;
4171 LPCWSTR component, section, key, value, identifier;
4172 LPWSTR deformated_section, deformated_key, deformated_value, fullname;
4173 MSIRECORD * uirow;
4174 INT action;
4175 MSICOMPONENT *comp;
4176
4177 component = MSI_RecordGetString(row, 8);
4178 comp = msi_get_loaded_component(package,component);
4179 if (!comp)
4180 return ERROR_SUCCESS;
4181
4182 comp->Action = msi_get_component_action( package, comp );
4183 if (comp->Action != INSTALLSTATE_LOCAL)
4184 {
4185 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
4186 return ERROR_SUCCESS;
4187 }
4188
4189 identifier = MSI_RecordGetString(row,1);
4190 section = MSI_RecordGetString(row,4);
4191 key = MSI_RecordGetString(row,5);
4192 value = MSI_RecordGetString(row,6);
4193 action = MSI_RecordGetInteger(row,7);
4194
4195 deformat_string(package,section,&deformated_section);
4196 deformat_string(package,key,&deformated_key);
4197 deformat_string(package,value,&deformated_value);
4198
4199 fullname = get_ini_file_name(package, row);
4200
4201 if (action == 0)
4202 {
4203 TRACE("Adding value %s to section %s in %s\n",
4204 debugstr_w(deformated_key), debugstr_w(deformated_section),
4205 debugstr_w(fullname));
4206 WritePrivateProfileStringW(deformated_section, deformated_key,
4207 deformated_value, fullname);
4208 }
4209 else if (action == 1)
4210 {
4211 WCHAR returned[10];
4212 GetPrivateProfileStringW(deformated_section, deformated_key, NULL,
4213 returned, 10, fullname);
4214 if (returned[0] == 0)
4215 {
4216 TRACE("Adding value %s to section %s in %s\n",
4217 debugstr_w(deformated_key), debugstr_w(deformated_section),
4218 debugstr_w(fullname));
4219
4220 WritePrivateProfileStringW(deformated_section, deformated_key,
4221 deformated_value, fullname);
4222 }
4223 }
4224 else if (action == 3)
4225 FIXME("Append to existing section not yet implemented\n");
4226
4227 uirow = MSI_CreateRecord(4);
4228 MSI_RecordSetStringW(uirow,1,identifier);
4229 MSI_RecordSetStringW(uirow,2,deformated_section);
4230 MSI_RecordSetStringW(uirow,3,deformated_key);
4231 MSI_RecordSetStringW(uirow,4,deformated_value);
4232 msi_ui_actiondata( package, szWriteIniValues, uirow );
4233 msiobj_release( &uirow->hdr );
4234
4235 msi_free(fullname);
4236 msi_free(deformated_key);
4237 msi_free(deformated_value);
4238 msi_free(deformated_section);
4239 return ERROR_SUCCESS;
4240 }
4241
4242 static UINT ACTION_WriteIniValues(MSIPACKAGE *package)
4243 {
4244 static const WCHAR query[] = {
4245 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4246 '`','I','n','i','F','i','l','e','`',0};
4247 MSIQUERY *view;
4248 UINT rc;
4249
4250 rc = MSI_DatabaseOpenViewW(package->db, query, &view);
4251 if (rc != ERROR_SUCCESS)
4252 return ERROR_SUCCESS;
4253
4254 rc = MSI_IterateRecords(view, NULL, ITERATE_WriteIniValues, package);
4255 msiobj_release(&view->hdr);
4256 return rc;
4257 }
4258
4259 static UINT ITERATE_RemoveIniValuesOnUninstall( MSIRECORD *row, LPVOID param )
4260 {
4261 MSIPACKAGE *package = param;
4262 LPCWSTR component, section, key, value, identifier;
4263 LPWSTR deformated_section, deformated_key, deformated_value, filename;
4264 MSICOMPONENT *comp;
4265 MSIRECORD *uirow;
4266 INT action;
4267
4268 component = MSI_RecordGetString( row, 8 );
4269 comp = msi_get_loaded_component( package, component );
4270 if (!comp)
4271 return ERROR_SUCCESS;
4272
4273 comp->Action = msi_get_component_action( package, comp );
4274 if (comp->Action != INSTALLSTATE_ABSENT)
4275 {
4276 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
4277 return ERROR_SUCCESS;
4278 }
4279
4280 identifier = MSI_RecordGetString( row, 1 );
4281 section = MSI_RecordGetString( row, 4 );
4282 key = MSI_RecordGetString( row, 5 );
4283 value = MSI_RecordGetString( row, 6 );
4284 action = MSI_RecordGetInteger( row, 7 );
4285
4286 deformat_string( package, section, &deformated_section );
4287 deformat_string( package, key, &deformated_key );
4288 deformat_string( package, value, &deformated_value );
4289
4290 if (action == msidbIniFileActionAddLine || action == msidbIniFileActionCreateLine)
4291 {
4292 filename = get_ini_file_name( package, row );
4293
4294 TRACE("Removing key %s from section %s in %s\n",
4295 debugstr_w(deformated_key), debugstr_w(deformated_section), debugstr_w(filename));
4296
4297 if (!WritePrivateProfileStringW( deformated_section, deformated_key, NULL, filename ))
4298 {
4299 WARN("Unable to remove key %u\n", GetLastError());
4300 }
4301 msi_free( filename );
4302 }
4303 else
4304 FIXME("Unsupported action %d\n", action);
4305
4306
4307 uirow = MSI_CreateRecord( 4 );
4308 MSI_RecordSetStringW( uirow, 1, identifier );
4309 MSI_RecordSetStringW( uirow, 2, deformated_section );
4310 MSI_RecordSetStringW( uirow, 3, deformated_key );
4311 MSI_RecordSetStringW( uirow, 4, deformated_value );
4312 msi_ui_actiondata( package, szRemoveIniValues, uirow );
4313 msiobj_release( &uirow->hdr );
4314
4315 msi_free( deformated_key );
4316 msi_free( deformated_value );
4317 msi_free( deformated_section );
4318 return ERROR_SUCCESS;
4319 }
4320
4321 static UINT ITERATE_RemoveIniValuesOnInstall( MSIRECORD *row, LPVOID param )
4322 {
4323 MSIPACKAGE *package = param;
4324 LPCWSTR component, section, key, value, identifier;
4325 LPWSTR deformated_section, deformated_key, deformated_value, filename;
4326 MSICOMPONENT *comp;
4327 MSIRECORD *uirow;
4328 INT action;
4329
4330 component = MSI_RecordGetString( row, 8 );
4331 comp = msi_get_loaded_component( package, component );
4332 if (!comp)
4333 return ERROR_SUCCESS;
4334
4335 comp->Action = msi_get_component_action( package, comp );
4336 if (comp->Action != INSTALLSTATE_LOCAL)
4337 {
4338 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
4339 return ERROR_SUCCESS;
4340 }
4341
4342 identifier = MSI_RecordGetString( row, 1 );
4343 section = MSI_RecordGetString( row, 4 );
4344 key = MSI_RecordGetString( row, 5 );
4345 value = MSI_RecordGetString( row, 6 );
4346 action = MSI_RecordGetInteger( row, 7 );
4347
4348 deformat_string( package, section, &deformated_section );
4349 deformat_string( package, key, &deformated_key );
4350 deformat_string( package, value, &deformated_value );
4351
4352 if (action == msidbIniFileActionRemoveLine)
4353 {
4354 filename = get_ini_file_name( package, row );
4355
4356 TRACE("Removing key %s from section %s in %s\n",
4357 debugstr_w(deformated_key), debugstr_w(deformated_section), debugstr_w(filename));
4358
4359 if (!WritePrivateProfileStringW( deformated_section, deformated_key, NULL, filename ))
4360 {
4361 WARN("Unable to remove key %u\n", GetLastError());
4362 }
4363 msi_free( filename );
4364 }
4365 else
4366 FIXME("Unsupported action %d\n", action);
4367
4368 uirow = MSI_CreateRecord( 4 );
4369 MSI_RecordSetStringW( uirow, 1, identifier );
4370 MSI_RecordSetStringW( uirow, 2, deformated_section );
4371 MSI_RecordSetStringW( uirow, 3, deformated_key );
4372 MSI_RecordSetStringW( uirow, 4, deformated_value );
4373 msi_ui_actiondata( package, szRemoveIniValues, uirow );
4374 msiobj_release( &uirow->hdr );
4375
4376 msi_free( deformated_key );
4377 msi_free( deformated_value );
4378 msi_free( deformated_section );
4379 return ERROR_SUCCESS;
4380 }
4381
4382 static UINT ACTION_RemoveIniValues( MSIPACKAGE *package )
4383 {
4384 static const WCHAR query[] = {
4385 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4386 '`','I','n','i','F','i','l','e','`',0};
4387 static const WCHAR remove_query[] = {
4388 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4389 '`','R','e','m','o','v','e','I','n','i','F','i','l','e','`',0};
4390 MSIQUERY *view;
4391 UINT rc;
4392
4393 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
4394 if (rc == ERROR_SUCCESS)
4395 {
4396 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveIniValuesOnUninstall, package );
4397 msiobj_release( &view->hdr );
4398 if (rc != ERROR_SUCCESS)
4399 return rc;
4400 }
4401 rc = MSI_DatabaseOpenViewW( package->db, remove_query, &view );
4402 if (rc == ERROR_SUCCESS)
4403 {
4404 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveIniValuesOnInstall, package );
4405 msiobj_release( &view->hdr );
4406 if (rc != ERROR_SUCCESS)
4407 return rc;
4408 }
4409 return ERROR_SUCCESS;
4410 }
4411
4412 static void register_dll( const WCHAR *dll, BOOL unregister )
4413 {
4414 HMODULE hmod;
4415
4416 hmod = LoadLibraryExW( dll, 0, LOAD_WITH_ALTERED_SEARCH_PATH );
4417 if (hmod)
4418 {
4419 HRESULT (WINAPI *func_ptr)( void );
4420 const char *func = unregister ? "DllUnregisterServer" : "DllRegisterServer";
4421
4422 func_ptr = (void *)GetProcAddress( hmod, func );
4423 if (func_ptr)
4424 {
4425 HRESULT hr = func_ptr();
4426 if (FAILED( hr ))
4427 WARN("failed to register dll 0x%08x\n", hr);
4428 }
4429 else
4430 WARN("entry point %s not found\n", func);
4431 FreeLibrary( hmod );
4432 return;
4433 }
4434 WARN("failed to load library %u\n", GetLastError());
4435 }
4436
4437 static UINT ITERATE_SelfRegModules(MSIRECORD *row, LPVOID param)
4438 {
4439 MSIPACKAGE *package = param;
4440 LPCWSTR filename;
4441 MSIFILE *file;
4442 MSIRECORD *uirow;
4443
4444 filename = MSI_RecordGetString( row, 1 );
4445 file = msi_get_loaded_file( package, filename );
4446 if (!file)
4447 {
4448 WARN("unable to find file %s\n", debugstr_w(filename));
4449 return ERROR_SUCCESS;
4450 }
4451 file->Component->Action = msi_get_component_action( package, file->Component );
4452 if (file->Component->Action != INSTALLSTATE_LOCAL)
4453 {
4454 TRACE("component not scheduled for installation %s\n", debugstr_w(file->Component->Component));
4455 return ERROR_SUCCESS;
4456 }
4457
4458 TRACE("Registering %s\n", debugstr_w( file->TargetPath ));
4459 register_dll( file->TargetPath, FALSE );
4460
4461 uirow = MSI_CreateRecord( 2 );
4462 MSI_RecordSetStringW( uirow, 1, file->File );
4463 MSI_RecordSetStringW( uirow, 2, file->Component->Directory );
4464 msi_ui_actiondata( package, szSelfRegModules, uirow );
4465 msiobj_release( &uirow->hdr );
4466
4467 return ERROR_SUCCESS;
4468 }
4469
4470 static UINT ACTION_SelfRegModules(MSIPACKAGE *package)
4471 {
4472 static const WCHAR query[] = {
4473 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4474 '`','S','e','l','f','R','e','g','`',0};
4475 MSIQUERY *view;
4476 UINT rc;
4477
4478 rc = MSI_DatabaseOpenViewW(package->db, query, &view);
4479 if (rc != ERROR_SUCCESS)
4480 return ERROR_SUCCESS;
4481
4482 rc = MSI_IterateRecords(view, NULL, ITERATE_SelfRegModules, package);
4483 msiobj_release(&view->hdr);
4484 return rc;
4485 }
4486
4487 static UINT ITERATE_SelfUnregModules( MSIRECORD *row, LPVOID param )
4488 {
4489 MSIPACKAGE *package = param;
4490 LPCWSTR filename;
4491 MSIFILE *file;
4492 MSIRECORD *uirow;
4493
4494 filename = MSI_RecordGetString( row, 1 );
4495 file = msi_get_loaded_file( package, filename );
4496 if (!file)
4497 {
4498 WARN("unable to find file %s\n", debugstr_w(filename));
4499 return ERROR_SUCCESS;
4500 }
4501 file->Component->Action = msi_get_component_action( package, file->Component );
4502 if (file->Component->Action != INSTALLSTATE_ABSENT)
4503 {
4504 TRACE("component not scheduled for removal %s\n", debugstr_w(file->Component->Component));
4505 return ERROR_SUCCESS;
4506 }
4507
4508 TRACE("Unregistering %s\n", debugstr_w( file->TargetPath ));
4509 register_dll( file->TargetPath, TRUE );
4510
4511 uirow = MSI_CreateRecord( 2 );
4512 MSI_RecordSetStringW( uirow, 1, file->File );
4513 MSI_RecordSetStringW( uirow, 2, file->Component->Directory );
4514 msi_ui_actiondata( package, szSelfUnregModules, uirow );
4515 msiobj_release( &uirow->hdr );
4516
4517 return ERROR_SUCCESS;
4518 }
4519
4520 static UINT ACTION_SelfUnregModules( MSIPACKAGE *package )
4521 {
4522 static const WCHAR query[] = {
4523 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4524 '`','S','e','l','f','R','e','g','`',0};
4525 MSIQUERY *view;
4526 UINT rc;
4527
4528 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
4529 if (rc != ERROR_SUCCESS)
4530 return ERROR_SUCCESS;
4531
4532 rc = MSI_IterateRecords( view, NULL, ITERATE_SelfUnregModules, package );
4533 msiobj_release( &view->hdr );
4534 return rc;
4535 }
4536
4537 static UINT ACTION_PublishFeatures(MSIPACKAGE *package)
4538 {
4539 MSIFEATURE *feature;
4540 UINT rc;
4541 HKEY hkey = NULL, userdata = NULL;
4542
4543 if (!msi_check_publish(package))
4544 return ERROR_SUCCESS;
4545
4546 rc = MSIREG_OpenFeaturesKey(package->ProductCode, package->Context,
4547 &hkey, TRUE);
4548 if (rc != ERROR_SUCCESS)
4549 goto end;
4550
4551 rc = MSIREG_OpenUserDataFeaturesKey(package->ProductCode, package->Context,
4552 &userdata, TRUE);
4553 if (rc != ERROR_SUCCESS)
4554 goto end;
4555
4556 /* here the guids are base 85 encoded */
4557 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
4558 {
4559 ComponentList *cl;
4560 LPWSTR data = NULL;
4561 GUID clsid;
4562 INT size;
4563 BOOL absent = FALSE;
4564 MSIRECORD *uirow;
4565
4566 if (feature->Action != INSTALLSTATE_LOCAL &&
4567 feature->Action != INSTALLSTATE_SOURCE &&
4568 feature->Action != INSTALLSTATE_ADVERTISED) absent = TRUE;
4569
4570 size = 1;
4571 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
4572 {
4573 size += 21;
4574 }
4575 if (feature->Feature_Parent)
4576 size += strlenW( feature->Feature_Parent )+2;
4577
4578 data = msi_alloc(size * sizeof(WCHAR));
4579
4580 data[0] = 0;
4581 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
4582 {
4583 MSICOMPONENT* component = cl->component;
4584 WCHAR buf[21];
4585
4586 buf[0] = 0;
4587 if (component->ComponentId)
4588 {
4589 TRACE("From %s\n",debugstr_w(component->ComponentId));
4590 CLSIDFromString(component->ComponentId, &clsid);
4591 encode_base85_guid(&clsid,buf);
4592 TRACE("to %s\n",debugstr_w(buf));
4593 strcatW(data,buf);
4594 }
4595 }
4596
4597 if (feature->Feature_Parent)
4598 {
4599 static const WCHAR sep[] = {'\2',0};
4600 strcatW(data,sep);
4601 strcatW(data,feature->Feature_Parent);
4602 }
4603
4604 msi_reg_set_val_str( userdata, feature->Feature, data );
4605 msi_free(data);
4606
4607 size = 0;
4608 if (feature->Feature_Parent)
4609 size = strlenW(feature->Feature_Parent)*sizeof(WCHAR);
4610 if (!absent)
4611 {
4612 size += sizeof(WCHAR);
4613 RegSetValueExW(hkey,feature->Feature,0,REG_SZ,
4614 (const BYTE*)(feature->Feature_Parent ? feature->Feature_Parent : szEmpty),size);
4615 }
4616 else
4617 {
4618 size += 2*sizeof(WCHAR);
4619 data = msi_alloc(size);
4620 data[0] = 0x6;
4621 data[1] = 0;
4622 if (feature->Feature_Parent)
4623 strcpyW( &data[1], feature->Feature_Parent );
4624 RegSetValueExW(hkey,feature->Feature,0,REG_SZ,
4625 (LPBYTE)data,size);
4626 msi_free(data);
4627 }
4628
4629 /* the UI chunk */
4630 uirow = MSI_CreateRecord( 1 );
4631 MSI_RecordSetStringW( uirow, 1, feature->Feature );
4632 msi_ui_actiondata( package, szPublishFeatures, uirow );
4633 msiobj_release( &uirow->hdr );
4634 /* FIXME: call msi_ui_progress? */
4635 }
4636
4637 end:
4638 RegCloseKey(hkey);
4639 RegCloseKey(userdata);
4640 return rc;
4641 }
4642
4643 static UINT msi_unpublish_feature(MSIPACKAGE *package, MSIFEATURE *feature)
4644 {
4645 UINT r;
4646 HKEY hkey;
4647 MSIRECORD *uirow;
4648
4649 TRACE("unpublishing feature %s\n", debugstr_w(feature->Feature));
4650
4651 r = MSIREG_OpenFeaturesKey(package->ProductCode, package->Context,
4652 &hkey, FALSE);
4653 if (r == ERROR_SUCCESS)
4654 {
4655 RegDeleteValueW(hkey, feature->Feature);
4656 RegCloseKey(hkey);
4657 }
4658
4659 r = MSIREG_OpenUserDataFeaturesKey(package->ProductCode, package->Context,
4660 &hkey, FALSE);
4661 if (r == ERROR_SUCCESS)
4662 {
4663 RegDeleteValueW(hkey, feature->Feature);
4664 RegCloseKey(hkey);
4665 }
4666
4667 uirow = MSI_CreateRecord( 1 );
4668 MSI_RecordSetStringW( uirow, 1, feature->Feature );
4669 msi_ui_actiondata( package, szUnpublishFeatures, uirow );
4670 msiobj_release( &uirow->hdr );
4671
4672 return ERROR_SUCCESS;
4673 }
4674
4675 static UINT ACTION_UnpublishFeatures(MSIPACKAGE *package)
4676 {
4677 MSIFEATURE *feature;
4678
4679 if (!msi_check_unpublish(package))
4680 return ERROR_SUCCESS;
4681
4682 LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
4683 {
4684 msi_unpublish_feature(package, feature);
4685 }
4686
4687 return ERROR_SUCCESS;
4688 }
4689
4690 static UINT msi_publish_install_properties(MSIPACKAGE *package, HKEY hkey)
4691 {
4692 SYSTEMTIME systime;
4693 DWORD size, langid;
4694 WCHAR date[9], *val, *buffer;
4695 const WCHAR *prop, *key;
4696
4697 static const WCHAR date_fmt[] = {'%','i','%','0','2','i','%','0','2','i',0};
4698 static const WCHAR modpath_fmt[] =
4699 {'M','s','i','E','x','e','c','.','e','x','e',' ',
4700 '/','I','[','P','r','o','d','u','c','t','C','o','d','e',']',0};
4701 static const WCHAR szModifyPath[] =
4702 {'M','o','d','i','f','y','P','a','t','h',0};
4703 static const WCHAR szUninstallString[] =
4704 {'U','n','i','n','s','t','a','l','l','S','t','r','i','n','g',0};
4705 static const WCHAR szEstimatedSize[] =
4706 {'E','s','t','i','m','a','t','e','d','S','i','z','e',0};
4707 static const WCHAR szDisplayVersion[] =
4708 {'D','i','s','p','l','a','y','V','e','r','s','i','o','n',0};
4709 static const WCHAR szInstallSource[] =
4710 {'I','n','s','t','a','l','l','S','o','u','r','c','e',0};
4711 static const WCHAR szARPAUTHORIZEDCDFPREFIX[] =
4712 {'A','R','P','A','U','T','H','O','R','I','Z','E','D','C','D','F','P','R','E','F','I','X',0};
4713 static const WCHAR szAuthorizedCDFPrefix[] =
4714 {'A','u','t','h','o','r','i','z','e','d','C','D','F','P','r','e','f','i','x',0};
4715 static const WCHAR szARPCONTACT[] =
4716 {'A','R','P','C','O','N','T','A','C','T',0};
4717 static const WCHAR szContact[] =
4718 {'C','o','n','t','a','c','t',0};
4719 static const WCHAR szARPCOMMENTS[] =
4720 {'A','R','P','C','O','M','M','E','N','T','S',0};
4721 static const WCHAR szComments[] =
4722 {'C','o','m','m','e','n','t','s',0};
4723 static const WCHAR szProductName[] =
4724 {'P','r','o','d','u','c','t','N','a','m','e',0};
4725 static const WCHAR szDisplayName[] =
4726 {'D','i','s','p','l','a','y','N','a','m','e',0};
4727 static const WCHAR szARPHELPLINK[] =
4728 {'A','R','P','H','E','L','P','L','I','N','K',0};
4729 static const WCHAR szHelpLink[] =
4730 {'H','e','l','p','L','i','n','k',0};
4731 static const WCHAR szARPHELPTELEPHONE[] =
4732 {'A','R','P','H','E','L','P','T','E','L','E','P','H','O','N','E',0};
4733 static const WCHAR szHelpTelephone[] =
4734 {'H','e','l','p','T','e','l','e','p','h','o','n','e',0};
4735 static const WCHAR szARPINSTALLLOCATION[] =
4736 {'A','R','P','I','N','S','T','A','L','L','L','O','C','A','T','I','O','N',0};
4737 static const WCHAR szInstallLocation[] =
4738 {'I','n','s','t','a','l','l','L','o','c','a','t','i','o','n',0};
4739 static const WCHAR szManufacturer[] =
4740 {'M','a','n','u','f','a','c','t','u','r','e','r',0};
4741 static const WCHAR szPublisher[] =
4742 {'P','u','b','l','i','s','h','e','r',0};
4743 static const WCHAR szARPREADME[] =
4744 {'A','R','P','R','E','A','D','M','E',0};
4745 static const WCHAR szReadme[] =
4746 {'R','e','a','d','M','e',0};
4747 static const WCHAR szARPSIZE[] =
4748 {'A','R','P','S','I','Z','E',0};
4749 static const WCHAR szSize[] =
4750 {'S','i','z','e',0};
4751 static const WCHAR szARPURLINFOABOUT[] =
4752 {'A','R','P','U','R','L','I','N','F','O','A','B','O','U','T',0};
4753 static const WCHAR szURLInfoAbout[] =
4754 {'U','R','L','I','n','f','o','A','b','o','u','t',0};
4755 static const WCHAR szARPURLUPDATEINFO[] =
4756 {'A','R','P','U','R','L','U','P','D','A','T','E','I','N','F','O',0};
4757 static const WCHAR szURLUpdateInfo[] =
4758 {'U','R','L','U','p','d','a','t','e','I','n','f','o',0};
4759 static const WCHAR szARPSYSTEMCOMPONENT[] =
4760 {'A','R','P','S','Y','S','T','E','M','C','O','M','P','O','N','E','N','T',0};
4761 static const WCHAR szSystemComponent[] =
4762 {'S','y','s','t','e','m','C','o','m','p','o','n','e','n','t',0};
4763
4764 static const WCHAR *propval[] = {
4765 szARPAUTHORIZEDCDFPREFIX, szAuthorizedCDFPrefix,
4766 szARPCONTACT, szContact,
4767 szARPCOMMENTS, szComments,
4768 szProductName, szDisplayName,
4769 szARPHELPLINK, szHelpLink,
4770 szARPHELPTELEPHONE, szHelpTelephone,
4771 szARPINSTALLLOCATION, szInstallLocation,
4772 szSourceDir, szInstallSource,
4773 szManufacturer, szPublisher,
4774 szARPREADME, szReadme,
4775 szARPSIZE, szSize,
4776 szARPURLINFOABOUT, szURLInfoAbout,
4777 szARPURLUPDATEINFO, szURLUpdateInfo,
4778 NULL
4779 };
4780 const WCHAR **p = propval;
4781
4782 while (*p)
4783 {
4784 prop = *p++;
4785 key = *p++;
4786 val = msi_dup_property(package->db, prop);
4787 msi_reg_set_val_str(hkey, key, val);
4788 msi_free(val);
4789 }
4790
4791 msi_reg_set_val_dword(hkey, szWindowsInstaller, 1);
4792 if (msi_get_property_int( package->db, szARPSYSTEMCOMPONENT, 0 ))
4793 {
4794 msi_reg_set_val_dword( hkey, szSystemComponent, 1 );
4795 }
4796 size = deformat_string(package, modpath_fmt, &buffer);
4797 RegSetValueExW(hkey, szModifyPath, 0, REG_EXPAND_SZ, (LPBYTE)buffer, size);
4798 RegSetValueExW(hkey, szUninstallString, 0, REG_EXPAND_SZ, (LPBYTE)buffer, size);
4799 msi_free(buffer);
4800
4801 /* FIXME: Write real Estimated Size when we have it */
4802 msi_reg_set_val_dword(hkey, szEstimatedSize, 0);
4803
4804 GetLocalTime(&systime);
4805 sprintfW(date, date_fmt, systime.wYear, systime.wMonth, systime.wDay);
4806 msi_reg_set_val_str(hkey, INSTALLPROPERTY_INSTALLDATEW, date);
4807
4808 langid = msi_get_property_int(package->db, szProductLanguage, 0);
4809 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_LANGUAGEW, langid);
4810
4811 buffer = msi_dup_property(package->db, szProductVersion);
4812 msi_reg_set_val_str(hkey, szDisplayVersion, buffer);
4813 if (buffer)
4814 {
4815 DWORD verdword = msi_version_str_to_dword(buffer);
4816
4817 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONW, verdword);
4818 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONMAJORW, verdword >> 24);
4819 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONMINORW, (verdword >> 16) & 0xFF);
4820 msi_free(buffer);
4821 }
4822
4823 return ERROR_SUCCESS;
4824 }
4825
4826 static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
4827 {
4828 WCHAR squashed_pc[SQUISH_GUID_SIZE];
4829 MSIRECORD *uirow;
4830 LPWSTR upgrade_code;
4831 HKEY hkey, props, upgrade_key;
4832 UINT rc;
4833
4834 /* FIXME: also need to publish if the product is in advertise mode */
4835 if (!msi_check_publish(package))
4836 return ERROR_SUCCESS;
4837
4838 rc = MSIREG_OpenUninstallKey(package->ProductCode, package->platform, &hkey, TRUE);
4839 if (rc != ERROR_SUCCESS)
4840 return rc;
4841
4842 rc = MSIREG_OpenInstallProps(package->ProductCode, package->Context, NULL, &props, TRUE);
4843 if (rc != ERROR_SUCCESS)
4844 goto done;
4845
4846 rc = msi_publish_install_properties(package, hkey);
4847 if (rc != ERROR_SUCCESS)
4848 goto done;
4849
4850 rc = msi_publish_install_properties(package, props);
4851 if (rc != ERROR_SUCCESS)
4852 goto done;
4853
4854 upgrade_code = msi_dup_property(package->db, szUpgradeCode);
4855 if (upgrade_code)
4856 {
4857 rc = MSIREG_OpenUpgradeCodesKey( upgrade_code, &upgrade_key, TRUE );
4858 if (rc == ERROR_SUCCESS)
4859 {
4860 squash_guid( package->ProductCode, squashed_pc );
4861 msi_reg_set_val_str( upgrade_key, squashed_pc, NULL );
4862 RegCloseKey( upgrade_key );
4863 }
4864 msi_free( upgrade_code );
4865 }
4866 msi_reg_set_val_str( props, INSTALLPROPERTY_LOCALPACKAGEW, package->localfile );
4867 package->delete_on_close = FALSE;
4868
4869 done:
4870 uirow = MSI_CreateRecord( 1 );
4871 MSI_RecordSetStringW( uirow, 1, package->ProductCode );
4872 msi_ui_actiondata( package, szRegisterProduct, uirow );
4873 msiobj_release( &uirow->hdr );
4874
4875 RegCloseKey(hkey);
4876 return ERROR_SUCCESS;
4877 }
4878
4879 static UINT ACTION_InstallExecute(MSIPACKAGE *package)
4880 {
4881 return execute_script(package, SCRIPT_INSTALL);
4882 }
4883
4884 static UINT ITERATE_UnpublishIcon( MSIRECORD *row, LPVOID param )
4885 {
4886 MSIPACKAGE *package = param;
4887 const WCHAR *icon = MSI_RecordGetString( row, 1 );
4888 WCHAR *p, *icon_path;
4889
4890 if (!icon) return ERROR_SUCCESS;
4891 if ((icon_path = msi_build_icon_path( package, icon )))
4892 {
4893 TRACE("removing icon file %s\n", debugstr_w(icon_path));
4894 DeleteFileW( icon_path );
4895 if ((p = strrchrW( icon_path, '\\' )))
4896 {
4897 *p = 0;
4898 RemoveDirectoryW( icon_path );
4899 }
4900 msi_free( icon_path );
4901 }
4902 return ERROR_SUCCESS;
4903 }
4904
4905 static UINT msi_unpublish_icons( MSIPACKAGE *package )
4906 {
4907 static const WCHAR query[]= {
4908 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','`','I','c','o','n','`',0};
4909 MSIQUERY *view;
4910 UINT r;
4911
4912 r = MSI_DatabaseOpenViewW( package->db, query, &view );
4913 if (r == ERROR_SUCCESS)
4914 {
4915 r = MSI_IterateRecords( view, NULL, ITERATE_UnpublishIcon, package );
4916 msiobj_release( &view->hdr );
4917 if (r != ERROR_SUCCESS)
4918 return r;
4919 }
4920 return ERROR_SUCCESS;
4921 }
4922
4923 static UINT msi_unpublish_product( MSIPACKAGE *package, const WCHAR *remove )
4924 {
4925 static const WCHAR szUpgradeCode[] = {'U','p','g','r','a','d','e','C','o','d','e',0};
4926 WCHAR *upgrade, **features;
4927 BOOL full_uninstall = TRUE;
4928 MSIFEATURE *feature;
4929 MSIPATCHINFO *patch;
4930 UINT i;
4931
4932 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
4933 {
4934 if (feature->Action == INSTALLSTATE_LOCAL) full_uninstall = FALSE;
4935 }
4936 features = msi_split_string( remove, ',' );
4937 for (i = 0; features && features[i]; i++)
4938 {
4939 if (!strcmpW( features[i], szAll )) full_uninstall = TRUE;
4940 }
4941 msi_free(features);
4942
4943 if (!full_uninstall)
4944 return ERROR_SUCCESS;
4945
4946 MSIREG_DeleteProductKey(package->ProductCode);
4947 MSIREG_DeleteUserDataProductKey(package->ProductCode);
4948 MSIREG_DeleteUninstallKey(package->ProductCode, package->platform);
4949
4950 MSIREG_DeleteLocalClassesProductKey(package->ProductCode);
4951 MSIREG_DeleteLocalClassesFeaturesKey(package->ProductCode);
4952 MSIREG_DeleteUserProductKey(package->ProductCode);
4953 MSIREG_DeleteUserFeaturesKey(package->ProductCode);
4954
4955 upgrade = msi_dup_property(package->db, szUpgradeCode);
4956 if (upgrade)
4957 {
4958 MSIREG_DeleteUserUpgradeCodesKey(upgrade);
4959 MSIREG_DeleteClassesUpgradeCodesKey(upgrade);
4960 msi_free(upgrade);
4961 }
4962
4963 LIST_FOR_EACH_ENTRY(patch, &package->patches, MSIPATCHINFO, entry)
4964 {
4965 MSIREG_DeleteUserDataPatchKey(patch->patchcode, package->Context);
4966 if (!strcmpW( package->ProductCode, patch->products ))
4967 {
4968 TRACE("removing local patch package %s\n", debugstr_w(patch->localfile));
4969 patch->delete_on_close = TRUE;
4970 }
4971 /* FIXME: remove local patch package if this is the last product */
4972 }
4973 TRACE("removing local package %s\n", debugstr_w(package->localfile));
4974 package->delete_on_close = TRUE;
4975
4976 msi_unpublish_icons( package );
4977 return ERROR_SUCCESS;
4978 }
4979
4980 static UINT ACTION_InstallFinalize(MSIPACKAGE *package)
4981 {
4982 UINT rc;
4983 WCHAR *remove;
4984
4985 /* turn off scheduling */
4986 package->script->CurrentlyScripting= FALSE;
4987
4988 /* first do the same as an InstallExecute */
4989 rc = ACTION_InstallExecute(package);
4990 if (rc != ERROR_SUCCESS)
4991 return rc;
4992
4993 /* then handle commit actions */
4994 rc = execute_script(package, SCRIPT_COMMIT);
4995 if (rc != ERROR_SUCCESS)
4996 return rc;
4997
4998 remove = msi_dup_property(package->db, szRemove);
4999 rc = msi_unpublish_product(package, remove);
5000 msi_free(remove);
5001 return rc;
5002 }
5003
5004 UINT ACTION_ForceReboot(MSIPACKAGE *package)
5005 {
5006 static const WCHAR RunOnce[] = {
5007 'S','o','f','t','w','a','r','e','\\',
5008 'M','i','c','r','o','s','o','f','t','\\',
5009 'W','i','n','d','o','w','s','\\',
5010 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
5011 'R','u','n','O','n','c','e',0};
5012 static const WCHAR InstallRunOnce[] = {
5013 'S','o','f','t','w','a','r','e','\\',
5014 'M','i','c','r','o','s','o','f','t','\\',
5015 'W','i','n','d','o','w','s','\\',
5016 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
5017 'I','n','s','t','a','l','l','e','r','\\',
5018 'R','u','n','O','n','c','e','E','n','t','r','i','e','s',0};
5019
5020 static const WCHAR msiexec_fmt[] = {
5021 '%','s',
5022 '\\','M','s','i','E','x','e','c','.','e','x','e',' ','/','@',' ',
5023 '\"','%','s','\"',0};
5024 static const WCHAR install_fmt[] = {
5025 '/','I',' ','\"','%','s','\"',' ',
5026 'A','F','T','E','R','R','E','B','O','O','T','=','1',' ',
5027 'R','U','N','O','N','C','E','E','N','T','R','Y','=','\"','%','s','\"',0};
5028 WCHAR buffer[256], sysdir[MAX_PATH];
5029 HKEY hkey;
5030 WCHAR squished_pc[100];
5031
5032 squash_guid(package->ProductCode,squished_pc);
5033
5034 GetSystemDirectoryW(sysdir, sizeof(sysdir)/sizeof(sysdir[0]));
5035 RegCreateKeyW(HKEY_LOCAL_MACHINE,RunOnce,&hkey);
5036 snprintfW(buffer,sizeof(buffer)/sizeof(buffer[0]),msiexec_fmt,sysdir,
5037 squished_pc);
5038
5039 msi_reg_set_val_str( hkey, squished_pc, buffer );
5040 RegCloseKey(hkey);
5041
5042 TRACE("Reboot command %s\n",debugstr_w(buffer));
5043
5044 RegCreateKeyW(HKEY_LOCAL_MACHINE,InstallRunOnce,&hkey);
5045 sprintfW(buffer,install_fmt,package->ProductCode,squished_pc);
5046
5047 msi_reg_set_val_str( hkey, squished_pc, buffer );
5048 RegCloseKey(hkey);
5049
5050 return ERROR_INSTALL_SUSPEND;
5051 }
5052
5053 WCHAR *msi_build_error_string( MSIPACKAGE *package, UINT error, DWORD count, ... )
5054 {
5055 static const WCHAR query[] =
5056 {'S','E','L','E','C','T',' ','`','M','e','s','s','a','g','e','`',' ',
5057 'F','R','O','M',' ','`','E','r','r','o','r','`',' ','W','H','E','R','E',' ',
5058 '`','E','r','r','o','r','`',' ','=',' ','%','i',0};
5059 MSIRECORD *rec, *row;
5060 DWORD i, size = 0;
5061 va_list va;
5062 const WCHAR *str;
5063 WCHAR *data;
5064
5065 if (!(row = MSI_QueryGetRecord( package->db, query, error ))) return 0;
5066
5067 rec = MSI_CreateRecord( count + 2 );
5068 str = MSI_RecordGetString( row, 1 );
5069 MSI_RecordSetStringW( rec, 0, str );
5070 msiobj_release( &row->hdr );
5071 MSI_RecordSetInteger( rec, 1, error );
5072
5073 va_start( va, count );
5074 for (i = 0; i < count; i++)
5075 {
5076 str = va_arg( va, const WCHAR *);
5077 MSI_RecordSetStringW( rec, i + 2, str );
5078 }
5079 va_end( va );
5080
5081 MSI_FormatRecordW( package, rec, NULL, &size );
5082 size++;
5083 data = msi_alloc( size * sizeof(WCHAR) );
5084 if (size > 1) MSI_FormatRecordW( package, rec, data, &size );
5085 else data[0] = 0;
5086 msiobj_release( &rec->hdr );
5087 return data;
5088 }
5089
5090 static UINT ACTION_ResolveSource(MSIPACKAGE* package)
5091 {
5092 DWORD attrib;
5093 UINT rc;
5094
5095 /*
5096 * We are currently doing what should be done here in the top level Install
5097 * however for Administrative and uninstalls this step will be needed
5098 */
5099 if (!package->PackagePath)
5100 return ERROR_SUCCESS;
5101
5102 msi_set_sourcedir_props(package, TRUE);
5103
5104 attrib = GetFileAttributesW(package->db->path);
5105 if (attrib == INVALID_FILE_ATTRIBUTES)
5106 {
5107 LPWSTR prompt, msg;
5108 DWORD size = 0;
5109
5110 rc = MsiSourceListGetInfoW(package->ProductCode, NULL,
5111 package->Context, MSICODE_PRODUCT,
5112 INSTALLPROPERTY_DISKPROMPTW,NULL,&size);
5113 if (rc == ERROR_MORE_DATA)
5114 {
5115 prompt = msi_alloc(size * sizeof(WCHAR));
5116 MsiSourceListGetInfoW(package->ProductCode, NULL,
5117 package->Context, MSICODE_PRODUCT,
5118 INSTALLPROPERTY_DISKPROMPTW,prompt,&size);
5119 }
5120 else
5121 prompt = strdupW(package->db->path);
5122
5123 msg = msi_build_error_string(package, 1302, 1, prompt);
5124 msi_free(prompt);
5125 while(attrib == INVALID_FILE_ATTRIBUTES)
5126 {
5127 rc = MessageBoxW(NULL, msg, NULL, MB_OKCANCEL);
5128 if (rc == IDCANCEL)
5129 {
5130 msi_free(msg);
5131 return ERROR_INSTALL_USEREXIT;
5132 }
5133 attrib = GetFileAttributesW(package->db->path);
5134 }
5135 msi_free(msg);
5136 rc = ERROR_SUCCESS;
5137 }
5138 else
5139 return ERROR_SUCCESS;
5140
5141 return rc;
5142 }
5143
5144 static UINT ACTION_RegisterUser(MSIPACKAGE *package)
5145 {
5146 HKEY hkey = 0;
5147 LPWSTR buffer, productid = NULL;
5148 UINT i, rc = ERROR_SUCCESS;
5149 MSIRECORD *uirow;
5150
5151 static const WCHAR szPropKeys[][80] =
5152 {
5153 {'P','r','o','d','u','c','t','I','D',0},
5154 {'U','S','E','R','N','A','M','E',0},
5155 {'C','O','M','P','A','N','Y','N','A','M','E',0},
5156 {0},
5157 };
5158
5159 static const WCHAR szRegKeys[][80] =
5160 {
5161 {'P','r','o','d','u','c','t','I','D',0},
5162 {'R','e','g','O','w','n','e','r',0},
5163 {'R','e','g','C','o','m','p','a','n','y',0},
5164 {0},
5165 };
5166
5167 if (msi_check_unpublish(package))
5168 {
5169 MSIREG_DeleteUserDataProductKey(package->ProductCode);
5170 goto end;
5171 }
5172
5173 productid = msi_dup_property( package->db, INSTALLPROPERTY_PRODUCTIDW );
5174 if (!productid)
5175 goto end;
5176
5177 rc = MSIREG_OpenInstallProps(package->ProductCode, package->Context,
5178 NULL, &hkey, TRUE);
5179 if (rc != ERROR_SUCCESS)
5180 goto end;
5181
5182 for( i = 0; szPropKeys[i][0]; i++ )
5183 {
5184 buffer = msi_dup_property( package->db, szPropKeys[i] );
5185 msi_reg_set_val_str( hkey, szRegKeys[i], buffer );
5186 msi_free( buffer );
5187 }
5188
5189 end:
5190 uirow = MSI_CreateRecord( 1 );
5191 MSI_RecordSetStringW( uirow, 1, productid );
5192 msi_ui_actiondata( package, szRegisterUser, uirow );
5193 msiobj_release( &uirow->hdr );
5194
5195 msi_free(productid);
5196 RegCloseKey(hkey);
5197 return rc;
5198 }
5199
5200
5201 static UINT ACTION_ExecuteAction(MSIPACKAGE *package)
5202 {
5203 UINT rc;
5204
5205 package->script->InWhatSequence |= SEQUENCE_EXEC;
5206 rc = ACTION_ProcessExecSequence(package,FALSE);
5207 return rc;
5208 }
5209
5210 WCHAR *msi_create_component_advertise_string( MSIPACKAGE *package, MSICOMPONENT *component, const WCHAR *feature )
5211 {
5212 static const WCHAR fmt[] = {'%','s','%','s','%','c','%','s',0};
5213 WCHAR productid_85[21], component_85[21], *ret;
5214 GUID clsid;
5215 DWORD sz;
5216
5217 /* > is used if there is a component GUID and < if not. */
5218
5219 productid_85[0] = 0;
5220 component_85[0] = 0;
5221 CLSIDFromString( package->ProductCode, &clsid );
5222
5223 encode_base85_guid( &clsid, productid_85 );
5224 if (component)
5225 {
5226 CLSIDFromString( component->ComponentId, &clsid );
5227 encode_base85_guid( &clsid, component_85 );
5228 }
5229
5230 TRACE("product=%s feature=%s component=%s\n", debugstr_w(productid_85), debugstr_w(feature),
5231 debugstr_w(component_85));
5232
5233 sz = 20 + strlenW( feature ) + 20 + 3;
5234 ret = msi_alloc_zero( sz * sizeof(WCHAR) );
5235 if (ret) sprintfW( ret, fmt, productid_85, feature, component ? '>' : '<', component_85 );
5236 return ret;
5237 }
5238
5239 static UINT ITERATE_PublishComponent(MSIRECORD *rec, LPVOID param)
5240 {
5241 MSIPACKAGE *package = param;
5242 LPCWSTR compgroupid, component, feature, qualifier, text;
5243 LPWSTR advertise = NULL, output = NULL, existing = NULL, p, q;
5244 HKEY hkey = NULL;
5245 UINT rc;
5246 MSICOMPONENT *comp;
5247 MSIFEATURE *feat;
5248 DWORD sz;
5249 MSIRECORD *uirow;
5250 int len;
5251
5252 feature = MSI_RecordGetString(rec, 5);
5253 feat = msi_get_loaded_feature(package, feature);
5254 if (!feat)
5255 return ERROR_SUCCESS;
5256
5257 feat->Action = msi_get_feature_action( package, feat );
5258 if (feat->Action != INSTALLSTATE_LOCAL &&
5259 feat->Action != INSTALLSTATE_SOURCE &&
5260 feat->Action != INSTALLSTATE_ADVERTISED)
5261 {
5262 TRACE("feature not scheduled for installation %s\n", debugstr_w(feature));
5263 return ERROR_SUCCESS;
5264 }
5265
5266 component = MSI_RecordGetString(rec, 3);
5267 comp = msi_get_loaded_component(package, component);
5268 if (!comp)
5269 return ERROR_SUCCESS;
5270
5271 compgroupid = MSI_RecordGetString(rec,1);
5272 qualifier = MSI_RecordGetString(rec,2);
5273
5274 rc = MSIREG_OpenUserComponentsKey(compgroupid, &hkey, TRUE);
5275 if (rc != ERROR_SUCCESS)
5276 goto end;
5277
5278 advertise = msi_create_component_advertise_string( package, comp, feature );
5279 text = MSI_RecordGetString( rec, 4 );
5280 if (text)
5281 {
5282 p = msi_alloc( (strlenW( advertise ) + strlenW( text ) + 1) * sizeof(WCHAR) );
5283 strcpyW( p, advertise );
5284 strcatW( p, text );
5285 msi_free( advertise );
5286 advertise = p;
5287 }
5288 existing = msi_reg_get_val_str( hkey, qualifier );
5289
5290 sz = strlenW( advertise ) + 1;
5291 if (existing)
5292 {
5293 for (p = existing; *p; p += len)
5294 {
5295 len = strlenW( p ) + 1;
5296 if (strcmpW( advertise, p )) sz += len;
5297 }
5298 }
5299 if (!(output = msi_alloc( (sz + 1) * sizeof(WCHAR) )))
5300 {
5301 rc = ERROR_OUTOFMEMORY;
5302 goto end;
5303 }
5304 q = output;
5305 if (existing)
5306 {
5307 for (p = existing; *p; p += len)
5308 {
5309 len = strlenW( p ) + 1;
5310 if (strcmpW( advertise, p ))
5311 {
5312 memcpy( q, p, len * sizeof(WCHAR) );
5313 q += len;
5314 }
5315 }
5316 }
5317 strcpyW( q, advertise );
5318 q[strlenW( q ) + 1] = 0;
5319
5320 msi_reg_set_val_multi_str( hkey, qualifier, output );
5321
5322 end:
5323 RegCloseKey(hkey);
5324 msi_free( output );
5325 msi_free( advertise );
5326 msi_free( existing );
5327
5328 /* the UI chunk */
5329 uirow = MSI_CreateRecord( 2 );
5330 MSI_RecordSetStringW( uirow, 1, compgroupid );
5331 MSI_RecordSetStringW( uirow, 2, qualifier);
5332 msi_ui_actiondata( package, szPublishComponents, uirow );
5333 msiobj_release( &uirow->hdr );
5334 /* FIXME: call ui_progress? */
5335
5336 return rc;
5337 }
5338
5339 /*
5340 * At present I am ignorning the advertised components part of this and only
5341 * focusing on the qualified component sets
5342 */
5343 static UINT ACTION_PublishComponents(MSIPACKAGE *package)
5344 {
5345 static const WCHAR query[] = {
5346 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5347 '`','P','u','b','l','i','s','h','C','o','m','p','o','n','e','n','t','`',0};
5348 MSIQUERY *view;
5349 UINT rc;
5350
5351 rc = MSI_DatabaseOpenViewW(package->db, query, &view);
5352 if (rc != ERROR_SUCCESS)
5353 return ERROR_SUCCESS;
5354
5355 rc = MSI_IterateRecords(view, NULL, ITERATE_PublishComponent, package);
5356 msiobj_release(&view->hdr);
5357 return rc;
5358 }
5359
5360 static UINT ITERATE_UnpublishComponent( MSIRECORD *rec, LPVOID param )
5361 {
5362 static const WCHAR szInstallerComponents[] = {
5363 'S','o','f','t','w','a','r','e','\\',
5364 'M','i','c','r','o','s','o','f','t','\\',
5365 'I','n','s','t','a','l','l','e','r','\\',
5366 'C','o','m','p','o','n','e','n','t','s','\\',0};
5367
5368 MSIPACKAGE *package = param;
5369 LPCWSTR compgroupid, component, feature, qualifier;
5370 MSICOMPONENT *comp;
5371 MSIFEATURE *feat;
5372 MSIRECORD *uirow;
5373 WCHAR squashed[GUID_SIZE], keypath[MAX_PATH];
5374 LONG res;
5375
5376 feature = MSI_RecordGetString( rec, 5 );
5377 feat = msi_get_loaded_feature( package, feature );
5378 if (!feat)
5379 return ERROR_SUCCESS;
5380
5381 feat->Action = msi_get_feature_action( package, feat );
5382 if (feat->Action != INSTALLSTATE_ABSENT)
5383 {
5384 TRACE("feature not scheduled for removal %s\n", debugstr_w(feature));
5385 return ERROR_SUCCESS;
5386 }
5387
5388 component = MSI_RecordGetString( rec, 3 );
5389 comp = msi_get_loaded_component( package, component );
5390 if (!comp)
5391 return ERROR_SUCCESS;
5392
5393 compgroupid = MSI_RecordGetString( rec, 1 );
5394 qualifier = MSI_RecordGetString( rec, 2 );
5395
5396 squash_guid( compgroupid, squashed );
5397 strcpyW( keypath, szInstallerComponents );
5398 strcatW( keypath, squashed );
5399
5400 res = RegDeleteKeyW( HKEY_CURRENT_USER, keypath );
5401 if (res != ERROR_SUCCESS)
5402 {
5403 WARN("Unable to delete component key %d\n", res);
5404 }
5405
5406 uirow = MSI_CreateRecord( 2 );
5407 MSI_RecordSetStringW( uirow, 1, compgroupid );
5408 MSI_RecordSetStringW( uirow, 2, qualifier );
5409 msi_ui_actiondata( package, szUnpublishComponents, uirow );
5410 msiobj_release( &uirow->hdr );
5411
5412 return ERROR_SUCCESS;
5413 }
5414
5415 static UINT ACTION_UnpublishComponents( MSIPACKAGE *package )
5416 {
5417 static const WCHAR query[] = {
5418 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5419 '`','P','u','b','l','i','s','h','C','o','m','p','o','n','e','n','t','`',0};
5420 MSIQUERY *view;
5421 UINT rc;
5422
5423 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
5424 if (rc != ERROR_SUCCESS)
5425 return ERROR_SUCCESS;
5426
5427 rc = MSI_IterateRecords( view, NULL, ITERATE_UnpublishComponent, package );
5428 msiobj_release( &view->hdr );
5429 return rc;
5430 }
5431
5432 static UINT ITERATE_InstallService(MSIRECORD *rec, LPVOID param)
5433 {
5434 static const WCHAR query[] =
5435 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5436 '`','C','o','m','p','o','n','e','n','t','`',' ','W','H','E','R','E',' ',
5437 '`','C','o','m','p','o','n','e','n','t','`',' ','=','\'','%','s','\'',0};
5438 MSIPACKAGE *package = param;
5439 MSICOMPONENT *component;
5440 MSIRECORD *row;
5441 MSIFILE *file;
5442 SC_HANDLE hscm = NULL, service = NULL;
5443 LPCWSTR comp, key;
5444 LPWSTR name = NULL, disp = NULL, load_order = NULL, serv_name = NULL;
5445 LPWSTR depends = NULL, pass = NULL, args = NULL, image_path = NULL;
5446 DWORD serv_type, start_type, err_control;
5447 SERVICE_DESCRIPTIONW sd = {NULL};
5448
5449 comp = MSI_RecordGetString( rec, 12 );
5450 component = msi_get_loaded_component( package, comp );
5451 if (!component)
5452 {
5453 WARN("service component not found\n");
5454 goto done;
5455 }
5456 component->Action = msi_get_component_action( package, component );
5457 if (component->Action != INSTALLSTATE_LOCAL)
5458 {
5459 TRACE("component not scheduled for installation %s\n", debugstr_w(comp));
5460 goto done;
5461 }
5462 hscm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, GENERIC_WRITE);
5463 if (!hscm)
5464 {
5465 ERR("Failed to open the SC Manager!\n");
5466 goto done;
5467 }
5468
5469 start_type = MSI_RecordGetInteger(rec, 5);
5470 if (start_type == SERVICE_BOOT_START || start_type == SERVICE_SYSTEM_START)
5471 goto done;
5472
5473 deformat_string(package, MSI_RecordGetString(rec, 2), &name);
5474 deformat_string(package, MSI_RecordGetString(rec, 3), &disp);
5475 serv_type = MSI_RecordGetInteger(rec, 4);
5476 err_control = MSI_RecordGetInteger(rec, 6);
5477 deformat_string(package, MSI_RecordGetString(rec, 7), &load_order);
5478 deformat_string(package, MSI_RecordGetString(rec, 8), &depends);
5479 deformat_string(package, MSI_RecordGetString(rec, 9), &serv_name);
5480 deformat_string(package, MSI_RecordGetString(rec, 10), &pass);
5481 deformat_string(package, MSI_RecordGetString(rec, 11), &args);
5482 deformat_string(package, MSI_RecordGetString(rec, 13), &sd.lpDescription);
5483
5484 /* fetch the service path */
5485 row = MSI_QueryGetRecord(package->db, query, comp);
5486 if (!row)
5487 {
5488 ERR("Query failed\n");
5489 goto done;
5490 }
5491 key = MSI_RecordGetString(row, 6);
5492 file = msi_get_loaded_file(package, key);
5493 msiobj_release(&row->hdr);
5494 if (!file)
5495 {
5496 ERR("Failed to load the service file\n");
5497 goto done;
5498 }
5499
5500 if (!args || !args[0]) image_path = file->TargetPath;
5501 else
5502 {
5503 int len = strlenW(file->TargetPath) + strlenW(args) + 2;
5504 if (!(image_path = msi_alloc(len * sizeof(WCHAR))))
5505 return ERROR_OUTOFMEMORY;
5506
5507 strcpyW(image_path, file->TargetPath);
5508 strcatW(image_path, szSpace);
5509 strcatW(image_path, args);
5510 }
5511 service = CreateServiceW(hscm, name, disp, GENERIC_ALL, serv_type,
5512 start_type, err_control, image_path, load_order,
5513 NULL, depends, serv_name, pass);
5514
5515 if (!service)
5516 {
5517 if (GetLastError() != ERROR_SERVICE_EXISTS)
5518 ERR("Failed to create service %s: %d\n", debugstr_w(name), GetLastError());
5519 }
5520 else if (sd.lpDescription)
5521 {
5522 if (!ChangeServiceConfig2W(service, SERVICE_CONFIG_DESCRIPTION, &sd))
5523 WARN("failed to set service description %u\n", GetLastError());
5524 }
5525
5526 if (image_path != file->TargetPath) msi_free(image_path);
5527 done:
5528 CloseServiceHandle(service);
5529 CloseServiceHandle(hscm);
5530 msi_free(name);
5531 msi_free(disp);
5532 msi_free(sd.lpDescription);
5533 msi_free(load_order);
5534 msi_free(serv_name);
5535 msi_free(pass);
5536 msi_free(depends);
5537 msi_free(args);
5538
5539 return ERROR_SUCCESS;
5540 }
5541
5542 static UINT ACTION_InstallServices( MSIPACKAGE *package )
5543 {
5544 static const WCHAR query[] = {
5545 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5546 'S','e','r','v','i','c','e','I','n','s','t','a','l','l',0};
5547 MSIQUERY *view;
5548 UINT rc;
5549
5550 rc = MSI_DatabaseOpenViewW(package->db, query, &view);
5551 if (rc != ERROR_SUCCESS)
5552 return ERROR_SUCCESS;
5553
5554 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallService, package);
5555 msiobj_release(&view->hdr);
5556 return rc;
5557 }
5558
5559 /* converts arg1[~]arg2[~]arg3 to a list of ptrs to the strings */
5560 static LPCWSTR *msi_service_args_to_vector(LPWSTR args, DWORD *numargs)
5561 {
5562 LPCWSTR *vector, *temp_vector;
5563 LPWSTR p, q;
5564 DWORD sep_len;
5565
5566 static const WCHAR separator[] = {'[','~',']',0};
5567
5568 *numargs = 0;
5569 sep_len = sizeof(separator) / sizeof(WCHAR) - 1;
5570
5571 if (!args)
5572 return NULL;
5573
5574 vector = msi_alloc(sizeof(LPWSTR));
5575 if (!vector)
5576 return NULL;
5577
5578 p = args;
5579 do
5580 {
5581 (*numargs)++;
5582 vector[*numargs - 1] = p;
5583
5584 if ((q = strstrW(p, separator)))
5585 {
5586 *q = '\0';
5587
5588 temp_vector = msi_realloc(vector, (*numargs + 1) * sizeof(LPWSTR));
5589 if (!temp_vector)
5590 {
5591 msi_free(vector);
5592 return NULL;
5593 }
5594 vector = temp_vector;
5595
5596 p = q + sep_len;
5597 }
5598 } while (q);
5599
5600 return vector;
5601 }
5602
5603 static UINT ITERATE_StartService(MSIRECORD *rec, LPVOID param)
5604 {
5605 MSIPACKAGE *package = param;
5606 MSICOMPONENT *comp;
5607 MSIRECORD *uirow;
5608 SC_HANDLE scm = NULL, service = NULL;
5609 LPCWSTR component, *vector = NULL;
5610 LPWSTR name, args, display_name = NULL;
5611 DWORD event, numargs, len, wait, dummy;
5612 UINT r = ERROR_FUNCTION_FAILED;
5613 SERVICE_STATUS_PROCESS status;
5614 ULONGLONG start_time;
5615
5616 component = MSI_RecordGetString(rec, 6);
5617 comp = msi_get_loaded_component(package, component);
5618 if (!comp)
5619 return ERROR_SUCCESS;
5620
5621 comp->Action = msi_get_component_action( package, comp );
5622 if (comp->Action != INSTALLSTATE_LOCAL)
5623 {
5624 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
5625 return ERROR_SUCCESS;
5626 }
5627
5628 deformat_string(package, MSI_RecordGetString(rec, 2), &name);
5629 deformat_string(package, MSI_RecordGetString(rec, 4), &args);
5630 event = MSI_RecordGetInteger(rec, 3);
5631 wait = MSI_RecordGetInteger(rec, 5);
5632
5633 if (!(event & msidbServiceControlEventStart))
5634 {
5635 r = ERROR_SUCCESS;
5636 goto done;
5637 }
5638
5639 scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
5640 if (!scm)
5641 {
5642 ERR("Failed to open the service control manager\n");
5643 goto done;
5644 }
5645
5646 len = 0;
5647 if (!GetServiceDisplayNameW( scm, name, NULL, &len ) &&
5648 GetLastError() == ERROR_INSUFFICIENT_BUFFER)
5649 {
5650 if ((display_name = msi_alloc( ++len * sizeof(WCHAR ))))
5651 GetServiceDisplayNameW( scm, name, display_name, &len );
5652 }
5653
5654 service = OpenServiceW(scm, name, SERVICE_START|SERVICE_QUERY_STATUS);
5655 if (!service)
5656 {
5657 ERR("Failed to open service %s (%u)\n", debugstr_w(name), GetLastError());
5658 goto done;
5659 }
5660
5661 vector = msi_service_args_to_vector(args, &numargs);
5662
5663 if (!StartServiceW(service, numargs, vector) &&
5664 GetLastError() != ERROR_SERVICE_ALREADY_RUNNING)
5665 {
5666 ERR("Failed to start service %s (%u)\n", debugstr_w(name), GetLastError());
5667 goto done;
5668 }
5669
5670 r = ERROR_SUCCESS;
5671 if (wait)
5672 {
5673 /* wait for at most 30 seconds for the service to be up and running */
5674 if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO,
5675 (BYTE *)&status, sizeof(SERVICE_STATUS_PROCESS), &dummy))
5676 {
5677 TRACE("failed to query service status (%u)\n", GetLastError());
5678 goto done;
5679 }
5680 start_time = GetTickCount64();
5681 while (status.dwCurrentState == SERVICE_START_PENDING)
5682 {
5683 if (GetTickCount64() - start_time > 30000) break;
5684 Sleep(1000);
5685 if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO,
5686 (BYTE *)&status, sizeof(SERVICE_STATUS_PROCESS), &dummy))
5687 {
5688 TRACE("failed to query service status (%u)\n", GetLastError());
5689 goto done;
5690 }
5691 }
5692 if (status.dwCurrentState != SERVICE_RUNNING)
5693 {
5694 WARN("service failed to start %u\n", status.dwCurrentState);
5695 r = ERROR_FUNCTION_FAILED;
5696 }
5697 }
5698
5699 done:
5700 uirow = MSI_CreateRecord( 2 );
5701 MSI_RecordSetStringW( uirow, 1, display_name );
5702 MSI_RecordSetStringW( uirow, 2, name );
5703 msi_ui_actiondata( package, szStartServices, uirow );
5704 msiobj_release( &uirow->hdr );
5705
5706 CloseServiceHandle(service);
5707 CloseServiceHandle(scm);
5708
5709 msi_free(name);
5710 msi_free(args);
5711 msi_free(vector);
5712 msi_free(display_name);
5713 return r;
5714 }
5715
5716 static UINT ACTION_StartServices( MSIPACKAGE *package )
5717 {
5718 static const WCHAR query[] = {
5719 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5720 'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0};
5721 MSIQUERY *view;
5722 UINT rc;
5723
5724 rc = MSI_DatabaseOpenViewW(package->db, query, &view);
5725 if (rc != ERROR_SUCCESS)
5726 return ERROR_SUCCESS;
5727
5728 rc = MSI_IterateRecords(view, NULL, ITERATE_StartService, package);
5729 msiobj_release(&view->hdr);
5730 return rc;
5731 }
5732
5733 static BOOL stop_service_dependents(SC_HANDLE scm, SC_HANDLE service)
5734 {
5735 DWORD i, needed, count;
5736 ENUM_SERVICE_STATUSW *dependencies;
5737 SERVICE_STATUS ss;
5738 SC_HANDLE depserv;
5739
5740 if (EnumDependentServicesW(service, SERVICE_ACTIVE, NULL,
5741 0, &needed, &count))
5742 return TRUE;
5743
5744 if (GetLastError() != ERROR_MORE_DATA)
5745 return FALSE;
5746
5747 dependencies = msi_alloc(needed);
5748 if (!dependencies)
5749 return FALSE;
5750
5751 if (!EnumDependentServicesW(service, SERVICE_ACTIVE, dependencies,
5752 needed, &needed, &count))
5753 goto error;
5754
5755 for (i = 0; i < count; i++)
5756 {
5757 depserv = OpenServiceW(scm, dependencies[i].lpServiceName,
5758 SERVICE_STOP | SERVICE_QUERY_STATUS);
5759 if (!depserv)
5760 goto error;
5761
5762 if (!ControlService(depserv, SERVICE_CONTROL_STOP, &ss))
5763 goto error;
5764 }
5765
5766 return TRUE;
5767
5768 error:
5769 msi_free(dependencies);
5770 return FALSE;
5771 }
5772
5773 static UINT stop_service( LPCWSTR name )
5774 {
5775 SC_HANDLE scm = NULL, service = NULL;
5776 SERVICE_STATUS status;
5777 SERVICE_STATUS_PROCESS ssp;
5778 DWORD needed;
5779
5780 scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);
5781 if (!scm)
5782 {
5783 WARN("Failed to open the SCM: %d\n", GetLastError());
5784 goto done;
5785 }
5786
5787 service = OpenServiceW(scm, name,
5788 SERVICE_STOP |
5789 SERVICE_QUERY_STATUS |
5790 SERVICE_ENUMERATE_DEPENDENTS);
5791 if (!service)
5792 {
5793 WARN("Failed to open service (%s): %d\n", debugstr_w(name), GetLastError());
5794 goto done;
5795 }
5796
5797 if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp,
5798 sizeof(SERVICE_STATUS_PROCESS), &needed))
5799 {
5800 WARN("Failed to query service status (%s): %d\n", debugstr_w(name), GetLastError());
5801 goto done;
5802 }
5803
5804 if (ssp.dwCurrentState == SERVICE_STOPPED)
5805 goto done;
5806
5807 stop_service_dependents(scm, service);
5808
5809 if (!ControlService(service, SERVICE_CONTROL_STOP, &status))
5810 WARN("Failed to stop service (%s): %d\n", debugstr_w(name), GetLastError());
5811
5812 done:
5813 CloseServiceHandle(service);
5814 CloseServiceHandle(scm);
5815
5816 return ERROR_SUCCESS;
5817 }
5818
5819 static UINT ITERATE_StopService( MSIRECORD *rec, LPVOID param )
5820 {
5821 MSIPACKAGE *package = param;
5822 MSICOMPONENT *comp;
5823 MSIRECORD *uirow;
5824 LPCWSTR component;
5825 LPWSTR name = NULL, display_name = NULL;
5826 DWORD event, len;
5827 SC_HANDLE scm;
5828
5829 event = MSI_RecordGetInteger( rec, 3 );
5830 if (!(event & msidbServiceControlEventStop))
5831 return ERROR_SUCCESS;
5832
5833 component = MSI_RecordGetString( rec, 6 );
5834 comp = msi_get_loaded_component( package, component );
5835 if (!comp)
5836 return ERROR_SUCCESS;
5837
5838 comp->Action = msi_get_component_action( package, comp );
5839 if (comp->Action != INSTALLSTATE_ABSENT)
5840 {
5841 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
5842 return ERROR_SUCCESS;
5843 }
5844
5845 scm = OpenSCManagerW( NULL, NULL, SC_MANAGER_CONNECT );
5846 if (!scm)
5847 {
5848 ERR("Failed to open the service control manager\n");
5849 goto done;
5850 }
5851
5852 len = 0;
5853 if (!GetServiceDisplayNameW( scm, name, NULL, &len ) &&
5854 GetLastError() == ERROR_INSUFFICIENT_BUFFER)
5855 {
5856 if ((display_name = msi_alloc( ++len * sizeof(WCHAR ))))
5857 GetServiceDisplayNameW( scm, name, display_name, &len );
5858 }
5859 CloseServiceHandle( scm );
5860
5861 deformat_string( package, MSI_RecordGetString( rec, 2 ), &name );
5862 stop_service( name );
5863
5864 done:
5865 uirow = MSI_CreateRecord( 2 );
5866 MSI_RecordSetStringW( uirow, 1, display_name );
5867 MSI_RecordSetStringW( uirow, 2, name );
5868 msi_ui_actiondata( package, szStopServices, uirow );
5869 msiobj_release( &uirow->hdr );
5870
5871 msi_free( name );
5872 msi_free( display_name );
5873 return ERROR_SUCCESS;
5874 }
5875
5876 static UINT ACTION_StopServices( MSIPACKAGE *package )
5877 {
5878 static const WCHAR query[] = {
5879 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5880 'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0};
5881 MSIQUERY *view;
5882 UINT rc;
5883
5884 rc = MSI_DatabaseOpenViewW(package->db, query, &view);
5885 if (rc != ERROR_SUCCESS)
5886 return ERROR_SUCCESS;
5887
5888 rc = MSI_IterateRecords(view, NULL, ITERATE_StopService, package);
5889 msiobj_release(&view->hdr);
5890 return rc;
5891 }
5892
5893 static UINT ITERATE_DeleteService( MSIRECORD *rec, LPVOID param )
5894 {
5895 MSIPACKAGE *package = param;
5896 MSICOMPONENT *comp;
5897 MSIRECORD *uirow;
5898 LPCWSTR component;
5899 LPWSTR name = NULL, display_name = NULL;
5900 DWORD event, len;
5901 SC_HANDLE scm = NULL, service = NULL;
5902
5903 event = MSI_RecordGetInteger( rec, 3 );
5904 if (!(event & msidbServiceControlEventDelete))
5905 return ERROR_SUCCESS;
5906
5907 component = MSI_RecordGetString(rec, 6);
5908 comp = msi_get_loaded_component(package, component);
5909 if (!comp)
5910 return ERROR_SUCCESS;
5911
5912 comp->Action = msi_get_component_action( package, comp );
5913 if (comp->Action != INSTALLSTATE_ABSENT)
5914 {
5915 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
5916 return ERROR_SUCCESS;
5917 }
5918
5919 deformat_string( package, MSI_RecordGetString(rec, 2), &name );
5920 stop_service( name );
5921
5922 scm = OpenSCManagerW( NULL, NULL, SC_MANAGER_ALL_ACCESS );
5923 if (!scm)
5924 {
5925 WARN("Failed to open the SCM: %d\n", GetLastError());
5926 goto done;
5927 }
5928
5929 len = 0;
5930 if (!GetServiceDisplayNameW( scm, name, NULL, &len ) &&
5931 GetLastError() == ERROR_INSUFFICIENT_BUFFER)
5932 {
5933 if ((display_name = msi_alloc( ++len * sizeof(WCHAR ))))
5934 GetServiceDisplayNameW( scm, name, display_name, &len );
5935 }
5936
5937 service = OpenServiceW( scm, name, DELETE );
5938 if (!service)
5939 {
5940 WARN("Failed to open service (%s): %u\n", debugstr_w(name), GetLastError());
5941 goto done;
5942 }
5943
5944 if (!DeleteService( service ))
5945 WARN("Failed to delete service (%s): %u\n", debugstr_w(name), GetLastError());
5946
5947 done:
5948 uirow = MSI_CreateRecord( 2 );
5949 MSI_RecordSetStringW( uirow, 1, display_name );
5950 MSI_RecordSetStringW( uirow, 2, name );
5951 msi_ui_actiondata( package, szDeleteServices, uirow );
5952 msiobj_release( &uirow->hdr );
5953
5954 CloseServiceHandle( service );
5955 CloseServiceHandle( scm );
5956 msi_free( name );
5957 msi_free( display_name );
5958
5959 return ERROR_SUCCESS;
5960 }
5961
5962 static UINT ACTION_DeleteServices( MSIPACKAGE *package )
5963 {
5964 static const WCHAR query[] = {
5965 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5966 'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0};
5967 MSIQUERY *view;
5968 UINT rc;
5969
5970 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
5971 if (rc != ERROR_SUCCESS)
5972 return ERROR_SUCCESS;
5973
5974 rc = MSI_IterateRecords( view, NULL, ITERATE_DeleteService, package );
5975 msiobj_release( &view->hdr );
5976 return rc;
5977 }
5978
5979 static UINT ITERATE_InstallODBCDriver( MSIRECORD *rec, LPVOID param )
5980 {
5981 MSIPACKAGE *package = param;
5982 LPWSTR driver, driver_path, ptr;
5983 WCHAR outpath[MAX_PATH];
5984 MSIFILE *driver_file = NULL, *setup_file = NULL;
5985 MSICOMPONENT *comp;
5986 MSIRECORD *uirow;
5987 LPCWSTR desc, file_key, component;
5988 DWORD len, usage;
5989 UINT r = ERROR_SUCCESS;
5990
5991 static const WCHAR driver_fmt[] = {
5992 'D','r','i','v','e','r','=','%','s',0};
5993 static const WCHAR setup_fmt[] = {
5994 'S','e','t','u','p','=','%','s',0};
5995 static const WCHAR usage_fmt[] = {
5996 'F','i','l','e','U','s','a','g','e','=','1',0};
5997
5998 component = MSI_RecordGetString( rec, 2 );
5999 comp = msi_get_loaded_component( package, component );
6000 if (!comp)
6001 return ERROR_SUCCESS;
6002
6003 comp->Action = msi_get_component_action( package, comp );
6004 if (comp->Action != INSTALLSTATE_LOCAL)
6005 {
6006 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
6007 return ERROR_SUCCESS;
6008 }
6009 desc = MSI_RecordGetString(rec, 3);
6010
6011 file_key = MSI_RecordGetString( rec, 4 );
6012 if (file_key) driver_file = msi_get_loaded_file( package, file_key );
6013
6014 file_key = MSI_RecordGetString( rec, 5 );
6015 if (file_key) setup_file = msi_get_loaded_file( package, file_key );
6016
6017 if (!driver_file)
6018 {
6019 ERR("ODBC Driver entry not found!\n");
6020 return ERROR_FUNCTION_FAILED;
6021 }
6022
6023 len = lstrlenW(desc) + lstrlenW(driver_fmt) + lstrlenW(driver_file->FileName);
6024 if (setup_file)
6025 len += lstrlenW(setup_fmt) + lstrlenW(setup_file->FileName);
6026 len += lstrlenW(usage_fmt) + 2; /* \0\0 */
6027
6028 driver = msi_alloc(len * sizeof(WCHAR));
6029 if (!driver)
6030 return ERROR_OUTOFMEMORY;
6031
6032 ptr = driver;
6033 lstrcpyW(ptr, desc);
6034 ptr += lstrlenW(ptr) + 1;
6035
6036 len = sprintfW(ptr, driver_fmt, driver_file->FileName);
6037 ptr += len + 1;
6038
6039 if (setup_file)
6040 {
6041 len = sprintfW(ptr, setup_fmt, setup_file->FileName);
6042 ptr += len + 1;
6043 }
6044
6045 lstrcpyW(ptr, usage_fmt);
6046 ptr += lstrlenW(ptr) + 1;
6047 *ptr = '\0';
6048
6049 driver_path = strdupW(driver_file->TargetPath);
6050 ptr = strrchrW(driver_path, '\\');
6051 if (ptr) *ptr = '\0';
6052
6053 if (!SQLInstallDriverExW(driver, driver_path, outpath, MAX_PATH,
6054 NULL, ODBC_INSTALL_COMPLETE, &usage))
6055 {
6056 ERR("Failed to install SQL driver!\n");
6057 r = ERROR_FUNCTION_FAILED;
6058 }
6059
6060 uirow = MSI_CreateRecord( 5 );
6061 MSI_RecordSetStringW( uirow, 1, desc );
6062 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6063 MSI_RecordSetStringW( uirow, 3, driver_file->Component->Directory );
6064 msi_ui_actiondata( package, szInstallODBC, uirow );
6065 msiobj_release( &uirow->hdr );
6066
6067 msi_free(driver);
6068 msi_free(driver_path);
6069
6070 return r;
6071 }
6072
6073 static UINT ITERATE_InstallODBCTranslator( MSIRECORD *rec, LPVOID param )
6074 {
6075 MSIPACKAGE *package = param;
6076 LPWSTR translator, translator_path, ptr;
6077 WCHAR outpath[MAX_PATH];
6078 MSIFILE *translator_file = NULL, *setup_file = NULL;
6079 MSICOMPONENT *comp;
6080 MSIRECORD *uirow;
6081 LPCWSTR desc, file_key, component;
6082 DWORD len, usage;
6083 UINT r = ERROR_SUCCESS;
6084
6085 static const WCHAR translator_fmt[] = {
6086 'T','r','a','n','s','l','a','t','o','r','=','%','s',0};
6087 static const WCHAR setup_fmt[] = {
6088 'S','e','t','u','p','=','%','s',0};
6089
6090 component = MSI_RecordGetString( rec, 2 );
6091 comp = msi_get_loaded_component( package, component );
6092 if (!comp)
6093 return ERROR_SUCCESS;
6094
6095 comp->Action = msi_get_component_action( package, comp );
6096 if (comp->Action != INSTALLSTATE_LOCAL)
6097 {
6098 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
6099 return ERROR_SUCCESS;
6100 }
6101 desc = MSI_RecordGetString(rec, 3);
6102
6103 file_key = MSI_RecordGetString( rec, 4 );
6104 if (file_key) translator_file = msi_get_loaded_file( package, file_key );
6105
6106 file_key = MSI_RecordGetString( rec, 5 );
6107 if (file_key) setup_file = msi_get_loaded_file( package, file_key );
6108
6109 if (!translator_file)
6110 {
6111 ERR("ODBC Translator entry not found!\n");
6112 return ERROR_FUNCTION_FAILED;
6113 }
6114
6115 len = lstrlenW(desc) + lstrlenW(translator_fmt) + lstrlenW(translator_file->FileName) + 2; /* \0\0 */
6116 if (setup_file)
6117 len += lstrlenW(setup_fmt) + lstrlenW(setup_file->FileName);
6118
6119 translator = msi_alloc(len * sizeof(WCHAR));
6120 if (!translator)
6121 return ERROR_OUTOFMEMORY;
6122
6123 ptr = translator;
6124 lstrcpyW(ptr, desc);
6125 ptr += lstrlenW(ptr) + 1;
6126
6127 len = sprintfW(ptr, translator_fmt, translator_file->FileName);
6128 ptr += len + 1;
6129
6130 if (setup_file)
6131 {
6132 len = sprintfW(ptr, setup_fmt, setup_file->FileName);
6133 ptr += len + 1;
6134 }
6135 *ptr = '\0';
6136
6137 translator_path = strdupW(translator_file->TargetPath);
6138 ptr = strrchrW(translator_path, '\\');
6139 if (ptr) *ptr = '\0';
6140
6141 if (!SQLInstallTranslatorExW(translator, translator_path, outpath, MAX_PATH,
6142 NULL, ODBC_INSTALL_COMPLETE, &usage))
6143 {
6144 ERR("Failed to install SQL translator!\n");
6145 r = ERROR_FUNCTION_FAILED;
6146 }
6147
6148 uirow = MSI_CreateRecord( 5 );
6149 MSI_RecordSetStringW( uirow, 1, desc );
6150 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6151 MSI_RecordSetStringW( uirow, 3, translator_file->Component->Directory );
6152 msi_ui_actiondata( package, szInstallODBC, uirow );
6153 msiobj_release( &uirow->hdr );
6154
6155 msi_free(translator);
6156 msi_free(translator_path);
6157
6158 return r;
6159 }
6160
6161 static UINT ITERATE_InstallODBCDataSource( MSIRECORD *rec, LPVOID param )
6162 {
6163 MSIPACKAGE *package = param;
6164 MSICOMPONENT *comp;
6165 LPWSTR attrs;
6166 LPCWSTR desc, driver, component;
6167 WORD request = ODBC_ADD_SYS_DSN;
6168 INT registration;
6169 DWORD len;
6170 UINT r = ERROR_SUCCESS;
6171 MSIRECORD *uirow;
6172
6173 static const WCHAR attrs_fmt[] = {
6174 'D','S','N','=','%','s',0 };
6175
6176 component = MSI_RecordGetString( rec, 2 );
6177 comp = msi_get_loaded_component( package, component );
6178 if (!comp)
6179 return ERROR_SUCCESS;
6180
6181 comp->Action = msi_get_component_action( package, comp );
6182 if (comp->Action != INSTALLSTATE_LOCAL)
6183 {
6184 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
6185 return ERROR_SUCCESS;
6186 }
6187
6188 desc = MSI_RecordGetString(rec, 3);
6189 driver = MSI_RecordGetString(rec, 4);
6190 registration = MSI_RecordGetInteger(rec, 5);
6191
6192 if (registration == msidbODBCDataSourceRegistrationPerMachine) request = ODBC_ADD_SYS_DSN;
6193 else if (registration == msidbODBCDataSourceRegistrationPerUser) request = ODBC_ADD_DSN;
6194
6195 len = lstrlenW(attrs_fmt) + lstrlenW(desc) + 2; /* \0\0 */
6196 attrs = msi_alloc(len * sizeof(WCHAR));
6197 if (!attrs)
6198 return ERROR_OUTOFMEMORY;
6199
6200 len = sprintfW(attrs, attrs_fmt, desc);
6201 attrs[len + 1] = 0;
6202
6203 if (!SQLConfigDataSourceW(NULL, request, driver, attrs))
6204 {
6205 ERR("Failed to install SQL data source!\n");
6206 r = ERROR_FUNCTION_FAILED;
6207 }
6208
6209 uirow = MSI_CreateRecord( 5 );
6210 MSI_RecordSetStringW( uirow, 1, desc );
6211 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6212 MSI_RecordSetInteger( uirow, 3, request );
6213 msi_ui_actiondata( package, szInstallODBC, uirow );
6214 msiobj_release( &uirow->hdr );
6215
6216 msi_free(attrs);
6217
6218 return r;
6219 }
6220
6221 static UINT ACTION_InstallODBC( MSIPACKAGE *package )
6222 {
6223 static const WCHAR driver_query[] = {
6224 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6225 'O','D','B','C','D','r','i','v','e','r',0};
6226 static const WCHAR translator_query[] = {
6227 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6228 'O','D','B','C','T','r','a','n','s','l','a','t','o','r',0};
6229 static const WCHAR source_query[] = {
6230 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6231 'O','D','B','C','D','a','t','a','S','o','u','r','c','e',0};
6232 MSIQUERY *view;
6233 UINT rc;
6234
6235 rc = MSI_DatabaseOpenViewW(package->db, driver_query, &view);
6236 if (rc == ERROR_SUCCESS)
6237 {
6238 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCDriver, package);
6239 msiobj_release(&view->hdr);
6240 if (rc != ERROR_SUCCESS)
6241 return rc;
6242 }
6243 rc = MSI_DatabaseOpenViewW(package->db, translator_query, &view);
6244 if (rc == ERROR_SUCCESS)
6245 {
6246 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCTranslator, package);
6247 msiobj_release(&view->hdr);
6248 if (rc != ERROR_SUCCESS)
6249 return rc;
6250 }
6251 rc = MSI_DatabaseOpenViewW(package->db, source_query, &view);
6252 if (rc == ERROR_SUCCESS)
6253 {
6254 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCDataSource, package);
6255 msiobj_release(&view->hdr);
6256 if (rc != ERROR_SUCCESS)
6257 return rc;
6258 }
6259 return ERROR_SUCCESS;
6260 }
6261
6262 static UINT ITERATE_RemoveODBCDriver( MSIRECORD *rec, LPVOID param )
6263 {
6264 MSIPACKAGE *package = param;
6265 MSICOMPONENT *comp;
6266 MSIRECORD *uirow;
6267 DWORD usage;
6268 LPCWSTR desc, component;
6269
6270 component = MSI_RecordGetString( rec, 2 );
6271 comp = msi_get_loaded_component( package, component );
6272 if (!comp)
6273 return ERROR_SUCCESS;
6274
6275 comp->Action = msi_get_component_action( package, comp );
6276 if (comp->Action != INSTALLSTATE_ABSENT)
6277 {
6278 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
6279 return ERROR_SUCCESS;
6280 }
6281
6282 desc = MSI_RecordGetString( rec, 3 );
6283 if (!SQLRemoveDriverW( desc, FALSE, &usage ))
6284 {
6285 WARN("Failed to remove ODBC driver\n");
6286 }
6287 else if (!usage)
6288 {
6289 FIXME("Usage count reached 0\n");
6290 }
6291
6292 uirow = MSI_CreateRecord( 2 );
6293 MSI_RecordSetStringW( uirow, 1, desc );
6294 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6295 msi_ui_actiondata( package, szRemoveODBC, uirow );
6296 msiobj_release( &uirow->hdr );
6297
6298 return ERROR_SUCCESS;
6299 }
6300
6301 static UINT ITERATE_RemoveODBCTranslator( MSIRECORD *rec, LPVOID param )
6302 {
6303 MSIPACKAGE *package = param;
6304 MSICOMPONENT *comp;
6305 MSIRECORD *uirow;
6306 DWORD usage;
6307 LPCWSTR desc, component;
6308
6309 component = MSI_RecordGetString( rec, 2 );
6310 comp = msi_get_loaded_component( package, component );
6311 if (!comp)
6312 return ERROR_SUCCESS;
6313
6314 comp->Action = msi_get_component_action( package, comp );
6315 if (comp->Action != INSTALLSTATE_ABSENT)
6316 {
6317 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
6318 return ERROR_SUCCESS;
6319 }
6320
6321 desc = MSI_RecordGetString( rec, 3 );
6322 if (!SQLRemoveTranslatorW( desc, &usage ))
6323 {
6324 WARN("Failed to remove ODBC translator\n");
6325 }
6326 else if (!usage)
6327 {
6328 FIXME("Usage count reached 0\n");
6329 }
6330
6331 uirow = MSI_CreateRecord( 2 );
6332 MSI_RecordSetStringW( uirow, 1, desc );
6333 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6334 msi_ui_actiondata( package, szRemoveODBC, uirow );
6335 msiobj_release( &uirow->hdr );
6336
6337 return ERROR_SUCCESS;
6338 }
6339
6340 static UINT ITERATE_RemoveODBCDataSource( MSIRECORD *rec, LPVOID param )
6341 {
6342 MSIPACKAGE *package = param;
6343 MSICOMPONENT *comp;
6344 MSIRECORD *uirow;
6345 LPWSTR attrs;
6346 LPCWSTR desc, driver, component;
6347 WORD request = ODBC_REMOVE_SYS_DSN;
6348 INT registration;
6349 DWORD len;
6350
6351 static const WCHAR attrs_fmt[] = {
6352 'D','S','N','=','%','s',0 };
6353
6354 component = MSI_RecordGetString( rec, 2 );
6355 comp = msi_get_loaded_component( package, component );
6356 if (!comp)
6357 return ERROR_SUCCESS;
6358
6359 comp->Action = msi_get_component_action( package, comp );
6360 if (comp->Action != INSTALLSTATE_ABSENT)
6361 {
6362 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
6363 return ERROR_SUCCESS;
6364 }
6365
6366 desc = MSI_RecordGetString( rec, 3 );
6367 driver = MSI_RecordGetString( rec, 4 );
6368 registration = MSI_RecordGetInteger( rec, 5 );
6369
6370 if (registration == msidbODBCDataSourceRegistrationPerMachine) request = ODBC_REMOVE_SYS_DSN;
6371 else if (registration == msidbODBCDataSourceRegistrationPerUser) request = ODBC_REMOVE_DSN;
6372
6373 len = strlenW( attrs_fmt ) + strlenW( desc ) + 2; /* \0\0 */
6374 attrs = msi_alloc( len * sizeof(WCHAR) );
6375 if (!attrs)
6376 return ERROR_OUTOFMEMORY;
6377
6378 FIXME("Use ODBCSourceAttribute table\n");
6379
6380 len = sprintfW( attrs, attrs_fmt, desc );
6381 attrs[len + 1] = 0;
6382
6383 if (!SQLConfigDataSourceW( NULL, request, driver, attrs ))
6384 {
6385 WARN("Failed to remove ODBC data source\n");
6386 }
6387 msi_free( attrs );
6388
6389 uirow = MSI_CreateRecord( 3 );
6390 MSI_RecordSetStringW( uirow, 1, desc );
6391 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6392 MSI_RecordSetInteger( uirow, 3, request );
6393 msi_ui_actiondata( package, szRemoveODBC, uirow );
6394 msiobj_release( &uirow->hdr );
6395
6396 return ERROR_SUCCESS;
6397 }
6398
6399 static UINT ACTION_RemoveODBC( MSIPACKAGE *package )
6400 {
6401 static const WCHAR driver_query[] = {
6402 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6403 'O','D','B','C','D','r','i','v','e','r',0};
6404 static const WCHAR translator_query[] = {
6405 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6406 'O','D','B','C','T','r','a','n','s','l','a','t','o','r',0};
6407 static const WCHAR source_query[] = {
6408 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6409 'O','D','B','C','D','a','t','a','S','o','u','r','c','e',0};
6410 MSIQUERY *view;
6411 UINT rc;
6412
6413 rc = MSI_DatabaseOpenViewW( package->db, driver_query, &view );
6414 if (rc == ERROR_SUCCESS)
6415 {
6416 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveODBCDriver, package );
6417 msiobj_release( &view->hdr );
6418 if (rc != ERROR_SUCCESS)
6419 return rc;
6420 }
6421 rc = MSI_DatabaseOpenViewW( package->db, translator_query, &view );
6422 if (rc == ERROR_SUCCESS)
6423 {
6424 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveODBCTranslator, package );
6425 msiobj_release( &view->hdr );
6426 if (rc != ERROR_SUCCESS)
6427 return rc;
6428 }
6429 rc = MSI_DatabaseOpenViewW( package->db, source_query, &view );
6430 if (rc == ERROR_SUCCESS)
6431 {
6432 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveODBCDataSource, package );
6433 msiobj_release( &view->hdr );
6434 if (rc != ERROR_SUCCESS)
6435 return rc;
6436 }
6437 return ERROR_SUCCESS;
6438 }
6439
6440 #define ENV_ACT_SETALWAYS 0x1
6441 #define ENV_ACT_SETABSENT 0x2
6442 #define ENV_ACT_REMOVE 0x4
6443 #define ENV_ACT_REMOVEMATCH 0x8
6444
6445 #define ENV_MOD_MACHINE 0x20000000
6446 #define ENV_MOD_APPEND 0x40000000
6447 #define ENV_MOD_PREFIX 0x80000000
6448 #define ENV_MOD_MASK 0xC0000000
6449
6450 #define check_flag_combo(x, y) ((x) & ~(y)) == (y)
6451
6452 static UINT env_parse_flags( LPCWSTR *name, LPCWSTR *value, DWORD *flags )
6453 {
6454 LPCWSTR cptr = *name;
6455
6456 static const WCHAR prefix[] = {'[','~',']',0};
6457 static const int prefix_len = 3;
6458
6459 *flags = 0;
6460 while (*cptr)
6461 {
6462 if (*cptr == '=')
6463 *flags |= ENV_ACT_SETALWAYS;
6464 else if (*cptr == '+')
6465 *flags |= ENV_ACT_SETABSENT;
6466 else if (*cptr == '-')
6467 *flags |= ENV_ACT_REMOVE;
6468 else if (*cptr == '!')
6469 *flags |= ENV_ACT_REMOVEMATCH;
6470 else if (*cptr == '*')
6471 *flags |= ENV_MOD_MACHINE;
6472 else
6473 break;
6474
6475 cptr++;
6476 (*name)++;
6477 }
6478
6479 if (!*cptr)
6480 {
6481 ERR("Missing environment variable\n");
6482 return ERROR_FUNCTION_FAILED;
6483 }
6484
6485 if (*value)
6486 {
6487 LPCWSTR ptr = *value;
6488 if (!strncmpW(ptr, prefix, prefix_len))
6489 {
6490 if (ptr[prefix_len] == szSemiColon[0])
6491 {
6492 *flags |= ENV_MOD_APPEND;
6493 *value += lstrlenW(prefix);
6494 }
6495 else
6496 {
6497 *value = NULL;
6498 }
6499 }
6500 else if (lstrlenW(*value) >= prefix_len)
6501 {
6502 ptr += lstrlenW(ptr) - prefix_len;
6503 if (!strcmpW( ptr, prefix ))
6504 {
6505 if ((ptr-1) > *value && *(ptr-1) == szSemiColon[0])
6506 {
6507 *flags |= ENV_MOD_PREFIX;
6508 /* the "[~]" will be removed by deformat_string */;
6509 }
6510 else
6511 {
6512 *value = NULL;
6513 }
6514 }
6515 }
6516 }
6517
6518 if (check_flag_combo(*flags, ENV_ACT_SETALWAYS | ENV_ACT_SETABSENT) ||
6519 check_flag_combo(*flags, ENV_ACT_REMOVEMATCH | ENV_ACT_SETABSENT) ||
6520 check_flag_combo(*flags, ENV_ACT_REMOVEMATCH | ENV_ACT_SETALWAYS) ||
6521 check_flag_combo(*flags, ENV_ACT_SETABSENT | ENV_MOD_MASK))
6522 {
6523 ERR("Invalid flags: %08x\n", *flags);
6524 return ERROR_FUNCTION_FAILED;
6525 }
6526
6527 if (!*flags)
6528 *flags = ENV_ACT_SETALWAYS | ENV_ACT_REMOVE;
6529
6530 return ERROR_SUCCESS;
6531 }
6532
6533 static UINT open_env_key( DWORD flags, HKEY *key )
6534 {
6535 static const WCHAR user_env[] =
6536 {'E','n','v','i','r','o','n','m','e','n','t',0};
6537 static const WCHAR machine_env[] =
6538 {'S','y','s','t','e','m','\\',
6539 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
6540 'C','o','n','t','r','o','l','\\',
6541 'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
6542 'E','n','v','i','r','o','n','m','e','n','t',0};
6543 const WCHAR *env;
6544 HKEY root;
6545 LONG res;
6546
6547 if (flags & ENV_MOD_MACHINE)
6548 {
6549 env = machine_env;
6550 root = HKEY_LOCAL_MACHINE;
6551 }
6552 else
6553 {
6554 env = user_env;
6555 root = HKEY_CURRENT_USER;
6556 }
6557
6558 res = RegOpenKeyExW( root, env, 0, KEY_ALL_ACCESS, key );
6559 if (res != ERROR_SUCCESS)
6560 {
6561 WARN("Failed to open key %s (%d)\n", debugstr_w(env), res);
6562 return ERROR_FUNCTION_FAILED;
6563 }
6564
6565 return ERROR_SUCCESS;
6566 }
6567
6568 static UINT ITERATE_WriteEnvironmentString( MSIRECORD *rec, LPVOID param )
6569 {
6570 MSIPACKAGE *package = param;
6571 LPCWSTR name, value, component;
6572 LPWSTR data = NULL, newval = NULL, deformatted = NULL, ptr;
6573 DWORD flags, type, size;
6574 UINT res;
6575 HKEY env = NULL;
6576 MSICOMPONENT *comp;
6577 MSIRECORD *uirow;
6578 int action = 0;
6579
6580 component = MSI_RecordGetString(rec, 4);
6581 comp = msi_get_loaded_component(package, component);
6582 if (!comp)
6583 return ERROR_SUCCESS;
6584
6585 comp->Action = msi_get_component_action( package, comp );
6586 if (comp->Action != INSTALLSTATE_LOCAL)
6587 {
6588 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
6589 return ERROR_SUCCESS;
6590 }
6591 name = MSI_RecordGetString(rec, 2);
6592 value = MSI_RecordGetString(rec, 3);
6593
6594 TRACE("name %s value %s\n", debugstr_w(name), debugstr_w(value));
6595
6596 res = env_parse_flags(&name, &value, &flags);
6597 if (res != ERROR_SUCCESS || !value)
6598 goto done;
6599
6600 if (value && !deformat_string(package, value, &deformatted))
6601 {
6602 res = ERROR_OUTOFMEMORY;
6603 goto done;
6604 }
6605
6606 value = deformatted;
6607
6608 res = open_env_key( flags, &env );
6609 if (res != ERROR_SUCCESS)
6610 goto done;
6611
6612 if (flags & ENV_MOD_MACHINE)
6613 action |= 0x20000000;
6614
6615 size = 0;
6616 type = REG_SZ;
6617 res = RegQueryValueExW(env, name, NULL, &type, NULL, &size);
6618 if ((res != ERROR_SUCCESS && res != ERROR_FILE_NOT_FOUND) ||
6619 (res == ERROR_SUCCESS && type != REG_SZ && type != REG_EXPAND_SZ))
6620 goto done;
6621
6622 if ((res == ERROR_FILE_NOT_FOUND || !(flags & ENV_MOD_MASK)))
6623 {
6624 action = 0x2;
6625
6626 /* Nothing to do. */
6627 if (!value)
6628 {
6629 res = ERROR_SUCCESS;
6630 goto done;
6631 }
6632
6633 /* If we are appending but the string was empty, strip ; */
6634 if ((flags & ENV_MOD_APPEND) && (value[0] == szSemiColon[0])) value++;
6635
6636 size = (lstrlenW(value) + 1) * sizeof(WCHAR);
6637 newval = strdupW(value);
6638 if (!newval)
6639 {
6640 res = ERROR_OUTOFMEMORY;
6641 goto done;
6642 }
6643 }
6644 else
6645 {
6646 action = 0x1;
6647
6648 /* Contrary to MSDN, +-variable to [~];path works */
6649 if (flags & ENV_ACT_SETABSENT && !(flags & ENV_MOD_MASK))
6650 {
6651 res = ERROR_SUCCESS;
6652 goto done;
6653 }
6654
6655 data = msi_alloc(size);
6656 if (!data)
6657 {
6658 RegCloseKey(env);
6659 return ERROR_OUTOFMEMORY;
6660 }
6661
6662 res = RegQueryValueExW(env, name, NULL, &type, (LPVOID)data, &size);
6663 if (res != ERROR_SUCCESS)
6664 goto done;
6665
6666 if (flags & ENV_ACT_REMOVEMATCH && (!value || !strcmpW( data, value )))
6667 {
6668 action = 0x4;
6669 res = RegDeleteValueW(env, name);
6670 if (res != ERROR_SUCCESS)
6671 WARN("Failed to remove value %s (%d)\n", debugstr_w(name), res);
6672 goto done;
6673 }
6674
6675 size = (lstrlenW(data) + 1) * sizeof(WCHAR);
6676 if (flags & ENV_MOD_MASK)
6677 {
6678 DWORD mod_size;
6679 int multiplier = 0;
6680 if (flags & ENV_MOD_APPEND) multiplier++;
6681 if (flags & ENV_MOD_PREFIX) multiplier++;
6682 mod_size = lstrlenW(value) * multiplier;
6683 size += mod_size * sizeof(WCHAR);
6684 }
6685
6686 newval = msi_alloc(size);
6687 ptr = newval;
6688 if (!newval)
6689 {
6690 res = ERROR_OUTOFMEMORY;
6691 goto done;
6692 }
6693
6694 if (flags & ENV_MOD_PREFIX)
6695 {
6696 lstrcpyW(newval, value);
6697 ptr = newval + lstrlenW(value);
6698 action |= 0x80000000;
6699 }
6700
6701 lstrcpyW(ptr, data);
6702
6703 if (flags & ENV_MOD_APPEND)
6704 {
6705 lstrcatW(newval, value);
6706 action |= 0x40000000;
6707 }
6708 }
6709 TRACE("setting %s to %s\n", debugstr_w(name), debugstr_w(newval));
6710 res = RegSetValueExW(env, name, 0, type, (LPVOID)newval, size);
6711 if (res)
6712 {
6713 WARN("Failed to set %s to %s (%d)\n", debugstr_w(name), debugstr_w(newval), res);
6714 }
6715
6716 done:
6717 uirow = MSI_CreateRecord( 3 );
6718 MSI_RecordSetStringW( uirow, 1, name );
6719 MSI_RecordSetStringW( uirow, 2, newval );
6720 MSI_RecordSetInteger( uirow, 3, action );
6721 msi_ui_actiondata( package, szWriteEnvironmentStrings, uirow );
6722 msiobj_release( &uirow->hdr );
6723
6724 if (env) RegCloseKey(env);
6725 msi_free(deformatted);
6726 msi_free(data);
6727 msi_free(newval);
6728 return res;
6729 }
6730
6731 static UINT ACTION_WriteEnvironmentStrings( MSIPACKAGE *package )
6732 {
6733 static const WCHAR query[] = {
6734 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6735 '`','E','n','v','i','r','o','n','m','e','n','t','`',0};
6736 MSIQUERY *view;
6737 UINT rc;
6738
6739 rc = MSI_DatabaseOpenViewW(package->db, query, &view);
6740 if (rc != ERROR_SUCCESS)
6741 return ERROR_SUCCESS;
6742
6743 rc = MSI_IterateRecords(view, NULL, ITERATE_WriteEnvironmentString, package);
6744 msiobj_release(&view->hdr);
6745 return rc;
6746 }
6747
6748 static UINT ITERATE_RemoveEnvironmentString( MSIRECORD *rec, LPVOID param )
6749 {
6750 MSIPACKAGE *package = param;
6751 LPCWSTR name, value, component;
6752 LPWSTR deformatted = NULL;
6753 DWORD flags;
6754 HKEY env;
6755 MSICOMPONENT *comp;
6756 MSIRECORD *uirow;
6757 int action = 0;
6758 LONG res;
6759 UINT r;
6760
6761 component = MSI_RecordGetString( rec, 4 );
6762 comp = msi_get_loaded_component( package, component );
6763 if (!comp)
6764 return ERROR_SUCCESS;
6765
6766 comp->Action = msi_get_component_action( package, comp );
6767 if (comp->Action != INSTALLSTATE_ABSENT)
6768 {
6769 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
6770 return ERROR_SUCCESS;
6771 }
6772 name = MSI_RecordGetString( rec, 2 );
6773 value = MSI_RecordGetString( rec, 3 );
6774
6775 TRACE("name %s value %s\n", debugstr_w(name), debugstr_w(value));
6776
6777 r = env_parse_flags( &name, &value, &flags );
6778 if (r != ERROR_SUCCESS)
6779 return r;
6780
6781 if (!(flags & ENV_ACT_REMOVE))
6782 {
6783 TRACE("Environment variable %s not marked for removal\n", debugstr_w(name));
6784 return ERROR_SUCCESS;
6785 }
6786
6787 if (value && !deformat_string( package, value, &deformatted ))
6788 return ERROR_OUTOFMEMORY;
6789
6790 value = deformatted;
6791
6792 r = open_env_key( flags, &env );
6793 if (r != ERROR_SUCCESS)
6794 {
6795 r = ERROR_SUCCESS;
6796 goto done;
6797 }
6798
6799 if (flags & ENV_MOD_MACHINE)
6800 action |= 0x20000000;
6801
6802 TRACE("Removing %s\n", debugstr_w(name));
6803
6804 res = RegDeleteValueW( env, name );
6805 if (res != ERROR_SUCCESS)
6806 {
6807 WARN("Failed to delete value %s (%d)\n", debugstr_w(name), res);
6808 r = ERROR_SUCCESS;
6809 }
6810
6811 done:
6812 uirow = MSI_CreateRecord( 3 );
6813 MSI_RecordSetStringW( uirow, 1, name );
6814 MSI_RecordSetStringW( uirow, 2, value );
6815 MSI_RecordSetInteger( uirow, 3, action );
6816 msi_ui_actiondata( package, szRemoveEnvironmentStrings, uirow );
6817 msiobj_release( &uirow->hdr );
6818
6819 if (env) RegCloseKey( env );
6820 msi_free( deformatted );
6821 return r;
6822 }
6823
6824 static UINT ACTION_RemoveEnvironmentStrings( MSIPACKAGE *package )
6825 {
6826 static const WCHAR query[] = {
6827 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6828 '`','E','n','v','i','r','o','n','m','e','n','t','`',0};
6829 MSIQUERY *view;
6830 UINT rc;
6831
6832 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
6833 if (rc != ERROR_SUCCESS)
6834 return ERROR_SUCCESS;
6835
6836 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveEnvironmentString, package );
6837 msiobj_release( &view->hdr );
6838 return rc;
6839 }
6840
6841 UINT msi_validate_product_id( MSIPACKAGE *package )
6842 {
6843 LPWSTR key, template, id;
6844 UINT r = ERROR_SUCCESS;
6845
6846 id = msi_dup_property( package->db, szProductID );
6847 if (id)
6848 {
6849 msi_free( id );
6850 return ERROR_SUCCESS;
6851 }
6852 template = msi_dup_property( package->db, szPIDTemplate );
6853 key = msi_dup_property( package->db, szPIDKEY );
6854 if (key && template)
6855 {
6856 FIXME( "partial stub: template %s key %s\n", debugstr_w(template), debugstr_w(key) );
6857 r = msi_set_property( package->db, szProductID, key );
6858 }
6859 msi_free( template );
6860 msi_free( key );
6861 return r;
6862 }
6863
6864 static UINT ACTION_ValidateProductID( MSIPACKAGE *package )
6865 {
6866 return msi_validate_product_id( package );
6867 }
6868
6869 static UINT ACTION_ScheduleReboot( MSIPACKAGE *package )
6870 {
6871 TRACE("\n");
6872 package->need_reboot = 1;
6873 return ERROR_SUCCESS;
6874 }
6875
6876 static UINT ACTION_AllocateRegistrySpace( MSIPACKAGE *package )
6877 {
6878 static const WCHAR szAvailableFreeReg[] =
6879 {'A','V','A','I','L','A','B','L','E','F','R','E','E','R','E','G',0};
6880 MSIRECORD *uirow;
6881 int space = msi_get_property_int( package->db, szAvailableFreeReg, 0 );
6882
6883 TRACE("%p %d kilobytes\n", package, space);
6884
6885 uirow = MSI_CreateRecord( 1 );
6886 MSI_RecordSetInteger( uirow, 1, space );
6887 msi_ui_actiondata( package, szAllocateRegistrySpace, uirow );
6888 msiobj_release( &uirow->hdr );
6889
6890 return ERROR_SUCCESS;
6891 }
6892
6893 static UINT ACTION_DisableRollback( MSIPACKAGE *package )
6894 {
6895 TRACE("%p\n", package);
6896
6897 msi_set_property( package->db, szRollbackDisabled, szOne );
6898 return ERROR_SUCCESS;
6899 }
6900
6901 static UINT ACTION_InstallAdminPackage( MSIPACKAGE *package )
6902 {
6903 FIXME("%p\n", package);
6904 return ERROR_SUCCESS;
6905 }
6906
6907 static UINT ACTION_SetODBCFolders( MSIPACKAGE *package )
6908 {
6909 static const WCHAR driver_query[] = {
6910 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6911 'O','D','B','C','D','r','i','v','e','r',0};
6912 static const WCHAR translator_query[] = {
6913 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6914 'O','D','B','C','T','r','a','n','s','l','a','t','o','r',0};
6915 MSIQUERY *view;
6916 UINT r, count;
6917
6918 r = MSI_DatabaseOpenViewW( package->db, driver_query, &view );
6919 if (r == ERROR_SUCCESS)
6920 {
6921 count = 0;
6922 r = MSI_IterateRecords( view, &count, NULL, package );
6923 msiobj_release( &view->hdr );
6924 if (r != ERROR_SUCCESS)
6925 return r;
6926 if (count) FIXME("ignored %u rows in ODBCDriver table\n", count);
6927 }
6928 r = MSI_DatabaseOpenViewW( package->db, translator_query, &view );
6929 if (r == ERROR_SUCCESS)
6930 {
6931 count = 0;
6932 r = MSI_IterateRecords( view, &count, NULL, package );
6933 msiobj_release( &view->hdr );
6934 if (r != ERROR_SUCCESS)
6935 return r;
6936 if (count) FIXME("ignored %u rows in ODBCTranslator table\n", count);
6937 }
6938 return ERROR_SUCCESS;
6939 }
6940
6941 static UINT ITERATE_RemoveExistingProducts( MSIRECORD *rec, LPVOID param )
6942 {
6943 MSIPACKAGE *package = param;
6944 const WCHAR *property = MSI_RecordGetString( rec, 1 );
6945 WCHAR *value;
6946
6947 if ((value = msi_dup_property( package->db, property )))
6948 {
6949 FIXME("remove %s\n", debugstr_w(value));
6950 msi_free( value );
6951 }
6952 return ERROR_SUCCESS;
6953 }
6954
6955 static UINT ACTION_RemoveExistingProducts( MSIPACKAGE *package )
6956 {
6957 static const WCHAR query[] = {
6958 'S','E','L','E','C','T',' ','A','c','t','i','o','n','P','r','o','p','e','r','t','y',' ',
6959 'F','R','O','M',' ','U','p','g','r','a','d','e',0};
6960 MSIQUERY *view;
6961 UINT r;
6962
6963 r = MSI_DatabaseOpenViewW( package->db, query, &view );
6964 if (r == ERROR_SUCCESS)
6965 {
6966 r = MSI_IterateRecords( view, NULL, ITERATE_RemoveExistingProducts, package );
6967 msiobj_release( &view->hdr );
6968 if (r != ERROR_SUCCESS)
6969 return r;
6970 }
6971 return ERROR_SUCCESS;
6972 }
6973
6974 static UINT ITERATE_MigrateFeatureStates( MSIRECORD *rec, LPVOID param )
6975 {
6976 MSIPACKAGE *package = param;
6977 int attributes = MSI_RecordGetInteger( rec, 5 );
6978
6979 if (attributes & msidbUpgradeAttributesMigrateFeatures)
6980 {
6981 const WCHAR *upgrade_code = MSI_RecordGetString( rec, 1 );
6982 const WCHAR *version_min = MSI_RecordGetString( rec, 2 );
6983 const WCHAR *version_max = MSI_RecordGetString( rec, 3 );
6984 const WCHAR *language = MSI_RecordGetString( rec, 4 );
6985 HKEY hkey;
6986 UINT r;
6987
6988 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
6989 {
6990 r = MSIREG_OpenClassesUpgradeCodesKey( upgrade_code, &hkey, FALSE );
6991 if (r != ERROR_SUCCESS)
6992 return ERROR_SUCCESS;
6993 }
6994 else
6995 {
6996 r = MSIREG_OpenUserUpgradeCodesKey( upgrade_code, &hkey, FALSE );
6997 if (r != ERROR_SUCCESS)
6998 return ERROR_SUCCESS;
6999 }
7000 RegCloseKey( hkey );
7001
7002 FIXME("migrate feature states from %s version min %s version max %s language %s\n",
7003 debugstr_w(upgrade_code), debugstr_w(version_min),
7004 debugstr_w(version_max), debugstr_w(language));
7005 }
7006 return ERROR_SUCCESS;
7007 }
7008
7009 static UINT ACTION_MigrateFeatureStates( MSIPACKAGE *package )
7010 {
7011 static const WCHAR query[] = {
7012 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
7013 'U','p','g','r','a','d','e',0};
7014 MSIQUERY *view;
7015 UINT r;
7016
7017 if (msi_get_property_int( package->db, szInstalled, 0 ))
7018 {
7019 TRACE("product is installed, skipping action\n");
7020 return ERROR_SUCCESS;
7021 }
7022 if (msi_get_property_int( package->db, szPreselected, 0 ))
7023 {
7024 TRACE("Preselected property is set, not migrating feature states\n");
7025 return ERROR_SUCCESS;
7026 }
7027 r = MSI_DatabaseOpenViewW( package->db, query, &view );
7028 if (r == ERROR_SUCCESS)
7029 {
7030 r = MSI_IterateRecords( view, NULL, ITERATE_MigrateFeatureStates, package );
7031 msiobj_release( &view->hdr );
7032 if (r != ERROR_SUCCESS)
7033 return r;
7034 }
7035 return ERROR_SUCCESS;
7036 }
7037
7038 static void bind_image( const char *filename, const char *path )
7039 {
7040 if (!BindImageEx( 0, filename, path, NULL, NULL ))
7041 {
7042 WARN("failed to bind image %u\n", GetLastError());
7043 }
7044 }
7045
7046 static UINT ITERATE_BindImage( MSIRECORD *rec, LPVOID param )
7047 {
7048 UINT i;
7049 MSIFILE *file;
7050 MSIPACKAGE *package = param;
7051 const WCHAR *key = MSI_RecordGetString( rec, 1 );
7052 const WCHAR *paths = MSI_RecordGetString( rec, 2 );
7053 char *filenameA, *pathA;
7054 WCHAR *pathW, **path_list;
7055
7056 if (!(file = msi_get_loaded_file( package, key )))
7057 {
7058 WARN("file %s not found\n", debugstr_w(key));
7059 return ERROR_SUCCESS;
7060 }
7061 if (!(filenameA = strdupWtoA( file->TargetPath ))) return ERROR_SUCCESS;
7062 path_list = msi_split_string( paths, ';' );
7063 if (!path_list) bind_image( filenameA, NULL );
7064 else
7065 {
7066 for (i = 0; path_list[i] && path_list[i][0]; i++)
7067 {
7068 deformat_string( package, path_list[i], &pathW );
7069 if ((pathA = strdupWtoA( pathW )))
7070 {
7071 bind_image( filenameA, pathA );
7072 msi_free( pathA );
7073 }
7074 msi_free( pathW );
7075 }
7076 }
7077 msi_free( path_list );
7078 msi_free( filenameA );
7079 return ERROR_SUCCESS;
7080 }
7081
7082 static UINT ACTION_BindImage( MSIPACKAGE *package )
7083 {
7084 static const WCHAR query[] = {
7085 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
7086 'B','i','n','d','I','m','a','g','e',0};
7087 MSIQUERY *view;
7088 UINT r;
7089
7090 r = MSI_DatabaseOpenViewW( package->db, query, &view );
7091 if (r == ERROR_SUCCESS)
7092 {
7093 r = MSI_IterateRecords( view, NULL, ITERATE_BindImage, package );
7094 msiobj_release( &view->hdr );
7095 if (r != ERROR_SUCCESS)
7096 return r;
7097 }
7098 return ERROR_SUCCESS;
7099 }
7100
7101 static UINT msi_unimplemented_action_stub( MSIPACKAGE *package, LPCSTR action, LPCWSTR table )
7102 {
7103 static const WCHAR query[] = {
7104 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','`','%','s','`',0};
7105 MSIQUERY *view;
7106 DWORD count = 0;
7107 UINT r;
7108
7109 r = MSI_OpenQuery( package->db, &view, query, table );
7110 if (r == ERROR_SUCCESS)
7111 {
7112 r = MSI_IterateRecords(view, &count, NULL, package);
7113 msiobj_release(&view->hdr);
7114 if (r != ERROR_SUCCESS)
7115 return r;
7116 }
7117 if (count) FIXME("%s: ignored %u rows from %s\n", action, count, debugstr_w(table));
7118 return ERROR_SUCCESS;
7119 }
7120
7121 static UINT ACTION_IsolateComponents( MSIPACKAGE *package )
7122 {
7123 static const WCHAR table[] = {
7124 'I','s','o','l','a','t','e','d','C','o','m','p','o','n','e','n','t',0 };
7125 return msi_unimplemented_action_stub( package, "IsolateComponents", table );
7126 }
7127
7128 static UINT ACTION_RMCCPSearch( MSIPACKAGE *package )
7129 {
7130 static const WCHAR table[] = { 'C','C','P','S','e','a','r','c','h',0 };
7131 return msi_unimplemented_action_stub( package, "RMCCPSearch", table );
7132 }
7133
7134 static UINT ACTION_RegisterComPlus( MSIPACKAGE *package )
7135 {
7136 static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
7137 return msi_unimplemented_action_stub( package, "RegisterComPlus", table );
7138 }
7139
7140 static UINT ACTION_UnregisterComPlus( MSIPACKAGE *package )
7141 {
7142 static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
7143 return msi_unimplemented_action_stub( package, "UnregisterComPlus", table );
7144 }
7145
7146 static UINT ACTION_InstallSFPCatalogFile( MSIPACKAGE *package )
7147 {
7148 static const WCHAR table[] = { 'S','F','P','C','a','t','a','l','o','g',0 };
7149 return msi_unimplemented_action_stub( package, "InstallSFPCatalogFile", table );
7150 }
7151
7152 static const struct
7153 {
7154 const WCHAR *action;
7155 UINT (*handler)(MSIPACKAGE *);
7156 const WCHAR *action_rollback;
7157 }
7158 StandardActions[] =
7159 {
7160 { szAllocateRegistrySpace, ACTION_AllocateRegistrySpace, NULL },
7161 { szAppSearch, ACTION_AppSearch, NULL },
7162 { szBindImage, ACTION_BindImage, NULL },
7163 { szCCPSearch, ACTION_CCPSearch, NULL },
7164 { szCostFinalize, ACTION_CostFinalize, NULL },
7165 { szCostInitialize, ACTION_CostInitialize, NULL },
7166 { szCreateFolders, ACTION_CreateFolders, szRemoveFolders },
7167 { szCreateShortcuts, ACTION_CreateShortcuts, szRemoveShortcuts },
7168 { szDeleteServices, ACTION_DeleteServices, szInstallServices },
7169 { szDisableRollback, ACTION_DisableRollback, NULL },
7170 { szDuplicateFiles, ACTION_DuplicateFiles, szRemoveDuplicateFiles },
7171 { szExecuteAction, ACTION_ExecuteAction, NULL },
7172 { szFileCost, ACTION_FileCost, NULL },
7173 { szFindRelatedProducts, ACTION_FindRelatedProducts, NULL },
7174 { szForceReboot, ACTION_ForceReboot, NULL },
7175 { szInstallAdminPackage, ACTION_InstallAdminPackage, NULL },
7176 { szInstallExecute, ACTION_InstallExecute, NULL },
7177 { szInstallExecuteAgain, ACTION_InstallExecute, NULL },
7178 { szInstallFiles, ACTION_InstallFiles, szRemoveFiles },
7179 { szInstallFinalize, ACTION_InstallFinalize, NULL },
7180 { szInstallInitialize, ACTION_InstallInitialize, NULL },
7181 { szInstallODBC, ACTION_InstallODBC, szRemoveODBC },
7182 { szInstallServices, ACTION_InstallServices, szDeleteServices },
7183 { szInstallSFPCatalogFile, ACTION_InstallSFPCatalogFile, NULL },
7184 { szInstallValidate, ACTION_InstallValidate, NULL },
7185 { szIsolateComponents, ACTION_IsolateComponents, NULL },
7186 { szLaunchConditions, ACTION_LaunchConditions, NULL },
7187 { szMigrateFeatureStates, ACTION_MigrateFeatureStates, NULL },
7188 { szMoveFiles, ACTION_MoveFiles, NULL },
7189 { szMsiPublishAssemblies, ACTION_MsiPublishAssemblies, szMsiUnpublishAssemblies },
7190 { szMsiUnpublishAssemblies, ACTION_MsiUnpublishAssemblies, szMsiPublishAssemblies },
7191 { szPatchFiles, ACTION_PatchFiles, NULL },
7192 { szProcessComponents, ACTION_ProcessComponents, szProcessComponents },
7193 { szPublishComponents, ACTION_PublishComponents, szUnpublishComponents },
7194 { szPublishFeatures, ACTION_PublishFeatures, szUnpublishFeatures },
7195 { szPublishProduct, ACTION_PublishProduct, NULL },
7196 { szRegisterClassInfo, ACTION_RegisterClassInfo, szUnregisterClassInfo },
7197 { szRegisterComPlus, ACTION_RegisterComPlus, szUnregisterComPlus },
7198 { szRegisterExtensionInfo, ACTION_RegisterExtensionInfo, szUnregisterExtensionInfo },
7199 { szRegisterFonts, ACTION_RegisterFonts, szUnregisterFonts },
7200 { szRegisterMIMEInfo, ACTION_RegisterMIMEInfo, szUnregisterMIMEInfo },
7201 { szRegisterProduct, ACTION_RegisterProduct, NULL },
7202 { szRegisterProgIdInfo, ACTION_RegisterProgIdInfo, szUnregisterProgIdInfo },
7203 { szRegisterTypeLibraries, ACTION_RegisterTypeLibraries, szUnregisterTypeLibraries },
7204 { szRegisterUser, ACTION_RegisterUser, NULL },
7205 { szRemoveDuplicateFiles, ACTION_RemoveDuplicateFiles, szDuplicateFiles },
7206 { szRemoveEnvironmentStrings, ACTION_RemoveEnvironmentStrings, szWriteEnvironmentStrings },
7207 { szRemoveExistingProducts, ACTION_RemoveExistingProducts, NULL },
7208 { szRemoveFiles, ACTION_RemoveFiles, szInstallFiles },
7209 { szRemoveFolders, ACTION_RemoveFolders, szCreateFolders },
7210 { szRemoveIniValues, ACTION_RemoveIniValues, szWriteIniValues },
7211 { szRemoveODBC, ACTION_RemoveODBC, szInstallODBC },
7212 { szRemoveRegistryValues, ACTION_RemoveRegistryValues, szWriteRegistryValues },
7213 { szRemoveShortcuts, ACTION_RemoveShortcuts, szCreateShortcuts },
7214 { szResolveSource, ACTION_ResolveSource, NULL },
7215 { szRMCCPSearch, ACTION_RMCCPSearch, NULL },
7216 { szScheduleReboot, ACTION_ScheduleReboot, NULL },
7217 { szSelfRegModules, ACTION_SelfRegModules, szSelfUnregModules },
7218 { szSelfUnregModules, ACTION_SelfUnregModules, szSelfRegModules },
7219 { szSetODBCFolders, ACTION_SetODBCFolders, NULL },
7220 { szStartServices, ACTION_StartServices, szStopServices },
7221 { szStopServices, ACTION_StopServices, szStartServices },
7222 { szUnpublishComponents, ACTION_UnpublishComponents, szPublishComponents },
7223 { szUnpublishFeatures, ACTION_UnpublishFeatures, szPublishFeatures },
7224 { szUnregisterClassInfo, ACTION_UnregisterClassInfo, szRegisterClassInfo },
7225 { szUnregisterComPlus, ACTION_UnregisterComPlus, szRegisterComPlus },
7226 { szUnregisterExtensionInfo, ACTION_UnregisterExtensionInfo, szRegisterExtensionInfo },
7227 { szUnregisterFonts, ACTION_UnregisterFonts, szRegisterFonts },
7228 { szUnregisterMIMEInfo, ACTION_UnregisterMIMEInfo, szRegisterMIMEInfo },
7229 { szUnregisterProgIdInfo, ACTION_UnregisterProgIdInfo, szRegisterProgIdInfo },
7230 { szUnregisterTypeLibraries, ACTION_UnregisterTypeLibraries, szRegisterTypeLibraries },
7231 { szValidateProductID, ACTION_ValidateProductID, NULL },
7232 { szWriteEnvironmentStrings, ACTION_WriteEnvironmentStrings, szRemoveEnvironmentStrings },
7233 { szWriteIniValues, ACTION_WriteIniValues, szRemoveIniValues },
7234 { szWriteRegistryValues, ACTION_WriteRegistryValues, szRemoveRegistryValues },
7235 { NULL, NULL, NULL }
7236 };
7237
7238 static BOOL ACTION_HandleStandardAction( MSIPACKAGE *package, LPCWSTR action, UINT *rc )
7239 {
7240 BOOL ret = FALSE;
7241 UINT i;
7242
7243 i = 0;
7244 while (StandardActions[i].action != NULL)
7245 {
7246 if (!strcmpW( StandardActions[i].action, action ))
7247 {
7248 ui_actionstart( package, action );
7249 if (StandardActions[i].handler)
7250 {
7251 ui_actioninfo( package, action, TRUE, 0 );
7252 *rc = StandardActions[i].handler( package );
7253 ui_actioninfo( package, action, FALSE, *rc );
7254
7255 if (StandardActions[i].action_rollback && !package->need_rollback)
7256 {
7257 TRACE("scheduling rollback action\n");
7258 msi_schedule_action( package, SCRIPT_ROLLBACK, StandardActions[i].action_rollback );
7259 }
7260 }
7261 else
7262 {
7263 FIXME("unhandled standard action %s\n", debugstr_w(action));
7264 *rc = ERROR_SUCCESS;
7265 }
7266 ret = TRUE;
7267 break;
7268 }
7269 i++;
7270 }
7271 return ret;
7272 }
7273
7274 UINT ACTION_PerformAction(MSIPACKAGE *package, const WCHAR *action, UINT script)
7275 {
7276 UINT rc = ERROR_SUCCESS;
7277 BOOL handled;
7278
7279 TRACE("Performing action (%s)\n", debugstr_w(action));
7280
7281 handled = ACTION_HandleStandardAction(package, action, &rc);
7282
7283 if (!handled)
7284 handled = ACTION_HandleCustomAction(package, action, &rc, script, TRUE);
7285
7286 if (!handled)
7287 {
7288 WARN("unhandled msi action %s\n", debugstr_w(action));
7289 rc = ERROR_FUNCTION_NOT_CALLED;
7290 }
7291
7292 return rc;
7293 }
7294
7295 UINT ACTION_PerformUIAction(MSIPACKAGE *package, const WCHAR *action, UINT script)
7296 {
7297 UINT rc = ERROR_SUCCESS;
7298 BOOL handled = FALSE;
7299
7300 TRACE("Performing action (%s)\n", debugstr_w(action));
7301
7302 handled = ACTION_HandleStandardAction(package, action, &rc);
7303
7304 if (!handled)
7305 handled = ACTION_HandleCustomAction(package, action, &rc, script, FALSE);
7306
7307 if( !handled && ACTION_DialogBox(package, action) == ERROR_SUCCESS )
7308 handled = TRUE;
7309
7310 if (!handled)
7311 {
7312 WARN("unhandled msi action %s\n", debugstr_w(action));
7313 rc = ERROR_FUNCTION_NOT_CALLED;
7314 }
7315
7316 return rc;
7317 }
7318
7319 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq)
7320 {
7321 UINT rc = ERROR_SUCCESS;
7322 MSIRECORD *row;
7323
7324 static const WCHAR query[] =
7325 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
7326 '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
7327 'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
7328 '`','S','e','q','u','e','n','c','e','`',' ', '=',' ','%','i',0};
7329 static const WCHAR ui_query[] =
7330 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
7331 '`','I','n','s','t','a','l','l','U','I','S','e','q','u','e','n','c','e',
7332 '`', ' ', 'W','H','E','R','E',' ','`','S','e','q','u','e','n','c','e','`',
7333 ' ', '=',' ','%','i',0};
7334
7335 if (needs_ui_sequence(package))
7336 row = MSI_QueryGetRecord(package->db, ui_query, seq);
7337 else
7338 row = MSI_QueryGetRecord(package->db, query, seq);
7339
7340 if (row)
7341 {
7342 LPCWSTR action, cond;
7343
7344 TRACE("Running the actions\n");
7345
7346 /* check conditions */
7347 cond = MSI_RecordGetString(row, 2);
7348
7349 /* this is a hack to skip errors in the condition code */
7350 if (MSI_EvaluateConditionW(package, cond) == MSICONDITION_FALSE)
7351 {
7352 msiobj_release(&row->hdr);
7353 return ERROR_SUCCESS;
7354 }
7355
7356 action = MSI_RecordGetString(row, 1);
7357 if (!action)
7358 {
7359 ERR("failed to fetch action\n");
7360 msiobj_release(&row->hdr);
7361 return ERROR_FUNCTION_FAILED;
7362 }
7363
7364 if (needs_ui_sequence(package))
7365 rc = ACTION_PerformUIAction(package, action, SCRIPT_NONE);
7366 else
7367 rc = ACTION_PerformAction(package, action, SCRIPT_NONE);
7368
7369 msiobj_release(&row->hdr);
7370 }
7371
7372 return rc;
7373 }
7374
7375 /****************************************************
7376 * TOP level entry points
7377 *****************************************************/
7378
7379 UINT MSI_InstallPackage( MSIPACKAGE *package, LPCWSTR szPackagePath,
7380 LPCWSTR szCommandLine )
7381 {
7382 static const WCHAR szDisableRollback[] = {'D','I','S','A','B','L','E','R','O','L','L','B','A','C','K',0};
7383 static const WCHAR szAction[] = {'A','C','T','I','O','N',0};
7384 static const WCHAR szInstall[] = {'I','N','S','T','A','L','L',0};
7385 WCHAR *reinstall = NULL;
7386 BOOL ui_exists;
7387 UINT rc;
7388
7389 msi_set_property( package->db, szAction, szInstall );
7390
7391 package->script->InWhatSequence = SEQUENCE_INSTALL;
7392
7393 if (szPackagePath)
7394 {
7395 LPWSTR p, dir;
7396 LPCWSTR file;
7397
7398 dir = strdupW(szPackagePath);
7399 p = strrchrW(dir, '\\');
7400 if (p)
7401 {
7402 *(++p) = 0;
7403 file = szPackagePath + (p - dir);
7404 }
7405 else
7406 {
7407 msi_free(dir);
7408 dir = msi_alloc(MAX_PATH * sizeof(WCHAR));
7409 GetCurrentDirectoryW(MAX_PATH, dir);
7410 lstrcatW(dir, szBackSlash);
7411 file = szPackagePath;
7412 }
7413
7414 msi_free( package->PackagePath );
7415 package->PackagePath = msi_alloc((lstrlenW(dir) + lstrlenW(file) + 1) * sizeof(WCHAR));
7416 if (!package->PackagePath)
7417 {
7418 msi_free(dir);
7419 return ERROR_OUTOFMEMORY;
7420 }
7421
7422 lstrcpyW(package->PackagePath, dir);
7423 lstrcatW(package->PackagePath, file);
7424 msi_free(dir);
7425
7426 msi_set_sourcedir_props(package, FALSE);
7427 }
7428
7429 rc = msi_parse_command_line( package, szCommandLine, FALSE );
7430 if (rc != ERROR_SUCCESS)
7431 return rc;
7432
7433 msi_apply_transforms( package );
7434 msi_apply_patches( package );
7435
7436 if (!szCommandLine && msi_get_property_int( package->db, szInstalled, 0 ))
7437 {
7438 TRACE("setting reinstall property\n");
7439 msi_set_property( package->db, szReinstall, szAll );
7440 }
7441
7442 /* properties may have been added by a transform */
7443 msi_clone_properties( package );
7444
7445 msi_parse_command_line( package, szCommandLine, FALSE );
7446 msi_adjust_privilege_properties( package );
7447 msi_set_context( package );
7448
7449 if (msi_get_property_int( package->db, szDisableRollback, 0 ))
7450 {
7451 TRACE("disabling rollback\n");
7452 msi_set_property( package->db, szRollbackDisabled, szOne );
7453 }
7454
7455 if (needs_ui_sequence( package))
7456 {
7457 package->script->InWhatSequence |= SEQUENCE_UI;
7458 rc = ACTION_ProcessUISequence(package);
7459 ui_exists = ui_sequence_exists(package);
7460 if (rc == ERROR_SUCCESS || !ui_exists)
7461 {
7462 package->script->InWhatSequence |= SEQUENCE_EXEC;
7463 rc = ACTION_ProcessExecSequence(package, ui_exists);
7464 }
7465 }
7466 else
7467 rc = ACTION_ProcessExecSequence(package, FALSE);
7468
7469 package->script->CurrentlyScripting = FALSE;
7470
7471 /* process the ending type action */
7472 if (rc == ERROR_SUCCESS)
7473 ACTION_PerformActionSequence(package, -1);
7474 else if (rc == ERROR_INSTALL_USEREXIT)
7475 ACTION_PerformActionSequence(package, -2);
7476 else if (rc == ERROR_INSTALL_SUSPEND)
7477 ACTION_PerformActionSequence(package, -4);
7478 else /* failed */
7479 {
7480 ACTION_PerformActionSequence(package, -3);
7481 if (!msi_get_property_int( package->db, szRollbackDisabled, 0 ))
7482 {
7483 package->need_rollback = TRUE;
7484 }
7485 }
7486
7487 /* finish up running custom actions */
7488 ACTION_FinishCustomActions(package);
7489
7490 if (package->need_rollback && !(reinstall = msi_dup_property( package->db, szReinstall )))
7491 {
7492 WARN("installation failed, running rollback script\n");
7493 execute_script( package, SCRIPT_ROLLBACK );
7494 }
7495 msi_free( reinstall );
7496
7497 if (rc == ERROR_SUCCESS && package->need_reboot)
7498 return ERROR_SUCCESS_REBOOT_REQUIRED;
7499
7500 return rc;
7501 }
Maarten's multimedia branch