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 "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 static char *client_id;
  82
  83 /* The full path name to the Emacs program */
  84 static char *emacs_program;
  85
  86 /* The client session id for this session as a lisp object. */
  87
  88 Lisp_Object Vx_session_id;
  89
  90 /* The id we had the previous session.  This is only available if we
  91    have been started by the session manager with SMID_OPT. */
  92
  93 Lisp_Object Vx_session_previous_id;
  94
  95 /* The option we tell the session manager to start Emacs with when
  96    restarting Emacs.  The client_id is appended. */
  97
  98 #define SMID_OPT "--smid="
  99
 100
 101 /* The option to start Emacs without the splash screen when
 102    restarting Emacs. */
 103
 104 #define NOSPLASH_OPT "--no-splash"
 105
 106
 107 /* Handle any messages from the session manager.  If no connection is
 108    open to a session manager, just return 0.
 109    Otherwise returns the number of events stored in buffer BUFP,
 110    which can hold up to *NUMCHARS characters.  At most one event is
 111    stored, a SAVE_SESSION_EVENT. */
 112 int
 113 x_session_check_input (bufp, numchars)
 114      struct input_event *bufp;
 115      int *numchars;
 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 (*numchars > 0 && emacs_event.kind != NO_EVENT)
 150     {
 151       bcopy (&emacs_event, bufp, sizeof (struct input_event));
 152       bufp++;
 153       (*numchars)--;
 154
 155       return 1;
 156     }
 157
 158   return 0;
 159 }
 160
 161 /* Return non-zero if we have a connection to a session manager.*/
 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 static void
 172 smc_interact_CB (smcConn, clientData)
 173      SmcConn smcConn;
 174      SmPointer clientData;
 175 {
 176   doing_interact = True;
 177   emacs_event.kind = SAVE_SESSION_EVENT;
 178 }
 179
 180 /* This is called when the session manager tells us to save ourselves.
 181    We set the required properties so the session manager can restart us,
 182    plus the current working directory property (not mandatory) so we
 183    are started in the correct directory.
 184
 185    If this is a shutdown and we can request to interact with the user,
 186    we do so, because we don't know what the lisp code might do. */
 187 static void
 188 smc_save_yourself_CB (smcConn,
 189                       clientData,
 190                       saveType,
 191                       shutdown,
 192                       interactStyle,
 193                       fast)
 194      SmcConn smcConn;
 195      SmPointer clientData;
 196      int saveType;
 197      Bool shutdown;
 198      int interactStyle;
 199      Bool fast;
 200 {
 201 #define NR_PROPS 5
 202
 203   SmProp *props[NR_PROPS];
 204   SmProp prop_ptr[NR_PROPS];
 205
 206   SmPropValue values[20];
 207   int val_idx = 0;
 208   int props_idx = 0;
 209
 210   char cwd[MAXPATHLEN+1];
 211   char *smid_opt;
 212
 213   /* How to start a new instance of Emacs */
 214   props[props_idx] = &prop_ptr[props_idx];
 215   props[props_idx]->name = SmCloneCommand;
 216   props[props_idx]->type = SmLISTofARRAY8;
 217   props[props_idx]->num_vals = 1;
 218   props[props_idx]->vals = &values[val_idx++];
 219   props[props_idx]->vals[0].length = strlen (emacs_program);
 220   props[props_idx]->vals[0].value = emacs_program;
 221   ++props_idx;
 222
 223   /* The name of the program */
 224   props[props_idx] = &prop_ptr[props_idx];
 225   props[props_idx]->name = SmProgram;
 226   props[props_idx]->type = SmARRAY8;
 227   props[props_idx]->num_vals = 1;
 228   props[props_idx]->vals = &values[val_idx++];
 229   props[props_idx]->vals[0].length = strlen (SDATA (Vinvocation_name));
 230   props[props_idx]->vals[0].value = SDATA (Vinvocation_name);
 231   ++props_idx;
 232
 233   /* How to restart Emacs (i.e.: /path/to/emacs --smid=xxxx --no-splash). */
 234   props[props_idx] = &prop_ptr[props_idx];
 235   props[props_idx]->name = SmRestartCommand;
 236   props[props_idx]->type = SmLISTofARRAY8;
 237   props[props_idx]->num_vals = 3; /* /path/to/emacs, --smid=xxx --no-splash */
 238   props[props_idx]->vals = &values[val_idx];
 239   props[props_idx]->vals[0].length = strlen (emacs_program);
 240   props[props_idx]->vals[0].value = emacs_program;
 241
 242   smid_opt = xmalloc (strlen (SMID_OPT) + strlen (client_id) + 1);
 243   strcpy (smid_opt, SMID_OPT);
 244   strcat (smid_opt, client_id);
 245
 246   props[props_idx]->vals[1].length = strlen (smid_opt);
 247   props[props_idx]->vals[1].value = smid_opt;
 248
 249   props[props_idx]->vals[2].length = strlen (NOSPLASH_OPT);
 250   props[props_idx]->vals[2].value = NOSPLASH_OPT;
 251   val_idx += 3;
 252   ++props_idx;
 253
 254   /* User id */
 255   props[props_idx] = &prop_ptr[props_idx];
 256   props[props_idx]->name = SmUserID;
 257   props[props_idx]->type = SmARRAY8;
 258   props[props_idx]->num_vals = 1;
 259   props[props_idx]->vals = &values[val_idx++];
 260   props[props_idx]->vals[0].length = strlen (SDATA (Vuser_login_name));
 261   props[props_idx]->vals[0].value = SDATA (Vuser_login_name);
 262   ++props_idx;
 263
 264   /* The current directory property, not mandatory */
 265 #ifdef HAVE_GETCWD
 266   if (getcwd (cwd, MAXPATHLEN+1) != 0)
 267 #else
 268   if (getwd (cwd) != 0)
 269 #endif
 270     {
 271       props[props_idx] = &prop_ptr[props_idx];
 272       props[props_idx]->name = SmCurrentDirectory;
 273       props[props_idx]->type = SmARRAY8;
 274       props[props_idx]->num_vals = 1;
 275       props[props_idx]->vals = &values[val_idx++];
 276       props[props_idx]->vals[0].length = strlen (cwd);
 277       props[props_idx]->vals[0].value = cwd;
 278       ++props_idx;
 279     }
 280
 281
 282   SmcSetProperties (smcConn, props_idx, props);
 283
 284   xfree (smid_opt);
 285
 286   /* See if we maybe shall interact with the user. */
 287   if (interactStyle != SmInteractStyleAny
 288       || ! shutdown
 289       || saveType == SmSaveLocal
 290       || ! SmcInteractRequest (smcConn, SmDialogNormal, smc_interact_CB, 0))
 291     {
 292       /* No interaction, we are done saving ourself. */
 293       SmcSaveYourselfDone (smcConn, True);
 294     }
 295 }
 296
 297 /* According to the SM specification, this shall close the connection */
 298 static void
 299 smc_die_CB (smcConn, clientData)
 300      SmcConn smcConn;
 301      SmPointer clientData;
 302 {
 303   SmcCloseConnection (smcConn, 0, 0);
 304   ice_fd = -1;
 305 }
 306
 307 /* We don't use the next two but they are mandatory, leave them empty.
 308    According to the SM specification, we should not interact with the
 309    user between smc_save_yourself_CB is called and until smc_save_complete_CB
 310    is called.  It seems like a lot of job to implement this and it doesn't
 311    even seem necessary. */
 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 static void
 331 smc_error_handler (smcConn,
 332                    swap,
 333                    offendingMinorOpcode,
 334                    offendingSequence,
 335                    errorClass,
 336                    severity,
 337                    values)
 338      SmcConn smcConn;
 339      Bool swap;
 340      int offendingMinorOpcode;
 341      unsigned long offendingSequence;
 342      int errorClass;
 343      int severity;
 344      SmPointer values;
 345 {
 346   /* Empty */
 347 }
 348
 349 static void
 350 ice_error_handler (iceConn,
 351                    swap,
 352                    offendingMinorOpcode,
 353                    offendingSequence,
 354                    errorClass,
 355                    severity,
 356                    values)
 357      IceConn iceConn;
 358      Bool swap;
 359      int offendingMinorOpcode;
 360      unsigned long offendingSequence;
 361      int errorClass;
 362      int severity;
 363      IcePointer values;
 364 {
 365   /* Empty */
 366 }
 367
 368
 369 static void
 370 ice_io_error_handler (iceConn)
 371      IceConn iceConn;
 372 {
 373   /* Connection probably gone. */
 374   ice_fd = -1;
 375 }
 376
 377 /* This is called when the ICE connection is created or closed.  The SM library
 378    uses ICE as it transport protocol. */
 379 static void
 380 ice_conn_watch_CB (iceConn, clientData, opening, watchData)
 381      IceConn iceConn;
 382      IcePointer clientData;
 383      Bool opening;
 384      IcePointer *watchData;
 385 {
 386   if (! opening)
 387     {
 388       ice_fd = -1;
 389       return;
 390     }
 391
 392   ice_fd = IceConnectionNumber (iceConn);
 393 #ifndef F_SETOWN_BUG
 394 #ifdef F_SETOWN
 395 #ifdef F_SETOWN_SOCK_NEG
 396   /* stdin is a socket here */
 397   fcntl (ice_fd, F_SETOWN, -getpid ());
 398 #else /* ! defined (F_SETOWN_SOCK_NEG) */
 399   fcntl (ice_fd, F_SETOWN, getpid ());
 400 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
 401 #endif /* ! defined (F_SETOWN) */
 402 #endif /* F_SETOWN_BUG */
 403
 404 #ifdef SIGIO
 405   if (interrupt_input)
 406     init_sigio (ice_fd);
 407 #endif /* ! defined (SIGIO) */
 408 }
 409
 410 /* Create the client leader window.  */
 411 static void
 412 create_client_leader_window (dpyinfo, client_id)
 413      struct x_display_info *dpyinfo;
 414      char *client_id;
 415 {
 416   Window w;
 417   XClassHint class_hints;
 418   Atom sm_id;
 419
 420   w = XCreateSimpleWindow (dpyinfo->display,
 421                            dpyinfo->root_window,
 422                            -1, -1, 1, 1,
 423                            CopyFromParent, CopyFromParent, CopyFromParent);
 424
 425   class_hints.res_name = (char *) SDATA (Vx_resource_name);
 426   class_hints.res_class = (char *) SDATA (Vx_resource_class);
 427   XSetClassHint (dpyinfo->display, w, &class_hints);
 428   XStoreName (dpyinfo->display, w, class_hints.res_name);
 429
 430   sm_id = XInternAtom (dpyinfo->display, "SM_CLIENT_ID", False);
 431   XChangeProperty (dpyinfo->display, w, sm_id, XA_STRING, 8, PropModeReplace,
 432                    client_id, strlen (client_id));
 433
 434   dpyinfo->client_leader_window = w;
 435 }
 436
 437 /* Try to open a connection to the session manager. */
 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) */