int call_connect(struct call *call, const struct pl *paddr)
{
struct sip_addr addr;
int err;
if (!call || !paddr)
return EINVAL;
info("call: connecting to '%r'..\n", paddr);
call->outgoing = true;
/* if the peer-address is a full SIP address then we need
* to parse it and extract the SIP uri part.
*/
if (0 == sip_addr_decode(&addr, paddr) && addr.dname.p) {
err = pl_strdup(&call->peer_uri, &addr.auri);
}
else {
err = pl_strdup(&call->peer_uri, paddr);
}
if (err)
return err;
set_state(call, STATE_OUTGOING);
/* If we are using asyncronous medianat like STUN/TURN, then
* wait until completed before sending the INVITE */
if (!call->acc->mnat)
err = send_invite(call);
return err;
}
static bool contact_handler(const struct sip_hdr *hdr,
const struct sip_msg *msg, void *arg)
{
struct sipreg *reg = arg;
struct sip_addr c;
struct pl pval;
char uri[256];
if (sip_addr_decode(&c, &hdr->val))
return false;
if (re_snprintf(uri, sizeof(uri), "sip:%s@%J%s", reg->cuser,
®->laddr, sip_transp_param(reg->tp)) < 0)
return false;
if (pl_strcmp(&c.auri, uri))
return false;
if (!sip_param_decode(&c.params, "expires", &pval)) {
reg->wait = pl_u32(&pval);
}
else if (pl_isset(&msg->expires))
reg->wait = pl_u32(&msg->expires);
else
reg->wait = DEFAULT_EXPIRES;
return true;
}
/**
* Add a contact
*
* @param contactp Pointer to allocated contact (optional)
* @param addr Contact in SIP address format
*
* @return 0 if success, otherwise errorcode
*/
int contact_add(struct contact **contactp, const struct pl *addr)
{
struct contact *c;
struct pl pl;
int err;
c = mem_zalloc(sizeof(*c), destructor);
if (!c)
return ENOMEM;
err = pl_strdup(&c->buf, addr);
if (err)
goto out;
pl_set_str(&pl, c->buf);
err = sip_addr_decode(&c->addr, &pl);
if (err) {
warning("contact: decode error '%r'\n", addr);
goto out;
}
c->status = PRESENCE_UNKNOWN;
list_append(&cl, &c->le, c);
out:
if (err)
mem_deref(c);
else if (contactp)
*contactp = c;
return err;
}
/**
* Send SIP instant MESSAGE to a peer
*
* @param ua User-Agent object
* @param peer Peer SIP Address
* @param msg Message to send
*
* @return 0 if success, otherwise errorcode
*/
int message_send(struct ua *ua, const char *peer, const char *msg)
{
struct sip_addr addr;
struct pl pl;
char *uri = NULL;
int err = 0;
if (!ua || !peer || !msg)
return EINVAL;
pl_set_str(&pl, peer);
err = sip_addr_decode(&addr, &pl);
if (err)
return err;
err = pl_strdup(&uri, &addr.auri);
if (err)
return err;
err = sip_req_send(ua, "MESSAGE", uri, resp_handler, ua,
"Accept: text/plain\r\n"
"Content-Type: text/plain\r\n"
"Content-Length: %zu\r\n"
"\r\n%s",
str_len(msg), msg);
mem_deref(uri);
return err;
}
/**
* Add a contact
*
* @param contacts Contacts container
* @param contactp Pointer to allocated contact (optional)
* @param addr Contact in SIP address format
*
* @return 0 if success, otherwise errorcode
*/
int contact_add(struct contacts *contacts,
struct contact **contactp, const struct pl *addr)
{
struct contact *c;
struct pl pl;
int err;
if (!contacts)
return EINVAL;
c = mem_zalloc(sizeof(*c), destructor);
if (!c)
return ENOMEM;
err = pl_strdup(&c->buf, addr);
if (err)
goto out;
pl_set_str(&pl, c->buf);
err = sip_addr_decode(&c->addr, &pl);
if (err) {
warning("contact: decode error '%r'\n", addr);
goto out;
}
if (0 == msg_param_decode(&c->addr.params, "access", &pl)) {
if (0 == pl_strcasecmp(&pl, "block")) {
c->access = ACCESS_BLOCK;
}
else if (0 == pl_strcasecmp(&pl, "allow")) {
c->access = ACCESS_ALLOW;
}
else {
warning("contact: unknown 'access=%r' for '%r'\n",
&pl, addr);
err = EINVAL;
goto out;
}
}
else
c->access = ACCESS_UNKNOWN;
c->status = PRESENCE_UNKNOWN;
list_append(&contacts->cl, &c->le, c);
hash_append(contacts->cht, hash_joaat_pl(&c->addr.auri), &c->he, c);
out:
if (err)
mem_deref(c);
else if (contactp)
*contactp = c;
return err;
}
/**
* 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 inline int hdr_add(struct sip_msg *msg, const struct pl *name,
enum sip_hdrid id, const char *p, ssize_t l,
bool atomic, bool line)
{
struct sip_hdr *hdr;
int err = 0;
hdr = mem_zalloc(sizeof(*hdr), hdr_destructor);
if (!hdr)
return ENOMEM;
hdr->name = *name;
hdr->val.p = p;
hdr->val.l = MAX(l, 0);
hdr->id = id;
switch (id) {
case SIP_HDR_VIA:
case SIP_HDR_ROUTE:
if (!atomic)
break;
hash_append(msg->hdrht, id, &hdr->he, mem_ref(hdr));
list_append(&msg->hdrl, &hdr->le, mem_ref(hdr));
break;
default:
if (atomic)
hash_append(msg->hdrht, id, &hdr->he, mem_ref(hdr));
if (line)
list_append(&msg->hdrl, &hdr->le, mem_ref(hdr));
break;
}
/* parse common headers */
switch (id) {
case SIP_HDR_VIA:
if (!atomic || pl_isset(&msg->via.sentby))
break;
err = sip_via_decode(&msg->via, &hdr->val);
break;
case SIP_HDR_TO:
err = sip_addr_decode((struct sip_addr *)&msg->to, &hdr->val);
if (err)
break;
(void)msg_param_decode(&msg->to.params, "tag", &msg->to.tag);
msg->to.val = hdr->val;
break;
case SIP_HDR_FROM:
err = sip_addr_decode((struct sip_addr *)&msg->from,
&hdr->val);
if (err)
break;
(void)msg_param_decode(&msg->from.params, "tag",
&msg->from.tag);
msg->from.val = hdr->val;
break;
case SIP_HDR_CALL_ID:
msg->callid = hdr->val;
break;
case SIP_HDR_CSEQ:
err = sip_cseq_decode(&msg->cseq, &hdr->val);
break;
case SIP_HDR_MAX_FORWARDS:
msg->maxfwd = hdr->val;
break;
case SIP_HDR_CONTENT_TYPE:
err = msg_ctype_decode(&msg->ctyp, &hdr->val);
break;
case SIP_HDR_CONTENT_LENGTH:
msg->clen = hdr->val;
break;
case SIP_HDR_EXPIRES:
msg->expires = hdr->val;
break;
default:
/* re_printf("%r = %u\n", &hdr->name, id); */
break;
}
mem_deref(hdr);
return err;
}
/**
* Allocate a SIP Dialog
*
* @param dlgp Pointer to allocated SIP Dialog
* @param uri Target URI
* @param to_uri To URI
* @param from_name From displayname (optional)
* @param from_uri From URI
* @param routev Route vector
* @param routec Route count
*
* @return 0 if success, otherwise errorcode
*/
int sip_dialog_alloc(struct sip_dialog **dlgp,
const char *uri, const char *to_uri,
const char *from_name, const char *from_uri,
const char *routev[], uint32_t routec)
{
const uint64_t ltag = rand_u64();
struct sip_dialog *dlg;
struct sip_addr addr;
size_t rend = 0;
struct pl pl;
uint32_t i;
int err;
if (!dlgp || !uri || !to_uri || !from_uri)
return EINVAL;
dlg = mem_zalloc(sizeof(*dlg), destructor);
if (!dlg)
return ENOMEM;
dlg->lseq = rand_u16();
err = str_dup(&dlg->uri, uri);
if (err)
goto out;
err = x64_strdup(&dlg->callid, rand_u64());
if (err)
goto out;
err = x64_strdup(&dlg->ltag, ltag);
if (err)
goto out;
dlg->mb = mbuf_alloc(512);
if (!dlg->mb) {
err = ENOMEM;
goto out;
}
for (i=0; i<routec; i++) {
err |= mbuf_printf(dlg->mb, "Route: <%s;lr>\r\n", routev[i]);
if (i == 0)
rend = dlg->mb->pos - 2;
}
err |= mbuf_printf(dlg->mb, "To: <%s>\r\n", to_uri);
dlg->cpos = dlg->mb->pos;
err |= mbuf_printf(dlg->mb, "From: %s%s%s<%s>;tag=%016llx\r\n",
from_name ? "\"" : "", from_name,
from_name ? "\" " : "",
from_uri, ltag);
if (err)
goto out;
dlg->mb->pos = 0;
if (rend) {
pl.p = (const char *)mbuf_buf(dlg->mb) + ROUTE_OFFSET;
pl.l = rend - 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;
}
/**
* 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;
}
