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