1 /* Session management module for systems which understand the X Session
2 management protocol.
3
4 Copyright (C) 2002-2021 Free Software Foundation, Inc.
5
6 This file is part of GNU Emacs.
7
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 (at
11 your option) any later version.
12
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.
17
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>. */
20
21 #include <config.h>
22
23 #ifdef HAVE_X_SM
24
25 #include <X11/SM/SMlib.h>
26 #include <X11/Xlib.h>
27 #include <X11/Xutil.h>
28
29 #include <unistd.h>
30 #include <sys/param.h>
31 #include <errno.h>
32 #include <stdio.h>
33
34 #include "lisp.h"
35 #include "frame.h"
36 #include "termhooks.h"
37 #include "xterm.h"
38 #include "process.h"
39 #include "keyboard.h"
40
41 #if defined USE_GTK && !defined HAVE_GTK3
42 #define gdk_x11_set_sm_client_id(w) gdk_set_sm_client_id (w)
43 #endif
44
45 /* This is the event used when SAVE_SESSION_EVENT occurs. */
46
47 static struct input_event emacs_event;
48
49 /* The descriptor that we use to check for data from the session manager. */
50
51 static int ice_fd = -1;
52
53 /* A flag that says if we are in shutdown interactions or not. */
54
55 static bool doing_interact;
56
57 /* The session manager object for the session manager connection. */
58
59 static SmcConn smc_conn;
60
61 /* The client session id for this session. */
62
63 static char *client_id;
64
65 /* The full path name to the Emacs program. */
66
67 static char *emacs_program;
68
69 /* The option we tell the session manager to start Emacs with when
70 restarting Emacs. The client_id is appended. */
71
72 #define SMID_OPT "--smid="
73
74
75 /* The option to start Emacs without the splash screen when
76 restarting Emacs. */
77
78 static char NOSPLASH_OPT[] = "--no-splash";
79
80 /* The option to make Emacs start in the given directory. */
81
82 #define CHDIR_OPT "--chdir="
83
84 static void
ice_connection_closed(void)85 ice_connection_closed (void)
86 {
87 if (ice_fd >= 0)
88 delete_read_fd (ice_fd);
89 ice_fd = -1;
90 }
91
92
93 /* Handle any messages from the session manager. If no connection is
94 open to a session manager, just return. */
95
96 static void
x_session_check_input(int fd,void * data)97 x_session_check_input (int fd, void *data)
98 {
99 int ret;
100
101 if (ice_fd == -1) return;
102
103 /* Reset this so wo can check kind after callbacks have been called by
104 IceProcessMessages. The smc_interact_CB sets the kind to
105 SAVE_SESSION_EVENT, but we don't know beforehand if that callback
106 will be called. */
107 emacs_event.kind = NO_EVENT;
108
109 ret = IceProcessMessages (SmcGetIceConnection (smc_conn), 0, 0);
110 if (ret != IceProcessMessagesSuccess)
111 {
112 /* Either IO error or Connection closed. */
113 if (ret == IceProcessMessagesIOError)
114 IceCloseConnection (SmcGetIceConnection (smc_conn));
115
116 ice_connection_closed ();
117 }
118
119 /* Check if smc_interact_CB was called and we shall generate a
120 SAVE_SESSION_EVENT. */
121 if (emacs_event.kind != NO_EVENT)
122 kbd_buffer_store_event (&emacs_event);
123 }
124
125 /* Return true if we have a connection to a session manager. */
126
127 bool
x_session_have_connection(void)128 x_session_have_connection (void)
129 {
130 return ice_fd != -1;
131 }
132
133 /* This is called when the session manager says it is OK to interact with the
134 user. Here we set the kind to SAVE_SESSION_EVENT so an event is generated.
135 Then lisp code can interact with the user. */
136
137 static void
smc_interact_CB(SmcConn smcConn,SmPointer clientData)138 smc_interact_CB (SmcConn smcConn, SmPointer clientData)
139 {
140 doing_interact = true;
141 emacs_event.kind = SAVE_SESSION_EVENT;
142 emacs_event.arg = Qnil;
143 }
144
145 /* This is called when the session manager tells us to save ourselves.
146 We set the required properties so the session manager can restart us,
147 plus the current working directory property (not mandatory) so we
148 are started in the correct directory.
149
150 If this is a shutdown and we can request to interact with the user,
151 we do so, because we don't know what the lisp code might do. */
152
153 static void
smc_save_yourself_CB(SmcConn smcConn,SmPointer clientData,int saveType,Bool shutdown,int interactStyle,Bool fast)154 smc_save_yourself_CB (SmcConn smcConn,
155 SmPointer clientData,
156 int saveType,
157 Bool shutdown,
158 int interactStyle,
159 Bool fast)
160 {
161 #define NR_PROPS 5
162
163 SmProp *props[NR_PROPS];
164 SmProp prop_ptr[NR_PROPS];
165
166 SmPropValue values[20], *vp;
167 int val_idx = 0, vp_idx = 0;
168 int props_idx = 0;
169 int i;
170 char *smid_opt, *chdir_opt = NULL;
171 Lisp_Object user_login_name = Fuser_login_name (Qnil);
172
173 /* Must have these. */
174 if (! STRINGP (Vinvocation_name) || ! STRINGP (user_login_name))
175 return;
176
177 /* How to start a new instance of Emacs. */
178 props[props_idx] = &prop_ptr[props_idx];
179 props[props_idx]->name = xstrdup (SmCloneCommand);
180 props[props_idx]->type = xstrdup (SmLISTofARRAY8);
181 props[props_idx]->num_vals = 1;
182 props[props_idx]->vals = &values[val_idx++];
183 props[props_idx]->vals[0].length = strlen (emacs_program);
184 props[props_idx]->vals[0].value = emacs_program;
185 ++props_idx;
186
187 /* The name of the program. */
188 props[props_idx] = &prop_ptr[props_idx];
189 props[props_idx]->name = xstrdup (SmProgram);
190 props[props_idx]->type = xstrdup (SmARRAY8);
191 props[props_idx]->num_vals = 1;
192 props[props_idx]->vals = &values[val_idx++];
193 props[props_idx]->vals[0].length = SBYTES (Vinvocation_name);
194 props[props_idx]->vals[0].value = SDATA (Vinvocation_name);
195 ++props_idx;
196
197 /* User id. */
198 props[props_idx] = &prop_ptr[props_idx];
199 props[props_idx]->name = xstrdup (SmUserID);
200 props[props_idx]->type = xstrdup (SmARRAY8);
201 props[props_idx]->num_vals = 1;
202 props[props_idx]->vals = &values[val_idx++];
203 props[props_idx]->vals[0].length = SBYTES (user_login_name);
204 props[props_idx]->vals[0].value = SDATA (user_login_name);
205 ++props_idx;
206
207 char *cwd = emacs_get_current_dir_name ();
208 if (cwd)
209 {
210 props[props_idx] = &prop_ptr[props_idx];
211 props[props_idx]->name = xstrdup (SmCurrentDirectory);
212 props[props_idx]->type = xstrdup (SmARRAY8);
213 props[props_idx]->num_vals = 1;
214 props[props_idx]->vals = &values[val_idx++];
215 props[props_idx]->vals[0].length = strlen (cwd);
216 props[props_idx]->vals[0].value = cwd;
217 ++props_idx;
218 }
219
220
221 /* How to restart Emacs. */
222 props[props_idx] = &prop_ptr[props_idx];
223 props[props_idx]->name = xstrdup (SmRestartCommand);
224 props[props_idx]->type = xstrdup (SmLISTofARRAY8);
225 /* /path/to/emacs, --smid=xxx --no-splash --chdir=dir ... */
226 if (INT_ADD_WRAPV (initial_argc, 3, &i))
227 memory_full (SIZE_MAX);
228 props[props_idx]->num_vals = i;
229 vp = xnmalloc (i, sizeof *vp);
230 props[props_idx]->vals = vp;
231 props[props_idx]->vals[vp_idx].length = strlen (emacs_program);
232 props[props_idx]->vals[vp_idx++].value = emacs_program;
233
234 smid_opt = xmalloc (strlen (SMID_OPT) + strlen (client_id) + 1);
235 strcpy (stpcpy (smid_opt, SMID_OPT), client_id);
236
237 props[props_idx]->vals[vp_idx].length = strlen (smid_opt);
238 props[props_idx]->vals[vp_idx++].value = smid_opt;
239
240 props[props_idx]->vals[vp_idx].length = strlen (NOSPLASH_OPT);
241 props[props_idx]->vals[vp_idx++].value = NOSPLASH_OPT;
242
243 if (cwd)
244 {
245 chdir_opt = xmalloc (strlen (CHDIR_OPT) + strlen (cwd) + 1);
246 strcpy (stpcpy (chdir_opt, CHDIR_OPT), cwd);
247
248 props[props_idx]->vals[vp_idx].length = strlen (chdir_opt);
249 props[props_idx]->vals[vp_idx++].value = chdir_opt;
250 }
251
252 for (i = 1; i < initial_argc; ++i)
253 {
254 props[props_idx]->vals[vp_idx].length = strlen (initial_argv[i]);
255 props[props_idx]->vals[vp_idx++].value = initial_argv[i];
256 }
257
258 ++props_idx;
259
260 SmcSetProperties (smcConn, props_idx, props);
261
262 xfree (smid_opt);
263 xfree (chdir_opt);
264 xfree (cwd);
265 xfree (vp);
266
267 for (i = 0; i < props_idx; ++i)
268 {
269 xfree (props[i]->type);
270 xfree (props[i]->name);
271 }
272
273 /* See if we maybe shall interact with the user. */
274 if (interactStyle != SmInteractStyleAny
275 || ! shutdown
276 || saveType == SmSaveLocal
277 || ! SmcInteractRequest (smcConn, SmDialogNormal, smc_interact_CB, 0))
278 {
279 /* No interaction, we are done saving ourself. */
280 SmcSaveYourselfDone (smcConn, True);
281 }
282 }
283
284 /* According to the SM specification, this shall close the connection. */
285
286 static void
smc_die_CB(SmcConn smcConn,SmPointer clientData)287 smc_die_CB (SmcConn smcConn, SmPointer clientData)
288 {
289 emacs_event.kind = SAVE_SESSION_EVENT;
290 emacs_event.arg = Qt;
291 }
292
293 /* We don't use the next two but they are mandatory, leave them empty.
294 According to the SM specification, we should not interact with the
295 user between smc_save_yourself_CB is called and until smc_save_complete_CB
296 is called. It seems like a lot of job to implement this and it doesn't
297 even seem necessary. */
298
299 static void
smc_save_complete_CB(SmcConn smcConn,SmPointer clientData)300 smc_save_complete_CB (SmcConn smcConn, SmPointer clientData)
301 {
302 /* Empty */
303 }
304
305 static void
smc_shutdown_cancelled_CB(SmcConn smcConn,SmPointer clientData)306 smc_shutdown_cancelled_CB (SmcConn smcConn, SmPointer clientData)
307 {
308 /* Empty */
309 }
310
311 /* Error handlers for SM and ICE. We don't want to exit Emacs just
312 because there is some error in the session management. */
313
314 static void
smc_error_handler(SmcConn smcConn,Bool swap,int offendingMinorOpcode,unsigned long offendingSequence,int errorClass,int severity,SmPointer values)315 smc_error_handler (SmcConn smcConn,
316 Bool swap,
317 int offendingMinorOpcode,
318 unsigned long offendingSequence,
319 int errorClass,
320 int severity,
321 SmPointer values)
322 {
323 /* Empty */
324 }
325
326 static void
ice_error_handler(IceConn iceConn,Bool swap,int offendingMinorOpcode,unsigned long offendingSequence,int errorClass,int severity,IcePointer values)327 ice_error_handler (IceConn iceConn,
328 Bool swap,
329 int offendingMinorOpcode,
330 unsigned long offendingSequence,
331 int errorClass,
332 int severity,
333 IcePointer values)
334 {
335 /* Empty */
336 }
337
338
339 static void
ice_io_error_handler(IceConn iceConn)340 ice_io_error_handler (IceConn iceConn)
341 {
342 /* Connection probably gone. */
343 ice_connection_closed ();
344 }
345
346 /* This is called when the ICE connection is created or closed. The SM library
347 uses ICE as it transport protocol. */
348
349 static void
ice_conn_watch_CB(IceConn iceConn,IcePointer clientData,int opening,IcePointer * watchData)350 ice_conn_watch_CB (IceConn iceConn, IcePointer clientData,
351 int opening, IcePointer *watchData)
352 {
353 if (! opening)
354 {
355 ice_connection_closed ();
356 return;
357 }
358
359 ice_fd = IceConnectionNumber (iceConn);
360 add_read_fd (ice_fd, x_session_check_input, NULL);
361 }
362
363 /* Create the client leader window. */
364
365 #ifndef USE_GTK
366 static void
create_client_leader_window(struct x_display_info * dpyinfo,char * client_ID)367 create_client_leader_window (struct x_display_info *dpyinfo, char *client_ID)
368 {
369 Window w;
370 XClassHint class_hints;
371
372 w = XCreateSimpleWindow (dpyinfo->display,
373 dpyinfo->root_window,
374 -1, -1, 1, 1,
375 CopyFromParent, CopyFromParent, CopyFromParent);
376
377 validate_x_resource_name ();
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);
382
383 XChangeProperty (dpyinfo->display, w, dpyinfo->Xatom_SM_CLIENT_ID,
384 XA_STRING, 8, PropModeReplace,
385 (unsigned char *) client_ID, strlen (client_ID));
386
387 dpyinfo->client_leader_window = w;
388 }
389 #endif /* ! USE_GTK */
390
391
392 /* Try to open a connection to the session manager. */
393
394 void
x_session_initialize(struct x_display_info * dpyinfo)395 x_session_initialize (struct x_display_info *dpyinfo)
396 {
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;
402
403 /* libSM seems to crash if pwd is missing - see bug#18851. */
404 char *pwd = emacs_get_current_dir_name ();
405 if (!pwd)
406 {
407 fprintf (stderr, "Disabling session management due to pwd error: %s\n",
408 emacs_strerror (errno));
409 return;
410 }
411 xfree (pwd);
412
413 ice_fd = -1;
414 doing_interact = false;
415
416 /* Check if we where started by the session manager. If so, we will
417 have a previous id. */
418 if (STRINGP (Vx_session_previous_id))
419 previous_id = SSDATA (Vx_session_previous_id);
420
421 /* Construct the path to the Emacs program. */
422 if (STRINGP (Vinvocation_directory))
423 name_len += SBYTES (Vinvocation_directory);
424 if (STRINGP (Vinvocation_name))
425 name_len += SBYTES (Vinvocation_name);
426
427 /* This malloc will not be freed, but it is only done once, and hopefully
428 not very large */
429 emacs_program = xmalloc (name_len + 1);
430 char *z = emacs_program;
431
432 if (STRINGP (Vinvocation_directory))
433 z = lispstpcpy (z, Vinvocation_directory);
434 if (STRINGP (Vinvocation_name))
435 lispstpcpy (z, Vinvocation_name);
436
437 /* The SM protocol says all callbacks are mandatory, so set up all
438 here and in the mask passed to SmcOpenConnection. */
439 callbacks.save_yourself.callback = smc_save_yourself_CB;
440 callbacks.save_yourself.client_data = 0;
441 callbacks.die.callback = smc_die_CB;
442 callbacks.die.client_data = 0;
443 callbacks.save_complete.callback = smc_save_complete_CB;
444 callbacks.save_complete.client_data = 0;
445 callbacks.shutdown_cancelled.callback = smc_shutdown_cancelled_CB;
446 callbacks.shutdown_cancelled.client_data = 0;
447
448 /* Set error handlers. */
449 SmcSetErrorHandler (smc_error_handler);
450 IceSetErrorHandler (ice_error_handler);
451 IceSetIOErrorHandler (ice_io_error_handler);
452
453 /* Install callback for when connection status changes. */
454 IceAddConnectionWatch (ice_conn_watch_CB, 0);
455
456 /* Open the connection to the session manager. A failure is not
457 critical, it usually means that no session manager is running.
458 The errorstring is here for debugging. */
459 smc_conn = SmcOpenConnection (NULL, NULL, 1, 0,
460 (SmcSaveYourselfProcMask|
461 SmcDieProcMask|
462 SmcSaveCompleteProcMask|
463 SmcShutdownCancelledProcMask),
464 &callbacks,
465 previous_id,
466 &client_id,
467 SM_ERRORSTRING_LEN,
468 errorstring);
469
470 if (smc_conn != 0)
471 {
472 Vx_session_id = build_string (client_id);
473
474 #ifdef USE_GTK
475 /* GTK creates a leader window by itself, but we need to tell
476 it about our client_id. */
477 gdk_x11_set_sm_client_id (client_id);
478 #else
479 create_client_leader_window (dpyinfo, client_id);
480 #endif
481 }
482 }
483
484 /* Ensure that the session manager is not contacted again. */
485
486 void
x_session_close(void)487 x_session_close (void)
488 {
489 ice_connection_closed ();
490 }
491
492
493 DEFUN ("handle-save-session", Fhandle_save_session,
494 Shandle_save_session, 1, 1, "e",
495 doc: /* Handle the save_yourself event from a session manager.
496 A session manager can tell Emacs that the window system is shutting down
497 by sending Emacs a save_yourself message. Emacs executes this function when
498 such an event occurs. This function then executes `emacs-session-save'.
499 After that, this function informs the session manager that it can continue
500 or abort shutting down the window system depending on the return value
501 from `emacs-session-save' If the return value is non-nil the session manager
502 is told to abort the window system shutdown.
503
504 Do not call this function yourself. */)
505 (Lisp_Object event)
506 {
507 bool kill_emacs = (CONSP (event) && CONSP (XCDR (event))
508 && EQ (Qt, XCAR (XCDR (event))));
509
510 /* Check doing_interact so that we don't do anything if someone called
511 this at the wrong time. */
512 if (doing_interact && ! kill_emacs)
513 {
514 bool cancel_shutdown = ! NILP (call0 (intern ("emacs-session-save")));
515
516 SmcInteractDone (smc_conn, cancel_shutdown);
517 SmcSaveYourselfDone (smc_conn, True);
518
519 doing_interact = false;
520 }
521 else if (kill_emacs)
522 {
523 /* We should not do user interaction here, but it is not easy to
524 prevent. Fix this in next version. */
525 Fkill_emacs (Qnil);
526
527 #if false
528 /* This will not be reached, but we want kill-emacs-hook to be run. */
529 SmcCloseConnection (smc_conn, 0, 0);
530 ice_connection_closed ();
531 #endif
532 }
533
534 return Qnil;
535 }
536
537
538
539 /***********************************************************************
540 Initialization
541 ***********************************************************************/
542 void
syms_of_xsmfns(void)543 syms_of_xsmfns (void)
544 {
545 DEFVAR_LISP ("x-session-id", Vx_session_id,
546 doc: /* The session id Emacs got from the session manager for this session.
547 Changing the value does not change the session id used by Emacs.
548 The value is nil if no session manager is running.
549 See also `x-session-previous-id', `emacs-save-session-functions',
550 `emacs-session-save' and `emacs-session-restore'. */);
551 Vx_session_id = Qnil;
552
553 DEFVAR_LISP ("x-session-previous-id", Vx_session_previous_id,
554 doc: /* The previous session id Emacs got from session manager.
555 If Emacs is running on a window system that has a session manager, the
556 session manager gives Emacs a session id. It is feasible for Emacs Lisp
557 code to use the session id to save configuration in, for example, a file
558 with a file name based on the session id. If Emacs is running when the
559 window system is shut down, the session manager remembers that Emacs was
560 running and saves the session id Emacs had.
561
562 When the window system is started again, the session manager restarts
563 Emacs and hands Emacs the session id it had the last time it was
564 running. This is now the previous session id and the value of this
565 variable. If configuration was saved in a file as stated above, the
566 previous session id shall be used to reconstruct the file name.
567
568 The session id Emacs has while it is running is in the variable
569 `x-session-id'. The value of this variable and `x-session-id' may be the
570 same, depending on how the session manager works.
571
572 See also `emacs-save-session-functions', `emacs-session-save' and
573 `emacs-session-restore'. */);
574 Vx_session_previous_id = Qnil;
575
576 defsubr (&Shandle_save_session);
577 }
578
579 #endif /* HAVE_X_SM */
580