X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fafb-proto-ws.c;h=edf63634e21dd0d1d68bdea68ba08f9c51c7ec77;hb=ad66a4685f5d50ef05338157c84a572088693ed3;hp=e1993abe47399ba12a0169774188ed2aad227d2c;hpb=24d000c2290126abf88204089d132229d63f9a05;p=src%2Fapp-framework-binder.git

diff --git a/src/afb-proto-ws.c b/src/afb-proto-ws.c
index e1993abe..edf63634 100644
--- a/src/afb-proto-ws.c
+++ b/src/afb-proto-ws.c
@@ -17,8 +17,6 @@
 
 #define _GNU_SOURCE
 
-#define NO_PLUGIN_VERBOSE_MACRO
-
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
@@ -37,8 +35,8 @@
 #include "afb-ws.h"
 #include "afb-msg-json.h"
 #include "afb-proto-ws.h"
-#include "jobs.h"
 #include "fdev.h"
+#include "verbose.h"
 
 struct afb_proto_ws;
 
@@ -61,8 +59,6 @@ The server must reply to the previous actions by
 
 The server can also within the context of a call
 
-  - make a subcall
-
   - subscribe or unsubscribe an event
 
 For the purpose of handling events the server can:
@@ -75,42 +71,17 @@ For the purpose of handling events the server can:
 /************** constants for protocol definition *************************/
 
 #define CHAR_FOR_CALL             'C'
-#define CHAR_FOR_ANSWER_SUCCESS   'T'
-#define CHAR_FOR_ANSWER_FAIL      'F'
+#define CHAR_FOR_REPLY            'Y'
 #define CHAR_FOR_EVT_BROADCAST    '*'
 #define CHAR_FOR_EVT_ADD          '+'
 #define CHAR_FOR_EVT_DEL          '-'
 #define CHAR_FOR_EVT_PUSH         '!'
 #define CHAR_FOR_EVT_SUBSCRIBE    'S'
 #define CHAR_FOR_EVT_UNSUBSCRIBE  'U'
-#define CHAR_FOR_SUBCALL_CALL     'B'
-#define CHAR_FOR_SUBCALL_REPLY    'R'
 #define CHAR_FOR_DESCRIBE         'D'
 #define CHAR_FOR_DESCRIPTION      'd'
 
-/******************* handling subcalls *****************************/
-
-/**
- * Structure on server side for recording pending
- * subcalls.
- */
-struct server_subcall
-{
-	struct server_subcall *next;	/**< next subcall for the client */
-	uint32_t subcallid;		/**< the subcallid */
-	void (*callback)(void*, int, struct json_object*); /**< callback on completion */
-	void *closure;			/**< closure of the callback */
-};
-
-/**
- * Structure for sending back replies on client side
- */
-struct afb_proto_ws_subcall
-{
-	struct afb_proto_ws *protows;	/**< proto descriptor */
-	void *buffer;
-	uint32_t subcallid;		/**< subcallid for the reply */
-};
+/******************* handling calls *****************************/
 
 /*
  * structure for recording calls on client side
@@ -118,7 +89,7 @@ struct afb_proto_ws_subcall
 struct client_call {
 	struct client_call *next;	/* the next call */
 	struct afb_proto_ws *protows;	/* the proto_ws */
-	void *request;
+	void *request;			/* the request closure */
 	uint32_t callid;		/* the message identifier */
 };
 
@@ -161,9 +132,6 @@ struct afb_proto_ws
 	/* count of references */
 	int refcount;
 
-	/* file descriptor */
-	struct fdev *fdev;
-
 	/* resource control */
 	pthread_mutex_t mutex;
 
@@ -182,14 +150,14 @@ struct afb_proto_ws
 	/* emitted calls (client side) */
 	struct client_call *calls;
 
-	/* pending subcalls (server side) */
-	struct server_subcall *subcalls;
-
 	/* pending description (client side) */
 	struct client_describe *describes;
 
 	/* on hangup callback */
 	void (*on_hangup)(void *closure);
