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
  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   free (cwd);
 266
 267   /* See if we maybe shall interact with the user.  */
 268   if (interactStyle != SmInteractStyleAny
 269       || ! shutdown
 270       || saveType == SmSaveLocal
 271       || ! SmcInteractRequest (smcConn, SmDialogNormal, smc_interact_CB, 0))
 272     {
 273       /* No interaction, we are done saving ourself.  */
 274       SmcSaveYourselfDone (smcConn, True);
 275     }
 276 }
 277
 278 /* According to the SM specification, this shall close the connection.  */
 279
 280 static void
 281 smc_die_CB (smcConn, clientData)
 282      SmcConn smcConn;
 283      SmPointer clientData;
 284 {
 285   SmcCloseConnection (smcConn, 0, 0);
 286   ice_fd = -1;
 287 }
 288
 289 /* We don't use the next two but they are mandatory, leave them empty.
 290    According to the SM specification, we should not interact with the
 291    user between smc_save_yourself_CB is called and until smc_save_complete_CB
 292    is called.  It seems like a lot of job to implement this and it doesn't
 293    even seem necessary.  */
 294
 295 static void
 296 smc_save_complete_CB (smcConn, clientData)
 297      SmcConn smcConn;
 298      SmPointer clientData;
 299 {
 300   /* Empty */
 301 }
 302
 303 static void
 304 smc_shutdown_cancelled_CB (smcConn, clientData)
 305      SmcConn smcConn;
 306      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,
 316                    swap,
 317                    offendingMinorOpcode,
 318                    offendingSequence,
 319                    errorClass,
 320                    severity,
 321                    values)
 322      SmcConn smcConn;
 323      Bool swap;
 324      int offendingMinorOpcode;
 325      unsigned long offendingSequence;
 326      int errorClass;
 327      int severity;
 328      SmPointer values;
 329 {
 330   /* Empty  */
 331 }
 332
 333 static void
 334 ice_error_handler (iceConn,
 335                    swap,
 336                    offendingMinorOpcode,
 337                    offendingSequence,
 338                    errorClass,
 339                    severity,
 340                    values)
 341      IceConn iceConn;
 342      Bool swap;
 343      int offendingMinorOpcode;
 344      unsigned long offendingSequence;
 345      int errorClass;
 346      int severity;
 347      IcePointer values;
 348 {
 349   /* Empty  */
 350 }
 351
 352
 353 static void
 354 ice_io_error_handler (iceConn)
 355      IceConn iceConn;
 356 {
 357   /* Connection probably gone.  */
 358   ice_fd = -1;
 359 }
 360
 361 /* This is called when the ICE connection is created or closed.  The SM library
 362    uses ICE as it transport protocol.  */
 363
 364 static void
 365 ice_conn_watch_CB (iceConn, clientData, opening, watchData)
 366      IceConn iceConn;
 367      IcePointer clientData;
 368      Bool opening;
 369      IcePointer *watchData;
 370 {
 371   if (! opening)
 372     {
 373       ice_fd = -1;
 374       return;
 375     }
 376
 377   ice_fd = IceConnectionNumber (iceConn);
 378 #ifdef F_SETOWN
 379   fcntl (ice_fd, F_SETOWN, getpid ());
 380 #endif /* ! defined (F_SETOWN) */
 381
 382 #ifdef SIGIO
 383   if (interrupt_input)
 384     init_sigio (ice_fd);
 385 #endif /* ! defined (SIGIO) */
 386 }
 387
 388 /* Create the client leader window.  */
 389
 390 static void
 391 create_client_leader_window (dpyinfo, client_id)
 392      struct x_display_info *dpyinfo;
 393      char *client_id;
 394 {
 395   Window w;
 396   XClassHint class_hints;
 397   Atom sm_id;
 398
 399   w = XCreateSimpleWindow (dpyinfo->display,
 400                            dpyinfo->root_window,
 401                            -1, -1, 1, 1,
 402                            CopyFromParent, CopyFromParent, CopyFromParent);
 403
 404   class_hints.res_name = (char *) SDATA (Vx_resource_name);
 405   class_hints.res_class = (char *) SDATA (Vx_resource_class);
 406   XSetClassHint (dpyinfo->display, w, &class_hints);
 407   XStoreName (dpyinfo->display, w, class_hints.res_name);
 408
 409   sm_id = XInternAtom (dpyinfo->display, "SM_CLIENT_ID", False);
 410   XChangeProperty (dpyinfo->display, w, sm_id, XA_STRING, 8, PropModeReplace,
 411                    client_id, strlen (client_id));
 412
 413   dpyinfo->client_leader_window = w;
 414 }
 415
 416 /* Try to open a connection to the session manager.  */
 417
 418 void
 419 x_session_initialize (dpyinfo)
 420      struct x_display_info *dpyinfo;
 421 {
 422 #define SM_ERRORSTRING_LEN 512
 423   char errorstring[SM_ERRORSTRING_LEN];
 424   char* previous_id = NULL;
 425   SmcCallbacks callbacks;
 426   int  name_len = 0;
 427
 428   /* Check if we where started by the session manager.  If so, we will
 429      have a previous id.  */
 430   if (! EQ (Vx_session_previous_id, Qnil) && STRINGP (Vx_session_previous_id))
 431     previous_id = SDATA (Vx_session_previous_id);
 432
 433   /* Construct the path to the Emacs program.  */
 434   if (! EQ (Vinvocation_directory, Qnil))
 435     name_len += strlen (SDATA (Vinvocation_directory));
 436   name_len += strlen (SDATA (Vinvocation_name));
 437
 438   /* This malloc will not be freed, but it is only done once, and hopefully
 439      not very large   */
 440   emacs_program = xmalloc (name_len + 1);
 441   emacs_program[0] = '\0';
 442
 443   if (! EQ (Vinvocation_directory, Qnil))
 444     strcpy (emacs_program, SDATA (Vinvocation_directory));
 445   strcat (emacs_program, SDATA (Vinvocation_name));
 446
 447   /* The SM protocol says all callbacks are mandatory, so set up all
 448      here and in the mask passed to SmcOpenConnection.  */
 449   callbacks.save_yourself.callback = smc_save_yourself_CB;
 450   callbacks.save_yourself.client_data = 0;
 451   callbacks.die.callback = smc_die_CB;
 452   callbacks.die.client_data = 0;
 453   callbacks.save_complete.callback = smc_save_complete_CB;
 454   callbacks.save_complete.client_data = 0;
 455   callbacks.shutdown_cancelled.callback = smc_shutdown_cancelled_CB;
 456   callbacks.shutdown_cancelled.client_data = 0;
 457
 458   /* Set error handlers.  */
 459   SmcSetErrorHandler (smc_error_handler);
 460   IceSetErrorHandler (ice_error_handler);
 461   IceSetIOErrorHandler (ice_io_error_handler);
 462
 463   /* Install callback for when connection status changes.  */
 464   IceAddConnectionWatch (ice_conn_watch_CB, 0);
 465
 466   /* Open the connection to the session manager.  A failure is not
 467      critical, it usually means that no session manager is running.
 468      The errorstring is here for debugging.  */
 469   smc_conn = SmcOpenConnection (NULL, NULL, 1, 0,
 470                                 (SmcSaveYourselfProcMask|
 471                                  SmcDieProcMask|
 472                                  SmcSaveCompleteProcMask|
 473                                  SmcShutdownCancelledProcMask),
 474                                 &callbacks,
 475                                 previous_id,
 476                                 &client_id,
 477                                 SM_ERRORSTRING_LEN,
 478                                 errorstring);
 479
 480   if (smc_conn != 0)
 481     {
 482       Vx_session_id = make_string (client_id, strlen (client_id));
 483
 484 #ifdef USE_GTK
 485       /* GTK creats a leader window by itself, but we need to tell
 486          it about our client_id.  */
 487       gdk_set_sm_client_id (client_id);
 488 #else
 489       create_client_leader_window (dpyinfo, client_id);
 490 #endif
 491     }
 492 }
 493
 494 /* Ensure that the session manager is not contacted again. */
 495
 496 void
 497 x_session_close ()
 498 {
 499   ice_fd = -1;
 500 }
 501
 502
 503 DEFUN ("handle-save-session", Fhandle_save_session,
 504        Shandle_save_session, 1, 1, "e",
 505        doc: /* Handle the save_yourself event from a session manager.
 506 A session manager can tell Emacs that the window system is shutting down
 507 by sending Emacs a save_yourself message.  Emacs executes this function when
 508 such an event occurs.  This function then executes `emacs-session-save'.
 509 After that, this function informs the session manager that it can continue
 510 or abort shutting down the window system depending on the return value
 511 from `emacs-session-save'  If the return value is non-nil the session manager
 512 is told to abort the window system shutdown.
 513
 514 Do not call this function yourself. */)
 515      (event)
 516      Lisp_Object event;
 517 {
 518   /* Check doing_interact so that we don't do anything if someone called
 519      this at the wrong time. */
 520   if (doing_interact)
 521     {
 522       Bool cancel_shutdown = False;
 523
 524       cancel_shutdown = ! EQ (call0 (intern ("emacs-session-save")), Qnil);
 525
 526       SmcInteractDone (smc_conn, cancel_shutdown);
 527       SmcSaveYourselfDone (smc_conn, True);
 528
 529       doing_interact = False;
 530     }
 531
 532   return Qnil;
 533 }
 534
 535 \f
 536 /***********************************************************************
 537                             Initialization
 538  ***********************************************************************/
 539 void
 540 syms_of_xsmfns ()
 541 {
 542   DEFVAR_LISP ("x-session-id", &Vx_session_id,
 543     doc: /* The session id Emacs got from the session manager for this session.
 544 Changing the value does not change the session id used by Emacs.
 545 The value is nil if no session manager is running.
 546 See also `x-session-previous-id', `emacs-save-session-functions',
 547 `emacs-session-save' and `emacs-session-restore'." */);
 548   Vx_session_id = Qnil;
 549
 550   DEFVAR_LISP ("x-session-previous-id", &Vx_session_previous_id,
 551     doc: /* The previous session id Emacs got from session manager.
 552 If Emacs is running on a window system that has a session manager, the
 553 session manager gives Emacs a session id.  It is feasible for Emacs Lisp
 554 code to use the session id to save configuration in, for example, a file
 555 with a file name based on the session id.  If Emacs is running when the
 556 window system is shut down, the session manager remembers that Emacs was
 557 running and saves the session id Emacs had.
 558
 559 When the window system is started again, the session manager restarts
 560 Emacs and hands Emacs the session id it had the last time it was
 561 running.  This is now the previous session id and the value of this
 562 variable.  If configuration was saved in a file as stated above, the
 563 previous session id shall be used to reconstruct the file name.
 564
 565 The session id Emacs has while it is running is in the variable
 566 `x-session-id'.  The value of this variable and `x-session-id' may be the
 567 same, depending on how the session manager works.
 568
 569 See also `emacs-save-session-functions', `emacs-session-save' and
 570 `emacs-session-restore'." */);
 571   Vx_session_previous_id = Qnil;
 572
 573   defsubr (&Shandle_save_session);
 574 }
 575
 576 #endif /* HAVE_X_SM */
 577
 578 /* arch-tag: 56a2c58c-adfa-430a-b772-130abd29fd2e
 579    (do not change this comment) */