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