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