*** empty log message ***
[emacs.git] / src / xsmfns.c
blob4c250fecf006d5872330278d01c8be0163c7afd6
1 /* Session management module for systems which understand the X Session
2 management protocol.
3 Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
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.
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.
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., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
22 #include <config.h>
24 #ifdef HAVE_X_SM
26 #include <X11/SM/SMlib.h>
27 #include <X11/Xlib.h>
28 #include <X11/Xutil.h>
30 #ifdef HAVE_STRING_H
31 #include <string.h>
32 #else
33 #ifdef HAVE_STRINGS_H
34 #include <strings.h>
35 #endif
36 #endif
38 #ifdef HAVE_UNISTD_H
39 #include <unistd.h>
40 #endif
41 #ifdef HAVE_STDLIB_H
42 #include <stdlib.h>
43 #endif
45 #include <sys/param.h>
46 #include <stdio.h>
48 #include "lisp.h"
49 #include "systime.h"
50 #include "sysselect.h"
51 #include "termhooks.h"
52 #include "termopts.h"
53 #include "xterm.h"
55 /* The user login name. */
57 extern Lisp_Object Vuser_login_name;
59 /* This is the event used when SAVE_SESSION_EVENT occurs. */
61 static struct input_event emacs_event;
63 /* The descriptor that we use to check for data from the session manager. */
65 static int ice_fd = -1;
67 /* A flag that says if we are in shutdown interactions or not. */
69 static int doing_interact = False;
71 /* The session manager object for the session manager connection. */
73 static SmcConn smc_conn;
75 /* The client session id for this session. */
77 static char *client_id;
79 /* The full path name to the Emacs program. */
81 static char *emacs_program;
83 /* The client session id for this session as a lisp object. */
85 Lisp_Object Vx_session_id;
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. */
90 Lisp_Object Vx_session_previous_id;
92 /* The option we tell the session manager to start Emacs with when
93 restarting Emacs. The client_id is appended. */
95 #define SMID_OPT "--smid="
98 /* The option to start Emacs without the splash screen when
99 restarting Emacs. */
101 #define NOSPLASH_OPT "--no-splash"
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. */
109 x_session_check_input (bufp)
110 struct input_event *bufp;
112 SELECT_TYPE read_fds;
113 EMACS_TIME tmout;
115 if (ice_fd == -1) return 0;
117 FD_ZERO (&read_fds);
118 FD_SET (ice_fd, &read_fds);
120 tmout.tv_sec = 0;
121 tmout.tv_usec = 0;
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;
129 if (select (ice_fd+1, &read_fds,
130 (SELECT_TYPE *)0, (SELECT_TYPE *)0, &tmout) < 0)
132 ice_fd = -1;
133 return 0;
137 if (FD_ISSET (ice_fd, &read_fds))
138 IceProcessMessages (SmcGetIceConnection (smc_conn),
139 (IceReplyWaitInfo *)0, (Bool *)0);
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;
147 bcopy (&emacs_event, bufp, sizeof (struct input_event));
148 return 1;
151 /* Return non-zero if we have a connection to a session manager. */
154 x_session_have_connection ()
156 return ice_fd != -1;
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. */
163 static void
164 smc_interact_CB (smcConn, clientData)
165 SmcConn smcConn;
166 SmPointer clientData;
168 doing_interact = True;
169 emacs_event.kind = SAVE_SESSION_EVENT;
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.
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. */
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;
194 #define NR_PROPS 5
196 SmProp *props[NR_PROPS];
197 SmProp prop_ptr[NR_PROPS];
199 SmPropValue values[20];
200 int val_idx = 0;
201 int props_idx = 0;
203 char *cwd = NULL;
204 char *smid_opt;
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;
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;
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;
235 smid_opt = xmalloc (strlen (SMID_OPT) + strlen (client_id) + 1);
236 strcpy (smid_opt, SMID_OPT);
237 strcat (smid_opt, client_id);
239 props[props_idx]->vals[1].length = strlen (smid_opt);
240 props[props_idx]->vals[1].value = smid_opt;
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;
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;
257 cwd = get_current_dir_name ();
259 if (cwd)
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;
272 SmcSetProperties (smcConn, props_idx, props);
274 xfree (smid_opt);
276 if (cwd)
277 free (cwd);
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))
285 /* No interaction, we are done saving ourself. */
286 SmcSaveYourselfDone (smcConn, True);
290 /* According to the SM specification, this shall close the connection. */
292 static void
293 smc_die_CB (smcConn, clientData)
294 SmcConn smcConn;
295 SmPointer clientData;
297 SmcCloseConnection (smcConn, 0, 0);
298 ice_fd = -1;
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. */
307 static void
308 smc_save_complete_CB (smcConn, clientData)
309 SmcConn smcConn;
310 SmPointer clientData;
312 /* Empty */
315 static void
316 smc_shutdown_cancelled_CB (smcConn, clientData)
317 SmcConn smcConn;
318 SmPointer clientData;
320 /* Empty */
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. */
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;
342 /* Empty */
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;
361 /* Empty */
365 static void
366 ice_io_error_handler (iceConn)
367 IceConn iceConn;
369 /* Connection probably gone. */
370 ice_fd = -1;
373 /* This is called when the ICE connection is created or closed. The SM library
374 uses ICE as it transport protocol. */
376 static void
377 ice_conn_watch_CB (iceConn, clientData, opening, watchData)
378 IceConn iceConn;
379 IcePointer clientData;
380 Bool opening;
381 IcePointer *watchData;
383 if (! opening)
385 ice_fd = -1;
386 return;
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 */
401 #ifdef SIGIO
402 if (interrupt_input)
403 init_sigio (ice_fd);
404 #endif /* ! defined (SIGIO) */
407 /* Create the client leader window. */
409 static void
410 create_client_leader_window (dpyinfo, client_id)
411 struct x_display_info *dpyinfo;
412 char *client_id;
414 Window w;
415 XClassHint class_hints;
416 Atom sm_id;
418 w = XCreateSimpleWindow (dpyinfo->display,
419 dpyinfo->root_window,
420 -1, -1, 1, 1,
421 CopyFromParent, CopyFromParent, CopyFromParent);
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);
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));
432 dpyinfo->client_leader_window = w;
435 /* Try to open a connection to the session manager. */
437 void
438 x_session_initialize (dpyinfo)
439 struct x_display_info *dpyinfo;
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;
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);
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));
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';
462 if (! EQ (Vinvocation_directory, Qnil))
463 strcpy (emacs_program, SDATA (Vinvocation_directory));
464 strcat (emacs_program, SDATA (Vinvocation_name));
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;
477 /* Set error handlers. */
478 SmcSetErrorHandler (smc_error_handler);
479 IceSetErrorHandler (ice_error_handler);
480 IceSetIOErrorHandler (ice_io_error_handler);
482 /* Install callback for when connection status changes. */
483 IceAddConnectionWatch (ice_conn_watch_CB, 0);
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);
499 if (smc_conn != 0)
501 Vx_session_id = make_string (client_id, strlen (client_id));
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
514 DEFUN ("handle-save-session", Fhandle_save_session,
515 Shandle_save_session, 1, 1, "e",
516 doc: /* Handle the save_yourself event from a session manager.
517 A session manager can tell Emacs that the window system is shutting down
518 by sending Emacs a save_yourself message. Emacs executes this function when
519 such an event occurs. This function then executes `emacs-session-save'.
520 After that, this function informs the session manager that it can continue
521 or abort shutting down the window system depending on the return value
522 from `emacs-session-save' If the return value is non-nil the session manager
523 is told to abort the window system shutdown.
525 Do not call this function yourself. */)
526 (event)
527 Lisp_Object event;
529 /* Check doing_interact so that we don't do anything if someone called
530 this at the wrong time. */
531 if (doing_interact)
533 Bool cancel_shutdown = False;
535 cancel_shutdown = ! EQ (call0 (intern ("emacs-session-save")), Qnil);
537 SmcInteractDone (smc_conn, cancel_shutdown);
538 SmcSaveYourselfDone (smc_conn, True);
540 doing_interact = False;
543 return Qnil;
547 /***********************************************************************
548 Initialization
549 ***********************************************************************/
550 void
551 syms_of_xsmfns ()
553 DEFVAR_LISP ("x-session-id", &Vx_session_id,
554 doc: /* The session id Emacs got from the session manager for this session.
555 Changing the value does not change the session id used by Emacs.
556 The value is nil if no session manager is running.
557 See also `x-session-previous-id', `emacs-save-session-functions',
558 `emacs-session-save' and `emacs-session-restore'." */);
559 Vx_session_id = Qnil;
561 DEFVAR_LISP ("x-session-previous-id", &Vx_session_previous_id,
562 doc: /* The previous session id Emacs got from session manager.
563 If Emacs is running on a window system that has a session manager, the
564 session manager gives Emacs a session id. It is feasible for Emacs Lisp
565 code to use the session id to save configuration in, for example, a file
566 with a file name based on the session id. If Emacs is running when the
567 window system is shut down, the session manager remembers that Emacs was
568 running and saves the session id Emacs had.
570 When the window system is started again, the session manager restarts
571 Emacs and hands Emacs the session id it had the last time it was
572 running. This is now the previous session id and the value of this
573 variable. If configuration was saved in a file as stated above, the
574 previous session id shall be used to reconstruct the file name.
576 The 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
578 same, depending on how the session manager works.
580 See also `emacs-save-session-functions', `emacs-session-save' and
581 `emacs-session-restore'." */);
582 Vx_session_previous_id = Qnil;
584 defsubr (&Shandle_save_session);
587 #endif /* HAVE_X_SM */
589 /* arch-tag: 56a2c58c-adfa-430a-b772-130abd29fd2e
590 (do not change this comment) */