Merge lp:~timchen119/ubuntu/utopic/gnome-bluetooth/lp1035431 into lp:ubuntu/utopic/gnome-bluetooth

[Tim Chen]

This fixed the issue for the paring issue on Logitech K810 and HP bluetooth keyboard K4000 and should also fixed any ssp paired bluetooth keyboard.

gnome-bluetooth is being removed in recent gnome upstream, so we need to maintain a ubuntu distro patch here.

Another related merge is at
https://code.launchpad.net/~timchen119/ubuntu/utopic/bluez/lp1035431/+merge/219626

The root problem here is that in bluez4, the doc (agent-api.txt), specific that the
function

void DisplayPasskey(object device, uint32 passkey, uint8 entered)

however in bluez4's src/agent.c agent_display_passkey()
didn't pass the entered correct "enter" parameter,
and most of client implementation in linux (at least gnome-bluetooth, bluedevil, blueman) follows the specification in the api document so they never receive correct parameter.

This is already fixed in bluez5,
however due to the compatibility issue between bluez4 and bluez5
this never being backported in bluez4.

This request is from our OEM so please help to review these patch and see if there's things I can improve this patch. If the patch is accepted I'll send SRUs to trusty (OEM shipping image is LTS based, so it will be trusty right now).

[Mathieu Trudel-Lapierre (cyphermox)]

Looks fine to me. If it fixes the issues let's land it.

review: Approve

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2014-02-25 16:32:43 +0000
+++ .pc/applied-patches	2014-05-15 03:31:21 +0000
@@ -7,3 +7,4 @@
 git_leak_fixes.patch
 git_disconnect_callbacks.patch
 git_reference_handling.patch
+ssp-parameter-fix.patch
 
