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