X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fafb-hsrv.c;h=f200a960e0bc89e9f3baf763c56bc0c6ab0aa394;hb=6309ade131c20f1ad3a8385921e0fb278dfe850c;hp=b5e6887b9ceb405e25209804bb75b13aefa796e1;hpb=f113d2b31333538f5784de5ee5f02bc19cc603e4;p=src%2Fapp-framework-binder.git

diff --git a/src/afb-hsrv.c b/src/afb-hsrv.c
index b5e6887b..f200a960 100644
--- a/src/afb-hsrv.c
+++ b/src/afb-hsrv.c
@@ -26,21 +26,20 @@
 
 #include <microhttpd.h>
 
-#include "local-def.h"
 #include "afb-method.h"
 #include "afb-hreq.h"
-#include "afb-websock.h"
-#include "afb-apis.h"
+#include "afb-hsrv.h"
 #include "afb-req-itf.h"
 #include "verbose.h"
 #include "utils-upoll.h"
 
+
 #define JSON_CONTENT  "application/json"
 #define FORM_CONTENT  MHD_HTTP_POST_ENCODING_MULTIPART_FORMDATA
 
 
-struct afb_hsrv_handler {
-	struct afb_hsrv_handler *next;
+struct hsrv_handler {
+	struct hsrv_handler *next;
 	const char *prefix;
 	size_t length;
 	int (*handler) (struct afb_hreq *, void *);
@@ -48,193 +47,26 @@ struct afb_hsrv_handler {
 	int priority;
 };
 
-struct afb_diralias {
+struct hsrv_alias {
 	const char *alias;
 	const char *directory;
 	size_t lendir;
 	int dirfd;
 };
 
-static struct upoll *upoll = NULL;
-
-static struct afb_hsrv_handler *new_handler(
-		struct afb_hsrv_handler *head,
-		const char *prefix,
-		int (*handler) (struct afb_hreq *, void *),
-		void *data,
-		int priority)
-{
-	struct afb_hsrv_handler *link, *iter, *previous;
-	size_t length;
-
-	/* get the length of the prefix without its leading / */
-	length = strlen(prefix);
-	while (length && prefix[length - 1] == '/')
-		length--;
-
-	/* allocates the new link */
-	link = malloc(sizeof *link);
-	if (link == NULL)
-		return NULL;
-
-	/* initialize it */
-	link->prefix = prefix;
-	link->length = length;
-	link->handler = handler;
-	link->data = data;
-	link->priority = priority;
-
-	/* adds it */
-	previous = NULL;
-	iter = head;
-	while (iter && (priority < iter->priority || (priority == iter->priority && length <= iter->length))) {
-		previous = iter;
-		iter = iter->next;
-	}
-	link->next = iter;
-	if (previous == NULL)
-		return link;
-	previous->next = link;
-	return head;
-}
-
-int afb_hsrv_add_handler(
-		AFB_session * session,
-		const char *prefix,
-		int (*handler) (struct afb_hreq *, void *),
-		void *data,
-		int priority)
-{
-	struct afb_hsrv_handler *head;
-
-	head = new_handler(session->handlers, prefix, handler, data, priority);
-	if (head == NULL)
-		return 0;
-	session->handlers = head;
-	return 1;
-}
-
-int afb_hreq_one_page_api_redirect(
-		struct afb_hreq *hreq,
-		void *data)
-{
-	size_t plen;
-	char *url;
-
-	if (hreq->lentail >= 2 && hreq->tail[1] == '#')
-		return 0;
-	/*
-	 * Here we have for example:
-	 *    url  = "/pre/dir/page"   lenurl = 13
-	 *    tail =     "/dir/page"   lentail = 9
-	 *
-	 * We will produce "/pre/#!dir/page"
-	 *
-	 * Let compute plen that include the / at end (for "/pre/")
-	 */
-	plen = hreq->lenurl - hreq->lentail + 1;
-	url = alloca(hreq->lenurl + 3);
-	memcpy(url, hreq->url, plen);
-	url[plen++] = '#';
-	url[plen++] = '!';
-	memcpy(&url[plen], &hreq->tail[1], hreq->lentail);
-	return afb_hreq_redirect_to(hreq, url);
-}
-
-static int afb_hreq_websocket_switch(struct afb_hreq *hreq, void *data)
-{
-	int later;
-
-	afb_hreq_context(hreq);
-	if (hreq->lentail != 0 || !afb_websock_check(hreq, &later))
-		return 0;
-
-	if (!later) {
-		struct afb_websock *ws = afb_websock_create(hreq->connection);
-		if (ws == NULL) {
-			/* TODO */
-		} else {
-			/* TODO */
-		}
-	}
-	return 1;
-}
-
-static int afb_hreq_rest_api(struct afb_hreq *hreq, void *data)
-{
-	const char *api, *verb;
-	size_t lenapi, lenverb;
-	struct AFB_clientCtx *context;
-
-	api = &hreq->tail[strspn(hreq->tail, "/")];
-	lenapi = strcspn(api, "/");
-	verb = &api[lenapi];
-	verb = &verb[strspn(verb, "/")];
-	lenverb = strcspn(verb, "/");
-
-	if (!(*api && *verb && lenapi && lenverb))
-		return 0;
-
-	context = afb_hreq_context(hreq);
-	return afb_apis_handle(afb_hreq_to_req(hreq), context, api, lenapi, verb, lenverb);
-}
-
-static int handle_alias(struct afb_hreq *hreq, void *data)
-{
-	struct afb_diralias *da = data;
-
-	if (hreq->method != afb_method_get) {
-		afb_hreq_reply_error(hreq, MHD_HTTP_METHOD_NOT_ALLOWED);
-		return 1;
-	}
-
-	if (!afb_hreq_valid_tail(hreq)) {
-		afb_hreq_reply_error(hreq, MHD_HTTP_FORBIDDEN);
-		return 1;
-	}
-
-	return afb_hreq_reply_file(hreq, da->dirfd, &hreq->tail[1]);
-}
-
-int afb_hsrv_add_alias(AFB_session * session, const char *prefix, const char *alias, int priority)
-{
-	struct afb_diralias *da;
-	int dirfd;
+struct afb_hsrv {
+	unsigned refcount;
+	struct hsrv_handler *handlers;
+	struct MHD_Daemon *httpd;
+	struct upoll *upoll;
+	char *cache_to;
+};
 
-	dirfd = open(alias, O_PATH|O_DIRECTORY);
-	if (dirfd < 0) {
-		/* TODO message */
-		return 0;
-	}
-	da = malloc(sizeof *da);
-	if (da != NULL) {
-		da->alias = prefix;
-		da->directory = alias;
-		da->lendir = strlen(da->directory);
-		da->dirfd = dirfd;
-		if (afb_hsrv_add_handler(session, prefix, handle_alias, da, priority))
-			return 1;
-		free(da);
-	}
-	close(dirfd);
-	return 0;
-}
 
-void afb_hsrv_reply_error(struct MHD_Connection *connection, unsigned int status)
+static void reply_error(struct MHD_Connection *connection, unsigned int status)
 {
-	char *buffer;
-	int length;
-	struct MHD_Response *response;
-
-	length = asprintf(&buffer, "<html><body>error %u</body></html>", status);
-	if (length > 0)
-		response = MHD_create_response_from_buffer((unsigned)length, buffer, MHD_RESPMEM_MUST_FREE);
-	else {
-		buffer = "<html><body>error</body></html>";
-		response = MHD_create_response_from_buffer(strlen(buffer), buffer, MHD_RESPMEM_PERSISTENT);
-	}
-	if (!MHD_queue_response(connection, status, response))
-		fprintf(stderr, "Failed to reply error code %u", status);
+	struct MHD_Response *response = MHD_create_response_from_buffer(0, NULL, MHD_RESPMEM_PERSISTENT);
+	MHD_queue_response(connection, status, response);
 	MHD_destroy_response(response);
 }
 
@@ -268,11 +100,11 @@ static int access_handler(
 	int rc;
 	struct afb_hreq *hreq;
 	enum afb_method method;
-	AFB_session *session;
-	struct afb_hsrv_handler *iter;
+	struct afb_hsrv *hsrv;
+	struct hsrv_handler *iter;
 	const char *type;
 
-	session = cls;
+	hsrv = cls;
 	hreq = *recordreq;
 	if (hreq == NULL) {
 		/* create the request */
@@ -288,7 +120,7 @@ static int access_handler(
 			goto bad_request;
 
 		/* init the request */
-		hreq->session = cls;
+		hreq->cacheTimeout = hsrv->cache_to;
 		hreq->connection = connection;
 		hreq->method = method;
 		hreq->version = version;
@@ -305,8 +137,9 @@ static int access_handler(
 				hreq->postform = MHD_create_post_processor (connection, 65500, postproc, hreq);
 				if (hreq->postform == NULL)
 					goto internal_error;
+				return MHD_YES;
 			} else if (strcasestr(type, JSON_CONTENT) == NULL) {
-				afb_hsrv_reply_error(connection, MHD_HTTP_UNSUPPORTED_MEDIA_TYPE);
+				reply_error(connection, MHD_HTTP_UNSUPPORTED_MEDIA_TYPE);
 				return MHD_YES;
 			}
 		}
@@ -318,7 +151,7 @@ static int access_handler(
 			if (!MHD_post_process (hreq->postform, upload_data, *upload_data_size))
 				goto internal_error;
 		} else {
-			if (!afb_hreq_post_add(hreq, NULL, upload_data, *upload_data_size))
+			if (!afb_hreq_post_add(hreq, "", upload_data, *upload_data_size))
 				goto internal_error;
 		}
 		*upload_data_size = 0;
@@ -326,7 +159,6 @@ static int access_handler(
 	}
 
 	/* flush the data */
-	afb_hreq_post_end(hreq);
 	if (hreq->postform != NULL) {
 		rc = MHD_destroy_post_processor(hreq->postform);
 		hreq->postform = NULL;
@@ -335,7 +167,7 @@ static int access_handler(
 	}
 
 	/* search an handler for the request */
-	iter = session->handlers;
+	iter = hsrv->handlers;
 	while (iter) {
 		if (afb_hreq_unprefix(hreq, iter->prefix, iter->length)) {
 			if (iter->handler(hreq, iter->data))
@@ -351,11 +183,11 @@ static int access_handler(
 	return MHD_YES;
 
 bad_request:
-	afb_hsrv_reply_error(connection, MHD_HTTP_BAD_REQUEST);
+	reply_error(connection, MHD_HTTP_BAD_REQUEST);
 	return MHD_YES;
 
 internal_error:
-	afb_hsrv_reply_error(connection, MHD_HTTP_INTERNAL_SERVER_ERROR);
+	reply_error(connection, MHD_HTTP_INTERNAL_SERVER_ERROR);
 	return MHD_YES;
 }
 
@@ -371,66 +203,147 @@ static void end_handler(void *cls, struct MHD_Connection *connection, void **rec
 	afb_hreq_free(hreq);
 }
 
+static void handle_epoll_readable(struct afb_hsrv *hsrv)
+{
+	upoll_on_readable(hsrv->upoll, NULL);
+	MHD_run(hsrv->httpd);
+	upoll_on_readable(hsrv->upoll, (void*)handle_epoll_readable);
+};
+
 static int new_client_handler(void *cls, const struct sockaddr *addr, socklen_t addrlen)
 {
 	return MHD_YES;
 }
 
-static int my_default_init(AFB_session * session)
+static struct hsrv_handler *new_handler(
+		struct hsrv_handler *head,
+		const char *prefix,
+		int (*handler) (struct afb_hreq *, void *),
+		void *data,
+		int priority)
 {
-	int idx;
+	struct hsrv_handler *link, *iter, *previous;
+	size_t length;
 
-	if (!afb_hsrv_add_handler(session, session->config->rootapi, afb_hreq_websocket_switch, NULL, 20))
-		return 0;
+	/* get the length of the prefix without its leading / */
+	length = strlen(prefix);
+	while (length && prefix[length - 1] == '/')
+		length--;
 
-	if (!afb_hsrv_add_handler(session, session->config->rootapi, afb_hreq_rest_api, NULL, 10))
-		return 0;
+	/* allocates the new link */
+	link = malloc(sizeof *link);
+	if (link == NULL)
+		return NULL;
 
-	for (idx = 0; session->config->aliasdir[idx].url != NULL; idx++)
-		if (!afb_hsrv_add_alias (session, session->config->aliasdir[idx].url, session->config->aliasdir[idx].path, 0))
-			return 0;
+	/* initialize it */
+	link->prefix = prefix;
+	link->length = length;
+	link->handler = handler;
+	link->data = data;
+	link->priority = priority;
 
-	if (!afb_hsrv_add_alias(session, "", session->config->rootdir, -10))
-		return 0;
+	/* adds it */
+	previous = NULL;
+	iter = head;
+	while (iter && (priority < iter->priority || (priority == iter->priority && length <= iter->length))) {
+		previous = iter;
+		iter = iter->next;
+	}
+	link->next = iter;
+	if (previous == NULL)
+		return link;
+	previous->next = link;
+	return head;
+}
 
-	if (!afb_hsrv_add_handler(session, session->config->rootbase, afb_hreq_one_page_api_redirect, NULL, -20))
-		return 0;
+static int handle_alias(struct afb_hreq *hreq, void *data)
+{
+	struct hsrv_alias *da = data;
 
-	return 1;
+	if (hreq->method != afb_method_get) {
+		afb_hreq_reply_error(hreq, MHD_HTTP_METHOD_NOT_ALLOWED);
+		return 1;
+	}
+
+	if (!afb_hreq_valid_tail(hreq)) {
+		afb_hreq_reply_error(hreq, MHD_HTTP_FORBIDDEN);
+		return 1;
+	}
+
+	return afb_hreq_reply_file(hreq, da->dirfd, &hreq->tail[1]);
 }
 
-/* infinite loop */
-static void hsrv_handle_event(struct MHD_Daemon *httpd)
+int afb_hsrv_add_handler(
+		struct afb_hsrv *hsrv,
+		const char *prefix,
+		int (*handler) (struct afb_hreq *, void *),
+		void *data,
+		int priority)
 {
-	MHD_run(httpd);
+	struct hsrv_handler *head;
+
+	head = new_handler(hsrv->handlers, prefix, handler, data, priority);
+	if (head == NULL)
+		return 0;
+	hsrv->handlers = head;
+	return 1;
 }
 
-int afb_hsrv_start(AFB_session * session)
+int afb_hsrv_add_alias(struct afb_hsrv *hsrv, const char *prefix, const char *alias, int priority)
 {
-	struct MHD_Daemon *httpd;
-	const union MHD_DaemonInfo *info;
+	struct hsrv_alias *da;
+	int dirfd;
 
-	if (!my_default_init(session)) {
-		printf("Error: initialisation of httpd failed");
+	dirfd = open(alias, O_PATH|O_DIRECTORY);
+	if (dirfd < 0) {
+		/* TODO message */
 		return 0;
 	}
-
-	if (verbosity) {
-		printf("AFB:notice Waiting port=%d rootdir=%s\n", session->config->httpdPort, session->config->rootdir);
-		printf("AFB:notice Browser URL= http:/*localhost:%d\n", session->config->httpdPort);
+	da = malloc(sizeof *da);
+	if (da != NULL) {
+		da->alias = prefix;
+		da->directory = alias;
+		da->lendir = strlen(da->directory);
+		da->dirfd = dirfd;
+		if (afb_hsrv_add_handler(hsrv, prefix, handle_alias, da, priority))
+			return 1;
+		free(da);
 	}
+	close(dirfd);
+	return 0;
+}
+
+int afb_hsrv_set_cache_timeout(struct afb_hsrv *hsrv, int duration)
+{
+	int rc;
+	char *dur;
+
+	rc = asprintf(&dur, "%d", duration);
+	if (rc < 0)
+		return 0;
+
+	free(hsrv->cache_to);
+	hsrv->cache_to = dur;
+	return 1;
+}
+
+int afb_hsrv_start(struct afb_hsrv *hsrv, uint16_t port, unsigned int connection_timeout)
+{
+	struct upoll *upoll;
+	struct MHD_Daemon *httpd;
+	const union MHD_DaemonInfo *info;
 
 	httpd = MHD_start_daemon(
 		MHD_USE_EPOLL_LINUX_ONLY | MHD_USE_TCP_FASTOPEN | MHD_USE_DEBUG | MHD_USE_SUSPEND_RESUME,
-		(uint16_t) session->config->httpdPort,	/* port */
+		port,				/* port */
 		new_client_handler, NULL,	/* Tcp Accept call back + extra attribute */
-		access_handler, session,	/* Http Request Call back + extra attribute */
-		MHD_OPTION_NOTIFY_COMPLETED, end_handler, session,
-		MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int)15,	/* 15 seconds */
+		access_handler, hsrv,	/* Http Request Call back + extra attribute */
+		MHD_OPTION_NOTIFY_COMPLETED, end_handler, hsrv,
+		MHD_OPTION_CONNECTION_TIMEOUT, connection_timeout,
 		MHD_OPTION_END);	/* options-end */
 
 	if (httpd == NULL) {
-		printf("Error: httpStart invalid httpd port: %d", session->config->httpdPort);
+		fprintf(stderr, "Error: httpStart invalid httpd port: %d", (int)port);
 		return 0;
 	}
 
@@ -441,25 +354,43 @@ int afb_hsrv_start(AFB_session * session)
 		return 0;
 	}
 
-	upoll = upoll_open(info->listen_fd, httpd);
+	upoll = upoll_open(info->listen_fd, hsrv);
 	if (upoll == NULL) {
 		MHD_stop_daemon(httpd);
 		fprintf(stderr, "Error: connection to upoll of httpd failed");
 		return 0;
 	}
-	upoll_on_readable(upoll, (void*)hsrv_handle_event);
+	upoll_on_readable(upoll, (void*)handle_epoll_readable);
 
-	session->httpd = httpd;
+	hsrv->httpd = httpd;
+	hsrv->upoll = upoll;
 	return 1;
 }
 
-void afb_hsrv_stop(AFB_session * session)
+void afb_hsrv_stop(struct afb_hsrv *hsrv)
 {
-	if (upoll)
-		upoll_close(upoll);
-	upoll = NULL;
-	if (session->httpd != NULL)
-		MHD_stop_daemon(session->httpd);
-	session->httpd = NULL;
+	if (hsrv->upoll)
+		upoll_close(hsrv->upoll);
+	hsrv->upoll = NULL;
+	if (hsrv->httpd != NULL)
+		MHD_stop_daemon(hsrv->httpd);
+	hsrv->httpd = NULL;
+}
+
+struct afb_hsrv *afb_hsrv_create()
+{
+	struct afb_hsrv *result = calloc(1, sizeof(struct afb_hsrv));
+	if (result != NULL)
+		result->refcount = 1;
+	return result;
+}
+
+void afb_hsrv_put(struct afb_hsrv *hsrv)
+{
+	assert(hsrv->refcount != 0);
+	if (!--hsrv->refcount) {
+		afb_hsrv_stop(hsrv);
+		free(hsrv);
+	}
 }