static bool rr_naptr_handler(struct dnsrr *rr, void *arg)
{
struct sip_request *req = arg;
enum sip_transp tp;
if (rr->type != DNS_TYPE_NAPTR)
return false;
if (!str_casecmp(rr->rdata.naptr.services, "SIP+D2U"))
tp = SIP_TRANSP_UDP;
else if (!str_casecmp(rr->rdata.naptr.services, "SIP+D2T"))
tp = SIP_TRANSP_TCP;
else if (!str_casecmp(rr->rdata.naptr.services, "SIPS+D2T"))
tp = SIP_TRANSP_TLS;
else
return false;
if (!sip_transp_supported(req->sip, tp, AF_UNSPEC))
return false;
req->tp = tp;
req->tp_selected = true;
return true;
}
int agent_process_remote_attr(struct agent *ag,
const char *name, const char *value)
{
int err = 0;
if (!ag || !name)
return EINVAL;
if (0 == str_casecmp(name, "ice-ufrag")) {
ag->rufrag = true;
err = trice_set_remote_ufrag(ag->icem, value);
}
else if (0 == str_casecmp(name, "ice-pwd")) {
ag->rpwd = true;
err = trice_set_remote_pwd(ag->icem, value);
}
else if (0 == str_casecmp(name, "candidate")) {
unsigned i;
err = agent_rcand_decode_add(ag->icem, value);
for (i=0; i<ag->candc; i++)
candidate_add_permissions(&ag->candv[i]);
}
else if (0 == str_casecmp(name, "end-of-candidates")) {
re_printf("got end-of-candidates from remote\n");
ag->remote_eoc = true;
}
else {
re_printf("attribute ignored: %s\n", name);
}
if (err) {
re_printf("remote attr error (%m)\n", err);
return err;
}
if (ag->rufrag && ag->rpwd && ag->cli->param.run_checklist
&& !list_isempty(trice_rcandl(ag->icem))
&& !trice_checklist_isrunning(ag->icem)) {
re_printf("starting ICE checklist with pacing interval"
" %u milliseconds..\n",
ag->cli->param.pacing_interval);
err = trice_checklist_start(ag->icem, NULL,
ag->cli->param.pacing_interval,
true,
ice_estab_handler,
ice_failed_handler, ag);
if (err) {
re_fprintf(stderr, "could not start checklist (%m)\n",
err);
}
}
return 0;
}
enum ice_cand_type ice_cand_name2type(const char *name)
{
if (0 == str_casecmp(name, "host")) return ICE_CAND_TYPE_HOST;
if (0 == str_casecmp(name, "srflx")) return ICE_CAND_TYPE_SRFLX;
if (0 == str_casecmp(name, "prflx")) return ICE_CAND_TYPE_PRFLX;
if (0 == str_casecmp(name, "relay")) return ICE_CAND_TYPE_RELAY;
return (enum ice_cand_type)-1;
}
static const EVP_MD *type2evp(const char *type)
{
if (0 == str_casecmp(type, "SHA-1"))
return EVP_sha1();
else if (0 == str_casecmp(type, "SHA-256"))
return EVP_sha256();
else
return NULL;
}
int avcodec_resolve_codecid(const char *s)
{
if (0 == str_casecmp(s, "H263"))
return AV_CODEC_ID_H263;
else if (0 == str_casecmp(s, "H264"))
return AV_CODEC_ID_H264;
else if (0 == str_casecmp(s, "MP4V-ES"))
return AV_CODEC_ID_MPEG4;
else
return AV_CODEC_ID_NONE;
}
static enum srtp_suite resolve_suite(const char *suite)
{
if (0 == str_casecmp(suite, aes_cm_128_hmac_sha1_32))
return SRTP_AES_CM_128_HMAC_SHA1_32;
if (0 == str_casecmp(suite, aes_cm_128_hmac_sha1_80))
return SRTP_AES_CM_128_HMAC_SHA1_80;
if (0 == str_casecmp(suite, aes_128_gcm))
return SRTP_AES_128_GCM;
return -1;
}
static enum bfcp_transp str2tp(const char *proto)
{
if (0 == str_casecmp(proto, "udp"))
return BFCP_UDP;
else if (0 == str_casecmp(proto, "dtls"))
return BFCP_DTLS;
else {
warning("unsupported BFCP protocol: %s\n", proto);
return -1;
}
}
static int start_srtp(struct menc_st *st, const char *suite)
{
crypto_policy_t policy;
err_status_t e;
if (0 == str_casecmp(suite, aes_cm_128_hmac_sha1_32)) {
crypto_policy_set_aes_cm_128_hmac_sha1_32(&policy);
}
else if (0 == str_casecmp(suite, aes_cm_128_hmac_sha1_80)) {
crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy);
}
else {
DEBUG_WARNING("unknown SRTP crypto suite (%s)\n", suite);
return ENOENT;
}
/* transmit policy */
st->policy_tx.rtp = policy;
st->policy_tx.rtcp = policy;
st->policy_tx.ssrc.type = ssrc_any_outbound;
st->policy_tx.key = st->key_tx;
st->policy_tx.next = NULL;
/* receive policy */
st->policy_rx.rtp = policy;
st->policy_rx.rtcp = policy;
st->policy_rx.ssrc.type = ssrc_any_inbound;
st->policy_rx.key = st->key_rx;
st->policy_rx.next = NULL;
/* allocate and initialize the SRTP session */
e = srtp_create(&st->srtp_tx, &st->policy_tx);
if (e != err_status_ok) {
DEBUG_WARNING("srtp_create TX failed (%H)\n",
errstatus_print, e);
return EPROTO;
}
e = srtp_create(&st->srtp_rx, &st->policy_rx);
if (err_status_ok != e) {
DEBUG_WARNING("srtp_create RX failed (%H)\n",
errstatus_print, e);
return EPROTO;
}
/* use SRTP for this stream/session */
st->use_srtp = true;
return 0;
}
LogLevel log_str2Level(char* buf) {
if (str_casecmp(buf, "error") == 0)
return ERROR;
if ((str_casecmp(buf, "warn") == 0) || (str_casecmp(buf, "warning") == 0))
return WARNING;
if (str_casecmp(buf, "info") == 0)
return INFO;
if (str_casecmp(buf, "debug") == 0)
return DEBUG;
return DEBUG;
}
static bool if_getaddr_handler(const char *ifname,
const struct sa *sa, void *arg)
{
struct ifentry *ife = arg;
/* Match name of interface? */
if (str_isset(ife->ifname) && 0 != str_casecmp(ife->ifname, ifname))
return false;
if (!sa_isset(sa, SA_ADDR))
return false;
#if 1
/* skip loopback and link-local IP */
if (sa_is_loopback(sa) || sa_is_linklocal(sa))
return false;
#endif
/* Match address family */
if (ife->af != sa_af(sa))
return false;
/* Match - copy address */
sa_cpy(ife->ip, sa);
ife->found = true;
return ife->found;
}
static bool remote_user_handler(char *key, void *val, void *arg)
{
struct flow *flow = val;
const char *remote_user = arg;
return 0 == str_casecmp(flow->remoteid, remote_user);
}
/**
* Decode SDP media attributes
*
* @param icem ICE Media object
* @param name Name of the SDP attribute
* @param value Value of the SDP attribute (optional)
*
* @return 0 if success, otherwise errorcode
*/
int icem_sdp_decode(struct icem *icem, const char *name, const char *value)
{
if (!icem)
return EINVAL;
if (0 == str_casecmp(name, ice_attr_cand))
return cand_decode(icem, value);
else if (0 == str_casecmp(name, ice_attr_mismatch))
icem->mismatch = true;
else if (0 == str_casecmp(name, ice_attr_ufrag))
return media_ufrag_decode(icem, value);
else if (0 == str_casecmp(name, ice_attr_pwd))
return media_pwd_decode(icem, value);
return 0;
}
static void dns_server_match(struct dns_server *srv, struct list *rrl,
const char *name, uint16_t type)
{
struct dnsrr *rr0 = NULL;
struct le *le;
le = srv->rrl.head;
while (le) {
struct dnsrr *rr = le->data;
le = le->next;
if (type == rr->type && 0==str_casecmp(name, rr->name)) {
if (!rr0)
rr0 = rr;
list_append(rrl, &rr->le_priv, rr);
}
}
/* If rotation is enabled, then rotate multiple entries
in a deterministic way (no randomness please) */
if (srv->rotate && rr0) {
list_unlink(&rr0->le);
list_append(&srv->rrl, &rr0->le, rr0);
}
}
/**
* Get the DSP samplerate for an audio-codec (exception for G.722)
*/
static inline uint32_t get_srate(const struct aucodec *ac)
{
if (!ac)
return 0;
return !str_casecmp(ac->name, "G722") ? 16000 : ac->srate;
}
bool sdp_format_cmp(const struct sdp_format *fmt1,
const struct sdp_format *fmt2)
{
if (!fmt1 || !fmt2)
return false;
if (fmt1->pt < RTP_DYNPT_START && fmt2->pt < RTP_DYNPT_START) {
if (!fmt1->id || !fmt2->id)
return false;
return strcmp(fmt1->id, fmt2->id) ? false : true;
}
if (str_casecmp(fmt1->name, fmt2->name))
return false;
if (fmt1->srate != fmt2->srate)
return false;
if (fmt1->ch != fmt2->ch)
return false;
if (fmt1->cmph && !fmt1->cmph(fmt1->params, fmt2->params, fmt1->data))
return false;
if (fmt2->cmph && !fmt2->cmph(fmt2->params, fmt1->params, fmt2->data))
return false;
return true;
}
ADDRESS *mutt_lookup_alias (const char *s)
{
ALIAS *t = Aliases;
for (; t; t = t->next)
if (!str_casecmp (s, t->name))
return (t->addr);
return (NULL); /* no such alias */
}
int lookup_action (char *keyname)
{
int i;
for (i = 0; command_names [i].name; i++){
if (!str_casecmp (command_names [i].name, keyname))
return command_names [i].val;
}
return 0;
}
/**
* Find a Video Codec by name
*
* @param name Name of the Video Codec to find
* @param variant Codec Variant
*
* @return Matching Video Codec if found, otherwise NULL
*/
const struct vidcodec *vidcodec_find(const char *name, const char *variant)
{
struct le *le;
for (le=vidcodecl.head; le; le=le->next) {
struct vidcodec *vc = le->data;
if (name && 0 != str_casecmp(name, vc->name))
continue;
if (variant && 0 != str_casecmp(variant, vc->variant))
continue;
return vc;
}
return NULL;
}
/**
* Decode SDP session attributes
*
* @param ice ICE Session
* @param name Name of the SDP attribute
* @param value Value of the SDP attribute (optional)
*
* @return 0 if success, otherwise errorcode
*/
int ice_sdp_decode(struct ice *ice, const char *name, const char *value)
{
if (!ice)
return EINVAL;
if (0 == str_casecmp(name, ice_attr_lite)) {
if (ICE_MODE_LITE == ice->lmode) {
DEBUG_WARNING("we are lite, peer is also lite!\n");
return EPROTO;
}
ice->rmode = ICE_MODE_LITE;
ice->lrole = ROLE_CONTROLLING;
}
else if (0 == str_casecmp(name, ice_attr_ufrag))
return ufrag_decode(ice, value);
else if (0 == str_casecmp(name, ice_attr_pwd))
return pwd_decode(ice, value);
return 0;
}
/* check_cn()
*
* Check if the given commonname matches the full qualified hostname
* of the target host.
*
* Basic wildcard matching is supported (i.e. "*.ccc.de")
*
* For a full list of regexes see:
* http://wp.netscape.com/eng/security/ssl_2.0_certificate.html
**/
int check_cn(char *cn, char *fqdn)
{
int n;
if (*cn == '*') {
cn++;
n = str_len(fqdn) - str_len(cn);
if (n >= 0)
fqdn += n;
}
return str_casecmp(fqdn, cn);
}
static bool interface_handler(const char *ifname, const struct sa *addr,
void *arg)
{
struct agent *ag = arg;
int err = 0;
/* Skip loopback and link-local addresses */
if (ag->cli->param.skip_local) {
if (sa_is_loopback(addr) || sa_is_linklocal(addr))
return false;
}
if (str_isset(ag->cli->param.ifname) &&
str_casecmp(ag->cli->param.ifname, ifname)) {
return false;
}
switch (sa_af(addr)) {
case AF_INET:
if (!ag->cli->param.use_ipv4)
return false;
break;
case AF_INET6:
if (!ag->cli->param.use_ipv6)
return false;
break;
}
/* NOTE: on some machines an interface is listed twice. */
if (interface_find(ag, addr)) {
re_printf("ignoring duplicated interface (%s %j)\n",
ifname, addr);
return false;
}
ag->interfacev[ag->interfacec++] = *addr;
re_printf("interface: %s %j\n", ifname, addr);
if (ag->cli->param.use_udp)
err |= add_candidate(ag, addr, IPPROTO_UDP, 0, ifname);
if (ag->cli->param.use_tcp) {
err |= add_candidate(ag, addr, IPPROTO_TCP, ICE_TCP_SO,
ifname);
err |= add_candidate(ag, addr, IPPROTO_TCP,
ag->client ? ICE_TCP_ACTIVE : ICE_TCP_PASSIVE,
ifname);
}
return err != 0;
}
int audio_encoder_set(struct audio *a, const struct aucodec *ac,
int pt_tx, const char *params)
{
struct autx *tx;
int err = 0;
bool reset;
if (!a || !ac)
return EINVAL;
tx = &a->tx;
reset = !aucodec_equal(ac, tx->ac);
if (ac != tx->ac) {
(void)re_fprintf(stderr, "Set audio encoder: %s %uHz %dch\n",
ac->name, get_srate(ac), ac->ch);
/* Audio source must be stopped first */
if (reset) {
tx->ausrc = mem_deref(tx->ausrc);
}
tx->is_g722 = (0 == str_casecmp(ac->name, "G722"));
tx->enc = mem_deref(tx->enc);
tx->ac = ac;
}
if (ac->encupdh) {
struct auenc_param prm;
prm.ptime = tx->ptime;
err = ac->encupdh(&tx->enc, ac, &prm, params);
if (err) {
DEBUG_WARNING("alloc encoder: %m\n", err);
return err;
}
}
stream_set_srate(a->strm, get_srate(ac), get_srate(ac));
stream_update_encoder(a->strm, pt_tx);
if (!tx->ausrc) {
err |= audio_start(a);
}
return err;
}
/**
* Find an Audio Source by name
*
* @param ausrcl List of Audio Sources
* @param name Name of the Audio Source to find
*
* @return Matching Audio Source if found, otherwise NULL
*/
const struct ausrc *ausrc_find(const struct list *ausrcl, const char *name)
{
struct le *le;
for (le=list_head(ausrcl); le; le=le->next) {
struct ausrc *as = le->data;
if (str_isset(name) && 0 != str_casecmp(name, as->name))
continue;
return as;
}
return NULL;
}
/**
* Find a Video Source by name
*
* @param name Name of the Video Source to find
*
* @return Matching Video Source if found, otherwise NULL
*/
const struct vidsrc *vidsrc_find(const char *name)
{
struct le *le;
for (le=vidsrcl.head; le; le=le->next) {
struct vidsrc *vs = le->data;
if (str_isset(name) && 0 != str_casecmp(name, vs->name))
continue;
return vs;
}
return NULL;
}
static bool sort_handler(struct le *le1, struct le *le2, void *arg)
{
struct cmd_sort *cs1 = le1->data;
struct cmd_sort *cs2 = le2->data;
const struct cmd *cmd1 = cs1->cmd;
const struct cmd *cmd2 = cs2->cmd;
bool print_long = *(bool *)arg;
if (print_long) {
return str_casecmp(cs2->cmd->name ? cs2->cmd->name : "",
cs1->cmd->name ? cs1->cmd->name : "") >= 0;
}
else {
return tolower(cmd2->key) >= tolower(cmd1->key);
}
}
const struct vidisp *vidisp_find(const struct list *vidispl, const char *name)
{
struct le *le;
for (le = list_head(vidispl); le; le = le->next) {
struct vidisp *vd = le->data;
if (str_isset(name) && 0 != str_casecmp(name, vd->name))
continue;
/* Found */
return vd;
}
return NULL;
}
void module_app_unload(void)
{
struct le *le = list_tail(mod_list());
/* unload in reverse order */
while (le) {
struct mod *mod = le->data;
const struct mod_export *me = mod_export(mod);
le = le->prev;
if (me && 0 == str_casecmp(me->type, "application")) {
debug("module: unloading app %s\n", me->name);
mem_deref(mod);
}
}
}
static bool linklocal_handler(const char *ifname, const struct sa *sa,
void *arg)
{
void **argv = arg;
int af = *(int *)argv[1];
if (argv[0] && 0 != str_casecmp(argv[0], ifname))
return false;
if (af != AF_UNSPEC && af != sa_af(sa))
return false;
if (sa_is_linklocal(sa)) {
*((struct sa *)argv[2]) = *sa;
return true;
}
return false;
}
static int module_app_handler(const struct pl *val, void *arg)
{
struct mod *mod = NULL;
const struct mod_export *me;
debug("module: loading app %r\n", val);
if (load_module(&mod, arg, val)) {
return 0;
}
me = mod_export(mod);
if (0 != str_casecmp(me->type, "application")) {
warning("module_app %r should be type application (%s)\n",
val, me->type);
}
return 0;
}
static void mediaflow_localcand_handler(
const struct zapi_candidate *candv,
size_t candc, void *arg)
{
TestMedia *tm = static_cast<TestMedia *>(arg);
ASSERT_TRUE(tm->candc < ARRAY_SIZE(tm->candv));
for (size_t i=0; i<candc; i++) {
struct ice_cand_attr *cand = &tm->candv[tm->candc];
const struct zapi_candidate *zcand = &candv[i];
int err;
if (0 == str_casecmp(zcand->sdp,
"a=end-of-candidates")) {
++tm->n_local_eoc;
continue;
}
tm->candc++;
err = ice_cand_attr_decode(cand, zcand->sdp);
ASSERT_EQ(0, err);
ASSERT_STREQ("audio", zcand->mid);
ASSERT_EQ(0, zcand->mline_index);
/* verify that SRFLX and RELAY candidates contain
the related address */
switch (cand->type) {
case ICE_CAND_TYPE_SRFLX:
case ICE_CAND_TYPE_RELAY:
ASSERT_TRUE(sa_isset(&cand->rel_addr, SA_ALL));
break;
default:
break;
}
}
if (tm->candc >= tm->candc_expected)
re_cancel();
}