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 #ifdef HAVE_STRING_H
  28 #include <string.h>
  29 #else
  30 #ifdef HAVE_STRINGS_H
  31 #include <strings.h>
  32 #endif
  33 #endif
  34
  35 #ifdef HAVE_UNISTD_H
  36 #include <unistd.h>
  37 #endif
  38 #ifdef HAVE_STDLIB_H
  39 #include <stdlib.h>
  40 #endif
  41
  42 #include <sys/param.h>
  43 #include <stdio.h>
  44
  45 #include "systime.h"
  46 #include "sysselect.h"
  47 #include "lisp.h"
  48 #include "termhooks.h"
  49 #include "termopts.h"
  50
  51 #ifndef MAXPATHLEN
  52 #define MAXPATHLEN 1024
  53 #endif /* not MAXPATHLEN */
  54
  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 static char *client_id;
  78
  79 /* The full path name to the Emacs program */
  80 static char *emacs_program;
  81
  82 /* The client session id for this session as a lisp object. */
  83
  84 Lisp_Object Vx_session_id;
  85
  86 /* The id we had the previous session.  This is only available if we
  87    have been started by the session manager with SMID_OPT. */
  88
  89 Lisp_Object Vx_session_previous_id;
  90
  91 /* The option we tell the session manager to start Emacs with when
  92    restarting Emacs.  The client_id is appended. */
  93
  94 #define SMID_OPT "--smid="
  95
  96
  97 /* The option to start Emacs without the splash screen when
  98    restarting Emacs. */
  99
 100 #define NOSPLASH_OPT "--no-splash"
 101
 102
 103 /* Handle any messages from the session manager.  If no connection is
 104    open to a session manager, just return 0.
 105    Otherwise returns the number of events stored in buffer BUFP,
 106    which can hold up to *NUMCHARS characters.  At most one event is
 107    stored, a SAVE_SESSION_EVENT. */
 108 int
 109 x_session_check_input (bufp, numchars)
 110      struct input_event *bufp;
 111      int *numchars;
 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 (*numchars > 0 && emacs_event.kind != NO_EVENT)
 146     {
 147       bcopy (&emacs_event, bufp, sizeof (struct input_event));
 148       bufp++;
 149       (*numchars)--;
 150
 151       return 1;
 152     }
 153
 154   return 0;
 155 }
 156
 157 /* Return non-zero if we have a connection to a session manager.*/
 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 static void
 168 smc_interact_CB (smcConn, clientData)
 169      SmcConn smcConn;
 170      SmPointer clientData;
 171 {
 172   doing_interact = True;
 173   emacs_event.kind = SAVE_SESSION_EVENT;
 174 }
 175
 176 /* This is called when the session manager tells us to save ourselves.
 177    We set the required properties so the session manager can restart us,
 178    plus the current working directory property (not mandatory) so we
 179    are started in the correct directory.
 180
 181    If this is a shutdown and we can request to interact with the user,
 182    we do so, because we don't know what the lisp code might do. */
 183 static void
 184 smc_save_yourself_CB (smcConn,
 185                       clientData,
 186                       saveType,
 187                       shutdown,
 188                       interactStyle,
 189                       fast)
 190      SmcConn smcConn;
 191      SmPointer clientData;
 192      int saveType;
 193      Bool shutdown;
 194      int interactStyle;
 195      Bool fast;
 196 {
 197 #define NR_PROPS 5
 198
 199   SmProp *props[NR_PROPS];
 200   SmProp prop_ptr[NR_PROPS];
 201
 202   SmPropValue values[20];
 203   int val_idx = 0;
 204   int props_idx = 0;
 205
 206   char cwd[MAXPATHLEN+1];
 207   char *smid_opt;
 208
 209   /* How to start a new instance of Emacs */
 210   props[props_idx] = &prop_ptr[props_idx];
 211   props[props_idx]->name = SmCloneCommand;
 212   props[props_idx]->type = SmLISTofARRAY8;
 213   props[props_idx]->num_vals = 1;
 214   props[props_idx]->vals = &values[val_idx++];
 215   props[props_idx]->vals[0].length = strlen (emacs_program);
 216   props[props_idx]->vals[0].value = emacs_program;
 217   ++props_idx;
 218
 219   /* The name of the program */
 220   props[props_idx] = &prop_ptr[props_idx];
 221   props[props_idx]->name = SmProgram;
 222   props[props_idx]->type = SmARRAY8;
 223   props[props_idx]->num_vals = 1;
 224   props[props_idx]->vals = &values[val_idx++];
 225   props[props_idx]->vals[0].length = strlen (SDATA (Vinvocation_name));
 226   props[props_idx]->vals[0].value = SDATA (Vinvocation_name);
 227   ++props_idx;
 228
 229   /* How to restart Emacs (i.e.: /path/to/emacs --smid=xxxx --no-splash). */
 230   props[props_idx] = &prop_ptr[props_idx];
 231   props[props_idx]->name = SmRestartCommand;
 232   props[props_idx]->type = SmLISTofARRAY8;
 233   props[props_idx]->num_vals = 3; /* /path/to/emacs, --smid=xxx --no-splash */
 234   props[props_idx]->vals = &values[val_idx];
 235   props[props_idx]->vals[0].length = strlen (emacs_program);
 236   props[props_idx]->vals[0].value = emacs_program;
 237
 238   smid_opt = xmalloc (strlen (SMID_OPT) + strlen (client_id) + 1);
 239   strcpy (smid_opt, SMID_OPT);
 240   strcat (smid_opt, client_id);
 241
 242   props[props_idx]->vals[1].length = strlen (smid_opt);
 243   props[props_idx]->vals[1].value = smid_opt;
 244
 245   props[props_idx]->vals[2].length = strlen (NOSPLASH_OPT);
 246   props[props_idx]->vals[2].value = NOSPLASH_OPT;
 247   val_idx += 3;
 248   ++props_idx;
 249
 250   /* User id */
 251   props[props_idx] = &prop_ptr[props_idx];
 252   props[props_idx]->name = SmUserID;
 253   props[props_idx]->type = SmARRAY8;
 254   props[props_idx]->num_vals = 1;
 255   props[props_idx]->vals = &values[val_idx++];
 256   props[props_idx]->vals[0].length = strlen (SDATA (Vuser_login_name));
 257   props[props_idx]->vals[0].value = SDATA (Vuser_login_name);
 258   ++props_idx;
 259
 260   /* The current directory property, not mandatory */
 261 #ifdef HAVE_GETCWD
 262   if (getcwd (cwd, MAXPATHLEN+1) != 0)
 263 #else
 264   if (getwd (cwd) != 0)
 265 #endif
 266     {
 267       props[props_idx] = &prop_ptr[props_idx];
 268       props[props_idx]->name = SmCurrentDirectory;
 269       props[props_idx]->type = SmARRAY8;
 270       props[props_idx]->num_vals = 1;
 271       props[props_idx]->vals = &values[val_idx++];
 272       props[props_idx]->vals[0].length = strlen (cwd);
 273       props[props_idx]->vals[0].value = cwd;
 274       ++props_idx;
 275     }
 276
 277
 278   SmcSetProperties (smcConn, props_idx, props);
 279
 280   xfree (smid_opt);
 281
 282   /* See if we maybe shall interact with the user. */
 283   if (interactStyle != SmInteractStyleAny
 284       || ! shutdown
 285       || saveType == SmSaveLocal
 286       || ! SmcInteractRequest (smcConn, SmDialogNormal, smc_interact_CB, 0))
 287     {
 288       /* No interaction, we are done saving ourself. */
 289       SmcSaveYourselfDone (smcConn, True);
 290     }
 291 }
 292
 293 /* According to the SM specification, this shall close the connection */
 294 static void
 295 smc_die_CB (smcConn, clientData)
 296      SmcConn smcConn;
 297      SmPointer clientData;
 298 {
 299   SmcCloseConnection (smcConn, 0, 0);
 300   ice_fd = -1;
 301 }
 302
 303 /* We don't use the next two but they are mandatory, leave them empty.
 304    According to the SM specification, we should not interact with the
 305    user between smc_save_yourself_CB is called and until smc_save_complete_CB
 306    is called.  It seems like a lot of job to implement this and it doesn't
 307    even seem necessary. */
 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 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 static void
 376 ice_conn_watch_CB (iceConn, clientData, opening, watchData)
 377      IceConn iceConn;
 378      IcePointer clientData;
 379      Bool opening;
 380      IcePointer *watchData;
 381 {
 382   if (! opening)
 383     {
 384       ice_fd = -1;
 385       return;
 386     }
 387
 388   ice_fd = IceConnectionNumber (iceConn);
 389 #ifndef F_SETOWN_BUG
 390 #ifdef F_SETOWN
 391 #ifdef F_SETOWN_SOCK_NEG
 392   /* stdin is a socket here */
 393   fcntl (ice_fd, F_SETOWN, -getpid ());
 394 #else /* ! defined (F_SETOWN_SOCK_NEG) */
 395   fcntl (ice_fd, F_SETOWN, getpid ());
 396 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
 397 #endif /* ! defined (F_SETOWN) */
 398 #endif /* F_SETOWN_BUG */
 399
 400 #ifdef SIGIO
 401   if (interrupt_input)
 402     init_sigio (ice_fd);
 403 #endif /* ! defined (SIGIO) */
 404 }
 405
 406 /* Try to open a connection to the session manager. */
 407 void
 408 x_session_initialize ()
 409 {
 410 #define SM_ERRORSTRING_LEN 512
 411   char errorstring[SM_ERRORSTRING_LEN];
 412   char* previous_id = NULL;
 413   SmcCallbacks callbacks;
 414   int  name_len = 0;
 415
 416   /* Check if we where started by the session manager.  If so, we will
 417      have a previous id. */
 418   if (! EQ (Vx_session_previous_id, Qnil) && STRINGP (Vx_session_previous_id))
 419     previous_id = SDATA (Vx_session_previous_id);
 420
 421   /* Construct the path to the Emacs program. */
 422   if (! EQ (Vinvocation_directory, Qnil))
 423     name_len += strlen (SDATA (Vinvocation_directory));
 424   name_len += strlen (SDATA (Vinvocation_name));
 425
 426   /* This malloc will not be freed, but it is only done once, and hopefully
 427      not very large  */
 428   emacs_program = xmalloc (name_len + 1);
 429   emacs_program[0] = '\0';
 430
 431   if (! EQ (Vinvocation_directory, Qnil))
 432     strcpy (emacs_program, SDATA (Vinvocation_directory));
 433   strcat (emacs_program, SDATA (Vinvocation_name));
 434
 435   /* The SM protocol says all callbacks are mandatory, so set up all
 436      here and in the mask passed to SmcOpenConnection */
 437   callbacks.save_yourself.callback = smc_save_yourself_CB;
 438   callbacks.save_yourself.client_data = 0;
 439   callbacks.die.callback = smc_die_CB;
 440   callbacks.die.client_data = 0;
 441   callbacks.save_complete.callback = smc_save_complete_CB;
 442   callbacks.save_complete.client_data = 0;
 443   callbacks.shutdown_cancelled.callback = smc_shutdown_cancelled_CB;
 444   callbacks.shutdown_cancelled.client_data = 0;
 445
 446   /* Set error handlers. */
 447   SmcSetErrorHandler (smc_error_handler);
 448   IceSetErrorHandler (ice_error_handler);
 449   IceSetIOErrorHandler (ice_io_error_handler);
 450
 451   /* Install callback for when connection status changes. */
 452   IceAddConnectionWatch (ice_conn_watch_CB, 0);
 453
 454   /* Open the connection to the session manager.  A failure is not
 455      critical, it usually means that no session manager is running.
 456      The errorstring is here for debugging. */
 457   smc_conn = SmcOpenConnection (NULL, NULL, 1, 0,
 458                                 (SmcSaveYourselfProcMask|
 459                                  SmcDieProcMask|
 460                                  SmcSaveCompleteProcMask|
 461                                  SmcShutdownCancelledProcMask),
 462                                 &callbacks,
 463                                 previous_id,
 464                                 &client_id,
 465                                 SM_ERRORSTRING_LEN,
 466                                 errorstring);
 467
 468   if (smc_conn != 0)
 469     Vx_session_id = make_string (client_id, strlen (client_id));
 470 }
 471
 472
 473 DEFUN ("handle-save-session", Fhandle_save_session,
 474        Shandle_save_session, 1, 1, "e",
 475        doc: /* Handle the save_yourself event from a session manager.
 476 A session manager can tell Emacs that the window system is shutting down
 477 by sending Emacs a save_yourself message.  Emacs executes this function when
 478 such an event occurs.  This function then executes `emacs-session-save'.
 479 After that, this function informs the session manager that it can continue
 480 or abort shutting down the window system depending on the return value
 481 from `emacs-session-save'  If the return value is non-nil the session manager
 482 is told to abort the window system shutdown.
 483
 484 Do not call this function yourself. */)
 485      (event)
 486      Lisp_Object event;
 487 {
 488   /* Check doing_interact so that we don't do anything if someone called
 489      this at the wrong time. */
 490   if (doing_interact)
 491     {
 492       Bool cancel_shutdown = False;
 493
 494       cancel_shutdown = ! EQ (call0 (intern ("emacs-session-save")), Qnil);
 495
 496       SmcInteractDone (smc_conn, cancel_shutdown);
 497       SmcSaveYourselfDone (smc_conn, True);
 498
 499       doing_interact = False;
 500     }
 501
 502   return Qnil;
 503 }
 504
 505 \f
 506 /***********************************************************************
 507                             Initialization
 508  ***********************************************************************/
 509 void
 510 syms_of_xsmfns ()
 511 {
 512   DEFVAR_LISP ("x-session-id", &Vx_session_id,
 513     doc: /* The session id Emacs got from the session manager for this session.
 514 Changing the value does not change the session id used by Emacs.
 515 The value is nil if no session manager is running.
 516 See also `x-session-previous-id', `emacs-save-session-functions',
 517 `emacs-session-save' and `emacs-session-restore'." */);
 518   Vx_session_id = Qnil;
 519
 520   DEFVAR_LISP ("x-session-previous-id", &Vx_session_previous_id,
 521     doc: /* The previous session id Emacs got from session manager.
 522 If Emacs is running on a window system that has a session manager, the
 523 session manager gives Emacs a session id.  It is feasible for Emacs lisp
 524 code to use the session id to save configuration in, for example, a file
 525 with a file name based on the session id.  If Emacs is running when the
 526 window system is shut down, the session manager remembers that Emacs was
 527 running and saves the session id Emacs had.
 528
 529 When the window system is started again, the session manager restarts
 530 Emacs and hands Emacs the session id it had the last time it was
 531 running.  This is now the previous session id and the value of this
 532 variable.  If configuration was saved in a file as stated above, the
 533 previous session id shall be used to reconstruct the file name.
 534
 535 The session id Emacs has while it is running is in the variable
 536 `x-session-id'.  The value of this variable and `x-session-id' may be the
 537 same, depending on how the session manager works.
 538
 539 See also `emacs-save-session-functions', `emacs-session-save' and
 540 `emacs-session-restore'." */);
 541   Vx_session_previous_id = Qnil;
 542
 543   defsubr (&Shandle_save_session);
 544 }
 545
 546 #endif /* HAVE_X_SM */