Merge lp:~ted/ubuntu-app-launch/xmir-support into lp:ubuntu-app-launch/15.04

[Ted Gould]

[lp:~ted/ubuntu-app-launch/xmir-support]

124. By Ted Gould on 2015-06-10

Updating to trunk

125. By Ted Gould on 2015-06-26

Refactor to make things all pipey

126. By Ted Gould on 2015-06-26

Putting the basics together for a helper test

127. By Ted Gould on 2015-06-26

Remove trailing returns

128. By Ted Gould on 2015-06-26

Linking into CMake

129. By Ted Gould on 2015-06-30

Getting the value out of the code page

130. By Ted Gould on 2015-06-30

Add in a sig child handler to handle the Xserver dying and not sending info on the socket

131. By Ted Gould on 2015-06-30

Adding in an evil test

132. By Ted Gould on 2015-07-01

Adding in rootless

133. By Ted Gould on 2015-07-01

Desktop tests for setting the xmir values

134. By Ted Gould on 2015-07-02

Adding a click test, with all the joy that brings

135. By Ted Gould on 2015-08-06

Remove the -rootless flag

136. By Ted Gould on 2015-08-11

Refactor test into a helper function

137. By Ted Gould on 2015-08-11

Porting some more cases

138. By Ted Gould on 2015-08-11

Changing the click mir tests over

139. By Ted Gould on 2015-08-11

Mention varargs

140. By Ted Gould on 2015-08-11

Remove std=c11

141. By Ted Gould on 2015-08-17

Don't set a default value for XMIR_ENABLE

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-03-05 02:59:41 +0000
+++ CMakeLists.txt	2015-07-01 01:16:06 +0000
@@ -36,7 +36,8 @@
 )
 set(ubuntu_app_launch_arch "${UBUNTU_APP_LAUNCH_ARCH}")
 
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror -Wno-error=unused-function -std=c99")
+# Deprecated needed for g_atexit() in libual
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror -Wno-error=unused-function -Wno-error=deprecated-declarations -std=c99")
 
 enable_testing()
 
@@ -46,7 +47,7 @@
 pkg_check_modules(GOBJECT2 REQUIRED gobject-2.0)
 include_directories(${GOBJECT2_INCLUDE_DIRS})
 
-pkg_check_modules(GIO2 REQUIRED gio-2.0)
+pkg_check_modules(GIO2 REQUIRED gio-2.0 gio-unix-2.0)
 include_directories(${GIO2_INCLUDE_DIRS})
 
 pkg_check_modules(JSONGLIB REQUIRED json-glib-1.0)
@@ -80,6 +81,8 @@
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11 -fPIC")
 
+add_definitions( -DXMIR_HELPER="${pkglibexecdir}/xmir-helper" )
+
 ####################
 # Helpers
 ####################
@@ -135,6 +138,14 @@
 install(TARGETS application-failed RUNTIME DESTINATION "${pkglibexecdir}")
 
 ####################
+# xmir-helper
+####################
+
+add_executable(xmir-helper xmir-helper.c)
+set_target_properties(xmir-helper PROPERTIES OUTPUT_NAME "xmir-helper")
+install(TARGETS xmir-helper RUNTIME DESTINATION "${pkglibexecdir}")
+
+####################
 # untrusted-helper-type-end
 ####################
 
@@ -161,6 +172,15 @@
 install(TARGETS oom-adjust-setuid-helper RUNTIME DESTINATION "${pkglibexecdir}")
 
 ####################
+# socket-demangler
+####################
+
+add_executable(socket-demangler-helper socket-demangler.c)
+set_target_properties(socket-demangler-helper PROPERTIES OUTPUT_NAME "socket-demangler")
+target_link_libraries(socket-demangler-helper ${GIO2_LIBRARIES})
+install(TARGETS socket-demangler-helper RUNTIME DESTINATION "${pkglibexecdir}")
+
+####################
 # ubuntu-app-launch-desktop.click-hook
 ####################
 

=== modified file 'cmake/UseGdbusCodegen.cmake'
--- cmake/UseGdbusCodegen.cmake	2013-07-24 21:13:19 +0000
+++ cmake/UseGdbusCodegen.cmake	2015-07-01 01:16:06 +0000
@@ -8,28 +8,29 @@
   message(FATAL_ERROR "Excutable gdbus-codegen not found")
 endif()
 
-function(add_gdbus_codegen)
-  set(_one_value OUTFILES NAME PREFIX NAMESPACE SERVICE_XML)
-  set(_multi_value DEPENDS)
-  cmake_parse_arguments (arg "" "${_one_value}" "${_multi_value}" ${ARGN})
+macro(add_gdbus_codegen outfiles name prefix service_xml)
+  add_custom_command(
+    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${name}.h" "${CMAKE_CURRENT_BINARY_DIR}/${name}.c"
+    COMMAND "${GDBUS_CODEGEN}"
+        --interface-prefix "${prefix}"
+        --generate-c-code "${name}"
+        "${service_xml}"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    DEPENDS ${ARGN} "${service_xml}"
+  )
+  list(APPEND ${outfiles} "${CMAKE_CURRENT_BINARY_DIR}/${name}.c")
+endmacro(add_gdbus_codegen)
 
-  if(arg_PREFIX)
-    set(PREFIX --interface-prefix ${arg_PREFIX})
-  endif()
-  
-  if(arg_NAMESPACE)
-    set(NAMESPACE --c-namespace ${arg_NAMESPACE})
-  endif()
-  
+macro(add_gdbus_codegen_with_namespace outfiles name prefix namespace service_xml)
   add_custom_command(
-    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${arg_NAME}.h" "${CMAKE_CURRENT_BINARY_DIR}/${arg_NAME}.c"
+    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${name}.h" "${CMAKE_CURRENT_BINARY_DIR}/${name}.c"
     COMMAND "${GDBUS_CODEGEN}"
-        --generate-c-code "${arg_NAME}"
-        ${PREFIX}
-        ${NAMESPACE}
-        "${arg_SERVICE_XML}"
+        --interface-prefix "${prefix}"
+        --generate-c-code "${name}"
+        --c-namespace "${namespace}"
+        "${service_xml}"
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-    DEPENDS ${arg_DEPENDS} "${arg_SERVICE_XML}"
+    DEPENDS ${ARGN} "${service_xml}"
   )
-  set(${arg_OUTFILES} ${${arg_OUTFILES}} "${CMAKE_CURRENT_BINARY_DIR}/${arg_NAME}.c" PARENT_SCOPE)
-endfunction(add_gdbus_codegen)
+  list(APPEND ${outfiles} "${CMAKE_CURRENT_BINARY_DIR}/${name}.c")
+endmacro(add_gdbus_codegen_with_namespace)

=== added file 'data/com.canonical.UbuntuAppLaunch.SocketDemangler.xml'
--- data/com.canonical.UbuntuAppLaunch.SocketDemangler.xml	1970-01-01 00:00:00 +0000
+++ data/com.canonical.UbuntuAppLaunch.SocketDemangler.xml	2015-07-01 01:16:06 +0000
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<node>
+	<interface name="com.canonical.UbuntuAppLaunch.SocketDemangler">
+		<method name="GetMirSocket">
+			<arg type="h" name="handle" direction="out" />
+		</method>
+	</interface>
+</node>

=== modified file 'debian/changelog'
--- debian/changelog	2015-06-03 21:20:42 +0000
+++ debian/changelog	2015-07-01 01:16:06 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 ubuntu-app-launch (0.4+15.04.20150603-0ubuntu1) vivid; urgency=medium
 
   [ Ted Gould ]
@@ -5,6 +6,27 @@
 
  -- CI Train Bot <[e-mail]>  Wed, 03 Jun 2015 21:20:42 +0000
 
