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