?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
advapi32: Make some variables static and/or const.
[wine/multimedia.git] / dlls / msi / action.c
blob63eb9c77d7fe34c7e9f0779d2b429e1adecc4bbf
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 LPWSTR p, tgt_short, tgt_long, src_short, src_long;
1425 LPCWSTR parent;
1426 MSIRECORD *row;
1427 MSIFOLDER *folder;
1428
1429 TRACE("Looking for dir %s\n",debugstr_w(dir));
1430
1431 folder = get_loaded_folder( package, dir );
1432 if (folder)
1433 return folder;
1434
1435 TRACE("Working to load %s\n",debugstr_w(dir));
1436
1437 folder = msi_alloc_zero( sizeof (MSIFOLDER) );
1438 if (!folder)
1439 return NULL;
1440
1441 folder->Directory = strdupW(dir);
1442
1443 row = MSI_QueryGetRecord(package->db, Query, dir);
1444 if (!row)
1445 return NULL;
1446
1447 p = msi_dup_record_field(row, 3);
1448
1449 /* split src and target dir */
1450 tgt_short = p;
1451 src_short = folder_split_path( p, ':' );
1452
1453 /* split the long and short paths */
1454 tgt_long = folder_split_path( tgt_short, '|' );
1455 src_long = folder_split_path( src_short, '|' );
1456
1457 /* check for root dirs */
1458 if (!lstrcmpW(szDot, tgt_short))
1459 tgt_short = NULL;
1460 if (!lstrcmpW(szDot, tgt_long))
1461 tgt_long = NULL;
1462
1463 if (!tgt_long)
1464 tgt_long = tgt_short;
1465
1466 if (!src_short) {
1467 src_short = tgt_short;
1468 src_long = tgt_long;
1469 }
1470
1471 if (!src_long)
1472 src_long = src_short;
1473
1474 /* FIXME: use the target short path too */
1475 folder->TargetDefault = strdupW(tgt_long);
1476 folder->SourceShortPath = strdupW(src_short);
1477 folder->SourceLongPath = strdupW(src_long);
1478 msi_free(p);
1479
1480 TRACE("TargetDefault = %s\n",debugstr_w( folder->TargetDefault ));
1481 TRACE("SourceLong = %s\n", debugstr_w( folder->SourceLongPath ));
1482 TRACE("SourceShort = %s\n", debugstr_w( folder->SourceShortPath ));
1483
1484 parent = MSI_RecordGetString(row, 2);
1485 if (parent)
1486 {
1487 folder->Parent = load_folder( package, parent );
1488 if ( folder->Parent )
1489 TRACE("loaded parent %p %s\n", folder->Parent,
1490 debugstr_w(folder->Parent->Directory));
1491 else
1492 ERR("failed to load parent folder %s\n", debugstr_w(parent));
1493 }
1494
1495 folder->Property = msi_dup_property( package, dir );
1496
1497 msiobj_release(&row->hdr);
1498
1499 list_add_tail( &package->folders, &folder->entry );
1500
1501 TRACE("%s returning %p\n",debugstr_w(dir),folder);
1502
1503 return folder;
1504 }
1505
1506 /* scan for and update current install states */
1507 static void ACTION_UpdateInstallStates(MSIPACKAGE *package)
1508 {
1509 MSICOMPONENT *comp;
1510 MSIFEATURE *feature;
1511
1512 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
1513 {
1514 INSTALLSTATE res;
1515 res = MsiGetComponentPathW( package->ProductCode,
1516 comp->ComponentId, NULL, NULL);
1517 if (res < 0)
1518 res = INSTALLSTATE_ABSENT;
1519 comp->Installed = res;
1520 }
1521
1522 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1523 {
1524 ComponentList *cl;
1525 INSTALLSTATE res = -10;
1526
1527 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1528 {
1529 comp= cl->component;
1530
1531 if (res == -10)
1532 res = comp->Installed;
1533 else
1534 {
1535 if (res == comp->Installed)
1536 continue;
1537
1538 if (res != comp->Installed)
1539 res = INSTALLSTATE_INCOMPLETE;
1540 }
1541 }
1542 feature->Installed = res;
1543 }
1544 }
1545
1546 static BOOL process_state_property (MSIPACKAGE* package, LPCWSTR property,
1547 INSTALLSTATE state)
1548 {
1549 static const WCHAR all[]={'A','L','L',0};
1550 LPWSTR override;
1551 MSIFEATURE *feature;
1552
1553 override = msi_dup_property( package, property );
1554 if (!override)
1555 return FALSE;
1556
1557 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1558 {
1559 if (strcmpiW(override,all)==0)
1560 {
1561 feature->ActionRequest= state;
1562 feature->Action = state;
1563 }
1564 else
1565 {
1566 LPWSTR ptr = override;
1567 LPWSTR ptr2 = strchrW(override,',');
1568
1569 while (ptr)
1570 {
1571 if ((ptr2 && strncmpW(ptr,feature->Feature, ptr2-ptr)==0)
1572 || (!ptr2 && strcmpW(ptr,feature->Feature)==0))
1573 {
1574 feature->ActionRequest= state;
1575 feature->Action = state;
1576 break;
1577 }
1578 if (ptr2)
1579 {
1580 ptr=ptr2+1;
1581 ptr2 = strchrW(ptr,',');
1582 }
1583 else
1584 break;
1585 }
1586 }
1587 }
1588 msi_free(override);
1589
1590 return TRUE;
1591 }
1592
1593 static UINT SetFeatureStates(MSIPACKAGE *package)
1594 {
1595 int install_level;
1596 static const WCHAR szlevel[] =
1597 {'I','N','S','T','A','L','L','L','E','V','E','L',0};
1598 static const WCHAR szAddLocal[] =
1599 {'A','D','D','L','O','C','A','L',0};
1600 static const WCHAR szRemove[] =
1601 {'R','E','M','O','V','E',0};
1602 static const WCHAR szReinstall[] =
1603 {'R','E','I','N','S','T','A','L','L',0};
1604 BOOL override = FALSE;
1605 MSICOMPONENT* component;
1606 MSIFEATURE *feature;
1607
1608
1609 /* I do not know if this is where it should happen.. but */
1610
1611 TRACE("Checking Install Level\n");
1612
1613 install_level = msi_get_property_int( package, szlevel, 1 );
1614
1615 /* ok hereis the _real_ rub
1616 * all these activation/deactivation things happen in order and things
1617 * later on the list override things earlier on the list.
1618 * 1) INSTALLLEVEL processing
1619 * 2) ADDLOCAL
1620 * 3) REMOVE
1621 * 4) ADDSOURCE
1622 * 5) ADDDEFAULT
1623 * 6) REINSTALL
1624 * 7) COMPADDLOCAL
1625 * 8) COMPADDSOURCE
1626 * 9) FILEADDLOCAL
1627 * 10) FILEADDSOURCE
1628 * 11) FILEADDDEFAULT
1629 * I have confirmed that if ADDLOCAL is stated then the INSTALLLEVEL is
1630 * ignored for all the features. seems strange, especially since it is not
1631 * documented anywhere, but it is how it works.
1632 *
1633 * I am still ignoring a lot of these. But that is ok for now, ADDLOCAL and
1634 * REMOVE are the big ones, since we don't handle administrative installs
1635 * yet anyway.
1636 */
1637 override |= process_state_property(package,szAddLocal,INSTALLSTATE_LOCAL);
1638 override |= process_state_property(package,szRemove,INSTALLSTATE_ABSENT);
1639 override |= process_state_property(package,szReinstall,INSTALLSTATE_LOCAL);
1640
1641 if (!override)
1642 {
1643 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1644 {
1645 BOOL feature_state = ((feature->Level > 0) &&
1646 (feature->Level <= install_level));
1647
1648 if ((feature_state) && (feature->Action == INSTALLSTATE_UNKNOWN))
1649 {
1650 if (feature->Attributes & msidbFeatureAttributesFavorSource)
1651 {
1652 feature->ActionRequest = INSTALLSTATE_SOURCE;
1653 feature->Action = INSTALLSTATE_SOURCE;
1654 }
1655 else if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
1656 {
1657 feature->ActionRequest = INSTALLSTATE_ADVERTISED;
1658 feature->Action = INSTALLSTATE_ADVERTISED;
1659 }
1660 else
1661 {
1662 feature->ActionRequest = INSTALLSTATE_LOCAL;
1663 feature->Action = INSTALLSTATE_LOCAL;
1664 }
1665 }
1666 }
1667 }
1668 else
1669 {
1670 /* set the Preselected Property */
1671 static const WCHAR szPreselected[] = {'P','r','e','s','e','l','e','c','t','e','d',0};
1672 static const WCHAR szOne[] = { '1', 0 };
1673
1674 MSI_SetPropertyW(package,szPreselected,szOne);
1675 }
1676
1677 /*
1678 * now we want to enable or disable components base on feature
1679 */
1680
1681 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1682 {
1683 ComponentList *cl;
1684
1685 TRACE("Examining Feature %s (Installed %i, Action %i, Request %i)\n",
1686 debugstr_w(feature->Feature), feature->Installed, feature->Action,
1687 feature->ActionRequest);
1688
1689 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1690 {
1691 component = cl->component;
1692
1693 if (!component->Enabled)
1694 {
1695 component->Action = INSTALLSTATE_UNKNOWN;
1696 component->ActionRequest = INSTALLSTATE_UNKNOWN;
1697 }
1698 else
1699 {
1700 if (feature->Action == INSTALLSTATE_LOCAL)
1701 {
1702 component->Action = INSTALLSTATE_LOCAL;
1703 component->ActionRequest = INSTALLSTATE_LOCAL;
1704 }
1705 else if (feature->ActionRequest == INSTALLSTATE_SOURCE)
1706 {
1707 if ((component->Action == INSTALLSTATE_UNKNOWN) ||
1708 (component->Action == INSTALLSTATE_ABSENT) ||
1709 (component->Action == INSTALLSTATE_ADVERTISED))
1710
1711 {
1712 component->Action = INSTALLSTATE_SOURCE;
1713 component->ActionRequest = INSTALLSTATE_SOURCE;
1714 }
1715 }
1716 else if (feature->ActionRequest == INSTALLSTATE_ADVERTISED)
1717 {
1718 if ((component->Action == INSTALLSTATE_UNKNOWN) ||
1719 (component->Action == INSTALLSTATE_ABSENT))
1720
1721 {
1722 component->Action = INSTALLSTATE_ADVERTISED;
1723 component->ActionRequest = INSTALLSTATE_ADVERTISED;
1724 }
1725 }
1726 else if (feature->ActionRequest == INSTALLSTATE_ABSENT)
1727 {
1728 if (component->Action == INSTALLSTATE_UNKNOWN)
1729 {
1730 component->Action = INSTALLSTATE_ABSENT;
1731 component->ActionRequest = INSTALLSTATE_ABSENT;
1732 }
1733 }
1734 }
1735 }
1736 }
1737
1738 LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
1739 {
1740 TRACE("Result: Component %s (Installed %i, Action %i, Request %i)\n",
1741 debugstr_w(component->Component), component->Installed,
1742 component->Action, component->ActionRequest);
1743 }
1744
1745
1746 return ERROR_SUCCESS;
1747 }
1748
1749 static UINT ITERATE_CostFinalizeDirectories(MSIRECORD *row, LPVOID param)
1750 {
1751 MSIPACKAGE *package = (MSIPACKAGE*)param;
1752 LPCWSTR name;
1753 LPWSTR path;
1754
1755 name = MSI_RecordGetString(row,1);
1756
1757 /* This helper function now does ALL the work */
1758 TRACE("Dir %s ...\n",debugstr_w(name));
1759 load_folder(package,name);
1760 path = resolve_folder(package,name,FALSE,TRUE,NULL);
1761 TRACE("resolves to %s\n",debugstr_w(path));
1762 msi_free(path);
1763
1764 return ERROR_SUCCESS;
1765 }
1766
1767 static UINT ITERATE_CostFinalizeConditions(MSIRECORD *row, LPVOID param)
1768 {
1769 MSIPACKAGE *package = (MSIPACKAGE*)param;
1770 LPCWSTR name;
1771 MSIFEATURE *feature;
1772
1773 name = MSI_RecordGetString( row, 1 );
1774
1775 feature = get_loaded_feature( package, name );
1776 if (!feature)
1777 ERR("FAILED to find loaded feature %s\n",debugstr_w(name));
1778 else
1779 {
1780 LPCWSTR Condition;
1781 Condition = MSI_RecordGetString(row,3);
1782
1783 if (MSI_EvaluateConditionW(package,Condition) == MSICONDITION_TRUE)
1784 {
1785 int level = MSI_RecordGetInteger(row,2);
1786 TRACE("Reseting feature %s to level %i\n", debugstr_w(name), level);
1787 feature->Level = level;
1788 }
1789 }
1790 return ERROR_SUCCESS;
1791 }
1792
1793
1794 /*
1795 * A lot is done in this function aside from just the costing.
1796 * The costing needs to be implemented at some point but for now I am going
1797 * to focus on the directory building
1798 *
1799 */
1800 static UINT ACTION_CostFinalize(MSIPACKAGE *package)
1801 {
1802 static const WCHAR ExecSeqQuery[] =
1803 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1804 '`','D','i','r','e','c','t','o','r','y','`',0};
1805 static const WCHAR ConditionQuery[] =
1806 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1807 '`','C','o','n','d','i','t','i','o','n','`',0};
1808 static const WCHAR szCosting[] =
1809 {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
1810 static const WCHAR szlevel[] =
1811 {'I','N','S','T','A','L','L','L','E','V','E','L',0};
1812 static const WCHAR szOne[] = { '1', 0 };
1813 MSICOMPONENT *comp;
1814 MSIFILE *file;
1815 UINT rc;
1816 MSIQUERY * view;
1817 LPWSTR level;
1818
1819 if ( 1 == msi_get_property_int( package, szCosting, 0 ) )
1820 return ERROR_SUCCESS;
1821
1822 TRACE("Building Directory properties\n");
1823
1824 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
1825 if (rc == ERROR_SUCCESS)
1826 {
1827 rc = MSI_IterateRecords(view, NULL, ITERATE_CostFinalizeDirectories,
1828 package);
1829 msiobj_release(&view->hdr);
1830 }
1831
1832 TRACE("File calculations\n");
1833
1834 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
1835 {
1836 MSICOMPONENT* comp = file->Component;
1837 LPWSTR p;
1838
1839 if (!comp)
1840 continue;
1841
1842 /* calculate target */
1843 p = resolve_folder(package, comp->Directory, FALSE, FALSE, NULL);
1844
1845 msi_free(file->TargetPath);
1846
1847 TRACE("file %s is named %s\n",
1848 debugstr_w(file->File),debugstr_w(file->FileName));
1849
1850 file->TargetPath = build_directory_name(2, p, file->FileName);
1851
1852 msi_free(p);
1853
1854 TRACE("file %s resolves to %s\n",
1855 debugstr_w(file->File),debugstr_w(file->TargetPath));
1856
1857 if (GetFileAttributesW(file->TargetPath) == INVALID_FILE_ATTRIBUTES)
1858 {
1859 file->state = msifs_missing;
1860 comp->Cost += file->FileSize;
1861 continue;
1862 }
1863
1864 if (file->Version)
1865 {
1866 DWORD handle;
1867 DWORD versize;
1868 UINT sz;
1869 LPVOID version;
1870 static WCHAR name[] = {'\\',0};
1871 static const WCHAR name_fmt[] =
1872 {'%','u','.','%','u','.','%','u','.','%','u',0};
1873 WCHAR filever[0x100];
1874 VS_FIXEDFILEINFO *lpVer;
1875
1876 TRACE("Version comparison..\n");
1877 versize = GetFileVersionInfoSizeW(file->TargetPath,&handle);
1878 version = msi_alloc(versize);
1879 GetFileVersionInfoW(file->TargetPath, 0, versize, version);
1880
1881 VerQueryValueW(version, name, (LPVOID*)&lpVer, &sz);
1882
1883 sprintfW(filever,name_fmt,
1884 HIWORD(lpVer->dwFileVersionMS),
1885 LOWORD(lpVer->dwFileVersionMS),
1886 HIWORD(lpVer->dwFileVersionLS),
1887 LOWORD(lpVer->dwFileVersionLS));
1888
1889 TRACE("new %s old %s\n", debugstr_w(file->Version),
1890 debugstr_w(filever));
1891 if (strcmpiW(filever,file->Version)<0)
1892 {
1893 file->state = msifs_overwrite;
1894 /* FIXME: cost should be diff in size */
1895 comp->Cost += file->FileSize;
1896 }
1897 else
1898 file->state = msifs_present;
1899 msi_free(version);
1900 }
1901 else
1902 file->state = msifs_present;
1903 }
1904
1905 TRACE("Evaluating Condition Table\n");
1906
1907 rc = MSI_DatabaseOpenViewW(package->db, ConditionQuery, &view);
1908 if (rc == ERROR_SUCCESS)
1909 {
1910 rc = MSI_IterateRecords(view, NULL, ITERATE_CostFinalizeConditions,
1911 package);
1912 msiobj_release(&view->hdr);
1913 }
1914
1915 TRACE("Enabling or Disabling Components\n");
1916 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
1917 {
1918 if (comp->Condition)
1919 {
1920 if (MSI_EvaluateConditionW(package,
1921 comp->Condition) == MSICONDITION_FALSE)
1922 {
1923 TRACE("Disabling component %s\n", debugstr_w(comp->Component));
1924 comp->Enabled = FALSE;
1925 }
1926 }
1927 }
1928
1929 MSI_SetPropertyW(package,szCosting,szOne);
1930 /* set default run level if not set */
1931 level = msi_dup_property( package, szlevel );
1932 if (!level)
1933 MSI_SetPropertyW(package,szlevel, szOne);
1934 msi_free(level);
1935
1936 ACTION_UpdateInstallStates(package);
1937
1938 return SetFeatureStates(package);
1939 }
1940
1941 /* OK this value is "interpreted" and then formatted based on the
1942 first few characters */
1943 static LPSTR parse_value(MSIPACKAGE *package, LPCWSTR value, DWORD *type,
1944 DWORD *size)
1945 {
1946 LPSTR data = NULL;
1947 if (value[0]=='#' && value[1]!='#' && value[1]!='%')
1948 {
1949 if (value[1]=='x')
1950 {
1951 LPWSTR ptr;
1952 CHAR byte[5];
1953 LPWSTR deformated = NULL;
1954 int count;
1955
1956 deformat_string(package, &value[2], &deformated);
1957
1958 /* binary value type */
1959 ptr = deformated;
1960 *type = REG_BINARY;
1961 if (strlenW(ptr)%2)
1962 *size = (strlenW(ptr)/2)+1;
1963 else
1964 *size = strlenW(ptr)/2;
1965
1966 data = msi_alloc(*size);
1967
1968 byte[0] = '0';
1969 byte[1] = 'x';
1970 byte[4] = 0;
1971 count = 0;
1972 /* if uneven pad with a zero in front */
1973 if (strlenW(ptr)%2)
1974 {
1975 byte[2]= '0';
1976 byte[3]= *ptr;
1977 ptr++;
1978 data[count] = (BYTE)strtol(byte,NULL,0);
1979 count ++;
1980 TRACE("Uneven byte count\n");
1981 }
1982 while (*ptr)
1983 {
1984 byte[2]= *ptr;
1985 ptr++;
1986 byte[3]= *ptr;
1987 ptr++;
1988 data[count] = (BYTE)strtol(byte,NULL,0);
1989 count ++;
1990 }
1991 msi_free(deformated);
1992
1993 TRACE("Data %li bytes(%i)\n",*size,count);
1994 }
1995 else
1996 {
1997 LPWSTR deformated;
1998 LPWSTR p;
1999 DWORD d = 0;
2000 deformat_string(package, &value[1], &deformated);
2001
2002 *type=REG_DWORD;
2003 *size = sizeof(DWORD);
2004 data = msi_alloc(*size);
2005 p = deformated;
2006 if (*p == '-')
2007 p++;
2008 while (*p)
2009 {
2010 if ( (*p < '0') || (*p > '9') )
2011 break;
2012 d *= 10;
2013 d += (*p - '0');
2014 p++;
2015 }
2016 if (deformated[0] == '-')
2017 d = -d;
2018 *(LPDWORD)data = d;
2019 TRACE("DWORD %li\n",*(LPDWORD)data);
2020
2021 msi_free(deformated);
2022 }
2023 }
2024 else
2025 {
2026 static const WCHAR szMulti[] = {'[','~',']',0};
2027 LPCWSTR ptr;
2028 *type=REG_SZ;
2029
2030 if (value[0]=='#')
2031 {
2032 if (value[1]=='%')
2033 {
2034 ptr = &value[2];
2035 *type=REG_EXPAND_SZ;
2036 }
2037 else
2038 ptr = &value[1];
2039 }
2040 else
2041 ptr=value;
2042
2043 if (strstrW(value,szMulti))
2044 *type = REG_MULTI_SZ;
2045
2046 *size = deformat_string(package, ptr,(LPWSTR*)&data);
2047 }
2048 return data;
2049 }
2050
2051 static UINT ITERATE_WriteRegistryValues(MSIRECORD *row, LPVOID param)
2052 {
2053 MSIPACKAGE *package = (MSIPACKAGE*)param;
2054 static const WCHAR szHCR[] =
2055 {'H','K','E','Y','_','C','L','A','S','S','E','S','_',
2056 'R','O','O','T','\\',0};
2057 static const WCHAR szHCU[] =
2058 {'H','K','E','Y','_','C','U','R','R','E','N','T','_',
2059 'U','S','E','R','\\',0};
2060 static const WCHAR szHLM[] =
2061 {'H','K','E','Y','_','L','O','C','A','L','_',
2062 'M','A','C','H','I','N','E','\\',0};
2063 static const WCHAR szHU[] =
2064 {'H','K','E','Y','_','U','S','E','R','S','\\',0};
2065
2066 LPSTR value_data = NULL;
2067 HKEY root_key, hkey;
2068 DWORD type,size;
2069 LPWSTR deformated;
2070 LPCWSTR szRoot, component, name, key, value;
2071 MSICOMPONENT *comp;
2072 MSIRECORD * uirow;
2073 LPWSTR uikey;
2074 INT root;
2075 BOOL check_first = FALSE;
2076 UINT rc;
2077
2078 ui_progress(package,2,0,0,0);
2079
2080 value = NULL;
2081 key = NULL;
2082 uikey = NULL;
2083 name = NULL;
2084
2085 component = MSI_RecordGetString(row, 6);
2086 comp = get_loaded_component(package,component);
2087 if (!comp)
2088 return ERROR_SUCCESS;
2089
2090 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2091 {
2092 TRACE("Skipping write due to disabled component %s\n",
2093 debugstr_w(component));
2094
2095 comp->Action = comp->Installed;
2096
2097 return ERROR_SUCCESS;
2098 }
2099
2100 comp->Action = INSTALLSTATE_LOCAL;
2101
2102 name = MSI_RecordGetString(row, 4);
2103 if( MSI_RecordIsNull(row,5) && name )
2104 {
2105 /* null values can have special meanings */
2106 if (name[0]=='-' && name[1] == 0)
2107 return ERROR_SUCCESS;
2108 else if ((name[0]=='+' && name[1] == 0) ||
2109 (name[0] == '*' && name[1] == 0))
2110 name = NULL;
2111 check_first = TRUE;
2112 }
2113
2114 root = MSI_RecordGetInteger(row,2);
2115 key = MSI_RecordGetString(row, 3);
2116
2117 /* get the root key */
2118 switch (root)
2119 {
2120 case -1:
2121 {
2122 static const WCHAR szALLUSER[] = {'A','L','L','U','S','E','R','S',0};
2123 LPWSTR all_users = msi_dup_property( package, szALLUSER );
2124 if (all_users && all_users[0] == '1')
2125 {
2126 root_key = HKEY_LOCAL_MACHINE;
2127 szRoot = szHLM;
2128 }
2129 else
2130 {
2131 root_key = HKEY_CURRENT_USER;
2132 szRoot = szHCU;
2133 }
2134 msi_free(all_users);
2135 }
2136 break;
2137 case 0: root_key = HKEY_CLASSES_ROOT;
2138 szRoot = szHCR;
2139 break;
2140 case 1: root_key = HKEY_CURRENT_USER;
2141 szRoot = szHCU;
2142 break;
2143 case 2: root_key = HKEY_LOCAL_MACHINE;
2144 szRoot = szHLM;
2145 break;
2146 case 3: root_key = HKEY_USERS;
2147 szRoot = szHU;
2148 break;
2149 default:
2150 ERR("Unknown root %i\n",root);
2151 root_key=NULL;
2152 szRoot = NULL;
2153 break;
2154 }
2155 if (!root_key)
2156 return ERROR_SUCCESS;
2157
2158 deformat_string(package, key , &deformated);
2159 size = strlenW(deformated) + strlenW(szRoot) + 1;
2160 uikey = msi_alloc(size*sizeof(WCHAR));
2161 strcpyW(uikey,szRoot);
2162 strcatW(uikey,deformated);
2163
2164 if (RegCreateKeyW( root_key, deformated, &hkey))
2165 {
2166 ERR("Could not create key %s\n",debugstr_w(deformated));
2167 msi_free(deformated);
2168 msi_free(uikey);
2169 return ERROR_SUCCESS;
2170 }
2171 msi_free(deformated);
2172
2173 value = MSI_RecordGetString(row,5);
2174 if (value)
2175 value_data = parse_value(package, value, &type, &size);
2176 else
2177 {
2178 static const WCHAR szEmpty[] = {0};
2179 value_data = (LPSTR)strdupW(szEmpty);
2180 size = 0;
2181 type = REG_SZ;
2182 }
2183
2184 deformat_string(package, name, &deformated);
2185
2186 /* get the double nulls to terminate SZ_MULTI */
2187 if (type == REG_MULTI_SZ)
2188 size +=sizeof(WCHAR);
2189
2190 if (!check_first)
2191 {
2192 TRACE("Setting value %s of %s\n",debugstr_w(deformated),
2193 debugstr_w(uikey));
2194 RegSetValueExW(hkey, deformated, 0, type, (LPBYTE)value_data, size);
2195 }
2196 else
2197 {
2198 DWORD sz = 0;
2199 rc = RegQueryValueExW(hkey, deformated, NULL, NULL, NULL, &sz);
2200 if (rc == ERROR_SUCCESS || rc == ERROR_MORE_DATA)
2201 {
2202 TRACE("value %s of %s checked already exists\n",
2203 debugstr_w(deformated), debugstr_w(uikey));
2204 }
2205 else
2206 {
2207 TRACE("Checked and setting value %s of %s\n",
2208 debugstr_w(deformated), debugstr_w(uikey));
2209 if (deformated || size)
2210 RegSetValueExW(hkey, deformated, 0, type, (LPBYTE) value_data, size);
2211 }
2212 }
2213 RegCloseKey(hkey);
2214
2215 uirow = MSI_CreateRecord(3);
2216 MSI_RecordSetStringW(uirow,2,deformated);
2217 MSI_RecordSetStringW(uirow,1,uikey);
2218
2219 if (type == REG_SZ)
2220 MSI_RecordSetStringW(uirow,3,(LPWSTR)value_data);
2221 else
2222 MSI_RecordSetStringW(uirow,3,value);
2223
2224 ui_actiondata(package,szWriteRegistryValues,uirow);
2225 msiobj_release( &uirow->hdr );
2226
2227 msi_free(value_data);
2228 msi_free(deformated);
2229 msi_free(uikey);
2230
2231 return ERROR_SUCCESS;
2232 }
2233
2234 static UINT ACTION_WriteRegistryValues(MSIPACKAGE *package)
2235 {
2236 UINT rc;
2237 MSIQUERY * view;
2238 static const WCHAR ExecSeqQuery[] =
2239 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2240 '`','R','e','g','i','s','t','r','y','`',0 };
2241
2242 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2243 if (rc != ERROR_SUCCESS)
2244 return ERROR_SUCCESS;
2245
2246 /* increment progress bar each time action data is sent */
2247 ui_progress(package,1,REG_PROGRESS_VALUE,1,0);
2248
2249 rc = MSI_IterateRecords(view, NULL, ITERATE_WriteRegistryValues, package);
2250
2251 msiobj_release(&view->hdr);
2252 return rc;
2253 }
2254
2255 static UINT ACTION_InstallInitialize(MSIPACKAGE *package)
2256 {
2257 package->script->CurrentlyScripting = TRUE;
2258
2259 return ERROR_SUCCESS;
2260 }
2261
2262
2263 static UINT ACTION_InstallValidate(MSIPACKAGE *package)
2264 {
2265 MSICOMPONENT *comp;
2266 DWORD progress = 0;
2267 DWORD total = 0;
2268 static const WCHAR q1[]=
2269 {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
2270 '`','R','e','g','i','s','t','r','y','`',0};
2271 UINT rc;
2272 MSIQUERY * view;
2273 MSIFEATURE *feature;
2274 MSIFILE *file;
2275
2276 TRACE("InstallValidate\n");
2277
2278 rc = MSI_DatabaseOpenViewW(package->db, q1, &view);
2279 if (rc == ERROR_SUCCESS)
2280 {
2281 MSI_IterateRecords( view, &progress, NULL, package );
2282 msiobj_release( &view->hdr );
2283 total += progress * REG_PROGRESS_VALUE;
2284 }
2285
2286 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2287 total += COMPONENT_PROGRESS_VALUE;
2288
2289 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2290 total += file->FileSize;
2291
2292 ui_progress(package,0,total,0,0);
2293
2294 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2295 {
2296 TRACE("Feature: %s; Installed: %i; Action %i; Request %i\n",
2297 debugstr_w(feature->Feature), feature->Installed, feature->Action,
2298 feature->ActionRequest);
2299 }
2300
2301 return ERROR_SUCCESS;
2302 }
2303
2304 static UINT ITERATE_LaunchConditions(MSIRECORD *row, LPVOID param)
2305 {
2306 MSIPACKAGE* package = (MSIPACKAGE*)param;
2307 LPCWSTR cond = NULL;
2308 LPCWSTR message = NULL;
2309 static const WCHAR title[]=
2310 {'I','n','s','t','a','l','l',' ','F','a', 'i','l','e','d',0};
2311
2312 cond = MSI_RecordGetString(row,1);
2313
2314 if (MSI_EvaluateConditionW(package,cond) != MSICONDITION_TRUE)
2315 {
2316 LPWSTR deformated;
2317 message = MSI_RecordGetString(row,2);
2318 deformat_string(package,message,&deformated);
2319 MessageBoxW(NULL,deformated,title,MB_OK);
2320 msi_free(deformated);
2321 return ERROR_FUNCTION_FAILED;
2322 }
2323
2324 return ERROR_SUCCESS;
2325 }
2326
2327 static UINT ACTION_LaunchConditions(MSIPACKAGE *package)
2328 {
2329 UINT rc;
2330 MSIQUERY * view = NULL;
2331 static const WCHAR ExecSeqQuery[] =
2332 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2333 '`','L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','`',0};
2334
2335 TRACE("Checking launch conditions\n");
2336
2337 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2338 if (rc != ERROR_SUCCESS)
2339 return ERROR_SUCCESS;
2340
2341 rc = MSI_IterateRecords(view, NULL, ITERATE_LaunchConditions, package);
2342 msiobj_release(&view->hdr);
2343
2344 return rc;
2345 }
2346
2347 static LPWSTR resolve_keypath( MSIPACKAGE* package, MSICOMPONENT *cmp )
2348 {
2349
2350 if (!cmp->KeyPath)
2351 return resolve_folder(package,cmp->Directory,FALSE,FALSE,NULL);
2352
2353 if (cmp->Attributes & msidbComponentAttributesRegistryKeyPath)
2354 {
2355 MSIRECORD * row = 0;
2356 UINT root,len;
2357 LPWSTR deformated,buffer,deformated_name;
2358 LPCWSTR key,name;
2359 static const WCHAR ExecSeqQuery[] =
2360 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2361 '`','R','e','g','i','s','t','r','y','`',' ',
2362 'W','H','E','R','E',' ', '`','R','e','g','i','s','t','r','y','`',
2363 ' ','=',' ' ,'\'','%','s','\'',0 };
2364 static const WCHAR fmt[]={'%','0','2','i',':','\\','%','s','\\',0};
2365 static const WCHAR fmt2[]=
2366 {'%','0','2','i',':','\\','%','s','\\','%','s',0};
2367
2368 row = MSI_QueryGetRecord(package->db, ExecSeqQuery,cmp->KeyPath);
2369 if (!row)
2370 return NULL;
2371
2372 root = MSI_RecordGetInteger(row,2);
2373 key = MSI_RecordGetString(row, 3);
2374 name = MSI_RecordGetString(row, 4);
2375 deformat_string(package, key , &deformated);
2376 deformat_string(package, name, &deformated_name);
2377
2378 len = strlenW(deformated) + 6;
2379 if (deformated_name)
2380 len+=strlenW(deformated_name);
2381
2382 buffer = msi_alloc( len *sizeof(WCHAR));
2383
2384 if (deformated_name)
2385 sprintfW(buffer,fmt2,root,deformated,deformated_name);
2386 else
2387 sprintfW(buffer,fmt,root,deformated);
2388
2389 msi_free(deformated);
2390 msi_free(deformated_name);
2391 msiobj_release(&row->hdr);
2392
2393 return buffer;
2394 }
2395 else if (cmp->Attributes & msidbComponentAttributesODBCDataSource)
2396 {
2397 FIXME("UNIMPLEMENTED keypath as ODBC Source\n");
2398 return NULL;
2399 }
2400 else
2401 {
2402 MSIFILE *file = get_loaded_file( package, cmp->KeyPath );
2403
2404 if (file)
2405 return strdupW( file->TargetPath );
2406 }
2407 return NULL;
2408 }
2409
2410 static HKEY openSharedDLLsKey(void)
2411 {
2412 HKEY hkey=0;
2413 static const WCHAR path[] =
2414 {'S','o','f','t','w','a','r','e','\\',
2415 'M','i','c','r','o','s','o','f','t','\\',
2416 'W','i','n','d','o','w','s','\\',
2417 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
2418 'S','h','a','r','e','d','D','L','L','s',0};
2419
2420 RegCreateKeyW(HKEY_LOCAL_MACHINE,path,&hkey);
2421 return hkey;
2422 }
2423
2424 static UINT ACTION_GetSharedDLLsCount(LPCWSTR dll)
2425 {
2426 HKEY hkey;
2427 DWORD count=0;
2428 DWORD type;
2429 DWORD sz = sizeof(count);
2430 DWORD rc;
2431
2432 hkey = openSharedDLLsKey();
2433 rc = RegQueryValueExW(hkey, dll, NULL, &type, (LPBYTE)&count, &sz);
2434 if (rc != ERROR_SUCCESS)
2435 count = 0;
2436 RegCloseKey(hkey);
2437 return count;
2438 }
2439
2440 static UINT ACTION_WriteSharedDLLsCount(LPCWSTR path, UINT count)
2441 {
2442 HKEY hkey;
2443
2444 hkey = openSharedDLLsKey();
2445 if (count > 0)
2446 msi_reg_set_val_dword( hkey, path, count );
2447 else
2448 RegDeleteValueW(hkey,path);
2449 RegCloseKey(hkey);
2450 return count;
2451 }
2452
2453 /*
2454 * Return TRUE if the count should be written out and FALSE if not
2455 */
2456 static void ACTION_RefCountComponent( MSIPACKAGE* package, MSICOMPONENT *comp )
2457 {
2458 MSIFEATURE *feature;
2459 INT count = 0;
2460 BOOL write = FALSE;
2461
2462 /* only refcount DLLs */
2463 if (comp->KeyPath == NULL ||
2464 comp->Attributes & msidbComponentAttributesRegistryKeyPath ||
2465 comp->Attributes & msidbComponentAttributesODBCDataSource)
2466 write = FALSE;
2467 else
2468 {
2469 count = ACTION_GetSharedDLLsCount( comp->FullKeypath);
2470 write = (count > 0);
2471
2472 if (comp->Attributes & msidbComponentAttributesSharedDllRefCount)
2473 write = TRUE;
2474 }
2475
2476 /* increment counts */
2477 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2478 {
2479 ComponentList *cl;
2480
2481 if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_LOCAL ))
2482 continue;
2483
2484 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
2485 {
2486 if ( cl->component == comp )
2487 count++;
2488 }
2489 }
2490
2491 /* decrement counts */
2492 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2493 {
2494 ComponentList *cl;
2495
2496 if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_ABSENT ))
2497 continue;
2498
2499 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
2500 {
2501 if ( cl->component == comp )
2502 count--;
2503 }
2504 }
2505
2506 /* ref count all the files in the component */
2507 if (write)
2508 {
2509 MSIFILE *file;
2510
2511 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2512 {
2513 if (file->Component == comp)
2514 ACTION_WriteSharedDLLsCount( file->TargetPath, count );
2515 }
2516 }
2517
2518 /* add a count for permenent */
2519 if (comp->Attributes & msidbComponentAttributesPermanent)
2520 count ++;
2521
2522 comp->RefCount = count;
2523
2524 if (write)
2525 ACTION_WriteSharedDLLsCount( comp->FullKeypath, comp->RefCount );
2526 }
2527
2528 /*
2529 * Ok further analysis makes me think that this work is
2530 * actually done in the PublishComponents and PublishFeatures
2531 * step, and not here. It appears like the keypath and all that is
2532 * resolved in this step, however actually written in the Publish steps.
2533 * But we will leave it here for now because it is unclear
2534 */
2535 static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
2536 {
2537 WCHAR squished_pc[GUID_SIZE];
2538 WCHAR squished_cc[GUID_SIZE];
2539 UINT rc;
2540 MSICOMPONENT *comp;
2541 HKEY hkey=0,hkey2=0;
2542
2543 /* writes the Component and Features values to the registry */
2544
2545 rc = MSIREG_OpenComponents(&hkey);
2546 if (rc != ERROR_SUCCESS)
2547 return rc;
2548
2549 squash_guid(package->ProductCode,squished_pc);
2550 ui_progress(package,1,COMPONENT_PROGRESS_VALUE,1,0);
2551
2552 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2553 {
2554 MSIRECORD * uirow;
2555
2556 ui_progress(package,2,0,0,0);
2557 if (!comp->ComponentId)
2558 continue;
2559
2560 squash_guid(comp->ComponentId,squished_cc);
2561
2562 msi_free(comp->FullKeypath);
2563 comp->FullKeypath = resolve_keypath( package, comp );
2564
2565 /* do the refcounting */
2566 ACTION_RefCountComponent( package, comp );
2567
2568 TRACE("Component %s (%s), Keypath=%s, RefCount=%i\n",
2569 debugstr_w(comp->Component),
2570 debugstr_w(squished_cc),
2571 debugstr_w(comp->FullKeypath),
2572 comp->RefCount);
2573 /*
2574 * Write the keypath out if the component is to be registered
2575 * and delete the key if the component is to be deregistered
2576 */
2577 if (ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2578 {
2579 rc = RegCreateKeyW(hkey,squished_cc,&hkey2);
2580 if (rc != ERROR_SUCCESS)
2581 continue;
2582
2583 if (!comp->FullKeypath)
2584 continue;
2585
2586 msi_reg_set_val_str( hkey2, squished_pc, comp->FullKeypath );
2587
2588 if (comp->Attributes & msidbComponentAttributesPermanent)
2589 {
2590 static const WCHAR szPermKey[] =
2591 { '0','0','0','0','0','0','0','0','0','0','0','0',
2592 '0','0','0','0','0','0','0','0','0','0','0','0',
2593 '0','0','0','0','0','0','0','0',0 };
2594
2595 msi_reg_set_val_str( hkey2, szPermKey, comp->FullKeypath );
2596 }
2597
2598 RegCloseKey(hkey2);
2599
2600 /* UI stuff */
2601 uirow = MSI_CreateRecord(3);
2602 MSI_RecordSetStringW(uirow,1,package->ProductCode);
2603 MSI_RecordSetStringW(uirow,2,comp->ComponentId);
2604 MSI_RecordSetStringW(uirow,3,comp->FullKeypath);
2605 ui_actiondata(package,szProcessComponents,uirow);
2606 msiobj_release( &uirow->hdr );
2607 }
2608 else if (ACTION_VerifyComponentForAction( comp, INSTALLSTATE_ABSENT))
2609 {
2610 DWORD res;
2611
2612 rc = RegOpenKeyW(hkey,squished_cc,&hkey2);
2613 if (rc != ERROR_SUCCESS)
2614 continue;
2615
2616 RegDeleteValueW(hkey2,squished_pc);
2617
2618 /* if the key is empty delete it */
2619 res = RegEnumKeyExW(hkey2,0,NULL,0,0,NULL,0,NULL);
2620 RegCloseKey(hkey2);
2621 if (res == ERROR_NO_MORE_ITEMS)
2622 RegDeleteKeyW(hkey,squished_cc);
2623
2624 /* UI stuff */
2625 uirow = MSI_CreateRecord(2);
2626 MSI_RecordSetStringW(uirow,1,package->ProductCode);
2627 MSI_RecordSetStringW(uirow,2,comp->ComponentId);
2628 ui_actiondata(package,szProcessComponents,uirow);
2629 msiobj_release( &uirow->hdr );
2630 }
2631 }
2632 RegCloseKey(hkey);
2633 return rc;
2634 }
2635
2636 typedef struct {
2637 CLSID clsid;
2638 LPWSTR source;
2639
2640 LPWSTR path;
2641 ITypeLib *ptLib;
2642 } typelib_struct;
2643
2644 static BOOL CALLBACK Typelib_EnumResNameProc( HMODULE hModule, LPCWSTR lpszType,
2645 LPWSTR lpszName, LONG_PTR lParam)
2646 {
2647 TLIBATTR *attr;
2648 typelib_struct *tl_struct = (typelib_struct*) lParam;
2649 static const WCHAR fmt[] = {'%','s','\\','%','i',0};
2650 int sz;
2651 HRESULT res;
2652
2653 if (!IS_INTRESOURCE(lpszName))
2654 {
2655 ERR("Not Int Resource Name %s\n",debugstr_w(lpszName));
2656 return TRUE;
2657 }
2658
2659 sz = strlenW(tl_struct->source)+4;
2660 sz *= sizeof(WCHAR);
2661
2662 if ((INT_PTR)lpszName == 1)
2663 tl_struct->path = strdupW(tl_struct->source);
2664 else
2665 {
2666 tl_struct->path = msi_alloc(sz);
2667 sprintfW(tl_struct->path,fmt,tl_struct->source, lpszName);
2668 }
2669
2670 TRACE("trying %s\n", debugstr_w(tl_struct->path));
2671 res = LoadTypeLib(tl_struct->path,&tl_struct->ptLib);
2672 if (!SUCCEEDED(res))
2673 {
2674 msi_free(tl_struct->path);
2675 tl_struct->path = NULL;
2676
2677 return TRUE;
2678 }
2679
2680 ITypeLib_GetLibAttr(tl_struct->ptLib, &attr);
2681 if (IsEqualGUID(&(tl_struct->clsid),&(attr->guid)))
2682 {
2683 ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
2684 return FALSE;
2685 }
2686
2687 msi_free(tl_struct->path);
2688 tl_struct->path = NULL;
2689
2690 ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
2691 ITypeLib_Release(tl_struct->ptLib);
2692
2693 return TRUE;
2694 }
2695
2696 static UINT ITERATE_RegisterTypeLibraries(MSIRECORD *row, LPVOID param)
2697 {
2698 MSIPACKAGE* package = (MSIPACKAGE*)param;
2699 LPCWSTR component;
2700 MSICOMPONENT *comp;
2701 MSIFILE *file;
2702 typelib_struct tl_struct;
2703 HMODULE module;
2704 static const WCHAR szTYPELIB[] = {'T','Y','P','E','L','I','B',0};
2705
2706 component = MSI_RecordGetString(row,3);
2707 comp = get_loaded_component(package,component);
2708 if (!comp)
2709 return ERROR_SUCCESS;
2710
2711 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2712 {
2713 TRACE("Skipping typelib reg due to disabled component\n");
2714
2715 comp->Action = comp->Installed;
2716
2717 return ERROR_SUCCESS;
2718 }
2719
2720 comp->Action = INSTALLSTATE_LOCAL;
2721
2722 file = get_loaded_file( package, comp->KeyPath );
2723 if (!file)
2724 return ERROR_SUCCESS;
2725
2726 module = LoadLibraryExW( file->TargetPath, NULL, LOAD_LIBRARY_AS_DATAFILE );
2727 if (module)
2728 {
2729 LPCWSTR guid;
2730 guid = MSI_RecordGetString(row,1);
2731 CLSIDFromString((LPWSTR)guid, &tl_struct.clsid);
2732 tl_struct.source = strdupW( file->TargetPath );
2733 tl_struct.path = NULL;
2734
2735 EnumResourceNamesW(module, szTYPELIB, Typelib_EnumResNameProc,
2736 (LONG_PTR)&tl_struct);
2737
2738 if (tl_struct.path)
2739 {
2740 LPWSTR help = NULL;
2741 LPCWSTR helpid;
2742 HRESULT res;
2743
2744 helpid = MSI_RecordGetString(row,6);
2745
2746 if (helpid)
2747 help = resolve_folder(package,helpid,FALSE,FALSE,NULL);
2748 res = RegisterTypeLib(tl_struct.ptLib,tl_struct.path,help);
2749 msi_free(help);
2750
2751 if (!SUCCEEDED(res))
2752 ERR("Failed to register type library %s\n",
2753 debugstr_w(tl_struct.path));
2754 else
2755 {
2756 ui_actiondata(package,szRegisterTypeLibraries,row);
2757
2758 TRACE("Registered %s\n", debugstr_w(tl_struct.path));
2759 }
2760
2761 ITypeLib_Release(tl_struct.ptLib);
2762 msi_free(tl_struct.path);
2763 }
2764 else
2765 ERR("Failed to load type library %s\n",
2766 debugstr_w(tl_struct.source));
2767
2768 FreeLibrary(module);
2769 msi_free(tl_struct.source);
2770 }
2771 else
2772 ERR("Could not load file! %s\n", debugstr_w(file->TargetPath));
2773
2774 return ERROR_SUCCESS;
2775 }
2776
2777 static UINT ACTION_RegisterTypeLibraries(MSIPACKAGE *package)
2778 {
2779 /*
2780 * OK this is a bit confusing.. I am given a _Component key and I believe
2781 * that the file that is being registered as a type library is the "key file
2782 * of that component" which I interpret to mean "The file in the KeyPath of
2783 * that component".
2784 */
2785 UINT rc;
2786 MSIQUERY * view;
2787 static const WCHAR Query[] =
2788 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2789 '`','T','y','p','e','L','i','b','`',0};
2790
2791 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
2792 if (rc != ERROR_SUCCESS)
2793 return ERROR_SUCCESS;
2794
2795 rc = MSI_IterateRecords(view, NULL, ITERATE_RegisterTypeLibraries, package);
2796 msiobj_release(&view->hdr);
2797 return rc;
2798 }
2799
2800 static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
2801 {
2802 MSIPACKAGE *package = (MSIPACKAGE*)param;
2803 LPWSTR target_file, target_folder, filename;
2804 LPCWSTR buffer, extension;
2805 MSICOMPONENT *comp;
2806 static const WCHAR szlnk[]={'.','l','n','k',0};
2807 IShellLinkW *sl = NULL;
2808 IPersistFile *pf = NULL;
2809 HRESULT res;
2810
2811 buffer = MSI_RecordGetString(row,4);
2812 comp = get_loaded_component(package,buffer);
2813 if (!comp)
2814 return ERROR_SUCCESS;
2815
2816 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL ))
2817 {
2818 TRACE("Skipping shortcut creation due to disabled component\n");
2819
2820 comp->Action = comp->Installed;
2821
2822 return ERROR_SUCCESS;
2823 }
2824
2825 comp->Action = INSTALLSTATE_LOCAL;
2826
2827 ui_actiondata(package,szCreateShortcuts,row);
2828
2829 res = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
2830 &IID_IShellLinkW, (LPVOID *) &sl );
2831
2832 if (FAILED( res ))
2833 {
2834 ERR("CLSID_ShellLink not available\n");
2835 goto err;
2836 }
2837
2838 res = IShellLinkW_QueryInterface( sl, &IID_IPersistFile,(LPVOID*) &pf );
2839 if (FAILED( res ))
2840 {
2841 ERR("QueryInterface(IID_IPersistFile) failed\n");
2842 goto err;
2843 }
2844
2845 buffer = MSI_RecordGetString(row,2);
2846 target_folder = resolve_folder(package, buffer,FALSE,FALSE,NULL);
2847
2848 /* may be needed because of a bug somehwere else */
2849 create_full_pathW(target_folder);
2850
2851 filename = msi_dup_record_field( row, 3 );
2852 reduce_to_longfilename(filename);
2853
2854 extension = strchrW(filename,'.');
2855 if (!extension || strcmpiW(extension,szlnk))
2856 {
2857 int len = strlenW(filename);
2858 filename = msi_realloc(filename, len * sizeof(WCHAR) + sizeof(szlnk));
2859 memcpy(filename + len, szlnk, sizeof(szlnk));
2860 }
2861 target_file = build_directory_name(2, target_folder, filename);
2862 msi_free(target_folder);
2863 msi_free(filename);
2864
2865 buffer = MSI_RecordGetString(row,5);
2866 if (strchrW(buffer,'['))
2867 {
2868 LPWSTR deformated;
2869 deformat_string(package,buffer,&deformated);
2870 IShellLinkW_SetPath(sl,deformated);
2871 msi_free(deformated);
2872 }
2873 else
2874 {
2875 FIXME("poorly handled shortcut format, advertised shortcut\n");
2876 IShellLinkW_SetPath(sl,comp->FullKeypath);
2877 }
2878
2879 if (!MSI_RecordIsNull(row,6))
2880 {
2881 LPWSTR deformated;
2882 buffer = MSI_RecordGetString(row,6);
2883 deformat_string(package,buffer,&deformated);
2884 IShellLinkW_SetArguments(sl,deformated);
2885 msi_free(deformated);
2886 }
2887
2888 if (!MSI_RecordIsNull(row,7))
2889 {
2890 buffer = MSI_RecordGetString(row,7);
2891 IShellLinkW_SetDescription(sl,buffer);
2892 }
2893
2894 if (!MSI_RecordIsNull(row,8))
2895 IShellLinkW_SetHotkey(sl,MSI_RecordGetInteger(row,8));
2896
2897 if (!MSI_RecordIsNull(row,9))
2898 {
2899 LPWSTR Path;
2900 INT index;
2901
2902 buffer = MSI_RecordGetString(row,9);
2903
2904 Path = build_icon_path(package,buffer);
2905 index = MSI_RecordGetInteger(row,10);
2906
2907 IShellLinkW_SetIconLocation(sl,Path,index);
2908 msi_free(Path);
2909 }
2910
2911 if (!MSI_RecordIsNull(row,11))
2912 IShellLinkW_SetShowCmd(sl,MSI_RecordGetInteger(row,11));
2913
2914 if (!MSI_RecordIsNull(row,12))
2915 {
2916 LPWSTR Path;
2917 buffer = MSI_RecordGetString(row,12);
2918 Path = resolve_folder(package, buffer, FALSE, FALSE, NULL);
2919 IShellLinkW_SetWorkingDirectory(sl,Path);
2920 msi_free(Path);
2921 }
2922
2923 TRACE("Writing shortcut to %s\n",debugstr_w(target_file));
2924 IPersistFile_Save(pf,target_file,FALSE);
2925
2926 msi_free(target_file);
2927
2928 err:
2929 if (pf)
2930 IPersistFile_Release( pf );
2931 if (sl)
2932 IShellLinkW_Release( sl );
2933
2934 return ERROR_SUCCESS;
2935 }
2936
2937 static UINT ACTION_CreateShortcuts(MSIPACKAGE *package)
2938 {
2939 UINT rc;
2940 HRESULT res;
2941 MSIQUERY * view;
2942 static const WCHAR Query[] =
2943 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2944 '`','S','h','o','r','t','c','u','t','`',0};
2945
2946 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
2947 if (rc != ERROR_SUCCESS)
2948 return ERROR_SUCCESS;
2949
2950 res = CoInitialize( NULL );
2951 if (FAILED (res))
2952 {
2953 ERR("CoInitialize failed\n");
2954 return ERROR_FUNCTION_FAILED;
2955 }
2956
2957 rc = MSI_IterateRecords(view, NULL, ITERATE_CreateShortcuts, package);
2958 msiobj_release(&view->hdr);
2959
2960 CoUninitialize();
2961
2962 return rc;
2963 }
2964
2965 static UINT ITERATE_PublishProduct(MSIRECORD *row, LPVOID param)
2966 {
2967 MSIPACKAGE* package = (MSIPACKAGE*)param;
2968 HANDLE the_file;
2969 LPWSTR FilePath;
2970 LPCWSTR FileName;
2971 CHAR buffer[1024];
2972 DWORD sz;
2973 UINT rc;
2974 MSIRECORD *uirow;
2975
2976 FileName = MSI_RecordGetString(row,1);
2977 if (!FileName)
2978 {
2979 ERR("Unable to get FileName\n");
2980 return ERROR_SUCCESS;
2981 }
2982
2983 FilePath = build_icon_path(package,FileName);
2984
2985 TRACE("Creating icon file at %s\n",debugstr_w(FilePath));
2986
2987 the_file = CreateFileW(FilePath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
2988 FILE_ATTRIBUTE_NORMAL, NULL);
2989
2990 if (the_file == INVALID_HANDLE_VALUE)
2991 {
2992 ERR("Unable to create file %s\n",debugstr_w(FilePath));
2993 msi_free(FilePath);
2994 return ERROR_SUCCESS;
2995 }
2996
2997 do
2998 {
2999 DWORD write;
3000 sz = 1024;
3001 rc = MSI_RecordReadStream(row,2,buffer,&sz);
3002 if (rc != ERROR_SUCCESS)
3003 {
3004 ERR("Failed to get stream\n");
3005 CloseHandle(the_file);
3006 DeleteFileW(FilePath);
3007 break;
3008 }
3009 WriteFile(the_file,buffer,sz,&write,NULL);
3010 } while (sz == 1024);
3011
3012 msi_free(FilePath);
3013
3014 CloseHandle(the_file);
3015
3016 uirow = MSI_CreateRecord(1);
3017 MSI_RecordSetStringW(uirow,1,FileName);
3018 ui_actiondata(package,szPublishProduct,uirow);
3019 msiobj_release( &uirow->hdr );
3020
3021 return ERROR_SUCCESS;
3022 }
3023
3024 /*
3025 * 99% of the work done here is only done for
3026 * advertised installs. However this is where the
3027 * Icon table is processed and written out
3028 * so that is what I am going to do here.
3029 */
3030 static UINT ACTION_PublishProduct(MSIPACKAGE *package)
3031 {
3032 UINT rc;
3033 MSIQUERY * view;
3034 static const WCHAR Query[]=
3035 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3036 '`','I','c','o','n','`',0};
3037 /* for registry stuff */
3038 HKEY hkey=0;
3039 HKEY hukey=0;
3040 static const WCHAR szProductLanguage[] =
3041 {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
3042 static const WCHAR szARPProductIcon[] =
3043 {'A','R','P','P','R','O','D','U','C','T','I','C','O','N',0};
3044 static const WCHAR szProductVersion[] =
3045 {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
3046 DWORD langid;
3047 LPWSTR buffer;
3048 DWORD size;
3049 MSIHANDLE hDb, hSumInfo;
3050
3051 /* write out icon files */
3052
3053 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3054 if (rc == ERROR_SUCCESS)
3055 {
3056 MSI_IterateRecords(view, NULL, ITERATE_PublishProduct, package);
3057 msiobj_release(&view->hdr);
3058 }
3059
3060 /* ok there is a lot more done here but i need to figure out what */
3061
3062 rc = MSIREG_OpenProductsKey(package->ProductCode,&hkey,TRUE);
3063 if (rc != ERROR_SUCCESS)
3064 goto end;
3065
3066 rc = MSIREG_OpenUserProductsKey(package->ProductCode,&hukey,TRUE);
3067 if (rc != ERROR_SUCCESS)
3068 goto end;
3069
3070
3071 buffer = msi_dup_property( package, INSTALLPROPERTY_PRODUCTNAMEW );
3072 msi_reg_set_val_str( hukey, INSTALLPROPERTY_PRODUCTNAMEW, buffer );
3073 msi_free(buffer);
3074
3075 langid = msi_get_property_int( package, szProductLanguage, 0 );
3076 msi_reg_set_val_dword( hkey, INSTALLPROPERTY_LANGUAGEW, langid );
3077
3078 buffer = msi_dup_property( package, szARPProductIcon );
3079 if (buffer)
3080 {
3081 LPWSTR path = build_icon_path(package,buffer);
3082 msi_reg_set_val_str( hukey, INSTALLPROPERTY_PRODUCTICONW, path );
3083 msi_free( path );
3084 }
3085 msi_free(buffer);
3086
3087 buffer = msi_dup_property( package, szProductVersion );
3088 if (buffer)
3089 {
3090 DWORD verdword = build_version_dword(buffer);
3091 msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONW, verdword );
3092 }
3093 msi_free(buffer);
3094
3095 /* FIXME: Need to write more keys to the user registry */
3096
3097 hDb= alloc_msihandle( &package->db->hdr );
3098 rc = MsiGetSummaryInformationW(hDb, NULL, 0, &hSumInfo);
3099 MsiCloseHandle(hDb);
3100 if (rc == ERROR_SUCCESS)
3101 {
3102 WCHAR guidbuffer[0x200];
3103 size = 0x200;
3104 rc = MsiSummaryInfoGetPropertyW(hSumInfo, 9, NULL, NULL, NULL,
3105 guidbuffer, &size);
3106 if (rc == ERROR_SUCCESS)
3107 {
3108 WCHAR squashed[GUID_SIZE];
3109 /* for now we only care about the first guid */
3110 LPWSTR ptr = strchrW(guidbuffer,';');
3111 if (ptr) *ptr = 0;
3112 squash_guid(guidbuffer,squashed);
3113 msi_reg_set_val_str( hukey, INSTALLPROPERTY_PACKAGECODEW, squashed );
3114 }
3115 else
3116 {
3117 ERR("Unable to query Revision_Number...\n");
3118 rc = ERROR_SUCCESS;
3119 }
3120 MsiCloseHandle(hSumInfo);
3121 }
3122 else
3123 {
3124 ERR("Unable to open Summary Information\n");
3125 rc = ERROR_SUCCESS;
3126 }
3127
3128 end:
3129
3130 RegCloseKey(hkey);
3131 RegCloseKey(hukey);
3132
3133 return rc;
3134 }
3135
3136 static UINT ITERATE_WriteIniValues(MSIRECORD *row, LPVOID param)
3137 {
3138 MSIPACKAGE *package = (MSIPACKAGE*)param;
3139 LPCWSTR component,section,key,value,identifier,filename,dirproperty;
3140 LPWSTR deformated_section, deformated_key, deformated_value;
3141 LPWSTR folder, fullname = NULL;
3142 MSIRECORD * uirow;
3143 INT action;
3144 MSICOMPONENT *comp;
3145 static const WCHAR szWindowsFolder[] =
3146 {'W','i','n','d','o','w','s','F','o','l','d','e','r',0};
3147
3148 component = MSI_RecordGetString(row, 8);
3149 comp = get_loaded_component(package,component);
3150
3151 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
3152 {
3153 TRACE("Skipping ini file due to disabled component %s\n",
3154 debugstr_w(component));
3155
3156 comp->Action = comp->Installed;
3157
3158 return ERROR_SUCCESS;
3159 }
3160
3161 comp->Action = INSTALLSTATE_LOCAL;
3162
3163 identifier = MSI_RecordGetString(row,1);
3164 filename = MSI_RecordGetString(row,2);
3165 dirproperty = MSI_RecordGetString(row,3);
3166 section = MSI_RecordGetString(row,4);
3167 key = MSI_RecordGetString(row,5);
3168 value = MSI_RecordGetString(row,6);
3169 action = MSI_RecordGetInteger(row,7);
3170
3171 deformat_string(package,section,&deformated_section);
3172 deformat_string(package,key,&deformated_key);
3173 deformat_string(package,value,&deformated_value);
3174
3175 if (dirproperty)
3176 {
3177 folder = resolve_folder(package, dirproperty, FALSE, FALSE, NULL);
3178 if (!folder)
3179 folder = msi_dup_property( package, dirproperty );
3180 }
3181 else
3182 folder = msi_dup_property( package, szWindowsFolder );
3183
3184 if (!folder)
3185 {
3186 ERR("Unable to resolve folder! (%s)\n",debugstr_w(dirproperty));
3187 goto cleanup;
3188 }
3189
3190 fullname = build_directory_name(2, folder, filename);
3191
3192 if (action == 0)
3193 {
3194 TRACE("Adding value %s to section %s in %s\n",
3195 debugstr_w(deformated_key), debugstr_w(deformated_section),
3196 debugstr_w(fullname));
3197 WritePrivateProfileStringW(deformated_section, deformated_key,
3198 deformated_value, fullname);
3199 }
3200 else if (action == 1)
3201 {
3202 WCHAR returned[10];
3203 GetPrivateProfileStringW(deformated_section, deformated_key, NULL,
3204 returned, 10, fullname);
3205 if (returned[0] == 0)
3206 {
3207 TRACE("Adding value %s to section %s in %s\n",
3208 debugstr_w(deformated_key), debugstr_w(deformated_section),
3209 debugstr_w(fullname));
3210
3211 WritePrivateProfileStringW(deformated_section, deformated_key,
3212 deformated_value, fullname);
3213 }
3214 }
3215 else if (action == 3)
3216 FIXME("Append to existing section not yet implemented\n");
3217
3218 uirow = MSI_CreateRecord(4);
3219 MSI_RecordSetStringW(uirow,1,identifier);
3220 MSI_RecordSetStringW(uirow,2,deformated_section);
3221 MSI_RecordSetStringW(uirow,3,deformated_key);
3222 MSI_RecordSetStringW(uirow,4,deformated_value);
3223 ui_actiondata(package,szWriteIniValues,uirow);
3224 msiobj_release( &uirow->hdr );
3225 cleanup:
3226 msi_free(fullname);
3227 msi_free(folder);
3228 msi_free(deformated_key);
3229 msi_free(deformated_value);
3230 msi_free(deformated_section);
3231 return ERROR_SUCCESS;
3232 }
3233
3234 static UINT ACTION_WriteIniValues(MSIPACKAGE *package)
3235 {
3236 UINT rc;
3237 MSIQUERY * view;
3238 static const WCHAR ExecSeqQuery[] =
3239 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3240 '`','I','n','i','F','i','l','e','`',0};
3241
3242 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3243 if (rc != ERROR_SUCCESS)
3244 {
3245 TRACE("no IniFile table\n");
3246 return ERROR_SUCCESS;
3247 }
3248
3249 rc = MSI_IterateRecords(view, NULL, ITERATE_WriteIniValues, package);
3250 msiobj_release(&view->hdr);
3251 return rc;
3252 }
3253
3254 static UINT ITERATE_SelfRegModules(MSIRECORD *row, LPVOID param)
3255 {
3256 MSIPACKAGE *package = (MSIPACKAGE*)param;
3257 LPCWSTR filename;
3258 LPWSTR FullName;
3259 MSIFILE *file;
3260 DWORD len;
3261 static const WCHAR ExeStr[] =
3262 {'r','e','g','s','v','r','3','2','.','e','x','e',' ','\"',0};
3263 static const WCHAR close[] = {'\"',0};
3264 STARTUPINFOW si;
3265 PROCESS_INFORMATION info;
3266 BOOL brc;
3267 MSIRECORD *uirow;
3268 LPWSTR uipath, p;
3269
3270 memset(&si,0,sizeof(STARTUPINFOW));
3271
3272 filename = MSI_RecordGetString(row,1);
3273 file = get_loaded_file( package, filename );
3274
3275 if (!file)
3276 {
3277 ERR("Unable to find file id %s\n",debugstr_w(filename));
3278 return ERROR_SUCCESS;
3279 }
3280
3281 len = strlenW(ExeStr) + strlenW( file->TargetPath ) + 2;
3282
3283 FullName = msi_alloc(len*sizeof(WCHAR));
3284 strcpyW(FullName,ExeStr);
3285 strcatW( FullName, file->TargetPath );
3286 strcatW(FullName,close);
3287
3288 TRACE("Registering %s\n",debugstr_w(FullName));
3289 brc = CreateProcessW(NULL, FullName, NULL, NULL, FALSE, 0, NULL, c_colon,
3290 &si, &info);
3291
3292 if (brc)
3293 msi_dialog_check_messages(info.hProcess);
3294
3295 msi_free(FullName);
3296
3297 /* the UI chunk */
3298 uirow = MSI_CreateRecord( 2 );
3299 uipath = strdupW( file->TargetPath );
3300 p = strrchrW(uipath,'\\');
3301 if (p)
3302 p[1]=0;
3303 MSI_RecordSetStringW( uirow, 1, &p[2] );
3304 MSI_RecordSetStringW( uirow, 2, uipath);
3305 ui_actiondata( package, szSelfRegModules, uirow);
3306 msiobj_release( &uirow->hdr );
3307 msi_free( uipath );
3308 /* FIXME: call ui_progress? */
3309
3310 return ERROR_SUCCESS;
3311 }
3312
3313 static UINT ACTION_SelfRegModules(MSIPACKAGE *package)
3314 {
3315 UINT rc;
3316 MSIQUERY * view;
3317 static const WCHAR ExecSeqQuery[] =
3318 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3319 '`','S','e','l','f','R','e','g','`',0};
3320
3321 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3322 if (rc != ERROR_SUCCESS)
3323 {
3324 TRACE("no SelfReg table\n");
3325 return ERROR_SUCCESS;
3326 }
3327
3328 MSI_IterateRecords(view, NULL, ITERATE_SelfRegModules, package);
3329 msiobj_release(&view->hdr);
3330
3331 return ERROR_SUCCESS;
3332 }
3333
3334 static UINT ACTION_PublishFeatures(MSIPACKAGE *package)
3335 {
3336 MSIFEATURE *feature;
3337 UINT rc;
3338 HKEY hkey=0;
3339 HKEY hukey=0;
3340
3341 rc = MSIREG_OpenFeaturesKey(package->ProductCode,&hkey,TRUE);
3342 if (rc != ERROR_SUCCESS)
3343 goto end;
3344
3345 rc = MSIREG_OpenUserFeaturesKey(package->ProductCode,&hukey,TRUE);
3346 if (rc != ERROR_SUCCESS)
3347 goto end;
3348
3349 /* here the guids are base 85 encoded */
3350 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
3351 {
3352 ComponentList *cl;
3353 LPWSTR data = NULL;
3354 GUID clsid;
3355 INT size;
3356 BOOL absent = FALSE;
3357 MSIRECORD *uirow;
3358
3359 if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_LOCAL ) &&
3360 !ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_SOURCE ) &&
3361 !ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_ADVERTISED ))
3362 absent = TRUE;
3363
3364 size = 1;
3365 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3366 {
3367 size += 21;
3368 }
3369 if (feature->Feature_Parent)
3370 size += strlenW( feature->Feature_Parent )+2;
3371
3372 data = msi_alloc(size * sizeof(WCHAR));
3373
3374 data[0] = 0;
3375 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3376 {
3377 MSICOMPONENT* component = cl->component;
3378 WCHAR buf[21];
3379
3380 buf[0] = 0;
3381 if (component->ComponentId)
3382 {
3383 TRACE("From %s\n",debugstr_w(component->ComponentId));
3384 CLSIDFromString(component->ComponentId, &clsid);
3385 encode_base85_guid(&clsid,buf);
3386 TRACE("to %s\n",debugstr_w(buf));
3387 strcatW(data,buf);
3388 }
3389 }
3390 if (feature->Feature_Parent)
3391 {
3392 static const WCHAR sep[] = {'\2',0};
3393 strcatW(data,sep);
3394 strcatW(data,feature->Feature_Parent);
3395 }
3396
3397 msi_reg_set_val_str( hkey, feature->Feature, data );
3398 msi_free(data);
3399
3400 size = 0;
3401 if (feature->Feature_Parent)
3402 size = strlenW(feature->Feature_Parent)*sizeof(WCHAR);
3403 if (!absent)
3404 {
3405 RegSetValueExW(hukey,feature->Feature,0,REG_SZ,
3406 (LPBYTE)feature->Feature_Parent,size);
3407 }
3408 else
3409 {
3410 size += 2*sizeof(WCHAR);
3411 data = msi_alloc(size);
3412 data[0] = 0x6;
3413 data[1] = 0;
3414 if (feature->Feature_Parent)
3415 strcpyW( &data[1], feature->Feature_Parent );
3416 RegSetValueExW(hukey,feature->Feature,0,REG_SZ,
3417 (LPBYTE)data,size);
3418 msi_free(data);
3419 }
3420
3421 /* the UI chunk */
3422 uirow = MSI_CreateRecord( 1 );
3423 MSI_RecordSetStringW( uirow, 1, feature->Feature );
3424 ui_actiondata( package, szPublishFeatures, uirow);
3425 msiobj_release( &uirow->hdr );
3426 /* FIXME: call ui_progress? */
3427 }
3428
3429 end:
3430 RegCloseKey(hkey);
3431 RegCloseKey(hukey);
3432 return rc;
3433 }
3434
3435 static UINT msi_make_package_local( MSIPACKAGE *package, HKEY hkey )
3436 {
3437 static const WCHAR installerPathFmt[] = {
3438 '%','s','\\','I','n','s','t','a','l','l','e','r','\\',0};
3439 static const WCHAR fmt[] = {
3440 '%','s','\\',
3441 'I','n','s','t','a','l','l','e','r','\\',
3442 '%','x','.','m','s','i',0};
3443 static const WCHAR szOriginalDatabase[] =
3444 {'O','r','i','g','i','n','a','l','D','a','t','a','b','a','s','e',0};
3445 WCHAR windir[MAX_PATH], path[MAX_PATH], packagefile[MAX_PATH];
3446 INT num, start;
3447 LPWSTR msiFilePath;
3448 BOOL r;
3449
3450 /* copy the package locally */
3451 num = GetTickCount() & 0xffff;
3452 if (!num)
3453 num = 1;
3454 start = num;
3455 GetWindowsDirectoryW( windir, MAX_PATH );
3456 snprintfW( packagefile, MAX_PATH, fmt, windir, num );
3457 do
3458 {
3459 HANDLE handle = CreateFileW(packagefile,GENERIC_WRITE, 0, NULL,
3460 CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
3461 if (handle != INVALID_HANDLE_VALUE)
3462 {
3463 CloseHandle(handle);
3464 break;
3465 }
3466 if (GetLastError() != ERROR_FILE_EXISTS &&
3467 GetLastError() != ERROR_SHARING_VIOLATION)
3468 break;
3469 if (!(++num & 0xffff)) num = 1;
3470 sprintfW(packagefile,fmt,num);
3471 } while (num != start);
3472
3473 snprintfW( path, MAX_PATH, installerPathFmt, windir );
3474 create_full_pathW(path);
3475
3476 TRACE("Copying to local package %s\n",debugstr_w(packagefile));
3477
3478 msiFilePath = msi_dup_property( package, szOriginalDatabase );
3479 r = CopyFileW( msiFilePath, packagefile, FALSE);
3480 msi_free( msiFilePath );
3481
3482 if (!r)
3483 {
3484 ERR("Unable to copy package (%s -> %s) (error %ld)\n",
3485 debugstr_w(msiFilePath), debugstr_w(packagefile), GetLastError());
3486 return ERROR_FUNCTION_FAILED;
3487 }
3488
3489 /* FIXME: maybe set this key in ACTION_RegisterProduct instead */
3490 msi_reg_set_val_str( hkey, INSTALLPROPERTY_LOCALPACKAGEW, packagefile );
3491 return ERROR_SUCCESS;
3492 }
3493
3494 static UINT msi_write_uninstall_property_vals( MSIPACKAGE *package, HKEY hkey )
3495 {
3496 LPWSTR prop, val, key;
3497 static const LPCSTR propval[] = {
3498 "ARPAUTHORIZEDCDFPREFIX", "AuthorizedCDFPrefix",
3499 "ARPCONTACT", "Contact",
3500 "ARPCOMMENTS", "Comments",
3501 "ProductName", "DisplayName",
3502 "ProductVersion", "DisplayVersion",
3503 "ARPHELPLINK", "HelpLink",
3504 "ARPHELPTELEPHONE", "HelpTelephone",
3505 "ARPINSTALLLOCATION", "InstallLocation",
3506 "SourceDir", "InstallSource",
3507 "Manufacturer", "Publisher",
3508 "ARPREADME", "Readme",
3509 "ARPSIZE", "Size",
3510 "ARPURLINFOABOUT", "URLInfoAbout",
3511 "ARPURLUPDATEINFO", "URLUpdateInfo",
3512 NULL,
3513 };
3514 const LPCSTR *p = propval;
3515
3516 while( *p )
3517 {
3518 prop = strdupAtoW( *p++ );
3519 key = strdupAtoW( *p++ );
3520 val = msi_dup_property( package, prop );
3521 msi_reg_set_val_str( hkey, key, val );
3522 msi_free(val);
3523 msi_free(key);
3524 msi_free(prop);
3525 }
3526 return ERROR_SUCCESS;
3527 }
3528
3529 static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
3530 {
3531 HKEY hkey=0;
3532 LPWSTR buffer = NULL;
3533 UINT rc;
3534 DWORD size, langid;
3535 static const WCHAR szWindowsInstaller[] =
3536 {'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
3537 static const WCHAR szUpgradeCode[] =
3538 {'U','p','g','r','a','d','e','C','o','d','e',0};
3539 static const WCHAR modpath_fmt[] =
3540 {'M','s','i','E','x','e','c','.','e','x','e',' ',
3541 '/','I','[','P','r','o','d','u','c','t','C','o','d','e',']',0};
3542 static const WCHAR szModifyPath[] =
3543 {'M','o','d','i','f','y','P','a','t','h',0};
3544 static const WCHAR szUninstallString[] =
3545 {'U','n','i','n','s','t','a','l','l','S','t','r','i','n','g',0};
3546 static const WCHAR szEstimatedSize[] =
3547 {'E','s','t','i','m','a','t','e','d','S','i','z','e',0};
3548 static const WCHAR szProductLanguage[] =
3549 {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
3550 static const WCHAR szProductVersion[] =
3551 {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
3552
3553 SYSTEMTIME systime;
3554 static const WCHAR date_fmt[] = {'%','i','%','i','%','i',0};
3555 LPWSTR upgrade_code;
3556 WCHAR szDate[9];
3557
3558 rc = MSIREG_OpenUninstallKey(package->ProductCode,&hkey,TRUE);
3559 if (rc != ERROR_SUCCESS)
3560 return rc;
3561
3562 /* dump all the info i can grab */
3563 /* FIXME: Flesh out more information */
3564
3565 msi_write_uninstall_property_vals( package, hkey );
3566
3567 msi_reg_set_val_dword( hkey, szWindowsInstaller, 1 );
3568
3569 msi_make_package_local( package, hkey );
3570
3571 /* do ModifyPath and UninstallString */
3572 size = deformat_string(package,modpath_fmt,&buffer);
3573 RegSetValueExW(hkey,szModifyPath,0,REG_EXPAND_SZ,(LPBYTE)buffer,size);
3574 RegSetValueExW(hkey,szUninstallString,0,REG_EXPAND_SZ,(LPBYTE)buffer,size);
3575 msi_free(buffer);
3576
3577 /* FIXME: Write real Estimated Size when we have it */
3578 msi_reg_set_val_dword( hkey, szEstimatedSize, 0 );
3579
3580 GetLocalTime(&systime);
3581 sprintfW(szDate,date_fmt,systime.wYear,systime.wMonth,systime.wDay);
3582 msi_reg_set_val_str( hkey, INSTALLPROPERTY_INSTALLDATEW, szDate );
3583
3584 langid = msi_get_property_int( package, szProductLanguage, 0 );
3585 msi_reg_set_val_dword( hkey, INSTALLPROPERTY_LANGUAGEW, langid );
3586
3587 buffer = msi_dup_property( package, szProductVersion );
3588 if (buffer)
3589 {
3590 DWORD verdword = build_version_dword(buffer);
3591
3592 msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONW, verdword );
3593 msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONMAJORW, verdword>>24 );
3594 msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONMINORW, (verdword>>16)&0x00FF );
3595 }
3596 msi_free(buffer);
3597
3598 /* Handle Upgrade Codes */
3599 upgrade_code = msi_dup_property( package, szUpgradeCode );
3600 if (upgrade_code)
3601 {
3602 HKEY hkey2;
3603 WCHAR squashed[33];
3604 MSIREG_OpenUpgradeCodesKey(upgrade_code, &hkey2, TRUE);
3605 squash_guid(package->ProductCode,squashed);
3606 msi_reg_set_val_str( hkey2, squashed, NULL );
3607 RegCloseKey(hkey2);
3608 MSIREG_OpenUserUpgradeCodesKey(upgrade_code, &hkey2, TRUE);
3609 squash_guid(package->ProductCode,squashed);
3610 msi_reg_set_val_str( hkey2, squashed, NULL );
3611 RegCloseKey(hkey2);
3612
3613 msi_free(upgrade_code);
3614 }
3615
3616 RegCloseKey(hkey);
3617
3618 /* FIXME: call ui_actiondata */
3619
3620 return ERROR_SUCCESS;
3621 }
3622
3623 static UINT ACTION_InstallExecute(MSIPACKAGE *package)
3624 {
3625 return execute_script(package,INSTALL_SCRIPT);
3626 }
3627
3628 static UINT ACTION_InstallFinalize(MSIPACKAGE *package)
3629 {
3630 UINT rc;
3631
3632 /* turn off scheduleing */
3633 package->script->CurrentlyScripting= FALSE;
3634
3635 /* first do the same as an InstallExecute */
3636 rc = ACTION_InstallExecute(package);
3637 if (rc != ERROR_SUCCESS)
3638 return rc;
3639
3640 /* then handle Commit Actions */
3641 rc = execute_script(package,COMMIT_SCRIPT);
3642
3643 return rc;
3644 }
3645
3646 static UINT ACTION_ForceReboot(MSIPACKAGE *package)
3647 {
3648 static const WCHAR RunOnce[] = {
3649 'S','o','f','t','w','a','r','e','\\',
3650 'M','i','c','r','o','s','o','f','t','\\',
3651 'W','i','n','d','o','w','s','\\',
3652 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3653 'R','u','n','O','n','c','e',0};
3654 static const WCHAR InstallRunOnce[] = {
3655 'S','o','f','t','w','a','r','e','\\',
3656 'M','i','c','r','o','s','o','f','t','\\',
3657 'W','i','n','d','o','w','s','\\',
3658 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3659 'I','n','s','t','a','l','l','e','r','\\',
3660 'R','u','n','O','n','c','e','E','n','t','r','i','e','s',0};
3661
3662 static const WCHAR msiexec_fmt[] = {
3663 '%','s',
3664 '\\','M','s','i','E','x','e','c','.','e','x','e',' ','/','@',' ',
3665 '\"','%','s','\"',0};
3666 static const WCHAR install_fmt[] = {
3667 '/','I',' ','\"','%','s','\"',' ',
3668 'A','F','T','E','R','R','E','B','O','O','T','=','1',' ',
3669 'R','U','N','O','N','C','E','E','N','T','R','Y','=','\"','%','s','\"',0};
3670 WCHAR buffer[256], sysdir[MAX_PATH];
3671 HKEY hkey;
3672 WCHAR squished_pc[100];
3673
3674 squash_guid(package->ProductCode,squished_pc);
3675
3676 GetSystemDirectoryW(sysdir, sizeof(sysdir)/sizeof(sysdir[0]));
3677 RegCreateKeyW(HKEY_LOCAL_MACHINE,RunOnce,&hkey);
3678 snprintfW(buffer,sizeof(buffer)/sizeof(buffer[0]),msiexec_fmt,sysdir,
3679 squished_pc);
3680
3681 msi_reg_set_val_str( hkey, squished_pc, buffer );
3682 RegCloseKey(hkey);
3683
3684 TRACE("Reboot command %s\n",debugstr_w(buffer));
3685
3686 RegCreateKeyW(HKEY_LOCAL_MACHINE,InstallRunOnce,&hkey);
3687 sprintfW(buffer,install_fmt,package->ProductCode,squished_pc);
3688
3689 msi_reg_set_val_str( hkey, squished_pc, buffer );
3690 RegCloseKey(hkey);
3691
3692 return ERROR_INSTALL_SUSPEND;
3693 }
3694
3695 UINT ACTION_ResolveSource(MSIPACKAGE* package)
3696 {
3697 DWORD attrib;
3698 UINT rc;
3699 /*
3700 * we are currently doing what should be done here in the top level Install
3701 * however for Adminastrative and uninstalls this step will be needed
3702 */
3703 if (!package->PackagePath)
3704 return ERROR_SUCCESS;
3705
3706 attrib = GetFileAttributesW(package->PackagePath);
3707 if (attrib == INVALID_FILE_ATTRIBUTES)
3708 {
3709 LPWSTR prompt;
3710 LPWSTR msg;
3711 DWORD size = 0;
3712
3713 rc = MsiSourceListGetInfoW(package->ProductCode, NULL,
3714 MSIINSTALLCONTEXT_USERMANAGED, MSICODE_PRODUCT,
3715 INSTALLPROPERTY_DISKPROMPTW,NULL,&size);
3716 if (rc == ERROR_MORE_DATA)
3717 {
3718 prompt = msi_alloc(size * sizeof(WCHAR));
3719 MsiSourceListGetInfoW(package->ProductCode, NULL,
3720 MSIINSTALLCONTEXT_USERMANAGED, MSICODE_PRODUCT,
3721 INSTALLPROPERTY_DISKPROMPTW,prompt,&size);
3722 }
3723 else
3724 prompt = strdupW(package->PackagePath);
3725
3726 msg = generate_error_string(package,1302,1,prompt);
3727 while(attrib == INVALID_FILE_ATTRIBUTES)
3728 {
3729 rc = MessageBoxW(NULL,msg,NULL,MB_OKCANCEL);
3730 if (rc == IDCANCEL)
3731 {
3732 rc = ERROR_INSTALL_USEREXIT;
3733 break;
3734 }
3735 attrib = GetFileAttributesW(package->PackagePath);
3736 }
3737 msi_free(prompt);
3738 rc = ERROR_SUCCESS;
3739 }
3740 else
3741 return ERROR_SUCCESS;
3742
3743 return rc;
3744 }
3745
3746 static UINT ACTION_RegisterUser(MSIPACKAGE *package)
3747 {
3748 HKEY hkey=0;
3749 LPWSTR buffer;
3750 LPWSTR productid;
3751 UINT rc,i;
3752
3753 static const WCHAR szPropKeys[][80] =
3754 {
3755 {'P','r','o','d','u','c','t','I','D',0},
3756 {'U','S','E','R','N','A','M','E',0},
3757 {'C','O','M','P','A','N','Y','N','A','M','E',0},
3758 {0},
3759 };
3760
3761 static const WCHAR szRegKeys[][80] =
3762 {
3763 {'P','r','o','d','u','c','t','I','D',0},
3764 {'R','e','g','O','w','n','e','r',0},
3765 {'R','e','g','C','o','m','p','a','n','y',0},
3766 {0},
3767 };
3768
3769 productid = msi_dup_property( package, INSTALLPROPERTY_PRODUCTIDW );
3770 if (!productid)
3771 return ERROR_SUCCESS;
3772
3773 rc = MSIREG_OpenUninstallKey(package->ProductCode,&hkey,TRUE);
3774 if (rc != ERROR_SUCCESS)
3775 goto end;
3776
3777 for( i = 0; szPropKeys[i][0]; i++ )
3778 {
3779 buffer = msi_dup_property( package, szPropKeys[i] );
3780 msi_reg_set_val_str( hkey, szRegKeys[i], buffer );
3781 msi_free( buffer );
3782 }
3783
3784 end:
3785 msi_free(productid);
3786 RegCloseKey(hkey);
3787
3788 /* FIXME: call ui_actiondata */
3789
3790 return ERROR_SUCCESS;
3791 }
3792
3793
3794 static UINT ACTION_ExecuteAction(MSIPACKAGE *package)
3795 {
3796 UINT rc;
3797
3798 package->script->InWhatSequence |= SEQUENCE_EXEC;
3799 rc = ACTION_ProcessExecSequence(package,FALSE);
3800 return rc;
3801 }
3802
3803
3804 /*
3805 * Code based off of code located here
3806 * http://www.codeproject.com/gdi/fontnamefromfile.asp
3807 *
3808 * Using string index 4 (full font name) instead of 1 (family name)
3809 */
3810 static LPWSTR load_ttfname_from(LPCWSTR filename)
3811 {
3812 HANDLE handle;
3813 LPWSTR ret = NULL;
3814 int i;
3815
3816 typedef struct _tagTT_OFFSET_TABLE{
3817 USHORT uMajorVersion;
3818 USHORT uMinorVersion;
3819 USHORT uNumOfTables;
3820 USHORT uSearchRange;
3821 USHORT uEntrySelector;
3822 USHORT uRangeShift;
3823 }TT_OFFSET_TABLE;
3824
3825 typedef struct _tagTT_TABLE_DIRECTORY{
3826 char szTag[4]; /* table name */
3827 ULONG uCheckSum; /* Check sum */
3828 ULONG uOffset; /* Offset from beginning of file */
3829 ULONG uLength; /* length of the table in bytes */
3830 }TT_TABLE_DIRECTORY;
3831
3832 typedef struct _tagTT_NAME_TABLE_HEADER{
3833 USHORT uFSelector; /* format selector. Always 0 */
3834 USHORT uNRCount; /* Name Records count */
3835 USHORT uStorageOffset; /* Offset for strings storage,
3836 * from start of the table */
3837 }TT_NAME_TABLE_HEADER;
3838
3839 typedef struct _tagTT_NAME_RECORD{
3840 USHORT uPlatformID;
3841 USHORT uEncodingID;
3842 USHORT uLanguageID;
3843 USHORT uNameID;
3844 USHORT uStringLength;
3845 USHORT uStringOffset; /* from start of storage area */
3846 }TT_NAME_RECORD;
3847
3848 #define SWAPWORD(x) MAKEWORD(HIBYTE(x), LOBYTE(x))
3849 #define SWAPLONG(x) MAKELONG(SWAPWORD(HIWORD(x)), SWAPWORD(LOWORD(x)))
3850
3851 handle = CreateFileW(filename ,GENERIC_READ, 0, NULL, OPEN_EXISTING,
3852 FILE_ATTRIBUTE_NORMAL, 0 );
3853 if (handle != INVALID_HANDLE_VALUE)
3854 {
3855 TT_TABLE_DIRECTORY tblDir;
3856 BOOL bFound = FALSE;
3857 TT_OFFSET_TABLE ttOffsetTable;
3858 DWORD dwRead;
3859
3860 ReadFile(handle,&ttOffsetTable, sizeof(TT_OFFSET_TABLE),&dwRead,NULL);
3861 ttOffsetTable.uNumOfTables = SWAPWORD(ttOffsetTable.uNumOfTables);
3862 ttOffsetTable.uMajorVersion = SWAPWORD(ttOffsetTable.uMajorVersion);
3863 ttOffsetTable.uMinorVersion = SWAPWORD(ttOffsetTable.uMinorVersion);
3864
3865 if (ttOffsetTable.uMajorVersion != 1 ||
3866 ttOffsetTable.uMinorVersion != 0)
3867 return NULL;
3868
3869 for (i=0; i< ttOffsetTable.uNumOfTables; i++)
3870 {
3871 ReadFile(handle,&tblDir, sizeof(TT_TABLE_DIRECTORY),&dwRead,NULL);
3872 if (strncmp(tblDir.szTag,"name",4)==0)
3873 {
3874 bFound = TRUE;
3875 tblDir.uLength = SWAPLONG(tblDir.uLength);
3876 tblDir.uOffset = SWAPLONG(tblDir.uOffset);
3877 break;
3878 }
3879 }
3880
3881 if (bFound)
3882 {
3883 TT_NAME_TABLE_HEADER ttNTHeader;
3884 TT_NAME_RECORD ttRecord;
3885
3886 SetFilePointer(handle, tblDir.uOffset, NULL, FILE_BEGIN);
3887 ReadFile(handle,&ttNTHeader, sizeof(TT_NAME_TABLE_HEADER),
3888 &dwRead,NULL);
3889
3890 ttNTHeader.uNRCount = SWAPWORD(ttNTHeader.uNRCount);
3891 ttNTHeader.uStorageOffset = SWAPWORD(ttNTHeader.uStorageOffset);
3892 bFound = FALSE;
3893 for(i=0; i<ttNTHeader.uNRCount; i++)
3894 {
3895 ReadFile(handle,&ttRecord, sizeof(TT_NAME_RECORD),&dwRead,NULL);
3896 ttRecord.uNameID = SWAPWORD(ttRecord.uNameID);
3897 /* 4 is the Full Font Name */
3898 if(ttRecord.uNameID == 4)
3899 {
3900 int nPos;
3901 LPSTR buf;
3902 static LPCSTR tt = " (TrueType)";
3903
3904 ttRecord.uStringLength = SWAPWORD(ttRecord.uStringLength);
3905 ttRecord.uStringOffset = SWAPWORD(ttRecord.uStringOffset);
3906 nPos = SetFilePointer(handle, 0, NULL, FILE_CURRENT);
3907 SetFilePointer(handle, tblDir.uOffset +
3908 ttRecord.uStringOffset +
3909 ttNTHeader.uStorageOffset,
3910 NULL, FILE_BEGIN);
3911 buf = msi_alloc_zero( ttRecord.uStringLength + 1 + strlen(tt) );
3912 ReadFile(handle, buf, ttRecord.uStringLength, &dwRead, NULL);
3913 if (strlen(buf) > 0)
3914 {
3915 strcat(buf,tt);
3916 ret = strdupAtoW(buf);
3917 msi_free(buf);
3918 break;
3919 }
3920
3921 msi_free(buf);
3922 SetFilePointer(handle,nPos, NULL, FILE_BEGIN);
3923 }
3924 }
3925 }
3926 CloseHandle(handle);
3927 }
3928 else
3929 ERR("Unable to open font file %s\n", debugstr_w(filename));
3930
3931 TRACE("Returning fontname %s\n",debugstr_w(ret));
3932 return ret;
3933 }
3934
3935 static UINT ITERATE_RegisterFonts(MSIRECORD *row, LPVOID param)
3936 {
3937 MSIPACKAGE *package = (MSIPACKAGE*)param;
3938 LPWSTR name;
3939 LPCWSTR filename;
3940 MSIFILE *file;
3941 static const WCHAR regfont1[] =
3942 {'S','o','f','t','w','a','r','e','\\',
3943 'M','i','c','r','o','s','o','f','t','\\',
3944 'W','i','n','d','o','w','s',' ','N','T','\\',
3945 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3946 'F','o','n','t','s',0};
3947 static const WCHAR regfont2[] =
3948 {'S','o','f','t','w','a','r','e','\\',
3949 'M','i','c','r','o','s','o','f','t','\\',
3950 'W','i','n','d','o','w','s','\\',
3951 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3952 'F','o','n','t','s',0};
3953 HKEY hkey1;
3954 HKEY hkey2;
3955 MSIRECORD *uirow;
3956 LPWSTR uipath, p;
3957
3958 filename = MSI_RecordGetString( row, 1 );
3959 file = get_loaded_file( package, filename );
3960 if (!file)
3961 {
3962 ERR("Unable to load file\n");
3963 return ERROR_SUCCESS;
3964 }
3965
3966 /* check to make sure that component is installed */
3967 if (!ACTION_VerifyComponentForAction( file->Component, INSTALLSTATE_LOCAL))
3968 {
3969 TRACE("Skipping: Component not scheduled for install\n");
3970 return ERROR_SUCCESS;
3971 }
3972
3973 RegCreateKeyW(HKEY_LOCAL_MACHINE,regfont1,&hkey1);
3974 RegCreateKeyW(HKEY_LOCAL_MACHINE,regfont2,&hkey2);
3975
3976 if (MSI_RecordIsNull(row,2))
3977 name = load_ttfname_from( file->TargetPath );
3978 else
3979 name = msi_dup_record_field(row,2);
3980
3981 if (name)
3982 {
3983 msi_reg_set_val_str( hkey1, name, file->FileName );
3984 msi_reg_set_val_str( hkey2, name, file->FileName );
3985 }
3986
3987 msi_free(name);
3988 RegCloseKey(hkey1);
3989 RegCloseKey(hkey2);
3990
3991 /* the UI chunk */
3992 uirow = MSI_CreateRecord( 1 );
3993 uipath = strdupW( file->TargetPath );
3994 p = strrchrW(uipath,'\\');
3995 if (p) p++;
3996 else p = uipath;
3997 MSI_RecordSetStringW( uirow, 1, p );
3998 ui_actiondata( package, szRegisterFonts, uirow);
3999 msiobj_release( &uirow->hdr );
4000 msi_free( uipath );
4001 /* FIXME: call ui_progress? */
4002
4003 return ERROR_SUCCESS;
4004 }
4005
4006 static UINT ACTION_RegisterFonts(MSIPACKAGE *package)
4007 {
4008 UINT rc;
4009 MSIQUERY * view;
4010 static const WCHAR ExecSeqQuery[] =
4011 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4012 '`','F','o','n','t','`',0};
4013
4014 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4015 if (rc != ERROR_SUCCESS)
4016 {
4017 TRACE("MSI_DatabaseOpenViewW failed: %d\n", rc);
4018 return ERROR_SUCCESS;
4019 }
4020
4021 MSI_IterateRecords(view, NULL, ITERATE_RegisterFonts, package);
4022 msiobj_release(&view->hdr);
4023
4024 return ERROR_SUCCESS;
4025 }
4026
4027 static UINT ITERATE_PublishComponent(MSIRECORD *rec, LPVOID param)
4028 {
4029 MSIPACKAGE *package = (MSIPACKAGE*)param;
4030 LPCWSTR compgroupid=NULL;
4031 LPCWSTR feature=NULL;
4032 LPCWSTR text = NULL;
4033 LPCWSTR qualifier = NULL;
4034 LPCWSTR component = NULL;
4035 LPWSTR advertise = NULL;
4036 LPWSTR output = NULL;
4037 HKEY hkey;
4038 UINT rc = ERROR_SUCCESS;
4039 MSICOMPONENT *comp;
4040 DWORD sz = 0;
4041 MSIRECORD *uirow;
4042
4043 component = MSI_RecordGetString(rec,3);
4044 comp = get_loaded_component(package,component);
4045
4046 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL ) &&
4047 !ACTION_VerifyComponentForAction( comp, INSTALLSTATE_SOURCE ) &&
4048 !ACTION_VerifyComponentForAction( comp, INSTALLSTATE_ADVERTISED ))
4049 {
4050 TRACE("Skipping: Component %s not scheduled for install\n",
4051 debugstr_w(component));
4052
4053 return ERROR_SUCCESS;
4054 }
4055
4056 compgroupid = MSI_RecordGetString(rec,1);
4057 qualifier = MSI_RecordGetString(rec,2);
4058
4059 rc = MSIREG_OpenUserComponentsKey(compgroupid, &hkey, TRUE);
4060 if (rc != ERROR_SUCCESS)
4061 goto end;
4062
4063 text = MSI_RecordGetString(rec,4);
4064 feature = MSI_RecordGetString(rec,5);
4065
4066 advertise = create_component_advertise_string(package, comp, feature);
4067
4068 sz = strlenW(advertise);
4069
4070 if (text)
4071 sz += lstrlenW(text);
4072
4073 sz+=3;
4074 sz *= sizeof(WCHAR);
4075
4076 output = msi_alloc_zero(sz);
4077 strcpyW(output,advertise);
4078 msi_free(advertise);
4079
4080 if (text)
4081 strcatW(output,text);
4082
4083 msi_reg_set_val_multi_str( hkey, qualifier, output );
4084
4085 end:
4086 RegCloseKey(hkey);
4087 msi_free(output);
4088
4089 /* the UI chunk */
4090 uirow = MSI_CreateRecord( 2 );
4091 MSI_RecordSetStringW( uirow, 1, compgroupid );
4092 MSI_RecordSetStringW( uirow, 2, qualifier);
4093 ui_actiondata( package, szPublishComponents, uirow);
4094 msiobj_release( &uirow->hdr );
4095 /* FIXME: call ui_progress? */
4096
4097 return rc;
4098 }
4099
4100 /*
4101 * At present I am ignorning the advertised components part of this and only
4102 * focusing on the qualified component sets
4103 */
4104 static UINT ACTION_PublishComponents(MSIPACKAGE *package)
4105 {
4106 UINT rc;
4107 MSIQUERY * view;
4108 static const WCHAR ExecSeqQuery[] =
4109 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4110 '`','P','u','b','l','i','s','h',
4111 'C','o','m','p','o','n','e','n','t','`',0};
4112
4113 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4114 if (rc != ERROR_SUCCESS)
4115 return ERROR_SUCCESS;
4116
4117 rc = MSI_IterateRecords(view, NULL, ITERATE_PublishComponent, package);
4118 msiobj_release(&view->hdr);
4119
4120 return rc;
4121 }
4122
4123 static UINT msi_unimplemented_action_stub( MSIPACKAGE *package,
4124 LPCSTR action, LPCWSTR table )
4125 {
4126 static const WCHAR query[] = {
4127 'S','E','L','E','C','T',' ','*',' ',
4128 'F','R','O','M',' ','`','%','s','`',0 };
4129 MSIQUERY *view = NULL;
4130 DWORD count = 0;
4131 UINT r;
4132
4133 r = MSI_OpenQuery( package->db, &view, query, table );
4134 if (r == ERROR_SUCCESS)
4135 {
4136 r = MSI_IterateRecords(view, &count, NULL, package);
4137 msiobj_release(&view->hdr);
4138 }
4139
4140 if (count)
4141 FIXME("%s -> %lu ignored %s table values\n",
4142 action, count, debugstr_w(table));
4143
4144 return ERROR_SUCCESS;
4145 }
4146
4147 static UINT ACTION_AllocateRegistrySpace( MSIPACKAGE *package )
4148 {
4149 TRACE("%p\n", package);
4150 return ERROR_SUCCESS;
4151 }
4152
4153 static UINT ACTION_RemoveIniValues( MSIPACKAGE *package )
4154 {
4155 static const WCHAR table[] =
4156 {'R','e','m','o','v','e','I','n','i','F','i','l','e',0 };
4157 return msi_unimplemented_action_stub( package, "RemoveIniValues", table );
4158 }
4159
4160 static UINT ACTION_MoveFiles( MSIPACKAGE *package )
4161 {
4162 static const WCHAR table[] = { 'M','o','v','e','F','i','l','e',0 };
4163 return msi_unimplemented_action_stub( package, "MoveFiles", table );
4164 }
4165
4166 static UINT ACTION_PatchFiles( MSIPACKAGE *package )
4167 {
4168 static const WCHAR table[] = { 'P','a','t','c','h',0 };
4169 return msi_unimplemented_action_stub( package, "PatchFiles", table );
4170 }
4171
4172 static UINT ACTION_BindImage( MSIPACKAGE *package )
4173 {
4174 static const WCHAR table[] = { 'B','i','n','d','I','m','a','g','e',0 };
4175 return msi_unimplemented_action_stub( package, "BindImage", table );
4176 }
4177
4178 static UINT ACTION_IsolateComponents( MSIPACKAGE *package )
4179 {
4180 static const WCHAR table[] = {
4181 'I','s','o','l','a','t','e','C','o','m','p','o','n','e','n','t',0 };
4182 return msi_unimplemented_action_stub( package, "IsolateComponents", table );
4183 }
4184
4185 static UINT ACTION_MigrateFeatureStates( MSIPACKAGE *package )
4186 {
4187 static const WCHAR table[] = { 'U','p','g','r','a','d','e',0 };
4188 return msi_unimplemented_action_stub( package, "MigrateFeatureStates", table );
4189 }
4190
4191 static UINT ACTION_SelfUnregModules( MSIPACKAGE *package )
4192 {
4193 static const WCHAR table[] = { 'S','e','l','f','R','e','g',0 };
4194 return msi_unimplemented_action_stub( package, "SelfUnregModules", table );
4195 }
4196
4197 static UINT ACTION_InstallServices( MSIPACKAGE *package )
4198 {
4199 static const WCHAR table[] = {
4200 'S','e','r','v','i','c','e','I','n','s','t','a','l','l',0 };
4201 return msi_unimplemented_action_stub( package, "InstallServices", table );
4202 }
4203
4204 static UINT ACTION_StartServices( MSIPACKAGE *package )
4205 {
4206 static const WCHAR table[] = {
4207 'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
4208 return msi_unimplemented_action_stub( package, "StartServices", table );
4209 }
4210
4211 static UINT ACTION_StopServices( MSIPACKAGE *package )
4212 {
4213 static const WCHAR table[] = {
4214 'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
4215 return msi_unimplemented_action_stub( package, "StopServices", table );
4216 }
4217
4218 static UINT ACTION_DeleteServices( MSIPACKAGE *package )
4219 {
4220 static const WCHAR table[] = {
4221 'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
4222 return msi_unimplemented_action_stub( package, "DeleteServices", table );
4223 }
4224
4225 static UINT ACTION_WriteEnvironmentStrings( MSIPACKAGE *package )
4226 {
4227 static const WCHAR table[] = {
4228 'E','n','v','i','r','o','n','m','e','n','t',0 };
4229 return msi_unimplemented_action_stub( package, "WriteEnvironmentStrings", table );
4230 }
4231
4232 static UINT ACTION_RemoveEnvironmentStrings( MSIPACKAGE *package )
4233 {
4234 static const WCHAR table[] = {
4235 'E','n','v','i','r','o','n','m','e','n','t',0 };
4236 return msi_unimplemented_action_stub( package, "RemoveEnvironmentStrings", table );
4237 }
4238
4239 static UINT ACTION_MsiPublishAssemblies( MSIPACKAGE *package )
4240 {
4241 static const WCHAR table[] = {
4242 'M','s','i','A','s','s','e','m','b','l','y',0 };
4243 return msi_unimplemented_action_stub( package, "MsiPublishAssemblies", table );
4244 }
4245
4246 static UINT ACTION_MsiUnpublishAssemblies( MSIPACKAGE *package )
4247 {
4248 static const WCHAR table[] = {
4249 'M','s','i','A','s','s','e','m','b','l','y',0 };
4250 return msi_unimplemented_action_stub( package, "MsiUnpublishAssemblies", table );
4251 }
4252
4253 static UINT ACTION_UnregisterFonts( MSIPACKAGE *package )
4254 {
4255 static const WCHAR table[] = { 'F','o','n','t',0 };
4256 return msi_unimplemented_action_stub( package, "UnregisterFonts", table );
4257 }
4258
4259 static UINT ACTION_CCPSearch( MSIPACKAGE *package )
4260 {
4261 static const WCHAR table[] = { 'C','C','P','S','e','a','r','c','h',0 };
4262 return msi_unimplemented_action_stub( package, "CCPSearch", table );
4263 }
4264
4265 static UINT ACTION_RMCCPSearch( MSIPACKAGE *package )
4266 {
4267 static const WCHAR table[] = { 'C','C','P','S','e','a','r','c','h',0 };
4268 return msi_unimplemented_action_stub( package, "RMCCPSearch", table );
4269 }
4270
4271 static UINT ACTION_RegisterComPlus( MSIPACKAGE *package )
4272 {
4273 static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
4274 return msi_unimplemented_action_stub( package, "RegisterComPlus", table );
4275 }
4276
4277 static UINT ACTION_UnregisterComPlus( MSIPACKAGE *package )
4278 {
4279 static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
4280 return msi_unimplemented_action_stub( package, "UnregisterComPlus", table );
4281 }
4282
4283 static struct _actions StandardActions[] = {
4284 { szAllocateRegistrySpace, ACTION_AllocateRegistrySpace },
4285 { szAppSearch, ACTION_AppSearch },
4286 { szBindImage, ACTION_BindImage },
4287 { szCCPSearch, ACTION_CCPSearch},
4288 { szCostFinalize, ACTION_CostFinalize },
4289 { szCostInitialize, ACTION_CostInitialize },
4290 { szCreateFolders, ACTION_CreateFolders },
4291 { szCreateShortcuts, ACTION_CreateShortcuts },
4292 { szDeleteServices, ACTION_DeleteServices },
4293 { szDisableRollback, NULL},
4294 { szDuplicateFiles, ACTION_DuplicateFiles },
4295 { szExecuteAction, ACTION_ExecuteAction },
4296 { szFileCost, ACTION_FileCost },
4297 { szFindRelatedProducts, ACTION_FindRelatedProducts },
4298 { szForceReboot, ACTION_ForceReboot },
4299 { szInstallAdminPackage, NULL},
4300 { szInstallExecute, ACTION_InstallExecute },
4301 { szInstallExecuteAgain, ACTION_InstallExecute },
4302 { szInstallFiles, ACTION_InstallFiles},
4303 { szInstallFinalize, ACTION_InstallFinalize },
4304 { szInstallInitialize, ACTION_InstallInitialize },
4305 { szInstallSFPCatalogFile, NULL},
4306 { szInstallValidate, ACTION_InstallValidate },
4307 { szIsolateComponents, ACTION_IsolateComponents },
4308 { szLaunchConditions, ACTION_LaunchConditions },
4309 { szMigrateFeatureStates, ACTION_MigrateFeatureStates },
4310 { szMoveFiles, ACTION_MoveFiles },
4311 { szMsiPublishAssemblies, ACTION_MsiPublishAssemblies },
4312 { szMsiUnpublishAssemblies, ACTION_MsiUnpublishAssemblies },
4313 { szInstallODBC, NULL},
4314 { szInstallServices, ACTION_InstallServices },
4315 { szPatchFiles, ACTION_PatchFiles },
4316 { szProcessComponents, ACTION_ProcessComponents },
4317 { szPublishComponents, ACTION_PublishComponents },
4318 { szPublishFeatures, ACTION_PublishFeatures },
4319 { szPublishProduct, ACTION_PublishProduct },
4320 { szRegisterClassInfo, ACTION_RegisterClassInfo },
4321 { szRegisterComPlus, ACTION_RegisterComPlus},
4322 { szRegisterExtensionInfo, ACTION_RegisterExtensionInfo },
4323 { szRegisterFonts, ACTION_RegisterFonts },
4324 { szRegisterMIMEInfo, ACTION_RegisterMIMEInfo },
4325 { szRegisterProduct, ACTION_RegisterProduct },
4326 { szRegisterProgIdInfo, ACTION_RegisterProgIdInfo },
4327 { szRegisterTypeLibraries, ACTION_RegisterTypeLibraries },
4328 { szRegisterUser, ACTION_RegisterUser},
4329 { szRemoveDuplicateFiles, NULL},
4330 { szRemoveEnvironmentStrings, ACTION_RemoveEnvironmentStrings },
4331 { szRemoveExistingProducts, NULL},
4332 { szRemoveFiles, ACTION_RemoveFiles},
4333 { szRemoveFolders, NULL},
4334 { szRemoveIniValues, ACTION_RemoveIniValues },
4335 { szRemoveODBC, NULL},
4336 { szRemoveRegistryValues, NULL},
4337 { szRemoveShortcuts, NULL},
4338 { szResolveSource, ACTION_ResolveSource},
4339 { szRMCCPSearch, ACTION_RMCCPSearch},
4340 { szScheduleReboot, NULL},
4341 { szSelfRegModules, ACTION_SelfRegModules },
4342 { szSelfUnregModules, ACTION_SelfUnregModules },
4343 { szSetODBCFolders, NULL},
4344 { szStartServices, ACTION_StartServices },
4345 { szStopServices, ACTION_StopServices },
4346 { szUnpublishComponents, NULL},
4347 { szUnpublishFeatures, NULL},
4348 { szUnregisterClassInfo, NULL},
4349 { szUnregisterComPlus, ACTION_UnregisterComPlus},
4350 { szUnregisterExtensionInfo, NULL},
4351 { szUnregisterFonts, ACTION_UnregisterFonts },
4352 { szUnregisterMIMEInfo, NULL},
4353 { szUnregisterProgIdInfo, NULL},
4354 { szUnregisterTypeLibraries, NULL},
4355 { szValidateProductID, NULL},
4356 { szWriteEnvironmentStrings, ACTION_WriteEnvironmentStrings },
4357 { szWriteIniValues, ACTION_WriteIniValues },
4358 { szWriteRegistryValues, ACTION_WriteRegistryValues},
4359 { NULL, NULL},
4360 };
Maarten's multimedia branch