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