+=======
+ubuntu-app-launch (0.5+15.10.20150605-0ubuntu1) wily; urgency=medium
+
+  [ Ted Gould ]
+  * Don't error on ZG failure (LP: #1452178)
+  * Fallback to looking for the AppID tag if the source is missing (LP:
+    #1461138)
+
+ -- CI Train Bot <[e-mail]>  Fri, 05 Jun 2015 19:49:48 +0000
+
+ubuntu-app-launch (0.5+15.10.20150604-0ubuntu1) wily; urgency=medium
+
+  [ Ted Gould ]
+  * Add an untrusted helper that works with Mir trusted prompt sessions.
+
+  [ CI Train Bot ]
+  * debian/libubuntu-app-launch2.symbols: update to released version.
+
+ -- CI Train Bot <[e-mail]>  Thu, 04 Jun 2015 20:35:57 +0000
+
+>>>>>>> MERGE-SOURCE
 ubuntu-app-launch (0.4+15.04.20150410-0ubuntu1) vivid; urgency=medium
 
   [ Ted Gould ]

=== modified file 'debian/control'
--- debian/control	2015-03-05 03:04:41 +0000
+++ debian/control	2015-07-01 01:16:06 +0000
@@ -16,7 +16,7 @@
                libgtest-dev,
                libjson-glib-dev,
                liblttng-ust-dev,
-               libmirclient-dev (>= 0.5) [!powerpc !ppc64el],
+               libmirclient-dev (>= 0.5),
                libnih-dbus-dev,
                libnih-dev,
                libupstart-dev,
@@ -78,6 +78,7 @@
 Depends: ${misc:Depends},
          ${shlibs:Depends},
          libglib2.0-dev,
+         libmirclient-dev (>= 0.5),
          libubuntu-app-launch2 (= ${binary:Version}),
 Pre-Depends: ${misc:Pre-Depends},
 Multi-Arch: same

=== modified file 'debian/libubuntu-app-launch2.symbols'
--- debian/libubuntu-app-launch2.symbols	2015-03-05 14:36:33 +0000
+++ debian/libubuntu-app-launch2.symbols	2015-07-01 01:16:06 +0000
@@ -2,6 +2,7 @@
  ubuntu_app_launch_app_id_parse@Base 0.4
  ubuntu_app_launch_application_log_path@Base 0.4
  ubuntu_app_launch_get_primary_pid@Base 0.4
+ ubuntu_app_launch_helper_set_exec@Base 0.5+15.10.20150604
  ubuntu_app_launch_list_helper_instances@Base 0.4
  ubuntu_app_launch_list_helpers@Base 0.4
  ubuntu_app_launch_list_running_apps@Base 0.4
@@ -32,6 +33,7 @@
  ubuntu_app_launch_start_application_test@Base 0.4
  ubuntu_app_launch_start_helper@Base 0.4
  ubuntu_app_launch_start_multiple_helper@Base 0.4
+ ubuntu_app_launch_start_session_helper@Base 0.5+15.10.20150604
  ubuntu_app_launch_stop_application@Base 0.4
  ubuntu_app_launch_stop_helper@Base 0.4
  ubuntu_app_launch_stop_multiple_helper@Base 0.4

=== modified file 'exec-line-exec-trace.tp'
--- exec-line-exec-trace.tp	2014-08-11 17:19:57 +0000
+++ exec-line-exec-trace.tp	2015-07-01 01:16:06 +0000
@@ -5,6 +5,12 @@
 		ctf_string(appid, appid)
 	)
 )
+TRACEPOINT_EVENT(ubuntu_app_launch, exec_parse_complete,
+	TP_ARGS(const char *, appid),
+	TP_FIELDS(
+		ctf_string(appid, appid)
+	)
+)
 TRACEPOINT_EVENT(ubuntu_app_launch, exec_pre_exec,
 	TP_ARGS(const char *, appid),
 	TP_FIELDS(

=== modified file 'exec-line-exec.c'
--- exec-line-exec.c	2014-08-11 17:19:57 +0000
+++ exec-line-exec.c	2015-07-01 01:16:06 +0000
@@ -139,6 +139,20 @@
 		return 1;
 	}
 
+	ual_tracepoint(exec_parse_complete, app_id);
+
+	if (g_getenv("MIR_SOCKET") != NULL && g_strcmp0(g_getenv("APP_XMIR_ENABLE"), "1") == 0) {
+		g_debug("XMir Helper being used");
+
+		/* xmir-helper $(APP_ID) $(COMMAND) */
+		const gchar * appid = g_getenv("APP_ID");
+		g_array_prepend_val(newargv, appid);
+
+		/* Pulling into the heap instead of the code page */
+		char * xmir_helper = g_strdup(XMIR_HELPER);
+		g_array_prepend_val(newargv, xmir_helper);
+	}
+
 	/* Now exec */
 	gchar ** nargv = (gchar**)g_array_free(newargv, FALSE);
 

=== modified file 'libubuntu-app-launch/CMakeLists.txt'
--- libubuntu-app-launch/CMakeLists.txt	2014-11-21 21:17:09 +0000
+++ libubuntu-app-launch/CMakeLists.txt	2015-07-01 01:16:06 +0000
@@ -17,7 +17,7 @@
 add_lttng_gen_tp(NAME ubuntu-app-launch-trace)
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
-add_definitions ( -DOOM_HELPER="${pkglibexecdir}/oom-adjust-setuid-helper" )
+add_definitions ( -DOOM_HELPER="${pkglibexecdir}/oom-adjust-setuid-helper" -DDEMANGLER_PATH="${pkglibexecdir}/socket-demangler" )
 
 set(LAUNCHER_HEADERS
 ubuntu-app-launch.h
@@ -31,7 +31,13 @@
 ubuntu-app-launch-trace.c
 )
 
-add_library(ubuntu-launcher SHARED ${LAUNCHER_SOURCES})
+set(LAUNCHER_GEN_SOURCES
+)
+
+add_gdbus_codegen_with_namespace(LAUNCHER_GEN_SOURCES proxy-socket-demangler com.canonical.UbuntuAppLaunch. proxy ${CMAKE_SOURCE_DIR}/data/com.canonical.UbuntuAppLaunch.SocketDemangler.xml)
+
+
+add_library(ubuntu-launcher SHARED ${LAUNCHER_SOURCES} ${LAUNCHER_GEN_SOURCES})
 
 set_target_properties(ubuntu-launcher PROPERTIES
 	VERSION ${ABI_VERSION}.0.0
@@ -50,6 +56,7 @@
 	${JSONGLIB_LIBRARIES}
 	${CLICK_LIBRARIES}
 	${ZEITGEIST_LIBRARIES}
+	${MIR_LIBRARIES}
 	helpers
 	-Wl,--no-undefined
 )
@@ -91,7 +98,8 @@
 set(UbuntuAppLaunch_2_gir_INCLUDES GObject-2.0)
 
 gir_get_cflags(_cflags)
-set(UbuntuAppLaunch_2_gir_CFLAGS ${c_flags})
+list_prefix(MIR_C_INCLUDES MIR_INCLUDE_DIRS "-I")
+set(UbuntuAppLaunch_2_gir_CFLAGS ${c_flags} ${MIR_C_INCLUDES})
 set(UbuntuAppLaunch_2_gir_LIBS ubuntu-app-launch)
 
 list_make_absolute(_abs_introspection_files _introspection_files "${CMAKE_CURRENT_SOURCE_DIR}/")

=== modified file 'libubuntu-app-launch/click-exec.c'
--- libubuntu-app-launch/click-exec.c	2014-08-22 21:04:13 +0000
+++ libubuntu-app-launch/click-exec.c	2015-07-01 01:16:06 +0000
@@ -136,6 +136,14 @@
 		return FALSE;
 	}
 
+	if (g_key_file_has_key(keyfile, "Desktop Entry", "X-Ubuntu-XMir-Enable", NULL)) {
+		if (g_key_file_get_boolean(keyfile, "Desktop Entry", "X-Ubuntu-XMir-Enable", NULL)) {
+			env_handle_add(handle, "APP_XMIR_ENABLE", "1");
+		} else {
+			env_handle_add(handle, "APP_XMIR_ENABLE", "0");
+		}
+	}
+
 	/* This string is quoted using desktop file quoting:
 	   http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#exec-variables */
 	gchar * exec = desktop_to_exec(keyfile, desktopfile);

=== modified file 'libubuntu-app-launch/desktop-exec.c'
--- libubuntu-app-launch/desktop-exec.c	2014-08-22 21:06:00 +0000
+++ libubuntu-app-launch/desktop-exec.c	2015-07-01 01:16:06 +0000
@@ -118,6 +118,14 @@
 		env_handle_add(handle, "APP_EXEC_POLICY", "unconfined");
 	}
 
+	if (g_key_file_has_key(keyfile, "Desktop Entry", "X-Ubuntu-XMir-Enable", NULL)) {
+		if (g_key_file_get_boolean(keyfile, "Desktop Entry", "X-Ubuntu-XMir-Enable", NULL)) {
+			env_handle_add(handle, "APP_XMIR_ENABLE", "1");
+		} else {
+			env_handle_add(handle, "APP_XMIR_ENABLE", "0");
+		}
+	}
+
 	/* This string is quoted using desktop file quoting:
 	   http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#exec-variables */
 	gchar * execline = desktop_to_exec(keyfile, app_id);

