static int tcp_perf_test(void)
{
enum { COUNT=10000 };
pj_pool_t *pool = NULL;
pj_ioqueue_t *ioqueue = NULL;
pj_sock_t sock1=PJ_INVALID_SOCKET, sock2=PJ_INVALID_SOCKET;
pj_activesock_t *asock1 = NULL, *asock2 = NULL;
pj_activesock_cb cb;
struct tcp_state *state1, *state2;
unsigned i;
pj_status_t status;
pool = pj_pool_create(mem, "tcpperf", 256, 256, NULL);
status = app_socketpair(pj_AF_INET(), pj_SOCK_STREAM(), 0, &sock1,
&sock2);
if (status != PJ_SUCCESS) {
status = -100;
goto on_return;
}
status = pj_ioqueue_create(pool, 4, &ioqueue);
if (status != PJ_SUCCESS) {
status = -110;
goto on_return;
}
pj_bzero(&cb, sizeof(cb));
cb.on_data_read = &tcp_on_data_read;
cb.on_data_sent = &tcp_on_data_sent;
state1 = PJ_POOL_ZALLOC_T(pool, struct tcp_state);
status = pj_activesock_create(pool, sock1, pj_SOCK_STREAM(), NULL, ioqueue,
&cb, state1, &asock1);
if (status != PJ_SUCCESS) {
status = -120;
goto on_return;
}
state2 = PJ_POOL_ZALLOC_T(pool, struct tcp_state);
status = pj_activesock_create(pool, sock2, pj_SOCK_STREAM(), NULL, ioqueue,
&cb, state2, &asock2);
if (status != PJ_SUCCESS) {
status = -130;
goto on_return;
}
status = pj_activesock_start_read(asock1, pool, 1000, 0);
if (status != PJ_SUCCESS) {
status = -140;
goto on_return;
}
/* Send packet as quickly as possible */
for (i=0; i<COUNT && !state1->err && !state2->err; ++i) {
struct tcp_pkt *pkt;
struct send_key send_key[2], *op_key;
pj_ssize_t len;
pkt = (struct tcp_pkt*)state2->pkt;
pkt->signature = SIGNATURE;
pkt->seq = i;
pj_memset(pkt->fill, 'a', sizeof(pkt->fill));
op_key = &send_key[i%2];
pj_ioqueue_op_key_init(&op_key->op_key, sizeof(*op_key));
state2->sent = PJ_FALSE;
len = sizeof(*pkt);
status = pj_activesock_send(asock2, &op_key->op_key, pkt, &len, 0);
if (status == PJ_EPENDING) {
do {
#if PJ_SYMBIAN
pj_symbianos_poll(-1, -1);
#else
pj_ioqueue_poll(ioqueue, NULL);
#endif
} while (!state2->sent);
} else {
#if PJ_SYMBIAN
/* The Symbian socket always returns PJ_SUCCESS for TCP send,
* eventhough the remote end hasn't received the data yet.
* If we continue sending, eventually send() will block,
* possibly because the send buffer is full. So we need to
* poll the ioqueue periodically, to let receiver gets the
* data.
*/
pj_symbianos_poll(-1, 0);
#endif
if (status != PJ_SUCCESS) {
PJ_LOG(1,("", " err: send status=%d", status));
status = -180;
break;
} else if (status == PJ_SUCCESS) {
if (len != sizeof(*pkt)) {
PJ_LOG(1,("", " err: shouldn't report partial sent"));
status = -190;
break;
}
}
}
#ifndef PJ_SYMBIAN
for (;;) {
pj_time_val timeout = {0, 10};
if (pj_ioqueue_poll(ioqueue, &timeout) < 1)
break;
}
#endif
}
/* Wait until everything has been sent/received */
if (state1->next_recv_seq < COUNT) {
#ifdef PJ_SYMBIAN
while (pj_symbianos_poll(-1, 1000) == PJ_TRUE)
;
#else
pj_time_val delay = {0, 100};
while (pj_ioqueue_poll(ioqueue, &delay) > 0)
;
#endif
}
if (status == PJ_EPENDING)
status = PJ_SUCCESS;
if (status != 0)
goto on_return;
if (state1->err) {
status = -183;
goto on_return;
}
if (state2->err) {
status = -186;
goto on_return;
}
if (state1->next_recv_seq != COUNT) {
PJ_LOG(3,("", " err: only %u packets received, expecting %u",
state1->next_recv_seq, COUNT));
status = -195;
goto on_return;
}
on_return:
if (asock2)
pj_activesock_close(asock2);
if (asock1)
pj_activesock_close(asock1);
if (ioqueue)
pj_ioqueue_destroy(ioqueue);
if (pool)
pj_pool_release(pool);
return status;
}
static int fingerprint_test_vector()
{
pj_pool_t *pool;
pj_status_t status;
unsigned i;
int rc = 0;
/* To avoid function not referenced warnings */
(void)create_msgint2;
(void)create_msgint3;
PJ_LOG(3,(THIS_FILE, " draft-denis-behave-rfc3489bis-test-vectors-02"));
pool = pj_pool_create(mem, "fingerprint", 1024, 1024, NULL);
for (i=0; i<PJ_ARRAY_SIZE(test_vectors); ++i) {
struct test_vector *v;
pj_stun_msg *ref_msg, *msg;
pj_size_t parsed_len;
pj_size_t len;
unsigned pos;
pj_uint8_t buf[1500];
char print[1500];
pj_str_t key;
PJ_LOG(3,(THIS_FILE, " Running test %d/%d", i,
PJ_ARRAY_SIZE(test_vectors)));
v = &test_vectors[i];
/* Print reference message */
PJ_LOG(4,(THIS_FILE, "Reference message PDU:\n%s",
print_binary((pj_uint8_t*)v->pdu, v->pdu_len)));
/* Try to parse the reference message first */
status = pj_stun_msg_decode(pool, (pj_uint8_t*)v->pdu, v->pdu_len,
PJ_STUN_IS_DATAGRAM | PJ_STUN_CHECK_PACKET,
&ref_msg, &parsed_len, NULL);
if (status != PJ_SUCCESS) {
PJ_LOG(1,(THIS_FILE, " Error decoding reference message"));
rc = -1010;
goto on_return;
}
if (parsed_len != v->pdu_len) {
PJ_LOG(1,(THIS_FILE, " Parsed len error"));
rc = -1020;
goto on_return;
}
/* Print the reference message */
pj_stun_msg_dump(ref_msg, print, sizeof(print), NULL);
PJ_LOG(4,(THIS_FILE, "Reference message:\n%s", print));
/* Create our message */
msg = v->create(pool, v);
if (msg == NULL) {
PJ_LOG(1,(THIS_FILE, " Error creating stun message"));
rc = -1030;
goto on_return;
}
/* Encode message */
if (v->options & USE_MESSAGE_INTEGRITY) {
pj_str_t s1, s2, r;
pj_stun_create_key(pool, &key, pj_cstr(&r, v->realm),
pj_cstr(&s1, v->username),
PJ_STUN_PASSWD_PLAIN,
pj_cstr(&s2, v->password));
pj_stun_msg_encode(msg, buf, sizeof(buf), 0, &key, &len);
} else {
pj_stun_msg_encode(msg, buf, sizeof(buf), 0, NULL, &len);
}
/* Print our raw message */
PJ_LOG(4,(THIS_FILE, "Message PDU:\n%s",
print_binary((pj_uint8_t*)buf, (unsigned)len)));
/* Print our message */
pj_stun_msg_dump(msg, print, sizeof(print), NULL);
PJ_LOG(4,(THIS_FILE, "Message is:\n%s", print));
/* Compare message length */
if (len != v->pdu_len) {
PJ_LOG(1,(THIS_FILE, " Message length mismatch"));
rc = -1050;
goto on_return;
}
pos = cmp_buf(buf, (const pj_uint8_t*)v->pdu, (unsigned)len);
if (pos != (unsigned)-1) {
PJ_LOG(1,(THIS_FILE, " Message mismatch at byte %d", pos));
rc = -1060;
goto on_return;
}
/* Authenticate the request/response */
if (v->options & USE_MESSAGE_INTEGRITY) {
if (PJ_STUN_IS_REQUEST(msg->hdr.type)) {
pj_stun_auth_cred cred;
pj_status_t status;
pj_bzero(&cred, sizeof(cred));
cred.type = PJ_STUN_AUTH_CRED_STATIC;
cred.data.static_cred.realm = pj_str(v->realm);
cred.data.static_cred.username = pj_str(v->username);
cred.data.static_cred.data = pj_str(v->password);
cred.data.static_cred.nonce = pj_str(v->nonce);
status = pj_stun_authenticate_request(buf, (unsigned)len, msg,
&cred, pool, NULL, NULL);
if (status != PJ_SUCCESS) {
char errmsg[PJ_ERR_MSG_SIZE];
pj_strerror(status, errmsg, sizeof(errmsg));
PJ_LOG(1,(THIS_FILE,
" Request authentication failed: %s",
errmsg));
rc = -1070;
goto on_return;
}
} else if (PJ_STUN_IS_RESPONSE(msg->hdr.type)) {
pj_status_t status;
status = pj_stun_authenticate_response(buf, (unsigned)len,
msg, &key);
if (status != PJ_SUCCESS) {
char errmsg[PJ_ERR_MSG_SIZE];
pj_strerror(status, errmsg, sizeof(errmsg));
PJ_LOG(1,(THIS_FILE,
" Response authentication failed: %s",
errmsg));
rc = -1080;
goto on_return;
}
}
}
}
on_return:
pj_pool_release(pool);
return rc;
}
/* API: refresh the device list */
static pj_status_t alsa_factory_refresh(pjmedia_aud_dev_factory *f)
{
struct alsa_factory *af = (struct alsa_factory*)f;
char **hints, **n;
int err;
TRACE_((THIS_FILE, "pjmedia_snd_init: Enumerate sound devices"));
if (af->pool != NULL) {
pj_pool_release(af->pool);
af->pool = NULL;
}
af->pool = pj_pool_create(af->pf, "alsa_aud", 256, 256, NULL);
af->dev_cnt = 0;
/* Enumerate sound devices */
err = snd_device_name_hint(-1, "pcm", (void***)&hints);
if (err != 0)
return PJMEDIA_EAUD_SYSERR;
/* Set a null error handler prior to enumeration to suppress errors */
snd_lib_error_set_handler(null_alsa_error_handler);
n = hints;
while (*n != NULL) {
char *name = snd_device_name_get_hint(*n, "NAME");
char *desc = snd_device_name_get_hint(*n, "DESC");
if (name != NULL) {
if (strncmp("null", name, 4) == 0 ||
strncmp("front", name, 5) == 0 ||
strncmp("rear", name, 4) == 0 ||
strncmp("side", name, 4) == 0 ||
strncmp("dmix", name, 4) == 0 ||
strncmp("dsnoop", name, 6) == 0 ||
strncmp("hw", name, 2) == 0 ||
strncmp("plughw", name, 6) == 0 ||
strncmp("center_lfe", name, 10) == 0 ||
strncmp("surround40", name, 10) == 0 ||
strncmp("surround41", name, 10) == 0 ||
strncmp("surround50", name, 10) == 0 ||
strncmp("surround51", name, 10) == 0 ||
strncmp("surround71", name, 10) == 0 ||
(strncmp("default", name, 7) == 0 && strstr(name, ":CARD=") != NULL)) {
/* skip these devices, 'sysdefault' always contains the relevant information */
;
} else {
add_dev(af, name, desc);
}
free(name);
free(desc);
}
n++;
}
/* Install error handler after enumeration, otherwise we'll get many
* error messages about invalid card/device ID.
*/
snd_lib_error_set_handler(alsa_error_handler);
err = snd_device_name_free_hint((void**)hints);
PJ_LOG(4,(THIS_FILE, "ALSA driver found %d devices", af->dev_cnt));
return PJ_SUCCESS;
}
pj_status_t session_test (pj_pool_factory *pf)
{
pj_med_mgr_t *mm;
pj_media_session_t *s1, *s2;
pj_pool_t *pool;
pjsdp_session_desc *sdp;
pj_media_stream_info sd_info;
char buf[1024];
int len;
pj_media_stream_stat tx_stat, rx_stat;
pool = pj_pool_create(pf, "test", 4096, 1024, NULL);
// Init media manager.
mm = pj_med_mgr_create ( pf );
// Create caller session.
// THIS WILL DEFINITELY CRASH (NULL as argument)!
s1 = pj_media_session_create (mm, NULL);
// Set caller's media to send-only.
sd_info.dir = PJMEDIA_DIR_ENCODING;
pj_media_session_modify_stream (s1, 0, PJMEDIA_STREAM_MODIFY_DIR, &sd_info);
// Create caller SDP.
sdp = pj_media_session_create_sdp (s1, pool, 0);
len = pjsdp_print (sdp, buf, sizeof(buf));
buf[len] = '\0';
printf("Caller's initial SDP:\n<BEGIN>\n%s\n<END>\n", buf);
// Parse SDP from caller.
sdp = pjsdp_parse (buf, len, pool);
// Create callee session based on caller's SDP.
// THIS WILL DEFINITELY CRASH (NULL as argument)!
s2 = pj_media_session_create_from_sdp (mm, sdp, NULL);
// Create callee SDP
sdp = pj_media_session_create_sdp (s2, pool, 0);
len = pjsdp_print (sdp, buf, sizeof(buf));
buf[len] = '\0';
printf("Callee's SDP:\n<BEGIN>\n%s\n<END>\n", buf);
// Parse SDP from callee.
sdp = pjsdp_parse (buf, len, pool);
// Update caller
pj_media_session_update (s1, sdp);
sdp = pj_media_session_create_sdp (s1, pool, 0);
pjsdp_print (sdp, buf, sizeof(buf));
printf("Caller's SDP after update:\n<BEGIN>\n%s\n<END>\n", buf);
// Now start media.
pj_media_session_activate (s2);
pj_media_session_activate (s1);
// Wait
for (;;) {
int has_stat;
printf("Enter q to exit, 1 or 2 to print statistics.\n");
fgets (buf, 10, stdin);
has_stat = 0;
switch (buf[0]) {
case 'q':
case 'Q':
goto done;
break;
case '1':
pj_media_session_get_stat (s1, 0, &tx_stat, &rx_stat);
has_stat = 1;
break;
case '2':
pj_media_session_get_stat (s2, 0, &tx_stat, &rx_stat);
has_stat = 1;
break;
}
if (has_stat) {
pj_media_stream_stat *stat[2] = { &tx_stat, &rx_stat };
const char *statname[2] = { "TX", "RX" };
int i;
for (i=0; i<2; ++i) {
printf("%s statistics:\n", statname[i]);
printf(" Pkt TX=%d RX=%d\n", stat[i]->pkt_tx, stat[i]->pkt_rx);
printf(" Octets TX=%d RX=%d\n", stat[i]->oct_tx, stat[i]->oct_rx);
printf(" Jitter %d ms\n", stat[i]->jitter);
printf(" Pkt lost %d\n", stat[i]->pkt_lost);
}
printf("\n");
}
}
done:
// Done.
pj_pool_release (pool);
pj_media_session_destroy (s2);
pj_media_session_destroy (s1);
pj_med_mgr_destroy (mm);
return 0;
}
static pj_bool_t srv_on_data_recvfrom(pj_activesock_t *asock,
void *data,
pj_size_t size,
const pj_sockaddr_t *src_addr,
int addr_len,
pj_status_t status)
{
struct stun_srv *srv;
pj_ssize_t sent;
srv = (struct stun_srv*) pj_activesock_get_user_data(asock);
/* Ignore error */
if (status != PJ_SUCCESS)
return PJ_TRUE;
++srv->rx_cnt;
/* Ignore if we're not responding */
if (srv->flag & RESPOND_STUN) {
pj_pool_t *pool;
pj_stun_msg *req_msg, *res_msg;
pool = pj_pool_create(mem, "stunsrv", 512, 512, NULL);
/* Parse request */
status = pj_stun_msg_decode(pool, (pj_uint8_t*)data, size,
PJ_STUN_IS_DATAGRAM | PJ_STUN_CHECK_PACKET,
&req_msg, NULL, NULL);
if (status != PJ_SUCCESS) {
app_perror(" pj_stun_msg_decode()", status);
pj_pool_release(pool);
return PJ_TRUE;
}
/* Create response */
status = pj_stun_msg_create(pool, PJ_STUN_BINDING_RESPONSE, PJ_STUN_MAGIC,
req_msg->hdr.tsx_id, &res_msg);
if (status != PJ_SUCCESS) {
app_perror(" pj_stun_msg_create()", status);
pj_pool_release(pool);
return PJ_TRUE;
}
/* Add MAPPED-ADDRESS or XOR-MAPPED-ADDRESS (or don't add) */
if (srv->flag & WITH_MAPPED) {
pj_sockaddr_in addr;
pj_sockaddr_in_init(&addr, &srv->ip_to_send, srv->port_to_send);
pj_stun_msg_add_sockaddr_attr(pool, res_msg, PJ_STUN_ATTR_MAPPED_ADDR,
PJ_FALSE, &addr, sizeof(addr));
} else if (srv->flag & WITH_XOR_MAPPED) {
pj_sockaddr_in addr;
pj_sockaddr_in_init(&addr, &srv->ip_to_send, srv->port_to_send);
pj_stun_msg_add_sockaddr_attr(pool, res_msg,
PJ_STUN_ATTR_XOR_MAPPED_ADDR,
PJ_TRUE, &addr, sizeof(addr));
}
/* Encode */
status = pj_stun_msg_encode(res_msg, (pj_uint8_t*)data, 100, 0,
NULL, &size);
if (status != PJ_SUCCESS) {
app_perror(" pj_stun_msg_encode()", status);
pj_pool_release(pool);
return PJ_TRUE;
}
/* Send back */
sent = size;
pj_activesock_sendto(asock, &srv->send_key, data, &sent, 0,
src_addr, addr_len);
pj_pool_release(pool);
} else if (srv->flag & ECHO) {
/* Send back */
sent = size;
pj_activesock_sendto(asock, &srv->send_key, data, &sent, 0,
src_addr, addr_len);
}
return PJ_TRUE;
}
PJ_DEF(pj_status_t) pjmedia_vid_port_create( pj_pool_t *pool,
const pjmedia_vid_port_param *prm,
pjmedia_vid_port **p_vid_port)
{
pjmedia_vid_port *vp;
const pjmedia_video_format_detail *vfd;
char dev_name[64];
char fmt_name[5];
pjmedia_vid_dev_cb vid_cb;
pj_bool_t need_frame_buf = PJ_FALSE;
pj_status_t status;
unsigned ptime_usec;
pjmedia_vid_dev_param vparam;
pjmedia_vid_dev_info di;
unsigned i;
PJ_ASSERT_RETURN(pool && prm && p_vid_port, PJ_EINVAL);
PJ_ASSERT_RETURN(prm->vidparam.fmt.type == PJMEDIA_TYPE_VIDEO &&
prm->vidparam.dir != PJMEDIA_DIR_NONE &&
prm->vidparam.dir != PJMEDIA_DIR_CAPTURE_RENDER,
PJ_EINVAL);
/* Retrieve the video format detail */
vfd = pjmedia_format_get_video_format_detail(&prm->vidparam.fmt, PJ_TRUE);
if (!vfd)
return PJ_EINVAL;
PJ_ASSERT_RETURN(vfd->fps.num, PJ_EINVAL);
/* Allocate videoport */
vp = PJ_POOL_ZALLOC_T(pool, pjmedia_vid_port);
vp->pool = pj_pool_create(pool->factory, "video port", 500, 500, NULL);
vp->role = prm->active ? ROLE_ACTIVE : ROLE_PASSIVE;
vp->dir = prm->vidparam.dir;
// vp->cap_size = vfd->size;
vparam = prm->vidparam;
dev_name[0] = '\0';
/* Get device info */
if (vp->dir & PJMEDIA_DIR_CAPTURE)
status = pjmedia_vid_dev_get_info(prm->vidparam.cap_id, &di);
else
status = pjmedia_vid_dev_get_info(prm->vidparam.rend_id, &di);
if (status != PJ_SUCCESS)
return status;
pj_ansi_snprintf(dev_name, sizeof(dev_name), "%s [%s]",
di.name, di.driver);
for (i = 0; i < di.fmt_cnt; ++i) {
if (prm->vidparam.fmt.id == di.fmt[i].id)
break;
}
if (i == di.fmt_cnt) {
/* The device has no no matching format. Pick one from
* the supported formats, and later use converter to
* convert it to the required format.
*/
pj_assert(di.fmt_cnt != 0);
vparam.fmt.id = di.fmt[0].id;
}
pj_strdup2_with_null(pool, &vp->dev_name, di.name);
vp->stream_role = di.has_callback ? ROLE_ACTIVE : ROLE_PASSIVE;
pjmedia_fourcc_name(vparam.fmt.id, fmt_name);
PJ_LOG(4,(THIS_FILE,
"Opening device %s for %s: format=%s, size=%dx%d @%d:%d fps",
dev_name,
vid_dir_name(prm->vidparam.dir), fmt_name,
vfd->size.w, vfd->size.h,
vfd->fps.num, vfd->fps.denum));
ptime_usec = PJMEDIA_PTIME(&vfd->fps);
pjmedia_clock_src_init(&vp->clocksrc, PJMEDIA_TYPE_VIDEO,
prm->vidparam.clock_rate, ptime_usec);
vp->sync_clocksrc.max_sync_ticks =
PJMEDIA_CLOCK_SYNC_MAX_RESYNC_DURATION *
1000 / vp->clocksrc.ptime_usec;
/* Create the video stream */
pj_bzero(&vid_cb, sizeof(vid_cb));
vid_cb.capture_cb = &vidstream_cap_cb;
vid_cb.render_cb = &vidstream_render_cb;
status = pjmedia_vid_dev_stream_create(&vparam, &vid_cb, vp,
&vp->strm);
if (status != PJ_SUCCESS)
goto on_error;
PJ_LOG(4,(THIS_FILE,
"Device %s opened: format=%s, size=%dx%d @%d:%d fps",
dev_name, fmt_name,
vparam.fmt.det.vid.size.w, vparam.fmt.det.vid.size.h,
vparam.fmt.det.vid.fps.num, vparam.fmt.det.vid.fps.denum));
/* Subscribe to device's events */
pjmedia_event_subscribe(NULL, &vidstream_event_cb,
vp, vp->strm);
if (vp->dir & PJMEDIA_DIR_CAPTURE) {
pjmedia_format_copy(&vp->conv.conv_param.src, &vparam.fmt);
pjmedia_format_copy(&vp->conv.conv_param.dst, &prm->vidparam.fmt);
} else {
pjmedia_format_copy(&vp->conv.conv_param.src, &prm->vidparam.fmt);
pjmedia_format_copy(&vp->conv.conv_param.dst, &vparam.fmt);
}
status = create_converter(vp);
if (status != PJ_SUCCESS)
goto on_error;
if (vp->role==ROLE_ACTIVE &&
((vp->dir & PJMEDIA_DIR_ENCODING) || vp->stream_role==ROLE_PASSIVE))
{
pjmedia_clock_param param;
/* Active role is wanted, but our device is passive, so create
* master clocks to run the media flow. For encoding direction,
* we also want to create our own clock since the device's clock
* may run at a different rate.
*/
need_frame_buf = PJ_TRUE;
param.usec_interval = PJMEDIA_PTIME(&vfd->fps);
param.clock_rate = prm->vidparam.clock_rate;
status = pjmedia_clock_create2(pool, ¶m,
PJMEDIA_CLOCK_NO_HIGHEST_PRIO,
(vp->dir & PJMEDIA_DIR_ENCODING) ?
&enc_clock_cb: &dec_clock_cb,
vp, &vp->clock);
if (status != PJ_SUCCESS)
goto on_error;
} else if (vp->role==ROLE_PASSIVE) {
vid_pasv_port *pp;
/* Always need to create media port for passive role */
vp->pasv_port = pp = PJ_POOL_ZALLOC_T(pool, vid_pasv_port);
pp->vp = vp;
pp->base.get_frame = &vid_pasv_port_get_frame;
pp->base.put_frame = &vid_pasv_port_put_frame;
pjmedia_port_info_init2(&pp->base.info, &vp->dev_name,
PJMEDIA_SIG_VID_PORT,
prm->vidparam.dir, &prm->vidparam.fmt);
if (vp->stream_role == ROLE_ACTIVE) {
need_frame_buf = PJ_TRUE;
}
}
if (need_frame_buf) {
const pjmedia_video_format_info *vfi;
pjmedia_video_apply_fmt_param vafp;
vfi = pjmedia_get_video_format_info(NULL, vparam.fmt.id);
if (!vfi) {
status = PJ_ENOTFOUND;
goto on_error;
}
pj_bzero(&vafp, sizeof(vafp));
vafp.size = vparam.fmt.det.vid.size;
status = vfi->apply_fmt(vfi, &vafp);
if (status != PJ_SUCCESS)
goto on_error;
vp->frm_buf = PJ_POOL_ZALLOC_T(pool, pjmedia_frame);
vp->frm_buf_size = vafp.framebytes;
vp->frm_buf->buf = pj_pool_alloc(pool, vafp.framebytes);
vp->frm_buf->size = vp->frm_buf_size;
vp->frm_buf->type = PJMEDIA_FRAME_TYPE_NONE;
status = pj_mutex_create_simple(pool, vp->dev_name.ptr,
&vp->frm_mutex);
if (status != PJ_SUCCESS)
goto on_error;
}
*p_vid_port = vp;
return PJ_SUCCESS;
on_error:
pjmedia_vid_port_destroy(vp);
return status;
}
static pj_status_t factory_create_streamBDIMAD(pjmedia_aud_dev_factory *f,
const pjmedia_aud_param *param,
pjmedia_aud_rec_cb rec_cb,
pjmedia_aud_play_cb play_cb,
void *user_data,
pjmedia_aud_stream **p_aud_strm)
{
struct bd_factory *wf = (struct bd_factory*)f;
pj_pool_t *pool;
struct bd_stream *strm;
pj_uint8_t silence_char;
pj_status_t status;
switch (param->ext_fmt.id) {
case PJMEDIA_FORMAT_L16:
silence_char = '\0';
break;
default:
return PJMEDIA_EAUD_BADFORMAT;
}
/* Create and Initialize stream descriptor */
pool = pj_pool_create(wf->pf, "BDIMAD_STREAM", 1000, 1000, NULL);
PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
strm = PJ_POOL_ZALLOC_T(pool, struct bd_stream);
pj_memcpy(&strm->param, param, sizeof(*param));
strm->pool = pool;
strm->rec_cb = rec_cb;
strm->play_cb = play_cb;
strm->user_data = user_data;
strm->fmt_id = (pjmedia_format_id)param->ext_fmt.id;
strm->silence_char = silence_char;
strm->channel_count = param->channel_count;
strm->samples_per_frame = param->samples_per_frame;
if (param->dir & PJMEDIA_DIR_CAPTURE_PLAYBACK) {
status = init_streams(wf, strm, param);
if (status != PJ_SUCCESS) {
stream_destroyBDIMAD(&strm->base);
return status;
}
} else {
stream_destroyBDIMAD(&strm->base);
return PJMEDIA_EAUD_ERR;
}
strm->rec_buf = (pj_int16_t*)pj_pool_alloc(pool,
strm->bytes_per_frame);
if (!strm->rec_buf) {
pj_pool_release(pool);
return PJ_ENOMEM;
}
strm->rec_buf_count = 0;
strm->play_buf = (pj_int16_t*)pj_pool_alloc(pool,
strm->bytes_per_frame);
if (!strm->play_buf) {
pj_pool_release(pool);
return PJ_ENOMEM;
}
strm->play_buf_count = 0;
/* Apply the remaining settings */
if(param->flags & PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING) {
stream_set_capBDIMAD(&strm->base,
PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING,
¶m->output_vol);
}
if(param->flags & PJMEDIA_AUD_DEV_CAP_INPUT_VOLUME_SETTING) {
stream_set_capBDIMAD(&strm->base,
PJMEDIA_AUD_DEV_CAP_INPUT_VOLUME_SETTING,
¶m->input_vol);
}
if(param->flags & PJMEDIA_AUD_DEV_CAP_EC) {
stream_set_capBDIMAD(&strm->base,
PJMEDIA_AUD_DEV_CAP_EC,
¶m->ec_enabled);
}
strm->base.op = &stream_op;
*p_aud_strm = &strm->base;
return PJ_SUCCESS;
}
int string_test(void)
{
const pj_str_t hello_world = { HELLO_WORLD, HELLO_WORLD_LEN };
const pj_str_t just_hello = { JUST_HELLO, JUST_HELLO_LEN };
pj_str_t s1, s2, s3, s4, s5;
enum { RCOUNT = 10, RLEN = 16 };
pj_str_t random[RCOUNT];
pj_pool_t *pool;
int i;
pool = pj_pool_create(mem, SNULL, 4096, 0, SNULL);
if (!pool) return -5;
/*
* pj_str(), pj_strcmp(), pj_stricmp(), pj_strlen(),
* pj_strncmp(), pj_strchr()
*/
s1 = pj_str(HELLO_WORLD);
if (pj_strcmp(&s1, &hello_world) != 0)
return -10;
if (pj_stricmp(&s1, &hello_world) != 0)
return -20;
if (pj_strcmp(&s1, &just_hello) <= 0)
return -30;
if (pj_stricmp(&s1, &just_hello) <= 0)
return -40;
if (pj_strlen(&s1) != strlen(HELLO_WORLD))
return -50;
if (pj_strncmp(&s1, &hello_world, 5) != 0)
return -60;
if (pj_strnicmp(&s1, &hello_world, 5) != 0)
return -70;
if (pj_strchr(&s1, HELLO_WORLD[1]) != s1.ptr+1)
return -80;
/*
* pj_strdup()
*/
if (!pj_strdup(pool, &s2, &s1))
return -100;
if (pj_strcmp(&s1, &s2) != 0)
return -110;
/*
* pj_strcpy(), pj_strcat()
*/
s3.ptr = (char*) pj_pool_alloc(pool, 256);
if (!s3.ptr)
return -200;
pj_strcpy(&s3, &s2);
pj_strcat(&s3, &just_hello);
if (pj_strcmp2(&s3, HELLO_WORLD JUST_HELLO) != 0)
return -210;
/*
* pj_strdup2(), pj_strtrim().
*/
pj_strdup2(pool, &s4, " " HELLO_WORLD "\t ");
pj_strtrim(&s4);
if (pj_strcmp2(&s4, HELLO_WORLD) != 0)
return -250;
/*
* pj_utoa()
*/
s5.ptr = (char*) pj_pool_alloc(pool, 16);
if (!s5.ptr)
return -270;
s5.slen = pj_utoa(UL_VALUE, s5.ptr);
/*
* pj_strtoul()
*/
if (pj_strtoul(&s5) != UL_VALUE)
return -280;
/*
* pj_strtoul2()
*/
s5 = pj_str("123456");
pj_strtoul2(&s5, SNULL, 10); /* Crash test */
if (pj_strtoul2(&s5, &s4, 10) != 123456UL)
return -290;
if (s4.slen != 0)
return -291;
if (pj_strtoul2(&s5, &s4, 16) != 0x123456UL)
return -292;
s5 = pj_str("0123ABCD");
if (pj_strtoul2(&s5, &s4, 10) != 123)
return -293;
if (s4.slen != 4)
return -294;
if (s4.ptr == SNULL || *s4.ptr != 'A')
return -295;
if (pj_strtoul2(&s5, &s4, 16) != 0x123ABCDUL)
return -296;
if (s4.slen != 0)
return -297;
/*
* pj_create_random_string()
* Check that no duplicate strings are returned.
*/
for (i=0; i<RCOUNT; ++i) {
int j;
random[i].ptr = (char*) pj_pool_alloc(pool, RLEN);
if (!random[i].ptr)
return -320;
random[i].slen = RLEN;
pj_create_random_string(random[i].ptr, RLEN);
for (j=0; j<i; ++j) {
if (pj_strcmp(&random[i], &random[j])==0)
return -330;
}
}
/* Done. */
pj_pool_release(pool);
/* Case sensitive comparison test. */
i = strcmp_test();
if (i != 0)
return i;
/* Caseless comparison test. */
i = stricmp_test();
if (i != 0)
return i;
return 0;
}
/* API: create stream */
static pj_status_t bb10_factory_create_stream(pjmedia_aud_dev_factory *f,
const pjmedia_aud_param *param,
pjmedia_aud_rec_cb rec_cb,
pjmedia_aud_play_cb play_cb,
void *user_data,
pjmedia_aud_stream **p_strm)
{
struct bb10_factory *af = (struct bb10_factory*)f;
pj_status_t status;
pj_pool_t* pool;
struct bb10_stream* stream;
pool = pj_pool_create (af->pf, "bb10%p", 1024, 1024, NULL);
if (!pool)
return PJ_ENOMEM;
/* Allocate and initialize comon stream data */
stream = PJ_POOL_ZALLOC_T (pool, struct bb10_stream);
stream->base.op = &bb10_stream_op;
stream->pool = pool;
stream->af = af;
stream->user_data = user_data;
stream->pb_cb = play_cb;
stream->ca_cb = rec_cb;
stream->quit = 0;
pj_memcpy(&stream->param, param, sizeof(*param));
/* Init playback */
if (param->dir & PJMEDIA_DIR_PLAYBACK) {
status = bb10_open_playback (stream, param);
if (status != PJ_SUCCESS) {
pj_pool_release (pool);
return status;
}
}
/* Init capture */
if (param->dir & PJMEDIA_DIR_CAPTURE) {
status = bb10_open_capture (stream, param);
if (status != PJ_SUCCESS) {
if (param->dir & PJMEDIA_DIR_PLAYBACK) {
close_play_pcm(stream);
}
pj_pool_release (pool);
return status;
}
}
/* Set the audio routing ONLY if app explicitly asks one */
if ((param->dir & PJMEDIA_DIR_PLAYBACK) &&
(param->flags & PJMEDIA_AUD_DEV_CAP_OUTPUT_ROUTE))
{
status = bb10_stream_set_cap(&stream->base,
PJMEDIA_AUD_DEV_CAP_OUTPUT_ROUTE,
¶m->output_route);
if (status != PJ_SUCCESS) {
TRACE_((THIS_FILE, "Error setting output route"));
bb10_stream_destroy(&stream->base);
return status;
}
} else {
/* Legacy behavior: if none specified, set to speaker */
status = bb10_initialize_playback_ctrl(stream, false);
}
*p_strm = &stream->base;
return PJ_SUCCESS;
}
/* API: refresh the device list */
static pj_status_t factory_refresh(pjmedia_aud_dev_factory *f)
{
struct bd_factory *wf = (struct bd_factory*)f;
unsigned int i = 0;
wchar_t *deviceNamep=NULL;
wchar_t captureDevName[BD_IMAD_MAX_DEV_COUNT][BD_IMAD_MAX_DEV_LENGTH_NAME];
unsigned int captureDeviceCount = 0;
wchar_t playbackDevName[BD_IMAD_MAX_DEV_COUNT][BD_IMAD_MAX_DEV_LENGTH_NAME];
unsigned int playbackDeviceCount = 0;
if(wf->pool != NULL) {
pj_pool_release(wf->pool);
wf->pool = NULL;
}
// Enumerate capture sound devices
while(bdIMADpj_getDeviceName(BD_IMAD_CAPTURE_DEVICES, &deviceNamep) !=
BD_PJ_ERROR_IMAD_DEVICE_LIST_EMPTY)
{
wcscpy(captureDevName[captureDeviceCount], deviceNamep);
captureDeviceCount++;
}
// Enumerate playback sound devices
while(bdIMADpj_getDeviceName(BD_IMAD_PLAYBACK_DEVICES, &deviceNamep) !=
BD_PJ_ERROR_IMAD_DEVICE_LIST_EMPTY)
{
wcscpy(playbackDevName[playbackDeviceCount], deviceNamep);
playbackDeviceCount++;
}
// Set devices info
wf->dev_count = captureDeviceCount + playbackDeviceCount;
wf->pool = pj_pool_create(wf->pf, "BD_IMAD_DEVICES", 1000, 1000, NULL);
wf->dev_info = (struct bddev_info*)pj_pool_calloc(wf->pool, wf->dev_count,
sizeof(struct bddev_info));
// Capture device properties
for(i=0;i<captureDeviceCount;i++) {
wf->dev_info[i].deviceId = i;
wf->dev_info[i].info.caps = PJMEDIA_AUD_DEV_CAP_INPUT_VOLUME_SETTING |
PJMEDIA_AUD_DEV_CAP_EC;
wf->dev_info[i].info.default_samples_per_sec = BD_IMAD_DEFAULT_FREQ;
strcpy(wf->dev_info[i].info.driver, "BD_IMAD");
wf->dev_info[i].info.ext_fmt_cnt = 0;
wf->dev_info[i].info.input_count = BD_IMAD_MAX_CHANNELS;
wf->dev_info[i].info.output_count = 0;
strcpy(wf->dev_info[i].info.name,
BD_IMAD_PJ_WCHARtoCHAR(captureDevName[i]));
wf->dev_info[i].info.routes = 0;
}
// Playback device properties
for(i=0;i<playbackDeviceCount;i++) {
wf->dev_info[captureDeviceCount+i].deviceId = captureDeviceCount+i;
wf->dev_info[captureDeviceCount+i].info.caps =
PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING;
wf->dev_info[captureDeviceCount+i].info.default_samples_per_sec =
BD_IMAD_DEFAULT_FREQ;
strcpy(wf->dev_info[captureDeviceCount+i].info.driver, "BD_IMAD");
wf->dev_info[captureDeviceCount+i].info.ext_fmt_cnt = 0;
wf->dev_info[captureDeviceCount+i].info.input_count = 0;
wf->dev_info[captureDeviceCount+i].info.output_count =
BD_IMAD_MAX_CHANNELS;
strcpy(wf->dev_info[captureDeviceCount+i].info.name,
BD_IMAD_PJ_WCHARtoCHAR(playbackDevName[i]));
wf->dev_info[captureDeviceCount+i].info.routes = 0;
}
PJ_LOG(4, (THIS_FILE, "BDIMAD found %d devices:", wf->dev_count));
for(i=0; i<wf->dev_count; i++) {
PJ_LOG(4,
(THIS_FILE, " dev_id %d: %s (in=%d, out=%d)",
i,
wf->dev_info[i].info.name,
wf->dev_info[i].info.input_count,
wf->dev_info[i].info.output_count));
}
return PJ_SUCCESS;
}
/*
* 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;
pj_sockaddr bound_addr;
unsigned i;
pj_uint16_t max_bind_retry;
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;
if (cfg && cfg->grp_lock) {
stun_sock->grp_lock = cfg->grp_lock;
} else {
status = pj_grp_lock_create(pool, NULL, &stun_sock->grp_lock);
if (status != PJ_SUCCESS) {
pj_pool_release(pool);
return status;
}
}
pj_grp_lock_add_ref(stun_sock->grp_lock);
pj_grp_lock_add_handler(stun_sock->grp_lock, pool, stun_sock,
&stun_sock_destructor);
/* 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;
/* Apply socket buffer size */
if (cfg->so_rcvbuf_size > 0) {
unsigned sobuf_size = cfg->so_rcvbuf_size;
status = pj_sock_setsockopt_sobuf(stun_sock->sock_fd, pj_SO_RCVBUF(),
PJ_TRUE, &sobuf_size);
if (status != PJ_SUCCESS) {
pj_perror(3, stun_sock->obj_name, status,
"Failed setting SO_RCVBUF");
} else {
if (sobuf_size < cfg->so_rcvbuf_size) {
PJ_LOG(4, (stun_sock->obj_name,
"Warning! Cannot set SO_RCVBUF as configured, "
"now=%d, configured=%d",
sobuf_size, cfg->so_rcvbuf_size));
} else {
PJ_LOG(5, (stun_sock->obj_name, "SO_RCVBUF set to %d",
sobuf_size));
}
}
}
if (cfg->so_sndbuf_size > 0) {
unsigned sobuf_size = cfg->so_sndbuf_size;
status = pj_sock_setsockopt_sobuf(stun_sock->sock_fd, pj_SO_SNDBUF(),
PJ_TRUE, &sobuf_size);
if (status != PJ_SUCCESS) {
pj_perror(3, stun_sock->obj_name, status,
"Failed setting SO_SNDBUF");
} else {
if (sobuf_size < cfg->so_sndbuf_size) {
PJ_LOG(4, (stun_sock->obj_name,
"Warning! Cannot set SO_SNDBUF as configured, "
"now=%d, configured=%d",
sobuf_size, cfg->so_sndbuf_size));
} else {
PJ_LOG(5, (stun_sock->obj_name, "SO_SNDBUF set to %d",
sobuf_size));
}
}
}
/* Bind socket */
max_bind_retry = MAX_BIND_RETRY;
if (cfg->port_range && cfg->port_range < max_bind_retry)
max_bind_retry = cfg->port_range;
pj_sockaddr_init(af, &bound_addr, NULL, 0);
if (cfg->bound_addr.addr.sa_family == pj_AF_INET() ||
cfg->bound_addr.addr.sa_family == pj_AF_INET6())
{
pj_sockaddr_cp(&bound_addr, &cfg->bound_addr);
}
status = pj_sock_bind_random(stun_sock->sock_fd, &bound_addr,
cfg->port_range, max_bind_retry);
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.grp_lock = stun_sock->grp_lock;
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->grp_lock,
&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;
}
/*
* Encode test. Read input from WAV file, encode to temporary output file,
* and compare the temporary output file to the reference file.
*/
static int codec_test_encode(pjmedia_codec_mgr *mgr,
char *codec_name,
unsigned bitrate,
const char *wav_file,
const char *ref_encoded_file)
{
pj_str_t codec_id = pj_str(codec_name);
pj_pool_t *pool = NULL;
unsigned count, samples_per_frame, encoded_frame_len = 0, pos;
pjmedia_codec *codec = NULL;
const pjmedia_codec_info *ci[1];
pjmedia_codec_param codec_param;
pjmedia_port *wav_port = NULL;
pjmedia_frame in_frame, out_frame;
FILE *output = NULL, *fref = NULL;
int rc = 0;
pj_status_t status;
pool = pj_pool_create(mem, "codec-vectors", 512, 512, NULL);
if (!pool) {
rc = -20;
goto on_return;
}
/* Find and open the codec */
count = 1;
status = pjmedia_codec_mgr_find_codecs_by_id(mgr, &codec_id, &count, ci, NULL);
if (status != PJ_SUCCESS) {
rc = -30;
goto on_return;
}
status = pjmedia_codec_mgr_alloc_codec(mgr, ci[0], &codec);
if (status != PJ_SUCCESS) {
rc = -40;
goto on_return;
}
status = pjmedia_codec_mgr_get_default_param(mgr, ci[0], &codec_param);
if (status != PJ_SUCCESS) {
rc = -50;
goto on_return;
}
codec_param.info.avg_bps = bitrate;
codec_param.setting.vad = 0;
status = codec->op->init(codec, pool);
if (status != PJ_SUCCESS) {
rc = -60;
goto on_return;
}
status = codec->op->open(codec, &codec_param);
if (status != PJ_SUCCESS) {
rc = -70;
goto on_return;
}
/* Open WAV file */
status = pjmedia_wav_player_port_create(pool, wav_file,
codec_param.info.frm_ptime,
PJMEDIA_FILE_NO_LOOP, 0,
&wav_port);
if (status != PJ_SUCCESS) {
rc = -80;
goto on_return;
}
/* Open output file */
output = fopen(TMP_OUT, "wb");
if (!output) {
rc = -90;
goto on_return;
}
/* Allocate buffer for PCM and encoded frames */
samples_per_frame = codec_param.info.clock_rate * codec_param.info.frm_ptime / 1000;
in_frame.buf = pj_pool_alloc(pool, samples_per_frame * 2);
out_frame.buf = (pj_uint8_t*) pj_pool_alloc(pool, samples_per_frame);
/* Loop read WAV file and encode and write to output file */
for (;;) {
in_frame.size = samples_per_frame * 2;
in_frame.type = PJMEDIA_FRAME_TYPE_AUDIO;
status = pjmedia_port_get_frame(wav_port, &in_frame);
if (status != PJ_SUCCESS || in_frame.type != PJMEDIA_FRAME_TYPE_AUDIO)
break;
out_frame.size = samples_per_frame;
status = codec->op->encode(codec, &in_frame, samples_per_frame,
&out_frame);
if (status != PJ_SUCCESS) {
rc = -95;
goto on_return;
}
if (out_frame.size) {
int cnt;
cnt = fwrite(out_frame.buf, out_frame.size, 1, output);
if (encoded_frame_len == 0)
encoded_frame_len = out_frame.size;
}
}
fclose(output);
output = NULL;
/* Compare encoded files */
fref = fopen(ref_encoded_file, "rb");
if (!fref) {
rc = -100;
goto on_return;
}
output = fopen(TMP_OUT, "rb");
if (!output) {
rc = -110;
goto on_return;
}
pos = 0;
for (;;) {
int count;
count = fread(in_frame.buf, encoded_frame_len, 1, fref);
if (count != 1)
break;
count = fread(out_frame.buf, encoded_frame_len, 1, output);
if (count != 1)
break;
if (memcmp(in_frame.buf, out_frame.buf, encoded_frame_len)) {
unsigned i;
pj_uint8_t *in = (pj_uint8_t*)in_frame.buf;
pj_uint8_t *out = (pj_uint8_t*)out_frame.buf;
for (i=0; i<encoded_frame_len; ++i) {
if (in[i] != out[i])
break;
}
PJ_LOG(1,(THIS_FILE," failed: mismatch at pos %d", pos+i));
rc = -200;
break;
}
pos += encoded_frame_len;
}
on_return:
if (output)
fclose(output);
if (fref)
fclose(fref);
if (codec) {
codec->op->close(codec);
pjmedia_codec_mgr_dealloc_codec(mgr, codec);
}
if (wav_port)
pjmedia_port_destroy(wav_port);
if (pool)
pj_pool_release(pool);
return rc;
}
/*
* Decode test
*
* Decode the specified encoded file in "in_encoded_file" into temporary
* PCM output file, and compare the temporary PCM output file with
* the PCM reference file.
*
* Some reference file requires manipulation to the PCM output
* before comparison, such manipulation can be done by supplying
* this function with the "manip" function.
*/
static int codec_test_decode(pjmedia_codec_mgr *mgr,
char *codec_name,
unsigned bitrate,
unsigned encoded_len,
const char *in_encoded_file,
const char *ref_pcm_file,
void (*manip)(short *pcm, unsigned count))
{
pj_str_t codec_id = pj_str(codec_name);
pj_pool_t *pool = NULL;
unsigned count, samples_per_frame, pos;
pjmedia_codec *codec = NULL;
const pjmedia_codec_info *ci[1];
pjmedia_codec_param codec_param;
pjmedia_frame out_frame;
void *pkt;
FILE *input = NULL, *output = NULL, *fref = NULL;
pj_bool_t is_itu_format = PJ_FALSE;
int rc = 0;
pj_status_t status;
pool = pj_pool_create(mem, "codec-vectors", 512, 512, NULL);
if (!pool) {
rc = -20;
goto on_return;
}
/* Find and open the codec */
count = 1;
status = pjmedia_codec_mgr_find_codecs_by_id(mgr, &codec_id, &count, ci, NULL);
if (status != PJ_SUCCESS) {
rc = -30;
goto on_return;
}
status = pjmedia_codec_mgr_alloc_codec(mgr, ci[0], &codec);
if (status != PJ_SUCCESS) {
rc = -40;
goto on_return;
}
status = pjmedia_codec_mgr_get_default_param(mgr, ci[0], &codec_param);
if (status != PJ_SUCCESS) {
rc = -50;
goto on_return;
}
codec_param.info.avg_bps = bitrate;
codec_param.setting.vad = 0;
status = codec->op->init(codec, pool);
if (status != PJ_SUCCESS) {
rc = -60;
goto on_return;
}
status = codec->op->open(codec, &codec_param);
if (status != PJ_SUCCESS) {
rc = -70;
goto on_return;
}
/* Open input file */
input = fopen(in_encoded_file, "rb");
if (!input) {
rc = -80;
goto on_return;
}
/* Is the file in ITU format? */
is_itu_format = pj_ansi_stricmp(in_encoded_file+strlen(in_encoded_file)-4,
".itu")==0;
/* Open output file */
output = fopen(TMP_OUT, "wb");
if (!output) {
rc = -90;
goto on_return;
}
/* Allocate buffer for PCM and encoded frames */
samples_per_frame = codec_param.info.clock_rate * codec_param.info.frm_ptime / 1000;
pkt = pj_pool_alloc(pool, samples_per_frame * 2);
out_frame.buf = (pj_uint8_t*) pj_pool_alloc(pool, samples_per_frame * 2);
/* Loop read WAV file and encode and write to output file */
for (;;) {
pjmedia_frame in_frame[2];
pj_timestamp ts;
unsigned count;
pj_bool_t has_frame;
if (is_itu_format) {
int nsamp;
short frame_err = 0;
nsamp = read_ITU_format(input, (short*)pkt, &frame_err,
encoded_len / 2, PJ_TRUE);
if (nsamp != (int)encoded_len / 2)
break;
has_frame = !frame_err;
} else {
if (fread(pkt, encoded_len, 1, input) != 1)
break;
has_frame = PJ_TRUE;
}
if (has_frame) {
count = 2;
if (codec->op->parse(codec, pkt, encoded_len, &ts,
&count, in_frame) != PJ_SUCCESS)
{
rc = -100;
goto on_return;
}
if (count != 1) {
rc = -110;
goto on_return;
}
if (codec->op->decode(codec, &in_frame[0], samples_per_frame*2,
&out_frame) != PJ_SUCCESS)
{
rc = -120;
goto on_return;
}
} else {
if (codec->op->recover(codec, samples_per_frame*2,
&out_frame) != PJ_SUCCESS)
{
rc = -125;
goto on_return;
}
}
if (manip)
manip((short*)out_frame.buf, samples_per_frame);
if (fwrite(out_frame.buf, out_frame.size, 1, output) != 1) {
rc = -130;
goto on_return;
}
}
fclose(input);
input = NULL;
fclose(output);
output = NULL;
/* Compare encoded files */
fref = fopen(ref_pcm_file, "rb");
if (!fref) {
rc = -140;
goto on_return;
}
output = fopen(TMP_OUT, "rb");
if (!output) {
rc = -110;
goto on_return;
}
pos = 0;
for (;;) {
int count;
count = fread(pkt, samples_per_frame*2, 1, fref);
if (count != 1)
break;
count = fread(out_frame.buf, samples_per_frame*2, 1, output);
if (count != 1)
break;
if (memcmp(pkt, out_frame.buf, samples_per_frame*2)) {
unsigned i;
pj_int16_t *in = (pj_int16_t*)pkt;
pj_int16_t *out = (pj_int16_t*)out_frame.buf;
for (i=0; i<samples_per_frame; ++i) {
if (in[i] != out[i])
break;
}
PJ_LOG(1,(THIS_FILE," failed: mismatch at samples %d", pos+i));
rc = -200;
break;
}
pos += samples_per_frame;
}
on_return:
if (output)
fclose(output);
if (fref)
fclose(fref);
if (input)
fclose(input);
if (codec) {
codec->op->close(codec);
pjmedia_codec_mgr_dealloc_codec(mgr, codec);
}
if (pool)
pj_pool_release(pool);
return rc;
}
/* SSL socket try to connect to raw TCP socket server, once
* connection established, SSL socket will try to perform SSL
* handshake. SSL client socket should be able to close the
* connection after specified timeout period (set ms_timeout to
* 0 to disable timer).
*/
static int server_non_ssl(unsigned ms_timeout)
{
pj_pool_t *pool = NULL;
pj_ioqueue_t *ioqueue = NULL;
pj_timer_heap_t *timer = NULL;
pj_activesock_t *asock_serv = NULL;
pj_ssl_sock_t *ssock_cli = NULL;
pj_activesock_cb asock_cb = { 0 };
pj_sock_t sock = PJ_INVALID_SOCKET;
pj_ssl_sock_param param;
struct test_state state_serv = { 0 };
struct test_state state_cli = { 0 };
pj_sockaddr addr, listen_addr;
pj_status_t status;
pool = pj_pool_create(mem, "ssl_connect_raw_tcp", 256, 256, NULL);
status = pj_ioqueue_create(pool, 4, &ioqueue);
if (status != PJ_SUCCESS) {
goto on_return;
}
status = pj_timer_heap_create(pool, 4, &timer);
if (status != PJ_SUCCESS) {
goto on_return;
}
/* SERVER */
state_serv.pool = pool;
state_serv.ioqueue = ioqueue;
status = pj_sock_socket(pj_AF_INET(), pj_SOCK_STREAM(), 0, &sock);
if (status != PJ_SUCCESS) {
goto on_return;
}
/* Init bind address */
{
pj_str_t tmp_st;
pj_sockaddr_init(PJ_AF_INET, &listen_addr, pj_strset2(&tmp_st, "127.0.0.1"), 0);
}
status = pj_sock_bind(sock, (pj_sockaddr_t*)&listen_addr,
pj_sockaddr_get_len((pj_sockaddr_t*)&listen_addr));
if (status != PJ_SUCCESS) {
goto on_return;
}
status = pj_sock_listen(sock, PJ_SOMAXCONN);
if (status != PJ_SUCCESS) {
goto on_return;
}
asock_cb.on_accept_complete = &asock_on_accept_complete;
status = pj_activesock_create(pool, sock, pj_SOCK_STREAM(), NULL,
ioqueue, &asock_cb, &state_serv, &asock_serv);
if (status != PJ_SUCCESS) {
goto on_return;
}
status = pj_activesock_start_accept(asock_serv, pool);
if (status != PJ_SUCCESS)
goto on_return;
/* Update listener address */
{
int addr_len;
addr_len = sizeof(listen_addr);
pj_sock_getsockname(sock, (pj_sockaddr_t*)&listen_addr, &addr_len);
}
/* CLIENT */
pj_ssl_sock_param_default(¶m);
param.cb.on_connect_complete = &ssl_on_connect_complete;
param.cb.on_data_read = &ssl_on_data_read;
param.cb.on_data_sent = &ssl_on_data_sent;
param.ioqueue = ioqueue;
param.timer_heap = timer;
param.timeout.sec = 0;
param.timeout.msec = ms_timeout;
pj_time_val_normalize(¶m.timeout);
param.user_data = &state_cli;
state_cli.pool = pool;
state_cli.is_server = PJ_FALSE;
state_cli.is_verbose = PJ_TRUE;
status = pj_ssl_sock_create(pool, ¶m, &ssock_cli);
if (status != PJ_SUCCESS) {
goto on_return;
}
/* Init default bind address */
{
pj_str_t tmp_st;
pj_sockaddr_init(PJ_AF_INET, &addr, pj_strset2(&tmp_st, "127.0.0.1"), 0);
}
status = pj_ssl_sock_start_connect(ssock_cli, pool,
(pj_sockaddr_t*)&addr,
(pj_sockaddr_t*)&listen_addr,
pj_sockaddr_get_len(&listen_addr));
if (status != PJ_EPENDING) {
goto on_return;
}
/* Wait until everything has been sent/received or error */
while ((!state_serv.err && !state_serv.done) || (!state_cli.err && !state_cli.done))
{
#ifdef PJ_SYMBIAN
pj_symbianos_poll(-1, 1000);
#else
pj_time_val delay = {0, 100};
pj_ioqueue_poll(ioqueue, &delay);
pj_timer_heap_poll(timer, &delay);
#endif
}
if (state_serv.err || state_cli.err) {
if (state_cli.err != PJ_SUCCESS)
status = state_cli.err;
else
status = state_serv.err;
goto on_return;
}
PJ_LOG(3, ("", "...Done!"));
on_return:
if (asock_serv)
pj_activesock_close(asock_serv);
if (ssock_cli && !state_cli.err && !state_cli.done)
pj_ssl_sock_close(ssock_cli);
if (timer)
pj_timer_heap_destroy(timer);
if (ioqueue)
pj_ioqueue_destroy(ioqueue);
if (pool)
pj_pool_release(pool);
return status;
}
int main(int argc, char *argv[])
{
pj_str_t input, output, srtp_crypto, srtp_key, codec;
pjmedia_aud_dev_index dev_id = PJMEDIA_AUD_DEFAULT_PLAYBACK_DEV;
pj_pcap_filter filter;
pj_status_t status;
enum {
OPT_SRC_IP = 1, OPT_DST_IP, OPT_SRC_PORT, OPT_DST_PORT,
OPT_CODEC, OPT_PLAY_DEV_ID
};
struct pj_getopt_option long_options[] = {
{ "srtp-crypto", 1, 0, 'c' },
{ "srtp-key", 1, 0, 'k' },
{ "src-ip", 1, 0, OPT_SRC_IP },
{ "dst-ip", 1, 0, OPT_DST_IP },
{ "src-port", 1, 0, OPT_SRC_PORT },
{ "dst-port", 1, 0, OPT_DST_PORT },
{ "codec", 1, 0, OPT_CODEC },
{ "play-dev-id", 1, 0, OPT_PLAY_DEV_ID },
{ NULL, 0, 0, 0}
};
int c;
int option_index;
char key_bin[32];
srtp_crypto.slen = srtp_key.slen = 0;
codec.slen = 0;
pj_pcap_filter_default(&filter);
filter.link = PJ_PCAP_LINK_TYPE_ETH;
filter.proto = PJ_PCAP_PROTO_TYPE_UDP;
/* Parse arguments */
pj_optind = 0;
while((c=pj_getopt_long(argc,argv, "c:k:", long_options, &option_index))!=-1) {
switch (c) {
case 'c':
srtp_crypto = pj_str(pj_optarg);
break;
case 'k':
{
int key_len = sizeof(key_bin);
srtp_key = pj_str(pj_optarg);
if (pj_base64_decode(&srtp_key, (pj_uint8_t*)key_bin, &key_len)) {
puts("Error: invalid key");
return 1;
}
srtp_key.ptr = key_bin;
srtp_key.slen = key_len;
}
break;
case OPT_SRC_IP:
{
pj_str_t t = pj_str(pj_optarg);
pj_in_addr a = pj_inet_addr(&t);
filter.ip_src = a.s_addr;
}
break;
case OPT_DST_IP:
{
pj_str_t t = pj_str(pj_optarg);
pj_in_addr a = pj_inet_addr(&t);
filter.ip_dst = a.s_addr;
}
break;
case OPT_SRC_PORT:
filter.src_port = pj_htons((pj_uint16_t)atoi(pj_optarg));
break;
case OPT_DST_PORT:
filter.dst_port = pj_htons((pj_uint16_t)atoi(pj_optarg));
break;
case OPT_CODEC:
codec = pj_str(pj_optarg);
break;
case OPT_PLAY_DEV_ID:
dev_id = atoi(pj_optarg);
break;
default:
puts("Error: invalid option");
return 1;
}
}
if (pj_optind != argc - 2) {
puts(USAGE);
return 1;
}
if (!(srtp_crypto.slen) != !(srtp_key.slen)) {
puts("Error: both SRTP crypto and key must be specified");
puts(USAGE);
return 1;
}
input = pj_str(argv[pj_optind]);
output = pj_str(argv[pj_optind+1]);
T( pj_init() );
pj_caching_pool_init(&app.cp, NULL, 0);
app.pool = pj_pool_create(&app.cp.factory, "pcaputil", 1000, 1000, NULL);
T( pjlib_util_init() );
T( pjmedia_endpt_create(&app.cp.factory, NULL, 0, &app.mept) );
T( pj_pcap_open(app.pool, input.ptr, &app.pcap) );
T( pj_pcap_set_filter(app.pcap, &filter) );
pcap2wav(&codec, &output, dev_id, &srtp_crypto, &srtp_key);
cleanup();
return 0;
}
/*
* main()
*
*/
int main(int argc, char *argv[])
{
pj_caching_pool cp;
pj_pool_t *pool = NULL;
pjsip_module mod_app =
{
NULL, NULL, /* prev, next. */
{ "mod-app", 7 }, /* Name. */
-1, /* Id */
PJSIP_MOD_PRIORITY_APPLICATION, /* Priority */
NULL, /* load() */
NULL, /* start() */
NULL, /* stop() */
NULL, /* unload() */
&on_rx_request, /* on_rx_request() */
NULL, /* on_rx_response() */
NULL, /* on_tx_request. */
NULL, /* on_tx_response() */
NULL, /* on_tsx_state() */
};
int c;
pj_status_t status;
/* Must init PJLIB first: */
status = pj_init();
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* 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: */
{
/* Endpoint MUST be assigned a globally unique name.
* Ideally we should put hostname or public IP address, but
* we'll just use an arbitrary name here.
*/
/* Create the endpoint: */
status = pjsip_endpt_create(&cp.factory, "sipstateless",
&sip_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
}
/* Parse arguments */
pj_optind = 0;
pj_list_init(&hdr_list);
while ((c=pj_getopt(argc, argv , "H:")) != -1) {
switch (c) {
case 'H':
if (pool == NULL) {
pool = pj_pool_create(&cp.factory, "sipstateless", 1000,
1000, NULL);
}
if (pool) {
char *name;
name = strtok(pj_optarg, ":");
if (name == NULL) {
puts("Error: invalid header format");
return 1;
} else {
char *val = strtok(NULL, "\r\n");
pjsip_generic_string_hdr *h;
pj_str_t hname, hvalue;
hname = pj_str(name);
hvalue = pj_str(val);
h = pjsip_generic_string_hdr_create(pool, &hname, &hvalue);
pj_list_push_back(&hdr_list, h);
PJ_LOG(4,(THIS_FILE, "Header %s: %s added", name, val));
}
}
break;
default:
puts("Error: invalid argument");
usage();
return 1;
}
}
if (pj_optind != argc) {
code = atoi(argv[pj_optind]);
if (code < 200 || code > 699) {
puts("Error: invalid status code");
usage();
return 1;
}
}
PJ_LOG(4,(THIS_FILE, "Returning %d to incoming requests", code));
/*
* Add UDP transport, with hard-coded port
*/
#ifdef HAS_UDP_TRANSPORT
{
pj_sockaddr_in addr;
addr.sin_family = pj_AF_INET();
addr.sin_addr.s_addr = 0;
addr.sin_port = pj_htons(5060);
status = pjsip_udp_transport_start( sip_endpt, &addr, NULL, 1, NULL);
if (status != PJ_SUCCESS) {
PJ_LOG(3,(THIS_FILE,
"Error starting UDP transport (port in use?)"));
return 1;
}
}
#endif
#if HAS_TCP_TRANSPORT
/*
* Add UDP transport, with hard-coded port
*/
{
pj_sockaddr_in addr;
addr.sin_family = pj_AF_INET();
addr.sin_addr.s_addr = 0;
addr.sin_port = pj_htons(5060);
status = pjsip_tcp_transport_start(sip_endpt, &addr, 1, NULL);
if (status != PJ_SUCCESS) {
PJ_LOG(3,(THIS_FILE,
"Error starting TCP transport (port in use?)"));
return 1;
}
}
#endif
/*
* Register our module to receive incoming requests.
*/
status = pjsip_endpt_register_module( sip_endpt, &mod_app);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Done. Loop forever to handle incoming events. */
PJ_LOG(3,(THIS_FILE, "Press Ctrl-C to quit.."));
for (;;) {
pjsip_endpt_handle_events(sip_endpt, NULL);
}
}
int fifobuf_test()
{
enum { SIZE = 1024, MAX_ENTRIES = 128,
MIN_SIZE = 4, MAX_SIZE = 64,
LOOP=10000 };
pj_pool_t *pool;
pj_fifobuf_t fifo;
unsigned available = SIZE;
void *entries[MAX_ENTRIES];
void *buffer;
int i;
pool = pj_pool_create(mem, NULL, SIZE+256, 0, NULL);
if (!pool)
return -10;
buffer = pj_pool_alloc(pool, SIZE);
if (!buffer)
return -20;
pj_fifobuf_init (&fifo, buffer, SIZE);
// Test 1
for (i=0; i<LOOP*MAX_ENTRIES; ++i) {
int size;
int c, f;
c = i%2;
f = (i+1)%2;
do {
size = MIN_SIZE+(pj_rand() % MAX_SIZE);
entries[c] = pj_fifobuf_alloc (&fifo, size);
} while (entries[c] == 0);
if ( i!=0) {
pj_fifobuf_free(&fifo, entries[f]);
}
}
if (entries[(i+1)%2])
pj_fifobuf_free(&fifo, entries[(i+1)%2]);
if (pj_fifobuf_max_size(&fifo) < SIZE-4) {
pj_assert(0);
return -1;
}
// Test 2
entries[0] = pj_fifobuf_alloc (&fifo, MIN_SIZE);
if (!entries[0]) return -1;
for (i=0; i<LOOP*MAX_ENTRIES; ++i) {
int size = MIN_SIZE+(pj_rand() % MAX_SIZE);
entries[1] = pj_fifobuf_alloc (&fifo, size);
if (entries[1])
pj_fifobuf_unalloc(&fifo, entries[1]);
}
pj_fifobuf_unalloc(&fifo, entries[0]);
if (pj_fifobuf_max_size(&fifo) < SIZE-4) {
pj_assert(0);
return -2;
}
// Test 3
for (i=0; i<LOOP; ++i) {
int count, j;
for (count=0; available>=MIN_SIZE+4 && count < MAX_ENTRIES;) {
int size = MIN_SIZE+(pj_rand() % MAX_SIZE);
entries[count] = pj_fifobuf_alloc (&fifo, size);
if (entries[count]) {
available -= (size+4);
++count;
}
}
for (j=0; j<count; ++j) {
pj_fifobuf_free (&fifo, entries[j]);
}
available = SIZE;
}
if (pj_fifobuf_max_size(&fifo) < SIZE-4) {
pj_assert(0);
return -3;
}
pj_pool_release(pool);
return 0;
}
/*
* Create server.
*/
PJ_DEF(pj_status_t) pj_turn_srv_create(pj_pool_factory *pf,
pj_turn_srv **p_srv)
{
pj_pool_t *pool;
pj_stun_session_cb sess_cb;
pj_turn_srv *srv;
unsigned i;
pj_status_t status;
PJ_ASSERT_RETURN(pf && p_srv, PJ_EINVAL);
/* Create server and init core settings */
pool = pj_pool_create(pf, "srv%p", 1000, 1000, NULL);
srv = PJ_POOL_ZALLOC_T(pool, pj_turn_srv);
srv->obj_name = pool->obj_name;
srv->core.pf = pf;
srv->core.pool = pool;
srv->core.tls_key = srv->core.tls_data = -1;
/* Create ioqueue */
status = pj_ioqueue_create(pool, MAX_HANDLES, &srv->core.ioqueue);
if (status != PJ_SUCCESS)
goto on_error;
/* Server mutex */
status = pj_lock_create_recursive_mutex(pool, srv->obj_name,
&srv->core.lock);
if (status != PJ_SUCCESS)
goto on_error;
/* Allocate TLS */
status = pj_thread_local_alloc(&srv->core.tls_key);
if (status != PJ_SUCCESS)
goto on_error;
status = pj_thread_local_alloc(&srv->core.tls_data);
if (status != PJ_SUCCESS)
goto on_error;
/* Create timer heap */
status = pj_timer_heap_create(pool, MAX_TIMER, &srv->core.timer_heap);
if (status != PJ_SUCCESS)
goto on_error;
/* Configure lock for the timer heap */
pj_timer_heap_set_lock(srv->core.timer_heap, srv->core.lock, PJ_FALSE);
/* Array of listeners */
srv->core.listener = (pj_turn_listener**)
pj_pool_calloc(pool, MAX_LISTENERS,
sizeof(srv->core.listener[0]));
/* Create hash tables */
srv->tables.alloc = pj_hash_create(pool, MAX_CLIENTS);
srv->tables.res = pj_hash_create(pool, MAX_CLIENTS);
/* Init ports settings */
srv->ports.min_udp = srv->ports.next_udp = MIN_PORT;
srv->ports.max_udp = MAX_PORT;
srv->ports.min_tcp = srv->ports.next_tcp = MIN_PORT;
srv->ports.max_tcp = MAX_PORT;
/* Init STUN config */
pj_stun_config_init(&srv->core.stun_cfg, pf, 0, srv->core.ioqueue,
srv->core.timer_heap);
/* Init STUN credential */
srv->core.cred.type = PJ_STUN_AUTH_CRED_DYNAMIC;
srv->core.cred.data.dyn_cred.user_data = srv;
srv->core.cred.data.dyn_cred.get_auth = &pj_turn_get_auth;
srv->core.cred.data.dyn_cred.get_password = &pj_turn_get_password;
srv->core.cred.data.dyn_cred.verify_nonce = &pj_turn_verify_nonce;
/* Create STUN session to handle new allocation */
pj_bzero(&sess_cb, sizeof(sess_cb));
sess_cb.on_rx_request = &on_rx_stun_request;
sess_cb.on_send_msg = &on_tx_stun_msg;
status = pj_stun_session_create(&srv->core.stun_cfg, srv->obj_name,
&sess_cb, PJ_FALSE, NULL,
&srv->core.stun_sess);
if (status != PJ_SUCCESS) {
goto on_error;
}
pj_stun_session_set_user_data(srv->core.stun_sess, srv);
pj_stun_session_set_credential(srv->core.stun_sess, PJ_STUN_AUTH_LONG_TERM,
&srv->core.cred);
/* Array of worker threads */
srv->core.thread_cnt = MAX_THREADS;
srv->core.thread = (pj_thread_t**)
pj_pool_calloc(pool, srv->core.thread_cnt,
sizeof(pj_thread_t*));
/* Start the worker threads */
for (i=0; i<srv->core.thread_cnt; ++i) {
status = pj_thread_create(pool, srv->obj_name, &server_thread_proc,
srv, 0, 0, &srv->core.thread[i]);
if (status != PJ_SUCCESS)
goto on_error;
}
/* We're done. Application should add listeners now */
PJ_LOG(4,(srv->obj_name, "TURN server v%s is running",
pj_get_version()));
*p_srv = srv;
return PJ_SUCCESS;
on_error:
pj_turn_srv_destroy(srv);
return status;
}
/*
* sock_producer_consumer()
*
* Simple producer-consumer benchmarking. Send loop number of
* buf_size size packets as fast as possible.
*/
static int sock_producer_consumer(int sock_type,
unsigned buf_size,
unsigned loop,
unsigned *p_bandwidth)
{
pj_sock_t consumer, producer;
pj_pool_t *pool;
char *outgoing_buffer, *incoming_buffer;
pj_timestamp start, stop;
unsigned i;
pj_highprec_t elapsed, bandwidth;
pj_size_t total_received;
pj_status_t rc;
/* Create pool. */
pool = pj_pool_create(mem, NULL, 4096, 4096, NULL);
if (!pool)
return -10;
/* Create producer-consumer pair. */
rc = app_socketpair(pj_AF_INET(), sock_type, 0, &consumer, &producer);
if (rc != PJ_SUCCESS) {
app_perror("...error: create socket pair", rc);
return -20;
}
/* Create buffers. */
outgoing_buffer = (char*) pj_pool_alloc(pool, buf_size);
incoming_buffer = (char*) pj_pool_alloc(pool, buf_size);
/* Start loop. */
pj_get_timestamp(&start);
total_received = 0;
for (i=0; i<loop; ++i) {
pj_ssize_t sent, part_received, received;
pj_time_val delay;
sent = buf_size;
rc = pj_sock_send(producer, outgoing_buffer, &sent, 0);
if (rc != PJ_SUCCESS || sent != (pj_ssize_t)buf_size) {
app_perror("...error: send()", rc);
return -61;
}
/* Repeat recv() until all data is part_received.
* This applies only for non-UDP of course, since for UDP
* we would expect all data to be part_received in one packet.
*/
received = 0;
do {
part_received = buf_size-received;
rc = pj_sock_recv(consumer, incoming_buffer+received,
&part_received, 0);
if (rc != PJ_SUCCESS) {
app_perror("...recv error", rc);
return -70;
}
if (part_received <= 0) {
PJ_LOG(3,("", "...error: socket has closed (part_received=%d)!",
part_received));
return -73;
}
if ((pj_size_t)part_received != buf_size-received) {
if (sock_type != pj_SOCK_STREAM()) {
PJ_LOG(3,("", "...error: expecting %u bytes, got %u bytes",
buf_size-received, part_received));
return -76;
}
}
received += part_received;
} while ((pj_size_t)received < buf_size);
total_received += received;
/* Stop test if it's been runnign for more than 10 secs. */
pj_get_timestamp(&stop);
delay = pj_elapsed_time(&start, &stop);
if (delay.sec > 10)
break;
}
/* Stop timer. */
pj_get_timestamp(&stop);
elapsed = pj_elapsed_usec(&start, &stop);
/* bandwidth = total_received * 1000 / elapsed */
bandwidth = total_received;
pj_highprec_mul(bandwidth, 1000);
pj_highprec_div(bandwidth, elapsed);
*p_bandwidth = (pj_uint32_t)bandwidth;
/* Close sockets. */
pj_sock_close(consumer);
pj_sock_close(producer);
/* Done */
pj_pool_release(pool);
return 0;
}
int jbuf_main(void)
{
FILE *input;
pj_bool_t data_eof = PJ_FALSE;
int old_log_level;
int rc = 0;
const char* input_filename = "Jbtest.dat";
const char* input_search_path[] = {
"../build",
"pjmedia/build",
"build"
};
/* Try to open test data file in the working directory */
input = fopen(input_filename, "rt");
/* If that fails, try to open test data file in specified search paths */
if (input == NULL) {
char input_path[PJ_MAXPATH];
int i;
for (i = 0; !input && i < PJ_ARRAY_SIZE(input_search_path); ++i) {
pj_ansi_snprintf(input_path, PJ_MAXPATH, "%s/%s",
input_search_path[i],
input_filename);
input = fopen(input_path, "rt");
}
}
/* Failed to open test data file. */
if (input == NULL) {
printf("Failed to open test data file, Jbtest.dat\n");
return -1;
}
old_log_level = pj_log_get_level();
pj_log_set_level(5);
while (rc == 0 && !data_eof) {
pj_str_t jb_name = {"JBTEST", 6};
pjmedia_jbuf *jb;
pj_pool_t *pool;
pjmedia_jb_state state;
pj_uint16_t last_seq = 0;
pj_uint16_t seq = 1;
char line[1024], *p = NULL;
test_param_t param;
test_cond_t cond;
param.adaptive = PJ_TRUE;
param.init_prefetch = JB_INIT_PREFETCH;
param.min_prefetch = JB_MIN_PREFETCH;
param.max_prefetch = JB_MAX_PREFETCH;
cond.burst = -1;
cond.delay = -1;
cond.delay_min = -1;
cond.discard = -1;
cond.empty = -1;
cond.lost = -1;
printf("\n\n");
/* Parse test session title, param, and conditions */
do {
p = fgets(line, sizeof(line), input);
} while (p && parse_test_headers(line, ¶m, &cond));
/* EOF test data */
if (p == NULL)
break;
//printf("======================================================\n");
/* Initialize test session */
pool = pj_pool_create(mem, "JBPOOL", 256*16, 256*16, NULL);
pjmedia_jbuf_create(pool, &jb_name, 1, JB_PTIME, JB_BUF_SIZE, &jb);
pjmedia_jbuf_reset(jb);
if (param.adaptive) {
pjmedia_jbuf_set_adaptive(jb,
param.init_prefetch,
param.min_prefetch,
param.max_prefetch);
} else {
pjmedia_jbuf_set_fixed(jb, param.init_prefetch);
}
#ifdef REPORT
pjmedia_jbuf_get_state(jb, &state);
printf("Initial\tsize=%d\tprefetch=%d\tmin.pftch=%d\tmax.pftch=%d\n",
state.size, state.prefetch, state.min_prefetch,
state.max_prefetch);
#endif
/* Test session start */
while (1) {
char c;
/* Get next line of test data */
if (!p || *p == 0) {
p = fgets(line, sizeof(line), input);
if (p == NULL) {
data_eof = PJ_TRUE;
break;
}
}
/* Get next char of test data */
c = *p++;
/* Skip spaces */
if (isspace(c))
continue;
/* Print comment line */
if (c == '#') {
#ifdef PRINT_COMMENT
while (*p && isspace(*p)) ++p;
if (*p) printf("..%s", p);
#endif
*p = 0;
continue;
}
/* Process test data */
if (!process_test_data(c, jb, &seq, &last_seq))
break;
}
/* Print JB states */
pjmedia_jbuf_get_state(jb, &state);
printf("------------------------------------------------------\n");
printf("Summary:\n");
printf(" size=%d prefetch=%d\n", state.size, state.prefetch);
printf(" delay (min/max/avg/dev)=%d/%d/%d/%d ms\n",
state.min_delay, state.max_delay, state.avg_delay,
state.dev_delay);
printf(" lost=%d discard=%d empty=%d burst(avg)=%d\n",
state.lost, state.discard, state.empty, state.avg_burst);
/* Evaluate test session */
if (cond.burst >= 0 && (int)state.avg_burst > cond.burst) {
printf("! 'Burst' should be %d, it is %d\n",
cond.burst, state.avg_burst);
rc |= 1;
}
if (cond.delay >= 0 && (int)state.avg_delay/JB_PTIME > cond.delay) {
printf("! 'Delay' should be %d, it is %d\n",
cond.delay, state.avg_delay/JB_PTIME);
rc |= 2;
}
if (cond.delay_min >= 0 && (int)state.min_delay/JB_PTIME > cond.delay_min) {
printf("! 'Minimum delay' should be %d, it is %d\n",
cond.delay_min, state.min_delay/JB_PTIME);
rc |= 32;
}
if (cond.discard >= 0 && (int)state.discard > cond.discard) {
printf("! 'Discard' should be %d, it is %d\n",
cond.discard, state.discard);
rc |= 4;
}
if (cond.empty >= 0 && (int)state.empty > cond.empty) {
printf("! 'Empty' should be %d, it is %d\n",
cond.empty, state.empty);
rc |= 8;
}
if (cond.lost >= 0 && (int)state.lost > cond.lost) {
printf("! 'Lost' should be %d, it is %d\n",
cond.lost, state.lost);
rc |= 16;
}
pjmedia_jbuf_destroy(jb);
pj_pool_release(pool);
}
fclose(input);
pj_log_set_level(old_log_level);
return rc;
}
/* Test will perform multiple clients trying to connect to single server.
* Once SSL connection established, echo test will be performed.
*/
static int perf_test(unsigned clients, unsigned ms_handshake_timeout)
{
pj_pool_t *pool = NULL;
pj_ioqueue_t *ioqueue = NULL;
pj_timer_heap_t *timer = NULL;
pj_ssl_sock_t *ssock_serv = NULL;
pj_ssl_sock_t **ssock_cli = NULL;
pj_ssl_sock_param param;
struct test_state state_serv = { 0 };
struct test_state *state_cli = NULL;
pj_sockaddr addr, listen_addr;
pj_ssl_cert_t *cert = NULL;
pj_status_t status;
unsigned i, cli_err = 0;
pj_size_t tot_sent = 0, tot_recv = 0;
pj_time_val start;
pool = pj_pool_create(mem, "ssl_perf", 256, 256, NULL);
status = pj_ioqueue_create(pool, PJ_IOQUEUE_MAX_HANDLES, &ioqueue);
if (status != PJ_SUCCESS) {
goto on_return;
}
status = pj_timer_heap_create(pool, PJ_IOQUEUE_MAX_HANDLES, &timer);
if (status != PJ_SUCCESS) {
goto on_return;
}
/* Set cert */
{
pj_str_t tmp1, tmp2, tmp3, tmp4;
status = pj_ssl_cert_load_from_files(pool,
pj_strset2(&tmp1, (char*)CERT_CA_FILE),
pj_strset2(&tmp2, (char*)CERT_FILE),
pj_strset2(&tmp3, (char*)CERT_PRIVKEY_FILE),
pj_strset2(&tmp4, (char*)CERT_PRIVKEY_PASS),
&cert);
if (status != PJ_SUCCESS) {
goto on_return;
}
}
pj_ssl_sock_param_default(¶m);
param.cb.on_accept_complete = &ssl_on_accept_complete;
param.cb.on_connect_complete = &ssl_on_connect_complete;
param.cb.on_data_read = &ssl_on_data_read;
param.cb.on_data_sent = &ssl_on_data_sent;
param.ioqueue = ioqueue;
param.timer_heap = timer;
param.timeout.sec = 0;
param.timeout.msec = ms_handshake_timeout;
pj_time_val_normalize(¶m.timeout);
/* Init default bind address */
{
pj_str_t tmp_st;
pj_sockaddr_init(PJ_AF_INET, &addr, pj_strset2(&tmp_st, "127.0.0.1"), 0);
}
/* SERVER */
param.user_data = &state_serv;
state_serv.pool = pool;
state_serv.echo = PJ_TRUE;
state_serv.is_server = PJ_TRUE;
status = pj_ssl_sock_create(pool, ¶m, &ssock_serv);
if (status != PJ_SUCCESS) {
goto on_return;
}
status = pj_ssl_sock_set_certificate(ssock_serv, pool, cert);
if (status != PJ_SUCCESS) {
goto on_return;
}
status = pj_ssl_sock_start_accept(ssock_serv, pool, &addr, pj_sockaddr_get_len(&addr));
if (status != PJ_SUCCESS) {
goto on_return;
}
/* Get listening address for clients to connect to */
{
pj_ssl_sock_info info;
char buf[64];
pj_ssl_sock_get_info(ssock_serv, &info);
pj_sockaddr_cp(&listen_addr, &info.local_addr);
pj_sockaddr_print((pj_sockaddr_t*)&listen_addr, buf, sizeof(buf), 1);
PJ_LOG(3, ("", "...Listener ready at %s", buf));
}
/* CLIENTS */
clients_num = clients;
param.timeout.sec = 0;
param.timeout.msec = 0;
/* Init random seed */
{
pj_time_val now;
pj_gettimeofday(&now);
pj_srand((unsigned)now.sec);
}
/* Allocate SSL socket pointers and test state */
ssock_cli = (pj_ssl_sock_t**)pj_pool_calloc(pool, clients, sizeof(pj_ssl_sock_t*));
state_cli = (struct test_state*)pj_pool_calloc(pool, clients, sizeof(struct test_state));
/* Get start timestamp */
pj_gettimeofday(&start);
/* Setup clients */
for (i = 0; i < clients; ++i) {
param.user_data = &state_cli[i];
state_cli[i].pool = pool;
state_cli[i].check_echo = PJ_TRUE;
state_cli[i].send_str_len = (pj_rand() % 5 + 1) * 1024 + pj_rand() % 1024;
state_cli[i].send_str = (char*)pj_pool_alloc(pool, state_cli[i].send_str_len);
{
unsigned j;
for (j = 0; j < state_cli[i].send_str_len; ++j)
state_cli[i].send_str[j] = (char)(pj_rand() % 256);
}
status = pj_ssl_sock_create(pool, ¶m, &ssock_cli[i]);
if (status != PJ_SUCCESS) {
app_perror("...ERROR pj_ssl_sock_create()", status);
cli_err++;
clients_num--;
continue;
}
status = pj_ssl_sock_start_connect(ssock_cli[i], pool, &addr, &listen_addr, pj_sockaddr_get_len(&addr));
if (status == PJ_SUCCESS) {
ssl_on_connect_complete(ssock_cli[i], PJ_SUCCESS);
} else if (status == PJ_EPENDING) {
status = PJ_SUCCESS;
} else {
app_perror("...ERROR pj_ssl_sock_create()", status);
pj_ssl_sock_close(ssock_cli[i]);
ssock_cli[i] = NULL;
clients_num--;
cli_err++;
continue;
}
/* Give chance to server to accept this client */
{
unsigned n = 5;
#ifdef PJ_SYMBIAN
while(n && pj_symbianos_poll(-1, 1000))
n--;
#else
pj_time_val delay = {0, 100};
while(n && pj_ioqueue_poll(ioqueue, &delay) > 0)
n--;
#endif
}
}
/* Wait until everything has been sent/received or error */
while (clients_num)
{
#ifdef PJ_SYMBIAN
pj_symbianos_poll(-1, 1000);
#else
pj_time_val delay = {0, 100};
pj_ioqueue_poll(ioqueue, &delay);
pj_timer_heap_poll(timer, &delay);
#endif
}
/* Clean up sockets */
{
pj_time_val delay = {0, 500};
while (pj_ioqueue_poll(ioqueue, &delay) > 0);
}
if (state_serv.err != PJ_SUCCESS) {
status = state_serv.err;
goto on_return;
}
PJ_LOG(3, ("", "...Done!"));
/* SSL setup and data transfer duration */
{
pj_time_val stop;
pj_gettimeofday(&stop);
PJ_TIME_VAL_SUB(stop, start);
PJ_LOG(3, ("", ".....Setup & data transfer duration: %d.%03ds", stop.sec, stop.msec));
}
/* Check clients status */
for (i = 0; i < clients; ++i) {
if (state_cli[i].err != PJ_SUCCESS)
cli_err++;
tot_sent += state_cli[1].sent;
tot_recv += state_cli[1].recv;
}
PJ_LOG(3, ("", ".....Clients: %d (%d errors)", clients, cli_err));
PJ_LOG(3, ("", ".....Total sent/recv: %d/%d bytes", tot_sent, tot_recv));
on_return:
if (ssock_serv)
pj_ssl_sock_close(ssock_serv);
for (i = 0; i < clients; ++i) {
if (ssock_cli[i] && !state_cli[i].err && !state_cli[i].done)
pj_ssl_sock_close(ssock_cli[i]);
}
if (ioqueue)
pj_ioqueue_destroy(ioqueue);
if (pool)
pj_pool_release(pool);
return status;
}
static int create_ses_by_remote_sdp(int local_port, char *sdp)
{
pj_media_session_t *ses = NULL;
pjsdp_session_desc *sdp_ses;
pj_media_sock_info skinfo;
pj_pool_t *pool;
char s[4];
const pj_media_stream_info *info[2];
int i, count;
pool = pj_pool_create(pf, "sdp", 1024, 0, NULL);
if (!pool) {
PJ_LOG(1,(THIS_FILE, "Unable to create pool"));
return -1;
}
pj_bzero(&skinfo, sizeof(skinfo));
skinfo.rtp_sock = skinfo.rtcp_sock = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, 0);
if (skinfo.rtp_sock == PJ_INVALID_SOCKET) {
PJ_LOG(1,(THIS_FILE, "Unable to create socket"));
goto on_error;
}
pj_sockaddr_init2(&skinfo.rtp_addr_name, "0.0.0.0", local_port);
if (pj_sock_bind(skinfo.rtp_sock, (struct pj_sockaddr*)&skinfo.rtp_addr_name, sizeof(pj_sockaddr_in)) != 0) {
PJ_LOG(1,(THIS_FILE, "Unable to bind socket"));
goto on_error;
}
sdp_ses = pjsdp_parse(sdp, strlen(sdp), pool);
if (!sdp_ses) {
PJ_LOG(1,(THIS_FILE, "Error parsing SDP"));
goto on_error;
}
ses = pj_media_session_create_from_sdp(mm, sdp_ses, &skinfo);
if (!ses) {
PJ_LOG(1,(THIS_FILE, "Unable to create session from SDP"));
goto on_error;
}
if (pj_media_session_activate(ses) != 0) {
PJ_LOG(1,(THIS_FILE, "Error activating session"));
goto on_error;
}
count = pj_media_session_enum_streams(ses, 2, info);
printf("\nDumping streams: \n");
for (i=0; i<count; ++i) {
const char *dir;
char *local_ip;
switch (info[i]->dir) {
case PJMEDIA_DIR_NONE:
dir = "- NONE -"; break;
case PJMEDIA_DIR_ENCODING:
dir = "SENDONLY"; break;
case PJMEDIA_DIR_DECODING:
dir = "RECVONLY"; break;
case PJMEDIA_DIR_ENCODING_DECODING:
dir = "SENDRECV"; break;
default:
dir = "?UNKNOWN"; break;
}
local_ip = pj_sockaddr_get_str_addr(&info[i]->sock_info.rtp_addr_name);
printf(" Stream %d: %.*s %s local=%s:%d remote=%.*s:%d\n",
i, info[i]->type.slen, info[i]->type.ptr,
dir,
local_ip, pj_sockaddr_get_port(&info[i]->sock_info.rtp_addr_name),
info[i]->rem_addr.slen, info[i]->rem_addr.ptr, info[i]->rem_port);
}
puts("Press <ENTER> to quit");
fgets(s, sizeof(s), stdin);
pj_media_session_destroy(ses);
pj_sock_close(skinfo.rtp_sock);
pj_pool_release(pool);
return 0;
on_error:
if (ses)
pj_media_session_destroy(ses);
if (skinfo.rtp_sock != PJ_INVALID_SOCKET)
pj_sock_close(skinfo.rtp_sock);
if (pool)
pj_pool_release(pool);
return -1;
}
static int https_client_test(unsigned ms_timeout)
{
pj_pool_t *pool = NULL;
pj_ioqueue_t *ioqueue = NULL;
pj_timer_heap_t *timer = NULL;
pj_ssl_sock_t *ssock = NULL;
pj_ssl_sock_param param;
pj_status_t status;
struct test_state state = {0};
pj_sockaddr local_addr, rem_addr;
pj_str_t tmp_st;
pool = pj_pool_create(mem, "https_get", 256, 256, NULL);
status = pj_ioqueue_create(pool, 4, &ioqueue);
if (status != PJ_SUCCESS) {
goto on_return;
}
status = pj_timer_heap_create(pool, 4, &timer);
if (status != PJ_SUCCESS) {
goto on_return;
}
state.pool = pool;
state.send_str = HTTP_REQ;
state.send_str_len = pj_ansi_strlen(state.send_str);
state.is_verbose = PJ_TRUE;
pj_ssl_sock_param_default(¶m);
param.cb.on_connect_complete = &ssl_on_connect_complete;
param.cb.on_data_read = &ssl_on_data_read;
param.cb.on_data_sent = &ssl_on_data_sent;
param.ioqueue = ioqueue;
param.user_data = &state;
param.server_name = pj_str((char*)HTTP_SERVER_ADDR);
param.timer_heap = timer;
param.timeout.sec = 0;
param.timeout.msec = ms_timeout;
param.proto = PJ_SSL_SOCK_PROTO_SSL23;
pj_time_val_normalize(¶m.timeout);
status = pj_ssl_sock_create(pool, ¶m, &ssock);
if (status != PJ_SUCCESS) {
goto on_return;
}
pj_sockaddr_init(PJ_AF_INET, &local_addr, pj_strset2(&tmp_st, "0.0.0.0"), 0);
pj_sockaddr_init(PJ_AF_INET, &rem_addr, pj_strset2(&tmp_st, HTTP_SERVER_ADDR), HTTP_SERVER_PORT);
status = pj_ssl_sock_start_connect(ssock, pool, &local_addr, &rem_addr, sizeof(rem_addr));
if (status == PJ_SUCCESS) {
ssl_on_connect_complete(ssock, PJ_SUCCESS);
} else if (status == PJ_EPENDING) {
status = PJ_SUCCESS;
} else {
goto on_return;
}
/* Wait until everything has been sent/received */
while (state.err == PJ_SUCCESS && !state.done) {
#ifdef PJ_SYMBIAN
pj_symbianos_poll(-1, 1000);
#else
pj_time_val delay = {0, 100};
pj_ioqueue_poll(ioqueue, &delay);
pj_timer_heap_poll(timer, &delay);
#endif
}
if (state.err) {
status = state.err;
goto on_return;
}
PJ_LOG(3, ("", "...Done!"));
PJ_LOG(3, ("", ".....Sent/recv: %d/%d bytes", state.sent, state.recv));
on_return:
if (ssock && !state.err && !state.done)
pj_ssl_sock_close(ssock);
if (ioqueue)
pj_ioqueue_destroy(ioqueue);
if (timer)
pj_timer_heap_destroy(timer);
if (pool)
pj_pool_release(pool);
return status;
}
pj_status_t UE::init_int(pj_log_func* logger,
std::string realm,
std::string myurl,
std::string username,
std::string password,
std::string outbound_proxy)
{
pj_status_t status;
char errmsg[PJ_ERR_MSG_SIZE];
pj_sockaddr addr;
pj_str_t remote;
pj_sockaddr remote_addr;
init_pjsip(logger);
std::string server_uri = std::string("sip:") + realm + std::string(";lr;transport=tcp");
_pool = pj_pool_create(get_global_pool_factory(), "a", 256, 256, NULL);
pj_sockaddr_init(pj_AF_INET(), &addr, NULL, (pj_uint16_t)0);
//status = pjsip_udp_transport_start(get_global_endpoint(), &addr.ipv4, NULL, 1, &_transport);
//assert(status == PJ_SUCCESS);
if (outbound_proxy.empty())
{
outbound_proxy = realm;
}
pj_cstr(&remote, outbound_proxy.c_str());
pj_sockaddr_init(pj_AF_INET(), &remote_addr, &remote, (pj_uint16_t)5060);
pjsip_tpselector sel2;
sel2.type = PJSIP_TPSELECTOR_LISTENER;
sel2.u.listener = get_global_tcp_factory();
status = pjsip_endpt_acquire_transport(get_global_endpoint(),
PJSIP_TRANSPORT_TCP,
&remote_addr,
pj_sockaddr_get_len(&remote_addr),
&sel2,
&_transport);
if (status != PJ_SUCCESS)
{
pj_strerror(status, errmsg, sizeof(errmsg));
PJ_LOG(1, (__FILE__, "TCP connection to %s failed: %s (%d)", outbound_proxy.c_str(), errmsg, status));
return status;
}
transport_mapping[_transport] = this;
status = pjsip_regc_create(get_global_endpoint(), this, ®c_cb, &_regc);
if (status != PJ_SUCCESS)
{
pj_strerror(status, errmsg, sizeof(errmsg));
PJ_LOG(1, (__FILE__, "Creating the REGISTER session failed: %s (%d)", errmsg, status));
return status;
}
pjsip_regc_set_reg_tsx_cb(_regc, ®_tsx_cb);
pjsip_tpselector sel;
sel.type = PJSIP_TPSELECTOR_TRANSPORT;
sel.u.transport = _transport;
pjsip_regc_set_transport(_regc, &sel);
pjsip_auth_clt_pref prefs = {};
prefs.initial_auth = PJ_TRUE;
pjsip_regc_set_prefs(_regc, &prefs);
pjsip_cred_info cred;
stra(&cred.realm, realm.c_str());
stra(&cred.scheme, "Digest");
stra(&cred.username, username.c_str());
stra(&cred.data, password.c_str());
cred.data_type = 0; // Plaintext password
pjsip_cred_info creds[1] = {cred};
pjsip_regc_set_credentials(_regc, 1, creds);
char contact[32];
snprintf(contact, 32, "sip:phone@%.*s:%d", (int)_transport->local_name.host.slen, _transport->local_name.host.ptr, _transport->local_name.port);
stra(&_realm, realm.c_str());
stra(&_server, server_uri.c_str());
_server_uri = pjsip_parse_uri(_pool, _server.ptr, _server.slen, 0);
stra(&_my_uri, myurl.c_str());
stra(&_username, username.c_str());
stra(&_contact, contact);
return PJ_SUCCESS;
}
static int echo_test(pj_ssl_sock_proto srv_proto, pj_ssl_sock_proto cli_proto,
pj_ssl_cipher srv_cipher, pj_ssl_cipher cli_cipher,
pj_bool_t req_client_cert, pj_bool_t client_provide_cert)
{
pj_pool_t *pool = NULL;
pj_ioqueue_t *ioqueue = NULL;
pj_ssl_sock_t *ssock_serv = NULL;
pj_ssl_sock_t *ssock_cli = NULL;
pj_ssl_sock_param param;
struct test_state state_serv = { 0 };
struct test_state state_cli = { 0 };
pj_sockaddr addr, listen_addr;
pj_ssl_cipher ciphers[1];
pj_ssl_cert_t *cert = NULL;
pj_status_t status;
pool = pj_pool_create(mem, "ssl_echo", 256, 256, NULL);
status = pj_ioqueue_create(pool, 4, &ioqueue);
if (status != PJ_SUCCESS) {
goto on_return;
}
pj_ssl_sock_param_default(¶m);
param.cb.on_accept_complete = &ssl_on_accept_complete;
param.cb.on_connect_complete = &ssl_on_connect_complete;
param.cb.on_data_read = &ssl_on_data_read;
param.cb.on_data_sent = &ssl_on_data_sent;
param.ioqueue = ioqueue;
param.ciphers = ciphers;
/* Init default bind address */
{
pj_str_t tmp_st;
pj_sockaddr_init(PJ_AF_INET, &addr, pj_strset2(&tmp_st, "127.0.0.1"), 0);
}
/* === SERVER === */
param.proto = srv_proto;
param.user_data = &state_serv;
param.ciphers_num = (srv_cipher == -1)? 0 : 1;
param.require_client_cert = req_client_cert;
ciphers[0] = srv_cipher;
state_serv.pool = pool;
state_serv.echo = PJ_TRUE;
state_serv.is_server = PJ_TRUE;
state_serv.is_verbose = PJ_TRUE;
status = pj_ssl_sock_create(pool, ¶m, &ssock_serv);
if (status != PJ_SUCCESS) {
goto on_return;
}
/* Set server cert */
{
pj_str_t tmp1, tmp2, tmp3, tmp4;
status = pj_ssl_cert_load_from_files(pool,
pj_strset2(&tmp1, (char*)CERT_CA_FILE),
pj_strset2(&tmp2, (char*)CERT_FILE),
pj_strset2(&tmp3, (char*)CERT_PRIVKEY_FILE),
pj_strset2(&tmp4, (char*)CERT_PRIVKEY_PASS),
&cert);
if (status != PJ_SUCCESS) {
goto on_return;
}
status = pj_ssl_sock_set_certificate(ssock_serv, pool, cert);
if (status != PJ_SUCCESS) {
goto on_return;
}
}
status = pj_ssl_sock_start_accept(ssock_serv, pool, &addr, pj_sockaddr_get_len(&addr));
if (status != PJ_SUCCESS) {
goto on_return;
}
/* Get listener address */
{
pj_ssl_sock_info info;
pj_ssl_sock_get_info(ssock_serv, &info);
pj_sockaddr_cp(&listen_addr, &info.local_addr);
}
/* === CLIENT === */
param.proto = cli_proto;
param.user_data = &state_cli;
param.ciphers_num = (cli_cipher == -1)? 0 : 1;
ciphers[0] = cli_cipher;
state_cli.pool = pool;
state_cli.check_echo = PJ_TRUE;
state_cli.is_verbose = PJ_TRUE;
{
pj_time_val now;
pj_gettimeofday(&now);
pj_srand((unsigned)now.sec);
state_cli.send_str_len = (pj_rand() % 5 + 1) * 1024 + pj_rand() % 1024;
}
state_cli.send_str = (char*)pj_pool_alloc(pool, state_cli.send_str_len);
{
unsigned i;
for (i = 0; i < state_cli.send_str_len; ++i)
state_cli.send_str[i] = (char)(pj_rand() % 256);
}
status = pj_ssl_sock_create(pool, ¶m, &ssock_cli);
if (status != PJ_SUCCESS) {
goto on_return;
}
/* Set cert for client */
{
if (!client_provide_cert) {
pj_str_t tmp1, tmp2;
pj_strset2(&tmp1, (char*)CERT_CA_FILE);
pj_strset2(&tmp2, NULL);
status = pj_ssl_cert_load_from_files(pool,
&tmp1, &tmp2, &tmp2, &tmp2,
&cert);
if (status != PJ_SUCCESS) {
goto on_return;
}
}
status = pj_ssl_sock_set_certificate(ssock_cli, pool, cert);
if (status != PJ_SUCCESS) {
goto on_return;
}
}
status = pj_ssl_sock_start_connect(ssock_cli, pool, &addr, &listen_addr, pj_sockaddr_get_len(&addr));
if (status == PJ_SUCCESS) {
ssl_on_connect_complete(ssock_cli, PJ_SUCCESS);
} else if (status == PJ_EPENDING) {
status = PJ_SUCCESS;
} else {
goto on_return;
}
/* Wait until everything has been sent/received or error */
while (!state_serv.err && !state_cli.err && !state_serv.done && !state_cli.done)
{
#ifdef PJ_SYMBIAN
pj_symbianos_poll(-1, 1000);
#else
pj_time_val delay = {0, 100};
pj_ioqueue_poll(ioqueue, &delay);
#endif
}
/* Clean up sockets */
{
pj_time_val delay = {0, 100};
while (pj_ioqueue_poll(ioqueue, &delay) > 0);
}
if (state_serv.err || state_cli.err) {
if (state_serv.err != PJ_SUCCESS)
status = state_serv.err;
else
status = state_cli.err;
goto on_return;
}
PJ_LOG(3, ("", "...Done!"));
PJ_LOG(3, ("", ".....Sent/recv: %d/%d bytes", state_cli.sent, state_cli.recv));
on_return:
if (ssock_serv)
pj_ssl_sock_close(ssock_serv);
if (ssock_cli && !state_cli.err && !state_cli.done)
pj_ssl_sock_close(ssock_cli);
if (ioqueue)
pj_ioqueue_destroy(ioqueue);
if (pool)
pj_pool_release(pool);
return status;
}
/*******************************************************************
* UDP ping pong test (send packet back and forth between two UDP echo
* servers.
*/
static int udp_ping_pong_test(void)
{
pj_ioqueue_t *ioqueue = NULL;
pj_pool_t *pool = NULL;
struct udp_echo_srv *srv1=NULL, *srv2=NULL;
pj_bool_t need_send = PJ_TRUE;
unsigned data = 0;
int count, ret;
pj_status_t status;
pool = pj_pool_create(mem, "pingpong", 512, 512, NULL);
if (!pool)
return -10;
status = pj_ioqueue_create(pool, 4, &ioqueue);
if (status != PJ_SUCCESS) {
ret = -20;
udp_echo_err("pj_ioqueue_create()", status);
goto on_return;
}
status = udp_echo_srv_create(pool, ioqueue, PJ_TRUE, &srv1);
if (status != PJ_SUCCESS) {
ret = -30;
goto on_return;
}
status = udp_echo_srv_create(pool, ioqueue, PJ_TRUE, &srv2);
if (status != PJ_SUCCESS) {
ret = -40;
goto on_return;
}
/* initiate the first send */
for (count=0; count<1000; ++count) {
unsigned last_rx1, last_rx2;
unsigned i;
if (need_send) {
pj_str_t loopback;
pj_sockaddr_in addr;
pj_ssize_t sent;
++data;
sent = sizeof(data);
loopback = pj_str("127.0.0.1");
pj_sockaddr_in_init(&addr, &loopback, srv2->port);
status = pj_activesock_sendto(srv1->asock, &srv1->send_key,
&data, &sent, 0,
&addr, sizeof(addr));
if (status != PJ_SUCCESS && status != PJ_EPENDING) {
ret = -50;
udp_echo_err("sendto()", status);
goto on_return;
}
need_send = PJ_FALSE;
}
last_rx1 = srv1->rx_cnt;
last_rx2 = srv2->rx_cnt;
for (i=0; i<10 && last_rx1 == srv1->rx_cnt && last_rx2 == srv2->rx_cnt; ++i) {
pj_time_val delay = {0, 10};
#ifdef PJ_SYMBIAN
PJ_UNUSED_ARG(delay);
pj_symbianos_poll(-1, 100);
#else
pj_ioqueue_poll(ioqueue, &delay);
#endif
}
if (srv1->rx_err_cnt+srv1->tx_err_cnt != 0 ||
srv2->rx_err_cnt+srv2->tx_err_cnt != 0)
{
/* Got error */
ret = -60;
goto on_return;
}
if (last_rx1 == srv1->rx_cnt && last_rx2 == srv2->rx_cnt) {
/* Packet lost */
ret = -70;
udp_echo_err("packets have been lost", PJ_ETIMEDOUT);
goto on_return;
}
}
ret = 0;
on_return:
if (srv2)
udp_echo_srv_destroy(srv2);
if (srv1)
udp_echo_srv_destroy(srv1);
if (ioqueue)
pj_ioqueue_destroy(ioqueue);
if (pool)
pj_pool_release(pool);
return ret;
}
/* Raw TCP socket try to connect to SSL socket server, once
* connection established, it will just do nothing, SSL socket
* server should be able to close the connection after specified
* timeout period (set ms_timeout to 0 to disable timer).
*/
static int client_non_ssl(unsigned ms_timeout)
{
pj_pool_t *pool = NULL;
pj_ioqueue_t *ioqueue = NULL;
pj_timer_heap_t *timer = NULL;
pj_ssl_sock_t *ssock_serv = NULL;
pj_activesock_t *asock_cli = NULL;
pj_activesock_cb asock_cb = { 0 };
pj_sock_t sock = PJ_INVALID_SOCKET;
pj_ssl_sock_param param;
struct test_state state_serv = { 0 };
struct test_state state_cli = { 0 };
pj_sockaddr listen_addr;
pj_ssl_cert_t *cert = NULL;
pj_status_t status;
pool = pj_pool_create(mem, "ssl_accept_raw_tcp", 256, 256, NULL);
status = pj_ioqueue_create(pool, 4, &ioqueue);
if (status != PJ_SUCCESS) {
goto on_return;
}
status = pj_timer_heap_create(pool, 4, &timer);
if (status != PJ_SUCCESS) {
goto on_return;
}
/* Set cert */
{
pj_str_t tmp1, tmp2, tmp3, tmp4;
status = pj_ssl_cert_load_from_files(pool,
pj_strset2(&tmp1, (char*)CERT_CA_FILE),
pj_strset2(&tmp2, (char*)CERT_FILE),
pj_strset2(&tmp3, (char*)CERT_PRIVKEY_FILE),
pj_strset2(&tmp4, (char*)CERT_PRIVKEY_PASS),
&cert);
if (status != PJ_SUCCESS) {
goto on_return;
}
}
pj_ssl_sock_param_default(¶m);
param.cb.on_accept_complete = &ssl_on_accept_complete;
param.cb.on_data_read = &ssl_on_data_read;
param.cb.on_data_sent = &ssl_on_data_sent;
param.ioqueue = ioqueue;
param.timer_heap = timer;
param.timeout.sec = 0;
param.timeout.msec = ms_timeout;
pj_time_val_normalize(¶m.timeout);
/* SERVER */
param.user_data = &state_serv;
state_serv.pool = pool;
state_serv.is_server = PJ_TRUE;
state_serv.is_verbose = PJ_TRUE;
status = pj_ssl_sock_create(pool, ¶m, &ssock_serv);
if (status != PJ_SUCCESS) {
goto on_return;
}
status = pj_ssl_sock_set_certificate(ssock_serv, pool, cert);
if (status != PJ_SUCCESS) {
goto on_return;
}
/* Init bind address */
{
pj_str_t tmp_st;
pj_sockaddr_init(PJ_AF_INET, &listen_addr, pj_strset2(&tmp_st, "127.0.0.1"), 0);
}
status = pj_ssl_sock_start_accept(ssock_serv, pool, &listen_addr, pj_sockaddr_get_len(&listen_addr));
if (status != PJ_SUCCESS) {
goto on_return;
}
/* Update listener address */
{
pj_ssl_sock_info info;
pj_ssl_sock_get_info(ssock_serv, &info);
pj_sockaddr_cp(&listen_addr, &info.local_addr);
}
/* CLIENT */
state_cli.pool = pool;
status = pj_sock_socket(pj_AF_INET(), pj_SOCK_STREAM(), 0, &sock);
if (status != PJ_SUCCESS) {
goto on_return;
}
asock_cb.on_connect_complete = &asock_on_connect_complete;
asock_cb.on_data_read = &asock_on_data_read;
status = pj_activesock_create(pool, sock, pj_SOCK_STREAM(), NULL,
ioqueue, &asock_cb, &state_cli, &asock_cli);
if (status != PJ_SUCCESS) {
goto on_return;
}
status = pj_activesock_start_connect(asock_cli, pool, (pj_sockaddr_t*)&listen_addr,
pj_sockaddr_get_len(&listen_addr));
if (status == PJ_SUCCESS) {
asock_on_connect_complete(asock_cli, PJ_SUCCESS);
} else if (status == PJ_EPENDING) {
status = PJ_SUCCESS;
} else {
goto on_return;
}
/* Wait until everything has been sent/received or error */
while (!state_serv.err && !state_cli.err && !state_serv.done && !state_cli.done)
{
#ifdef PJ_SYMBIAN
pj_symbianos_poll(-1, 1000);
#else
pj_time_val delay = {0, 100};
pj_ioqueue_poll(ioqueue, &delay);
pj_timer_heap_poll(timer, &delay);
#endif
}
if (state_serv.err || state_cli.err) {
if (state_serv.err != PJ_SUCCESS)
status = state_serv.err;
else
status = state_cli.err;
goto on_return;
}
PJ_LOG(3, ("", "...Done!"));
on_return:
if (ssock_serv)
pj_ssl_sock_close(ssock_serv);
if (asock_cli && !state_cli.err && !state_cli.done)
pj_activesock_close(asock_cli);
if (timer)
pj_timer_heap_destroy(timer);
if (ioqueue)
pj_ioqueue_destroy(ioqueue);
if (pool)
pj_pool_release(pool);
return status;
}
/* Instantiate standard server */
static int create_std_server(pj_stun_auth_type auth_type,
pj_bool_t responding,
pj_bool_t use_ipv6)
{
pj_pool_t *pool;
pj_stun_session_cb sess_cb;
pj_stun_auth_cred cred;
pj_status_t status;
/* Create server */
pool = pj_pool_create(mem, "server", 1000, 1000, NULL);
server = PJ_POOL_ZALLOC_T(pool, struct server);
server->pool = pool;
server->auth_type = auth_type;
server->responding = responding;
/* Create STUN session */
pj_bzero(&sess_cb, sizeof(sess_cb));
sess_cb.on_rx_request = &server_on_rx_request;
sess_cb.on_send_msg = &server_send_msg;
status = pj_stun_session_create(&stun_cfg, "server", &sess_cb, PJ_FALSE, NULL, &server->sess);
if (status != PJ_SUCCESS) {
destroy_server();
return -10;
}
/* Configure credential */
pj_bzero(&cred, sizeof(cred));
cred.type = PJ_STUN_AUTH_CRED_DYNAMIC;
cred.data.dyn_cred.get_auth = &server_get_auth;
cred.data.dyn_cred.get_password = &server_get_password;
cred.data.dyn_cred.verify_nonce = &server_verify_nonce;
status = pj_stun_session_set_credential(server->sess, auth_type, &cred);
if (status != PJ_SUCCESS) {
destroy_server();
return -20;
}
/* Create socket */
status = pj_sock_socket(GET_AF(use_ipv6), pj_SOCK_DGRAM(), 0, &server->sock);
if (status != PJ_SUCCESS) {
destroy_server();
return -30;
}
/* Bind */
pj_sockaddr_init(GET_AF(use_ipv6), &server->addr, NULL, 0);
status = pj_sock_bind(server->sock, &server->addr, pj_sockaddr_get_len(&server->addr));
if (status != PJ_SUCCESS) {
destroy_server();
return -40;
} else {
/* Get the bound IP address */
int namelen = sizeof(server->addr);
pj_sockaddr addr;
status = pj_sock_getsockname(server->sock, &server->addr, &namelen);
if (status != PJ_SUCCESS) {
destroy_server();
return -43;
}
if (use_ipv6) {
/* pj_gethostip() may return IPv6 link-local and currently it will cause
* 'no route to host' error, so let's just hardcode to [::1]
*/
pj_sockaddr_init(pj_AF_INET6(), &addr, NULL, 0);
addr.ipv6.sin6_addr.s6_addr[15] = 1;
} else {
status = pj_gethostip(GET_AF(use_ipv6), &addr);
if (status != PJ_SUCCESS) {
destroy_server();
return -45;
}
}
pj_sockaddr_copy_addr(&server->addr, &addr);
}
/* Create worker thread */
status = pj_thread_create(pool, "server", &server_thread, 0, 0, 0, &server->thread);
if (status != PJ_SUCCESS) {
destroy_server();
return -30;
}
return 0;
}
static int decode_test(void)
{
unsigned i;
pj_pool_t *pool;
int rc = 0;
pool = pj_pool_create(mem, "decode_test", 1024, 1024, NULL);
PJ_LOG(3,(THIS_FILE, " STUN decode test"));
for (i=0; i<PJ_ARRAY_SIZE(tests); ++i) {
struct test *t = &tests[i];
pj_stun_msg *msg, *msg2;
pj_uint8_t buf[1500];
pj_str_t key;
pj_size_t len;
pj_status_t status;
PJ_LOG(3,(THIS_FILE, " %s", t->title));
if (t->pdu) {
status = pj_stun_msg_decode(pool, (pj_uint8_t*)t->pdu, t->pdu_len,
PJ_STUN_IS_DATAGRAM | PJ_STUN_CHECK_PACKET,
&msg, NULL, NULL);
/* Check expected decode result */
if (t->expected_status != status) {
PJ_LOG(1,(THIS_FILE, " expecting status %d, got %d",
t->expected_status, status));
rc = -10;
goto on_return;
}
} else {
msg = t->create(pool);
status = PJ_SUCCESS;
}
if (status != PJ_SUCCESS)
continue;
/* Try to encode message */
pj_stun_create_key(pool, &key, NULL, &USERNAME, PJ_STUN_PASSWD_PLAIN, &PASSWORD);
status = pj_stun_msg_encode(msg, buf, sizeof(buf), 0, &key, &len);
if (status != PJ_SUCCESS) {
PJ_LOG(1,(THIS_FILE, " encode error: %s", err(status)));
rc = -40;
goto on_return;
}
/* Try to decode it once more */
status = pj_stun_msg_decode(pool, buf, len,
PJ_STUN_IS_DATAGRAM | PJ_STUN_CHECK_PACKET,
&msg2, NULL, NULL);
if (status != PJ_SUCCESS) {
PJ_LOG(1,(THIS_FILE, " subsequent decoding failed: %s", err(status)));
rc = -50;
goto on_return;
}
/* Verify */
if (t->verify) {
rc = t->verify(msg);
if (rc != 0) {
goto on_return;
}
}
}
on_return:
pj_pool_release(pool);
if (rc == 0)
PJ_LOG(3,(THIS_FILE, "...success!"));
return rc;
}
