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