bool
IpAddr::isValid(const std::string &address, pj_uint16_t family)
{
pj_str_t pjstring;
pj_cstr(&pjstring, address.c_str());
pj_str_t ret_str;
pj_uint16_t ret_port;
int ret_family;
auto status = pj_sockaddr_parse2(pj_AF_UNSPEC(), 0, &pjstring, &ret_str, &ret_port, &ret_family);
if (status != PJ_SUCCESS || (family != pj_AF_UNSPEC() && ret_family != family))
return false;
char buf[PJ_INET6_ADDRSTRLEN];
pj_str_t addr_with_null = {buf, 0};
pj_strncpy_with_null(&addr_with_null, &ret_str, sizeof(buf));
struct sockaddr sa;
return inet_pton(ret_family==pj_AF_INET6()?AF_INET6:AF_INET, buf, &(sa.sa_data)) == 1;
}
static pj_stun_msg* create_msgint3(pj_pool_t *pool, test_vector *v)
{
pj_stun_msg *msg;
pj_sockaddr mapped_addr;
pj_str_t s1;
pj_status_t status;
status = pj_stun_msg_create(pool, v->msg_type, PJ_STUN_MAGIC,
(pj_uint8_t*)v->tsx_id, &msg);
if (status != PJ_SUCCESS)
goto on_error;
status = pj_stun_msg_add_string_attr(pool, msg, PJ_STUN_ATTR_SOFTWARE,
pj_cstr(&s1, "test vector"));
if (status != PJ_SUCCESS)
goto on_error;
status = pj_sockaddr_init(pj_AF_INET6(), &mapped_addr,
pj_cstr(&s1, "2001:db8:1234:5678:11:2233:4455:6677"),
32853);
if (status != PJ_SUCCESS)
goto on_error;
status = pj_stun_msg_add_sockaddr_attr(pool, msg,
PJ_STUN_ATTR_XOR_MAPPED_ADDR,
PJ_TRUE, &mapped_addr,
sizeof(pj_sockaddr));
if (status != PJ_SUCCESS)
goto on_error;
status = pj_stun_msg_add_msgint_attr(pool, msg);
if (status != PJ_SUCCESS)
goto on_error;
status = pj_stun_msg_add_uint_attr(pool, msg, PJ_STUN_ATTR_FINGERPRINT, 0);
if (status != PJ_SUCCESS)
goto on_error;
return msg;
on_error:
app_perror(" error: create_msgint3()", status);
return NULL;
}
/*! \brief Helper function which determines if the existing address has priority over new one */
static int multihomed_rewrite_header(pj_str_t *source, pjsip_transport *transport)
{
pj_uint32_t loop6[4] = {0, 0, 0, 0};
/* If the transport is bound to any it should always rewrite */
if ((transport->local_addr.addr.sa_family == pj_AF_INET() &&
transport->local_addr.ipv4.sin_addr.s_addr == PJ_INADDR_ANY) ||
(transport->local_addr.addr.sa_family == pj_AF_INET6() &&
!pj_memcmp(&transport->local_addr.ipv6.sin6_addr, loop6, sizeof(loop6)))) {
return 1;
}
/* If the transport is explicitly bound but the determined source differs favor the transport */
if (!pj_strcmp(source, &transport->local_name.host)) {
return 1;
}
return 0;
}
static void dump_answer(unsigned index, const pj_dns_parsed_rr *rr)
{
const pj_str_t root_name = { "<Root>", 6 };
const pj_str_t *name = &rr->name;
char ttl_words[32];
char addr[PJ_INET6_ADDRSTRLEN];
if (name->slen == 0)
name = &root_name;
PJ_LOG(3,(THIS_FILE, " %d. %s record (type=%d)",
index, pj_dns_get_type_name(rr->type),
rr->type));
PJ_LOG(3,(THIS_FILE, " Name: %.*s", (int)name->slen, name->ptr));
PJ_LOG(3,(THIS_FILE, " TTL: %u (%s)", rr->ttl,
spell_ttl(ttl_words, sizeof(ttl_words), rr->ttl)));
PJ_LOG(3,(THIS_FILE, " Data length: %u", rr->rdlength));
if (rr->type == PJ_DNS_TYPE_SRV) {
PJ_LOG(3,(THIS_FILE, " SRV: prio=%d, weight=%d %.*s:%d",
rr->rdata.srv.prio, rr->rdata.srv.weight,
(int)rr->rdata.srv.target.slen,
rr->rdata.srv.target.ptr,
rr->rdata.srv.port));
} else if (rr->type == PJ_DNS_TYPE_CNAME ||
rr->type == PJ_DNS_TYPE_NS ||
rr->type == PJ_DNS_TYPE_PTR)
{
PJ_LOG(3,(THIS_FILE, " Name: %.*s",
(int)rr->rdata.cname.name.slen,
rr->rdata.cname.name.ptr));
} else if (rr->type == PJ_DNS_TYPE_A) {
PJ_LOG(3,(THIS_FILE, " IP address: %s",
pj_inet_ntop2(pj_AF_INET(), &rr->rdata.a.ip_addr,
addr, sizeof(addr))));
} else if (rr->type == PJ_DNS_TYPE_AAAA) {
PJ_LOG(3,(THIS_FILE, " IPv6 address: %s",
pj_inet_ntop2(pj_AF_INET6(), &rr->rdata.aaaa.ip_addr,
addr, sizeof(addr))));
}
}
/* DNS resolver callback */
static void dns_srv_resolver_cb(void *user_data,
pj_status_t status,
const pj_dns_srv_record *rec)
{
pj_stun_sock *stun_sock = (pj_stun_sock*) user_data;
pj_grp_lock_acquire(stun_sock->grp_lock);
/* Clear query */
stun_sock->q = NULL;
/* Handle error */
if (status != PJ_SUCCESS) {
sess_fail(stun_sock, PJ_STUN_SOCK_DNS_OP, status);
pj_grp_lock_release(stun_sock->grp_lock);
return;
}
pj_assert(rec->count);
pj_assert(rec->entry[0].server.addr_count);
pj_assert(rec->entry[0].server.addr[0].af == stun_sock->af);
/* Set the address */
pj_sockaddr_init(stun_sock->af, &stun_sock->srv_addr, NULL,
rec->entry[0].port);
if (stun_sock->af == pj_AF_INET6()) {
stun_sock->srv_addr.ipv6.sin6_addr =
rec->entry[0].server.addr[0].ip.v6;
} else {
stun_sock->srv_addr.ipv4.sin_addr =
rec->entry[0].server.addr[0].ip.v4;
}
/* Start sending Binding request */
get_mapped_addr(stun_sock);
pj_grp_lock_release(stun_sock->grp_lock);
}
static pj_status_t sock_set_ip_ds(pj_sock_t sock, pj_qos_params *param)
{
pj_status_t status = PJ_SUCCESS;
PJ_ASSERT_RETURN(param, PJ_EINVAL);
if (param->flags & PJ_QOS_PARAM_HAS_DSCP) {
/* We need to know if the socket is IPv4 or IPv6 */
pj_sockaddr sa;
int salen = sizeof(salen);
/* Value is dscp_val << 2 */
int val = (param->dscp_val << 2);
status = pj_sock_getsockname(sock, &sa, &salen);
if (status != PJ_SUCCESS)
return status;
if (sa.addr.sa_family == pj_AF_INET()) {
/* In IPv4, the DS field goes in the TOS field */
status = pj_sock_setsockopt(sock, pj_SOL_IP(), pj_IP_TOS(),
&val, sizeof(val));
} else if (sa.addr.sa_family == pj_AF_INET6()) {
/* In IPv6, the DS field goes in the Traffic Class field */
status = pj_sock_setsockopt(sock, pj_SOL_IPV6(),
pj_IPV6_TCLASS(),
&val, sizeof(val));
} else
status = PJ_EINVAL;
if (status != PJ_SUCCESS) {
param->flags &= ~(PJ_QOS_PARAM_HAS_DSCP);
}
}
return status;
}
/*
* Create stream info from SDP media line.
*/
PJ_DEF(pj_status_t) pjmedia_stream_info_from_sdp(
pjmedia_stream_info *si,
pj_pool_t *pool,
pjmedia_endpt *endpt,
const pjmedia_sdp_session *local,
const pjmedia_sdp_session *remote,
unsigned stream_idx)
{
pjmedia_codec_mgr *mgr;
const pjmedia_sdp_attr *attr;
const pjmedia_sdp_media *local_m;
const pjmedia_sdp_media *rem_m;
const pjmedia_sdp_conn *local_conn;
const pjmedia_sdp_conn *rem_conn;
int rem_af, local_af;
pj_sockaddr local_addr;
pjmedia_sdp_rtpmap *rtpmap;
unsigned i, pt, fmti;
pj_status_t status;
/* Validate arguments: */
PJ_ASSERT_RETURN(pool && si && local && remote, PJ_EINVAL);
PJ_ASSERT_RETURN(stream_idx < local->media_count, PJ_EINVAL);
PJ_ASSERT_RETURN(stream_idx < remote->media_count, PJ_EINVAL);
/* Get codec manager. */
mgr = pjmedia_endpt_get_codec_mgr(endpt);
/* Keep SDP shortcuts */
local_m = local->media[stream_idx];
rem_m = remote->media[stream_idx];
local_conn = local_m->conn ? local_m->conn : local->conn;
if (local_conn == NULL)
return PJMEDIA_SDP_EMISSINGCONN;
rem_conn = rem_m->conn ? rem_m->conn : remote->conn;
if (rem_conn == NULL)
return PJMEDIA_SDP_EMISSINGCONN;
/* Reset: */
pj_bzero(si, sizeof(*si));
#if PJMEDIA_HAS_RTCP_XR && PJMEDIA_STREAM_ENABLE_XR
/* Set default RTCP XR enabled/disabled */
si->rtcp_xr_enabled = PJ_TRUE;
#endif
/* Media type: */
if (pj_stricmp(&local_m->desc.media, &ID_AUDIO) == 0) {
si->type = PJMEDIA_TYPE_AUDIO;
} else if (pj_stricmp(&local_m->desc.media, &ID_VIDEO) == 0) {
si->type = PJMEDIA_TYPE_VIDEO;
} else {
si->type = PJMEDIA_TYPE_UNKNOWN;
/* Avoid rejecting call because of unrecognized media,
* just return PJ_SUCCESS, this media will be deactivated later.
*/
//return PJMEDIA_EINVALIMEDIATYPE;
return PJ_SUCCESS;
}
/* Transport protocol */
/* At this point, transport type must be compatible,
* the transport instance will do more validation later.
*/
status = pjmedia_sdp_transport_cmp(&rem_m->desc.transport,
&local_m->desc.transport);
if (status != PJ_SUCCESS)
return PJMEDIA_SDPNEG_EINVANSTP;
if (pj_stricmp(&local_m->desc.transport, &ID_RTP_AVP) == 0) {
si->proto = PJMEDIA_TP_PROTO_RTP_AVP;
} else if (pj_stricmp(&local_m->desc.transport, &ID_RTP_SAVP) == 0) {
si->proto = PJMEDIA_TP_PROTO_RTP_SAVP;
} else {
si->proto = PJMEDIA_TP_PROTO_UNKNOWN;
return PJ_SUCCESS;
}
/* Check address family in remote SDP */
rem_af = pj_AF_UNSPEC();
if (pj_stricmp(&rem_conn->net_type, &ID_IN)==0) {
if (pj_stricmp(&rem_conn->addr_type, &ID_IP4)==0) {
rem_af = pj_AF_INET();
} else if (pj_stricmp(&rem_conn->addr_type, &ID_IP6)==0) {
rem_af = pj_AF_INET6();
}
}
if (rem_af==pj_AF_UNSPEC()) {
/* Unsupported address family */
return PJ_EAFNOTSUP;
}
/* Set remote address: */
status = pj_sockaddr_init(rem_af, &si->rem_addr, &rem_conn->addr,
rem_m->desc.port);
if (status != PJ_SUCCESS) {
/* Invalid IP address. */
return PJMEDIA_EINVALIDIP;
}
/* Check address family of local info */
local_af = pj_AF_UNSPEC();
if (pj_stricmp(&local_conn->net_type, &ID_IN)==0) {
if (pj_stricmp(&local_conn->addr_type, &ID_IP4)==0) {
local_af = pj_AF_INET();
} else if (pj_stricmp(&local_conn->addr_type, &ID_IP6)==0) {
local_af = pj_AF_INET6();
}
}
if (local_af==pj_AF_UNSPEC()) {
/* Unsupported address family */
return PJ_SUCCESS;
}
/* Set remote address: */
status = pj_sockaddr_init(local_af, &local_addr, &local_conn->addr,
local_m->desc.port);
if (status != PJ_SUCCESS) {
/* Invalid IP address. */
return PJMEDIA_EINVALIDIP;
}
/* Local and remote address family must match */
if (local_af != rem_af)
return PJ_EAFNOTSUP;
/* Media direction: */
if (local_m->desc.port == 0 ||
pj_sockaddr_has_addr(&local_addr)==PJ_FALSE ||
pj_sockaddr_has_addr(&si->rem_addr)==PJ_FALSE ||
pjmedia_sdp_media_find_attr(local_m, &STR_INACTIVE, NULL)!=NULL)
{
/* Inactive stream. */
si->dir = PJMEDIA_DIR_NONE;
} else if (pjmedia_sdp_media_find_attr(local_m, &STR_SENDONLY, NULL)!=NULL) {
/* Send only stream. */
si->dir = PJMEDIA_DIR_ENCODING;
} else if (pjmedia_sdp_media_find_attr(local_m, &STR_RECVONLY, NULL)!=NULL) {
/* Recv only stream. */
si->dir = PJMEDIA_DIR_DECODING;
} else {
/* Send and receive stream. */
si->dir = PJMEDIA_DIR_ENCODING_DECODING;
}
/* No need to do anything else if stream is rejected */
if (local_m->desc.port == 0) {
return PJ_SUCCESS;
}
/* If "rtcp" attribute is present in the SDP, set the RTCP address
* from that attribute. Otherwise, calculate from RTP address.
*/
attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
"rtcp", NULL);
if (attr) {
pjmedia_sdp_rtcp_attr rtcp;
status = pjmedia_sdp_attr_get_rtcp(attr, &rtcp);
if (status == PJ_SUCCESS) {
if (rtcp.addr.slen) {
status = pj_sockaddr_init(rem_af, &si->rem_rtcp, &rtcp.addr,
(pj_uint16_t)rtcp.port);
} else {
pj_sockaddr_init(rem_af, &si->rem_rtcp, NULL,
(pj_uint16_t)rtcp.port);
pj_memcpy(pj_sockaddr_get_addr(&si->rem_rtcp),
pj_sockaddr_get_addr(&si->rem_addr),
pj_sockaddr_get_addr_len(&si->rem_addr));
}
}
}
if (!pj_sockaddr_has_addr(&si->rem_rtcp)) {
int rtcp_port;
pj_memcpy(&si->rem_rtcp, &si->rem_addr, sizeof(pj_sockaddr));
rtcp_port = pj_sockaddr_get_port(&si->rem_addr) + 1;
pj_sockaddr_set_port(&si->rem_rtcp, (pj_uint16_t)rtcp_port);
}
/* Get the payload number for receive channel. */
/*
Previously we used to rely on fmt[0] being the selected codec,
but some UA sends telephone-event as fmt[0] and this would
cause assert failure below.
Thanks Chris Hamilton <chamilton .at. cs.dal.ca> for this patch.
// And codec must be numeric!
if (!pj_isdigit(*local_m->desc.fmt[0].ptr) ||
!pj_isdigit(*rem_m->desc.fmt[0].ptr))
{
return PJMEDIA_EINVALIDPT;
}
pt = pj_strtoul(&local_m->desc.fmt[0]);
pj_assert(PJMEDIA_RTP_PT_TELEPHONE_EVENTS==0 ||
pt != PJMEDIA_RTP_PT_TELEPHONE_EVENTS);
*/
/* This is to suppress MSVC warning about uninitialized var */
pt = 0;
/* Find the first codec which is not telephone-event */
for ( fmti = 0; fmti < local_m->desc.fmt_count; ++fmti ) {
if ( !pj_isdigit(*local_m->desc.fmt[fmti].ptr) )
return PJMEDIA_EINVALIDPT;
pt = pj_strtoul(&local_m->desc.fmt[fmti]);
if ( PJMEDIA_RTP_PT_TELEPHONE_EVENTS == 0 ||
pt != PJMEDIA_RTP_PT_TELEPHONE_EVENTS )
break;
}
if ( fmti >= local_m->desc.fmt_count )
return PJMEDIA_EINVALIDPT;
/* Get codec info.
* For static payload types, get the info from codec manager.
* For dynamic payload types, MUST get the rtpmap.
*/
if (pt < 96) {
pj_bool_t has_rtpmap;
rtpmap = NULL;
has_rtpmap = PJ_TRUE;
attr = pjmedia_sdp_media_find_attr(local_m, &ID_RTPMAP,
&local_m->desc.fmt[fmti]);
if (attr == NULL) {
has_rtpmap = PJ_FALSE;
}
if (attr != NULL) {
status = pjmedia_sdp_attr_to_rtpmap(pool, attr, &rtpmap);
if (status != PJ_SUCCESS)
has_rtpmap = PJ_FALSE;
}
/* Build codec format info: */
if (has_rtpmap) {
si->fmt.type = si->type;
si->fmt.pt = pj_strtoul(&local_m->desc.fmt[fmti]);
pj_strdup(pool, &si->fmt.encoding_name, &rtpmap->enc_name);
si->fmt.clock_rate = rtpmap->clock_rate;
#if defined(PJMEDIA_HANDLE_G722_MPEG_BUG) && (PJMEDIA_HANDLE_G722_MPEG_BUG != 0)
/* The session info should have the actual clock rate, because
* this info is used for calculationg buffer size, etc in stream
*/
if (si->fmt.pt == PJMEDIA_RTP_PT_G722)
si->fmt.clock_rate = 16000;
#endif
/* For audio codecs, rtpmap parameters denotes the number of
* channels.
*/
if (si->type == PJMEDIA_TYPE_AUDIO && rtpmap->param.slen) {
si->fmt.channel_cnt = (unsigned) pj_strtoul(&rtpmap->param);
} else {
si->fmt.channel_cnt = 1;
}
} else {
const pjmedia_codec_info *p_info;
status = pjmedia_codec_mgr_get_codec_info( mgr, pt, &p_info);
if (status != PJ_SUCCESS)
return status;
pj_memcpy(&si->fmt, p_info, sizeof(pjmedia_codec_info));
}
/* For static payload type, pt's are symetric */
si->tx_pt = pt;
} else {
attr = pjmedia_sdp_media_find_attr(local_m, &ID_RTPMAP,
&local_m->desc.fmt[fmti]);
if (attr == NULL)
return PJMEDIA_EMISSINGRTPMAP;
status = pjmedia_sdp_attr_to_rtpmap(pool, attr, &rtpmap);
if (status != PJ_SUCCESS)
return status;
/* Build codec format info: */
si->fmt.type = si->type;
si->fmt.pt = pj_strtoul(&local_m->desc.fmt[fmti]);
pj_strdup(pool, &si->fmt.encoding_name, &rtpmap->enc_name);
si->fmt.clock_rate = rtpmap->clock_rate;
/* For audio codecs, rtpmap parameters denotes the number of
* channels.
*/
if (si->type == PJMEDIA_TYPE_AUDIO && rtpmap->param.slen) {
si->fmt.channel_cnt = (unsigned) pj_strtoul(&rtpmap->param);
} else {
si->fmt.channel_cnt = 1;
}
/* Determine payload type for outgoing channel, by finding
* dynamic payload type in remote SDP that matches the answer.
*/
si->tx_pt = 0xFFFF;
for (i=0; i<rem_m->desc.fmt_count; ++i) {
unsigned rpt;
pjmedia_sdp_attr *r_attr;
pjmedia_sdp_rtpmap r_rtpmap;
rpt = pj_strtoul(&rem_m->desc.fmt[i]);
if (rpt < 96)
continue;
r_attr = pjmedia_sdp_media_find_attr(rem_m, &ID_RTPMAP,
&rem_m->desc.fmt[i]);
if (!r_attr)
continue;
if (pjmedia_sdp_attr_get_rtpmap(r_attr, &r_rtpmap) != PJ_SUCCESS)
continue;
if (!pj_stricmp(&rtpmap->enc_name, &r_rtpmap.enc_name) &&
rtpmap->clock_rate == r_rtpmap.clock_rate)
{
/* Found matched codec. */
si->tx_pt = rpt;
break;
}
}
if (si->tx_pt == 0xFFFF)
return PJMEDIA_EMISSINGRTPMAP;
}
/* Now that we have codec info, get the codec param. */
si->param = PJ_POOL_ALLOC_T(pool, pjmedia_codec_param);
status = pjmedia_codec_mgr_get_default_param(mgr, &si->fmt, si->param);
/* Get remote fmtp for our encoder. */
parse_fmtp(pool, rem_m, si->tx_pt, &si->param->setting.enc_fmtp);
/* Get local fmtp for our decoder. */
parse_fmtp(pool, local_m, si->fmt.pt, &si->param->setting.dec_fmtp);
/* Get remote maxptime for our encoder. */
attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
"maxptime", NULL);
if (attr) {
pj_str_t tmp_val = attr->value;
pj_strltrim(&tmp_val);
si->tx_maxptime = pj_strtoul(&tmp_val);
}
/* When direction is NONE (it means SDP negotiation has failed) we don't
* need to return a failure here, as returning failure will cause
* the whole SDP to be rejected. See ticket #:
* http://
*
* Thanks Alain Totouom
*/
if (status != PJ_SUCCESS && si->dir != PJMEDIA_DIR_NONE)
return status;
/* Get incomming payload type for telephone-events */
si->rx_event_pt = -1;
for (i=0; i<local_m->attr_count; ++i) {
pjmedia_sdp_rtpmap r;
attr = local_m->attr[i];
if (pj_strcmp(&attr->name, &ID_RTPMAP) != 0)
continue;
if (pjmedia_sdp_attr_get_rtpmap(attr, &r) != PJ_SUCCESS)
continue;
if (pj_strcmp(&r.enc_name, &ID_TELEPHONE_EVENT) == 0) {
si->rx_event_pt = pj_strtoul(&r.pt);
break;
}
}
/* Get outgoing payload type for telephone-events */
si->tx_event_pt = -1;
for (i=0; i<rem_m->attr_count; ++i) {
pjmedia_sdp_rtpmap r;
attr = rem_m->attr[i];
if (pj_strcmp(&attr->name, &ID_RTPMAP) != 0)
continue;
if (pjmedia_sdp_attr_get_rtpmap(attr, &r) != PJ_SUCCESS)
continue;
if (pj_strcmp(&r.enc_name, &ID_TELEPHONE_EVENT) == 0) {
si->tx_event_pt = pj_strtoul(&r.pt);
break;
}
}
/* Leave SSRC to random. */
si->ssrc = pj_rand();
/* Set default jitter buffer parameter. */
si->jb_init = si->jb_max = si->jb_min_pre = si->jb_max_pre = -1;
return PJ_SUCCESS;
}
/* Start socket. */
PJ_DEF(pj_status_t) pj_stun_sock_start( pj_stun_sock *stun_sock,
const pj_str_t *domain,
pj_uint16_t default_port,
pj_dns_resolver *resolver)
{
pj_status_t status;
PJ_ASSERT_RETURN(stun_sock && domain && default_port, PJ_EINVAL);
pj_grp_lock_acquire(stun_sock->grp_lock);
/* Check whether the domain contains IP address */
stun_sock->srv_addr.addr.sa_family = (pj_uint16_t)stun_sock->af;
status = pj_inet_pton(stun_sock->af, domain,
pj_sockaddr_get_addr(&stun_sock->srv_addr));
if (status != PJ_SUCCESS) {
stun_sock->srv_addr.addr.sa_family = (pj_uint16_t)0;
}
/* If resolver is set, try to resolve with DNS SRV first. It
* will fallback to DNS A/AAAA when no SRV record is found.
*/
if (status != PJ_SUCCESS && resolver) {
const pj_str_t res_name = pj_str("_stun._udp.");
unsigned opt;
pj_assert(stun_sock->q == NULL);
opt = PJ_DNS_SRV_FALLBACK_A;
if (stun_sock->af == pj_AF_INET6()) {
opt |= (PJ_DNS_SRV_RESOLVE_AAAA | PJ_DNS_SRV_FALLBACK_AAAA);
}
status = pj_dns_srv_resolve(domain, &res_name, default_port,
stun_sock->pool, resolver, opt,
stun_sock, &dns_srv_resolver_cb,
&stun_sock->q);
/* Processing will resume when the DNS SRV callback is called */
} else {
if (status != PJ_SUCCESS) {
pj_addrinfo ai;
unsigned cnt = 1;
status = pj_getaddrinfo(stun_sock->af, domain, &cnt, &ai);
if (status != PJ_SUCCESS)
return status;
pj_sockaddr_cp(&stun_sock->srv_addr, &ai.ai_addr);
}
pj_sockaddr_set_port(&stun_sock->srv_addr, (pj_uint16_t)default_port);
/* Start sending Binding request */
status = get_mapped_addr(stun_sock);
}
pj_grp_lock_release(stun_sock->grp_lock);
return status;
}
/*
* Create stream info from SDP media line.
*/
PJ_DEF(pj_status_t) pjmedia_stream_info_from_sdp(
pjmedia_stream_info *si,
pj_pool_t *pool,
pjmedia_endpt *endpt,
const pjmedia_sdp_session *local,
const pjmedia_sdp_session *remote,
unsigned stream_idx)
{
const pj_str_t STR_INACTIVE = { "inactive", 8 };
const pj_str_t STR_SENDONLY = { "sendonly", 8 };
const pj_str_t STR_RECVONLY = { "recvonly", 8 };
pjmedia_codec_mgr *mgr;
const pjmedia_sdp_attr *attr;
const pjmedia_sdp_media *local_m;
const pjmedia_sdp_media *rem_m;
const pjmedia_sdp_conn *local_conn;
const pjmedia_sdp_conn *rem_conn;
int rem_af, local_af;
pj_sockaddr local_addr;
pj_status_t status;
/* Validate arguments: */
PJ_ASSERT_RETURN(pool && si && local && remote, PJ_EINVAL);
PJ_ASSERT_RETURN(stream_idx < local->media_count, PJ_EINVAL);
PJ_ASSERT_RETURN(stream_idx < remote->media_count, PJ_EINVAL);
/* Keep SDP shortcuts */
local_m = local->media[stream_idx];
rem_m = remote->media[stream_idx];
local_conn = local_m->conn ? local_m->conn : local->conn;
if (local_conn == NULL)
return PJMEDIA_SDP_EMISSINGCONN;
rem_conn = rem_m->conn ? rem_m->conn : remote->conn;
if (rem_conn == NULL)
return PJMEDIA_SDP_EMISSINGCONN;
/* Media type must be audio */
if (pj_stricmp(&local_m->desc.media, &ID_AUDIO) != 0)
return PJMEDIA_EINVALIMEDIATYPE;
/* Get codec manager. */
mgr = pjmedia_endpt_get_codec_mgr(endpt);
/* Reset: */
pj_bzero(si, sizeof(*si));
#if PJMEDIA_HAS_RTCP_XR && PJMEDIA_STREAM_ENABLE_XR
/* Set default RTCP XR enabled/disabled */
si->rtcp_xr_enabled = PJ_TRUE;
#endif
/* Media type: */
si->type = PJMEDIA_TYPE_AUDIO;
/* Transport protocol */
/* At this point, transport type must be compatible,
* the transport instance will do more validation later.
*/
status = pjmedia_sdp_transport_cmp(&rem_m->desc.transport,
&local_m->desc.transport);
if (status != PJ_SUCCESS)
return PJMEDIA_SDPNEG_EINVANSTP;
if (pj_stricmp(&local_m->desc.transport, &ID_RTP_AVP) == 0) {
si->proto = PJMEDIA_TP_PROTO_RTP_AVP;
} else if (pj_stricmp(&local_m->desc.transport, &ID_RTP_SAVP) == 0) {
si->proto = PJMEDIA_TP_PROTO_RTP_SAVP;
} else {
si->proto = PJMEDIA_TP_PROTO_UNKNOWN;
return PJ_SUCCESS;
}
/* Check address family in remote SDP */
rem_af = pj_AF_UNSPEC();
if (pj_stricmp(&rem_conn->net_type, &ID_IN)==0) {
if (pj_stricmp(&rem_conn->addr_type, &ID_IP4)==0) {
rem_af = pj_AF_INET();
} else if (pj_stricmp(&rem_conn->addr_type, &ID_IP6)==0) {
rem_af = pj_AF_INET6();
}
}
if (rem_af==pj_AF_UNSPEC()) {
/* Unsupported address family */
return PJ_EAFNOTSUP;
}
/* Set remote address: */
status = pj_sockaddr_init(rem_af, &si->rem_addr, &rem_conn->addr,
rem_m->desc.port);
if (status != PJ_SUCCESS) {
/* Invalid IP address. */
return PJMEDIA_EINVALIDIP;
}
/* Check address family of local info */
local_af = pj_AF_UNSPEC();
if (pj_stricmp(&local_conn->net_type, &ID_IN)==0) {
if (pj_stricmp(&local_conn->addr_type, &ID_IP4)==0) {
local_af = pj_AF_INET();
} else if (pj_stricmp(&local_conn->addr_type, &ID_IP6)==0) {
local_af = pj_AF_INET6();
}
}
if (local_af==pj_AF_UNSPEC()) {
/* Unsupported address family */
return PJ_SUCCESS;
}
/* Set remote address: */
status = pj_sockaddr_init(local_af, &local_addr, &local_conn->addr,
local_m->desc.port);
if (status != PJ_SUCCESS) {
/* Invalid IP address. */
return PJMEDIA_EINVALIDIP;
}
/* Local and remote address family must match */
if (local_af != rem_af)
return PJ_EAFNOTSUP;
/* Media direction: */
if (local_m->desc.port == 0 ||
pj_sockaddr_has_addr(&local_addr)==PJ_FALSE ||
pj_sockaddr_has_addr(&si->rem_addr)==PJ_FALSE ||
pjmedia_sdp_media_find_attr(local_m, &STR_INACTIVE, NULL)!=NULL)
{
/* Inactive stream. */
si->dir = PJMEDIA_DIR_NONE;
} else if (pjmedia_sdp_media_find_attr(local_m, &STR_SENDONLY, NULL)!=NULL) {
/* Send only stream. */
si->dir = PJMEDIA_DIR_ENCODING;
} else if (pjmedia_sdp_media_find_attr(local_m, &STR_RECVONLY, NULL)!=NULL) {
/* Recv only stream. */
si->dir = PJMEDIA_DIR_DECODING;
} else {
/* Send and receive stream. */
si->dir = PJMEDIA_DIR_ENCODING_DECODING;
}
/* No need to do anything else if stream is rejected */
if (local_m->desc.port == 0) {
return PJ_SUCCESS;
}
/* If "rtcp" attribute is present in the SDP, set the RTCP address
* from that attribute. Otherwise, calculate from RTP address.
*/
attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
"rtcp", NULL);
if (attr) {
pjmedia_sdp_rtcp_attr rtcp;
status = pjmedia_sdp_attr_get_rtcp(attr, &rtcp);
if (status == PJ_SUCCESS) {
if (rtcp.addr.slen) {
status = pj_sockaddr_init(rem_af, &si->rem_rtcp, &rtcp.addr,
(pj_uint16_t)rtcp.port);
} else {
pj_sockaddr_init(rem_af, &si->rem_rtcp, NULL,
(pj_uint16_t)rtcp.port);
pj_memcpy(pj_sockaddr_get_addr(&si->rem_rtcp),
pj_sockaddr_get_addr(&si->rem_addr),
pj_sockaddr_get_addr_len(&si->rem_addr));
}
}
}
if (!pj_sockaddr_has_addr(&si->rem_rtcp)) {
int rtcp_port;
pj_memcpy(&si->rem_rtcp, &si->rem_addr, sizeof(pj_sockaddr));
rtcp_port = pj_sockaddr_get_port(&si->rem_addr) + 1;
pj_sockaddr_set_port(&si->rem_rtcp, (pj_uint16_t)rtcp_port);
}
/* Get the payload number for receive channel. */
/*
Previously we used to rely on fmt[0] being the selected codec,
but some UA sends telephone-event as fmt[0] and this would
cause assert failure below.
Thanks Chris Hamilton <chamilton .at. cs.dal.ca> for this patch.
// And codec must be numeric!
if (!pj_isdigit(*local_m->desc.fmt[0].ptr) ||
!pj_isdigit(*rem_m->desc.fmt[0].ptr))
{
return PJMEDIA_EINVALIDPT;
}
pt = pj_strtoul(&local_m->desc.fmt[0]);
pj_assert(PJMEDIA_RTP_PT_TELEPHONE_EVENTS==0 ||
pt != PJMEDIA_RTP_PT_TELEPHONE_EVENTS);
*/
/* Get codec info and param */
status = get_audio_codec_info_param(si, pool, mgr, local_m, rem_m);
/* Leave SSRC to random. */
si->ssrc = pj_rand();
/* Set default jitter buffer parameter. */
si->jb_init = si->jb_max = si->jb_min_pre = si->jb_max_pre = -1;
return status;
}
/*
* udp_on_read_complete()
*
* This is callback notification from ioqueue that a pending recvfrom()
* operation has completed.
*/
static void udp_on_read_complete( pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
pj_ssize_t bytes_read)
{
/* See https://trac.pjsip.org/repos/ticket/1197 */
enum { MAX_IMMEDIATE_PACKET = 50 };
pjsip_rx_data_op_key *rdata_op_key = (pjsip_rx_data_op_key*) op_key;
pjsip_rx_data *rdata = rdata_op_key->rdata;
struct udp_transport *tp = (struct udp_transport*)rdata->tp_info.transport;
int i;
pj_status_t status;
/* Don't do anything if transport is closing. */
if (tp->is_closing) {
tp->is_closing++;
return;
}
/* Don't do anything if transport is being paused. */
if (tp->is_paused)
return;
/*
* The idea of the loop is to process immediate data received by
* pj_ioqueue_recvfrom(), as long as i < MAX_IMMEDIATE_PACKET. When
* i is >= MAX_IMMEDIATE_PACKET, we force the recvfrom() operation to
* complete asynchronously, to allow other sockets to get their data.
*/
for (i=0;; ++i) {
enum { MIN_SIZE = 32 };
pj_uint32_t flags;
/* Report the packet to transport manager. Only do so if packet size
* is relatively big enough for a SIP packet.
*/
if (bytes_read > MIN_SIZE) {
pj_ssize_t size_eaten;
const pj_sockaddr *src_addr = &rdata->pkt_info.src_addr;
/* Init pkt_info part. */
rdata->pkt_info.len = bytes_read;
rdata->pkt_info.zero = 0;
pj_gettimeofday(&rdata->pkt_info.timestamp);
if (src_addr->addr.sa_family == pj_AF_INET()) {
pj_ansi_strcpy(rdata->pkt_info.src_name,
pj_inet_ntoa(src_addr->ipv4.sin_addr));
rdata->pkt_info.src_port = pj_ntohs(src_addr->ipv4.sin_port);
} else {
pj_inet_ntop(pj_AF_INET6(),
pj_sockaddr_get_addr(&rdata->pkt_info.src_addr),
rdata->pkt_info.src_name,
sizeof(rdata->pkt_info.src_name));
rdata->pkt_info.src_port = pj_ntohs(src_addr->ipv6.sin6_port);
}
size_eaten =
pjsip_tpmgr_receive_packet(rdata->tp_info.transport->tpmgr,
rdata);
if (size_eaten < 0) {
pj_assert(!"It shouldn't happen!");
size_eaten = rdata->pkt_info.len;
}
/* Since this is UDP, the whole buffer is the message. */
rdata->pkt_info.len = 0;
} else if (bytes_read <= MIN_SIZE) {
/* TODO: */
} else if (-bytes_read != PJ_STATUS_FROM_OS(OSERR_EWOULDBLOCK) &&
-bytes_read != PJ_STATUS_FROM_OS(OSERR_EINPROGRESS) &&
-bytes_read != PJ_STATUS_FROM_OS(OSERR_ECONNRESET))
{
/* Report error to endpoint. */
PJSIP_ENDPT_LOG_ERROR((rdata->tp_info.transport->endpt,
rdata->tp_info.transport->obj_name,
(pj_status_t)-bytes_read,
"Warning: pj_ioqueue_recvfrom()"
" callback error"));
}
if (i >= MAX_IMMEDIATE_PACKET) {
/* Force ioqueue_recvfrom() to return PJ_EPENDING */
flags = PJ_IOQUEUE_ALWAYS_ASYNC;
} else {
flags = 0;
}
/* Reset pool.
* Need to copy rdata fields to temp variable because they will
* be invalid after pj_pool_reset().
*/
{
pj_pool_t *rdata_pool = rdata->tp_info.pool;
struct udp_transport *rdata_tp ;
unsigned rdata_index;
rdata_tp = (struct udp_transport*)rdata->tp_info.transport;
rdata_index = (unsigned)(unsigned long)(pj_ssize_t)
rdata->tp_info.tp_data;
pj_pool_reset(rdata_pool);
init_rdata(rdata_tp, rdata_index, rdata_pool, &rdata);
/* Change some vars to point to new location after
* pool reset.
*/
op_key = &rdata->tp_info.op_key.op_key;
}
/* Only read next packet if transport is not being paused. This
* check handles the case where transport is paused while endpoint
* is still processing a SIP message.
*/
if (tp->is_paused)
return;
/* Read next packet. */
bytes_read = sizeof(rdata->pkt_info.packet);
rdata->pkt_info.src_addr_len = sizeof(rdata->pkt_info.src_addr);
status = pj_ioqueue_recvfrom(key, op_key,
rdata->pkt_info.packet,
&bytes_read, flags,
&rdata->pkt_info.src_addr,
&rdata->pkt_info.src_addr_len);
if (status == PJ_SUCCESS) {
/* Continue loop. */
pj_assert(i < MAX_IMMEDIATE_PACKET);
} else if (status == PJ_EPENDING) {
break;
} else {
if (i < MAX_IMMEDIATE_PACKET) {
/* Report error to endpoint if this is not EWOULDBLOCK error.*/
if (status != PJ_STATUS_FROM_OS(OSERR_EWOULDBLOCK) &&
status != PJ_STATUS_FROM_OS(OSERR_EINPROGRESS) &&
status != PJ_STATUS_FROM_OS(OSERR_ECONNRESET))
{
PJSIP_ENDPT_LOG_ERROR((rdata->tp_info.transport->endpt,
rdata->tp_info.transport->obj_name,
status,
"Warning: pj_ioqueue_recvfrom"));
}
/* Continue loop. */
bytes_read = 0;
} else {
/* This is fatal error.
* Ioqueue operation will stop for this transport!
*/
PJSIP_ENDPT_LOG_ERROR((rdata->tp_info.transport->endpt,
rdata->tp_info.transport->obj_name,
status,
"FATAL: pj_ioqueue_recvfrom() error, "
"UDP transport stopping! Error"));
break;
}
}
}
}
/* main()
*
* If called with argument, treat argument as SIP URL to be called.
* Otherwise wait for incoming calls.
*/
int main(int argc, char *argv[])
{
struct pj_getopt_option long_options[] = {
{ "local-port", 1, 0, 'p' },
{ "tcp", 0, 0, 't' },
{ "ipv6", 0, 0, '6' },
{ "help", 0, 0, 'h' }
};
int c, option_index;
pj_log_set_level(5);
pj_init();
sip_af = pj_AF_INET();
pj_optind = 0;
while ((c = pj_getopt_long(argc, argv, "p:t6h", long_options,
&option_index)) != -1)
{
switch (c) {
case 'p':
sip_port = atoi(pj_optarg);
break;
case 't':
sip_tcp = PJ_TRUE;
break;
case 'h':
usage();
return 0;
case '6':
sip_af = pj_AF_INET6();
break;
default:
PJ_LOG(1,(THIS_FILE,
"Argument \"%s\" is not valid. Use --help to see help",
argv[pj_optind-1]));
return -1;
}
}
if (init_stack())
goto on_error;
/* If URL is specified, then make call immediately. */
if (pj_optind != argc) {
pj_sockaddr hostaddr;
char hostip[PJ_INET6_ADDRSTRLEN+2];
char temp[80];
call_t *call;
pj_str_t dst_uri = pj_str(argv[pj_optind]);
pj_str_t local_uri;
pjsip_dialog *dlg;
pj_status_t status;
pjsip_tx_data *tdata;
if (pj_gethostip(sip_af, &hostaddr) != PJ_SUCCESS) {
PJ_LOG(1,(THIS_FILE, "Unable to retrieve local host IP"));
goto on_error;
}
pj_sockaddr_print(&hostaddr, hostip, sizeof(hostip), 2);
pj_ansi_sprintf(temp, "<sip:sipecho@%s:%d>",
hostip, sip_port);
local_uri = pj_str(temp);
call = &app.call[0];
status = pjsip_dlg_create_uac( pjsip_ua_instance(),
&local_uri, /* local URI */
&local_uri, /* local Contact */
&dst_uri, /* remote URI */
&dst_uri, /* remote target */
&dlg); /* dialog */
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to create UAC dialog", status);
return 1;
}
status = pjsip_inv_create_uac( dlg, NULL, 0, &call->inv);
if (status != PJ_SUCCESS) goto on_error;
call->inv->mod_data[mod_sipecho.id] = call;
status = pjsip_inv_invite(call->inv, &tdata);
if (status != PJ_SUCCESS) goto on_error;
status = pjsip_inv_send_msg(call->inv, tdata);
if (status != PJ_SUCCESS) goto on_error;
puts("Press ENTER to quit...");
} else {
puts("Ready for incoming calls. Press ENTER to quit...");
}
for (;;) {
char s[10];
printf("\nMenu:\n"
" h Hangup all calls\n"
" l %s message logging\n"
" q Quit\n",
(app.enable_msg_logging? "Disable" : "Enable"));
if (fgets(s, sizeof(s), stdin) == NULL)
continue;
if (s[0]=='q')
break;
switch (s[0]) {
case 'l':
app.enable_msg_logging = !app.enable_msg_logging;
break;
case 'h':
hangup_all();
break;
}
}
destroy_stack();
puts("Bye bye..");
return 0;
on_error:
puts("An error has occurred. run a debugger..");
return 1;
}
/*
* Create.
*/
PJ_DEF(pj_status_t) pj_turn_sock_create(pj_stun_config *cfg,
int af,
pj_turn_tp_type conn_type,
const pj_turn_sock_cb *cb,
const pj_turn_sock_cfg *setting,
void *user_data,
pj_turn_sock **p_turn_sock)
{
pj_turn_sock *turn_sock;
pj_turn_session_cb sess_cb;
pj_turn_sock_cfg default_setting;
pj_pool_t *pool;
const char *name_tmpl;
pj_status_t status;
PJ_ASSERT_RETURN(cfg && p_turn_sock, PJ_EINVAL);
PJ_ASSERT_RETURN(af==pj_AF_INET() || af==pj_AF_INET6(), PJ_EINVAL);
PJ_ASSERT_RETURN(conn_type!=PJ_TURN_TP_TCP || PJ_HAS_TCP, PJ_EINVAL);
if (!setting) {
pj_turn_sock_cfg_default(&default_setting);
setting = &default_setting;
}
switch (conn_type) {
case PJ_TURN_TP_UDP:
name_tmpl = "udprel%p";
break;
case PJ_TURN_TP_TCP:
name_tmpl = "tcprel%p";
break;
default:
PJ_ASSERT_RETURN(!"Invalid TURN conn_type", PJ_EINVAL);
name_tmpl = "tcprel%p";
break;
}
/* Create and init basic data structure */
pool = pj_pool_create(cfg->pf, name_tmpl, PJNATH_POOL_LEN_TURN_SOCK,
PJNATH_POOL_INC_TURN_SOCK, NULL);
turn_sock = PJ_POOL_ZALLOC_T(pool, pj_turn_sock);
turn_sock->pool = pool;
turn_sock->obj_name = pool->obj_name;
turn_sock->user_data = user_data;
turn_sock->af = af;
turn_sock->conn_type = conn_type;
/* Copy STUN config (this contains ioqueue, timer heap, etc.) */
pj_memcpy(&turn_sock->cfg, cfg, sizeof(*cfg));
/* Copy setting (QoS parameters etc */
pj_memcpy(&turn_sock->setting, setting, sizeof(*setting));
/* Set callback */
if (cb) {
pj_memcpy(&turn_sock->cb, cb, sizeof(*cb));
}
/* Session lock */
if (setting && setting->grp_lock) {
turn_sock->grp_lock = setting->grp_lock;
} else {
status = pj_grp_lock_create(pool, NULL, &turn_sock->grp_lock);
if (status != PJ_SUCCESS) {
pj_pool_release(pool);
return status;
}
}
pj_grp_lock_add_ref(turn_sock->grp_lock);
pj_grp_lock_add_handler(turn_sock->grp_lock, pool, turn_sock,
&turn_sock_on_destroy);
/* Init timer */
pj_timer_entry_init(&turn_sock->timer, TIMER_NONE, turn_sock, &timer_cb);
/* Init TURN session */
pj_bzero(&sess_cb, sizeof(sess_cb));
sess_cb.on_send_pkt = &turn_on_send_pkt;
sess_cb.on_channel_bound = &turn_on_channel_bound;
sess_cb.on_rx_data = &turn_on_rx_data;
sess_cb.on_state = &turn_on_state;
status = pj_turn_session_create(cfg, pool->obj_name, af, conn_type,
turn_sock->grp_lock, &sess_cb, 0,
turn_sock, &turn_sock->sess);
if (status != PJ_SUCCESS) {
destroy(turn_sock);
return status;
}
/* Note: socket and ioqueue will be created later once the TURN server
* has been resolved.
*/
*p_turn_sock = turn_sock;
return PJ_SUCCESS;
}
/*
* main()
*
* If called with argument, treat argument as SIP URL to be called.
* Otherwise wait for incoming calls.
*/
int main(int argc, char *argv[])
{
pj_pool_t *pool = NULL;
pj_status_t status;
unsigned i;
/* Must init PJLIB first: */
status = pj_init();
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
pj_log_set_level(5);
/* Then init PJLIB-UTIL: */
status = pjlib_util_init();
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Must create a pool factory before we can allocate any memory. */
pj_caching_pool_init(&cp, &pj_pool_factory_default_policy, 0);
/* Create global endpoint: */
{
const pj_str_t *hostname;
const char *endpt_name;
/* Endpoint MUST be assigned a globally unique name.
* The name will be used as the hostname in Warning header.
*/
/* For this implementation, we'll use hostname for simplicity */
hostname = pj_gethostname();
endpt_name = hostname->ptr;
/* Create the endpoint: */
status = pjsip_endpt_create(&cp.factory, endpt_name,
&g_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
}
/*
* Add UDP transport, with hard-coded port
* Alternatively, application can use pjsip_udp_transport_attach() to
* start UDP transport, if it already has an UDP socket (e.g. after it
* resolves the address with STUN).
*/
{
pj_sockaddr addr;
pj_sockaddr_init(AF, &addr, NULL, (pj_uint16_t)SIP_PORT);
if (AF == pj_AF_INET()) {
status = pjsip_udp_transport_start( g_endpt, &addr.ipv4, NULL,
1, NULL);
} else if (AF == pj_AF_INET6()) {
status = pjsip_udp_transport_start6(g_endpt, &addr.ipv6, NULL,
1, NULL);
} else {
status = PJ_EAFNOTSUP;
}
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to start UDP transport", status);
return 1;
}
}
/*
* Init transaction layer.
* This will create/initialize transaction hash tables etc.
*/
status = pjsip_tsx_layer_init_module(g_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/*
* Initialize UA layer module.
* This will create/initialize dialog hash tables etc.
*/
status = pjsip_ua_init_module( g_endpt, NULL );
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/*
* Init invite session module.
* The invite session module initialization takes additional argument,
* i.e. a structure containing callbacks to be called on specific
* occurence of events.
*
* The on_state_changed and on_new_session callbacks are mandatory.
* Application must supply the callback function.
*
* We use on_media_update() callback in this application to start
* media transmission.
*/
{
pjsip_inv_callback inv_cb;
/* Init the callback for INVITE session: */
pj_bzero(&inv_cb, sizeof(inv_cb));
inv_cb.on_state_changed = &call_on_state_changed;
inv_cb.on_new_session = &call_on_forked;
inv_cb.on_media_update = &call_on_media_update;
/* Initialize invite session module: */
status = pjsip_inv_usage_init(g_endpt, &inv_cb);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
}
/* Initialize 100rel support */
status = pjsip_100rel_init_module(g_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, status);
/*
* Register our module to receive incoming requests.
*/
status = pjsip_endpt_register_module( g_endpt, &mod_simpleua);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/*
* Register message logger module.
*/
status = pjsip_endpt_register_module( g_endpt, &msg_logger);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/*
* Initialize media endpoint.
* This will implicitly initialize PJMEDIA too.
*/
#if PJ_HAS_THREADS
status = pjmedia_endpt_create(&cp.factory, NULL, 1, &g_med_endpt);
#else
status = pjmedia_endpt_create(&cp.factory,
pjsip_endpt_get_ioqueue(g_endpt),
0, &g_med_endpt);
#endif
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/*
* Add PCMA/PCMU codec to the media endpoint.
*/
#if defined(PJMEDIA_HAS_G711_CODEC) && PJMEDIA_HAS_G711_CODEC!=0
status = pjmedia_codec_g711_init(g_med_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
#endif
#if defined(PJMEDIA_HAS_VIDEO) && (PJMEDIA_HAS_VIDEO != 0)
/* Init video subsystem */
pool = pjmedia_endpt_create_pool(g_med_endpt, "Video subsystem", 512, 512);
status = pjmedia_video_format_mgr_create(pool, 64, 0, NULL);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
status = pjmedia_converter_mgr_create(pool, NULL);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
status = pjmedia_vid_codec_mgr_create(pool, NULL);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
status = pjmedia_vid_dev_subsys_init(&cp.factory);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
# if defined(PJMEDIA_HAS_FFMPEG_VID_CODEC) && PJMEDIA_HAS_FFMPEG_VID_CODEC!=0
/* Init ffmpeg video codecs */
status = pjmedia_codec_ffmpeg_vid_init(NULL, &cp.factory);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
# endif /* PJMEDIA_HAS_FFMPEG_VID_CODEC */
#endif /* PJMEDIA_HAS_VIDEO */
/*
* Create media transport used to send/receive RTP/RTCP socket.
* One media transport is needed for each call. Application may
* opt to re-use the same media transport for subsequent calls.
*/
for (i = 0; i < PJ_ARRAY_SIZE(g_med_transport); ++i) {
status = pjmedia_transport_udp_create3(g_med_endpt, AF, NULL, NULL,
RTP_PORT + i*2, 0,
&g_med_transport[i]);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to create media transport", status);
return 1;
}
/*
* Get socket info (address, port) of the media transport. We will
* need this info to create SDP (i.e. the address and port info in
* the SDP).
*/
pjmedia_transport_info_init(&g_med_tpinfo[i]);
pjmedia_transport_get_info(g_med_transport[i], &g_med_tpinfo[i]);
pj_memcpy(&g_sock_info[i], &g_med_tpinfo[i].sock_info,
sizeof(pjmedia_sock_info));
}
/*
* If URL is specified, then make call immediately.
*/
if (argc > 1) {
pj_sockaddr hostaddr;
char hostip[PJ_INET6_ADDRSTRLEN+2];
char temp[80];
pj_str_t dst_uri = pj_str(argv[1]);
pj_str_t local_uri;
pjsip_dialog *dlg;
pjmedia_sdp_session *local_sdp;
pjsip_tx_data *tdata;
if (pj_gethostip(AF, &hostaddr) != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to retrieve local host IP", status);
return 1;
}
pj_sockaddr_print(&hostaddr, hostip, sizeof(hostip), 2);
pj_ansi_sprintf(temp, "<sip:simpleuac@%s:%d>",
hostip, SIP_PORT);
local_uri = pj_str(temp);
/* Create UAC dialog */
status = pjsip_dlg_create_uac( pjsip_ua_instance(),
&local_uri, /* local URI */
&local_uri, /* local Contact */
&dst_uri, /* remote URI */
&dst_uri, /* remote target */
&dlg); /* dialog */
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to create UAC dialog", status);
return 1;
}
/* If we expect the outgoing INVITE to be challenged, then we should
* put the credentials in the dialog here, with something like this:
*
{
pjsip_cred_info cred[1];
cred[0].realm = pj_str("sip.server.realm");
cred[0].scheme = pj_str("digest");
cred[0].username = pj_str("theuser");
cred[0].data_type = PJSIP_CRED_DATA_PLAIN_PASSWD;
cred[0].data = pj_str("thepassword");
pjsip_auth_clt_set_credentials( &dlg->auth_sess, 1, cred);
}
*
*/
/* Get the SDP body to be put in the outgoing INVITE, by asking
* media endpoint to create one for us.
*/
status = pjmedia_endpt_create_sdp( g_med_endpt, /* the media endpt */
dlg->pool, /* pool. */
MAX_MEDIA_CNT, /* # of streams */
g_sock_info, /* RTP sock info */
&local_sdp); /* the SDP result */
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Create the INVITE session, and pass the SDP returned earlier
* as the session's initial capability.
*/
status = pjsip_inv_create_uac( dlg, local_sdp, 0, &g_inv);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* If we want the initial INVITE to travel to specific SIP proxies,
* then we should put the initial dialog's route set here. The final
* route set will be updated once a dialog has been established.
* To set the dialog's initial route set, we do it with something
* like this:
*
{
pjsip_route_hdr route_set;
pjsip_route_hdr *route;
const pj_str_t hname = { "Route", 5 };
char *uri = "sip:proxy.server;lr";
pj_list_init(&route_set);
route = pjsip_parse_hdr( dlg->pool, &hname,
uri, strlen(uri),
NULL);
PJ_ASSERT_RETURN(route != NULL, 1);
pj_list_push_back(&route_set, route);
pjsip_dlg_set_route_set(dlg, &route_set);
}
*
* Note that Route URI SHOULD have an ";lr" parameter!
*/
/* Create initial INVITE request.
* This INVITE request will contain a perfectly good request and
* an SDP body as well.
*/
status = pjsip_inv_invite(g_inv, &tdata);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Send initial INVITE request.
* From now on, the invite session's state will be reported to us
* via the invite session callbacks.
*/
status = pjsip_inv_send_msg(g_inv, tdata);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
} else {
/* No URL to make call to */
PJ_LOG(3,(THIS_FILE, "Ready to accept incoming calls..."));
}
/* Loop until one call is completed */
for (;!g_complete;) {
pj_time_val timeout = {0, 10};
pjsip_endpt_handle_events(g_endpt, &timeout);
}
/* On exit, dump current memory usage: */
dump_pool_usage(THIS_FILE, &cp);
/* Destroy audio ports. Destroy the audio port first
* before the stream since the audio port has threads
* that get/put frames to the stream.
*/
if (g_snd_port)
pjmedia_snd_port_destroy(g_snd_port);
#if defined(PJMEDIA_HAS_VIDEO) && (PJMEDIA_HAS_VIDEO != 0)
/* Destroy video ports */
if (g_vid_capturer)
pjmedia_vid_port_destroy(g_vid_capturer);
if (g_vid_renderer)
pjmedia_vid_port_destroy(g_vid_renderer);
#endif
/* Destroy streams */
if (g_med_stream)
pjmedia_stream_destroy(g_med_stream);
#if defined(PJMEDIA_HAS_VIDEO) && (PJMEDIA_HAS_VIDEO != 0)
if (g_med_vstream)
pjmedia_vid_stream_destroy(g_med_vstream);
/* Deinit ffmpeg codec */
# if defined(PJMEDIA_HAS_FFMPEG_VID_CODEC) && PJMEDIA_HAS_FFMPEG_VID_CODEC!=0
pjmedia_codec_ffmpeg_vid_deinit();
# endif
#endif
/* Destroy media transports */
for (i = 0; i < MAX_MEDIA_CNT; ++i) {
if (g_med_transport[i])
pjmedia_transport_close(g_med_transport[i]);
}
/* Deinit pjmedia endpoint */
if (g_med_endpt)
pjmedia_endpt_destroy(g_med_endpt);
/* Deinit pjsip endpoint */
if (g_endpt)
pjsip_endpt_destroy(g_endpt);
/* Release pool */
if (pool)
pj_pool_release(pool);
return 0;
}
/*! \brief Apply handler for transports */
static int transport_apply(const struct ast_sorcery *sorcery, void *obj)
{
struct ast_sip_transport *transport = obj;
RAII_VAR(struct ast_sip_transport *, existing, ast_sorcery_retrieve_by_id(sorcery, "transport", ast_sorcery_object_get_id(obj)), ao2_cleanup);
pj_status_t res = -1;
if (!existing || !existing->state) {
if (!(transport->state = ao2_alloc(sizeof(*transport->state), transport_state_destroy))) {
ast_log(LOG_ERROR, "Transport state for '%s' could not be allocated\n", ast_sorcery_object_get_id(obj));
return -1;
}
} else {
transport->state = existing->state;
ao2_ref(transport->state, +1);
}
/* Once active a transport can not be reconfigured */
if (transport->state->transport || transport->state->factory) {
return -1;
}
if (transport->host.addr.sa_family != PJ_AF_INET && transport->host.addr.sa_family != PJ_AF_INET6) {
ast_log(LOG_ERROR, "Transport '%s' could not be started as binding not specified\n", ast_sorcery_object_get_id(obj));
return -1;
}
/* Set default port if not present */
if (!pj_sockaddr_get_port(&transport->host)) {
pj_sockaddr_set_port(&transport->host, (transport->type == AST_TRANSPORT_TLS) ? 5061 : 5060);
}
/* Now that we know what address family we can set up a dnsmgr refresh for the external media address if present */
if (!ast_strlen_zero(transport->external_signaling_address)) {
if (transport->host.addr.sa_family == pj_AF_INET()) {
transport->external_address.ss.ss_family = AF_INET;
} else if (transport->host.addr.sa_family == pj_AF_INET6()) {
transport->external_address.ss.ss_family = AF_INET6;
} else {
ast_log(LOG_ERROR, "Unknown address family for transport '%s', could not get external signaling address\n",
ast_sorcery_object_get_id(obj));
return -1;
}
if (ast_dnsmgr_lookup(transport->external_signaling_address, &transport->external_address, &transport->external_address_refresher, NULL) < 0) {
ast_log(LOG_ERROR, "Could not create dnsmgr for external signaling address on '%s'\n", ast_sorcery_object_get_id(obj));
return -1;
}
}
if (transport->type == AST_TRANSPORT_UDP) {
if (transport->host.addr.sa_family == pj_AF_INET()) {
res = pjsip_udp_transport_start(ast_sip_get_pjsip_endpoint(), &transport->host.ipv4, NULL, transport->async_operations, &transport->state->transport);
} else if (transport->host.addr.sa_family == pj_AF_INET6()) {
res = pjsip_udp_transport_start6(ast_sip_get_pjsip_endpoint(), &transport->host.ipv6, NULL, transport->async_operations, &transport->state->transport);
}
if (res == PJ_SUCCESS && (transport->tos || transport->cos)) {
pj_sock_t sock;
pj_qos_params qos_params;
sock = pjsip_udp_transport_get_socket(transport->state->transport);
pj_sock_get_qos_params(sock, &qos_params);
set_qos(transport, &qos_params);
pj_sock_set_qos_params(sock, &qos_params);
}
} else if (transport->type == AST_TRANSPORT_TCP) {
pjsip_tcp_transport_cfg cfg;
pjsip_tcp_transport_cfg_default(&cfg, transport->host.addr.sa_family);
cfg.bind_addr = transport->host;
cfg.async_cnt = transport->async_operations;
set_qos(transport, &cfg.qos_params);
res = pjsip_tcp_transport_start3(ast_sip_get_pjsip_endpoint(), &cfg, &transport->state->factory);
} else if (transport->type == AST_TRANSPORT_TLS) {
transport->tls.ca_list_file = pj_str((char*)transport->ca_list_file);
transport->tls.cert_file = pj_str((char*)transport->cert_file);
transport->tls.privkey_file = pj_str((char*)transport->privkey_file);
transport->tls.password = pj_str((char*)transport->password);
set_qos(transport, &transport->tls.qos_params);
res = pjsip_tls_transport_start2(ast_sip_get_pjsip_endpoint(), &transport->tls, &transport->host, NULL, transport->async_operations, &transport->state->factory);
} else if ((transport->type == AST_TRANSPORT_WS) || (transport->type == AST_TRANSPORT_WSS)) {
if (transport->cos || transport->tos) {
ast_log(LOG_WARNING, "TOS and COS values ignored for websocket transport\n");
}
res = PJ_SUCCESS;
}
if (res != PJ_SUCCESS) {
char msg[PJ_ERR_MSG_SIZE];
pjsip_strerror(res, msg, sizeof(msg));
ast_log(LOG_ERROR, "Transport '%s' could not be started: %s\n", ast_sorcery_object_get_id(obj), msg);
return -1;
}
return 0;
}
PJ_DEF(pj_status_t) pjsip_tls_transport_start2( pjsip_endpoint *endpt,
const pjsip_tls_setting *opt,
const pj_sockaddr *local,
const pjsip_host_port *a_name,
unsigned async_cnt,
pjsip_tpfactory **p_factory)
{
pj_pool_t *pool;
pj_bool_t is_ipv6;
int af;
struct tls_listener *listener;
pj_ssl_sock_param ssock_param;
pj_sockaddr *listener_addr;
pj_bool_t has_listener;
pj_status_t status;
/* Sanity check */
PJ_ASSERT_RETURN(endpt && async_cnt, PJ_EINVAL);
is_ipv6 = (local && local->addr.sa_family == pj_AF_INET6());
af = is_ipv6 ? pj_AF_INET6() : pj_AF_INET();
/* Verify that address given in a_name (if any) is valid */
if (a_name && a_name->host.slen) {
pj_sockaddr tmp;
status = pj_sockaddr_init(af, &tmp, &a_name->host,
(pj_uint16_t)a_name->port);
if (status != PJ_SUCCESS || !pj_sockaddr_has_addr(&tmp) ||
(!is_ipv6 && tmp.ipv4.sin_addr.s_addr == PJ_INADDR_NONE))
{
/* Invalid address */
return PJ_EINVAL;
}
}
pool = pjsip_endpt_create_pool(endpt, "tlslis", POOL_LIS_INIT,
POOL_LIS_INC);
PJ_ASSERT_RETURN(pool, PJ_ENOMEM);
listener = PJ_POOL_ZALLOC_T(pool, struct tls_listener);
listener->factory.pool = pool;
if (is_ipv6)
listener->factory.type = PJSIP_TRANSPORT_TLS6;
else
listener->factory.type = PJSIP_TRANSPORT_TLS;
listener->factory.type_name = (char*)
pjsip_transport_get_type_name(listener->factory.type);
listener->factory.flag =
pjsip_transport_get_flag_from_type(listener->factory.type);
pj_ansi_strcpy(listener->factory.obj_name, "tlslis");
if (is_ipv6)
pj_ansi_strcat(listener->factory.obj_name, "6");
if (opt)
pjsip_tls_setting_copy(pool, &listener->tls_setting, opt);
else
pjsip_tls_setting_default(&listener->tls_setting);
status = pj_lock_create_recursive_mutex(pool, listener->factory.obj_name,
&listener->factory.lock);
if (status != PJ_SUCCESS)
goto on_error;
if (async_cnt > MAX_ASYNC_CNT)
async_cnt = MAX_ASYNC_CNT;
/* Build SSL socket param */
pj_ssl_sock_param_default(&ssock_param);
ssock_param.sock_af = af;
ssock_param.cb.on_accept_complete = &on_accept_complete;
ssock_param.cb.on_data_read = &on_data_read;
ssock_param.cb.on_data_sent = &on_data_sent;
ssock_param.async_cnt = async_cnt;
ssock_param.ioqueue = pjsip_endpt_get_ioqueue(endpt);
ssock_param.require_client_cert = listener->tls_setting.require_client_cert;
ssock_param.timeout = listener->tls_setting.timeout;
ssock_param.user_data = listener;
ssock_param.verify_peer = PJ_FALSE; /* avoid SSL socket closing the socket
* due to verification error */
if (ssock_param.send_buffer_size < PJSIP_MAX_PKT_LEN)
ssock_param.send_buffer_size = PJSIP_MAX_PKT_LEN;
if (ssock_param.read_buffer_size < PJSIP_MAX_PKT_LEN)
ssock_param.read_buffer_size = PJSIP_MAX_PKT_LEN;
ssock_param.ciphers_num = listener->tls_setting.ciphers_num;
ssock_param.ciphers = listener->tls_setting.ciphers;
ssock_param.reuse_addr = listener->tls_setting.reuse_addr;
ssock_param.qos_type = listener->tls_setting.qos_type;
ssock_param.qos_ignore_error = listener->tls_setting.qos_ignore_error;
pj_memcpy(&ssock_param.qos_params, &listener->tls_setting.qos_params,
sizeof(ssock_param.qos_params));
has_listener = PJ_FALSE;
switch(listener->tls_setting.method) {
case PJSIP_TLSV1_METHOD:
ssock_param.proto = PJ_SSL_SOCK_PROTO_TLS1;
break;
case PJSIP_SSLV2_METHOD:
ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL2;
break;
case PJSIP_SSLV3_METHOD:
ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL3;
break;
case PJSIP_SSLV23_METHOD:
ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL23;
break;
default:
ssock_param.proto = PJ_SSL_SOCK_PROTO_DEFAULT;
break;
}
/* Create SSL socket */
status = pj_ssl_sock_create(pool, &ssock_param, &listener->ssock);
if (status != PJ_SUCCESS)
goto on_error;
/* Bind address may be different than factory.local_addr because
* factory.local_addr will be resolved below.
*/
listener_addr = &listener->factory.local_addr;
if (local) {
pj_sockaddr_cp((pj_sockaddr_t*)listener_addr,
(const pj_sockaddr_t*)local);
pj_sockaddr_cp(&listener->bound_addr, local);
} else {
pj_sockaddr_init(af, listener_addr, NULL, 0);
pj_sockaddr_init(af, &listener->bound_addr, NULL, 0);
}
/* Check if certificate/CA list for SSL socket is set */
if (listener->tls_setting.cert_file.slen ||
listener->tls_setting.ca_list_file.slen)
{
status = pj_ssl_cert_load_from_files(pool,
&listener->tls_setting.ca_list_file,
&listener->tls_setting.cert_file,
&listener->tls_setting.privkey_file,
&listener->tls_setting.password,
&listener->cert);
if (status != PJ_SUCCESS)
goto on_error;
status = pj_ssl_sock_set_certificate(listener->ssock, pool,
listener->cert);
if (status != PJ_SUCCESS)
goto on_error;
}
/* Start accepting incoming connections. Note that some TLS/SSL backends
* may not support for SSL socket server.
*/
has_listener = PJ_FALSE;
status = pj_ssl_sock_start_accept(listener->ssock, pool,
(pj_sockaddr_t*)listener_addr,
pj_sockaddr_get_len((pj_sockaddr_t*)listener_addr));
if (status == PJ_SUCCESS || status == PJ_EPENDING) {
pj_ssl_sock_info info;
has_listener = PJ_TRUE;
/* Retrieve the bound address */
status = pj_ssl_sock_get_info(listener->ssock, &info);
if (status == PJ_SUCCESS)
pj_sockaddr_cp(listener_addr, (pj_sockaddr_t*)&info.local_addr);
} else if (status != PJ_ENOTSUP) {
goto on_error;
}
/* If published host/IP is specified, then use that address as the
* listener advertised address.
*/
if (a_name && a_name->host.slen) {
/* Copy the address */
listener->factory.addr_name = *a_name;
pj_strdup(listener->factory.pool, &listener->factory.addr_name.host,
&a_name->host);
listener->factory.addr_name.port = a_name->port;
} else {
/* No published address is given, use the bound address */
/* If the address returns 0.0.0.0, use the default
* interface address as the transport's address.
*/
if (!pj_sockaddr_has_addr(listener_addr)) {
pj_sockaddr hostip;
status = pj_gethostip(af, &hostip);
if (status != PJ_SUCCESS)
goto on_error;
pj_sockaddr_copy_addr(listener_addr, &hostip);
}
/* Save the address name */
sockaddr_to_host_port(listener->factory.pool,
&listener->factory.addr_name, listener_addr);
}
/* If port is zero, get the bound port */
if (listener->factory.addr_name.port == 0) {
listener->factory.addr_name.port = pj_sockaddr_get_port(listener_addr);
}
pj_ansi_snprintf(listener->factory.obj_name,
sizeof(listener->factory.obj_name),
"tlslis:%d", listener->factory.addr_name.port);
/* Register to transport manager */
listener->endpt = endpt;
listener->tpmgr = pjsip_endpt_get_tpmgr(endpt);
listener->factory.create_transport2 = lis_create_transport;
listener->factory.destroy = lis_destroy;
listener->is_registered = PJ_TRUE;
status = pjsip_tpmgr_register_tpfactory(listener->tpmgr,
&listener->factory);
if (status != PJ_SUCCESS) {
listener->is_registered = PJ_FALSE;
goto on_error;
}
if (has_listener) {
PJ_LOG(4,(listener->factory.obj_name,
"SIP TLS listener is ready for incoming connections "
"at %.*s:%d",
(int)listener->factory.addr_name.host.slen,
listener->factory.addr_name.host.ptr,
listener->factory.addr_name.port));
} else {
PJ_LOG(4,(listener->factory.obj_name, "SIP TLS is ready "
"(client only)"));
}
/* Return the pointer to user */
if (p_factory) *p_factory = &listener->factory;
return PJ_SUCCESS;
on_error:
lis_destroy(&listener->factory);
return status;
}
/*! \brief Apply handler for transports */
static int transport_apply(const struct ast_sorcery *sorcery, void *obj)
{
struct ast_sip_transport *transport = obj;
const char *transport_id = ast_sorcery_object_get_id(obj);
RAII_VAR(struct ao2_container *, states, transport_states, states_cleanup);
RAII_VAR(struct internal_state *, temp_state, NULL, ao2_cleanup);
RAII_VAR(struct internal_state *, perm_state, NULL, ao2_cleanup);
RAII_VAR(struct ast_variable *, changes, NULL, ast_variables_destroy);
pj_status_t res = -1;
int i;
#define BIND_TRIES 3
#define BIND_DELAY_US 100000
if (!states) {
return -1;
}
/*
* transport_apply gets called for EVERY retrieval of a transport when using realtime.
* We need to prevent multiple threads from trying to mess with underlying transports
* at the same time. The container is the only thing we have to lock on.
*/
ao2_wrlock(states);
temp_state = internal_state_alloc(transport);
if (!temp_state) {
ast_log(LOG_ERROR, "Transport '%s' failed to allocate memory\n", transport_id);
return -1;
}
perm_state = find_internal_state_by_transport(transport);
if (perm_state) {
ast_sorcery_diff(sorcery, perm_state->transport, transport, &changes);
if (!changes && !has_state_changed(perm_state->state, temp_state->state)) {
/* In case someone is using the deprecated fields, reset them */
transport->state = perm_state->state;
copy_state_to_transport(transport);
ao2_replace(perm_state->transport, transport);
return 0;
}
if (!transport->allow_reload) {
if (!perm_state->change_detected) {
perm_state->change_detected = 1;
ast_log(LOG_WARNING, "Transport '%s' is not reloadable, maintaining previous values\n", transport_id);
}
/* In case someone is using the deprecated fields, reset them */
transport->state = perm_state->state;
copy_state_to_transport(transport);
ao2_replace(perm_state->transport, transport);
return 0;
}
}
if (temp_state->state->host.addr.sa_family != PJ_AF_INET && temp_state->state->host.addr.sa_family != PJ_AF_INET6) {
ast_log(LOG_ERROR, "Transport '%s' could not be started as binding not specified\n", transport_id);
return -1;
}
/* Set default port if not present */
if (!pj_sockaddr_get_port(&temp_state->state->host)) {
pj_sockaddr_set_port(&temp_state->state->host, (transport->type == AST_TRANSPORT_TLS) ? 5061 : 5060);
}
/* Now that we know what address family we can set up a dnsmgr refresh for the external media address if present */
if (!ast_strlen_zero(transport->external_signaling_address)) {
if (temp_state->state->host.addr.sa_family == pj_AF_INET()) {
temp_state->state->external_address.ss.ss_family = AF_INET;
} else if (temp_state->state->host.addr.sa_family == pj_AF_INET6()) {
temp_state->state->external_address.ss.ss_family = AF_INET6;
} else {
ast_log(LOG_ERROR, "Unknown address family for transport '%s', could not get external signaling address\n",
transport_id);
return -1;
}
if (ast_dnsmgr_lookup(transport->external_signaling_address, &temp_state->state->external_address, &temp_state->state->external_address_refresher, NULL) < 0) {
ast_log(LOG_ERROR, "Could not create dnsmgr for external signaling address on '%s'\n", transport_id);
return -1;
}
}
if (transport->type == AST_TRANSPORT_UDP) {
for (i = 0; i < BIND_TRIES && res != PJ_SUCCESS; i++) {
if (perm_state && perm_state->state && perm_state->state->transport) {
pjsip_udp_transport_pause(perm_state->state->transport,
PJSIP_UDP_TRANSPORT_DESTROY_SOCKET);
usleep(BIND_DELAY_US);
}
if (temp_state->state->host.addr.sa_family == pj_AF_INET()) {
res = pjsip_udp_transport_start(ast_sip_get_pjsip_endpoint(),
&temp_state->state->host.ipv4, NULL, transport->async_operations,
&temp_state->state->transport);
} else if (temp_state->state->host.addr.sa_family == pj_AF_INET6()) {
res = pjsip_udp_transport_start6(ast_sip_get_pjsip_endpoint(),
&temp_state->state->host.ipv6, NULL, transport->async_operations,
&temp_state->state->transport);
}
}
if (res == PJ_SUCCESS && (transport->tos || transport->cos)) {
pj_sock_t sock;
pj_qos_params qos_params;
sock = pjsip_udp_transport_get_socket(temp_state->state->transport);
pj_sock_get_qos_params(sock, &qos_params);
set_qos(transport, &qos_params);
pj_sock_set_qos_params(sock, &qos_params);
}
} else if (transport->type == AST_TRANSPORT_TCP) {
pjsip_tcp_transport_cfg cfg;
pjsip_tcp_transport_cfg_default(&cfg, temp_state->state->host.addr.sa_family);
cfg.bind_addr = temp_state->state->host;
cfg.async_cnt = transport->async_operations;
set_qos(transport, &cfg.qos_params);
for (i = 0; i < BIND_TRIES && res != PJ_SUCCESS; i++) {
if (perm_state && perm_state->state && perm_state->state->factory
&& perm_state->state->factory->destroy) {
perm_state->state->factory->destroy(perm_state->state->factory);
usleep(BIND_DELAY_US);
}
res = pjsip_tcp_transport_start3(ast_sip_get_pjsip_endpoint(), &cfg,
&temp_state->state->factory);
}
} else if (transport->type == AST_TRANSPORT_TLS) {
if (transport->async_operations > 1 && ast_compare_versions(pj_get_version(), "2.5.0") < 0) {
ast_log(LOG_ERROR, "Transport: %s: When protocol=tls and pjproject version < 2.5.0, async_operations can't be > 1\n",
ast_sorcery_object_get_id(obj));
return -1;
}
temp_state->state->tls.password = pj_str((char*)transport->password);
set_qos(transport, &temp_state->state->tls.qos_params);
for (i = 0; i < BIND_TRIES && res != PJ_SUCCESS; i++) {
if (perm_state && perm_state->state && perm_state->state->factory
&& perm_state->state->factory->destroy) {
perm_state->state->factory->destroy(perm_state->state->factory);
usleep(BIND_DELAY_US);
}
res = pjsip_tls_transport_start2(ast_sip_get_pjsip_endpoint(), &temp_state->state->tls,
&temp_state->state->host, NULL, transport->async_operations,
&temp_state->state->factory);
}
} else if ((transport->type == AST_TRANSPORT_WS) || (transport->type == AST_TRANSPORT_WSS)) {
if (transport->cos || transport->tos) {
ast_log(LOG_WARNING, "TOS and COS values ignored for websocket transport\n");
}
res = PJ_SUCCESS;
}
if (res != PJ_SUCCESS) {
char msg[PJ_ERR_MSG_SIZE];
pj_strerror(res, msg, sizeof(msg));
ast_log(LOG_ERROR, "Transport '%s' could not be started: %s\n", ast_sorcery_object_get_id(obj), msg);
return -1;
}
copy_state_to_transport(transport);
if (perm_state) {
ao2_unlink_flags(states, perm_state, OBJ_NOLOCK);
}
ao2_link_flags(states, temp_state, OBJ_NOLOCK);
return 0;
}
/*
* Create the STUN transport using the specified configuration.
*/
PJ_DEF(pj_status_t) pj_stun_sock_create( pj_stun_config *stun_cfg,
const char *name,
int af,
const pj_stun_sock_cb *cb,
const pj_stun_sock_cfg *cfg,
void *user_data,
pj_stun_sock **p_stun_sock)
{
pj_pool_t *pool;
pj_stun_sock *stun_sock;
pj_stun_sock_cfg default_cfg;
unsigned i;
pj_status_t status;
PJ_ASSERT_RETURN(stun_cfg && cb && p_stun_sock, PJ_EINVAL);
PJ_ASSERT_RETURN(af==pj_AF_INET()||af==pj_AF_INET6(), PJ_EAFNOTSUP);
PJ_ASSERT_RETURN(!cfg || pj_stun_sock_cfg_is_valid(cfg), PJ_EINVAL);
PJ_ASSERT_RETURN(cb->on_status, PJ_EINVAL);
status = pj_stun_config_check_valid(stun_cfg);
if (status != PJ_SUCCESS)
return status;
if (name == NULL)
name = "stuntp%p";
if (cfg == NULL) {
pj_stun_sock_cfg_default(&default_cfg);
cfg = &default_cfg;
}
/* Create structure */
pool = pj_pool_create(stun_cfg->pf, name, 256, 512, NULL);
stun_sock = PJ_POOL_ZALLOC_T(pool, pj_stun_sock);
stun_sock->pool = pool;
stun_sock->obj_name = pool->obj_name;
stun_sock->user_data = user_data;
stun_sock->af = af;
stun_sock->sock_fd = PJ_INVALID_SOCKET;
pj_memcpy(&stun_sock->stun_cfg, stun_cfg, sizeof(*stun_cfg));
pj_memcpy(&stun_sock->cb, cb, sizeof(*cb));
stun_sock->ka_interval = cfg->ka_interval;
if (stun_sock->ka_interval == 0)
stun_sock->ka_interval = PJ_STUN_KEEP_ALIVE_SEC;
/* Create socket and bind socket */
status = pj_sock_socket(af, pj_SOCK_DGRAM(), 0, &stun_sock->sock_fd);
if (status != PJ_SUCCESS)
goto on_error;
/* Apply QoS, if specified */
status = pj_sock_apply_qos2(stun_sock->sock_fd, cfg->qos_type,
&cfg->qos_params, 2, stun_sock->obj_name,
NULL);
if (status != PJ_SUCCESS && !cfg->qos_ignore_error)
goto on_error;
/* Bind socket */
if (pj_sockaddr_has_addr(&cfg->bound_addr)) {
status = pj_sock_bind(stun_sock->sock_fd, &cfg->bound_addr,
pj_sockaddr_get_len(&cfg->bound_addr));
} else {
pj_sockaddr bound_addr;
pj_sockaddr_init(af, &bound_addr, NULL, 0);
status = pj_sock_bind(stun_sock->sock_fd, &bound_addr,
pj_sockaddr_get_len(&bound_addr));
}
if (status != PJ_SUCCESS)
goto on_error;
/* Create more useful information string about this transport */
#if 0
{
pj_sockaddr bound_addr;
int addr_len = sizeof(bound_addr);
status = pj_sock_getsockname(stun_sock->sock_fd, &bound_addr,
&addr_len);
if (status != PJ_SUCCESS)
goto on_error;
stun_sock->info = pj_pool_alloc(pool, PJ_INET6_ADDRSTRLEN+10);
pj_sockaddr_print(&bound_addr, stun_sock->info,
PJ_INET6_ADDRSTRLEN, 3);
}
#endif
/* Init active socket configuration */
{
pj_activesock_cfg activesock_cfg;
pj_activesock_cb activesock_cb;
pj_activesock_cfg_default(&activesock_cfg);
activesock_cfg.async_cnt = cfg->async_cnt;
activesock_cfg.concurrency = 0;
/* Create the active socket */
pj_bzero(&activesock_cb, sizeof(activesock_cb));
activesock_cb.on_data_recvfrom = &on_data_recvfrom;
activesock_cb.on_data_sent = &on_data_sent;
status = pj_activesock_create(pool, stun_sock->sock_fd,
pj_SOCK_DGRAM(),
&activesock_cfg, stun_cfg->ioqueue,
&activesock_cb, stun_sock,
&stun_sock->active_sock);
if (status != PJ_SUCCESS)
goto on_error;
/* Start asynchronous read operations */
status = pj_activesock_start_recvfrom(stun_sock->active_sock, pool,
cfg->max_pkt_size, 0);
if (status != PJ_SUCCESS)
goto on_error;
/* Init send keys */
pj_ioqueue_op_key_init(&stun_sock->send_key,
sizeof(stun_sock->send_key));
pj_ioqueue_op_key_init(&stun_sock->int_send_key,
sizeof(stun_sock->int_send_key));
}
/* Create STUN session */
{
pj_stun_session_cb sess_cb;
pj_bzero(&sess_cb, sizeof(sess_cb));
sess_cb.on_request_complete = &sess_on_request_complete;
sess_cb.on_send_msg = &sess_on_send_msg;
status = pj_stun_session_create(&stun_sock->stun_cfg,
stun_sock->obj_name,
&sess_cb, PJ_FALSE,
&stun_sock->stun_sess);
if (status != PJ_SUCCESS)
goto on_error;
}
/* Associate us with the STUN session */
pj_stun_session_set_user_data(stun_sock->stun_sess, stun_sock);
/* Initialize random numbers to be used as STUN transaction ID for
* outgoing Binding request. We use the 80bit number to distinguish
* STUN messages we sent with STUN messages that the application sends.
* The last 16bit value in the array is a counter.
*/
for (i=0; i<PJ_ARRAY_SIZE(stun_sock->tsx_id); ++i) {
stun_sock->tsx_id[i] = (pj_uint16_t) pj_rand();
}
stun_sock->tsx_id[5] = 0;
/* Init timer entry */
stun_sock->ka_timer.cb = &ka_timer_cb;
stun_sock->ka_timer.user_data = stun_sock;
/* Done */
*p_stun_sock = stun_sock;
return PJ_SUCCESS;
on_error:
pj_stun_sock_destroy(stun_sock);
return status;
}
/* This callback is called by transport manager for the TLS factory
* to create outgoing transport to the specified destination.
*/
static pj_status_t lis_create_transport(pjsip_tpfactory *factory,
pjsip_tpmgr *mgr,
pjsip_endpoint *endpt,
const pj_sockaddr *rem_addr,
int addr_len,
pjsip_tx_data *tdata,
pjsip_transport **p_transport)
{
struct tls_listener *listener;
struct tls_transport *tls;
pj_pool_t *pool;
pj_ssl_sock_t *ssock;
pj_ssl_sock_param ssock_param;
pj_sockaddr local_addr;
pj_str_t remote_name;
pj_status_t status;
/* Sanity checks */
PJ_ASSERT_RETURN(factory && mgr && endpt && rem_addr &&
addr_len && p_transport, PJ_EINVAL);
/* Check that address is a sockaddr_in or sockaddr_in6*/
PJ_ASSERT_RETURN((rem_addr->addr.sa_family == pj_AF_INET() &&
addr_len == sizeof(pj_sockaddr_in)) ||
(rem_addr->addr.sa_family == pj_AF_INET6() &&
addr_len == sizeof(pj_sockaddr_in6)), PJ_EINVAL);
listener = (struct tls_listener*)factory;
pool = pjsip_endpt_create_pool(listener->endpt, "tls",
POOL_TP_INIT, POOL_TP_INC);
PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
/* Get remote host name from tdata */
if (tdata)
remote_name = tdata->dest_info.name;
else
pj_bzero(&remote_name, sizeof(remote_name));
/* Build SSL socket param */
pj_ssl_sock_param_default(&ssock_param);
ssock_param.sock_af = (factory->type & PJSIP_TRANSPORT_IPV6) ?
pj_AF_INET6() : pj_AF_INET();
ssock_param.cb.on_connect_complete = &on_connect_complete;
ssock_param.cb.on_data_read = &on_data_read;
ssock_param.cb.on_data_sent = &on_data_sent;
ssock_param.async_cnt = 1;
ssock_param.ioqueue = pjsip_endpt_get_ioqueue(listener->endpt);
ssock_param.server_name = remote_name;
ssock_param.timeout = listener->tls_setting.timeout;
ssock_param.user_data = NULL; /* pending, must be set later */
ssock_param.verify_peer = PJ_FALSE; /* avoid SSL socket closing the socket
* due to verification error */
if (ssock_param.send_buffer_size < PJSIP_MAX_PKT_LEN)
ssock_param.send_buffer_size = PJSIP_MAX_PKT_LEN;
if (ssock_param.read_buffer_size < PJSIP_MAX_PKT_LEN)
ssock_param.read_buffer_size = PJSIP_MAX_PKT_LEN;
ssock_param.ciphers_num = listener->tls_setting.ciphers_num;
ssock_param.ciphers = listener->tls_setting.ciphers;
ssock_param.qos_type = listener->tls_setting.qos_type;
ssock_param.qos_ignore_error = listener->tls_setting.qos_ignore_error;
pj_memcpy(&ssock_param.qos_params, &listener->tls_setting.qos_params,
sizeof(ssock_param.qos_params));
switch(listener->tls_setting.method) {
case PJSIP_TLSV1_METHOD:
ssock_param.proto = PJ_SSL_SOCK_PROTO_TLS1;
break;
case PJSIP_SSLV2_METHOD:
ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL2;
break;
case PJSIP_SSLV3_METHOD:
ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL3;
break;
case PJSIP_SSLV23_METHOD:
ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL23;
break;
default:
ssock_param.proto = PJ_SSL_SOCK_PROTO_DEFAULT;
break;
}
status = pj_ssl_sock_create(pool, &ssock_param, &ssock);
if (status != PJ_SUCCESS)
return status;
/* Apply SSL certificate */
if (listener->cert) {
status = pj_ssl_sock_set_certificate(ssock, pool, listener->cert);
if (status != PJ_SUCCESS)
return status;
}
/* Initially set bind address to listener's bind address */
pj_sockaddr_init(listener->bound_addr.addr.sa_family,
&local_addr, NULL, 0);
pj_sockaddr_copy_addr(&local_addr, &listener->bound_addr);
/* Create the transport descriptor */
status = tls_create(listener, pool, ssock, PJ_FALSE, &local_addr,
rem_addr, &remote_name, &tls);
if (status != PJ_SUCCESS)
return status;
/* Set the "pending" SSL socket user data */
pj_ssl_sock_set_user_data(tls->ssock, tls);
/* Start asynchronous connect() operation */
tls->has_pending_connect = PJ_TRUE;
status = pj_ssl_sock_start_connect(tls->ssock, tls->base.pool,
(pj_sockaddr_t*)&local_addr,
(pj_sockaddr_t*)rem_addr,
addr_len);
if (status == PJ_SUCCESS) {
on_connect_complete(tls->ssock, PJ_SUCCESS);
} else if (status != PJ_EPENDING) {
tls_destroy(&tls->base, status);
return status;
}
if (tls->has_pending_connect) {
pj_ssl_sock_info info;
/* Update local address, just in case local address currently set is
* different now that asynchronous connect() is started.
*/
/* Retrieve the bound address */
status = pj_ssl_sock_get_info(tls->ssock, &info);
if (status == PJ_SUCCESS) {
pj_uint16_t new_port;
new_port = pj_sockaddr_get_port((pj_sockaddr_t*)&info.local_addr);
if (pj_sockaddr_has_addr((pj_sockaddr_t*)&info.local_addr)) {
/* Update sockaddr */
pj_sockaddr_cp((pj_sockaddr_t*)&tls->base.local_addr,
(pj_sockaddr_t*)&info.local_addr);
} else if (new_port && new_port != pj_sockaddr_get_port(
(pj_sockaddr_t*)&tls->base.local_addr))
{
/* Update port only */
pj_sockaddr_set_port(&tls->base.local_addr,
new_port);
}
sockaddr_to_host_port(tls->base.pool, &tls->base.local_name,
&tls->base.local_addr);
}
PJ_LOG(4,(tls->base.obj_name,
"TLS transport %.*s:%d is connecting to %.*s:%d...",
(int)tls->base.local_name.host.slen,
tls->base.local_name.host.ptr,
tls->base.local_name.port,
(int)tls->base.remote_name.host.slen,
tls->base.remote_name.host.ptr,
tls->base.remote_name.port));
}
/* Done */
*p_transport = &tls->base;
return PJ_SUCCESS;
}
pj_status_t ConnectionPool::create_connection(int hash_slot)
{
// Resolve the target host to an IP address.
pj_sockaddr remote_addr;
pj_status_t status = resolve_host(&_target.host, _target.port, &remote_addr);
if (status != PJ_SUCCESS)
{
TRC_ERROR("Failed to resolve %.*s to an IP address - %s",
_target.host.slen, _target.host.ptr,
PJUtils::pj_status_to_string(status).c_str());
return status;
}
// Call TPMGR to create a new transport connection.
pjsip_transport* tp;
pjsip_tpselector tp_sel;
tp_sel.type = PJSIP_TPSELECTOR_LISTENER;
tp_sel.u.listener = _tpfactory;
status = pjsip_tpmgr_acquire_transport(pjsip_endpt_get_tpmgr(_endpt),
(remote_addr.addr.sa_family == pj_AF_INET6()) ?
PJSIP_TRANSPORT_TCP6 : PJSIP_TRANSPORT_TCP,
&remote_addr,
(remote_addr.addr.sa_family == pj_AF_INET6()) ?
sizeof(pj_sockaddr_in6) : sizeof(pj_sockaddr_in),
&tp_sel,
&tp);
if (status != PJ_SUCCESS)
{
return status;
}
// TPMGR will have already added a reference to the new transport to stop it
// being destroyed while we have pointers referencing it.
TRC_DEBUG("Created transport %s in slot %d (%.*s:%d to %.*s:%d)",
tp->obj_name,
hash_slot,
(int)tp->local_name.host.slen,
tp->local_name.host.ptr,
tp->local_name.port,
(int)tp->remote_name.host.slen,
tp->remote_name.host.ptr,
tp->remote_name.port);
// Register for transport state callbacks.
pjsip_tp_state_listener_key* key;
status = pjsip_transport_add_state_listener(tp, &transport_state, (void*)this, &key);
// Store the new transport in the hash slot, but marked as disconnected.
pthread_mutex_lock(&_tp_hash_lock);
_tp_hash[hash_slot].tp = tp;
_tp_hash[hash_slot].listener_key = key;
_tp_hash[hash_slot].connected = PJ_FALSE;
_tp_map[tp] = hash_slot;
// Don't increment the connection count here, wait until we get confirmation
// that the transport is connected.
pthread_mutex_unlock(&_tp_hash_lock);
return PJ_SUCCESS;
}
/**
* Create ipv6 transport
*/
PJ_DECL(pj_status_t) media_transports_create_ipv6(pjsua_transport_config rtp_cfg) {
pjsua_media_transport tp[PJSUA_MAX_CALLS];
pj_status_t status;
int port = rtp_cfg.port;
unsigned i;
//TODO : here should be get from config
for (i=0; i<PJSUA_MAX_CALLS; ++i) {
enum { MAX_RETRY = 10 };
pj_sock_t sock[2];
pjmedia_sock_info si;
unsigned j;
/* Get rid of uninitialized var compiler warning with MSVC */
status = PJ_SUCCESS;
for (j=0; j<MAX_RETRY; ++j) {
unsigned k;
for (k=0; k<2; ++k) {
pj_sockaddr bound_addr;
status = pj_sock_socket(pj_AF_INET6(), pj_SOCK_DGRAM(), 0, &sock[k]);
if (status != PJ_SUCCESS)
break;
status = pj_sockaddr_init(pj_AF_INET6(), &bound_addr,
&rtp_cfg.bound_addr,
(unsigned short)(port+k));
if (status != PJ_SUCCESS)
break;
status = pj_sock_bind(sock[k], &bound_addr,
pj_sockaddr_get_len(&bound_addr));
if (status != PJ_SUCCESS)
break;
}
if (status != PJ_SUCCESS) {
if (k==1)
pj_sock_close(sock[0]);
if (port != 0)
port += 10;
else
break;
continue;
}
pj_bzero(&si, sizeof(si));
si.rtp_sock = sock[0];
si.rtcp_sock = sock[1];
pj_sockaddr_init(pj_AF_INET6(), &si.rtp_addr_name,
&rtp_cfg.public_addr,
(unsigned short)(port));
pj_sockaddr_init(pj_AF_INET6(), &si.rtcp_addr_name,
&rtp_cfg.public_addr,
(unsigned short)(port+1));
status = pjmedia_transport_udp_attach(pjsua_get_pjmedia_endpt(),
NULL,
&si,
0,
&tp[i].transport);
if (port != 0)
port += 10;
else
break;
if (status == PJ_SUCCESS)
break;
}
if (status != PJ_SUCCESS) {
pjsua_perror(THIS_FILE, "Error creating IPv6 UDP media transport",
status);
for (j=0; j<i; ++j) {
pjmedia_transport_close(tp[j].transport);
}
return status;
}
}
return pjsua_media_transports_attach(tp, i, PJ_TRUE);
}
/*
* This is the main function for performing server resolution.
*/
PJ_DEF(void) pjsip_resolve( pjsip_resolver_t *resolver,
pj_pool_t *pool,
const pjsip_host_info *target,
void *token,
pjsip_resolver_callback *cb)
{
pjsip_server_addresses svr_addr;
pj_status_t status = PJ_SUCCESS;
int ip_addr_ver;
struct query *query;
pjsip_transport_type_e type = target->type;
/* Is it IP address or hostname? And if it's an IP, which version? */
ip_addr_ver = get_ip_addr_ver(&target->addr.host);
/* Set the transport type if not explicitly specified.
* RFC 3263 section 4.1 specify rules to set up this.
*/
if (type == PJSIP_TRANSPORT_UNSPECIFIED) {
if (ip_addr_ver || (target->addr.port != 0)) {
#if PJ_HAS_TCP
if (target->flag & PJSIP_TRANSPORT_SECURE)
{
type = PJSIP_TRANSPORT_TLS;
} else if (target->flag & PJSIP_TRANSPORT_RELIABLE)
{
type = PJSIP_TRANSPORT_TCP;
} else
#endif
{
type = PJSIP_TRANSPORT_UDP;
}
} else {
/* No type or explicit port is specified, and the address is
* not IP address.
* In this case, full NAPTR resolution must be performed.
* But we don't support it (yet).
*/
#if PJ_HAS_TCP
if (target->flag & PJSIP_TRANSPORT_SECURE)
{
type = PJSIP_TRANSPORT_TLS;
} else if (target->flag & PJSIP_TRANSPORT_RELIABLE)
{
type = PJSIP_TRANSPORT_TCP;
} else
#endif
{
type = PJSIP_TRANSPORT_UDP;
}
}
/* Add IPv6 flag for IPv6 address */
if (ip_addr_ver == 6)
type = (pjsip_transport_type_e)((int)type + PJSIP_TRANSPORT_IPV6);
}
/* If target is an IP address, or if resolver is not configured,
* we can just finish the resolution now using pj_gethostbyname()
*/
if (ip_addr_ver || resolver->res == NULL) {
char addr_str[PJ_INET6_ADDRSTRLEN+10];
pj_uint16_t srv_port;
if (ip_addr_ver != 0) {
/* Target is an IP address, no need to resolve */
if (ip_addr_ver == 4) {
pj_sockaddr_init(pj_AF_INET(), &svr_addr.entry[0].addr,
NULL, 0);
pj_inet_aton(&target->addr.host,
&svr_addr.entry[0].addr.ipv4.sin_addr);
} else {
pj_sockaddr_init(pj_AF_INET6(), &svr_addr.entry[0].addr,
NULL, 0);
pj_inet_pton(pj_AF_INET6(), &target->addr.host,
&svr_addr.entry[0].addr.ipv6.sin6_addr);
}
} else {
pj_addrinfo ai;
unsigned count;
int af;
PJ_LOG(5,(THIS_FILE,
"DNS resolver not available, target '%.*s:%d' type=%s "
"will be resolved with getaddrinfo()",
target->addr.host.slen,
target->addr.host.ptr,
target->addr.port,
pjsip_transport_get_type_name(target->type)));
if (type & PJSIP_TRANSPORT_IPV6) {
af = pj_AF_INET6();
} else {
af = pj_AF_INET();
}
/* Resolve */
count = 1;
status = pj_getaddrinfo(af, &target->addr.host, &count, &ai);
if (status != PJ_SUCCESS)
goto on_error;
svr_addr.entry[0].addr.addr.sa_family = (pj_uint16_t)af;
pj_memcpy(&svr_addr.entry[0].addr, &ai.ai_addr,
sizeof(pj_sockaddr));
}
/* Set the port number */
if (target->addr.port == 0) {
srv_port = (pj_uint16_t)
pjsip_transport_get_default_port_for_type(type);
} else {
srv_port = (pj_uint16_t)target->addr.port;
}
pj_sockaddr_set_port(&svr_addr.entry[0].addr, srv_port);
/* Call the callback. */
PJ_LOG(5,(THIS_FILE,
"Target '%.*s:%d' type=%s resolved to "
"'%s' type=%s (%s)",
(int)target->addr.host.slen,
target->addr.host.ptr,
target->addr.port,
pjsip_transport_get_type_name(target->type),
pj_sockaddr_print(&svr_addr.entry[0].addr, addr_str,
sizeof(addr_str), 3),
pjsip_transport_get_type_name(type),
pjsip_transport_get_type_desc(type)));
svr_addr.count = 1;
svr_addr.entry[0].priority = 0;
svr_addr.entry[0].weight = 0;
svr_addr.entry[0].type = type;
svr_addr.entry[0].addr_len = pj_sockaddr_get_len(&svr_addr.entry[0].addr);
(*cb)(status, token, &svr_addr);
/* Done. */
return;
}
/* Target is not an IP address so we need to resolve it. */
#if PJSIP_HAS_RESOLVER
/* Build the query state */
query = PJ_POOL_ZALLOC_T(pool, struct query);
query->objname = THIS_FILE;
query->token = token;
query->cb = cb;
query->req.target = *target;
pj_strdup(pool, &query->req.target.addr.host, &target->addr.host);
/* If port is not specified, start with SRV resolution
* (should be with NAPTR, but we'll do that later)
*/
PJ_TODO(SUPPORT_DNS_NAPTR);
/* Build dummy NAPTR entry */
query->naptr_cnt = 1;
pj_bzero(&query->naptr[0], sizeof(query->naptr[0]));
query->naptr[0].order = 0;
query->naptr[0].pref = 0;
query->naptr[0].type = type;
pj_strdup(pool, &query->naptr[0].name, &target->addr.host);
/* Start DNS SRV or A resolution, depending on whether port is specified */
if (target->addr.port == 0) {
query->query_type = PJ_DNS_TYPE_SRV;
query->req.def_port = 5060;
if (type == PJSIP_TRANSPORT_TLS) {
query->naptr[0].res_type = pj_str("_sips._tcp.");
query->req.def_port = 5061;
} else if (type == PJSIP_TRANSPORT_TCP)
query->naptr[0].res_type = pj_str("_sip._tcp.");
else if (type == PJSIP_TRANSPORT_UDP)
query->naptr[0].res_type = pj_str("_sip._udp.");
else {
pj_assert(!"Unknown transport type");
query->naptr[0].res_type = pj_str("_sip._udp.");
}
} else {
/* Otherwise if port is specified, start with A (or AAAA) host
* resolution
*/
query->query_type = PJ_DNS_TYPE_A;
query->naptr[0].res_type.slen = 0;
query->req.def_port = target->addr.port;
}
/* Start the asynchronous query */
PJ_LOG(5, (query->objname,
"Starting async DNS %s query: target=%.*s%.*s, transport=%s, "
"port=%d",
pj_dns_get_type_name(query->query_type),
(int)query->naptr[0].res_type.slen,
query->naptr[0].res_type.ptr,
(int)query->naptr[0].name.slen, query->naptr[0].name.ptr,
pjsip_transport_get_type_name(target->type),
target->addr.port));
if (query->query_type == PJ_DNS_TYPE_SRV) {
unsigned option = PJ_TRUE;
if (type & PJSIP_TRANSPORT_IPV6) {
option |= PJ_DNS_SRV_FALLBACK_GETADDRINFO_IPV6;
} else {
option |= PJ_DNS_SRV_FALLBACK_GETADDRINFO_IPV4;
}
status = pj_dns_srv_resolve(&query->naptr[0].name,
&query->naptr[0].res_type,
query->req.def_port, pool, resolver->res,
option, query, &srv_resolver_cb, NULL);
} else if (query->query_type == PJ_DNS_TYPE_A) {
status = pj_dns_resolver_start_query(resolver->res,
&query->naptr[0].name,
PJ_DNS_TYPE_A, 0,
&dns_a_callback,
query, &query->object);
} else {
pj_assert(!"Unexpected");
status = PJ_EBUG;
}
if (status != PJ_SUCCESS)
goto on_error;
return;
#else /* PJSIP_HAS_RESOLVER */
PJ_UNUSED_ARG(pool);
PJ_UNUSED_ARG(query);
PJ_UNUSED_ARG(srv_name);
#endif /* PJSIP_HAS_RESOLVER */
on_error:
if (status != PJ_SUCCESS) {
char errmsg[PJ_ERR_MSG_SIZE];
PJ_LOG(4,(THIS_FILE, "Failed to resolve '%.*s'. Err=%d (%s)",
(int)target->addr.host.slen,
target->addr.host.ptr,
status,
pj_strerror(status,errmsg,sizeof(errmsg)).ptr));
(*cb)(status, token, NULL);
return;
}
}
static int print_attr(char *buffer, unsigned length,
const pj_stun_attr_hdr *ahdr)
{
char *p = buffer, *end = buffer + length;
const char *attr_name = pj_stun_get_attr_name(ahdr->type);
char attr_buf[32];
int len;
if (*attr_name == '?') {
pj_ansi_snprintf(attr_buf, sizeof(attr_buf), "Attr 0x%x",
ahdr->type);
attr_name = attr_buf;
}
len = pj_ansi_snprintf(p, end-p,
" %s: length=%d",
attr_name,
(int)ahdr->length);
APPLY();
switch (ahdr->type) {
case PJ_STUN_ATTR_MAPPED_ADDR:
case PJ_STUN_ATTR_RESPONSE_ADDR:
case PJ_STUN_ATTR_SOURCE_ADDR:
case PJ_STUN_ATTR_CHANGED_ADDR:
case PJ_STUN_ATTR_REFLECTED_FROM:
case PJ_STUN_ATTR_XOR_PEER_ADDR:
case PJ_STUN_ATTR_XOR_RELAYED_ADDR:
case PJ_STUN_ATTR_XOR_MAPPED_ADDR:
case PJ_STUN_ATTR_XOR_REFLECTED_FROM:
case PJ_STUN_ATTR_ALTERNATE_SERVER:
{
const pj_stun_sockaddr_attr *attr;
attr = (const pj_stun_sockaddr_attr*)ahdr;
if (attr->sockaddr.addr.sa_family == pj_AF_INET()) {
len = pj_ansi_snprintf(p, end-p,
", IPv4 addr=%s:%d\n",
pj_inet_ntoa(attr->sockaddr.ipv4.sin_addr),
pj_ntohs(attr->sockaddr.ipv4.sin_port));
} else if (attr->sockaddr.addr.sa_family == pj_AF_INET6()) {
len = pj_ansi_snprintf(p, end-p,
", IPv6 addr present\n");
} else {
len = pj_ansi_snprintf(p, end-p,
", INVALID ADDRESS FAMILY!\n");
}
APPLY();
}
break;
case PJ_STUN_ATTR_CHANNEL_NUMBER:
{
const pj_stun_uint_attr *attr;
attr = (const pj_stun_uint_attr*)ahdr;
len = pj_ansi_snprintf(p, end-p,
", chnum=%u (0x%x)\n",
(int)PJ_STUN_GET_CH_NB(attr->value),
(int)PJ_STUN_GET_CH_NB(attr->value));
APPLY();
}
break;
case PJ_STUN_ATTR_CHANGE_REQUEST:
case PJ_STUN_ATTR_LIFETIME:
case PJ_STUN_ATTR_BANDWIDTH:
case PJ_STUN_ATTR_REQ_ADDR_TYPE:
case PJ_STUN_ATTR_EVEN_PORT:
case PJ_STUN_ATTR_REQ_TRANSPORT:
case PJ_STUN_ATTR_TIMER_VAL:
case PJ_STUN_ATTR_PRIORITY:
case PJ_STUN_ATTR_FINGERPRINT:
case PJ_STUN_ATTR_REFRESH_INTERVAL:
case PJ_STUN_ATTR_ICMP:
{
const pj_stun_uint_attr *attr;
attr = (const pj_stun_uint_attr*)ahdr;
len = pj_ansi_snprintf(p, end-p,
", value=%u (0x%x)\n",
(pj_uint32_t)attr->value,
(pj_uint32_t)attr->value);
APPLY();
}
break;
case PJ_STUN_ATTR_USERNAME:
case PJ_STUN_ATTR_PASSWORD:
case PJ_STUN_ATTR_REALM:
case PJ_STUN_ATTR_NONCE:
case PJ_STUN_ATTR_SOFTWARE:
{
const pj_stun_string_attr *attr;
attr = (pj_stun_string_attr*)ahdr;
len = pj_ansi_snprintf(p, end-p,
", value=\"%.*s\"\n",
(int)attr->value.slen,
attr->value.ptr);
APPLY();
}
break;
case PJ_STUN_ATTR_ERROR_CODE:
{
const pj_stun_errcode_attr *attr;
attr = (const pj_stun_errcode_attr*) ahdr;
len = pj_ansi_snprintf(p, end-p,
", err_code=%d, reason=\"%.*s\"\n",
attr->err_code,
(int)attr->reason.slen,
attr->reason.ptr);
APPLY();
}
break;
case PJ_STUN_ATTR_UNKNOWN_ATTRIBUTES:
{
const pj_stun_unknown_attr *attr;
unsigned j;
attr = (const pj_stun_unknown_attr*) ahdr;
len = pj_ansi_snprintf(p, end-p,
", unknown list:");
APPLY();
for (j=0; j<attr->attr_count; ++j) {
len = pj_ansi_snprintf(p, end-p,
" %d",
(int)attr->attrs[j]);
APPLY();
}
}
break;
case PJ_STUN_ATTR_MESSAGE_INTEGRITY:
{
const pj_stun_msgint_attr *attr;
attr = (const pj_stun_msgint_attr*) ahdr;
len = print_binary(p, (unsigned)(end-p), attr->hmac, 20);
APPLY();
}
break;
case PJ_STUN_ATTR_DATA:
{
const pj_stun_binary_attr *attr;
attr = (const pj_stun_binary_attr*) ahdr;
len = print_binary(p, (unsigned)(end-p), attr->data, attr->length);
APPLY();
}
break;
case PJ_STUN_ATTR_ICE_CONTROLLED:
case PJ_STUN_ATTR_ICE_CONTROLLING:
case PJ_STUN_ATTR_RESERVATION_TOKEN:
{
const pj_stun_uint64_attr *attr;
pj_uint8_t data[8];
int i;
attr = (const pj_stun_uint64_attr*) ahdr;
for (i=0; i<8; ++i)
data[i] = ((const pj_uint8_t*)&attr->value)[7-i];
len = print_binary(p, (unsigned)(end-p), data, 8);
APPLY();
}
break;
case PJ_STUN_ATTR_USE_CANDIDATE:
case PJ_STUN_ATTR_DONT_FRAGMENT:
default:
len = pj_ansi_snprintf(p, end-p, "\n");
APPLY();
break;
}
return (int)(p-buffer);
on_return:
return len;
}
/*
* Callback from TURN session when state has changed
*/
static void turn_on_state(pj_turn_session *sess,
pj_turn_state_t old_state,
pj_turn_state_t new_state)
{
pj_turn_sock *turn_sock = (pj_turn_sock*)
pj_turn_session_get_user_data(sess);
pj_status_t status;
if (turn_sock == NULL) {
/* We've been destroyed */
return;
}
/* Notify app first */
if (turn_sock->cb.on_state) {
(*turn_sock->cb.on_state)(turn_sock, old_state, new_state);
}
/* Make sure user hasn't destroyed us in the callback */
if (turn_sock->sess && new_state == PJ_TURN_STATE_RESOLVED) {
pj_turn_session_info info;
pj_turn_session_get_info(turn_sock->sess, &info);
new_state = info.state;
}
if (turn_sock->sess && new_state == PJ_TURN_STATE_RESOLVED) {
/*
* Once server has been resolved, initiate outgoing TCP
* connection to the server.
*/
pj_turn_session_info info;
char addrtxt[PJ_INET6_ADDRSTRLEN+8];
int sock_type;
pj_sock_t sock;
pj_activesock_cfg asock_cfg;
pj_activesock_cb asock_cb;
pj_sockaddr bound_addr, *cfg_bind_addr;
pj_uint16_t max_bind_retry;
/* Close existing connection, if any. This happens when
* we're switching to alternate TURN server when either TCP
* connection or ALLOCATE request failed.
*/
if (turn_sock->active_sock) {
pj_activesock_close(turn_sock->active_sock);
turn_sock->active_sock = NULL;
}
/* Get server address from session info */
pj_turn_session_get_info(sess, &info);
if (turn_sock->conn_type == PJ_TURN_TP_UDP)
sock_type = pj_SOCK_DGRAM();
else
sock_type = pj_SOCK_STREAM();
/* Init socket */
status = pj_sock_socket(turn_sock->af, sock_type, 0, &sock);
if (status != PJ_SUCCESS) {
pj_turn_sock_destroy(turn_sock);
return;
}
/* Bind socket */
cfg_bind_addr = &turn_sock->setting.bound_addr;
max_bind_retry = MAX_BIND_RETRY;
if (turn_sock->setting.port_range &&
turn_sock->setting.port_range < max_bind_retry)
{
max_bind_retry = turn_sock->setting.port_range;
}
pj_sockaddr_init(turn_sock->af, &bound_addr, NULL, 0);
if (cfg_bind_addr->addr.sa_family == pj_AF_INET() ||
cfg_bind_addr->addr.sa_family == pj_AF_INET6())
{
pj_sockaddr_cp(&bound_addr, cfg_bind_addr);
}
status = pj_sock_bind_random(sock, &bound_addr,
turn_sock->setting.port_range,
max_bind_retry);
if (status != PJ_SUCCESS) {
pj_turn_sock_destroy(turn_sock);
return;
}
/* Apply QoS, if specified */
status = pj_sock_apply_qos2(sock, turn_sock->setting.qos_type,
&turn_sock->setting.qos_params,
(turn_sock->setting.qos_ignore_error?2:1),
turn_sock->pool->obj_name, NULL);
if (status != PJ_SUCCESS && !turn_sock->setting.qos_ignore_error) {
pj_turn_sock_destroy(turn_sock);
return;
}
/* Apply socket buffer size */
if (turn_sock->setting.so_rcvbuf_size > 0) {
unsigned sobuf_size = turn_sock->setting.so_rcvbuf_size;
status = pj_sock_setsockopt_sobuf(sock, pj_SO_RCVBUF(),
PJ_TRUE, &sobuf_size);
if (status != PJ_SUCCESS) {
pj_perror(3, turn_sock->obj_name, status,
"Failed setting SO_RCVBUF");
} else {
if (sobuf_size < turn_sock->setting.so_rcvbuf_size) {
PJ_LOG(4, (turn_sock->obj_name,
"Warning! Cannot set SO_RCVBUF as configured,"
" now=%d, configured=%d", sobuf_size,
turn_sock->setting.so_rcvbuf_size));
} else {
PJ_LOG(5, (turn_sock->obj_name, "SO_RCVBUF set to %d",
sobuf_size));
}
}
}
if (turn_sock->setting.so_sndbuf_size > 0) {
unsigned sobuf_size = turn_sock->setting.so_sndbuf_size;
status = pj_sock_setsockopt_sobuf(sock, pj_SO_SNDBUF(),
PJ_TRUE, &sobuf_size);
if (status != PJ_SUCCESS) {
pj_perror(3, turn_sock->obj_name, status,
"Failed setting SO_SNDBUF");
} else {
if (sobuf_size < turn_sock->setting.so_sndbuf_size) {
PJ_LOG(4, (turn_sock->obj_name,
"Warning! Cannot set SO_SNDBUF as configured,"
" now=%d, configured=%d", sobuf_size,
turn_sock->setting.so_sndbuf_size));
} else {
PJ_LOG(5, (turn_sock->obj_name, "SO_SNDBUF set to %d",
sobuf_size));
}
}
}
/* Create active socket */
pj_activesock_cfg_default(&asock_cfg);
asock_cfg.grp_lock = turn_sock->grp_lock;
pj_bzero(&asock_cb, sizeof(asock_cb));
asock_cb.on_data_read = &on_data_read;
asock_cb.on_connect_complete = &on_connect_complete;
status = pj_activesock_create(turn_sock->pool, sock,
sock_type, &asock_cfg,
turn_sock->cfg.ioqueue, &asock_cb,
turn_sock,
&turn_sock->active_sock);
if (status != PJ_SUCCESS) {
pj_turn_sock_destroy(turn_sock);
return;
}
PJ_LOG(5,(turn_sock->pool->obj_name,
"Connecting to %s",
pj_sockaddr_print(&info.server, addrtxt,
sizeof(addrtxt), 3)));
/* Initiate non-blocking connect */
#if PJ_HAS_TCP
status=pj_activesock_start_connect(turn_sock->active_sock,
turn_sock->pool,
&info.server,
pj_sockaddr_get_len(&info.server));
if (status == PJ_SUCCESS) {
on_connect_complete(turn_sock->active_sock, PJ_SUCCESS);
} else if (status != PJ_EPENDING) {
pj_turn_sock_destroy(turn_sock);
return;
}
#else
on_connect_complete(turn_sock->active_sock, PJ_SUCCESS);
#endif
/* Done for now. Subsequent work will be done in
* on_connect_complete() callback.
*/
}
if (new_state >= PJ_TURN_STATE_DESTROYING && turn_sock->sess) {
pj_time_val delay = {0, 0};
turn_sock->sess = NULL;
pj_turn_session_set_user_data(sess, NULL);
pj_timer_heap_cancel_if_active(turn_sock->cfg.timer_heap,
&turn_sock->timer, 0);
pj_timer_heap_schedule_w_grp_lock(turn_sock->cfg.timer_heap,
&turn_sock->timer,
&delay, TIMER_DESTROY,
turn_sock->grp_lock);
}
}
/*
* Create stream info from SDP media line.
*/
PJ_DEF(pj_status_t) pjmedia_vid_stream_info_from_sdp(
pjmedia_vid_stream_info *si,
pj_pool_t *pool,
pjmedia_endpt *endpt,
const pjmedia_sdp_session *local,
const pjmedia_sdp_session *remote,
unsigned stream_idx)
{
const pjmedia_sdp_attr *attr;
const pjmedia_sdp_media *local_m;
const pjmedia_sdp_media *rem_m;
const pjmedia_sdp_conn *local_conn;
const pjmedia_sdp_conn *rem_conn;
int rem_af, local_af;
pj_sockaddr local_addr;
pj_status_t status;
PJ_UNUSED_ARG(endpt);
/* Validate arguments: */
PJ_ASSERT_RETURN(pool && si && local && remote, PJ_EINVAL);
PJ_ASSERT_RETURN(stream_idx < local->media_count, PJ_EINVAL);
PJ_ASSERT_RETURN(stream_idx < remote->media_count, PJ_EINVAL);
/* Keep SDP shortcuts */
local_m = local->media[stream_idx];
rem_m = remote->media[stream_idx];
local_conn = local_m->conn ? local_m->conn : local->conn;
if (local_conn == NULL)
return PJMEDIA_SDP_EMISSINGCONN;
rem_conn = rem_m->conn ? rem_m->conn : remote->conn;
if (rem_conn == NULL)
return PJMEDIA_SDP_EMISSINGCONN;
/* Media type must be video */
if (pj_stricmp(&local_m->desc.media, &ID_VIDEO) != 0)
return PJMEDIA_EINVALIMEDIATYPE;
/* Reset: */
pj_bzero(si, sizeof(*si));
/* Media type: */
si->type = PJMEDIA_TYPE_VIDEO;
/* Transport protocol */
/* At this point, transport type must be compatible,
* the transport instance will do more validation later.
*/
status = pjmedia_sdp_transport_cmp(&rem_m->desc.transport,
&local_m->desc.transport);
if (status != PJ_SUCCESS)
return PJMEDIA_SDPNEG_EINVANSTP;
if (pj_stricmp(&local_m->desc.transport, &ID_RTP_AVP) == 0) {
si->proto = PJMEDIA_TP_PROTO_RTP_AVP;
} else if (pj_stricmp(&local_m->desc.transport, &ID_RTP_SAVP) == 0) {
si->proto = PJMEDIA_TP_PROTO_RTP_SAVP;
} else {
si->proto = PJMEDIA_TP_PROTO_UNKNOWN;
return PJ_SUCCESS;
}
/* Check address family in remote SDP */
rem_af = pj_AF_UNSPEC();
if (pj_stricmp(&rem_conn->net_type, &ID_IN)==0) {
if (pj_stricmp(&rem_conn->addr_type, &ID_IP4)==0) {
rem_af = pj_AF_INET();
} else if (pj_stricmp(&rem_conn->addr_type, &ID_IP6)==0) {
rem_af = pj_AF_INET6();
}
}
if (rem_af==pj_AF_UNSPEC()) {
/* Unsupported address family */
return PJ_EAFNOTSUP;
}
/* Set remote address: */
status = pj_sockaddr_init(rem_af, &si->rem_addr, &rem_conn->addr,
rem_m->desc.port);
if (status != PJ_SUCCESS) {
/* Invalid IP address. */
return PJMEDIA_EINVALIDIP;
}
/* Check address family of local info */
local_af = pj_AF_UNSPEC();
if (pj_stricmp(&local_conn->net_type, &ID_IN)==0) {
if (pj_stricmp(&local_conn->addr_type, &ID_IP4)==0) {
local_af = pj_AF_INET();
} else if (pj_stricmp(&local_conn->addr_type, &ID_IP6)==0) {
local_af = pj_AF_INET6();
}
}
if (local_af==pj_AF_UNSPEC()) {
/* Unsupported address family */
return PJ_SUCCESS;
}
/* Set remote address: */
status = pj_sockaddr_init(local_af, &local_addr, &local_conn->addr,
local_m->desc.port);
if (status != PJ_SUCCESS) {
/* Invalid IP address. */
return PJMEDIA_EINVALIDIP;
}
/* Local and remote address family must match */
if (local_af != rem_af)
return PJ_EAFNOTSUP;
/* Media direction: */
if (local_m->desc.port == 0 ||
pj_sockaddr_has_addr(&local_addr)==PJ_FALSE ||
pj_sockaddr_has_addr(&si->rem_addr)==PJ_FALSE ||
pjmedia_sdp_media_find_attr(local_m, &STR_INACTIVE, NULL)!=NULL)
{
/* Inactive stream. */
si->dir = PJMEDIA_DIR_NONE;
} else if (pjmedia_sdp_media_find_attr(local_m, &STR_SENDONLY, NULL)!=NULL) {
/* Send only stream. */
si->dir = PJMEDIA_DIR_ENCODING;
} else if (pjmedia_sdp_media_find_attr(local_m, &STR_RECVONLY, NULL)!=NULL) {
/* Recv only stream. */
si->dir = PJMEDIA_DIR_DECODING;
} else {
/* Send and receive stream. */
si->dir = PJMEDIA_DIR_ENCODING_DECODING;
}
/* No need to do anything else if stream is rejected */
if (local_m->desc.port == 0) {
return PJ_SUCCESS;
}
/* If "rtcp" attribute is present in the SDP, set the RTCP address
* from that attribute. Otherwise, calculate from RTP address.
*/
attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
"rtcp", NULL);
if (attr) {
pjmedia_sdp_rtcp_attr rtcp;
status = pjmedia_sdp_attr_get_rtcp(attr, &rtcp);
if (status == PJ_SUCCESS) {
if (rtcp.addr.slen) {
status = pj_sockaddr_init(rem_af, &si->rem_rtcp, &rtcp.addr,
(pj_uint16_t)rtcp.port);
} else {
pj_sockaddr_init(rem_af, &si->rem_rtcp, NULL,
(pj_uint16_t)rtcp.port);
pj_memcpy(pj_sockaddr_get_addr(&si->rem_rtcp),
pj_sockaddr_get_addr(&si->rem_addr),
pj_sockaddr_get_addr_len(&si->rem_addr));
}
}
}
if (!pj_sockaddr_has_addr(&si->rem_rtcp)) {
int rtcp_port;
pj_memcpy(&si->rem_rtcp, &si->rem_addr, sizeof(pj_sockaddr));
rtcp_port = pj_sockaddr_get_port(&si->rem_addr) + 1;
pj_sockaddr_set_port(&si->rem_rtcp, (pj_uint16_t)rtcp_port);
}
/* Get codec info and param */
status = get_video_codec_info_param(si, pool, NULL, local_m, rem_m);
/* Leave SSRC to random. */
si->ssrc = pj_rand();
/* Set default jitter buffer parameter. */
si->jb_init = si->jb_max = si->jb_min_pre = si->jb_max_pre = -1;
return status;
}
/* This callback is called by transport manager for the TCP factory
* to create outgoing transport to the specified destination.
*/
static pj_status_t lis_create_transport(pjsip_tpfactory *factory,
pjsip_tpmgr *mgr,
pjsip_endpoint *endpt,
const pj_sockaddr *rem_addr,
int addr_len,
pjsip_transport **p_transport)
{
struct tcp_listener *listener;
struct tcp_transport *tcp;
pj_sock_t sock;
pj_sockaddr local_addr;
pj_status_t status;
/* Sanity checks */
PJ_ASSERT_RETURN(factory && mgr && endpt && rem_addr &&
addr_len && p_transport, PJ_EINVAL);
/* Check that address is a sockaddr_in or sockaddr_in6*/
PJ_ASSERT_RETURN((rem_addr->addr.sa_family == pj_AF_INET() &&
addr_len == sizeof(pj_sockaddr_in)) ||
(rem_addr->addr.sa_family == pj_AF_INET6() &&
addr_len == sizeof(pj_sockaddr_in6)), PJ_EINVAL);
listener = (struct tcp_listener*)factory;
/* Create socket */
status = pj_sock_socket(rem_addr->addr.sa_family, pj_SOCK_STREAM(),
0, &sock);
if (status != PJ_SUCCESS)
return status;
/* Apply QoS, if specified */
status = pj_sock_apply_qos2(sock, listener->qos_type,
&listener->qos_params,
2, listener->factory.obj_name,
"outgoing SIP TCP socket");
/* Bind to listener's address and any port */
pj_bzero(&local_addr, sizeof(local_addr));
pj_sockaddr_cp(&local_addr, &listener->bound_addr);
pj_sockaddr_set_port(&local_addr, 0);
status = pj_sock_bind(sock, &local_addr,
pj_sockaddr_get_len(&local_addr));
if (status != PJ_SUCCESS) {
pj_sock_close(sock);
return status;
}
/* Get the local port */
addr_len = sizeof(local_addr);
status = pj_sock_getsockname(sock, &local_addr, &addr_len);
if (status != PJ_SUCCESS) {
pj_sock_close(sock);
return status;
}
/* Initially set the address from the listener's address */
if (!pj_sockaddr_has_addr(&local_addr)) {
pj_sockaddr_copy_addr(&local_addr, &listener->factory.local_addr);
}
/* Create the transport descriptor */
status = tcp_create(listener, NULL, sock, PJ_FALSE, &local_addr,
rem_addr, &tcp);
if (status != PJ_SUCCESS)
return status;
/* Start asynchronous connect() operation */
tcp->has_pending_connect = PJ_TRUE;
status = pj_activesock_start_connect(tcp->asock, tcp->base.pool, rem_addr,
addr_len);
if (status == PJ_SUCCESS) {
on_connect_complete(tcp->asock, PJ_SUCCESS);
} else if (status != PJ_EPENDING) {
tcp_destroy(&tcp->base, status);
return status;
}
if (tcp->has_pending_connect) {
/* Update (again) local address, just in case local address currently
* set is different now that asynchronous connect() is started.
*/
addr_len = sizeof(local_addr);
if (pj_sock_getsockname(sock, &local_addr, &addr_len)==PJ_SUCCESS) {
pj_sockaddr *tp_addr = &tcp->base.local_addr;
/* Some systems (like old Win32 perhaps) may not set local address
* properly before socket is fully connected.
*/
if (pj_sockaddr_cmp(tp_addr, &local_addr) &&
pj_sockaddr_get_port(&local_addr) != 0)
{
pj_sockaddr_cp(tp_addr, &local_addr);
sockaddr_to_host_port(tcp->base.pool, &tcp->base.local_name,
&local_addr);
}
}
PJ_LOG(4,(tcp->base.obj_name,
"TCP transport %.*s:%d is connecting to %.*s:%d...",
(int)tcp->base.local_name.host.slen,
tcp->base.local_name.host.ptr,
tcp->base.local_name.port,
(int)tcp->base.remote_name.host.slen,
tcp->base.remote_name.host.ptr,
tcp->base.remote_name.port));
}
/* Done */
*p_transport = &tcp->base;
return PJ_SUCCESS;
}
/*! \brief Function which creates an outgoing stream */
static int create_outgoing_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
struct pjmedia_sdp_session *sdp)
{
pj_pool_t *pool = session->inv_session->pool_prov;
static const pj_str_t STR_IN = { "IN", 2 };
static const pj_str_t STR_IP4 = { "IP4", 3};
static const pj_str_t STR_IP6 = { "IP6", 3};
static const pj_str_t STR_UDPTL = { "udptl", 5 };
static const pj_str_t STR_T38 = { "t38", 3 };
static const pj_str_t STR_TRANSFERREDTCF = { "transferredTCF", 14 };
static const pj_str_t STR_LOCALTCF = { "localTCF", 8 };
static const pj_str_t STR_T38UDPFEC = { "t38UDPFEC", 9 };
static const pj_str_t STR_T38UDPREDUNDANCY = { "t38UDPRedundancy", 16 };
struct t38_state *state;
pjmedia_sdp_media *media;
const char *hostip = NULL;
struct ast_sockaddr addr;
char tmp[512];
pj_str_t stmp;
if (!session->endpoint->media.t38.enabled) {
return 1;
} else if ((session->t38state != T38_LOCAL_REINVITE) && (session->t38state != T38_PEER_REINVITE) &&
(session->t38state != T38_ENABLED)) {
return 1;
} else if (!(state = t38_state_get_or_alloc(session))) {
return -1;
} else if (t38_initialize_session(session, session_media)) {
return -1;
}
if (!(media = pj_pool_zalloc(pool, sizeof(struct pjmedia_sdp_media))) ||
!(media->conn = pj_pool_zalloc(pool, sizeof(struct pjmedia_sdp_conn)))) {
return -1;
}
media->desc.media = pj_str(session_media->stream_type);
media->desc.transport = STR_UDPTL;
if (ast_strlen_zero(session->endpoint->media.address)) {
hostip = ast_sip_get_host_ip_string(session->endpoint->media.t38.ipv6 ? pj_AF_INET6() : pj_AF_INET());
} else {
hostip = session->endpoint->media.address;
}
if (ast_strlen_zero(hostip)) {
return -1;
}
media->conn->net_type = STR_IN;
media->conn->addr_type = session->endpoint->media.t38.ipv6 ? STR_IP6 : STR_IP4;
pj_strdup2(pool, &media->conn->addr, hostip);
ast_udptl_get_us(session_media->udptl, &addr);
media->desc.port = (pj_uint16_t) ast_sockaddr_port(&addr);
media->desc.port_count = 1;
media->desc.fmt[media->desc.fmt_count++] = STR_T38;
snprintf(tmp, sizeof(tmp), "%u", state->our_parms.version);
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxVersion", pj_cstr(&stmp, tmp));
snprintf(tmp, sizeof(tmp), "%u", t38_get_rate(state->our_parms.rate));
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38MaxBitRate", pj_cstr(&stmp, tmp));
if (state->our_parms.fill_bit_removal) {
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxFillBitRemoval", NULL);
}
if (state->our_parms.transcoding_mmr) {
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxTranscodingMMR", NULL);
}
if (state->our_parms.transcoding_jbig) {
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxTranscodingJBIG", NULL);
}
switch (state->our_parms.rate_management) {
case AST_T38_RATE_MANAGEMENT_TRANSFERRED_TCF:
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxRateManagement", &STR_TRANSFERREDTCF);
break;
case AST_T38_RATE_MANAGEMENT_LOCAL_TCF:
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxRateManagement", &STR_LOCALTCF);
break;
}
snprintf(tmp, sizeof(tmp), "%u", ast_udptl_get_local_max_datagram(session_media->udptl));
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxMaxDatagram", pj_cstr(&stmp, tmp));
switch (ast_udptl_get_error_correction_scheme(session_media->udptl)) {
case UDPTL_ERROR_CORRECTION_NONE:
break;
case UDPTL_ERROR_CORRECTION_FEC:
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxUdpEC", &STR_T38UDPFEC);
break;
case UDPTL_ERROR_CORRECTION_REDUNDANCY:
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxUdpEC", &STR_T38UDPREDUNDANCY);
break;
}
sdp->media[sdp->media_count++] = media;
return 1;
}
/*
* pjsip_udp_transport_attach()
*
* Attach UDP socket and start transport.
*/
static pj_status_t transport_attach( pjsip_endpoint *endpt,
pjsip_transport_type_e type,
pj_sock_t sock,
const pjsip_host_port *a_name,
unsigned async_cnt,
pjsip_transport **p_transport)
{
pj_pool_t *pool;
struct udp_transport *tp;
const char *format, *ipv6_quoteb, *ipv6_quotee;
unsigned i;
pj_status_t status;
PJ_ASSERT_RETURN(endpt && sock!=PJ_INVALID_SOCKET && a_name && async_cnt>0,
PJ_EINVAL);
/* Object name. */
if (type & PJSIP_TRANSPORT_IPV6) {
format = "udpv6%p";
ipv6_quoteb = "[";
ipv6_quotee = "]";
} else {
format = "udp%p";
ipv6_quoteb = ipv6_quotee = "";
}
/* Create pool. */
pool = pjsip_endpt_create_pool(endpt, format, PJSIP_POOL_LEN_TRANSPORT,
PJSIP_POOL_INC_TRANSPORT);
if (!pool)
return PJ_ENOMEM;
/* Create the UDP transport object. */
tp = PJ_POOL_ZALLOC_T(pool, struct udp_transport);
/* Save pool. */
tp->base.pool = pool;
pj_memcpy(tp->base.obj_name, pool->obj_name, PJ_MAX_OBJ_NAME);
/* Init reference counter. */
status = pj_atomic_create(pool, 0, &tp->base.ref_cnt);
if (status != PJ_SUCCESS)
goto on_error;
/* Init lock. */
status = pj_lock_create_recursive_mutex(pool, pool->obj_name,
&tp->base.lock);
if (status != PJ_SUCCESS)
goto on_error;
/* Set type. */
tp->base.key.type = type;
/* Remote address is left zero (except the family) */
tp->base.key.rem_addr.addr.sa_family = (pj_uint16_t)
((type & PJSIP_TRANSPORT_IPV6) ? pj_AF_INET6() : pj_AF_INET());
/* Type name. */
tp->base.type_name = "UDP";
/* Transport flag */
tp->base.flag = pjsip_transport_get_flag_from_type(type);
/* Length of addressess. */
tp->base.addr_len = sizeof(tp->base.local_addr);
/* Init local address. */
status = pj_sock_getsockname(sock, &tp->base.local_addr,
&tp->base.addr_len);
if (status != PJ_SUCCESS)
goto on_error;
/* Init remote name. */
if (type == PJSIP_TRANSPORT_UDP)
tp->base.remote_name.host = pj_str("0.0.0.0");
else
tp->base.remote_name.host = pj_str("::0");
tp->base.remote_name.port = 0;
/* Init direction */
tp->base.dir = PJSIP_TP_DIR_NONE;
/* Set endpoint. */
tp->base.endpt = endpt;
/* Transport manager and timer will be initialized by tpmgr */
/* Attach socket and assign name. */
udp_set_socket(tp, sock, a_name);
/* Register to ioqueue */
status = register_to_ioqueue(tp);
if (status != PJ_SUCCESS)
goto on_error;
/* Set functions. */
tp->base.send_msg = &udp_send_msg;
tp->base.do_shutdown = &udp_shutdown;
tp->base.destroy = &udp_destroy;
/* This is a permanent transport, so we initialize the ref count
* to one so that transport manager don't destroy this transport
* when there's no user!
*/
pj_atomic_inc(tp->base.ref_cnt);
/* Register to transport manager. */
tp->base.tpmgr = pjsip_endpt_get_tpmgr(endpt);
status = pjsip_transport_register( tp->base.tpmgr, (pjsip_transport*)tp);
if (status != PJ_SUCCESS)
goto on_error;
/* Create rdata and put it in the array. */
tp->rdata_cnt = 0;
tp->rdata = (pjsip_rx_data**)
pj_pool_calloc(tp->base.pool, async_cnt,
sizeof(pjsip_rx_data*));
for (i=0; i<async_cnt; ++i) {
pj_pool_t *rdata_pool = pjsip_endpt_create_pool(endpt, "rtd%p",
PJSIP_POOL_RDATA_LEN,
PJSIP_POOL_RDATA_INC);
if (!rdata_pool) {
pj_atomic_set(tp->base.ref_cnt, 0);
pjsip_transport_destroy(&tp->base);
return PJ_ENOMEM;
}
init_rdata(tp, i, rdata_pool, NULL);
tp->rdata_cnt++;
}
/* Start reading the ioqueue. */
status = start_async_read(tp);
if (status != PJ_SUCCESS) {
pjsip_transport_destroy(&tp->base);
return status;
}
/* Done. */
if (p_transport)
*p_transport = &tp->base;
PJ_LOG(4,(tp->base.obj_name,
"SIP %s started, published address is %s%.*s%s:%d",
pjsip_transport_get_type_desc((pjsip_transport_type_e)tp->base.key.type),
ipv6_quoteb,
(int)tp->base.local_name.host.slen,
tp->base.local_name.host.ptr,
ipv6_quotee,
tp->base.local_name.port));
return PJ_SUCCESS;
on_error:
udp_destroy((pjsip_transport*)tp);
return status;
}
static int purity_test(void)
{
PJ_LOG(3,("test", "...purity_test()"));
#if defined(PJ_SOCKADDR_HAS_LEN) && PJ_SOCKADDR_HAS_LEN!=0
/* Check on "sin_len" member of sockaddr */
{
const pj_str_t str_ip = {"1.1.1.1", 7};
pj_sockaddr addr[16];
pj_addrinfo ai[16];
unsigned cnt;
pj_status_t rc;
/* pj_enum_ip_interface() */
cnt = PJ_ARRAY_SIZE(addr);
rc = pj_enum_ip_interface(pj_AF_UNSPEC(), &cnt, addr);
if (rc == PJ_SUCCESS) {
while (cnt--)
CHECK_SA_ZERO_LEN(&addr[cnt], -10);
}
/* pj_gethostip() on IPv4 */
rc = pj_gethostip(pj_AF_INET(), &addr[0]);
if (rc == PJ_SUCCESS)
CHECK_SA_ZERO_LEN(&addr[0], -20);
/* pj_gethostip() on IPv6 */
rc = pj_gethostip(pj_AF_INET6(), &addr[0]);
if (rc == PJ_SUCCESS)
CHECK_SA_ZERO_LEN(&addr[0], -30);
/* pj_getdefaultipinterface() on IPv4 */
rc = pj_getdefaultipinterface(pj_AF_INET(), &addr[0]);
if (rc == PJ_SUCCESS)
CHECK_SA_ZERO_LEN(&addr[0], -40);
/* pj_getdefaultipinterface() on IPv6 */
rc = pj_getdefaultipinterface(pj_AF_INET6(), &addr[0]);
if (rc == PJ_SUCCESS)
CHECK_SA_ZERO_LEN(&addr[0], -50);
/* pj_getaddrinfo() on a host name */
cnt = PJ_ARRAY_SIZE(ai);
rc = pj_getaddrinfo(pj_AF_UNSPEC(), pj_gethostname(), &cnt, ai);
if (rc == PJ_SUCCESS) {
while (cnt--)
CHECK_SA_ZERO_LEN(&ai[cnt].ai_addr, -60);
}
/* pj_getaddrinfo() on an IP address */
cnt = PJ_ARRAY_SIZE(ai);
rc = pj_getaddrinfo(pj_AF_UNSPEC(), &str_ip, &cnt, ai);
if (rc == PJ_SUCCESS) {
pj_assert(cnt == 1);
CHECK_SA_ZERO_LEN(&ai[0].ai_addr, -70);
}
}
#endif
return 0;
}
/**
* Create a SDP session description that describes the endpoint
* capability.
*/
PJ_DEF(pj_status_t) pjmedia_endpt_create_sdp( pjmedia_endpt *endpt,
pj_pool_t *pool,
unsigned stream_cnt,
const pjmedia_sock_info sock_info[],
pjmedia_sdp_session **p_sdp )
{
pj_time_val tv;
unsigned i;
const pj_sockaddr *addr0;
pjmedia_sdp_session *sdp;
pjmedia_sdp_media *m;
pjmedia_sdp_attr *attr;
/* Sanity check arguments */
PJ_ASSERT_RETURN(endpt && pool && p_sdp && stream_cnt, PJ_EINVAL);
/* Check that there are not too many codecs */
PJ_ASSERT_RETURN(endpt->codec_mgr.codec_cnt <= PJMEDIA_MAX_SDP_FMT,
PJ_ETOOMANY);
/* Create and initialize basic SDP session */
sdp = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_session);
addr0 = &sock_info[0].rtp_addr_name;
pj_gettimeofday(&tv);
sdp->origin.user = pj_str("-");
sdp->origin.version = sdp->origin.id = tv.sec + 2208988800UL;
sdp->origin.net_type = STR_IN;
if (addr0->addr.sa_family == pj_AF_INET()) {
sdp->origin.addr_type = STR_IP4;
pj_strdup2(pool, &sdp->origin.addr,
pj_inet_ntoa(addr0->ipv4.sin_addr));
} else if (addr0->addr.sa_family == pj_AF_INET6()) {
char tmp_addr[PJ_INET6_ADDRSTRLEN];
sdp->origin.addr_type = STR_IP6;
pj_strdup2(pool, &sdp->origin.addr,
pj_sockaddr_print(addr0, tmp_addr, sizeof(tmp_addr), 0));
} else {
pj_assert(!"Invalid address family");
return PJ_EAFNOTSUP;
}
sdp->name = STR_SDP_NAME;
/* Since we only support one media stream at present, put the
* SDP connection line in the session level.
*/
sdp->conn = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_conn);
sdp->conn->net_type = sdp->origin.net_type;
sdp->conn->addr_type = sdp->origin.addr_type;
sdp->conn->addr = sdp->origin.addr;
/* SDP time and attributes. */
sdp->time.start = sdp->time.stop = 0;
sdp->attr_count = 0;
/* Create media stream 0: */
sdp->media_count = 1;
m = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_media);
sdp->media[0] = m;
/* Standard media info: */
pj_strdup(pool, &m->desc.media, &STR_AUDIO);
m->desc.port = pj_sockaddr_get_port(addr0);
m->desc.port_count = 1;
pj_strdup (pool, &m->desc.transport, &STR_RTP_AVP);
/* Init media line and attribute list. */
m->desc.fmt_count = 0;
m->attr_count = 0;
/* Add "rtcp" attribute */
#if defined(PJMEDIA_HAS_RTCP_IN_SDP) && PJMEDIA_HAS_RTCP_IN_SDP!=0
if (sock_info->rtcp_addr_name.addr.sa_family != 0) {
attr = pjmedia_sdp_attr_create_rtcp(pool, &sock_info->rtcp_addr_name);
if (attr)
pjmedia_sdp_attr_add(&m->attr_count, m->attr, attr);
}
#endif
/* Add format, rtpmap, and fmtp (when applicable) for each codec */
for (i=0; i<endpt->codec_mgr.codec_cnt; ++i) {
pjmedia_codec_info *codec_info;
pjmedia_sdp_rtpmap rtpmap;
char tmp_param[3];
pjmedia_sdp_attr *attr;
pjmedia_codec_param codec_param;
pj_str_t *fmt;
if (endpt->codec_mgr.codec_desc[i].prio == PJMEDIA_CODEC_PRIO_DISABLED)
break;
codec_info = &endpt->codec_mgr.codec_desc[i].info;
pjmedia_codec_mgr_get_default_param(&endpt->codec_mgr, codec_info,
&codec_param);
fmt = &m->desc.fmt[m->desc.fmt_count++];
fmt->ptr = (char*) pj_pool_alloc(pool, 8);
fmt->slen = pj_utoa(codec_info->pt, fmt->ptr);
rtpmap.pt = *fmt;
rtpmap.enc_name = codec_info->encoding_name;
#if defined(PJMEDIA_HANDLE_G722_MPEG_BUG) && (PJMEDIA_HANDLE_G722_MPEG_BUG != 0)
if (codec_info->pt == PJMEDIA_RTP_PT_G722)
rtpmap.clock_rate = 8000;
else
rtpmap.clock_rate = codec_info->clock_rate;
#else
rtpmap.clock_rate = codec_info->clock_rate;
#endif
/* For audio codecs, rtpmap parameters denotes the number
* of channels, which can be omited if the value is 1.
*/
if (codec_info->type == PJMEDIA_TYPE_AUDIO &&
codec_info->channel_cnt > 1)
{
/* Can only support one digit channel count */
pj_assert(codec_info->channel_cnt < 10);
tmp_param[0] = (char)('0' + codec_info->channel_cnt);
rtpmap.param.ptr = tmp_param;
rtpmap.param.slen = 1;
} else {
rtpmap.param.slen = 0;
}
if (codec_info->pt >= 96 || pjmedia_add_rtpmap_for_static_pt) {
pjmedia_sdp_rtpmap_to_attr(pool, &rtpmap, &attr);
m->attr[m->attr_count++] = attr;
}
/* Add fmtp params */
if (codec_param.setting.dec_fmtp.cnt > 0) {
enum { MAX_FMTP_STR_LEN = 160 };
char buf[MAX_FMTP_STR_LEN];
unsigned buf_len = 0, i;
pjmedia_codec_fmtp *dec_fmtp = &codec_param.setting.dec_fmtp;
/* Print codec PT */
buf_len += pj_ansi_snprintf(buf,
MAX_FMTP_STR_LEN - buf_len,
"%d",
codec_info->pt);
for (i = 0; i < dec_fmtp->cnt; ++i) {
unsigned test_len = 2;
/* Check if buf still available */
test_len = dec_fmtp->param[i].val.slen +
dec_fmtp->param[i].name.slen;
if (test_len + buf_len >= MAX_FMTP_STR_LEN)
return PJ_ETOOBIG;
/* Print delimiter */
buf_len += pj_ansi_snprintf(&buf[buf_len],
MAX_FMTP_STR_LEN - buf_len,
(i == 0?" ":";"));
/* Print an fmtp param */
if (dec_fmtp->param[i].name.slen)
buf_len += pj_ansi_snprintf(
&buf[buf_len],
MAX_FMTP_STR_LEN - buf_len,
"%.*s=%.*s",
(int)dec_fmtp->param[i].name.slen,
dec_fmtp->param[i].name.ptr,
(int)dec_fmtp->param[i].val.slen,
dec_fmtp->param[i].val.ptr);
else
buf_len += pj_ansi_snprintf(&buf[buf_len],
MAX_FMTP_STR_LEN - buf_len,
"%.*s",
(int)dec_fmtp->param[i].val.slen,
dec_fmtp->param[i].val.ptr);
}
attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
attr->name = pj_str("fmtp");
attr->value = pj_strdup3(pool, buf);
m->attr[m->attr_count++] = attr;
}
}
/* Add sendrecv attribute. */
attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
attr->name = STR_SENDRECV;
m->attr[m->attr_count++] = attr;
#if defined(PJMEDIA_RTP_PT_TELEPHONE_EVENTS) && \
PJMEDIA_RTP_PT_TELEPHONE_EVENTS != 0
/*
* Add support telephony event
*/
m->desc.fmt[m->desc.fmt_count++] =
pj_str(PJMEDIA_RTP_PT_TELEPHONE_EVENTS_STR);
/* Add rtpmap. */
attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
attr->name = pj_str("rtpmap");
attr->value = pj_str(PJMEDIA_RTP_PT_TELEPHONE_EVENTS_STR
" telephone-event/8000");
m->attr[m->attr_count++] = attr;
/* Add fmtp */
attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
attr->name = pj_str("fmtp");
attr->value = pj_str(PJMEDIA_RTP_PT_TELEPHONE_EVENTS_STR " 0-15");
m->attr[m->attr_count++] = attr;
#endif
/* Done */
*p_sdp = sdp;
return PJ_SUCCESS;
}
static int format_test(void)
{
pj_str_t s = pj_str(ADDRESS);
unsigned char *p;
pj_in_addr addr;
char zero[64];
pj_sockaddr_in addr2;
const pj_str_t *hostname;
const unsigned char A[] = {127, 0, 0, 1};
PJ_LOG(3,("test", "...format_test()"));
/* pj_inet_aton() */
if (pj_inet_aton(&s, &addr) != 1)
return -10;
/* Check the result. */
p = (unsigned char*)&addr;
if (p[0]!=A[0] || p[1]!=A[1] || p[2]!=A[2] || p[3]!=A[3]) {
PJ_LOG(3,("test", " error: mismatched address. p0=%d, p1=%d, "
"p2=%d, p3=%d", p[0] & 0xFF, p[1] & 0xFF,
p[2] & 0xFF, p[3] & 0xFF));
return -15;
}
/* pj_inet_ntoa() */
p = (unsigned char*) pj_inet_ntoa(addr);
if (!p)
return -20;
if (pj_strcmp2(&s, (char*)p) != 0)
return -22;
#if defined(PJ_HAS_IPV6) && PJ_HAS_IPV6!=0
/* pj_inet_pton() */
/* pj_inet_ntop() */
{
const pj_str_t s_ipv4 = pj_str("127.0.0.1");
const pj_str_t s_ipv6 = pj_str("fe80::2ff:83ff:fe7c:8b42");
char buf_ipv4[PJ_INET_ADDRSTRLEN];
char buf_ipv6[PJ_INET6_ADDRSTRLEN];
pj_in_addr ipv4;
pj_in6_addr ipv6;
if (pj_inet_pton(pj_AF_INET(), &s_ipv4, &ipv4) != PJ_SUCCESS)
return -24;
p = (unsigned char*)&ipv4;
if (p[0]!=A[0] || p[1]!=A[1] || p[2]!=A[2] || p[3]!=A[3]) {
return -25;
}
if (pj_inet_pton(pj_AF_INET6(), &s_ipv6, &ipv6) != PJ_SUCCESS)
return -26;
p = (unsigned char*)&ipv6;
if (p[0] != 0xfe || p[1] != 0x80 || p[2] != 0 || p[3] != 0 ||
p[4] != 0 || p[5] != 0 || p[6] != 0 || p[7] != 0 ||
p[8] != 0x02 || p[9] != 0xff || p[10] != 0x83 || p[11] != 0xff ||
p[12]!=0xfe || p[13]!=0x7c || p[14] != 0x8b || p[15]!=0x42)
{
return -27;
}
if (pj_inet_ntop(pj_AF_INET(), &ipv4, buf_ipv4, sizeof(buf_ipv4)) != PJ_SUCCESS)
return -28;
if (pj_stricmp2(&s_ipv4, buf_ipv4) != 0)
return -29;
if (pj_inet_ntop(pj_AF_INET6(), &ipv6, buf_ipv6, sizeof(buf_ipv6)) != PJ_SUCCESS)
return -30;
if (pj_stricmp2(&s_ipv6, buf_ipv6) != 0)
return -31;
}
#endif /* PJ_HAS_IPV6 */
/* Test that pj_sockaddr_in_init() initialize the whole structure,
* including sin_zero.
*/
pj_sockaddr_in_init(&addr2, 0, 1000);
pj_bzero(zero, sizeof(zero));
if (pj_memcmp(addr2.sin_zero, zero, sizeof(addr2.sin_zero)) != 0)
return -35;
/* pj_gethostname() */
hostname = pj_gethostname();
if (!hostname || !hostname->ptr || !hostname->slen)
return -40;
PJ_LOG(3,("test", "....hostname is %.*s",
(int)hostname->slen, hostname->ptr));
/* pj_gethostaddr() */
/* Various constants */
#if !defined(PJ_SYMBIAN) || PJ_SYMBIAN==0
if (PJ_AF_INET==0xFFFF) return -5500;
if (PJ_AF_INET6==0xFFFF) return -5501;
/* 0xFFFF could be a valid SOL_SOCKET (e.g: on some Win or Mac) */
//if (PJ_SOL_SOCKET==0xFFFF) return -5503;
if (PJ_SOL_IP==0xFFFF) return -5502;
if (PJ_SOL_TCP==0xFFFF) return -5510;
if (PJ_SOL_UDP==0xFFFF) return -5520;
if (PJ_SOL_IPV6==0xFFFF) return -5530;
if (PJ_SO_TYPE==0xFFFF) return -5540;
if (PJ_SO_RCVBUF==0xFFFF) return -5550;
if (PJ_SO_SNDBUF==0xFFFF) return -5560;
if (PJ_TCP_NODELAY==0xFFFF) return -5570;
if (PJ_SO_REUSEADDR==0xFFFF) return -5580;
if (PJ_MSG_OOB==0xFFFF) return -5590;
if (PJ_MSG_PEEK==0xFFFF) return -5600;
#endif
return 0;
}
