[msi]
[reactos.git] / reactos / dll / win32 / msi / events.c
1 /*
2 * Implementation of the Microsoft Installer (msi.dll)
3 *
4 * Copyright 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdarg.h>
22 #include <stdio.h>
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winerror.h"
27 #include "winreg.h"
28 #include "msi.h"
29 #include "msipriv.h"
30
31 #include "wine/debug.h"
32 #include "wine/unicode.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(msi);
35
36 typedef UINT (*EVENTHANDLER)(MSIPACKAGE*,LPCWSTR,msi_dialog *);
37
38 struct _events {
39 LPCSTR event;
40 EVENTHANDLER handler;
41 };
42
43 struct subscriber {
44 struct list entry;
45 msi_dialog *dialog;
46 LPWSTR event;
47 LPWSTR control;
48 LPWSTR attribute;
49 };
50
51 static UINT ControlEvent_HandleControlEvent(MSIPACKAGE *, LPCWSTR, LPCWSTR, msi_dialog*);
52
53 /*
54 * Create a dialog box and run it if it's modal
55 */
56 static UINT event_do_dialog( MSIPACKAGE *package, LPCWSTR name, msi_dialog *parent, BOOL destroy_modeless )
57 {
58 msi_dialog *dialog;
59 UINT r;
60
61 /* create a new dialog */
62 dialog = msi_dialog_create( package, name, parent,
63 ControlEvent_HandleControlEvent );
64 if( dialog )
65 {
66 /* kill the current modeless dialog */
67 if( destroy_modeless && package->dialog )
68 {
69 msi_dialog_destroy( package->dialog );
70 package->dialog = NULL;
71 }
72
73 /* modeless dialogs return an error message */
74 r = msi_dialog_run_message_loop( dialog );
75 if( r == ERROR_SUCCESS )
76 msi_dialog_destroy( dialog );
77 else
78 package->dialog = dialog;
79 }
80 else
81 r = ERROR_FUNCTION_FAILED;
82
83 return r;
84 }
85
86
87 /*
88 * End a modal dialog box
89 */
90 static UINT ControlEvent_EndDialog(MSIPACKAGE* package, LPCWSTR argument,
91 msi_dialog* dialog)
92 {
93 static const WCHAR szExit[] = {'E','x','i','t',0};
94 static const WCHAR szRetry[] = {'R','e','t','r','y',0};
95 static const WCHAR szIgnore[] = {'I','g','n','o','r','e',0};
96 static const WCHAR szReturn[] = {'R','e','t','u','r','n',0};
97
98 if (!strcmpW( argument, szExit ))
99 package->CurrentInstallState = ERROR_INSTALL_USEREXIT;
100 else if (!strcmpW( argument, szRetry ))
101 package->CurrentInstallState = ERROR_INSTALL_SUSPEND;
102 else if (!strcmpW( argument, szIgnore ))
103 package->CurrentInstallState = ERROR_SUCCESS;
104 else if (!strcmpW( argument, szReturn ))
105 {
106 msi_dialog *parent = msi_dialog_get_parent(dialog);
107 msi_free(package->next_dialog);
108 package->next_dialog = (parent) ? strdupW(msi_dialog_get_name(parent)) : NULL;
109 package->CurrentInstallState = ERROR_SUCCESS;
110 }
111 else
112 {
113 ERR("Unknown argument string %s\n",debugstr_w(argument));
114 package->CurrentInstallState = ERROR_FUNCTION_FAILED;
115 }
116
117 ControlEvent_CleanupDialogSubscriptions(package, msi_dialog_get_name( dialog ));
118 msi_dialog_end_dialog( dialog );
119 return ERROR_SUCCESS;
120 }
121
122 /*
123 * transition from one modal dialog to another modal dialog
124 */
125 static UINT ControlEvent_NewDialog(MSIPACKAGE* package, LPCWSTR argument,
126 msi_dialog *dialog)
127 {
128 /* store the name of the next dialog, and signal this one to end */
129 package->next_dialog = strdupW(argument);
130 ControlEvent_CleanupSubscriptions(package);
131 msi_dialog_end_dialog( dialog );
132 return ERROR_SUCCESS;
133 }
134
135 /*
136 * Create a new child dialog of an existing modal dialog
137 */
138 static UINT ControlEvent_SpawnDialog(MSIPACKAGE* package, LPCWSTR argument,
139 msi_dialog *dialog)
140 {
141 /* don't destroy a modeless dialogs that might be our parent */
142 event_do_dialog( package, argument, dialog, FALSE );
143 if( package->CurrentInstallState != ERROR_SUCCESS )
144 msi_dialog_end_dialog( dialog );
145 return ERROR_SUCCESS;
146 }
147
148 /*
149 * Creates a dialog that remains up for a period of time
150 * based on a condition
151 */
152 static UINT ControlEvent_SpawnWaitDialog(MSIPACKAGE* package, LPCWSTR argument,
153 msi_dialog* dialog)
154 {
155 FIXME("Doing Nothing\n");
156 return ERROR_SUCCESS;
157 }
158
159 static UINT ControlEvent_DoAction(MSIPACKAGE* package, LPCWSTR argument,
160 msi_dialog* dialog)
161 {
162 ACTION_PerformAction(package, argument, -1);
163 return ERROR_SUCCESS;
164 }
165
166 static UINT ControlEvent_AddLocal( MSIPACKAGE *package, LPCWSTR argument, msi_dialog *dialog )
167 {
168 MSIFEATURE *feature;
169
170 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
171 {
172 if (!strcmpW( argument, feature->Feature ) || !strcmpW( argument, szAll ))
173 {
174 if (feature->ActionRequest != INSTALLSTATE_LOCAL)
175 msi_set_property( package->db, szPreselected, szOne );
176 MSI_SetFeatureStateW( package, feature->Feature, INSTALLSTATE_LOCAL );
177 }
178 }
179 return ERROR_SUCCESS;
180 }
181
182 static UINT ControlEvent_Remove( MSIPACKAGE *package, LPCWSTR argument, msi_dialog *dialog )
183 {
184 MSIFEATURE *feature;
185
186 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
187 {
188 if (!strcmpW( argument, feature->Feature ) || !strcmpW( argument, szAll ))
189 {
190 if (feature->ActionRequest != INSTALLSTATE_ABSENT)
191 msi_set_property( package->db, szPreselected, szOne );
192 MSI_SetFeatureStateW( package, feature->Feature, INSTALLSTATE_ABSENT );
193 }
194 }
195 return ERROR_SUCCESS;
196 }
197
198 static UINT ControlEvent_AddSource( MSIPACKAGE *package, LPCWSTR argument, msi_dialog *dialog )
199 {
200 MSIFEATURE *feature;
201
202 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
203 {
204 if (!strcmpW( argument, feature->Feature ) || !strcmpW( argument, szAll ))
205 {
206 if (feature->ActionRequest != INSTALLSTATE_SOURCE)
207 msi_set_property( package->db, szPreselected, szOne );
208 MSI_SetFeatureStateW( package, feature->Feature, INSTALLSTATE_SOURCE );
209 }
210 }
211 return ERROR_SUCCESS;
212 }
213
214 static UINT ControlEvent_SetTargetPath(MSIPACKAGE* package, LPCWSTR argument,
215 msi_dialog* dialog)
216 {
217 LPWSTR path = msi_dup_property( package->db, argument );
218 MSIRECORD *rec = MSI_CreateRecord( 1 );
219 UINT r;
220
221 static const WCHAR szSelectionPath[] = {'S','e','l','e','c','t','i','o','n','P','a','t','h',0};
222
223 MSI_RecordSetStringW( rec, 1, path );
224 ControlEvent_FireSubscribedEvent( package, szSelectionPath, rec );
225
226 /* failure to set the path halts the executing of control events */
227 r = MSI_SetTargetPathW(package, argument, path);
228 msi_free(path);
229 msi_free(&rec->hdr);
230 return r;
231 }
232
233 static UINT ControlEvent_Reset(MSIPACKAGE* package, LPCWSTR argument,
234 msi_dialog* dialog)
235 {
236 msi_dialog_reset(dialog);
237 return ERROR_SUCCESS;
238 }
239
240 /*
241 * Subscribed events
242 */
243 static void free_subscriber( struct subscriber *sub )
244 {
245 msi_free(sub->event);
246 msi_free(sub->control);
247 msi_free(sub->attribute);
248 msi_free(sub);
249 }
250
251 VOID ControlEvent_SubscribeToEvent( MSIPACKAGE *package, msi_dialog *dialog,
252 LPCWSTR event, LPCWSTR control, LPCWSTR attribute )
253 {
254 struct subscriber *sub;
255
256 sub = msi_alloc(sizeof (*sub));
257 if( !sub )
258 return;
259 sub->dialog = dialog;
260 sub->event = strdupW(event);
261 sub->control = strdupW(control);
262 sub->attribute = strdupW(attribute);
263 list_add_tail( &package->subscriptions, &sub->entry );
264 }
265
266 VOID ControlEvent_FireSubscribedEvent( MSIPACKAGE *package, LPCWSTR event,
267 MSIRECORD *rec )
268 {
269 struct subscriber *sub;
270
271 TRACE("Firing Event %s\n",debugstr_w(event));
272
273 LIST_FOR_EACH_ENTRY( sub, &package->subscriptions, struct subscriber, entry )
274 {
275 if (strcmpiW( sub->event, event ))
276 continue;
277 msi_dialog_handle_event( sub->dialog, sub->control, sub->attribute, rec );
278 }
279 }
280
281 VOID ControlEvent_CleanupDialogSubscriptions(MSIPACKAGE *package, LPWSTR dialog)
282 {
283 struct list *i, *t;
284 struct subscriber *sub;
285
286 LIST_FOR_EACH_SAFE( i, t, &package->subscriptions )
287 {
288 sub = LIST_ENTRY( i, struct subscriber, entry );
289
290 if (strcmpW( msi_dialog_get_name( sub->dialog ), dialog ))
291 continue;
292
293 list_remove( &sub->entry );
294 free_subscriber( sub );
295 }
296 }
297
298 VOID ControlEvent_CleanupSubscriptions(MSIPACKAGE *package)
299 {
300 struct list *i, *t;
301 struct subscriber *sub;
302
303 LIST_FOR_EACH_SAFE( i, t, &package->subscriptions )
304 {
305 sub = LIST_ENTRY( i, struct subscriber, entry );
306
307 list_remove( &sub->entry );
308 free_subscriber( sub );
309 }
310 }
311
312 /*
313 * ACTION_DialogBox()
314 *
315 * Return ERROR_SUCCESS if dialog is process and ERROR_FUNCTION_FAILED
316 * if the given parameter is not a dialog box
317 */
318 UINT ACTION_DialogBox( MSIPACKAGE* package, LPCWSTR szDialogName )
319 {
320 UINT r = ERROR_SUCCESS;
321
322 if( package->next_dialog )
323 ERR("Already a next dialog... ignoring it\n");
324 package->next_dialog = NULL;
325
326 /*
327 * Dialogs are chained by filling in the next_dialog member
328 * of the package structure, then terminating the current dialog.
329 * The code below sees the next_dialog member set, and runs the
330 * next dialog.
331 * We fall out of the loop below if we come across a modeless
332 * dialog, as it returns ERROR_IO_PENDING when we try to run
333 * its message loop.
334 */
335 r = event_do_dialog( package, szDialogName, NULL, TRUE );
336 while( r == ERROR_SUCCESS && package->next_dialog )
337 {
338 LPWSTR name = package->next_dialog;
339
340 package->next_dialog = NULL;
341 r = event_do_dialog( package, name, NULL, TRUE );
342 msi_free( name );
343 }
344
345 if( r == ERROR_IO_PENDING )
346 r = ERROR_SUCCESS;
347
348 return r;
349 }
350
351 static UINT ControlEvent_SetInstallLevel(MSIPACKAGE* package, LPCWSTR argument,
352 msi_dialog* dialog)
353 {
354 int iInstallLevel = atolW(argument);
355
356 TRACE("Setting install level: %i\n", iInstallLevel);
357
358 return MSI_SetInstallLevel( package, iInstallLevel );
359 }
360
361 static UINT ControlEvent_DirectoryListUp(MSIPACKAGE *package, LPCWSTR argument,
362 msi_dialog *dialog)
363 {
364 return msi_dialog_directorylist_up( dialog );
365 }
366
367 static UINT ControlEvent_ReinstallMode(MSIPACKAGE *package, LPCWSTR argument,
368 msi_dialog *dialog)
369 {
370 return msi_set_property( package->db, szReinstallMode, argument );
371 }
372
373 static UINT ControlEvent_Reinstall( MSIPACKAGE *package, LPCWSTR argument,
374 msi_dialog *dialog )
375 {
376 return msi_set_property( package->db, szReinstall, argument );
377 }
378
379 static UINT ControlEvent_ValidateProductID(MSIPACKAGE *package, LPCWSTR argument,
380 msi_dialog *dialog)
381 {
382 LPWSTR key, template;
383 UINT ret = ERROR_SUCCESS;
384
385 template = msi_dup_property( package->db, szPIDTemplate );
386 key = msi_dup_property( package->db, szPIDKEY );
387
388 if (key && template)
389 {
390 FIXME( "partial stub: template %s key %s\n", debugstr_w(template), debugstr_w(key) );
391 ret = msi_set_property( package->db, szProductID, key );
392 }
393 msi_free( template );
394 msi_free( key );
395 return ret;
396 }
397
398 static const struct _events Events[] = {
399 { "EndDialog",ControlEvent_EndDialog },
400 { "NewDialog",ControlEvent_NewDialog },
401 { "SpawnDialog",ControlEvent_SpawnDialog },
402 { "SpawnWaitDialog",ControlEvent_SpawnWaitDialog },
403 { "DoAction",ControlEvent_DoAction },
404 { "AddLocal",ControlEvent_AddLocal },
405 { "Remove",ControlEvent_Remove },
406 { "AddSource",ControlEvent_AddSource },
407 { "SetTargetPath",ControlEvent_SetTargetPath },
408 { "Reset",ControlEvent_Reset },
409 { "SetInstallLevel",ControlEvent_SetInstallLevel },
410 { "DirectoryListUp",ControlEvent_DirectoryListUp },
411 { "SelectionBrowse",ControlEvent_SpawnDialog },
412 { "ReinstallMode",ControlEvent_ReinstallMode },
413 { "Reinstall",ControlEvent_Reinstall },
414 { "ValidateProductID",ControlEvent_ValidateProductID },
415 { NULL,NULL },
416 };
417
418 UINT ControlEvent_HandleControlEvent(MSIPACKAGE *package, LPCWSTR event,
419 LPCWSTR argument, msi_dialog* dialog)
420 {
421 int i = 0;
422 UINT rc = ERROR_SUCCESS;
423
424 TRACE("Handling Control Event %s\n",debugstr_w(event));
425 if (!event)
426 return rc;
427
428 while( Events[i].event != NULL)
429 {
430 LPWSTR wevent = strdupAtoW(Events[i].event);
431 if (!strcmpW( wevent, event ))
432 {
433 msi_free(wevent);
434 rc = Events[i].handler(package,argument,dialog);
435 return rc;
436 }
437 msi_free(wevent);
438 i++;
439 }
440 FIXME("unhandled control event %s arg(%s)\n",
441 debugstr_w(event), debugstr_w(argument));
442 return rc;
443 }