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