// wait for a new connection. A return value of sFALSE indicates an error,
// in case of timeout, "connection" will be set to NULL
sBool sTCPHostSocket::WaitForNewConnection(sTCPSocket *&connection, sInt timeout)
{
connection=0;
if (!IsConnected()) return sFALSE;
fd_set set;
sInt nfds = 0;
FD_ZERO(&set);
sFD_SET(P->Socket,&set,nfds);
timeval tv;
tv.tv_sec=timeout/1000;
tv.tv_usec=(timeout%1000)*1000;
sInt res=select(nfds,&set,0,0,timeout>=0?&tv:0);
if (res==sSOCKET_ERROR)
{
P->HandleError();
return sFALSE;
}
if (FD_ISSET(P->Socket,&set))
{
sTCPSocket *ts=Accept();
if (!ts) return sFALSE;
connection=ts;
return sTRUE;
}
return sFALSE;
}
int make_listen_bind(uint32 ip, uint16 port)
{
struct sockaddr_in server_address;
int fd;
int result;
fd = sSocket(AF_INET, SOCK_STREAM, 0);
if( fd == -1 )
{
ShowError("make_listen_bind: socket creation failed (%s)!\n", error_msg());
exit(EXIT_FAILURE);
}
if( fd == 0 )
{ // reserved
ShowError("make_listen_bind: Socket #0 is reserved - Please report this!!!\n");
sClose(fd);
return -1;
}
if( fd >= FD_SETSIZE )
{ // socket number too big
ShowError("make_listen_bind: New socket #%d is greater than can we handle! Increase the value of FD_SETSIZE (currently %d) for your OS to fix this!\n", fd, FD_SETSIZE);
sClose(fd);
return -1;
}
setsocketopts(fd,0);
set_nonblocking(fd, 1);
server_address.sin_family = AF_INET;
server_address.sin_addr.s_addr = htonl(ip);
server_address.sin_port = htons(port);
result = sBind(fd, (struct sockaddr*)&server_address, sizeof(server_address));
if( result == SOCKET_ERROR ) {
ShowError("make_listen_bind: bind failed (socket #%d, %s)!\n", fd, error_msg());
exit(EXIT_FAILURE);
}
result = sListen(fd,5);
if( result == SOCKET_ERROR ) {
ShowError("make_listen_bind: listen failed (socket #%d, %s)!\n", fd, error_msg());
exit(EXIT_FAILURE);
}
if(fd_max <= fd) fd_max = fd + 1;
sFD_SET(fd, &readfds);
create_session(fd, connect_client, null_send, null_parse);
session[fd]->client_addr = 0; // just listens
session[fd]->rdata_tick = 0; // disable timeouts on this socket
return fd;
}
int make_listen_bind(uint32 ip, uint16 port)
{
struct sockaddr_in server_address;
int fd;
int result;
fd = sSocket(AF_INET, SOCK_STREAM, 0);
if( fd == -1 )
{
ShowError("make_listen_bind: criacao de socket falhou (codigo %d)!\n", sErrno);
exit(EXIT_FAILURE);
}
if( fd == 0 )
{// reserved
ShowError("make_listen_bind: Socket #0 e reservado - Favor reportar isso!!!\n");
sClose(fd);
return -1;
}
if( fd >= FD_SETSIZE )
{// socket number too big
ShowError("make_listen_bind: Novo socket #%d e maior do que suportamos! aumente o valor de FD_SETSIZE (atualmente %d) para seu SO consertar isso!\n", fd, FD_SETSIZE);
sClose(fd);
return -1;
}
setsocketopts(fd);
set_nonblocking(fd, 1);
server_address.sin_family = AF_INET;
server_address.sin_addr.s_addr = htonl(ip);
server_address.sin_port = htons(port);
result = sBind(fd, (struct sockaddr*)&server_address, sizeof(server_address));
if( result == SOCKET_ERROR ) {
ShowError("make_listen_bind: vinculacao falhou (socket #%d, codigo %d)!\n", fd, sErrno);
exit(EXIT_FAILURE);
}
result = sListen(fd,5);
if( result == SOCKET_ERROR ) {
ShowError("make_listen_bind: listen falhou (socket #%d, codigo %d)!\n", fd, sErrno);
exit(EXIT_FAILURE);
}
if(fd_max <= fd) fd_max = fd + 1;
sFD_SET(fd, &readfds);
create_session(fd, connect_client, null_send, null_parse);
session[fd]->client_addr = 0; // just listens
session[fd]->rdata_tick = 0; // disable timeouts on this socket
return fd;
}
int make_connection(uint32 ip, uint16 port, bool silent)
{
struct sockaddr_in remote_address;
int fd;
int result;
fd = sSocket(AF_INET, SOCK_STREAM, 0);
if(fd == -1) {
ShowError(read_message("Source.common.make_connection"), error_msg());
return -1;
}
if(fd == 0) {
// reserved
ShowError(read_message("Source.common.make_connection2"));
sClose(fd);
return -1;
}
if(fd >= FD_SETSIZE) {
// socket number too big
ShowError("make_connection: New socket #%d is greater than can we handle! Increase the value of FD_SETSIZE (currently %d) for your OS to fix this!\n", fd, FD_SETSIZE);
sClose(fd);
return -1;
}
setsocketopts(fd);
remote_address.sin_family = AF_INET;
remote_address.sin_addr.s_addr = htonl(ip);
remote_address.sin_port = htons(port);
if(!silent)
ShowStatus(read_message("Source.common.make_connect"), CONVIP(ip), port);
result = sConnect(fd, (struct sockaddr *)(&remote_address), sizeof(struct sockaddr_in));
if(result == SOCKET_ERROR) {
if(!silent)
ShowError(read_message("Source.common.make_sConnect"), fd, error_msg());
do_close(fd);
return -1;
}
//Now the socket can be made non-blocking. [Skotlex]
set_nonblocking(fd, 1);
if(fd_max <= fd) fd_max = fd + 1;
sFD_SET(fd,&readfds);
create_session(fd, recv_to_fifo, send_from_fifo, default_func_parse);
session[fd]->client_addr = ntohl(remote_address.sin_addr.s_addr);
return fd;
}
int make_listen_bind(uint32 ip, uint16 port)
{
struct sockaddr_in server_address;
int fd;
int result;
fd = sSocket(AF_INET, SOCK_STREAM, 0);
if(fd == -1) {
ShowError(read_message("Source.common.make_listen_bind"), error_msg());
exit(EXIT_FAILURE);
}
if(fd == 0) {
// reserved
ShowError(read_message("Source.common.make_listen_bind2"));
sClose(fd);
return -1;
}
if(fd >= FD_SETSIZE) {
// socket number too big
ShowError(read_message("Source.common.make_listen_bind3"), fd, FD_SETSIZE);
sClose(fd);
return -1;
}
setsocketopts(fd);
set_nonblocking(fd, 1);
server_address.sin_family = AF_INET;
server_address.sin_addr.s_addr = htonl(ip);
server_address.sin_port = htons(port);
result = sBind(fd, (struct sockaddr *)&server_address, sizeof(server_address));
if(result == SOCKET_ERROR) {
ShowError(read_message("Source.common.make_listen_bind4"), fd, error_msg());
exit(EXIT_FAILURE);
}
result = sListen(fd,5);
if(result == SOCKET_ERROR) {
ShowError(read_message("Source.common.make_listen_bind5"), fd, error_msg());
exit(EXIT_FAILURE);
}
if(fd_max <= fd) fd_max = fd + 1;
sFD_SET(fd, &readfds);
create_session(fd, connect_client, null_send, null_parse);
session[fd]->client_addr = 0; // just listens
session[fd]->rdata_tick = 0; // disable timeouts on this socket
return fd;
}
// wait for read/write to get available
sBool sUDPSocket::Wait(sBool read, sBool write, sInt timeout)
{
if (!P || (!read && !write))
{
sSleep(timeout);
return sFALSE;
}
fd_set readset, writeset;
FD_ZERO(&readset);
FD_ZERO(&writeset);
sInt nfds=0;
if (read) { sFD_SET(P->Socket,&readset,nfds); }
if (write) { sFD_SET(P->Socket,&writeset,nfds); }
timeval tv;
tv.tv_sec=timeout/1000;
tv.tv_usec=(timeout%1000)*1000;
sInt res=select(nfds,&readset,&writeset,0,timeout?&tv:0);
return res!=-1 && (FD_ISSET(P->Socket,&readset)||FD_ISSET(P->Socket,&writeset));
}
int make_listen_bind(uint32 ip, uint16 port)
{
struct sockaddr_in server_address = { 0 };
int fd;
int result;
fd = sSocket(AF_INET, SOCK_STREAM, 0);
if( fd == -1 ) {
ShowError("make_listen_bind: Criacao de socket falhou (%s)!\n", error_msg());
exit(EXIT_FAILURE);
}
if( fd == 0 ) { // reserved
ShowError("make_listen_bind: Socket #0 esta reservado - Por favor reporte isso!!!\n");
sClose(fd);
return -1;
}
if( fd >= FD_SETSIZE ) { // socket number too big
ShowError("make_listen_bind: Novo socket #%d e maior do que o limite suportado! Aumentando o valor para FD_SETSIZE (atualmente %d) seu SO deve corrigir isso!\n", fd, FD_SETSIZE);
sClose(fd);
return -1;
}
setsocketopts(fd,NULL);
set_nonblocking(fd, 1);
server_address.sin_family = AF_INET;
server_address.sin_addr.s_addr = htonl(ip);
server_address.sin_port = htons(port);
result = sBind(fd, (struct sockaddr*)&server_address, sizeof(server_address));
if( result == SOCKET_ERROR ) {
ShowError("make_listen_bind: socket-bind falhou (socket #%d, %s)!\n", fd, error_msg());
exit(EXIT_FAILURE);
}
result = sListen(fd,5);
if( result == SOCKET_ERROR ) {
ShowError("make_listen_bind: socket-listen falhou (socket #%d, %s)!\n", fd, error_msg());
exit(EXIT_FAILURE);
}
if(sockt->fd_max <= fd) sockt->fd_max = fd + 1;
sFD_SET(fd, &readfds);
create_session(fd, connect_client, null_send, null_parse);
session[fd]->client_addr = 0; // just listens
session[fd]->rdata_tick = 0; // disable timeouts on this socket
return fd;
}
int make_connection(uint32 ip, uint16 port)
{
struct sockaddr_in remote_address;
int fd;
int result;
fd = sSocket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
ShowError("make_connection: criação do socket falhou ("CL_RED"%s"CL_RESET")!\n", error_msg());
return -1;
}
if( fd == 0 )
{// reserved
ShowError("make_connection: Socket #"CL_WHITE"0"CL_RESET" é reservado - Reporte isso!\n");
sClose(fd);
return -1;
}
if( fd >= FD_SETSIZE )
{// socket number too big
ShowError("make_connection: Novo socket #"CL_WHITE"%d"CL_RESET" é maior que o que suporta-se! Aumente o valor do FD_SETSIZE (atualemente "CL_WHITE"%d"CL_RESET") para seu SO consertar isso!\n", fd, FD_SETSIZE);
sClose(fd);
return -1;
}
setsocketopts(fd);
remote_address.sin_family = AF_INET;
remote_address.sin_addr.s_addr = htonl(ip);
remote_address.sin_port = htons(port);
ShowStatus("Conectando-se a "CL_WHITE"%d.%d.%d.%d"CL_RESET":"CL_WHITE"%i"CL_RESET"\n", CONVIP(ip), port);
result = sConnect(fd, (struct sockaddr *)(&remote_address), sizeof(struct sockaddr_in));
if( result == SOCKET_ERROR ) {
ShowError("make_connection: conexão falhou (soquete #"CL_WHITE"%d"CL_RESET", "CL_WHITE"%s"CL_RESET")!\n", fd, error_msg());
do_close(fd);
return -1;
}
//Now the socket can be made non-blocking. [Skotlex]
set_nonblocking(fd, 1);
if (fd_max <= fd) fd_max = fd + 1;
sFD_SET(fd,&readfds);
create_session(fd, recv_to_fifo, send_from_fifo, default_func_parse);
session[fd]->client_addr = ntohl(remote_address.sin_addr.s_addr);
return fd;
}
int make_connection(uint32 ip, uint16 port)
{
struct sockaddr_in remote_address;
int fd;
int result;
fd = sSocket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
ShowError("make_connection: falha ao criar socket (codigo %d)!\n", sErrno);
return -1;
}
if( fd == 0 )
{// reserved
ShowError("make_connection: Socket #0 e reservado - Favor reportar isso!!!\n");
sClose(fd);
return -1;
}
if( fd >= FD_SETSIZE )
{// socket number too big
ShowError("Novo socket #%d e maior do que suportamos! aumente o valor de FD_SETSIZE (atualmente %d) para seu SO consertar isso!\n", fd, FD_SETSIZE);
sClose(fd);
return -1;
}
setsocketopts(fd);
remote_address.sin_family = AF_INET;
remote_address.sin_addr.s_addr = htonl(ip);
remote_address.sin_port = htons(port);
ShowStatus("Conectando a %d.%d.%d.%d:%i\n", CONVIP(ip), port);
result = sConnect(fd, (struct sockaddr *)(&remote_address), sizeof(struct sockaddr_in));
if( result == SOCKET_ERROR ) {
ShowError("make_connection: conexao falhou (socket #%d, codigo %d)!\n", fd, sErrno);
do_close(fd);
return -1;
}
//Now the socket can be made non-blocking. [Skotlex]
set_nonblocking(fd, 1);
if (fd_max <= fd) fd_max = fd + 1;
sFD_SET(fd,&readfds);
create_session(fd, recv_to_fifo, send_from_fifo, default_func_parse);
session[fd]->client_addr = ntohl(remote_address.sin_addr.s_addr);
return fd;
}
int make_connection(uint32 ip, uint16 port, struct hSockOpt *opt) {
struct sockaddr_in remote_address;
int fd;
int result;
fd = sSocket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
ShowError("make_connection: socket creation failed (%s)!\n", error_msg());
return -1;
}
if( fd == 0 ) {// reserved
ShowError("make_connection: Socket #0 is reserved - Please report this!!!\n");
sClose(fd);
return -1;
}
if( fd >= FD_SETSIZE ) {// socket number too big
ShowError("make_connection: New socket #%d is greater than can we handle! Increase the value of FD_SETSIZE (currently %d) for your OS to fix this!\n", fd, FD_SETSIZE);
sClose(fd);
return -1;
}
setsocketopts(fd,opt);
remote_address.sin_family = AF_INET;
remote_address.sin_addr.s_addr = htonl(ip);
remote_address.sin_port = htons(port);
if( !( opt && opt->silent ) )
ShowStatus("Connecting to %d.%d.%d.%d:%i\n", CONVIP(ip), port);
result = sConnect(fd, (struct sockaddr *)(&remote_address), sizeof(struct sockaddr_in));
if( result == SOCKET_ERROR ) {
if( !( opt && opt->silent ) )
ShowError("make_connection: connect failed (socket #%d, %s)!\n", fd, error_msg());
sockt->close(fd);
return -1;
}
//Now the socket can be made non-blocking. [Skotlex]
set_nonblocking(fd, 1);
if (sockt->fd_max <= fd) sockt->fd_max = fd + 1;
sFD_SET(fd,&readfds);
create_session(fd, recv_to_fifo, send_from_fifo, default_func_parse);
session[fd]->client_addr = ntohl(remote_address.sin_addr.s_addr);
return fd;
}
int make_connection(uint32 ip, uint16 port, struct hSockOpt *opt) {
struct sockaddr_in remote_address = { 0 };
int fd;
int result;
fd = sSocket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
ShowError("make_connection: Criacao de socket falhou (%s)!\n", error_msg());
return -1;
}
if( fd == 0 ) {// reserved
ShowError("make_connection: Socket #0 esta reservado - Por favor reporte isso!!!\n");
sClose(fd);
return -1;
}
if( fd >= FD_SETSIZE ) {// socket number too big
ShowError("make_connection: Novo socket #%d e maior do que o limite suportado! Aumentando o valor para FD_SETSIZE (atualmente %d) seu SO deve corrigir isso!\n", fd, FD_SETSIZE);
sClose(fd);
return -1;
}
setsocketopts(fd,opt);
remote_address.sin_family = AF_INET;
remote_address.sin_addr.s_addr = htonl(ip);
remote_address.sin_port = htons(port);
if( !( opt && opt->silent ) )
ShowStatus("Conectando-se a %d.%d.%d.%d:%i\n", CONVIP(ip), port);
result = sConnect(fd, (struct sockaddr *)(&remote_address), sizeof(struct sockaddr_in));
if( result == SOCKET_ERROR ) {
if( !( opt && opt->silent ) )
ShowError("make_connection: Falha na conexao (socket #%d, %s)!\n", fd, error_msg());
sockt->close(fd);
return -1;
}
//Now the socket can be made non-blocking. [Skotlex]
set_nonblocking(fd, 1);
if (sockt->fd_max <= fd) sockt->fd_max = fd + 1;
sFD_SET(fd,&readfds);
create_session(fd, recv_to_fifo, send_from_fifo, default_func_parse);
session[fd]->client_addr = ntohl(remote_address.sin_addr.s_addr);
return fd;
}
// check if sockets are able to read
sBool sUDPSocket::CanRead()
{
if (!P) return sFALSE;
fd_set set;
sInt nfds = 0;
FD_ZERO(&set);
sFD_SET(P->Socket,&set,nfds);
timeval tv;
tv.tv_sec=tv.tv_usec=0;
select(nfds,&set,0,0,&tv);
return FD_ISSET(P->Socket,&set)?sTRUE:sFALSE;
}
// check if sockets are able to write
sBool sTCPSocket::CanWrite()
{
if (!IsConnected()) return sFALSE;
fd_set set;
sInt nfds = 0;
FD_ZERO(&set);
sFD_SET(P->Socket,&set,nfds);
timeval tv;
tv.tv_sec=tv.tv_usec=0;
select(nfds,0,&set,0,&tv);
return FD_ISSET(P->Socket,&set)?sTRUE:sFALSE;
}
/*======================================
* CORE : Connection functions
*--------------------------------------*/
int connect_client(int listen_fd)
{
int fd;
struct sockaddr_in client_address;
socklen_t len;
len = sizeof(client_address);
fd = sAccept(listen_fd, (struct sockaddr*)&client_address, &len);
if ( fd == -1 ) {
ShowError("connect_client: accept failed (%s)!\n", error_msg());
return -1;
}
if( fd == 0 )
{ // reserved
ShowError("connect_client: Socket #0 is reserved - Please report this!!!\n");
sClose(fd);
return -1;
}
if( fd >= FD_SETSIZE )
{ // socket number too big
ShowError("connect_client: New socket #%d is greater than can we handle! Increase the value of FD_SETSIZE (currently %d) for your OS to fix this!\n", fd, FD_SETSIZE);
sClose(fd);
return -1;
}
setsocketopts(fd,0);
set_nonblocking(fd, 1);
#ifndef MINICORE
if( ip_rules && !connect_check(ntohl(client_address.sin_addr.s_addr)) ) {
do_close(fd);
return -1;
}
#endif
if( fd_max <= fd ) fd_max = fd + 1;
sFD_SET(fd,&readfds);
create_session(fd, recv_to_fifo, send_from_fifo, default_func_parse);
session[fd]->client_addr = ntohl(client_address.sin_addr.s_addr);
return fd;
}
/*======================================
* CORE : Connection functions
*--------------------------------------*/
int connect_client(int listen_fd)
{
int fd;
struct sockaddr_in client_address;
socklen_t len;
len = sizeof(client_address);
fd = sAccept(listen_fd, (struct sockaddr*)&client_address, &len);
if ( fd == -1 ) {
ShowError("connect_client: accept falhou (codigo %d)!\n", sErrno);
return -1;
}
if( fd == 0 )
{// reserved
ShowError("connect_client: Socket #0 e reservado - Favor reportar isso!!!\n");
sClose(fd);
return -1;
}
if( fd >= FD_SETSIZE )
{// socket number too big
ShowError("connect_client: Novo socket #%d e maior do que suportamos! aumente o valor de FD_SETSIZE (atualmente %d) para seu SO consertar isso!\n", fd, FD_SETSIZE);
sClose(fd);
return -1;
}
setsocketopts(fd);
set_nonblocking(fd, 1);
#ifndef MINICORE
if( ip_rules && !connect_check(ntohl(client_address.sin_addr.s_addr)) ) {
do_close(fd);
return -1;
}
#endif
if( fd_max <= fd ) fd_max = fd + 1;
sFD_SET(fd,&readfds);
create_session(fd, recv_to_fifo, send_from_fifo, default_func_parse);
session[fd]->client_addr = ntohl(client_address.sin_addr.s_addr);
return fd;
}
/*======================================
* CORE : Connection functions
*--------------------------------------*/
int connect_client(int listen_fd)
{
int fd;
struct sockaddr_in client_address;
socklen_t len;
len = sizeof(client_address);
fd = sAccept(listen_fd, (struct sockaddr *)&client_address, &len);
if(fd == -1) {
ShowError(read_message("Source.common.connect_client"), error_msg());
return -1;
}
if(fd == 0) {
// reserved
ShowError(read_message("Source.common.connect_client2"));
sClose(fd);
return -1;
}
if(fd >= FD_SETSIZE) {
// socket number too big
ShowError(read_message("Source.common.connect_client3"), fd, FD_SETSIZE);
sClose(fd);
return -1;
}
setsocketopts(fd);
set_nonblocking(fd, 1);
#ifndef MINICORE
if(ip_rules && !connect_check(ntohl(client_address.sin_addr.s_addr))) {
do_close(fd);
return -1;
}
#endif
if(fd_max <= fd) fd_max = fd + 1;
sFD_SET(fd,&readfds);
create_session(fd, recv_to_fifo, send_from_fifo, default_func_parse);
session[fd]->client_addr = ntohl(client_address.sin_addr.s_addr);
return fd;
}
/*======================================
* CORE : Connection functions
*--------------------------------------*/
int connect_client(int listen_fd) {
int fd;
struct sockaddr_in client_address;
socklen_t len;
len = sizeof(client_address);
fd = sAccept(listen_fd, (struct sockaddr*)&client_address, &len);
if ( fd == -1 ) {
ShowError("connect_client: Recebimento falhou (%s)!\n", error_msg());
return -1;
}
if( fd == 0 ) { // reserved
ShowError("connect_client: Socket #0 esta reservado - Por favor reporte isso!!!\n");
sClose(fd);
return -1;
}
if( fd >= FD_SETSIZE ) { // socket number too big
ShowError("connect_client: Novo socket #%d e maior do que o limite suportado! Aumentando o valor para FD_SETSIZE (atualmente %d) seu SO deve corrigir isso!\n", fd, FD_SETSIZE);
sClose(fd);
return -1;
}
setsocketopts(fd,NULL);
set_nonblocking(fd, 1);
#ifndef MINICORE
if( ip_rules && !connect_check(ntohl(client_address.sin_addr.s_addr)) ) {
sockt->close(fd);
return -1;
}
#endif
if( sockt->fd_max <= fd ) sockt->fd_max = fd + 1;
sFD_SET(fd,&readfds);
create_session(fd, recv_to_fifo, send_from_fifo, default_func_parse);
session[fd]->client_addr = ntohl(client_address.sin_addr.s_addr);
return fd;
}
sBool sTCPHostSocket::WaitForEvents(sInt &numreads, sTCPSocket **reads, sInt& numwrites, sTCPSocket **writes, sTCPSocket **newconn, sInt timeout)
{
if (newconn) *newconn=0;
if (!IsConnected())
{
numreads=numwrites=0;
return sFALSE;
}
fd_set readset, writeset;
sInt nfds = 0;
FD_ZERO(&readset);
FD_ZERO(&writeset);
for (sInt i=0; i<numreads; i++)
sFD_SET(reads[i]->P->Socket,&readset,nfds);
for (sInt i=0; i<numwrites; i++)
sFD_SET(writes[i]->P->Socket,&writeset,nfds);
sInt realnumreads=numreads;
if (newconn)
{
sFD_SET(P->Socket,&readset,nfds);
realnumreads++;
}
if (!realnumreads && !numwrites)
{
sSleep(timeout);
return sTRUE;
}
timeval tv;
tv.tv_sec=timeout/1000;
tv.tv_usec=(timeout%1000)*1000;
sInt res=select(nfds,(realnumreads?&readset:0),(numwrites?&writeset:0),0,(timeout>=0?&tv:0));
if (res==sSOCKET_ERROR)
{
P->HandleError();
numreads=numwrites=0;
return sFALSE;
}
// new connection?
if (FD_ISSET(P->Socket,&readset))
{
*newconn=Accept();
if (!*newconn)
{
numreads=numwrites=0;
return sFALSE;
}
}
// read set...
sInt nr=0;
for (sInt i=0; i<numreads; i++)
if (FD_ISSET(reads[i]->P->Socket,&readset))
reads[nr++]=reads[i];
numreads=nr;
// write set...
sInt nw=0;
for (sInt i=0; i<numwrites; i++)
if (FD_ISSET(writes[i]->P->Socket,&writeset))
writes[nw++]=writes[i];
numwrites=nw;
return sTRUE;
}