+
+	/* queuing facility for processing messages */
+	int (*queuing)(struct afb_proto_ws *proto, void (*process)(int s, void *c), void *closure);
 };
 
 /******************* streaming objects **********************************/
@@ -237,6 +205,7 @@ static char *readbuf_get(struct readbuf *rb, uint32_t length)
 	return before;
 }
 
+__attribute__((unused))
 static int readbuf_char(struct readbuf *rb, char *value)
 {
 	if (rb->head >= rb->end)
@@ -256,24 +225,44 @@ static int readbuf_uint32(struct readbuf *rb, uint32_t *value)
 	return 1;
 }
 
-static int readbuf_string(struct readbuf *rb, const char **value, size_t *length)
+static int _readbuf_string_(struct readbuf *rb, const char **value, size_t *length, int nulok)
 {
 	uint32_t len;
-	if (!readbuf_uint32(rb, &len) || !len)
+	if (!readbuf_uint32(rb, &len))
 		return 0;
+	if (!len) {
+		if (!nulok)
+			return 0;
+		*value = NULL;
+		if (length)
+			*length = 0;
+		return 1;
+	}
 	if (length)
 		*length = (size_t)(len - 1);
 	return (*value = readbuf_get(rb, len)) != NULL &&  rb->head[-1] == 0;
 }
 
+
+static int readbuf_string(struct readbuf *rb, const char **value, size_t *length)
+{
+	return _readbuf_string_(rb, value, length, 0);
+}
+
+static int readbuf_nullstring(struct readbuf *rb, const char **value, size_t *length)
+{
+	return _readbuf_string_(rb, value, length, 1);
+}
+
 static int readbuf_object(struct readbuf *rb, struct json_object **object)
 {
 	const char *string;
 	struct json_object *o;
+	enum json_tokener_error jerr;
 	int rc = readbuf_string(rb, &string, NULL);
 	if (rc) {
-		o = json_tokener_parse(string);
-		if (o == NULL && strcmp(string, "null"))
+		o = json_tokener_parse_verbose(string, &jerr);
+		if (jerr != json_tokener_success)
 			o = json_object_new_string(string);
 		*object = o;
 	}
@@ -326,12 +315,43 @@ static int writebuf_string(struct writebuf *wb, const char *value)
 	return writebuf_string_length(wb, value, strlen(value));
 }
 
+static int writebuf_nullstring(struct writebuf *wb, const char *value)
+{
+	return value ? writebuf_string_length(wb, value, strlen(value)) : writebuf_uint32(wb, 0);
+}
+
 static int writebuf_object(struct writebuf *wb, struct json_object *object)
 {
 	const char *string = json_object_to_json_string_ext(object, JSON_C_TO_STRING_PLAIN);
 	return string != NULL && writebuf_string(wb, string);
 }
 
+/******************* queuing of messages *****************/
+
+/* queue the processing of the received message (except if size=0 cause it's not a valid message) */
+static void queue_message_processing(struct afb_proto_ws *protows, char *data, size_t size, void (*processing)(int,void*))
+{
+	struct binary *binary;
+
+	if (size) {
+		binary = malloc(sizeof *binary);
+		if (!binary) {
+			/* TODO process the problem */
+			errno = ENOMEM;
+		} else {
+			binary->protows = protows;
+			binary->rb.base = data;
+			binary->rb.head = data;
+			binary->rb.end = data + size;
+			if (!protows->queuing
+			 || protows->queuing(protows, processing, binary) < 0)
+				processing(0, binary);
+			return;
+		}
+	}
+	free(data);
+}
+
 /******************* ws request part for server *****************/
 
 void afb_proto_ws_call_addref(struct afb_proto_ws_call *call)
@@ -349,15 +369,16 @@ void afb_proto_ws_call_unref(struct afb_proto_ws_call *call)
 	free(call);
 }
 
