static void
handle_nomem(struct cfg *cf, struct rtpp_command *cmd,
int ecode, struct ul_opts *ulop, int *fds,
struct rtpp_session *spa, struct rtpp_session *spb)
{
int i;
rtpp_log_write(RTPP_LOG_ERR, cf->stable->glog, "can't allocate memory");
rtpp_command_ul_opts_free(ulop);
if (spa != NULL) {
if (spa->call_id != NULL)
free(spa->call_id);
if (spa->tag != NULL)
free(spa->tag);
if (spa->tag_nomedianum != NULL)
free(spa->tag_nomedianum);
free(spa);
}
if (spb != NULL)
free(spb);
for (i = 0; i < 2; i++)
if (fds[i] != -1)
close(fds[i]);
reply_error(cf, cmd, ecode);
}
static void
handle_nomem(struct cfg *cf, struct rtpp_command *cmd,
int ecode, struct ul_opts *ulop, struct rtpp_socket **fds,
struct rtpp_session *spa)
{
int i;
RTPP_LOG(cf->stable->glog, RTPP_LOG_ERR, "can't allocate memory");
rtpp_command_ul_opts_free(ulop);
if (spa != NULL) {
CALL_METHOD(spa->rcnt, decref);
}
if (fds != NULL) {
for (i = 0; i < 2; i++)
if (fds[i] != NULL)
CALL_METHOD(fds[i]->rcnt, decref);
}
reply_error(cmd, ecode);
}
int
rtpp_command_ul_handle(struct cfg *cf, struct rtpp_command *cmd,
struct ul_opts *ulop, int sidx)
{
int pidx, lport, sessions_active;
struct rtpp_socket *fds[2];
const char *actor;
struct rtpp_session *spa, *spb;
pidx = 1;
lport = 0;
spa = spb = NULL;
fds[0] = fds[1] = NULL;
if (sidx != -1) {
RTPP_DBG_ASSERT(cmd->cca.op == UPDATE || cmd->cca.op == LOOKUP);
spa = cmd->sp;
if (spa->rtp->stream[sidx]->fd == NULL || ulop->new_port != 0) {
if (ulop->local_addr != NULL) {
spa->rtp->stream[sidx]->laddr = ulop->local_addr;
}
if (rtpp_create_listener(cf, spa->rtp->stream[sidx]->laddr, &lport, fds) == -1) {
RTPP_LOG(spa->log, RTPP_LOG_ERR, "can't create listener");
reply_error(cmd, ECODE_LSTFAIL_1);
goto err_undo_0;
}
if (spa->rtp->stream[sidx]->fd != NULL && ulop->new_port != 0) {
RTPP_LOG(spa->log, RTPP_LOG_INFO,
"new port requested, releasing %d/%d, replacing with %d/%d",
spa->rtp->stream[sidx]->port, spa->rtcp->stream[sidx]->port, lport, lport + 1);
CALL_METHOD(cf->stable->sessinfo, update, spa, sidx, fds);
} else {
RTPP_DBG_ASSERT(spa->rtp->stream[sidx]->fd == NULL);
spa->rtp->stream[sidx]->fd = fds[0];
RTPP_DBG_ASSERT(spa->rtcp->stream[sidx]->fd == NULL);
spa->rtcp->stream[sidx]->fd = fds[1];
CALL_METHOD(cf->stable->sessinfo, append, spa, sidx);
}
spa->rtp->stream[sidx]->port = lport;
spa->rtcp->stream[sidx]->port = lport + 1;
if (spa->complete == 0) {
cmd->csp->nsess_complete.cnt++;
}
spa->complete = 1;
}
if (ulop->weak)
spa->rtp->stream[sidx]->weak = 1;
else if (cmd->cca.op == UPDATE)
spa->strong = 1;
lport = spa->rtp->stream[sidx]->port;
ulop->lia[0] = spa->rtp->stream[sidx]->laddr;
pidx = (sidx == 0) ? 1 : 0;
if (cmd->cca.op == UPDATE) {
CALL_METHOD(spa->rtp->stream[0]->ttl, reset_with,
cf->stable->max_setup_ttl);
CALL_METHOD(spa->rtp->stream[1]->ttl, reset_with,
cf->stable->max_setup_ttl);
RTPP_LOG(spa->log, RTPP_LOG_INFO,
"adding %s flag to existing session, new=%d/%d/%d",
ulop->weak ? ( sidx ? "weak[1]" : "weak[0]" ) : "strong",
spa->strong, spa->rtp->stream[0]->weak, spa->rtp->stream[1]->weak);
} else {
CALL_METHOD(spa->rtp->stream[0]->ttl, reset_with, cf->stable->max_ttl);
CALL_METHOD(spa->rtp->stream[1]->ttl, reset_with, cf->stable->max_ttl);
}
RTPP_LOG(spa->log, RTPP_LOG_INFO,
"lookup on ports %d/%d, session timer restarted", spa->rtp->stream[0]->port,
spa->rtp->stream[1]->port);
} else {
struct rtpp_hash_table_entry *hte;
RTPP_DBG_ASSERT(cmd->cca.op == UPDATE);
RTPP_LOG(cf->stable->glog, RTPP_LOG_INFO,
"new session %s, tag %s requested, type %s",
cmd->cca.call_id, cmd->cca.from_tag, ulop->weak ? "weak" : "strong");
if (cf->stable->slowshutdown != 0) {
RTPP_LOG(cf->stable->glog, RTPP_LOG_INFO,
"proxy is in the deorbiting-burn mode, new session rejected");
reply_error(cmd, ECODE_SLOWSHTDN);
goto err_undo_0;
}
if (ulop->local_addr != NULL) {
ulop->lia[0] = ulop->lia[1] = ulop->local_addr;
}
if (rtpp_create_listener(cf, ulop->lia[0], &lport, fds) == -1) {
RTPP_LOG(cf->stable->glog, RTPP_LOG_ERR, "can't create listener");
reply_error(cmd, ECODE_LSTFAIL_2);
goto err_undo_0;
}
/*
* Session creation. If creation is requested with weak flag,
* set weak[0].
*/
spa = rtpp_session_ctor(cf->stable, &cmd->cca, cmd->dtime, ulop->lia,
ulop->weak, lport, fds);
if (spa == NULL) {
handle_nomem(cf, cmd, ECODE_NOMEM_4, ulop,
fds, NULL);
return (-1);
}
hte = CALL_METHOD(cf->stable->sessions_ht, append_refcnt, spa->call_id,
spa->rcnt);
if (hte == NULL) {
handle_nomem(cf, cmd, ECODE_NOMEM_5, ulop, NULL, spa);
return (-1);
}
if (CALL_METHOD(cf->stable->sessions_wrt, reg, spa->rcnt, spa->seuid) != 0) {
CALL_METHOD(cf->stable->sessions_ht, remove, spa->call_id, hte);
handle_nomem(cf, cmd, ECODE_NOMEM_8, ulop, NULL, spa);
return (-1);
}
cmd->csp->nsess_created.cnt++;
/*
* Each session can consume up to 5 open file descriptors (2 RTP,
* 2 RTCP and 1 logging) so that warn user when he is likely to
* exceed 80% mark on hard limit.
*/
sessions_active = CALL_METHOD(cf->stable->sessions_wrt, get_length);
if (sessions_active > (rtpp_rlim_max(cf) * 80 / (100 * 5)) &&
cf->nofile_limit_warned == 0) {
cf->nofile_limit_warned = 1;
RTPP_LOG(cf->stable->glog, RTPP_LOG_WARN, "passed 80%% "
"threshold on the open file descriptors limit (%d), "
"consider increasing the limit using -L command line "
"option", (int)rtpp_rlim_max(cf));
}
RTPP_LOG(spa->log, RTPP_LOG_INFO, "new session on a port %d created, "
"tag %s", lport, cmd->cca.from_tag);
if (cf->stable->record_all != 0) {
handle_copy(cf, spa, 0, NULL, 0);
handle_copy(cf, spa, 1, NULL, 0);
}
/* Save ref, it will be decref'd by the command disposal code */
RTPP_DBG_ASSERT(cmd->sp == NULL);
cmd->sp = spa;
}
if (cmd->cca.op == UPDATE) {
if (!CALL_METHOD(cf->stable->rtpp_tnset_cf, isenabled) && ulop->notify_socket != NULL)
RTPP_LOG(spa->log, RTPP_LOG_ERR, "must permit notification socket with -n");
if (spa->timeout_data.notify_tag != NULL) {
free(spa->timeout_data.notify_tag);
spa->timeout_data.notify_tag = NULL;
}
if (ulop->notify_socket != NULL) {
struct rtpp_tnotify_target *rttp;
rttp = CALL_METHOD(cf->stable->rtpp_tnset_cf, lookup, ulop->notify_socket,
(cmd->rlen > 0) ? sstosa(&cmd->raddr) : NULL, (cmd->rlen > 0) ? cmd->laddr : NULL);
if (rttp == NULL) {
RTPP_LOG(spa->log, RTPP_LOG_ERR, "invalid socket name %s", ulop->notify_socket);
ulop->notify_socket = NULL;
} else {
RTPP_LOG(spa->log, RTPP_LOG_INFO, "setting timeout handler");
spa->timeout_data.notify_target = rttp;
spa->timeout_data.notify_tag = strdup(ulop->notify_tag);
}
} else if (spa->timeout_data.notify_target != NULL) {
spa->timeout_data.notify_target = NULL;
RTPP_LOG(spa->log, RTPP_LOG_INFO, "disabling timeout handler");
}
}
if (ulop->ia[0] != NULL && ulop->ia[1] != NULL) {
CALL_METHOD(spa->rtp->stream[pidx], prefill_addr, &(ulop->ia[0]),
cmd->dtime);
CALL_METHOD(spa->rtcp->stream[pidx], prefill_addr, &(ulop->ia[1]),
cmd->dtime);
}
spa->rtp->stream[pidx]->asymmetric = spa->rtcp->stream[pidx]->asymmetric = ulop->asymmetric;
spa->rtp->stream[pidx]->latch_info.latched = spa->rtcp->stream[pidx]->latch_info.latched = ulop->asymmetric;
if (spa->rtp->stream[pidx]->codecs != NULL) {
free(spa->rtp->stream[pidx]->codecs);
spa->rtp->stream[pidx]->codecs = NULL;
}
if (ulop->codecs != NULL) {
spa->rtp->stream[pidx]->codecs = ulop->codecs;
ulop->codecs = NULL;
}
spa->rtp->stream[NOT(pidx)]->ptime = ulop->requested_ptime;
actor = CALL_METHOD(spa->rtp->stream[pidx], get_actor);
if (ulop->requested_ptime > 0) {
RTPP_LOG(spa->log, RTPP_LOG_INFO, "RTP packets from %s "
"will be resized to %d milliseconds", actor, ulop->requested_ptime);
} else if (spa->rtp->stream[pidx]->resizer != NULL) {
RTPP_LOG(spa->log, RTPP_LOG_INFO, "Resizing of RTP "
"packets from %s has been disabled", actor);
}
if (ulop->requested_ptime > 0) {
if (spa->rtp->stream[pidx]->resizer != NULL) {
rtp_resizer_set_ptime(spa->rtp->stream[pidx]->resizer, ulop->requested_ptime);
} else {
spa->rtp->stream[pidx]->resizer = rtp_resizer_new(ulop->requested_ptime);
}
} else if (spa->rtp->stream[pidx]->resizer != NULL) {
rtp_resizer_free(cf->stable->rtpp_stats, spa->rtp->stream[pidx]->resizer);
spa->rtp->stream[pidx]->resizer = NULL;
}
RTPP_DBG_ASSERT(lport != 0);
ulop->reply.port = lport;
ulop->reply.ia = ulop->lia[0];
if (cf->stable->advaddr[0] != NULL) {
if (cf->stable->bmode != 0 && cf->stable->advaddr[1] != NULL &&
ulop->lia[0] == cf->stable->bindaddr[1]) {
ulop->reply.ia_ov = cf->stable->advaddr[1];
} else {
ulop->reply.ia_ov = cf->stable->advaddr[0];
}
}
ul_reply_port(cmd, &ulop->reply);
rtpp_command_ul_opts_free(ulop);
return (0);
err_undo_0:
rtpp_command_ul_opts_free(ulop);
return (-1);
}
struct ul_opts *
rtpp_command_ul_opts_parse(struct cfg *cf, struct rtpp_command *cmd)
{
int len, tpf, n, i;
char c;
char *cp, *t;
const char *errmsg;
struct sockaddr_storage tia;
struct ul_opts *ulop;
ulop = rtpp_zmalloc(sizeof(struct ul_opts));
if (ulop == NULL) {
reply_error(cmd, ECODE_NOMEM_1);
goto err_undo_0;
}
ul_opts_init(cf, ulop);
if (cmd->cca.op == UPDATE && cmd->argc > 6) {
if (cmd->argc == 8) {
ulop->notify_socket = cmd->argv[6];
ulop->notify_tag = cmd->argv[7];
} else {
ulop->notify_socket = cmd->argv[5];
ulop->notify_tag = cmd->argv[6];
cmd->cca.to_tag = NULL;
}
len = url_unquote((uint8_t *)ulop->notify_tag, strlen(ulop->notify_tag));
if (len == -1) {
RTPP_LOG(cf->stable->glog, RTPP_LOG_ERR,
"command syntax error - invalid URL encoding");
reply_error(cmd, ECODE_PARSE_10);
goto err_undo_1;
}
ulop->notify_tag[len] = '\0';
}
ulop->addr = cmd->argv[2];
ulop->port = cmd->argv[3];
/* Process additional command modifiers */
for (cp = cmd->argv[0] + 1; *cp != '\0'; cp++) {
switch (*cp) {
case 'a':
case 'A':
ulop->asymmetric = 1;
break;
case 'e':
case 'E':
if (ulop->lidx < 0 || cf->stable->bindaddr[1] == NULL) {
RTPP_LOG(cf->stable->glog, RTPP_LOG_ERR, "command syntax error");
reply_error(cmd, ECODE_PARSE_11);
goto err_undo_1;
}
ulop->lia[ulop->lidx] = cf->stable->bindaddr[1];
ulop->lidx--;
break;
case 'i':
case 'I':
if (ulop->lidx < 0 || cf->stable->bindaddr[1] == NULL) {
RTPP_LOG(cf->stable->glog, RTPP_LOG_ERR, "command syntax error");
reply_error(cmd, ECODE_PARSE_12);
goto err_undo_1;
}
ulop->lia[ulop->lidx] = cf->stable->bindaddr[0];
ulop->lidx--;
break;
case '6':
ulop->pf = AF_INET6;
break;
case 's':
case 'S':
ulop->asymmetric = 0;
break;
case 'w':
case 'W':
ulop->weak = 1;
break;
case 'z':
case 'Z':
ulop->requested_ptime = strtol(cp + 1, &cp, 10);
if (ulop->requested_ptime <= 0) {
RTPP_LOG(cf->stable->glog, RTPP_LOG_ERR, "command syntax error");
reply_error(cmd, ECODE_PARSE_13);
goto err_undo_1;
}
cp--;
break;
case 'c':
case 'C':
cp += 1;
for (t = cp; *cp != '\0'; cp++) {
if (!isdigit(*cp) && *cp != ',')
break;
}
if (t == cp) {
RTPP_LOG(cf->stable->glog, RTPP_LOG_ERR, "command syntax error");
reply_error(cmd, ECODE_PARSE_14);
goto err_undo_1;
}
ulop->codecs = malloc(cp - t + 1);
if (ulop->codecs == NULL) {
reply_error(cmd, ECODE_NOMEM_2);
goto err_undo_1;
}
memcpy(ulop->codecs, t, cp - t);
ulop->codecs[cp - t] = '\0';
cp--;
break;
case 'l':
case 'L':
len = extractaddr(cp + 1, &t, &cp, &tpf);
if (len == -1) {
RTPP_LOG(cf->stable->glog, RTPP_LOG_ERR, "command syntax error");
reply_error(cmd, ECODE_PARSE_15);
goto err_undo_1;
}
c = t[len];
t[len] = '\0';
ulop->local_addr = host2bindaddr(cf, t, tpf, &errmsg);
if (ulop->local_addr == NULL) {
RTPP_LOG(cf->stable->glog, RTPP_LOG_ERR,
"invalid local address: %s: %s", t, errmsg);
reply_error(cmd, ECODE_INVLARG_1);
goto err_undo_1;
}
t[len] = c;
cp--;
break;
case 'r':
case 'R':
len = extractaddr(cp + 1, &t, &cp, &tpf);
if (len == -1) {
RTPP_LOG(cf->stable->glog, RTPP_LOG_ERR, "command syntax error");
reply_error(cmd, ECODE_PARSE_16);
goto err_undo_1;
}
c = t[len];
t[len] = '\0';
ulop->local_addr = alloca(sizeof(struct sockaddr_storage));
n = resolve(ulop->local_addr, tpf, t, SERVICE, AI_PASSIVE);
if (n != 0) {
RTPP_LOG(cf->stable->glog, RTPP_LOG_ERR,
"invalid remote address: %s: %s", t, gai_strerror(n));
reply_error(cmd, ECODE_INVLARG_2);
goto err_undo_1;
}
if (local4remote(ulop->local_addr, satoss(ulop->local_addr)) == -1) {
RTPP_LOG(cf->stable->glog, RTPP_LOG_ERR,
"can't find local address for remote address: %s", t);
reply_error(cmd, ECODE_INVLARG_3);
goto err_undo_1;
}
ulop->local_addr = addr2bindaddr(cf, ulop->local_addr, &errmsg);
if (ulop->local_addr == NULL) {
RTPP_LOG(cf->stable->glog, RTPP_LOG_ERR,
"invalid local address: %s", errmsg);
reply_error(cmd, ECODE_INVLARG_4);
goto err_undo_1;
}
t[len] = c;
cp--;
break;
case 'n':
case 'N':
ulop->new_port = 1;
break;
default:
RTPP_LOG(cf->stable->glog, RTPP_LOG_ERR, "unknown command modifier `%c'",
*cp);
break;
}
}
if (ulop->addr != NULL && ulop->port != NULL && strlen(ulop->addr) >= 7) {
n = resolve(sstosa(&tia), ulop->pf, ulop->addr, ulop->port, AI_NUMERICHOST);
if (n == 0) {
if (!ishostnull(sstosa(&tia))) {
for (i = 0; i < 2; i++) {
ulop->ia[i] = malloc(SS_LEN(&tia));
if (ulop->ia[i] == NULL) {
reply_error(cmd, ECODE_NOMEM_3);
goto err_undo_1;
}
memcpy(ulop->ia[i], &tia, SS_LEN(&tia));
}
/* Set port for RTCP, will work both for IPv4 and IPv6 */
n = ntohs(satosin(ulop->ia[1])->sin_port);
satosin(ulop->ia[1])->sin_port = htons(n + 1);
}
} else {
RTPP_LOG(cf->stable->glog, RTPP_LOG_ERR, "getaddrinfo(pf=%d, addr=%s, port=%s): %s",
ulop->pf, ulop->addr, ulop->port, gai_strerror(n));
}
}
return (ulop);
err_undo_1:
rtpp_command_ul_opts_free(ulop);
err_undo_0:
return (NULL);
}
int
rtpp_command_ul_handle(struct cfg *cf, struct rtpp_command *cmd,
struct common_cmd_args *ccap, struct ul_opts *ulop,
struct rtpp_session *sp, int sidx)
{
int pidx, lport, i;
int fds[2];
char *cp;
struct rtpp_session *spa, *spb;
pidx = 1;
lport = 0;
spa = spb = NULL;
fds[0] = fds[1] = -1;
if (sidx != -1) {
assert(ccap->op == UPDATE || ccap->op == LOOKUP);
spa = sp;
if (spa->fds[sidx] == -1) {
if (ulop->local_addr != NULL) {
spa->laddr[sidx] = ulop->local_addr;
}
if (rtpp_create_listener(cf, spa->laddr[sidx], &lport, fds) == -1) {
rtpp_log_write(RTPP_LOG_ERR, spa->log, "can't create listener");
reply_error(cf, cmd, ECODE_LSTFAIL_1);
goto err_undo_0;
}
assert(spa->fds[sidx] == -1);
spa->fds[sidx] = fds[0];
assert(spa->rtcp->fds[sidx] == -1);
spa->rtcp->fds[sidx] = fds[1];
spa->ports[sidx] = lport;
spa->rtcp->ports[sidx] = lport + 1;
if (spa->complete == 0) {
cmd->csp->nsess_complete.cnt++;
}
spa->complete = spa->rtcp->complete = 1;
append_session(cf, spa, sidx);
}
if (ulop->weak)
spa->weak[sidx] = 1;
else if (ccap->op == UPDATE)
spa->strong = 1;
lport = spa->ports[sidx];
ulop->lia[0] = spa->laddr[sidx];
pidx = (sidx == 0) ? 1 : 0;
spa->ttl_mode = cf->stable->ttl_mode;
spa->ttl[0] = cf->stable->max_ttl;
spa->ttl[1] = cf->stable->max_ttl;
if (ccap->op == UPDATE) {
rtpp_log_write(RTPP_LOG_INFO, spa->log,
"adding %s flag to existing session, new=%d/%d/%d",
ulop->weak ? ( sidx ? "weak[1]" : "weak[0]" ) : "strong",
spa->strong, spa->weak[0], spa->weak[1]);
}
rtpp_log_write(RTPP_LOG_INFO, spa->log,
"lookup on ports %d/%d, session timer restarted", spa->ports[0],
spa->ports[1]);
} else {
assert(ccap->op == UPDATE);
rtpp_log_write(RTPP_LOG_INFO, cf->stable->glog,
"new session %s, tag %s requested, type %s",
ccap->call_id, ccap->from_tag, ulop->weak ? "weak" : "strong");
if (cf->stable->slowshutdown != 0) {
rtpp_log_write(RTPP_LOG_INFO, cf->stable->glog,
"proxy is in the deorbiting-burn mode, new session rejected");
reply_error(cf, cmd, ECODE_SLOWSHTDN);
goto err_undo_0;
}
if (ulop->local_addr != NULL) {
ulop->lia[0] = ulop->lia[1] = ulop->local_addr;
}
if (rtpp_create_listener(cf, ulop->lia[0], &lport, fds) == -1) {
rtpp_log_write(RTPP_LOG_ERR, cf->stable->glog, "can't create listener");
reply_error(cf, cmd, ECODE_LSTFAIL_2);
goto err_undo_0;
}
/*
* Session creation. If creation is requested with weak flag,
* set weak[0].
*/
spa = malloc(sizeof(*spa));
if (spa == NULL) {
handle_nomem(cf, cmd, ECODE_NOMEM_4, ulop,
fds, spa, spb);
return (-1);
}
/* spb is RTCP twin session for this one. */
spb = malloc(sizeof(*spb));
if (spb == NULL) {
handle_nomem(cf, cmd, ECODE_NOMEM_5, ulop,
fds, spa, spb);
return (-1);
}
memset(spa, 0, sizeof(*spa));
memset(spb, 0, sizeof(*spb));
spa->init_ts = cmd->dtime;
spb->init_ts = cmd->dtime;
for (i = 0; i < 2; i++) {
spa->fds[i] = spb->fds[i] = -1;
spa->last_update[i] = 0;
spb->last_update[i] = 0;
}
spa->call_id = strdup(ccap->call_id);
if (spa->call_id == NULL) {
handle_nomem(cf, cmd, ECODE_NOMEM_6, ulop,
fds, spa, spb);
return (-1);
}
spb->call_id = spa->call_id;
spa->tag = strdup(ccap->from_tag);
spa->tag_nomedianum = strdup(ccap->from_tag);
if (spa->tag == NULL) {
handle_nomem(cf, cmd, ECODE_NOMEM_7, ulop,
fds, spa, spb);
return (-1);
}
cp = strrchr(spa->tag_nomedianum, ';');
if (cp != NULL)
*cp = '\0';
spb->tag = spa->tag;
spb->tag_nomedianum = spa->tag_nomedianum;
for (i = 0; i < 2; i++) {
spa->rrcs[i] = NULL;
spb->rrcs[i] = NULL;
spa->laddr[i] = ulop->lia[i];
spb->laddr[i] = ulop->lia[i];
}
spa->strong = spa->weak[0] = spa->weak[1] = 0;
if (ulop->weak)
spa->weak[0] = 1;
else
spa->strong = 1;
assert(spa->fds[0] == -1);
spa->fds[0] = fds[0];
assert(spb->fds[0] == -1);
spb->fds[0] = fds[1];
spa->ports[0] = lport;
spb->ports[0] = lport + 1;
spa->ttl[0] = cf->stable->max_ttl;
spa->ttl[1] = cf->stable->max_ttl;
spb->ttl[0] = -1;
spb->ttl[1] = -1;
spa->log = rtpp_log_open(cf->stable, "rtpproxy", spa->call_id, 0);
rtpp_log_setlevel(spa->log, cf->stable->log_level);
spb->log = spa->log;
spa->rtcp = spb;
spb->rtcp = NULL;
spa->rtp = NULL;
spb->rtp = spa;
spa->sridx = spb->sridx = -1;
append_session(cf, spa, 0);
append_session(cf, spa, 1);
spa->hte = CALL_METHOD(cf->stable->sessions_ht, append, spa->call_id, spa);
if (spa->hte == NULL) {
remove_session(cf, spa);
remove_session(cf, spb);
handle_nomem(cf, cmd, ECODE_NOMEM_8, ulop, fds, spa, spb);
return (-1);
}
cf->sessions_created++;
cf->sessions_active++;
cmd->csp->nsess_created.cnt++;
/*
* Each session can consume up to 5 open file descriptors (2 RTP,
* 2 RTCP and 1 logging) so that warn user when he is likely to
* exceed 80% mark on hard limit.
*/
if (cf->sessions_active > (rtpp_rlim_max(cf) * 80 / (100 * 5)) &&
cf->nofile_limit_warned == 0) {
cf->nofile_limit_warned = 1;
rtpp_log_write(RTPP_LOG_WARN, cf->stable->glog, "passed 80%% "
"threshold on the open file descriptors limit (%d), "
"consider increasing the limit using -L command line "
"option", (int)rtpp_rlim_max(cf));
}
rtpp_log_write(RTPP_LOG_INFO, spa->log, "new session on a port %d created, "
"tag %s", lport, ccap->from_tag);
if (cf->stable->record_all != 0) {
handle_copy(cf, spa, 0, NULL, 0);
handle_copy(cf, spa, 1, NULL, 0);
}
}
if (ccap->op == UPDATE) {
if (rtpp_th_get_sn(cf->timeout_handler) == NULL && ulop->socket_name_u != NULL)
rtpp_log_write(RTPP_LOG_ERR, spa->log, "must permit notification socket with -n");
if (spa->timeout_data.notify_tag != NULL) {
free(spa->timeout_data.notify_tag);
spa->timeout_data.notify_tag = NULL;
}
if (rtpp_th_get_sn(cf->timeout_handler) != NULL && ulop->socket_name_u != NULL) {
if (strcmp(rtpp_th_get_sn(cf->timeout_handler), ulop->socket_name_u) != 0) {
rtpp_log_write(RTPP_LOG_ERR, spa->log, "invalid socket name %s", ulop->socket_name_u);
ulop->socket_name_u = NULL;
} else {
rtpp_log_write(RTPP_LOG_INFO, spa->log, "setting timeout handler");
spa->timeout_data.handler = cf->timeout_handler;
spa->timeout_data.notify_tag = strdup(ulop->notify_tag);
}
} else if (ulop->socket_name_u == NULL && spa->timeout_data.handler != NULL) {
spa->timeout_data.handler = NULL;
rtpp_log_write(RTPP_LOG_INFO, spa->log, "disabling timeout handler");
}
}
if (ulop->ia[0] != NULL && ulop->ia[1] != NULL) {
if (spa->addr[pidx] != NULL)
spa->last_update[pidx] = cmd->dtime;
if (spa->rtcp->addr[pidx] != NULL)
spa->rtcp->last_update[pidx] = cmd->dtime;
/*
* Unless the address provided by client historically
* cannot be trusted and address is different from one
* that we recorded update it.
*/
if (spa->untrusted_addr[pidx] == 0 && !(spa->addr[pidx] != NULL &&
SA_LEN(ulop->ia[0]) == SA_LEN(spa->addr[pidx]) &&
memcmp(ulop->ia[0], spa->addr[pidx], SA_LEN(ulop->ia[0])) == 0)) {
rtpp_log_write(RTPP_LOG_INFO, spa->log, "pre-filling %s's address "
"with %s:%s", (pidx == 0) ? "callee" : "caller", ulop->addr, ulop->port);
if (spa->addr[pidx] != NULL) {
if (spa->canupdate[pidx] == 0) {
if (spa->prev_addr[pidx] != NULL)
free(spa->prev_addr[pidx]);
spa->prev_addr[pidx] = spa->addr[pidx];
} else {
free(spa->addr[pidx]);
}
}
spa->addr[pidx] = ulop->ia[0];
ulop->ia[0] = NULL;
}
if (spa->rtcp->untrusted_addr[pidx] == 0 && !(spa->rtcp->addr[pidx] != NULL &&
SA_LEN(ulop->ia[1]) == SA_LEN(spa->rtcp->addr[pidx]) &&
memcmp(ulop->ia[1], spa->rtcp->addr[pidx], SA_LEN(ulop->ia[1])) == 0)) {
if (spa->rtcp->addr[pidx] != NULL) {
if (spa->rtcp->canupdate[pidx] == 0) {
if (spa->rtcp->prev_addr[pidx] != NULL)
free(spa->rtcp->prev_addr[pidx]);
spa->rtcp->prev_addr[pidx] = spa->rtcp->addr[pidx];
} else {
free(spa->rtcp->addr[pidx]);
}
}
spa->rtcp->addr[pidx] = ulop->ia[1];
ulop->ia[1] = NULL;
}
}
spa->asymmetric[pidx] = spa->rtcp->asymmetric[pidx] = ulop->asymmetric;
spa->canupdate[pidx] = spa->rtcp->canupdate[pidx] = NOT(ulop->asymmetric);
if (spa->codecs[pidx] != NULL) {
free(spa->codecs[pidx]);
spa->codecs[pidx] = NULL;
}
if (ulop->codecs != NULL) {
spa->codecs[pidx] = ulop->codecs;
ulop->codecs = NULL;
}
if (ulop->requested_nsamples > 0) {
rtpp_log_write(RTPP_LOG_INFO, spa->log, "RTP packets from %s "
"will be resized to %d milliseconds",
(pidx == 0) ? "callee" : "caller", ulop->requested_nsamples / 8);
} else if (spa->resizers[pidx] != NULL) {
rtpp_log_write(RTPP_LOG_INFO, spa->log, "Resizing of RTP "
"packets from %s has been disabled",
(pidx == 0) ? "callee" : "caller");
}
if (ulop->requested_nsamples > 0) {
if (spa->resizers[pidx] != NULL) {
rtp_resizer_set_onsamples(spa->resizers[pidx], ulop->requested_nsamples);
} else {
spa->resizers[pidx] = rtp_resizer_new(ulop->requested_nsamples);
}
} else if (spa->resizers[pidx] != NULL) {
rtp_resizer_free(spa->resizers[pidx]);
spa->resizers[pidx] = NULL;
}
assert(lport != 0);
ulop->reply.port = lport;
ulop->reply.ia = ulop->lia[0];
if (cf->stable->advaddr[0] != NULL) {
if (cf->stable->bmode != 0 && cf->stable->advaddr[1] != NULL &&
ulop->lia[0] == cf->stable->bindaddr[1]) {
ulop->reply.ia_ov = cf->stable->advaddr[1];
} else {
ulop->reply.ia_ov = cf->stable->advaddr[0];
}
}
ul_reply_port(cf, cmd, &ulop->reply);
rtpp_command_ul_opts_free(ulop);
return (0);
err_undo_0:
rtpp_command_ul_opts_free(ulop);
return (-1);
}
int
handle_command(struct cfg *cf, struct rtpp_command *cmd)
{
int i, verbose, rval;
int playcount;
char *cp, *tcp;
char *pname, *codecs, *recording_name;
struct rtpp_session *spa;
int record_single_file;
struct ul_opts *ulop;
struct d_opts dopt;
spa = NULL;
recording_name = NULL;
codecs = NULL;
/* Step II: parse parameters that are specific to a particular op and run simple ops */
switch (cmd->cca.op) {
case VER_FEATURE:
handle_ver_feature(cf, cmd);
return 0;
case GET_VER:
/* This returns base version. */
reply_number(cf, cmd, CPROTOVER);
return 0;
case DELETE_ALL:
/* Delete all active sessions */
rtpp_log_write(RTPP_LOG_INFO, cf->stable->glog, "deleting all active sessions");
pthread_mutex_lock(&cf->sessinfo.lock);
for (i = 0; i < cf->sessinfo.nsessions; i++) {
spa = cf->sessinfo.sessions[i];
if (spa == NULL || spa->sidx[0] != i)
continue;
remove_session(cf, spa);
}
pthread_mutex_unlock(&cf->sessinfo.lock);
reply_ok(cf, cmd);
return 0;
case INFO:
handle_info(cf, cmd, &cmd->argv[0][1]);
return 0;
case PLAY:
/*
* P callid pname codecs from_tag to_tag
*
* <codecs> could be either comma-separated list of supported
* payload types or word "session" (without quotes), in which
* case list saved on last session update will be used instead.
*/
playcount = 1;
pname = cmd->argv[2];
codecs = cmd->argv[3];
tcp = &(cmd->argv[0][1]);
if (*tcp != '\0') {
playcount = strtol(tcp, &cp, 10);
if (cp == tcp || *cp != '\0') {
rtpp_log_write(RTPP_LOG_ERR, cf->stable->glog, "command syntax error");
reply_error(cf, cmd, ECODE_PARSE_6);
return 0;
}
}
break;
case COPY:
recording_name = cmd->argv[2];
/* Fallthrough */
case RECORD:
if (cmd->argv[0][1] == 'S' || cmd->argv[0][1] == 's') {
if (cmd->argv[0][2] != '\0') {
rtpp_log_write(RTPP_LOG_ERR, cf->stable->glog, "command syntax error");
reply_error(cf, cmd, ECODE_PARSE_2);
return 0;
}
record_single_file = (cf->stable->record_pcap == 0) ? 0 : 1;
} else {
if (cmd->argv[0][1] != '\0') {
rtpp_log_write(RTPP_LOG_ERR, cf->stable->glog, "command syntax error");
reply_error(cf, cmd, ECODE_PARSE_3);
return 0;
}
record_single_file = 0;
}
break;
case DELETE:
/* D[w] call_id from_tag [to_tag] */
dopt.weak = 0;
for (cp = cmd->argv[0] + 1; *cp != '\0'; cp++) {
switch (*cp) {
case 'w':
case 'W':
dopt.weak = 1;
break;
default:
rtpp_log_write(RTPP_LOG_ERR, cf->stable->glog,
"DELETE: unknown command modifier `%c'", *cp);
reply_error(cf, cmd, ECODE_PARSE_4);
return 0;
}
}
break;
case UPDATE:
case LOOKUP:
ulop = rtpp_command_ul_opts_parse(cf, cmd);
if (ulop == NULL) {
return 0;
}
break;
case GET_STATS:
verbose = 0;
for (cp = cmd->argv[0] + 1; *cp != '\0'; cp++) {
switch (*cp) {
case 'v':
case 'V':
verbose = 1;
break;
default:
rtpp_log_write(RTPP_LOG_ERR, cf->stable->glog,
"STATS: unknown command modifier `%c'", *cp);
reply_error(cf, cmd, ECODE_PARSE_5);
return 0;
}
}
i = handle_get_stats(cf, cmd, verbose);
if (i != 0) {
reply_error(cf, cmd, i);
}
return 0;
default:
break;
}
/*
* Record and delete need special handling since they apply to all
* streams in the session.
*/
switch (cmd->cca.op) {
case DELETE:
i = handle_delete(cf, &cmd->cca, dopt.weak);
break;
case RECORD:
i = handle_record(cf, &cmd->cca, record_single_file);
break;
default:
i = find_stream(cf, cmd->cca.call_id, cmd->cca.from_tag, cmd->cca.to_tag, &spa);
if (i != -1 && cmd->cca.op != UPDATE)
i = NOT(i);
break;
}
if (i == -1 && cmd->cca.op != UPDATE) {
rtpp_log_write(RTPP_LOG_INFO, cf->stable->glog,
"%s request failed: session %s, tags %s/%s not found", cmd->cca.rname,
cmd->cca.call_id, cmd->cca.from_tag, cmd->cca.to_tag != NULL ? cmd->cca.to_tag : "NONE");
if (cmd->cca.op == LOOKUP) {
rtpp_command_ul_opts_free(ulop);
ul_reply_port(cf, cmd, NULL);
return 0;
}
reply_error(cf, cmd, ECODE_SESUNKN);
return 0;
}
switch (cmd->cca.op) {
case DELETE:
case RECORD:
reply_ok(cf, cmd);
break;
case NOPLAY:
handle_noplay(cf, spa, i, cmd);
reply_ok(cf, cmd);
break;
case PLAY:
handle_noplay(cf, spa, i, cmd);
if (strcmp(codecs, "session") == 0) {
if (spa->codecs[i] == NULL) {
reply_error(cf, cmd, ECODE_INVLARG_5);
return 0;
}
codecs = spa->codecs[i];
}
if (playcount != 0 && handle_play(cf, spa, i, codecs, pname, playcount, cmd) != 0) {
reply_error(cf, cmd, ECODE_PLRFAIL);
return 0;
}
reply_ok(cf, cmd);
break;
case COPY:
if (handle_copy(cf, spa, i, recording_name, record_single_file) != 0) {
reply_error(cf, cmd, ECODE_CPYFAIL);
return 0;
}
reply_ok(cf, cmd);
break;
case QUERY:
rval = handle_query(cf, cmd, spa, i);
if (rval != 0) {
reply_error(cf, cmd, rval);
}
break;
case LOOKUP:
case UPDATE:
rtpp_command_ul_handle(cf, cmd, ulop, spa, i);
break;
default:
/* Programmatic error, should not happen */
abort();
}
return 0;
}
