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 sipsess_close_handler(int err, const struct sip_msg *msg,
void *arg)
{
struct call *call = arg;
char reason[128] = "";
MAGIC_CHECK(call);
if (err) {
info("%s: session closed: %m\n", call->peer_uri, err);
if (call->not) {
(void)call_notify_sipfrag(call, 500, "%m", err);
}
}
else if (msg) {
call->scode = msg->scode;
(void)re_snprintf(reason, sizeof(reason), "%u %r",
msg->scode, &msg->reason);
info("%s: session closed: %u %r\n",
call->peer_uri, msg->scode, &msg->reason);
if (call->not) {
(void)call_notify_sipfrag(call, msg->scode,
"%r", &msg->reason);
}
}
else {
info("%s: session closed\n", call->peer_uri);
}
call_stream_stop(call);
call_event_handler(call, CALL_EVENT_CLOSED, reason);
}
static void sipsess_estab_handler(const struct sip_msg *msg, void *arg)
{
struct call *call = arg;
MAGIC_CHECK(call);
(void)msg;
if (call->state == STATE_ESTABLISHED)
return;
set_state(call, STATE_ESTABLISHED);
call_event_handler(call, CALL_EVENT_ESTABLISHED, call->peer_uri);
call_stream_start(call, true);
/* the transferor will hangup this call */
if (call->not) {
(void)call_notify_sipfrag(call, 200, "OK");
}
}
static void call_event_handler(struct call *call, enum call_event ev,
const char *str, void *arg)
{
struct ua *ua = arg;
const char *peeruri;
struct call *call2 = NULL;
int err;
MAGIC_CHECK(ua);
peeruri = call_peeruri(call);
/* stop any ringtones */
ua->play = mem_deref(ua->play);
switch (ev) {
case CALL_EVENT_INCOMING:
if (contact_block_access(peeruri)) {
info("ua: blocked access: \"%s\"\n", peeruri);
ua_event(ua, UA_EVENT_CALL_CLOSED, call, str);
mem_deref(call);
break;
}
switch (ua->acc->answermode) {
case ANSWERMODE_EARLY:
(void)call_progress(call);
break;
case ANSWERMODE_AUTO:
(void)call_answer(call, 200);
break;
case ANSWERMODE_MANUAL:
default:
if (list_count(&ua->calls) > 1) {
(void)play_file(&ua->play,
"callwaiting.wav", 3);
}
else {
/* Alert user */
(void)play_file(&ua->play, "ring.wav", -1);
}
ua_event(ua, UA_EVENT_CALL_INCOMING, call, peeruri);
break;
}
break;
case CALL_EVENT_RINGING:
(void)play_file(&ua->play, "ringback.wav", -1);
ua_event(ua, UA_EVENT_CALL_RINGING, call, peeruri);
break;
case CALL_EVENT_PROGRESS:
ua_printf(ua, "Call in-progress: %s\n", peeruri);
ua_event(ua, UA_EVENT_CALL_PROGRESS, call, peeruri);
break;
case CALL_EVENT_ESTABLISHED:
ua_printf(ua, "Call established: %s\n", peeruri);
ua_event(ua, UA_EVENT_CALL_ESTABLISHED, call, peeruri);
break;
case CALL_EVENT_CLOSED:
if (call_scode(call)) {
const char *tone;
tone = translate_errorcode(call_scode(call));
if (tone)
(void)play_file(&ua->play, tone, 1);
}
ua_event(ua, UA_EVENT_CALL_CLOSED, call, str);
mem_deref(call);
break;
case CALL_EVENT_TRANSFER:
/*
* Create a new call to transfer target.
*
* NOTE: we will automatically connect a new call to the
* transfer target
*/
ua_printf(ua, "transferring call to %s\n", str);
err = ua_call_alloc(&call2, ua, VIDMODE_ON, NULL, call,
call_localuri(call));
if (!err) {
struct pl pl;
pl_set_str(&pl, str);
err = call_connect(call2, &pl);
if (err) {
warning("ua: transfer: connect error: %m\n",
err);
}
}
if (err) {
(void)call_notify_sipfrag(call, 500, "Call Error");
mem_deref(call2);
}
break;
case CALL_EVENT_TRANSFER_FAILED:
ua_event(ua, UA_EVENT_CALL_TRANSFER_FAILED, call, str);
break;
}
}