X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fafb-xreq.c;h=ea830d9df048ef6237220b182c95b6ca2386e3fd;hb=86134053455a621eac709d2a2d766b80b7ba7ec7;hp=4282f624afe2c8116c611bc9929938462a30dff4;hpb=03f863dd080d32f71c4a0755c02e23c72e4cb342;p=src%2Fapp-framework-binder.git diff --git a/src/afb-xreq.c b/src/afb-xreq.c index 4282f624..ea830d9d 100644 --- a/src/afb-xreq.c +++ b/src/afb-xreq.c @@ -16,37 +16,319 @@ */ #define _GNU_SOURCE -#define NO_BINDING_VERBOSE_MACRO #include +#include #include #include #include -#include +#include +#include #include "afb-context.h" #include "afb-xreq.h" #include "afb-evt.h" #include "afb-msg-json.h" -#include "afb-subcall.h" +#include "afb-cred.h" #include "afb-hook.h" +#include "afb-api.h" +#include "afb-apiset.h" +#include "afb-auth.h" +#include "jobs.h" #include "verbose.h" +/******************************************************************************/ + +static inline void xreq_addref(struct afb_xreq *xreq) +{ + __atomic_add_fetch(&xreq->refcount, 1, __ATOMIC_RELAXED); +} + +static inline void xreq_unref(struct afb_xreq *xreq) +{ + if (!__atomic_sub_fetch(&xreq->refcount, 1, __ATOMIC_RELAXED)) { + if (!xreq->replied) + afb_xreq_fail(xreq, "error", "no reply"); + if (xreq->hookflags) + afb_hook_xreq_end(xreq); + if (xreq->caller) + xreq_unref(xreq->caller); + xreq->queryitf->unref(xreq); + } +} + +/******************************************************************************/ + +extern const struct afb_req_itf xreq_itf; +extern const struct afb_req_itf xreq_hooked_itf; + +static inline struct afb_req to_req(struct afb_xreq *xreq) +{ + return (struct afb_req){ .itf = xreq->hookflags ? &xreq_hooked_itf : &xreq_itf, .closure = xreq }; +} + +/******************************************************************************/ + +struct subcall +{ + struct afb_xreq xreq; + + void (*completion)(struct subcall*, int, struct json_object*); + + union { + struct { + struct jobloop *jobloop; + struct json_object *result; + int status; + }; + struct { + union { + void (*callback)(void*, int, struct json_object*); + void (*callback2)(void*, int, struct json_object*, struct afb_req); + }; + void *closure; + }; + }; +}; + +static int subcall_subscribe_cb(struct afb_xreq *xreq, struct afb_event event) +{ + struct subcall *subcall = CONTAINER_OF_XREQ(struct subcall, xreq); + + return afb_xreq_subscribe(subcall->xreq.caller, event); +} + +static int subcall_unsubscribe_cb(struct afb_xreq *xreq, struct afb_event event) +{ + struct subcall *subcall = CONTAINER_OF_XREQ(struct subcall, xreq); + + return afb_xreq_unsubscribe(subcall->xreq.caller, event); +} + +static void subcall_reply_cb(struct afb_xreq *xreq, int status, struct json_object *result) +{ + struct subcall *subcall = CONTAINER_OF_XREQ(struct subcall, xreq); + + subcall->completion(subcall, status, result); + json_object_put(result); + afb_xreq_unref(&subcall->xreq); +} + +static void subcall_destroy_cb(struct afb_xreq *xreq) +{ + struct subcall *subcall = CONTAINER_OF_XREQ(struct subcall, xreq); + + json_object_put(subcall->xreq.json); + afb_cred_unref(subcall->xreq.cred); + free(subcall); +} + +const struct afb_xreq_query_itf afb_xreq_subcall_itf = { + .reply = subcall_reply_cb, + .unref = subcall_destroy_cb, + .subscribe = subcall_subscribe_cb, + .unsubscribe = subcall_unsubscribe_cb +}; + +static struct subcall *subcall_alloc( + struct afb_xreq *caller, + const char *api, + const char *verb, + struct json_object *args +) +{ + struct subcall *subcall; + size_t lenapi, lenverb; + char *copy; + + lenapi = 1 + strlen(api); + lenverb = 1 + strlen(verb); + subcall = malloc(lenapi + lenverb + sizeof *subcall); + if (!subcall) + ERROR("out of memory"); + else { + copy = (char*)&subcall[1]; + memcpy(copy, api, lenapi); + api = copy; + copy = ©[lenapi]; + memcpy(copy, verb, lenverb); + verb = copy; + + afb_xreq_init(&subcall->xreq, &afb_xreq_subcall_itf); + afb_context_subinit(&subcall->xreq.context, &caller->context); + subcall->xreq.cred = afb_cred_addref(caller->cred); + subcall->xreq.json = args; + subcall->xreq.api = api; + subcall->xreq.verb = verb; + subcall->xreq.caller = caller; + xreq_addref(caller); + } + return subcall; +} + + +static void subcall_on_reply(struct subcall *subcall, int status, struct json_object *result) +{ + subcall->callback(subcall->closure, status, result); +} + +static void subcall_req_on_reply(struct subcall *subcall, int status, struct json_object *result) +{ + subcall->callback2(subcall->closure, status, result, to_req(subcall->xreq.caller)); +} + +static void subcall_hooked_on_reply(struct subcall *subcall, int status, struct json_object *result) +{ + afb_hook_xreq_subcall_result(subcall->xreq.caller, status, result); + subcall_on_reply(subcall, status, result); +} + +static void subcall_req_hooked_on_reply(struct subcall *subcall, int status, struct json_object *result) +{ + afb_hook_xreq_subcall_req_result(subcall->xreq.caller, status, result); + subcall_req_on_reply(subcall, status, result); +} + +static void subcall_reply_direct_cb(void *closure, int status, struct json_object *result) +{ + struct afb_xreq *xreq = closure; + + if (xreq->replied) { + ERROR("subcall replied more than one time!!"); + json_object_put(result); + } else { + xreq->replied = 1; + subcall_reply_cb(xreq, status, result); + } +} + +static void subcall_process(struct subcall *subcall, void (*completion)(struct subcall*, int, struct json_object*)) +{ + subcall->completion = completion; + if (subcall->xreq.caller->queryitf->subcall) { + subcall->xreq.caller->queryitf->subcall( + subcall->xreq.caller, subcall->xreq.api, subcall->xreq.verb, + subcall->xreq.json, subcall_reply_direct_cb, &subcall->xreq); + } else { + afb_xreq_addref(&subcall->xreq); + afb_xreq_process(&subcall->xreq, subcall->xreq.caller->apiset); + } +} + +static void subcall(struct subcall *subcall, void (*callback)(void*, int, struct json_object*), void *cb_closure) +{ + subcall->callback = callback; + subcall->closure = cb_closure; + subcall_process(subcall, subcall_on_reply); +} + +static void subcall_req(struct subcall *subcall, void (*callback)(void*, int, struct json_object*, struct afb_req), void *cb_closure) +{ + subcall->callback2 = callback; + subcall->closure = cb_closure; + subcall_process(subcall, subcall_req_on_reply); +} + +static void subcall_hooked(struct subcall *subcall, void (*callback)(void*, int, struct json_object*), void *cb_closure) +{ + subcall->callback = callback; + subcall->closure = cb_closure; + subcall_process(subcall, subcall_hooked_on_reply); +} + +static void subcall_req_hooked(struct subcall *subcall, void (*callback)(void*, int, struct json_object*, struct afb_req), void *cb_closure) +{ + subcall->callback2 = callback; + subcall->closure = cb_closure; + subcall_process(subcall, subcall_req_hooked_on_reply); +} + +static void subcall_sync_leave(struct subcall *subcall) +{ + struct jobloop *jobloop = __atomic_exchange_n(&subcall->jobloop, NULL, __ATOMIC_RELAXED); + if (jobloop) + jobs_leave(jobloop); +} + +static void subcall_sync_reply(struct subcall *subcall, int status, struct json_object *result) +{ + subcall->status = status; + subcall->result = json_object_get(result); + subcall_sync_leave(subcall); +} + +static void subcall_sync_enter(int signum, void *closure, struct jobloop *jobloop) +{ + struct subcall *subcall = closure; + + if (!signum) { + subcall->jobloop = jobloop; + subcall->result = NULL; + subcall->status = 0; + subcall_process(subcall, subcall_sync_reply); + } else { + subcall->status = -1; + subcall_sync_leave(subcall); + } +} + +static int subcallsync(struct subcall *subcall, struct json_object **result) +{ + int rc; + + afb_xreq_addref(&subcall->xreq); + rc = jobs_enter(NULL, 0, subcall_sync_enter, subcall); + *result = subcall->result; + if (rc < 0 || subcall->status < 0) { + *result = *result ?: afb_msg_json_internal_error(); + rc = -1; + } + afb_xreq_unref(&subcall->xreq); + return rc; +} + +/******************************************************************************/ + +static void vinfo(void *first, void *second, const char *fmt, va_list args, void (*fun)(void*,void*,const char*)) +{ + char *info; + if (fmt == NULL || vasprintf(&info, fmt, args) < 0) + info = NULL; + fun(first, second, info); + free(info); +} + +/******************************************************************************/ static struct json_object *xreq_json_cb(void *closure) { struct afb_xreq *xreq = closure; - return xreq->json ? : (xreq->json = xreq->queryitf->json(xreq)); + if (!xreq->json && xreq->queryitf->json) + xreq->json = xreq->queryitf->json(xreq); + return xreq->json; } static struct afb_arg xreq_get_cb(void *closure, const char *name) { struct afb_xreq *xreq = closure; + struct afb_arg arg; + struct json_object *object, *value; + if (xreq->queryitf->get) - return xreq->queryitf->get(xreq, name); - else - return afb_msg_json_get_arg(xreq_json_cb(closure), name); + arg = xreq->queryitf->get(xreq, name); + else { + object = xreq_json_cb(closure); + if (json_object_object_get_ex(object, name, &value)) { + arg.name = name; + arg.value = json_object_get_string(value); + } else { + arg.name = NULL; + arg.value = NULL; + } + arg.path = NULL; + } + return arg; } static void xreq_success_cb(void *closure, struct json_object *obj, const char *info) @@ -76,26 +358,18 @@ static void xreq_fail_cb(void *closure, const char *status, const char *info) if (xreq->queryitf->fail) xreq->queryitf->fail(xreq, status, info); else - xreq->queryitf->reply(xreq, 1, afb_msg_json_reply_error(status, info, &xreq->context, NULL)); + xreq->queryitf->reply(xreq, -1, afb_msg_json_reply_error(status, info, &xreq->context, NULL)); } } -static const char *xreq_raw_cb(void *closure, size_t *size) +static void xreq_vsuccess_cb(void *closure, struct json_object *obj, const char *fmt, va_list args) { - struct afb_xreq *xreq = closure; - const char *result = json_object_to_json_string(xreq_json_cb(xreq)); - if (size != NULL) - *size = strlen(result); - return result; + vinfo(closure, obj, fmt, args, (void*)xreq_success_cb); } -static void xreq_send_cb(void *closure, const char *buffer, size_t size) +static void xreq_vfail_cb(void *closure, const char *status, const char *fmt, va_list args) { - struct json_object *obj = json_tokener_parse(buffer); - if (!obj == !buffer) - xreq_success_cb(closure, obj, "fake send"); - else - xreq_fail_cb(closure, "fake-send-failed", "fake send"); + vinfo(closure, (void*)status, fmt, args, (void*)xreq_fail_cb); } static void *xreq_context_get_cb(void *closure) @@ -113,15 +387,13 @@ static void xreq_context_set_cb(void *closure, void *value, void (*free_value)(v static void xreq_addref_cb(void *closure) { struct afb_xreq *xreq = closure; - __atomic_add_fetch(&xreq->refcount, 1, __ATOMIC_RELAXED); + xreq_addref(xreq); } static void xreq_unref_cb(void *closure) { struct afb_xreq *xreq = closure; - if (!__atomic_sub_fetch(&xreq->refcount, 1, __ATOMIC_RELAXED)) { - xreq->queryitf->unref(xreq); - } + xreq_unref(xreq); } static void xreq_session_close_cb(void *closure) @@ -173,19 +445,89 @@ int afb_xreq_unsubscribe(struct afb_xreq *xreq, struct afb_event event) static void xreq_subcall_cb(void *closure, const char *api, const char *verb, struct json_object *args, void (*callback)(void*, int, struct json_object*), void *cb_closure) { struct afb_xreq *xreq = closure; + struct subcall *sc; - if (xreq->queryitf->subcall) - xreq->queryitf->subcall(xreq, api, verb, args, callback, cb_closure); - else - afb_subcall(xreq, api, verb, args, callback, cb_closure); + sc = subcall_alloc(xreq, api, verb, args); + if (sc == NULL) { + if (callback) + callback(cb_closure, 1, afb_msg_json_internal_error()); + json_object_put(args); + } else { + subcall(sc, callback, cb_closure); + } +} + +static void xreq_subcall_req_cb(void *closure, const char *api, const char *verb, struct json_object *args, void (*callback)(void*, int, struct json_object*, struct afb_req), void *cb_closure) +{ + struct afb_xreq *xreq = closure; + struct subcall *sc; + + sc = subcall_alloc(xreq, api, verb, args); + if (sc == NULL) { + if (callback) + callback(cb_closure, 1, afb_msg_json_internal_error(), to_req(xreq)); + json_object_put(args); + } else { + subcall_req(sc, callback, cb_closure); + } } + static int xreq_subcallsync_cb(void *closure, const char *api, const char *verb, struct json_object *args, struct json_object **result) +{ + int rc; + struct subcall *sc; + struct afb_xreq *xreq = closure; + struct json_object *resu; + + sc = subcall_alloc(xreq, api, verb, args); + if (!sc) { + rc = -1; + resu = afb_msg_json_internal_error(); + json_object_put(args); + } else { + rc = subcallsync(sc, &resu); + } + if (result) + *result = resu; + else + json_object_put(resu); + return rc; +} + +static void xreq_vverbose_cb(void*closure, int level, const char *file, int line, const char *func, const char *fmt, va_list args) +{ + char *p; + struct afb_xreq *xreq = closure; + + if (!fmt || vasprintf(&p, fmt, args) < 0) + vverbose(level, file, line, func, fmt, args); + else { + verbose(level, file, line, func, "[REQ/API %s] %s", xreq->api, p); + free(p); + } +} + +static struct afb_stored_req *xreq_store_cb(void *closure) +{ + xreq_addref_cb(closure); + return closure; +} + +static int xreq_has_permission_cb(void*closure, const char *permission) +{ + struct afb_xreq *xreq = closure; + return afb_auth_has_permission(xreq, permission); +} + +static char *xreq_get_application_id_cb(void*closure) { struct afb_xreq *xreq = closure; - return afb_subcall_sync(xreq, api, verb, args, result); + return xreq->cred && xreq->cred->id ? strdup(xreq->cred->id) : NULL; } +/******************************************************************************/ + static struct json_object *xreq_hooked_json_cb(void *closure) { struct json_object *r = xreq_json_cb(closure); @@ -214,19 +556,14 @@ static void xreq_hooked_fail_cb(void *closure, const char *status, const char *i xreq_fail_cb(closure, status, info); } -static const char *xreq_hooked_raw_cb(void *closure, size_t *size) +static void xreq_hooked_vsuccess_cb(void *closure, struct json_object *obj, const char *fmt, va_list args) { - size_t s; - const char *r = xreq_raw_cb(closure, size ? : &s); - struct afb_xreq *xreq = closure; - return afb_hook_xreq_raw(xreq, r, *(size ? : &s)); + vinfo(closure, obj, fmt, args, (void*)xreq_hooked_success_cb); } -static void xreq_hooked_send_cb(void *closure, const char *buffer, size_t size) +static void xreq_hooked_vfail_cb(void *closure, const char *status, const char *fmt, va_list args) { - struct afb_xreq *xreq = closure; - afb_hook_xreq_send(xreq, buffer, size); - xreq_send_cb(closure, buffer, size); + vinfo(closure, (void*)status, fmt, args, (void*)xreq_hooked_fail_cb); } static void *xreq_hooked_context_get_cb(void *closure) @@ -254,10 +591,7 @@ static void xreq_hooked_unref_cb(void *closure) { struct afb_xreq *xreq = closure; afb_hook_xreq_unref(xreq); - if (!__atomic_sub_fetch(&xreq->refcount, 1, __ATOMIC_RELAXED)) { - afb_hook_xreq_end(xreq); - xreq->queryitf->unref(xreq); - } + xreq_unref_cb(closure); } static void xreq_hooked_session_close_cb(void *closure) @@ -288,35 +622,35 @@ static int xreq_hooked_unsubscribe_cb(void *closure, struct afb_event event) return afb_hook_xreq_unsubscribe(xreq, event, r); } -struct reply +static void xreq_hooked_subcall_cb(void *closure, const char *api, const char *verb, struct json_object *args, void (*callback)(void*, int, struct json_object*), void *cb_closure) { - struct afb_xreq *xreq; - void (*callback)(void*, int, struct json_object*); - void *closure; -}; + struct afb_xreq *xreq = closure; + struct subcall *sc; -static void xreq_hooked_subcall_reply_cb(void *closure, int iserror, struct json_object *result) -{ - struct reply *reply = closure; - - afb_hook_xreq_subcall_result(reply->xreq, iserror, result); - reply->callback(reply->closure, iserror, result); - free(reply); + afb_hook_xreq_subcall(xreq, api, verb, args); + sc = subcall_alloc(xreq, api, verb, args); + if (sc == NULL) { + if (callback) + callback(cb_closure, 1, afb_msg_json_internal_error()); + json_object_put(args); + } else { + subcall_hooked(sc, callback, cb_closure); + } } -static void xreq_hooked_subcall_cb(void *closure, const char *api, const char *verb, struct json_object *args, void (*callback)(void*, int, struct json_object*), void *cb_closure) +static void xreq_hooked_subcall_req_cb(void *closure, const char *api, const char *verb, struct json_object *args, void (*callback)(void*, int, struct json_object*, struct afb_req), void *cb_closure) { - struct reply *reply = malloc(sizeof *reply); struct afb_xreq *xreq = closure; - afb_hook_xreq_subcall(xreq, api, verb, args); - if (reply) { - reply->xreq = xreq; - reply->callback = callback; - reply->closure = cb_closure; - xreq_subcall_cb(closure, api, verb, args, xreq_hooked_subcall_reply_cb, reply); + struct subcall *sc; + + afb_hook_xreq_subcall_req(xreq, api, verb, args); + sc = subcall_alloc(xreq, api, verb, args); + if (sc == NULL) { + if (callback) + callback(cb_closure, 1, afb_msg_json_internal_error(), to_req(xreq)); + json_object_put(args); } else { - ERROR("out of memory"); - xreq_subcall_cb(closure, api, verb, args, callback, cb_closure); + subcall_req_hooked(sc, callback, cb_closure); } } @@ -329,13 +663,47 @@ static int xreq_hooked_subcallsync_cb(void *closure, const char *api, const char return afb_hook_xreq_subcallsync_result(xreq, r, *result); } +static void xreq_hooked_vverbose_cb(void*closure, int level, const char *file, int line, const char *func, const char *fmt, va_list args) +{ + struct afb_xreq *xreq = closure; + va_list ap; + va_copy(ap, args); + xreq_vverbose_cb(closure, level, file, line, func, fmt, args); + afb_hook_xreq_vverbose(xreq, level, file, line, func, fmt, ap); + va_end(ap); +} + +static struct afb_stored_req *xreq_hooked_store_cb(void *closure) +{ + struct afb_xreq *xreq = closure; + struct afb_stored_req *r = xreq_store_cb(closure); + afb_hook_xreq_store(xreq, r); + return r; +} + +static int xreq_hooked_has_permission_cb(void*closure, const char *permission) +{ + struct afb_xreq *xreq = closure; + int r = xreq_has_permission_cb(closure, permission); + return afb_hook_xreq_has_permission(xreq, permission, r); +} + +static char *xreq_hooked_get_application_id_cb(void*closure) +{ + struct afb_xreq *xreq = closure; + char *r = xreq_get_application_id_cb(closure); + return afb_hook_xreq_get_application_id(xreq, r); +} + +/******************************************************************************/ + const struct afb_req_itf xreq_itf = { .json = xreq_json_cb, .get = xreq_get_cb, .success = xreq_success_cb, .fail = xreq_fail_cb, - .raw = xreq_raw_cb, - .send = xreq_send_cb, + .vsuccess = xreq_vsuccess_cb, + .vfail = xreq_vfail_cb, .context_get = xreq_context_get_cb, .context_set = xreq_context_set_cb, .addref = xreq_addref_cb, @@ -345,7 +713,12 @@ const struct afb_req_itf xreq_itf = { .subscribe = xreq_subscribe_cb, .unsubscribe = xreq_unsubscribe_cb, .subcall = xreq_subcall_cb, - .subcallsync = xreq_subcallsync_cb + .subcallsync = xreq_subcallsync_cb, + .vverbose = xreq_vverbose_cb, + .store = xreq_store_cb, + .subcall_req = xreq_subcall_req_cb, + .has_permission = xreq_has_permission_cb, + .get_application_id = xreq_get_application_id_cb }; const struct afb_req_itf xreq_hooked_itf = { @@ -353,8 +726,8 @@ const struct afb_req_itf xreq_hooked_itf = { .get = xreq_hooked_get_cb, .success = xreq_hooked_success_cb, .fail = xreq_hooked_fail_cb, - .raw = xreq_hooked_raw_cb, - .send = xreq_hooked_send_cb, + .vsuccess = xreq_hooked_vsuccess_cb, + .vfail = xreq_hooked_vfail_cb, .context_get = xreq_hooked_context_get_cb, .context_set = xreq_hooked_context_set_cb, .addref = xreq_hooked_addref_cb, @@ -364,12 +737,27 @@ const struct afb_req_itf xreq_hooked_itf = { .subscribe = xreq_hooked_subscribe_cb, .unsubscribe = xreq_hooked_unsubscribe_cb, .subcall = xreq_hooked_subcall_cb, - .subcallsync = xreq_hooked_subcallsync_cb + .subcallsync = xreq_hooked_subcallsync_cb, + .vverbose = xreq_hooked_vverbose_cb, + .store = xreq_hooked_store_cb, + .subcall_req = xreq_hooked_subcall_req_cb, + .has_permission = xreq_hooked_has_permission_cb, + .get_application_id = xreq_hooked_get_application_id_cb }; -static inline struct afb_req to_req(struct afb_xreq *xreq) +/******************************************************************************/ + +struct afb_req afb_xreq_unstore(struct afb_stored_req *sreq) { - return (struct afb_req){ .itf = xreq->hookflags ? &xreq_hooked_itf : &xreq_itf, .closure = xreq }; + struct afb_xreq *xreq = (struct afb_xreq *)sreq; + if (xreq->hookflags) + afb_hook_xreq_unstore(xreq); + return to_req(xreq); +} + +struct json_object *afb_xreq_json(struct afb_xreq *xreq) +{ + return afb_req_json(to_req(xreq)); } void afb_xreq_success(struct afb_xreq *xreq, struct json_object *obj, const char *info) @@ -408,7 +796,11 @@ void afb_xreq_fail_f(struct afb_xreq *xreq, const char *status, const char *info const char *afb_xreq_raw(struct afb_xreq *xreq, size_t *size) { - return afb_req_raw(to_req(xreq), size); + struct json_object *obj = xreq_json_cb(xreq); + const char *result = json_object_to_json_string(obj); + if (size != NULL) + *size = strlen(result); + return result; } void afb_xreq_addref(struct afb_xreq *xreq) @@ -431,67 +823,196 @@ void afb_xreq_subcall(struct afb_xreq *xreq, const char *api, const char *verb, afb_req_subcall(to_req(xreq), api, verb, args, callback, cb_closure); } -static int xcheck(struct afb_xreq *xreq, int sessionflags) +int afb_xreq_unhooked_subcall_sync(struct afb_xreq *xreq, const char *api, const char *verb, struct json_object *args, struct json_object **result) +{ + return xreq_subcallsync_cb(xreq, api, verb, args, result); +} + +int afb_xreq_subcall_sync(struct afb_xreq *xreq, const char *api, const char *verb, struct json_object *args, struct json_object **result) +{ + return afb_req_subcall_sync(to_req(xreq), api, verb, args, result); +} + +static int xreq_session_check_apply_v1(struct afb_xreq *xreq, int sessionflags) { - if ((sessionflags & (AFB_SESSION_CREATE|AFB_SESSION_CLOSE|AFB_SESSION_RENEW|AFB_SESSION_CHECK|AFB_SESSION_LOA_EQ)) != 0) { + int loa; + + if ((sessionflags & (AFB_SESSION_CLOSE_V1|AFB_SESSION_RENEW_V1|AFB_SESSION_CHECK_V1|AFB_SESSION_LOA_EQ_V1)) != 0) { if (!afb_context_check(&xreq->context)) { afb_context_close(&xreq->context); - afb_xreq_fail_f(xreq, "failed", "invalid token's identity"); - return 0; + afb_xreq_fail_f(xreq, "denied", "invalid token's identity"); + errno = EINVAL; + return -1; } } - if ((sessionflags & AFB_SESSION_CREATE) != 0) { - if (afb_context_check_loa(&xreq->context, 1)) { - afb_xreq_fail_f(xreq, "failed", "invalid creation state"); - return 0; + if ((sessionflags & AFB_SESSION_LOA_GE_V1) != 0) { + loa = (sessionflags >> AFB_SESSION_LOA_SHIFT_V1) & AFB_SESSION_LOA_MASK_V1; + if (!afb_context_check_loa(&xreq->context, loa)) { + afb_xreq_fail_f(xreq, "denied", "invalid LOA"); + errno = EPERM; + return -1; } - afb_context_change_loa(&xreq->context, 1); - afb_context_refresh(&xreq->context); } - if ((sessionflags & (AFB_SESSION_CREATE | AFB_SESSION_RENEW)) != 0) - afb_context_refresh(&xreq->context); + if ((sessionflags & AFB_SESSION_LOA_LE_V1) != 0) { + loa = (sessionflags >> AFB_SESSION_LOA_SHIFT_V1) & AFB_SESSION_LOA_MASK_V1; + if (afb_context_check_loa(&xreq->context, loa + 1)) { + afb_xreq_fail_f(xreq, "denied", "invalid LOA"); + errno = EPERM; + return -1; + } + } - if ((sessionflags & AFB_SESSION_CLOSE) != 0) { + if ((sessionflags & AFB_SESSION_RENEW_V1) != 0) { + afb_context_refresh(&xreq->context); + } + if ((sessionflags & AFB_SESSION_CLOSE_V1) != 0) { afb_context_change_loa(&xreq->context, 0); afb_context_close(&xreq->context); } - if ((sessionflags & AFB_SESSION_LOA_GE) != 0) { - int loa = (sessionflags >> AFB_SESSION_LOA_SHIFT) & AFB_SESSION_LOA_MASK; - if (!afb_context_check_loa(&xreq->context, loa)) { - afb_xreq_fail_f(xreq, "failed", "invalid LOA"); - return 0; + return 0; +} + +static int xreq_session_check_apply_v2(struct afb_xreq *xreq, uint32_t sessionflags, const struct afb_auth *auth) +{ + int loa; + + if (sessionflags != 0) { + if (!afb_context_check(&xreq->context)) { + afb_context_close(&xreq->context); + afb_xreq_fail_f(xreq, "denied", "invalid token's identity"); + errno = EINVAL; + return -1; } } - if ((sessionflags & AFB_SESSION_LOA_LE) != 0) { - int loa = (sessionflags >> AFB_SESSION_LOA_SHIFT) & AFB_SESSION_LOA_MASK; - if (afb_context_check_loa(&xreq->context, loa + 1)) { - afb_xreq_fail_f(xreq, "failed", "invalid LOA"); - return 0; - } + loa = (int)(sessionflags & AFB_SESSION_LOA_MASK_V2); + if (loa && !afb_context_check_loa(&xreq->context, loa)) { + afb_xreq_fail_f(xreq, "denied", "invalid LOA"); + errno = EPERM; + return -1; + } + + if (auth && !afb_auth_check(xreq, auth)) { + afb_xreq_fail_f(xreq, "denied", "authorisation refused"); + errno = EPERM; + return -1; + } + + if ((sessionflags & AFB_SESSION_REFRESH_V2) != 0) { + afb_context_refresh(&xreq->context); + } + if ((sessionflags & AFB_SESSION_CLOSE_V2) != 0) { + afb_context_close(&xreq->context); } - return 1; + + return 0; } -void afb_xreq_call(struct afb_xreq *xreq, int sessionflags, void (*method)(struct afb_req req)) +void afb_xreq_call_verb_v1(struct afb_xreq *xreq, const struct afb_verb_desc_v1 *verb) { - if (xcheck(xreq, sessionflags)) - method(to_req(xreq)); + if (!verb) + afb_xreq_fail_unknown_verb(xreq); + else + if (!xreq_session_check_apply_v1(xreq, verb->session)) + verb->callback(to_req(xreq)); } -void afb_xreq_begin(struct afb_xreq *xreq) +void afb_xreq_call_verb_v2(struct afb_xreq *xreq, const struct afb_verb_v2 *verb) { - afb_hook_init_xreq(xreq); - if (xreq->hookflags) - afb_hook_xreq_begin(xreq); + if (!verb) + afb_xreq_fail_unknown_verb(xreq); + else + if (!xreq_session_check_apply_v2(xreq, verb->session, verb->auth)) + verb->callback(to_req(xreq)); } void afb_xreq_init(struct afb_xreq *xreq, const struct afb_xreq_query_itf *queryitf) { + memset(xreq, 0, sizeof *xreq); xreq->refcount = 1; xreq->queryitf = queryitf; } +void afb_xreq_fail_unknown_api(struct afb_xreq *xreq) +{ + afb_xreq_fail_f(xreq, "unknown-api", "api %s not found (for verb %s)", xreq->api, xreq->verb); +} + +void afb_xreq_fail_unknown_verb(struct afb_xreq *xreq) +{ + afb_xreq_fail_f(xreq, "unknown-verb", "verb %s unknown within api %s", xreq->verb, xreq->api); +} + +static void process_sync(struct afb_xreq *xreq) +{ + const struct afb_api *api; + + /* init hooking */ + afb_hook_init_xreq(xreq); + if (xreq->hookflags) + afb_hook_xreq_begin(xreq); + + /* search the api */ + api = (const struct afb_api*)xreq->context.api_key; + if (api) + api->itf->call(api->closure, xreq); + else { + api = afb_apiset_lookup_started(xreq->apiset, xreq->api, 1); + if (errno == ENOENT) + afb_xreq_fail_f(xreq, "unknown-api", "api %s not found", xreq->api); + else + afb_xreq_fail_f(xreq, "bad-api-state", "api %s not started correctly: %m", xreq->api); + } +} + +static void process_async(int signum, void *arg) +{ + struct afb_xreq *xreq = arg; + + if (signum != 0) { + afb_xreq_fail_f(xreq, "aborted", "signal %s(%d) caught", strsignal(signum), signum); + } else { + process_sync(xreq); + } + xreq_unref(xreq); +} + +void afb_xreq_process(struct afb_xreq *xreq, struct afb_apiset *apiset) +{ + const void *jobkey; + const struct afb_api *api; + struct afb_xreq *caller; + + xreq->apiset = apiset; + api = afb_apiset_lookup_started(apiset, xreq->api, 1); + xreq->context.api_key = api; + + if (!api || !api->noconcurrency) + jobkey = NULL; + else { + caller = xreq->caller; + while (caller) { + if (caller->context.api_key == api) { + /* noconcurrency lock detected */ + ERROR("self-lock detected in call stack for API %s", xreq->api); + afb_xreq_fail_f(xreq, "cancelled", "recursive self lock, API %s", xreq->api); + goto end; + } + caller = caller->caller; + } + jobkey = api; + } + xreq_addref(xreq); + if (jobs_queue(jobkey, afb_apiset_timeout_get(apiset), process_async, xreq) < 0) { + /* TODO: allows or not to proccess it directly as when no threading? (see above) */ + ERROR("can't process job with threads: %m"); + afb_xreq_fail_f(xreq, "cancelled", "not able to create a job for the task"); + xreq_unref(xreq); + } +end: + xreq_unref(xreq); +} +