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