int HttpConnector::Update(int timeout)
{
int ret = -1 ;
char buf[1024*32] ;
if (!CheckValid() ) {
m_recvRequest->setStatus(-1) ;
m_recvRequest->OnEnd() ;
return -1 ;
}
ndtime_t start = nd_time() ;
int lefttime = timeout ;
do {
int size = Recv(buf, sizeof(buf), lefttime) ;
if (size <=0){
break ;
}
m_recvRequest->InData(buf, size) ;
if (m_recvRequest->CheckRecvOk()) {
ret = 0;
break ;
}
lefttime -= nd_time() - start ;
start = nd_time() ;
}while (lefttime > 0);
if (ret ==-1 ) {
m_recvRequest->setStatus(-1) ;
}
m_recvRequest->OnEnd() ;
return ret;
}
//connect remote host
int nd_tcpnode_connect(const char *host, int port, struct nd_tcp_node *node, struct nd_proxy_info *proxy)
{
ENTER_FUNC()
nd_assert(node);
nd_assert(host);
node->sys_error = 0;
node->last_push = nd_time();
ndlbuf_reset(&(node->recv_buffer)); /* buffer store data recv from net */
ndlbuf_reset(&(node->send_buffer)); /* buffer store data send from net */
if (proxy && proxy->proxy_type != ND_PROXY_NOPROXY) {
node->fd = nd_proxy_connect(host, port, &(node->remote_addr), proxy, 0);
}
else {
node->fd = nd_socket_tcp_connect(host, (short)port, &(node->remote_addr));
}
if (node->fd <= 0) {
node->myerrno = NDERR_OPENFILE;
LEAVE_FUNC();
return -1;
}
TCPNODE_SET_OK(node);
nd_socket_nonblock(node->fd, 1);
_set_ndtcp_conn_dft_option(node->fd);
node->start_time = nd_time();
if (node->remote_addr.sin_family == AF_INET6) {
node->is_ipv6 = 1;
}
LEAVE_FUNC();
return 0;
}
//#include "nd_crypt/nd_crypt.h"
int _sys_socket_write(struct nd_tcp_node *node,void *data , size_t len)
{
ENTER_FUNC();
int ret ;
ret = (int) send(node->fd, data, len, 0) ;
if(ret > 0) {
//char md5[33];
//ndfprintf(stderr, "!!!!!----- send data %d, return length =%d md5 = %s\n", len, ret, MD5Crypt32(data, ret, md5));
node->send_len += ret;
node->last_push = nd_time();
}
else if(-1==ret) {
node->sys_error = nd_socket_last_error() ;
if (node->sys_error == ESOCKETTIMEOUT) {
node->myerrno = NDERR_WOULD_BLOCK;
}
else {
node->myerrno = NDERR_IO ;
}
}
else if(ret == 0 ) {
node->myerrno = NDERR_WOULD_BLOCK;
}
LEAVE_FUNC();
return ret ;
};
int _log_net_stream(const char *fileName, void *data, int size)
{
FILE *fp = fopen(fileName, "a") ;
if (!fp) {
return -1 ;
}
NDUINT32 now = nd_time() ;
NDUINT16 mark = ND_STREAM_MESSAGE_START ;
fwrite(&mark, sizeof(mark), 1, fp) ;
//write time
fwrite(&now, sizeof(now), 1, fp) ;
//data size
mark = size ;
fwrite(&mark, sizeof(mark), 1, fp) ;
//WRITE data
fwrite(data, size, 1, fp) ;
mark = ND_STREAM_MESSAGE_END ;
fwrite(&mark, sizeof(mark), 1, fp) ;
fflush(fp) ;
fclose(fp) ;
return 0;
}
int ndSendAndWaitMessage(nd_handle nethandle, nd_usermsgbuf_t *sendBuf, nd_usermsgbuf_t* recvBuf, ndmsgid_t waitMaxid, ndmsgid_t waitMinid, int sendFlag, int timeout)
{
if (nd_connector_send(nethandle, (nd_packhdr_t*)sendBuf, sendFlag) <= 0) {
nd_object_seterror(nethandle, NDERR_WRITE);
nd_logerror("send data error: NDERR_WRITE\n");
return -1;
}
ndtime_t start_tm = nd_time();
RE_RECV:
if (-1 == nd_connector_waitmsg(nethandle, (nd_packetbuf_t *)recvBuf, timeout)) {
nd_object_seterror(nethandle, NDERR_TIMEOUT);
nd_logerror("wait message timeout\n");
return -1;
}
else if (recvBuf->msg_hdr.packet_hdr.ndsys_msg){
if (-1 == nd_net_sysmsg_hander((nd_netui_handle)nethandle, (nd_sysresv_pack_t *)recvBuf)){
nd_logerror("receive system mesaage and handler error \n");
return -1;
}
}
else if (nd_checkErrorMsg(nethandle, (struct ndMsgData*)recvBuf)) {
nd_logerror("receive error message \n");
return -1;
}
else if (ND_USERMSG_MAXID(recvBuf) != waitMaxid || ND_USERMSG_MINID(recvBuf) != waitMinid) {
if ((nd_time() - start_tm) >= timeout) {
nd_object_seterror(nethandle, NDERR_TIMEOUT);
nd_logerror("wait message(%d,%d) timeout\n", waitMaxid, waitMinid);
return -1;
}
if (((nd_netui_handle)nethandle)->msg_handle) {
//int ret = nd_translate_message(nethandle, (nd_packhdr_t*)recvBuf, NULL);
int ret = _packet_handler((nd_netui_handle)nethandle, &recvBuf->msg_hdr.packet_hdr, NULL);
if (ret == -1){
nd_logerror("wait message(%d,%d) error ,recvd(%d,%d)\n", waitMaxid, waitMinid, ND_USERMSG_MAXID(recvBuf), ND_USERMSG_MINID(recvBuf));
return ret;
}
}
goto RE_RECV;
}
return 0;
}
void udp_node_init(struct nd_udp_node* node)
{
nd_assert(node) ;
memset(node, 0, sizeof(*node)) ;
node->type = NDHANDLE_UDPNODE ;
node->size = sizeof(struct nd_udp_node) ;
node->sock_write = (socket_write_entry) nd_udp_send ;
node->close_entry = (nd_close_callback) nd_udp_close;
node->sock_read = (socket_read_entry)nd_udp_read;
node->status = ETS_DEAD; /*socket state in game 0 not read 1 ready*/
node->protocol = PROTOCOL_OTHER;
node->sock_type = SOCK_DGRAM ;
node->start_time =nd_time() ;
node->last_push = nd_time() ;
node->disconn_timeout = ND_DFT_DISSCONN_TIMEOUT ;
node->msg_caller = node;
init_crypt_key(&node->crypt_key);
nd_net_connbuf_init((struct netui_info*)node) ;
}
int nd_udp_send(struct nd_udp_node*node,const char *data, size_t len)
{
int ret =0;
ret = nd_socket_udp_write(node->fd, data, len, &node->remote_addr);
if(ret > 0){
node->last_push = nd_time() ;
node->send_len += len ;
}
else if(-1==ret) {
if(ESOCKETTIMEOUT==nd_last_errno())
node->myerrno = NDERR_WOULD_BLOCK;
else
node->myerrno = NDERR_WRITE ;
}
return ret;
}
//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 ;
}
