moving from https://github.com/perberos/mate-desktop-environment

1 files changed, 496 insertions, 0 deletions

diff --git a/mate-session/mdm.c b/mate-session/mdm.c
new file mode 100644
index 0000000..e6e2eac
--- /dev/null
+++ b/mate-session/mdm.c
@@ -0,0 +1,496 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2005 Raffaele Sandrini
+ * Copyright (C) 2005 Red Hat, Inc.
+ * Copyright (C) 2002, 2003 George Lebl
+ * Copyright (C) 2001 Queen of England,
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors:
+ *      Raffaele Sandrini <[email protected]>
+ *      George Lebl <[email protected]>
+ *      Mark McLoughlin <[email protected]>
+ */
+
+#ifdef HAVE_CONFIG_H
+	#include <config.h>
+#endif
+
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <time.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+
+#include <X11/Xauth.h>
+#include <gdk/gdk.h>
+
+#include "mdm.h"
+
+#define MDM_PROTOCOL_UPDATE_INTERVAL 1 /* seconds */
+
+#define MDM_PROTOCOL_SOCKET_PATH "/var/run/mdm_socket"
+
+#define MDM_PROTOCOL_MSG_CLOSE "CLOSE"
+#define MDM_PROTOCOL_MSG_VERSION "VERSION"
+#define MDM_PROTOCOL_MSG_AUTHENTICATE "AUTH_LOCAL"
+#define MDM_PROTOCOL_MSG_QUERY_ACTION "QUERY_LOGOUT_ACTION"
+#define MDM_PROTOCOL_MSG_SET_ACTION "SET_SAFE_LOGOUT_ACTION"
+#define MDM_PROTOCOL_MSG_FLEXI_XSERVER "FLEXI_XSERVER"
+
+#define MDM_ACTION_STR_NONE "NONE"
+#define MDM_ACTION_STR_SHUTDOWN "HALT"
+#define MDM_ACTION_STR_REBOOT "REBOOT"
+#define MDM_ACTION_STR_SUSPEND "SUSPEND"
+
+typedef struct {
+	int fd;
+	char* auth_cookie;
+
+	MdmLogoutAction available_actions;
+	MdmLogoutAction current_actions;
+
+	time_t last_update;
+} MdmProtocolData;
+
+static MdmProtocolData mdm_protocol_data = {
+	0,
+	NULL,
+	MDM_LOGOUT_ACTION_NONE,
+	MDM_LOGOUT_ACTION_NONE,
+	0
+};
+
+static char* mdm_send_protocol_msg(MdmProtocolData* data, const char* msg)
+{
+	GString* retval;
+	char buf[256];
+	char* p;
+	int len;
+
+	p = g_strconcat(msg, "\n", NULL);
+
+	if (write(data->fd, p, strlen(p)) < 0)
+	{
+		g_free(p);
+
+		g_warning("Failed to send message to MDM: %s", g_strerror(errno));
+
+		return NULL;
+	}
+
+	g_free(p);
+
+	p = NULL;
+	retval = NULL;
+
+	while ((len = read(data->fd, buf, sizeof(buf) - 1)) > 0)
+	{
+		buf[len] = '\0';
+
+		if (!retval)
+		{
+			retval = g_string_new(buf);
+		}
+		else
+		{
+			retval = g_string_append(retval, buf);
+		}
+
+		if ((p = strchr(retval->str, '\n')))
+		{
+			break;
+		}
+	}
+
+	if (p)
+	{
+		*p = '\0';
+	}
+
+	return retval ? g_string_free(retval, FALSE) : NULL;
+}
+
+static char* get_display_number(void)
+{
+	const char* display_name;
+	char* retval;
+	char* p;
+
+	display_name = gdk_display_get_name(gdk_display_get_default());
+
+	p = strchr(display_name, ':');
+
+	if (!p)
+	{
+		return g_strdup("0");
+	}
+
+	while (*p == ':')
+	{
+		p++;
+	}
+
+	retval = g_strdup(p);
+
+	p = strchr(retval, '.');
+
+	if (p != NULL)
+	{
+		*p = '\0';
+	}
+
+	return retval;
+}
+
+static gboolean mdm_authenticate_connection(MdmProtocolData* data)
+{
+	#define MDM_MIT_MAGIC_COOKIE_LEN 16
+
+	const char* xau_path;
+	FILE* f;
+	Xauth* xau;
+	char* display_number;
+	gboolean retval;
+
+	if (data->auth_cookie)
+	{
+		char* msg;
+		char* response;
+
+		msg = g_strdup_printf(MDM_PROTOCOL_MSG_AUTHENTICATE " %s", data->auth_cookie);
+		response = mdm_send_protocol_msg(data, msg);
+		g_free(msg);
+
+		if (response && !strcmp(response, "OK"))
+		{
+			g_free(response);
+			return TRUE;
+		}
+		else
+		{
+			g_free(response);
+			g_free(data->auth_cookie);
+			data->auth_cookie = NULL;
+		}
+	}
+
+	if (!(xau_path = XauFileName()))
+	{
+		return FALSE;
+	}
+
+	if (!(f = fopen(xau_path, "r")))
+	{
+		return FALSE;
+	}
+
+	retval = FALSE;
+	display_number = get_display_number();
+
+	while ((xau = XauReadAuth(f)))
+	{
+		char buffer[40]; /* 2*16 == 32, so 40 is enough */
+		char* msg;
+		char* response;
+		int   i;
+
+		if (xau->family != FamilyLocal || strncmp(xau->number, display_number, xau->number_length) || strncmp(xau->name, "MIT-MAGIC-COOKIE-1", xau->name_length) || xau->data_length != MDM_MIT_MAGIC_COOKIE_LEN)
+		{
+			XauDisposeAuth(xau);
+			continue;
+		}
+
+		for (i = 0; i < MDM_MIT_MAGIC_COOKIE_LEN; i++)
+		{
+			g_snprintf(buffer + 2 * i, 3, "%02x", (guint)(guchar) xau->data[i]);
+		}
+
+		XauDisposeAuth(xau);
+
+		msg = g_strdup_printf(MDM_PROTOCOL_MSG_AUTHENTICATE " %s", buffer);
+		response = mdm_send_protocol_msg(data, msg);
+		g_free(msg);
+
+		if (response && !strcmp(response, "OK"))
+		{
+			data->auth_cookie = g_strdup(buffer);
+			g_free(response);
+			retval = TRUE;
+			break;
+		}
+
+		g_free(response);
+	}
+
+	g_free(display_number);
+
+	fclose(f);
+
+	return retval;
+
+	#undef MDM_MIT_MAGIC_COOKIE_LEN
+}
+
+static void mdm_shutdown_protocol_connection(MdmProtocolData *data)
+{
+	if (data->fd)
+	{
+		close(data->fd);
+	}
+
+	data->fd = 0;
+}
+
+static gboolean mdm_init_protocol_connection(MdmProtocolData* data)
+{
+	struct sockaddr_un addr;
+	char* response;
+
+	g_assert(data->fd <= 0);
+
+	if (g_file_test(MDM_PROTOCOL_SOCKET_PATH, G_FILE_TEST_EXISTS))
+	{
+		strcpy(addr.sun_path, MDM_PROTOCOL_SOCKET_PATH);
+	}
+	else if (g_file_test("/tmp/.mdm_socket", G_FILE_TEST_EXISTS))
+	{
+		strcpy(addr.sun_path, "/tmp/.mdm_socket");
+	}
+	else
+	{
+		return FALSE;
+	}
+
+	data->fd = socket(AF_UNIX, SOCK_STREAM, 0);
+
+	if (data->fd < 0)
+	{
+		g_warning("Failed to create MDM socket: %s", g_strerror(errno));
+
+		mdm_shutdown_protocol_connection(data);
+
+		return FALSE;
+	}
+
+	addr.sun_family = AF_UNIX;
+
+	if (connect(data->fd, (struct sockaddr*) &addr, sizeof(addr)) < 0)
+	{
+		g_warning("Failed to establish a connection with MDM: %s", g_strerror(errno));
+
+		mdm_shutdown_protocol_connection(data);
+
+		return FALSE;
+	}
+
+	response = mdm_send_protocol_msg(data, MDM_PROTOCOL_MSG_VERSION);
+
+	if (!response || strncmp(response, "MDM ", strlen("MDM ") != 0))
+	{
+		g_free(response);
+
+		g_warning("Failed to get protocol version from MDM");
+		mdm_shutdown_protocol_connection(data);
+
+		return FALSE;
+	}
+
+	g_free(response);
+
+	if (!mdm_authenticate_connection(data))
+	{
+		g_warning("Failed to authenticate with MDM");
+		mdm_shutdown_protocol_connection(data);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static void mdm_parse_query_response(MdmProtocolData* data, const char* response)
+{
+	char** actions;
+	int i;
+
+	data->available_actions = MDM_LOGOUT_ACTION_NONE;
+	data->current_actions = MDM_LOGOUT_ACTION_NONE;
+
+	if (strncmp(response, "OK ", 3) != 0)
+	{
+		return;
+	}
+
+	response += 3;
+
+	actions = g_strsplit(response, ";", -1);
+
+	for (i = 0; actions[i]; i++)
+	{
+		MdmLogoutAction action = MDM_LOGOUT_ACTION_NONE;
+		gboolean selected = FALSE;
+		char* str = actions [i];
+		int len;
+
+		len = strlen(str);
+
+		if (!len)
+		{
+			continue;
+		}
+
+		if (str[len - 1] == '!')
+		{
+			selected = TRUE;
+			str[len - 1] = '\0';
+		}
+
+		if (!strcmp(str, MDM_ACTION_STR_SHUTDOWN))
+		{
+				action = MDM_LOGOUT_ACTION_SHUTDOWN;
+		}
+		else if (!strcmp(str, MDM_ACTION_STR_REBOOT))
+		{
+				action = MDM_LOGOUT_ACTION_REBOOT;
+		}
+		else if (!strcmp(str, MDM_ACTION_STR_SUSPEND))
+		{
+				action = MDM_LOGOUT_ACTION_SUSPEND;
+		}
+
+		data->available_actions |= action;
+
+		if (selected)
+		{
+			data->current_actions |= action;
+		}
+	}
+
+	g_strfreev(actions);
+}
+
+static void mdm_update_logout_actions(MdmProtocolData* data)
+{
+	time_t current_time;
+	char* response;
+
+	current_time = time(NULL);
+
+	if (current_time <= (data->last_update + MDM_PROTOCOL_UPDATE_INTERVAL))
+	{
+		return;
+	}
+
+	data->last_update = current_time;
+
+	if (!mdm_init_protocol_connection(data))
+	{
+		return;
+	}
+
+	if ((response = mdm_send_protocol_msg(data, MDM_PROTOCOL_MSG_QUERY_ACTION)))
+	{
+		mdm_parse_query_response(data, response);
+		g_free(response);
+	}
+
+	mdm_shutdown_protocol_connection(data);
+}
+
+gboolean mdm_is_available(void)
+{
+	if (!mdm_init_protocol_connection(&mdm_protocol_data))
+	{
+		return FALSE;
+	}
+
+	mdm_shutdown_protocol_connection(&mdm_protocol_data);
+
+	return TRUE;
+}
+
+gboolean mdm_supports_logout_action(MdmLogoutAction action)
+{
+	mdm_update_logout_actions(&mdm_protocol_data);
+
+	return (mdm_protocol_data.available_actions & action) != 0;
+}
+
+MdmLogoutAction mdm_get_logout_action(void)
+{
+	mdm_update_logout_actions(&mdm_protocol_data);
+
+	return mdm_protocol_data.current_actions;
+}
+
+void mdm_set_logout_action(MdmLogoutAction action)
+{
+	char* action_str = NULL;
+	char* msg;
+	char* response;
+
+	if (!mdm_init_protocol_connection(&mdm_protocol_data))
+	{
+		return;
+	}
+
+	switch (action)
+	{
+		case MDM_LOGOUT_ACTION_NONE:
+			action_str = MDM_ACTION_STR_NONE;
+			break;
+		case MDM_LOGOUT_ACTION_SHUTDOWN:
+			action_str = MDM_ACTION_STR_SHUTDOWN;
+			break;
+		case MDM_LOGOUT_ACTION_REBOOT:
+			action_str = MDM_ACTION_STR_REBOOT;
+			break;
+		case MDM_LOGOUT_ACTION_SUSPEND:
+			action_str = MDM_ACTION_STR_SUSPEND;
+			break;
+	}
+
+	msg = g_strdup_printf(MDM_PROTOCOL_MSG_SET_ACTION " %s", action_str);
+
+	response = mdm_send_protocol_msg(&mdm_protocol_data, msg);
+
+	g_free(msg);
+	g_free(response);
+
+	mdm_protocol_data.last_update = 0;
+
+	mdm_shutdown_protocol_connection(&mdm_protocol_data);
+}
+
+void mdm_new_login(void)
+{
+    char* response;
+
+    if (!mdm_init_protocol_connection(&mdm_protocol_data))
+    {
+        return;
+    }
+
+    response = mdm_send_protocol_msg(&mdm_protocol_data, MDM_PROTOCOL_MSG_FLEXI_XSERVER);
+
+    g_free(response);
+
+    mdm_protocol_data.last_update = 0;
+
+    mdm_shutdown_protocol_connection(&mdm_protocol_data);
+}