static pj_status_t transport_get_info(pjmedia_transport *tp,
pjmedia_transport_info *info)
{
transport_srtp *srtp = (transport_srtp*) tp;
pjmedia_srtp_info srtp_info;
int spc_info_idx;
unsigned i;
PJ_ASSERT_RETURN(tp && info, PJ_EINVAL);
PJ_ASSERT_RETURN(info->specific_info_cnt <
PJMEDIA_TRANSPORT_SPECIFIC_INFO_MAXCNT, PJ_ETOOMANY);
PJ_ASSERT_RETURN(sizeof(pjmedia_srtp_info) <=
PJMEDIA_TRANSPORT_SPECIFIC_INFO_MAXSIZE, PJ_ENOMEM);
srtp_info.active = srtp->session_inited;
srtp_info.rx_policy = srtp->rx_policy;
srtp_info.tx_policy = srtp->tx_policy;
srtp_info.use = srtp->setting.use;
srtp_info.peer_use = srtp->peer_use;
spc_info_idx = info->specific_info_cnt++;
info->spc_info[spc_info_idx].type = PJMEDIA_TRANSPORT_TYPE_SRTP;
info->spc_info[spc_info_idx].cbsize = sizeof(srtp_info);
pj_memcpy(&info->spc_info[spc_info_idx].buffer, &srtp_info,
sizeof(srtp_info));
/* Invoke get_info() of all keying methods */
for (i=0; i < srtp->keying_cnt; i++)
pjmedia_transport_get_info(srtp->keying[i], info);
return pjmedia_transport_get_info(srtp->member_tp, info);
}
/*
* get_info() is called to get the transport addresses to be put
* in SDP c= line and a=rtcp line.
*/
static pj_status_t transport_get_info(pjmedia_transport *tp,
pjmedia_transport_info *info)
{
struct tp_adapter *adapter = (struct tp_adapter*)tp;
/* Since we don't have our own connection here, we just pass
* this function to the slave transport.
*/
return pjmedia_transport_get_info(adapter->slave_tp, info);
}
/*
* get_info() is called to get the transport addresses to be put
* in SDP c= line and a=rtcp line.
*/
static pj_status_t transport_get_info(pjmedia_transport *tp,
pjmedia_transport_info *info)
{
struct tp_zrtp *zrtp = (struct tp_zrtp*)tp;
pjmedia_zrtp_info zrtp_info;
int spc_info_idx;
PJ_ASSERT_RETURN(tp && info, PJ_EINVAL);
PJ_ASSERT_RETURN(info->specific_info_cnt <
PJMEDIA_TRANSPORT_SPECIFIC_INFO_MAXCNT, PJ_ETOOMANY);
zrtp_info.active = zrtp_inState(zrtp->zrtpCtx, SecureState) ? PJ_TRUE : PJ_FALSE;
spc_info_idx = info->specific_info_cnt++;
info->spc_info[spc_info_idx].type = PJMEDIA_TRANSPORT_TYPE_ZRTP;
pj_memcpy(&info->spc_info[spc_info_idx].buffer, &zrtp_info,
sizeof(zrtp_info));
return pjmedia_transport_get_info(zrtp->slave_tp, info);
}
struct jzrtp_allContext jzrtp_getContext(pjsua_call_id call_id) {
pjsua_call *call;
pj_status_t status;
unsigned i;
pjmedia_transport_info tp_info;
struct jzrtp_allContext result;
result.cbUserData = NULL;
result.zrtpContext = NULL;
PJ_ASSERT_RETURN(call_id>=0 && call_id<(int)pjsua_var.ua_cfg.max_calls,
NULL);
if (pjsua_call_has_media(call_id)) {
call = &pjsua_var.calls[call_id];
for (i = 0; i < call->med_cnt; ++i) {
pjsua_call_media *call_med = &call->media[i];
if (call_med->tp && call_med->type == PJMEDIA_TYPE_AUDIO) {
pjmedia_transport_info tp_info;
pjmedia_transport_info_init(&tp_info);
pjmedia_transport_get_info(call_med->tp, &tp_info);
if (tp_info.specific_info_cnt > 0) {
unsigned j;
for (j = 0; j < tp_info.specific_info_cnt; ++j) {
if (tp_info.spc_info[j].type
== PJMEDIA_TRANSPORT_TYPE_ZRTP) {
result.zrtpContext = pjmedia_transport_zrtp_getZrtpContext(call_med->tp);
result.cbUserData = (zrtp_cb_user_data*) pjmedia_transport_zrtp_getUserData(call_med->tp);
}
}
}
}
}
}
return result;
}
/**
* Is call using a secure RTP method (SRTP/ZRTP -- TODO)
*/
PJ_DECL(pj_bool_t) is_call_secure(pjsua_call_id call_id){
pjsua_call *call;
pjsip_dialog *dlg;
pj_status_t status;
pjmedia_transport_info tp_info;
pj_bool_t result = PJ_FALSE;
PJ_ASSERT_RETURN(call_id>=0 && call_id<(int)pjsua_var.ua_cfg.max_calls,
PJ_EINVAL);
status = acquire_call("is_call_secure()", call_id, &call, &dlg);
if (status != PJ_SUCCESS) {
return result;
}
/* Get and ICE SRTP status */
pjmedia_transport_info_init(&tp_info);
pjmedia_transport_get_info(call->med_tp, &tp_info);
if (tp_info.specific_info_cnt > 0) {
unsigned i;
for (i = 0; i < tp_info.specific_info_cnt; ++i) {
if (tp_info.spc_info[i].type == PJMEDIA_TRANSPORT_TYPE_SRTP) {
pjmedia_srtp_info *srtp_info =
(pjmedia_srtp_info*) tp_info.spc_info[i].buffer;
if(srtp_info->active){
result = PJ_TRUE;
}
}
}
}
pjsip_dlg_dec_lock(dlg);
return result;
}
/**
* Is call using a secure RTP method (SRTP/ZRTP)
*/
PJ_DECL(pj_str_t) call_secure_info(pjsua_call_id call_id) {
pjsua_call *call;
pj_status_t status;
unsigned i;
pjmedia_transport_info tp_info;
pj_str_t result = pj_str("");
PJ_ASSERT_RETURN(call_id>=0 && call_id<(int)pjsua_var.ua_cfg.max_calls,
result);
PJSUA_LOCK();
if (pjsua_call_has_media(call_id)) {
call = &pjsua_var.calls[call_id];
for (i = 0; i < call->med_cnt; ++i) {
pjsua_call_media *call_med = &call->media[i];
PJ_LOG(4, (THIS_FILE, "Get secure for media type %d", call_med->type));
if (call_med->tp && call_med->type == PJMEDIA_TYPE_AUDIO) {
pjmedia_transport_info tp_info;
pjmedia_transport_info_init(&tp_info);
pjmedia_transport_get_info(call_med->tp, &tp_info);
if (tp_info.specific_info_cnt > 0) {
unsigned j;
for (j = 0; j < tp_info.specific_info_cnt; ++j) {
if (tp_info.spc_info[j].type
== PJMEDIA_TRANSPORT_TYPE_SRTP) {
pjmedia_srtp_info *srtp_info =
(pjmedia_srtp_info*) tp_info.spc_info[j].buffer;
if (srtp_info->active) {
result = pj_str("SRTP");
break;
}
}
#if defined(PJMEDIA_HAS_ZRTP) && PJMEDIA_HAS_ZRTP!=0
else if (tp_info.spc_info[j].type
== PJMEDIA_TRANSPORT_TYPE_ZRTP) {
zrtp_state_info info = jzrtp_getInfoFromTransport(call_med->tp);
if(info.secure){
char msg[512];
PJ_LOG(4, (THIS_FILE, "ZRTP :: V %d", info.sas_verified));
PJ_LOG(4, (THIS_FILE, "ZRTP :: S L %d", info.sas.slen));
PJ_LOG(4, (THIS_FILE, "ZRTP :: C L %d", info.cipher.slen));
pj_ansi_snprintf(msg, sizeof(msg), "ZRTP - %s\n%.*s\n%.*s",
info.sas_verified ? "Verified": "Not verified",
info.sas.slen, info.sas.ptr,
info.cipher.slen, info.cipher.ptr);
pj_strdup2_with_null(css_var.pool, &result, msg);
break;
}
}
#endif
}
}
}
}
}
PJSUA_UNLOCK();
return result;
}
/*
* 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;
}
/* Dump media session */
static void dump_media_session(const char *indent,
char *buf, unsigned maxlen,
pjsua_call *call)
{
unsigned i;
char *p = buf, *end = buf+maxlen;
int len;
for (i=0; i<call->med_cnt; ++i) {
pjsua_call_media *call_med = &call->media[i];
pjmedia_rtcp_stat stat;
pj_bool_t has_stat;
pjmedia_transport_info tp_info;
char rem_addr_buf[80];
char codec_info[32] = {'0'};
char rx_info[80] = {'\0'};
char tx_info[80] = {'\0'};
const char *rem_addr;
const char *dir_str;
const char *media_type_str;
switch (call_med->type) {
case PJMEDIA_TYPE_AUDIO:
media_type_str = "audio";
break;
case PJMEDIA_TYPE_VIDEO:
media_type_str = "video";
break;
case PJMEDIA_TYPE_APPLICATION:
media_type_str = "application";
break;
default:
media_type_str = "unknown";
break;
}
/* Check if the stream is deactivated */
if (call_med->tp == NULL ||
(!call_med->strm.a.stream && !call_med->strm.v.stream))
{
len = pj_ansi_snprintf(p, end-p,
"%s #%d %s deactivated\n",
indent, i, media_type_str);
if (len < 1 || len > end-p) {
*p = '\0';
return;
}
p += len;
continue;
}
pjmedia_transport_info_init(&tp_info);
pjmedia_transport_get_info(call_med->tp, &tp_info);
// rem_addr will contain actual address of RTP originator, instead of
// remote RTP address specified by stream which is fetched from the SDP.
// Please note that we are assuming only one stream per call.
//rem_addr = pj_sockaddr_print(&info.stream_info[i].rem_addr,
// rem_addr_buf, sizeof(rem_addr_buf), 3);
if (pj_sockaddr_has_addr(&tp_info.src_rtp_name)) {
rem_addr = pj_sockaddr_print(&tp_info.src_rtp_name, rem_addr_buf,
sizeof(rem_addr_buf), 3);
} else {
pj_ansi_snprintf(rem_addr_buf, sizeof(rem_addr_buf), "-");
rem_addr = rem_addr_buf;
}
if (call_med->dir == PJMEDIA_DIR_NONE) {
/* To handle when the stream that is currently being paused
* (http://trac.pjsip.org/repos/ticket/1079)
*/
dir_str = "inactive";
} else if (call_med->dir == PJMEDIA_DIR_ENCODING)
dir_str = "sendonly";
else if (call_med->dir == PJMEDIA_DIR_DECODING)
dir_str = "recvonly";
else if (call_med->dir == PJMEDIA_DIR_ENCODING_DECODING)
dir_str = "sendrecv";
else
dir_str = "inactive";
if (call_med->type == PJMEDIA_TYPE_AUDIO) {
pjmedia_stream *stream = call_med->strm.a.stream;
pjmedia_stream_info info;
pjmedia_stream_get_stat(stream, &stat);
has_stat = PJ_TRUE;
pjmedia_stream_get_info(stream, &info);
pj_ansi_snprintf(codec_info, sizeof(codec_info), " %.*s @%dkHz",
(int)info.fmt.encoding_name.slen,
info.fmt.encoding_name.ptr,
info.fmt.clock_rate / 1000);
pj_ansi_snprintf(rx_info, sizeof(rx_info), "pt=%d,",
info.rx_pt);
pj_ansi_snprintf(tx_info, sizeof(tx_info), "pt=%d, ptime=%d,",
info.tx_pt,
info.param->setting.frm_per_pkt*
info.param->info.frm_ptime);
#if defined(PJMEDIA_HAS_VIDEO) && (PJMEDIA_HAS_VIDEO != 0)
} else if (call_med->type == PJMEDIA_TYPE_VIDEO) {
pjmedia_vid_stream *stream = call_med->strm.v.stream;
pjmedia_vid_stream_info info;
pjmedia_vid_stream_get_stat(stream, &stat);
has_stat = PJ_TRUE;
pjmedia_vid_stream_get_info(stream, &info);
pj_ansi_snprintf(codec_info, sizeof(codec_info), " %.*s",
(int)info.codec_info.encoding_name.slen,
info.codec_info.encoding_name.ptr);
if (call_med->dir & PJMEDIA_DIR_DECODING) {
pjmedia_video_format_detail *vfd;
vfd = pjmedia_format_get_video_format_detail(
&info.codec_param->dec_fmt, PJ_TRUE);
pj_ansi_snprintf(rx_info, sizeof(rx_info),
"pt=%d, size=%dx%d, fps=%.2f,",
info.rx_pt,
vfd->size.w, vfd->size.h,
vfd->fps.num*1.0/vfd->fps.denum);
}
if (call_med->dir & PJMEDIA_DIR_ENCODING) {
pjmedia_video_format_detail *vfd;
vfd = pjmedia_format_get_video_format_detail(
&info.codec_param->enc_fmt, PJ_TRUE);
pj_ansi_snprintf(tx_info, sizeof(tx_info),
"pt=%d, size=%dx%d, fps=%.2f,",
info.tx_pt,
vfd->size.w, vfd->size.h,
vfd->fps.num*1.0/vfd->fps.denum);
}
#endif /* PJMEDIA_HAS_VIDEO */
} else {
has_stat = PJ_FALSE;
}
len = pj_ansi_snprintf(p, end-p,
"%s #%d %s%s, %s, peer=%s\n",
indent,
call_med->idx,
media_type_str,
codec_info,
dir_str,
rem_addr);
if (len < 1 || len > end-p) {
*p = '\0';
return;
}
p += len;
/* Get and ICE SRTP status */
if (call_med->tp) {
pjmedia_transport_info tp_info;
pjmedia_transport_info_init(&tp_info);
pjmedia_transport_get_info(call_med->tp, &tp_info);
if (tp_info.specific_info_cnt > 0) {
unsigned j;
for (j = 0; j < tp_info.specific_info_cnt; ++j) {
if (tp_info.spc_info[j].type == PJMEDIA_TRANSPORT_TYPE_SRTP)
{
pjmedia_srtp_info *srtp_info =
(pjmedia_srtp_info*) tp_info.spc_info[j].buffer;
len = pj_ansi_snprintf(p, end-p,
" %s SRTP status: %s Crypto-suite: %s",
indent,
(srtp_info->active?"Active":"Not active"),
srtp_info->tx_policy.name.ptr);
if (len > 0 && len < end-p) {
p += len;
*p++ = '\n';
*p = '\0';
}
} else if (tp_info.spc_info[j].type==PJMEDIA_TRANSPORT_TYPE_ICE) {
const pjmedia_ice_transport_info *ii;
unsigned jj;
ii = (const pjmedia_ice_transport_info*)
tp_info.spc_info[j].buffer;
len = pj_ansi_snprintf(p, end-p,
" %s ICE role: %s, state: %s, comp_cnt: %u",
indent,
pj_ice_sess_role_name(ii->role),
pj_ice_strans_state_name(ii->sess_state),
ii->comp_cnt);
if (len > 0 && len < end-p) {
p += len;
*p++ = '\n';
*p = '\0';
}
for (jj=0; ii->sess_state==PJ_ICE_STRANS_STATE_RUNNING && jj<2; ++jj) {
const char *type1 = pj_ice_get_cand_type_name(ii->comp[jj].lcand_type);
const char *type2 = pj_ice_get_cand_type_name(ii->comp[jj].rcand_type);
char addr1[PJ_INET6_ADDRSTRLEN+10];
char addr2[PJ_INET6_ADDRSTRLEN+10];
if (pj_sockaddr_has_addr(&ii->comp[jj].lcand_addr))
pj_sockaddr_print(&ii->comp[jj].lcand_addr, addr1, sizeof(addr1), 3);
else
strcpy(addr1, "0.0.0.0:0");
if (pj_sockaddr_has_addr(&ii->comp[jj].rcand_addr))
pj_sockaddr_print(&ii->comp[jj].rcand_addr, addr2, sizeof(addr2), 3);
else
strcpy(addr2, "0.0.0.0:0");
len = pj_ansi_snprintf(p, end-p,
" %s [%d]: L:%s (%c) --> R:%s (%c)\n",
indent, jj,
addr1, type1[0],
addr2, type2[0]);
if (len > 0 && len < end-p) {
p += len;
*p = '\0';
}
}
}
}
}
}
if (has_stat) {
len = dump_media_stat(indent, p, end-p, &stat,
rx_info, tx_info);
p += len;
}
#if defined(PJMEDIA_HAS_RTCP_XR) && (PJMEDIA_HAS_RTCP_XR != 0)
# define SAMPLES_TO_USEC(usec, samples, clock_rate) \
do { \
if (samples <= 4294) \
usec = samples * 1000000 / clock_rate; \
else { \
usec = samples * 1000 / clock_rate; \
usec *= 1000; \
} \
} while(0)
# define PRINT_VOIP_MTC_VAL(s, v) \
if (v == 127) \
sprintf(s, "(na)"); \
else \
sprintf(s, "%d", v)
# define VALIDATE_PRINT_BUF() \
if (len < 1 || len > end-p) { *p = '\0'; return; } \
p += len; *p++ = '\n'; *p = '\0'
if (call_med->type == PJMEDIA_TYPE_AUDIO) {
pjmedia_stream_info info;
char last_update[64];
char loss[16], dup[16];
char jitter[80];
char toh[80];
char plc[16], jba[16], jbr[16];
char signal_lvl[16], noise_lvl[16], rerl[16];
char r_factor[16], ext_r_factor[16], mos_lq[16], mos_cq[16];
pjmedia_rtcp_xr_stat xr_stat;
unsigned clock_rate;
pj_time_val now;
if (pjmedia_stream_get_stat_xr(call_med->strm.a.stream,
&xr_stat) != PJ_SUCCESS)
{
continue;
}
if (pjmedia_stream_get_info(call_med->strm.a.stream, &info)
!= PJ_SUCCESS)
{
continue;
}
clock_rate = info.fmt.clock_rate;
pj_gettimeofday(&now);
len = pj_ansi_snprintf(p, end-p, "\n%s Extended reports:", indent);
VALIDATE_PRINT_BUF();
/* Statistics Summary */
len = pj_ansi_snprintf(p, end-p, "%s Statistics Summary", indent);
VALIDATE_PRINT_BUF();
if (xr_stat.rx.stat_sum.l)
sprintf(loss, "%d", xr_stat.rx.stat_sum.lost);
else
sprintf(loss, "(na)");
if (xr_stat.rx.stat_sum.d)
sprintf(dup, "%d", xr_stat.rx.stat_sum.dup);
else
sprintf(dup, "(na)");
if (xr_stat.rx.stat_sum.j) {
unsigned jmin, jmax, jmean, jdev;
SAMPLES_TO_USEC(jmin, xr_stat.rx.stat_sum.jitter.min,
clock_rate);
SAMPLES_TO_USEC(jmax, xr_stat.rx.stat_sum.jitter.max,
clock_rate);
SAMPLES_TO_USEC(jmean, xr_stat.rx.stat_sum.jitter.mean,
clock_rate);
SAMPLES_TO_USEC(jdev,
pj_math_stat_get_stddev(&xr_stat.rx.stat_sum.jitter),
clock_rate);
sprintf(jitter, "%7.3f %7.3f %7.3f %7.3f",
jmin/1000.0, jmean/1000.0, jmax/1000.0, jdev/1000.0);
} else
sprintf(jitter, "(report not available)");
if (xr_stat.rx.stat_sum.t) {
sprintf(toh, "%11d %11d %11d %11d",
xr_stat.rx.stat_sum.toh.min,
xr_stat.rx.stat_sum.toh.mean,
xr_stat.rx.stat_sum.toh.max,
pj_math_stat_get_stddev(&xr_stat.rx.stat_sum.toh));
} else
sprintf(toh, "(report not available)");
if (xr_stat.rx.stat_sum.update.sec == 0)
strcpy(last_update, "never");
else {
pj_gettimeofday(&now);
PJ_TIME_VAL_SUB(now, xr_stat.rx.stat_sum.update);
sprintf(last_update, "%02ldh:%02ldm:%02ld.%03lds ago",
now.sec / 3600,
(now.sec % 3600) / 60,
now.sec % 60,
now.msec);
}
len = pj_ansi_snprintf(p, end-p,
"%s RX last update: %s\n"
"%s begin seq=%d, end seq=%d\n"
"%s pkt loss=%s, dup=%s\n"
"%s (msec) min avg max dev\n"
"%s jitter : %s\n"
"%s toh : %s",
indent, last_update,
indent,
xr_stat.rx.stat_sum.begin_seq, xr_stat.rx.stat_sum.end_seq,
indent, loss, dup,
indent,
indent, jitter,
indent, toh
);
VALIDATE_PRINT_BUF();
if (xr_stat.tx.stat_sum.l)
sprintf(loss, "%d", xr_stat.tx.stat_sum.lost);
else
sprintf(loss, "(na)");
if (xr_stat.tx.stat_sum.d)
sprintf(dup, "%d", xr_stat.tx.stat_sum.dup);
else
sprintf(dup, "(na)");
if (xr_stat.tx.stat_sum.j) {
unsigned jmin, jmax, jmean, jdev;
SAMPLES_TO_USEC(jmin, xr_stat.tx.stat_sum.jitter.min,
clock_rate);
SAMPLES_TO_USEC(jmax, xr_stat.tx.stat_sum.jitter.max,
clock_rate);
SAMPLES_TO_USEC(jmean, xr_stat.tx.stat_sum.jitter.mean,
clock_rate);
SAMPLES_TO_USEC(jdev,
pj_math_stat_get_stddev(&xr_stat.tx.stat_sum.jitter),
clock_rate);
sprintf(jitter, "%7.3f %7.3f %7.3f %7.3f",
jmin/1000.0, jmean/1000.0, jmax/1000.0, jdev/1000.0);
} else
sprintf(jitter, "(report not available)");
if (xr_stat.tx.stat_sum.t) {
sprintf(toh, "%11d %11d %11d %11d",
xr_stat.tx.stat_sum.toh.min,
xr_stat.tx.stat_sum.toh.mean,
xr_stat.tx.stat_sum.toh.max,
pj_math_stat_get_stddev(&xr_stat.rx.stat_sum.toh));
} else
sprintf(toh, "(report not available)");
if (xr_stat.tx.stat_sum.update.sec == 0)
strcpy(last_update, "never");
else {
pj_gettimeofday(&now);
PJ_TIME_VAL_SUB(now, xr_stat.tx.stat_sum.update);
sprintf(last_update, "%02ldh:%02ldm:%02ld.%03lds ago",
now.sec / 3600,
(now.sec % 3600) / 60,
now.sec % 60,
now.msec);
}
len = pj_ansi_snprintf(p, end-p,
"%s TX last update: %s\n"
"%s begin seq=%d, end seq=%d\n"
"%s pkt loss=%s, dup=%s\n"
"%s (msec) min avg max dev\n"
"%s jitter : %s\n"
"%s toh : %s",
indent, last_update,
indent,
xr_stat.tx.stat_sum.begin_seq, xr_stat.tx.stat_sum.end_seq,
indent, loss, dup,
indent,
indent, jitter,
indent, toh
);
VALIDATE_PRINT_BUF();
/* VoIP Metrics */
len = pj_ansi_snprintf(p, end-p, "%s VoIP Metrics", indent);
VALIDATE_PRINT_BUF();
PRINT_VOIP_MTC_VAL(signal_lvl, xr_stat.rx.voip_mtc.signal_lvl);
PRINT_VOIP_MTC_VAL(noise_lvl, xr_stat.rx.voip_mtc.noise_lvl);
PRINT_VOIP_MTC_VAL(rerl, xr_stat.rx.voip_mtc.rerl);
PRINT_VOIP_MTC_VAL(r_factor, xr_stat.rx.voip_mtc.r_factor);
PRINT_VOIP_MTC_VAL(ext_r_factor, xr_stat.rx.voip_mtc.ext_r_factor);
PRINT_VOIP_MTC_VAL(mos_lq, xr_stat.rx.voip_mtc.mos_lq);
PRINT_VOIP_MTC_VAL(mos_cq, xr_stat.rx.voip_mtc.mos_cq);
switch ((xr_stat.rx.voip_mtc.rx_config>>6) & 3) {
case PJMEDIA_RTCP_XR_PLC_DIS:
sprintf(plc, "DISABLED");
break;
case PJMEDIA_RTCP_XR_PLC_ENH:
sprintf(plc, "ENHANCED");
break;
case PJMEDIA_RTCP_XR_PLC_STD:
sprintf(plc, "STANDARD");
break;
case PJMEDIA_RTCP_XR_PLC_UNK:
default:
sprintf(plc, "UNKNOWN");
break;
}
switch ((xr_stat.rx.voip_mtc.rx_config>>4) & 3) {
case PJMEDIA_RTCP_XR_JB_FIXED:
sprintf(jba, "FIXED");
break;
case PJMEDIA_RTCP_XR_JB_ADAPTIVE:
sprintf(jba, "ADAPTIVE");
break;
default:
sprintf(jba, "UNKNOWN");
break;
}
sprintf(jbr, "%d", xr_stat.rx.voip_mtc.rx_config & 0x0F);
if (xr_stat.rx.voip_mtc.update.sec == 0)
strcpy(last_update, "never");
else {
pj_gettimeofday(&now);
PJ_TIME_VAL_SUB(now, xr_stat.rx.voip_mtc.update);
sprintf(last_update, "%02ldh:%02ldm:%02ld.%03lds ago",
now.sec / 3600,
(now.sec % 3600) / 60,
now.sec % 60,
now.msec);
}
len = pj_ansi_snprintf(p, end-p,
"%s RX last update: %s\n"
"%s packets : loss rate=%d (%.2f%%), discard rate=%d (%.2f%%)\n"
"%s burst : density=%d (%.2f%%), duration=%d%s\n"
"%s gap : density=%d (%.2f%%), duration=%d%s\n"
"%s delay : round trip=%d%s, end system=%d%s\n"
"%s level : signal=%s%s, noise=%s%s, RERL=%s%s\n"
"%s quality : R factor=%s, ext R factor=%s\n"
"%s MOS LQ=%s, MOS CQ=%s\n"
"%s config : PLC=%s, JB=%s, JB rate=%s, Gmin=%d\n"
"%s JB delay : cur=%d%s, max=%d%s, abs max=%d%s",
indent,
last_update,
/* packets */
indent,
xr_stat.rx.voip_mtc.loss_rate, xr_stat.rx.voip_mtc.loss_rate*100.0/256,
xr_stat.rx.voip_mtc.discard_rate, xr_stat.rx.voip_mtc.discard_rate*100.0/256,
/* burst */
indent,
xr_stat.rx.voip_mtc.burst_den, xr_stat.rx.voip_mtc.burst_den*100.0/256,
xr_stat.rx.voip_mtc.burst_dur, "ms",
/* gap */
indent,
xr_stat.rx.voip_mtc.gap_den, xr_stat.rx.voip_mtc.gap_den*100.0/256,
xr_stat.rx.voip_mtc.gap_dur, "ms",
/* delay */
indent,
xr_stat.rx.voip_mtc.rnd_trip_delay, "ms",
xr_stat.rx.voip_mtc.end_sys_delay, "ms",
/* level */
indent,
signal_lvl, "dB",
noise_lvl, "dB",
rerl, "",
/* quality */
indent,
r_factor, ext_r_factor,
indent,
mos_lq, mos_cq,
/* config */
indent,
plc, jba, jbr, xr_stat.rx.voip_mtc.gmin,
/* JB delay */
indent,
xr_stat.rx.voip_mtc.jb_nom, "ms",
xr_stat.rx.voip_mtc.jb_max, "ms",
xr_stat.rx.voip_mtc.jb_abs_max, "ms"
);
VALIDATE_PRINT_BUF();
PRINT_VOIP_MTC_VAL(signal_lvl, xr_stat.tx.voip_mtc.signal_lvl);
PRINT_VOIP_MTC_VAL(noise_lvl, xr_stat.tx.voip_mtc.noise_lvl);
PRINT_VOIP_MTC_VAL(rerl, xr_stat.tx.voip_mtc.rerl);
PRINT_VOIP_MTC_VAL(r_factor, xr_stat.tx.voip_mtc.r_factor);
PRINT_VOIP_MTC_VAL(ext_r_factor, xr_stat.tx.voip_mtc.ext_r_factor);
PRINT_VOIP_MTC_VAL(mos_lq, xr_stat.tx.voip_mtc.mos_lq);
PRINT_VOIP_MTC_VAL(mos_cq, xr_stat.tx.voip_mtc.mos_cq);
switch ((xr_stat.tx.voip_mtc.rx_config>>6) & 3) {
case PJMEDIA_RTCP_XR_PLC_DIS:
sprintf(plc, "DISABLED");
break;
case PJMEDIA_RTCP_XR_PLC_ENH:
sprintf(plc, "ENHANCED");
break;
case PJMEDIA_RTCP_XR_PLC_STD:
sprintf(plc, "STANDARD");
break;
case PJMEDIA_RTCP_XR_PLC_UNK:
default:
sprintf(plc, "unknown");
break;
}
switch ((xr_stat.tx.voip_mtc.rx_config>>4) & 3) {
case PJMEDIA_RTCP_XR_JB_FIXED:
sprintf(jba, "FIXED");
break;
case PJMEDIA_RTCP_XR_JB_ADAPTIVE:
sprintf(jba, "ADAPTIVE");
break;
default:
sprintf(jba, "unknown");
break;
}
sprintf(jbr, "%d", xr_stat.tx.voip_mtc.rx_config & 0x0F);
if (xr_stat.tx.voip_mtc.update.sec == 0)
strcpy(last_update, "never");
else {
pj_gettimeofday(&now);
PJ_TIME_VAL_SUB(now, xr_stat.tx.voip_mtc.update);
sprintf(last_update, "%02ldh:%02ldm:%02ld.%03lds ago",
now.sec / 3600,
(now.sec % 3600) / 60,
now.sec % 60,
now.msec);
}
len = pj_ansi_snprintf(p, end-p,
"%s TX last update: %s\n"
"%s packets : loss rate=%d (%.2f%%), discard rate=%d (%.2f%%)\n"
"%s burst : density=%d (%.2f%%), duration=%d%s\n"
"%s gap : density=%d (%.2f%%), duration=%d%s\n"
"%s delay : round trip=%d%s, end system=%d%s\n"
"%s level : signal=%s%s, noise=%s%s, RERL=%s%s\n"
"%s quality : R factor=%s, ext R factor=%s\n"
"%s MOS LQ=%s, MOS CQ=%s\n"
"%s config : PLC=%s, JB=%s, JB rate=%s, Gmin=%d\n"
"%s JB delay : cur=%d%s, max=%d%s, abs max=%d%s",
indent,
last_update,
/* pakcets */
indent,
xr_stat.tx.voip_mtc.loss_rate, xr_stat.tx.voip_mtc.loss_rate*100.0/256,
xr_stat.tx.voip_mtc.discard_rate, xr_stat.tx.voip_mtc.discard_rate*100.0/256,
/* burst */
indent,
xr_stat.tx.voip_mtc.burst_den, xr_stat.tx.voip_mtc.burst_den*100.0/256,
xr_stat.tx.voip_mtc.burst_dur, "ms",
/* gap */
indent,
xr_stat.tx.voip_mtc.gap_den, xr_stat.tx.voip_mtc.gap_den*100.0/256,
xr_stat.tx.voip_mtc.gap_dur, "ms",
/* delay */
indent,
xr_stat.tx.voip_mtc.rnd_trip_delay, "ms",
xr_stat.tx.voip_mtc.end_sys_delay, "ms",
/* level */
indent,
signal_lvl, "dB",
noise_lvl, "dB",
rerl, "",
/* quality */
indent,
r_factor, ext_r_factor,
indent,
mos_lq, mos_cq,
/* config */
indent,
plc, jba, jbr, xr_stat.tx.voip_mtc.gmin,
/* JB delay */
indent,
xr_stat.tx.voip_mtc.jb_nom, "ms",
xr_stat.tx.voip_mtc.jb_max, "ms",
xr_stat.tx.voip_mtc.jb_abs_max, "ms"
);
VALIDATE_PRINT_BUF();
/* RTT delay (by receiver side) */
len = pj_ansi_snprintf(p, end-p,
"%s RTT (from recv) min avg max last dev",
indent);
VALIDATE_PRINT_BUF();
len = pj_ansi_snprintf(p, end-p,
"%s RTT msec : %7.3f %7.3f %7.3f %7.3f %7.3f",
indent,
xr_stat.rtt.min / 1000.0,
xr_stat.rtt.mean / 1000.0,
xr_stat.rtt.max / 1000.0,
xr_stat.rtt.last / 1000.0,
pj_math_stat_get_stddev(&xr_stat.rtt) / 1000.0
);
VALIDATE_PRINT_BUF();
} /* if audio */;
#endif
}
/**
* Is call using a secure RTP method (SRTP/ZRTP)
*/
PJ_DECL(pj_str_t) call_secure_info(pjsua_call_id call_id) {
pjsua_call *call;
pjsip_dialog *dlg;
pj_status_t status;
unsigned i;
pjmedia_transport_info tp_info;
pj_str_t result = pj_str("");
PJ_LOG(3, (THIS_FILE, "Get call secure info..."));
PJ_ASSERT_RETURN(call_id>=0 && call_id<(int)pjsua_var.ua_cfg.max_calls,
result);
/* Use PJSUA_LOCK() instead of acquire_call():
* https://trac.pjsip.org/repos/ticket/1371
*/
PJSUA_LOCK();
if (pjsua_call_has_media(call_id)) {
call = &pjsua_var.calls[call_id];
for (i = 0; i < call->med_cnt; ++i) {
pjsua_call_media *call_med = &call->media[i];
PJ_LOG(4, (THIS_FILE, "Get secure for media type %d", call_med->type));
/* Get and ICE SRTP status */
if (call_med->tp && call_med->type == PJMEDIA_TYPE_AUDIO) {
pjmedia_transport_info tp_info;
pjmedia_transport_info_init(&tp_info);
pjmedia_transport_get_info(call_med->tp, &tp_info);
if (tp_info.specific_info_cnt > 0) {
unsigned j;
for (j = 0; j < tp_info.specific_info_cnt; ++j) {
if (tp_info.spc_info[j].type
== PJMEDIA_TRANSPORT_TYPE_SRTP) {
pjmedia_srtp_info *srtp_info =
(pjmedia_srtp_info*) tp_info.spc_info[j].buffer;
if (srtp_info->active) {
result = pj_str("SRTP");
break;
}
}
#if defined(PJMEDIA_HAS_ZRTP) && PJMEDIA_HAS_ZRTP!=0
else if (tp_info.spc_info[j].type
== PJMEDIA_TRANSPORT_TYPE_ZRTP) {
pjmedia_zrtp_info *zrtp_info =
(pjmedia_zrtp_info*) tp_info.spc_info[j].buffer;
// if(zrtp_info->active){
result = jzrtp_getInfo(call_med->tp);
break;
// }
}
#endif
}
}
}
}
}
PJSUA_UNLOCK();
return result;
}
