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