X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fafb-hook.c;h=6a11341c2aa6bca005707ee32fa328ff96beb76b;hb=6a325d7f101c986e7329ef912c0458719f95c096;hp=5786f1940ceb292d6c8e137b6eb856d2862726c2;hpb=6f1126ae2c585afc34d0bb06f3763e3a82ee3d37;p=src%2Fapp-framework-binder.git diff --git a/src/afb-hook.c b/src/afb-hook.c index 5786f194..6a11341c 100644 --- a/src/afb-hook.c +++ b/src/afb-hook.c @@ -23,6 +23,7 @@ #include #include #include +#include #include @@ -35,6 +36,8 @@ #include "afb-cred.h" #include "afb-xreq.h" #include "afb-ditf.h" +#include "afb-svc.h" +#include "afb-evt.h" #include "verbose.h" /** @@ -63,6 +66,30 @@ struct afb_hook_ditf { void *closure; /**< closure for callbacks */ }; +/** + * Definition of a hook for svc + */ +struct afb_hook_svc { + struct afb_hook_svc *next; /**< next hook */ + unsigned refcount; /**< reference count */ + char *api; /**< api hooked or NULL for any */ + unsigned flags; /**< hook flags */ + struct afb_hook_svc_itf *itf; /**< interface of hook */ + void *closure; /**< closure for callbacks */ +}; + +/** + * Definition of a hook for evt + */ +struct afb_hook_evt { + struct afb_hook_evt *next; /**< next hook */ + unsigned refcount; /**< reference count */ + char *pattern; /**< event pattern name hooked or NULL for any */ + unsigned flags; /**< hook flags */ + struct afb_hook_evt_itf *itf; /**< interface of hook */ + void *closure; /**< closure for callbacks */ +}; + /* synchronisation across threads */ static pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER; @@ -72,26 +99,58 @@ static struct afb_hook_xreq *list_of_xreq_hooks = NULL; /* list of hooks for ditf */ static struct afb_hook_ditf *list_of_ditf_hooks = NULL; +/* list of hooks for svc */ +static struct afb_hook_svc *list_of_svc_hooks = NULL; + +/* list of hooks for evt */ +static struct afb_hook_evt *list_of_evt_hooks = NULL; + /****************************************************************************** * section: default callbacks for tracing requests *****************************************************************************/ +static char *_pbuf_(const char *fmt, va_list args, char **palloc, char *sbuf, size_t szsbuf) +{ + int rc; + va_list cp; + + *palloc = NULL; + va_copy(cp, args); + rc = vsnprintf(sbuf, szsbuf, fmt, args); + if ((size_t)rc >= szsbuf) { + sbuf[szsbuf-1] = 0; + sbuf[szsbuf-2] = sbuf[szsbuf-3] = sbuf[szsbuf-4] = '.'; + rc = vasprintf(palloc, fmt, cp); + if (rc >= 0) + sbuf = *palloc; + } + va_end(cp); + return sbuf; +} + +static void _hook_(const char *fmt1, const char *fmt2, va_list arg2, ...) +{ + char *tag, *data, *mem1, *mem2, buf1[256], buf2[2000]; + va_list arg1; + + data = _pbuf_(fmt2, arg2, &mem2, buf2, sizeof buf2); + + va_start(arg1, arg2); + tag = _pbuf_(fmt1, arg1, &mem1, buf1, sizeof buf1); + va_end(arg1); + + NOTICE("[HOOK %s] %s", tag, data); + + free(mem1); + free(mem2); +} + static void _hook_xreq_(const struct afb_xreq *xreq, const char *format, ...) { - int len; - char *buffer; va_list ap; - va_start(ap, format); - len = vasprintf(&buffer, format, ap); + _hook_("xreq-%06d:%s/%s", format, ap, xreq->hookindex, xreq->api, xreq->verb); va_end(ap); - - if (len < 0) - NOTICE("hook xreq-%06d:%s/%s allocation error", xreq->hookindex, xreq->api, xreq->verb); - else { - NOTICE("hook xreq-%06d:%s/%s %s", xreq->hookindex, xreq->api, xreq->verb, buffer); - free(buffer); - } } static void hook_xreq_begin_default_cb(void * closure, const struct afb_xreq *xreq) @@ -166,12 +225,12 @@ static void hook_xreq_session_set_LOA_default_cb(void * closure, const struct af static void hook_xreq_subscribe_default_cb(void * closure, const struct afb_xreq *xreq, struct afb_event event, int result) { - _hook_xreq_(xreq, "subscribe(%s:%p) -> %d", afb_event_name(event), event.closure, result); + _hook_xreq_(xreq, "subscribe(%s:%d) -> %d", afb_evt_event_name(event), afb_evt_event_id(event), result); } static void hook_xreq_unsubscribe_default_cb(void * closure, const struct afb_xreq *xreq, struct afb_event event, int result) { - _hook_xreq_(xreq, "unsubscribe(%s:%p) -> %d", afb_event_name(event), event.closure, result); + _hook_xreq_(xreq, "unsubscribe(%s:%d) -> %d", afb_evt_event_name(event), afb_evt_event_id(event), result); } static void hook_xreq_subcall_default_cb(void * closure, const struct afb_xreq *xreq, const char *api, const char *verb, struct json_object *args) @@ -194,6 +253,24 @@ static void hook_xreq_subcallsync_result_default_cb(void * closure, const struct _hook_xreq_(xreq, " ...subcallsync... -> %d: %s", status, json_object_to_json_string(result)); } +static void hook_xreq_vverbose_default_cb(void * closure, const struct afb_xreq *xreq, int level, const char *file, int line, const char *func, const char *fmt, va_list args) +{ + int len; + char *msg; + va_list ap; + + va_copy(ap, args); + len = vasprintf(&msg, fmt, ap); + va_end(ap); + + if (len < 0) + _hook_xreq_(xreq, "vverbose(%d, %s, %d, %s) -> %s ? ? ?", level, file, line, func, fmt); + else { + _hook_xreq_(xreq, "vverbose(%d, %s, %d, %s) -> %s", level, file, line, func, msg); + free(msg); + } +} + static struct afb_hook_xreq_itf hook_xreq_default_itf = { .hook_xreq_begin = hook_xreq_begin_default_cb, .hook_xreq_end = hook_xreq_end_default_cb, @@ -213,6 +290,7 @@ static struct afb_hook_xreq_itf hook_xreq_default_itf = { .hook_xreq_subcall_result = hook_xreq_subcall_result_default_cb, .hook_xreq_subcallsync = hook_xreq_subcallsync_default_cb, .hook_xreq_subcallsync_result = hook_xreq_subcallsync_result_default_cb, + .hook_xreq_vverbose = hook_xreq_vverbose_default_cb }; /****************************************************************************** @@ -333,8 +411,13 @@ int afb_hook_xreq_subcallsync_result(const struct afb_xreq *xreq, int status, st return status; } +void afb_hook_xreq_vverbose(const struct afb_xreq *xreq, int level, const char *file, int line, const char *func, const char *fmt, va_list args) +{ + _HOOK_XREQ_(vverbose, xreq, level, file ?: "?", line, func ?: "?", fmt, args); +} + /****************************************************************************** - * section: + * section: hooking xreqs *****************************************************************************/ void afb_hook_init_xreq(struct afb_xreq *xreq) @@ -452,20 +535,10 @@ void afb_hook_unref_xreq(struct afb_hook_xreq *hook) static void _hook_ditf_(const struct afb_ditf *ditf, const char *format, ...) { - int len; - char *buffer; va_list ap; - va_start(ap, format); - len = vasprintf(&buffer, format, ap); + _hook_("ditf-%s", format, ap, ditf->api); va_end(ap); - - if (len < 0) - NOTICE("hook ditf-%s allocation error for %s", ditf->prefix, format); - else { - NOTICE("hook ditf-%s %s", ditf->prefix, buffer); - free(buffer); - } } static void hook_ditf_event_broadcast_before_cb(void *closure, const struct afb_ditf *ditf, const char *name, struct json_object *object) @@ -513,7 +586,7 @@ static void hook_ditf_vverbose_cb(void*closure, const struct afb_ditf *ditf, int static void hook_ditf_event_make_cb(void *closure, const struct afb_ditf *ditf, const char *name, struct afb_event result) { - _hook_ditf_(ditf, "event_make(%s) -> %s:%p", name, afb_event_name(result), result.closure); + _hook_ditf_(ditf, "event_make(%s) -> %s:%d", name, afb_evt_event_name(result), afb_evt_event_id(result)); } static void hook_ditf_rootdir_get_fd_cb(void *closure, const struct afb_ditf *ditf, int result) @@ -561,7 +634,7 @@ static struct afb_hook_ditf_itf hook_ditf_default_itf = { }; /****************************************************************************** - * section: hooks for tracing requests + * section: hooks for tracing daemon interface (ditf) *****************************************************************************/ #define _HOOK_DITF_(what,...) \ @@ -571,7 +644,7 @@ static struct afb_hook_ditf_itf hook_ditf_default_itf = { while (hook) { \ if (hook->itf->hook_ditf_##what \ && (hook->flags & afb_hook_flag_ditf_##what) != 0 \ - && (!hook->api || !strcasecmp(hook->api, ditf->prefix))) { \ + && (!hook->api || !strcasecmp(hook->api, ditf->api))) { \ hook->itf->hook_ditf_##what(hook->closure, __VA_ARGS__); \ } \ hook = hook->next; \ @@ -637,7 +710,7 @@ int afb_hook_ditf_queue_job(const struct afb_ditf *ditf, void (*callback)(int si } /****************************************************************************** - * section: + * section: hooking ditf *****************************************************************************/ int afb_hook_flags_ditf(const char *api) @@ -722,3 +795,410 @@ void afb_hook_unref_ditf(struct afb_hook_ditf *hook) } } +/****************************************************************************** + * section: default callbacks for tracing service interface (svc) + *****************************************************************************/ + +static void _hook_svc_(const struct afb_svc *svc, const char *format, ...) +{ + va_list ap; + va_start(ap, format); + _hook_("svc-%s", format, ap, svc->api); + va_end(ap); +} + +static void hook_svc_start_before_default_cb(void *closure, const struct afb_svc *svc) +{ + _hook_svc_(svc, "start.before"); +} + +static void hook_svc_start_after_default_cb(void *closure, const struct afb_svc *svc, int status) +{ + _hook_svc_(svc, "start.after -> %d", status); +} + +static void hook_svc_on_event_before_default_cb(void *closure, const struct afb_svc *svc, const char *event, int eventid, struct json_object *object) +{ + _hook_svc_(svc, "on_event.before(%s, %d, %s)", event, eventid, json_object_to_json_string(object)); +} + +static void hook_svc_on_event_after_default_cb(void *closure, const struct afb_svc *svc, const char *event, int eventid, struct json_object *object) +{ + _hook_svc_(svc, "on_event.after(%s, %d, %s)", event, eventid, json_object_to_json_string(object)); +} + +static void hook_svc_call_default_cb(void *closure, const struct afb_svc *svc, const char *api, const char *verb, struct json_object *args) +{ + _hook_svc_(svc, "call(%s/%s, %s) ...", api, verb, json_object_to_json_string(args)); +} + +static void hook_svc_call_result_default_cb(void *closure, const struct afb_svc *svc, int status, struct json_object *result) +{ + _hook_svc_(svc, " ...call... -> %d: %s", status, json_object_to_json_string(result)); +} + +static void hook_svc_callsync_default_cb(void *closure, const struct afb_svc *svc, const char *api, const char *verb, struct json_object *args) +{ + _hook_svc_(svc, "callsync(%s/%s, %s) ...", api, verb, json_object_to_json_string(args)); +} + +static void hook_svc_callsync_result_default_cb(void *closure, const struct afb_svc *svc, int status, struct json_object *result) +{ + _hook_svc_(svc, " ...callsync... -> %d: %s", status, json_object_to_json_string(result)); +} + +static struct afb_hook_svc_itf hook_svc_default_itf = { + .hook_svc_start_before = hook_svc_start_before_default_cb, + .hook_svc_start_after = hook_svc_start_after_default_cb, + .hook_svc_on_event_before = hook_svc_on_event_before_default_cb, + .hook_svc_on_event_after = hook_svc_on_event_after_default_cb, + .hook_svc_call = hook_svc_call_default_cb, + .hook_svc_call_result = hook_svc_call_result_default_cb, + .hook_svc_callsync = hook_svc_callsync_default_cb, + .hook_svc_callsync_result = hook_svc_callsync_result_default_cb +}; + +/****************************************************************************** + * section: hooks for tracing service interface (svc) + *****************************************************************************/ + +#define _HOOK_SVC_(what,...) \ + struct afb_hook_svc *hook; \ + pthread_rwlock_rdlock(&rwlock); \ + hook = list_of_svc_hooks; \ + while (hook) { \ + if (hook->itf->hook_svc_##what \ + && (hook->flags & afb_hook_flag_svc_##what) != 0 \ + && (!hook->api || !strcasecmp(hook->api, svc->api))) { \ + hook->itf->hook_svc_##what(hook->closure, __VA_ARGS__); \ + } \ + hook = hook->next; \ + } \ + pthread_rwlock_unlock(&rwlock); + +void afb_hook_svc_start_before(const struct afb_svc *svc) +{ + _HOOK_SVC_(start_before, svc); +} + +int afb_hook_svc_start_after(const struct afb_svc *svc, int status) +{ + _HOOK_SVC_(start_after, svc, status); + return status; +} + +void afb_hook_svc_on_event_before(const struct afb_svc *svc, const char *event, int eventid, struct json_object *object) +{ + _HOOK_SVC_(on_event_before, svc, event, eventid, object); +} + +void afb_hook_svc_on_event_after(const struct afb_svc *svc, const char *event, int eventid, struct json_object *object) +{ + _HOOK_SVC_(on_event_after, svc, event, eventid, object); +} + +void afb_hook_svc_call(const struct afb_svc *svc, const char *api, const char *verb, struct json_object *args) +{ + _HOOK_SVC_(call, svc, api, verb, args); +} + +void afb_hook_svc_call_result(const struct afb_svc *svc, int status, struct json_object *result) +{ + _HOOK_SVC_(call_result, svc, status, result); +} + +void afb_hook_svc_callsync(const struct afb_svc *svc, const char *api, const char *verb, struct json_object *args) +{ + _HOOK_SVC_(callsync, svc, api, verb, args); +} + +int afb_hook_svc_callsync_result(const struct afb_svc *svc, int status, struct json_object *result) +{ + _HOOK_SVC_(callsync_result, svc, status, result); + return status; +} + +/****************************************************************************** + * section: hooking services (svc) + *****************************************************************************/ + +int afb_hook_flags_svc(const char *api) +{ + int flags; + struct afb_hook_svc *hook; + + pthread_rwlock_rdlock(&rwlock); + flags = 0; + hook = list_of_svc_hooks; + while (hook) { + if (!api || !hook->api || !strcasecmp(hook->api, api)) + flags |= hook->flags; + hook = hook->next; + } + pthread_rwlock_unlock(&rwlock); + return flags; +} + +struct afb_hook_svc *afb_hook_create_svc(const char *api, int flags, struct afb_hook_svc_itf *itf, void *closure) +{ + struct afb_hook_svc *hook; + + /* alloc the result */ + hook = calloc(1, sizeof *hook); + if (hook == NULL) + return NULL; + + /* get a copy of the names */ + hook->api = api ? strdup(api) : NULL; + if (api && !hook->api) { + free(hook); + return NULL; + } + + /* initialise the rest */ + hook->refcount = 1; + hook->flags = flags; + hook->itf = itf ? itf : &hook_svc_default_itf; + hook->closure = closure; + + /* record the hook */ + pthread_rwlock_wrlock(&rwlock); + hook->next = list_of_svc_hooks; + list_of_svc_hooks = hook; + pthread_rwlock_unlock(&rwlock); + + /* returns it */ + return hook; +} + +struct afb_hook_svc *afb_hook_addref_svc(struct afb_hook_svc *hook) +{ + pthread_rwlock_wrlock(&rwlock); + hook->refcount++; + pthread_rwlock_unlock(&rwlock); + return hook; +} + +void afb_hook_unref_svc(struct afb_hook_svc *hook) +{ + struct afb_hook_svc **prv; + + if (hook) { + pthread_rwlock_wrlock(&rwlock); + if (--hook->refcount) + hook = NULL; + else { + /* unlink */ + prv = &list_of_svc_hooks; + while (*prv && *prv != hook) + prv = &(*prv)->next; + if(*prv) + *prv = hook->next; + } + pthread_rwlock_unlock(&rwlock); + if (hook) { + /* free */ + free(hook->api); + free(hook); + } + } +} + +/****************************************************************************** + * section: default callbacks for tracing service interface (evt) + *****************************************************************************/ + +static void _hook_evt_(const char *evt, int id, const char *format, ...) +{ + va_list ap; + va_start(ap, format); + _hook_("evt-%s:%d", format, ap, evt, id); + va_end(ap); +} + +static void hook_evt_create_default_cb(void *closure, const char *evt, int id) +{ + _hook_evt_(evt, id, "create"); +} + +static void hook_evt_push_before_default_cb(void *closure, const char *evt, int id, struct json_object *obj) +{ + _hook_evt_(evt, id, "push.before(%s)", json_object_to_json_string(obj)); +} + + +static void hook_evt_push_after_default_cb(void *closure, const char *evt, int id, struct json_object *obj, int result) +{ + _hook_evt_(evt, id, "push.after(%s) -> %d", json_object_to_json_string(obj), result); +} + +static void hook_evt_broadcast_before_default_cb(void *closure, const char *evt, int id, struct json_object *obj) +{ + _hook_evt_(evt, id, "broadcast.before(%s)", json_object_to_json_string(obj)); +} + +static void hook_evt_broadcast_after_default_cb(void *closure, const char *evt, int id, struct json_object *obj, int result) +{ + _hook_evt_(evt, id, "broadcast.after(%s) -> %d", json_object_to_json_string(obj), result); +} + +static void hook_evt_name_default_cb(void *closure, const char *evt, int id) +{ + _hook_evt_(evt, id, "name"); +} + +static void hook_evt_drop_default_cb(void *closure, const char *evt, int id) +{ + _hook_evt_(evt, id, "drop"); +} + +static struct afb_hook_evt_itf hook_evt_default_itf = { + .hook_evt_create = hook_evt_create_default_cb, + .hook_evt_push_before = hook_evt_push_before_default_cb, + .hook_evt_push_after = hook_evt_push_after_default_cb, + .hook_evt_broadcast_before = hook_evt_broadcast_before_default_cb, + .hook_evt_broadcast_after = hook_evt_broadcast_after_default_cb, + .hook_evt_name = hook_evt_name_default_cb, + .hook_evt_drop = hook_evt_drop_default_cb +}; + +/****************************************************************************** + * section: hooks for tracing service interface (evt) + *****************************************************************************/ + +#define _HOOK_EVT_(what,...) \ + struct afb_hook_evt *hook; \ + pthread_rwlock_rdlock(&rwlock); \ + hook = list_of_evt_hooks; \ + while (hook) { \ + if (hook->itf->hook_evt_##what \ + && (hook->flags & afb_hook_flag_evt_##what) != 0 \ + && (!hook->pattern || !fnmatch(hook->pattern, evt, FNM_CASEFOLD))) { \ + hook->itf->hook_evt_##what(hook->closure, __VA_ARGS__); \ + } \ + hook = hook->next; \ + } \ + pthread_rwlock_unlock(&rwlock); + +void afb_hook_evt_create(const char *evt, int id) +{ + _HOOK_EVT_(create, evt, id); +} + +void afb_hook_evt_push_before(const char *evt, int id, struct json_object *obj) +{ + _HOOK_EVT_(push_before, evt, id, obj); +} + +int afb_hook_evt_push_after(const char *evt, int id, struct json_object *obj, int result) +{ + _HOOK_EVT_(push_after, evt, id, obj, result); + return result; +} + +void afb_hook_evt_broadcast_before(const char *evt, int id, struct json_object *obj) +{ + _HOOK_EVT_(broadcast_before, evt, id, obj); +} + +int afb_hook_evt_broadcast_after(const char *evt, int id, struct json_object *obj, int result) +{ + _HOOK_EVT_(broadcast_after, evt, id, obj, result); + return result; +} + +void afb_hook_evt_name(const char *evt, int id) +{ + _HOOK_EVT_(name, evt, id); +} + +void afb_hook_evt_drop(const char *evt, int id) +{ + _HOOK_EVT_(drop, evt, id); +} + +/****************************************************************************** + * section: hooking services (evt) + *****************************************************************************/ + +int afb_hook_flags_evt(const char *name) +{ + int flags; + struct afb_hook_evt *hook; + + pthread_rwlock_rdlock(&rwlock); + flags = 0; + hook = list_of_evt_hooks; + while (hook) { + if (!name || !hook->pattern || !fnmatch(hook->pattern, name, FNM_CASEFOLD)) + flags |= hook->flags; + hook = hook->next; + } + pthread_rwlock_unlock(&rwlock); + return flags; +} + +struct afb_hook_evt *afb_hook_create_evt(const char *pattern, int flags, struct afb_hook_evt_itf *itf, void *closure) +{ + struct afb_hook_evt *hook; + + /* alloc the result */ + hook = calloc(1, sizeof *hook); + if (hook == NULL) + return NULL; + + /* get a copy of the names */ + hook->pattern = pattern ? strdup(pattern) : NULL; + if (pattern && !hook->pattern) { + free(hook); + return NULL; + } + + /* initialise the rest */ + hook->refcount = 1; + hook->flags = flags; + hook->itf = itf ? itf : &hook_evt_default_itf; + hook->closure = closure; + + /* record the hook */ + pthread_rwlock_wrlock(&rwlock); + hook->next = list_of_evt_hooks; + list_of_evt_hooks = hook; + pthread_rwlock_unlock(&rwlock); + + /* returns it */ + return hook; +} + +struct afb_hook_evt *afb_hook_addref_evt(struct afb_hook_evt *hook) +{ + pthread_rwlock_wrlock(&rwlock); + hook->refcount++; + pthread_rwlock_unlock(&rwlock); + return hook; +} + +void afb_hook_unref_evt(struct afb_hook_evt *hook) +{ + struct afb_hook_evt **prv; + + if (hook) { + pthread_rwlock_wrlock(&rwlock); + if (--hook->refcount) + hook = NULL; + else { + /* unlink */ + prv = &list_of_evt_hooks; + while (*prv && *prv != hook) + prv = &(*prv)->next; + if(*prv) + *prv = hook->next; + } + pthread_rwlock_unlock(&rwlock); + if (hook) { + /* free */ + free(hook->pattern); + free(hook); + } + } +}