=== added directory '.pc/ssp-parameter-fix.patch'
=== added directory '.pc/ssp-parameter-fix.patch/lib'
=== added file '.pc/ssp-parameter-fix.patch/lib/bluetooth-agent.c'
--- .pc/ssp-parameter-fix.patch/lib/bluetooth-agent.c	1970-01-01 00:00:00 +0000
+++ .pc/ssp-parameter-fix.patch/lib/bluetooth-agent.c	2014-05-15 03:31:21 +0000
@@ -0,0 +1,633 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2005-2008  Marcel Holtmann <[e-mail]>
+ *
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library 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
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <gio/gio.h>
+
+#include "bluetooth-client-glue.h"
+#include "bluetooth-agent.h"
+
+#define BLUEZ_SERVICE	"org.bluez"
+
+#define BLUEZ_MANAGER_PATH	"/"
+#define BLUEZ_MANAGER_INTERFACE	"org.bluez.Manager"
+#define BLUEZ_DEVICE_INTERFACE	"org.bluez.Device"
+
+static const gchar introspection_xml[] =
+"<node name='/'>"
+"  <interface name='org.bluez.Agent'>"
+"    <method name='Release'/>"
+"    <method name='RequestPinCode'>"
+"      <arg type='o' name='device' direction='in'/>"
+"      <arg type='s' name='pincode' direction='out'/>"
+"    </method>"
+"    <method name='RequestPasskey'>"
+"      <arg type='o' name='device' direction='in'/>"
+"      <arg type='u' name='passkey' direction='out'/>"
+"    </method>"
+"    <method name='DisplayPasskey'>"
+"      <arg type='o' name='device' direction='in'/>"
+"      <arg type='u' name='passkey' direction='in'/>"
+"      <arg type='y' name='entered' direction='in'/>"
+"    </method>"
+"    <method name='RequestConfirmation'>"
+"      <arg type='o' name='device' direction='in'/>"
+"      <arg type='u' name='passkey' direction='in'/>"
+"    </method>"
+"    <method name='Authorize'>"
+"      <arg type='o' name='device' direction='in'/>"
+"      <arg type='s' name='uuid' direction='in'/>"
+"    </method>"
+"    <method name='ConfirmMode'>"
+"      <arg type='s' name='mode'/>"
+"    </method>"
+"    <method name='Cancel'/>"
+"  </interface>"
+"</node>";
+
+#define BLUETOOTH_AGENT_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
+				BLUETOOTH_TYPE_AGENT, BluetoothAgentPrivate))
+
+typedef struct _BluetoothAgentPrivate BluetoothAgentPrivate;
+
+struct _BluetoothAgentPrivate {
+	GDBusConnection *conn;
+	gchar *busname;
+	gchar *path;
+	GDBusProxy *adapter;
+	GDBusNodeInfo *introspection_data;
+	guint reg_id;
+	guint watch_id;
+
+	BluetoothAgentPasskeyFunc pincode_func;
+	gpointer pincode_data;
+
+	BluetoothAgentDisplayFunc display_func;
+	gpointer display_data;
+
+	BluetoothAgentPasskeyFunc passkey_func;
+	gpointer passkey_data;
+
+	BluetoothAgentConfirmFunc confirm_func;
+	gpointer confirm_data;
+
+	BluetoothAgentAuthorizeFunc authorize_func;
+	gpointer authorize_data;
+
+	BluetoothAgentCancelFunc cancel_func;
+	gpointer cancel_data;
+};
+
+G_DEFINE_TYPE(BluetoothAgent, bluetooth_agent, G_TYPE_OBJECT)
+
+static GDBusProxy *
+get_device_from_adapter (BluetoothAgent *agent,
+			 const char *path)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	if (priv->adapter == NULL)
+		return NULL;
+
+	return g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+					      G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+					      NULL,
+					      g_dbus_proxy_get_name (priv->adapter),
+					      path,
+					      BLUEZ_DEVICE_INTERFACE,
+					      NULL,
+					      NULL);
+}
+
+static gboolean bluetooth_agent_request_pin_code(BluetoothAgent *agent,
+			const char *path, GDBusMethodInvocation *invocation)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+	GDBusProxy *device;
+	gboolean result = FALSE;
+
+	if (priv->pincode_func) {
+		device = get_device_from_adapter (agent, path);
+
+		result = priv->pincode_func(invocation, device,
+							priv->pincode_data);
+
+		if (device != NULL)
+			g_object_unref(device);
+	}
+
+	return result;
+}
+
+static gboolean bluetooth_agent_request_passkey(BluetoothAgent *agent,
+			const char *path, GDBusMethodInvocation *invocation)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+	GDBusProxy *device;
+	gboolean result = FALSE;
+
+	if (priv->passkey_func) {
+		device = get_device_from_adapter (agent, path);
+
+		result = priv->passkey_func(invocation, device,
+							priv->passkey_data);
+
+		if (device != NULL)
+			g_object_unref(device);
+	}
+
+	return result;
+}
+
+static gboolean bluetooth_agent_display_passkey(BluetoothAgent *agent,
+			const char *path, guint passkey, guint8 entered,
+						GDBusMethodInvocation *invocation)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+	GDBusProxy *device;
+	gboolean result = FALSE;
+
+	if (priv->display_func) {
+		device = get_device_from_adapter (agent, path);
+
+		result = priv->display_func(invocation, device, passkey, entered,
+							priv->display_data);
+
+		if (device != NULL)
+			g_object_unref(device);
+	}
+
+	return result;
+}
+
+static gboolean bluetooth_agent_request_confirmation(BluetoothAgent *agent,
+					const char *path, guint passkey,
+						GDBusMethodInvocation *invocation)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+	GDBusProxy *device;
+	gboolean result = FALSE;
+
+	if (priv->confirm_func) {
+		device = get_device_from_adapter (agent, path);
+
+		result = priv->confirm_func(invocation, device, passkey,
+							priv->confirm_data);
+
+		if (device != NULL)
+			g_object_unref(device);
+	}
+
+	return result;
+}
+
+static gboolean bluetooth_agent_authorize(BluetoothAgent *agent,
+					const char *path, const char *uuid,
+						GDBusMethodInvocation *invocation)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+	GDBusProxy *device;
+	gboolean result = FALSE;
+
+	if (priv->authorize_func) {
+		device = get_device_from_adapter (agent, path);
+
+		result = priv->authorize_func(invocation, device, uuid,
+							priv->authorize_data);
+
+		if (device != NULL)
+			g_object_unref(device);
+	}
+
+	return result;
+}
+
+static gboolean bluetooth_agent_cancel(BluetoothAgent *agent,
+						GDBusMethodInvocation *invocation)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+	gboolean result = FALSE;
+
+	if (priv->cancel_func)
+		result = priv->cancel_func(invocation, priv->cancel_data);
+
+	return result;
+}
+
+static void
+name_appeared_cb (GDBusConnection *connection,
+		  const gchar     *name,
+		  const gchar     *name_owner,
+		  BluetoothAgent  *agent)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	g_free (priv->busname);
+	priv->busname = g_strdup (name_owner);
+}
+
+static void
+name_vanished_cb (GDBusConnection *connection,
+		  const gchar     *name,
+		  BluetoothAgent  *agent)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	g_free (priv->busname);
+	priv->busname = NULL;
+}
+
+static void bluetooth_agent_init(BluetoothAgent *agent)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	priv->introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, NULL);
+	g_assert (priv->introspection_data);
+	priv->conn = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, NULL);
+	priv->watch_id = g_bus_watch_name_on_connection (priv->conn,
+							 BLUEZ_SERVICE,
+							 G_BUS_NAME_WATCHER_FLAGS_NONE,
+							 (GBusNameAppearedCallback) name_appeared_cb,
+							 (GBusNameVanishedCallback) name_vanished_cb,
+							 agent,
+							 NULL);
+}
+
+static void bluetooth_agent_finalize(GObject *agent)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	bluetooth_agent_unregister (BLUETOOTH_AGENT (agent));
+
+	g_bus_unwatch_name (priv->watch_id);
+	g_free (priv->busname);
+	g_dbus_node_info_unref (priv->introspection_data);
+	g_object_unref (priv->conn);
+
+	G_OBJECT_CLASS(bluetooth_agent_parent_class)->finalize(agent);
+}
+
+static void bluetooth_agent_class_init(BluetoothAgentClass *klass)
+{
+	GObjectClass *object_class = (GObjectClass *) klass;
+
+	g_type_class_add_private(klass, sizeof(BluetoothAgentPrivate));
+
+	object_class->finalize = bluetooth_agent_finalize;
+}
+
+BluetoothAgent *
+bluetooth_agent_new (void)
+{
+	return BLUETOOTH_AGENT (g_object_new (BLUETOOTH_TYPE_AGENT, NULL));
+}
+
+static void
+handle_method_call (GDBusConnection       *connection,
+		    const gchar           *sender,
+		    const gchar           *object_path,
+		    const gchar           *interface_name,
+		    const gchar           *method_name,
+		    GVariant              *parameters,
+		    GDBusMethodInvocation *invocation,
+		    gpointer               user_data)
+{
+	BluetoothAgent *agent = (BluetoothAgent *) user_data;
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	if (g_str_equal (sender, priv->busname) == FALSE) {
+		g_assert_not_reached ();
+		/* FIXME, should this just be a D-Bus Error instead? */
+	}
+
+	if (g_strcmp0 (method_name, "Release") == 0) {
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	} else if (g_strcmp0 (method_name, "RequestPinCode") == 0) {
+		char *path;
+		g_variant_get (parameters, "(o)", &path);
+		bluetooth_agent_request_pin_code (agent, path, invocation);
+		g_free (path);
+	} else if (g_strcmp0 (method_name, "RequestPasskey") == 0) {
+		char *path;
+		g_variant_get (parameters, "(o)", &path);
+		bluetooth_agent_request_passkey (agent, path, invocation);
+		g_free (path);
+	} else if (g_strcmp0 (method_name, "DisplayPasskey") == 0) {
+		char *path;
+		guint32 passkey;
+		guint8 entered;
+
+		g_variant_get (parameters, "(ouy)", &path, &passkey, &entered);
+		bluetooth_agent_display_passkey (agent, path, passkey, entered, invocation);
+		g_free (path);
+	} else if (g_strcmp0 (method_name, "RequestConfirmation") == 0) {
+		char *path;
+		guint32 passkey;
+
+		g_variant_get (parameters, "(ou)", &path, &passkey);
+		bluetooth_agent_request_confirmation (agent, path, passkey, invocation);
+		g_free (path);
+	} else if (g_strcmp0 (method_name, "Authorize") == 0) {
+		char *path, *uuid;
+		g_variant_get (parameters, "(os)", &path, &uuid);
+		bluetooth_agent_authorize (agent, path, uuid, invocation);
+		g_free (path);
+		g_free (uuid);
+	} else if (g_strcmp0 (method_name, "Cancel") == 0) {
+		bluetooth_agent_cancel (agent, invocation);
+	} else if (g_strcmp0 (method_name, "ConfirmMode") == 0) {
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	}
+}
+
+static const GDBusInterfaceVTable interface_vtable =
+{
+	handle_method_call,
+	NULL, /* GetProperty */
+	NULL, /* SetProperty */
+};
+
+gboolean bluetooth_agent_setup(BluetoothAgent *agent, const char *path)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+	GError *error = NULL;
+
+	if (priv->path != NULL) {
+		g_warning ("Agent already setup on '%s'", priv->path);
+		return FALSE;
+	}
+
+	priv->path = g_strdup(path);
+
+	priv->reg_id = g_dbus_connection_register_object (priv->conn,
+						      priv->path,
+						      priv->introspection_data->interfaces[0],
+						      &interface_vtable,
+						      agent,
+						      NULL,
+						      &error);
+	if (priv->reg_id == 0) {
+		g_warning ("Failed to register object: %s", error->message);
+		g_error_free (error);
+	}
+
+	return TRUE;
+}
+
+#define BLUEZ_SERVICE			"org.bluez"
+#define BLUEZ_MANAGER_INTERFACE		"org.bluez.Manager"
+
+static GDBusProxy *
+get_default_adapter (void)
+{
+	Manager *manager;
+	char *adapter_path;
+	Adapter *adapter;
+
+	manager = manager_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+						  G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+						  BLUEZ_SERVICE,
+						  BLUEZ_MANAGER_PATH,
+						  NULL,
+						  NULL);
+	if (manager == NULL)
+		return NULL;
+	if (manager_call_default_adapter_sync (manager, &adapter_path, NULL, NULL) == FALSE) {
+		g_object_unref (manager);
+		return NULL;
+	}
+	adapter = adapter_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+						  G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+						  BLUEZ_SERVICE,
+						  adapter_path,
+						  NULL,
+						  NULL);
+	g_object_unref (manager);
+	g_free (adapter_path);
+
+	return G_DBUS_PROXY (adapter);
+}
+
+gboolean bluetooth_agent_register(BluetoothAgent *agent)
+{
+	BluetoothAgentPrivate *priv;
+	GError *error = NULL;
+	char *path;
+	GVariant *r;
+
+	g_return_val_if_fail (BLUETOOTH_IS_AGENT (agent), FALSE);
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE (agent);
+
+	priv->adapter = get_default_adapter ();
+
+	if (priv->adapter == NULL)
+		return FALSE;
+
+	if (priv->path != NULL) {
+		g_warning ("Agent already setup on '%s'", priv->path);
+		return FALSE;
+	}
+
+	path = g_path_get_basename(g_dbus_proxy_get_object_path(priv->adapter));
+	priv->path = g_strdup_printf("/org/bluez/agent/%s", path);
+	g_free(path);
+
+	priv->reg_id = g_dbus_connection_register_object (priv->conn,
+						      priv->path,
+						      priv->introspection_data->interfaces[0],
+						      &interface_vtable,
+						      agent,
+						      NULL,
+						      &error);
+	if (priv->reg_id == 0) {
+		g_warning ("Failed to register object: %s", error->message);
+		g_error_free (error);
+		error = NULL;
+		return FALSE;
+	}
+
+	r = g_dbus_proxy_call_sync (priv->adapter, "RegisterAgent",
+				    g_variant_new ("(os)", priv->path, "DisplayYesNo"),
+				    G_DBUS_CALL_FLAGS_NONE,
+				    -1, NULL, &error);
+	if (r == NULL) {
+		g_printerr ("Agent registration failed: %s\n", error->message);
+		g_error_free (error);
+		return FALSE;
+	}
+	g_variant_unref (r);
+
+	return TRUE;
+}
+
+gboolean bluetooth_agent_unregister(BluetoothAgent *agent)
+{
+	BluetoothAgentPrivate *priv;
+	GError *error = NULL;
+
+	g_return_val_if_fail (BLUETOOTH_IS_AGENT (agent), FALSE);
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	if (priv->adapter == NULL)
+		return FALSE;
+
+	if (g_dbus_proxy_call_sync (priv->adapter, "UnregisterAgent",
+				    g_variant_new ("(o)", priv->path),
+				    G_DBUS_CALL_FLAGS_NONE,
+				    -1, NULL, &error) == FALSE) {
+		/* Ignore errors if the adapter is gone */
+		if (g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD) == FALSE) {
+			g_printerr ("Agent unregistration failed: %s '%s'\n",
+				    error->message,
+				    g_quark_to_string (error->domain));
+		}
+		g_error_free(error);
+	}
+
+	g_object_unref(priv->adapter);
+	priv->adapter = NULL;
+
+	g_free(priv->path);
+	priv->path = NULL;
+
+	g_free(priv->busname);
+	priv->busname = NULL;
+
+	if (priv->reg_id > 0) {
+		g_dbus_connection_unregister_object (priv->conn, priv->reg_id);
+		priv->reg_id = 0;
+	}
+
+	return TRUE;
+}
+
+void bluetooth_agent_set_pincode_func(BluetoothAgent *agent,
+				BluetoothAgentPasskeyFunc func, gpointer data)
+{
+	BluetoothAgentPrivate *priv;
+
+	g_return_if_fail (BLUETOOTH_IS_AGENT (agent));
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	priv->pincode_func = func;
+	priv->pincode_data = data;
+}
+
+void bluetooth_agent_set_passkey_func(BluetoothAgent *agent,
+				BluetoothAgentPasskeyFunc func, gpointer data)
+{
+	BluetoothAgentPrivate *priv;
+
+	g_return_if_fail (BLUETOOTH_IS_AGENT (agent));
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	priv->passkey_func = func;
+	priv->passkey_data = data;
+}
+
+void bluetooth_agent_set_display_func(BluetoothAgent *agent,
+				BluetoothAgentDisplayFunc func, gpointer data)
+{
+	BluetoothAgentPrivate *priv;
+
+	g_return_if_fail (BLUETOOTH_IS_AGENT (agent));
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	priv->display_func = func;
+	priv->display_data = data;
+}
+
+void bluetooth_agent_set_confirm_func(BluetoothAgent *agent,
+				BluetoothAgentConfirmFunc func, gpointer data)
+{
+	BluetoothAgentPrivate *priv;
+
+	g_return_if_fail (BLUETOOTH_IS_AGENT (agent));
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	priv->confirm_func = func;
+	priv->confirm_data = data;
+}
+
+void bluetooth_agent_set_authorize_func(BluetoothAgent *agent,
+				BluetoothAgentAuthorizeFunc func, gpointer data)
+{
+	BluetoothAgentPrivate *priv;
+
+	g_return_if_fail (BLUETOOTH_IS_AGENT (agent));
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	priv->authorize_func = func;
+	priv->authorize_data = data;
+}
+
+void bluetooth_agent_set_cancel_func(BluetoothAgent *agent,
+				BluetoothAgentCancelFunc func, gpointer data)
+{
+	BluetoothAgentPrivate *priv;
+
+	g_return_if_fail (BLUETOOTH_IS_AGENT (agent));
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	priv->cancel_func = func;
+	priv->cancel_data = data;
+}
+
+GQuark bluetooth_agent_error_quark(void)
+{
+	static GQuark quark = 0;
+	if (!quark)
+		quark = g_quark_from_static_string("agent");
+
+	return quark;
+}
+
+#define ENUM_ENTRY(NAME, DESC) { NAME, "" #NAME "", DESC }
+
+GType bluetooth_agent_error_get_type(void)
+{
+	static GType etype = 0;
+	if (etype == 0) {
+		static const GEnumValue values[] = {
+			ENUM_ENTRY(AGENT_ERROR_REJECT, "Rejected"),
+			{ 0, 0, 0 }
+		};
+
+		etype = g_enum_register_static("agent", values);
+	}
+
+	return etype;
+}
+
 
