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