int uv_fs_event_init(uv_loop_t* loop,
uv_fs_event_t* handle,
const char* filename,
uv_fs_event_cb cb,
int flags) {
int events;
int wd;
loop->counters.fs_event_init++;
/* We don't support any flags yet. */
assert(!flags);
if (init_inotify(loop)) return -1;
events = IN_ATTRIB
| IN_CREATE
| IN_MODIFY
| IN_DELETE
| IN_DELETE_SELF
| IN_MOVED_FROM
| IN_MOVED_TO;
wd = inotify_add_watch(loop->inotify_fd, filename, events);
if (wd == -1) return uv__set_sys_error(loop, errno);
uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT);
handle->filename = strdup(filename);
handle->cb = cb;
handle->fd = wd;
add_watcher(handle);
return 0;
}
static guint
add_timeout_full (MilterEventLoop *loop,
gint priority,
gdouble interval_in_seconds,
GSourceFunc function,
gpointer data,
GDestroyNotify notify)
{
guint id;
ev_timer *watcher;
TimerWatcherPrivate *watcher_priv;
MilterLibevEventLoopPrivate *priv;
priv = MILTER_LIBEV_EVENT_LOOP_GET_PRIVATE(loop);
watcher_priv = g_new0(TimerWatcherPrivate, 1);
watcher_priv->function = function;
watcher = g_new0(ev_timer, 1);
watcher->data = watcher_priv;
id = add_watcher(MILTER_LIBEV_EVENT_LOOP(loop),
(ev_watcher *)watcher,
WATCHER_STOP_FUNC(ev_timer_stop),
NULL,
notify, data);
ev_timer_init(watcher, timer_func, interval_in_seconds, interval_in_seconds);
ev_timer_start(priv->ev_loop, watcher);
return id;
}
static guint
add_idle_full (MilterEventLoop *loop,
gint priority,
GSourceFunc function,
gpointer data,
GDestroyNotify notify)
{
guint id;
ev_idle *watcher;
IdleWatcherPrivate *watcher_priv;
MilterLibevEventLoopPrivate *priv;
priv = MILTER_LIBEV_EVENT_LOOP_GET_PRIVATE(loop);
watcher_priv = g_new0(IdleWatcherPrivate, 1);
watcher_priv->function = function;
watcher = g_new0(ev_idle, 1);
watcher->data = watcher_priv;
id = add_watcher(MILTER_LIBEV_EVENT_LOOP(loop),
(ev_watcher *)watcher,
WATCHER_STOP_FUNC(ev_idle_stop),
NULL,
notify, data);
ev_idle_init(watcher, idle_func);
ev_idle_start(priv->ev_loop, watcher);
return id;
}
int register_watcher(str* _f, str* _t, notcb_t _c, void* _data)
{
udomain_t* d;
urecord_t* r;
if (find_domain(&dom, &d) > 0) {
LOG(L_ERR, "register_watcher(): Domain '%.*s' not found\n", dom.len, ZSW(dom.s));
return -1;
}
lock_udomain(d);
if (get_urecord(d, _t, &r) > 0) {
if (insert_urecord(d, _t, &r) < 0) {
unlock_udomain(d);
LOG(L_ERR, "register_watcher(): Error while creating a new record\n");
return -2;
}
}
if (add_watcher(r, _c, _data) < 0) {
LOG(L_ERR, "register_watcher(): Error while adding a watcher\n");
release_urecord(r);
unlock_udomain(d);
return -3;
}
unlock_udomain(d);
return 0;
}
static guint
watch_child_full (MilterEventLoop *loop,
gint priority,
GPid pid,
GChildWatchFunc function,
gpointer data,
GDestroyNotify notify)
{
guint id;
ev_child *watcher;
ChildWatcherPrivate *watcher_priv;
MilterLibevEventLoopPrivate *priv;
priv = MILTER_LIBEV_EVENT_LOOP_GET_PRIVATE(loop);
watcher_priv = g_new0(ChildWatcherPrivate, 1);
watcher_priv->function = function;
watcher = g_new0(ev_child, 1);
watcher->data = watcher_priv;
id = add_watcher(MILTER_LIBEV_EVENT_LOOP(loop),
(ev_watcher *)watcher,
WATCHER_STOP_FUNC(ev_child_stop),
NULL,
notify, data);
ev_child_init(watcher, child_func, pid, FALSE);
ev_child_start(priv->ev_loop, watcher);
return id;
}
void get_watchers_from_avp(str_lst_t **watchers, unsigned int *watcher_size,
unsigned int *watchers_no)
{
str_lst_t *new_watcher;
struct usr_avp *avp;
int_str val;
unsigned int size;
struct sip_uri parsed_uri;
char *p;
*watchers = NULL;
*watcher_size = 0;
*watchers_no = 0;
for(;;) {
avp = search_first_avp(watchers_avp_type, watchers_avp_name, &val, 0);
if (avp == NULL)
break;
if(avp->flags&AVP_VAL_STR)
if (parse_uri(val.s.s, val.s.len, &parsed_uri)<0)
LM_WARN("discarding non URI watcher [%.*s]\n", val.s.len, val.s.s);
else {
LM_DBG("got watcher [%.*s]\n", val.s.len, val.s.s);
size = sizeof(str_lst_t) + val.s.len;
new_watcher = (str_lst_t *)pkg_malloc(size);
if (new_watcher == NULL) {
LM_ERR("OOM\n");
return;
}
memset(new_watcher, 0, size);
p = (char*)(new_watcher + 1);
new_watcher->watcher.len = val.s.len;
new_watcher->watcher.s = p;
memcpy(p, val.s.s, val.s.len);
add_watcher(watchers, new_watcher);
*watcher_size += size;
*watchers_no += 1;
}
else
LM_WARN("Ignoring non STR AVP\n");
destroy_avp(avp);
}
print_watchers(*watchers);
return;
}
static guint
watch_io_full (MilterEventLoop *loop,
gint priority,
GIOChannel *channel,
GIOCondition condition,
GIOFunc function,
gpointer user_data,
GDestroyNotify notify)
{
guint id;
int fd;
ev_io *watcher;
IOWatcherPrivate *watcher_priv;
MilterLibevEventLoopPrivate *priv;
fd = g_io_channel_unix_get_fd(channel);
if (fd == -1)
return 0;
priv = MILTER_LIBEV_EVENT_LOOP_GET_PRIVATE(loop);
watcher_priv = g_new0(IOWatcherPrivate, 1);
watcher_priv->channel = channel;
g_io_channel_ref(watcher_priv->channel);
watcher_priv->function = function;
watcher = g_new0(ev_io, 1);
watcher->data = watcher_priv;
id = add_watcher(MILTER_LIBEV_EVENT_LOOP(loop),
(ev_watcher *)watcher,
WATCHER_STOP_FUNC(ev_io_stop),
io_watcher_destroy,
notify, user_data);
ev_io_init(watcher, io_func, fd, evcond_from_g_io_condition(condition));
ev_io_start(priv->ev_loop, watcher);
return id;
}
void get_watchers_from_csv(str *watchers_csv, str_lst_t **watchers, unsigned int *watcher_size,
unsigned int *watcher_no)
{
str_lst_t *new_watcher;
char *tmp;
char *start = watchers_csv->s;
char *end = watchers_csv->s + watchers_csv->len;
unsigned int size;
char *p;
*watchers = NULL;
*watcher_size = 0;
for( tmp=watchers_csv->s; tmp<=end; tmp++) {
if (*tmp == ',' || tmp==end) {
LM_DBG("watcher->[%.*s]\n", (int)(tmp-start), start);
size = sizeof(str_lst_t) + tmp-start;
new_watcher = (str_lst_t *)pkg_malloc(size);
if (new_watcher == NULL) {
LM_ERR("OOM\n");
return;
}
memset(new_watcher, 0, size);
p = (char*)(new_watcher + 1);
new_watcher->watcher.len = tmp-start;
new_watcher->watcher.s = p;
memcpy(p, start, tmp-start);
add_watcher(watchers, new_watcher);
*watcher_size += size;
*watcher_no += 1;
start = tmp + 1;
}
}
print_watchers(*watchers);
return;
}
/*
* Update existing presentity and watcher list
*/
static int update_presentity(struct sip_msg* _m, struct pdomain* _d,
struct presentity* _p, struct watcher** _w)
{
time_t e;
dlg_t* dialog;
str watch_uri;
str watch_dn;
event_t *event = NULL;
int et = 0;
if (_m->event) {
event = (event_t*)(_m->event->parsed);
et = event->parsed;
} else {
LOG(L_ERR, "update_presentity defaulting to EVENT_PRESENCE\n");
et = EVENT_PRESENCE;
}
if (_m->expires) {
e = ((exp_body_t*)_m->expires->parsed)->val;
} else {
e = default_expires;
}
if (get_watch_uri(_m, &watch_uri, &watch_dn) < 0) {
LOG(L_ERR, "update_presentity(): Error while extracting watcher URI\n");
return -1;
}
if (find_watcher(_p, &watch_uri, et, _w) == 0) {
LOG(L_ERR, "update_presentity() found watcher\n");
if (e == 0) {
if (et != EVENT_PRESENCE_WINFO) {
if (remove_watcher(_p, *_w) < 0) {
LOG(L_ERR, "update_presentity(): Error while deleting winfo watcher\n");
return -2;
}
} else {
if (remove_winfo_watcher(_p, *_w) < 0) {
LOG(L_ERR, "update_presentity(): Error while deleting winfo watcher\n");
return -2;
}
}
(*_w)->expires = 0; /* The watcher will be freed after NOTIFY is sent */
if (!_p->watchers && !_p->winfo_watchers) {
remove_presentity(_d, _p);
}
} else {
e += act_time;
if (update_watcher(*_w, e) < 0) {
LOG(L_ERR, "update_presentity(): Error while updating watcher\n");
return -3;
}
}
} else {
if (e) {
e += act_time;
if (tmb.new_dlg_uas(_m, 200, &dialog) < 0) {
paerrno = PA_DIALOG_ERR;
LOG(L_ERR, "update_presentity(): Error while creating dialog state\n");
return -4;
}
if (et != EVENT_PRESENCE_WINFO) {
if (add_watcher(_p, &watch_uri, e, et, acc, dialog, &watch_dn, _w) < 0) {
LOG(L_ERR, "update_presentity(): Error while creating presentity\n");
tmb.free_dlg(dialog);
return -5;
}
} else {
if (add_winfo_watcher(_p, &watch_uri, e, et, acc, dialog, &watch_dn, _w) < 0) {
LOG(L_ERR, "update_presentity(): Error while creating winfo watcher\n");
tmb.free_dlg(dialog);
return -5;
}
}
} else {
DBG("update_presentity(): expires = 0 but no watcher found\n");
*_w = 0;
}
}
return 0;
}
/*
* Create a new presentity and corresponding watcher list
*/
int create_presentity(struct sip_msg* _m, struct pdomain* _d, str* _puri,
struct presentity** _p, struct watcher** _w)
{
time_t e;
dlg_t* dialog;
str watch_uri;
str watch_dn;
event_t *event = NULL;
int et = 0;
if (_m->event) {
event = (event_t*)(_m->event->parsed);
et = event->parsed;
} else {
et = EVENT_PRESENCE;
}
if (_m->expires) {
e = ((exp_body_t*)_m->expires->parsed)->val;
} else {
e = default_expires;
}
if (e == 0) {
*_p = 0;
*_w = 0;
DBG("create_presentity(): expires = 0\n");
return 0;
}
/* Convert to absolute time */
e += act_time;
if (get_watch_uri(_m, &watch_uri, &watch_dn) < 0) {
LOG(L_ERR, "create_presentity(): Error while extracting watcher URI\n");
return -1;
}
if (new_presentity(_d, _puri, _p) < 0) {
LOG(L_ERR, "create_presentity(): Error while creating presentity\n");
return -2;
}
if (tmb.new_dlg_uas(_m, 200, &dialog) < 0) {
paerrno = PA_DIALOG_ERR;
LOG(L_ERR, "create_presentity(): Error while creating dialog state\n");
free_presentity(*_p);
return -3;
}
if (et != EVENT_PRESENCE_WINFO) {
if (add_watcher(*_p, &watch_uri, e, et, acc, dialog, &watch_dn, _w) < 0) {
LOG(L_ERR, "create_presentity(): Error while adding a watcher\n");
tmb.free_dlg(dialog);
free_presentity(*_p);
return -4;
}
} else if (et == EVENT_PRESENCE_WINFO) {
if (add_winfo_watcher(*_p, &watch_uri, e, et, acc, dialog, &watch_dn, _w) < 0) {
LOG(L_ERR, "create_presentity(): Error while adding a winfo watcher\n");
tmb.free_dlg(dialog);
free_presentity(*_p);
return -5;
}
}
add_presentity(_d, *_p);
_d->reg(&watch_uri, _puri, (void*)callback, *_p);
return 0;
}
