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