aruslan
diff --git a/‎serve/async.c‎
Lines changed: 12 additions & 4 deletions b/‎serve/async.c‎
Lines changed: 12 additions & 4 deletions
diff --git a/‎serve/async.h‎
Lines changed: 1 addition & 1 deletion b/‎serve/async.h‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎serve/bbf.c‎
Lines changed: 21 additions & 4 deletions b/‎serve/bbf.c‎
Lines changed: 21 additions & 4 deletions
diff --git a/‎serve/ebb.c‎
Lines changed: 0 additions & 1 deletion b/‎serve/ebb.c‎
Lines changed: 0 additions & 1 deletion
@@ -1,4 +1,5 @@
 #include <stdlib.h>
+#include <assert.h>
 #include <ev.h>
 #include <dispatch/dispatch.h>
 
@@ -14,8 +15,9 @@ static int queue_length = 10;
 static main_async_t* async_queue;
 static ev_async main_async;
 
-void dispatch_main_async_f(void* context, void (*cb)(void*))
+void main_async_f(void* context, void (*cb)(void*))
 {
+	assert(cb);
 	dispatch_semaphore_wait(async_queue_semaphore, DISPATCH_TIME_FOREVER);
 	++queue_pending;
 	if (queue_pending > queue_length)
@@ -30,14 +32,20 @@ void dispatch_main_async_f(void* context, void (*cb)(void*))
 	ev_async_send(EV_DEFAULT_ &main_async);
 }
 
-static void main_async_dispatch(EV_P_ ev_async* w, int revents)
+static void main_async_drain(EV_P_ ev_async* w, int revents)
 {
 	dispatch_semaphore_wait(async_queue_semaphore, DISPATCH_TIME_FOREVER);
 	while (queue_pending > 0)
 	{
+		main_async_t async;
 		queue_position = (queue_position + queue_length - 1) % queue_length;
 		--queue_pending;
-		async_queue[queue_position].cb(async_queue[queue_position].context);
+		async = async_queue[queue_position];
+		dispatch_semaphore_signal(async_queue_semaphore);
+		// call the async block outside the lock
+		async.cb(async.context);
+		// continue the lock so we can get correct queue_pending
+		dispatch_semaphore_wait(async_queue_semaphore, DISPATCH_TIME_FOREVER);
 	}
 	dispatch_semaphore_signal(async_queue_semaphore);
 }
@@ -46,7 +54,7 @@ void main_async_init(void)
 {
 	async_queue_semaphore = dispatch_semaphore_create(1);
 	async_queue = (main_async_t*)malloc(sizeof(main_async_t) * queue_length);
-	ev_async_init(&main_async, main_async_dispatch);
+	ev_async_init(&main_async, main_async_drain);
 }
 
 void main_async_start(EV_P)
 
@@ -1,7 +1,7 @@
 #ifndef _GUARD_async_h_
 #define _GUARD_async_h_
 
-void dispatch_main_async_f(void* context, void (*cb)(void*));
+void main_async_f(void* context, void (*cb)(void*));
 void main_async_init(void);
 void main_async_start(EV_P);
 void main_async_destroy(void);
 
@@ -1,11 +1,28 @@
 #include "uri.h"
 
-#define MSG ("HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 12\r\n\r\nhello world\n")
+void* uri_bbf_detect_objects_parse(void* parsed, const char* key, const char* value)
+{
+	return 0;
+}
+
+ebb_buf uri_bbf_detect_objects_intro(const void* query)
+{
+	ebb_buf buf;
+	const static char bbf_intro[] = 
+		"HTTP/1.1 200 OK\r\nCache-Control: no-cache\r\nAccept: \r\nContent-Type: text/html\r\nContent-Length: 156\r\n\r\n"
+		"<html><body><form enctype='multipart/form-data' method='post'><input type='file' name='a'><input type='file' name='b'><input type='submit'></form>\n";
+	buf.data = (void*)bbf_intro;
+	buf.len = sizeof(bbf_intro);
+	return buf;
+}
 