=== modified file 'libubuntu-app-launch/ubuntu-app-launch.c'
--- libubuntu-app-launch/ubuntu-app-launch.c	2015-04-10 16:58:27 +0000
+++ libubuntu-app-launch/ubuntu-app-launch.c	2015-07-01 01:16:06 +0000
@@ -22,6 +22,7 @@
 #include <click.h>
 #include <upstart.h>
 #include <gio/gio.h>
+#include <gio/gunixfdlist.h>
 #include <string.h>
 #include <fcntl.h>
 #include <errno.h>
@@ -33,11 +34,17 @@
 #include "ual-tracepoint.h"
 #include "click-exec.h"
 #include "desktop-exec.h"
+#include "recoverable-problem.h"
+#include "proxy-socket-demangler.h"
 
 static void apps_for_job (GDBusConnection * con, const gchar * name, GArray * apps, gboolean truncate_legacy);
 static void free_helper (gpointer value);
 static GList * pids_for_appid (const gchar * appid);
 int kill (pid_t pid, int signal);
+static gchar * escape_dbus_string (const gchar * input);
+
+G_DEFINE_QUARK(UBUNTU_APP_LAUNCH_PROXY_PATH, proxy_path);
+G_DEFINE_QUARK(UBUNTU_APP_LAUNCH_MIR_FD, mir_fd);
 
 /* Function to take the urls and escape them so that they can be
    parsed on the other side correctly. */
@@ -1754,7 +1761,7 @@
    to define the instance.  In the end there's only one job with
    an array of instances. */
 static gboolean
-start_helper_core (const gchar * type, const gchar * appid, const gchar * const * uris, const gchar * instance)
+start_helper_core (const gchar * type, const gchar * appid, const gchar * const * uris, const gchar * instance, const gchar * mirsocketpath)
 {
 	GDBusConnection * con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
 	g_return_val_if_fail(con != NULL, FALSE);
@@ -1778,6 +1785,11 @@
 		g_variant_builder_add_value(&builder, g_variant_new_take_string(g_strdup_printf("INSTANCE_ID=%s", instance)));
 	}
 
+	if (mirsocketpath != NULL) {
+		g_variant_builder_add_value(&builder, g_variant_new_take_string(g_strdup_printf("UBUNTU_APP_LAUNCH_DEMANGLE_PATH=%s", mirsocketpath)));
+		g_variant_builder_add_value(&builder, g_variant_new_take_string(g_strdup_printf("UBUNTU_APP_LAUNCH_DEMANGLE_NAME=%s", g_dbus_connection_get_unique_name(con))));
+	}
+
 	g_variant_builder_close(&builder);
 	g_variant_builder_add_value(&builder, g_variant_new_boolean(TRUE));
 	
@@ -1807,7 +1819,7 @@
 	g_return_val_if_fail(appid != NULL, FALSE);
 	g_return_val_if_fail(g_strstr_len(type, -1, ":") == NULL, FALSE);
 
-	return start_helper_core(type, appid, uris, NULL);
+	return start_helper_core(type, appid, uris, NULL, NULL);
 }
 
 gchar *
@@ -1819,10 +1831,254 @@
 
 	gchar * instanceid = g_strdup_printf("%" G_GUINT64_FORMAT, g_get_real_time());
 
-	if (start_helper_core(type, appid, uris, instanceid)) {
-		return instanceid;
-	}
-
+	if (start_helper_core(type, appid, uris, instanceid, NULL)) {
+		return instanceid;
+	}
+
+	g_free(instanceid);
+	return NULL;
+}
+
+/* Transfer from Mir's data structure to ours */
+static void
+get_mir_session_fd_helper (MirPromptSession * session, size_t count, int const * fdin, void * user_data)
+{
+	if (count != 1) {
+		g_warning("Mir trusted session returned %d FDs instead of one", (int)count);
+		return;
+	}
+
+	int * retfd = (int *)user_data;
+	*retfd = fdin[0];
+}
+
+/* Setup to get the FD from Mir, blocking */
+static int
+get_mir_session_fd (MirPromptSession * session)
+{
+	int retfd = 0;
+	MirWaitHandle * wait = mir_prompt_session_new_fds_for_prompt_providers(session,
+		1,
+		get_mir_session_fd_helper,
+		&retfd);
+
+	mir_wait_for(wait);
+
+	return retfd;
+}
+
+static GList * open_proxies = NULL;
+
+static gint
+remove_socket_path_find (gconstpointer a, gconstpointer b) 
+{
+	GObject * obj = (GObject *)a;
+	const gchar * path = (const gchar *)b;
+
+	gchar * objpath = g_object_get_qdata(obj, proxy_path_quark());
+	
+	return g_strcmp0(objpath, path);
+}
+
+/* Cleans up if we need to early */
+static gboolean
+remove_socket_path (const gchar * path)
+{
+	GList * thisproxy = g_list_find_custom(open_proxies, path, remove_socket_path_find);
+	if (thisproxy == NULL)
+		return FALSE;
+
+	g_debug("Removing Mir Socket Proxy: %s", path);
+
+	GObject * obj = G_OBJECT(thisproxy->data);
+	open_proxies = g_list_delete_link(open_proxies, thisproxy);
+
+	/* Remove ourselves from DBus if we weren't already */
+	g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(obj));
+
+	/* If we still have FD, close it */
+	int mirfd = GPOINTER_TO_INT(g_object_get_qdata(obj, mir_fd_quark()));
+	if (mirfd != 0) {
+		close(mirfd);
+
+		/* This is actually an error, we should expect not to find
+		   this here to do anything with it. */
+		const gchar * props[3] = {
+			"UbuntuAppLaunchProxyDbusPath",
+			NULL,
+			NULL
+		};
+		props[1] = path;
+		report_recoverable_problem("ubuntu-app-launch-mir-fd-proxy", 0, TRUE, props);
+	}
+
+	g_object_unref(obj);
+
+	return TRUE;
+}
+
+/* Small timeout function that shouldn't, in most cases, ever do anything.
+   But we need it here to ensure we don't leave things on the bus */
+static gboolean
+proxy_timeout (gpointer user_data)
+{
+	const gchar * path = (const gchar *)user_data;
+	remove_socket_path(path);
+	return G_SOURCE_REMOVE;
+}
+
+/* Removes the whole list of proxies if they are there */
+static void
+proxy_cleanup_list (void)
+{
+	while (open_proxies) {
+		GObject * obj = G_OBJECT(open_proxies->data);
+		gchar * path = g_object_get_qdata(obj, proxy_path_quark());
+		remove_socket_path(path);
+	}
+}
+
+static gboolean
+proxy_mir_socket (GObject * obj, GDBusMethodInvocation * invocation, gpointer user_data)
+{
+	g_debug("Called to give Mir socket");
+	int fd = GPOINTER_TO_INT(user_data);
+
+	if (fd == 0) {
+		g_critical("No FDs to give!");
+		return FALSE;
+	}
+
+	/* Index into fds */
+	GVariant* handle = g_variant_new_handle(0);
+	GVariant* tuple = g_variant_new_tuple(&handle, 1);
+
+	GError* error = NULL;
+	GUnixFDList* list = g_unix_fd_list_new();
+	g_unix_fd_list_append(list, fd, &error);
+
+	if (error == NULL) {   
+		g_dbus_method_invocation_return_value_with_unix_fd_list(invocation, tuple, list);
+	} else {
+		g_variant_ref_sink(tuple);
+		g_variant_unref(tuple);
+	}
+
+	g_object_unref(list);
+
+	if (error != NULL) {   
+		g_critical("Unable to pass FD %d: %s", fd, error->message);
+		g_error_free(error);
+		return FALSE;
+	}   
+
+	g_object_set_qdata(obj, mir_fd_quark(), GINT_TO_POINTER(0));
+
+	return TRUE;
+}
+
+/* Sets up the DBus proxy to send to the demangler */
+static gchar *
+build_proxy_socket_path (const gchar * appid, int mirfd)
+{
+	static gboolean final_cleanup = FALSE;
+	if (!final_cleanup) {
+		g_atexit(proxy_cleanup_list);
+		final_cleanup = TRUE;
+	}
+
+	GError * error = NULL;
+	GDBusConnection * session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
+	if (error != NULL) {
+		g_warning("Unable to get session bus: %s", error->message);
+		g_error_free(error);
+		return NULL;
+	}
+
+	/* Export an Object on DBus */
+	proxySocketDemangler * skel = proxy_socket_demangler_skeleton_new();
+	g_signal_connect(G_OBJECT(skel), "handle-get-mir-socket", G_CALLBACK(proxy_mir_socket), GINT_TO_POINTER(mirfd));
+
+	gchar * encoded_appid = escape_dbus_string(appid);
+	gchar * socket_name = NULL;
+	/* Loop until we fine an object path that isn't taken (probably only once) */
+	while (socket_name == NULL) {
+		gchar* tryname = g_strdup_printf("/com/canonical/UbuntuAppLaunch/%s/%X", encoded_appid, g_random_int());
+		g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(skel),
+			session,
+			tryname,
+			&error);
+
+		if (error == NULL) {
+			socket_name = tryname;
+			g_debug("Exporting Mir socket on path: %s", socket_name);
+		} else {
+			/* Always print the error, but if the object path is in use let's
+			   not exit the loop. Let's just try again. */
+			bool exitnow = (error->domain != G_DBUS_ERROR || error->code != G_DBUS_ERROR_OBJECT_PATH_IN_USE);
+			g_critical("Unable to export trusted session object: %s", error->message);
+
+			g_clear_error(&error);
+			g_free(tryname);
+
+			if (exitnow) {
+				break;
+			}
+		}
+	}
+	g_free(encoded_appid);
+
+	/* If we didn't get a socket name, we should just exit. And
+	   make sure to clean up the socket. */
+	if (socket_name == NULL) {   
+		g_object_unref(skel);
+		g_object_unref(session);
+		g_critical("Unable to export object to any name");
+		return NULL;
+	}
+
+	g_object_set_qdata_full(G_OBJECT(skel), proxy_path_quark(), g_strdup(socket_name), g_free);
+	g_object_set_qdata(G_OBJECT(skel), mir_fd_quark(), GINT_TO_POINTER(mirfd));
+	open_proxies = g_list_prepend(open_proxies, skel);
+
+	g_timeout_add_seconds_full(G_PRIORITY_DEFAULT,
+	                           2,
+	                           proxy_timeout,
+	                           g_strdup(socket_name),
+	                           g_free);
+
+	g_object_unref(session);
+
+	return socket_name;
+}
+
+gchar *
+ubuntu_app_launch_start_session_helper (const gchar * type, MirPromptSession * session, const gchar * appid, const gchar * const * uris)
+{
+	g_return_val_if_fail(type != NULL, NULL);
+	g_return_val_if_fail(session != NULL, NULL);
+	g_return_val_if_fail(appid != NULL, NULL);
+	g_return_val_if_fail(g_strstr_len(type, -1, ":") == NULL, NULL);
+
+	int mirfd = get_mir_session_fd(session);
+	if (mirfd == 0)
+		return NULL;
+
+	gchar * socket_path = build_proxy_socket_path(appid, mirfd);
+	if (socket_path == NULL) {
+		close(mirfd);
+		return NULL;
+	}
+
+	gchar * instanceid = g_strdup_printf("%" G_GUINT64_FORMAT, g_get_real_time());
+
+	if (start_helper_core(type, appid, uris, instanceid, socket_path)) {
+		return instanceid;
+	}
+
+	remove_socket_path(socket_path);
+	g_free(socket_path);
+	close(mirfd);
 	g_free(instanceid);
 	return NULL;
 }
