//read udp socket data
int nd_udp_read(struct nd_udp_node*node , char *buf, size_t buf_size, ndtime_t outval)
{
int ret ;
int readlen = 0;
nd_assert(buf && buf_size>0);
TCPNODE_READ_AGAIN(node) = 0;
if(outval ) {
ret = nd_socket_wait_read(node->fd, outval) ;
if(ret <= 0) {
node->myerrno = (ret == 0) ? NDERR_WOULD_BLOCK: NDERR_IO;
return ret ;
}
}
readlen = nd_socket_udp_read(node->fd, buf, (int)buf_size, &node->last_read);
if (-1 == readlen) {
node->sys_error = nd_socket_last_error();
if (node->sys_error == ESOCKETTIMEOUT) {
node->myerrno = NDERR_WOULD_BLOCK;
return 0;
}
else {
node->myerrno = NDERR_READ;
nd_logdebug("recvfrom : %s\n", nd_last_error());
return -1;
}
}
TCPNODE_READ_AGAIN(node) = 1;
node->last_recv = nd_time();
node->recv_len += readlen;
return readlen ;
}
/*deal with received net message
* return 0 connect closed
* return -1 nothing to be done
* else return received data length
*/
NEINT32 ne_do_netmsg(struct ne_client_map *cli_map,struct ne_srv_node *srv_node)
{
NEINT32 read_len,ret = 0;
ne_assert(cli_map) ;
ne_assert(check_connect_valid(& (cli_map->connect_node))) ;
// ne_assert(cli_map->status != ESC_CLOSED ) ;
RE_READ:
read_len = ne_tcpnode_read(& (cli_map->connect_node)) ;
if(read_len == 0) {
NE_CLOSE_REASON(cli_map) = ECR_READOVER ;
return 0 ;
}
else if(-1== read_len) {
if(cli_map->connect_node.myerrno==NEERR_WUOLD_BLOCK) {
return -1 ;
}
else {
NE_CLOSE_REASON(cli_map) = ECR_SOCKETERROR ;
return 0 ; //need closed
}
}
else {
ret += read_len ;
if(-1 == tcpnode_parse_recv_msgex(&(cli_map->connect_node), srv_stream_data_entry, (void*)srv_node) ){
return 0 ;
}
if(TCPNODE_READ_AGAIN(&(cli_map->connect_node))) {
/*read buf is to small , after parse data , read again*/
/*read_len = ne_tcpnode_read(& (cli_map->connect_node)) ;
if(read_len>0){
//NE_RUN_HERE();
ret += read_len ;
}*/
goto RE_READ;
/*else if(0==read_len){
return 0;
}*/
}
}
return ret ;
}
/* 更新客户端的网络连接 */
NEINT32 ne_connector_update(ne_netui_handle net_handle,netime_t timeout)
{
NEINT32 ret =0;
ne_assert(net_handle ) ;
if(net_handle->nodetype==NE_TCP){
NEINT32 read_len ;
//把tcp的流式协议变成消息模式
struct ne_tcp_node *socket_node = (struct ne_tcp_node *) net_handle ;
socket_node->myerrno = NEERR_SUCCESS ;
//首先清空发送缓冲
if(0==ne_tcpnode_trytolock(socket_node)) {
ne_tcpnode_flush_sendbuf(socket_node) ;
ne_tcpnode_unlock(socket_node) ;
}
if(timeout) {
ret = ne_socket_wait_read(socket_node->fd,timeout) ;
if(ret<=0)
return ret ;
}
RE_READ:
read_len = ne_tcpnode_read(socket_node) ;
if(read_len<=0) {
if(socket_node->myerrno==NEERR_WUOLD_BLOCK) {
return 0 ;
}
return read_len ;
}
else {
ret += read_len ;
if(-1==tcpnode_parse_recv_msgex(socket_node,stream_data_entry, NULL) ){
//ne_tcpnode_close(socket_node,1) ;
return -1 ;
}
if(TCPNODE_READ_AGAIN(socket_node)) {
/*read buf is to small , after parse data , read again*/
goto RE_READ;
}
}
}
else if(net_handle->nodetype==NE_UDT) {
ne_udt_node *socket_addr =(ne_udt_node *) net_handle ;
udt_pocketbuf msg_buf ;
socket_addr->myerrno = NEERR_SUCCESS ;
if(-1==update_socket(socket_addr) )
return -1 ;
ret = _wait_data(socket_addr, &msg_buf,timeout) ;
if(ret <=0)
return ret;
if(PROTOCOL_UDP==POCKET_PROTOCOL(&(msg_buf.pocket))){
/*处理udp消息,提前过来消息*/
struct neudp_packet *packet = (struct neudp_packet *)&msg_buf ;
NEINT32 data_len = ret - sizeof(struct neudp_packet) ;
//if(packet->session_id!=socket_addr->session_id)
// return 0;
return _datagram_entry(socket_addr, packet, data_len,NULL) ;
}
if(socket_addr->is_datagram) {
//直接使用UDP的消息模式
//这里需要处理返回-1关闭连接
socket_addr->datagram_entry = _datagram_entry ;
socket_addr->callback_param = NULL ;
ret = udt_parse_rawpacket(socket_addr, &msg_buf, ret) ;
}
else {
//把udt的stream模式变成消息模式
//这里需要处理返回-1关闭连接
if(-1==udt_parse_rawpacket(socket_addr, &msg_buf, ret))
return -1 ;
ret = parse_udt_stream(socket_addr, stream_data_entry, NULL) ;
}
// update
if(-1==update_socket(socket_addr) )
return -1 ;
}
return ret;
}
