The documentation is improved to reflect the new version.
Tune the options
Change-Id: I894c3db3bc0c10e89db66a9a51a9ad049bb8c0c4
Signed-off-by: José Bollo <jose.bollo@iot.bzh>
_book/
*.kdev4
nbproject/*
-docs/binding
-docs/binder
+doxygen-output
json_object_put(object);
}
-static void callcb (void *prequest, int status, json_object *object, afb_api_t api)
+static void callcb (void *prequest, json_object *object, const char *error, const char *info, afb_api_t api)
{
afb_req_t request = prequest;
- if (status < 0)
- afb_req_fail(request, "failed", json_object_to_json_string(object));
- else
- afb_req_success(request, json_object_get(object), NULL);
+ afb_req_reply(request, json_object_get(object), error, info);
afb_req_unref(request);
}
const char *args = afb_req_value(request, "args");
json_object *object = api && verb && args ? json_tokener_parse(args) : NULL;
- if (object == NULL)
- afb_req_fail(request, "failed", "bad arguments");
- else
- afb_service_call(api, verb, object, callcb, afb_req_addref(request));
+ afb_service_call(api, verb, object, callcb, afb_req_addref(request));
}
static void callsync (afb_req_t request)
{
- int rc;
const char *api = afb_req_value(request, "api");
const char *verb = afb_req_value(request, "verb");
const char *args = afb_req_value(request, "args");
- json_object *result, *object = api && verb && args ? json_tokener_parse(args) : NULL;
+ json_object *object = api && verb && args ? json_tokener_parse(args) : NULL;
+ json_object *result;
+ char *error, *info;
- if (object == NULL)
- afb_req_fail(request, "failed", "bad arguments");
- else {
- rc = afb_service_call_sync(api, verb, object, &result);
- if (rc >= 0)
- afb_req_success(request, result, NULL);
- else {
- afb_req_fail(request, "failed", json_object_to_json_string(result));
- json_object_put(result);
- }
- }
+ afb_service_call_sync(api, verb, object, &result, &error, &info);
+ afb_req_reply(request, result, error, info);
+ free(error);
+ free(info);
}
static void verbose (afb_req_t request)
static void callcb (void *prequest, json_object *object, const char *error, const char *info, afb_api_t api)
{
- afb_req_t request = afb_req_unstore(prequest);
+ afb_req_t request = prequest;
afb_req_reply(request, json_object_get(object), error, info);
afb_req_unref(request);
}
const char *args = afb_req_value(request, "args");
json_object *object = api && verb && args ? json_tokener_parse(args) : NULL;
- if (object == NULL)
- afb_req_fail(request, "failed", "bad arguments");
- else
- afb_api_call(request->api, api, verb, object, callcb, afb_req_store(request));
+ afb_service_call(api, verb, object, callcb, afb_req_addref(request));
}
static void callsync (afb_req_t request)
{
- int rc;
const char *api = afb_req_value(request, "api");
const char *verb = afb_req_value(request, "verb");
const char *args = afb_req_value(request, "args");
- json_object *result, *object = api && verb && args ? json_tokener_parse(args) : NULL;
+ json_object *object = api && verb && args ? json_tokener_parse(args) : NULL;
+ json_object *result;
+ char *error, *info;
- if (object == NULL)
- afb_req_fail(request, "failed", "bad arguments");
- else {
- rc = afb_service_call_sync(api, verb, object, &result);
- if (rc >= 0)
- afb_req_success(request, result, NULL);
- else {
- afb_req_fail(request, "failed", json_object_to_json_string(result));
- json_object_put(result);
- }
- }
+ afb_service_call_sync(api, verb, object, &result, &error, &info);
+ afb_req_reply(request, result, error, info);
+ free(error);
+ free(info);
}
static void verbose (afb_req_t request)
afb_req_success_f(request, json_object_new_int(uid), "uid is %d", uid);
}
-static int preinit()
+static int preinit(afb_api_t api)
{
AFB_NOTICE("hello binding comes to live");
return 0;
}
-static int init()
+static int init(afb_api_t api)
{
AFB_NOTICE("hello binding starting");
return 0;
{ .verb=NULL}
};
+#if !defined(APINAME)
+#define APINAME "hello3"
+#endif
+
const struct afb_binding_v3 afbBindingV3 = {
- .api = "hello3",
+ .api = APINAME,
.specification = NULL,
.verbs = verbs,
.preinit = preinit,
* [Binder daemon vocabulary](afb-daemon-vocabulary.md)
* [How to write a binding ?](afb-binding-writing.md)
* [Binding references](afb-binding-references.md)
+ * [Types and globals](reference-v3/types-and-globals.md)
+ * [Macros for logging](reference-v3/macro-log.md)
+ * [Functions of class afb_api](reference-v3/func-api.md)
+ * [Functions of class afb_req](reference-v3/func-req.md)
+ * [Functions of class afb_event](reference-v3/func-event.md)
+ * [Functions of class afb_daemon](reference-v3/func-daemon.md)
+ * [Functions of class afb_service](reference-v3/func-service.md)
* [Binder events guide](afb-events-guide.md)
* [Binder Application writing guide](afb-application-writing.md)
* [Annexes](annexes.md)
* [Migration to binding v3](afb-migration-to-binding-v3.md)
+ * [WebSocket protocol x-afb-ws-json1](protocol-x-afb-ws-json1.md)
* [Installing the binder on a desktop](afb-desktop-package.md)
* [Options of afb-daemon](afb-daemon-options.md)
* [Debugging binder and bindings](afb-daemon-debugging.md)
- * [(LEGACY) guide to migrate bindings from v1 to v2](afb-migration-v1-to-v2.md)
+ * [LEGACY Guide to migrate bindings from v1 to v2](legacy/afb-migration-v1-to-v2.md)
+ * [LEGACY Binding V2 references](legacy/afb-binding-v2-references.md)
* [Document revisions](REVISIONS.md)
# Binding Reference
-## Structure for declaring binding
-### afb_binding_t
-
-The main structure, of type **afb_binding_t**, for describing the binding
-must be exported under the name **afbBindingExport**.
-
-This structure is defined as below.
-
-```C
-typedef struct afb_binding_v3 afb_binding_t;
-```
-
-Where:
-
-```C
-/**
- * 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;
-};
-```
-
-### struct afb_verb_t
-
-Each verb is described with a structure of type **afb_verb_t**
-defined below:
-
-```C
-typedef struct afb_verb_v3 afb_verb_t;
-```
-
-```C
-/**
- * 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)(afb_req_t_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;
-};
-```
-
-The **session** flags is one of the constant defined below:
-
-- AFB_SESSION_NONE : no flag, synonym to 0
-- AFB_SESSION_LOA_0 : Requires the LOA to be 0 or more, synonym to 0 or AFB_SESSION_NONE
-- AFB_SESSION_LOA_1 : Requires the LOA to be 1 or more
-- AFB_SESSION_LOA_2 : Requires the LOA to be 2 or more
-- AFB_SESSION_LOA_3 : Requires the LOA to be 3 or more
-- AFB_SESSION_CHECK : Requires the token to be set and valid
-- AFB_SESSION_REFRESH : Implies a token refresh
-- AFB_SESSION_CLOSE : Implies closing the session after request processed
-
-The LOA (Level Of Assurance) is set, by binding api, using the function **afb_req_session_set_LOA**.
-
-The session can be closed, by binding api, using the function **afb_req_session_close**.
-
-### afb_auth_t and afb_auth_type_t
-
-The structure **afb_auth_t** is used within verb description to
-set security requirements.
-The interpretation of the structure depends on the value of the field **type**.
-
-```C
-typedef struct afb_auth afb_auth_t;
-
-/**
- * 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;
-};
-
-```
-
-The possible values for **type** is defined here:
-
-```C
-typedef enum afb_auth_type afb_auth_type_t;
-
-/**
- * Enumeration for authority (Session/Token/Assurance) definitions.
- *
- * @see afb_auth
- */
-enum afb_auth_type
-{
- /** 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
-};
-```
-
-Example:
-
-```C
-static const afb_auth_t myauth[] = {
- { .type = afb_auth_Permission, .text = "urn:AGL:permission:me:public:set" },
- { .type = afb_auth_Permission, .text = "urn:AGL:permission:me:public:get" },
- { .type = afb_auth_Or, .first = &myauth[1], .next = &myauth[0] }
-};
-```
-
-## Functions of class afb_daemon
-
-The 3 following functions are linked to libsystemd.
-They allow use of **sd_event** features and access
-to **sd_bus** features.
-
-```C
-/*
- * Retrieves the common systemd's event loop of AFB
- *
- */
-struct sd_event *afb_daemon_get_event_loop();
-
-/*
- * Retrieves the common systemd's user/session d-bus of AFB if active
- */
-struct sd_bus *afb_daemon_get_user_bus();
-
-/*
- * Retrieves the common systemd's system d-bus of AFB if active or NULL
- */
-struct sd_bus *afb_daemon_get_system_bus();
-```
-
-The 2 following functions are linked to event management.
-Broadcasting an event send it to any possible listener.
-
-```C
-/*
- * 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.
- */
-int afb_daemon_broadcast_event(const char *name, struct json_object *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.
- */
-afb_event_t afb_daemon_make_event(const char *name);
-```
-
-The following function is used by logging macros and should normally
-not be used.
-Instead, you should use the macros:
-
-- **AFB\_ERROR**
-- **AFB\_WARNING**
-- **AFB\_NOTICE**
-- **AFB\_INFO**
-- **AFB\_DEBUG**
-
-```C
-/*
- * 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
- */
-void afb_daemon_verbose(int level, const char *file, int line, const char * func, const char *fmt, ...);
-```
-
-The 2 following functions MUST be used to access data of the bindings.
-
-```C
-/*
- * Get the root directory file descriptor. This file descriptor can
- * be used with functions 'openat', 'fstatat', ...
- */
-int afb_daemon_rootdir_get_fd();
-
-/*
- * 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.
- */
-int afb_daemon_rootdir_open_locale(const char *filename, int flags, const char *locale);
-```
-
-The following function is used to queue jobs.
-
-```C
-/*
- * 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 re-executed but with
- * signum being the signal number (SIGALRM when timeout expired).
- *
- * Returns 0 in case of success or -1 in case of error.
- */
-int afb_daemon_queue_job(void (*callback)(int signum, void *arg), void *argument, void *group, int timeout)
-```
-
-The following function must be used when a binding depends on other
-bindings at its initialization.
-
-```C
-/*
- * 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.
- */
-int afb_daemon_require_api(const char *name, int initialized)
-```
-
-This function allows to give a different name to the binding.
-It can be called during pre-init.
-
-```C
-/*
- * 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.
- */
-int afb_daemon_rename_api(const char *name);
-```
-
-## Functions of class afb_service
-
-The following functions allow services to call verbs of other
-bindings for themselves.
-
-```C
-/**
- * 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 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'
- */
-void afb_service_call(
- const char *api,
- const char *verb,
- struct json_object *args,
- void (*callback)(void*closure, int status, struct json_object *result),
- void *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 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'
- */
-int afb_service_call_sync(
- const char *api,
- const char *verb,
- struct json_object *args,
- struct json_object **result);
-```
-
-## Functions of class afb_event
-
-This function checks whether the event is valid.
-It must be used when creating events.
-
-```C
-/*
- * Checks wether the 'event' is valid or not.
- *
- * Returns 0 if not valid or 1 if valid.
- */
-int afb_event_is_valid(afb_event_t event);
-```
-
-The two following functions are used to broadcast or push
-event with its data.
-
-```C
-/*
- * Broadcasts widely the '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.
- *
- * Returns the count of clients that received the event.
- */
-int afb_event_broadcast(afb_event_t event, struct json_object *object);
-
-/*
- * Pushes the '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.
- *
- * Returns the count of clients that received the event.
- */
-int afb_event_push(afb_event_t event, struct json_object *object);
-```
-
-The following function remove one reference to the event.
-
-```C
-/*
- * Decrease the reference count of the event.
- * After calling this function, the event
- * MUST NOT BE USED ANYMORE.
- */
-void afb_event_unref(afb_event_t event);
-```
-
-The following function add one reference to the event.
-
-```C
-/*
- * Decrease the reference count of the event.
- * After calling this function, the event
- * MUST NOT BE USED ANYMORE.
- */
-void afb_event_unref(afb_event_t event);
-```
-
-This function allows to retrieve the exact name of the event.
-
-```C
-/*
- * Gets the name associated to the 'event'.
- */
-const char *afb_event_name(afb_event_t event);
-```
-
-## Functions of class afb_req
-
-This function checks the validity of the **req**.
-
-```C
-/*
- * Checks wether the request 'req' is valid or not.
- *
- * Returns 0 if not valid or 1 if valid.
- */
-int afb_req_is_valid(afb_req_t req);
-```
-
-The following functions retrieves parameters of the request.
-
-```C
-/*
- * 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.
- */
-afb_arg_t afb_req_get(afb_req_t req, const char *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_get(req, name).value
- */
-const char *afb_req_value(afb_req_t req, const char *name);
-
-/*
- * 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
- */
-const char *afb_req_path(afb_req_t req, const char *name);
-
-/*
- * Gets from the request 'req' the json object hashing the arguments.
- * The returned object must not be released using 'json_object_put'.
- */
-struct json_object *afb_req_json(afb_req_t req);
-```
-
-The following functions emit the reply to the request.
-
-```C
-/*
- * Sends a reply of kind success to the request 'req'.
- * 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.
- */
-void afb_req_success(afb_req_t req, struct json_object *obj, const char *info);
-
-/*
- * Same as 'afb_req_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.
- */
-void afb_req_success_f(afb_req_t req, struct json_object *obj, const char *info, ...);
-
-/*
- * Same as 'afb_req_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.
- */
-void afb_req_success_v(afb_req_t req, struct json_object *obj, const char *info, va_list args);
-
-/*
- * Sends a reply of kind failure to the request 'req'.
- * The status of the reply is set to 'status' and an
- * informational comment 'info' (can also be NULL) can be added.
- *
- * Note that calling afb_req_fail("success", info) is equivalent
- * to call afb_req_success(NULL, info). Thus even if possible it
- * is strongly recommended to NEVER use "success" for status.
- */
-void afb_req_fail(afb_req_t req, const char *status, const char *info);
-
-/*
- * Same as 'afb_req_fail' but the 'info' is a formatting
- * string followed by arguments.
- */
-void afb_req_fail_f(afb_req_t req, const char *status, const char *info, ...);
-
-/*
- * Same as 'afb_req_fail_f' but the arguments to the format 'info'
- * are given as a variable argument list instance.
- */
-void afb_req_fail_v(afb_req_t req, const char *status, const char *info, va_list args);
-```
-
-The following functions handle the session data.
-
-```C
-/*
- * Gets the pointer stored by the binding for the session of 'req'.
- * When the binding has not yet recorded a pointer, NULL is returned.
- */
-void *afb_req_context_get(afb_req_t req);
-
-/*
- * 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.
- */
-void afb_req_context_set(afb_req_t req, void *context, void (*free_context)(void*));
-
-/*
- * 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'.
- */
-void *afb_req_context(afb_req_t req, void *(*create_context)(), void (*free_context)(void*));
-
-/*
- * 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)
- */
-void afb_req_context_clear(afb_req_t req);
-
-/*
- * Closes the session associated with 'req'
- * and delete all associated contexts.
- */
-void afb_req_session_close(afb_req_t req);
-
-/*
- * 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.
- */
-int afb_req_session_set_LOA(afb_req_t req, unsigned level);
-```
-
-The 4 following functions must be used for asynchronous handling requests.
-
-```C
-/*
- * 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.
- */
-void afb_req_addref(afb_req_t req);
-
-/*
- * Substracts one to the count of references of 'req'.
- * This function MUST be called by asynchronous implementations
- * of verbs after sending the asynchronous reply.
- */
-void afb_req_unref(afb_req_t req);
-
-/*
- * Stores 'req' on heap for asynchronous 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).
- */
-struct afb_stored_req *afb_req_store(afb_req_t req);
-
-/*
- * 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.
- */
-afb_req_t afb_req_unstore(struct afb_stored_req *sreq);
-```
-
-The two following functions are used to associate client with events
-(subscription).
-
-```C
-/*
- * 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.
- */
-int afb_req_subscribe(afb_req_t req, afb_event_t 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.
- */
-int afb_req_unsubscribe(afb_req_t req, afb_event_t event);
-```
-
-The following functions must be used to make request in the name of the
-client (with its permissions).
-
-```C
-/*
- * 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.
- *
- * See also:
- * - 'afb_req_subcall_req' that is convenient to keep request alive automatically.
- * - 'afb_req_subcall_sync' the synchronous version
- */
-void afb_req_subcall(
- afb_req_t req,
- const char *api,
- const char *verb,
- struct json_object *args,
- void (*callback)(void *closure, int status, struct json_object *result),
- void *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'.
- * On completion, the function 'callback' is invoked with the
- * original request 'req', 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_req_subcall' that doesn't keep request alive automatically.
- * - 'afb_req_subcall_sync' the synchronous version
- */
-static inline void afb_req_subcall_req(afb_req_t req, const char *api, const char *verb, struct json_object *args, void (*callback)(void *closure, int iserror, struct json_object *result, afb_req_t req), void *closure)
-{
- req.itf->subcall_req(req.closure, 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 '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.
- *
- * See also:
- * - 'afb_req_subcall_req' that is convenient to keep request alive automatically.
- * - 'afb_req_subcall' that doesn't keep request alive automatically.
- */
-int afb_req_subcall_sync(
- afb_req_t req,
- const char *api,
- const char *verb,
- struct json_object *args,
- struct json_object **result);
-```
-
-The following function is used by logging macros and should normally
-not be used.
-Instead, you should use the macros:
-
-- **AFB_REQ_ERROR**
-- **AFB_REQ_WARNING**
-- **AFB_REQ_NOTICE**
-- **AFB_REQ_INFO**
-- **AFB_REQ_DEBUG**
-
-```C
-/*
- * 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
- */
-void afb_req_verbose(afb_req_t req, int level, const char *file, int line, const char * func, const char *fmt, ...);
-```
-
-The functions below allow a binding involved in the platform security
-to explicitely check a permission of a client or to get the calling
-application identity.
-
-```C
-/*
- * Check whether the 'permission' is granted or not to the client
- * identified by 'req'.
- *
- * Returns 1 if the permission is granted or 0 otherwise.
- */
-int afb_req_has_permission(afb_req_t req, const char *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
- */
-char *afb_req_get_application_id(afb_req_t req);
-
-/*
- * Get the user identifier (UID) of the client application for the
- * request 'req'.
- *
- * Returns -1 when the application can not be identified.
- */
-int afb_req_get_uid(afb_req_t req);
-```
-
-## Logging macros
-
-The following macros must be used for logging:
-
-```C
-AFB_ERROR(fmt,...)
-AFB_WARNING(fmt,...)
-AFB_NOTICE(fmt,...)
-AFB_INFO(fmt,...)
-AFB_DEBUG(fmt,...)
-```
-
-The following macros can be used for logging in the context
-of a request **req** of type **afb_req**:
-
-```C
-AFB_REQ_ERROR(req,fmt,...)
-AFB_REQ_WARNING(req,fmt,...)
-AFB_REQ_NOTICE(req,fmt,...)
-AFB_REQ_INFO(req,fmt,...)
-AFB_REQ_DEBUG(req,fmt,...)
-```
-
-By default, the logging macros add file, line and function
-indication.
+ * [Structures and types](reference-v3/types-and-globals.md.md)
+ * [Functions of api](reference-v3/func-api.md)
+ * [Functions of req](reference-v3/func-req.md)
+ * [Functions of event](reference-v3/func-event.md)
+ * [Functions of daemon](reference-v3/func-daemon.md)
+ * [Functions of service](reference-v3/func-service.md)
+ * [Macros for logging](reference-v3/macro-log.md)
The launch options for binder **afb-daemon** are:
- --help
+```
+ -v, --verbose Verbose Mode, repeat to increase verbosity
+ -q, --quiet Quiet Mode, repeat to decrease verbosity
+ -l, --log=xxxx Tune log level
+ --foreground Get all in foreground mode
+ --daemon Get all in background mode
+ -n, --name=xxxx Set the visible name
+ -p, --port=xxxx HTTP listening TCP port [default 1234]
+ --roothttp=xxxx HTTP Root Directory [default no root http (files not served but apis still available)]
+ --rootbase=xxxx Angular Base Root URL [default /opa]
+ --rootapi=xxxx HTML Root API URL [default /api]
+ --alias=xxxx Multiple url map outside of rootdir [eg: --alias=/icons:/usr/share/icons]
+ --apitimeout=xxxx Binding API timeout in seconds [default 20]
+ --cntxtimeout=xxxx Client Session Context Timeout [default 32000000]
+ --cache-eol=xxxx Client cache end of live [default 100000]
+ -w, --workdir=xxxx Set the working directory [default: $PWD or current working directory]
+ -u, --uploaddir=xxxx Directory for uploading files [default: workdir]
+ --rootdir=xxxx Root Directory of the application [default: workdir]
+ --ldpaths=xxxx Load bindings from dir1:dir2:... [default = /opt/jobol/lib64/afb]
+ -b, --binding=xxxx Load the binding of path
+ --weak-ldpaths=xxxx Same as --ldpaths but ignore errors
+ --no-ldpaths Discard default ldpaths loading
+ -t, --token=xxxx Initial Secret [default=random, use --token= to allow any token]
+ -r, --random-token Enforce a random token
+ -V, --version Display version and copyright
+ -h, --help Display this help
+ --ws-client=xxxx Bind to an afb service through websocket
+ --ws-server=xxxx Provide an afb service through websockets
+ -A, --auto-api=xxxx Automatic load of api of the given directory
+ --session-max=xxxx Max count of session simultaneously [default 200]
+ --tracereq=xxxx Log the requests: no, common, extra, all
+ --traceditf=xxxx Log the daemons: no, common, all
+ --tracesvc=xxxx Log the services: no, all
+ --traceevt=xxxx Log the events: no, common, extra, all
+ --traceses=xxxx Log the sessions: no, all
+ --traceapi=xxxx Log the apis: no, common, api, event, all
+ -c, --call=xxxx call at start format of val: API/VERB:json-args
+ --no-httpd Forbid HTTP service
+ -e, --exec Execute the remaining arguments
+ -M, --monitoring Enable HTTP monitoring at <ROOT>/monitoring/
+```
- Prints help with available options
+## help
- --version
+Prints help with available options
- Display version and copyright
+## version
- --verbose
+Display version and copyright
- Increases the verbosity, can be repeated
+## verbose
- --quiet
+Increases the verbosity, can be repeated
- Decreases the verbosity, can be repeated
+## quiet
- --port=xxxx
+Decreases the verbosity, can be repeated
- HTTP listening TCP port [default 1234]
+## log=xxxx
- --workdir=xxxx
+Tune the log level mask. The levels are:
- Directory where the daemon must run [default: $PWD if defined
- or the current working directory]
+ - error
+ - warning
+ - notice
+ - info
+ - debug
- --uploaddir=xxxx
+The level can be set using + or -.
- Directory where uploaded files are temporarily stored [default: workdir]
+| Examples | descritpion
+|-----------------|-------------------
+| error,warning | selects only the levels error and warning
+| +debug | adds level debug to the current verbosity
+| -warning | remove the level warning from the current verbosity
+| +warning-debug,info | Adds error and remove errors and warnings
- --rootdir=xxxx
+## port=xxxx
- Root directory of the application to serve [default: workdir]
+HTTP listening TCP port [default 1234]
- --roothttp=xxxx
+## workdir=xxxx
- Directory of HTTP served files. If not set, files are not served
- but apis are still accessible.
+Directory where the daemon must run [default: $PWD if defined
+or the current working directory]
- --rootbase=xxxx
+## uploaddir=xxxx
- Angular Base Root URL [default /opa]
+Directory where uploaded files are temporarily stored [default: workdir]
- This is used for any application of kind OPA (one page application).
- When set, any missing document whose url has the form /opa/zzz
- is translated to /opa/#!zzz
+## rootdir=xxxx
- --rootapi=xxxx
+Root directory of the application to serve [default: workdir]
- HTML Root API URL [default /api]
+## roothttp=xxxx
- The bindings are available within that url.
+Directory of HTTP served files. If not set, files are not served
+but apis are still accessible.
- --alias=xxxx
+## rootbase=xxxx
- Maps a path located anywhere in the file system to the
- a subdirectory. The syntax for mapping a PATH to the
- subdirectory NAME is: --alias=/NAME:PATH.
+Angular Base Root URL [default /opa]
- Example: --alias=/icons:/usr/share/icons maps the
- content of /usr/share/icons within the subpath /icons.
+This is used for any application of kind OPA (one page application).
+When set, any missing document whose url has the form /opa/zzz
+is translated to /opa/#!zzz
- This option can be repeated.
+## rootapi=xxxx
- --apitimeout=xxxx
+HTML Root API URL [default /api]
- binding API timeout in seconds [default 20]
+The bindings are available within that url.
- Defines how many seconds maximum a method is allowed to run.
- 0 means no limit.
+## alias=xxxx
- --cntxtimeout=xxxx
+Maps a path located anywhere in the file system to the
+a subdirectory. The syntax for mapping a PATH to the
+subdirectory NAME is: --alias=/NAME:PATH.
- Client Session Timeout in seconds [default 3600]
+Example: --alias=/icons:/usr/share/icons maps the
+content of /usr/share/icons within the subpath /icons.
- --cache-eol=xxxx
+This option can be repeated.
- Client cache end of live [default 100000 that is 27,7 hours]
+## apitimeout=xxxx
- --session-max=xxxx
+binding API timeout in seconds [default 20]
- Maximum count of simultaneous sessions [default 10]
+Defines how many seconds maximum a method is allowed to run.
+0 means no limit.
- --ldpaths=xxxx
+## cntxtimeout=xxxx
- Load bindings from given paths separated by colons
- as for dir1:dir2:binding1.so:... [default = $libdir/afb]
+Client Session Timeout in seconds [default 32000000 that is 1 year]
- You can mix path to directories and to bindings.
- The sub-directories of the given directories are searched
- recursively.
+## cache-eol=xxxx
- The bindings are the files terminated by '.so' (the extension
- so denotes shared object) that contain the public entry symbol.
+Client cache end of live [default 100000 that is 27,7 hours]
- --binding=xxxx
+## session-max=xxxx
- Load the binding of given path.
+Maximum count of simultaneous sessions [default 200]
- --token=xxxx
+## ldpaths=xxxx
- Initial Secret token to authenticate.
+Load bindings from given paths separated by colons
+as for dir1:dir2:binding1.so:... [default = $libdir/afb]
- If not set, no client can authenticate.
+You can mix path to directories and to bindings.
+The sub-directories of the given directories are searched
+recursively.
- If set to the empty string, then any initial token is accepted.
+The bindings are the files terminated by '.so' (the extension
+so denotes shared object) that contain the public entry symbol.
- --random-token
+## weak-ldpaths=xxxx
- Generate a random starting token. See option --exec.
+Same as --ldpaths but instead of stopping on error, ignore errors and continue.
- --mode=xxxx
+## binding=xxxx
- Set the mode: either local, remote or global.
+Load the binding of given path.
- The mode indicate if the application is run locally on the host
- or remotely through network.
+## token=xxxx
- --dbus-client=xxxx
+Initial Secret token to authenticate.
- Transparent binding to a binder afb-daemon service through dbus.
+If not set, no client can authenticate.
- It creates an API of name xxxx that is implemented remotely
- and queried via DBUS.
+If set to the empty string, then any initial token is accepted.
- --dbus-server=xxxx
+## random-token
- Provides a binder afb-daemon service through dbus.
+Generate a random starting token. See option --exec.
- The name xxxx must be the name of an API defined by a binding.
- This API is exported through DBUS.
+## ws-client=xxxx
- --ws-client=xxxx
+Transparent binding to a binder afb-daemon service through a WebSocket.
- Transparent binding to a binder afb-daemon service through a WebSocket.
+The value of xxxx is either a unix naming socket, of the form "unix:path/api",
+or an internet socket, of the form "host:port/api".
- The value of xxxx is either a unix naming socket, of the form "unix:path/api",
- or an internet socket, of the form "host:port/api".
+## ws-server=xxxx
- --ws-server=xxxx
+Provides a binder afb-daemon service through WebSocket.
- Provides a binder afb-daemon service through WebSocket.
+The value of xxxx is either a unix naming socket, of the form "unix:path/api",
+or an internet socket, of the form "host:port/api".
- The value of xxxx is either a unix naming socket, of the form "unix:path/api",
- or an internet socket, of the form "host:port/api".
+## foreground
- --foreground
+Get all in foreground mode (default)
- Get all in foreground mode (default)
+## daemon
- --daemon
+Get all in background mode
- Get all in background mode
+## no-httpd
- --no-httpd
+Forbids HTTP serve
- Forbids HTTP serve
+## exec
- --exec
+Must be the last option for afb-daemon. The remaining
+arguments define a command that afb-daemon will launch.
+The sequences @p, @t and @@ of the arguments are replaced
+with the port, the token and @.
- Must be the last option for afb-daemon. The remaining
- arguments define a command that afb-daemon will launch.
- The sequences @p, @t and @@ of the arguments are replaced
- with the port, the token and @.
+## tracereq=xxxx
- --tracereq=xxxx
+Trace the processing of requests in the log file.
- Trace the processing of requests in the log file.
+Valid values are 'no' (default), 'common', 'extra' or 'all'.
- Valid values are 'no' (default), 'common', 'extra' or 'all'.
+## traceapi=xxxx
- --traceditf=xxxx
+Trace the accesses to functions of class api.
- Trace the accesses to functions of class daemon.
+Valid values are 'no' (default), 'common', 'api', 'event' or 'all'.
- Valid values are 'no' (default), 'common', 'extra' or 'all'.
+## traceevt=xxxx
- --tracesvc=xxxx
+Trace the accesses to functions of class event.
- Trace the accesses to functions of class service.
+Valid values are 'no' (default), 'common', 'extra' or 'all'.
- Valid values are 'no' (default) or 'all'.
+## call=xxx
- --traceevt=xxxx
+Call a binding at start (can be be repeated).
+The values are given in the form API/VERB:json-args.
- Trace the accesses to functions of class event.
+Example: --call 'monitor/set:{"verbosity":{"api":"debug"}}'
- Valid values are 'no' (default), 'common', 'extra' or 'all'.
+## monitoring
- --call=xxx
+Enable HTTP monitoring at <ROOT>/monitoring/
- Call a binding at start (can be be repeated).
- The values are given in the form API/VERB:json-args.
+## name=xxxx
+
+Set the visible name
+
+## auto-api=xxxx
+
+Automatic activation of api of the given directory when the api is missing.
- Example: --call 'monitor/set:{"verbosity":{"api":"debug"}}'
## Binding
A shared library object intended to add a functionality to an afb-daemon
-instance.
+instance.
It implements an API and may provide a service.
Binding made for services can have specific entry point called after
- HTTP
- WebSocket
-- DBUS
- ...
and served by ***afb-daemon***
## Service
-Service are made of bindings running by their side on their binder.
-It can serve many client.
-Each one attached to one session.
+Service are made of bindings running on a binder
+The binder is in charge of connecting services and applications.
+A service can serve many clients.
-The framework establishes connection between the services and the clients.
+The framework establishes connection between the services and the clients.
Using sockets currently but other protocols are considered.
+The term of service is tightly bound to the notion of API.
+
## Session
A session is meant to be the unique instance context of a client,
which identify that instance across requests.
-Each session has an identifier.
+Each session has an identifier.
Session identifier generated by afb-daemon are UUIDs.
+A client can present its own session id.
-Internally, afb-daemon offers a mechanism to attach data to sessions.
-When the session is closed or disappears, the data attached to that session
+Internally, afb-daemon offers a mechanism to attach data to sessions.
+When a session is closed or disappears, data attached to that session
are freed.
## Token
# Guide for developing with events
Signaling agents are services that send events to any clients that
-subscribed for receiving it.
+subscribed for receiving it.
The sent events carry any data.
To have a good understanding of how to:
### Subscribing and unsubscribing
-- Subscribing is the action that makes a client able to receive
+- Subscribing is the action that makes a client able to receive
data from a signaling agent.
Subscription must :
1. ask the framework to establish the subscription to the event for the request.
1. optionally give indications about the event in the reply to the client.
-The first two steps are not involving the framework.
-They are linked to the business logic of the binding.
-The request can be any description of the requested data
-and the computing stream can be of any nature,
+The first two steps are not involving the framework.
+They are linked to the business logic of the binding.
+The request can be any description of the requested data
+and the computing stream can be of any nature,
this is specific to the binding.
As said before, the framework uses and integrates **libsystemd** and its event
-loop.
+loop.
Within the framework, **libsystemd** is the standard API/library for
bindings expecting to setup and handle I/O, timer or signal events.
Steps 3 and 4 are bound to the framework.
The agent must create an object for handling the propagation of produced
-data to its clients.
-That object is called “event” in the framework.
+data to its clients.
+That object is called “event” in the framework.
An event has a name that allows clients to distinguish it from other
events.
-Events are created using the ***afb\_daemon\_make\_event*** function
-that takes the name of the event.
+Events are created using the ***afb\_api\_make\_event*** function
+that takes the api that creates the event and the name of the event.
Example:
```C
- event = afb_daemon_make_event(name);
+ event = afb_api_make_event(api, name);
```
Once created, the event can be used either to push data to its
subscribers or to broadcast data to any listener.
The event must be used to establish the subscription for the requesting
-client.
+client.
This is done using the ***afb\_req\_subscribe*** function
that takes the current request object and event and associates them
-together.
+together.
Example:
```C
```
When successful, this function make the connection between the event and
-the client that emitted the request.
-The client becomes a subscriber of the event until it unsubscribes or disconnects.
+the client that emitted the request.
+The client becomes a subscriber of the event until it unsubscribes or disconnects.
The ***afb\_req\_subscribe*** function will fail:
- if the client connection is weak.
- client B expects the speed in mph twice a second.
In that case, there are two different events because it is not the same
-unit and it is not the same frequency.
-Having two different events allows to associate clients to the correct event.
-But this doesn't tell any word about the name of these events.
+unit and it is not the same frequency.
+Having two different events allows to associate clients to the correct event.
+But this doesn't tell any word about the name of these events.
The designer of the signaling agent has two options for naming:
-1. names can be the same (“speed” for example) with sent data
+1. names can be the same (“speed” for example) with sent data
self describing itself or having a specific tag (requiring from
clients awareness about requesting both kinds of speed isn't safe).
1. names of the event include the variations (by example:
In both cases, the signaling agent might have to send the name of the
event and/or an associated tag to its client in the reply of the
-subscription.
+subscription.
This is part of the step 5 above.
The framework only uses the event (not its name) for:
When the requested data is already generated and the event used for
pushing it already exists, the signaling agent must not instantiate a
new processing chain and must not create a new event object for pushing
-data.
+data.
The signaling agent must reuse the existing chain and event.
-Unsubscribing is made by the signaling agent on a request of its client.
+Unsubscribing is made by the signaling agent on a request of its client.
The ***afb\_req\_unsubscribe*** function tells the framework to
-remove the requesting client from the event's list of subscribers.
+remove the requesting client from the event's list of subscribers.
Example:
```C
Subscription count does not matter to the framework:
-- Subscribing the same client several times has the same effect that subscribing only one time.
+- Subscribing the same client several times has the same effect that subscribing only one time.
Thus, when unsubscribing is invoked, it becomes immediately effective.
- Within the AGL framework, a signaling agent is a binding that has an API prefix.
-This prefix is meant to be unique and to identify the binding API.
+This prefix is meant to be unique and to identify the binding API.
The names of the events that this signaling agent creates are
automatically prefixed by the framework, using the API prefix of the
binding.
- This of the responsibility of the designer of the signaling agent to establish the processing chain for generating events.
-In many cases, this can be achieved using I/O or timer or signal events inserted in the main loop.
+In many cases, this can be achieved using I/O or timer or signal events inserted in the main loop.
For this case, the AGL framework uses **libsystemd** and
provide a way to integrates to the main loop of this library using
-afb\_daemon\_get\_event\_loop.
+afb\_api\_get\_event\_loop.
Example:
```C
- sdev = afb_daemon_get_event_loop();
+ sdev = afb_api_get_event_loop(api);
rc = sd_event_add_io(sdev, &source, fd, EPOLLIN, myfunction, NULL);
```
-In some other cases, the events are coming from D-Bus.
-In that case, the framework also uses **libsystemd** internally to access D-Bus.
+In some other cases, the events are coming from D-Bus.
+In that case, the framework also uses **libsystemd** internally to access D-Bus.
It provides two methods to get the available D-Bus objects, already existing and
-bound to the main **libsystemd** event loop.
-Use either ***afb\_daemon\_get\_system\_bus*** or
-***afb\_daemon\_get\_user\_bus*** to get the required instance.
+bound to the main **libsystemd** event loop.
+Use either ***afb\_api\_get\_system\_bus*** or
+***afb\_api\_get\_user\_bus*** to get the required instance.
Then use functions of **libsystemd** to handle D-Bus.
In some rare cases, the generation of the data requires to start a new
thread.
When a data is generated and ready to be pushed, the signaling agent
-should call the function ***afb\_event\_push***.
+should call the function ***afb\_event\_push***.
Example:
```C
rc = afb_event_push(event, JSON);
if (rc == 0) {
stop_generating(event);
- afb_event_drop(event);
+ afb_event_unref(event);
}
```
-The function ***afb\_event\_push*** pushes json data to all the subscribers.
-It then returns the count of subscribers.
-When the count is zero, there is no subscriber listening for the event.
-The example above shows that in that case, the signaling agent stops to generate data for the event and delete the event using afb\_event\_drop.
-This is one possible option.
-Other valuable options are:
+The function ***afb\_event\_push*** pushes json data to all the subscribers.
+It then returns the count of subscribers.
+When the count is zero, there is no subscriber listening for the event.
+The example above shows that in that case, the signaling agent stops to
+generate data for the event and tells that it doesn't use it anymore by calling
+**afb\_event\_unref**.
+
+This is one possible option.
+Other valuable options are:
- do nothing and continue to generate and push the event.
- just stop to generate and push the data but keep the event existing.
Understanding what a client expects when it receives signals, events or
data shall be the most important topic of the designer of a signaling
-agent.
+agent.
The good point here is that because JSON[^1] is the exchange
format, structured data can be sent in a flexible way.
### The exceptional case of wide broadcast
Some data or events have so much importance that they can be widely
-broadcasted to alert any listening client.
+broadcasted to alert any listening client.
Examples of such an alert are:
- system is entering/leaving “power safe” mode
An event can be broadcasted using one of the two following methods:
-- ***afb\_daemon\_broadcast\_event***
+- ***afb\_api\_broadcast\_event***
- ***afb\_event\_broadcast***
Example 1:
```C
-afb_daemon_broadcast_event(name, json);
+afb_api_broadcast_event(api, name, json);
```
Example 2:
```C
-event = afb_daemon_make_event(name);
+event = afb_api_make_event(api, name);
. . . .
afb_event_broadcast(event, json);
```
As for other events, the name of events broadcasted using
-***afb\_daemon\_broadcast\_event*** are automatically prefixed by
-the framework with API prefix of the binding (signaling agent).
+***afb\_api\_broadcast\_event*** are automatically prefixed by
+the framework with API prefix.
## Reference of functions
-### Function afb\_event afb\_daemon\_make\_event
-
-The function ***afb\_daemon\_make\_event*** that is defined as below:
-
-```C
-/*
- * Creates an event of 'name' and returns it.
- */
-struct afb_event afb_daemon_make_event(const char *name);
-```
-
-The correct way to create the event at initialization is to call the function
-***afb\_daemon\_make\_event*** within the initialization
-function referenced by the field ***init*** of the structure ***afbBindingV2***.
-
-### Function afb\_event\_push
-
-The function ***afb\_event\_push*** is defined as below:
-
-```C
-/*
- * Pushes the '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.
- *
- * Returns the count of clients that received the event.
- */
-int afb_event_push(struct afb_event event, struct json_object *object);
-```
-
-As the function ***afb\_event\_push*** returns 0 when there is no
-more subscriber, a binding can remove such unexpected event using the
-function ***afb\_event\_drop***.
-
-### Function afb\_event\_drop
-
-The function ***afb\_event\_drop*** is defined as below:
-
-```C
-/*
- * Drops the data associated to the event
- * After calling this function, the event
- * MUST NOT BE USED ANYMORE.
- */
-void afb_event_drop(struct afb_event event);
-```
-
-### Function afb\_req\_subscribe
-
-The function ***afb\_req\_subscribe*** is defined as below:
-
-```C
-/*
- * 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.
- */
-int afb_req_subscribe(struct afb_req req, struct afb_event event);
-```
-
-The subscription adds the client of the request to the list of subscribers
-to the event.
-
-### Function afb\_req\_unsubscribe
+See the [references for functions of class afb_event](reference-v3/func-event.md)
-The function ***afb\_req\_unsubscribe*** is defined as
-below:
-
-```C
-/*
- * Revokes the subscription established to the 'event' for the client
- * link identified by 'req'.
- * Returns 0 in case of successful un-subscription or -1 in case of error.
- */
-int afb_req_unsubscribe(struct afb_req req, struct afb_event event);
-```
+### Function onevent (field of afbBindingExport)
-The un-subscription removes the client of the request of the
-list of subscribers to the event.
-When the list of subscribers to the event becomes empty,
-the function ***afb\_event\_push*** will return zero.
-
-### Function afb\_event\_broadcast
-
-The function ***afb\_event\_broadcast*** is defined as below:
-
-```C
-/*
- * Broadcasts widely the '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.
- *
- * Returns the count of clients that received the event.
- */
-int afb_event_broadcast(struct afb_event event, struct json_object *object);
-```
-
-This uses an existing event (created with ***afb\_daemon\_make\_event***)
-for broadcasting an event having its name.
-
-### Function afb\_daemon\_broadcast\_event
-
-The function ***afb\_daemon\_broadcast\_event*** is defined as below:
-
-```C
-/*
- * 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.
- *
- * Returns the count of clients that received the event.
- */
-int afb_daemon_broadcast_event(const char *name, struct json_object *object);
-```
+Binding can designate an event handling function using the field **onevent**
+of the structure **afb_binding_t**.
-The name is given here explicitly.
-The name is automatically prefixed with the name of the binding.
-For example, a binding of prefix "xxx" would broadcast the event "xxx/name".
+This function is called when an event is broadcasted or when an event that the
+api subscribed to (through call or subcall mechanism) is pushed.
+That behavior allows a service to react to an event and do what it is to do if
+this is relevant for it.
+(ie: car back camera detects imminent collision and broadcast it, then
+appropriate service enable parking brake.).
-### Function onevent (field of afbBindingV2)
+### Event handlers
-Binding can designate an event handling function using the field **onevent**
-of the structure **afbBindingV2**.
-This function is called when an event is broadcasted or when an event the
-binding subscribed to is pushed.
-That allow a service to react to an event and do what it is to do if this is
-relevant for it.
-(ie: car back camera detects imminent collision and broadcast it, then
-appropriate service enable parking brake.).
+The apis functions allow to declare event handling callbacks. These callback are
+called on reception of an event matching a pattern and a receive in more that
+the event name and its companion JSON data, a user defiend closure and the api
+that is used to create it.
The migration from version 1 is not treated here because bindings version 1
are very old and probably does not exist anymore. If needed you can refer
-to the old [guide to migrate bindings from v1 to v2](afb-migration-v1-to-v2.md).
+to the old [guide to migrate bindings from v1 to v2](legacy/afb-migration-v1-to-v2.md).
Differences between version 2 and version 3
### in v3 all is api
-The version 3 introduce the concept of "API" that gather what was called before
+The version 3 introduces the concept of "API" that gather what was called before
the daemon and the service. This is the new concept that predates the 2 others.
The concept of API is intended to allow the definition of multiple APIs
Because there is potentially several "API", the functions that were without
context in bindings version 2 need now to tell what API is consumer.
-To be compatible with version 2, the bindings v3 still have a default hidden
+To be compatible with version 2, bindings v3 still have a default hidden
context: the default API named **afbBindingV3root**.
To summarize, the functions of class **daemon** and **service** use the default
This task list is:
1. Use the automatic migration procedure described below
-2. Adapt the init and preinit functions
-3. Consider to change to use the new reply
-4. Consider to change to use the new (sub)call
+2. Adapt the functions **preinit**, **init** and **onevent**
+3. Consider use of the new reply
+4. Consider use of the new (sub)call
+5. Consider use of event handlers
The remaining chapters explain these task with more details.
--------------------
A tiny **sed** script is intended to perform a first pass on the code that
-you want to upgrade. It can be down using **curl** and applied using **sed**
+you want to upgrade. It can be done using **curl** and applied using **sed**
as below.
```bash
sed -i -f $SED file1 file2 file3...
```
-This automatic action does most of the boring job nut not all the job.
+This automatic action does most of the boring job but not all the job.
The remaining of this guide explains the missing part.
-Adapt the init and preinit functions
-------------------------------------
+Adapt the functions preinit, init and onevent
+----------------------------------------------
-Consider to change to use the new reply
----------------------------------------
+The signature of the functions **preinit**, **init** and **onevent** changed
+to include the target api.
-Consider to change to use the new (sub)call
--------------------------------------------
+The functions of the v2:
+
+```C
+int (*preinit)();
+int (*init)();
+void (*onevent)(const char *event, struct json_object *object);
+```
+
+Gain a new first argument of type **afb_api_t** as below:
+
+```C
+int (*preinit)(afb_api_t api);
+int (*init)(afb_api_t api);
+void (*onevent)(afb_api_t api, const char *event, struct json_object *object);
+```
+
+For the migration, it is enough to just add the new argument without
+using it.
+
+Consider use of the new reply
+-----------------------------
+
+The v3 allows error reply with JSON object. To achieve it, an unified
+reply function's family is introduced:
+
+```C
+void afb_req_reply(afb_req_t req, json_object *obj, const char *error, const char *info);
+void afb_req_reply_v(afb_req_t req, json_object *obj, const char *error, const char *info, va_list args);
+void afb_req_reply_f(afb_req_t req, json_object *obj, const char *error, const char *info, ...);
+```
+
+The functions **success** and **fail** are still supported.
+These functions are now implemented as the following macros:
+
+
+```C
+#define afb_req_success(r,o,i) afb_req_reply(r,o,NULL,i)
+#define afb_req_success_f(r,o,...) afb_req_reply_f(r,o,NULL,__VA_ARGS__)
+#define afb_req_success_v(r,o,f,v) afb_req_reply_v(r,o,NULL,f,v)
+#define afb_req_fail(r,e,i) afb_req_reply(r,NULL,e,i)
+#define afb_req_fail_f(r,e,...) afb_req_reply_f(r,NULL,e,__VA_ARGS__)
+#define afb_req_fail_v(r,e,f,v) afb_req_reply_v(r,NULL,e,f,v)
+```
+
+This is a decision of the developer to switch to the new family
+**afb_req_reply** or to keep the good old functions **afb_req_fail**
+adn **afb_req_success**.
+
+Consider use of the new (sub)call
+---------------------------------
+
+The new call and subcall (the functions **afb_api_call**, **afb_api_call_sync**,
+**afb_req_subcall** and **afb_req_subcall_sync**) functions are redesigned
+to better fit the new reply behaviour. In most case the developer will benefit
+of the new behavior that directly gives result and error without enforcing
+to parse the JSON object result.
+
+The subcall functions are also fully redesigned to allow precise handling
+of the context and event subscriptions. The new design allows you to specify:
+
+ - whether the subcall is made in the session of the caller or in the session
+ of the service
+ - whether the credentials to use are those of the caller or those of the
+ service
+ - whether the caller or the service or both or none will receive the
+ eventually events during the subcall.
+
+See [calls](reference-v3/func-api/#calls-and-job-functions) and
+[subcalls](reference-v3/func-req/#subcall-functions).
+
+
+Consider use of event handlers
+------------------------------
+
+Binding V3 brings new ways of handling event in services. You can register
+functions that will handle specific events and that accept closure arguments.
+See [**afb_api_event_handler_add** and **afb_api_event_handler_del**](reference-v3/func-api/#event-functions)
--- /dev/null
+# Summary
+
+* [Binder Overview](afb-introduction.md)
+* [Binder daemon vocabulary](afb-daemon-vocabulary.md)
+* [How to write a binding ?](afb-binding-writing.md)
+* [Binding references](afb-binding-references.md)
+ * [Types and globals](reference-v3/types-and-globals.md)
+ * [Macros for logging](reference-v3/macro-log.md)
+ * [Functions of class afb_api](reference-v3/func-api.md)
+ * [Functions of class afb_req](reference-v3/func-req.md)
+ * [Functions of class afb_event](reference-v3/func-event.md)
+ * [Functions of class afb_daemon](reference-v3/func-daemon.md)
+ * [Functions of class afb_service](reference-v3/func-service.md)
+* [Binder events guide](afb-events-guide.md)
+* [Binder Application writing guide](afb-application-writing.md)
+* [Annexes](annexes.md)
+ * [Migration to binding v3](afb-migration-to-binding-v3.md)
+ * [WebSocket protocol x-afb-ws-json1](protocol-x-afb-ws-json1.md)
+ * [Installing the binder on a desktop](afb-desktop-package.md)
+ * [Options of afb-daemon](afb-daemon-options.md)
+ * [Debugging binder and bindings](afb-daemon-debugging.md)
+ * [LEGACY Guide to migrate bindings from v1 to v2](legacy/afb-migration-v1-to-v2.md)
+ * [LEGACY Binding V2 references](legacy/afb-binding-v2-references.md)
+* [Document revisions](REVISIONS.md)
--- /dev/null
+[LEGACY] Binding Reference
+==========================
+
+# Structure for declaring binding
+---------------------------------
+
+### struct afb_binding_v2
+
+The main structure, of type **afb_binding_v2**, for describing the binding
+must be exported under the name **afbBindingV2**.
+
+This structure is defined as below.
+
+```C
+/*
+ * Description of the bindings of type version 2
+ */
+struct afb_binding_v2
+{
+ const char *api; /* api name for the binding */
+ const char *specification; /* textual openAPIv3 specification of the binding */
+ 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 */
+};
+```
+
+### struct afb_verb_v2
+
+Each verb is described with a structure of type **afb_verb_v2**
+defined below:
+
+```C
+/*
+ * Description of one verb of the API provided by the binding
+ * This enumeration is valid for bindings of type version 2
+ */
+struct afb_verb_v2
+{
+ const char *verb; /* name of the verb */
+ void (*callback)(struct afb_req req); /* callback function implementing the verb */
+ const struct afb_auth *auth; /* required authorization */
+ const char *info; /* some info about the verb, can be NULL */
+ uint32_t session; /* authorization and session requirements of the verb */
+};
+```
+
+The **session** flags is one of the constant defined below:
+
+- AFB_SESSION_NONE : no flag, synonym to 0
+- AFB_SESSION_LOA_0 : Requires the LOA to be 0 or more, synonym to 0 or AFB_SESSION_NONE
+- AFB_SESSION_LOA_1 : Requires the LOA to be 1 or more
+- AFB_SESSION_LOA_2 : Requires the LOA to be 2 or more
+- AFB_SESSION_LOA_3 : Requires the LOA to be 3 or more
+- AFB_SESSION_CHECK : Requires the token to be set and valid
+- AFB_SESSION_REFRESH : Implies a token refresh
+- AFB_SESSION_CLOSE : Implies cloing the session
+
+The LOA (Level Of Assurance) is set, by binding, using the function **afb_req_session_set_LOA**.
+
+### struct afb_auth and enum afb_auth_type
+
+The structure **afb_auth** is used within verb description to
+set security requirements.
+The interpretation of the structure depends on the value of the field **type**.
+
+```C
+struct afb_auth
+{
+ const enum afb_auth_type type;
+ union {
+ const char *text;
+ const unsigned loa;
+ const struct afb_auth *first;
+ };
+ const struct afb_auth *next;
+};
+```
+
+The possible values for **type** is defined here:
+
+```C
+/*
+ * Enum for Session/Token/Assurance middleware.
+ */
+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 */
+};
+```
+
+Example:
+
+```C
+static const struct afb_auth _afb_auths_v2_monitor[] = {
+ { .type = afb_auth_Permission, .text = "urn:AGL:permission:monitor:public:set" },
+ { .type = afb_auth_Permission, .text = "urn:AGL:permission:monitor:public:get" },
+ { .type = afb_auth_Or, .first = &_afb_auths_v2_monitor[1], .next = &_afb_auths_v2_monitor[0] }
+};
+```
+
+## Functions of class afb_daemon
+
+The 3 following functions are linked to libsystemd.
+They allow use of **sd_event** features and access
+to **sd_bus** features.
+
+```C
+/*
+ * Retrieves the common systemd's event loop of AFB
+ */
+struct sd_event *afb_daemon_get_event_loop();
+
+/*
+ * Retrieves the common systemd's user/session d-bus of AFB
+ */
+struct sd_bus *afb_daemon_get_user_bus();
+
+/*
+ * Retrieves the common systemd's system d-bus of AFB
+ */
+struct sd_bus *afb_daemon_get_system_bus();
+```
+
+The 2 following functions are linked to event management.
+Broadcasting an event send it to any possible listener.
+
+```C
+/*
+ * 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.
+ */
+int afb_daemon_broadcast_event(const char *name, struct json_object *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.
+ */
+struct afb_event afb_daemon_make_event(const char *name);
+```
+
+The following function is used by logging macros and should normally
+not be used.
+Instead, you should use the macros:
+
+- **AFB\_ERROR**
+- **AFB\_WARNING**
+- **AFB\_NOTICE**
+- **AFB\_INFO**
+- **AFB\_DEBUG**
+
+```C
+/*
+ * 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
+ */
+void afb_daemon_verbose(int level, const char *file, int line, const char * func, const char *fmt, ...);
+```
+
+The 2 following functions MUST be used to access data of the bindings.
+
+```C
+/*
+ * Get the root directory file descriptor. This file descriptor can
+ * be used with functions 'openat', 'fstatat', ...
+ */
+int afb_daemon_rootdir_get_fd();
+
+/*
+ * 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.
+ */
+int afb_daemon_rootdir_open_locale(const char *filename, int flags, const char *locale);
+```
+
+The following function is used to queue jobs.
+
+```C
+/*
+ * 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 re-executed but with
+ * signum being the signal number (SIGALRM when timeout expired).
+ *
+ * Returns 0 in case of success or -1 in case of error.
+ */
+int afb_daemon_queue_job(void (*callback)(int signum, void *arg), void *argument, void *group, int timeout)
+```
+
+The following function must be used when a binding depends on other
+bindings at its initialization.
+
+```C
+/*
+ * 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.
+ */
+int afb_daemon_require_api(const char *name, int initialized)
+```
+
+This function allows to give a different name to the binding.
+It can be called during pre-init.
+
+```C
+/*
+ * 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.
+ */
+int afb_daemon_rename_api(const char *name);
+```
+
+## Functions of class afb_service
+
+The following functions allow services to call verbs of other
+bindings for themselves.
+
+```C
+/**
+ * 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 occurred,
+ * 2. 'result' the resulting data as a JSON object.
+ *
+ * @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'
+ */
+void afb_service_call(
+ const char *api,
+ const char *verb,
+ struct json_object *args,
+ void (*callback)(void*closure, int status, struct json_object *result),
+ void *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 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'
+ */
+int afb_service_call_sync(
+ const char *api,
+ const char *verb,
+ struct json_object *args,
+ struct json_object **result);
+```
+
+## Functions of class afb_event
+
+This function checks whether the event is valid.
+It must be used when creating events.
+
+```C
+/*
+ * Checks wether the 'event' is valid or not.
+ *
+ * Returns 0 if not valid or 1 if valid.
+ */
+int afb_event_is_valid(struct afb_event event);
+```
+
+The two following functions are used to broadcast or push
+event with its data.
+
+```C
+/*
+ * Broadcasts widely the '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.
+ *
+ * Returns the count of clients that received the event.
+ */
+int afb_event_broadcast(struct afb_event event, struct json_object *object);
+
+/*
+ * Pushes the '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.
+ *
+ * Returns the count of clients that received the event.
+ */
+int afb_event_push(struct afb_event event, struct json_object *object);
+```
+
+The following function destroys the event.
+
+```C
+/*
+ * Drops the data associated to the 'event'
+ * After calling this function, the event
+ * MUST NOT BE USED ANYMORE.
+ */
+void afb_event_drop(struct afb_event event);
+```
+
+This function allows to retrieve the exact name of the event.
+
+```C
+/*
+ * Gets the name associated to the 'event'.
+ */
+const char *afb_event_name(struct afb_event event);
+```
+
+## Functions of class afb_req
+
+This function checks the validity of the **req**.
+
+```C
+/*
+ * Checks wether the request 'req' is valid or not.
+ *
+ * Returns 0 if not valid or 1 if valid.
+ */
+int afb_req_is_valid(struct afb_req req);
+```
+
+The following functions retrieves parameters of the request.
+
+```C
+/*
+ * 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.
+ */
+struct afb_arg afb_req_get(struct afb_req req, const char *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_get(req, name).value
+ */
+const char *afb_req_value(struct afb_req req, const char *name);
+
+/*
+ * 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
+ */
+const char *afb_req_path(struct afb_req req, const char *name);
+
+/*
+ * Gets from the request 'req' the json object hashing the arguments.
+ * The returned object must not be released using 'json_object_put'.
+ */
+struct json_object *afb_req_json(struct afb_req req);
+```
+
+The following functions emit the reply to the request.
+
+```C
+/*
+ * Sends a reply of kind success to the request 'req'.
+ * The status of the reply is automatically set to "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.
+ */
+void afb_req_success(struct afb_req req, struct json_object *obj, const char *info);
+
+/*
+ * Same as 'afb_req_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.
+ */
+void afb_req_success_f(struct afb_req req, struct json_object *obj, const char *info, ...);
+
+/*
+ * Same as 'afb_req_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.
+ */
+void afb_req_success_v(struct afb_req req, struct json_object *obj, const char *info, va_list args);
+
+/*
+ * Sends a reply of kind failure to the request 'req'.
+ * The status of the reply is set to 'status' and an
+ * informational comment 'info' (can also be NULL) can be added.
+ *
+ * Note that calling afb_req_fail("success", info) is equivalent
+ * to call afb_req_success(NULL, info). Thus even if possible it
+ * is strongly recommended to NEVER use "success" for status.
+ */
+void afb_req_fail(struct afb_req req, const char *status, const char *info);
+
+/*
+ * Same as 'afb_req_fail' but the 'info' is a formatting
+ * string followed by arguments.
+ */
+void afb_req_fail_f(struct afb_req req, const char *status, const char *info, ...);
+
+/*
+ * Same as 'afb_req_fail_f' but the arguments to the format 'info'
+ * are given as a variable argument list instance.
+ */
+void afb_req_fail_v(struct afb_req req, const char *status, const char *info, va_list args);
+```
+
+The following functions handle the session data.
+
+```C
+/*
+ * Gets the pointer stored by the binding for the session of 'req'.
+ * When the binding has not yet recorded a pointer, NULL is returned.
+ */
+void *afb_req_context_get(struct afb_req req);
+
+/*
+ * 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.
+ */
+void afb_req_context_set(struct afb_req req, void *context, void (*free_context)(void*));
+
+/*
+ * 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'.
+ */
+void *afb_req_context(struct afb_req req, void *(*create_context)(), void (*free_context)(void*));
+
+/*
+ * 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)
+ */
+void afb_req_context_clear(struct afb_req req);
+
+/*
+ * Closes the session associated with 'req'
+ * and delete all associated contexts.
+ */
+void afb_req_session_close(struct afb_req req);
+
+/*
+ * 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.
+ */
+int afb_req_session_set_LOA(struct afb_req req, unsigned level);
+```
+
+The 4 following functions must be used for asynchronous handling requests.
+
+```C
+/*
+ * 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.
+ */
+void afb_req_addref(struct afb_req req);
+
+/*
+ * Substracts one to the count of references of 'req'.
+ * This function MUST be called by asynchronous implementations
+ * of verbs after sending the asynchronous reply.
+ */
+void afb_req_unref(struct afb_req req);
+
+/*
+ * Stores 'req' on heap for asynchronous 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).
+ */
+struct afb_stored_req *afb_req_store(struct afb_req req);
+
+/*
+ * 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.
+ */
+struct afb_req afb_req_unstore(struct afb_stored_req *sreq);
+```
+
+The two following functions are used to associate client with events
+(subscription).
+
+```C
+/*
+ * 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.
+ */
+int afb_req_subscribe(struct afb_req req, struct afb_event 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.
+ */
+int afb_req_unsubscribe(struct afb_req req, struct afb_event event);
+```
+
+The following functions must be used to make request in the name of the
+client (with its permissions).
+
+```C
+/*
+ * 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.
+ *
+ * See also:
+ * - 'afb_req_subcall_req' that is convenient to keep request alive automatically.
+ * - 'afb_req_subcall_sync' the synchronous version
+ */
+void afb_req_subcall(
+ struct afb_req req,
+ const char *api,
+ const char *verb,
+ struct json_object *args,
+ void (*callback)(void *closure, int status, struct json_object *result),
+ void *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'.
+ * On completion, the function 'callback' is invoked with the
+ * original request 'req', 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_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)
+{
+ req.itf->subcall_req(req.closure, 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 'req'.
+ * This call is synchronous, it waits until 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_req_subcall_req' that is convenient to keep request alive automatically.
+ * - 'afb_req_subcall' that doesn't keep request alive automatically.
+ */
+int afb_req_subcall_sync(
+ struct afb_req req,
+ const char *api,
+ const char *verb,
+ struct json_object *args,
+ struct json_object **result);
+```
+
+The following function is used by logging macros and should normally
+not be used.
+Instead, you should use the macros:
+
+- **AFB_REQ_ERROR**
+- **AFB_REQ_WARNING**
+- **AFB_REQ_NOTICE**
+- **AFB_REQ_INFO**
+- **AFB_REQ_DEBUG**
+
+```C
+/*
+ * 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
+ */
+void afb_req_verbose(struct afb_req req, int level, const char *file, int line, const char * func, const char *fmt, ...);
+```
+
+The functions below allow a binding involved in the platform security
+to explicitly check a permission of a client or to get the calling
+application identity.
+
+```C
+/*
+ * Check whether the 'permission' is granted or not to the client
+ * identified by 'req'.
+ *
+ * Returns 1 if the permission is granted or 0 otherwise.
+ */
+int afb_req_has_permission(struct afb_req req, const char *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
+ */
+char *afb_req_get_application_id(struct afb_req req);
+
+/*
+ * Get the user identifier (UID) of the client application for the
+ * request 'req'.
+ *
+ * Returns -1 when the application can not be identified.
+ */
+int afb_req_get_uid(struct afb_req req);
+```
+
+## Logging macros
+
+The following macros must be used for logging:
+
+```C
+AFB_ERROR(fmt,...)
+AFB_WARNING(fmt,...)
+AFB_NOTICE(fmt,...)
+AFB_INFO(fmt,...)
+AFB_DEBUG(fmt,...)
+```
+
+The following macros can be used for logging in the context
+of a request **req** of type **afb_req**:
+
+```C
+AFB_REQ_ERROR(req,fmt,...)
+AFB_REQ_WARNING(req,fmt,...)
+AFB_REQ_NOTICE(req,fmt,...)
+AFB_REQ_INFO(req,fmt,...)
+AFB_REQ_DEBUG(req,fmt,...)
+```
+
+By default, the logging macros add file, line and function
+indication.
--- /dev/null
+The websocket protocol x-afb-ws-json1
+=====================================
+
+The WebSocket protocol *x-afb-ws-json1* is used to communicate between
+an application and a binder. It allows access to all registered apis
+of the binder.
+
+This protocol is inspired from the protocol **OCPP - SRPC** as described for
+example here:
+[OCPP transport specification - SRPC over WebSocket](http://www.gir.fr/ocppjs/ocpp_srpc_spec.shtml).
+
+The registration to the IANA is still to be done, see:
+[WebSocket Protocol Registries](https://www.iana.org/assignments/websocket/websocket.xml)
+
+This document gives a short description of the protocol *x-afb-ws-json1*.
+A more formal description has to be done.
+
+
+Architecture
+------------
+
+The protocol is intended to be symmetric. It allows:
+
+ - to CALL a remote procedure that returns a result
+ - to push and receive EVENT
+
+
+Messages
+--------
+
+Valid messages are made of *text* frames that are all valid JSON.
+
+Valid messages are:
+
+Calls:
+```
+[ 2, ID, PROCN, ARGS ]
+[ 2, ID, PROCN, ARGS, TOKEN ]
+```
+
+Replies (3: OK, 4: ERROR):
+```
+[ 3, ID, RESP ]
+[ 3, ID, RESP, TOKEN ]
+[ 4, ID, RESP ]
+[ 4, ID, RESP, TOKEN ]
+```
+
+Events:
+```
+[ 5, EVTN, OBJ ]
+```
+
+Where:
+
+| Field | Type | Description
+|-------|--------|------------------
+| ID | string | A string that identifies the call. A reply to that call use the ID of the CALL.
+| PROCN | string | The procedure name to call of the form "api/verb"
+| ARGS | any | Any argument to pass to the call (see afb_req_json that returns it)
+| RESP | any | The response to the call
+| TOKEN | string | The token in case of refresh
+| EVTN | string | Name of the event in the form "api/event"
+| OBJ | any | The companion object of the event
+
+Below, an example of exchange:
+
+```
+C->S: [2,"156","hello/ping",null]
+S->C: [3,"156",{"response":"Some String","jtype":"afb-reply","request":{"status":"success","info":"Ping Binder Daemon tag=pingSample count=1 query=\"null\"","uuid":"ec30120c-6997-4529-9d63-c0de0cce56c0"}}]
+```
+
+
+Future
+------
+
+Here are the planned extensions:
+
+ - add binary messages with cbor data
+ - add calls with unstructured replies
+
+This could be implemented by extending the current protocol or by
+allowing the binder to accept either protocol including the new ones.
+
+
+Javascript implementation
+-------------------------
+
+The file **AFB.js** is a javascript implementation of the protocol.
+
+Here is that code:
+
+```javascript
+/*
+ * Copyright (C) 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.
+ */
+AFB = function(base, initialtoken){
+
+if (typeof base != "object")
+ base = { base: base, token: initialtoken };
+
+var initial = {
+ base: base.base || "api",
+ token: base.token || initialtoken || "HELLO",
+ host: base.host || window.location.host,
+ url: base.url || undefined
+};
+
+var urlws = initial.url || "ws://"+initial.host+"/"+initial.base;
+
+/*********************************************/
+/**** ****/
+/**** AFB_context ****/
+/**** ****/
+/*********************************************/
+var AFB_context;
+{
+ var UUID = undefined;
+ var TOKEN = initial.token;
+
+ var context = function(token, uuid) {
+ this.token = token;
+ this.uuid = uuid;
+ }
+
+ context.prototype = {
+ get token() {return TOKEN;},
+ set token(tok) {if(tok) TOKEN=tok;},
+ get uuid() {return UUID;},
+ set uuid(id) {if(id) UUID=id;}
+ };
+
+ AFB_context = new context();
+}
+/*********************************************/
+/**** ****/
+/**** AFB_websocket ****/
+/**** ****/
+/*********************************************/
+var AFB_websocket;
+{
+ var CALL = 2;
+ var RETOK = 3;
+ var RETERR = 4;
+ var EVENT = 5;
+
+ var PROTO1 = "x-afb-ws-json1";
+
+ AFB_websocket = function(on_open, on_abort) {
+ var u = urlws;
+ if (AFB_context.token) {
+ u = u + '?x-afb-token=' + AFB_context.token;
+ if (AFB_context.uuid)
+ u = u + '&x-afb-uuid=' + AFB_context.uuid;
+ }
+ this.ws = new WebSocket(u, [ PROTO1 ]);
+ this.url = u;
+ this.pendings = {};
+ this.awaitens = {};
+ this.counter = 0;
+ this.ws.onopen = onopen.bind(this);
+ this.ws.onerror = onerror.bind(this);
+ this.ws.onclose = onclose.bind(this);
+ this.ws.onmessage = onmessage.bind(this);
+ this.onopen = on_open;
+ this.onabort = on_abort;
+ }
+
+ function onerror(event) {
+ var f = this.onabort;
+ if (f) {
+ delete this.onopen;
+ delete this.onabort;
+ f && f(this);
+ }
+ this.onerror && this.onerror(this);
+ }
+
+ function onopen(event) {
+ var f = this.onopen;
+ delete this.onopen;
+ delete this.onabort;
+ f && f(this);
+ }
+
+ function onclose(event) {
+ for (var id in this.pendings) {
+ try { this.pendings[id][1](); } catch (x) {/*TODO?*/}
+ }
+ this.pendings = {};
+ this.onclose && this.onclose();
+ }
+
+ function fire(awaitens, name, data) {
+ var a = awaitens[name];
+ if (a)
+ a.forEach(function(handler){handler(data);});
+ var i = name.indexOf("/");
+ if (i >= 0) {
+ a = awaitens[name.substring(0,i)];
+ if (a)
+ a.forEach(function(handler){handler(data);});
+ }
+ a = awaitens["*"];
+ if (a)
+ a.forEach(function(handler){handler(data);});
+ }
+
+ function reply(pendings, id, ans, offset) {
+ if (id in pendings) {
+ var p = pendings[id];
+ delete pendings[id];
+ try { p[offset](ans); } catch (x) {/*TODO?*/}
+ }
+ }
+
+ function onmessage(event) {
+ var obj = JSON.parse(event.data);
+ var code = obj[0];
+ var id = obj[1];
+ var ans = obj[2];
+ AFB_context.token = obj[3];
+ switch (code) {
+ case RETOK:
+ reply(this.pendings, id, ans, 0);
+ break;
+ case RETERR:
+ reply(this.pendings, id, ans, 1);
+ break;
+ case EVENT:
+ default:
+ fire(this.awaitens, id, ans);
+ break;
+ }
+ }
+
+ function close() {
+ this.ws.close();
+ this.ws.onopen =
+ this.ws.onerror =
+ this.ws.onclose =
+ this.ws.onmessage =
+ this.onopen =
+ this.onabort = function(){};
+ }
+
+ function call(method, request, callid) {
+ return new Promise((function(resolve, reject){
+ var id, arr;
+ if (callid) {
+ id = String(callid);
+ if (id in this.pendings)
+ throw new Error("pending callid("+id+") exists");
+ } else {
+ do {
+ id = String(this.counter = 4095 & (this.counter + 1));
+ } while (id in this.pendings);
+ }
+ this.pendings[id] = [ resolve, reject ];
+ arr = [CALL, id, method, request ];
+ if (AFB_context.token) arr.push(AFB_context.token);
+ this.ws.send(JSON.stringify(arr));
+ }).bind(this));
+ }
+
+ function onevent(name, handler) {
+ var id = name;
+ var list = this.awaitens[id] || (this.awaitens[id] = []);
+ list.push(handler);
+ }
+
+ AFB_websocket.prototype = {
+ close: close,
+ call: call,
+ onevent: onevent
+ };
+}
+/*********************************************/
+/**** ****/
+/**** ****/
+/**** ****/
+/*********************************************/
+return {
+ context: AFB_context,
+ ws: AFB_websocket
+};
+};
+```
\ No newline at end of file
--- /dev/null
+Functions of class **afb_api**
+============================
+
+## General functions
+
+### afb_api_name
+
+```C
+/**
+ * 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.
+ */
+const char *afb_api_name(
+ afb_api_t api);
+```
+
+### afb_api_get_userdata
+
+```C
+/**
+ * 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_set_userdata
+ */
+void *afb_api_get_userdata(
+ afb_api_t api);
+```
+
+### afb_api_set_userdata
+
+```C
+/**
+ * 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_get_userdata
+ */
+void afb_api_set_userdata(
+ afb_api_t api,
+ void *value);
+```
+
+### afb_api_require_api
+
+```C
+/**
+ * Check that it requires the API of 'name'.
+ * If 'initialized' is not zero it request the API to be
+ * initialized, implying its initialization if needed.
+ *
+ * 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 required api names
+ * @param initialized if zero, the api is just required to exist. If not zero,
+ * the api is required to exist and to be initialized at return of the call
+ * (initializing it if needed and possible as a side effect of the call).
+ *
+ * @return 0 in case of success or -1 in case of error with errno set appropriately.
+ */
+int afb_api_require_api(
+ afb_api_t api,
+ const char *name,
+ int initialized);
+```
+
+
+## Verbosity functions
+
+### afb_api_wants_log_level
+
+```C
+/**
+ * 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
+ */
+int afb_api_wants_log_level(
+ afb_api_t api,
+ int level);
+```
+
+### afb_api_vverbose
+
+```C
+/**
+ * Send to the journal with the logging 'level' a message described
+ * by 'fmt' applied to the va-list 'args'.
+ *
+ * 'file', 'line' and 'func' are indicators of code position 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
+ */
+void afb_api_vverbose(
+ afb_api_t api,
+ int level,
+ const char *file,
+ int line,
+ const char *func,
+ const char *fmt,
+ va_list args);
+```
+
+### afb_api_verbose
+
+```C
+/**
+ * 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
+ */
+void afb_api_verbose(
+ afb_api_t api,
+ int level,
+ const char *file,
+ int line,
+ const char *func,
+ const char *fmt,
+ ...);
+```
+
+## Data retrieval functions
+
+### afb_api_rootdir_get_fd
+
+```C
+/**
+ * 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:
+ *
+ * char buffer[MAX_PATH], proc[100];
+ * int dirfd = afb_api_rootdir_get_fd(api);
+ * snprintf(proc, sizeof proc, "/proc/self/fd/%d", dirfd);
+ * readlink(proc, 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_rootdir_open_locale
+ */
+int afb_api_rootdir_get_fd(
+ afb_api_t api);
+```
+
+### afb_api_rootdir_open_locale
+
+```C
+/**
+ * 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_rootdir_get_fd
+ */
+int afb_api_rootdir_open_locale(
+ afb_api_t api,
+ const char *filename,
+ int flags,
+ const char *locale);
+```
+
+## Calls and job functions
+
+### afb_api_call
+
+```C
+/**
+ * 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_call_sync
+ */
+void afb_api_call(
+ afb_api_t 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,
+ afb_api_t api),
+ void *closure);
+```
+
+### afb_api_call_sync
+
+```C
+/**
+ * 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_call
+ */
+int afb_api_call_sync(
+ afb_api_t api,
+ const char *apiname,
+ const char *verb,
+ struct json_object *args,
+ struct json_object **object,
+ char **error,
+ char **info);
+```
+
+### afb_api_queue_job
+
+```C
+/**
+ * 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 implementation of the job callback is:
+ *
+ * void my_job_cb(int signum, void *arg)
+ * {
+ * struct myarg_t *myarg = arg;
+ * if (signum)
+ * AFB_API_ERROR(myarg->api, "job interrupted 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.
+ */
+int afb_api_queue_job(
+ afb_api_t api,
+ void (*callback)(int signum, void *arg),
+ void *argument,
+ void *group,
+ int timeout);
+```
+
+## Event functions
+
+### afb_api_broadcast_event
+
+```C
+/**
+ * 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.
+ */
+int afb_api_broadcast_event(
+ afb_api_t api,
+ const char *name,
+ struct json_object *object);
+```
+
+### afb_api_make_event
+
+```C
+/**
+ * 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
+ */
+afb_event_t afb_api_make_event(
+ afb_api_t api,
+ const char *name);
+```
+
+### afb_api_event_handler_add
+
+```C
+/**
+ * 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_on_event
+ * @see afb_api_event_handler_del
+ */
+int afb_api_event_handler_add(
+ afb_api_t api,
+ const char *pattern,
+ void (*callback)(
+ void *,
+ const char*,
+ struct json_object*,
+ afb_api_t),
+ void *closure);
+```
+
+### afb_api_event_handler_del
+
+```C
+/**
+ * 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_on_event
+ * @see afb_api_event_handler_add
+ */
+int afb_api_event_handler_del(
+ afb_api_t api,
+ const char *pattern,
+ void **closure);
+
+```
+
+## Systemd functions
+
+### afb_api_get_event_loop
+
+```C
+/**
+ * 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_get_user_bus
+ * @see afb_api_get_system_bus
+ */
+struct sd_event *afb_api_get_event_loop(
+ afb_api_t api);
+```
+
+### afb_api_get_user_bus
+
+```C
+/**
+ * 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_get_event_loop
+ * @see afb_api_get_system_bus
+ */
+struct sd_bus *afb_api_get_user_bus(
+ afb_api_t api);
+```
+
+### afb_api_get_system_bus
+
+```C
+/**
+ * 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_get_event_loop
+ * @see afb_api_get_user_bus
+ */
+struct sd_bus *afb_api_get_system_bus(
+ afb_api_t api);
+```
+
+
+## Dynamic api functions
+
+### afb_api_new_api
+
+```C
+/**
+ * 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_delete_api
+ */
+afb_api_t afb_api_new_api(
+ afb_api_t api,
+ const char *apiname,
+ const char *info,
+ int noconcurrency,
+ int (*preinit)(void*, afb_api_t ),
+ void *closure);
+```
+
+### afb_api_set_verbs_v2
+
+```C
+/**
+ * @deprecated use @ref afb_api_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_add_verb
+ * @see afb_api_set_verbs_v3
+ */
+int afb_api_set_verbs_v2(
+ afb_api_t api,
+ const struct afb_verb_v2 *verbs);
+```
+
+### afb_api_set_verbs_v3
+
+```C
+/**
+ * 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_add_verb
+ * @see afb_api_del_verb
+ */
+int afb_api_set_verbs_v3(
+ afb_api_t api,
+ const struct afb_verb_v3 *verbs);
+```
+
+### afb_api_add_verb
+
+```C
+/**
+ * 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_del_verb
+ * @see afb_api_set_verbs_v3
+ * @see fnmatch for matching names using glob
+ */
+int afb_api_add_verb(
+ afb_api_t 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);
+```
+
+### afb_api_del_verb
+
+```C
+/**
+ * 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_add_verb
+ */
+int afb_api_del_verb(
+ afb_api_t api,
+ const char *verb,
+ void **vcbdata);
+```
+
+### afb_api_on_event
+
+```C
+/**
+ * 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_event_handler_add
+ * @see afb_api_event_handler_del
+ */
+int afb_api_on_event(
+ afb_api_t api,
+ void (*onevent)(
+ afb_api_t api,
+ const char *event,
+ struct json_object *object));
+```
+
+### afb_api_on_init
+
+```C
+/**
+ * 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
+ */
+int afb_api_on_init(
+ afb_api_t api,
+ int (*oninit)(afb_api_t api));
+```
+
+### afb_api_provide_class
+
+```C
+/**
+ * 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_require_class
+ */
+int afb_api_provide_class(
+ afb_api_t api,
+ const char *name);
+```
+
+### afb_api_require_class
+
+```C
+/**
+ * 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 required classes
+ *
+ * @returns 0 in case of success or a negative value in case of error.
+ *
+ * @see afb_api_provide_class
+ */
+int afb_api_require_class(
+ afb_api_t api,
+ const char *name);
+```
+
+### afb_api_seal
+
+```C
+/**
+ * Seal the api. After a call to this function the api can not be modified
+ * anymore.
+ *
+ * @param api the api to be sealed
+ */
+void afb_api_seal(
+ afb_api_t api);
+```
+
+### afb_api_delete_api
+
+```C
+/**
+ * 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_new_api
+ */
+int afb_api_delete_api(
+ afb_api_t api);
+```
+
+### afb_api_add_alias
+
+```C
+/**
+ * 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.
+ */
+int afb_api_add_alias(
+ afb_api_t api,
+ const char *name,
+ const char *as_name);
+```
+
+
+## Legacy functions
+
+The function for legacy calls are still provided for some time because
+adaptation of existing code to the new call functions require a small amount
+of work.
+
+### afb_api_call_legacy
+
+```C
+/**
+ * @deprecated try to use @ref afb_api_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'
+ */
+void afb_api_call_legacy(
+ afb_api_t api,
+ const char *apiname,
+ const char *verb,
+ struct json_object *args,
+ void (*callback)(
+ void *closure,
+ int status,
+ struct json_object *result,
+ afb_api_t api),
+ void *closure);
+```
+
+### afb_api_call_sync_legacy
+
+```C
+/**
+ * @deprecated try to use @ref afb_api_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'
+ */
+int afb_api_call_sync_legacy(
+ afb_api_t api,
+ const char *apiname,
+ const char *verb,
+ struct json_object *args,
+ struct json_object **result);
+```
+
--- /dev/null
+Functions of class **afb_daemon**
+============================
+
+All the functions of the class **afb_daemon** use the default api.
+This are internally aliased to the corresponding function of class afb_api_t.
+
+```C
+/**
+ * Retrieves the common systemd's event loop of AFB
+ */
+struct sd_event *afb_daemon_get_event_loop();
+
+/**
+ * Retrieves the common systemd's user/session d-bus of AFB
+ */
+struct sd_bus *afb_daemon_get_user_bus();
+
+/**
+ * Retrieves the common systemd's system d-bus of AFB
+ */
+struct sd_bus *afb_daemon_get_system_bus();
+
+/**
+ * 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.
+ */
+int afb_daemon_broadcast_event(
+ const char *name,
+ struct json_object *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.
+ */
+afb_event_t afb_daemon_make_event(
+ const char *name);
+
+/**
+ * @deprecated use bindings version 3
+ *
+ * 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
+ */
+void afb_daemon_verbose(
+ int level,
+ const char *file,
+ int line,
+ const char * func,
+ const char *fmt,
+ ...);
+
+/**
+ * @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.
+ */
+int afb_daemon_rootdir_get_fd();
+
+/**
+ * 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.
+ */
+int afb_daemon_rootdir_open_locale(
+ const char *filename,
+ int flags,
+ const char *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.
+ */
+int afb_daemon_queue_job(
+ void (*callback)(int signum, void *arg),
+ void *argument,
+ void *group,
+ int 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.
+ */
+int afb_daemon_require_api(
+ const char *name,
+ int initialized);
+
+/**
+ * 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.
+ */
+int afb_daemon_add_alias(const char *name, const char *as_name);
+
+/**
+ * Creates a new api of name 'api' with brief 'info'.
+ *
+ * Returns 0 in case of success or -1 in case of error.
+ */
+int afb_daemon_new_api(
+ const char *api,
+ const char *info,
+ int noconcurrency,
+ int (*preinit)(void*, struct afb_api_x3 *),
+ void *closure);
+```
--- /dev/null
+Functions of class afb_event_t
+==============================
+
+## General functions
+
+### afb_event_is_valid
+
+```C
+/**
+ * Checks whether the 'event' is valid or not.
+ *
+ * @param event the event to check
+ *
+ * @return 0 if not valid or 1 if valid.
+ */
+int afb_event_is_valid(
+ afb_event_t event);
+```
+
+### afb_event_name
+
+```C
+/**
+ * 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_unref'.
+ * It shouldn't be freed.
+ */
+const char *afb_event_name(
+ afb_event_t event);
+```
+
+### afb_event_unref
+
+```C
+/**
+ * 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
+ */
+void afb_event_unref(
+ afb_event_t event);
+```
+
+### afb_event_addref
+
+```C
+/**
+ * Increases the count of references to 'event'
+ *
+ * @param event the event
+ *
+ * @return the event
+ */
+afb_event_t *afb_event_addref(
+ afb_event_t event);
+```
+
+## Pushing functions
+
+### afb_event_broadcast
+
+```C
+/**
+ * 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.
+ */
+int afb_event_broadcast(
+ afb_event_t event,
+ struct json_object *object);
+```
+
+### afb_event_push
+
+```C
+/**
+ * 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.
+ */
+int afb_event_push(
+ afb_event_t event,
+ struct json_object *object);
+```
+
--- /dev/null
+Functions of class afb_req_t
+============================
+
+## General function
+
+### afb_req_is_valid
+
+```C
+/**
+ * Checks whether the request 'req' is valid or not.
+ *
+ * @param req the request to check
+ *
+ * @return 0 if not valid or 1 if valid.
+ */
+int afb_req_is_valid(
+ afb_req_t*req);
+```
+
+### afb_req_get_api
+
+```C
+/**
+ * Retrieves the api that serves the request
+ *
+ * @param req the request whose serving api is queried
+ *
+ * @return the api serving the request
+ */
+afb_api_t afb_req_get_api(
+ afb_req_t*req);
+```
+
+### afb_req_get_vcbdata
+
+```C
+/**
+ * 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
+ */
+void *afb_req_get_vcbdata(
+ afb_req_t*req);
+```
+
+### afb_req_get_called_api
+
+```C
+/**
+ * Retrieve the name of the called api.
+ *
+ * @param req the request
+ *
+ * @return the name of the called api
+ *
+ * @see afb_api_new_api
+ * @see afb_api_add_alias
+ */
+const char *afb_req_get_called_api(
+ afb_req_t*req);
+```
+
+### afb_req_get_called_verb
+
+```C
+/**
+ * Retrieve the name of the called verb
+ *
+ * @param req the request
+ *
+ * @return the name of the called verb
+ */
+const char *afb_req_get_called_verb(
+ afb_req_t*req);
+```
+
+### afb_req_addref
+
+```C
+/**
+ * Increments the count of references of 'req'.
+ *
+ * @param req the request
+ *
+ * @return returns the request req
+ */
+afb_req_t*afb_req_addref(
+ afb_req_t*req);
+```
+
+### afb_req_unref
+
+```C
+/**
+ * Decrement the count of references of 'req'.
+ *
+ * @param req the request
+ */
+void afb_req_unref(
+ afb_req_t*req);
+```
+
+
+## Logging functions
+
+### afb_req_wants_log_level
+
+```C
+/**
+ * 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
+ */
+int afb_req_wants_log_level(
+ afb_req_t*req,
+ int level);
+```
+
+### afb_req_vverbose
+
+```C
+/**
+ * Send associated to 'req' a message described by 'fmt' and its 'args'
+ * 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 args the arguments to the format
+ *
+ * @see printf
+ * @see afb_req_verbose
+ */
+void afb_req_vverbose(
+ afb_req_t*req,
+ int level, const char *file,
+ int line,
+ const char * func,
+ const char *fmt,
+ va_list args);
+```
+
+### afb_req_verbose
+
+```C
+/**
+ * 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 format 'fmt'
+ *
+ * @see printf
+ */
+void afb_req_verbose(
+ afb_req_t*req,
+ int level, const char *file,
+ int line,
+ const char * func,
+ const char *fmt,
+ ...);
+```
+
+## Arguments/parameters function
+
+### afb_req_get
+
+```C
+/**
+ * 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_value
+ * @see afb_req_path
+ */
+struct afb_arg afb_req_get(
+ afb_req_t*req,
+ const char *name);
+```
+
+### afb_req_value
+
+```C
+/**
+ * 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
+ *
+ * @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_get
+ * @see afb_req_path
+ */
+const char *afb_req_value(
+ afb_req_t*req,
+ const char *name);
+```
+
+### afb_req_path
+
+```C
+/**
+ * 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
+ *
+ * @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_get
+ * @see afb_req_value
+ */
+const char *afb_req_path(
+ afb_req_t*req,
+ const char *name);
+```
+
+### afb_req_json
+
+```C
+/**
+ * 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_get
+ * @see afb_req_value
+ * @see afb_req_path
+ */
+struct json_object *afb_req_json(
+ afb_req_t*req);
+```
+
+## Reply functions
+
+The functions **success** and **fail** are still supported.
+These functions are now implemented as the following macros:
+
+```C
+#define afb_req_success(r,o,i) afb_req_reply(r,o,NULL,i)
+#define afb_req_success_f(r,o,...) afb_req_reply_f(r,o,NULL,__VA_ARGS__)
+#define afb_req_success_v(r,o,f,v) afb_req_reply_v(r,o,NULL,f,v)
+#define afb_req_fail(r,e,i) afb_req_reply(r,NULL,e,i)
+#define afb_req_fail_f(r,e,...) afb_req_reply_f(r,NULL,e,__VA_ARGS__)
+#define afb_req_fail_v(r,e,f,v) afb_req_reply_v(r,NULL,e,f,v)
+```
+
+
+### afb_req_reply
+
+```C
+/**
+ * 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_reply_v
+ * @see afb_req_reply_f
+ */
+void afb_req_reply(
+ afb_req_t*req,
+ struct json_object *obj,
+ const char *error,
+ const char *info);
+```
+
+### afb_req_reply_v
+
+```C
+/**
+ * Same as 'afb_req_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_reply
+ * @see afb_req_reply_f
+ * @see vprintf
+ */
+void afb_req_reply_v(
+ afb_req_t*req,
+ struct json_object *obj,
+ const char *error,
+ const char *info,
+ va_list args);
+```
+
+### afb_req_reply_f
+
+```C
+/**
+ * Same as 'afb_req_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_reply
+ * @see afb_req_reply_v
+ * @see printf
+ */
+void afb_req_reply_f(
+ afb_req_t*req,
+ struct json_object *obj,
+ const char *error,
+ const char *info,
+ ...);
+```
+
+## Subcall functions
+
+
+
+### afb_req_subcall
+
+```C
+/**
+ * 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_subcall_flags_t
+ * @param callback The to call on completion
+ * @param closure The closure to pass to the callback
+ *
+ * The flags are any combination of the following values:
+ *
+ * - afb_req_x2_subcall_catch_events = 1
+ *
+ * the calling API wants to receive the events from subscription
+ *
+ * - afb_req_x2_subcall_pass_events = 2
+ *
+ * the original request will receive the events from subscription
+ *
+ * - afb_req_x2_subcall_on_behalf = 4
+ *
+ * the calling API wants to use the credentials of the original request
+ *
+ * - afb_req_x2_subcall_api_session = 8
+ *
+ * the calling API wants to use its session instead of the one of the
+ * original request
+ *
+ * @see also 'afb_req_subcall_sync'
+ */
+void afb_req_subcall(
+ afb_req_t*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,
+ afb_req_t*req),
+ void *closure);
+```
+
+### afb_req_subcall_sync
+
+```C
+/**
+ * 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_subcall_req' that is convenient to keep request alive automatically.
+ * - 'afb_req_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_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
+ */
+int afb_req_subcall_sync(
+ afb_req_t*req,
+ const char *api,
+ const char *verb,
+ struct json_object *args,
+ int flags,
+ struct json_object **object,
+ char **error,
+ char **info);
+```
+
+## Event functions
+
+### afb_req_subscribe
+
+```C
+/**
+ * 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.
+ */
+int afb_req_subscribe(
+ afb_req_t*req,
+ afb_event_t event);
+```
+
+### afb_req_unsubscribe
+
+```C
+/**
+ * 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.
+ */
+int afb_req_unsubscribe(
+ afb_req_t*req,
+ afb_event_t event);
+```
+
+## Session functions
+
+### afb_req_context
+
+```C
+/**
+ * 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
+ */
+void *afb_req_context(
+ afb_req_t*req,
+ int replace,
+ void *(*create_context)(void *closure),
+ void (*free_context)(void*),
+ void *closure);
+```
+
+### afb_req_context_get
+
+```C
+/**
+ * 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_context(req, 0, NULL, NULL, NULL)
+ *
+ * @param req the request
+ *
+ * @return the previously stored value
+ */
+void *afb_req_context_get(
+ afb_req_t*req);
+```
+
+### afb_req_context_set
+
+```C
+/**
+ * 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_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)
+ */
+void afb_req_context_set(
+ afb_req_t*req,
+ void *context,
+ void (*free_context)(void*));
+```
+
+### afb_req_context_clear
+
+```C
+/**
+ * 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)
+ *
+ * @param req the request
+ */
+void afb_req_context_clear(
+ afb_req_t*req);
+```
+
+### afb_req_session_close
+
+```C
+/**
+ * Closes the session associated with 'req'
+ * and delete all associated contexts.
+ *
+ * @param req the request
+ */
+void afb_req_session_close(
+ afb_req_t*req);
+```
+
+### afb_req_session_set_LOA
+
+```C
+/**
+ * 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.
+ */
+int afb_req_session_set_LOA(
+ afb_req_t*req,
+ unsigned level);
+```
+
+## Credential/client functions
+
+### afb_req_has_permission
+
+```C
+/**
+ * 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.
+ */
+int afb_req_has_permission(
+ afb_req_t*req,
+ const char *permission);
+```
+
+### afb_req_get_application_id
+
+```C
+/**
+ * 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
+ */
+char *afb_req_get_application_id(
+ afb_req_t*req);
+```
+
+### afb_req_get_uid
+
+```C
+/**
+ * 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.
+ *
+ */
+int afb_req_get_uid(
+ afb_req_t*req);
+```
+
+### afb_req_get_client_info
+
+```C
+/**
+ * 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
+ */
+struct json_object *afb_req_get_client_info(
+ afb_req_t*req);
+```
+
+## Legacy functions
+
+### afb_req_subcall_legacy
+
+```C
+/**
+ * @deprecated use @ref afb_req_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_subcall
+ * @see afb_req_subcall_sync
+ */
+void afb_req_subcall_legacy(
+ afb_req_t*req,
+ const char *api,
+ const char *verb,
+ struct json_object *args,
+ void (*callback)(
+ void *closure,
+ int iserror,
+ struct json_object *result,
+ afb_req_t*req),
+ void *closure);
+```
+
+### afb_req_subcall_sync_legacy
+
+```C
+/**
+ * @deprecated use @ref afb_req_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_subcall
+ * @see afb_req_subcall_sync
+ */
+int afb_req_subcall_sync_legacy(
+ afb_req_t*req,
+ const char *api,
+ const char *verb,
+ struct json_object *args,
+ struct json_object **result);
+```
+
--- /dev/null
+Functions of class afb_service
+==============================
+
+All the functions of the class **afb_daemon** use the default api.
+This are internally aliased to the corresponding legacy function of
+class **afb_api**.
+
+```C
+/**
+ * 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 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'
+ */
+void afb_service_call(
+ const char *api,
+ const char *verb,
+ struct json_object *args,
+ void (*callback)(void*closure, int status, struct json_object *result),
+ void *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 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'
+ */
+int afb_service_call_sync(
+ const char *api,
+ const char *verb,
+ struct json_object *args,
+ struct json_object **result);
+```
\ No newline at end of file
--- /dev/null
+Macro for logging
+=================
+
+The final behaviour of macros can be tuned using 2 defines that must be defined
+before including **<afb/afb-binding.h>**.
+
+| define | action
+|---------------------------------------|--------------------
+| AFB_BINDING_PRAGMA_NO_VERBOSE_DATA | show file and line, remove function and text message
+| AFB_BINDING_PRAGMA_NO_VERBOSE_DETAILS | show text, remove function, line and file
+
+## Logging for an api
+
+The following macros must be used for logging for an **api** of type
+**afb_api_t**.
+
+```C
+AFB_API_ERROR(api,fmt,...)
+AFB_API_WARNING(api,fmt,...)
+AFB_API_NOTICE(api,fmt,...)
+AFB_API_INFO(api,fmt,...)
+AFB_API_DEBUG(api,fmt,...)
+```
+
+## Logging for a request
+
+
+The following macros can be used for logging in the context
+of a request **req** of type **afb_req_t**:
+
+```C
+AFB_REQ_ERROR(req,fmt,...)
+AFB_REQ_WARNING(req,fmt,...)
+AFB_REQ_NOTICE(req,fmt,...)
+AFB_REQ_INFO(req,fmt,...)
+AFB_REQ_DEBUG(req,fmt,...)
+```
+
+By default, the logging macros add file, line and function
+indication.
+
+## Logging legacy
+
+The following macros are provided for legacy.
+
+```C
+AFB_ERROR(fmt,...)
+AFB_WARNING(fmt,...)
+AFB_NOTICE(fmt,...)
+AFB_INFO(fmt,...)
+AFB_DEBUG(fmt,...)
+```
+
--- /dev/null
+# Types and globals
+
+## The global afbBindingRoot
+
+The global **afbBindingRoot** of type **afb_api_t** is always implicitely
+defined for bindings of version 3 or upper. It records the root api of
+the binding.
+
+When the binding has a defined **afbBindingExport**, the root api
+**afbBindingRoot** is the **afb_pi_t** relative to the api created for
+this static description.
+
+When the binding has no defined **afbBindingExport**, the root api is
+a virtual api representing the shared object of the binding. In that case
+the name of the api is the path of the shared object. Its use is restricted
+but allows log messages.
+
+## The global afbBindingExport
+
+The global **afbBindingExport** is not mandatory.
+
+If **afbBindingExport** is defined and exported, it must be of the type
+**const afb_binding_t** and must describe the *root* api of the binding.
+
+## The type afb_api_t
+
+Bindings now can declare more than one api. The counter part is that
+a new handle is needed to manage apis. These handles are of the type
+**afb_api_t**.
+
+It is defined as below.
+
+```C
+typedef struct afb_api_x3 afb_api_t;
+```
+
+## The type afb_binding_t
+
+The main structure, of type **afb_binding_t**, for describing the binding
+must be exported under the name **afbBindingExport**.
+
+This structure is defined as below.
+
+```C
+typedef struct afb_binding_v3 afb_binding_t;
+```
+
+Where:
+
+```C
+/**
+ * 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;
+};
+```
+
+## The type afb_verb_t
+
+Each verb is described with a structure of type **afb_verb_t**
+defined below:
+
+```C
+typedef struct afb_verb_v3 afb_verb_t;
+```
+
+```C
+/**
+ * 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)(afb_req_t_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;
+};
+```
+
+The **session** flags is one of the constant defined below:
+
+| Name | Description
+|:----------------------:|------------------------------------------------------
+| AFB_SESSION_NONE | no flag, synonym to 0
+| AFB_SESSION_LOA_0 | Requires the LOA to be 0 or more, synonym to 0 or AFB_SESSION_NONE
+| AFB_SESSION_LOA_1 | Requires the LOA to be 1 or more
+| AFB_SESSION_LOA_2 | Requires the LOA to be 2 or more
+| AFB_SESSION_LOA_3 | Requires the LOA to be 3 or more
+| AFB_SESSION_CHECK | Requires the token to be set and valid
+| AFB_SESSION_REFRESH | Implies a token refresh
+| AFB_SESSION_CLOSE | Implies closing the session after request processed
+
+The LOA (Level Of Assurance) is set, by binding api, using the function **afb_req_session_set_LOA**.
+
+The session can be closed, by binding api, using the function **afb_req_session_close**.
+
+## The types afb_auth_t and afb_auth_type_t
+
+The structure **afb_auth_t** is used within verb description to
+set security requirements.
+The interpretation of the structure depends on the value of the field **type**.
+
+```C
+typedef struct afb_auth afb_auth_t;
+
+/**
+ * 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;
+};
+
+```
+
+The possible values for **type** is defined here:
+
+```C
+typedef enum afb_auth_type afb_auth_type_t;
+
+/**
+ * Enumeration for authority (Session/Token/Assurance) definitions.
+ *
+ * @see afb_auth
+ */
+enum afb_auth_type
+{
+ /** 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
+};
+```
+
+Example:
+
+```C
+static const afb_auth_t myauth[] = {
+ { .type = afb_auth_Permission, .text = "urn:AGL:permission:me:public:set" },
+ { .type = afb_auth_Permission, .text = "urn:AGL:permission:me:public:get" },
+ { .type = afb_auth_Or, .first = &myauth[1], .next = &myauth[0] }
+};
+```
+
+
+## The type afb_req_subcall_flags_t
+
+This is an enumeration that defines bit's positions for setting behaviour
+of subcalls.
+
+| flag | value | description
+|----------------------------|-------|--------------
+| afb_req_subcall_catch_events | 1 | the calling API wants to receive the events from subscription
+| afb_req_subcall_pass_events | 2 | the original request will receive the events from subscription
+| afb_req_subcall_on_behalf | 4 | the calling API wants to use the credentials of the original request
+| afb_req_subcall_api_session | 8 | the calling API wants to use its session instead of the one of the original request
+
# entered, it will be relative to the location where doxygen was started. If
# left blank the current directory will be used.
-OUTPUT_DIRECTORY = ./docs/binder
+OUTPUT_DIRECTORY = ./doxygen-output/binder
# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
# directories (in 2 levels) under the output directory of each output format and
# entered, it will be relative to the location where doxygen was started. If
# left blank the current directory will be used.
-OUTPUT_DIRECTORY = ./docs/binding
+OUTPUT_DIRECTORY = ./doxygen-output/binding
# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
# directories (in 2 levels) under the output directory of each output format and
struct afb_verb_v2;
struct afb_verb_v3;
+/** @addtogroup AFB_API
+ * @{ */
+
/**
* Structure for the APIv3
*/
struct afb_api_x3 *api);
};
+/** @} */
#include "afb-verbosity.h"
#include "afb-api-x3-itf.h"
+/** @defgroup AFB_API
+ * @{ */
+
/**
* Get 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)
+const char *afb_api_x3_name(
+ struct afb_api_x3 *api)
{
return api->apiname;
}
* @see afb_api_x3_set_userdata
*/
static inline
-void *afb_api_x3_get_userdata(struct afb_api_x3 *api)
+void *afb_api_x3_get_userdata(
+ struct afb_api_x3 *api)
{
return api->userdata;
}
* @see afb_api_x3_get_userdata
*/
static inline
-void afb_api_x3_set_userdata(struct afb_api_x3 *api, void *value)
+void afb_api_x3_set_userdata(
+ struct afb_api_x3 *api,
+ void *value)
{
api->userdata = value;
}
* @see syslog
*/
static inline
-int afb_api_x3_wants_log_level(struct afb_api_x3 *api, int level)
+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
+ * Send to the journal with the logging '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
+ * 'file', 'line' and 'func' are indicators of code position in source files
* (see macros __FILE__, __LINE__ and __func__).
*
* 'level' is defined by syslog standard:
* @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 func the name of the function in the source file that logs (or NULL)
* @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 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)
+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);
}
* @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 func the name of the function in the source file that logs (or NULL)
* @param fmt the format of the message as in printf
* @param ... the arguments to the format string of the message
*
* @see afb_api_x3_get_system_bus
*/
static inline
-struct sd_event *afb_api_x3_get_event_loop(struct afb_api_x3 *api)
+struct sd_event *afb_api_x3_get_event_loop(
+ struct afb_api_x3 *api)
{
return api->itf->get_event_loop(api);
}
* @see afb_api_x3_get_system_bus
*/
static inline
-struct sd_bus *afb_api_x3_get_user_bus(struct afb_api_x3 *api)
+struct sd_bus *afb_api_x3_get_user_bus(
+ struct afb_api_x3 *api)
{
return api->itf->get_user_bus(api);
}
*/
static inline
-struct sd_bus *afb_api_x3_get_system_bus(struct afb_api_x3 *api)
+struct sd_bus *afb_api_x3_get_system_bus(
+ struct afb_api_x3 *api)
{
return api->itf->get_system_bus(api);
}
* 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);
+ * char buffer[MAX_PATH], proc[100];
+ * int dirfd = afb_api_rootdir_get_fd(api);
+ * snprintf(proc, sizeof proc, "/proc/self/fd/%d", dirfd);
+ * readlink(proc, buffer, sizeof buffer);
* ```
*
* But note that within AGL this is the value given by the environment variable
* @see afb_api_x3_rootdir_open_locale
*/
static inline
-int afb_api_x3_rootdir_get_fd(struct afb_api_x3 *api)
+int afb_api_x3_rootdir_get_fd(
+ struct afb_api_x3 *api)
{
return api->itf->rootdir_get_fd(api);
}
* @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)
+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);
}
* - 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:
+ * A typical implementation 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));
+ * AFB_API_ERROR(myarg->api, "job interrupted with signal %s", strsignal(signum));
* else
* really_do_my_job(myarg);
* }
* @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)
+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.
+ * Check that it requires the API of 'name'.
+ * If 'initialized' is not zero it request the API to be
+ * initialized, implying its initialization if needed.
+ *
* 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 name a space separated list of required api names
* @param initialized if zero, the api is just required to exist. If not zero,
- * the api is required to exist and to be initialized.
+ * the api is required to exist and to be initialized at return of the call
+ * (initializing it if needed and possible as a side effect of the call).
*
* @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)
+int afb_api_x3_require_api(
+ struct afb_api_x3 *api,
+ const char *name,
+ int initialized)
{
return api->itf->require_api(api, name, initialized);
}
* @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)
+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);
}
* @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)
+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);
}
* @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)
+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);
}
*/
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)
+ 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);
}
*/
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)
+ 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);
}
*/
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)
+ 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);
}
*/
static inline
int afb_api_x3_set_verbs_v2(
- struct afb_api_x3 *api,
- const struct afb_verb_v2 *verbs)
+ struct afb_api_x3 *api,
+ const struct afb_verb_v2 *verbs)
{
return api->itf->api_set_verbs_v2(api, verbs);
}
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))
+ void (*onevent)(
+ struct afb_api_x3 *api,
+ const char *event,
+ struct json_object *object))
{
return api->itf->api_set_on_event(api, onevent);
}
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 (*callback)(
+ void *,
+ const char*,
+ struct json_object*,
+ struct afb_api_x3*),
void *closure)
{
return api->itf->event_handler_add(api, pattern, callback, closure);
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 (*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);
* 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
+ * @param name a space separated list of the names of the required classes
*
* @returns 0 in case of success or a negative value in case of error.
*
{
return api->itf->delete_api(api);
}
+
+/** @} */
#pragma once
+/** @addtogroup AFB_REQ
+ * @{ */
+
/**
* Describes an argument (or parameter) of a request.
*
/**< when the request is finalized this file is removed */
};
+
+/** @} */
#pragma once
+/** @defgroup AFB_AUTH
+ * @{ */
+
+
/**
* Enumeration for authority (Session/Token/Assurance) definitions.
*
const struct afb_auth *next;
};
+/** @} */
\ No newline at end of file
typedef struct afb_event_x2 *afb_event_t;
typedef struct afb_req_x2 *afb_req_t;
typedef struct afb_api_x3 *afb_api_t;
+typedef enum afb_req_subcall_flags afb_req_subcall_flags_t;
#define afbBindingExport afbBindingV3
+#define afbBindingRoot afbBindingV3root
+#define afbBindingEntry afbBindingV3entry
/* compatibility with previous versions */
#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_flags afb_req_subcall_flags
#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_req_x2_subcall_api_session afb_req_subcall_api_session
+
#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_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__)
+#define afb_service_call_v3(...) afb_api_call(afbBindingV3root,__VA_ARGS__)
+#define afb_service_call_sync_v3(...) afb_api_call_sync(afbBindingV3root,__VA_ARGS__)
{ 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)
+inline void call(const char *api, const char *verb, struct json_object *args, void (*callback)(void*closure, struct json_object *result, const char *error, const char *info, 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)
+inline void call(const char *api, const char *verb, struct json_object *args, void (*callback)(T*closure, struct json_object *result, const char *error, const char *info, 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));
}
+
+inline bool callsync(const char *api, const char *verb, struct json_object *args, struct json_object *&result, char *&error, char *&info)
+{
+ return !!afb_service_call_sync(api, verb, args, &result, &error, &info);
+}
#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, 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)
{
return !!afb_service_call_sync(api, verb, args, &result);
}
+#endif
/*************************************************************************/
/* declaration of the binding's authorization s */
struct afb_event_x1;
struct afb_api_x3;
+/** @defgroup AFB_DAEMON
+ * @{ */
+
/**
* @deprecated use bindings version 3
*
struct afb_api_x3 *closure; /**< the closure when calling these functions */
};
+/** @} */
#include "afb-daemon-itf-x1.h"
+/** @addtogroup AFB_DAEMON
+ * @{ */
+
/**
* @deprecated use bindings version 3
*
{
return -!daemon.itf->new_api(daemon.closure, api, info, noconcurrency, preinit, closure);
}
+
+/** @} */
#include "afb-daemon-itf-x1.h"
+/** @addtogroup AFB_DAEMON
+ * @{ */
+
/**
* @deprecated use bindings version 3
*
return -!(afb_get_daemon_v2().itf->new_api(afb_get_daemon_v2().closure, api, info, noconcurrency, preinit, closure));
}
+/** @} */
+
#include "afb-event-x2-itf.h"
+/** @addtogroup AFB_EVENT
+ * @{ */
+
/**
* @deprecated use bindings version 3
*
struct afb_event_x2 *closure; /**< the closure argument for functions of 'itf' */
};
+/** @} */
#include "afb-event-x1-itf.h"
+/** @addtogroup AFB_EVENT
+ * @{ */
+
/**
* @deprecated use bindings version 3
*
event.itf->addref(event.closure);
}
+/** @} */
struct afb_event_x2;
struct afb_event_x2_itf;
+/** @addtogroup AFB_EVENT
+ * @{ */
+
/**
* Interface for handling event_x2.
*
const struct afb_event_x2_itf *itf; /**< the interface functions to use */
};
+/** @} */
#include "afb-event-x2-itf.h"
+/** @defgroup AFB_EVENT
+ * @{ */
+
/**
* Checks whether the 'event' is valid or not.
*
return event->itf->addref(event);
}
+/** @} */
#include <stdlib.h>
#include "afb-req-x1.h"
+/** @addtogroup AFB_REQ
+ * @{ */
+
/**
* @deprecated use bindings version 3
*
return result;
}
+
+/** @} */
#include "afb-req-x1.h"
+/** @addtogroup AFB_REQ
+ * @{ */
+
/**
* @deprecated use bindings version 3
*
return req.itf->legacy_store_req(req.closure);
}
+
+/** @} */
#include "afb-req-x2-itf.h"
+/** @addtogroup AFB_REQ
+ * @{ */
+
/**
* @deprecated use bindings version 3
*
struct afb_req_x2 *closure; /**< the closure argument for functions of 'itf' */
};
+
+/** @} */
#include "afb-req-x1-itf.h"
#include "afb-event-x1.h"
+/** @addtogroup AFB_REQ
+ * @{ */
+
/**
* @deprecated use bindings version 3
*
}
+
+/** @} */
struct afb_api_x3;
struct afb_stored_req;
+/** @addtogroup AFB_REQ
+ * @{ */
+
/**
* structure for the request
*/
};
/**
- * subcall modes
+ * subcall flags
*
* When making subcalls, it is now possible to explicitely set the subcall
- * mode to a combination of the following mode using binary OR.
+ * mode to a combination of the following flags using binary OR.
*
- * In particular, the following combination of modes are to be known:
+ * In particular, the following combination of flags 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
*
char **info);
};
+
+/** @} */
#include "afb-req-x2-itf.h"
#include "afb-api-x3.h"
+/** @defgroup AFB_REQ
+ * @{ */
+
/**
* Checks whether the request 'req' is valid or not.
*
return req->itf->legacy_subcallsync(req, api, verb, args, result);
}
+/**
+ * Send associated to 'req' a message described by 'fmt' and its 'args'
+ * 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 args the arguments to the format 'fmt'
+ *
+ * @see printf
+ * @see afb_req_x2_verbose
+ */
+static inline
+void afb_req_x2_vverbose(
+ struct afb_req_x2 *req,
+ int level, const char *file,
+ int line,
+ const char * func,
+ const char *fmt,
+ va_list args)
+{
+ req->itf->vverbose(req, level, file, line, func, fmt, args);
+}
+
/**
* Send associated to 'req' a message described by 'fmt' and following parameters
* to the journal for the verbosity 'level'.
* @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
+ * @param ... the arguments of the format 'fmt'
*
* @see printf
+ * @see afb_req_x2_vverbose
*/
__attribute__((format(printf, 6, 7)))
static inline
{
va_list args;
va_start(args, fmt);
- req->itf->vverbose(req, level, file, line, func, fmt, args);
+ afb_req_x2_verbose(req, level, file, line, func, fmt, args);
va_end(args);
}
{
return req->itf->subcallsync(req, api, verb, args, flags, object, error, info);
}
+
+
+/** @} */
struct afb_api_x3;
+/** @defgroup AFB_SERVICE
+ * @{ */
+
/**
* @deprecated use bindings version 3
*
struct afb_api_x3 *closure;
};
+/** @} */
#include "afb-service-itf-x1.h"
+/** @addtogroup AFB_SERVICE
+ * @{ */
+
/**
* @deprecated use bindings version 3
*
return service.itf->call_sync(service.closure, api, verb, args, result);
}
+/** @} */
#include "afb-service-itf-x1.h"
+/** @addtogroup AFB_SERVICE
+ * @{ */
+
/**
* @deprecated use bindings version 3
*
return afb_get_service_v2().itf->call_sync(afb_get_service_v2().closure, api, verb, args, result);
}
+/** @} */
#pragma once
-#define AFB_VERBOSITY_LEVEL_ERROR 0
-#define AFB_VERBOSITY_LEVEL_WARNING 1
-#define AFB_VERBOSITY_LEVEL_NOTICE 2
-#define AFB_VERBOSITY_LEVEL_INFO 3
-#define AFB_VERBOSITY_LEVEL_DEBUG 4
+/** @defgroup AFB_LOGGING
+ * @{ */
+
+#define AFB_VERBOSITY_LEVEL_ERROR 0 /**< @deprecated in favor of @ref AFB_SYSLOG_LEVEL_ERROR */
+#define AFB_VERBOSITY_LEVEL_WARNING 1 /**< @deprecated in favor of @ref AFB_SYSLOG_LEVEL_WARNING */
+#define AFB_VERBOSITY_LEVEL_NOTICE 2 /**< @deprecated in favor of @ref AFB_SYSLOG_LEVEL_NOTICE */
+#define AFB_VERBOSITY_LEVEL_INFO 3 /**< @deprecated in favor of @ref AFB_SYSLOG_LEVEL_INFO */
+#define AFB_VERBOSITY_LEVEL_DEBUG 4 /**< @deprecated in favor of @ref AFB_SYSLOG_LEVEL_DEBUG */
#define AFB_SYSLOG_LEVEL_EMERGENCY 0
#define AFB_SYSLOG_LEVEL_ALERT 1
#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(verbosity,level) ((verbosity) >= (level)) /**< @deprecated in favor of @ref AFB_SYSLOG_MASK_WANT */
-#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_VERBOSITY_LEVEL_WANT_ERROR(x) AFB_VERBOSITY_LEVEL_WANT(x,AFB_VERBOSITY_LEVEL_ERROR) /**< @deprecated in favor of @ref AFB_SYSLOG_MASK_WANT_ERROR */
+#define AFB_VERBOSITY_LEVEL_WANT_WARNING(x) AFB_VERBOSITY_LEVEL_WANT(x,AFB_VERBOSITY_LEVEL_WARNING) /**< @deprecated in favor of @ref AFB_SYSLOG_MASK_WANT_WARNING */
+#define AFB_VERBOSITY_LEVEL_WANT_NOTICE(x) AFB_VERBOSITY_LEVEL_WANT(x,AFB_VERBOSITY_LEVEL_NOTICE) /**< @deprecated in favor of @ref AFB_SYSLOG_MASK_WANT_NOTICE */
+#define AFB_VERBOSITY_LEVEL_WANT_INFO(x) AFB_VERBOSITY_LEVEL_WANT(x,AFB_VERBOSITY_LEVEL_INFO) /**< @deprecated in favor of @ref AFB_SYSLOG_MASK_WANT_INFO */
+#define AFB_VERBOSITY_LEVEL_WANT_DEBUG(x) AFB_VERBOSITY_LEVEL_WANT(x,AFB_VERBOSITY_LEVEL_DEBUG) /**< @deprecated in favor of @ref AFB_SYSLOG_MASK_WANT_DEBUG */
#define AFB_SYSLOG_MASK_WANT(verbomask,level) ((verbomask) & (1 << (level)))
#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))
+/**
+ * Transform a mask of verbosity to its significant level of verbosity.
+ *
+ * @param verbomask the mask
+ *
+ * @return the upper level that is not null, truncated to AFB_SYSLOG_LEVEL_DEBUG
+ *
+ * @example _afb_verbomask_to_upper_level_(5) -> 2
+ * @example _afb_verbomask_to_upper_level_(16) -> 4
+ */
static inline int _afb_verbomask_to_upper_level_(int verbomask)
{
int result = 0;
return result;
}
+/** @} */
\ No newline at end of file
site_name: AGL Framework Binder
theme: readthedocs
docs_dir: docs
+# tr '*])([' "-''''" < docs/SUMMARY.md | sed "s/^\(.*'\)'/ \1: '/"
pages:
- 'Overview' : 'index.md'
+ - 'Binder Overview': 'afb-introduction.md'
+ - 'Binder daemon vocabulary': 'afb-daemon-vocabulary.md'
- 'How to write a binding ?': 'afb-binding-writing.md'
- - 'Binding references': 'afb-binding-references.md'
- - 'Migration from v1 to v2' : 'afb-migration-v1-to-v2.md'
- - 'Binder events guide' : 'afb-events-guide.md'
- - 'Binder Application writing guide' : 'afb-application-writing.md'
- - 'Binder daemon vocabulary' : 'afb-daemon-vocabulary.md'
- - 'Annexes':
+ - 'Binding references':
+ - 'Types and globals': 'reference-v3/types-and-globals.md'
+ - 'Functions of class afb_api': 'reference-v3/func-api.md'
+ - 'Functions of class afb_req': 'reference-v3/func-req.md'
+ - 'Functions of class afb_event': 'reference-v3/func-event.md'
+ - 'Functions of class afb_daemon': 'reference-v3/func-daemon.md'
+ - 'Functions of class afb_service': 'reference-v3/func-service.md'
+ - 'Macros for logging': 'reference-v3/macro-log.md'
+ - 'Binder events guide': 'afb-events-guide.md'
+ - 'Binder Application writing guide': 'afb-application-writing.md'
+ - 'Annexes':
+ - 'Migration to binding v3': 'afb-migration-to-binding-v3.md'
+ - 'WebSocket protocol x-afb-ws-json1': 'protocol-x-afb-ws-json1.md'
- 'Installing the binder on a desktop': 'afb-desktop-package.md'
- - 'Options of afb-daemon' : 'afb-daemon-options.md'
+ - 'Options of afb-daemon': 'afb-daemon-options.md'
+ - 'Debugging binder and bindings': 'afb-daemon-debugging.md'
+ - 'LEGACY Guide to migrate bindings from v1 to v2': 'legacy/afb-migration-v1-to-v2.md'
+ - 'LEGACY Binding V2 references': 'legacy/afb-binding-v2-references.md'
+ - 'Document revisions': 'REVISIONS.md'
return 0;
}
+/*******************************************************************/
+
static int create_ws(const char *path, struct afb_apiset *declare_set, struct afb_apiset *call_set)
{
return afb_api_ws_add_client(path, declare_set, call_set, 0) >= 0;
return add(path, declare_set, call_set, onlack_ws);
}
+/*******************************************************************/
+
static int create_so(const char *path, struct afb_apiset *declare_set, struct afb_apiset *call_set)
{
return afb_api_so_add_binding(path, declare_set, call_set) >= 0;
{
return add(path, declare_set, call_set, onlack_so);
}
+
+/*******************************************************************/
+
+static int create_any(const char *path, struct afb_apiset *declare_set, struct afb_apiset *call_set)
+{
+ int rc;
+ struct stat st;
+
+ rc = stat(path, &st);
+ if (!rc) {
+ switch(st.st_mode & S_IFMT) {
+ case S_IFREG:
+ rc = afb_api_so_add_binding(path, declare_set, call_set);
+ break;
+ case S_IFSOCK:
+ rc = afb_api_ws_add_client(path, declare_set, call_set, 0);
+ break;
+ default:
+ NOTICE("Unexpected autoset entry: %s", path);
+ rc = -1;
+ break;
+ }
+ }
+ return rc >= 0;
+}
+
+static int onlack_any(void *closure, struct afb_apiset *set, const char *name)
+{
+ return onlack(closure, set, name, create_any);
+}
+
+int afb_autoset_add_any(const char *path, struct afb_apiset *declare_set, struct afb_apiset *call_set)
+{
+ return add(path, declare_set, call_set, onlack_any);
+}
extern int afb_autoset_add_ws(const char *path, struct afb_apiset *declare_set, struct afb_apiset *call_set);
extern int afb_autoset_add_so(const char *path, struct afb_apiset *declare_set, struct afb_apiset *call_set);
+extern int afb_autoset_add_any(const char *path, struct afb_apiset *declare_set, struct afb_apiset *call_set);
#include "afb-config.h"
#include "afb-hook.h"
+#define _d2s_(x) #x
+#define d2s(x) _d2s_(x)
+
#if !defined(BINDING_INSTALL_DIR)
#error "you should define BINDING_INSTALL_DIR"
#endif
*/
#define DEFAULT_MAX_SESSION_COUNT 200
+/**
+ * The default HTTP port to serve
+ */
+#define DEFAULT_HTTP_PORT 1234
+
+
+
+
+
// Define command line option
-#define SET_BACKGROUND 2
-#define SET_FORGROUND 3
+#define SET_BACKGROUND 1
+#define SET_FORGROUND 2
+#define SET_ROOT_DIR 3
+#define SET_ROOT_BASE 4
+#define SET_ROOT_API 5
+#define SET_ALIAS 6
-#define SET_ROOT_DIR 6
-#define SET_ROOT_BASE 7
-#define SET_ROOT_API 8
-#define SET_ALIAS 9
+#define SET_CACHE_TIMEOUT 7
-#define SET_CACHE_TIMEOUT 10
-#define SET_SESSION_DIR 11
+#define AUTO_WS 8
+#define AUTO_LINK 9
-#define SET_LDPATH 13
-#define SET_APITIMEOUT 14
-#define SET_CNTXTIMEOUT 15
-#define SET_WEAK_LDPATH 16
-#define NO_LDPATH 17
+#define SET_LDPATH 10
+#define SET_APITIMEOUT 11
+#define SET_CNTXTIMEOUT 12
+#define SET_WEAK_LDPATH 13
+#define NO_LDPATH 14
-#if defined(KEEP_LEGACY_MODE)
-#define SET_MODE 18
-#endif
+#define SET_SESSIONMAX 15
-#if HAS_DBUS
-# define DBUS_CLIENT 20
-# define DBUS_SERVICE 21
-#endif
+#define WS_CLIENT 16
+#define WS_SERVICE 17
+#define SET_ROOT_HTTP 18
-#define SET_SESSIONMAX 23
+#define SET_NO_HTTPD 19
-#define WS_CLIENT 24
-#define WS_SERVICE 25
+#define SET_TRACEEVT 20
+#define SET_TRACESES 21
+#define SET_TRACEREQ 22
+#define SET_TRACEAPI 23
+#if !defined(REMOVE_LEGACY_TRACE)
+#define SET_TRACEDITF 24
+#define SET_TRACESVC 25
+#endif
-#define SET_ROOT_HTTP 26
+#if HAS_DBUS
+# define DBUS_CLIENT 30
+# define DBUS_SERVICE 31
+#endif
-#define SET_NO_HTTPD 28
-#define AUTO_WS 'a'
-#define AUTO_LINK 'A'
+#define AUTO_API 'A'
#define SO_BINDING 'b'
#define ADD_CALL 'c'
-#if !defined(REMOVE_LEGACY_TRACE)
-#define SET_TRACEDITF 'D'
-#endif
-#define SET_TRACEEVT 'E'
#define SET_EXEC 'e'
#define DISPLAY_HELP 'h'
#define SET_LOG 'l'
-#define SET_TRACEAPI 'I'
#if HAS_MONITORING
-# define SET_MONITORING 'M'
+#define SET_MONITORING 'M'
#endif
#define SET_NAME 'n'
#define SET_TCP_PORT 'p'
#define SET_QUIET 'q'
#define SET_RNDTOKEN 'r'
-#if !defined(REMOVE_LEGACY_TRACE)
-#define SET_TRACESVC 'S'
-#endif
-#define SET_TRACESES 's'
-#define SET_TRACEREQ 'T'
#define SET_AUTH_TOKEN 't'
#define SET_UPLOAD_DIR 'u'
#define DISPLAY_VERSION 'V'
#define SET_WORK_DIR 'w'
const char shortopts[] =
- "a:A:b:c:"
-#if !defined(REMOVE_LEGACY_TRACE)
- "D:"
-#endif
- "E:ehl:n:p:qr"
-#if !defined(REMOVE_LEGACY_TRACE)
- "S:"
-#endif
- "s:T:t:u:Vvw:"
+ "A:"
+ "b:"
+ "c:"
+ "e"
+ "h"
+ "l:"
#if HAS_MONITORING
"M"
#endif
+ "n:"
+ "p:"
+ "q"
+ "r"
+ "t:"
+ "u:"
+ "V"
+ "v"
+ "w:"
;
// Command line structure hold cli --command + help text
/* *INDENT-OFF* */
{SET_VERBOSE, 0, "verbose", "Verbose Mode, repeat to increase verbosity"},
{SET_QUIET, 0, "quiet", "Quiet Mode, repeat to decrease verbosity"},
- {SET_LOG, 1, "log", "tune log level"},
+ {SET_LOG, 1, "log", "Tune log level"},
{SET_FORGROUND, 0, "foreground", "Get all in foreground mode"},
{SET_BACKGROUND, 0, "daemon", "Get all in background mode"},
{SET_NAME, 1, "name", "Set the visible name"},
- {SET_TCP_PORT, 1, "port", "HTTP listening TCP port [default 1234]"},
+ {SET_TCP_PORT, 1, "port", "HTTP listening TCP port [default " d2s(DEFAULT_HTTP_PORT) "]"},
{SET_ROOT_HTTP, 1, "roothttp", "HTTP Root Directory [default no root http (files not served but apis still available)]"},
{SET_ROOT_BASE, 1, "rootbase", "Angular Base Root URL [default /opa]"},
{SET_ROOT_API, 1, "rootapi", "HTML Root API URL [default /api]"},
{SET_ALIAS, 1, "alias", "Multiple url map outside of rootdir [eg: --alias=/icons:/usr/share/icons]"},
- {SET_APITIMEOUT, 1, "apitimeout", "Binding API timeout in seconds [default 10]"},
- {SET_CNTXTIMEOUT, 1, "cntxtimeout", "Client Session Context Timeout [default 900]"},
- {SET_CACHE_TIMEOUT, 1, "cache-eol", "Client cache end of live [default 3600]"},
+ {SET_APITIMEOUT, 1, "apitimeout", "Binding API timeout in seconds [default " d2s(DEFAULT_API_TIMEOUT) "]"},
+ {SET_CNTXTIMEOUT, 1, "cntxtimeout", "Client Session Context Timeout [default " d2s(DEFAULT_SESSION_TIMEOUT) "]"},
+ {SET_CACHE_TIMEOUT, 1, "cache-eol", "Client cache end of live [default " d2s(DEFAULT_CACHE_TIMEOUT) "]"},
{SET_WORK_DIR, 1, "workdir", "Set the working directory [default: $PWD or current working directory]"},
{SET_UPLOAD_DIR, 1, "uploaddir", "Directory for uploading files [default: workdir]"},
{SET_ROOT_DIR, 1, "rootdir", "Root Directory of the application [default: workdir]"},
- {SET_SESSION_DIR, 1, "sessiondir", "OBSOLETE (was: Sessions file path)"},
{SET_LDPATH, 1, "ldpaths", "Load bindings from dir1:dir2:... [default = " BINDING_INSTALL_DIR "]"},
{SO_BINDING, 1, "binding", "Load the binding of path"},
{DISPLAY_VERSION, 0, "version", "Display version and copyright"},
{DISPLAY_HELP, 0, "help", "Display this help"},
-#if defined(KEEP_LEGACY_MODE)
- {SET_MODE, 1, "mode", "Set the mode: either local, remote or global"},
-#endif
-
#if HAS_DBUS
{DBUS_CLIENT, 1, "dbus-client", "Bind to an afb service through dbus"},
- {DBUS_SERVICE, 1, "dbus-server", "Provides an afb service through dbus"},
+ {DBUS_SERVICE, 1, "dbus-server", "Provide an afb service through dbus"},
#endif
{WS_CLIENT, 1, "ws-client", "Bind to an afb service through websocket"},
- {WS_SERVICE, 1, "ws-server", "Provides an afb service through websockets"},
+ {WS_SERVICE, 1, "ws-server", "Provide an afb service through websockets"},
- {AUTO_WS, 1, "auto-ws", "Automatic bind on need to remote service through websocket"},
- {AUTO_LINK, 1, "auto-link", "Automatic load on need to binding shared objects"},
+ {AUTO_API, 1, "auto-api", "Automatic load of api of the given directory"},
- {SET_SESSIONMAX, 1, "session-max", "Max count of session simultaneously [default 10]"},
+ {SET_SESSIONMAX, 1, "session-max", "Max count of session simultaneously [default " d2s(DEFAULT_MAX_SESSION_COUNT) "]"},
{SET_TRACEREQ, 1, "tracereq", "Log the requests: no, common, extra, all"},
#if !defined(REMOVE_LEGACY_TRACE)
{ADD_CALL, 1, "call", "call at start format of val: API/VERB:json-args"},
- {SET_NO_HTTPD, 0, "no-httpd", "Forbids HTTP service"},
+ {SET_NO_HTTPD, 0, "no-httpd", "Forbid HTTP service"},
{SET_EXEC, 0, "exec", "Execute the remaining arguments"},
#if HAS_MONITORING
- {SET_MONITORING, 0, "monitoring", "enable HTTP monitoring at <ROOT>/monitoring/"},
+ {SET_MONITORING, 0, "monitoring", "Enable HTTP monitoring at <ROOT>/monitoring/"},
#endif
{0, 0, NULL, NULL}
/* *INDENT-ON* */
{ NULL, 0 }
};
-#if defined(KEEP_LEGACY_MODE)
-#include <afb/afb-binding-v1.h>
-
-static struct enumdesc mode_desc[] = {
- { "local", AFB_MODE_LOCAL },
- { "remote", AFB_MODE_REMOTE },
- { "global", AFB_MODE_GLOBAL },
- { NULL, 0 }
-};
-#endif
-
/*----------------------------------------------------------
| printversion
| print version and copyright
static void printHelp(FILE * file, const char *name)
{
int ind;
- char command[50];
+ char command[50], sht[4];
+ sht[3] = 0;
fprintf(file, "%s:\nallowed options\n", name);
for (ind = 0; cliOptions[ind].name != NULL; ind++) {
+ if (((cliOptions[ind].val >= 'a' && cliOptions[ind].val <= 'z')
+ || (cliOptions[ind].val >= 'A' && cliOptions[ind].val <= 'Z')
+ || (cliOptions[ind].val >= '0' && cliOptions[ind].val <= '9'))
+ && strchr(shortopts, (char)cliOptions[ind].val)) {
+ sht[0] = '-';
+ sht[1] = (char)cliOptions[ind].val;
+ sht[2] = ',';
+ } else {
+ sht[0] = sht[1] = sht[2] = ' ';
+ }
strcpy(command, cliOptions[ind].name);
if (cliOptions[ind].has_arg)
strcat(command, "=xxxx");
- fprintf(file, " --%-15s %s\n", command, cliOptions[ind].help);
+ fprintf(file, " %s --%-17s %s\n", sht, command, cliOptions[ind].help);
}
fprintf(file,
- "Example:\n %s --verbose --port=1234 --token='azerty' --ldpaths=build/bindings:/usr/lib64/agl/bindings\n",
+ "Example:\n %s --verbose --port=" d2s(DEFAULT_HTTP_PORT) " --token='azerty' --ldpaths=build/bindings:/usr/lib64/agl/bindings\n",
name);
}
list_add(&config->calls, argvalstr(optc));
break;
- case SET_SESSION_DIR:
- /* config->sessiondir = argvalstr(optc); */
- WARNING("Obsolete option %s ignored", name_of_option(optc));
- break;
-
case SET_UPLOAD_DIR:
config->uploaddir = argvalstr(optc);
break;
config->name = argvalstr(optc);
break;
-#if defined(KEEP_LEGACY_MODE)
- case SET_MODE:
- config->mode = argvalenum(optc, mode_desc);
- break;
-#endif
-
#if HAS_DBUS
case DBUS_CLIENT:
list_add(&config->dbus_clients, argvalstr(optc));
list_add(&config->so_bindings, argvalstr(optc));
break;
- case AUTO_WS:
- list_add(&config->auto_ws, argvalstr(optc));
- break;
-
- case AUTO_LINK:
- list_add(&config->auto_link, argvalstr(optc));
+ case AUTO_API:
+ list_add(&config->auto_api, argvalstr(optc));
break;
case SET_TRACEREQ:
{
// default HTTP port
if (config->http_port == 0)
- config->http_port = 1234;
+ config->http_port = DEFAULT_HTTP_PORT;
// default binding API timeout
if (config->api_timeout == 0)
L(ws_clients)
L(ws_servers)
L(so_bindings)
+ L(auto_api)
L(ldpaths)
L(weak_ldpaths)
L(calls)
D(session_timeout)
D(max_session_count)
-#if defined(KEEP_LEGACY_MODE)
- E(mode,mode_desc)
-#endif
E(tracereq,tracereq_desc)
#if !defined(REMOVE_LEGACY_TRACE)
E(traceditf,traceditf_desc)
L(ws_clients)
L(ws_servers)
L(so_bindings)
+ L(auto_api)
L(ldpaths)
L(weak_ldpaths)
L(calls)
D(session_timeout)
D(max_session_count)
-#if defined(KEEP_LEGACY_MODE)
- E(mode,mode_desc)
-#endif
E(tracereq,tracereq_desc)
#if !defined(REMOVE_LEGACY_TRACE)
E(traceditf,traceditf_desc)
struct afb_config_list *ldpaths;
struct afb_config_list *weak_ldpaths;
struct afb_config_list *calls;
- struct afb_config_list *auto_ws;
- struct afb_config_list *auto_link;
+ struct afb_config_list *auto_api;
char **exec;
apiset_start_list(main_config->ws_clients, afb_api_ws_add_client_weak, "the afb-websocket client");
apiset_start_list(main_config->ldpaths, afb_api_so_add_pathset_fails, "the binding path set");
apiset_start_list(main_config->weak_ldpaths, afb_api_so_add_pathset_nofails, "the weak binding path set");
- apiset_start_list(main_config->auto_ws, afb_autoset_add_ws, "the automatic afb-websocket path set");
- apiset_start_list(main_config->auto_link, afb_autoset_add_so, "the automatic link binding path set");
+ apiset_start_list(main_config->auto_api, afb_autoset_add_any, "the automatic api path set");
#if defined(WITH_DBUS_TRANSPARENCY)
apiset_start_list(main_config->dbus_servers, afb_api_dbus_add_server, "the afb-dbus service");
Code Review / src / app-framework-binder.git / commitdiff