@@ -2203,3 +2459,104 @@
 	return delete_helper_generic(observer, helper_type, user_data, &helper_stopped_obs);
 }
 
+/* Sets an environment variable in Upstart */
+static void
+set_var (GDBusConnection * bus, const gchar * job_name, const gchar * instance_name, const gchar * envvar)
+{
+	GVariantBuilder builder; /* Target: (assb) */
+	g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+
+	/* Setup the job properties */
+	g_variant_builder_open(&builder, G_VARIANT_TYPE_ARRAY);
+	g_variant_builder_add_value(&builder, g_variant_new_string(job_name));
+	if (instance_name != NULL)
+		g_variant_builder_add_value(&builder, g_variant_new_string(instance_name));
+	g_variant_builder_close(&builder);
+
+	g_variant_builder_add_value(&builder, g_variant_new_string(envvar));
+
+	/* Do we want to replace?  Yes, we do! */
+	g_variant_builder_add_value(&builder, g_variant_new_boolean(TRUE));
+
+	g_dbus_connection_call(bus,
+		"com.ubuntu.Upstart",
+		"/com/ubuntu/Upstart",
+		"com.ubuntu.Upstart0_6",
+		"SetEnv",
+		g_variant_builder_end(&builder),
+		NULL, /* reply */
+		G_DBUS_CALL_FLAGS_NONE,
+		-1, /* timeout */
+		NULL, /* cancelable */
+		NULL, NULL); /* callback */
+}
+
+gboolean
+ubuntu_app_launch_helper_set_exec (const gchar * execline, const gchar * directory)
+{
+	g_return_val_if_fail(execline != NULL, FALSE);
+	g_return_val_if_fail(execline[0] != '\0', FALSE);
+
+	/* Check to see if we can get the job environment */
+	const gchar * job_name = g_getenv("UPSTART_JOB");
+	const gchar * instance_name = g_getenv("UPSTART_INSTANCE");
+	const gchar * demangler = g_getenv("UBUNTU_APP_LAUNCH_DEMANGLE_NAME");
+	g_return_if_fail(job_name != NULL);
+
+	GError * error = NULL;
+	GDBusConnection * bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
+
+	if (error != NULL) {
+		g_warning("Unable to get session bus: %s", error->message);
+		g_error_free(error);
+		return FALSE;
+	}
+
+	/* The exec value */
+	gchar * envstr = NULL;
+	if (demangler) {
+		envstr = g_strdup_printf("APP_EXEC=" DEMANGLER_PATH " %s", execline);
+	} else {
+		envstr = g_strdup_printf("APP_EXEC=%s", execline);
+	}
+
+	set_var(bus, job_name, instance_name, envstr);
+	g_free(envstr);
+
+	/* The directory value */
+	if (directory != NULL) {
+		gchar * direnv = g_strdup_printf("APP_DIR=%s", directory);
+		set_var(bus, job_name, instance_name, direnv);
+		g_free(direnv);
+	}
+
+	g_object_unref(bus);
+
+	return TRUE;
+}
+
+
+/* ensure that all characters are valid in the dbus output string */
+static gchar *
+escape_dbus_string (const gchar * input)
+{
+	static const gchar *xdigits = "0123456789abcdef";
+	GString *escaped;
+	gchar c;
+
+	g_return_val_if_fail (input != NULL, NULL);
+
+	escaped = g_string_new (NULL);
+	while ((c = *input++)) {
+		if (g_ascii_isalnum (c)) {
+			g_string_append_c (escaped, c);
+		} else {
+			g_string_append_c (escaped, '_');
+			g_string_append_c (escaped, xdigits[c >> 4]);
+			g_string_append_c (escaped, xdigits[c & 0xf]);
+		}
+	}
+
+	return g_string_free (escaped, FALSE);
+}
+

=== modified file 'libubuntu-app-launch/ubuntu-app-launch.h'
--- libubuntu-app-launch/ubuntu-app-launch.h	2015-02-25 22:20:14 +0000
+++ libubuntu-app-launch/ubuntu-app-launch.h	2015-07-01 01:16:06 +0000
@@ -18,6 +18,7 @@
  */
 
 #include <glib.h>
+#include <mir_toolkit/mir_prompt_session.h>
 
 #ifndef __UBUNTU_APP_LAUNCH_H__
 #define __UBUNTU_APP_LAUNCH_H__ 1
@@ -450,7 +451,7 @@
  * @appid: App ID of the helper
  * @uris: (allow-none) (array zero-terminated=1) (element-type utf8) (transfer none): A NULL terminated list of URIs to send to the helper
  *
- * Start an untrusted helper for a specific @type on a given
+ * Start an untrusted helper for a specific @type of a given
  * @appid.  We don't know how that is done specifically, as Upstart
  * will call a helper for that type.  And then execute it under the
  * Apparmor profile for that helper type.  This function is different
