int create_lpidf_document(presentity_info_t *p, str_t *dst, str_t *dst_content_type)
{
dstring_t buf;
int err;
if (!dst) return -1;
str_clear(dst);
if (dst_content_type) str_clear(dst_content_type);
if (!p) return -1;
if (dst_content_type) {
if (str_dup_zt(dst_content_type, "text/lpidf") < 0) {
return -1;
}
}
/* if (!p->first_tuple) return 0;*/ /* no tuples => nothing to say */
dstr_init(&buf, 2048);
doc_add_presentity(&buf, p);
err = dstr_get_str(&buf, dst);
dstr_destroy(&buf);
if (err != 0) {
str_free_content(dst);
if (dst_content_type) str_free_content(dst_content_type);
}
return err;
}
static inline int create_headers(struct watcher* _w, str *dst, str *content_type)
{
dstring_t buf;
time_t t;
int err = 0;
dstr_init(&buf, 256);
str_clear(dst);
/* required by RFC 3261 */
dstr_append_zt(&buf, "Max-Forwards: 70\r\n");
/* Event header */
dstr_append_zt(&buf, "Event: ");
dstr_append_zt(&buf, event_package2str(_w->event_package));
dstr_append_zt(&buf, "\r\n");
/* Content-Type header */
/* content types can have dynamical parameters (multipart/related)
* => don't generate them "staticaly"; use values created in the
* time of document creation */
if (!is_str_empty(content_type)) { /* documents without body doesn't need it */
dstr_append_zt(&buf, "Content-Type: ");
dstr_append_str(&buf, content_type);
dstr_append_zt(&buf, "\r\n");
}
/* Contact header */
if (is_str_empty(&_w->server_contact)) {
LOG(L_WARN, "add_contact_hf(): Can't add empty contact to NOTIFY.\n");
}
else {
dstr_append_zt(&buf, "Contact: ");
dstr_append_str(&buf, &_w->server_contact);
dstr_append_zt(&buf, "\r\n");
}
/* Subscription-State header */
if (_w->expires) t = _w->expires - time(0);
else t = 0;
if (add_subs_state_hf(&buf, _w->status, t) < 0) {
LOG(L_ERR, "create_headers(): Error while adding Subscription-State\n");
dstr_destroy(&buf);
return -3;
}
err = dstr_get_str(&buf, dst);
dstr_destroy(&buf);
return err;
}
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;
}
int get_serialized_sstream(sstream_t *ss, str_t *dst)
{
if (ss->type == sstream_out) return dstr_get_str(&ss->out, dst);
else return -1; /* no output for input stream */
}
