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