From 9a304ebddac4deb4992ea931ea1131b639798b3b Mon Sep 17 00:00:00 2001 From: =?utf8?q?Jos=C3=83=C2=A9=20Bollo?= Date: Fri, 22 Sep 2017 15:22:54 +0200 Subject: [PATCH] Allow pure dynamic bindings MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Activates the new internal interfaces Change-Id: I8f51cd271f66a0216ffdf03626300bb5964a70f9 Signed-off-by: José Bollo --- bindings/samples/CMakeLists.txt | 12 + bindings/samples/ave.c | 477 ++++++++++++++++++++++++++++++++++++++++ include/afb/afb-binding-vdyn.h | 8 + src/CMakeLists.txt | 1 + src/afb-api-so-vdyn.c | 64 ++++++ src/afb-api-so-vdyn.h | 23 ++ src/afb-api-so.c | 10 + 7 files changed, 595 insertions(+) create mode 100644 bindings/samples/ave.c create mode 100644 src/afb-api-so-vdyn.c create mode 100644 src/afb-api-so-vdyn.h diff --git a/bindings/samples/CMakeLists.txt b/bindings/samples/CMakeLists.txt index 5662ac12..efb3d20c 100644 --- a/bindings/samples/CMakeLists.txt +++ b/bindings/samples/CMakeLists.txt @@ -31,6 +31,18 @@ TARGET_LINK_LIBRARIES(authLogin ${link_libraries}) INSTALL(TARGETS authLogin LIBRARY DESTINATION ${binding_install_dir}) +################################################## +# ave +################################################## +ADD_LIBRARY(ave MODULE ave.c) +SET_TARGET_PROPERTIES(ave PROPERTIES + PREFIX "" + LINK_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/export.map" +) +TARGET_LINK_LIBRARIES(ave ${link_libraries}) +INSTALL(TARGETS ave + LIBRARY DESTINATION ${binding_install_dir}) + ################################################## # DemoContext ################################################## diff --git a/bindings/samples/ave.c b/bindings/samples/ave.c new file mode 100644 index 00000000..3ddfda62 --- /dev/null +++ b/bindings/samples/ave.c @@ -0,0 +1,477 @@ +/* + * Copyright (C) 2015, 2016, 2017 "IoT.bzh" + * Author José Bollo + * + * 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * 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 +#include +#include + +#include + +#define AFB_BINDING_VERSION 0 +#include + +static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; + +struct event +{ + struct event *next; + struct afb_eventid *eventid; + char tag[1]; +}; + +static struct event *events = 0; + +/* searchs the event of tag */ +static struct event *event_get(const char *tag) +{ + struct event *e = events; + while(e && strcmp(e->tag, tag)) + e = e->next; + return e; +} + +/* deletes the event of tag */ +static int event_del(const char *tag) +{ + struct event *e, **p; + + /* check exists */ + e = event_get(tag); + if (!e) return -1; + + /* unlink */ + p = &events; + while(*p != e) p = &(*p)->next; + *p = e->next; + + /* destroys */ + afb_eventid_unref(e->eventid); + free(e); + return 0; +} + +/* creates the event of tag */ +static int event_add(afb_dynapi *dynapi, const char *tag, const char *name) +{ + struct event *e; + + /* check valid tag */ + e = event_get(tag); + if (e) return -1; + + /* creation */ + e = malloc(strlen(tag) + sizeof *e); + if (!e) return -1; + strcpy(e->tag, tag); + + /* make the event */ + e->eventid = afb_dynapi_make_eventid(dynapi, name); + if (!e->eventid) { free(e); return -1; } + + /* link */ + e->next = events; + events = e; + return 0; +} + +static int event_subscribe(afb_request *request, const char *tag) +{ + struct event *e; + e = event_get(tag); + return e ? afb_request_subscribe(request, e->eventid) : -1; +} + +static int event_unsubscribe(afb_request *request, const char *tag) +{ + struct event *e; + e = event_get(tag); + return e ? afb_request_unsubscribe(request, e->eventid) : -1; +} + +static int event_push(struct json_object *args, const char *tag) +{ + struct event *e; + e = event_get(tag); + return e ? afb_eventid_push(e->eventid, json_object_get(args)) : -1; +} + +static int event_broadcast(struct json_object *args, const char *tag) +{ + struct event *e; + e = event_get(tag); + return e ? afb_eventid_broadcast(e->eventid, json_object_get(args)) : -1; +} + +// Sample Generic Ping Debug API +static void ping(afb_request *request, json_object *jresp, const char *tag) +{ + static int pingcount = 0; + json_object *query = afb_request_json(request); + afb_request_success_f(request, jresp, "Ping Binder Daemon tag=%s count=%d query=%s", tag, ++pingcount, json_object_to_json_string(query)); +} + +static void pingSample (afb_request *request) +{ + ping(request, json_object_new_string ("Some String"), "pingSample"); +} + +static void pingFail (afb_request *request) +{ + afb_request_fail(request, "failed", "Ping Binder Daemon fails"); +} + +static void pingNull (afb_request *request) +{ + ping(request, NULL, "pingNull"); +} + +static void pingBug (afb_request *request) +{ + ping(NULL, NULL, "pingBug"); +} + +static void pingEvent(afb_request *request) +{ + json_object *query = afb_request_json(request); + afb_dynapi_broadcast_event(request->dynapi, "event", json_object_get(query)); + ping(request, json_object_get(query), "event"); +} + + +// For samples https://linuxprograms.wordpress.com/2010/05/20/json-c-libjson-tutorial/ +static void pingJson (afb_request *request) { + json_object *jresp, *embed; + + jresp = json_object_new_object(); + json_object_object_add(jresp, "myString", json_object_new_string ("Some String")); + json_object_object_add(jresp, "myInt", json_object_new_int (1234)); + + embed = json_object_new_object(); + json_object_object_add(embed, "subObjString", json_object_new_string ("Some String")); + json_object_object_add(embed, "subObjInt", json_object_new_int (5678)); + + json_object_object_add(jresp,"eobj", embed); + + ping(request, jresp, "pingJson"); +} + +static void subcallcb (void *closure, int status, json_object *object, afb_request *request) +{ + if (status < 0) + afb_request_fail(request, "failed", json_object_to_json_string(object)); + else + afb_request_success(request, json_object_get(object), NULL); +} + +static void subcall (afb_request *request) +{ + const char *api = afb_request_value(request, "api"); + const char *verb = afb_request_value(request, "verb"); + const char *args = afb_request_value(request, "args"); + json_object *object = api && verb && args ? json_tokener_parse(args) : NULL; + + if (object == NULL) + afb_request_fail(request, "failed", "bad arguments"); + else + afb_request_subcall(request, api, verb, object, subcallcb, NULL); +} + +static void subcallsync (afb_request *request) +{ + int rc; + const char *api = afb_request_value(request, "api"); + const char *verb = afb_request_value(request, "verb"); + const char *args = afb_request_value(request, "args"); + json_object *result, *object = api && verb && args ? json_tokener_parse(args) : NULL; + + if (object == NULL) + afb_request_fail(request, "failed", "bad arguments"); + else { + rc = afb_request_subcall_sync(request, api, verb, object, &result); + if (rc >= 0) + afb_request_success(request, result, NULL); + else { + afb_request_fail(request, "failed", json_object_to_json_string(result)); + json_object_put(result); + } + } +} + +static void eventadd (afb_request *request) +{ + const char *tag = afb_request_value(request, "tag"); + const char *name = afb_request_value(request, "name"); + + pthread_mutex_lock(&mutex); + if (tag == NULL || name == NULL) + afb_request_fail(request, "failed", "bad arguments"); + else if (0 != event_add(request->dynapi, tag, name)) + afb_request_fail(request, "failed", "creation error"); + else + afb_request_success(request, NULL, NULL); + pthread_mutex_unlock(&mutex); +} + +static void eventdel (afb_request *request) +{ + const char *tag = afb_request_value(request, "tag"); + + pthread_mutex_lock(&mutex); + if (tag == NULL) + afb_request_fail(request, "failed", "bad arguments"); + else if (0 != event_del(tag)) + afb_request_fail(request, "failed", "deletion error"); + else + afb_request_success(request, NULL, NULL); + pthread_mutex_unlock(&mutex); +} + +static void eventsub (afb_request *request) +{ + const char *tag = afb_request_value(request, "tag"); + + pthread_mutex_lock(&mutex); + if (tag == NULL) + afb_request_fail(request, "failed", "bad arguments"); + else if (0 != event_subscribe(request, tag)) + afb_request_fail(request, "failed", "subscription error"); + else + afb_request_success(request, NULL, NULL); + pthread_mutex_unlock(&mutex); +} + +static void eventunsub (afb_request *request) +{ + const char *tag = afb_request_value(request, "tag"); + + pthread_mutex_lock(&mutex); + if (tag == NULL) + afb_request_fail(request, "failed", "bad arguments"); + else if (0 != event_unsubscribe(request, tag)) + afb_request_fail(request, "failed", "unsubscription error"); + else + afb_request_success(request, NULL, NULL); + pthread_mutex_unlock(&mutex); +} + +static void eventpush (afb_request *request) +{ + const char *tag = afb_request_value(request, "tag"); + const char *data = afb_request_value(request, "data"); + json_object *object = data ? json_tokener_parse(data) : NULL; + + pthread_mutex_lock(&mutex); + if (tag == NULL) + afb_request_fail(request, "failed", "bad arguments"); + else if (0 > event_push(object, tag)) + afb_request_fail(request, "failed", "push error"); + else + afb_request_success(request, NULL, NULL); + pthread_mutex_unlock(&mutex); + json_object_put(object); +} + +static void callcb (void *prequest, int status, json_object *object, afb_dynapi *dynapi) +{ + afb_request *request = prequest; + if (status < 0) + afb_request_fail(request, "failed", json_object_to_json_string(object)); + else + afb_request_success(request, json_object_get(object), NULL); + afb_request_unref(request); +} + +static void call (afb_request *request) +{ + const char *api = afb_request_value(request, "api"); + const char *verb = afb_request_value(request, "verb"); + const char *args = afb_request_value(request, "args"); + json_object *object = api && verb && args ? json_tokener_parse(args) : NULL; + + if (object == NULL) + afb_request_fail(request, "failed", "bad arguments"); + else + afb_dynapi_call(request->dynapi, api, verb, object, callcb, afb_request_addref(request)); +} + +static void callsync (afb_request *request) +{ + int rc; + const char *api = afb_request_value(request, "api"); + const char *verb = afb_request_value(request, "verb"); + const char *args = afb_request_value(request, "args"); + json_object *result, *object = api && verb && args ? json_tokener_parse(args) : NULL; + + if (object == NULL) + afb_request_fail(request, "failed", "bad arguments"); + else { + rc = afb_dynapi_call_sync(request->dynapi, api, verb, object, &result); + if (rc >= 0) + afb_request_success(request, result, NULL); + else { + afb_request_fail(request, "failed", json_object_to_json_string(result)); + json_object_put(result); + } + } +} + +static void verbose (afb_request *request) +{ + int level = 5; + json_object *query = afb_request_json(request), *l; + + if (json_object_is_type(query,json_type_int)) + level = json_object_get_int(query); + else if (json_object_object_get_ex(query, "level", &l) && json_object_is_type(l, json_type_int)) + level = json_object_get_int(l); + + if (!json_object_object_get_ex(query,"message",&l)) + l = query; + + AFB_REQUEST_VERBOSE(request, level, "verbose called for %s", json_object_get_string(l)); + afb_request_success(request, NULL, NULL); +} + +static void exitnow (afb_request *request) +{ + int code = 0; + json_object *query = afb_request_json(request), *l; + + if (json_object_is_type(query,json_type_int)) + code = json_object_get_int(query); + else if (json_object_object_get_ex(query, "code", &l) && json_object_is_type(l, json_type_int)) + code = json_object_get_int(l); + + if (!json_object_object_get_ex(query,"reason",&l)) + l = NULL; + + AFB_REQUEST_NOTICE(request, "in phase of exiting with code %d, reason: %s", code, l ? json_object_get_string(l) : "unknown"); + afb_request_success(request, NULL, NULL); + exit(code); +} + +static void broadcast(afb_request *request) +{ + const char *tag = afb_request_value(request, "tag"); + const char *name = afb_request_value(request, "name"); + const char *data = afb_request_value(request, "data"); + json_object *object = data ? json_tokener_parse(data) : NULL; + + if (tag != NULL) { + pthread_mutex_lock(&mutex); + if (0 > event_broadcast(object, tag)) + afb_request_fail(request, "failed", "broadcast error"); + else + afb_request_success(request, NULL, NULL); + pthread_mutex_unlock(&mutex); + } else if (name != NULL) { + if (0 > afb_dynapi_broadcast_event(request->dynapi, name, object)) + afb_request_fail(request, "failed", "broadcast error"); + else + afb_request_success(request, NULL, NULL); + } else { + afb_request_fail(request, "failed", "bad arguments"); + } + json_object_put(object); +} + +static void hasperm (afb_request *request) +{ + const char *perm = afb_request_value(request, "perm"); + if (afb_request_has_permission(request, perm)) + afb_request_success_f(request, NULL, "permission %s granted", perm?:"(null)"); + else + afb_request_fail_f(request, "not-granted", "permission %s NOT granted", perm?:"(null)"); +} + +static void appid (afb_request *request) +{ + char *aid = afb_request_get_application_id(request); + afb_request_success_f(request, aid ? json_object_new_string(aid) : NULL, "application is %s", aid?:"?"); + free(aid); +} + +static int init(afb_dynapi *dynapi) +{ + AFB_DYNAPI_NOTICE(dynapi, "dynamic binding AVE(%s) starting", (const char*)dynapi->userdata); + return 0; +} + +static void onevent(afb_dynapi *dynapi, const char *event, struct json_object *object) +{ + AFB_DYNAPI_NOTICE(dynapi, "received event %s(%s) by AVE(%s)", + event, json_object_to_json_string(object), + (const char*)dynapi->userdata); +} + +// NOTE: this sample does not use session to keep test a basic as possible +// in real application most APIs should be protected with AFB_SESSION_CHECK +static const struct { + const char *verb; + void (*callback)(afb_request*); } verbs[] = +{ + { .verb="ping", .callback=pingSample }, + { .verb="pingfail", .callback=pingFail }, + { .verb="pingnull", .callback=pingNull }, + { .verb="pingbug", .callback=pingBug }, + { .verb="pingJson", .callback=pingJson }, + { .verb="pingevent", .callback=pingEvent }, + { .verb="subcall", .callback=subcall }, + { .verb="subcallsync", .callback=subcallsync }, + { .verb="eventadd", .callback=eventadd }, + { .verb="eventdel", .callback=eventdel }, + { .verb="eventsub", .callback=eventsub }, + { .verb="eventunsub", .callback=eventunsub }, + { .verb="eventpush", .callback=eventpush }, + { .verb="call", .callback=call }, + { .verb="callsync", .callback=callsync }, + { .verb="verbose", .callback=verbose }, + { .verb="broadcast", .callback=broadcast }, + { .verb="hasperm", .callback=hasperm }, + { .verb="appid", .callback=appid }, + { .verb="exit", .callback=exitnow }, + { .verb=NULL} +}; + +static const char *apis[] = { "ave", "hi", "salut", NULL }; + +static int api_preinit(void *closure, afb_dynapi *dynapi) +{ + int i, rc; + + dynapi->userdata = closure; + AFB_DYNAPI_NOTICE(dynapi, "dynamic binding AVE(%s) comes to live", (const char*)dynapi->userdata); + afb_dynapi_on_init(dynapi, init); + afb_dynapi_on_event(dynapi, onevent); + + for (i = rc = 0; verbs[i].verb && rc >= 0 ; i++) { + rc = afb_dynapi_add_verb(dynapi, verbs[i].verb, NULL, verbs[i].callback, NULL, 0); + } + afb_dynapi_seal(dynapi); + return rc; +} + +int afbBindingVdyn(afb_dynapi *dynapi) +{ + int i, rc; + + for (i = 0; apis[i] ; i++) { + rc = afb_dynapi_new_api(dynapi, apis[i], NULL, api_preinit, (void*)apis[i]); + } + return 0; +} + diff --git a/include/afb/afb-binding-vdyn.h b/include/afb/afb-binding-vdyn.h index 6e7a0815..a3063a75 100644 --- a/include/afb/afb-binding-vdyn.h +++ b/include/afb/afb-binding-vdyn.h @@ -25,6 +25,14 @@ #include "afb-request.h" #include "afb-dynapi.h" +/* + * The function afbBindingVdyn if exported allows to create + * pure dynamic bindings. When the binding is loaded, it receives + * a virtual dynapi that can be used to create apis. The + * given API can not be used except for creating dynamic apis. + */ +extern int afbBindingVdyn(struct afb_dynapi *dynapi); + /* * Macros for logging messages */ diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 0e05f850..ade02a11 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -36,6 +36,7 @@ ADD_LIBRARY(afb-lib STATIC afb-api-so.c afb-api-so-v1.c afb-api-so-v2.c + afb-api-so-vdyn.c afb-api-ws.c afb-apiset.c afb-auth.c diff --git a/src/afb-api-so-vdyn.c b/src/afb-api-so-vdyn.c new file mode 100644 index 00000000..c2ac2cf2 --- /dev/null +++ b/src/afb-api-so-vdyn.c @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2016, 2017 "IoT.bzh" + * Author José Bollo + * + * 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * 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 +#include + +#include "afb-api-so-vdyn.h" +#include "afb-export.h" +#include "verbose.h" + +/* + * names of symbols + */ +static const char afb_api_so_vdyn_entry[] = "afbBindingVdyn"; + +/* + * Description of a binding + */ +static int vdyn_preinit(void *closure, struct afb_dynapi *dynapi) +{ + int (*entry)(struct afb_dynapi*) = closure; + return entry(dynapi); +} + +int afb_api_so_vdyn_add(const char *path, void *handle, struct afb_apiset *apiset) +{ + int rc; + int (*entry)(void*, struct afb_dynapi*); + struct afb_export *export; + + entry = dlsym(handle, afb_api_so_vdyn_entry); + if (!entry) + return 0; + + INFO("binding [%s] looks like an AFB binding Vdyn", path); + + export = afb_export_create_vdyn(apiset, path, NULL); + if (!export) { + ERROR("can't create export for %s", path); + return -1; + } + + INFO("binding [%s] calling dynamic initialisation %s", path, afb_api_so_vdyn_entry); + rc = afb_export_preinit_vdyn(export, vdyn_preinit, entry); + afb_export_destroy(export); + return rc < 0 ? rc : 1; +} + diff --git a/src/afb-api-so-vdyn.h b/src/afb-api-so-vdyn.h new file mode 100644 index 00000000..90a686a4 --- /dev/null +++ b/src/afb-api-so-vdyn.h @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2016, 2017 "IoT.bzh" + * Author: José Bollo + * + * 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * 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. + */ + + +#pragma once + +struct afb_apiset; + +extern int afb_api_so_vdyn_add(const char *path, void *handle, struct afb_apiset *apiset); diff --git a/src/afb-api-so.c b/src/afb-api-so.c index 3588e163..2a0f9d6e 100644 --- a/src/afb-api-so.c +++ b/src/afb-api-so.c @@ -27,6 +27,7 @@ #include "afb-api-so.h" #include "afb-api-so-v1.h" #include "afb-api-so-v2.h" +#include "afb-api-so-vdyn.h" #include "verbose.h" #include "sig-monitor.h" @@ -83,6 +84,15 @@ static int load_binding(const char *path, int force, struct afb_apiset *apiset) if (rc) return 0; /* yes version 2 */ + /* try the version dyn */ + rc = afb_api_so_vdyn_add(path, handle, apiset); + if (rc < 0) { + /* error when loading a valid dyn binding */ + goto error2; + } + if (rc) + return 0; /* yes version dyn */ + /* try the version 1 */ rc = afb_api_so_v1_add(path, handle, apiset); if (rc < 0) { -- 2.16.6