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