[PATCH obexd v0 00/16] client: Remove D-Bus agent

[PATCH obexd v0 00/16] client: Remove D-Bus agent

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

This patchset includes a second set of D-Bus changes as part of a bigger API rewrite in obex-client. The original API proposal started around 6 months ago ([1]) and it has later been discussed and modified several times.

This second series focuses on the replacement of the D-Bus agent: the authorization part is entirely removed and the reporting part is now addressed using D-Bus signals. The resulting API is more BlueZ-style and easier to use.

A third and last patchset is left out for later discussion (not proposed yet in the ML). These should extend the D-Bus API such that the transfer-initiating methods will return relevant information (D-Bus path + properties, to be discussed) about the created transfer object.

This results in a transitional API problem regarding FileTransfer interface: once the agent is removed, and before the transfer path is reported, there is no proper way to get transfer notifications. This problem can be seen in patch v0 16/16, but hopefully it's acceptable during the API transition. The fix is not included here to keep a reasonable patchset size.

Mikel Astiz (16):
  client: Add D-Bus helper library
  client-doc: Add progress property to transfer
  client: Add progress property to transfer
  client-doc: Add transfer event-reporting signals
  client: Add transfer event-reporting signals
  client-doc: Remove D-Bus agent
  client: Use transfer owner instead of agent
  client: Remove D-Bus agent
  client: Remove unused functions in transfer API
  client: Remove internal transfer progress report
  client: Remove obsolete authentication code
  client: Make D-Bus exposure of transfers optional
  client-doc: Add signal to report new transfers
  client: Expose D-Bus data in internal transfer API
  client: Add signal to report new transfers
  client-test: Remove agent from ftp-client

 Makefile.am        |    2 +-
 client/agent.c     |  252 --------------------------------
 client/agent.h     |   43 ------
 client/dbus.c      |  256 ++++++++++++++++++++++++++++++++
 client/dbus.h      |   66 +++++++++
 client/ftp.c       |   48 ++-----
 client/map.c       |    6 +-
 client/opp.c       |    4 +-
 client/pbap.c      |    8 +-
 client/session.c   |  408 ++++++++++------------------------------------------
 client/session.h   |    6 +-
 client/sync.c      |    4 +-
 client/transfer.c  |  205 ++++++++++++++------------
 client/transfer.h  |   13 +-
 doc/client-api.txt |   53 ++------
 test/ftp-client    |   49 ++-----
 16 files changed, 561 insertions(+), 862 deletions(-)
 delete mode 100644 client/agent.c
 delete mode 100644 client/agent.h
 create mode 100644 client/dbus.c
 create mode 100644 client/dbus.h

-- 
1.7.7.6

[PATCH obexd v0 01/16] client: Add D-Bus helper library

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

No functionality changes. This is just about avoiding duplicated code.
---
 Makefile.am       |    1 +
 client/dbus.c     |  256 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 client/dbus.h     |   66 ++++++++++++++
 client/ftp.c      |   42 ++--------
 client/session.c  |   42 +--------
 client/transfer.c |   42 +--------
 6 files changed, 339 insertions(+), 110 deletions(-)
 create mode 100644 client/dbus.c
 create mode 100644 client/dbus.h

diff --git a/Makefile.am b/Makefile.am
index 3cde6c0..86f9ad1 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -126,6 +126,7 @@ client_obex_client_SOURCES = $(gdbus_sources) $(gobex_sources) \
 				client/transfer.h client/transfer.c \
 				client/agent.h client/agent.c \
 				client/transport.h client/transport.c \
+				client/dbus.h client/dbus.c \
 				client/driver.h client/driver.c \
 				src/map_ap.h src/map_ap.c
 
