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