X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fafb-apis.c;h=6e093550e4113cde18613a80f1f20ff1184c1c38;hb=5d248158cc380d0a164fa56b46a7bdede4115407;hp=9b2df3f30f1176d4a9e2fc89afa91ddce4b346d1;hpb=ee28f046a7d389a4de305297abb065a9fddfb928;p=src%2Fapp-framework-binder.git

diff --git a/src/afb-apis.c b/src/afb-apis.c
index 9b2df3f3..6e093550 100644
--- a/src/afb-apis.c
+++ b/src/afb-apis.c
@@ -1,384 +1,387 @@
 /*
- * Copyright (C) 2016 "IoT.bzh"
+ * Copyright (C) 2016, 2017 "IoT.bzh"
  * Author "Fulup Ar Foll"
  * Author José Bollo <jose.bollo@iot.bzh>
  *
- * 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 3 of the License, or
- * (at your option) any later version.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
  *
- * 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.
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- * 
- * Contain all generic part to handle REST/API
- * 
- *  https://www.gnu.org/software/libmicrohttpd/tutorial.html [search 'largepost.c']
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 
 #define _GNU_SOURCE
 
+#include <stdlib.h>
 #include <stdio.h>
-#include <assert.h>
 #include <string.h>
-#include <dirent.h>
-#include <dlfcn.h>
-#include <unistd.h>
-#include <limits.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <signal.h>
-#include <time.h>
-#include <sys/syscall.h>
-#include <setjmp.h>
-
-#include "local-def.h"
-
-#include "afb-plugin.h"
-#include "afb-req-itf.h"
-#include "afb-poll-itf.h"
-
-#include "session.h"
-#include "afb-apis.h"
+#include <errno.h>
+
+#include "afb-session.h"
 #include "verbose.h"
-#include "utils-upoll.h"
+#include "afb-apis.h"
+#include "afb-context.h"
+#include "afb-xreq.h"
+#include "jobs.h"
 
+#include <afb/afb-req-itf.h>
+
+/**
+ * Internal description of an api
+ */
 struct api_desc {
-	struct AFB_plugin *plugin;	/* descriptor */
-	size_t prefixlen;
-	const char *prefix;
-	void *handle;		/* context of dlopen */
-	struct AFB_interface *interface;
+	const char *name;	/**< name of the api */
+	struct afb_api api;	/**< handler of the api */
 };
 
-static int api_timeout = 15;
 static struct api_desc *apis_array = NULL;
 static int apis_count = 0;
+static int apis_timeout = 15;
 
-static const char plugin_register_function[] = "pluginRegister";
-
-static const struct afb_poll_itf upoll_itf = {
-	.on_readable = (void*)upoll_on_readable,
-	.on_writable = (void*)upoll_on_writable,
-	.on_hangup = (void*)upoll_on_hangup,
-	.close = (void*)upoll_close
-};
-
-
-int afb_apis_count()
-{
-	return apis_count;
-}
-
-void afb_apis_free_context(int apiidx, void *context)
+/**
+ * Set the API timeout
+ * @param to the timeout in seconds
+ */
+void afb_apis_set_timeout(int to)
 {
-	void (*cb)(void*);
-
-	assert(0 <= apiidx && apiidx < apis_count);
-	cb = apis_array[apiidx].plugin->freeCtxCB;
-	if (cb)
-		cb(context);
-	else
-		free(context);
+	apis_timeout = to;
 }
 
-static struct afb_poll itf_poll_open(int fd, void *closure)
+/**
+ * Checks wether 'name' is a valid API name.
+ * @return 1 if valid, 0 otherwise
+ */
+int afb_apis_is_valid_api_name(const char *name)
 {
-	struct afb_poll result;
-	result.data = upoll_open(fd, closure);
-	result.itf = result.data ? &upoll_itf : NULL;
-	return result;
+	unsigned char c;
+
+	c = (unsigned char)*name;
+	if (c == 0)
+		/* empty names aren't valid */
+		return 0;
+
+	do {
+		if (c < (unsigned char)'\x80') {
+			switch(c) {
+			default:
+				if (c > ' ')
+					break;
+			case '"':
+			case '#':
+			case '%':
+			case '&':
+			case '\'':
+			case '/':
+			case '?':
+			case '`':
+			case '\\':
+			case '\x7f':
+				return 0;
+			}
+		}
+		c = (unsigned char)*++name;
+	} while(c != 0);
+	return 1;
 }
 
