04f4add1995c6f72d57912080b39e1cc2e023aa9
[src/app-framework-binder.git] / include / afb / c++ / binding-wrap.hpp
1 /*
2  * Copyright (C) 2016-2019 "IoT.bzh"
3  * Author: José Bollo <jose.bollo@iot.bzh>
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  *   http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 #pragma once
19
20 #include <cstddef>
21 #include <cstdlib>
22 #include <cstdarg>
23 #include <functional>
24
25 /* ensure version */
26 #ifndef AFB_BINDING_VERSION
27 # define AFB_BINDING_VERSION   3
28 #endif
29
30 /* check the version */
31 #if AFB_BINDING_VERSION < 3
32 # error "AFB_BINDING_VERSION must be at least 3"
33 #endif
34
35 /* get C definitions of bindings */
36 extern "C" {
37 #include <afb/afb-binding.h>
38 }
39
40 namespace afb {
41 /*************************************************************************/
42 /* pre-declaration of classes                                            */
43 /*************************************************************************/
44
45 class api;
46 class arg;
47 class event;
48 class req;
49
50 /*************************************************************************/
51 /* declaration of functions                                              */
52 /*************************************************************************/
53
54 int broadcast_event(const char *name, json_object *object = nullptr);
55
56 event make_event(const char *name);
57
58 void verbose(int level, const char *file, int line, const char * func, const char *fmt, va_list args);
59
60 void verbose(int level, const char *file, int line, const char * func, const char *fmt, ...);
61
62 int rootdir_get_fd();
63
64 int rootdir_open_locale_fd(const char *filename, int flags, const char *locale = nullptr);
65
66 int queue_job(void (*callback)(int signum, void *arg), void *argument, void *group, int timeout);
67
68 int require_api(const char *apiname, bool initialized = true);
69
70 int add_alias(const char *apiname, const char *aliasname);
71
72 int verbosity();
73
74 bool wants_errors();
75 bool wants_warnings();
76 bool wants_notices();
77 bool wants_infos();
78 bool wants_debugs();
79
80 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);
81
82 template <class T> void call(const char *api, const char *verb, struct json_object *args, void (*callback)(T*closure, int iserror, struct json_object *result, afb_api_t api), T *closure);
83
84 bool callsync(const char *api, const char *verb, struct json_object *args, struct json_object *&result);
85
86 /*************************************************************************/
87 /* effective declaration of classes                                      */
88 /*************************************************************************/
89
90 /* apis */
91 class api
92 {
93         afb_api_t api_;
94 public:
95         using call_cb = void (*)(void *closure, struct json_object *object, const char *error, const char *info, afb_api_t api);
96         using queue_cb = void (*)(int signum, void *arg);
97         using event_cb = void (*)(void *, const char *, struct json_object *, afb_api_t);
98         using preinit_cb = int (*)(void *, afb_api_t);
99         using verb_cb = void (*)(afb_req_t req);
100         using onevent_cb = void (*)(afb_api_t api, const char *event, struct json_object *object);
101         using oninit_cb = int (*)(afb_api_t api);
102
103         api();
104         api(afb_api_t a);
105         api(const api &other) = delete;
106         api(api &&other);
107         ~api();
108         api &operator=(const api &other) = delete;
109         api &operator=(api &&other);
110
111         operator afb_api_t() const;
112         afb_api_t operator->() const;
113
114         /* General functions */
115         const char *name() const;
116         void *get_userdata() const;
117         void set_userdata(void *value) const;
118         int require_api(const char *name, int initialized) const;
119         int require_api(const std::string &name, int initialized) const;
120
121         /* Verbosity functions */
122         int wants_log_level(int level) const;
123         void vverbose(int level, const char *file, int line, const char *func, const char *fmt, va_list args) const;
124         void verbose(int level, const char *file, int line, const char *func, const char *fmt, ...) const;
125
126         /* Data retrieval functions */
127         int rootdir_get_fd() const;
128         int rootdir_open_locale(const char *filename, int flags, const char *locale) const;
129         int rootdir_open_locale(const std::string &filename, int flags, const std::string &locale) const;
130         struct json_object *settings() const;
131
132         /* Calls and job functions */
133         void call(const char *apiname, const char *verb, struct json_object *args, call_cb callback, void *closure) const;
134         void call(const std::string &apiname, const std::string &verb, struct json_object *args, call_cb callback, void *closure) const;
135         int call_sync(const char *apiname, const char *verb, struct json_object *args, struct json_object **object, char **error, char **info) const;
136         int call_sync(const std::string &apiname, const std::string &verb, struct json_object *args, struct json_object **object, std::string &error, std::string &info) const;
137         int queue_job(queue_cb callback, void *argument, void *group, int timeout) const;
138
139         /* Event functions */
140         int broadcast_event(const char *name, struct json_object *object) const;
141         int broadcast_event(const std::string &name, struct json_object *object) const;
142         event make_event(const char *name) const;
143         event make_event(const std::string &name) const;
144         int event_handler_add(const char *pattern, event_cb callback, void *closure) const;
145         int event_handler_add(const std::string &pattern, event_cb callback, void *closure) const;
146         int event_handler_del(const char *pattern, void **closure) const;
147         int event_handler_del(const std::string &pattern, void **closure) const;
148
149         /* Systemd functions */
150         struct sd_event *get_event_loop() const;
151         struct sd_bus *get_user_bus() const;
152         struct sd_bus *get_system_bus() const;
153
154         /* Dynamic api functions */
155         api new_api(const char *apiname, const char *info, int noconcurrency, preinit_cb preinit, void *closure) const;
156         api new_api(const std::string &apiname, const std::string &info, int noconcurrency, preinit_cb preinit, void *closure) const;
157         int set_verbs(const struct afb_verb_v2 *verbs) const;
158         int set_verbs(const struct afb_verb_v3 *verbs) const;
159         int add_verb(const char *verb, const char *info, verb_cb callback, void *vcbdata, const struct afb_auth *auth, uint32_t session, int glob) const;
160         int add_verb(const std::string &verb, const std::string &info, verb_cb callback, void *vcbdata, const struct afb_auth *auth, uint32_t session, int glob) const;
161         int del_verb(const char *verb, void **vcbdata) const;
162         int del_verb(const std::string &verb, void **vcbdata) const;
163         int on_event(onevent_cb onevent) const;
164         int on_init(oninit_cb oninit) const;
165         int provide_class(const char *name) const;
166         int provide_class(const std::string &name) const;
167         int require_class(const char *name) const;
168         int require_class(const std::string &name) const;
169         void seal() const;
170         int delete_api() const;
171         int add_alias(const char *name, const char *as_name) const;
172         int add_alias(const std::string &name, const std::string &as_name) const;
173 };
174
175 /* events */
176 class event
177 {
178         afb_event_t event_;
179 public:
180         event();
181         event(afb_event_t e);
182         event(const event &other);
183         event(event &&other);
184         ~event();
185         event &operator=(const event &other);
186         event &operator=(event &&other);
187
188         operator afb_event_t() const;
189         afb_event_t operator->() const;
190
191         operator bool() const;
192         bool is_valid() const;
193
194         int broadcast(json_object *object) const;
195         int push(json_object *object) const;
196
197         void unref();
198         void addref();
199         const char *name() const;
200 };
201
202 /* args */
203 class arg
204 {
205         struct afb_arg arg_;
206 public:
207         arg() = delete;
208         arg(const struct afb_arg &a);
209         arg(const arg &other);
210         arg &operator=(const arg &other);
211
212         operator const struct afb_arg&() const;
213
214         bool has_name() const;
215         bool has_value() const;
216         bool has_path() const;
217
218         const char *name() const;
219         const char *value() const;
220         const char *path() const;
221 };
222
223 /* req(uest) */
224 class req
225 {
226         afb_req_t req_;
227
228 public:
229         req() = delete;
230         req(afb_req_t r);
231         req(const req &other);
232         req &operator=(const req &other);
233
234         operator afb_req_t() const;
235         afb_req_t operator->() const;
236
237         operator bool() const;
238         bool is_valid() const;
239
240         arg get(const char *name) const;
241
242         const char *value(const char *name) const;
243
244         const char *path(const char *name) const;
245
246         json_object *json() const;
247
248         void reply(json_object *obj = nullptr, const char *error = nullptr, const char *info = nullptr) const;
249         void replyf(json_object *obj, const char *error, const char *info, ...) const;
250         void replyv(json_object *obj, const char *error, const char *info, va_list args) const;
251
252         void success(json_object *obj = nullptr, const char *info = nullptr) const;
253         void successf(json_object *obj, const char *info, ...) const;
254         void successv(json_object *obj, const char *info, va_list args) const;
255
256         void fail(const char *error = "failed", const char *info = nullptr) const;
257         void failf(const char *error, const char *info, ...) const;
258         void failv(const char *error, const char *info, va_list args) const;
259
260         template < class T > T *context() const;
261
262         void addref() const;
263
264         void unref() const;
265
266         void session_close() const;
267
268         bool session_set_LOA(unsigned level) const;
269
270         bool subscribe(const event &event) const;
271
272         bool unsubscribe(const event &event) const;
273
274         void subcall(const char *api, const char *verb, json_object *args, void (*callback)(void *closure, int iserror, json_object *result, afb_req_t req), void *closure) const;
275         template <class T> void subcall(const char *api, const char *verb, json_object *args, void (*callback)(T *closure, int iserror, json_object *result, afb_req_t req), T *closure) const;
276
277         bool subcallsync(const char *api, const char *verb, json_object *args, struct json_object *&result) const;
278
279         void subcall(const char *api, const char *verb, json_object *args, int flags, void (*callback)(void *closure, json_object *object, const char *error, const char *info, afb_req_t req), void *closure) const;
280
281         template <class T> void subcall(const char *api, const char *verb, json_object *args, int flags, void (*callback)(T *closure, json_object *object, const char *error, const char *info, afb_req_t req), T *closure) const;
282
283         bool subcallsync(const char *api, const char *verb, json_object *args, int flags, struct json_object *&object, char *&error, char *&info) const;
284
285         void verbose(int level, const char *file, int line, const char * func, const char *fmt, va_list args) const;
286
287         void verbose(int level, const char *file, int line, const char * func, const char *fmt, ...) const;
288
289         bool has_permission(const char *permission) const;
290
291         char *get_application_id() const;
292
293         int get_uid() const;
294
295         json_object *get_client_info() const;
296 };
297
298 /*************************************************************************/
299 /* effective declaration of classes                                      */
300 /*************************************************************************/
301 /////////////////////////////////////////////////////////////////////////////////////////////////////
302 /////////////////////////////////////////////////////////////////////////////////////////////////////
303 /////////////////////////////////////////////////////////////////////////////////////////////////////
304 /////////////////////////////////////////////////////////////////////////////////////////////////////
305 /////////////////////////////////////////////////////////////////////////////////////////////////////
306 /////////////////////////////////////////////////////////////////////////////////////////////////////
307 /////////////////////////////////////////////////////////////////////////////////////////////////////
308 /////////////////////////////////////////////////////////////////////////////////////////////////////
309 /////////////////////////////////////////////////////////////////////////////////////////////////////
310 /////////////////////////////////////////////////////////////////////////////////////////////////////
311 /////////////////////////////////////////////////////////////////////////////////////////////////////
312 /////////////////////////////////////////////////////////////////////////////////////////////////////
313 /////////////////////////////////////////////////////////////////////////////////////////////////////
314 /////////////////////////////////////////////////////////////////////////////////////////////////////
315 /////////////////////////////////////////////////////////////////////////////////////////////////////
316 /////////////////////////////////////////////////////////////////////////////////////////////////////
317
318
319 /*************************************************************************/
320 /* effective declaration of classes                                      */
321 /*************************************************************************/
322
323 /* apis */
324 inline api::api() : api_{nullptr} { }
325 inline api::api(afb_api_t a) : api_{a} { }
326 inline api::api(api &&other) : api_{other.api_} { other.api_ = nullptr; }
327 inline api::~api() { api_ = nullptr; }
328 inline api &api::operator=(api &&other) { api_ = other.api_; other.api_ = nullptr; return *this;}
329 inline api::operator afb_api_t() const { return api_; }
330 inline afb_api_t api::operator->() const { return api_; }
331 inline const char *api::name() const { return afb_api_name(api_); }
332 inline void *api::get_userdata() const { return afb_api_get_userdata(api_); }
333 inline void api::set_userdata(void *value) const { afb_api_set_userdata(api_, value); }
334 inline int api::require_api(const char *name, int initialized) const { return afb_api_require_api(api_, name, initialized); }
335 inline int api::require_api(const std::string& name, int initialized) const { return afb_api_require_api(api_, name.c_str(), initialized); }
336 inline int api::wants_log_level(int level) const { return afb_api_wants_log_level(api_, level); }
337 inline void api::vverbose(int level, const char *file, int line, const char *func, const char *fmt, va_list args) const { afb_api_vverbose(api_, level, file, line, func, fmt, args); }
338 inline void api::verbose(int level, const char *file, int line, const char *func, const char *fmt, ...) const
339 {
340         va_list args;
341         va_start(args, fmt);
342         vverbose(level, file, line, func, fmt, args);
343         va_end(args);
344 }
345 inline int api::rootdir_get_fd() const { return afb_api_rootdir_get_fd(api_); }
346 inline int api::rootdir_open_locale(const char *filename, int flags, const char *locale) const { return afb_api_rootdir_open_locale(api_, filename, flags, locale); }
347 inline int api::rootdir_open_locale(const std::string &filename, int flags, const std::string &locale) const { return afb_api_rootdir_open_locale(api_, filename.c_str(), flags, locale.c_str()); }
348 inline struct json_object *api::settings() const { return afb_api_settings(api_); }
349 inline void api::call(const char *apiname, const char *verb, struct json_object *args, call_cb callback, void *closure) const { afb_api_call(api_, apiname, verb, args, callback, closure); }
350 inline void api::call(const std::string &apiname, const std::string &verb, struct json_object *args, call_cb callback, void *closure) const { afb_api_call(api_, apiname.c_str(), verb.c_str(), args, callback, closure); }
351 inline int api::call_sync(const char *apiname, const char *verb, struct json_object *args, struct json_object **object, char **error, char **info) const { return afb_api_call_sync(api_, apiname, verb, args, object, error, info); }
352 inline int api::call_sync(const std::string &apiname, const std::string &verb, struct json_object *args, struct json_object **object, std::string &error, std::string& info) const
353 {
354         char *err, *inf;
355         int ret = afb_api_call_sync(api_, apiname.c_str(), verb.c_str(), args, object, &err, &inf);
356         error = err;
357         info = inf;
358         return ret;
359 }
360 inline int api::queue_job(queue_cb callback, void *argument, void *group, int timeout) const { return afb_api_queue_job(api_, callback, argument, group, timeout); }
361 inline int api::broadcast_event(const char *name, struct json_object *object) const { return afb_api_broadcast_event(api_, name, object); }
362 inline int api::broadcast_event(const std::string &name, struct json_object *object) const { return afb_api_broadcast_event(api_, name.c_str(), object); }
363 inline event api::make_event(const char *name) const { return event(afb_api_make_event(api_, name)); }
364 inline event api::make_event(const std::string &name) const { return event(afb_api_make_event(api_, name.c_str())); }
365 inline int api::event_handler_add(const char *pattern, event_cb callback, void *closure) const { return afb_api_event_handler_add(api_, pattern, callback, closure); }
366 inline int api::event_handler_add(const std::string &pattern, event_cb callback, void *closure) const { return afb_api_event_handler_add(api_, pattern.c_str(), callback, closure); }
367 inline int api::event_handler_del(const char *pattern, void **closure) const { return afb_api_event_handler_del(api_, pattern, closure); }
368 inline int api::event_handler_del(const std::string &pattern, void **closure) const { return afb_api_event_handler_del(api_, pattern.c_str(), closure); }
369 inline struct sd_event *api::get_event_loop() const { return afb_api_get_event_loop(api_); }
370 inline struct sd_bus *api::get_user_bus() const { return afb_api_get_user_bus(api_); }
371 inline struct sd_bus *api::get_system_bus() const { return afb_api_get_system_bus(api_); }
372 inline api api::new_api(const char *apiname, const char *info, int noconcurrency, preinit_cb preinit, void *closure) const { return api(afb_api_new_api(api_, apiname, info, noconcurrency, preinit, closure)); }
373 inline api api::new_api(const std::string &apiname, const std::string &info, int noconcurrency, preinit_cb preinit, void *closure) const { return api(afb_api_new_api(api_, apiname.c_str(), info.c_str(), noconcurrency, preinit, closure)); }
374 inline int api::set_verbs(const struct afb_verb_v2 *verbs) const { return afb_api_set_verbs_v2(api_, verbs); }
375 inline int api::set_verbs(const struct afb_verb_v3 *verbs) const { return afb_api_set_verbs_v3(api_, verbs); }
376 inline int api::add_verb(const char *verb, const char *info, verb_cb callback, void *vcbdata, const struct afb_auth *auth, uint32_t session, int glob) const { return afb_api_add_verb(api_, verb, info, callback, vcbdata, auth, session, glob); }
377 inline int api::add_verb(const std::string &verb, const std::string &info, verb_cb callback, void *vcbdata, const struct afb_auth *auth, uint32_t session, int glob) const { return afb_api_add_verb(api_, verb.c_str(), info.c_str(), callback, vcbdata, auth, session, glob); }
378 inline int api::del_verb(const char *verb, void **vcbdata) const { return afb_api_del_verb(api_, verb, vcbdata); }
379 inline int api::del_verb(const std::string &verb, void **vcbdata) const { return afb_api_del_verb(api_, verb.c_str(), vcbdata); }
380 inline int api::on_event(onevent_cb onevent) const { return afb_api_on_event(api_, onevent); }
381 inline int api::on_init(oninit_cb oninit) const { return afb_api_on_init(api_, oninit); }
382 inline int api::provide_class(const char *name) const { return afb_api_provide_class(api_, name); }
383 inline int api::provide_class(const std::string &name) const { return afb_api_provide_class(api_, name.c_str()); }
384 inline int api::require_class(const char *name) const { return afb_api_require_class(api_, name); }
385 inline int api::require_class(const std::string &name) const { return afb_api_require_class(api_, name.c_str()); }
386 inline void api::seal() const { afb_api_seal(api_); }
387 inline int api::delete_api() const { return afb_api_delete_api(api_); }
388 inline int api::add_alias(const char *name, const char *as_name) const { return afb_api_add_alias(api_, name, as_name); }
389 inline int api::add_alias(const std::string &name, const std::string &as_name) const { return afb_api_add_alias(api_, name.c_str(), as_name.c_str()); }
390
391 /* events */
392 inline event::event() : event_{nullptr} { }
393 inline event::event(afb_event_t e) : event_{e} { }
394 inline event::event(event &&other) : event_{other.event_} { other.event_ = nullptr; }
395 inline event::event(const event &other) : event_{other.event_} { addref(); }
396 inline event::~event() { unref(); }
397 inline event &event::operator=(const event &other) { event_ = other.event_; return *this; }
398 inline event &event::operator=(event &&other) { event_ = other.event_; other.event_ = nullptr; return *this;}
399
400 inline event::operator afb_event_t() const { return event_; }
401 inline afb_event_t event::operator->() const { return event_; }
402
403 inline event::operator bool() const { return is_valid(); }
404 inline bool event::is_valid() const { return afb_event_is_valid(event_); }
405
406 inline int event::broadcast(json_object *object) const { return afb_event_broadcast(event_, object); }
407 inline int event::push(json_object *object) const { return afb_event_push(event_, object); }
408
409 inline void event::unref() { afb_event_unref(event_); event_ = nullptr; }
410 inline void event::addref() { afb_event_addref(event_); }
411 inline const char *event::name() const { return afb_event_name(event_); }
412
413 /* args */
414 inline arg::arg(const struct afb_arg &a) : arg_(a) {}
415 inline arg::arg(const arg &other) : arg_(other.arg_) {}
416 inline arg &arg::operator=(const arg &other) { arg_ = other.arg_; return *this; }
417
418 inline arg::operator const struct afb_arg&() const { return arg_; }
419
420 inline bool arg::has_name() const { return !!arg_.name; }
421 inline bool arg::has_value() const { return !!arg_.value; }
422 inline bool arg::has_path() const { return !!arg_.path; }
423
424 inline const char *arg::name() const { return arg_.name; }
425 inline const char *arg::value() const { return arg_.value; }
426 inline const char *arg::path() const { return arg_.path; }
427
428 /* req(uests)s */
429
430 inline req::req(afb_req_t r) : req_(r) {}
431 inline req::req(const req &other) : req_(other.req_) {}
432 inline req &req::operator=(const req &other) { req_ = other.req_; return *this; }
433
434 inline req::operator afb_req_t() const { return req_; }
435 inline afb_req_t req::operator->() const { return req_; }
436
437 inline req::operator bool() const { return is_valid(); }
438 inline bool req::is_valid() const { return afb_req_is_valid(req_); }
439
440 inline arg req::get(const char *name) const { return arg(afb_req_get(req_, name)); }
441
442 inline const char *req::value(const char *name) const { return afb_req_value(req_, name); }
443
444 inline const char *req::path(const char *name) const { return afb_req_path(req_, name); }
445
446 inline json_object *req::json() const { return afb_req_json(req_); }
447
448 inline void req::reply(json_object *obj, const char *error, const char *info) const { afb_req_reply(req_, obj, error, info); }
449 inline void req::replyv(json_object *obj, const char *error, const char *info, va_list args) const { afb_req_reply_v(req_, obj, error, info, args); }
450 inline void req::replyf(json_object *obj, const char *error, const char *info, ...) const
451 {
452         va_list args;
453         va_start(args, info);
454         replyv(obj, error, info, args);
455         va_end(args);
456 }
457
458 inline void req::success(json_object *obj, const char *info) const { reply(obj, nullptr, info); }
459 inline void req::successv(json_object *obj, const char *info, va_list args) const { replyv(obj, nullptr, info, args); }
460 inline void req::successf(json_object *obj, const char *info, ...) const
461 {
462         va_list args;
463         va_start(args, info);
464         successv(obj, info, args);
465         va_end(args);
466 }
467
468 inline void req::fail(const char *error, const char *info) const { reply(nullptr, error, info); }
469 inline void req::failv(const char *error, const char *info, va_list args) const { replyv(nullptr, error, info, args); }
470 inline void req::failf(const char *error, const char *info, ...) const
471 {
472         va_list args;
473         va_start(args, info);
474         failv(error, info, args);
475         va_end(args);
476 }
477
478 template < class T >
479 inline T *req::context() const
480 {
481         T* (*creater)(void*) = [](){return new T();};
482         void (*freer)(T*) = [](T*t){delete t;};
483         return reinterpret_cast<T*>(afb_req_context(req_, 0,
484                         reinterpret_cast<void *(*)(void*)>(creater),
485                         reinterpret_cast<void (*)(void*)>(freer), nullptr));
486 }
487
488 inline void req::addref() const { afb_req_addref(req_); }
489
490 inline void req::unref() const { afb_req_unref(req_); }
491
492 inline void req::session_close() const { afb_req_session_close(req_); }
493
494 inline bool req::session_set_LOA(unsigned level) const { return !afb_req_session_set_LOA(req_, level); }
495
496 inline bool req::subscribe(const event &event) const { return !afb_req_subscribe(req_, event); }
497
498 inline bool req::unsubscribe(const event &event) const { return !afb_req_unsubscribe(req_, event); }
499
500 inline void req::subcall(const char *api, const char *verb, json_object *args, int flags, void (*callback)(void *closure, json_object *result, const char *error, const char *info, afb_req_t req), void *closure) const
501 {
502         afb_req_subcall(req_, api, verb, args, flags, callback, closure);
503 }
504
505 template <class T>
506 inline void req::subcall(const char *api, const char *verb, json_object *args, int flags, void (*callback)(T *closure, json_object *result, const char *error, const char *info, afb_req_t req), T *closure) const
507 {
508         subcall(api, verb, args, flags, reinterpret_cast<void(*)(void*,json_object*,const char*,const char*,afb_req_t)>(callback), reinterpret_cast<void*>(closure));
509 }
510
511 inline bool req::subcallsync(const char *api, const char *verb, json_object *args, int flags, struct json_object *&object, char *&error, char *&info) const
512 {
513         return !afb_req_subcall_sync(req_, api, verb, args, flags, &object, &error, &info);
514 }
515
516 inline void req::subcall(const char *api, const char *verb, json_object *args, void (*callback)(void *closure, int iserror, json_object *result, afb_req_t req), void *closure) const
517 {
518         afb_req_subcall_legacy(req_, api, verb, args, callback, closure);
519 }
520
521 template <class T>
522 inline void req::subcall(const char *api, const char *verb, json_object *args, void (*callback)(T *closure, int iserror, json_object *result, afb_req_t req), T *closure) const
523 {
524         subcall(api, verb, args, reinterpret_cast<void(*)(void*,int,json_object*,afb_req_t)>(callback), reinterpret_cast<void*>(closure));
525 }
526
527 inline bool req::subcallsync(const char *api, const char *verb, json_object *args, struct json_object *&result) const
528 {
529         return !afb_req_subcall_sync_legacy(req_, api, verb, args, &result);
530 }
531
532 inline void req::verbose(int level, const char *file, int line, const char * func, const char *fmt, va_list args) const
533 {
534         afb_req_verbose(req_, level, file, line, func, fmt, args);
535 }
536
537 inline void req::verbose(int level, const char *file, int line, const char * func, const char *fmt, ...) const
538 {
539         va_list args;
540         va_start(args, fmt);
541         afb_req_verbose(req_, level, file, line, func, fmt, args);
542         va_end(args);
543 }
544
545 inline bool req::has_permission(const char *permission) const
546 {
547         return bool(afb_req_has_permission(req_, permission));
548 }
549
550 inline char *req::get_application_id() const
551 {
552         return afb_req_get_application_id(req_);
553 }
554
555 inline int req::get_uid() const
556 {
557         return afb_req_get_uid(req_);
558 }
559
560 inline json_object *req::get_client_info() const
561 {
562         return afb_req_get_client_info(req_);
563 }
564
565 /* commons */
566 inline int broadcast_event(const char *name, json_object *object)
567         { return afb_daemon_broadcast_event(name, object); }
568
569 inline event make_event(const char *name)
570         { return afb_daemon_make_event(name); }
571
572 inline void verbose(int level, const char *file, int line, const char * func, const char *fmt, va_list args)
573         { afb_daemon_verbose(level, file, line, func, fmt, args); }
574
575 inline void verbose(int level, const char *file, int line, const char * func, const char *fmt, ...)
576         { va_list args; va_start(args, fmt); verbose(level, file, line, func, fmt, args); va_end(args); }
577
578 inline int rootdir_get_fd()
579         { return afb_daemon_rootdir_get_fd(); }
580
581 inline int rootdir_open_locale_fd(const char *filename, int flags, const char *locale)
582         { return afb_daemon_rootdir_open_locale(filename, flags, locale); }
583
584 inline int queue_job(void (*callback)(int signum, void *arg), void *argument, void *group, int timeout)
585         { return afb_daemon_queue_job(callback, argument, group, timeout); }
586
587 inline int require_api(const char *apiname, bool initialized)
588         { return afb_daemon_require_api(apiname, int(initialized)); }
589
590 inline int add_alias(const char *apiname, const char *aliasname)
591         { return afb_daemon_add_alias(apiname, aliasname); }
592
593 inline int logmask()
594         { return afb_get_logmask(); }
595
596 inline bool wants_errors()
597         { return AFB_SYSLOG_MASK_WANT_ERROR(logmask()); }
598
599 inline bool wants_warnings()
600         { return AFB_SYSLOG_MASK_WANT_WARNING(logmask()); }
601
602 inline bool wants_notices()
603         { return AFB_SYSLOG_MASK_WANT_NOTICE(logmask()); }
604
605 inline bool wants_infos()
606         { return AFB_SYSLOG_MASK_WANT_INFO(logmask()); }
607
608 inline bool wants_debugs()
609         { return AFB_SYSLOG_MASK_WANT_DEBUG(logmask()); }
610
611 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)
612 {
613         afb_service_call(api, verb, args, callback, closure);
614 }
615
616 template <class T>
617 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)
618 {
619         afb_service_call(api, verb, args, reinterpret_cast<void(*)(void*,json_object*,const char*, const char*,afb_api_t)>(callback), reinterpret_cast<void*>(closure));
620 }
621
622 inline bool callsync(const char *api, const char *verb, struct json_object *args, struct json_object *&result, char *&error, char *&info)
623 {
624         return !!afb_service_call_sync(api, verb, args, &result, &error, &info);
625 }
626
627 /*************************************************************************/
628 /* declaration of the binding's authorization s                          */
629 /*************************************************************************/
630
631 constexpr afb_auth auth_no()
632 {
633         afb_auth r = { afb_auth_No, 0, 0};
634         r.type = afb_auth_No;
635         return r;
636 }
637
638 constexpr afb_auth auth_yes()
639 {
640         afb_auth r = { afb_auth_No, 0, 0};
641         r.type = afb_auth_Yes;
642         return r;
643 }
644
645 constexpr afb_auth auth_token()
646 {
647         afb_auth r = { afb_auth_No, 0, 0};
648         r.type = afb_auth_Token;
649         return r;
650 }
651
652 constexpr afb_auth auth_LOA(unsigned loa)
653 {
654         afb_auth r = { afb_auth_No, 0, 0};
655         r.type = afb_auth_LOA;
656         r.loa = loa;
657         return r;
658 }
659
660 constexpr afb_auth auth_permission(const char *permission)
661 {
662         afb_auth r = { afb_auth_No, 0, 0};
663         r.type = afb_auth_Permission;
664         r.text = permission;
665         return r;
666 }
667
668 constexpr afb_auth auth_not(const afb_auth *other)
669 {
670         afb_auth r = { afb_auth_No, 0, 0};
671         r.type = afb_auth_Not;
672         r.first = other;
673         return r;
674 }
675
676 constexpr afb_auth auth_not(const afb_auth &other)
677 {
678         return auth_not(&other);
679 }
680
681 constexpr afb_auth auth_or(const afb_auth *first, const afb_auth *next)
682 {
683         afb_auth r = { afb_auth_No, 0, 0};
684         r.type = afb_auth_Or;
685         r.first = first;
686         r.next = next;
687         return r;
688 }
689
690 constexpr afb_auth auth_or(const afb_auth &first, const afb_auth &next)
691 {
692         return auth_or(&first, &next);
693 }
694
695 constexpr afb_auth auth_and(const afb_auth *first, const afb_auth *next)
696 {
697         afb_auth r = { afb_auth_No, 0, 0};
698         r.type = afb_auth_And;
699         r.first = first;
700         r.next = next;
701         return r;
702 }
703
704 constexpr afb_auth auth_and(const afb_auth &first, const afb_auth &next)
705 {
706         return auth_and(&first, &next);
707 }
708
709 constexpr afb_verb_t verb(
710         const char *name,
711         void (*callback)(afb_req_t),
712         const char *info = nullptr,
713         uint16_t session = 0,
714         const afb_auth *auth = nullptr,
715         bool glob = false,
716         void *vcbdata = nullptr
717 )
718 {
719         afb_verb_t r = { 0, 0, 0, 0, 0, 0, 0 };
720         r.verb = name;
721         r.callback = callback;
722         r.info = info;
723         r.session = session;
724         r.auth = auth;
725         r.glob = (unsigned)glob;
726         r.vcbdata = vcbdata;
727         return r;
728 }
729
730 void __attribute__((weak)) __afb__verb__cb__for__global__(afb_req_t r)
731 {
732         void *vcbdata;
733         void (*callback)(req);
734
735         vcbdata = afb_req_get_vcbdata(r);
736         callback = reinterpret_cast<void(*)(req)>(vcbdata);
737         callback(req(r));
738 }
739
740 constexpr afb_verb_t verb(
741         const char *name,
742         void (&callback)(req),
743         const char *info = nullptr,
744         uint16_t session = 0,
745         const afb_auth *auth = nullptr,
746         bool glob = false,
747         void *vcbdata = nullptr
748 )
749 {
750         return verb(
751                 name,
752                 __afb__verb__cb__for__global__,
753                 info,
754                 session,
755                 auth,
756                 glob,
757                 (void*)(&callback)
758         );
759 }
760
761 constexpr afb_verb_t verbend()
762 {
763         afb_verb_t r = verb(nullptr, nullptr);
764         return r;
765 }
766
767 constexpr afb_binding_t binding(
768         const char *name,
769         const afb_verb_t *verbs,
770         const char *info = nullptr,
771         int (*init)(afb_api_t) = nullptr,
772         const char *specification = nullptr,
773         void (*onevent)(afb_api_t, const char*, struct json_object*) = nullptr,
774         bool noconcurrency = false,
775         int (*preinit)(afb_api_t) = nullptr,
776         void *userdata = nullptr
777 )
778 {
779         afb_binding_t r = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
780         r.api = name;
781         r.specification = specification;
782         r.info = info;
783         r.verbs = verbs;
784         r.preinit = preinit;
785         r.init = init;
786         r.onevent = onevent;
787         r.noconcurrency = noconcurrency ? 1 : 0;
788         r.userdata = userdata;
789         return r;
790 };
791
792 /*************************************************************************/
793 /***                         E N D                                     ***/
794 /*************************************************************************/
795 }