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