/* Session management module for systems which understand the X Session
management protocol.
- Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ Copyright (C) 2002-2011
Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <X11/Xlib.h>
#include <X11/Xutil.h>
-#ifdef HAVE_UNISTD_H
#include <unistd.h>
-#endif
-
#include <sys/param.h>
#include <stdio.h>
+#include <setjmp.h>
#include "lisp.h"
#include "systime.h"
#include "termopts.h"
#include "xterm.h"
-/* The user login name. */
-
-extern Lisp_Object Vuser_login_name;
-
/* This is the event used when SAVE_SESSION_EVENT occurs. */
static struct input_event emacs_event;
/* The descriptor that we use to check for data from the session manager. */
-static int ice_fd = -1;
+static int ice_fd;
/* A flag that says if we are in shutdown interactions or not. */
-static int doing_interact = False;
+static int doing_interact;
/* The session manager object for the session manager connection. */
static char *emacs_program;
-/* The client session id for this session as a lisp object. */
-
-Lisp_Object Vx_session_id;
-
-/* The id we had the previous session. This is only available if we
- have been started by the session manager with SMID_OPT. */
-
-Lisp_Object Vx_session_previous_id;
-
/* The option we tell the session manager to start Emacs with when
restarting Emacs. The client_id is appended. */
/* The option to start Emacs without the splash screen when
restarting Emacs. */
-#define NOSPLASH_OPT "--no-splash"
+static char NOSPLASH_OPT[] = "--no-splash";
+
+/* The option to make Emacs start in the given directory. */
+
+#define CHDIR_OPT "--chdir="
+
+static void
+ice_connection_closed (void)
+{
+ if (ice_fd >= 0)
+ delete_keyboard_wait_descriptor (ice_fd);
+ ice_fd = -1;
+}
/* Handle any messages from the session manager. If no connection is
Otherwise returns 1 if SAVE_SESSION_EVENT is stored in buffer BUFP. */
int
-x_session_check_input (bufp)
- struct input_event *bufp;
+x_session_check_input (struct input_event *bufp)
{
SELECT_TYPE read_fds;
EMACS_TIME tmout;
+ int ret;
if (ice_fd == -1) return 0;
-
FD_ZERO (&read_fds);
FD_SET (ice_fd, &read_fds);
will be called. */
emacs_event.kind = NO_EVENT;
- if (select (ice_fd+1, &read_fds,
- (SELECT_TYPE *)0, (SELECT_TYPE *)0, &tmout) < 0)
+ ret = select (ice_fd+1, &read_fds,
+ (SELECT_TYPE *)0, (SELECT_TYPE *)0, &tmout);
+
+ if (ret < 0)
{
- ice_fd = -1;
- return 0;
+ ice_connection_closed ();
+ }
+ else if (ret > 0 && FD_ISSET (ice_fd, &read_fds))
+ {
+ ret = IceProcessMessages (SmcGetIceConnection (smc_conn),
+ (IceReplyWaitInfo *)0, (Bool *)0);
+ if (ret != IceProcessMessagesSuccess)
+ {
+ /* Either IO error or Connection closed. */
+ if (ret == IceProcessMessagesIOError)
+ IceCloseConnection (SmcGetIceConnection (smc_conn));
+
+ ice_connection_closed ();
+ }
}
-
-
- if (FD_ISSET (ice_fd, &read_fds))
- IceProcessMessages (SmcGetIceConnection (smc_conn),
- (IceReplyWaitInfo *)0, (Bool *)0);
-
/* Check if smc_interact_CB was called and we shall generate a
SAVE_SESSION_EVENT. */
- if (emacs_event.kind == NO_EVENT)
- return 0;
+ if (emacs_event.kind != NO_EVENT)
+ memcpy (bufp, &emacs_event, sizeof (struct input_event));
- bcopy (&emacs_event, bufp, sizeof (struct input_event));
- return 1;
+ return emacs_event.kind != NO_EVENT ? 1 : 0;
}
/* Return non-zero if we have a connection to a session manager. */
int
-x_session_have_connection ()
+x_session_have_connection (void)
{
return ice_fd != -1;
}
Then lisp code can interact with the user. */
static void
-smc_interact_CB (smcConn, clientData)
- SmcConn smcConn;
- SmPointer clientData;
+smc_interact_CB (SmcConn smcConn, SmPointer clientData)
{
doing_interact = True;
emacs_event.kind = SAVE_SESSION_EVENT;
+ emacs_event.arg = Qnil;
}
/* This is called when the session manager tells us to save ourselves.
we do so, because we don't know what the lisp code might do. */
static void
-smc_save_yourself_CB (smcConn,
- clientData,
- saveType,
- shutdown,
- interactStyle,
- fast)
- SmcConn smcConn;
- SmPointer clientData;
- int saveType;
- Bool shutdown;
- int interactStyle;
- Bool fast;
+smc_save_yourself_CB (SmcConn smcConn,
+ SmPointer clientData,
+ int saveType,
+ Bool shutdown,
+ int interactStyle,
+ Bool fast)
{
#define NR_PROPS 5
SmPropValue values[20];
int val_idx = 0;
int props_idx = 0;
-
+ int i;
char *cwd = NULL;
- char *smid_opt;
+ char *smid_opt, *chdir_opt = NULL;
/* How to start a new instance of Emacs. */
props[props_idx] = &prop_ptr[props_idx];
- props[props_idx]->name = SmCloneCommand;
- props[props_idx]->type = SmLISTofARRAY8;
+ props[props_idx]->name = xstrdup (SmCloneCommand);
+ props[props_idx]->type = xstrdup (SmLISTofARRAY8);
props[props_idx]->num_vals = 1;
props[props_idx]->vals = &values[val_idx++];
props[props_idx]->vals[0].length = strlen (emacs_program);
/* The name of the program. */
props[props_idx] = &prop_ptr[props_idx];
- props[props_idx]->name = SmProgram;
- props[props_idx]->type = SmARRAY8;
+ props[props_idx]->name = xstrdup (SmProgram);
+ props[props_idx]->type = xstrdup (SmARRAY8);
props[props_idx]->num_vals = 1;
props[props_idx]->vals = &values[val_idx++];
- props[props_idx]->vals[0].length = strlen (SDATA (Vinvocation_name));
+ props[props_idx]->vals[0].length = strlen (SSDATA (Vinvocation_name));
props[props_idx]->vals[0].value = SDATA (Vinvocation_name);
++props_idx;
- /* How to restart Emacs (i.e.: /path/to/emacs --smid=xxxx --no-splash). */
+ /* How to restart Emacs. */
props[props_idx] = &prop_ptr[props_idx];
- props[props_idx]->name = SmRestartCommand;
- props[props_idx]->type = SmLISTofARRAY8;
- props[props_idx]->num_vals = 3; /* /path/to/emacs, --smid=xxx --no-splash */
+ props[props_idx]->name = xstrdup (SmRestartCommand);
+ props[props_idx]->type = xstrdup (SmLISTofARRAY8);
+ /* /path/to/emacs, --smid=xxx --no-splash --chdir=dir */
+ props[props_idx]->num_vals = 4;
props[props_idx]->vals = &values[val_idx];
props[props_idx]->vals[0].length = strlen (emacs_program);
props[props_idx]->vals[0].value = emacs_program;
props[props_idx]->vals[2].length = strlen (NOSPLASH_OPT);
props[props_idx]->vals[2].value = NOSPLASH_OPT;
- val_idx += 3;
+
+ cwd = get_current_dir_name ();
+ if (cwd)
+ {
+ chdir_opt = xmalloc (strlen (CHDIR_OPT) + strlen (cwd) + 1);
+ strcpy (chdir_opt, CHDIR_OPT);
+ strcat (chdir_opt, cwd);
+
+ props[props_idx]->vals[3].length = strlen (chdir_opt);
+ props[props_idx]->vals[3].value = chdir_opt;
+ }
+
+ val_idx += cwd ? 4 : 3;
++props_idx;
/* User id. */
props[props_idx] = &prop_ptr[props_idx];
- props[props_idx]->name = SmUserID;
- props[props_idx]->type = SmARRAY8;
+ props[props_idx]->name = xstrdup (SmUserID);
+ props[props_idx]->type = xstrdup (SmARRAY8);
props[props_idx]->num_vals = 1;
props[props_idx]->vals = &values[val_idx++];
- props[props_idx]->vals[0].length = strlen (SDATA (Vuser_login_name));
+ props[props_idx]->vals[0].length = strlen (SSDATA (Vuser_login_name));
props[props_idx]->vals[0].value = SDATA (Vuser_login_name);
++props_idx;
- cwd = get_current_dir_name ();
if (cwd)
{
props[props_idx] = &prop_ptr[props_idx];
- props[props_idx]->name = SmCurrentDirectory;
- props[props_idx]->type = SmARRAY8;
+ props[props_idx]->name = xstrdup (SmCurrentDirectory);
+ props[props_idx]->type = xstrdup (SmARRAY8);
props[props_idx]->num_vals = 1;
props[props_idx]->vals = &values[val_idx++];
props[props_idx]->vals[0].length = strlen (cwd);
SmcSetProperties (smcConn, props_idx, props);
xfree (smid_opt);
+ xfree (chdir_opt);
free (cwd);
+ for (i = 0; i < props_idx; ++i)
+ {
+ xfree (props[i]->type);
+ xfree (props[i]->name);
+ }
/* See if we maybe shall interact with the user. */
if (interactStyle != SmInteractStyleAny
/* According to the SM specification, this shall close the connection. */
static void
-smc_die_CB (smcConn, clientData)
- SmcConn smcConn;
- SmPointer clientData;
+smc_die_CB (SmcConn smcConn, SmPointer clientData)
{
- SmcCloseConnection (smcConn, 0, 0);
- ice_fd = -1;
+ emacs_event.kind = SAVE_SESSION_EVENT;
+ emacs_event.arg = Qt;
}
/* We don't use the next two but they are mandatory, leave them empty.
even seem necessary. */
static void
-smc_save_complete_CB (smcConn, clientData)
- SmcConn smcConn;
- SmPointer clientData;
+smc_save_complete_CB (SmcConn smcConn, SmPointer clientData)
{
/* Empty */
}
static void
-smc_shutdown_cancelled_CB (smcConn, clientData)
- SmcConn smcConn;
- SmPointer clientData;
+smc_shutdown_cancelled_CB (SmcConn smcConn, SmPointer clientData)
{
/* Empty */
}
because there is some error in the session management. */
static void
-smc_error_handler (smcConn,
- swap,
- offendingMinorOpcode,
- offendingSequence,
- errorClass,
- severity,
- values)
- SmcConn smcConn;
- Bool swap;
- int offendingMinorOpcode;
- unsigned long offendingSequence;
- int errorClass;
- int severity;
- SmPointer values;
+smc_error_handler (SmcConn smcConn,
+ Bool swap,
+ int offendingMinorOpcode,
+ unsigned long offendingSequence,
+ int errorClass,
+ int severity,
+ SmPointer values)
{
/* Empty */
}
static void
-ice_error_handler (iceConn,
- swap,
- offendingMinorOpcode,
- offendingSequence,
- errorClass,
- severity,
- values)
- IceConn iceConn;
- Bool swap;
- int offendingMinorOpcode;
- unsigned long offendingSequence;
- int errorClass;
- int severity;
- IcePointer values;
+ice_error_handler (IceConn iceConn,
+ Bool swap,
+ int offendingMinorOpcode,
+ unsigned long offendingSequence,
+ int errorClass,
+ int severity,
+ IcePointer values)
{
/* Empty */
}
static void
-ice_io_error_handler (iceConn)
- IceConn iceConn;
+ice_io_error_handler (IceConn iceConn)
{
/* Connection probably gone. */
- ice_fd = -1;
+ ice_connection_closed ();
}
/* This is called when the ICE connection is created or closed. The SM library
uses ICE as it transport protocol. */
static void
-ice_conn_watch_CB (iceConn, clientData, opening, watchData)
- IceConn iceConn;
- IcePointer clientData;
- Bool opening;
- IcePointer *watchData;
+ice_conn_watch_CB (IceConn iceConn, IcePointer clientData, int opening, IcePointer *watchData)
{
if (! opening)
{
- ice_fd = -1;
+ ice_connection_closed ();
return;
}
if (interrupt_input)
init_sigio (ice_fd);
#endif /* ! defined (SIGIO) */
+
+ add_keyboard_wait_descriptor (ice_fd);
}
/* Create the client leader window. */
+#ifndef USE_GTK
static void
-create_client_leader_window (dpyinfo, client_id)
- struct x_display_info *dpyinfo;
- char *client_id;
+create_client_leader_window (struct x_display_info *dpyinfo, char *client_id)
{
Window w;
XClassHint class_hints;
-1, -1, 1, 1,
CopyFromParent, CopyFromParent, CopyFromParent);
- class_hints.res_name = (char *) SDATA (Vx_resource_name);
- class_hints.res_class = (char *) SDATA (Vx_resource_class);
+ class_hints.res_name = SSDATA (Vx_resource_name);
+ class_hints.res_class = SSDATA (Vx_resource_class);
XSetClassHint (dpyinfo->display, w, &class_hints);
XStoreName (dpyinfo->display, w, class_hints.res_name);
- sm_id = XInternAtom (dpyinfo->display, "SM_CLIENT_ID", False);
- XChangeProperty (dpyinfo->display, w, sm_id, XA_STRING, 8, PropModeReplace,
- client_id, strlen (client_id));
+ XChangeProperty (dpyinfo->display, w, dpyinfo->Xatom_SM_CLIENT_ID,
+ XA_STRING, 8, PropModeReplace,
+ (unsigned char *)client_id, strlen (client_id));
dpyinfo->client_leader_window = w;
}
+#endif /* ! USE_GTK */
+
/* Try to open a connection to the session manager. */
void
-x_session_initialize (dpyinfo)
- struct x_display_info *dpyinfo;
+x_session_initialize (struct x_display_info *dpyinfo)
{
#define SM_ERRORSTRING_LEN 512
char errorstring[SM_ERRORSTRING_LEN];
SmcCallbacks callbacks;
int name_len = 0;
+ ice_fd = -1;
+ doing_interact = False;
+
/* Check if we where started by the session manager. If so, we will
have a previous id. */
if (! EQ (Vx_session_previous_id, Qnil) && STRINGP (Vx_session_previous_id))
- previous_id = SDATA (Vx_session_previous_id);
+ previous_id = SSDATA (Vx_session_previous_id);
/* Construct the path to the Emacs program. */
if (! EQ (Vinvocation_directory, Qnil))
- name_len += strlen (SDATA (Vinvocation_directory));
- name_len += strlen (SDATA (Vinvocation_name));
+ name_len += strlen (SSDATA (Vinvocation_directory));
+ name_len += strlen (SSDATA (Vinvocation_name));
/* This malloc will not be freed, but it is only done once, and hopefully
not very large */
emacs_program[0] = '\0';
if (! EQ (Vinvocation_directory, Qnil))
- strcpy (emacs_program, SDATA (Vinvocation_directory));
- strcat (emacs_program, SDATA (Vinvocation_name));
+ strcpy (emacs_program, SSDATA (Vinvocation_directory));
+ strcat (emacs_program, SSDATA (Vinvocation_name));
/* The SM protocol says all callbacks are mandatory, so set up all
here and in the mask passed to SmcOpenConnection. */
/* Ensure that the session manager is not contacted again. */
void
-x_session_close ()
+x_session_close (void)
{
- ice_fd = -1;
+ ice_connection_closed ();
}
is told to abort the window system shutdown.
Do not call this function yourself. */)
- (event)
- Lisp_Object event;
+ (Lisp_Object event)
{
+ int kill_emacs = CONSP (event) && CONSP (XCDR (event))
+ && EQ (Qt, XCAR (XCDR (event)));
+
/* Check doing_interact so that we don't do anything if someone called
this at the wrong time. */
- if (doing_interact)
+ if (doing_interact && ! kill_emacs)
{
Bool cancel_shutdown = False;
doing_interact = False;
}
+ else if (kill_emacs)
+ {
+ /* We should not do user interaction here, but it is not easy to
+ prevent. Fix this in next version. */
+ Fkill_emacs (Qnil);
+
+ /* This will not be reached, but we want kill-emacs-hook to be run. */
+ SmcCloseConnection (smc_conn, 0, 0);
+ ice_connection_closed ();
+ }
return Qnil;
}
+
\f
/***********************************************************************
Initialization
***********************************************************************/
void
-syms_of_xsmfns ()
+syms_of_xsmfns (void)
{
- DEFVAR_LISP ("x-session-id", &Vx_session_id,
+ DEFVAR_LISP ("x-session-id", Vx_session_id,
doc: /* The session id Emacs got from the session manager for this session.
Changing the value does not change the session id used by Emacs.
The value is nil if no session manager is running.
`emacs-session-save' and `emacs-session-restore'." */);
Vx_session_id = Qnil;
- DEFVAR_LISP ("x-session-previous-id", &Vx_session_previous_id,
+ DEFVAR_LISP ("x-session-previous-id", Vx_session_previous_id,
doc: /* The previous session id Emacs got from session manager.
If Emacs is running on a window system that has a session manager, the
session manager gives Emacs a session id. It is feasible for Emacs Lisp
}
#endif /* HAVE_X_SM */
-
-/* arch-tag: 56a2c58c-adfa-430a-b772-130abd29fd2e
- (do not change this comment) */
HCoop / bpt / emacs.git / blobdiff