diff options
Diffstat (limited to 'include/afb')
40 files changed, 4441 insertions, 2157 deletions
diff --git a/include/afb/afb-api-x3-itf.h b/include/afb/afb-api-x3-itf.h new file mode 100644 index 00000000..38b29196 --- /dev/null +++ b/include/afb/afb-api-x3-itf.h @@ -0,0 +1,262 @@ +/* + * Copyright (C) 2016, 2017, 2018 "IoT.bzh" + * Author: José Bollo <jose.bollo@iot.bzh> + * + * 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 + +/* declared here */ +struct afb_api_x3; +struct afb_api_x3_itf; + +/* referenced here */ +struct sd_event; +struct sd_bus; +struct afb_req_x2; +struct afb_event_x2; +struct afb_auth; +struct afb_verb_v2; +struct afb_verb_v3; + +/** + * Structure for the APIv3 + */ +struct afb_api_x3 +{ + /** + * Interface functions + * + * Don't use it directly, prefer helper functions. + */ + const struct afb_api_x3_itf *itf; + + /** + * The name of the api + * + * @see afb_api_x3_name + */ + const char *apiname; + + /** + * User defined data + * + * @see afb_api_x3_set_userdata + * @see afb_api_x3_get_userdata + */ + void *userdata; + + /** + * Current verbosity mask + * + * The bits tells what verbosity is required for the api. + * It is related to the syslog levels. + * + * EMERGENCY 0 System is unusable + * ALERT 1 Action must be taken immediately + * CRITICAL 2 Critical conditions + * ERROR 3 Error conditions + * WARNING 4 Warning conditions + * NOTICE 5 Normal but significant condition + * INFO 6 Informational + * DEBUG 7 Debug-level messages + */ + int logmask; +}; + +/** + * Definition of the function's interface for the APIv3 + */ +struct afb_api_x3_itf +{ + /* CAUTION: respect the order, add at the end */ + + /** sending log messages */ + void (*vverbose)( + struct afb_api_x3 *api, + int level, + const char *file, + int line, + const char * func, + const char *fmt, + va_list args); + + /** gets the common systemd's event loop */ + struct sd_event *(*get_event_loop)( + struct afb_api_x3 *api); + + /** gets the common systemd's user d-bus */ + struct sd_bus *(*get_user_bus)( + struct afb_api_x3 *api); + + /** gets the common systemd's system d-bus */ + struct sd_bus *(*get_system_bus)( + struct afb_api_x3 *api); + + /** get the file descriptor for the root directory */ + int (*rootdir_get_fd)( + struct afb_api_x3 *api); + + /** get a file using locale setting */ + int (*rootdir_open_locale)( + struct afb_api_x3 *api, + const char *filename, + int flags, + const char *locale); + + /** queue a job */ + int (*queue_job)( + struct afb_api_x3 *api, + void (*callback)(int signum, void *arg), + void *argument, + void *group, + int timeout); + + /** requires an api initialized or not */ + int (*require_api)( + struct afb_api_x3 *api, + const char *name, + int initialized); + + /** add an alias */ + int (*add_alias)( + struct afb_api_x3 *api, + const char *name, + const char *as_name); + + /** broadcasts event 'name' with 'object' */ + int (*event_broadcast)( + struct afb_api_x3 *api, + const char *name, + struct json_object *object); + + /** creates an event of 'name' */ + struct afb_event_x2 *(*event_make)( + struct afb_api_x3 *api, + const char *name); + + /** legacy asynchronous invocation */ + void (*legacy_call)( + struct afb_api_x3 *api, + const char *apiname, + const char *verb, + struct json_object *args, + void (*callback)(void*, int, struct json_object*, struct afb_api_x3 *), + void *closure); + + /** legacy synchronous invocation */ + int (*legacy_call_sync)( + struct afb_api_x3 *api, + const char *apiname, + const char *verb, + struct json_object *args, + struct json_object **result); + + /** creation of a new api*/ + struct afb_api_x3 *(*api_new_api)( + struct afb_api_x3 *api, + const char *apiname, + const char *info, + int noconcurrency, + int (*preinit)(void*, struct afb_api_x3 *), + void *closure); + + /** set verbs of the api using v2 description */ + int (*api_set_verbs_v2)( + struct afb_api_x3 *api, + const struct afb_verb_v2 *verbs); + + /** add one verb to the api */ + int (*api_add_verb)( + struct afb_api_x3 *api, + const char *verb, + const char *info, + void (*callback)(struct afb_req_x2 *req), + void *vcbdata, + const struct afb_auth *auth, + uint32_t session, + int glob); + + /** delete one verb of the api */ + int (*api_del_verb)( + struct afb_api_x3 *api, + const char *verb, + void **vcbdata); + + /** set the api's callback for processing events */ + int (*api_set_on_event)( + struct afb_api_x3 *api, + void (*onevent)(struct afb_api_x3 *api, const char *event, struct json_object *object)); + + /** set the api's callback for initialisation */ + int (*api_set_on_init)( + struct afb_api_x3 *api, + int (*oninit)(struct afb_api_x3 *api)); + + /** seal the api */ + void (*api_seal)( + struct afb_api_x3 *api); + + /** set verbs of the api using v3 description */ + int (*api_set_verbs_v3)( + struct afb_api_x3 *api, + const struct afb_verb_v3 *verbs); + + /** add an event handler for the api */ + int (*event_handler_add)( + struct afb_api_x3 *api, + const char *pattern, + void (*callback)(void *, const char*, struct json_object*, struct afb_api_x3*), + void *closure); + + /** delete an event handler of the api */ + int (*event_handler_del)( + struct afb_api_x3 *api, + const char *pattern, + void **closure); + + /** asynchronous call for the api */ + void (*call)( + struct afb_api_x3 *api, + const char *apiname, + const char *verb, + struct json_object *args, + void (*callback)(void*, struct json_object*, const char*, const char*, struct afb_api_x3 *), + void *closure); + + /** synchronous call for the api */ + int (*call_sync)( + struct afb_api_x3 *api, + const char *apiname, + const char *verb, + struct json_object *args, + struct json_object **result, + char **error, + char **info); + + /** indicate provided classes of the api */ + int (*class_provide)( + struct afb_api_x3 *api, + const char *name); + + /** indicate required classes of the api */ + int (*class_require)( + struct afb_api_x3 *api, + const char *name); + + /** delete the api */ + int (*delete_api)( + struct afb_api_x3 *api); +}; + diff --git a/include/afb/afb-api-x3.h b/include/afb/afb-api-x3.h new file mode 100644 index 00000000..81323ef5 --- /dev/null +++ b/include/afb/afb-api-x3.h @@ -0,0 +1,884 @@ +/* + * Copyright (C) 2016, 2017, 2018 "IoT.bzh" + * Author: José Bollo <jose.bollo@iot.bzh> + * + * 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 + +#include "afb-verbosity.h" +#include "afb-api-x3-itf.h" + +/** + * Get the name of the 'api'. + * + * @param api the api whose name is to be returned + * + * @return the name of the api. + * + * The returned value must not be changed nor freed. + */ +static inline +const char *afb_api_x3_name(struct afb_api_x3 *api) +{ + return api->apiname; +} + +/** + * Get the "userdata" pointer of the 'api' + * + * @param api the api whose user's data is to be returned + * + * @return the user's data pointer of the api. + * + * @see afb_api_x3_set_userdata + */ +static inline +void *afb_api_x3_get_userdata(struct afb_api_x3 *api) +{ + return api->userdata; +} + +/** + * Set the "userdata" pointer of the 'api' to 'value' + * + * @param api the api whose user's data is to be set + * @param value the data to set + * + * @see afb_api_x3_get_userdata + */ +static inline +void afb_api_x3_set_userdata(struct afb_api_x3 *api, void *value) +{ + api->userdata = value; +} + +/** + * Is the log message of 'level (as defined for syslog) required for the api? + * + * @param api the api to check + * @param level the level to check as defined for syslog: + * + * EMERGENCY 0 System is unusable + * ALERT 1 Action must be taken immediately + * CRITICAL 2 Critical conditions + * ERROR 3 Error conditions + * WARNING 4 Warning conditions + * NOTICE 5 Normal but significant condition + * INFO 6 Informational + * DEBUG 7 Debug-level messages + * + * @return 0 if not required or a value not null if required + * + * @see syslog + */ +static inline +int afb_api_x3_wants_log_level(struct afb_api_x3 *api, int level) +{ + return AFB_SYSLOG_MASK_WANT(api->logmask, level); +} + +/** + * Send to the journal with the log 'level' a message described + * by 'fmt' applied to the va-list 'args'. + * + * 'file', 'line' and 'func' are indicators of position of the code in source files + * (see macros __FILE__, __LINE__ and __func__). + * + * 'level' is defined by syslog standard: + * + * EMERGENCY 0 System is unusable + * ALERT 1 Action must be taken immediately + * CRITICAL 2 Critical conditions + * ERROR 3 Error conditions + * WARNING 4 Warning conditions + * NOTICE 5 Normal but significant condition + * INFO 6 Informational + * DEBUG 7 Debug-level messages + * + * @param api the api that collects the logging message + * @param level the level of the message + * @param file the source file that logs the messages or NULL + * @param line the line in the source file that logs the message + * @param func the name of the function in the source file that logs + * @param fmt the format of the message as in printf + * @param args the arguments to the format string of the message as a va_list + * + * @see syslog + * @see printf + */ +static inline +void afb_api_x3_vverbose(struct afb_api_x3 *api, int level, const char *file, int line, const char *func, const char *fmt, va_list args) +{ + api->itf->vverbose(api, level, file, line, func, fmt, args); +} + +/** + * Send to the journal with the log 'level' a message described + * by 'fmt' and following parameters. + * + * 'file', 'line' and 'func' are indicators of position of the code in source files + * (see macros __FILE__, __LINE__ and __func__). + * + * 'level' is defined by syslog standard: + * EMERGENCY 0 System is unusable + * ALERT 1 Action must be taken immediately + * CRITICAL 2 Critical conditions + * ERROR 3 Error conditions + * WARNING 4 Warning conditions + * NOTICE 5 Normal but significant condition + * INFO 6 Informational + * DEBUG 7 Debug-level messages + * + * @param api the api that collects the logging message + * @param level the level of the message + * @param file the source file that logs the messages or NULL + * @param line the line in the source file that logs the message + * @param func the name of the function in the source file that logs + * @param fmt the format of the message as in printf + * @param ... the arguments to the format string of the message + * + * @see syslog + * @see printf + */ +__attribute__((format(printf, 6, 7))) +static inline +void afb_api_x3_verbose( + struct afb_api_x3 *api, + int level, + const char *file, + int line, + const char *func, + const char *fmt, + ...) +{ + va_list args; + va_start(args, fmt); + api->itf->vverbose(api, level, file, line, func, fmt, args); + va_end(args); +} + +/** + * Retrieves the common systemd's event loop of AFB + * + * @param api the api that uses the event loop + * + * @return the systemd event loop if active, NULL otherwise + * + * @see afb_api_x3_get_user_bus + * @see afb_api_x3_get_system_bus + */ +static inline +struct sd_event *afb_api_x3_get_event_loop(struct afb_api_x3 *api) +{ + return api->itf->get_event_loop(api); +} + +/** + * Retrieves the common systemd's user/session d-bus of AFB + * + * @param api the api that uses the user dbus + * + * @return the systemd user connection to dbus if active, NULL otherwise + * + * @see afb_api_x3_get_event_loop + * @see afb_api_x3_get_system_bus + */ +static inline +struct sd_bus *afb_api_x3_get_user_bus(struct afb_api_x3 *api) +{ + return api->itf->get_user_bus(api); +} + +/** + * Retrieves the common systemd's system d-bus of AFB + * + * @param api the api that uses the system dbus + * + * @return the systemd system connection to dbus if active, NULL otherwise + * + * @see afb_api_x3_get_event_loop + * @see afb_api_x3_get_user_bus + */ + +static inline +struct sd_bus *afb_api_x3_get_system_bus(struct afb_api_x3 *api) +{ + return api->itf->get_system_bus(api); +} + +/** + * Get the root directory file descriptor. This file descriptor can + * be used with functions 'openat', 'fstatat', ... + * + * CAUTION, manipulate this this descriptor with care, in particular, don't close + * it. + * + * This can be used to get the path of the root directory using: + * + * ```C + * char buffer[MAX_PATH]; + * int dirfd = afb_api_x3_rootdir_get_fd(api); + * snprintf(buffer, sizeof buffer, "/proc/self/fd/%d", dirfd); + * readlink(buffer, buffer, sizeof buffer); + * ``` + * + * But note that within AGL this is the value given by the environment variable + * AFM_APP_INSTALL_DIR. + * + * @param api the api that uses the directory file descriptor + * + * @return the file descriptor of the root directory. + * + * @see afb_api_x3_rootdir_open_locale + */ +static inline +int afb_api_x3_rootdir_get_fd(struct afb_api_x3 *api) +{ + return api->itf->rootdir_get_fd(api); +} + +/** + * Opens 'filename' within the root directory with 'flags' (see function openat) + * using the 'locale' definition (example: "jp,en-US") that can be NULL. + * + * The filename must be relative to the root of the bindings. + * + * The opening mode must be for read or write but not for O_CREAT. + * + * The definition of locales and of how files are searched can be checked + * here: https://www.w3.org/TR/widgets/#folder-based-localization + * and https://tools.ietf.org/html/rfc7231#section-5.3.5 + * + * @param api the api that queries the file + * @param filename the relative path to the file to open + * @param flags the flags for opening as for C function 'open' + * @param locale string indicating how to search content, can be NULL + * + * @return the file descriptor or -1 in case of error and errno is set with the + * error indication. + * + * @see open + * @see afb_api_x3_rootdir_get_fd + */ +static inline +int afb_api_x3_rootdir_open_locale(struct afb_api_x3 *api, const char *filename, int flags, const char *locale) +{ + return api->itf->rootdir_open_locale(api, filename, flags, locale); +} + +/** + * Queue the job defined by 'callback' and 'argument' for being executed asynchronously + * in this thread (later) or in an other thread. + * + * If 'group' is not NULL, the jobs queued with a same value (as the pointer value 'group') + * are executed in sequence in the order of there submission. + * + * If 'timeout' is not 0, it represent the maximum execution time for the job in seconds. + * At first, the job is called with 0 as signum and the given argument. + * + * The job is executed with the monitoring of its time and some signals like SIGSEGV and + * SIGFPE. When a such signal is catched, the job is terminated and reexecuted but with + * signum being the signal number (SIGALRM when timeout expired). + * + * When executed, the callback function receives 2 arguments: + * + * - int signum: the signal catched if any or zero at the beginning + * - void *arg: the parameter 'argument' + * + * A typical implmentation of the job callback is: + * + * ```C + * void my_job_cb(int signum, void *arg) + * { + * struct myarg_t *myarg = arg; + * if (signum) + * AFB_API_ERROR(myarg->api, "job interupted with signal %s", strsignal(signum)); + * else + * really_do_my_job(myarg); + * } + * ``` + * + * @param api the api that queue the job + * @param callback the job as a callback function + * @param argument the argument to pass to the queued job + * @param group the group of the job, NULL if no group + * @param timeout the timeout of execution of the job + * + * @return 0 in case of success or -1 in case of error with errno set appropriately. + */ +static inline +int afb_api_x3_queue_job(struct afb_api_x3 *api, void (*callback)(int signum, void *arg), void *argument, void *group, int timeout) +{ + return api->itf->queue_job(api, callback, argument, group, timeout); +} + +/** + * Tells that it requires the API of "name" to exist + * and if 'initialized' is not null to be initialized. + * Calling this function is only allowed within init. + * + * A single request allows to require multiple apis. + * + * @param api the api that requires the other api by its name + * @param name a space separated list of the names of the required api + * @param initialized if zero, the api is just required to exist. If not zero, + * the api is required to exist and to be initialized. + * + * @return 0 in case of success or -1 in case of error with errno set appropriately. + */ +static inline +int afb_api_x3_require_api(struct afb_api_x3 *api, const char *name, int initialized) +{ + return api->itf->require_api(api, name, initialized); +} + +/** + * Create an aliased name 'as_name' for the api 'name'. + * Calling this function is only allowed within preinit. + * + * @param api the api that requires the aliasing + * @param name the api to alias + * @param as_name the aliased name of the aliased api + * + * @return 0 in case of success or -1 in case of error with errno set appropriately. + */ +static inline +int afb_api_x3_add_alias(struct afb_api_x3 *api, const char *name, const char *as_name) +{ + return api->itf->add_alias(api, name, as_name); +} + +/** + * Broadcasts widely the event of 'name' with the data 'object'. + * 'object' can be NULL. + * + * For convenience, the function calls 'json_object_put' for 'object'. + * Thus, in the case where 'object' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * Calling this function is only forbidden during preinit. + * + * The event sent as the name API/name where API is the name of the + * api. + * + * @param api the api that broadcast the event + * @param name the event name suffix + * @param object the object that comes with the event + * + * @return the count of clients that received the event. + */ +static inline +int afb_api_x3_broadcast_event(struct afb_api_x3 *api, const char *name, struct json_object *object) +{ + return api->itf->event_broadcast(api, name, object); +} + +/** + * Creates an event of 'name' and returns it. + * + * Calling this function is only forbidden during preinit. + * + * See afb_event_is_valid to check if there is an error. + * + * The event created as the name API/name where API is the name of the + * api. + * + * @param api the api that creates the event + * @param name the event name suffix + * + * @return the created event. Use the function afb_event_is_valid to check + * whether the event is valid (created) or not (error as reported by errno). + * + * @see afb_event_is_valid + */ +static inline +struct afb_event_x2 *afb_api_x3_make_event_x2(struct afb_api_x3 *api, const char *name) +{ + return api->itf->event_make(api, name); +} + +/** + * @deprecated try to use @ref afb_api_x3_call instead + * + * * Calls the 'verb' of the 'api' with the arguments 'args' and 'verb' in the name of the binding. + * The result of the call is delivered to the 'callback' function with the 'callback_closure'. + * + * For convenience, the function calls 'json_object_put' for 'args'. + * Thus, in the case where 'args' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * The 'callback' receives 3 arguments: + * 1. 'closure' the user defined closure pointer 'closure', + * 2. 'status' a status being 0 on success or negative when an error occurred, + * 2. 'result' the resulting data as a JSON object. + * + * @param api The api + * @param apiname The api name of the method to call + * @param verb The verb name of the method to call + * @param args The arguments to pass to the method + * @param callback The to call on completion + * @param closure The closure to pass to the callback + * + * @see also 'afb_api_call' + * @see also 'afb_api_call_sync' + * @see also 'afb_api_call_sync_legacy' + * @see also 'afb_req_subcall' + * @see also 'afb_req_subcall_sync' + */ +static inline +void afb_api_x3_call_legacy( + struct afb_api_x3 *api, + const char *apiname, + const char *verb, + struct json_object *args, + void (*callback)(void *closure, int status, struct json_object *result, struct afb_api_x3 *api), + void *closure) +{ + api->itf->legacy_call(api, apiname, verb, args, callback, closure); +} + +/** + * @deprecated try to use @ref afb_api_x3_call_sync instead + * + * Calls the 'verb' of the 'api' with the arguments 'args' and 'verb' in the name of the binding. + * 'result' will receive the response. + * + * For convenience, the function calls 'json_object_put' for 'args'. + * Thus, in the case where 'args' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * @param api The api + * @param apiname The api name of the method to call + * @param verb The verb name of the method to call + * @param args The arguments to pass to the method + * @param result Where to store the result - should call json_object_put on it - + * + * @returns 0 in case of success or a negative value in case of error. + * + * @see also 'afb_api_call' + * @see also 'afb_api_call_sync' + * @see also 'afb_api_call_legacy' + * @see also 'afb_req_subcall' + * @see also 'afb_req_subcall_sync' + */ +static inline +int afb_api_x3_call_sync_legacy( + struct afb_api_x3 *api, + const char *apiname, + const char *verb, + struct json_object *args, + struct json_object **result) +{ + return api->itf->legacy_call_sync(api, apiname, verb, args, result); +} + +/** + * Creates a new api of name 'apiname' briefly described by 'info' (that can + * be NULL). + * + * When the pre-initialization function is given, it is a function that + * receives 2 parameters: + * + * - the closure as given in the call + * - the created api that can be initialised + * + * This pre-initialization function must return a negative value to abort + * the creation of the api. Otherwise, it returns a non-negative value to + * continue. + * + * @param api the api that creates the other one + * @param apiname the name of the new api + * @param info the brief description of the new api (can be NULL) + * @param noconcurrency zero or not zero whether the new api is reentrant or not + * @param preinit the pre-initialization function if any (can be NULL) + * @param closure the closure for the pre-initialization \ref preinit + * + * @return 0 in case of success or -1 on failure with errno set + * + * @see afb_api_x3_delete_api + */ +static inline +struct afb_api_x3 *afb_api_x3_new_api( + struct afb_api_x3 *api, + const char *apiname, + const char *info, + int noconcurrency, + int (*preinit)(void*, struct afb_api_x3 *), + void *closure) +{ + return api->itf->api_new_api(api, apiname, info, noconcurrency, preinit, closure); +} + +/** + * @deprecated use @ref afb_api_x3_set_verbs_v3 instead + * + * Set the verbs of the 'api' using description of verbs of the api v2 + * + * @param api the api that will get the verbs + * @param verbs the array of verbs to add terminated with an item with name=NULL + * + * @return 0 in case of success or -1 on failure with errno set + * + * @see afb_verb_v2 + * @see afb_api_x3_add_verb + * @see afb_api_x3_set_verbs_v3 + */ +static inline +int afb_api_x3_set_verbs_v2( + struct afb_api_x3 *api, + const struct afb_verb_v2 *verbs) +{ + return api->itf->api_set_verbs_v2(api, verbs); +} + +/** + * Add one verb to the dynamic set of the api + * + * @param api the api to change + * @param verb name of the verb + * @param info brief description of the verb, can be NULL + * @param callback callback function implementing the verb + * @param vcbdata data for the verb callback, available through req + * @param auth required authorization, can be NULL + * @param session authorization and session requirements of the verb + * @param glob is the verb glob name + * + * @return 0 in case of success or -1 on failure with errno set + * + * @see afb_verb_v3 + * @see afb_api_x3_del_verb + * @see afb_api_x3_set_verbs_v3 + * @see fnmatch for matching names using glob + */ +static inline +int afb_api_x3_add_verb( + struct afb_api_x3 *api, + const char *verb, + const char *info, + void (*callback)(struct afb_req_x2 *req), + void *vcbdata, + const struct afb_auth *auth, + uint32_t session, + int glob) +{ + return api->itf->api_add_verb(api, verb, info, callback, vcbdata, auth, session, glob); +} + +/** + * Delete one verb from the dynamic set of the api + * + * @param api the api to change + * @param verb name of the verb to delete + * @param vcbdata if not NULL will receive the vcbdata of the deleted verb + * + * @return 0 in case of success or -1 on failure with errno set + * + * @see afb_api_x3_add_verb + */ +static inline +int afb_api_x3_del_verb( + struct afb_api_x3 *api, + const char *verb, + void **vcbdata) +{ + return api->itf->api_del_verb(api, verb, vcbdata); +} + +/** + * Set the callback 'onevent' to process events in the name of the 'api'. + * + * This setting can be done statically using the global variable + * @ref afbBindingV3. + * + * This function replace any previously global event callback set. + * + * When an event is received, the callback 'onevent' is called with 3 parameters + * + * - the api that recorded the event handler + * - the full name of the event + * - the companion JSON object of the event + * + * @param api the api that wants to process events + * @param onevent the callback function that will process events (can be NULL + * to remove event callback) + * + * @return 0 in case of success or -1 on failure with errno set + * + * @see afbBindingV3 + * @see afb_binding_v3 + * @see afb_api_x3_event_handler_add + * @see afb_api_x3_event_handler_del + */ +static inline +int afb_api_x3_on_event( + struct afb_api_x3 *api, + void (*onevent)(struct afb_api_x3 *api, const char *event, struct json_object *object)) +{ + return api->itf->api_set_on_event(api, onevent); +} + +/** + * Set the callback 'oninit' to process initialization of the 'api'. + * + * This setting can be done statically using the global variable + * @ref afbBindingV3 + * + * This function replace any previously initialization callback set. + * + * This function is only valid during the pre-initialization stage. + * + * The callback initialization function will receive one argument: the api + * to initialize. + * + * @param api the api that wants to process events + * @param oninit the callback function that initialize the api + * + * @return 0 in case of success or -1 on failure with errno set + * + * @see afbBindingV3 + * @see afb_binding_v3 + */ +static inline +int afb_api_x3_on_init( + struct afb_api_x3 *api, + int (*oninit)(struct afb_api_x3 *api)) +{ + return api->itf->api_set_on_init(api, oninit); +} + +/** + * Seal the api. After a call to this function the api can not be modified + * anymore. + * + * @param api the api to be sealed + */ +static inline +void afb_api_x3_seal( + struct afb_api_x3 *api) +{ + api->itf->api_seal(api); +} + +/** + * Set the verbs of the 'api' using description of verbs of the api v2 + * + * @param api the api that will get the verbs + * @param verbs the array of verbs to add terminated with an item with name=NULL + * + * @return 0 in case of success or -1 on failure with errno set + * + * @see afb_verb_v3 + * @see afb_api_x3_add_verb + * @see afb_api_x3_del_verb + */ +static inline +int afb_api_x3_set_verbs_v3( + struct afb_api_x3 *api, + const struct afb_verb_v3 *verbs) +{ + return api->itf->api_set_verbs_v3(api, verbs); +} + +/** + * Add a specific event handler for the api + * + * The handler callback is called when an event matching the given pattern + * is received (it is received if broadcasted or after subscription through + * a call or a subcall). + * + * The handler callback receive 4 arguments: + * + * - the closure given here + * - the event full name + * - the companion JSON object of the event + * - the api that subscribed the event + * + * @param api the api that creates the handler + * @param pattern the global pattern of the event to handle + * @param callback the handler callback function + * @param closure the closure of the handler + * + * @return 0 in case of success or -1 on failure with errno set + * + * @see afb_api_x3_on_event + * @see afb_api_x3_event_handler_del + */ +static inline +int afb_api_x3_event_handler_add( + struct afb_api_x3 *api, + const char *pattern, + void (*callback)(void *, const char*, struct json_object*, struct afb_api_x3*), + void *closure) +{ + return api->itf->event_handler_add(api, pattern, callback, closure); +} + +/** + * Delete a specific event handler for the api + * + * @param api the api that the handler belongs to + * @param pattern the global pattern of the handler to remove + * @param closure if not NULL it will receive the closure set to the handler + * + * @return 0 in case of success or -1 on failure with errno set + * + * @see afb_api_x3_on_event + * @see afb_api_x3_event_handler_add + */ +static inline +int afb_api_x3_event_handler_del( + struct afb_api_x3 *api, + const char *pattern, + void **closure) +{ + return api->itf->event_handler_del(api, pattern, closure); +} + +/** + * Calls the 'verb' of the 'api' with the arguments 'args' and 'verb' in the name of the binding. + * The result of the call is delivered to the 'callback' function with the 'callback_closure'. + * + * For convenience, the function calls 'json_object_put' for 'args'. + * Thus, in the case where 'args' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * The 'callback' receives 5 arguments: + * 1. 'closure' the user defined closure pointer 'closure', + * 2. 'object' a JSON object returned (can be NULL) + * 3. 'error' a string not NULL in case of error but NULL on success + * 4. 'info' a string handling some info (can be NULL) + * 5. 'api' the api + * + * @param api The api that makes the call + * @param apiname The api name of the method to call + * @param verb The verb name of the method to call + * @param args The arguments to pass to the method + * @param callback The to call on completion + * @param closure The closure to pass to the callback + * + * + * @see afb_req_subcall + * @see afb_req_subcall_sync + * @see afb_api_x3_call_sync + */ +static inline +void afb_api_x3_call( + struct afb_api_x3 *api, + const char *apiname, + const char *verb, + struct json_object *args, + void (*callback)(void *closure, struct json_object *object, const char *error, const char * info, struct afb_api_x3 *api), + void *closure) +{ + api->itf->call(api, apiname, verb, args, callback, closure); +} + +/** + * Calls the 'verb' of the 'api' with the arguments 'args' and 'verb' in the name of the binding. + * 'result' will receive the response. + * + * For convenience, the function calls 'json_object_put' for 'args'. + * Thus, in the case where 'args' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * @param api The api that makes the call + * @param apiname The api name of the method to call + * @param verb The verb name of the method to call + * @param args The arguments to pass to the method + * @param object Where to store the returned object - should call json_object_put on it - can be NULL + * @param error Where to store the copied returned error - should call free on it - can be NULL + * @param info Where to store the copied returned info - should call free on it - can be NULL + * + * @returns 0 in case of success or a negative value in case of error. + * + * @see afb_req_subcall + * @see afb_req_subcall_sync + * @see afb_api_x3_call + */ +static inline +int afb_api_x3_call_sync( + struct afb_api_x3 *api, + const char *apiname, + const char *verb, + struct json_object *args, + struct json_object **object, + char **error, + char **info) +{ + return api->itf->call_sync(api, apiname, verb, args, object, error, info); +} + +/** + * Tells that the api provides a class of features. Classes are intended to + * allow ordering of initializations: apis that provides a given class are + * initialized before apis requiring it. + * + * This function is only valid during the pre-initialization stage. + * + * @param api the api that provides the classes + * @param name a space separated list of the names of the provided classes + * + * @returns 0 in case of success or a negative value in case of error. + * + * @see afb_api_x3_require_class + */ +static inline +int afb_api_x3_provide_class( + struct afb_api_x3 *api, + const char *name) +{ + return api->itf->class_provide(api, name); +} + +/** + * Tells that the api requires a set of class features. Classes are intended to + * allow ordering of initializations: apis that provides a given class are + * initialized before apis requiring it. + * + * This function is only valid during the pre-initialization stage. + * + * @param api the api that requires the classes + * @param name a space separated list of the names of the requireded classes + * + * @returns 0 in case of success or a negative value in case of error. + * + * @see afb_api_x3_provide_class + */ +static inline +int afb_api_x3_require_class( + struct afb_api_x3 *api, + const char *name) +{ + return api->itf->class_require(api, name); +} + +/** + * Delete the given api. + * + * It is of the responsibility of the caller to don't used the deleted api + * anymore after this function returned. + * + * @param api the api to delete + * + * @returns 0 in case of success or a negative value in case of error. + * + * @see afb_api_x3_new_api + */ +static inline +int afb_api_x3_delete_api( + struct afb_api_x3 *api) +{ + return api->itf->delete_api(api); +} diff --git a/include/afb/afb-arg.h b/include/afb/afb-arg.h new file mode 100644 index 00000000..de3fb9b5 --- /dev/null +++ b/include/afb/afb-arg.h @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2016, 2017, 2018 "IoT.bzh" + * Author: José Bollo <jose.bollo@iot.bzh> + * + * 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 + +/** + * Describes an argument (or parameter) of a request. + * + * @see afb_req_get + */ +struct afb_arg +{ + const char *name; /**< name of the argument or NULL if invalid */ + const char *value; /**< string representation of the value of the argument */ + /**< original filename of the argument if path != NULL */ + const char *path; /**< if not NULL, path of the received file for the argument */ + /**< when the request is finalized this file is removed */ +}; + diff --git a/include/afb/afb-auth.h b/include/afb/afb-auth.h index da4f8be8..3ce78666 100644 --- a/include/afb/afb-auth.h +++ b/include/afb/afb-auth.h @@ -17,29 +17,58 @@ #pragma once -/* - * Enum for Session/Token/Assurance middleware. +/** + * Enumeration for authority (Session/Token/Assurance) definitions. + * + * @see afb_auth */ enum afb_auth_type { - afb_auth_No = 0, /** never authorized, no data */ - afb_auth_Token, /** authorized if token valid, no data */ - afb_auth_LOA, /** authorized if LOA greater than data 'loa' */ - afb_auth_Permission, /** authorized if permission 'text' is granted */ - afb_auth_Or, /** authorized if 'first' or 'next' is authorized */ - afb_auth_And, /** authorized if 'first' and 'next' are authorized */ - afb_auth_Not, /** authorized if 'first' is not authorized */ - afb_auth_Yes /** always authorized, no data */ + /** never authorized, no data */ + afb_auth_No = 0, + + /** authorized if token valid, no data */ + afb_auth_Token, + + /** authorized if LOA greater than data 'loa' */ + afb_auth_LOA, + + /** authorized if permission 'text' is granted */ + afb_auth_Permission, + + /** authorized if 'first' or 'next' is authorized */ + afb_auth_Or, + + /** authorized if 'first' and 'next' are authorized */ + afb_auth_And, + + /** authorized if 'first' is not authorized */ + afb_auth_Not, + + /** always authorized, no data */ + afb_auth_Yes }; +/** + * Definition of an authorization entry + */ struct afb_auth { + /** type of entry @see afb_auth_type */ enum afb_auth_type type; + union { + /** text when @ref type == @ref afb_auth_Permission */ const char *text; + + /** level of assurancy when @ref type == @ref afb_auth_LOA */ unsigned loa; + + /** first child when @ref type in { @ref afb_auth_Or, @ref afb_auth_And, @ref afb_auth_Not } */ const struct afb_auth *first; }; + + /** second child when @ref type in { @ref afb_auth_Or, @ref afb_auth_And } */ const struct afb_auth *next; }; diff --git a/include/afb/afb-binding-postdefs.h b/include/afb/afb-binding-postdefs.h new file mode 100644 index 00000000..93cd46ef --- /dev/null +++ b/include/afb/afb-binding-postdefs.h @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2018 "IoT.bzh" + * Author: José Bollo <jose.bollo@iot.bzh> + * + * 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 + +typedef enum afb_auth_type afb_auth_type_t; +typedef struct afb_auth afb_auth_t; +typedef struct afb_arg afb_arg_t; + +#if AFB_BINDING_VERSION == 1 + +typedef struct afb_verb_desc_v1 afb_verb_t; +typedef struct afb_binding_v1 afb_binding_t; +typedef struct afb_binding_interface_v1 afb_binding_interface_v1; + +typedef struct afb_daemon_x1 afb_daemon_t; +typedef struct afb_service_x1 afb_service_t; + +typedef struct afb_event_x1 afb_event_t; +typedef struct afb_req_x1 afb_req_t; + +typedef struct afb_stored_req afb_stored_req_t; + +#ifndef __cplusplus +typedef struct afb_event_x1 afb_event; +typedef struct afb_req_x1 afb_req; +typedef struct afb_stored_req afb_stored_req; +#endif + +#endif + +#if AFB_BINDING_VERSION == 2 + +typedef struct afb_verb_v2 afb_verb_t; +typedef struct afb_binding_v2 afb_binding_t; + +typedef struct afb_daemon afb_daemon_t; +typedef struct afb_event afb_event_t; +typedef struct afb_req afb_req_t; +typedef struct afb_stored_req afb_stored_req_t; +typedef struct afb_service afb_service_t; + +#define afbBindingExport afbBindingV2 + +#ifndef __cplusplus +typedef struct afb_verb_v2 afb_verb_v2; +typedef struct afb_binding_v2 afb_binding_v2; +typedef struct afb_event_x1 afb_event; +typedef struct afb_req_x1 afb_req; +typedef struct afb_stored_req afb_stored_req; +#endif + +#endif + +#if AFB_BINDING_VERSION == 3 + +typedef struct afb_verb_v3 afb_verb_t; +typedef struct afb_binding_v3 afb_binding_t; + +typedef struct afb_event_x2 *afb_event_t; +typedef struct afb_req_x2 *afb_req_t; +typedef struct afb_api_x3 *afb_api_t; + +#define afbBindingExport afbBindingV3 + +/* compatibility with previous versions */ + +typedef struct afb_api_x3 *afb_daemon_t; +typedef struct afb_api_x3 *afb_service_t; + +#endif + + +#if defined(AFB_BINDING_WANT_DYNAPI) +typedef struct afb_dynapi *afb_dynapi_t; +typedef struct afb_request *afb_request_t; +typedef struct afb_eventid *afb_eventid_t; +#endif
\ No newline at end of file diff --git a/include/afb/afb-binding-predefs.h b/include/afb/afb-binding-predefs.h new file mode 100644 index 00000000..f1765edb --- /dev/null +++ b/include/afb/afb-binding-predefs.h @@ -0,0 +1,372 @@ +/* + * Copyright (C) 2018 "IoT.bzh" + * Author: José Bollo <jose.bollo@iot.bzh> + * + * 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 + +/******************************************************************************/ + +#if AFB_BINDING_VERSION == 1 || AFB_BINDING_VERSION == 2 + +#define afb_req afb_req_x1 +#define afb_req_is_valid afb_req_x1_is_valid +#define afb_req_get afb_req_x1_get +#define afb_req_value afb_req_x1_value +#define afb_req_path afb_req_x1_path +#define afb_req_json afb_req_x1_json +#define afb_req_reply afb_req_x1_reply +#define afb_req_reply_f afb_req_x1_reply_f +#define afb_req_reply_v afb_req_x1_reply_v +#define afb_req_success(r,o,i) afb_req_x1_reply(r,o,0,i) +#define afb_req_success_f(r,o,...) afb_req_x1_reply_f(r,o,0,__VA_ARGS__) +#define afb_req_success_v(r,o,f,v) afb_req_x1_reply_v(r,o,0,f,v) +#define afb_req_fail(r,e,i) afb_req_x1_reply(r,0,e,i) +#define afb_req_fail_f(r,e,...) afb_req_x1_reply_f(r,0,e,__VA_ARGS__) +#define afb_req_fail_v(r,e,f,v) afb_req_x1_reply_v(r,0,e,f,v) +#define afb_req_context_get afb_req_x1_context_get +#define afb_req_context_set afb_req_x1_context_set +#define afb_req_context afb_req_x1_context +#define afb_req_context_make afb_req_x1_context_make +#define afb_req_context_clear afb_req_x1_context_clear +#define afb_req_addref afb_req_x1_addref +#define afb_req_unref afb_req_x1_unref +#define afb_req_session_close afb_req_x1_session_close +#define afb_req_session_set_LOA afb_req_x1_session_set_LOA +#define afb_req_subscribe afb_req_x1_subscribe +#define afb_req_unsubscribe afb_req_x1_unsubscribe +#define afb_req_subcall afb_req_x1_subcall +#define afb_req_subcall_req afb_req_x1_subcall_req +#define afb_req_subcall_sync afb_req_x1_subcall_sync +#define afb_req_verbose afb_req_x1_verbose +#define afb_req_has_permission afb_req_x1_has_permission +#define afb_req_get_application_id afb_req_x1_get_application_id +#define afb_req_get_uid afb_req_x1_get_uid +#define afb_req_get_client_info afb_req_x1_get_client_info + +#define afb_event afb_event_x1 +#define afb_event_to_event_x2 afb_event_x1_to_event_x2 +#define afb_event_is_valid afb_event_x1_is_valid +#define afb_event_broadcast afb_event_x1_broadcast +#define afb_event_push afb_event_x1_push +#define afb_event_drop afb_event_x1_unref +#define afb_event_name afb_event_x1_name +#define afb_event_unref afb_event_x1_unref +#define afb_event_addref afb_event_x1_addref + +#define afb_service afb_service_x1 +#define afb_daemon afb_daemon_x1 + +#define _AFB_SYSLOG_LEVEL_EMERGENCY_ AFB_SYSLOG_LEVEL_EMERGENCY +#define _AFB_SYSLOG_LEVEL_ALERT_ AFB_SYSLOG_LEVEL_ALERT +#define _AFB_SYSLOG_LEVEL_CRITICAL_ AFB_SYSLOG_LEVEL_CRITICAL +#define _AFB_SYSLOG_LEVEL_ERROR_ AFB_SYSLOG_LEVEL_ERROR +#define _AFB_SYSLOG_LEVEL_WARNING_ AFB_SYSLOG_LEVEL_WARNING +#define _AFB_SYSLOG_LEVEL_NOTICE_ AFB_SYSLOG_LEVEL_NOTICE +#define _AFB_SYSLOG_LEVEL_INFO_ AFB_SYSLOG_LEVEL_INFO +#define _AFB_SYSLOG_LEVEL_DEBUG_ AFB_SYSLOG_LEVEL_DEBUG + +#endif + +/******************************************************************************/ +#if AFB_BINDING_VERSION == 1 + +#define afb_req_store afb_req_x1_store_v1 +#define afb_req_unstore afb_req_x1_unstore_v1 + +#define afb_binding afb_binding_v1 +#define afb_binding_interface afb_binding_interface_v1 + +#define afb_daemon_get_event_loop afb_daemon_get_event_loop_v1 +#define afb_daemon_get_user_bus afb_daemon_get_user_bus_v1 +#define afb_daemon_get_system_bus afb_daemon_get_system_bus_v1 +#define afb_daemon_broadcast_event afb_daemon_broadcast_event_v1 +#define afb_daemon_make_event afb_daemon_make_event_v1 +#define afb_daemon_verbose afb_daemon_verbose_v1 +#define afb_daemon_rootdir_get_fd afb_daemon_rootdir_get_fd_v1 +#define afb_daemon_rootdir_open_locale afb_daemon_rootdir_open_locale_v1 +#define afb_daemon_queue_job afb_daemon_queue_job_v1 +#define afb_daemon_require_api afb_daemon_require_api_v1 +#define afb_daemon_rename_api afb_daemon_add_alias_v1 + +#define afb_service_call afb_service_call_v1 +#define afb_service_call_sync afb_service_call_sync_v1 + +# define AFB_ERROR AFB_ERROR_V1 +# define AFB_WARNING AFB_WARNING_V1 +# define AFB_NOTICE AFB_NOTICE_V1 +# define AFB_INFO AFB_INFO_V1 +# define AFB_DEBUG AFB_DEBUG_V1 + +# define AFB_REQ_ERROR AFB_REQ_ERROR_V1 +# define AFB_REQ_WARNING AFB_REQ_WARNING_V1 +# define AFB_REQ_NOTICE AFB_REQ_NOTICE_V1 +# define AFB_REQ_INFO AFB_REQ_INFO_V1 +# define AFB_REQ_DEBUG AFB_REQ_DEBUG_V1 + +#define AFB_REQ_VERBOSE AFB_REQ_VERBOSE_V1 + +# define AFB_SESSION_NONE AFB_SESSION_NONE_X1 +# define AFB_SESSION_CREATE AFB_SESSION_CREATE_X1 +# define AFB_SESSION_CLOSE AFB_SESSION_CLOSE_X1 +# define AFB_SESSION_RENEW AFB_SESSION_RENEW_X1 +# define AFB_SESSION_CHECK AFB_SESSION_CHECK_X1 + +# define AFB_SESSION_LOA_GE AFB_SESSION_LOA_GE_X1 +# define AFB_SESSION_LOA_LE AFB_SESSION_LOA_LE_X1 +# define AFB_SESSION_LOA_EQ AFB_SESSION_LOA_EQ_X1 + +# define AFB_SESSION_LOA_SHIFT AFB_SESSION_LOA_SHIFT_X1 +# define AFB_SESSION_LOA_MASK AFB_SESSION_LOA_MASK_X1 + +# define AFB_SESSION_LOA_0 AFB_SESSION_LOA_0_X1 +# define AFB_SESSION_LOA_1 AFB_SESSION_LOA_1_X1 +# define AFB_SESSION_LOA_2 AFB_SESSION_LOA_2_X1 +# define AFB_SESSION_LOA_3 AFB_SESSION_LOA_3_X1 +# define AFB_SESSION_LOA_4 AFB_SESSION_LOA_4_X1 + +# define AFB_SESSION_LOA_LE_0 AFB_SESSION_LOA_LE_0_X1 +# define AFB_SESSION_LOA_LE_1 AFB_SESSION_LOA_LE_1_X1 +# define AFB_SESSION_LOA_LE_2 AFB_SESSION_LOA_LE_2_X1 +# define AFB_SESSION_LOA_LE_3 AFB_SESSION_LOA_LE_3_X1 + +# define AFB_SESSION_LOA_EQ_0 AFB_SESSION_LOA_EQ_0_X1 +# define AFB_SESSION_LOA_EQ_1 AFB_SESSION_LOA_EQ_1_X1 +# define AFB_SESSION_LOA_EQ_2 AFB_SESSION_LOA_EQ_2_X1 +# define AFB_SESSION_LOA_EQ_3 AFB_SESSION_LOA_EQ_3_X1 + +# define AFB_SESSION_LOA_GE_0 AFB_SESSION_LOA_GE_0_X1 +# define AFB_SESSION_LOA_GE_1 AFB_SESSION_LOA_GE_1_X1 +# define AFB_SESSION_LOA_GE_2 AFB_SESSION_LOA_GE_2_X1 +# define AFB_SESSION_LOA_GE_3 AFB_SESSION_LOA_GE_3_X1 + +#endif + +/******************************************************************************/ +#if AFB_BINDING_VERSION == 2 + +#define afb_req_store afb_req_x1_store_v2 +#define afb_req_unstore afb_daemon_unstore_req_v2 + +#define afb_binding afb_binding_v2 + +#define afb_get_verbosity afb_get_verbosity_v2 +#define afb_get_daemon afb_get_daemon_v2 +#define afb_get_service afb_get_service_v2 + +#define afb_daemon_get_event_loop afb_daemon_get_event_loop_v2 +#define afb_daemon_get_user_bus afb_daemon_get_user_bus_v2 +#define afb_daemon_get_system_bus afb_daemon_get_system_bus_v2 +#define afb_daemon_broadcast_event afb_daemon_broadcast_event_v2 +#define afb_daemon_make_event afb_daemon_make_event_v2 +#define afb_daemon_verbose afb_daemon_verbose_v2 +#define afb_daemon_rootdir_get_fd afb_daemon_rootdir_get_fd_v2 +#define afb_daemon_rootdir_open_locale afb_daemon_rootdir_open_locale_v2 +#define afb_daemon_queue_job afb_daemon_queue_job_v2 +#define afb_daemon_unstore_req afb_daemon_unstore_req_v2 +#define afb_daemon_require_api afb_daemon_require_api_v2 +#define afb_daemon_rename_api(x) afb_daemon_add_alias_v2(0,x) +#define afb_daemon_add_alias afb_daemon_add_alias_v2 + +#define afb_service_call afb_service_call_v2 +#define afb_service_call_sync afb_service_call_sync_v2 + +#define AFB_ERROR AFB_ERROR_V2 +#define AFB_WARNING AFB_WARNING_V2 +#define AFB_NOTICE AFB_NOTICE_V2 +#define AFB_INFO AFB_INFO_V2 +#define AFB_DEBUG AFB_DEBUG_V2 + +#define AFB_REQ_ERROR AFB_REQ_ERROR_V2 +#define AFB_REQ_WARNING AFB_REQ_WARNING_V2 +#define AFB_REQ_NOTICE AFB_REQ_NOTICE_V2 +#define AFB_REQ_INFO AFB_REQ_INFO_V2 +#define AFB_REQ_DEBUG AFB_REQ_DEBUG_V2 + +#define AFB_REQ_VERBOSE AFB_REQ_VERBOSE_V2 + +#endif + +/******************************************************************************/ +#if AFB_BINDING_VERSION == 2 || AFB_BINDING_VERSION == 3 + +#define AFB_SESSION_NONE AFB_SESSION_NONE_X2 +#define AFB_SESSION_CLOSE AFB_SESSION_CLOSE_X2 +#define AFB_SESSION_RENEW AFB_SESSION_REFRESH_X2 +#define AFB_SESSION_REFRESH AFB_SESSION_REFRESH_X2 +#define AFB_SESSION_CHECK AFB_SESSION_CHECK_X2 + +#define AFB_SESSION_LOA_MASK AFB_SESSION_LOA_MASK_X2 + +#define AFB_SESSION_LOA_0 AFB_SESSION_LOA_0_X2 +#define AFB_SESSION_LOA_1 AFB_SESSION_LOA_1_X2 +#define AFB_SESSION_LOA_2 AFB_SESSION_LOA_2_X2 +#define AFB_SESSION_LOA_3 AFB_SESSION_LOA_3_X2 + +#endif + +/******************************************************************************/ +#if AFB_BINDING_VERSION == 2 + +#define AFB_SESSION_NONE_V2 AFB_SESSION_NONE_X2 +#define AFB_SESSION_CLOSE_V2 AFB_SESSION_CLOSE_X2 +#define AFB_SESSION_RENEW_V2 AFB_SESSION_REFRESH_X2 +#define AFB_SESSION_REFRESH_V2 AFB_SESSION_REFRESH_X2 +#define AFB_SESSION_CHECK_V2 AFB_SESSION_CHECK_X2 + +#define AFB_SESSION_LOA_MASK_V2 AFB_SESSION_LOA_MASK_X2 + +#define AFB_SESSION_LOA_0_V2 AFB_SESSION_LOA_0_X2 +#define AFB_SESSION_LOA_1_V2 AFB_SESSION_LOA_1_X2 +#define AFB_SESSION_LOA_2_V2 AFB_SESSION_LOA_2_X2 +#define AFB_SESSION_LOA_3_V2 AFB_SESSION_LOA_3_X2 + +#endif + +/******************************************************************************/ +#if AFB_BINDING_VERSION == 3 + +#define afb_req_x2 afb_req + +#define afb_req_x2_is_valid afb_req_is_valid +#define afb_req_x2_get_api afb_req_get_api +#define afb_req_x2_get_vcbdata afb_req_get_vcbdata +#define afb_req_x2_get_called_api afb_req_get_called_api +#define afb_req_x2_get_called_verb afb_req_get_called_verb +#define afb_req_x2_wants_log_level afb_req_wants_log_level + +#define afb_req_x2_get afb_req_get +#define afb_req_x2_value afb_req_value +#define afb_req_x2_path afb_req_path +#define afb_req_x2_json afb_req_json +#define afb_req_x2_reply afb_req_reply +#define afb_req_x2_reply_f afb_req_reply_f +#define afb_req_x2_reply_v afb_req_reply_v +#define afb_req_success(r,o,i) afb_req_reply(r,o,0,i) +#define afb_req_success_f(r,o,...) afb_req_reply_f(r,o,0,__VA_ARGS__) +#define afb_req_success_v(r,o,f,v) afb_req_reply_v(r,o,0,f,v) +#define afb_req_fail(r,e,i) afb_req_reply(r,0,e,i) +#define afb_req_fail_f(r,e,...) afb_req_reply_f(r,0,e,__VA_ARGS__) +#define afb_req_fail_v(r,e,f,v) afb_req_reply_v(r,0,e,f,v) +#define afb_req_x2_context_get afb_req_context_get +#define afb_req_x2_context_set afb_req_context_set +#define afb_req_x2_context afb_req_context +#define afb_req_x2_context_make afb_req_context_make +#define afb_req_x2_context_clear afb_req_context_clear +#define afb_req_x2_addref afb_req_addref +#define afb_req_x2_unref afb_req_unref +#define afb_req_x2_session_close afb_req_session_close +#define afb_req_x2_session_set_LOA afb_req_session_set_LOA +#define afb_req_x2_subscribe afb_req_subscribe +#define afb_req_x2_unsubscribe afb_req_unsubscribe +#define afb_req_x2_subcall afb_req_subcall +#define afb_req_x2_subcall_legacy afb_req_subcall_legacy +#define afb_req_x2_subcall_req afb_req_subcall_req +#define afb_req_x2_subcall_sync_legacy afb_req_subcall_sync_legacy +#define afb_req_x2_subcall_sync afb_req_subcall_sync +#define afb_req_x2_verbose afb_req_verbose +#define afb_req_x2_has_permission afb_req_has_permission +#define afb_req_x2_get_application_id afb_req_get_application_id +#define afb_req_x2_get_uid afb_req_get_uid +#define afb_req_x2_get_client_info afb_req_get_client_info + +#define afb_req_x2_subcall_catch_events afb_req_subcall_catch_events +#define afb_req_x2_subcall_pass_events afb_req_subcall_pass_events +#define afb_req_x2_subcall_on_behalf afb_req_subcall_on_behalf + +#define afb_event_x2 afb_event +#define afb_event_x2_is_valid afb_event_is_valid +#define afb_event_x2_broadcast afb_event_broadcast +#define afb_event_x2_push afb_event_push +#define afb_event_x2_name afb_event_name +#define afb_event_x2_unref afb_event_unref +#define afb_event_x2_addref afb_event_addref + +#define afb_api_x3 afb_api + +#define afb_api_x3_name afb_api_name +#define afb_api_x3_get_userdata afb_api_get_userdata +#define afb_api_x3_set_userdata afb_api_set_userdata +#define afb_api_x3_wants_log_level afb_api_wants_log_level + +#define afb_api_x3_verbose afb_api_verbose +#define afb_api_x3_get_event_loop afb_api_get_event_loop +#define afb_api_x3_get_user_bus afb_api_get_user_bus +#define afb_api_x3_get_system_bus afb_api_get_system_bus +#define afb_api_x3_rootdir_get_fd afb_api_rootdir_get_fd +#define afb_api_x3_rootdir_open_locale afb_api_rootdir_open_locale +#define afb_api_x3_queue_job afb_api_queue_job +#define afb_api_x3_require_api afb_api_require_api +#define afb_api_x3_broadcast_event afb_api_broadcast_event +#define afb_api_x3_make_event_x2 afb_api_make_event +#define afb_api_x3_call afb_api_call +#define afb_api_x3_call_sync afb_api_call_sync +#define afb_api_x3_call_legacy afb_api_call_legacy +#define afb_api_x3_call_sync_legacy afb_api_call_sync_legacy +#define afb_api_x3_new_api afb_api_new_api +#define afb_api_x3_set_verbs_v2 afb_api_set_verbs_v2 +#define afb_api_x3_add_verb afb_api_add_verb +#define afb_api_x3_del_verb afb_api_del_verb +#define afb_api_x3_on_event afb_api_on_event +#define afb_api_x3_on_init afb_api_on_init +#define afb_api_x3_seal afb_api_seal +#define afb_api_x3_add_alias afb_api_add_alias + +#define AFB_API_ERROR AFB_API_ERROR_V3 +#define AFB_API_WARNING AFB_API_WARNING_V3 +#define AFB_API_NOTICE AFB_API_NOTICE_V3 +#define AFB_API_INFO AFB_API_INFO_V3 +#define AFB_API_DEBUG AFB_API_DEBUG_V3 + +#define AFB_REQ_ERROR AFB_REQ_ERROR_V3 +#define AFB_REQ_WARNING AFB_REQ_WARNING_V3 +#define AFB_REQ_NOTICE AFB_REQ_NOTICE_V3 +#define AFB_REQ_INFO AFB_REQ_INFO_V3 +#define AFB_REQ_DEBUG AFB_REQ_DEBUG_V3 + +#define AFB_REQ_VERBOSE AFB_REQ_VERBOSE_V3 + +#define afb_stored_req afb_req_x2 +#define afb_req_store(x) afb_req_x2_addref(x) +#define afb_req_unstore(x) (x) + +#define afb_get_verbosity afb_get_verbosity_v3 +#define afb_get_logmask afb_get_logmask_v3 +#define afb_get_daemon afb_get_root_api_v3 +#define afb_get_service afb_get_root_api_v3 + +#define afb_daemon_get_event_loop afb_daemon_get_event_loop_v3 +#define afb_daemon_get_user_bus afb_daemon_get_user_bus_v3 +#define afb_daemon_get_system_bus afb_daemon_get_system_bus_v3 +#define afb_daemon_broadcast_event afb_daemon_broadcast_event_v3 +#define afb_daemon_make_event afb_daemon_make_event_v3 +#define afb_daemon_verbose afb_daemon_verbose_v3 +#define afb_daemon_rootdir_get_fd afb_daemon_rootdir_get_fd_v3 +#define afb_daemon_rootdir_open_locale afb_daemon_rootdir_open_locale_v3 +#define afb_daemon_queue_job afb_daemon_queue_job_v3 +#define afb_daemon_require_api afb_daemon_require_api_v3 +#define afb_daemon_add_alias afb_daemon_add_alias_v3 + +# define afb_service_call afb_service_call_v3 +# define afb_service_call_sync afb_service_call_sync_v3 + +# define AFB_ERROR AFB_ERROR_V3 +# define AFB_WARNING AFB_WARNING_V3 +# define AFB_NOTICE AFB_NOTICE_V3 +# define AFB_INFO AFB_INFO_V3 +# define AFB_DEBUG AFB_DEBUG_V3 + +#endif + diff --git a/include/afb/afb-binding-v1.h b/include/afb/afb-binding-v1.h index 9fb0ab89..3d5010d0 100644 --- a/include/afb/afb-binding-v1.h +++ b/include/afb/afb-binding-v1.h @@ -17,22 +17,27 @@ #pragma once -struct json_object; +/******************************************************************************/ -#include "afb-req.h" -#include "afb-event.h" -#include "afb-service-itf.h" -#include "afb-daemon-itf.h" +#include "afb-verbosity.h" +#include "afb-req-x1.h" +#include "afb-event-x1.h" +#include "afb-service-itf-x1.h" +#include "afb-daemon-itf-x1.h" #include "afb-req-v1.h" -#include "afb-session-v1.h" +#include "afb-session-x1.h" #include "afb-service-v1.h" #include "afb-daemon-v1.h" struct afb_binding_v1; struct afb_binding_interface_v1; -/* +/******************************************************************************/ + +/** + * @deprecated use bindings version 3 + * * Function for registering the binding * * A binding V1 MUST have an exported function of name @@ -57,7 +62,9 @@ struct afb_binding_interface_v1; */ extern const struct afb_binding_v1 *afbBindingV1Register (const struct afb_binding_interface_v1 *interface); -/* +/** + * @deprecated use bindings version 3 + * * When a binding have an exported implementation of the * function 'afbBindingV1ServiceInit', defined below, * the framework calls it for initialising the service after @@ -69,9 +76,11 @@ extern const struct afb_binding_v1 *afbBindingV1Register (const struct afb_bindi * The function should return 0 in case of success or, else, should return * a negative value. */ -extern int afbBindingV1ServiceInit(struct afb_service service); +extern int afbBindingV1ServiceInit(struct afb_service_x1 service); -/* +/** + * @deprecated use bindings version 3 + * * When a binding have an implementation of the function 'afbBindingV1ServiceEvent', * defined below, the framework calls that function for any broadcasted event or for * events that the service subscribed to in its name. @@ -82,30 +91,36 @@ extern int afbBindingV1ServiceInit(struct afb_service service); extern void afbBindingV1ServiceEvent(const char *event, struct json_object *object); -/* +/** + * @deprecated use bindings version 3 + * * Description of one verb of the API provided by the binding * This enumeration is valid for bindings of type version 1 */ struct afb_verb_desc_v1 { - const char *name; /* name of the verb */ - enum afb_session_flags_v1 session; /* authorisation and session requirements of the verb */ - void (*callback)(struct afb_req req); /* callback function implementing the verb */ - const char *info; /* textual description of the verb */ + const char *name; /**< name of the verb */ + enum afb_session_flags_x1 session; /**< authorisation and session requirements of the verb */ + void (*callback)(struct afb_req_x1 req);/**< callback function implementing the verb */ + const char *info; /**< textual description of the verb */ }; -/* +/** + * @deprecated use bindings version 3 + * * Description of the bindings of type version 1 */ struct afb_binding_desc_v1 { - const char *info; /* textual information about the binding */ - const char *prefix; /* required prefix name for the binding */ - const struct afb_verb_desc_v1 *verbs; /* array of descriptions of verbs terminated by a NULL name */ + const char *info; /**< textual information about the binding */ + const char *prefix; /**< required prefix name for the binding */ + const struct afb_verb_desc_v1 *verbs; /**< array of descriptions of verbs terminated by a NULL name */ }; -/* - * Definition of the type+versions of the binding. +/** + * @deprecated use bindings version 3 + * + * Definition of the type+versions of the binding version 1. * The definition uses hashes. */ enum afb_binding_type_v1 @@ -113,94 +128,107 @@ enum afb_binding_type_v1 AFB_BINDING_VERSION_1 = 123456789 }; -/* - * Description of a binding +/** + * @deprecated use bindings version 3 + * + * Description of a binding version 1 */ struct afb_binding_v1 { - enum afb_binding_type_v1 type; /* type of the binding */ + enum afb_binding_type_v1 type; /**< type of the binding */ union { - struct afb_binding_desc_v1 v1; /* description of the binding of type 1 */ + struct afb_binding_desc_v1 v1; /**< description of the binding of type 1 */ }; }; -/* - * config mode +/** + * @deprecated use bindings version 3 + * + * config mode for bindings version 1 */ enum afb_mode_v1 { - AFB_MODE_LOCAL = 0, /* run locally */ - AFB_MODE_REMOTE, /* run remotely */ - AFB_MODE_GLOBAL /* run either remotely or locally (DONT USE! reserved for future) */ + AFB_MODE_LOCAL = 0, /**< run locally */ + AFB_MODE_REMOTE, /**< run remotely */ + AFB_MODE_GLOBAL /**< run either remotely or locally (DONT USE! reserved for future) */ }; -/* - * Interface between the daemon and the binding. +/** + * @deprecated use bindings version 3 + * + * Interface between the daemon and the binding version 1. */ struct afb_binding_interface_v1 { - struct afb_daemon daemon; /* access to the daemon facilies */ - int verbosity; /* level of verbosity */ - enum afb_mode_v1 mode; /* run mode (local or remote) */ + struct afb_daemon_x1 daemon; /**< access to the daemon facilies */ + int verbosity; /**< level of verbosity */ + enum afb_mode_v1 mode; /**< run mode (local or remote) */ }; +/******************************************************************************/ /* * Macros for logging messages */ #if defined(AFB_BINDING_PRAGMA_NO_VERBOSE_DATA) -# define _AFB_LOGGING_V1_(itf,vlevel,llevel,...) \ - do{ \ - if(itf->verbosity>=vlevel) {\ - if (llevel <= AFB_VERBOSITY_LEVEL_ERROR) \ - afb_daemon_verbose2_v1(itf->daemon,llevel,__FILE__,__LINE__,__func__,__VA_ARGS__); \ - else \ - afb_daemon_verbose2_v1(itf->daemon,llevel,__FILE__,__LINE__,NULL,NULL); \ - } \ - }while(0) -# define _AFB_REQ_LOGGING_V1_(itf,vlevel,llevel,req,...) \ - do{ \ - if(itf->verbosity>=vlevel) \ - afb_req_verbose(req,llevel,__FILE__,__LINE__,NULL,NULL); \ - }while(0) +# define AFB_VERBOSE_V1(itf,level,...) \ + do { if(level <= AFB_VERBOSITY_LEVEL_ERROR) \ + afb_daemon_verbose2_v1(itf->daemon,level,__FILE__,__LINE__,NULL,__VA_ARGS__); \ + else afb_daemon_verbose2_v1(itf->daemon,level,__FILE__,__LINE__,NULL); } while(0) + +# define AFB_REQ_VERBOSE_V1(req,level,...) \ + do { if(level <= AFB_VERBOSITY_LEVEL_ERROR) \ + afb_req_x1_verbose(req,level,__FILE__,__LINE__,NULL,__VA_ARGS__); \ + else afb_req_x1_verbose(req,level,__FILE__,__LINE__,NULL); } while(0) #elif defined(AFB_BINDING_PRAGMA_NO_VERBOSE_DETAILS) -# define _AFB_LOGGING_V1_(itf,vlevel,llevel,...) \ - do{ \ - if(itf->verbosity>=vlevel) \ - afb_daemon_verbose2_v1(itf->daemon,llevel,NULL,0,NULL,__VA_ARGS__); \ - }while(0) -# define _AFB_REQ_LOGGING_V1_(itf,vlevel,llevel,req,...) \ - do{ \ - if(itf->verbosity>=vlevel) \ - afb_req_verbose(req,llevel,NULL,0,NULL,__VA_ARGS__); \ - }while(0) +# define AFB_VERBOSE_V1(itf,level,...) \ + afb_daemon_verbose2_v1(itf->daemon,level,NULL,0,NULL,__VA_ARGS__) + +# define AFB_REQ_VERBOSE_V1(req,level,...) \ + afb_req_x1_verbose(req,level,NULL,0,NULL,__VA_ARGS__) #else -# define _AFB_LOGGING_V1_(itf,vlevel,llevel,...) \ - do{ \ - if(itf->verbosity>=vlevel) \ - afb_daemon_verbose2_v1(itf->daemon,llevel,__FILE__,__LINE__,__func__,__VA_ARGS__); \ - }while(0) -# define _AFB_REQ_LOGGING_V1_(itf,vlevel,llevel,req,...) \ - do{ \ - if(itf->verbosity>=vlevel) \ - afb_req_verbose(req,llevel,__FILE__,__LINE__,__func__,__VA_ARGS__); \ - }while(0) +# define AFB_VERBOSE_V1(itf,level,...) \ + afb_daemon_verbose2_v1(itf->daemon,level,__FILE__,__LINE__,__func__,__VA_ARGS__) + +# define AFB_REQ_VERBOSE_V1(req,level,...) \ + afb_req_x1_verbose(req,level,__FILE__,__LINE__,__func__,__VA_ARGS__) #endif -# include "afb-verbosity.h" -# define AFB_ERROR_V1(itf,...) _AFB_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_ERROR,_AFB_SYSLOG_LEVEL_ERROR_,__VA_ARGS__) -# define AFB_WARNING_V1(itf,...) _AFB_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_WARNING,_AFB_SYSLOG_LEVEL_WARNING_,__VA_ARGS__) -# define AFB_NOTICE_V1(itf,...) _AFB_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_NOTICE,_AFB_SYSLOG_LEVEL_NOTICE_,__VA_ARGS__) -# define AFB_INFO_V1(itf,...) _AFB_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_INFO,_AFB_SYSLOG_LEVEL_INFO_,__VA_ARGS__) -# define AFB_DEBUG_V1(itf,...) _AFB_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_DEBUG,_AFB_SYSLOG_LEVEL_DEBUG_,__VA_ARGS__) -# define AFB_REQ_ERROR_V1(itf,...) _AFB_REQ_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_ERROR,_AFB_SYSLOG_LEVEL_ERROR_,__VA_ARGS__) -# define AFB_REQ_WARNING_V1(itf,...) _AFB_REQ_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_WARNING,_AFB_SYSLOG_LEVEL_WARNING_,__VA_ARGS__) -# define AFB_REQ_NOTICE_V1(itf,...) _AFB_REQ_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_NOTICE,_AFB_SYSLOG_LEVEL_NOTICE_,__VA_ARGS__) -# define AFB_REQ_INFO_V1(itf,...) _AFB_REQ_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_INFO,_AFB_SYSLOG_LEVEL_INFO_,__VA_ARGS__) -# define AFB_REQ_DEBUG_V1(itf,...) _AFB_REQ_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_DEBUG,_AFB_SYSLOG_LEVEL_DEBUG_,__VA_ARGS__) +#define _AFB_LOGGING_V1_(itf,vlevel,llevel,...) \ + do{ if(itf->verbosity>=vlevel) AFB_VERBOSE_V1(itf,llevel,__VA_ARGS__); }while(0) +#define _AFB_REQ_LOGGING_V1_(itf,vlevel,llevel,req,...) \ + do{ if(itf->verbosity>=vlevel) AFB_REQ_VERBOSE_V1(itf,llevel,__VA_ARGS__); }while(0) + +# define AFB_ERROR_V1(itf,...) _AFB_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_ERROR,AFB_SYSLOG_LEVEL_ERROR,__VA_ARGS__) +# define AFB_WARNING_V1(itf,...) _AFB_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_WARNING,AFB_SYSLOG_LEVEL_WARNING,__VA_ARGS__) +# define AFB_NOTICE_V1(itf,...) _AFB_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_NOTICE,AFB_SYSLOG_LEVEL_NOTICE,__VA_ARGS__) +# define AFB_INFO_V1(itf,...) _AFB_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_INFO,AFB_SYSLOG_LEVEL_INFO,__VA_ARGS__) +# define AFB_DEBUG_V1(itf,...) _AFB_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_DEBUG,AFB_SYSLOG_LEVEL_DEBUG,__VA_ARGS__) + +# define AFB_REQ_ERROR_V1(itf,...) _AFB_REQ_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_ERROR,AFB_SYSLOG_LEVEL_ERROR,__VA_ARGS__) +# define AFB_REQ_WARNING_V1(itf,...) _AFB_REQ_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_WARNING,AFB_SYSLOG_LEVEL_WARNING,__VA_ARGS__) +# define AFB_REQ_NOTICE_V1(itf,...) _AFB_REQ_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_NOTICE,AFB_SYSLOG_LEVEL_NOTICE,__VA_ARGS__) +# define AFB_REQ_INFO_V1(itf,...) _AFB_REQ_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_INFO,AFB_SYSLOG_LEVEL_INFO,__VA_ARGS__) +# define AFB_REQ_DEBUG_V1(itf,...) _AFB_REQ_LOGGING_V1_(itf,AFB_VERBOSITY_LEVEL_DEBUG,AFB_SYSLOG_LEVEL_DEBUG,__VA_ARGS__) + +/******************************************************************************/ + +#if AFB_BINDING_VERSION == 1 && defined(AFB_BINDING_PRAGMA_KEEP_VERBOSE_UNPREFIX) +# define ERROR AFB_ERROR +# define WARNING AFB_WARNING +# define NOTICE AFB_NOTICE +# define INFO AFB_INFO +# define DEBUG AFB_DEBUG + +# define REQ_ERROR AFB_REQ_ERROR +# define REQ_WARNING AFB_REQ_WARNING +# define REQ_NOTICE AFB_REQ_NOTICE +# define REQ_INFO AFB_REQ_INFO +# define REQ_DEBUG AFB_REQ_DEBUG +#endif diff --git a/include/afb/afb-binding-v2.h b/include/afb/afb-binding-v2.h index 3aa61b23..1535f429 100644 --- a/include/afb/afb-binding-v2.h +++ b/include/afb/afb-binding-v2.h @@ -17,137 +17,156 @@ #pragma once -#include <stdint.h> +/******************************************************************************/ +#include "afb-verbosity.h" #include "afb-auth.h" -#include "afb-event.h" -#include "afb-req.h" -#include "afb-service-itf.h" -#include "afb-daemon-itf.h" +#include "afb-event-x1.h" +#include "afb-req-x1.h" +#include "afb-service-itf-x1.h" +#include "afb-daemon-itf-x1.h" #include "afb-req-v2.h" -#include "afb-session-v2.h" +#include "afb-session-x2.h" -struct json_object; +/******************************************************************************/ -/* - * Description of one verb of the API provided by the binding - * This enumeration is valid for bindings of type version 2 +/** + * @deprecated use bindings version 3 + * + * Description of one verb as provided for binding API version 2 */ struct afb_verb_v2 { - const char *verb; /* name of the verb, NULL only at end of the array */ - void (*callback)(struct afb_req req); /* callback function implementing the verb */ - const struct afb_auth *auth; /* required authorisation, can be NULL */ - const char *info; /* some info about the verb, can be NULL */ - uint32_t session; /* authorisation and session requirements of the verb */ + const char *verb; /**< name of the verb, NULL only at end of the array */ + void (*callback)(struct afb_req_x1 req);/**< callback function implementing the verb */ + const struct afb_auth *auth; /**< required authorisation, can be NULL */ + const char *info; /**< some info about the verb, can be NULL */ + uint32_t session; /**< authorisation and session requirements of the verb */ }; -/* +/** + * @deprecated use bindings version 3 + * * Description of the bindings of type version 2 */ struct afb_binding_v2 { - const char *api; /* api name for the binding */ - const char *specification; /* textual specification of the binding, can be NULL */ - const char *info; /* some info about the api, can be NULL */ - const struct afb_verb_v2 *verbs; /* array of descriptions of verbs terminated by a NULL name */ - int (*preinit)(); /* callback at load of the binding */ - int (*init)(); /* callback for starting the service */ - void (*onevent)(const char *event, struct json_object *object); /* callback for handling events */ - unsigned noconcurrency: 1; /* avoids concurrent requests to verbs */ + const char *api; /**< api name for the binding */ + const char *specification; /**< textual specification of the binding, can be NULL */ + const char *info; /**< some info about the api, can be NULL */ + const struct afb_verb_v2 *verbs; /**< array of descriptions of verbs terminated by a NULL name */ + int (*preinit)(); /**< callback at load of the binding */ + int (*init)(); /**< callback for starting the service */ + void (*onevent)(const char *event, struct json_object *object); /**< callback for handling events */ + unsigned noconcurrency: 1; /**< avoids concurrent requests to verbs */ }; +/** + * @deprecated use bindings version 3 + * + * structure for the global data of the binding + */ struct afb_binding_data_v2 { - int verbosity; /* level of verbosity */ - struct afb_daemon daemon; /* access to daemon APIs */ - struct afb_service service; /* access to service APIs */ + int verbosity; /**< level of verbosity */ + struct afb_daemon_x1 daemon; /**< access to daemon APIs */ + struct afb_service_x1 service; /**< access to service APIs */ }; -/* +/** + * @page validity-v2 Validity of a binding v2 + * * A binding V2 MUST have two exported symbols of name: * - * - afbBindingV2 - * - afbBindingV2data + * - @ref afbBindingV2 + * - @ref afbBindingV2data + */ + +/** + * @deprecated use bindings version 3 * + * The global mandatory description of the binding */ #if !defined(AFB_BINDING_MAIN_NAME_V2) extern const struct afb_binding_v2 afbBindingV2; #endif -#if !defined(AFB_BINDING_DATA_NAME_V2) -#define AFB_BINDING_DATA_NAME_V2 afbBindingV2data -#endif - +/** + * @deprecated use bindings version 3 + * + * The global auto declared internal data of the binding + */ #if AFB_BINDING_VERSION != 2 extern #endif -struct afb_binding_data_v2 AFB_BINDING_DATA_NAME_V2 __attribute__ ((weak)); +struct afb_binding_data_v2 afbBindingV2data __attribute__ ((weak)); -#define afb_get_verbosity_v2() (AFB_BINDING_DATA_NAME_V2.verbosity) -#define afb_get_daemon_v2() (AFB_BINDING_DATA_NAME_V2.daemon) -#define afb_get_service_v2() (AFB_BINDING_DATA_NAME_V2.service) +#define afb_get_verbosity_v2() (afbBindingV2data.verbosity) +#define afb_get_daemon_v2() (afbBindingV2data.daemon) +#define afb_get_service_v2() (afbBindingV2data.service) +/******************************************************************************/ /* * Macros for logging messages */ #if defined(AFB_BINDING_PRAGMA_NO_VERBOSE_DATA) -# define _AFB_LOGGING_V2_(vlevel,llevel,...) \ - do{ \ - if(AFB_BINDING_DATA_NAME_V2.verbosity>=vlevel) {\ - if (llevel <= AFB_VERBOSITY_LEVEL_ERROR) \ - afb_daemon_verbose_v2(llevel,__FILE__,__LINE__,__func__,__VA_ARGS__); \ - else \ - afb_daemon_verbose_v2(llevel,__FILE__,__LINE__,NULL,NULL); \ - } \ - }while(0) -# define _AFB_REQ_LOGGING_V2_(vlevel,llevel,req,...) \ - do{ \ - if(AFB_BINDING_DATA_NAME_V2.verbosity>=vlevel) \ - afb_req_verbose(req,llevel,__FILE__,__LINE__,NULL,NULL); \ - }while(0) +#define AFB_VERBOSE_V2(level,...) \ + do { if(level <= AFB_VERBOSITY_LEVEL_ERROR) \ + afb_daemon_verbose_v2(level,__FILE__,__LINE__,NULL,__VA_ARGS__); \ + else afb_daemon_verbose_v2(level,__FILE__,__LINE__,NULL); } while(0) + +#define AFB_REQ_VERBOSE_V2(req,level,...) \ + do { if(level <= AFB_VERBOSITY_LEVEL_ERROR) \ + afb_req_x1_verbose(req,level,__FILE__,__LINE__,NULL,__VA_ARGS__); \ + else afb_req_x1_verbose(req,level,__FILE__,__LINE__,NULL); } while(0) #elif defined(AFB_BINDING_PRAGMA_NO_VERBOSE_DETAILS) -# define _AFB_LOGGING_V2_(vlevel,llevel,...) \ - do{ \ - if(AFB_BINDING_DATA_NAME_V2.verbosity>=vlevel) \ - afb_daemon_verbose_v2(llevel,NULL,0,NULL,__VA_ARGS__); \ - }while(0) -# define _AFB_REQ_LOGGING_V2_(vlevel,llevel,req,...) \ - do{ \ - if(AFB_BINDING_DATA_NAME_V2.verbosity>=vlevel) \ - afb_req_verbose(req,llevel,NULL,0,NULL,__VA_ARGS__); \ - }while(0) +#define AFB_VERBOSE_V2(level,...) \ + afb_daemon_verbose_v2(level,NULL,0,NULL,__VA_ARGS__) + +#define AFB_REQ_VERBOSE_V2(req,level,...) \ + afb_req_x1_verbose(req,level,NULL,0,NULL,__VA_ARGS__) #else -# define _AFB_LOGGING_V2_(vlevel,llevel,...) \ - do{ \ - if(AFB_BINDING_DATA_NAME_V2.verbosity>=vlevel) \ - afb_daemon_verbose_v2(llevel,__FILE__,__LINE__,__func__,__VA_ARGS__); \ - }while(0) -# define _AFB_REQ_LOGGING_V2_(vlevel,llevel,req,...) \ - do{ \ - if(AFB_BINDING_DATA_NAME_V2.verbosity>=vlevel) \ - afb_req_verbose(req,llevel,__FILE__,__LINE__,__func__,__VA_ARGS__); \ - }while(0) +#define AFB_VERBOSE_V2(level,...) \ + afb_daemon_verbose_v2(level,__FILE__,__LINE__,__func__,__VA_ARGS__) + +#define AFB_REQ_VERBOSE_V2(req,level,...) \ + afb_req_x1_verbose(req,level,__FILE__,__LINE__,__func__,__VA_ARGS__) #endif -#include "afb-verbosity.h" -#define AFB_ERROR_V2(...) _AFB_LOGGING_V2_(AFB_VERBOSITY_LEVEL_ERROR,_AFB_SYSLOG_LEVEL_ERROR_,__VA_ARGS__) -#define AFB_WARNING_V2(...) _AFB_LOGGING_V2_(AFB_VERBOSITY_LEVEL_WARNING,_AFB_SYSLOG_LEVEL_WARNING_,__VA_ARGS__) -#define AFB_NOTICE_V2(...) _AFB_LOGGING_V2_(AFB_VERBOSITY_LEVEL_NOTICE,_AFB_SYSLOG_LEVEL_NOTICE_,__VA_ARGS__) -#define AFB_INFO_V2(...) _AFB_LOGGING_V2_(AFB_VERBOSITY_LEVEL_INFO,_AFB_SYSLOG_LEVEL_INFO_,__VA_ARGS__) -#define AFB_DEBUG_V2(...) _AFB_LOGGING_V2_(AFB_VERBOSITY_LEVEL_DEBUG,_AFB_SYSLOG_LEVEL_DEBUG_,__VA_ARGS__) -#define AFB_REQ_ERROR_V2(...) _AFB_REQ_LOGGING_V2_(AFB_VERBOSITY_LEVEL_ERROR,_AFB_SYSLOG_LEVEL_ERROR_,__VA_ARGS__) -#define AFB_REQ_WARNING_V2(...) _AFB_REQ_LOGGING_V2_(AFB_VERBOSITY_LEVEL_WARNING,_AFB_SYSLOG_LEVEL_WARNING_,__VA_ARGS__) -#define AFB_REQ_NOTICE_V2(...) _AFB_REQ_LOGGING_V2_(AFB_VERBOSITY_LEVEL_NOTICE,_AFB_SYSLOG_LEVEL_NOTICE_,__VA_ARGS__) -#define AFB_REQ_INFO_V2(...) _AFB_REQ_LOGGING_V2_(AFB_VERBOSITY_LEVEL_INFO,_AFB_SYSLOG_LEVEL_INFO_,__VA_ARGS__) -#define AFB_REQ_DEBUG_V2(...) _AFB_REQ_LOGGING_V2_(AFB_VERBOSITY_LEVEL_DEBUG,_AFB_SYSLOG_LEVEL_DEBUG_,__VA_ARGS__) +#define _AFB_LOGGING_V2_(vlevel,llevel,...) \ + do{ if(afb_get_verbosity_v2()>=vlevel) AFB_VERBOSE_V2(llevel,__VA_ARGS__); } while(0) +#define _AFB_REQ_LOGGING_V2_(vlevel,llevel,req,...) \ + do{ if(afb_get_verbosity_v2()>=vlevel) AFB_REQ_VERBOSE_V2(req,llevel,__VA_ARGS__); } while(0) + +#define AFB_ERROR_V2(...) _AFB_LOGGING_V2_(AFB_VERBOSITY_LEVEL_ERROR,AFB_SYSLOG_LEVEL_ERROR,__VA_ARGS__) +#define AFB_WARNING_V2(...) _AFB_LOGGING_V2_(AFB_VERBOSITY_LEVEL_WARNING,AFB_SYSLOG_LEVEL_WARNING,__VA_ARGS__) +#define AFB_NOTICE_V2(...) _AFB_LOGGING_V2_(AFB_VERBOSITY_LEVEL_NOTICE,AFB_SYSLOG_LEVEL_NOTICE,__VA_ARGS__) +#define AFB_INFO_V2(...) _AFB_LOGGING_V2_(AFB_VERBOSITY_LEVEL_INFO,AFB_SYSLOG_LEVEL_INFO,__VA_ARGS__) +#define AFB_DEBUG_V2(...) _AFB_LOGGING_V2_(AFB_VERBOSITY_LEVEL_DEBUG,AFB_SYSLOG_LEVEL_DEBUG,__VA_ARGS__) +#define AFB_REQ_ERROR_V2(...) _AFB_REQ_LOGGING_V2_(AFB_VERBOSITY_LEVEL_ERROR,AFB_SYSLOG_LEVEL_ERROR,__VA_ARGS__) +#define AFB_REQ_WARNING_V2(...) _AFB_REQ_LOGGING_V2_(AFB_VERBOSITY_LEVEL_WARNING,AFB_SYSLOG_LEVEL_WARNING,__VA_ARGS__) +#define AFB_REQ_NOTICE_V2(...) _AFB_REQ_LOGGING_V2_(AFB_VERBOSITY_LEVEL_NOTICE,AFB_SYSLOG_LEVEL_NOTICE,__VA_ARGS__) +#define AFB_REQ_INFO_V2(...) _AFB_REQ_LOGGING_V2_(AFB_VERBOSITY_LEVEL_INFO,AFB_SYSLOG_LEVEL_INFO,__VA_ARGS__) +#define AFB_REQ_DEBUG_V2(...) _AFB_REQ_LOGGING_V2_(AFB_VERBOSITY_LEVEL_DEBUG,AFB_SYSLOG_LEVEL_DEBUG,__VA_ARGS__) + +/******************************************************************************/ + +#if 0 && AFB_BINDING_VERSION >= 2 + +# define afb_verbose_error() (afb_get_verbosity() >= AFB_VERBOSITY_LEVEL_ERROR) +# define afb_verbose_warning() (afb_get_verbosity() >= AFB_VERBOSITY_LEVEL_WARNING) +# define afb_verbose_notice() (afb_get_verbosity() >= AFB_VERBOSITY_LEVEL_NOTICE) +# define afb_verbose_info() (afb_get_verbosity() >= AFB_VERBOSITY_LEVEL_INFO) +# define afb_verbose_debug() (afb_get_verbosity() >= AFB_VERBOSITY_LEVEL_DEBUG) + +#endif #include "afb-daemon-v2.h" #include "afb-service-v2.h" diff --git a/include/afb/afb-binding-v3.h b/include/afb/afb-binding-v3.h new file mode 100644 index 00000000..ece3f1c4 --- /dev/null +++ b/include/afb/afb-binding-v3.h @@ -0,0 +1,262 @@ +/* + * Copyright (C) 2016, 2017, 2018 "IoT.bzh" + * Author: José Bollo <jose.bollo@iot.bzh> + * + * 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. + */ + +/**< @file afb/afb-binding-v3.h */ + +#pragma once + +/******************************************************************************/ + +#include "afb-auth.h" +#include "afb-event-x2.h" +#include "afb-req-x2.h" +#include "afb-session-x2.h" +#include "afb-api-x3.h" + +/******************************************************************************/ + +/** + * @page validity-v3 Validity of a binding v3 + * + * A binding V3 MUST have at least two exported symbols of name: + * + * - @ref afbBindingV3root + * - @ref afbBindingV3 and/or @ref afbBindingV3entry + * + * @ref afbBindingV3root is automatically created when **AFB_BINDING_VERSION == 3** + * without programmer action, as a hidden variable linked as *weak*. + * + * The symbols @ref afbBindingV3 and **afbBindingV3entry** are under control + * of the programmer. + * + * The symbol @ref afbBindingV3 if defined is used, as in binding v2, to describe + * an API that will be declared during pre-initialization of bindings. + * + * The symbol @ref afbBindingV3entry if defined will be called during + * pre-initialization. + * + * If @ref afbBindingV3entry and @ref afbBindingV3 are both defined, it is an + * error to fill the field @ref preinit of @ref afbBindingV3. + * + * @see afb_binding_v3 + * @see afbBindingV3root + * @see afbBindingV3entry + * @see afbBindingV3 + */ + +/** + * Description of one verb as provided for binding API version 3 + */ +struct afb_verb_v3 +{ + /** name of the verb, NULL only at end of the array */ + const char *verb; + + /** callback function implementing the verb */ + void (*callback)(struct afb_req_x2 *req); + + /** required authorization, can be NULL */ + const struct afb_auth *auth; + + /** some info about the verb, can be NULL */ + const char *info; + + /**< data for the verb callback */ + void *vcbdata; + + /** authorization and session requirements of the verb */ + uint16_t session; + + /** is the verb glob name */ + uint16_t glob: 1; +}; + +/** + * Description of the bindings of type version 3 + */ +struct afb_binding_v3 +{ + /** api name for the binding, can't be NULL */ + const char *api; + + /** textual specification of the binding, can be NULL */ + const char *specification; + + /** some info about the api, can be NULL */ + const char *info; + + /** array of descriptions of verbs terminated by a NULL name, can be NULL */ + const struct afb_verb_v3 *verbs; + + /** callback at load of the binding */ + int (*preinit)(struct afb_api_x3 *api); + + /** callback for starting the service */ + int (*init)(struct afb_api_x3 *api); + + /** callback for handling events */ + void (*onevent)(struct afb_api_x3 *api, const char *event, struct json_object *object); + + /** userdata for afb_api_x3 */ + void *userdata; + + /** space separated list of provided class(es) */ + const char *provide_class; + + /** space separated list of required class(es) */ + const char *require_class; + + /** space separated list of required API(es) */ + const char *require_api; + + /** avoids concurrent requests to verbs */ + unsigned noconcurrency: 1; +}; + +/** + * Default root binding's api that can be used when no explicit context is + * available. + * + * When @ref afbBindingV3 is defined, this variable records the corresponding + * api handler. Otherwise, it points to an fake handles that allows logging + * and api creation. + * + * @see afbBindingV3entry + * @see afbBindingV3 + * @see @ref validity-v3 + */ +#if AFB_BINDING_VERSION != 3 +extern +#endif +struct afb_api_x3 *afbBindingV3root __attribute__((weak)); + +/** + * Pre-initialization function. + * + * If this function is defined and exported in the produced binding + * (shared object), it will be called during pre-initialization with the + * rootapi defined by \ref afbBindingV3root + * + * @param rootapi the root api (equals to afbBindingV3root) + * + * @return the function must return a negative integer on error to abort the + * initialization of the binding. Any positive or zero returned value is a + * interpreted as a success. + + * @see afbBindingV3root + * @see afbBindingV3 + * @see @ref validity-v3 + */ +extern int afbBindingV3entry(struct afb_api_x3 *rootapi); + +/** + * Static definition of the root api of the binding. + * + * This symbol if defined describes the API of the binding. + * + * If it is not defined then the function @ref afbBindingV3entry must be defined + * + * @see afbBindingV3root + * @see afbBindingV3entry + * @see @ref validity-v3 + */ +extern const struct afb_binding_v3 afbBindingV3; + +#include "afb-auth.h" +#include "afb-session-x2.h" +#include "afb-verbosity.h" + +#include "afb-event-x2.h" +#include "afb-req-x2.h" +#include "afb-api-x3.h" + +/* + * Macros for logging messages + */ + +#if defined(AFB_BINDING_PRAGMA_NO_VERBOSE_DATA) + +# define AFB_API_VERBOSE_V3(api,level,...) \ + do { if(level <= AFB_VERBOSITY_LEVEL_ERROR) \ + afb_api_v3_verbose(api,level,__FILE__,__LINE__,NULL,__VA_ARGS__); \ + else afb_api_v3_verbose(api,level,__FILE__,__LINE__,NULL); } while(0) + +# define AFB_REQ_VERBOSE_V3(req,level,...) \ + do { if(level <= AFB_VERBOSITY_LEVEL_ERROR) \ + afb_req_x2_verbose(req,level,__FILE__,__LINE__,NULL,__VA_ARGS__); \ + else afb_req_x2_verbose(req,level,__FILE__,__LINE__,NULL); } while(0) + +#elif defined(AFB_BINDING_PRAGMA_NO_VERBOSE_DETAILS) + +# define AFB_API_VERBOSE_V3(api,level,...) \ + afb_api_v3_verbose(api,level,NULL,0,NULL,__VA_ARGS__) + +# define AFB_REQ_VERBOSE_V3(req,level,...) \ + afb_req_x2_verbose(req,level,NULL,0,NULL,__VA_ARGS__) + +#else + +# define AFB_API_VERBOSE_V3(api,level,...) \ + afb_api_x3_verbose(api,level,__FILE__,__LINE__,__func__,__VA_ARGS__) + +# define AFB_REQ_VERBOSE_V3(req,level,...) \ + afb_req_x2_verbose(req,level,__FILE__,__LINE__,__func__,__VA_ARGS__) + +#endif + +#define _AFB_API_LOGGING_V3_(api,llevel,...) \ + do{ if(AFB_SYSLOG_MASK_WANT((api)->logmask,(llevel))) AFB_API_VERBOSE_V3((api),(llevel),__VA_ARGS__); }while(0) +#define _AFB_REQ_LOGGING_V3_(req,llevel,...) \ + do{ if(AFB_SYSLOG_MASK_WANT((req)->api->logmask,(llevel))) AFB_REQ_VERBOSE_V3((req),(llevel),__VA_ARGS__); }while(0) + +#define AFB_API_ERROR_V3(api,...) _AFB_API_LOGGING_V3_(api,AFB_SYSLOG_LEVEL_ERROR,__VA_ARGS__) +#define AFB_API_WARNING_V3(api,...) _AFB_API_LOGGING_V3_(api,AFB_SYSLOG_LEVEL_WARNING,__VA_ARGS__) +#define AFB_API_NOTICE_V3(api,...) _AFB_API_LOGGING_V3_(api,AFB_SYSLOG_LEVEL_NOTICE,__VA_ARGS__) +#define AFB_API_INFO_V3(api,...) _AFB_API_LOGGING_V3_(api,AFB_SYSLOG_LEVEL_INFO,__VA_ARGS__) +#define AFB_API_DEBUG_V3(api,...) _AFB_API_LOGGING_V3_(api,AFB_SYSLOG_LEVEL_DEBUG,__VA_ARGS__) + +#define AFB_REQ_ERROR_V3(req,...) _AFB_REQ_LOGGING_V3_(req,AFB_SYSLOG_LEVEL_ERROR,__VA_ARGS__) +#define AFB_REQ_WARNING_V3(req,...) _AFB_REQ_LOGGING_V3_(req,AFB_SYSLOG_LEVEL_WARNING,__VA_ARGS__) +#define AFB_REQ_NOTICE_V3(req,...) _AFB_REQ_LOGGING_V3_(req,AFB_SYSLOG_LEVEL_NOTICE,__VA_ARGS__) +#define AFB_REQ_INFO_V3(req,...) _AFB_REQ_LOGGING_V3_(req,AFB_SYSLOG_LEVEL_INFO,__VA_ARGS__) +#define AFB_REQ_DEBUG_V3(req,...) _AFB_REQ_LOGGING_V3_(req,AFB_SYSLOG_LEVEL_DEBUG,__VA_ARGS__) + +#define AFB_ERROR_V3(...) AFB_API_ERROR_V3(afbBindingV3root,__VA_ARGS__) +#define AFB_WARNING_V3(...) AFB_API_WARNING_V3(afbBindingV3root,__VA_ARGS__) +#define AFB_NOTICE_V3(...) AFB_API_NOTICE_V3(afbBindingV3root,__VA_ARGS__) +#define AFB_INFO_V3(...) AFB_API_INFO_V3(afbBindingV3root,__VA_ARGS__) +#define AFB_DEBUG_V3(...) AFB_API_DEBUG_V3(afbBindingV3root,__VA_ARGS__) + +#define afb_get_root_api_v3() (afbBindingV3root) +#define afb_get_logmask_v3() (afbBindingV3root->logmask) +#define afb_get_verbosity_v3() AFB_SYSLOG_LEVEL_TO_VERBOSITY(_afb_verbomask_to_upper_level_(afbBindingV3root->logmask)) + +#define afb_daemon_get_event_loop_v3(...) afb_api_get_event_loop(afbBindingV3root,__VA_ARGS__) +#define afb_daemon_get_user_bus_v3(...) afb_api_get_user_bus(afbBindingV3root,__VA_ARGS__) +#define afb_daemon_get_system_bus_v3(...) afb_api_get_system_bus(afbBindingV3root,__VA_ARGS__) +#define afb_daemon_broadcast_event_v3(...) afb_api_broadcast_event(afbBindingV3root,__VA_ARGS__) +#define afb_daemon_make_event_v3(...) afb_api_make_event(afbBindingV3root,__VA_ARGS__) +#define afb_daemon_verbose_v3(...) afb_api_verbose(afbBindingV3root,__VA_ARGS__) +#define afb_daemon_rootdir_get_fd_v3() afb_api_rootdir_get_fd(afbBindingV3root) +#define afb_daemon_rootdir_open_locale_v3(...) afb_api_rootdir_open_locale(afbBindingV3root,__VA_ARGS__) +#define afb_daemon_queue_job_v3(...) afb_api_queue_job(afbBindingV3root,__VA_ARGS__) +#define afb_daemon_require_api_v3(...) afb_api_require_api(afbBindingV3root,__VA_ARGS__) +#define afb_daemon_add_alias_v3(...) afb_api_add_alias(afbBindingV3root,__VA_ARGS__) + +#define afb_service_call_v3(...) afb_api_call_legacy(afbBindingV3root,__VA_ARGS__) +#define afb_service_call_sync_v3(...) afb_api_call_sync_legacy(afbBindingV3root,__VA_ARGS__) + diff --git a/include/afb/afb-binding-vdyn.h b/include/afb/afb-binding-vdyn.h deleted file mode 100644 index 357a85f6..00000000 --- a/include/afb/afb-binding-vdyn.h +++ /dev/null @@ -1,95 +0,0 @@ -/* - * Copyright (C) 2016, 2017, 2018 "IoT.bzh" - * Author: José Bollo <jose.bollo@iot.bzh> - * - * 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 - -#include "afb-auth.h" -#include "afb-session-v2.h" -#include "afb-verbosity.h" - -#include "afb-eventid.h" -#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 - */ -#if defined(AFB_BINDING_PRAGMA_NO_VERBOSE_DATA) - -# define _AFB_DYNAPI_LOGGING_(vlevel,llevel,dynapi,...) \ - do{ \ - if(dynapi->verbosity>=vlevel) {\ - if (llevel <= AFB_VERBOSITY_LEVEL_ERROR) \ - afb_dynapi_verbose(dynapi,llevel,__FILE__,__LINE__,__func__,__VA_ARGS__); \ - else \ - afb_dynapi_verbose(dynapi,llevel,__FILE__,__LINE__,NULL,NULL); \ - } \ - }while(0) -# define _AFB_REQUEST_LOGGING_(vlevel,llevel,request,...) \ - do{ \ - if(request->dynapi->verbosity>=vlevel) \ - afb_request_verbose(request,llevel,__FILE__,__LINE__,NULL,NULL); \ - }while(0) - -#elif defined(AFB_BINDING_PRAGMA_NO_VERBOSE_DETAILS) - -# define _AFB_DYNAPI_LOGGING_(vlevel,llevel,dynapi,...) \ - do{ \ - if(dynapi->verbosity>=vlevel) \ - afb_dynapi_verbose(dynapi,llevel,NULL,0,NULL,__VA_ARGS__); \ - }while(0) -# define _AFB_REQUEST_LOGGING_(vlevel,llevel,request,...) \ - do{ \ - if(request->dynapi->verbosity>=vlevel) \ - afb_request_verbose(request,llevel,NULL,0,NULL,__VA_ARGS__); \ - }while(0) - -#else - -# define _AFB_DYNAPI_LOGGING_(vlevel,llevel,dynapi,...) \ - do{ \ - if(dynapi->verbosity>=vlevel) \ - afb_dynapi_verbose(dynapi,llevel,__FILE__,__LINE__,__func__,__VA_ARGS__); \ - }while(0) -# define _AFB_REQUEST_LOGGING_(vlevel,llevel,request,...) \ - do{ \ - if(request->dynapi->verbosity>=vlevel) \ - afb_request_verbose(request,llevel,__FILE__,__LINE__,__func__,__VA_ARGS__); \ - }while(0) - -#endif - -#define AFB_DYNAPI_ERROR(...) _AFB_DYNAPI_LOGGING_(AFB_VERBOSITY_LEVEL_ERROR,_AFB_SYSLOG_LEVEL_ERROR_,__VA_ARGS__) -#define AFB_DYNAPI_WARNING(...) _AFB_DYNAPI_LOGGING_(AFB_VERBOSITY_LEVEL_WARNING,_AFB_SYSLOG_LEVEL_WARNING_,__VA_ARGS__) -#define AFB_DYNAPI_NOTICE(...) _AFB_DYNAPI_LOGGING_(AFB_VERBOSITY_LEVEL_NOTICE,_AFB_SYSLOG_LEVEL_NOTICE_,__VA_ARGS__) -#define AFB_DYNAPI_INFO(...) _AFB_DYNAPI_LOGGING_(AFB_VERBOSITY_LEVEL_INFO,_AFB_SYSLOG_LEVEL_INFO_,__VA_ARGS__) -#define AFB_DYNAPI_DEBUG(...) _AFB_DYNAPI_LOGGING_(AFB_VERBOSITY_LEVEL_DEBUG,_AFB_SYSLOG_LEVEL_DEBUG_,__VA_ARGS__) -#define AFB_REQUEST_ERROR(...) _AFB_REQUEST_LOGGING_(AFB_VERBOSITY_LEVEL_ERROR,_AFB_SYSLOG_LEVEL_ERROR_,__VA_ARGS__) -#define AFB_REQUEST_WARNING(...) _AFB_REQUEST_LOGGING_(AFB_VERBOSITY_LEVEL_WARNING,_AFB_SYSLOG_LEVEL_WARNING_,__VA_ARGS__) -#define AFB_REQUEST_NOTICE(...) _AFB_REQUEST_LOGGING_(AFB_VERBOSITY_LEVEL_NOTICE,_AFB_SYSLOG_LEVEL_NOTICE_,__VA_ARGS__) -#define AFB_REQUEST_INFO(...) _AFB_REQUEST_LOGGING_(AFB_VERBOSITY_LEVEL_INFO,_AFB_SYSLOG_LEVEL_INFO_,__VA_ARGS__) -#define AFB_REQUEST_DEBUG(...) _AFB_REQUEST_LOGGING_(AFB_VERBOSITY_LEVEL_DEBUG,_AFB_SYSLOG_LEVEL_DEBUG_,__VA_ARGS__) - - diff --git a/include/afb/afb-binding.h b/include/afb/afb-binding.h index 37305991..085dc388 100644 --- a/include/afb/afb-binding.h +++ b/include/afb/afb-binding.h @@ -17,246 +17,105 @@ #pragma once +/** + * @mainpage + * + * @section brief Brief introduction + * + * This is part of the AGL framework micro-service binder and is provided as the + * API for writing bindings. + * + * The normal usage is to include only one file as below: + * + * ```C + * #define AFB_BINDING_VERSION 3 + * #include <afb/afb-binding.h> + * ``` + * + * @example tuto-1.c + * @example tuto-2.c + */ +/** + * @file afb/afb-binding.h + */ + #include <stdarg.h> +#include <stdint.h> +struct json_object; -/***************************************************************************** - * This files is the main file to include for writing bindings dedicated to +/** + * @def AFB_BINDING_INTERFACE_VERSION + + * * Version of the binding interface. * - * AFB-DAEMON + * This is intended to be test for tuning condition code. + * It is of the form MAJOR * 1000 + REVISION. * - * Functions of bindings of afb-daemon are accessible by authorized clients - * through the apis module of afb-daemon. + * @see AFB_BINDING_UPPER_VERSION that should match MAJOR */ +#define AFB_BINDING_INTERFACE_VERSION 3000 +/** + * @def AFB_BINDING_LOWER_VERSION + * + * Lowest binding API version supported. + * + * @see AFB_BINDING_VERSION + * @see AFB_BINDING_UPPER_VERSION + */ #define AFB_BINDING_LOWER_VERSION 1 -#define AFB_BINDING_UPPER_VERSION 2 + +/** + * @def AFB_BINDING_UPPER_VERSION + * + * Upper binding API version supported. + * + * @see AFB_BINDING_VERSION + * @see AFB_BINDING_LOWER_VERSION + */ +#define AFB_BINDING_UPPER_VERSION 3 + +/** + * @def AFB_BINDING_VERSION + * + * This macro must be defined before including <afb/afb-binding.h> to set + * the required binding API. + */ #ifndef AFB_BINDING_VERSION -#define AFB_BINDING_VERSION 1 -#pragma GCC warning "\ +#error "\ \n\ \n\ AFB_BINDING_VERSION should be defined before including <afb/afb-binding.h>\n\ AFB_BINDING_VERSION defines the version of binding that you use.\n\ - Currently, known versions are 1 or 2.\n\ - Setting now AFB_BINDING_VERSION to 1 (version 1 by default)\n\ - NOTE THAT VERSION 2 IS NOW RECOMMENDED!\n\ + Currently the version to use is 3 (older versions: 1 is obsolete, 2 is legacy).\n\ Consider to add one of the following define before including <afb/afb-binding.h>:\n\ \n\ - #define AFB_BINDING_VERSION 1\n\ - #define AFB_BINDING_VERSION 2\n\ + #define AFB_BINDING_VERSION 3\n\ \n\ - Note that in some case it will enforce you to include <stdio.h>\n\ " -#include <stdio.h> /* old version side effect */ #else # if AFB_BINDING_VERSION == 1 -# pragma GCC warning "Using binding version 1, consider to switch to version 2" +# pragma GCC warning "Using binding version 1, consider to switch to version 3" +# endif +# if AFB_BINDING_VERSION == 2 +# pragma GCC warning "Using binding version 2, consider to switch to version 3" # endif #endif #if AFB_BINDING_VERSION != 0 # if AFB_BINDING_VERSION < AFB_BINDING_LOWER_VERSION || AFB_BINDING_VERSION > AFB_BINDING_UPPER_VERSION -# error "Unsupported binding version AFB_BINDING_VERSION " #AFB_BINDING_VERSION +# error "Unsupported binding version AFB_BINDING_VERSION" # endif #endif -/* - * Some function of the library are exported to afb-daemon. - */ - +/***************************************************************************************************/ +#include "afb-binding-predefs.h" #include "afb-binding-v1.h" #include "afb-binding-v2.h" -#include "afb-binding-vdyn.h" - -typedef struct afb_verb_desc_v1 afb_verb_desc_v1; -typedef struct afb_binding_desc_v1 afb_binding_desc_v1; -typedef struct afb_binding_v1 afb_binding_v1; -typedef struct afb_binding_interface_v1 afb_binding_interface_v1; - -typedef struct afb_verb_v2 afb_verb_v2; -typedef struct afb_binding_v2 afb_binding_v2; - -typedef enum afb_auth_type afb_auth_type; -typedef struct afb_auth afb_auth; -typedef struct afb_daemon afb_daemon; -typedef struct afb_event afb_event; -typedef struct afb_arg afb_arg; -typedef struct afb_req afb_req; -typedef struct afb_stored_req afb_stored_req; -typedef struct afb_service afb_service; - -typedef struct afb_dynapi afb_dynapi; -typedef struct afb_request afb_request; -typedef struct afb_eventid afb_eventid; - -#if 0 -/* these typedef's shouldn't be needed */ -typedef enum afb_binding_type_v1 afb_binding_type_v1; -typedef enum afb_mode_v1 afb_mode_v1; -typedef enum afb_session_flags_v1 afb_session_flags_v1; -typedef enum afb_session_flags_v2 afb_session_flags_v2; -typedef struct afb_binding_data_v2 afb_binding_data_v2; -typedef struct afb_daemon_itf afb_daemon_itf; -typedef struct afb_event_itf afb_event_itf; -typedef struct afb_req_itf afb_req_itf; -typedef struct afb_service_itf afb_service_itf; -#endif - -/***************************************************************************************************/ - -#if AFB_BINDING_VERSION == 1 - -# define afb_binding afb_binding_v1 -# define afb_binding_interface afb_binding_interface_v1 - -# define AFB_SESSION_NONE AFB_SESSION_NONE_V1 -# define AFB_SESSION_CREATE AFB_SESSION_CREATE_V1 -# define AFB_SESSION_CLOSE AFB_SESSION_CLOSE_V1 -# define AFB_SESSION_RENEW AFB_SESSION_RENEW_V1 -# define AFB_SESSION_CHECK AFB_SESSION_CHECK_V1 - -# define AFB_SESSION_LOA_GE AFB_SESSION_LOA_GE_V1 -# define AFB_SESSION_LOA_LE AFB_SESSION_LOA_LE_V1 -# define AFB_SESSION_LOA_EQ AFB_SESSION_LOA_EQ_V1 - -# define AFB_SESSION_LOA_SHIFT AFB_SESSION_LOA_SHIFT_V1 -# define AFB_SESSION_LOA_MASK AFB_SESSION_LOA_MASK_V1 - -# define AFB_SESSION_LOA_0 AFB_SESSION_LOA_0_V1 -# define AFB_SESSION_LOA_1 AFB_SESSION_LOA_1_V1 -# define AFB_SESSION_LOA_2 AFB_SESSION_LOA_2_V1 -# define AFB_SESSION_LOA_3 AFB_SESSION_LOA_3_V1 -# define AFB_SESSION_LOA_4 AFB_SESSION_LOA_4_V1 - -# define AFB_SESSION_LOA_LE_0 AFB_SESSION_LOA_LE_0_V1 -# define AFB_SESSION_LOA_LE_1 AFB_SESSION_LOA_LE_1_V1 -# define AFB_SESSION_LOA_LE_2 AFB_SESSION_LOA_LE_2_V1 -# define AFB_SESSION_LOA_LE_3 AFB_SESSION_LOA_LE_3_V1 - -# define AFB_SESSION_LOA_EQ_0 AFB_SESSION_LOA_EQ_0_V1 -# define AFB_SESSION_LOA_EQ_1 AFB_SESSION_LOA_EQ_1_V1 -# define AFB_SESSION_LOA_EQ_2 AFB_SESSION_LOA_EQ_2_V1 -# define AFB_SESSION_LOA_EQ_3 AFB_SESSION_LOA_EQ_3_V1 - -# define AFB_SESSION_LOA_GE_0 AFB_SESSION_LOA_GE_0_V1 -# define AFB_SESSION_LOA_GE_1 AFB_SESSION_LOA_GE_1_V1 -# define AFB_SESSION_LOA_GE_2 AFB_SESSION_LOA_GE_2_V1 -# define AFB_SESSION_LOA_GE_3 AFB_SESSION_LOA_GE_3_V1 - -# define AFB_ERROR AFB_ERROR_V1 -# define AFB_WARNING AFB_WARNING_V1 -# define AFB_NOTICE AFB_NOTICE_V1 -# define AFB_INFO AFB_INFO_V1 -# define AFB_DEBUG AFB_DEBUG_V1 - -# define AFB_REQ_ERROR AFB_REQ_ERROR_V1 -# define AFB_REQ_WARNING AFB_REQ_WARNING_V1 -# define AFB_REQ_NOTICE AFB_REQ_NOTICE_V1 -# define AFB_REQ_INFO AFB_REQ_INFO_V1 -# define AFB_REQ_DEBUG AFB_REQ_DEBUG_V1 - -#define afb_daemon_get_event_loop afb_daemon_get_event_loop_v1 -#define afb_daemon_get_user_bus afb_daemon_get_user_bus_v1 -#define afb_daemon_get_system_bus afb_daemon_get_system_bus_v1 -#define afb_daemon_broadcast_event afb_daemon_broadcast_event_v1 -#define afb_daemon_make_event afb_daemon_make_event_v1 -#define afb_daemon_verbose afb_daemon_verbose_v1 -#define afb_daemon_rootdir_get_fd afb_daemon_rootdir_get_fd_v1 -#define afb_daemon_rootdir_open_locale afb_daemon_rootdir_open_locale_v1 -#define afb_daemon_queue_job afb_daemon_queue_job_v1 -#define afb_daemon_require_api afb_daemon_require_api_v1 -#define afb_daemon_rename_api afb_daemon_rename_api_v1 - -#define afb_service_call afb_service_call_v1 -#define afb_service_call_sync afb_service_call_sync_v1 - -#define afb_req_store afb_req_store_v1 -#define afb_req_unstore afb_req_unstore_v1 - -#endif - -/***************************************************************************************************/ - -#if AFB_BINDING_VERSION == 2 - -# define afb_binding afb_binding_v2 -# define afb_get_verbosity afb_get_verbosity_v2 -# define afb_get_daemon afb_get_daemon_v2 -# define afb_get_service afb_get_service_v2 - - -# define AFB_SESSION_NONE AFB_SESSION_NONE_V2 -# define AFB_SESSION_CLOSE AFB_SESSION_CLOSE_V2 -# define AFB_SESSION_RENEW AFB_SESSION_REFRESH_V2 -# define AFB_SESSION_REFRESH AFB_SESSION_REFRESH_V2 -# define AFB_SESSION_CHECK AFB_SESSION_CHECK_V2 - -# define AFB_SESSION_LOA_MASK AFB_SESSION_LOA_MASK_V2 - -# define AFB_SESSION_LOA_0 AFB_SESSION_LOA_0_V2 -# define AFB_SESSION_LOA_1 AFB_SESSION_LOA_1_V2 -# define AFB_SESSION_LOA_2 AFB_SESSION_LOA_2_V2 -# define AFB_SESSION_LOA_3 AFB_SESSION_LOA_3_V2 - -# define AFB_ERROR AFB_ERROR_V2 -# define AFB_WARNING AFB_WARNING_V2 -# define AFB_NOTICE AFB_NOTICE_V2 -# define AFB_INFO AFB_INFO_V2 -# define AFB_DEBUG AFB_DEBUG_V2 - -# define AFB_REQ_ERROR AFB_REQ_ERROR_V2 -# define AFB_REQ_WARNING AFB_REQ_WARNING_V2 -# define AFB_REQ_NOTICE AFB_REQ_NOTICE_V2 -# define AFB_REQ_INFO AFB_REQ_INFO_V2 -# define AFB_REQ_DEBUG AFB_REQ_DEBUG_V2 - -#define afb_daemon_get_event_loop afb_daemon_get_event_loop_v2 -#define afb_daemon_get_user_bus afb_daemon_get_user_bus_v2 -#define afb_daemon_get_system_bus afb_daemon_get_system_bus_v2 -#define afb_daemon_broadcast_event afb_daemon_broadcast_event_v2 -#define afb_daemon_make_event afb_daemon_make_event_v2 -#define afb_daemon_verbose afb_daemon_verbose_v2 -#define afb_daemon_rootdir_get_fd afb_daemon_rootdir_get_fd_v2 -#define afb_daemon_rootdir_open_locale afb_daemon_rootdir_open_locale_v2 -#define afb_daemon_queue_job afb_daemon_queue_job_v2 -#define afb_daemon_unstore_req afb_daemon_unstore_req_v2 -#define afb_daemon_require_api afb_daemon_require_api_v2 -#define afb_daemon_rename_api afb_daemon_rename_api_v2 - -#define afb_service_call afb_service_call_v2 -#define afb_service_call_sync afb_service_call_sync_v2 - -#define afb_req_store afb_req_store_v2 -#define afb_req_unstore afb_daemon_unstore_req_v2 - -#endif - -/***************************************************************************************************/ - -#if AFB_BINDING_VERSION >= 2 - -# define afb_verbose_error() (afb_get_verbosity() >= AFB_VERBOSITY_LEVEL_ERROR) -# define afb_verbose_warning() (afb_get_verbosity() >= AFB_VERBOSITY_LEVEL_WARNING) -# define afb_verbose_notice() (afb_get_verbosity() >= AFB_VERBOSITY_LEVEL_NOTICE) -# define afb_verbose_info() (afb_get_verbosity() >= AFB_VERBOSITY_LEVEL_INFO) -# define afb_verbose_debug() (afb_get_verbosity() >= AFB_VERBOSITY_LEVEL_DEBUG) - -#endif - -/***************************************************************************************************/ - -#if defined(AFB_BINDING_PRAGMA_KEEP_VERBOSE_UNPREFIX) -# define ERROR AFB_ERROR -# define WARNING AFB_WARNING -# define NOTICE AFB_NOTICE -# define INFO AFB_INFO -# define DEBUG AFB_DEBUG - -# define REQ_ERROR AFB_REQ_ERROR -# define REQ_WARNING AFB_REQ_WARNING -# define REQ_NOTICE AFB_REQ_NOTICE -# define REQ_INFO AFB_REQ_INFO -# define REQ_DEBUG AFB_REQ_DEBUG +#include "afb-binding-v3.h" +#if defined(AFB_BINDING_WANT_DYNAPI) +# include "afb-dynapi-legacy.h" #endif +#include "afb-binding-postdefs.h" diff --git a/include/afb/afb-binding.hpp b/include/afb/afb-binding.hpp index ee151339..27715f39 100644 --- a/include/afb/afb-binding.hpp +++ b/include/afb/afb-binding.hpp @@ -17,18 +17,19 @@ #pragma once +#include <cstddef> #include <cstdlib> #include <cstdarg> #include <functional> /* ensure version */ #ifndef AFB_BINDING_VERSION -# define AFB_BINDING_VERSION 2 +# define AFB_BINDING_VERSION 3 #endif /* check the version */ #if AFB_BINDING_VERSION < 2 -# error "AFB_BINDING_VERSION must be at least 2" +# error "AFB_BINDING_VERSION must be at least 2 but 3 is prefered" #endif /* get C definitions of bindings */ @@ -44,16 +45,11 @@ namespace afb { class arg; class event; class req; -class stored_req; /*************************************************************************/ /* declaration of functions */ /*************************************************************************/ -struct sd_event *get_event_loop(); -struct sd_bus *get_system_bus(); -struct sd_bus *get_user_bus(); - int broadcast_event(const char *name, json_object *object = nullptr); event make_event(const char *name); @@ -70,7 +66,7 @@ int queue_job(void (*callback)(int signum, void *arg), void *argument, void *gro int require_api(const char *apiname, bool initialized = true); -int rename_api(const char *apiname); +int add_alias(const char *apiname, const char *aliasname); int verbosity(); @@ -80,9 +76,17 @@ bool wants_notices(); bool wants_infos(); bool wants_debugs(); +#if AFB_BINDING_VERSION >= 3 +void call(const char *api, const char *verb, struct json_object *args, void (*callback)(void*closure, int iserror, struct json_object *result, afb_api_t api), void *closure); + +template <class T> void call(const char *api, const char *verb, struct json_object *args, void (*callback)(T*closure, int iserror, struct json_object *result, afb_api_t api), T *closure); + +bool callsync(const char *api, const char *verb, struct json_object *args, struct json_object *&result); +#else void call(const char *api, const char *verb, struct json_object *args, void (*callback)(void*closure, int iserror, struct json_object *result), void *closure); template <class T> void call(const char *api, const char *verb, struct json_object *args, void (*callback)(T*closure, int iserror, struct json_object *result), T *closure); +#endif bool callsync(const char *api, const char *verb, struct json_object *args, struct json_object *&result); @@ -93,14 +97,15 @@ bool callsync(const char *api, const char *verb, struct json_object *args, struc /* events */ class event { - struct afb_event event_; + afb_event_t event_; public: - event() { event_.itf = nullptr; event_.closure = nullptr; } - event(const struct afb_event &e); + event() { invalidate(); } + event(afb_event_t e); event(const event &other); event &operator=(const event &other); - operator const struct afb_event&() const; + operator afb_event_t() const; + afb_event_t operator->() const; operator bool() const; bool is_valid() const; @@ -139,30 +144,16 @@ public: /* req(uest) */ class req { - struct afb_req req_; -public: - class stored - { - struct afb_stored_req *sreq_; - - friend class req; - stored() = delete; - stored(struct afb_stored_req *sr); - public: - stored(const stored &other); - stored &operator =(const stored &other); - req unstore() const; - }; - - class stored; + afb_req_t req_; public: req() = delete; - req(const struct afb_req &r); + req(afb_req_t r); req(const req &other); req &operator=(const req &other); - operator const struct afb_req&() const; + operator afb_req_t() const; + afb_req_t operator->() const; operator bool() const; bool is_valid() const; @@ -175,22 +166,20 @@ public: json_object *json() const; + void reply(json_object *obj = nullptr, const char *error = nullptr, const char *info = nullptr) const; + void replyf(json_object *obj, const char *error, const char *info, ...) const; + void replyv(json_object *obj, const char *error, const char *info, va_list args) const; + void success(json_object *obj = nullptr, const char *info = nullptr) const; void successf(json_object *obj, const char *info, ...) const; + void successv(json_object *obj, const char *info, va_list args) const; - void fail(const char *status = "failed", const char *info = nullptr) const; - void failf(const char *status, const char *info, ...) const; - - void *context_get() const; - - void context_set(void *context, void (*free_context)(void*)) const; - - void *context(void *(*create_context)(), void (*free_context)(void*)) const; + void fail(const char *error = "failed", const char *info = nullptr) const; + void failf(const char *error, const char *info, ...) const; + void failv(const char *error, const char *info, va_list args) const; template < class T > T *context() const; - void context_clear() const; - void addref() const; void unref() const; @@ -199,19 +188,22 @@ public: bool session_set_LOA(unsigned level) const; - stored store() const; - bool subscribe(const event &event) const; bool unsubscribe(const event &event) const; - void subcall(const char *api, const char *verb, json_object *args, void (*callback)(void *closure, int iserror, json_object *result), void *closure) const; + void subcall(const char *api, const char *verb, json_object *args, void (*callback)(void *closure, int iserror, json_object *result, afb_req_t req), void *closure) const; + template <class T> void subcall(const char *api, const char *verb, json_object *args, void (*callback)(T *closure, int iserror, json_object *result, afb_req_t req), T *closure) const; - void subcall(const char *api, const char *verb, json_object *args, void (*callback)(void *closure, int iserror, json_object *result, afb_req req), void *closure) const; + bool subcallsync(const char *api, const char *verb, json_object *args, struct json_object *&result) const; - template <class T> void subcall(const char *api, const char *verb, json_object *args, void (*callback)(T *closure, int iserror, json_object *result), T *closure) const; +#if AFB_BINDING_VERSION >= 3 + void subcall(const char *api, const char *verb, json_object *args, int flags, void (*callback)(void *closure, json_object *object, const char *error, const char *info, afb_req_t req), void *closure) const; - bool subcallsync(const char *api, const char *verb, json_object *args, struct json_object *&result) const; + template <class T> void subcall(const char *api, const char *verb, json_object *args, int flags, void (*callback)(T *closure, json_object *object, const char *error, const char *info, afb_req_t req), T *closure) const; + + bool subcallsync(const char *api, const char *verb, json_object *args, int flags, struct json_object *&object, char *&error, char *&info) const; +#endif void verbose(int level, const char *file, int line, const char * func, const char *fmt, va_list args) const; @@ -222,6 +214,8 @@ public: char *get_application_id() const; int get_uid() const; + + json_object *get_client_info() const; }; /*************************************************************************/ @@ -250,18 +244,23 @@ public: /*************************************************************************/ /* events */ -inline event::event(const struct afb_event &e) : event_(e) { } +inline event::event(afb_event_t e) : event_(e) { } inline event::event(const event &other) : event_(other.event_) { } inline event &event::operator=(const event &other) { event_ = other.event_; return *this; } -inline event::operator const struct afb_event&() const { return event_; } +inline event::operator afb_event_t() const { return event_; } +inline afb_event_t event::operator->() const { return event_; } inline event::operator bool() const { return is_valid(); } -inline bool event::is_valid() const { return afb_event_is_valid(event_); } +inline bool event::is_valid() const { return afb_event_is_valid(event_); } -inline void event::invalidate() { event_.itf = NULL; event_.closure = NULL; } +#if AFB_BINDING_VERSION >= 3 +inline void event::invalidate() { event_ = nullptr; } +#else +inline void event::invalidate() { event_ = { nullptr, nullptr }; } +#endif -inline int event::broadcast(json_object *object) const { return afb_event_broadcast(event_, object); } +inline int event::broadcast(json_object *object) const { return afb_event_broadcast(event_, object); } inline int event::push(json_object *object) const { return afb_event_push(event_, object); } inline void event::unref() { afb_event_unref(event_); invalidate(); } @@ -285,23 +284,16 @@ inline const char *arg::path() const { return arg_.path; } /* req(uests)s */ -inline req::stored::stored(struct afb_stored_req *sr) : sreq_(sr) {} - -inline req::stored::stored(const req::stored &other) : sreq_(other.sreq_) {} - -inline req::stored &req::stored::operator =(const req::stored &other) { sreq_ = other.sreq_; return *this; } - -inline req req::stored::unstore() const { return req(afb_daemon_unstore_req_v2(sreq_)); } - -inline req::req(const struct afb_req &r) : req_(r) {} +inline req::req(afb_req_t r) : req_(r) {} inline req::req(const req &other) : req_(other.req_) {} inline req &req::operator=(const req &other) { req_ = other.req_; return *this; } -inline req::operator const struct afb_req&() const { return req_; } +inline req::operator afb_req_t() const { return req_; } +inline afb_req_t req::operator->() const { return req_; } -inline req::operator bool() const { return !!afb_req_is_valid(req_); } -inline bool req::is_valid() const { return !!afb_req_is_valid(req_); } +inline req::operator bool() const { return is_valid(); } +inline bool req::is_valid() const { return afb_req_is_valid(req_); } inline arg req::get(const char *name) const { return arg(afb_req_get(req_, name)); } @@ -311,160 +303,210 @@ inline const char *req::path(const char *name) const { return afb_req_path(req_, inline json_object *req::json() const { return afb_req_json(req_); } -inline void req::success(json_object *obj, const char *info) const { afb_req_success(req_, obj, info); } -inline void req::successf(json_object *obj, const char *info, ...) const +inline void req::reply(json_object *obj, const char *error, const char *info) const { afb_req_reply(req_, obj, error, info); } +inline void req::replyv(json_object *obj, const char *error, const char *info, va_list args) const { afb_req_reply_v(req_, obj, error, info, args); } +inline void req::replyf(json_object *obj, const char *error, const char *info, ...) const { va_list args; va_start(args, info); - afb_req_success_v(req_, obj, info, args); + replyv(obj, error, info, args); va_end(args); } -inline void req::fail(const char *status, const char *info) const { afb_req_fail(req_, status, info); } -inline void req::failf(const char *status, const char *info, ...) const +inline void req::success(json_object *obj, const char *info) const { reply(obj, nullptr, info); } +inline void req::successv(json_object *obj, const char *info, va_list args) const { replyv(obj, nullptr, info, args); } +inline void req::successf(json_object *obj, const char *info, ...) const { va_list args; va_start(args, info); - afb_req_fail_v(req_, status, info, args); + successv(obj, info, args); va_end(args); } -inline void *req::context_get() const { return afb_req_context_get(req_); } - -inline void req::context_set(void *context, void (*free_context)(void*)) const { afb_req_context_set(req_, context, free_context); } - -inline void *req::context(void *(*create_context)(), void (*free_context)(void*)) const { return afb_req_context(req_, create_context, free_context); } +inline void req::fail(const char *error, const char *info) const { reply(nullptr, error, info); } +inline void req::failv(const char *error, const char *info, va_list args) const { replyv(nullptr, error, info, args); } +inline void req::failf(const char *error, const char *info, ...) const +{ + va_list args; + va_start(args, info); + failv(error, info, args); + va_end(args); +} template < class T > inline T *req::context() const { +#if AFB_BINDING_VERSION >= 3 + T* (*creater)(void*) = [](){return new T();}; + void (*freer)(T*) = [](T*t){delete t;}; + return reinterpret_cast<T*>(afb_req_context(req_, 0, + reinterpret_cast<void *(*)(void*)>(creater), + reinterpret_cast<void (*)(void*)>(freer), nullptr)); +#else T* (*creater)() = [](){return new T();}; void (*freer)(T*) = [](T*t){delete t;}; return reinterpret_cast<T*>(afb_req_context(req_, reinterpret_cast<void *(*)()>(creater), reinterpret_cast<void (*)(void*)>(freer))); +#endif } -inline void req::context_clear() const { afb_req_context_clear(req_); } - inline void req::addref() const { afb_req_addref(req_); } inline void req::unref() const { afb_req_unref(req_); } inline void req::session_close() const { afb_req_session_close(req_); } -inline bool req::session_set_LOA(unsigned level) const { return !!afb_req_session_set_LOA(req_, level); } - -inline req::stored req::store() const { return stored(afb_req_store_v2(req_)); } +inline bool req::session_set_LOA(unsigned level) const { return !afb_req_session_set_LOA(req_, level); } inline bool req::subscribe(const event &event) const { return !afb_req_subscribe(req_, event); } inline bool req::unsubscribe(const event &event) const { return !afb_req_unsubscribe(req_, event); } -inline void req::subcall(const char *api, const char *verb, json_object *args, void (*callback)(void *closure, int iserror, json_object *result), void *closure) const + + + + +#if AFB_BINDING_VERSION >= 3 + +inline void req::subcall(const char *api, const char *verb, json_object *args, int flags, void (*callback)(void *closure, json_object *result, const char *error, const char *info, afb_req_t req), void *closure) const { - afb_req_subcall(req_, api, verb, args, callback, closure); + afb_req_subcall(req_, api, verb, args, flags, callback, closure); } -inline void req::subcall(const char *api, const char *verb, json_object *args, void (*callback)(void *closure, int iserror, json_object *result, struct afb_req req), void *closure) const +template <class T> +inline void req::subcall(const char *api, const char *verb, json_object *args, int flags, void (*callback)(T *closure, json_object *result, const char *error, const char *info, afb_req_t req), T *closure) const { + subcall(api, verb, args, flags, reinterpret_cast<void(*)(void*,json_object*,const char*,const char*,afb_req_t)>(callback), reinterpret_cast<void*>(closure)); +} + +inline bool req::subcallsync(const char *api, const char *verb, json_object *args, int flags, struct json_object *&object, char *&error, char *&info) const +{ + return !afb_req_subcall_sync(req_, api, verb, args, flags, &object, &error, &info); +} + +#endif + +inline void req::subcall(const char *api, const char *verb, json_object *args, void (*callback)(void *closure, int iserror, json_object *result, afb_req_t req), void *closure) const +{ +#if AFB_BINDING_VERSION >= 3 + afb_req_subcall_legacy(req_, api, verb, args, callback, closure); +#else afb_req_subcall_req(req_, api, verb, args, callback, closure); +#endif } template <class T> -inline void req::subcall(const char *api, const char *verb, json_object *args, void (*callback)(T *closure, int iserror, json_object *result), T *closure) const +inline void req::subcall(const char *api, const char *verb, json_object *args, void (*callback)(T *closure, int iserror, json_object *result, afb_req_t req), T *closure) const { - afb_req_subcall(req_, api, verb, args, reinterpret_cast<void(*)(void*,int,json_object*)>(callback), reinterpret_cast<void*>(closure)); + subcall(api, verb, args, reinterpret_cast<void(*)(void*,int,json_object*,afb_req_t)>(callback), reinterpret_cast<void*>(closure)); } inline bool req::subcallsync(const char *api, const char *verb, json_object *args, struct json_object *&result) const { - return !!afb_req_subcall_sync(req_, api, verb, args, &result); +#if AFB_BINDING_VERSION >= 3 + return !afb_req_subcall_sync_legacy(req_, api, verb, args, &result); +#else + return !afb_req_subcall_sync(req_, api, verb, args, &result); +#endif } inline void req::verbose(int level, const char *file, int line, const char * func, const char *fmt, va_list args) const { - req_.itf->vverbose(req_.closure, level, file, line, func, fmt, args); + afb_req_verbose(req_, level, file, line, func, fmt, args); } inline void req::verbose(int level, const char *file, int line, const char * func, const char *fmt, ...) const { va_list args; va_start(args, fmt); - req_.itf->vverbose(req_.closure, level, file, line, func, fmt, args); + afb_req_verbose(req_, level, file, line, func, fmt, args); va_end(args); } inline bool req::has_permission(const char *permission) const { - return bool(req_.itf->has_permission(req_.closure, permission)); + return bool(afb_req_has_permission(req_, permission)); } inline char *req::get_application_id() const { - return req_.itf->get_application_id(req_.closure); + return afb_req_get_application_id(req_); } inline int req::get_uid() const { - return req_.itf->get_uid(req_.closure); + return afb_req_get_uid(req_); } -/* commons */ -inline struct sd_event *get_event_loop() - { return afb_daemon_get_event_loop_v2(); } - -inline struct sd_bus *get_system_bus() - { return afb_daemon_get_system_bus_v2(); } - -inline struct sd_bus *get_user_bus() - { return afb_daemon_get_user_bus_v2(); } +inline json_object *req::get_client_info() const +{ + return afb_req_get_client_info(req_); +} +/* commons */ inline int broadcast_event(const char *name, json_object *object) - { return afb_daemon_broadcast_event_v2(name, object); } + { return afb_daemon_broadcast_event(name, object); } inline event make_event(const char *name) - { return afb_daemon_make_event_v2(name); } + { return afb_daemon_make_event(name); } inline void verbose(int level, const char *file, int line, const char * func, const char *fmt, va_list args) - { afb_daemon_verbose_v2(level, file, line, func, fmt, args); } + { afb_daemon_verbose(level, file, line, func, fmt, args); } inline void verbose(int level, const char *file, int line, const char * func, const char *fmt, ...) { va_list args; va_start(args, fmt); verbose(level, file, line, func, fmt, args); va_end(args); } inline int rootdir_get_fd() - { return afb_daemon_rootdir_get_fd_v2(); } + { return afb_daemon_rootdir_get_fd(); } inline int rootdir_open_locale_fd(const char *filename, int flags, const char *locale) - { return afb_daemon_rootdir_open_locale_v2(filename, flags, locale); } + { return afb_daemon_rootdir_open_locale(filename, flags, locale); } inline int queue_job(void (*callback)(int signum, void *arg), void *argument, void *group, int timeout) - { return afb_daemon_queue_job_v2(callback, argument, group, timeout); } + { return afb_daemon_queue_job(callback, argument, group, timeout); } inline int require_api(const char *apiname, bool initialized) - { return afb_daemon_require_api_v2(apiname, int(initialized)); } + { return afb_daemon_require_api(apiname, int(initialized)); } -inline int rename_api(const char *apiname) - { return afb_daemon_rename_api_v2(apiname); } +inline int add_alias(const char *apiname, const char *aliasname) + { return afb_daemon_add_alias(apiname, aliasname); } -inline int verbosity() - { return afb_get_verbosity(); } +#if AFB_BINDING_VERSION >= 3 +inline int logmask() + { return afb_get_logmask(); } +#else +inline int logmask() + { return (1 << (1 + afb_get_verbosity() + AFB_SYSLOG_LEVEL_ERROR)) - 1; } +#endif inline bool wants_errors() - { return afb_verbose_error(); } + { return AFB_SYSLOG_MASK_WANT_ERROR(logmask()); } inline bool wants_warnings() - { return afb_verbose_warning(); } + { return AFB_SYSLOG_MASK_WANT_WARNING(logmask()); } inline bool wants_notices() - { return afb_verbose_notice(); } + { return AFB_SYSLOG_MASK_WANT_NOTICE(logmask()); } inline bool wants_infos() - { return afb_verbose_info(); } + { return AFB_SYSLOG_MASK_WANT_INFO(logmask()); } inline bool wants_debugs() - { return afb_verbose_debug(); } + { return AFB_SYSLOG_MASK_WANT_DEBUG(logmask()); } +#if AFB_BINDING_VERSION >= 3 +inline void call(const char *api, const char *verb, struct json_object *args, void (*callback)(void*closure, int iserror, struct json_object *result, afb_api_t api), void *closure) +{ + afb_service_call(api, verb, args, callback, closure); +} + +template <class T> +inline void call(const char *api, const char *verb, struct json_object *args, void (*callback)(T*closure, int iserror, struct json_object *result, afb_api_t api), T *closure) +{ + afb_service_call(api, verb, args, reinterpret_cast<void(*)(void*,int,json_object*,afb_api_t)>(callback), reinterpret_cast<void*>(closure)); +} +#else inline void call(const char *api, const char *verb, struct json_object *args, void (*callback)(void*closure, int iserror, struct json_object *result), void *closure) { afb_service_call(api, verb, args, callback, closure); @@ -475,6 +517,7 @@ inline void call(const char *api, const char *verb, struct json_object *args, vo { afb_service_call(api, verb, args, reinterpret_cast<void(*)(void*,int,json_object*)>(callback), reinterpret_cast<void*>(closure)); } +#endif inline bool callsync(const char *api, const char *verb, struct json_object *args, struct json_object *&result) { @@ -563,31 +606,67 @@ constexpr afb_auth auth_and(const afb_auth &first, const afb_auth &next) return auth_and(&first, &next); } -constexpr afb_verb_v2 verb(const char *name, void (*callback)(afb_req), const char *info = nullptr, unsigned session = 0, const afb_auth *auth = nullptr) +constexpr afb_verb_t verb( + const char *name, + void (*callback)(afb_req_t), + const char *info = nullptr, + uint16_t session = 0, + const afb_auth *auth = nullptr +#if AFB_BINDING_VERSION >= 3 + , + bool glob = false, + void *vcbdata = nullptr +#endif +) { - afb_verb_v2 r = { 0, 0, 0, 0, 0 }; +#if AFB_BINDING_VERSION >= 3 + afb_verb_t r = { 0, 0, 0, 0, 0, 0, 0 }; +#else + afb_verb_t r = { 0, 0, 0, 0, 0 }; +#endif r.verb = name; r.callback = callback; r.info = info; r.session = session; r.auth = auth; +#if AFB_BINDING_VERSION >= 3 + r.glob = (unsigned)glob; + r.vcbdata = vcbdata; +#endif return r; } -constexpr afb_verb_v2 verbend() +constexpr afb_verb_t verbend() { - afb_verb_v2 r = { 0, 0, 0, 0, 0 }; - r.verb = nullptr; - r.callback = nullptr; - r.info = nullptr; - r.session = 0; - r.auth = nullptr; + afb_verb_t r = verb(nullptr, nullptr); return r; } -constexpr afb_binding_v2 binding(const char *name, const struct afb_verb_v2 *verbs, const char *info = nullptr, int (*init)() = nullptr, const char *specification = nullptr, void (*onevent)(const char*, struct json_object*) = nullptr, bool noconcurrency = false, int (*preinit)() = nullptr) +constexpr afb_binding_t binding( + const char *name, + const afb_verb_t *verbs, + const char *info = nullptr, +#if AFB_BINDING_VERSION >= 3 + int (*init)(afb_api_t) = nullptr, + const char *specification = nullptr, + void (*onevent)(afb_api_t, const char*, struct json_object*) = nullptr, + bool noconcurrency = false, + int (*preinit)(afb_api_t) = nullptr, + void *userdata = nullptr +#else + int (*init)() = nullptr, + const char *specification = nullptr, + void (*onevent)(const char*, struct json_object*) = nullptr, + bool noconcurrency = false, + int (*preinit)() = nullptr +#endif +) { - afb_binding_v2 r = { 0, 0, 0, 0, 0, 0, 0, 0 }; +#if AFB_BINDING_VERSION >= 3 + afb_binding_t r = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; +#else + afb_binding_t r = { 0, 0, 0, 0, 0, 0, 0, 0 }; +#endif r.api = name; r.specification = specification; r.info = info; @@ -596,6 +675,9 @@ constexpr afb_binding_v2 binding(const char *name, const struct afb_verb_v2 *ver r.init = init; r.onevent = onevent; r.noconcurrency = noconcurrency ? 1 : 0; +#if AFB_BINDING_VERSION >= 3 + r.userdata = userdata; +#endif return r; }; diff --git a/include/afb/afb-daemon-itf-x1.h b/include/afb/afb-daemon-itf-x1.h new file mode 100644 index 00000000..3ca12eba --- /dev/null +++ b/include/afb/afb-daemon-itf-x1.h @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2016, 2017, 2018 "IoT.bzh" + * Author: José Bollo <jose.bollo@iot.bzh> + * + * 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 + +#include <stdarg.h> + +/* declaration of features of libsystemd */ +struct sd_event; +struct sd_bus; +struct afb_stored_req; +struct afb_req_x1; +struct afb_event_x1; +struct afb_api_x3; + +/** + * @deprecated use bindings version 3 + * + * Definition of the facilities provided by the daemon. + */ +struct afb_daemon_itf_x1 +{ + /** broadcasts evant 'name' with 'object' */ + int (*event_broadcast)(struct afb_api_x3 *closure, const char *name, struct json_object *object); + + /** gets the common systemd's event loop */ + struct sd_event *(*get_event_loop)(struct afb_api_x3 *closure); + + /** gets the common systemd's user d-bus */ + struct sd_bus *(*get_user_bus)(struct afb_api_x3 *closure); + + /** gets the common systemd's system d-bus */ + struct sd_bus *(*get_system_bus)(struct afb_api_x3 *closure); + + /** logging messages */ + void (*vverbose_v1)(struct afb_api_x3*closure, int level, const char *file, int line, const char *fmt, va_list args); + + /** creates an event of 'name' */ + struct afb_event_x1 (*event_make)(struct afb_api_x3 *closure, const char *name); + + /** get the file descriptor of the install directory */ + int (*rootdir_get_fd)(struct afb_api_x3 *closure); + + /** opens a file of the install directory */ + int (*rootdir_open_locale)(struct afb_api_x3 *closure, const char *filename, int flags, const char *locale); + + /** queue a job */ + int (*queue_job)(struct afb_api_x3 *closure, void (*callback)(int signum, void *arg), void *argument, void *group, int timeout); + + /** logging messages */ + void (*vverbose_v2)(struct afb_api_x3*closure, int level, const char *file, int line, const char * func, const char *fmt, va_list args); + + /** retrieve a stored request */ + struct afb_req_x1 (*unstore_req)(struct afb_api_x3*closure, struct afb_stored_req *sreq); + + /** require an api */ + int (*require_api)(struct afb_api_x3*closure, const char *name, int initialized); + + /** aliases an api */ + int (*add_alias)(struct afb_api_x3*closure, const char *name, const char *as_name); + + /** creates a new api */ + struct afb_api_x3 *(*new_api)(struct afb_api_x3 *closure, const char *api, const char *info, int noconcurrency, int (*preinit)(void*, struct afb_api_x3 *), void *preinit_closure); +}; + +/** + * @deprecated use bindings version 3 + * + * Structure for accessing daemon. + * See also: afb_daemon_get_event_sender, afb_daemon_get_event_loop, afb_daemon_get_user_bus, afb_daemon_get_system_bus + */ +struct afb_daemon_x1 +{ + const struct afb_daemon_itf_x1 *itf; /**< the interfacing functions */ + struct afb_api_x3 *closure; /**< the closure when calling these functions */ +}; + diff --git a/include/afb/afb-daemon-itf.h b/include/afb/afb-daemon-itf.h deleted file mode 100644 index b8fa1931..00000000 --- a/include/afb/afb-daemon-itf.h +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright (C) 2016, 2017, 2018 "IoT.bzh" - * Author: José Bollo <jose.bollo@iot.bzh> - * - * 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 - -#include <stdarg.h> - -/* declaration of features of libsystemd */ -struct sd_event; -struct sd_bus; -struct afb_stored_req; -struct afb_req; -struct afb_dynapi; - -/* - * Definition of the facilities provided by the daemon. - */ -struct afb_daemon_itf -{ - int (*event_broadcast)(void *closure, const char *name, struct json_object *object); /* broadcasts evant 'name' with 'object' */ - struct sd_event *(*get_event_loop)(void *closure); /* gets the common systemd's event loop */ - struct sd_bus *(*get_user_bus)(void *closure); /* gets the common systemd's user d-bus */ - struct sd_bus *(*get_system_bus)(void *closure); /* gets the common systemd's system d-bus */ - void (*vverbose_v1)(void*closure, int level, const char *file, int line, const char *fmt, va_list args); - struct afb_event (*event_make)(void *closure, const char *name); /* creates an event of 'name' */ - int (*rootdir_get_fd)(void *closure); - int (*rootdir_open_locale)(void *closure, const char *filename, int flags, const char *locale); - int (*queue_job)(void *closure, void (*callback)(int signum, void *arg), void *argument, void *group, int timeout); - void (*vverbose_v2)(void*closure, int level, const char *file, int line, const char * func, const char *fmt, va_list args); - struct afb_req (*unstore_req)(void*closure, struct afb_stored_req *sreq); - int (*require_api)(void*closure, const char *name, int initialized); - int (*rename_api)(void*closure, const char *name); - int (*new_api)(void *closure, const char *api, const char *info, int noconcurrency, int (*preinit)(void*, struct afb_dynapi *), void *preinit_closure); -}; - -/* - * Structure for accessing daemon. - * See also: afb_daemon_get_event_sender, afb_daemon_get_event_loop, afb_daemon_get_user_bus, afb_daemon_get_system_bus - */ -struct afb_daemon -{ - const struct afb_daemon_itf *itf; /* the interfacing functions */ - void *closure; /* the closure when calling these functions */ -}; - diff --git a/include/afb/afb-daemon-v1.h b/include/afb/afb-daemon-v1.h index 5a78b15d..d84517d1 100644 --- a/include/afb/afb-daemon-v1.h +++ b/include/afb/afb-daemon-v1.h @@ -17,36 +17,44 @@ #pragma once -#include "afb-daemon-itf.h" +#include "afb-daemon-itf-x1.h" -/* +/** + * @deprecated use bindings version 3 + * * Retrieves the common systemd's event loop of AFB * 'daemon' MUST be the daemon given in interface when activating the binding. */ -static inline struct sd_event *afb_daemon_get_event_loop_v1(struct afb_daemon daemon) +static inline struct sd_event *afb_daemon_get_event_loop_v1(struct afb_daemon_x1 daemon) { return daemon.itf->get_event_loop(daemon.closure); } -/* +/** + * @deprecated use bindings version 3 + * * Retrieves the common systemd's user/session d-bus of AFB * 'daemon' MUST be the daemon given in interface when activating the binding. */ -static inline struct sd_bus *afb_daemon_get_user_bus_v1(struct afb_daemon daemon) +static inline struct sd_bus *afb_daemon_get_user_bus_v1(struct afb_daemon_x1 daemon) { return daemon.itf->get_user_bus(daemon.closure); } -/* +/** + * @deprecated use bindings version 3 + * * Retrieves the common systemd's system d-bus of AFB * 'daemon' MUST be the daemon given in interface when activating the binding. */ -static inline struct sd_bus *afb_daemon_get_system_bus_v1(struct afb_daemon daemon) +static inline struct sd_bus *afb_daemon_get_system_bus_v1(struct afb_daemon_x1 daemon) { return daemon.itf->get_system_bus(daemon.closure); } -/* +/** + * @deprecated use bindings version 3 + * * Broadcasts widely the event of 'name' with the data 'object'. * 'object' can be NULL. * 'daemon' MUST be the daemon given in interface when activating the binding. @@ -59,12 +67,14 @@ static inline struct sd_bus *afb_daemon_get_system_bus_v1(struct afb_daemon daem * * Returns the count of clients that received the event. */ -static inline int afb_daemon_broadcast_event_v1(struct afb_daemon daemon, const char *name, struct json_object *object) +static inline int afb_daemon_broadcast_event_v1(struct afb_daemon_x1 daemon, const char *name, struct json_object *object) { return daemon.itf->event_broadcast(daemon.closure, name, object); } -/* +/** + * @deprecated use bindings version 3 + * * Creates an event of 'name' and returns it. * 'daemon' MUST be the daemon given in interface when activating the binding. * @@ -72,12 +82,14 @@ static inline int afb_daemon_broadcast_event_v1(struct afb_daemon daemon, const * * See afb_event_is_valid to check if there is an error. */ -static inline struct afb_event afb_daemon_make_event_v1(struct afb_daemon daemon, const char *name) +static inline struct afb_event_x1 afb_daemon_make_event_v1(struct afb_daemon_x1 daemon, const char *name) { return daemon.itf->event_make(daemon.closure, name); } -/* +/** + * @deprecated use bindings version 3 + * * Send a message described by 'fmt' and following parameters * to the journal for the verbosity 'level'. * @@ -96,8 +108,8 @@ static inline struct afb_event afb_daemon_make_event_v1(struct afb_daemon daemon * INFO 6 Informational * DEBUG 7 Debug-level messages */ -static inline void afb_daemon_verbose_v1(struct afb_daemon daemon, int level, const char *file, int line, const char *fmt, ...) __attribute__((format(printf, 5, 6))); -static inline void afb_daemon_verbose_v1(struct afb_daemon daemon, int level, const char *file, int line, const char *fmt, ...) +static inline void afb_daemon_verbose_v1(struct afb_daemon_x1 daemon, int level, const char *file, int line, const char *fmt, ...) __attribute__((format(printf, 5, 6))); +static inline void afb_daemon_verbose_v1(struct afb_daemon_x1 daemon, int level, const char *file, int line, const char *fmt, ...) { va_list args; va_start(args, fmt); @@ -105,7 +117,9 @@ static inline void afb_daemon_verbose_v1(struct afb_daemon daemon, int level, co va_end(args); } -/* +/** + * @deprecated use bindings version 3 + * * Send a message described by 'fmt' and following parameters * to the journal for the verbosity 'level'. * @@ -124,8 +138,8 @@ static inline void afb_daemon_verbose_v1(struct afb_daemon daemon, int level, co * INFO 6 Informational * DEBUG 7 Debug-level messages */ -static inline void afb_daemon_verbose2_v1(struct afb_daemon daemon, int level, const char *file, int line, const char *func, const char *fmt, ...) __attribute__((format(printf, 6, 7))); -static inline void afb_daemon_verbose2_v1(struct afb_daemon daemon, int level, const char *file, int line, const char *func, const char *fmt, ...) +static inline void afb_daemon_verbose2_v1(struct afb_daemon_x1 daemon, int level, const char *file, int line, const char *func, const char *fmt, ...) __attribute__((format(printf, 6, 7))); +static inline void afb_daemon_verbose2_v1(struct afb_daemon_x1 daemon, int level, const char *file, int line, const char *func, const char *fmt, ...) { va_list args; va_start(args, fmt); @@ -133,26 +147,34 @@ static inline void afb_daemon_verbose2_v1(struct afb_daemon daemon, int level, c va_end(args); } -/* +/** + * @deprecated use bindings version 3 + * * Get the root directory file descriptor. This file descriptor can * be used with functions 'openat', 'fstatat', ... + * + * Returns the file descriptor or -1 in case of error. */ -static inline int afb_daemon_rootdir_get_fd_v1(struct afb_daemon daemon) +static inline int afb_daemon_rootdir_get_fd_v1(struct afb_daemon_x1 daemon) { return daemon.itf->rootdir_get_fd(daemon.closure); } -/* - * Opens 'filename' within the root directory with 'flags' (see function openat) +/** + * @deprecated use bindings version 3 + * * using the 'locale' definition (example: "jp,en-US") that can be NULL. + * * Returns the file descriptor or -1 in case of error. */ -static inline int afb_daemon_rootdir_open_locale_v1(struct afb_daemon daemon, const char *filename, int flags, const char *locale) +static inline int afb_daemon_rootdir_open_locale_v1(struct afb_daemon_x1 daemon, const char *filename, int flags, const char *locale) { return daemon.itf->rootdir_open_locale(daemon.closure, filename, flags, locale); } -/* +/** + * @deprecated use bindings version 3 + * * Queue the job defined by 'callback' and 'argument' for being executed asynchronously * in this thread (later) or in an other thread. * If 'group' is not NUL, the jobs queued with a same value (as the pointer value 'group') @@ -165,39 +187,52 @@ static inline int afb_daemon_rootdir_open_locale_v1(struct afb_daemon daemon, co * * Returns 0 in case of success or -1 in case of error. */ -static inline int afb_daemon_queue_job_v1(struct afb_daemon daemon, void (*callback)(int signum, void *arg), void *argument, void *group, int timeout) +static inline int afb_daemon_queue_job_v1(struct afb_daemon_x1 daemon, void (*callback)(int signum, void *arg), void *argument, void *group, int timeout) { return daemon.itf->queue_job(daemon.closure, callback, argument, group, timeout); } -/* +/** + * @deprecated use bindings version 3 + * * Tells that it requires the API of "name" to exist * and if 'initialized' is not null to be initialized. * Calling this function is only allowed within init. + * * Returns 0 in case of success or -1 in case of error. */ -static inline int afb_daemon_require_api_v1(struct afb_daemon daemon, const char *name, int initialized) +static inline int afb_daemon_require_api_v1(struct afb_daemon_x1 daemon, const char *name, int initialized) { return daemon.itf->require_api(daemon.closure, name, initialized); } -/* - * Set the name of the API to 'name'. +/** + * @deprecated use bindings version 3 + * + * Create an aliased name 'as_name' for the api 'name'. * Calling this function is only allowed within preinit. + * * Returns 0 in case of success or -1 in case of error. */ -static inline int afb_daemon_rename_api_v1(struct afb_daemon daemon, const char *name) +static inline int afb_daemon_add_alias_v1(struct afb_daemon_x1 daemon, const char *name, const char *as_name) { - return daemon.itf->rename_api(daemon.closure, name); + return daemon.itf->add_alias(daemon.closure, name, as_name); } +/** + * @deprecated use bindings version 3 + * + * Creates a new api of name 'api' with brief 'info'. + * + * Returns 0 in case of success or -1 in case of error. + */ static inline int afb_daemon_new_api_v1( - struct afb_daemon daemon, + struct afb_daemon_x1 daemon, const char *api, const char *info, int noconcurrency, - int (*preinit)(void*, struct afb_dynapi *), + int (*preinit)(void*, struct afb_api_x3 *), void *closure) { - return daemon.itf->new_api(daemon.closure, api, info, noconcurrency, preinit, closure); + return -!daemon.itf->new_api(daemon.closure, api, info, noconcurrency, preinit, closure); } diff --git a/include/afb/afb-daemon-v2.h b/include/afb/afb-daemon-v2.h index 4b8399c4..f3c2c904 100644 --- a/include/afb/afb-daemon-v2.h +++ b/include/afb/afb-daemon-v2.h @@ -17,9 +17,11 @@ #pragma once -#include "afb-daemon-itf.h" +#include "afb-daemon-itf-x1.h" -/* +/** + * @deprecated use bindings version 3 + * * Retrieves the common systemd's event loop of AFB */ static inline struct sd_event *afb_daemon_get_event_loop_v2() @@ -27,7 +29,9 @@ static inline struct sd_event *afb_daemon_get_event_loop_v2() return afb_get_daemon_v2().itf->get_event_loop(afb_get_daemon_v2().closure); } -/* +/** + * @deprecated use bindings version 3 + * * Retrieves the common systemd's user/session d-bus of AFB */ static inline struct sd_bus *afb_daemon_get_user_bus_v2() @@ -35,7 +39,9 @@ static inline struct sd_bus *afb_daemon_get_user_bus_v2() return afb_get_daemon_v2().itf->get_user_bus(afb_get_daemon_v2().closure); } -/* +/** + * @deprecated use bindings version 3 + * * Retrieves the common systemd's system d-bus of AFB */ static inline struct sd_bus *afb_daemon_get_system_bus_v2() @@ -43,7 +49,9 @@ static inline struct sd_bus *afb_daemon_get_system_bus_v2() return afb_get_daemon_v2().itf->get_system_bus(afb_get_daemon_v2().closure); } -/* +/** + * @deprecated use bindings version 3 + * * Broadcasts widely the event of 'name' with the data 'object'. * 'object' can be NULL. * @@ -60,19 +68,23 @@ static inline int afb_daemon_broadcast_event_v2(const char *name, struct json_ob return afb_get_daemon_v2().itf->event_broadcast(afb_get_daemon_v2().closure, name, object); } -/* +/** + * @deprecated use bindings version 3 + * * Creates an event of 'name' and returns it. * * Calling this function is only forbidden during preinit. * * See afb_event_is_valid to check if there is an error. */ -static inline struct afb_event afb_daemon_make_event_v2(const char *name) +static inline struct afb_event_x1 afb_daemon_make_event_v2(const char *name) { return afb_get_daemon_v2().itf->event_make(afb_get_daemon_v2().closure, name); } -/* +/** + * @deprecated use bindings version 3 + * * Send a message described by 'fmt' and following parameters * to the journal for the verbosity 'level'. * @@ -98,18 +110,25 @@ static inline void afb_daemon_verbose_v2(int level, const char *file, int line, va_end(args); } -/* +/** + * @deprecated use bindings version 3 + * * Get the root directory file descriptor. This file descriptor can * be used with functions 'openat', 'fstatat', ... + * + * Returns the file descriptor or -1 in case of error. */ static inline int afb_daemon_rootdir_get_fd_v2() { return afb_get_daemon_v2().itf->rootdir_get_fd(afb_get_daemon_v2().closure); } -/* +/** + * @deprecated use bindings version 3 + * * Opens 'filename' within the root directory with 'flags' (see function openat) * using the 'locale' definition (example: "jp,en-US") that can be NULL. + * * Returns the file descriptor or -1 in case of error. */ static inline int afb_daemon_rootdir_open_locale_v2(const char *filename, int flags, const char *locale) @@ -117,7 +136,9 @@ static inline int afb_daemon_rootdir_open_locale_v2(const char *filename, int fl return afb_get_daemon_v2().itf->rootdir_open_locale(afb_get_daemon_v2().closure, filename, flags, locale); } -/* +/** + * @deprecated use bindings version 3 + * * Queue the job defined by 'callback' and 'argument' for being executed asynchronously * in this thread (later) or in an other thread. * If 'group' is not NUL, the jobs queued with a same value (as the pointer value 'group') @@ -135,22 +156,27 @@ static inline int afb_daemon_queue_job_v2(void (*callback)(int signum, void *arg return afb_get_daemon_v2().itf->queue_job(afb_get_daemon_v2().closure, callback, argument, group, timeout); } -/* +/** + * @deprecated use bindings version 3 + * * Retrieves the afb_req stored at 'sreq'. * Returns the stored request. * The count of reference is UNCHANGED, thus, the * function 'afb_req_unref' should be called on the result * after that the asynchronous reply if sent. */ -static inline struct afb_req afb_daemon_unstore_req_v2(struct afb_stored_req *sreq) +static inline struct afb_req_x1 afb_daemon_unstore_req_v2(struct afb_stored_req *sreq) { return afb_get_daemon_v2().itf->unstore_req(afb_get_daemon_v2().closure, sreq); } -/* +/** + * @deprecated use bindings version 3 + * * Tells that it requires the API of "name" to exist * and if 'initialized' is not null to be initialized. * Calling this function is only allowed within init. + * * Returns 0 in case of success or -1 in case of error. */ static inline int afb_daemon_require_api_v2(const char *name, int initialized) @@ -158,23 +184,33 @@ static inline int afb_daemon_require_api_v2(const char *name, int initialized) return afb_get_daemon_v2().itf->require_api(afb_get_daemon_v2().closure, name, initialized); } -/* - * Set the name of the API to 'name'. +/** + * @deprecated use bindings version 3 + * + * Create an aliased name 'as_name' for the api 'name'. * Calling this function is only allowed within preinit. + * * Returns 0 in case of success or -1 in case of error. */ -static inline int afb_daemon_rename_api_v2(const char *name) +static inline int afb_daemon_add_alias_v2(const char *name, const char *as_name) { - return afb_get_daemon_v2().itf->rename_api(afb_get_daemon_v2().closure, name); + return afb_get_daemon_v2().itf->add_alias(afb_get_daemon_v2().closure, name, as_name); } +/** + * @deprecated use bindings version 3 + * + * Creates a new api of name 'api' with brief 'info'. + * + * Returns 0 in case of success or -1 in case of error. + */ static inline int afb_daemon_new_api_v2( const char *api, const char *info, int noconcurrency, - int (*preinit)(void*, struct afb_dynapi *), + int (*preinit)(void*, struct afb_api_x3 *), void *closure) { - return afb_get_daemon_v2().itf->new_api(afb_get_daemon_v2().closure, api, info, noconcurrency, preinit, closure); + return -!(afb_get_daemon_v2().itf->new_api(afb_get_daemon_v2().closure, api, info, noconcurrency, preinit, closure)); } diff --git a/include/afb/afb-dynapi-itf.h b/include/afb/afb-dynapi-itf.h deleted file mode 100644 index 979088d6..00000000 --- a/include/afb/afb-dynapi-itf.h +++ /dev/null @@ -1,166 +0,0 @@ -/* - * Copyright (C) 2016, 2017, 2018 "IoT.bzh" - * Author: José Bollo <jose.bollo@iot.bzh> - * - * 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 - -/* declared here */ -struct afb_dynapi; -struct afb_dynapi_itf; - -/* referenced here */ -#include <stdarg.h> -struct sd_event; -struct sd_bus; -struct afb_request; -struct afb_eventid; -struct afb_auth; -struct afb_verb_v2; - -/* - * structure for the dynapi - */ -struct afb_dynapi -{ - /* interface for the dynapi */ - const struct afb_dynapi_itf *itf; - - /* user defined data */ - void *userdata; - - /* current verbosity level */ - int verbosity; - - /* the name of the api */ - const char *apiname; -}; - -/* - * Definition of the interface for the API - */ -struct afb_dynapi_itf -{ - /* CAUTION: respect the order, add at the end */ - - void (*vverbose)( - void *dynapi, - int level, - const char *file, - int line, - const char * func, - const char *fmt, - va_list args); - - /* gets the common systemd's event loop */ - struct sd_event *(*get_event_loop)( - void *dynapi); - - /* gets the common systemd's user d-bus */ - struct sd_bus *(*get_user_bus)( - void *dynapi); - - /* gets the common systemd's system d-bus */ - struct sd_bus *(*get_system_bus)( - void *dynapi); - - int (*rootdir_get_fd)( - void *dynapi); - - int (*rootdir_open_locale)( - void *dynapi, - const char *filename, - int flags, - const char *locale); - - int (*queue_job)( - void *dynapi, - void (*callback)(int signum, void *arg), - void *argument, - void *group, - int timeout); - - int (*require_api)( - void *dynapi, - const char *name, - int initialized); - - int (*rename_api)( - void *dynapi, - const char *name); - - /* broadcasts event 'name' with 'object' */ - int (*event_broadcast)( - void *dynapi, - const char *name, - struct json_object *object); - - /* creates an event of 'name' */ - struct afb_eventid *(*eventid_make)( - void *dynapi, - const char *name); - - void (*call)( - struct afb_dynapi *dynapi, - const char *api, - const char *verb, - struct json_object *args, - void (*callback)(void*, int, struct json_object*, struct afb_dynapi *), - void *callback_closure); - - int (*call_sync)( - void *dynapi, - const char *api, - const char *verb, - struct json_object *args, - struct json_object **result); - - int (*api_new_api)( - void *dynapi, - const char *api, - const char *info, - int noconcurrency, - int (*preinit)(void*, struct afb_dynapi *), - void *closure); - - int (*api_set_verbs_v2)( - struct afb_dynapi *dynapi, - const struct afb_verb_v2 *verbs); - - int (*api_add_verb)( - struct afb_dynapi *dynapi, - const char *verb, - const char *info, - void (*callback)(struct afb_request *request), - void *vcbdata, - const struct afb_auth *auth, - uint32_t session); - - int (*api_sub_verb)( - struct afb_dynapi *dynapi, - const char *verb); - - int (*api_set_on_event)( - struct afb_dynapi *dynapi, - void (*onevent)(struct afb_dynapi *dynapi, const char *event, struct json_object *object)); - - int (*api_set_on_init)( - struct afb_dynapi *dynapi, - int (*oninit)(struct afb_dynapi *dynapi)); - - void (*api_seal)( - struct afb_dynapi *dynapi); -}; - diff --git a/include/afb/afb-dynapi-legacy.h b/include/afb/afb-dynapi-legacy.h new file mode 100644 index 00000000..ffa0d92a --- /dev/null +++ b/include/afb/afb-dynapi-legacy.h @@ -0,0 +1,191 @@ + +/* + * Copyright (C) 2018 "IoT.bzh" + * Author: José Bollo <jose.bollo@iot.bzh> + * + * 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 + +/***************************************************************************************************/ + +#define afb_dynapi afb_api_x3 +#define afb_dynapi_itf afb_api_x3_itf + +#define afb_request afb_req_x2 +#define afb_request_get_dynapi afb_req_x2_get_api +#define afb_request_get_vcbdata afb_req_x2_get_vcbdata +#define afb_request_get_api afb_req_x2_get_called_api +#define afb_request_get_verb afb_req_x2_get_called_verb +#define afb_request_wants_log_level afb_req_x2_wants_log_level + +#define afb_request_get afb_req_x2_get +#define afb_request_value afb_req_x2_value +#define afb_request_path afb_req_x2_path +#define afb_request_json afb_req_x2_json +#define afb_request_reply afb_req_x2_reply +#define afb_request_reply_f afb_req_x2_reply_f +#define afb_request_reply_v afb_req_x2_reply_v +#define afb_request_success(r,o,i) afb_req_x2_reply(r,o,0,i) +#define afb_request_success_f(r,o,...) afb_req_x2_reply_f(r,o,0,__VA_ARGS__) +#define afb_request_success_v(r,o,f,v) afb_req_x2_reply_v(r,o,0,f,v) +#define afb_request_fail(r,e,i) afb_req_x2_reply(r,0,e,i) +#define afb_request_fail_f(r,e,f,...) afb_req_x2_reply_f(r,0,e,f,__VA_ARGS__) +#define afb_request_fail_v(r,e,f,v) afb_req_x2_reply_v(r,0,e,f,v) +#define afb_request_context_get afb_req_x2_context_get +#define afb_request_context_set afb_req_x2_context_set +#define afb_request_context afb_req_x2_context +#define afb_request_context_clear afb_req_x2_context_clear +#define afb_request_addref afb_req_x2_addref +#define afb_request_unref afb_req_x2_unref +#define afb_request_session_close afb_req_x2_session_close +#define afb_request_session_set_LOA afb_req_x2_session_set_LOA +#define afb_request_subscribe afb_req_x2_subscribe +#define afb_request_unsubscribe afb_req_x2_unsubscribe +#define afb_request_subcall afb_req_x2_subcall_legacy +#define afb_request_subcall_sync afb_req_x2_subcall_sync_legacy +#define afb_request_verbose afb_req_x2_verbose +#define afb_request_has_permission afb_req_x2_has_permission +#define afb_request_get_application_id afb_req_x2_get_application_id +#define afb_request_get_uid afb_req_x2_get_uid +#define afb_request_get_client_info afb_req_x2_get_client_info + +#define afb_dynapi_name afb_api_x3_name +#define afb_dynapi_get_userdata afb_api_x3_get_userdata +#define afb_dynapi_set_userdata afb_api_x3_set_userdata +#define afb_dynapi_wants_log_level afb_api_x3_wants_log_level + +#define afb_dynapi_verbose afb_api_x3_verbose +#define afb_dynapi_vverbose afb_api_x3_vverbose +#define afb_dynapi_get_event_loop afb_api_x3_get_event_loop +#define afb_dynapi_get_user_bus afb_api_x3_get_user_bus +#define afb_dynapi_get_system_bus afb_api_x3_get_system_bus +#define afb_dynapi_rootdir_get_fd afb_api_x3_rootdir_get_fd +#define afb_dynapi_rootdir_open_locale afb_api_x3_rootdir_open_locale +#define afb_dynapi_queue_job afb_api_x3_queue_job +#define afb_dynapi_require_api afb_api_x3_require_api +#define afb_dynapi_rename_api afb_api_x3_add_alias +#define afb_dynapi_broadcast_event afb_api_x3_broadcast_event +#define afb_dynapi_make_eventid afb_api_x3_make_event_x2 +#define afb_dynapi_call afb_api_x3_call_legacy +#define afb_dynapi_call_sync afb_api_x3_call_sync_legacy +#define afb_dynapi_new_api(...) (-!afb_api_x3_new_api(__VA_ARGS__)) +#define afb_dynapi_set_verbs_v2 afb_api_x3_set_verbs_v2 +#define afb_dynapi_add_verb(a,b,c,d,e,f,g) afb_api_x3_add_verb(a,b,c,d,e,f,g,0) +#define afb_dynapi_sub_verb(a,b) afb_api_x3_del_verb(a,b,NULL) +#define afb_dynapi_on_event afb_api_x3_on_event +#define afb_dynapi_on_init afb_api_x3_on_init +#define afb_dynapi_seal afb_api_x3_seal + +#define afb_eventid_broadcast afb_event_x2_broadcast +#define afb_eventid_push afb_event_x2_push +#define afb_eventid_name afb_event_x2_name +#define afb_eventid_unref afb_event_x2_unref +#define afb_eventid_addref afb_event_x2_addref + +#define afb_eventid afb_event_x2 +#define afb_eventid_is_valid afb_event_x2_is_valid +#define afb_eventid_broadcast afb_event_x2_broadcast +#define afb_eventid_push afb_event_x2_push +#define afb_eventid_drop afb_event_x2_unref +#define afb_eventid_name afb_event_x2_name +#define afb_eventid_unref afb_event_x2_unref +#define afb_eventid_addref afb_event_x2_addref + +/* + * 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 + */ +/* macro for setting file, line and function automatically */ +# if !defined(AFB_BINDING_PRAGMA_NO_VERBOSE_DETAILS) +#define AFB_REQUEST_VERBOSE(req,level,...) afb_req_x2_verbose(req,level,__FILE__,__LINE__,__func__,__VA_ARGS__) +#else +#define AFB_REQUEST_VERBOSE(req,level,...) afb_req_x2_verbose(req,level,NULL,0,NULL,__VA_ARGS__) +#endif + +#if defined(AFB_BINDING_PRAGMA_NO_VERBOSE_DATA) + +# define _AFB_DYNAPI_LOGGING_(llevel,dynapi,...) \ + do{ \ + if(_AFB_SYSLOG_MASK_WANT_(dynapi->logmask,llevel)) {\ + if (llevel <= AFB_VERBOSITY_LEVEL_ERROR) \ + afb_dynapi_verbose(dynapi,llevel,__FILE__,__LINE__,__func__,__VA_ARGS__); \ + else \ + afb_dynapi_verbose(dynapi,llevel,__FILE__,__LINE__,NULL,NULL); \ + } \ + }while(0) +# define _AFB_REQUEST_LOGGING_(llevel,request,...) \ + do{ \ + if(request->_AFB_SYSLOG_MASK_WANT_(dynapi->logmask,llevel)) \ + afb_request_verbose(request,llevel,__FILE__,__LINE__,NULL,NULL); \ + }while(0) + +#elif defined(AFB_BINDING_PRAGMA_NO_VERBOSE_DETAILS) + +# define _AFB_DYNAPI_LOGGING_(llevel,dynapi,...) \ + do{ \ + if(_AFB_SYSLOG_MASK_WANT_(dynapi->logmask,llevel)) \ + afb_dynapi_verbose(dynapi,llevel,NULL,0,NULL,__VA_ARGS__); \ + }while(0) +# define _AFB_REQUEST_LOGGING_(llevel,request,...) \ + do{ \ + if(request->_AFB_SYSLOG_MASK_WANT_(dynapi->logmask,llevel)) \ + afb_request_verbose(request,llevel,NULL,0,NULL,__VA_ARGS__); \ + }while(0) + +#else + +# define _AFB_DYNAPI_LOGGING_(llevel,dynapi,...) \ + do{ \ + if(AFB_SYSLOG_MASK_WANT(dynapi->logmask,llevel)) \ + afb_dynapi_verbose(dynapi,llevel,__FILE__,__LINE__,__func__,__VA_ARGS__); \ + }while(0) +# define _AFB_REQUEST_LOGGING_(llevel,request,...) \ + do{ \ + if(AFB_SYSLOG_MASK_WANT(request->api->logmask,llevel)) \ + afb_request_verbose(request,llevel,__FILE__,__LINE__,__func__,__VA_ARGS__); \ + }while(0) + +#endif + +#define AFB_DYNAPI_ERROR(...) _AFB_DYNAPI_LOGGING_(AFB_SYSLOG_LEVEL_ERROR,__VA_ARGS__) +#define AFB_DYNAPI_WARNING(...) _AFB_DYNAPI_LOGGING_(AFB_SYSLOG_LEVEL_WARNING,__VA_ARGS__) +#define AFB_DYNAPI_NOTICE(...) _AFB_DYNAPI_LOGGING_(AFB_SYSLOG_LEVEL_NOTICE,__VA_ARGS__) +#define AFB_DYNAPI_INFO(...) _AFB_DYNAPI_LOGGING_(AFB_SYSLOG_LEVEL_INFO,__VA_ARGS__) +#define AFB_DYNAPI_DEBUG(...) _AFB_DYNAPI_LOGGING_(AFB_SYSLOG_LEVEL_DEBUG,__VA_ARGS__) +#define AFB_REQUEST_ERROR(...) _AFB_REQUEST_LOGGING_(AFB_SYSLOG_LEVEL_ERROR,__VA_ARGS__) +#define AFB_REQUEST_WARNING(...) _AFB_REQUEST_LOGGING_(AFB_SYSLOG_LEVEL_WARNING,__VA_ARGS__) +#define AFB_REQUEST_NOTICE(...) _AFB_REQUEST_LOGGING_(AFB_SYSLOG_LEVEL_NOTICE,__VA_ARGS__) +#define AFB_REQUEST_INFO(...) _AFB_REQUEST_LOGGING_(AFB_SYSLOG_LEVEL_INFO,__VA_ARGS__) +#define AFB_REQUEST_DEBUG(...) _AFB_REQUEST_LOGGING_(AFB_SYSLOG_LEVEL_DEBUG,__VA_ARGS__) + +typedef struct afb_eventid afb_eventid; +typedef struct afb_dynapi afb_dynapi; +typedef struct afb_request afb_request; + +#define _AFB_SYSLOG_LEVEL_EMERGENCY_ AFB_SYSLOG_LEVEL_EMERGENCY +#define _AFB_SYSLOG_LEVEL_ALERT_ AFB_SYSLOG_LEVEL_ALERT +#define _AFB_SYSLOG_LEVEL_CRITICAL_ AFB_SYSLOG_LEVEL_CRITICAL +#define _AFB_SYSLOG_LEVEL_ERROR_ AFB_SYSLOG_LEVEL_ERROR +#define _AFB_SYSLOG_LEVEL_WARNING_ AFB_SYSLOG_LEVEL_WARNING +#define _AFB_SYSLOG_LEVEL_NOTICE_ AFB_SYSLOG_LEVEL_NOTICE +#define _AFB_SYSLOG_LEVEL_INFO_ AFB_SYSLOG_LEVEL_INFO +#define _AFB_SYSLOG_LEVEL_DEBUG_ AFB_SYSLOG_LEVEL_DEBUG diff --git a/include/afb/afb-dynapi.h b/include/afb/afb-dynapi.h deleted file mode 100644 index 2a26915c..00000000 --- a/include/afb/afb-dynapi.h +++ /dev/null @@ -1,302 +0,0 @@ -/* - * Copyright (C) 2016, 2017, 2018 "IoT.bzh" - * Author: José Bollo <jose.bollo@iot.bzh> - * - * 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 - -#include "afb-dynapi-itf.h" - -static inline const char *afb_dynapi_name(struct afb_dynapi *dynapi) -{ - return dynapi->apiname; -} - -static inline void *afb_dynapi_get_userdata(struct afb_dynapi *dynapi) -{ - return dynapi->userdata; -} - -static inline void afb_dynapi_set_userdata(struct afb_dynapi *dynapi, void *userdata) -{ - dynapi->userdata = userdata; -} - -/* - * Send a message described by 'fmt' and following parameters - * to the journal for the verbosity 'level'. - * - * 'file', 'line' and 'func' are indicators of position of the code in source files - * (see macros __FILE__, __LINE__ and __func__). - * - * - * 'level' is defined by syslog standard: - * EMERGENCY 0 System is unusable - * ALERT 1 Action must be taken immediately - * CRITICAL 2 Critical conditions - * ERROR 3 Error conditions - * WARNING 4 Warning conditions - * NOTICE 5 Normal but significant condition - * INFO 6 Informational - * DEBUG 7 Debug-level messages - */ -static inline void afb_dynapi_verbose(struct afb_dynapi *dynapi, int level, const char *file, int line, const char *func, const char *fmt, ...) __attribute__((format(printf, 6, 7))); -static inline void afb_dynapi_verbose(struct afb_dynapi *dynapi, int level, const char *file, int line, const char *func, const char *fmt, ...) -{ - va_list args; - va_start(args, fmt); - dynapi->itf->vverbose(dynapi, level, file, line, func, fmt, args); - va_end(args); -} -static inline void afb_dynapi_vverbose(struct afb_dynapi *dynapi, int level, const char *file, int line, const char *func, const char *fmt, va_list args) -{ - dynapi->itf->vverbose(dynapi, level, file, line, func, fmt, args); -} - -/* - * Retrieves the common systemd's event loop of AFB - */ -static inline struct sd_event *afb_dynapi_get_event_loop(struct afb_dynapi *dynapi) -{ - return dynapi->itf->get_event_loop(dynapi); -} - -/* - * Retrieves the common systemd's user/session d-bus of AFB - */ -static inline struct sd_bus *afb_dynapi_get_user_bus(struct afb_dynapi *dynapi) -{ - return dynapi->itf->get_user_bus(dynapi); -} - -/* - * Retrieves the common systemd's system d-bus of AFB - */ -static inline struct sd_bus *afb_dynapi_get_system_bus(struct afb_dynapi *dynapi) -{ - return dynapi->itf->get_system_bus(dynapi); -} - -/* - * Get the root directory file descriptor. This file descriptor can - * be used with functions 'openat', 'fstatat', ... - */ -static inline int afb_dynapi_rootdir_get_fd(struct afb_dynapi *dynapi) -{ - return dynapi->itf->rootdir_get_fd(dynapi); -} - -/* - * Opens 'filename' within the root directory with 'flags' (see function openat) - * using the 'locale' definition (example: "jp,en-US") that can be NULL. - * Returns the file descriptor or -1 in case of error. - */ -static inline int afb_dynapi_rootdir_open_locale(struct afb_dynapi *dynapi, const char *filename, int flags, const char *locale) -{ - return dynapi->itf->rootdir_open_locale(dynapi, filename, flags, locale); -} - -/* - * Queue the job defined by 'callback' and 'argument' for being executed asynchronously - * in this thread (later) or in an other thread. - * If 'group' is not NUL, the jobs queued with a same value (as the pointer value 'group') - * are executed in sequence in the order of there submission. - * If 'timeout' is not 0, it represent the maximum execution time for the job in seconds. - * At first, the job is called with 0 as signum and the given argument. - * The job is executed with the monitoring of its time and some signals like SIGSEGV and - * SIGFPE. When a such signal is catched, the job is terminated and reexecuted but with - * signum being the signal number (SIGALRM when timeout expired). - * - * Returns 0 in case of success or -1 in case of error. - */ -static inline int afb_dynapi_queue_job(struct afb_dynapi *dynapi, void (*callback)(int signum, void *arg), void *argument, void *group, int timeout) -{ - return dynapi->itf->queue_job(dynapi, callback, argument, group, timeout); -} - -/* - * Tells that it requires the API of "name" to exist - * and if 'initialized' is not null to be initialized. - * Calling this function is only allowed within init. - * Returns 0 in case of success or -1 in case of error. - */ -static inline int afb_dynapi_require_api(struct afb_dynapi *dynapi, const char *name, int initialized) -{ - return dynapi->itf->require_api(dynapi, name, initialized); -} - -/* - * Set the name of the API to 'name'. - * Calling this function is only allowed within preinit. - * Returns 0 in case of success or -1 in case of error. - */ -static inline int afb_dynapi_rename_api(struct afb_dynapi *dynapi, const char *name) -{ - return dynapi->itf->rename_api(dynapi, name); -} - -/* - * Broadcasts widely the event of 'name' with the data 'object'. - * 'object' can be NULL. - * - * For convenience, the function calls 'json_object_put' for 'object'. - * Thus, in the case where 'object' should remain available after - * the function returns, the function 'json_object_get' shall be used. - * - * Calling this function is only forbidden during preinit. - * - * Returns the count of clients that received the event. - */ -static inline int afb_dynapi_broadcast_event(struct afb_dynapi *dynapi, const char *name, struct json_object *object) -{ - return dynapi->itf->event_broadcast(dynapi, name, object); -} - -/* - * Creates an event of 'name' and returns it. - * - * Calling this function is only forbidden during preinit. - * - * See afb_event_is_valid to check if there is an error. - */ -static inline struct afb_eventid *afb_dynapi_make_eventid(struct afb_dynapi *dynapi, const char *name) -{ - return dynapi->itf->eventid_make(dynapi, name); -} - -/** - * Calls the 'verb' of the 'api' with the arguments 'args' and 'verb' in the name of the binding. - * The result of the call is delivered to the 'callback' function with the 'callback_closure'. - * - * For convenience, the function calls 'json_object_put' for 'args'. - * Thus, in the case where 'args' should remain available after - * the function returns, the function 'json_object_get' shall be used. - * - * The 'callback' receives 3 arguments: - * 1. 'closure' the user defined closure pointer 'callback_closure', - * 2. 'status' a status being 0 on success or negative when an error occured, - * 2. 'result' the resulting data as a JSON object. - * - * @param dynapi The dynapi - * @param api The api name of the method to call - * @param verb The verb name of the method to call - * @param args The arguments to pass to the method - * @param callback The to call on completion - * @param callback_closure The closure to pass to the callback - * - * @see also 'afb_req_subcall' - */ -static inline void afb_dynapi_call( - struct afb_dynapi *dynapi, - const char *api, - const char *verb, - struct json_object *args, - void (*callback)(void *closure, int status, struct json_object *result, struct afb_dynapi *dynapi), - void *callback_closure) -{ - dynapi->itf->call(dynapi, api, verb, args, callback, callback_closure); -} - -/** - * Calls the 'verb' of the 'api' with the arguments 'args' and 'verb' in the name of the binding. - * 'result' will receive the response. - * - * For convenience, the function calls 'json_object_put' for 'args'. - * Thus, in the case where 'args' should remain available after - * the function returns, the function 'json_object_get' shall be used. - * - * @param dynapi The dynapi - * @param api The api name of the method to call - * @param verb The verb name of the method to call - * @param args The arguments to pass to the method - * @param result Where to store the result - should call json_object_put on it - - * - * @returns 0 in case of success or a negative value in case of error. - * - * @see also 'afb_req_subcall' - */ -static inline int afb_dynapi_call_sync( - struct afb_dynapi *dynapi, - const char *api, - const char *verb, - struct json_object *args, - struct json_object **result) -{ - return dynapi->itf->call_sync(dynapi, api, verb, args, result); -} - - -static inline int afb_dynapi_new_api( - struct afb_dynapi *dynapi, - const char *api, - const char *info, - int noconcurrency, - int (*preinit)(void*, struct afb_dynapi *), - void *closure) -{ - return dynapi->itf->api_new_api(dynapi, api, info, noconcurrency, preinit, closure); -} - -static inline int afb_dynapi_set_verbs_v2( - struct afb_dynapi *dynapi, - const struct afb_verb_v2 *verbs) -{ - return dynapi->itf->api_set_verbs_v2(dynapi, verbs); -} - -static inline int afb_dynapi_add_verb( - struct afb_dynapi *dynapi, - const char *verb, - const char *info, - void (*callback)(struct afb_request *request), - void *vcbdata, - const struct afb_auth *auth, - uint32_t session) -{ - return dynapi->itf->api_add_verb(dynapi, verb, info, callback, vcbdata, auth, session); -} - - -static inline int afb_dynapi_sub_verb( - struct afb_dynapi *dynapi, - const char *verb) -{ - return dynapi->itf->api_sub_verb(dynapi, verb); -} - - -static inline int afb_dynapi_on_event( - struct afb_dynapi *dynapi, - void (*onevent)(struct afb_dynapi *dynapi, const char *event, struct json_object *object)) -{ - return dynapi->itf->api_set_on_event(dynapi, onevent); -} - - -static inline int afb_dynapi_on_init( - struct afb_dynapi *dynapi, - int (*oninit)(struct afb_dynapi *dynapi)) -{ - return dynapi->itf->api_set_on_init(dynapi, oninit); -} - - -static inline void afb_dynapi_seal( - struct afb_dynapi *dynapi) -{ - dynapi->itf->api_seal(dynapi); -} - - diff --git a/include/afb/afb-event-x1-itf.h b/include/afb/afb-event-x1-itf.h new file mode 100644 index 00000000..afd033b8 --- /dev/null +++ b/include/afb/afb-event-x1-itf.h @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2016, 2017, 2018 "IoT.bzh" + * Author: José Bollo <jose.bollo@iot.bzh> + * + * 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 + +#include "afb-event-x2-itf.h" + +/** + * @deprecated use bindings version 3 + * + * Describes the request of afb-daemon for bindings + */ +struct afb_event_x1 +{ + const struct afb_event_x2_itf *itf; /**< the interface to use */ + struct afb_event_x2 *closure; /**< the closure argument for functions of 'itf' */ +}; + diff --git a/include/afb/afb-event.h b/include/afb/afb-event-x1.h index 0876d8cf..1fc7696f 100644 --- a/include/afb/afb-event.h +++ b/include/afb/afb-event-x1.h @@ -17,36 +17,33 @@ #pragma once -#include "afb-eventid-itf.h" +#include "afb-event-x1-itf.h" -/* - * Describes the request of afb-daemon for bindings - */ -struct afb_event -{ - const struct afb_eventid_itf *itf; /* the interface to use */ - struct afb_eventid *closure; /* the closure argument for functions of 'itf' */ -}; - -/* +/** + * @deprecated use bindings version 3 + * * Converts the 'event' to an afb_eventid. */ -static inline struct afb_eventid *afb_event_to_eventid(struct afb_event event) +static inline struct afb_event_x2 *afb_event_x1_to_event_x2(struct afb_event_x1 event) { return event.closure; } -/* +/** + * @deprecated use bindings version 3 + * * Checks wether the 'event' is valid or not. * * Returns 0 if not valid or 1 if valid. */ -static inline int afb_event_is_valid(struct afb_event event) +static inline int afb_event_x1_is_valid(struct afb_event_x1 event) { return !!event.itf; } -/* +/** + * @deprecated use bindings version 3 + * * Broadcasts widely the 'event' with the data 'object'. * 'object' can be NULL. * @@ -56,12 +53,14 @@ static inline int afb_event_is_valid(struct afb_event event) * * Returns the count of clients that received the event. */ -static inline int afb_event_broadcast(struct afb_event event, struct json_object *object) +static inline int afb_event_x1_broadcast(struct afb_event_x1 event, struct json_object *object) { return event.itf->broadcast(event.closure, object); } -/* +/** + * @deprecated use bindings version 3 + * * Pushes the 'event' with the data 'object' to its observers. * 'object' can be NULL. * @@ -71,35 +70,41 @@ static inline int afb_event_broadcast(struct afb_event event, struct json_object * * Returns the count of clients that received the event. */ -static inline int afb_event_push(struct afb_event event, struct json_object *object) +static inline int afb_event_x1_push(struct afb_event_x1 event, struct json_object *object) { return event.itf->push(event.closure, object); } /* OBSOLETE */ -#define afb_event_drop afb_event_unref +#define afb_event_x1_drop afb_event_x1_unref -/* +/** + * @deprecated use bindings version 3 + * * Gets the name associated to the 'event'. */ -static inline const char *afb_event_name(struct afb_event event) +static inline const char *afb_event_x1_name(struct afb_event_x1 event) { return event.itf->name(event.closure); } -/* +/** + * @deprecated use bindings version 3 + * * Decreases the count of reference to 'event' and * destroys the event when the reference count falls to zero. */ -static inline void afb_event_unref(struct afb_event event) +static inline void afb_event_x1_unref(struct afb_event_x1 event) { event.itf->unref(event.closure); } -/* +/** + * @deprecated use bindings version 3 + * * Increases the count of reference to 'event' */ -static inline void afb_event_addref(struct afb_event event) +static inline void afb_event_x1_addref(struct afb_event_x1 event) { event.itf->addref(event.closure); } diff --git a/include/afb/afb-eventid-itf.h b/include/afb/afb-event-x2-itf.h index 0af36581..ecc42c79 100644 --- a/include/afb/afb-eventid-itf.h +++ b/include/afb/afb-event-x2-itf.h @@ -17,31 +17,41 @@ #pragma once -struct json_object; -struct afb_eventid; -struct afb_eventid_itf; +struct afb_event_x2; +struct afb_event_x2_itf; -/* - * Interface for handling eventid. - * It records the functions to be called for the eventid. +/** + * Interface for handling event_x2. + * + * It records the functions to be called for the event_x2. + * * Don't use this structure directly. */ -struct afb_eventid_itf +struct afb_event_x2_itf { /* CAUTION: respect the order, add at the end */ - int (*broadcast)(struct afb_eventid *eventid, struct json_object *obj); - int (*push)(struct afb_eventid *eventid, struct json_object *obj); - void (*unref)(struct afb_eventid *eventid); /* aka drop */ - const char *(*name)(struct afb_eventid *eventid); - struct afb_eventid *(*addref)(struct afb_eventid *eventid); + /** broadcast the event */ + int (*broadcast)(struct afb_event_x2 *event, struct json_object *obj); + + /** push the event to its subscribers */ + int (*push)(struct afb_event_x2 *event, struct json_object *obj); + + /** unreference the event */ + void (*unref)(struct afb_event_x2 *event); /* aka drop */ + + /** get the event name */ + const char *(*name)(struct afb_event_x2 *event); + + /** rereference the event */ + struct afb_event_x2 *(*addref)(struct afb_event_x2 *event); }; -/* - * Describes the eventid +/** + * Describes the event_x2 */ -struct afb_eventid +struct afb_event_x2 { - const struct afb_eventid_itf *itf; /* the interface to use */ + const struct afb_event_x2_itf *itf; /**< the interface functions to use */ }; diff --git a/include/afb/afb-event-x2.h b/include/afb/afb-event-x2.h new file mode 100644 index 00000000..f0a27877 --- /dev/null +++ b/include/afb/afb-event-x2.h @@ -0,0 +1,113 @@ +/* + * Copyright (C) 2016, 2017, 2018 "IoT.bzh" + * Author: José Bollo <jose.bollo@iot.bzh> + * + * 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 + +#include "afb-event-x2-itf.h" + +/** + * Checks whether the 'event' is valid or not. + * + * @param event the event to check + * + * @return 0 if not valid or 1 if valid. + */ +static inline int afb_event_x2_is_valid(struct afb_event_x2 *event) +{ + return !!event; +} + +/** + * Broadcasts widely an event of 'event' with the data 'object'. + * 'object' can be NULL. + * + * For convenience, the function calls 'json_object_put' for 'object'. + * Thus, in the case where 'object' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * @param event the event to broadcast + * @param object the companion object to associate to the broadcasted event (can be NULL) + * + * @return the count of clients that received the event. + */ +static inline int afb_event_x2_broadcast( + struct afb_event_x2 *event, + struct json_object *object) +{ + return event->itf->broadcast(event, object); +} + +/** + * Pushes an event of 'event' with the data 'object' to its observers. + * 'object' can be NULL. + * + * For convenience, the function calls 'json_object_put' for 'object'. + * Thus, in the case where 'object' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * @param event the event to push + * @param object the companion object to associate to the pushed event (can be NULL) + * + * @return the count of clients that received the event. + */ +static inline int afb_event_x2_push( + struct afb_event_x2 *event, + struct json_object *object) +{ + return event->itf->push(event, object); +} + +/** + * Gets the name associated to 'event'. + * + * @param event the event whose name is requested + * + * @return the name of the event + * + * The returned name can be used until call to 'afb_event_x2_unref'. + * It shouldn't be freed. + */ +static inline const char *afb_event_x2_name(struct afb_event_x2 *event) +{ + return event->itf->name(event); +} + +/** + * Decrease the count of references to 'event'. + * Call this function when the evenid is no more used. + * It destroys the event_x2 when the reference count falls to zero. + * + * @param event the event + */ +static inline void afb_event_x2_unref(struct afb_event_x2 *event) +{ + event->itf->unref(event); +} + +/** + * Increases the count of references to 'event' + * + * @param event the event + * + * @return the event + */ +static inline struct afb_event_x2 *afb_event_x2_addref( + struct afb_event_x2 *event) +{ + return event->itf->addref(event); +} + diff --git a/include/afb/afb-eventid.h b/include/afb/afb-eventid.h deleted file mode 100644 index 69d82a75..00000000 --- a/include/afb/afb-eventid.h +++ /dev/null @@ -1,83 +0,0 @@ -/* - * Copyright (C) 2016, 2017, 2018 "IoT.bzh" - * Author: José Bollo <jose.bollo@iot.bzh> - * - * 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 - -#include "afb-eventid-itf.h" - -/* - * Broadcasts widely an event of 'eventid' with the data 'object'. - * 'object' can be NULL. - * - * For convenience, the function calls 'json_object_put' for 'object'. - * Thus, in the case where 'object' should remain available after - * the function returns, the function 'json_object_get' shall be used. - * - * Returns the count of clients that received the event. - */ -static inline int afb_eventid_broadcast( - struct afb_eventid *eventid, - struct json_object *object) -{ - return eventid->itf->broadcast(eventid, object); -} - -/* - * Pushes an event of 'eventid' with the data 'object' to its observers. - * 'object' can be NULL. - * - * For convenience, the function calls 'json_object_put' for 'object'. - * Thus, in the case where 'object' should remain available after - * the function returns, the function 'json_object_get' shall be used. - * - * Returns the count of clients that received the event. - */ -static inline int afb_eventid_push( - struct afb_eventid *eventid, - struct json_object *object) -{ - return eventid->itf->push(eventid, object); -} - -/* - * Gets the name associated to 'eventid'. - * The returned name can be used until call to 'afb_eventid_unref'. - */ -static inline const char *afb_eventid_name(struct afb_eventid *eventid) -{ - return eventid->itf->name(eventid); -} - -/* - * Decrease the count of references to 'eventid'. - * Call this function when the evenid is no more used. - * It destroys the eventid when the reference count falls to zero. - */ -static inline void afb_eventid_unref(struct afb_eventid *eventid) -{ - eventid->itf->unref(eventid); -} - -/* - * Increases the count of references to 'eventid' - */ -static inline struct afb_eventid *afb_eventid_addref( - struct afb_eventid *eventid) -{ - return eventid->itf->addref(eventid); -} - diff --git a/include/afb/afb-req-v1.h b/include/afb/afb-req-v1.h index f1bcd47d..40fb3b85 100644 --- a/include/afb/afb-req-v1.h +++ b/include/afb/afb-req-v1.h @@ -18,34 +18,38 @@ #pragma once #include <stdlib.h> -#include "afb-req.h" +#include "afb-req-x1.h" -/* +/** + * @deprecated use bindings version 3 + * * Stores 'req' on heap for asynchrnous use. * Returns a pointer to the stored 'req' or NULL on memory depletion. * The count of reference to 'req' is incremented on success * (see afb_req_addref). */ -static inline struct afb_req *afb_req_store_v1(struct afb_req req) +static inline struct afb_req_x1 *afb_req_x1_store_v1(struct afb_req_x1 req) { - struct afb_req *result = (struct afb_req*)malloc(sizeof *result); + struct afb_req_x1 *result = (struct afb_req_x1*)malloc(sizeof *result); if (result) { *result = req; - afb_req_addref(req); + afb_req_x1_addref(req); } return result; } -/* +/** + * @deprecated use bindings version 3 + * * Retrieves the afb_req stored at 'req' and frees the memory. * Returns the stored request. * The count of reference is UNCHANGED, thus, normally, the * function 'afb_req_unref' should be called on the result * after that the asynchronous reply if sent. */ -static inline struct afb_req afb_req_unstore_v1(struct afb_req *req) +static inline struct afb_req_x1 afb_req_unstore_x1_v1(struct afb_req_x1 *req) { - struct afb_req result = *req; + struct afb_req_x1 result = *req; free(req); return result; } diff --git a/include/afb/afb-req-v2.h b/include/afb/afb-req-v2.h index 34cbbdaa..f7901908 100644 --- a/include/afb/afb-req-v2.h +++ b/include/afb/afb-req-v2.h @@ -17,16 +17,18 @@ #pragma once -#include "afb-req.h" +#include "afb-req-x1.h" -/* +/** + * @deprecated use bindings version 3 + * * Stores 'req' on heap for asynchrnous use. * Returns a handler to the stored 'req' or NULL on memory depletion. * The count of reference to 'req' is incremented on success * (see afb_req_addref). */ -static inline struct afb_stored_req *afb_req_store_v2(struct afb_req req) +static inline struct afb_stored_req *afb_req_x1_store_v2(struct afb_req_x1 req) { - return req.itf->store(req.closure); + return req.itf->legacy_store_req(req.closure); } diff --git a/include/afb/afb-req-itf.h b/include/afb/afb-req-x1-itf.h index 2dd42d2e..dce936d1 100644 --- a/include/afb/afb-req-itf.h +++ b/include/afb/afb-req-x1-itf.h @@ -17,14 +17,16 @@ #pragma once -#include "afb-request-itf.h" +#include "afb-req-x2-itf.h" -/* - * Describes the request by bindings from afb-daemon +/** + * @deprecated use bindings version 3 + * + * Describes the request to bindings version 1 and 2 */ -struct afb_req +struct afb_req_x1 { - const struct afb_request_itf *itf; /* the interface to use */ - struct afb_request *closure; /* the closure argument for functions of 'itf' */ + const struct afb_req_x2_itf *itf; /**< the interface to use */ + struct afb_req_x2 *closure; /**< the closure argument for functions of 'itf' */ }; diff --git a/include/afb/afb-req.h b/include/afb/afb-req-x1.h index 77153ef1..cea17d0c 100644 --- a/include/afb/afb-req.h +++ b/include/afb/afb-req-x1.h @@ -17,28 +17,34 @@ #pragma once -#include "afb-req-itf.h" -#include "afb-event.h" +#include "afb-req-x1-itf.h" +#include "afb-event-x1.h" -/* +/** + * @deprecated use bindings version 3 + * * Converts the 'req' to an afb_request. */ -static inline struct afb_request *afb_req_to_request(struct afb_req req) +static inline struct afb_req_x2 *afb_req_x1_to_req_x2(struct afb_req_x1 req) { return req.closure; } -/* +/** + * @deprecated use bindings version 3 + * * Checks whether the request 'req' is valid or not. * * Returns 0 if not valid or 1 if valid. */ -static inline int afb_req_is_valid(struct afb_req req) +static inline int afb_req_x1_is_valid(struct afb_req_x1 req) { return !!req.itf; } -/* +/** + * @deprecated use bindings version 3 + * * Gets from the request 'req' the argument of 'name'. * Returns a PLAIN structure of type 'struct afb_arg'. * When the argument of 'name' is not found, all fields of result are set to NULL. @@ -50,157 +56,141 @@ static inline int afb_req_is_valid(struct afb_req req) * an HTTP POST of Content-Type "application/json". In that case, the * argument of name "" receives the value of the body of the HTTP request. */ -static inline struct afb_arg afb_req_get(struct afb_req req, const char *name) +static inline struct afb_arg afb_req_x1_get(struct afb_req_x1 req, const char *name) { return req.itf->get(req.closure, name); } -/* +/** + * @deprecated use bindings version 3 + * * Gets from the request 'req' the string value of the argument of 'name'. * Returns NULL if when there is no argument of 'name'. * Returns the value of the argument of 'name' otherwise. * * Shortcut for: afb_req_get(req, name).value */ -static inline const char *afb_req_value(struct afb_req req, const char *name) +static inline const char *afb_req_x1_value(struct afb_req_x1 req, const char *name) { - return afb_req_get(req, name).value; + return afb_req_x1_get(req, name).value; } -/* +/** + * @deprecated use bindings version 3 + * * Gets from the request 'req' the path for file attached to the argument of 'name'. * Returns NULL if when there is no argument of 'name' or when there is no file. * Returns the path of the argument of 'name' otherwise. * * Shortcut for: afb_req_get(req, name).path */ -static inline const char *afb_req_path(struct afb_req req, const char *name) +static inline const char *afb_req_x1_path(struct afb_req_x1 req, const char *name) { - return afb_req_get(req, name).path; + return afb_req_x1_get(req, name).path; } -/* +/** + * @deprecated use bindings version 3 + * * Gets from the request 'req' the json object hashing the arguments. * The returned object must not be released using 'json_object_put'. */ -static inline struct json_object *afb_req_json(struct afb_req req) +static inline struct json_object *afb_req_x1_json(struct afb_req_x1 req) { return req.itf->json(req.closure); } -/* - * Sends a reply of kind success to the request 'req'. - * The status of the reply is automatically set to "success". +/** + * @deprecated use bindings version 3 + * + * Sends a reply to the request 'req'. + * The status of the reply is set to 'error' (that must be NULL on success). * Its send the object 'obj' (can be NULL) with an - * informationnal comment 'info (can also be NULL). + * informational comment 'info (can also be NULL). * * For convenience, the function calls 'json_object_put' for 'obj'. * Thus, in the case where 'obj' should remain available after * the function returns, the function 'json_object_get' shall be used. */ -static inline void afb_req_success(struct afb_req req, struct json_object *obj, const char *info) +static inline void afb_req_x1_reply(struct afb_req_x1 req, struct json_object *obj, const char *error, const char *info) { - req.itf->success(req.closure, obj, info); + req.itf->reply(req.closure, obj, error, info); } -/* - * Same as 'afb_req_success' but the 'info' is a formatting +/** + * @deprecated use bindings version 3 + * + * Same as 'afb_req_x1_reply' but the 'info' is a formatting * string followed by arguments. * * For convenience, the function calls 'json_object_put' for 'obj'. * Thus, in the case where 'obj' should remain available after * the function returns, the function 'json_object_get' shall be used. */ -static inline void afb_req_success_f(struct afb_req req, struct json_object *obj, const char *info, ...) __attribute__((format(printf, 3, 4))); -static inline void afb_req_success_f(struct afb_req req, struct json_object *obj, const char *info, ...) +static inline void afb_req_x1_reply_f(struct afb_req_x1 req, struct json_object *obj, const char *error, const char *info, ...) __attribute__((format(printf, 4, 5))); +static inline void afb_req_x1_reply_f(struct afb_req_x1 req, struct json_object *obj, const char *error, const char *info, ...) { va_list args; va_start(args, info); - req.itf->vsuccess(req.closure, obj, info, args); + req.itf->vreply(req.closure, obj, error, info, args); va_end(args); } -/* - * Same as 'afb_req_success_f' but the arguments to the format 'info' +/** + * @deprecated use bindings version 3 + * + * Same as 'afb_req_x1_reply_f' but the arguments to the format 'info' * are given as a variable argument list instance. * * For convenience, the function calls 'json_object_put' for 'obj'. * Thus, in the case where 'obj' should remain available after * the function returns, the function 'json_object_get' shall be used. */ -static inline void afb_req_success_v(struct afb_req req, struct json_object *obj, const char *info, va_list args) +static inline void afb_req_x1_reply_v(struct afb_req_x1 req, struct json_object *obj, const char *error, const char *info, va_list args) { - req.itf->vsuccess(req.closure, obj, info, args); + req.itf->vreply(req.closure, obj, error, info, args); } -/* - * Sends a reply of kind failure to the request 'req'. - * The status of the reply is set to 'status' and an - * informationnal comment 'info' (can also be NULL) can be added. +/** + * @deprecated use bindings version 3 * - * Note that calling afb_req_fail("success", info) is equivalent - * to call afb_req_success(NULL, info). Thus even if possible it - * is strongly recommanded to NEVER use "success" for status. - */ -static inline void afb_req_fail(struct afb_req req, const char *status, const char *info) -{ - req.itf->fail(req.closure, status, info); -} - -/* - * Same as 'afb_req_fail' but the 'info' is a formatting - * string followed by arguments. - */ -static inline void afb_req_fail_f(struct afb_req req, const char *status, const char *info, ...) __attribute__((format(printf, 3, 4))); -static inline void afb_req_fail_f(struct afb_req req, const char *status, const char *info, ...) -{ - va_list args; - va_start(args, info); - req.itf->vfail(req.closure, status, info, args); - va_end(args); -} - -/* - * Same as 'afb_req_fail_f' but the arguments to the format 'info' - * are given as a variable argument list instance. - */ -static inline void afb_req_fail_v(struct afb_req req, const char *status, const char *info, va_list args) -{ - req.itf->vfail(req.closure, status, info, args); -} - -/* * Gets the pointer stored by the binding for the session of 'req'. * When the binding has not yet recorded a pointer, NULL is returned. */ -static inline void *afb_req_context_get(struct afb_req req) +static inline void *afb_req_x1_context_get(struct afb_req_x1 req) { - return req.itf->context_get(req.closure); + return req.itf->context_make(req.closure, 0, 0, 0, 0); } -/* +/** + * @deprecated use bindings version 3 + * * Stores for the binding the pointer 'context' to the session of 'req'. * The function 'free_context' will be called when the session is closed * or if binding stores an other pointer. */ -static inline void afb_req_context_set(struct afb_req req, void *context, void (*free_context)(void*)) +static inline void afb_req_x1_context_set(struct afb_req_x1 req, void *context, void (*free_context)(void*)) { - req.itf->context_set(req.closure, context, free_context); + req.itf->context_make(req.closure, 1, 0, free_context, context); } -/* +/** + * @deprecated use bindings version 3 + * * Gets the pointer stored by the binding for the session of 'req'. * If the stored pointer is NULL, indicating that no pointer was * already stored, afb_req_context creates a new context by calling * the function 'create_context' and stores it with the freeing function * 'free_context'. */ -static inline void *afb_req_context(struct afb_req req, void *(*create_context)(), void (*free_context)(void*)) +static inline void *afb_req_x1_context(struct afb_req_x1 req, void *(*create_context)(), void (*free_context)(void*)) { return req.itf->context_make(req.closure, 0, (void *(*)(void*))(void*)create_context, free_context, 0); } -/* +/** + * @deprecated use bindings version 3 + * * Gets the pointer stored by the binding for the session of 'request'. * If no previous pointer is stored or if 'replace' is not zero, a new value * is generated using the function 'create_context' called with the 'closure'. @@ -210,83 +200,99 @@ static inline void *afb_req_context(struct afb_req req, void *(*create_context)( * it is not more used. * This function is atomic: it ensures that 2 threads will not race together. */ -static inline void *afb_req_context_make(struct afb_req req, int replace, void *(*create_context)(void *closure), void (*free_context)(void*), void *closure) +static inline void *afb_req_x1_context_make(struct afb_req_x1 req, int replace, void *(*create_context)(void *closure), void (*free_context)(void*), void *closure) { return req.itf->context_make(req.closure, replace, create_context, free_context, closure); } -/* +/** + * @deprecated use bindings version 3 + * * Frees the pointer stored by the binding for the session of 'req' * and sets it to NULL. * * Shortcut for: afb_req_context_set(req, NULL, NULL) */ -static inline void afb_req_context_clear(struct afb_req req) +static inline void afb_req_x1_context_clear(struct afb_req_x1 req) { - afb_req_context_set(req, 0, 0); + req.itf->context_make(req.closure, 1, 0, 0, 0); } -/* +/** + * @deprecated use bindings version 3 + * * Adds one to the count of references of 'req'. * This function MUST be called by asynchronous implementations * of verbs if no reply was sent before returning. */ -static inline void afb_req_addref(struct afb_req req) +static inline void afb_req_x1_addref(struct afb_req_x1 req) { req.itf->addref(req.closure); } -/* +/** + * @deprecated use bindings version 3 + * * Substracts one to the count of references of 'req'. * This function MUST be called by asynchronous implementations * of verbs after sending the asynchronous reply. */ -static inline void afb_req_unref(struct afb_req req) +static inline void afb_req_x1_unref(struct afb_req_x1 req) { req.itf->unref(req.closure); } -/* +/** + * @deprecated use bindings version 3 + * * Closes the session associated with 'req' * and delete all associated contexts. */ -static inline void afb_req_session_close(struct afb_req req) +static inline void afb_req_x1_session_close(struct afb_req_x1 req) { req.itf->session_close(req.closure); } -/* +/** + * @deprecated use bindings version 3 + * * Sets the level of assurance of the session of 'req' * to 'level'. The effect of this function is subject of * security policies. * Returns 1 on success or 0 if failed. */ -static inline int afb_req_session_set_LOA(struct afb_req req, unsigned level) +static inline int afb_req_x1_session_set_LOA(struct afb_req_x1 req, unsigned level) { - return req.itf->session_set_LOA(req.closure, level); + return 1 + req.itf->session_set_LOA(req.closure, level); } -/* +/** + * @deprecated use bindings version 3 + * * Establishes for the client link identified by 'req' a subscription * to the 'event'. * Returns 0 in case of successful subscription or -1 in case of error. */ -static inline int afb_req_subscribe(struct afb_req req, struct afb_event event) +static inline int afb_req_x1_subscribe(struct afb_req_x1 req, struct afb_event_x1 event) { - return req.itf->subscribe(req.closure, event); + return req.itf->legacy_subscribe_event_x1(req.closure, event); } -/* +/** + * @deprecated use bindings version 3 + * * Revokes the subscription established to the 'event' for the client * link identified by 'req'. * Returns 0 in case of successful subscription or -1 in case of error. */ -static inline int afb_req_unsubscribe(struct afb_req req, struct afb_event event) +static inline int afb_req_x1_unsubscribe(struct afb_req_x1 req, struct afb_event_x1 event) { - return req.itf->unsubscribe(req.closure, event); + return req.itf->legacy_unsubscribe_event_x1(req.closure, event); } -/* +/** + * @deprecated use bindings version 3 + * * Makes a call to the method of name 'api' / 'verb' with the object 'args'. * This call is made in the context of the request 'req'. * On completion, the function 'callback' is invoked with the @@ -303,12 +309,14 @@ static inline int afb_req_unsubscribe(struct afb_req req, struct afb_event event * - 'afb_req_subcall_req' that is convenient to keep request alive automatically. * - 'afb_req_subcall_sync' the synchronous version */ -static inline void afb_req_subcall(struct afb_req req, const char *api, const char *verb, struct json_object *args, void (*callback)(void *closure, int iserror, struct json_object *result), void *closure) +static inline void afb_req_x1_subcall(struct afb_req_x1 req, const char *api, const char *verb, struct json_object *args, void (*callback)(void *closure, int iserror, struct json_object *result), void *closure) { - req.itf->subcall(req.closure, api, verb, args, callback, closure); + req.itf->legacy_subcall(req.closure, api, verb, args, callback, closure); } -/* +/** + * @deprecated use bindings version 3 + * * Makes a call to the method of name 'api' / 'verb' with the object 'args'. * This call is made in the context of the request 'req'. * On completion, the function 'callback' is invoked with the @@ -326,12 +334,14 @@ static inline void afb_req_subcall(struct afb_req req, const char *api, const ch * - 'afb_req_subcall' that doesn't keep request alive automatically. * - 'afb_req_subcall_sync' the synchronous version */ -static inline void afb_req_subcall_req(struct afb_req req, const char *api, const char *verb, struct json_object *args, void (*callback)(void *closure, int iserror, struct json_object *result, struct afb_req req), void *closure) +static inline void afb_req_x1_subcall_req(struct afb_req_x1 req, const char *api, const char *verb, struct json_object *args, void (*callback)(void *closure, int iserror, struct json_object *result, struct afb_req_x1 req), void *closure) { - req.itf->subcall_req(req.closure, api, verb, args, callback, closure); + req.itf->legacy_subcall_req(req.closure, api, verb, args, callback, closure); } -/* +/** + * @deprecated use bindings version 3 + * * Makes a call to the method of name 'api' / 'verb' with the object 'args'. * This call is made in the context of the request 'req'. * This call is synchronous, it waits untill completion of the request. @@ -347,12 +357,14 @@ static inline void afb_req_subcall_req(struct afb_req req, const char *api, cons * - 'afb_req_subcall_req' that is convenient to keep request alive automatically. * - 'afb_req_subcall' that doesn't keep request alive automatically. */ -static inline int afb_req_subcall_sync(struct afb_req req, const char *api, const char *verb, struct json_object *args, struct json_object **result) +static inline int afb_req_x1_subcall_sync(struct afb_req_x1 req, const char *api, const char *verb, struct json_object *args, struct json_object **result) { - return req.itf->subcallsync(req.closure, api, verb, args, result); + return req.itf->legacy_subcallsync(req.closure, api, verb, args, result); } -/* +/** + * @deprecated use bindings version 3 + * * Send associated to 'req' a message described by 'fmt' and following parameters * to the journal for the verbosity 'level'. * @@ -369,8 +381,8 @@ static inline int afb_req_subcall_sync(struct afb_req req, const char *api, cons * INFO 6 Informational * DEBUG 7 Debug-level messages */ -static inline void afb_req_verbose(struct afb_req req, int level, const char *file, int line, const char * func, const char *fmt, ...) __attribute__((format(printf, 6, 7))); -static inline void afb_req_verbose(struct afb_req req, int level, const char *file, int line, const char * func, const char *fmt, ...) +static inline void afb_req_x1_verbose(struct afb_req_x1 req, int level, const char *file, int line, const char * func, const char *fmt, ...) __attribute__((format(printf, 6, 7))); +static inline void afb_req_x1_verbose(struct afb_req_x1 req, int level, const char *file, int line, const char * func, const char *fmt, ...) { va_list args; va_start(args, fmt); @@ -378,25 +390,22 @@ static inline void afb_req_verbose(struct afb_req req, int level, const char *fi va_end(args); } -/* macro for setting file, line and function automatically */ -# if !defined(AFB_BINDING_PRAGMA_NO_VERBOSE_DETAILS) -#define AFB_REQ_VERBOSE(req,level,...) afb_req_verbose(req,level,__FILE__,__LINE__,__func__,__VA_ARGS__) -#else -#define AFB_REQ_VERBOSE(req,level,...) afb_req_verbose(req,level,NULL,0,NULL,__VA_ARGS__) -#endif - -/* +/** + * @deprecated use bindings version 3 + * * Check whether the 'permission' is granted or not to the client * identified by 'req'. * * Returns 1 if the permission is granted or 0 otherwise. */ -static inline int afb_req_has_permission(struct afb_req req, const char *permission) +static inline int afb_req_x1_has_permission(struct afb_req_x1 req, const char *permission) { return req.itf->has_permission(req.closure, permission); } -/* +/** + * @deprecated use bindings version 3 + * * Get the application identifier of the client application for the * request 'req'. * @@ -405,19 +414,40 @@ static inline int afb_req_has_permission(struct afb_req req, const char *permiss * * The returned value if not NULL must be freed by the caller */ -static inline char *afb_req_get_application_id(struct afb_req req) +static inline char *afb_req_x1_get_application_id(struct afb_req_x1 req) { return req.itf->get_application_id(req.closure); } -/* +/** + * @deprecated use bindings version 3 + * * Get the user identifier (UID) of the client application for the * request 'req'. * * Returns -1 when the application can not be identified. */ -static inline int afb_req_get_uid(struct afb_req req) +static inline int afb_req_x1_get_uid(struct afb_req_x1 req) { return req.itf->get_uid(req.closure); } +/** + * @deprecated use bindings version 3 + * + * Get informations about the client of the + * request 'req'. + * + * Returns an object with client informations: + * { + * "pid": int, "uid": int, "gid": int, + * "smack": string, "appid": string, + * "uuid": string, "LOA": int + * } + */ +static inline struct json_object *afb_req_x1_get_client_info(struct afb_req_x1 req) +{ + return req.itf->get_client_info(req.closure); +} + + diff --git a/include/afb/afb-req-x2-itf.h b/include/afb/afb-req-x2-itf.h new file mode 100644 index 00000000..9de7a214 --- /dev/null +++ b/include/afb/afb-req-x2-itf.h @@ -0,0 +1,306 @@ +/* + * Copyright (C) 2016, 2017, 2018 "IoT.bzh" + * Author: José Bollo <jose.bollo@iot.bzh> + * + * 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 + +/* defined here */ +struct afb_req_x2; +struct afb_req_x2_itf; + +/* referenced here */ +#include "afb-arg.h" +struct afb_req_x1; +struct afb_event_x1; +struct afb_event_x2; +struct afb_api_x3; +struct afb_stored_req; + +/** + * structure for the request + */ +struct afb_req_x2 +{ + /** + * interface for the request + */ + const struct afb_req_x2_itf *itf; + + /** + * current api (if any) + */ + struct afb_api_x3 *api; + + /** + * closure associated with the callback processing the verb of the request + * as given at its declaration + */ + void *vcbdata; + + /** + * the name of the called api + */ + const char *called_api; + + /** + * the name of the called verb + */ + const char *called_verb; +}; + +/** + * subcall modes + * + * When making subcalls, it is now possible to explicitely set the subcall + * mode to a combination of the following mode using binary OR. + * + * In particular, the following combination of modes are to be known: + * + * - for **subcall** having a similar behaviour to the subcalls of bindings + * version 1 and 2: afb_req_x2_subcall_pass_events|afb_req_x2_subcall_on_behalf + * - for **subcall** having the behaviour of the **call**: + * afb_req_x2_subcall_catch_events|afb_req_x2_subcall_api_session + * + * Be aware that if none of mode afb_req_x2_subcall_catch_events or + * afb_req_x2_subcall_pass_events is set, subscrption to events will be ignored. + */ +enum afb_req_x2_subcall_flags +{ + /** + * the calling API wants to receive the events from subscription + */ + afb_req_x2_subcall_catch_events = 1, + + /** + * the original request will receive the events from subscription + */ + afb_req_x2_subcall_pass_events = 2, + + /** + * the calling API wants to use the credentials of the original request + */ + afb_req_x2_subcall_on_behalf = 4, + + /** + * the calling API wants to use its session instead of the one of the + * original request + */ + afb_req_x2_subcall_api_session = 8, +}; + +/** + * Interface for handling requests. + * + * It records the functions to be called for the request. + * Don't use this structure directly, Use the helper functions instead. + */ +struct afb_req_x2_itf +{ + /* CAUTION: respect the order, add at the end */ + + /** get the json */ + struct json_object *(*json)( + struct afb_req_x2 *req); + + /** get an argument */ + struct afb_arg (*get)( + struct afb_req_x2 *req, + const char *name); + + /** reply a success @deprecated use @ref reply */ + void (*legacy_success)( + struct afb_req_x2 *req, + struct json_object *obj, + const char *info); + + /** reply a failure @deprecated use @ref reply */ + void (*legacy_fail)( + struct afb_req_x2 *req, + const char *status, + const char *info); + + /** reply a success @deprecated use @ref vreply */ + void (*legacy_vsuccess)( + struct afb_req_x2 *req, + struct json_object *obj, + const char *fmt, + va_list args); + + /** reply a failure @deprecated use @ref vreply */ + void (*legacy_vfail)( + struct afb_req_x2 *req, + const char *status, + const char *fmt, + va_list args); + + /** get a client context @deprecated use @ref context_make */ + void *(*legacy_context_get)( + struct afb_req_x2 *req); + + /** set a client context @deprecated use @ref context_make */ + void (*legacy_context_set)( + struct afb_req_x2 *req, + void *value, + void (*free_value)(void*)); + + /** increase reference count of the request */ + struct afb_req_x2 *(*addref)( + struct afb_req_x2 *req); + + /** decrease reference count of the request */ + void (*unref)( + struct afb_req_x2 *req); + + /** close the client session related to the api of the request */ + void (*session_close)( + struct afb_req_x2 *req); + + /** set the levele of assurancy related to the api of the request */ + int (*session_set_LOA)( + struct afb_req_x2 *req, + unsigned level); + + /** make subscription of the client of the request to the event @deprecated use @ref subscribe_event_x2 */ + int (*legacy_subscribe_event_x1)( + struct afb_req_x2 *req, + struct afb_event_x1 event); + + /** remove subscription of the client of the request to the event @deprecated use @ref unsubscribe_event_x2 */ + int (*legacy_unsubscribe_event_x1)( + struct afb_req_x2 *req, + struct afb_event_x1 event); + + /** asynchronous subcall @deprecated use @ref subcall */ + void (*legacy_subcall)( + struct afb_req_x2 *req, + const char *api, + const char *verb, + struct json_object *args, + void (*callback)(void*, int, struct json_object*), + void *cb_closure); + + /** synchronous subcall @deprecated use @ref subcallsync */ + int (*legacy_subcallsync)( + struct afb_req_x2 *req, + const char *api, + const char *verb, + struct json_object *args, + struct json_object **result); + + /** log a message for the request */ + void (*vverbose)( + struct afb_req_x2 *req, + int level, + const char *file, + int line, + const char * func, + const char *fmt, + va_list args); + + /** store the request @deprecated no more needed */ + struct afb_stored_req *(*legacy_store_req)( + struct afb_req_x2 *req); + + /** asynchronous subcall with request @deprecated use @ref subcall */ + void (*legacy_subcall_req)( + struct afb_req_x2 *req, + const char *api, + const char *verb, + struct json_object *args, + void (*callback)(void*, int, struct json_object*, struct afb_req_x1), + void *cb_closure); + + /** store the request @deprecated no more needed */ + int (*has_permission)( + struct afb_req_x2 *req, + const char *permission); + + /** get the application id of the client of the request */ + char *(*get_application_id)( + struct afb_req_x2 *req); + + /** handle client context of the api getting the request */ + void *(*context_make)( + struct afb_req_x2 *req, + int replace, + void *(*create_value)(void *creation_closure), + void (*free_value)(void*), + void *creation_closure); + + /** make subscription of the client of the request to the event */ + int (*subscribe_event_x2)( + struct afb_req_x2 *req, + struct afb_event_x2 *event); + + /** remove subscription of the client of the request to the event */ + int (*unsubscribe_event_x2)( + struct afb_req_x2 *req, + struct afb_event_x2 *event); + + /** asynchronous subcall with request @deprecated use @ref subcall */ + void (*legacy_subcall_request)( + struct afb_req_x2 *req, + const char *api, + const char *verb, + struct json_object *args, + void (*callback)(void*, int, struct json_object*, struct afb_req_x2 *req), + void *cb_closure); + + /** get the user id (unix) of the client of the request */ + int (*get_uid)( + struct afb_req_x2 *req); + + /** reply to the request */ + void (*reply)( + struct afb_req_x2 *req, + struct json_object *obj, + const char *error, + const char *info); + + /** reply to the request with formating of info */ + void (*vreply)( + struct afb_req_x2 *req, + struct json_object *obj, + const char *error, + const char *fmt, + va_list args); + + /** get description of the client of the request */ + struct json_object *(*get_client_info)( + struct afb_req_x2 *req); + + /** asynchronous subcall */ + void (*subcall)( + struct afb_req_x2 *req, + const char *apiname, + const char *verb, + struct json_object *args, + int flags, + void (*callback)(void *closure, struct json_object *object, const char *error, const char * info, struct afb_req_x2 *req), + void *closure); + + /** synchronous subcall */ + int (*subcallsync)( + struct afb_req_x2 *req, + const char *api, + const char *verb, + struct json_object *args, + int flags, + struct json_object **object, + char **error, + char **info); +}; + diff --git a/include/afb/afb-req-x2.h b/include/afb/afb-req-x2.h new file mode 100644 index 00000000..70ffab80 --- /dev/null +++ b/include/afb/afb-req-x2.h @@ -0,0 +1,758 @@ +/* + * Copyright (C) 2016, 2017, 2018 "IoT.bzh" + * Author: José Bollo <jose.bollo@iot.bzh> + * + * 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 + +#include "afb-req-x2-itf.h" +#include "afb-api-x3.h" + +/** + * Checks whether the request 'req' is valid or not. + * + * @param req the request to check + * + * @return 0 if not valid or 1 if valid. + */ +static inline +int afb_req_x2_is_valid( + struct afb_req_x2 *req) +{ + return !!req; +} + +/** + * Retrieves the api that serves the request + * + * @param req the request whose serving api is queried + * + * @return the api serving the request + */ +static inline +struct afb_api_x3 *afb_req_x2_get_api( + struct afb_req_x2 *req) +{ + return req->api; +} + +/** + * Retrieves the callback data of the verb. This callback data is set + * when the verb is created. + * + * @param req whose verb vcbdata is queried + * + * @return the callback data attached to the verb description + */ +static inline +void *afb_req_x2_get_vcbdata( + struct afb_req_x2 *req) +{ + return req->vcbdata; +} + +/** + * Retrieve the name of the called api. + * + * @param req the request + * + * @return the name of the called api + * + * @see afb_api_x3_add_alias + */ +static inline +const char *afb_req_x2_get_called_api( + struct afb_req_x2 *req) +{ + return req->called_api; +} + +/** + * Retrieve the name of the called verb + * + * @param req the request + * + * @return the name of the called verb + */ +static inline +const char *afb_req_x2_get_called_verb( + struct afb_req_x2 *req) +{ + return req->called_verb; +} + +/** + * Is the log message of 'level (as defined for syslog) required for the + * request 'req'? + * + * @param req the request + * @param level the level to check as defined for syslog: + * + * EMERGENCY 0 System is unusable + * ALERT 1 Action must be taken immediately + * CRITICAL 2 Critical conditions + * ERROR 3 Error conditions + * WARNING 4 Warning conditions + * NOTICE 5 Normal but significant condition + * INFO 6 Informational + * DEBUG 7 Debug-level messages + * + * @return 0 if not required or a value not null if required + * + * @see syslog + */ +static inline +int afb_req_x2_wants_log_level( + struct afb_req_x2 *req, + int level) +{ + return afb_api_x3_wants_log_level(afb_req_x2_get_api(req), level); +} + +/** + * Gets from the request 'req' the argument of 'name'. + * + * Returns a PLAIN structure of type 'struct afb_arg'. + * + * When the argument of 'name' is not found, all fields of result are set to NULL. + * + * When the argument of 'name' is found, the fields are filled, + * in particular, the field 'result.name' is set to 'name'. + * + * There is a special name value: the empty string. + * The argument of name "" is defined only if the request was made using + * an HTTP POST of Content-Type "application/json". In that case, the + * argument of name "" receives the value of the body of the HTTP request. + * + * @param req the request + * @param name the name of the argument to get + * + * @return a structure describing the retrieved argument for the request + * + * @see afb_req_x2_value + * @see afb_req_x2_path + */ +static inline +struct afb_arg afb_req_x2_get( + struct afb_req_x2 *req, + const char *name) +{ + return req->itf->get(req, name); +} + +/** + * Gets from the request 'req' the string value of the argument of 'name'. + * Returns NULL if when there is no argument of 'name'. + * Returns the value of the argument of 'name' otherwise. + * + * Shortcut for: afb_req_x2_get(req, name).value + * + * @param req the request + * @param name the name of the argument's value to get + * + * @return the value as a string or NULL + * + * @see afb_req_x2_get + * @see afb_req_x2_path + */ +static inline +const char *afb_req_x2_value( + struct afb_req_x2 *req, + const char *name) +{ + return afb_req_x2_get(req, name).value; +} + +/** + * Gets from the request 'req' the path for file attached to the argument of 'name'. + * Returns NULL if when there is no argument of 'name' or when there is no file. + * Returns the path of the argument of 'name' otherwise. + * + * Shortcut for: afb_req_x2_get(req, name).path + * + * @param req the request + * @param name the name of the argument's path to get + * + * @return the path if any or NULL + * + * @see afb_req_x2_get + * @see afb_req_x2_value + */ +static inline +const char *afb_req_x2_path( + struct afb_req_x2 *req, + const char *name) +{ + return afb_req_x2_get(req, name).path; +} + +/** + * Gets from the request 'req' the json object hashing the arguments. + * + * The returned object must not be released using 'json_object_put'. + * + * @param req the request + * + * @return the JSON object of the query + * + * @see afb_req_x2_get + * @see afb_req_x2_value + * @see afb_req_x2_path + */ +static inline +struct json_object *afb_req_x2_json( + struct afb_req_x2 *req) +{ + return req->itf->json(req); +} + +/** + * Sends a reply to the request 'req'. + * + * The status of the reply is set to 'error' (that must be NULL on success). + * Its send the object 'obj' (can be NULL) with an + * informational comment 'info (can also be NULL). + * + * For convenience, the function calls 'json_object_put' for 'obj'. + * Thus, in the case where 'obj' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * @param req the request + * @param obj the replied object or NULL + * @param error the error message if it is a reply error or NULL + * @param info an informative text or NULL + * + * @see afb_req_x2_reply_v + * @see afb_req_x2_reply_f + */ +static inline +void afb_req_x2_reply( + struct afb_req_x2 *req, + struct json_object *obj, + const char *error, + const char *info) +{ + req->itf->reply(req, obj, error, info); +} + +/** + * Same as 'afb_req_x2_reply_f' but the arguments to the format 'info' + * are given as a variable argument list instance. + * + * For convenience, the function calls 'json_object_put' for 'obj'. + * Thus, in the case where 'obj' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * @param req the request + * @param obj the replied object or NULL + * @param error the error message if it is a reply error or NULL + * @param info an informative text containing a format as for vprintf + * @param args the va_list of arguments to the format as for vprintf + * + * @see afb_req_x2_reply + * @see afb_req_x2_reply_f + * @see vprintf + */ +static inline +void afb_req_x2_reply_v( + struct afb_req_x2 *req, + struct json_object *obj, + const char *error, + const char *info, + va_list args) +{ + req->itf->vreply(req, obj, error, info, args); +} + +/** + * Same as 'afb_req_x2_reply' but the 'info' is a formatting + * string followed by arguments. + * + * For convenience, the function calls 'json_object_put' for 'obj'. + * Thus, in the case where 'obj' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * @param req the request + * @param obj the replied object or NULL + * @param error the error message if it is a reply error or NULL + * @param info an informative text containing a format as for printf + * @param ... the arguments to the format as for printf + * + * @see afb_req_x2_reply + * @see afb_req_x2_reply_v + * @see printf + */ +__attribute__((format(printf, 4, 5))) +static inline +void afb_req_x2_reply_f( + struct afb_req_x2 *req, + struct json_object *obj, + const char *error, + const char *info, + ...) +{ + va_list args; + va_start(args, info); + afb_req_x2_reply_v(req, obj, error, info, args); + va_end(args); +} + +/** + * Manage the pointer stored by the binding for the client session of 'req'. + * + * If no previous pointer is stored or if 'replace' is not zero, a new value + * is generated using the function 'create_context' called with the 'closure'. + * If 'create_context' is NULL the generated value is 'closure'. + * + * When a value is created, the function 'free_context' is recorded and will + * be called (with the created value as argument) to free the created value when + * it is not more used. + * + * This function is atomic: it ensures that 2 threads will not race together. + * + * @param req the request + * @param replace if not zero an existing value is replaced + * @param create_context the creation function or NULL + * @param free_context the destroying function or NULL + * @param closure the closure to the creation function + * + * @return the stored value + */ +static inline +void *afb_req_x2_context( + struct afb_req_x2 *req, + int replace, + void *(*create_context)(void *closure), + void (*free_context)(void*), + void *closure) +{ + return req->itf->context_make(req, replace, create_context, free_context, closure); +} + +/** + * Gets the pointer stored by the binding for the session of 'req'. + * When the binding has not yet recorded a pointer, NULL is returned. + * + * Shortcut for: afb_req_x2_context(req, 0, NULL, NULL, NULL) + * + * @param req the request + * + * @return the previously stored value + */ +static inline +void *afb_req_x2_context_get( + struct afb_req_x2 *req) +{ + return afb_req_x2_context(req, 0, 0, 0, 0); +} + +/** + * Stores for the binding the pointer 'context' to the session of 'req'. + * The function 'free_context' will be called when the session is closed + * or if binding stores an other pointer. + * + * Shortcut for: afb_req_x2_context(req, 1, NULL, free_context, context) + * + * + * @param req the request + * @param context the context value to store + * @param free_context the cleaning function for the stored context (can be NULL) + */ +static inline +void afb_req_x2_context_set( + struct afb_req_x2 *req, + void *context, + void (*free_context)(void*)) +{ + afb_req_x2_context(req, 1, 0, free_context, context); +} + +/** + * Frees the pointer stored by the binding for the session of 'req' + * and sets it to NULL. + * + * Shortcut for: afb_req_x2_context_set(req, NULL, NULL) + * + * @param req the request + */ +static inline +void afb_req_x2_context_clear( + struct afb_req_x2 *req) +{ + afb_req_x2_context(req, 1, 0, 0, 0); +} + +/** + * Increments the count of references of 'req'. + * + * @param req the request + * + * @return returns the request req + */ +static inline +struct afb_req_x2 *afb_req_x2_addref( + struct afb_req_x2 *req) +{ + return req->itf->addref(req); +} + +/** + * Decrement the count of references of 'req'. + * + * @param req the request + */ +static inline +void afb_req_x2_unref( + struct afb_req_x2 *req) +{ + req->itf->unref(req); +} + +/** + * Closes the session associated with 'req' + * and delete all associated contexts. + * + * @param req the request + */ +static inline +void afb_req_x2_session_close( + struct afb_req_x2 *req) +{ + req->itf->session_close(req); +} + +/** + * Sets the level of assurance of the session of 'req' + * to 'level'. The effect of this function is subject of + * security policies. + * + * @param req the request + * @param level of assurance from 0 to 7 + * + * @return 0 on success or -1 if failed. + */ +static inline +int afb_req_x2_session_set_LOA( + struct afb_req_x2 *req, + unsigned level) +{ + return req->itf->session_set_LOA(req, level); +} + +/** + * Establishes for the client link identified by 'req' a subscription + * to the 'event'. + * + * @param req the request + * @param event the event to subscribe + * + * @return 0 in case of successful subscription or -1 in case of error. + */ +static inline +int afb_req_x2_subscribe( + struct afb_req_x2 *req, + struct afb_event_x2 *event) +{ + return req->itf->subscribe_event_x2(req, event); +} + +/** + * Revokes the subscription established to the 'event' for the client + * link identified by 'req'. + * Returns 0 in case of successful subscription or -1 in case of error. + * + * @param req the request + * @param event the event to revoke + * + * @return 0 in case of successful subscription or -1 in case of error. + */ +static inline +int afb_req_x2_unsubscribe( + struct afb_req_x2 *req, + struct afb_event_x2 *event) +{ + return req->itf->unsubscribe_event_x2(req, event); +} + +/** + * @deprecated use @ref afb_req_x2_subcall + * + * Makes a call to the method of name 'api' / 'verb' with the object 'args'. + * This call is made in the context of the request 'req'. + * On completion, the function 'callback' is invoked with the + * 'closure' given at call and two other parameters: 'iserror' and 'result'. + * 'status' is 0 on success or negative when on an error reply. + * 'result' is the json object of the reply, you must not call json_object_put + * on the result. + * + * For convenience, the function calls 'json_object_put' for 'args'. + * Thus, in the case where 'args' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * @param req the request + * @param api the name of the api to call + * @param verb the name of the verb to call + * @param args the arguments of the call as a JSON object + * @param callback the call back that will receive the reply + * @param closure the closure passed back to the callback + * + * @see afb_req_x2_subcall + * @see afb_req_x2_subcall_sync + */ +static inline +void afb_req_x2_subcall_legacy( + struct afb_req_x2 *req, + const char *api, + const char *verb, + struct json_object *args, + void (*callback)(void *closure, int iserror, struct json_object *result, struct afb_req_x2 *req), + void *closure) +{ + req->itf->legacy_subcall_request(req, api, verb, args, callback, closure); +} + +/** + * @deprecated use @ref afb_req_x2_subcall_sync + * + * Makes a call to the method of name 'api' / 'verb' with the object 'args'. + * This call is made in the context of the request 'req'. + * This call is synchronous, it waits untill completion of the request. + * It returns 0 on success or a negative value on error answer. + * The object pointed by 'result' is filled and must be released by the caller + * after its use by calling 'json_object_put'. + * + * For convenience, the function calls 'json_object_put' for 'args'. + * Thus, in the case where 'args' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * @param req the request + * @param api the name of the api to call + * @param verb the name of the verb to call + * @param args the arguments of the call as a JSON object + * @param result the pointer to the JSON object pointer that will receive the result + * + * @return 0 on success or a negative value on error answer. + * + * @see afb_req_x2_subcall + * @see afb_req_x2_subcall_sync + */ +static inline +int afb_req_x2_subcall_sync_legacy( + struct afb_req_x2 *req, + const char *api, + const char *verb, + struct json_object *args, + struct json_object **result) +{ + return req->itf->legacy_subcallsync(req, api, verb, args, result); +} + +/** + * Send associated to 'req' a message described by 'fmt' and following parameters + * to the journal for the verbosity 'level'. + * + * 'file', 'line' and 'func' are indicators of position of the code in source files + * (see macros __FILE__, __LINE__ and __func__). + * + * 'level' is defined by syslog standard: + * EMERGENCY 0 System is unusable + * ALERT 1 Action must be taken immediately + * CRITICAL 2 Critical conditions + * ERROR 3 Error conditions + * WARNING 4 Warning conditions + * NOTICE 5 Normal but significant condition + * INFO 6 Informational + * DEBUG 7 Debug-level messages + * + * @param req the request + * @param level the level of the message + * @param file the source filename that emits the message or NULL + * @param line the line number in the source filename that emits the message + * @param func the name of the function that emits the message or NULL + * @param fmt the message format as for printf + * @param ... the arguments of the printf + * + * @see printf + */ +__attribute__((format(printf, 6, 7))) +static inline +void afb_req_x2_verbose( + struct afb_req_x2 *req, + int level, const char *file, + int line, + const char * func, + const char *fmt, + ...) +{ + va_list args; + va_start(args, fmt); + req->itf->vverbose(req, level, file, line, func, fmt, args); + va_end(args); +} + +/** + * Check whether the 'permission' is granted or not to the client + * identified by 'req'. + * + * @param req the request + * @param permission string to check + * + * @return 1 if the permission is granted or 0 otherwise. + */ +static inline +int afb_req_x2_has_permission( + struct afb_req_x2 *req, + const char *permission) +{ + return req->itf->has_permission(req, permission); +} + +/** + * Get the application identifier of the client application for the + * request 'req'. + * + * Returns the application identifier or NULL when the application + * can not be identified. + * + * The returned value if not NULL must be freed by the caller + * + * @param req the request + * + * @return the string for the application id of the client MUST BE FREED + */ +static inline +char *afb_req_x2_get_application_id( + struct afb_req_x2 *req) +{ + return req->itf->get_application_id(req); +} + +/** + * Get the user identifier (UID) of the client for the + * request 'req'. + * + * @param req the request + * + * @return -1 when the application can not be identified or the unix uid. + * + */ +static inline +int afb_req_x2_get_uid( + struct afb_req_x2 *req) +{ + return req->itf->get_uid(req); +} + +/** + * Get informations about the client of the + * request 'req'. + * + * Returns an object with client informations: + * { + * "pid": int, "uid": int, "gid": int, + * "label": string, "id": string, "user": string, + * "uuid": string, "LOA": int + * } + * + * If some of this information can't be computed, the field of the return + * object will not be set at all. + * + * @param req the request + * + * @return a JSON object that must be freed using @ref json_object_put + */ +static inline +struct json_object *afb_req_x2_get_client_info( + struct afb_req_x2 *req) +{ + return req->itf->get_client_info(req); +} + +/** + * Calls the 'verb' of the 'api' with the arguments 'args' and 'verb' in the name of the binding. + * The result of the call is delivered to the 'callback' function with the 'callback_closure'. + * + * For convenience, the function calls 'json_object_put' for 'args'. + * Thus, in the case where 'args' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * The 'callback' receives 5 arguments: + * 1. 'closure' the user defined closure pointer 'closure', + * 2. 'object' a JSON object returned (can be NULL) + * 3. 'error' a string not NULL in case of error + * 4. 'info' a string handling some info (can be NULL) + * 5. 'req' the req + * + * @param req The request + * @param api The api name of the method to call + * @param verb The verb name of the method to call + * @param args The arguments to pass to the method + * @param flags The bit field of flags for the subcall as defined by @ref afb_req_x2_subcall_flags + * @param callback The to call on completion + * @param closure The closure to pass to the callback + * + * @see also 'afb_req_subcall_sync' + */ +static inline +void afb_req_x2_subcall( + struct afb_req_x2 *req, + const char *api, + const char *verb, + struct json_object *args, + int flags, + void (*callback)(void *closure, struct json_object *object, const char *error, const char * info, struct afb_req_x2 *req), + void *closure) +{ + req->itf->subcall(req, api, verb, args, flags, callback, closure); +} + +/** + * Makes a call to the method of name 'api' / 'verb' with the object 'args'. + * This call is made in the context of the request 'req'. + * This call is synchronous, it waits untill completion of the request. + * It returns 0 on success or a negative value on error answer. + * + * For convenience, the function calls 'json_object_put' for 'args'. + * Thus, in the case where 'args' should remain available after + * the function returns, the function 'json_object_get' shall be used. + * + * See also: + * - 'afb_req_x2_subcall_req' that is convenient to keep request alive automatically. + * - 'afb_req_x2_subcall' that doesn't keep request alive automatically. + * + * @param req The request + * @param api The api name of the method to call + * @param verb The verb name of the method to call + * @param args The arguments to pass to the method + * @param flags The bit field of flags for the subcall as defined by @ref afb_req_x2_subcall_flags + * @param object a pointer where the replied JSON object is stored must be freed using @ref json_object_put (can be NULL) + * @param error a pointer where a copy of the replied error is stored must be freed using @ref free (can be NULL) + * @param info a pointer where a copy of the replied info is stored must be freed using @ref free (can be NULL) + * + * @return 0 in case of success or -1 in case of error + */ +static inline +int afb_req_x2_subcall_sync( + struct afb_req_x2 *req, + const char *api, + const char *verb, + struct json_object *args, + int flags, + struct json_object **object, + char **error, + char **info) +{ + return req->itf->subcallsync(req, api, verb, args, flags, object, error, info); +} diff --git a/include/afb/afb-request-itf.h b/include/afb/afb-request-itf.h deleted file mode 100644 index 44066c66..00000000 --- a/include/afb/afb-request-itf.h +++ /dev/null @@ -1,205 +0,0 @@ -/* - * Copyright (C) 2016, 2017, 2018 "IoT.bzh" - * Author: José Bollo <jose.bollo@iot.bzh> - * - * 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 - -/* defined here */ -struct afb_arg; -struct afb_request; -struct afb_request_itf; - -/* referenced here */ -#include <stdarg.h> -struct json_object; -struct afb_req; -struct afb_event; -struct afb_eventid; -struct afb_dynapi; -struct afb_stored_req; - -/* - * Describes an argument (or parameter) of a request - */ -struct afb_arg -{ - const char *name; /* name of the argument or NULL if invalid */ - const char *value; /* string representation of the value of the argument */ - /* original filename of the argument if path != NULL */ - const char *path; /* if not NULL, path of the received file for the argument */ - /* when the request is finalized this file is removed */ -}; - -/* - * structure for the request - */ -struct afb_request -{ - /* interface for the request */ - const struct afb_request_itf *itf; - - /* current dynapi (if any) */ - struct afb_dynapi *dynapi; - - /* closure associated with the callback processing the verb of the request - * as given at its declaration */ - void *vcbdata; - - /* the name of the called verb */ - const char *api; - - /* the name of the called verb */ - const char *verb; -}; - -/* - * Interface for handling requests. - * It records the functions to be called for the request. - * Don't use this structure directly. - * Use the helper functions - */ -struct afb_request_itf -{ - /* CAUTION: respect the order, add at the end */ - - struct json_object *(*json)( - struct afb_request *request); - - struct afb_arg (*get)( - struct afb_request *request, - const char *name); - - void (*success)( - struct afb_request *request, - struct json_object *obj, - const char *info); - - void (*fail)( - struct afb_request *request, - const char *status, - const char *info); - - void (*vsuccess)( - struct afb_request *request, - struct json_object *obj, - const char *fmt, - va_list args); - - void (*vfail)( - struct afb_request *request, - const char *status, - const char *fmt, - va_list args); - - void *(*context_get)( - struct afb_request *request); - - void (*context_set)( - struct afb_request *request, - void *value, - void (*free_value)(void*)); - - struct afb_request *(*addref)( - struct afb_request *request); - - void (*unref)( - struct afb_request *request); - - void (*session_close)( - struct afb_request *request); - - int (*session_set_LOA)( - struct afb_request *request, - unsigned level); - - int (*subscribe)( - struct afb_request *request, - struct afb_event event); - - int (*unsubscribe)( - struct afb_request *request, - struct afb_event event); - - void (*subcall)( - struct afb_request *request, - const char *api, - const char *verb, - struct json_object *args, - void (*callback)(void*, int, struct json_object*), - void *cb_closure); - - int (*subcallsync)( - struct afb_request *request, - const char *api, - const char *verb, - struct json_object *args, - struct json_object **result); - - void (*vverbose)( - struct afb_request *request, - int level, - const char *file, - int line, - const char * func, - const char *fmt, - va_list args); - - struct afb_stored_req *(*store)( - struct afb_request *request); - - void (*subcall_req)( - struct afb_request *request, - const char *api, - const char *verb, - struct json_object *args, - void (*callback)(void*, int, struct json_object*, struct afb_req), - void *cb_closure); - - int (*has_permission)( - struct afb_request *request, - const char *permission); - - char *(*get_application_id)( - struct afb_request *request); - - void *(*context_make)( - struct afb_request *request, - int replace, - void *(*create_value)(void *creation_closure), - void (*free_value)(void*), - void *creation_closure); - - int (*subscribe_eventid)( - struct afb_request *request, - struct afb_eventid *eventid); - - int (*unsubscribe_eventid)( - struct afb_request *request, - struct afb_eventid *eventid); - - void (*subcall_request)( - struct afb_request *request, - const char *api, - const char *verb, - struct json_object *args, - void (*callback)(void*, int, struct json_object*, struct afb_request *request), - void *cb_closure); - - int (*get_uid)( - struct afb_request *request); - -}; - diff --git a/include/afb/afb-request.h b/include/afb/afb-request.h deleted file mode 100644 index 8e909bba..00000000 --- a/include/afb/afb-request.h +++ /dev/null @@ -1,389 +0,0 @@ -/* - * Copyright (C) 2016, 2017, 2018 "IoT.bzh" - * Author: José Bollo <jose.bollo@iot.bzh> - * - * 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 - -#include "afb-request-itf.h" - -static inline struct afb_dynapi *afb_request_get_dynapi(struct afb_request *request) -{ - return request->dynapi; -} - -static inline void *afb_request_get_vcbdata(struct afb_request *request) -{ - return request->vcbdata; -} - -static inline const char *afb_request_get_api(struct afb_request *request) -{ - return request->api; -} - -static inline const char *afb_request_get_verb(struct afb_request *request) -{ - return request->verb; -} - -/* - * Gets from the request 'request' the argument of 'name'. - * Returns a PLAIN structure of type 'struct afb_arg'. - * When the argument of 'name' is not found, all fields of result are set to NULL. - * When the argument of 'name' is found, the fields are filled, - * in particular, the field 'result.name' is set to 'name'. - * - * There is a special name value: the empty string. - * The argument of name "" is defined only if the request was made using - * an HTTP POST of Content-Type "application/json". In that case, the - * argument of name "" receives the value of the body of the HTTP request. - */ -static inline struct afb_arg afb_request_get(struct afb_request *request, const char *name) -{ - return request->itf->get(request, name); -} - -/* - * Gets from the request 'request' the string value of the argument of 'name'. - * Returns NULL if when there is no argument of 'name'. - * Returns the value of the argument of 'name' otherwise. - * - * Shortcut for: afb_request_get(request, name).value - */ -static inline const char *afb_request_value(struct afb_request *request, const char *name) -{ - return afb_request_get(request, name).value; -} - -/* - * Gets from the request 'request' the path for file attached to the argument of 'name'. - * Returns NULL if when there is no argument of 'name' or when there is no file. - * Returns the path of the argument of 'name' otherwise. - * - * Shortcut for: afb_request_get(request, name).path - */ -static inline const char *afb_request_path(struct afb_request *request, const char *name) -{ - return afb_request_get(request, name).path; -} - -/* - * Gets from the request 'request' the json object hashing the arguments. - * The returned object must not be released using 'json_object_put'. - */ -static inline struct json_object *afb_request_json(struct afb_request *request) -{ - return request->itf->json(request); -} - -/* - * Sends a reply of kind success to the request 'request'. - * The status of the reply is automatically set to "success". - * Its send the object 'obj' (can be NULL) with an - * informationnal comment 'info (can also be NULL). - * - * For convenience, the function calls 'json_object_put' for 'obj'. - * Thus, in the case where 'obj' should remain available after - * the function returns, the function 'json_object_get' shall be used. - */ -static inline void afb_request_success(struct afb_request *request, struct json_object *obj, const char *info) -{ - request->itf->success(request, obj, info); -} - -/* - * Same as 'afb_request_success' but the 'info' is a formatting - * string followed by arguments. - * - * For convenience, the function calls 'json_object_put' for 'obj'. - * Thus, in the case where 'obj' should remain available after - * the function returns, the function 'json_object_get' shall be used. - */ -static inline void afb_request_success_f(struct afb_request *request, struct json_object *obj, const char *info, ...) __attribute__((format(printf, 3, 4))); -static inline void afb_request_success_f(struct afb_request *request, struct json_object *obj, const char *info, ...) -{ - va_list args; - va_start(args, info); - request->itf->vsuccess(request, obj, info, args); - va_end(args); -} - -/* - * Same as 'afb_request_success_f' but the arguments to the format 'info' - * are given as a variable argument list instance. - * - * For convenience, the function calls 'json_object_put' for 'obj'. - * Thus, in the case where 'obj' should remain available after - * the function returns, the function 'json_object_get' shall be used. - */ -static inline void afb_request_success_v(struct afb_request *request, struct json_object *obj, const char *info, va_list args) -{ - request->itf->vsuccess(request, obj, info, args); -} - -/* - * Sends a reply of kind failure to the request 'request'. - * The status of the reply is set to 'status' and an - * informationnal comment 'info' (can also be NULL) can be added. - * - * Note that calling afb_request_fail("success", info) is equivalent - * to call afb_request_success(NULL, info). Thus even if possible it - * is strongly recommanded to NEVER use "success" for status. - */ -static inline void afb_request_fail(struct afb_request *request, const char *status, const char *info) -{ - request->itf->fail(request, status, info); -} - -/* - * Same as 'afb_request_fail' but the 'info' is a formatting - * string followed by arguments. - */ -static inline void afb_request_fail_f(struct afb_request *request, const char *status, const char *info, ...) __attribute__((format(printf, 3, 4))); -static inline void afb_request_fail_f(struct afb_request *request, const char *status, const char *info, ...) -{ - va_list args; - va_start(args, info); - request->itf->vfail(request, status, info, args); - va_end(args); -} - -/* - * Same as 'afb_request_fail_f' but the arguments to the format 'info' - * are given as a variable argument list instance. - */ -static inline void afb_request_fail_v(struct afb_request *request, const char *status, const char *info, va_list args) -{ - request->itf->vfail(request, status, info, args); -} - -/* - * Gets the pointer stored by the binding for the session of 'request'. - * When the binding has not yet recorded a pointer, NULL is returned. - */ -static inline void *afb_request_context_get(struct afb_request *request) -{ - return request->itf->context_make(request, 0, 0, 0, 0); -} - -/* - * Stores for the binding the pointer 'context' to the session of 'request'. - * The function 'free_context' will be called when the session is closed - * or if binding stores an other pointer. - */ -static inline void afb_request_context_set(struct afb_request *request, void *context, void (*free_context)(void*)) -{ - request->itf->context_make(request, 1, 0, free_context, context); -} - -/* - * Gets the pointer stored by the binding for the session of 'request'. - * If no previous pointer is stored or if 'replace' is not zero, a new value - * is generated using the function 'create_context' called with the 'closure'. - * If 'create_context' is NULL the generated value is 'closure'. - * When a value is created, the function 'free_context' is recorded and will - * be called (with the created value as argument) to free the created value when - * it is not more used. - * This function is atomic: it ensures that 2 threads will not race together. - */ -static inline void *afb_request_context(struct afb_request *request, int replace, void *(*create_context)(void *closure), void (*free_context)(void*), void *closure) -{ - return request->itf->context_make(request, replace, create_context, free_context, closure); -} - -/* - * Frees the pointer stored by the binding for the session of 'request' - * and sets it to NULL. - * - * Shortcut for: afb_request_context_set(request, NULL, NULL) - */ -static inline void afb_request_context_clear(struct afb_request *request) -{ - request->itf->context_make(request, 1, 0, 0, 0); -} - -/* - * Adds one to the count of references of 'request'. - * This function MUST be called by asynchronous implementations - * of verbs if no reply was sent before returning. - */ -static inline struct afb_request *afb_request_addref(struct afb_request *request) -{ - return request->itf->addref(request); -} - -/* - * Substracts one to the count of references of 'request'. - * This function MUST be called by asynchronous implementations - * of verbs after sending the asynchronous reply. - */ -static inline void afb_request_unref(struct afb_request *request) -{ - request->itf->unref(request); -} - -/* - * Closes the session associated with 'request' - * and delete all associated contexts. - */ -static inline void afb_request_session_close(struct afb_request *request) -{ - request->itf->session_close(request); -} - -/* - * Sets the level of assurance of the session of 'request' - * to 'level'. The effect of this function is subject of - * security policies. - * Returns 1 on success or 0 if failed. - */ -static inline int afb_request_session_set_LOA(struct afb_request *request, unsigned level) -{ - return request->itf->session_set_LOA(request, level); -} - -/* - * Establishes for the client link identified by 'request' a subscription - * to the 'event'. - * Returns 0 in case of successful subscription or -1 in case of error. - */ -static inline int afb_request_subscribe(struct afb_request *request, struct afb_eventid *eventid) -{ - return request->itf->subscribe_eventid(request, eventid); -} - -/* - * Revokes the subscription established to the 'event' for the client - * link identified by 'request'. - * Returns 0 in case of successful subscription or -1 in case of error. - */ -static inline int afb_request_unsubscribe(struct afb_request *request, struct afb_eventid *eventid) -{ - return request->itf->unsubscribe_eventid(request, eventid); -} - -/* - * Makes a call to the method of name 'api' / 'verb' with the object 'args'. - * This call is made in the context of the request 'request'. - * On completion, the function 'callback' is invoked with the - * 'closure' given at call and two other parameters: 'iserror' and 'result'. - * 'status' is 0 on success or negative when on an error reply. - * 'result' is the json object of the reply, you must not call json_object_put - * on the result. - * - * For convenience, the function calls 'json_object_put' for 'args'. - * Thus, in the case where 'args' should remain available after - * the function returns, the function 'json_object_get' shall be used. - * - * See also: - * - 'afb_request_subcall_req' that is convenient to keep request alive automatically. - * - 'afb_request_subcall_sync' the synchronous version - */ -static inline void afb_request_subcall(struct afb_request *request, const char *api, const char *verb, struct json_object *args, void (*callback)(void *closure, int iserror, struct json_object *result, struct afb_request *request), void *closure) -{ - request->itf->subcall_request(request, api, verb, args, callback, closure); -} - -/* - * Makes a call to the method of name 'api' / 'verb' with the object 'args'. - * This call is made in the context of the request 'request'. - * This call is synchronous, it waits untill completion of the request. - * It returns 0 on success or a negative value on error answer. - * The object pointed by 'result' is filled and must be released by the caller - * after its use by calling 'json_object_put'. - * - * For convenience, the function calls 'json_object_put' for 'args'. - * Thus, in the case where 'args' should remain available after - * the function returns, the function 'json_object_get' shall be used. - * - * See also: - * - 'afb_request_subcall_req' that is convenient to keep request alive automatically. - * - 'afb_request_subcall' that doesn't keep request alive automatically. - */ -static inline int afb_request_subcall_sync(struct afb_request *request, const char *api, const char *verb, struct json_object *args, struct json_object **result) -{ - return request->itf->subcallsync(request, api, verb, args, result); -} - -/* - * Send associated to 'request' a message described by 'fmt' and following parameters - * to the journal for the verbosity 'level'. - * - * 'file', 'line' and 'func' are indicators of position of the code in source files - * (see macros __FILE__, __LINE__ and __func__). - * - * 'level' is defined by syslog standard: - * EMERGENCY 0 System is unusable - * ALERT 1 Action must be taken immediately - * CRITICAL 2 Critical conditions - * ERROR 3 Error conditions - * WARNING 4 Warning conditions - * NOTICE 5 Normal but significant condition - * INFO 6 Informational - * DEBUG 7 Debug-level messages - */ -static inline void afb_request_verbose(struct afb_request *request, int level, const char *file, int line, const char * func, const char *fmt, ...) __attribute__((format(printf, 6, 7))); -static inline void afb_request_verbose(struct afb_request *request, int level, const char *file, int line, const char * func, const char *fmt, ...) -{ - va_list args; - va_start(args, fmt); - request->itf->vverbose(request, level, file, line, func, fmt, args); - va_end(args); -} - -/* macro for setting file, line and function automatically */ -# if !defined(AFB_BINDING_PRAGMA_NO_VERBOSE_DETAILS) -#define AFB_REQUEST_VERBOSE(request,level,...) afb_request_verbose(request,level,__FILE__,__LINE__,__func__,__VA_ARGS__) -#else -#define AFB_REQUEST_VERBOSE(request,level,...) afb_request_verbose(request,level,NULL,0,NULL,__VA_ARGS__) -#endif - -/* - * Check whether the 'permission' is granted or not to the client - * identified by 'request'. - * - * Returns 1 if the permission is granted or 0 otherwise. - */ -static inline int afb_request_has_permission(struct afb_request *request, const char *permission) -{ - return request->itf->has_permission(request, permission); -} - -/* - * Get the application identifier of the client application for the - * request 'request'. - * - * Returns the application identifier or NULL when the application - * can not be identified. - * - * The returned value if not NULL must be freed by the caller - */ -static inline char *afb_request_get_application_id(struct afb_request *request) -{ - return request->itf->get_application_id(request); -} - -/* - * Get the user identifier (UID) of the client for the - * request 'request'. - * - * Returns -1 when the application can not be identified. - */ -static inline int afb_request_get_uid(struct afb_request *request) -{ - return request->itf->get_uid(request); -} - diff --git a/include/afb/afb-service-itf.h b/include/afb/afb-service-itf-x1.h index dd79bdde..fcdd08e1 100644 --- a/include/afb/afb-service-itf.h +++ b/include/afb/afb-service-itf-x1.h @@ -17,32 +17,35 @@ #pragma once -/* avoid inclusion of <json-c/json.h> */ -struct json_object; +struct afb_api_x3; -/* +/** + * @deprecated use bindings version 3 + * * Interface for internal of services * It records the functions to be called for the request. * Don't use this structure directly. * Use the helper functions documented below. */ -struct afb_service_itf +struct afb_service_itf_x1 { /* CAUTION: respect the order, add at the end */ - void (*call)(void *closure, const char *api, const char *verb, struct json_object *args, + void (*call)(struct afb_api_x3 *closure, const char *api, const char *verb, struct json_object *args, void (*callback)(void*, int, struct json_object*), void *callback_closure); - int (*call_sync)(void *closure, const char *api, const char *verb, struct json_object *args, + int (*call_sync)(struct afb_api_x3 *closure, const char *api, const char *verb, struct json_object *args, struct json_object **result); }; -/* +/** + * @deprecated use bindings version 3 + * * Object that encapsulate accesses to service items */ -struct afb_service +struct afb_service_x1 { - const struct afb_service_itf *itf; - void *closure; + const struct afb_service_itf_x1 *itf; + struct afb_api_x3 *closure; }; diff --git a/include/afb/afb-service-v1.h b/include/afb/afb-service-v1.h index 6a24ecb0..a3265af8 100644 --- a/include/afb/afb-service-v1.h +++ b/include/afb/afb-service-v1.h @@ -17,9 +17,11 @@ #pragma once -#include "afb-service-itf.h" +#include "afb-service-itf-x1.h" /** + * @deprecated use bindings version 3 + * * Calls the 'verb' of the 'api' with the arguments 'args' and 'verb' in the name of the binding. * The result of the call is delivered to the 'callback' function with the 'callback_closure'. * @@ -42,7 +44,7 @@ * @see also 'afb_req_subcall' */ static inline void afb_service_call_v1( - struct afb_service service, + struct afb_service_x1 service, const char *api, const char *verb, struct json_object *args, @@ -53,6 +55,8 @@ static inline void afb_service_call_v1( } /** + * @deprecated use bindings version 3 + * * Calls the 'verb' of the 'api' with the arguments 'args' and 'verb' in the name of the binding. * 'result' will receive the response. * @@ -71,7 +75,7 @@ static inline void afb_service_call_v1( * @see also 'afb_req_subcall' */ static inline int afb_service_call_sync_v1( - struct afb_service service, + struct afb_service_x1 service, const char *api, const char *verb, struct json_object *args, diff --git a/include/afb/afb-service-v2.h b/include/afb/afb-service-v2.h index df751bd5..da59786d 100644 --- a/include/afb/afb-service-v2.h +++ b/include/afb/afb-service-v2.h @@ -17,9 +17,11 @@ #pragma once -#include "afb-service-itf.h" +#include "afb-service-itf-x1.h" /** + * @deprecated use bindings version 3 + * * Calls the 'verb' of the 'api' with the arguments 'args' and 'verb' in the name of the binding. * The result of the call is delivered to the 'callback' function with the 'callback_closure'. * @@ -51,6 +53,8 @@ static inline void afb_service_call_v2( } /** + * @deprecated use bindings version 3 + * * Calls the 'verb' of the 'api' with the arguments 'args' and 'verb' in the name of the binding. * 'result' will receive the response. * diff --git a/include/afb/afb-session-v1.h b/include/afb/afb-session-v1.h deleted file mode 100644 index a606679b..00000000 --- a/include/afb/afb-session-v1.h +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright (C) 2016, 2017, 2018 "IoT.bzh" - * Author: José Bollo <jose.bollo@iot.bzh> - * - * 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 - -/* - * Enum for Session/Token/Assurance middleware. - */ -enum afb_session_flags_v1 -{ - AFB_SESSION_NONE_V1 = 0, /* nothing required */ - AFB_SESSION_CREATE_V1 = 1, /* Obsolete */ - AFB_SESSION_CLOSE_V1 = 2, /* After token authentification, closes the session at end */ - AFB_SESSION_RENEW_V1 = 4, /* After token authentification, refreshes the token at end */ - AFB_SESSION_CHECK_V1 = 8, /* Requires token authentification */ - - AFB_SESSION_LOA_GE_V1 = 16, /* check that the LOA is greater or equal to the given value */ - AFB_SESSION_LOA_LE_V1 = 32, /* check that the LOA is lesser or equal to the given value */ - AFB_SESSION_LOA_EQ_V1 = 48, /* check that the LOA is equal to the given value */ - - AFB_SESSION_LOA_SHIFT_V1 = 6, /* shift for LOA */ - AFB_SESSION_LOA_MASK_V1 = 7, /* mask for LOA */ - - AFB_SESSION_LOA_0_V1 = 0, /* value for LOA of 0 */ - AFB_SESSION_LOA_1_V1 = 64, /* value for LOA of 1 */ - AFB_SESSION_LOA_2_V1 = 128, /* value for LOA of 2 */ - AFB_SESSION_LOA_3_V1 = 192, /* value for LOA of 3 */ - AFB_SESSION_LOA_4_V1 = 256, /* value for LOA of 4 */ - - AFB_SESSION_LOA_LE_0_V1 = AFB_SESSION_LOA_LE_V1 | AFB_SESSION_LOA_0_V1, /* check LOA <= 0 */ - AFB_SESSION_LOA_LE_1_V1 = AFB_SESSION_LOA_LE_V1 | AFB_SESSION_LOA_1_V1, /* check LOA <= 1 */ - AFB_SESSION_LOA_LE_2_V1 = AFB_SESSION_LOA_LE_V1 | AFB_SESSION_LOA_2_V1, /* check LOA <= 2 */ - AFB_SESSION_LOA_LE_3_V1 = AFB_SESSION_LOA_LE_V1 | AFB_SESSION_LOA_3_V1, /* check LOA <= 3 */ - - AFB_SESSION_LOA_EQ_0_V1 = AFB_SESSION_LOA_EQ_V1 | AFB_SESSION_LOA_0_V1, /* check LOA == 0 */ - AFB_SESSION_LOA_EQ_1_V1 = AFB_SESSION_LOA_EQ_V1 | AFB_SESSION_LOA_1_V1, /* check LOA == 1 */ - AFB_SESSION_LOA_EQ_2_V1 = AFB_SESSION_LOA_EQ_V1 | AFB_SESSION_LOA_2_V1, /* check LOA == 2 */ - AFB_SESSION_LOA_EQ_3_V1 = AFB_SESSION_LOA_EQ_V1 | AFB_SESSION_LOA_3_V1, /* check LOA == 3 */ - - AFB_SESSION_LOA_GE_0_V1 = AFB_SESSION_LOA_GE_V1 | AFB_SESSION_LOA_0_V1, /* check LOA >= 0 */ - AFB_SESSION_LOA_GE_1_V1 = AFB_SESSION_LOA_GE_V1 | AFB_SESSION_LOA_1_V1, /* check LOA >= 1 */ - AFB_SESSION_LOA_GE_2_V1 = AFB_SESSION_LOA_GE_V1 | AFB_SESSION_LOA_2_V1, /* check LOA >= 2 */ - AFB_SESSION_LOA_GE_3_V1 = AFB_SESSION_LOA_GE_V1 | AFB_SESSION_LOA_3_V1 /* check LOA >= 3 */ -}; - diff --git a/include/afb/afb-session-v2.h b/include/afb/afb-session-v2.h deleted file mode 100644 index 3f940ed6..00000000 --- a/include/afb/afb-session-v2.h +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Copyright (C) 2016, 2017, 2018 "IoT.bzh" - * Author: José Bollo <jose.bollo@iot.bzh> - * - * 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 - -/* - * Enum for Session/Token/Assurance middleware. - */ -enum afb_session_flags_v2 -{ - AFB_SESSION_LOA_MASK_V2 = 3, /* mask for LOA */ - - AFB_SESSION_LOA_0_V2 = 0, /* value for LOA of 0 */ - AFB_SESSION_LOA_1_V2 = 1, /* value for LOA of 1 */ - AFB_SESSION_LOA_2_V2 = 2, /* value for LOA of 2 */ - AFB_SESSION_LOA_3_V2 = 3, /* value for LOA of 3 */ - - AFB_SESSION_CHECK_V2 = 4, /* Requires token authentification */ - AFB_SESSION_REFRESH_V2 = 8, /* After token authentification, refreshes the token at end */ - AFB_SESSION_CLOSE_V2 = 16, /* After token authentification, closes the session at end */ - - AFB_SESSION_NONE_V2 = 0 /* nothing required */ -}; - diff --git a/include/afb/afb-session-x1.h b/include/afb/afb-session-x1.h new file mode 100644 index 00000000..776cb8f5 --- /dev/null +++ b/include/afb/afb-session-x1.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2016, 2017, 2018 "IoT.bzh" + * Author: José Bollo <jose.bollo@iot.bzh> + * + * 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 + +/** + * @deprecated use bindings version 3 + * + * Enum for Session/Token/Assurance of bindings version 1. + */ +enum afb_session_flags_x1 +{ + AFB_SESSION_NONE_X1 = 0, /**< nothing required */ + AFB_SESSION_CREATE_X1 = 1, /**< Obsolete */ + AFB_SESSION_CLOSE_X1 = 2, /**< After token authentification, closes the session at end */ + AFB_SESSION_RENEW_X1 = 4, /**< After token authentification, refreshes the token at end */ + AFB_SESSION_CHECK_X1 = 8, /**< Requires token authentification */ + + AFB_SESSION_LOA_GE_X1 = 16, /**< check that the LOA is greater or equal to the given value */ + AFB_SESSION_LOA_LE_X1 = 32, /**< check that the LOA is lesser or equal to the given value */ + AFB_SESSION_LOA_EQ_X1 = 48, /**< check that the LOA is equal to the given value */ + + AFB_SESSION_LOA_SHIFT_X1 = 6, /**< shift for LOA */ + AFB_SESSION_LOA_MASK_X1 = 7, /**< mask for LOA */ + + AFB_SESSION_LOA_0_X1 = 0, /**< value for LOA of 0 */ + AFB_SESSION_LOA_1_X1 = 64, /**< value for LOA of 1 */ + AFB_SESSION_LOA_2_X1 = 128, /**< value for LOA of 2 */ + AFB_SESSION_LOA_3_X1 = 192, /**< value for LOA of 3 */ + AFB_SESSION_LOA_4_X1 = 256, /**< value for LOA of 4 */ + + AFB_SESSION_LOA_LE_0_X1 = AFB_SESSION_LOA_LE_X1 | AFB_SESSION_LOA_0_X1, /**< check LOA <= 0 */ + AFB_SESSION_LOA_LE_1_X1 = AFB_SESSION_LOA_LE_X1 | AFB_SESSION_LOA_1_X1, /**< check LOA <= 1 */ + AFB_SESSION_LOA_LE_2_X1 = AFB_SESSION_LOA_LE_X1 | AFB_SESSION_LOA_2_X1, /**< check LOA <= 2 */ + AFB_SESSION_LOA_LE_3_X1 = AFB_SESSION_LOA_LE_X1 | AFB_SESSION_LOA_3_X1, /**< check LOA <= 3 */ + + AFB_SESSION_LOA_EQ_0_X1 = AFB_SESSION_LOA_EQ_X1 | AFB_SESSION_LOA_0_X1, /**< check LOA == 0 */ + AFB_SESSION_LOA_EQ_1_X1 = AFB_SESSION_LOA_EQ_X1 | AFB_SESSION_LOA_1_X1, /**< check LOA == 1 */ + AFB_SESSION_LOA_EQ_2_X1 = AFB_SESSION_LOA_EQ_X1 | AFB_SESSION_LOA_2_X1, /**< check LOA == 2 */ + AFB_SESSION_LOA_EQ_3_X1 = AFB_SESSION_LOA_EQ_X1 | AFB_SESSION_LOA_3_X1, /**< check LOA == 3 */ + + AFB_SESSION_LOA_GE_0_X1 = AFB_SESSION_LOA_GE_X1 | AFB_SESSION_LOA_0_X1, /**< check LOA >= 0 */ + AFB_SESSION_LOA_GE_1_X1 = AFB_SESSION_LOA_GE_X1 | AFB_SESSION_LOA_1_X1, /**< check LOA >= 1 */ + AFB_SESSION_LOA_GE_2_X1 = AFB_SESSION_LOA_GE_X1 | AFB_SESSION_LOA_2_X1, /**< check LOA >= 2 */ + AFB_SESSION_LOA_GE_3_X1 = AFB_SESSION_LOA_GE_X1 | AFB_SESSION_LOA_3_X1 /**< check LOA >= 3 */ +}; + diff --git a/include/afb/afb-session-x2.h b/include/afb/afb-session-x2.h new file mode 100644 index 00000000..b4a24c77 --- /dev/null +++ b/include/afb/afb-session-x2.h @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2016, 2017, 2018 "IoT.bzh" + * Author: José Bollo <jose.bollo@iot.bzh> + * + * 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 + +/** + * Enum for Session/Token/Assurance middleware of bindings version 2 and 3. + */ +enum afb_session_flags_x2 +{ + AFB_SESSION_LOA_MASK_X2 = 3, /**< mask for LOA */ + + AFB_SESSION_LOA_0_X2 = 0, /**< value for LOA of 0 */ + AFB_SESSION_LOA_1_X2 = 1, /**< value for LOA of 1 */ + AFB_SESSION_LOA_2_X2 = 2, /**< value for LOA of 2 */ + AFB_SESSION_LOA_3_X2 = 3, /**< value for LOA of 3 */ + + AFB_SESSION_CHECK_X2 = 4, /**< Requires token authentification */ + AFB_SESSION_REFRESH_X2 = 8, /**< After token authentification, refreshes the token at end */ + AFB_SESSION_CLOSE_X2 = 16, /**< After token authentification, closes the session at end */ + + AFB_SESSION_NONE_X2 = 0 /**< nothing required */ +}; + diff --git a/include/afb/afb-verbosity.h b/include/afb/afb-verbosity.h index 9f122056..dd34f841 100644 --- a/include/afb/afb-verbosity.h +++ b/include/afb/afb-verbosity.h @@ -23,9 +23,42 @@ #define AFB_VERBOSITY_LEVEL_INFO 3 #define AFB_VERBOSITY_LEVEL_DEBUG 4 -#define _AFB_SYSLOG_LEVEL_ERROR_ 3 -#define _AFB_SYSLOG_LEVEL_WARNING_ 4 -#define _AFB_SYSLOG_LEVEL_NOTICE_ 5 -#define _AFB_SYSLOG_LEVEL_INFO_ 6 -#define _AFB_SYSLOG_LEVEL_DEBUG_ 7 +#define AFB_SYSLOG_LEVEL_EMERGENCY 0 +#define AFB_SYSLOG_LEVEL_ALERT 1 +#define AFB_SYSLOG_LEVEL_CRITICAL 2 +#define AFB_SYSLOG_LEVEL_ERROR 3 +#define AFB_SYSLOG_LEVEL_WARNING 4 +#define AFB_SYSLOG_LEVEL_NOTICE 5 +#define AFB_SYSLOG_LEVEL_INFO 6 +#define AFB_SYSLOG_LEVEL_DEBUG 7 + +#define AFB_VERBOSITY_LEVEL_WANT(verbosity,level) ((verbosity) >= (level)) + +#define AFB_VERBOSITY_LEVEL_WANT_ERROR(x) AFB_VERBOSITY_LEVEL_WANT(x,AFB_VERBOSITY_LEVEL_ERROR) +#define AFB_VERBOSITY_LEVEL_WANT_WARNING(x) AFB_VERBOSITY_LEVEL_WANT(x,AFB_VERBOSITY_LEVEL_WARNING) +#define AFB_VERBOSITY_LEVEL_WANT_NOTICE(x) AFB_VERBOSITY_LEVEL_WANT(x,AFB_VERBOSITY_LEVEL_NOTICE) +#define AFB_VERBOSITY_LEVEL_WANT_INFO(x) AFB_VERBOSITY_LEVEL_WANT(x,AFB_VERBOSITY_LEVEL_INFO) +#define AFB_VERBOSITY_LEVEL_WANT_DEBUG(x) AFB_VERBOSITY_LEVEL_WANT(x,AFB_VERBOSITY_LEVEL_DEBUG) + +#define AFB_SYSLOG_MASK_WANT(verbomask,level) ((verbomask) & (1 << (level))) + +#define AFB_SYSLOG_MASK_WANT_EMERGENCY(x) AFB_SYSLOG_MASK_WANT(x,AFB_SYSLOG_LEVEL_EMERGENCY) +#define AFB_SYSLOG_MASK_WANT_ALERT(x) AFB_SYSLOG_MASK_WANT(x,AFB_SYSLOG_LEVEL_ALERT) +#define AFB_SYSLOG_MASK_WANT_CRITICAL(x) AFB_SYSLOG_MASK_WANT(x,AFB_SYSLOG_LEVEL_CRITICAL) +#define AFB_SYSLOG_MASK_WANT_ERROR(x) AFB_SYSLOG_MASK_WANT(x,AFB_SYSLOG_LEVEL_ERROR) +#define AFB_SYSLOG_MASK_WANT_WARNING(x) AFB_SYSLOG_MASK_WANT(x,AFB_SYSLOG_LEVEL_WARNING) +#define AFB_SYSLOG_MASK_WANT_NOTICE(x) AFB_SYSLOG_MASK_WANT(x,AFB_SYSLOG_LEVEL_NOTICE) +#define AFB_SYSLOG_MASK_WANT_INFO(x) AFB_SYSLOG_MASK_WANT(x,AFB_SYSLOG_LEVEL_INFO) +#define AFB_SYSLOG_MASK_WANT_DEBUG(x) AFB_SYSLOG_MASK_WANT(x,AFB_SYSLOG_LEVEL_DEBUG) + +#define AFB_SYSLOG_LEVEL_FROM_VERBOSITY(x) ((x) + (AFB_SYSLOG_LEVEL_ERROR - AFB_VERBOSITY_LEVEL_ERROR)) +#define AFB_SYSLOG_LEVEL_TO_VERBOSITY(x) ((x) + (AFB_VERBOSITY_LEVEL_ERROR - AFB_SYSLOG_LEVEL_ERROR)) + +static inline int _afb_verbomask_to_upper_level_(int verbomask) +{ + int result = 0; + while ((verbomask >>= 1) && result < AFB_SYSLOG_LEVEL_DEBUG) + result++; + return result; +} |