diff --git a/client/dbus.c b/client/dbus.c
new file mode 100644
index 0000000..c8f86f8
--- /dev/null
+++ b/client/dbus.c
@@ -0,0 +1,256 @@
+/*
+ *
+ *  OBEX Client
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 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 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 <glib.h>
+#include <gdbus.h>
+
+#include "log.h"
+#include "dbus.h"
+
+static void append_variant(DBusMessageIter *iter,
+				int type, void *value)
+{
+	char sig[2];
+	DBusMessageIter valueiter;
+
+	sig[0] = type;
+	sig[1] = 0;
+
+	dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
+						sig, &valueiter);
+
+	dbus_message_iter_append_basic(&valueiter, type, value);
+
+	dbus_message_iter_close_container(iter, &valueiter);
+}
+
+void obex_dbus_dict_append(DBusMessageIter *dict,
+			const char *key, int type, void *value)
+{
+	DBusMessageIter keyiter;
+
+	if (type == DBUS_TYPE_STRING) {
+		const char *str = *((const char **) value);
+		if (str == NULL)
+			return;
+	}
+
+	dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
+							NULL, &keyiter);
+
+	dbus_message_iter_append_basic(&keyiter, DBUS_TYPE_STRING, &key);
+
+	append_variant(&keyiter, type, value);
+
+	dbus_message_iter_close_container(dict, &keyiter);
+}
+
+static void append_array_variant(DBusMessageIter *iter, int type, void *val)
+{
+	DBusMessageIter variant, array;
+	char typesig[2];
+	char arraysig[3];
+	const char **str_array = *(const char ***) val;
+	int i;
+
+	arraysig[0] = DBUS_TYPE_ARRAY;
+	arraysig[1] = typesig[0] = type;
+	arraysig[2] = typesig[1] = '\0';
+
+	dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
+						arraysig, &variant);
+
+	dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY,
+						typesig, &array);
+
+	for (i = 0; str_array[i]; i++)
+		dbus_message_iter_append_basic(&array, type,
+						&(str_array[i]));
+
+	dbus_message_iter_close_container(&variant, &array);
+
+	dbus_message_iter_close_container(iter, &variant);
+}
+
+void obex_dbus_dict_append_array(DBusMessageIter *dict, const char *key,
+				int type, void *val)
+{
+	DBusMessageIter entry;
+
+	dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
+						NULL, &entry);
+
+	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
+
+	append_array_variant(&entry, type, val);
+
+	dbus_message_iter_close_container(dict, &entry);
+}
+
+static void append_dict_variant(DBusMessageIter *iter, int type, void *val)
+{
+	DBusMessageIter variant, array, entry;
+	char typesig[5];
+	char arraysig[6];
+	const void **val_array = *(const void ***) val;
+	int i;
+
+	arraysig[0] = DBUS_TYPE_ARRAY;
+	arraysig[1] = typesig[0] = DBUS_DICT_ENTRY_BEGIN_CHAR;
+	arraysig[2] = typesig[1] = DBUS_TYPE_STRING;
+	arraysig[3] = typesig[2] = type;
+	arraysig[4] = typesig[3] = DBUS_DICT_ENTRY_END_CHAR;
+	arraysig[5] = typesig[4] = '\0';
+
+	dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
+						arraysig, &variant);
+
+	dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY,
+						typesig, &array);
+
+	for (i = 0; val_array[i]; i += 2) {
+		dbus_message_iter_open_container(&array, DBUS_TYPE_DICT_ENTRY,
+							NULL, &entry);
+
+		dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING,
+						&(val_array[i + 0]));
+
+		/*
+		 * D-Bus expects a char** or uint8* depending on the type
+		 * given. Since we are dealing with an array through a void**
+		 * (and thus val_array[i] is a pointer) we need to
+		 * differentiate DBUS_TYPE_STRING from the others. The other
+		 * option would be the user to pass the exact type to this
+		 * function, instead of a pointer to it. However in this case
+		 * a cast from type to void* would be needed, which is not
+		 * good.
+		 */
+		if (type == DBUS_TYPE_STRING) {
+			dbus_message_iter_append_basic(&entry, type,
+							&(val_array[i + 1]));
+		} else {
+			dbus_message_iter_append_basic(&entry, type,
+							val_array[i + 1]);
+		}
+
+		dbus_message_iter_close_container(&array, &entry);
+	}
+
+	dbus_message_iter_close_container(&variant, &array);
+
+	dbus_message_iter_close_container(iter, &variant);
+}
+
+void obex_dbus_dict_append_dict(DBusMessageIter *dict, const char *key,
+				int type, void *val)
+{
+	DBusMessageIter entry;
+
+	dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
+						NULL, &entry);
+
+	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
+
+	append_dict_variant(&entry, type, val);
+
+	dbus_message_iter_close_container(dict, &entry);
+}
+
+int obex_dbus_signal_property_changed(DBusConnection *conn,
+					const char *path,
+					const char *interface,
+					const char *name,
+					int type, void *value)
+{
+	DBusMessage *signal;
+	DBusMessageIter iter;
+
+	signal = dbus_message_new_signal(path, interface, "PropertyChanged");
+	if (signal == NULL) {
+		error("Unable to allocate new %s.PropertyChanged signal",
+				interface);
+		return -1;
+	}
+
+	dbus_message_iter_init_append(signal, &iter);
+
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name);
+
+	append_variant(&iter, type, value);
+
+	return g_dbus_send_message(conn, signal);
+}
+
+int obex_dbus_signal_array_property_changed(DBusConnection *conn,
+						const char *path,
+						const char *interface,
+						const char *name,
+						int type, void *value)
+
+{
+	DBusMessage *signal;
+	DBusMessageIter iter;
+
+	signal = dbus_message_new_signal(path, interface, "PropertyChanged");
+	if (signal == NULL) {
+		error("Unable to allocate new %s.PropertyChanged signal",
+				interface);
+		return -1;
+	}
+
+	dbus_message_iter_init_append(signal, &iter);
+
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name);
+
+	append_array_variant(&iter, type, value);
+
+	return g_dbus_send_message(conn, signal);
+}
+
+int obex_dbus_signal_dict_property_changed(DBusConnection *conn,
+						const char *path,
+						const char *interface,
+						const char *name,
+						int type, void *value)
+
+{
+	DBusMessage *signal;
+	DBusMessageIter iter;
+
+	signal = dbus_message_new_signal(path, interface, "PropertyChanged");
+	if (signal == NULL) {
+		error("Unable to allocate new %s.PropertyChanged signal",
+				interface);
+		return -1;
+	}
+
+	dbus_message_iter_init_append(signal, &iter);
+
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name);
+
+	append_dict_variant(&iter, type, value);
+
+	return g_dbus_send_message(conn, signal);
+}
diff --git a/client/dbus.h b/client/dbus.h
new file mode 100644
index 0000000..d861c1a
--- /dev/null
+++ b/client/dbus.h
@@ -0,0 +1,66 @@
+/*
+ *
+ *  OBEX Client
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 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 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
+ *
+ */
+
+#ifndef __OBEX_DBUS_H
+#define __OBEX_DBUS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <dbus/dbus.h>
+
+/* Essentially a{sv} */
+#define OBC_PROPERTIES_ARRAY_SIGNATURE DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING \
+					DBUS_TYPE_STRING_AS_STRING \
+					DBUS_TYPE_VARIANT_AS_STRING \
+					DBUS_DICT_ENTRY_END_CHAR_AS_STRING
+
+void obex_dbus_dict_append(DBusMessageIter *dict, const char *key, int type,
+				void *value);
+
+void obex_dbus_dict_append_array(DBusMessageIter *dict, const char *key,
+					int type, void *val);
+
+void obex_dbus_dict_append_dict(DBusMessageIter *dict, const char *key,
+					int type, void *val);
+
+int obex_dbus_signal_property_changed(DBusConnection *conn, const char *path,
+					const char *interface, const char *name,
+					int type, void *value);
+
+int obex_dbus_signal_array_property_changed(DBusConnection *conn,
+						const char *path,
+						const char *interface,
+						const char *name, int type,
+						void *value);
+
+int obex_dbus_signal_dict_property_changed(DBusConnection *conn,
+						const char *path,
+						const char *interface,
+						const char *name, int type,
+						void *value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __OBEX_DBUS_H */
diff --git a/client/ftp.c b/client/ftp.c
index 8585566..9b2c51d 100644
--- a/client/ftp.c
+++ b/client/ftp.c
@@ -30,6 +30,7 @@
 
 #include <gdbus.h>
 
+#include "dbus.h"
 #include "log.h"
 
 #include "transfer.h"
@@ -95,39 +96,6 @@ static DBusMessage *change_folder(DBusConnection *connection,
 	return NULL;
 }
 
-static void append_variant(DBusMessageIter *iter, int type, void *val)
-{
-	DBusMessageIter value;
-	char sig[2] = { type, '\0' };
-
-	dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, sig, &value);
-
-	dbus_message_iter_append_basic(&value, type, val);
-
-	dbus_message_iter_close_container(iter, &value);
-}
-
-static void dict_append_entry(DBusMessageIter *dict,
-			const char *key, int type, void *val)
-{
-	DBusMessageIter entry;
-
-	if (type == DBUS_TYPE_STRING) {
-		const char *str = *((const char **) val);
-		if (str == NULL)
-			return;
-	}
-
-	dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
-							NULL, &entry);
-
-	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
-
-	append_variant(&entry, type, val);
-
-	dbus_message_iter_close_container(dict, &entry);
-}
-
 static void xml_element(GMarkupParseContext *ctxt,
 			const gchar *element,
 			const gchar **names,
@@ -147,7 +115,7 @@ static void xml_element(GMarkupParseContext *ctxt,
 			DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
 			DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
 
-	dict_append_entry(&dict, "Type", DBUS_TYPE_STRING, &element);
+	obex_dbus_dict_append(&dict, "Type", DBUS_TYPE_STRING, &element);
 
 	/* FIXME: User, Group, Other permission must be reviewed */
 
@@ -157,9 +125,11 @@ static void xml_element(GMarkupParseContext *ctxt,
 		if (g_str_equal("Size", key) == TRUE) {
 			guint64 size;
 			size = g_ascii_strtoll(values[i], NULL, 10);
-			dict_append_entry(&dict, key, DBUS_TYPE_UINT64, &size);
+			obex_dbus_dict_append(&dict, key, DBUS_TYPE_UINT64,
+								&size);
 		} else
-			dict_append_entry(&dict, key, DBUS_TYPE_STRING, &values[i]);
+			obex_dbus_dict_append(&dict, key, DBUS_TYPE_STRING,
+								&values[i]);
 	}
 
 	dbus_message_iter_close_container(iter, &dict);
diff --git a/client/session.c b/client/session.c
index 1c5e452..94256b4 100644
--- a/client/session.c
+++ b/client/session.c
@@ -37,6 +37,7 @@
 #include <gdbus.h>
 #include <gobex.h>
 
+#include "dbus.h"
 #include "log.h"
 #include "transfer.h"
 #include "session.h"
@@ -582,40 +583,6 @@ static DBusMessage *release_agent(DBusConnection *connection,
 	return dbus_message_new_method_return(message);
 }
 
-static void append_entry(DBusMessageIter *dict,
-				const char *key, int type, void *val)
-{
-	DBusMessageIter entry, value;
-	const char *signature;
-
-	dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
-								NULL, &entry);
-
-	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
-
-	switch (type) {
-	case DBUS_TYPE_STRING:
-		signature = DBUS_TYPE_STRING_AS_STRING;
-		break;
-	case DBUS_TYPE_BYTE:
-		signature = DBUS_TYPE_BYTE_AS_STRING;
-		break;
-	case DBUS_TYPE_UINT64:
-		signature = DBUS_TYPE_UINT64_AS_STRING;
-		break;
-	default:
-		signature = DBUS_TYPE_VARIANT_AS_STRING;
-		break;
-	}
-
-	dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
-							signature, &value);
-	dbus_message_iter_append_basic(&value, type, val);
-	dbus_message_iter_close_container(&entry, &value);
-
-	dbus_message_iter_close_container(dict, &entry);
-}
-
 static DBusMessage *session_get_properties(DBusConnection *connection,
 				DBusMessage *message, void *user_data)
 {
@@ -635,13 +602,14 @@ static DBusMessage *session_get_properties(DBusConnection *connection,
 			DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
 
 	if (session->source != NULL)
-		append_entry(&dict, "Source", DBUS_TYPE_STRING,
+		obex_dbus_dict_append(&dict, "Source", DBUS_TYPE_STRING,
 							&session->source);
 
-	append_entry(&dict, "Destination", DBUS_TYPE_STRING,
+	obex_dbus_dict_append(&dict, "Destination", DBUS_TYPE_STRING,
 							&session->destination);
 
-	append_entry(&dict, "Channel", DBUS_TYPE_BYTE, &session->channel);
+	obex_dbus_dict_append(&dict, "Channel", DBUS_TYPE_BYTE,
+							&session->channel);
 
 	dbus_message_iter_close_container(&iter, &dict);
 
diff --git a/client/transfer.c b/client/transfer.c
index 3065c9c..8292265 100644
--- a/client/transfer.c
+++ b/client/transfer.c
@@ -38,6 +38,7 @@
 #include <gdbus.h>
 #include <gobex.h>
 
+#include "dbus.h"
 #include "log.h"
 #include "transfer.h"
 
@@ -81,40 +82,6 @@ static GQuark obc_transfer_error_quark(void)
 	return g_quark_from_static_string("obc-transfer-error-quark");
 }
 
-static void append_entry(DBusMessageIter *dict,
-				const char *key, int type, void *val)
-{
-	DBusMessageIter entry, value;
-	const char *signature;
-
-	dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
-								NULL, &entry);
-
-	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
-
-	switch (type) {
-	case DBUS_TYPE_STRING:
-		signature = DBUS_TYPE_STRING_AS_STRING;
-		break;
-	case DBUS_TYPE_BYTE:
-		signature = DBUS_TYPE_BYTE_AS_STRING;
-		break;
-	case DBUS_TYPE_UINT64:
-		signature = DBUS_TYPE_UINT64_AS_STRING;
-		break;
-	default:
-		signature = DBUS_TYPE_VARIANT_AS_STRING;
-		break;
-	}
-
-	dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
-							signature, &value);
-	dbus_message_iter_append_basic(&value, type, val);
-	dbus_message_iter_close_container(&entry, &value);
-
-	dbus_message_iter_close_container(dict, &entry);
-}
-
 static DBusMessage *obc_transfer_get_properties(DBusConnection *connection,
 					DBusMessage *message, void *user_data)
 {
@@ -133,9 +100,10 @@ static DBusMessage *obc_transfer_get_properties(DBusConnection *connection,
 			DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
 			DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
 
-	append_entry(&dict, "Name", DBUS_TYPE_STRING, &transfer->name);
-	append_entry(&dict, "Size", DBUS_TYPE_UINT64, &transfer->size);
-	append_entry(&dict, "Filename", DBUS_TYPE_STRING, &transfer->filename);
+	obex_dbus_dict_append(&dict, "Name", DBUS_TYPE_STRING, &transfer->name);
+	obex_dbus_dict_append(&dict, "Size", DBUS_TYPE_UINT64, &transfer->size);
+	obex_dbus_dict_append(&dict, "Filename", DBUS_TYPE_STRING,
+							&transfer->filename);
 
 	dbus_message_iter_close_container(&iter, &dict);
 
-- 
1.7.7.6

[PATCH obexd v0 02/16] client-doc: Add progress property to transfer

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

This property exposes the number of bytes transferred so far in a given
transfer.
---
 doc/client-api.txt |   10 ++++++++++
 1 files changed, 10 insertions(+), 0 deletions(-)

diff --git a/doc/client-api.txt b/doc/client-api.txt
index cfb4ec9..cc25543 100644
--- a/doc/client-api.txt
+++ b/doc/client-api.txt
@@ -312,6 +312,16 @@ Properties	string Name [readonly]
 
 			Complete name of the file being received or sent.
 
+		uint64 Progress [readonly, optional]
+
+			Number of bytes transferred. For queued transfers, this
+			value will not be present.
+
+Signals		PropertyChanged(string name, variant value)
+
+			This signal indicates a changed value of the given
+			property.
+
 Agent hierarchy
 ===============
 
-- 
1.7.7.6

[PATCH obexd v0 03/16] client: Add progress property to transfer

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

The number of transferred bytes is exposed in D-Bus using a specific
property for this purpose.

Internally, the value of this property does not necessarily match the
internal progress counter. In order to avoid D-Bus overhead, the
property will be updated at least every N bytes, where N is fixed and
hardcoded (TRANSFER_PROGRESS_PERIOD).
---
 client/transfer.c |   47 +++++++++++++++++++++++++++++++++++++++++++++--
 1 files changed, 45 insertions(+), 2 deletions(-)

diff --git a/client/transfer.c b/client/transfer.c
index 8292265..2c6e1ed 100644
--- a/client/transfer.c
+++ b/client/transfer.c
@@ -44,6 +44,7 @@
 
 #define TRANSFER_INTERFACE  "org.openobex.Transfer"
 #define TRANSFER_BASEPATH   "/org/openobex"
+#define TRANSFER_PROGRESS_PERIOD (16 * 1024)
 
 #define OBC_TRANSFER_ERROR obc_transfer_error_quark()
 
@@ -75,6 +76,7 @@ struct obc_transfer {
 	guint xfer;
 	gint64 size;
 	gint64 transferred;
+	gint64 transferred_dbus;
 };
 
 static GQuark obc_transfer_error_quark(void)
@@ -105,6 +107,10 @@ static DBusMessage *obc_transfer_get_properties(DBusConnection *connection,
 	obex_dbus_dict_append(&dict, "Filename", DBUS_TYPE_STRING,
 							&transfer->filename);
 
+	if (transfer->obex != NULL)
+		obex_dbus_dict_append(&dict, "Progress", DBUS_TYPE_UINT64,
+						&transfer->transferred_dbus);
+
 	dbus_message_iter_close_container(&iter, &dict);
 
 	return reply;
@@ -182,6 +188,12 @@ static const GDBusMethodTable obc_transfer_methods[] = {
 	{ }
 };
 
+static const GDBusSignalTable obc_transfer_signals[] = {
+	{ GDBUS_SIGNAL("PropertyChanged",
+		GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
+	{ }
+};
+
 static void obc_transfer_free(struct obc_transfer *transfer)
 {
 	DBG("%p", transfer);
@@ -260,8 +272,8 @@ gboolean obc_transfer_register(struct obc_transfer *transfer,
 
 	if (g_dbus_register_interface(transfer->conn, transfer->path,
 				TRANSFER_INTERFACE,
-				obc_transfer_methods, NULL, NULL,
-				transfer, NULL) == FALSE) {
+				obc_transfer_methods, obc_transfer_signals,
+				NULL, transfer, NULL) == FALSE) {
 		g_set_error(err, OBC_TRANSFER_ERROR, -EFAULT,
 						"Unable to register to D-Bus");
 		return FALSE;
@@ -380,6 +392,33 @@ void obc_transfer_unregister(struct obc_transfer *transfer)
 	obc_transfer_free(transfer);
 }
 
+static void transfer_notify_progress(struct obc_transfer *transfer)
+{
+	gint64 notify;
+
+	DBG("Transfer %p progress: %lu bytes", transfer, transfer->transferred);
+
+	if (transfer->path == NULL)
+		return;
+
+	if (transfer->transferred == transfer->transferred_dbus)
+		return;
+
+	notify = transfer->transferred_dbus + TRANSFER_PROGRESS_PERIOD;
+
+	if ((transfer->transferred != transfer->size) &&
+					(transfer->transferred < notify))
+		return;
+
+	transfer->transferred_dbus = transfer->transferred;
+
+	obex_dbus_signal_property_changed(transfer->conn,
+						transfer->path,
+						TRANSFER_INTERFACE, "Progress",
+						DBUS_TYPE_INT64,
+						&transfer->transferred_dbus);
+}
+
 static gboolean get_xfer_progress(const void *buf, gsize len,
 							gpointer user_data)
 {
@@ -400,6 +439,8 @@ static gboolean get_xfer_progress(const void *buf, gsize len,
 		callback->func(transfer, transfer->transferred, NULL,
 							callback->data);
 
+	transfer_notify_progress(transfer);
+
 	return TRUE;
 }
 
@@ -497,6 +538,8 @@ static gssize put_xfer_progress(void *buf, gsize len, gpointer user_data)
 
 	transfer->transferred += size;
 
+	transfer_notify_progress(transfer);
+
 	return size;
 }
 
-- 
1.7.7.6

[PATCH obexd v0 04/16] client-doc: Add transfer event-reporting signals

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

These signals replace the old agent-based notification mechanism.
---
 doc/client-api.txt |    9 +++++++++
 1 files changed, 9 insertions(+), 0 deletions(-)

diff --git a/doc/client-api.txt b/doc/client-api.txt
index cc25543..527df05 100644
--- a/doc/client-api.txt
+++ b/doc/client-api.txt
@@ -322,6 +322,15 @@ Signals		PropertyChanged(string name, variant value)
 			This signal indicates a changed value of the given
 			property.
 
+		void Complete()
+
+			Informs that the transfer has completed successfully.
+
+		void Error(string message)
+
+			Informs that the transfer has been terminated because
+			of some error.
+
 Agent hierarchy
 ===============
 
-- 
1.7.7.6

[PATCH obexd v0 05/16] client: Add transfer event-reporting signals

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

These signals replace the old agent-based notification mechanism.
---
 client/transfer.c |   18 ++++++++++++++----
 1 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/client/transfer.c b/client/transfer.c
index 2c6e1ed..09abe50 100644
--- a/client/transfer.c
+++ b/client/transfer.c
@@ -191,6 +191,8 @@ static const GDBusMethodTable obc_transfer_methods[] = {
 static const GDBusSignalTable obc_transfer_signals[] = {
 	{ GDBUS_SIGNAL("PropertyChanged",
 		GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
+	{ GDBUS_SIGNAL("Complete", NULL) },
+	{ GDBUS_SIGNAL("Error", GDBUS_ARGS({ "message", "s" })) },
 	{ }
 };
 
@@ -451,12 +453,20 @@ static void xfer_complete(GObex *obex, GError *err, gpointer user_data)
 
 	transfer->xfer = 0;
 
-	if (err)
-		goto done;
+	if (err == NULL) {
+		transfer->size = transfer->transferred;
 
-	transfer->size = transfer->transferred;
+		if (transfer->path != NULL)
+			g_dbus_emit_signal(transfer->conn, transfer->path,
+						TRANSFER_INTERFACE, "Complete",
+						DBUS_TYPE_INVALID);
+	} else if (transfer->path != NULL)
+		g_dbus_emit_signal(transfer->conn, transfer->path,
+						TRANSFER_INTERFACE, "Error",
+						DBUS_TYPE_STRING,
+						&err->message,
+						DBUS_TYPE_INVALID);
 
-done:
 	if (callback)
 		callback->func(transfer, transfer->size, err, callback->data);
 }
-- 
1.7.7.6

[PATCH obexd v0 06/16] client-doc: Remove D-Bus agent

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

The request confirmation from the agent is not really useful and the
rest of the reporting is already reported by the transfer's signal-
reporting.

The main benefit of this is that the API is simpler and the client apps
do not have to register the agent, and can just listen to the relevant
signals.
---
 doc/client-api.txt |   52 ----------------------------------------------------
 1 files changed, 0 insertions(+), 52 deletions(-)

diff --git a/doc/client-api.txt b/doc/client-api.txt
index 527df05..656c492 100644
--- a/doc/client-api.txt
+++ b/doc/client-api.txt
@@ -46,15 +46,6 @@ Methods		dict GetProperties()
 
 			Returns all properties for the session.
 
-		void AssignAgent(object agent)
-
-			Assign an OBEX agent to this session. This allows
-			detailed progress reports about the transactions.
-
-		void ReleaseAgent(object agent)
-
-			Release a previously assigned OBEX agent.
-
 		string GetCapabilities()
 
 			Get remote device capabilities.
@@ -330,46 +321,3 @@ Signals		PropertyChanged(string name, variant value)
 
 			Informs that the transfer has been terminated because
 			of some error.
-
-Agent hierarchy
-===============
-
-Service		unique name
-Interface	org.openobex.Agent
-Object path	freely definable
-
-Methods		void Release()
-
-			This method gets called when the service daemon
-			unregisters the agent. An agent can use it to do
-			cleanup tasks. There is no need to unregister the
-			agent, because when this method gets called it has
-			already been unregistered.
-
-		string Request(object transfer)
-
-			Accept or reject a new transfer (client and server)
-			and provide the filename for it.
-
-			In case of incoming transfers it is the filename
-			where to store the file and for outgoing transfers
-			it is the filename to show the remote device. If left
-			empty it will be calculated automatically.
-
-			Possible errors: org.openobex.Error.Rejected
-					 org.openobex.Error.Canceled
-
-		void Progress(object transfer, uint64 transferred)
-
-			Progress within the transfer has been made. The
-			number of transferred bytes is given as second
-			argument for convenience.
-
-		void Complete(object transfer)
-
-			Informs that the transfer has completed successfully.
-
-		void Error(object transfer, string message)
-
-			Informs that the transfer has been terminated because
-			of some error.
-- 
1.7.7.6

[PATCH obexd v0 07/16] client: Use transfer owner instead of agent

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

The security checks in the transfers' D-Bus API will consider check for
the transfer owner's path (session owner) instead of the agent path.
---
 client/session.c  |    9 ++-------
 client/transfer.c |   10 +++++-----
 client/transfer.h |    2 +-
 3 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/client/session.c b/client/session.c
index 94256b4..9c4c9f0 100644
--- a/client/session.c
+++ b/client/session.c
@@ -793,7 +793,6 @@ guint obc_session_queue(struct obc_session *session,
 				GError **err)
 {
 	struct pending_request *p;
-	const char *agent;
 	int perr;
 
 	if (session->obex == NULL) {
@@ -803,12 +802,8 @@ guint obc_session_queue(struct obc_session *session,
 		return 0;
 	}
 
-	if (session->agent)
-		agent = obc_agent_get_name(session->agent);
-	else
-		agent = NULL;
-
-	if (!obc_transfer_register(transfer, session->conn, agent, err)) {
+	if (!obc_transfer_register(transfer, session->conn, session->owner,
+									err)) {
 		obc_transfer_unregister(transfer);
 		return 0;
 	}
diff --git a/client/transfer.c b/client/transfer.c
index 09abe50..e6e9d46 100644
--- a/client/transfer.c
+++ b/client/transfer.c
@@ -67,7 +67,7 @@ struct obc_transfer {
 	struct transfer_callback *callback;
 	DBusConnection *conn;
 	DBusMessage *msg;
-	char *agent;		/* Transfer agent */
+	char *owner;		/* Transfer initiator */
 	char *path;		/* Transfer path */
 	gchar *filename;	/* Transfer file location */
 	char *name;		/* Transfer object name */
@@ -164,7 +164,7 @@ static DBusMessage *obc_transfer_cancel(DBusConnection *connection,
 	const gchar *sender;
 
 	sender = dbus_message_get_sender(message);
-	if (g_strcmp0(transfer->agent, sender) != 0)
+	if (g_strcmp0(transfer->owner, sender) != 0)
 		return g_dbus_create_error(message,
 				"org.openobex.Error.NotAuthorized",
 				"Not Authorized");
@@ -225,7 +225,7 @@ static void obc_transfer_free(struct obc_transfer *transfer)
 		g_obex_unref(transfer->obex);
 
 	g_free(transfer->callback);
-	g_free(transfer->agent);
+	g_free(transfer->owner);
 	g_free(transfer->filename);
 	g_free(transfer->name);
 	g_free(transfer->type);
@@ -251,7 +251,7 @@ static struct obc_transfer *obc_transfer_create(guint8 op,
 
 gboolean obc_transfer_register(struct obc_transfer *transfer,
 						DBusConnection *conn,
-						const char *agent,
+						const char *owner,
 						GError **err)
 {
 	/* for OBEX specific mime types we don't need to register a transfer */
@@ -260,7 +260,7 @@ gboolean obc_transfer_register(struct obc_transfer *transfer,
 			strncmp(transfer->type, "x-bt/", 5) == 0))
 		goto done;
 
-	transfer->agent = g_strdup(agent);
+	transfer->owner = g_strdup(owner);
 
 	transfer->path = g_strdup_printf("%s/transfer%ju",
 			TRANSFER_BASEPATH, counter++);
diff --git a/client/transfer.h b/client/transfer.h
index bf40a4c..a65a2ed 100644
--- a/client/transfer.h
+++ b/client/transfer.h
@@ -36,7 +36,7 @@ struct obc_transfer *obc_transfer_put(const char *type, const char *name,
 
 gboolean obc_transfer_register(struct obc_transfer *transfer,
 					DBusConnection *conn,
-					const char *agent,
+					const char *owner,
 					GError **err);
 
 void obc_transfer_unregister(struct obc_transfer *transfer);
-- 
1.7.7.6

[PATCH obexd v0 08/16] client: Remove D-Bus agent

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

The authorization mechanism is entirely removed from the session, and
thus transfers are automatically started (once popped from the queue)
without confirmation and without any name/filename change.
---
 Makefile.am      |    1 -
 client/agent.c   |  252 ------------------------------------------------------
 client/agent.h   |   43 ---------
 client/session.c |  218 +----------------------------------------------
 client/session.h |    4 -
 5 files changed, 2 insertions(+), 516 deletions(-)
 delete mode 100644 client/agent.c
 delete mode 100644 client/agent.h

diff --git a/Makefile.am b/Makefile.am
index 86f9ad1..5cc0603 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -124,7 +124,6 @@ client_obex_client_SOURCES = $(gdbus_sources) $(gobex_sources) \
 				client/opp.h client/opp.c \
 				client/map.h client/map.c \
 				client/transfer.h client/transfer.c \
-				client/agent.h client/agent.c \
 				client/transport.h client/transport.c \
 				client/dbus.h client/dbus.c \
 				client/driver.h client/driver.c \
diff --git a/client/agent.c b/client/agent.c
deleted file mode 100644
index 929a05f..0000000
--- a/client/agent.c
+++ /dev/null
@@ -1,252 +0,0 @@
-/*
- *
- *  OBEX Client
- *
- *  Copyright (C) 2007-2010  Marcel Holtmann <marcel@holtmann.org>
- *
- *
- *  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 <errno.h>
-
-#include "log.h"
-#include "agent.h"
-
-#define AGENT_INTERFACE  "org.openobex.Agent"
-
-struct pending_request {
-	DBusPendingCall *call;
-	DBusPendingCallNotifyFunction function;
-	void *data;
-	DBusFreeFunction destroy;
-};
-
-struct obc_agent {
-	DBusConnection *conn;
-	char *name;
-	char *path;
-	guint watch;
-	GFunc destroy;
-	void *data;
-	struct pending_request *pending;
-};
-
-static void pending_request_free(struct pending_request *req)
-{
-	if (req->call)
-		dbus_pending_call_unref(req->call);
-
-	if (req->destroy)
-		req->destroy(req->data);
-
-	g_free(req);
-}
-
-void obc_agent_free(struct obc_agent *agent)
-{
-	if (agent->watch)
-		g_dbus_remove_watch(agent->conn, agent->watch);
-
-	if (agent->pending) {
-		if (agent->pending->call)
-			dbus_pending_call_cancel(agent->pending->call);
-		pending_request_free(agent->pending);
-	}
-
-	dbus_connection_unref(agent->conn);
-	g_free(agent->name);
-	g_free(agent->path);
-	g_free(agent);
-}
-
-static void agent_disconnected(DBusConnection *connection, void *user_data)
-{
-	struct obc_agent *agent = user_data;
-
-	agent->watch = 0;
-
-	if (agent->destroy)
-		agent->destroy(agent, agent->data);
-
-	obc_agent_free(agent);
-}
-
-struct obc_agent *obc_agent_create(DBusConnection *conn, const char *name,
-					const char *path, GFunc destroy,
-					void *user_data)
-{
-	struct obc_agent *agent;
-
-	agent = g_new0(struct obc_agent, 1);
-	agent->conn = dbus_connection_ref(conn);
-	agent->name = g_strdup(name);
-	agent->path = g_strdup(path);
-	agent->destroy = destroy;
-	agent->data = user_data;
-
-	agent->watch = g_dbus_add_disconnect_watch(conn, name,
-							agent_disconnected,
-							agent, NULL);
-
-	return agent;
-}
-
-static void agent_request_reply(DBusPendingCall *call, void *user_data)
-{
-	struct obc_agent *agent = user_data;
-	struct pending_request *req = agent->pending;
-
-	agent->pending = NULL;
-
-	if (req->function)
-		req->function(call, req->data);
-
-	pending_request_free(req);
-}
-
-int obc_agent_request(struct obc_agent *agent, const char *path,
-				DBusPendingCallNotifyFunction function,
-				void *user_data, DBusFreeFunction destroy)
-{
-	struct pending_request *req;
-	DBusMessage *message;
-
-	if (agent->pending)
-		return -EBUSY;
-
-	DBG("%s", path);
-
-	message = dbus_message_new_method_call(agent->name,
-			agent->path, AGENT_INTERFACE, "Request");
-
-	dbus_message_append_args(message,
-			DBUS_TYPE_OBJECT_PATH, &path,
-			DBUS_TYPE_INVALID);
-
-	req = g_new0(struct pending_request, 1);
-	req->function = function;
-	req->destroy = destroy;
-	req->data = user_data;
-
-	if (!dbus_connection_send_with_reply(agent->conn, message,
-						&req->call, -1)) {
-		g_free(req);
-		dbus_message_unref(message);
-		return -ENOMEM;
-	}
-
-	agent->pending = req;
-
-	dbus_message_unref(message);
-
-	dbus_pending_call_set_notify(req->call, agent_request_reply,
-					agent, NULL);
-
-	return 0;
-}
-
-void obc_agent_notify_progress(struct obc_agent *agent, const char *path,
-							guint64 transferred)
-{
-	DBusMessage *message;
-
-	DBG("%s", path);
-
-	message = dbus_message_new_method_call(agent->name,
-			agent->path, AGENT_INTERFACE, "Progress");
-	if (message == NULL)
-		return;
-
-	dbus_message_set_no_reply(message, TRUE);
-
-	dbus_message_append_args(message,
-			DBUS_TYPE_OBJECT_PATH, &path,
-			DBUS_TYPE_UINT64, &transferred,
-			DBUS_TYPE_INVALID);
-
-	g_dbus_send_message(agent->conn, message);
-}
-
-void obc_agent_notify_complete(struct obc_agent *agent, const char *path)
-{
-	DBusMessage *message;
-
-	DBG("%s", path);
-
-	message = dbus_message_new_method_call(agent->name,
-			agent->path, AGENT_INTERFACE, "Complete");
-	if (message == NULL)
-		return;
-
-	dbus_message_set_no_reply(message, TRUE);
-
-	dbus_message_append_args(message,
-			DBUS_TYPE_OBJECT_PATH, &path,
-			DBUS_TYPE_INVALID);
-
-	g_dbus_send_message(agent->conn, message);
-}
-
-void obc_agent_notify_error(struct obc_agent *agent, const char *path,
-							const char *err)
-{
-	DBusMessage *message;
-
-	DBG("%s", path);
-
-	message = dbus_message_new_method_call(agent->name,
-			agent->path, AGENT_INTERFACE, "Error");
-	if (message == NULL)
-		return;
-
-	dbus_message_set_no_reply(message, TRUE);
-
-	dbus_message_append_args(message,
-			DBUS_TYPE_OBJECT_PATH, &path,
-			DBUS_TYPE_STRING, &err,
-			DBUS_TYPE_INVALID);
-
-	g_dbus_send_message(agent->conn, message);
-}
-
-void obc_agent_release(struct obc_agent *agent)
-{
-	DBusMessage *message;
-
-	DBG("");
-
-	message = dbus_message_new_method_call(agent->name,
-			agent->path, AGENT_INTERFACE, "Release");
-
-	dbus_message_set_no_reply(message, TRUE);
-
-	g_dbus_send_message(agent->conn, message);
-}
-
-const char *obc_agent_get_name(struct obc_agent *agent)
-{
-	return agent->name;
-}
-
-const char *obc_agent_get_path(struct obc_agent *agent)
-{
-	return agent->path;
-}
diff --git a/client/agent.h b/client/agent.h
deleted file mode 100644
index 69f2ffe..0000000
--- a/client/agent.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- *
- *  OBEX Client
- *
- *  Copyright (C) 2007-2010  Intel Corporation
- *  Copyright (C) 2007-2010  Marcel Holtmann <marcel@holtmann.org>
- *
- *
- *  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
- *
- */
-
-#include <gdbus.h>
-
-struct obc_agent;
-
-struct obc_agent *obc_agent_create(DBusConnection *conn, const char *name,
-					const char *path, GFunc destroy,
-					void *user_data);
-void obc_agent_free(struct obc_agent *agent);
-const char *obc_agent_get_name(struct obc_agent *agent);
-const char *obc_agent_get_path(struct obc_agent *agent);
-int obc_agent_request(struct obc_agent *agent, const char *path,
-				DBusPendingCallNotifyFunction function,
-				void *user_data, DBusFreeFunction destroy);
-void obc_agent_notify_progress(struct obc_agent *agent, const char *path,
-							guint64 transferred);
-void obc_agent_notify_complete(struct obc_agent *agent, const char *path);
-void obc_agent_notify_error(struct obc_agent *agent, const char *path,
-							const char *err);
-void obc_agent_release(struct obc_agent *agent);
diff --git a/client/session.c b/client/session.c
index 9c4c9f0..989439c 100644
--- a/client/session.c
+++ b/client/session.c
@@ -41,7 +41,6 @@
 #include "log.h"
 #include "transfer.h"
 #include "session.h"
-#include "agent.h"
 #include "driver.h"
 #include "transport.h"
 
@@ -92,7 +91,6 @@ struct obc_session {
 	gchar *path;		/* Session path */
 	DBusConnection *conn;
 	GObex *obex;
-	struct obc_agent *agent;
 	struct pending_request *p;
 	gchar *owner;		/* Session owner */
 	guint watch;
@@ -175,11 +173,6 @@ static void session_free(struct obc_session *session)
 {
 	DBG("%p", session);
 
-	if (session->agent) {
-		obc_agent_release(session->agent);
-		obc_agent_free(session->agent);
-	}
-
 	if (session->queue) {
 		g_queue_foreach(session->queue, (GFunc) pending_request_free,
 									NULL);
@@ -529,60 +522,6 @@ void obc_session_shutdown(struct obc_session *session)
 	obc_session_unref(session);
 }
 
-static DBusMessage *assign_agent(DBusConnection *connection,
-				DBusMessage *message, void *user_data)
-{
-	struct obc_session *session = user_data;
-	const gchar *sender, *path;
-
-	if (dbus_message_get_args(message, NULL,
-					DBUS_TYPE_OBJECT_PATH, &path,
-					DBUS_TYPE_INVALID) == FALSE)
-		return g_dbus_create_error(message,
-				"org.openobex.Error.InvalidArguments",
-				"Invalid arguments in method call");
-
-	sender = dbus_message_get_sender(message);
-
-	if (obc_session_set_agent(session, sender, path) < 0)
-		return g_dbus_create_error(message,
-				"org.openobex.Error.AlreadyExists",
-				"Already exists");
-
-	return dbus_message_new_method_return(message);
-}
-
-static DBusMessage *release_agent(DBusConnection *connection,
-				DBusMessage *message, void *user_data)
-{
-	struct obc_session *session = user_data;
-	struct obc_agent *agent = session->agent;
-	const gchar *sender;
-	gchar *path;
-
-	if (dbus_message_get_args(message, NULL,
-					DBUS_TYPE_OBJECT_PATH, &path,
-					DBUS_TYPE_INVALID) == FALSE)
-		return g_dbus_create_error(message,
-				"org.openobex.Error.InvalidArguments",
-				"Invalid arguments in method call");
-
-	sender = dbus_message_get_sender(message);
-
-	if (agent == NULL)
-		return dbus_message_new_method_return(message);
-
-	if (g_str_equal(sender, obc_agent_get_name(agent)) == FALSE ||
-			g_str_equal(path, obc_agent_get_path(agent)) == FALSE)
-		return g_dbus_create_error(message,
-				"org.openobex.Error.NotAuthorized",
-				"Not Authorized");
-
-	obc_agent_free(agent);
-
-	return dbus_message_new_method_return(message);
-}
-
 static DBusMessage *session_get_properties(DBusConnection *connection,
 				DBusMessage *message, void *user_data)
 {
@@ -685,79 +624,12 @@ static const GDBusMethodTable session_methods[] = {
 	{ GDBUS_METHOD("GetProperties",
 				NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
 				session_get_properties) },
-	{ GDBUS_METHOD("AssignAgent",
-				GDBUS_ARGS({ "agent", "o" }), NULL,
-				assign_agent) },
-	{ GDBUS_METHOD("ReleaseAgent",
-				GDBUS_ARGS({ "agent", "o" }), NULL,
-				release_agent) },
 	{ GDBUS_ASYNC_METHOD("GetCapabilities",
 				NULL, GDBUS_ARGS({ "capabilities", "s" }),
 				get_capabilities) },
 	{ }
 };
 
-static void session_request_reply(DBusPendingCall *call, gpointer user_data)
-{
-	struct obc_session *session = user_data;
-	struct pending_request *p = session->p;
-	struct obc_transfer *transfer = p->transfer;
-	DBusMessage *reply = dbus_pending_call_steal_reply(call);
-	const char *name;
-	DBusError derr;
-	int err;
-
-	dbus_error_init(&derr);
-	if (dbus_set_error_from_message(&derr, reply)) {
-		GError *gerr = NULL;
-
-		error("Replied with an error: %s, %s",
-				derr.name, derr.message);
-		dbus_error_free(&derr);
-		dbus_message_unref(reply);
-
-		g_set_error(&gerr, OBEX_IO_ERROR, -ECANCELED, "%s",
-								derr.message);
-		session_terminate_transfer(session, transfer, gerr);
-		g_clear_error(&gerr);
-
-		return;
-	}
-
-	dbus_message_get_args(reply, NULL,
-			DBUS_TYPE_STRING, &name,
-			DBUS_TYPE_INVALID);
-
-	DBG("Agent.Request() reply: %s", name);
-
-	if (strlen(name) == 0)
-		goto done;
-
-	if (obc_transfer_get_operation(transfer) == G_OBEX_OP_PUT) {
-		obc_transfer_set_name(transfer, name);
-		goto done;
-	}
-
-	err = obc_transfer_set_filename(transfer, name);
-	if (err < 0) {
-		GError *gerr = NULL;
-
-		g_set_error(&gerr, OBEX_IO_ERROR, err,
-						"Unable to set filename");
-		session_terminate_transfer(session, transfer, gerr);
-		g_clear_error(&gerr);
-		return;
-	}
-
-done:
-	if (p->auth_complete)
-		p->auth_complete(session, transfer);
-
-	dbus_message_unref(reply);
-
-	return;
-}
-
 static gboolean session_request_proceed(gpointer data)
 {
 	struct obc_session *session = data;
@@ -772,19 +644,8 @@ static gboolean session_request_proceed(gpointer data)
 
 static int pending_request_auth(struct pending_request *p)
 {
-	struct obc_session *session = p->session;
-	struct obc_agent *agent = session->agent;
-	const char *path;
-
-	path = obc_transfer_get_path(p->transfer);
-
-	if (agent == NULL || path == NULL) {
-		g_idle_add(session_request_proceed, session);
-		return 0;
-	}
-
-	return obc_agent_request(agent, path, session_request_reply, session,
-									NULL);
+	g_idle_add(session_request_proceed, p->session);
+	return 0;
 }
 
 guint obc_session_queue(struct obc_session *session,
@@ -911,18 +772,6 @@ static void session_terminate_transfer(struct obc_session *session,
 static void session_notify_complete(struct obc_session *session,
 				struct obc_transfer *transfer)
 {
-	struct obc_agent *agent = session->agent;
-	const char *path;
-
-	path = obc_transfer_get_path(transfer);
-
-	if (agent == NULL || path == NULL)
-		goto done;
-
-	obc_agent_notify_complete(agent, path);
-
-done:
-
 	DBG("Transfer(%p) complete", transfer);
 
 	session_terminate_transfer(session, transfer, NULL);
@@ -932,16 +781,6 @@ static void session_notify_error(struct obc_session *session,
 				struct obc_transfer *transfer,
 				GError *err)
 {
-	struct obc_agent *agent = session->agent;
-	const char *path;
-
-	path = obc_transfer_get_path(transfer);
-	if (agent == NULL || path == NULL)
-		goto done;
-
-	obc_agent_notify_error(agent, path, err->message);
-
-done:
 	error("Transfer(%p) Error: %s", transfer, err->message);
 
 	session_terminate_transfer(session, transfer, err);
@@ -951,16 +790,6 @@ static void session_notify_progress(struct obc_session *session,
 					struct obc_transfer *transfer,
 					gint64 transferred)
 {
-	struct obc_agent *agent = session->agent;
-	const char *path;
-
-	path = obc_transfer_get_path(transfer);
-	if (agent == NULL || path == NULL)
-		goto done;
-
-	obc_agent_notify_progress(agent, path, transferred);
-
-done:
 	DBG("Transfer(%p) progress: %ld bytes", transfer,
 			(long int ) transferred);
 
@@ -1030,49 +859,6 @@ fail:
 	return NULL;
 }
 
-static void agent_destroy(gpointer data, gpointer user_data)
-{
-	struct obc_session *session = user_data;
-
-	session->agent = NULL;
-}
-
-int obc_session_set_agent(struct obc_session *session, const char *name,
-							const char *path)
-{
-	struct obc_agent *agent;
-
-	if (session == NULL)
-		return -EINVAL;
-
-	if (session->agent)
-		return -EALREADY;
-
-	agent = obc_agent_create(session->conn, name, path, agent_destroy,
-								session);
-
-	if (session->watch == 0)
-		obc_session_set_owner(session, name, owner_disconnected);
-
-	session->agent = agent;
-
-	return 0;
-}
-
-const char *obc_session_get_agent(struct obc_session *session)
-{
-	struct obc_agent *agent;
-
-	if (session == NULL)
-		return NULL;
-
-	agent = session->agent;
-	if (agent == NULL)
-		return NULL;
-
-	return obc_agent_get_name(session->agent);
-}
-
 const char *obc_session_get_owner(struct obc_session *session)
 {
 	if (session == NULL)
diff --git a/client/session.h b/client/session.h
index 2cac032..7f37d29 100644
--- a/client/session.h
+++ b/client/session.h
@@ -47,10 +47,6 @@ int obc_session_set_owner(struct obc_session *session, const char *name,
 			GDBusWatchFunction func);
 const char *obc_session_get_owner(struct obc_session *session);
 
-int obc_session_set_agent(struct obc_session *session, const char *name,
-							const char *path);
-const char *obc_session_get_agent(struct obc_session *session);
-
 const char *obc_session_get_path(struct obc_session *session);
 const char *obc_session_get_target(struct obc_session *session);
 
-- 
1.7.7.6

[PATCH obexd v0 09/16] client: Remove unused functions in transfer API

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

After the removal of the agent these functions are not useful any more.
---
 client/transfer.c |   23 -----------------------
 client/transfer.h |    3 ---
 2 files changed, 0 insertions(+), 26 deletions(-)

diff --git a/client/transfer.c b/client/transfer.c
index e6e9d46..cf7a860 100644
--- a/client/transfer.c
+++ b/client/transfer.c
@@ -726,29 +726,6 @@ int obc_transfer_get_contents(struct obc_transfer *transfer, char **contents,
 	return 0;
 }
 
-void obc_transfer_set_name(struct obc_transfer *transfer, const char *name)
-{
-	g_free(transfer->name);
-	transfer->name = g_strdup(name);
-}
-
-int obc_transfer_set_filename(struct obc_transfer *transfer,
-					const char *filename)
-{
-	int err;
-
-	err = rename(transfer->filename, filename);
-	if (err < 0) {
-		error("rename(): %s (%d)", strerror(errno), errno);
-		return -errno;
-	}
-
-	g_free(transfer->filename);
-	transfer->filename = g_strdup(filename);
-
-	return 0;
-}
-
 const char *obc_transfer_get_path(struct obc_transfer *transfer)
 {
 	return transfer->path;
diff --git a/client/transfer.h b/client/transfer.h
index a65a2ed..bfa166d 100644
--- a/client/transfer.h
+++ b/client/transfer.h
@@ -56,8 +56,5 @@ const void *obc_transfer_get_params(struct obc_transfer *transfer,
 int obc_transfer_get_contents(struct obc_transfer *transfer, char **contents,
 								size_t *size);
 
-void obc_transfer_set_name(struct obc_transfer *transfer, const char *name);
-int obc_transfer_set_filename(struct obc_transfer *transfer,
-					const char *filename);
 const char *obc_transfer_get_path(struct obc_transfer *transfer);
 gint64 obc_transfer_get_size(struct obc_transfer *transfer);
-- 
1.7.7.6

[PATCH obexd v0 10/16] client: Remove internal transfer progress report

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

The new D-Bus API uses signals to report the progress updates, so the
internal progress callback is not needed any more.
---
 client/session.c  |   25 ++++++-------------------
 client/transfer.c |   18 +++---------------
 client/transfer.h |    3 +--
 3 files changed, 10 insertions(+), 36 deletions(-)

diff --git a/client/session.c b/client/session.c
index 989439c..8e21da4 100644
--- a/client/session.c
+++ b/client/session.c
@@ -103,9 +103,8 @@ static void session_start_transfer(gpointer data, gpointer user_data);
 static void session_terminate_transfer(struct obc_session *session,
 					struct obc_transfer *transfer,
 					GError *gerr);
-static void transfer_progress(struct obc_transfer *transfer,
-					gint64 transferred, GError *err,
-					void *user_data);
+static void transfer_complete(struct obc_transfer *transfer,
+					GError *err, void *user_data);
 
 static GQuark obex_io_error_quark(void)
 {
@@ -669,7 +668,7 @@ guint obc_session_queue(struct obc_session *session,
 		return 0;
 	}
 
-	obc_transfer_set_callback(transfer, transfer_progress, session);
+	obc_transfer_set_callback(transfer, transfer_complete, session);
 
 	p = pending_request_new(session, transfer, session_start_transfer,
 							func, user_data);
@@ -786,27 +785,15 @@ static void session_notify_error(struct obc_session *session,
 	session_terminate_transfer(session, transfer, err);
 }
 
-static void session_notify_progress(struct obc_session *session,
-					struct obc_transfer *transfer,
-					gint64 transferred)
-{
-	DBG("Transfer(%p) progress: %ld bytes", transfer,
-			(long int ) transferred);
-
-	if (transferred == obc_transfer_get_size(transfer))
-		session_notify_complete(session, transfer);
-}
-
-static void transfer_progress(struct obc_transfer *transfer,
-					gint64 transferred, GError *err,
-					void *user_data)
+static void transfer_complete(struct obc_transfer *transfer,
+					GError *err, void *user_data)
 {
 	struct obc_session *session = user_data;
 
 	if (err != 0)
 		goto fail;
 
-	session_notify_progress(session, transfer, transferred);
+	session_notify_complete(session, transfer);
 
 	return;
 
diff --git a/client/transfer.c b/client/transfer.c
index cf7a860..b6b4b9c 100644
--- a/client/transfer.c
+++ b/client/transfer.c
@@ -135,15 +135,13 @@ static void abort_complete(GObex *obex, GError *err, gpointer user_data)
 		return;
 
 	if (err) {
-		callback->func(transfer, transfer->transferred, err,
-							callback->data);
+		callback->func(transfer, err, callback->data);
 	} else {
 		GError *abort_err;
 
 		abort_err = g_error_new(OBC_TRANSFER_ERROR, -ECANCELED, "%s",
 						"Transfer cancelled by user");
-		callback->func(transfer, transfer->transferred, abort_err,
-							callback->data);
+		callback->func(transfer, abort_err, callback->data);
 		g_error_free(abort_err);
 	}
 }
@@ -425,7 +423,6 @@ static gboolean get_xfer_progress(const void *buf, gsize len,
 							gpointer user_data)
 {
 	struct obc_transfer *transfer = user_data;
-	struct transfer_callback *callback = transfer->callback;
 
 	if (transfer->fd > 0) {
 		gint w;
@@ -437,10 +434,6 @@ static gboolean get_xfer_progress(const void *buf, gsize len,
 		transfer->transferred += w;
 	}
 
-	if (callback && transfer->transferred != transfer->size)
-		callback->func(transfer, transfer->transferred, NULL,
-							callback->data);
-
 	transfer_notify_progress(transfer);
 
 	return TRUE;
@@ -468,7 +461,7 @@ static void xfer_complete(GObex *obex, GError *err, gpointer user_data)
 						DBUS_TYPE_INVALID);
 
 	if (callback)
-		callback->func(transfer, transfer->size, err, callback->data);
+		callback->func(transfer, err, callback->data);
 }
 
 static void get_xfer_progress_first(GObex *obex, GError *err, GObexPacket *rsp,
@@ -535,17 +528,12 @@ static void get_xfer_progress_first(GObex *obex, GError *err, GObexPacket *rsp,
 static gssize put_xfer_progress(void *buf, gsize len, gpointer user_data)
 {
 	struct obc_transfer *transfer = user_data;
-	struct transfer_callback *callback = transfer->callback;
 	gssize size;
 
 	size = read(transfer->fd, buf, len);
 	if (size <= 0)
 		return size;
 
-	if (callback)
-		callback->func(transfer, transfer->transferred, NULL,
-							callback->data);
-
 	transfer->transferred += size;
 
 	transfer_notify_progress(transfer);
diff --git a/client/transfer.h b/client/transfer.h
index bfa166d..15c157a 100644
--- a/client/transfer.h
+++ b/client/transfer.h
@@ -24,8 +24,7 @@
 struct obc_transfer;
 
 typedef void (*transfer_callback_t) (struct obc_transfer *transfer,
-					gint64 transferred, GError *err,
-					void *user_data);
+					GError *err, void *user_data);
 
 struct obc_transfer *obc_transfer_get(const char *type, const char *name,
 					const char *filename, GError **err);
-- 
1.7.7.6

[PATCH obexd v0 11/16] client: Remove obsolete authentication code

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

After the removal of the agent, the implementation of the session can be
simplified by removing all authentication-related code.
---
 client/session.c |   86 ++++++++++++++++-------------------------------------
 1 files changed, 26 insertions(+), 60 deletions(-)

diff --git a/client/session.c b/client/session.c
index 8e21da4..9670968 100644
--- a/client/session.c
+++ b/client/session.c
@@ -68,7 +68,6 @@ struct pending_request {
 	guint req_id;
 	struct obc_session *session;
 	struct obc_transfer *transfer;
-	GFunc auth_complete;
 	session_callback_t func;
 	void *data;
 };
@@ -95,11 +94,12 @@ struct obc_session {
 	gchar *owner;		/* Session owner */
 	guint watch;
 	GQueue *queue;
+	guint queue_complete_id;
 };
 
 static GSList *sessions = NULL;
 
-static void session_start_transfer(gpointer data, gpointer user_data);
+static void session_process_queue(struct obc_session *session);
 static void session_terminate_transfer(struct obc_session *session,
 					struct obc_transfer *transfer,
 					GError *gerr);
@@ -139,7 +139,6 @@ static void session_unregistered(struct obc_session *session)
 
 static struct pending_request *pending_request_new(struct obc_session *session,
 						struct obc_transfer *transfer,
-						GFunc auth_complete,
 						session_callback_t func,
 						void *data)
 {
@@ -150,7 +149,6 @@ static struct pending_request *pending_request_new(struct obc_session *session,
 	p->id = ++id;
 	p->session = obc_session_ref(session);
 	p->transfer = transfer;
-	p->auth_complete = auth_complete;
 	p->func = func;
 	p->data = data;
 
@@ -172,6 +170,9 @@ static void session_free(struct obc_session *session)
 {
 	DBG("%p", session);
 
+	if (session->queue_complete_id != 0)
+		g_source_remove(session->queue_complete_id);
+
 	if (session->queue) {
 		g_queue_foreach(session->queue, (GFunc) pending_request_free,
 									NULL);
@@ -629,22 +630,15 @@ static const GDBusMethodTable session_methods[] = {
 	{ }
 };
 
-static gboolean session_request_proceed(gpointer data)
+static gboolean session_queue_complete(gpointer data)
 {
 	struct obc_session *session = data;
-	struct pending_request *p = session->p;
-	struct obc_transfer *transfer = p->transfer;
 
-	if (p->auth_complete)
-		p->auth_complete(p->session, transfer);
+	session_process_queue(session);
 
-	return FALSE;
-}
+	session->queue_complete_id = 0;
 
-static int pending_request_auth(struct pending_request *p)
-{
-	g_idle_add(session_request_proceed, p->session);
-	return 0;
+	return FALSE;
 }
 
 guint obc_session_queue(struct obc_session *session,
@@ -653,7 +647,6 @@ guint obc_session_queue(struct obc_session *session,
 				GError **err)
 {
 	struct pending_request *p;
-	int perr;
 
 	if (session->obex == NULL) {
 		obc_transfer_unregister(transfer);
@@ -670,21 +663,12 @@ guint obc_session_queue(struct obc_session *session,
 
 	obc_transfer_set_callback(transfer, transfer_complete, session);
 
-	p = pending_request_new(session, transfer, session_start_transfer,
-							func, user_data);
-	if (session->p) {
-		g_queue_push_tail(session->queue, p);
-		return p->id;
-	}
-
-	perr = pending_request_auth(p);
-	if (perr < 0) {
-		g_set_error(err, OBEX_IO_ERROR, perr, "Authorization failed");
-		pending_request_free(p);
-		return 0;
-	}
+	p = pending_request_new(session, transfer, func, user_data);
+	g_queue_push_tail(session->queue, p);
 
-	session->p = p;
+	if (session->queue_complete_id == 0)
+		session->queue_complete_id = g_idle_add(
+					session_queue_complete, session);
 
 	return p->id;
 }
@@ -702,22 +686,19 @@ static void session_process_queue(struct obc_session *session)
 	obc_session_ref(session);
 
 	while ((p = g_queue_pop_head(session->queue))) {
-		int err;
+		GError *gerr = NULL;
+
+		DBG("Transfer(%p) started", p->transfer);
 
-		err = pending_request_auth(p);
-		if (err == 0) {
+		if (obc_transfer_start(p->transfer, session->obex, &gerr)) {
 			session->p = p;
 			break;
 		}
 
-		if (p->func) {
-			GError *gerr = NULL;
-
-			g_set_error(&gerr, OBEX_IO_ERROR, err,
-							"Authorization failed");
+		if (p->func)
 			p->func(session, p->transfer, gerr, p->data);
-			g_error_free(gerr);
-		}
+
+		g_clear_error(&gerr);
 
 		pending_request_free(p);
 	}
@@ -801,21 +782,6 @@ fail:
 	session_notify_error(session, transfer, err);
 }
 
-static void session_start_transfer(gpointer data, gpointer user_data)
-{
-	struct obc_session *session = data;
-	struct obc_transfer *transfer = user_data;
-	GError *err = NULL;
-
-	if (!obc_transfer_start(transfer, session->obex, &err)) {
-		session_notify_error(session, transfer, err);
-		g_clear_error(&err);
-		return;
-	}
-
-	DBG("Transfer(%p) started", transfer);
-}
-
 const char *obc_session_register(struct obc_session *session,
 						GDBusDestroyFunction destroy)
 {
@@ -950,7 +916,7 @@ guint obc_session_setpath(struct obc_session *session, const char *path,
 	data->user_data = user_data;
 	data->remaining = g_strsplit(path, "/", 3);
 
-	p = pending_request_new(session, NULL, NULL, setpath_complete, data);
+	p = pending_request_new(session, NULL, setpath_complete, data);
 
 	/* Relative path */
 	if (path[0] != '/') {
@@ -1025,7 +991,7 @@ guint obc_session_mkdir(struct obc_session *session, const char *folder,
 	}
 
 
-	p = pending_request_new(session, NULL, NULL, func, user_data);
+	p = pending_request_new(session, NULL, func, user_data);
 
 	p->req_id = g_obex_mkdir(session->obex, folder, async_cb, p, err);
 	if (*err != NULL) {
@@ -1054,7 +1020,7 @@ guint obc_session_copy(struct obc_session *session, const char *srcname,
 		return 0;
 	}
 
-	p = pending_request_new(session, NULL, NULL, func, user_data);
+	p = pending_request_new(session, NULL, func, user_data);
 
 	p->req_id = g_obex_copy(session->obex, srcname, destname, async_cb, p,
 									err);
@@ -1084,7 +1050,7 @@ guint obc_session_move(struct obc_session *session, const char *srcname,
 		return 0;
 	}
 
-	p = pending_request_new(session, NULL, NULL, func, user_data);
+	p = pending_request_new(session, NULL, func, user_data);
 
 	p->req_id = g_obex_move(session->obex, srcname, destname, async_cb, p,
 									err);
@@ -1114,7 +1080,7 @@ guint obc_session_delete(struct obc_session *session, const char *file,
 		return 0;
 	}
 
-	p = pending_request_new(session, NULL, NULL, func, user_data);
+	p = pending_request_new(session, NULL, func, user_data);
 
 	p->req_id = g_obex_delete(session->obex, file, async_cb, p, err);
 	if (*err != NULL) {
-- 
1.7.7.6

[PATCH obexd v0 12/16] client: Make D-Bus exposure of transfers optional

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

The session API lets the modules decide if each transfer should be
exposed in D-Bus or not, instead of relying on a internal policy inside
transfer.c that would decide this based on the transfer type.
---
 client/ftp.c      |    6 +++---
 client/map.c      |    6 ++++--
 client/opp.c      |    4 ++--
 client/pbap.c     |    8 +++++---
 client/session.c  |   15 ++++++++-------
 client/session.h  |    2 +-
 client/sync.c     |    4 ++--
 client/transfer.c |    7 -------
 8 files changed, 25 insertions(+), 27 deletions(-)

diff --git a/client/ftp.c b/client/ftp.c
index 9b2c51d..b7b5081 100644
--- a/client/ftp.c
+++ b/client/ftp.c
@@ -237,7 +237,7 @@ static DBusMessage *list_folder(DBusConnection *connection,
 		goto fail;
 
 	if (obc_session_queue(session, transfer, list_folder_callback,
-							message, &err)) {
+							message, FALSE, &err)) {
 		dbus_message_ref(message);
 		return NULL;
 	}
@@ -271,7 +271,7 @@ static DBusMessage *get_file(DBusConnection *connection,
 		goto fail;
 
 	if (obc_session_queue(session, transfer, get_file_callback, message,
-								&err)) {
+								TRUE, &err)) {
 		dbus_message_ref(message);
 		return NULL;
 	}
@@ -306,7 +306,7 @@ static DBusMessage *put_file(DBusConnection *connection,
 	if (transfer == NULL)
 		goto fail;
 
-	if (obc_session_queue(session, transfer, NULL, NULL, &err))
+	if (obc_session_queue(session, transfer, NULL, NULL, TRUE, &err))
 		return dbus_message_new_method_return(message);
 
 fail:
diff --git a/client/map.c b/client/map.c
index 52b7c68..add302a 100644
--- a/client/map.c
+++ b/client/map.c
@@ -143,7 +143,8 @@ static DBusMessage *map_get_folder_listing(DBusConnection *connection,
 	if (transfer == NULL)
 		goto fail;
 
-	if (obc_session_queue(map->session, transfer, buffer_cb, map, &err)) {
+	if (obc_session_queue(map->session, transfer, buffer_cb, map, FALSE,
+									&err)) {
 		map->msg = dbus_message_ref(message);
 		return NULL;
 	}
@@ -177,7 +178,8 @@ static DBusMessage *map_get_message_listing(DBusConnection *connection,
 	if (transfer == NULL)
 		goto fail;
 
-	if (obc_session_queue(map->session, transfer, buffer_cb, map, &err)) {
+	if (obc_session_queue(map->session, transfer, buffer_cb, map, FALSE,
+									&err)) {
 		map->msg = dbus_message_ref(message);
 		return NULL;
 	}
diff --git a/client/opp.c b/client/opp.c
index 67b01a9..f6ba398 100644
--- a/client/opp.c
+++ b/client/opp.c
@@ -88,7 +88,7 @@ static DBusMessage *opp_send_file(DBusConnection *connection,
 		goto fail;
 
 	if (!obc_session_queue(opp->session, transfer, send_file_callback,
-								message, &err))
+							message, TRUE, &err))
 		goto fail;
 
 	dbus_message_ref(message);
@@ -144,7 +144,7 @@ static DBusMessage *opp_pull_business_card(DBusConnection *connection,
 		goto fail;
 
 	if (!obc_session_queue(opp->session, pull, pull_complete_callback,
-								message, &err))
+							message, TRUE, &err))
 		goto fail;
 
 	dbus_message_ref(message);
diff --git a/client/pbap.c b/client/pbap.c
index 3a771ab..1945fad 100644
--- a/client/pbap.c
+++ b/client/pbap.c
@@ -500,7 +500,8 @@ static DBusMessage *pull_phonebook(struct pbap_data *pbap,
 
 	obc_transfer_set_params(transfer, &apparam, sizeof(apparam));
 
-	if (obc_session_queue(pbap->session, transfer, func, request, &err))
+	if (obc_session_queue(pbap->session, transfer, func, request,
+								FALSE, &err))
 		return NULL;
 
 	pending_request_free(request);
@@ -567,7 +568,8 @@ static DBusMessage *pull_vcard_listing(struct pbap_data *pbap,
 	obc_transfer_set_params(transfer, apparam, apparam_size);
 
 	if (obc_session_queue(pbap->session, transfer,
-				pull_vcard_listing_callback, request, &err))
+					pull_vcard_listing_callback, request,
+					FALSE, &err))
 		return NULL;
 
 	pending_request_free(request);
@@ -796,7 +798,7 @@ static DBusMessage *pbap_pull_vcard(DBusConnection *connection,
 	obc_transfer_set_params(transfer, &apparam, sizeof(apparam));
 
 	if (obc_session_queue(pbap->session, transfer, pull_phonebook_callback,
-								request, &err))
+							request, FALSE, &err))
 		return NULL;
 
 	pending_request_free(request);
diff --git a/client/session.c b/client/session.c
index 9670968..bb20a61 100644
--- a/client/session.c
+++ b/client/session.c
@@ -604,7 +604,7 @@ static DBusMessage *get_capabilities(DBusConnection *connection,
 		goto fail;
 
 	if (!obc_session_queue(session, pull, capabilities_complete_callback,
-								message, &gerr))
+							message, FALSE, &gerr))
 		goto fail;
 
 	dbus_message_ref(message);
@@ -644,7 +644,7 @@ static gboolean session_queue_complete(gpointer data)
 guint obc_session_queue(struct obc_session *session,
 				struct obc_transfer *transfer,
 				session_callback_t func, void *user_data,
-				GError **err)
+				gboolean dbus_register, GError **err)
 {
 	struct pending_request *p;
 
@@ -655,11 +655,12 @@ guint obc_session_queue(struct obc_session *session,
 		return 0;
 	}
 
-	if (!obc_transfer_register(transfer, session->conn, session->owner,
-									err)) {
-		obc_transfer_unregister(transfer);
-		return 0;
-	}
+	if (dbus_register)
+		if (!obc_transfer_register(transfer, session->conn,
+							session->owner, err)) {
+			obc_transfer_unregister(transfer);
+			return 0;
+		}
 
 	obc_transfer_set_callback(transfer, transfer_complete, session);
 
diff --git a/client/session.h b/client/session.h
index 7f37d29..1f77d56 100644
--- a/client/session.h
+++ b/client/session.h
@@ -56,7 +56,7 @@ const char *obc_session_register(struct obc_session *session,
 guint obc_session_queue(struct obc_session *session,
 				struct obc_transfer *transfer,
 				session_callback_t func, void *user_data,
-				GError **err);
+				gboolean dbus_register, GError **err);
 guint obc_session_setpath(struct obc_session *session, const char *path,
 				session_callback_t func, void *user_data,
 				GError **err);
diff --git a/client/sync.c b/client/sync.c
index d56e066..032f400 100644
--- a/client/sync.c
+++ b/client/sync.c
@@ -146,7 +146,7 @@ static DBusMessage *sync_getphonebook(DBusConnection *connection,
 
 	if (obc_session_queue(sync->session, transfer,
 						sync_getphonebook_callback,
-						sync, &err)) {
+						sync, TRUE, &err)) {
 		sync->msg = dbus_message_ref(message);
 		return NULL;
 	}
@@ -182,7 +182,7 @@ static DBusMessage *sync_putphonebook(DBusConnection *connection,
 	if (transfer == NULL)
 		goto fail;
 
-	if (obc_session_queue(sync->session, transfer, NULL, NULL, &err))
+	if (obc_session_queue(sync->session, transfer, NULL, NULL, TRUE, &err))
 		return dbus_message_new_method_return(message);
 
 fail:
diff --git a/client/transfer.c b/client/transfer.c
index b6b4b9c..f07afd0 100644
--- a/client/transfer.c
+++ b/client/transfer.c
@@ -252,12 +252,6 @@ gboolean obc_transfer_register(struct obc_transfer *transfer,
 						const char *owner,
 						GError **err)
 {
-	/* for OBEX specific mime types we don't need to register a transfer */
-	if (transfer->type != NULL &&
-			(strncmp(transfer->type, "x-obex/", 7) == 0 ||
-			strncmp(transfer->type, "x-bt/", 5) == 0))
-		goto done;
-
 	transfer->owner = g_strdup(owner);
 
 	transfer->path = g_strdup_printf("%s/transfer%ju",
@@ -279,7 +273,6 @@ gboolean obc_transfer_register(struct obc_transfer *transfer,
 		return FALSE;
 	}
 
-done:
 	DBG("%p registered %s", transfer, transfer->path);
 
 	return TRUE;
-- 
1.7.7.6

[PATCH obexd v0 13/16] client-doc: Add signal to report new transfers

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

This signal makes it possible to support transfer-monitoring
applications.
---
 doc/client-api.txt |    4 ++++
 1 files changed, 4 insertions(+), 0 deletions(-)

diff --git a/doc/client-api.txt b/doc/client-api.txt
index 656c492..e6647ff 100644
--- a/doc/client-api.txt
+++ b/doc/client-api.txt
@@ -56,6 +56,10 @@ Properties	string Source [readonly]
 
 		byte Channel [readonly]
 
+Signals		void TransferAdded(object path, dict properties)
+
+			Informs that a new transfer has been created (queued).
+
 Object Push hierarchy
 =====================
 
-- 
1.7.7.6

[PATCH obexd v0 14/16] client: Expose D-Bus data in internal transfer API

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

Split internal methods logically and expose in transfer API the D-Bus
path and properties as should be returned by transfer-initiating D-Bus
methods.
---
 client/transfer.c |   64 ++++++++++++++++++++++++++++++++++++++++++----------
 client/transfer.h |    3 ++
 2 files changed, 54 insertions(+), 13 deletions(-)

diff --git a/client/transfer.c b/client/transfer.c
index f07afd0..9f1aea0 100644
--- a/client/transfer.c
+++ b/client/transfer.c
@@ -84,6 +84,19 @@ static GQuark obc_transfer_error_quark(void)
 	return g_quark_from_static_string("obc-transfer-error-quark");
 }
 
+static void obc_transfer_append_dbus_properties(struct obc_transfer *transfer,
+							DBusMessageIter *dict)
+{
+	obex_dbus_dict_append(dict, "Name", DBUS_TYPE_STRING, &transfer->name);
+	obex_dbus_dict_append(dict, "Size", DBUS_TYPE_UINT64, &transfer->size);
+	obex_dbus_dict_append(dict, "Filename", DBUS_TYPE_STRING,
+							&transfer->filename);
+
+	if (transfer->obex != NULL)
+		obex_dbus_dict_append(dict, "Progress", DBUS_TYPE_UINT64,
+						&transfer->transferred_dbus);
+}
+
 static DBusMessage *obc_transfer_get_properties(DBusConnection *connection,
 					DBusMessage *message, void *user_data)
 {
@@ -92,30 +105,55 @@ static DBusMessage *obc_transfer_get_properties(DBusConnection *connection,
 	DBusMessageIter iter, dict;
 
 	reply = dbus_message_new_method_return(message);
-	if (!reply)
+	if (reply == NULL)
 		return NULL;
 
 	dbus_message_iter_init_append(reply, &iter);
-
 	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
-			DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
-			DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
-			DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
+						OBC_PROPERTIES_ARRAY_SIGNATURE,
+						&dict);
 
-	obex_dbus_dict_append(&dict, "Name", DBUS_TYPE_STRING, &transfer->name);
-	obex_dbus_dict_append(&dict, "Size", DBUS_TYPE_UINT64, &transfer->size);
-	obex_dbus_dict_append(&dict, "Filename", DBUS_TYPE_STRING,
-							&transfer->filename);
-
-	if (transfer->obex != NULL)
-		obex_dbus_dict_append(&dict, "Progress", DBUS_TYPE_UINT64,
-						&transfer->transferred_dbus);
+	obc_transfer_append_dbus_properties(transfer, &dict);
 
 	dbus_message_iter_close_container(&iter, &dict);
 
 	return reply;
 }
 
+static void obc_transfer_append_dbus_data(struct obc_transfer *transfer,
+							DBusMessageIter *iter)
+{
+	const char *path = transfer->path;
+	DBusMessageIter entry, dict;
+
+	dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL, &entry);
+	dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH, &path);
+	dbus_message_iter_open_container(&entry, DBUS_TYPE_ARRAY,
+						OBC_PROPERTIES_ARRAY_SIGNATURE,
+						&dict);
+
+	obc_transfer_append_dbus_properties(transfer, &dict);
+
+	dbus_message_iter_close_container(&entry, &dict);
+	dbus_message_iter_close_container(iter, &entry);
+}
+
+DBusMessage *obc_transfer_create_dbus_reply(struct obc_transfer *transfer,
+							DBusMessage *message)
+{
+	DBusMessage *reply;
+	DBusMessageIter iter;
+
+	reply = dbus_message_new_method_return(message);
+	if (reply == NULL)
+		return NULL;
+
+	dbus_message_iter_init_append(reply, &iter);
+	obc_transfer_append_dbus_data(transfer, &iter);
+
+	return reply;
+}
+
 static void abort_complete(GObex *obex, GError *err, gpointer user_data)
 {
 	struct obc_transfer *transfer = user_data;
diff --git a/client/transfer.h b/client/transfer.h
index 15c157a..eb5275c 100644
--- a/client/transfer.h
+++ b/client/transfer.h
@@ -57,3 +57,6 @@ int obc_transfer_get_contents(struct obc_transfer *transfer, char **contents,
 
 const char *obc_transfer_get_path(struct obc_transfer *transfer);
 gint64 obc_transfer_get_size(struct obc_transfer *transfer);
+
+DBusMessage *obc_transfer_create_dbus_reply(struct obc_transfer *transfer,
+							DBusMessage *message);
-- 
1.7.7.6

[PATCH obexd v0 15/16] client: Add signal to report new transfers

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

---
 client/session.c  |   45 +++++++++++++++++++++++++++++++++++++++++++--
 client/transfer.c |    2 +-
 client/transfer.h |    2 ++
 3 files changed, 46 insertions(+), 3 deletions(-)

diff --git a/client/session.c b/client/session.c
index bb20a61..fcaa97e 100644
--- a/client/session.c
+++ b/client/session.c
@@ -630,6 +630,12 @@ static const GDBusMethodTable session_methods[] = {
 	{ }
 };
 
+static const GDBusSignalTable session_signals[] = {
+	{ GDBUS_SIGNAL("TransferAdded",
+		GDBUS_ARGS({ "path", "o" }, { "properties", "a{sv}" })) },
+	{ }
+};
+
 static gboolean session_queue_complete(gpointer data)
 {
 	struct obc_session *session = data;
@@ -641,6 +647,34 @@ static gboolean session_queue_complete(gpointer data)
 	return FALSE;
 }
 
+static gboolean emit_transfer_added(struct obc_session *session,
+						struct obc_transfer *transfer)
+{
+	DBusMessage *signal;
+	DBusMessageIter iter;
+	DBusMessageIter dict;
+	const char *path;
+
+	signal = dbus_message_new_signal(session->path, SESSION_INTERFACE,
+							"TransferAdded");
+	if (signal == NULL)
+		return FALSE;
+
+	dbus_message_iter_init_append(signal, &iter);
+
+	path = obc_transfer_get_path(transfer);
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &path);
+	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+						OBC_PROPERTIES_ARRAY_SIGNATURE,
+						&dict);
+	obc_transfer_append_dbus_properties(transfer, &dict);
+	dbus_message_iter_close_container(&iter, &dict);
+
+	g_dbus_send_message(session->conn, signal);
+
+	return TRUE;
+}
+
 guint obc_session_queue(struct obc_session *session,
 				struct obc_transfer *transfer,
 				session_callback_t func, void *user_data,
@@ -655,13 +689,19 @@ guint obc_session_queue(struct obc_session *session,
 		return 0;
 	}
 
-	if (dbus_register)
+	if (dbus_register) {
 		if (!obc_transfer_register(transfer, session->conn,
 							session->owner, err)) {
 			obc_transfer_unregister(transfer);
 			return 0;
 		}
 
+		if (!emit_transfer_added(session, transfer)) {
+			obc_transfer_unregister(transfer);
+			return 0;
+		}
+	}
+
 	obc_transfer_set_callback(transfer, transfer_complete, session);
 
 	p = pending_request_new(session, transfer, func, user_data);
@@ -794,7 +834,8 @@ const char *obc_session_register(struct obc_session *session,
 
 	if (g_dbus_register_interface(session->conn, session->path,
 					SESSION_INTERFACE, session_methods,
-					NULL, NULL, session, destroy) == FALSE)
+					session_signals, NULL, session,
+					destroy) == FALSE)
 		goto fail;
 
 	if (session->driver->probe && session->driver->probe(session) < 0) {
diff --git a/client/transfer.c b/client/transfer.c
index 9f1aea0..e61cb3c 100644
--- a/client/transfer.c
+++ b/client/transfer.c
@@ -84,7 +84,7 @@ static GQuark obc_transfer_error_quark(void)
 	return g_quark_from_static_string("obc-transfer-error-quark");
 }
 
-static void obc_transfer_append_dbus_properties(struct obc_transfer *transfer,
+void obc_transfer_append_dbus_properties(struct obc_transfer *transfer,
 							DBusMessageIter *dict)
 {
 	obex_dbus_dict_append(dict, "Name", DBUS_TYPE_STRING, &transfer->name);
diff --git a/client/transfer.h b/client/transfer.h
index eb5275c..df01a2b 100644
--- a/client/transfer.h
+++ b/client/transfer.h
@@ -58,5 +58,7 @@ int obc_transfer_get_contents(struct obc_transfer *transfer, char **contents,
 const char *obc_transfer_get_path(struct obc_transfer *transfer);
 gint64 obc_transfer_get_size(struct obc_transfer *transfer);
 
+void obc_transfer_append_dbus_properties(struct obc_transfer *transfer,
+							DBusMessageIter *dict);
 DBusMessage *obc_transfer_create_dbus_reply(struct obc_transfer *transfer,
 							DBusMessage *message);
-- 
1.7.7.6

[PATCH obexd v0 16/16] client-test: Remove agent from ftp-client

[Mikel Astiz]

From: Mikel Astiz <mikel.astiz@bmw-carit.de>

This updated test script is limited because the current transitional
D-Bus API is incomplete. The reason behind is that the transfer path is
not being returned by methods that initiate such a transfer. Therefore
the client cannot know when the transfer has succeeded or failed, and
neither can receive progress reports in a reliable way.
---
 test/ftp-client |   49 +++++++++----------------------------------------
 1 files changed, 9 insertions(+), 40 deletions(-)

diff --git a/test/ftp-client b/test/ftp-client
index 825f591..da15116 100755
--- a/test/ftp-client
+++ b/test/ftp-client
@@ -9,42 +9,6 @@ import dbus.mainloop.glib
 import os.path
 from optparse import OptionParser
 
-class Agent(dbus.service.Object):
-    def __init__(self, conn=None, obj_path=None, verbose=False):
-        dbus.service.Object.__init__(self, conn, obj_path)
-        self.verbose = verbose
-
-    @dbus.service.method("org.openobex.Agent",
-                    in_signature="o", out_signature="s")
-    def Request(self, path):
-        return ""
-
-    @dbus.service.method("org.openobex.Agent",
-                    in_signature="ot", out_signature="")
-    def Progress(self, path, transferred):
-        if self.verbose:
-            print "Transfer progress (%d bytes)" % (transferred)
-        return
-
-    @dbus.service.method("org.openobex.Agent",
-                    in_signature="o", out_signature="")
-    def Complete(self, path):
-        if self.verbose:
-            print "Transfer finished"
-        mainloop.quit()
-
-    @dbus.service.method("org.openobex.Agent",
-                    in_signature="os", out_signature="")
-    def Error(self, path, error):
-        print "Transfer finished with an error: %s" % (error)
-        mainloop.quit()
-
-    @dbus.service.method("org.openobex.Agent",
-                    in_signature="", out_signature="")
-    def Release(self):
-        mainloop.quit()
-
-
 def parse_options():
     parser.add_option("-d", "--device", dest="device",
                       help="Device to connect", metavar="DEVICE")
@@ -74,6 +38,9 @@ def error(err):
 def void_reply():
     pass
 
+def transfer_complete():
+    print "SOME transfer finished (could not check if path matches)"
+
 def change_folder(session, new_dir):
     for node in new_dir.split("/"):
         session.ChangeFolder(node)
@@ -129,8 +96,12 @@ if  __name__ == '__main__':
     bus = dbus.SessionBus()
     mainloop = gobject.MainLoop()
 
-    path = "/test/agent"
-    agent = Agent(bus, path, options.verbose)
+    bus.add_signal_receiver(transfer_complete,
+                            dbus_interface="org.openobex.Transfer",
+                            signal_name="Complete")
+    bus.add_signal_receiver(error,
+                            dbus_interface="org.openobex.Transfer",
+                            signal_name="Error")
 
     client = dbus.Interface(bus.get_object("org.openobex.client", "/"),
                             "org.openobex.Client")
@@ -140,8 +111,6 @@ if  __name__ == '__main__':
     session = dbus.Interface(bus.get_object("org.openobex.client", session_path),
                  "org.openobex.Session")
 
-    session.AssignAgent(path)
-
     ftp = dbus.Interface(bus.get_object("org.openobex.client", session_path),
                  "org.openobex.FileTransfer")
 
-- 
1.7.7.6

Re: [PATCH obexd v0 03/16] client: Add progress property to transfer

[Vinicius Costa Gomes]

Hi Mikel,

On 17:00 Wed 23 May, Mikel Astiz wrote:
> From: Mikel Astiz <mikel.astiz@bmw-carit.de>
> 
> The number of transferred bytes is exposed in D-Bus using a specific
> property for this purpose.
> 
> Internally, the value of this property does not necessarily match the
> internal progress counter. In order to avoid D-Bus overhead, the
> property will be updated at least every N bytes, where N is fixed and
> hardcoded (TRANSFER_PROGRESS_PERIOD).
> ---
>  client/transfer.c |   47 +++++++++++++++++++++++++++++++++++++++++++++--
>  1 files changed, 45 insertions(+), 2 deletions(-)
> 
> diff --git a/client/transfer.c b/client/transfer.c
> index 8292265..2c6e1ed 100644
> --- a/client/transfer.c
> +++ b/client/transfer.c
> @@ -44,6 +44,7 @@
>  
>  #define TRANSFER_INTERFACE  "org.openobex.Transfer"
>  #define TRANSFER_BASEPATH   "/org/openobex"
> +#define TRANSFER_PROGRESS_PERIOD (16 * 1024)

Just a detail, but this value is half the value of the default Bluetooth
MTU, right? 

For a future improvement, I think it would be nice to consider a value
related to the MTU.

[snip]

>  
> -- 
> 1.7.7.6
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-bluetooth" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html


Cheers,
-- 
Vinicius

Re: [PATCH obexd v0 03/16] client: Add progress property to transfer

[Luiz Augusto von Dentz]

Hi Vinicius, Mikel,

On Wed, May 23, 2012 at 8:40 PM, Vinicius Costa Gomes
<vinicius.gomes@openbossa.org> wrote:
> Hi Mikel,
>
> On 17:00 Wed 23 May, Mikel Astiz wrote:
>> From: Mikel Astiz <mikel.astiz@bmw-carit.de>
>>
>> The number of transferred bytes is exposed in D-Bus using a specific
>> property for this purpose.
>>
>> Internally, the value of this property does not necessarily match the
>> internal progress counter. In order to avoid D-Bus overhead, the
>> property will be updated at least every N bytes, where N is fixed and
>> hardcoded (TRANSFER_PROGRESS_PERIOD).
>> ---
>>  client/transfer.c |   47 +++++++++++++++++++++++++++++++++++++++++++++--
>>  1 files changed, 45 insertions(+), 2 deletions(-)
>>
>> diff --git a/client/transfer.c b/client/transfer.c
>> index 8292265..2c6e1ed 100644
>> --- a/client/transfer.c
>> +++ b/client/transfer.c
>> @@ -44,6 +44,7 @@
>>
>>  #define TRANSFER_INTERFACE  "org.openobex.Transfer"
>>  #define TRANSFER_BASEPATH   "/org/openobex"
>> +#define TRANSFER_PROGRESS_PERIOD (16 * 1024)
>
> Just a detail, but this value is half the value of the default Bluetooth
> MTU, right?
>
> For a future improvement, I think it would be nice to consider a value
> related to the MTU.

Actually I would rather do it time based, send progress once per
second, since with high speed this may spam the bus anyway.


-- 
Luiz Augusto von Dentz

Re: [PATCH obexd v0 03/16] client: Add progress property to transfer

[Vinicius Costa Gomes]

Hi Luiz,

On 11:25 Thu 24 May, Luiz Augusto von Dentz wrote:
> Hi Vinicius, Mikel,
> 
> On Wed, May 23, 2012 at 8:40 PM, Vinicius Costa Gomes
> <vinicius.gomes@openbossa.org> wrote:
> > Hi Mikel,
> >
> > On 17:00 Wed 23 May, Mikel Astiz wrote:
> >> From: Mikel Astiz <mikel.astiz@bmw-carit.de>
> >>
> >> The number of transferred bytes is exposed in D-Bus using a specific
> >> property for this purpose.
> >>
> >> Internally, the value of this property does not necessarily match the
> >> internal progress counter. In order to avoid D-Bus overhead, the
> >> property will be updated at least every N bytes, where N is fixed and
> >> hardcoded (TRANSFER_PROGRESS_PERIOD).
> >> ---
> >>  client/transfer.c |   47 +++++++++++++++++++++++++++++++++++++++++++++--
> >>  1 files changed, 45 insertions(+), 2 deletions(-)
> >>
> >> diff --git a/client/transfer.c b/client/transfer.c
> >> index 8292265..2c6e1ed 100644
> >> --- a/client/transfer.c
> >> +++ b/client/transfer.c
> >> @@ -44,6 +44,7 @@
> >>
> >>  #define TRANSFER_INTERFACE  "org.openobex.Transfer"
> >>  #define TRANSFER_BASEPATH   "/org/openobex"
> >> +#define TRANSFER_PROGRESS_PERIOD (16 * 1024)
> >
> > Just a detail, but this value is half the value of the default Bluetooth
> > MTU, right?
> >
> > For a future improvement, I think it would be nice to consider a value
> > related to the MTU.
> 
> Actually I would rather do it time based, send progress once per
> second, since with high speed this may spam the bus anyway.

Yeah, that would be even better :-)

> 
> 
> -- 
> Luiz Augusto von Dentz


Cheers,
-- 
Vinicius