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