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