src/xsmfns.c

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