int prepare_notify(struct retr_buf **dst,
struct presentity* _p, struct watcher* _w)
{
int rc = 0;
pa_notify_cb_param_t *cbd = NULL;
/* alloc data for callback */
cbd = create_notify_cb_param(_p, _w);
if (!cbd) {
ERR("can't allocate data for callback\n");
/* FIXME: destroy subscription? */
return -1;
}
LOG(L_DBG, "notifying %.*s _p->flags=%x _w->event_package=%d _w->preferred_mimetype=%d _w->status=%d\n",
_w->uri.len, _w->uri.s, _p->flags, _w->event_package, _w->preferred_mimetype, _w->status);
if ((_w->status == WS_PENDING) ||
(_w->status == WS_PENDING_TERMINATED) ||
(_w->status == WS_REJECTED)) {
rc = prepare_unauthorized_notify(dst, _p, _w, cbd);
}
else {
switch (_w->event_package) {
case EVENT_PRESENCE:
rc = prepare_presence_notify(dst, _p, _w, cbd);
break;
case EVENT_PRESENCE_WINFO:
rc = prepare_winfo_notify(dst, _p, _w, cbd);
break;
default:
LOG(L_ERR, "sending notify for unknow package\n");
rc = -1;
}
}
if ((rc < 0) && cbd) shm_free(cbd); /* ??? or not ??? */
else {
/* At least dialog has changed (sometimes more - for example
* version counter for winfo)!
* Ignore errors there because the watcher need NOT to be in DB
* (polling). */
if (use_db) db_update_watcher(_p, _w);
/* if (use_db && (!is_watcher_terminated(_w)))
db_update_watcher(_p, _w); */
}
return rc;
}
static int rls_generate_notify_ext(rl_subscription_t *s, int full_info)
{
/* !!! the main mutex must be locked here !!! */
int res;
str doc;
dstring_t dstr;
str headers, content_type;
static str method = STR_STATIC_INIT(METHOD_NOTIFY);
dlg_t *dlg;
int exp_time = 0;
char expiration[32];
str body = STR_STATIC_INIT("");
int removed = 0;
dlg = s->u.external.dialog;
if (!dlg) return -1;
DEBUG("generating external notify\n");
str_clear(&doc);
str_clear(&content_type);
if (sm_subscription_pending(&s->u.external) != 0) {
/* create the document only for non-pending subscriptions */
if (create_rlmi_document(&doc, &content_type, s, full_info) != 0) {
return -1;
}
}
exp_time = sm_subscription_expires_in(rls_manager, &s->u.external);
sprintf(expiration, ";expires=%d\r\n", exp_time);
dstr_init(&dstr, 256);
dstr_append_zt(&dstr, "Subscription-State: ");
switch (s->u.external.status) {
case subscription_active:
dstr_append_zt(&dstr, "active");
dstr_append_zt(&dstr, expiration);
break;
case subscription_pending:
dstr_append_zt(&dstr, "pending");
dstr_append_zt(&dstr, expiration);
break;
case subscription_terminated_pending:
case subscription_terminated:
dstr_append_zt(&dstr, "terminated\r\n");
break;
case subscription_terminated_pending_to:
case subscription_terminated_to:
dstr_append_zt(&dstr,
"terminated;reason=timeout\r\n");
break;
case subscription_uninitialized:
dstr_append_zt(&dstr, "pending\r\n");
/* this is an error ! */
LOG(L_ERR, "sending NOTIFY for an unitialized subscription!\n");
break;
}
dstr_append_str(&dstr, &s->u.external.contact);
/* required by RFC 3261 */
dstr_append_zt(&dstr, "Max-Forwards: 70\r\n");
dstr_append_zt(&dstr, "Event: ");
dstr_append_str(&dstr, rls_get_package(s));
dstr_append_zt(&dstr, "\r\n");
dstr_append_zt(&dstr, "Require: eventlist\r\nContent-Type: ");
dstr_append_str(&dstr, &content_type);
dstr_append_zt(&dstr, "\r\n");
res = dstr_get_str(&dstr, &headers);
dstr_destroy(&dstr);
if (res >= 0) {
/* DEBUG("sending NOTIFY message to %.*s (subscription %p)\n",
dlg->rem_uri.len,
ZSW(dlg->rem_uri.s), s); */
if (!is_str_empty(&doc)) body = doc;
if (sm_subscription_terminated(&s->u.external) == 0) {
/* doesn't matter if delivered or not, it will be freed otherwise !!! */
res = tmb.t_request_within(&method, &headers, &body, dlg, 0, 0);
if (res >= 0) clear_change_flags(s);
}
else {
rls_notify_cb_param_t *cbd = create_notify_cb_param(s);
if (!cbd) {
ERR("Can't create notify cb data! Freeing RL subscription.\n");
rls_remove(s); /* ?????? */
removed = 1;
res = -13;
}
else {
/* the subscritpion will be destroyed if NOTIFY delivery problems */
/* rls_unlock(); the callback locks this mutex ! */
/* !!!! FIXME: callbacks can't be safely used (may be called or not,
* may free memory automaticaly or not) !!! */
res = tmb.t_request_within(&method, &headers, &body, dlg, rls_notify_cb, cbd);
/* res = tmb.t_request_within(&method, &headers, &body, dlg, rls_notify_cb, s); */
/* rls_lock(); the callback locks this mutex ! */
if (res < 0) {
/* does this mean, that the callback was not called ??? */
ERR("t_request_within FAILED: %d! Freeing RL subscription.\n", res);
rls_remove(s); /* ?????? */
removed = 1;
}
else clear_change_flags(s);
}
}
}
if (doc.s) cds_free(doc.s);
if (content_type.s) cds_free(content_type.s);
if (headers.s) cds_free(headers.s);
if ((!removed) && use_db) rls_db_update(s);
if (res < 0) DEBUG("external notify NOT generated\n");
else DEBUG("external notify generated\n");
return res;
}
