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