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