-int afb_proto_ws_call_success(struct afb_proto_ws_call *call, struct json_object *obj, const char *info)
+int afb_proto_ws_call_reply(struct afb_proto_ws_call *call, struct json_object *obj, const char *error, const char *info)
 {
 	int rc = -1;
 	struct writebuf wb = { .count = 0 };
 	struct afb_proto_ws *protows = call->protows;
 
-	if (writebuf_char(&wb, CHAR_FOR_ANSWER_SUCCESS)
+	if (writebuf_char(&wb, CHAR_FOR_REPLY)
 	 && writebuf_uint32(&wb, call->callid)
-	 && writebuf_string(&wb, info ?: "")
+	 && writebuf_nullstring(&wb, error)
+	 && writebuf_nullstring(&wb, info)
 	 && writebuf_object(&wb, obj)) {
 		pthread_mutex_lock(&protows->mutex);
 		rc = afb_ws_binary_v(protows->ws, wb.iovec, wb.count);
@@ -371,73 +392,6 @@ success:
 	return rc;
 }
 
-int afb_proto_ws_call_fail(struct afb_proto_ws_call *call, const char *status, const char *info)
-{
-	int rc = -1;
-	struct writebuf wb = { .count = 0 };
-	struct afb_proto_ws *protows = call->protows;
-
-	if (writebuf_char(&wb, CHAR_FOR_ANSWER_FAIL)
-	 && writebuf_uint32(&wb, call->callid)
-	 && writebuf_string(&wb, status)
-	 && writebuf_string(&wb, info ? : "")) {
-		pthread_mutex_lock(&protows->mutex);
-		rc = afb_ws_binary_v(protows->ws, wb.iovec, wb.count);
-		pthread_mutex_unlock(&protows->mutex);
-		if (rc >= 0) {
-			rc = 0;
-			goto success;
-		}
-	}
-success:
-	return rc;
-}
-
-int afb_proto_ws_call_subcall(struct afb_proto_ws_call *call, const char *api, const char *verb, struct json_object *args, void (*callback)(void*, int, struct json_object*), void *cb_closure)
-{
-	int rc = -1;
-	struct writebuf wb = { .count = 0 };
-	struct server_subcall *sc, *osc;
-	struct afb_proto_ws *protows = call->protows;
-
-	sc = malloc(sizeof *sc);
-	if (!sc)
-		errno = ENOMEM;
-	else {
-		sc->callback = callback;
-		sc->closure = cb_closure;
-
-		pthread_mutex_lock(&protows->mutex);
-		sc->subcallid = ptr2id(sc);
-		do {
-			sc->subcallid++;
-			osc = protows->subcalls;
-			while(osc && osc->subcallid != sc->subcallid)
-				osc = osc->next;
-		} while (osc);
-		sc->next = protows->subcalls;
-		protows->subcalls = sc;
-		pthread_mutex_unlock(&protows->mutex);
-
-		if (writebuf_char(&wb, CHAR_FOR_SUBCALL_CALL)
-		 && writebuf_uint32(&wb, sc->subcallid)
-		 && writebuf_uint32(&wb, call->callid)
-		 && writebuf_string(&wb, api)
-		 && writebuf_string(&wb, verb)
-		 && writebuf_object(&wb, args)) {
-			pthread_mutex_lock(&protows->mutex);
-			rc = afb_ws_binary_v(protows->ws, wb.iovec, wb.count);
-			pthread_mutex_unlock(&protows->mutex);
-			if (rc >= 0) {
-				rc = 0;
-				goto success;
-			}
-		}
-	}
-success:
-	return rc;
-}
-
 int afb_proto_ws_call_subscribe(struct afb_proto_ws_call *call, const char *event_name, int event_id)
 {
 	int rc = -1;
@@ -558,6 +512,8 @@ static void client_on_event_create(struct afb_proto_ws *protows, struct readbuf
 
 	if (protows->client_itf->on_event_create && client_msg_event_read(rb, &event_id, &event_name))
 		protows->client_itf->on_event_create(protows->closure, event_name, (int)event_id);
+	else
+		ERROR("Ignoring creation of event");
 }
 
 /* removes an event */
@@ -568,6 +524,8 @@ static void client_on_event_remove(struct afb_proto_ws *protows, struct readbuf
 
 	if (protows->client_itf->on_event_remove && client_msg_event_read(rb, &event_id, &event_name))
 		protows->client_itf->on_event_remove(protows->closure, event_name, (int)event_id);
+	else
+		ERROR("Ignoring deletion of event");
 }
 
 /* subscribes an event */
@@ -579,6 +537,8 @@ static void client_on_event_subscribe(struct afb_proto_ws *protows, struct readb
 
 	if (protows->client_itf->on_event_subscribe && client_msg_call_get(protows, rb, &call) && client_msg_event_read(rb, &event_id, &event_name))
 		protows->client_itf->on_event_subscribe(protows->closure, call->request, event_name, (int)event_id);
+	else
+		ERROR("Ignoring subscription to event");
 }
 
 /* unsubscribes an event */
@@ -590,16 +550,21 @@ static void client_on_event_unsubscribe(struct afb_proto_ws *protows, struct rea
 
 	if (protows->client_itf->on_event_unsubscribe && client_msg_call_get(protows, rb, &call) && client_msg_event_read(rb, &event_id, &event_name))
 		protows->client_itf->on_event_unsubscribe(protows->closure, call->request, event_name, (int)event_id);
+	else
+		ERROR("Ignoring unsubscription to event");
 }
 
 /* receives broadcasted events */
 static void client_on_event_broadcast(struct afb_proto_ws *protows, struct readbuf *rb)
 {
-	const char *event_name;
+	const char *event_name, *uuid;
+	char hop;
 	struct json_object *object;
 
-	if (protows->client_itf->on_event_broadcast && readbuf_string(rb, &event_name, NULL) && readbuf_object(rb, &object))
-		protows->client_itf->on_event_broadcast(protows->closure, event_name, object);
+	if (protows->client_itf->on_event_broadcast && readbuf_string(rb, &event_name, NULL) && readbuf_object(rb, &object) && (uuid = readbuf_get(rb, 16)) && readbuf_char(rb, &hop))
+		protows->client_itf->on_event_broadcast(protows->closure, event_name, object, (unsigned char*)uuid, (uint8_t)hop);
+	else
+		ERROR("Ignoring broadcast of event");
 }
 
 /* pushs an event */
@@ -611,115 +576,27 @@ static void client_on_event_push(struct afb_proto_ws *protows, struct readbuf *r
 
 	if (protows->client_itf->on_event_push && client_msg_event_read(rb, &event_id, &event_name) && readbuf_object(rb, &object))
 		protows->client_itf->on_event_push(protows->closure, event_name, (int)event_id, object);
+	else
+		ERROR("Ignoring push of event");
 }
 
-static void client_on_reply_success(struct afb_proto_ws *protows, struct readbuf *rb)
+static void client_on_reply(struct afb_proto_ws *protows, struct readbuf *rb)
 {
 	struct client_call *call;
 	struct json_object *object;
-	const char *info;
-
-	if (!client_msg_call_get(protows, rb, &call))
-		return;
-
-	if (readbuf_string(rb, &info, NULL) && readbuf_object(rb, &object)) {
-		protows->client_itf->on_reply_success(protows->closure, call->request, object, info);
-	} else {
-		protows->client_itf->on_reply_fail(protows->closure, call->request, "proto-error", "can't process success");
-	}
-	client_call_destroy(call);
-}
-
-static void client_on_reply_fail(struct afb_proto_ws *protows, struct readbuf *rb)
-{
-	struct client_call *call;
-	const char *info, *status;
+	const char *error, *info;
 
 	if (!client_msg_call_get(protows, rb, &call))
 		return;
-	
 
-	if (readbuf_string(rb, &status, NULL) && readbuf_string(rb, &info, NULL)) {
-		protows->client_itf->on_reply_fail(protows->closure, call->request, status, info);
+	if (readbuf_nullstring(rb, &error, NULL) && readbuf_nullstring(rb, &info, NULL) && readbuf_object(rb, &object)) {
+		protows->client_itf->on_reply(protows->closure, call->request, object, error, info);
 	} else {
-		protows->client_itf->on_reply_fail(protows->closure, call->request, "proto-error", "can't process fail");
+		protows->client_itf->on_reply(protows->closure, call->request, NULL, "proto-error", "can't process success");
 	}
 	client_call_destroy(call);
 }
 
-/* send a subcall reply */
-static int client_send_subcall_reply(struct afb_proto_ws *protows, uint32_t subcallid, int status, json_object *object)
-{
-	struct writebuf wb = { .count = 0 };
-	char ie = status < 0;
-	int rc;
-
-	if (writebuf_char(&wb, CHAR_FOR_SUBCALL_REPLY)
-	 && writebuf_uint32(&wb, subcallid)
-	 && writebuf_char(&wb, ie)
-	 && writebuf_object(&wb, object)) {
-		pthread_mutex_lock(&protows->mutex);
-		rc = afb_ws_binary_v(protows->ws, wb.iovec, wb.count);
-		pthread_mutex_unlock(&protows->mutex);
-		if (rc >= 0)
-			return 0;
-	}
-	return -1;
-}
-
-/* callback for subcall reply */
-int afb_proto_ws_subcall_reply(struct afb_proto_ws_subcall *subcall, int status, struct json_object *result)
-{
-	int rc = client_send_subcall_reply(subcall->protows, subcall->subcallid, status, result);
-	afb_proto_ws_unref(subcall->protows);
-	free(subcall->buffer);
-	free(subcall);
-	return rc;
-}
-
-/* received a subcall request */
-static void client_on_subcall(struct afb_proto_ws *protows, struct readbuf *rb)
-{
-	struct afb_proto_ws_subcall *subcall;
-	struct client_call *call;
-	const char *api, *verb;
-	uint32_t subcallid;
-	struct json_object *object;
-
-	/* get the subcallid */
-	if (!readbuf_uint32(rb, &subcallid))
-		return;
-
-	/* if not expected drop it */
-	if (!protows->client_itf->on_subcall)
-		goto error;
-
-	/* retrieve the message data */
-	if (!client_msg_call_get(protows, rb, &call))
-		goto error;
-
-	/* allocation of the subcall */
-	subcall = malloc(sizeof *subcall);
-	if (!subcall)
-		goto error;
-
-	/* make the call */
-	if (readbuf_string(rb, &api, NULL)
-	 && readbuf_string(rb, &verb, NULL)
-	 && readbuf_object(rb, &object)) {
-		afb_proto_ws_addref(protows);
-		subcall->protows = protows;
-		subcall->subcallid = subcallid;
-		subcall->buffer = rb->base;
-		rb->base = NULL;
-		protows->client_itf->on_subcall(protows->closure, subcall, call->request, api, verb, object);
-		return;
-	}
-	free(subcall);
-error:
-	client_send_subcall_reply(protows, subcallid, 1, NULL);
-}
-
 static void client_on_description(struct afb_proto_ws *protows, struct readbuf *rb)
 {
 	uint32_t descid;
@@ -751,11 +628,8 @@ static void client_on_binary_job(int sig, void *closure)
 
 	if (!sig) {
 		switch (*binary->rb.head++) {
-		case CHAR_FOR_ANSWER_SUCCESS: /* success */
-			client_on_reply_success(binary->protows, &binary->rb);
-			break;
-		case CHAR_FOR_ANSWER_FAIL: /* fail */
-			client_on_reply_fail(binary->protows, &binary->rb);
+		case CHAR_FOR_REPLY: /* reply */
+			client_on_reply(binary->protows, &binary->rb);
 			break;
 		case CHAR_FOR_EVT_BROADCAST: /* broadcast */
 			client_on_event_broadcast(binary->protows, &binary->rb);
@@ -775,9 +649,6 @@ static void client_on_binary_job(int sig, void *closure)
 		case CHAR_FOR_EVT_UNSUBSCRIBE: /* unsubscribe event for a request */
 			client_on_event_unsubscribe(binary->protows, &binary->rb);
 			break;
-		case CHAR_FOR_SUBCALL_CALL: /* subcall */
-			client_on_subcall(binary->protows, &binary->rb);
-			break;
 		case CHAR_FOR_DESCRIPTION: /* description */
 			client_on_description(binary->protows, &binary->rb);
 			break;
@@ -793,25 +664,9 @@ static void client_on_binary_job(int sig, void *closure)
 /* callback when receiving binary data */
 static void client_on_binary(void *closure, char *data, size_t size)
 {
-	int rc;
-	struct binary *binary;
+	struct afb_proto_ws *protows = closure;
 
-	if (size) {
-		binary = malloc(sizeof *binary);
-		if (!binary) {
-			errno = ENOMEM;
-		} else {
-			binary->protows = closure;
-			binary->rb.base = data;
-			binary->rb.head = data;
-			binary->rb.end = data + size;
-			rc = jobs_queue(NULL, 0, client_on_binary_job, binary);
-			if (rc >= 0)
-				return;
-			free(binary);
-		}
-	}
-	free(data);
+	queue_message_processing(protows, data, size, client_on_binary_job);
 }
 
 int afb_proto_ws_client_call(
@@ -819,7 +674,8 @@ int afb_proto_ws_client_call(
 		const char *verb,
 		struct json_object *args,
 		const char *sessionid,
-		void *request
+		void *request,
+		const char *user_creds
 )
 {
 	int rc = -1;
@@ -849,7 +705,8 @@ int afb_proto_ws_client_call(
 	 || !writebuf_uint32(&wb, call->callid)
 	 || !writebuf_string(&wb, verb)
 	 || !writebuf_string(&wb, sessionid)
-	 || !writebuf_object(&wb, args)) {
+	 || !writebuf_object(&wb, args)
+	 || !writebuf_nullstring(&wb, user_creds)) {
 		errno = EINVAL;
 		goto clean;
 	}
@@ -929,7 +786,7 @@ error:
 static void server_on_call(struct afb_proto_ws *protows, struct readbuf *rb)
 {
 	struct afb_proto_ws_call *call;
-	const char *uuid, *verb;
+	const char *uuid, *verb, *user_creds;
 	uint32_t callid;
 	size_t lenverb;
 	struct json_object *object;
@@ -940,7 +797,8 @@ static void server_on_call(struct afb_proto_ws *protows, struct readbuf *rb)
 	if (!readbuf_uint32(rb, &callid)
 	 || !readbuf_string(rb, &verb, &lenverb)
 	 || !readbuf_string(rb, &uuid, NULL)
-	 || !readbuf_object(rb, &object))
+	 || !readbuf_object(rb, &object)
+	 || !readbuf_nullstring(rb, &user_creds, NULL))
 		goto overflow;
 
 	/* create the request */
@@ -954,7 +812,7 @@ static void server_on_call(struct afb_proto_ws *protows, struct readbuf *rb)
 	call->buffer = rb->base;
 	rb->base = NULL; /* don't free the buffer */
 
-	protows->server_itf->on_call(protows->closure, call, verb, object, uuid);
+	protows->server_itf->on_call(protows->closure, call, verb, object, uuid, user_creds);
 	return;
 
 out_of_memory:
@@ -964,39 +822,6 @@ overflow:
 	afb_proto_ws_unref(protows);
 }
 
-/* on subcall reply */
-static void server_on_subcall_reply(struct afb_proto_ws *protows, struct readbuf *rb)
-{
-	char ie;
-	uint32_t subcallid;
-	struct json_object *object;
-	struct server_subcall *sc, **psc;
-
-	/* reads the call message data */
-	if (!readbuf_uint32(rb, &subcallid)
-	 || !readbuf_char(rb, &ie)
-	 || !readbuf_object(rb, &object)) {
-		/* TODO bad protocol */
-		return;
-	}
-
-	/* search the subcall and unlink it */
-	pthread_mutex_lock(&protows->mutex);
-	psc = &protows->subcalls;
-	while ((sc = *psc) && sc->subcallid != subcallid)
-		psc = &sc->next;
-	if (!sc) {
-		pthread_mutex_unlock(&protows->mutex);
-		json_object_put(object);
-		/* TODO subcall not found */
-	} else {
-		*psc = sc->next;
-		pthread_mutex_unlock(&protows->mutex);
-		sc->callback(sc->closure, -(int)ie, object);
-		free(sc);
-	}
-}
-
 static int server_send_description(struct afb_proto_ws *protows, uint32_t descid, struct json_object *descobj)
 {
 	int rc;
@@ -1055,9 +880,6 @@ static void server_on_binary_job(int sig, void *closure)
 		case CHAR_FOR_CALL:
 			server_on_call(binary->protows, &binary->rb);
 			break;
-		case CHAR_FOR_SUBCALL_REPLY:
-			server_on_subcall_reply(binary->protows, &binary->rb);
-			break;
 		case CHAR_FOR_DESCRIBE:
 			server_on_describe(binary->protows, &binary->rb);
 			break;
@@ -1072,25 +894,9 @@ static void server_on_binary_job(int sig, void *closure)
 
 static void server_on_binary(void *closure, char *data, size_t size)
 {
-	int rc;
-	struct binary *binary;
+	struct afb_proto_ws *protows = closure;
 
-	if (size) {
-		binary = malloc(sizeof *binary);
-		if (!binary) {
-			errno = ENOMEM;
-		} else {
-			binary->protows = closure;
-			binary->rb.base = data;
-			binary->rb.head = data;
-			binary->rb.end = data + size;
-			rc = jobs_queue(NULL, 0, server_on_binary_job, binary);
-			if (rc >= 0)
-				return;
-			free(binary);
-		}
-	}
-	free(data);
+	queue_message_processing(protows, data, size, server_on_binary_job);
 }
 
 /******************* server part: manage events **********************************/
@@ -1101,9 +907,9 @@ static int server_event_send(struct afb_proto_ws *protows, char order, const cha
 	int rc;
 
 	if (writebuf_char(&wb, order)
-	 && (order == CHAR_FOR_EVT_BROADCAST || writebuf_uint32(&wb, event_id))
+	 && writebuf_uint32(&wb, event_id)
 	 && writebuf_string(&wb, event_name)
-	 && (order == CHAR_FOR_EVT_ADD || order == CHAR_FOR_EVT_DEL || writebuf_object(&wb, data))) {
+	 && (order != CHAR_FOR_EVT_PUSH || writebuf_object(&wb, data))) {
 		pthread_mutex_lock(&protows->mutex);
 		rc = afb_ws_binary_v(protows->ws, wb.iovec, wb.count);
 		pthread_mutex_unlock(&protows->mutex);
@@ -1128,9 +934,26 @@ int afb_proto_ws_server_event_push(struct afb_proto_ws *protows, const char *eve
 	return server_event_send(protows, CHAR_FOR_EVT_PUSH, event_name, event_id, data);
 }
 
-int afb_proto_ws_server_event_broadcast(struct afb_proto_ws *protows, const char *event_name, struct json_object *data)
+int afb_proto_ws_server_event_broadcast(struct afb_proto_ws *protows, const char *event_name, struct json_object *data, const unsigned char uuid[16], uint8_t hop)
 {
-	return server_event_send(protows, CHAR_FOR_EVT_BROADCAST, event_name, 0, data);
+	struct writebuf wb = { .count = 0 };
+	int rc;
+
+	if (!hop--)
+		return 0;
+
+	if (writebuf_char(&wb, CHAR_FOR_EVT_BROADCAST)
+	 && writebuf_string(&wb, event_name)
+	 && writebuf_object(&wb, data)
+	 && writebuf_put(&wb, uuid, 16)
+	 && writebuf_char(&wb, (char)hop)) {
+		pthread_mutex_lock(&protows->mutex);
+		rc = afb_ws_binary_v(protows->ws, wb.iovec, wb.count);
+		pthread_mutex_unlock(&protows->mutex);
+		if (rc >= 0)
+			return 0;
+	}
+	return -1;
 }
 
 /*****************************************************/
@@ -1139,18 +962,19 @@ int afb_proto_ws_server_event_broadcast(struct afb_proto_ws *protows, const char
 static void on_hangup(void *closure)
 {
 	struct afb_proto_ws *protows = closure;
-	struct server_subcall *sc, *nsc;
 	struct client_describe *cd, *ncd;
+	struct client_call *call, *ncall;
+
+	ncd = __atomic_exchange_n(&protows->describes, NULL, __ATOMIC_RELAXED);
+	ncall = __atomic_exchange_n(&protows->calls, NULL, __ATOMIC_RELAXED);
 
-	nsc = protows->subcalls;
-	while (nsc) {
-		sc= nsc;
-		nsc = sc->next;
-		sc->callback(sc->closure, 1, NULL);
-		free(sc);
+	while (ncall) {
+		call= ncall;
+		ncall = call->next;
+		protows->client_itf->on_reply(protows->closure, call->request, NULL, "disconnected", "server hung up");
+		free(call);
 	}
 
-	ncd = protows->describes;
 	while (ncd) {
 		cd= ncd;
 		ncd = cd->next;
@@ -1158,9 +982,9 @@ static void on_hangup(void *closure)
 		free(cd);
 	}
 
-	if (protows->fdev) {
-		fdev_unref(protows->fdev);
-		protows->fdev = 0;
+	if (protows->ws) {
+		afb_ws_destroy(protows->ws);
+		protows->ws = 0;
 		if (protows->on_hangup)
 			protows->on_hangup(protows->closure);
 	}
@@ -1200,9 +1024,7 @@ static struct afb_proto_ws *afb_proto_ws_create(struct fdev *fdev, const struct
 		fcntl(fdev_fd(fdev), F_SETFL, O_NONBLOCK);
 		protows->ws = afb_ws_create(fdev, itf, protows);
 		if (protows->ws != NULL) {
-			protows->fdev = fdev;
 			protows->refcount = 1;
-			protows->subcalls = NULL;
 			protows->closure = closure;
 			protows->server_itf = itfs;
 			protows->client_itf = itfc;
@@ -1226,9 +1048,8 @@ struct afb_proto_ws *afb_proto_ws_create_server(struct fdev *fdev, const struct
 
 void afb_proto_ws_unref(struct afb_proto_ws *protows)
 {
-	if (!__atomic_sub_fetch(&protows->refcount, 1, __ATOMIC_RELAXED)) {
+	if (protows && !__atomic_sub_fetch(&protows->refcount, 1, __ATOMIC_RELAXED)) {
 		afb_proto_ws_hangup(protows);
-		afb_ws_destroy(protows->ws);
 		pthread_mutex_destroy(&protows->mutex);
 		free(protows);
 	}
@@ -1251,7 +1072,8 @@ int afb_proto_ws_is_server(struct afb_proto_ws *protows)
 
 void afb_proto_ws_hangup(struct afb_proto_ws *protows)
 {
-	afb_ws_hangup(protows->ws);
+	if (protows->ws)
+		afb_ws_hangup(protows->ws);
 }
 
 void afb_proto_ws_on_hangup(struct afb_proto_ws *protows, void (*on_hangup)(void *closure))
@@ -1259,3 +1081,7 @@ void afb_proto_ws_on_hangup(struct afb_proto_ws *protows, void (*on_hangup)(void
 	protows->on_hangup = on_hangup;
 }
 
+void afb_proto_ws_set_queuing(struct afb_proto_ws *protows, int (*queuing)(struct afb_proto_ws*, void (*)(int,void*), void*))
+{
+	protows->queuing = queuing;
+}