?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implement NtAccessCheck.
[wine/gsoc-2012-control.git] / dlls / msi / action.c
bloba115a422bf0be525f18a44a1c240d0b59a0d9ec6
1 /*
2 * Implementation of the Microsoft Installer (msi.dll)
3 *
4 * Copyright 2004 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 #include <stdio.h>
31
32 #define COBJMACROS
33
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winerror.h"
37 #include "winreg.h"
38 #include "wine/debug.h"
39 #include "fdi.h"
40 #include "msi.h"
41 #include "msiquery.h"
42 #include "msidefs.h"
43 #include "msvcrt/fcntl.h"
44 #include "objbase.h"
45 #include "objidl.h"
46 #include "msipriv.h"
47 #include "winnls.h"
48 #include "winuser.h"
49 #include "shlobj.h"
50 #include "wine/unicode.h"
51 #include "winver.h"
52 #include "action.h"
53
54 #define REG_PROGRESS_VALUE 13200
55 #define COMPONENT_PROGRESS_VALUE 24000
56
57 WINE_DEFAULT_DEBUG_CHANNEL(msi);
58
59 /*
60 * Prototypes
61 */
62 static UINT ACTION_ProcessExecSequence(MSIPACKAGE *package, BOOL UIran);
63 static UINT ACTION_ProcessUISequence(MSIPACKAGE *package);
64 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq, BOOL UI);
65 static UINT build_icon_path(MSIPACKAGE *package, LPCWSTR icon_name,
66 LPWSTR *FilePath);
67
68 /*
69 * action handlers
70 */
71 typedef UINT (*STANDARDACTIONHANDLER)(MSIPACKAGE*);
72
73 static UINT ACTION_LaunchConditions(MSIPACKAGE *package);
74 static UINT ACTION_CostInitialize(MSIPACKAGE *package);
75 static UINT ACTION_CreateFolders(MSIPACKAGE *package);
76 static UINT ACTION_CostFinalize(MSIPACKAGE *package);
77 static UINT ACTION_FileCost(MSIPACKAGE *package);
78 static UINT ACTION_InstallFiles(MSIPACKAGE *package);
79 static UINT ACTION_DuplicateFiles(MSIPACKAGE *package);
80 static UINT ACTION_WriteRegistryValues(MSIPACKAGE *package);
81 static UINT ACTION_InstallInitialize(MSIPACKAGE *package);
82 static UINT ACTION_InstallValidate(MSIPACKAGE *package);
83 static UINT ACTION_ProcessComponents(MSIPACKAGE *package);
84 static UINT ACTION_RegisterTypeLibraries(MSIPACKAGE *package);
85 static UINT ACTION_RegisterClassInfo(MSIPACKAGE *package);
86 static UINT ACTION_RegisterProgIdInfo(MSIPACKAGE *package);
87 static UINT ACTION_RegisterExtensionInfo(MSIPACKAGE *package);
88 static UINT ACTION_RegisterMIMEInfo(MSIPACKAGE *package);
89 static UINT ACTION_RegisterUser(MSIPACKAGE *package);
90 static UINT ACTION_CreateShortcuts(MSIPACKAGE *package);
91 static UINT ACTION_PublishProduct(MSIPACKAGE *package);
92 static UINT ACTION_WriteIniValues(MSIPACKAGE *package);
93 static UINT ACTION_SelfRegModules(MSIPACKAGE *package);
94 static UINT ACTION_PublishFeatures(MSIPACKAGE *package);
95 static UINT ACTION_RegisterProduct(MSIPACKAGE *package);
96 static UINT ACTION_InstallExecute(MSIPACKAGE *package);
97 static UINT ACTION_InstallFinalize(MSIPACKAGE *package);
98 static UINT ACTION_ForceReboot(MSIPACKAGE *package);
99 static UINT ACTION_ResolveSource(MSIPACKAGE *package);
100 static UINT ACTION_ExecuteAction(MSIPACKAGE *package);
101 static UINT ACTION_RegisterFonts(MSIPACKAGE *package);
102 static UINT ACTION_PublishComponents(MSIPACKAGE *package);
103
104
105 /*
106 * consts and values used
107 */
108 static const WCHAR cszSourceDir[] = {'S','o','u','r','c','e','D','i','r',0};
109 static const WCHAR cszRootDrive[] = {'R','O','O','T','D','R','I','V','E',0};
110 static const WCHAR cszTargetDir[] = {'T','A','R','G','E','T','D','I','R',0};
111 static const WCHAR cszTempFolder[]= {'T','e','m','p','F','o','l','d','e','r',0};
112 static const WCHAR cszDatabase[]={'D','A','T','A','B','A','S','E',0};
113 static const WCHAR c_colon[] = {'C',':','\\',0};
114 static const WCHAR szProductCode[]=
115 {'P','r','o','d','u','c','t','C','o','d','e',0};
116 static const WCHAR cszbs[]={'\\',0};
117 const static WCHAR szCreateFolders[] =
118 {'C','r','e','a','t','e','F','o','l','d','e','r','s',0};
119 const static WCHAR szCostFinalize[] =
120 {'C','o','s','t','F','i','n','a','l','i','z','e',0};
121 const static WCHAR szInstallFiles[] =
122 {'I','n','s','t','a','l','l','F','i','l','e','s',0};
123 const static WCHAR szDuplicateFiles[] =
124 {'D','u','p','l','i','c','a','t','e','F','i','l','e','s',0};
125 const static WCHAR szWriteRegistryValues[] =
126 {'W','r','i','t','e','R','e','g','i','s','t','r','y',
127 'V','a','l','u','e','s',0};
128 const static WCHAR szCostInitialize[] =
129 {'C','o','s','t','I','n','i','t','i','a','l','i','z','e',0};
130 const static WCHAR szFileCost[] =
131 {'F','i','l','e','C','o','s','t',0};
132 const static WCHAR szInstallInitialize[] =
133 {'I','n','s','t','a','l','l','I','n','i','t','i','a','l','i','z','e',0};
134 const static WCHAR szInstallValidate[] =
135 {'I','n','s','t','a','l','l','V','a','l','i','d','a','t','e',0};
136 const static WCHAR szLaunchConditions[] =
137 {'L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','s',0};
138 const static WCHAR szProcessComponents[] =
139 {'P','r','o','c','e','s','s','C','o','m','p','o','n','e','n','t','s',0};
140 const static WCHAR szRegisterTypeLibraries[] =
141 {'R','e','g','i','s','t','e','r','T','y','p','e',
142 'L','i','b','r','a','r','i','e','s',0};
143 const static WCHAR szRegisterClassInfo[] =
144 {'R','e','g','i','s','t','e','r','C','l','a','s','s','I','n','f','o',0};
145 const static WCHAR szRegisterProgIdInfo[] =
146 {'R','e','g','i','s','t','e','r','P','r','o','g','I','d','I','n','f','o',0};
147 const static WCHAR szCreateShortcuts[] =
148 {'C','r','e','a','t','e','S','h','o','r','t','c','u','t','s',0};
149 const static WCHAR szPublishProduct[] =
150 {'P','u','b','l','i','s','h','P','r','o','d','u','c','t',0};
151 const static WCHAR szWriteIniValues[] =
152 {'W','r','i','t','e','I','n','i','V','a','l','u','e','s',0};
153 const static WCHAR szSelfRegModules[] =
154 {'S','e','l','f','R','e','g','M','o','d','u','l','e','s',0};
155 const static WCHAR szPublishFeatures[] =
156 {'P','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
157 const static WCHAR szRegisterProduct[] =
158 {'R','e','g','i','s','t','e','r','P','r','o','d','u','c','t',0};
159 const static WCHAR szInstallExecute[] =
160 {'I','n','s','t','a','l','l','E','x','e','c','u','t','e',0};
161 const static WCHAR szInstallExecuteAgain[] =
162 {'I','n','s','t','a','l','l','E','x','e','c','u','t','e',
163 'A','g','a','i','n',0};
164 const static WCHAR szInstallFinalize[] =
165 {'I','n','s','t','a','l','l','F','i','n','a','l','i','z','e',0};
166 const static WCHAR szForceReboot[] =
167 {'F','o','r','c','e','R','e','b','o','o','t',0};
168 const static WCHAR szResolveSource[] =
169 {'R','e','s','o','l','v','e','S','o','u','r','c','e',0};
170 const static WCHAR szAppSearch[] =
171 {'A','p','p','S','e','a','r','c','h',0};
172 const static WCHAR szAllocateRegistrySpace[] =
173 {'A','l','l','o','c','a','t','e','R','e','g','i','s','t','r','y',
174 'S','p','a','c','e',0};
175 const static WCHAR szBindImage[] =
176 {'B','i','n','d','I','m','a','g','e',0};
177 const static WCHAR szCCPSearch[] =
178 {'C','C','P','S','e','a','r','c','h',0};
179 const static WCHAR szDeleteServices[] =
180 {'D','e','l','e','t','e','S','e','r','v','i','c','e','s',0};
181 const static WCHAR szDisableRollback[] =
182 {'D','i','s','a','b','l','e','R','o','l','l','b','a','c','k',0};
183 const static WCHAR szExecuteAction[] =
184 {'E','x','e','c','u','t','e','A','c','t','i','o','n',0};
185 const static WCHAR szFindRelatedProducts[] =
186 {'F','i','n','d','R','e','l','a','t','e','d',
187 'P','r','o','d','u','c','t','s',0};
188 const static WCHAR szInstallAdminPackage[] =
189 {'I','n','s','t','a','l','l','A','d','m','i','n',
190 'P','a','c','k','a','g','e',0};
191 const static WCHAR szInstallSFPCatalogFile[] =
192 {'I','n','s','t','a','l','l','S','F','P','C','a','t','a','l','o','g',
193 'F','i','l','e',0};
194 const static WCHAR szIsolateComponents[] =
195 {'I','s','o','l','a','t','e','C','o','m','p','o','n','e','n','t','s',0};
196 const static WCHAR szMigrateFeatureStates[] =
197 {'M','i','g','r','a','t','e','F','e','a','t','u','r','e',
198 'S','t','a','t','e','s',0};
199 const static WCHAR szMoveFiles[] =
200 {'M','o','v','e','F','i','l','e','s',0};
201 const static WCHAR szMsiPublishAssemblies[] =
202 {'M','s','i','P','u','b','l','i','s','h',
203 'A','s','s','e','m','b','l','i','e','s',0};
204 const static WCHAR szMsiUnpublishAssemblies[] =
205 {'M','s','i','U','n','p','u','b','l','i','s','h',
206 'A','s','s','e','m','b','l','i','e','s',0};
207 const static WCHAR szInstallODBC[] =
208 {'I','n','s','t','a','l','l','O','D','B','C',0};
209 const static WCHAR szInstallServices[] =
210 {'I','n','s','t','a','l','l','S','e','r','v','i','c','e','s',0};
211 const static WCHAR szPatchFiles[] =
212 {'P','a','t','c','h','F','i','l','e','s',0};
213 const static WCHAR szPublishComponents[] =
214 {'P','u','b','l','i','s','h','C','o','m','p','o','n','e','n','t','s',0};
215 const static WCHAR szRegisterComPlus[] =
216 {'R','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
217 const static WCHAR szRegisterExtensionInfo[] =
218 {'R','e','g','i','s','t','e','r','E','x','t','e','n','s','i','o','n',
219 'I','n','f','o',0};
220 const static WCHAR szRegisterFonts[] =
221 {'R','e','g','i','s','t','e','r','F','o','n','t','s',0};
222 const static WCHAR szRegisterMIMEInfo[] =
223 {'R','e','g','i','s','t','e','r','M','I','M','E','I','n','f','o',0};
224 const static WCHAR szRegisterUser[] =
225 {'R','e','g','i','s','t','e','r','U','s','e','r',0};
226 const static WCHAR szRemoveDuplicateFiles[] =
227 {'R','e','m','o','v','e','D','u','p','l','i','c','a','t','e',
228 'F','i','l','e','s',0};
229 const static WCHAR szRemoveEnvironmentStrings[] =
230 {'R','e','m','o','v','e','E','n','v','i','r','o','n','m','e','n','t',
231 'S','t','r','i','n','g','s',0};
232 const static WCHAR szRemoveExistingProducts[] =
233 {'R','e','m','o','v','e','E','x','i','s','t','i','n','g',
234 'P','r','o','d','u','c','t','s',0};
235 const static WCHAR szRemoveFiles[] =
236 {'R','e','m','o','v','e','F','i','l','e','s',0};
237 const static WCHAR szRemoveFolders[] =
238 {'R','e','m','o','v','e','F','o','l','d','e','r','s',0};
239 const static WCHAR szRemoveIniValues[] =
240 {'R','e','m','o','v','e','I','n','i','V','a','l','u','e','s',0};
241 const static WCHAR szRemoveODBC[] =
242 {'R','e','m','o','v','e','O','D','B','C',0};
243 const static WCHAR szRemoveRegistryValues[] =
244 {'R','e','m','o','v','e','R','e','g','i','s','t','r','y',
245 'V','a','l','u','e','s',0};
246 const static WCHAR szRemoveShortcuts[] =
247 {'R','e','m','o','v','e','S','h','o','r','t','c','u','t','s',0};
248 const static WCHAR szRMCCPSearch[] =
249 {'R','M','C','C','P','S','e','a','r','c','h',0};
250 const static WCHAR szScheduleReboot[] =
251 {'S','c','h','e','d','u','l','e','R','e','b','o','o','t',0};
252 const static WCHAR szSelfUnregModules[] =
253 {'S','e','l','f','U','n','r','e','g','M','o','d','u','l','e','s',0};
254 const static WCHAR szSetODBCFolders[] =
255 {'S','e','t','O','D','B','C','F','o','l','d','e','r','s',0};
256 const static WCHAR szStartServices[] =
257 {'S','t','a','r','t','S','e','r','v','i','c','e','s',0};
258 const static WCHAR szStopServices[] =
259 {'S','t','o','p','S','e','r','v','i','c','e','s',0};
260 const static WCHAR szUnpublishComponents[] =
261 {'U','n','p','u','b','l','i','s','h',
262 'C','o','m','p','o','n','e','n','t','s',0};
263 const static WCHAR szUnpublishFeatures[] =
264 {'U','n','p','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
265 const static WCHAR szUnregisterClassInfo[] =
266 {'U','n','r','e','g','i','s','t','e','r','C','l','a','s','s',
267 'I','n','f','o',0};
268 const static WCHAR szUnregisterComPlus[] =
269 {'U','n','r','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
270 const static WCHAR szUnregisterExtensionInfo[] =
271 {'U','n','r','e','g','i','s','t','e','r',
272 'E','x','t','e','n','s','i','o','n','I','n','f','o',0};
273 const static WCHAR szUnregisterFonts[] =
274 {'U','n','r','e','g','i','s','t','e','r','F','o','n','t','s',0};
275 const static WCHAR szUnregisterMIMEInfo[] =
276 {'U','n','r','e','g','i','s','t','e','r','M','I','M','E','I','n','f','o',0};
277 const static WCHAR szUnregisterProgIdInfo[] =
278 {'U','n','r','e','g','i','s','t','e','r','P','r','o','g','I','d',
279 'I','n','f','o',0};
280 const static WCHAR szUnregisterTypeLibraries[] =
281 {'U','n','r','e','g','i','s','t','e','r','T','y','p','e',
282 'L','i','b','r','a','r','i','e','s',0};
283 const static WCHAR szValidateProductID[] =
284 {'V','a','l','i','d','a','t','e','P','r','o','d','u','c','t','I','D',0};
285 const static WCHAR szWriteEnvironmentStrings[] =
286 {'W','r','i','t','e','E','n','v','i','r','o','n','m','e','n','t',
287 'S','t','r','i','n','g','s',0};
288
289 struct _actions {
290 LPCWSTR action;
291 STANDARDACTIONHANDLER handler;
292 };
293
294 static struct _actions StandardActions[] = {
295 { szAllocateRegistrySpace, NULL},
296 { szAppSearch, ACTION_AppSearch },
297 { szBindImage, NULL},
298 { szCCPSearch, NULL},
299 { szCostFinalize, ACTION_CostFinalize },
300 { szCostInitialize, ACTION_CostInitialize },
301 { szCreateFolders, ACTION_CreateFolders },
302 { szCreateShortcuts, ACTION_CreateShortcuts },
303 { szDeleteServices, NULL},
304 { szDisableRollback, NULL},
305 { szDuplicateFiles, ACTION_DuplicateFiles },
306 { szExecuteAction, ACTION_ExecuteAction },
307 { szFileCost, ACTION_FileCost },
308 { szFindRelatedProducts, NULL},
309 { szForceReboot, ACTION_ForceReboot },
310 { szInstallAdminPackage, NULL},
311 { szInstallExecute, ACTION_InstallExecute },
312 { szInstallExecuteAgain, ACTION_InstallExecute },
313 { szInstallFiles, ACTION_InstallFiles},
314 { szInstallFinalize, ACTION_InstallFinalize },
315 { szInstallInitialize, ACTION_InstallInitialize },
316 { szInstallSFPCatalogFile, NULL},
317 { szInstallValidate, ACTION_InstallValidate },
318 { szIsolateComponents, NULL},
319 { szLaunchConditions, ACTION_LaunchConditions },
320 { szMigrateFeatureStates, NULL},
321 { szMoveFiles, NULL},
322 { szMsiPublishAssemblies, NULL},
323 { szMsiUnpublishAssemblies, NULL},
324 { szInstallODBC, NULL},
325 { szInstallServices, NULL},
326 { szPatchFiles, NULL},
327 { szProcessComponents, ACTION_ProcessComponents },
328 { szPublishComponents, ACTION_PublishComponents },
329 { szPublishFeatures, ACTION_PublishFeatures },
330 { szPublishProduct, ACTION_PublishProduct },
331 { szRegisterClassInfo, ACTION_RegisterClassInfo },
332 { szRegisterComPlus, NULL},
333 { szRegisterExtensionInfo, ACTION_RegisterExtensionInfo },
334 { szRegisterFonts, ACTION_RegisterFonts },
335 { szRegisterMIMEInfo, ACTION_RegisterMIMEInfo },
336 { szRegisterProduct, ACTION_RegisterProduct },
337 { szRegisterProgIdInfo, ACTION_RegisterProgIdInfo },
338 { szRegisterTypeLibraries, ACTION_RegisterTypeLibraries },
339 { szRegisterUser, ACTION_RegisterUser},
340 { szRemoveDuplicateFiles, NULL},
341 { szRemoveEnvironmentStrings, NULL},
342 { szRemoveExistingProducts, NULL},
343 { szRemoveFiles, NULL},
344 { szRemoveFolders, NULL},
345 { szRemoveIniValues, NULL},
346 { szRemoveODBC, NULL},
347 { szRemoveRegistryValues, NULL},
348 { szRemoveShortcuts, NULL},
349 { szResolveSource, ACTION_ResolveSource},
350 { szRMCCPSearch, NULL},
351 { szScheduleReboot, NULL},
352 { szSelfRegModules, ACTION_SelfRegModules },
353 { szSelfUnregModules, NULL},
354 { szSetODBCFolders, NULL},
355 { szStartServices, NULL},
356 { szStopServices, NULL},
357 { szUnpublishComponents, NULL},
358 { szUnpublishFeatures, NULL},
359 { szUnregisterClassInfo, NULL},
360 { szUnregisterComPlus, NULL},
361 { szUnregisterExtensionInfo, NULL},
362 { szUnregisterFonts, NULL},
363 { szUnregisterMIMEInfo, NULL},
364 { szUnregisterProgIdInfo, NULL},
365 { szUnregisterTypeLibraries, NULL},
366 { szValidateProductID, NULL},
367 { szWriteEnvironmentStrings, NULL},
368 { szWriteIniValues, ACTION_WriteIniValues },
369 { szWriteRegistryValues, ACTION_WriteRegistryValues},
370 { NULL, NULL},
371 };
372
373
374 /********************************************************
375 * helper functions to get around current HACKS and such
376 ********************************************************/
377 inline static void reduce_to_longfilename(WCHAR* filename)
378 {
379 LPWSTR p = strchrW(filename,'|');
380 if (p)
381 memmove(filename, p+1, (strlenW(p+1)+1)*sizeof(WCHAR));
382 }
383
384 inline static void reduce_to_shortfilename(WCHAR* filename)
385 {
386 LPWSTR p = strchrW(filename,'|');
387 if (p)
388 *p = 0;
389 }
390
391 WCHAR *load_dynamic_stringW(MSIRECORD *row, INT index)
392 {
393 UINT rc;
394 DWORD sz;
395 LPWSTR ret;
396
397 sz = 0;
398 if (MSI_RecordIsNull(row,index))
399 return NULL;
400
401 rc = MSI_RecordGetStringW(row,index,NULL,&sz);
402
403 /* having an empty string is different than NULL */
404 if (sz == 0)
405 {
406 ret = HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR));
407 ret[0] = 0;
408 return ret;
409 }
410
411 sz ++;
412 ret = HeapAlloc(GetProcessHeap(),0,sz * sizeof (WCHAR));
413 rc = MSI_RecordGetStringW(row,index,ret,&sz);
414 if (rc!=ERROR_SUCCESS)
415 {
416 ERR("Unable to load dynamic string\n");
417 HeapFree(GetProcessHeap(), 0, ret);
418 ret = NULL;
419 }
420 return ret;
421 }
422
423 LPWSTR load_dynamic_property(MSIPACKAGE *package, LPCWSTR prop, UINT* rc)
424 {
425 DWORD sz = 0;
426 LPWSTR str;
427 UINT r;
428
429 r = MSI_GetPropertyW(package, prop, NULL, &sz);
430 if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
431 {
432 if (rc)
433 *rc = r;
434 return NULL;
435 }
436 sz++;
437 str = HeapAlloc(GetProcessHeap(),0,sz*sizeof(WCHAR));
438 r = MSI_GetPropertyW(package, prop, str, &sz);
439 if (r != ERROR_SUCCESS)
440 {
441 HeapFree(GetProcessHeap(),0,str);
442 str = NULL;
443 }
444 if (rc)
445 *rc = r;
446 return str;
447 }
448
449 int get_loaded_component(MSIPACKAGE* package, LPCWSTR Component )
450 {
451 int rc = -1;
452 DWORD i;
453
454 for (i = 0; i < package->loaded_components; i++)
455 {
456 if (strcmpW(Component,package->components[i].Component)==0)
457 {
458 rc = i;
459 break;
460 }
461 }
462 return rc;
463 }
464
465 int get_loaded_feature(MSIPACKAGE* package, LPCWSTR Feature )
466 {
467 int rc = -1;
468 DWORD i;
469
470 for (i = 0; i < package->loaded_features; i++)
471 {
472 if (strcmpW(Feature,package->features[i].Feature)==0)
473 {
474 rc = i;
475 break;
476 }
477 }
478 return rc;
479 }
480
481 int get_loaded_file(MSIPACKAGE* package, LPCWSTR file)
482 {
483 int rc = -1;
484 DWORD i;
485
486 for (i = 0; i < package->loaded_files; i++)
487 {
488 if (strcmpW(file,package->files[i].File)==0)
489 {
490 rc = i;
491 break;
492 }
493 }
494 return rc;
495 }
496
497 int track_tempfile(MSIPACKAGE *package, LPCWSTR name, LPCWSTR path)
498 {
499 DWORD i;
500 DWORD index;
501
502 if (!package)
503 return -2;
504
505 for (i=0; i < package->loaded_files; i++)
506 if (strcmpW(package->files[i].File,name)==0)
507 return -1;
508
509 index = package->loaded_files;
510 package->loaded_files++;
511 if (package->loaded_files== 1)
512 package->files = HeapAlloc(GetProcessHeap(),0,sizeof(MSIFILE));
513 else
514 package->files = HeapReAlloc(GetProcessHeap(),0,
515 package->files , package->loaded_files * sizeof(MSIFILE));
516
517 memset(&package->files[index],0,sizeof(MSIFILE));
518
519 package->files[index].File = strdupW(name);
520 package->files[index].TargetPath = strdupW(path);
521 package->files[index].Temporary = TRUE;
522
523 TRACE("Tracking tempfile (%s)\n",debugstr_w(package->files[index].File));
524
525 return 0;
526 }
527
528 static void remove_tracked_tempfiles(MSIPACKAGE* package)
529 {
530 DWORD i;
531
532 if (!package)
533 return;
534
535 for (i = 0; i < package->loaded_files; i++)
536 {
537 if (package->files[i].Temporary)
538 {
539 TRACE("Cleaning up %s\n",debugstr_w(package->files[i].TargetPath));
540 DeleteFileW(package->files[i].TargetPath);
541 }
542
543 }
544 }
545
546 /* wrapper to resist a need for a full rewrite right now */
547 DWORD deformat_string(MSIPACKAGE *package, LPCWSTR ptr, WCHAR** data )
548 {
549 if (ptr)
550 {
551 MSIRECORD *rec = MSI_CreateRecord(1);
552 DWORD size = 0;
553
554 MSI_RecordSetStringW(rec,0,ptr);
555 MSI_FormatRecordW(package,rec,NULL,&size);
556 if (size >= 0)
557 {
558 size++;
559 *data = HeapAlloc(GetProcessHeap(),0,size*sizeof(WCHAR));
560 if (size > 1)
561 MSI_FormatRecordW(package,rec,*data,&size);
562 else
563 *data[0] = 0;
564 msiobj_release( &rec->hdr );
565 return sizeof(WCHAR)*size;
566 }
567 msiobj_release( &rec->hdr );
568 }
569
570 *data = NULL;
571 return 0;
572 }
573
574 /* Called when the package is being closed */
575 void ACTION_free_package_structures( MSIPACKAGE* package)
576 {
577 INT i;
578
579 TRACE("Freeing package action data\n");
580
581 remove_tracked_tempfiles(package);
582
583 /* No dynamic buffers in features */
584 if (package->features && package->loaded_features > 0)
585 HeapFree(GetProcessHeap(),0,package->features);
586
587 for (i = 0; i < package->loaded_folders; i++)
588 {
589 HeapFree(GetProcessHeap(),0,package->folders[i].Directory);
590 HeapFree(GetProcessHeap(),0,package->folders[i].TargetDefault);
591 HeapFree(GetProcessHeap(),0,package->folders[i].SourceDefault);
592 HeapFree(GetProcessHeap(),0,package->folders[i].ResolvedTarget);
593 HeapFree(GetProcessHeap(),0,package->folders[i].ResolvedSource);
594 HeapFree(GetProcessHeap(),0,package->folders[i].Property);
595 }
596 if (package->folders && package->loaded_folders > 0)
597 HeapFree(GetProcessHeap(),0,package->folders);
598
599 for (i = 0; i < package->loaded_components; i++)
600 HeapFree(GetProcessHeap(),0,package->components[i].FullKeypath);
601
602 if (package->components && package->loaded_components > 0)
603 HeapFree(GetProcessHeap(),0,package->components);
604
605 for (i = 0; i < package->loaded_files; i++)
606 {
607 HeapFree(GetProcessHeap(),0,package->files[i].File);
608 HeapFree(GetProcessHeap(),0,package->files[i].FileName);
609 HeapFree(GetProcessHeap(),0,package->files[i].ShortName);
610 HeapFree(GetProcessHeap(),0,package->files[i].Version);
611 HeapFree(GetProcessHeap(),0,package->files[i].Language);
612 HeapFree(GetProcessHeap(),0,package->files[i].SourcePath);
613 HeapFree(GetProcessHeap(),0,package->files[i].TargetPath);
614 }
615
616 if (package->files && package->loaded_files > 0)
617 HeapFree(GetProcessHeap(),0,package->files);
618
619 for (i = 0; i < package->DeferredActionCount; i++)
620 HeapFree(GetProcessHeap(),0,package->DeferredAction[i]);
621 HeapFree(GetProcessHeap(),0,package->DeferredAction);
622
623 for (i = 0; i < package->CommitActionCount; i++)
624 HeapFree(GetProcessHeap(),0,package->CommitAction[i]);
625 HeapFree(GetProcessHeap(),0,package->CommitAction);
626
627 HeapFree(GetProcessHeap(),0,package->PackagePath);
628 }
629
630 static void ui_progress(MSIPACKAGE *package, int a, int b, int c, int d )
631 {
632 MSIRECORD * row;
633
634 row = MSI_CreateRecord(4);
635 MSI_RecordSetInteger(row,1,a);
636 MSI_RecordSetInteger(row,2,b);
637 MSI_RecordSetInteger(row,3,c);
638 MSI_RecordSetInteger(row,4,d);
639 MSI_ProcessMessage(package, INSTALLMESSAGE_PROGRESS, row);
640 msiobj_release(&row->hdr);
641
642 msi_dialog_check_messages(NULL);
643 }
644
645 static void ui_actiondata(MSIPACKAGE *package, LPCWSTR action, MSIRECORD * record)
646 {
647 static const WCHAR Query_t[] =
648 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
649 '`','A','c','t','i','o', 'n','T','e','x','t','`',' ',
650 'W','H','E','R','E',' ', '`','A','c','t','i','o','n','`',' ','=',
651 ' ','\'','%','s','\'',0};
652 WCHAR message[1024];
653 UINT rc;
654 MSIQUERY * view;
655 MSIRECORD * row = 0;
656 DWORD size;
657
658 if (!package->LastAction || strcmpW(package->LastAction,action))
659 {
660 rc = MSI_OpenQuery(package->db, &view, Query_t, action);
661 if (rc != ERROR_SUCCESS)
662 return;
663
664 rc = MSI_ViewExecute(view, 0);
665 if (rc != ERROR_SUCCESS)
666 {
667 MSI_ViewClose(view);
668 msiobj_release(&view->hdr);
669 return;
670 }
671 rc = MSI_ViewFetch(view,&row);
672 if (rc != ERROR_SUCCESS)
673 {
674 MSI_ViewClose(view);
675 msiobj_release(&view->hdr);
676 return;
677 }
678
679 if (MSI_RecordIsNull(row,3))
680 {
681 msiobj_release(&row->hdr);
682 MSI_ViewClose(view);
683 msiobj_release(&view->hdr);
684 return;
685 }
686
687 /* update the cached actionformat */
688 HeapFree(GetProcessHeap(),0,package->ActionFormat);
689 package->ActionFormat = load_dynamic_stringW(row,3);
690
691 HeapFree(GetProcessHeap(),0,package->LastAction);
692 package->LastAction = strdupW(action);
693
694 msiobj_release(&row->hdr);
695 MSI_ViewClose(view);
696 msiobj_release(&view->hdr);
697 }
698
699 MSI_RecordSetStringW(record,0,package->ActionFormat);
700 size = 1024;
701 MSI_FormatRecordW(package,record,message,&size);
702
703 row = MSI_CreateRecord(1);
704 MSI_RecordSetStringW(row,1,message);
705
706 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, row);
707 msiobj_release(&row->hdr);
708 }
709
710
711 static void ui_actionstart(MSIPACKAGE *package, LPCWSTR action)
712 {
713 static const WCHAR template_s[]=
714 {'A','c','t','i','o','n',' ','%','s',':',' ','%','s','.',' ', '%','s',
715 '.',0};
716 static const WCHAR format[] =
717 {'H','H','\'',':','\'','m','m','\'',':','\'','s','s',0};
718 static const WCHAR Query_t[] =
719 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
720 '`','A','c','t','i','o', 'n','T','e','x','t','`',' ',
721 'W','H','E','R','E', ' ','`','A','c','t','i','o','n','`',' ','=',
722 ' ','\'','%','s','\'',0};
723 WCHAR message[1024];
724 WCHAR timet[0x100];
725 UINT rc;
726 MSIQUERY * view;
727 MSIRECORD * row = 0;
728 WCHAR *ActionText=NULL;
729
730 GetTimeFormatW(LOCALE_USER_DEFAULT, 0, NULL, format, timet, 0x100);
731
732 rc = MSI_OpenQuery(package->db, &view, Query_t, action);
733 if (rc != ERROR_SUCCESS)
734 return;
735 rc = MSI_ViewExecute(view, 0);
736 if (rc != ERROR_SUCCESS)
737 {
738 MSI_ViewClose(view);
739 msiobj_release(&view->hdr);
740 return;
741 }
742 rc = MSI_ViewFetch(view,&row);
743 if (rc != ERROR_SUCCESS)
744 {
745 MSI_ViewClose(view);
746 msiobj_release(&view->hdr);
747 return;
748 }
749
750 ActionText = load_dynamic_stringW(row,2);
751 msiobj_release(&row->hdr);
752 MSI_ViewClose(view);
753 msiobj_release(&view->hdr);
754
755 sprintfW(message,template_s,timet,action,ActionText);
756
757 row = MSI_CreateRecord(1);
758 MSI_RecordSetStringW(row,1,message);
759
760 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONSTART, row);
761 msiobj_release(&row->hdr);
762 HeapFree(GetProcessHeap(),0,ActionText);
763 }
764
765 static void ui_actioninfo(MSIPACKAGE *package, LPCWSTR action, BOOL start,
766 UINT rc)
767 {
768 MSIRECORD * row;
769 static const WCHAR template_s[]=
770 {'A','c','t','i','o','n',' ','s','t','a','r','t',' ','%','s',':',' ',
771 '%','s', '.',0};
772 static const WCHAR template_e[]=
773 {'A','c','t','i','o','n',' ','e','n','d','e','d',' ','%','s',':',' ',
774 '%','s', '.',' ','R','e','t','u','r','n',' ','v','a','l','u','e',' ',
775 '%','i','.',0};
776 static const WCHAR format[] =
777 {'H','H','\'',':','\'','m','m','\'',':','\'','s','s',0};
778 WCHAR message[1024];
779 WCHAR timet[0x100];
780
781 GetTimeFormatW(LOCALE_USER_DEFAULT, 0, NULL, format, timet, 0x100);
782 if (start)
783 sprintfW(message,template_s,timet,action);
784 else
785 sprintfW(message,template_e,timet,action,rc);
786
787 row = MSI_CreateRecord(1);
788 MSI_RecordSetStringW(row,1,message);
789
790 MSI_ProcessMessage(package, INSTALLMESSAGE_INFO, row);
791 msiobj_release(&row->hdr);
792 }
793
794 /*
795 * build_directory_name()
796 *
797 * This function is to save messing round with directory names
798 * It handles adding backslashes between path segments,
799 * and can add \ at the end of the directory name if told to.
800 *
801 * It takes a variable number of arguments.
802 * It always allocates a new string for the result, so make sure
803 * to free the return value when finished with it.
804 *
805 * The first arg is the number of path segments that follow.
806 * The arguments following count are a list of path segments.
807 * A path segment may be NULL.
808 *
809 * Path segments will be added with a \ separating them.
810 * A \ will not be added after the last segment, however if the
811 * last segment is NULL, then the last character will be a \
812 *
813 */
814 static LPWSTR build_directory_name(DWORD count, ...)
815 {
816 DWORD sz = 1, i;
817 LPWSTR dir;
818 va_list va;
819
820 va_start(va,count);
821 for(i=0; i<count; i++)
822 {
823 LPCWSTR str = va_arg(va,LPCWSTR);
824 if (str)
825 sz += strlenW(str) + 1;
826 }
827 va_end(va);
828
829 dir = HeapAlloc(GetProcessHeap(), 0, sz*sizeof(WCHAR));
830 dir[0]=0;
831
832 va_start(va,count);
833 for(i=0; i<count; i++)
834 {
835 LPCWSTR str = va_arg(va,LPCWSTR);
836 if (!str)
837 continue;
838 strcatW(dir, str);
839 if( ((i+1)!=count) && dir[strlenW(dir)-1]!='\\')
840 strcatW(dir, cszbs);
841 }
842 return dir;
843 }
844
845 static BOOL ACTION_VerifyComponentForAction(MSIPACKAGE* package, INT index,
846 INSTALLSTATE check )
847 {
848 if (package->components[index].Installed == check)
849 return FALSE;
850
851 if (package->components[index].ActionRequest == check)
852 return TRUE;
853 else
854 return FALSE;
855 }
856
857 static BOOL ACTION_VerifyFeatureForAction(MSIPACKAGE* package, INT index,
858 INSTALLSTATE check )
859 {
860 if (package->features[index].Installed == check)
861 return FALSE;
862
863 if (package->features[index].ActionRequest == check)
864 return TRUE;
865 else
866 return FALSE;
867 }
868
869
870 /****************************************************
871 * TOP level entry points
872 *****************************************************/
873
874 UINT ACTION_DoTopLevelINSTALL(MSIPACKAGE *package, LPCWSTR szPackagePath,
875 LPCWSTR szCommandLine)
876 {
877 DWORD sz;
878 WCHAR buffer[10];
879 UINT rc;
880 BOOL ui = FALSE;
881 static const WCHAR szUILevel[] = {'U','I','L','e','v','e','l',0};
882 static const WCHAR szAction[] = {'A','C','T','I','O','N',0};
883 static const WCHAR szInstall[] = {'I','N','S','T','A','L','L',0};
884
885 MSI_SetPropertyW(package, szAction, szInstall);
886 package->ExecuteSequenceRun = FALSE;
887
888 if (szPackagePath)
889 {
890 LPWSTR p, check, path;
891
892 package->PackagePath = strdupW(szPackagePath);
893 path = strdupW(szPackagePath);
894 p = strrchrW(path,'\\');
895 if (p)
896 {
897 p++;
898 *p=0;
899 }
900 else
901 {
902 HeapFree(GetProcessHeap(),0,path);
903 path = HeapAlloc(GetProcessHeap(),0,MAX_PATH*sizeof(WCHAR));
904 GetCurrentDirectoryW(MAX_PATH,path);
905 strcatW(path,cszbs);
906 }
907
908 check = load_dynamic_property(package, cszSourceDir,NULL);
909 if (!check)
910 MSI_SetPropertyW(package, cszSourceDir, path);
911 else
912 HeapFree(GetProcessHeap(), 0, check);
913
914 HeapFree(GetProcessHeap(), 0, path);
915 }
916
917 if (szCommandLine)
918 {
919 LPWSTR ptr,ptr2;
920 ptr = (LPWSTR)szCommandLine;
921
922 while (*ptr)
923 {
924 WCHAR *prop = NULL;
925 WCHAR *val = NULL;
926
927 TRACE("Looking at %s\n",debugstr_w(ptr));
928
929 ptr2 = strchrW(ptr,'=');
930 if (ptr2)
931 {
932 BOOL quote=FALSE;
933 DWORD len = 0;
934
935 while (*ptr == ' ') ptr++;
936 len = ptr2-ptr;
937 prop = HeapAlloc(GetProcessHeap(),0,(len+1)*sizeof(WCHAR));
938 memcpy(prop,ptr,len*sizeof(WCHAR));
939 prop[len]=0;
940 ptr2++;
941
942 len = 0;
943 ptr = ptr2;
944 while (*ptr && (quote || (!quote && *ptr!=' ')))
945 {
946 if (*ptr == '"')
947 quote = !quote;
948 ptr++;
949 len++;
950 }
951
952 if (*ptr2=='"')
953 {
954 ptr2++;
955 len -= 2;
956 }
957 val = HeapAlloc(GetProcessHeap(),0,(len+1)*sizeof(WCHAR));
958 memcpy(val,ptr2,len*sizeof(WCHAR));
959 val[len] = 0;
960
961 if (strlenW(prop) > 0)
962 {
963 TRACE("Found commandline property (%s) = (%s)\n",
964 debugstr_w(prop), debugstr_w(val));
965 MSI_SetPropertyW(package,prop,val);
966 }
967 HeapFree(GetProcessHeap(),0,val);
968 HeapFree(GetProcessHeap(),0,prop);
969 }
970 ptr++;
971 }
972 }
973
974 sz = 10;
975 if (MSI_GetPropertyW(package,szUILevel,buffer,&sz) == ERROR_SUCCESS)
976 {
977 if (atoiW(buffer) >= INSTALLUILEVEL_REDUCED)
978 {
979 rc = ACTION_ProcessUISequence(package);
980 ui = TRUE;
981 if (rc == ERROR_SUCCESS)
982 rc = ACTION_ProcessExecSequence(package,TRUE);
983 }
984 else
985 rc = ACTION_ProcessExecSequence(package,FALSE);
986 }
987 else
988 rc = ACTION_ProcessExecSequence(package,FALSE);
989
990 if (rc == -1)
991 {
992 /* install was halted but should be considered a success */
993 rc = ERROR_SUCCESS;
994 }
995
996 /* process the ending type action */
997 if (rc == ERROR_SUCCESS)
998 ACTION_PerformActionSequence(package,-1,ui);
999 else if (rc == ERROR_INSTALL_USEREXIT)
1000 ACTION_PerformActionSequence(package,-2,ui);
1001 else if (rc == ERROR_FUNCTION_FAILED)
1002 ACTION_PerformActionSequence(package,-3,ui);
1003 else if (rc == ERROR_INSTALL_SUSPEND)
1004 ACTION_PerformActionSequence(package,-4,ui);
1005
1006 /* finish up running custom actions */
1007 ACTION_FinishCustomActions(package);
1008
1009 return rc;
1010 }
1011
1012 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq, BOOL UI)
1013 {
1014 MSIQUERY * view;
1015 UINT rc;
1016 WCHAR buffer[0x100];
1017 DWORD sz = 0x100;
1018 MSIRECORD * row = 0;
1019 static const WCHAR ExecSeqQuery[] =
1020 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1021 '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
1022 'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
1023 '`','S','e','q','u','e','n','c','e','`',' ', '=',' ','%','i',0};
1024
1025 static const WCHAR UISeqQuery[] =
1026 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1027 '`','I','n','s','t','a','l','l','U','I','S','e','q','u','e','n','c','e',
1028 '`', ' ', 'W','H','E','R','E',' ','`','S','e','q','u','e','n','c','e','`',
1029 ' ', '=',' ','%','i',0};
1030
1031 if (UI)
1032 rc = MSI_OpenQuery(package->db, &view, UISeqQuery, seq);
1033 else
1034 rc = MSI_OpenQuery(package->db, &view, ExecSeqQuery, seq);
1035
1036 if (rc == ERROR_SUCCESS)
1037 {
1038 rc = MSI_ViewExecute(view, 0);
1039
1040 if (rc != ERROR_SUCCESS)
1041 {
1042 MSI_ViewClose(view);
1043 msiobj_release(&view->hdr);
1044 goto end;
1045 }
1046
1047 TRACE("Running the actions\n");
1048
1049 rc = MSI_ViewFetch(view,&row);
1050 if (rc != ERROR_SUCCESS)
1051 {
1052 rc = ERROR_SUCCESS;
1053 goto end;
1054 }
1055
1056 /* check conditions */
1057 if (!MSI_RecordIsNull(row,2))
1058 {
1059 LPWSTR cond = NULL;
1060 cond = load_dynamic_stringW(row,2);
1061
1062 if (cond)
1063 {
1064 /* this is a hack to skip errors in the condition code */
1065 if (MSI_EvaluateConditionW(package, cond) == MSICONDITION_FALSE)
1066 {
1067 HeapFree(GetProcessHeap(),0,cond);
1068 msiobj_release(&row->hdr);
1069 goto end;
1070 }
1071 else
1072 HeapFree(GetProcessHeap(),0,cond);
1073 }
1074 }
1075
1076 sz=0x100;
1077 rc = MSI_RecordGetStringW(row,1,buffer,&sz);
1078 if (rc != ERROR_SUCCESS)
1079 {
1080 ERR("Error is %x\n",rc);
1081 msiobj_release(&row->hdr);
1082 goto end;
1083 }
1084
1085 if (UI)
1086 rc = ACTION_PerformUIAction(package,buffer);
1087 else
1088 rc = ACTION_PerformAction(package,buffer);
1089 msiobj_release(&row->hdr);
1090 end:
1091 MSI_ViewClose(view);
1092 msiobj_release(&view->hdr);
1093 }
1094 else
1095 rc = ERROR_SUCCESS;
1096
1097 return rc;
1098 }
1099
1100 static UINT ACTION_ProcessExecSequence(MSIPACKAGE *package, BOOL UIran)
1101 {
1102 MSIQUERY * view;
1103 UINT rc;
1104 static const WCHAR ExecSeqQuery[] =
1105 {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1106 '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
1107 'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
1108 '`','S','e','q','u','e','n','c','e','`',' ', '>',' ','%','i',' ',
1109 'O','R','D','E','R',' ', 'B','Y',' ',
1110 '`','S','e','q','u','e','n','c','e','`',0 };
1111 MSIRECORD * row = 0;
1112 static const WCHAR IVQuery[] =
1113 {'S','E','L','E','C','T',' ','`','S','e','q','u','e','n','c','e','`',
1114 ' ', 'F','R','O','M',' ','`','I','n','s','t','a','l','l',
1115 'E','x','e','c','u','t','e','S','e','q','u','e','n','c','e','`',' ',
1116 'W','H','E','R','E',' ','`','A','c','t','i','o','n','`',' ','=',
1117 ' ','\'', 'I','n','s','t','a','l','l',
1118 'V','a','l','i','d','a','t','e','\'', 0};
1119 INT seq = 0;
1120
1121
1122 if (package->ExecuteSequenceRun)
1123 {
1124 TRACE("Execute Sequence already Run\n");
1125 return ERROR_SUCCESS;
1126 }
1127
1128 package->ExecuteSequenceRun = TRUE;
1129
1130 /* get the sequence number */
1131 if (UIran)
1132 {
1133 rc = MSI_DatabaseOpenViewW(package->db, IVQuery, &view);
1134 if (rc != ERROR_SUCCESS)
1135 return rc;
1136 rc = MSI_ViewExecute(view, 0);
1137 if (rc != ERROR_SUCCESS)
1138 {
1139 MSI_ViewClose(view);
1140 msiobj_release(&view->hdr);
1141 return rc;
1142 }
1143 rc = MSI_ViewFetch(view,&row);
1144 if (rc != ERROR_SUCCESS)
1145 {
1146 MSI_ViewClose(view);
1147 msiobj_release(&view->hdr);
1148 return rc;
1149 }
1150 seq = MSI_RecordGetInteger(row,1);
1151 msiobj_release(&row->hdr);
1152 MSI_ViewClose(view);
1153 msiobj_release(&view->hdr);
1154 }
1155
1156 rc = MSI_OpenQuery(package->db, &view, ExecSeqQuery, seq);
1157 if (rc == ERROR_SUCCESS)
1158 {
1159 rc = MSI_ViewExecute(view, 0);
1160
1161 if (rc != ERROR_SUCCESS)
1162 {
1163 MSI_ViewClose(view);
1164 msiobj_release(&view->hdr);
1165 goto end;
1166 }
1167
1168 TRACE("Running the actions\n");
1169
1170 while (1)
1171 {
1172 WCHAR buffer[0x100];
1173 DWORD sz = 0x100;
1174
1175 rc = MSI_ViewFetch(view,&row);
1176 if (rc != ERROR_SUCCESS)
1177 {
1178 rc = ERROR_SUCCESS;
1179 break;
1180 }
1181
1182 /* check conditions */
1183 if (!MSI_RecordIsNull(row,2))
1184 {
1185 LPWSTR cond = NULL;
1186 cond = load_dynamic_stringW(row,2);
1187
1188 if (cond)
1189 {
1190 /* this is a hack to skip errors in the condition code */
1191 if (MSI_EvaluateConditionW(package, cond) ==
1192 MSICONDITION_FALSE)
1193 {
1194 HeapFree(GetProcessHeap(),0,cond);
1195 msiobj_release(&row->hdr);
1196 continue;
1197 }
1198 else
1199 HeapFree(GetProcessHeap(),0,cond);
1200 }
1201 }
1202
1203 sz=0x100;
1204 rc = MSI_RecordGetStringW(row,1,buffer,&sz);
1205 if (rc != ERROR_SUCCESS)
1206 {
1207 ERR("Error is %x\n",rc);
1208 msiobj_release(&row->hdr);
1209 break;
1210 }
1211
1212 rc = ACTION_PerformAction(package,buffer);
1213
1214 if (rc == ERROR_FUNCTION_NOT_CALLED)
1215 rc = ERROR_SUCCESS;
1216
1217 if (rc != ERROR_SUCCESS)
1218 {
1219 ERR("Execution halted due to error (%i)\n",rc);
1220 msiobj_release(&row->hdr);
1221 break;
1222 }
1223
1224 msiobj_release(&row->hdr);
1225 }
1226
1227 MSI_ViewClose(view);
1228 msiobj_release(&view->hdr);
1229 }
1230
1231 end:
1232 return rc;
1233 }
1234
1235
1236 static UINT ACTION_ProcessUISequence(MSIPACKAGE *package)
1237 {
1238 MSIQUERY * view;
1239 UINT rc;
1240 static const WCHAR ExecSeqQuery [] =
1241 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1242 '`','I','n','s','t','a','l','l',
1243 'U','I','S','e','q','u','e','n','c','e','`',
1244 ' ','W','H','E','R','E',' ',
1245 '`','S','e','q','u','e','n','c','e','`',' ',
1246 '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
1247 '`','S','e','q','u','e','n','c','e','`',0};
1248
1249 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
1250
1251 if (rc == ERROR_SUCCESS)
1252 {
1253 rc = MSI_ViewExecute(view, 0);
1254
1255 if (rc != ERROR_SUCCESS)
1256 {
1257 MSI_ViewClose(view);
1258 msiobj_release(&view->hdr);
1259 goto end;
1260 }
1261
1262 TRACE("Running the actions \n");
1263
1264 while (1)
1265 {
1266 WCHAR buffer[0x100];
1267 DWORD sz = 0x100;
1268 MSIRECORD * row = 0;
1269
1270 rc = MSI_ViewFetch(view,&row);
1271 if (rc != ERROR_SUCCESS)
1272 {
1273 rc = ERROR_SUCCESS;
1274 break;
1275 }
1276
1277 /* check conditions */
1278 if (!MSI_RecordIsNull(row,2))
1279 {
1280 LPWSTR cond = NULL;
1281 cond = load_dynamic_stringW(row,2);
1282
1283 if (cond)
1284 {
1285 /* this is a hack to skip errors in the condition code */
1286 if (MSI_EvaluateConditionW(package, cond) ==
1287 MSICONDITION_FALSE)
1288 {
1289 HeapFree(GetProcessHeap(),0,cond);
1290 msiobj_release(&row->hdr);
1291 continue;
1292 }
1293 else
1294 HeapFree(GetProcessHeap(),0,cond);
1295 }
1296 }
1297
1298 sz=0x100;
1299 rc = MSI_RecordGetStringW(row,1,buffer,&sz);
1300 if (rc != ERROR_SUCCESS)
1301 {
1302 ERR("Error is %x\n",rc);
1303 msiobj_release(&row->hdr);
1304 break;
1305 }
1306
1307 rc = ACTION_PerformUIAction(package,buffer);
1308
1309 if (rc == ERROR_FUNCTION_NOT_CALLED)
1310 rc = ERROR_SUCCESS;
1311
1312 if (rc != ERROR_SUCCESS)
1313 {
1314 ERR("Execution halted due to error (%i)\n",rc);
1315 msiobj_release(&row->hdr);
1316 break;
1317 }
1318
1319 msiobj_release(&row->hdr);
1320 }
1321
1322 MSI_ViewClose(view);
1323 msiobj_release(&view->hdr);
1324 }
1325
1326 end:
1327 return rc;
1328 }
1329
1330 /********************************************************
1331 * ACTION helper functions and functions that perform the actions
1332 *******************************************************/
1333 BOOL ACTION_HandleStandardAction(MSIPACKAGE *package, LPCWSTR action, UINT* rc)
1334 {
1335 BOOL ret = FALSE;
1336
1337 int i;
1338 i = 0;
1339 while (StandardActions[i].action != NULL)
1340 {
1341 if (strcmpW(StandardActions[i].action, action)==0)
1342 {
1343 ui_actioninfo(package, action, TRUE, 0);
1344 ui_actionstart(package, action);
1345 if (StandardActions[i].handler)
1346 {
1347 *rc = StandardActions[i].handler(package);
1348 }
1349 else
1350 {
1351 FIXME("UNHANDLED Standard Action %s\n",debugstr_w(action));
1352 *rc = ERROR_SUCCESS;
1353 }
1354 ui_actioninfo(package, action, FALSE, *rc);
1355 ret = TRUE;
1356 break;
1357 }
1358 i++;
1359 }
1360 return ret;
1361 }
1362
1363 BOOL ACTION_HandleDialogBox(MSIPACKAGE *package, LPCWSTR dialog, UINT* rc)
1364 {
1365 BOOL ret = FALSE;
1366
1367 /*
1368 * for the UI when we get that working
1369 *
1370 if (ACTION_DialogBox(package,dialog) == ERROR_SUCCESS)
1371 {
1372 *rc = package->CurrentInstallState;
1373 ret = TRUE;
1374 }
1375 */
1376 return ret;
1377 }
1378
1379 BOOL ACTION_HandleCustomAction(MSIPACKAGE* package, LPCWSTR action, UINT* rc)
1380 {
1381 BOOL ret=FALSE;
1382 UINT arc;
1383
1384 arc = ACTION_CustomAction(package,action,FALSE);
1385
1386 if (arc != ERROR_CALL_NOT_IMPLEMENTED)
1387 {
1388 *rc = arc;
1389 ret = TRUE;
1390 }
1391 return ret;
1392 }
1393
1394 /*
1395 * A lot of actions are really important even if they don't do anything
1396 * explicit... Lots of properties are set at the beginning of the installation
1397 * CostFinalize does a bunch of work to translate the directories and such
1398 *
1399 * But until I get write access to the database that is hard, so I am going to
1400 * hack it to see if I can get something to run.
1401 */
1402 UINT ACTION_PerformAction(MSIPACKAGE *package, const WCHAR *action)
1403 {
1404 UINT rc = ERROR_SUCCESS;
1405 BOOL handled;
1406
1407 TRACE("Performing action (%s)\n",debugstr_w(action));
1408
1409 handled = ACTION_HandleStandardAction(package, action, &rc);
1410
1411 if (!handled)
1412 handled = ACTION_HandleCustomAction(package, action, &rc);
1413
1414 if (!handled)
1415 {
1416 FIXME("UNHANDLED MSI ACTION %s\n",debugstr_w(action));
1417 rc = ERROR_FUNCTION_NOT_CALLED;
1418 }
1419
1420 package->CurrentInstallState = rc;
1421 return rc;
1422 }
1423
1424 UINT ACTION_PerformUIAction(MSIPACKAGE *package, const WCHAR *action)
1425 {
1426 UINT rc = ERROR_SUCCESS;
1427 BOOL handled = FALSE;
1428
1429 TRACE("Performing action (%s)\n",debugstr_w(action));
1430
1431 handled = ACTION_HandleStandardAction(package, action, &rc);
1432
1433 if (!handled)
1434 handled = ACTION_HandleCustomAction(package, action, &rc);
1435
1436 if (!handled)
1437 handled = ACTION_HandleDialogBox(package, action, &rc);
1438
1439 msi_dialog_check_messages( NULL );
1440
1441 if (!handled)
1442 {
1443 FIXME("UNHANDLED MSI ACTION %s\n",debugstr_w(action));
1444 rc = ERROR_FUNCTION_NOT_CALLED;
1445 }
1446
1447 package->CurrentInstallState = rc;
1448 return rc;
1449 }
1450
1451 /***********************************************************************
1452 * create_full_pathW
1453 *
1454 * Recursively create all directories in the path.
1455 *
1456 * shamelessly stolen from setupapi/queue.c
1457 */
1458 static BOOL create_full_pathW(const WCHAR *path)
1459 {
1460 BOOL ret = TRUE;
1461 int len;
1462 WCHAR *new_path;
1463
1464 new_path = HeapAlloc(GetProcessHeap(), 0, (strlenW(path) + 1) *
1465 sizeof(WCHAR));
1466
1467 strcpyW(new_path, path);
1468
1469 while((len = strlenW(new_path)) && new_path[len - 1] == '\\')
1470 new_path[len - 1] = 0;
1471
1472 while(!CreateDirectoryW(new_path, NULL))
1473 {
1474 WCHAR *slash;
1475 DWORD last_error = GetLastError();
1476 if(last_error == ERROR_ALREADY_EXISTS)
1477 break;
1478
1479 if(last_error != ERROR_PATH_NOT_FOUND)
1480 {
1481 ret = FALSE;
1482 break;
1483 }
1484
1485 if(!(slash = strrchrW(new_path, '\\')))
1486 {
1487 ret = FALSE;
1488 break;
1489 }
1490
1491 len = slash - new_path;
1492 new_path[len] = 0;
1493 if(!create_full_pathW(new_path))
1494 {
1495 ret = FALSE;
1496 break;
1497 }
1498 new_path[len] = '\\';
1499 }
1500
1501 HeapFree(GetProcessHeap(), 0, new_path);
1502 return ret;
1503 }
1504
1505 /*
1506 * Also we cannot enable/disable components either, so for now I am just going
1507 * to do all the directories for all the components.
1508 */
1509 static UINT ACTION_CreateFolders(MSIPACKAGE *package)
1510 {
1511 static const WCHAR ExecSeqQuery[] =
1512 {'S','E','L','E','C','T',' ',
1513 '`','D','i','r','e','c','t','o','r','y','_','`',
1514 ' ','F','R','O','M',' ',
1515 '`','C','r','e','a','t','e','F','o','l','d','e','r','`',0 };
1516 UINT rc;
1517 MSIQUERY *view;
1518 MSIFOLDER *folder;
1519
1520 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view );
1521 if (rc != ERROR_SUCCESS)
1522 return ERROR_SUCCESS;
1523
1524 rc = MSI_ViewExecute(view, 0);
1525 if (rc != ERROR_SUCCESS)
1526 {
1527 MSI_ViewClose(view);
1528 msiobj_release(&view->hdr);
1529 return rc;
1530 }
1531
1532 while (1)
1533 {
1534 WCHAR dir[0x100];
1535 LPWSTR full_path;
1536 DWORD sz;
1537 MSIRECORD *row = NULL, *uirow;
1538
1539 rc = MSI_ViewFetch(view,&row);
1540 if (rc != ERROR_SUCCESS)
1541 {
1542 rc = ERROR_SUCCESS;
1543 break;
1544 }
1545
1546 sz=0x100;
1547 rc = MSI_RecordGetStringW(row,1,dir,&sz);
1548
1549 if (rc!= ERROR_SUCCESS)
1550 {
1551 ERR("Unable to get folder id \n");
1552 msiobj_release(&row->hdr);
1553 continue;
1554 }
1555
1556 sz = MAX_PATH;
1557 full_path = resolve_folder(package,dir,FALSE,FALSE,&folder);
1558 if (!full_path)
1559 {
1560 ERR("Unable to resolve folder id %s\n",debugstr_w(dir));
1561 msiobj_release(&row->hdr);
1562 continue;
1563 }
1564
1565 TRACE("Folder is %s\n",debugstr_w(full_path));
1566
1567 /* UI stuff */
1568 uirow = MSI_CreateRecord(1);
1569 MSI_RecordSetStringW(uirow,1,full_path);
1570 ui_actiondata(package,szCreateFolders,uirow);
1571 msiobj_release( &uirow->hdr );
1572
1573 if (folder->State == 0)
1574 create_full_pathW(full_path);
1575
1576 folder->State = 3;
1577
1578 msiobj_release(&row->hdr);
1579 HeapFree(GetProcessHeap(),0,full_path);
1580 }
1581 MSI_ViewClose(view);
1582 msiobj_release(&view->hdr);
1583
1584 return rc;
1585 }
1586
1587 static int load_component(MSIPACKAGE* package, MSIRECORD * row)
1588 {
1589 int index = package->loaded_components;
1590 DWORD sz;
1591
1592 /* fill in the data */
1593
1594 package->loaded_components++;
1595 if (package->loaded_components == 1)
1596 package->components = HeapAlloc(GetProcessHeap(),0,
1597 sizeof(MSICOMPONENT));
1598 else
1599 package->components = HeapReAlloc(GetProcessHeap(),0,
1600 package->components, package->loaded_components *
1601 sizeof(MSICOMPONENT));
1602
1603 memset(&package->components[index],0,sizeof(MSICOMPONENT));
1604
1605 sz = 96;
1606 MSI_RecordGetStringW(row,1,package->components[index].Component,&sz);
1607
1608 TRACE("Loading Component %s\n",
1609 debugstr_w(package->components[index].Component));
1610
1611 sz = 0x100;
1612 if (!MSI_RecordIsNull(row,2))
1613 MSI_RecordGetStringW(row,2,package->components[index].ComponentId,&sz);
1614
1615 sz = 96;
1616 MSI_RecordGetStringW(row,3,package->components[index].Directory,&sz);
1617
1618 package->components[index].Attributes = MSI_RecordGetInteger(row,4);
1619
1620 sz = 0x100;
1621 MSI_RecordGetStringW(row,5,package->components[index].Condition,&sz);
1622
1623 sz = 96;
1624 MSI_RecordGetStringW(row,6,package->components[index].KeyPath,&sz);
1625
1626 package->components[index].Installed = INSTALLSTATE_ABSENT;
1627 package->components[index].Action = INSTALLSTATE_UNKNOWN;
1628 package->components[index].ActionRequest = INSTALLSTATE_UNKNOWN;
1629
1630 package->components[index].Enabled = TRUE;
1631
1632 return index;
1633 }
1634
1635 static void load_feature(MSIPACKAGE* package, MSIRECORD * row)
1636 {
1637 int index = package->loaded_features;
1638 DWORD sz;
1639 static const WCHAR Query1[] =
1640 {'S','E','L','E','C','T',' ',
1641 '`','C','o','m','p','o','n','e','n','t','_','`',
1642 ' ','F','R','O','M',' ','`','F','e','a','t','u','r','e',
1643 'C','o','m','p','o','n','e','n','t','s','`',' ',
1644 'W','H','E','R','E',' ',
1645 '`','F','e', 'a','t','u','r','e','_','`',' ','=','\'','%','s','\'',0};
1646 static const WCHAR Query2[] =
1647 {'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
1648 '`','C','o','m','p','o','n','e','n','t','`',' ',
1649 'W','H','E','R','E',' ',
1650 '`','C','o','m','p','o','n','e','n','t','`',' ',
1651 '=','\'','%','s','\'',0};
1652 MSIQUERY * view;
1653 MSIQUERY * view2;
1654 MSIRECORD * row2;
1655 MSIRECORD * row3;
1656 UINT rc;
1657
1658 /* fill in the data */
1659
1660 package->loaded_features ++;
1661 if (package->loaded_features == 1)
1662 package->features = HeapAlloc(GetProcessHeap(),0,sizeof(MSIFEATURE));
1663 else
1664 package->features = HeapReAlloc(GetProcessHeap(),0,package->features,
1665 package->loaded_features * sizeof(MSIFEATURE));
1666
1667 memset(&package->features[index],0,sizeof(MSIFEATURE));
1668
1669 sz = 96;
1670 MSI_RecordGetStringW(row,1,package->features[index].Feature,&sz);
1671
1672 TRACE("Loading feature %s\n",debugstr_w(package->features[index].Feature));
1673
1674 sz = 96;
1675 if (!MSI_RecordIsNull(row,2))
1676 MSI_RecordGetStringW(row,2,package->features[index].Feature_Parent,&sz);
1677
1678 sz = 0x100;
1679 if (!MSI_RecordIsNull(row,3))
1680 MSI_RecordGetStringW(row,3,package->features[index].Title,&sz);
1681
1682 sz = 0x100;
1683 if (!MSI_RecordIsNull(row,4))
1684 MSI_RecordGetStringW(row,4,package->features[index].Description,&sz);
1685
1686 if (!MSI_RecordIsNull(row,5))
1687 package->features[index].Display = MSI_RecordGetInteger(row,5);
1688
1689 package->features[index].Level= MSI_RecordGetInteger(row,6);
1690
1691 sz = 96;
1692 if (!MSI_RecordIsNull(row,7))
1693 MSI_RecordGetStringW(row,7,package->features[index].Directory,&sz);
1694
1695 package->features[index].Attributes= MSI_RecordGetInteger(row,8);
1696
1697 package->features[index].Installed = INSTALLSTATE_ABSENT;
1698 package->features[index].Action = INSTALLSTATE_UNKNOWN;
1699 package->features[index].ActionRequest = INSTALLSTATE_UNKNOWN;
1700
1701 /* load feature components */
1702
1703 rc = MSI_OpenQuery(package->db, &view, Query1, package->features[index].Feature);
1704 if (rc != ERROR_SUCCESS)
1705 return;
1706 rc = MSI_ViewExecute(view,0);
1707 if (rc != ERROR_SUCCESS)
1708 {
1709 MSI_ViewClose(view);
1710 msiobj_release(&view->hdr);
1711 return;
1712 }
1713 while (1)
1714 {
1715 DWORD sz = 0x100;
1716 WCHAR buffer[0x100];
1717 DWORD rc;
1718 INT c_indx;
1719 INT cnt = package->features[index].ComponentCount;
1720
1721 rc = MSI_ViewFetch(view,&row2);
1722 if (rc != ERROR_SUCCESS)
1723 break;
1724
1725 sz = 0x100;
1726 MSI_RecordGetStringW(row2,1,buffer,&sz);
1727
1728 /* check to see if the component is already loaded */
1729 c_indx = get_loaded_component(package,buffer);
1730 if (c_indx != -1)
1731 {
1732 TRACE("Component %s already loaded at %i\n", debugstr_w(buffer),
1733 c_indx);
1734 package->features[index].Components[cnt] = c_indx;
1735 package->features[index].ComponentCount ++;
1736 msiobj_release( &row2->hdr );
1737 continue;
1738 }
1739
1740 rc = MSI_OpenQuery(package->db, &view2, Query2, buffer);
1741 if (rc != ERROR_SUCCESS)
1742 {
1743 msiobj_release( &row2->hdr );
1744 continue;
1745 }
1746 rc = MSI_ViewExecute(view2,0);
1747 if (rc != ERROR_SUCCESS)
1748 {
1749 msiobj_release( &row2->hdr );
1750 MSI_ViewClose(view2);
1751 msiobj_release( &view2->hdr );
1752 continue;
1753 }
1754 while (1)
1755 {
1756 DWORD rc;
1757
1758 rc = MSI_ViewFetch(view2,&row3);
1759 if (rc != ERROR_SUCCESS)
1760 break;
1761 c_indx = load_component(package,row3);
1762 msiobj_release( &row3->hdr );
1763
1764 package->features[index].Components[cnt] = c_indx;
1765 package->features[index].ComponentCount ++;
1766 TRACE("Loaded new component to index %i\n",c_indx);
1767 }
1768 MSI_ViewClose(view2);
1769 msiobj_release( &view2->hdr );
1770 msiobj_release( &row2->hdr );
1771 }
1772 MSI_ViewClose(view);
1773 msiobj_release(&view->hdr);
1774 }
1775
1776 static UINT load_file(MSIPACKAGE* package, MSIRECORD * row)
1777 {
1778 DWORD index = package->loaded_files;
1779 DWORD i;
1780 LPWSTR buffer;
1781
1782 /* fill in the data */
1783
1784 package->loaded_files++;
1785 if (package->loaded_files== 1)
1786 package->files = HeapAlloc(GetProcessHeap(),0,sizeof(MSIFILE));
1787 else
1788 package->files = HeapReAlloc(GetProcessHeap(),0,
1789 package->files , package->loaded_files * sizeof(MSIFILE));
1790
1791 memset(&package->files[index],0,sizeof(MSIFILE));
1792
1793 package->files[index].File = load_dynamic_stringW(row, 1);
1794 buffer = load_dynamic_stringW(row, 2);
1795
1796 package->files[index].ComponentIndex = -1;
1797 for (i = 0; i < package->loaded_components; i++)
1798 if (strcmpW(package->components[i].Component,buffer)==0)
1799 {
1800 package->files[index].ComponentIndex = i;
1801 break;
1802 }
1803 if (package->files[index].ComponentIndex == -1)
1804 ERR("Unfound Component %s\n",debugstr_w(buffer));
1805 HeapFree(GetProcessHeap(), 0, buffer);
1806
1807 package->files[index].FileName = load_dynamic_stringW(row,3);
1808 reduce_to_longfilename(package->files[index].FileName);
1809
1810 package->files[index].ShortName = load_dynamic_stringW(row,3);
1811 reduce_to_shortfilename(package->files[index].ShortName);
1812
1813 package->files[index].FileSize = MSI_RecordGetInteger(row,4);
1814 package->files[index].Version = load_dynamic_stringW(row, 5);
1815 package->files[index].Language = load_dynamic_stringW(row, 6);
1816 package->files[index].Attributes= MSI_RecordGetInteger(row,7);
1817 package->files[index].Sequence= MSI_RecordGetInteger(row,8);
1818
1819 package->files[index].Temporary = FALSE;
1820 package->files[index].State = 0;
1821
1822 TRACE("File Loaded (%s)\n",debugstr_w(package->files[index].File));
1823
1824 return ERROR_SUCCESS;
1825 }
1826
1827 static UINT load_all_files(MSIPACKAGE *package)
1828 {
1829 MSIQUERY * view;
1830 MSIRECORD * row;
1831 UINT rc;
1832 static const WCHAR Query[] =
1833 {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1834 '`','F','i','l','e','`',' ', 'O','R','D','E','R',' ','B','Y',' ',
1835 '`','S','e','q','u','e','n','c','e','`', 0};
1836
1837 if (!package)
1838 return ERROR_INVALID_HANDLE;
1839
1840 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
1841 if (rc != ERROR_SUCCESS)
1842 return ERROR_SUCCESS;
1843
1844 rc = MSI_ViewExecute(view, 0);
1845 if (rc != ERROR_SUCCESS)
1846 {
1847 MSI_ViewClose(view);
1848 msiobj_release(&view->hdr);
1849 return ERROR_SUCCESS;
1850 }
1851
1852 while (1)
1853 {
1854 rc = MSI_ViewFetch(view,&row);
1855 if (rc != ERROR_SUCCESS)
1856 {
1857 rc = ERROR_SUCCESS;
1858 break;
1859 }
1860 load_file(package,row);
1861 msiobj_release(&row->hdr);
1862 }
1863 MSI_ViewClose(view);
1864 msiobj_release(&view->hdr);
1865
1866 return ERROR_SUCCESS;
1867 }
1868
1869
1870 /*
1871 * I am not doing any of the costing functionality yet.
1872 * Mostly looking at doing the Component and Feature loading
1873 *
1874 * The native MSI does A LOT of modification to tables here. Mostly adding
1875 * a lot of temporary columns to the Feature and Component tables.
1876 *
1877 * note: Native msi also tracks the short filename. But I am only going to
1878 * track the long ones. Also looking at this directory table
1879 * it appears that the directory table does not get the parents
1880 * resolved base on property only based on their entries in the
1881 * directory table.
1882 */
1883 static UINT ACTION_CostInitialize(MSIPACKAGE *package)
1884 {
1885 MSIQUERY * view;
1886 MSIRECORD * row;
1887 UINT rc;
1888 static const WCHAR Query_all[] =
1889 {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1890 '`','F','e','a','t','u','r','e','`',0};
1891 static const WCHAR szCosting[] =
1892 {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
1893 static const WCHAR szZero[] = { '0', 0 };
1894 WCHAR buffer[3];
1895 DWORD sz = 3;
1896
1897 MSI_GetPropertyW(package, szCosting, buffer, &sz);
1898 if (buffer[0]=='1')
1899 return ERROR_SUCCESS;
1900
1901 MSI_SetPropertyW(package, szCosting, szZero);
1902 MSI_SetPropertyW(package, cszRootDrive , c_colon);
1903
1904 rc = MSI_DatabaseOpenViewW(package->db,Query_all,&view);
1905 if (rc != ERROR_SUCCESS)
1906 return rc;
1907 rc = MSI_ViewExecute(view,0);
1908 if (rc != ERROR_SUCCESS)
1909 {
1910 MSI_ViewClose(view);
1911 msiobj_release(&view->hdr);
1912 return rc;
1913 }
1914 while (1)
1915 {
1916 DWORD rc;
1917
1918 rc = MSI_ViewFetch(view,&row);
1919 if (rc != ERROR_SUCCESS)
1920 break;
1921
1922 load_feature(package,row);
1923 msiobj_release(&row->hdr);
1924 }
1925 MSI_ViewClose(view);
1926 msiobj_release(&view->hdr);
1927
1928 load_all_files(package);
1929
1930 return ERROR_SUCCESS;
1931 }
1932
1933 static UINT ACTION_FileCost(MSIPACKAGE *package)
1934 {
1935 return ERROR_SUCCESS;
1936 }
1937
1938
1939 static INT load_folder(MSIPACKAGE *package, const WCHAR* dir)
1940 {
1941 static const WCHAR Query[] =
1942 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1943 '`','D','i','r','e','c', 't','o','r','y','`',' ',
1944 'W','H','E','R','E',' ', '`', 'D','i','r','e','c','t', 'o','r','y','`',
1945 ' ','=',' ','\'','%','s','\'',
1946 0};
1947 UINT rc;
1948 MSIQUERY * view;
1949 LPWSTR ptargetdir, targetdir, parent, srcdir;
1950 LPWSTR shortname = NULL;
1951 MSIRECORD * row = 0;
1952 INT index = -1;
1953 DWORD i;
1954
1955 TRACE("Looking for dir %s\n",debugstr_w(dir));
1956
1957 for (i = 0; i < package->loaded_folders; i++)
1958 {
1959 if (strcmpW(package->folders[i].Directory,dir)==0)
1960 {
1961 TRACE(" %s retuning on index %lu\n",debugstr_w(dir),i);
1962 return i;
1963 }
1964 }
1965
1966 TRACE("Working to load %s\n",debugstr_w(dir));
1967
1968 index = package->loaded_folders++;
1969 if (package->loaded_folders==1)
1970 package->folders = HeapAlloc(GetProcessHeap(),0,
1971 sizeof(MSIFOLDER));
1972 else
1973 package->folders= HeapReAlloc(GetProcessHeap(),0,
1974 package->folders, package->loaded_folders*
1975 sizeof(MSIFOLDER));
1976
1977 memset(&package->folders[index],0,sizeof(MSIFOLDER));
1978
1979 package->folders[index].Directory = strdupW(dir);
1980
1981 rc = MSI_OpenQuery(package->db, &view, Query, dir);
1982 if (rc != ERROR_SUCCESS)
1983 return -1;
1984
1985 rc = MSI_ViewExecute(view, 0);
1986 if (rc != ERROR_SUCCESS)
1987 {
1988 MSI_ViewClose(view);
1989 msiobj_release(&view->hdr);
1990 return -1;
1991 }
1992
1993 rc = MSI_ViewFetch(view,&row);
1994 if (rc != ERROR_SUCCESS)
1995 {
1996 MSI_ViewClose(view);
1997 msiobj_release(&view->hdr);
1998 return -1;
1999 }
2000
2001 ptargetdir = targetdir = load_dynamic_stringW(row,3);
2002
2003 /* split src and target dir */
2004 if (strchrW(targetdir,':'))
2005 {
2006 srcdir=strchrW(targetdir,':');
2007 *srcdir=0;
2008 srcdir ++;
2009 }
2010 else
2011 srcdir=NULL;
2012
2013 /* for now only pick long filename versions */
2014 if (strchrW(targetdir,'|'))
2015 {
2016 shortname = targetdir;
2017 targetdir = strchrW(targetdir,'|');
2018 *targetdir = 0;
2019 targetdir ++;
2020 }
2021 /* for the sourcedir pick the short filename */
2022 if (srcdir && strchrW(srcdir,'|'))
2023 {
2024 LPWSTR p = strchrW(srcdir,'|');
2025 *p = 0;
2026 }
2027
2028 /* now check for root dirs */
2029 if (targetdir[0] == '.' && targetdir[1] == 0)
2030 targetdir = NULL;
2031
2032 if (srcdir && srcdir[0] == '.' && srcdir[1] == 0)
2033 srcdir = NULL;
2034
2035 if (targetdir)
2036 {
2037 TRACE(" TargetDefault = %s\n",debugstr_w(targetdir));
2038 HeapFree(GetProcessHeap(),0, package->folders[index].TargetDefault);
2039 package->folders[index].TargetDefault = strdupW(targetdir);
2040 }
2041
2042 if (srcdir)
2043 package->folders[index].SourceDefault = strdupW(srcdir);
2044 else if (shortname)
2045 package->folders[index].SourceDefault = strdupW(shortname);
2046 else if (targetdir)
2047 package->folders[index].SourceDefault = strdupW(targetdir);
2048 HeapFree(GetProcessHeap(), 0, ptargetdir);
2049 TRACE(" SourceDefault = %s\n",debugstr_w(package->folders[index].SourceDefault));
2050
2051 parent = load_dynamic_stringW(row,2);
2052 if (parent)
2053 {
2054 i = load_folder(package,parent);
2055 package->folders[index].ParentIndex = i;
2056 TRACE("Parent is index %i... %s %s\n",
2057 package->folders[index].ParentIndex,
2058 debugstr_w(package->folders[package->folders[index].ParentIndex].Directory),
2059 debugstr_w(parent));
2060 }
2061 else
2062 package->folders[index].ParentIndex = -2;
2063 HeapFree(GetProcessHeap(), 0, parent);
2064
2065 package->folders[index].Property = load_dynamic_property(package, dir,NULL);
2066
2067 msiobj_release(&row->hdr);
2068 MSI_ViewClose(view);
2069 msiobj_release(&view->hdr);
2070 TRACE(" %s retuning on index %i\n",debugstr_w(dir),index);
2071 return index;
2072 }
2073
2074
2075 LPWSTR resolve_folder(MSIPACKAGE *package, LPCWSTR name, BOOL source,
2076 BOOL set_prop, MSIFOLDER **folder)
2077 {
2078 DWORD i;
2079 LPWSTR p, path = NULL;
2080
2081 TRACE("Working to resolve %s\n",debugstr_w(name));
2082
2083 /* special resolving for Target and Source root dir */
2084 if (strcmpW(name,cszTargetDir)==0 || strcmpW(name,cszSourceDir)==0)
2085 {
2086 if (!source)
2087 {
2088 path = load_dynamic_property(package,cszTargetDir,NULL);
2089 if (!path)
2090 {
2091 path = load_dynamic_property(package,cszRootDrive,NULL);
2092 if (set_prop)
2093 MSI_SetPropertyW(package,cszTargetDir,path);
2094 }
2095 if (folder)
2096 {
2097 for (i = 0; i < package->loaded_folders; i++)
2098 {
2099 if (strcmpW(package->folders[i].Directory,name)==0)
2100 break;
2101 }
2102 *folder = &(package->folders[i]);
2103 }
2104 return path;
2105 }
2106 else
2107 {
2108 path = load_dynamic_property(package,cszSourceDir,NULL);
2109 if (!path)
2110 {
2111 path = load_dynamic_property(package,cszDatabase,NULL);
2112 if (path)
2113 {
2114 p = strrchrW(path,'\\');
2115 if (p)
2116 *(p+1) = 0;
2117 }
2118 }
2119 if (folder)
2120 {
2121 for (i = 0; i < package->loaded_folders; i++)
2122 {
2123 if (strcmpW(package->folders[i].Directory,name)==0)
2124 break;
2125 }
2126 *folder = &(package->folders[i]);
2127 }
2128 return path;
2129 }
2130 }
2131
2132 for (i = 0; i < package->loaded_folders; i++)
2133 {
2134 if (strcmpW(package->folders[i].Directory,name)==0)
2135 break;
2136 }
2137
2138 if (i >= package->loaded_folders)
2139 return NULL;
2140
2141 if (folder)
2142 *folder = &(package->folders[i]);
2143
2144 if (!source && package->folders[i].ResolvedTarget)
2145 {
2146 path = strdupW(package->folders[i].ResolvedTarget);
2147 TRACE(" already resolved to %s\n",debugstr_w(path));
2148 return path;
2149 }
2150 else if (source && package->folders[i].ResolvedSource)
2151 {
2152 path = strdupW(package->folders[i].ResolvedSource);
2153 TRACE(" (source)already resolved to %s\n",debugstr_w(path));
2154 return path;
2155 }
2156 else if (!source && package->folders[i].Property)
2157 {
2158 path = build_directory_name(2, package->folders[i].Property, NULL);
2159
2160 TRACE(" internally set to %s\n",debugstr_w(path));
2161 if (set_prop)
2162 MSI_SetPropertyW(package,name,path);
2163 return path;
2164 }
2165
2166 if (package->folders[i].ParentIndex >= 0)
2167 {
2168 LPWSTR parent = package->folders[package->folders[i].ParentIndex].Directory;
2169
2170 TRACE(" ! Parent is %s\n", debugstr_w(parent));
2171
2172 p = resolve_folder(package, parent, source, set_prop, NULL);
2173 if (!source)
2174 {
2175 TRACE(" TargetDefault = %s\n",debugstr_w(package->folders[i].TargetDefault));
2176 path = build_directory_name(3, p, package->folders[i].TargetDefault, NULL);
2177 package->folders[i].ResolvedTarget = strdupW(path);
2178 TRACE(" resolved into %s\n",debugstr_w(path));
2179 if (set_prop)
2180 MSI_SetPropertyW(package,name,path);
2181 }
2182 else
2183 {
2184 path = build_directory_name(3, p, package->folders[i].SourceDefault, NULL);
2185 TRACE(" (source)resolved into %s\n",debugstr_w(path));
2186 package->folders[i].ResolvedSource = strdupW(path);
2187 }
2188 HeapFree(GetProcessHeap(),0,p);
2189 }
2190 return path;
2191 }
2192
2193 /* scan for and update current install states */
2194 void ACTION_UpdateInstallStates(MSIPACKAGE *package)
2195 {
2196 int i;
2197 LPWSTR productcode;
2198
2199 productcode = load_dynamic_property(package,szProductCode,NULL);
2200
2201 for (i = 0; i < package->loaded_components; i++)
2202 {
2203 INSTALLSTATE res;
2204 res = MsiGetComponentPathW(productcode,
2205 package->components[i].ComponentId , NULL, NULL);
2206 if (res < 0)
2207 res = INSTALLSTATE_ABSENT;
2208 package->components[i].Installed = res;
2209 }
2210
2211 for (i = 0; i < package->loaded_features; i++)
2212 {
2213 INSTALLSTATE res = -10;
2214 int j;
2215 for (j = 0; j < package->features[i].ComponentCount; j++)
2216 {
2217 MSICOMPONENT* component = &package->components[package->features[i].
2218 Components[j]];
2219 if (res == -10)
2220 res = component->Installed;
2221 else
2222 {
2223 if (res == component->Installed)
2224 continue;
2225
2226 if (res != component->Installed)
2227 res = INSTALLSTATE_INCOMPLETE;
2228 }
2229 }
2230 }
2231 }
2232
2233 /* update compoennt state based on a feature change */
2234 void ACTION_UpdateComponentStates(MSIPACKAGE *package, LPCWSTR szFeature)
2235 {
2236 int i;
2237 INSTALLSTATE newstate;
2238 MSIFEATURE *feature;
2239
2240 i = get_loaded_feature(package,szFeature);
2241 if (i < 0)
2242 return;
2243
2244 feature = &package->features[i];
2245 newstate = feature->ActionRequest;
2246
2247 for( i = 0; i < feature->ComponentCount; i++)
2248 {
2249 MSICOMPONENT* component = &package->components[feature->Components[i]];
2250
2251 TRACE("MODIFYING(%i): Component %s (Installed %i, Action %i, Request %i)\n",
2252 newstate, debugstr_w(component->Component), component->Installed,
2253 component->Action, component->ActionRequest);
2254
2255 if (!component->Enabled)
2256 continue;
2257 else
2258 {
2259 if (newstate == INSTALLSTATE_LOCAL)
2260 {
2261 component->ActionRequest = INSTALLSTATE_LOCAL;
2262 component->Action = INSTALLSTATE_LOCAL;
2263 }
2264 else
2265 {
2266 int j,k;
2267
2268 component->ActionRequest = newstate;
2269 component->Action = newstate;
2270
2271 /*if any other feature wants is local we need to set it local*/
2272 for (j = 0;
2273 j < package->loaded_features &&
2274 component->ActionRequest != INSTALLSTATE_LOCAL;
2275 j++)
2276 {
2277 for (k = 0; k < package->features[j].ComponentCount; k++)
2278 if ( package->features[j].Components[k] ==
2279 feature->Components[i] )
2280 {
2281 if (package->features[j].ActionRequest ==
2282 INSTALLSTATE_LOCAL)
2283 {
2284 TRACE("Saved by %s\n", debugstr_w(package->features[j].Feature));
2285 component->ActionRequest = INSTALLSTATE_LOCAL;
2286 component->Action = INSTALLSTATE_LOCAL;
2287 }
2288 break;
2289 }
2290 }
2291 }
2292 }
2293 TRACE("Result (%i): Component %s (Installed %i, Action %i, Request %i)\n",
2294 newstate, debugstr_w(component->Component), component->Installed,
2295 component->Action, component->ActionRequest);
2296 }
2297 }
2298
2299 static BOOL process_state_property (MSIPACKAGE* package, LPCWSTR property,
2300 INSTALLSTATE state)
2301 {
2302 static const WCHAR all[]={'A','L','L',0};
2303 LPWSTR override = NULL;
2304 INT i;
2305 BOOL rc = FALSE;
2306
2307 override = load_dynamic_property(package, property, NULL);
2308 if (override)
2309 {
2310 rc = TRUE;
2311 for(i = 0; i < package->loaded_features; i++)
2312 {
2313 if (strcmpiW(override,all)==0)
2314 {
2315 package->features[i].ActionRequest= state;
2316 package->features[i].Action = state;
2317 }
2318 else
2319 {
2320 LPWSTR ptr = override;
2321 LPWSTR ptr2 = strchrW(override,',');
2322
2323 while (ptr)
2324 {
2325 if ((ptr2 &&
2326 strncmpW(ptr,package->features[i].Feature, ptr2-ptr)==0)
2327 || (!ptr2 &&
2328 strcmpW(ptr,package->features[i].Feature)==0))
2329 {
2330 package->features[i].ActionRequest= state;
2331 package->features[i].Action = state;
2332 break;
2333 }
2334 if (ptr2)
2335 {
2336 ptr=ptr2+1;
2337 ptr2 = strchrW(ptr,',');
2338 }
2339 else
2340 break;
2341 }
2342 }
2343 }
2344 HeapFree(GetProcessHeap(),0,override);
2345 }
2346
2347 return rc;
2348 }
2349
2350 static UINT SetFeatureStates(MSIPACKAGE *package)
2351 {
2352 LPWSTR level;
2353 INT install_level;
2354 DWORD i;
2355 INT j;
2356 static const WCHAR szlevel[] =
2357 {'I','N','S','T','A','L','L','L','E','V','E','L',0};
2358 static const WCHAR szAddLocal[] =
2359 {'A','D','D','L','O','C','A','L',0};
2360 static const WCHAR szRemove[] =
2361 {'R','E','M','O','V','E',0};
2362 BOOL override = FALSE;
2363
2364 /* I do not know if this is where it should happen.. but */
2365
2366 TRACE("Checking Install Level\n");
2367
2368 level = load_dynamic_property(package,szlevel,NULL);
2369 if (level)
2370 {
2371 install_level = atoiW(level);
2372 HeapFree(GetProcessHeap(), 0, level);
2373 }
2374 else
2375 install_level = 1;
2376
2377 /* ok hereis the _real_ rub
2378 * all these activation/deactivation things happen in order and things
2379 * later on the list override things earlier on the list.
2380 * 1) INSTALLLEVEL processing
2381 * 2) ADDLOCAL
2382 * 3) REMOVE
2383 * 4) ADDSOURCE
2384 * 5) ADDDEFAULT
2385 * 6) REINSTALL
2386 * 7) COMPADDLOCAL
2387 * 8) COMPADDSOURCE
2388 * 9) FILEADDLOCAL
2389 * 10) FILEADDSOURCE
2390 * 11) FILEADDDEFAULT
2391 * I have confirmed that if ADDLOCAL is stated then the INSTALLLEVEL is
2392 * ignored for all the features. seems strange, especially since it is not
2393 * documented anywhere, but it is how it works.
2394 *
2395 * I am still ignoring a lot of these. But that is ok for now, ADDLOCAL and
2396 * REMOVE are the big ones, since we don't handle administrative installs
2397 * yet anyway.
2398 */
2399 override |= process_state_property(package,szAddLocal,INSTALLSTATE_LOCAL);
2400 override |= process_state_property(package,szRemove,INSTALLSTATE_ABSENT);
2401
2402 if (!override)
2403 {
2404 for(i = 0; i < package->loaded_features; i++)
2405 {
2406 BOOL feature_state = ((package->features[i].Level > 0) &&
2407 (package->features[i].Level <= install_level));
2408
2409 if ((feature_state) &&
2410 (package->features[i].Action == INSTALLSTATE_UNKNOWN))
2411 {
2412 if (package->features[i].Attributes &
2413 msidbFeatureAttributesFavorSource)
2414 {
2415 package->features[i].ActionRequest = INSTALLSTATE_SOURCE;
2416 package->features[i].Action = INSTALLSTATE_SOURCE;
2417 }
2418 else if (package->features[i].Attributes &
2419 msidbFeatureAttributesFavorAdvertise)
2420 {
2421 package->features[i].ActionRequest =INSTALLSTATE_ADVERTISED;
2422 package->features[i].Action =INSTALLSTATE_ADVERTISED;
2423 }
2424 else
2425 {
2426 package->features[i].ActionRequest = INSTALLSTATE_LOCAL;
2427 package->features[i].Action = INSTALLSTATE_LOCAL;
2428 }
2429 }
2430 }
2431 }
2432
2433 /*
2434 * now we want to enable or disable components base on feature
2435 */
2436
2437 for(i = 0; i < package->loaded_features; i++)
2438 {
2439 MSIFEATURE* feature = &package->features[i];
2440 TRACE("Examining Feature %s (Installed %i, Action %i, Request %i)\n",
2441 debugstr_w(feature->Feature), feature->Installed, feature->Action,
2442 feature->ActionRequest);
2443
2444 for( j = 0; j < feature->ComponentCount; j++)
2445 {
2446 MSICOMPONENT* component = &package->components[
2447 feature->Components[j]];
2448
2449 if (!component->Enabled)
2450 {
2451 component->Action = INSTALLSTATE_UNKNOWN;
2452 component->ActionRequest = INSTALLSTATE_UNKNOWN;
2453 }
2454 else
2455 {
2456 if (feature->Action == INSTALLSTATE_LOCAL)
2457 {
2458 component->Action = INSTALLSTATE_LOCAL;
2459 component->ActionRequest = INSTALLSTATE_LOCAL;
2460 }
2461 else if (feature->ActionRequest == INSTALLSTATE_SOURCE)
2462 {
2463 if ((component->Action == INSTALLSTATE_UNKNOWN) ||
2464 (component->Action == INSTALLSTATE_ABSENT) ||
2465 (component->Action == INSTALLSTATE_ADVERTISED))
2466
2467 {
2468 component->Action = INSTALLSTATE_SOURCE;
2469 component->ActionRequest = INSTALLSTATE_SOURCE;
2470 }
2471 }
2472 else if (feature->ActionRequest == INSTALLSTATE_ADVERTISED)
2473 {
2474 if ((component->Action == INSTALLSTATE_UNKNOWN) ||
2475 (component->Action == INSTALLSTATE_ABSENT))
2476
2477 {
2478 component->Action = INSTALLSTATE_ADVERTISED;
2479 component->ActionRequest = INSTALLSTATE_ADVERTISED;
2480 }
2481 }
2482 else if (feature->ActionRequest == INSTALLSTATE_ABSENT)
2483 {
2484 if (component->Action == INSTALLSTATE_UNKNOWN)
2485 {
2486 component->Action = INSTALLSTATE_ABSENT;
2487 component->ActionRequest = INSTALLSTATE_ABSENT;
2488 }
2489 }
2490 }
2491 }
2492 }
2493
2494 for(i = 0; i < package->loaded_components; i++)
2495 {
2496 MSICOMPONENT* component= &package->components[i];
2497
2498 TRACE("Result: Component %s (Installed %i, Action %i, Request %i)\n",
2499 debugstr_w(component->Component), component->Installed,
2500 component->Action, component->ActionRequest);
2501 }
2502
2503
2504 return ERROR_SUCCESS;
2505 }
2506
2507 /*
2508 * A lot is done in this function aside from just the costing.
2509 * The costing needs to be implemented at some point but for now I am going
2510 * to focus on the directory building
2511 *
2512 */
2513 static UINT ACTION_CostFinalize(MSIPACKAGE *package)
2514 {
2515 static const WCHAR ExecSeqQuery[] =
2516 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2517 '`','D','i','r','e','c','t','o','r','y','`',0};
2518 static const WCHAR ConditionQuery[] =
2519 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2520 '`','C','o','n','d','i','t','i','o','n','`',0};
2521 static const WCHAR szCosting[] =
2522 {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
2523 static const WCHAR szlevel[] =
2524 {'I','N','S','T','A','L','L','L','E','V','E','L',0};
2525 static const WCHAR szOne[] = { '1', 0 };
2526 UINT rc;
2527 MSIQUERY * view;
2528 DWORD i;
2529 LPWSTR level;
2530 DWORD sz = 3;
2531 WCHAR buffer[3];
2532
2533 MSI_GetPropertyW(package, szCosting, buffer, &sz);
2534 if (buffer[0]=='1')
2535 return ERROR_SUCCESS;
2536
2537 TRACE("Building Directory properties\n");
2538
2539 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2540 if (rc == ERROR_SUCCESS)
2541 {
2542 rc = MSI_ViewExecute(view, 0);
2543 if (rc != ERROR_SUCCESS)
2544 {
2545 MSI_ViewClose(view);
2546 msiobj_release(&view->hdr);
2547 return rc;
2548 }
2549
2550 while (1)
2551 {
2552 WCHAR name[0x100];
2553 LPWSTR path;
2554 MSIRECORD * row = 0;
2555 DWORD sz;
2556
2557 rc = MSI_ViewFetch(view,&row);
2558 if (rc != ERROR_SUCCESS)
2559 {
2560 rc = ERROR_SUCCESS;
2561 break;
2562 }
2563
2564 sz=0x100;
2565 MSI_RecordGetStringW(row,1,name,&sz);
2566
2567 /* This helper function now does ALL the work */
2568 TRACE("Dir %s ...\n",debugstr_w(name));
2569 load_folder(package,name);
2570 path = resolve_folder(package,name,FALSE,TRUE,NULL);
2571 TRACE("resolves to %s\n",debugstr_w(path));
2572 HeapFree( GetProcessHeap(), 0, path);
2573
2574 msiobj_release(&row->hdr);
2575 }
2576 MSI_ViewClose(view);
2577 msiobj_release(&view->hdr);
2578 }
2579
2580 TRACE("File calculations %i files\n",package->loaded_files);
2581
2582 for (i = 0; i < package->loaded_files; i++)
2583 {
2584 MSICOMPONENT* comp = NULL;
2585 MSIFILE* file= NULL;
2586
2587 file = &package->files[i];
2588 if (file->ComponentIndex >= 0)
2589 comp = &package->components[file->ComponentIndex];
2590
2591 if (file->Temporary == TRUE)
2592 continue;
2593
2594 if (comp)
2595 {
2596 LPWSTR p;
2597
2598 /* calculate target */
2599 p = resolve_folder(package, comp->Directory, FALSE, FALSE, NULL);
2600
2601 HeapFree(GetProcessHeap(),0,file->TargetPath);
2602
2603 TRACE("file %s is named %s\n",
2604 debugstr_w(file->File),debugstr_w(file->FileName));
2605
2606 file->TargetPath = build_directory_name(2, p, file->FileName);
2607
2608 HeapFree(GetProcessHeap(),0,p);
2609
2610 TRACE("file %s resolves to %s\n",
2611 debugstr_w(file->File),debugstr_w(file->TargetPath));
2612
2613 if (GetFileAttributesW(file->TargetPath) == INVALID_FILE_ATTRIBUTES)
2614 {
2615 file->State = 1;
2616 comp->Cost += file->FileSize;
2617 }
2618 else
2619 {
2620 if (file->Version)
2621 {
2622 DWORD handle;
2623 DWORD versize;
2624 UINT sz;
2625 LPVOID version;
2626 static const WCHAR name[] =
2627 {'\\',0};
2628 static const WCHAR name_fmt[] =
2629 {'%','u','.','%','u','.','%','u','.','%','u',0};
2630 WCHAR filever[0x100];
2631 VS_FIXEDFILEINFO *lpVer;
2632
2633 TRACE("Version comparison.. \n");
2634 versize = GetFileVersionInfoSizeW(file->TargetPath,&handle);
2635 version = HeapAlloc(GetProcessHeap(),0,versize);
2636 GetFileVersionInfoW(file->TargetPath, 0, versize, version);
2637
2638 VerQueryValueW(version, name, (LPVOID*)&lpVer, &sz);
2639
2640 sprintfW(filever,name_fmt,
2641 HIWORD(lpVer->dwFileVersionMS),
2642 LOWORD(lpVer->dwFileVersionMS),
2643 HIWORD(lpVer->dwFileVersionLS),
2644 LOWORD(lpVer->dwFileVersionLS));
2645
2646 TRACE("new %s old %s\n", debugstr_w(file->Version),
2647 debugstr_w(filever));
2648 if (strcmpiW(filever,file->Version)<0)
2649 {
2650 file->State = 2;
2651 FIXME("cost should be diff in size\n");
2652 comp->Cost += file->FileSize;
2653 }
2654 else
2655 file->State = 3;
2656 HeapFree(GetProcessHeap(),0,version);
2657 }
2658 else
2659 file->State = 3;
2660 }
2661 }
2662 }
2663
2664 TRACE("Evaluating Condition Table\n");
2665
2666 rc = MSI_DatabaseOpenViewW(package->db, ConditionQuery, &view);
2667 if (rc == ERROR_SUCCESS)
2668 {
2669 rc = MSI_ViewExecute(view, 0);
2670 if (rc != ERROR_SUCCESS)
2671 {
2672 MSI_ViewClose(view);
2673 msiobj_release(&view->hdr);
2674 return rc;
2675 }
2676
2677 while (1)
2678 {
2679 WCHAR Feature[0x100];
2680 MSIRECORD * row = 0;
2681 DWORD sz;
2682 int feature_index;
2683
2684 rc = MSI_ViewFetch(view,&row);
2685
2686 if (rc != ERROR_SUCCESS)
2687 {
2688 rc = ERROR_SUCCESS;
2689 break;
2690 }
2691
2692 sz = 0x100;
2693 MSI_RecordGetStringW(row,1,Feature,&sz);
2694
2695 feature_index = get_loaded_feature(package,Feature);
2696 if (feature_index < 0)
2697 ERR("FAILED to find loaded feature %s\n",debugstr_w(Feature));
2698 else
2699 {
2700 LPWSTR Condition;
2701 Condition = load_dynamic_stringW(row,3);
2702
2703 if (MSI_EvaluateConditionW(package,Condition) ==
2704 MSICONDITION_TRUE)
2705 {
2706 int level = MSI_RecordGetInteger(row,2);
2707 TRACE("Reseting feature %s to level %i\n",
2708 debugstr_w(Feature), level);
2709 package->features[feature_index].Level = level;
2710 }
2711 HeapFree(GetProcessHeap(),0,Condition);
2712 }
2713
2714 msiobj_release(&row->hdr);
2715 }
2716 MSI_ViewClose(view);
2717 msiobj_release(&view->hdr);
2718 }
2719
2720 TRACE("Enabling or Disabling Components\n");
2721 for (i = 0; i < package->loaded_components; i++)
2722 {
2723 if (package->components[i].Condition[0])
2724 {
2725 if (MSI_EvaluateConditionW(package,
2726 package->components[i].Condition) == MSICONDITION_FALSE)
2727 {
2728 TRACE("Disabling component %s\n",
2729 debugstr_w(package->components[i].Component));
2730 package->components[i].Enabled = FALSE;
2731 }
2732 }
2733 }
2734
2735 MSI_SetPropertyW(package,szCosting,szOne);
2736 /* set default run level if not set */
2737 level = load_dynamic_property(package,szlevel,NULL);
2738 if (!level)
2739 MSI_SetPropertyW(package,szlevel, szOne);
2740 else
2741 HeapFree(GetProcessHeap(),0,level);
2742
2743 ACTION_UpdateInstallStates(package);
2744
2745 return SetFeatureStates(package);
2746 }
2747
2748 /*
2749 * This is a helper function for handling embedded cabinet media
2750 */
2751 static UINT writeout_cabinet_stream(MSIPACKAGE *package, WCHAR* stream_name,
2752 WCHAR* source)
2753 {
2754 UINT rc;
2755 USHORT* data;
2756 UINT size;
2757 DWORD write;
2758 HANDLE the_file;
2759 WCHAR tmp[MAX_PATH];
2760
2761 rc = read_raw_stream_data(package->db,stream_name,&data,&size);
2762 if (rc != ERROR_SUCCESS)
2763 return rc;
2764
2765 write = MAX_PATH;
2766 if (MSI_GetPropertyW(package, cszTempFolder, tmp, &write))
2767 GetTempPathW(MAX_PATH,tmp);
2768
2769 GetTempFileNameW(tmp,stream_name,0,source);
2770
2771 track_tempfile(package,strrchrW(source,'\\'), source);
2772 the_file = CreateFileW(source, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
2773 FILE_ATTRIBUTE_NORMAL, NULL);
2774
2775 if (the_file == INVALID_HANDLE_VALUE)
2776 {
2777 ERR("Unable to create file %s\n",debugstr_w(source));
2778 rc = ERROR_FUNCTION_FAILED;
2779 goto end;
2780 }
2781
2782 WriteFile(the_file,data,size,&write,NULL);
2783 CloseHandle(the_file);
2784 TRACE("wrote %li bytes to %s\n",write,debugstr_w(source));
2785 end:
2786 HeapFree(GetProcessHeap(),0,data);
2787 return rc;
2788 }
2789
2790
2791 /* Support functions for FDI functions */
2792 typedef struct
2793 {
2794 MSIPACKAGE* package;
2795 LPCSTR cab_path;
2796 LPCSTR file_name;
2797 } CabData;
2798
2799 static void * cabinet_alloc(ULONG cb)
2800 {
2801 return HeapAlloc(GetProcessHeap(), 0, cb);
2802 }
2803
2804 static void cabinet_free(void *pv)
2805 {
2806 HeapFree(GetProcessHeap(), 0, pv);
2807 }
2808
2809 static INT_PTR cabinet_open(char *pszFile, int oflag, int pmode)
2810 {
2811 DWORD dwAccess = 0;
2812 DWORD dwShareMode = 0;
2813 DWORD dwCreateDisposition = OPEN_EXISTING;
2814 switch (oflag & _O_ACCMODE)
2815 {
2816 case _O_RDONLY:
2817 dwAccess = GENERIC_READ;
2818 dwShareMode = FILE_SHARE_READ | FILE_SHARE_DELETE;
2819 break;
2820 case _O_WRONLY:
2821 dwAccess = GENERIC_WRITE;
2822 dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
2823 break;
2824 case _O_RDWR:
2825 dwAccess = GENERIC_READ | GENERIC_WRITE;
2826 dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
2827 break;
2828 }
2829 if ((oflag & (_O_CREAT | _O_EXCL)) == (_O_CREAT | _O_EXCL))
2830 dwCreateDisposition = CREATE_NEW;
2831 else if (oflag & _O_CREAT)
2832 dwCreateDisposition = CREATE_ALWAYS;
2833 return (INT_PTR)CreateFileA(pszFile, dwAccess, dwShareMode, NULL,
2834 dwCreateDisposition, 0, NULL);
2835 }
2836
2837 static UINT cabinet_read(INT_PTR hf, void *pv, UINT cb)
2838 {
2839 DWORD dwRead;
2840 if (ReadFile((HANDLE)hf, pv, cb, &dwRead, NULL))
2841 return dwRead;
2842 return 0;
2843 }
2844
2845 static UINT cabinet_write(INT_PTR hf, void *pv, UINT cb)
2846 {
2847 DWORD dwWritten;
2848 if (WriteFile((HANDLE)hf, pv, cb, &dwWritten, NULL))
2849 return dwWritten;
2850 return 0;
2851 }
2852
2853 static int cabinet_close(INT_PTR hf)
2854 {
2855 return CloseHandle((HANDLE)hf) ? 0 : -1;
2856 }
2857
2858 static long cabinet_seek(INT_PTR hf, long dist, int seektype)
2859 {
2860 /* flags are compatible and so are passed straight through */
2861 return SetFilePointer((HANDLE)hf, dist, NULL, seektype);
2862 }
2863
2864 static INT_PTR cabinet_notify(FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)
2865 {
2866 /* FIXME: try to do more processing in this function */
2867 switch (fdint)
2868 {
2869 case fdintCOPY_FILE:
2870 {
2871 CabData *data = (CabData*) pfdin->pv;
2872 ULONG len = strlen(data->cab_path) + strlen(pfdin->psz1);
2873 char *file;
2874
2875 LPWSTR trackname;
2876 LPWSTR trackpath;
2877 LPWSTR tracknametmp;
2878 static const WCHAR tmpprefix[] = {'C','A','B','T','M','P','_',0};
2879
2880 if (data->file_name && lstrcmpiA(data->file_name,pfdin->psz1))
2881 return 0;
2882
2883 file = cabinet_alloc((len+1)*sizeof(char));
2884 strcpy(file, data->cab_path);
2885 strcat(file, pfdin->psz1);
2886
2887 TRACE("file: %s\n", debugstr_a(file));
2888
2889 /* track this file so it can be deleted if not installed */
2890 trackpath=strdupAtoW(file);
2891 tracknametmp=strdupAtoW(strrchr(file,'\\')+1);
2892 trackname = HeapAlloc(GetProcessHeap(),0,(strlenW(tracknametmp) +
2893 strlenW(tmpprefix)+1) * sizeof(WCHAR));
2894
2895 strcpyW(trackname,tmpprefix);
2896 strcatW(trackname,tracknametmp);
2897
2898 track_tempfile(data->package, trackname, trackpath);
2899
2900 HeapFree(GetProcessHeap(),0,trackpath);
2901 HeapFree(GetProcessHeap(),0,trackname);
2902 HeapFree(GetProcessHeap(),0,tracknametmp);
2903
2904 return cabinet_open(file, _O_WRONLY | _O_CREAT, 0);
2905 }
2906 case fdintCLOSE_FILE_INFO:
2907 {
2908 FILETIME ft;
2909 FILETIME ftLocal;
2910 if (!DosDateTimeToFileTime(pfdin->date, pfdin->time, &ft))
2911 return -1;
2912 if (!LocalFileTimeToFileTime(&ft, &ftLocal))
2913 return -1;
2914 if (!SetFileTime((HANDLE)pfdin->hf, &ftLocal, 0, &ftLocal))
2915 return -1;
2916
2917 cabinet_close(pfdin->hf);
2918 return 1;
2919 }
2920 default:
2921 return 0;
2922 }
2923 }
2924
2925 /***********************************************************************
2926 * extract_cabinet_file
2927 *
2928 * Extract files from a cab file.
2929 */
2930 static BOOL extract_a_cabinet_file(MSIPACKAGE* package, const WCHAR* source,
2931 const WCHAR* path, const WCHAR* file)
2932 {
2933 HFDI hfdi;
2934 ERF erf;
2935 BOOL ret;
2936 char *cabinet;
2937 char *cab_path;
2938 char *file_name;
2939 CabData data;
2940
2941 TRACE("Extracting %s (%s) to %s\n",debugstr_w(source),
2942 debugstr_w(file), debugstr_w(path));
2943
2944 hfdi = FDICreate(cabinet_alloc,
2945 cabinet_free,
2946 cabinet_open,
2947 cabinet_read,
2948 cabinet_write,
2949 cabinet_close,
2950 cabinet_seek,
2951 0,
2952 &erf);
2953 if (!hfdi)
2954 {
2955 ERR("FDICreate failed\n");
2956 return FALSE;
2957 }
2958
2959 if (!(cabinet = strdupWtoA( source )))
2960 {
2961 FDIDestroy(hfdi);
2962 return FALSE;
2963 }
2964 if (!(cab_path = strdupWtoA( path )))
2965 {
2966 FDIDestroy(hfdi);
2967 HeapFree(GetProcessHeap(), 0, cabinet);
2968 return FALSE;
2969 }
2970
2971 data.package = package;
2972 data.cab_path = cab_path;
2973 if (file)
2974 file_name = strdupWtoA(file);
2975 else
2976 file_name = NULL;
2977 data.file_name = file_name;
2978
2979 ret = FDICopy(hfdi, cabinet, "", 0, cabinet_notify, NULL, &data);
2980
2981 if (!ret)
2982 ERR("FDICopy failed\n");
2983
2984 FDIDestroy(hfdi);
2985
2986 HeapFree(GetProcessHeap(), 0, cabinet);
2987 HeapFree(GetProcessHeap(), 0, cab_path);
2988 HeapFree(GetProcessHeap(), 0, file_name);
2989
2990 return ret;
2991 }
2992
2993 static UINT ready_media_for_file(MSIPACKAGE *package, WCHAR* path,
2994 MSIFILE* file)
2995 {
2996 UINT rc;
2997 MSIQUERY * view;
2998 MSIRECORD * row = 0;
2999 static WCHAR source[MAX_PATH];
3000 static const WCHAR ExecSeqQuery[] =
3001 {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
3002 '`','M','e','d','i','a','`',' ','W','H','E','R','E',' ',
3003 '`','L','a','s','t','S','e','q','u','e','n','c','e','`',' ','>','=',
3004 ' ','%', 'i',' ','O','R','D','E','R',' ','B','Y',' ',
3005 '`','L','a','s','t','S','e','q','u','e','n','c','e','`',0};
3006 WCHAR Query[1024];
3007 WCHAR cab[0x100];
3008 DWORD sz=0x100;
3009 INT seq;
3010 static UINT last_sequence = 0;
3011
3012 if (file->Attributes & msidbFileAttributesNoncompressed)
3013 {
3014 TRACE("Uncompressed File, no media to ready.\n");
3015 return ERROR_SUCCESS;
3016 }
3017
3018 if (file->Sequence <= last_sequence)
3019 {
3020 TRACE("Media already ready (%u, %u)\n",file->Sequence,last_sequence);
3021 /*extract_a_cabinet_file(package, source,path,file->File); */
3022 return ERROR_SUCCESS;
3023 }
3024
3025 sprintfW(Query,ExecSeqQuery,file->Sequence);
3026
3027 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3028 if (rc != ERROR_SUCCESS)
3029 return rc;
3030
3031 rc = MSI_ViewExecute(view, 0);
3032 if (rc != ERROR_SUCCESS)
3033 {
3034 MSI_ViewClose(view);
3035 msiobj_release(&view->hdr);
3036 return rc;
3037 }
3038
3039 rc = MSI_ViewFetch(view,&row);
3040 if (rc != ERROR_SUCCESS)
3041 {
3042 MSI_ViewClose(view);
3043 msiobj_release(&view->hdr);
3044 return rc;
3045 }
3046 seq = MSI_RecordGetInteger(row,2);
3047 last_sequence = seq;
3048
3049 if (!MSI_RecordIsNull(row,4))
3050 {
3051 sz=0x100;
3052 MSI_RecordGetStringW(row,4,cab,&sz);
3053 TRACE("Source is CAB %s\n",debugstr_w(cab));
3054 /* the stream does not contain the # character */
3055 if (cab[0]=='#')
3056 {
3057 writeout_cabinet_stream(package,&cab[1],source);
3058 strcpyW(path,source);
3059 *(strrchrW(path,'\\')+1)=0;
3060 }
3061 else
3062 {
3063 sz = MAX_PATH;
3064 if (MSI_GetPropertyW(package, cszSourceDir, source, &sz))
3065 {
3066 ERR("No Source dir defined \n");
3067 rc = ERROR_FUNCTION_FAILED;
3068 }
3069 else
3070 {
3071 strcpyW(path,source);
3072 strcatW(source,cab);
3073 /* extract the cab file into a folder in the temp folder */
3074 sz = MAX_PATH;
3075 if (MSI_GetPropertyW(package, cszTempFolder,path, &sz)
3076 != ERROR_SUCCESS)
3077 GetTempPathW(MAX_PATH,path);
3078 }
3079 }
3080 rc = !extract_a_cabinet_file(package, source,path,NULL);
3081 }
3082 else
3083 {
3084 sz = MAX_PATH;
3085 MSI_GetPropertyW(package,cszSourceDir,source,&sz);
3086 strcpyW(path,source);
3087 }
3088 msiobj_release(&row->hdr);
3089 MSI_ViewClose(view);
3090 msiobj_release(&view->hdr);
3091 return rc;
3092 }
3093
3094 inline static UINT create_component_directory ( MSIPACKAGE* package, INT component)
3095 {
3096 UINT rc = ERROR_SUCCESS;
3097 MSIFOLDER *folder;
3098 LPWSTR install_path;
3099
3100 install_path = resolve_folder(package, package->components[component].Directory,
3101 FALSE, FALSE, &folder);
3102 if (!install_path)
3103 return ERROR_FUNCTION_FAILED;
3104
3105 /* create the path */
3106 if (folder->State == 0)
3107 {
3108 create_full_pathW(install_path);
3109 folder->State = 2;
3110 }
3111 HeapFree(GetProcessHeap(), 0, install_path);
3112
3113 return rc;
3114 }
3115
3116 static UINT ACTION_InstallFiles(MSIPACKAGE *package)
3117 {
3118 UINT rc = ERROR_SUCCESS;
3119 DWORD index;
3120 MSIRECORD * uirow;
3121 WCHAR uipath[MAX_PATH];
3122
3123 if (!package)
3124 return ERROR_INVALID_HANDLE;
3125
3126 /* increment progress bar each time action data is sent */
3127 ui_progress(package,1,1,0,0);
3128
3129 for (index = 0; index < package->loaded_files; index++)
3130 {
3131 WCHAR path_to_source[MAX_PATH];
3132 MSIFILE *file;
3133
3134 file = &package->files[index];
3135
3136 if (file->Temporary)
3137 continue;
3138
3139
3140 if (!ACTION_VerifyComponentForAction(package, file->ComponentIndex,
3141 INSTALLSTATE_LOCAL))
3142 {
3143 ui_progress(package,2,file->FileSize,0,0);
3144 TRACE("File %s is not scheduled for install\n",
3145 debugstr_w(file->File));
3146
3147 continue;
3148 }
3149
3150 if ((file->State == 1) || (file->State == 2))
3151 {
3152 LPWSTR p;
3153 MSICOMPONENT* comp = NULL;
3154
3155 TRACE("Installing %s\n",debugstr_w(file->File));
3156 rc = ready_media_for_file(package, path_to_source, file);
3157 /*
3158 * WARNING!
3159 * our file table could change here because a new temp file
3160 * may have been created
3161 */
3162 file = &package->files[index];
3163 if (rc != ERROR_SUCCESS)
3164 {
3165 ERR("Unable to ready media\n");
3166 rc = ERROR_FUNCTION_FAILED;
3167 break;
3168 }
3169
3170 create_component_directory( package, file->ComponentIndex);
3171
3172 /* recalculate file paths because things may have changed */
3173
3174 if (file->ComponentIndex >= 0)
3175 comp = &package->components[file->ComponentIndex];
3176
3177 p = resolve_folder(package, comp->Directory, FALSE, FALSE, NULL);
3178 HeapFree(GetProcessHeap(),0,file->TargetPath);
3179
3180 file->TargetPath = build_directory_name(2, p, file->FileName);
3181 HeapFree(GetProcessHeap(),0,p);
3182
3183 if (file->Attributes & msidbFileAttributesNoncompressed)
3184 {
3185 p = resolve_folder(package, comp->Directory, TRUE, FALSE, NULL);
3186 file->SourcePath = build_directory_name(2, p, file->ShortName);
3187 HeapFree(GetProcessHeap(),0,p);
3188 }
3189 else
3190 file->SourcePath = build_directory_name(2, path_to_source,
3191 file->File);
3192
3193
3194 TRACE("file paths %s to %s\n",debugstr_w(file->SourcePath),
3195 debugstr_w(file->TargetPath));
3196
3197 /* the UI chunk */
3198 uirow=MSI_CreateRecord(9);
3199 MSI_RecordSetStringW(uirow,1,file->File);
3200 strcpyW(uipath,file->TargetPath);
3201 *(strrchrW(uipath,'\\')+1)=0;
3202 MSI_RecordSetStringW(uirow,9,uipath);
3203 MSI_RecordSetInteger(uirow,6,file->FileSize);
3204 ui_actiondata(package,szInstallFiles,uirow);
3205 msiobj_release( &uirow->hdr );
3206 ui_progress(package,2,file->FileSize,0,0);
3207
3208
3209 if (file->Attributes & msidbFileAttributesNoncompressed)
3210 rc = CopyFileW(file->SourcePath,file->TargetPath,FALSE);
3211 else
3212 rc = MoveFileW(file->SourcePath, file->TargetPath);
3213
3214 if (!rc)
3215 {
3216 rc = GetLastError();
3217 ERR("Unable to move/copy file (%s -> %s) (error %d)\n",
3218 debugstr_w(file->SourcePath), debugstr_w(file->TargetPath),
3219 rc);
3220 if (rc == ERROR_ALREADY_EXISTS && file->State == 2)
3221 {
3222 if (!CopyFileW(file->SourcePath,file->TargetPath,FALSE))
3223 ERR("Unable to copy file (%s -> %s) (error %ld)\n",
3224 debugstr_w(file->SourcePath),
3225 debugstr_w(file->TargetPath), GetLastError());
3226 if (!(file->Attributes & msidbFileAttributesNoncompressed))
3227 DeleteFileW(file->SourcePath);
3228 rc = 0;
3229 }
3230 else if (rc == ERROR_FILE_NOT_FOUND)
3231 {
3232 ERR("Source File Not Found! Continuing\n");
3233 rc = 0;
3234 }
3235 else if (file->Attributes & msidbFileAttributesVital)
3236 {
3237 ERR("Ignoring Error and continuing (nonvital file)...\n");
3238 rc = 0;
3239 }
3240 }
3241 else
3242 {
3243 file->State = 4;
3244 rc = ERROR_SUCCESS;
3245 }
3246 }
3247 }
3248
3249 return rc;
3250 }
3251
3252 inline static UINT get_file_target(MSIPACKAGE *package, LPCWSTR file_key,
3253 LPWSTR* file_source)
3254 {
3255 DWORD index;
3256
3257 if (!package)
3258 return ERROR_INVALID_HANDLE;
3259
3260 for (index = 0; index < package->loaded_files; index ++)
3261 {
3262 if (strcmpW(file_key,package->files[index].File)==0)
3263 {
3264 if (package->files[index].State >= 2)
3265 {
3266 *file_source = strdupW(package->files[index].TargetPath);
3267 return ERROR_SUCCESS;
3268 }
3269 else
3270 return ERROR_FILE_NOT_FOUND;
3271 }
3272 }
3273
3274 return ERROR_FUNCTION_FAILED;
3275 }
3276
3277 static UINT ACTION_DuplicateFiles(MSIPACKAGE *package)
3278 {
3279 UINT rc;
3280 MSIQUERY * view;
3281 MSIRECORD * row = 0;
3282 static const WCHAR ExecSeqQuery[] =
3283 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3284 '`','D','u','p','l','i','c','a','t','e','F','i','l','e','`',0};
3285
3286 if (!package)
3287 return ERROR_INVALID_HANDLE;
3288
3289 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3290 if (rc != ERROR_SUCCESS)
3291 return ERROR_SUCCESS;
3292
3293 rc = MSI_ViewExecute(view, 0);
3294 if (rc != ERROR_SUCCESS)
3295 {
3296 MSI_ViewClose(view);
3297 msiobj_release(&view->hdr);
3298 return rc;
3299 }
3300
3301 while (1)
3302 {
3303 WCHAR file_key[0x100];
3304 WCHAR *file_source = NULL;
3305 WCHAR dest_name[0x100];
3306 LPWSTR dest_path, dest;
3307 WCHAR component[0x100];
3308 INT component_index;
3309
3310 DWORD sz=0x100;
3311
3312 rc = MSI_ViewFetch(view,&row);
3313 if (rc != ERROR_SUCCESS)
3314 {
3315 rc = ERROR_SUCCESS;
3316 break;
3317 }
3318
3319 sz=0x100;
3320 rc = MSI_RecordGetStringW(row,2,component,&sz);
3321 if (rc != ERROR_SUCCESS)
3322 {
3323 ERR("Unable to get component\n");
3324 msiobj_release(&row->hdr);
3325 break;
3326 }
3327
3328 component_index = get_loaded_component(package,component);
3329
3330 if (!ACTION_VerifyComponentForAction(package, component_index,
3331 INSTALLSTATE_LOCAL))
3332 {
3333 TRACE("Skipping copy due to disabled component\n");
3334
3335 /* the action taken was the same as the current install state */
3336 package->components[component_index].Action =
3337 package->components[component_index].Installed;
3338
3339 msiobj_release(&row->hdr);
3340 continue;
3341 }
3342
3343 package->components[component_index].Action = INSTALLSTATE_LOCAL;
3344
3345 sz=0x100;
3346 rc = MSI_RecordGetStringW(row,3,file_key,&sz);
3347 if (rc != ERROR_SUCCESS)
3348 {
3349 ERR("Unable to get file key\n");
3350 msiobj_release(&row->hdr);
3351 break;
3352 }
3353
3354 rc = get_file_target(package,file_key,&file_source);
3355
3356 if (rc != ERROR_SUCCESS)
3357 {
3358 ERR("Original file unknown %s\n",debugstr_w(file_key));
3359 msiobj_release(&row->hdr);
3360 HeapFree(GetProcessHeap(),0,file_source);
3361 continue;
3362 }
3363
3364 if (MSI_RecordIsNull(row,4))
3365 {
3366 strcpyW(dest_name,strrchrW(file_source,'\\')+1);
3367 }
3368 else
3369 {
3370 sz=0x100;
3371 MSI_RecordGetStringW(row,4,dest_name,&sz);
3372 reduce_to_longfilename(dest_name);
3373 }
3374
3375 if (MSI_RecordIsNull(row,5))
3376 {
3377 LPWSTR p;
3378 dest_path = strdupW(file_source);
3379 p = strrchrW(dest_path,'\\');
3380 if (p)
3381 *p=0;
3382 }
3383 else
3384 {
3385 WCHAR destkey[0x100];
3386 sz=0x100;
3387 MSI_RecordGetStringW(row,5,destkey,&sz);
3388 sz = 0x100;
3389 dest_path = resolve_folder(package, destkey, FALSE,FALSE,NULL);
3390 if (!dest_path)
3391 {
3392 ERR("Unable to get destination folder\n");
3393 msiobj_release(&row->hdr);
3394 HeapFree(GetProcessHeap(),0,file_source);
3395 break;
3396 }
3397 }
3398
3399 dest = build_directory_name(2, dest_path, dest_name);
3400
3401 TRACE("Duplicating file %s to %s\n",debugstr_w(file_source),
3402 debugstr_w(dest));
3403
3404 if (strcmpW(file_source,dest))
3405 rc = !CopyFileW(file_source,dest,TRUE);
3406 else
3407 rc = ERROR_SUCCESS;
3408
3409 if (rc != ERROR_SUCCESS)
3410 ERR("Failed to copy file %s -> %s, last error %ld\n", debugstr_w(file_source), debugstr_w(dest_path), GetLastError());
3411
3412 FIXME("We should track these duplicate files as well\n");
3413
3414 msiobj_release(&row->hdr);
3415 HeapFree(GetProcessHeap(),0,dest_path);
3416 HeapFree(GetProcessHeap(),0,dest);
3417 HeapFree(GetProcessHeap(),0,file_source);
3418 }
3419 MSI_ViewClose(view);
3420 msiobj_release(&view->hdr);
3421 return rc;
3422 }
3423
3424
3425 /* OK this value is "interpreted" and then formatted based on the
3426 first few characters */
3427 static LPSTR parse_value(MSIPACKAGE *package, WCHAR *value, DWORD *type,
3428 DWORD *size)
3429 {
3430 LPSTR data = NULL;
3431 if (value[0]=='#' && value[1]!='#' && value[1]!='%')
3432 {
3433 if (value[1]=='x')
3434 {
3435 LPWSTR ptr;
3436 CHAR byte[5];
3437 LPWSTR deformated = NULL;
3438 int count;
3439
3440 deformat_string(package, &value[2], &deformated);
3441
3442 /* binary value type */
3443 ptr = deformated;
3444 *type = REG_BINARY;
3445 if (strlenW(ptr)%2)
3446 *size = (strlenW(ptr)/2)+1;
3447 else
3448 *size = strlenW(ptr)/2;
3449
3450 data = HeapAlloc(GetProcessHeap(),0,*size);
3451
3452 byte[0] = '0';
3453 byte[1] = 'x';
3454 byte[4] = 0;
3455 count = 0;
3456 /* if uneven pad with a zero in front */
3457 if (strlenW(ptr)%2)
3458 {
3459 byte[2]= '0';
3460 byte[3]= *ptr;
3461 ptr++;
3462 data[count] = (BYTE)strtol(byte,NULL,0);
3463 count ++;
3464 TRACE("Uneven byte count\n");
3465 }
3466 while (*ptr)
3467 {
3468 byte[2]= *ptr;
3469 ptr++;
3470 byte[3]= *ptr;
3471 ptr++;
3472 data[count] = (BYTE)strtol(byte,NULL,0);
3473 count ++;
3474 }
3475 HeapFree(GetProcessHeap(),0,deformated);
3476
3477 TRACE("Data %li bytes(%i)\n",*size,count);
3478 }
3479 else
3480 {
3481 LPWSTR deformated;
3482 LPWSTR p;
3483 DWORD d = 0;
3484 deformat_string(package, &value[1], &deformated);
3485
3486 *type=REG_DWORD;
3487 *size = sizeof(DWORD);
3488 data = HeapAlloc(GetProcessHeap(),0,*size);
3489 p = deformated;
3490 if (*p == '-')
3491 p++;
3492 while (*p)
3493 {
3494 if ( (*p < '0') || (*p > '9') )
3495 break;
3496 d *= 10;
3497 d += (*p - '0');
3498 p++;
3499 }
3500 if (deformated[0] == '-')
3501 d = -d;
3502 *(LPDWORD)data = d;
3503 TRACE("DWORD %li\n",*(LPDWORD)data);
3504
3505 HeapFree(GetProcessHeap(),0,deformated);
3506 }
3507 }
3508 else
3509 {
3510 static const WCHAR szMulti[] = {'[','~',']',0};
3511 WCHAR *ptr;
3512 *type=REG_SZ;
3513
3514 if (value[0]=='#')
3515 {
3516 if (value[1]=='%')
3517 {
3518 ptr = &value[2];
3519 *type=REG_EXPAND_SZ;
3520 }
3521 else
3522 ptr = &value[1];
3523 }
3524 else
3525 ptr=value;
3526
3527 if (strstrW(value,szMulti))
3528 *type = REG_MULTI_SZ;
3529
3530 *size = deformat_string(package, ptr,(LPWSTR*)&data);
3531 }
3532 return data;
3533 }
3534
3535 static UINT ACTION_WriteRegistryValues(MSIPACKAGE *package)
3536 {
3537 UINT rc;
3538 MSIQUERY * view;
3539 MSIRECORD * row = 0;
3540 static const WCHAR ExecSeqQuery[] =
3541 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3542 '`','R','e','g','i','s','t','r','y','`',0 };
3543
3544 if (!package)
3545 return ERROR_INVALID_HANDLE;
3546
3547 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3548 if (rc != ERROR_SUCCESS)
3549 return ERROR_SUCCESS;
3550
3551 rc = MSI_ViewExecute(view, 0);
3552 if (rc != ERROR_SUCCESS)
3553 {
3554 MSI_ViewClose(view);
3555 msiobj_release(&view->hdr);
3556 return rc;
3557 }
3558
3559 /* increment progress bar each time action data is sent */
3560 ui_progress(package,1,REG_PROGRESS_VALUE,1,0);
3561
3562 while (1)
3563 {
3564 static const WCHAR szHCR[] =
3565 {'H','K','E','Y','_','C','L','A','S','S','E','S','_',
3566 'R','O','O','T','\\',0};
3567 static const WCHAR szHCU[] =
3568 {'H','K','E','Y','_','C','U','R','R','E','N','T','_',
3569 'U','S','E','R','\\',0};
3570 static const WCHAR szHLM[] =
3571 {'H','K','E','Y','_','L','O','C','A','L','_',
3572 'M','A','C','H','I','N','E','\\',0};
3573 static const WCHAR szHU[] =
3574 {'H','K','E','Y','_','U','S','E','R','S','\\',0};
3575
3576 LPSTR value_data = NULL;
3577 HKEY root_key, hkey;
3578 DWORD type,size;
3579 LPWSTR value, key, name, component, deformated;
3580 LPCWSTR szRoot;
3581 INT component_index;
3582 MSIRECORD * uirow;
3583 LPWSTR uikey;
3584 INT root;
3585 BOOL check_first = FALSE;
3586
3587 rc = MSI_ViewFetch(view,&row);
3588 if (rc != ERROR_SUCCESS)
3589 {
3590 rc = ERROR_SUCCESS;
3591 break;
3592 }
3593 ui_progress(package,2,0,0,0);
3594
3595 value = NULL;
3596 key = NULL;
3597 uikey = NULL;
3598 name = NULL;
3599
3600 component = load_dynamic_stringW(row, 6);
3601 component_index = get_loaded_component(package,component);
3602
3603 if (!ACTION_VerifyComponentForAction(package, component_index,
3604 INSTALLSTATE_LOCAL))
3605 {
3606 TRACE("Skipping write due to disabled component\n");
3607 msiobj_release(&row->hdr);
3608
3609 package->components[component_index].Action =
3610 package->components[component_index].Installed;
3611
3612 goto next;
3613 }
3614
3615 package->components[component_index].Action = INSTALLSTATE_LOCAL;
3616
3617 name = load_dynamic_stringW(row, 4);
3618 if( MSI_RecordIsNull(row,5) && name )
3619 {
3620 /* null values can have special meanings */
3621 if (name[0]=='-' && name[1] == 0)
3622 {
3623 msiobj_release(&row->hdr);
3624 goto next;
3625 }
3626 else if ((name[0]=='+' && name[1] == 0) ||
3627 (name[0] == '*' && name[1] == 0))
3628 {
3629 HeapFree(GetProcessHeap(),0,name);
3630 name = NULL;
3631 check_first = TRUE;
3632 }
3633 }
3634
3635 root = MSI_RecordGetInteger(row,2);
3636 key = load_dynamic_stringW(row, 3);
3637
3638
3639 /* get the root key */
3640 switch (root)
3641 {
3642 case 0: root_key = HKEY_CLASSES_ROOT;
3643 szRoot = szHCR;
3644 break;
3645 case 1: root_key = HKEY_CURRENT_USER;
3646 szRoot = szHCU;
3647 break;
3648 case 2: root_key = HKEY_LOCAL_MACHINE;
3649 szRoot = szHLM;
3650 break;
3651 case 3: root_key = HKEY_USERS;
3652 szRoot = szHU;
3653 break;
3654 default:
3655 ERR("Unknown root %i\n",root);
3656 root_key=NULL;
3657 szRoot = NULL;
3658 break;
3659 }
3660 if (!root_key)
3661 {
3662 msiobj_release(&row->hdr);
3663 goto next;
3664 }
3665
3666 deformat_string(package, key , &deformated);
3667 size = strlenW(deformated) + strlenW(szRoot) + 1;
3668 uikey = HeapAlloc(GetProcessHeap(), 0, size*sizeof(WCHAR));
3669 strcpyW(uikey,szRoot);
3670 strcatW(uikey,deformated);
3671
3672 if (RegCreateKeyW( root_key, deformated, &hkey))
3673 {
3674 ERR("Could not create key %s\n",debugstr_w(deformated));
3675 msiobj_release(&row->hdr);
3676 HeapFree(GetProcessHeap(),0,deformated);
3677 goto next;
3678 }
3679 HeapFree(GetProcessHeap(),0,deformated);
3680
3681 value = load_dynamic_stringW(row,5);
3682 if (value)
3683 value_data = parse_value(package, value, &type, &size);
3684 else
3685 {
3686 static const WCHAR szEmpty[] = {0};
3687 value_data = (LPSTR)strdupW(szEmpty);
3688 size = 0;
3689 type = REG_SZ;
3690 }
3691
3692 deformat_string(package, name, &deformated);
3693
3694 /* get the double nulls to terminate SZ_MULTI */
3695 if (type == REG_MULTI_SZ)
3696 size +=sizeof(WCHAR);
3697
3698 if (!check_first)
3699 {
3700 TRACE("Setting value %s of %s\n",debugstr_w(deformated),
3701 debugstr_w(uikey));
3702 RegSetValueExW(hkey, deformated, 0, type, value_data, size);
3703 }
3704 else
3705 {
3706 DWORD sz = 0;
3707 rc = RegQueryValueExW(hkey, deformated, NULL, NULL, NULL, &sz);
3708 if (rc == ERROR_SUCCESS || rc == ERROR_MORE_DATA)
3709 {
3710 TRACE("value %s of %s checked already exists\n",
3711 debugstr_w(deformated), debugstr_w(uikey));
3712 }
3713 else
3714 {
3715 TRACE("Checked and setting value %s of %s\n",
3716 debugstr_w(deformated), debugstr_w(uikey));
3717 RegSetValueExW(hkey, deformated, 0, type, value_data, size);
3718 }
3719 }
3720
3721 uirow = MSI_CreateRecord(3);
3722 MSI_RecordSetStringW(uirow,2,deformated);
3723 MSI_RecordSetStringW(uirow,1,uikey);
3724
3725 if (type == REG_SZ)
3726 MSI_RecordSetStringW(uirow,3,(LPWSTR)value_data);
3727 else
3728 MSI_RecordSetStringW(uirow,3,value);
3729
3730 ui_actiondata(package,szWriteRegistryValues,uirow);
3731 msiobj_release( &uirow->hdr );
3732
3733 HeapFree(GetProcessHeap(),0,value_data);
3734 HeapFree(GetProcessHeap(),0,value);
3735 HeapFree(GetProcessHeap(),0,deformated);
3736
3737 msiobj_release(&row->hdr);
3738 RegCloseKey(hkey);
3739 next:
3740 HeapFree(GetProcessHeap(),0,uikey);
3741 HeapFree(GetProcessHeap(),0,key);
3742 HeapFree(GetProcessHeap(),0,name);
3743 HeapFree(GetProcessHeap(),0,component);
3744 }
3745 MSI_ViewClose(view);
3746 msiobj_release(&view->hdr);
3747 return rc;
3748 }
3749
3750 static UINT ACTION_InstallInitialize(MSIPACKAGE *package)
3751 {
3752 return ERROR_SUCCESS;
3753 }
3754
3755
3756 static UINT ACTION_InstallValidate(MSIPACKAGE *package)
3757 {
3758 DWORD progress = 0;
3759 DWORD total = 0;
3760 static const WCHAR q1[]=
3761 {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
3762 '`','R','e','g','i','s','t','r','y','`',0};
3763 UINT rc;
3764 MSIQUERY * view;
3765 MSIRECORD * row = 0;
3766 int i;
3767
3768 TRACE(" InstallValidate \n");
3769
3770 rc = MSI_DatabaseOpenViewW(package->db, q1, &view);
3771 if (rc != ERROR_SUCCESS)
3772 return ERROR_SUCCESS;
3773
3774 rc = MSI_ViewExecute(view, 0);
3775 if (rc != ERROR_SUCCESS)
3776 {
3777 MSI_ViewClose(view);
3778 msiobj_release(&view->hdr);
3779 return rc;
3780 }
3781 while (1)
3782 {
3783 rc = MSI_ViewFetch(view,&row);
3784 if (rc != ERROR_SUCCESS)
3785 {
3786 rc = ERROR_SUCCESS;
3787 break;
3788 }
3789 progress +=1;
3790
3791 msiobj_release(&row->hdr);
3792 }
3793 MSI_ViewClose(view);
3794 msiobj_release(&view->hdr);
3795
3796 total = total + progress * REG_PROGRESS_VALUE;
3797 total = total + package->loaded_components * COMPONENT_PROGRESS_VALUE;
3798 for (i=0; i < package->loaded_files; i++)
3799 total += package->files[i].FileSize;
3800 ui_progress(package,0,total,0,0);
3801
3802 for(i = 0; i < package->loaded_features; i++)
3803 {
3804 MSIFEATURE* feature = &package->features[i];
3805 TRACE("Feature: %s; Installed: %i; Action %i; Request %i\n",
3806 debugstr_w(feature->Feature), feature->Installed, feature->Action,
3807 feature->ActionRequest);
3808 }
3809
3810 return ERROR_SUCCESS;
3811 }
3812
3813 static UINT ACTION_LaunchConditions(MSIPACKAGE *package)
3814 {
3815 UINT rc;
3816 MSIQUERY * view = NULL;
3817 MSIRECORD * row = 0;
3818 static const WCHAR ExecSeqQuery[] =
3819 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3820 '`','L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','`',0};
3821 static const WCHAR title[]=
3822 {'I','n','s','t','a','l','l',' ','F','a', 'i','l','e','d',0};
3823
3824 TRACE("Checking launch conditions\n");
3825
3826 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3827 if (rc != ERROR_SUCCESS)
3828 return ERROR_SUCCESS;
3829
3830 rc = MSI_ViewExecute(view, 0);
3831 if (rc != ERROR_SUCCESS)
3832 {
3833 MSI_ViewClose(view);
3834 msiobj_release(&view->hdr);
3835 return rc;
3836 }
3837
3838 rc = ERROR_SUCCESS;
3839 while (rc == ERROR_SUCCESS)
3840 {
3841 LPWSTR cond = NULL;
3842 LPWSTR message = NULL;
3843
3844 rc = MSI_ViewFetch(view,&row);
3845 if (rc != ERROR_SUCCESS)
3846 {
3847 rc = ERROR_SUCCESS;
3848 break;
3849 }
3850
3851 cond = load_dynamic_stringW(row,1);
3852
3853 if (MSI_EvaluateConditionW(package,cond) != MSICONDITION_TRUE)
3854 {
3855 LPWSTR deformated;
3856 message = load_dynamic_stringW(row,2);
3857 deformat_string(package,message,&deformated);
3858 MessageBoxW(NULL,deformated,title,MB_OK);
3859 HeapFree(GetProcessHeap(),0,message);
3860 HeapFree(GetProcessHeap(),0,deformated);
3861 rc = ERROR_FUNCTION_FAILED;
3862 }
3863 HeapFree(GetProcessHeap(),0,cond);
3864 msiobj_release(&row->hdr);
3865 }
3866 MSI_ViewClose(view);
3867 msiobj_release(&view->hdr);
3868 return rc;
3869 }
3870
3871 static LPWSTR resolve_keypath( MSIPACKAGE* package, INT
3872 component_index)
3873 {
3874 MSICOMPONENT* cmp = &package->components[component_index];
3875
3876 if (cmp->KeyPath[0]==0)
3877 {
3878 LPWSTR p = resolve_folder(package,cmp->Directory,FALSE,FALSE,NULL);
3879 return p;
3880 }
3881 if (cmp->Attributes & msidbComponentAttributesRegistryKeyPath)
3882 {
3883 MSIQUERY * view;
3884 MSIRECORD * row = 0;
3885 UINT rc,root,len;
3886 LPWSTR key,deformated,buffer,name,deformated_name;
3887 static const WCHAR ExecSeqQuery[] =
3888 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3889 '`','R','e','g','i','s','t','r','y','`',' ',
3890 'W','H','E','R','E',' ', '`','R','e','g','i','s','t','r','y','`',
3891 ' ','=',' ' ,'\'','%','s','\'',0 };
3892 static const WCHAR fmt[]={'%','0','2','i',':','\\','%','s','\\',0};
3893 static const WCHAR fmt2[]=
3894 {'%','0','2','i',':','\\','%','s','\\','%','s',0};
3895
3896 rc = MSI_OpenQuery(package->db,&view,ExecSeqQuery,cmp->KeyPath);
3897
3898 if (rc!=ERROR_SUCCESS)
3899 return NULL;
3900
3901 rc = MSI_ViewExecute(view, 0);
3902 if (rc != ERROR_SUCCESS)
3903 {
3904 MSI_ViewClose(view);
3905 msiobj_release(&view->hdr);
3906 return NULL;
3907 }
3908
3909 rc = MSI_ViewFetch(view,&row);
3910 if (rc != ERROR_SUCCESS)
3911 {
3912 MSI_ViewClose(view);
3913 msiobj_release(&view->hdr);
3914 return NULL;
3915 }
3916
3917 root = MSI_RecordGetInteger(row,2);
3918 key = load_dynamic_stringW(row, 3);
3919 name = load_dynamic_stringW(row, 4);
3920 deformat_string(package, key , &deformated);
3921 deformat_string(package, name, &deformated_name);
3922
3923 len = strlenW(deformated) + 6;
3924 if (deformated_name)
3925 len+=strlenW(deformated_name);
3926
3927 buffer = HeapAlloc(GetProcessHeap(),0, len *sizeof(WCHAR));
3928
3929 if (deformated_name)
3930 sprintfW(buffer,fmt2,root,deformated,deformated_name);
3931 else
3932 sprintfW(buffer,fmt,root,deformated);
3933
3934 HeapFree(GetProcessHeap(),0,key);
3935 HeapFree(GetProcessHeap(),0,deformated);
3936 HeapFree(GetProcessHeap(),0,name);
3937 HeapFree(GetProcessHeap(),0,deformated_name);
3938 msiobj_release(&row->hdr);
3939 MSI_ViewClose(view);
3940 msiobj_release(&view->hdr);
3941
3942 return buffer;
3943 }
3944 else if (cmp->Attributes & msidbComponentAttributesODBCDataSource)
3945 {
3946 FIXME("UNIMPLEMENTED keypath as ODBC Source\n");
3947 return NULL;
3948 }
3949 else
3950 {
3951 int j;
3952 j = get_loaded_file(package,cmp->KeyPath);
3953
3954 if (j>=0)
3955 {
3956 LPWSTR p = strdupW(package->files[j].TargetPath);
3957 return p;
3958 }
3959 }
3960 return NULL;
3961 }
3962
3963 static HKEY openSharedDLLsKey()
3964 {
3965 HKEY hkey=0;
3966 static const WCHAR path[] =
3967 {'S','o','f','t','w','a','r','e','\\',
3968 'M','i','c','r','o','s','o','f','t','\\',
3969 'W','i','n','d','o','w','s','\\',
3970 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3971 'S','h','a','r','e','d','D','L','L','s',0};
3972
3973 RegCreateKeyW(HKEY_LOCAL_MACHINE,path,&hkey);
3974 return hkey;
3975 }
3976
3977 static UINT ACTION_GetSharedDLLsCount(LPCWSTR dll)
3978 {
3979 HKEY hkey;
3980 DWORD count=0;
3981 DWORD type;
3982 DWORD sz = sizeof(count);
3983 DWORD rc;
3984
3985 hkey = openSharedDLLsKey();
3986 rc = RegQueryValueExW(hkey, dll, NULL, &type, (LPBYTE)&count, &sz);
3987 if (rc != ERROR_SUCCESS)
3988 count = 0;
3989 RegCloseKey(hkey);
3990 return count;
3991 }
3992
3993 static UINT ACTION_WriteSharedDLLsCount(LPCWSTR path, UINT count)
3994 {
3995 HKEY hkey;
3996
3997 hkey = openSharedDLLsKey();
3998 if (count > 0)
3999 RegSetValueExW(hkey,path,0,REG_DWORD,
4000 (LPBYTE)&count,sizeof(count));
4001 else
4002 RegDeleteValueW(hkey,path);
4003 RegCloseKey(hkey);
4004 return count;
4005 }
4006
4007 /*
4008 * Return TRUE if the count should be written out and FALSE if not
4009 */
4010 static void ACTION_RefCountComponent( MSIPACKAGE* package, UINT index)
4011 {
4012 INT count = 0;
4013 BOOL write = FALSE;
4014 INT j;
4015
4016 /* only refcount DLLs */
4017 if (package->components[index].KeyPath[0]==0 ||
4018 package->components[index].Attributes &
4019 msidbComponentAttributesRegistryKeyPath ||
4020 package->components[index].Attributes &
4021 msidbComponentAttributesODBCDataSource)
4022 write = FALSE;
4023 else
4024 {
4025 count = ACTION_GetSharedDLLsCount(package->components[index].
4026 FullKeypath);
4027 write = (count > 0);
4028
4029 if (package->components[index].Attributes &
4030 msidbComponentAttributesSharedDllRefCount)
4031 write = TRUE;
4032 }
4033
4034 /* increment counts */
4035 for (j = 0; j < package->loaded_features; j++)
4036 {
4037 int i;
4038
4039 if (!ACTION_VerifyFeatureForAction(package,j,INSTALLSTATE_LOCAL))
4040 continue;
4041
4042 for (i = 0; i < package->features[j].ComponentCount; i++)
4043 {
4044 if (package->features[j].Components[i] == index)
4045 count++;
4046 }
4047 }
4048 /* decrement counts */
4049 for (j = 0; j < package->loaded_features; j++)
4050 {
4051 int i;
4052 if (!ACTION_VerifyFeatureForAction(package,j,INSTALLSTATE_ABSENT))
4053 continue;
4054
4055 for (i = 0; i < package->features[j].ComponentCount; i++)
4056 {
4057 if (package->features[j].Components[i] == index)
4058 count--;
4059 }
4060 }
4061
4062 /* ref count all the files in the component */
4063 if (write)
4064 for (j = 0; j < package->loaded_files; j++)
4065 {
4066 if (package->files[j].Temporary)
4067 continue;
4068 if (package->files[j].ComponentIndex == index)
4069 ACTION_WriteSharedDLLsCount(package->files[j].TargetPath,count);
4070 }
4071
4072 /* add a count for permenent */
4073 if (package->components[index].Attributes &
4074 msidbComponentAttributesPermanent)
4075 count ++;
4076
4077 package->components[index].RefCount = count;
4078
4079 if (write)
4080 ACTION_WriteSharedDLLsCount(package->components[index].FullKeypath,
4081 package->components[index].RefCount);
4082 }
4083
4084 /*
4085 * Ok further analysis makes me think that this work is
4086 * actually done in the PublishComponents and PublishFeatures
4087 * step, and not here. It appears like the keypath and all that is
4088 * resolved in this step, however actually written in the Publish steps.
4089 * But we will leave it here for now because it is unclear
4090 */
4091 static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
4092 {
4093 LPWSTR productcode;
4094 WCHAR squished_pc[GUID_SIZE];
4095 WCHAR squished_cc[GUID_SIZE];
4096 UINT rc;
4097 DWORD i;
4098 HKEY hkey=0,hkey2=0;
4099
4100 if (!package)
4101 return ERROR_INVALID_HANDLE;
4102
4103 /* writes the Component and Features values to the registry */
4104 productcode = load_dynamic_property(package,szProductCode,&rc);
4105 if (!productcode)
4106 return rc;
4107
4108 rc = MSIREG_OpenComponents(&hkey);
4109 if (rc != ERROR_SUCCESS)
4110 goto end;
4111
4112 squash_guid(productcode,squished_pc);
4113 ui_progress(package,1,COMPONENT_PROGRESS_VALUE,1,0);
4114 for (i = 0; i < package->loaded_components; i++)
4115 {
4116 ui_progress(package,2,0,0,0);
4117 if (package->components[i].ComponentId[0]!=0)
4118 {
4119 WCHAR *keypath = NULL;
4120 MSIRECORD * uirow;
4121
4122 squash_guid(package->components[i].ComponentId,squished_cc);
4123
4124 keypath = resolve_keypath(package,i);
4125 package->components[i].FullKeypath = keypath;
4126
4127 /* do the refcounting */
4128 ACTION_RefCountComponent( package, i);
4129
4130 TRACE("Component %s (%s), Keypath=%s, RefCount=%i\n",
4131 debugstr_w(package->components[i].Component),
4132 debugstr_w(squished_cc),
4133 debugstr_w(package->components[i].FullKeypath),
4134 package->components[i].RefCount);
4135 /*
4136 * Write the keypath out if the component is to be registered
4137 * and delete the key if the component is to be deregistered
4138 */
4139 if (ACTION_VerifyComponentForAction(package, i,
4140 INSTALLSTATE_LOCAL))
4141 {
4142 rc = RegCreateKeyW(hkey,squished_cc,&hkey2);
4143 if (rc != ERROR_SUCCESS)
4144 continue;
4145
4146 if (keypath)
4147 {
4148 RegSetValueExW(hkey2,squished_pc,0,REG_SZ,(LPVOID)keypath,
4149 (strlenW(keypath)+1)*sizeof(WCHAR));
4150
4151 if (package->components[i].Attributes &
4152 msidbComponentAttributesPermanent)
4153 {
4154 static const WCHAR szPermKey[] =
4155 { '0','0','0','0','0','0','0','0','0','0','0','0',
4156 '0','0','0','0','0','0','0', '0','0','0','0','0',
4157 '0','0','0','0','0','0','0','0',0};
4158
4159 RegSetValueExW(hkey2,szPermKey,0,REG_SZ,
4160 (LPVOID)keypath,
4161 (strlenW(keypath)+1)*sizeof(WCHAR));
4162 }
4163
4164 RegCloseKey(hkey2);
4165
4166 /* UI stuff */
4167 uirow = MSI_CreateRecord(3);
4168 MSI_RecordSetStringW(uirow,1,productcode);
4169 MSI_RecordSetStringW(uirow,2,package->components[i].
4170 ComponentId);
4171 MSI_RecordSetStringW(uirow,3,keypath);
4172 ui_actiondata(package,szProcessComponents,uirow);
4173 msiobj_release( &uirow->hdr );
4174 }
4175 }
4176 else if (ACTION_VerifyComponentForAction(package, i,
4177 INSTALLSTATE_ABSENT))
4178 {
4179 DWORD res;
4180
4181 rc = RegOpenKeyW(hkey,squished_cc,&hkey2);
4182 if (rc != ERROR_SUCCESS)
4183 continue;
4184
4185 RegDeleteValueW(hkey2,squished_pc);
4186
4187 /* if the key is empty delete it */
4188 res = RegEnumKeyExW(hkey2,0,NULL,0,0,NULL,0,NULL);
4189 RegCloseKey(hkey2);
4190 if (res == ERROR_NO_MORE_ITEMS)
4191 RegDeleteKeyW(hkey,squished_cc);
4192
4193 /* UI stuff */
4194 uirow = MSI_CreateRecord(2);
4195 MSI_RecordSetStringW(uirow,1,productcode);
4196 MSI_RecordSetStringW(uirow,2,package->components[i].
4197 ComponentId);
4198 ui_actiondata(package,szProcessComponents,uirow);
4199 msiobj_release( &uirow->hdr );
4200 }
4201 }
4202 }
4203 end:
4204 HeapFree(GetProcessHeap(), 0, productcode);
4205 RegCloseKey(hkey);
4206 return rc;
4207 }
4208
4209 typedef struct {
4210 CLSID clsid;
4211 LPWSTR source;
4212
4213 LPWSTR path;
4214 ITypeLib *ptLib;
4215 } typelib_struct;
4216
4217 BOOL CALLBACK Typelib_EnumResNameProc( HMODULE hModule, LPCWSTR lpszType,
4218 LPWSTR lpszName, LONG_PTR lParam)
4219 {
4220 TLIBATTR *attr;
4221 typelib_struct *tl_struct = (typelib_struct*) lParam;
4222 static const WCHAR fmt[] = {'%','s','\\','%','i',0};
4223 int sz;
4224 HRESULT res;
4225
4226 if (!IS_INTRESOURCE(lpszName))
4227 {
4228 ERR("Not Int Resource Name %s\n",debugstr_w(lpszName));
4229 return TRUE;
4230 }
4231
4232 sz = strlenW(tl_struct->source)+4;
4233 sz *= sizeof(WCHAR);
4234
4235 tl_struct->path = HeapAlloc(GetProcessHeap(),0,sz);
4236 sprintfW(tl_struct->path,fmt,tl_struct->source, lpszName);
4237
4238 TRACE("trying %s\n", debugstr_w(tl_struct->path));
4239 res = LoadTypeLib(tl_struct->path,&tl_struct->ptLib);
4240 if (!SUCCEEDED(res))
4241 {
4242 HeapFree(GetProcessHeap(),0,tl_struct->path);
4243 tl_struct->path = NULL;
4244
4245 return TRUE;
4246 }
4247
4248 ITypeLib_GetLibAttr(tl_struct->ptLib, &attr);
4249 if (IsEqualGUID(&(tl_struct->clsid),&(attr->guid)))
4250 {
4251 ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
4252 return FALSE;
4253 }
4254
4255 HeapFree(GetProcessHeap(),0,tl_struct->path);
4256 tl_struct->path = NULL;
4257
4258 ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
4259 ITypeLib_Release(tl_struct->ptLib);
4260
4261 return TRUE;
4262 }
4263
4264 static UINT ACTION_RegisterTypeLibraries(MSIPACKAGE *package)
4265 {
4266 /*
4267 * OK this is a bit confusing.. I am given a _Component key and I believe
4268 * that the file that is being registered as a type library is the "key file
4269 * of that component" which I interpret to mean "The file in the KeyPath of
4270 * that component".
4271 */
4272 UINT rc;
4273 MSIQUERY * view;
4274 MSIRECORD * row = 0;
4275 static const WCHAR Query[] =
4276 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4277 '`','T','y','p','e','L','i','b','`',0};
4278
4279 if (!package)
4280 return ERROR_INVALID_HANDLE;
4281
4282 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
4283 if (rc != ERROR_SUCCESS)
4284 return ERROR_SUCCESS;
4285
4286 rc = MSI_ViewExecute(view, 0);
4287 if (rc != ERROR_SUCCESS)
4288 {
4289 MSI_ViewClose(view);
4290 msiobj_release(&view->hdr);
4291 return rc;
4292 }
4293
4294 while (1)
4295 {
4296 WCHAR component[0x100];
4297 DWORD sz;
4298 INT index;
4299 LPWSTR guid;
4300 typelib_struct tl_struct;
4301 HMODULE module;
4302 static const WCHAR szTYPELIB[] = {'T','Y','P','E','L','I','B',0};
4303
4304 rc = MSI_ViewFetch(view,&row);
4305 if (rc != ERROR_SUCCESS)
4306 {
4307 rc = ERROR_SUCCESS;
4308 break;
4309 }
4310
4311 sz = 0x100;
4312 MSI_RecordGetStringW(row,3,component,&sz);
4313
4314 index = get_loaded_component(package,component);
4315 if (index < 0)
4316 {
4317 msiobj_release(&row->hdr);
4318 continue;
4319 }
4320
4321 if (!ACTION_VerifyComponentForAction(package, index,
4322 INSTALLSTATE_LOCAL))
4323 {
4324 TRACE("Skipping typelib reg due to disabled component\n");
4325 msiobj_release(&row->hdr);
4326
4327 package->components[index].Action =
4328 package->components[index].Installed;
4329
4330 continue;
4331 }
4332
4333 package->components[index].Action = INSTALLSTATE_LOCAL;
4334
4335 index = get_loaded_file(package,package->components[index].KeyPath);
4336
4337 if (index < 0)
4338 {
4339 msiobj_release(&row->hdr);
4340 continue;
4341 }
4342
4343 guid = load_dynamic_stringW(row,1);
4344 module = LoadLibraryExW(package->files[index].TargetPath, NULL,
4345 LOAD_LIBRARY_AS_DATAFILE);
4346 if (module != NULL)
4347 {
4348 CLSIDFromString(guid, &tl_struct.clsid);
4349 tl_struct.source = strdupW(package->files[index].TargetPath);
4350 tl_struct.path = NULL;
4351
4352 EnumResourceNamesW(module, szTYPELIB, Typelib_EnumResNameProc,
4353 (LONG_PTR)&tl_struct);
4354
4355 if (tl_struct.path != NULL)
4356 {
4357 LPWSTR help;
4358 WCHAR helpid[0x100];
4359 HRESULT res;
4360
4361 sz = 0x100;
4362 MSI_RecordGetStringW(row,6,helpid,&sz);
4363
4364 help = resolve_folder(package,helpid,FALSE,FALSE,NULL);
4365 res = RegisterTypeLib(tl_struct.ptLib,tl_struct.path,help);
4366 HeapFree(GetProcessHeap(),0,help);
4367
4368 if (!SUCCEEDED(res))
4369 ERR("Failed to register type library %s\n",
4370 debugstr_w(tl_struct.path));
4371 else
4372 {
4373 ui_actiondata(package,szRegisterTypeLibraries,row);
4374
4375 TRACE("Registered %s\n", debugstr_w(tl_struct.path));
4376 }
4377
4378 ITypeLib_Release(tl_struct.ptLib);
4379 HeapFree(GetProcessHeap(),0,tl_struct.path);
4380 }
4381 else
4382 ERR("Failed to load type library %s\n",
4383 debugstr_w(tl_struct.source));
4384
4385 FreeLibrary(module);
4386 HeapFree(GetProcessHeap(),0,tl_struct.source);
4387 }
4388 else
4389 ERR("Could not load file! %s\n",
4390 debugstr_w(package->files[index].TargetPath));
4391 msiobj_release(&row->hdr);
4392 }
4393 MSI_ViewClose(view);
4394 msiobj_release(&view->hdr);
4395 return rc;
4396 }
4397
4398 static UINT register_appid(MSIPACKAGE *package, LPCWSTR clsid, LPCWSTR app )
4399 {
4400 static const WCHAR szAppID[] = { 'A','p','p','I','D',0 };
4401 UINT rc;
4402 MSIQUERY * view;
4403 MSIRECORD * row = 0;
4404 static const WCHAR ExecSeqQuery[] =
4405 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4406 '`','A','p','p','I' ,'d','`',' ','W','H','E','R','E',' ',
4407 '`','A','p','p','I','d','`',' ','=','\'','%','s','\'',0};
4408 HKEY hkey2,hkey3;
4409 LPWSTR buffer=0;
4410
4411 if (!package)
4412 return ERROR_INVALID_HANDLE;
4413
4414 rc = MSI_OpenQuery(package->db, &view, ExecSeqQuery, clsid);
4415 if (rc != ERROR_SUCCESS)
4416 return rc;
4417
4418 rc = MSI_ViewExecute(view, 0);
4419 if (rc != ERROR_SUCCESS)
4420 {
4421 MSI_ViewClose(view);
4422 msiobj_release(&view->hdr);
4423 return rc;
4424 }
4425
4426 RegCreateKeyW(HKEY_CLASSES_ROOT,szAppID,&hkey2);
4427 RegCreateKeyW(hkey2,clsid,&hkey3);
4428 RegSetValueExW(hkey3,NULL,0,REG_SZ,(LPVOID)app,
4429 (strlenW(app)+1)*sizeof(WCHAR));
4430
4431 rc = MSI_ViewFetch(view,&row);
4432 if (rc != ERROR_SUCCESS)
4433 {
4434 MSI_ViewClose(view);
4435 msiobj_release(&view->hdr);
4436 return rc;
4437 }
4438
4439 if (!MSI_RecordIsNull(row,2))
4440 {
4441 LPWSTR deformated=0;
4442 UINT size;
4443 static const WCHAR szRemoteServerName[] =
4444 {'R','e','m','o','t','e','S','e','r','v','e','r','N','a','m','e',
4445 0};
4446 buffer = load_dynamic_stringW(row,2);
4447 size = deformat_string(package,buffer,&deformated);
4448 RegSetValueExW(hkey3,szRemoteServerName,0,REG_SZ,(LPVOID)deformated,
4449 size);
4450 HeapFree(GetProcessHeap(),0,deformated);
4451 HeapFree(GetProcessHeap(),0,buffer);
4452 }
4453
4454 if (!MSI_RecordIsNull(row,3))
4455 {
4456 static const WCHAR szLocalService[] =
4457 {'L','o','c','a','l','S','e','r','v','i','c','e',0};
4458 UINT size;
4459 buffer = load_dynamic_stringW(row,3);
4460 size = (strlenW(buffer)+1) * sizeof(WCHAR);
4461 RegSetValueExW(hkey3,szLocalService,0,REG_SZ,(LPVOID)buffer,size);
4462 HeapFree(GetProcessHeap(),0,buffer);
4463 }
4464
4465 if (!MSI_RecordIsNull(row,4))
4466 {
4467 static const WCHAR szService[] =
4468 {'S','e','r','v','i','c','e',
4469 'P','a','r','a','m','e','t','e','r','s',0};
4470 UINT size;
4471 buffer = load_dynamic_stringW(row,4);
4472 size = (strlenW(buffer)+1) * sizeof(WCHAR);
4473 RegSetValueExW(hkey3,szService,0,REG_SZ,(LPVOID)buffer,size);
4474 HeapFree(GetProcessHeap(),0,buffer);
4475 }
4476
4477 if (!MSI_RecordIsNull(row,5))
4478 {
4479 static const WCHAR szDLL[] =
4480 {'D','l','l','S','u','r','r','o','g','a','t','e',0};
4481 UINT size;
4482 buffer = load_dynamic_stringW(row,5);
4483 size = (strlenW(buffer)+1) * sizeof(WCHAR);
4484 RegSetValueExW(hkey3,szDLL,0,REG_SZ,(LPVOID)buffer,size);
4485 HeapFree(GetProcessHeap(),0,buffer);
4486 }
4487
4488 if (!MSI_RecordIsNull(row,6))
4489 {
4490 static const WCHAR szActivate[] =
4491 {'A','c','t','i','v','a','t','e','A','s',
4492 'S','t','o','r','a','g','e',0};
4493 static const WCHAR szY[] = {'Y',0};
4494
4495 if (MSI_RecordGetInteger(row,6))
4496 RegSetValueExW(hkey3,szActivate,0,REG_SZ,(LPVOID)szY,4);
4497 }
4498
4499 if (!MSI_RecordIsNull(row,7))
4500 {
4501 static const WCHAR szRunAs[] = {'R','u','n','A','s',0};
4502 static const WCHAR szUser[] =
4503 {'I','n','t','e','r','a','c','t','i','v','e',' ',
4504 'U','s','e','r',0};
4505
4506 if (MSI_RecordGetInteger(row,7))
4507 RegSetValueExW(hkey3,szRunAs,0,REG_SZ,(LPVOID)szUser,34);
4508 }
4509
4510 msiobj_release(&row->hdr);
4511 MSI_ViewClose(view);
4512 msiobj_release(&view->hdr);
4513 RegCloseKey(hkey3);
4514 RegCloseKey(hkey2);
4515 return rc;
4516 }
4517
4518 static UINT ACTION_RegisterClassInfo(MSIPACKAGE *package)
4519 {
4520 /*
4521 * Again I am assuming the words, "Whose key file represents" when referring
4522 * to a Component as to meaning that Components KeyPath file
4523 *
4524 * Also there is a very strong connection between ClassInfo and ProgID
4525 * that I am mostly glossing over.
4526 * What would be more propper is to load the ClassInfo and the ProgID info
4527 * into memory data structures and then be able to enable and disable them
4528 * based on component.
4529 */
4530
4531 UINT rc;
4532 MSIQUERY * view;
4533 MSIRECORD * row = 0;
4534 static const WCHAR ExecSeqQuery[] =
4535 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4536 '`','C','l','a','s','s','`',0};
4537 static const WCHAR szCLSID[] = { 'C','L','S','I','D',0 };
4538 static const WCHAR szProgID[] = { 'P','r','o','g','I','D',0 };
4539 static const WCHAR szAppID[] = { 'A','p','p','I','D',0 };
4540 static const WCHAR szSpace[] = {' ',0};
4541 HKEY hkey,hkey2,hkey3;
4542 LPWSTR argument,deformated;
4543
4544 if (!package)
4545 return ERROR_INVALID_HANDLE;
4546
4547 rc = RegCreateKeyW(HKEY_CLASSES_ROOT,szCLSID,&hkey);
4548 if (rc != ERROR_SUCCESS)
4549 return ERROR_FUNCTION_FAILED;
4550
4551 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4552 if (rc != ERROR_SUCCESS)
4553 {
4554 rc = ERROR_SUCCESS;
4555 goto end;
4556 }
4557
4558 rc = MSI_ViewExecute(view, 0);
4559 if (rc != ERROR_SUCCESS)
4560 {
4561 MSI_ViewClose(view);
4562 msiobj_release(&view->hdr);
4563 goto end;
4564 }
4565
4566 while (1)
4567 {
4568 WCHAR clsid[0x100];
4569 WCHAR buffer[0x100];
4570 WCHAR desc[0x100];
4571 DWORD sz;
4572 INT index;
4573 DWORD size;
4574
4575 rc = MSI_ViewFetch(view,&row);
4576 if (rc != ERROR_SUCCESS)
4577 {
4578 rc = ERROR_SUCCESS;
4579 break;
4580 }
4581
4582 sz=0x100;
4583 MSI_RecordGetStringW(row,3,buffer,&sz);
4584
4585 index = get_loaded_component(package,buffer);
4586
4587 if (index < 0)
4588 {
4589 msiobj_release(&row->hdr);
4590 continue;
4591 }
4592
4593 if ((!ACTION_VerifyComponentForAction(package, index,
4594 INSTALLSTATE_LOCAL)) &&
4595 (!ACTION_VerifyComponentForAction(package, index,
4596 INSTALLSTATE_ADVERTISED)))
4597 {
4598 TRACE("Skipping class reg due to disabled component\n");
4599 msiobj_release(&row->hdr);
4600
4601 package->components[index].Action =
4602 package->components[index].Installed;
4603
4604 continue;
4605 }
4606
4607 package->components[index].Action = INSTALLSTATE_LOCAL;
4608
4609 sz=0x100;
4610 MSI_RecordGetStringW(row,1,clsid,&sz);
4611 RegCreateKeyW(hkey,clsid,&hkey2);
4612
4613 if (!MSI_RecordIsNull(row,5))
4614 {
4615 sz=0x100;
4616 MSI_RecordGetStringW(row,5,desc,&sz);
4617
4618 RegSetValueExW(hkey2,NULL,0,REG_SZ,(LPVOID)desc,
4619 (strlenW(desc)+1)*sizeof(WCHAR));
4620 }
4621 else
4622 desc[0]=0;
4623
4624 sz=0x100;
4625 MSI_RecordGetStringW(row,2,buffer,&sz);
4626
4627 RegCreateKeyW(hkey2,buffer,&hkey3);
4628
4629 index = get_loaded_file(package,package->components[index].KeyPath);
4630
4631 argument = load_dynamic_stringW(row,11);
4632 size = deformat_string(package,argument,&deformated);
4633 if (deformated)
4634 size+=sizeof(WCHAR);
4635 HeapFree(GetProcessHeap(),0,argument);
4636 size += (strlenW(package->files[index].TargetPath))*sizeof(WCHAR);
4637
4638 argument = HeapAlloc(GetProcessHeap(),0,size+sizeof(WCHAR));
4639 strcpyW(argument,package->files[index].TargetPath);
4640 if (deformated)
4641 {
4642 strcatW(argument,szSpace);
4643 strcatW(argument,deformated);
4644 }
4645
4646 RegSetValueExW(hkey3,NULL,0,REG_SZ, (LPVOID)argument, size);
4647 HeapFree(GetProcessHeap(),0,deformated);
4648 HeapFree(GetProcessHeap(),0,argument);
4649
4650 RegCloseKey(hkey3);
4651
4652 if (!MSI_RecordIsNull(row,4))
4653 {
4654 sz=0x100;
4655 MSI_RecordGetStringW(row,4,buffer,&sz);
4656
4657 RegCreateKeyW(hkey2,szProgID,&hkey3);
4658
4659 RegSetValueExW(hkey3,NULL,0,REG_SZ,(LPVOID)buffer,
4660 (strlenW(buffer)+1)*sizeof(WCHAR));
4661
4662 RegCloseKey(hkey3);
4663 }
4664
4665 if (!MSI_RecordIsNull(row,6))
4666 {
4667 sz=0x100;
4668 MSI_RecordGetStringW(row,6,buffer,&sz);
4669
4670 RegSetValueExW(hkey2,szAppID,0,REG_SZ,(LPVOID)buffer,
4671 (strlenW(buffer)+1)*sizeof(WCHAR));
4672
4673 register_appid(package,buffer,desc);
4674 }
4675
4676
4677 if (!MSI_RecordIsNull(row,7))
4678 {
4679 FIXME("Process field 7\n");
4680 }
4681
4682 if (!MSI_RecordIsNull(row,8))
4683 {
4684 static const WCHAR szDefaultIcon[] =
4685 {'D','e','f','a','u','l','t','I','c','o','n',0};
4686
4687 LPWSTR FileName = load_dynamic_stringW(row,8);
4688 LPWSTR FilePath;
4689 INT index;
4690
4691 RegCreateKeyW(hkey2,szDefaultIcon,&hkey3);
4692 build_icon_path(package,FileName,&FilePath);
4693 if (!MSI_RecordIsNull(row,9))
4694 {
4695 static const WCHAR index_fmt[] = {',','%','i',0};
4696 WCHAR index_buf[20];
4697 index = MSI_RecordGetInteger(row,9);
4698 sprintfW(index_buf,index_fmt,index);
4699 size = strlenW(FilePath)+strlenW(index_buf)+1;
4700 size *= sizeof(WCHAR);
4701 HeapReAlloc(GetProcessHeap(),0,FilePath,size);
4702 }
4703 RegSetValueExW(hkey3,NULL,0,REG_SZ,(LPVOID)FilePath,
4704 (strlenW(FilePath)+1) * sizeof(WCHAR));
4705 HeapFree(GetProcessHeap(),0,FilePath);
4706 HeapFree(GetProcessHeap(),0,FileName);
4707 RegCloseKey(hkey3);
4708 }
4709
4710 if (!MSI_RecordIsNull(row,10))
4711 {
4712 static const WCHAR szInproc32[] =
4713 {'I','n','p','r','o','c','H','a','n','d','l','e','r','3','2',
4714 0};
4715 static const WCHAR szInproc[] =
4716 {'I','n','p','r','o','c','H','a','n','d','l','e','r',0};
4717 INT i = MSI_RecordGetInteger(row,10);
4718 if (i != MSI_NULL_INTEGER && i > 0 && i < 4)
4719 {
4720 static const WCHAR ole2[] = {'o','l','e','2','.','d','l','l',0};
4721 static const WCHAR ole32[] =
4722 {'o','l','e','3','2','.','d','l','l',0};
4723 switch(i)
4724 {
4725 case 1:
4726 size = strlenW(ole2) * sizeof(WCHAR);
4727 RegCreateKeyW(hkey2,szInproc,&hkey3);
4728 RegSetValueExW(hkey3,NULL,0,REG_SZ, (LPVOID)ole2, size);
4729 RegCloseKey(hkey3);
4730 break;
4731 case 2:
4732 size = strlenW(ole32) * sizeof(WCHAR);
4733 RegCreateKeyW(hkey2,szInproc32,&hkey3);
4734 RegSetValueExW(hkey3,NULL,0,REG_SZ, (LPVOID)ole32,size);
4735 RegCloseKey(hkey3);
4736 break;
4737 case 3:
4738 size = strlenW(ole2) * sizeof(WCHAR);
4739 RegCreateKeyW(hkey2,szInproc,&hkey3);
4740 RegSetValueExW(hkey3,NULL,0,REG_SZ, (LPVOID)ole2, size);
4741 RegCloseKey(hkey3);
4742 size = strlenW(ole32) * sizeof(WCHAR);
4743 RegCreateKeyW(hkey2,szInproc32,&hkey3);
4744 RegSetValueExW(hkey3,NULL,0,REG_SZ, (LPVOID)ole32,size);
4745 RegCloseKey(hkey3);
4746 break;
4747 }
4748
4749 }
4750 else
4751 {
4752 RegCreateKeyW(hkey2,szInproc32,&hkey3);
4753 argument = load_dynamic_stringW(row,10);
4754 reduce_to_longfilename(argument);
4755 size = strlenW(argument)*sizeof(WCHAR);
4756
4757 RegSetValueExW(hkey3,NULL,0,REG_SZ, (LPVOID)argument, size);
4758 HeapFree(GetProcessHeap(),0,argument);
4759
4760 RegCloseKey(hkey3);
4761 }
4762 }
4763
4764 RegCloseKey(hkey2);
4765
4766 ui_actiondata(package,szRegisterClassInfo,row);
4767
4768 msiobj_release(&row->hdr);
4769 }
4770 MSI_ViewClose(view);
4771 msiobj_release(&view->hdr);
4772
4773 end:
4774 RegCloseKey(hkey);
4775 return rc;
4776 }
4777
4778 static UINT register_progid_base(MSIPACKAGE* package, MSIRECORD * row,
4779 LPWSTR clsid)
4780 {
4781 static const WCHAR szCLSID[] = { 'C','L','S','I','D',0 };
4782 static const WCHAR szDefaultIcon[] =
4783 {'D','e','f','a','u','l','t','I','c','o','n',0};
4784 HKEY hkey,hkey2;
4785 WCHAR buffer[0x100];
4786 DWORD sz;
4787
4788
4789 sz = 0x100;
4790 MSI_RecordGetStringW(row,1,buffer,&sz);
4791 RegCreateKeyW(HKEY_CLASSES_ROOT,buffer,&hkey);
4792
4793 if (!MSI_RecordIsNull(row,4))
4794 {
4795 sz = 0x100;
4796 MSI_RecordGetStringW(row,4,buffer,&sz);
4797 RegSetValueExW(hkey,NULL,0,REG_SZ,(LPVOID)buffer, (strlenW(buffer)+1) *
4798 sizeof(WCHAR));
4799 }
4800
4801 if (!MSI_RecordIsNull(row,3))
4802 {
4803 sz = 0x100;
4804
4805 MSI_RecordGetStringW(row,3,buffer,&sz);
4806 RegCreateKeyW(hkey,szCLSID,&hkey2);
4807 RegSetValueExW(hkey2,NULL,0,REG_SZ,(LPVOID)buffer, (strlenW(buffer)+1) *
4808 sizeof(WCHAR));
4809
4810 if (clsid)
4811 strcpyW(clsid,buffer);
4812
4813 RegCloseKey(hkey2);
4814 }
4815 else
4816 {
4817 FIXME("UNHANDLED case, Parent progid but classid is NULL\n");
4818 return ERROR_FUNCTION_FAILED;
4819 }
4820 if (!MSI_RecordIsNull(row,5))
4821 {
4822 INT index = MSI_RecordGetInteger(row,6);
4823 LPWSTR FileName = load_dynamic_stringW(row,5);
4824 LPWSTR FilePath,IconPath;
4825 static const WCHAR fmt[] = {'%','s',',','%','i',0};
4826
4827 RegCreateKeyW(hkey,szDefaultIcon,&hkey2);
4828 build_icon_path(package,FileName,&FilePath);
4829
4830 IconPath = HeapAlloc(GetProcessHeap(),0,(strlenW(FilePath)+5)*
4831 sizeof(WCHAR));
4832
4833 sprintfW(IconPath,fmt,FilePath,index);
4834 RegSetValueExW(hkey2,NULL,0,REG_SZ,(LPVOID)IconPath,
4835 (strlenW(IconPath)+1) * sizeof(WCHAR));
4836 HeapFree(GetProcessHeap(),0,FilePath);
4837 HeapFree(GetProcessHeap(),0,FileName);
4838 RegCloseKey(hkey2);
4839 }
4840 return ERROR_SUCCESS;
4841 }
4842
4843 static UINT register_progid(MSIPACKAGE *package, MSIRECORD * row, LPWSTR clsid);
4844
4845 static UINT register_parent_progid(MSIPACKAGE *package, LPCWSTR parent,
4846 LPWSTR clsid)
4847 {
4848 UINT rc;
4849 MSIQUERY * view;
4850 MSIRECORD * row = 0;
4851 static const WCHAR Query_t[] =
4852 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4853 '`','P','r','o','g' ,'I','d','`',' ','W','H','E','R','E',' ',
4854 '`','P','r','o','g','I','d','`',' ','=',' ','\'' ,'%','s','\'',0};
4855
4856 if (!package)
4857 return ERROR_INVALID_HANDLE;
4858
4859 rc = MSI_OpenQuery(package->db, &view, Query_t, parent);
4860 if (rc != ERROR_SUCCESS)
4861 return rc;
4862
4863 rc = MSI_ViewExecute(view, 0);
4864 if (rc != ERROR_SUCCESS)
4865 {
4866 MSI_ViewClose(view);
4867 msiobj_release(&view->hdr);
4868 return rc;
4869 }
4870
4871 rc = MSI_ViewFetch(view,&row);
4872 if (rc != ERROR_SUCCESS)
4873 {
4874 MSI_ViewClose(view);
4875 msiobj_release(&view->hdr);
4876 return rc;
4877 }
4878
4879 register_progid(package,row,clsid);
4880
4881 msiobj_release(&row->hdr);
4882 MSI_ViewClose(view);
4883 msiobj_release(&view->hdr);
4884 return rc;
4885 }
4886
4887 static UINT register_progid(MSIPACKAGE *package, MSIRECORD * row, LPWSTR clsid)
4888 {
4889 UINT rc = ERROR_SUCCESS;
4890
4891 if (MSI_RecordIsNull(row,2))
4892 rc = register_progid_base(package,row,clsid);
4893 else
4894 {
4895 WCHAR buffer[0x1000];
4896 DWORD sz, disp;
4897 HKEY hkey,hkey2;
4898 static const WCHAR szCLSID[] = { 'C','L','S','I','D',0 };
4899 static const WCHAR szDefaultIcon[] =
4900 {'D','e','f','a','u','l','t','I','c','o','n',0};
4901
4902 /* check if already registered */
4903 sz = 0x100;
4904 MSI_RecordGetStringW(row,1,buffer,&sz);
4905 RegCreateKeyExW(HKEY_CLASSES_ROOT, buffer, 0, NULL, 0,
4906 KEY_ALL_ACCESS, NULL, &hkey, &disp );
4907 if (disp == REG_OPENED_EXISTING_KEY)
4908 {
4909 TRACE("Key already registered\n");
4910 RegCloseKey(hkey);
4911 return rc;
4912 }
4913
4914 sz = 0x100;
4915 MSI_RecordGetStringW(row,2,buffer,&sz);
4916 rc = register_parent_progid(package,buffer,clsid);
4917
4918 /* clsid is same as parent */
4919 RegCreateKeyW(hkey,szCLSID,&hkey2);
4920 RegSetValueExW(hkey2,NULL,0,REG_SZ,(LPVOID)clsid, (strlenW(clsid)+1) *
4921 sizeof(WCHAR));
4922
4923 RegCloseKey(hkey2);
4924
4925
4926 if (!MSI_RecordIsNull(row,4))
4927 {
4928 sz = 0x100;
4929 MSI_RecordGetStringW(row,4,buffer,&sz);
4930 RegSetValueExW(hkey,NULL,0,REG_SZ,(LPVOID)buffer,
4931 (strlenW(buffer)+1) * sizeof(WCHAR));
4932 }
4933
4934 if (!MSI_RecordIsNull(row,5))
4935 {
4936 LPWSTR FileName = load_dynamic_stringW(row,5);
4937 LPWSTR FilePath;
4938 RegCreateKeyW(hkey,szDefaultIcon,&hkey2);
4939 build_icon_path(package,FileName,&FilePath);
4940 RegSetValueExW(hkey2,NULL,0,REG_SZ,(LPVOID)FilePath,
4941 (strlenW(FilePath)+1) * sizeof(WCHAR));
4942 HeapFree(GetProcessHeap(),0,FilePath);
4943 HeapFree(GetProcessHeap(),0,FileName);
4944 RegCloseKey(hkey2);
4945 }
4946
4947 RegCloseKey(hkey);
4948 }
4949 return rc;
4950 }
4951
4952 static UINT ACTION_RegisterProgIdInfo(MSIPACKAGE *package)
4953 {
4954 /*
4955 * Sigh, here I am just brute force registering all progids
4956 * this needs to be linked to the Classes that have been registered
4957 * but the easiest way to do that is to load all these stuff into
4958 * memory for easy checking.
4959 *
4960 * Gives me something to continue to work toward.
4961 */
4962 UINT rc;
4963 MSIQUERY * view;
4964 MSIRECORD * row = 0;
4965 static const WCHAR Query[] =
4966 {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
4967 '`','P','r','o','g','I','d','`',0};
4968
4969 if (!package)
4970 return ERROR_INVALID_HANDLE;
4971
4972 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
4973 if (rc != ERROR_SUCCESS)
4974 return ERROR_SUCCESS;
4975
4976 rc = MSI_ViewExecute(view, 0);
4977 if (rc != ERROR_SUCCESS)
4978 {
4979 MSI_ViewClose(view);
4980 msiobj_release(&view->hdr);
4981 return rc;
4982 }
4983
4984 while (1)
4985 {
4986 WCHAR clsid[0x1000];
4987
4988 rc = MSI_ViewFetch(view,&row);
4989 if (rc != ERROR_SUCCESS)
4990 {
4991 rc = ERROR_SUCCESS;
4992 break;
4993 }
4994
4995 register_progid(package,row,clsid);
4996 ui_actiondata(package,szRegisterProgIdInfo,row);
4997
4998 msiobj_release(&row->hdr);
4999 }
5000 MSI_ViewClose(view);
5001 msiobj_release(&view->hdr);
5002 return rc;
5003 }
5004
5005 static UINT build_icon_path(MSIPACKAGE *package, LPCWSTR icon_name,
5006 LPWSTR *FilePath)
5007 {
5008 LPWSTR ProductCode;
5009 LPWSTR SystemFolder;
5010 LPWSTR dest;
5011 UINT rc;
5012
5013 static const WCHAR szInstaller[] =
5014 {'I','n','s','t','a','l','l','e','r','\\',0};
5015 static const WCHAR szFolder[] =
5016 {'W','i','n','d','o','w','s','F','o','l','d','e','r',0};
5017
5018 ProductCode = load_dynamic_property(package,szProductCode,&rc);
5019 if (!ProductCode)
5020 return rc;
5021
5022 SystemFolder = load_dynamic_property(package,szFolder,NULL);
5023
5024 dest = build_directory_name(3, SystemFolder, szInstaller, ProductCode);
5025
5026 create_full_pathW(dest);
5027
5028 *FilePath = build_directory_name(2, dest, icon_name);
5029
5030 HeapFree(GetProcessHeap(),0,SystemFolder);
5031 HeapFree(GetProcessHeap(),0,ProductCode);
5032 HeapFree(GetProcessHeap(),0,dest);
5033 return ERROR_SUCCESS;
5034 }
5035
5036 static UINT ACTION_CreateShortcuts(MSIPACKAGE *package)
5037 {
5038 UINT rc;
5039 MSIQUERY * view;
5040 MSIRECORD * row = 0;
5041 static const WCHAR Query[] =
5042 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5043 '`','S','h','o','r','t','c','u','t','`',0};
5044 IShellLinkW *sl;
5045 IPersistFile *pf;
5046 HRESULT res;
5047
5048 if (!package)
5049 return ERROR_INVALID_HANDLE;
5050
5051 res = CoInitialize( NULL );
5052 if (FAILED (res))
5053 {
5054 ERR("CoInitialize failed\n");
5055 return ERROR_FUNCTION_FAILED;
5056 }
5057
5058 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
5059 if (rc != ERROR_SUCCESS)
5060 return ERROR_SUCCESS;
5061
5062 rc = MSI_ViewExecute(view, 0);
5063 if (rc != ERROR_SUCCESS)
5064 {
5065 MSI_ViewClose(view);
5066 msiobj_release(&view->hdr);
5067 return rc;
5068 }
5069
5070 while (1)
5071 {
5072 LPWSTR target_file, target_folder;
5073 WCHAR buffer[0x100];
5074 DWORD sz;
5075 DWORD index;
5076 static const WCHAR szlnk[]={'.','l','n','k',0};
5077
5078 rc = MSI_ViewFetch(view,&row);
5079 if (rc != ERROR_SUCCESS)
5080 {
5081 rc = ERROR_SUCCESS;
5082 break;
5083 }
5084
5085 sz = 0x100;
5086 MSI_RecordGetStringW(row,4,buffer,&sz);
5087
5088 index = get_loaded_component(package,buffer);
5089
5090 if (index < 0)
5091 {
5092 msiobj_release(&row->hdr);
5093 continue;
5094 }
5095
5096 if (!ACTION_VerifyComponentForAction(package, index,
5097 INSTALLSTATE_LOCAL))
5098 {
5099 TRACE("Skipping shortcut creation due to disabled component\n");
5100 msiobj_release(&row->hdr);
5101
5102 package->components[index].Action =
5103 package->components[index].Installed;
5104
5105 continue;
5106 }
5107
5108 package->components[index].Action = INSTALLSTATE_LOCAL;
5109
5110 ui_actiondata(package,szCreateShortcuts,row);
5111
5112 res = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
5113 &IID_IShellLinkW, (LPVOID *) &sl );
5114
5115 if (FAILED(res))
5116 {
5117 ERR("Is IID_IShellLink\n");
5118 msiobj_release(&row->hdr);
5119 continue;
5120 }
5121
5122 res = IShellLinkW_QueryInterface( sl, &IID_IPersistFile,(LPVOID*) &pf );
5123 if( FAILED( res ) )
5124 {
5125 ERR("Is IID_IPersistFile\n");
5126 msiobj_release(&row->hdr);
5127 continue;
5128 }
5129
5130 sz = 0x100;
5131 MSI_RecordGetStringW(row,2,buffer,&sz);
5132 target_folder = resolve_folder(package, buffer,FALSE,FALSE,NULL);
5133
5134 /* may be needed because of a bug somehwere else */
5135 create_full_pathW(target_folder);
5136
5137 sz = 0x100;
5138 MSI_RecordGetStringW(row,3,buffer,&sz);
5139 reduce_to_longfilename(buffer);
5140 if (!strchrW(buffer,'.') || strcmpiW(strchrW(buffer,'.'),szlnk))
5141 strcatW(buffer,szlnk);
5142 target_file = build_directory_name(2, target_folder, buffer);
5143 HeapFree(GetProcessHeap(),0,target_folder);
5144
5145 sz = 0x100;
5146 MSI_RecordGetStringW(row,5,buffer,&sz);
5147 if (strchrW(buffer,'['))
5148 {
5149 LPWSTR deformated;
5150 deformat_string(package,buffer,&deformated);
5151 IShellLinkW_SetPath(sl,deformated);
5152 HeapFree(GetProcessHeap(),0,deformated);
5153 }
5154 else
5155 {
5156 LPWSTR keypath;
5157 FIXME("poorly handled shortcut format, advertised shortcut\n");
5158 keypath = strdupW(package->components[index].FullKeypath);
5159 IShellLinkW_SetPath(sl,keypath);
5160 HeapFree(GetProcessHeap(),0,keypath);
5161 }
5162
5163 if (!MSI_RecordIsNull(row,6))
5164 {
5165 LPWSTR deformated;
5166 sz = 0x100;
5167 MSI_RecordGetStringW(row,6,buffer,&sz);
5168 deformat_string(package,buffer,&deformated);
5169 IShellLinkW_SetArguments(sl,deformated);
5170 HeapFree(GetProcessHeap(),0,deformated);
5171 }
5172
5173 if (!MSI_RecordIsNull(row,7))
5174 {
5175 LPWSTR deformated;
5176 deformated = load_dynamic_stringW(row,7);
5177 IShellLinkW_SetDescription(sl,deformated);
5178 HeapFree(GetProcessHeap(),0,deformated);
5179 }
5180
5181 if (!MSI_RecordIsNull(row,8))
5182 IShellLinkW_SetHotkey(sl,MSI_RecordGetInteger(row,8));
5183
5184 if (!MSI_RecordIsNull(row,9))
5185 {
5186 WCHAR *Path = NULL;
5187 INT index;
5188
5189 sz = 0x100;
5190 MSI_RecordGetStringW(row,9,buffer,&sz);
5191
5192 build_icon_path(package,buffer,&Path);
5193 index = MSI_RecordGetInteger(row,10);
5194
5195 IShellLinkW_SetIconLocation(sl,Path,index);
5196 HeapFree(GetProcessHeap(),0,Path);
5197 }
5198
5199 if (!MSI_RecordIsNull(row,11))
5200 IShellLinkW_SetShowCmd(sl,MSI_RecordGetInteger(row,11));
5201
5202 if (!MSI_RecordIsNull(row,12))
5203 {
5204 LPWSTR Path;
5205 sz = 0x100;
5206 MSI_RecordGetStringW(row,12,buffer,&sz);
5207 Path = resolve_folder(package, buffer, FALSE, FALSE, NULL);
5208 IShellLinkW_SetWorkingDirectory(sl,Path);
5209 HeapFree(GetProcessHeap(), 0, Path);
5210 }
5211
5212 TRACE("Writing shortcut to %s\n",debugstr_w(target_file));
5213 IPersistFile_Save(pf,target_file,FALSE);
5214
5215 HeapFree(GetProcessHeap(),0,target_file);
5216
5217 IPersistFile_Release( pf );
5218 IShellLinkW_Release( sl );
5219
5220 msiobj_release(&row->hdr);
5221 }
5222 MSI_ViewClose(view);
5223 msiobj_release(&view->hdr);
5224
5225
5226 CoUninitialize();
5227
5228 return rc;
5229 }
5230
5231
5232 /*
5233 * 99% of the work done here is only done for
5234 * advertised installs. However this is where the
5235 * Icon table is processed and written out
5236 * so that is what I am going to do here.
5237 */
5238 static UINT ACTION_PublishProduct(MSIPACKAGE *package)
5239 {
5240 UINT rc;
5241 MSIQUERY * view;
5242 MSIRECORD * row = 0;
5243 static const WCHAR Query[]=
5244 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5245 '`','I','c','o','n','`',0};
5246 DWORD sz;
5247 /* for registry stuff */
5248 LPWSTR productcode;
5249 HKEY hkey=0;
5250 HKEY hukey=0;
5251 static const WCHAR szProductName[] =
5252 {'P','r','o','d','u','c','t','N','a','m','e',0};
5253 static const WCHAR szPackageCode[] =
5254 {'P','a','c','k','a','g','e','C','o','d','e',0};
5255 LPWSTR buffer;
5256 DWORD size;
5257 MSIHANDLE hDb, hSumInfo;
5258
5259 if (!package)
5260 return ERROR_INVALID_HANDLE;
5261
5262 rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
5263 if (rc != ERROR_SUCCESS)
5264 goto next;
5265
5266 rc = MSI_ViewExecute(view, 0);
5267 if (rc != ERROR_SUCCESS)
5268 {
5269 MSI_ViewClose(view);
5270 msiobj_release(&view->hdr);
5271 goto next;
5272 }
5273
5274 while (1)
5275 {
5276 HANDLE the_file;
5277 WCHAR *FilePath=NULL;
5278 WCHAR *FileName=NULL;
5279 CHAR buffer[1024];
5280
5281 rc = MSI_ViewFetch(view,&row);
5282 if (rc != ERROR_SUCCESS)
5283 {
5284 rc = ERROR_SUCCESS;
5285 break;
5286 }
5287
5288 FileName = load_dynamic_stringW(row,1);
5289 if (!FileName)
5290 {
5291 ERR("Unable to get FileName\n");
5292 msiobj_release(&row->hdr);
5293 continue;
5294 }
5295
5296 build_icon_path(package,FileName,&FilePath);
5297
5298 HeapFree(GetProcessHeap(),0,FileName);
5299
5300 TRACE("Creating icon file at %s\n",debugstr_w(FilePath));
5301
5302 the_file = CreateFileW(FilePath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
5303 FILE_ATTRIBUTE_NORMAL, NULL);
5304
5305 if (the_file == INVALID_HANDLE_VALUE)
5306 {
5307 ERR("Unable to create file %s\n",debugstr_w(FilePath));
5308 msiobj_release(&row->hdr);
5309 HeapFree(GetProcessHeap(),0,FilePath);
5310 continue;
5311 }
5312
5313 do
5314 {
5315 DWORD write;
5316 sz = 1024;
5317 rc = MSI_RecordReadStream(row,2,buffer,&sz);
5318 if (rc != ERROR_SUCCESS)
5319 {
5320 ERR("Failed to get stream\n");
5321 CloseHandle(the_file);
5322 DeleteFileW(FilePath);
5323 break;
5324 }
5325 WriteFile(the_file,buffer,sz,&write,NULL);
5326 } while (sz == 1024);
5327
5328 HeapFree(GetProcessHeap(),0,FilePath);
5329
5330 CloseHandle(the_file);
5331 msiobj_release(&row->hdr);
5332 }
5333 MSI_ViewClose(view);
5334 msiobj_release(&view->hdr);
5335
5336 next:
5337 /* ok there is a lot more done here but i need to figure out what */
5338 productcode = load_dynamic_property(package,szProductCode,&rc);
5339 if (!productcode)
5340 return rc;
5341
5342 rc = MSIREG_OpenProductsKey(productcode,&hkey,TRUE);
5343 if (rc != ERROR_SUCCESS)
5344 goto end;
5345
5346 rc = MSIREG_OpenUserProductsKey(productcode,&hukey,TRUE);
5347 if (rc != ERROR_SUCCESS)
5348 goto end;
5349
5350
5351 buffer = load_dynamic_property(package,szProductName,NULL);
5352 size = strlenW(buffer)*sizeof(WCHAR);
5353 RegSetValueExW(hukey,szProductName,0,REG_SZ, (LPSTR)buffer,size);
5354 HeapFree(GetProcessHeap(),0,buffer);
5355 FIXME("Need to write more keys to the user registry\n");
5356
5357 hDb= alloc_msihandle( &package->db->hdr );
5358 rc = MsiGetSummaryInformationW(hDb, NULL, 0, &hSumInfo);
5359 MsiCloseHandle(hDb);
5360 if (rc == ERROR_SUCCESS)
5361 {
5362 WCHAR guidbuffer[0x200];
5363 size = 0x200;
5364 rc = MsiSummaryInfoGetPropertyW(hSumInfo, 9, NULL, NULL, NULL,
5365 guidbuffer, &size);
5366 if (rc == ERROR_SUCCESS)
5367 {
5368 WCHAR squashed[GUID_SIZE];
5369 /* for now we only care about the first guid */
5370 LPWSTR ptr = strchrW(guidbuffer,';');
5371 if (ptr) *ptr = 0;
5372 squash_guid(guidbuffer,squashed);
5373 size = strlenW(squashed)*sizeof(WCHAR);
5374 RegSetValueExW(hukey,szPackageCode,0,REG_SZ, (LPSTR)squashed,
5375 size);
5376 }
5377 else
5378 {
5379 ERR("Unable to query Revision_Number... \n");
5380 rc = ERROR_SUCCESS;
5381 }
5382 MsiCloseHandle(hSumInfo);
5383 }
5384 else
5385 {
5386 ERR("Unable to open Summary Information\n");
5387 rc = ERROR_SUCCESS;
5388 }
5389
5390 end:
5391
5392 HeapFree(GetProcessHeap(),0,productcode);
5393 RegCloseKey(hkey);
5394 RegCloseKey(hukey);
5395
5396 return rc;
5397 }
5398
5399 static UINT ACTION_WriteIniValues(MSIPACKAGE *package)
5400 {
5401 UINT rc;
5402 MSIQUERY * view;
5403 MSIRECORD * row = 0;
5404 static const WCHAR ExecSeqQuery[] =
5405 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5406 '`','I','n','i','F','i','l','e','`',0};
5407 static const WCHAR szWindowsFolder[] =
5408 {'W','i','n','d','o','w','s','F','o','l','d','e','r',0};
5409
5410 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
5411 if (rc != ERROR_SUCCESS)
5412 {
5413 TRACE("no IniFile table\n");
5414 return ERROR_SUCCESS;
5415 }
5416
5417 rc = MSI_ViewExecute(view, 0);
5418 if (rc != ERROR_SUCCESS)
5419 {
5420 MSI_ViewClose(view);
5421 msiobj_release(&view->hdr);
5422 return rc;
5423 }
5424
5425 while (1)
5426 {
5427 LPWSTR component,filename,dirproperty,section,key,value,identifier;
5428 LPWSTR deformated_section, deformated_key, deformated_value;
5429 LPWSTR folder, fullname = NULL;
5430 MSIRECORD * uirow;
5431 INT component_index,action;
5432
5433 rc = MSI_ViewFetch(view,&row);
5434 if (rc != ERROR_SUCCESS)
5435 {
5436 rc = ERROR_SUCCESS;
5437 break;
5438 }
5439
5440 component = load_dynamic_stringW(row, 8);
5441 component_index = get_loaded_component(package,component);
5442 HeapFree(GetProcessHeap(),0,component);
5443
5444 if (!ACTION_VerifyComponentForAction(package, component_index,
5445 INSTALLSTATE_LOCAL))
5446 {
5447 TRACE("Skipping ini file due to disabled component\n");
5448 msiobj_release(&row->hdr);
5449
5450 package->components[component_index].Action =
5451 package->components[component_index].Installed;
5452
5453 continue;
5454 }
5455
5456 package->components[component_index].Action = INSTALLSTATE_LOCAL;
5457
5458 identifier = load_dynamic_stringW(row,1);
5459 filename = load_dynamic_stringW(row,2);
5460 dirproperty = load_dynamic_stringW(row,3);
5461 section = load_dynamic_stringW(row,4);
5462 key = load_dynamic_stringW(row,5);
5463 value = load_dynamic_stringW(row,6);
5464 action = MSI_RecordGetInteger(row,7);
5465
5466 deformat_string(package,section,&deformated_section);
5467 deformat_string(package,key,&deformated_key);
5468 deformat_string(package,value,&deformated_value);
5469
5470 if (dirproperty)
5471 {
5472 folder = resolve_folder(package, dirproperty, FALSE, FALSE, NULL);
5473 if (!folder)
5474 folder = load_dynamic_property(package,dirproperty,NULL);
5475 }
5476 else
5477 folder = load_dynamic_property(package, szWindowsFolder, NULL);
5478
5479 if (!folder)
5480 {
5481 ERR("Unable to resolve folder! (%s)\n",debugstr_w(dirproperty));
5482 goto cleanup;
5483 }
5484
5485 fullname = build_directory_name(3, folder, filename, NULL);
5486
5487 if (action == 0)
5488 {
5489 TRACE("Adding value %s to section %s in %s\n",
5490 debugstr_w(deformated_key), debugstr_w(deformated_section),
5491 debugstr_w(fullname));
5492 WritePrivateProfileStringW(deformated_section, deformated_key,
5493 deformated_value, fullname);
5494 }
5495 else if (action == 1)
5496 {
5497 WCHAR returned[10];
5498 GetPrivateProfileStringW(deformated_section, deformated_key, NULL,
5499 returned, 10, fullname);
5500 if (returned[0] == 0)
5501 {
5502 TRACE("Adding value %s to section %s in %s\n",
5503 debugstr_w(deformated_key), debugstr_w(deformated_section),
5504 debugstr_w(fullname));
5505
5506 WritePrivateProfileStringW(deformated_section, deformated_key,
5507 deformated_value, fullname);
5508 }
5509 }
5510 else if (action == 3)
5511 {
5512 FIXME("Append to existing section not yet implemented\n");
5513 }
5514
5515 uirow = MSI_CreateRecord(4);
5516 MSI_RecordSetStringW(uirow,1,identifier);
5517 MSI_RecordSetStringW(uirow,2,deformated_section);
5518 MSI_RecordSetStringW(uirow,3,deformated_key);
5519 MSI_RecordSetStringW(uirow,4,deformated_value);
5520 ui_actiondata(package,szWriteIniValues,uirow);
5521 msiobj_release( &uirow->hdr );
5522 cleanup:
5523 HeapFree(GetProcessHeap(),0,identifier);
5524 HeapFree(GetProcessHeap(),0,fullname);
5525 HeapFree(GetProcessHeap(),0,filename);
5526 HeapFree(GetProcessHeap(),0,key);
5527 HeapFree(GetProcessHeap(),0,value);
5528 HeapFree(GetProcessHeap(),0,section);
5529 HeapFree(GetProcessHeap(),0,dirproperty);
5530 HeapFree(GetProcessHeap(),0,folder);
5531 HeapFree(GetProcessHeap(),0,deformated_key);
5532 HeapFree(GetProcessHeap(),0,deformated_value);
5533 HeapFree(GetProcessHeap(),0,deformated_section);
5534 msiobj_release(&row->hdr);
5535 }
5536 MSI_ViewClose(view);
5537 msiobj_release(&view->hdr);
5538 return rc;
5539 }
5540
5541 static UINT ACTION_SelfRegModules(MSIPACKAGE *package)
5542 {
5543 UINT rc;
5544 MSIQUERY * view;
5545 MSIRECORD * row = 0;
5546 static const WCHAR ExecSeqQuery[] =
5547 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5548 '`','S','e','l','f','R','e','g','`',0};
5549
5550 static const WCHAR ExeStr[] =
5551 {'r','e','g','s','v','r','3','2','.','e','x','e',' ','\"',0};
5552 static const WCHAR close[] = {'\"',0};
5553 STARTUPINFOW si;
5554 PROCESS_INFORMATION info;
5555 BOOL brc;
5556
5557 memset(&si,0,sizeof(STARTUPINFOW));
5558
5559 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
5560 if (rc != ERROR_SUCCESS)
5561 {
5562 TRACE("no SelfReg table\n");
5563 return ERROR_SUCCESS;
5564 }
5565
5566 rc = MSI_ViewExecute(view, 0);
5567 if (rc != ERROR_SUCCESS)
5568 {
5569 MSI_ViewClose(view);
5570 msiobj_release(&view->hdr);
5571 return rc;
5572 }
5573
5574 while (1)
5575 {
5576 LPWSTR filename;
5577 INT index;
5578 DWORD len;
5579
5580 rc = MSI_ViewFetch(view,&row);
5581 if (rc != ERROR_SUCCESS)
5582 {
5583 rc = ERROR_SUCCESS;
5584 break;
5585 }
5586
5587 filename = load_dynamic_stringW(row,1);
5588 index = get_loaded_file(package,filename);
5589
5590 if (index < 0)
5591 {
5592 ERR("Unable to find file id %s\n",debugstr_w(filename));
5593 HeapFree(GetProcessHeap(),0,filename);
5594 msiobj_release(&row->hdr);
5595 continue;
5596 }
5597 HeapFree(GetProcessHeap(),0,filename);
5598
5599 len = strlenW(ExeStr);
5600 len += strlenW(package->files[index].TargetPath);
5601 len +=2;
5602
5603 filename = HeapAlloc(GetProcessHeap(),0,len*sizeof(WCHAR));
5604 strcpyW(filename,ExeStr);
5605 strcatW(filename,package->files[index].TargetPath);
5606 strcatW(filename,close);
5607
5608 TRACE("Registering %s\n",debugstr_w(filename));
5609 brc = CreateProcessW(NULL, filename, NULL, NULL, FALSE, 0, NULL,
5610 c_colon, &si, &info);
5611
5612 if (brc)
5613 msi_dialog_check_messages(info.hProcess);
5614
5615 HeapFree(GetProcessHeap(),0,filename);
5616 msiobj_release(&row->hdr);
5617 }
5618 MSI_ViewClose(view);
5619 msiobj_release(&view->hdr);
5620 return rc;
5621 }
5622
5623 static UINT ACTION_PublishFeatures(MSIPACKAGE *package)
5624 {
5625 LPWSTR productcode;
5626 UINT rc;
5627 DWORD i;
5628 HKEY hkey=0;
5629 HKEY hukey=0;
5630
5631 if (!package)
5632 return ERROR_INVALID_HANDLE;
5633
5634 productcode = load_dynamic_property(package,szProductCode,&rc);
5635 if (!productcode)
5636 return rc;
5637
5638 rc = MSIREG_OpenFeaturesKey(productcode,&hkey,TRUE);
5639 if (rc != ERROR_SUCCESS)
5640 goto end;
5641
5642 rc = MSIREG_OpenUserFeaturesKey(productcode,&hukey,TRUE);
5643 if (rc != ERROR_SUCCESS)
5644 goto end;
5645
5646 /* here the guids are base 85 encoded */
5647 for (i = 0; i < package->loaded_features; i++)
5648 {
5649 LPWSTR data = NULL;
5650 GUID clsid;
5651 int j;
5652 INT size;
5653 BOOL absent = FALSE;
5654
5655 if (!ACTION_VerifyFeatureForAction(package,i,INSTALLSTATE_LOCAL) &&
5656 !ACTION_VerifyFeatureForAction(package,i,INSTALLSTATE_SOURCE) &&
5657 !ACTION_VerifyFeatureForAction(package,i,INSTALLSTATE_ADVERTISED))
5658 absent = TRUE;
5659
5660 size = package->features[i].ComponentCount*21;
5661 size +=1;
5662 if (package->features[i].Feature_Parent[0])
5663 size += strlenW(package->features[i].Feature_Parent)+2;
5664
5665 data = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
5666
5667 data[0] = 0;
5668 for (j = 0; j < package->features[i].ComponentCount; j++)
5669 {
5670 WCHAR buf[21];
5671 memset(buf,0,sizeof(buf));
5672 if (package->components
5673 [package->features[i].Components[j]].ComponentId[0]!=0)
5674 {
5675 TRACE("From %s\n",debugstr_w(package->components
5676 [package->features[i].Components[j]].ComponentId));
5677 CLSIDFromString(package->components
5678 [package->features[i].Components[j]].ComponentId,
5679 &clsid);
5680 encode_base85_guid(&clsid,buf);
5681 TRACE("to %s\n",debugstr_w(buf));
5682 strcatW(data,buf);
5683 }
5684 }
5685 if (package->features[i].Feature_Parent[0])
5686 {
5687 static const WCHAR sep[] = {'\2',0};
5688 strcatW(data,sep);
5689 strcatW(data,package->features[i].Feature_Parent);
5690 }
5691
5692 size = (strlenW(data)+1)*sizeof(WCHAR);
5693 RegSetValueExW(hkey,package->features[i].Feature,0,REG_SZ,
5694 (LPSTR)data,size);
5695 HeapFree(GetProcessHeap(),0,data);
5696
5697 if (!absent)
5698 {
5699 size = strlenW(package->features[i].Feature_Parent)*sizeof(WCHAR);
5700 RegSetValueExW(hukey,package->features[i].Feature,0,REG_SZ,
5701 (LPSTR)package->features[i].Feature_Parent,size);
5702 }
5703 else
5704 {
5705 size = (strlenW(package->features[i].Feature_Parent)+2)*
5706 sizeof(WCHAR);
5707 data = HeapAlloc(GetProcessHeap(),0,size);
5708 data[0] = 0x6;
5709 strcpyW(&data[1],package->features[i].Feature_Parent);
5710 RegSetValueExW(hukey,package->features[i].Feature,0,REG_SZ,
5711 (LPSTR)data,size);
5712 HeapFree(GetProcessHeap(),0,data);
5713 }
5714 }
5715
5716 end:
5717 RegCloseKey(hkey);
5718 RegCloseKey(hukey);
5719 HeapFree(GetProcessHeap(), 0, productcode);
5720 return rc;
5721 }
5722
5723 static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
5724 {
5725 HKEY hkey=0;
5726 LPWSTR buffer;
5727 LPWSTR productcode;
5728 UINT rc,i;
5729 DWORD size;
5730 static WCHAR szNONE[] = {0};
5731 static const WCHAR szWindowsInstaler[] =
5732 {'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
5733 static const WCHAR szPropKeys[][80] =
5734 {
5735 {'A','R','P','A','U','T','H','O','R','I','Z','E','D','C','D','F','P','R','E','F','I','X',0},
5736 {'A','R','P','C','O','N','T','A','C','T',0},
5737 {'A','R','P','C','O','M','M','E','N','T','S',0},
5738 {'P','r','o','d','u','c','t','N','a','m','e',0},
5739 {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0},
5740 {'A','R','P','H','E','L','P','L','I','N','K',0},
5741 {'A','R','P','H','E','L','P','T','E','L','E','P','H','O','N','E',0},
5742 {'A','R','P','I','N','S','T','A','L','L','L','O','C','A','T','I','O','N',0},
5743 {'S','o','u','r','c','e','D','i','r',0},
5744 {'M','a','n','u','f','a','c','t','u','r','e','r',0},
5745 {'A','R','P','R','E','A','D','M','E',0},
5746 {'A','R','P','S','I','Z','E',0},
5747 {'A','R','P','U','R','L','I','N','F','O','A','B','O','U','T',0},
5748 {'A','R','P','U','R','L','U','P','D','A','T','E','I','N','F','O',0},
5749 {0},
5750 };
5751
5752 static const WCHAR szRegKeys[][80] =
5753 {
5754 {'A','u','t','h','o','r','i','z','e','d','C','D','F','P','r','e','f','i','x',0},
5755 {'C','o','n','t','a','c','t',0},
5756 {'C','o','m','m','e','n','t','s',0},
5757 {'D','i','s','p','l','a','y','N','a','m','e',0},
5758 {'D','i','s','p','l','a','y','V','e','r','s','i','o','n',0},
5759 {'H','e','l','p','L','i','n','k',0},
5760 {'H','e','l','p','T','e','l','e','p','h','o','n','e',0},
5761 {'I','n','s','t','a','l','l','L','o','c','a','t','i','o','n',0},
5762 {'I','n','s','t','a','l','l','S','o','u','r','c','e',0},
5763 {'P','u','b','l','i','s','h','e','r',0},
5764 {'R','e','a','d','m','e',0},
5765 {'S','i','z','e',0},
5766 {'U','R','L','I','n','f','o','A','b','o','u','t',0},
5767 {'U','R','L','U','p','d','a','t','e','I','n','f','o',0},
5768 {0},
5769 };
5770
5771 static const WCHAR installerPathFmt[] = {
5772 '%','s','\\',
5773 'I','n','s','t','a','l','l','e','r','\\',0};
5774 static const WCHAR fmt[] = {
5775 '%','s','\\',
5776 'I','n','s','t','a','l','l','e','r','\\',
5777 '%','x','.','m','s','i',0};
5778 static const WCHAR szLocalPackage[]=
5779 {'L','o','c','a','l','P','a','c','k','a','g','e',0};
5780 WCHAR windir[MAX_PATH], path[MAX_PATH], packagefile[MAX_PATH];
5781 INT num,start;
5782
5783 if (!package)
5784 return ERROR_INVALID_HANDLE;
5785
5786 productcode = load_dynamic_property(package,szProductCode,&rc);
5787 if (!productcode)
5788 return rc;
5789
5790 rc = MSIREG_OpenUninstallKey(productcode,&hkey,TRUE);
5791 if (rc != ERROR_SUCCESS)
5792 goto end;
5793
5794 /* dump all the info i can grab */
5795 FIXME("Flesh out more information \n");
5796
5797 i = 0;
5798 while (szPropKeys[i][0]!=0)
5799 {
5800 buffer = load_dynamic_property(package,szPropKeys[i],&rc);
5801 if (rc != ERROR_SUCCESS)
5802 buffer = szNONE;
5803 size = strlenW(buffer)*sizeof(WCHAR);
5804 RegSetValueExW(hkey,szRegKeys[i],0,REG_SZ,(LPSTR)buffer,size);
5805 i++;
5806 }
5807
5808 rc = 0x1;
5809 size = sizeof(rc);
5810 RegSetValueExW(hkey,szWindowsInstaler,0,REG_DWORD,(LPSTR)&rc,size);
5811
5812 /* copy the package locally */
5813 num = GetTickCount() & 0xffff;
5814 if (!num)
5815 num = 1;
5816 start = num;
5817 GetWindowsDirectoryW(windir, sizeof(windir) / sizeof(windir[0]));
5818 snprintfW(packagefile,sizeof(packagefile)/sizeof(packagefile[0]),fmt,
5819 windir,num);
5820 do
5821 {
5822 HANDLE handle = CreateFileW(packagefile,GENERIC_WRITE, 0, NULL,
5823 CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
5824 if (handle != INVALID_HANDLE_VALUE)
5825 {
5826 CloseHandle(handle);
5827 break;
5828 }
5829 if (GetLastError() != ERROR_FILE_EXISTS &&
5830 GetLastError() != ERROR_SHARING_VIOLATION)
5831 break;
5832 if (!(++num & 0xffff)) num = 1;
5833 sprintfW(packagefile,fmt,num);
5834 } while (num != start);
5835
5836 snprintfW(path,sizeof(path)/sizeof(path[0]),installerPathFmt,windir);
5837 create_full_pathW(path);
5838 TRACE("Copying to local package %s\n",debugstr_w(packagefile));
5839 if (!CopyFileW(package->PackagePath,packagefile,FALSE))
5840 ERR("Unable to copy package (%s -> %s) (error %ld)\n",
5841 debugstr_w(package->PackagePath), debugstr_w(packagefile),
5842 GetLastError());
5843 size = strlenW(packagefile)*sizeof(WCHAR);
5844 RegSetValueExW(hkey,szLocalPackage,0,REG_SZ,(LPSTR)packagefile,size);
5845
5846 end:
5847 HeapFree(GetProcessHeap(),0,productcode);
5848 RegCloseKey(hkey);
5849
5850 return ERROR_SUCCESS;
5851 }
5852
5853 static UINT ACTION_InstallExecute(MSIPACKAGE *package)
5854 {
5855 int i;
5856 if (!package)
5857 return ERROR_INVALID_HANDLE;
5858
5859 for (i = 0; i < package->DeferredActionCount; i++)
5860 {
5861 LPWSTR action;
5862 action = package->DeferredAction[i];
5863 ui_actionstart(package, action);
5864 TRACE("Executing Action (%s)\n",debugstr_w(action));
5865 ACTION_CustomAction(package,action,TRUE);
5866 HeapFree(GetProcessHeap(),0,package->DeferredAction[i]);
5867 }
5868 HeapFree(GetProcessHeap(),0,package->DeferredAction);
5869
5870 package->DeferredActionCount = 0;
5871 package->DeferredAction = NULL;
5872
5873 return ERROR_SUCCESS;
5874 }
5875
5876 static UINT ACTION_InstallFinalize(MSIPACKAGE *package)
5877 {
5878 int i;
5879 if (!package)
5880 return ERROR_INVALID_HANDLE;
5881
5882 /* first do the same as an InstallExecute */
5883 ACTION_InstallExecute(package);
5884
5885 /* then handle Commit Actions */
5886 for (i = 0; i < package->CommitActionCount; i++)
5887 {
5888 LPWSTR action;
5889 action = package->CommitAction[i];
5890 ui_actionstart(package, action);
5891 TRACE("Executing Commit Action (%s)\n",debugstr_w(action));
5892 ACTION_CustomAction(package,action,TRUE);
5893 HeapFree(GetProcessHeap(),0,package->CommitAction[i]);
5894 }
5895 HeapFree(GetProcessHeap(),0,package->CommitAction);
5896
5897 package->CommitActionCount = 0;
5898 package->CommitAction = NULL;
5899
5900 return ERROR_SUCCESS;
5901 }
5902
5903 static UINT ACTION_ForceReboot(MSIPACKAGE *package)
5904 {
5905 static const WCHAR RunOnce[] = {
5906 'S','o','f','t','w','a','r','e','\\',
5907 'M','i','c','r','o','s','o','f','t','\\',
5908 'W','i','n','d','o','w','s','\\',
5909 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
5910 'R','u','n','O','n','c','e',0};
5911 static const WCHAR InstallRunOnce[] = {
5912 'S','o','f','t','w','a','r','e','\\',
5913 'M','i','c','r','o','s','o','f','t','\\',
5914 'W','i','n','d','o','w','s','\\',
5915 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
5916 'I','n','s','t','a','l','l','e','r','\\',
5917 'R','u','n','O','n','c','e','E','n','t','r','i','e','s',0};
5918
5919 static const WCHAR msiexec_fmt[] = {
5920 '%','s',
5921 '\\','M','s','i','E','x','e','c','.','e','x','e',' ','/','@',' ',
5922 '\"','%','s','\"',0};
5923 static const WCHAR install_fmt[] = {
5924 '/','I',' ','\"','%','s','\"',' ',
5925 'A','F','T','E','R','R','E','B','O','O','T','=','1',' ',
5926 'R','U','N','O','N','C','E','E','N','T','R','Y','=','\"','%','s','\"',0};
5927 WCHAR buffer[256], sysdir[MAX_PATH];
5928 HKEY hkey,hukey;
5929 LPWSTR productcode;
5930 WCHAR squished_pc[100];
5931 INT rc;
5932 DWORD size;
5933 static const WCHAR szLUS[] = {
5934 'L','a','s','t','U','s','e','d','S','o','u','r','c','e',0};
5935 static const WCHAR szSourceList[] = {
5936 'S','o','u','r','c','e','L','i','s','t',0};
5937 static const WCHAR szPackageName[] = {
5938 'P','a','c','k','a','g','e','N','a','m','e',0};
5939
5940 if (!package)
5941 return ERROR_INVALID_HANDLE;
5942
5943 productcode = load_dynamic_property(package,szProductCode,&rc);
5944 if (!productcode)
5945 return rc;
5946
5947 squash_guid(productcode,squished_pc);
5948
5949 GetSystemDirectoryW(sysdir, sizeof(sysdir)/sizeof(sysdir[0]));
5950 RegCreateKeyW(HKEY_LOCAL_MACHINE,RunOnce,&hkey);
5951 snprintfW(buffer,sizeof(buffer)/sizeof(buffer[0]),msiexec_fmt,sysdir,
5952 squished_pc);
5953
5954 size = strlenW(buffer)*sizeof(WCHAR);
5955 RegSetValueExW(hkey,squished_pc,0,REG_SZ,(LPSTR)buffer,size);
5956 RegCloseKey(hkey);
5957
5958 TRACE("Reboot command %s\n",debugstr_w(buffer));
5959
5960 RegCreateKeyW(HKEY_LOCAL_MACHINE,InstallRunOnce,&hkey);
5961 sprintfW(buffer,install_fmt,productcode,squished_pc);
5962
5963 size = strlenW(buffer)*sizeof(WCHAR);
5964 RegSetValueExW(hkey,squished_pc,0,REG_SZ,(LPSTR)buffer,size);
5965 RegCloseKey(hkey);
5966
5967 rc = MSIREG_OpenUserProductsKey(productcode,&hukey,TRUE);
5968 if (rc == ERROR_SUCCESS)
5969 {
5970 HKEY hukey2;
5971 LPWSTR buf;
5972 RegCreateKeyW(hukey, szSourceList, &hukey2);
5973 buf = load_dynamic_property(package,cszSourceDir,NULL);
5974 size = strlenW(buf)*sizeof(WCHAR);
5975 RegSetValueExW(hukey2,szLUS,0,REG_SZ,(LPSTR)buf,size);
5976 HeapFree(GetProcessHeap(),0,buf);
5977
5978 buf = strrchrW(package->PackagePath,'\\');
5979 if (buf)
5980 {
5981 buf++;
5982 size = strlenW(buf)*sizeof(WCHAR);
5983 RegSetValueExW(hukey2,szPackageName,0,REG_SZ,(LPSTR)buf,size);
5984 }
5985
5986 RegCloseKey(hukey2);
5987 }
5988 HeapFree(GetProcessHeap(),0,productcode);
5989
5990 return ERROR_INSTALL_SUSPEND;
5991 }
5992
5993 UINT ACTION_ResolveSource(MSIPACKAGE* package)
5994 {
5995 /*
5996 * we are currently doing what should be done here in the top level Install
5997 * however for Adminastrative and uninstalls this step will be needed
5998 */
5999 return ERROR_SUCCESS;
6000 }
6001
6002
6003 static UINT ACTION_RegisterExtensionInfo(MSIPACKAGE *package)
6004 {
6005 UINT rc;
6006 MSIQUERY * view;
6007 MSIRECORD * row = 0;
6008 static const WCHAR ExecSeqQuery[] =
6009 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6010 '`','E','x','t','e','n','s','i','o','n','`',0};
6011 static const WCHAR szContentType[] =
6012 {'C','o','n','t','e','n','t',' ','T','y','p','e',0 };
6013 HKEY hkey;
6014
6015 if (!package)
6016 return ERROR_INVALID_HANDLE;
6017
6018 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
6019 if (rc != ERROR_SUCCESS)
6020 {
6021 rc = ERROR_SUCCESS;
6022 goto end;
6023 }
6024
6025 rc = MSI_ViewExecute(view, 0);
6026 if (rc != ERROR_SUCCESS)
6027 {
6028 MSI_ViewClose(view);
6029 msiobj_release(&view->hdr);
6030 goto end;
6031 }
6032
6033 while (1)
6034 {
6035 WCHAR buffer[0x100];
6036 WCHAR extension[257];
6037 LPWSTR exten;
6038 DWORD sz;
6039 INT index;
6040
6041 rc = MSI_ViewFetch(view,&row);
6042 if (rc != ERROR_SUCCESS)
6043 {
6044 rc = ERROR_SUCCESS;
6045 break;
6046 }
6047
6048 sz=0x100;
6049 MSI_RecordGetStringW(row,2,buffer,&sz);
6050
6051 index = get_loaded_component(package,buffer);
6052
6053 if (index < 0)
6054 {
6055 msiobj_release(&row->hdr);
6056 continue;
6057 }
6058
6059 if ((!ACTION_VerifyComponentForAction(package, index,
6060 INSTALLSTATE_LOCAL)) &&
6061 (!ACTION_VerifyComponentForAction(package, index,
6062 INSTALLSTATE_ADVERTISED)))
6063 {
6064 TRACE("Skipping extension reg due to disabled component\n");
6065 msiobj_release(&row->hdr);
6066
6067 package->components[index].Action =
6068 package->components[index].Installed;
6069
6070 continue;
6071 }
6072
6073 package->components[index].Action = INSTALLSTATE_LOCAL;
6074
6075 exten = load_dynamic_stringW(row,1);
6076 extension[0] = '.';
6077 extension[1] = 0;
6078 strcatW(extension,exten);
6079 HeapFree(GetProcessHeap(),0,exten);
6080
6081 RegCreateKeyW(HKEY_CLASSES_ROOT,extension,&hkey);
6082
6083 if (!MSI_RecordIsNull(row,4))
6084 {
6085 LPWSTR mime = load_dynamic_stringW(row,4);
6086 RegSetValueExW(hkey,szContentType,0,REG_SZ,(LPVOID)mime,
6087 (strlenW(mime)+1)*sizeof(WCHAR));
6088 HeapFree(GetProcessHeap(),0,mime);
6089 }
6090
6091 if (!MSI_RecordIsNull(row,3))
6092 {
6093 static const WCHAR szSN[] =
6094 {'\\','S','h','e','l','l','N','e','w',0};
6095 HKEY hkey2;
6096 LPWSTR newkey;
6097 LPWSTR progid= load_dynamic_stringW(row,3);
6098
6099 RegSetValueExW(hkey,NULL,0,REG_SZ,(LPVOID)progid,
6100 (strlenW(progid)+1)*sizeof(WCHAR));
6101
6102 newkey = HeapAlloc(GetProcessHeap(),0,
6103 (strlenW(progid)+strlenW(szSN)+1) * sizeof(WCHAR));
6104
6105 strcpyW(newkey,progid);
6106 strcatW(newkey,szSN);
6107 RegCreateKeyW(hkey,newkey,&hkey2);
6108 RegCloseKey(hkey2);
6109
6110 HeapFree(GetProcessHeap(),0,progid);
6111 HeapFree(GetProcessHeap(),0,newkey);
6112 }
6113
6114
6115 RegCloseKey(hkey);
6116
6117 ui_actiondata(package,szRegisterExtensionInfo,row);
6118
6119 msiobj_release(&row->hdr);
6120 }
6121 MSI_ViewClose(view);
6122 msiobj_release(&view->hdr);
6123
6124 end:
6125 return rc;
6126 }
6127
6128 static UINT ACTION_RegisterMIMEInfo(MSIPACKAGE *package)
6129 {
6130 UINT rc;
6131 MSIQUERY * view;
6132 MSIRECORD * row = 0;
6133 static const WCHAR ExecSeqQuery[] =
6134 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6135 '`','M','I','M','E','`',0};
6136 static const WCHAR szExten[] =
6137 {'E','x','t','e','n','s','i','o','n',0 };
6138 HKEY hkey;
6139
6140 if (!package)
6141 return ERROR_INVALID_HANDLE;
6142
6143 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
6144 if (rc != ERROR_SUCCESS)
6145 {
6146 rc = ERROR_SUCCESS;
6147 goto end;
6148 }
6149
6150 rc = MSI_ViewExecute(view, 0);
6151 if (rc != ERROR_SUCCESS)
6152 {
6153 MSI_ViewClose(view);
6154 msiobj_release(&view->hdr);
6155 goto end;
6156 }
6157
6158 while (1)
6159 {
6160 WCHAR extension[257];
6161 LPWSTR exten;
6162 LPWSTR mime;
6163 static const WCHAR fmt[] =
6164 {'M','I','M','E','\\','D','a','t','a','b','a','s','e','\\',
6165 'C','o','n','t','e','n','t',' ','T','y','p','e','\\', '%','s',0};
6166 LPWSTR key;
6167
6168 rc = MSI_ViewFetch(view,&row);
6169 if (rc != ERROR_SUCCESS)
6170 {
6171 rc = ERROR_SUCCESS;
6172 break;
6173 }
6174
6175 mime = load_dynamic_stringW(row,1);
6176 exten = load_dynamic_stringW(row,2);
6177 extension[0] = '.';
6178 extension[1] = 0;
6179 strcatW(extension,exten);
6180 HeapFree(GetProcessHeap(),0,exten);
6181
6182 key = HeapAlloc(GetProcessHeap(),0,(strlenW(mime)+strlenW(fmt)+1) *
6183 sizeof(WCHAR));
6184 sprintfW(key,fmt,mime);
6185 RegCreateKeyW(HKEY_CLASSES_ROOT,key,&hkey);
6186 RegSetValueExW(hkey,szExten,0,REG_SZ,(LPVOID)extension,
6187 (strlenW(extension)+1)*sizeof(WCHAR));
6188
6189 HeapFree(GetProcessHeap(),0,mime);
6190 HeapFree(GetProcessHeap(),0,key);
6191
6192 if (!MSI_RecordIsNull(row,3))
6193 {
6194 FIXME("Handle non null for field 3\n");
6195 }
6196
6197 RegCloseKey(hkey);
6198
6199 ui_actiondata(package,szRegisterMIMEInfo,row);
6200
6201 msiobj_release(&row->hdr);
6202 }
6203 MSI_ViewClose(view);
6204 msiobj_release(&view->hdr);
6205
6206 end:
6207 return rc;
6208 }
6209
6210 static UINT ACTION_RegisterUser(MSIPACKAGE *package)
6211 {
6212 static const WCHAR szProductID[]=
6213 {'P','r','o','d','u','c','t','I','D',0};
6214 HKEY hkey=0;
6215 LPWSTR buffer;
6216 LPWSTR productcode;
6217 LPWSTR productid;
6218 UINT rc,i;
6219 DWORD size;
6220
6221 static const WCHAR szPropKeys[][80] =
6222 {
6223 {'P','r','o','d','u','c','t','I','D',0},
6224 {'U','S','E','R','N','A','M','E',0},
6225 {'C','O','M','P','A','N','Y','N','A','M','E',0},
6226 {0},
6227 };
6228
6229 static const WCHAR szRegKeys[][80] =
6230 {
6231 {'P','r','o','d','u','c','t','I','D',0},
6232 {'R','e','g','O','w','n','e','r',0},
6233 {'R','e','g','C','o','m','p','a','n','y',0},
6234 {0},
6235 };
6236
6237 if (!package)
6238 return ERROR_INVALID_HANDLE;
6239
6240 productid = load_dynamic_property(package,szProductID,&rc);
6241 if (!productid)
6242 return ERROR_SUCCESS;
6243
6244 productcode = load_dynamic_property(package,szProductCode,&rc);
6245 if (!productcode)
6246 return rc;
6247
6248 rc = MSIREG_OpenUninstallKey(productcode,&hkey,TRUE);
6249 if (rc != ERROR_SUCCESS)
6250 goto end;
6251
6252 i = 0;
6253 while (szPropKeys[i][0]!=0)
6254 {
6255 buffer = load_dynamic_property(package,szPropKeys[i],&rc);
6256 if (rc == ERROR_SUCCESS)
6257 {
6258 size = strlenW(buffer)*sizeof(WCHAR);
6259 RegSetValueExW(hkey,szRegKeys[i],0,REG_SZ,(LPSTR)buffer,size);
6260 }
6261 else
6262 RegSetValueExW(hkey,szRegKeys[i],0,REG_SZ,NULL,0);
6263 i++;
6264 }
6265
6266 end:
6267 HeapFree(GetProcessHeap(),0,productcode);
6268 HeapFree(GetProcessHeap(),0,productid);
6269 RegCloseKey(hkey);
6270
6271 return ERROR_SUCCESS;
6272 }
6273
6274
6275 static UINT ACTION_ExecuteAction(MSIPACKAGE *package)
6276 {
6277 UINT rc;
6278 rc = ACTION_ProcessExecSequence(package,FALSE);
6279 return rc;
6280 }
6281
6282
6283 /*
6284 * Code based off of code located here
6285 * http://www.codeproject.com/gdi/fontnamefromfile.asp
6286 *
6287 * Using string index 4 (full font name) instead of 1 (family name)
6288 */
6289 static LPWSTR load_ttfname_from(LPCWSTR filename)
6290 {
6291 HANDLE handle;
6292 LPWSTR ret = NULL;
6293 int i;
6294
6295 typedef struct _tagTT_OFFSET_TABLE{
6296 USHORT uMajorVersion;
6297 USHORT uMinorVersion;
6298 USHORT uNumOfTables;
6299 USHORT uSearchRange;
6300 USHORT uEntrySelector;
6301 USHORT uRangeShift;
6302 }TT_OFFSET_TABLE;
6303
6304 typedef struct _tagTT_TABLE_DIRECTORY{
6305 char szTag[4]; /* table name */
6306 ULONG uCheckSum; /* Check sum */
6307 ULONG uOffset; /* Offset from beginning of file */
6308 ULONG uLength; /* length of the table in bytes */
6309 }TT_TABLE_DIRECTORY;
6310
6311 typedef struct _tagTT_NAME_TABLE_HEADER{
6312 USHORT uFSelector; /* format selector. Always 0 */
6313 USHORT uNRCount; /* Name Records count */
6314 USHORT uStorageOffset; /* Offset for strings storage,
6315 * from start of the table */
6316 }TT_NAME_TABLE_HEADER;
6317
6318 typedef struct _tagTT_NAME_RECORD{
6319 USHORT uPlatformID;
6320 USHORT uEncodingID;
6321 USHORT uLanguageID;
6322 USHORT uNameID;
6323 USHORT uStringLength;
6324 USHORT uStringOffset; /* from start of storage area */
6325 }TT_NAME_RECORD;
6326
6327 #define SWAPWORD(x) MAKEWORD(HIBYTE(x), LOBYTE(x))
6328 #define SWAPLONG(x) MAKELONG(SWAPWORD(HIWORD(x)), SWAPWORD(LOWORD(x)))
6329
6330 handle = CreateFileW(filename ,GENERIC_READ, 0, NULL, OPEN_EXISTING,
6331 FILE_ATTRIBUTE_NORMAL, 0 );
6332 if (handle != INVALID_HANDLE_VALUE)
6333 {
6334 TT_TABLE_DIRECTORY tblDir;
6335 BOOL bFound = FALSE;
6336 TT_OFFSET_TABLE ttOffsetTable;
6337
6338 ReadFile(handle,&ttOffsetTable, sizeof(TT_OFFSET_TABLE),NULL,NULL);
6339 ttOffsetTable.uNumOfTables = SWAPWORD(ttOffsetTable.uNumOfTables);
6340 ttOffsetTable.uMajorVersion = SWAPWORD(ttOffsetTable.uMajorVersion);
6341 ttOffsetTable.uMinorVersion = SWAPWORD(ttOffsetTable.uMinorVersion);
6342
6343 if (ttOffsetTable.uMajorVersion != 1 ||
6344 ttOffsetTable.uMinorVersion != 0)
6345 return NULL;
6346
6347 for (i=0; i< ttOffsetTable.uNumOfTables; i++)
6348 {
6349 ReadFile(handle,&tblDir, sizeof(TT_TABLE_DIRECTORY),NULL,NULL);
6350 if (strncmp(tblDir.szTag,"name",4)==0)
6351 {
6352 bFound = TRUE;
6353 tblDir.uLength = SWAPLONG(tblDir.uLength);
6354 tblDir.uOffset = SWAPLONG(tblDir.uOffset);
6355 break;
6356 }
6357 }
6358
6359 if (bFound)
6360 {
6361 TT_NAME_TABLE_HEADER ttNTHeader;
6362 TT_NAME_RECORD ttRecord;
6363
6364 SetFilePointer(handle, tblDir.uOffset, NULL, FILE_BEGIN);
6365 ReadFile(handle,&ttNTHeader, sizeof(TT_NAME_TABLE_HEADER),
6366 NULL,NULL);
6367
6368 ttNTHeader.uNRCount = SWAPWORD(ttNTHeader.uNRCount);
6369 ttNTHeader.uStorageOffset = SWAPWORD(ttNTHeader.uStorageOffset);
6370 bFound = FALSE;
6371 for(i=0; i<ttNTHeader.uNRCount; i++)
6372 {
6373 ReadFile(handle,&ttRecord, sizeof(TT_NAME_RECORD),NULL,NULL);
6374 ttRecord.uNameID = SWAPWORD(ttRecord.uNameID);
6375 /* 4 is the Full Font Name */
6376 if(ttRecord.uNameID == 4)
6377 {
6378 int nPos;
6379 LPSTR buf;
6380 static const LPSTR tt = " (TrueType)";
6381
6382 ttRecord.uStringLength = SWAPWORD(ttRecord.uStringLength);
6383 ttRecord.uStringOffset = SWAPWORD(ttRecord.uStringOffset);
6384 nPos = SetFilePointer(handle, 0, NULL, FILE_CURRENT);
6385 SetFilePointer(handle, tblDir.uOffset +
6386 ttRecord.uStringOffset +
6387 ttNTHeader.uStorageOffset,
6388 NULL, FILE_BEGIN);
6389 buf = HeapAlloc(GetProcessHeap(), 0,
6390 ttRecord.uStringLength + 1 + strlen(tt));
6391 memset(buf, 0, ttRecord.uStringLength + 1 + strlen(tt));
6392 ReadFile(handle, buf, ttRecord.uStringLength, NULL, NULL);
6393 if (strlen(buf) > 0)
6394 {
6395 strcat(buf,tt);
6396 ret = strdupAtoW(buf);
6397 HeapFree(GetProcessHeap(),0,buf);
6398 break;
6399 }
6400
6401 HeapFree(GetProcessHeap(),0,buf);
6402 SetFilePointer(handle,nPos, NULL, FILE_BEGIN);
6403 }
6404 }
6405 }
6406 CloseHandle(handle);
6407 }
6408 else
6409 ERR("Unable to open font file %s\n", debugstr_w(filename));
6410
6411 TRACE("Returning fontname %s\n",debugstr_w(ret));
6412 return ret;
6413 }
6414
6415 static UINT ACTION_RegisterFonts(MSIPACKAGE *package)
6416 {
6417 UINT rc;
6418 MSIQUERY * view;
6419 MSIRECORD * row = 0;
6420 static const WCHAR ExecSeqQuery[] =
6421 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6422 '`','F','o','n','t','`',0};
6423 static const WCHAR regfont1[] =
6424 {'S','o','f','t','w','a','r','e','\\',
6425 'M','i','c','r','o','s','o','f','t','\\',
6426 'W','i','n','d','o','w','s',' ','N','T','\\',
6427 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
6428 'F','o','n','t','s',0};
6429 static const WCHAR regfont2[] =
6430 {'S','o','f','t','w','a','r','e','\\',
6431 'M','i','c','r','o','s','o','f','t','\\',
6432 'W','i','n','d','o','w','s','\\',
6433 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
6434 'F','o','n','t','s',0};
6435 HKEY hkey1;
6436 HKEY hkey2;
6437
6438 TRACE("%p\n", package);
6439
6440 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
6441 if (rc != ERROR_SUCCESS)
6442 {
6443 TRACE("MSI_DatabaseOpenViewW failed: %d\n", rc);
6444 return ERROR_SUCCESS;
6445 }
6446
6447 rc = MSI_ViewExecute(view, 0);
6448 if (rc != ERROR_SUCCESS)
6449 {
6450 MSI_ViewClose(view);
6451 msiobj_release(&view->hdr);
6452 TRACE("MSI_ViewExecute returned %d\n", rc);
6453 return ERROR_SUCCESS;
6454 }
6455
6456 RegCreateKeyW(HKEY_LOCAL_MACHINE,regfont1,&hkey1);
6457 RegCreateKeyW(HKEY_LOCAL_MACHINE,regfont2,&hkey2);
6458
6459 while (1)
6460 {
6461 LPWSTR name;
6462 LPWSTR file;
6463 UINT index;
6464 DWORD size;
6465
6466 rc = MSI_ViewFetch(view,&row);
6467 if (rc != ERROR_SUCCESS)
6468 {
6469 rc = ERROR_SUCCESS;
6470 break;
6471 }
6472
6473 file = load_dynamic_stringW(row,1);
6474 index = get_loaded_file(package,file);
6475 if (index < 0)
6476 {
6477 ERR("Unable to load file\n");
6478 HeapFree(GetProcessHeap(),0,file);
6479 continue;
6480 }
6481
6482 /* check to make sure that component is installed */
6483 if (!ACTION_VerifyComponentForAction(package,
6484 package->files[index].ComponentIndex, INSTALLSTATE_LOCAL))
6485 {
6486 TRACE("Skipping: Component not scheduled for install\n");
6487 HeapFree(GetProcessHeap(),0,file);
6488
6489 msiobj_release(&row->hdr);
6490
6491 continue;
6492 }
6493
6494 if (MSI_RecordIsNull(row,2))
6495 name = load_ttfname_from(package->files[index].TargetPath);
6496 else
6497 name = load_dynamic_stringW(row,2);
6498
6499 if (name)
6500 {
6501 size = strlenW(package->files[index].FileName) * sizeof(WCHAR);
6502 RegSetValueExW(hkey1,name,0,REG_SZ,
6503 (LPBYTE)package->files[index].FileName,size);
6504 RegSetValueExW(hkey2,name,0,REG_SZ,
6505 (LPBYTE)package->files[index].FileName,size);
6506 }
6507
6508 HeapFree(GetProcessHeap(),0,file);
6509 HeapFree(GetProcessHeap(),0,name);
6510 msiobj_release(&row->hdr);
6511 }
6512 MSI_ViewClose(view);
6513 msiobj_release(&view->hdr);
6514
6515 RegCloseKey(hkey1);
6516 RegCloseKey(hkey2);
6517
6518 TRACE("returning %d\n", rc);
6519 return rc;
6520 }
6521
6522 static UINT ITERATE_PublishComponent(MSIRECORD *rec, LPVOID param)
6523 {
6524 MSIPACKAGE *package = (MSIPACKAGE*)param;
6525 LPWSTR productid=NULL, compgroupid=NULL;
6526 LPWSTR feature=NULL;
6527 LPWSTR text = NULL;
6528 LPWSTR qualifier = NULL;
6529 LPWSTR component = NULL;
6530 GUID clsid;
6531 WCHAR productid_85[21];
6532 WCHAR component_85[21];
6533 HKEY hkey;
6534 UINT rc = ERROR_SUCCESS;
6535 UINT index;
6536 /*
6537 * I have a fair bit of confusion as to when a < is used and when a > is
6538 * used. I do not think i have it right...
6539 *
6540 * Ok it appears that the > is used if there is a guid for the compoenent
6541 * and the < is used if not.
6542 */
6543 static WCHAR fmt1[] = {'%','s','%','s','<',0,0};
6544 static WCHAR fmt2[] = {'%','s','%','s','>','%','s',0,0};
6545 LPWSTR output = NULL;
6546 DWORD sz = 0;
6547 INT component_index;
6548
6549 component = load_dynamic_stringW(rec,3);
6550 component_index = get_loaded_component(package,component);
6551
6552 if (!ACTION_VerifyComponentForAction(package, component_index,
6553 INSTALLSTATE_LOCAL) &&
6554 !ACTION_VerifyComponentForAction(package, component_index,
6555 INSTALLSTATE_SOURCE) &&
6556 !ACTION_VerifyComponentForAction(package, component_index,
6557 INSTALLSTATE_ADVERTISED))
6558 {
6559 TRACE("Skipping: Component %s not scheduled for install\n",
6560 debugstr_w(component));
6561 HeapFree(GetProcessHeap(),0,component);
6562 return ERROR_SUCCESS;
6563 }
6564
6565 memset(productid_85,0,sizeof(productid_85));
6566 memset(component_85,0,sizeof(component_85));
6567 compgroupid = load_dynamic_stringW(rec,1);
6568
6569 rc = MSIREG_OpenUserComponentsKey(compgroupid, &hkey, TRUE);
6570 if (rc != ERROR_SUCCESS)
6571 goto end;
6572
6573 productid = load_dynamic_property(package,szProductCode,NULL);
6574 CLSIDFromString(productid, &clsid);
6575
6576 encode_base85_guid(&clsid,productid_85);
6577
6578 text = load_dynamic_stringW(rec,4);
6579 qualifier = load_dynamic_stringW(rec,2);
6580
6581 feature = load_dynamic_stringW(rec,5);
6582
6583 index = get_loaded_component(package, component);
6584 CLSIDFromString(package->components[index].ComponentId, &clsid);
6585 encode_base85_guid(&clsid,component_85);
6586
6587 TRACE("Doing something with this... %s = %s %s %s %s\n",
6588 debugstr_w(qualifier), debugstr_w(productid_85),
6589 debugstr_w(feature), debugstr_w(text), debugstr_w(component_85));
6590
6591 sz = lstrlenW(productid_85) + lstrlenW(feature);
6592 if (text)
6593 sz += lstrlenW(text);
6594 if (component && index >= 0)
6595 sz += lstrlenW(component_85);
6596
6597 sz+=3;
6598 sz *= sizeof(WCHAR);
6599
6600 output = HeapAlloc(GetProcessHeap(),0,sz);
6601 memset(output,0,sz);
6602
6603 if (component && index >= 0)
6604 sprintfW(output,fmt2,productid_85,feature,component_85);
6605 else
6606 sprintfW(output,fmt1,productid_85,feature);
6607
6608 if (text)
6609 strcatW(output,text);
6610
6611 sz = (lstrlenW(output)+2) * sizeof(WCHAR);
6612 RegSetValueExW(hkey, qualifier,0,REG_MULTI_SZ, (LPBYTE)output, sz);
6613
6614 end:
6615 RegCloseKey(hkey);
6616 HeapFree(GetProcessHeap(),0,output);
6617 HeapFree(GetProcessHeap(),0,compgroupid);
6618 HeapFree(GetProcessHeap(),0,component);
6619 HeapFree(GetProcessHeap(),0,productid);
6620 HeapFree(GetProcessHeap(),0,feature);
6621 HeapFree(GetProcessHeap(),0,text);
6622 HeapFree(GetProcessHeap(),0,qualifier);
6623
6624 return rc;
6625 }
6626
6627 /*
6628 * At present I am ignorning the advertised components part of this and only
6629 * focusing on the qualified component sets
6630 */
6631 static UINT ACTION_PublishComponents(MSIPACKAGE *package)
6632 {
6633 UINT rc;
6634 MSIQUERY * view;
6635 static const WCHAR ExecSeqQuery[] =
6636 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6637 '`','P','u','b','l','i','s','h',
6638 'C','o','m','p','o','n','e','n','t','`',0};
6639
6640 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
6641 if (rc != ERROR_SUCCESS)
6642 return ERROR_SUCCESS;
6643
6644 rc = MSI_IterateRecords(view, NULL, ITERATE_PublishComponent, package);
6645 msiobj_release(&view->hdr);
6646
6647 return rc;
6648 }
6649
6650 /* Msi functions that seem appropriate here */
6651
6652 /***********************************************************************
6653 * MsiDoActionA (MSI.@)
6654 */
6655 UINT WINAPI MsiDoActionA( MSIHANDLE hInstall, LPCSTR szAction )
6656 {
6657 LPWSTR szwAction;
6658 UINT rc;
6659
6660 TRACE(" exteral attempt at action %s\n",szAction);
6661
6662 if (!szAction)
6663 return ERROR_FUNCTION_FAILED;
6664 if (hInstall == 0)
6665 return ERROR_FUNCTION_FAILED;
6666
6667 szwAction = strdupAtoW(szAction);
6668
6669 if (!szwAction)
6670 return ERROR_FUNCTION_FAILED;
6671
6672
6673 rc = MsiDoActionW(hInstall, szwAction);
6674 HeapFree(GetProcessHeap(),0,szwAction);
6675 return rc;
6676 }
6677
6678 /***********************************************************************
6679 * MsiDoActionW (MSI.@)
6680 */
6681 UINT WINAPI MsiDoActionW( MSIHANDLE hInstall, LPCWSTR szAction )
6682 {
6683 MSIPACKAGE *package;
6684 UINT ret = ERROR_INVALID_HANDLE;
6685
6686 TRACE(" external attempt at action %s \n",debugstr_w(szAction));
6687
6688 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
6689 if( package )
6690 {
6691 ret = ACTION_PerformUIAction(package,szAction);
6692 msiobj_release( &package->hdr );
6693 }
6694 return ret;
6695 }
6696
6697 UINT WINAPI MsiGetTargetPathA( MSIHANDLE hInstall, LPCSTR szFolder,
6698 LPSTR szPathBuf, DWORD* pcchPathBuf)
6699 {
6700 LPWSTR szwFolder;
6701 LPWSTR szwPathBuf;
6702 UINT rc;
6703
6704 TRACE("getting folder %s %p %li\n",szFolder,szPathBuf, *pcchPathBuf);
6705
6706 if (!szFolder)
6707 return ERROR_FUNCTION_FAILED;
6708 if (hInstall == 0)
6709 return ERROR_FUNCTION_FAILED;
6710
6711 szwFolder = strdupAtoW(szFolder);
6712
6713 if (!szwFolder)
6714 return ERROR_FUNCTION_FAILED;
6715
6716 szwPathBuf = HeapAlloc( GetProcessHeap(), 0 , *pcchPathBuf * sizeof(WCHAR));
6717
6718 rc = MsiGetTargetPathW(hInstall, szwFolder, szwPathBuf,pcchPathBuf);
6719
6720 WideCharToMultiByte( CP_ACP, 0, szwPathBuf, *pcchPathBuf, szPathBuf,
6721 *pcchPathBuf, NULL, NULL );
6722
6723 HeapFree(GetProcessHeap(),0,szwFolder);
6724 HeapFree(GetProcessHeap(),0,szwPathBuf);
6725
6726 return rc;
6727 }
6728
6729 UINT WINAPI MsiGetTargetPathW( MSIHANDLE hInstall, LPCWSTR szFolder, LPWSTR
6730 szPathBuf, DWORD* pcchPathBuf)
6731 {
6732 LPWSTR path;
6733 UINT rc = ERROR_FUNCTION_FAILED;
6734 MSIPACKAGE *package;
6735
6736 TRACE("(%s %p %li)\n",debugstr_w(szFolder),szPathBuf,*pcchPathBuf);
6737
6738 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
6739 if (!package)
6740 return ERROR_INVALID_HANDLE;
6741 path = resolve_folder(package, szFolder, FALSE, FALSE, NULL);
6742 msiobj_release( &package->hdr );
6743
6744 if (path && (strlenW(path) > *pcchPathBuf))
6745 {
6746 *pcchPathBuf = strlenW(path)+1;
6747 rc = ERROR_MORE_DATA;
6748 }
6749 else if (path)
6750 {
6751 *pcchPathBuf = strlenW(path)+1;
6752 strcpyW(szPathBuf,path);
6753 TRACE("Returning Path %s\n",debugstr_w(path));
6754 rc = ERROR_SUCCESS;
6755 }
6756 HeapFree(GetProcessHeap(),0,path);
6757
6758 return rc;
6759 }
6760
6761
6762 UINT WINAPI MsiGetSourcePathA( MSIHANDLE hInstall, LPCSTR szFolder,
6763 LPSTR szPathBuf, DWORD* pcchPathBuf)
6764 {
6765 LPWSTR szwFolder;
6766 LPWSTR szwPathBuf;
6767 UINT rc;
6768
6769 TRACE("getting source %s %p %li\n",szFolder,szPathBuf, *pcchPathBuf);
6770
6771 if (!szFolder)
6772 return ERROR_FUNCTION_FAILED;
6773 if (hInstall == 0)
6774 return ERROR_FUNCTION_FAILED;
6775
6776 szwFolder = strdupAtoW(szFolder);
6777 if (!szwFolder)
6778 return ERROR_FUNCTION_FAILED;
6779
6780 szwPathBuf = HeapAlloc( GetProcessHeap(), 0 , *pcchPathBuf * sizeof(WCHAR));
6781
6782 rc = MsiGetSourcePathW(hInstall, szwFolder, szwPathBuf,pcchPathBuf);
6783
6784 WideCharToMultiByte( CP_ACP, 0, szwPathBuf, *pcchPathBuf, szPathBuf,
6785 *pcchPathBuf, NULL, NULL );
6786
6787 HeapFree(GetProcessHeap(),0,szwFolder);
6788 HeapFree(GetProcessHeap(),0,szwPathBuf);
6789
6790 return rc;
6791 }
6792
6793 UINT WINAPI MsiGetSourcePathW( MSIHANDLE hInstall, LPCWSTR szFolder, LPWSTR
6794 szPathBuf, DWORD* pcchPathBuf)
6795 {
6796 LPWSTR path;
6797 UINT rc = ERROR_FUNCTION_FAILED;
6798 MSIPACKAGE *package;
6799
6800 TRACE("(%s %p %li)\n",debugstr_w(szFolder),szPathBuf,*pcchPathBuf);
6801
6802 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
6803 if( !package )
6804 return ERROR_INVALID_HANDLE;
6805 path = resolve_folder(package, szFolder, TRUE, FALSE, NULL);
6806 msiobj_release( &package->hdr );
6807
6808 if (path && strlenW(path) > *pcchPathBuf)
6809 {
6810 *pcchPathBuf = strlenW(path)+1;
6811 rc = ERROR_MORE_DATA;
6812 }
6813 else if (path)
6814 {
6815 *pcchPathBuf = strlenW(path)+1;
6816 strcpyW(szPathBuf,path);
6817 TRACE("Returning Path %s\n",debugstr_w(path));
6818 rc = ERROR_SUCCESS;
6819 }
6820 HeapFree(GetProcessHeap(),0,path);
6821
6822 return rc;
6823 }
6824
6825
6826 /***********************************************************************
6827 * MsiSetTargetPathA (MSI.@)
6828 */
6829 UINT WINAPI MsiSetTargetPathA(MSIHANDLE hInstall, LPCSTR szFolder,
6830 LPCSTR szFolderPath)
6831 {
6832 LPWSTR szwFolder;
6833 LPWSTR szwFolderPath;
6834 UINT rc;
6835
6836 if (!szFolder)
6837 return ERROR_FUNCTION_FAILED;
6838 if (hInstall == 0)
6839 return ERROR_FUNCTION_FAILED;
6840
6841 szwFolder = strdupAtoW(szFolder);
6842 if (!szwFolder)
6843 return ERROR_FUNCTION_FAILED;
6844
6845 szwFolderPath = strdupAtoW(szFolderPath);
6846 if (!szwFolderPath)
6847 {
6848 HeapFree(GetProcessHeap(),0,szwFolder);
6849 return ERROR_FUNCTION_FAILED;
6850 }
6851
6852 rc = MsiSetTargetPathW(hInstall, szwFolder, szwFolderPath);
6853
6854 HeapFree(GetProcessHeap(),0,szwFolder);
6855 HeapFree(GetProcessHeap(),0,szwFolderPath);
6856
6857 return rc;
6858 }
6859
6860 UINT MSI_SetTargetPathW(MSIPACKAGE *package, LPCWSTR szFolder,
6861 LPCWSTR szFolderPath)
6862 {
6863 DWORD i;
6864 LPWSTR path = NULL;
6865 LPWSTR path2 = NULL;
6866 MSIFOLDER *folder;
6867
6868 TRACE("(%p %s %s)\n",package, debugstr_w(szFolder),debugstr_w(szFolderPath));
6869
6870 if (package==NULL)
6871 return ERROR_INVALID_HANDLE;
6872
6873 if (szFolderPath[0]==0)
6874 return ERROR_FUNCTION_FAILED;
6875
6876 if (GetFileAttributesW(szFolderPath) == INVALID_FILE_ATTRIBUTES)
6877 return ERROR_FUNCTION_FAILED;
6878
6879 path = resolve_folder(package,szFolder,FALSE,FALSE,&folder);
6880
6881 if (!path)
6882 return ERROR_INVALID_PARAMETER;
6883
6884 HeapFree(GetProcessHeap(),0,folder->Property);
6885 folder->Property = build_directory_name(2, szFolderPath, NULL);
6886
6887 if (lstrcmpiW(path, folder->Property) == 0)
6888 {
6889 /*
6890 * Resolved Target has not really changed, so just
6891 * set this folder and do not recalculate everything.
6892 */
6893 HeapFree(GetProcessHeap(),0,folder->ResolvedTarget);
6894 folder->ResolvedTarget = NULL;
6895 path2 = resolve_folder(package,szFolder,FALSE,TRUE,NULL);
6896 HeapFree(GetProcessHeap(),0,path2);
6897 }
6898 else
6899 {
6900 for (i = 0; i < package->loaded_folders; i++)
6901 {
6902 HeapFree(GetProcessHeap(),0,package->folders[i].ResolvedTarget);
6903 package->folders[i].ResolvedTarget=NULL;
6904 }
6905
6906 for (i = 0; i < package->loaded_folders; i++)
6907 {
6908 path2=resolve_folder(package, package->folders[i].Directory, FALSE,
6909 TRUE, NULL);
6910 HeapFree(GetProcessHeap(),0,path2);
6911 }
6912 }
6913 HeapFree(GetProcessHeap(),0,path);
6914
6915 return ERROR_SUCCESS;
6916 }
6917
6918 /***********************************************************************
6919 * MsiSetTargetPathW (MSI.@)
6920 */
6921 UINT WINAPI MsiSetTargetPathW(MSIHANDLE hInstall, LPCWSTR szFolder,
6922 LPCWSTR szFolderPath)
6923 {
6924 MSIPACKAGE *package;
6925 UINT ret;
6926
6927 TRACE("(%s %s)\n",debugstr_w(szFolder),debugstr_w(szFolderPath));
6928
6929 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
6930 ret = MSI_SetTargetPathW( package, szFolder, szFolderPath );
6931 msiobj_release( &package->hdr );
6932 return ret;
6933 }
6934
6935 /***********************************************************************
6936 * MsiGetMode (MSI.@)
6937 *
6938 * Returns an internal installer state (if it is running in a mode iRunMode)
6939 *
6940 * PARAMS
6941 * hInstall [I] Handle to the installation
6942 * hRunMode [I] Checking run mode
6943 * MSIRUNMODE_ADMIN Administrative mode
6944 * MSIRUNMODE_ADVERTISE Advertisement mode
6945 * MSIRUNMODE_MAINTENANCE Maintenance mode
6946 * MSIRUNMODE_ROLLBACKENABLED Rollback is enabled
6947 * MSIRUNMODE_LOGENABLED Log file is writing
6948 * MSIRUNMODE_OPERATIONS Operations in progress??
6949 * MSIRUNMODE_REBOOTATEND We need to reboot after installation completed
6950 * MSIRUNMODE_REBOOTNOW We need to reboot to continue the installation
6951 * MSIRUNMODE_CABINET Files from cabinet are installed
6952 * MSIRUNMODE_SOURCESHORTNAMES Long names in source files is suppressed
6953 * MSIRUNMODE_TARGETSHORTNAMES Long names in destination files is suppressed
6954 * MSIRUNMODE_RESERVED11 Reserved
6955 * MSIRUNMODE_WINDOWS9X Running under Windows95/98
6956 * MSIRUNMODE_ZAWENABLED Demand installation is supported
6957 * MSIRUNMODE_RESERVED14 Reserved
6958 * MSIRUNMODE_RESERVED15 Reserved
6959 * MSIRUNMODE_SCHEDULED called from install script
6960 * MSIRUNMODE_ROLLBACK called from rollback script
6961 * MSIRUNMODE_COMMIT called from commit script
6962 *
6963 * RETURNS
6964 * In the state: TRUE
6965 * Not in the state: FALSE
6966 *
6967 */
6968
6969 BOOL WINAPI MsiGetMode(MSIHANDLE hInstall, MSIRUNMODE iRunMode)
6970 {
6971 FIXME("STUB (iRunMode=%i)\n",iRunMode);
6972 return TRUE;
6973 }
6974
6975 /***********************************************************************
6976 * MsiSetFeatureStateA (MSI.@)
6977 *
6978 * According to the docs, when this is called it immediately recalculates
6979 * all the component states as well
6980 */
6981 UINT WINAPI MsiSetFeatureStateA(MSIHANDLE hInstall, LPCSTR szFeature,
6982 INSTALLSTATE iState)
6983 {
6984 LPWSTR szwFeature = NULL;
6985 UINT rc;
6986
6987 szwFeature = strdupAtoW(szFeature);
6988
6989 if (!szwFeature)
6990 return ERROR_FUNCTION_FAILED;
6991
6992 rc = MsiSetFeatureStateW(hInstall,szwFeature, iState);
6993
6994 HeapFree(GetProcessHeap(),0,szwFeature);
6995
6996 return rc;
6997 }
6998
6999
7000
7001 UINT WINAPI MSI_SetFeatureStateW(MSIPACKAGE* package, LPCWSTR szFeature,
7002 INSTALLSTATE iState)
7003 {
7004 INT index, i;
7005 UINT rc = ERROR_SUCCESS;
7006
7007 TRACE(" %s to %i\n",debugstr_w(szFeature), iState);
7008
7009 index = get_loaded_feature(package,szFeature);
7010 if (index < 0)
7011 return ERROR_UNKNOWN_FEATURE;
7012
7013 package->features[index].ActionRequest= iState;
7014 package->features[index].Action= iState;
7015
7016 ACTION_UpdateComponentStates(package,szFeature);
7017
7018 /* update all the features that are children of this feature */
7019 for (i = 0; i < package->loaded_features; i++)
7020 {
7021 if (strcmpW(szFeature, package->features[i].Feature_Parent) == 0)
7022 MSI_SetFeatureStateW(package, package->features[i].Feature, iState);
7023 }
7024
7025 return rc;
7026 }
7027
7028 /***********************************************************************
7029 * MsiSetFeatureStateW (MSI.@)
7030 */
7031 UINT WINAPI MsiSetFeatureStateW(MSIHANDLE hInstall, LPCWSTR szFeature,
7032 INSTALLSTATE iState)
7033 {
7034 MSIPACKAGE* package;
7035 UINT rc = ERROR_SUCCESS;
7036
7037 TRACE(" %s to %i\n",debugstr_w(szFeature), iState);
7038
7039 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
7040 if (!package)
7041 return ERROR_INVALID_HANDLE;
7042
7043 rc = MSI_SetFeatureStateW(package,szFeature,iState);
7044
7045 msiobj_release( &package->hdr );
7046 return rc;
7047 }
7048
7049 UINT WINAPI MsiGetFeatureStateA(MSIHANDLE hInstall, LPSTR szFeature,
7050 INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
7051 {
7052 LPWSTR szwFeature = NULL;
7053 UINT rc;
7054
7055 szwFeature = strdupAtoW(szFeature);
7056
7057 rc = MsiGetFeatureStateW(hInstall,szwFeature,piInstalled, piAction);
7058
7059 HeapFree( GetProcessHeap(), 0 , szwFeature);
7060
7061 return rc;
7062 }
7063
7064 UINT MSI_GetFeatureStateW(MSIPACKAGE *package, LPWSTR szFeature,
7065 INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
7066 {
7067 INT index;
7068
7069 index = get_loaded_feature(package,szFeature);
7070 if (index < 0)
7071 return ERROR_UNKNOWN_FEATURE;
7072
7073 if (piInstalled)
7074 *piInstalled = package->features[index].Installed;
7075
7076 if (piAction)
7077 *piAction = package->features[index].Action;
7078
7079 TRACE("returning %i %i\n",*piInstalled,*piAction);
7080
7081 return ERROR_SUCCESS;
7082 }
7083
7084 UINT WINAPI MsiGetFeatureStateW(MSIHANDLE hInstall, LPWSTR szFeature,
7085 INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
7086 {
7087 MSIPACKAGE* package;
7088 UINT ret;
7089
7090 TRACE("%ld %s %p %p\n", hInstall, debugstr_w(szFeature), piInstalled,
7091 piAction);
7092
7093 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
7094 if (!package)
7095 return ERROR_INVALID_HANDLE;
7096 ret = MSI_GetFeatureStateW(package, szFeature, piInstalled, piAction);
7097 msiobj_release( &package->hdr );
7098 return ret;
7099 }
7100
7101 /***********************************************************************
7102 * MsiGetComponentStateA (MSI.@)
7103 */
7104 UINT WINAPI MsiGetComponentStateA(MSIHANDLE hInstall, LPSTR szComponent,
7105 INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
7106 {
7107 LPWSTR szwComponent= NULL;
7108 UINT rc;
7109
7110 szwComponent= strdupAtoW(szComponent);
7111
7112 rc = MsiGetComponentStateW(hInstall,szwComponent,piInstalled, piAction);
7113
7114 HeapFree( GetProcessHeap(), 0 , szwComponent);
7115
7116 return rc;
7117 }
7118
7119 UINT MSI_GetComponentStateW(MSIPACKAGE *package, LPWSTR szComponent,
7120 INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
7121 {
7122 INT index;
7123
7124 TRACE("%p %s %p %p\n", package, debugstr_w(szComponent), piInstalled,
7125 piAction);
7126
7127 index = get_loaded_component(package,szComponent);
7128 if (index < 0)
7129 return ERROR_UNKNOWN_COMPONENT;
7130
7131 if (piInstalled)
7132 *piInstalled = package->components[index].Installed;
7133
7134 if (piAction)
7135 *piAction = package->components[index].Action;
7136
7137 TRACE("states (%i, %i)\n",
7138 (piInstalled)?*piInstalled:-1,(piAction)?*piAction:-1);
7139
7140 return ERROR_SUCCESS;
7141 }
7142
7143 /***********************************************************************
7144 * MsiGetComponentStateW (MSI.@)
7145 */
7146 UINT WINAPI MsiGetComponentStateW(MSIHANDLE hInstall, LPWSTR szComponent,
7147 INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
7148 {
7149 MSIPACKAGE* package;
7150 UINT ret;
7151
7152 TRACE("%ld %s %p %p\n", hInstall, debugstr_w(szComponent),
7153 piInstalled, piAction);
7154
7155 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
7156 if (!package)
7157 return ERROR_INVALID_HANDLE;
7158 ret = MSI_GetComponentStateW( package, szComponent, piInstalled, piAction);
7159 msiobj_release( &package->hdr );
7160 return ret;
7161 }
7162
7163 #if 0
7164 static UINT ACTION_Template(MSIPACKAGE *package)
7165 {
7166 UINT rc;
7167 MSIQUERY * view;
7168 MSIRECORD * row = 0;
7169 static const WCHAR ExecSeqQuery[] = {0};
7170
7171 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
7172 if (rc != ERROR_SUCCESS)
7173 return rc;
7174
7175 rc = MSI_ViewExecute(view, 0);
7176 if (rc != ERROR_SUCCESS)
7177 {
7178 MSI_ViewClose(view);
7179 msiobj_release(&view->hdr);
7180 return rc;
7181 }
7182
7183 while (1)
7184 {
7185 rc = MSI_ViewFetch(view,&row);
7186 if (rc != ERROR_SUCCESS)
7187 {
7188 rc = ERROR_SUCCESS;
7189 break;
7190 }
7191
7192 msiobj_release(&row->hdr);
7193 }
7194 MSI_ViewClose(view);
7195 msiobj_release(&view->hdr);
7196 return rc;
7197 }
7198 #endif
GSOC 2012 project to enhance the control panel