1/* Session management module for systems which understand the X Session
2   management protocol.
3   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
4
5This file is part of GNU Emacs.
6
7GNU Emacs is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2, or (at your option)
10any later version.
11
12GNU Emacs is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GNU Emacs; see the file COPYING.  If not, write to
19the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20Boston, MA 02110-1301, 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 "lisp.h"
49#include "systime.h"
50#include "sysselect.h"
51#include "termhooks.h"
52#include "termopts.h"
53#include "xterm.h"
54
55/* The user login name.  */
56
57extern Lisp_Object Vuser_login_name;
58
59/* This is the event used when SAVE_SESSION_EVENT occurs.  */
60
61static struct input_event emacs_event;
62
63/* The descriptor that we use to check for data from the session manager.  */
64
65static int ice_fd = -1;
66
67/* A flag that says if we are in shutdown interactions or not.  */
68
69static int doing_interact = False;
70
71/* The session manager object for the session manager connection.  */
72
73static SmcConn smc_conn;
74
75/* The client session id for this session.  */
76
77static char *client_id;
78
79/* The full path name to the Emacs program.  */
80
81static char *emacs_program;
82
83/* The client session id for this session as a lisp object.  */
84
85Lisp_Object Vx_session_id;
86
87/* The id we had the previous session.  This is only available if we
88   have been started by the session manager with SMID_OPT.  */
89
90Lisp_Object Vx_session_previous_id;
91
92/* The option we tell the session manager to start Emacs with when
93   restarting Emacs.  The client_id is appended.  */
94
95#define SMID_OPT "--smid="
96
97
98/* The option to start Emacs without the splash screen when
99   restarting Emacs.  */
100
101#define NOSPLASH_OPT "--no-splash"
102
103
104/* Handle any messages from the session manager.  If no connection is
105   open to a session manager, just return 0.
106   Otherwise returns 1 if SAVE_SESSION_EVENT is stored in buffer BUFP.  */
107
108int
109x_session_check_input (bufp)
110     struct input_event *bufp;
111{
112  SELECT_TYPE read_fds;
113  EMACS_TIME tmout;
114
115  if (ice_fd == -1) return 0;
116
117  FD_ZERO (&read_fds);
118  FD_SET (ice_fd, &read_fds);
119
120  tmout.tv_sec = 0;
121  tmout.tv_usec = 0;
122
123  /* Reset this so wo can check kind after callbacks have been called by
124     IceProcessMessages.  The smc_interact_CB sets the kind to
125     SAVE_SESSION_EVENT, but we don't know beforehand if that callback
126     will be called.  */
127  emacs_event.kind = NO_EVENT;
128
129  if (select (ice_fd+1, &read_fds,
130              (SELECT_TYPE *)0, (SELECT_TYPE *)0, &tmout) < 0)
131    {
132      ice_fd = -1;
133      return 0;
134    }
135
136
137  if (FD_ISSET (ice_fd, &read_fds))
138    IceProcessMessages (SmcGetIceConnection (smc_conn),
139                        (IceReplyWaitInfo *)0, (Bool *)0);
140
141
142  /* Check if smc_interact_CB was called and we shall generate a
143     SAVE_SESSION_EVENT.  */
144  if (emacs_event.kind == NO_EVENT)
145    return 0;
146
147  bcopy (&emacs_event, bufp, sizeof (struct input_event));
148  return 1;
149}
150
151/* Return non-zero if we have a connection to a session manager.  */
152
153int
154x_session_have_connection ()
155{
156  return ice_fd != -1;
157}
158
159/* This is called when the session manager says it is OK to interact with the
160   user.  Here we set the kind to SAVE_SESSION_EVENT so an event is generated.
161   Then lisp code can interact with the user.  */
162
163static void
164smc_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
180static void
181smc_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 = NULL;
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  cwd = get_current_dir_name ();
258
259  if (cwd)
260    {
261      props[props_idx] = &prop_ptr[props_idx];
262      props[props_idx]->name = SmCurrentDirectory;
263      props[props_idx]->type = SmARRAY8;
264      props[props_idx]->num_vals = 1;
265      props[props_idx]->vals = &values[val_idx++];
266      props[props_idx]->vals[0].length = strlen (cwd);
267      props[props_idx]->vals[0].value = cwd;
268      ++props_idx;
269    }
270
271
272  SmcSetProperties (smcConn, props_idx, props);
273
274  xfree (smid_opt);
275
276  if (cwd)
277    free (cwd);
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
292static void
293smc_die_CB (smcConn, clientData)
294     SmcConn smcConn;
295     SmPointer clientData;
296{
297  SmcCloseConnection (smcConn, 0, 0);
298  ice_fd = -1;
299}
300
301/* We don't use the next two but they are mandatory, leave them empty.
302   According to the SM specification, we should not interact with the
303   user between smc_save_yourself_CB is called and until smc_save_complete_CB
304   is called.  It seems like a lot of job to implement this and it doesn't
305   even seem necessary.  */
306
307static void
308smc_save_complete_CB (smcConn, clientData)
309     SmcConn smcConn;
310     SmPointer clientData;
311{
312  /* Empty */
313}
314
315static void
316smc_shutdown_cancelled_CB (smcConn, clientData)
317     SmcConn smcConn;
318     SmPointer clientData;
319{
320  /* Empty */
321}
322
323/* Error handlers for SM and ICE.  We don't want to exit Emacs just
324   because there is some error in the session management.  */
325
326static void
327smc_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
345static void
346ice_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
365static void
366ice_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
376static void
377ice_conn_watch_CB (iceConn, clientData, opening, watchData)
378     IceConn iceConn;
379     IcePointer clientData;
380     Bool opening;
381     IcePointer *watchData;
382{
383  if (! opening)
384    {
385      ice_fd = -1;
386      return;
387    }
388
389  ice_fd = IceConnectionNumber (iceConn);
390#ifndef F_SETOWN_BUG
391#ifdef F_SETOWN
392#ifdef F_SETOWN_SOCK_NEG
393  /* stdin is a socket here */
394  fcntl (ice_fd, F_SETOWN, -getpid ());
395#else /* ! defined (F_SETOWN_SOCK_NEG) */
396  fcntl (ice_fd, F_SETOWN, getpid ());
397#endif /* ! defined (F_SETOWN_SOCK_NEG) */
398#endif /* ! defined (F_SETOWN) */
399#endif /* F_SETOWN_BUG */
400
401#ifdef SIGIO
402  if (interrupt_input)
403    init_sigio (ice_fd);
404#endif /* ! defined (SIGIO) */
405}
406
407/* Create the client leader window.  */
408
409static void
410create_client_leader_window (dpyinfo, client_id)
411     struct x_display_info *dpyinfo;
412     char *client_id;
413{
414  Window w;
415  XClassHint class_hints;
416  Atom sm_id;
417
418  w = XCreateSimpleWindow (dpyinfo->display,
419                           dpyinfo->root_window,
420                           -1, -1, 1, 1,
421                           CopyFromParent, CopyFromParent, CopyFromParent);
422
423  class_hints.res_name = (char *) SDATA (Vx_resource_name);
424  class_hints.res_class = (char *) SDATA (Vx_resource_class);
425  XSetClassHint (dpyinfo->display, w, &class_hints);
426  XStoreName (dpyinfo->display, w, class_hints.res_name);
427
428  sm_id = XInternAtom (dpyinfo->display, "SM_CLIENT_ID", False);
429  XChangeProperty (dpyinfo->display, w, sm_id, XA_STRING, 8, PropModeReplace,
430                   client_id, strlen (client_id));
431
432  dpyinfo->client_leader_window = w;
433}
434
435/* Try to open a connection to the session manager.  */
436
437void
438x_session_initialize (dpyinfo)
439     struct x_display_info *dpyinfo;
440{
441#define SM_ERRORSTRING_LEN 512
442  char errorstring[SM_ERRORSTRING_LEN];
443  char* previous_id = NULL;
444  SmcCallbacks callbacks;
445  int  name_len = 0;
446
447  /* Check if we where started by the session manager.  If so, we will
448     have a previous id.  */
449  if (! EQ (Vx_session_previous_id, Qnil) && STRINGP (Vx_session_previous_id))
450    previous_id = SDATA (Vx_session_previous_id);
451
452  /* Construct the path to the Emacs program.  */
453  if (! EQ (Vinvocation_directory, Qnil))
454    name_len += strlen (SDATA (Vinvocation_directory));
455  name_len += strlen (SDATA (Vinvocation_name));
456
457  /* This malloc will not be freed, but it is only done once, and hopefully
458     not very large   */
459  emacs_program = xmalloc (name_len + 1);
460  emacs_program[0] = '\0';
461
462  if (! EQ (Vinvocation_directory, Qnil))
463    strcpy (emacs_program, SDATA (Vinvocation_directory));
464  strcat (emacs_program, SDATA (Vinvocation_name));
465
466  /* The SM protocol says all callbacks are mandatory, so set up all
467     here and in the mask passed to SmcOpenConnection.  */
468  callbacks.save_yourself.callback = smc_save_yourself_CB;
469  callbacks.save_yourself.client_data = 0;
470  callbacks.die.callback = smc_die_CB;
471  callbacks.die.client_data = 0;
472  callbacks.save_complete.callback = smc_save_complete_CB;
473  callbacks.save_complete.client_data = 0;
474  callbacks.shutdown_cancelled.callback = smc_shutdown_cancelled_CB;
475  callbacks.shutdown_cancelled.client_data = 0;
476
477  /* Set error handlers.  */
478  SmcSetErrorHandler (smc_error_handler);
479  IceSetErrorHandler (ice_error_handler);
480  IceSetIOErrorHandler (ice_io_error_handler);
481
482  /* Install callback for when connection status changes.  */
483  IceAddConnectionWatch (ice_conn_watch_CB, 0);
484
485  /* Open the connection to the session manager.  A failure is not
486     critical, it usually means that no session manager is running.
487     The errorstring is here for debugging.  */
488  smc_conn = SmcOpenConnection (NULL, NULL, 1, 0,
489                                (SmcSaveYourselfProcMask|
490                                 SmcDieProcMask|
491                                 SmcSaveCompleteProcMask|
492                                 SmcShutdownCancelledProcMask),
493                                &callbacks,
494                                previous_id,
495                                &client_id,
496                                SM_ERRORSTRING_LEN,
497                                errorstring);
498
499  if (smc_conn != 0)
500    {
501      Vx_session_id = make_string (client_id, strlen (client_id));
502
503#ifdef USE_GTK
504      /* GTK creats a leader window by itself, but we need to tell
505         it about our client_id.  */
506      gdk_set_sm_client_id (client_id);
507#else
508      create_client_leader_window (dpyinfo, client_id);
509#endif
510    }
511}
512
513
514DEFUN ("handle-save-session", Fhandle_save_session,
515       Shandle_save_session, 1, 1, "e",
516       doc: /* Handle the save_yourself event from a session manager.
517A session manager can tell Emacs that the window system is shutting down
518by sending Emacs a save_yourself message.  Emacs executes this function when
519such an event occurs.  This function then executes `emacs-session-save'.
520After that, this function informs the session manager that it can continue
521or abort shutting down the window system depending on the return value
522from `emacs-session-save'  If the return value is non-nil the session manager
523is told to abort the window system shutdown.
524
525Do not call this function yourself. */)
526     (event)
527     Lisp_Object event;
528{
529  /* Check doing_interact so that we don't do anything if someone called
530     this at the wrong time. */
531  if (doing_interact)
532    {
533      Bool cancel_shutdown = False;
534
535      cancel_shutdown = ! EQ (call0 (intern ("emacs-session-save")), Qnil);
536
537      SmcInteractDone (smc_conn, cancel_shutdown);
538      SmcSaveYourselfDone (smc_conn, True);
539
540      doing_interact = False;
541    }
542
543  return Qnil;
544}
545
546
547/***********************************************************************
548			    Initialization
549 ***********************************************************************/
550void
551syms_of_xsmfns ()
552{
553  DEFVAR_LISP ("x-session-id", &Vx_session_id,
554    doc: /* The session id Emacs got from the session manager for this session.
555Changing the value does not change the session id used by Emacs.
556The value is nil if no session manager is running.
557See also `x-session-previous-id', `emacs-save-session-functions',
558`emacs-session-save' and `emacs-session-restore'." */);
559  Vx_session_id = Qnil;
560
561  DEFVAR_LISP ("x-session-previous-id", &Vx_session_previous_id,
562    doc: /* The previous session id Emacs got from session manager.
563If Emacs is running on a window system that has a session manager, the
564session manager gives Emacs a session id.  It is feasible for Emacs Lisp
565code to use the session id to save configuration in, for example, a file
566with a file name based on the session id.  If Emacs is running when the
567window system is shut down, the session manager remembers that Emacs was
568running and saves the session id Emacs had.
569
570When the window system is started again, the session manager restarts
571Emacs and hands Emacs the session id it had the last time it was
572running.  This is now the previous session id and the value of this
573variable.  If configuration was saved in a file as stated above, the
574previous session id shall be used to reconstruct the file name.
575
576The session id Emacs has while it is running is in the variable
577`x-session-id'.  The value of this variable and `x-session-id' may be the
578same, depending on how the session manager works.
579
580See also `emacs-save-session-functions', `emacs-session-save' and
581`emacs-session-restore'." */);
582  Vx_session_previous_id = Qnil;
583
584  defsubr (&Shandle_save_session);
585}
586
587#endif /* HAVE_X_SM */
588
589/* arch-tag: 56a2c58c-adfa-430a-b772-130abd29fd2e
590   (do not change this comment) */
591