?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
user32: ToUnicodeEx should return 0 for an unknown key.
[wine/dibdrv.git] / dlls / msi / action.c
blob8e7641398d9be5ea4892d2e984c884caf52133fb
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 "wine/debug.h"
39 #include "msidefs.h"
40 #include "msipriv.h"
41 #include "winuser.h"
42 #include "shlobj.h"
43 #include "wine/unicode.h"
44 #include "winver.h"
45
46 #define REG_PROGRESS_VALUE 13200
47 #define COMPONENT_PROGRESS_VALUE 24000
48
49 WINE_DEFAULT_DEBUG_CHANNEL(msi);
50
51 /*
52 * Prototypes
53 */
54 static UINT ACTION_ProcessExecSequence(MSIPACKAGE *package, BOOL UIran);
55 static UINT ACTION_ProcessUISequence(MSIPACKAGE *package);
56 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq, BOOL UI);
57
58 /*
59 * consts and values used
60 */
61 static const WCHAR c_colon[] = {'C',':','\\',0};
62
63 static const WCHAR szCreateFolders[] =
64 {'C','r','e','a','t','e','F','o','l','d','e','r','s',0};
65 static const WCHAR szCostFinalize[] =
66 {'C','o','s','t','F','i','n','a','l','i','z','e',0};
67 const WCHAR szInstallFiles[] =
68 {'I','n','s','t','a','l','l','F','i','l','e','s',0};
69 const WCHAR szDuplicateFiles[] =
70 {'D','u','p','l','i','c','a','t','e','F','i','l','e','s',0};
71 static const WCHAR szWriteRegistryValues[] =
72 {'W','r','i','t','e','R','e','g','i','s','t','r','y',
73 'V','a','l','u','e','s',0};
74 static const WCHAR szCostInitialize[] =
75 {'C','o','s','t','I','n','i','t','i','a','l','i','z','e',0};
76 static const WCHAR szFileCost[] =
77 {'F','i','l','e','C','o','s','t',0};
78 static const WCHAR szInstallInitialize[] =
79 {'I','n','s','t','a','l','l','I','n','i','t','i','a','l','i','z','e',0};
80 static const WCHAR szInstallValidate[] =
81 {'I','n','s','t','a','l','l','V','a','l','i','d','a','t','e',0};
82 static const WCHAR szLaunchConditions[] =
83 {'L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','s',0};
84 static const WCHAR szProcessComponents[] =
85 {'P','r','o','c','e','s','s','C','o','m','p','o','n','e','n','t','s',0};
86 static const WCHAR szRegisterTypeLibraries[] =
87 {'R','e','g','i','s','t','e','r','T','y','p','e',
88 'L','i','b','r','a','r','i','e','s',0};
89 const WCHAR szRegisterClassInfo[] =
90 {'R','e','g','i','s','t','e','r','C','l','a','s','s','I','n','f','o',0};
91 const WCHAR szRegisterProgIdInfo[] =
92 {'R','e','g','i','s','t','e','r','P','r','o','g','I','d','I','n','f','o',0};
93 static const WCHAR szCreateShortcuts[] =
94 {'C','r','e','a','t','e','S','h','o','r','t','c','u','t','s',0};
95 static const WCHAR szPublishProduct[] =
96 {'P','u','b','l','i','s','h','P','r','o','d','u','c','t',0};
97 static const WCHAR szWriteIniValues[] =
98 {'W','r','i','t','e','I','n','i','V','a','l','u','e','s',0};
99 static const WCHAR szSelfRegModules[] =
100 {'S','e','l','f','R','e','g','M','o','d','u','l','e','s',0};
101 static const WCHAR szPublishFeatures[] =
102 {'P','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
103 static const WCHAR szRegisterProduct[] =
104 {'R','e','g','i','s','t','e','r','P','r','o','d','u','c','t',0};
105 static const WCHAR szInstallExecute[] =
106 {'I','n','s','t','a','l','l','E','x','e','c','u','t','e',0};
107 static const WCHAR szInstallExecuteAgain[] =
108 {'I','n','s','t','a','l','l','E','x','e','c','u','t','e',
109 'A','g','a','i','n',0};
110 static const WCHAR szInstallFinalize[] =
111 {'I','n','s','t','a','l','l','F','i','n','a','l','i','z','e',0};
112 static const WCHAR szForceReboot[] =
113 {'F','o','r','c','e','R','e','b','o','o','t',0};
114 static const WCHAR szResolveSource[] =
115 {'R','e','s','o','l','v','e','S','o','u','r','c','e',0};
116 static const WCHAR szAppSearch[] =
117 {'A','p','p','S','e','a','r','c','h',0};
118 static const WCHAR szAllocateRegistrySpace[] =
119 {'A','l','l','o','c','a','t','e','R','e','g','i','s','t','r','y',
120 'S','p','a','c','e',0};
121 static const WCHAR szBindImage[] =
122 {'B','i','n','d','I','m','a','g','e',0};
123 static const WCHAR szCCPSearch[] =
124 {'C','C','P','S','e','a','r','c','h',0};
125 static const WCHAR szDeleteServices[] =
126 {'D','e','l','e','t','e','S','e','r','v','i','c','e','s',0};
127 static const WCHAR szDisableRollback[] =
128 {'D','i','s','a','b','l','e','R','o','l','l','b','a','c','k',0};
129 static const WCHAR szExecuteAction[] =
130 {'E','x','e','c','u','t','e','A','c','t','i','o','n',0};
131 const WCHAR szFindRelatedProducts[] =
132 {'F','i','n','d','R','e','l','a','t','e','d',
133 'P','r','o','d','u','c','t','s',0};
134 static const WCHAR szInstallAdminPackage[] =
135 {'I','n','s','t','a','l','l','A','d','m','i','n',
136 'P','a','c','k','a','g','e',0};
137 static const WCHAR szInstallSFPCatalogFile[] =
138 {'I','n','s','t','a','l','l','S','F','P','C','a','t','a','l','o','g',
139 'F','i','l','e',0};
140 static const WCHAR szIsolateComponents[] =
141 {'I','s','o','l','a','t','e','C','o','m','p','o','n','e','n','t','s',0};
142 const WCHAR szMigrateFeatureStates[] =
143 {'M','i','g','r','a','t','e','F','e','a','t','u','r','e',
144 'S','t','a','t','e','s',0};
145 const WCHAR szMoveFiles[] =
146 {'M','o','v','e','F','i','l','e','s',0};
147 static const WCHAR szMsiPublishAssemblies[] =
148 {'M','s','i','P','u','b','l','i','s','h',
149 'A','s','s','e','m','b','l','i','e','s',0};
150 static const WCHAR szMsiUnpublishAssemblies[] =
151 {'M','s','i','U','n','p','u','b','l','i','s','h',
152 'A','s','s','e','m','b','l','i','e','s',0};
153 static const WCHAR szInstallODBC[] =
154 {'I','n','s','t','a','l','l','O','D','B','C',0};
155 static const WCHAR szInstallServices[] =
156 {'I','n','s','t','a','l','l','S','e','r','v','i','c','e','s',0};
157 const WCHAR szPatchFiles[] =
158 {'P','a','t','c','h','F','i','l','e','s',0};
159 static const WCHAR szPublishComponents[] =
160 {'P','u','b','l','i','s','h','C','o','m','p','o','n','e','n','t','s',0};
161 static const WCHAR szRegisterComPlus[] =
162 {'R','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
163 const WCHAR szRegisterExtensionInfo[] =
164 {'R','e','g','i','s','t','e','r','E','x','t','e','n','s','i','o','n',
165 'I','n','f','o',0};
166 static const WCHAR szRegisterFonts[] =
167 {'R','e','g','i','s','t','e','r','F','o','n','t','s',0};
168 const WCHAR szRegisterMIMEInfo[] =
169 {'R','e','g','i','s','t','e','r','M','I','M','E','I','n','f','o',0};
170 static const WCHAR szRegisterUser[] =
171 {'R','e','g','i','s','t','e','r','U','s','e','r',0};
172 const WCHAR szRemoveDuplicateFiles[] =
173 {'R','e','m','o','v','e','D','u','p','l','i','c','a','t','e',
174 'F','i','l','e','s',0};
175 static const WCHAR szRemoveEnvironmentStrings[] =
176 {'R','e','m','o','v','e','E','n','v','i','r','o','n','m','e','n','t',
177 'S','t','r','i','n','g','s',0};
178 const WCHAR szRemoveExistingProducts[] =
179 {'R','e','m','o','v','e','E','x','i','s','t','i','n','g',
180 'P','r','o','d','u','c','t','s',0};
181 const WCHAR szRemoveFiles[] =
182 {'R','e','m','o','v','e','F','i','l','e','s',0};
183 static const WCHAR szRemoveFolders[] =
184 {'R','e','m','o','v','e','F','o','l','d','e','r','s',0};
185 static const WCHAR szRemoveIniValues[] =
186 {'R','e','m','o','v','e','I','n','i','V','a','l','u','e','s',0};
187 static const WCHAR szRemoveODBC[] =
188 {'R','e','m','o','v','e','O','D','B','C',0};
189 static const WCHAR szRemoveRegistryValues[] =
190 {'R','e','m','o','v','e','R','e','g','i','s','t','r','y',
191 'V','a','l','u','e','s',0};
192 static const WCHAR szRemoveShortcuts[] =
193 {'R','e','m','o','v','e','S','h','o','r','t','c','u','t','s',0};
194 static const WCHAR szRMCCPSearch[] =
195 {'R','M','C','C','P','S','e','a','r','c','h',0};
196 static const WCHAR szScheduleReboot[] =
197 {'S','c','h','e','d','u','l','e','R','e','b','o','o','t',0};
198 static const WCHAR szSelfUnregModules[] =
199 {'S','e','l','f','U','n','r','e','g','M','o','d','u','l','e','s',0};
200 static const WCHAR szSetODBCFolders[] =
201 {'S','e','t','O','D','B','C','F','o','l','d','e','r','s',0};
202 static const WCHAR szStartServices[] =
203 {'S','t','a','r','t','S','e','r','v','i','c','e','s',0};
204 static const WCHAR szStopServices[] =
205 {'S','t','o','p','S','e','r','v','i','c','e','s',0};
206 static const WCHAR szUnpublishComponents[] =
207 {'U','n','p','u','b','l','i','s','h',
208 'C','o','m','p','o','n','e','n','t','s',0};
209 static const WCHAR szUnpublishFeatures[] =
210 {'U','n','p','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
211 const WCHAR szUnregisterClassInfo[] =
212 {'U','n','r','e','g','i','s','t','e','r','C','l','a','s','s',
213 'I','n','f','o',0};
214 static const WCHAR szUnregisterComPlus[] =
215 {'U','n','r','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
216 const WCHAR szUnregisterExtensionInfo[] =
217 {'U','n','r','e','g','i','s','t','e','r',
218 'E','x','t','e','n','s','i','o','n','I','n','f','o',0};
219 static const WCHAR szUnregisterFonts[] =
220 {'U','n','r','e','g','i','s','t','e','r','F','o','n','t','s',0};
221 const WCHAR szUnregisterMIMEInfo[] =
222 {'U','n','r','e','g','i','s','t','e','r','M','I','M','E','I','n','f','o',0};
223 const WCHAR szUnregisterProgIdInfo[] =
224 {'U','n','r','e','g','i','s','t','e','r','P','r','o','g','I','d',
225 'I','n','f','o',0};
226 static const WCHAR szUnregisterTypeLibraries[] =
227 {'U','n','r','e','g','i','s','t','e','r','T','y','p','e',
228 'L','i','b','r','a','r','i','e','s',0};
229 static const WCHAR szValidateProductID[] =
230 {'V','a','l','i','d','a','t','e','P','r','o','d','u','c','t','I','D',0};
231 static const WCHAR szWriteEnvironmentStrings[] =
232 {'W','r','i','t','e','E','n','v','i','r','o','n','m','e','n','t',
233 'S','t','r','i','n','g','s',0};
234
235 /* action handlers */
236 typedef UINT (*STANDARDACTIONHANDLER)(MSIPACKAGE*);
237
238 struct _actions {
239 LPCWSTR action;
240 STANDARDACTIONHANDLER handler;
241 };
242
243 static struct _actions StandardActions[];
244
245
246 /********************************************************
247 * helper functions
248 ********************************************************/
249
250 static void ui_actionstart(MSIPACKAGE *package, LPCWSTR action)
251 {
252 static const WCHAR Query_t[] =
253 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
254 '`','A','c','t','i','o', 'n','T','e','x','t','`',' ',
255 'W','H','E','R','E', ' ','`','A','c','t','i','o','n','`',' ','=',
256 ' ','\'','%','s','\'',0};
257 MSIRECORD * row;
258
259 row = MSI_QueryGetRecord( package->db, Query_t, action );
260 if (!row)
261 return;
262 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONSTART, row);
263 msiobj_release(&row->hdr);
264 }
265
266 static void ui_actioninfo(MSIPACKAGE *package, LPCWSTR action, BOOL start,
267 UINT rc)
268 {
269 MSIRECORD * row;
270 static const WCHAR template_s[]=
271 {'A','c','t','i','o','n',' ','s','t','a','r','t',' ','%','s',':',' ',
272 '%','s', '.',0};
273 static const WCHAR template_e[]=
274 {'A','c','t','i','o','n',' ','e','n','d','e','d',' ','%','s',':',' ',
275 '%','s', '.',' ','R','e','t','u','r','n',' ','v','a','l','u','e',' ',
276 '%','i','.',0};
277 static const WCHAR format[] =
278 {'H','H','\'',':','\'','m','m','\'',':','\'','s','s',0};
279 WCHAR message[1024];
280 WCHAR timet[0x100];
281
282 GetTimeFormatW(LOCALE_USER_DEFAULT, 0, NULL, format, timet, 0x100);
283 if (start)
284 sprintfW(message,template_s,timet,action);
285 else
286 sprintfW(message,template_e,timet,action,rc);
287
288 row = MSI_CreateRecord(1);
289 MSI_RecordSetStringW(row,1,message);
290
291 MSI_ProcessMessage(package, INSTALLMESSAGE_INFO, row);
292 msiobj_release(&row->hdr);
293 }
294
295 static UINT msi_parse_command_line( MSIPACKAGE *package, LPCWSTR szCommandLine )
296 {
297 LPCWSTR ptr,ptr2;
298 BOOL quote;
299 DWORD len;
300 LPWSTR prop = NULL, val = NULL;
301
302 if (!szCommandLine)
303 return ERROR_SUCCESS;
304
305 ptr = szCommandLine;
306
307 while (*ptr)
308 {
309 if (*ptr==' ')
310 {
311 ptr++;
312 continue;
313 }
314
315 TRACE("Looking at %s\n",debugstr_w(ptr));
316
317 ptr2 = strchrW(ptr,'=');
318 if (!ptr2)
319 {
320 ERR("command line contains unknown string : %s\n", debugstr_w(ptr));
321 break;
322 }
323
324 quote = FALSE;
325
326 len = ptr2-ptr;
327 prop = msi_alloc((len+1)*sizeof(WCHAR));
328 memcpy(prop,ptr,len*sizeof(WCHAR));
329 prop[len]=0;
330 ptr2++;
331
332 len = 0;
333 ptr = ptr2;
334 while (*ptr && (quote || (!quote && *ptr!=' ')))
335 {
336 if (*ptr == '"')
337 quote = !quote;
338 ptr++;
339 len++;
340 }
341
342 if (*ptr2=='"')
343 {
344 ptr2++;
345 len -= 2;
346 }
347 val = msi_alloc((len+1)*sizeof(WCHAR));
348 memcpy(val,ptr2,len*sizeof(WCHAR));
349 val[len] = 0;
350
351 if (lstrlenW(prop) > 0)
352 {
353 TRACE("Found commandline property (%s) = (%s)\n",
354 debugstr_w(prop), debugstr_w(val));
355 MSI_SetPropertyW(package,prop,val);
356 }
357 msi_free(val);
358 msi_free(prop);
359 }
360
361 return ERROR_SUCCESS;
362 }
363
364
365 static LPWSTR* msi_split_string( LPCWSTR str, WCHAR sep )
366 {
367 LPCWSTR pc;
368 LPWSTR p, *ret = NULL;
369 UINT count = 0;
370
371 if (!str)
372 return ret;
373
374 /* count the number of substrings */
375 for ( pc = str, count = 0; pc; count++ )
376 {
377 pc = strchrW( pc, sep );
378 if (pc)
379 pc++;
380 }
381
382 /* allocate space for an array of substring pointers and the substrings */
383 ret = msi_alloc( (count+1) * sizeof (LPWSTR) +
384 (lstrlenW(str)+1) * sizeof(WCHAR) );
385 if (!ret)
386 return ret;
387
388 /* copy the string and set the pointers */
389 p = (LPWSTR) &ret[count+1];
390 lstrcpyW( p, str );
391 for( count = 0; (ret[count] = p); count++ )
392 {
393 p = strchrW( p, sep );
394 if (p)
395 *p++ = 0;
396 }
397
398 return ret;
399 }
400
401 static UINT msi_check_transform_applicable( MSIPACKAGE *package, IStorage *patch )
402 {
403 WCHAR szProductCode[] = { 'P','r','o','d','u','c','t','C','o','d','e',0 };
404 LPWSTR prod_code, patch_product;
405 UINT ret;
406
407 prod_code = msi_dup_property( package, szProductCode );
408 patch_product = msi_get_suminfo_product( patch );
409
410 TRACE("db = %s patch = %s\n", debugstr_w(prod_code), debugstr_w(patch_product));
411
412 if ( strstrW( patch_product, prod_code ) )
413 ret = ERROR_SUCCESS;
414 else
415 ret = ERROR_FUNCTION_FAILED;
416
417 msi_free( patch_product );
418 msi_free( prod_code );
419
420 return ret;
421 }
422
423 static UINT msi_apply_substorage_transform( MSIPACKAGE *package,
424 MSIDATABASE *patch_db, LPCWSTR name )
425 {
426 UINT ret = ERROR_FUNCTION_FAILED;
427 IStorage *stg = NULL;
428 HRESULT r;
429
430 TRACE("%p %s\n", package, debugstr_w(name) );
431
432 if (*name++ != ':')
433 {
434 ERR("expected a colon in %s\n", debugstr_w(name));
435 return ERROR_FUNCTION_FAILED;
436 }
437
438 r = IStorage_OpenStorage( patch_db->storage, name, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &stg );
439 if (SUCCEEDED(r))
440 {
441 ret = msi_check_transform_applicable( package, stg );
442 if (ret == ERROR_SUCCESS)
443 msi_table_apply_transform( package->db, stg );
444 else
445 TRACE("substorage transform %s wasn't applicable\n", debugstr_w(name));
446 IStorage_Release( stg );
447 }
448 else
449 ERR("failed to open substorage %s\n", debugstr_w(name));
450
451 return ERROR_SUCCESS;
452 }
453
454 static UINT msi_check_patch_applicable( MSIPACKAGE *package, MSISUMMARYINFO *si )
455 {
456 static const WCHAR szProdID[] = { 'P','r','o','d','u','c','t','I','D',0 };
457 LPWSTR guid_list, *guids, product_id;
458 UINT i, ret = ERROR_FUNCTION_FAILED;
459
460 product_id = msi_dup_property( package, szProdID );
461 if (!product_id)
462 {
463 /* FIXME: the property ProductID should be written into the DB somewhere */
464 ERR("no product ID to check\n");
465 return ERROR_SUCCESS;
466 }
467
468 guid_list = msi_suminfo_dup_string( si, PID_TEMPLATE );
469 guids = msi_split_string( guid_list, ';' );
470 for ( i = 0; guids[i] && ret != ERROR_SUCCESS; i++ )
471 {
472 if (!lstrcmpW( guids[i], product_id ))
473 ret = ERROR_SUCCESS;
474 }
475 msi_free( guids );
476 msi_free( guid_list );
477 msi_free( product_id );
478
479 return ret;
480 }
481
482 static UINT msi_parse_patch_summary( MSIPACKAGE *package, MSIDATABASE *patch_db )
483 {
484 MSISUMMARYINFO *si;
485 LPWSTR str, *substorage;
486 UINT i, r = ERROR_SUCCESS;
487
488 si = MSI_GetSummaryInformationW( patch_db->storage, 0 );
489 if (!si)
490 return ERROR_FUNCTION_FAILED;
491
492 msi_check_patch_applicable( package, si );
493
494 /* enumerate the substorage */
495 str = msi_suminfo_dup_string( si, PID_LASTAUTHOR );
496 substorage = msi_split_string( str, ';' );
497 for ( i = 0; substorage && substorage[i] && r == ERROR_SUCCESS; i++ )
498 r = msi_apply_substorage_transform( package, patch_db, substorage[i] );
499 msi_free( substorage );
500 msi_free( str );
501
502 /* FIXME: parse the sources in PID_REVNUMBER and do something with them... */
503
504 msiobj_release( &si->hdr );
505
506 return r;
507 }
508
509 static UINT msi_apply_patch_package( MSIPACKAGE *package, LPCWSTR file )
510 {
511 MSIDATABASE *patch_db = NULL;
512 UINT r;
513
514 TRACE("%p %s\n", package, debugstr_w( file ) );
515
516 /* FIXME:
517 * We probably want to make sure we only open a patch collection here.
518 * Patch collections (.msp) and databases (.msi) have different GUIDs
519 * but currently MSI_OpenDatabaseW will accept both.
520 */
521 r = MSI_OpenDatabaseW( file, MSIDBOPEN_READONLY, &patch_db );
522 if ( r != ERROR_SUCCESS )
523 {
524 ERR("failed to open patch collection %s\n", debugstr_w( file ) );
525 return r;
526 }
527
528 msi_parse_patch_summary( package, patch_db );
529
530 /*
531 * There might be a CAB file in the patch package,
532 * so append it to the list of storage to search for streams.
533 */
534 append_storage_to_db( package->db, patch_db->storage );
535
536 msiobj_release( &patch_db->hdr );
537
538 return ERROR_SUCCESS;
539 }
540
541 /* get the PATCH property, and apply all the patches it specifies */
542 static UINT msi_apply_patches( MSIPACKAGE *package )
543 {
544 static const WCHAR szPatch[] = { 'P','A','T','C','H',0 };
545 LPWSTR patch_list, *patches;
546 UINT i, r = ERROR_SUCCESS;
547
548 patch_list = msi_dup_property( package, szPatch );
549
550 TRACE("patches to be applied: %s\n", debugstr_w( patch_list ) );
551
552 patches = msi_split_string( patch_list, ';' );
553 for( i=0; patches && patches[i] && r == ERROR_SUCCESS; i++ )
554 r = msi_apply_patch_package( package, patches[i] );
555
556 msi_free( patches );
557 msi_free( patch_list );
558
559 return r;
560 }
561
562 static UINT msi_apply_transforms( MSIPACKAGE *package )
563 {
564 static const WCHAR szTransforms[] = {
565 'T','R','A','N','S','F','O','R','M','S',0 };
566 LPWSTR xform_list, *xforms;
567 UINT i, r = ERROR_SUCCESS;
568
569 xform_list = msi_dup_property( package, szTransforms );
570 xforms = msi_split_string( xform_list, ';' );
571
572 for( i=0; xforms && xforms[i] && r == ERROR_SUCCESS; i++ )
573 {
574 if (xforms[i][0] == ':')
575 r = msi_apply_substorage_transform( package, package->db, &xforms[i][1] );
576 else
577 r = MSI_DatabaseApplyTransformW( package->db, xforms[i], 0 );
578 }
579
580 msi_free( xforms );
581 msi_free( xform_list );
582
583 return r;
584 }
585
586 /****************************************************
587 * TOP level entry points
588 *****************************************************/
589
590 UINT MSI_InstallPackage( MSIPACKAGE *package, LPCWSTR szPackagePath,
591 LPCWSTR szCommandLine )
592 {
593 UINT rc;
594 BOOL ui = FALSE;
595 static const WCHAR szUILevel[] = {'U','I','L','e','v','e','l',0};
596 static const WCHAR szAction[] = {'A','C','T','I','O','N',0};
597 static const WCHAR szInstall[] = {'I','N','S','T','A','L','L',0};
598
599 MSI_SetPropertyW(package, szAction, szInstall);
600
601 package->script = msi_alloc_zero(sizeof(MSISCRIPT));
602
603 package->script->InWhatSequence = SEQUENCE_INSTALL;
604
605 if (szPackagePath)
606 {
607 LPWSTR p, check, path;
608
609 path = strdupW(szPackagePath);
610 p = strrchrW(path,'\\');
611 if (p)
612 {
613 p++;
614 *p=0;
615 }
616 else
617 {
618 msi_free(path);
619 path = msi_alloc(MAX_PATH*sizeof(WCHAR));
620 GetCurrentDirectoryW(MAX_PATH,path);
621 strcatW(path,cszbs);
622 }
623
624 check = msi_dup_property( package, cszSourceDir );
625 if (!check)
626 MSI_SetPropertyW(package, cszSourceDir, path);
627
628 check = msi_dup_property( package, cszSOURCEDIR );
629 if (!check)
630 MSI_SetPropertyW(package, cszSOURCEDIR, path);
631
632 msi_free( package->PackagePath );
633 package->PackagePath = path;
634
635 msi_free(check);
636 }
637
638 msi_parse_command_line( package, szCommandLine );
639
640 msi_apply_transforms( package );
641 msi_apply_patches( package );
642
643 if ( msi_get_property_int(package, szUILevel, 0) >= INSTALLUILEVEL_REDUCED )
644 {
645 package->script->InWhatSequence |= SEQUENCE_UI;
646 rc = ACTION_ProcessUISequence(package);
647 ui = TRUE;
648 if (rc == ERROR_SUCCESS)
649 {
650 package->script->InWhatSequence |= SEQUENCE_EXEC;
651 rc = ACTION_ProcessExecSequence(package,TRUE);
652 }
653 }
654 else
655 rc = ACTION_ProcessExecSequence(package,FALSE);
656
657 if (rc == -1)
658 {
659 /* install was halted but should be considered a success */
660 rc = ERROR_SUCCESS;
661 }
662
663 package->script->CurrentlyScripting= FALSE;
664
665 /* process the ending type action */
666 if (rc == ERROR_SUCCESS)
667 ACTION_PerformActionSequence(package,-1,ui);
668 else if (rc == ERROR_INSTALL_USEREXIT)
669 ACTION_PerformActionSequence(package,-2,ui);
670 else if (rc == ERROR_INSTALL_SUSPEND)
671 ACTION_PerformActionSequence(package,-4,ui);
672 else /* failed */
673 ACTION_PerformActionSequence(package,-3,ui);
674
675 /* finish up running custom actions */
676 ACTION_FinishCustomActions(package);
677
678 return rc;
679 }
680
681 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq, BOOL UI)
682 {
683 UINT rc = ERROR_SUCCESS;
684 MSIRECORD * row = 0;
685 static const WCHAR ExecSeqQuery[] =
686 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
687 '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
688 'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
689 '`','S','e','q','u','e','n','c','e','`',' ', '=',' ','%','i',0};
690
691 static const WCHAR UISeqQuery[] =
692 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
693 '`','I','n','s','t','a','l','l','U','I','S','e','q','u','e','n','c','e',
694 '`', ' ', 'W','H','E','R','E',' ','`','S','e','q','u','e','n','c','e','`',
695 ' ', '=',' ','%','i',0};
696
697 if (UI)
698 row = MSI_QueryGetRecord(package->db, UISeqQuery, seq);
699 else
700 row = MSI_QueryGetRecord(package->db, ExecSeqQuery, seq);
701
702 if (row)
703 {
704 LPCWSTR action, cond;
705
706 TRACE("Running the actions\n");
707
708 /* check conditions */
709 cond = MSI_RecordGetString(row,2);
710
711 /* this is a hack to skip errors in the condition code */
712 if (MSI_EvaluateConditionW(package, cond) == MSICONDITION_FALSE)
713 goto end;
714
715 action = MSI_RecordGetString(row,1);
716 if (!action)
717 {
718 ERR("failed to fetch action\n");
719 rc = ERROR_FUNCTION_FAILED;
720 goto end;
721 }
722
723 if (UI)
724 rc = ACTION_PerformUIAction(package,action);
725 else
726 rc = ACTION_PerformAction(package,action,FALSE);
727 end:
728 msiobj_release(&row->hdr);
729 }
730 else
731 rc = ERROR_SUCCESS;
732
733 return rc;
734 }
735
736 typedef struct {
737 MSIPACKAGE* package;
738 BOOL UI;
739 } iterate_action_param;
740
741 static UINT ITERATE_Actions(MSIRECORD *row, LPVOID param)
742 {
743 iterate_action_param *iap= (iterate_action_param*)param;
744 UINT rc;
745 LPCWSTR cond, action;
746
747 action = MSI_RecordGetString(row,1);
748 if (!action)
749 {
750 ERR("Error is retrieving action name\n");
751 return ERROR_FUNCTION_FAILED;
752 }
753
754 /* check conditions */
755 cond = MSI_RecordGetString(row,2);
756
757 /* this is a hack to skip errors in the condition code */
758 if (MSI_EvaluateConditionW(iap->package, cond) == MSICONDITION_FALSE)
759 {
760 TRACE("Skipping action: %s (condition is false)\n", debugstr_w(action));
761 return ERROR_SUCCESS;
762 }
763
764 if (iap->UI)
765 rc = ACTION_PerformUIAction(iap->package,action);
766 else
767 rc = ACTION_PerformAction(iap->package,action,FALSE);
768
769 msi_dialog_check_messages( NULL );
770
771 if (iap->package->CurrentInstallState != ERROR_SUCCESS )
772 rc = iap->package->CurrentInstallState;
773
774 if (rc == ERROR_FUNCTION_NOT_CALLED)
775 rc = ERROR_SUCCESS;
776
777 if (rc != ERROR_SUCCESS)
778 ERR("Execution halted, action %s returned %i\n", debugstr_w(action), rc);
779
780 return rc;
781 }
782
783 UINT MSI_Sequence( MSIPACKAGE *package, LPCWSTR szTable, INT iSequenceMode )
784 {
785 MSIQUERY * view;
786 UINT r;
787 static const WCHAR query[] =
788 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
789 '`','%','s','`',
790 ' ','W','H','E','R','E',' ',
791 '`','S','e','q','u','e','n','c','e','`',' ',
792 '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
793 '`','S','e','q','u','e','n','c','e','`',0};
794 iterate_action_param iap;
795
796 /*
797 * FIXME: probably should be checking UILevel in the
798 * ACTION_PerformUIAction/ACTION_PerformAction
799 * rather than saving the UI level here. Those
800 * two functions can be merged too.
801 */
802 iap.package = package;
803 iap.UI = TRUE;
804
805 TRACE("%p %s %i\n", package, debugstr_w(szTable), iSequenceMode );
806
807 r = MSI_OpenQuery( package->db, &view, query, szTable );
808 if (r == ERROR_SUCCESS)
809 {
810 r = MSI_IterateRecords( view, NULL, ITERATE_Actions, &iap );
811 msiobj_release(&view->hdr);
812 }
813
814 return r;
815 }
816
817 static UINT ACTION_ProcessExecSequence(MSIPACKAGE *package, BOOL UIran)
818 {
819 MSIQUERY * view;
820 UINT rc;
821 static const WCHAR ExecSeqQuery[] =
822 {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
823 '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
824 'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
825 '`','S','e','q','u','e','n','c','e','`',' ', '>',' ','%','i',' ',
826 'O','R','D','E','R',' ', 'B','Y',' ',
827 '`','S','e','q','u','e','n','c','e','`',0 };
828 MSIRECORD * row = 0;
829 static const WCHAR IVQuery[] =
830 {'S','E','L','E','C','T',' ','`','S','e','q','u','e','n','c','e','`',
831 ' ', 'F','R','O','M',' ','`','I','n','s','t','a','l','l',
832 'E','x','e','c','u','t','e','S','e','q','u','e','n','c','e','`',' ',
833 'W','H','E','R','E',' ','`','A','c','t','i','o','n','`',' ','=',
834 ' ','\'', 'I','n','s','t','a','l','l',
835 'V','a','l','i','d','a','t','e','\'', 0};
836 INT seq = 0;
837 iterate_action_param iap;
838
839 iap.package = package;
840 iap.UI = FALSE;
841
842 if (package->script->ExecuteSequenceRun)
843 {
844 TRACE("Execute Sequence already Run\n");
845 return ERROR_SUCCESS;
846 }
847
848 package->script->ExecuteSequenceRun = TRUE;
849
850 /* get the sequence number */
851 if (UIran)
852 {
853 row = MSI_QueryGetRecord(package->db, IVQuery);
854 if( !row )
855 return ERROR_FUNCTION_FAILED;
856 seq = MSI_RecordGetInteger(row,1);
857 msiobj_release(&row->hdr);
858 }
859
860 rc = MSI_OpenQuery(package->db, &view, ExecSeqQuery, seq);
861 if (rc == ERROR_SUCCESS)
862 {
863 TRACE("Running the actions\n");
864
865 rc = MSI_IterateRecords(view, NULL, ITERATE_Actions, &iap);
866 msiobj_release(&view->hdr);
867 }
868
869 return rc;
870 }
871
872 static UINT ACTION_ProcessUISequence(MSIPACKAGE *package)
873 {
874 MSIQUERY * view;
875 UINT rc;
876 static const WCHAR ExecSeqQuery [] =
877 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
878 '`','I','n','s','t','a','l','l',
879 'U','I','S','e','q','u','e','n','c','e','`',
880 ' ','W','H','E','R','E',' ',
881 '`','S','e','q','u','e','n','c','e','`',' ',
882 '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
883 '`','S','e','q','u','e','n','c','e','`',0};
884 iterate_action_param iap;
885
886 iap.package = package;
887 iap.UI = TRUE;
888
889 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
890
891 if (rc == ERROR_SUCCESS)
892 {
893 TRACE("Running the actions\n");
894
895 rc = MSI_IterateRecords(view, NULL, ITERATE_Actions, &iap);
896 msiobj_release(&view->hdr);
897 }
898
899 return rc;
900 }
901
902 /********************************************************
903 * ACTION helper functions and functions that perform the actions
904 *******************************************************/
905 static BOOL ACTION_HandleStandardAction(MSIPACKAGE *package, LPCWSTR action,
906 UINT* rc, BOOL force )
907 {
908 BOOL ret = FALSE;
909 BOOL run = force;
910 int i;
911
912 if (!run && !package->script->CurrentlyScripting)
913 run = TRUE;
914
915 if (!run)
916 {
917 if (strcmpW(action,szInstallFinalize) == 0 ||
918 strcmpW(action,szInstallExecute) == 0 ||
919 strcmpW(action,szInstallExecuteAgain) == 0)
920 run = TRUE;
921 }
922
923 i = 0;
924 while (StandardActions[i].action != NULL)
925 {
926 if (strcmpW(StandardActions[i].action, action)==0)
927 {
928 if (!run)
929 {
930 ui_actioninfo(package, action, TRUE, 0);
931 *rc = schedule_action(package,INSTALL_SCRIPT,action);
932 ui_actioninfo(package, action, FALSE, *rc);
933 }
934 else
935 {
936 ui_actionstart(package, action);
937 if (StandardActions[i].handler)
938 {
939 *rc = StandardActions[i].handler(package);
940 }
941 else
942 {
943 FIXME("unhandled standard action %s\n",debugstr_w(action));
944 *rc = ERROR_SUCCESS;
945 }
946 }
947 ret = TRUE;
948 break;
949 }
950 i++;
951 }
952 return ret;
953 }
954
955 static BOOL ACTION_HandleCustomAction( MSIPACKAGE* package, LPCWSTR action,
956 UINT* rc, BOOL force )
957 {
958 BOOL ret=FALSE;
959 UINT arc;
960
961 arc = ACTION_CustomAction(package,action, force);
962
963 if (arc != ERROR_CALL_NOT_IMPLEMENTED)
964 {
965 *rc = arc;
966 ret = TRUE;
967 }
968 return ret;
969 }
970
971 /*
972 * A lot of actions are really important even if they don't do anything
973 * explicit... Lots of properties are set at the beginning of the installation
974 * CostFinalize does a bunch of work to translate the directories and such
975 *
976 * But until I get write access to the database that is hard, so I am going to
977 * hack it to see if I can get something to run.
978 */
979 UINT ACTION_PerformAction(MSIPACKAGE *package, const WCHAR *action, BOOL force)
980 {
981 UINT rc = ERROR_SUCCESS;
982 BOOL handled;
983
984 TRACE("Performing action (%s)\n",debugstr_w(action));
985
986 handled = ACTION_HandleStandardAction(package, action, &rc, force);
987
988 if (!handled)
989 handled = ACTION_HandleCustomAction(package, action, &rc, force);
990
991 if (!handled)
992 {
993 FIXME("unhandled msi action %s\n",debugstr_w(action));
994 rc = ERROR_FUNCTION_NOT_CALLED;
995 }
996
997 return rc;
998 }
999
1000 UINT ACTION_PerformUIAction(MSIPACKAGE *package, const WCHAR *action)
1001 {
1002 UINT rc = ERROR_SUCCESS;
1003 BOOL handled = FALSE;
1004
1005 TRACE("Performing action (%s)\n",debugstr_w(action));
1006
1007 handled = ACTION_HandleStandardAction(package, action, &rc,TRUE);
1008
1009 if (!handled)
1010 handled = ACTION_HandleCustomAction(package, action, &rc, FALSE);
1011
1012 if( !handled && ACTION_DialogBox(package,action) == ERROR_SUCCESS )
1013 handled = TRUE;
1014
1015 if (!handled)
1016 {
1017 FIXME("unhandled msi action %s\n",debugstr_w(action));
1018 rc = ERROR_FUNCTION_NOT_CALLED;
1019 }
1020
1021 return rc;
1022 }
1023
1024
1025 /*
1026 * Actual Action Handlers
1027 */
1028
1029 static UINT ITERATE_CreateFolders(MSIRECORD *row, LPVOID param)
1030 {
1031 MSIPACKAGE *package = (MSIPACKAGE*)param;
1032 LPCWSTR dir;
1033 LPWSTR full_path;
1034 MSIRECORD *uirow;
1035 MSIFOLDER *folder;
1036
1037 dir = MSI_RecordGetString(row,1);
1038 if (!dir)
1039 {
1040 ERR("Unable to get folder id\n");
1041 return ERROR_SUCCESS;
1042 }
1043
1044 full_path = resolve_folder(package,dir,FALSE,FALSE,&folder);
1045 if (!full_path)
1046 {
1047 ERR("Unable to resolve folder id %s\n",debugstr_w(dir));
1048 return ERROR_SUCCESS;
1049 }
1050
1051 TRACE("Folder is %s\n",debugstr_w(full_path));
1052
1053 /* UI stuff */
1054 uirow = MSI_CreateRecord(1);
1055 MSI_RecordSetStringW(uirow,1,full_path);
1056 ui_actiondata(package,szCreateFolders,uirow);
1057 msiobj_release( &uirow->hdr );
1058
1059 if (folder->State == 0)
1060 create_full_pathW(full_path);
1061
1062 folder->State = 3;
1063
1064 msi_free(full_path);
1065 return ERROR_SUCCESS;
1066 }
1067
1068 /* FIXME: probably should merge this with the above function */
1069 static UINT msi_create_directory( MSIPACKAGE* package, LPCWSTR dir )
1070 {
1071 UINT rc = ERROR_SUCCESS;
1072 MSIFOLDER *folder;
1073 LPWSTR install_path;
1074
1075 install_path = resolve_folder(package, dir, FALSE, FALSE, &folder);
1076 if (!install_path)
1077 return ERROR_FUNCTION_FAILED;
1078
1079 /* create the path */
1080 if (folder->State == 0)
1081 {
1082 create_full_pathW(install_path);
1083 folder->State = 2;
1084 }
1085 msi_free(install_path);
1086
1087 return rc;
1088 }
1089
1090 UINT msi_create_component_directories( MSIPACKAGE *package )
1091 {
1092 MSICOMPONENT *comp;
1093
1094 /* create all the folders required by the components are going to install */
1095 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
1096 {
1097 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
1098 continue;
1099 msi_create_directory( package, comp->Directory );
1100 }
1101
1102 return ERROR_SUCCESS;
1103 }
1104
1105 /*
1106 * Also we cannot enable/disable components either, so for now I am just going
1107 * to do all the directories for all the components.
1108 */
1109 static UINT ACTION_CreateFolders(MSIPACKAGE *package)
1110 {
1111 static const WCHAR ExecSeqQuery[] =
1112 {'S','E','L','E','C','T',' ',
1113 '`','D','i','r','e','c','t','o','r','y','_','`',
1114 ' ','F','R','O','M',' ',
1115 '`','C','r','e','a','t','e','F','o','l','d','e','r','`',0 };
1116 UINT rc;
1117 MSIQUERY *view;
1118
1119 /* create all the empty folders specified in the CreateFolder table */
1120 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view );
1121 if (rc != ERROR_SUCCESS)
1122 return ERROR_SUCCESS;
1123
1124 rc = MSI_IterateRecords(view, NULL, ITERATE_CreateFolders, package);
1125 msiobj_release(&view->hdr);
1126
1127 msi_create_component_directories( package );
1128
1129 return rc;
1130 }
1131
1132 static UINT load_component( MSIRECORD *row, LPVOID param )
1133 {
1134 MSIPACKAGE *package = param;
1135 MSICOMPONENT *comp;
1136
1137 comp = msi_alloc_zero( sizeof(MSICOMPONENT) );
1138 if (!comp)
1139 return ERROR_FUNCTION_FAILED;
1140
1141 list_add_tail( &package->components, &comp->entry );
1142
1143 /* fill in the data */
1144 comp->Component = msi_dup_record_field( row, 1 );
1145
1146 TRACE("Loading Component %s\n", debugstr_w(comp->Component));
1147
1148 comp->ComponentId = msi_dup_record_field( row, 2 );
1149 comp->Directory = msi_dup_record_field( row, 3 );
1150 comp->Attributes = MSI_RecordGetInteger(row,4);
1151 comp->Condition = msi_dup_record_field( row, 5 );
1152 comp->KeyPath = msi_dup_record_field( row, 6 );
1153
1154 comp->Installed = INSTALLSTATE_UNKNOWN;
1155 msi_component_set_state( comp, INSTALLSTATE_UNKNOWN );
1156
1157 return ERROR_SUCCESS;
1158 }
1159
1160 static UINT load_all_components( MSIPACKAGE *package )
1161 {
1162 static const WCHAR query[] = {
1163 'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
1164 '`','C','o','m','p','o','n','e','n','t','`',0 };
1165 MSIQUERY *view;
1166 UINT r;
1167
1168 if (!list_empty(&package->components))
1169 return ERROR_SUCCESS;
1170
1171 r = MSI_DatabaseOpenViewW( package->db, query, &view );
1172 if (r != ERROR_SUCCESS)
1173 return r;
1174
1175 r = MSI_IterateRecords(view, NULL, load_component, package);
1176 msiobj_release(&view->hdr);
1177 return r;
1178 }
1179
1180 typedef struct {
1181 MSIPACKAGE *package;
1182 MSIFEATURE *feature;
1183 } _ilfs;
1184
1185 static UINT add_feature_component( MSIFEATURE *feature, MSICOMPONENT *comp )
1186 {
1187 ComponentList *cl;
1188
1189 cl = msi_alloc( sizeof (*cl) );
1190 if ( !cl )
1191 return ERROR_NOT_ENOUGH_MEMORY;
1192 cl->component = comp;
1193 list_add_tail( &feature->Components, &cl->entry );
1194
1195 return ERROR_SUCCESS;
1196 }
1197
1198 static UINT add_feature_child( MSIFEATURE *parent, MSIFEATURE *child )
1199 {
1200 FeatureList *fl;
1201
1202 fl = msi_alloc( sizeof(*fl) );
1203 if ( !fl )
1204 return ERROR_NOT_ENOUGH_MEMORY;
1205 fl->feature = child;
1206 list_add_tail( &parent->Children, &fl->entry );
1207
1208 return ERROR_SUCCESS;
1209 }
1210
1211 static UINT iterate_load_featurecomponents(MSIRECORD *row, LPVOID param)
1212 {
1213 _ilfs* ilfs= (_ilfs*)param;
1214 LPCWSTR component;
1215 MSICOMPONENT *comp;
1216
1217 component = MSI_RecordGetString(row,1);
1218
1219 /* check to see if the component is already loaded */
1220 comp = get_loaded_component( ilfs->package, component );
1221 if (!comp)
1222 {
1223 ERR("unknown component %s\n", debugstr_w(component));
1224 return ERROR_FUNCTION_FAILED;
1225 }
1226
1227 add_feature_component( ilfs->feature, comp );
1228 comp->Enabled = TRUE;
1229
1230 return ERROR_SUCCESS;
1231 }
1232
1233 static MSIFEATURE *find_feature_by_name( MSIPACKAGE *package, LPCWSTR name )
1234 {
1235 MSIFEATURE *feature;
1236
1237 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1238 {
1239 if ( !lstrcmpW( feature->Feature, name ) )
1240 return feature;
1241 }
1242
1243 return NULL;
1244 }
1245
1246 static UINT load_feature(MSIRECORD * row, LPVOID param)
1247 {
1248 MSIPACKAGE* package = (MSIPACKAGE*)param;
1249 MSIFEATURE* feature;
1250 static const WCHAR Query1[] =
1251 {'S','E','L','E','C','T',' ',
1252 '`','C','o','m','p','o','n','e','n','t','_','`',
1253 ' ','F','R','O','M',' ','`','F','e','a','t','u','r','e',
1254 'C','o','m','p','o','n','e','n','t','s','`',' ',
1255 'W','H','E','R','E',' ',
1256 '`','F','e', 'a','t','u','r','e','_','`',' ','=','\'','%','s','\'',0};
1257 MSIQUERY * view;
1258 UINT rc;
1259 _ilfs ilfs;
1260
1261 /* fill in the data */
1262
1263 feature = msi_alloc_zero( sizeof (MSIFEATURE) );
1264 if (!feature)
1265 return ERROR_NOT_ENOUGH_MEMORY;
1266
1267 list_init( &feature->Children );
1268 list_init( &feature->Components );
1269
1270 feature->Feature = msi_dup_record_field( row, 1 );
1271
1272 TRACE("Loading feature %s\n",debugstr_w(feature->Feature));
1273
1274 feature->Feature_Parent = msi_dup_record_field( row, 2 );
1275 feature->Title = msi_dup_record_field( row, 3 );
1276 feature->Description = msi_dup_record_field( row, 4 );
1277
1278 if (!MSI_RecordIsNull(row,5))
1279 feature->Display = MSI_RecordGetInteger(row,5);
1280
1281 feature->Level= MSI_RecordGetInteger(row,6);
1282 feature->Directory = msi_dup_record_field( row, 7 );
1283 feature->Attributes = MSI_RecordGetInteger(row,8);
1284
1285 feature->Installed = INSTALLSTATE_UNKNOWN;
1286 msi_feature_set_state( feature, INSTALLSTATE_UNKNOWN );
1287
1288 list_add_tail( &package->features, &feature->entry );
1289
1290 /* load feature components */
1291
1292 rc = MSI_OpenQuery( package->db, &view, Query1, feature->Feature );
1293 if (rc != ERROR_SUCCESS)
1294 return ERROR_SUCCESS;
1295
1296 ilfs.package = package;
1297 ilfs.feature = feature;
1298
1299 MSI_IterateRecords(view, NULL, iterate_load_featurecomponents , &ilfs);
1300 msiobj_release(&view->hdr);
1301
1302 return ERROR_SUCCESS;
1303 }
1304
1305 static UINT find_feature_children(MSIRECORD * row, LPVOID param)
1306 {
1307 MSIPACKAGE* package = (MSIPACKAGE*)param;
1308 MSIFEATURE *parent, *child;
1309
1310 child = find_feature_by_name( package, MSI_RecordGetString( row, 1 ) );
1311 if (!child)
1312 return ERROR_FUNCTION_FAILED;
1313
1314 if (!child->Feature_Parent)
1315 return ERROR_SUCCESS;
1316
1317 parent = find_feature_by_name( package, child->Feature_Parent );
1318 if (!parent)
1319 return ERROR_FUNCTION_FAILED;
1320
1321 add_feature_child( parent, child );
1322 return ERROR_SUCCESS;
1323 }
1324
1325 static UINT load_all_features( MSIPACKAGE *package )
1326 {
1327 static const WCHAR query[] = {
1328 'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1329 '`','F','e','a','t','u','r','e','`',' ','O','R','D','E','R',
1330 ' ','B','Y',' ','`','D','i','s','p','l','a','y','`',0};
1331 MSIQUERY *view;
1332 UINT r;
1333
1334 if (!list_empty(&package->features))
1335 return ERROR_SUCCESS;
1336
1337 r = MSI_DatabaseOpenViewW( package->db, query, &view );
1338 if (r != ERROR_SUCCESS)
1339 return r;
1340
1341 r = MSI_IterateRecords( view, NULL, load_feature, package );
1342 if (r != ERROR_SUCCESS)
1343 return r;
1344
1345 r = MSI_IterateRecords( view, NULL, find_feature_children, package );
1346 msiobj_release( &view->hdr );
1347
1348 return r;
1349 }
1350
1351 static LPWSTR folder_split_path(LPWSTR p, WCHAR ch)
1352 {
1353 if (!p)
1354 return p;
1355 p = strchrW(p, ch);
1356 if (!p)
1357 return p;
1358 *p = 0;
1359 return p+1;
1360 }
1361
1362 static UINT load_file(MSIRECORD *row, LPVOID param)
1363 {
1364 MSIPACKAGE* package = (MSIPACKAGE*)param;
1365 LPCWSTR component;
1366 MSIFILE *file;
1367
1368 /* fill in the data */
1369
1370 file = msi_alloc_zero( sizeof (MSIFILE) );
1371 if (!file)
1372 return ERROR_NOT_ENOUGH_MEMORY;
1373
1374 file->File = msi_dup_record_field( row, 1 );
1375
1376 component = MSI_RecordGetString( row, 2 );
1377 file->Component = get_loaded_component( package, component );
1378
1379 if (!file->Component)
1380 ERR("Unfound Component %s\n",debugstr_w(component));
1381
1382 file->FileName = msi_dup_record_field( row, 3 );
1383 reduce_to_longfilename( file->FileName );
1384
1385 file->ShortName = msi_dup_record_field( row, 3 );
1386 file->LongName = strdupW( folder_split_path(file->ShortName, '|'));
1387
1388 file->FileSize = MSI_RecordGetInteger( row, 4 );
1389 file->Version = msi_dup_record_field( row, 5 );
1390 file->Language = msi_dup_record_field( row, 6 );
1391 file->Attributes = MSI_RecordGetInteger( row, 7 );
1392 file->Sequence = MSI_RecordGetInteger( row, 8 );
1393
1394 file->state = msifs_invalid;
1395
1396 /* if the compressed bits are not set in the file attributes,
1397 * then read the information from the package word count property
1398 */
1399 if (file->Attributes & msidbFileAttributesCompressed)
1400 {
1401 file->IsCompressed = TRUE;
1402 }
1403 else if (file->Attributes & msidbFileAttributesNoncompressed)
1404 {
1405 file->IsCompressed = FALSE;
1406 }
1407 else
1408 {
1409 file->IsCompressed = package->WordCount & MSIWORDCOUNT_COMPRESSED;
1410 }
1411
1412 TRACE("File Loaded (%s)\n",debugstr_w(file->File));
1413
1414 list_add_tail( &package->files, &file->entry );
1415
1416 return ERROR_SUCCESS;
1417 }
1418
1419 static UINT load_all_files(MSIPACKAGE *package)
1420 {
1421 MSIQUERY * view;
1422 UINT rc;
1423 static const WCHAR Query[] =
1424 {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1425 '`','F','i','l','e','`',' ', 'O','R','D','E','R',' ','B','Y',' ',
1426 '`','S','e','q','u','e','n','c','e','`', 0};
1427
1428 if (!list_empty(&package->files))
1429 return ERROR_SUCCESS;
1430
1431 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
1432 if (rc != ERROR_SUCCESS)
1433 return ERROR_SUCCESS;
1434
1435 rc = MSI_IterateRecords(view, NULL, load_file, package);
1436 msiobj_release(&view->hdr);
1437
1438 return ERROR_SUCCESS;
1439 }
1440
1441
1442 /*
1443 * I am not doing any of the costing functionality yet.
1444 * Mostly looking at doing the Component and Feature loading
1445 *
1446 * The native MSI does A LOT of modification to tables here. Mostly adding
1447 * a lot of temporary columns to the Feature and Component tables.
1448 *
1449 * note: Native msi also tracks the short filename. But I am only going to
1450 * track the long ones. Also looking at this directory table
1451 * it appears that the directory table does not get the parents
1452 * resolved base on property only based on their entries in the
1453 * directory table.
1454 */
1455 static UINT ACTION_CostInitialize(MSIPACKAGE *package)
1456 {
1457 static const WCHAR szCosting[] =
1458 {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
1459 static const WCHAR szZero[] = { '0', 0 };
1460
1461 if ( 1 == msi_get_property_int( package, szCosting, 0 ) )
1462 return ERROR_SUCCESS;
1463
1464 MSI_SetPropertyW(package, szCosting, szZero);
1465 MSI_SetPropertyW(package, cszRootDrive, c_colon);
1466
1467 load_all_components( package );
1468 load_all_features( package );
1469 load_all_files( package );
1470
1471 return ERROR_SUCCESS;
1472 }
1473
1474 static UINT execute_script(MSIPACKAGE *package, UINT script )
1475 {
1476 int i;
1477 UINT rc = ERROR_SUCCESS;
1478
1479 TRACE("Executing Script %i\n",script);
1480
1481 if (!package->script)
1482 {
1483 ERR("no script!\n");
1484 return ERROR_FUNCTION_FAILED;
1485 }
1486
1487 for (i = 0; i < package->script->ActionCount[script]; i++)
1488 {
1489 LPWSTR action;
1490 action = package->script->Actions[script][i];
1491 ui_actionstart(package, action);
1492 TRACE("Executing Action (%s)\n",debugstr_w(action));
1493 rc = ACTION_PerformAction(package, action, TRUE);
1494 if (rc != ERROR_SUCCESS)
1495 break;
1496 }
1497 msi_free_action_script(package, script);
1498 return rc;
1499 }
1500
1501 static UINT ACTION_FileCost(MSIPACKAGE *package)
1502 {
1503 return ERROR_SUCCESS;
1504 }
1505
1506 static MSIFOLDER *load_folder( MSIPACKAGE *package, LPCWSTR dir )
1507 {
1508 static const WCHAR Query[] =
1509 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1510 '`','D','i','r','e','c', 't','o','r','y','`',' ',
1511 'W','H','E','R','E',' ', '`', 'D','i','r','e','c','t', 'o','r','y','`',
1512 ' ','=',' ','\'','%','s','\'',
1513 0};
1514 static const WCHAR szDot[] = { '.',0 };
1515 static WCHAR szEmpty[] = { 0 };
1516 LPWSTR p, tgt_short, tgt_long, src_short, src_long;
1517 LPCWSTR parent;
1518 MSIRECORD *row;
1519 MSIFOLDER *folder;
1520
1521 TRACE("Looking for dir %s\n",debugstr_w(dir));
1522
1523 folder = get_loaded_folder( package, dir );
1524 if (folder)
1525 return folder;
1526
1527 TRACE("Working to load %s\n",debugstr_w(dir));
1528
1529 folder = msi_alloc_zero( sizeof (MSIFOLDER) );
1530 if (!folder)
1531 return NULL;
1532
1533 folder->Directory = strdupW(dir);
1534
1535 row = MSI_QueryGetRecord(package->db, Query, dir);
1536 if (!row)
1537 return NULL;
1538
1539 p = msi_dup_record_field(row, 3);
1540
1541 /* split src and target dir */
1542 tgt_short = p;
1543 src_short = folder_split_path( p, ':' );
1544
1545 /* split the long and short paths */
1546 tgt_long = folder_split_path( tgt_short, '|' );
1547 src_long = folder_split_path( src_short, '|' );
1548
1549 /* check for no-op dirs */
1550 if (!lstrcmpW(szDot, tgt_short))
1551 tgt_short = szEmpty;
1552 if (!lstrcmpW(szDot, src_short))
1553 src_short = szEmpty;
1554
1555 if (!tgt_long)
1556 tgt_long = tgt_short;
1557
1558 if (!src_short) {
1559 src_short = tgt_short;
1560 src_long = tgt_long;
1561 }
1562
1563 if (!src_long)
1564 src_long = src_short;
1565
1566 /* FIXME: use the target short path too */
1567 folder->TargetDefault = strdupW(tgt_long);
1568 folder->SourceShortPath = strdupW(src_short);
1569 folder->SourceLongPath = strdupW(src_long);
1570 msi_free(p);
1571
1572 TRACE("TargetDefault = %s\n",debugstr_w( folder->TargetDefault ));
1573 TRACE("SourceLong = %s\n", debugstr_w( folder->SourceLongPath ));
1574 TRACE("SourceShort = %s\n", debugstr_w( folder->SourceShortPath ));
1575
1576 parent = MSI_RecordGetString(row, 2);
1577 if (parent)
1578 {
1579 folder->Parent = load_folder( package, parent );
1580 if ( folder->Parent )
1581 TRACE("loaded parent %p %s\n", folder->Parent,
1582 debugstr_w(folder->Parent->Directory));
1583 else
1584 ERR("failed to load parent folder %s\n", debugstr_w(parent));
1585 }
1586
1587 folder->Property = msi_dup_property( package, dir );
1588
1589 msiobj_release(&row->hdr);
1590
1591 list_add_tail( &package->folders, &folder->entry );
1592
1593 TRACE("%s returning %p\n",debugstr_w(dir),folder);
1594
1595 return folder;
1596 }
1597
1598 static void ACTION_GetComponentInstallStates(MSIPACKAGE *package)
1599 {
1600 MSICOMPONENT *comp;
1601
1602 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
1603 {
1604 INSTALLSTATE res;
1605
1606 if (!comp->ComponentId)
1607 continue;
1608
1609 res = MsiGetComponentPathW( package->ProductCode,
1610 comp->ComponentId, NULL, NULL);
1611 if (res < 0)
1612 res = INSTALLSTATE_ABSENT;
1613 comp->Installed = res;
1614 }
1615 }
1616
1617 /* scan for and update current install states */
1618 static void ACTION_UpdateFeatureInstallStates(MSIPACKAGE *package)
1619 {
1620 MSICOMPONENT *comp;
1621 MSIFEATURE *feature;
1622
1623 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1624 {
1625 ComponentList *cl;
1626 INSTALLSTATE res = INSTALLSTATE_ABSENT;
1627
1628 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1629 {
1630 comp= cl->component;
1631
1632 if (!comp->ComponentId)
1633 {
1634 res = INSTALLSTATE_ABSENT;
1635 break;
1636 }
1637
1638 if (res == INSTALLSTATE_ABSENT)
1639 res = comp->Installed;
1640 else
1641 {
1642 if (res == comp->Installed)
1643 continue;
1644
1645 if (res != INSTALLSTATE_DEFAULT || res != INSTALLSTATE_LOCAL ||
1646 res != INSTALLSTATE_SOURCE)
1647 {
1648 res = INSTALLSTATE_INCOMPLETE;
1649 }
1650 }
1651 }
1652 feature->Installed = res;
1653 }
1654 }
1655
1656 static BOOL process_state_property (MSIPACKAGE* package, LPCWSTR property,
1657 INSTALLSTATE state)
1658 {
1659 static const WCHAR all[]={'A','L','L',0};
1660 LPWSTR override;
1661 MSIFEATURE *feature;
1662
1663 override = msi_dup_property( package, property );
1664 if (!override)
1665 return FALSE;
1666
1667 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1668 {
1669 if (strcmpiW(override,all)==0)
1670 msi_feature_set_state( feature, state );
1671 else
1672 {
1673 LPWSTR ptr = override;
1674 LPWSTR ptr2 = strchrW(override,',');
1675
1676 while (ptr)
1677 {
1678 if ((ptr2 && strncmpW(ptr,feature->Feature, ptr2-ptr)==0)
1679 || (!ptr2 && strcmpW(ptr,feature->Feature)==0))
1680 {
1681 msi_feature_set_state( feature, state );
1682 break;
1683 }
1684 if (ptr2)
1685 {
1686 ptr=ptr2+1;
1687 ptr2 = strchrW(ptr,',');
1688 }
1689 else
1690 break;
1691 }
1692 }
1693 }
1694 msi_free(override);
1695
1696 return TRUE;
1697 }
1698
1699 UINT MSI_SetFeatureStates(MSIPACKAGE *package)
1700 {
1701 int install_level;
1702 static const WCHAR szlevel[] =
1703 {'I','N','S','T','A','L','L','L','E','V','E','L',0};
1704 static const WCHAR szAddLocal[] =
1705 {'A','D','D','L','O','C','A','L',0};
1706 static const WCHAR szRemove[] =
1707 {'R','E','M','O','V','E',0};
1708 static const WCHAR szReinstall[] =
1709 {'R','E','I','N','S','T','A','L','L',0};
1710 BOOL override = FALSE;
1711 MSICOMPONENT* component;
1712 MSIFEATURE *feature;
1713
1714
1715 /* I do not know if this is where it should happen.. but */
1716
1717 TRACE("Checking Install Level\n");
1718
1719 install_level = msi_get_property_int( package, szlevel, 1 );
1720
1721 /* ok here is the _real_ rub
1722 * all these activation/deactivation things happen in order and things
1723 * later on the list override things earlier on the list.
1724 * 1) INSTALLLEVEL processing
1725 * 2) ADDLOCAL
1726 * 3) REMOVE
1727 * 4) ADDSOURCE
1728 * 5) ADDDEFAULT
1729 * 6) REINSTALL
1730 * 7) COMPADDLOCAL
1731 * 8) COMPADDSOURCE
1732 * 9) FILEADDLOCAL
1733 * 10) FILEADDSOURCE
1734 * 11) FILEADDDEFAULT
1735 * I have confirmed that if ADDLOCAL is stated then the INSTALLLEVEL is
1736 * ignored for all the features. seems strange, especially since it is not
1737 * documented anywhere, but it is how it works.
1738 *
1739 * I am still ignoring a lot of these. But that is ok for now, ADDLOCAL and
1740 * REMOVE are the big ones, since we don't handle administrative installs
1741 * yet anyway.
1742 */
1743 override |= process_state_property(package,szAddLocal,INSTALLSTATE_LOCAL);
1744 override |= process_state_property(package,szRemove,INSTALLSTATE_ABSENT);
1745 override |= process_state_property(package,szReinstall,INSTALLSTATE_LOCAL);
1746
1747 if (!override)
1748 {
1749 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1750 {
1751 BOOL feature_state = ((feature->Level > 0) &&
1752 (feature->Level <= install_level));
1753
1754 if ((feature_state) && (feature->Action == INSTALLSTATE_UNKNOWN))
1755 {
1756 if (feature->Attributes & msidbFeatureAttributesFavorSource)
1757 msi_feature_set_state( feature, INSTALLSTATE_SOURCE );
1758 else if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
1759 msi_feature_set_state( feature, INSTALLSTATE_ADVERTISED );
1760 else
1761 msi_feature_set_state( feature, INSTALLSTATE_LOCAL );
1762 }
1763 }
1764
1765 /* disable child features of unselected parent features */
1766 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1767 {
1768 FeatureList *fl;
1769
1770 if (feature->Level > 0 && feature->Level <= install_level)
1771 continue;
1772
1773 LIST_FOR_EACH_ENTRY( fl, &feature->Children, FeatureList, entry )
1774 msi_feature_set_state( fl->feature, INSTALLSTATE_UNKNOWN );
1775 }
1776 }
1777 else
1778 {
1779 /* set the Preselected Property */
1780 static const WCHAR szPreselected[] = {'P','r','e','s','e','l','e','c','t','e','d',0};
1781 static const WCHAR szOne[] = { '1', 0 };
1782
1783 MSI_SetPropertyW(package,szPreselected,szOne);
1784 }
1785
1786 /*
1787 * now we want to enable or disable components base on feature
1788 */
1789
1790 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1791 {
1792 ComponentList *cl;
1793
1794 TRACE("Examining Feature %s (Installed %i, Action %i, Request %i)\n",
1795 debugstr_w(feature->Feature), feature->Installed, feature->Action,
1796 feature->ActionRequest);
1797
1798 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1799 {
1800 component = cl->component;
1801
1802 switch (component->Attributes)
1803 {
1804 case msidbComponentAttributesLocalOnly:
1805 msi_component_set_state( component, INSTALLSTATE_LOCAL );
1806 break;
1807 case msidbComponentAttributesSourceOnly:
1808 msi_component_set_state( component, INSTALLSTATE_SOURCE );
1809 break;
1810 case msidbComponentAttributesOptional:
1811 msi_component_set_state( component, INSTALLSTATE_DEFAULT );
1812 break;
1813 default:
1814 msi_component_set_state( component, INSTALLSTATE_LOCAL );
1815 }
1816
1817 if (component->ForceLocalState)
1818 msi_component_set_state( component, INSTALLSTATE_LOCAL );
1819
1820 if (!component->Enabled)
1821 msi_component_set_state( component, INSTALLSTATE_UNKNOWN );
1822 else if (feature->Attributes == msidbFeatureAttributesFavorLocal)
1823 {
1824 if (!(component->Attributes & msidbComponentAttributesSourceOnly))
1825 msi_component_set_state( component, INSTALLSTATE_LOCAL );
1826 }
1827 else if (feature->Attributes == msidbFeatureAttributesFavorSource)
1828 {
1829 if ((component->Action == INSTALLSTATE_UNKNOWN) ||
1830 (component->Action == INSTALLSTATE_ABSENT) ||
1831 (component->Action == INSTALLSTATE_ADVERTISED) ||
1832 (component->Action == INSTALLSTATE_DEFAULT))
1833 msi_component_set_state( component, INSTALLSTATE_SOURCE );
1834 }
1835 else if (feature->ActionRequest == INSTALLSTATE_ADVERTISED)
1836 {
1837 if ((component->Action == INSTALLSTATE_UNKNOWN) ||
1838 (component->Action == INSTALLSTATE_ABSENT))
1839 msi_component_set_state( component, INSTALLSTATE_ADVERTISED );
1840 }
1841 else if (feature->ActionRequest == INSTALLSTATE_ABSENT)
1842 {
1843 if (component->Action == INSTALLSTATE_UNKNOWN)
1844 msi_component_set_state( component, INSTALLSTATE_ABSENT );
1845 }
1846 else if (feature->ActionRequest == INSTALLSTATE_UNKNOWN)
1847 msi_component_set_state( component, INSTALLSTATE_UNKNOWN );
1848
1849 if (component->ForceLocalState && feature->Action == INSTALLSTATE_SOURCE)
1850 msi_feature_set_state( feature, INSTALLSTATE_LOCAL );
1851 }
1852 }
1853
1854 LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
1855 {
1856 TRACE("Result: Component %s (Installed %i, Action %i, Request %i)\n",
1857 debugstr_w(component->Component), component->Installed,
1858 component->Action, component->ActionRequest);
1859 }
1860
1861
1862 return ERROR_SUCCESS;
1863 }
1864
1865 static UINT ITERATE_CostFinalizeDirectories(MSIRECORD *row, LPVOID param)
1866 {
1867 MSIPACKAGE *package = (MSIPACKAGE*)param;
1868 LPCWSTR name;
1869 LPWSTR path;
1870
1871 name = MSI_RecordGetString(row,1);
1872
1873 /* This helper function now does ALL the work */
1874 TRACE("Dir %s ...\n",debugstr_w(name));
1875 load_folder(package,name);
1876 path = resolve_folder(package,name,FALSE,TRUE,NULL);
1877 TRACE("resolves to %s\n",debugstr_w(path));
1878 msi_free(path);
1879
1880 return ERROR_SUCCESS;
1881 }
1882
1883 static UINT ITERATE_CostFinalizeConditions(MSIRECORD *row, LPVOID param)
1884 {
1885 MSIPACKAGE *package = (MSIPACKAGE*)param;
1886 LPCWSTR name;
1887 MSIFEATURE *feature;
1888
1889 name = MSI_RecordGetString( row, 1 );
1890
1891 feature = get_loaded_feature( package, name );
1892 if (!feature)
1893 ERR("FAILED to find loaded feature %s\n",debugstr_w(name));
1894 else
1895 {
1896 LPCWSTR Condition;
1897 Condition = MSI_RecordGetString(row,3);
1898
1899 if (MSI_EvaluateConditionW(package,Condition) == MSICONDITION_TRUE)
1900 {
1901 int level = MSI_RecordGetInteger(row,2);
1902 TRACE("Reseting feature %s to level %i\n", debugstr_w(name), level);
1903 feature->Level = level;
1904 }
1905 }
1906 return ERROR_SUCCESS;
1907 }
1908
1909 LPWSTR msi_get_disk_file_version( LPCWSTR filename )
1910 {
1911 static const WCHAR name_fmt[] =
1912 {'%','u','.','%','u','.','%','u','.','%','u',0};
1913 static WCHAR name[] = {'\\',0};
1914 VS_FIXEDFILEINFO *lpVer;
1915 WCHAR filever[0x100];
1916 LPVOID version;
1917 DWORD versize;
1918 DWORD handle;
1919 UINT sz;
1920
1921 TRACE("%s\n", debugstr_w(filename));
1922
1923 versize = GetFileVersionInfoSizeW( filename, &handle );
1924 if (!versize)
1925 return NULL;
1926
1927 version = msi_alloc( versize );
1928 GetFileVersionInfoW( filename, 0, versize, version );
1929
1930 VerQueryValueW( version, name, (LPVOID*)&lpVer, &sz );
1931 msi_free( version );
1932
1933 sprintfW( filever, name_fmt,
1934 HIWORD(lpVer->dwFileVersionMS),
1935 LOWORD(lpVer->dwFileVersionMS),
1936 HIWORD(lpVer->dwFileVersionLS),
1937 LOWORD(lpVer->dwFileVersionLS));
1938
1939 return strdupW( filever );
1940 }
1941
1942 /*
1943 * A lot is done in this function aside from just the costing.
1944 * The costing needs to be implemented at some point but for now I am going
1945 * to focus on the directory building
1946 *
1947 */
1948 static UINT ACTION_CostFinalize(MSIPACKAGE *package)
1949 {
1950 static const WCHAR ExecSeqQuery[] =
1951 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1952 '`','D','i','r','e','c','t','o','r','y','`',0};
1953 static const WCHAR ConditionQuery[] =
1954 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1955 '`','C','o','n','d','i','t','i','o','n','`',0};
1956 static const WCHAR szCosting[] =
1957 {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
1958 static const WCHAR szlevel[] =
1959 {'I','N','S','T','A','L','L','L','E','V','E','L',0};
1960 static const WCHAR szOne[] = { '1', 0 };
1961 MSICOMPONENT *comp;
1962 MSIFILE *file;
1963 UINT rc;
1964 MSIQUERY * view;
1965 LPWSTR level, file_version;
1966
1967 if ( 1 == msi_get_property_int( package, szCosting, 0 ) )
1968 return ERROR_SUCCESS;
1969
1970 TRACE("Building Directory properties\n");
1971
1972 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
1973 if (rc == ERROR_SUCCESS)
1974 {
1975 rc = MSI_IterateRecords(view, NULL, ITERATE_CostFinalizeDirectories,
1976 package);
1977 msiobj_release(&view->hdr);
1978 }
1979
1980 /* read components states from the registry */
1981 ACTION_GetComponentInstallStates(package);
1982
1983 TRACE("File calculations\n");
1984
1985 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
1986 {
1987 MSICOMPONENT* comp = file->Component;
1988 LPWSTR p;
1989
1990 if (!comp)
1991 continue;
1992
1993 if (file->IsCompressed)
1994 comp->ForceLocalState = TRUE;
1995
1996 /* calculate target */
1997 p = resolve_folder(package, comp->Directory, FALSE, FALSE, NULL);
1998
1999 msi_free(file->TargetPath);
2000
2001 TRACE("file %s is named %s\n",
2002 debugstr_w(file->File), debugstr_w(file->FileName));
2003
2004 file->TargetPath = build_directory_name(2, p, file->FileName);
2005
2006 msi_free(p);
2007
2008 TRACE("file %s resolves to %s\n",
2009 debugstr_w(file->File), debugstr_w(file->TargetPath));
2010
2011 /* don't check files of components that aren't installed */
2012 if (comp->Installed == INSTALLSTATE_UNKNOWN ||
2013 comp->Installed == INSTALLSTATE_ABSENT)
2014 {
2015 file->state = msifs_missing; /* assume files are missing */
2016 continue;
2017 }
2018
2019 if (GetFileAttributesW(file->TargetPath) == INVALID_FILE_ATTRIBUTES)
2020 {
2021 file->state = msifs_missing;
2022 comp->Cost += file->FileSize;
2023 comp->Installed = INSTALLSTATE_INCOMPLETE;
2024 continue;
2025 }
2026
2027 if (file->Version &&
2028 (file_version = msi_get_disk_file_version( file->TargetPath )))
2029 {
2030 TRACE("new %s old %s\n", debugstr_w(file->Version),
2031 debugstr_w(file_version));
2032 /* FIXME: seems like a bad way to compare version numbers */
2033 if (lstrcmpiW(file_version, file->Version)<0)
2034 {
2035 file->state = msifs_overwrite;
2036 comp->Cost += file->FileSize;
2037 comp->Installed = INSTALLSTATE_INCOMPLETE;
2038 }
2039 else
2040 file->state = msifs_present;
2041 msi_free( file_version );
2042 }
2043 else
2044 file->state = msifs_present;
2045 }
2046
2047 TRACE("Evaluating Condition Table\n");
2048
2049 rc = MSI_DatabaseOpenViewW(package->db, ConditionQuery, &view);
2050 if (rc == ERROR_SUCCESS)
2051 {
2052 rc = MSI_IterateRecords(view, NULL, ITERATE_CostFinalizeConditions,
2053 package);
2054 msiobj_release(&view->hdr);
2055 }
2056
2057 TRACE("Enabling or Disabling Components\n");
2058 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2059 {
2060 if (MSI_EvaluateConditionW(package, comp->Condition) == MSICONDITION_FALSE)
2061 {
2062 TRACE("Disabling component %s\n", debugstr_w(comp->Component));
2063 comp->Enabled = FALSE;
2064 }
2065 }
2066
2067 MSI_SetPropertyW(package,szCosting,szOne);
2068 /* set default run level if not set */
2069 level = msi_dup_property( package, szlevel );
2070 if (!level)
2071 MSI_SetPropertyW(package,szlevel, szOne);
2072 msi_free(level);
2073
2074 ACTION_UpdateFeatureInstallStates(package);
2075
2076 return MSI_SetFeatureStates(package);
2077 }
2078
2079 /* OK this value is "interpreted" and then formatted based on the
2080 first few characters */
2081 static LPSTR parse_value(MSIPACKAGE *package, LPCWSTR value, DWORD *type,
2082 DWORD *size)
2083 {
2084 LPSTR data = NULL;
2085 if (value[0]=='#' && value[1]!='#' && value[1]!='%')
2086 {
2087 if (value[1]=='x')
2088 {
2089 LPWSTR ptr;
2090 CHAR byte[5];
2091 LPWSTR deformated = NULL;
2092 int count;
2093
2094 deformat_string(package, &value[2], &deformated);
2095
2096 /* binary value type */
2097 ptr = deformated;
2098 *type = REG_BINARY;
2099 if (strlenW(ptr)%2)
2100 *size = (strlenW(ptr)/2)+1;
2101 else
2102 *size = strlenW(ptr)/2;
2103
2104 data = msi_alloc(*size);
2105
2106 byte[0] = '0';
2107 byte[1] = 'x';
2108 byte[4] = 0;
2109 count = 0;
2110 /* if uneven pad with a zero in front */
2111 if (strlenW(ptr)%2)
2112 {
2113 byte[2]= '0';
2114 byte[3]= *ptr;
2115 ptr++;
2116 data[count] = (BYTE)strtol(byte,NULL,0);
2117 count ++;
2118 TRACE("Uneven byte count\n");
2119 }
2120 while (*ptr)
2121 {
2122 byte[2]= *ptr;
2123 ptr++;
2124 byte[3]= *ptr;
2125 ptr++;
2126 data[count] = (BYTE)strtol(byte,NULL,0);
2127 count ++;
2128 }
2129 msi_free(deformated);
2130
2131 TRACE("Data %i bytes(%i)\n",*size,count);
2132 }
2133 else
2134 {
2135 LPWSTR deformated;
2136 LPWSTR p;
2137 DWORD d = 0;
2138 deformat_string(package, &value[1], &deformated);
2139
2140 *type=REG_DWORD;
2141 *size = sizeof(DWORD);
2142 data = msi_alloc(*size);
2143 p = deformated;
2144 if (*p == '-')
2145 p++;
2146 while (*p)
2147 {
2148 if ( (*p < '0') || (*p > '9') )
2149 break;
2150 d *= 10;
2151 d += (*p - '0');
2152 p++;
2153 }
2154 if (deformated[0] == '-')
2155 d = -d;
2156 *(LPDWORD)data = d;
2157 TRACE("DWORD %i\n",*(LPDWORD)data);
2158
2159 msi_free(deformated);
2160 }
2161 }
2162 else
2163 {
2164 static const WCHAR szMulti[] = {'[','~',']',0};
2165 LPCWSTR ptr;
2166 *type=REG_SZ;
2167
2168 if (value[0]=='#')
2169 {
2170 if (value[1]=='%')
2171 {
2172 ptr = &value[2];
2173 *type=REG_EXPAND_SZ;
2174 }
2175 else
2176 ptr = &value[1];
2177 }
2178 else
2179 ptr=value;
2180
2181 if (strstrW(value,szMulti))
2182 *type = REG_MULTI_SZ;
2183
2184 *size = deformat_string(package, ptr,(LPWSTR*)&data);
2185 }
2186 return data;
2187 }
2188
2189 static UINT ITERATE_WriteRegistryValues(MSIRECORD *row, LPVOID param)
2190 {
2191 MSIPACKAGE *package = (MSIPACKAGE*)param;
2192 static const WCHAR szHCR[] =
2193 {'H','K','E','Y','_','C','L','A','S','S','E','S','_',
2194 'R','O','O','T','\\',0};
2195 static const WCHAR szHCU[] =
2196 {'H','K','E','Y','_','C','U','R','R','E','N','T','_',
2197 'U','S','E','R','\\',0};
2198 static const WCHAR szHLM[] =
2199 {'H','K','E','Y','_','L','O','C','A','L','_',
2200 'M','A','C','H','I','N','E','\\',0};
2201 static const WCHAR szHU[] =
2202 {'H','K','E','Y','_','U','S','E','R','S','\\',0};
2203
2204 LPSTR value_data = NULL;
2205 HKEY root_key, hkey;
2206 DWORD type,size;
2207 LPWSTR deformated;
2208 LPCWSTR szRoot, component, name, key, value;
2209 MSICOMPONENT *comp;
2210 MSIRECORD * uirow;
2211 LPWSTR uikey;
2212 INT root;
2213 BOOL check_first = FALSE;
2214 UINT rc;
2215
2216 ui_progress(package,2,0,0,0);
2217
2218 value = NULL;
2219 key = NULL;
2220 uikey = NULL;
2221 name = NULL;
2222
2223 component = MSI_RecordGetString(row, 6);
2224 comp = get_loaded_component(package,component);
2225 if (!comp)
2226 return ERROR_SUCCESS;
2227
2228 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2229 {
2230 TRACE("Skipping write due to disabled component %s\n",
2231 debugstr_w(component));
2232
2233 comp->Action = comp->Installed;
2234
2235 return ERROR_SUCCESS;
2236 }
2237
2238 comp->Action = INSTALLSTATE_LOCAL;
2239
2240 name = MSI_RecordGetString(row, 4);
2241 if( MSI_RecordIsNull(row,5) && name )
2242 {
2243 /* null values can have special meanings */
2244 if (name[0]=='-' && name[1] == 0)
2245 return ERROR_SUCCESS;
2246 else if ((name[0]=='+' && name[1] == 0) ||
2247 (name[0] == '*' && name[1] == 0))
2248 name = NULL;
2249 check_first = TRUE;
2250 }
2251
2252 root = MSI_RecordGetInteger(row,2);
2253 key = MSI_RecordGetString(row, 3);
2254
2255 /* get the root key */
2256 switch (root)
2257 {
2258 case -1:
2259 {
2260 static const WCHAR szALLUSER[] = {'A','L','L','U','S','E','R','S',0};
2261 LPWSTR all_users = msi_dup_property( package, szALLUSER );
2262 if (all_users && all_users[0] == '1')
2263 {
2264 root_key = HKEY_LOCAL_MACHINE;
2265 szRoot = szHLM;
2266 }
2267 else
2268 {
2269 root_key = HKEY_CURRENT_USER;
2270 szRoot = szHCU;
2271 }
2272 msi_free(all_users);
2273 }
2274 break;
2275 case 0: root_key = HKEY_CLASSES_ROOT;
2276 szRoot = szHCR;
2277 break;
2278 case 1: root_key = HKEY_CURRENT_USER;
2279 szRoot = szHCU;
2280 break;
2281 case 2: root_key = HKEY_LOCAL_MACHINE;
2282 szRoot = szHLM;
2283 break;
2284 case 3: root_key = HKEY_USERS;
2285 szRoot = szHU;
2286 break;
2287 default:
2288 ERR("Unknown root %i\n",root);
2289 root_key=NULL;
2290 szRoot = NULL;
2291 break;
2292 }
2293 if (!root_key)
2294 return ERROR_SUCCESS;
2295
2296 deformat_string(package, key , &deformated);
2297 size = strlenW(deformated) + strlenW(szRoot) + 1;
2298 uikey = msi_alloc(size*sizeof(WCHAR));
2299 strcpyW(uikey,szRoot);
2300 strcatW(uikey,deformated);
2301
2302 if (RegCreateKeyW( root_key, deformated, &hkey))
2303 {
2304 ERR("Could not create key %s\n",debugstr_w(deformated));
2305 msi_free(deformated);
2306 msi_free(uikey);
2307 return ERROR_SUCCESS;
2308 }
2309 msi_free(deformated);
2310
2311 value = MSI_RecordGetString(row,5);
2312 if (value)
2313 value_data = parse_value(package, value, &type, &size);
2314 else
2315 {
2316 static const WCHAR szEmpty[] = {0};
2317 value_data = (LPSTR)strdupW(szEmpty);
2318 size = 0;
2319 type = REG_SZ;
2320 }
2321
2322 deformat_string(package, name, &deformated);
2323
2324 /* get the double nulls to terminate SZ_MULTI */
2325 if (type == REG_MULTI_SZ)
2326 size +=sizeof(WCHAR);
2327
2328 if (!check_first)
2329 {
2330 TRACE("Setting value %s of %s\n",debugstr_w(deformated),
2331 debugstr_w(uikey));
2332 RegSetValueExW(hkey, deformated, 0, type, (LPBYTE)value_data, size);
2333 }
2334 else
2335 {
2336 DWORD sz = 0;
2337 rc = RegQueryValueExW(hkey, deformated, NULL, NULL, NULL, &sz);
2338 if (rc == ERROR_SUCCESS || rc == ERROR_MORE_DATA)
2339 {
2340 TRACE("value %s of %s checked already exists\n",
2341 debugstr_w(deformated), debugstr_w(uikey));
2342 }
2343 else
2344 {
2345 TRACE("Checked and setting value %s of %s\n",
2346 debugstr_w(deformated), debugstr_w(uikey));
2347 if (deformated || size)
2348 RegSetValueExW(hkey, deformated, 0, type, (LPBYTE) value_data, size);
2349 }
2350 }
2351 RegCloseKey(hkey);
2352
2353 uirow = MSI_CreateRecord(3);
2354 MSI_RecordSetStringW(uirow,2,deformated);
2355 MSI_RecordSetStringW(uirow,1,uikey);
2356
2357 if (type == REG_SZ)
2358 MSI_RecordSetStringW(uirow,3,(LPWSTR)value_data);
2359 else
2360 MSI_RecordSetStringW(uirow,3,value);
2361
2362 ui_actiondata(package,szWriteRegistryValues,uirow);
2363 msiobj_release( &uirow->hdr );
2364
2365 msi_free(value_data);
2366 msi_free(deformated);
2367 msi_free(uikey);
2368
2369 return ERROR_SUCCESS;
2370 }
2371
2372 static UINT ACTION_WriteRegistryValues(MSIPACKAGE *package)
2373 {
2374 UINT rc;
2375 MSIQUERY * view;
2376 static const WCHAR ExecSeqQuery[] =
2377 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2378 '`','R','e','g','i','s','t','r','y','`',0 };
2379
2380 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2381 if (rc != ERROR_SUCCESS)
2382 return ERROR_SUCCESS;
2383
2384 /* increment progress bar each time action data is sent */
2385 ui_progress(package,1,REG_PROGRESS_VALUE,1,0);
2386
2387 rc = MSI_IterateRecords(view, NULL, ITERATE_WriteRegistryValues, package);
2388
2389 msiobj_release(&view->hdr);
2390 return rc;
2391 }
2392
2393 static UINT ACTION_InstallInitialize(MSIPACKAGE *package)
2394 {
2395 package->script->CurrentlyScripting = TRUE;
2396
2397 return ERROR_SUCCESS;
2398 }
2399
2400
2401 static UINT ACTION_InstallValidate(MSIPACKAGE *package)
2402 {
2403 MSICOMPONENT *comp;
2404 DWORD progress = 0;
2405 DWORD total = 0;
2406 static const WCHAR q1[]=
2407 {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
2408 '`','R','e','g','i','s','t','r','y','`',0};
2409 UINT rc;
2410 MSIQUERY * view;
2411 MSIFEATURE *feature;
2412 MSIFILE *file;
2413
2414 TRACE("InstallValidate\n");
2415
2416 rc = MSI_DatabaseOpenViewW(package->db, q1, &view);
2417 if (rc == ERROR_SUCCESS)
2418 {
2419 MSI_IterateRecords( view, &progress, NULL, package );
2420 msiobj_release( &view->hdr );
2421 total += progress * REG_PROGRESS_VALUE;
2422 }
2423
2424 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2425 total += COMPONENT_PROGRESS_VALUE;
2426
2427 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2428 total += file->FileSize;
2429
2430 ui_progress(package,0,total,0,0);
2431
2432 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2433 {
2434 TRACE("Feature: %s; Installed: %i; Action %i; Request %i\n",
2435 debugstr_w(feature->Feature), feature->Installed, feature->Action,
2436 feature->ActionRequest);
2437 }
2438
2439 return ERROR_SUCCESS;
2440 }
2441
2442 static UINT ITERATE_LaunchConditions(MSIRECORD *row, LPVOID param)
2443 {
2444 MSIPACKAGE* package = (MSIPACKAGE*)param;
2445 LPCWSTR cond = NULL;
2446 LPCWSTR message = NULL;
2447 static const WCHAR title[]=
2448 {'I','n','s','t','a','l','l',' ','F','a', 'i','l','e','d',0};
2449
2450 cond = MSI_RecordGetString(row,1);
2451
2452 if (MSI_EvaluateConditionW(package,cond) != MSICONDITION_TRUE)
2453 {
2454 LPWSTR deformated;
2455 message = MSI_RecordGetString(row,2);
2456 deformat_string(package,message,&deformated);
2457 MessageBoxW(NULL,deformated,title,MB_OK);
2458 msi_free(deformated);
2459 return ERROR_FUNCTION_FAILED;
2460 }
2461
2462 return ERROR_SUCCESS;
2463 }
2464
2465 static UINT ACTION_LaunchConditions(MSIPACKAGE *package)
2466 {
2467 UINT rc;
2468 MSIQUERY * view = NULL;
2469 static const WCHAR ExecSeqQuery[] =
2470 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2471 '`','L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','`',0};
2472
2473 TRACE("Checking launch conditions\n");
2474
2475 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2476 if (rc != ERROR_SUCCESS)
2477 return ERROR_SUCCESS;
2478
2479 rc = MSI_IterateRecords(view, NULL, ITERATE_LaunchConditions, package);
2480 msiobj_release(&view->hdr);
2481
2482 return rc;
2483 }
2484
2485 static LPWSTR resolve_keypath( MSIPACKAGE* package, MSICOMPONENT *cmp )
2486 {
2487
2488 if (!cmp->KeyPath)
2489 return resolve_folder(package,cmp->Directory,FALSE,FALSE,NULL);
2490
2491 if (cmp->Attributes & msidbComponentAttributesRegistryKeyPath)
2492 {
2493 MSIRECORD * row = 0;
2494 UINT root,len;
2495 LPWSTR deformated,buffer,deformated_name;
2496 LPCWSTR key,name;
2497 static const WCHAR ExecSeqQuery[] =
2498 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2499 '`','R','e','g','i','s','t','r','y','`',' ',
2500 'W','H','E','R','E',' ', '`','R','e','g','i','s','t','r','y','`',
2501 ' ','=',' ' ,'\'','%','s','\'',0 };
2502 static const WCHAR fmt[]={'%','0','2','i',':','\\','%','s','\\',0};
2503 static const WCHAR fmt2[]=
2504 {'%','0','2','i',':','\\','%','s','\\','%','s',0};
2505
2506 row = MSI_QueryGetRecord(package->db, ExecSeqQuery,cmp->KeyPath);
2507 if (!row)
2508 return NULL;
2509
2510 root = MSI_RecordGetInteger(row,2);
2511 key = MSI_RecordGetString(row, 3);
2512 name = MSI_RecordGetString(row, 4);
2513 deformat_string(package, key , &deformated);
2514 deformat_string(package, name, &deformated_name);
2515
2516 len = strlenW(deformated) + 6;
2517 if (deformated_name)
2518 len+=strlenW(deformated_name);
2519
2520 buffer = msi_alloc( len *sizeof(WCHAR));
2521
2522 if (deformated_name)
2523 sprintfW(buffer,fmt2,root,deformated,deformated_name);
2524 else
2525 sprintfW(buffer,fmt,root,deformated);
2526
2527 msi_free(deformated);
2528 msi_free(deformated_name);
2529 msiobj_release(&row->hdr);
2530
2531 return buffer;
2532 }
2533 else if (cmp->Attributes & msidbComponentAttributesODBCDataSource)
2534 {
2535 FIXME("UNIMPLEMENTED keypath as ODBC Source\n");
2536 return NULL;
2537 }
2538 else
2539 {
2540 MSIFILE *file = get_loaded_file( package, cmp->KeyPath );
2541
2542 if (file)
2543 return strdupW( file->TargetPath );
2544 }
2545 return NULL;
2546 }
2547
2548 static HKEY openSharedDLLsKey(void)
2549 {
2550 HKEY hkey=0;
2551 static const WCHAR path[] =
2552 {'S','o','f','t','w','a','r','e','\\',
2553 'M','i','c','r','o','s','o','f','t','\\',
2554 'W','i','n','d','o','w','s','\\',
2555 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
2556 'S','h','a','r','e','d','D','L','L','s',0};
2557
2558 RegCreateKeyW(HKEY_LOCAL_MACHINE,path,&hkey);
2559 return hkey;
2560 }
2561
2562 static UINT ACTION_GetSharedDLLsCount(LPCWSTR dll)
2563 {
2564 HKEY hkey;
2565 DWORD count=0;
2566 DWORD type;
2567 DWORD sz = sizeof(count);
2568 DWORD rc;
2569
2570 hkey = openSharedDLLsKey();
2571 rc = RegQueryValueExW(hkey, dll, NULL, &type, (LPBYTE)&count, &sz);
2572 if (rc != ERROR_SUCCESS)
2573 count = 0;
2574 RegCloseKey(hkey);
2575 return count;
2576 }
2577
2578 static UINT ACTION_WriteSharedDLLsCount(LPCWSTR path, UINT count)
2579 {
2580 HKEY hkey;
2581
2582 hkey = openSharedDLLsKey();
2583 if (count > 0)
2584 msi_reg_set_val_dword( hkey, path, count );
2585 else
2586 RegDeleteValueW(hkey,path);
2587 RegCloseKey(hkey);
2588 return count;
2589 }
2590
2591 /*
2592 * Return TRUE if the count should be written out and FALSE if not
2593 */
2594 static void ACTION_RefCountComponent( MSIPACKAGE* package, MSICOMPONENT *comp )
2595 {
2596 MSIFEATURE *feature;
2597 INT count = 0;
2598 BOOL write = FALSE;
2599
2600 /* only refcount DLLs */
2601 if (comp->KeyPath == NULL ||
2602 comp->Attributes & msidbComponentAttributesRegistryKeyPath ||
2603 comp->Attributes & msidbComponentAttributesODBCDataSource)
2604 write = FALSE;
2605 else
2606 {
2607 count = ACTION_GetSharedDLLsCount( comp->FullKeypath);
2608 write = (count > 0);
2609
2610 if (comp->Attributes & msidbComponentAttributesSharedDllRefCount)
2611 write = TRUE;
2612 }
2613
2614 /* increment counts */
2615 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2616 {
2617 ComponentList *cl;
2618
2619 if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_LOCAL ))
2620 continue;
2621
2622 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
2623 {
2624 if ( cl->component == comp )
2625 count++;
2626 }
2627 }
2628
2629 /* decrement counts */
2630 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2631 {
2632 ComponentList *cl;
2633
2634 if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_ABSENT ))
2635 continue;
2636
2637 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
2638 {
2639 if ( cl->component == comp )
2640 count--;
2641 }
2642 }
2643
2644 /* ref count all the files in the component */
2645 if (write)
2646 {
2647 MSIFILE *file;
2648
2649 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2650 {
2651 if (file->Component == comp)
2652 ACTION_WriteSharedDLLsCount( file->TargetPath, count );
2653 }
2654 }
2655
2656 /* add a count for permenent */
2657 if (comp->Attributes & msidbComponentAttributesPermanent)
2658 count ++;
2659
2660 comp->RefCount = count;
2661
2662 if (write)
2663 ACTION_WriteSharedDLLsCount( comp->FullKeypath, comp->RefCount );
2664 }
2665
2666 /*
2667 * Ok further analysis makes me think that this work is
2668 * actually done in the PublishComponents and PublishFeatures
2669 * step, and not here. It appears like the keypath and all that is
2670 * resolved in this step, however actually written in the Publish steps.
2671 * But we will leave it here for now because it is unclear
2672 */
2673 static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
2674 {
2675 WCHAR squished_pc[GUID_SIZE];
2676 WCHAR squished_cc[GUID_SIZE];
2677 UINT rc;
2678 MSICOMPONENT *comp;
2679 HKEY hkey=0,hkey2=0;
2680
2681 /* writes the Component and Features values to the registry */
2682
2683 rc = MSIREG_OpenComponents(&hkey);
2684 if (rc != ERROR_SUCCESS)
2685 return rc;
2686
2687 squash_guid(package->ProductCode,squished_pc);
2688 ui_progress(package,1,COMPONENT_PROGRESS_VALUE,1,0);
2689
2690 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2691 {
2692 MSIRECORD * uirow;
2693
2694 ui_progress(package,2,0,0,0);
2695 if (!comp->ComponentId)
2696 continue;
2697
2698 squash_guid(comp->ComponentId,squished_cc);
2699
2700 msi_free(comp->FullKeypath);
2701 comp->FullKeypath = resolve_keypath( package, comp );
2702
2703 /* do the refcounting */
2704 ACTION_RefCountComponent( package, comp );
2705
2706 TRACE("Component %s (%s), Keypath=%s, RefCount=%i\n",
2707 debugstr_w(comp->Component),
2708 debugstr_w(squished_cc),
2709 debugstr_w(comp->FullKeypath),
2710 comp->RefCount);
2711 /*
2712 * Write the keypath out if the component is to be registered
2713 * and delete the key if the component is to be deregistered
2714 */
2715 if (ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2716 {
2717 rc = RegCreateKeyW(hkey,squished_cc,&hkey2);
2718 if (rc != ERROR_SUCCESS)
2719 continue;
2720
2721 if (!comp->FullKeypath)
2722 continue;
2723
2724 msi_reg_set_val_str( hkey2, squished_pc, comp->FullKeypath );
2725
2726 if (comp->Attributes & msidbComponentAttributesPermanent)
2727 {
2728 static const WCHAR szPermKey[] =
2729 { '0','0','0','0','0','0','0','0','0','0','0','0',
2730 '0','0','0','0','0','0','0','0','0','0','0','0',
2731 '0','0','0','0','0','0','0','0',0 };
2732
2733 msi_reg_set_val_str( hkey2, szPermKey, comp->FullKeypath );
2734 }
2735
2736 RegCloseKey(hkey2);
2737
2738 /* UI stuff */
2739 uirow = MSI_CreateRecord(3);
2740 MSI_RecordSetStringW(uirow,1,package->ProductCode);
2741 MSI_RecordSetStringW(uirow,2,comp->ComponentId);
2742 MSI_RecordSetStringW(uirow,3,comp->FullKeypath);
2743 ui_actiondata(package,szProcessComponents,uirow);
2744 msiobj_release( &uirow->hdr );
2745 }
2746 else if (ACTION_VerifyComponentForAction( comp, INSTALLSTATE_ABSENT))
2747 {
2748 DWORD res;
2749
2750 rc = RegOpenKeyW(hkey,squished_cc,&hkey2);
2751 if (rc != ERROR_SUCCESS)
2752 continue;
2753
2754 RegDeleteValueW(hkey2,squished_pc);
2755
2756 /* if the key is empty delete it */
2757 res = RegEnumKeyExW(hkey2,0,NULL,0,0,NULL,0,NULL);
2758 RegCloseKey(hkey2);
2759 if (res == ERROR_NO_MORE_ITEMS)
2760 RegDeleteKeyW(hkey,squished_cc);
2761
2762 /* UI stuff */
2763 uirow = MSI_CreateRecord(2);
2764 MSI_RecordSetStringW(uirow,1,package->ProductCode);
2765 MSI_RecordSetStringW(uirow,2,comp->ComponentId);
2766 ui_actiondata(package,szProcessComponents,uirow);
2767 msiobj_release( &uirow->hdr );
2768 }
2769 }
2770 RegCloseKey(hkey);
2771 return rc;
2772 }
2773
2774 typedef struct {
2775 CLSID clsid;
2776 LPWSTR source;
2777
2778 LPWSTR path;
2779 ITypeLib *ptLib;
2780 } typelib_struct;
2781
2782 static BOOL CALLBACK Typelib_EnumResNameProc( HMODULE hModule, LPCWSTR lpszType,
2783 LPWSTR lpszName, LONG_PTR lParam)
2784 {
2785 TLIBATTR *attr;
2786 typelib_struct *tl_struct = (typelib_struct*) lParam;
2787 static const WCHAR fmt[] = {'%','s','\\','%','i',0};
2788 int sz;
2789 HRESULT res;
2790
2791 if (!IS_INTRESOURCE(lpszName))
2792 {
2793 ERR("Not Int Resource Name %s\n",debugstr_w(lpszName));
2794 return TRUE;
2795 }
2796
2797 sz = strlenW(tl_struct->source)+4;
2798 sz *= sizeof(WCHAR);
2799
2800 if ((INT_PTR)lpszName == 1)
2801 tl_struct->path = strdupW(tl_struct->source);
2802 else
2803 {
2804 tl_struct->path = msi_alloc(sz);
2805 sprintfW(tl_struct->path,fmt,tl_struct->source, lpszName);
2806 }
2807
2808 TRACE("trying %s\n", debugstr_w(tl_struct->path));
2809 res = LoadTypeLib(tl_struct->path,&tl_struct->ptLib);
2810 if (!SUCCEEDED(res))
2811 {
2812 msi_free(tl_struct->path);
2813 tl_struct->path = NULL;
2814
2815 return TRUE;
2816 }
2817
2818 ITypeLib_GetLibAttr(tl_struct->ptLib, &attr);
2819 if (IsEqualGUID(&(tl_struct->clsid),&(attr->guid)))
2820 {
2821 ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
2822 return FALSE;
2823 }
2824
2825 msi_free(tl_struct->path);
2826 tl_struct->path = NULL;
2827
2828 ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
2829 ITypeLib_Release(tl_struct->ptLib);
2830
2831 return TRUE;
2832 }
2833
2834 static UINT ITERATE_RegisterTypeLibraries(MSIRECORD *row, LPVOID param)
2835 {
2836 MSIPACKAGE* package = (MSIPACKAGE*)param;
2837 LPCWSTR component;
2838 MSICOMPONENT *comp;
2839 MSIFILE *file;
2840 typelib_struct tl_struct;
2841 HMODULE module;
2842 static const WCHAR szTYPELIB[] = {'T','Y','P','E','L','I','B',0};
2843
2844 component = MSI_RecordGetString(row,3);
2845 comp = get_loaded_component(package,component);
2846 if (!comp)
2847 return ERROR_SUCCESS;
2848
2849 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2850 {
2851 TRACE("Skipping typelib reg due to disabled component\n");
2852
2853 comp->Action = comp->Installed;
2854
2855 return ERROR_SUCCESS;
2856 }
2857
2858 comp->Action = INSTALLSTATE_LOCAL;
2859
2860 file = get_loaded_file( package, comp->KeyPath );
2861 if (!file)
2862 return ERROR_SUCCESS;
2863
2864 module = LoadLibraryExW( file->TargetPath, NULL, LOAD_LIBRARY_AS_DATAFILE );
2865 if (module)
2866 {
2867 LPCWSTR guid;
2868 guid = MSI_RecordGetString(row,1);
2869 CLSIDFromString((LPWSTR)guid, &tl_struct.clsid);
2870 tl_struct.source = strdupW( file->TargetPath );
2871 tl_struct.path = NULL;
2872
2873 EnumResourceNamesW(module, szTYPELIB, Typelib_EnumResNameProc,
2874 (LONG_PTR)&tl_struct);
2875
2876 if (tl_struct.path)
2877 {
2878 LPWSTR help = NULL;
2879 LPCWSTR helpid;
2880 HRESULT res;
2881
2882 helpid = MSI_RecordGetString(row,6);
2883
2884 if (helpid)
2885 help = resolve_folder(package,helpid,FALSE,FALSE,NULL);
2886 res = RegisterTypeLib(tl_struct.ptLib,tl_struct.path,help);
2887 msi_free(help);
2888
2889 if (!SUCCEEDED(res))
2890 ERR("Failed to register type library %s\n",
2891 debugstr_w(tl_struct.path));
2892 else
2893 {
2894 ui_actiondata(package,szRegisterTypeLibraries,row);
2895
2896 TRACE("Registered %s\n", debugstr_w(tl_struct.path));
2897 }
2898
2899 ITypeLib_Release(tl_struct.ptLib);
2900 msi_free(tl_struct.path);
2901 }
2902 else
2903 ERR("Failed to load type library %s\n",
2904 debugstr_w(tl_struct.source));
2905
2906 FreeLibrary(module);
2907 msi_free(tl_struct.source);
2908 }
2909 else
2910 ERR("Could not load file! %s\n", debugstr_w(file->TargetPath));
2911
2912 return ERROR_SUCCESS;
2913 }
2914
2915 static UINT ACTION_RegisterTypeLibraries(MSIPACKAGE *package)
2916 {
2917 /*
2918 * OK this is a bit confusing.. I am given a _Component key and I believe
2919 * that the file that is being registered as a type library is the "key file
2920 * of that component" which I interpret to mean "The file in the KeyPath of
2921 * that component".
2922 */
2923 UINT rc;
2924 MSIQUERY * view;
2925 static const WCHAR Query[] =
2926 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2927 '`','T','y','p','e','L','i','b','`',0};
2928
2929 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
2930 if (rc != ERROR_SUCCESS)
2931 return ERROR_SUCCESS;
2932
2933 rc = MSI_IterateRecords(view, NULL, ITERATE_RegisterTypeLibraries, package);
2934 msiobj_release(&view->hdr);
2935 return rc;
2936 }
2937
2938 static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
2939 {
2940 MSIPACKAGE *package = (MSIPACKAGE*)param;
2941 LPWSTR target_file, target_folder, filename;
2942 LPCWSTR buffer, extension;
2943 MSICOMPONENT *comp;
2944 static const WCHAR szlnk[]={'.','l','n','k',0};
2945 IShellLinkW *sl = NULL;
2946 IPersistFile *pf = NULL;
2947 HRESULT res;
2948
2949 buffer = MSI_RecordGetString(row,4);
2950 comp = get_loaded_component(package,buffer);
2951 if (!comp)
2952 return ERROR_SUCCESS;
2953
2954 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL ))
2955 {
2956 TRACE("Skipping shortcut creation due to disabled component\n");
2957
2958 comp->Action = comp->Installed;
2959
2960 return ERROR_SUCCESS;
2961 }
2962
2963 comp->Action = INSTALLSTATE_LOCAL;
2964
2965 ui_actiondata(package,szCreateShortcuts,row);
2966
2967 res = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
2968 &IID_IShellLinkW, (LPVOID *) &sl );
2969
2970 if (FAILED( res ))
2971 {
2972 ERR("CLSID_ShellLink not available\n");
2973 goto err;
2974 }
2975
2976 res = IShellLinkW_QueryInterface( sl, &IID_IPersistFile,(LPVOID*) &pf );
2977 if (FAILED( res ))
2978 {
2979 ERR("QueryInterface(IID_IPersistFile) failed\n");
2980 goto err;
2981 }
2982
2983 buffer = MSI_RecordGetString(row,2);
2984 target_folder = resolve_folder(package, buffer,FALSE,FALSE,NULL);
2985
2986 /* may be needed because of a bug somehwere else */
2987 create_full_pathW(target_folder);
2988
2989 filename = msi_dup_record_field( row, 3 );
2990 reduce_to_longfilename(filename);
2991
2992 extension = strchrW(filename,'.');
2993 if (!extension || strcmpiW(extension,szlnk))
2994 {
2995 int len = strlenW(filename);
2996 filename = msi_realloc(filename, len * sizeof(WCHAR) + sizeof(szlnk));
2997 memcpy(filename + len, szlnk, sizeof(szlnk));
2998 }
2999 target_file = build_directory_name(2, target_folder, filename);
3000 msi_free(target_folder);
3001 msi_free(filename);
3002
3003 buffer = MSI_RecordGetString(row,5);
3004 if (strchrW(buffer,'['))
3005 {
3006 LPWSTR deformated;
3007 deformat_string(package,buffer,&deformated);
3008 IShellLinkW_SetPath(sl,deformated);
3009 msi_free(deformated);
3010 }
3011 else
3012 {
3013 FIXME("poorly handled shortcut format, advertised shortcut\n");
3014 IShellLinkW_SetPath(sl,comp->FullKeypath);
3015 }
3016
3017 if (!MSI_RecordIsNull(row,6))
3018 {
3019 LPWSTR deformated;
3020 buffer = MSI_RecordGetString(row,6);
3021 deformat_string(package,buffer,&deformated);
3022 IShellLinkW_SetArguments(sl,deformated);
3023 msi_free(deformated);
3024 }
3025
3026 if (!MSI_RecordIsNull(row,7))
3027 {
3028 buffer = MSI_RecordGetString(row,7);
3029 IShellLinkW_SetDescription(sl,buffer);
3030 }
3031
3032 if (!MSI_RecordIsNull(row,8))
3033 IShellLinkW_SetHotkey(sl,MSI_RecordGetInteger(row,8));
3034
3035 if (!MSI_RecordIsNull(row,9))
3036 {
3037 LPWSTR Path;
3038 INT index;
3039
3040 buffer = MSI_RecordGetString(row,9);
3041
3042 Path = build_icon_path(package,buffer);
3043 index = MSI_RecordGetInteger(row,10);
3044
3045 /* no value means 0 */
3046 if (index == MSI_NULL_INTEGER)
3047 index = 0;
3048
3049 IShellLinkW_SetIconLocation(sl,Path,index);
3050 msi_free(Path);
3051 }
3052
3053 if (!MSI_RecordIsNull(row,11))
3054 IShellLinkW_SetShowCmd(sl,MSI_RecordGetInteger(row,11));
3055
3056 if (!MSI_RecordIsNull(row,12))
3057 {
3058 LPWSTR Path;
3059 buffer = MSI_RecordGetString(row,12);
3060 Path = resolve_folder(package, buffer, FALSE, FALSE, NULL);
3061 if (Path)
3062 IShellLinkW_SetWorkingDirectory(sl,Path);
3063 msi_free(Path);
3064 }
3065
3066 TRACE("Writing shortcut to %s\n",debugstr_w(target_file));
3067 IPersistFile_Save(pf,target_file,FALSE);
3068
3069 msi_free(target_file);
3070
3071 err:
3072 if (pf)
3073 IPersistFile_Release( pf );
3074 if (sl)
3075 IShellLinkW_Release( sl );
3076
3077 return ERROR_SUCCESS;
3078 }
3079
3080 static UINT ACTION_CreateShortcuts(MSIPACKAGE *package)
3081 {
3082 UINT rc;
3083 HRESULT res;
3084 MSIQUERY * view;
3085 static const WCHAR Query[] =
3086 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3087 '`','S','h','o','r','t','c','u','t','`',0};
3088
3089 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3090 if (rc != ERROR_SUCCESS)
3091 return ERROR_SUCCESS;
3092
3093 res = CoInitialize( NULL );
3094 if (FAILED (res))
3095 {
3096 ERR("CoInitialize failed\n");
3097 return ERROR_FUNCTION_FAILED;
3098 }
3099
3100 rc = MSI_IterateRecords(view, NULL, ITERATE_CreateShortcuts, package);
3101 msiobj_release(&view->hdr);
3102
3103 CoUninitialize();
3104
3105 return rc;
3106 }
3107
3108 static UINT ITERATE_PublishProduct(MSIRECORD *row, LPVOID param)
3109 {
3110 MSIPACKAGE* package = (MSIPACKAGE*)param;
3111 HANDLE the_file;
3112 LPWSTR FilePath;
3113 LPCWSTR FileName;
3114 CHAR buffer[1024];
3115 DWORD sz;
3116 UINT rc;
3117 MSIRECORD *uirow;
3118
3119 FileName = MSI_RecordGetString(row,1);
3120 if (!FileName)
3121 {
3122 ERR("Unable to get FileName\n");
3123 return ERROR_SUCCESS;
3124 }
3125
3126 FilePath = build_icon_path(package,FileName);
3127
3128 TRACE("Creating icon file at %s\n",debugstr_w(FilePath));
3129
3130 the_file = CreateFileW(FilePath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
3131 FILE_ATTRIBUTE_NORMAL, NULL);
3132
3133 if (the_file == INVALID_HANDLE_VALUE)
3134 {
3135 ERR("Unable to create file %s\n",debugstr_w(FilePath));
3136 msi_free(FilePath);
3137 return ERROR_SUCCESS;
3138 }
3139
3140 do
3141 {
3142 DWORD write;
3143 sz = 1024;
3144 rc = MSI_RecordReadStream(row,2,buffer,&sz);
3145 if (rc != ERROR_SUCCESS)
3146 {
3147 ERR("Failed to get stream\n");
3148 CloseHandle(the_file);
3149 DeleteFileW(FilePath);
3150 break;
3151 }
3152 WriteFile(the_file,buffer,sz,&write,NULL);
3153 } while (sz == 1024);
3154
3155 msi_free(FilePath);
3156
3157 CloseHandle(the_file);
3158
3159 uirow = MSI_CreateRecord(1);
3160 MSI_RecordSetStringW(uirow,1,FileName);
3161 ui_actiondata(package,szPublishProduct,uirow);
3162 msiobj_release( &uirow->hdr );
3163
3164 return ERROR_SUCCESS;
3165 }
3166
3167 /*
3168 * 99% of the work done here is only done for
3169 * advertised installs. However this is where the
3170 * Icon table is processed and written out
3171 * so that is what I am going to do here.
3172 */
3173 static UINT ACTION_PublishProduct(MSIPACKAGE *package)
3174 {
3175 UINT rc;
3176 MSIQUERY * view;
3177 static const WCHAR Query[]=
3178 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3179 '`','I','c','o','n','`',0};
3180 /* for registry stuff */
3181 HKEY hkey=0;
3182 HKEY hukey=0;
3183 static const WCHAR szProductLanguage[] =
3184 {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
3185 static const WCHAR szARPProductIcon[] =
3186 {'A','R','P','P','R','O','D','U','C','T','I','C','O','N',0};
3187 static const WCHAR szProductVersion[] =
3188 {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
3189 DWORD langid;
3190 LPWSTR buffer;
3191 DWORD size;
3192 MSIHANDLE hDb, hSumInfo;
3193
3194 /* write out icon files */
3195
3196 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3197 if (rc == ERROR_SUCCESS)
3198 {
3199 MSI_IterateRecords(view, NULL, ITERATE_PublishProduct, package);
3200 msiobj_release(&view->hdr);
3201 }
3202
3203 /* ok there is a lot more done here but i need to figure out what */
3204
3205 rc = MSIREG_OpenProductsKey(package->ProductCode,&hkey,TRUE);
3206 if (rc != ERROR_SUCCESS)
3207 goto end;
3208
3209 rc = MSIREG_OpenUserProductsKey(package->ProductCode,&hukey,TRUE);
3210 if (rc != ERROR_SUCCESS)
3211 goto end;
3212
3213
3214 buffer = msi_dup_property( package, INSTALLPROPERTY_PRODUCTNAMEW );
3215 msi_reg_set_val_str( hukey, INSTALLPROPERTY_PRODUCTNAMEW, buffer );
3216 msi_free(buffer);
3217
3218 langid = msi_get_property_int( package, szProductLanguage, 0 );
3219 msi_reg_set_val_dword( hkey, INSTALLPROPERTY_LANGUAGEW, langid );
3220
3221 buffer = msi_dup_property( package, szARPProductIcon );
3222 if (buffer)
3223 {
3224 LPWSTR path = build_icon_path(package,buffer);
3225 msi_reg_set_val_str( hukey, INSTALLPROPERTY_PRODUCTICONW, path );
3226 msi_free( path );
3227 }
3228 msi_free(buffer);
3229
3230 buffer = msi_dup_property( package, szProductVersion );
3231 if (buffer)
3232 {
3233 DWORD verdword = msi_version_str_to_dword(buffer);
3234 msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONW, verdword );
3235 }
3236 msi_free(buffer);
3237
3238 /* FIXME: Need to write more keys to the user registry */
3239
3240 hDb= alloc_msihandle( &package->db->hdr );
3241 if (!hDb) {
3242 rc = ERROR_NOT_ENOUGH_MEMORY;
3243 goto end;
3244 }
3245 rc = MsiGetSummaryInformationW(hDb, NULL, 0, &hSumInfo);
3246 MsiCloseHandle(hDb);
3247 if (rc == ERROR_SUCCESS)
3248 {
3249 WCHAR guidbuffer[0x200];
3250 size = 0x200;
3251 rc = MsiSummaryInfoGetPropertyW(hSumInfo, 9, NULL, NULL, NULL,
3252 guidbuffer, &size);
3253 if (rc == ERROR_SUCCESS)
3254 {
3255 WCHAR squashed[GUID_SIZE];
3256 /* for now we only care about the first guid */
3257 LPWSTR ptr = strchrW(guidbuffer,';');
3258 if (ptr) *ptr = 0;
3259 squash_guid(guidbuffer,squashed);
3260 msi_reg_set_val_str( hukey, INSTALLPROPERTY_PACKAGECODEW, squashed );
3261 }
3262 else
3263 {
3264 ERR("Unable to query Revision_Number...\n");
3265 rc = ERROR_SUCCESS;
3266 }
3267 MsiCloseHandle(hSumInfo);
3268 }
3269 else
3270 {
3271 ERR("Unable to open Summary Information\n");
3272 rc = ERROR_SUCCESS;
3273 }
3274
3275 end:
3276
3277 RegCloseKey(hkey);
3278 RegCloseKey(hukey);
3279
3280 return rc;
3281 }
3282
3283 static UINT ITERATE_WriteIniValues(MSIRECORD *row, LPVOID param)
3284 {
3285 MSIPACKAGE *package = (MSIPACKAGE*)param;
3286 LPCWSTR component,section,key,value,identifier,filename,dirproperty;
3287 LPWSTR deformated_section, deformated_key, deformated_value;
3288 LPWSTR folder, fullname = NULL;
3289 MSIRECORD * uirow;
3290 INT action;
3291 MSICOMPONENT *comp;
3292 static const WCHAR szWindowsFolder[] =
3293 {'W','i','n','d','o','w','s','F','o','l','d','e','r',0};
3294
3295 component = MSI_RecordGetString(row, 8);
3296 comp = get_loaded_component(package,component);
3297
3298 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
3299 {
3300 TRACE("Skipping ini file due to disabled component %s\n",
3301 debugstr_w(component));
3302
3303 comp->Action = comp->Installed;
3304
3305 return ERROR_SUCCESS;
3306 }
3307
3308 comp->Action = INSTALLSTATE_LOCAL;
3309
3310 identifier = MSI_RecordGetString(row,1);
3311 filename = MSI_RecordGetString(row,2);
3312 dirproperty = MSI_RecordGetString(row,3);
3313 section = MSI_RecordGetString(row,4);
3314 key = MSI_RecordGetString(row,5);
3315 value = MSI_RecordGetString(row,6);
3316 action = MSI_RecordGetInteger(row,7);
3317
3318 deformat_string(package,section,&deformated_section);
3319 deformat_string(package,key,&deformated_key);
3320 deformat_string(package,value,&deformated_value);
3321
3322 if (dirproperty)
3323 {
3324 folder = resolve_folder(package, dirproperty, FALSE, FALSE, NULL);
3325 if (!folder)
3326 folder = msi_dup_property( package, dirproperty );
3327 }
3328 else
3329 folder = msi_dup_property( package, szWindowsFolder );
3330
3331 if (!folder)
3332 {
3333 ERR("Unable to resolve folder! (%s)\n",debugstr_w(dirproperty));
3334 goto cleanup;
3335 }
3336
3337 fullname = build_directory_name(2, folder, filename);
3338
3339 if (action == 0)
3340 {
3341 TRACE("Adding value %s to section %s in %s\n",
3342 debugstr_w(deformated_key), debugstr_w(deformated_section),
3343 debugstr_w(fullname));
3344 WritePrivateProfileStringW(deformated_section, deformated_key,
3345 deformated_value, fullname);
3346 }
3347 else if (action == 1)
3348 {
3349 WCHAR returned[10];
3350 GetPrivateProfileStringW(deformated_section, deformated_key, NULL,
3351 returned, 10, fullname);
3352 if (returned[0] == 0)
3353 {
3354 TRACE("Adding value %s to section %s in %s\n",
3355 debugstr_w(deformated_key), debugstr_w(deformated_section),
3356 debugstr_w(fullname));
3357
3358 WritePrivateProfileStringW(deformated_section, deformated_key,
3359 deformated_value, fullname);
3360 }
3361 }
3362 else if (action == 3)
3363 FIXME("Append to existing section not yet implemented\n");
3364
3365 uirow = MSI_CreateRecord(4);
3366 MSI_RecordSetStringW(uirow,1,identifier);
3367 MSI_RecordSetStringW(uirow,2,deformated_section);
3368 MSI_RecordSetStringW(uirow,3,deformated_key);
3369 MSI_RecordSetStringW(uirow,4,deformated_value);
3370 ui_actiondata(package,szWriteIniValues,uirow);
3371 msiobj_release( &uirow->hdr );
3372 cleanup:
3373 msi_free(fullname);
3374 msi_free(folder);
3375 msi_free(deformated_key);
3376 msi_free(deformated_value);
3377 msi_free(deformated_section);
3378 return ERROR_SUCCESS;
3379 }
3380
3381 static UINT ACTION_WriteIniValues(MSIPACKAGE *package)
3382 {
3383 UINT rc;
3384 MSIQUERY * view;
3385 static const WCHAR ExecSeqQuery[] =
3386 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3387 '`','I','n','i','F','i','l','e','`',0};
3388
3389 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3390 if (rc != ERROR_SUCCESS)
3391 {
3392 TRACE("no IniFile table\n");
3393 return ERROR_SUCCESS;
3394 }
3395
3396 rc = MSI_IterateRecords(view, NULL, ITERATE_WriteIniValues, package);
3397 msiobj_release(&view->hdr);
3398 return rc;
3399 }
3400
3401 static UINT ITERATE_SelfRegModules(MSIRECORD *row, LPVOID param)
3402 {
3403 MSIPACKAGE *package = (MSIPACKAGE*)param;
3404 LPCWSTR filename;
3405 LPWSTR FullName;
3406 MSIFILE *file;
3407 DWORD len;
3408 static const WCHAR ExeStr[] =
3409 {'r','e','g','s','v','r','3','2','.','e','x','e',' ','\"',0};
3410 static const WCHAR close[] = {'\"',0};
3411 STARTUPINFOW si;
3412 PROCESS_INFORMATION info;
3413 BOOL brc;
3414 MSIRECORD *uirow;
3415 LPWSTR uipath, p;
3416
3417 memset(&si,0,sizeof(STARTUPINFOW));
3418
3419 filename = MSI_RecordGetString(row,1);
3420 file = get_loaded_file( package, filename );
3421
3422 if (!file)
3423 {
3424 ERR("Unable to find file id %s\n",debugstr_w(filename));
3425 return ERROR_SUCCESS;
3426 }
3427
3428 len = strlenW(ExeStr) + strlenW( file->TargetPath ) + 2;
3429
3430 FullName = msi_alloc(len*sizeof(WCHAR));
3431 strcpyW(FullName,ExeStr);
3432 strcatW( FullName, file->TargetPath );
3433 strcatW(FullName,close);
3434
3435 TRACE("Registering %s\n",debugstr_w(FullName));
3436 brc = CreateProcessW(NULL, FullName, NULL, NULL, FALSE, 0, NULL, c_colon,
3437 &si, &info);
3438
3439 if (brc)
3440 msi_dialog_check_messages(info.hProcess);
3441
3442 msi_free(FullName);
3443
3444 /* the UI chunk */
3445 uirow = MSI_CreateRecord( 2 );
3446 uipath = strdupW( file->TargetPath );
3447 p = strrchrW(uipath,'\\');
3448 if (p)
3449 p[1]=0;
3450 MSI_RecordSetStringW( uirow, 1, &p[2] );
3451 MSI_RecordSetStringW( uirow, 2, uipath);
3452 ui_actiondata( package, szSelfRegModules, uirow);
3453 msiobj_release( &uirow->hdr );
3454 msi_free( uipath );
3455 /* FIXME: call ui_progress? */
3456
3457 return ERROR_SUCCESS;
3458 }
3459
3460 static UINT ACTION_SelfRegModules(MSIPACKAGE *package)
3461 {
3462 UINT rc;
3463 MSIQUERY * view;
3464 static const WCHAR ExecSeqQuery[] =
3465 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3466 '`','S','e','l','f','R','e','g','`',0};
3467
3468 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3469 if (rc != ERROR_SUCCESS)
3470 {
3471 TRACE("no SelfReg table\n");
3472 return ERROR_SUCCESS;
3473 }
3474
3475 MSI_IterateRecords(view, NULL, ITERATE_SelfRegModules, package);
3476 msiobj_release(&view->hdr);
3477
3478 return ERROR_SUCCESS;
3479 }
3480
3481 static UINT ACTION_PublishFeatures(MSIPACKAGE *package)
3482 {
3483 MSIFEATURE *feature;
3484 UINT rc;
3485 HKEY hkey=0;
3486 HKEY hukey=0;
3487
3488 rc = MSIREG_OpenFeaturesKey(package->ProductCode,&hkey,TRUE);
3489 if (rc != ERROR_SUCCESS)
3490 goto end;
3491
3492 rc = MSIREG_OpenUserFeaturesKey(package->ProductCode,&hukey,TRUE);
3493 if (rc != ERROR_SUCCESS)
3494 goto end;
3495
3496 /* here the guids are base 85 encoded */
3497 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
3498 {
3499 ComponentList *cl;
3500 LPWSTR data = NULL;
3501 GUID clsid;
3502 INT size;
3503 BOOL absent = FALSE;
3504 MSIRECORD *uirow;
3505
3506 if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_LOCAL ) &&
3507 !ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_SOURCE ) &&
3508 !ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_ADVERTISED ))
3509 absent = TRUE;
3510
3511 size = 1;
3512 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3513 {
3514 size += 21;
3515 }
3516 if (feature->Feature_Parent)
3517 size += strlenW( feature->Feature_Parent )+2;
3518
3519 data = msi_alloc(size * sizeof(WCHAR));
3520
3521 data[0] = 0;
3522 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3523 {
3524 MSICOMPONENT* component = cl->component;
3525 WCHAR buf[21];
3526
3527 buf[0] = 0;
3528 if (component->ComponentId)
3529 {
3530 TRACE("From %s\n",debugstr_w(component->ComponentId));
3531 CLSIDFromString(component->ComponentId, &clsid);
3532 encode_base85_guid(&clsid,buf);
3533 TRACE("to %s\n",debugstr_w(buf));
3534 strcatW(data,buf);
3535 }
3536 }
3537 if (feature->Feature_Parent)
3538 {
3539 static const WCHAR sep[] = {'\2',0};
3540 strcatW(data,sep);
3541 strcatW(data,feature->Feature_Parent);
3542 }
3543
3544 msi_reg_set_val_str( hkey, feature->Feature, data );
3545 msi_free(data);
3546
3547 size = 0;
3548 if (feature->Feature_Parent)
3549 size = strlenW(feature->Feature_Parent)*sizeof(WCHAR);
3550 if (!absent)
3551 {
3552 RegSetValueExW(hukey,feature->Feature,0,REG_SZ,
3553 (LPBYTE)feature->Feature_Parent,size);
3554 }
3555 else
3556 {
3557 size += 2*sizeof(WCHAR);
3558 data = msi_alloc(size);
3559 data[0] = 0x6;
3560 data[1] = 0;
3561 if (feature->Feature_Parent)
3562 strcpyW( &data[1], feature->Feature_Parent );
3563 RegSetValueExW(hukey,feature->Feature,0,REG_SZ,
3564 (LPBYTE)data,size);
3565 msi_free(data);
3566 }
3567
3568 /* the UI chunk */
3569 uirow = MSI_CreateRecord( 1 );
3570 MSI_RecordSetStringW( uirow, 1, feature->Feature );
3571 ui_actiondata( package, szPublishFeatures, uirow);
3572 msiobj_release( &uirow->hdr );
3573 /* FIXME: call ui_progress? */
3574 }
3575
3576 end:
3577 RegCloseKey(hkey);
3578 RegCloseKey(hukey);
3579 return rc;
3580 }
3581
3582 static UINT msi_get_local_package_name( LPWSTR path )
3583 {
3584 static const WCHAR szInstaller[] = {
3585 '\\','I','n','s','t','a','l','l','e','r','\\',0};
3586 static const WCHAR fmt[] = { '%','x','.','m','s','i',0};
3587 DWORD time, len, i;
3588 HANDLE handle;
3589
3590 time = GetTickCount();
3591 GetWindowsDirectoryW( path, MAX_PATH );
3592 lstrcatW( path, szInstaller );
3593 CreateDirectoryW( path, NULL );
3594
3595 len = lstrlenW(path);
3596 for (i=0; i<0x10000; i++)
3597 {
3598 snprintfW( &path[len], MAX_PATH - len, fmt, (time+i)&0xffff );
3599 handle = CreateFileW( path, GENERIC_WRITE, 0, NULL,
3600 CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
3601 if (handle != INVALID_HANDLE_VALUE)
3602 {
3603 CloseHandle(handle);
3604 break;
3605 }
3606 if (GetLastError() != ERROR_FILE_EXISTS &&
3607 GetLastError() != ERROR_SHARING_VIOLATION)
3608 return ERROR_FUNCTION_FAILED;
3609 }
3610
3611 return ERROR_SUCCESS;
3612 }
3613
3614 static UINT msi_make_package_local( MSIPACKAGE *package, HKEY hkey )
3615 {
3616 static const WCHAR szOriginalDatabase[] =
3617 {'O','r','i','g','i','n','a','l','D','a','t','a','b','a','s','e',0};
3618 WCHAR packagefile[MAX_PATH];
3619 LPWSTR msiFilePath;
3620 UINT r;
3621
3622 r = msi_get_local_package_name( packagefile );
3623 if (r != ERROR_SUCCESS)
3624 return r;
3625
3626 TRACE("Copying to local package %s\n",debugstr_w(packagefile));
3627
3628 msiFilePath = msi_dup_property( package, szOriginalDatabase );
3629 r = CopyFileW( msiFilePath, packagefile, FALSE);
3630 msi_free( msiFilePath );
3631
3632 if (!r)
3633 {
3634 ERR("Unable to copy package (%s -> %s) (error %d)\n",
3635 debugstr_w(msiFilePath), debugstr_w(packagefile), GetLastError());
3636 return ERROR_FUNCTION_FAILED;
3637 }
3638
3639 /* FIXME: maybe set this key in ACTION_RegisterProduct instead */
3640 msi_reg_set_val_str( hkey, INSTALLPROPERTY_LOCALPACKAGEW, packagefile );
3641 return ERROR_SUCCESS;
3642 }
3643
3644 static UINT msi_write_uninstall_property_vals( MSIPACKAGE *package, HKEY hkey )
3645 {
3646 LPWSTR prop, val, key;
3647 static const LPCSTR propval[] = {
3648 "ARPAUTHORIZEDCDFPREFIX", "AuthorizedCDFPrefix",
3649 "ARPCONTACT", "Contact",
3650 "ARPCOMMENTS", "Comments",
3651 "ProductName", "DisplayName",
3652 "ProductVersion", "DisplayVersion",
3653 "ARPHELPLINK", "HelpLink",
3654 "ARPHELPTELEPHONE", "HelpTelephone",
3655 "ARPINSTALLLOCATION", "InstallLocation",
3656 "SourceDir", "InstallSource",
3657 "Manufacturer", "Publisher",
3658 "ARPREADME", "Readme",
3659 "ARPSIZE", "Size",
3660 "ARPURLINFOABOUT", "URLInfoAbout",
3661 "ARPURLUPDATEINFO", "URLUpdateInfo",
3662 NULL,
3663 };
3664 const LPCSTR *p = propval;
3665
3666 while( *p )
3667 {
3668 prop = strdupAtoW( *p++ );
3669 key = strdupAtoW( *p++ );
3670 val = msi_dup_property( package, prop );
3671 msi_reg_set_val_str( hkey, key, val );
3672 msi_free(val);
3673 msi_free(key);
3674 msi_free(prop);
3675 }
3676 return ERROR_SUCCESS;
3677 }
3678
3679 static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
3680 {
3681 HKEY hkey=0;
3682 LPWSTR buffer = NULL;
3683 UINT rc;
3684 DWORD size, langid;
3685 static const WCHAR szWindowsInstaller[] =
3686 {'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
3687 static const WCHAR szUpgradeCode[] =
3688 {'U','p','g','r','a','d','e','C','o','d','e',0};
3689 static const WCHAR modpath_fmt[] =
3690 {'M','s','i','E','x','e','c','.','e','x','e',' ',
3691 '/','I','[','P','r','o','d','u','c','t','C','o','d','e',']',0};
3692 static const WCHAR szModifyPath[] =
3693 {'M','o','d','i','f','y','P','a','t','h',0};
3694 static const WCHAR szUninstallString[] =
3695 {'U','n','i','n','s','t','a','l','l','S','t','r','i','n','g',0};
3696 static const WCHAR szEstimatedSize[] =
3697 {'E','s','t','i','m','a','t','e','d','S','i','z','e',0};
3698 static const WCHAR szProductLanguage[] =
3699 {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
3700 static const WCHAR szProductVersion[] =
3701 {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
3702
3703 SYSTEMTIME systime;
3704 static const WCHAR date_fmt[] = {'%','i','%','i','%','i',0};
3705 LPWSTR upgrade_code;
3706 WCHAR szDate[9];
3707
3708 rc = MSIREG_OpenUninstallKey(package->ProductCode,&hkey,TRUE);
3709 if (rc != ERROR_SUCCESS)
3710 return rc;
3711
3712 /* dump all the info i can grab */
3713 /* FIXME: Flesh out more information */
3714
3715 msi_write_uninstall_property_vals( package, hkey );
3716
3717 msi_reg_set_val_dword( hkey, szWindowsInstaller, 1 );
3718
3719 msi_make_package_local( package, hkey );
3720
3721 /* do ModifyPath and UninstallString */
3722 size = deformat_string(package,modpath_fmt,&buffer);
3723 RegSetValueExW(hkey,szModifyPath,0,REG_EXPAND_SZ,(LPBYTE)buffer,size);
3724 RegSetValueExW(hkey,szUninstallString,0,REG_EXPAND_SZ,(LPBYTE)buffer,size);
3725 msi_free(buffer);
3726
3727 /* FIXME: Write real Estimated Size when we have it */
3728 msi_reg_set_val_dword( hkey, szEstimatedSize, 0 );
3729
3730 GetLocalTime(&systime);
3731 sprintfW(szDate,date_fmt,systime.wYear,systime.wMonth,systime.wDay);
3732 msi_reg_set_val_str( hkey, INSTALLPROPERTY_INSTALLDATEW, szDate );
3733
3734 langid = msi_get_property_int( package, szProductLanguage, 0 );
3735 msi_reg_set_val_dword( hkey, INSTALLPROPERTY_LANGUAGEW, langid );
3736
3737 buffer = msi_dup_property( package, szProductVersion );
3738 if (buffer)
3739 {
3740 DWORD verdword = msi_version_str_to_dword(buffer);
3741
3742 msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONW, verdword );
3743 msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONMAJORW, verdword>>24 );
3744 msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONMINORW, (verdword>>16)&0x00FF );
3745 }
3746 msi_free(buffer);
3747
3748 /* Handle Upgrade Codes */
3749 upgrade_code = msi_dup_property( package, szUpgradeCode );
3750 if (upgrade_code)
3751 {
3752 HKEY hkey2;
3753 WCHAR squashed[33];
3754 MSIREG_OpenUpgradeCodesKey(upgrade_code, &hkey2, TRUE);
3755 squash_guid(package->ProductCode,squashed);
3756 msi_reg_set_val_str( hkey2, squashed, NULL );
3757 RegCloseKey(hkey2);
3758 MSIREG_OpenUserUpgradeCodesKey(upgrade_code, &hkey2, TRUE);
3759 squash_guid(package->ProductCode,squashed);
3760 msi_reg_set_val_str( hkey2, squashed, NULL );
3761 RegCloseKey(hkey2);
3762
3763 msi_free(upgrade_code);
3764 }
3765
3766 RegCloseKey(hkey);
3767
3768 /* FIXME: call ui_actiondata */
3769
3770 return ERROR_SUCCESS;
3771 }
3772
3773 static UINT ACTION_InstallExecute(MSIPACKAGE *package)
3774 {
3775 return execute_script(package,INSTALL_SCRIPT);
3776 }
3777
3778 static UINT ACTION_InstallFinalize(MSIPACKAGE *package)
3779 {
3780 UINT rc;
3781
3782 /* turn off scheduleing */
3783 package->script->CurrentlyScripting= FALSE;
3784
3785 /* first do the same as an InstallExecute */
3786 rc = ACTION_InstallExecute(package);
3787 if (rc != ERROR_SUCCESS)
3788 return rc;
3789
3790 /* then handle Commit Actions */
3791 rc = execute_script(package,COMMIT_SCRIPT);
3792
3793 return rc;
3794 }
3795
3796 static UINT ACTION_ForceReboot(MSIPACKAGE *package)
3797 {
3798 static const WCHAR RunOnce[] = {
3799 'S','o','f','t','w','a','r','e','\\',
3800 'M','i','c','r','o','s','o','f','t','\\',
3801 'W','i','n','d','o','w','s','\\',
3802 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3803 'R','u','n','O','n','c','e',0};
3804 static const WCHAR InstallRunOnce[] = {
3805 'S','o','f','t','w','a','r','e','\\',
3806 'M','i','c','r','o','s','o','f','t','\\',
3807 'W','i','n','d','o','w','s','\\',
3808 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3809 'I','n','s','t','a','l','l','e','r','\\',
3810 'R','u','n','O','n','c','e','E','n','t','r','i','e','s',0};
3811
3812 static const WCHAR msiexec_fmt[] = {
3813 '%','s',
3814 '\\','M','s','i','E','x','e','c','.','e','x','e',' ','/','@',' ',
3815 '\"','%','s','\"',0};
3816 static const WCHAR install_fmt[] = {
3817 '/','I',' ','\"','%','s','\"',' ',
3818 'A','F','T','E','R','R','E','B','O','O','T','=','1',' ',
3819 'R','U','N','O','N','C','E','E','N','T','R','Y','=','\"','%','s','\"',0};
3820 WCHAR buffer[256], sysdir[MAX_PATH];
3821 HKEY hkey;
3822 WCHAR squished_pc[100];
3823
3824 squash_guid(package->ProductCode,squished_pc);
3825
3826 GetSystemDirectoryW(sysdir, sizeof(sysdir)/sizeof(sysdir[0]));
3827 RegCreateKeyW(HKEY_LOCAL_MACHINE,RunOnce,&hkey);
3828 snprintfW(buffer,sizeof(buffer)/sizeof(buffer[0]),msiexec_fmt,sysdir,
3829 squished_pc);
3830
3831 msi_reg_set_val_str( hkey, squished_pc, buffer );
3832 RegCloseKey(hkey);
3833
3834 TRACE("Reboot command %s\n",debugstr_w(buffer));
3835
3836 RegCreateKeyW(HKEY_LOCAL_MACHINE,InstallRunOnce,&hkey);
3837 sprintfW(buffer,install_fmt,package->ProductCode,squished_pc);
3838
3839 msi_reg_set_val_str( hkey, squished_pc, buffer );
3840 RegCloseKey(hkey);
3841
3842 return ERROR_INSTALL_SUSPEND;
3843 }
3844
3845 static UINT ACTION_ResolveSource(MSIPACKAGE* package)
3846 {
3847 DWORD attrib, len;
3848 LPWSTR ptr, source;
3849 UINT rc;
3850
3851 /*
3852 * we are currently doing what should be done here in the top level Install
3853 * however for Adminastrative and uninstalls this step will be needed
3854 */
3855 if (!package->PackagePath)
3856 return ERROR_SUCCESS;
3857
3858 ptr = strrchrW(package->PackagePath, '\\');
3859 if (!ptr)
3860 return ERROR_SUCCESS;
3861
3862 len = ptr - package->PackagePath + 2;
3863 source = msi_alloc(len * sizeof(WCHAR));
3864 lstrcpynW(source, package->PackagePath, len);
3865
3866 MSI_SetPropertyW(package, cszSourceDir, source);
3867 MSI_SetPropertyW(package, cszSOURCEDIR, source);
3868
3869 msi_free(source);
3870
3871 attrib = GetFileAttributesW(package->PackagePath);
3872 if (attrib == INVALID_FILE_ATTRIBUTES)
3873 {
3874 LPWSTR prompt;
3875 LPWSTR msg;
3876 DWORD size = 0;
3877
3878 rc = MsiSourceListGetInfoW(package->ProductCode, NULL,
3879 MSIINSTALLCONTEXT_USERMANAGED, MSICODE_PRODUCT,
3880 INSTALLPROPERTY_DISKPROMPTW,NULL,&size);
3881 if (rc == ERROR_MORE_DATA)
3882 {
3883 prompt = msi_alloc(size * sizeof(WCHAR));
3884 MsiSourceListGetInfoW(package->ProductCode, NULL,
3885 MSIINSTALLCONTEXT_USERMANAGED, MSICODE_PRODUCT,
3886 INSTALLPROPERTY_DISKPROMPTW,prompt,&size);
3887 }
3888 else
3889 prompt = strdupW(package->PackagePath);
3890
3891 msg = generate_error_string(package,1302,1,prompt);
3892 while(attrib == INVALID_FILE_ATTRIBUTES)
3893 {
3894 rc = MessageBoxW(NULL,msg,NULL,MB_OKCANCEL);
3895 if (rc == IDCANCEL)
3896 {
3897 rc = ERROR_INSTALL_USEREXIT;
3898 break;
3899 }
3900 attrib = GetFileAttributesW(package->PackagePath);
3901 }
3902 msi_free(prompt);
3903 rc = ERROR_SUCCESS;
3904 }
3905 else
3906 return ERROR_SUCCESS;
3907
3908 return rc;
3909 }
3910
3911 static UINT ACTION_RegisterUser(MSIPACKAGE *package)
3912 {
3913 HKEY hkey=0;
3914 LPWSTR buffer;
3915 LPWSTR productid;
3916 UINT rc,i;
3917
3918 static const WCHAR szPropKeys[][80] =
3919 {
3920 {'P','r','o','d','u','c','t','I','D',0},
3921 {'U','S','E','R','N','A','M','E',0},
3922 {'C','O','M','P','A','N','Y','N','A','M','E',0},
3923 {0},
3924 };
3925
3926 static const WCHAR szRegKeys[][80] =
3927 {
3928 {'P','r','o','d','u','c','t','I','D',0},
3929 {'R','e','g','O','w','n','e','r',0},
3930 {'R','e','g','C','o','m','p','a','n','y',0},
3931 {0},
3932 };
3933
3934 productid = msi_dup_property( package, INSTALLPROPERTY_PRODUCTIDW );
3935 if (!productid)
3936 return ERROR_SUCCESS;
3937
3938 rc = MSIREG_OpenUninstallKey(package->ProductCode,&hkey,TRUE);
3939 if (rc != ERROR_SUCCESS)
3940 goto end;
3941
3942 for( i = 0; szPropKeys[i][0]; i++ )
3943 {
3944 buffer = msi_dup_property( package, szPropKeys[i] );
3945 msi_reg_set_val_str( hkey, szRegKeys[i], buffer );
3946 msi_free( buffer );
3947 }
3948
3949 end:
3950 msi_free(productid);
3951 RegCloseKey(hkey);
3952
3953 /* FIXME: call ui_actiondata */
3954
3955 return ERROR_SUCCESS;
3956 }
3957
3958
3959 static UINT ACTION_ExecuteAction(MSIPACKAGE *package)
3960 {
3961 UINT rc;
3962
3963 package->script->InWhatSequence |= SEQUENCE_EXEC;
3964 rc = ACTION_ProcessExecSequence(package,FALSE);
3965 return rc;
3966 }
3967
3968
3969 static UINT ITERATE_PublishComponent(MSIRECORD *rec, LPVOID param)
3970 {
3971 MSIPACKAGE *package = (MSIPACKAGE*)param;
3972 LPCWSTR compgroupid=NULL;
3973 LPCWSTR feature=NULL;
3974 LPCWSTR text = NULL;
3975 LPCWSTR qualifier = NULL;
3976 LPCWSTR component = NULL;
3977 LPWSTR advertise = NULL;
3978 LPWSTR output = NULL;
3979 HKEY hkey;
3980 UINT rc = ERROR_SUCCESS;
3981 MSICOMPONENT *comp;
3982 DWORD sz = 0;
3983 MSIRECORD *uirow;
3984
3985 component = MSI_RecordGetString(rec,3);
3986 comp = get_loaded_component(package,component);
3987
3988 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL ) &&
3989 !ACTION_VerifyComponentForAction( comp, INSTALLSTATE_SOURCE ) &&
3990 !ACTION_VerifyComponentForAction( comp, INSTALLSTATE_ADVERTISED ))
3991 {
3992 TRACE("Skipping: Component %s not scheduled for install\n",
3993 debugstr_w(component));
3994
3995 return ERROR_SUCCESS;
3996 }
3997
3998 compgroupid = MSI_RecordGetString(rec,1);
3999 qualifier = MSI_RecordGetString(rec,2);
4000
4001 rc = MSIREG_OpenUserComponentsKey(compgroupid, &hkey, TRUE);
4002 if (rc != ERROR_SUCCESS)
4003 goto end;
4004
4005 text = MSI_RecordGetString(rec,4);
4006 feature = MSI_RecordGetString(rec,5);
4007
4008 advertise = create_component_advertise_string(package, comp, feature);
4009
4010 sz = strlenW(advertise);
4011
4012 if (text)
4013 sz += lstrlenW(text);
4014
4015 sz+=3;
4016 sz *= sizeof(WCHAR);
4017
4018 output = msi_alloc_zero(sz);
4019 strcpyW(output,advertise);
4020 msi_free(advertise);
4021
4022 if (text)
4023 strcatW(output,text);
4024
4025 msi_reg_set_val_multi_str( hkey, qualifier, output );
4026
4027 end:
4028 RegCloseKey(hkey);
4029 msi_free(output);
4030
4031 /* the UI chunk */
4032 uirow = MSI_CreateRecord( 2 );
4033 MSI_RecordSetStringW( uirow, 1, compgroupid );
4034 MSI_RecordSetStringW( uirow, 2, qualifier);
4035 ui_actiondata( package, szPublishComponents, uirow);
4036 msiobj_release( &uirow->hdr );
4037 /* FIXME: call ui_progress? */
4038
4039 return rc;
4040 }
4041
4042 /*
4043 * At present I am ignorning the advertised components part of this and only
4044 * focusing on the qualified component sets
4045 */
4046 static UINT ACTION_PublishComponents(MSIPACKAGE *package)
4047 {
4048 UINT rc;
4049 MSIQUERY * view;
4050 static const WCHAR ExecSeqQuery[] =
4051 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4052 '`','P','u','b','l','i','s','h',
4053 'C','o','m','p','o','n','e','n','t','`',0};
4054
4055 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4056 if (rc != ERROR_SUCCESS)
4057 return ERROR_SUCCESS;
4058
4059 rc = MSI_IterateRecords(view, NULL, ITERATE_PublishComponent, package);
4060 msiobj_release(&view->hdr);
4061
4062 return rc;
4063 }
4064
4065 static UINT ITERATE_InstallService(MSIRECORD *rec, LPVOID param)
4066 {
4067 MSIPACKAGE *package = (MSIPACKAGE*)param;
4068 MSIRECORD *row;
4069 MSIFILE *file;
4070 SC_HANDLE hscm, service = NULL;
4071 LPCWSTR name, disp, comp, depends, pass;
4072 LPCWSTR load_order, serv_name, key;
4073 DWORD serv_type, start_type;
4074 DWORD err_control;
4075
4076 static const WCHAR query[] =
4077 {'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
4078 '`','C','o','m','p','o','n','e','n','t','`',' ',
4079 'W','H','E','R','E',' ',
4080 '`','C','o','m','p','o','n','e','n','t','`',' ',
4081 '=','\'','%','s','\'',0};
4082
4083 hscm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, GENERIC_WRITE);
4084 if (!hscm)
4085 {
4086 ERR("Failed to open the SC Manager!\n");
4087 goto done;
4088 }
4089
4090 start_type = MSI_RecordGetInteger(rec, 5);
4091 if (start_type == SERVICE_BOOT_START || start_type == SERVICE_SYSTEM_START)
4092 goto done;
4093
4094 depends = MSI_RecordGetString(rec, 8);
4095 if (depends && *depends)
4096 FIXME("Dependency list unhandled!\n");
4097
4098 name = MSI_RecordGetString(rec, 2);
4099 disp = MSI_RecordGetString(rec, 3);
4100 serv_type = MSI_RecordGetInteger(rec, 4);
4101 err_control = MSI_RecordGetInteger(rec, 6);
4102 load_order = MSI_RecordGetString(rec, 7);
4103 serv_name = MSI_RecordGetString(rec, 9);
4104 pass = MSI_RecordGetString(rec, 10);
4105 comp = MSI_RecordGetString(rec, 12);
4106
4107 /* fetch the service path */
4108 row = MSI_QueryGetRecord(package->db, query, comp);
4109 if (!row)
4110 {
4111 ERR("Control query failed!\n");
4112 goto done;
4113 }
4114
4115 key = MSI_RecordGetString(row, 6);
4116 msiobj_release(&row->hdr);
4117
4118 file = get_loaded_file(package, key);
4119 if (!file)
4120 {
4121 ERR("Failed to load the service file\n");
4122 goto done;
4123 }
4124
4125 service = CreateServiceW(hscm, name, disp, GENERIC_ALL, serv_type,
4126 start_type, err_control, file->TargetPath,
4127 load_order, NULL, NULL, serv_name, pass);
4128 if (!service)
4129 {
4130 if (GetLastError() != ERROR_SERVICE_EXISTS)
4131 ERR("Failed to create service %s: %d\n", debugstr_w(name), GetLastError());
4132 }
4133
4134 done:
4135 CloseServiceHandle(service);
4136 CloseServiceHandle(hscm);
4137
4138 return ERROR_SUCCESS;
4139 }
4140
4141 static UINT ACTION_InstallServices( MSIPACKAGE *package )
4142 {
4143 UINT rc;
4144 MSIQUERY * view;
4145 static const WCHAR ExecSeqQuery[] =
4146 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4147 'S','e','r','v','i','c','e','I','n','s','t','a','l','l',0};
4148
4149 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4150 if (rc != ERROR_SUCCESS)
4151 return ERROR_SUCCESS;
4152
4153 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallService, package);
4154 msiobj_release(&view->hdr);
4155
4156 return rc;
4157 }
4158
4159 static UINT msi_unimplemented_action_stub( MSIPACKAGE *package,
4160 LPCSTR action, LPCWSTR table )
4161 {
4162 static const WCHAR query[] = {
4163 'S','E','L','E','C','T',' ','*',' ',
4164 'F','R','O','M',' ','`','%','s','`',0 };
4165 MSIQUERY *view = NULL;
4166 DWORD count = 0;
4167 UINT r;
4168
4169 r = MSI_OpenQuery( package->db, &view, query, table );
4170 if (r == ERROR_SUCCESS)
4171 {
4172 r = MSI_IterateRecords(view, &count, NULL, package);
4173 msiobj_release(&view->hdr);
4174 }
4175
4176 if (count)
4177 FIXME("%s -> %u ignored %s table values\n",
4178 action, count, debugstr_w(table));
4179
4180 return ERROR_SUCCESS;
4181 }
4182
4183 static UINT ACTION_AllocateRegistrySpace( MSIPACKAGE *package )
4184 {
4185 TRACE("%p\n", package);
4186 return ERROR_SUCCESS;
4187 }
4188
4189 static UINT ACTION_RemoveIniValues( MSIPACKAGE *package )
4190 {
4191 static const WCHAR table[] =
4192 {'R','e','m','o','v','e','I','n','i','F','i','l','e',0 };
4193 return msi_unimplemented_action_stub( package, "RemoveIniValues", table );
4194 }
4195
4196 static UINT ACTION_MoveFiles( MSIPACKAGE *package )
4197 {
4198 static const WCHAR table[] = { 'M','o','v','e','F','i','l','e',0 };
4199 return msi_unimplemented_action_stub( package, "MoveFiles", table );
4200 }
4201
4202 static UINT ACTION_PatchFiles( MSIPACKAGE *package )
4203 {
4204 static const WCHAR table[] = { 'P','a','t','c','h',0 };
4205 return msi_unimplemented_action_stub( package, "PatchFiles", table );
4206 }
4207
4208 static UINT ACTION_BindImage( MSIPACKAGE *package )
4209 {
4210 static const WCHAR table[] = { 'B','i','n','d','I','m','a','g','e',0 };
4211 return msi_unimplemented_action_stub( package, "BindImage", table );
4212 }
4213
4214 static UINT ACTION_IsolateComponents( MSIPACKAGE *package )
4215 {
4216 static const WCHAR table[] = {
4217 'I','s','o','l','a','t','e','C','o','m','p','o','n','e','n','t',0 };
4218 return msi_unimplemented_action_stub( package, "IsolateComponents", table );
4219 }
4220
4221 static UINT ACTION_MigrateFeatureStates( MSIPACKAGE *package )
4222 {
4223 static const WCHAR table[] = { 'U','p','g','r','a','d','e',0 };
4224 return msi_unimplemented_action_stub( package, "MigrateFeatureStates", table );
4225 }
4226
4227 static UINT ACTION_SelfUnregModules( MSIPACKAGE *package )
4228 {
4229 static const WCHAR table[] = { 'S','e','l','f','R','e','g',0 };
4230 return msi_unimplemented_action_stub( package, "SelfUnregModules", table );
4231 }
4232
4233 static UINT ACTION_StartServices( MSIPACKAGE *package )
4234 {
4235 static const WCHAR table[] = {
4236 'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
4237 return msi_unimplemented_action_stub( package, "StartServices", table );
4238 }
4239
4240 static UINT ACTION_StopServices( MSIPACKAGE *package )
4241 {
4242 static const WCHAR table[] = {
4243 'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
4244 return msi_unimplemented_action_stub( package, "StopServices", table );
4245 }
4246
4247 static UINT ACTION_DeleteServices( MSIPACKAGE *package )
4248 {
4249 static const WCHAR table[] = {
4250 'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
4251 return msi_unimplemented_action_stub( package, "DeleteServices", table );
4252 }
4253
4254 static UINT ACTION_WriteEnvironmentStrings( MSIPACKAGE *package )
4255 {
4256 static const WCHAR table[] = {
4257 'E','n','v','i','r','o','n','m','e','n','t',0 };
4258 return msi_unimplemented_action_stub( package, "WriteEnvironmentStrings", table );
4259 }
4260
4261 static UINT ACTION_RemoveEnvironmentStrings( MSIPACKAGE *package )
4262 {
4263 static const WCHAR table[] = {
4264 'E','n','v','i','r','o','n','m','e','n','t',0 };
4265 return msi_unimplemented_action_stub( package, "RemoveEnvironmentStrings", table );
4266 }
4267
4268 static UINT ACTION_MsiPublishAssemblies( MSIPACKAGE *package )
4269 {
4270 static const WCHAR table[] = {
4271 'M','s','i','A','s','s','e','m','b','l','y',0 };
4272 return msi_unimplemented_action_stub( package, "MsiPublishAssemblies", table );
4273 }
4274
4275 static UINT ACTION_MsiUnpublishAssemblies( MSIPACKAGE *package )
4276 {
4277 static const WCHAR table[] = {
4278 'M','s','i','A','s','s','e','m','b','l','y',0 };
4279 return msi_unimplemented_action_stub( package, "MsiUnpublishAssemblies", table );
4280 }
4281
4282 static UINT ACTION_UnregisterFonts( MSIPACKAGE *package )
4283 {
4284 static const WCHAR table[] = { 'F','o','n','t',0 };
4285 return msi_unimplemented_action_stub( package, "UnregisterFonts", table );
4286 }
4287
4288 static UINT ACTION_CCPSearch( MSIPACKAGE *package )
4289 {
4290 static const WCHAR table[] = { 'C','C','P','S','e','a','r','c','h',0 };
4291 return msi_unimplemented_action_stub( package, "CCPSearch", table );
4292 }
4293
4294 static UINT ACTION_RMCCPSearch( MSIPACKAGE *package )
4295 {
4296 static const WCHAR table[] = { 'C','C','P','S','e','a','r','c','h',0 };
4297 return msi_unimplemented_action_stub( package, "RMCCPSearch", table );
4298 }
4299
4300 static UINT ACTION_RegisterComPlus( MSIPACKAGE *package )
4301 {
4302 static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
4303 return msi_unimplemented_action_stub( package, "RegisterComPlus", table );
4304 }
4305
4306 static UINT ACTION_UnregisterComPlus( MSIPACKAGE *package )
4307 {
4308 static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
4309 return msi_unimplemented_action_stub( package, "UnregisterComPlus", table );
4310 }
4311
4312 static struct _actions StandardActions[] = {
4313 { szAllocateRegistrySpace, ACTION_AllocateRegistrySpace },
4314 { szAppSearch, ACTION_AppSearch },
4315 { szBindImage, ACTION_BindImage },
4316 { szCCPSearch, ACTION_CCPSearch},
4317 { szCostFinalize, ACTION_CostFinalize },
4318 { szCostInitialize, ACTION_CostInitialize },
4319 { szCreateFolders, ACTION_CreateFolders },
4320 { szCreateShortcuts, ACTION_CreateShortcuts },
4321 { szDeleteServices, ACTION_DeleteServices },
4322 { szDisableRollback, NULL},
4323 { szDuplicateFiles, ACTION_DuplicateFiles },
4324 { szExecuteAction, ACTION_ExecuteAction },
4325 { szFileCost, ACTION_FileCost },
4326 { szFindRelatedProducts, ACTION_FindRelatedProducts },
4327 { szForceReboot, ACTION_ForceReboot },
4328 { szInstallAdminPackage, NULL},
4329 { szInstallExecute, ACTION_InstallExecute },
4330 { szInstallExecuteAgain, ACTION_InstallExecute },
4331 { szInstallFiles, ACTION_InstallFiles},
4332 { szInstallFinalize, ACTION_InstallFinalize },
4333 { szInstallInitialize, ACTION_InstallInitialize },
4334 { szInstallSFPCatalogFile, NULL},
4335 { szInstallValidate, ACTION_InstallValidate },
4336 { szIsolateComponents, ACTION_IsolateComponents },
4337 { szLaunchConditions, ACTION_LaunchConditions },
4338 { szMigrateFeatureStates, ACTION_MigrateFeatureStates },
4339 { szMoveFiles, ACTION_MoveFiles },
4340 { szMsiPublishAssemblies, ACTION_MsiPublishAssemblies },
4341 { szMsiUnpublishAssemblies, ACTION_MsiUnpublishAssemblies },
4342 { szInstallODBC, NULL},
4343 { szInstallServices, ACTION_InstallServices },
4344 { szPatchFiles, ACTION_PatchFiles },
4345 { szProcessComponents, ACTION_ProcessComponents },
4346 { szPublishComponents, ACTION_PublishComponents },
4347 { szPublishFeatures, ACTION_PublishFeatures },
4348 { szPublishProduct, ACTION_PublishProduct },
4349 { szRegisterClassInfo, ACTION_RegisterClassInfo },
4350 { szRegisterComPlus, ACTION_RegisterComPlus},
4351 { szRegisterExtensionInfo, ACTION_RegisterExtensionInfo },
4352 { szRegisterFonts, ACTION_RegisterFonts },
4353 { szRegisterMIMEInfo, ACTION_RegisterMIMEInfo },
4354 { szRegisterProduct, ACTION_RegisterProduct },
4355 { szRegisterProgIdInfo, ACTION_RegisterProgIdInfo },
4356 { szRegisterTypeLibraries, ACTION_RegisterTypeLibraries },
4357 { szRegisterUser, ACTION_RegisterUser},
4358 { szRemoveDuplicateFiles, NULL},
4359 { szRemoveEnvironmentStrings, ACTION_RemoveEnvironmentStrings },
4360 { szRemoveExistingProducts, NULL},
4361 { szRemoveFiles, ACTION_RemoveFiles},
4362 { szRemoveFolders, NULL},
4363 { szRemoveIniValues, ACTION_RemoveIniValues },
4364 { szRemoveODBC, NULL},
4365 { szRemoveRegistryValues, NULL},
4366 { szRemoveShortcuts, NULL},
4367 { szResolveSource, ACTION_ResolveSource},
4368 { szRMCCPSearch, ACTION_RMCCPSearch},
4369 { szScheduleReboot, NULL},
4370 { szSelfRegModules, ACTION_SelfRegModules },
4371 { szSelfUnregModules, ACTION_SelfUnregModules },
4372 { szSetODBCFolders, NULL},
4373 { szStartServices, ACTION_StartServices },
4374 { szStopServices, ACTION_StopServices },
4375 { szUnpublishComponents, NULL},
4376 { szUnpublishFeatures, NULL},
4377 { szUnregisterClassInfo, NULL},
4378 { szUnregisterComPlus, ACTION_UnregisterComPlus},
4379 { szUnregisterExtensionInfo, NULL},
4380 { szUnregisterFonts, ACTION_UnregisterFonts },
4381 { szUnregisterMIMEInfo, NULL},
4382 { szUnregisterProgIdInfo, NULL},
4383 { szUnregisterTypeLibraries, NULL},
4384 { szValidateProductID, NULL},
4385 { szWriteEnvironmentStrings, ACTION_WriteEnvironmentStrings },
4386 { szWriteIniValues, ACTION_WriteIniValues },
4387 { szWriteRegistryValues, ACTION_WriteRegistryValues},
4388 { NULL, NULL},
4389 };
GDI DIB driver