/*
- * Copyright (C) 2016, 2017 "IoT.bzh"
+ * Copyright (C) 2015-2020 "IoT.bzh"
* Author José Bollo <jose.bollo@iot.bzh>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* limitations under the License.
*/
+#if WITH_AFB_HOOK && WITH_AFB_TRACE
+
#define _GNU_SOURCE
#include <assert.h>
#include <pthread.h>
#include <json-c/json.h>
-#include <afb/afb-binding-v2.h>
+#if !defined(JSON_C_TO_STRING_NOSLASHESCAPE)
+#define JSON_C_TO_STRING_NOSLASHESCAPE 0
+#endif
+
+#define AFB_BINDING_VERSION 3
+#include <afb/afb-binding.h>
#include "afb-hook.h"
+#include "afb-hook-flags.h"
#include "afb-cred.h"
#include "afb-session.h"
#include "afb-xreq.h"
#include "afb-export.h"
#include "afb-evt.h"
+#include "afb-session.h"
#include "afb-trace.h"
#include "wrap-json.h"
/***** types *****/
/*******************************************************************************/
-/* structure for searching flags by names */
-struct flag
-{
- const char *name; /** the name */
- int value; /** the value */
-};
-
/* struct for tags */
struct tag {
struct tag *next; /* link to the next */
- char tag[1]; /* name of the tag */
+ char tag[]; /* name of the tag */
};
/* struct for events */
struct event {
struct event *next; /* link to the next event */
- struct afb_event event; /* the event */
+ struct afb_evtid *evtid; /* the event */
};
/* struct for sessions */
-struct session {
- struct session *next; /* link to the next session */
- struct afb_session *session; /* the session */
- struct afb_trace *trace; /* the tracer */
+struct cookie {
+ struct afb_session *session; /* the session */
+ struct afb_trace *trace; /* the tracer */
};
/* struct for recording hooks */
void *handler; /* the handler of the hook */
struct event *event; /* the associated event */
struct tag *tag; /* the associated tag */
- struct session *session; /* the associated session */
+ struct afb_session *session; /* the associated session */
};
/* types of hooks */
enum trace_type
{
- Trace_Type_Xreq, /* xreq hooks */
- Trace_Type_Ditf, /* export hooks */
- Trace_Type_Svc, /* export hooks */
- Trace_Type_Evt, /* evt hooks */
- Trace_Type_Global, /* global hooks */
- Trace_Type_Count /* count of types of hooks */
+ Trace_Type_Xreq, /* xreq hooks */
+ Trace_Type_Api, /* api hooks */
+ Trace_Type_Evt, /* evt hooks */
+ Trace_Type_Session, /* session hooks */
+ Trace_Type_Global, /* global hooks */
+#if !defined(REMOVE_LEGACY_TRACE)
+ Trace_Legacy_Type_Ditf, /* export hooks */
+ Trace_Legacy_Type_Svc, /* export hooks */
+#endif
+ Trace_Type_Count, /* count of types of hooks */
};
/* client data */
{
int refcount; /* reference count */
pthread_mutex_t mutex; /* concurrency management */
- struct afb_daemon *daemon; /* daemon */
+ const char *apiname; /* api name for events */
struct afb_session *bound; /* bound to session */
struct event *events; /* list of events */
struct tag *tags; /* list of tags */
- struct session *sessions; /* list of tags */
struct hook *hooks[Trace_Type_Count]; /* hooks */
};
}
}
-/* get the value of the flag of 'name' in the array 'flags' of 'count elements */
-static int get_flag(const char *name, struct flag flags[], int count)
-{
- /* dichotomic search */
- int lower = 0, upper = count;
- while (lower < upper) {
- int mid = (lower + upper) >> 1;
- int cmp = strcmp(name, flags[mid].name);
- if (!cmp)
- return flags[mid].value;
- if (cmp < 0)
- upper = mid;
- else
- lower = mid + 1;
- }
- return 0;
-}
-
/* timestamp */
static struct json_object *timestamp(const struct afb_hookid *hookid)
{
- char ts[50];
-
- snprintf(ts, sizeof ts, "%llu.%06lu", (long long unsigned)hookid->time.tv_sec, (long unsigned)(hookid->time.tv_nsec / 1000));
- return json_object_new_string(ts);
+ return json_object_new_double((double)hookid->time.tv_sec +
+ (double)hookid->time.tv_nsec * .000000001);
}
/* verbosity level name or NULL */
type, data1,
"data", data2);
- afb_evt_unhooked_push(hook->event->event, data);
+ afb_evt_evtid_push(hook->event->evtid, data);
}
/*******************************************************************************/
/***** trace the requests *****/
/*******************************************************************************/
-static struct flag xreq_flags[] = { /* must be sorted by names */
- { "addref", afb_hook_flag_req_addref },
- { "all", afb_hook_flags_req_all },
- { "args", afb_hook_flags_req_args },
- { "begin", afb_hook_flag_req_begin },
- { "common", afb_hook_flags_req_common },
- { "context", afb_hook_flags_req_context },
- { "context_get", afb_hook_flag_req_context_get },
- { "context_make", afb_hook_flag_req_context_make },
- { "context_set", afb_hook_flag_req_context_set },
- { "end", afb_hook_flag_req_end },
- { "event", afb_hook_flags_req_event },
- { "extra", afb_hook_flags_req_extra },
- { "fail", afb_hook_flag_req_fail },
- { "get", afb_hook_flag_req_get },
- { "get_application_id", afb_hook_flag_req_get_application_id },
- { "has_permission", afb_hook_flag_req_has_permission },
- { "json", afb_hook_flag_req_json },
- { "life", afb_hook_flags_req_life },
- { "ref", afb_hook_flags_req_ref },
- { "result", afb_hook_flags_req_result },
- { "security", afb_hook_flags_req_security },
- { "session", afb_hook_flags_req_session },
- { "session_close", afb_hook_flag_req_session_close },
- { "session_set_LOA", afb_hook_flag_req_session_set_LOA },
- { "store", afb_hook_flag_req_store },
- { "stores", afb_hook_flags_req_stores },
- { "subcall", afb_hook_flag_req_subcall },
- { "subcall_req", afb_hook_flag_req_subcall_req },
- { "subcall_req_result", afb_hook_flag_req_subcall_req_result },
- { "subcall_result", afb_hook_flag_req_subcall_result },
- { "subcalls", afb_hook_flags_req_subcalls },
- { "subcallsync", afb_hook_flag_req_subcallsync },
- { "subcallsync_result", afb_hook_flag_req_subcallsync_result },
- { "subscribe", afb_hook_flag_req_subscribe },
- { "success", afb_hook_flag_req_success },
- { "unref", afb_hook_flag_req_unref },
- { "unstore", afb_hook_flag_req_unstore },
- { "unsubscribe", afb_hook_flag_req_unsubscribe },
- { "vverbose", afb_hook_flag_req_vverbose },
-};
-
-/* get the xreq value for flag of 'name' */
-static int get_xreq_flag(const char *name)
-{
- return get_flag(name, xreq_flags, (int)(sizeof xreq_flags / sizeof *xreq_flags));
-}
-
static void hook_xreq(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, const char *action, const char *format, ...)
{
- struct json_object *cred = NULL;
+ struct afb_cred *cred;
+ struct json_object *jcred = NULL;
const char *session = NULL;
va_list ap;
if (xreq->context.session)
session = afb_session_uuid(xreq->context.session);
- if (xreq->cred)
- wrap_json_pack(&cred, "{si ss si si ss* ss*}",
- "uid", (int)xreq->cred->uid,
- "user", xreq->cred->user,
- "gid", (int)xreq->cred->gid,
- "pid", (int)xreq->cred->pid,
- "label", xreq->cred->label,
- "id", xreq->cred->id
+ cred = xreq->context.credentials;
+ if (cred)
+ wrap_json_pack(&jcred, "{si ss si si ss* ss*}",
+ "uid", (int)cred->uid,
+ "user", cred->user,
+ "gid", (int)cred->gid,
+ "pid", (int)cred->pid,
+ "label", cred->label,
+ "id", cred->id
);
va_start(ap, format);
emit(closure, hookid, "request", "{si ss ss ss so* ss*}", format, ap,
"index", xreq->hookindex,
- "api", xreq->api,
- "verb", xreq->verb,
+ "api", xreq->request.called_api,
+ "verb", xreq->request.called_verb,
"action", action,
- "credentials", cred,
+ "credentials", jcred,
"session", session);
va_end(ap);
}
static void hook_xreq_begin(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq)
{
- hook_xreq(closure, hookid, xreq, "begin", NULL);
+ hook_xreq(closure, hookid, xreq, "begin", "{sO?}",
+ "json", afb_xreq_unhooked_json((struct afb_xreq*)xreq));
}
static void hook_xreq_end(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq)
"path", arg.path);
}
-static void hook_xreq_success(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct json_object *obj, const char *info)
+static void hook_xreq_reply(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct json_object *obj, const char *error, const char *info)
{
- hook_xreq(closure, hookid, xreq, "success", "{sO? ss?}",
+ hook_xreq(closure, hookid, xreq, "reply", "{sO? ss? ss?}",
"result", obj,
- "info", info);
-}
-
-static void hook_xreq_fail(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, const char *status, const char *info)
-{
- hook_xreq(closure, hookid, xreq, "fail", "{ss? ss?}",
- "status", status,
+ "error", error,
"info", info);
}
"result", result);
}
-static void hook_xreq_subscribe(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct afb_event event, int result)
+static void hook_xreq_subscribe(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct afb_event_x2 *event, int result)
{
hook_xreq(closure, hookid, xreq, "subscribe", "{s{ss si} si}",
"event",
- "name", afb_evt_event_name(event),
- "id", afb_evt_event_id(event),
+ "name", afb_evt_event_x2_fullname(event),
+ "id", afb_evt_event_x2_id(event),
"result", result);
}
-static void hook_xreq_unsubscribe(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct afb_event event, int result)
+static void hook_xreq_unsubscribe(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct afb_event_x2 *event, int result)
{
hook_xreq(closure, hookid, xreq, "unsubscribe", "{s{ss? si} si}",
"event",
- "name", afb_evt_event_name(event),
- "id", afb_evt_event_id(event),
+ "name", afb_evt_event_x2_fullname(event),
+ "id", afb_evt_event_x2_id(event),
"result", result);
}
"args", args);
}
-static void hook_xreq_subcall_result(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, int status, struct json_object *result)
+static void hook_xreq_subcall_result(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct json_object *object, const char *error, const char *info)
{
- hook_xreq(closure, hookid, xreq, "subcall_result", "{si sO?}",
- "status", status,
- "result", result);
+ hook_xreq(closure, hookid, xreq, "subcall_result", "{sO? ss? ss?}",
+ "object", object,
+ "error", error,
+ "info", info);
}
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)
"args", args);
}
-static void hook_xreq_subcallsync_result(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, int status, struct json_object *result)
+static void hook_xreq_subcallsync_result(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, int status, struct json_object *object, const char *error, const char *info)
{
- hook_xreq(closure, hookid, xreq, "subcallsync_result", "{si sO?}",
+ hook_xreq(closure, hookid, xreq, "subcallsync_result", "{si sO? ss? ss?}",
"status", status,
- "result", result);
+ "object", object,
+ "error", error,
+ "info", info);
}
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)
hook_xreq(closure, hookid, xreq, "unstore", NULL);
}
-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)
-{
- hook_xreq(closure, hookid, xreq, "subcall_req", "{ss? ss? sO?}",
- "api", api,
- "verb", verb,
- "args", args);
-}
-
-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)
-{
- hook_xreq(closure, hookid, xreq, "subcall_req_result", "{si sO?}",
- "status", status,
- "result", result);
-}
-
static void hook_xreq_has_permission(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, const char *permission, int result)
{
hook_xreq(closure, hookid, xreq, "has_permission", "{ss sb}",
"result", pr);
}
+static void hook_xreq_get_uid(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, int result)
+{
+ hook_xreq(closure, hookid, xreq, "get_uid", "{si}",
+ "result", result);
+}
+
+static void hook_xreq_get_client_info(void *closure, const struct afb_hookid *hookid, const struct afb_xreq *xreq, struct json_object *result)
+{
+ hook_xreq(closure, hookid, xreq, "get_client_info", "{sO}",
+ "result", result);
+}
+
static struct afb_hook_xreq_itf hook_xreq_itf = {
.hook_xreq_begin = hook_xreq_begin,
.hook_xreq_end = hook_xreq_end,
.hook_xreq_json = hook_xreq_json,
.hook_xreq_get = hook_xreq_get,
- .hook_xreq_success = hook_xreq_success,
- .hook_xreq_fail = hook_xreq_fail,
- .hook_xreq_context_get = hook_xreq_context_get,
- .hook_xreq_context_set = hook_xreq_context_set,
+ .hook_xreq_reply = hook_xreq_reply,
+ .hook_xreq_legacy_context_get = hook_xreq_context_get,
+ .hook_xreq_legacy_context_set = hook_xreq_context_set,
.hook_xreq_addref = hook_xreq_addref,
.hook_xreq_unref = hook_xreq_unref,
.hook_xreq_session_close = hook_xreq_session_close,
.hook_xreq_subcallsync = hook_xreq_subcallsync,
.hook_xreq_subcallsync_result = hook_xreq_subcallsync_result,
.hook_xreq_vverbose = hook_xreq_vverbose,
- .hook_xreq_store = hook_xreq_store,
- .hook_xreq_unstore = hook_xreq_unstore,
- .hook_xreq_subcall_req = hook_xreq_subcall_req,
- .hook_xreq_subcall_req_result = hook_xreq_subcall_req_result,
+ .hook_xreq_legacy_store = hook_xreq_store,
+ .hook_xreq_legacy_unstore = hook_xreq_unstore,
.hook_xreq_has_permission = hook_xreq_has_permission,
.hook_xreq_get_application_id = hook_xreq_get_application_id,
- .hook_xreq_context_make = hook_xreq_context_make
+ .hook_xreq_context_make = hook_xreq_context_make,
+ .hook_xreq_get_uid = hook_xreq_get_uid,
+ .hook_xreq_get_client_info = hook_xreq_get_client_info,
};
/*******************************************************************************/
-/***** trace the daemon interface *****/
+/***** trace the api interface *****/
/*******************************************************************************/
-static struct flag ditf_flags[] = { /* must be sorted by names */
- { "all", afb_hook_flags_ditf_all },
- { "common", afb_hook_flags_ditf_common },
- { "event_broadcast_after", afb_hook_flag_ditf_event_broadcast_after },
- { "event_broadcast_before", afb_hook_flag_ditf_event_broadcast_before },
- { "event_make", afb_hook_flag_ditf_event_make },
- { "extra", afb_hook_flags_ditf_extra },
- { "get_event_loop", afb_hook_flag_ditf_get_event_loop },
- { "get_system_bus", afb_hook_flag_ditf_get_system_bus },
- { "get_user_bus", afb_hook_flag_ditf_get_user_bus },
- { "queue_job", afb_hook_flag_ditf_queue_job },
- { "require_api", afb_hook_flag_ditf_require_api },
- { "require_api_result", afb_hook_flag_ditf_require_api_result },
- { "rootdir_get_fd", afb_hook_flag_ditf_rootdir_get_fd },
- { "rootdir_open_locale", afb_hook_flag_ditf_rootdir_open_locale },
- { "unstore_req", afb_hook_flag_ditf_unstore_req },
- { "vverbose", afb_hook_flag_ditf_vverbose },
-};
-
-/* get the export value for flag of 'name' */
-static int get_ditf_flag(const char *name)
-{
- return get_flag(name, ditf_flags, (int)(sizeof ditf_flags / sizeof *ditf_flags));
-}
-
-
-static void hook_ditf(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *action, const char *format, ...)
+static void hook_api(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *action, const char *format, ...)
{
va_list ap;
va_start(ap, format);
- emit(closure, hookid, "daemon", "{ss ss}", format, ap,
+ emit(closure, hookid, "api", "{ss ss}", format, ap,
"api", afb_export_apiname(export),
"action", action);
va_end(ap);
}
-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)
+static void hook_api_event_broadcast_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, struct json_object *object)
{
- hook_ditf(closure, hookid, export, "event_broadcast_before", "{ss sO*}",
+ hook_api(closure, hookid, export, "event_broadcast_before", "{ss sO?}",
"name", name, "data", object);
}
-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)
+static void hook_api_event_broadcast_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, struct json_object *object, int result)
{
- hook_ditf(closure, hookid, export, "event_broadcast_after", "{ss sO* si}",
+ hook_api(closure, hookid, export, "event_broadcast_after", "{ss sO? si}",
"name", name, "data", object, "result", result);
}
-static void hook_ditf_get_event_loop(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct sd_event *result)
+static void hook_api_get_event_loop(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct sd_event *result)
{
- hook_ditf(closure, hookid, export, "get_event_loop", NULL);
+ hook_api(closure, hookid, export, "get_event_loop", NULL);
}
-static void hook_ditf_get_user_bus(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct sd_bus *result)
+static void hook_api_get_user_bus(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct sd_bus *result)
{
- hook_ditf(closure, hookid, export, "get_user_bus", NULL);
+ hook_api(closure, hookid, export, "get_user_bus", NULL);
}
-static void hook_ditf_get_system_bus(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct sd_bus *result)
+static void hook_api_get_system_bus(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct sd_bus *result)
{
- hook_ditf(closure, hookid, export, "get_system_bus", NULL);
+ hook_api(closure, hookid, export, "get_system_bus", NULL);
}
-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)
+static void hook_api_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)
{
struct json_object *pos;
int len;
if (file)
wrap_json_pack(&pos, "{ss si ss*}", "file", file, "line", line, "function", function);
- hook_ditf(closure, hookid, export, "vverbose", "{si ss* ss? so*}",
+ hook_api(closure, hookid, export, "vverbose", "{si ss* ss? so*}",
"level", level,
"type", verbosity_level_name(level),
len < 0 ? "format" : "message", len < 0 ? fmt : msg,
free(msg);
}
-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)
+static void hook_api_event_make(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, struct afb_event_x2 *result)
{
- hook_ditf(closure, hookid, export, "event_make", "{ss ss si}",
- "name", name, "event", afb_evt_event_name(result), "id", afb_evt_event_id(result));
+ hook_api(closure, hookid, export, "event_make", "{ss ss si}",
+ "name", name, "event", afb_evt_event_x2_fullname(result), "id", afb_evt_event_x2_id(result));
}
-static void hook_ditf_rootdir_get_fd(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result)
+static void hook_api_rootdir_get_fd(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result)
{
- char path[PATH_MAX];
+ char path[PATH_MAX], proc[100];
+ const char *key, *val;
+ ssize_t s;
if (result >= 0) {
- sprintf(path, "/proc/self/fd/%d", result);
- readlink(path, path, sizeof path);
+ snprintf(proc, sizeof proc, "/proc/self/fd/%d", result);
+ s = readlink(proc, path, sizeof path);
+ path[s < 0 ? 0 : s >= sizeof path ? sizeof path - 1 : s] = 0;
+ key = "path";
+ val = path;
+ } else {
+ key = "error";
+ val = strerror(errno);
}
- hook_ditf(closure, hookid, export, "rootdir_get_fd", "{ss}",
- result < 0 ? "path" : "error",
- result < 0 ? strerror(errno) : path);
+ hook_api(closure, hookid, export, "rootdir_get_fd", "{ss}", key, val);
}
-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)
+static void hook_api_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)
{
- char path[PATH_MAX];
+ char path[PATH_MAX], proc[100];
+ const char *key, *val;
+ ssize_t s;
if (result >= 0) {
- sprintf(path, "/proc/self/fd/%d", result);
- readlink(path, path, sizeof path);
+ snprintf(proc, sizeof proc, "/proc/self/fd/%d", result);
+ s = readlink(proc, path, sizeof path);
+ path[s < 0 ? 0 : s >= sizeof path ? sizeof path - 1 : s] = 0;
+ key = "path";
+ val = path;
+ } else {
+ key = "error";
+ val = strerror(errno);
}
- hook_ditf(closure, hookid, export, "rootdir_open_locale", "{ss si ss* ss}",
+ hook_api(closure, hookid, export, "rootdir_open_locale", "{ss si ss* ss}",
"file", filename,
"flags", flags,
"locale", locale,
- result < 0 ? "path" : "error",
- result < 0 ? strerror(errno) : path);
+ key, val);
}
-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)
+static void hook_api_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)
{
- hook_ditf(closure, hookid, export, "queue_job", "{ss}", "result", result);
+ hook_api(closure, hookid, export, "queue_job", "{ss}", "result", result);
}
-static void hook_ditf_unstore_req(void * closure, const struct afb_hookid *hookid, const struct afb_export *export, struct afb_stored_req *sreq)
+static void hook_api_unstore_req(void * closure, const struct afb_hookid *hookid, const struct afb_export *export, struct afb_stored_req *sreq)
{
- hook_ditf(closure, hookid, export, "unstore_req", NULL);
+ hook_api(closure, hookid, export, "unstore_req", NULL);
}
-static void hook_ditf_require_api(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, int initialized)
+static void hook_api_require_api(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, int initialized)
{
- hook_ditf(closure, hookid, export, "require_api", "{ss sb}", "name", name, "initialized", initialized);
+ hook_api(closure, hookid, export, "require_api", "{ss sb}", "name", name, "initialized", initialized);
}
-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)
+static void hook_api_require_api_result(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, int initialized, int result)
{
- hook_ditf(closure, hookid, export, "require_api_result", "{ss sb si}", "name", name, "initialized", initialized, "result", result);
+ hook_api(closure, hookid, export, "require_api_result", "{ss sb si}", "name", name, "initialized", initialized, "result", result);
}
-static struct afb_hook_ditf_itf hook_ditf_itf = {
- .hook_ditf_event_broadcast_before = hook_ditf_event_broadcast_before,
- .hook_ditf_event_broadcast_after = hook_ditf_event_broadcast_after,
- .hook_ditf_get_event_loop = hook_ditf_get_event_loop,
- .hook_ditf_get_user_bus = hook_ditf_get_user_bus,
- .hook_ditf_get_system_bus = hook_ditf_get_system_bus,
- .hook_ditf_vverbose = hook_ditf_vverbose,
- .hook_ditf_event_make = hook_ditf_event_make,
- .hook_ditf_rootdir_get_fd = hook_ditf_rootdir_get_fd,
- .hook_ditf_rootdir_open_locale = hook_ditf_rootdir_open_locale,
- .hook_ditf_queue_job = hook_ditf_queue_job,
- .hook_ditf_unstore_req = hook_ditf_unstore_req,
- .hook_ditf_require_api = hook_ditf_require_api,
- .hook_ditf_require_api_result = hook_ditf_require_api_result
-};
+static void hook_api_add_alias_cb(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *api, const char *alias, int result)
+{
+ hook_api(closure, hookid, export, "add_alias", "{si ss? ss}", "status", result, "api", api, "alias", alias);
+}
-/*******************************************************************************/
-/***** trace the services *****/
-/*******************************************************************************/
+static void hook_api_start_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export)
+{
+ hook_api(closure, hookid, export, "start_before", NULL);
+}
-static struct flag svc_flags[] = { /* must be sorted by names */
- { "all", afb_hook_flags_svc_all },
- { "call", afb_hook_flag_svc_call },
- { "call_result", afb_hook_flag_svc_call_result },
- { "callsync", afb_hook_flag_svc_callsync },
- { "callsync_result", afb_hook_flag_svc_callsync_result },
- { "on_event_after", afb_hook_flag_svc_on_event_after },
- { "on_event_before", afb_hook_flag_svc_on_event_before },
- { "start_after", afb_hook_flag_svc_start_after },
- { "start_before", afb_hook_flag_svc_start_before },
-};
+static void hook_api_start_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int status)
+{
+ hook_api(closure, hookid, export, "start_after", "{si}", "result", status);
+}
-/* get the export value for flag of 'name' */
-static int get_svc_flag(const char *name)
+static void hook_api_on_event_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *event, int evtid, struct json_object *object)
{
- return get_flag(name, svc_flags, (int)(sizeof svc_flags / sizeof *svc_flags));
+ hook_api(closure, hookid, export, "on_event_before", "{ss si sO*}",
+ "event", event, "id", evtid, "data", object);
}
-static void hook_svc(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *action, const char *format, ...)
+static void hook_api_on_event_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *event, int evtid, struct json_object *object)
{
- va_list ap;
+ hook_api(closure, hookid, export, "on_event_after", "{ss si sO?}",
+ "event", event, "id", evtid, "data", object);
+}
- va_start(ap, format);
- emit(closure, hookid, "service", "{ss ss}", format, ap,
- "api", afb_export_apiname(export),
- "action", action);
- va_end(ap);
+static void hook_api_call(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *api, const char *verb, struct json_object *args)
+{
+ hook_api(closure, hookid, export, "call", "{ss ss sO?}",
+ "api", api, "verb", verb, "args", args);
}
-static void hook_svc_start_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export)
+static void hook_api_call_result(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct json_object *object, const char *error, const char *info)
{
- hook_svc(closure, hookid, export, "start_before", NULL);
+ hook_api(closure, hookid, export, "call_result", "{sO? ss? ss?}",
+ "object", object, "error", error, "info", info);
}
-static void hook_svc_start_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int status)
+static void hook_api_callsync(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *api, const char *verb, struct json_object *args)
{
- hook_svc(closure, hookid, export, "start_after", "{si}", "result", status);
+ hook_api(closure, hookid, export, "callsync", "{ss ss sO?}",
+ "api", api, "verb", verb, "args", args);
}
-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)
+static void hook_api_callsync_result(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int status, struct json_object *object, const char *error, const char *info)
{
- hook_svc(closure, hookid, export, "on_event_before", "{ss si sO*}",
- "event", event, "id", eventid, "data", object);
+ hook_api(closure, hookid, export, "callsync_result", "{si sO? ss? ss?}",
+ "status", status, "object", object, "error", error, "info", info);
}
-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)
+static void hook_api_new_api_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *api, const char *info, int noconcurrency)
{
- hook_svc(closure, hookid, export, "on_event_after", "{ss si sO*}",
- "event", event, "id", eventid, "data", object);
+ hook_api(closure, hookid, export, "new_api.before", "{ss ss? sb}",
+ "api", api, "info", info, "noconcurrency", noconcurrency);
}
-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)
+static void hook_api_new_api_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const char *api)
{
- hook_svc(closure, hookid, export, "call", "{ss ss sO*}",
- "api", api, "verb", verb, "args", args);
+ hook_api(closure, hookid, export, "new_api.after", "{si ss}",
+ "status", result, "api", api);
}
-static void hook_svc_call_result(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int status, struct json_object *result)
+static void hook_api_api_set_verbs_v2(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const struct afb_verb_v2 *verbs)
{
- hook_svc(closure, hookid, export, "call_result", "{si sO*}",
- "status", status, "result", result);
+ hook_api(closure, hookid, export, "set_verbs_v2", "{si}", "status", result);
}
-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)
+static void hook_api_api_set_verbs_v3(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const struct afb_verb_v3 *verbs)
{
- hook_svc(closure, hookid, export, "callsync", "{ss ss sO*}",
- "api", api, "verb", verb, "args", args);
+ hook_api(closure, hookid, export, "set_verbs_v3", "{si}", "status", result);
}
-static void hook_svc_callsync_result(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int status, struct json_object *result)
+
+static void hook_api_api_add_verb(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const char *verb, const char *info, int glob)
{
- hook_svc(closure, hookid, export, "callsync_result", "{si sO*}",
- "status", status, "result", result);
+ hook_api(closure, hookid, export, "add_verb", "{si ss ss? sb}", "status", result, "verb", verb, "info", info, "glob", glob);
}
-static struct afb_hook_svc_itf hook_svc_itf = {
- .hook_svc_start_before = hook_svc_start_before,
- .hook_svc_start_after = hook_svc_start_after,
- .hook_svc_on_event_before = hook_svc_on_event_before,
- .hook_svc_on_event_after = hook_svc_on_event_after,
- .hook_svc_call = hook_svc_call,
- .hook_svc_call_result = hook_svc_call_result,
- .hook_svc_callsync = hook_svc_callsync,
- .hook_svc_callsync_result = hook_svc_callsync_result
-};
+static void hook_api_api_del_verb(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const char *verb)
+{
+ hook_api(closure, hookid, export, "del_verb", "{si ss}", "status", result, "verb", verb);
+}
-/*******************************************************************************/
-/***** trace the events *****/
-/*******************************************************************************/
+static void hook_api_api_set_on_event(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result)
+{
+ hook_api(closure, hookid, export, "set_on_event", "{si}", "status", result);
+}
-static struct flag evt_flags[] = { /* must be sorted by names */
- { "all", afb_hook_flags_evt_all },
- { "broadcast_after", afb_hook_flag_evt_broadcast_after },
- { "broadcast_before", afb_hook_flag_evt_broadcast_before },
- { "common", afb_hook_flags_evt_common },
- { "create", afb_hook_flag_evt_create },
- { "drop", afb_hook_flag_evt_drop },
- { "extra", afb_hook_flags_evt_extra },
- { "name", afb_hook_flag_evt_name },
- { "push_after", afb_hook_flag_evt_push_after },
- { "push_before", afb_hook_flag_evt_push_before },
-};
+static void hook_api_api_set_on_init(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result)
+{
+ hook_api(closure, hookid, export, "set_on_init", "{si}", "status", result);
+}
+
+static void hook_api_api_seal(void *closure, const struct afb_hookid *hookid, const struct afb_export *export)
+{
+ hook_api(closure, hookid, export, "seal", NULL);
+}
+
+static void hook_api_event_handler_add(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const char *pattern)
+{
+ hook_api(closure, hookid, export, "event_handler_add", "{si ss?}", "status", result, "pattern", pattern);
+}
+
+static void hook_api_event_handler_del(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const char *pattern)
+{
+ hook_api(closure, hookid, export, "event_handler_del", "{si ss?}", "status", result, "pattern", pattern);
+}
+
+static void hook_api_class_provide(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const char *name)
+{
+ hook_api(closure, hookid, export, "class_provide", "{si ss?}", "status", result, "name", name);
+}
+
+static void hook_api_class_require(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result, const char *name)
+{
+ hook_api(closure, hookid, export, "class_require", "{si ss?}", "status", result, "name", name);
+}
+
+static void hook_api_delete_api(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result)
+{
+ hook_api(closure, hookid, export, "delete_api", "{si}", "status", result);
+}
+
+static void hook_api_on_event_handler_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *event, int event_x2, struct json_object *object, const char *pattern)
+{
+ hook_api(closure, hookid, export, "on_event_handler.before",
+ "{ss ss sO?}", "pattern", pattern, "event", event, "data", object);
+}
-/* get the evt value for flag of 'name' */
-static int get_evt_flag(const char *name)
+static void hook_api_on_event_handler_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *event, int event_x2, struct json_object *object, const char *pattern)
{
- return get_flag(name, evt_flags, (int)(sizeof evt_flags / sizeof *evt_flags));
+ hook_api(closure, hookid, export, "on_event_handler.after",
+ "{ss ss sO?}", "pattern", pattern, "event", event, "data", object);
}
+static void hook_api_settings(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, struct json_object *object)
+{
+ hook_api(closure, hookid, export, "settings", "{sO}", "settings", object);
+}
+
+static struct afb_hook_api_itf hook_api_itf = {
+ .hook_api_event_broadcast_before = hook_api_event_broadcast_before,
+ .hook_api_event_broadcast_after = hook_api_event_broadcast_after,
+ .hook_api_get_event_loop = hook_api_get_event_loop,
+ .hook_api_get_user_bus = hook_api_get_user_bus,
+ .hook_api_get_system_bus = hook_api_get_system_bus,
+ .hook_api_vverbose = hook_api_vverbose,
+ .hook_api_event_make = hook_api_event_make,
+ .hook_api_rootdir_get_fd = hook_api_rootdir_get_fd,
+ .hook_api_rootdir_open_locale = hook_api_rootdir_open_locale,
+ .hook_api_queue_job = hook_api_queue_job,
+ .hook_api_legacy_unstore_req = hook_api_unstore_req,
+ .hook_api_require_api = hook_api_require_api,
+ .hook_api_require_api_result = hook_api_require_api_result,
+ .hook_api_add_alias = hook_api_add_alias_cb,
+ .hook_api_start_before = hook_api_start_before,
+ .hook_api_start_after = hook_api_start_after,
+ .hook_api_on_event_before = hook_api_on_event_before,
+ .hook_api_on_event_after = hook_api_on_event_after,
+ .hook_api_call = hook_api_call,
+ .hook_api_call_result = hook_api_call_result,
+ .hook_api_callsync = hook_api_callsync,
+ .hook_api_callsync_result = hook_api_callsync_result,
+ .hook_api_new_api_before = hook_api_new_api_before,
+ .hook_api_new_api_after = hook_api_new_api_after,
+ .hook_api_api_set_verbs_v2 = hook_api_api_set_verbs_v2,
+ .hook_api_api_set_verbs_v3 = hook_api_api_set_verbs_v3,
+ .hook_api_api_add_verb = hook_api_api_add_verb,
+ .hook_api_api_del_verb = hook_api_api_del_verb,
+ .hook_api_api_set_on_event = hook_api_api_set_on_event,
+ .hook_api_api_set_on_init = hook_api_api_set_on_init,
+ .hook_api_api_seal = hook_api_api_seal,
+ .hook_api_event_handler_add = hook_api_event_handler_add,
+ .hook_api_event_handler_del = hook_api_event_handler_del,
+ .hook_api_class_provide = hook_api_class_provide,
+ .hook_api_class_require = hook_api_class_require,
+ .hook_api_delete_api = hook_api_delete_api,
+ .hook_api_on_event_handler_before = hook_api_on_event_handler_before,
+ .hook_api_on_event_handler_after = hook_api_on_event_handler_after,
+ .hook_api_settings = hook_api_settings,
+};
+
+/*******************************************************************************/
+/***** trace the events *****/
+/*******************************************************************************/
+
static void hook_evt(void *closure, const struct afb_hookid *hookid, const char *evt, int id, const char *action, const char *format, ...)
{
va_list ap;
hook_evt(closure, hookid, evt, id, "broadcast_after", "{sO* si}", "data", obj, "result", result);
}
-static void hook_evt_name(void *closure, const struct afb_hookid *hookid, const char *evt, int id)
+static void hook_evt_name(void *closure, const struct afb_hookid *hookid, const char *evt, int id, const char *result)
{
- hook_evt(closure, hookid, evt, id, "name", NULL);
+ hook_evt(closure, hookid, evt, id, "name", "{ss}", "result", result);
}
-static void hook_evt_drop(void *closure, const struct afb_hookid *hookid, const char *evt, int id)
+static void hook_evt_addref(void *closure, const struct afb_hookid *hookid, const char *evt, int id)
{
- hook_evt(closure, hookid, evt, id, "drop", NULL);
+ hook_evt(closure, hookid, evt, id, "addref", NULL);
+}
+
+static void hook_evt_unref(void *closure, const struct afb_hookid *hookid, const char *evt, int id)
+{
+ hook_evt(closure, hookid, evt, id, "unref", NULL);
}
static struct afb_hook_evt_itf hook_evt_itf = {
.hook_evt_broadcast_before = hook_evt_broadcast_before,
.hook_evt_broadcast_after = hook_evt_broadcast_after,
.hook_evt_name = hook_evt_name,
- .hook_evt_drop = hook_evt_drop
+ .hook_evt_addref = hook_evt_addref,
+ .hook_evt_unref = hook_evt_unref
};
/*******************************************************************************/
-/***** trace the globals *****/
+/***** trace the sessions *****/
/*******************************************************************************/
-static struct flag global_flags[] = { /* must be sorted by names */
- { "all", afb_hook_flags_global_all },
- { "vverbose", afb_hook_flag_global_vverbose },
-};
+static void hook_session(void *closure, const struct afb_hookid *hookid, struct afb_session *session, const char *action, const char *format, ...)
+{
+ va_list ap;
+
+ va_start(ap, format);
+ emit(closure, hookid, "session", "{ss ss}", format, ap,
+ "uuid", afb_session_uuid(session),
+ "action", action);
+ va_end(ap);
+}
+
+static void hook_session_create(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
+{
+ hook_session(closure, hookid, session, "create", NULL);
+}
+
+static void hook_session_close(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
+{
+ hook_session(closure, hookid, session, "close", NULL);
+}
-/* get the global value for flag of 'name' */
-static int get_global_flag(const char *name)
+static void hook_session_destroy(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
{
- return get_flag(name, global_flags, (int)(sizeof global_flags / sizeof *global_flags));
+ hook_session(closure, hookid, session, "destroy", NULL);
}
+static void hook_session_addref(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
+{
+ hook_session(closure, hookid, session, "addref", NULL);
+}
+
+static void hook_session_unref(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
+{
+ hook_session(closure, hookid, session, "unref", NULL);
+}
+
+static struct afb_hook_session_itf hook_session_itf = {
+ .hook_session_create = hook_session_create,
+ .hook_session_close = hook_session_close,
+ .hook_session_destroy = hook_session_destroy,
+ .hook_session_addref = hook_session_addref,
+ .hook_session_unref = hook_session_unref
+};
+
+/*******************************************************************************/
+/***** trace the globals *****/
+/*******************************************************************************/
+
static void hook_global(void *closure, const struct afb_hookid *hookid, const char *action, const char *format, ...)
{
va_list ap;
{
.name = "request",
.unref = (void(*)(void*))afb_hook_unref_xreq,
- .get_flag = get_xreq_flag
- },
- [Trace_Type_Ditf] =
- {
- .name = "daemon",
- .unref = (void(*)(void*))afb_hook_unref_ditf,
- .get_flag = get_ditf_flag
+ .get_flag = afb_hook_flags_xreq_from_text
},
- [Trace_Type_Svc] =
+ [Trace_Type_Api] =
{
- .name = "service",
- .unref = (void(*)(void*))afb_hook_unref_svc,
- .get_flag = get_svc_flag
+ .name = "api",
+ .unref = (void(*)(void*))afb_hook_unref_api,
+ .get_flag = afb_hook_flags_api_from_text
},
[Trace_Type_Evt] =
{
.name = "event",
.unref = (void(*)(void*))afb_hook_unref_evt,
- .get_flag = get_evt_flag
+ .get_flag = afb_hook_flags_evt_from_text
+ },
+ [Trace_Type_Session] =
+ {
+ .name = "session",
+ .unref = (void(*)(void*))afb_hook_unref_session,
+ .get_flag = afb_hook_flags_session_from_text
},
[Trace_Type_Global] =
{
.name = "global",
.unref = (void(*)(void*))afb_hook_unref_global,
- .get_flag = get_global_flag
+ .get_flag = afb_hook_flags_global_from_text
},
+#if !defined(REMOVE_LEGACY_TRACE)
+ [Trace_Legacy_Type_Ditf] =
+ {
+ .name = "daemon",
+ .unref = (void(*)(void*))afb_hook_unref_api,
+ .get_flag = afb_hook_flags_legacy_ditf_from_text
+ },
+ [Trace_Legacy_Type_Svc] =
+ {
+ .name = "service",
+ .unref = (void(*)(void*))afb_hook_unref_api,
+ .get_flag = afb_hook_flags_legacy_svc_from_text
+ },
+#endif
};
/*******************************************************************************/
/*******************************************************************************/
/* drop hooks of 'trace' matching 'tag' and 'event' and 'session' */
-static void trace_unhook(struct afb_trace *trace, struct tag *tag, struct event *event, struct session *session)
+static void trace_unhook(struct afb_trace *trace, struct tag *tag, struct event *event, struct afb_session *session)
{
int i;
struct hook *hook, **prev;
struct hook *hook;
struct tag *tag, **ptag;
struct event *event, **pevent;
- struct session *session, **psession;
- /* clean sessions */
- psession = &trace->sessions;
- while ((session = *psession)) {
- /* search for session */
- for (hook = NULL, i = 0 ; !hook && i < Trace_Type_Count ; i++)
- for (hook = trace->hooks[i] ; hook && hook->session != session ; hook = hook->next);
- /* keep or free whether used or not */
- if (hook)
- psession = &session->next;
- else {
- *psession = session->next;
- if (__atomic_exchange_n(&session->trace, NULL, __ATOMIC_RELAXED))
- afb_session_set_cookie(session->session, session, NULL, NULL);
- free(session);
- }
- }
/* clean tags */
ptag = &trace->tags;
while ((tag = *ptag)) {
pevent = &event->next;
else {
*pevent = event->next;
- afb_event_drop(event->event);
+ afb_evt_evtid_unref(event->evtid);
free(event);
}
}
}
-/* callback at end of traced session */
-static void free_session_cookie(void *cookie)
-{
- struct session *session = cookie;
- struct afb_trace *trace = __atomic_exchange_n(&session->trace, NULL, __ATOMIC_RELAXED);
- if (trace) {
- pthread_mutex_lock(&trace->mutex);
- trace_unhook(trace, NULL, NULL, session);
- trace_cleanup(trace);
- pthread_mutex_unlock(&trace->mutex);
- }
-}
-
/*
* Get the tag of 'name' within 'trace'.
* If 'alloc' isn't zero, create the tag and add it.
if (!tag && alloc) {
/* creation if needed */
- tag = malloc(sizeof * tag + strlen(name));
+ tag = malloc(sizeof * tag + 1 + strlen(name));
if (tag) {
strcpy(tag->tag, name);
tag->next = trace->tags;
/* search the event */
event = trace->events;
- while (event && strcmp(afb_event_name(event->event), name))
+ while (event && strcmp(afb_evt_evtid_name(event->evtid), name))
event = event->next;
if (!event && alloc) {
event = malloc(sizeof * event);
if (event) {
- event->event = trace->daemon->itf->event_make(trace->daemon->closure, name);
- if (afb_event_is_valid(event->event)) {
+ event->evtid = afb_evt_evtid_create2(trace->apiname, name);
+ if (event->evtid) {
event->next = trace->events;
trace->events = event;
} else {
}
/*
- * Get the session of 'value' within 'trace'.
- * If 'alloc' isn't zero, create the session and add it.
+ * called on session closing
*/
-static struct session *trace_get_session(struct afb_trace *trace, struct afb_session *value, int alloc)
-{
- struct session *session;
-
- /* search the session */
- session = trace->sessions;
- while (session && session->session != value)
- session = session->next;
-
- if (!session && alloc) {
- session = malloc(sizeof * session);
- if (session) {
- session->session = value;
- session->trace = NULL;
- session->next = trace->sessions;
- trace->sessions = session;
- }
- }
- return session;
+static void session_closed(void *item)
+{
+ struct cookie *cookie = item;
+
+ pthread_mutex_lock(&cookie->trace->mutex);
+ trace_unhook(cookie->trace, NULL, NULL, cookie->session);
+ pthread_mutex_unlock(&cookie->trace->mutex);
+ free(cookie);
+}
+
+/*
+ * records the cookie of session for tracking close
+ */
+static void *session_open(void *closure)
+{
+ struct cookie *param = closure, *cookie;
+ cookie = malloc(sizeof *cookie);
+ if (cookie)
+ *cookie = *param;
+ return cookie;
}
/*
* Get the session of 'uuid' within 'trace'.
* If 'alloc' isn't zero, create the session and add it.
*/
-static struct session *trace_get_session_by_uuid(struct afb_trace *trace, const char *uuid, int alloc)
+static struct afb_session *trace_get_session_by_uuid(struct afb_trace *trace, const char *uuid, int alloc)
{
- struct afb_session *session;
- int created;
+ struct cookie cookie;
- session = afb_session_get(uuid, alloc ? &created : NULL);
- return session ? trace_get_session(trace, session, alloc) : NULL;
+ if (!alloc)
+ cookie.session = afb_session_search(uuid);
+ else {
+ cookie.session = afb_session_get(uuid, AFB_SESSION_TIMEOUT_DEFAULT, NULL);
+ if (cookie.session) {
+ cookie.trace = trace;
+ afb_session_cookie(cookie.session, cookie.trace, session_open, session_closed, &cookie, 0);
+ }
+ }
+ return cookie.session;
}
static struct hook *trace_make_detached_hook(struct afb_trace *trace, const char *event, const char *tag)
static void trace_attach_hook(struct afb_trace *trace, struct hook *hook, enum trace_type type)
{
- struct session *session = hook->session;
hook->next = trace->hooks[type];
trace->hooks[type] = hook;
- if (session && !session->trace) {
- session->trace = trace;
- afb_session_set_cookie(session->session, session, session, free_session_cookie);
- }
}
/*******************************************************************************/
struct context
{
struct afb_trace *trace;
- struct afb_req req;
+ afb_req_t req;
char *errors;
};
struct context *context;
const char *name;
const char *tag;
- const char *session;
- const char *api;
- const char *verb;
+ const char *uuid;
+ const char *apiname;
+ const char *verbname;
const char *pattern;
int flags[Trace_Type_Count];
};
-
static void addhook(struct desc *desc, enum trace_type type)
{
struct hook *hook;
- struct session *session;
+ struct afb_session *session;
struct afb_session *bind;
struct afb_trace *trace = desc->context->trace;
ctxt_error(&desc->context->errors, "tracing %s is forbidden", abstracting[type].name);
return;
}
- if (desc->session) {
+ if (desc->uuid) {
ctxt_error(&desc->context->errors, "setting session is forbidden");
return;
}
/* create the hook handler */
switch (type) {
case Trace_Type_Xreq:
- if (desc->session) {
- session = trace_get_session_by_uuid(trace, desc->session, 1);
+ if (!desc->uuid)
+ session = afb_session_addref(bind);
+ else {
+ session = trace_get_session_by_uuid(trace, desc->uuid, 1);
if (!session) {
ctxt_error(&desc->context->errors, "allocation of session failed");
free(hook);
return;
}
- bind = session->session;
}
- hook->handler = afb_hook_create_xreq(desc->api, desc->verb, bind,
+ hook->handler = afb_hook_create_xreq(desc->apiname, desc->verbname, session,
desc->flags[type], &hook_xreq_itf, hook);
+ afb_session_unref(session);
break;
- case Trace_Type_Ditf:
- hook->handler = afb_hook_create_ditf(desc->api, desc->flags[type], &hook_ditf_itf, hook);
- break;
- case Trace_Type_Svc:
- hook->handler = afb_hook_create_svc(desc->api, desc->flags[type], &hook_svc_itf, hook);
+ case Trace_Type_Api:
+ hook->handler = afb_hook_create_api(desc->apiname, desc->flags[type], &hook_api_itf, hook);
break;
case Trace_Type_Evt:
hook->handler = afb_hook_create_evt(desc->pattern, desc->flags[type], &hook_evt_itf, hook);
break;
+ case Trace_Type_Session:
+ hook->handler = afb_hook_create_session(desc->uuid, desc->flags[type], &hook_session_itf, hook);
+ break;
case Trace_Type_Global:
hook->handler = afb_hook_create_global(desc->flags[type], &hook_global_itf, hook);
break;
}
/* attach and activate the hook */
- afb_req_subscribe(desc->context->req, hook->event->event);
+ afb_req_subscribe(desc->context->req, afb_evt_event_x2_from_evtid(hook->event->evtid));
trace_attach_hook(trace, hook, type);
}
{
int i;
+#if !defined(REMOVE_LEGACY_TRACE)
+ desc->flags[Trace_Type_Api] |= desc->flags[Trace_Legacy_Type_Ditf] | desc->flags[Trace_Legacy_Type_Svc];
+ desc->flags[Trace_Legacy_Type_Ditf] = desc->flags[Trace_Legacy_Type_Svc] = 0;
+#endif
+
for (i = 0 ; i < Trace_Type_Count ; i++) {
if (desc->flags[i])
addhook(desc, i);
if (wrap_json_unpack(object, "s", &name))
ctxt_error(&desc->context->errors, "unexpected %s value %s",
abstracting[type].name,
- json_object_to_json_string(object));
+ json_object_to_json_string_ext(object, JSON_C_TO_STRING_NOSLASHESCAPE));
else {
queried = (name[0] == '*' && !name[1]) ? "all" : name;
value = abstracting[type].get_flag(queried);
add_flags(closure, object, Trace_Type_Xreq);
}
-static void add_ditf_flags(void *closure, struct json_object *object)
+#if !defined(REMOVE_LEGACY_TRACE)
+static void legacy_add_ditf_flags(void *closure, struct json_object *object)
+{
+ add_flags(closure, object, Trace_Legacy_Type_Ditf);
+}
+
+static void legacy_add_svc_flags(void *closure, struct json_object *object)
{
- add_flags(closure, object, Trace_Type_Ditf);
+ add_flags(closure, object, Trace_Legacy_Type_Svc);
}
+#endif
-static void add_svc_flags(void *closure, struct json_object *object)
+static void add_api_flags(void *closure, struct json_object *object)
{
- add_flags(closure, object, Trace_Type_Svc);
+ add_flags(closure, object, Trace_Type_Api);
}
static void add_evt_flags(void *closure, struct json_object *object)
add_flags(closure, object, Trace_Type_Evt);
}
+static void add_session_flags(void *closure, struct json_object *object)
+{
+ add_flags(closure, object, Trace_Type_Session);
+}
+
static void add_global_flags(void *closure, struct json_object *object)
{
add_flags(closure, object, Trace_Type_Global);
{
int rc;
struct desc desc;
- struct json_object *request, *event, *daemon, *service, *sub, *global;
+ struct json_object *request, *event, *sub, *global, *session, *api;
+#if !defined(REMOVE_LEGACY_TRACE)
+ struct json_object *daemon, *service;
+#endif
memcpy (&desc, closure, sizeof desc);
- request = event = daemon = service = sub = global = NULL;
+ request = event = sub = global = session = api = NULL;
+#if !defined(REMOVE_LEGACY_TRACE)
+ daemon = service = NULL;
+#endif
- 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}",
+ 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 s?o}",
"name", &desc.name,
"tag", &desc.tag,
- "api", &desc.api,
- "verb", &desc.verb,
- "session", &desc.session,
+ "apiname", &desc.apiname,
+ "verbname", &desc.verbname,
+ "uuid", &desc.uuid,
"pattern", &desc.pattern,
+ "api", &api,
"request", &request,
+#if !defined(REMOVE_LEGACY_TRACE)
"daemon", &daemon,
"service", &service,
+#endif
"event", &event,
+ "session", &session,
"global", &global,
"for", &sub);
if (!rc) {
/* replace stars */
- if (desc.api && desc.api[0] == '*' && !desc.api[1])
- desc.api = NULL;
+ if (desc.apiname && desc.apiname[0] == '*' && !desc.apiname[1])
+ desc.apiname = NULL;
- if (desc.verb && desc.verb[0] == '*' && !desc.verb[1])
- desc.verb = NULL;
+ if (desc.verbname && desc.verbname[0] == '*' && !desc.verbname[1])
+ desc.verbname = NULL;
- if (desc.session && desc.session[0] == '*' && !desc.session[1])
- desc.session = NULL;
+ if (desc.uuid && desc.uuid[0] == '*' && !desc.uuid[1])
+ desc.uuid = NULL;
/* get what is expected */
if (request)
wrap_json_optarray_for_all(request, add_xreq_flags, &desc);
+ if (api)
+ wrap_json_optarray_for_all(api, add_api_flags, &desc);
+
+#if !defined(REMOVE_LEGACY_TRACE)
if (daemon)
- wrap_json_optarray_for_all(daemon, add_ditf_flags, &desc);
+ wrap_json_optarray_for_all(daemon, legacy_add_ditf_flags, &desc);
if (service)
- wrap_json_optarray_for_all(service, add_svc_flags, &desc);
+ wrap_json_optarray_for_all(service, legacy_add_svc_flags, &desc);
+#endif
if (event)
wrap_json_optarray_for_all(event, add_evt_flags, &desc);
+ if (session)
+ wrap_json_optarray_for_all(session, add_session_flags, &desc);
+
if (global)
wrap_json_optarray_for_all(global, add_global_flags, &desc);
rc = wrap_json_unpack(object, "s", &name);
if (rc)
- ctxt_error(&context->errors, "unexpected tag value %s", json_object_to_json_string(object));
+ ctxt_error(&context->errors, "unexpected tag value %s", json_object_to_json_string_ext(object, JSON_C_TO_STRING_NOSLASHESCAPE));
else {
tag = trace_get_tag(context->trace, name, 0);
if (!tag)
rc = wrap_json_unpack(object, "s", &name);
if (rc)
- ctxt_error(&context->errors, "unexpected event value %s", json_object_to_json_string(object));
+ ctxt_error(&context->errors, "unexpected event value %s", json_object_to_json_string_ext(object, JSON_C_TO_STRING_NOSLASHESCAPE));
else {
event = trace_get_event(context->trace, name, 0);
if (!event)
{
int rc;
struct context *context = closure;
- struct session *session;
+ struct afb_session *session;
const char *uuid;
rc = wrap_json_unpack(object, "s", &uuid);
if (rc)
- ctxt_error(&context->errors, "unexpected session value %s", json_object_to_json_string(object));
+ ctxt_error(&context->errors, "unexpected session value %s", json_object_to_json_string_ext(object, JSON_C_TO_STRING_NOSLASHESCAPE));
else {
session = trace_get_session_by_uuid(context->trace, uuid, 0);
if (!session)
ctxt_error(&context->errors, "session %s not found", uuid);
- else
+ else {
trace_unhook(context->trace, NULL, NULL, session);
+ afb_session_unref(session);
+ }
}
}
/*******************************************************************************/
/* allocates an afb_trace instance */
-struct afb_trace *afb_trace_create(struct afb_daemon *daemon, struct afb_session *bound)
+struct afb_trace *afb_trace_create(const char *apiname, struct afb_session *bound)
{
struct afb_trace *trace;
- assert(daemon);
+ assert(apiname);
trace = calloc(1, sizeof *trace);
if (trace) {
trace->refcount = 1;
trace->bound = bound;
- trace->daemon = daemon;
+ trace->apiname = apiname;
pthread_mutex_init(&trace->mutex, NULL);
}
return trace;
}
/* add traces */
-int afb_trace_add(struct afb_req req, struct json_object *args, struct afb_trace *trace)
+int afb_trace_add(afb_req_t req, struct json_object *args, struct afb_trace *trace)
{
struct context context;
struct desc desc;
}
/* drop traces */
-extern int afb_trace_drop(struct afb_req req, struct json_object *args, struct afb_trace *trace)
+int afb_trace_drop(afb_req_t req, struct json_object *args, struct afb_trace *trace)
{
int rc;
struct context context;
- struct json_object *tags, *events, *sessions;
+ struct json_object *tags, *events, *uuids;
memset(&context, 0, sizeof context);
context.trace = trace;
return 0;
}
- tags = events = sessions = NULL;
+ tags = events = uuids = NULL;
rc = wrap_json_unpack(args, "{s?o s?o s?o}",
"event", &events,
"tag", &tags,
- "session", &sessions);
+ "uuid", &uuids);
- if (rc < 0 || !(events || tags || sessions)) {
+ if (rc < 0 || !(events || tags || uuids)) {
afb_req_fail(req, "error-detected", "bad drop arguments");
return -1;
}
if (events)
wrap_json_optarray_for_all(events, drop_event, &context);
- if (sessions)
- wrap_json_optarray_for_all(sessions, drop_session, &context);
+ if (uuids)
+ wrap_json_optarray_for_all(uuids, drop_session, &context);
trace_cleanup(trace);
return -1;
}
+#endif
Code Review / src / app-framework-binder.git / blobdiff