int connection_t::on_recv_data()
{
LOGTRACE((CONNECTION_MODULE, "connection_t::on_recv_data begin"));
if (m_enable_hb)
{
m_service_ptr->async_update_hb_element(m_conn_id);
}
int recv_ret = 0;
int ret = m_read_buffer.recv_to_buffer(m_socket, recv_ret);
if (-1 == ret)
{
//! yunjie: 内存分配失败, 必须回调callback, 否则buffer满了将陷入死循环
LOGWARN((CONNECTION_MODULE, "connection_t::on_recv_data recv_to_buffer failed socket fd:[%u] read buf data size:[%u]",
m_socket,
m_read_buffer.size()
));
on_read_complete(m_read_buffer);
return 0;
}
if (0 == recv_ret)
{
LOGWARN((CONNECTION_MODULE, "connection_t::on_recv_data recv_ret == 0 socket fd:[%u]", m_socket));
async_close(m_conn_id, true, EV_PASSIVE_CLOSED);
return 0;
}
else if (recv_ret < 0)
{
//! yunjie: 如果不是EAGAIN或EINTR, 那么就调用callback返回错误信息
if (errno != EAGAIN && errno != EINTR)
{
if (NULL != m_conn_event_callback)
{
m_conn_event_callback(EV_ERROR_OCCURRED, m_conn_status, m_conn_id, m_user_data);
}
}
LOGWARN((CONNECTION_MODULE, "connection_t::on_recv_data recv_ret:[%d] socket fd:[%u] errno:[%s]", recv_ret, m_socket, STRERR));
return 0;
}
else
{
//! yunjie: 使用者可以实现的虚方法
on_read_complete(m_read_buffer);
}
LOGTRACE((CONNECTION_MODULE, "connection_t::on_recv_data end"));
return 0;
}
static void on_write_complete(pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
pj_ssize_t bytes_sent)
{
struct op_key *send_rec = (struct op_key*)op_key;
if (bytes_sent <= 0) {
pj_status_t rc = (pj_status_t)-bytes_sent;
if (rc != send_rec->last_err) {
send_rec->last_err = rc;
app_perror("...send error(2)", rc);
}
}
send_rec->is_pending = 0;
on_read_complete(key, &send_rec->peer->op_key_, 0);
}
static int worker_thread(void *arg)
{
pj_ioqueue_t *ioqueue = (pj_ioqueue_t*) arg;
struct op_key read_op, write_op;
char recv_buf[512], send_buf[512];
pj_ssize_t length;
pj_status_t rc;
read_op.peer = &write_op;
read_op.is_pending = 0;
read_op.last_err = 0;
read_op.buffer = recv_buf;
read_op.size = sizeof(recv_buf);
read_op.addrlen = sizeof(read_op.addr);
write_op.peer = &read_op;
write_op.is_pending = 0;
write_op.last_err = 0;
write_op.buffer = send_buf;
write_op.size = sizeof(send_buf);
length = sizeof(recv_buf);
rc = pj_ioqueue_recvfrom(key, &read_op.op_key_, recv_buf, &length, 0,
&read_op.addr, &read_op.addrlen);
if (rc == PJ_SUCCESS) {
read_op.is_pending = 1;
on_read_complete(key, &read_op.op_key_, length);
}
while (!thread_quit_flag) {
pj_time_val timeout;
timeout.sec = 0; timeout.msec = 10;
rc = pj_ioqueue_poll(ioqueue, &timeout);
}
return 0;
}
pj_status_t pj_stun_detect_nat_type(const pj_sockaddr_in *server,
pj_stun_config *stun_cfg,
void *user_data,
pj_stun_nat_detect_cb *cb)
{
pj_pool_t *pool;
nat_detect_session *sess;
pj_stun_session_cb sess_cb;
pj_ioqueue_callback ioqueue_cb;
int addr_len;
pj_status_t status;
PJ_ASSERT_RETURN(server && stun_cfg, PJ_EINVAL);
PJ_ASSERT_RETURN(stun_cfg->pf && stun_cfg->ioqueue && stun_cfg->timer_heap,
PJ_EINVAL);
/*
* Init NAT detection session.
*/
pool = pj_pool_create(stun_cfg->pf, "natck%p", PJNATH_POOL_LEN_NATCK,
PJNATH_POOL_INC_NATCK, NULL);
if (!pool)
return PJ_ENOMEM;
sess = PJ_POOL_ZALLOC_T(pool, nat_detect_session);
sess->pool = pool;
sess->user_data = user_data;
sess->cb = cb;
status = pj_grp_lock_create(pool, NULL, &sess->grp_lock);
if (status != PJ_SUCCESS) {
/* Group lock not created yet, just destroy pool and return */
pj_pool_release(pool);
return status;
}
pj_grp_lock_add_ref(sess->grp_lock);
pj_grp_lock_add_handler(sess->grp_lock, pool, sess, &sess_on_destroy);
pj_memcpy(&sess->server, server, sizeof(pj_sockaddr_in));
/*
* Init timer to self-destroy.
*/
sess->timer_heap = stun_cfg->timer_heap;
sess->timer.cb = &on_sess_timer;
sess->timer.user_data = sess;
/*
* Initialize socket.
*/
status = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &sess->sock);
if (status != PJ_SUCCESS)
goto on_error;
/*
* Bind to any.
*/
pj_bzero(&sess->local_addr, sizeof(pj_sockaddr_in));
sess->local_addr.sin_family = pj_AF_INET();
status = pj_sock_bind(sess->sock, &sess->local_addr,
sizeof(pj_sockaddr_in));
if (status != PJ_SUCCESS)
goto on_error;
/*
* Get local/bound address.
*/
addr_len = sizeof(sess->local_addr);
status = pj_sock_getsockname(sess->sock, &sess->local_addr, &addr_len);
if (status != PJ_SUCCESS)
goto on_error;
/*
* Find out which interface is used to send to the server.
*/
status = get_local_interface(server, &sess->local_addr.sin_addr);
if (status != PJ_SUCCESS)
goto on_error;
PJ_LOG(5,(sess->pool->obj_name, "Local address is %s:%d",
pj_inet_ntoa(sess->local_addr.sin_addr),
pj_ntohs(sess->local_addr.sin_port)));
PJ_LOG(5,(sess->pool->obj_name, "Server set to %s:%d",
pj_inet_ntoa(server->sin_addr),
pj_ntohs(server->sin_port)));
/*
* Register socket to ioqueue to receive asynchronous input
* notification.
*/
pj_bzero(&ioqueue_cb, sizeof(ioqueue_cb));
ioqueue_cb.on_read_complete = &on_read_complete;
status = pj_ioqueue_register_sock2(sess->pool, stun_cfg->ioqueue,
sess->sock, sess->grp_lock, sess,
&ioqueue_cb, &sess->key);
if (status != PJ_SUCCESS)
goto on_error;
/*
* Create STUN session.
*/
pj_bzero(&sess_cb, sizeof(sess_cb));
sess_cb.on_request_complete = &on_request_complete;
sess_cb.on_send_msg = &on_send_msg;
status = pj_stun_session_create(stun_cfg, pool->obj_name, &sess_cb,
PJ_FALSE, sess->grp_lock, &sess->stun_sess);
if (status != PJ_SUCCESS)
goto on_error;
pj_stun_session_set_user_data(sess->stun_sess, sess);
/*
* Kick-off ioqueue reading.
*/
pj_ioqueue_op_key_init(&sess->read_op, sizeof(sess->read_op));
pj_ioqueue_op_key_init(&sess->write_op, sizeof(sess->write_op));
on_read_complete(sess->key, &sess->read_op, 0);
/*
* Start TEST_1
*/
sess->timer.id = TIMER_TEST;
on_sess_timer(stun_cfg->timer_heap, &sess->timer);
return PJ_SUCCESS;
on_error:
sess_destroy(sess);
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)
{
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;
}
/*
* Create a new listener on the specified port.
*/
PJ_DEF(pj_status_t) pj_turn_listener_create_udp( pj_turn_srv *srv,
int af,
const pj_str_t *bound_addr,
unsigned port,
unsigned concurrency_cnt,
unsigned flags,
pj_turn_listener **p_listener)
{
pj_pool_t *pool;
struct udp_listener *udp;
pj_ioqueue_callback ioqueue_cb;
unsigned i;
pj_status_t status;
/* Create structure */
pool = pj_pool_create(srv->core.pf, "udp%p", 1000, 1000, NULL);
udp = PJ_POOL_ZALLOC_T(pool, struct udp_listener);
udp->base.pool = pool;
udp->base.obj_name = pool->obj_name;
udp->base.server = srv;
udp->base.tp_type = PJ_TURN_TP_UDP;
udp->base.sock = PJ_INVALID_SOCKET;
udp->base.destroy = &udp_destroy;
udp->read_cnt = concurrency_cnt;
udp->base.flags = flags;
udp->tp.obj_name = udp->base.obj_name;
udp->tp.info = udp->base.info;
udp->tp.listener = &udp->base;
udp->tp.sendto = &udp_sendto;
udp->tp.add_ref = &udp_add_ref;
udp->tp.dec_ref = &udp_dec_ref;
/* Create socket */
status = pj_sock_socket(af, pj_SOCK_DGRAM(), 0, &udp->base.sock);
if (status != PJ_SUCCESS)
goto on_error;
/* Init bind address */
status = pj_sockaddr_init(af, &udp->base.addr, bound_addr,
(pj_uint16_t)port);
if (status != PJ_SUCCESS)
goto on_error;
/* Create info */
pj_ansi_strcpy(udp->base.info, "UDP:");
pj_sockaddr_print(&udp->base.addr, udp->base.info+4,
sizeof(udp->base.info)-4, 3);
/* Bind socket */
status = pj_sock_bind(udp->base.sock, &udp->base.addr,
pj_sockaddr_get_len(&udp->base.addr));
if (status != PJ_SUCCESS)
goto on_error;
/* Register to ioqueue */
pj_bzero(&ioqueue_cb, sizeof(ioqueue_cb));
ioqueue_cb.on_read_complete = on_read_complete;
status = pj_ioqueue_register_sock(pool, srv->core.ioqueue, udp->base.sock,
udp, &ioqueue_cb, &udp->key);
/* Create op keys */
udp->read_op = (struct read_op**)pj_pool_calloc(pool, concurrency_cnt,
sizeof(struct read_op*));
/* Create each read_op and kick off read operation */
for (i=0; i<concurrency_cnt; ++i) {
pj_pool_t *rpool = pj_pool_create(srv->core.pf, "rop%p",
1000, 1000, NULL);
udp->read_op[i] = PJ_POOL_ZALLOC_T(pool, struct read_op);
udp->read_op[i]->pkt.pool = rpool;
on_read_complete(udp->key, &udp->read_op[i]->op_key, 0);
}
/* Done */
PJ_LOG(4,(udp->base.obj_name, "Listener %s created", udp->base.info));
*p_listener = &udp->base;
return PJ_SUCCESS;
on_error:
udp_destroy(&udp->base);
return status;
}
