src/xsmfns.c

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