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