static pj_bool_t asock_on_connect_complete(pj_activesock_t *asock,
pj_status_t status)
{
struct test_state *st = (struct test_state*)
pj_activesock_get_user_data(asock);
if (status == PJ_SUCCESS) {
void *read_buf[1];
/* Start reading data */
read_buf[0] = st->read_buf;
status = pj_activesock_start_read2(asock, st->pool, sizeof(st->read_buf), (void**)read_buf, 0);
if (status != PJ_SUCCESS) {
app_perror("...ERROR pj_ssl_sock_start_read2()", status);
}
}
st->err = status;
if (st->err != PJ_SUCCESS) {
pj_activesock_close(asock);
if (!st->is_server)
clients_num--;
return PJ_FALSE;
}
return PJ_TRUE;
}
/*
* This utility function creates receive data buffers and start
* asynchronous recv() operations from the socket. It is called after
* accept() or connect() operation complete.
*/
static pj_status_t tcp_start_read(struct tcp_transport *tcp)
{
pj_pool_t *pool;
pj_ssize_t size;
pj_sockaddr *rem_addr;
void *readbuf[1];
pj_status_t status;
/* Init rdata */
pool = pjsip_endpt_create_pool(tcp->base.endpt,
"rtd%p",
PJSIP_POOL_RDATA_LEN,
PJSIP_POOL_RDATA_INC);
if (!pool) {
tcp_perror(tcp->base.obj_name, "Unable to create pool", PJ_ENOMEM);
return PJ_ENOMEM;
}
tcp->rdata.tp_info.pool = pool;
tcp->rdata.tp_info.transport = &tcp->base;
tcp->rdata.tp_info.tp_data = tcp;
tcp->rdata.tp_info.op_key.rdata = &tcp->rdata;
pj_ioqueue_op_key_init(&tcp->rdata.tp_info.op_key.op_key,
sizeof(pj_ioqueue_op_key_t));
tcp->rdata.pkt_info.src_addr = tcp->base.key.rem_addr;
tcp->rdata.pkt_info.src_addr_len = sizeof(tcp->rdata.pkt_info.src_addr);
rem_addr = &tcp->base.key.rem_addr;
pj_sockaddr_print(rem_addr, tcp->rdata.pkt_info.src_name,
sizeof(tcp->rdata.pkt_info.src_name), 0);
tcp->rdata.pkt_info.src_port = pj_sockaddr_get_port(rem_addr);
size = sizeof(tcp->rdata.pkt_info.packet);
readbuf[0] = tcp->rdata.pkt_info.packet;
status = pj_activesock_start_read2(tcp->asock, tcp->base.pool, size,
readbuf, 0);
if (status != PJ_SUCCESS && status != PJ_EPENDING) {
PJ_LOG(4, (tcp->base.obj_name,
"pj_activesock_start_read() error, status=%d",
status));
return status;
}
return PJ_SUCCESS;
}
PJ_DEF(pj_status_t) pj_activesock_start_read(pj_activesock_t *asock,
pj_pool_t *pool,
unsigned buff_size,
pj_uint32_t flags)
{
void **readbuf;
unsigned i;
PJ_ASSERT_RETURN(asock && pool && buff_size, PJ_EINVAL);
readbuf = (void**) pj_pool_calloc(pool, asock->async_count,
sizeof(void*));
for (i=0; i<asock->async_count; ++i) {
readbuf[i] = pj_pool_alloc(pool, buff_size);
}
return pj_activesock_start_read2(asock, pool, buff_size, readbuf, flags);
}
static pj_bool_t asock_on_accept_complete(pj_activesock_t *asock,
pj_sock_t newsock,
const pj_sockaddr_t *src_addr,
int src_addr_len)
{
struct test_state *st;
void *read_buf[1];
pj_activesock_t *new_asock;
pj_activesock_cb asock_cb = { 0 };
pj_status_t status;
PJ_UNUSED_ARG(src_addr);
PJ_UNUSED_ARG(src_addr_len);
st = (struct test_state*) pj_activesock_get_user_data(asock);
asock_cb.on_data_read = &asock_on_data_read;
status = pj_activesock_create(st->pool, newsock, pj_SOCK_STREAM(), NULL,
st->ioqueue, &asock_cb, st, &new_asock);
if (status != PJ_SUCCESS) {
goto on_return;
}
/* Start reading data */
read_buf[0] = st->read_buf;
status = pj_activesock_start_read2(new_asock, st->pool,
sizeof(st->read_buf),
(void**)read_buf, 0);
if (status != PJ_SUCCESS) {
app_perror("...ERROR pj_ssl_sock_start_read2()", status);
}
on_return:
st->err = status;
if (st->err != PJ_SUCCESS)
pj_activesock_close(new_asock);
return PJ_TRUE;
}
