lightdm.c \
login1.c \
login1.h \
+ mir-server.c \
+ mir-server.h \
plymouth.c \
plymouth.h \
privileges.c \
session.h \
session-child.c \
session-child.h \
+ session-config.c \
+ session-config.h \
vnc-server.c \
vnc-server.h \
vt.c \
vt.h \
- xauthority.c \
- xauthority.h \
+ x-authority.c \
+ x-authority.h \
- x-greeter.c \
- x-greeter.h \
+ x-server-local.c \
+ x-server-local.h \
+ x-server-remote.c \
+ x-server-remote.h \
+ x-server-xvnc.c \
+ x-server-xvnc.h \
+ x-server.c \
+ x-server.h \
- x-session.c \
- x-session.h \
xdmcp-protocol.c \
xdmcp-protocol.h \
xdmcp-server.c \
xdmcp-server.h \
xdmcp-session.c \
xdmcp-session.h \
- xdmcp-session-private.h \
- xserver-local.c \
- xserver-local.h \
- xserver-remote.c \
- xserver-remote.h \
- xserver-xvnc.c \
- xserver-xvnc.h \
- xserver.c \
- xserver.h
+ xdmcp-session-private.h
lightdm_CFLAGS = \
$(LIGHTDM_CFLAGS) \
#include "seat-unity.h"
#include "configuration.h"
- #include "xserver-local.h"
+ #include "x-server-local.h"
-#include "x-greeter.h"
-#include "x-session.h"
+#include "mir-server.h"
#include "vt.h"
#include "plymouth.h"
G_DEFINE_TYPE (SeatUnity, seat_unity, SEAT_TYPE);
+static gboolean
+seat_unity_get_start_local_sessions (Seat *seat)
+{
+ return !seat_get_string_property (seat, "xdmcp-manager");
+}
+
static void
seat_unity_setup (Seat *seat)
{
}
static DisplayServer *
-seat_unity_create_display_server (Seat *seat)
+create_x_server (Seat *seat)
{
- XServerLocal *xserver;
+ XServerLocal *x_server;
const gchar *command = NULL, *layout = NULL, *config_file = NULL, *xdmcp_manager = NULL, *key_name = NULL;
gboolean allow_tcp;
gint port = 0;
g_debug ("Starting X server on Unity compositor");
- xserver = xserver_local_new ();
+ x_server = x_server_local_new ();
if (!SEAT_UNITY (seat)->priv->use_vt_switching)
{
id = g_strdup_printf ("%d", SEAT_UNITY (seat)->priv->next_id);
SEAT_UNITY (seat)->priv->next_id++;
- xserver_local_set_mir_id (xserver, id);
- xserver_local_set_mir_socket (xserver, SEAT_UNITY (seat)->priv->mir_socket_filename);
+ x_server_local_set_mir_id (x_server, id);
+ x_server_local_set_mir_socket (x_server, SEAT_UNITY (seat)->priv->mir_socket_filename);
g_free (id);
}
command = seat_get_string_property (seat, "xserver-command");
if (command)
- xserver_local_set_command (xserver, command);
+ x_server_local_set_command (x_server, command);
layout = seat_get_string_property (seat, "xserver-layout");
if (layout)
- xserver_local_set_layout (xserver, layout);
+ x_server_local_set_layout (x_server, layout);
config_file = seat_get_string_property (seat, "xserver-config");
if (config_file)
- xserver_local_set_config (xserver, config_file);
+ x_server_local_set_config (x_server, config_file);
allow_tcp = seat_get_boolean_property (seat, "xserver-allow-tcp");
- xserver_local_set_allow_tcp (xserver, allow_tcp);
+ x_server_local_set_allow_tcp (x_server, allow_tcp);
xdmcp_manager = seat_get_string_property (seat, "xdmcp-manager");
if (xdmcp_manager)
- xserver_local_set_xdmcp_server (xserver, xdmcp_manager);
+ x_server_local_set_xdmcp_server (x_server, xdmcp_manager);
port = seat_get_integer_property (seat, "xdmcp-port");
if (port > 0)
- xserver_local_set_xdmcp_port (xserver, port);
+ x_server_local_set_xdmcp_port (x_server, port);
key_name = seat_get_string_property (seat, "xdmcp-key");
if (key_name)
g_debug ("Key %s not defined", key_name);
if (key)
- xserver_local_set_xdmcp_key (xserver, key);
+ x_server_local_set_xdmcp_key (x_server, key);
g_free (key);
}
g_key_file_free (keys);
}
- return DISPLAY_SERVER (xserver);
+ return DISPLAY_SERVER (x_server);
}
+static DisplayServer *
+seat_unity_create_display_server (Seat *seat, const gchar *session_type)
+{
+ if (strcmp (session_type, "x") == 0)
+ return create_x_server (seat);
+ else if (strcmp (session_type, "mir") == 0)
+ return DISPLAY_SERVER (mir_server_new ());
+ else
+ {
+ g_warning ("Can't create unsupported display server '%s'", session_type);
+ return NULL;
+ }
+}
+
static Greeter *
seat_unity_create_greeter_session (Seat *seat)
{
- XGreeter *greeter_session;
+ Greeter *greeter_session;
- greeter_session = x_greeter_new ();
+ greeter_session = greeter_new ();
session_set_env (SESSION (greeter_session), "XDG_SEAT", "seat0");
- return GREETER (greeter_session);
+ return greeter_session;
}
static Session *
seat_unity_create_session (Seat *seat)
{
- XSession *session;
+ Session *session;
- session = x_session_new ();
- session_set_env (SESSION (session), "XDG_SEAT", "seat0");
+ session = session_new ();
+ session_set_env (session, "XDG_SEAT", "seat0");
- return SESSION (session);
+ return session;
}
static void
const gchar *id;
SEAT_UNITY (seat)->priv->active_display_server = g_object_ref (display_server);
- id = xserver_local_get_mir_id (XSERVER_LOCAL (display_server));
+ id = x_server_local_get_mir_id (X_SERVER_LOCAL (display_server));
g_debug ("Switching to Mir session %s", id);
write_message (SEAT_UNITY (seat), USC_MESSAGE_SET_ACTIVE_SESSION, (const guint8 *) id, strlen (id));
seat_unity_run_script (Seat *seat, DisplayServer *display_server, Process *script)
{
const gchar *path;
- XServerLocal *xserver;
+ XServerLocal *x_server;
- xserver = XSERVER_LOCAL (display_server);
- path = xserver_local_get_authority_file_path (xserver);
- process_set_env (script, "DISPLAY", xserver_get_address (XSERVER (xserver)));
+ x_server = X_SERVER_LOCAL (display_server);
+ path = x_server_local_get_authority_file_path (x_server);
+ process_set_env (script, "DISPLAY", x_server_get_address (X_SERVER (x_server)));
process_set_env (script, "XAUTHORITY", path);
SEAT_CLASS (seat_unity_parent_class)->run_script (seat, display_server, script);
SeatClass *seat_class = SEAT_CLASS (klass);
object_class->finalize = seat_unity_finalize;
+ seat_class->get_start_local_sessions = seat_unity_get_start_local_sessions;
seat_class->setup = seat_unity_setup;
seat_class->start = seat_unity_start;
seat_class->create_display_server = seat_unity_create_display_server;
#include <string.h>
#include "seat-xdmcp-session.h"
- #include "xserver-remote.h"
+ #include "x-server-remote.h"
-#include "x-greeter.h"
-#include "x-session.h"
struct SeatXDMCPSessionPrivate
{
}
static DisplayServer *
-seat_xdmcp_session_create_display_server (Seat *seat)
+seat_xdmcp_session_create_display_server (Seat *seat, const gchar *session_type)
{
XAuthority *authority;
gchar *host;
- XServerRemote *xserver;
+ XServerRemote *x_server;
+ if (strcmp (session_type, "x") != 0)
+ {
+ g_warning ("XDMCP seat only supports X display servers, not '%s'", session_type);
+ return NULL;
+ }
+
authority = xdmcp_session_get_authority (SEAT_XDMCP_SESSION (seat)->priv->session);
host = g_inet_address_to_string (xdmcp_session_get_address (SEAT_XDMCP_SESSION (seat)->priv->session));
- xserver = xserver_remote_new (host, xdmcp_session_get_display_number (SEAT_XDMCP_SESSION (seat)->priv->session), authority);
+ x_server = x_server_remote_new (host, xdmcp_session_get_display_number (SEAT_XDMCP_SESSION (seat)->priv->session), authority);
g_free (host);
- return DISPLAY_SERVER (xserver);
+ return DISPLAY_SERVER (x_server);
}
-static Greeter *
-seat_xdmcp_session_create_greeter_session (Seat *seat)
-{
- return GREETER (x_greeter_new ());
-}
-
-static Session *
-seat_xdmcp_session_create_session (Seat *seat)
-{
- return SESSION (x_session_new ());
-}
-
static void
seat_xdmcp_session_init (SeatXDMCPSession *seat)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
seat_class->create_display_server = seat_xdmcp_session_create_display_server;
- seat_class->create_greeter_session = seat_xdmcp_session_create_greeter_session;
- seat_class->create_session = seat_xdmcp_session_create_session;
object_class->finalize = seat_xdmcp_session_finalize;
g_type_class_add_private (klass, sizeof (SeatXDMCPSessionPrivate));
#include "seat-xlocal.h"
#include "configuration.h"
- #include "xserver-local.h"
+ #include "x-server-local.h"
-#include "x-greeter.h"
-#include "x-session.h"
+#include "mir-server.h"
#include "vt.h"
G_DEFINE_TYPE (SeatXLocal, seat_xlocal, SEAT_TYPE);
+static gboolean
+seat_xlocal_get_start_local_sessions (Seat *seat)
+{
+ return !seat_get_string_property (seat, "xdmcp-manager");
+}
+
static void
seat_xlocal_setup (Seat *seat)
{
}
static DisplayServer *
-seat_xlocal_create_display_server (Seat *seat)
+create_x_server (Seat *seat)
{
- XServerLocal *xserver;
+ XServerLocal *x_server;
const gchar *command = NULL, *layout = NULL, *config_file = NULL, *xdmcp_manager = NULL, *key_name = NULL;
gboolean allow_tcp;
gint port = 0;
g_debug ("Starting local X display");
- xserver = xserver_local_new ();
+ x_server = x_server_local_new ();
/* If running inside an X server use Xephyr instead */
if (g_getenv ("DISPLAY"))
if (!command)
command = seat_get_string_property (seat, "xserver-command");
if (command)
- xserver_local_set_command (xserver, command);
+ x_server_local_set_command (x_server, command);
layout = seat_get_string_property (seat, "xserver-layout");
if (layout)
- xserver_local_set_layout (xserver, layout);
+ x_server_local_set_layout (x_server, layout);
config_file = seat_get_string_property (seat, "xserver-config");
if (config_file)
- xserver_local_set_config (xserver, config_file);
+ x_server_local_set_config (x_server, config_file);
allow_tcp = seat_get_boolean_property (seat, "xserver-allow-tcp");
- xserver_local_set_allow_tcp (xserver, allow_tcp);
+ x_server_local_set_allow_tcp (x_server, allow_tcp);
xdmcp_manager = seat_get_string_property (seat, "xdmcp-manager");
if (xdmcp_manager)
- xserver_local_set_xdmcp_server (xserver, xdmcp_manager);
+ x_server_local_set_xdmcp_server (x_server, xdmcp_manager);
port = seat_get_integer_property (seat, "xdmcp-port");
if (port > 0)
- xserver_local_set_xdmcp_port (xserver, port);
+ x_server_local_set_xdmcp_port (x_server, port);
key_name = seat_get_string_property (seat, "xdmcp-key");
if (key_name)
g_debug ("Key %s not defined", key_name);
if (key)
- xserver_local_set_xdmcp_key (xserver, key);
+ x_server_local_set_xdmcp_key (x_server, key);
g_free (key);
}
g_key_file_free (keys);
}
- return DISPLAY_SERVER (xserver);
+ return DISPLAY_SERVER (x_server);
}
+static DisplayServer *
+seat_xlocal_create_display_server (Seat *seat, const gchar *session_type)
+{
+ if (strcmp (session_type, "x") == 0)
+ return create_x_server (seat);
+ else if (strcmp (session_type, "mir") == 0)
+ return DISPLAY_SERVER (mir_server_new ());
+ else
+ {
+ g_warning ("Can't create unsupported display server '%s'", session_type);
+ return NULL;
+ }
+}
+
static Greeter *
seat_xlocal_create_greeter_session (Seat *seat)
{
- XGreeter *greeter_session;
+ Greeter *greeter_session;
- greeter_session = x_greeter_new ();
+ greeter_session = SEAT_CLASS (seat_xlocal_parent_class)->create_greeter_session (seat);
session_set_env (SESSION (greeter_session), "XDG_SEAT", "seat0");
- return GREETER (greeter_session);
+ return greeter_session;
}
static Session *
seat_xlocal_create_session (Seat *seat)
{
- XSession *session;
+ Session *session;
- session = x_session_new ();
+ session = SEAT_CLASS (seat_xlocal_parent_class)->create_session (seat);
session_set_env (SESSION (session), "XDG_SEAT", "seat0");
- return SESSION (session);
+ return session;
}
static void
seat_xlocal_run_script (Seat *seat, DisplayServer *display_server, Process *script)
{
const gchar *path;
- XServerLocal *xserver;
+ XServerLocal *x_server;
- xserver = XSERVER_LOCAL (display_server);
- path = xserver_local_get_authority_file_path (xserver);
- process_set_env (script, "DISPLAY", xserver_get_address (XSERVER (xserver)));
+ x_server = X_SERVER_LOCAL (display_server);
+ path = x_server_local_get_authority_file_path (x_server);
+ process_set_env (script, "DISPLAY", x_server_get_address (X_SERVER (x_server)));
process_set_env (script, "XAUTHORITY", path);
SEAT_CLASS (seat_xlocal_parent_class)->run_script (seat, display_server, script);
{
SeatClass *seat_class = SEAT_CLASS (klass);
+ seat_class->get_start_local_sessions = seat_xlocal_get_start_local_sessions;
seat_class->setup = seat_xlocal_setup;
seat_class->create_display_server = seat_xlocal_create_display_server;
seat_class->create_greeter_session = seat_xlocal_create_greeter_session;
#include "seat-xremote.h"
#include "configuration.h"
- #include "xserver-remote.h"
+ #include "x-server-remote.h"
-#include "x-greeter.h"
-#include "x-session.h"
G_DEFINE_TYPE (SeatXRemote, seat_xremote, SEAT_TYPE);
}
static DisplayServer *
-seat_xremote_create_display_server (Seat *seat)
+seat_xremote_create_display_server (Seat *seat, const gchar *session_type)
{
- XServerRemote *xserver;
+ XServerRemote *x_server;
const gchar *hostname;
gint number;
+ if (strcmp (session_type, "x") != 0)
+ {
+ g_warning ("X remote seat only supports X display servers, not '%s'", session_type);
+ return NULL;
+ }
+
hostname = seat_get_string_property (seat, "xserver-hostname");
if (!hostname)
hostname = "localhost";
g_debug ("Starting remote X display %s:%d", hostname, number);
- xserver = xserver_remote_new (hostname, number, NULL);
+ x_server = x_server_remote_new (hostname, number, NULL);
- return DISPLAY_SERVER (xserver);
+ return DISPLAY_SERVER (x_server);
}
static Greeter *
seat_xremote_create_greeter_session (Seat *seat)
{
- XGreeter *greeter_session;
+ Greeter *greeter_session;
- greeter_session = x_greeter_new ();
+ greeter_session = SEAT_CLASS (seat_xremote_parent_class)->create_greeter_session (seat);
session_set_env (SESSION (greeter_session), "XDG_SEAT", "seat0");
- return GREETER (greeter_session);
+ return greeter_session;
}
static Session *
seat_xremote_create_session (Seat *seat)
{
- return SESSION (x_session_new ());
+ Session *session;
+
+ session = SEAT_CLASS (seat_xremote_parent_class)->create_session (seat);
+ session_set_env (SESSION (session), "XDG_SEAT", "seat0");
+
+ return session;
}
static void
seat_xremote_run_script (Seat *seat, DisplayServer *display_server, Process *script)
{
- XServerRemote *xserver;
+ XServerRemote *x_server;
- xserver = XSERVER_REMOTE (display_server);
- process_set_env (script, "DISPLAY", xserver_get_address (XSERVER (xserver)));
- process_set_env (script, "REMOTE_HOST", xserver_get_hostname (XSERVER (xserver)));
+ x_server = X_SERVER_REMOTE (display_server);
+ process_set_env (script, "DISPLAY", x_server_get_address (X_SERVER (x_server)));
+ process_set_env (script, "REMOTE_HOST", x_server_get_hostname (X_SERVER (x_server)));
SEAT_CLASS (seat_xremote_parent_class)->run_script (seat, display_server, script);
}
* license.
*/
+#include <string.h>
+
#include "seat-xvnc.h"
- #include "xserver-xvnc.h"
+ #include "x-server-xvnc.h"
-#include "x-greeter.h"
-#include "x-session.h"
#include "configuration.h"
G_DEFINE_TYPE (SeatXVNC, seat_xvnc, SEAT_TYPE);
}
static DisplayServer *
-seat_xvnc_create_display_server (Seat *seat)
+seat_xvnc_create_display_server (Seat *seat, const gchar *session_type)
{
- XServerXVNC *xserver;
+ XServerXVNC *x_server;
const gchar *command = NULL;
- xserver = xserver_xvnc_new ();
- xserver_xvnc_set_socket (xserver, g_socket_get_fd (SEAT_XVNC (seat)->priv->connection));
+ if (strcmp (session_type, "x") != 0)
+ {
+ g_warning ("XVNC seat only supports X display servers, not '%s'", session_type);
+ return NULL;
+ }
+
+ x_server = x_server_xvnc_new ();
+ x_server_xvnc_set_socket (x_server, g_socket_get_fd (SEAT_XVNC (seat)->priv->connection));
command = config_get_string (config_get_instance (), "VNCServer", "command");
if (command)
- xserver_xvnc_set_command (xserver, command);
+ x_server_xvnc_set_command (x_server, command);
if (config_has_key (config_get_instance (), "VNCServer", "width") &&
config_has_key (config_get_instance (), "VNCServer", "height"))
width = config_get_integer (config_get_instance (), "VNCServer", "width");
height = config_get_integer (config_get_instance (), "VNCServer", "height");
if (height > 0 && width > 0)
- xserver_xvnc_set_geometry (xserver, width, height);
+ x_server_xvnc_set_geometry (x_server, width, height);
}
if (config_has_key (config_get_instance (), "VNCServer", "depth"))
{
gint depth;
depth = config_get_integer (config_get_instance (), "VNCServer", "depth");
if (depth == 8 || depth == 16 || depth == 24 || depth == 32)
- xserver_xvnc_set_depth (xserver, depth);
+ x_server_xvnc_set_depth (x_server, depth);
}
- return DISPLAY_SERVER (xserver);
+ return DISPLAY_SERVER (x_server);
}
-static Greeter *
-seat_xvnc_create_greeter_session (Seat *seat)
-{
- return GREETER (x_greeter_new ());
-}
-
-static Session *
-seat_xvnc_create_session (Seat *seat)
-{
- return SESSION (x_session_new ());
-}
-
static void
seat_xvnc_run_script (Seat *seat, DisplayServer *display_server, Process *script)
{
- XServerXVNC *xserver;
+ XServerXVNC *x_server;
GInetSocketAddress *address;
gchar *hostname;
const gchar *path;
- xserver = XSERVER_XVNC (display_server);
+ x_server = X_SERVER_XVNC (display_server);
address = G_INET_SOCKET_ADDRESS (g_socket_get_remote_address (SEAT_XVNC (seat)->priv->connection, NULL));
hostname = g_inet_address_to_string (g_inet_socket_address_get_address (address));
- path = xserver_xvnc_get_authority_file_path (xserver);
+ path = x_server_xvnc_get_authority_file_path (x_server);
process_set_env (script, "REMOTE_HOST", hostname);
- process_set_env (script, "DISPLAY", xserver_get_address (XSERVER (xserver)));
+ process_set_env (script, "DISPLAY", x_server_get_address (X_SERVER (x_server)));
process_set_env (script, "XAUTHORITY", path);
g_free (hostname);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
seat_class->create_display_server = seat_xvnc_create_display_server;
- seat_class->create_greeter_session = seat_xvnc_create_greeter_session;
- seat_class->create_session = seat_xvnc_create_session;
seat_class->run_script = seat_xvnc_run_script;
object_class->finalize = seat_xdmcp_session_finalize;
struct SessionPrivate
{
+ /* Session type */
+ gchar *session_type;
+
/* Display server running on */
DisplayServer *display_server;
/* X display connected to */
gchar *xdisplay;
- XAuthority *xauthority;
- gboolean xauth_use_system_location;
+ XAuthority *x_authority;
+ gboolean x_authority_use_system_location;
/* Remote host this session is being controlled from */
gchar *remote_host_name;
G_DEFINE_TYPE (Session, session, G_TYPE_OBJECT);
+Session *
+session_new (void)
+{
+ return g_object_new (SESSION_TYPE, NULL);
+}
+
+void
+session_set_session_type (Session *session, const gchar *session_type)
+{
+ g_return_if_fail (session != NULL);
+ g_free (session->priv->session_type);
+ session->priv->session_type = g_strdup (session_type);
+}
+
+const gchar *
+session_get_session_type (Session *session)
+{
+ g_return_val_if_fail (session != NULL, NULL);
+ return session->priv->session_type;
+}
+
void
session_set_pam_service (Session *session, const gchar *pam_service)
{
}
void
- session_set_xauthority (Session *session, XAuthority *authority, gboolean use_system_location)
+ session_set_x_authority (Session *session, XAuthority *authority, gboolean use_system_location)
{
g_return_if_fail (session != NULL);
- if (session->priv->xauthority)
+ if (session->priv->x_authority)
{
- g_object_unref (session->priv->xauthority);
- session->priv->xauthority = NULL;
+ g_object_unref (session->priv->x_authority);
+ session->priv->x_authority = NULL;
}
if (authority)
- session->priv->xauthority = g_object_ref (authority);
- session->priv->xauth_use_system_location = use_system_location;
+ session->priv->x_authority = g_object_ref (authority);
+ session->priv->x_authority_use_system_location = use_system_location;
}
void
}
static void
- write_xauth (Session *session, XAuthority *xauthority)
+ write_xauth (Session *session, XAuthority *x_authority)
{
guint16 family;
gsize length;
- if (!xauthority)
+ if (!x_authority)
{
write_string (session, NULL);
return;
}
- write_string (session, xauth_get_authorization_name (session->priv->xauthority));
- family = xauth_get_family (session->priv->xauthority);
+ write_string (session, x_authority_get_authorization_name (session->priv->x_authority));
+ family = x_authority_get_family (session->priv->x_authority);
write_data (session, &family, sizeof (family));
- length = xauth_get_address_length (session->priv->xauthority);
+ length = x_authority_get_address_length (session->priv->x_authority);
write_data (session, &length, sizeof (length));
- write_data (session, xauth_get_address (session->priv->xauthority), length);
- write_string (session, xauth_get_number (session->priv->xauthority));
- length = xauth_get_authorization_data_length (session->priv->xauthority);
+ write_data (session, x_authority_get_address (session->priv->x_authority), length);
+ write_string (session, x_authority_get_number (session->priv->x_authority));
+ length = x_authority_get_authorization_data_length (session->priv->x_authority);
write_data (session, &length, sizeof (length));
- write_data (session, xauth_get_authorization_data (session->priv->xauthority), length);
+ write_data (session, x_authority_get_authorization_data (session->priv->x_authority), length);
}
static ssize_t
g_return_val_if_fail (session->priv->pid == 0, FALSE);
+ display_server_setup_session (session->priv->display_server, session);
+
/* Create pipes to talk to the child */
if (pipe (to_child_pipe) < 0 || pipe (from_child_pipe) < 0)
{
write_string (session, session->priv->tty);
write_string (session, session->priv->remote_host_name);
write_string (session, session->priv->xdisplay);
- write_xauth (session, session->priv->xauthority);
+ write_xauth (session, session->priv->x_authority);
g_debug ("Started session %d with service '%s', username '%s'", session->priv->pid, session->priv->pam_service, session->priv->username);
session_real_run (Session *session)
{
gsize i, argc;
- gchar *command, *xauth_filename;
+ gchar *command, *x_authority_filename;
GList *link;
g_return_if_fail (session != NULL);
g_return_if_fail (session->priv->argv != NULL);
g_return_if_fail (session->priv->pid != 0);
+ display_server_setup_session (session->priv->display_server, session);
+
session->priv->command_run = TRUE;
command = g_strjoinv (" ", session->priv->argv);
g_free (command);
/* Create authority location */
- if (session->priv->xauth_use_system_location)
+ if (session->priv->x_authority_use_system_location)
{
gchar *run_dir, *dir;
g_warning ("Failed to set ownership of user authority dir: %s", strerror (errno));
}
- xauth_filename = g_build_filename (dir, "xauthority", NULL);
+ x_authority_filename = g_build_filename (dir, "xauthority", NULL);
g_free (dir);
}
else
- xauth_filename = g_build_filename (user_get_home_directory (session_get_user (session)), ".Xauthority", NULL);
+ x_authority_filename = g_build_filename (user_get_home_directory (session_get_user (session)), ".Xauthority", NULL);
write_string (session, session->priv->log_filename);
write_string (session, session->priv->tty);
- write_string (session, xauth_filename);
- g_free (xauth_filename);
+ write_string (session, x_authority_filename);
+ g_free (x_authority_filename);
write_string (session, session->priv->xdisplay);
- write_xauth (session, session->priv->xauthority);
+ write_xauth (session, session->priv->x_authority);
argc = g_list_length (session->priv->env);
write_data (session, &argc, sizeof (argc));
for (link = session->priv->env; link; link = link->next)
session_init (Session *session)
{
session->priv = G_TYPE_INSTANCE_GET_PRIVATE (session, SESSION_TYPE, SessionPrivate);
+ session->priv->log_filename = g_strdup (".xsession-errors");
}
static void
Session *self = SESSION (object);
int i;
+ g_free (self->priv->session_type);
if (self->priv->display_server)
g_object_unref (self->priv->display_server);
if (self->priv->pid)
g_free (self->priv->class);
g_free (self->priv->tty);
g_free (self->priv->xdisplay);
- if (self->priv->xauthority)
- g_object_unref (self->priv->xauthority);
+ if (self->priv->x_authority)
+ g_object_unref (self->priv->x_authority);
g_free (self->priv->remote_host_name);
g_free (self->priv->login1_session);
g_free (self->priv->console_kit_cookie);
#include <security/pam_appl.h>
+typedef struct Session Session;
+
#include "display-server.h"
#include "accounts.h"
- #include "xauthority.h"
+ #include "x-authority.h"
G_BEGIN_DECLS
typedef struct SessionPrivate SessionPrivate;
-typedef struct
+struct Session
{
GObject parent_instance;
SessionPrivate *priv;
-} Session;
+};
typedef struct
{
GType session_get_type (void);
+Session *session_new (void);
+
+void session_set_session_type (Session *session, const gchar *session_type);
+
+const gchar *session_get_session_type (Session *session);
+
void session_set_pam_service (Session *session, const gchar *pam_service);
void session_set_username (Session *session, const gchar *username);
void session_set_xdisplay (Session *session, const gchar *xdisplay);
- void session_set_xauthority (Session *session, XAuthority *authority, gboolean use_system_location);
+ void session_set_x_authority (Session *session, XAuthority *authority, gboolean use_system_location);
void session_set_remote_host_name (Session *session, const gchar *remote_host_name);
#include <glib/gstdio.h>
#include <stdlib.h>
- #include "xserver-local.h"
+ #include "x-server-local.h"
#include "configuration.h"
#include "process.h"
#include "vt.h"
struct XServerLocalPrivate
{
/* X server process */
- Process *xserver_process;
+ Process *x_server_process;
/* File to log to */
gchar *log_file;
gboolean replacing_plymouth;
};
- G_DEFINE_TYPE (XServerLocal, xserver_local, XSERVER_TYPE);
+ G_DEFINE_TYPE (XServerLocal, x_server_local, X_SERVER_TYPE);
static GList *display_numbers = NULL;
}
guint
- xserver_local_get_unused_display_number (void)
+ x_server_local_get_unused_display_number (void)
{
guint number;
}
void
- xserver_local_release_display_number (guint display_number)
+ x_server_local_release_display_number (guint display_number)
{
GList *link;
for (link = display_numbers; link; link = link->next)
}
XServerLocal *
- xserver_local_new (void)
+ x_server_local_new (void)
{
- XServerLocal *self = g_object_new (XSERVER_LOCAL_TYPE, NULL);
+ XServerLocal *self = g_object_new (X_SERVER_LOCAL_TYPE, NULL);
gchar hostname[1024], *number, *name;
- xserver_set_display_number (XSERVER (self), xserver_local_get_unused_display_number ());
+ x_server_set_display_number (X_SERVER (self), x_server_local_get_unused_display_number ());
gethostname (hostname, 1024);
- number = g_strdup_printf ("%d", xserver_get_display_number (XSERVER (self)));
- xserver_set_authority (XSERVER (self), xauth_new_cookie (XAUTH_FAMILY_LOCAL, (guint8*) hostname, strlen (hostname), number));
+ number = g_strdup_printf ("%d", x_server_get_display_number (X_SERVER (self)));
+ x_server_set_authority (X_SERVER (self), x_authority_new_cookie (XAUTH_FAMILY_LOCAL, (guint8*) hostname, strlen (hostname), number));
g_free (number);
- name = g_strdup_printf ("x-%d", xserver_get_display_number (XSERVER (self)));
+ name = g_strdup_printf ("x-%d", x_server_get_display_number (X_SERVER (self)));
display_server_set_name (DISPLAY_SERVER (self), name);
g_free (name);
gint active_vt = vt_get_active ();
if (active_vt >= vt_get_min ())
{
- g_debug ("X server %s will replace Plymouth", xserver_get_address (XSERVER (self)));
+ g_debug ("X server %s will replace Plymouth", x_server_get_address (X_SERVER (self)));
self->priv->replacing_plymouth = TRUE;
self->priv->vt = active_vt;
plymouth_deactivate ();
}
void
- xserver_local_set_command (XServerLocal *server, const gchar *command)
+ x_server_local_set_command (XServerLocal *server, const gchar *command)
{
g_return_if_fail (server != NULL);
g_free (server->priv->command);
}
void
- xserver_local_set_config (XServerLocal *server, const gchar *path)
+ x_server_local_set_config (XServerLocal *server, const gchar *path)
{
g_return_if_fail (server != NULL);
g_free (server->priv->config_file);
}
void
- xserver_local_set_layout (XServerLocal *server, const gchar *layout)
+ x_server_local_set_layout (XServerLocal *server, const gchar *layout)
{
g_return_if_fail (server != NULL);
g_free (server->priv->layout);
}
void
- xserver_local_set_allow_tcp (XServerLocal *server, gboolean allow_tcp)
+ x_server_local_set_allow_tcp (XServerLocal *server, gboolean allow_tcp)
{
g_return_if_fail (server != NULL);
server->priv->allow_tcp = allow_tcp;
}
void
- xserver_local_set_xdmcp_server (XServerLocal *server, const gchar *hostname)
+ x_server_local_set_xdmcp_server (XServerLocal *server, const gchar *hostname)
{
g_return_if_fail (server != NULL);
g_free (server->priv->xdmcp_server);
server->priv->xdmcp_server = g_strdup (hostname);
- display_server_set_start_local_sessions (DISPLAY_SERVER (server), hostname == NULL);
}
const gchar *
- xserver_local_get_xdmcp_server (XServerLocal *server)
+ x_server_local_get_xdmcp_server (XServerLocal *server)
{
g_return_val_if_fail (server != NULL, 0);
return server->priv->xdmcp_server;
}
void
- xserver_local_set_xdmcp_port (XServerLocal *server, guint port)
+ x_server_local_set_xdmcp_port (XServerLocal *server, guint port)
{
g_return_if_fail (server != NULL);
server->priv->xdmcp_port = port;
}
guint
- xserver_local_get_xdmcp_port (XServerLocal *server)
+ x_server_local_get_xdmcp_port (XServerLocal *server)
{
g_return_val_if_fail (server != NULL, 0);
return server->priv->xdmcp_port;
}
void
- xserver_local_set_xdmcp_key (XServerLocal *server, const gchar *key)
+ x_server_local_set_xdmcp_key (XServerLocal *server, const gchar *key)
{
g_return_if_fail (server != NULL);
g_free (server->priv->xdmcp_key);
server->priv->xdmcp_key = g_strdup (key);
- xserver_set_authority (XSERVER (server), NULL);
+ x_server_set_authority (X_SERVER (server), NULL);
}
void
- xserver_local_set_mir_id (XServerLocal *server, const gchar *id)
+ x_server_local_set_mir_id (XServerLocal *server, const gchar *id)
{
g_return_if_fail (server != NULL);
g_free (server->priv->mir_id);
server->priv->vt = -1;
}
- const gchar *xserver_local_get_mir_id (XServerLocal *server)
+ const gchar *x_server_local_get_mir_id (XServerLocal *server)
{
g_return_val_if_fail (server != NULL, NULL);
return server->priv->mir_id;
}
void
- xserver_local_set_mir_socket (XServerLocal *server, const gchar *socket)
+ x_server_local_set_mir_socket (XServerLocal *server, const gchar *socket)
{
g_return_if_fail (server != NULL);
g_free (server->priv->mir_socket);
}
static gint
- xserver_local_get_vt (DisplayServer *server)
+ x_server_local_get_vt (DisplayServer *server)
{
g_return_val_if_fail (server != NULL, 0);
- return XSERVER_LOCAL (server)->priv->vt;
+ return X_SERVER_LOCAL (server)->priv->vt;
}
const gchar *
- xserver_local_get_authority_file_path (XServerLocal *server)
+ x_server_local_get_authority_file_path (XServerLocal *server)
{
g_return_val_if_fail (server != NULL, 0);
return server->priv->authority_file;
if (signum == SIGUSR1 && !server->priv->got_signal)
{
server->priv->got_signal = TRUE;
- g_debug ("Got signal from X server :%d", xserver_get_display_number (XSERVER (server)));
+ g_debug ("Got signal from X server :%d", x_server_get_display_number (X_SERVER (server)));
if (server->priv->replacing_plymouth)
{
}
// FIXME: Check return value
- DISPLAY_SERVER_CLASS (xserver_local_parent_class)->start (DISPLAY_SERVER (server));
+ DISPLAY_SERVER_CLASS (x_server_local_parent_class)->start (DISPLAY_SERVER (server));
}
}
{
g_debug ("X server stopped");
- xserver_local_release_display_number (xserver_get_display_number (XSERVER (server)));
+ x_server_local_release_display_number (x_server_get_display_number (X_SERVER (server)));
- if (xserver_get_authority (XSERVER (server)) && server->priv->authority_file)
+ if (x_server_get_authority (X_SERVER (server)) && server->priv->authority_file)
{
g_debug ("Removing X server authority %s", server->priv->authority_file);
plymouth_quit (FALSE);
}
- DISPLAY_SERVER_CLASS (xserver_local_parent_class)->stop (DISPLAY_SERVER (server));
+ DISPLAY_SERVER_CLASS (x_server_local_parent_class)->stop (DISPLAY_SERVER (server));
}
static void
XAuthority *authority;
GError *error = NULL;
- authority = xserver_get_authority (XSERVER (server));
+ authority = x_server_get_authority (X_SERVER (server));
if (!authority)
return;
if (g_mkdir_with_parents (dir, S_IRWXU) < 0)
g_warning ("Failed to make authority directory %s: %s", dir, strerror (errno));
- server->priv->authority_file = g_build_filename (dir, xserver_get_address (XSERVER (server)), NULL);
+ server->priv->authority_file = g_build_filename (dir, x_server_get_address (X_SERVER (server)), NULL);
g_free (dir);
}
g_debug ("Writing X server authority to %s", server->priv->authority_file);
- xauth_write (authority, XAUTH_WRITE_MODE_REPLACE, server->priv->authority_file, &error);
+ x_authority_write (authority, XAUTH_WRITE_MODE_REPLACE, server->priv->authority_file, &error);
if (error)
g_warning ("Failed to write authority: %s", error->message);
g_clear_error (&error);
}
static gboolean
- xserver_local_start (DisplayServer *display_server)
+ x_server_local_start (DisplayServer *display_server)
{
- XServerLocal *server = XSERVER_LOCAL (display_server);
+ XServerLocal *server = X_SERVER_LOCAL (display_server);
gboolean result;
gchar *filename, *dir, *absolute_command;
GString *command;
- g_return_val_if_fail (server->priv->xserver_process == NULL, FALSE);
+ g_return_val_if_fail (server->priv->x_server_process == NULL, FALSE);
server->priv->got_signal = FALSE;
g_return_val_if_fail (server->priv->command != NULL, FALSE);
- server->priv->xserver_process = process_new ();
- process_set_clear_environment (server->priv->xserver_process, TRUE);
- g_signal_connect (server->priv->xserver_process, "run", G_CALLBACK (run_cb), server);
- g_signal_connect (server->priv->xserver_process, "got-signal", G_CALLBACK (got_signal_cb), server);
- g_signal_connect (server->priv->xserver_process, "stopped", G_CALLBACK (stopped_cb), server);
+ server->priv->x_server_process = process_new ();
+ process_set_clear_environment (server->priv->x_server_process, TRUE);
+ g_signal_connect (server->priv->x_server_process, "run", G_CALLBACK (run_cb), server);
+ g_signal_connect (server->priv->x_server_process, "got-signal", G_CALLBACK (got_signal_cb), server);
+ g_signal_connect (server->priv->x_server_process, "stopped", G_CALLBACK (stopped_cb), server);
/* Setup logging */
filename = g_strdup_printf ("%s.log", display_server_get_name (display_server));
if (!absolute_command)
{
g_debug ("Can't launch X server %s, not found in path", server->priv->command);
- stopped_cb (server->priv->xserver_process, XSERVER_LOCAL (server));
+ stopped_cb (server->priv->x_server_process, X_SERVER_LOCAL (server));
return FALSE;
}
command = g_string_new (absolute_command);
g_free (absolute_command);
- g_string_append_printf (command, " :%d", xserver_get_display_number (XSERVER (server)));
+ g_string_append_printf (command, " :%d", x_server_get_display_number (X_SERVER (server)));
if (server->priv->config_file)
g_string_append_printf (command, " -config %s", server->priv->config_file);
if (server->priv->replacing_plymouth)
g_string_append (command, " -background none");
- process_set_command (server->priv->xserver_process, command->str);
+ process_set_command (server->priv->x_server_process, command->str);
g_string_free (command, TRUE);
g_debug ("Launching X Server");
/* If running inside another display then pass through those variables */
if (g_getenv ("DISPLAY"))
{
- process_set_env (server->priv->xserver_process, "DISPLAY", g_getenv ("DISPLAY"));
+ process_set_env (server->priv->x_server_process, "DISPLAY", g_getenv ("DISPLAY"));
if (g_getenv ("XAUTHORITY"))
- process_set_env (server->priv->xserver_process, "XAUTHORITY", g_getenv ("XAUTHORITY"));
+ process_set_env (server->priv->x_server_process, "XAUTHORITY", g_getenv ("XAUTHORITY"));
else
{
gchar *path;
path = g_build_filename (g_get_home_dir (), ".Xauthority", NULL);
- process_set_env (server->priv->xserver_process, "XAUTHORITY", path);
+ process_set_env (server->priv->x_server_process, "XAUTHORITY", path);
g_free (path);
}
}
/* Variable required for regression tests */
if (g_getenv ("LIGHTDM_TEST_ROOT"))
{
- process_set_env (server->priv->xserver_process, "LIGHTDM_TEST_ROOT", g_getenv ("LIGHTDM_TEST_ROOT"));
- process_set_env (server->priv->xserver_process, "LD_PRELOAD", g_getenv ("LD_PRELOAD"));
- process_set_env (server->priv->xserver_process, "LD_LIBRARY_PATH", g_getenv ("LD_LIBRARY_PATH"));
+ process_set_env (server->priv->x_server_process, "LIGHTDM_TEST_ROOT", g_getenv ("LIGHTDM_TEST_ROOT"));
+ process_set_env (server->priv->x_server_process, "LD_PRELOAD", g_getenv ("LD_PRELOAD"));
+ process_set_env (server->priv->x_server_process, "LD_LIBRARY_PATH", g_getenv ("LD_LIBRARY_PATH"));
}
- result = process_start (server->priv->xserver_process, FALSE);
+ result = process_start (server->priv->x_server_process, FALSE);
if (result)
- g_debug ("Waiting for ready signal from X server :%d", xserver_get_display_number (XSERVER (server)));
+ g_debug ("Waiting for ready signal from X server :%d", x_server_get_display_number (X_SERVER (server)));
if (!result)
- stopped_cb (server->priv->xserver_process, XSERVER_LOCAL (server));
+ stopped_cb (server->priv->x_server_process, X_SERVER_LOCAL (server));
return result;
}
static void
- xserver_local_stop (DisplayServer *server)
+ x_server_local_stop (DisplayServer *server)
{
- process_stop (XSERVER_LOCAL (server)->priv->xserver_process);
+ process_stop (X_SERVER_LOCAL (server)->priv->x_server_process);
}
static void
- xserver_local_init (XServerLocal *server)
+ x_server_local_init (XServerLocal *server)
{
- server->priv = G_TYPE_INSTANCE_GET_PRIVATE (server, XSERVER_LOCAL_TYPE, XServerLocalPrivate);
+ server->priv = G_TYPE_INSTANCE_GET_PRIVATE (server, X_SERVER_LOCAL_TYPE, XServerLocalPrivate);
server->priv->vt = -1;
server->priv->command = g_strdup ("X");
}
static void
- xserver_local_finalize (GObject *object)
+ x_server_local_finalize (GObject *object)
{
XServerLocal *self;
- self = XSERVER_LOCAL (object);
+ self = X_SERVER_LOCAL (object);
- if (self->priv->xserver_process)
+ if (self->priv->x_server_process)
{
- g_signal_handlers_disconnect_matched (self->priv->xserver_process, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, self);
- g_object_unref (self->priv->xserver_process);
+ g_signal_handlers_disconnect_matched (self->priv->x_server_process, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, self);
+ g_object_unref (self->priv->x_server_process);
}
g_free (self->priv->log_file);
g_free (self->priv->command);
if (self->priv->have_vt_ref)
vt_unref (self->priv->vt);
- G_OBJECT_CLASS (xserver_local_parent_class)->finalize (object);
+ G_OBJECT_CLASS (x_server_local_parent_class)->finalize (object);
}
static void
- xserver_local_class_init (XServerLocalClass *klass)
+ x_server_local_class_init (XServerLocalClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
DisplayServerClass *display_server_class = DISPLAY_SERVER_CLASS (klass);
- display_server_class->get_vt = xserver_local_get_vt;
- display_server_class->start = xserver_local_start;
- display_server_class->stop = xserver_local_stop;
- object_class->finalize = xserver_local_finalize;
+ display_server_class->get_vt = x_server_local_get_vt;
+ display_server_class->start = x_server_local_start;
+ display_server_class->stop = x_server_local_stop;
+ object_class->finalize = x_server_local_finalize;
g_type_class_add_private (klass, sizeof (XServerLocalPrivate));
}
#include <string.h>
#include <xcb/xcb.h>
- #include "xserver.h"
+ #include "x-server.h"
-#include "x-session.h"
+#include "configuration.h"
struct XServerPrivate
{
xcb_connection_t *connection;
};
- G_DEFINE_TYPE (XServer, xserver, DISPLAY_SERVER_TYPE);
+ G_DEFINE_TYPE (XServer, x_server, DISPLAY_SERVER_TYPE);
void
- xserver_set_hostname (XServer *server, const gchar *hostname)
+ x_server_set_hostname (XServer *server, const gchar *hostname)
{
g_return_if_fail (server != NULL);
g_free (server->priv->hostname);
}
gchar *
- xserver_get_hostname (XServer *server)
+ x_server_get_hostname (XServer *server)
{
g_return_val_if_fail (server != NULL, NULL);
return server->priv->hostname;
}
void
- xserver_set_display_number (XServer *server, guint number)
+ x_server_set_display_number (XServer *server, guint number)
{
g_return_if_fail (server != NULL);
server->priv->number = number;
}
guint
- xserver_get_display_number (XServer *server)
+ x_server_get_display_number (XServer *server)
{
g_return_val_if_fail (server != NULL, 0);
return server->priv->number;
}
const gchar *
- xserver_get_address (XServer *server)
+ x_server_get_address (XServer *server)
{
g_return_val_if_fail (server != NULL, NULL);
}
void
- xserver_set_authority (XServer *server, XAuthority *authority)
+ x_server_set_authority (XServer *server, XAuthority *authority)
{
g_return_if_fail (server != NULL);
}
XAuthority *
- xserver_get_authority (XServer *server)
+ x_server_get_authority (XServer *server)
{
g_return_val_if_fail (server != NULL, NULL);
return server->priv->authority;
}
static gboolean
- xserver_start (DisplayServer *display_server)
+ x_server_start (DisplayServer *display_server)
{
- XServer *server = XSERVER (display_server);
+ XServer *server = X_SERVER (display_server);
xcb_auth_info_t *auth = NULL, a;
if (server->priv->authority)
{
- a.namelen = strlen (xauth_get_authorization_name (server->priv->authority));
- a.name = (char *) xauth_get_authorization_name (server->priv->authority);
- a.datalen = xauth_get_authorization_data_length (server->priv->authority);
- a.data = (char *) xauth_get_authorization_data (server->priv->authority);
+ a.namelen = strlen (x_authority_get_authorization_name (server->priv->authority));
+ a.name = (char *) x_authority_get_authorization_name (server->priv->authority);
+ a.datalen = x_authority_get_authorization_data_length (server->priv->authority);
+ a.data = (char *) x_authority_get_authorization_data (server->priv->authority);
auth = &a;
}
/* Open connection */
- g_debug ("Connecting to XServer %s", xserver_get_address (server));
- server->priv->connection = xcb_connect_to_display_with_auth_info (xserver_get_address (server), auth, NULL);
+ g_debug ("Connecting to XServer %s", x_server_get_address (server));
+ server->priv->connection = xcb_connect_to_display_with_auth_info (x_server_get_address (server), auth, NULL);
if (xcb_connection_has_error (server->priv->connection))
{
- g_debug ("Error connecting to XServer %s", xserver_get_address (server));
+ g_debug ("Error connecting to XServer %s", x_server_get_address (server));
return FALSE;
}
- return DISPLAY_SERVER_CLASS (xserver_parent_class)->start (display_server);
+ return DISPLAY_SERVER_CLASS (x_server_parent_class)->start (display_server);
}
static void
- xserver_setup_session (DisplayServer *display_server, Session *session)
++x_server_setup_session (DisplayServer *display_server, Session *session)
+{
+ gint vt;
+
+ display_server = session_get_display_server (session);
+
+ vt = display_server_get_vt (display_server);
+ if (vt > 0)
+ {
+ gchar *t;
+
+ t = g_strdup_printf ("/dev/tty%d", vt);
+ session_set_tty (session, t);
+ g_free (t);
+
+ t = g_strdup_printf ("%d", vt);
+ session_set_env (session, "XDG_VTNR", t);
+ g_free (t);
+ }
+
- session_set_env (session, "DISPLAY", xserver_get_address (XSERVER (display_server)));
- session_set_tty (session, xserver_get_address (XSERVER (display_server)));
- session_set_xdisplay (session, xserver_get_address (XSERVER (display_server)));
- session_set_remote_host_name (session, xserver_get_hostname (XSERVER (display_server)));
- session_set_xauthority (session,
- xserver_get_authority (XSERVER (display_server)),
- config_get_boolean (config_get_instance (), "LightDM", "user-authority-in-system-dir"));
++ session_set_env (session, "DISPLAY", x_server_get_address (X_SERVER (display_server)));
++ session_set_tty (session, x_server_get_address (X_SERVER (display_server)));
++ session_set_xdisplay (session, x_server_get_address (X_SERVER (display_server)));
++ session_set_remote_host_name (session, x_server_get_hostname (X_SERVER (display_server)));
++ session_set_x_authority (session,
++ x_server_get_authority (X_SERVER (display_server)),
++ config_get_boolean (config_get_instance (), "LightDM", "user-authority-in-system-dir"));
+}
+
- static void
- xserver_init (XServer *server)
++void
+ x_server_init (XServer *server)
{
- server->priv = G_TYPE_INSTANCE_GET_PRIVATE (server, XSERVER_TYPE, XServerPrivate);
+ server->priv = G_TYPE_INSTANCE_GET_PRIVATE (server, X_SERVER_TYPE, XServerPrivate);
}
static void
- xserver_finalize (GObject *object)
+ x_server_finalize (GObject *object)
{
XServer *self;
- self = XSERVER (object);
+ self = X_SERVER (object);
g_free (self->priv->hostname);
g_free (self->priv->address);
if (self->priv->connection)
xcb_disconnect (self->priv->connection);
- G_OBJECT_CLASS (xserver_parent_class)->finalize (object);
+ G_OBJECT_CLASS (x_server_parent_class)->finalize (object);
}
static void
- xserver_class_init (XServerClass *klass)
+ x_server_class_init (XServerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
DisplayServerClass *display_server_class = DISPLAY_SERVER_CLASS (klass);
- display_server_class->start = xserver_start;
- display_server_class->setup_session = xserver_setup_session;
- object_class->finalize = xserver_finalize;
+ display_server_class->start = x_server_start;
++ display_server_class->setup_session = x_server_setup_session;
+ object_class->finalize = x_server_finalize;
g_type_class_add_private (klass, sizeof (XServerPrivate));
}
projects / sojka / lightdm.git / commitdiff