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