src/xsmfns.c

   1 /* Session management module for systems which understand the X Session
   2    management protocol.
   3    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
   4      Free Software Foundation, Inc.
   5
   6 This file is part of GNU Emacs.
   7
   8 GNU Emacs is free software: you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation, either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 GNU Emacs is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include <config.h>
  22
  23 #ifdef HAVE_X_SM
  24
  25 #include <X11/SM/SMlib.h>
  26 #include <X11/Xlib.h>
  27 #include <X11/Xutil.h>
  28
  29 #ifdef HAVE_UNISTD_H
  30 #include <unistd.h>
  31 #endif
  32
  33 #include <sys/param.h>
  34 #include <stdio.h>
  35
  36 #include "lisp.h"
  37 #include "systime.h"
  38 #include "sysselect.h"
  39 #include "frame.h"
  40 #include "termhooks.h"
  41 #include "termopts.h"
  42 #include "xterm.h"
  43
  44 /* The user login name.  */
  45
  46 extern Lisp_Object Vuser_login_name;
  47
  48 /* This is the event used when SAVE_SESSION_EVENT occurs.  */
  49
  50 static struct input_event emacs_event;
  51
  52 /* The descriptor that we use to check for data from the session manager.  */
  53
  54 static int ice_fd = -1;
  55
  56 /* A flag that says if we are in shutdown interactions or not.  */
  57
  58 static int doing_interact = False;
  59
  60 /* The session manager object for the session manager connection.  */
  61
  62 static SmcConn smc_conn;
  63
  64 /* The client session id for this session.  */
  65
  66 static char *client_id;
  67
  68 /* The full path name to the Emacs program.  */
  69
  70 static char *emacs_program;
  71
  72 /* The client session id for this session as a lisp object.  */
  73
  74 Lisp_Object Vx_session_id;
  75
  76 /* The id we had the previous session.  This is only available if we
  77    have been started by the session manager with SMID_OPT.  */
  78
  79 Lisp_Object Vx_session_previous_id;
  80
  81 /* The option we tell the session manager to start Emacs with when
  82    restarting Emacs.  The client_id is appended.  */
  83
  84 #define SMID_OPT "--smid="
  85
  86
  87 /* The option to start Emacs without the splash screen when
  88    restarting Emacs.  */
  89
  90 #define NOSPLASH_OPT "--no-splash"
  91
  92
  93 /* Handle any messages from the session manager.  If no connection is
  94    open to a session manager, just return 0.
  95    Otherwise returns 1 if SAVE_SESSION_EVENT is stored in buffer BUFP.  */
  96
  97 int
  98 x_session_check_input (bufp)
  99      struct input_event *bufp;
 100 {
 101   SELECT_TYPE read_fds;
 102   EMACS_TIME tmout;
 103
 104   if (ice_fd == -1) return 0;
 105
 106   FD_ZERO (&read_fds);
 107   FD_SET (ice_fd, &read_fds);
 108
 109   tmout.tv_sec = 0;
 110   tmout.tv_usec = 0;
 111
 112   /* Reset this so wo can check kind after callbacks have been called by
 113      IceProcessMessages.  The smc_interact_CB sets the kind to
 114      SAVE_SESSION_EVENT, but we don't know beforehand if that callback
 115      will be called.  */
 116   emacs_event.kind = NO_EVENT;
 117
 118   if (select (ice_fd+1, &read_fds,
 119               (SELECT_TYPE *)0, (SELECT_TYPE *)0, &tmout) < 0)
 120     {
 121       ice_fd = -1;
 122       return 0;
 123     }
 124
 125
 126   if (FD_ISSET (ice_fd, &read_fds))
 127     IceProcessMessages (SmcGetIceConnection (smc_conn),
 128                         (IceReplyWaitInfo *)0, (Bool *)0);
 129
 130
 131   /* Check if smc_interact_CB was called and we shall generate a
 132      SAVE_SESSION_EVENT.  */
 133   if (emacs_event.kind == NO_EVENT)
 134     return 0;
 135
 136   bcopy (&emacs_event, bufp, sizeof (struct input_event));
 137   return 1;
 138 }
 139
 140 /* Return non-zero if we have a connection to a session manager.  */
 141
 142 int
 143 x_session_have_connection ()
 144 {
 145   return ice_fd != -1;
 146 }
 147
 148 /* This is called when the session manager says it is OK to interact with the
 149    user.  Here we set the kind to SAVE_SESSION_EVENT so an event is generated.
 150    Then lisp code can interact with the user.  */
 151
 152 static void
 153 smc_interact_CB (smcConn, clientData)
 154      SmcConn smcConn;
 155      SmPointer clientData;
 156 {
 157   doing_interact = True;
 158   emacs_event.kind = SAVE_SESSION_EVENT;
 159 }
 160
 161 /* This is called when the session manager tells us to save ourselves.
 162    We set the required properties so the session manager can restart us,
 163    plus the current working directory property (not mandatory) so we
 164    are started in the correct directory.
 165
 166    If this is a shutdown and we can request to interact with the user,
 167    we do so, because we don't know what the lisp code might do.  */
 168
 169 static void
 170 smc_save_yourself_CB (smcConn,
 171                       clientData,
 172                       saveType,
 173                       shutdown,
 174                       interactStyle,
 175                       fast)
 176      SmcConn smcConn;
 177      SmPointer clientData;
 178      int saveType;
 179      Bool shutdown;
 180      int interactStyle;
 181      Bool fast;
 182 {
 183 #define NR_PROPS 5
 184
 185   SmProp *props[NR_PROPS];
 186   SmProp prop_ptr[NR_PROPS];
 187
 188   SmPropValue values[20];
 189   int val_idx = 0;
 190   int props_idx = 0;
 191
 192   char *cwd = NULL;
 193   char *smid_opt;
 194
 195   /* How to start a new instance of Emacs.  */
 196   props[props_idx] = &prop_ptr[props_idx];
 197   props[props_idx]->name = SmCloneCommand;
 198   props[props_idx]->type = SmLISTofARRAY8;
 199   props[props_idx]->num_vals = 1;
 200   props[props_idx]->vals = &values[val_idx++];
 201   props[props_idx]->vals[0].length = strlen (emacs_program);
 202   props[props_idx]->vals[0].value = emacs_program;
 203   ++props_idx;
 204
 205   /* The name of the program.  */
 206   props[props_idx] = &prop_ptr[props_idx];
 207   props[props_idx]->name = SmProgram;
 208   props[props_idx]->type = SmARRAY8;
 209   props[props_idx]->num_vals = 1;
 210   props[props_idx]->vals = &values[val_idx++];
 211   props[props_idx]->vals[0].length = strlen (SDATA (Vinvocation_name));
 212   props[props_idx]->vals[0].value = SDATA (Vinvocation_name);
 213   ++props_idx;
 214
 215   /* How to restart Emacs (i.e.: /path/to/emacs --smid=xxxx --no-splash).  */
 216   props[props_idx] = &prop_ptr[props_idx];
 217   props[props_idx]->name = SmRestartCommand;
 218   props[props_idx]->type = SmLISTofARRAY8;
 219   props[props_idx]->num_vals = 3; /* /path/to/emacs, --smid=xxx --no-splash  */
 220   props[props_idx]->vals = &values[val_idx];
 221   props[props_idx]->vals[0].length = strlen (emacs_program);
 222   props[props_idx]->vals[0].value = emacs_program;
 223
 224   smid_opt = xmalloc (strlen (SMID_OPT) + strlen (client_id) + 1);
 225   strcpy (smid_opt, SMID_OPT);
 226   strcat (smid_opt, client_id);
 227
 228   props[props_idx]->vals[1].length = strlen (smid_opt);
 229   props[props_idx]->vals[1].value = smid_opt;
 230
 231   props[props_idx]->vals[2].length = strlen (NOSPLASH_OPT);
 232   props[props_idx]->vals[2].value = NOSPLASH_OPT;
 233   val_idx += 3;
 234   ++props_idx;
 235
 236   /* User id.  */
 237   props[props_idx] = &prop_ptr[props_idx];
 238   props[props_idx]->name = SmUserID;
 239   props[props_idx]->type = SmARRAY8;
 240   props[props_idx]->num_vals = 1;
 241   props[props_idx]->vals = &values[val_idx++];
 242   props[props_idx]->vals[0].length = strlen (SDATA (Vuser_login_name));
 243   props[props_idx]->vals[0].value = SDATA (Vuser_login_name);
 244   ++props_idx;
 245
 246   cwd = get_current_dir_name ();
 247
 248   if (cwd)
 249     {
 250       props[props_idx] = &prop_ptr[props_idx];
 251       props[props_idx]->name = SmCurrentDirectory;
 252       props[props_idx]->type = SmARRAY8;
 253       props[props_idx]->num_vals = 1;
 254       props[props_idx]->vals = &values[val_idx++];
 255       props[props_idx]->vals[0].length = strlen (cwd);
 256       props[props_idx]->vals[0].value = cwd;
 257       ++props_idx;
 258     }
 259
 260
 261   SmcSetProperties (smcConn, props_idx, props);
 262
 263   xfree (smid_opt);
 264
 265   if (cwd)
 266     free (cwd);
 267
 268   /* See if we maybe shall interact with the user.  */
 269   if (interactStyle != SmInteractStyleAny
 270       || ! shutdown
 271       || saveType == SmSaveLocal
 272       || ! SmcInteractRequest (smcConn, SmDialogNormal, smc_interact_CB, 0))
 273     {
 274       /* No interaction, we are done saving ourself.  */
 275       SmcSaveYourselfDone (smcConn, True);
 276     }
 277 }
 278
 279 /* According to the SM specification, this shall close the connection.  */
 280
 281 static void
 282 smc_die_CB (smcConn, clientData)
 283      SmcConn smcConn;
 284      SmPointer clientData;
 285 {
 286   SmcCloseConnection (smcConn, 0, 0);
 287   ice_fd = -1;
 288 }
 289
 290 /* We don't use the next two but they are mandatory, leave them empty.
 291    According to the SM specification, we should not interact with the
 292    user between smc_save_yourself_CB is called and until smc_save_complete_CB
 293    is called.  It seems like a lot of job to implement this and it doesn't
 294    even seem necessary.  */
 295
 296 static void
 297 smc_save_complete_CB (smcConn, clientData)
 298      SmcConn smcConn;
 299      SmPointer clientData;
 300 {
 301   /* Empty */
 302 }
 303
 304 static void
 305 smc_shutdown_cancelled_CB (smcConn, clientData)
 306      SmcConn smcConn;
 307      SmPointer clientData;
 308 {
 309   /* Empty */
 310 }
 311
 312 /* Error handlers for SM and ICE.  We don't want to exit Emacs just
 313    because there is some error in the session management.  */
 314
 315 static void
 316 smc_error_handler (smcConn,
 317                    swap,
 318                    offendingMinorOpcode,
 319                    offendingSequence,
 320                    errorClass,
 321                    severity,
 322                    values)
 323      SmcConn smcConn;
 324      Bool swap;
 325      int offendingMinorOpcode;
 326      unsigned long offendingSequence;
 327      int errorClass;
 328      int severity;
 329      SmPointer values;
 330 {
 331   /* Empty  */
 332 }
 333
 334 static void
 335 ice_error_handler (iceConn,
 336                    swap,
 337                    offendingMinorOpcode,
 338                    offendingSequence,
 339                    errorClass,
 340                    severity,
 341                    values)
 342      IceConn iceConn;
 343      Bool swap;
 344      int offendingMinorOpcode;
 345      unsigned long offendingSequence;
 346      int errorClass;
 347      int severity;
 348      IcePointer values;
 349 {
 350   /* Empty  */
 351 }
 352
 353
 354 static void
 355 ice_io_error_handler (iceConn)
 356      IceConn iceConn;
 357 {
 358   /* Connection probably gone.  */
 359   ice_fd = -1;
 360 }
 361
 362 /* This is called when the ICE connection is created or closed.  The SM library
 363    uses ICE as it transport protocol.  */
 364
 365 static void
 366 ice_conn_watch_CB (iceConn, clientData, opening, watchData)
 367      IceConn iceConn;
 368      IcePointer clientData;
 369      Bool opening;
 370      IcePointer *watchData;
 371 {
 372   if (! opening)
 373     {
 374       ice_fd = -1;
 375       return;
 376     }
 377
 378   ice_fd = IceConnectionNumber (iceConn);
 379 #ifdef F_SETOWN
 380   fcntl (ice_fd, F_SETOWN, getpid ());
 381 #endif /* ! defined (F_SETOWN) */
 382
 383 #ifdef SIGIO
 384   if (interrupt_input)
 385     init_sigio (ice_fd);
 386 #endif /* ! defined (SIGIO) */
 387 }
 388
 389 /* Create the client leader window.  */
 390
 391 static void
 392 create_client_leader_window (dpyinfo, client_id)
 393      struct x_display_info *dpyinfo;
 394      char *client_id;
 395 {
 396   Window w;
 397   XClassHint class_hints;
 398   Atom sm_id;
 399
 400   w = XCreateSimpleWindow (dpyinfo->display,
 401                            dpyinfo->root_window,
 402                            -1, -1, 1, 1,
 403                            CopyFromParent, CopyFromParent, CopyFromParent);
 404
 405   class_hints.res_name = (char *) SDATA (Vx_resource_name);
 406   class_hints.res_class = (char *) SDATA (Vx_resource_class);
 407   XSetClassHint (dpyinfo->display, w, &class_hints);
 408   XStoreName (dpyinfo->display, w, class_hints.res_name);
 409
 410   sm_id = XInternAtom (dpyinfo->display, "SM_CLIENT_ID", False);
 411   XChangeProperty (dpyinfo->display, w, sm_id, XA_STRING, 8, PropModeReplace,
 412                    client_id, strlen (client_id));
 413
 414   dpyinfo->client_leader_window = w;
 415 }
 416
 417 /* Try to open a connection to the session manager.  */
 418
 419 void
 420 x_session_initialize (dpyinfo)
 421      struct x_display_info *dpyinfo;
 422 {
 423 #define SM_ERRORSTRING_LEN 512
 424   char errorstring[SM_ERRORSTRING_LEN];
 425   char* previous_id = NULL;
 426   SmcCallbacks callbacks;
 427   int  name_len = 0;
 428
 429   /* Check if we where started by the session manager.  If so, we will
 430      have a previous id.  */
 431   if (! EQ (Vx_session_previous_id, Qnil) && STRINGP (Vx_session_previous_id))
 432     previous_id = SDATA (Vx_session_previous_id);
 433
 434   /* Construct the path to the Emacs program.  */
 435   if (! EQ (Vinvocation_directory, Qnil))
 436     name_len += strlen (SDATA (Vinvocation_directory));
 437   name_len += strlen (SDATA (Vinvocation_name));
 438
 439   /* This malloc will not be freed, but it is only done once, and hopefully
 440      not very large   */
 441   emacs_program = xmalloc (name_len + 1);
 442   emacs_program[0] = '\0';
 443
 444   if (! EQ (Vinvocation_directory, Qnil))
 445     strcpy (emacs_program, SDATA (Vinvocation_directory));
 446   strcat (emacs_program, SDATA (Vinvocation_name));
 447
 448   /* The SM protocol says all callbacks are mandatory, so set up all
 449      here and in the mask passed to SmcOpenConnection.  */
 450   callbacks.save_yourself.callback = smc_save_yourself_CB;
 451   callbacks.save_yourself.client_data = 0;
 452   callbacks.die.callback = smc_die_CB;
 453   callbacks.die.client_data = 0;
 454   callbacks.save_complete.callback = smc_save_complete_CB;
 455   callbacks.save_complete.client_data = 0;
 456   callbacks.shutdown_cancelled.callback = smc_shutdown_cancelled_CB;
 457   callbacks.shutdown_cancelled.client_data = 0;
 458
 459   /* Set error handlers.  */
 460   SmcSetErrorHandler (smc_error_handler);
 461   IceSetErrorHandler (ice_error_handler);
 462   IceSetIOErrorHandler (ice_io_error_handler);
 463
 464   /* Install callback for when connection status changes.  */
 465   IceAddConnectionWatch (ice_conn_watch_CB, 0);
 466
 467   /* Open the connection to the session manager.  A failure is not
 468      critical, it usually means that no session manager is running.
 469      The errorstring is here for debugging.  */
 470   smc_conn = SmcOpenConnection (NULL, NULL, 1, 0,
 471                                 (SmcSaveYourselfProcMask|
 472                                  SmcDieProcMask|
 473                                  SmcSaveCompleteProcMask|
 474                                  SmcShutdownCancelledProcMask),
 475                                 &callbacks,
 476                                 previous_id,
 477                                 &client_id,
 478                                 SM_ERRORSTRING_LEN,
 479                                 errorstring);
 480
 481   if (smc_conn != 0)
 482     {
 483       Vx_session_id = make_string (client_id, strlen (client_id));
 484
 485 #ifdef USE_GTK
 486       /* GTK creats a leader window by itself, but we need to tell
 487          it about our client_id.  */
 488       gdk_set_sm_client_id (client_id);
 489 #else
 490       create_client_leader_window (dpyinfo, client_id);
 491 #endif
 492     }
 493 }
 494
 495 /* Ensure that the session manager is not contacted again. */
 496
 497 void
 498 x_session_close ()
 499 {
 500   ice_fd = -1;
 501 }
 502
 503
 504 DEFUN ("handle-save-session", Fhandle_save_session,
 505        Shandle_save_session, 1, 1, "e",
 506        doc: /* Handle the save_yourself event from a session manager.
 507 A session manager can tell Emacs that the window system is shutting down
 508 by sending Emacs a save_yourself message.  Emacs executes this function when
 509 such an event occurs.  This function then executes `emacs-session-save'.
 510 After that, this function informs the session manager that it can continue
 511 or abort shutting down the window system depending on the return value
 512 from `emacs-session-save'  If the return value is non-nil the session manager
 513 is told to abort the window system shutdown.
 514
 515 Do not call this function yourself. */)
 516      (event)
 517      Lisp_Object event;
 518 {
 519   /* Check doing_interact so that we don't do anything if someone called
 520      this at the wrong time. */
 521   if (doing_interact)
 522     {
 523       Bool cancel_shutdown = False;
 524
 525       cancel_shutdown = ! EQ (call0 (intern ("emacs-session-save")), Qnil);
 526
 527       SmcInteractDone (smc_conn, cancel_shutdown);
 528       SmcSaveYourselfDone (smc_conn, True);
 529
 530       doing_interact = False;
 531     }
 532
 533   return Qnil;
 534 }
 535
 536 \f
 537 /***********************************************************************
 538                             Initialization
 539  ***********************************************************************/
 540 void
 541 syms_of_xsmfns ()
 542 {
 543   DEFVAR_LISP ("x-session-id", &Vx_session_id,
 544     doc: /* The session id Emacs got from the session manager for this session.
 545 Changing the value does not change the session id used by Emacs.
 546 The value is nil if no session manager is running.
 547 See also `x-session-previous-id', `emacs-save-session-functions',
 548 `emacs-session-save' and `emacs-session-restore'." */);
 549   Vx_session_id = Qnil;
 550
 551   DEFVAR_LISP ("x-session-previous-id", &Vx_session_previous_id,
 552     doc: /* The previous session id Emacs got from session manager.
 553 If Emacs is running on a window system that has a session manager, the
 554 session manager gives Emacs a session id.  It is feasible for Emacs Lisp
 555 code to use the session id to save configuration in, for example, a file
 556 with a file name based on the session id.  If Emacs is running when the
 557 window system is shut down, the session manager remembers that Emacs was
 558 running and saves the session id Emacs had.
 559
 560 When the window system is started again, the session manager restarts
 561 Emacs and hands Emacs the session id it had the last time it was
 562 running.  This is now the previous session id and the value of this
 563 variable.  If configuration was saved in a file as stated above, the
 564 previous session id shall be used to reconstruct the file name.
 565
 566 The session id Emacs has while it is running is in the variable
 567 `x-session-id'.  The value of this variable and `x-session-id' may be the
 568 same, depending on how the session manager works.
 569
 570 See also `emacs-save-session-functions', `emacs-session-save' and
 571 `emacs-session-restore'." */);
 572   Vx_session_previous_id = Qnil;
 573
 574   defsubr (&Shandle_save_session);
 575 }
 576
 577 #endif /* HAVE_X_SM */
 578
 579 /* arch-tag: 56a2c58c-adfa-430a-b772-130abd29fd2e
 580    (do not change this comment) */