2 * Copyright (C) 2016, 2017 "IoT.bzh"
3 * Author José Bollo <jose.bollo@iot.bzh>
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
9 * http://www.apache.org/licenses/LICENSE-2.0
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.
29 #include <json-c/json.h>
30 #include <afb/afb-binding-v2.h>
34 #include "afb-session.h"
36 #include "afb-export.h"
38 #include "afb-trace.h"
40 #include "wrap-json.h"
43 /*******************************************************************************/
44 /***** default names *****/
45 /*******************************************************************************/
47 #if !defined(DEFAULT_EVENT_NAME)
48 # define DEFAULT_EVENT_NAME "trace"
50 #if !defined(DEFAULT_TAG_NAME)
51 # define DEFAULT_TAG_NAME "trace"
54 /*******************************************************************************/
56 /*******************************************************************************/
58 /* structure for searching flags by names */
61 const char *name; /** the name */
62 int value; /** the value */
67 struct tag *next; /* link to the next */
68 char tag[1]; /* name of the tag */
71 /* struct for events */
73 struct event *next; /* link to the next event */
74 struct afb_event event; /* the event */
77 /* struct for sessions */
79 struct session *next; /* link to the next session */
80 struct afb_session *session; /* the session */
81 struct afb_trace *trace; /* the tracer */
84 /* struct for recording hooks */
86 struct hook *next; /* link to next hook */
87 void *handler; /* the handler of the hook */
88 struct event *event; /* the associated event */
89 struct tag *tag; /* the associated tag */
90 struct session *session; /* the associated session */
96 Trace_Type_Xreq, /* xreq hooks */
97 Trace_Type_Ditf, /* export hooks */
98 Trace_Type_Svc, /* export hooks */
99 Trace_Type_Evt, /* evt hooks */
100 Trace_Type_Global, /* global hooks */
101 Trace_Type_Count /* count of types of hooks */
107 int refcount; /* reference count */
108 pthread_mutex_t mutex; /* concurrency management */
109 struct afb_daemon *daemon; /* daemon */
110 struct afb_session *bound; /* bound to session */
111 struct event *events; /* list of events */
112 struct tag *tags; /* list of tags */
113 struct session *sessions; /* list of tags */
114 struct hook *hooks[Trace_Type_Count]; /* hooks */
117 /*******************************************************************************/
118 /***** utility functions *****/
119 /*******************************************************************************/
121 static void ctxt_error(char **errors, const char *format, ...)
129 va_start(ap, format);
130 len = vsnprintf(buffer, sizeof buffer, format, ap);
132 if (len > (int)(sizeof buffer - 2))
133 len = (int)(sizeof buffer - 2);
134 buffer[len++] = '\n';
138 sz = errs ? strlen(errs) : 0;
139 errs = realloc(errs, sz + (size_t)len);
141 memcpy(errs + sz, buffer, len);
146 /* get the value of the flag of 'name' in the array 'flags' of 'count elements */
147 static int get_flag(const char *name, struct flag flags[], int count)
149 /* dichotomic search */
150 int lower = 0, upper = count;
151 while (lower < upper) {
152 int mid = (lower + upper) >> 1;
153 int cmp = strcmp(name, flags[mid].name);
155 return flags[mid].value;
165 static struct json_object *timestamp(const struct afb_hookid *hookid)
169 snprintf(ts, sizeof ts, "%llu.%06lu", (long long unsigned)hookid->time.tv_sec, (long unsigned)(hookid->time.tv_nsec / 1000));
170 return json_object_new_string(ts);
173 /* verbosity level name or NULL */
174 static const char *verbosity_level_name(int level)
176 static const char *names[] = {
184 return level >= Log_Level_Error && level <= Log_Level_Debug ? names[level - Log_Level_Error] : NULL;
188 static void emit(void *closure, const struct afb_hookid *hookid, const char *type, const char *fmt1, const char *fmt2, va_list ap2, ...)
190 struct hook *hook = closure;
191 struct json_object *data, *data1, *data2;
194 data1 = data2 = data = NULL;
196 wrap_json_vpack(&data1, fmt1, ap1);
199 wrap_json_vpack(&data2, fmt2, ap2);
201 wrap_json_pack(&data, "{so ss ss si so so*}",
202 "time", timestamp(hookid),
203 "tag", hook->tag->tag,
205 "id", (int)(hookid->id & INT_MAX),
209 afb_evt_unhooked_push(hook->event->event, data);
212 /*******************************************************************************/
213 /***** trace the requests *****/
214 /*******************************************************************************/
216 static struct flag xreq_flags[] = { /* must be sorted by names */
217 { "addref", afb_hook_flag_req_addref },
218 { "all", afb_hook_flags_req_all },
219 { "args", afb_hook_flags_req_args },
220 { "begin", afb_hook_flag_req_begin },
221 { "common", afb_hook_flags_req_common },
222 { "context", afb_hook_flags_req_context },
223 { "context_get", afb_hook_flag_req_context_get },
224 { "context_make", afb_hook_flag_req_context_make },
225 { "context_set", afb_hook_flag_req_context_set },
226 { "end", afb_hook_flag_req_end },
227 { "event", afb_hook_flags_req_event },
228 { "extra", afb_hook_flags_req_extra },
229 { "fail", afb_hook_flag_req_fail },
230 { "get", afb_hook_flag_req_get },
231 { "get_application_id", afb_hook_flag_req_get_application_id },
232 { "has_permission", afb_hook_flag_req_has_permission },
233 { "json", afb_hook_flag_req_json },
234 { "life", afb_hook_flags_req_life },
235 { "ref", afb_hook_flags_req_ref },
236 { "result", afb_hook_flags_req_result },
237 { "security", afb_hook_flags_req_security },
238 { "session", afb_hook_flags_req_session },
239 { "session_close", afb_hook_flag_req_session_close },
240 { "session_set_LOA", afb_hook_flag_req_session_set_LOA },
241 { "store", afb_hook_flag_req_store },
242 { "stores", afb_hook_flags_req_stores },
243 { "subcall", afb_hook_flag_req_subcall },
244 { "subcall_req", afb_hook_flag_req_subcall_req },
245 { "subcall_req_result", afb_hook_flag_req_subcall_req_result },
246 { "subcall_result", afb_hook_flag_req_subcall_result },
247 { "subcalls", afb_hook_flags_req_subcalls },
248 { "subcallsync", afb_hook_flag_req_subcallsync },
249 { "subcallsync_result", afb_hook_flag_req_subcallsync_result },
250 { "subscribe", afb_hook_flag_req_subscribe },
251 { "success", afb_hook_flag_req_success },
252 { "unref", afb_hook_flag_req_unref },
253 { "unstore", afb_hook_flag_req_unstore },
254 { "unsubscribe", afb_hook_flag_req_unsubscribe },
255 { "vverbose", afb_hook_flag_req_vverbose },
258 /* get the xreq value for flag of 'name' */
259 static int get_xreq_flag(const char *name)
261 return get_flag(name, xreq_flags, (int)(sizeof xreq_flags / sizeof *xreq_flags));
264 static void hook_xreq(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, const char *action, const char *format, ...)
266 struct json_object *cred = NULL;
267 const char *session = NULL;
270 if (xreq->context.session)
271 session = afb_session_uuid(xreq->context.session);
274 wrap_json_pack(&cred, "{si ss si si ss* ss*}",
275 "uid", (int)xreq->cred->uid,
276 "user", xreq->cred->user,
277 "gid", (int)xreq->cred->gid,
278 "pid", (int)xreq->cred->pid,
279 "label", xreq->cred->label,
282 va_start(ap, format);
283 emit(closure, hookid, "request", "{si ss ss ss so* ss*}", format, ap,
284 "index", xreq->hookindex,
293 static void hook_xreq_begin(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq)
295 hook_xreq(closure, hookid, xreq, "begin", NULL);
298 static void hook_xreq_end(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq)
300 hook_xreq(closure, hookid, xreq, "end", NULL);
303 static void hook_xreq_json(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct json_object *obj)
305 hook_xreq(closure, hookid, xreq, "json", "{sO?}",
309 static void hook_xreq_get(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, const char *name, struct afb_arg arg)
311 hook_xreq(closure, hookid, xreq, "get", "{ss? ss? ss? ss?}",
318 static void hook_xreq_success(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct json_object *obj, const char *info)
320 hook_xreq(closure, hookid, xreq, "success", "{sO? ss?}",
325 static void hook_xreq_fail(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, const char *status, const char *info)
327 hook_xreq(closure, hookid, xreq, "fail", "{ss? ss?}",
332 static void hook_xreq_context_get(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, void *value)
334 hook_xreq(closure, hookid, xreq, "context_get", NULL);
337 static void hook_xreq_context_set(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, void *value, void (*free_value)(void*))
339 hook_xreq(closure, hookid, xreq, "context_set", NULL);
342 static void hook_xreq_addref(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq)
344 hook_xreq(closure, hookid, xreq, "addref", NULL);
347 static void hook_xreq_unref(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq)
349 hook_xreq(closure, hookid, xreq, "unref", NULL);
352 static void hook_xreq_session_close(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq)
354 hook_xreq(closure, hookid, xreq, "session_close", NULL);
357 static void hook_xreq_session_set_LOA(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, unsigned level, int result)
359 hook_xreq(closure, hookid, xreq, "session_set_LOA", "{si si}",
364 static void hook_xreq_subscribe(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct afb_event event, int result)
366 hook_xreq(closure, hookid, xreq, "subscribe", "{s{ss si} si}",
368 "name", afb_evt_event_name(event),
369 "id", afb_evt_event_id(event),
373 static void hook_xreq_unsubscribe(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct afb_event event, int result)
375 hook_xreq(closure, hookid, xreq, "unsubscribe", "{s{ss? si} si}",
377 "name", afb_evt_event_name(event),
378 "id", afb_evt_event_id(event),
382 static void hook_xreq_subcall(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, const char *api, const char *verb, struct json_object *args)
384 hook_xreq(closure, hookid, xreq, "subcall", "{ss? ss? sO?}",
390 static void hook_xreq_subcall_result(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, int status, struct json_object *result)
392 hook_xreq(closure, hookid, xreq, "subcall_result", "{si sO?}",
397 static void hook_xreq_subcallsync(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, const char *api, const char *verb, struct json_object *args)
399 hook_xreq(closure, hookid, xreq, "subcallsync", "{ss? ss? sO?}",
405 static void hook_xreq_subcallsync_result(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, int status, struct json_object *result)
407 hook_xreq(closure, hookid, xreq, "subcallsync_result", "{si sO?}",
412 static void hook_xreq_vverbose(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, int level, const char *file, int line, const char *func, const char *fmt, va_list args)
414 struct json_object *pos;
423 len = vasprintf(&msg, fmt, ap);
427 wrap_json_pack(&pos, "{ss si ss*}", "file", file, "line", line, "function", func);
429 hook_xreq(closure, hookid, xreq, "vverbose", "{si ss* ss? so*}",
431 "type", verbosity_level_name(level),
432 len < 0 ? "format" : "message", len < 0 ? fmt : msg,
438 static void hook_xreq_store(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct afb_stored_req *sreq)
440 hook_xreq(closure, hookid, xreq, "store", NULL);
443 static void hook_xreq_unstore(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq)
445 hook_xreq(closure, hookid, xreq, "unstore", NULL);
448 static void hook_xreq_subcall_req(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, const char *api, const char *verb, struct json_object *args)
450 hook_xreq(closure, hookid, xreq, "subcall_req", "{ss? ss? sO?}",
456 static void hook_xreq_subcall_req_result(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, int status, struct json_object *result)
458 hook_xreq(closure, hookid, xreq, "subcall_req_result", "{si sO?}",
463 static void hook_xreq_has_permission(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, const char *permission, int result)
465 hook_xreq(closure, hookid, xreq, "has_permission", "{ss sb}",
466 "permission", permission,
470 static void hook_xreq_get_application_id(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, char *result)
472 hook_xreq(closure, hookid, xreq, "get_application_id", "{ss?}",
476 static void hook_xreq_context_make(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, int replace, void *(*create_value)(void*), void (*free_value)(void*), void *create_closure, void *result)
478 char pc[50], pf[50], pv[50], pr[50];
479 snprintf(pc, sizeof pc, "%p", create_value);
480 snprintf(pf, sizeof pf, "%p", free_value);
481 snprintf(pv, sizeof pv, "%p", create_closure);
482 snprintf(pr, sizeof pr, "%p", result);
483 hook_xreq(closure, hookid, xreq, "context_make", "{sb ss ss ss ss}",
491 static struct afb_hook_xreq_itf hook_xreq_itf = {
492 .hook_xreq_begin = hook_xreq_begin,
493 .hook_xreq_end = hook_xreq_end,
494 .hook_xreq_json = hook_xreq_json,
495 .hook_xreq_get = hook_xreq_get,
496 .hook_xreq_success = hook_xreq_success,
497 .hook_xreq_fail = hook_xreq_fail,
498 .hook_xreq_context_get = hook_xreq_context_get,
499 .hook_xreq_context_set = hook_xreq_context_set,
500 .hook_xreq_addref = hook_xreq_addref,
501 .hook_xreq_unref = hook_xreq_unref,
502 .hook_xreq_session_close = hook_xreq_session_close,
503 .hook_xreq_session_set_LOA = hook_xreq_session_set_LOA,
504 .hook_xreq_subscribe = hook_xreq_subscribe,
505 .hook_xreq_unsubscribe = hook_xreq_unsubscribe,
506 .hook_xreq_subcall = hook_xreq_subcall,
507 .hook_xreq_subcall_result = hook_xreq_subcall_result,
508 .hook_xreq_subcallsync = hook_xreq_subcallsync,
509 .hook_xreq_subcallsync_result = hook_xreq_subcallsync_result,
510 .hook_xreq_vverbose = hook_xreq_vverbose,
511 .hook_xreq_store = hook_xreq_store,
512 .hook_xreq_unstore = hook_xreq_unstore,
513 .hook_xreq_subcall_req = hook_xreq_subcall_req,
514 .hook_xreq_subcall_req_result = hook_xreq_subcall_req_result,
515 .hook_xreq_has_permission = hook_xreq_has_permission,
516 .hook_xreq_get_application_id = hook_xreq_get_application_id,
517 .hook_xreq_context_make = hook_xreq_context_make
520 /*******************************************************************************/
521 /***** trace the daemon interface *****/
522 /*******************************************************************************/
524 static struct flag ditf_flags[] = { /* must be sorted by names */
525 { "all", afb_hook_flags_ditf_all },
526 { "common", afb_hook_flags_ditf_common },
527 { "event_broadcast_after", afb_hook_flag_ditf_event_broadcast_after },
528 { "event_broadcast_before", afb_hook_flag_ditf_event_broadcast_before },
529 { "event_make", afb_hook_flag_ditf_event_make },
530 { "extra", afb_hook_flags_ditf_extra },
531 { "get_event_loop", afb_hook_flag_ditf_get_event_loop },
532 { "get_system_bus", afb_hook_flag_ditf_get_system_bus },
533 { "get_user_bus", afb_hook_flag_ditf_get_user_bus },
534 { "queue_job", afb_hook_flag_ditf_queue_job },
535 { "require_api", afb_hook_flag_ditf_require_api },
536 { "require_api_result", afb_hook_flag_ditf_require_api_result },
537 { "rootdir_get_fd", afb_hook_flag_ditf_rootdir_get_fd },
538 { "rootdir_open_locale", afb_hook_flag_ditf_rootdir_open_locale },
539 { "unstore_req", afb_hook_flag_ditf_unstore_req },
540 { "vverbose", afb_hook_flag_ditf_vverbose },
543 /* get the export value for flag of 'name' */
544 static int get_ditf_flag(const char *name)
546 return get_flag(name, ditf_flags, (int)(sizeof ditf_flags / sizeof *ditf_flags));
550 static void hook_ditf(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *action, const char *format, ...)
554 va_start(ap, format);
555 emit(closure, hookid, "daemon", "{ss ss}", format, ap,
556 "api", afb_export_apiname(export),
561 static void hook_ditf_event_broadcast_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, struct json_object *object)
563 hook_ditf(closure, hookid, export, "event_broadcast_before", "{ss sO*}",
564 "name", name, "data", object);
567 static void hook_ditf_event_broadcast_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, struct json_object *object, int result)
569 hook_ditf(closure, hookid, export, "event_broadcast_after", "{ss sO* si}",
570 "name", name, "data", object, "result", result);
573 static void hook_ditf_get_event_loop(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct sd_event *result)
575 hook_ditf(closure, hookid, export, "get_event_loop", NULL);
578 static void hook_ditf_get_user_bus(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct sd_bus *result)
580 hook_ditf(closure, hookid, export, "get_user_bus", NULL);
583 static void hook_ditf_get_system_bus(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct sd_bus *result)
585 hook_ditf(closure, hookid, export, "get_system_bus", NULL);
588 static void hook_ditf_vverbose(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int level, const char *file, int line, const char *function, const char *fmt, va_list args)
590 struct json_object *pos;
599 len = vasprintf(&msg, fmt, ap);
603 wrap_json_pack(&pos, "{ss si ss*}", "file", file, "line", line, "function", function);
605 hook_ditf(closure, hookid, export, "vverbose", "{si ss* ss? so*}",
607 "type", verbosity_level_name(level),
608 len < 0 ? "format" : "message", len < 0 ? fmt : msg,
614 static void hook_ditf_event_make(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, struct afb_event result)
616 hook_ditf(closure, hookid, export, "event_make", "{ss ss si}",
617 "name", name, "event", afb_evt_event_name(result), "id", afb_evt_event_id(result));
620 static void hook_ditf_rootdir_get_fd(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result)
625 sprintf(path, "/proc/self/fd/%d", result);
626 readlink(path, path, sizeof path);
629 hook_ditf(closure, hookid, export, "rootdir_get_fd", "{ss}",
630 result < 0 ? "path" : "error",
631 result < 0 ? strerror(errno) : path);
634 static void hook_ditf_rootdir_open_locale(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *filename, int flags, const char *locale, int result)
639 sprintf(path, "/proc/self/fd/%d", result);
640 readlink(path, path, sizeof path);
643 hook_ditf(closure, hookid, export, "rootdir_open_locale", "{ss si ss* ss}",
647 result < 0 ? "path" : "error",
648 result < 0 ? strerror(errno) : path);
651 static void hook_ditf_queue_job(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, void (*callback)(int signum, void *arg), void *argument, void *group, int timeout, int result)
653 hook_ditf(closure, hookid, export, "queue_job", "{ss}", "result", result);
656 static void hook_ditf_unstore_req(void * closure, const struct afb_hookid *hookid, const struct afb_export *export, struct afb_stored_req *sreq)
658 hook_ditf(closure, hookid, export, "unstore_req", NULL);
661 static void hook_ditf_require_api(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, int initialized)
663 hook_ditf(closure, hookid, export, "require_api", "{ss sb}", "name", name, "initialized", initialized);
666 static void hook_ditf_require_api_result(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, int initialized, int result)
668 hook_ditf(closure, hookid, export, "require_api_result", "{ss sb si}", "name", name, "initialized", initialized, "result", result);
671 static struct afb_hook_ditf_itf hook_ditf_itf = {
672 .hook_ditf_event_broadcast_before = hook_ditf_event_broadcast_before,
673 .hook_ditf_event_broadcast_after = hook_ditf_event_broadcast_after,
674 .hook_ditf_get_event_loop = hook_ditf_get_event_loop,
675 .hook_ditf_get_user_bus = hook_ditf_get_user_bus,
676 .hook_ditf_get_system_bus = hook_ditf_get_system_bus,
677 .hook_ditf_vverbose = hook_ditf_vverbose,
678 .hook_ditf_event_make = hook_ditf_event_make,
679 .hook_ditf_rootdir_get_fd = hook_ditf_rootdir_get_fd,
680 .hook_ditf_rootdir_open_locale = hook_ditf_rootdir_open_locale,
681 .hook_ditf_queue_job = hook_ditf_queue_job,
682 .hook_ditf_unstore_req = hook_ditf_unstore_req,
683 .hook_ditf_require_api = hook_ditf_require_api,
684 .hook_ditf_require_api_result = hook_ditf_require_api_result
687 /*******************************************************************************/
688 /***** trace the services *****/
689 /*******************************************************************************/
691 static struct flag svc_flags[] = { /* must be sorted by names */
692 { "all", afb_hook_flags_svc_all },
693 { "call", afb_hook_flag_svc_call },
694 { "call_result", afb_hook_flag_svc_call_result },
695 { "callsync", afb_hook_flag_svc_callsync },
696 { "callsync_result", afb_hook_flag_svc_callsync_result },
697 { "on_event_after", afb_hook_flag_svc_on_event_after },
698 { "on_event_before", afb_hook_flag_svc_on_event_before },
699 { "start_after", afb_hook_flag_svc_start_after },
700 { "start_before", afb_hook_flag_svc_start_before },
703 /* get the export value for flag of 'name' */
704 static int get_svc_flag(const char *name)
706 return get_flag(name, svc_flags, (int)(sizeof svc_flags / sizeof *svc_flags));
709 static void hook_svc(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *action, const char *format, ...)
713 va_start(ap, format);
714 emit(closure, hookid, "service", "{ss ss}", format, ap,
715 "api", afb_export_apiname(export),
720 static void hook_svc_start_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export)
722 hook_svc(closure, hookid, export, "start_before", NULL);
725 static void hook_svc_start_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int status)
727 hook_svc(closure, hookid, export, "start_after", "{si}", "result", status);
730 static void hook_svc_on_event_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *event, int eventid, struct json_object *object)
732 hook_svc(closure, hookid, export, "on_event_before", "{ss si sO*}",
733 "event", event, "id", eventid, "data", object);
736 static void hook_svc_on_event_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *event, int eventid, struct json_object *object)
738 hook_svc(closure, hookid, export, "on_event_after", "{ss si sO*}",
739 "event", event, "id", eventid, "data", object);
742 static void hook_svc_call(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *api, const char *verb, struct json_object *args)
744 hook_svc(closure, hookid, export, "call", "{ss ss sO*}",
745 "api", api, "verb", verb, "args", args);
748 static void hook_svc_call_result(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int status, struct json_object *result)
750 hook_svc(closure, hookid, export, "call_result", "{si sO*}",
751 "status", status, "result", result);
754 static void hook_svc_callsync(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *api, const char *verb, struct json_object *args)
756 hook_svc(closure, hookid, export, "callsync", "{ss ss sO*}",
757 "api", api, "verb", verb, "args", args);
760 static void hook_svc_callsync_result(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int status, struct json_object *result)
762 hook_svc(closure, hookid, export, "callsync_result", "{si sO*}",
763 "status", status, "result", result);
766 static struct afb_hook_svc_itf hook_svc_itf = {
767 .hook_svc_start_before = hook_svc_start_before,
768 .hook_svc_start_after = hook_svc_start_after,
769 .hook_svc_on_event_before = hook_svc_on_event_before,
770 .hook_svc_on_event_after = hook_svc_on_event_after,
771 .hook_svc_call = hook_svc_call,
772 .hook_svc_call_result = hook_svc_call_result,
773 .hook_svc_callsync = hook_svc_callsync,
774 .hook_svc_callsync_result = hook_svc_callsync_result
777 /*******************************************************************************/
778 /***** trace the events *****/
779 /*******************************************************************************/
781 static struct flag evt_flags[] = { /* must be sorted by names */
782 { "all", afb_hook_flags_evt_all },
783 { "broadcast_after", afb_hook_flag_evt_broadcast_after },
784 { "broadcast_before", afb_hook_flag_evt_broadcast_before },
785 { "common", afb_hook_flags_evt_common },
786 { "create", afb_hook_flag_evt_create },
787 { "drop", afb_hook_flag_evt_drop },
788 { "extra", afb_hook_flags_evt_extra },
789 { "name", afb_hook_flag_evt_name },
790 { "push_after", afb_hook_flag_evt_push_after },
791 { "push_before", afb_hook_flag_evt_push_before },
794 /* get the evt value for flag of 'name' */
795 static int get_evt_flag(const char *name)
797 return get_flag(name, evt_flags, (int)(sizeof evt_flags / sizeof *evt_flags));
800 static void hook_evt(void *closure, const struct afb_hookid *hookid, const char *evt, int id, const char *action, const char *format, ...)
804 va_start(ap, format);
805 emit(closure, hookid, "event", "{si ss ss}", format, ap,
812 static void hook_evt_create(void *closure, const struct afb_hookid *hookid, const char *evt, int id)
814 hook_evt(closure, hookid, evt, id, "create", NULL);
817 static void hook_evt_push_before(void *closure, const struct afb_hookid *hookid, const char *evt, int id, struct json_object *obj)
819 hook_evt(closure, hookid, evt, id, "push_before", "{sO*}", "data", obj);
823 static void hook_evt_push_after(void *closure, const struct afb_hookid *hookid, const char *evt, int id, struct json_object *obj, int result)
825 hook_evt(closure, hookid, evt, id, "push_after", "{sO* si}", "data", obj, "result", result);
828 static void hook_evt_broadcast_before(void *closure, const struct afb_hookid *hookid, const char *evt, int id, struct json_object *obj)
830 hook_evt(closure, hookid, evt, id, "broadcast_before", "{sO*}", "data", obj);
833 static void hook_evt_broadcast_after(void *closure, const struct afb_hookid *hookid, const char *evt, int id, struct json_object *obj, int result)
835 hook_evt(closure, hookid, evt, id, "broadcast_after", "{sO* si}", "data", obj, "result", result);
838 static void hook_evt_name(void *closure, const struct afb_hookid *hookid, const char *evt, int id)
840 hook_evt(closure, hookid, evt, id, "name", NULL);
843 static void hook_evt_drop(void *closure, const struct afb_hookid *hookid, const char *evt, int id)
845 hook_evt(closure, hookid, evt, id, "drop", NULL);
848 static struct afb_hook_evt_itf hook_evt_itf = {
849 .hook_evt_create = hook_evt_create,
850 .hook_evt_push_before = hook_evt_push_before,
851 .hook_evt_push_after = hook_evt_push_after,
852 .hook_evt_broadcast_before = hook_evt_broadcast_before,
853 .hook_evt_broadcast_after = hook_evt_broadcast_after,
854 .hook_evt_name = hook_evt_name,
855 .hook_evt_drop = hook_evt_drop
858 /*******************************************************************************/
859 /***** trace the globals *****/
860 /*******************************************************************************/
862 static struct flag global_flags[] = { /* must be sorted by names */
863 { "all", afb_hook_flags_global_all },
864 { "vverbose", afb_hook_flag_global_vverbose },
867 /* get the global value for flag of 'name' */
868 static int get_global_flag(const char *name)
870 return get_flag(name, global_flags, (int)(sizeof global_flags / sizeof *global_flags));
873 static void hook_global(void *closure, const struct afb_hookid *hookid, const char *action, const char *format, ...)
877 va_start(ap, format);
878 emit(closure, hookid, "global", "{ss}", format, ap, "action", action);
882 static void hook_global_vverbose(void *closure, const struct afb_hookid *hookid, int level, const char *file, int line, const char *function, const char *fmt, va_list args)
884 struct json_object *pos;
893 len = vasprintf(&msg, fmt, ap);
897 wrap_json_pack(&pos, "{ss si ss*}", "file", file, "line", line, "function", function);
899 hook_global(closure, hookid, "vverbose", "{si ss* ss? so*}",
901 "type", verbosity_level_name(level),
902 len < 0 ? "format" : "message", len < 0 ? fmt : msg,
908 static struct afb_hook_global_itf hook_global_itf = {
909 .hook_global_vverbose = hook_global_vverbose,
912 /*******************************************************************************/
913 /***** abstract types *****/
914 /*******************************************************************************/
920 void (*unref)(void*);
921 int (*get_flag)(const char*);
923 abstracting[Trace_Type_Count] =
928 .unref = (void(*)(void*))afb_hook_unref_xreq,
929 .get_flag = get_xreq_flag
934 .unref = (void(*)(void*))afb_hook_unref_ditf,
935 .get_flag = get_ditf_flag
940 .unref = (void(*)(void*))afb_hook_unref_svc,
941 .get_flag = get_svc_flag
946 .unref = (void(*)(void*))afb_hook_unref_evt,
947 .get_flag = get_evt_flag
949 [Trace_Type_Global] =
952 .unref = (void(*)(void*))afb_hook_unref_global,
953 .get_flag = get_global_flag
957 /*******************************************************************************/
958 /***** handle trace data *****/
959 /*******************************************************************************/
961 /* drop hooks of 'trace' matching 'tag' and 'event' and 'session' */
962 static void trace_unhook(struct afb_trace *trace, struct tag *tag, struct event *event, struct session *session)
965 struct hook *hook, **prev;
967 /* remove any event */
968 for (i = 0 ; i < Trace_Type_Count ; i++) {
969 prev = &trace->hooks[i];
970 while ((hook = *prev)) {
971 if ((tag && tag != hook->tag)
972 || (event && event != hook->event)
973 || (session && session != hook->session))
977 abstracting[i].unref(hook->handler);
984 /* cleanup: removes unused tags, events and sessions of the 'trace' */
985 static void trace_cleanup(struct afb_trace *trace)
989 struct tag *tag, **ptag;
990 struct event *event, **pevent;
991 struct session *session, **psession;
994 psession = &trace->sessions;
995 while ((session = *psession)) {
996 /* search for session */
997 for (hook = NULL, i = 0 ; !hook && i < Trace_Type_Count ; i++)
998 for (hook = trace->hooks[i] ; hook && hook->session != session ; hook = hook->next);
999 /* keep or free whether used or not */
1001 psession = &session->next;
1003 *psession = session->next;
1004 if (__atomic_exchange_n(&session->trace, NULL, __ATOMIC_RELAXED))
1005 afb_session_set_cookie(session->session, session, NULL, NULL);
1010 ptag = &trace->tags;
1011 while ((tag = *ptag)) {
1012 /* search for tag */
1013 for (hook = NULL, i = 0 ; !hook && i < Trace_Type_Count ; i++)
1014 for (hook = trace->hooks[i] ; hook && hook->tag != tag ; hook = hook->next);
1015 /* keep or free whether used or not */
1024 pevent = &trace->events;
1025 while ((event = *pevent)) {
1026 /* search for event */
1027 for (hook = NULL, i = 0 ; !hook && i < Trace_Type_Count ; i++)
1028 for (hook = trace->hooks[i] ; hook && hook->event != event ; hook = hook->next);
1029 /* keep or free whether used or not */
1031 pevent = &event->next;
1033 *pevent = event->next;
1034 afb_event_drop(event->event);
1040 /* callback at end of traced session */
1041 static void free_session_cookie(void *cookie)
1043 struct session *session = cookie;
1044 struct afb_trace *trace = __atomic_exchange_n(&session->trace, NULL, __ATOMIC_RELAXED);
1046 pthread_mutex_lock(&trace->mutex);
1047 trace_unhook(trace, NULL, NULL, session);
1048 trace_cleanup(trace);
1049 pthread_mutex_unlock(&trace->mutex);
1054 * Get the tag of 'name' within 'trace'.
1055 * If 'alloc' isn't zero, create the tag and add it.
1057 static struct tag *trace_get_tag(struct afb_trace *trace, const char *name, int alloc)
1061 /* search the tag of 'name' */
1063 while (tag && strcmp(name, tag->tag))
1066 if (!tag && alloc) {
1067 /* creation if needed */
1068 tag = malloc(sizeof * tag + strlen(name));
1070 strcpy(tag->tag, name);
1071 tag->next = trace->tags;
1079 * Get the event of 'name' within 'trace'.
1080 * If 'alloc' isn't zero, create the event and add it.
1082 static struct event *trace_get_event(struct afb_trace *trace, const char *name, int alloc)
1084 struct event *event;
1086 /* search the event */
1087 event = trace->events;
1088 while (event && strcmp(afb_event_name(event->event), name))
1089 event = event->next;
1091 if (!event && alloc) {
1092 event = malloc(sizeof * event);
1094 event->event = trace->daemon->itf->event_make(trace->daemon->closure, name);
1095 if (afb_event_is_valid(event->event)) {
1096 event->next = trace->events;
1097 trace->events = event;
1108 * Get the session of 'value' within 'trace'.
1109 * If 'alloc' isn't zero, create the session and add it.
1111 static struct session *trace_get_session(struct afb_trace *trace, struct afb_session *value, int alloc)
1113 struct session *session;
1115 /* search the session */
1116 session = trace->sessions;
1117 while (session && session->session != value)
1118 session = session->next;
1120 if (!session && alloc) {
1121 session = malloc(sizeof * session);
1123 session->session = value;
1124 session->trace = NULL;
1125 session->next = trace->sessions;
1126 trace->sessions = session;
1133 * Get the session of 'uuid' within 'trace'.
1134 * If 'alloc' isn't zero, create the session and add it.
1136 static struct session *trace_get_session_by_uuid(struct afb_trace *trace, const char *uuid, int alloc)
1138 struct afb_session *session;
1141 session = afb_session_get(uuid, alloc ? &created : NULL);
1142 return session ? trace_get_session(trace, session, alloc) : NULL;
1145 static struct hook *trace_make_detached_hook(struct afb_trace *trace, const char *event, const char *tag)
1149 tag = tag ?: DEFAULT_TAG_NAME;
1150 event = event ?: DEFAULT_EVENT_NAME;
1151 hook = malloc(sizeof *hook);
1153 hook->tag = trace_get_tag(trace, tag, 1);
1154 hook->event = trace_get_event(trace, event, 1);
1155 hook->session = NULL;
1156 hook->handler = NULL;
1161 static void trace_attach_hook(struct afb_trace *trace, struct hook *hook, enum trace_type type)
1163 struct session *session = hook->session;
1164 hook->next = trace->hooks[type];
1165 trace->hooks[type] = hook;
1166 if (session && !session->trace) {
1167 session->trace = trace;
1168 afb_session_set_cookie(session->session, session, session, free_session_cookie);
1172 /*******************************************************************************/
1173 /***** handle client requests *****/
1174 /*******************************************************************************/
1178 struct afb_trace *trace;
1185 struct context *context;
1188 const char *session;
1191 const char *pattern;
1192 int flags[Trace_Type_Count];
1196 static void addhook(struct desc *desc, enum trace_type type)
1199 struct session *session;
1200 struct afb_session *bind;
1201 struct afb_trace *trace = desc->context->trace;
1203 /* check permission for bound traces */
1204 bind = trace->bound;
1206 if (type != Trace_Type_Xreq) {
1207 ctxt_error(&desc->context->errors, "tracing %s is forbidden", abstracting[type].name);
1210 if (desc->session) {
1211 ctxt_error(&desc->context->errors, "setting session is forbidden");
1216 /* allocate the hook */
1217 hook = trace_make_detached_hook(trace, desc->name, desc->tag);
1219 ctxt_error(&desc->context->errors, "allocation of hook failed");
1223 /* create the hook handler */
1225 case Trace_Type_Xreq:
1226 if (desc->session) {
1227 session = trace_get_session_by_uuid(trace, desc->session, 1);
1229 ctxt_error(&desc->context->errors, "allocation of session failed");
1233 bind = session->session;
1235 hook->handler = afb_hook_create_xreq(desc->api, desc->verb, bind,
1236 desc->flags[type], &hook_xreq_itf, hook);
1238 case Trace_Type_Ditf:
1239 hook->handler = afb_hook_create_ditf(desc->api, desc->flags[type], &hook_ditf_itf, hook);
1241 case Trace_Type_Svc:
1242 hook->handler = afb_hook_create_svc(desc->api, desc->flags[type], &hook_svc_itf, hook);
1244 case Trace_Type_Evt:
1245 hook->handler = afb_hook_create_evt(desc->pattern, desc->flags[type], &hook_evt_itf, hook);
1247 case Trace_Type_Global:
1248 hook->handler = afb_hook_create_global(desc->flags[type], &hook_global_itf, hook);
1253 if (!hook->handler) {
1254 ctxt_error(&desc->context->errors, "creation of hook failed");
1259 /* attach and activate the hook */
1260 afb_req_subscribe(desc->context->req, hook->event->event);
1261 trace_attach_hook(trace, hook, type);
1264 static void addhooks(struct desc *desc)
1268 for (i = 0 ; i < Trace_Type_Count ; i++) {
1274 static void add_flags(void *closure, struct json_object *object, enum trace_type type)
1277 const char *name, *queried;
1278 struct desc *desc = closure;
1280 if (wrap_json_unpack(object, "s", &name))
1281 ctxt_error(&desc->context->errors, "unexpected %s value %s",
1282 abstracting[type].name,
1283 json_object_to_json_string(object));
1285 queried = (name[0] == '*' && !name[1]) ? "all" : name;
1286 value = abstracting[type].get_flag(queried);
1288 desc->flags[type] |= value;
1290 ctxt_error(&desc->context->errors, "unknown %s name %s",
1291 abstracting[type].name, name);
1295 static void add_xreq_flags(void *closure, struct json_object *object)
1297 add_flags(closure, object, Trace_Type_Xreq);
1300 static void add_ditf_flags(void *closure, struct json_object *object)
1302 add_flags(closure, object, Trace_Type_Ditf);
1305 static void add_svc_flags(void *closure, struct json_object *object)
1307 add_flags(closure, object, Trace_Type_Svc);
1310 static void add_evt_flags(void *closure, struct json_object *object)
1312 add_flags(closure, object, Trace_Type_Evt);
1315 static void add_global_flags(void *closure, struct json_object *object)
1317 add_flags(closure, object, Trace_Type_Global);
1321 static void add(void *closure, struct json_object *object)
1325 struct json_object *request, *event, *daemon, *service, *sub, *global;
1327 memcpy (&desc, closure, sizeof desc);
1328 request = event = daemon = service = sub = global = NULL;
1330 rc = wrap_json_unpack(object, "{s?s s?s s?s s?s s?s s?s s?o s?o s?o s?o s?o s?o}",
1335 "session", &desc.session,
1336 "pattern", &desc.pattern,
1337 "request", &request,
1339 "service", &service,
1346 if (desc.api && desc.api[0] == '*' && !desc.api[1])
1349 if (desc.verb && desc.verb[0] == '*' && !desc.verb[1])
1352 if (desc.session && desc.session[0] == '*' && !desc.session[1])
1353 desc.session = NULL;
1355 /* get what is expected */
1357 wrap_json_optarray_for_all(request, add_xreq_flags, &desc);
1360 wrap_json_optarray_for_all(daemon, add_ditf_flags, &desc);
1363 wrap_json_optarray_for_all(service, add_svc_flags, &desc);
1366 wrap_json_optarray_for_all(event, add_evt_flags, &desc);
1369 wrap_json_optarray_for_all(global, add_global_flags, &desc);
1373 wrap_json_optarray_for_all(sub, add, &desc);
1378 wrap_json_optarray_for_all(object, add_xreq_flags, &desc);
1383 /* drop hooks of given tag */
1384 static void drop_tag(void *closure, struct json_object *object)
1387 struct context *context = closure;
1391 rc = wrap_json_unpack(object, "s", &name);
1393 ctxt_error(&context->errors, "unexpected tag value %s", json_object_to_json_string(object));
1395 tag = trace_get_tag(context->trace, name, 0);
1397 ctxt_error(&context->errors, "tag %s not found", name);
1399 trace_unhook(context->trace, tag, NULL, NULL);
1403 /* drop hooks of given event */
1404 static void drop_event(void *closure, struct json_object *object)
1407 struct context *context = closure;
1408 struct event *event;
1411 rc = wrap_json_unpack(object, "s", &name);
1413 ctxt_error(&context->errors, "unexpected event value %s", json_object_to_json_string(object));
1415 event = trace_get_event(context->trace, name, 0);
1417 ctxt_error(&context->errors, "event %s not found", name);
1419 trace_unhook(context->trace, NULL, event, NULL);
1423 /* drop hooks of given session */
1424 static void drop_session(void *closure, struct json_object *object)
1427 struct context *context = closure;
1428 struct session *session;
1431 rc = wrap_json_unpack(object, "s", &uuid);
1433 ctxt_error(&context->errors, "unexpected session value %s", json_object_to_json_string(object));
1435 session = trace_get_session_by_uuid(context->trace, uuid, 0);
1437 ctxt_error(&context->errors, "session %s not found", uuid);
1439 trace_unhook(context->trace, NULL, NULL, session);
1443 /*******************************************************************************/
1444 /***** public interface *****/
1445 /*******************************************************************************/
1447 /* allocates an afb_trace instance */
1448 struct afb_trace *afb_trace_create(struct afb_daemon *daemon, struct afb_session *bound)
1450 struct afb_trace *trace;
1454 trace = calloc(1, sizeof *trace);
1456 trace->refcount = 1;
1457 trace->bound = bound;
1458 trace->daemon = daemon;
1459 pthread_mutex_init(&trace->mutex, NULL);
1464 /* add a reference to the trace */
1465 void afb_trace_addref(struct afb_trace *trace)
1467 __atomic_add_fetch(&trace->refcount, 1, __ATOMIC_RELAXED);
1470 /* drop one reference to the trace */
1471 void afb_trace_unref(struct afb_trace *trace)
1473 if (trace && !__atomic_sub_fetch(&trace->refcount, 1, __ATOMIC_RELAXED)) {
1475 trace_unhook(trace, NULL, NULL, NULL);
1476 trace_cleanup(trace);
1477 pthread_mutex_destroy(&trace->mutex);
1483 int afb_trace_add(struct afb_req req, struct json_object *args, struct afb_trace *trace)
1485 struct context context;
1488 memset(&context, 0, sizeof context);
1489 context.trace = trace;
1492 memset(&desc, 0, sizeof desc);
1493 desc.context = &context;
1495 pthread_mutex_lock(&trace->mutex);
1496 wrap_json_optarray_for_all(args, add, &desc);
1497 pthread_mutex_unlock(&trace->mutex);
1499 if (!context.errors)
1502 afb_req_fail(req, "error-detected", context.errors);
1503 free(context.errors);
1508 extern int afb_trace_drop(struct afb_req req, struct json_object *args, struct afb_trace *trace)
1511 struct context context;
1512 struct json_object *tags, *events, *sessions;
1514 memset(&context, 0, sizeof context);
1515 context.trace = trace;
1518 /* special: boolean value */
1519 if (!wrap_json_unpack(args, "b", &rc)) {
1521 pthread_mutex_lock(&trace->mutex);
1522 trace_unhook(trace, NULL, NULL, NULL);
1523 trace_cleanup(trace);
1524 pthread_mutex_unlock(&trace->mutex);
1529 tags = events = sessions = NULL;
1530 rc = wrap_json_unpack(args, "{s?o s?o s?o}",
1533 "session", &sessions);
1535 if (rc < 0 || !(events || tags || sessions)) {
1536 afb_req_fail(req, "error-detected", "bad drop arguments");
1540 pthread_mutex_lock(&trace->mutex);
1543 wrap_json_optarray_for_all(tags, drop_tag, &context);
1546 wrap_json_optarray_for_all(events, drop_event, &context);
1549 wrap_json_optarray_for_all(sessions, drop_session, &context);
1551 trace_cleanup(trace);
1553 pthread_mutex_unlock(&trace->mutex);
1555 if (!context.errors)
1558 afb_req_fail(req, "error-detected", context.errors);
1559 free(context.errors);