#include <pthread.h>
#include <json-c/json.h>
-#include <afb/afb-binding-v2.h>
+#define AFB_BINDING_VERSION 0
+#include <afb/afb-binding.h>
#include "afb-hook.h"
#include "afb-cred.h"
/* 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 */
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 */
};
static void emit(void *closure, const struct afb_hookid *hookid, const char *type, const char *fmt1, const char *fmt2, va_list ap2, ...)
{
struct hook *hook = closure;
- struct json_object *event, *data1, *data2;
+ struct json_object *data, *data1, *data2;
va_list ap1;
- data1 = data2 = event = NULL;
+ data1 = data2 = data = NULL;
va_start(ap1, ap2);
wrap_json_vpack(&data1, fmt1, ap1);
va_end(ap1);
if (fmt2)
wrap_json_vpack(&data2, fmt2, ap2);
- wrap_json_pack(&event, "{so ss ss si so so*}",
+ wrap_json_pack(&data, "{so ss ss si so so*}",
"time", timestamp(hookid),
"tag", hook->tag->tag,
"type", type,
type, data1,
"data", data2);
- afb_evt_unhooked_push(hook->event->event, event);
+ afb_evt_evtid_push(hook->event->evtid, data);
}
/*******************************************************************************/
{ "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 },
{ "fail", afb_hook_flag_req_fail },
{ "get", afb_hook_flag_req_get },
{ "get_application_id", afb_hook_flag_req_get_application_id },
+ { "get_uid", afb_hook_flag_req_get_uid },
{ "has_permission", afb_hook_flag_req_has_permission },
{ "json", afb_hook_flag_req_json },
{ "life", afb_hook_flags_req_life },
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.api,
+ "verb", xreq->request.verb,
"action", action,
"credentials", cred,
"session", session);
"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_eventid *eventid, 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_eventid_fullname(eventid),
+ "id", afb_evt_eventid_id(eventid),
"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_eventid *eventid, 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_eventid_fullname(eventid),
+ "id", afb_evt_eventid_id(eventid),
"result", result);
}
"result", result);
}
+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)
+{
+ char pc[50], pf[50], pv[50], pr[50];
+ snprintf(pc, sizeof pc, "%p", create_value);
+ snprintf(pf, sizeof pf, "%p", free_value);
+ snprintf(pv, sizeof pv, "%p", create_closure);
+ snprintf(pr, sizeof pr, "%p", result);
+ hook_xreq(closure, hookid, xreq, "context_make", "{sb ss ss ss ss}",
+ "replace", replace,
+ "create", pc,
+ "free", pf,
+ "closure", pv,
+ "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 struct afb_hook_xreq_itf hook_xreq_itf = {
.hook_xreq_begin = hook_xreq_begin,
.hook_xreq_end = hook_xreq_end,
.hook_xreq_subcall_req = hook_xreq_subcall_req,
.hook_xreq_subcall_req_result = hook_xreq_subcall_req_result,
.hook_xreq_has_permission = hook_xreq_has_permission,
- .hook_xreq_get_application_id = hook_xreq_get_application_id
+ .hook_xreq_get_application_id = hook_xreq_get_application_id,
+ .hook_xreq_context_make = hook_xreq_context_make,
+ .hook_xreq_get_uid = hook_xreq_get_uid,
};
/*******************************************************************************/
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_ditf_event_make(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *name, struct afb_eventid *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));
+ "name", name, "event", afb_evt_eventid_fullname(result), "id", afb_evt_eventid_id(result));
}
static void hook_ditf_rootdir_get_fd(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, int result)
hook_svc(closure, hookid, export, "start_after", "{si}", "result", status);
}
-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_svc_on_event_before(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *event, int evtid, struct json_object *object)
{
hook_svc(closure, hookid, export, "on_event_before", "{ss si sO*}",
- "event", event, "id", eventid, "data", object);
+ "event", event, "id", evtid, "data", object);
}
-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_svc_on_event_after(void *closure, const struct afb_hookid *hookid, const struct afb_export *export, const char *event, int evtid, struct json_object *object)
{
hook_svc(closure, hookid, export, "on_event_after", "{ss si sO*}",
- "event", event, "id", eventid, "data", object);
+ "event", event, "id", evtid, "data", object);
}
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 struct flag evt_flags[] = { /* must be sorted by names */
+ { "addref", afb_hook_flag_evt_addref },
{ "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 },
+ { "unref", afb_hook_flag_evt_unref },
};
/* get the evt value for flag of 'name' */
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", "{ss}", "result", result);
+}
+
+static void hook_evt_addref(void *closure, const struct afb_hookid *hookid, const char *evt, int id)
{
- hook_evt(closure, hookid, evt, id, "name", NULL);
+ hook_evt(closure, hookid, evt, id, "addref", NULL);
}
-static void hook_evt_drop(void *closure, const struct afb_hookid *hookid, const char *evt, int id)
+static void hook_evt_unref(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, "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
};
/*******************************************************************************/
/*******************************************************************************/
/* 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.
*/
static struct event *trace_get_event(struct afb_trace *trace, const char *name, int alloc)
{
+ struct afb_event e;
struct event *event;
/* 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)) {
+ e = afb_daemon_make_event_v1(*trace->daemon, name);
+ event->evtid = afb_evt_eventid_to_evtid(afb_event_to_eventid(e));
+ 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;
+ struct cookie cookie;
int created;
- session = afb_session_get(uuid, alloc ? &created : NULL);
- return session ? trace_get_session(trace, session, alloc) : NULL;
+ cookie.session = afb_session_get(uuid, alloc ? &created : 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);
- }
}
/*******************************************************************************/
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;
free(hook);
return;
}
- bind = session->session;
+ bind = session;
}
hook->handler = afb_hook_create_xreq(desc->api, desc->verb, bind,
desc->flags[type], &hook_xreq_itf, hook);
}
/* attach and activate the hook */
- afb_req_subscribe(desc->context->req, hook->event->event);
+ afb_req_subscribe(desc->context->req, afb_evt_event_from_evtid(hook->event->evtid));
trace_attach_hook(trace, hook, type);
}
{
int rc;
struct context *context = closure;
- struct session *session;
+ struct afb_session *session;
const char *uuid;
rc = wrap_json_unpack(object, "s", &uuid);
Code Review / src / app-framework-binder.git / blobdiff