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