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