-
-int afb_apis_add_plugin(const char *path)
+/**
+ * Adds the api of 'name' described by 'api'.
+ * @param name the name of the api to add (have to survive, not copied!)
+ * @param api the api
+ * @returns 0 in case of success or -1 in case
+ * of error with errno set:
+ *   - EINVAL if name isn't valid
+ *   - EEXIST if name already registered
+ *   - ENOMEM when out of memory
+ */
+int afb_apis_add(const char *name, struct afb_api api)
 {
 	struct api_desc *apis;
-	struct AFB_plugin *plugin;
-	struct AFB_plugin *(*pluginRegisterFct) (const struct AFB_interface *interface);
-	struct AFB_interface *interface;
-	void *handle;
-	int i;
+	int i, c;
 
-	// This is a loadable library let's check if it's a plugin
-	handle = dlopen(path, RTLD_NOW | RTLD_LOCAL);
-	if (handle == NULL) {
-		fprintf(stderr, "[%s] not loadable, continuing...\n", path);
+	/* Checks the api name */
+	if (!afb_apis_is_valid_api_name(name)) {
+		ERROR("invalid api name forbidden (name is '%s')", name);
+		errno = EINVAL;
 		goto error;
 	}
 
-	/* retrieves the register function */
-	pluginRegisterFct = dlsym(handle, plugin_register_function);
-	if (!pluginRegisterFct) {
-		fprintf(stderr, "[%s] not an AFB plugin, continuing...\n", path);
-		goto error2;
+	/* check previously existing plugin */
+	for (i = 0 ; i < apis_count ; i++) {
+		c = strcasecmp(apis_array[i].name, name);
+		if (c == 0) {
+			ERROR("api of name %s already exists", name);
+			errno = EEXIST;
+			goto error;
+		}
+		if (c > 0)
+			break;
 	}
-	if (verbosity)
-		fprintf(stderr, "[%s] is a valid AFB plugin\n", path);
 
 	/* allocates enough memory */
 	apis = realloc(apis_array, ((unsigned)apis_count + 1) * sizeof * apis);
 	if (apis == NULL) {
-		fprintf(stderr, "ERROR: plugin [%s] memory missing. continuing...\n", path);
-		goto error2;
+		ERROR("out of memory");
+		errno = ENOMEM;
+		goto error;
 	}
 	apis_array = apis;
 
-	/* allocates the interface */
-	interface = calloc(1, sizeof *interface);
-	if (interface == NULL) {
-		fprintf(stderr, "ERROR: plugin [%s] memory missing. continuing...\n", path);
-		goto error2;
-	}
-	interface->verbosity = 0;
-	interface->mode = AFB_MODE_LOCAL;
-	interface->poll_open = itf_poll_open;
-
-	/* init the plugin */
-	plugin = pluginRegisterFct(interface);
-	if (plugin == NULL) {
-		fprintf(stderr, "ERROR: plugin [%s] register function failed. continuing...\n", path);
-		goto error3;
-	}
-
-	/* check the returned structure */
-	if (plugin->type != AFB_PLUGIN_JSON) {
-		fprintf(stderr, "ERROR: plugin [%s] invalid type %d...\n", path, plugin->type);
-		goto error3;
-	}
-	if (plugin->prefix == NULL || *plugin->prefix == 0) {
-		fprintf(stderr, "ERROR: plugin [%s] bad prefix...\n", path);
-		goto error3;
-	}
-	if (plugin->info == NULL || *plugin->info == 0) {
-		fprintf(stderr, "ERROR: plugin [%s] bad description...\n", path);
-		goto error3;
-	}
-	if (plugin->apis == NULL) {
-		fprintf(stderr, "ERROR: plugin [%s] no APIs...\n", path);
-		goto error3;
-	}
-
-	/* check previously existing plugin */
-	for (i = 0 ; i < apis_count ; i++) {
-		if (!strcasecmp(apis_array[i].prefix, plugin->prefix)) {
-			fprintf(stderr, "ERROR: plugin [%s] prefix %s duplicated...\n", path, plugin->prefix);
-			goto error2;
-		}
+	/* copy higher part of the array */
+	c = apis_count;
+	while (c > i) {
+		apis_array[c] = apis_array[c - 1];
+		c--;
 	}
 
 	/* record the plugin */
-	if (verbosity)
-		fprintf(stderr, "Loading plugin[%lu] prefix=[%s] info=%s\n", (unsigned long)apis_count, plugin->prefix, plugin->info);
-	apis = &apis_array[apis_count];
-	apis->plugin = plugin;
-	apis->prefixlen = strlen(plugin->prefix);
-	apis->prefix = plugin->prefix;
-	apis->handle = handle;
-	apis->interface = interface;
+	apis = &apis_array[i];
+	apis->api = api;
+	apis->name = name;
 	apis_count++;
 
+	NOTICE("API %s added", name);
+
 	return 0;
 
-error3:
-	free(interface);
-error2:
-	dlclose(handle);
 error:
 	return -1;
 }
 
-static int adddirs(char path[PATH_MAX], size_t end)
+/**
+ * Search the 'api'.
+ * @param api the api of the verb
+ * @return the descriptor if found or NULL otherwise
+ */
+static const struct api_desc *search(const char *api)
 {
-	int rc;
-	DIR *dir;
-	struct dirent ent, *result;
-	size_t len;
-
-	/* open the DIR now */
-	dir = opendir(path);
-	if (dir == NULL) {
-		fprintf(stderr, "ERROR in scanning plugin directory %s, %m\n", path);
-		return -1;
-	}
-	if (verbosity)
-		fprintf(stderr, "Scanning dir=[%s] for plugins\n", path);
+	int i, c, up, lo;
+	const struct api_desc *a;
 
-	/* scan each entry */
-	if (end)
-		path[end++] = '/';
+	/* dichotomic search of the api */
+	/* initial slice */
+	lo = 0;
+	up = apis_count;
 	for (;;) {
-		readdir_r(dir, &ent, &result);
-		if (result == NULL)
-			break;
-
-		len = strlen(ent.d_name);
-		if (len + end >= PATH_MAX) {
-			fprintf(stderr, "path too long for %s\n", ent.d_name);
-			continue;
+		/* check remaining slice */
+		if (lo >= up) {
+			/* not found */
+			return NULL;
 		}
-		memcpy(&path[end], ent.d_name, len+1);
-		if (ent.d_type == DT_DIR) {
-			/* case of directories */
-			if (ent.d_name[0] == '.') {
-				if (len == 1)
-					continue;
-				if (ent.d_name[1] == '.' && len == 2)
-					continue;
-			}
-			rc = adddirs(path, end+len);;
-		} else if (ent.d_type == DT_REG) {
-			/* case of files */
-			if (!strstr(ent.d_name, ".so"))
-				continue;
-			rc = afb_apis_add_plugin(path);
+		/* check the mid of the slice */
+		i = (lo + up) >> 1;
+		a = &apis_array[i];
+		c = strcasecmp(a->name, api);
+		if (c == 0) {
+			/* found */
+			return a;
 		}
+		/* update the slice */
+		if (c < 0)
+			lo = i + 1;
+		else
+			up = i;
 	}
-	closedir(dir);
-	return 0;
 }
 
-int afb_apis_add_directory(const char *path)
+/**
+ * Starts a service by its 'api' name.
+ * @param api name of the service to start
+ * @param share_session if true start the servic"e in a shared session
+ *                      if false start it in its own session
+ * @param onneed if true start the service if possible, if false the api
+ *               must be a service
+ * @return a positive number on success
+ */
+int afb_apis_start_service(const char *api, int share_session, int onneed)
 {
-	size_t length;
-	char buffer[PATH_MAX];
+	int i;
 
-	length = strlen(path);
-	if (length >= sizeof(buffer)) {
-		fprintf(stderr, "path too long %lu [%.99s...]\n", (unsigned long)length, path);
-		return -1;
+	for (i = 0 ; i < apis_count ; i++) {
+		if (!strcasecmp(apis_array[i].name, api))
+			return apis_array[i].api.itf->service_start(apis_array[i].api.closure, share_session, onneed);
 	}
+	ERROR("can't find service %s", api);
+	errno = ENOENT;
+	return -1;
+}
+
+/**
+ * Starts all possible services but stops at first error.
+ * @param share_session if true start the servic"e in a shared session
+ *                      if false start it in its own session
+ * @return 0 on success or a negative number when an error is found
+ */
+int afb_apis_start_all_services(int share_session)
+{
+	int i, rc;
 
-	memcpy(buffer, path, length + 1);
-	return adddirs(buffer, length);
+	for (i = 0 ; i < apis_count ; i++) {
+		rc = apis_array[i].api.itf->service_start(apis_array[i].api.closure, share_session, 1);
+		if (rc < 0)
+			return rc;
+	}
+	return 0;
 }
 
-int afb_apis_add_path(const char *path)
+/**
+ * Internal direct dispatch of the request 'xreq'
+ * @param xreq the request to dispatch
+ */
+static void do_call_direct(struct afb_xreq *xreq)
 {
-	struct stat st;
-	int rc;
+	const struct api_desc *a;
 
-	rc = stat(path, &st);
-	if (rc < 0)
-		fprintf(stderr, "Invalid plugin path [%s]: %m\n", path);
-	else if (S_ISDIR(st.st_mode))
-		rc = afb_apis_add_directory(path);
-	else
-		rc = afb_apis_add_plugin(path);
-	return rc;
+	/* search the api */
+	a = search(xreq->api);
+	if (!a)
+		afb_xreq_fail_f(xreq, "unknown-api", "api %s not found", xreq->api);
+	else {
+		xreq->context.api_key = a->api.closure;
+		a->api.itf->call(a->api.closure, xreq);
+	}
+}
+
+/**
+ * Asynchronous dispatch callback for the request 'xreq'
+ * @param signum 0 on normal flow or the signal number that interupted the normal flow
+ */
+static void do_call_async(int signum, void *arg)
+{
+	struct afb_xreq *xreq = arg;
+
+	if (signum != 0)
+		afb_xreq_fail_f(xreq, "aborted", "signal %s(%d) caught", strsignal(signum), signum);
+	else {
+		do_call_direct(xreq);
+	}
+	afb_xreq_unref(xreq);
 }
 
-int afb_apis_add_pathset(const char *pathset)
+/**
+ * Dispatch the request 'xreq' synchronously and directly.
+ * @param xreq the request to dispatch
+ */
+void afb_apis_call_direct(struct afb_xreq *xreq)
+{
+	afb_xreq_begin(xreq);
+	do_call_direct(xreq);
+}
+
+/**
+ * Dispatch the request 'xreq' asynchronously.
+ * @param xreq the request to dispatch
+ */
+void afb_apis_call(struct afb_xreq *xreq)
 {
-	static char sep[] = ":";
-	char *ps, *p;
 	int rc;
 
-	ps = strdupa(pathset);
-	for (;;) {
-		p = strsep(&ps, sep);
-		if (!p)
-			return 0;
-		rc = afb_apis_add_path(p);
-	};
+	afb_xreq_begin(xreq);
+	afb_xreq_addref(xreq);
+	rc = jobs_queue(NULL, apis_timeout, do_call_async, xreq);
+	if (rc < 0) {
+		/* TODO: allows or not to proccess it directly as when no threading? (see above) */
+		ERROR("can't process job with threads: %m");
+		afb_xreq_fail_f(xreq, "cancelled", "not able to create a job for the task");
+		afb_xreq_unref(xreq);
+	}
 }
 
-// Check of apiurl is declare in this plugin and call it
-extern __thread sigjmp_buf *error_handler;
-static void trapping_handle(struct afb_req req, void(*cb)(struct afb_req))
+/**
+ * Ask to update the hook flags of the 'api'
+ * @param api the api to update (NULL updates all)
+ */
+void afb_apis_update_hooks(const char *api)
 {
-	volatile int signum, timerset;
-	timer_t timerid;
-	sigjmp_buf jmpbuf, *older;
-	struct sigevent sevp;
-	struct itimerspec its;
-
-	// save context before calling the API
-	timerset = 0;
-	older = error_handler;
-	signum = setjmp(jmpbuf);
-	if (signum != 0) {
-		afb_req_fail_f(req, "aborted", "signal %d caught", signum);
+	const struct api_desc *i, *e;
+
+	if (!api) {
+		i = apis_array;
+		e = &apis_array[apis_count];
+	} else {
+		i = search(api);
+		e = &i[!!i];
 	}
-	else {
-		error_handler = &jmpbuf;
-		if (api_timeout > 0) {
-			timerset = 1; /* TODO: check statuses */
-			sevp.sigev_notify = SIGEV_THREAD_ID;
-			sevp.sigev_signo = SIGALRM;
-			sevp.sigev_value.sival_ptr = NULL;
-#if defined(sigev_notify_thread_id)
-			sevp.sigev_notify_thread_id = (pid_t)syscall(SYS_gettid);
-#else
-			sevp._sigev_un._tid = (pid_t)syscall(SYS_gettid);
-#endif
-			timer_create(CLOCK_THREAD_CPUTIME_ID, &sevp, &timerid);
-			its.it_interval.tv_sec = 0;
-			its.it_interval.tv_nsec = 0;
-			its.it_value.tv_sec = api_timeout;
-			its.it_value.tv_nsec = 0;
-			timer_settime(timerid, 0, &its, NULL);
-		}
+	while (i != e) {
+		if (i->api.itf->update_hooks)
+			i->api.itf->update_hooks(i->api.closure);
+		i++;
+	}
+}
 
-		cb(req);
+/**
+ * Set the verbosity level of the 'api'
+ * @param api the api to set (NULL set all)
+ */
+void afb_apis_set_verbosity(const char *api, int level)
+{
+	const struct api_desc *i, *e;
+
+	if (!api) {
+		i = apis_array;
+		e = &apis_array[apis_count];
+	} else {
+		i = search(api);
+		e = &i[!!i];
+	}
+	while (i != e) {
+		if (i->api.itf->set_verbosity)
+			i->api.itf->set_verbosity(i->api.closure, level);
+		i++;
 	}
-	if (timerset)
-		timer_delete(timerid);
-	error_handler = older;
 }
 
-static void handle(struct afb_req req, const struct AFB_restapi *verb)
+/**
+ * Set the verbosity level of the 'api'
+ * @param api the api to set (NULL set all)
+ */
+int afb_apis_get_verbosity(const char *api)
 {
-	switch(verb->session) {
-	case AFB_SESSION_CREATE:
-		if (!afb_req_session_create(req))
-			return;
-		break;
-	case AFB_SESSION_RENEW:
-		if (!afb_req_session_check(req, 1))
-			return;
-		break;
-	case AFB_SESSION_CLOSE:
-	case AFB_SESSION_CHECK:
-		if (!afb_req_session_check(req, 0))
-			return;
-		break;
-	case AFB_SESSION_NONE:
-	default:
-		break;
+	const struct api_desc *i;
+
+	i = api ? search(api) : NULL;
+	if (!i) {
+		errno = ENOENT;
+		return -1;
 	}
-	trapping_handle(req, verb->callback);
+	if (!i->api.itf->get_verbosity)
+		return 0;
 
-	if (verb->session == AFB_SESSION_CLOSE)
-		afb_req_session_close(req);
+	return i->api.itf->get_verbosity(i->api.closure);
 }
 
-int afb_apis_handle(struct afb_req req, struct AFB_clientCtx *context, const char *api, size_t lenapi, const char *verb, size_t lenverb)
+/**
+ * Get the list of api names
+ * @return a NULL terminated array of api names. Must be freed.
+ */
+const char **afb_apis_get_names()
 {
-	int i, j;
-	const struct api_desc *a;
-	const struct AFB_restapi *v;
-
-	a = apis_array;
-	for (i = 0 ; i < apis_count ; i++, a++) {
-		if (a->prefixlen == lenapi && !strncasecmp(a->prefix, api, lenapi)) {
-			v = a->plugin->apis;
-			for (j = 0 ; v->name ; j++, v++) {
-				if (!strncasecmp(v->name, verb, lenverb) && !v->name[lenverb]) {
-					req.context = &context->contexts[i];
-					handle(req, v);
-					return 1;
-				}
-			}
-			afb_req_fail_f(req, "unknown-verb", "verb %.*s unknown within api %s", (int)lenverb, verb, a->prefix);
-			return 1;
+	size_t size;
+	char *dest;
+	const char **names;
+	int i;
+
+	size = apis_count * (1 + sizeof(*names)) + sizeof(*names);
+	for (i = 0 ; i < apis_count ; i++)
+		size += strlen(apis_array[i].name);
+
+	names = malloc(size);
+	if (!names)
+		errno = ENOMEM;
+	else {
+		dest = (void*)&names[apis_count+1];
+		for (i = 0 ; i < apis_count ; i++) {
+			names[i] = dest;
+			dest = stpcpy(dest, apis_array[i].name) + 1;
 		}
+		names[i] = NULL;
 	}
-	return 0;
+	return names;
 }