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