static str *call_request_lookup_tcp(char **out, struct callmaster *m, enum call_opmode opmode) {
struct call *c;
struct call_monologue *monologue;
GQueue s = G_QUEUE_INIT;
str *ret = NULL, callid, fromtag, totag = STR_NULL;
GHashTable *infohash;
str_init(&callid, out[RE_TCP_RL_CALLID]);
infohash = g_hash_table_new(g_str_hash, g_str_equal);
c = call_get_opmode(&callid, m, opmode);
if (!c) {
ilog(LOG_WARNING, "["STR_FORMAT"] Got LOOKUP for unknown call-id", STR_FMT(&callid));
goto out;
}
info_parse(out[RE_TCP_RL_INFO], infohash, m);
streams_parse(out[RE_TCP_RL_STREAMS], m, &s);
str_init(&fromtag, g_hash_table_lookup(infohash, "fromtag"));
if (!fromtag.s) {
ilog(LOG_WARNING, "No from-tag in message");
goto out2;
}
if (opmode == OP_ANSWER) {
str_init(&totag, g_hash_table_lookup(infohash, "totag"));
if (!totag.s) {
ilog(LOG_WARNING, "No to-tag in message");
goto out2;
}
}
monologue = call_get_mono_dialogue(c, &fromtag, &totag);
if (!monologue) {
ilog(LOG_WARNING, "Invalid dialogue association");
goto out2;
}
if (monologue_offer_answer(monologue, &s, NULL))
goto out2;
ret = streams_print(&monologue->active_dialogue->medias, 1, s.length, NULL, SAF_TCP);
out2:
rwlock_unlock_w(&c->master_lock);
streams_free(&s);
redis_update(c, m->conf.redis);
ilog(LOG_INFO, "Returning to SIP proxy: "STR_FORMAT"", STR_FMT0(ret));
obj_put(c);
out:
g_hash_table_destroy(infohash);
return ret;
}
static void control_incoming(int fd, void *p, uintptr_t u) {
int nfd;
struct control_tcp *c = p;
struct control_stream *s;
struct poller_item i;
struct sockaddr_in sin;
socklen_t sinl;
next:
sinl = sizeof(sin);
nfd = accept(fd, (struct sockaddr *) &sin, &sinl);
if (nfd == -1) {
if (errno == EAGAIN || errno == EWOULDBLOCK)
return;
goto next;
}
nonblock(nfd);
ilog(LOG_INFO, "New control connection from " DF, DP(sin));
s = obj_alloc0("control_stream", sizeof(*s), control_stream_free);
s->fd = nfd;
s->control = c;
s->poller = c->poller;
s->inbuf = streambuf_new(c->poller, nfd);
s->outbuf = streambuf_new(c->poller, nfd);
memcpy(&s->inaddr, &sin, sizeof(s->inaddr));
mutex_init(&s->lock);
s->linked = 1;
ZERO(i);
i.fd = nfd;
i.closed = control_stream_closed;
i.readable = control_stream_readable;
i.writeable = control_stream_writeable;
i.timer = control_stream_timer;
i.obj = &s->obj;
if (poller_add_item(c->poller, &i))
goto fail;
mutex_lock(&c->lock);
/* let the list steal our own ref */
c->streams = g_list_prepend(c->streams, s);
mutex_unlock(&c->lock);
goto next;
fail:
obj_put(s);
goto next;
}
static void __agent_deschedule(struct ice_agent *ag) {
int ret;
mutex_lock(&ice_agents_timers_lock);
if (!ag->next_check.tv_sec)
goto nope; /* already descheduled */
ret = g_tree_remove(ice_agents_timers, ag);
ZERO(ag->next_check);
if (ret)
obj_put(ag);
nope:
mutex_unlock(&ice_agents_timers_lock);
}
static void __dtls_timer(void *p) {
struct dtls_cert *c;
long int left;
c = dtls_cert();
left = c->expires - poller_now;
if (left > CERT_EXPIRY_TIME/2)
goto out;
cert_init();
out:
obj_put(c);
}
static void __ice_agent_free(void *p) {
struct ice_agent *ag = p;
if (!ag) {
ilog(LOG_ERR, "ice ag is NULL");
return;
}
__DBG("freeing ice_agent");
__ice_agent_free_components(ag);
mutex_destroy(&ag->lock);
obj_put(ag->call);
}
void timerthread_obj_deschedule(struct timerthread_obj *tt_obj) {
if (!tt_obj)
return;
struct timerthread *tt = tt_obj->tt;
mutex_lock(&tt->lock);
if (!tt_obj->next_check.tv_sec)
goto nope; /* already descheduled */
int ret = g_tree_remove(tt->tree, tt_obj);
ZERO(tt_obj->next_check);
if (ret)
obj_put(tt_obj);
nope:
mutex_unlock(&tt->lock);
}
void calls_status_tcp(struct callmaster *m, struct control_stream *s) {
GQueue q = G_QUEUE_INIT;
struct call *c;
callmaster_get_all_calls(m, &q);
control_stream_printf(s, "proxy %u "UINT64F"/%i/%i\n",
g_queue_get_length(&q),
atomic64_get(&m->stats.bytes), 0, 0);
while (q.head) {
c = g_queue_pop_head(&q);
call_status_iterator(c, s);
obj_put(c);
}
}
/* call must be locked */
void ice_shutdown(struct ice_agent **agp) {
struct ice_agent *ag;
if (!agp) {
ilog(LOG_ERR, "ice agp is NULL");
return ;
}
ag = *agp;
if (!ag)
return;
__agent_deschedule(ag);
*agp = NULL;
obj_put(ag);
}
static str *call_update_lookup_udp(char **out, struct callmaster *m, enum call_opmode opmode) {
struct call *c;
struct call_monologue *monologue;
GQueue q = G_QUEUE_INIT;
struct stream_params sp;
str *ret, callid, viabranch, fromtag, totag = STR_NULL;
str_init(&callid, out[RE_UDP_UL_CALLID]);
str_init(&viabranch, out[RE_UDP_UL_VIABRANCH]);
str_init(&fromtag, out[RE_UDP_UL_FROMTAG]);
if (opmode == OP_ANSWER)
str_init(&totag, out[RE_UDP_UL_TOTAG]);
c = call_get_opmode(&callid, m, opmode);
if (!c) {
ilog(LOG_WARNING, "["STR_FORMAT"] Got UDP LOOKUP for unknown call-id",
STR_FMT(&callid));
return str_sprintf("%s 0 " IPF "\n", out[RE_UDP_COOKIE], IPP(m->conf.ipv4));
}
monologue = call_get_mono_dialogue(c, &fromtag, &totag);
if (addr_parse_udp(&sp, out))
goto fail;
g_queue_push_tail(&q, &sp);
/* XXX return value */
monologue_offer_answer(monologue, &q, NULL);
g_queue_clear(&q);
ret = streams_print(&monologue->medias, sp.index, sp.index, out[RE_UDP_COOKIE], SAF_UDP);
rwlock_unlock_w(&c->master_lock);
redis_update(c, m->conf.redis);
ilog(LOG_INFO, "Returning to SIP proxy: "STR_FORMAT"", STR_FMT(ret));
goto out;
fail:
rwlock_unlock_w(&c->master_lock);
ilog(LOG_WARNING, "Failed to parse a media stream: %s/%s:%s", out[RE_UDP_UL_ADDR4], out[RE_UDP_UL_ADDR6], out[RE_UDP_UL_PORT]);
ret = str_sprintf("%s E8\n", out[RE_UDP_COOKIE]);
out:
obj_put(c);
return ret;
}
struct control_udp *control_udp_new(struct poller *p, endpoint_t *ep, struct callmaster *m) {
struct control_udp *c;
const char *errptr;
int erroff;
if (!p || !m)
return NULL;
c = obj_alloc0("control_udp", sizeof(*c), NULL);
c->callmaster = m;
c->parse_re = pcre_compile(
/* cookie cmd flags callid viabranch:5 */
"^(\\S+)\\s+(?:([ul])(\\S*)\\s+([^;]+)(?:;(\\S+))?\\s+" \
/* addr4 addr6:7 */
"(?:([\\d.]+)|([\\da-f:]+(?::ffff:[\\d.]+)?))" \
/* port fromtag num totag:11 */
"\\s+(\\d+)\\s+(\\S+?);(\\d+)(?:\\s+(\\S+?);\\d+(?:\\s+.*)?)?\r?\n?$" \
/* "d/q" flags callid viabranch fromtag totag:17 */
"|([dq])(\\S*)\\s+([^;\\s]+)(?:;(\\S+))?\\s+(\\S+?)(?:;\\d+)?(?:\\s+(\\S+?)(?:;\\d+)?)?\r?\n?$" \
/* v flags params:20 */
"|(v)(\\S*)(?:\\s+(\\S+))?)",
PCRE_DOLLAR_ENDONLY | PCRE_DOTALL | PCRE_CASELESS, &errptr, &erroff, NULL);
c->parse_ree = pcre_study(c->parse_re, 0, &errptr);
/* cookie cmd flags callid addr port */
c->fallback_re = pcre_compile("^(\\S+)(?:\\s+(\\S)\\S*\\s+\\S+(\\s+\\S+)(\\s+\\S+))?", PCRE_DOLLAR_ENDONLY | PCRE_DOTALL | PCRE_CASELESS, &errptr, &erroff, NULL);
if (!c->parse_re || !c->fallback_re)
goto fail2;
cookie_cache_init(&c->cookie_cache);
if (udp_listener_init(&c->udp_listeners[0], p, ep, control_udp_incoming, &c->obj))
goto fail2;
if (ipv46_any_convert(ep) && udp_listener_init(&c->udp_listeners[1], p, ep, control_udp_incoming, &c->obj))
goto fail2;
return c;
fail2:
obj_put(c);
return NULL;
}
const char *call_query_ng(bencode_item_t *input, struct callmaster *m, bencode_item_t *output) {
str callid, fromtag, totag;
struct call *call;
if (!bencode_dictionary_get_str(input, "call-id", &callid))
return "No call-id in message";
call = call_get_opmode(&callid, m, OP_OTHER);
if (!call)
return "Unknown call-id";
bencode_dictionary_get_str(input, "from-tag", &fromtag);
bencode_dictionary_get_str(input, "to-tag", &totag);
bencode_dictionary_add_string(output, "result", "ok");
ng_call_stats(call, &fromtag, &totag, output, NULL);
rwlock_unlock_w(&call->master_lock);
obj_put(call);
return NULL;
}
int scnprintf(char *buf, uint32_t n, char *fmt, ...) {
va_list ap;
struct char_device *stream;
int ret;
va_start(ap, fmt);
stream = buf_stream_create(buf, n);
if (!stream) {
ret = -1;
goto out;
}
ret = vfprintf(stream, fmt, ap);
obj_put(&stream->obj);
out:
va_end(ap);
return ret;
}
void timerthread_run(void *p) {
struct timerthread *tt = p;
mutex_lock(&tt->lock);
while (!rtpe_shutdown) {
gettimeofday(&rtpe_now, NULL);
/* lock our list and get the first element */
struct timerthread_obj *tt_obj = g_tree_find_first(tt->tree, NULL, NULL);
/* scheduled to run? if not, we just go to sleep, otherwise we remove it from the tree,
* steal the reference and run it */
if (!tt_obj)
goto sleep;
if (timeval_cmp(&rtpe_now, &tt_obj->next_check) < 0)
goto sleep;
// steal reference
g_tree_remove(tt->tree, tt_obj);
ZERO(tt_obj->next_check);
tt_obj->last_run = rtpe_now;
mutex_unlock(&tt->lock);
// run and release
tt->func(tt_obj);
obj_put(tt_obj);
mutex_lock(&tt->lock);
continue;
sleep:;
/* figure out how long we should sleep */
long long sleeptime = tt_obj ? timeval_diff(&tt_obj->next_check, &rtpe_now) : 100000;
sleeptime = MIN(100000, sleeptime); /* 100 ms at the most */
struct timeval tv = rtpe_now;
timeval_add_usec(&tv, sleeptime);
cond_timedwait(&tt->cond, &tt->lock, &tv);
}
mutex_unlock(&tt->lock);
}
int udp_listener_init(struct udp_listener *u, struct poller *p, struct in6_addr ip, u_int16_t port, udp_listener_callback_t func, struct obj *obj) {
struct sockaddr_in6 sin;
struct poller_item i;
struct udp_listener_callback *cb;
cb = obj_alloc("udp_listener_callback", sizeof(*cb), NULL);
cb->func = func;
cb->p = obj_get_o(obj);
u->fd = socket(AF_INET6, SOCK_DGRAM, 0);
if (u->fd == -1)
goto fail;
nonblock(u->fd);
reuseaddr(u->fd);
ipv6only(u->fd, 0);
ZERO(sin);
sin.sin6_family = AF_INET6;
sin.sin6_addr = ip;
sin.sin6_port = htons(port);
if (bind(u->fd, (struct sockaddr *) &sin, sizeof(sin)))
goto fail;
ZERO(i);
i.fd = u->fd;
i.closed = udp_listener_closed;
i.readable = udp_listener_incoming;
i.obj = &cb->obj;
if (poller_add_item(p, &i))
goto fail;
return 0;
fail:
if (u->fd != -1)
close(u->fd);
obj_put_o(obj);
obj_put(cb);
return -1;
}
void calls_status_tcp(struct callmaster *m, struct control_stream *s) {
struct stats st;
GQueue q = G_QUEUE_INIT;
struct call *c;
mutex_lock(&m->statslock);
st = m->stats;
mutex_unlock(&m->statslock);
callmaster_get_all_calls(m, &q);
control_stream_printf(s, "proxy %u "UINT64F"/"UINT64F"/"UINT64F"\n",
g_queue_get_length(&q),
st.bytes, st.bytes - st.errors,
st.bytes * 2 - st.errors);
while (q.head) {
c = g_queue_pop_head(&q);
call_status_iterator(c, s);
obj_put(c);
}
}
str *call_query_udp(char **out, struct callmaster *m) {
struct call *c;
str *ret, callid, fromtag, totag;
struct call_stats stats;
__C_DBG("got query for callid '%s'", out[RE_UDP_DQ_CALLID]);
str_init(&callid, out[RE_UDP_DQ_CALLID]);
str_init(&fromtag, out[RE_UDP_DQ_FROMTAG]);
str_init(&totag, out[RE_UDP_DQ_TOTAG]);
c = call_get_opmode(&callid, m, OP_OTHER);
if (!c) {
ilog(LOG_INFO, "["STR_FORMAT"] Call-ID to query not found", STR_FMT(&callid));
goto err;
}
ng_call_stats(c, &fromtag, &totag, NULL, &stats);
rwlock_unlock_w(&c->master_lock);
ret = str_sprintf("%s %lld "UINT64F" "UINT64F" "UINT64F" "UINT64F"\n", out[RE_UDP_COOKIE],
(long long int) m->conf.silent_timeout - (poller_now - stats.last_packet),
stats.totals[0].packets, stats.totals[1].packets,
stats.totals[2].packets, stats.totals[3].packets);
goto out;
err:
if (c)
rwlock_unlock_w(&c->master_lock);
ret = str_sprintf("%s E8\n", out[RE_UDP_COOKIE]);
goto out;
out:
if (c)
obj_put(c);
return ret;
}
static str *call_update_lookup_udp(char **out, struct callmaster *m, enum call_opmode opmode, const char* addr,
const struct sockaddr_in6 *sin)
{
struct call *c;
struct call_monologue *monologue;
GQueue q = G_QUEUE_INIT;
struct stream_params sp;
str *ret, callid, viabranch, fromtag, totag = STR_NULL;
int i;
str_init(&callid, out[RE_UDP_UL_CALLID]);
str_init(&viabranch, out[RE_UDP_UL_VIABRANCH]);
str_init(&fromtag, out[RE_UDP_UL_FROMTAG]);
str_init(&totag, out[RE_UDP_UL_TOTAG]);
if (opmode == OP_ANSWER)
str_swap(&fromtag, &totag);
c = call_get_opmode(&callid, m, opmode);
if (!c) {
ilog(LOG_WARNING, "["STR_FORMAT"] Got UDP LOOKUP for unknown call-id",
STR_FMT(&callid));
return str_sprintf("%s 0 0.0.0.0\n", out[RE_UDP_COOKIE]);
}
if (!c->created_from && addr) {
c->created_from = call_strdup(c, addr);
c->created_from_addr = *sin;
}
monologue = call_get_mono_dialogue(c, &fromtag, &totag, NULL);
if (!monologue)
goto ml_fail;
if (opmode == OP_OFFER) {
monologue->tagtype = FROM_TAG;
} else {
monologue->tagtype = TO_TAG;
}
if (addr_parse_udp(&sp, out))
goto addr_fail;
g_queue_push_tail(&q, &sp);
i = monologue_offer_answer(monologue, &q, NULL);
g_queue_clear(&q);
if (i)
goto unlock_fail;
ret = streams_print(&monologue->active_dialogue->medias,
sp.index, sp.index, out[RE_UDP_COOKIE], SAF_UDP);
rwlock_unlock_w(&c->master_lock);
if (m->conf.redis_write) {
redis_update(c, m->conf.redis_write, ANY_REDIS_ROLE);
} else if (m->conf.redis) {
redis_update(c, m->conf.redis, MASTER_REDIS_ROLE);
}
gettimeofday(&(monologue->started), NULL);
ilog(LOG_INFO, "Returning to SIP proxy: "STR_FORMAT"", STR_FMT(ret));
goto out;
ml_fail:
ilog(LOG_ERR, "Invalid dialogue association");
goto unlock_fail;
addr_fail:
ilog(LOG_ERR, "Failed to parse a media stream: %s/%s:%s",
out[RE_UDP_UL_ADDR4], out[RE_UDP_UL_ADDR6], out[RE_UDP_UL_PORT]);
goto unlock_fail;
unlock_fail:
rwlock_unlock_w(&c->master_lock);
ret = str_sprintf("%s E8\n", out[RE_UDP_COOKIE]);
out:
obj_put(c);
return ret;
}
static int cert_init() {
X509 *x509 = NULL;
EVP_PKEY *pkey = NULL;
BIGNUM *exponent = NULL, *serial_number = NULL;
RSA *rsa = NULL;
ASN1_INTEGER *asn1_serial_number;
X509_NAME *name;
struct dtls_cert *new_cert;
ilog(LOG_INFO, "Generating new DTLS certificate");
/* objects */
pkey = EVP_PKEY_new();
exponent = BN_new();
rsa = RSA_new();
serial_number = BN_new();
name = X509_NAME_new();
x509 = X509_new();
if (!exponent || !pkey || !rsa || !serial_number || !name || !x509)
goto err;
/* key */
if (!BN_set_word(exponent, 0x10001))
goto err;
if (!RSA_generate_key_ex(rsa, 1024, exponent, NULL))
goto err;
if (!EVP_PKEY_assign_RSA(pkey, rsa))
goto err;
/* x509 cert */
if (!X509_set_pubkey(x509, pkey))
goto err;
/* serial */
if (!BN_pseudo_rand(serial_number, 64, 0, 0))
goto err;
asn1_serial_number = X509_get_serialNumber(x509);
if (!asn1_serial_number)
goto err;
if (!BN_to_ASN1_INTEGER(serial_number, asn1_serial_number))
goto err;
/* version 1 */
if (!X509_set_version(x509, 0L))
goto err;
/* common name */
if (!X509_NAME_add_entry_by_NID(name, NID_commonName, MBSTRING_UTF8,
(unsigned char *) "rtpengine", -1, -1, 0))
goto err;
if (!X509_set_subject_name(x509, name))
goto err;
if (!X509_set_issuer_name(x509, name))
goto err;
/* cert lifetime */
if (!X509_gmtime_adj(X509_get_notBefore(x509), -60*60*24))
goto err;
if (!X509_gmtime_adj(X509_get_notAfter(x509), CERT_EXPIRY_TIME))
goto err;
/* sign it */
if (!X509_sign(x509, pkey, EVP_sha1()))
goto err;
/* digest */
new_cert = obj_alloc0("dtls_cert", sizeof(*new_cert), cert_free);
new_cert->fingerprint.hash_func = &hash_funcs[0];
dtls_fingerprint_hash(&new_cert->fingerprint, x509);
new_cert->x509 = x509;
new_cert->pkey = pkey;
new_cert->expires = time(NULL) + CERT_EXPIRY_TIME;
dump_cert(new_cert);
/* swap out certs */
rwlock_lock_w(&__dtls_cert_lock);
if (__dtls_cert)
obj_put(__dtls_cert);
__dtls_cert = new_cert;
rwlock_unlock_w(&__dtls_cert_lock);
/* cleanup */
BN_free(exponent);
BN_free(serial_number);
X509_NAME_free(name);
return 0;
err:
ilog(LOG_ERROR, "Failed to generate DTLS certificate");
if (pkey)
EVP_PKEY_free(pkey);
if (exponent)
BN_free(exponent);
if (rsa)
RSA_free(rsa);
if (x509)
X509_free(x509);
if (serial_number)
BN_free(serial_number);
return -1;
}
struct control_tcp *control_tcp_new(struct poller *p, u_int32_t ip, u_int16_t port, struct callmaster *m) {
int fd;
struct control_tcp *c;
struct poller_item i;
struct sockaddr_in sin;
const char *errptr;
int erroff;
if (!p)
return NULL;
if (!m)
return NULL;
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1)
return NULL;
nonblock(fd);
reuseaddr(fd);
ZERO(sin);
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = ip;
sin.sin_port = htons(port);
if (bind(fd, (struct sockaddr *) &sin, sizeof(sin)))
goto fail;
if (listen(fd, 5))
goto fail;
c = obj_alloc0("control", sizeof(*c), NULL);
c->parse_re = pcre_compile(
/* reqtype callid streams ip fromdom fromtype todom totype agent info |reqtype callid info | reqtype */
"^(?:(request|lookup)\\s+(\\S+)\\s+(\\S+)\\s+(\\S+)\\s+(\\S+)\\s+(\\S+)\\s+(\\S+)\\s+(\\S+)\\s+(\\S+)\\s+info=(\\S*)|(delete)\\s+(\\S+)\\s+info=(\\S*)|(build|version|controls|quit|exit|status))$",
PCRE_DOLLAR_ENDONLY | PCRE_DOTALL, &errptr, &erroff, NULL);
c->parse_ree = pcre_study(c->parse_re, 0, &errptr);
c->fd = fd;
c->poller = p;
c->callmaster = m;
mutex_init(&c->lock);
ZERO(i);
i.fd = fd;
i.closed = control_closed;
i.readable = control_incoming;
i.obj = &c->obj;
if (poller_add_item(p, &i))
goto fail2;
obj_put(c);
return c;
fail2:
obj_put(c);
fail:
close(fd);
return NULL;
}
static void call_release_ref(void *p) {
struct call *c = p;
obj_put(c);
}
static const char *call_offer_answer_ng(bencode_item_t *input, struct callmaster *m,
bencode_item_t *output, enum call_opmode opmode)
{
str sdp, fromtag, totag = STR_NULL, callid;
char *errstr;
GQueue parsed = G_QUEUE_INIT;
GQueue streams = G_QUEUE_INIT;
struct call *call;
struct call_monologue *monologue;
int ret;
struct sdp_ng_flags flags;
struct sdp_chopper *chopper;
if (!bencode_dictionary_get_str(input, "sdp", &sdp))
return "No SDP body in message";
if (!bencode_dictionary_get_str(input, "call-id", &callid))
return "No call-id in message";
if (!bencode_dictionary_get_str(input, "from-tag", &fromtag))
return "No from-tag in message";
if (opmode == OP_ANSWER) {
if (!bencode_dictionary_get_str(input, "to-tag", &totag))
return "No to-tag in message";
}
//bencode_dictionary_get_str(input, "via-branch", &viabranch);
if (sdp_parse(&sdp, &parsed))
return "Failed to parse SDP";
call_ng_process_flags(&flags, input);
flags.opmode = opmode;
errstr = "Incomplete SDP specification";
if (sdp_streams(&parsed, &streams, &flags))
goto out;
call = call_get_opmode(&callid, m, opmode);
errstr = "Unknown call-id";
if (!call)
goto out;
/* At least the random ICE strings are contained within the call struct, so we
* need to hold a ref until we're done sending the reply */
call_bencode_hold_ref(call, output);
monologue = call_get_mono_dialogue(call, &fromtag, &totag);
errstr = "Invalid dialogue association";
if (!monologue) {
rwlock_unlock_w(&call->master_lock);
obj_put(call);
goto out;
}
chopper = sdp_chopper_new(&sdp);
bencode_buffer_destroy_add(output->buffer, (free_func_t) sdp_chopper_destroy, chopper);
ret = monologue_offer_answer(monologue, &streams, &flags);
if (!ret)
ret = sdp_replace(chopper, &parsed, monologue->active_dialogue, &flags);
rwlock_unlock_w(&call->master_lock);
redis_update(call, m->conf.redis);
obj_put(call);
errstr = "Error rewriting SDP";
if (ret)
goto out;
bencode_dictionary_add_iovec(output, "sdp", &g_array_index(chopper->iov, struct iovec, 0),
chopper->iov_num, chopper->str_len);
bencode_dictionary_add_string(output, "result", "ok");
errstr = NULL;
out:
sdp_free(&parsed);
streams_free(&streams);
return errstr;
}
int poller_poll(struct poller *p, int timeout) {
int ret, i;
struct poller_item_int *it;
struct epoll_event evs[128], *ev, e;
if (!p)
return -1;
mutex_lock(&p->lock);
ret = -1;
if (!p->items || !p->items_size)
goto out;
mutex_unlock(&p->lock);
errno = 0;
ret = epoll_wait(p->fd, evs, sizeof(evs) / sizeof(*evs), timeout);
mutex_lock(&p->lock);
if (errno == EINTR)
ret = 0;
if (ret == 0)
ret = 0;
if (ret <= 0)
goto out;
gettimeofday(&g_now, NULL);
for (i = 0; i < ret; i++) {
ev = &evs[i];
if (ev->data.fd < 0)
continue;
it = (ev->data.fd < p->items_size) ? p->items[ev->data.fd] : NULL;
if (!it)
continue;
obj_hold(it);
mutex_unlock(&p->lock);
if (it->error) {
it->item.closed(it->item.fd, it->item.obj, it->item.uintp);
goto next;
}
if ((ev->events & (POLLERR | POLLHUP)))
it->item.closed(it->item.fd, it->item.obj, it->item.uintp);
else if ((ev->events & POLLOUT)) {
mutex_lock(&p->lock);
it->blocked = 0;
ZERO(e);
e.events = epoll_events(NULL, it);
e.data.fd = it->item.fd;
if (epoll_ctl(p->fd, EPOLL_CTL_MOD, it->item.fd, &e))
abort();
mutex_unlock(&p->lock);
it->item.writeable(it->item.fd, it->item.obj, it->item.uintp);
}
else if ((ev->events & POLLIN))
it->item.readable(it->item.fd, it->item.obj, it->item.uintp);
else if (!ev->events)
goto next;
else
abort();
next:
obj_put(it);
mutex_lock(&p->lock);
}
out:
mutex_unlock(&p->lock);
return ret;
}
