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, 2009
   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 #include <setjmp.h>
  36
  37 #include "lisp.h"
  38 #include "systime.h"
  39 #include "sysselect.h"
  40 #include "frame.h"
  41 #include "termhooks.h"
  42 #include "termopts.h"
  43 #include "xterm.h"
  44
  45 /* The user login name.  */
  46
  47 extern Lisp_Object Vuser_login_name;
  48
  49 /* This is the event used when SAVE_SESSION_EVENT occurs.  */
  50
  51 static struct input_event emacs_event;
  52
  53 /* The descriptor that we use to check for data from the session manager.  */
  54
  55 static int ice_fd = -1;
  56
  57 /* A flag that says if we are in shutdown interactions or not.  */
  58
  59 static int doing_interact = False;
  60
  61 /* The session manager object for the session manager connection.  */
  62
  63 static SmcConn smc_conn;
  64
  65 /* The client session id for this session.  */
  66
  67 static char *client_id;
  68
  69 /* The full path name to the Emacs program.  */
  70
  71 static char *emacs_program;
  72
  73 /* The client session id for this session as a lisp object.  */
  74
  75 Lisp_Object Vx_session_id;
  76
  77 /* The id we had the previous session.  This is only available if we
  78    have been started by the session manager with SMID_OPT.  */
  79
  80 Lisp_Object Vx_session_previous_id;
  81
  82 /* The option we tell the session manager to start Emacs with when
  83    restarting Emacs.  The client_id is appended.  */
  84
  85 #define SMID_OPT "--smid="
  86
  87
  88 /* The option to start Emacs without the splash screen when
  89    restarting Emacs.  */
  90
  91 #define NOSPLASH_OPT "--no-splash"
  92
  93
  94 /* Handle any messages from the session manager.  If no connection is
  95    open to a session manager, just return 0.
  96    Otherwise returns 1 if SAVE_SESSION_EVENT is stored in buffer BUFP.  */
  97
  98 int
  99 x_session_check_input (bufp)
 100      struct input_event *bufp;
 101 {
 102   SELECT_TYPE read_fds;
 103   EMACS_TIME tmout;
 104
 105   if (ice_fd == -1) return 0;
 106
 107   FD_ZERO (&read_fds);
 108   FD_SET (ice_fd, &read_fds);
 109
 110   tmout.tv_sec = 0;
 111   tmout.tv_usec = 0;
 112
 113   /* Reset this so wo can check kind after callbacks have been called by
 114      IceProcessMessages.  The smc_interact_CB sets the kind to
 115      SAVE_SESSION_EVENT, but we don't know beforehand if that callback
 116      will be called.  */
 117   emacs_event.kind = NO_EVENT;
 118
 119   if (select (ice_fd+1, &read_fds,
 120               (SELECT_TYPE *)0, (SELECT_TYPE *)0, &tmout) < 0)
 121     {
 122       ice_fd = -1;
 123       return 0;
 124     }
 125
 126
 127   if (FD_ISSET (ice_fd, &read_fds))
 128     IceProcessMessages (SmcGetIceConnection (smc_conn),
 129                         (IceReplyWaitInfo *)0, (Bool *)0);
 130
 131
 132   /* Check if smc_interact_CB was called and we shall generate a
 133      SAVE_SESSION_EVENT.  */
 134   if (emacs_event.kind == NO_EVENT)
 135     return 0;
 136
 137   bcopy (&emacs_event, bufp, sizeof (struct input_event));
 138   return 1;
 139 }
 140
 141 /* Return non-zero if we have a connection to a session manager.  */
 142
 143 int
 144 x_session_have_connection ()
 145 {
 146   return ice_fd != -1;
 147 }
 148
 149 /* This is called when the session manager says it is OK to interact with the
 150    user.  Here we set the kind to SAVE_SESSION_EVENT so an event is generated.
 151    Then lisp code can interact with the user.  */
 152
 153 static void
 154 smc_interact_CB (smcConn, clientData)
 155      SmcConn smcConn;
 156      SmPointer clientData;
 157 {
 158   doing_interact = True;
 159   emacs_event.kind = SAVE_SESSION_EVENT;
 160 }
 161
 162 /* This is called when the session manager tells us to save ourselves.
 163    We set the required properties so the session manager can restart us,
 164    plus the current working directory property (not mandatory) so we
 165    are started in the correct directory.
 166
 167    If this is a shutdown and we can request to interact with the user,
 168    we do so, because we don't know what the lisp code might do.  */
 169
 170 static void
 171 smc_save_yourself_CB (smcConn,
 172                       clientData,
 173                       saveType,
 174                       shutdown,
 175                       interactStyle,
 176                       fast)
 177      SmcConn smcConn;
 178      SmPointer clientData;
 179      int saveType;
 180      Bool shutdown;
 181      int interactStyle;
 182      Bool fast;
 183 {
 184 #define NR_PROPS 5
 185
 186   SmProp *props[NR_PROPS];
 187   SmProp prop_ptr[NR_PROPS];
 188
 189   SmPropValue values[20];
 190   int val_idx = 0;
 191   int props_idx = 0;
 192
 193   char *cwd = NULL;
 194   char *smid_opt;
 195
 196   /* How to start a new instance of Emacs.  */
 197   props[props_idx] = &prop_ptr[props_idx];
 198   props[props_idx]->name = SmCloneCommand;
 199   props[props_idx]->type = SmLISTofARRAY8;
 200   props[props_idx]->num_vals = 1;
 201   props[props_idx]->vals = &values[val_idx++];
 202   props[props_idx]->vals[0].length = strlen (emacs_program);
 203   props[props_idx]->vals[0].value = emacs_program;
 204   ++props_idx;
 205
 206   /* The name of the program.  */
 207   props[props_idx] = &prop_ptr[props_idx];
 208   props[props_idx]->name = SmProgram;
 209   props[props_idx]->type = SmARRAY8;
 210   props[props_idx]->num_vals = 1;
 211   props[props_idx]->vals = &values[val_idx++];
 212   props[props_idx]->vals[0].length = strlen (SDATA (Vinvocation_name));
 213   props[props_idx]->vals[0].value = SDATA (Vinvocation_name);
 214   ++props_idx;
 215
 216   /* How to restart Emacs (i.e.: /path/to/emacs --smid=xxxx --no-splash).  */
 217   props[props_idx] = &prop_ptr[props_idx];
 218   props[props_idx]->name = SmRestartCommand;
 219   props[props_idx]->type = SmLISTofARRAY8;
 220   props[props_idx]->num_vals = 3; /* /path/to/emacs, --smid=xxx --no-splash  */
 221   props[props_idx]->vals = &values[val_idx];
 222   props[props_idx]->vals[0].length = strlen (emacs_program);
 223   props[props_idx]->vals[0].value = emacs_program;
 224
 225   smid_opt = xmalloc (strlen (SMID_OPT) + strlen (client_id) + 1);
 226   strcpy (smid_opt, SMID_OPT);
 227   strcat (smid_opt, client_id);
 228
 229   props[props_idx]->vals[1].length = strlen (smid_opt);
 230   props[props_idx]->vals[1].value = smid_opt;
 231
 232   props[props_idx]->vals[2].length = strlen (NOSPLASH_OPT);
 233   props[props_idx]->vals[2].value = NOSPLASH_OPT;
 234   val_idx += 3;
 235   ++props_idx;
 236
 237   /* User id.  */
 238   props[props_idx] = &prop_ptr[props_idx];
 239   props[props_idx]->name = SmUserID;
 240   props[props_idx]->type = SmARRAY8;
 241   props[props_idx]->num_vals = 1;
 242   props[props_idx]->vals = &values[val_idx++];
 243   props[props_idx]->vals[0].length = strlen (SDATA (Vuser_login_name));
 244   props[props_idx]->vals[0].value = SDATA (Vuser_login_name);
 245   ++props_idx;
 246
 247   cwd = get_current_dir_name ();
 248
 249   if (cwd)
 250     {
 251       props[props_idx] = &prop_ptr[props_idx];
 252       props[props_idx]->name = SmCurrentDirectory;
 253       props[props_idx]->type = SmARRAY8;
 254       props[props_idx]->num_vals = 1;
 255       props[props_idx]->vals = &values[val_idx++];
 256       props[props_idx]->vals[0].length = strlen (cwd);
 257       props[props_idx]->vals[0].value = cwd;
 258       ++props_idx;
 259     }
 260
 261
 262   SmcSetProperties (smcConn, props_idx, props);
 263
 264   xfree (smid_opt);
 265
 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) */