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