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