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