src/xsmfns.c

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