Fix bug #13553 with usage of IS_DIRECTORY_SEP on MS-Windows under DBCS.
[emacs.git] / src / xsmfns.c
blobfe2dfbaf83e4b51b5f375e120a72fc7c82adfbc6
1 /* Session management module for systems which understand the X Session
2 management protocol.
4 Copyright (C) 2002-2013 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 #include <config.h>
23 #ifdef HAVE_X_SM
25 #include <X11/SM/SMlib.h>
26 #include <X11/Xlib.h>
27 #include <X11/Xutil.h>
29 #include <unistd.h>
30 #include <sys/param.h>
31 #include <stdio.h>
33 #include "lisp.h"
34 #include "systime.h"
35 #include "sysselect.h"
36 #include "frame.h"
37 #include "termhooks.h"
38 #include "xterm.h"
39 #include "process.h"
40 #include "keyboard.h"
42 #if defined USE_GTK && !defined HAVE_GTK3
43 #define gdk_x11_set_sm_client_id(w) gdk_set_sm_client_id (w)
44 #endif
46 /* This is the event used when SAVE_SESSION_EVENT occurs. */
48 static struct input_event emacs_event;
50 /* The descriptor that we use to check for data from the session manager. */
52 static int ice_fd;
54 /* A flag that says if we are in shutdown interactions or not. */
56 static int doing_interact;
58 /* The session manager object for the session manager connection. */
60 static SmcConn smc_conn;
62 /* The client session id for this session. */
64 static char *client_id;
66 /* The full path name to the Emacs program. */
68 static char *emacs_program;
70 /* The option we tell the session manager to start Emacs with when
71 restarting Emacs. The client_id is appended. */
73 #define SMID_OPT "--smid="
76 /* The option to start Emacs without the splash screen when
77 restarting Emacs. */
79 static char NOSPLASH_OPT[] = "--no-splash";
81 /* The option to make Emacs start in the given directory. */
83 #define CHDIR_OPT "--chdir="
85 static void
86 ice_connection_closed (void)
88 if (ice_fd >= 0)
89 delete_read_fd (ice_fd);
90 ice_fd = -1;
94 /* Handle any messages from the session manager. If no connection is
95 open to a session manager, just return. */
97 static void
98 x_session_check_input (int fd, void *data)
100 int ret;
102 if (ice_fd == -1) return;
104 /* Reset this so wo can check kind after callbacks have been called by
105 IceProcessMessages. The smc_interact_CB sets the kind to
106 SAVE_SESSION_EVENT, but we don't know beforehand if that callback
107 will be called. */
108 emacs_event.kind = NO_EVENT;
110 ret = IceProcessMessages (SmcGetIceConnection (smc_conn),
111 (IceReplyWaitInfo *)0, (Bool *)0);
112 if (ret != IceProcessMessagesSuccess)
114 /* Either IO error or Connection closed. */
115 if (ret == IceProcessMessagesIOError)
116 IceCloseConnection (SmcGetIceConnection (smc_conn));
118 ice_connection_closed ();
121 /* Check if smc_interact_CB was called and we shall generate a
122 SAVE_SESSION_EVENT. */
123 if (emacs_event.kind != NO_EVENT)
124 kbd_buffer_store_event (&emacs_event);
127 /* Return non-zero if we have a connection to a session manager. */
130 x_session_have_connection (void)
132 return ice_fd != -1;
135 /* This is called when the session manager says it is OK to interact with the
136 user. Here we set the kind to SAVE_SESSION_EVENT so an event is generated.
137 Then lisp code can interact with the user. */
139 static void
140 smc_interact_CB (SmcConn smcConn, SmPointer clientData)
142 doing_interact = True;
143 emacs_event.kind = SAVE_SESSION_EVENT;
144 emacs_event.arg = Qnil;
147 /* This is called when the session manager tells us to save ourselves.
148 We set the required properties so the session manager can restart us,
149 plus the current working directory property (not mandatory) so we
150 are started in the correct directory.
152 If this is a shutdown and we can request to interact with the user,
153 we do so, because we don't know what the lisp code might do. */
155 static void
156 smc_save_yourself_CB (SmcConn smcConn,
157 SmPointer clientData,
158 int saveType,
159 Bool shutdown,
160 int interactStyle,
161 Bool fast)
163 #define NR_PROPS 5
165 SmProp *props[NR_PROPS];
166 SmProp prop_ptr[NR_PROPS];
168 SmPropValue values[20], *vp;
169 int val_idx = 0, vp_idx = 0;
170 int props_idx = 0;
171 int i;
172 char *cwd = get_current_dir_name ();
173 char *smid_opt, *chdir_opt = NULL;
175 /* How to start a new instance of Emacs. */
176 props[props_idx] = &prop_ptr[props_idx];
177 props[props_idx]->name = xstrdup (SmCloneCommand);
178 props[props_idx]->type = xstrdup (SmLISTofARRAY8);
179 props[props_idx]->num_vals = 1;
180 props[props_idx]->vals = &values[val_idx++];
181 props[props_idx]->vals[0].length = strlen (emacs_program);
182 props[props_idx]->vals[0].value = emacs_program;
183 ++props_idx;
185 /* The name of the program. */
186 props[props_idx] = &prop_ptr[props_idx];
187 props[props_idx]->name = xstrdup (SmProgram);
188 props[props_idx]->type = xstrdup (SmARRAY8);
189 props[props_idx]->num_vals = 1;
190 props[props_idx]->vals = &values[val_idx++];
191 props[props_idx]->vals[0].length = SBYTES (Vinvocation_name);
192 props[props_idx]->vals[0].value = SDATA (Vinvocation_name);
193 ++props_idx;
195 /* User id. */
196 props[props_idx] = &prop_ptr[props_idx];
197 props[props_idx]->name = xstrdup (SmUserID);
198 props[props_idx]->type = xstrdup (SmARRAY8);
199 props[props_idx]->num_vals = 1;
200 props[props_idx]->vals = &values[val_idx++];
201 props[props_idx]->vals[0].length = SBYTES (Vuser_login_name);
202 props[props_idx]->vals[0].value = SDATA (Vuser_login_name);
203 ++props_idx;
206 if (cwd)
208 props[props_idx] = &prop_ptr[props_idx];
209 props[props_idx]->name = xstrdup (SmCurrentDirectory);
210 props[props_idx]->type = xstrdup (SmARRAY8);
211 props[props_idx]->num_vals = 1;
212 props[props_idx]->vals = &values[val_idx++];
213 props[props_idx]->vals[0].length = strlen (cwd);
214 props[props_idx]->vals[0].value = cwd;
215 ++props_idx;
219 /* How to restart Emacs. */
220 props[props_idx] = &prop_ptr[props_idx];
221 props[props_idx]->name = xstrdup (SmRestartCommand);
222 props[props_idx]->type = xstrdup (SmLISTofARRAY8);
223 /* /path/to/emacs, --smid=xxx --no-splash --chdir=dir ... */
224 if (INT_MAX - 3 < initial_argc)
225 memory_full (SIZE_MAX);
226 i = 3 + initial_argc;
227 props[props_idx]->num_vals = i;
228 vp = xnmalloc (i, sizeof *vp);
229 props[props_idx]->vals = vp;
230 props[props_idx]->vals[vp_idx].length = strlen (emacs_program);
231 props[props_idx]->vals[vp_idx++].value = emacs_program;
233 smid_opt = xmalloc (strlen (SMID_OPT) + strlen (client_id) + 1);
234 strcpy (smid_opt, SMID_OPT);
235 strcat (smid_opt, client_id);
237 props[props_idx]->vals[vp_idx].length = strlen (smid_opt);
238 props[props_idx]->vals[vp_idx++].value = smid_opt;
240 props[props_idx]->vals[vp_idx].length = strlen (NOSPLASH_OPT);
241 props[props_idx]->vals[vp_idx++].value = NOSPLASH_OPT;
243 if (cwd)
245 chdir_opt = xmalloc (strlen (CHDIR_OPT) + strlen (cwd) + 1);
246 strcpy (chdir_opt, CHDIR_OPT);
247 strcat (chdir_opt, cwd);
249 props[props_idx]->vals[vp_idx].length = strlen (chdir_opt);
250 props[props_idx]->vals[vp_idx++].value = chdir_opt;
253 for (i = 1; i < initial_argc; ++i)
255 props[props_idx]->vals[vp_idx].length = strlen (initial_argv[i]);
256 props[props_idx]->vals[vp_idx++].value = initial_argv[i];
259 ++props_idx;
261 SmcSetProperties (smcConn, props_idx, props);
263 xfree (smid_opt);
264 xfree (chdir_opt);
265 xfree (cwd);
266 xfree (vp);
268 for (i = 0; i < props_idx; ++i)
270 xfree (props[i]->type);
271 xfree (props[i]->name);
274 /* See if we maybe shall interact with the user. */
275 if (interactStyle != SmInteractStyleAny
276 || ! shutdown
277 || saveType == SmSaveLocal
278 || ! SmcInteractRequest (smcConn, SmDialogNormal, smc_interact_CB, 0))
280 /* No interaction, we are done saving ourself. */
281 SmcSaveYourselfDone (smcConn, True);
285 /* According to the SM specification, this shall close the connection. */
287 static void
288 smc_die_CB (SmcConn smcConn, SmPointer clientData)
290 emacs_event.kind = SAVE_SESSION_EVENT;
291 emacs_event.arg = Qt;
294 /* We don't use the next two but they are mandatory, leave them empty.
295 According to the SM specification, we should not interact with the
296 user between smc_save_yourself_CB is called and until smc_save_complete_CB
297 is called. It seems like a lot of job to implement this and it doesn't
298 even seem necessary. */
300 static void
301 smc_save_complete_CB (SmcConn smcConn, SmPointer clientData)
303 /* Empty */
306 static void
307 smc_shutdown_cancelled_CB (SmcConn smcConn, SmPointer clientData)
309 /* Empty */
312 /* Error handlers for SM and ICE. We don't want to exit Emacs just
313 because there is some error in the session management. */
315 static void
316 smc_error_handler (SmcConn smcConn,
317 Bool swap,
318 int offendingMinorOpcode,
319 unsigned long offendingSequence,
320 int errorClass,
321 int severity,
322 SmPointer values)
324 /* Empty */
327 static void
328 ice_error_handler (IceConn iceConn,
329 Bool swap,
330 int offendingMinorOpcode,
331 unsigned long offendingSequence,
332 int errorClass,
333 int severity,
334 IcePointer values)
336 /* Empty */
340 static void
341 ice_io_error_handler (IceConn iceConn)
343 /* Connection probably gone. */
344 ice_connection_closed ();
347 /* This is called when the ICE connection is created or closed. The SM library
348 uses ICE as it transport protocol. */
350 static void
351 ice_conn_watch_CB (IceConn iceConn, IcePointer clientData,
352 int opening, IcePointer *watchData)
354 if (! opening)
356 ice_connection_closed ();
357 return;
360 ice_fd = IceConnectionNumber (iceConn);
361 add_read_fd (ice_fd, x_session_check_input, NULL);
364 /* Create the client leader window. */
366 #ifndef USE_GTK
367 static void
368 create_client_leader_window (struct x_display_info *dpyinfo, char *client_ID)
370 Window w;
371 XClassHint class_hints;
373 w = XCreateSimpleWindow (dpyinfo->display,
374 dpyinfo->root_window,
375 -1, -1, 1, 1,
376 CopyFromParent, CopyFromParent, CopyFromParent);
378 class_hints.res_name = SSDATA (Vx_resource_name);
379 class_hints.res_class = SSDATA (Vx_resource_class);
380 XSetClassHint (dpyinfo->display, w, &class_hints);
381 XStoreName (dpyinfo->display, w, class_hints.res_name);
383 XChangeProperty (dpyinfo->display, w, dpyinfo->Xatom_SM_CLIENT_ID,
384 XA_STRING, 8, PropModeReplace,
385 (unsigned char *) client_ID, strlen (client_ID));
387 dpyinfo->client_leader_window = w;
389 #endif /* ! USE_GTK */
392 /* Try to open a connection to the session manager. */
394 void
395 x_session_initialize (struct x_display_info *dpyinfo)
397 #define SM_ERRORSTRING_LEN 512
398 char errorstring[SM_ERRORSTRING_LEN];
399 char* previous_id = NULL;
400 SmcCallbacks callbacks;
401 ptrdiff_t name_len = 0;
403 ice_fd = -1;
404 doing_interact = False;
406 /* Check if we where started by the session manager. If so, we will
407 have a previous id. */
408 if (! EQ (Vx_session_previous_id, Qnil) && STRINGP (Vx_session_previous_id))
409 previous_id = SSDATA (Vx_session_previous_id);
411 /* Construct the path to the Emacs program. */
412 if (! EQ (Vinvocation_directory, Qnil))
413 name_len += SBYTES (Vinvocation_directory);
414 name_len += SBYTES (Vinvocation_name);
416 /* This malloc will not be freed, but it is only done once, and hopefully
417 not very large */
418 emacs_program = xmalloc (name_len + 1);
419 emacs_program[0] = '\0';
421 if (! EQ (Vinvocation_directory, Qnil))
422 strcpy (emacs_program, SSDATA (Vinvocation_directory));
423 strcat (emacs_program, SSDATA (Vinvocation_name));
425 /* The SM protocol says all callbacks are mandatory, so set up all
426 here and in the mask passed to SmcOpenConnection. */
427 callbacks.save_yourself.callback = smc_save_yourself_CB;
428 callbacks.save_yourself.client_data = 0;
429 callbacks.die.callback = smc_die_CB;
430 callbacks.die.client_data = 0;
431 callbacks.save_complete.callback = smc_save_complete_CB;
432 callbacks.save_complete.client_data = 0;
433 callbacks.shutdown_cancelled.callback = smc_shutdown_cancelled_CB;
434 callbacks.shutdown_cancelled.client_data = 0;
436 /* Set error handlers. */
437 SmcSetErrorHandler (smc_error_handler);
438 IceSetErrorHandler (ice_error_handler);
439 IceSetIOErrorHandler (ice_io_error_handler);
441 /* Install callback for when connection status changes. */
442 IceAddConnectionWatch (ice_conn_watch_CB, 0);
444 /* Open the connection to the session manager. A failure is not
445 critical, it usually means that no session manager is running.
446 The errorstring is here for debugging. */
447 smc_conn = SmcOpenConnection (NULL, NULL, 1, 0,
448 (SmcSaveYourselfProcMask|
449 SmcDieProcMask|
450 SmcSaveCompleteProcMask|
451 SmcShutdownCancelledProcMask),
452 &callbacks,
453 previous_id,
454 &client_id,
455 SM_ERRORSTRING_LEN,
456 errorstring);
458 if (smc_conn != 0)
460 Vx_session_id = build_string (client_id);
462 #ifdef USE_GTK
463 /* GTK creates a leader window by itself, but we need to tell
464 it about our client_id. */
465 gdk_x11_set_sm_client_id (client_id);
466 #else
467 create_client_leader_window (dpyinfo, client_id);
468 #endif
472 /* Ensure that the session manager is not contacted again. */
474 void
475 x_session_close (void)
477 ice_connection_closed ();
481 DEFUN ("handle-save-session", Fhandle_save_session,
482 Shandle_save_session, 1, 1, "e",
483 doc: /* Handle the save_yourself event from a session manager.
484 A session manager can tell Emacs that the window system is shutting down
485 by sending Emacs a save_yourself message. Emacs executes this function when
486 such an event occurs. This function then executes `emacs-session-save'.
487 After that, this function informs the session manager that it can continue
488 or abort shutting down the window system depending on the return value
489 from `emacs-session-save' If the return value is non-nil the session manager
490 is told to abort the window system shutdown.
492 Do not call this function yourself. */)
493 (Lisp_Object event)
495 int kill_emacs = CONSP (event) && CONSP (XCDR (event))
496 && EQ (Qt, XCAR (XCDR (event)));
498 /* Check doing_interact so that we don't do anything if someone called
499 this at the wrong time. */
500 if (doing_interact && ! kill_emacs)
502 Bool cancel_shutdown = False;
504 cancel_shutdown = ! EQ (call0 (intern ("emacs-session-save")), Qnil);
506 SmcInteractDone (smc_conn, cancel_shutdown);
507 SmcSaveYourselfDone (smc_conn, True);
509 doing_interact = False;
511 else if (kill_emacs)
513 /* We should not do user interaction here, but it is not easy to
514 prevent. Fix this in next version. */
515 Fkill_emacs (Qnil);
517 /* This will not be reached, but we want kill-emacs-hook to be run. */
518 SmcCloseConnection (smc_conn, 0, 0);
519 ice_connection_closed ();
522 return Qnil;
527 /***********************************************************************
528 Initialization
529 ***********************************************************************/
530 void
531 syms_of_xsmfns (void)
533 DEFVAR_LISP ("x-session-id", Vx_session_id,
534 doc: /* The session id Emacs got from the session manager for this session.
535 Changing the value does not change the session id used by Emacs.
536 The value is nil if no session manager is running.
537 See also `x-session-previous-id', `emacs-save-session-functions',
538 `emacs-session-save' and `emacs-session-restore'." */);
539 Vx_session_id = Qnil;
541 DEFVAR_LISP ("x-session-previous-id", Vx_session_previous_id,
542 doc: /* The previous session id Emacs got from session manager.
543 If Emacs is running on a window system that has a session manager, the
544 session manager gives Emacs a session id. It is feasible for Emacs Lisp
545 code to use the session id to save configuration in, for example, a file
546 with a file name based on the session id. If Emacs is running when the
547 window system is shut down, the session manager remembers that Emacs was
548 running and saves the session id Emacs had.
550 When the window system is started again, the session manager restarts
551 Emacs and hands Emacs the session id it had the last time it was
552 running. This is now the previous session id and the value of this
553 variable. If configuration was saved in a file as stated above, the
554 previous session id shall be used to reconstruct the file name.
556 The session id Emacs has while it is running is in the variable
557 `x-session-id'. The value of this variable and `x-session-id' may be the
558 same, depending on how the session manager works.
560 See also `emacs-save-session-functions', `emacs-session-save' and
561 `emacs-session-restore'." */);
562 Vx_session_previous_id = Qnil;
564 defsubr (&Shandle_save_session);
567 #endif /* HAVE_X_SM */