-ebb_buf ebb_bbf_detect_objects(const void* query)
+ebb_buf uri_bbf_detect_objects(const void* query)
 {
 	ebb_buf buf;
-	buf.data = MSG;
-	buf.len = sizeof(MSG);
+	const static char bbf_intro[] = 
+		"HTTP/1.1 201 Created\r\nCache-Control: no-cache\r\nContent-Type: text/plain\r\nContent-Length: 3\r\n\r\n"
+		"OK\n";
+	buf.data = (void*)bbf_intro;
+	buf.len = sizeof(bbf_intro);
 	return buf;
 }
@@ -121,7 +121,6 @@ on_readable(EV_P_ ev_io *watcher, int revents)
     recv_buffer_size = buf->len;
   }
 
-
   recved = recv(connection->fd, recv_buffer, recv_buffer_size, 0);
   if(recved < 0) goto error;
   if(recved == 0) return;
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`#include <stdlib.h>`
	`2`	`+#include <assert.h>`
`2`	`3`	`#include <ev.h>`
`3`	`4`	`#include <dispatch/dispatch.h>`
`4`	`5`
`@@ -14,8 +15,9 @@ static int queue_length = 10;`
`14`	`15`	`static main_async_t* async_queue;`
`15`	`16`	`static ev_async main_async;`
`16`	`17`
`17`		`-void dispatch_main_async_f(void* context, void (cb)(void))`
	`18`	`+void main_async_f(void* context, void (cb)(void))`
`18`	`19`	`{`
	`20`	`+ assert(cb);`
`19`	`21`	`dispatch_semaphore_wait(async_queue_semaphore, DISPATCH_TIME_FOREVER);`
`20`	`22`	`++queue_pending;`
`21`	`23`	`if (queue_pending > queue_length)`
`@@ -30,14 +32,20 @@ void dispatch_main_async_f(void* context, void (cb)(void))`
`30`	`32`	`ev_async_send(EV_DEFAULT_ &main_async);`
`31`	`33`	`}`
`32`	`34`
`33`		`-static void main_async_dispatch(EV_P_ ev_async* w, int revents)`
	`35`	`+static void main_async_drain(EV_P_ ev_async* w, int revents)`
`34`	`36`	`{`
`35`	`37`	`dispatch_semaphore_wait(async_queue_semaphore, DISPATCH_TIME_FOREVER);`
`36`	`38`	`while (queue_pending > 0)`
`37`	`39`	`{`
	`40`	`+ main_async_t async;`
`38`	`41`	`queue_position = (queue_position + queue_length - 1) % queue_length;`
`39`	`42`	`--queue_pending;`
`40`		`- async_queue[queue_position].cb(async_queue[queue_position].context);`
	`43`	`+ async = async_queue[queue_position];`
	`44`	`+ dispatch_semaphore_signal(async_queue_semaphore);`
	`45`	`+ // call the async block outside the lock`
	`46`	`+ async.cb(async.context);`
	`47`	`+ // continue the lock so we can get correct queue_pending`
	`48`	`+ dispatch_semaphore_wait(async_queue_semaphore, DISPATCH_TIME_FOREVER);`
`41`	`49`	`}`
`42`	`50`	`dispatch_semaphore_signal(async_queue_semaphore);`
`43`	`51`	`}`
`@@ -46,7 +54,7 @@ void main_async_init(void)`
`46`	`54`	`{`
`47`	`55`	`async_queue_semaphore = dispatch_semaphore_create(1);`
`48`	`56`	`async_queue = (main_async_t)malloc(sizeof(main_async_t) queue_length);`
`49`		`- ev_async_init(&main_async, main_async_dispatch);`
	`57`	`+ ev_async_init(&main_async, main_async_drain);`
`50`	`58`	`}`
`51`	`59`
`52`	`60`	`void main_async_start(EV_P)`
Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,6 @@ on_readable(EV_P_ ev_io *watcher, int revents)`
`121`	`121`	`recv_buffer_size = buf->len;`
`122`	`122`	`}`
`123`	`123`
`124`		`-`
`125`	`124`	`recved = recv(connection->fd, recv_buffer, recv_buffer_size, 0);`
`126`	`125`	`if(recved < 0) goto error;`
`127`	`126`	`if(recved == 0) return;`