include/afb/c++/binding-wrap.hpp

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