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