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