=== added directory '.pc/ssp-parameter-fix.patch/wizard'
=== added file '.pc/ssp-parameter-fix.patch/wizard/main.c'
--- .pc/ssp-parameter-fix.patch/wizard/main.c	1970-01-01 00:00:00 +0000
+++ .pc/ssp-parameter-fix.patch/wizard/main.c	2014-05-15 03:31:21 +0000
@@ -0,0 +1,1001 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2005-2008  Marcel Holtmann <[e-mail]>
+ *
+ *
+ *  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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <math.h>
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+
+#include <bluetooth-client.h>
+#include <bluetooth-client-private.h>
+#include <bluetooth-chooser.h>
+#include <bluetooth-agent.h>
+#include <bluetooth-plugin-manager.h>
+
+#include "pin.h"
+
+#define AGENT_PATH "/org/bluez/agent/wizard"
+
+/* We'll try to connect to the device repeatedly for that
+ * amount of time before we bail out */
+#define CONNECT_TIMEOUT 3.0
+
+#define W(x) GTK_WIDGET(gtk_builder_get_object(builder, x))
+
+enum {
+	PAGE_SEARCH,
+	PAGE_CONNECTING,
+	PAGE_SETUP,
+	PAGE_SSP_SETUP,
+	PAGE_FINISHING,
+	PAGE_SUMMARY
+};
+
+typedef enum {
+	PAIRING_UI_NORMAL,
+	PAIRING_UI_KEYBOARD,
+	PAIRING_UI_ICADE
+} PairingUIBehaviour;
+
+static gboolean set_page_search_complete(void);
+
+static BluetoothClient *client;
+static BluetoothAgent *agent;
+
+static gchar *target_address = NULL;
+static gchar *target_name = NULL;
+static guint target_max_digits = 0;
+static PairingUIBehaviour target_ui_behaviour = PAIRING_UI_NORMAL;
+static gboolean target_ssp = FALSE;
+static gboolean create_started = FALSE;
+static gboolean display_called = FALSE;
+
+/* NULL means automatic, anything else is a pincode specified by the user */
+static gchar *user_pincode = NULL;
+/* If TRUE, then we won't display the PIN code to the user when pairing */
+static gboolean automatic_pincode = FALSE;
+static char *pincode = NULL;
+
+static GtkBuilder *builder = NULL;
+
+static GtkAssistant *window_assistant = NULL;
+static GtkWidget *button_quit = NULL;
+static GtkWidget *button_cancel = NULL;
+static GtkWidget *page_search = NULL;
+static GtkWidget *page_connecting = NULL;
+static GtkWidget *page_setup = NULL;
+static GtkWidget *page_ssp_setup = NULL;
+static GtkWidget *page_finishing = NULL;
+static GtkWidget *page_summary = NULL;
+
+static GtkWidget *label_connecting = NULL;
+static GtkWidget *spinner_connecting = NULL;
+
+static GtkWidget *label_pin = NULL;
+static GtkWidget *label_pin_help = NULL;
+
+static GtkWidget *label_ssp_pin_help = NULL;
+static GtkWidget *label_ssp_pin = NULL;
+static GtkWidget *does_not_match_button = NULL;
+static GtkWidget *matches_button = NULL;
+
+static GtkWidget *label_finishing = NULL;
+static GtkWidget *spinner_finishing = NULL;
+
+static gboolean   summary_failure = FALSE;
+static GtkWidget *label_summary = NULL;
+static GtkWidget *extra_config_vbox = NULL;
+
+static BluetoothChooser *selector = NULL;
+
+static GtkWidget *pin_dialog = NULL;
+static GtkWidget *radio_auto = NULL;
+static GtkWidget *radio_0000 = NULL;
+static GtkWidget *radio_1111 = NULL;
+static GtkWidget *radio_1234 = NULL;
+static GtkWidget *radio_none = NULL;
+static GtkWidget *radio_custom = NULL;
+static GtkWidget *entry_custom = NULL;
+
+/* Signals */
+void quit_callback(GtkWidget *assistant, gpointer data);
+void prepare_callback(GtkWidget *assistant, GtkWidget *page, gpointer data);
+void select_device_changed(BluetoothChooser *selector, const char *address, gpointer user_data);
+gboolean entry_custom_event(GtkWidget *entry, GdkEventKey *event);
+void set_user_pincode(GtkWidget *button);
+void toggle_set_sensitive(GtkWidget *button, gpointer data);
+void pin_option_button_clicked (GtkButton *button, gpointer data);
+void entry_custom_changed(GtkWidget *entry);
+void restart_button_clicked (GtkButton *button, gpointer user_data);
+void does_not_match_cb (GtkButton *button, gpointer user_data);
+void matches_cb (GtkButton *button, gpointer user_data);
+
+static void
+set_large_label (GtkLabel *label, const char *text)
+{
+	char *str;
+
+	str = g_strdup_printf("<span font_desc=\"50\">  %s  </span>", text);
+	gtk_label_set_markup(GTK_LABEL(label), str);
+	g_free(str);
+}
+
+static char *
+get_random_pincode (guint num_digits)
+{
+	if (num_digits == 0)
+		num_digits = PIN_NUM_DIGITS;
+	return g_strdup_printf ("%d", g_random_int_range (pow (10, num_digits - 1),
+							  pow (10, num_digits)));
+}
+
+static char *
+get_icade_pincode (char **pin_display_str)
+{
+	GString *pin, *pin_display;
+	guint i;
+	static char *arrows[] = {
+		NULL,
+		"⬆", /* up = 1    */
+		"⬇", /* down = 2  */
+		"⬅", /* left = 3  */
+		"➡"  /* right = 4 */
+	};
+
+	pin = g_string_new (NULL);
+	pin_display = g_string_new (NULL);
+
+	for (i = 0; i < PIN_NUM_DIGITS; i++) {
+		int r;
+		char *c;
+
+		r = g_random_int_range (1, 4);
+
+		c = g_strdup_printf ("%d", r);
+		g_string_append (pin, c);
+		g_free (c);
+
+		g_string_append (pin_display, arrows[r]);
+	}
+	g_string_append (pin_display, "❍");
+
+	*pin_display_str = g_string_free (pin_display, FALSE);
+	return g_string_free (pin, FALSE);
+}
+
+static gboolean
+pincode_callback (GDBusMethodInvocation *invocation,
+		  GDBusProxy *device,
+		  gpointer user_data)
+{
+	target_ssp = FALSE;
+
+	/* Only show the pincode page if the pincode isn't automatic */
+	if (automatic_pincode == FALSE)
+		gtk_assistant_set_current_page (window_assistant, PAGE_SETUP);
+	g_debug ("Using pincode \"%s\"", pincode);
+	g_dbus_method_invocation_return_value (invocation, g_variant_new ("(s)", pincode));
+
+	return TRUE;
+}
+
+void
+restart_button_clicked (GtkButton *button,
+			gpointer user_data)
+{
+	/* Clean up old state */
+	target_ssp = FALSE;
+	display_called = FALSE;
+	g_free (target_address);
+	target_address = NULL;
+	g_free (target_name);
+	target_name = NULL;
+	summary_failure = FALSE;
+	target_ui_behaviour = PAIRING_UI_NORMAL;
+
+	g_object_set (selector,
+		      "device-category-filter", BLUETOOTH_CATEGORY_NOT_PAIRED_OR_TRUSTED,
+		      NULL);
+
+	gtk_assistant_set_current_page (window_assistant, PAGE_SEARCH);
+}
+
+void
+does_not_match_cb (GtkButton *button,
+		   gpointer user_data)
+{
+	GDBusMethodInvocation *invocation;
+	GError *error = NULL;
+	char *text;
+
+	summary_failure = TRUE;
+	gtk_assistant_set_current_page (window_assistant, PAGE_SUMMARY);
+
+	/* translators:
+	 * The '%s' is the device name, for example:
+	 * Pairing with 'Sony Bluetooth Headset' cancelled
+	 */
+	text = g_strdup_printf(_("Pairing with '%s' cancelled"), target_name);
+	gtk_label_set_text(GTK_LABEL(label_summary), text);
+	g_free(text);
+
+	invocation = g_object_get_data (G_OBJECT (button), "invocation");
+	error = g_error_new (AGENT_ERROR, AGENT_ERROR_REJECT,
+			     "Agent callback cancelled");
+	g_dbus_method_invocation_return_gerror (invocation, error);
+	g_error_free (error);
+
+	g_object_set_data (G_OBJECT(does_not_match_button), "invocation", NULL);
+	g_object_set_data (G_OBJECT(matches_button), "invocation", NULL);
+}
+
+void
+matches_cb (GtkButton *button,
+	    gpointer user_data)
+{
+	GDBusMethodInvocation *invocation;
+
+	invocation = g_object_get_data (G_OBJECT (button), "invocation");
+	gtk_widget_set_sensitive (does_not_match_button, FALSE);
+	gtk_widget_set_sensitive (matches_button, FALSE);
+	g_dbus_method_invocation_return_value (invocation, NULL);
+
+	g_object_set_data (G_OBJECT(does_not_match_button), "invocation", NULL);
+	g_object_set_data (G_OBJECT(matches_button), "invocation", NULL);
+}
+
+static gboolean
+confirm_callback (GDBusMethodInvocation *invocation,
+		  GDBusProxy *device,
+		  guint pin,
+		  gpointer user_data)
+{
+	char *str, *label;
+
+	target_ssp = TRUE;
+	gtk_assistant_set_current_page (window_assistant, PAGE_SSP_SETUP);
+
+	gtk_widget_show (label_ssp_pin_help);
+	label = g_strdup_printf (_("Please confirm that the PIN displayed on '%s' matches this one."),
+				 target_name);
+	gtk_label_set_markup(GTK_LABEL(label_ssp_pin_help), label);
+	g_free (label);
+
+	gtk_widget_show (label_ssp_pin);
+	str = g_strdup_printf ("%06d", pin);
+	set_large_label (GTK_LABEL (label_ssp_pin), str);
+	g_free (str);
+
+	g_object_set_data (G_OBJECT(does_not_match_button), "invocation", invocation);
+	g_object_set_data (G_OBJECT(matches_button), "invocation", invocation);
+
+	return TRUE;
+}
+
+static gboolean
+display_callback (GDBusMethodInvocation *invocation,
+		  GDBusProxy *device,
+		  guint pin,
+		  guint entered,
+		  gpointer user_data)
+{
+	gchar *text, *done, *code;
+
+	display_called = TRUE;
+	target_ssp = TRUE;
+	gtk_assistant_set_current_page (window_assistant, PAGE_SSP_SETUP);
+
+	code = g_strdup_printf("%06d", pin);
+
+	if (entered > 0) {
+		GtkEntry *entry;
+		gunichar invisible;
+		GString *str;
+		guint i;
+
+		entry = GTK_ENTRY (gtk_entry_new ());
+		invisible = gtk_entry_get_invisible_char (entry);
+		g_object_unref (entry);
+
+		str = g_string_new (NULL);
+		for (i = 0; i < entered; i++)
+			g_string_append_unichar (str, invisible);
+		if (entered < strlen (code))
+			g_string_append (str, code + entered);
+
+		done = g_string_free (str, FALSE);
+	} else {
+		done = g_strdup ("");
+	}
+
+	gtk_widget_show (label_pin_help);
+
+	gtk_label_set_markup(GTK_LABEL(label_ssp_pin_help), _("Please enter the following PIN:"));
+	text = g_strdup_printf("%s%s", done, code + entered);
+	set_large_label (GTK_LABEL (label_ssp_pin), text);
+	g_free(text);
+
+	g_free(done);
+	g_free(code);
+
+	g_dbus_method_invocation_return_value (invocation, NULL);
+
+	return TRUE;
+}
+
+static gboolean
+cancel_callback (GDBusMethodInvocation *invocation,
+		 gpointer user_data)
+{
+	gchar *text;
+
+	create_started = FALSE;
+
+	summary_failure = TRUE;
+	gtk_assistant_set_current_page (window_assistant, PAGE_SUMMARY);
+
+	/* translators:
+	 * The '%s' is the device name, for example:
+	 * Pairing with 'Sony Bluetooth Headset' cancelled
+	 */
+	text = g_strdup_printf(_("Pairing with '%s' cancelled"), target_name);
+	gtk_label_set_text(GTK_LABEL(label_summary), text);
+	g_free(text);
+
+	g_dbus_method_invocation_return_value (invocation, NULL);
+
+	return TRUE;
+}
+
+typedef struct {
+	char *path;
+	GTimer *timer;
+} ConnectData;
+
+static void
+connect_callback (GObject      *source_object,
+		  GAsyncResult *res,
+		  gpointer      user_data)
+{
+	ConnectData *data = (ConnectData *) user_data;
+	gboolean success;
+
+	success = bluetooth_client_connect_service_finish (client, res, NULL);
+
+	if (success == FALSE && g_timer_elapsed (data->timer, NULL) < CONNECT_TIMEOUT) {
+		bluetooth_client_connect_service (client, data->path, TRUE, NULL, connect_callback, data);
+		return;
+	}
+
+	if (success == FALSE)
+		g_debug ("Failed to connect to device %s", data->path);
+
+	g_timer_destroy (data->timer);
+	g_free (data->path);
+	g_free (data);
+
+	gtk_assistant_set_current_page (window_assistant, PAGE_SUMMARY);
+}
+
+static void
+create_callback (BluetoothClient *_client,
+		 const char *path,
+		 const GError *error,
+		 gpointer user_data)
+{
+	ConnectData *data;
+
+	create_started = FALSE;
+
+	/* Create failed */
+	if (path == NULL) {
+		char *text;
+
+		summary_failure = TRUE;
+		gtk_assistant_set_current_page (window_assistant, PAGE_SUMMARY);
+
+		/* translators:
+		 * The '%s' is the device name, for example:
+		 * Setting up 'Sony Bluetooth Headset' failed
+		 */
+		text = g_strdup_printf(_("Setting up '%s' failed"), target_name);
+
+		g_warning ("Setting up '%s' failed: %s", target_name, error->message);
+
+		gtk_label_set_markup(GTK_LABEL(label_summary), text);
+		g_free (text);
+
+		return;
+	}
+
+	bluetooth_client_set_trusted(client, path, TRUE);
+
+	data = g_new0 (ConnectData, 1);
+	data->path = g_strdup (path);
+	data->timer = g_timer_new ();
+
+	bluetooth_client_connect_service (client, path, TRUE, NULL, connect_callback, data);
+	gtk_assistant_set_current_page (window_assistant, PAGE_FINISHING);
+}
+
+void
+quit_callback (GtkWidget *widget,
+		gpointer data)
+{
+	gtk_widget_destroy(GTK_WIDGET (window_assistant));
+}
+
+void prepare_callback (GtkWidget *assistant,
+		       GtkWidget *page,
+		       gpointer data)
+{
+	gboolean complete = TRUE;
+
+	gtk_widget_hide (button_quit);
+	gtk_widget_hide (button_cancel);
+
+	if (page == page_search) {
+		complete = set_page_search_complete ();
+		bluetooth_chooser_start_discovery(selector);
+	} else {
+		bluetooth_chooser_stop_discovery(selector);
+	}
+
+	if (page == page_connecting) {
+		char *text;
+
+		complete = FALSE;
+
+		gtk_spinner_start (GTK_SPINNER (spinner_connecting));
+
+		/* translators:
+		 * The '%s' is the device name, for example:
+		 * Connecting to 'Sony Bluetooth Headset'...
+		 */
+		text = g_strdup_printf (_("Connecting to '%s'..."), target_name);
+		gtk_label_set_text (GTK_LABEL (label_connecting), text);
+		g_free (text);
+
+		gtk_widget_show (button_cancel);
+	} else {
+		gtk_spinner_stop (GTK_SPINNER (spinner_connecting));
+	}
+
+	if ((page == page_setup || page == page_connecting) && (create_started == FALSE)) {
+		const char *path = AGENT_PATH;
+
+		/* Set the filter on the selector, so we can use it to get more
+		 * info later, in page_summary */
+		g_object_set (selector,
+			      "device-category-filter", BLUETOOTH_CATEGORY_ALL,
+			      NULL);
+
+		/* Do we pair, or don't we? */
+		if (automatic_pincode && pincode == NULL) {
+			g_debug ("Not pairing as %s", automatic_pincode ? "pincode is NULL" : "automatic_pincode is FALSE");
+			path = NULL;
+		}
+
+		g_object_ref(agent);
+		bluetooth_client_create_device (client, target_address,
+						path, create_callback, assistant);
+		create_started = TRUE;
+	}
+
+	if (page == page_setup) {
+		complete = FALSE;
+
+		if (automatic_pincode == FALSE && target_ssp == FALSE) {
+			char *help, *pincode_display;
+
+			g_free (pincode);
+			pincode = NULL;
+			pincode_display = NULL;
+
+			switch (target_ui_behaviour) {
+			case PAIRING_UI_NORMAL:
+				help = g_strdup_printf (_("Please enter the following PIN on '%s':"), target_name);
+				break;
+			case PAIRING_UI_KEYBOARD:
+				help = g_strdup_printf (_("Please enter the following PIN on '%s' and press “Enter” on the keyboard:"), target_name);
+				pincode = get_random_pincode (target_max_digits);
+				pincode_display = g_strdup_printf ("%s⏎", pincode);
+				break;
+			case PAIRING_UI_ICADE:
+				help = g_strdup (_("Please move the joystick of your iCade in the following directions:"));
+				pincode = get_icade_pincode (&pincode_display);
+				break;
+			default:
+				g_assert_not_reached ();
+			}
+
+			if (pincode == NULL)
+				pincode = get_random_pincode (target_max_digits);
+
+			gtk_label_set_markup(GTK_LABEL(label_pin_help), help);
+			g_free (help);
+			set_large_label (GTK_LABEL (label_pin), pincode_display ? pincode_display : pincode);
+			g_free (pincode_display);
+		} else {
+			g_assert_not_reached ();
+		}
+
+		gtk_widget_show (button_cancel);
+	}
+
+	if (page == page_finishing) {
+		char *text;
+
+		complete = FALSE;
+
+		gtk_spinner_start (GTK_SPINNER (spinner_finishing));
+
+		/* translators:
+		 * The '%s' is the device name, for example:
+		 * Please wait while finishing setup on 'Sony Bluetooth Headset'...
+		 */
+		text = g_strdup_printf (_("Please wait while finishing setup on device '%s'..."), target_name);
+		gtk_label_set_text (GTK_LABEL (label_finishing), text);
+		g_free (text);
+
+		gtk_widget_show (button_quit);
+	} else {
+		gtk_spinner_stop (GTK_SPINNER (spinner_finishing));
+	}
+
+	if (page == page_summary && summary_failure == FALSE) {
+		GList *widgets = NULL;
+		GValue value = { 0, };
+		char **uuids, *text;
+
+		/* FIXME remove this code when bluetoothd has pair/unpair code */
+		g_object_set (G_OBJECT (selector), "device-selected", target_address, NULL);
+
+		bluetooth_chooser_get_selected_device_info (selector, "name", &value);
+		text = g_strdup_printf (_("Successfully set up new device '%s'"), g_value_get_string (&value));
+		g_value_unset (&value);
+		gtk_label_set_text (GTK_LABEL (label_summary), text);
+		g_free (text);
+
+		if (bluetooth_chooser_get_selected_device_info (selector, "uuids", &value) != FALSE) {
+			uuids = g_value_get_boxed (&value);
+			widgets = bluetooth_plugin_manager_get_widgets (target_address,
+									(const char **) uuids);
+			g_value_unset (&value);
+		}
+		if (widgets != NULL) {
+			GList *l;
+
+			for (l = widgets; l != NULL; l = l->next) {
+				GtkWidget *widget = l->data;
+				gtk_box_pack_start (GTK_BOX (extra_config_vbox),
+						    widget,
+						    FALSE,
+						    TRUE,
+						    0);
+			}
+			g_list_free (widgets);
+			gtk_widget_show_all (extra_config_vbox);
+		}
+		gtk_widget_show (button_quit);
+	}
+
+	/* Setup the buttons some */
+	if (page == page_summary && summary_failure) {
+		complete = FALSE;
+		gtk_assistant_add_action_widget (GTK_ASSISTANT (assistant), W("restart_button"));
+		gtk_widget_show (button_quit);
+	} else {
+		if (gtk_widget_get_parent (W("restart_button")) != NULL)
+			gtk_assistant_remove_action_widget (GTK_ASSISTANT (assistant), W("restart_button"));
+	}
+
+	if (page == page_ssp_setup) {
+		if (display_called == FALSE) {
+			complete = FALSE;
+			gtk_assistant_add_action_widget (GTK_ASSISTANT (assistant), W("matches_button"));
+			gtk_assistant_add_action_widget (GTK_ASSISTANT (assistant), W("does_not_match_button"));
+		} else {
+			gtk_widget_show (button_cancel);
+		}
+	} else {
+		if (gtk_widget_get_parent (W("does_not_match_button")) != NULL)
+			gtk_assistant_remove_action_widget (GTK_ASSISTANT (assistant), W("does_not_match_button"));
+		if (gtk_widget_get_parent (W("matches_button")) != NULL)
+			gtk_assistant_remove_action_widget (GTK_ASSISTANT (assistant), W("matches_button"));
+	}
+
+	gtk_assistant_set_page_complete (GTK_ASSISTANT(assistant),
+					 page, complete);
+}
+
+static gboolean
+set_page_search_complete (void)
+{
+	char *name, *address;
+	gboolean complete = FALSE;
+
+	address = bluetooth_chooser_get_selected_device (selector);
+	name = bluetooth_chooser_get_selected_device_name (selector);
+
+	if (address == NULL)
+		complete = FALSE;
+	else if (name == NULL)
+		complete = (user_pincode != NULL && strlen(user_pincode) >= 4);
+	else
+		complete = (user_pincode == NULL || strlen(user_pincode) >= 4);
+
+	g_free (address);
+	g_free (name);
+
+	gtk_assistant_set_page_complete (GTK_ASSISTANT (window_assistant),
+					 page_search, complete);
+
+	return complete;
+}
+
+gboolean
+entry_custom_event (GtkWidget *entry, GdkEventKey *event)
+{
+	gunichar c;
+
+	if (event->length == 0)
+		return FALSE;
+
+	/* Not a printable character? */
+	c = gdk_keyval_to_unicode (event->keyval);
+	if (c == 0 ||
+	    g_unichar_iscntrl (c) ||
+	    g_unichar_isdigit (c))
+		return FALSE;
+
+	return TRUE;
+}
+
+void
+entry_custom_changed (GtkWidget *entry)
+{
+	g_free (user_pincode);
+	user_pincode = g_strdup (gtk_entry_get_text(GTK_ENTRY(entry)));
+	gtk_dialog_set_response_sensitive (GTK_DIALOG (pin_dialog),
+					   GTK_RESPONSE_ACCEPT,
+					   gtk_entry_get_text_length (GTK_ENTRY (entry)) >= 1);
+}
+
+void
+toggle_set_sensitive (GtkWidget *button,
+		      gpointer data)
+{
+	gboolean active;
+
+	active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
+	gtk_widget_set_sensitive(entry_custom, active);
+	/* When selecting another PIN, make sure the "Close" button is sensitive */
+	if (!active)
+		gtk_dialog_set_response_sensitive (GTK_DIALOG (pin_dialog),
+						   GTK_RESPONSE_ACCEPT, TRUE);
+	else
+		entry_custom_changed (entry_custom);
+}
+
+void
+set_user_pincode (GtkWidget *button)
+{
+	if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
+		return;
+
+	g_free (user_pincode);
+	user_pincode = g_strdup (g_object_get_data (G_OBJECT (button), "pin"));
+}
+
+void
+select_device_changed (BluetoothChooser *selector,
+		       const char *address,
+		       gpointer user_data)
+{
+	GValue value = { 0, };
+	guint target_type = BLUETOOTH_TYPE_ANY;
+	gboolean is_custom_pin = FALSE;
+	int legacypairing;
+
+	if (gtk_assistant_get_current_page (GTK_ASSISTANT (window_assistant)) != PAGE_SEARCH)
+		return;
+
+	set_page_search_complete ();
+
+	/* Device was deselected */
+	if (address == NULL)
+		return;
+
+	if (bluetooth_chooser_get_selected_device_info (selector, "legacypairing", &value) != FALSE) {
+		legacypairing = g_value_get_int (&value);
+		if (legacypairing == -1)
+			legacypairing = TRUE;
+	} else {
+		legacypairing = TRUE;
+	}
+
+	g_free(target_address);
+	target_address = g_strdup (address);
+
+	g_free(target_name);
+	target_name = bluetooth_chooser_get_selected_device_name (selector);
+
+	target_type = bluetooth_chooser_get_selected_device_type (selector);
+	target_ssp = !legacypairing;
+	automatic_pincode = FALSE;
+	target_ui_behaviour = PAIRING_UI_NORMAL;
+
+	g_free (pincode);
+	pincode = NULL;
+
+	g_free (user_pincode);
+	user_pincode = get_pincode_for_device (target_type, target_address, target_name, &target_max_digits);
+	if (user_pincode != NULL &&
+	    g_str_equal (user_pincode, "NULL") == FALSE) {
+		if (g_str_equal (user_pincode, "KEYBOARD")) {
+			target_ui_behaviour = PAIRING_UI_KEYBOARD;
+			is_custom_pin = TRUE;
+		} else if (g_str_equal (user_pincode, "ICADE")) {
+			target_ui_behaviour = PAIRING_UI_ICADE;
+			is_custom_pin = TRUE;
+		} else {
+			pincode = g_strdup (user_pincode);
+		}
+	}
+
+	if (is_custom_pin)
+		automatic_pincode = FALSE;
+	else
+		automatic_pincode = user_pincode != NULL;
+
+	g_free (user_pincode);
+	user_pincode = NULL;
+
+	gtk_entry_set_max_length (GTK_ENTRY (entry_custom), target_max_digits);
+}
+
+void
+pin_option_button_clicked (GtkButton *button,
+			       gpointer data)
+{
+	GtkWidget *radio;
+
+	gtk_window_set_transient_for (GTK_WINDOW (pin_dialog),
+				      GTK_WINDOW (window_assistant));
+	gtk_window_present (GTK_WINDOW (pin_dialog));
+
+	/* When reopening, try to guess where the pincode was set */
+	if (user_pincode == NULL)
+		radio = radio_auto;
+	else if (g_str_equal (user_pincode, "0000"))
+		radio = radio_0000;
+	else if (g_str_equal (user_pincode, "1111"))
+		radio = radio_1111;
+	else if (g_str_equal (user_pincode, "1234"))
+		radio = radio_1234;
+	else if (g_str_equal (user_pincode, "NULL"))
+		radio = radio_none;
+	else {
+		radio = radio_custom;
+		gtk_entry_set_text (GTK_ENTRY (entry_custom), user_pincode);
+	}
+	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), TRUE);
+
+	gtk_dialog_run (GTK_DIALOG (pin_dialog));
+	gtk_widget_hide (pin_dialog);
+	g_free (pincode);
+	pincode = g_strdup (user_pincode);
+	automatic_pincode = user_pincode != NULL;
+}
+
+static int
+page_func (gint current_page,
+	   gpointer data)
+{
+	if (current_page == PAGE_SEARCH) {
+		if (target_ssp != FALSE || automatic_pincode != FALSE)
+			return PAGE_CONNECTING;
+		else
+			return PAGE_SETUP;
+	}
+	if (current_page == PAGE_SETUP)
+		return PAGE_SUMMARY;
+	return current_page + 1;
+}
+
+static gboolean
+create_wizard (void)
+{
+	GtkAssistant *assistant;
+	GError *err = NULL;
+
+	builder = gtk_builder_new ();
+	if (gtk_builder_add_from_file (builder, "wizard.ui", NULL) == 0) {
+		if (gtk_builder_add_from_file (builder, PKGDATADIR "/wizard.ui", &err) == 0) {
+			g_warning ("Could not load UI from %s: %s", PKGDATADIR "/wizard.ui", err->message);
+			g_error_free(err);
+			return FALSE;
+		}
+	}
+
+	window_assistant = GTK_ASSISTANT(gtk_builder_get_object(builder, "assistant"));
+	assistant = window_assistant;
+
+	gtk_assistant_set_forward_page_func (assistant, page_func, NULL, NULL);
+
+	/* The 2 custom buttons */
+	button_quit = W("quit_button");
+	button_cancel = W("cancel_button");
+	gtk_assistant_add_action_widget (assistant, button_quit);
+	gtk_assistant_add_action_widget (assistant, button_cancel);
+	gtk_widget_hide (button_quit);
+	gtk_widget_hide (button_cancel);
+
+	/* Intro page, nothing to do */
+
+	/* Search page */
+	page_search = W("page_search");
+	selector = BLUETOOTH_CHOOSER (gtk_builder_get_object (builder, "selector"));
+
+	/* Connecting page */
+	page_connecting = W("page_connecting");
+	label_connecting = W("label_connecting");
+	spinner_connecting = W("spinner_connecting");
+
+	/* Setup page */
+	page_setup = W("page_setup");
+	label_pin_help = W("label_pin_help");
+	label_pin = W("label_pin");
+
+	/* SSP Setup page */
+	page_ssp_setup = W("page_ssp_setup");
+	gtk_assistant_set_page_complete(assistant, page_ssp_setup, FALSE);
+	label_ssp_pin_help = W("label_ssp_pin_help");
+	label_ssp_pin = W("label_ssp_pin");
+	does_not_match_button = W("does_not_match_button");
+	matches_button = W("matches_button");
+
+	/* Finishing page */
+	page_finishing = W("page_finishing");
+	label_finishing = W("label_finishing");
+	spinner_finishing = W("spinner_finishing");
+
+	/* Summary page */
+	page_summary = W("page_summary");
+	label_summary = W("label_summary");
+	extra_config_vbox = W("extra_config_vbox");
+
+	/* PIN dialog */
+	pin_dialog = W("pin_dialog");
+	radio_auto = W("radio_auto");
+	radio_0000 = W("radio_0000");
+	radio_1111 = W("radio_1111");
+	radio_1234 = W("radio_1234");
+	radio_none = W("radio_none");
+	radio_custom = W("radio_custom");
+	entry_custom = W("entry_custom");
+
+	g_object_set_data (G_OBJECT (radio_auto), "pin", NULL);
+	g_object_set_data (G_OBJECT (radio_0000), "pin", "0000");
+	g_object_set_data (G_OBJECT (radio_1111), "pin", "1111");
+	g_object_set_data (G_OBJECT (radio_1234), "pin", "1234");
+	g_object_set_data (G_OBJECT (radio_none), "pin", "NULL");
+	g_object_set_data (G_OBJECT (radio_custom), "pin", "");
+	g_object_set_data (G_OBJECT (radio_custom), "entry", entry_custom);
+
+	gtk_builder_connect_signals(builder, NULL);
+
+	gtk_widget_show (GTK_WIDGET(assistant));
+
+	gtk_assistant_update_buttons_state(GTK_ASSISTANT(assistant));
+
+	return TRUE;
+}
+
+static void
+activate_cb (GApplication      *app,
+	     gpointer           user_data)
+{
+	gtk_window_present_with_time (GTK_WINDOW (user_data), GDK_CURRENT_TIME);
+}
+
+static GOptionEntry options[] = {
+	{ NULL },
+};
+
+int main (int argc, char **argv)
+{
+	GtkApplication *app;
+	GError *error = NULL;
+
+	bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
+	bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
+	textdomain(GETTEXT_PACKAGE);
+
+	if (gtk_init_with_args(&argc, &argv, NULL,
+				options, GETTEXT_PACKAGE, &error) == FALSE) {
+		if (error) {
+			g_printerr("%s\n", error->message);
+			g_error_free(error);
+		} else
+			g_printerr("An unknown error occurred\n");
+
+		return 1;
+	}
+
+	app = gtk_application_new ("org.gnome.Bluetooth.wizard", G_APPLICATION_FLAGS_NONE);
+	if (g_application_register (G_APPLICATION (app), NULL, &error) == FALSE) {
+		g_warning ("Could not register application: %s", error->message);
+		g_error_free (error);
+		return 1;
+	}
+
+	if (g_application_get_is_remote (G_APPLICATION (app))) {
+		g_application_activate (G_APPLICATION (app));
+		gdk_notify_startup_complete ();
+		return 0;
+	}
+
+	gtk_window_set_default_icon_name("bluetooth");
+
+	client = bluetooth_client_new();
+
+	agent = bluetooth_agent_new();
+	g_object_add_weak_pointer (G_OBJECT (agent), (gpointer *) (&agent));
+
+	bluetooth_agent_set_pincode_func(agent, pincode_callback, NULL);
+	bluetooth_agent_set_display_func(agent, display_callback, NULL);
+	bluetooth_agent_set_cancel_func(agent, cancel_callback, NULL);
+	bluetooth_agent_set_confirm_func(agent, confirm_callback, NULL);
+
+	bluetooth_agent_setup(agent, AGENT_PATH);
+
+	bluetooth_plugin_manager_init ();
+
+	if (create_wizard() == FALSE)
+		return 1;
+	gtk_application_add_window (app,
+				    GTK_WINDOW (window_assistant));
+
+	g_signal_connect (app, "activate",
+			  G_CALLBACK (activate_cb), window_assistant);
+
+	g_application_run (G_APPLICATION (app), argc, argv);
+
+	bluetooth_plugin_manager_cleanup ();
+
+	if (agent != NULL)
+		g_object_unref (agent);
+
+	g_object_unref(client);
+
+	g_object_unref(app);
+
+	return 0;
+}
+
 
