src/xsmfns.c

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