@@ -465,6 +466,29 @@
                                                          const gchar * const *             uris);
 
 /**
+ * ubuntu_app_launch_start_session_helper:
+ * @type: Type of helper
+ * @session: Mir Trusted Prompt Session to run the helper under
+ * @appid: App ID of the helper
+ * @uris: (allow-none) (array zero-terminated=1) (element-type utf8) (transfer none): A NULL terminated list of URIs to send to the helper
+ *
+ * Start an untrusted helper for a specific @type of a given
+ * @appid running under a Mir Trusted Prompt Session @session. The
+ * helper's MIR_SOCKET environment variable will be set appropriately
+ * so that the helper will draw on the correct surfaces. Otherwise this
+ * is the same as #ubuntu_app_launch_start_multiple_helper.
+ *
+ * It is important that all exec tools for @type call the function
+ * #ubuntu_app_launch_helper_set_exec to set the exec line.
+ *
+ * Return value: The generated instance ID or NULL on failure
+ */
+gchar *    ubuntu_app_launch_start_session_helper  (const gchar *            type,
+                                                    MirPromptSession *       session,
+                                                    const gchar *            appid,
+                                                    const gchar * const *    uris);
+
+/**
  * ubuntu_app_launch_stop_helper:
  * @type: Type of helper
  * @appid: App ID of the helper
@@ -574,6 +598,24 @@
                                                               const gchar *                     helper_type,
                                                               gpointer                          user_data);
 
+/**
+ * ubuntu_app_launch_helper_set_exec:
+ * @execline: Exec line to be executed, in Desktop file format
+ * @directory: (allow-none): The directory that the exec line should
+ *     be executed in.
+ *
+ * A function to be called by an untrusted helper exec
+ * tool to set the exec line. The exec tool should determine
+ * what should be executed from some sort of configuration
+ * based on its type (usually a configuration file from a click
+ * package). Once it determines the exec line it can set it
+ * with this function and exit.
+ *
+ * Return Value: Whether we were able to set the exec line
+ */
+gboolean   ubuntu_app_launch_helper_set_exec       (const gchar *            execline,
+                                                    const gchar *            directory);
+
 #ifdef __cplusplus
 }
 #endif

=== modified file 'libubuntu-app-launch/ubuntu-app-launch.pc.in'
--- libubuntu-app-launch/ubuntu-app-launch.pc.in	2014-04-30 15:45:23 +0000
+++ libubuntu-app-launch/ubuntu-app-launch.pc.in	2015-07-01 01:16:06 +0000
@@ -2,7 +2,7 @@
 includedir=@includedir@
 
 Cflags: -I${includedir}/libubuntu-app-launch-@apiversion@
-Requires: glib-2.0
+Requires: glib-2.0 mirclient
 Libs: -L${libdir} -lubuntu-app-launch
 
 Name: libubuntu-app-launch

=== added file 'socket-demangler.c'
--- socket-demangler.c	1970-01-01 00:00:00 +0000
+++ socket-demangler.c	2015-07-01 01:16:06 +0000
@@ -0,0 +1,124 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Ted Gould <[e-mail]>
+ */
+
+#define _POSIX_C_SOURCE 200112L
+
+#include <gio/gio.h>
+#include <gio/gunixfdlist.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <fcntl.h>
+
+int
+main (int argc, char * argv[])
+{
+	const gchar * mir_name =   g_getenv("UBUNTU_APP_LAUNCH_DEMANGLE_NAME");
+	const gchar * mir_socket = g_getenv("UBUNTU_APP_LAUNCH_DEMANGLE_PATH");
+	if (mir_socket == NULL || mir_socket[0] == '\0') {
+		g_error("Unable to find Mir path for service");
+		return -1;
+	}
+	if (mir_name == NULL || mir_name[0] == '\0') {
+		g_error("Unable to find Mir name for service");
+		return -1;
+	}
+
+	g_debug("Mir socket connection to %s:%s", mir_name, mir_socket);
+
+	GError * error = NULL;
+	GDBusConnection * bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
+
+	if (error != NULL) {
+		g_error("Unable to get session bus: %s", error->message);
+		g_error_free(error);
+		return -1;
+	}
+
+	GVariant * retval;
+	GUnixFDList * fdlist;
+
+	retval = g_dbus_connection_call_with_unix_fd_list_sync(
+		bus,
+		mir_name,
+		mir_socket,
+		"com.canonical.UbuntuAppLaunch.SocketDemangler",
+		"GetMirSocket",
+		NULL,
+		G_VARIANT_TYPE("(h)"),
+		G_DBUS_CALL_FLAGS_NO_AUTO_START,
+		-1, /* timeout */
+		NULL, /* fd list in */
+		&fdlist,
+		NULL, /* cancelable */
+		&error);
+
+	g_clear_object(&bus);
+
+	if (error != NULL) {
+		g_error("Unable to get Mir socket over dbus: %s", error->message);
+		g_error_free(error);
+		return -1;
+	}
+
+	GVariant * outhandle = g_variant_get_child_value(retval, 0);
+
+	if (outhandle == NULL) {
+		g_error("Unable to get data from function");
+		return -1;
+	}
+
+	gint32 handle = g_variant_get_handle(outhandle);
+	g_variant_unref(outhandle);
+	g_variant_unref(retval);
+
+	if (handle >= g_unix_fd_list_get_length(fdlist)) {
+		g_error("Handle is %d but the FD list only has %d entries", handle, g_unix_fd_list_get_length(fdlist));
+		g_clear_object(&fdlist);
+		return -1;
+	}
+
+	gint32 fd = g_unix_fd_list_get(fdlist, handle, &error);
+	g_clear_object(&fdlist);
+
+	if (error != NULL) {
+		g_error("Unable to Unix FD: %s", error->message);
+		g_error_free(error);
+		return -1;
+	}
+
+	errno = 0;
+	fcntl(fd, F_GETFD);
+	if (errno != 0) {
+		perror("File descriptor is invalid");
+		return -1;
+	}
+
+	/* Make sure the FD doesn't close on exec */
+	fcntl(fd, F_SETFD, 0);
+
+	gchar * mirsocketbuf = g_strdup_printf("fd://%d", fd);
+	setenv("MIR_SOCKET", mirsocketbuf, 1);
+	g_debug("MIR_SOCKET=%s", mirsocketbuf);
+
+	g_free(mirsocketbuf);
+
+	return execvp(argv[1], argv + 1);
+}

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2015-04-06 21:28:13 +0000
+++ tests/CMakeLists.txt	2015-07-01 01:16:06 +0000
@@ -32,15 +32,23 @@
 
 include_directories("${CMAKE_SOURCE_DIR}/libubuntu-app-launch")
 add_definitions ( -DSPEW_UTILITY="${CMAKE_CURRENT_BINARY_DIR}/data-spew" )
+add_definitions ( -DSESSION_TEMP_FILE="${CMAKE_CURRENT_BINARY_DIR}/libual-test-session-start-temp" )
+add_definitions ( -DSOCKET_DEMANGLER="${CMAKE_BINARY_DIR}/socket-demangler" )
+add_definitions ( -DSOCKET_DEMANGLER_INSTALL="${pkglibexecdir}/socket-demangler" )
+add_definitions ( -DSOCKET_TOOL="${CMAKE_CURRENT_BINARY_DIR}/socket-tool" )
 
 add_executable (libual-test
-	libual-test.cc)
+	libual-test.cc
+	mir-mock.cpp)
 target_link_libraries (libual-test gtest ${GTEST_LIBS} ${LIBUPSTART_LIBRARIES} ${DBUSTEST_LIBRARIES} ubuntu-launcher)
 
 add_executable (data-spew
 	data-spew.c)
 target_link_libraries (data-spew ${GLIB2_LIBRARIES})
 
+add_executable (socket-tool
+	socket-tool.c)
+
 add_test (NAME libual-test COMMAND libual-test)
 
 # Failure Test
@@ -87,3 +95,9 @@
 configure_file ("click-desktop-hook-db/test.conf.in" "${CMAKE_CURRENT_BINARY_DIR}/click-desktop-hook-db/test.conf" @ONLY)
 configure_file ("desktop-hook-test.sh.in" "${CMAKE_CURRENT_BINARY_DIR}/desktop-hook-test.sh" @ONLY)
 add_test (desktop-hook-test desktop-hook-test.sh)
+
+# XMir helper Test
+
+configure_file ("xmir-helper-test.in" "${CMAKE_CURRENT_BINARY_DIR}/xmir-helper-test" @ONLY)
+add_test (xmir-helper-test xmir-helper-test)
+

