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