int32_t CloseSocket(HANDLE sock)
{
socket_t s = GetSocketByHandle(sock);
if(s)
{
return close(s->fd);
}
return -1;
}
static void InitSocket(HANDLE sock,int fd)
{
socket_t s = GetSocketByHandle(sock);
s->fd = fd;
LIST_CLEAR(s->pending_send);
LIST_CLEAR(s->pending_recv);
s->readable = s->writeable = 0;
s->active_read_count = s->active_write_count = 0;
s->engine = 0;
}
static void InitSocket(HANDLE sock,int32_t fd)
{
socket_t s = GetSocketByHandle(sock);
s->fd = fd;
LINK_LIST_CLEAR(s->pending_send);
LINK_LIST_CLEAR(s->pending_recv);
s->readable = s->writeable = 0;
s->engine = 0;
s->isactived = 0;
s->dnode.pre = s->dnode.next = NULL;
}
int Bind2Engine(HANDLE e,HANDLE s)
{
engine_t engine = GetEngineByHandle(e);
socket_t sock = GetSocketByHandle(s);
if(!engine || ! sock)
return -1;
if(engine->Register(engine,sock) == 0)
{
sock->engine = engine;
return 0;
}
return -1;
}
int32_t CloseSocket(SOCK sock)
{
socket_t s = GetSocketByHandle(sock);
if(s)
{
#ifdef _LINUX
return close(s->fd);
#else
return closesocket(s->fd);
#endif
}
return -1;
}
int32_t Bind(HANDLE sock,const struct sockaddr *myaddr,socklen_t addrlen)
{
socket_t s = GetSocketByHandle(sock);
if(s)
{
if(bind(s->fd,myaddr,addrlen) < 0)
{
printf("%s\n",strerror(errno));
return -1;
}
return 0;
}
return -1;
}
int32_t Listen(HANDLE sock,int32_t backlog)
{
socket_t s = GetSocketByHandle(sock);
if(s)
{
if(listen(s->fd,backlog) < 0)
{
printf("%s\n",strerror(errno));
return -1;
}
return 0;
}
return -1;
}
int32_t Connect(HANDLE sock,const struct sockaddr *servaddr,socklen_t addrlen)
{
socket_t s = GetSocketByHandle(sock);
if(s)
{
if(connect(s->fd,servaddr,addrlen) < 0)
{
//printf("%s\n",strerror(errno));
return -1;
}
return 0;
}
return -1;
}
int32_t connector_connect(connector_t c,const char *ip,uint32_t port,on_connect call_back,void *ud,uint32_t ms)
{
struct sockaddr_in remote;
HANDLE sock;
struct pending_connect *pc;
sock = OpenSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(sock < 0)
return -1;
remote.sin_family = AF_INET;
remote.sin_port = htons(port);
if(inet_pton(INET,ip,&remote.sin_addr) < 0)
{
printf("%s\n",strerror(errno));
return -1;
}
if(ms>0)
{
if(setNonblock(sock)!=0)
return -1;
}
if(Connect(sock, (struct sockaddr *)&remote, sizeof(remote)) == 0)
{
//连接成功,无需要后续处理了,直接调用回调函数
call_back(sock,ip,port,ud);
return 0;
}
socket_t s = GetSocketByHandle(sock);
pc = malloc(sizeof(*pc));
pc->lnode.next = NULL;
pc->sock = sock;
pc->ip = ip;
pc->port = port;
pc->call_back = call_back;
pc->timeout = GetSystemMs() + ms;
pc->ud = ud;
pc->real_fd = s->fd;
mutex_lock(c->lock);
LINK_LIST_PUSH_BACK(c->extern_pending_connect,pc);
mutex_unlock(c->lock);
return 0;
}
int32_t getLocalAddrPort(HANDLE sock,struct sockaddr_in *remoAddr,socklen_t *len,char *buf,uint16_t *port)
{
socket_t s = GetSocketByHandle(sock);
if(s)
{
if(0 == buf)
return -1;
int32_t ret = getsockname(s->fd, (struct sockaddr*)remoAddr,len);
if(ret != 0)
return -1;
if(0 == inet_ntop(INET,&remoAddr->sin_addr,buf,15))
return -1;
*port = ntohs(remoAddr->sin_port);
return 0;
}
return -1;
}
int WSASend(HANDLE sock,st_io *io,int notify)
{
assert(io);
socket_t s = GetSocketByHandle(sock);
if(!s)
return -1;
int active_send_count = -1;
int ret = 0;
mutex_lock(s->send_mtx);
//为保证执行顺序与请求的顺序一致,先将请求插入队列尾部,再弹出队列首元素
LIST_PUSH_BACK(s->pending_send,io);
io = 0;
if(s->writeable)
{
io = LIST_POP(st_io*,s->pending_send);
active_send_count = s->active_write_count;
}
int32_t getRemoteAddrPort(HANDLE sock,char *buf,uint16_t *port)
{
socket_t s = GetSocketByHandle(sock);
if(s)
{
if(0 == buf)
return -1;
struct sockaddr_in remoAddr;
memset(&remoAddr,0,sizeof(remoAddr));
remoAddr.sin_family = INET;
socklen_t len = sizeof(remoAddr);
int32_t ret = getpeername(s->fd,(struct sockaddr*)&remoAddr,&len);
if(ret != 0)
return -1;
if(0 == inet_ntop(INET,&remoAddr.sin_addr,buf,15))
return -1;
*port = ntohs(remoAddr.sin_port);
return 0;
}
return -1;
}
void rem_listener(acceptor_t a,SOCK l)
{
if(a)
{
struct epoll_event ev;int32_t ret;
TEMP_FAILURE_RETRY(ret = epoll_ctl(a->poller_fd,EPOLL_CTL_DEL,GetSocketByHandle(l)->fd,&ev));
if(ret == 0)
{
int32_t count = link_list_size(a->st_listens);
while(count>0)
{
struct st_listen *_st = LINK_LIST_POP(struct st_listen *,a->st_listens);
if(_st->sock == l)
{
ReleaseSocket(l);
free(_st);
break;
}
else
LINK_LIST_PUSH_BACK(a->st_listens,_st);
--count;
};
}
}
SOCK add_listener(acceptor_t a,const char *ip,uint32_t port,on_accept call_back,void *ud)
{
if(!a)
return INVALID_SOCK;
SOCK ListenSocket;
struct sockaddr_in servaddr;
ListenSocket = Tcp_Listen(ip,port,&servaddr,256);
if(ListenSocket != INVALID_SOCK)
{
struct st_listen *_st = (struct st_listen *)calloc(1,sizeof(*_st));
_st->accept_callback = call_back;
_st->ud = ud;
_st->sock = ListenSocket;
_st->real_fd = GetSocketByHandle(ListenSocket)->fd;
int32_t ret = -1;
struct epoll_event ev;
ev.data.ptr = _st;
ev.events = EV_IN;
TEMP_FAILURE_RETRY(ret = epoll_ctl(a->poller_fd,EPOLL_CTL_ADD,_st->real_fd,&ev));
if(ret == -1)
{
ReleaseSocket(ListenSocket);
printf("listen %s:%d error\n",ip,port);
return INVALID_SOCK;
}
LINK_LIST_PUSH_BACK(a->st_listens,_st);
return ListenSocket;
}
else
{
ReleaseSocket(ListenSocket);
printf("listen %s:%d error\n",ip,port);
return INVALID_SOCK;
}
}
SOCK Accept(SOCK sock,struct sockaddr *sa,socklen_t *salen)
{
socket_t s = GetSocketByHandle(sock);
if(s)
{
int32_t n;
again:
if((n = accept(s->fd,sa,salen)) < 0)
{
#if defined(_LINUX)
#ifdef EPROTO
if(errno == EPROTO || errno == ECONNABORTED)
#else
if(errno == ECONNABORTED)
#endif
goto again;
else
{
//printf("%s\n",strerror(errno));
return INVALID_SOCK;
}
#elif defined(_WIN)
return INVALID_SOCK;
#endif
}
SOCK newsock = NewSocketWrapper();
if(newsock < 0)
{
close(n);
return INVALID_SOCK;
}
InitSocket(newsock,n);
return newsock;
}
return INVALID_SOCK;
}
static void InitSocket(SOCK sock,SOCKET fd)
{
socket_t s = GetSocketByHandle(sock);
s->fd = fd;
s->engine = NULL;
}
