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