static int net_getaddrinfo(Value *vret, Value *v, RefNode *node)
{
struct addrinfo *res = NULL;
struct addrinfo *ai;
RefArray *ra;
RefStr *rs = Value_vp(v[1]);
int err;
if (str_has0(rs->c, rs->size)) {
fs->throw_errorf(fs->mod_io, "SocketError", "No address found");
return FALSE;
}
err = getaddrinfo_sub(&res, rs->c, NULL, 0);
if (err != 0) {
throw_socket_error(err);
return FALSE;
}
ra = fs->refarray_new(0);
*vret = vp_Value(ra);
for (ai = res; ai != NULL; ai = ai->ai_next) {
Value *vt = fs->refarray_push(ra);
*vt = vp_Value(new_refsockaddr(ai->ai_addr, FALSE));
}
freeaddrinfo(res);
return TRUE;
}
/**
@fn void check_timeout_and_resend_data()
@detail 检查超时并重发数据
@param void
@return void
@note
*/
void line_socket::check_timeout_and_resend_data()
{
SOCKET_PACKAGE_SENT_PTR package = NULL;
std::list<SOCKET_PACKAGE_SENT_PTR>::iterator itr;
std::list<SOCKET_PACKAGE_SENT_PTR> tmp_queue;
sent_pack_queue_lock_.Lock();
itr = sent_pack_queue_.begin();
while( itr != sent_pack_queue_.end()) {
package = *itr;
if(package->counter_sent_ < MAX_RESEND_COUNTER) {
if(package->time_counter_ < MAX_TIME_COUNTER) {
++package->time_counter_;
}
else {
tmp_queue.push_back(package);
itr = sent_pack_queue_.erase(itr);
continue;
}
}
else {
if(package->cmd_ == CmdSetHeartBeat) {
sent_pack_queue_lock_.Unlock();
throw_socket_error(SOCKET_CLOSED);
Close();
return;
}
else {
sent_pack_queue_.erase(itr);
throw_socket_error(SOCKET_RESEND_ERROR);
break;
}
}
++itr;
}
sent_pack_queue_lock_.Unlock();
for(itr = tmp_queue.begin(); itr != tmp_queue.end(); ++itr) {
package = *itr;
push_back_wait_sending_queue(package);
}
}
static int ipaddrrange_new_sub(Value *vret, const char *ipaddr, const char *mask)
{
RefSockAddr *rsa = cstr_to_ipaddr(ipaddr, TRUE);
if (rsa == NULL) {
return FALSE;
}
if (mask == NULL || mask[0] == '\0') {
rsa->mask_bits = 128;
} else if (is_all_digit(mask)) {
long bits;
errno = 0;
bits = strtol(mask, NULL, 10);
if (errno == 0 && bits >= 0) {
rsa->mask_bits = bits;
}
} else {
struct addrinfo *ai = NULL;
int err = getaddrinfo_sub(&ai, mask, NULL, AI_NUMERICHOST);
if (err != 0) {
throw_socket_error(err);
return FALSE;
}
if (ai != NULL) {
rsa->mask_bits = get_mask_bit_count(sockaddr_bytes(ai->ai_addr), sockaddr_bytes_count(ai->ai_addr));
} else {
fs->throw_errorf(fs->mod_io, "SocketError", "No address found");
return FALSE;
}
freeaddrinfo(ai);
}
{
int max_bits = sockaddr_bytes_count(rsa->addr) * 8;
if (rsa->mask_bits > max_bits) {
rsa->mask_bits = max_bits;
}
}
*vret = vp_Value(rsa);
return TRUE;
}
static RefSockAddr *cstr_to_ipaddr(const char *hostname, int is_range)
{
RefSockAddr *rsa = NULL;
struct addrinfo *ai = NULL;
int err = getaddrinfo_sub(&ai, hostname, NULL, AI_NUMERICHOST);
if (err != 0) {
throw_socket_error(err);
return NULL;
}
if (ai != NULL) {
rsa = new_refsockaddr(ai->ai_addr, is_range);
} else {
fs->throw_errorf(fs->mod_io, "SocketError", "No address found");
return NULL;
}
freeaddrinfo(ai);
return rsa;
}
/**
@fn void OnReceive(int nErrorCode)
@detail 继承自CSocket
@note
*/
void line_socket::OnReceive(int nErrorCode)
{
int size = 0;
char frame_head[4] = {0x0};
int length = 0x0;
frame_head[0] = FrameHead1;
frame_head[1] = FrameHead2;
frame_head[2] = FrameHead3;
frame_head[3] = FrameHead4;
if(recv_package_.status_ == HEAD_RECV)
length = sizeof(frame_head);//CommFrame_Struct::m_cFrameHead
else if(recv_package_.status_ == LENGTH_RECV)
length = sizeof(recv_package_.length_);//CommFrame_Struct::m_usFrameLength
else if(recv_package_.status_ == DATA_RECV)
length = recv_package_.length_;//CommFrame_Struct::m_usFrameLength
size = Receive(recv_package_.pack_ + recv_package_.size_, length);
if(size == SOCKET_ERROR) {
if(WSAGetLastError() != WSAEWOULDBLOCK)//读取错误,将通知主框架,将停止程序socket,重连
throw_socket_error(size);
}
else if(size == 0) { //没有数据
throw_socket_error(SOCKET_CLOSED);
Close();
}
else if((size + recv_package_.size_) < length) { //读取小于数据包开始标志大小
recv_package_.size_ += size;
}
else { //得到包头标志大小相同的数据
recv_package_.size_ += size;
recv_package_.pack_[recv_package_.size_] = 0x0;
switch(recv_package_.status_) {
case HEAD_RECV://得到数据包头
recv_package_.size_ = 0x0;
if(recv_package_.pack_[0] == frame_head[0] &&
recv_package_.pack_[1] == frame_head[1] &&
recv_package_.pack_[2] == frame_head[2] &&
recv_package_.pack_[3] == frame_head[3] ) { //得到包头标志
recv_package_.status_ = LENGTH_RECV;
CopyMemory(recv_package_.head_, recv_package_.pack_, sizeof(recv_package_.head_));
}
break;
case LENGTH_RECV://得到数据包长度
recv_package_.size_ = 0x0;
CopyMemory(&recv_package_.length_, recv_package_.pack_ , sizeof(recv_package_.length_));
if(recv_package_.length_ > FrameSizeLimit) {
recv_package_.status_ = HEAD_RECV;
}
else {
recv_package_.status_ = DATA_RECV;
}
break;
case DATA_RECV://得到数据包
if(static_cast<unsigned char>(recv_package_.pack_[recv_package_.size_ - 1]) == FrameTail) { //包尾标志正确,放入到发送队列中
analyze_package_and_push_recv_queue(&recv_package_);
recv_package_.size_ = 0x0;
recv_package_.status_ = HEAD_RECV;
}
else { //包尾标志错误
normalize_package_and_push_recv_queue(&recv_package_);
}
break;
}
}
CAsyncSocket::OnReceive(nErrorCode);
}
