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