?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mshtml: Added IDispatchEx support to HTMLImgElement.
[wine/multimedia.git] / dlls / msi / action.c
blob749da324cb48e60d3255558fe552f15075f42503
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 #include <stdarg.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winerror.h"
28 #include "winreg.h"
29 #include "winsvc.h"
30 #include "odbcinst.h"
31 #include "wine/debug.h"
32 #include "msidefs.h"
33 #include "msipriv.h"
34 #include "winuser.h"
35 #include "shlobj.h"
36 #include "objbase.h"
37 #include "mscoree.h"
38 #include "fusion.h"
39 #include "shlwapi.h"
40 #include "wine/unicode.h"
41 #include "winver.h"
42
43 #define REG_PROGRESS_VALUE 13200
44 #define COMPONENT_PROGRESS_VALUE 24000
45
46 WINE_DEFAULT_DEBUG_CHANNEL(msi);
47
48 /*
49 * Prototypes
50 */
51 static UINT ACTION_ProcessExecSequence(MSIPACKAGE *package, BOOL UIran);
52 static UINT ACTION_ProcessUISequence(MSIPACKAGE *package);
53 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq, BOOL UI);
54 static BOOL ACTION_HandleStandardAction(MSIPACKAGE *package, LPCWSTR action, UINT* rc, BOOL force);
55
56 /*
57 * consts and values used
58 */
59 static const WCHAR c_colon[] = {'C',':','\\',0};
60
61 static const WCHAR szCreateFolders[] =
62 {'C','r','e','a','t','e','F','o','l','d','e','r','s',0};
63 static const WCHAR szCostFinalize[] =
64 {'C','o','s','t','F','i','n','a','l','i','z','e',0};
65 const WCHAR szInstallFiles[] =
66 {'I','n','s','t','a','l','l','F','i','l','e','s',0};
67 const WCHAR szDuplicateFiles[] =
68 {'D','u','p','l','i','c','a','t','e','F','i','l','e','s',0};
69 static const WCHAR szWriteRegistryValues[] =
70 {'W','r','i','t','e','R','e','g','i','s','t','r','y',
71 'V','a','l','u','e','s',0};
72 static const WCHAR szCostInitialize[] =
73 {'C','o','s','t','I','n','i','t','i','a','l','i','z','e',0};
74 static const WCHAR szFileCost[] =
75 {'F','i','l','e','C','o','s','t',0};
76 static const WCHAR szInstallInitialize[] =
77 {'I','n','s','t','a','l','l','I','n','i','t','i','a','l','i','z','e',0};
78 static const WCHAR szInstallValidate[] =
79 {'I','n','s','t','a','l','l','V','a','l','i','d','a','t','e',0};
80 static const WCHAR szLaunchConditions[] =
81 {'L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','s',0};
82 static const WCHAR szProcessComponents[] =
83 {'P','r','o','c','e','s','s','C','o','m','p','o','n','e','n','t','s',0};
84 static const WCHAR szRegisterTypeLibraries[] =
85 {'R','e','g','i','s','t','e','r','T','y','p','e',
86 'L','i','b','r','a','r','i','e','s',0};
87 const WCHAR szRegisterClassInfo[] =
88 {'R','e','g','i','s','t','e','r','C','l','a','s','s','I','n','f','o',0};
89 const WCHAR szRegisterProgIdInfo[] =
90 {'R','e','g','i','s','t','e','r','P','r','o','g','I','d','I','n','f','o',0};
91 static const WCHAR szCreateShortcuts[] =
92 {'C','r','e','a','t','e','S','h','o','r','t','c','u','t','s',0};
93 static const WCHAR szPublishProduct[] =
94 {'P','u','b','l','i','s','h','P','r','o','d','u','c','t',0};
95 static const WCHAR szWriteIniValues[] =
96 {'W','r','i','t','e','I','n','i','V','a','l','u','e','s',0};
97 static const WCHAR szSelfRegModules[] =
98 {'S','e','l','f','R','e','g','M','o','d','u','l','e','s',0};
99 static const WCHAR szPublishFeatures[] =
100 {'P','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
101 static const WCHAR szRegisterProduct[] =
102 {'R','e','g','i','s','t','e','r','P','r','o','d','u','c','t',0};
103 static const WCHAR szInstallExecute[] =
104 {'I','n','s','t','a','l','l','E','x','e','c','u','t','e',0};
105 static const WCHAR szInstallExecuteAgain[] =
106 {'I','n','s','t','a','l','l','E','x','e','c','u','t','e',
107 'A','g','a','i','n',0};
108 static const WCHAR szInstallFinalize[] =
109 {'I','n','s','t','a','l','l','F','i','n','a','l','i','z','e',0};
110 static const WCHAR szForceReboot[] =
111 {'F','o','r','c','e','R','e','b','o','o','t',0};
112 static const WCHAR szResolveSource[] =
113 {'R','e','s','o','l','v','e','S','o','u','r','c','e',0};
114 static const WCHAR szAppSearch[] =
115 {'A','p','p','S','e','a','r','c','h',0};
116 static const WCHAR szAllocateRegistrySpace[] =
117 {'A','l','l','o','c','a','t','e','R','e','g','i','s','t','r','y',
118 'S','p','a','c','e',0};
119 static const WCHAR szBindImage[] =
120 {'B','i','n','d','I','m','a','g','e',0};
121 static const WCHAR szCCPSearch[] =
122 {'C','C','P','S','e','a','r','c','h',0};
123 static const WCHAR szDeleteServices[] =
124 {'D','e','l','e','t','e','S','e','r','v','i','c','e','s',0};
125 static const WCHAR szDisableRollback[] =
126 {'D','i','s','a','b','l','e','R','o','l','l','b','a','c','k',0};
127 static const WCHAR szExecuteAction[] =
128 {'E','x','e','c','u','t','e','A','c','t','i','o','n',0};
129 const WCHAR szFindRelatedProducts[] =
130 {'F','i','n','d','R','e','l','a','t','e','d',
131 'P','r','o','d','u','c','t','s',0};
132 static const WCHAR szInstallAdminPackage[] =
133 {'I','n','s','t','a','l','l','A','d','m','i','n',
134 'P','a','c','k','a','g','e',0};
135 static const WCHAR szInstallSFPCatalogFile[] =
136 {'I','n','s','t','a','l','l','S','F','P','C','a','t','a','l','o','g',
137 'F','i','l','e',0};
138 static const WCHAR szIsolateComponents[] =
139 {'I','s','o','l','a','t','e','C','o','m','p','o','n','e','n','t','s',0};
140 const WCHAR szMigrateFeatureStates[] =
141 {'M','i','g','r','a','t','e','F','e','a','t','u','r','e',
142 'S','t','a','t','e','s',0};
143 const WCHAR szMoveFiles[] =
144 {'M','o','v','e','F','i','l','e','s',0};
145 static const WCHAR szMsiPublishAssemblies[] =
146 {'M','s','i','P','u','b','l','i','s','h',
147 'A','s','s','e','m','b','l','i','e','s',0};
148 static const WCHAR szMsiUnpublishAssemblies[] =
149 {'M','s','i','U','n','p','u','b','l','i','s','h',
150 'A','s','s','e','m','b','l','i','e','s',0};
151 static const WCHAR szInstallODBC[] =
152 {'I','n','s','t','a','l','l','O','D','B','C',0};
153 static const WCHAR szInstallServices[] =
154 {'I','n','s','t','a','l','l','S','e','r','v','i','c','e','s',0};
155 const WCHAR szPatchFiles[] =
156 {'P','a','t','c','h','F','i','l','e','s',0};
157 static const WCHAR szPublishComponents[] =
158 {'P','u','b','l','i','s','h','C','o','m','p','o','n','e','n','t','s',0};
159 static const WCHAR szRegisterComPlus[] =
160 {'R','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
161 const WCHAR szRegisterExtensionInfo[] =
162 {'R','e','g','i','s','t','e','r','E','x','t','e','n','s','i','o','n',
163 'I','n','f','o',0};
164 static const WCHAR szRegisterFonts[] =
165 {'R','e','g','i','s','t','e','r','F','o','n','t','s',0};
166 const WCHAR szRegisterMIMEInfo[] =
167 {'R','e','g','i','s','t','e','r','M','I','M','E','I','n','f','o',0};
168 static const WCHAR szRegisterUser[] =
169 {'R','e','g','i','s','t','e','r','U','s','e','r',0};
170 const WCHAR szRemoveDuplicateFiles[] =
171 {'R','e','m','o','v','e','D','u','p','l','i','c','a','t','e',
172 'F','i','l','e','s',0};
173 static const WCHAR szRemoveEnvironmentStrings[] =
174 {'R','e','m','o','v','e','E','n','v','i','r','o','n','m','e','n','t',
175 'S','t','r','i','n','g','s',0};
176 const WCHAR szRemoveExistingProducts[] =
177 {'R','e','m','o','v','e','E','x','i','s','t','i','n','g',
178 'P','r','o','d','u','c','t','s',0};
179 const WCHAR szRemoveFiles[] =
180 {'R','e','m','o','v','e','F','i','l','e','s',0};
181 static const WCHAR szRemoveFolders[] =
182 {'R','e','m','o','v','e','F','o','l','d','e','r','s',0};
183 static const WCHAR szRemoveIniValues[] =
184 {'R','e','m','o','v','e','I','n','i','V','a','l','u','e','s',0};
185 static const WCHAR szRemoveODBC[] =
186 {'R','e','m','o','v','e','O','D','B','C',0};
187 static const WCHAR szRemoveRegistryValues[] =
188 {'R','e','m','o','v','e','R','e','g','i','s','t','r','y',
189 'V','a','l','u','e','s',0};
190 static const WCHAR szRemoveShortcuts[] =
191 {'R','e','m','o','v','e','S','h','o','r','t','c','u','t','s',0};
192 static const WCHAR szRMCCPSearch[] =
193 {'R','M','C','C','P','S','e','a','r','c','h',0};
194 static const WCHAR szScheduleReboot[] =
195 {'S','c','h','e','d','u','l','e','R','e','b','o','o','t',0};
196 static const WCHAR szSelfUnregModules[] =
197 {'S','e','l','f','U','n','r','e','g','M','o','d','u','l','e','s',0};
198 static const WCHAR szSetODBCFolders[] =
199 {'S','e','t','O','D','B','C','F','o','l','d','e','r','s',0};
200 static const WCHAR szStartServices[] =
201 {'S','t','a','r','t','S','e','r','v','i','c','e','s',0};
202 static const WCHAR szStopServices[] =
203 {'S','t','o','p','S','e','r','v','i','c','e','s',0};
204 static const WCHAR szUnpublishComponents[] =
205 {'U','n','p','u','b','l','i','s','h',
206 'C','o','m','p','o','n','e','n','t','s',0};
207 static const WCHAR szUnpublishFeatures[] =
208 {'U','n','p','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
209 const WCHAR szUnregisterClassInfo[] =
210 {'U','n','r','e','g','i','s','t','e','r','C','l','a','s','s',
211 'I','n','f','o',0};
212 static const WCHAR szUnregisterComPlus[] =
213 {'U','n','r','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
214 const WCHAR szUnregisterExtensionInfo[] =
215 {'U','n','r','e','g','i','s','t','e','r',
216 'E','x','t','e','n','s','i','o','n','I','n','f','o',0};
217 static const WCHAR szUnregisterFonts[] =
218 {'U','n','r','e','g','i','s','t','e','r','F','o','n','t','s',0};
219 const WCHAR szUnregisterMIMEInfo[] =
220 {'U','n','r','e','g','i','s','t','e','r','M','I','M','E','I','n','f','o',0};
221 const WCHAR szUnregisterProgIdInfo[] =
222 {'U','n','r','e','g','i','s','t','e','r','P','r','o','g','I','d',
223 'I','n','f','o',0};
224 static const WCHAR szUnregisterTypeLibraries[] =
225 {'U','n','r','e','g','i','s','t','e','r','T','y','p','e',
226 'L','i','b','r','a','r','i','e','s',0};
227 static const WCHAR szValidateProductID[] =
228 {'V','a','l','i','d','a','t','e','P','r','o','d','u','c','t','I','D',0};
229 static const WCHAR szWriteEnvironmentStrings[] =
230 {'W','r','i','t','e','E','n','v','i','r','o','n','m','e','n','t',
231 'S','t','r','i','n','g','s',0};
232
233 /* action handlers */
234 typedef UINT (*STANDARDACTIONHANDLER)(MSIPACKAGE*);
235
236 struct _actions {
237 LPCWSTR action;
238 STANDARDACTIONHANDLER handler;
239 };
240
241
242 /********************************************************
243 * helper functions
244 ********************************************************/
245
246 static void ui_actionstart(MSIPACKAGE *package, LPCWSTR action)
247 {
248 static const WCHAR Query_t[] =
249 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
250 '`','A','c','t','i','o', 'n','T','e','x','t','`',' ',
251 'W','H','E','R','E', ' ','`','A','c','t','i','o','n','`',' ','=',
252 ' ','\'','%','s','\'',0};
253 MSIRECORD * row;
254
255 row = MSI_QueryGetRecord( package->db, Query_t, action );
256 if (!row)
257 return;
258 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONSTART, row);
259 msiobj_release(&row->hdr);
260 }
261
262 static void ui_actioninfo(MSIPACKAGE *package, LPCWSTR action, BOOL start,
263 UINT rc)
264 {
265 MSIRECORD * row;
266 static const WCHAR template_s[]=
267 {'A','c','t','i','o','n',' ','s','t','a','r','t',' ','%','s',':',' ',
268 '%','s', '.',0};
269 static const WCHAR template_e[]=
270 {'A','c','t','i','o','n',' ','e','n','d','e','d',' ','%','s',':',' ',
271 '%','s', '.',' ','R','e','t','u','r','n',' ','v','a','l','u','e',' ',
272 '%','i','.',0};
273 static const WCHAR format[] =
274 {'H','H','\'',':','\'','m','m','\'',':','\'','s','s',0};
275 WCHAR message[1024];
276 WCHAR timet[0x100];
277
278 GetTimeFormatW(LOCALE_USER_DEFAULT, 0, NULL, format, timet, 0x100);
279 if (start)
280 sprintfW(message,template_s,timet,action);
281 else
282 sprintfW(message,template_e,timet,action,rc);
283
284 row = MSI_CreateRecord(1);
285 MSI_RecordSetStringW(row,1,message);
286
287 MSI_ProcessMessage(package, INSTALLMESSAGE_INFO, row);
288 msiobj_release(&row->hdr);
289 }
290
291 UINT msi_parse_command_line( MSIPACKAGE *package, LPCWSTR szCommandLine )
292 {
293 LPCWSTR ptr,ptr2;
294 BOOL quote;
295 DWORD len;
296 LPWSTR prop = NULL, val = NULL;
297
298 if (!szCommandLine)
299 return ERROR_SUCCESS;
300
301 ptr = szCommandLine;
302
303 while (*ptr)
304 {
305 if (*ptr==' ')
306 {
307 ptr++;
308 continue;
309 }
310
311 TRACE("Looking at %s\n",debugstr_w(ptr));
312
313 ptr2 = strchrW(ptr,'=');
314 if (!ptr2)
315 {
316 ERR("command line contains unknown string : %s\n", debugstr_w(ptr));
317 break;
318 }
319
320 quote = FALSE;
321
322 len = ptr2-ptr;
323 prop = msi_alloc((len+1)*sizeof(WCHAR));
324 memcpy(prop,ptr,len*sizeof(WCHAR));
325 prop[len]=0;
326 ptr2++;
327
328 len = 0;
329 ptr = ptr2;
330 while (*ptr && (quote || (!quote && *ptr!=' ')))
331 {
332 if (*ptr == '"')
333 quote = !quote;
334 ptr++;
335 len++;
336 }
337
338 if (*ptr2=='"')
339 {
340 ptr2++;
341 len -= 2;
342 }
343 val = msi_alloc((len+1)*sizeof(WCHAR));
344 memcpy(val,ptr2,len*sizeof(WCHAR));
345 val[len] = 0;
346
347 if (lstrlenW(prop) > 0)
348 {
349 TRACE("Found commandline property (%s) = (%s)\n",
350 debugstr_w(prop), debugstr_w(val));
351 MSI_SetPropertyW(package,prop,val);
352 }
353 msi_free(val);
354 msi_free(prop);
355 }
356
357 return ERROR_SUCCESS;
358 }
359
360
361 static LPWSTR* msi_split_string( LPCWSTR str, WCHAR sep )
362 {
363 LPCWSTR pc;
364 LPWSTR p, *ret = NULL;
365 UINT count = 0;
366
367 if (!str)
368 return ret;
369
370 /* count the number of substrings */
371 for ( pc = str, count = 0; pc; count++ )
372 {
373 pc = strchrW( pc, sep );
374 if (pc)
375 pc++;
376 }
377
378 /* allocate space for an array of substring pointers and the substrings */
379 ret = msi_alloc( (count+1) * sizeof (LPWSTR) +
380 (lstrlenW(str)+1) * sizeof(WCHAR) );
381 if (!ret)
382 return ret;
383
384 /* copy the string and set the pointers */
385 p = (LPWSTR) &ret[count+1];
386 lstrcpyW( p, str );
387 for( count = 0; (ret[count] = p); count++ )
388 {
389 p = strchrW( p, sep );
390 if (p)
391 *p++ = 0;
392 }
393
394 return ret;
395 }
396
397 static UINT msi_check_transform_applicable( MSIPACKAGE *package, IStorage *patch )
398 {
399 WCHAR szProductCode[] = { 'P','r','o','d','u','c','t','C','o','d','e',0 };
400 LPWSTR prod_code, patch_product;
401 UINT ret;
402
403 prod_code = msi_dup_property( package, szProductCode );
404 patch_product = msi_get_suminfo_product( patch );
405
406 TRACE("db = %s patch = %s\n", debugstr_w(prod_code), debugstr_w(patch_product));
407
408 if ( strstrW( patch_product, prod_code ) )
409 ret = ERROR_SUCCESS;
410 else
411 ret = ERROR_FUNCTION_FAILED;
412
413 msi_free( patch_product );
414 msi_free( prod_code );
415
416 return ret;
417 }
418
419 static UINT msi_apply_substorage_transform( MSIPACKAGE *package,
420 MSIDATABASE *patch_db, LPCWSTR name )
421 {
422 UINT ret = ERROR_FUNCTION_FAILED;
423 IStorage *stg = NULL;
424 HRESULT r;
425
426 TRACE("%p %s\n", package, debugstr_w(name) );
427
428 if (*name++ != ':')
429 {
430 ERR("expected a colon in %s\n", debugstr_w(name));
431 return ERROR_FUNCTION_FAILED;
432 }
433
434 r = IStorage_OpenStorage( patch_db->storage, name, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &stg );
435 if (SUCCEEDED(r))
436 {
437 ret = msi_check_transform_applicable( package, stg );
438 if (ret == ERROR_SUCCESS)
439 msi_table_apply_transform( package->db, stg );
440 else
441 TRACE("substorage transform %s wasn't applicable\n", debugstr_w(name));
442 IStorage_Release( stg );
443 }
444 else
445 ERR("failed to open substorage %s\n", debugstr_w(name));
446
447 return ERROR_SUCCESS;
448 }
449
450 static UINT msi_check_patch_applicable( MSIPACKAGE *package, MSISUMMARYINFO *si )
451 {
452 static const WCHAR szProdCode[] = { 'P','r','o','d','u','c','t','C','o','d','e',0 };
453 LPWSTR guid_list, *guids, product_code;
454 UINT i, ret = ERROR_FUNCTION_FAILED;
455
456 product_code = msi_dup_property( package, szProdCode );
457 if (!product_code)
458 {
459 /* FIXME: the property ProductCode should be written into the DB somewhere */
460 ERR("no product code to check\n");
461 return ERROR_SUCCESS;
462 }
463
464 guid_list = msi_suminfo_dup_string( si, PID_TEMPLATE );
465 guids = msi_split_string( guid_list, ';' );
466 for ( i = 0; guids[i] && ret != ERROR_SUCCESS; i++ )
467 {
468 if (!lstrcmpW( guids[i], product_code ))
469 ret = ERROR_SUCCESS;
470 }
471 msi_free( guids );
472 msi_free( guid_list );
473 msi_free( product_code );
474
475 return ret;
476 }
477
478 static UINT msi_parse_patch_summary( MSIPACKAGE *package, MSIDATABASE *patch_db )
479 {
480 MSISUMMARYINFO *si;
481 LPWSTR str, *substorage;
482 UINT i, r = ERROR_SUCCESS;
483
484 si = MSI_GetSummaryInformationW( patch_db->storage, 0 );
485 if (!si)
486 return ERROR_FUNCTION_FAILED;
487
488 msi_check_patch_applicable( package, si );
489
490 /* enumerate the substorage */
491 str = msi_suminfo_dup_string( si, PID_LASTAUTHOR );
492 substorage = msi_split_string( str, ';' );
493 for ( i = 0; substorage && substorage[i] && r == ERROR_SUCCESS; i++ )
494 r = msi_apply_substorage_transform( package, patch_db, substorage[i] );
495 msi_free( substorage );
496 msi_free( str );
497
498 /* FIXME: parse the sources in PID_REVNUMBER and do something with them... */
499
500 msiobj_release( &si->hdr );
501
502 return r;
503 }
504
505 static UINT msi_apply_patch_package( MSIPACKAGE *package, LPCWSTR file )
506 {
507 MSIDATABASE *patch_db = NULL;
508 UINT r;
509
510 TRACE("%p %s\n", package, debugstr_w( file ) );
511
512 /* FIXME:
513 * We probably want to make sure we only open a patch collection here.
514 * Patch collections (.msp) and databases (.msi) have different GUIDs
515 * but currently MSI_OpenDatabaseW will accept both.
516 */
517 r = MSI_OpenDatabaseW( file, MSIDBOPEN_READONLY, &patch_db );
518 if ( r != ERROR_SUCCESS )
519 {
520 ERR("failed to open patch collection %s\n", debugstr_w( file ) );
521 return r;
522 }
523
524 msi_parse_patch_summary( package, patch_db );
525
526 /*
527 * There might be a CAB file in the patch package,
528 * so append it to the list of storage to search for streams.
529 */
530 append_storage_to_db( package->db, patch_db->storage );
531
532 msiobj_release( &patch_db->hdr );
533
534 return ERROR_SUCCESS;
535 }
536
537 /* get the PATCH property, and apply all the patches it specifies */
538 static UINT msi_apply_patches( MSIPACKAGE *package )
539 {
540 static const WCHAR szPatch[] = { 'P','A','T','C','H',0 };
541 LPWSTR patch_list, *patches;
542 UINT i, r = ERROR_SUCCESS;
543
544 patch_list = msi_dup_property( package, szPatch );
545
546 TRACE("patches to be applied: %s\n", debugstr_w( patch_list ) );
547
548 patches = msi_split_string( patch_list, ';' );
549 for( i=0; patches && patches[i] && r == ERROR_SUCCESS; i++ )
550 r = msi_apply_patch_package( package, patches[i] );
551
552 msi_free( patches );
553 msi_free( patch_list );
554
555 return r;
556 }
557
558 static UINT msi_apply_transforms( MSIPACKAGE *package )
559 {
560 static const WCHAR szTransforms[] = {
561 'T','R','A','N','S','F','O','R','M','S',0 };
562 LPWSTR xform_list, *xforms;
563 UINT i, r = ERROR_SUCCESS;
564
565 xform_list = msi_dup_property( package, szTransforms );
566 xforms = msi_split_string( xform_list, ';' );
567
568 for( i=0; xforms && xforms[i] && r == ERROR_SUCCESS; i++ )
569 {
570 if (xforms[i][0] == ':')
571 r = msi_apply_substorage_transform( package, package->db, xforms[i] );
572 else
573 r = MSI_DatabaseApplyTransformW( package->db, xforms[i], 0 );
574 }
575
576 msi_free( xforms );
577 msi_free( xform_list );
578
579 return r;
580 }
581
582 static BOOL ui_sequence_exists( MSIPACKAGE *package )
583 {
584 MSIQUERY *view;
585 UINT rc;
586
587 static const WCHAR ExecSeqQuery [] =
588 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
589 '`','I','n','s','t','a','l','l',
590 'U','I','S','e','q','u','e','n','c','e','`',
591 ' ','W','H','E','R','E',' ',
592 '`','S','e','q','u','e','n','c','e','`',' ',
593 '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
594 '`','S','e','q','u','e','n','c','e','`',0};
595
596 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
597 if (rc == ERROR_SUCCESS)
598 {
599 msiobj_release(&view->hdr);
600 return TRUE;
601 }
602
603 return FALSE;
604 }
605
606 static UINT msi_set_sourcedir_props(MSIPACKAGE *package, BOOL replace)
607 {
608 LPWSTR p, db;
609 LPWSTR source, check;
610 DWORD len;
611
612 static const WCHAR szOriginalDatabase[] =
613 {'O','r','i','g','i','n','a','l','D','a','t','a','b','a','s','e',0};
614
615 db = msi_dup_property( package, szOriginalDatabase );
616 if (!db)
617 return ERROR_OUTOFMEMORY;
618
619 p = strrchrW( db, '\\' );
620 if (!p)
621 {
622 p = strrchrW( db, '/' );
623 if (!p)
624 {
625 msi_free(db);
626 return ERROR_SUCCESS;
627 }
628 }
629
630 len = p - db + 2;
631 source = msi_alloc( len * sizeof(WCHAR) );
632 lstrcpynW( source, db, len );
633
634 check = msi_dup_property( package, cszSourceDir );
635 if (!check || replace)
636 MSI_SetPropertyW( package, cszSourceDir, source );
637
638 msi_free( check );
639
640 check = msi_dup_property( package, cszSOURCEDIR );
641 if (!check || replace)
642 MSI_SetPropertyW( package, cszSOURCEDIR, source );
643
644 msi_free( check );
645 msi_free( source );
646 msi_free( db );
647
648 return ERROR_SUCCESS;
649 }
650
651 /****************************************************
652 * TOP level entry points
653 *****************************************************/
654
655 UINT MSI_InstallPackage( MSIPACKAGE *package, LPCWSTR szPackagePath,
656 LPCWSTR szCommandLine )
657 {
658 UINT rc;
659 BOOL ui = FALSE, ui_exists;
660 static const WCHAR szUILevel[] = {'U','I','L','e','v','e','l',0};
661 static const WCHAR szAction[] = {'A','C','T','I','O','N',0};
662 static const WCHAR szInstall[] = {'I','N','S','T','A','L','L',0};
663
664 MSI_SetPropertyW(package, szAction, szInstall);
665
666 package->script = msi_alloc_zero(sizeof(MSISCRIPT));
667
668 package->script->InWhatSequence = SEQUENCE_INSTALL;
669
670 if (szPackagePath)
671 {
672 LPWSTR p, dir;
673 LPCWSTR file;
674
675 dir = strdupW(szPackagePath);
676 p = strrchrW(dir, '\\');
677 if (p)
678 {
679 *(++p) = 0;
680 file = szPackagePath + (p - dir);
681 }
682 else
683 {
684 msi_free(dir);
685 dir = msi_alloc(MAX_PATH*sizeof(WCHAR));
686 GetCurrentDirectoryW(MAX_PATH, dir);
687 lstrcatW(dir, cszbs);
688 file = szPackagePath;
689 }
690
691 msi_free( package->PackagePath );
692 package->PackagePath = msi_alloc((lstrlenW(dir) + lstrlenW(file) + 1) * sizeof(WCHAR));
693 if (!package->PackagePath)
694 {
695 msi_free(dir);
696 return ERROR_OUTOFMEMORY;
697 }
698
699 lstrcpyW(package->PackagePath, dir);
700 lstrcatW(package->PackagePath, file);
701 msi_free(dir);
702
703 msi_set_sourcedir_props(package, FALSE);
704 }
705
706 msi_parse_command_line( package, szCommandLine );
707
708 msi_apply_transforms( package );
709 msi_apply_patches( package );
710
711 /* properties may have been added by a transform */
712 msi_clone_properties( package );
713
714 if ( (msi_get_property_int(package, szUILevel, 0) & INSTALLUILEVEL_MASK) >= INSTALLUILEVEL_REDUCED )
715 {
716 package->script->InWhatSequence |= SEQUENCE_UI;
717 rc = ACTION_ProcessUISequence(package);
718 ui = TRUE;
719 ui_exists = ui_sequence_exists(package);
720 if (rc == ERROR_SUCCESS || !ui_exists)
721 {
722 package->script->InWhatSequence |= SEQUENCE_EXEC;
723 rc = ACTION_ProcessExecSequence(package,ui_exists);
724 }
725 }
726 else
727 rc = ACTION_ProcessExecSequence(package,FALSE);
728
729 package->script->CurrentlyScripting= FALSE;
730
731 /* process the ending type action */
732 if (rc == ERROR_SUCCESS)
733 ACTION_PerformActionSequence(package,-1,ui);
734 else if (rc == ERROR_INSTALL_USEREXIT)
735 ACTION_PerformActionSequence(package,-2,ui);
736 else if (rc == ERROR_INSTALL_SUSPEND)
737 ACTION_PerformActionSequence(package,-4,ui);
738 else /* failed */
739 ACTION_PerformActionSequence(package,-3,ui);
740
741 /* finish up running custom actions */
742 ACTION_FinishCustomActions(package);
743
744 return rc;
745 }
746
747 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq, BOOL UI)
748 {
749 UINT rc = ERROR_SUCCESS;
750 MSIRECORD * row = 0;
751 static const WCHAR ExecSeqQuery[] =
752 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
753 '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
754 'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
755 '`','S','e','q','u','e','n','c','e','`',' ', '=',' ','%','i',0};
756
757 static const WCHAR UISeqQuery[] =
758 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
759 '`','I','n','s','t','a','l','l','U','I','S','e','q','u','e','n','c','e',
760 '`', ' ', 'W','H','E','R','E',' ','`','S','e','q','u','e','n','c','e','`',
761 ' ', '=',' ','%','i',0};
762
763 if (UI)
764 row = MSI_QueryGetRecord(package->db, UISeqQuery, seq);
765 else
766 row = MSI_QueryGetRecord(package->db, ExecSeqQuery, seq);
767
768 if (row)
769 {
770 LPCWSTR action, cond;
771
772 TRACE("Running the actions\n");
773
774 /* check conditions */
775 cond = MSI_RecordGetString(row,2);
776
777 /* this is a hack to skip errors in the condition code */
778 if (MSI_EvaluateConditionW(package, cond) == MSICONDITION_FALSE)
779 goto end;
780
781 action = MSI_RecordGetString(row,1);
782 if (!action)
783 {
784 ERR("failed to fetch action\n");
785 rc = ERROR_FUNCTION_FAILED;
786 goto end;
787 }
788
789 if (UI)
790 rc = ACTION_PerformUIAction(package,action,-1);
791 else
792 rc = ACTION_PerformAction(package,action,-1,FALSE);
793 end:
794 msiobj_release(&row->hdr);
795 }
796 else
797 rc = ERROR_SUCCESS;
798
799 return rc;
800 }
801
802 typedef struct {
803 MSIPACKAGE* package;
804 BOOL UI;
805 } iterate_action_param;
806
807 static UINT ITERATE_Actions(MSIRECORD *row, LPVOID param)
808 {
809 iterate_action_param *iap= (iterate_action_param*)param;
810 UINT rc;
811 LPCWSTR cond, action;
812
813 action = MSI_RecordGetString(row,1);
814 if (!action)
815 {
816 ERR("Error is retrieving action name\n");
817 return ERROR_FUNCTION_FAILED;
818 }
819
820 /* check conditions */
821 cond = MSI_RecordGetString(row,2);
822
823 /* this is a hack to skip errors in the condition code */
824 if (MSI_EvaluateConditionW(iap->package, cond) == MSICONDITION_FALSE)
825 {
826 TRACE("Skipping action: %s (condition is false)\n", debugstr_w(action));
827 return ERROR_SUCCESS;
828 }
829
830 if (iap->UI)
831 rc = ACTION_PerformUIAction(iap->package,action,-1);
832 else
833 rc = ACTION_PerformAction(iap->package,action,-1,FALSE);
834
835 msi_dialog_check_messages( NULL );
836
837 if (iap->package->CurrentInstallState != ERROR_SUCCESS )
838 rc = iap->package->CurrentInstallState;
839
840 if (rc == ERROR_FUNCTION_NOT_CALLED)
841 rc = ERROR_SUCCESS;
842
843 if (rc != ERROR_SUCCESS)
844 ERR("Execution halted, action %s returned %i\n", debugstr_w(action), rc);
845
846 return rc;
847 }
848
849 UINT MSI_Sequence( MSIPACKAGE *package, LPCWSTR szTable, INT iSequenceMode )
850 {
851 MSIQUERY * view;
852 UINT r;
853 static const WCHAR query[] =
854 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
855 '`','%','s','`',
856 ' ','W','H','E','R','E',' ',
857 '`','S','e','q','u','e','n','c','e','`',' ',
858 '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
859 '`','S','e','q','u','e','n','c','e','`',0};
860 iterate_action_param iap;
861
862 /*
863 * FIXME: probably should be checking UILevel in the
864 * ACTION_PerformUIAction/ACTION_PerformAction
865 * rather than saving the UI level here. Those
866 * two functions can be merged too.
867 */
868 iap.package = package;
869 iap.UI = TRUE;
870
871 TRACE("%p %s %i\n", package, debugstr_w(szTable), iSequenceMode );
872
873 r = MSI_OpenQuery( package->db, &view, query, szTable );
874 if (r == ERROR_SUCCESS)
875 {
876 r = MSI_IterateRecords( view, NULL, ITERATE_Actions, &iap );
877 msiobj_release(&view->hdr);
878 }
879
880 return r;
881 }
882
883 static UINT ACTION_ProcessExecSequence(MSIPACKAGE *package, BOOL UIran)
884 {
885 MSIQUERY * view;
886 UINT rc;
887 static const WCHAR ExecSeqQuery[] =
888 {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
889 '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
890 'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
891 '`','S','e','q','u','e','n','c','e','`',' ', '>',' ','%','i',' ',
892 'O','R','D','E','R',' ', 'B','Y',' ',
893 '`','S','e','q','u','e','n','c','e','`',0 };
894 MSIRECORD * row = 0;
895 static const WCHAR IVQuery[] =
896 {'S','E','L','E','C','T',' ','`','S','e','q','u','e','n','c','e','`',
897 ' ', 'F','R','O','M',' ','`','I','n','s','t','a','l','l',
898 'E','x','e','c','u','t','e','S','e','q','u','e','n','c','e','`',' ',
899 'W','H','E','R','E',' ','`','A','c','t','i','o','n','`',' ','=',
900 ' ','\'', 'I','n','s','t','a','l','l',
901 'V','a','l','i','d','a','t','e','\'', 0};
902 INT seq = 0;
903 iterate_action_param iap;
904
905 iap.package = package;
906 iap.UI = FALSE;
907
908 if (package->script->ExecuteSequenceRun)
909 {
910 TRACE("Execute Sequence already Run\n");
911 return ERROR_SUCCESS;
912 }
913
914 package->script->ExecuteSequenceRun = TRUE;
915
916 /* get the sequence number */
917 if (UIran)
918 {
919 row = MSI_QueryGetRecord(package->db, IVQuery);
920 if( !row )
921 return ERROR_FUNCTION_FAILED;
922 seq = MSI_RecordGetInteger(row,1);
923 msiobj_release(&row->hdr);
924 }
925
926 rc = MSI_OpenQuery(package->db, &view, ExecSeqQuery, seq);
927 if (rc == ERROR_SUCCESS)
928 {
929 TRACE("Running the actions\n");
930
931 rc = MSI_IterateRecords(view, NULL, ITERATE_Actions, &iap);
932 msiobj_release(&view->hdr);
933 }
934
935 return rc;
936 }
937
938 static UINT ACTION_ProcessUISequence(MSIPACKAGE *package)
939 {
940 MSIQUERY * view;
941 UINT rc;
942 static const WCHAR ExecSeqQuery [] =
943 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
944 '`','I','n','s','t','a','l','l',
945 'U','I','S','e','q','u','e','n','c','e','`',
946 ' ','W','H','E','R','E',' ',
947 '`','S','e','q','u','e','n','c','e','`',' ',
948 '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
949 '`','S','e','q','u','e','n','c','e','`',0};
950 iterate_action_param iap;
951
952 iap.package = package;
953 iap.UI = TRUE;
954
955 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
956
957 if (rc == ERROR_SUCCESS)
958 {
959 TRACE("Running the actions\n");
960
961 rc = MSI_IterateRecords(view, NULL, ITERATE_Actions, &iap);
962 msiobj_release(&view->hdr);
963 }
964
965 return rc;
966 }
967
968 /********************************************************
969 * ACTION helper functions and functions that perform the actions
970 *******************************************************/
971 static BOOL ACTION_HandleCustomAction( MSIPACKAGE* package, LPCWSTR action,
972 UINT* rc, UINT script, BOOL force )
973 {
974 BOOL ret=FALSE;
975 UINT arc;
976
977 arc = ACTION_CustomAction(package, action, script, force);
978
979 if (arc != ERROR_CALL_NOT_IMPLEMENTED)
980 {
981 *rc = arc;
982 ret = TRUE;
983 }
984 return ret;
985 }
986
987 /*
988 * A lot of actions are really important even if they don't do anything
989 * explicit... Lots of properties are set at the beginning of the installation
990 * CostFinalize does a bunch of work to translate the directories and such
991 *
992 * But until I get write access to the database that is hard, so I am going to
993 * hack it to see if I can get something to run.
994 */
995 UINT ACTION_PerformAction(MSIPACKAGE *package, const WCHAR *action, UINT script, BOOL force)
996 {
997 UINT rc = ERROR_SUCCESS;
998 BOOL handled;
999
1000 TRACE("Performing action (%s)\n",debugstr_w(action));
1001
1002 handled = ACTION_HandleStandardAction(package, action, &rc, force);
1003
1004 if (!handled)
1005 handled = ACTION_HandleCustomAction(package, action, &rc, script, force);
1006
1007 if (!handled)
1008 {
1009 WARN("unhandled msi action %s\n",debugstr_w(action));
1010 rc = ERROR_FUNCTION_NOT_CALLED;
1011 }
1012
1013 return rc;
1014 }
1015
1016 UINT ACTION_PerformUIAction(MSIPACKAGE *package, const WCHAR *action, UINT script)
1017 {
1018 UINT rc = ERROR_SUCCESS;
1019 BOOL handled = FALSE;
1020
1021 TRACE("Performing action (%s)\n",debugstr_w(action));
1022
1023 handled = ACTION_HandleStandardAction(package, action, &rc,TRUE);
1024
1025 if (!handled)
1026 handled = ACTION_HandleCustomAction(package, action, &rc, script, FALSE);
1027
1028 if( !handled && ACTION_DialogBox(package,action) == ERROR_SUCCESS )
1029 handled = TRUE;
1030
1031 if (!handled)
1032 {
1033 WARN("unhandled msi action %s\n",debugstr_w(action));
1034 rc = ERROR_FUNCTION_NOT_CALLED;
1035 }
1036
1037 return rc;
1038 }
1039
1040
1041 /*
1042 * Actual Action Handlers
1043 */
1044
1045 static UINT ITERATE_CreateFolders(MSIRECORD *row, LPVOID param)
1046 {
1047 MSIPACKAGE *package = (MSIPACKAGE*)param;
1048 LPCWSTR dir;
1049 LPWSTR full_path;
1050 MSIRECORD *uirow;
1051 MSIFOLDER *folder;
1052
1053 dir = MSI_RecordGetString(row,1);
1054 if (!dir)
1055 {
1056 ERR("Unable to get folder id\n");
1057 return ERROR_SUCCESS;
1058 }
1059
1060 full_path = resolve_folder(package,dir,FALSE,FALSE,TRUE,&folder);
1061 if (!full_path)
1062 {
1063 ERR("Unable to resolve folder id %s\n",debugstr_w(dir));
1064 return ERROR_SUCCESS;
1065 }
1066
1067 TRACE("Folder is %s\n",debugstr_w(full_path));
1068
1069 /* UI stuff */
1070 uirow = MSI_CreateRecord(1);
1071 MSI_RecordSetStringW(uirow,1,full_path);
1072 ui_actiondata(package,szCreateFolders,uirow);
1073 msiobj_release( &uirow->hdr );
1074
1075 if (folder->State == 0)
1076 create_full_pathW(full_path);
1077
1078 folder->State = 3;
1079
1080 msi_free(full_path);
1081 return ERROR_SUCCESS;
1082 }
1083
1084 /* FIXME: probably should merge this with the above function */
1085 static UINT msi_create_directory( MSIPACKAGE* package, LPCWSTR dir )
1086 {
1087 UINT rc = ERROR_SUCCESS;
1088 MSIFOLDER *folder;
1089 LPWSTR install_path;
1090
1091 install_path = resolve_folder(package, dir, FALSE, FALSE, TRUE, &folder);
1092 if (!install_path)
1093 return ERROR_FUNCTION_FAILED;
1094
1095 /* create the path */
1096 if (folder->State == 0)
1097 {
1098 create_full_pathW(install_path);
1099 folder->State = 2;
1100 }
1101 msi_free(install_path);
1102
1103 return rc;
1104 }
1105
1106 UINT msi_create_component_directories( MSIPACKAGE *package )
1107 {
1108 MSICOMPONENT *comp;
1109
1110 /* create all the folders required by the components are going to install */
1111 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
1112 {
1113 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
1114 continue;
1115 msi_create_directory( package, comp->Directory );
1116 }
1117
1118 return ERROR_SUCCESS;
1119 }
1120
1121 /*
1122 * Also we cannot enable/disable components either, so for now I am just going
1123 * to do all the directories for all the components.
1124 */
1125 static UINT ACTION_CreateFolders(MSIPACKAGE *package)
1126 {
1127 static const WCHAR ExecSeqQuery[] =
1128 {'S','E','L','E','C','T',' ',
1129 '`','D','i','r','e','c','t','o','r','y','_','`',
1130 ' ','F','R','O','M',' ',
1131 '`','C','r','e','a','t','e','F','o','l','d','e','r','`',0 };
1132 UINT rc;
1133 MSIQUERY *view;
1134
1135 /* create all the empty folders specified in the CreateFolder table */
1136 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view );
1137 if (rc != ERROR_SUCCESS)
1138 return ERROR_SUCCESS;
1139
1140 rc = MSI_IterateRecords(view, NULL, ITERATE_CreateFolders, package);
1141 msiobj_release(&view->hdr);
1142
1143 msi_create_component_directories( package );
1144
1145 return rc;
1146 }
1147
1148 static UINT load_component( MSIRECORD *row, LPVOID param )
1149 {
1150 MSIPACKAGE *package = param;
1151 MSICOMPONENT *comp;
1152
1153 comp = msi_alloc_zero( sizeof(MSICOMPONENT) );
1154 if (!comp)
1155 return ERROR_FUNCTION_FAILED;
1156
1157 list_add_tail( &package->components, &comp->entry );
1158
1159 /* fill in the data */
1160 comp->Component = msi_dup_record_field( row, 1 );
1161
1162 TRACE("Loading Component %s\n", debugstr_w(comp->Component));
1163
1164 comp->ComponentId = msi_dup_record_field( row, 2 );
1165 comp->Directory = msi_dup_record_field( row, 3 );
1166 comp->Attributes = MSI_RecordGetInteger(row,4);
1167 comp->Condition = msi_dup_record_field( row, 5 );
1168 comp->KeyPath = msi_dup_record_field( row, 6 );
1169
1170 comp->Installed = INSTALLSTATE_UNKNOWN;
1171 msi_component_set_state( comp, INSTALLSTATE_UNKNOWN );
1172
1173 return ERROR_SUCCESS;
1174 }
1175
1176 static UINT load_all_components( MSIPACKAGE *package )
1177 {
1178 static const WCHAR query[] = {
1179 'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
1180 '`','C','o','m','p','o','n','e','n','t','`',0 };
1181 MSIQUERY *view;
1182 UINT r;
1183
1184 if (!list_empty(&package->components))
1185 return ERROR_SUCCESS;
1186
1187 r = MSI_DatabaseOpenViewW( package->db, query, &view );
1188 if (r != ERROR_SUCCESS)
1189 return r;
1190
1191 r = MSI_IterateRecords(view, NULL, load_component, package);
1192 msiobj_release(&view->hdr);
1193 return r;
1194 }
1195
1196 typedef struct {
1197 MSIPACKAGE *package;
1198 MSIFEATURE *feature;
1199 } _ilfs;
1200
1201 static UINT add_feature_component( MSIFEATURE *feature, MSICOMPONENT *comp )
1202 {
1203 ComponentList *cl;
1204
1205 cl = msi_alloc( sizeof (*cl) );
1206 if ( !cl )
1207 return ERROR_NOT_ENOUGH_MEMORY;
1208 cl->component = comp;
1209 list_add_tail( &feature->Components, &cl->entry );
1210
1211 return ERROR_SUCCESS;
1212 }
1213
1214 static UINT add_feature_child( MSIFEATURE *parent, MSIFEATURE *child )
1215 {
1216 FeatureList *fl;
1217
1218 fl = msi_alloc( sizeof(*fl) );
1219 if ( !fl )
1220 return ERROR_NOT_ENOUGH_MEMORY;
1221 fl->feature = child;
1222 list_add_tail( &parent->Children, &fl->entry );
1223
1224 return ERROR_SUCCESS;
1225 }
1226
1227 static UINT iterate_load_featurecomponents(MSIRECORD *row, LPVOID param)
1228 {
1229 _ilfs* ilfs= (_ilfs*)param;
1230 LPCWSTR component;
1231 MSICOMPONENT *comp;
1232
1233 component = MSI_RecordGetString(row,1);
1234
1235 /* check to see if the component is already loaded */
1236 comp = get_loaded_component( ilfs->package, component );
1237 if (!comp)
1238 {
1239 ERR("unknown component %s\n", debugstr_w(component));
1240 return ERROR_FUNCTION_FAILED;
1241 }
1242
1243 add_feature_component( ilfs->feature, comp );
1244 comp->Enabled = TRUE;
1245
1246 return ERROR_SUCCESS;
1247 }
1248
1249 static MSIFEATURE *find_feature_by_name( MSIPACKAGE *package, LPCWSTR name )
1250 {
1251 MSIFEATURE *feature;
1252
1253 if ( !name )
1254 return NULL;
1255
1256 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1257 {
1258 if ( !lstrcmpW( feature->Feature, name ) )
1259 return feature;
1260 }
1261
1262 return NULL;
1263 }
1264
1265 static UINT load_feature(MSIRECORD * row, LPVOID param)
1266 {
1267 MSIPACKAGE* package = (MSIPACKAGE*)param;
1268 MSIFEATURE* feature;
1269 static const WCHAR Query1[] =
1270 {'S','E','L','E','C','T',' ',
1271 '`','C','o','m','p','o','n','e','n','t','_','`',
1272 ' ','F','R','O','M',' ','`','F','e','a','t','u','r','e',
1273 'C','o','m','p','o','n','e','n','t','s','`',' ',
1274 'W','H','E','R','E',' ',
1275 '`','F','e', 'a','t','u','r','e','_','`',' ','=','\'','%','s','\'',0};
1276 MSIQUERY * view;
1277 UINT rc;
1278 _ilfs ilfs;
1279
1280 /* fill in the data */
1281
1282 feature = msi_alloc_zero( sizeof (MSIFEATURE) );
1283 if (!feature)
1284 return ERROR_NOT_ENOUGH_MEMORY;
1285
1286 list_init( &feature->Children );
1287 list_init( &feature->Components );
1288
1289 feature->Feature = msi_dup_record_field( row, 1 );
1290
1291 TRACE("Loading feature %s\n",debugstr_w(feature->Feature));
1292
1293 feature->Feature_Parent = msi_dup_record_field( row, 2 );
1294 feature->Title = msi_dup_record_field( row, 3 );
1295 feature->Description = msi_dup_record_field( row, 4 );
1296
1297 if (!MSI_RecordIsNull(row,5))
1298 feature->Display = MSI_RecordGetInteger(row,5);
1299
1300 feature->Level= MSI_RecordGetInteger(row,6);
1301 feature->Directory = msi_dup_record_field( row, 7 );
1302 feature->Attributes = MSI_RecordGetInteger(row,8);
1303
1304 feature->Installed = INSTALLSTATE_UNKNOWN;
1305 msi_feature_set_state( feature, INSTALLSTATE_UNKNOWN );
1306
1307 list_add_tail( &package->features, &feature->entry );
1308
1309 /* load feature components */
1310
1311 rc = MSI_OpenQuery( package->db, &view, Query1, feature->Feature );
1312 if (rc != ERROR_SUCCESS)
1313 return ERROR_SUCCESS;
1314
1315 ilfs.package = package;
1316 ilfs.feature = feature;
1317
1318 MSI_IterateRecords(view, NULL, iterate_load_featurecomponents , &ilfs);
1319 msiobj_release(&view->hdr);
1320
1321 return ERROR_SUCCESS;
1322 }
1323
1324 static UINT find_feature_children(MSIRECORD * row, LPVOID param)
1325 {
1326 MSIPACKAGE* package = (MSIPACKAGE*)param;
1327 MSIFEATURE *parent, *child;
1328
1329 child = find_feature_by_name( package, MSI_RecordGetString( row, 1 ) );
1330 if (!child)
1331 return ERROR_FUNCTION_FAILED;
1332
1333 if (!child->Feature_Parent)
1334 return ERROR_SUCCESS;
1335
1336 parent = find_feature_by_name( package, child->Feature_Parent );
1337 if (!parent)
1338 return ERROR_FUNCTION_FAILED;
1339
1340 add_feature_child( parent, child );
1341 return ERROR_SUCCESS;
1342 }
1343
1344 static UINT load_all_features( MSIPACKAGE *package )
1345 {
1346 static const WCHAR query[] = {
1347 'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1348 '`','F','e','a','t','u','r','e','`',' ','O','R','D','E','R',
1349 ' ','B','Y',' ','`','D','i','s','p','l','a','y','`',0};
1350 MSIQUERY *view;
1351 UINT r;
1352
1353 if (!list_empty(&package->features))
1354 return ERROR_SUCCESS;
1355
1356 r = MSI_DatabaseOpenViewW( package->db, query, &view );
1357 if (r != ERROR_SUCCESS)
1358 return r;
1359
1360 r = MSI_IterateRecords( view, NULL, load_feature, package );
1361 if (r != ERROR_SUCCESS)
1362 return r;
1363
1364 r = MSI_IterateRecords( view, NULL, find_feature_children, package );
1365 msiobj_release( &view->hdr );
1366
1367 return r;
1368 }
1369
1370 static LPWSTR folder_split_path(LPWSTR p, WCHAR ch)
1371 {
1372 if (!p)
1373 return p;
1374 p = strchrW(p, ch);
1375 if (!p)
1376 return p;
1377 *p = 0;
1378 return p+1;
1379 }
1380
1381 static UINT load_file_hash(MSIPACKAGE *package, MSIFILE *file)
1382 {
1383 static const WCHAR query[] = {
1384 'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1385 '`','M','s','i','F','i','l','e','H','a','s','h','`',' ',
1386 'W','H','E','R','E',' ','`','F','i','l','e','_','`',' ','=',' ','\'','%','s','\'',0};
1387 MSIQUERY *view = NULL;
1388 MSIRECORD *row = NULL;
1389 UINT r;
1390
1391 TRACE("%s\n", debugstr_w(file->File));
1392
1393 r = MSI_OpenQuery(package->db, &view, query, file->File);
1394 if (r != ERROR_SUCCESS)
1395 goto done;
1396
1397 r = MSI_ViewExecute(view, NULL);
1398 if (r != ERROR_SUCCESS)
1399 goto done;
1400
1401 r = MSI_ViewFetch(view, &row);
1402 if (r != ERROR_SUCCESS)
1403 goto done;
1404
1405 file->hash.dwFileHashInfoSize = sizeof(MSIFILEHASHINFO);
1406 file->hash.dwData[0] = MSI_RecordGetInteger(row, 3);
1407 file->hash.dwData[1] = MSI_RecordGetInteger(row, 4);
1408 file->hash.dwData[2] = MSI_RecordGetInteger(row, 5);
1409 file->hash.dwData[3] = MSI_RecordGetInteger(row, 6);
1410
1411 done:
1412 if (view) msiobj_release(&view->hdr);
1413 if (row) msiobj_release(&row->hdr);
1414 return r;
1415 }
1416
1417 static UINT load_file(MSIRECORD *row, LPVOID param)
1418 {
1419 MSIPACKAGE* package = (MSIPACKAGE*)param;
1420 LPCWSTR component;
1421 MSIFILE *file;
1422
1423 /* fill in the data */
1424
1425 file = msi_alloc_zero( sizeof (MSIFILE) );
1426 if (!file)
1427 return ERROR_NOT_ENOUGH_MEMORY;
1428
1429 file->File = msi_dup_record_field( row, 1 );
1430
1431 component = MSI_RecordGetString( row, 2 );
1432 file->Component = get_loaded_component( package, component );
1433
1434 if (!file->Component)
1435 ERR("Unfound Component %s\n",debugstr_w(component));
1436
1437 file->FileName = msi_dup_record_field( row, 3 );
1438 reduce_to_longfilename( file->FileName );
1439
1440 file->ShortName = msi_dup_record_field( row, 3 );
1441 file->LongName = strdupW( folder_split_path(file->ShortName, '|'));
1442
1443 file->FileSize = MSI_RecordGetInteger( row, 4 );
1444 file->Version = msi_dup_record_field( row, 5 );
1445 file->Language = msi_dup_record_field( row, 6 );
1446 file->Attributes = MSI_RecordGetInteger( row, 7 );
1447 file->Sequence = MSI_RecordGetInteger( row, 8 );
1448
1449 file->state = msifs_invalid;
1450
1451 /* if the compressed bits are not set in the file attributes,
1452 * then read the information from the package word count property
1453 */
1454 if (file->Attributes & msidbFileAttributesCompressed)
1455 {
1456 file->IsCompressed = TRUE;
1457 }
1458 else if (file->Attributes & msidbFileAttributesNoncompressed)
1459 {
1460 file->IsCompressed = FALSE;
1461 }
1462 else
1463 {
1464 file->IsCompressed = package->WordCount & MSIWORDCOUNT_COMPRESSED;
1465 }
1466
1467 load_file_hash(package, file);
1468
1469 TRACE("File Loaded (%s)\n",debugstr_w(file->File));
1470
1471 list_add_tail( &package->files, &file->entry );
1472
1473 return ERROR_SUCCESS;
1474 }
1475
1476 static UINT load_all_files(MSIPACKAGE *package)
1477 {
1478 MSIQUERY * view;
1479 UINT rc;
1480 static const WCHAR Query[] =
1481 {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1482 '`','F','i','l','e','`',' ', 'O','R','D','E','R',' ','B','Y',' ',
1483 '`','S','e','q','u','e','n','c','e','`', 0};
1484
1485 if (!list_empty(&package->files))
1486 return ERROR_SUCCESS;
1487
1488 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
1489 if (rc != ERROR_SUCCESS)
1490 return ERROR_SUCCESS;
1491
1492 rc = MSI_IterateRecords(view, NULL, load_file, package);
1493 msiobj_release(&view->hdr);
1494
1495 return ERROR_SUCCESS;
1496 }
1497
1498 static UINT load_folder( MSIRECORD *row, LPVOID param )
1499 {
1500 MSIPACKAGE *package = param;
1501 static const WCHAR szDot[] = { '.',0 };
1502 static WCHAR szEmpty[] = { 0 };
1503 LPWSTR p, tgt_short, tgt_long, src_short, src_long;
1504 MSIFOLDER *folder;
1505
1506 folder = msi_alloc_zero( sizeof (MSIFOLDER) );
1507 if (!folder)
1508 return ERROR_NOT_ENOUGH_MEMORY;
1509
1510 folder->Directory = msi_dup_record_field( row, 1 );
1511
1512 TRACE("%s\n", debugstr_w(folder->Directory));
1513
1514 p = msi_dup_record_field(row, 3);
1515
1516 /* split src and target dir */
1517 tgt_short = p;
1518 src_short = folder_split_path( p, ':' );
1519
1520 /* split the long and short paths */
1521 tgt_long = folder_split_path( tgt_short, '|' );
1522 src_long = folder_split_path( src_short, '|' );
1523
1524 /* check for no-op dirs */
1525 if (!lstrcmpW(szDot, tgt_short))
1526 tgt_short = szEmpty;
1527 if (!lstrcmpW(szDot, src_short))
1528 src_short = szEmpty;
1529
1530 if (!tgt_long)
1531 tgt_long = tgt_short;
1532
1533 if (!src_short) {
1534 src_short = tgt_short;
1535 src_long = tgt_long;
1536 }
1537
1538 if (!src_long)
1539 src_long = src_short;
1540
1541 /* FIXME: use the target short path too */
1542 folder->TargetDefault = strdupW(tgt_long);
1543 folder->SourceShortPath = strdupW(src_short);
1544 folder->SourceLongPath = strdupW(src_long);
1545 msi_free(p);
1546
1547 TRACE("TargetDefault = %s\n",debugstr_w( folder->TargetDefault ));
1548 TRACE("SourceLong = %s\n", debugstr_w( folder->SourceLongPath ));
1549 TRACE("SourceShort = %s\n", debugstr_w( folder->SourceShortPath ));
1550
1551 folder->Parent = msi_dup_record_field( row, 2 );
1552
1553 folder->Property = msi_dup_property( package, folder->Directory );
1554
1555 list_add_tail( &package->folders, &folder->entry );
1556
1557 TRACE("returning %p\n", folder);
1558
1559 return ERROR_SUCCESS;
1560 }
1561
1562 static UINT load_all_folders( MSIPACKAGE *package )
1563 {
1564 static const WCHAR query[] = {
1565 'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
1566 '`','D','i','r','e','c','t','o','r','y','`',0 };
1567 MSIQUERY *view;
1568 UINT r;
1569
1570 if (!list_empty(&package->folders))
1571 return ERROR_SUCCESS;
1572
1573 r = MSI_DatabaseOpenViewW( package->db, query, &view );
1574 if (r != ERROR_SUCCESS)
1575 return r;
1576
1577 r = MSI_IterateRecords(view, NULL, load_folder, package);
1578 msiobj_release(&view->hdr);
1579 return r;
1580 }
1581
1582 /*
1583 * I am not doing any of the costing functionality yet.
1584 * Mostly looking at doing the Component and Feature loading
1585 *
1586 * The native MSI does A LOT of modification to tables here. Mostly adding
1587 * a lot of temporary columns to the Feature and Component tables.
1588 *
1589 * note: Native msi also tracks the short filename. But I am only going to
1590 * track the long ones. Also looking at this directory table
1591 * it appears that the directory table does not get the parents
1592 * resolved base on property only based on their entries in the
1593 * directory table.
1594 */
1595 static UINT ACTION_CostInitialize(MSIPACKAGE *package)
1596 {
1597 static const WCHAR szCosting[] =
1598 {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
1599 static const WCHAR szZero[] = { '0', 0 };
1600
1601 MSI_SetPropertyW(package, szCosting, szZero);
1602 MSI_SetPropertyW(package, cszRootDrive, c_colon);
1603
1604 load_all_components( package );
1605 load_all_features( package );
1606 load_all_files( package );
1607 load_all_folders( package );
1608
1609 return ERROR_SUCCESS;
1610 }
1611
1612 static UINT execute_script(MSIPACKAGE *package, UINT script )
1613 {
1614 UINT i;
1615 UINT rc = ERROR_SUCCESS;
1616
1617 TRACE("Executing Script %i\n",script);
1618
1619 if (!package->script)
1620 {
1621 ERR("no script!\n");
1622 return ERROR_FUNCTION_FAILED;
1623 }
1624
1625 for (i = 0; i < package->script->ActionCount[script]; i++)
1626 {
1627 LPWSTR action;
1628 action = package->script->Actions[script][i];
1629 ui_actionstart(package, action);
1630 TRACE("Executing Action (%s)\n",debugstr_w(action));
1631 rc = ACTION_PerformAction(package, action, script, TRUE);
1632 if (rc != ERROR_SUCCESS)
1633 break;
1634 }
1635 msi_free_action_script(package, script);
1636 return rc;
1637 }
1638
1639 static UINT ACTION_FileCost(MSIPACKAGE *package)
1640 {
1641 return ERROR_SUCCESS;
1642 }
1643
1644 static void ACTION_GetComponentInstallStates(MSIPACKAGE *package)
1645 {
1646 MSICOMPONENT *comp;
1647
1648 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
1649 {
1650 INSTALLSTATE res;
1651
1652 if (!comp->ComponentId)
1653 continue;
1654
1655 res = MsiGetComponentPathW( package->ProductCode,
1656 comp->ComponentId, NULL, NULL);
1657 if (res < 0)
1658 res = INSTALLSTATE_ABSENT;
1659 comp->Installed = res;
1660 }
1661 }
1662
1663 /* scan for and update current install states */
1664 static void ACTION_UpdateFeatureInstallStates(MSIPACKAGE *package)
1665 {
1666 MSICOMPONENT *comp;
1667 MSIFEATURE *feature;
1668
1669 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1670 {
1671 ComponentList *cl;
1672 INSTALLSTATE res = INSTALLSTATE_ABSENT;
1673
1674 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1675 {
1676 comp= cl->component;
1677
1678 if (!comp->ComponentId)
1679 {
1680 res = INSTALLSTATE_ABSENT;
1681 break;
1682 }
1683
1684 if (res == INSTALLSTATE_ABSENT)
1685 res = comp->Installed;
1686 else
1687 {
1688 if (res == comp->Installed)
1689 continue;
1690
1691 if (res != INSTALLSTATE_DEFAULT && res != INSTALLSTATE_LOCAL &&
1692 res != INSTALLSTATE_SOURCE)
1693 {
1694 res = INSTALLSTATE_INCOMPLETE;
1695 }
1696 }
1697 }
1698 feature->Installed = res;
1699 }
1700 }
1701
1702 static BOOL process_state_property (MSIPACKAGE* package, LPCWSTR property,
1703 INSTALLSTATE state)
1704 {
1705 static const WCHAR all[]={'A','L','L',0};
1706 LPWSTR override;
1707 MSIFEATURE *feature;
1708
1709 override = msi_dup_property( package, property );
1710 if (!override)
1711 return FALSE;
1712
1713 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1714 {
1715 if (strcmpiW(override,all)==0)
1716 msi_feature_set_state( feature, state );
1717 else
1718 {
1719 LPWSTR ptr = override;
1720 LPWSTR ptr2 = strchrW(override,',');
1721
1722 while (ptr)
1723 {
1724 if ((ptr2 && strncmpW(ptr,feature->Feature, ptr2-ptr)==0)
1725 || (!ptr2 && strcmpW(ptr,feature->Feature)==0))
1726 {
1727 msi_feature_set_state( feature, state );
1728 break;
1729 }
1730 if (ptr2)
1731 {
1732 ptr=ptr2+1;
1733 ptr2 = strchrW(ptr,',');
1734 }
1735 else
1736 break;
1737 }
1738 }
1739 }
1740 msi_free(override);
1741
1742 return TRUE;
1743 }
1744
1745 UINT MSI_SetFeatureStates(MSIPACKAGE *package)
1746 {
1747 int install_level;
1748 static const WCHAR szlevel[] =
1749 {'I','N','S','T','A','L','L','L','E','V','E','L',0};
1750 static const WCHAR szAddLocal[] =
1751 {'A','D','D','L','O','C','A','L',0};
1752 static const WCHAR szAddSource[] =
1753 {'A','D','D','S','O','U','R','C','E',0};
1754 static const WCHAR szRemove[] =
1755 {'R','E','M','O','V','E',0};
1756 static const WCHAR szReinstall[] =
1757 {'R','E','I','N','S','T','A','L','L',0};
1758 BOOL override = FALSE;
1759 MSICOMPONENT* component;
1760 MSIFEATURE *feature;
1761
1762
1763 /* I do not know if this is where it should happen.. but */
1764
1765 TRACE("Checking Install Level\n");
1766
1767 install_level = msi_get_property_int( package, szlevel, 1 );
1768
1769 /* ok here is the _real_ rub
1770 * all these activation/deactivation things happen in order and things
1771 * later on the list override things earlier on the list.
1772 * 1) INSTALLLEVEL processing
1773 * 2) ADDLOCAL
1774 * 3) REMOVE
1775 * 4) ADDSOURCE
1776 * 5) ADDDEFAULT
1777 * 6) REINSTALL
1778 * 7) COMPADDLOCAL
1779 * 8) COMPADDSOURCE
1780 * 9) FILEADDLOCAL
1781 * 10) FILEADDSOURCE
1782 * 11) FILEADDDEFAULT
1783 * I have confirmed that if ADDLOCAL is stated then the INSTALLLEVEL is
1784 * ignored for all the features. seems strange, especially since it is not
1785 * documented anywhere, but it is how it works.
1786 *
1787 * I am still ignoring a lot of these. But that is ok for now, ADDLOCAL and
1788 * REMOVE are the big ones, since we don't handle administrative installs
1789 * yet anyway.
1790 */
1791 override |= process_state_property(package,szAddLocal,INSTALLSTATE_LOCAL);
1792 override |= process_state_property(package,szRemove,INSTALLSTATE_ABSENT);
1793 override |= process_state_property(package,szAddSource,INSTALLSTATE_SOURCE);
1794 override |= process_state_property(package,szReinstall,INSTALLSTATE_LOCAL);
1795
1796 if (!override)
1797 {
1798 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1799 {
1800 BOOL feature_state = ((feature->Level > 0) &&
1801 (feature->Level <= install_level));
1802
1803 if ((feature_state) && (feature->Action == INSTALLSTATE_UNKNOWN))
1804 {
1805 if (feature->Attributes & msidbFeatureAttributesFavorSource)
1806 msi_feature_set_state( feature, INSTALLSTATE_SOURCE );
1807 else if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
1808 msi_feature_set_state( feature, INSTALLSTATE_ADVERTISED );
1809 else
1810 msi_feature_set_state( feature, INSTALLSTATE_LOCAL );
1811 }
1812 }
1813
1814 /* disable child features of unselected parent features */
1815 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1816 {
1817 FeatureList *fl;
1818
1819 if (feature->Level > 0 && feature->Level <= install_level)
1820 continue;
1821
1822 LIST_FOR_EACH_ENTRY( fl, &feature->Children, FeatureList, entry )
1823 msi_feature_set_state( fl->feature, INSTALLSTATE_UNKNOWN );
1824 }
1825 }
1826 else
1827 {
1828 /* set the Preselected Property */
1829 static const WCHAR szPreselected[] = {'P','r','e','s','e','l','e','c','t','e','d',0};
1830 static const WCHAR szOne[] = { '1', 0 };
1831
1832 MSI_SetPropertyW(package,szPreselected,szOne);
1833 }
1834
1835 /*
1836 * now we want to enable or disable components base on feature
1837 */
1838
1839 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1840 {
1841 ComponentList *cl;
1842
1843 TRACE("Examining Feature %s (Installed %i, Action %i)\n",
1844 debugstr_w(feature->Feature), feature->Installed, feature->Action);
1845
1846 /* features with components that have compressed files are made local */
1847 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1848 {
1849 if (cl->component->Enabled &&
1850 cl->component->ForceLocalState &&
1851 feature->Action == INSTALLSTATE_SOURCE)
1852 {
1853 msi_feature_set_state( feature, INSTALLSTATE_LOCAL );
1854 break;
1855 }
1856 }
1857
1858 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1859 {
1860 component = cl->component;
1861
1862 if (!component->Enabled)
1863 continue;
1864
1865 switch (feature->Action)
1866 {
1867 case INSTALLSTATE_ABSENT:
1868 component->anyAbsent = 1;
1869 break;
1870 case INSTALLSTATE_ADVERTISED:
1871 component->hasAdvertiseFeature = 1;
1872 break;
1873 case INSTALLSTATE_SOURCE:
1874 component->hasSourceFeature = 1;
1875 break;
1876 case INSTALLSTATE_LOCAL:
1877 component->hasLocalFeature = 1;
1878 break;
1879 case INSTALLSTATE_DEFAULT:
1880 if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
1881 component->hasAdvertiseFeature = 1;
1882 else if (feature->Attributes & msidbFeatureAttributesFavorSource)
1883 component->hasSourceFeature = 1;
1884 else
1885 component->hasLocalFeature = 1;
1886 break;
1887 default:
1888 break;
1889 }
1890 }
1891 }
1892
1893 LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
1894 {
1895 /* if the component isn't enabled, leave it alone */
1896 if (!component->Enabled)
1897 continue;
1898
1899 /* check if it's local or source */
1900 if (!(component->Attributes & msidbComponentAttributesOptional) &&
1901 (component->hasLocalFeature || component->hasSourceFeature))
1902 {
1903 if ((component->Attributes & msidbComponentAttributesSourceOnly) &&
1904 !component->ForceLocalState)
1905 msi_component_set_state( component, INSTALLSTATE_SOURCE );
1906 else
1907 msi_component_set_state( component, INSTALLSTATE_LOCAL );
1908 continue;
1909 }
1910
1911 /* if any feature is local, the component must be local too */
1912 if (component->hasLocalFeature)
1913 {
1914 msi_component_set_state( component, INSTALLSTATE_LOCAL );
1915 continue;
1916 }
1917
1918 if (component->hasSourceFeature)
1919 {
1920 msi_component_set_state( component, INSTALLSTATE_SOURCE );
1921 continue;
1922 }
1923
1924 if (component->hasAdvertiseFeature)
1925 {
1926 msi_component_set_state( component, INSTALLSTATE_ADVERTISED );
1927 continue;
1928 }
1929
1930 TRACE("nobody wants component %s\n", debugstr_w(component->Component));
1931 if (component->anyAbsent)
1932 msi_component_set_state(component, INSTALLSTATE_ABSENT);
1933 }
1934
1935 LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
1936 {
1937 if (component->Action == INSTALLSTATE_DEFAULT)
1938 {
1939 TRACE("%s was default, setting to local\n", debugstr_w(component->Component));
1940 msi_component_set_state( component, INSTALLSTATE_LOCAL );
1941 }
1942
1943 TRACE("Result: Component %s (Installed %i, Action %i)\n",
1944 debugstr_w(component->Component), component->Installed, component->Action);
1945 }
1946
1947
1948 return ERROR_SUCCESS;
1949 }
1950
1951 static UINT ITERATE_CostFinalizeDirectories(MSIRECORD *row, LPVOID param)
1952 {
1953 MSIPACKAGE *package = (MSIPACKAGE*)param;
1954 LPCWSTR name;
1955 LPWSTR path;
1956 MSIFOLDER *f;
1957
1958 name = MSI_RecordGetString(row,1);
1959
1960 f = get_loaded_folder(package, name);
1961 if (!f) return ERROR_SUCCESS;
1962
1963 /* reset the ResolvedTarget */
1964 msi_free(f->ResolvedTarget);
1965 f->ResolvedTarget = NULL;
1966
1967 /* This helper function now does ALL the work */
1968 TRACE("Dir %s ...\n",debugstr_w(name));
1969 path = resolve_folder(package,name,FALSE,TRUE,TRUE,NULL);
1970 TRACE("resolves to %s\n",debugstr_w(path));
1971 msi_free(path);
1972
1973 return ERROR_SUCCESS;
1974 }
1975
1976 static UINT ITERATE_CostFinalizeConditions(MSIRECORD *row, LPVOID param)
1977 {
1978 MSIPACKAGE *package = (MSIPACKAGE*)param;
1979 LPCWSTR name;
1980 MSIFEATURE *feature;
1981
1982 name = MSI_RecordGetString( row, 1 );
1983
1984 feature = get_loaded_feature( package, name );
1985 if (!feature)
1986 ERR("FAILED to find loaded feature %s\n",debugstr_w(name));
1987 else
1988 {
1989 LPCWSTR Condition;
1990 Condition = MSI_RecordGetString(row,3);
1991
1992 if (MSI_EvaluateConditionW(package,Condition) == MSICONDITION_TRUE)
1993 {
1994 int level = MSI_RecordGetInteger(row,2);
1995 TRACE("Reseting feature %s to level %i\n", debugstr_w(name), level);
1996 feature->Level = level;
1997 }
1998 }
1999 return ERROR_SUCCESS;
2000 }
2001
2002 static LPWSTR msi_get_disk_file_version( LPCWSTR filename )
2003 {
2004 static const WCHAR name_fmt[] =
2005 {'%','u','.','%','u','.','%','u','.','%','u',0};
2006 static WCHAR name[] = {'\\',0};
2007 VS_FIXEDFILEINFO *lpVer;
2008 WCHAR filever[0x100];
2009 LPVOID version;
2010 DWORD versize;
2011 DWORD handle;
2012 UINT sz;
2013
2014 TRACE("%s\n", debugstr_w(filename));
2015
2016 versize = GetFileVersionInfoSizeW( filename, &handle );
2017 if (!versize)
2018 return NULL;
2019
2020 version = msi_alloc( versize );
2021 GetFileVersionInfoW( filename, 0, versize, version );
2022
2023 if (!VerQueryValueW( version, name, (LPVOID*)&lpVer, &sz ))
2024 {
2025 msi_free( version );
2026 return NULL;
2027 }
2028
2029 sprintfW( filever, name_fmt,
2030 HIWORD(lpVer->dwFileVersionMS),
2031 LOWORD(lpVer->dwFileVersionMS),
2032 HIWORD(lpVer->dwFileVersionLS),
2033 LOWORD(lpVer->dwFileVersionLS));
2034
2035 msi_free( version );
2036
2037 return strdupW( filever );
2038 }
2039
2040 static UINT msi_check_file_install_states( MSIPACKAGE *package )
2041 {
2042 LPWSTR file_version;
2043 MSIFILE *file;
2044
2045 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2046 {
2047 MSICOMPONENT* comp = file->Component;
2048 LPWSTR p;
2049
2050 if (!comp)
2051 continue;
2052
2053 if (file->IsCompressed)
2054 comp->ForceLocalState = TRUE;
2055
2056 /* calculate target */
2057 p = resolve_folder(package, comp->Directory, FALSE, FALSE, TRUE, NULL);
2058
2059 msi_free(file->TargetPath);
2060
2061 TRACE("file %s is named %s\n",
2062 debugstr_w(file->File), debugstr_w(file->FileName));
2063
2064 file->TargetPath = build_directory_name(2, p, file->FileName);
2065
2066 msi_free(p);
2067
2068 TRACE("file %s resolves to %s\n",
2069 debugstr_w(file->File), debugstr_w(file->TargetPath));
2070
2071 /* don't check files of components that aren't installed */
2072 if (comp->Installed == INSTALLSTATE_UNKNOWN ||
2073 comp->Installed == INSTALLSTATE_ABSENT)
2074 {
2075 file->state = msifs_missing; /* assume files are missing */
2076 continue;
2077 }
2078
2079 if (GetFileAttributesW(file->TargetPath) == INVALID_FILE_ATTRIBUTES)
2080 {
2081 file->state = msifs_missing;
2082 comp->Cost += file->FileSize;
2083 comp->Installed = INSTALLSTATE_INCOMPLETE;
2084 continue;
2085 }
2086
2087 if (file->Version &&
2088 (file_version = msi_get_disk_file_version( file->TargetPath )))
2089 {
2090 TRACE("new %s old %s\n", debugstr_w(file->Version),
2091 debugstr_w(file_version));
2092 /* FIXME: seems like a bad way to compare version numbers */
2093 if (lstrcmpiW(file_version, file->Version)<0)
2094 {
2095 file->state = msifs_overwrite;
2096 comp->Cost += file->FileSize;
2097 comp->Installed = INSTALLSTATE_INCOMPLETE;
2098 }
2099 else
2100 file->state = msifs_present;
2101 msi_free( file_version );
2102 }
2103 else
2104 file->state = msifs_present;
2105 }
2106
2107 return ERROR_SUCCESS;
2108 }
2109
2110 /*
2111 * A lot is done in this function aside from just the costing.
2112 * The costing needs to be implemented at some point but for now I am going
2113 * to focus on the directory building
2114 *
2115 */
2116 static UINT ACTION_CostFinalize(MSIPACKAGE *package)
2117 {
2118 static const WCHAR ExecSeqQuery[] =
2119 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2120 '`','D','i','r','e','c','t','o','r','y','`',0};
2121 static const WCHAR ConditionQuery[] =
2122 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2123 '`','C','o','n','d','i','t','i','o','n','`',0};
2124 static const WCHAR szCosting[] =
2125 {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
2126 static const WCHAR szlevel[] =
2127 {'I','N','S','T','A','L','L','L','E','V','E','L',0};
2128 static const WCHAR szOne[] = { '1', 0 };
2129 MSICOMPONENT *comp;
2130 UINT rc;
2131 MSIQUERY * view;
2132 LPWSTR level;
2133
2134 if ( 1 == msi_get_property_int( package, szCosting, 0 ) )
2135 return ERROR_SUCCESS;
2136
2137 TRACE("Building Directory properties\n");
2138
2139 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2140 if (rc == ERROR_SUCCESS)
2141 {
2142 rc = MSI_IterateRecords(view, NULL, ITERATE_CostFinalizeDirectories,
2143 package);
2144 msiobj_release(&view->hdr);
2145 }
2146
2147 /* read components states from the registry */
2148 ACTION_GetComponentInstallStates(package);
2149
2150 TRACE("File calculations\n");
2151 msi_check_file_install_states( package );
2152
2153 TRACE("Evaluating Condition Table\n");
2154
2155 rc = MSI_DatabaseOpenViewW(package->db, ConditionQuery, &view);
2156 if (rc == ERROR_SUCCESS)
2157 {
2158 rc = MSI_IterateRecords(view, NULL, ITERATE_CostFinalizeConditions,
2159 package);
2160 msiobj_release(&view->hdr);
2161 }
2162
2163 TRACE("Enabling or Disabling Components\n");
2164 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2165 {
2166 if (MSI_EvaluateConditionW(package, comp->Condition) == MSICONDITION_FALSE)
2167 {
2168 TRACE("Disabling component %s\n", debugstr_w(comp->Component));
2169 comp->Enabled = FALSE;
2170 }
2171 }
2172
2173 MSI_SetPropertyW(package,szCosting,szOne);
2174 /* set default run level if not set */
2175 level = msi_dup_property( package, szlevel );
2176 if (!level)
2177 MSI_SetPropertyW(package,szlevel, szOne);
2178 msi_free(level);
2179
2180 ACTION_UpdateFeatureInstallStates(package);
2181
2182 return MSI_SetFeatureStates(package);
2183 }
2184
2185 /* OK this value is "interpreted" and then formatted based on the
2186 first few characters */
2187 static LPSTR parse_value(MSIPACKAGE *package, LPCWSTR value, DWORD *type,
2188 DWORD *size)
2189 {
2190 LPSTR data = NULL;
2191
2192 if (value[0]=='#' && value[1]!='#' && value[1]!='%')
2193 {
2194 if (value[1]=='x')
2195 {
2196 LPWSTR ptr;
2197 CHAR byte[5];
2198 LPWSTR deformated = NULL;
2199 int count;
2200
2201 deformat_string(package, &value[2], &deformated);
2202
2203 /* binary value type */
2204 ptr = deformated;
2205 *type = REG_BINARY;
2206 if (strlenW(ptr)%2)
2207 *size = (strlenW(ptr)/2)+1;
2208 else
2209 *size = strlenW(ptr)/2;
2210
2211 data = msi_alloc(*size);
2212
2213 byte[0] = '0';
2214 byte[1] = 'x';
2215 byte[4] = 0;
2216 count = 0;
2217 /* if uneven pad with a zero in front */
2218 if (strlenW(ptr)%2)
2219 {
2220 byte[2]= '0';
2221 byte[3]= *ptr;
2222 ptr++;
2223 data[count] = (BYTE)strtol(byte,NULL,0);
2224 count ++;
2225 TRACE("Uneven byte count\n");
2226 }
2227 while (*ptr)
2228 {
2229 byte[2]= *ptr;
2230 ptr++;
2231 byte[3]= *ptr;
2232 ptr++;
2233 data[count] = (BYTE)strtol(byte,NULL,0);
2234 count ++;
2235 }
2236 msi_free(deformated);
2237
2238 TRACE("Data %i bytes(%i)\n",*size,count);
2239 }
2240 else
2241 {
2242 LPWSTR deformated;
2243 LPWSTR p;
2244 DWORD d = 0;
2245 deformat_string(package, &value[1], &deformated);
2246
2247 *type=REG_DWORD;
2248 *size = sizeof(DWORD);
2249 data = msi_alloc(*size);
2250 p = deformated;
2251 if (*p == '-')
2252 p++;
2253 while (*p)
2254 {
2255 if ( (*p < '0') || (*p > '9') )
2256 break;
2257 d *= 10;
2258 d += (*p - '0');
2259 p++;
2260 }
2261 if (deformated[0] == '-')
2262 d = -d;
2263 *(LPDWORD)data = d;
2264 TRACE("DWORD %i\n",*(LPDWORD)data);
2265
2266 msi_free(deformated);
2267 }
2268 }
2269 else
2270 {
2271 static const WCHAR szMulti[] = {'[','~',']',0};
2272 LPCWSTR ptr;
2273 *type=REG_SZ;
2274
2275 if (value[0]=='#')
2276 {
2277 if (value[1]=='%')
2278 {
2279 ptr = &value[2];
2280 *type=REG_EXPAND_SZ;
2281 }
2282 else
2283 ptr = &value[1];
2284 }
2285 else
2286 ptr=value;
2287
2288 if (strstrW(value,szMulti))
2289 *type = REG_MULTI_SZ;
2290
2291 /* remove initial delimiter */
2292 if (!strncmpW(value, szMulti, 3))
2293 ptr = value + 3;
2294
2295 *size = deformat_string(package, ptr,(LPWSTR*)&data);
2296
2297 /* add double NULL terminator */
2298 if (*type == REG_MULTI_SZ)
2299 {
2300 *size += 2 * sizeof(WCHAR); /* two NULL terminators */
2301 data = msi_realloc_zero(data, *size);
2302 }
2303 }
2304 return data;
2305 }
2306
2307 static UINT ITERATE_WriteRegistryValues(MSIRECORD *row, LPVOID param)
2308 {
2309 MSIPACKAGE *package = (MSIPACKAGE*)param;
2310 static const WCHAR szHCR[] =
2311 {'H','K','E','Y','_','C','L','A','S','S','E','S','_',
2312 'R','O','O','T','\\',0};
2313 static const WCHAR szHCU[] =
2314 {'H','K','E','Y','_','C','U','R','R','E','N','T','_',
2315 'U','S','E','R','\\',0};
2316 static const WCHAR szHLM[] =
2317 {'H','K','E','Y','_','L','O','C','A','L','_',
2318 'M','A','C','H','I','N','E','\\',0};
2319 static const WCHAR szHU[] =
2320 {'H','K','E','Y','_','U','S','E','R','S','\\',0};
2321
2322 LPSTR value_data = NULL;
2323 HKEY root_key, hkey;
2324 DWORD type,size;
2325 LPWSTR deformated;
2326 LPCWSTR szRoot, component, name, key, value;
2327 MSICOMPONENT *comp;
2328 MSIRECORD * uirow;
2329 LPWSTR uikey;
2330 INT root;
2331 BOOL check_first = FALSE;
2332 UINT rc;
2333
2334 ui_progress(package,2,0,0,0);
2335
2336 value = NULL;
2337 key = NULL;
2338 uikey = NULL;
2339 name = NULL;
2340
2341 component = MSI_RecordGetString(row, 6);
2342 comp = get_loaded_component(package,component);
2343 if (!comp)
2344 return ERROR_SUCCESS;
2345
2346 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2347 {
2348 TRACE("Skipping write due to disabled component %s\n",
2349 debugstr_w(component));
2350
2351 comp->Action = comp->Installed;
2352
2353 return ERROR_SUCCESS;
2354 }
2355
2356 comp->Action = INSTALLSTATE_LOCAL;
2357
2358 name = MSI_RecordGetString(row, 4);
2359 if( MSI_RecordIsNull(row,5) && name )
2360 {
2361 /* null values can have special meanings */
2362 if (name[0]=='-' && name[1] == 0)
2363 return ERROR_SUCCESS;
2364 else if ((name[0]=='+' && name[1] == 0) ||
2365 (name[0] == '*' && name[1] == 0))
2366 name = NULL;
2367 check_first = TRUE;
2368 }
2369
2370 root = MSI_RecordGetInteger(row,2);
2371 key = MSI_RecordGetString(row, 3);
2372
2373 /* get the root key */
2374 switch (root)
2375 {
2376 case -1:
2377 {
2378 static const WCHAR szALLUSER[] = {'A','L','L','U','S','E','R','S',0};
2379 LPWSTR all_users = msi_dup_property( package, szALLUSER );
2380 if (all_users && all_users[0] == '1')
2381 {
2382 root_key = HKEY_LOCAL_MACHINE;
2383 szRoot = szHLM;
2384 }
2385 else
2386 {
2387 root_key = HKEY_CURRENT_USER;
2388 szRoot = szHCU;
2389 }
2390 msi_free(all_users);
2391 }
2392 break;
2393 case 0: root_key = HKEY_CLASSES_ROOT;
2394 szRoot = szHCR;
2395 break;
2396 case 1: root_key = HKEY_CURRENT_USER;
2397 szRoot = szHCU;
2398 break;
2399 case 2: root_key = HKEY_LOCAL_MACHINE;
2400 szRoot = szHLM;
2401 break;
2402 case 3: root_key = HKEY_USERS;
2403 szRoot = szHU;
2404 break;
2405 default:
2406 ERR("Unknown root %i\n",root);
2407 root_key=NULL;
2408 szRoot = NULL;
2409 break;
2410 }
2411 if (!root_key)
2412 return ERROR_SUCCESS;
2413
2414 deformat_string(package, key , &deformated);
2415 size = strlenW(deformated) + strlenW(szRoot) + 1;
2416 uikey = msi_alloc(size*sizeof(WCHAR));
2417 strcpyW(uikey,szRoot);
2418 strcatW(uikey,deformated);
2419
2420 if (RegCreateKeyW( root_key, deformated, &hkey))
2421 {
2422 ERR("Could not create key %s\n",debugstr_w(deformated));
2423 msi_free(deformated);
2424 msi_free(uikey);
2425 return ERROR_SUCCESS;
2426 }
2427 msi_free(deformated);
2428
2429 value = MSI_RecordGetString(row,5);
2430 if (value)
2431 value_data = parse_value(package, value, &type, &size);
2432 else
2433 {
2434 static const WCHAR szEmpty[] = {0};
2435 value_data = (LPSTR)strdupW(szEmpty);
2436 size = sizeof(szEmpty);
2437 type = REG_SZ;
2438 }
2439
2440 deformat_string(package, name, &deformated);
2441
2442 if (!check_first)
2443 {
2444 TRACE("Setting value %s of %s\n",debugstr_w(deformated),
2445 debugstr_w(uikey));
2446 RegSetValueExW(hkey, deformated, 0, type, (LPBYTE)value_data, size);
2447 }
2448 else
2449 {
2450 DWORD sz = 0;
2451 rc = RegQueryValueExW(hkey, deformated, NULL, NULL, NULL, &sz);
2452 if (rc == ERROR_SUCCESS || rc == ERROR_MORE_DATA)
2453 {
2454 TRACE("value %s of %s checked already exists\n",
2455 debugstr_w(deformated), debugstr_w(uikey));
2456 }
2457 else
2458 {
2459 TRACE("Checked and setting value %s of %s\n",
2460 debugstr_w(deformated), debugstr_w(uikey));
2461 if (deformated || size)
2462 RegSetValueExW(hkey, deformated, 0, type, (LPBYTE) value_data, size);
2463 }
2464 }
2465 RegCloseKey(hkey);
2466
2467 uirow = MSI_CreateRecord(3);
2468 MSI_RecordSetStringW(uirow,2,deformated);
2469 MSI_RecordSetStringW(uirow,1,uikey);
2470
2471 if (type == REG_SZ)
2472 MSI_RecordSetStringW(uirow,3,(LPWSTR)value_data);
2473 else
2474 MSI_RecordSetStringW(uirow,3,value);
2475
2476 ui_actiondata(package,szWriteRegistryValues,uirow);
2477 msiobj_release( &uirow->hdr );
2478
2479 msi_free(value_data);
2480 msi_free(deformated);
2481 msi_free(uikey);
2482
2483 return ERROR_SUCCESS;
2484 }
2485
2486 static UINT ACTION_WriteRegistryValues(MSIPACKAGE *package)
2487 {
2488 UINT rc;
2489 MSIQUERY * view;
2490 static const WCHAR ExecSeqQuery[] =
2491 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2492 '`','R','e','g','i','s','t','r','y','`',0 };
2493
2494 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2495 if (rc != ERROR_SUCCESS)
2496 return ERROR_SUCCESS;
2497
2498 /* increment progress bar each time action data is sent */
2499 ui_progress(package,1,REG_PROGRESS_VALUE,1,0);
2500
2501 rc = MSI_IterateRecords(view, NULL, ITERATE_WriteRegistryValues, package);
2502
2503 msiobj_release(&view->hdr);
2504 return rc;
2505 }
2506
2507 static UINT ACTION_InstallInitialize(MSIPACKAGE *package)
2508 {
2509 package->script->CurrentlyScripting = TRUE;
2510
2511 return ERROR_SUCCESS;
2512 }
2513
2514
2515 static UINT ACTION_InstallValidate(MSIPACKAGE *package)
2516 {
2517 MSICOMPONENT *comp;
2518 DWORD progress = 0;
2519 DWORD total = 0;
2520 static const WCHAR q1[]=
2521 {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
2522 '`','R','e','g','i','s','t','r','y','`',0};
2523 UINT rc;
2524 MSIQUERY * view;
2525 MSIFEATURE *feature;
2526 MSIFILE *file;
2527
2528 TRACE("InstallValidate\n");
2529
2530 rc = MSI_DatabaseOpenViewW(package->db, q1, &view);
2531 if (rc == ERROR_SUCCESS)
2532 {
2533 MSI_IterateRecords( view, &progress, NULL, package );
2534 msiobj_release( &view->hdr );
2535 total += progress * REG_PROGRESS_VALUE;
2536 }
2537
2538 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2539 total += COMPONENT_PROGRESS_VALUE;
2540
2541 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2542 total += file->FileSize;
2543
2544 ui_progress(package,0,total,0,0);
2545
2546 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2547 {
2548 TRACE("Feature: %s; Installed: %i; Action %i; Request %i\n",
2549 debugstr_w(feature->Feature), feature->Installed, feature->Action,
2550 feature->ActionRequest);
2551 }
2552
2553 return ERROR_SUCCESS;
2554 }
2555
2556 static UINT ITERATE_LaunchConditions(MSIRECORD *row, LPVOID param)
2557 {
2558 MSIPACKAGE* package = (MSIPACKAGE*)param;
2559 LPCWSTR cond = NULL;
2560 LPCWSTR message = NULL;
2561 UINT r;
2562
2563 static const WCHAR title[]=
2564 {'I','n','s','t','a','l','l',' ','F','a', 'i','l','e','d',0};
2565
2566 cond = MSI_RecordGetString(row,1);
2567
2568 r = MSI_EvaluateConditionW(package,cond);
2569 if (r == MSICONDITION_FALSE)
2570 {
2571 if ((gUILevel & INSTALLUILEVEL_MASK) != INSTALLUILEVEL_NONE)
2572 {
2573 LPWSTR deformated;
2574 message = MSI_RecordGetString(row,2);
2575 deformat_string(package,message,&deformated);
2576 MessageBoxW(NULL,deformated,title,MB_OK);
2577 msi_free(deformated);
2578 }
2579
2580 return ERROR_INSTALL_FAILURE;
2581 }
2582
2583 return ERROR_SUCCESS;
2584 }
2585
2586 static UINT ACTION_LaunchConditions(MSIPACKAGE *package)
2587 {
2588 UINT rc;
2589 MSIQUERY * view = NULL;
2590 static const WCHAR ExecSeqQuery[] =
2591 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2592 '`','L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','`',0};
2593
2594 TRACE("Checking launch conditions\n");
2595
2596 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2597 if (rc != ERROR_SUCCESS)
2598 return ERROR_SUCCESS;
2599
2600 rc = MSI_IterateRecords(view, NULL, ITERATE_LaunchConditions, package);
2601 msiobj_release(&view->hdr);
2602
2603 return rc;
2604 }
2605
2606 static LPWSTR resolve_keypath( MSIPACKAGE* package, MSICOMPONENT *cmp )
2607 {
2608
2609 if (!cmp->KeyPath)
2610 return resolve_folder(package,cmp->Directory,FALSE,FALSE,TRUE,NULL);
2611
2612 if (cmp->Attributes & msidbComponentAttributesRegistryKeyPath)
2613 {
2614 MSIRECORD * row = 0;
2615 UINT root,len;
2616 LPWSTR deformated,buffer,deformated_name;
2617 LPCWSTR key,name;
2618 static const WCHAR ExecSeqQuery[] =
2619 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2620 '`','R','e','g','i','s','t','r','y','`',' ',
2621 'W','H','E','R','E',' ', '`','R','e','g','i','s','t','r','y','`',
2622 ' ','=',' ' ,'\'','%','s','\'',0 };
2623 static const WCHAR fmt[]={'%','0','2','i',':','\\','%','s','\\',0};
2624 static const WCHAR fmt2[]=
2625 {'%','0','2','i',':','\\','%','s','\\','%','s',0};
2626
2627 row = MSI_QueryGetRecord(package->db, ExecSeqQuery,cmp->KeyPath);
2628 if (!row)
2629 return NULL;
2630
2631 root = MSI_RecordGetInteger(row,2);
2632 key = MSI_RecordGetString(row, 3);
2633 name = MSI_RecordGetString(row, 4);
2634 deformat_string(package, key , &deformated);
2635 deformat_string(package, name, &deformated_name);
2636
2637 len = strlenW(deformated) + 6;
2638 if (deformated_name)
2639 len+=strlenW(deformated_name);
2640
2641 buffer = msi_alloc( len *sizeof(WCHAR));
2642
2643 if (deformated_name)
2644 sprintfW(buffer,fmt2,root,deformated,deformated_name);
2645 else
2646 sprintfW(buffer,fmt,root,deformated);
2647
2648 msi_free(deformated);
2649 msi_free(deformated_name);
2650 msiobj_release(&row->hdr);
2651
2652 return buffer;
2653 }
2654 else if (cmp->Attributes & msidbComponentAttributesODBCDataSource)
2655 {
2656 FIXME("UNIMPLEMENTED keypath as ODBC Source\n");
2657 return NULL;
2658 }
2659 else
2660 {
2661 MSIFILE *file = get_loaded_file( package, cmp->KeyPath );
2662
2663 if (file)
2664 return strdupW( file->TargetPath );
2665 }
2666 return NULL;
2667 }
2668
2669 static HKEY openSharedDLLsKey(void)
2670 {
2671 HKEY hkey=0;
2672 static const WCHAR path[] =
2673 {'S','o','f','t','w','a','r','e','\\',
2674 'M','i','c','r','o','s','o','f','t','\\',
2675 'W','i','n','d','o','w','s','\\',
2676 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
2677 'S','h','a','r','e','d','D','L','L','s',0};
2678
2679 RegCreateKeyW(HKEY_LOCAL_MACHINE,path,&hkey);
2680 return hkey;
2681 }
2682
2683 static UINT ACTION_GetSharedDLLsCount(LPCWSTR dll)
2684 {
2685 HKEY hkey;
2686 DWORD count=0;
2687 DWORD type;
2688 DWORD sz = sizeof(count);
2689 DWORD rc;
2690
2691 hkey = openSharedDLLsKey();
2692 rc = RegQueryValueExW(hkey, dll, NULL, &type, (LPBYTE)&count, &sz);
2693 if (rc != ERROR_SUCCESS)
2694 count = 0;
2695 RegCloseKey(hkey);
2696 return count;
2697 }
2698
2699 static UINT ACTION_WriteSharedDLLsCount(LPCWSTR path, UINT count)
2700 {
2701 HKEY hkey;
2702
2703 hkey = openSharedDLLsKey();
2704 if (count > 0)
2705 msi_reg_set_val_dword( hkey, path, count );
2706 else
2707 RegDeleteValueW(hkey,path);
2708 RegCloseKey(hkey);
2709 return count;
2710 }
2711
2712 /*
2713 * Return TRUE if the count should be written out and FALSE if not
2714 */
2715 static void ACTION_RefCountComponent( MSIPACKAGE* package, MSICOMPONENT *comp )
2716 {
2717 MSIFEATURE *feature;
2718 INT count = 0;
2719 BOOL write = FALSE;
2720
2721 /* only refcount DLLs */
2722 if (comp->KeyPath == NULL ||
2723 comp->Attributes & msidbComponentAttributesRegistryKeyPath ||
2724 comp->Attributes & msidbComponentAttributesODBCDataSource)
2725 write = FALSE;
2726 else
2727 {
2728 count = ACTION_GetSharedDLLsCount( comp->FullKeypath);
2729 write = (count > 0);
2730
2731 if (comp->Attributes & msidbComponentAttributesSharedDllRefCount)
2732 write = TRUE;
2733 }
2734
2735 /* increment counts */
2736 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2737 {
2738 ComponentList *cl;
2739
2740 if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_LOCAL ))
2741 continue;
2742
2743 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
2744 {
2745 if ( cl->component == comp )
2746 count++;
2747 }
2748 }
2749
2750 /* decrement counts */
2751 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2752 {
2753 ComponentList *cl;
2754
2755 if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_ABSENT ))
2756 continue;
2757
2758 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
2759 {
2760 if ( cl->component == comp )
2761 count--;
2762 }
2763 }
2764
2765 /* ref count all the files in the component */
2766 if (write)
2767 {
2768 MSIFILE *file;
2769
2770 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2771 {
2772 if (file->Component == comp)
2773 ACTION_WriteSharedDLLsCount( file->TargetPath, count );
2774 }
2775 }
2776
2777 /* add a count for permanent */
2778 if (comp->Attributes & msidbComponentAttributesPermanent)
2779 count ++;
2780
2781 comp->RefCount = count;
2782
2783 if (write)
2784 ACTION_WriteSharedDLLsCount( comp->FullKeypath, comp->RefCount );
2785 }
2786
2787 /*
2788 * Ok further analysis makes me think that this work is
2789 * actually done in the PublishComponents and PublishFeatures
2790 * step, and not here. It appears like the keypath and all that is
2791 * resolved in this step, however actually written in the Publish steps.
2792 * But we will leave it here for now because it is unclear
2793 */
2794 static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
2795 {
2796 WCHAR squished_pc[GUID_SIZE];
2797 WCHAR squished_cc[GUID_SIZE];
2798 UINT rc;
2799 MSICOMPONENT *comp;
2800 HKEY hkey=0,hkey2=0;
2801
2802 TRACE("\n");
2803
2804 /* writes the Component and Features values to the registry */
2805
2806 rc = MSIREG_OpenComponents(&hkey);
2807 if (rc != ERROR_SUCCESS)
2808 return rc;
2809
2810 squash_guid(package->ProductCode,squished_pc);
2811 ui_progress(package,1,COMPONENT_PROGRESS_VALUE,1,0);
2812
2813 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2814 {
2815 MSIRECORD * uirow;
2816
2817 ui_progress(package,2,0,0,0);
2818 if (!comp->ComponentId)
2819 continue;
2820
2821 squash_guid(comp->ComponentId,squished_cc);
2822
2823 msi_free(comp->FullKeypath);
2824 comp->FullKeypath = resolve_keypath( package, comp );
2825
2826 /* do the refcounting */
2827 ACTION_RefCountComponent( package, comp );
2828
2829 TRACE("Component %s (%s), Keypath=%s, RefCount=%i\n",
2830 debugstr_w(comp->Component),
2831 debugstr_w(squished_cc),
2832 debugstr_w(comp->FullKeypath),
2833 comp->RefCount);
2834 /*
2835 * Write the keypath out if the component is to be registered
2836 * and delete the key if the component is to be unregistered
2837 */
2838 if (ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2839 {
2840 rc = RegCreateKeyW(hkey,squished_cc,&hkey2);
2841 if (rc != ERROR_SUCCESS)
2842 continue;
2843
2844 if (!comp->FullKeypath)
2845 continue;
2846
2847 msi_reg_set_val_str( hkey2, squished_pc, comp->FullKeypath );
2848
2849 if (comp->Attributes & msidbComponentAttributesPermanent)
2850 {
2851 static const WCHAR szPermKey[] =
2852 { '0','0','0','0','0','0','0','0','0','0','0','0',
2853 '0','0','0','0','0','0','0','0','0','0','0','0',
2854 '0','0','0','0','0','0','0','0',0 };
2855
2856 msi_reg_set_val_str( hkey2, szPermKey, comp->FullKeypath );
2857 }
2858
2859 RegCloseKey(hkey2);
2860
2861 rc = MSIREG_OpenUserDataComponentKey(comp->ComponentId, &hkey2, TRUE);
2862 if (rc != ERROR_SUCCESS)
2863 continue;
2864
2865 msi_reg_set_val_str(hkey2, squished_pc, comp->FullKeypath);
2866 RegCloseKey(hkey2);
2867 }
2868 else if (ACTION_VerifyComponentForAction( comp, INSTALLSTATE_ABSENT))
2869 {
2870 DWORD res;
2871
2872 rc = RegOpenKeyW(hkey,squished_cc,&hkey2);
2873 if (rc != ERROR_SUCCESS)
2874 continue;
2875
2876 RegDeleteValueW(hkey2,squished_pc);
2877
2878 /* if the key is empty delete it */
2879 res = RegEnumKeyExW(hkey2,0,NULL,0,0,NULL,0,NULL);
2880 RegCloseKey(hkey2);
2881 if (res == ERROR_NO_MORE_ITEMS)
2882 RegDeleteKeyW(hkey,squished_cc);
2883
2884 MSIREG_DeleteUserDataComponentKey(comp->ComponentId);
2885 }
2886
2887 /* UI stuff */
2888 uirow = MSI_CreateRecord(3);
2889 MSI_RecordSetStringW(uirow,1,package->ProductCode);
2890 MSI_RecordSetStringW(uirow,2,comp->ComponentId);
2891 MSI_RecordSetStringW(uirow,3,comp->FullKeypath);
2892 ui_actiondata(package,szProcessComponents,uirow);
2893 msiobj_release( &uirow->hdr );
2894 }
2895 RegCloseKey(hkey);
2896 return rc;
2897 }
2898
2899 typedef struct {
2900 CLSID clsid;
2901 LPWSTR source;
2902
2903 LPWSTR path;
2904 ITypeLib *ptLib;
2905 } typelib_struct;
2906
2907 static BOOL CALLBACK Typelib_EnumResNameProc( HMODULE hModule, LPCWSTR lpszType,
2908 LPWSTR lpszName, LONG_PTR lParam)
2909 {
2910 TLIBATTR *attr;
2911 typelib_struct *tl_struct = (typelib_struct*) lParam;
2912 static const WCHAR fmt[] = {'%','s','\\','%','i',0};
2913 int sz;
2914 HRESULT res;
2915
2916 if (!IS_INTRESOURCE(lpszName))
2917 {
2918 ERR("Not Int Resource Name %s\n",debugstr_w(lpszName));
2919 return TRUE;
2920 }
2921
2922 sz = strlenW(tl_struct->source)+4;
2923 sz *= sizeof(WCHAR);
2924
2925 if ((INT_PTR)lpszName == 1)
2926 tl_struct->path = strdupW(tl_struct->source);
2927 else
2928 {
2929 tl_struct->path = msi_alloc(sz);
2930 sprintfW(tl_struct->path,fmt,tl_struct->source, lpszName);
2931 }
2932
2933 TRACE("trying %s\n", debugstr_w(tl_struct->path));
2934 res = LoadTypeLib(tl_struct->path,&tl_struct->ptLib);
2935 if (!SUCCEEDED(res))
2936 {
2937 msi_free(tl_struct->path);
2938 tl_struct->path = NULL;
2939
2940 return TRUE;
2941 }
2942
2943 ITypeLib_GetLibAttr(tl_struct->ptLib, &attr);
2944 if (IsEqualGUID(&(tl_struct->clsid),&(attr->guid)))
2945 {
2946 ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
2947 return FALSE;
2948 }
2949
2950 msi_free(tl_struct->path);
2951 tl_struct->path = NULL;
2952
2953 ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
2954 ITypeLib_Release(tl_struct->ptLib);
2955
2956 return TRUE;
2957 }
2958
2959 static UINT ITERATE_RegisterTypeLibraries(MSIRECORD *row, LPVOID param)
2960 {
2961 MSIPACKAGE* package = (MSIPACKAGE*)param;
2962 LPCWSTR component;
2963 MSICOMPONENT *comp;
2964 MSIFILE *file;
2965 typelib_struct tl_struct;
2966 HMODULE module;
2967 static const WCHAR szTYPELIB[] = {'T','Y','P','E','L','I','B',0};
2968
2969 component = MSI_RecordGetString(row,3);
2970 comp = get_loaded_component(package,component);
2971 if (!comp)
2972 return ERROR_SUCCESS;
2973
2974 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2975 {
2976 TRACE("Skipping typelib reg due to disabled component\n");
2977
2978 comp->Action = comp->Installed;
2979
2980 return ERROR_SUCCESS;
2981 }
2982
2983 comp->Action = INSTALLSTATE_LOCAL;
2984
2985 file = get_loaded_file( package, comp->KeyPath );
2986 if (!file)
2987 return ERROR_SUCCESS;
2988
2989 module = LoadLibraryExW( file->TargetPath, NULL, LOAD_LIBRARY_AS_DATAFILE );
2990 if (module)
2991 {
2992 LPCWSTR guid;
2993 guid = MSI_RecordGetString(row,1);
2994 CLSIDFromString((LPWSTR)guid, &tl_struct.clsid);
2995 tl_struct.source = strdupW( file->TargetPath );
2996 tl_struct.path = NULL;
2997
2998 EnumResourceNamesW(module, szTYPELIB, Typelib_EnumResNameProc,
2999 (LONG_PTR)&tl_struct);
3000
3001 if (tl_struct.path)
3002 {
3003 LPWSTR help = NULL;
3004 LPCWSTR helpid;
3005 HRESULT res;
3006
3007 helpid = MSI_RecordGetString(row,6);
3008
3009 if (helpid)
3010 help = resolve_folder(package,helpid,FALSE,FALSE,TRUE,NULL);
3011 res = RegisterTypeLib(tl_struct.ptLib,tl_struct.path,help);
3012 msi_free(help);
3013
3014 if (!SUCCEEDED(res))
3015 ERR("Failed to register type library %s\n",
3016 debugstr_w(tl_struct.path));
3017 else
3018 {
3019 ui_actiondata(package,szRegisterTypeLibraries,row);
3020
3021 TRACE("Registered %s\n", debugstr_w(tl_struct.path));
3022 }
3023
3024 ITypeLib_Release(tl_struct.ptLib);
3025 msi_free(tl_struct.path);
3026 }
3027 else
3028 ERR("Failed to load type library %s\n",
3029 debugstr_w(tl_struct.source));
3030
3031 FreeLibrary(module);
3032 msi_free(tl_struct.source);
3033 }
3034 else
3035 ERR("Could not load file! %s\n", debugstr_w(file->TargetPath));
3036
3037 return ERROR_SUCCESS;
3038 }
3039
3040 static UINT ACTION_RegisterTypeLibraries(MSIPACKAGE *package)
3041 {
3042 /*
3043 * OK this is a bit confusing.. I am given a _Component key and I believe
3044 * that the file that is being registered as a type library is the "key file
3045 * of that component" which I interpret to mean "The file in the KeyPath of
3046 * that component".
3047 */
3048 UINT rc;
3049 MSIQUERY * view;
3050 static const WCHAR Query[] =
3051 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3052 '`','T','y','p','e','L','i','b','`',0};
3053
3054 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3055 if (rc != ERROR_SUCCESS)
3056 return ERROR_SUCCESS;
3057
3058 rc = MSI_IterateRecords(view, NULL, ITERATE_RegisterTypeLibraries, package);
3059 msiobj_release(&view->hdr);
3060 return rc;
3061 }
3062
3063 static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
3064 {
3065 MSIPACKAGE *package = (MSIPACKAGE*)param;
3066 LPWSTR target_file, target_folder, filename;
3067 LPCWSTR buffer, extension;
3068 MSICOMPONENT *comp;
3069 static const WCHAR szlnk[]={'.','l','n','k',0};
3070 IShellLinkW *sl = NULL;
3071 IPersistFile *pf = NULL;
3072 HRESULT res;
3073
3074 buffer = MSI_RecordGetString(row,4);
3075 comp = get_loaded_component(package,buffer);
3076 if (!comp)
3077 return ERROR_SUCCESS;
3078
3079 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL ))
3080 {
3081 TRACE("Skipping shortcut creation due to disabled component\n");
3082
3083 comp->Action = comp->Installed;
3084
3085 return ERROR_SUCCESS;
3086 }
3087
3088 comp->Action = INSTALLSTATE_LOCAL;
3089
3090 ui_actiondata(package,szCreateShortcuts,row);
3091
3092 res = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
3093 &IID_IShellLinkW, (LPVOID *) &sl );
3094
3095 if (FAILED( res ))
3096 {
3097 ERR("CLSID_ShellLink not available\n");
3098 goto err;
3099 }
3100
3101 res = IShellLinkW_QueryInterface( sl, &IID_IPersistFile,(LPVOID*) &pf );
3102 if (FAILED( res ))
3103 {
3104 ERR("QueryInterface(IID_IPersistFile) failed\n");
3105 goto err;
3106 }
3107
3108 buffer = MSI_RecordGetString(row,2);
3109 target_folder = resolve_folder(package, buffer,FALSE,FALSE,TRUE,NULL);
3110
3111 /* may be needed because of a bug somewhere else */
3112 create_full_pathW(target_folder);
3113
3114 filename = msi_dup_record_field( row, 3 );
3115 reduce_to_longfilename(filename);
3116
3117 extension = strchrW(filename,'.');
3118 if (!extension || strcmpiW(extension,szlnk))
3119 {
3120 int len = strlenW(filename);
3121 filename = msi_realloc(filename, len * sizeof(WCHAR) + sizeof(szlnk));
3122 memcpy(filename + len, szlnk, sizeof(szlnk));
3123 }
3124 target_file = build_directory_name(2, target_folder, filename);
3125 msi_free(target_folder);
3126 msi_free(filename);
3127
3128 buffer = MSI_RecordGetString(row,5);
3129 if (strchrW(buffer,'['))
3130 {
3131 LPWSTR deformated;
3132 deformat_string(package,buffer,&deformated);
3133 IShellLinkW_SetPath(sl,deformated);
3134 msi_free(deformated);
3135 }
3136 else
3137 {
3138 FIXME("poorly handled shortcut format, advertised shortcut\n");
3139 IShellLinkW_SetPath(sl,comp->FullKeypath);
3140 }
3141
3142 if (!MSI_RecordIsNull(row,6))
3143 {
3144 LPWSTR deformated;
3145 buffer = MSI_RecordGetString(row,6);
3146 deformat_string(package,buffer,&deformated);
3147 IShellLinkW_SetArguments(sl,deformated);
3148 msi_free(deformated);
3149 }
3150
3151 if (!MSI_RecordIsNull(row,7))
3152 {
3153 buffer = MSI_RecordGetString(row,7);
3154 IShellLinkW_SetDescription(sl,buffer);
3155 }
3156
3157 if (!MSI_RecordIsNull(row,8))
3158 IShellLinkW_SetHotkey(sl,MSI_RecordGetInteger(row,8));
3159
3160 if (!MSI_RecordIsNull(row,9))
3161 {
3162 LPWSTR Path;
3163 INT index;
3164
3165 buffer = MSI_RecordGetString(row,9);
3166
3167 Path = build_icon_path(package,buffer);
3168 index = MSI_RecordGetInteger(row,10);
3169
3170 /* no value means 0 */
3171 if (index == MSI_NULL_INTEGER)
3172 index = 0;
3173
3174 IShellLinkW_SetIconLocation(sl,Path,index);
3175 msi_free(Path);
3176 }
3177
3178 if (!MSI_RecordIsNull(row,11))
3179 IShellLinkW_SetShowCmd(sl,MSI_RecordGetInteger(row,11));
3180
3181 if (!MSI_RecordIsNull(row,12))
3182 {
3183 LPWSTR Path;
3184 buffer = MSI_RecordGetString(row,12);
3185 Path = resolve_folder(package, buffer, FALSE, FALSE, TRUE, NULL);
3186 if (Path)
3187 IShellLinkW_SetWorkingDirectory(sl,Path);
3188 msi_free(Path);
3189 }
3190
3191 TRACE("Writing shortcut to %s\n",debugstr_w(target_file));
3192 IPersistFile_Save(pf,target_file,FALSE);
3193
3194 msi_free(target_file);
3195
3196 err:
3197 if (pf)
3198 IPersistFile_Release( pf );
3199 if (sl)
3200 IShellLinkW_Release( sl );
3201
3202 return ERROR_SUCCESS;
3203 }
3204
3205 static UINT ACTION_CreateShortcuts(MSIPACKAGE *package)
3206 {
3207 UINT rc;
3208 HRESULT res;
3209 MSIQUERY * view;
3210 static const WCHAR Query[] =
3211 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3212 '`','S','h','o','r','t','c','u','t','`',0};
3213
3214 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3215 if (rc != ERROR_SUCCESS)
3216 return ERROR_SUCCESS;
3217
3218 res = CoInitialize( NULL );
3219 if (FAILED (res))
3220 {
3221 ERR("CoInitialize failed\n");
3222 return ERROR_FUNCTION_FAILED;
3223 }
3224
3225 rc = MSI_IterateRecords(view, NULL, ITERATE_CreateShortcuts, package);
3226 msiobj_release(&view->hdr);
3227
3228 CoUninitialize();
3229
3230 return rc;
3231 }
3232
3233 static UINT ITERATE_PublishProduct(MSIRECORD *row, LPVOID param)
3234 {
3235 MSIPACKAGE* package = (MSIPACKAGE*)param;
3236 HANDLE the_file;
3237 LPWSTR FilePath;
3238 LPCWSTR FileName;
3239 CHAR buffer[1024];
3240 DWORD sz;
3241 UINT rc;
3242 MSIRECORD *uirow;
3243
3244 FileName = MSI_RecordGetString(row,1);
3245 if (!FileName)
3246 {
3247 ERR("Unable to get FileName\n");
3248 return ERROR_SUCCESS;
3249 }
3250
3251 FilePath = build_icon_path(package,FileName);
3252
3253 TRACE("Creating icon file at %s\n",debugstr_w(FilePath));
3254
3255 the_file = CreateFileW(FilePath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
3256 FILE_ATTRIBUTE_NORMAL, NULL);
3257
3258 if (the_file == INVALID_HANDLE_VALUE)
3259 {
3260 ERR("Unable to create file %s\n",debugstr_w(FilePath));
3261 msi_free(FilePath);
3262 return ERROR_SUCCESS;
3263 }
3264
3265 do
3266 {
3267 DWORD write;
3268 sz = 1024;
3269 rc = MSI_RecordReadStream(row,2,buffer,&sz);
3270 if (rc != ERROR_SUCCESS)
3271 {
3272 ERR("Failed to get stream\n");
3273 CloseHandle(the_file);
3274 DeleteFileW(FilePath);
3275 break;
3276 }
3277 WriteFile(the_file,buffer,sz,&write,NULL);
3278 } while (sz == 1024);
3279
3280 msi_free(FilePath);
3281
3282 CloseHandle(the_file);
3283
3284 uirow = MSI_CreateRecord(1);
3285 MSI_RecordSetStringW(uirow,1,FileName);
3286 ui_actiondata(package,szPublishProduct,uirow);
3287 msiobj_release( &uirow->hdr );
3288
3289 return ERROR_SUCCESS;
3290 }
3291
3292 static BOOL msi_check_publish(MSIPACKAGE *package)
3293 {
3294 MSIFEATURE *feature;
3295
3296 LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
3297 {
3298 if (feature->ActionRequest == INSTALLSTATE_LOCAL)
3299 return TRUE;
3300 }
3301
3302 return FALSE;
3303 }
3304
3305 /*
3306 * 99% of the work done here is only done for
3307 * advertised installs. However this is where the
3308 * Icon table is processed and written out
3309 * so that is what I am going to do here.
3310 */
3311 static UINT ACTION_PublishProduct(MSIPACKAGE *package)
3312 {
3313 UINT rc;
3314 LPWSTR packname;
3315 MSIQUERY * view;
3316 MSISOURCELISTINFO *info;
3317 MSIMEDIADISK *disk;
3318 static const WCHAR Query[]=
3319 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3320 '`','I','c','o','n','`',0};
3321 /* for registry stuff */
3322 HKEY hkey=0;
3323 HKEY hukey=0;
3324 HKEY hudkey=0, props=0;
3325 HKEY source;
3326 static const WCHAR szProductLanguage[] =
3327 {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
3328 static const WCHAR szARPProductIcon[] =
3329 {'A','R','P','P','R','O','D','U','C','T','I','C','O','N',0};
3330 static const WCHAR szProductVersion[] =
3331 {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
3332 static const WCHAR szSourceList[] =
3333 {'S','o','u','r','c','e','L','i','s','t',0};
3334 static const WCHAR szEmpty[] = {0};
3335 DWORD langid;
3336 LPWSTR buffer;
3337 DWORD size;
3338 MSIHANDLE hDb, hSumInfo;
3339
3340 /* FIXME: also need to publish if the product is in advertise mode */
3341 if (!msi_check_publish(package))
3342 return ERROR_SUCCESS;
3343
3344 /* write out icon files */
3345
3346 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3347 if (rc == ERROR_SUCCESS)
3348 {
3349 MSI_IterateRecords(view, NULL, ITERATE_PublishProduct, package);
3350 msiobj_release(&view->hdr);
3351 }
3352
3353 /* ok there is a lot more done here but i need to figure out what */
3354
3355 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3356 {
3357 rc = MSIREG_OpenLocalClassesProductKey(package->ProductCode, &hukey, TRUE);
3358 if (rc != ERROR_SUCCESS)
3359 goto end;
3360
3361 rc = MSIREG_OpenLocalSystemInstallProps(package->ProductCode, &props, TRUE);
3362 if (rc != ERROR_SUCCESS)
3363 goto end;
3364 }
3365 else
3366 {
3367 rc = MSIREG_OpenProductsKey(package->ProductCode,&hkey,TRUE);
3368 if (rc != ERROR_SUCCESS)
3369 goto end;
3370
3371 rc = MSIREG_OpenUserProductsKey(package->ProductCode,&hukey,TRUE);
3372 if (rc != ERROR_SUCCESS)
3373 goto end;
3374
3375 rc = MSIREG_OpenCurrentUserInstallProps(package->ProductCode, &props, TRUE);
3376 if (rc != ERROR_SUCCESS)
3377 goto end;
3378 }
3379
3380 rc = RegCreateKeyW(hukey, szSourceList, &source);
3381 if (rc != ERROR_SUCCESS)
3382 goto end;
3383
3384 RegCloseKey(source);
3385
3386 rc = MSIREG_OpenUserDataProductKey(package->ProductCode,&hudkey,TRUE);
3387 if (rc != ERROR_SUCCESS)
3388 goto end;
3389
3390 buffer = msi_dup_property( package, INSTALLPROPERTY_PRODUCTNAMEW );
3391 msi_reg_set_val_str( hukey, INSTALLPROPERTY_PRODUCTNAMEW, buffer );
3392 msi_free(buffer);
3393
3394 langid = msi_get_property_int( package, szProductLanguage, 0 );
3395 msi_reg_set_val_dword( hukey, INSTALLPROPERTY_LANGUAGEW, langid );
3396
3397 packname = strrchrW( package->PackagePath, '\\' ) + 1;
3398 msi_reg_set_val_str( hukey, INSTALLPROPERTY_PACKAGENAMEW, packname );
3399
3400 /* FIXME */
3401 msi_reg_set_val_dword( hukey, INSTALLPROPERTY_AUTHORIZED_LUA_APPW, 0 );
3402 msi_reg_set_val_dword( props, INSTALLPROPERTY_INSTANCETYPEW, 0 );
3403
3404 buffer = msi_dup_property( package, szARPProductIcon );
3405 if (buffer)
3406 {
3407 LPWSTR path = build_icon_path(package,buffer);
3408 msi_reg_set_val_str( hukey, INSTALLPROPERTY_PRODUCTICONW, path );
3409 msi_free( path );
3410 }
3411 msi_free(buffer);
3412
3413 buffer = msi_dup_property( package, szProductVersion );
3414 if (buffer)
3415 {
3416 DWORD verdword = msi_version_str_to_dword(buffer);
3417 msi_reg_set_val_dword( hukey, INSTALLPROPERTY_VERSIONW, verdword );
3418 }
3419 msi_free(buffer);
3420
3421 buffer = strrchrW( package->PackagePath, '\\') + 1;
3422 rc = MsiSourceListSetInfoW( package->ProductCode, NULL,
3423 package->Context, MSICODE_PRODUCT,
3424 INSTALLPROPERTY_PACKAGENAMEW, buffer );
3425 if (rc != ERROR_SUCCESS)
3426 goto end;
3427
3428 rc = MsiSourceListSetInfoW( package->ProductCode, NULL,
3429 package->Context, MSICODE_PRODUCT,
3430 INSTALLPROPERTY_MEDIAPACKAGEPATHW, szEmpty );
3431 if (rc != ERROR_SUCCESS)
3432 goto end;
3433
3434 rc = MsiSourceListSetInfoW( package->ProductCode, NULL,
3435 package->Context, MSICODE_PRODUCT,
3436 INSTALLPROPERTY_DISKPROMPTW, szEmpty );
3437 if (rc != ERROR_SUCCESS)
3438 goto end;
3439
3440 /* FIXME: Need to write more keys to the user registry */
3441
3442 hDb= alloc_msihandle( &package->db->hdr );
3443 if (!hDb) {
3444 rc = ERROR_NOT_ENOUGH_MEMORY;
3445 goto end;
3446 }
3447 rc = MsiGetSummaryInformationW(hDb, NULL, 0, &hSumInfo);
3448 MsiCloseHandle(hDb);
3449 if (rc == ERROR_SUCCESS)
3450 {
3451 WCHAR guidbuffer[0x200];
3452 size = 0x200;
3453 rc = MsiSummaryInfoGetPropertyW(hSumInfo, 9, NULL, NULL, NULL,
3454 guidbuffer, &size);
3455 if (rc == ERROR_SUCCESS)
3456 {
3457 /* for now we only care about the first guid */
3458 LPWSTR ptr = strchrW(guidbuffer,';');
3459 if (ptr) *ptr = 0;
3460 msi_reg_set_val_str( hukey, INSTALLPROPERTY_PACKAGECODEW, guidbuffer );
3461 }
3462 else
3463 {
3464 ERR("Unable to query Revision_Number...\n");
3465 rc = ERROR_SUCCESS;
3466 }
3467 MsiCloseHandle(hSumInfo);
3468 }
3469 else
3470 {
3471 ERR("Unable to open Summary Information\n");
3472 rc = ERROR_SUCCESS;
3473 }
3474
3475 /* publish the SourceList info */
3476 LIST_FOR_EACH_ENTRY(info, &package->sourcelist_info, MSISOURCELISTINFO, entry)
3477 {
3478 if (!lstrcmpW(info->property, INSTALLPROPERTY_LASTUSEDSOURCEW))
3479 msi_set_last_used_source(package->ProductCode, NULL, info->context,
3480 info->options, info->value);
3481 else
3482 MsiSourceListSetInfoW(package->ProductCode, NULL,
3483 info->context, info->options,
3484 info->property, info->value);
3485 }
3486
3487 LIST_FOR_EACH_ENTRY(disk, &package->sourcelist_media, MSIMEDIADISK, entry)
3488 {
3489 MsiSourceListAddMediaDiskW(package->ProductCode, NULL,
3490 disk->context, disk->options,
3491 disk->disk_id, disk->volume_label, disk->disk_prompt);
3492 }
3493
3494 end:
3495 RegCloseKey(hkey);
3496 RegCloseKey(hukey);
3497 RegCloseKey(hudkey);
3498 RegCloseKey(props);
3499
3500 return rc;
3501 }
3502
3503 static UINT ITERATE_WriteIniValues(MSIRECORD *row, LPVOID param)
3504 {
3505 MSIPACKAGE *package = (MSIPACKAGE*)param;
3506 LPCWSTR component,section,key,value,identifier,filename,dirproperty;
3507 LPWSTR deformated_section, deformated_key, deformated_value;
3508 LPWSTR folder, fullname = NULL;
3509 MSIRECORD * uirow;
3510 INT action;
3511 MSICOMPONENT *comp;
3512 static const WCHAR szWindowsFolder[] =
3513 {'W','i','n','d','o','w','s','F','o','l','d','e','r',0};
3514
3515 component = MSI_RecordGetString(row, 8);
3516 comp = get_loaded_component(package,component);
3517
3518 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
3519 {
3520 TRACE("Skipping ini file due to disabled component %s\n",
3521 debugstr_w(component));
3522
3523 comp->Action = comp->Installed;
3524
3525 return ERROR_SUCCESS;
3526 }
3527
3528 comp->Action = INSTALLSTATE_LOCAL;
3529
3530 identifier = MSI_RecordGetString(row,1);
3531 filename = MSI_RecordGetString(row,2);
3532 dirproperty = MSI_RecordGetString(row,3);
3533 section = MSI_RecordGetString(row,4);
3534 key = MSI_RecordGetString(row,5);
3535 value = MSI_RecordGetString(row,6);
3536 action = MSI_RecordGetInteger(row,7);
3537
3538 deformat_string(package,section,&deformated_section);
3539 deformat_string(package,key,&deformated_key);
3540 deformat_string(package,value,&deformated_value);
3541
3542 if (dirproperty)
3543 {
3544 folder = resolve_folder(package, dirproperty, FALSE, FALSE, TRUE, NULL);
3545 if (!folder)
3546 folder = msi_dup_property( package, dirproperty );
3547 }
3548 else
3549 folder = msi_dup_property( package, szWindowsFolder );
3550
3551 if (!folder)
3552 {
3553 ERR("Unable to resolve folder! (%s)\n",debugstr_w(dirproperty));
3554 goto cleanup;
3555 }
3556
3557 fullname = build_directory_name(2, folder, filename);
3558
3559 if (action == 0)
3560 {
3561 TRACE("Adding value %s to section %s in %s\n",
3562 debugstr_w(deformated_key), debugstr_w(deformated_section),
3563 debugstr_w(fullname));
3564 WritePrivateProfileStringW(deformated_section, deformated_key,
3565 deformated_value, fullname);
3566 }
3567 else if (action == 1)
3568 {
3569 WCHAR returned[10];
3570 GetPrivateProfileStringW(deformated_section, deformated_key, NULL,
3571 returned, 10, fullname);
3572 if (returned[0] == 0)
3573 {
3574 TRACE("Adding value %s to section %s in %s\n",
3575 debugstr_w(deformated_key), debugstr_w(deformated_section),
3576 debugstr_w(fullname));
3577
3578 WritePrivateProfileStringW(deformated_section, deformated_key,
3579 deformated_value, fullname);
3580 }
3581 }
3582 else if (action == 3)
3583 FIXME("Append to existing section not yet implemented\n");
3584
3585 uirow = MSI_CreateRecord(4);
3586 MSI_RecordSetStringW(uirow,1,identifier);
3587 MSI_RecordSetStringW(uirow,2,deformated_section);
3588 MSI_RecordSetStringW(uirow,3,deformated_key);
3589 MSI_RecordSetStringW(uirow,4,deformated_value);
3590 ui_actiondata(package,szWriteIniValues,uirow);
3591 msiobj_release( &uirow->hdr );
3592 cleanup:
3593 msi_free(fullname);
3594 msi_free(folder);
3595 msi_free(deformated_key);
3596 msi_free(deformated_value);
3597 msi_free(deformated_section);
3598 return ERROR_SUCCESS;
3599 }
3600
3601 static UINT ACTION_WriteIniValues(MSIPACKAGE *package)
3602 {
3603 UINT rc;
3604 MSIQUERY * view;
3605 static const WCHAR ExecSeqQuery[] =
3606 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3607 '`','I','n','i','F','i','l','e','`',0};
3608
3609 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3610 if (rc != ERROR_SUCCESS)
3611 {
3612 TRACE("no IniFile table\n");
3613 return ERROR_SUCCESS;
3614 }
3615
3616 rc = MSI_IterateRecords(view, NULL, ITERATE_WriteIniValues, package);
3617 msiobj_release(&view->hdr);
3618 return rc;
3619 }
3620
3621 static UINT ITERATE_SelfRegModules(MSIRECORD *row, LPVOID param)
3622 {
3623 MSIPACKAGE *package = (MSIPACKAGE*)param;
3624 LPCWSTR filename;
3625 LPWSTR FullName;
3626 MSIFILE *file;
3627 DWORD len;
3628 static const WCHAR ExeStr[] =
3629 {'r','e','g','s','v','r','3','2','.','e','x','e',' ','\"',0};
3630 static const WCHAR close[] = {'\"',0};
3631 STARTUPINFOW si;
3632 PROCESS_INFORMATION info;
3633 BOOL brc;
3634 MSIRECORD *uirow;
3635 LPWSTR uipath, p;
3636
3637 memset(&si,0,sizeof(STARTUPINFOW));
3638
3639 filename = MSI_RecordGetString(row,1);
3640 file = get_loaded_file( package, filename );
3641
3642 if (!file)
3643 {
3644 ERR("Unable to find file id %s\n",debugstr_w(filename));
3645 return ERROR_SUCCESS;
3646 }
3647
3648 len = strlenW(ExeStr) + strlenW( file->TargetPath ) + 2;
3649
3650 FullName = msi_alloc(len*sizeof(WCHAR));
3651 strcpyW(FullName,ExeStr);
3652 strcatW( FullName, file->TargetPath );
3653 strcatW(FullName,close);
3654
3655 TRACE("Registering %s\n",debugstr_w(FullName));
3656 brc = CreateProcessW(NULL, FullName, NULL, NULL, FALSE, 0, NULL, c_colon,
3657 &si, &info);
3658
3659 if (brc)
3660 msi_dialog_check_messages(info.hProcess);
3661
3662 msi_free(FullName);
3663
3664 /* the UI chunk */
3665 uirow = MSI_CreateRecord( 2 );
3666 uipath = strdupW( file->TargetPath );
3667 p = strrchrW(uipath,'\\');
3668 if (p)
3669 p[0]=0;
3670 MSI_RecordSetStringW( uirow, 1, &p[1] );
3671 MSI_RecordSetStringW( uirow, 2, uipath);
3672 ui_actiondata( package, szSelfRegModules, uirow);
3673 msiobj_release( &uirow->hdr );
3674 msi_free( uipath );
3675 /* FIXME: call ui_progress? */
3676
3677 return ERROR_SUCCESS;
3678 }
3679
3680 static UINT ACTION_SelfRegModules(MSIPACKAGE *package)
3681 {
3682 UINT rc;
3683 MSIQUERY * view;
3684 static const WCHAR ExecSeqQuery[] =
3685 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3686 '`','S','e','l','f','R','e','g','`',0};
3687
3688 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3689 if (rc != ERROR_SUCCESS)
3690 {
3691 TRACE("no SelfReg table\n");
3692 return ERROR_SUCCESS;
3693 }
3694
3695 MSI_IterateRecords(view, NULL, ITERATE_SelfRegModules, package);
3696 msiobj_release(&view->hdr);
3697
3698 return ERROR_SUCCESS;
3699 }
3700
3701 static UINT ACTION_PublishFeatures(MSIPACKAGE *package)
3702 {
3703 MSIFEATURE *feature;
3704 UINT rc;
3705 HKEY hkey=0;
3706 HKEY hukey=0;
3707 HKEY userdata=0;
3708
3709 if (!msi_check_publish(package))
3710 return ERROR_SUCCESS;
3711
3712 rc = MSIREG_OpenFeaturesKey(package->ProductCode,&hkey,TRUE);
3713 if (rc != ERROR_SUCCESS)
3714 goto end;
3715
3716 rc = MSIREG_OpenUserFeaturesKey(package->ProductCode,&hukey,TRUE);
3717 if (rc != ERROR_SUCCESS)
3718 goto end;
3719
3720 rc = MSIREG_OpenUserDataFeaturesKey(package->ProductCode, &userdata, TRUE);
3721 if (rc != ERROR_SUCCESS)
3722 goto end;
3723
3724 /* here the guids are base 85 encoded */
3725 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
3726 {
3727 ComponentList *cl;
3728 LPWSTR data = NULL;
3729 GUID clsid;
3730 INT size;
3731 BOOL absent = FALSE;
3732 MSIRECORD *uirow;
3733
3734 if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_LOCAL ) &&
3735 !ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_SOURCE ) &&
3736 !ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_ADVERTISED ))
3737 absent = TRUE;
3738
3739 size = 1;
3740 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3741 {
3742 size += 21;
3743 }
3744 if (feature->Feature_Parent)
3745 size += strlenW( feature->Feature_Parent )+2;
3746
3747 data = msi_alloc(size * sizeof(WCHAR));
3748
3749 data[0] = 0;
3750 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3751 {
3752 MSICOMPONENT* component = cl->component;
3753 WCHAR buf[21];
3754
3755 buf[0] = 0;
3756 if (component->ComponentId)
3757 {
3758 TRACE("From %s\n",debugstr_w(component->ComponentId));
3759 CLSIDFromString(component->ComponentId, &clsid);
3760 encode_base85_guid(&clsid,buf);
3761 TRACE("to %s\n",debugstr_w(buf));
3762 strcatW(data,buf);
3763 }
3764 }
3765
3766 if (feature->Feature_Parent)
3767 {
3768 static const WCHAR sep[] = {'\2',0};
3769 strcatW(data,sep);
3770 strcatW(data,feature->Feature_Parent);
3771 }
3772
3773 msi_reg_set_val_str( hkey, feature->Feature, data );
3774 msi_reg_set_val_str( userdata, feature->Feature, data );
3775 msi_free(data);
3776
3777 size = 0;
3778 if (feature->Feature_Parent)
3779 size = strlenW(feature->Feature_Parent)*sizeof(WCHAR);
3780 if (!absent)
3781 {
3782 static const WCHAR emptyW[] = {0};
3783 size += sizeof(WCHAR);
3784 RegSetValueExW(hukey,feature->Feature,0,REG_SZ,
3785 (LPBYTE)(feature->Feature_Parent ? feature->Feature_Parent : emptyW),size);
3786 }
3787 else
3788 {
3789 size += 2*sizeof(WCHAR);
3790 data = msi_alloc(size);
3791 data[0] = 0x6;
3792 data[1] = 0;
3793 if (feature->Feature_Parent)
3794 strcpyW( &data[1], feature->Feature_Parent );
3795 RegSetValueExW(hukey,feature->Feature,0,REG_SZ,
3796 (LPBYTE)data,size);
3797 msi_free(data);
3798 }
3799
3800 /* the UI chunk */
3801 uirow = MSI_CreateRecord( 1 );
3802 MSI_RecordSetStringW( uirow, 1, feature->Feature );
3803 ui_actiondata( package, szPublishFeatures, uirow);
3804 msiobj_release( &uirow->hdr );
3805 /* FIXME: call ui_progress? */
3806 }
3807
3808 end:
3809 RegCloseKey(hkey);
3810 RegCloseKey(hukey);
3811 return rc;
3812 }
3813
3814 static UINT msi_unpublish_feature(MSIPACKAGE *package, MSIFEATURE *feature)
3815 {
3816 UINT r;
3817 HKEY hkey;
3818
3819 TRACE("unpublishing feature %s\n", debugstr_w(feature->Feature));
3820
3821 r = MSIREG_OpenUserFeaturesKey(package->ProductCode, &hkey, FALSE);
3822 if (r == ERROR_SUCCESS)
3823 {
3824 RegDeleteValueW(hkey, feature->Feature);
3825 RegCloseKey(hkey);
3826 }
3827
3828 r = MSIREG_OpenUserDataFeaturesKey(package->ProductCode, &hkey, FALSE);
3829 if (r == ERROR_SUCCESS)
3830 {
3831 RegDeleteValueW(hkey, feature->Feature);
3832 RegCloseKey(hkey);
3833 }
3834
3835 return ERROR_SUCCESS;
3836 }
3837
3838 static BOOL msi_check_unpublish(MSIPACKAGE *package)
3839 {
3840 MSIFEATURE *feature;
3841
3842 LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
3843 {
3844 if (feature->ActionRequest != INSTALLSTATE_ABSENT)
3845 return FALSE;
3846 }
3847
3848 return TRUE;
3849 }
3850
3851 static UINT ACTION_UnpublishFeatures(MSIPACKAGE *package)
3852 {
3853 MSIFEATURE *feature;
3854
3855 if (!msi_check_unpublish(package))
3856 return ERROR_SUCCESS;
3857
3858 LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
3859 {
3860 msi_unpublish_feature(package, feature);
3861 }
3862
3863 return ERROR_SUCCESS;
3864 }
3865
3866 static UINT msi_get_local_package_name( LPWSTR path )
3867 {
3868 static const WCHAR szInstaller[] = {
3869 '\\','I','n','s','t','a','l','l','e','r','\\',0};
3870 static const WCHAR fmt[] = { '%','x','.','m','s','i',0};
3871 DWORD time, len, i;
3872 HANDLE handle;
3873
3874 time = GetTickCount();
3875 GetWindowsDirectoryW( path, MAX_PATH );
3876 lstrcatW( path, szInstaller );
3877 CreateDirectoryW( path, NULL );
3878
3879 len = lstrlenW(path);
3880 for (i=0; i<0x10000; i++)
3881 {
3882 snprintfW( &path[len], MAX_PATH - len, fmt, (time+i)&0xffff );
3883 handle = CreateFileW( path, GENERIC_WRITE, 0, NULL,
3884 CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
3885 if (handle != INVALID_HANDLE_VALUE)
3886 {
3887 CloseHandle(handle);
3888 break;
3889 }
3890 if (GetLastError() != ERROR_FILE_EXISTS &&
3891 GetLastError() != ERROR_SHARING_VIOLATION)
3892 return ERROR_FUNCTION_FAILED;
3893 }
3894
3895 return ERROR_SUCCESS;
3896 }
3897
3898 static UINT msi_make_package_local( MSIPACKAGE *package, HKEY hkey )
3899 {
3900 WCHAR packagefile[MAX_PATH];
3901 HKEY props;
3902 UINT r;
3903
3904 r = msi_get_local_package_name( packagefile );
3905 if (r != ERROR_SUCCESS)
3906 return r;
3907
3908 TRACE("Copying to local package %s\n",debugstr_w(packagefile));
3909
3910 r = CopyFileW( package->db->path, packagefile, FALSE);
3911
3912 if (!r)
3913 {
3914 ERR("Unable to copy package (%s -> %s) (error %d)\n",
3915 debugstr_w(package->db->path), debugstr_w(packagefile), GetLastError());
3916 return ERROR_FUNCTION_FAILED;
3917 }
3918
3919 msi_reg_set_val_str( hkey, INSTALLPROPERTY_LOCALPACKAGEW, packagefile );
3920
3921 r = MSIREG_OpenCurrentUserInstallProps(package->ProductCode, &props, TRUE);
3922 if (r != ERROR_SUCCESS)
3923 return r;
3924
3925 msi_reg_set_val_str(props, INSTALLPROPERTY_LOCALPACKAGEW, packagefile);
3926 RegCloseKey(props);
3927 return ERROR_SUCCESS;
3928 }
3929
3930 static UINT msi_write_uninstall_property_vals( MSIPACKAGE *package, HKEY hkey )
3931 {
3932 LPWSTR prop, val, key;
3933 static const LPCSTR propval[] = {
3934 "ARPAUTHORIZEDCDFPREFIX", "AuthorizedCDFPrefix",
3935 "ARPCONTACT", "Contact",
3936 "ARPCOMMENTS", "Comments",
3937 "ProductName", "DisplayName",
3938 "ProductVersion", "DisplayVersion",
3939 "ARPHELPLINK", "HelpLink",
3940 "ARPHELPTELEPHONE", "HelpTelephone",
3941 "ARPINSTALLLOCATION", "InstallLocation",
3942 "SourceDir", "InstallSource",
3943 "Manufacturer", "Publisher",
3944 "ARPREADME", "Readme",
3945 "ARPSIZE", "Size",
3946 "ARPURLINFOABOUT", "URLInfoAbout",
3947 "ARPURLUPDATEINFO", "URLUpdateInfo",
3948 NULL,
3949 };
3950 const LPCSTR *p = propval;
3951
3952 while( *p )
3953 {
3954 prop = strdupAtoW( *p++ );
3955 key = strdupAtoW( *p++ );
3956 val = msi_dup_property( package, prop );
3957 msi_reg_set_val_str( hkey, key, val );
3958 msi_free(val);
3959 msi_free(key);
3960 msi_free(prop);
3961 }
3962 return ERROR_SUCCESS;
3963 }
3964
3965 static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
3966 {
3967 HKEY hkey=0;
3968 HKEY hudkey=0, props=0;
3969 LPWSTR buffer = NULL;
3970 UINT rc;
3971 DWORD size, langid;
3972 static const WCHAR szWindowsInstaller[] =
3973 {'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
3974 static const WCHAR szUpgradeCode[] =
3975 {'U','p','g','r','a','d','e','C','o','d','e',0};
3976 static const WCHAR modpath_fmt[] =
3977 {'M','s','i','E','x','e','c','.','e','x','e',' ',
3978 '/','I','[','P','r','o','d','u','c','t','C','o','d','e',']',0};
3979 static const WCHAR szModifyPath[] =
3980 {'M','o','d','i','f','y','P','a','t','h',0};
3981 static const WCHAR szUninstallString[] =
3982 {'U','n','i','n','s','t','a','l','l','S','t','r','i','n','g',0};
3983 static const WCHAR szEstimatedSize[] =
3984 {'E','s','t','i','m','a','t','e','d','S','i','z','e',0};
3985 static const WCHAR szProductLanguage[] =
3986 {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
3987 static const WCHAR szProductVersion[] =
3988 {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
3989 static const WCHAR szProductName[] =
3990 {'P','r','o','d','u','c','t','N','a','m','e',0};
3991 static const WCHAR szDisplayName[] =
3992 {'D','i','s','p','l','a','y','N','a','m','e',0};
3993 static const WCHAR szDisplayVersion[] =
3994 {'D','i','s','p','l','a','y','V','e','r','s','i','o','n',0};
3995 static const WCHAR szManufacturer[] =
3996 {'M','a','n','u','f','a','c','t','u','r','e','r',0};
3997
3998 SYSTEMTIME systime;
3999 static const WCHAR date_fmt[] = {'%','i','%','0','2','i','%','0','2','i',0};
4000 LPWSTR upgrade_code;
4001 WCHAR szDate[9];
4002
4003 /* FIXME: also need to publish if the product is in advertise mode */
4004 if (!msi_check_publish(package))
4005 return ERROR_SUCCESS;
4006
4007 rc = MSIREG_OpenUninstallKey(package->ProductCode,&hkey,TRUE);
4008 if (rc != ERROR_SUCCESS)
4009 return rc;
4010
4011 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
4012 {
4013 rc = MSIREG_OpenLocalSystemInstallProps(package->ProductCode, &props, TRUE);
4014 if (rc != ERROR_SUCCESS)
4015 return rc;
4016 }
4017 else
4018 {
4019 rc = MSIREG_OpenCurrentUserInstallProps(package->ProductCode, &props, TRUE);
4020 if (rc != ERROR_SUCCESS)
4021 return rc;
4022 }
4023
4024 /* dump all the info i can grab */
4025 /* FIXME: Flesh out more information */
4026
4027 msi_write_uninstall_property_vals( package, hkey );
4028
4029 msi_reg_set_val_dword( hkey, szWindowsInstaller, 1 );
4030
4031 msi_make_package_local( package, hkey );
4032
4033 /* do ModifyPath and UninstallString */
4034 size = deformat_string(package,modpath_fmt,&buffer);
4035 RegSetValueExW(hkey,szModifyPath,0,REG_EXPAND_SZ,(LPBYTE)buffer,size);
4036 RegSetValueExW(hkey,szUninstallString,0,REG_EXPAND_SZ,(LPBYTE)buffer,size);
4037 msi_free(buffer);
4038
4039 /* FIXME: Write real Estimated Size when we have it */
4040 msi_reg_set_val_dword( hkey, szEstimatedSize, 0 );
4041
4042 buffer = msi_dup_property( package, szProductName );
4043 msi_reg_set_val_str( props, szDisplayName, buffer );
4044 msi_free(buffer);
4045
4046 buffer = msi_dup_property( package, cszSourceDir );
4047 msi_reg_set_val_str( props, INSTALLPROPERTY_INSTALLSOURCEW, buffer);
4048 msi_free(buffer);
4049
4050 buffer = msi_dup_property( package, szManufacturer );
4051 msi_reg_set_val_str( props, INSTALLPROPERTY_PUBLISHERW, buffer);
4052 msi_free(buffer);
4053
4054 GetLocalTime(&systime);
4055 sprintfW(szDate,date_fmt,systime.wYear,systime.wMonth,systime.wDay);
4056 msi_reg_set_val_str( hkey, INSTALLPROPERTY_INSTALLDATEW, szDate );
4057 msi_reg_set_val_str( props, INSTALLPROPERTY_INSTALLDATEW, szDate );
4058
4059 langid = msi_get_property_int( package, szProductLanguage, 0 );
4060 msi_reg_set_val_dword( hkey, INSTALLPROPERTY_LANGUAGEW, langid );
4061
4062 buffer = msi_dup_property( package, szProductVersion );
4063 msi_reg_set_val_str( props, szDisplayVersion, buffer );
4064 if (buffer)
4065 {
4066 DWORD verdword = msi_version_str_to_dword(buffer);
4067
4068 msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONW, verdword );
4069 msi_reg_set_val_dword( props, INSTALLPROPERTY_VERSIONW, verdword );
4070 msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONMAJORW, verdword>>24 );
4071 msi_reg_set_val_dword( props, INSTALLPROPERTY_VERSIONMAJORW, verdword>>24 );
4072 msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONMINORW, (verdword>>16)&0x00FF );
4073 msi_reg_set_val_dword( props, INSTALLPROPERTY_VERSIONMINORW, (verdword>>16)&0x00FF );
4074 }
4075 msi_free(buffer);
4076
4077 /* Handle Upgrade Codes */
4078 upgrade_code = msi_dup_property( package, szUpgradeCode );
4079 if (upgrade_code)
4080 {
4081 HKEY hkey2;
4082 WCHAR squashed[33];
4083 MSIREG_OpenUpgradeCodesKey(upgrade_code, &hkey2, TRUE);
4084 squash_guid(package->ProductCode,squashed);
4085 msi_reg_set_val_str( hkey2, squashed, NULL );
4086 RegCloseKey(hkey2);
4087 MSIREG_OpenUserUpgradeCodesKey(upgrade_code, &hkey2, TRUE);
4088 squash_guid(package->ProductCode,squashed);
4089 msi_reg_set_val_str( hkey2, squashed, NULL );
4090 RegCloseKey(hkey2);
4091
4092 msi_free(upgrade_code);
4093 }
4094
4095 RegCloseKey(hkey);
4096
4097 rc = MSIREG_OpenUserDataProductKey(package->ProductCode, &hudkey, TRUE);
4098 if (rc != ERROR_SUCCESS)
4099 return rc;
4100
4101 RegCloseKey(hudkey);
4102
4103 msi_reg_set_val_dword( props, szWindowsInstaller, 1 );
4104 RegCloseKey(props);
4105
4106 return ERROR_SUCCESS;
4107 }
4108
4109 static UINT ACTION_InstallExecute(MSIPACKAGE *package)
4110 {
4111 return execute_script(package,INSTALL_SCRIPT);
4112 }
4113
4114 static UINT msi_unpublish_product(MSIPACKAGE *package)
4115 {
4116 LPWSTR remove = NULL;
4117 LPWSTR *features = NULL;
4118 BOOL full_uninstall = TRUE;
4119 MSIFEATURE *feature;
4120
4121 static const WCHAR szRemove[] = {'R','E','M','O','V','E',0};
4122 static const WCHAR szAll[] = {'A','L','L',0};
4123
4124 remove = msi_dup_property(package, szRemove);
4125 if (!remove)
4126 return ERROR_SUCCESS;
4127
4128 features = msi_split_string(remove, ',');
4129 if (!features)
4130 {
4131 msi_free(remove);
4132 ERR("REMOVE feature list is empty!\n");
4133 return ERROR_FUNCTION_FAILED;
4134 }
4135
4136 if (!lstrcmpW(features[0], szAll))
4137 full_uninstall = TRUE;
4138 else
4139 {
4140 LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
4141 {
4142 if (feature->Action != INSTALLSTATE_ABSENT)
4143 full_uninstall = FALSE;
4144 }
4145 }
4146
4147 if (!full_uninstall)
4148 goto done;
4149
4150 MSIREG_DeleteProductKey(package->ProductCode);
4151 MSIREG_DeleteUserProductKey(package->ProductCode);
4152 MSIREG_DeleteUserDataProductKey(package->ProductCode);
4153 MSIREG_DeleteUserFeaturesKey(package->ProductCode);
4154 MSIREG_DeleteUninstallKey(package->ProductCode);
4155
4156 done:
4157 msi_free(remove);
4158 msi_free(features);
4159 return ERROR_SUCCESS;
4160 }
4161
4162 static UINT ACTION_InstallFinalize(MSIPACKAGE *package)
4163 {
4164 UINT rc;
4165
4166 rc = msi_unpublish_product(package);
4167 if (rc != ERROR_SUCCESS)
4168 return rc;
4169
4170 /* turn off scheduling */
4171 package->script->CurrentlyScripting= FALSE;
4172
4173 /* first do the same as an InstallExecute */
4174 rc = ACTION_InstallExecute(package);
4175 if (rc != ERROR_SUCCESS)
4176 return rc;
4177
4178 /* then handle Commit Actions */
4179 rc = execute_script(package,COMMIT_SCRIPT);
4180
4181 return rc;
4182 }
4183
4184 UINT ACTION_ForceReboot(MSIPACKAGE *package)
4185 {
4186 static const WCHAR RunOnce[] = {
4187 'S','o','f','t','w','a','r','e','\\',
4188 'M','i','c','r','o','s','o','f','t','\\',
4189 'W','i','n','d','o','w','s','\\',
4190 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
4191 'R','u','n','O','n','c','e',0};
4192 static const WCHAR InstallRunOnce[] = {
4193 'S','o','f','t','w','a','r','e','\\',
4194 'M','i','c','r','o','s','o','f','t','\\',
4195 'W','i','n','d','o','w','s','\\',
4196 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
4197 'I','n','s','t','a','l','l','e','r','\\',
4198 'R','u','n','O','n','c','e','E','n','t','r','i','e','s',0};
4199
4200 static const WCHAR msiexec_fmt[] = {
4201 '%','s',
4202 '\\','M','s','i','E','x','e','c','.','e','x','e',' ','/','@',' ',
4203 '\"','%','s','\"',0};
4204 static const WCHAR install_fmt[] = {
4205 '/','I',' ','\"','%','s','\"',' ',
4206 'A','F','T','E','R','R','E','B','O','O','T','=','1',' ',
4207 'R','U','N','O','N','C','E','E','N','T','R','Y','=','\"','%','s','\"',0};
4208 WCHAR buffer[256], sysdir[MAX_PATH];
4209 HKEY hkey;
4210 WCHAR squished_pc[100];
4211
4212 squash_guid(package->ProductCode,squished_pc);
4213
4214 GetSystemDirectoryW(sysdir, sizeof(sysdir)/sizeof(sysdir[0]));
4215 RegCreateKeyW(HKEY_LOCAL_MACHINE,RunOnce,&hkey);
4216 snprintfW(buffer,sizeof(buffer)/sizeof(buffer[0]),msiexec_fmt,sysdir,
4217 squished_pc);
4218
4219 msi_reg_set_val_str( hkey, squished_pc, buffer );
4220 RegCloseKey(hkey);
4221
4222 TRACE("Reboot command %s\n",debugstr_w(buffer));
4223
4224 RegCreateKeyW(HKEY_LOCAL_MACHINE,InstallRunOnce,&hkey);
4225 sprintfW(buffer,install_fmt,package->ProductCode,squished_pc);
4226
4227 msi_reg_set_val_str( hkey, squished_pc, buffer );
4228 RegCloseKey(hkey);
4229
4230 return ERROR_INSTALL_SUSPEND;
4231 }
4232
4233 static UINT ACTION_ResolveSource(MSIPACKAGE* package)
4234 {
4235 DWORD attrib;
4236 UINT rc;
4237
4238 /*
4239 * We are currently doing what should be done here in the top level Install
4240 * however for Administrative and uninstalls this step will be needed
4241 */
4242 if (!package->PackagePath)
4243 return ERROR_SUCCESS;
4244
4245 msi_set_sourcedir_props(package, TRUE);
4246
4247 attrib = GetFileAttributesW(package->db->path);
4248 if (attrib == INVALID_FILE_ATTRIBUTES)
4249 {
4250 LPWSTR prompt;
4251 LPWSTR msg;
4252 DWORD size = 0;
4253
4254 rc = MsiSourceListGetInfoW(package->ProductCode, NULL,
4255 package->Context, MSICODE_PRODUCT,
4256 INSTALLPROPERTY_DISKPROMPTW,NULL,&size);
4257 if (rc == ERROR_MORE_DATA)
4258 {
4259 prompt = msi_alloc(size * sizeof(WCHAR));
4260 MsiSourceListGetInfoW(package->ProductCode, NULL,
4261 package->Context, MSICODE_PRODUCT,
4262 INSTALLPROPERTY_DISKPROMPTW,prompt,&size);
4263 }
4264 else
4265 prompt = strdupW(package->db->path);
4266
4267 msg = generate_error_string(package,1302,1,prompt);
4268 while(attrib == INVALID_FILE_ATTRIBUTES)
4269 {
4270 rc = MessageBoxW(NULL,msg,NULL,MB_OKCANCEL);
4271 if (rc == IDCANCEL)
4272 {
4273 rc = ERROR_INSTALL_USEREXIT;
4274 break;
4275 }
4276 attrib = GetFileAttributesW(package->db->path);
4277 }
4278 msi_free(prompt);
4279 rc = ERROR_SUCCESS;
4280 }
4281 else
4282 return ERROR_SUCCESS;
4283
4284 return rc;
4285 }
4286
4287 static UINT ACTION_RegisterUser(MSIPACKAGE *package)
4288 {
4289 HKEY hkey=0;
4290 LPWSTR buffer;
4291 LPWSTR productid;
4292 UINT rc,i;
4293
4294 static const WCHAR szPropKeys[][80] =
4295 {
4296 {'P','r','o','d','u','c','t','I','D',0},
4297 {'U','S','E','R','N','A','M','E',0},
4298 {'C','O','M','P','A','N','Y','N','A','M','E',0},
4299 {0},
4300 };
4301
4302 static const WCHAR szRegKeys[][80] =
4303 {
4304 {'P','r','o','d','u','c','t','I','D',0},
4305 {'R','e','g','O','w','n','e','r',0},
4306 {'R','e','g','C','o','m','p','a','n','y',0},
4307 {0},
4308 };
4309
4310 if (msi_check_unpublish(package))
4311 {
4312 MSIREG_DeleteUserDataProductKey(package->ProductCode);
4313 return ERROR_SUCCESS;
4314 }
4315
4316 productid = msi_dup_property( package, INSTALLPROPERTY_PRODUCTIDW );
4317 if (!productid)
4318 return ERROR_SUCCESS;
4319
4320 rc = MSIREG_OpenCurrentUserInstallProps(package->ProductCode, &hkey, TRUE);
4321 if (rc != ERROR_SUCCESS)
4322 goto end;
4323
4324 for( i = 0; szPropKeys[i][0]; i++ )
4325 {
4326 buffer = msi_dup_property( package, szPropKeys[i] );
4327 msi_reg_set_val_str( hkey, szRegKeys[i], buffer );
4328 msi_free( buffer );
4329 }
4330
4331 end:
4332 msi_free(productid);
4333 RegCloseKey(hkey);
4334
4335 /* FIXME: call ui_actiondata */
4336
4337 return rc;
4338 }
4339
4340
4341 static UINT ACTION_ExecuteAction(MSIPACKAGE *package)
4342 {
4343 UINT rc;
4344
4345 package->script->InWhatSequence |= SEQUENCE_EXEC;
4346 rc = ACTION_ProcessExecSequence(package,FALSE);
4347 return rc;
4348 }
4349
4350
4351 static UINT ITERATE_PublishComponent(MSIRECORD *rec, LPVOID param)
4352 {
4353 MSIPACKAGE *package = (MSIPACKAGE*)param;
4354 LPCWSTR compgroupid=NULL;
4355 LPCWSTR feature=NULL;
4356 LPCWSTR text = NULL;
4357 LPCWSTR qualifier = NULL;
4358 LPCWSTR component = NULL;
4359 LPWSTR advertise = NULL;
4360 LPWSTR output = NULL;
4361 HKEY hkey;
4362 UINT rc = ERROR_SUCCESS;
4363 MSICOMPONENT *comp;
4364 DWORD sz = 0;
4365 MSIRECORD *uirow;
4366
4367 component = MSI_RecordGetString(rec,3);
4368 comp = get_loaded_component(package,component);
4369
4370 if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL ) &&
4371 !ACTION_VerifyComponentForAction( comp, INSTALLSTATE_SOURCE ) &&
4372 !ACTION_VerifyComponentForAction( comp, INSTALLSTATE_ADVERTISED ))
4373 {
4374 TRACE("Skipping: Component %s not scheduled for install\n",
4375 debugstr_w(component));
4376
4377 return ERROR_SUCCESS;
4378 }
4379
4380 compgroupid = MSI_RecordGetString(rec,1);
4381 qualifier = MSI_RecordGetString(rec,2);
4382
4383 rc = MSIREG_OpenUserComponentsKey(compgroupid, &hkey, TRUE);
4384 if (rc != ERROR_SUCCESS)
4385 goto end;
4386
4387 text = MSI_RecordGetString(rec,4);
4388 feature = MSI_RecordGetString(rec,5);
4389
4390 advertise = create_component_advertise_string(package, comp, feature);
4391
4392 sz = strlenW(advertise);
4393
4394 if (text)
4395 sz += lstrlenW(text);
4396
4397 sz+=3;
4398 sz *= sizeof(WCHAR);
4399
4400 output = msi_alloc_zero(sz);
4401 strcpyW(output,advertise);
4402 msi_free(advertise);
4403
4404 if (text)
4405 strcatW(output,text);
4406
4407 msi_reg_set_val_multi_str( hkey, qualifier, output );
4408
4409 end:
4410 RegCloseKey(hkey);
4411 msi_free(output);
4412
4413 /* the UI chunk */
4414 uirow = MSI_CreateRecord( 2 );
4415 MSI_RecordSetStringW( uirow, 1, compgroupid );
4416 MSI_RecordSetStringW( uirow, 2, qualifier);
4417 ui_actiondata( package, szPublishComponents, uirow);
4418 msiobj_release( &uirow->hdr );
4419 /* FIXME: call ui_progress? */
4420
4421 return rc;
4422 }
4423
4424 /*
4425 * At present I am ignorning the advertised components part of this and only
4426 * focusing on the qualified component sets
4427 */
4428 static UINT ACTION_PublishComponents(MSIPACKAGE *package)
4429 {
4430 UINT rc;
4431 MSIQUERY * view;
4432 static const WCHAR ExecSeqQuery[] =
4433 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4434 '`','P','u','b','l','i','s','h',
4435 'C','o','m','p','o','n','e','n','t','`',0};
4436
4437 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4438 if (rc != ERROR_SUCCESS)
4439 return ERROR_SUCCESS;
4440
4441 rc = MSI_IterateRecords(view, NULL, ITERATE_PublishComponent, package);
4442 msiobj_release(&view->hdr);
4443
4444 return rc;
4445 }
4446
4447 static UINT ITERATE_InstallService(MSIRECORD *rec, LPVOID param)
4448 {
4449 MSIPACKAGE *package = (MSIPACKAGE*)param;
4450 MSIRECORD *row;
4451 MSIFILE *file;
4452 SC_HANDLE hscm, service = NULL;
4453 LPCWSTR comp, depends, pass;
4454 LPWSTR name = NULL, disp = NULL;
4455 LPCWSTR load_order, serv_name, key;
4456 DWORD serv_type, start_type;
4457 DWORD err_control;
4458
4459 static const WCHAR query[] =
4460 {'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
4461 '`','C','o','m','p','o','n','e','n','t','`',' ',
4462 'W','H','E','R','E',' ',
4463 '`','C','o','m','p','o','n','e','n','t','`',' ',
4464 '=','\'','%','s','\'',0};
4465
4466 hscm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, GENERIC_WRITE);
4467 if (!hscm)
4468 {
4469 ERR("Failed to open the SC Manager!\n");
4470 goto done;
4471 }
4472
4473 start_type = MSI_RecordGetInteger(rec, 5);
4474 if (start_type == SERVICE_BOOT_START || start_type == SERVICE_SYSTEM_START)
4475 goto done;
4476
4477 depends = MSI_RecordGetString(rec, 8);
4478 if (depends && *depends)
4479 FIXME("Dependency list unhandled!\n");
4480
4481 deformat_string(package, MSI_RecordGetString(rec, 2), &name);
4482 deformat_string(package, MSI_RecordGetString(rec, 3), &disp);
4483 serv_type = MSI_RecordGetInteger(rec, 4);
4484 err_control = MSI_RecordGetInteger(rec, 6);
4485 load_order = MSI_RecordGetString(rec, 7);
4486 serv_name = MSI_RecordGetString(rec, 9);
4487 pass = MSI_RecordGetString(rec, 10);
4488 comp = MSI_RecordGetString(rec, 12);
4489
4490 /* fetch the service path */
4491 row = MSI_QueryGetRecord(package->db, query, comp);
4492 if (!row)
4493 {
4494 ERR("Control query failed!\n");
4495 goto done;
4496 }
4497
4498 key = MSI_RecordGetString(row, 6);
4499
4500 file = get_loaded_file(package, key);
4501 msiobj_release(&row->hdr);
4502 if (!file)
4503 {
4504 ERR("Failed to load the service file\n");
4505 goto done;
4506 }
4507
4508 service = CreateServiceW(hscm, name, disp, GENERIC_ALL, serv_type,
4509 start_type, err_control, file->TargetPath,
4510 load_order, NULL, NULL, serv_name, pass);
4511 if (!service)
4512 {
4513 if (GetLastError() != ERROR_SERVICE_EXISTS)
4514 ERR("Failed to create service %s: %d\n", debugstr_w(name), GetLastError());
4515 }
4516
4517 done:
4518 CloseServiceHandle(service);
4519 CloseServiceHandle(hscm);
4520 msi_free(name);
4521 msi_free(disp);
4522
4523 return ERROR_SUCCESS;
4524 }
4525
4526 static UINT ACTION_InstallServices( MSIPACKAGE *package )
4527 {
4528 UINT rc;
4529 MSIQUERY * view;
4530 static const WCHAR ExecSeqQuery[] =
4531 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4532 'S','e','r','v','i','c','e','I','n','s','t','a','l','l',0};
4533
4534 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4535 if (rc != ERROR_SUCCESS)
4536 return ERROR_SUCCESS;
4537
4538 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallService, package);
4539 msiobj_release(&view->hdr);
4540
4541 return rc;
4542 }
4543
4544 /* converts arg1[~]arg2[~]arg3 to a list of ptrs to the strings */
4545 static LPCWSTR *msi_service_args_to_vector(LPWSTR args, DWORD *numargs)
4546 {
4547 LPCWSTR *vector, *temp_vector;
4548 LPWSTR p, q;
4549 DWORD sep_len;
4550
4551 static const WCHAR separator[] = {'[','~',']',0};
4552
4553 *numargs = 0;
4554 sep_len = sizeof(separator) / sizeof(WCHAR) - 1;
4555
4556 if (!args)
4557 return NULL;
4558
4559 vector = msi_alloc(sizeof(LPWSTR));
4560 if (!vector)
4561 return NULL;
4562
4563 p = args;
4564 do
4565 {
4566 (*numargs)++;
4567 vector[*numargs - 1] = p;
4568
4569 if ((q = strstrW(p, separator)))
4570 {
4571 *q = '\0';
4572
4573 temp_vector = msi_realloc(vector, (*numargs + 1) * sizeof(LPWSTR));
4574 if (!temp_vector)
4575 {
4576 msi_free(vector);
4577 return NULL;
4578 }
4579 vector = temp_vector;
4580
4581 p = q + sep_len;
4582 }
4583 } while (q);
4584
4585 return vector;
4586 }
4587
4588 static UINT ITERATE_StartService(MSIRECORD *rec, LPVOID param)
4589 {
4590 MSIPACKAGE *package = (MSIPACKAGE *)param;
4591 MSICOMPONENT *comp;
4592 SC_HANDLE scm, service = NULL;
4593 LPCWSTR name, *vector = NULL;
4594 LPWSTR args;
4595 DWORD event, numargs;
4596 UINT r = ERROR_FUNCTION_FAILED;
4597
4598 comp = get_loaded_component(package, MSI_RecordGetString(rec, 6));
4599 if (!comp || comp->Action == INSTALLSTATE_UNKNOWN || comp->Action == INSTALLSTATE_ABSENT)
4600 return ERROR_SUCCESS;
4601
4602 name = MSI_RecordGetString(rec, 2);
4603 event = MSI_RecordGetInteger(rec, 3);
4604 args = strdupW(MSI_RecordGetString(rec, 4));
4605
4606 if (!(event & msidbServiceControlEventStart))
4607 return ERROR_SUCCESS;
4608
4609 scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
4610 if (!scm)
4611 {
4612 ERR("Failed to open the service control manager\n");
4613 goto done;
4614 }
4615
4616 service = OpenServiceW(scm, name, SERVICE_START);
4617 if (!service)
4618 {
4619 ERR("Failed to open service %s\n", debugstr_w(name));
4620 goto done;
4621 }
4622
4623 vector = msi_service_args_to_vector(args, &numargs);
4624
4625 if (!StartServiceW(service, numargs, vector))
4626 {
4627 ERR("Failed to start service %s\n", debugstr_w(name));
4628 goto done;
4629 }
4630
4631 r = ERROR_SUCCESS;
4632
4633 done:
4634 CloseServiceHandle(service);
4635 CloseServiceHandle(scm);
4636
4637 msi_free(args);
4638 msi_free(vector);
4639 return r;
4640 }
4641
4642 static UINT ACTION_StartServices( MSIPACKAGE *package )
4643 {
4644 UINT rc;
4645 MSIQUERY *view;
4646
4647 static const WCHAR query[] = {
4648 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4649 'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
4650
4651 rc = MSI_DatabaseOpenViewW(package->db, query, &view);
4652 if (rc != ERROR_SUCCESS)
4653 return ERROR_SUCCESS;
4654
4655 rc = MSI_IterateRecords(view, NULL, ITERATE_StartService, package);
4656 msiobj_release(&view->hdr);
4657
4658 return rc;
4659 }
4660
4661 static BOOL stop_service_dependents(SC_HANDLE scm, SC_HANDLE service)
4662 {
4663 DWORD i, needed, count;
4664 ENUM_SERVICE_STATUSW *dependencies;
4665 SERVICE_STATUS ss;
4666 SC_HANDLE depserv;
4667
4668 if (EnumDependentServicesW(service, SERVICE_ACTIVE, NULL,
4669 0, &needed, &count))
4670 return TRUE;
4671
4672 if (GetLastError() != ERROR_MORE_DATA)
4673 return FALSE;
4674
4675 dependencies = msi_alloc(needed);
4676 if (!dependencies)
4677 return FALSE;
4678
4679 if (!EnumDependentServicesW(service, SERVICE_ACTIVE, dependencies,
4680 needed, &needed, &count))
4681 goto error;
4682
4683 for (i = 0; i < count; i++)
4684 {
4685 depserv = OpenServiceW(scm, dependencies[i].lpServiceName,
4686 SERVICE_STOP | SERVICE_QUERY_STATUS);
4687 if (!depserv)
4688 goto error;
4689
4690 if (!ControlService(depserv, SERVICE_CONTROL_STOP, &ss))
4691 goto error;
4692 }
4693
4694 return TRUE;
4695
4696 error:
4697 msi_free(dependencies);
4698 return FALSE;
4699 }
4700
4701 static UINT ITERATE_StopService(MSIRECORD *rec, LPVOID param)
4702 {
4703 MSIPACKAGE *package = (MSIPACKAGE *)param;
4704 MSICOMPONENT *comp;
4705 SERVICE_STATUS status;
4706 SERVICE_STATUS_PROCESS ssp;
4707 SC_HANDLE scm = NULL, service = NULL;
4708 LPWSTR name, args;
4709 DWORD event, needed;
4710
4711 event = MSI_RecordGetInteger(rec, 3);
4712 if (!(event & msidbServiceControlEventStop))
4713 return ERROR_SUCCESS;
4714
4715 comp = get_loaded_component(package, MSI_RecordGetString(rec, 6));
4716 if (!comp || comp->Action == INSTALLSTATE_UNKNOWN || comp->Action == INSTALLSTATE_ABSENT)
4717 return ERROR_SUCCESS;
4718
4719 deformat_string(package, MSI_RecordGetString(rec, 2), &name);
4720 deformat_string(package, MSI_RecordGetString(rec, 4), &args);
4721 args = strdupW(MSI_RecordGetString(rec, 4));
4722
4723 scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);
4724 if (!scm)
4725 {
4726 WARN("Failed to open the SCM: %d\n", GetLastError());
4727 goto done;
4728 }
4729
4730 service = OpenServiceW(scm, name,
4731 SERVICE_STOP |
4732 SERVICE_QUERY_STATUS |
4733 SERVICE_ENUMERATE_DEPENDENTS);
4734 if (!service)
4735 {
4736 WARN("Failed to open service (%s): %d\n",
4737 debugstr_w(name), GetLastError());
4738 goto done;
4739 }
4740
4741 if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp,
4742 sizeof(SERVICE_STATUS_PROCESS), &needed))
4743 {
4744 WARN("Failed to query service status (%s): %d\n",
4745 debugstr_w(name), GetLastError());
4746 goto done;
4747 }
4748
4749 if (ssp.dwCurrentState == SERVICE_STOPPED)
4750 goto done;
4751
4752 stop_service_dependents(scm, service);
4753
4754 if (!ControlService(service, SERVICE_CONTROL_STOP, &status))
4755 WARN("Failed to stop service (%s): %d\n", debugstr_w(name), GetLastError());
4756
4757 done:
4758 CloseServiceHandle(service);
4759 CloseServiceHandle(scm);
4760 msi_free(name);
4761 msi_free(args);
4762
4763 return ERROR_SUCCESS;
4764 }
4765
4766 static UINT ACTION_StopServices( MSIPACKAGE *package )
4767 {
4768 UINT rc;
4769 MSIQUERY *view;
4770
4771 static const WCHAR query[] = {
4772 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4773 'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
4774
4775 rc = MSI_DatabaseOpenViewW(package->db, query, &view);
4776 if (rc != ERROR_SUCCESS)
4777 return ERROR_SUCCESS;
4778
4779 rc = MSI_IterateRecords(view, NULL, ITERATE_StopService, package);
4780 msiobj_release(&view->hdr);
4781
4782 return rc;
4783 }
4784
4785 static MSIFILE *msi_find_file( MSIPACKAGE *package, LPCWSTR filename )
4786 {
4787 MSIFILE *file;
4788
4789 LIST_FOR_EACH_ENTRY(file, &package->files, MSIFILE, entry)
4790 {
4791 if (!lstrcmpW(file->File, filename))
4792 return file;
4793 }
4794
4795 return NULL;
4796 }
4797
4798 static UINT ITERATE_InstallODBCDriver( MSIRECORD *rec, LPVOID param )
4799 {
4800 MSIPACKAGE *package = (MSIPACKAGE*)param;
4801 LPWSTR driver, driver_path, ptr;
4802 WCHAR outpath[MAX_PATH];
4803 MSIFILE *driver_file, *setup_file;
4804 LPCWSTR desc;
4805 DWORD len, usage;
4806 UINT r = ERROR_SUCCESS;
4807
4808 static const WCHAR driver_fmt[] = {
4809 'D','r','i','v','e','r','=','%','s',0};
4810 static const WCHAR setup_fmt[] = {
4811 'S','e','t','u','p','=','%','s',0};
4812 static const WCHAR usage_fmt[] = {
4813 'F','i','l','e','U','s','a','g','e','=','1',0};
4814
4815 desc = MSI_RecordGetString(rec, 3);
4816
4817 driver_file = msi_find_file(package, MSI_RecordGetString(rec, 4));
4818 setup_file = msi_find_file(package, MSI_RecordGetString(rec, 5));
4819
4820 if (!driver_file || !setup_file)
4821 {
4822 ERR("ODBC Driver entry not found!\n");
4823 return ERROR_FUNCTION_FAILED;
4824 }
4825
4826 len = lstrlenW(desc) + lstrlenW(driver_fmt) + lstrlenW(driver_file->FileName) +
4827 lstrlenW(setup_fmt) + lstrlenW(setup_file->FileName) +
4828 lstrlenW(usage_fmt) + 1;
4829 driver = msi_alloc(len * sizeof(WCHAR));
4830 if (!driver)
4831 return ERROR_OUTOFMEMORY;
4832
4833 ptr = driver;
4834 lstrcpyW(ptr, desc);
4835 ptr += lstrlenW(ptr) + 1;
4836
4837 sprintfW(ptr, driver_fmt, driver_file->FileName);
4838 ptr += lstrlenW(ptr) + 1;
4839
4840 sprintfW(ptr, setup_fmt, setup_file->FileName);
4841 ptr += lstrlenW(ptr) + 1;
4842
4843 lstrcpyW(ptr, usage_fmt);
4844 ptr += lstrlenW(ptr) + 1;
4845 *ptr = '\0';
4846
4847 driver_path = strdupW(driver_file->TargetPath);
4848 ptr = strrchrW(driver_path, '\\');
4849 if (ptr) *ptr = '\0';
4850
4851 if (!SQLInstallDriverExW(driver, driver_path, outpath, MAX_PATH,
4852 NULL, ODBC_INSTALL_COMPLETE, &usage))
4853 {
4854 ERR("Failed to install SQL driver!\n");
4855 r = ERROR_FUNCTION_FAILED;
4856 }
4857
4858 msi_free(driver);
4859 msi_free(driver_path);
4860
4861 return r;
4862 }
4863
4864 static UINT ITERATE_InstallODBCTranslator( MSIRECORD *rec, LPVOID param )
4865 {
4866 MSIPACKAGE *package = (MSIPACKAGE*)param;
4867 LPWSTR translator, translator_path, ptr;
4868 WCHAR outpath[MAX_PATH];
4869 MSIFILE *translator_file, *setup_file;
4870 LPCWSTR desc;
4871 DWORD len, usage;
4872 UINT r = ERROR_SUCCESS;
4873
4874 static const WCHAR translator_fmt[] = {
4875 'T','r','a','n','s','l','a','t','o','r','=','%','s',0};
4876 static const WCHAR setup_fmt[] = {
4877 'S','e','t','u','p','=','%','s',0};
4878
4879 desc = MSI_RecordGetString(rec, 3);
4880
4881 translator_file = msi_find_file(package, MSI_RecordGetString(rec, 4));
4882 setup_file = msi_find_file(package, MSI_RecordGetString(rec, 5));
4883
4884 if (!translator_file || !setup_file)
4885 {
4886 ERR("ODBC Translator entry not found!\n");
4887 return ERROR_FUNCTION_FAILED;
4888 }
4889
4890 len = lstrlenW(desc) + lstrlenW(translator_fmt) + lstrlenW(translator_file->FileName) +
4891 lstrlenW(setup_fmt) + lstrlenW(setup_file->FileName) + 1;
4892 translator = msi_alloc(len * sizeof(WCHAR));
4893 if (!translator)
4894 return ERROR_OUTOFMEMORY;
4895
4896 ptr = translator;
4897 lstrcpyW(ptr, desc);
4898 ptr += lstrlenW(ptr) + 1;
4899
4900 sprintfW(ptr, translator_fmt, translator_file->FileName);
4901 ptr += lstrlenW(ptr) + 1;
4902
4903 sprintfW(ptr, setup_fmt, setup_file->FileName);
4904 ptr += lstrlenW(ptr) + 1;
4905 *ptr = '\0';
4906
4907 translator_path = strdupW(translator_file->TargetPath);
4908 ptr = strrchrW(translator_path, '\\');
4909 if (ptr) *ptr = '\0';
4910
4911 if (!SQLInstallTranslatorExW(translator, translator_path, outpath, MAX_PATH,
4912 NULL, ODBC_INSTALL_COMPLETE, &usage))
4913 {
4914 ERR("Failed to install SQL translator!\n");
4915 r = ERROR_FUNCTION_FAILED;
4916 }
4917
4918 msi_free(translator);
4919 msi_free(translator_path);
4920
4921 return r;
4922 }
4923
4924 static UINT ITERATE_InstallODBCDataSource( MSIRECORD *rec, LPVOID param )
4925 {
4926 LPWSTR attrs;
4927 LPCWSTR desc, driver;
4928 WORD request = ODBC_ADD_SYS_DSN;
4929 INT registration;
4930 DWORD len;
4931 UINT r = ERROR_SUCCESS;
4932
4933 static const WCHAR attrs_fmt[] = {
4934 'D','S','N','=','%','s',0 };
4935
4936 desc = MSI_RecordGetString(rec, 3);
4937 driver = MSI_RecordGetString(rec, 4);
4938 registration = MSI_RecordGetInteger(rec, 5);
4939
4940 if (registration == msidbODBCDataSourceRegistrationPerMachine) request = ODBC_ADD_SYS_DSN;
4941 else if (registration == msidbODBCDataSourceRegistrationPerUser) request = ODBC_ADD_DSN;
4942
4943 len = lstrlenW(attrs_fmt) + lstrlenW(desc) + 1 + 1;
4944 attrs = msi_alloc(len * sizeof(WCHAR));
4945 if (!attrs)
4946 return ERROR_OUTOFMEMORY;
4947
4948 sprintfW(attrs, attrs_fmt, desc);
4949 attrs[len - 1] = '\0';
4950
4951 if (!SQLConfigDataSourceW(NULL, request, driver, attrs))
4952 {
4953 ERR("Failed to install SQL data source!\n");
4954 r = ERROR_FUNCTION_FAILED;
4955 }
4956
4957 msi_free(attrs);
4958
4959 return r;
4960 }
4961
4962 static UINT ACTION_InstallODBC( MSIPACKAGE *package )
4963 {
4964 UINT rc;
4965 MSIQUERY *view;
4966
4967 static const WCHAR driver_query[] = {
4968 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4969 'O','D','B','C','D','r','i','v','e','r',0 };
4970
4971 static const WCHAR translator_query[] = {
4972 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4973 'O','D','B','C','T','r','a','n','s','l','a','t','o','r',0 };
4974
4975 static const WCHAR source_query[] = {
4976 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4977 'O','D','B','C','D','a','t','a','S','o','u','r','c','e',0 };
4978
4979 rc = MSI_DatabaseOpenViewW(package->db, driver_query, &view);
4980 if (rc != ERROR_SUCCESS)
4981 return ERROR_SUCCESS;
4982
4983 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCDriver, package);
4984 msiobj_release(&view->hdr);
4985
4986 rc = MSI_DatabaseOpenViewW(package->db, translator_query, &view);
4987 if (rc != ERROR_SUCCESS)
4988 return ERROR_SUCCESS;
4989
4990 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCTranslator, package);
4991 msiobj_release(&view->hdr);
4992
4993 rc = MSI_DatabaseOpenViewW(package->db, source_query, &view);
4994 if (rc != ERROR_SUCCESS)
4995 return ERROR_SUCCESS;
4996
4997 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCDataSource, package);
4998 msiobj_release(&view->hdr);
4999
5000 return rc;
5001 }
5002
5003 #define ENV_ACT_SETALWAYS 0x1
5004 #define ENV_ACT_SETABSENT 0x2
5005 #define ENV_ACT_REMOVE 0x4
5006 #define ENV_ACT_REMOVEMATCH 0x8
5007
5008 #define ENV_MOD_MACHINE 0x20000000
5009 #define ENV_MOD_APPEND 0x40000000
5010 #define ENV_MOD_PREFIX 0x80000000
5011 #define ENV_MOD_MASK 0xC0000000
5012
5013 #define check_flag_combo(x, y) ((x) & ~(y)) == (y)
5014
5015 static LONG env_set_flags( LPCWSTR *name, LPCWSTR *value, DWORD *flags )
5016 {
5017 LPCWSTR cptr = *name;
5018 LPCWSTR ptr = *value;
5019
5020 static const WCHAR prefix[] = {'[','~',']',0};
5021 static const int prefix_len = 3;
5022
5023 *flags = 0;
5024 while (*cptr)
5025 {
5026 if (*cptr == '=')
5027 *flags |= ENV_ACT_SETALWAYS;
5028 else if (*cptr == '+')
5029 *flags |= ENV_ACT_SETABSENT;
5030 else if (*cptr == '-')
5031 *flags |= ENV_ACT_REMOVE;
5032 else if (*cptr == '!')
5033 *flags |= ENV_ACT_REMOVEMATCH;
5034 else if (*cptr == '*')
5035 *flags |= ENV_MOD_MACHINE;
5036 else
5037 break;
5038
5039 cptr++;
5040 (*name)++;
5041 }
5042
5043 if (!*cptr)
5044 {
5045 ERR("Missing environment variable\n");
5046 return ERROR_FUNCTION_FAILED;
5047 }
5048
5049 if (!strncmpW(ptr, prefix, prefix_len))
5050 {
5051 *flags |= ENV_MOD_APPEND;
5052 *value += lstrlenW(prefix);
5053 }
5054 else if (lstrlenW(*value) >= prefix_len)
5055 {
5056 ptr += lstrlenW(ptr) - prefix_len;
5057 if (!lstrcmpW(ptr, prefix))
5058 {
5059 *flags |= ENV_MOD_PREFIX;
5060 /* the "[~]" will be removed by deformat_string */;
5061 }
5062 }
5063
5064 if (!*flags ||
5065 check_flag_combo(*flags, ENV_ACT_SETALWAYS | ENV_ACT_SETABSENT) ||
5066 check_flag_combo(*flags, ENV_ACT_REMOVEMATCH | ENV_ACT_SETABSENT) ||
5067 check_flag_combo(*flags, ENV_ACT_REMOVEMATCH | ENV_ACT_SETALWAYS) ||
5068 check_flag_combo(*flags, ENV_ACT_SETABSENT | ENV_MOD_MASK))
5069 {
5070 ERR("Invalid flags: %08x\n", *flags);
5071 return ERROR_FUNCTION_FAILED;
5072 }
5073
5074 return ERROR_SUCCESS;
5075 }
5076
5077 static UINT ITERATE_WriteEnvironmentString( MSIRECORD *rec, LPVOID param )
5078 {
5079 MSIPACKAGE *package = param;
5080 LPCWSTR name, value;
5081 LPWSTR data = NULL, newval = NULL;
5082 LPWSTR deformatted = NULL, ptr;
5083 DWORD flags, type, size;
5084 LONG res;
5085 HKEY env = NULL, root;
5086 LPCWSTR environment;
5087
5088 static const WCHAR user_env[] =
5089 {'E','n','v','i','r','o','n','m','e','n','t',0};
5090 static const WCHAR machine_env[] =
5091 {'S','y','s','t','e','m','\\',
5092 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
5093 'C','o','n','t','r','o','l','\\',
5094 'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
5095 'E','n','v','i','r','o','n','m','e','n','t',0};
5096 static const WCHAR semicolon[] = {';',0};
5097
5098 name = MSI_RecordGetString(rec, 2);
5099 value = MSI_RecordGetString(rec, 3);
5100
5101 res = env_set_flags(&name, &value, &flags);
5102 if (res != ERROR_SUCCESS)
5103 goto done;
5104
5105 deformat_string(package, value, &deformatted);
5106 if (!deformatted)
5107 {
5108 res = ERROR_OUTOFMEMORY;
5109 goto done;
5110 }
5111
5112 value = deformatted;
5113
5114 if (flags & ENV_MOD_MACHINE)
5115 {
5116 environment = machine_env;
5117 root = HKEY_LOCAL_MACHINE;
5118 }
5119 else
5120 {
5121 environment = user_env;
5122 root = HKEY_CURRENT_USER;
5123 }
5124
5125 res = RegCreateKeyExW(root, environment, 0, NULL, 0,
5126 KEY_ALL_ACCESS, NULL, &env, NULL);
5127 if (res != ERROR_SUCCESS)
5128 goto done;
5129
5130 if (flags & ENV_ACT_REMOVE)
5131 FIXME("Not removing environment variable on uninstall!\n");
5132
5133 size = 0;
5134 res = RegQueryValueExW(env, name, NULL, &type, NULL, &size);
5135 if ((res != ERROR_SUCCESS && res != ERROR_FILE_NOT_FOUND) ||
5136 (res == ERROR_SUCCESS && type != REG_SZ && type != REG_EXPAND_SZ))
5137 goto done;
5138
5139 if (res != ERROR_FILE_NOT_FOUND)
5140 {
5141 if (flags & ENV_ACT_SETABSENT)
5142 {
5143 res = ERROR_SUCCESS;
5144 goto done;
5145 }
5146
5147 data = msi_alloc(size);
5148 if (!data)
5149 {
5150 RegCloseKey(env);
5151 return ERROR_OUTOFMEMORY;
5152 }
5153
5154 res = RegQueryValueExW(env, name, NULL, &type, (LPVOID)data, &size);
5155 if (res != ERROR_SUCCESS)
5156 goto done;
5157
5158 if (flags & ENV_ACT_REMOVEMATCH && (!value || !lstrcmpW(data, value)))
5159 {
5160 res = RegDeleteKeyW(env, name);
5161 goto done;
5162 }
5163
5164 size = (lstrlenW(value) + 1 + size) * sizeof(WCHAR);
5165 newval = msi_alloc(size);
5166 ptr = newval;
5167 if (!newval)
5168 {
5169 res = ERROR_OUTOFMEMORY;
5170 goto done;
5171 }
5172
5173 if (!(flags & ENV_MOD_MASK))
5174 lstrcpyW(newval, value);
5175 else
5176 {
5177 if (flags & ENV_MOD_PREFIX)
5178 {
5179 lstrcpyW(newval, value);
5180 lstrcatW(newval, semicolon);
5181 ptr = newval + lstrlenW(value) + 1;
5182 }
5183
5184 lstrcpyW(ptr, data);
5185
5186 if (flags & ENV_MOD_APPEND)
5187 {
5188 lstrcatW(newval, semicolon);
5189 lstrcatW(newval, value);
5190 }
5191 }
5192 }
5193 else
5194 {
5195 size = (lstrlenW(value) + 1) * sizeof(WCHAR);
5196 newval = msi_alloc(size);
5197 if (!newval)
5198 {
5199 res = ERROR_OUTOFMEMORY;
5200 goto done;
5201 }
5202
5203 lstrcpyW(newval, value);
5204 }
5205
5206 TRACE("setting %s to %s\n", debugstr_w(name), debugstr_w(newval));
5207 res = RegSetValueExW(env, name, 0, type, (LPVOID)newval, size);
5208
5209 done:
5210 if (env) RegCloseKey(env);
5211 msi_free(deformatted);
5212 msi_free(data);
5213 msi_free(newval);
5214 return res;
5215 }
5216
5217 static UINT ACTION_WriteEnvironmentStrings( MSIPACKAGE *package )
5218 {
5219 UINT rc;
5220 MSIQUERY * view;
5221 static const WCHAR ExecSeqQuery[] =
5222 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5223 '`','E','n','v','i','r','o','n','m','e','n','t','`',0};
5224 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
5225 if (rc != ERROR_SUCCESS)
5226 return ERROR_SUCCESS;
5227
5228 rc = MSI_IterateRecords(view, NULL, ITERATE_WriteEnvironmentString, package);
5229 msiobj_release(&view->hdr);
5230
5231 return rc;
5232 }
5233
5234 #define is_dot_dir(x) ((x[0] == '.') && ((x[1] == 0) || ((x[1] == '.') && (x[2] == 0))))
5235
5236 typedef struct
5237 {
5238 struct list entry;
5239 LPWSTR sourcename;
5240 LPWSTR destname;
5241 LPWSTR source;
5242 LPWSTR dest;
5243 } FILE_LIST;
5244
5245 static BOOL msi_move_file(LPCWSTR source, LPCWSTR dest, int options)
5246 {
5247 BOOL ret;
5248
5249 if (GetFileAttributesW(source) == FILE_ATTRIBUTE_DIRECTORY ||
5250 GetFileAttributesW(dest) == FILE_ATTRIBUTE_DIRECTORY)
5251 {
5252 WARN("Source or dest is directory, not moving\n");
5253 return FALSE;
5254 }
5255
5256 if (options == msidbMoveFileOptionsMove)
5257 {
5258 TRACE("moving %s -> %s\n", debugstr_w(source), debugstr_w(dest));
5259 ret = MoveFileExW(source, dest, MOVEFILE_REPLACE_EXISTING);
5260 if (!ret)
5261 {
5262 WARN("MoveFile failed: %d\n", GetLastError());
5263 return FALSE;
5264 }
5265 }
5266 else
5267 {
5268 TRACE("copying %s -> %s\n", debugstr_w(source), debugstr_w(dest));
5269 ret = CopyFileW(source, dest, FALSE);
5270 if (!ret)
5271 {
5272 WARN("CopyFile failed: %d\n", GetLastError());
5273 return FALSE;
5274 }
5275 }
5276
5277 return TRUE;
5278 }
5279
5280 static LPWSTR wildcard_to_file(LPWSTR wildcard, LPWSTR filename)
5281 {
5282 LPWSTR path, ptr;
5283 DWORD dirlen, pathlen;
5284
5285 ptr = strrchrW(wildcard, '\\');
5286 dirlen = ptr - wildcard + 1;
5287
5288 pathlen = dirlen + lstrlenW(filename) + 1;
5289 path = msi_alloc(pathlen * sizeof(WCHAR));
5290
5291 lstrcpynW(path, wildcard, dirlen + 1);
5292 lstrcatW(path, filename);
5293
5294 return path;
5295 }
5296
5297 static void free_file_entry(FILE_LIST *file)
5298 {
5299 msi_free(file->source);
5300 msi_free(file->dest);
5301 msi_free(file);
5302 }
5303
5304 static void free_list(FILE_LIST *list)
5305 {
5306 while (!list_empty(&list->entry))
5307 {
5308 FILE_LIST *file = LIST_ENTRY(list_head(&list->entry), FILE_LIST, entry);
5309
5310 list_remove(&file->entry);
5311 free_file_entry(file);
5312 }
5313 }
5314
5315 static BOOL add_wildcard(FILE_LIST *files, LPWSTR source, LPWSTR dest)
5316 {
5317 FILE_LIST *new, *file;
5318 LPWSTR ptr, filename;
5319 DWORD size;
5320
5321 new = msi_alloc_zero(sizeof(FILE_LIST));
5322 if (!new)
5323 return FALSE;
5324
5325 new->source = strdupW(source);
5326 ptr = strrchrW(dest, '\\') + 1;
5327 filename = strrchrW(new->source, '\\') + 1;
5328
5329 new->sourcename = filename;
5330
5331 if (*ptr)
5332 new->destname = ptr;
5333 else
5334 new->destname = new->sourcename;
5335
5336 size = (ptr - dest) + lstrlenW(filename) + 1;
5337 new->dest = msi_alloc(size * sizeof(WCHAR));
5338 if (!new->dest)
5339 {
5340 free_file_entry(new);
5341 return FALSE;
5342 }
5343
5344 lstrcpynW(new->dest, dest, ptr - dest + 1);
5345 lstrcatW(new->dest, filename);
5346
5347 if (list_empty(&files->entry))
5348 {
5349 list_add_head(&files->entry, &new->entry);
5350 return TRUE;
5351 }
5352
5353 LIST_FOR_EACH_ENTRY(file, &files->entry, FILE_LIST, entry)
5354 {
5355 if (lstrcmpW(source, file->source) < 0)
5356 {
5357 list_add_before(&file->entry, &new->entry);
5358 return TRUE;
5359 }
5360 }
5361
5362 list_add_after(&file->entry, &new->entry);
5363 return TRUE;
5364 }
5365
5366 static BOOL move_files_wildcard(LPWSTR source, LPWSTR dest, int options)
5367 {
5368 WIN32_FIND_DATAW wfd;
5369 HANDLE hfile;
5370 LPWSTR path;
5371 BOOL res;
5372 FILE_LIST files, *file;
5373 DWORD size;
5374
5375 hfile = FindFirstFileW(source, &wfd);
5376 if (hfile == INVALID_HANDLE_VALUE) return FALSE;
5377
5378 list_init(&files.entry);
5379
5380 for (res = TRUE; res; res = FindNextFileW(hfile, &wfd))
5381 {
5382 if (is_dot_dir(wfd.cFileName)) continue;
5383
5384 path = wildcard_to_file(source, wfd.cFileName);
5385 if (!path)
5386 {
5387 res = FALSE;
5388 goto done;
5389 }
5390
5391 add_wildcard(&files, path, dest);
5392 msi_free(path);
5393 }
5394
5395 /* no files match the wildcard */
5396 if (list_empty(&files.entry))
5397 goto done;
5398
5399 /* only the first wildcard match gets renamed to dest */
5400 file = LIST_ENTRY(list_head(&files.entry), FILE_LIST, entry);
5401 size = (strrchrW(file->dest, '\\') - file->dest) + lstrlenW(file->destname) + 2;
5402 file->dest = msi_realloc(file->dest, size * sizeof(WCHAR));
5403 if (!file->dest)
5404 {
5405 res = FALSE;
5406 goto done;
5407 }
5408
5409 lstrcpyW(strrchrW(file->dest, '\\') + 1, file->destname);
5410
5411 while (!list_empty(&files.entry))
5412 {
5413 file = LIST_ENTRY(list_head(&files.entry), FILE_LIST, entry);
5414
5415 msi_move_file((LPCWSTR)file->source, (LPCWSTR)file->dest, options);
5416
5417 list_remove(&file->entry);
5418 free_file_entry(file);
5419 }
5420
5421 res = TRUE;
5422
5423 done:
5424 free_list(&files);
5425 FindClose(hfile);
5426 return res;
5427 }
5428
5429 static UINT ITERATE_MoveFiles( MSIRECORD *rec, LPVOID param )
5430 {
5431 MSIPACKAGE *package = param;
5432 MSICOMPONENT *comp;
5433 LPCWSTR sourcename, destname;
5434 LPWSTR sourcedir = NULL, destdir = NULL;
5435 LPWSTR source = NULL, dest = NULL;
5436 int options;
5437 DWORD size;
5438 BOOL ret, wildcards;
5439
5440 static const WCHAR backslash[] = {'\\',0};
5441
5442 comp = get_loaded_component(package, MSI_RecordGetString(rec, 2));
5443 if (!comp || !comp->Enabled ||
5444 !(comp->Action & (INSTALLSTATE_LOCAL | INSTALLSTATE_SOURCE)))
5445 {
5446 TRACE("Component not set for install, not moving file\n");
5447 return ERROR_SUCCESS;
5448 }
5449
5450 sourcename = MSI_RecordGetString(rec, 3);
5451 destname = MSI_RecordGetString(rec, 4);
5452 options = MSI_RecordGetInteger(rec, 7);
5453
5454 sourcedir = msi_dup_property(package, MSI_RecordGetString(rec, 5));
5455 if (!sourcedir)
5456 goto done;
5457
5458 destdir = msi_dup_property(package, MSI_RecordGetString(rec, 6));
5459 if (!destdir)
5460 goto done;
5461
5462 if (!sourcename)
5463 {
5464 if (GetFileAttributesW(sourcedir) == INVALID_FILE_ATTRIBUTES)
5465 goto done;
5466
5467 source = strdupW(sourcedir);
5468 if (!source)
5469 goto done;
5470 }
5471 else
5472 {
5473 size = lstrlenW(sourcedir) + lstrlenW(sourcename) + 2;
5474 source = msi_alloc(size * sizeof(WCHAR));
5475 if (!source)
5476 goto done;
5477
5478 lstrcpyW(source, sourcedir);
5479 if (source[lstrlenW(source) - 1] != '\\')
5480 lstrcatW(source, backslash);
5481 lstrcatW(source, sourcename);
5482 }
5483
5484 wildcards = strchrW(source, '*') || strchrW(source, '?');
5485
5486 if (!destname && !wildcards)
5487 {
5488 destname = strdupW(sourcename);
5489 if (!destname)
5490 goto done;
5491 }
5492
5493 size = 0;
5494 if (destname)
5495 size = lstrlenW(destname);
5496
5497 size += lstrlenW(destdir) + 2;
5498 dest = msi_alloc(size * sizeof(WCHAR));
5499 if (!dest)
5500 goto done;
5501
5502 lstrcpyW(dest, destdir);
5503 if (dest[lstrlenW(dest) - 1] != '\\')
5504 lstrcatW(dest, backslash);
5505
5506 if (destname)
5507 lstrcatW(dest, destname);
5508
5509 if (GetFileAttributesW(destdir) == INVALID_FILE_ATTRIBUTES)
5510 {
5511 ret = CreateDirectoryW(destdir, NULL);
5512 if (!ret)
5513 {
5514 WARN("CreateDirectory failed: %d\n", GetLastError());
5515 return ERROR_SUCCESS;
5516 }
5517 }
5518
5519 if (!wildcards)
5520 msi_move_file(source, dest, options);
5521 else
5522 move_files_wildcard(source, dest, options);
5523
5524 done:
5525 msi_free(sourcedir);
5526 msi_free(destdir);
5527 msi_free(source);
5528 msi_free(dest);
5529
5530 return ERROR_SUCCESS;
5531 }
5532
5533 static UINT ACTION_MoveFiles( MSIPACKAGE *package )
5534 {
5535 UINT rc;
5536 MSIQUERY *view;
5537
5538 static const WCHAR ExecSeqQuery[] =
5539 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5540 '`','M','o','v','e','F','i','l','e','`',0};
5541
5542 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
5543 if (rc != ERROR_SUCCESS)
5544 return ERROR_SUCCESS;
5545
5546 rc = MSI_IterateRecords(view, NULL, ITERATE_MoveFiles, package);
5547 msiobj_release(&view->hdr);
5548
5549 return rc;
5550 }
5551
5552 static HRESULT (WINAPI *pCreateAssemblyCache)(IAssemblyCache **ppAsmCache,
5553 DWORD dwReserved);
5554 static HRESULT (WINAPI *pLoadLibraryShim)(LPCWSTR szDllName, LPCWSTR szVersion,
5555 LPVOID pvReserved, HMODULE *phModDll);
5556
5557 static BOOL init_functionpointers(void)
5558 {
5559 HRESULT hr;
5560 HMODULE hfusion;
5561 HMODULE hmscoree;
5562
5563 static const WCHAR szFusion[] = {'f','u','s','i','o','n','.','d','l','l',0};
5564
5565 hmscoree = LoadLibraryA("mscoree.dll");
5566 if (!hmscoree)
5567 {
5568 WARN("mscoree.dll not available\n");
5569 return FALSE;
5570 }
5571
5572 pLoadLibraryShim = (void *)GetProcAddress(hmscoree, "LoadLibraryShim");
5573 if (!pLoadLibraryShim)
5574 {
5575 WARN("LoadLibraryShim not available\n");
5576 FreeLibrary(hmscoree);
5577 return FALSE;
5578 }
5579
5580 hr = pLoadLibraryShim(szFusion, NULL, NULL, &hfusion);
5581 if (FAILED(hr))
5582 {
5583 WARN("fusion.dll not available\n");
5584 FreeLibrary(hmscoree);
5585 return FALSE;
5586 }
5587
5588 pCreateAssemblyCache = (void *)GetProcAddress(hfusion, "CreateAssemblyCache");
5589
5590 FreeLibrary(hmscoree);
5591 return TRUE;
5592 }
5593
5594 static UINT install_assembly(LPWSTR path)
5595 {
5596 IAssemblyCache *cache;
5597 HRESULT hr;
5598 UINT r = ERROR_FUNCTION_FAILED;
5599
5600 if (!init_functionpointers() || !pCreateAssemblyCache)
5601 return ERROR_FUNCTION_FAILED;
5602
5603 hr = pCreateAssemblyCache(&cache, 0);
5604 if (FAILED(hr))
5605 goto done;
5606
5607 hr = IAssemblyCache_InstallAssembly(cache, 0, path, NULL);
5608 if (FAILED(hr))
5609 ERR("Failed to install assembly: %s %08x\n", debugstr_w(path), hr);
5610
5611 r = ERROR_SUCCESS;
5612
5613 done:
5614 IAssemblyCache_Release(cache);
5615 return r;
5616 }
5617
5618 static UINT ITERATE_PublishAssembly( MSIRECORD *rec, LPVOID param )
5619 {
5620 MSIPACKAGE *package = param;
5621 MSICOMPONENT *comp;
5622 MSIFEATURE *feature;
5623 MSIFILE *file;
5624 WCHAR path[MAX_PATH];
5625 LPCWSTR app;
5626 DWORD attr;
5627 UINT r;
5628
5629 comp = get_loaded_component(package, MSI_RecordGetString(rec, 1));
5630 if (!comp || !comp->Enabled ||
5631 !(comp->Action & (INSTALLSTATE_LOCAL | INSTALLSTATE_SOURCE)))
5632 {
5633 ERR("Component not set for install, not publishing assembly\n");
5634 return ERROR_SUCCESS;
5635 }
5636
5637 feature = find_feature_by_name(package, MSI_RecordGetString(rec, 2));
5638 if (feature)
5639 msi_feature_set_state(feature, INSTALLSTATE_LOCAL);
5640
5641 if (MSI_RecordGetString(rec, 3))
5642 FIXME("Manifest unhandled\n");
5643
5644 app = MSI_RecordGetString(rec, 4);
5645 if (app)
5646 {
5647 FIXME("Assembly should be privately installed\n");
5648 return ERROR_SUCCESS;
5649 }
5650
5651 attr = MSI_RecordGetInteger(rec, 5);
5652 if (attr == msidbAssemblyAttributesWin32)
5653 {
5654 FIXME("Win32 assemblies not handled\n");
5655 return ERROR_SUCCESS;
5656 }
5657
5658 /* FIXME: extract all files belonging to this component */
5659 file = msi_find_file(package, comp->KeyPath);
5660
5661 GetTempPathW(MAX_PATH, path);
5662 r = msi_extract_file(package, file, path);
5663 if (r != ERROR_SUCCESS)
5664 {
5665 ERR("Failed to extract temporary assembly\n");
5666 return r;
5667 }
5668
5669 PathAddBackslashW(path);
5670 lstrcatW(path, file->FileName);
5671
5672 r = install_assembly(path);
5673 if (r != ERROR_SUCCESS)
5674 ERR("Failed to install assembly\n");
5675
5676 /* FIXME: write Installer assembly reg values */
5677
5678 return r;
5679 }
5680
5681 static UINT ACTION_MsiPublishAssemblies( MSIPACKAGE *package )
5682 {
5683 UINT rc;
5684 MSIQUERY *view;
5685
5686 static const WCHAR ExecSeqQuery[] =
5687 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5688 '`','M','s','i','A','s','s','e','m','b','l','y','`',0};
5689
5690 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
5691 if (rc != ERROR_SUCCESS)
5692 return ERROR_SUCCESS;
5693
5694 rc = MSI_IterateRecords(view, NULL, ITERATE_PublishAssembly, package);
5695 msiobj_release(&view->hdr);
5696
5697 return rc;
5698 }
5699
5700 static UINT msi_unimplemented_action_stub( MSIPACKAGE *package,
5701 LPCSTR action, LPCWSTR table )
5702 {
5703 static const WCHAR query[] = {
5704 'S','E','L','E','C','T',' ','*',' ',
5705 'F','R','O','M',' ','`','%','s','`',0 };
5706 MSIQUERY *view = NULL;
5707 DWORD count = 0;
5708 UINT r;
5709
5710 r = MSI_OpenQuery( package->db, &view, query, table );
5711 if (r == ERROR_SUCCESS)
5712 {
5713 r = MSI_IterateRecords(view, &count, NULL, package);
5714 msiobj_release(&view->hdr);
5715 }
5716
5717 if (count)
5718 FIXME("%s -> %u ignored %s table values\n",
5719 action, count, debugstr_w(table));
5720
5721 return ERROR_SUCCESS;
5722 }
5723
5724 static UINT ACTION_AllocateRegistrySpace( MSIPACKAGE *package )
5725 {
5726 TRACE("%p\n", package);
5727 return ERROR_SUCCESS;
5728 }
5729
5730 static UINT ACTION_RemoveIniValues( MSIPACKAGE *package )
5731 {
5732 static const WCHAR table[] =
5733 {'R','e','m','o','v','e','I','n','i','F','i','l','e',0 };
5734 return msi_unimplemented_action_stub( package, "RemoveIniValues", table );
5735 }
5736
5737 static UINT ACTION_PatchFiles( MSIPACKAGE *package )
5738 {
5739 static const WCHAR table[] = { 'P','a','t','c','h',0 };
5740 return msi_unimplemented_action_stub( package, "PatchFiles", table );
5741 }
5742
5743 static UINT ACTION_BindImage( MSIPACKAGE *package )
5744 {
5745 static const WCHAR table[] = { 'B','i','n','d','I','m','a','g','e',0 };
5746 return msi_unimplemented_action_stub( package, "BindImage", table );
5747 }
5748
5749 static UINT ACTION_IsolateComponents( MSIPACKAGE *package )
5750 {
5751 static const WCHAR table[] = {
5752 'I','s','o','l','a','t','e','C','o','m','p','o','n','e','n','t',0 };
5753 return msi_unimplemented_action_stub( package, "IsolateComponents", table );
5754 }
5755
5756 static UINT ACTION_MigrateFeatureStates( MSIPACKAGE *package )
5757 {
5758 static const WCHAR table[] = { 'U','p','g','r','a','d','e',0 };
5759 return msi_unimplemented_action_stub( package, "MigrateFeatureStates", table );
5760 }
5761
5762 static UINT ACTION_SelfUnregModules( MSIPACKAGE *package )
5763 {
5764 static const WCHAR table[] = { 'S','e','l','f','R','e','g',0 };
5765 return msi_unimplemented_action_stub( package, "SelfUnregModules", table );
5766 }
5767
5768 static UINT ACTION_DeleteServices( MSIPACKAGE *package )
5769 {
5770 static const WCHAR table[] = {
5771 'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
5772 return msi_unimplemented_action_stub( package, "DeleteServices", table );
5773 }
5774 static UINT ACTION_ValidateProductID( MSIPACKAGE *package )
5775 {
5776 static const WCHAR table[] = {
5777 'P','r','o','d','u','c','t','I','D',0 };
5778 return msi_unimplemented_action_stub( package, "ValidateProductID", table );
5779 }
5780
5781 static UINT ACTION_RemoveEnvironmentStrings( MSIPACKAGE *package )
5782 {
5783 static const WCHAR table[] = {
5784 'E','n','v','i','r','o','n','m','e','n','t',0 };
5785 return msi_unimplemented_action_stub( package, "RemoveEnvironmentStrings", table );
5786 }
5787
5788 static UINT ACTION_MsiUnpublishAssemblies( MSIPACKAGE *package )
5789 {
5790 static const WCHAR table[] = {
5791 'M','s','i','A','s','s','e','m','b','l','y',0 };
5792 return msi_unimplemented_action_stub( package, "MsiUnpublishAssemblies", table );
5793 }
5794
5795 static UINT ACTION_UnregisterFonts( MSIPACKAGE *package )
5796 {
5797 static const WCHAR table[] = { 'F','o','n','t',0 };
5798 return msi_unimplemented_action_stub( package, "UnregisterFonts", table );
5799 }
5800
5801 static UINT ACTION_RMCCPSearch( MSIPACKAGE *package )
5802 {
5803 static const WCHAR table[] = { 'C','C','P','S','e','a','r','c','h',0 };
5804 return msi_unimplemented_action_stub( package, "RMCCPSearch", table );
5805 }
5806
5807 static UINT ACTION_RegisterComPlus( MSIPACKAGE *package )
5808 {
5809 static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
5810 return msi_unimplemented_action_stub( package, "RegisterComPlus", table );
5811 }
5812
5813 static UINT ACTION_UnregisterComPlus( MSIPACKAGE *package )
5814 {
5815 static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
5816 return msi_unimplemented_action_stub( package, "UnregisterComPlus", table );
5817 }
5818
5819 static UINT ACTION_InstallSFPCatalogFile( MSIPACKAGE *package )
5820 {
5821 static const WCHAR table[] = { 'S','F','P','C','a','t','a','l','o','g',0 };
5822 return msi_unimplemented_action_stub( package, "InstallSFPCatalogFile", table );
5823 }
5824
5825 static UINT ACTION_RemoveDuplicateFiles( MSIPACKAGE *package )
5826 {
5827 static const WCHAR table[] = { 'D','u','p','l','i','c','a','t','e','F','i','l','e',0 };
5828 return msi_unimplemented_action_stub( package, "RemoveDuplicateFiles", table );
5829 }
5830
5831 static UINT ACTION_RemoveExistingProducts( MSIPACKAGE *package )
5832 {
5833 static const WCHAR table[] = { 'U','p','g','r','a','d','e',0 };
5834 return msi_unimplemented_action_stub( package, "RemoveExistingProducts", table );
5835 }
5836
5837 static UINT ACTION_RemoveFolders( MSIPACKAGE *package )
5838 {
5839 static const WCHAR table[] = { 'C','r','e','a','t','e','F','o','l','d','e','r',0 };
5840 return msi_unimplemented_action_stub( package, "RemoveFolders", table );
5841 }
5842
5843 static UINT ACTION_RemoveODBC( MSIPACKAGE *package )
5844 {
5845 static const WCHAR table[] = { 'O','D','B','C','D','r','i','v','e','r',0 };
5846 return msi_unimplemented_action_stub( package, "RemoveODBC", table );
5847 }
5848
5849 static UINT ACTION_RemoveRegistryValues( MSIPACKAGE *package )
5850 {
5851 static const WCHAR table[] = { 'R','e','m','o','v','e','R','e','g','i','s','t','r','y',0 };
5852 return msi_unimplemented_action_stub( package, "RemoveRegistryValues", table );
5853 }
5854
5855 static UINT ACTION_RemoveShortcuts( MSIPACKAGE *package )
5856 {
5857 static const WCHAR table[] = { 'S','h','o','r','t','c','u','t',0 };
5858 return msi_unimplemented_action_stub( package, "RemoveShortcuts", table );
5859 }
5860
5861 static UINT ACTION_UnpublishComponents( MSIPACKAGE *package )
5862 {
5863 static const WCHAR table[] = { 'P','u','b','l','i','s','h','C','o','m','p','o','n','e','n','t',0 };
5864 return msi_unimplemented_action_stub( package, "UnpublishComponents", table );
5865 }
5866
5867 static UINT ACTION_UnregisterClassInfo( MSIPACKAGE *package )
5868 {
5869 static const WCHAR table[] = { 'A','p','p','I','d',0 };
5870 return msi_unimplemented_action_stub( package, "UnregisterClassInfo", table );
5871 }
5872
5873 static UINT ACTION_UnregisterExtensionInfo( MSIPACKAGE *package )
5874 {
5875 static const WCHAR table[] = { 'E','x','t','e','n','s','i','o','n',0 };
5876 return msi_unimplemented_action_stub( package, "UnregisterExtensionInfo", table );
5877 }
5878
5879 static UINT ACTION_UnregisterMIMEInfo( MSIPACKAGE *package )
5880 {
5881 static const WCHAR table[] = { 'M','I','M','E',0 };
5882 return msi_unimplemented_action_stub( package, "UnregisterMIMEInfo", table );
5883 }
5884
5885 static UINT ACTION_UnregisterProgIdInfo( MSIPACKAGE *package )
5886 {
5887 static const WCHAR table[] = { 'P','r','o','g','I','d',0 };
5888 return msi_unimplemented_action_stub( package, "UnregisterProgIdInfo", table );
5889 }
5890
5891 static UINT ACTION_UnregisterTypeLibraries( MSIPACKAGE *package )
5892 {
5893 static const WCHAR table[] = { 'T','y','p','e','L','i','b',0 };
5894 return msi_unimplemented_action_stub( package, "UnregisterTypeLibraries", table );
5895 }
5896
5897 static const struct _actions StandardActions[] = {
5898 { szAllocateRegistrySpace, ACTION_AllocateRegistrySpace },
5899 { szAppSearch, ACTION_AppSearch },
5900 { szBindImage, ACTION_BindImage },
5901 { szCCPSearch, ACTION_CCPSearch },
5902 { szCostFinalize, ACTION_CostFinalize },
5903 { szCostInitialize, ACTION_CostInitialize },
5904 { szCreateFolders, ACTION_CreateFolders },
5905 { szCreateShortcuts, ACTION_CreateShortcuts },
5906 { szDeleteServices, ACTION_DeleteServices },
5907 { szDisableRollback, NULL },
5908 { szDuplicateFiles, ACTION_DuplicateFiles },
5909 { szExecuteAction, ACTION_ExecuteAction },
5910 { szFileCost, ACTION_FileCost },
5911 { szFindRelatedProducts, ACTION_FindRelatedProducts },
5912 { szForceReboot, ACTION_ForceReboot },
5913 { szInstallAdminPackage, NULL },
5914 { szInstallExecute, ACTION_InstallExecute },
5915 { szInstallExecuteAgain, ACTION_InstallExecute },
5916 { szInstallFiles, ACTION_InstallFiles},
5917 { szInstallFinalize, ACTION_InstallFinalize },
5918 { szInstallInitialize, ACTION_InstallInitialize },
5919 { szInstallSFPCatalogFile, ACTION_InstallSFPCatalogFile },
5920 { szInstallValidate, ACTION_InstallValidate },
5921 { szIsolateComponents, ACTION_IsolateComponents },
5922 { szLaunchConditions, ACTION_LaunchConditions },
5923 { szMigrateFeatureStates, ACTION_MigrateFeatureStates },
5924 { szMoveFiles, ACTION_MoveFiles },
5925 { szMsiPublishAssemblies, ACTION_MsiPublishAssemblies },
5926 { szMsiUnpublishAssemblies, ACTION_MsiUnpublishAssemblies },
5927 { szInstallODBC, ACTION_InstallODBC },
5928 { szInstallServices, ACTION_InstallServices },
5929 { szPatchFiles, ACTION_PatchFiles },
5930 { szProcessComponents, ACTION_ProcessComponents },
5931 { szPublishComponents, ACTION_PublishComponents },
5932 { szPublishFeatures, ACTION_PublishFeatures },
5933 { szPublishProduct, ACTION_PublishProduct },
5934 { szRegisterClassInfo, ACTION_RegisterClassInfo },
5935 { szRegisterComPlus, ACTION_RegisterComPlus},
5936 { szRegisterExtensionInfo, ACTION_RegisterExtensionInfo },
5937 { szRegisterFonts, ACTION_RegisterFonts },
5938 { szRegisterMIMEInfo, ACTION_RegisterMIMEInfo },
5939 { szRegisterProduct, ACTION_RegisterProduct },
5940 { szRegisterProgIdInfo, ACTION_RegisterProgIdInfo },
5941 { szRegisterTypeLibraries, ACTION_RegisterTypeLibraries },
5942 { szRegisterUser, ACTION_RegisterUser },
5943 { szRemoveDuplicateFiles, ACTION_RemoveDuplicateFiles },
5944 { szRemoveEnvironmentStrings, ACTION_RemoveEnvironmentStrings },
5945 { szRemoveExistingProducts, ACTION_RemoveExistingProducts },
5946 { szRemoveFiles, ACTION_RemoveFiles },
5947 { szRemoveFolders, ACTION_RemoveFolders },
5948 { szRemoveIniValues, ACTION_RemoveIniValues },
5949 { szRemoveODBC, ACTION_RemoveODBC },
5950 { szRemoveRegistryValues, ACTION_RemoveRegistryValues },
5951 { szRemoveShortcuts, ACTION_RemoveShortcuts },
5952 { szResolveSource, ACTION_ResolveSource },
5953 { szRMCCPSearch, ACTION_RMCCPSearch },
5954 { szScheduleReboot, NULL },
5955 { szSelfRegModules, ACTION_SelfRegModules },
5956 { szSelfUnregModules, ACTION_SelfUnregModules },
5957 { szSetODBCFolders, NULL },
5958 { szStartServices, ACTION_StartServices },
5959 { szStopServices, ACTION_StopServices },
5960 { szUnpublishComponents, ACTION_UnpublishComponents },
5961 { szUnpublishFeatures, ACTION_UnpublishFeatures },
5962 { szUnregisterClassInfo, ACTION_UnregisterClassInfo },
5963 { szUnregisterComPlus, ACTION_UnregisterComPlus },
5964 { szUnregisterExtensionInfo, ACTION_UnregisterExtensionInfo },
5965 { szUnregisterFonts, ACTION_UnregisterFonts },
5966 { szUnregisterMIMEInfo, ACTION_UnregisterMIMEInfo },
5967 { szUnregisterProgIdInfo, ACTION_UnregisterProgIdInfo },
5968 { szUnregisterTypeLibraries, ACTION_UnregisterTypeLibraries },
5969 { szValidateProductID, ACTION_ValidateProductID },
5970 { szWriteEnvironmentStrings, ACTION_WriteEnvironmentStrings },
5971 { szWriteIniValues, ACTION_WriteIniValues },
5972 { szWriteRegistryValues, ACTION_WriteRegistryValues },
5973 { NULL, NULL },
5974 };
5975
5976 static BOOL ACTION_HandleStandardAction(MSIPACKAGE *package, LPCWSTR action,
5977 UINT* rc, BOOL force )
5978 {
5979 BOOL ret = FALSE;
5980 BOOL run = force;
5981 int i;
5982
5983 if (!run && !package->script->CurrentlyScripting)
5984 run = TRUE;
5985
5986 if (!run)
5987 {
5988 if (strcmpW(action,szInstallFinalize) == 0 ||
5989 strcmpW(action,szInstallExecute) == 0 ||
5990 strcmpW(action,szInstallExecuteAgain) == 0)
5991 run = TRUE;
5992 }
5993
5994 i = 0;
5995 while (StandardActions[i].action != NULL)
5996 {
5997 if (strcmpW(StandardActions[i].action, action)==0)
5998 {
5999 if (!run)
6000 {
6001 ui_actioninfo(package, action, TRUE, 0);
6002 *rc = schedule_action(package,INSTALL_SCRIPT,action);
6003 ui_actioninfo(package, action, FALSE, *rc);
6004 }
6005 else
6006 {
6007 ui_actionstart(package, action);
6008 if (StandardActions[i].handler)
6009 {
6010 *rc = StandardActions[i].handler(package);
6011 }
6012 else
6013 {
6014 FIXME("unhandled standard action %s\n",debugstr_w(action));
6015 *rc = ERROR_SUCCESS;
6016 }
6017 }
6018 ret = TRUE;
6019 break;
6020 }
6021 i++;
6022 }
6023 return ret;
6024 }
Maarten's multimedia branch