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