static int state_progression_test(pj_stun_config *stun_cfg)
{
struct test_session_cfg test_cfg =
{
{ /* Client cfg */
/* DNS SRV */ /* Destroy on state */
PJ_TRUE, 0xFFFF
},
{ /* Server cfg */
0xFFFFFFFF, /* flags */
PJ_TRUE, /* respond to allocate */
PJ_TRUE /* respond to refresh */
}
};
struct test_session *sess;
unsigned i;
int rc;
PJ_LOG(3,("", " state progression tests"));
for (i=0; i<=1; ++i) {
enum { TIMEOUT = 60 };
pjlib_state pjlib_state;
pj_turn_session_info info;
struct test_result result;
pj_time_val tstart;
PJ_LOG(3,("", " %s DNS SRV resolution",
(i==0? "without" : "with")));
capture_pjlib_state(stun_cfg, &pjlib_state);
test_cfg.client.enable_dns_srv = i;
rc = create_test_session(stun_cfg, &test_cfg, &sess);
if (rc != 0)
return rc;
pj_bzero(&info, sizeof(info));
/* Wait until state is READY */
pj_gettimeofday(&tstart);
while (sess->turn_sock) {
pj_time_val now;
poll_events(stun_cfg, 10, PJ_FALSE);
rc = pj_turn_sock_get_info(sess->turn_sock, &info);
if (rc!=PJ_SUCCESS)
break;
if (info.state >= PJ_TURN_STATE_READY)
break;
pj_gettimeofday(&now);
if (now.sec - tstart.sec > TIMEOUT) {
PJ_LOG(3,("", " timed-out"));
break;
}
}
if (info.state != PJ_TURN_STATE_READY) {
PJ_LOG(3,("", " error: state is not READY"));
destroy_session(sess);
return -130;
}
/* Deallocate */
pj_turn_sock_destroy(sess->turn_sock);
/* Wait for couple of seconds.
* We can't poll the session info since the session may have
* been destroyed
*/
poll_events(stun_cfg, 2000, PJ_FALSE);
sess->turn_sock = NULL;
pj_memcpy(&result, &sess->result, sizeof(result));
destroy_session(sess);
/* Check the result */
if ((result.state_called & (1<<PJ_TURN_STATE_RESOLVING)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_RESOLVING is not called"));
return -140;
}
if ((result.state_called & (1<<PJ_TURN_STATE_RESOLVED)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_RESOLVED is not called"));
return -150;
}
if ((result.state_called & (1<<PJ_TURN_STATE_ALLOCATING)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_ALLOCATING is not called"));
return -155;
}
if ((result.state_called & (1<<PJ_TURN_STATE_READY)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_READY is not called"));
return -160;
}
if ((result.state_called & (1<<PJ_TURN_STATE_DEALLOCATING)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_DEALLOCATING is not called"));
return -170;
}
if ((result.state_called & (1<<PJ_TURN_STATE_DEALLOCATED)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_DEALLOCATED is not called"));
return -180;
}
if ((result.state_called & (1<<PJ_TURN_STATE_DESTROYING)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_DESTROYING is not called"));
return -190;
}
poll_events(stun_cfg, 500, PJ_FALSE);
rc = check_pjlib_state(stun_cfg, &pjlib_state);
if (rc != 0) {
PJ_LOG(3,("", " error: memory/timer-heap leak detected"));
return rc;
}
}
return 0;
}
static int destroy_test(pj_stun_config *stun_cfg,
pj_bool_t with_dns_srv,
pj_bool_t in_callback)
{
struct test_session_cfg test_cfg =
{
{ /* Client cfg */
/* DNS SRV */ /* Destroy on state */
PJ_TRUE, 0xFFFF
},
{ /* Server cfg */
0xFFFFFFFF, /* flags */
PJ_TRUE, /* respond to allocate */
PJ_TRUE /* respond to refresh */
}
};
struct test_session *sess;
int target_state;
int rc;
PJ_LOG(3,("", " destroy test %s %s",
(in_callback? "in callback" : ""),
(with_dns_srv? "with DNS srv" : "")
));
test_cfg.client.enable_dns_srv = with_dns_srv;
for (target_state=PJ_TURN_STATE_RESOLVING; target_state<=PJ_TURN_STATE_READY; ++target_state) {
enum { TIMEOUT = 60 };
pjlib_state pjlib_state;
pj_turn_session_info info;
pj_time_val tstart;
capture_pjlib_state(stun_cfg, &pjlib_state);
PJ_LOG(3,("", " %s", pj_turn_state_name((pj_turn_state_t)target_state)));
if (in_callback)
test_cfg.client.destroy_on_state = target_state;
rc = create_test_session(stun_cfg, &test_cfg, &sess);
if (rc != 0)
return rc;
if (in_callback) {
pj_gettimeofday(&tstart);
rc = 0;
while (sess->turn_sock) {
pj_time_val now;
poll_events(stun_cfg, 100, PJ_FALSE);
pj_gettimeofday(&now);
if (now.sec - tstart.sec > TIMEOUT) {
rc = -7;
break;
}
}
} else {
pj_gettimeofday(&tstart);
rc = 0;
while (sess->turn_sock) {
pj_time_val now;
poll_events(stun_cfg, 1, PJ_FALSE);
pj_turn_sock_get_info(sess->turn_sock, &info);
if (info.state >= target_state) {
pj_turn_sock_destroy(sess->turn_sock);
break;
}
pj_gettimeofday(&now);
if (now.sec - tstart.sec > TIMEOUT) {
rc = -8;
break;
}
}
}
if (rc != 0) {
PJ_LOG(3,("", " error: timeout"));
return rc;
}
poll_events(stun_cfg, 1000, PJ_FALSE);
destroy_session(sess);
rc = check_pjlib_state(stun_cfg, &pjlib_state);
if (rc != 0) {
PJ_LOG(3,("", " error: memory/timer-heap leak detected"));
return rc;
}
}
return 0;
}
/*
* The definition of the process.
*/
PROCESS_THREAD(twamp_tcp_control_server, ev, data)
{
/*
* The process begins here.
*/
uip_ipaddr_t *ipaddr;
PROCESS_BEGIN();
set_global_address();
/*
* We start with setting up a listening TCP port. Note how we're
* using the UIP_HTONS() macro to convert the port number (862) to
* network byte order as required by the tcp_listen() function.
*/
tcp_listen(UIP_HTONS(862));
/*
* We loop for ever, accepting new connections.
*/
while(1) {
/*
* We wait until we get the first TCP/IP event, which probably
* comes because someone connected to us.
*/
PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event);
/*
* If a peer connected with us, we'll initialize the protosocket
* with PSOCK_INIT().
*/
if(uip_connected()) {
/*
* The PSOCK_INIT() function initializes the protosocket and
* binds the input buffer to the protosocket.
*/
PSOCK_INIT(&ps, buffer, sizeof(buffer));
printf("Someone connected!\n");
/*
* We loop until the connection is aborted, closed, or times out.
*/
while(!(uip_aborted() || uip_closed() || uip_timedout())) {
/*
* We wait until we get a TCP/IP event. Remember that we
* always need to wait for events inside a process, to let
* other processes run while we are waiting.
*/
PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event);
/*
* Here is where the real work is taking place: we call the
* handle_connection() protothread that we defined above. This
* protothread uses the protosocket to receive the data that
* we want it to.
*/
if(state == 1){
connection_setup(&ps);
}
if(state == 2){
create_test_session(&ps);
}
if(state == 3){
timesynch(&ps);
}
if(state == 4){
//PT_INIT(&pthread);
//run_test_session(&ps);
process_start(&run_test_session,NULL);
PROCESS_YIELD_UNTIL(!process_is_running(&run_test_session));
}
}
}
}
/*
* We must always declare the end of a process.
*/
PROCESS_END();
}