=== modified file 'debian/changelog'
--- debian/changelog	2014-04-25 02:00:56 +0000
+++ debian/changelog	2014-05-15 03:31:21 +0000
@@ -1,3 +1,13 @@
+gnome-bluetooth (3.8.2.1-0ubuntu6~test1) utopic; urgency=medium
+
+  * Add ssp parameter fix, fix the parameter entered in agent dbus API,
+    also fix the wizard's UI to show the pin code correctly.
+    Fixed Logitech Bluetooth Keyboard K760, Logitech Bluetooth Keyboard K810,
+    HP Bluetooth Keyboard K4000 secure simple pairing failed issue.
+    (LP: #1035431, #1291756)
+
+ -- Jian-Ding Chen (timchen119) <[e-mail]>  Fri, 02 May 2014 16:50:57 +0800
+
 gnome-bluetooth (3.8.2.1-0ubuntu5) utopic; urgency=low
 
   * debian/patches/99_add_microsoft_mice.patch: fix the problem that
 
=== modified file 'debian/patches/series'
--- debian/patches/series	2014-02-25 16:32:43 +0000
+++ debian/patches/series	2014-05-15 03:31:21 +0000
@@ -7,3 +7,4 @@
 git_leak_fixes.patch
 git_disconnect_callbacks.patch
 git_reference_handling.patch
+ssp-parameter-fix.patch
 
=== added file 'debian/patches/ssp-parameter-fix.patch'
--- debian/patches/ssp-parameter-fix.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/ssp-parameter-fix.patch	2014-05-15 03:31:21 +0000
@@ -0,0 +1,86 @@
+Description: ssp parameter fix
+   * Add ssp parameter fix, fix the parameter entered in agent dbus API,
+     also fix the wizard's UI to show the pin code correctly.
+     Fixed Logitech Bluetooth Keyboard K760, Logitech Bluetooth Keyboard K810,
+     HP Bluetooth Keyboard K4000 secure simple pairing failed issue.
+     (LP: #1035431, #1291756)
+Author: Jian-Ding Chen (timchen119) <[e-mail]>
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1035431
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1291756
+Last-Update: 2014-04-29
+
+--- gnome-bluetooth-3.8.2.1.orig/lib/bluetooth-agent.c
++++ gnome-bluetooth-3.8.2.1/lib/bluetooth-agent.c
+@@ -52,7 +52,7 @@ static const gchar introspection_xml[] =
+ "    <method name='DisplayPasskey'>"
+ "      <arg type='o' name='device' direction='in'/>"
+ "      <arg type='u' name='passkey' direction='in'/>"
+-"      <arg type='y' name='entered' direction='in'/>"
++"      <arg type='q' name='entered' direction='in'/>"
+ "    </method>"
+ "    <method name='RequestConfirmation'>"
+ "      <arg type='o' name='device' direction='in'/>"
+@@ -164,7 +164,7 @@ static gboolean bluetooth_agent_request_
+ }
+ 
+ static gboolean bluetooth_agent_display_passkey(BluetoothAgent *agent,
+-			const char *path, guint passkey, guint8 entered,
++			const char *path, guint passkey, guint16 entered,
+ 						GDBusMethodInvocation *invocation)
+ {
+ 	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+@@ -339,9 +339,9 @@ handle_method_call (GDBusConnection
+ 	} else if (g_strcmp0 (method_name, "DisplayPasskey") == 0) {
+ 		char *path;
+ 		guint32 passkey;
+-		guint8 entered;
++		guint16 entered;
+ 
+-		g_variant_get (parameters, "(ouy)", &path, &passkey, &entered);
++		g_variant_get (parameters, "(ouq)", &path, &passkey, &entered);
+ 		bluetooth_agent_display_passkey (agent, path, passkey, entered, invocation);
+ 		g_free (path);
+ 	} else if (g_strcmp0 (method_name, "RequestConfirmation") == 0) {
+--- gnome-bluetooth-3.8.2.1.orig/wizard/main.c
++++ gnome-bluetooth-3.8.2.1/wizard/main.c
+@@ -303,7 +303,7 @@ display_callback (GDBusMethodInvocation
+ 		  guint entered,
+ 		  gpointer user_data)
+ {
+-	gchar *text, *done, *code;
++	gchar *text, *done, *code, *label;
+ 
+ 	display_called = TRUE;
+ 	target_ssp = TRUE;
+@@ -329,18 +329,27 @@ display_callback (GDBusMethodInvocation
+ 
+ 		done = g_string_free (str, FALSE);
+ 	} else {
+-		done = g_strdup ("");
++		done = g_strdup_printf("%s", code);
+ 	}
+ 
+-	gtk_widget_show (label_pin_help);
++	gtk_widget_show (label_ssp_pin);
+ 
+-	gtk_label_set_markup(GTK_LABEL(label_ssp_pin_help), _("Please enter the following PIN:"));
+-	text = g_strdup_printf("%s%s", done, code + entered);
++	if (target_ui_behaviour == PAIRING_UI_KEYBOARD) {
++		label = g_strdup_printf (_("Please enter the following PIN on '%s' and press “Enter” on the keyboard:"), target_name);
++		text = g_strdup_printf("%s⏎", done);
++	}
++	else {
++		label = g_strdup_printf (_("Please enter the following PIN on '%s':"), target_name);
++		text = g_strdup_printf("%s", done);
++	}
++
++	gtk_label_set_markup(GTK_LABEL(label_ssp_pin_help), label);
+ 	set_large_label (GTK_LABEL (label_ssp_pin), text);
+ 	g_free(text);
+ 
+ 	g_free(done);
+ 	g_free(code);
++	g_free(label);
+ 
+ 	g_dbus_method_invocation_return_value (invocation, NULL);
+ 
 
=== modified file 'lib/bluetooth-agent.c'
--- lib/bluetooth-agent.c	2013-07-03 16:07:57 +0000
+++ lib/bluetooth-agent.c	2014-05-15 03:31:21 +0000
@@ -52,7 +52,7 @@
 "    <method name='DisplayPasskey'>"
 "      <arg type='o' name='device' direction='in'/>"
 "      <arg type='u' name='passkey' direction='in'/>"
-"      <arg type='y' name='entered' direction='in'/>"
+"      <arg type='q' name='entered' direction='in'/>"
 "    </method>"
 "    <method name='RequestConfirmation'>"
 "      <arg type='o' name='device' direction='in'/>"
@@ -164,7 +164,7 @@
 }
 
 static gboolean bluetooth_agent_display_passkey(BluetoothAgent *agent,
-			const char *path, guint passkey, guint8 entered,
+			const char *path, guint passkey, guint16 entered,
 						GDBusMethodInvocation *invocation)
 {
 	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
@@ -339,9 +339,9 @@
 	} else if (g_strcmp0 (method_name, "DisplayPasskey") == 0) {
 		char *path;
 		guint32 passkey;
-		guint8 entered;
+		guint16 entered;
 
-		g_variant_get (parameters, "(ouy)", &path, &passkey, &entered);
+		g_variant_get (parameters, "(ouq)", &path, &passkey, &entered);
 		bluetooth_agent_display_passkey (agent, path, passkey, entered, invocation);
 		g_free (path);
 	} else if (g_strcmp0 (method_name, "RequestConfirmation") == 0) {
 
=== modified file 'wizard/main.c'
--- wizard/main.c	2013-07-03 16:07:57 +0000
+++ wizard/main.c	2014-05-15 03:31:21 +0000
@@ -303,7 +303,7 @@
 		  guint entered,
 		  gpointer user_data)
 {
-	gchar *text, *done, *code;
+	gchar *text, *done, *code, *label;
 
 	display_called = TRUE;
 	target_ssp = TRUE;
@@ -329,18 +329,27 @@
 
 		done = g_string_free (str, FALSE);
 	} else {
-		done = g_strdup ("");
-	}
-
-	gtk_widget_show (label_pin_help);
-
-	gtk_label_set_markup(GTK_LABEL(label_ssp_pin_help), _("Please enter the following PIN:"));
-	text = g_strdup_printf("%s%s", done, code + entered);
+		done = g_strdup_printf("%s", code);
+	}
+
+	gtk_widget_show (label_ssp_pin);
+
+	if (target_ui_behaviour == PAIRING_UI_KEYBOARD) {
+		label = g_strdup_printf (_("Please enter the following PIN on '%s' and press “Enter” on the keyboard:"), target_name);
+		text = g_strdup_printf("%s⏎", done);
+	}
+	else {
+		label = g_strdup_printf (_("Please enter the following PIN on '%s':"), target_name);
+		text = g_strdup_printf("%s", done);
+	}
+
+	gtk_label_set_markup(GTK_LABEL(label_ssp_pin_help), label);
 	set_large_label (GTK_LABEL (label_ssp_pin), text);
 	g_free(text);
 
 	g_free(done);
 	g_free(code);
+	g_free(label);
 
 	g_dbus_method_invocation_return_value (invocation, NULL);