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