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