4 Structure for declaring binding
5 -------------------------------
7 ### struct afb_binding_v2
9 The main structure, of type **afb_binding_v2**, for describing the binding
10 must be exported under the name **afbBindingV2**.
12 This structure is defined as below.
16 * Description of the bindings of type version 2
20 const char *api; /* api name for the binding */
21 const char *specification; /* textual openAPIv3 specification of the binding */
22 const char *info; /* some info about the api, can be NULL */
23 const struct afb_verb_v2 *verbs; /* array of descriptions of verbs terminated by a NULL name */
24 int (*preinit)(); /* callback at load of the binding */
25 int (*init)(); /* callback for starting the service */
26 void (*onevent)(const char *event, struct json_object *object); /* callback for handling events */
27 unsigned noconcurrency: 1; /* avoids concurrent requests to verbs */
31 ### struct afb_verb_v2
33 Each verb is described with a structure of type **afb_verb_v2**
38 * Description of one verb of the API provided by the binding
39 * This enumeration is valid for bindings of type version 2
43 const char *verb; /* name of the verb */
44 void (*callback)(struct afb_req req); /* callback function implementing the verb */
45 const struct afb_auth *auth; /* required authorization */
46 const char *info; /* some info about the verb, can be NULL */
47 uint32_t session; /* authorization and session requirements of the verb */
51 The session flags is an or of the constant defined below:
53 - AFB_SESSION_NONE : no flag, synonym to 0
54 - AFB_SESSION_LOA_0 : Requires the LOA to be 0 or more, synonym to 0 or AFB_SESSION_NONE
55 - AFB_SESSION_LOA_1 : Requires the LOA to be 1 or more
56 - AFB_SESSION_LOA_2 : Requires the LOA to be 2 or more
57 - AFB_SESSION_LOA_3 : Requires the LOA to be 3 or more
58 - AFB_SESSION_CHECK : Requires the token to be set and valid
59 - AFB_SESSION_REFRESH : Implies a token refresh
60 - AFB_SESSION_CLOSE : Implies cloing the session
62 The LOA is set binding by binding using the function **afb_req_session_set_LOA**.
64 ### struct afb_auth and enum afb_auth_type
66 The structure **afb_auth** is used within verb description to
67 set security requirements. The interpretation of the structure
68 depends on the value of the field **type**.
73 const enum afb_auth_type type;
77 const struct afb_auth *first;
79 const struct afb_auth *next;
82 The possible values for **type** is defined here:
86 * Enum for Session/Token/Assurance middleware.
90 afb_auth_No = 0, /** never authorized, no data */
91 afb_auth_Token, /** authorized if token valid, no data */
92 afb_auth_LOA, /** authorized if LOA greater than data 'loa' */
93 afb_auth_Permission, /** authorized if permission 'text' is granted */
94 afb_auth_Or, /** authorized if 'first' or 'next' is authorized */
95 afb_auth_And, /** authorized if 'first' and 'next' are authorized */
96 afb_auth_Not, /** authorized if 'first' is not authorized */
97 afb_auth_Yes /** always authorized, no data */
104 static const struct afb_auth _afb_auths_v2_monitor[] = {
105 { .type = afb_auth_Permission, .text = "urn:AGL:permission:monitor:public:set" },
106 { .type = afb_auth_Permission, .text = "urn:AGL:permission:monitor:public:get" },
107 { .type = afb_auth_Or, .first = &_afb_auths_v2_monitor[1], .next = &_afb_auths_v2_monitor[0] }
111 Functions of class afb_daemon...
112 -------------------------
114 The 3 following functions are linked to libsystemd.
115 They allow use of **sd_event** features and access
116 to **sd_bus** features.
120 * Retrieves the common systemd's event loop of AFB
122 struct sd_event *afb_daemon_get_event_loop();
125 * Retrieves the common systemd's user/session d-bus of AFB
127 struct sd_bus *afb_daemon_get_user_bus();
130 * Retrieves the common systemd's system d-bus of AFB
132 struct sd_bus *afb_daemon_get_system_bus();
135 The 2 following functions are linked to event management.
136 Broadcasting an event send it to any possible listener.
140 * Broadcasts widely the event of 'name' with the data 'object'.
141 * 'object' can be NULL.
143 * For convenience, the function calls 'json_object_put' for 'object'.
144 * Thus, in the case where 'object' should remain available after
145 * the function returns, the function 'json_object_get' shall be used.
147 * Returns the count of clients that received the event.
149 int afb_daemon_broadcast_event(const char *name, struct json_object *object);
152 * Creates an event of 'name' and returns it.
154 * See afb_event_is_valid to check if there is an error.
156 struct afb_event afb_daemon_make_event(const char *name);
159 The following function is used by logging macros and should normally
160 not be used. Instead, you should use the macros
161 **AFB\_ERROR**, **AFB\_WARNING**, **AFB\_NOTICE**,
162 **AFB\_INFO**, **AFB\_DEBUG**
166 * Send a message described by 'fmt' and following parameters
167 * to the journal for the verbosity 'level'.
169 * 'file', 'line' and 'func' are indicators of position of the code in source files
170 * (see macros __FILE__, __LINE__ and __func__).
172 * 'level' is defined by syslog standard:
173 * EMERGENCY 0 System is unusable
174 * ALERT 1 Action must be taken immediately
175 * CRITICAL 2 Critical conditions
176 * ERROR 3 Error conditions
177 * WARNING 4 Warning conditions
178 * NOTICE 5 Normal but significant condition
179 * INFO 6 Informational
180 * DEBUG 7 Debug-level messages
182 void afb_daemon_verbose(int level, const char *file, int line, const char * func, const char *fmt, ...);
185 The 2 following functions MUST be used to access data of the bindings.
189 * Get the root directory file descriptor. This file descriptor can
190 * be used with functions 'openat', 'fstatat', ...
192 int afb_daemon_rootdir_get_fd();
195 * Opens 'filename' within the root directory with 'flags' (see function openat)
196 * using the 'locale' definition (example: "jp,en-US") that can be NULL.
197 * Returns the file descriptor or -1 in case of error.
199 int afb_daemon_rootdir_open_locale(const char *filename, int flags, const char *locale);
202 The following function is used to queue jobs.
206 * Queue the job defined by 'callback' and 'argument' for being executed asynchronously
207 * in this thread (later) or in an other thread.
208 * If 'group' is not NUL, the jobs queued with a same value (as the pointer value 'group')
209 * are executed in sequence in the order of there submission.
210 * If 'timeout' is not 0, it represent the maximum execution time for the job in seconds.
211 * At first, the job is called with 0 as signum and the given argument.
212 * The job is executed with the monitoring of its time and some signals like SIGSEGV and
213 * SIGFPE. When a such signal is catched, the job is terminated and re-executed but with
214 * signum being the signal number (SIGALRM when timeout expired).
216 * Returns 0 in case of success or -1 in case of error.
218 int afb_daemon_queue_job(void (*callback)(int signum, void *arg), void *argument, void *group, int timeout)
221 The following function must be used when a binding depends on other
222 bindings at its initialization.
226 * Tells that it requires the API of "name" to exist
227 * and if 'initialized' is not null to be initialized.
228 * Returns 0 in case of success or -1 in case of error.
230 int afb_daemon_require_api(const char *name, int initialized)
233 Functions of class afb_service...
234 -------------------------
236 The following functions allow services to call verbs of other
237 bindings for themselves.
241 * Calls the 'verb' of the 'api' with the arguments 'args' and 'verb' in the name of the binding.
242 * The result of the call is delivered to the 'callback' function with the 'callback_closure'.
244 * For convenience, the function calls 'json_object_put' for 'args'.
245 * Thus, in the case where 'args' should remain available after
246 * the function returns, the function 'json_object_get' shall be used.
248 * The 'callback' receives 3 arguments:
249 * 1. 'closure' the user defined closure pointer 'callback_closure',
250 * 2. 'status' a status being 0 on success or negative when an error occured,
251 * 2. 'result' the resulting data as a JSON object.
253 * @param api The api name of the method to call
254 * @param verb The verb name of the method to call
255 * @param args The arguments to pass to the method
256 * @param callback The to call on completion
257 * @param callback_closure The closure to pass to the callback
259 * @see also 'afb_req_subcall'
261 void afb_service_call(
264 struct json_object *args,
265 void (*callback)(void*closure, int status, struct json_object *result),
266 void *callback_closure);
269 * Calls the 'verb' of the 'api' with the arguments 'args' and 'verb' in the name of the binding.
270 * 'result' will receive the response.
272 * For convenience, the function calls 'json_object_put' for 'args'.
273 * Thus, in the case where 'args' should remain available after
274 * the function returns, the function 'json_object_get' shall be used.
276 * @param api The api name of the method to call
277 * @param verb The verb name of the method to call
278 * @param args The arguments to pass to the method
279 * @param result Where to store the result - should call json_object_put on it -
281 * @returns 0 in case of success or a negative value in case of error.
283 * @see also 'afb_req_subcall'
285 int afb_service_call_sync(
288 struct json_object *args,
289 struct json_object **result);
292 Functions of class afb_event...
293 -------------------------
295 This function checks whether the event is valid. It must be used
296 when creating events.
300 * Checks wether the 'event' is valid or not.
302 * Returns 0 if not valid or 1 if valid.
304 int afb_event_is_valid(struct afb_event event);
307 The two following functions are used to broadcast or push
312 * Broadcasts widely the 'event' with the data 'object'.
313 * 'object' can be NULL.
315 * For convenience, the function calls 'json_object_put' for 'object'.
316 * Thus, in the case where 'object' should remain available after
317 * the function returns, the function 'json_object_get' shall be used.
319 * Returns the count of clients that received the event.
321 int afb_event_broadcast(struct afb_event event, struct json_object *object);
324 * Pushes the 'event' with the data 'object' to its observers.
325 * 'object' can be NULL.
327 * For convenience, the function calls 'json_object_put' for 'object'.
328 * Thus, in the case where 'object' should remain available after
329 * the function returns, the function 'json_object_get' shall be used.
331 * Returns the count of clients that received the event.
333 int afb_event_push(struct afb_event event, struct json_object *object);
336 The following function destiys the event.
340 * Drops the data associated to the 'event'
341 * After calling this function, the event
342 * MUST NOT BE USED ANYMORE.
344 void afb_event_drop(struct afb_event event);
347 This function allows to retrieve the exact name of the event.
351 * Gets the name associated to the 'event'.
353 const char *afb_event_name(struct afb_event event);
356 Functions of class afb_req...
357 -------------------------
359 This function checks the validity of the **req**.
363 * Checks wether the request 'req' is valid or not.
365 * Returns 0 if not valid or 1 if valid.
367 int afb_req_is_valid(struct afb_req req);
370 The following functions retrieves parameters of the request.
374 * Gets from the request 'req' the argument of 'name'.
375 * Returns a PLAIN structure of type 'struct afb_arg'.
376 * When the argument of 'name' is not found, all fields of result are set to NULL.
377 * When the argument of 'name' is found, the fields are filled,
378 * in particular, the field 'result.name' is set to 'name'.
380 * There is a special name value: the empty string.
381 * The argument of name "" is defined only if the request was made using
382 * an HTTP POST of Content-Type "application/json". In that case, the
383 * argument of name "" receives the value of the body of the HTTP request.
385 struct afb_arg afb_req_get(struct afb_req req, const char *name);
388 * Gets from the request 'req' the string value of the argument of 'name'.
389 * Returns NULL if when there is no argument of 'name'.
390 * Returns the value of the argument of 'name' otherwise.
392 * Shortcut for: afb_req_get(req, name).value
394 const char *afb_req_value(struct afb_req req, const char *name);
397 * Gets from the request 'req' the path for file attached to the argument of 'name'.
398 * Returns NULL if when there is no argument of 'name' or when there is no file.
399 * Returns the path of the argument of 'name' otherwise.
401 * Shortcut for: afb_req_get(req, name).path
403 const char *afb_req_path(struct afb_req req, const char *name);
406 * Gets from the request 'req' the json object hashing the arguments.
407 * The returned object must not be released using 'json_object_put'.
409 struct json_object *afb_req_json(struct afb_req req);
412 The following functions emit the reply to the request.
416 * Sends a reply of kind success to the request 'req'.
417 * The status of the reply is automatically set to "success".
418 * Its send the object 'obj' (can be NULL) with an
419 * informationnal comment 'info (can also be NULL).
421 * For convenience, the function calls 'json_object_put' for 'obj'.
422 * Thus, in the case where 'obj' should remain available after
423 * the function returns, the function 'json_object_get' shall be used.
425 void afb_req_success(struct afb_req req, struct json_object *obj, const char *info);
428 * Same as 'afb_req_success' but the 'info' is a formatting
429 * string followed by arguments.
431 * For convenience, the function calls 'json_object_put' for 'obj'.
432 * Thus, in the case where 'obj' should remain available after
433 * the function returns, the function 'json_object_get' shall be used.
435 void afb_req_success_f(struct afb_req req, struct json_object *obj, const char *info, ...);
438 * Same as 'afb_req_success_f' but the arguments to the format 'info'
439 * are given as a variable argument list instance.
441 * For convenience, the function calls 'json_object_put' for 'obj'.
442 * Thus, in the case where 'obj' should remain available after
443 * the function returns, the function 'json_object_get' shall be used.
445 void afb_req_success_v(struct afb_req req, struct json_object *obj, const char *info, va_list args);
448 * Sends a reply of kind failure to the request 'req'.
449 * The status of the reply is set to 'status' and an
450 * informationnal comment 'info' (can also be NULL) can be added.
452 * Note that calling afb_req_fail("success", info) is equivalent
453 * to call afb_req_success(NULL, info). Thus even if possible it
454 * is strongly recommended to NEVER use "success" for status.
456 void afb_req_fail(struct afb_req req, const char *status, const char *info);
459 * Same as 'afb_req_fail' but the 'info' is a formatting
460 * string followed by arguments.
462 void afb_req_fail_f(struct afb_req req, const char *status, const char *info, ...);
465 * Same as 'afb_req_fail_f' but the arguments to the format 'info'
466 * are given as a variable argument list instance.
468 void afb_req_fail_v(struct afb_req req, const char *status, const char *info, va_list args);
471 The following functions handle the session data.
475 * Gets the pointer stored by the binding for the session of 'req'.
476 * When the binding has not yet recorded a pointer, NULL is returned.
478 void *afb_req_context_get(struct afb_req req);
481 * Stores for the binding the pointer 'context' to the session of 'req'.
482 * The function 'free_context' will be called when the session is closed
483 * or if binding stores an other pointer.
485 void afb_req_context_set(struct afb_req req, void *context, void (*free_context)(void*));
488 * Gets the pointer stored by the binding for the session of 'req'.
489 * If the stored pointer is NULL, indicating that no pointer was
490 * already stored, afb_req_context creates a new context by calling
491 * the function 'create_context' and stores it with the freeing function
494 void *afb_req_context(struct afb_req req, void *(*create_context)(), void (*free_context)(void*));
497 * Frees the pointer stored by the binding for the session of 'req'
498 * and sets it to NULL.
500 * Shortcut for: afb_req_context_set(req, NULL, NULL)
502 void afb_req_context_clear(struct afb_req req);
505 * Closes the session associated with 'req'
506 * and delete all associated contexts.
508 void afb_req_session_close(struct afb_req req);
511 * Sets the level of assurance of the session of 'req'
512 * to 'level'. The effect of this function is subject of
514 * Returns 1 on success or 0 if failed.
516 int afb_req_session_set_LOA(struct afb_req req, unsigned level);
520 The 4 following functions must be used for asynchronous handling requests.
524 * Adds one to the count of references of 'req'.
525 * This function MUST be called by asynchronous implementations
526 * of verbs if no reply was sent before returning.
528 void afb_req_addref(struct afb_req req);
531 * Substracts one to the count of references of 'req'.
532 * This function MUST be called by asynchronous implementations
533 * of verbs after sending the asynchronous reply.
535 void afb_req_unref(struct afb_req req);
538 * Stores 'req' on heap for asynchronous use.
539 * Returns a handler to the stored 'req' or NULL on memory depletion.
540 * The count of reference to 'req' is incremented on success
541 * (see afb_req_addref).
543 struct afb_stored_req *afb_req_store(struct afb_req req);
546 * Retrieves the afb_req stored at 'sreq'.
547 * Returns the stored request.
548 * The count of reference is UNCHANGED, thus, the
549 * function 'afb_req_unref' should be called on the result
550 * after that the asynchronous reply if sent.
552 struct afb_req afb_req_unstore(struct afb_stored_req *sreq);
555 The two following functions are used to associate client with events
560 * Establishes for the client link identified by 'req' a subscription
562 * Returns 0 in case of successful subscription or -1 in case of error.
564 int afb_req_subscribe(struct afb_req req, struct afb_event event);
567 * Revokes the subscription established to the 'event' for the client
568 * link identified by 'req'.
569 * Returns 0 in case of successful subscription or -1 in case of error.
571 int afb_req_unsubscribe(struct afb_req req, struct afb_event event);
574 The following functions must be used to make request in the name of the
575 client (with its permissions).
579 * Makes a call to the method of name 'api' / 'verb' with the object 'args'.
580 * This call is made in the context of the request 'req'.
581 * On completion, the function 'callback' is invoked with the
582 * 'closure' given at call and two other parameters: 'iserror' and 'result'.
583 * 'status' is 0 on success or negative when on an error reply.
584 * 'result' is the json object of the reply, you must not call json_object_put
587 * For convenience, the function calls 'json_object_put' for 'args'.
588 * Thus, in the case where 'args' should remain available after
589 * the function returns, the function 'json_object_get' shall be used.
591 void afb_req_subcall(
595 struct json_object *args,
596 void (*callback)(void *closure, int status, struct json_object *result),
600 * Makes a call to the method of name 'api' / 'verb' with the object 'args'.
601 * This call is made in the context of the request 'req'.
602 * This call is synchronous, it waits untill completion of the request.
603 * It returns 0 on success or a negative value on error answer.
604 * The object pointed by 'result' is filled and must be released by the caller
605 * after its use by calling 'json_object_put'.
607 * For convenience, the function calls 'json_object_put' for 'args'.
608 * Thus, in the case where 'args' should remain available after
609 * the function returns, the function 'json_object_get' shall be used.
611 int afb_req_subcall_sync(
615 struct json_object *args,
616 struct json_object **result);
619 The following function is used by logging macros and should normally
620 not be used. Instead, you should use the macros
621 **AFB_REQ_ERROR**, **AFB_REQ_WARNING**, **AFB_REQ_NOTICE**,
622 **AFB_REQ_INFO**, **AFB_REQ_DEBUG**
626 * Send associated to 'req' a message described by 'fmt' and following parameters
627 * to the journal for the verbosity 'level'.
629 * 'file', 'line' and 'func' are indicators of position of the code in source files
630 * (see macros __FILE__, __LINE__ and __func__).
632 * 'level' is defined by syslog standard:
633 * EMERGENCY 0 System is unusable
634 * ALERT 1 Action must be taken immediately
635 * CRITICAL 2 Critical conditions
636 * ERROR 3 Error conditions
637 * WARNING 4 Warning conditions
638 * NOTICE 5 Normal but significant condition
639 * INFO 6 Informational
640 * DEBUG 7 Debug-level messages
642 void afb_req_verbose(struct afb_req req, int level, const char *file, int line, const char * func, const char *fmt, ...);
648 The following macros must be used for logging:
658 The following macros can be used for logging in the context
659 of a request **req** of type **afb_req**:
662 AFB_REQ_ERROR(req,fmt,...)
663 AFB_REQ_WARNING(req,fmt,...)
664 AFB_REQ_NOTICE(req,fmt,...)
665 AFB_REQ_INFO(req,fmt,...)
666 AFB_REQ_DEBUG(req,fmt,...)
669 By default, the logging macros add file, line and function