/*
* Input and parse SDP from the remote (containing remote's ICE information)
* and save it to global variables.
*/
static void icedemo_input_remote(void)
{
char linebuf[80];
unsigned media_cnt = 0;
unsigned comp0_port = 0;
char comp0_addr[80];
pj_bool_t done = PJ_FALSE;
puts("Paste SDP from remote host, end with empty line");
reset_rem_info();
comp0_addr[0] = '\0';
while (!done) {
pj_size_t len;
char *line;
printf(">");
if (stdout) fflush(stdout);
if (fgets(linebuf, sizeof(linebuf), stdin)==NULL)
break;
len = strlen(linebuf);
while (len && (linebuf[len-1] == '\r' || linebuf[len-1] == '\n'))
linebuf[--len] = '\0';
line = linebuf;
while (len && pj_isspace(*line))
++line, --len;
if (len==0)
break;
/* Ignore subsequent media descriptors */
if (media_cnt > 1)
continue;
switch (line[0]) {
case 'm':
{
int cnt;
char media[32], portstr[32];
++media_cnt;
if (media_cnt > 1) {
puts("Media line ignored");
break;
}
cnt = sscanf(line+2, "%s %s RTP/", media, portstr);
if (cnt != 2) {
PJ_LOG(1,(THIS_FILE, "Error parsing media line"));
goto on_error;
}
comp0_port = atoi(portstr);
}
break;
case 'c':
{
int cnt;
char c[32], net[32], ip[80];
cnt = sscanf(line+2, "%s %s %s", c, net, ip);
if (cnt != 3) {
PJ_LOG(1,(THIS_FILE, "Error parsing connection line"));
goto on_error;
}
strcpy(comp0_addr, ip);
}
break;
case 'a':
{
char *attr = strtok(line+2, ": \t\r\n");
if (strcmp(attr, "ice-ufrag")==0) {
strcpy(icedemo.rem.ufrag, attr+strlen(attr)+1);
} else if (strcmp(attr, "ice-pwd")==0) {
strcpy(icedemo.rem.pwd, attr+strlen(attr)+1);
} else if (strcmp(attr, "rtcp")==0) {
char *val = attr+strlen(attr)+1;
int af, cnt;
int port;
char net[32], ip[64];
pj_str_t tmp_addr;
pj_status_t status;
cnt = sscanf(val, "%d IN %s %s", &port, net, ip);
if (cnt != 3) {
PJ_LOG(1,(THIS_FILE, "Error parsing rtcp attribute"));
goto on_error;
}
if (strchr(ip, ':'))
af = pj_AF_INET6();
else
af = pj_AF_INET();
pj_sockaddr_init(af, &icedemo.rem.def_addr[1], NULL, 0);
tmp_addr = pj_str(ip);
status = pj_sockaddr_set_str_addr(af, &icedemo.rem.def_addr[1],
&tmp_addr);
if (status != PJ_SUCCESS) {
PJ_LOG(1,(THIS_FILE, "Invalid IP address"));
goto on_error;
}
pj_sockaddr_set_port(&icedemo.rem.def_addr[1], (pj_uint16_t)port);
} else if (strcmp(attr, "candidate")==0) {
char *sdpcand = attr+strlen(attr)+1;
int af, cnt;
char foundation[32], transport[12], ipaddr[80], type[32];
pj_str_t tmpaddr;
int comp_id, prio, port;
pj_ice_sess_cand *cand;
pj_status_t status;
cnt = sscanf(sdpcand, "%s %d %s %d %s %d typ %s",
foundation,
&comp_id,
transport,
&prio,
ipaddr,
&port,
type);
if (cnt != 7) {
PJ_LOG(1, (THIS_FILE, "error: Invalid ICE candidate line"));
goto on_error;
}
cand = &icedemo.rem.cand[icedemo.rem.cand_cnt];
pj_bzero(cand, sizeof(*cand));
if (strcmp(type, "host")==0)
cand->type = PJ_ICE_CAND_TYPE_HOST;
else if (strcmp(type, "srflx")==0)
cand->type = PJ_ICE_CAND_TYPE_SRFLX;
else if (strcmp(type, "relay")==0)
cand->type = PJ_ICE_CAND_TYPE_RELAYED;
else {
PJ_LOG(1, (THIS_FILE, "Error: invalid candidate type '%s'",
type));
goto on_error;
}
cand->comp_id = (pj_uint8_t)comp_id;
pj_strdup2(icedemo.pool, &cand->foundation, foundation);
cand->prio = prio;
if (strchr(ipaddr, ':'))
af = pj_AF_INET6();
else
af = pj_AF_INET();
tmpaddr = pj_str(ipaddr);
pj_sockaddr_init(af, &cand->addr, NULL, 0);
status = pj_sockaddr_set_str_addr(af, &cand->addr, &tmpaddr);
if (status != PJ_SUCCESS) {
PJ_LOG(1,(THIS_FILE, "Error: invalid IP address '%s'",
ipaddr));
goto on_error;
}
pj_sockaddr_set_port(&cand->addr, (pj_uint16_t)port);
++icedemo.rem.cand_cnt;
if (cand->comp_id > icedemo.rem.comp_cnt)
icedemo.rem.comp_cnt = cand->comp_id;
}
}
break;
}
}
if (icedemo.rem.cand_cnt==0 ||
icedemo.rem.ufrag[0]==0 ||
icedemo.rem.pwd[0]==0 ||
icedemo.rem.comp_cnt == 0)
{
PJ_LOG(1, (THIS_FILE, "Error: not enough info"));
goto on_error;
}
if (comp0_port==0 || comp0_addr[0]=='\0') {
PJ_LOG(1, (THIS_FILE, "Error: default address for component 0 not found"));
goto on_error;
} else {
int af;
pj_str_t tmp_addr;
pj_status_t status;
if (strchr(comp0_addr, ':'))
af = pj_AF_INET6();
else
af = pj_AF_INET();
pj_sockaddr_init(af, &icedemo.rem.def_addr[0], NULL, 0);
tmp_addr = pj_str(comp0_addr);
status = pj_sockaddr_set_str_addr(af, &icedemo.rem.def_addr[0],
&tmp_addr);
if (status != PJ_SUCCESS) {
PJ_LOG(1,(THIS_FILE, "Invalid IP address in c= line"));
goto on_error;
}
pj_sockaddr_set_port(&icedemo.rem.def_addr[0], (pj_uint16_t)comp0_port);
}
PJ_LOG(3, (THIS_FILE, "Done, %d remote candidate(s) added",
icedemo.rem.cand_cnt));
return;
on_error:
reset_rem_info();
}
/*
* unregister_test()
* Check if callback is still called after socket has been unregistered or
* closed.
*/
static int unregister_test(pj_bool_t allow_concur)
{
enum { RPORT = 50000, SPORT = 50001 };
pj_pool_t *pool;
pj_ioqueue_t *ioqueue;
pj_sock_t ssock;
pj_sock_t rsock;
int addrlen;
pj_sockaddr_in addr;
pj_ioqueue_key_t *key;
pj_ioqueue_op_key_t opkey;
pj_ioqueue_callback cb;
unsigned packet_cnt;
char sendbuf[10], recvbuf[10];
pj_ssize_t bytes;
pj_time_val timeout;
pj_status_t status;
pool = pj_pool_create(mem, "test", 4000, 4000, NULL);
if (!pool) {
app_perror("Unable to create pool", PJ_ENOMEM);
return -100;
}
status = pj_ioqueue_create(pool, 16, &ioqueue);
if (status != PJ_SUCCESS) {
app_perror("Error creating ioqueue", status);
return -110;
}
// Set concurrency
TRACE_("set concurrency...");
status = pj_ioqueue_set_default_concurrency(ioqueue, allow_concur);
if (status != PJ_SUCCESS) {
return -112;
}
/* Create sender socket */
status = app_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, SPORT, &ssock);
if (status != PJ_SUCCESS) {
app_perror("Error initializing socket", status);
return -120;
}
/* Create receiver socket. */
status = app_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, RPORT, &rsock);
if (status != PJ_SUCCESS) {
app_perror("Error initializing socket", status);
return -130;
}
/* Register rsock to ioqueue. */
pj_bzero(&cb, sizeof(cb));
cb.on_read_complete = &on_read_complete;
packet_cnt = 0;
status = pj_ioqueue_register_sock(pool, ioqueue, rsock, &packet_cnt,
&cb, &key);
if (status != PJ_SUCCESS) {
app_perror("Error registering to ioqueue", status);
return -140;
}
/* Init operation key. */
pj_ioqueue_op_key_init(&opkey, sizeof(opkey));
/* Start reading. */
bytes = sizeof(recvbuf);
status = pj_ioqueue_recv( key, &opkey, recvbuf, &bytes, 0);
if (status != PJ_EPENDING) {
app_perror("Expecting PJ_EPENDING, but got this", status);
return -150;
}
/* Init destination address. */
addrlen = sizeof(addr);
status = pj_sock_getsockname(rsock, &addr, &addrlen);
if (status != PJ_SUCCESS) {
app_perror("getsockname error", status);
return -160;
}
/* Override address with 127.0.0.1, since getsockname will return
* zero in the address field.
*/
addr.sin_addr = pj_inet_addr2("127.0.0.1");
/* Init buffer to send */
pj_ansi_strcpy(sendbuf, "Hello0123");
/* Send one packet. */
bytes = sizeof(sendbuf);
status = pj_sock_sendto(ssock, sendbuf, &bytes, 0,
&addr, sizeof(addr));
if (status != PJ_SUCCESS) {
app_perror("sendto error", status);
return -170;
}
/* Check if packet is received. */
timeout.sec = 1; timeout.msec = 0;
#ifdef PJ_SYMBIAN
pj_symbianos_poll(-1, 1000);
#else
pj_ioqueue_poll(ioqueue, &timeout);
#endif
if (packet_cnt != 1) {
return -180;
}
/* Just to make sure things are settled.. */
pj_thread_sleep(100);
/* Start reading again. */
bytes = sizeof(recvbuf);
status = pj_ioqueue_recv( key, &opkey, recvbuf, &bytes, 0);
if (status != PJ_EPENDING) {
app_perror("Expecting PJ_EPENDING, but got this", status);
return -190;
}
/* Reset packet counter */
packet_cnt = 0;
/* Send one packet. */
bytes = sizeof(sendbuf);
status = pj_sock_sendto(ssock, sendbuf, &bytes, 0,
&addr, sizeof(addr));
if (status != PJ_SUCCESS) {
app_perror("sendto error", status);
return -200;
}
/* Now unregister and close socket. */
pj_ioqueue_unregister(key);
/* Poll ioqueue. */
#ifdef PJ_SYMBIAN
pj_symbianos_poll(-1, 1000);
#else
timeout.sec = 1; timeout.msec = 0;
pj_ioqueue_poll(ioqueue, &timeout);
#endif
/* Must NOT receive any packets after socket is closed! */
if (packet_cnt > 0) {
PJ_LOG(3,(THIS_FILE, "....errror: not expecting to receive packet "
"after socket has been closed"));
return -210;
}
/* Success */
pj_sock_close(ssock);
pj_ioqueue_destroy(ioqueue);
pj_pool_release(pool);
return 0;
}
/*
* Benchmarking IOQueue
*/
static int bench_test(pj_bool_t allow_concur, int bufsize,
int inactive_sock_count)
{
pj_sock_t ssock=-1, csock=-1;
pj_sockaddr_in addr;
pj_pool_t *pool = NULL;
pj_sock_t *inactive_sock=NULL;
pj_ioqueue_op_key_t *inactive_read_op;
char *send_buf, *recv_buf;
pj_ioqueue_t *ioque = NULL;
pj_ioqueue_key_t *skey, *ckey, *keys[SOCK_INACTIVE_MAX+2];
pj_timestamp t1, t2, t_elapsed;
int rc=0, i; /* i must be signed */
pj_str_t temp;
char errbuf[PJ_ERR_MSG_SIZE];
TRACE__((THIS_FILE, " bench test %d", inactive_sock_count));
// Create pool.
pool = pj_pool_create(mem, NULL, POOL_SIZE, 4000, NULL);
// Allocate buffers for send and receive.
send_buf = (char*)pj_pool_alloc(pool, bufsize);
recv_buf = (char*)pj_pool_alloc(pool, bufsize);
// Allocate sockets for sending and receiving.
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &ssock);
if (rc == PJ_SUCCESS) {
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &csock);
} else
csock = PJ_INVALID_SOCKET;
if (rc != PJ_SUCCESS) {
app_perror("...error: pj_sock_socket()", rc);
goto on_error;
}
// Bind server socket.
pj_bzero(&addr, sizeof(addr));
addr.sin_family = pj_AF_INET();
addr.sin_port = pj_htons(PORT);
if (pj_sock_bind(ssock, &addr, sizeof(addr)))
goto on_error;
pj_assert(inactive_sock_count+2 <= PJ_IOQUEUE_MAX_HANDLES);
// Create I/O Queue.
rc = pj_ioqueue_create(pool, PJ_IOQUEUE_MAX_HANDLES, &ioque);
if (rc != PJ_SUCCESS) {
app_perror("...error: pj_ioqueue_create()", rc);
goto on_error;
}
// Set concurrency
rc = pj_ioqueue_set_default_concurrency(ioque, allow_concur);
if (rc != PJ_SUCCESS) {
app_perror("...error: pj_ioqueue_set_default_concurrency()", rc);
goto on_error;
}
// Allocate inactive sockets, and bind them to some arbitrary address.
// Then register them to the I/O queue, and start a read operation.
inactive_sock = (pj_sock_t*)pj_pool_alloc(pool,
inactive_sock_count*sizeof(pj_sock_t));
inactive_read_op = (pj_ioqueue_op_key_t*)pj_pool_alloc(pool,
inactive_sock_count*sizeof(pj_ioqueue_op_key_t));
pj_bzero(&addr, sizeof(addr));
addr.sin_family = pj_AF_INET();
for (i=0; i<inactive_sock_count; ++i) {
pj_ssize_t bytes;
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &inactive_sock[i]);
if (rc != PJ_SUCCESS || inactive_sock[i] < 0) {
app_perror("...error: pj_sock_socket()", rc);
goto on_error;
}
if ((rc=pj_sock_bind(inactive_sock[i], &addr, sizeof(addr))) != 0) {
pj_sock_close(inactive_sock[i]);
inactive_sock[i] = PJ_INVALID_SOCKET;
app_perror("...error: pj_sock_bind()", rc);
goto on_error;
}
rc = pj_ioqueue_register_sock(pool, ioque, inactive_sock[i],
NULL, &test_cb, &keys[i]);
if (rc != PJ_SUCCESS) {
pj_sock_close(inactive_sock[i]);
inactive_sock[i] = PJ_INVALID_SOCKET;
app_perror("...error(1): pj_ioqueue_register_sock()", rc);
PJ_LOG(3,(THIS_FILE, "....i=%d", i));
goto on_error;
}
bytes = bufsize;
rc = pj_ioqueue_recv(keys[i], &inactive_read_op[i], recv_buf, &bytes, 0);
if (rc != PJ_EPENDING) {
pj_sock_close(inactive_sock[i]);
inactive_sock[i] = PJ_INVALID_SOCKET;
app_perror("...error: pj_ioqueue_read()", rc);
goto on_error;
}
}
// Register server and client socket.
// We put this after inactivity socket, hopefully this can represent the
// worst waiting time.
rc = pj_ioqueue_register_sock(pool, ioque, ssock, NULL,
&test_cb, &skey);
if (rc != PJ_SUCCESS) {
app_perror("...error(2): pj_ioqueue_register_sock()", rc);
goto on_error;
}
rc = pj_ioqueue_register_sock(pool, ioque, csock, NULL,
&test_cb, &ckey);
if (rc != PJ_SUCCESS) {
app_perror("...error(3): pj_ioqueue_register_sock()", rc);
goto on_error;
}
// Set destination address to send the packet.
pj_sockaddr_in_init(&addr, pj_cstr(&temp, "127.0.0.1"), PORT);
// Test loop.
t_elapsed.u64 = 0;
for (i=0; i<LOOP; ++i) {
pj_ssize_t bytes;
pj_ioqueue_op_key_t read_op, write_op;
// Randomize send buffer.
pj_create_random_string(send_buf, bufsize);
// Start reading on the server side.
bytes = bufsize;
rc = pj_ioqueue_recv(skey, &read_op, recv_buf, &bytes, 0);
if (rc != PJ_EPENDING) {
app_perror("...error: pj_ioqueue_read()", rc);
break;
}
// Starts send on the client side.
bytes = bufsize;
rc = pj_ioqueue_sendto(ckey, &write_op, send_buf, &bytes, 0,
&addr, sizeof(addr));
if (rc != PJ_SUCCESS && rc != PJ_EPENDING) {
app_perror("...error: pj_ioqueue_write()", rc);
break;
}
if (rc == PJ_SUCCESS) {
if (bytes < 0) {
app_perror("...error: pj_ioqueue_sendto()", -bytes);
break;
}
}
// Begin time.
pj_get_timestamp(&t1);
// Poll the queue until we've got completion event in the server side.
callback_read_key = NULL;
callback_read_size = 0;
TRACE__((THIS_FILE, " waiting for key = %p", skey));
do {
pj_time_val timeout = { 1, 0 };
#ifdef PJ_SYMBIAN
rc = pj_symbianos_poll(-1, PJ_TIME_VAL_MSEC(timeout));
#else
rc = pj_ioqueue_poll(ioque, &timeout);
#endif
TRACE__((THIS_FILE, " poll rc=%d", rc));
} while (rc >= 0 && callback_read_key != skey);
// End time.
pj_get_timestamp(&t2);
t_elapsed.u64 += (t2.u64 - t1.u64);
if (rc < 0) {
app_perror(" error: pj_ioqueue_poll", -rc);
break;
}
// Compare recv buffer with send buffer.
if (callback_read_size != bufsize ||
pj_memcmp(send_buf, recv_buf, bufsize))
{
rc = -10;
PJ_LOG(3,(THIS_FILE, " error: size/buffer mismatch"));
break;
}
// Poll until all events are exhausted, before we start the next loop.
do {
pj_time_val timeout = { 0, 10 };
#ifdef PJ_SYMBIAN
PJ_UNUSED_ARG(timeout);
rc = pj_symbianos_poll(-1, 100);
#else
rc = pj_ioqueue_poll(ioque, &timeout);
#endif
} while (rc>0);
rc = 0;
}
// Print results
if (rc == 0) {
pj_timestamp tzero;
pj_uint32_t usec_delay;
tzero.u32.hi = tzero.u32.lo = 0;
usec_delay = pj_elapsed_usec( &tzero, &t_elapsed);
PJ_LOG(3, (THIS_FILE, "...%10d %15d % 9d",
bufsize, inactive_sock_count, usec_delay));
} else {
PJ_LOG(2, (THIS_FILE, "...ERROR rc=%d (buf:%d, fds:%d)",
rc, bufsize, inactive_sock_count+2));
}
// Cleaning up.
for (i=inactive_sock_count-1; i>=0; --i) {
pj_ioqueue_unregister(keys[i]);
}
pj_ioqueue_unregister(skey);
pj_ioqueue_unregister(ckey);
pj_ioqueue_destroy(ioque);
pj_pool_release( pool);
return rc;
on_error:
PJ_LOG(1,(THIS_FILE, "...ERROR: %s",
pj_strerror(pj_get_netos_error(), errbuf, sizeof(errbuf))));
if (ssock)
pj_sock_close(ssock);
if (csock)
pj_sock_close(csock);
for (i=0; i<inactive_sock_count && inactive_sock &&
inactive_sock[i]!=PJ_INVALID_SOCKET; ++i)
{
pj_sock_close(inactive_sock[i]);
}
if (ioque != NULL)
pj_ioqueue_destroy(ioque);
pj_pool_release( pool);
return -1;
}
/* This callback is called by transport manager for the TLS factory
* to create outgoing transport to the specified destination.
*/
static pj_status_t lis_create_transport(pjsip_tpfactory *factory,
pjsip_tpmgr *mgr,
pjsip_endpoint *endpt,
const pj_sockaddr *rem_addr,
int addr_len,
pjsip_tx_data *tdata,
pjsip_transport **p_transport)
{
struct tls_listener *listener;
struct tls_transport *tls;
pj_pool_t *pool;
pj_ssl_sock_t *ssock;
pj_ssl_sock_param ssock_param;
pj_sockaddr_in local_addr;
pj_str_t remote_name;
pj_status_t status;
/* Sanity checks */
PJ_ASSERT_RETURN(factory && mgr && endpt && rem_addr &&
addr_len && p_transport, PJ_EINVAL);
/* Check that address is a sockaddr_in */
PJ_ASSERT_RETURN(rem_addr->addr.sa_family == pj_AF_INET() &&
addr_len == sizeof(pj_sockaddr_in), PJ_EINVAL);
listener = (struct tls_listener*)factory;
pool = pjsip_endpt_create_pool(listener->endpt, "tls",
POOL_TP_INIT, POOL_TP_INC);
PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
/* Get remote host name from tdata */
if (tdata)
remote_name = tdata->dest_info.name;
else
pj_bzero(&remote_name, sizeof(remote_name));
/* Build SSL socket param */
pj_ssl_sock_param_default(&ssock_param);
ssock_param.cb.on_connect_complete = &on_connect_complete;
ssock_param.cb.on_data_read = &on_data_read;
ssock_param.cb.on_data_sent = &on_data_sent;
ssock_param.async_cnt = 1;
ssock_param.ioqueue = pjsip_endpt_get_ioqueue(listener->endpt);
ssock_param.server_name = remote_name;
ssock_param.timeout = listener->tls_setting.timeout;
ssock_param.user_data = NULL; /* pending, must be set later */
ssock_param.verify_peer = PJ_FALSE; /* avoid SSL socket closing the socket
* due to verification error */
if (ssock_param.send_buffer_size < PJSIP_MAX_PKT_LEN)
ssock_param.send_buffer_size = PJSIP_MAX_PKT_LEN;
if (ssock_param.read_buffer_size < PJSIP_MAX_PKT_LEN)
ssock_param.read_buffer_size = PJSIP_MAX_PKT_LEN;
ssock_param.ciphers_num = listener->tls_setting.ciphers_num;
ssock_param.ciphers = listener->tls_setting.ciphers;
ssock_param.qos_type = listener->tls_setting.qos_type;
ssock_param.qos_ignore_error = listener->tls_setting.qos_ignore_error;
pj_memcpy(&ssock_param.qos_params, &listener->tls_setting.qos_params,
sizeof(ssock_param.qos_params));
switch(listener->tls_setting.method) {
case PJSIP_TLSV1_METHOD:
ssock_param.proto = PJ_SSL_SOCK_PROTO_TLS1;
break;
case PJSIP_SSLV2_METHOD:
ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL2;
break;
case PJSIP_SSLV3_METHOD:
ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL3;
break;
case PJSIP_SSLV23_METHOD:
ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL23;
break;
default:
ssock_param.proto = PJ_SSL_SOCK_PROTO_DEFAULT;
break;
}
status = pj_ssl_sock_create(pool, &ssock_param, &ssock);
if (status != PJ_SUCCESS)
return status;
/* Apply SSL certificate */
if (listener->cert) {
status = pj_ssl_sock_set_certificate(ssock, pool, listener->cert);
if (status != PJ_SUCCESS)
return status;
}
/* Initially set bind address to PJ_INADDR_ANY port 0 */
pj_sockaddr_in_init(&local_addr, NULL, 0);
/* Create the transport descriptor */
status = tls_create(listener, pool, ssock, PJ_FALSE, &local_addr,
(pj_sockaddr_in*)rem_addr, &remote_name, &tls);
if (status != PJ_SUCCESS)
return status;
/* Set the "pending" SSL socket user data */
pj_ssl_sock_set_user_data(tls->ssock, tls);
/* Start asynchronous connect() operation */
tls->has_pending_connect = PJ_TRUE;
status = pj_ssl_sock_start_connect(tls->ssock, tls->base.pool,
(pj_sockaddr_t*)&local_addr,
(pj_sockaddr_t*)rem_addr,
addr_len);
if (status == PJ_SUCCESS) {
on_connect_complete(tls->ssock, PJ_SUCCESS);
} else if (status != PJ_EPENDING) {
tls_destroy(&tls->base, status);
return status;
}
if (tls->has_pending_connect) {
pj_ssl_sock_info info;
/* Update local address, just in case local address currently set is
* different now that asynchronous connect() is started.
*/
/* Retrieve the bound address */
status = pj_ssl_sock_get_info(tls->ssock, &info);
if (status == PJ_SUCCESS) {
pj_uint16_t new_port;
new_port = pj_sockaddr_get_port((pj_sockaddr_t*)&info.local_addr);
if (pj_sockaddr_has_addr((pj_sockaddr_t*)&info.local_addr)) {
/* Update sockaddr */
pj_sockaddr_cp((pj_sockaddr_t*)&tls->base.local_addr,
(pj_sockaddr_t*)&info.local_addr);
} else if (new_port && new_port != pj_sockaddr_get_port(
(pj_sockaddr_t*)&tls->base.local_addr))
{
/* Update port only */
pj_sockaddr_set_port(&tls->base.local_addr,
new_port);
}
sockaddr_to_host_port(tls->base.pool, &tls->base.local_name,
(pj_sockaddr_in*)&tls->base.local_addr);
}
PJ_LOG(4,(tls->base.obj_name,
"TLS transport %.*s:%d is connecting to %.*s:%d...",
(int)tls->base.local_name.host.slen,
tls->base.local_name.host.ptr,
tls->base.local_name.port,
(int)tls->base.remote_name.host.slen,
tls->base.remote_name.host.ptr,
tls->base.remote_name.port));
}
/* Done */
*p_transport = &tls->base;
return PJ_SUCCESS;
}
/*
* main()
*
* If called with argument, treat argument as SIP URL to be called.
* Otherwise wait for incoming calls.
*/
int main(int argc, char *argv[])
{
pj_pool_t *pool = NULL;
pj_status_t status;
unsigned i;
/* Must init PJLIB first: */
status = pj_init();
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
pj_log_set_level(5);
/* Then init PJLIB-UTIL: */
status = pjlib_util_init();
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Must create a pool factory before we can allocate any memory. */
pj_caching_pool_init(&cp, &pj_pool_factory_default_policy, 0);
/* Create global endpoint: */
{
const pj_str_t *hostname;
const char *endpt_name;
/* Endpoint MUST be assigned a globally unique name.
* The name will be used as the hostname in Warning header.
*/
/* For this implementation, we'll use hostname for simplicity */
hostname = pj_gethostname();
endpt_name = hostname->ptr;
/* Create the endpoint: */
status = pjsip_endpt_create(&cp.factory, endpt_name,
&g_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
}
/*
* Add UDP transport, with hard-coded port
* Alternatively, application can use pjsip_udp_transport_attach() to
* start UDP transport, if it already has an UDP socket (e.g. after it
* resolves the address with STUN).
*/
{
pj_sockaddr addr;
pj_sockaddr_init(AF, &addr, NULL, (pj_uint16_t)SIP_PORT);
if (AF == pj_AF_INET()) {
status = pjsip_udp_transport_start( g_endpt, &addr.ipv4, NULL,
1, NULL);
} else if (AF == pj_AF_INET6()) {
status = pjsip_udp_transport_start6(g_endpt, &addr.ipv6, NULL,
1, NULL);
} else {
status = PJ_EAFNOTSUP;
}
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to start UDP transport", status);
return 1;
}
}
/*
* Init transaction layer.
* This will create/initialize transaction hash tables etc.
*/
status = pjsip_tsx_layer_init_module(g_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/*
* Initialize UA layer module.
* This will create/initialize dialog hash tables etc.
*/
status = pjsip_ua_init_module( g_endpt, NULL );
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/*
* Init invite session module.
* The invite session module initialization takes additional argument,
* i.e. a structure containing callbacks to be called on specific
* occurence of events.
*
* The on_state_changed and on_new_session callbacks are mandatory.
* Application must supply the callback function.
*
* We use on_media_update() callback in this application to start
* media transmission.
*/
{
pjsip_inv_callback inv_cb;
/* Init the callback for INVITE session: */
pj_bzero(&inv_cb, sizeof(inv_cb));
inv_cb.on_state_changed = &call_on_state_changed;
inv_cb.on_new_session = &call_on_forked;
inv_cb.on_media_update = &call_on_media_update;
/* Initialize invite session module: */
status = pjsip_inv_usage_init(g_endpt, &inv_cb);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
}
/* Initialize 100rel support */
status = pjsip_100rel_init_module(g_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, status);
/*
* Register our module to receive incoming requests.
*/
status = pjsip_endpt_register_module( g_endpt, &mod_simpleua);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/*
* Register message logger module.
*/
status = pjsip_endpt_register_module( g_endpt, &msg_logger);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/*
* Initialize media endpoint.
* This will implicitly initialize PJMEDIA too.
*/
#if PJ_HAS_THREADS
status = pjmedia_endpt_create(&cp.factory, NULL, 1, &g_med_endpt);
#else
status = pjmedia_endpt_create(&cp.factory,
pjsip_endpt_get_ioqueue(g_endpt),
0, &g_med_endpt);
#endif
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/*
* Add PCMA/PCMU codec to the media endpoint.
*/
#if defined(PJMEDIA_HAS_G711_CODEC) && PJMEDIA_HAS_G711_CODEC!=0
status = pjmedia_codec_g711_init(g_med_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
#endif
#if defined(PJMEDIA_HAS_VIDEO) && (PJMEDIA_HAS_VIDEO != 0)
/* Init video subsystem */
pool = pjmedia_endpt_create_pool(g_med_endpt, "Video subsystem", 512, 512);
status = pjmedia_video_format_mgr_create(pool, 64, 0, NULL);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
status = pjmedia_converter_mgr_create(pool, NULL);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
status = pjmedia_vid_codec_mgr_create(pool, NULL);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
status = pjmedia_vid_dev_subsys_init(&cp.factory);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
# if defined(PJMEDIA_HAS_FFMPEG_VID_CODEC) && PJMEDIA_HAS_FFMPEG_VID_CODEC!=0
/* Init ffmpeg video codecs */
status = pjmedia_codec_ffmpeg_vid_init(NULL, &cp.factory);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
# endif /* PJMEDIA_HAS_FFMPEG_VID_CODEC */
#endif /* PJMEDIA_HAS_VIDEO */
/*
* Create media transport used to send/receive RTP/RTCP socket.
* One media transport is needed for each call. Application may
* opt to re-use the same media transport for subsequent calls.
*/
for (i = 0; i < PJ_ARRAY_SIZE(g_med_transport); ++i) {
status = pjmedia_transport_udp_create3(g_med_endpt, AF, NULL, NULL,
RTP_PORT + i*2, 0,
&g_med_transport[i]);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to create media transport", status);
return 1;
}
/*
* Get socket info (address, port) of the media transport. We will
* need this info to create SDP (i.e. the address and port info in
* the SDP).
*/
pjmedia_transport_info_init(&g_med_tpinfo[i]);
pjmedia_transport_get_info(g_med_transport[i], &g_med_tpinfo[i]);
pj_memcpy(&g_sock_info[i], &g_med_tpinfo[i].sock_info,
sizeof(pjmedia_sock_info));
}
/*
* If URL is specified, then make call immediately.
*/
if (argc > 1) {
pj_sockaddr hostaddr;
char hostip[PJ_INET6_ADDRSTRLEN+2];
char temp[80];
pj_str_t dst_uri = pj_str(argv[1]);
pj_str_t local_uri;
pjsip_dialog *dlg;
pjmedia_sdp_session *local_sdp;
pjsip_tx_data *tdata;
if (pj_gethostip(AF, &hostaddr) != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to retrieve local host IP", status);
return 1;
}
pj_sockaddr_print(&hostaddr, hostip, sizeof(hostip), 2);
pj_ansi_sprintf(temp, "<sip:simpleuac@%s:%d>",
hostip, SIP_PORT);
local_uri = pj_str(temp);
/* Create UAC dialog */
status = pjsip_dlg_create_uac( pjsip_ua_instance(),
&local_uri, /* local URI */
&local_uri, /* local Contact */
&dst_uri, /* remote URI */
&dst_uri, /* remote target */
&dlg); /* dialog */
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to create UAC dialog", status);
return 1;
}
/* If we expect the outgoing INVITE to be challenged, then we should
* put the credentials in the dialog here, with something like this:
*
{
pjsip_cred_info cred[1];
cred[0].realm = pj_str("sip.server.realm");
cred[0].scheme = pj_str("digest");
cred[0].username = pj_str("theuser");
cred[0].data_type = PJSIP_CRED_DATA_PLAIN_PASSWD;
cred[0].data = pj_str("thepassword");
pjsip_auth_clt_set_credentials( &dlg->auth_sess, 1, cred);
}
*
*/
/* Get the SDP body to be put in the outgoing INVITE, by asking
* media endpoint to create one for us.
*/
status = pjmedia_endpt_create_sdp( g_med_endpt, /* the media endpt */
dlg->pool, /* pool. */
MAX_MEDIA_CNT, /* # of streams */
g_sock_info, /* RTP sock info */
&local_sdp); /* the SDP result */
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Create the INVITE session, and pass the SDP returned earlier
* as the session's initial capability.
*/
status = pjsip_inv_create_uac( dlg, local_sdp, 0, &g_inv);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* If we want the initial INVITE to travel to specific SIP proxies,
* then we should put the initial dialog's route set here. The final
* route set will be updated once a dialog has been established.
* To set the dialog's initial route set, we do it with something
* like this:
*
{
pjsip_route_hdr route_set;
pjsip_route_hdr *route;
const pj_str_t hname = { "Route", 5 };
char *uri = "sip:proxy.server;lr";
pj_list_init(&route_set);
route = pjsip_parse_hdr( dlg->pool, &hname,
uri, strlen(uri),
NULL);
PJ_ASSERT_RETURN(route != NULL, 1);
pj_list_push_back(&route_set, route);
pjsip_dlg_set_route_set(dlg, &route_set);
}
*
* Note that Route URI SHOULD have an ";lr" parameter!
*/
/* Create initial INVITE request.
* This INVITE request will contain a perfectly good request and
* an SDP body as well.
*/
status = pjsip_inv_invite(g_inv, &tdata);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Send initial INVITE request.
* From now on, the invite session's state will be reported to us
* via the invite session callbacks.
*/
status = pjsip_inv_send_msg(g_inv, tdata);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
} else {
/* No URL to make call to */
PJ_LOG(3,(THIS_FILE, "Ready to accept incoming calls..."));
}
/* Loop until one call is completed */
for (;!g_complete;) {
pj_time_val timeout = {0, 10};
pjsip_endpt_handle_events(g_endpt, &timeout);
}
/* On exit, dump current memory usage: */
dump_pool_usage(THIS_FILE, &cp);
/* Destroy audio ports. Destroy the audio port first
* before the stream since the audio port has threads
* that get/put frames to the stream.
*/
if (g_snd_port)
pjmedia_snd_port_destroy(g_snd_port);
#if defined(PJMEDIA_HAS_VIDEO) && (PJMEDIA_HAS_VIDEO != 0)
/* Destroy video ports */
if (g_vid_capturer)
pjmedia_vid_port_destroy(g_vid_capturer);
if (g_vid_renderer)
pjmedia_vid_port_destroy(g_vid_renderer);
#endif
/* Destroy streams */
if (g_med_stream)
pjmedia_stream_destroy(g_med_stream);
#if defined(PJMEDIA_HAS_VIDEO) && (PJMEDIA_HAS_VIDEO != 0)
if (g_med_vstream)
pjmedia_vid_stream_destroy(g_med_vstream);
/* Deinit ffmpeg codec */
# if defined(PJMEDIA_HAS_FFMPEG_VID_CODEC) && PJMEDIA_HAS_FFMPEG_VID_CODEC!=0
pjmedia_codec_ffmpeg_vid_deinit();
# endif
#endif
/* Destroy media transports */
for (i = 0; i < MAX_MEDIA_CNT; ++i) {
if (g_med_transport[i])
pjmedia_transport_close(g_med_transport[i]);
}
/* Deinit pjmedia endpoint */
if (g_med_endpt)
pjmedia_endpt_destroy(g_med_endpt);
/* Deinit pjsip endpoint */
if (g_endpt)
pjsip_endpt_destroy(g_endpt);
/* Release pool */
if (pool)
pj_pool_release(pool);
return 0;
}
/* Generate transport's published address */
static pj_status_t get_published_name(pj_sock_t sock,
char hostbuf[],
int hostbufsz,
pjsip_host_port *bound_name)
{
pj_sockaddr tmp_addr;
int addr_len;
pj_status_t status;
addr_len = sizeof(tmp_addr);
status = pj_sock_getsockname(sock, &tmp_addr, &addr_len);
if (status != PJ_SUCCESS)
return status;
bound_name->host.ptr = hostbuf;
if (tmp_addr.addr.sa_family == pj_AF_INET()) {
bound_name->port = pj_ntohs(tmp_addr.ipv4.sin_port);
/* If bound address specifies "0.0.0.0", get the IP address
* of local hostname.
*/
if (tmp_addr.ipv4.sin_addr.s_addr == PJ_INADDR_ANY) {
pj_sockaddr hostip;
status = pj_gethostip(pj_AF_INET(), &hostip);
if (status != PJ_SUCCESS)
return status;
pj_strcpy2(&bound_name->host, pj_inet_ntoa(hostip.ipv4.sin_addr));
} else {
/* Otherwise use bound address. */
pj_strcpy2(&bound_name->host,
pj_inet_ntoa(tmp_addr.ipv4.sin_addr));
status = PJ_SUCCESS;
}
} else {
/* If bound address specifies "INADDR_ANY" (IPv6), get the
* IP address of local hostname
*/
pj_uint32_t loop6[4] = { 0, 0, 0, 0};
bound_name->port = pj_ntohs(tmp_addr.ipv6.sin6_port);
if (pj_memcmp(&tmp_addr.ipv6.sin6_addr, loop6, sizeof(loop6))==0) {
status = pj_gethostip(tmp_addr.addr.sa_family, &tmp_addr);
if (status != PJ_SUCCESS)
return status;
}
status = pj_inet_ntop(tmp_addr.addr.sa_family,
pj_sockaddr_get_addr(&tmp_addr),
hostbuf, hostbufsz);
if (status == PJ_SUCCESS) {
bound_name->host.slen = pj_ansi_strlen(hostbuf);
}
}
return status;
}
static int stun_destroy_test(void)
{
enum { LOOP = 500 };
struct stun_test_session test_sess;
pj_sockaddr bind_addr;
int addr_len;
pj_caching_pool cp;
pj_pool_t *pool;
unsigned i;
pj_status_t status;
int rc = 0;
PJ_LOG(3,(THIS_FILE, " STUN destroy concurrency test"));
pj_bzero(&test_sess, sizeof(test_sess));
pj_caching_pool_init(&cp, NULL, 0);
pool = pj_pool_create(&cp.factory, "testsess", 512, 512, NULL);
pj_stun_config_init(&test_sess.stun_cfg, &cp.factory, 0, NULL, NULL);
status = pj_timer_heap_create(pool, 1023, &test_sess.stun_cfg.timer_heap);
pj_assert(status == PJ_SUCCESS);
status = pj_lock_create_recursive_mutex(pool, NULL, &test_sess.lock);
pj_assert(status == PJ_SUCCESS);
pj_timer_heap_set_lock(test_sess.stun_cfg.timer_heap, test_sess.lock, PJ_TRUE);
pj_assert(status == PJ_SUCCESS);
status = pj_ioqueue_create(pool, 512, &test_sess.stun_cfg.ioqueue);
pj_assert(status == PJ_SUCCESS);
pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &test_sess.server_sock);
pj_sockaddr_init(pj_AF_INET(), &bind_addr, NULL, 0);
status = pj_sock_bind(test_sess.server_sock, &bind_addr, pj_sockaddr_get_len(&bind_addr));
pj_assert(status == PJ_SUCCESS);
addr_len = sizeof(bind_addr);
status = pj_sock_getsockname(test_sess.server_sock, &bind_addr, &addr_len);
pj_assert(status == PJ_SUCCESS);
test_sess.server_port = pj_sockaddr_get_port(&bind_addr);
status = pj_event_create(pool, NULL, PJ_TRUE, PJ_FALSE, &test_sess.server_event);
pj_assert(status == PJ_SUCCESS);
for (i=0; i<SERVER_THREAD_CNT; ++i) {
status = pj_thread_create(pool, NULL,
&server_thread_proc, &test_sess,
0, 0, &test_sess.server_threads[i]);
pj_assert(status == PJ_SUCCESS);
}
for (i=0; i<WORKER_THREAD_CNT; ++i) {
status = pj_thread_create(pool, NULL,
&worker_thread_proc, &test_sess,
0, 0, &test_sess.worker_threads[i]);
pj_assert(status == PJ_SUCCESS);
}
/* Test 1: Main thread calls destroy while callback is processing response */
PJ_LOG(3,(THIS_FILE, " Destroy in main thread while callback is running"));
for (i=0; i<LOOP; ++i) {
int sleep = pj_rand() % 5;
PJ_LOG(3,(THIS_FILE, " Try %-3d of %d", i+1, LOOP));
/* Test 1: destroy at the same time when receiving response */
pj_bzero(&test_sess.param, sizeof(test_sess.param));
test_sess.param.client_sleep_after_start = 20;
test_sess.param.client_sleep_before_destroy = sleep;
test_sess.param.server_wait_for_event = PJ_TRUE;
stun_destroy_test_session(&test_sess);
PJ_LOG(3,(THIS_FILE,
" stun test a: sleep delay:%d: clients with response: %d",
sleep, test_sess.param.client_got_response));
/* Test 2: destroy at the same time with STUN retransmit timer */
test_sess.param.server_drop_request = PJ_TRUE;
test_sess.param.client_sleep_after_start = 0;
test_sess.param.client_sleep_before_destroy = PJ_STUN_RTO_VALUE;
test_sess.param.server_wait_for_event = PJ_FALSE;
stun_destroy_test_session(&test_sess);
PJ_LOG(3,(THIS_FILE, " stun test b: retransmit concurrency"));
/* Test 3: destroy at the same time with receiving response
* AND STUN retransmit timer */
test_sess.param.client_got_response = 0;
test_sess.param.server_drop_request = PJ_FALSE;
test_sess.param.client_sleep_after_start = PJ_STUN_RTO_VALUE;
test_sess.param.client_sleep_before_destroy = 0;
test_sess.param.server_wait_for_event = PJ_TRUE;
stun_destroy_test_session(&test_sess);
PJ_LOG(3,(THIS_FILE,
" stun test c: clients with response: %d",
test_sess.param.client_got_response));
pj_thread_sleep(10);
ice_one_conc_test(&test_sess.stun_cfg, PJ_FALSE);
pj_thread_sleep(10);
}
/* Avoid compiler warning */
goto on_return;
on_return:
test_sess.thread_quit_flag = PJ_TRUE;
for (i=0; i<SERVER_THREAD_CNT; ++i) {
pj_thread_join(test_sess.server_threads[i]);
}
for (i=0; i<WORKER_THREAD_CNT; ++i) {
pj_thread_join(test_sess.worker_threads[i]);
}
pj_event_destroy(test_sess.server_event);
pj_sock_close(test_sess.server_sock);
pj_ioqueue_destroy(test_sess.stun_cfg.ioqueue);
pj_timer_heap_destroy(test_sess.stun_cfg.timer_heap);
pj_pool_release(pool);
pj_caching_pool_destroy(&cp);
PJ_LOG(3,(THIS_FILE, " Done. rc=%d", rc));
return rc;
}
/*
* Create stream info from SDP media line.
*/
PJ_DEF(pj_status_t) pjmedia_vid_stream_info_from_sdp(
pjmedia_vid_stream_info *si,
pj_pool_t *pool,
pjmedia_endpt *endpt,
const pjmedia_sdp_session *local,
const pjmedia_sdp_session *remote,
unsigned stream_idx)
{
const pj_str_t STR_INACTIVE = { "inactive", 8 };
const pj_str_t STR_SENDONLY = { "sendonly", 8 };
const pj_str_t STR_RECVONLY = { "recvonly", 8 };
const pjmedia_sdp_attr *attr;
const pjmedia_sdp_media *local_m;
const pjmedia_sdp_media *rem_m;
const pjmedia_sdp_conn *local_conn;
const pjmedia_sdp_conn *rem_conn;
int rem_af, local_af;
pj_sockaddr local_addr;
pj_status_t status;
PJ_UNUSED_ARG(endpt);
/* Validate arguments: */
PJ_ASSERT_RETURN(pool && si && local && remote, PJ_EINVAL);
PJ_ASSERT_RETURN(stream_idx < local->media_count, PJ_EINVAL);
PJ_ASSERT_RETURN(stream_idx < remote->media_count, PJ_EINVAL);
/* Keep SDP shortcuts */
local_m = local->media[stream_idx];
rem_m = remote->media[stream_idx];
local_conn = local_m->conn ? local_m->conn : local->conn;
if (local_conn == NULL)
return PJMEDIA_SDP_EMISSINGCONN;
rem_conn = rem_m->conn ? rem_m->conn : remote->conn;
if (rem_conn == NULL)
return PJMEDIA_SDP_EMISSINGCONN;
/* Media type must be video */
if (pj_stricmp(&local_m->desc.media, &ID_VIDEO) != 0)
return PJMEDIA_EINVALIMEDIATYPE;
/* Reset: */
pj_bzero(si, sizeof(*si));
/* Media type: */
si->type = PJMEDIA_TYPE_VIDEO;
/* Transport protocol */
/* At this point, transport type must be compatible,
* the transport instance will do more validation later.
*/
status = pjmedia_sdp_transport_cmp(&rem_m->desc.transport,
&local_m->desc.transport);
if (status != PJ_SUCCESS)
return PJMEDIA_SDPNEG_EINVANSTP;
if (pj_stricmp(&local_m->desc.transport, &ID_RTP_AVP) == 0) {
si->proto = PJMEDIA_TP_PROTO_RTP_AVP;
} else if (pj_stricmp(&local_m->desc.transport, &ID_RTP_SAVP) == 0) {
si->proto = PJMEDIA_TP_PROTO_RTP_SAVP;
} else {
si->proto = PJMEDIA_TP_PROTO_UNKNOWN;
return PJ_SUCCESS;
}
/* Check address family in remote SDP */
rem_af = pj_AF_UNSPEC();
if (pj_stricmp(&rem_conn->net_type, &ID_IN)==0) {
if (pj_stricmp(&rem_conn->addr_type, &ID_IP4)==0) {
rem_af = pj_AF_INET();
} else if (pj_stricmp(&rem_conn->addr_type, &ID_IP6)==0) {
rem_af = pj_AF_INET6();
}
}
if (rem_af==pj_AF_UNSPEC()) {
/* Unsupported address family */
return PJ_EAFNOTSUP;
}
/* Set remote address: */
status = pj_sockaddr_init(rem_af, &si->rem_addr, &rem_conn->addr,
rem_m->desc.port);
if (status != PJ_SUCCESS) {
/* Invalid IP address. */
return PJMEDIA_EINVALIDIP;
}
/* Check address family of local info */
local_af = pj_AF_UNSPEC();
if (pj_stricmp(&local_conn->net_type, &ID_IN)==0) {
if (pj_stricmp(&local_conn->addr_type, &ID_IP4)==0) {
local_af = pj_AF_INET();
} else if (pj_stricmp(&local_conn->addr_type, &ID_IP6)==0) {
local_af = pj_AF_INET6();
}
}
if (local_af==pj_AF_UNSPEC()) {
/* Unsupported address family */
return PJ_SUCCESS;
}
/* Set remote address: */
status = pj_sockaddr_init(local_af, &local_addr, &local_conn->addr,
local_m->desc.port);
if (status != PJ_SUCCESS) {
/* Invalid IP address. */
return PJMEDIA_EINVALIDIP;
}
/* Local and remote address family must match */
if (local_af != rem_af)
return PJ_EAFNOTSUP;
/* Media direction: */
if (local_m->desc.port == 0 ||
pj_sockaddr_has_addr(&local_addr)==PJ_FALSE ||
pj_sockaddr_has_addr(&si->rem_addr)==PJ_FALSE ||
pjmedia_sdp_media_find_attr(local_m, &STR_INACTIVE, NULL)!=NULL)
{
/* Inactive stream. */
si->dir = PJMEDIA_DIR_NONE;
} else if (pjmedia_sdp_media_find_attr(local_m, &STR_SENDONLY, NULL)!=NULL) {
/* Send only stream. */
si->dir = PJMEDIA_DIR_ENCODING;
} else if (pjmedia_sdp_media_find_attr(local_m, &STR_RECVONLY, NULL)!=NULL) {
/* Recv only stream. */
si->dir = PJMEDIA_DIR_DECODING;
} else {
/* Send and receive stream. */
si->dir = PJMEDIA_DIR_ENCODING_DECODING;
}
/* No need to do anything else if stream is rejected */
if (local_m->desc.port == 0) {
return PJ_SUCCESS;
}
/* If "rtcp" attribute is present in the SDP, set the RTCP address
* from that attribute. Otherwise, calculate from RTP address.
*/
attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
"rtcp", NULL);
if (attr) {
pjmedia_sdp_rtcp_attr rtcp;
status = pjmedia_sdp_attr_get_rtcp(attr, &rtcp);
if (status == PJ_SUCCESS) {
if (rtcp.addr.slen) {
status = pj_sockaddr_init(rem_af, &si->rem_rtcp, &rtcp.addr,
(pj_uint16_t)rtcp.port);
} else {
pj_sockaddr_init(rem_af, &si->rem_rtcp, NULL,
(pj_uint16_t)rtcp.port);
pj_memcpy(pj_sockaddr_get_addr(&si->rem_rtcp),
pj_sockaddr_get_addr(&si->rem_addr),
pj_sockaddr_get_addr_len(&si->rem_addr));
}
}
}
if (!pj_sockaddr_has_addr(&si->rem_rtcp)) {
int rtcp_port;
pj_memcpy(&si->rem_rtcp, &si->rem_addr, sizeof(pj_sockaddr));
rtcp_port = pj_sockaddr_get_port(&si->rem_addr) + 1;
pj_sockaddr_set_port(&si->rem_rtcp, (pj_uint16_t)rtcp_port);
}
/* Get codec info and param */
status = get_video_codec_info_param(si, pool, NULL, local_m, rem_m);
/* Leave SSRC to random. */
si->ssrc = pj_rand();
/* Set default jitter buffer parameter. */
si->jb_init = si->jb_max = si->jb_min_pre = si->jb_max_pre = -1;
return status;
}
static int purity_test(void)
{
PJ_LOG(3,("test", "...purity_test()"));
#if defined(PJ_SOCKADDR_HAS_LEN) && PJ_SOCKADDR_HAS_LEN!=0
/* Check on "sin_len" member of sockaddr */
{
const pj_str_t str_ip = {"1.1.1.1", 7};
pj_sockaddr addr[16];
pj_addrinfo ai[16];
unsigned cnt;
pj_status_t rc;
/* pj_enum_ip_interface() */
cnt = PJ_ARRAY_SIZE(addr);
rc = pj_enum_ip_interface(pj_AF_UNSPEC(), &cnt, addr);
if (rc == PJ_SUCCESS) {
while (cnt--)
CHECK_SA_ZERO_LEN(&addr[cnt], -10);
}
/* pj_gethostip() on IPv4 */
rc = pj_gethostip(pj_AF_INET(), &addr[0]);
if (rc == PJ_SUCCESS)
CHECK_SA_ZERO_LEN(&addr[0], -20);
/* pj_gethostip() on IPv6 */
rc = pj_gethostip(pj_AF_INET6(), &addr[0]);
if (rc == PJ_SUCCESS)
CHECK_SA_ZERO_LEN(&addr[0], -30);
/* pj_getdefaultipinterface() on IPv4 */
rc = pj_getdefaultipinterface(pj_AF_INET(), &addr[0]);
if (rc == PJ_SUCCESS)
CHECK_SA_ZERO_LEN(&addr[0], -40);
/* pj_getdefaultipinterface() on IPv6 */
rc = pj_getdefaultipinterface(pj_AF_INET6(), &addr[0]);
if (rc == PJ_SUCCESS)
CHECK_SA_ZERO_LEN(&addr[0], -50);
/* pj_getaddrinfo() on a host name */
cnt = PJ_ARRAY_SIZE(ai);
rc = pj_getaddrinfo(pj_AF_UNSPEC(), pj_gethostname(), &cnt, ai);
if (rc == PJ_SUCCESS) {
while (cnt--)
CHECK_SA_ZERO_LEN(&ai[cnt].ai_addr, -60);
}
/* pj_getaddrinfo() on an IP address */
cnt = PJ_ARRAY_SIZE(ai);
rc = pj_getaddrinfo(pj_AF_UNSPEC(), &str_ip, &cnt, ai);
if (rc == PJ_SUCCESS) {
pj_assert(cnt == 1);
CHECK_SA_ZERO_LEN(&ai[0].ai_addr, -70);
}
}
#endif
return 0;
}
static int init()
{
int i;
pj_status_t status;
CHECK( pj_init() );
CHECK( pjlib_util_init() );
CHECK( pjnath_init() );
/* Check that server is specified */
if (!o.srv_addr) {
printf("Error: server must be specified\n");
return PJ_EINVAL;
}
pj_caching_pool_init(&g.cp, &pj_pool_factory_default_policy, 0);
g.pool = pj_pool_create(&g.cp.factory, "main", 1000, 1000, NULL);
/* Init global STUN config */
pj_stun_config_init(&g.stun_config, &g.cp.factory, 0, NULL, NULL);
/* Create global timer heap */
CHECK( pj_timer_heap_create(g.pool, 1000, &g.stun_config.timer_heap) );
/* Create global ioqueue */
CHECK( pj_ioqueue_create(g.pool, 16, &g.stun_config.ioqueue) );
/*
* Create peers
*/
for (i=0; i<(int)PJ_ARRAY_SIZE(g.peer); ++i) {
pj_stun_sock_cb stun_sock_cb;
char name[] = "peer0";
pj_uint16_t port;
pj_str_t server;
pj_bzero(&stun_sock_cb, sizeof(stun_sock_cb));
stun_sock_cb.on_rx_data = &stun_sock_on_rx_data;
stun_sock_cb.on_status = &stun_sock_on_status;
g.peer[i].mapped_addr.addr.sa_family = pj_AF_INET();
name[strlen(name)-1] = '0'+i;
status = pj_stun_sock_create(&g.stun_config, name, pj_AF_INET(),
&stun_sock_cb, NULL,
&g.peer[i], &g.peer[i].stun_sock);
if (status != PJ_SUCCESS) {
my_perror("pj_stun_sock_create()", status);
return status;
}
if (o.stun_server) {
server = pj_str(o.stun_server);
port = PJ_STUN_PORT;
} else {
server = pj_str(o.srv_addr);
port = (pj_uint16_t)(o.srv_port?atoi(o.srv_port):PJ_STUN_PORT);
}
status = pj_stun_sock_start(g.peer[i].stun_sock, &server,
port, NULL);
if (status != PJ_SUCCESS) {
my_perror("pj_stun_sock_start()", status);
return status;
}
}
/* Start the worker thread */
CHECK( pj_thread_create(g.pool, "stun", &worker_thread, NULL, 0, 0, &g.thread) );
return PJ_SUCCESS;
}
static pj_status_t create_relay(void)
{
pj_turn_sock_cb rel_cb;
pj_stun_auth_cred cred;
pj_str_t srv;
pj_status_t status;
if (g.relay) {
PJ_LOG(1,(THIS_FILE, "Relay already created"));
return -1;
}
/* Create DNS resolver if configured */
if (o.nameserver) {
pj_str_t ns = pj_str(o.nameserver);
status = pj_dns_resolver_create(&g.cp.factory, "resolver", 0,
g.stun_config.timer_heap,
g.stun_config.ioqueue, &g.resolver);
if (status != PJ_SUCCESS) {
PJ_LOG(1,(THIS_FILE, "Error creating resolver (err=%d)", status));
return status;
}
status = pj_dns_resolver_set_ns(g.resolver, 1, &ns, NULL);
if (status != PJ_SUCCESS) {
PJ_LOG(1,(THIS_FILE, "Error configuring nameserver (err=%d)", status));
return status;
}
}
pj_bzero(&rel_cb, sizeof(rel_cb));
rel_cb.on_rx_data = &turn_on_rx_data;
rel_cb.on_state = &turn_on_state;
CHECK( pj_turn_sock_create(&g.stun_config, pj_AF_INET(),
(o.use_tcp? PJ_TURN_TP_TCP : PJ_TURN_TP_UDP),
&rel_cb, 0,
NULL, &g.relay) );
if (o.user_name) {
pj_bzero(&cred, sizeof(cred));
cred.type = PJ_STUN_AUTH_CRED_STATIC;
cred.data.static_cred.realm = pj_str(o.realm);
cred.data.static_cred.username = pj_str(o.user_name);
cred.data.static_cred.data_type = PJ_STUN_PASSWD_PLAIN;
cred.data.static_cred.data = pj_str(o.password);
//cred.data.static_cred.nonce = pj_str(o.nonce);
} else {
PJ_LOG(2,(THIS_FILE, "Warning: no credential is set"));
}
srv = pj_str(o.srv_addr);
CHECK(pj_turn_sock_alloc(g.relay, /* the relay */
&srv, /* srv addr */
(o.srv_port?atoi(o.srv_port):PJ_STUN_PORT),/* def port */
g.resolver, /* resolver */
(o.user_name?&cred:NULL), /* credential */
NULL) /* alloc param */
);
return PJ_SUCCESS;
}
/* 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;
}
/* 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;
}
/* Create ICE stream transport */
static int create_ice_strans(struct test_sess *test_sess,
struct ice_ept *ept,
pj_ice_strans **p_ice)
{
pj_ice_strans *ice;
pj_ice_strans_cb ice_cb;
pj_ice_strans_cfg ice_cfg;
pj_sockaddr hostip;
char serverip[PJ_INET6_ADDRSTRLEN];
pj_status_t status;
status = pj_gethostip(pj_AF_INET(), &hostip);
if (status != PJ_SUCCESS)
return -1030;
pj_sockaddr_print(&hostip, serverip, sizeof(serverip), 0);
/* Init callback structure */
pj_bzero(&ice_cb, sizeof(ice_cb));
ice_cb.on_rx_data = &ice_on_rx_data;
ice_cb.on_ice_complete = &ice_on_ice_complete;
/* Init ICE stream transport configuration structure */
pj_ice_strans_cfg_default(&ice_cfg);
pj_memcpy(&ice_cfg.stun_cfg, test_sess->stun_cfg, sizeof(pj_stun_config));
if ((ept->cfg.enable_stun & SRV)==SRV || (ept->cfg.enable_turn & SRV)==SRV)
ice_cfg.resolver = test_sess->resolver;
if (ept->cfg.enable_stun & YES) {
if ((ept->cfg.enable_stun & SRV) == SRV) {
ice_cfg.stun.server = pj_str(SRV_DOMAIN);
} else {
ice_cfg.stun.server = pj_str(serverip);
}
ice_cfg.stun.port = STUN_SERVER_PORT;
}
if (ept->cfg.enable_host == 0) {
ice_cfg.stun.max_host_cands = 0;
} else {
//ice_cfg.stun.no_host_cands = PJ_FALSE;
ice_cfg.stun.loop_addr = PJ_TRUE;
}
if (ept->cfg.enable_turn & YES) {
if ((ept->cfg.enable_turn & SRV) == SRV) {
ice_cfg.turn.server = pj_str(SRV_DOMAIN);
} else {
ice_cfg.turn.server = pj_str(serverip);
}
ice_cfg.turn.port = TURN_SERVER_PORT;
ice_cfg.turn.conn_type = PJ_TURN_TP_UDP;
ice_cfg.turn.auth_cred.type = PJ_STUN_AUTH_CRED_STATIC;
ice_cfg.turn.auth_cred.data.static_cred.realm = pj_str(SRV_DOMAIN);
if (ept->cfg.client_flag & WRONG_TURN)
ice_cfg.turn.auth_cred.data.static_cred.username = pj_str("xxx");
else
ice_cfg.turn.auth_cred.data.static_cred.username = pj_str(TURN_USERNAME);
ice_cfg.turn.auth_cred.data.static_cred.data_type = PJ_STUN_PASSWD_PLAIN;
ice_cfg.turn.auth_cred.data.static_cred.data = pj_str(TURN_PASSWD);
}
/* Create ICE stream transport */
status = pj_ice_strans_create(NULL, &ice_cfg, ept->cfg.comp_cnt,
(void*)ept, &ice_cb,
&ice);
if (status != PJ_SUCCESS) {
app_perror(INDENT "err: pj_ice_strans_create()", status);
return status;
}
pj_create_unique_string(test_sess->pool, &ept->ufrag);
pj_create_unique_string(test_sess->pool, &ept->pass);
/* Looks alright */
*p_ice = ice;
return PJ_SUCCESS;
}
/*
* Restart transport.
*
* If option is KEEP_SOCKET, just re-activate ioqueue operation.
*
* If option is DESTROY_SOCKET:
* - if socket is specified, replace.
* - if socket is not specified, create and replace.
*/
PJ_DEF(pj_status_t) pjsip_udp_transport_restart(pjsip_transport *transport,
unsigned option,
pj_sock_t sock,
const pj_sockaddr_in *local,
const pjsip_host_port *a_name)
{
struct udp_transport *tp;
pj_status_t status;
PJ_ASSERT_RETURN(transport != NULL, PJ_EINVAL);
/* Flag must be specified */
PJ_ASSERT_RETURN((option & 0x03) != 0, PJ_EINVAL);
tp = (struct udp_transport*) transport;
if (option & PJSIP_UDP_TRANSPORT_DESTROY_SOCKET) {
char addr_buf[PJ_INET6_ADDRSTRLEN];
pjsip_host_port bound_name;
/* Request to recreate transport */
/* Destroy existing socket, if any. */
if (tp->key) {
/* This implicitly closes the socket */
pj_ioqueue_unregister(tp->key);
tp->key = NULL;
} else {
/* Close socket. */
if (tp->sock && tp->sock != PJ_INVALID_SOCKET) {
pj_sock_close(tp->sock);
tp->sock = PJ_INVALID_SOCKET;
}
}
tp->sock = PJ_INVALID_SOCKET;
/* Create the socket if it's not specified */
if (sock == PJ_INVALID_SOCKET) {
status = create_socket(pj_AF_INET(), local,
sizeof(pj_sockaddr_in), &sock);
if (status != PJ_SUCCESS)
return status;
}
/* If transport published name is not specified, calculate it
* from the bound address.
*/
if (a_name == NULL) {
status = get_published_name(sock, addr_buf, sizeof(addr_buf),
&bound_name);
if (status != PJ_SUCCESS) {
pj_sock_close(sock);
return status;
}
a_name = &bound_name;
}
/* Init local address. */
status = pj_sock_getsockname(sock, &tp->base.local_addr,
&tp->base.addr_len);
if (status != PJ_SUCCESS)
return status;
/* Assign the socket and published address to transport. */
udp_set_socket(tp, sock, a_name);
} else {
/* For KEEP_SOCKET, transport must have been paused before */
PJ_ASSERT_RETURN(tp->is_paused, PJ_EINVALIDOP);
/* If address name is specified, update it */
if (a_name != NULL)
udp_set_pub_name(tp, a_name);
}
/* Re-register new or existing socket to ioqueue. */
status = register_to_ioqueue(tp);
if (status != PJ_SUCCESS) {
return status;
}
/* Restart async read operation. */
status = start_async_read(tp);
if (status != PJ_SUCCESS)
return status;
/* Everything has been set up */
tp->is_paused = PJ_FALSE;
PJ_LOG(4,(tp->base.obj_name,
"SIP UDP transport restarted, published address is %.*s:%d",
(int)tp->base.local_name.host.slen,
tp->base.local_name.host.ptr,
tp->base.local_name.port));
return PJ_SUCCESS;
}
static int udp_test(void)
{
pj_sock_t cs = PJ_INVALID_SOCKET, ss = PJ_INVALID_SOCKET;
pj_sockaddr_in dstaddr, srcaddr;
pj_str_t s;
pj_status_t rc = 0, retval;
PJ_LOG(3,("test", "...udp_test()"));
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &ss);
if (rc != 0) {
app_perror("...error: unable to create socket", rc);
return -100;
}
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &cs);
if (rc != 0)
return -110;
/* Bind server socket. */
pj_bzero(&dstaddr, sizeof(dstaddr));
dstaddr.sin_family = pj_AF_INET();
dstaddr.sin_port = pj_htons(UDP_PORT);
dstaddr.sin_addr = pj_inet_addr(pj_cstr(&s, ADDRESS));
if ((rc=pj_sock_bind(ss, &dstaddr, sizeof(dstaddr))) != 0) {
app_perror("...bind error udp:"ADDRESS, rc);
rc = -120;
goto on_error;
}
/* Bind client socket. */
pj_bzero(&srcaddr, sizeof(srcaddr));
srcaddr.sin_family = pj_AF_INET();
srcaddr.sin_port = pj_htons(UDP_PORT-1);
srcaddr.sin_addr = pj_inet_addr(pj_cstr(&s, ADDRESS));
if ((rc=pj_sock_bind(cs, &srcaddr, sizeof(srcaddr))) != 0) {
app_perror("...bind error", rc);
rc = -121;
goto on_error;
}
/* Test send/recv, with sendto */
rc = send_recv_test(pj_SOCK_DGRAM(), ss, cs, &dstaddr, NULL,
sizeof(dstaddr));
if (rc != 0)
goto on_error;
/* Test send/recv, with sendto and recvfrom */
rc = send_recv_test(pj_SOCK_DGRAM(), ss, cs, &dstaddr,
&srcaddr, sizeof(dstaddr));
if (rc != 0)
goto on_error;
/* Disable this test on Symbian since UDP connect()/send() failed
* with S60 3rd edition (including MR2).
* See http://www.pjsip.org/trac/ticket/264
*/
#if !defined(PJ_SYMBIAN) || PJ_SYMBIAN==0
/* connect() the sockets. */
rc = pj_sock_connect(cs, &dstaddr, sizeof(dstaddr));
if (rc != 0) {
app_perror("...connect() error", rc);
rc = -122;
goto on_error;
}
/* Test send/recv with send() */
rc = send_recv_test(pj_SOCK_DGRAM(), ss, cs, NULL, NULL, 0);
if (rc != 0)
goto on_error;
/* Test send/recv with send() and recvfrom */
rc = send_recv_test(pj_SOCK_DGRAM(), ss, cs, NULL, &srcaddr,
sizeof(srcaddr));
if (rc != 0)
goto on_error;
#endif
on_error:
retval = rc;
if (cs != PJ_INVALID_SOCKET) {
rc = pj_sock_close(cs);
if (rc != PJ_SUCCESS) {
app_perror("...error in closing socket", rc);
return -1000;
}
}
if (ss != PJ_INVALID_SOCKET) {
rc = pj_sock_close(ss);
if (rc != PJ_SUCCESS) {
app_perror("...error in closing socket", rc);
return -1010;
}
}
return retval;
}
/*
* udp_on_read_complete()
*
* This is callback notification from ioqueue that a pending recvfrom()
* operation has completed.
*/
static void udp_on_read_complete( pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
pj_ssize_t bytes_read)
{
/* See https://trac.pjsip.org/repos/ticket/1197 */
enum { MAX_IMMEDIATE_PACKET = 50 };
pjsip_rx_data_op_key *rdata_op_key = (pjsip_rx_data_op_key*) op_key;
pjsip_rx_data *rdata = rdata_op_key->rdata;
struct udp_transport *tp = (struct udp_transport*)rdata->tp_info.transport;
int i;
pj_status_t status;
/* Don't do anything if transport is closing. */
if (tp->is_closing) {
tp->is_closing++;
return;
}
/* Don't do anything if transport is being paused. */
if (tp->is_paused)
return;
/*
* The idea of the loop is to process immediate data received by
* pj_ioqueue_recvfrom(), as long as i < MAX_IMMEDIATE_PACKET. When
* i is >= MAX_IMMEDIATE_PACKET, we force the recvfrom() operation to
* complete asynchronously, to allow other sockets to get their data.
*/
for (i=0;; ++i) {
enum { MIN_SIZE = 32 };
pj_uint32_t flags;
/* Report the packet to transport manager. Only do so if packet size
* is relatively big enough for a SIP packet.
*/
if (bytes_read > MIN_SIZE) {
pj_size_t size_eaten;
const pj_sockaddr *src_addr = &rdata->pkt_info.src_addr;
/* Init pkt_info part. */
rdata->pkt_info.len = bytes_read;
rdata->pkt_info.zero = 0;
pj_gettimeofday(&rdata->pkt_info.timestamp);
if (src_addr->addr.sa_family == pj_AF_INET()) {
pj_ansi_strcpy(rdata->pkt_info.src_name,
pj_inet_ntoa(src_addr->ipv4.sin_addr));
rdata->pkt_info.src_port = pj_ntohs(src_addr->ipv4.sin_port);
} else {
pj_inet_ntop(pj_AF_INET6(),
pj_sockaddr_get_addr(&rdata->pkt_info.src_addr),
rdata->pkt_info.src_name,
sizeof(rdata->pkt_info.src_name));
rdata->pkt_info.src_port = pj_ntohs(src_addr->ipv6.sin6_port);
}
size_eaten =
pjsip_tpmgr_receive_packet(rdata->tp_info.transport->tpmgr,
rdata);
if (size_eaten < 0) {
pj_assert(!"It shouldn't happen!");
size_eaten = rdata->pkt_info.len;
}
/* Since this is UDP, the whole buffer is the message. */
rdata->pkt_info.len = 0;
} else if (bytes_read <= MIN_SIZE) {
/* TODO: */
} else if (-bytes_read != PJ_STATUS_FROM_OS(OSERR_EWOULDBLOCK) &&
-bytes_read != PJ_STATUS_FROM_OS(OSERR_EINPROGRESS) &&
-bytes_read != PJ_STATUS_FROM_OS(OSERR_ECONNRESET))
{
/* Report error to endpoint. */
PJSIP_ENDPT_LOG_ERROR((rdata->tp_info.transport->endpt,
rdata->tp_info.transport->obj_name,
(pj_status_t)-bytes_read,
"Warning: pj_ioqueue_recvfrom()"
" callback error"));
}
if (i >= MAX_IMMEDIATE_PACKET) {
/* Force ioqueue_recvfrom() to return PJ_EPENDING */
flags = PJ_IOQUEUE_ALWAYS_ASYNC;
} else {
flags = 0;
}
/* Reset pool.
* Need to copy rdata fields to temp variable because they will
* be invalid after pj_pool_reset().
*/
{
pj_pool_t *rdata_pool = rdata->tp_info.pool;
struct udp_transport *rdata_tp ;
unsigned rdata_index;
rdata_tp = (struct udp_transport*)rdata->tp_info.transport;
rdata_index = (unsigned)(unsigned long)(pj_ssize_t)
rdata->tp_info.tp_data;
pj_pool_reset(rdata_pool);
init_rdata(rdata_tp, rdata_index, rdata_pool, &rdata);
/* Change some vars to point to new location after
* pool reset.
*/
op_key = &rdata->tp_info.op_key.op_key;
}
/* Only read next packet if transport is not being paused. This
* check handles the case where transport is paused while endpoint
* is still processing a SIP message.
*/
if (tp->is_paused)
return;
/* Read next packet. */
bytes_read = sizeof(rdata->pkt_info.packet);
rdata->pkt_info.src_addr_len = sizeof(rdata->pkt_info.src_addr);
status = pj_ioqueue_recvfrom(key, op_key,
rdata->pkt_info.packet,
&bytes_read, flags,
&rdata->pkt_info.src_addr,
&rdata->pkt_info.src_addr_len);
if (status == PJ_SUCCESS) {
/* Continue loop. */
pj_assert(i < MAX_IMMEDIATE_PACKET);
} else if (status == PJ_EPENDING) {
break;
} else {
if (i < MAX_IMMEDIATE_PACKET) {
/* Report error to endpoint if this is not EWOULDBLOCK error.*/
if (status != PJ_STATUS_FROM_OS(OSERR_EWOULDBLOCK) &&
status != PJ_STATUS_FROM_OS(OSERR_EINPROGRESS) &&
status != PJ_STATUS_FROM_OS(OSERR_ECONNRESET))
{
PJSIP_ENDPT_LOG_ERROR((rdata->tp_info.transport->endpt,
rdata->tp_info.transport->obj_name,
status,
"Warning: pj_ioqueue_recvfrom"));
}
/* Continue loop. */
bytes_read = 0;
} else {
/* This is fatal error.
* Ioqueue operation will stop for this transport!
*/
PJSIP_ENDPT_LOG_ERROR((rdata->tp_info.transport->endpt,
rdata->tp_info.transport->obj_name,
status,
"FATAL: pj_ioqueue_recvfrom() error, "
"UDP transport stopping! Error"));
break;
}
}
}
}
static int format_test(void)
{
pj_str_t s = pj_str(ADDRESS);
unsigned char *p;
pj_in_addr addr;
char zero[64];
pj_sockaddr_in addr2;
const pj_str_t *hostname;
const unsigned char A[] = {127, 0, 0, 1};
PJ_LOG(3,("test", "...format_test()"));
/* pj_inet_aton() */
if (pj_inet_aton(&s, &addr) != 1)
return -10;
/* Check the result. */
p = (unsigned char*)&addr;
if (p[0]!=A[0] || p[1]!=A[1] || p[2]!=A[2] || p[3]!=A[3]) {
PJ_LOG(3,("test", " error: mismatched address. p0=%d, p1=%d, "
"p2=%d, p3=%d", p[0] & 0xFF, p[1] & 0xFF,
p[2] & 0xFF, p[3] & 0xFF));
return -15;
}
/* pj_inet_ntoa() */
p = (unsigned char*) pj_inet_ntoa(addr);
if (!p)
return -20;
if (pj_strcmp2(&s, (char*)p) != 0)
return -22;
#if defined(PJ_HAS_IPV6) && PJ_HAS_IPV6!=0
/* pj_inet_pton() */
/* pj_inet_ntop() */
{
const pj_str_t s_ipv4 = pj_str("127.0.0.1");
const pj_str_t s_ipv6 = pj_str("fe80::2ff:83ff:fe7c:8b42");
char buf_ipv4[PJ_INET_ADDRSTRLEN];
char buf_ipv6[PJ_INET6_ADDRSTRLEN];
pj_in_addr ipv4;
pj_in6_addr ipv6;
if (pj_inet_pton(pj_AF_INET(), &s_ipv4, &ipv4) != PJ_SUCCESS)
return -24;
p = (unsigned char*)&ipv4;
if (p[0]!=A[0] || p[1]!=A[1] || p[2]!=A[2] || p[3]!=A[3]) {
return -25;
}
if (pj_inet_pton(pj_AF_INET6(), &s_ipv6, &ipv6) != PJ_SUCCESS)
return -26;
p = (unsigned char*)&ipv6;
if (p[0] != 0xfe || p[1] != 0x80 || p[2] != 0 || p[3] != 0 ||
p[4] != 0 || p[5] != 0 || p[6] != 0 || p[7] != 0 ||
p[8] != 0x02 || p[9] != 0xff || p[10] != 0x83 || p[11] != 0xff ||
p[12]!=0xfe || p[13]!=0x7c || p[14] != 0x8b || p[15]!=0x42)
{
return -27;
}
if (pj_inet_ntop(pj_AF_INET(), &ipv4, buf_ipv4, sizeof(buf_ipv4)) != PJ_SUCCESS)
return -28;
if (pj_stricmp2(&s_ipv4, buf_ipv4) != 0)
return -29;
if (pj_inet_ntop(pj_AF_INET6(), &ipv6, buf_ipv6, sizeof(buf_ipv6)) != PJ_SUCCESS)
return -30;
if (pj_stricmp2(&s_ipv6, buf_ipv6) != 0)
return -31;
}
#endif /* PJ_HAS_IPV6 */
/* Test that pj_sockaddr_in_init() initialize the whole structure,
* including sin_zero.
*/
pj_sockaddr_in_init(&addr2, 0, 1000);
pj_bzero(zero, sizeof(zero));
if (pj_memcmp(addr2.sin_zero, zero, sizeof(addr2.sin_zero)) != 0)
return -35;
/* pj_gethostname() */
hostname = pj_gethostname();
if (!hostname || !hostname->ptr || !hostname->slen)
return -40;
PJ_LOG(3,("test", "....hostname is %.*s",
(int)hostname->slen, hostname->ptr));
/* pj_gethostaddr() */
/* Various constants */
#if !defined(PJ_SYMBIAN) || PJ_SYMBIAN==0
if (PJ_AF_INET==0xFFFF) return -5500;
if (PJ_AF_INET6==0xFFFF) return -5501;
/* 0xFFFF could be a valid SOL_SOCKET (e.g: on some Win or Mac) */
//if (PJ_SOL_SOCKET==0xFFFF) return -5503;
if (PJ_SOL_IP==0xFFFF) return -5502;
if (PJ_SOL_TCP==0xFFFF) return -5510;
if (PJ_SOL_UDP==0xFFFF) return -5520;
if (PJ_SOL_IPV6==0xFFFF) return -5530;
if (PJ_SO_TYPE==0xFFFF) return -5540;
if (PJ_SO_RCVBUF==0xFFFF) return -5550;
if (PJ_SO_SNDBUF==0xFFFF) return -5560;
if (PJ_TCP_NODELAY==0xFFFF) return -5570;
if (PJ_SO_REUSEADDR==0xFFFF) return -5580;
if (PJ_MSG_OOB==0xFFFF) return -5590;
if (PJ_MSG_PEEK==0xFFFF) return -5600;
#endif
return 0;
}
/*
* pjsip_udp_transport_attach()
*
* Attach UDP socket and start transport.
*/
static pj_status_t transport_attach( pjsip_endpoint *endpt,
pjsip_transport_type_e type,
pj_sock_t sock,
const pjsip_host_port *a_name,
unsigned async_cnt,
pjsip_transport **p_transport)
{
pj_pool_t *pool;
struct udp_transport *tp;
const char *format, *ipv6_quoteb, *ipv6_quotee;
unsigned i;
pj_status_t status;
PJ_ASSERT_RETURN(endpt && sock!=PJ_INVALID_SOCKET && a_name && async_cnt>0,
PJ_EINVAL);
/* Object name. */
if (type & PJSIP_TRANSPORT_IPV6) {
format = "udpv6%p";
ipv6_quoteb = "[";
ipv6_quotee = "]";
} else {
format = "udp%p";
ipv6_quoteb = ipv6_quotee = "";
}
/* Create pool. */
pool = pjsip_endpt_create_pool(endpt, format, PJSIP_POOL_LEN_TRANSPORT,
PJSIP_POOL_INC_TRANSPORT);
if (!pool)
return PJ_ENOMEM;
/* Create the UDP transport object. */
tp = PJ_POOL_ZALLOC_T(pool, struct udp_transport);
/* Save pool. */
tp->base.pool = pool;
pj_memcpy(tp->base.obj_name, pool->obj_name, PJ_MAX_OBJ_NAME);
/* Init reference counter. */
status = pj_atomic_create(pool, 0, &tp->base.ref_cnt);
if (status != PJ_SUCCESS)
goto on_error;
/* Init lock. */
status = pj_lock_create_recursive_mutex(pool, pool->obj_name,
&tp->base.lock);
if (status != PJ_SUCCESS)
goto on_error;
/* Set type. */
tp->base.key.type = type;
/* Remote address is left zero (except the family) */
tp->base.key.rem_addr.addr.sa_family = (pj_uint16_t)
((type & PJSIP_TRANSPORT_IPV6) ? pj_AF_INET6() : pj_AF_INET());
/* Type name. */
tp->base.type_name = "UDP";
/* Transport flag */
tp->base.flag = pjsip_transport_get_flag_from_type(type);
/* Length of addressess. */
tp->base.addr_len = sizeof(tp->base.local_addr);
/* Init local address. */
status = pj_sock_getsockname(sock, &tp->base.local_addr,
&tp->base.addr_len);
if (status != PJ_SUCCESS)
goto on_error;
/* Init remote name. */
if (type == PJSIP_TRANSPORT_UDP)
tp->base.remote_name.host = pj_str("0.0.0.0");
else
tp->base.remote_name.host = pj_str("::0");
tp->base.remote_name.port = 0;
/* Init direction */
tp->base.dir = PJSIP_TP_DIR_NONE;
/* Set endpoint. */
tp->base.endpt = endpt;
/* Transport manager and timer will be initialized by tpmgr */
/* Attach socket and assign name. */
udp_set_socket(tp, sock, a_name);
/* Register to ioqueue */
status = register_to_ioqueue(tp);
if (status != PJ_SUCCESS)
goto on_error;
/* Set functions. */
tp->base.send_msg = &udp_send_msg;
tp->base.do_shutdown = &udp_shutdown;
tp->base.destroy = &udp_destroy;
/* This is a permanent transport, so we initialize the ref count
* to one so that transport manager don't destroy this transport
* when there's no user!
*/
pj_atomic_inc(tp->base.ref_cnt);
/* Register to transport manager. */
tp->base.tpmgr = pjsip_endpt_get_tpmgr(endpt);
status = pjsip_transport_register( tp->base.tpmgr, (pjsip_transport*)tp);
if (status != PJ_SUCCESS)
goto on_error;
/* Create rdata and put it in the array. */
tp->rdata_cnt = 0;
tp->rdata = (pjsip_rx_data**)
pj_pool_calloc(tp->base.pool, async_cnt,
sizeof(pjsip_rx_data*));
for (i=0; i<async_cnt; ++i) {
pj_pool_t *rdata_pool = pjsip_endpt_create_pool(endpt, "rtd%p",
PJSIP_POOL_RDATA_LEN,
PJSIP_POOL_RDATA_INC);
if (!rdata_pool) {
pj_atomic_set(tp->base.ref_cnt, 0);
pjsip_transport_destroy(&tp->base);
return PJ_ENOMEM;
}
init_rdata(tp, i, rdata_pool, NULL);
tp->rdata_cnt++;
}
/* Start reading the ioqueue. */
status = start_async_read(tp);
if (status != PJ_SUCCESS) {
pjsip_transport_destroy(&tp->base);
return status;
}
/* Done. */
if (p_transport)
*p_transport = &tp->base;
PJ_LOG(4,(tp->base.obj_name,
"SIP %s started, published address is %s%.*s%s:%d",
pjsip_transport_get_type_desc((pjsip_transport_type_e)tp->base.key.type),
ipv6_quoteb,
(int)tp->base.local_name.host.slen,
tp->base.local_name.host.ptr,
ipv6_quotee,
tp->base.local_name.port));
return PJ_SUCCESS;
on_error:
udp_destroy((pjsip_transport*)tp);
return status;
}
IpAddr
ip_utils::getInterfaceAddr(const std::string &interface, pj_uint16_t family)
{
if (interface == DEFAULT_INTERFACE)
return getLocalAddr(family);
IpAddr addr {};
#ifndef _WIN32
const auto unix_family = family == pj_AF_INET() ? AF_INET : AF_INET6;
int fd = socket(unix_family, SOCK_DGRAM, 0);
if (fd < 0) {
RING_ERR("Could not open socket: %m");
return addr;
}
if (unix_family == AF_INET6) {
int val = family != pj_AF_UNSPEC();
if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, (void *) &val, sizeof(val)) < 0) {
RING_ERR("Could not setsockopt: %m");
close(fd);
return addr;
}
}
ifreq ifr;
strncpy(ifr.ifr_name, interface.c_str(), sizeof ifr.ifr_name);
// guarantee that ifr_name is NULL-terminated
ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
memset(&ifr.ifr_addr, 0, sizeof(ifr.ifr_addr));
ifr.ifr_addr.sa_family = unix_family;
ioctl(fd, SIOCGIFADDR, &ifr);
close(fd);
addr = ifr.ifr_addr;
if (addr.isUnspecified())
return getLocalAddr(addr.getFamily());
#else // _WIN32
struct addrinfo hints;
struct addrinfo *result = NULL;
struct sockaddr_in *sockaddr_ipv4;
struct sockaddr_in6 *sockaddr_ipv6;
ZeroMemory(&hints, sizeof(hints));
DWORD dwRetval = getaddrinfo(interface.c_str(), "0", &hints, &result);
if (dwRetval != 0) {
RING_ERR("getaddrinfo failed with error: %lu", dwRetval);
return addr;
}
switch (result->ai_family) {
sockaddr_ipv4 = (struct sockaddr_in *) result->ai_addr;
addr = sockaddr_ipv4->sin_addr;
break;
case AF_INET6:
sockaddr_ipv6 = (struct sockaddr_in6 *) result->ai_addr;
addr = sockaddr_ipv6->sin6_addr;
break;
default:
break;
}
if (addr.isUnspecified())
return getLocalAddr(addr.getFamily());
#endif // !_WIN32
return addr;
}
/*
* This is the public API to create, initialize, register, and start the
* TLS listener.
*/
PJ_DEF(pj_status_t) pjsip_tls_transport_start (pjsip_endpoint *endpt,
const pjsip_tls_setting *opt,
const pj_sockaddr_in *local,
const pjsip_host_port *a_name,
unsigned async_cnt,
pjsip_tpfactory **p_factory)
{
pj_pool_t *pool;
struct tls_listener *listener;
pj_ssl_sock_param ssock_param;
pj_sockaddr_in *listener_addr;
pj_bool_t has_listener;
pj_status_t status;
/* Sanity check */
PJ_ASSERT_RETURN(endpt && async_cnt, PJ_EINVAL);
/* Verify that address given in a_name (if any) is valid */
if (a_name && a_name->host.slen) {
pj_sockaddr_in tmp;
status = pj_sockaddr_in_init(&tmp, &a_name->host,
(pj_uint16_t)a_name->port);
if (status != PJ_SUCCESS || tmp.sin_addr.s_addr == PJ_INADDR_ANY ||
tmp.sin_addr.s_addr == PJ_INADDR_NONE)
{
/* Invalid address */
return PJ_EINVAL;
}
}
pool = pjsip_endpt_create_pool(endpt, "tlslis", POOL_LIS_INIT,
POOL_LIS_INC);
PJ_ASSERT_RETURN(pool, PJ_ENOMEM);
listener = PJ_POOL_ZALLOC_T(pool, struct tls_listener);
listener->factory.pool = pool;
listener->factory.type = PJSIP_TRANSPORT_TLS;
listener->factory.type_name = "tls";
listener->factory.flag =
pjsip_transport_get_flag_from_type(PJSIP_TRANSPORT_TLS);
pj_ansi_strcpy(listener->factory.obj_name, "tlslis");
if (opt)
pjsip_tls_setting_copy(pool, &listener->tls_setting, opt);
else
pjsip_tls_setting_default(&listener->tls_setting);
status = pj_lock_create_recursive_mutex(pool, "tlslis",
&listener->factory.lock);
if (status != PJ_SUCCESS)
goto on_error;
if (async_cnt > MAX_ASYNC_CNT)
async_cnt = MAX_ASYNC_CNT;
/* Build SSL socket param */
pj_ssl_sock_param_default(&ssock_param);
ssock_param.cb.on_accept_complete = &on_accept_complete;
ssock_param.cb.on_data_read = &on_data_read;
ssock_param.cb.on_data_sent = &on_data_sent;
ssock_param.async_cnt = async_cnt;
ssock_param.ioqueue = pjsip_endpt_get_ioqueue(endpt);
ssock_param.require_client_cert = listener->tls_setting.require_client_cert;
ssock_param.timeout = listener->tls_setting.timeout;
ssock_param.user_data = listener;
ssock_param.verify_peer = PJ_FALSE; /* avoid SSL socket closing the socket
* due to verification error */
if (ssock_param.send_buffer_size < PJSIP_MAX_PKT_LEN)
ssock_param.send_buffer_size = PJSIP_MAX_PKT_LEN;
if (ssock_param.read_buffer_size < PJSIP_MAX_PKT_LEN)
ssock_param.read_buffer_size = PJSIP_MAX_PKT_LEN;
ssock_param.ciphers_num = listener->tls_setting.ciphers_num;
ssock_param.ciphers = listener->tls_setting.ciphers;
ssock_param.qos_type = listener->tls_setting.qos_type;
ssock_param.qos_ignore_error = listener->tls_setting.qos_ignore_error;
pj_memcpy(&ssock_param.qos_params, &listener->tls_setting.qos_params,
sizeof(ssock_param.qos_params));
has_listener = PJ_FALSE;
switch(listener->tls_setting.method) {
case PJSIP_TLSV1_METHOD:
ssock_param.proto = PJ_SSL_SOCK_PROTO_TLS1;
break;
case PJSIP_SSLV2_METHOD:
ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL2;
break;
case PJSIP_SSLV3_METHOD:
ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL3;
break;
case PJSIP_SSLV23_METHOD:
ssock_param.proto = PJ_SSL_SOCK_PROTO_SSL23;
break;
default:
ssock_param.proto = PJ_SSL_SOCK_PROTO_DEFAULT;
break;
}
/* Create SSL socket */
status = pj_ssl_sock_create(pool, &ssock_param, &listener->ssock);
if (status != PJ_SUCCESS)
goto on_error;
listener_addr = (pj_sockaddr_in*)&listener->factory.local_addr;
if (local) {
pj_sockaddr_cp((pj_sockaddr_t*)listener_addr,
(const pj_sockaddr_t*)local);
} else {
pj_sockaddr_in_init(listener_addr, NULL, 0);
}
/* Check if certificate/CA list for SSL socket is set */
if (listener->tls_setting.cert_file.slen ||
listener->tls_setting.ca_list_file.slen)
{
status = pj_ssl_cert_load_from_files(pool,
&listener->tls_setting.ca_list_file,
&listener->tls_setting.cert_file,
&listener->tls_setting.privkey_file,
&listener->tls_setting.password,
&listener->cert);
if (status != PJ_SUCCESS)
goto on_error;
status = pj_ssl_sock_set_certificate(listener->ssock, pool,
listener->cert);
if (status != PJ_SUCCESS)
goto on_error;
}
/* Start accepting incoming connections. Note that some TLS/SSL backends
* may not support for SSL socket server.
*/
has_listener = PJ_FALSE;
status = pj_ssl_sock_start_accept(listener->ssock, pool,
(pj_sockaddr_t*)listener_addr,
pj_sockaddr_get_len((pj_sockaddr_t*)listener_addr));
if (status == PJ_SUCCESS || status == PJ_EPENDING) {
pj_ssl_sock_info info;
has_listener = PJ_TRUE;
/* Retrieve the bound address */
status = pj_ssl_sock_get_info(listener->ssock, &info);
if (status == PJ_SUCCESS)
pj_sockaddr_cp(listener_addr, (pj_sockaddr_t*)&info.local_addr);
} else if (status != PJ_ENOTSUP) {
goto on_error;
}
/* If published host/IP is specified, then use that address as the
* listener advertised address.
*/
if (a_name && a_name->host.slen) {
/* Copy the address */
listener->factory.addr_name = *a_name;
pj_strdup(listener->factory.pool, &listener->factory.addr_name.host,
&a_name->host);
listener->factory.addr_name.port = a_name->port;
} else {
/* No published address is given, use the bound address */
/* If the address returns 0.0.0.0, use the default
* interface address as the transport's address.
*/
if (listener_addr->sin_addr.s_addr == 0) {
pj_sockaddr hostip;
status = pj_gethostip(pj_AF_INET(), &hostip);
if (status != PJ_SUCCESS)
goto on_error;
listener_addr->sin_addr.s_addr = hostip.ipv4.sin_addr.s_addr;
}
/* Save the address name */
sockaddr_to_host_port(listener->factory.pool,
&listener->factory.addr_name, listener_addr);
}
/* If port is zero, get the bound port */
if (listener->factory.addr_name.port == 0) {
listener->factory.addr_name.port = pj_ntohs(listener_addr->sin_port);
}
pj_ansi_snprintf(listener->factory.obj_name,
sizeof(listener->factory.obj_name),
"tlslis:%d", listener->factory.addr_name.port);
/* Register to transport manager */
listener->endpt = endpt;
listener->tpmgr = pjsip_endpt_get_tpmgr(endpt);
listener->factory.create_transport2 = lis_create_transport;
listener->factory.destroy = lis_destroy;
listener->is_registered = PJ_TRUE;
status = pjsip_tpmgr_register_tpfactory(listener->tpmgr,
&listener->factory);
if (status != PJ_SUCCESS) {
listener->is_registered = PJ_FALSE;
goto on_error;
}
if (has_listener) {
PJ_LOG(4,(listener->factory.obj_name,
"SIP TLS listener is ready for incoming connections "
"at %.*s:%d",
(int)listener->factory.addr_name.host.slen,
listener->factory.addr_name.host.ptr,
listener->factory.addr_name.port));
} else {
PJ_LOG(4,(listener->factory.obj_name, "SIP TLS is ready "
"(client only)"));
}
/* Return the pointer to user */
if (p_factory) *p_factory = &listener->factory;
return PJ_SUCCESS;
on_error:
lis_destroy(&listener->factory);
return status;
}
/*
* Perform unregistration test.
*
* This will create ioqueue and register a server socket. Depending
* on the test method, either the callback or the main thread will
* unregister and destroy the server socket after some period of time.
*/
static int perform_unreg_test(pj_ioqueue_t *ioqueue,
pj_pool_t *test_pool,
const char *title,
pj_bool_t other_socket)
{
enum { WORKER_CNT = 1, MSEC = 500, QUIT_MSEC = 500 };
int i;
pj_thread_t *thread[WORKER_CNT];
struct sock_data osd;
pj_ioqueue_callback callback;
pj_time_val end_time;
pj_status_t status;
/* Sometimes its important to have other sockets registered to
* the ioqueue, because when no sockets are registered, the ioqueue
* will return from the poll early.
*/
if (other_socket) {
status = app_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, 56127, &osd.sock);
if (status != PJ_SUCCESS) {
app_perror("Error creating other socket", status);
return -12;
}
pj_bzero(&callback, sizeof(callback));
status = pj_ioqueue_register_sock(test_pool, ioqueue, osd.sock,
NULL, &callback, &osd.key);
if (status != PJ_SUCCESS) {
app_perror("Error registering other socket", status);
return -13;
}
} else {
osd.key = NULL;
osd.sock = PJ_INVALID_SOCKET;
}
/* Init both time duration of testing */
thread_quitting = 0;
pj_gettimeofday(&time_to_unregister);
time_to_unregister.msec += MSEC;
pj_time_val_normalize(&time_to_unregister);
end_time = time_to_unregister;
end_time.msec += QUIT_MSEC;
pj_time_val_normalize(&end_time);
/* Create polling thread */
for (i=0; i<WORKER_CNT; ++i) {
status = pj_thread_create(test_pool, "unregtest", &worker_thread,
ioqueue, 0, 0, &thread[i]);
if (status != PJ_SUCCESS) {
app_perror("Error creating thread", status);
return -20;
}
}
/* Create pair of client/server sockets */
status = app_socketpair(pj_AF_INET(), pj_SOCK_DGRAM(), 0,
&sock_data.sock, &sock_data.csock);
if (status != PJ_SUCCESS) {
app_perror("app_socketpair error", status);
return -30;
}
/* Initialize test data */
sock_data.pool = pj_pool_create(mem, "sd", 1000, 1000, NULL);
sock_data.buffer = (char*) pj_pool_alloc(sock_data.pool, 128);
sock_data.bufsize = 128;
sock_data.op_key = (pj_ioqueue_op_key_t*)
pj_pool_alloc(sock_data.pool,
sizeof(*sock_data.op_key));
sock_data.received = 0;
sock_data.unregistered = 0;
pj_ioqueue_op_key_init(sock_data.op_key, sizeof(*sock_data.op_key));
status = pj_mutex_create_simple(sock_data.pool, "sd", &sock_data.mutex);
if (status != PJ_SUCCESS) {
app_perror("create_mutex() error", status);
return -35;
}
/* Register socket to ioqueue */
pj_bzero(&callback, sizeof(callback));
callback.on_read_complete = &on_read_complete;
status = pj_ioqueue_register_sock(sock_data.pool, ioqueue, sock_data.sock,
NULL, &callback, &sock_data.key);
if (status != PJ_SUCCESS) {
app_perror("pj_ioqueue_register error", status);
return -40;
}
/* Bootstrap the first send/receive */
on_read_complete(sock_data.key, sock_data.op_key, 0);
/* Loop until test time ends */
for (;;) {
pj_time_val now, timeout;
pj_gettimeofday(&now);
if (test_method == UNREGISTER_IN_APP &&
PJ_TIME_VAL_GTE(now, time_to_unregister) &&
sock_data.pool)
{
//Can't do this otherwise it'll deadlock
//pj_mutex_lock(sock_data.mutex);
sock_data.unregistered = 1;
pj_ioqueue_unregister(sock_data.key);
//pj_mutex_unlock(sock_data.mutex);
pj_mutex_destroy(sock_data.mutex);
pj_pool_release(sock_data.pool);
sock_data.pool = NULL;
}
if (PJ_TIME_VAL_GT(now, end_time) && sock_data.unregistered)
break;
timeout.sec = 0; timeout.msec = 10;
pj_ioqueue_poll(ioqueue, &timeout);
//pj_thread_sleep(1);
}
thread_quitting = 1;
for (i=0; i<WORKER_CNT; ++i) {
pj_thread_join(thread[i]);
pj_thread_destroy(thread[i]);
}
if (other_socket) {
pj_ioqueue_unregister(osd.key);
}
pj_sock_close(sock_data.csock);
PJ_LOG(3,(THIS_FILE, "....%s: done (%d KB/s)",
title, sock_data.received * 1000 / MSEC / 1000));
return 0;
}
/*
* This is the main function for performing server resolution.
*/
PJ_DEF(void) pjsip_resolve( pjsip_resolver_t *resolver,
pj_pool_t *pool,
const pjsip_host_info *target,
void *token,
pjsip_resolver_callback *cb)
{
pjsip_server_addresses svr_addr;
pj_status_t status = PJ_SUCCESS;
int ip_addr_ver;
struct query *query;
pjsip_transport_type_e type = target->type;
/* Is it IP address or hostname? And if it's an IP, which version? */
ip_addr_ver = get_ip_addr_ver(&target->addr.host);
/* Set the transport type if not explicitly specified.
* RFC 3263 section 4.1 specify rules to set up this.
*/
if (type == PJSIP_TRANSPORT_UNSPECIFIED) {
if (ip_addr_ver || (target->addr.port != 0)) {
#if PJ_HAS_TCP
if (target->flag & PJSIP_TRANSPORT_SECURE)
{
type = PJSIP_TRANSPORT_TLS;
} else if (target->flag & PJSIP_TRANSPORT_RELIABLE)
{
type = PJSIP_TRANSPORT_TCP;
} else
#endif
{
type = PJSIP_TRANSPORT_UDP;
}
} else {
/* No type or explicit port is specified, and the address is
* not IP address.
* In this case, full NAPTR resolution must be performed.
* But we don't support it (yet).
*/
#if PJ_HAS_TCP
if (target->flag & PJSIP_TRANSPORT_SECURE)
{
type = PJSIP_TRANSPORT_TLS;
} else if (target->flag & PJSIP_TRANSPORT_RELIABLE)
{
type = PJSIP_TRANSPORT_TCP;
} else
#endif
{
type = PJSIP_TRANSPORT_UDP;
}
}
/* Add IPv6 flag for IPv6 address */
if (ip_addr_ver == 6)
type = (pjsip_transport_type_e)((int)type + PJSIP_TRANSPORT_IPV6);
}
/* If target is an IP address, or if resolver is not configured,
* we can just finish the resolution now using pj_gethostbyname()
*/
if (ip_addr_ver || resolver->res == NULL) {
char addr_str[PJ_INET6_ADDRSTRLEN+10];
pj_uint16_t srv_port;
if (ip_addr_ver != 0) {
/* Target is an IP address, no need to resolve */
if (ip_addr_ver == 4) {
pj_sockaddr_init(pj_AF_INET(), &svr_addr.entry[0].addr,
NULL, 0);
pj_inet_aton(&target->addr.host,
&svr_addr.entry[0].addr.ipv4.sin_addr);
} else {
pj_sockaddr_init(pj_AF_INET6(), &svr_addr.entry[0].addr,
NULL, 0);
pj_inet_pton(pj_AF_INET6(), &target->addr.host,
&svr_addr.entry[0].addr.ipv6.sin6_addr);
}
} else {
pj_addrinfo ai;
unsigned count;
int af;
PJ_LOG(5,(THIS_FILE,
"DNS resolver not available, target '%.*s:%d' type=%s "
"will be resolved with getaddrinfo()",
target->addr.host.slen,
target->addr.host.ptr,
target->addr.port,
pjsip_transport_get_type_name(target->type)));
if (type & PJSIP_TRANSPORT_IPV6) {
af = pj_AF_INET6();
} else {
af = pj_AF_INET();
}
/* Resolve */
count = 1;
status = pj_getaddrinfo(af, &target->addr.host, &count, &ai);
if (status != PJ_SUCCESS) {
/* "Normalize" error to PJ_ERESOLVE. This is a special error
* because it will be translated to SIP status 502 by
* sip_transaction.c
*/
status = PJ_ERESOLVE;
goto on_error;
}
svr_addr.entry[0].addr.addr.sa_family = (pj_uint16_t)af;
pj_memcpy(&svr_addr.entry[0].addr, &ai.ai_addr,
sizeof(pj_sockaddr));
}
/* Set the port number */
if (target->addr.port == 0) {
srv_port = (pj_uint16_t)
pjsip_transport_get_default_port_for_type(type);
} else {
srv_port = (pj_uint16_t)target->addr.port;
}
pj_sockaddr_set_port(&svr_addr.entry[0].addr, srv_port);
/* Call the callback. */
PJ_LOG(5,(THIS_FILE,
"Target '%.*s:%d' type=%s resolved to "
"'%s' type=%s (%s)",
(int)target->addr.host.slen,
target->addr.host.ptr,
target->addr.port,
pjsip_transport_get_type_name(target->type),
pj_sockaddr_print(&svr_addr.entry[0].addr, addr_str,
sizeof(addr_str), 3),
pjsip_transport_get_type_name(type),
pjsip_transport_get_type_desc(type)));
svr_addr.count = 1;
svr_addr.entry[0].priority = 0;
svr_addr.entry[0].weight = 0;
svr_addr.entry[0].type = type;
svr_addr.entry[0].addr_len = pj_sockaddr_get_len(&svr_addr.entry[0].addr);
(*cb)(status, token, &svr_addr, target->addr.port);
/* Done. */
return;
}
/* Target is not an IP address so we need to resolve it. */
#if PJSIP_HAS_RESOLVER
/* Build the query state */
query = PJ_POOL_ZALLOC_T(pool, struct query);
query->objname = THIS_FILE;
query->token = token;
query->cb = cb;
query->req.target = *target;
pj_strdup(pool, &query->req.target.addr.host, &target->addr.host);
/* If port is not specified, start with SRV resolution
* (should be with NAPTR, but we'll do that later)
*/
PJ_TODO(SUPPORT_DNS_NAPTR);
/* Build dummy NAPTR entry */
query->naptr_cnt = 1;
pj_bzero(&query->naptr[0], sizeof(query->naptr[0]));
query->naptr[0].order = 0;
query->naptr[0].pref = 0;
query->naptr[0].type = type;
pj_strdup(pool, &query->naptr[0].name, &target->addr.host);
/* Start DNS SRV or A resolution, depending on whether port is specified */
if (target->addr.port == 0) {
query->query_type = PJ_DNS_TYPE_SRV;
query->req.def_port = 5060;
if (type == PJSIP_TRANSPORT_TLS) {
query->naptr[0].res_type = pj_str("_sips._tcp.");
query->req.def_port = 5061;
} else if (type == PJSIP_TRANSPORT_TCP)
query->naptr[0].res_type = pj_str("_sip._tcp.");
else if (type == PJSIP_TRANSPORT_UDP)
query->naptr[0].res_type = pj_str("_sip._udp.");
else {
pj_assert(!"Unknown transport type");
query->naptr[0].res_type = pj_str("_sip._udp.");
}
} else {
/* Otherwise if port is specified, start with A (or AAAA) host
* resolution
*/
query->query_type = PJ_DNS_TYPE_A;
query->naptr[0].res_type.slen = 0;
query->req.def_port = target->addr.port;
}
/* Start the asynchronous query */
PJ_LOG(5, (query->objname,
"Starting async DNS %s query: target=%.*s%.*s, transport=%s, "
"port=%d",
pj_dns_get_type_name(query->query_type),
(int)query->naptr[0].res_type.slen,
query->naptr[0].res_type.ptr,
(int)query->naptr[0].name.slen, query->naptr[0].name.ptr,
pjsip_transport_get_type_name(target->type),
target->addr.port));
if (query->query_type == PJ_DNS_TYPE_SRV) {
status = pj_dns_srv_resolve(&query->naptr[0].name,
&query->naptr[0].res_type,
query->req.def_port, pool, resolver->res,
PJ_TRUE, query, &srv_resolver_cb, NULL);
} else if (query->query_type == PJ_DNS_TYPE_A) {
status = pj_dns_resolver_start_query(resolver->res,
&query->naptr[0].name,
PJ_DNS_TYPE_A, 0,
&dns_a_callback,
query, &query->object);
} else {
pj_assert(!"Unexpected");
status = PJ_EBUG;
}
if (status != PJ_SUCCESS)
goto on_error;
return;
#else /* PJSIP_HAS_RESOLVER */
PJ_UNUSED_ARG(pool);
PJ_UNUSED_ARG(query);
PJ_UNUSED_ARG(srv_name);
#endif /* PJSIP_HAS_RESOLVER */
on_error:
if (status != PJ_SUCCESS) {
char errmsg[PJ_ERR_MSG_SIZE];
PJ_LOG(4,(THIS_FILE, "Failed to resolve '%.*s'. Err=%d (%s)",
(int)target->addr.host.slen,
target->addr.host.ptr,
status,
pj_strerror(status,errmsg,sizeof(errmsg)).ptr));
(*cb)(status, token, NULL, target->addr.port);
return;
}
}
/*
* Compliance test for success scenario.
*/
static int compliance_test_0(pj_bool_t allow_concur)
{
pj_sock_t ssock=-1, csock0=-1, csock1=-1;
pj_sockaddr_in addr, client_addr, rmt_addr;
int client_addr_len;
pj_pool_t *pool = NULL;
char *send_buf, *recv_buf;
pj_ioqueue_t *ioque = NULL;
pj_ioqueue_key_t *skey=NULL, *ckey0=NULL, *ckey1=NULL;
pj_ioqueue_op_key_t accept_op;
int bufsize = BUF_MIN_SIZE;
int status = -1;
int pending_op = 0;
pj_timestamp t_elapsed;
pj_str_t s;
pj_status_t rc;
// Create pool.
pool = pj_pool_create(mem, NULL, POOL_SIZE, 4000, NULL);
// Allocate buffers for send and receive.
send_buf = (char*)pj_pool_alloc(pool, bufsize);
recv_buf = (char*)pj_pool_alloc(pool, bufsize);
// Create server socket and client socket for connecting
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_STREAM(), 0, &ssock);
if (rc != PJ_SUCCESS) {
app_perror("...error creating socket", rc);
status=-1; goto on_error;
}
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_STREAM(), 0, &csock1);
if (rc != PJ_SUCCESS) {
app_perror("...error creating socket", rc);
status=-1; goto on_error;
}
// Bind server socket.
pj_sockaddr_in_init(&addr, 0, 0);
if ((rc=pj_sock_bind(ssock, &addr, sizeof(addr))) != 0 ) {
app_perror("...bind error", rc);
status=-10; goto on_error;
}
// Get server address.
client_addr_len = sizeof(addr);
rc = pj_sock_getsockname(ssock, &addr, &client_addr_len);
if (rc != PJ_SUCCESS) {
app_perror("...ERROR in pj_sock_getsockname()", rc);
status=-15; goto on_error;
}
addr.sin_addr = pj_inet_addr(pj_cstr(&s, "127.0.0.1"));
// Create I/O Queue.
rc = pj_ioqueue_create(pool, PJ_IOQUEUE_MAX_HANDLES, &ioque);
if (rc != PJ_SUCCESS) {
app_perror("...ERROR in pj_ioqueue_create()", rc);
status=-20; goto on_error;
}
// Concurrency
rc = pj_ioqueue_set_default_concurrency(ioque, allow_concur);
if (rc != PJ_SUCCESS) {
app_perror("...ERROR in pj_ioqueue_set_default_concurrency()", rc);
status=-21; goto on_error;
}
// Register server socket and client socket.
rc = pj_ioqueue_register_sock(pool, ioque, ssock, NULL, &test_cb, &skey);
if (rc == PJ_SUCCESS)
rc = pj_ioqueue_register_sock(pool, ioque, csock1, NULL, &test_cb,
&ckey1);
else
ckey1 = NULL;
if (rc != PJ_SUCCESS) {
app_perror("...ERROR in pj_ioqueue_register_sock()", rc);
status=-23; goto on_error;
}
// Server socket listen().
if (pj_sock_listen(ssock, 5)) {
app_perror("...ERROR in pj_sock_listen()", rc);
status=-25; goto on_error;
}
// Server socket accept()
client_addr_len = sizeof(pj_sockaddr_in);
status = pj_ioqueue_accept(skey, &accept_op, &csock0,
&client_addr, &rmt_addr, &client_addr_len);
if (status != PJ_EPENDING) {
app_perror("...ERROR in pj_ioqueue_accept()", rc);
status=-30; goto on_error;
}
if (status==PJ_EPENDING) {
++pending_op;
}
// Client socket connect()
status = pj_ioqueue_connect(ckey1, &addr, sizeof(addr));
if (status!=PJ_SUCCESS && status != PJ_EPENDING) {
app_perror("...ERROR in pj_ioqueue_connect()", rc);
status=-40; goto on_error;
}
if (status==PJ_EPENDING) {
++pending_op;
}
// Poll until connected
callback_read_size = callback_write_size = 0;
callback_accept_status = callback_connect_status = -2;
callback_call_count = 0;
callback_read_key = callback_write_key =
callback_accept_key = callback_connect_key = NULL;
callback_accept_op = callback_read_op = callback_write_op = NULL;
while (pending_op) {
pj_time_val timeout = {1, 0};
#ifdef PJ_SYMBIAN
callback_call_count = 0;
pj_symbianos_poll(-1, PJ_TIME_VAL_MSEC(timeout));
status = callback_call_count;
#else
status = pj_ioqueue_poll(ioque, &timeout);
#endif
if (status > 0) {
if (callback_accept_status != -2) {
if (callback_accept_status != 0) {
status=-41; goto on_error;
}
if (callback_accept_key != skey) {
status=-42; goto on_error;
}
if (callback_accept_op != &accept_op) {
status=-43; goto on_error;
}
callback_accept_status = -2;
}
if (callback_connect_status != -2) {
if (callback_connect_status != 0) {
status=-50; goto on_error;
}
if (callback_connect_key != ckey1) {
status=-51; goto on_error;
}
callback_connect_status = -2;
}
if (status > pending_op) {
PJ_LOG(3,(THIS_FILE,
"...error: pj_ioqueue_poll() returned %d "
"(only expecting %d)",
status, pending_op));
return -52;
}
pending_op -= status;
if (pending_op == 0) {
status = 0;
}
}
}
// There's no pending operation.
// When we poll the ioqueue, there must not be events.
if (pending_op == 0) {
pj_time_val timeout = {1, 0};
#ifdef PJ_SYMBIAN
status = pj_symbianos_poll(-1, PJ_TIME_VAL_MSEC(timeout));
#else
status = pj_ioqueue_poll(ioque, &timeout);
#endif
if (status != 0) {
status=-60; goto on_error;
}
}
// Check accepted socket.
if (csock0 == PJ_INVALID_SOCKET) {
status = -69;
app_perror("...accept() error", pj_get_os_error());
goto on_error;
}
// Register newly accepted socket.
rc = pj_ioqueue_register_sock(pool, ioque, csock0, NULL,
&test_cb, &ckey0);
if (rc != PJ_SUCCESS) {
app_perror("...ERROR in pj_ioqueue_register_sock", rc);
status = -70;
goto on_error;
}
// Test send and receive.
t_elapsed.u32.lo = 0;
status = send_recv_test(ioque, ckey0, ckey1, send_buf,
recv_buf, bufsize, &t_elapsed);
if (status != 0) {
goto on_error;
}
// Success
status = 0;
on_error:
if (skey != NULL)
pj_ioqueue_unregister(skey);
else if (ssock != PJ_INVALID_SOCKET)
pj_sock_close(ssock);
if (ckey1 != NULL)
pj_ioqueue_unregister(ckey1);
else if (csock1 != PJ_INVALID_SOCKET)
pj_sock_close(csock1);
if (ckey0 != NULL)
pj_ioqueue_unregister(ckey0);
else if (csock0 != PJ_INVALID_SOCKET)
pj_sock_close(csock0);
if (ioque != NULL)
pj_ioqueue_destroy(ioque);
pj_pool_release(pool);
return status;
}
/*
* compliance_test()
* To test that the basic IOQueue functionality works. It will just exchange
* data between two sockets.
*/
static int compliance_test(pj_bool_t allow_concur)
{
pj_sock_t ssock=-1, csock=-1;
pj_sockaddr_in addr, dst_addr;
int addrlen;
pj_pool_t *pool = NULL;
char *send_buf, *recv_buf;
pj_ioqueue_t *ioque = NULL;
pj_ioqueue_key_t *skey = NULL, *ckey = NULL;
pj_ioqueue_op_key_t read_op, write_op;
int bufsize = BUF_MIN_SIZE;
pj_ssize_t bytes, status = -1;
pj_str_t temp;
pj_bool_t send_pending, recv_pending;
pj_status_t rc;
pj_set_os_error(PJ_SUCCESS);
// Create pool.
pool = pj_pool_create(mem, NULL, POOL_SIZE, 4000, NULL);
// Allocate buffers for send and receive.
send_buf = (char*)pj_pool_alloc(pool, bufsize);
recv_buf = (char*)pj_pool_alloc(pool, bufsize);
// Allocate sockets for sending and receiving.
TRACE_("creating sockets...");
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &ssock);
if (rc==PJ_SUCCESS)
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &csock);
else
csock = PJ_INVALID_SOCKET;
if (rc != PJ_SUCCESS) {
app_perror("...ERROR in pj_sock_socket()", rc);
status=-1; goto on_error;
}
// Bind server socket.
TRACE_("bind socket...");
pj_bzero(&addr, sizeof(addr));
addr.sin_family = pj_AF_INET();
addr.sin_port = pj_htons(PORT);
if (pj_sock_bind(ssock, &addr, sizeof(addr))) {
status=-10; goto on_error;
}
// Create I/O Queue.
TRACE_("create ioqueue...");
rc = pj_ioqueue_create(pool, PJ_IOQUEUE_MAX_HANDLES, &ioque);
if (rc != PJ_SUCCESS) {
status=-20; goto on_error;
}
// Set concurrency
TRACE_("set concurrency...");
rc = pj_ioqueue_set_default_concurrency(ioque, allow_concur);
if (rc != PJ_SUCCESS) {
status=-21; goto on_error;
}
// Register server and client socket.
// We put this after inactivity socket, hopefully this can represent the
// worst waiting time.
TRACE_("registering first sockets...");
rc = pj_ioqueue_register_sock(pool, ioque, ssock, NULL,
&test_cb, &skey);
if (rc != PJ_SUCCESS) {
app_perror("...error(10): ioqueue_register error", rc);
status=-25; goto on_error;
}
TRACE_("registering second sockets...");
rc = pj_ioqueue_register_sock( pool, ioque, csock, NULL,
&test_cb, &ckey);
if (rc != PJ_SUCCESS) {
app_perror("...error(11): ioqueue_register error", rc);
status=-26; goto on_error;
}
// Randomize send_buf.
pj_create_random_string(send_buf, bufsize);
// Register reading from ioqueue.
TRACE_("start recvfrom...");
pj_bzero(&addr, sizeof(addr));
addrlen = sizeof(addr);
bytes = bufsize;
rc = pj_ioqueue_recvfrom(skey, &read_op, recv_buf, &bytes, 0,
&addr, &addrlen);
if (rc != PJ_SUCCESS && rc != PJ_EPENDING) {
app_perror("...error: pj_ioqueue_recvfrom", rc);
status=-28; goto on_error;
} else if (rc == PJ_EPENDING) {
recv_pending = 1;
PJ_LOG(3, (THIS_FILE,
"......ok: recvfrom returned pending"));
} else {
PJ_LOG(3, (THIS_FILE,
"......error: recvfrom returned immediate ok!"));
status=-29; goto on_error;
}
// Set destination address to send the packet.
TRACE_("set destination address...");
temp = pj_str("127.0.0.1");
if ((rc=pj_sockaddr_in_init(&dst_addr, &temp, PORT)) != 0) {
app_perror("...error: unable to resolve 127.0.0.1", rc);
status=-290; goto on_error;
}
// Write must return the number of bytes.
TRACE_("start sendto...");
bytes = bufsize;
rc = pj_ioqueue_sendto(ckey, &write_op, send_buf, &bytes, 0, &dst_addr,
sizeof(dst_addr));
if (rc != PJ_SUCCESS && rc != PJ_EPENDING) {
app_perror("...error: pj_ioqueue_sendto", rc);
status=-30; goto on_error;
} else if (rc == PJ_EPENDING) {
send_pending = 1;
PJ_LOG(3, (THIS_FILE,
"......ok: sendto returned pending"));
} else {
send_pending = 0;
PJ_LOG(3, (THIS_FILE,
"......ok: sendto returned immediate success"));
}
// reset callback variables.
callback_read_size = callback_write_size = 0;
callback_accept_status = callback_connect_status = -2;
callback_read_key = callback_write_key =
callback_accept_key = callback_connect_key = NULL;
callback_read_op = callback_write_op = NULL;
// Poll if pending.
while (send_pending || recv_pending) {
int rc;
pj_time_val timeout = { 5, 0 };
TRACE_("poll...");
#ifdef PJ_SYMBIAN
rc = pj_symbianos_poll(-1, PJ_TIME_VAL_MSEC(timeout));
#else
rc = pj_ioqueue_poll(ioque, &timeout);
#endif
if (rc == 0) {
PJ_LOG(1,(THIS_FILE, "...ERROR: timed out..."));
status=-45; goto on_error;
} else if (rc < 0) {
app_perror("...ERROR in ioqueue_poll()", -rc);
status=-50; goto on_error;
}
if (callback_read_key != NULL) {
if (callback_read_size != bufsize) {
status=-61; goto on_error;
}
if (callback_read_key != skey) {
status=-65; goto on_error;
}
if (callback_read_op != &read_op) {
status=-66; goto on_error;
}
if (pj_memcmp(send_buf, recv_buf, bufsize) != 0) {
status=-67; goto on_error;
}
if (addrlen != sizeof(pj_sockaddr_in)) {
status=-68; goto on_error;
}
if (addr.sin_family != pj_AF_INET()) {
status=-69; goto on_error;
}
recv_pending = 0;
}
if (callback_write_key != NULL) {
if (callback_write_size != bufsize) {
status=-73; goto on_error;
}
if (callback_write_key != ckey) {
status=-75; goto on_error;
}
if (callback_write_op != &write_op) {
status=-76; goto on_error;
}
send_pending = 0;
}
}
// Success
status = 0;
on_error:
if (skey)
pj_ioqueue_unregister(skey);
else if (ssock != -1)
pj_sock_close(ssock);
if (ckey)
pj_ioqueue_unregister(ckey);
else if (csock != -1)
pj_sock_close(csock);
if (ioque != NULL)
pj_ioqueue_destroy(ioque);
pj_pool_release(pool);
return status;
}
/*
* Compliance test for failed scenario.
* In this case, the client connects to a non-existant service.
*/
static int compliance_test_1(pj_bool_t allow_concur)
{
pj_sock_t csock1=PJ_INVALID_SOCKET;
pj_sockaddr_in addr;
pj_pool_t *pool = NULL;
pj_ioqueue_t *ioque = NULL;
pj_ioqueue_key_t *ckey1 = NULL;
int status = -1;
int pending_op = 0;
pj_str_t s;
pj_status_t rc;
// Create pool.
pool = pj_pool_create(mem, NULL, POOL_SIZE, 4000, NULL);
// Create I/O Queue.
rc = pj_ioqueue_create(pool, PJ_IOQUEUE_MAX_HANDLES, &ioque);
if (!ioque) {
status=-20; goto on_error;
}
// Concurrency
rc = pj_ioqueue_set_default_concurrency(ioque, allow_concur);
if (rc != PJ_SUCCESS) {
status=-21; goto on_error;
}
// Create client socket
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_STREAM(), 0, &csock1);
if (rc != PJ_SUCCESS) {
app_perror("...ERROR in pj_sock_socket()", rc);
status=-1; goto on_error;
}
// Register client socket.
rc = pj_ioqueue_register_sock(pool, ioque, csock1, NULL,
&test_cb, &ckey1);
if (rc != PJ_SUCCESS) {
app_perror("...ERROR in pj_ioqueue_register_sock()", rc);
status=-23; goto on_error;
}
// Initialize remote address.
pj_sockaddr_in_init(&addr, pj_cstr(&s, "127.0.0.1"), NON_EXISTANT_PORT);
// Client socket connect()
status = pj_ioqueue_connect(ckey1, &addr, sizeof(addr));
if (status==PJ_SUCCESS) {
// unexpectedly success!
status = -30;
goto on_error;
}
if (status != PJ_EPENDING) {
// success
} else {
++pending_op;
}
callback_connect_status = -2;
callback_connect_key = NULL;
// Poll until we've got result
while (pending_op) {
pj_time_val timeout = {1, 0};
#ifdef PJ_SYMBIAN
callback_call_count = 0;
pj_symbianos_poll(-1, PJ_TIME_VAL_MSEC(timeout));
status = callback_call_count;
#else
status = pj_ioqueue_poll(ioque, &timeout);
#endif
if (status > 0) {
if (callback_connect_key==ckey1) {
if (callback_connect_status == 0) {
// unexpectedly connected!
status = -50;
goto on_error;
}
}
if (status > pending_op) {
PJ_LOG(3,(THIS_FILE,
"...error: pj_ioqueue_poll() returned %d "
"(only expecting %d)",
status, pending_op));
return -552;
}
pending_op -= status;
if (pending_op == 0) {
status = 0;
}
}
}
// There's no pending operation.
// When we poll the ioqueue, there must not be events.
if (pending_op == 0) {
pj_time_val timeout = {1, 0};
#ifdef PJ_SYMBIAN
status = pj_symbianos_poll(-1, PJ_TIME_VAL_MSEC(timeout));
#else
status = pj_ioqueue_poll(ioque, &timeout);
#endif
if (status != 0) {
status=-60; goto on_error;
}
}
// Success
status = 0;
on_error:
if (ckey1 != NULL)
pj_ioqueue_unregister(ckey1);
else if (csock1 != PJ_INVALID_SOCKET)
pj_sock_close(csock1);
if (ioque != NULL)
pj_ioqueue_destroy(ioque);
pj_pool_release(pool);
return status;
}
/*
* Testing with many handles.
* This will just test registering PJ_IOQUEUE_MAX_HANDLES count
* of sockets to the ioqueue.
*/
static int many_handles_test(pj_bool_t allow_concur)
{
enum { MAX = PJ_IOQUEUE_MAX_HANDLES };
pj_pool_t *pool;
pj_ioqueue_t *ioqueue;
pj_sock_t *sock;
pj_ioqueue_key_t **key;
pj_status_t rc;
int count, i; /* must be signed */
PJ_LOG(3,(THIS_FILE,"...testing with so many handles"));
pool = pj_pool_create(mem, NULL, 4000, 4000, NULL);
if (!pool)
return PJ_ENOMEM;
key = (pj_ioqueue_key_t**)
pj_pool_alloc(pool, MAX*sizeof(pj_ioqueue_key_t*));
sock = (pj_sock_t*) pj_pool_alloc(pool, MAX*sizeof(pj_sock_t));
/* Create IOQueue */
rc = pj_ioqueue_create(pool, MAX, &ioqueue);
if (rc != PJ_SUCCESS || ioqueue == NULL) {
app_perror("...error in pj_ioqueue_create", rc);
return -10;
}
// Set concurrency
rc = pj_ioqueue_set_default_concurrency(ioqueue, allow_concur);
if (rc != PJ_SUCCESS) {
return -11;
}
/* Register as many sockets. */
for (count=0; count<MAX; ++count) {
sock[count] = PJ_INVALID_SOCKET;
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &sock[count]);
if (rc != PJ_SUCCESS || sock[count] == PJ_INVALID_SOCKET) {
PJ_LOG(3,(THIS_FILE, "....unable to create %d-th socket, rc=%d",
count, rc));
break;
}
key[count] = NULL;
rc = pj_ioqueue_register_sock(pool, ioqueue, sock[count],
NULL, &test_cb, &key[count]);
if (rc != PJ_SUCCESS || key[count] == NULL) {
PJ_LOG(3,(THIS_FILE, "....unable to register %d-th socket, rc=%d",
count, rc));
return -30;
}
}
/* Test complete. */
/* Now deregister and close all handles. */
/* NOTE for RTEMS:
* It seems that the order of close(sock) is pretty important here.
* If we close the sockets with the same order as when they were created,
* RTEMS doesn't seem to reuse the sockets, thus next socket created
* will have descriptor higher than the last socket created.
* If we close the sockets in the reverse order, then the descriptor will
* get reused.
* This used to cause problem with select ioqueue, since the ioqueue
* always gives FD_SETSIZE for the first select() argument. This ioqueue
* behavior can be changed with setting PJ_SELECT_NEEDS_NFDS macro.
*/
for (i=count-1; i>=0; --i) {
///for (i=0; i<count; ++i) {
rc = pj_ioqueue_unregister(key[i]);
if (rc != PJ_SUCCESS) {
app_perror("...error in pj_ioqueue_unregister", rc);
}
}
rc = pj_ioqueue_destroy(ioqueue);
if (rc != PJ_SUCCESS) {
app_perror("...error in pj_ioqueue_destroy", rc);
}
pj_pool_release(pool);
PJ_LOG(3,(THIS_FILE,"....many_handles_test() ok"));
return 0;
}
/*
* Repeated connect/accept on the same listener socket.
*/
static int compliance_test_2(pj_bool_t allow_concur)
{
#if defined(PJ_SYMBIAN) && PJ_SYMBIAN!=0
enum { MAX_PAIR = 1, TEST_LOOP = 2 };
#else
enum { MAX_PAIR = 4, TEST_LOOP = 2 };
#endif
struct listener
{
pj_sock_t sock;
pj_ioqueue_key_t *key;
pj_sockaddr_in addr;
int addr_len;
} listener;
struct server
{
pj_sock_t sock;
pj_ioqueue_key_t *key;
pj_sockaddr_in local_addr;
pj_sockaddr_in rem_addr;
int rem_addr_len;
pj_ioqueue_op_key_t accept_op;
} server[MAX_PAIR];
struct client
{
pj_sock_t sock;
pj_ioqueue_key_t *key;
} client[MAX_PAIR];
pj_pool_t *pool = NULL;
char *send_buf, *recv_buf;
pj_ioqueue_t *ioque = NULL;
int i, bufsize = BUF_MIN_SIZE;
int status;
int test_loop, pending_op = 0;
pj_timestamp t_elapsed;
pj_str_t s;
pj_status_t rc;
listener.sock = PJ_INVALID_SOCKET;
listener.key = NULL;
for (i=0; i<MAX_PAIR; ++i) {
server[i].sock = PJ_INVALID_SOCKET;
server[i].key = NULL;
}
for (i=0; i<MAX_PAIR; ++i) {
client[i].sock = PJ_INVALID_SOCKET;
client[i].key = NULL;
}
// Create pool.
pool = pj_pool_create(mem, NULL, POOL_SIZE, 4000, NULL);
// Create I/O Queue.
rc = pj_ioqueue_create(pool, PJ_IOQUEUE_MAX_HANDLES, &ioque);
if (rc != PJ_SUCCESS) {
app_perror("...ERROR in pj_ioqueue_create()", rc);
return -10;
}
// Concurrency
rc = pj_ioqueue_set_default_concurrency(ioque, allow_concur);
if (rc != PJ_SUCCESS) {
app_perror("...ERROR in pj_ioqueue_set_default_concurrency()", rc);
return -11;
}
// Allocate buffers for send and receive.
send_buf = (char*)pj_pool_alloc(pool, bufsize);
recv_buf = (char*)pj_pool_alloc(pool, bufsize);
// Create listener socket
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_STREAM(), 0, &listener.sock);
if (rc != PJ_SUCCESS) {
app_perror("...error creating socket", rc);
status=-20; goto on_error;
}
// Bind listener socket.
pj_sockaddr_in_init(&listener.addr, 0, 0);
if ((rc=pj_sock_bind(listener.sock, &listener.addr, sizeof(listener.addr))) != 0 ) {
app_perror("...bind error", rc);
status=-30; goto on_error;
}
// Get listener address.
listener.addr_len = sizeof(listener.addr);
rc = pj_sock_getsockname(listener.sock, &listener.addr, &listener.addr_len);
if (rc != PJ_SUCCESS) {
app_perror("...ERROR in pj_sock_getsockname()", rc);
status=-40; goto on_error;
}
listener.addr.sin_addr = pj_inet_addr(pj_cstr(&s, "127.0.0.1"));
// Register listener socket.
rc = pj_ioqueue_register_sock(pool, ioque, listener.sock, NULL, &test_cb,
&listener.key);
if (rc != PJ_SUCCESS) {
app_perror("...ERROR", rc);
status=-50; goto on_error;
}
// Listener socket listen().
if (pj_sock_listen(listener.sock, 5)) {
app_perror("...ERROR in pj_sock_listen()", rc);
status=-60; goto on_error;
}
for (test_loop=0; test_loop < TEST_LOOP; ++test_loop) {
// Client connect and server accept.
for (i=0; i<MAX_PAIR; ++i) {
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_STREAM(), 0, &client[i].sock);
if (rc != PJ_SUCCESS) {
app_perror("...error creating socket", rc);
status=-70; goto on_error;
}
rc = pj_ioqueue_register_sock(pool, ioque, client[i].sock, NULL,
&test_cb, &client[i].key);
if (rc != PJ_SUCCESS) {
app_perror("...error ", rc);
status=-80; goto on_error;
}
// Server socket accept()
pj_ioqueue_op_key_init(&server[i].accept_op,
sizeof(server[i].accept_op));
server[i].rem_addr_len = sizeof(pj_sockaddr_in);
status = pj_ioqueue_accept(listener.key, &server[i].accept_op,
&server[i].sock, &server[i].local_addr,
&server[i].rem_addr,
&server[i].rem_addr_len);
if (status!=PJ_SUCCESS && status != PJ_EPENDING) {
app_perror("...ERROR in pj_ioqueue_accept()", rc);
status=-90; goto on_error;
}
if (status==PJ_EPENDING) {
++pending_op;
}
// Client socket connect()
status = pj_ioqueue_connect(client[i].key, &listener.addr,
sizeof(listener.addr));
if (status!=PJ_SUCCESS && status != PJ_EPENDING) {
app_perror("...ERROR in pj_ioqueue_connect()", rc);
status=-100; goto on_error;
}
if (status==PJ_EPENDING) {
++pending_op;
}
// Poll until connection of this pair established
while (pending_op) {
pj_time_val timeout = {1, 0};
#ifdef PJ_SYMBIAN
status = pj_symbianos_poll(-1, PJ_TIME_VAL_MSEC(timeout));
#else
status = pj_ioqueue_poll(ioque, &timeout);
#endif
if (status > 0) {
if (status > pending_op) {
PJ_LOG(3,(THIS_FILE,
"...error: pj_ioqueue_poll() returned %d "
"(only expecting %d)",
status, pending_op));
return -110;
}
pending_op -= status;
if (pending_op == 0) {
status = 0;
}
}
}
}
// There's no pending operation.
// When we poll the ioqueue, there must not be events.
if (pending_op == 0) {
pj_time_val timeout = {1, 0};
#ifdef PJ_SYMBIAN
status = pj_symbianos_poll(-1, PJ_TIME_VAL_MSEC(timeout));
#else
status = pj_ioqueue_poll(ioque, &timeout);
#endif
if (status != 0) {
status=-120; goto on_error;
}
}
for (i=0; i<MAX_PAIR; ++i) {
// Check server socket.
if (server[i].sock == PJ_INVALID_SOCKET) {
status = -130;
app_perror("...accept() error", pj_get_os_error());
goto on_error;
}
// Check addresses
if (server[i].local_addr.sin_family != pj_AF_INET() ||
server[i].local_addr.sin_addr.s_addr == 0 ||
server[i].local_addr.sin_port == 0)
{
app_perror("...ERROR address not set", rc);
status = -140;
goto on_error;
}
if (server[i].rem_addr.sin_family != pj_AF_INET() ||
server[i].rem_addr.sin_addr.s_addr == 0 ||
server[i].rem_addr.sin_port == 0)
{
app_perror("...ERROR address not set", rc);
status = -150;
goto on_error;
}
// Register newly accepted socket.
rc = pj_ioqueue_register_sock(pool, ioque, server[i].sock, NULL,
&test_cb, &server[i].key);
if (rc != PJ_SUCCESS) {
app_perror("...ERROR in pj_ioqueue_register_sock", rc);
status = -160;
goto on_error;
}
// Test send and receive.
t_elapsed.u32.lo = 0;
status = send_recv_test(ioque, server[i].key, client[i].key,
send_buf, recv_buf, bufsize, &t_elapsed);
if (status != 0) {
goto on_error;
}
}
// Success
status = 0;
for (i=0; i<MAX_PAIR; ++i) {
if (server[i].key != NULL) {
pj_ioqueue_unregister(server[i].key);
server[i].key = NULL;
server[i].sock = PJ_INVALID_SOCKET;
} else if (server[i].sock != PJ_INVALID_SOCKET) {
pj_sock_close(server[i].sock);
server[i].sock = PJ_INVALID_SOCKET;
}
if (client[i].key != NULL) {
pj_ioqueue_unregister(client[i].key);
client[i].key = NULL;
client[i].sock = PJ_INVALID_SOCKET;
} else if (client[i].sock != PJ_INVALID_SOCKET) {
pj_sock_close(client[i].sock);
client[i].sock = PJ_INVALID_SOCKET;
}
}
}
status = 0;
on_error:
for (i=0; i<MAX_PAIR; ++i) {
if (server[i].key != NULL) {
pj_ioqueue_unregister(server[i].key);
server[i].key = NULL;
server[i].sock = PJ_INVALID_SOCKET;
} else if (server[i].sock != PJ_INVALID_SOCKET) {
pj_sock_close(server[i].sock);
server[i].sock = PJ_INVALID_SOCKET;
}
if (client[i].key != NULL) {
pj_ioqueue_unregister(client[i].key);
client[i].key = NULL;
server[i].sock = PJ_INVALID_SOCKET;
} else if (client[i].sock != PJ_INVALID_SOCKET) {
pj_sock_close(client[i].sock);
client[i].sock = PJ_INVALID_SOCKET;
}
}
if (listener.key) {
pj_ioqueue_unregister(listener.key);
listener.key = NULL;
} else if (listener.sock != PJ_INVALID_SOCKET) {
pj_sock_close(listener.sock);
listener.sock = PJ_INVALID_SOCKET;
}
if (ioque != NULL)
pj_ioqueue_destroy(ioque);
pj_pool_release(pool);
return status;
}
static int tcp_perf_test(void)
{
enum { COUNT=100000 };
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;
}
}
}
}
/* 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;
}
/*
* This is the main application initialization function. It is called
* once (and only once) during application initialization sequence by
* main().
*/
static pj_status_t icedemo_init(void)
{
pj_status_t status;
if (icedemo.opt.log_file) {
icedemo.log_fhnd = fopen(icedemo.opt.log_file, "a");
pj_log_set_log_func(&log_func);
}
/* Initialize the libraries before anything else */
CHECK( pj_init() );
CHECK( pjlib_util_init() );
CHECK( pjnath_init() );
/* Must create pool factory, where memory allocations come from */
pj_caching_pool_init(&icedemo.cp, NULL, 0);
/* Init our ICE settings with null values */
pj_ice_strans_cfg_default(&icedemo.ice_cfg);
icedemo.ice_cfg.stun_cfg.pf = &icedemo.cp.factory;
/* Create application memory pool */
icedemo.pool = pj_pool_create(&icedemo.cp.factory, "icedemo",
512, 512, NULL);
/* Create timer heap for timer stuff */
CHECK( pj_timer_heap_create(icedemo.pool, 100,
&icedemo.ice_cfg.stun_cfg.timer_heap) );
/* and create ioqueue for network I/O stuff */
CHECK( pj_ioqueue_create(icedemo.pool, 16,
&icedemo.ice_cfg.stun_cfg.ioqueue) );
/* something must poll the timer heap and ioqueue,
* unless we're on Symbian where the timer heap and ioqueue run
* on themselves.
*/
CHECK( pj_thread_create(icedemo.pool, "icedemo", &icedemo_worker_thread,
NULL, 0, 0, &icedemo.thread) );
icedemo.ice_cfg.af = pj_AF_INET();
/* Create DNS resolver if nameserver is set */
if (icedemo.opt.ns.slen) {
CHECK( pj_dns_resolver_create(&icedemo.cp.factory,
"resolver",
0,
icedemo.ice_cfg.stun_cfg.timer_heap,
icedemo.ice_cfg.stun_cfg.ioqueue,
&icedemo.ice_cfg.resolver) );
CHECK( pj_dns_resolver_set_ns(icedemo.ice_cfg.resolver, 1,
&icedemo.opt.ns, NULL) );
}
/* -= Start initializing ICE stream transport config =- */
/* Maximum number of host candidates */
if (icedemo.opt.max_host != -1)
icedemo.ice_cfg.stun.max_host_cands = icedemo.opt.max_host;
/* Nomination strategy */
if (icedemo.opt.regular)
icedemo.ice_cfg.opt.aggressive = PJ_FALSE;
else
icedemo.ice_cfg.opt.aggressive = PJ_TRUE;
/* Configure STUN/srflx candidate resolution */
if (icedemo.opt.stun_srv.slen) {
char *pos;
/* Command line option may contain port number */
if ((pos=pj_strchr(&icedemo.opt.stun_srv, ':')) != NULL) {
icedemo.ice_cfg.stun.server.ptr = icedemo.opt.stun_srv.ptr;
icedemo.ice_cfg.stun.server.slen = (pos - icedemo.opt.stun_srv.ptr);
icedemo.ice_cfg.stun.port = (pj_uint16_t)atoi(pos+1);
} else {
icedemo.ice_cfg.stun.server = icedemo.opt.stun_srv;
icedemo.ice_cfg.stun.port = PJ_STUN_PORT;
}
/* For this demo app, configure longer STUN keep-alive time
* so that it does't clutter the screen output.
*/
icedemo.ice_cfg.stun.cfg.ka_interval = KA_INTERVAL;
}
/* Configure TURN candidate */
if (icedemo.opt.turn_srv.slen) {
char *pos;
/* Command line option may contain port number */
if ((pos=pj_strchr(&icedemo.opt.turn_srv, ':')) != NULL) {
icedemo.ice_cfg.turn.server.ptr = icedemo.opt.turn_srv.ptr;
icedemo.ice_cfg.turn.server.slen = (pos - icedemo.opt.turn_srv.ptr);
icedemo.ice_cfg.turn.port = (pj_uint16_t)atoi(pos+1);
} else {
icedemo.ice_cfg.turn.server = icedemo.opt.turn_srv;
icedemo.ice_cfg.turn.port = PJ_STUN_PORT;
}
/* TURN credential */
icedemo.ice_cfg.turn.auth_cred.type = PJ_STUN_AUTH_CRED_STATIC;
icedemo.ice_cfg.turn.auth_cred.data.static_cred.username = icedemo.opt.turn_username;
icedemo.ice_cfg.turn.auth_cred.data.static_cred.data_type = PJ_STUN_PASSWD_PLAIN;
icedemo.ice_cfg.turn.auth_cred.data.static_cred.data = icedemo.opt.turn_password;
/* Connection type to TURN server */
if (icedemo.opt.turn_tcp)
icedemo.ice_cfg.turn.conn_type = PJ_TURN_TP_TCP;
else
icedemo.ice_cfg.turn.conn_type = PJ_TURN_TP_UDP;
/* For this demo app, configure longer keep-alive time
* so that it does't clutter the screen output.
*/
icedemo.ice_cfg.turn.alloc_param.ka_interval = KA_INTERVAL;
}
/* -= That's it for now, initialization is complete =- */
return PJ_SUCCESS;
}