=== modified file 'tests/libual-test.cc'
--- tests/libual-test.cc	2015-03-02 19:59:44 +0000
+++ tests/libual-test.cc	2015-07-01 01:16:06 +0000
@@ -17,13 +17,18 @@
  *     Ted Gould <[e-mail]>
  */
 
+#include <future>
+#include <thread>
+
 #include <gtest/gtest.h>
 #include <gio/gio.h>
 #include <zeitgeist.h>
+#include "mir-mock.h"
 
 extern "C" {
 #include "ubuntu-app-launch.h"
 #include "libdbustest/dbus-test.h"
+#include <fcntl.h>
 }
 
 class LibUAL : public ::testing::Test
@@ -108,6 +113,13 @@
 				"	ret = dbus.ObjectPath('/com/test/untrusted/helper')\n",
 				NULL);
 
+			dbus_test_dbus_mock_object_add_method(mock, obj,
+				"SetEnv",
+				G_VARIANT_TYPE("(assb)"),
+				NULL,
+				"",
+				NULL);
+
 			/* Click App */
 			DbusTestDbusMockObject * jobobj = dbus_test_dbus_mock_get_object(mock, "/com/test/application_click", "com.ubuntu.Upstart0_6.Job", NULL);
 
@@ -266,50 +278,64 @@
 			}
 			ASSERT_EQ(nullptr, bus);
 		}
