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