/* 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;
}
/* 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;
}
/*
* This is the public API to create, initialize, register, and start the
* TCP listener.
*/
PJ_DEF(pj_status_t) pjsip_tcp_transport_start2(pjsip_endpoint *endpt,
const pj_sockaddr_in *local,
const pjsip_host_port *a_name,
unsigned async_cnt,
pjsip_tpfactory **p_factory)
{
pj_pool_t *pool;
pj_sock_t sock = PJ_INVALID_SOCKET;
struct tcp_listener *listener;
pj_activesock_cfg asock_cfg;
pj_activesock_cb listener_cb;
pj_sockaddr_in *listener_addr;
int addr_len;
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, "tcplis", POOL_LIS_INIT,
POOL_LIS_INC);
PJ_ASSERT_RETURN(pool, PJ_ENOMEM);
listener = PJ_POOL_ZALLOC_T(pool, struct tcp_listener);
listener->factory.pool = pool;
listener->factory.type = PJSIP_TRANSPORT_TCP;
listener->factory.type_name = "tcp";
listener->factory.flag =
pjsip_transport_get_flag_from_type(PJSIP_TRANSPORT_TCP);
pj_ansi_strcpy(listener->factory.obj_name, "tcplis");
status = pj_lock_create_recursive_mutex(pool, "tcplis",
&listener->factory.lock);
if (status != PJ_SUCCESS)
goto on_error;
/* Create and bind socket */
status = pj_sock_socket(pj_AF_INET(), pj_SOCK_STREAM(), 0, &sock);
if (status != PJ_SUCCESS)
goto on_error;
listener_addr = (pj_sockaddr_in*)&listener->factory.local_addr;
if (local) {
pj_memcpy(listener_addr, local, sizeof(pj_sockaddr_in));
} else {
pj_sockaddr_in_init(listener_addr, NULL, 0);
}
status = pj_sock_bind(sock, listener_addr, sizeof(pj_sockaddr_in));
if (status != PJ_SUCCESS)
goto on_error;
/* Retrieve the bound address */
addr_len = sizeof(pj_sockaddr_in);
status = pj_sock_getsockname(sock, listener_addr, &addr_len);
if (status != PJ_SUCCESS)
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),
"tcplis:%d", listener->factory.addr_name.port);
/* Start listening to the address */
status = pj_sock_listen(sock, PJSIP_TCP_TRANSPORT_BACKLOG);
if (status != PJ_SUCCESS)
goto on_error;
/* Create active socket */
if (async_cnt > MAX_ASYNC_CNT) async_cnt = MAX_ASYNC_CNT;
pj_activesock_cfg_default(&asock_cfg);
asock_cfg.async_cnt = async_cnt;
pj_bzero(&listener_cb, sizeof(listener_cb));
listener_cb.on_accept_complete = &on_accept_complete;
status = pj_activesock_create(pool, sock, pj_SOCK_STREAM(), &asock_cfg,
pjsip_endpt_get_ioqueue(endpt),
&listener_cb, listener,
&listener->asock);
/* Register to transport manager */
listener->endpt = endpt;
listener->tpmgr = pjsip_endpt_get_tpmgr(endpt);
listener->factory.create_transport = 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;
}
/* Start pending accept() operations */
status = pj_activesock_start_accept(listener->asock, pool);
if (status != PJ_SUCCESS)
goto on_error;
PJ_LOG(4,(listener->factory.obj_name,
"SIP TCP listener 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));
/* Return the pointer to user */
if (p_factory) *p_factory = &listener->factory;
return PJ_SUCCESS;
on_error:
if (listener->asock==NULL && sock!=PJ_INVALID_SOCKET)
pj_sock_close(sock);
lis_destroy(&listener->factory);
return status;
}
/* This callback is called by transport manager for the TCP factory
* to create outgoing transport to the specified destination.
*/
static pj_status_t lis_create_transport(pjsip_tpfactory *factory,
pjsip_tpmgr *mgr,
pjsip_endpoint *endpt,
const pj_sockaddr *rem_addr,
int addr_len,
pjsip_transport **p_transport)
{
struct tcp_listener *listener;
struct tcp_transport *tcp;
pj_sock_t sock;
pj_sockaddr_in local_addr;
pj_status_t status;
/* Sanity checks */
PJ_ASSERT_RETURN(factory && mgr && endpt && rem_addr &&
addr_len && p_transport, PJ_EINVAL);
/* Check that address is a sockaddr_in */
PJ_ASSERT_RETURN(rem_addr->addr.sa_family == pj_AF_INET() &&
addr_len == sizeof(pj_sockaddr_in), PJ_EINVAL);
listener = (struct tcp_listener*)factory;
/* Create socket */
status = pj_sock_socket(pj_AF_INET(), pj_SOCK_STREAM(), 0, &sock);
if (status != PJ_SUCCESS)
return status;
/* Bind to any port */
status = pj_sock_bind_in(sock, 0, 0);
if (status != PJ_SUCCESS) {
pj_sock_close(sock);
return status;
}
/* Get the local port */
addr_len = sizeof(pj_sockaddr_in);
status = pj_sock_getsockname(sock, &local_addr, &addr_len);
if (status != PJ_SUCCESS) {
pj_sock_close(sock);
return status;
}
/* Initially set the address from the listener's address */
local_addr.sin_addr.s_addr =
((pj_sockaddr_in*)&listener->factory.local_addr)->sin_addr.s_addr;
/* Create the transport descriptor */
status = tcp_create(listener, NULL, sock, PJ_FALSE, &local_addr,
(pj_sockaddr_in*)rem_addr, &tcp);
if (status != PJ_SUCCESS)
return status;
/* Start asynchronous connect() operation */
tcp->has_pending_connect = PJ_TRUE;
status = pj_activesock_start_connect(tcp->asock, tcp->base.pool, rem_addr,
sizeof(pj_sockaddr_in));
if (status == PJ_SUCCESS) {
on_connect_complete(tcp->asock, PJ_SUCCESS);
} else if (status != PJ_EPENDING) {
tcp_destroy(&tcp->base, status);
return status;
}
if (tcp->has_pending_connect) {
/* Update (again) local address, just in case local address currently
* set is different now that asynchronous connect() is started.
*/
addr_len = sizeof(pj_sockaddr_in);
if (pj_sock_getsockname(sock, &local_addr, &addr_len)==PJ_SUCCESS) {
pj_sockaddr_in *tp_addr = (pj_sockaddr_in*)&tcp->base.local_addr;
/* Some systems (like old Win32 perhaps) may not set local address
* properly before socket is fully connected.
*/
if (tp_addr->sin_addr.s_addr != local_addr.sin_addr.s_addr &&
local_addr.sin_addr.s_addr != 0)
{
tp_addr->sin_addr.s_addr = local_addr.sin_addr.s_addr;
tp_addr->sin_port = local_addr.sin_port;
sockaddr_to_host_port(tcp->base.pool, &tcp->base.local_name,
&local_addr);
}
}
PJ_LOG(4,(tcp->base.obj_name,
"TCP transport %.*s:%d is connecting to %.*s:%d...",
(int)tcp->base.local_name.host.slen,
tcp->base.local_name.host.ptr,
tcp->base.local_name.port,
(int)tcp->base.remote_name.host.slen,
tcp->base.remote_name.host.ptr,
tcp->base.remote_name.port));
}
/* Done */
*p_transport = &tcp->base;
return PJ_SUCCESS;
}
/*
* This is the public API to create, initialize, register, and start the
* TCP listener.
*/
PJ_DEF(pj_status_t) pjsip_tcp_transport_start3(
pjsip_endpoint *endpt,
const pjsip_tcp_transport_cfg *cfg,
pjsip_tpfactory **p_factory
)
{
pj_pool_t *pool;
pj_sock_t sock = PJ_INVALID_SOCKET;
struct tcp_listener *listener;
pj_activesock_cfg asock_cfg;
pj_activesock_cb listener_cb;
pj_sockaddr *listener_addr;
int addr_len;
pj_bool_t has_listener = PJ_FALSE;
pj_status_t status;
/* Sanity check */
PJ_ASSERT_RETURN(endpt && cfg->async_cnt, PJ_EINVAL);
/* Verify that address given in a_name (if any) is valid */
if (cfg->addr_name.host.slen) {
pj_sockaddr tmp;
status = pj_sockaddr_init(cfg->af, &tmp, &cfg->addr_name.host,
(pj_uint16_t)cfg->addr_name.port);
if (status != PJ_SUCCESS || !pj_sockaddr_has_addr(&tmp) ||
(cfg->af==pj_AF_INET() &&
tmp.ipv4.sin_addr.s_addr==PJ_INADDR_NONE))
{
/* Invalid address */
return PJ_EINVAL;
}
}
pool = pjsip_endpt_create_pool(endpt, "tcptp", POOL_LIS_INIT,
POOL_LIS_INC);
PJ_ASSERT_RETURN(pool, PJ_ENOMEM);
listener = PJ_POOL_ZALLOC_T(pool, struct tcp_listener);
listener->factory.pool = pool;
listener->factory.type = cfg->af==pj_AF_INET() ? PJSIP_TRANSPORT_TCP :
PJSIP_TRANSPORT_TCP6;
listener->factory.type_name = (char*)
pjsip_transport_get_type_name(listener->factory.type);
listener->factory.flag =
pjsip_transport_get_flag_from_type(listener->factory.type);
listener->qos_type = cfg->qos_type;
pj_memcpy(&listener->qos_params, &cfg->qos_params,
sizeof(cfg->qos_params));
pj_memcpy(&listener->sockopt_params, &cfg->sockopt_params,
sizeof(cfg->sockopt_params));
pj_ansi_strcpy(listener->factory.obj_name, "tcptp");
if (listener->factory.type==PJSIP_TRANSPORT_TCP6)
pj_ansi_strcat(listener->factory.obj_name, "6");
status = pj_lock_create_recursive_mutex(pool, listener->factory.obj_name,
&listener->factory.lock);
if (status != PJ_SUCCESS)
goto on_error;
#if !(defined(PJSIP_TCP_TRANSPORT_DONT_CREATE_LISTENER) && \
PJSIP_TCP_TRANSPORT_DONT_CREATE_LISTENER != 0)
/* Create socket */
status = pj_sock_socket(cfg->af, pj_SOCK_STREAM(), 0, &sock);
if (status != PJ_SUCCESS)
goto on_error;
/* Apply QoS, if specified */
status = pj_sock_apply_qos2(sock, cfg->qos_type, &cfg->qos_params,
2, listener->factory.obj_name,
"SIP TCP listener socket");
/* Apply SO_REUSEADDR */
if (cfg->reuse_addr) {
int enabled = 1;
status = pj_sock_setsockopt(sock, pj_SOL_SOCKET(), pj_SO_REUSEADDR(),
&enabled, sizeof(enabled));
if (status != PJ_SUCCESS) {
PJ_PERROR(4,(listener->factory.obj_name, status,
"Warning: error applying SO_REUSEADDR"));
}
}
/* Apply socket options, if specified */
if (cfg->sockopt_params.cnt)
status = pj_sock_setsockopt_params(sock, &cfg->sockopt_params);
#else
PJ_UNUSED_ARG(addr_len);
#endif
/* Bind address may be different than factory.local_addr because
* factory.local_addr will be resolved below.
*/
pj_sockaddr_cp(&listener->bound_addr, &cfg->bind_addr);
/* Bind socket */
listener_addr = &listener->factory.local_addr;
pj_sockaddr_cp(listener_addr, &cfg->bind_addr);
#if !(defined(PJSIP_TCP_TRANSPORT_DONT_CREATE_LISTENER) && \
PJSIP_TCP_TRANSPORT_DONT_CREATE_LISTENER != 0)
status = pj_sock_bind(sock, listener_addr,
pj_sockaddr_get_len(listener_addr));
if (status != PJ_SUCCESS)
goto on_error;
/* Retrieve the bound address */
addr_len = pj_sockaddr_get_len(listener_addr);
status = pj_sock_getsockname(sock, listener_addr, &addr_len);
if (status != PJ_SUCCESS)
goto on_error;
#endif
/* If published host/IP is specified, then use that address as the
* listener advertised address.
*/
if (cfg->addr_name.host.slen) {
/* Copy the address */
listener->factory.addr_name = cfg->addr_name;
pj_strdup(listener->factory.pool, &listener->factory.addr_name.host,
&cfg->addr_name.host);
listener->factory.addr_name.port = cfg->addr_name.port;
} else {
/* No published address is given, use the bound address */
/* If the address returns 0.0.0.0, use the default
* interface address as the transport's address.
*/
if (!pj_sockaddr_has_addr(listener_addr)) {
pj_sockaddr hostip;
status = pj_gethostip(listener->bound_addr.addr.sa_family,
&hostip);
if (status != PJ_SUCCESS)
goto on_error;
pj_sockaddr_copy_addr(listener_addr, &hostip);
}
/* Save the address name */
sockaddr_to_host_port(listener->factory.pool,
&listener->factory.addr_name,
listener_addr);
}
/* If port is zero, get the bound port */
if (listener->factory.addr_name.port == 0) {
listener->factory.addr_name.port = pj_sockaddr_get_port(listener_addr);
}
pj_ansi_snprintf(listener->factory.obj_name,
sizeof(listener->factory.obj_name),
"tcptp:%d", listener->factory.addr_name.port);
#if !(defined(PJSIP_TCP_TRANSPORT_DONT_CREATE_LISTENER) && \
PJSIP_TCP_TRANSPORT_DONT_CREATE_LISTENER != 0)
/* Start listening to the address */
status = pj_sock_listen(sock, PJSIP_TCP_TRANSPORT_BACKLOG);
if (status != PJ_SUCCESS)
goto on_error;
/* Create active socket */
pj_activesock_cfg_default(&asock_cfg);
if (cfg->async_cnt > MAX_ASYNC_CNT)
asock_cfg.async_cnt = MAX_ASYNC_CNT;
else
asock_cfg.async_cnt = cfg->async_cnt;
#endif
/* Create group lock */
status = pj_grp_lock_create(pool, NULL, &listener->grp_lock);
if (status != PJ_SUCCESS)
return status;
pj_grp_lock_add_ref(listener->grp_lock);
pj_grp_lock_add_handler(listener->grp_lock, pool, listener,
&lis_on_destroy);
asock_cfg.grp_lock = listener->grp_lock;
pj_bzero(&listener_cb, sizeof(listener_cb));
listener_cb.on_accept_complete = &on_accept_complete;
#if !(defined(PJSIP_TCP_TRANSPORT_DONT_CREATE_LISTENER) && \
PJSIP_TCP_TRANSPORT_DONT_CREATE_LISTENER != 0)
status = pj_activesock_create(pool, sock, pj_SOCK_STREAM(), &asock_cfg,
pjsip_endpt_get_ioqueue(endpt),
&listener_cb, listener,
&listener->asock);
#endif
/* Register to transport manager */
listener->endpt = endpt;
listener->tpmgr = pjsip_endpt_get_tpmgr(endpt);
listener->factory.create_transport = 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 !(defined(PJSIP_TCP_TRANSPORT_DONT_CREATE_LISTENER) && \
PJSIP_TCP_TRANSPORT_DONT_CREATE_LISTENER != 0)
/* Start pending accept() operations */
status = pj_activesock_start_accept(listener->asock, pool);
if (status != PJ_SUCCESS)
goto on_error;
has_listener = PJ_TRUE;
#endif
if (has_listener) {
PJ_LOG(4,(listener->factory.obj_name,
"SIP TCP listener 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 TCP is ready "
"(client only)"));
}
/* Return the pointer to user */
if (p_factory) *p_factory = &listener->factory;
return PJ_SUCCESS;
on_error:
if (listener->asock==NULL && sock!=PJ_INVALID_SOCKET)
pj_sock_close(sock);
lis_destroy(&listener->factory);
return status;
}
/* This callback is called by transport manager for the TCP factory
* to create outgoing transport to the specified destination.
*/
static pj_status_t lis_create_transport(pjsip_tpfactory *factory,
pjsip_tpmgr *mgr,
pjsip_endpoint *endpt,
const pj_sockaddr *rem_addr,
int addr_len,
pjsip_transport **p_transport)
{
struct tcp_listener *listener;
struct tcp_transport *tcp;
pj_sock_t sock;
pj_sockaddr local_addr;
pj_status_t status;
/* Sanity checks */
PJ_ASSERT_RETURN(factory && mgr && endpt && rem_addr &&
addr_len && p_transport, PJ_EINVAL);
/* Check that address is a sockaddr_in or sockaddr_in6*/
PJ_ASSERT_RETURN((rem_addr->addr.sa_family == pj_AF_INET() &&
addr_len == sizeof(pj_sockaddr_in)) ||
(rem_addr->addr.sa_family == pj_AF_INET6() &&
addr_len == sizeof(pj_sockaddr_in6)), PJ_EINVAL);
listener = (struct tcp_listener*)factory;
/* Create socket */
status = pj_sock_socket(rem_addr->addr.sa_family, pj_SOCK_STREAM(),
0, &sock);
if (status != PJ_SUCCESS)
return status;
/* Apply QoS, if specified */
status = pj_sock_apply_qos2(sock, listener->qos_type,
&listener->qos_params,
2, listener->factory.obj_name,
"outgoing SIP TCP socket");
/* Apply socket options, if specified */
if (listener->sockopt_params.cnt)
status = pj_sock_setsockopt_params(sock, &listener->sockopt_params);
/* Bind to listener's address and any port */
pj_bzero(&local_addr, sizeof(local_addr));
pj_sockaddr_cp(&local_addr, &listener->bound_addr);
pj_sockaddr_set_port(&local_addr, 0);
status = pj_sock_bind(sock, &local_addr,
pj_sockaddr_get_len(&local_addr));
if (status != PJ_SUCCESS) {
pj_sock_close(sock);
return status;
}
/* Get the local port */
addr_len = sizeof(local_addr);
status = pj_sock_getsockname(sock, &local_addr, &addr_len);
if (status != PJ_SUCCESS) {
pj_sock_close(sock);
return status;
}
/* Initially set the address from the listener's address */
if (!pj_sockaddr_has_addr(&local_addr)) {
pj_sockaddr_copy_addr(&local_addr, &listener->factory.local_addr);
}
/* Create the transport descriptor */
status = tcp_create(listener, NULL, sock, PJ_FALSE, &local_addr,
rem_addr, &tcp);
if (status != PJ_SUCCESS)
return status;
/* Start asynchronous connect() operation */
tcp->has_pending_connect = PJ_TRUE;
status = pj_activesock_start_connect(tcp->asock, tcp->base.pool, rem_addr,
addr_len);
if (status == PJ_SUCCESS) {
on_connect_complete(tcp->asock, PJ_SUCCESS);
} else if (status != PJ_EPENDING) {
tcp_destroy(&tcp->base, status);
return status;
}
if (tcp->has_pending_connect) {
/* Update (again) local address, just in case local address currently
* set is different now that asynchronous connect() is started.
*/
addr_len = sizeof(local_addr);
if (pj_sock_getsockname(sock, &local_addr, &addr_len)==PJ_SUCCESS) {
pj_sockaddr *tp_addr = &tcp->base.local_addr;
/* Some systems (like old Win32 perhaps) may not set local address
* properly before socket is fully connected.
*/
if (pj_sockaddr_cmp(tp_addr, &local_addr) &&
pj_sockaddr_has_addr(&local_addr) &&
pj_sockaddr_get_port(&local_addr) != 0)
{
pj_sockaddr_cp(tp_addr, &local_addr);
sockaddr_to_host_port(tcp->base.pool, &tcp->base.local_name,
&local_addr);
}
}
PJ_LOG(4,(tcp->base.obj_name,
"TCP transport %.*s:%d is connecting to %.*s:%d...",
(int)tcp->base.local_name.host.slen,
tcp->base.local_name.host.ptr,
tcp->base.local_name.port,
(int)tcp->base.remote_name.host.slen,
tcp->base.remote_name.host.ptr,
tcp->base.remote_name.port));
}
/* Done */
*p_transport = &tcp->base;
return PJ_SUCCESS;
}
int http_client_test_delete()
{
pj_str_t url;
pj_http_req_callback hcb;
pj_http_req_param param;
char urlbuf[80];
pj_bzero(&hcb, sizeof(hcb));
hcb.on_complete = &on_complete;
hcb.on_response = &on_response;
/* Create pool, timer, and ioqueue */
pool = pj_pool_create(mem, NULL, 8192, 4096, NULL);
if (pj_timer_heap_create(pool, 16, &timer_heap))
return -61;
if (pj_ioqueue_create(pool, 16, &ioqueue))
return -62;
#ifdef USE_LOCAL_SERVER
thread_quit = PJ_FALSE;
g_server.action = ACTION_REPLY;
g_server.send_content_length = PJ_TRUE;
g_server.data_size = 0;
g_server.buf_size = 1024;
sstatus = pj_sock_socket(pj_AF_INET(), pj_SOCK_STREAM(), 0,
&g_server.sock);
if (sstatus != PJ_SUCCESS)
return -41;
pj_sockaddr_in_init(&addr, NULL, 0);
sstatus = pj_sock_bind(g_server.sock, &addr, sizeof(addr));
if (sstatus != PJ_SUCCESS)
return -43;
{
pj_sockaddr_in addr;
int addr_len = sizeof(addr);
sstatus = pj_sock_getsockname(g_server.sock, &addr, &addr_len);
if (sstatus != PJ_SUCCESS)
return -44;
g_server.port = pj_sockaddr_in_get_port(&addr);
pj_ansi_snprintf(urlbuf, sizeof(urlbuf),
"http://127.0.0.1:%d/test/test2.txt",
g_server.port);
url = pj_str(urlbuf);
}
sstatus = pj_sock_listen(g_server.sock, 8);
if (sstatus != PJ_SUCCESS)
return -45;
sstatus = pj_thread_create(pool, NULL, &server_thread, &g_server,
0, 0, &g_server.thread);
if (sstatus != PJ_SUCCESS)
return -47;
#else
pj_cstr(&url, "http://127.0.0.1:280/test/test2.txt");
#endif
pj_http_req_param_default(¶m);
pj_strset2(¶m.method, (char*)"DELETE");
if (pj_http_req_create(pool, &url, timer_heap, ioqueue,
¶m, &hcb, &http_req))
return -63;
if (pj_http_req_start(http_req))
return -65;
while (pj_http_req_is_running(http_req)) {
pj_time_val delay = {0, 50};
pj_ioqueue_poll(ioqueue, &delay);
pj_timer_heap_poll(timer_heap, NULL);
}
#ifdef USE_LOCAL_SERVER
thread_quit = PJ_TRUE;
pj_thread_join(g_server.thread);
pj_sock_close(g_server.sock);
#endif
pj_http_req_destroy(http_req);
pj_ioqueue_destroy(ioqueue);
pj_timer_heap_destroy(timer_heap);
pj_pool_release(pool);
return PJ_SUCCESS;
}
/*
* 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;
pj_ssize_t 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, 1000);
#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, 1000);
#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 pj_status_t ioqueue_init_key( pj_pool_t *pool,
pj_ioqueue_t *ioqueue,
pj_ioqueue_key_t *key,
pj_sock_t sock,
pj_grp_lock_t *grp_lock,
void *user_data,
const pj_ioqueue_callback *cb)
{
pj_status_t rc;
int optlen;
PJ_UNUSED_ARG(pool);
key->ioqueue = ioqueue;
key->fd = sock;
key->user_data = user_data;
pj_list_init(&key->read_list);
pj_list_init(&key->write_list);
#if PJ_HAS_TCP
pj_list_init(&key->accept_list);
key->connecting = 0;
#endif
/* Save callback. */
pj_memcpy(&key->cb, cb, sizeof(pj_ioqueue_callback));
#if PJ_IOQUEUE_HAS_SAFE_UNREG
/* Set initial reference count to 1 */
pj_assert(key->ref_count == 0);
++key->ref_count;
key->closing = 0;
#endif
rc = pj_ioqueue_set_concurrency(key, ioqueue->default_concurrency);
if (rc != PJ_SUCCESS)
return rc;
/* Get socket type. When socket type is datagram, some optimization
* will be performed during send to allow parallel send operations.
*/
optlen = sizeof(key->fd_type);
rc = pj_sock_getsockopt(sock, pj_SOL_SOCKET(), pj_SO_TYPE(),
&key->fd_type, &optlen);
if (rc != PJ_SUCCESS)
key->fd_type = pj_SOCK_STREAM();
/* Create mutex for the key. */
#if !PJ_IOQUEUE_HAS_SAFE_UNREG
rc = pj_lock_create_simple_mutex(poll, NULL, &key->lock);
#endif
if (rc != PJ_SUCCESS)
return rc;
/* Group lock */
key->grp_lock = grp_lock;
if (key->grp_lock) {
pj_grp_lock_add_ref_dbg(key->grp_lock, "ioqueue", 0);
}
return PJ_SUCCESS;
}
/*
* GET request scenario 2: using on_complete() to get the
* complete data. Server does not reply with content-length.
* Request timed out, application sets a longer timeout, then
* then restart the request.
*/
int http_client_test2()
{
pj_str_t url;
pj_http_req_callback hcb;
pj_http_req_param param;
pj_time_val timeout;
char urlbuf[80];
pj_bzero(&hcb, sizeof(hcb));
hcb.on_complete = &on_complete;
hcb.on_response = &on_response;
pj_http_req_param_default(¶m);
/* Create pool, timer, and ioqueue */
pool = pj_pool_create(mem, NULL, 8192, 4096, NULL);
if (pj_timer_heap_create(pool, 16, &timer_heap))
return -41;
if (pj_ioqueue_create(pool, 16, &ioqueue))
return -42;
#ifdef USE_LOCAL_SERVER
pj_cstr(&url, "http://127.0.0.1:380");
param.timeout.sec = 0;
param.timeout.msec = 2000;
thread_quit = PJ_FALSE;
g_server.action = ACTION_IGNORE;
g_server.send_content_length = PJ_FALSE;
g_server.data_size = 4173;
g_server.buf_size = 1024;
sstatus = pj_sock_socket(pj_AF_INET(), pj_SOCK_STREAM(), 0,
&g_server.sock);
if (sstatus != PJ_SUCCESS)
return -41;
pj_sockaddr_in_init(&addr, NULL, 0);
sstatus = pj_sock_bind(g_server.sock, &addr, sizeof(addr));
if (sstatus != PJ_SUCCESS)
return -43;
{
pj_sockaddr_in addr;
int addr_len = sizeof(addr);
sstatus = pj_sock_getsockname(g_server.sock, &addr, &addr_len);
if (sstatus != PJ_SUCCESS)
return -44;
g_server.port = pj_sockaddr_in_get_port(&addr);
pj_ansi_snprintf(urlbuf, sizeof(urlbuf),
"http://127.0.0.1:%d",
g_server.port);
url = pj_str(urlbuf);
}
sstatus = pj_sock_listen(g_server.sock, 8);
if (sstatus != PJ_SUCCESS)
return -45;
sstatus = pj_thread_create(pool, NULL, &server_thread, &g_server,
0, 0, &g_server.thread);
if (sstatus != PJ_SUCCESS)
return -47;
#else
pj_cstr(&url, "http://www.google.com.sg");
param.timeout.sec = 0;
param.timeout.msec = 50;
#endif
pj_http_headers_add_elmt2(¶m.headers, (char*)"Accept",
(char*)"image/gif, image/x-xbitmap, image/jpeg, "
"image/pjpeg, application/x-ms-application,"
" application/vnd.ms-xpsdocument, "
"application/xaml+xml, "
"application/x-ms-xbap, "
"application/x-shockwave-flash, "
"application/vnd.ms-excel, "
"application/vnd.ms-powerpoint, "
"application/msword, */*");
pj_http_headers_add_elmt2(¶m.headers, (char*)"Accept-Language",
(char*)"en-sg");
pj_http_headers_add_elmt2(¶m.headers, (char*)"User-Agent",
(char*)"Mozilla/4.0 (compatible; MSIE 7.0; "
"Windows NT 6.0; SLCC1; "
".NET CLR 2.0.50727; "
".NET CLR 3.0.04506)");
if (pj_http_req_create(pool, &url, timer_heap, ioqueue,
¶m, &hcb, &http_req))
return -43;
if (pj_http_req_start(http_req))
return -45;
while (pj_http_req_is_running(http_req)) {
pj_time_val delay = {0, 50};
pj_ioqueue_poll(ioqueue, &delay);
pj_timer_heap_poll(timer_heap, NULL);
}
#ifdef USE_LOCAL_SERVER
g_server.action = ACTION_REPLY;
#endif
timeout.sec = 0; timeout.msec = 10000;
pj_http_req_set_timeout(http_req, &timeout);
if (pj_http_req_start(http_req))
return -47;
while (pj_http_req_is_running(http_req)) {
pj_time_val delay = {0, 50};
pj_ioqueue_poll(ioqueue, &delay);
pj_timer_heap_poll(timer_heap, NULL);
}
#ifdef USE_LOCAL_SERVER
thread_quit = PJ_TRUE;
pj_thread_join(g_server.thread);
pj_sock_close(g_server.sock);
#endif
pj_http_req_destroy(http_req);
pj_ioqueue_destroy(ioqueue);
pj_timer_heap_destroy(timer_heap);
pj_pool_release(pool);
return PJ_SUCCESS;
}
static int ioqueue_perf_test_imp(pj_bool_t allow_concur)
{
enum { BUF_SIZE = 512 };
int i, rc;
struct {
int type;
const char *type_name;
int thread_cnt;
int sockpair_cnt;
} test_param[] =
{
{ pj_SOCK_DGRAM(), "udp", 1, 1},
{ pj_SOCK_DGRAM(), "udp", 1, 2},
{ pj_SOCK_DGRAM(), "udp", 1, 4},
{ pj_SOCK_DGRAM(), "udp", 1, 8},
{ pj_SOCK_DGRAM(), "udp", 2, 1},
{ pj_SOCK_DGRAM(), "udp", 2, 2},
{ pj_SOCK_DGRAM(), "udp", 2, 4},
{ pj_SOCK_DGRAM(), "udp", 2, 8},
{ pj_SOCK_DGRAM(), "udp", 4, 1},
{ pj_SOCK_DGRAM(), "udp", 4, 2},
{ pj_SOCK_DGRAM(), "udp", 4, 4},
{ pj_SOCK_DGRAM(), "udp", 4, 8},
{ pj_SOCK_DGRAM(), "udp", 4, 16},
{ pj_SOCK_STREAM(), "tcp", 1, 1},
{ pj_SOCK_STREAM(), "tcp", 1, 2},
{ pj_SOCK_STREAM(), "tcp", 1, 4},
{ pj_SOCK_STREAM(), "tcp", 1, 8},
{ pj_SOCK_STREAM(), "tcp", 2, 1},
{ pj_SOCK_STREAM(), "tcp", 2, 2},
{ pj_SOCK_STREAM(), "tcp", 2, 4},
{ pj_SOCK_STREAM(), "tcp", 2, 8},
{ pj_SOCK_STREAM(), "tcp", 4, 1},
{ pj_SOCK_STREAM(), "tcp", 4, 2},
{ pj_SOCK_STREAM(), "tcp", 4, 4},
{ pj_SOCK_STREAM(), "tcp", 4, 8},
{ pj_SOCK_STREAM(), "tcp", 4, 16},
/*
{ pj_SOCK_DGRAM(), "udp", 32, 1},
{ pj_SOCK_DGRAM(), "udp", 32, 1},
{ pj_SOCK_DGRAM(), "udp", 32, 1},
{ pj_SOCK_DGRAM(), "udp", 32, 1},
{ pj_SOCK_DGRAM(), "udp", 1, 32},
{ pj_SOCK_DGRAM(), "udp", 1, 32},
{ pj_SOCK_DGRAM(), "udp", 1, 32},
{ pj_SOCK_DGRAM(), "udp", 1, 32},
{ pj_SOCK_STREAM(), "tcp", 32, 1},
{ pj_SOCK_STREAM(), "tcp", 32, 1},
{ pj_SOCK_STREAM(), "tcp", 32, 1},
{ pj_SOCK_STREAM(), "tcp", 32, 1},
{ pj_SOCK_STREAM(), "tcp", 1, 32},
{ pj_SOCK_STREAM(), "tcp", 1, 32},
{ pj_SOCK_STREAM(), "tcp", 1, 32},
{ pj_SOCK_STREAM(), "tcp", 1, 32},
*/
};
pj_size_t best_bandwidth;
int best_index = 0;
PJ_LOG(3,(THIS_FILE, " Benchmarking %s ioqueue:", pj_ioqueue_name()));
PJ_LOG(3,(THIS_FILE, " Testing with concurency=%d", allow_concur));
PJ_LOG(3,(THIS_FILE, " ======================================="));
PJ_LOG(3,(THIS_FILE, " Type Threads Skt.Pairs Bandwidth"));
PJ_LOG(3,(THIS_FILE, " ======================================="));
best_bandwidth = 0;
for (i=0; i<(int)(sizeof(test_param)/sizeof(test_param[0])); ++i) {
pj_size_t bandwidth;
rc = perform_test(allow_concur,
test_param[i].type,
test_param[i].type_name,
test_param[i].thread_cnt,
test_param[i].sockpair_cnt,
BUF_SIZE,
&bandwidth);
if (rc != 0)
return rc;
if (bandwidth > best_bandwidth)
best_bandwidth = bandwidth, best_index = i;
/* Give it a rest before next test, to allow system to close the
* sockets properly.
*/
pj_thread_sleep(500);
}
PJ_LOG(3,(THIS_FILE,
" Best: Type=%s Threads=%d, Skt.Pairs=%d, Bandwidth=%u KB/s",
test_param[best_index].type_name,
test_param[best_index].thread_cnt,
test_param[best_index].sockpair_cnt,
best_bandwidth));
PJ_LOG(3,(THIS_FILE, " (Note: packet size=%d, total errors=%u)",
BUF_SIZE, last_error_counter));
return 0;
}
pj_status_t app_socketpair(int family, int type, int protocol,
pj_sock_t *serverfd, pj_sock_t *clientfd)
{
int i;
static unsigned short port = 11000;
pj_sockaddr_in addr;
pj_str_t s;
pj_status_t rc = 0;
pj_sock_t sock[2];
/* Create both sockets. */
for (i=0; i<2; ++i) {
rc = pj_sock_socket(family, type, protocol, &sock[i]);
if (rc != PJ_SUCCESS) {
if (i==1)
pj_sock_close(sock[0]);
return rc;
}
}
/* Retry bind */
pj_bzero(&addr, sizeof(addr));
addr.sin_family = pj_AF_INET();
for (i=0; i<5; ++i) {
addr.sin_port = pj_htons(port++);
rc = pj_sock_bind(sock[SERVER], &addr, sizeof(addr));
if (rc == PJ_SUCCESS)
break;
}
if (rc != PJ_SUCCESS)
goto on_error;
/* For TCP, listen the socket. */
#if PJ_HAS_TCP
if (type == pj_SOCK_STREAM()) {
rc = pj_sock_listen(sock[SERVER], PJ_SOMAXCONN);
if (rc != PJ_SUCCESS)
goto on_error;
}
#endif
/* Connect client socket. */
addr.sin_addr = pj_inet_addr(pj_cstr(&s, "127.0.0.1"));
rc = pj_sock_connect(sock[CLIENT], &addr, sizeof(addr));
if (rc != PJ_SUCCESS)
goto on_error;
/* For TCP, must accept(), and get the new socket. */
#if PJ_HAS_TCP
if (type == pj_SOCK_STREAM()) {
pj_sock_t newserver;
rc = pj_sock_accept(sock[SERVER], &newserver, NULL, NULL);
if (rc != PJ_SUCCESS)
goto on_error;
/* Replace server socket with new socket. */
pj_sock_close(sock[SERVER]);
sock[SERVER] = newserver;
}
#endif
*serverfd = sock[SERVER];
*clientfd = sock[CLIENT];
return rc;
on_error:
for (i=0; i<2; ++i)
pj_sock_close(sock[i]);
return rc;
}
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;
}
/*
* 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;
pj_ssize_t 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, 1000);
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, 1000);
#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;
}
static int send_recv_test(int sock_type,
pj_sock_t ss, pj_sock_t cs,
pj_sockaddr_in *dstaddr, pj_sockaddr_in *srcaddr,
int addrlen)
{
enum { DATA_LEN = 16 };
char senddata[DATA_LEN+4], recvdata[DATA_LEN+4];
pj_ssize_t sent, received, total_received;
pj_status_t rc;
TRACE_(("test", "....create_random_string()"));
pj_create_random_string(senddata, DATA_LEN);
senddata[DATA_LEN-1] = '\0';
/*
* Test send/recv small data.
*/
TRACE_(("test", "....sendto()"));
if (dstaddr) {
sent = DATA_LEN;
rc = pj_sock_sendto(cs, senddata, &sent, 0, dstaddr, addrlen);
if (rc != PJ_SUCCESS || sent != DATA_LEN) {
app_perror("...sendto error", rc);
rc = -140; goto on_error;
}
} else {
sent = DATA_LEN;
rc = pj_sock_send(cs, senddata, &sent, 0);
if (rc != PJ_SUCCESS || sent != DATA_LEN) {
app_perror("...send error", rc);
rc = -145; goto on_error;
}
}
TRACE_(("test", "....recv()"));
if (srcaddr) {
pj_sockaddr_in addr;
int srclen = sizeof(addr);
pj_bzero(&addr, sizeof(addr));
received = DATA_LEN;
rc = pj_sock_recvfrom(ss, recvdata, &received, 0, &addr, &srclen);
if (rc != PJ_SUCCESS || received != DATA_LEN) {
app_perror("...recvfrom error", rc);
rc = -150; goto on_error;
}
if (srclen != addrlen)
return -151;
if (pj_sockaddr_cmp(&addr, srcaddr) != 0) {
char srcaddr_str[32], addr_str[32];
strcpy(srcaddr_str, pj_inet_ntoa(srcaddr->sin_addr));
strcpy(addr_str, pj_inet_ntoa(addr.sin_addr));
PJ_LOG(3,("test", "...error: src address mismatch (original=%s, "
"recvfrom addr=%s)",
srcaddr_str, addr_str));
return -152;
}
} else {
/* Repeat recv() until all data is received.
* This applies only for non-UDP of course, since for UDP
* we would expect all data to be received in one packet.
*/
total_received = 0;
do {
received = DATA_LEN-total_received;
rc = pj_sock_recv(ss, recvdata+total_received, &received, 0);
if (rc != PJ_SUCCESS) {
app_perror("...recv error", rc);
rc = -155; goto on_error;
}
if (received <= 0) {
PJ_LOG(3,("", "...error: socket has closed! (received=%d)",
received));
rc = -156; goto on_error;
}
if (received != DATA_LEN-total_received) {
if (sock_type != pj_SOCK_STREAM()) {
PJ_LOG(3,("", "...error: expecting %u bytes, got %u bytes",
DATA_LEN-total_received, received));
rc = -157; goto on_error;
}
}
total_received += received;
} while (total_received < DATA_LEN);
}
TRACE_(("test", "....memcmp()"));
if (pj_memcmp(senddata, recvdata, DATA_LEN) != 0) {
PJ_LOG(3,("","...error: received data mismatch "
"(got:'%s' expecting:'%s'",
recvdata, senddata));
rc = -160; goto on_error;
}
/*
* Test send/recv big data.
*/
TRACE_(("test", "....sendto()"));
if (dstaddr) {
sent = BIG_DATA_LEN;
rc = pj_sock_sendto(cs, bigdata, &sent, 0, dstaddr, addrlen);
if (rc != PJ_SUCCESS || sent != BIG_DATA_LEN) {
app_perror("...sendto error", rc);
rc = -161; goto on_error;
}
} else {
sent = BIG_DATA_LEN;
rc = pj_sock_send(cs, bigdata, &sent, 0);
if (rc != PJ_SUCCESS || sent != BIG_DATA_LEN) {
app_perror("...send error", rc);
rc = -165; goto on_error;
}
}
TRACE_(("test", "....recv()"));
/* Repeat recv() until all data is received.
* This applies only for non-UDP of course, since for UDP
* we would expect all data to be received in one packet.
*/
total_received = 0;
do {
received = BIG_DATA_LEN-total_received;
rc = pj_sock_recv(ss, bigbuffer+total_received, &received, 0);
if (rc != PJ_SUCCESS) {
app_perror("...recv error", rc);
rc = -170; goto on_error;
}
if (received <= 0) {
PJ_LOG(3,("", "...error: socket has closed! (received=%d)",
received));
rc = -173; goto on_error;
}
if (received != BIG_DATA_LEN-total_received) {
if (sock_type != pj_SOCK_STREAM()) {
PJ_LOG(3,("", "...error: expecting %u bytes, got %u bytes",
BIG_DATA_LEN-total_received, received));
rc = -176; goto on_error;
}
}
total_received += received;
} while (total_received < BIG_DATA_LEN);
TRACE_(("test", "....memcmp()"));
if (pj_memcmp(bigdata, bigbuffer, BIG_DATA_LEN) != 0) {
PJ_LOG(3,("", "...error: received data has been altered!"));
rc = -180; goto on_error;
}
rc = 0;
on_error:
return rc;
}
/*
* 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;
pj_ssize_t 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, 1000);
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, 1000);
#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;
}
/*
* Create relay.
*/
static pj_status_t create_relay(pj_turn_srv *srv,
pj_turn_allocation *alloc,
const pj_stun_msg *msg,
const alloc_request *req,
pj_turn_relay_res *relay)
{
enum { RETRY = 40 };
pj_pool_t *pool = alloc->pool;
int retry, retry_max, sock_type;
pj_ioqueue_callback icb;
int af, namelen;
pj_stun_string_attr *sa;
pj_status_t status;
pj_bzero(relay, sizeof(*relay));
relay->allocation = alloc;
relay->tp.sock = PJ_INVALID_SOCKET;
/* TODO: get the requested address family from somewhere */
af = alloc->transport->listener->addr.addr.sa_family;
/* Save realm */
sa = (pj_stun_string_attr*)
pj_stun_msg_find_attr(msg, PJ_STUN_ATTR_REALM, 0);
PJ_ASSERT_RETURN(sa, PJ_EINVALIDOP);
pj_strdup(pool, &relay->realm, &sa->value);
/* Save username */
sa = (pj_stun_string_attr*)
pj_stun_msg_find_attr(msg, PJ_STUN_ATTR_USERNAME, 0);
PJ_ASSERT_RETURN(sa, PJ_EINVALIDOP);
pj_strdup(pool, &relay->user, &sa->value);
/* Lifetime and timeout */
relay->lifetime = req->lifetime;
pj_timer_entry_init(&relay->timer, TIMER_ID_NONE, relay,
&relay_timeout_cb);
resched_timeout(alloc);
/* Transport type */
relay->hkey.tp_type = req->tp_type;
/* Create the socket */
if (req->tp_type == PJ_TURN_TP_UDP) {
sock_type = pj_SOCK_DGRAM();
} else if (req->tp_type == PJ_TURN_TP_TCP) {
sock_type = pj_SOCK_STREAM();
} else {
pj_assert(!"Unknown transport");
return PJ_EINVALIDOP;
}
status = pj_sock_socket(af, sock_type, 0, &relay->tp.sock);
if (status != PJ_SUCCESS) {
pj_bzero(relay, sizeof(*relay));
return status;
}
/* Find suitable port for this allocation */
if (req->rpp_port) {
retry_max = 1;
} else {
retry_max = RETRY;
}
for (retry=0; retry<retry_max; ++retry) {
pj_uint16_t port;
pj_sockaddr bound_addr;
pj_lock_acquire(srv->core.lock);
if (req->rpp_port) {
port = (pj_uint16_t) req->rpp_port;
} else if (req->tp_type == PJ_TURN_TP_UDP) {
port = (pj_uint16_t) srv->ports.next_udp++;
if (srv->ports.next_udp > srv->ports.max_udp)
srv->ports.next_udp = srv->ports.min_udp;
} else if (req->tp_type == PJ_TURN_TP_TCP) {
port = (pj_uint16_t) srv->ports.next_tcp++;
if (srv->ports.next_tcp > srv->ports.max_tcp)
srv->ports.next_tcp = srv->ports.min_tcp;
} else {
pj_assert(!"Invalid transport");
port = 0;
}
pj_lock_release(srv->core.lock);
pj_sockaddr_init(af, &bound_addr, NULL, port);
status = pj_sock_bind(relay->tp.sock, &bound_addr,
pj_sockaddr_get_len(&bound_addr));
if (status == PJ_SUCCESS)
break;
}
if (status != PJ_SUCCESS) {
/* Unable to allocate port */
PJ_LOG(4,(THIS_FILE, "Unable to allocate relay, giving up: err %d",
status));
pj_sock_close(relay->tp.sock);
relay->tp.sock = PJ_INVALID_SOCKET;
return status;
}
/* Init relay key */
namelen = sizeof(relay->hkey.addr);
status = pj_sock_getsockname(relay->tp.sock, &relay->hkey.addr, &namelen);
if (status != PJ_SUCCESS) {
PJ_LOG(4,(THIS_FILE, "pj_sock_getsockname() failed: err %d",
status));
pj_sock_close(relay->tp.sock);
relay->tp.sock = PJ_INVALID_SOCKET;
return status;
}
if (!pj_sockaddr_has_addr(&relay->hkey.addr)) {
pj_sockaddr_copy_addr(&relay->hkey.addr,
&alloc->transport->listener->addr);
}
if (!pj_sockaddr_has_addr(&relay->hkey.addr)) {
pj_sockaddr tmp_addr;
pj_gethostip(af, &tmp_addr);
pj_sockaddr_copy_addr(&relay->hkey.addr, &tmp_addr);
}
/* Init ioqueue */
pj_bzero(&icb, sizeof(icb));
icb.on_read_complete = &on_rx_from_peer;
status = pj_ioqueue_register_sock(pool, srv->core.ioqueue, relay->tp.sock,
relay, &icb, &relay->tp.key);
if (status != PJ_SUCCESS) {
PJ_LOG(4,(THIS_FILE, "pj_ioqueue_register_sock() failed: err %d",
status));
pj_sock_close(relay->tp.sock);
relay->tp.sock = PJ_INVALID_SOCKET;
return status;
}
/* Kick off pending read operation */
pj_ioqueue_op_key_init(&relay->tp.read_key, sizeof(relay->tp.read_key));
on_rx_from_peer(relay->tp.key, &relay->tp.read_key, 0);
/* Done */
return PJ_SUCCESS;
}
/*
* Callback from TURN session when state has changed
*/
static void turn_on_state(pj_turn_session *sess,
pj_turn_state_t old_state,
pj_turn_state_t new_state)
{
pj_turn_sock *turn_sock = (pj_turn_sock*)
pj_turn_session_get_user_data(sess);
pj_status_t status;
if (turn_sock == NULL) {
/* We've been destroyed */
return;
}
/* Notify app first */
if (turn_sock->cb.on_state) {
(*turn_sock->cb.on_state)(turn_sock, old_state, new_state);
}
/* Make sure user hasn't destroyed us in the callback */
if (turn_sock->sess && new_state == PJ_TURN_STATE_RESOLVED) {
pj_turn_session_info info;
pj_turn_session_get_info(turn_sock->sess, &info);
new_state = info.state;
}
if (turn_sock->sess && new_state == PJ_TURN_STATE_RESOLVED) {
/*
* Once server has been resolved, initiate outgoing TCP
* connection to the server.
*/
pj_turn_session_info info;
char addrtxt[PJ_INET6_ADDRSTRLEN+8];
int sock_type;
pj_sock_t sock;
pj_activesock_cfg asock_cfg;
pj_activesock_cb asock_cb;
pj_sockaddr bound_addr, *cfg_bind_addr;
pj_uint16_t max_bind_retry;
/* Close existing connection, if any. This happens when
* we're switching to alternate TURN server when either TCP
* connection or ALLOCATE request failed.
*/
if (turn_sock->active_sock) {
pj_activesock_close(turn_sock->active_sock);
turn_sock->active_sock = NULL;
}
/* Get server address from session info */
pj_turn_session_get_info(sess, &info);
if (turn_sock->conn_type == PJ_TURN_TP_UDP)
sock_type = pj_SOCK_DGRAM();
else
sock_type = pj_SOCK_STREAM();
/* Init socket */
status = pj_sock_socket(turn_sock->af, sock_type, 0, &sock);
if (status != PJ_SUCCESS) {
pj_turn_sock_destroy(turn_sock);
return;
}
/* Bind socket */
cfg_bind_addr = &turn_sock->setting.bound_addr;
max_bind_retry = MAX_BIND_RETRY;
if (turn_sock->setting.port_range &&
turn_sock->setting.port_range < max_bind_retry)
{
max_bind_retry = turn_sock->setting.port_range;
}
pj_sockaddr_init(turn_sock->af, &bound_addr, NULL, 0);
if (cfg_bind_addr->addr.sa_family == pj_AF_INET() ||
cfg_bind_addr->addr.sa_family == pj_AF_INET6())
{
pj_sockaddr_cp(&bound_addr, cfg_bind_addr);
}
status = pj_sock_bind_random(sock, &bound_addr,
turn_sock->setting.port_range,
max_bind_retry);
if (status != PJ_SUCCESS) {
pj_turn_sock_destroy(turn_sock);
return;
}
/* Apply QoS, if specified */
status = pj_sock_apply_qos2(sock, turn_sock->setting.qos_type,
&turn_sock->setting.qos_params,
(turn_sock->setting.qos_ignore_error?2:1),
turn_sock->pool->obj_name, NULL);
if (status != PJ_SUCCESS && !turn_sock->setting.qos_ignore_error) {
pj_turn_sock_destroy(turn_sock);
return;
}
/* Apply socket buffer size */
if (turn_sock->setting.so_rcvbuf_size > 0) {
unsigned sobuf_size = turn_sock->setting.so_rcvbuf_size;
status = pj_sock_setsockopt_sobuf(sock, pj_SO_RCVBUF(),
PJ_TRUE, &sobuf_size);
if (status != PJ_SUCCESS) {
pj_perror(3, turn_sock->obj_name, status,
"Failed setting SO_RCVBUF");
} else {
if (sobuf_size < turn_sock->setting.so_rcvbuf_size) {
PJ_LOG(4, (turn_sock->obj_name,
"Warning! Cannot set SO_RCVBUF as configured,"
" now=%d, configured=%d", sobuf_size,
turn_sock->setting.so_rcvbuf_size));
} else {
PJ_LOG(5, (turn_sock->obj_name, "SO_RCVBUF set to %d",
sobuf_size));
}
}
}
if (turn_sock->setting.so_sndbuf_size > 0) {
unsigned sobuf_size = turn_sock->setting.so_sndbuf_size;
status = pj_sock_setsockopt_sobuf(sock, pj_SO_SNDBUF(),
PJ_TRUE, &sobuf_size);
if (status != PJ_SUCCESS) {
pj_perror(3, turn_sock->obj_name, status,
"Failed setting SO_SNDBUF");
} else {
if (sobuf_size < turn_sock->setting.so_sndbuf_size) {
PJ_LOG(4, (turn_sock->obj_name,
"Warning! Cannot set SO_SNDBUF as configured,"
" now=%d, configured=%d", sobuf_size,
turn_sock->setting.so_sndbuf_size));
} else {
PJ_LOG(5, (turn_sock->obj_name, "SO_SNDBUF set to %d",
sobuf_size));
}
}
}
/* Create active socket */
pj_activesock_cfg_default(&asock_cfg);
asock_cfg.grp_lock = turn_sock->grp_lock;
pj_bzero(&asock_cb, sizeof(asock_cb));
asock_cb.on_data_read = &on_data_read;
asock_cb.on_connect_complete = &on_connect_complete;
status = pj_activesock_create(turn_sock->pool, sock,
sock_type, &asock_cfg,
turn_sock->cfg.ioqueue, &asock_cb,
turn_sock,
&turn_sock->active_sock);
if (status != PJ_SUCCESS) {
pj_turn_sock_destroy(turn_sock);
return;
}
PJ_LOG(5,(turn_sock->pool->obj_name,
"Connecting to %s",
pj_sockaddr_print(&info.server, addrtxt,
sizeof(addrtxt), 3)));
/* Initiate non-blocking connect */
#if PJ_HAS_TCP
status=pj_activesock_start_connect(turn_sock->active_sock,
turn_sock->pool,
&info.server,
pj_sockaddr_get_len(&info.server));
if (status == PJ_SUCCESS) {
on_connect_complete(turn_sock->active_sock, PJ_SUCCESS);
} else if (status != PJ_EPENDING) {
pj_perror(3, turn_sock->pool->obj_name, status,
"Failed to connect to %s",
pj_sockaddr_print(&info.server, addrtxt,
sizeof(addrtxt), 3));
pj_turn_sock_destroy(turn_sock);
return;
}
#else
on_connect_complete(turn_sock->active_sock, PJ_SUCCESS);
#endif
/* Done for now. Subsequent work will be done in
* on_connect_complete() callback.
*/
}
if (new_state >= PJ_TURN_STATE_DESTROYING && turn_sock->sess) {
pj_time_val delay = {0, 0};
turn_sock->sess = NULL;
pj_turn_session_set_user_data(sess, NULL);
pj_timer_heap_cancel_if_active(turn_sock->cfg.timer_heap,
&turn_sock->timer, 0);
pj_timer_heap_schedule_w_grp_lock(turn_sock->cfg.timer_heap,
&turn_sock->timer,
&delay, TIMER_DESTROY,
turn_sock->grp_lock);
}
}
/*
* Callback from TURN session when state has changed
*/
static void turn_on_state(pj_turn_session *sess,
pj_turn_state_t old_state,
pj_turn_state_t new_state)
{
pj_turn_sock *turn_sock = (pj_turn_sock*)
pj_turn_session_get_user_data(sess);
pj_status_t status;
if (turn_sock == NULL) {
/* We've been destroyed */
return;
}
/* Notify app first */
if (turn_sock->cb.on_state) {
(*turn_sock->cb.on_state)(turn_sock, old_state, new_state);
}
/* Make sure user hasn't destroyed us in the callback */
if (turn_sock->sess && new_state == PJ_TURN_STATE_RESOLVED) {
pj_turn_session_info info;
pj_turn_session_get_info(turn_sock->sess, &info);
new_state = info.state;
}
if (turn_sock->sess && new_state == PJ_TURN_STATE_RESOLVED) {
/*
* Once server has been resolved, initiate outgoing TCP
* connection to the server.
*/
pj_turn_session_info info;
char addrtxt[PJ_INET6_ADDRSTRLEN+8];
int sock_type;
pj_sock_t sock;
pj_activesock_cb asock_cb;
/* Close existing connection, if any. This happens when
* we're switching to alternate TURN server when either TCP
* connection or ALLOCATE request failed.
*/
if (turn_sock->active_sock) {
pj_activesock_close(turn_sock->active_sock);
turn_sock->active_sock = NULL;
}
/* Get server address from session info */
pj_turn_session_get_info(sess, &info);
if (turn_sock->conn_type == PJ_TURN_TP_UDP)
sock_type = pj_SOCK_DGRAM();
else
sock_type = pj_SOCK_STREAM();
/* Init socket */
status = pj_sock_socket(turn_sock->af, sock_type, 0, &sock);
if (status != PJ_SUCCESS) {
pj_turn_sock_destroy(turn_sock);
return;
}
/* Apply QoS, if specified */
status = pj_sock_apply_qos2(sock, turn_sock->setting.qos_type,
&turn_sock->setting.qos_params,
(turn_sock->setting.qos_ignore_error?2:1),
turn_sock->pool->obj_name, NULL);
if (status != PJ_SUCCESS && !turn_sock->setting.qos_ignore_error) {
pj_turn_sock_destroy(turn_sock);
return;
}
/* Create active socket */
pj_bzero(&asock_cb, sizeof(asock_cb));
asock_cb.on_data_read = &on_data_read;
asock_cb.on_connect_complete = &on_connect_complete;
status = pj_activesock_create(turn_sock->pool, sock,
sock_type, NULL,
turn_sock->cfg.ioqueue, &asock_cb,
turn_sock,
&turn_sock->active_sock);
if (status != PJ_SUCCESS) {
pj_turn_sock_destroy(turn_sock);
return;
}
PJ_LOG(5,(turn_sock->pool->obj_name,
"Connecting to %s",
pj_sockaddr_print(&info.server, addrtxt,
sizeof(addrtxt), 3)));
/* Initiate non-blocking connect */
#if PJ_HAS_TCP
status=pj_activesock_start_connect(turn_sock->active_sock,
turn_sock->pool,
&info.server,
pj_sockaddr_get_len(&info.server));
if (status == PJ_SUCCESS) {
on_connect_complete(turn_sock->active_sock, PJ_SUCCESS);
} else if (status != PJ_EPENDING) {
pj_turn_sock_destroy(turn_sock);
return;
}
#else
on_connect_complete(turn_sock->active_sock, PJ_SUCCESS);
#endif
/* Done for now. Subsequent work will be done in
* on_connect_complete() callback.
*/
}
if (new_state >= PJ_TURN_STATE_DESTROYING && turn_sock->sess) {
pj_time_val delay = {0, 0};
turn_sock->sess = NULL;
pj_turn_session_set_user_data(sess, NULL);
if (turn_sock->timer.id) {
pj_timer_heap_cancel(turn_sock->cfg.timer_heap, &turn_sock->timer);
turn_sock->timer.id = 0;
}
turn_sock->timer.id = TIMER_DESTROY;
pj_timer_heap_schedule(turn_sock->cfg.timer_heap, &turn_sock->timer,
&delay);
}
}
/*
* Common function to create TCP transport, called when pending accept() and
* pending connect() complete.
*/
static pj_status_t tcp_create( struct tcp_listener *listener,
pj_pool_t *pool,
pj_sock_t sock, pj_bool_t is_server,
const pj_sockaddr *local,
const pj_sockaddr *remote,
struct tcp_transport **p_tcp)
{
struct tcp_transport *tcp;
pj_ioqueue_t *ioqueue;
pj_activesock_cfg asock_cfg;
pj_activesock_cb tcp_callback;
const pj_str_t ka_pkt = PJSIP_TCP_KEEP_ALIVE_DATA;
char print_addr[PJ_INET6_ADDRSTRLEN+10];
pj_status_t status;
PJ_ASSERT_RETURN(sock != PJ_INVALID_SOCKET, PJ_EINVAL);
if (pool == NULL) {
pool = pjsip_endpt_create_pool(listener->endpt, "tcp",
POOL_TP_INIT, POOL_TP_INC);
PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
}
/*
* Create and initialize basic transport structure.
*/
tcp = PJ_POOL_ZALLOC_T(pool, struct tcp_transport);
tcp->is_server = is_server;
tcp->sock = sock;
/*tcp->listener = listener;*/
pj_list_init(&tcp->delayed_list);
tcp->base.pool = pool;
pj_ansi_snprintf(tcp->base.obj_name, PJ_MAX_OBJ_NAME,
(is_server ? "tcps%p" :"tcpc%p"), tcp);
status = pj_atomic_create(pool, 0, &tcp->base.ref_cnt);
if (status != PJ_SUCCESS) {
goto on_error;
}
status = pj_lock_create_recursive_mutex(pool, "tcp", &tcp->base.lock);
if (status != PJ_SUCCESS) {
goto on_error;
}
tcp->base.key.type = listener->factory.type;
pj_sockaddr_cp(&tcp->base.key.rem_addr, remote);
tcp->base.type_name = (char*)pjsip_transport_get_type_name(
(pjsip_transport_type_e)tcp->base.key.type);
tcp->base.flag = pjsip_transport_get_flag_from_type(
(pjsip_transport_type_e)tcp->base.key.type);
tcp->base.info = (char*) pj_pool_alloc(pool, 64);
pj_ansi_snprintf(tcp->base.info, 64, "%s to %s",
tcp->base.type_name,
pj_sockaddr_print(remote, print_addr,
sizeof(print_addr), 3));
tcp->base.addr_len = pj_sockaddr_get_len(remote);
pj_sockaddr_cp(&tcp->base.local_addr, local);
sockaddr_to_host_port(pool, &tcp->base.local_name, local);
sockaddr_to_host_port(pool, &tcp->base.remote_name, remote);
tcp->base.dir = is_server? PJSIP_TP_DIR_INCOMING : PJSIP_TP_DIR_OUTGOING;
tcp->base.endpt = listener->endpt;
tcp->base.tpmgr = listener->tpmgr;
tcp->base.send_msg = &tcp_send_msg;
tcp->base.do_shutdown = &tcp_shutdown;
tcp->base.destroy = &tcp_destroy_transport;
/* Create group lock */
status = pj_grp_lock_create(pool, NULL, &tcp->grp_lock);
if (status != PJ_SUCCESS)
goto on_error;
pj_grp_lock_add_ref(tcp->grp_lock);
pj_grp_lock_add_handler(tcp->grp_lock, pool, tcp, &tcp_on_destroy);
/* Create active socket */
pj_activesock_cfg_default(&asock_cfg);
asock_cfg.async_cnt = 1;
asock_cfg.grp_lock = tcp->grp_lock;
pj_bzero(&tcp_callback, sizeof(tcp_callback));
tcp_callback.on_data_read = &on_data_read;
tcp_callback.on_data_sent = &on_data_sent;
tcp_callback.on_connect_complete = &on_connect_complete;
ioqueue = pjsip_endpt_get_ioqueue(listener->endpt);
status = pj_activesock_create(pool, sock, pj_SOCK_STREAM(), &asock_cfg,
ioqueue, &tcp_callback, tcp, &tcp->asock);
if (status != PJ_SUCCESS) {
goto on_error;
}
/* Register transport to transport manager */
status = pjsip_transport_register(listener->tpmgr, &tcp->base);
if (status != PJ_SUCCESS) {
goto on_error;
}
tcp->is_registered = PJ_TRUE;
/* Initialize keep-alive timer */
tcp->ka_timer.user_data = (void*)tcp;
tcp->ka_timer.cb = &tcp_keep_alive_timer;
pj_ioqueue_op_key_init(&tcp->ka_op_key.key, sizeof(pj_ioqueue_op_key_t));
pj_strdup(tcp->base.pool, &tcp->ka_pkt, &ka_pkt);
/* Done setting up basic transport. */
*p_tcp = tcp;
PJ_LOG(4,(tcp->base.obj_name, "TCP %s transport created",
(tcp->is_server ? "server" : "client")));
return PJ_SUCCESS;
on_error:
tcp_destroy(&tcp->base, status);
return status;
}
/*
* sock_producer_consumer()
*
* Simple producer-consumer benchmarking. Send loop number of
* buf_size size packets as fast as possible.
*/
static int sock_producer_consumer(int sock_type,
unsigned buf_size,
unsigned loop,
unsigned *p_bandwidth)
{
pj_sock_t consumer, producer;
pj_pool_t *pool;
char *outgoing_buffer, *incoming_buffer;
pj_timestamp start, stop;
unsigned i;
pj_highprec_t elapsed, bandwidth;
pj_size_t total_received;
pj_status_t rc;
/* Create pool. */
pool = pj_pool_create(mem, NULL, 4096, 4096, NULL);
if (!pool)
return -10;
/* Create producer-consumer pair. */
rc = app_socketpair(pj_AF_INET(), sock_type, 0, &consumer, &producer);
if (rc != PJ_SUCCESS) {
app_perror("...error: create socket pair", rc);
return -20;
}
/* Create buffers. */
outgoing_buffer = (char*) pj_pool_alloc(pool, buf_size);
incoming_buffer = (char*) pj_pool_alloc(pool, buf_size);
/* Start loop. */
pj_get_timestamp(&start);
total_received = 0;
for (i=0; i<loop; ++i) {
pj_ssize_t sent, part_received, received;
pj_time_val delay;
sent = buf_size;
rc = pj_sock_send(producer, outgoing_buffer, &sent, 0);
if (rc != PJ_SUCCESS || sent != (pj_ssize_t)buf_size) {
app_perror("...error: send()", rc);
return -61;
}
/* Repeat recv() until all data is part_received.
* This applies only for non-UDP of course, since for UDP
* we would expect all data to be part_received in one packet.
*/
received = 0;
do {
part_received = buf_size-received;
rc = pj_sock_recv(consumer, incoming_buffer+received,
&part_received, 0);
if (rc != PJ_SUCCESS) {
app_perror("...recv error", rc);
return -70;
}
if (part_received <= 0) {
PJ_LOG(3,("", "...error: socket has closed (part_received=%d)!",
part_received));
return -73;
}
if ((pj_size_t)part_received != buf_size-received) {
if (sock_type != pj_SOCK_STREAM()) {
PJ_LOG(3,("", "...error: expecting %u bytes, got %u bytes",
buf_size-received, part_received));
return -76;
}
}
received += part_received;
} while ((pj_size_t)received < buf_size);
total_received += received;
/* Stop test if it's been runnign for more than 10 secs. */
pj_get_timestamp(&stop);
delay = pj_elapsed_time(&start, &stop);
if (delay.sec > 10)
break;
}
/* Stop timer. */
pj_get_timestamp(&stop);
elapsed = pj_elapsed_usec(&start, &stop);
/* bandwidth = total_received * 1000 / elapsed */
bandwidth = total_received;
pj_highprec_mul(bandwidth, 1000);
pj_highprec_div(bandwidth, elapsed);
*p_bandwidth = (pj_uint32_t)bandwidth;
/* Close sockets. */
pj_sock_close(consumer);
pj_sock_close(producer);
/* Done */
pj_pool_release(pool);
return 0;
}