-
-		bool check_env (GVariant * env_array, const gchar * var, const gchar * value) {
-			GVariantIter iter;
-			g_variant_iter_init(&iter, env_array);
+		
+		GVariant * find_env (GVariant * env_array, const gchar * var) {
+			int i;
 			gchar * envvar = NULL;
-			bool found = false;
-
-			while (g_variant_iter_loop(&iter, "s", &envvar)) {
+			GVariant * retval = nullptr;
+
+			for (i = 0; i < g_variant_n_children(env_array); i++) {
+				GVariant * child = g_variant_get_child_value(env_array, i);
+				const gchar * envvar = g_variant_get_string(child, nullptr);
+
 				if (g_str_has_prefix(envvar, var)) {
-					if (found) {
+					if (retval != nullptr) {
 						g_warning("Found the env var more than once!");
-						return false;
+						g_variant_unref(retval);
+						return nullptr;
 					}
 
-					if (value != NULL) {
-						gchar * combined = g_strdup_printf("%s=%s", var, value);
-						if (g_strcmp0(envvar, combined) == 0) {
-							found = true;
-						}
-						g_free(combined);
-					} else {
-						found = true;
-					}
+					retval = child;
+				} else {
+					g_variant_unref(child);
 				}
 			}
 
-			if (!found) {
+			if (!retval) {
 				gchar * envstr = g_variant_print(env_array, FALSE);
-				g_warning("Unable to find '%s' with value '%s' in '%s'", var, value, envstr);
+				g_warning("Unable to find '%s' in '%s'", var, envstr);
 				g_free(envstr);
 			}
 
+			return retval;
+		}
+
+		bool check_env (GVariant * env_array, const gchar * var, const gchar * value) {
+			bool found = false;
+			GVariant * val = find_env(env_array, var);
+			if (val == nullptr)
+				return false;
+
+			const gchar * envvar = g_variant_get_string(val, nullptr);
+
+			gchar * combined = g_strdup_printf("%s=%s", var, value);
+			if (g_strcmp0(envvar, combined) == 0) {
+				found = true;
+			}
+
+			g_variant_unref(val);
+
 			return found;
 		}
 
-		static gboolean pause_helper (gpointer pmainloop) {
-			g_main_loop_quit(static_cast<GMainLoop *>(pmainloop));
-			return G_SOURCE_REMOVE;
-		}
-
-		void pause (guint time) {
+		void pause (guint time = 0) {
 			if (time > 0) {
 				GMainLoop * mainloop = g_main_loop_new(NULL, FALSE);
-				g_timeout_add(time, pause_helper, mainloop);
+
+				g_timeout_add(time, [](gpointer pmainloop) -> gboolean {
+					g_main_loop_quit(static_cast<GMainLoop *>(pmainloop));
+					return G_SOURCE_REMOVE;
+				}, mainloop);
 
 				g_main_loop_run(mainloop);
 
@@ -1446,3 +1472,147 @@
 	
 	g_free(oomadjfile);
 }
+
+TEST_F(LibUAL, StartSessionHelper)
+{
+	DbusTestDbusMockObject * obj = dbus_test_dbus_mock_get_object(mock, "/com/test/untrusted/helper", "com.ubuntu.Upstart0_6.Job", NULL);
+	MirConnection * conn = mir_connect_sync("libual-test", "start-session-helper"); // Mocked, doesn't need cleaning up
+	MirPromptSession * msession = mir_connection_create_prompt_session_sync(conn, 5, nullptr, nullptr);
+
+	/* Building a temporary file and making an FD for it */
+	const char * filedata = "This is some data that we should get on the other side\n";
+	ASSERT_TRUE(g_file_set_contents(SESSION_TEMP_FILE, filedata, strlen(filedata), nullptr) == TRUE);
+	int mirfd = open(SESSION_TEMP_FILE, 0);
+	mir_mock_set_trusted_fd(mirfd);
+
+	/* Basic make sure we can send the event */
+	gchar * instance_id = ubuntu_app_launch_start_session_helper("untrusted-type", msession, "com.test.multiple_first_1.2.3", NULL);
+	ASSERT_NE(nullptr, instance_id);
+
+	guint len = 0;
+	const DbusTestDbusMockCall * calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "Start", &len, NULL);
+	EXPECT_NE(nullptr, calls);
+	EXPECT_EQ(1, len);
+
+	EXPECT_STREQ("Start", calls->name);
+	EXPECT_EQ(2, g_variant_n_children(calls->params));
+
+	GVariant * block = g_variant_get_child_value(calls->params, 1);
+	EXPECT_TRUE(g_variant_get_boolean(block));
+	g_variant_unref(block);
+
+	/* Check the environment */
+	GVariant * env = g_variant_get_child_value(calls->params, 0);
+	EXPECT_TRUE(check_env(env, "APP_ID", "com.test.multiple_first_1.2.3"));
+	EXPECT_TRUE(check_env(env, "HELPER_TYPE", "untrusted-type"));
+	EXPECT_TRUE(check_env(env, "INSTANCE_ID", instance_id));
+
+	GVariant * mnamev = find_env(env, "UBUNTU_APP_LAUNCH_DEMANGLE_NAME");
+	ASSERT_NE(nullptr, mnamev); /* Have to assert because, eh, GVariant */
+	EXPECT_STREQ(g_dbus_connection_get_unique_name(bus), g_variant_get_string(mnamev, nullptr) + strlen("UBUNTU_APP_LAUNCH_DEMANGLE_NAME="));
+	GVariant * mpathv = find_env(env, "UBUNTU_APP_LAUNCH_DEMANGLE_PATH");
+	ASSERT_NE(nullptr, mpathv); /* Have to assert because, eh, GVariant */
+
+	g_variant_unref(env);
+
+	/* Setup environment for call */
+	const gchar * mname = g_variant_get_string(mnamev, nullptr);
+	mname += strlen("UBUNTU_APP_LAUNCH_DEMANGLE_NAME=");
+	g_setenv("UBUNTU_APP_LAUNCH_DEMANGLE_NAME", mname, TRUE);
+	g_variant_unref(mnamev);
+
+	const gchar * mpath = g_variant_get_string(mpathv, nullptr);
+	mpath += strlen("UBUNTU_APP_LAUNCH_DEMANGLE_PATH=");
+	g_setenv("UBUNTU_APP_LAUNCH_DEMANGLE_PATH", mpath, TRUE);
+	g_variant_unref(mpathv);
+
+	/* Exec our tool */
+	std::promise<std::string> outputpromise;
+	std::thread t([&outputpromise]() {
+		gchar * socketstdout = nullptr;
+		GError * error = nullptr;
+		g_unsetenv("G_MESSAGES_DEBUG");
+
+		g_spawn_command_line_sync(
+				SOCKET_DEMANGLER " " SOCKET_TOOL,
+				&socketstdout,
+				nullptr,
+				nullptr,
+				&error);
+
+		if (error != nullptr) {
+			fprintf(stderr, "Unable to spawn '" SOCKET_DEMANGLER " " SOCKET_TOOL "': %s\n", error->message);
+			g_error_free(error);
+			outputpromise.set_value(std::string(""));
+		} else {
+			outputpromise.set_value(std::string(socketstdout));
+			g_free(socketstdout);
+		}
+	});
+	t.detach();
+
+	auto outputfuture = outputpromise.get_future();
+	while (outputfuture.wait_for(std::chrono::milliseconds{1}) != std::future_status::ready) {
+		pause();
+	}
+
+	ASSERT_STREQ(filedata, outputfuture.get().c_str());
+
+	ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
+
+	return;
+}
+
+TEST_F(LibUAL, SetExec)
+{
+	DbusTestDbusMockObject * obj = dbus_test_dbus_mock_get_object(mock, "/com/ubuntu/Upstart", "com.ubuntu.Upstart0_6", NULL);
+
+	const char * exec = "lets exec this";
+
+	g_setenv("UPSTART_JOB", "fubar", TRUE);
+	g_unsetenv("UBUNTU_APP_LAUNCH_DEMANGLE_NAME");
+	EXPECT_TRUE(ubuntu_app_launch_helper_set_exec(exec, NULL));
+
+	guint len = 0;
+	const DbusTestDbusMockCall * calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "SetEnv", &len, NULL);
+	ASSERT_NE(nullptr, calls);
+	EXPECT_EQ(1, len);
+
+	gchar * appexecstr = g_strdup_printf("APP_EXEC=%s", exec);
+	GVariant * appexecenv = g_variant_get_child_value(calls[0].params, 1);
+	EXPECT_STREQ(appexecstr, g_variant_get_string(appexecenv, nullptr));
+	g_variant_unref(appexecenv);
+	g_free(appexecstr);
+
+	ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
+
+	/* Now check for the demangler */
+	g_setenv("UBUNTU_APP_LAUNCH_DEMANGLE_NAME", g_dbus_connection_get_unique_name(bus), TRUE);
+	EXPECT_TRUE(ubuntu_app_launch_helper_set_exec(exec, NULL));
+
+	calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "SetEnv", &len, NULL);
+	ASSERT_NE(nullptr, calls);
+	EXPECT_EQ(1, len);
+
+	gchar * demangleexecstr = g_strdup_printf("APP_EXEC=%s %s", SOCKET_DEMANGLER_INSTALL, exec);
+	appexecenv = g_variant_get_child_value(calls[0].params, 1);
+	EXPECT_STREQ(demangleexecstr, g_variant_get_string(appexecenv, nullptr));
+	g_variant_unref(appexecenv);
+	g_free(demangleexecstr);
+
+	ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
+
+	/* Now check for the directory */
+	g_setenv("UBUNTU_APP_LAUNCH_DEMANGLE_NAME", g_dbus_connection_get_unique_name(bus), TRUE);
+	EXPECT_TRUE(ubuntu_app_launch_helper_set_exec(exec, "/not/a/real/directory"));
+
+	calls = dbus_test_dbus_mock_object_get_method_calls(mock, obj, "SetEnv", &len, NULL);
+	ASSERT_NE(nullptr, calls);
+	EXPECT_EQ(2, len);
+
+	appexecenv = g_variant_get_child_value(calls[1].params, 1);
+	EXPECT_STREQ("APP_DIR=/not/a/real/directory", g_variant_get_string(appexecenv, nullptr));
+	g_variant_unref(appexecenv);
+
+	ASSERT_TRUE(dbus_test_dbus_mock_object_clear_method_calls(mock, obj, NULL));
+}

=== added file 'tests/mir-mock.cpp'
--- tests/mir-mock.cpp	1970-01-01 00:00:00 +0000
+++ tests/mir-mock.cpp	2015-07-01 01:16:06 +0000
@@ -0,0 +1,106 @@
+
+#include "mir-mock.h"
+
+#include <iostream>
+#include <thread>
+
+#include <mir_toolkit/mir_connection.h>
+#include <mir_toolkit/mir_prompt_session.h>
+
+static const char * valid_trust_session = "In the circle of trust";
+static bool valid_trust_connection = true;
+static pid_t last_trust_pid = 0;
+static int trusted_fd = 1234;
+
+MirPromptSession *
+mir_connection_create_prompt_session_sync(MirConnection * connection, pid_t pid, void (*)(MirPromptSession *, MirPromptSessionState, void*data), void * context) {
+	last_trust_pid = pid;
+
+	if (valid_trust_connection) {
+		return (MirPromptSession *)valid_trust_session;
+	} else {
+		return nullptr;
+	}
+}
+
+void
+mir_prompt_session_release_sync (MirPromptSession * session)
+{
+	if (reinterpret_cast<char *>(session) != valid_trust_session) {
+		std::cerr << "Releasing a Mir Trusted Prompt that isn't valid" << std::endl;
+		exit(1);
+	}
+}
+
+MirWaitHandle *
+mir_prompt_session_new_fds_for_prompt_providers (MirPromptSession * session, unsigned int numfds, mir_client_fd_callback cb, void * data) {
+	if (reinterpret_cast<char *>(session) != valid_trust_session) {
+		std::cerr << "Releasing a Mir Trusted Prompt that isn't valid" << std::endl;
+		exit(1);
+	}
+
+	/* TODO: Put in another thread to be more mir like */
+	std::thread * thread = new std::thread([session, numfds, cb, data]() {
+		int fdlist[numfds];
+
+		for (int i = 0; i < numfds; i++) 
+			fdlist[i] = trusted_fd;
+
+		cb(session, numfds, fdlist, data);
+	});
+
+	return reinterpret_cast<MirWaitHandle *>(thread);
+}
+
+void
+mir_wait_for (MirWaitHandle * wait)
+{
+	auto thread = reinterpret_cast<std::thread *>(wait);
+
+	if (thread->joinable())
+		thread->join();
+
+	delete thread;
+}
+
+static const char * valid_connection_str = "Valid Mir Connection";
+static std::pair<std::string, std::string> last_connection;
+static bool valid_connection = true;
+
+void
+mir_mock_connect_return_valid (bool valid)
+{
+	valid_connection = valid;
+}
+
+std::pair<std::string, std::string>
+mir_mock_connect_last_connect (void)
+{
+	return last_connection;
+}
+
+MirConnection *
+mir_connect_sync (char const * server, char const * appname)
+{
+	last_connection = std::pair<std::string, std::string>(server, appname);
+
+	if (valid_connection) {
+		return (MirConnection *)(valid_connection_str);
+	} else {
+		return nullptr;
+	}
+}
+
+void
+mir_connection_release (MirConnection * con)
+{
+	if (reinterpret_cast<char *>(con) != valid_connection_str) {
+		std::cerr << "Releasing a Mir Connection that isn't valid" << std::endl;
+		exit(1);
+	}
+}
+
+void mir_mock_set_trusted_fd (int fd)
+{
+	trusted_fd = fd;
+}

=== added file 'tests/mir-mock.h'
--- tests/mir-mock.h	1970-01-01 00:00:00 +0000
+++ tests/mir-mock.h	2015-07-01 01:16:06 +0000
@@ -0,0 +1,12 @@
+
+#ifndef MIR_MOCK_H
+#define MIR_MOCK_H 1
+
+#include <string>
+#include <utility>
+
+void mir_mock_connect_return_valid (bool valid);
+std::pair<std::string, std::string> mir_mock_connect_last_connect (void);
+void mir_mock_set_trusted_fd (int fd);
+
+#endif // MIR_MOCK_H

=== added file 'tests/socket-tool.c'
--- tests/socket-tool.c	1970-01-01 00:00:00 +0000
+++ tests/socket-tool.c	2015-07-01 01:16:06 +0000
@@ -0,0 +1,28 @@
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+
+int
+main (int argc, char * argv[])
+{
+	const char * fdstr = getenv("MIR_SOCKET");
+	if (!fdstr) {
+		fprintf(stderr, "No MIR_SOCKET defined\n");
+		return 1;
+	}
+
+	int fdnum = 0;
+	sscanf(fdstr, "fd://%d", &fdnum);
+	if (fdnum == 0) {
+		fprintf(stderr, "Unable to get FD number\n");
+		return 1;
+	}
+
+	char inchar;
+	while (read(fdnum, &inchar, 1) == 1)
+		fwrite(&inchar, 1, 1, stdout);
+
+	close(fdnum);
+	return 0;
+}

=== added file 'tests/xmir-helper-exec.sh'
--- tests/xmir-helper-exec.sh	1970-01-01 00:00:00 +0000
+++ tests/xmir-helper-exec.sh	2015-07-01 01:16:06 +0000
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo $DISPLAY

=== added file 'tests/xmir-helper-test.in'
--- tests/xmir-helper-test.in	1970-01-01 00:00:00 +0000
+++ tests/xmir-helper-test.in	2015-07-01 01:16:06 +0000
@@ -0,0 +1,25 @@
+#!/bin/bash
+
+echo -n "Testing XMir Helper… "
+
+export UBUNTU_APP_LAUNCH_XMIR_PATH="@CMAKE_CURRENT_SOURCE_DIR@/xmir-mock.sh"
+
+TESTVALUE=`@CMAKE_BINARY_DIR@/xmir-helper com.mir.test_mirtest_1.2.3 @CMAKE_CURRENT_SOURCE_DIR@/xmir-helper-exec.sh`
+
+if [ $TESTVALUE == ":42" ]; then
+	echo "PASSED"
+else
+	echo "FAILED"
+	exit 1
+fi
+
+echo -n "Testing an evil XMir helper… "
+
+export UBUNTU_APP_LAUNCH_XMIR_PATH="@CMAKE_CURRENT_SOURCE_DIR@/xmir-mock-evil.sh"
+
+if @CMAKE_BINARY_DIR@/xmir-helper com.mir.test_mirtest_1.2.3 @CMAKE_CURRENT_SOURCE_DIR@/xmir-helper-exec.sh  ; then
+	echo "FAILED"
+	exit 1
+else
+	echo "PASSED"
+fi

=== added file 'tests/xmir-mock.sh'
--- tests/xmir-mock.sh	1970-01-01 00:00:00 +0000
+++ tests/xmir-mock.sh	2015-07-01 01:16:06 +0000
@@ -0,0 +1,27 @@
+#!/bin/bash
+
+if [ $1 != "-rootless" ]; then
+	echo "-rootless missing"
+	exit 1
+fi
+
+if [ $2 != "-displayfd" ]; then
+	echo "-displayfd missing"
+	exit 1
+fi
+
+if [ $4 != "-mir" ]; then
+	echo "-mir missing"
+	exit 1
+fi
+
+if [ $5 != "com.mir.test_mirtest_1.2.3" ]; then
+	echo "AppID wrong"
+	exit 1
+fi
+
+echo "42" >&$3
+
+# Ensure that our "XMir" runs longer than
+# the test, if it exits first that's a failure
+sleep 1

=== modified file 'ubuntu-app-test/CMakeLists.txt'
--- ubuntu-app-test/CMakeLists.txt	2015-03-05 14:35:26 +0000
+++ ubuntu-app-test/CMakeLists.txt	2015-07-01 01:16:06 +0000
@@ -1,6 +1,4 @@
 add_subdirectory(data)
-
-if (${MIR_FOUND})
 add_subdirectory(src)
 
 # testing & coverage
@@ -8,9 +6,3 @@
   add_subdirectory(tests)
 endif ()
 
-else ()
-
-install(PROGRAMS ubuntu-app-test DESTINATION "${CMAKE_INSTALL_FULL_BINDIR}/app-test")
-
-endif ()
-

=== removed file 'ubuntu-app-test/ubuntu-app-test'
--- ubuntu-app-test/ubuntu-app-test	2015-03-05 14:35:26 +0000
+++ ubuntu-app-test/ubuntu-app-test	1970-01-01 00:00:00 +0000
@@ -1,6 +0,0 @@
-#!/bin/sh
-
-# Used for Architectures that don't have Mir, otherwise we build the executable
-
-echo "ubuntu-app-test doesn't work on this architecture, sorry"
-exit 1

=== modified file 'upstart-jobs/application-click.conf.in'
--- upstart-jobs/application-click.conf.in	2015-01-23 18:12:29 +0000
+++ upstart-jobs/application-click.conf.in	2015-07-01 01:16:06 +0000
@@ -12,6 +12,9 @@
 env APP_DIR
 env APP_DESKTOP_FILE_PATH
 
+env APP_XMIR_ENABLE=0
+export APP_XMIR_ENABLE
+
 env UBUNTU_APP_LAUNCH_ARCH="@ubuntu_app_launch_arch@"
 export UBUNTU_APP_LAUNCH_ARCH
 

=== modified file 'upstart-jobs/application-legacy.conf.in'
--- upstart-jobs/application-legacy.conf.in	2015-01-23 18:12:29 +0000
+++ upstart-jobs/application-legacy.conf.in	2015-07-01 01:16:06 +0000
@@ -12,6 +12,9 @@
 env APP_URIS
 env APP_DESKTOP_FILE_PATH
 
+env APP_XMIR_ENABLE=1
+export APP_XMIR_ENABLE
+
 # This will be set to "unconfined" by desktop-exec if there is no confinement defined
 apparmor switch $APP_EXEC_POLICY
 cgroup freezer

=== added file 'xmir-helper.c'
--- xmir-helper.c	1970-01-01 00:00:00 +0000
+++ xmir-helper.c	2015-07-01 01:16:06 +0000
@@ -0,0 +1,118 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *     Ted Gould <[e-mail]>
+ */
+
+#define _POSIX_C_SOURCE 200212L
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <signal.h>
+
+void
+sigchild_handler (int signal)
+{
+	fprintf(stderr, "XMir has closed unexpectedly\n");
+	exit(1);
+}
+
+struct sigaction sigchild_action = {
+	.sa_handler = sigchild_handler,
+	.sa_flags = SA_NOCLDWAIT
+};
+
+int
+main (int argc, char * argv[])
+{
+	if (argc < 3) {
+		fprintf(stderr, "xmir-helper needs more arguments: xmir-helper $(appid) $(thing to exec)\n");
+		return 1;
+	}
+
+	/* Make nice variables for the things we need */
+	char * appid = argv[1];
+	char * xmir = getenv("UBUNTU_APP_LAUNCH_XMIR_PATH");
+	if (xmir == NULL) {
+		xmir = "/usr/bin/Xmir";
+	}
+
+	/* Build a socket pair to get the connection back from XMir */
+	int sockets[2];
+	if (socketpair(AF_LOCAL, SOCK_STREAM, 0, sockets) != 0) {
+		fprintf(stderr, "Unable to create socketpair for communicating with XMir\n");
+		return 1;
+	}
+
+	/* Give them nice names, the compiler will optimize out */
+	int xmirsocket = sockets[0];
+	int helpersocket = sockets[1];
+
+	/* Watch for the child dying */
+	if (sigaction(SIGCHLD, &sigchild_action, NULL) != 0) {
+		fprintf(stderr, "Unable to setup child signal handler\n");
+		return 1;
+	}
+
+	/* Start XMir */
+	if (fork() == 0) {
+		/* XMir start here */
+		/* GOAL: XMir -displayfd ${xmirsocket} -mir ${appid} */
+		char socketbuf[16] = {0};
+		snprintf(socketbuf, 16, "%d", xmirsocket);
+
+		char * xmirexec[7] = {
+			xmir,
+			"-rootless",
+			"-displayfd",
+			socketbuf,
+			"-mir",
+			appid,
+			NULL
+		};
+
+		return execv(xmir, xmirexec);
+	}
+
+	/* Wait to get the display number from XMir */
+	char readbuf[16] = {0};
+	if (read(helpersocket, readbuf, 16) == 0) {
+		fprintf(stderr, "Not reading anything from XMir\n");
+		return 1;
+	}
+
+	int i;
+	for (i = 0; i < sizeof(readbuf); i++) {
+		if (readbuf[i] == '\n') {
+			readbuf[i] = '\0';
+			break;
+		}
+	}
+
+	char displaynumber[16] = {0};
+	snprintf(displaynumber, 16, ":%s", readbuf);
+
+	/* Set up the display variable */
+	setenv("DISPLAY", displaynumber, 1);
+
+	/* Now that we have everything setup, we can execute */
+	char ** nargv = &argv[2];
+	int execret = execvp(nargv[0], nargv);
+	return execret;
+}

=== modified file 'zg-report-app.c'
--- zg-report-app.c	2014-09-10 14:54:01 +0000
+++ zg-report-app.c	2015-07-01 01:16:06 +0000
@@ -39,7 +39,7 @@
 	result = zeitgeist_log_insert_event_finish(ZEITGEIST_LOG(obj), res, &error);
 
 	if (error != NULL) {
-		g_error("Unable to submit Zeitgeist Event: %s", error->message);
+		g_warning("Unable to submit Zeitgeist Event: %s", error->message);
 		g_error_free(error);
 	}