static int notifier_add(struct sipevent_sock *sock, const struct sip_msg *msg,
struct ua *ua)
{
const struct sip_hdr *hdr;
struct sipevent_event se;
struct notifier *not;
int err;
hdr = sip_msg_hdr(msg, SIP_HDR_EVENT);
if (!hdr)
return EPROTO;
err = sipevent_event_decode(&se, &hdr->val);
if (err)
return err;
if (pl_strcasecmp(&se.event, "presence")) {
info("presence: unexpected event '%r'\n", &se.event);
return EPROTO;
}
err = notifier_alloc(¬, sock, msg, &se, ua);
if (err)
return err;
(void)notify(not, my_status);
return 0;
}
static void sipsess_refer_handler(struct sip *sip, const struct sip_msg *msg,
void *arg)
{
struct call *call = arg;
const struct sip_hdr *hdr;
int err;
/* get the transfer target */
hdr = sip_msg_hdr(msg, SIP_HDR_REFER_TO);
if (!hdr) {
warning("call: bad REFER request from %r\n", &msg->from.auri);
(void)sip_reply(sip, msg, 400, "Missing Refer-To header");
return;
}
/* The REFER creates an implicit subscription.
* Reply 202 to the REFER request
*/
call->not = mem_deref(call->not);
err = sipevent_accept(&call->not, uag_sipevent_sock(), msg,
sipsess_dialog(call->sess), NULL,
202, "Accepted", 60, 60, 60,
ua_cuser(call->ua), "message/sipfrag",
auth_handler, call->acc, true,
sipnot_close_handler, call,
"Allow: %s\r\n", uag_allowed_methods());
if (err) {
warning("call: refer: sipevent_accept failed: %m\n", err);
return;
}
(void)call_notify_sipfrag(call, 100, "Trying");
call_event_handler(call, CALL_EVENT_TRANSFER, "%r", &hdr->val);
}
static void notify_handler(struct sip *sip, const struct sip_msg *msg,
void *arg)
{
enum presence_status status = PRESENCE_CLOSED;
struct presence *pres = arg;
const struct sip_hdr *hdr;
struct pl pl;
pres->failc = 0;
hdr = sip_msg_hdr(msg, SIP_HDR_CONTENT_TYPE);
if (!hdr || 0 != pl_strcasecmp(&hdr->val, "application/pidf+xml")) {
if (hdr)
(void)re_printf("presence: unsupported"
" content-type: '%r'\n",
&hdr->val);
sip_treplyf(NULL, NULL, sip, msg, false,
415, "Unsupported Media Type",
"Accept: application/pidf+xml\r\n"
"Content-Length: 0\r\n"
"\r\n");
return;
}
if (!re_regex((const char *)mbuf_buf(msg->mb), mbuf_get_left(msg->mb),
"<status>[^<]*<basic>[^<]*</basic>[^<]*</status>",
NULL, &pl, NULL)) {
if (!pl_strcasecmp(&pl, "open"))
status = PRESENCE_OPEN;
}
if (!re_regex((const char *)mbuf_buf(msg->mb), mbuf_get_left(msg->mb),
"<rpid:away/>")) {
status = PRESENCE_CLOSED;
}
else if (!re_regex((const char *)mbuf_buf(msg->mb),
mbuf_get_left(msg->mb),
"<rpid:busy/>")) {
status = PRESENCE_BUSY;
}
else if (!re_regex((const char *)mbuf_buf(msg->mb),
mbuf_get_left(msg->mb),
"<rpid:on-the-phone/>")) {
status = PRESENCE_BUSY;
}
(void)sip_treply(NULL, sip, msg, 200, "OK");
contact_set_presence(pres->contact, status);
}
static void start_outbound(struct sipreg *reg, const struct sip_msg *msg)
{
const struct sip_hdr *flowtimer;
if (!sip_msg_hdr_has_value(msg, SIP_HDR_REQUIRE, "outbound"))
return;
flowtimer = sip_msg_hdr(msg, SIP_HDR_FLOW_TIMER);
(void)sip_keepalive_start(®->ka, reg->sip, msg,
flowtimer ? pl_u32(&flowtimer->val) : 0,
keepalive_handler, reg);
}
/**
* Update an existing SIP Dialog from a SIP Message
*
* @param dlg SIP Dialog to update
* @param msg SIP Message
*
* @return 0 if success, otherwise errorcode
*/
int sip_dialog_update(struct sip_dialog *dlg, const struct sip_msg *msg)
{
const struct sip_hdr *contact;
struct sip_addr addr;
char *uri;
int err;
if (!dlg || !msg)
return EINVAL;
contact = sip_msg_hdr(msg, SIP_HDR_CONTACT);
if (!contact)
return EBADMSG;
if (sip_addr_decode(&addr, &contact->val))
return EBADMSG;
err = pl_strdup(&uri, &addr.auri);
if (err)
return err;
if (dlg->route.scheme.p == dlg->uri) {
struct uri tmp;
struct pl pl;
pl_set_str(&pl, uri);
err = uri_decode(&tmp, &pl);
if (err)
goto out;
dlg->route = tmp;
}
mem_deref(dlg->uri);
dlg->uri = mem_ref(uri);
out:
mem_deref(uri);
return err;
}
static void response_handler(int err, const struct sip_msg *msg, void *arg)
{
const struct sip_hdr *minexp;
struct sipreg *reg = arg;
reg->wait = failwait(reg->failc + 1);
if (err || sip_request_loops(®->ls, msg->scode)) {
reg->failc++;
goto out;
}
if (msg->scode < 200) {
return;
}
else if (msg->scode < 300) {
reg->registered = true;
reg->wait = reg->expires;
sip_msg_hdr_apply(msg, true, SIP_HDR_CONTACT, contact_handler,
reg);
reg->wait *= 900;
reg->failc = 0;
if (reg->regid > 0 && !reg->terminated && !reg->ka)
start_outbound(reg, msg);
}
else {
if (reg->terminated && !reg->registered)
goto out;
switch (msg->scode) {
case 401:
case 407:
err = sip_auth_authenticate(reg->auth, msg);
if (err) {
err = (err == EAUTH) ? 0 : err;
break;
}
err = request(reg, false);
if (err)
break;
return;
case 403:
sip_auth_reset(reg->auth);
break;
case 423:
minexp = sip_msg_hdr(msg, SIP_HDR_MIN_EXPIRES);
if (!minexp || !pl_u32(&minexp->val) || !reg->expires)
break;
reg->expires = pl_u32(&minexp->val);
err = request(reg, false);
if (err)
break;
return;
}
++reg->failc;
}
out:
if (!reg->expires) {
mem_deref(reg);
}
else if (reg->terminated) {
if (!reg->registered || request(reg, true))
mem_deref(reg);
}
else {
tmr_start(®->tmr, reg->wait, tmr_handler, reg);
reg->resph(err, msg, reg->arg);
}
}
/**
* Fork a SIP Dialog from an incoming SIP Message
*
* @param dlgp Pointer to allocated SIP Dialog
* @param odlg Original SIP Dialog
* @param msg SIP Message
*
* @return 0 if success, otherwise errorcode
*/
int sip_dialog_fork(struct sip_dialog **dlgp, struct sip_dialog *odlg,
const struct sip_msg *msg)
{
const struct sip_hdr *contact;
struct sip_dialog *dlg;
struct route_enc renc;
struct sip_addr addr;
struct pl pl;
int err;
if (!dlgp || !odlg || !odlg->cpos || !msg)
return EINVAL;
contact = sip_msg_hdr(msg, SIP_HDR_CONTACT);
if (!contact || !msg->callid.p)
return EBADMSG;
if (sip_addr_decode(&addr, &contact->val))
return EBADMSG;
dlg = mem_zalloc(sizeof(*dlg), destructor);
if (!dlg)
return ENOMEM;
dlg->callid = mem_ref(odlg->callid);
dlg->ltag = mem_ref(odlg->ltag);
dlg->lseq = odlg->lseq;
dlg->rseq = msg->req ? msg->cseq.num : 0;
err = pl_strdup(&dlg->uri, &addr.auri);
if (err)
goto out;
err = pl_strdup(&dlg->rtag, msg->req ? &msg->from.tag : &msg->to.tag);
if (err)
goto out;
dlg->mb = mbuf_alloc(512);
if (!dlg->mb) {
err = ENOMEM;
goto out;
}
renc.mb = dlg->mb;
renc.end = 0;
err |= sip_msg_hdr_apply(msg, msg->req, SIP_HDR_RECORD_ROUTE,
record_route_handler, &renc) ? ENOMEM : 0;
err |= mbuf_printf(dlg->mb, "To: %r\r\n",
msg->req ? &msg->from.val : &msg->to.val);
odlg->mb->pos = odlg->cpos;
err |= mbuf_write_mem(dlg->mb, mbuf_buf(odlg->mb),
mbuf_get_left(odlg->mb));
odlg->mb->pos = 0;
if (err)
goto out;
dlg->mb->pos = 0;
if (renc.end) {
pl.p = (const char *)mbuf_buf(dlg->mb) + ROUTE_OFFSET;
pl.l = renc.end - ROUTE_OFFSET;
err = sip_addr_decode(&addr, &pl);
dlg->route = addr.uri;
}
else {
pl_set_str(&pl, dlg->uri);
err = uri_decode(&dlg->route, &pl);
}
out:
if (err)
mem_deref(dlg);
else
*dlgp = dlg;
return err;
}
/**
* Initialize a SIP Dialog from an incoming SIP Message
*
* @param dlg SIP Dialog to initialize
* @param msg SIP Message
*
* @return 0 if success, otherwise errorcode
*/
int sip_dialog_create(struct sip_dialog *dlg, const struct sip_msg *msg)
{
char *uri = NULL, *rtag = NULL;
const struct sip_hdr *contact;
struct route_enc renc;
struct sip_addr addr;
struct pl pl;
int err;
if (!dlg || dlg->rtag || !dlg->cpos || !msg)
return EINVAL;
contact = sip_msg_hdr(msg, SIP_HDR_CONTACT);
if (!contact)
return EBADMSG;
if (sip_addr_decode(&addr, &contact->val))
return EBADMSG;
renc.mb = mbuf_alloc(512);
if (!renc.mb)
return ENOMEM;
err = pl_strdup(&uri, &addr.auri);
if (err)
goto out;
err = pl_strdup(&rtag, msg->req ? &msg->from.tag : &msg->to.tag);
if (err)
goto out;
renc.end = 0;
err |= sip_msg_hdr_apply(msg, msg->req, SIP_HDR_RECORD_ROUTE,
record_route_handler, &renc) ? ENOMEM : 0;
err |= mbuf_printf(renc.mb, "To: %r\r\n",
msg->req ? &msg->from.val : &msg->to.val);
dlg->mb->pos = dlg->cpos;
err |= mbuf_write_mem(renc.mb, mbuf_buf(dlg->mb),
mbuf_get_left(dlg->mb));
dlg->mb->pos = 0;
if (err)
goto out;
renc.mb->pos = 0;
if (renc.end) {
pl.p = (const char *)mbuf_buf(renc.mb) + ROUTE_OFFSET;
pl.l = renc.end - ROUTE_OFFSET;
err = sip_addr_decode(&addr, &pl);
if (err)
goto out;
dlg->route = addr.uri;
}
else {
struct uri tmp;
pl_set_str(&pl, uri);
err = uri_decode(&tmp, &pl);
if (err)
goto out;
dlg->route = tmp;
}
mem_deref(dlg->mb);
mem_deref(dlg->uri);
dlg->mb = mem_ref(renc.mb);
dlg->rtag = mem_ref(rtag);
dlg->uri = mem_ref(uri);
dlg->rseq = msg->req ? msg->cseq.num : 0;
dlg->cpos = 0;
out:
mem_deref(renc.mb);
mem_deref(rtag);
mem_deref(uri);
return err;
}
static void notify_handler(struct sip *sip, const struct sip_msg *msg,
void *arg)
{
enum presence_status status = PRESENCE_CLOSED;
struct presence *pres = arg;
const struct sip_hdr *type_hdr, *length_hdr;
struct pl pl;
pres->failc = 0;
type_hdr = sip_msg_hdr(msg, SIP_HDR_CONTENT_TYPE);
if (!type_hdr) {
length_hdr = sip_msg_hdr(msg, SIP_HDR_CONTENT_LENGTH);
if (0 == pl_strcmp(&length_hdr->val, "0")) {
status = PRESENCE_UNKNOWN;
goto done;
}
}
if (!type_hdr ||
0 != pl_strcasecmp(&type_hdr->val, "application/pidf+xml")) {
if (type_hdr)
warning("presence: unsupported content-type: '%r'\n",
&type_hdr->val);
sip_treplyf(NULL, NULL, sip, msg, false,
415, "Unsupported Media Type",
"Accept: application/pidf+xml\r\n"
"Content-Length: 0\r\n"
"\r\n");
return;
}
if (!re_regex((const char *)mbuf_buf(msg->mb), mbuf_get_left(msg->mb),
"<basic>[^<]+</basic>", &pl)) {
if (!pl_strcasecmp(&pl, "open"))
status = PRESENCE_OPEN;
}
if (!re_regex((const char *)mbuf_buf(msg->mb), mbuf_get_left(msg->mb),
"<rpid:away/>")) {
status = PRESENCE_CLOSED;
}
else if (!re_regex((const char *)mbuf_buf(msg->mb),
mbuf_get_left(msg->mb),
"<rpid:busy/>")) {
status = PRESENCE_BUSY;
}
else if (!re_regex((const char *)mbuf_buf(msg->mb),
mbuf_get_left(msg->mb),
"<rpid:on-the-phone/>")) {
status = PRESENCE_BUSY;
}
done:
(void)sip_treply(NULL, sip, msg, 200, "OK");
contact_set_presence(pres->contact, status);
}
