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