static int fdw_select_watch(long timeout_msec)
{
static struct timeval tv;
tv.tv_sec = timeout_msec / 1000;
tv.tv_usec = timeout_msec % 1000;
/* set the working sets based on the templates */
memcpy(rfds, trfds, sizeof(t_psock_fd_set));
memcpy(wfds, twfds, sizeof(t_psock_fd_set));
return (sr = psock_select(smaxfd + 1, rfds, wfds, NULL, &tv));
}
void dbs_server_loop(int lsocket)
{
struct sockaddr_in sinRemote;
int sd ;
fd_set ReadFDs, WriteFDs, ExceptFDs;
t_elem * elem;
t_d2dbs_connection* it;
BOOL bOK ;
const char* pcErrorType ;
struct timeval tv;
int highest_fd;
psock_t_socklen nAddrSize = sizeof(sinRemote);
while (1) {
#ifdef WIN32
if (g_ServiceStatus<0 && kbhit() && getch()=='q')
d2dbs_signal_quit_wrapper();
if (g_ServiceStatus == 0) d2dbs_signal_quit_wrapper();
while (g_ServiceStatus == 2) Sleep(1000);
#endif
if (d2dbs_handle_signal()<0) break;
dbs_handle_timed_events();
highest_fd=dbs_server_setup_fdsets(&ReadFDs, &WriteFDs, &ExceptFDs, lsocket);
tv.tv_sec = 0;
tv.tv_usec = SELECT_TIME_OUT;
switch (psock_select(highest_fd+1, &ReadFDs, &WriteFDs, &ExceptFDs, &tv) ) {
case -1:
eventlog(eventlog_level_error,__FUNCTION__,"psock_select() failed : %s",strerror(psock_errno()));
continue;
case 0:
continue;
default:
break;
}
if (PSOCK_FD_ISSET(lsocket, &ReadFDs)) {
sd = psock_accept(lsocket, (struct sockaddr*)&sinRemote, &nAddrSize);
if (sd == -1) {
eventlog(eventlog_level_error,__FUNCTION__,"psock_accept() failed : %s",strerror(psock_errno()));
return;
}
eventlog(eventlog_level_info,__FUNCTION__,"accepted connection from %s:%d , socket %d .",
inet_ntoa(sinRemote.sin_addr) , ntohs(sinRemote.sin_port), sd);
eventlog_step(prefs_get_logfile_gs(),eventlog_level_info,__FUNCTION__,"accepted connection from %s:%d , socket %d .",
inet_ntoa(sinRemote.sin_addr) , ntohs(sinRemote.sin_port), sd);
setsockopt_keepalive(sd);
dbs_server_list_add_socket(sd, ntohl(sinRemote.sin_addr.s_addr));
if (psock_ctl(sd,PSOCK_NONBLOCK)<0) {
eventlog(eventlog_level_error,__FUNCTION__,"could not set TCP socket [%d] to non-blocking mode (closing connection) (psock_ctl: %s)", sd,strerror(psock_errno()));
psock_close(sd);
}
} else if (PSOCK_FD_ISSET(lsocket, &ExceptFDs)) {
eventlog(eventlog_level_error,__FUNCTION__,"exception on listening socket");
/* FIXME: exceptions are not errors with TCP, they are out-of-band data */
return;
}
LIST_TRAVERSE(dbs_server_connection_list,elem)
{
bOK = TRUE;
pcErrorType = 0;
if (!(it=elem_get_data(elem))) continue;
if (PSOCK_FD_ISSET(it->sd, &ExceptFDs)) {
bOK = FALSE;
pcErrorType = "General socket error"; /* FIXME: no no no no no */
PSOCK_FD_CLR(it->sd, &ExceptFDs);
} else {
if (PSOCK_FD_ISSET(it->sd, &ReadFDs)) {
bOK = dbs_server_read_data(it);
pcErrorType = "Read error";
PSOCK_FD_CLR(it->sd, &ReadFDs);
}
if (PSOCK_FD_ISSET(it->sd, &WriteFDs)) {
bOK = dbs_server_write_data(it);
pcErrorType = "Write error";
PSOCK_FD_CLR(it->sd, &WriteFDs);
}
}
if (!bOK) {
int err;
psock_t_socklen errlen;
err = 0;
errlen = sizeof(err);
if (psock_getsockopt(it->sd, PSOCK_SOL_SOCKET, PSOCK_SO_ERROR, &err, &errlen)==0) {
if (errlen && err!=0) {
eventlog(eventlog_level_error,__FUNCTION__,"data socket error : %s",strerror(err));
}
}
dbs_server_shutdown_connection(it);
list_remove_elem(dbs_server_connection_list,&elem);
} else {
if (dbs_packet_handle(it)==-1) {
eventlog(eventlog_level_error,__FUNCTION__,"dbs_packet_handle() failed");
dbs_server_shutdown_connection(it);
list_remove_elem(dbs_server_connection_list,&elem);
}
}
}
}
static int proxy_process(unsigned short server_listen_port, struct sockaddr_in servaddr)
{
int lsock;
struct sockaddr_in laddr;
t_psock_fd_set rfds, wfds;
int highest_fd;
int udpsock;
t_virtconn * vc;
t_elem const * curr;
int csocket;
int ssocket;
if ((udpsock = psock_socket(PSOCK_PF_INET,PSOCK_SOCK_DGRAM,PSOCK_IPPROTO_UDP))<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"could not create UDP socket (psock_socket: %s)",pstrerror(psock_errno()));
return -1;
}
if (psock_ctl(udpsock,PSOCK_NONBLOCK)<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not set UDP listen socket to non-blocking mode (psock_ctl: %s)",pstrerror(psock_errno()));
if ((lsock = psock_socket(PSOCK_PF_INET,PSOCK_SOCK_STREAM,PSOCK_IPPROTO_TCP))<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"could not create listening socket (psock_socket: %s)",pstrerror(psock_errno()));
psock_close(udpsock);
return -1;
}
{
int val=1;
if (psock_setsockopt(lsock,PSOCK_SOL_SOCKET,PSOCK_SO_REUSEADDR,&val,(psock_t_socklen)sizeof(int))<0)
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not set socket option SO_REUSEADDR (psock_setsockopt: %s)",lsock,pstrerror(psock_errno()));
/* not a fatal error... */
}
memset(&laddr,0,sizeof(laddr));
laddr.sin_family = PSOCK_AF_INET;
laddr.sin_port = htons(server_listen_port);
laddr.sin_addr.s_addr = htonl(INADDR_ANY);
if (psock_bind(lsock,(struct sockaddr *)&laddr,(psock_t_socklen)sizeof(laddr))<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"could not bind socket to address 0.0.0.0:%hu TCP (psock_bind: %s)",server_listen_port,pstrerror(psock_errno()));
psock_close(udpsock);
psock_close(lsock);
return -1;
}
memset(&laddr,0,sizeof(laddr));
laddr.sin_family = PSOCK_AF_INET;
laddr.sin_port = htons(server_listen_port);
laddr.sin_addr.s_addr = htonl(INADDR_ANY);
if (psock_bind(udpsock,(struct sockaddr *)&laddr,(psock_t_socklen)sizeof(laddr))<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"could not bind socket to address 0.0.0.0:%hu UDP (psock_bind: %s)",server_listen_port,pstrerror(psock_errno()));
psock_close(udpsock);
psock_close(lsock);
return -1;
}
eventlog(eventlog_level_info,__FUNCTION__,"bound to UDP port %hu",server_listen_port);
/* tell socket to listen for connections */
if (psock_listen(lsock,LISTEN_QUEUE)<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"could not listen (psock_listen: %s)",pstrerror(psock_errno()));
psock_close(udpsock);
psock_close(lsock);
return -1;
}
if (psock_ctl(lsock,PSOCK_NONBLOCK)<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not set TCP listen socket to non-blocking mode (psock_ctl: %s)",pstrerror(psock_errno()));
eventlog(eventlog_level_info,__FUNCTION__,"listening on TCP port %hu",server_listen_port);
for (;;)
{
/* loop over all connections to create the sets for select() */
PSOCK_FD_ZERO(&rfds);
PSOCK_FD_ZERO(&wfds);
highest_fd = lsock;
PSOCK_FD_SET(lsock,&rfds);
if (udpsock>highest_fd)
highest_fd = udpsock;
PSOCK_FD_SET(udpsock,&rfds);
LIST_TRAVERSE_CONST(virtconnlist(),curr)
{
vc = elem_get_data(curr);
csocket = virtconn_get_client_socket(vc);
if (queue_get_length((t_queue const * const *)virtconn_get_clientout_queue(vc))>0)
PSOCK_FD_SET(csocket,&wfds); /* pending output, also check for writeability */
PSOCK_FD_SET(csocket,&rfds);
if (csocket>highest_fd)
highest_fd = csocket;
switch (virtconn_get_state(vc))
{
case virtconn_state_connecting:
eventlog(eventlog_level_debug,__FUNCTION__,"waiting for %d to finish connecting",ssocket);
ssocket = virtconn_get_server_socket(vc);
PSOCK_FD_SET(ssocket,&wfds); /* wait for connect to complete */
if (ssocket>highest_fd)
highest_fd = ssocket;
break;
case virtconn_state_connected:
eventlog(eventlog_level_debug,__FUNCTION__,"checking for reading on connected socket %d",ssocket);
ssocket = virtconn_get_server_socket(vc);
if (queue_get_length((t_queue const * const *)virtconn_get_serverout_queue(vc))>0)
PSOCK_FD_SET(ssocket,&wfds); /* pending output, also check for writeability */
PSOCK_FD_SET(ssocket,&rfds);
if (ssocket>highest_fd)
highest_fd = ssocket;
break;
default: /* avoid warning */
break;
}
}
/* find which sockets need servicing */
if (psock_select(highest_fd+1,&rfds,&wfds,NULL,NULL)<0)
{
if (errno!=PSOCK_EINTR)
eventlog(eventlog_level_error,__FUNCTION__,"select failed (select: %s)",pstrerror(errno));
continue;
}
/* check for incoming connection */
if (PSOCK_FD_ISSET(lsock,&rfds))
{
int asock;
struct sockaddr_in caddr;
psock_t_socklen caddr_len;
/* accept the connection */
caddr_len = sizeof(caddr);
if ((asock = psock_accept(lsock,(struct sockaddr *)&caddr,&caddr_len))<0)
{
if (psock_errno()==PSOCK_EWOULDBLOCK || psock_errno()==PSOCK_ECONNABORTED) /* BSD, POSIX error for aborted connections, SYSV often uses EAGAIN */
eventlog(eventlog_level_error,__FUNCTION__,"client aborted connection (psock_accept: %s)",pstrerror(psock_errno()));
else /* EAGAIN can mean out of resources _or_ connection aborted */
if (psock_errno()!=PSOCK_EINTR)
eventlog(eventlog_level_error,__FUNCTION__,"could not accept new connection (psock_accept: %s)",pstrerror(psock_errno()));
}
else
{
int ssd;
int val=1;
eventlog(eventlog_level_info,__FUNCTION__,"[%d] accepted connection from %s:%hu",asock,inet_ntoa(caddr.sin_addr),ntohs(caddr.sin_port));
if (psock_setsockopt(asock,PSOCK_SOL_SOCKET,PSOCK_SO_KEEPALIVE,&val,(psock_t_socklen)sizeof(val))<0)
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not set socket option SO_KEEPALIVE (psock_setsockopt: %s)",asock,pstrerror(psock_errno()));
/* not a fatal error */
if (psock_ctl(asock,PSOCK_NONBLOCK)<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not set TCP socket to non-blocking mode (closing connection) (psock_ctl: %s)",asock,pstrerror(psock_errno()));
psock_close(asock);
}
else
if ((ssd = psock_socket(PSOCK_PF_INET,PSOCK_SOCK_STREAM,PSOCK_IPPROTO_TCP))<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could create TCP socket (closing connection) (psock_socket: %s)",asock,pstrerror(psock_errno()));
psock_close(asock);
}
else
if (psock_ctl(ssd,PSOCK_NONBLOCK)<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not set TCP socket to non-blocking mode (closing connection) (psock_ctl: %s)",asock,pstrerror(psock_errno()));
psock_close(ssd);
psock_close(asock);
}
else
if (!(vc = virtconn_create(asock,ssd,ntohl(caddr.sin_addr.s_addr),BNETD_MIN_TEST_PORT)))
{
eventlog(eventlog_level_error,__FUNCTION__,"[%d] unable to create new connection (closing connection)",asock);
psock_close(ssd);
psock_close(asock);
}
else
{
memset(&caddr,0,sizeof(caddr));
caddr.sin_family = PSOCK_AF_INET;
caddr.sin_port = htons(virtconn_get_udpport(vc));
caddr.sin_addr.s_addr = htonl(virtconn_get_udpaddr(vc));
eventlog(eventlog_level_info,__FUNCTION__,"[%d] addr now %s:%hu",asock,inet_ntoa(caddr.sin_addr),ntohs(caddr.sin_port));
}
}
}
eventlog(eventlog_level_debug,__FUNCTION__,"checking for incoming UDP");
if (PSOCK_FD_ISSET(udpsock,&rfds))
{
t_packet * upacket;
struct sockaddr_in toaddr;
struct sockaddr_in fromaddr;
psock_t_socklen fromlen;
int len;
if (!(upacket = packet_create(packet_class_raw)))
eventlog(eventlog_level_error,__FUNCTION__,"could not allocate raw packet for input");
else
{
/* packet_set_flags(upacket,PROXY_FLAG_UDP);*/
fromlen = sizeof(fromaddr);
if ((len = psock_recvfrom(udpsock,packet_get_raw_data_build(upacket,0),MAX_PACKET_SIZE,0,(struct sockaddr *)&fromaddr,&fromlen))<0)
{
if (psock_errno()!=PSOCK_EINTR && psock_errno()!=PSOCK_EAGAIN && psock_errno()!=PSOCK_EWOULDBLOCK)
eventlog(eventlog_level_error,__FUNCTION__,"could not recv UDP datagram (psock_recvfrom: %s)",pstrerror(psock_errno()));
}
else
{
if (fromaddr.sin_family!=PSOCK_AF_INET)
eventlog(eventlog_level_error,__FUNCTION__,"got UDP datagram with bad address family %d",fromaddr.sin_family);
else
{
char tempa[32];
char tempb[32];
packet_set_size(upacket,len);
if (fromaddr.sin_addr.s_addr==servaddr.sin_addr.s_addr) /* from server */
{
if ((curr = list_get_first_const(virtconnlist()))) /* hack.. find proper client */
{
vc = elem_get_data(curr);
memset(&toaddr,0,sizeof(toaddr));
toaddr.sin_family = PSOCK_AF_INET;
toaddr.sin_port = htons(virtconn_get_udpport(vc));
toaddr.sin_addr.s_addr = htonl(virtconn_get_udpaddr(vc));
eventlog(eventlog_level_info,__FUNCTION__,"[%d] addr by UDP send is %s:%hu",virtconn_get_client_socket(vc),inet_ntoa(toaddr.sin_addr),ntohs(toaddr.sin_port));
if (hexstrm)
{
strcpy(tempa,inet_ntoa(fromaddr.sin_addr));
strcpy(tempb,inet_ntoa(toaddr.sin_addr));
fprintf(hexstrm,"%d: srv prot=UDP from=%s:%hu to=%s:%hu length=%d\n",
udpsock,
tempa,
ntohs(fromaddr.sin_port),
tempb,
ntohs(toaddr.sin_port),
len);
hexdump(hexstrm,packet_get_raw_data(upacket,0),len);
}
/*queue_push_packet(virtconn_get_clientout_queue(__));*/ /* where to queue ... */
for (;;) /* hack.. just block for now */
{
if (psock_sendto(udpsock,packet_get_raw_data_const(upacket,0),len,0,
(struct sockaddr *)&toaddr,(psock_t_socklen)sizeof(toaddr))<len)
{
if (psock_errno()==PSOCK_EINTR || psock_errno()==PSOCK_EAGAIN || psock_errno()==PSOCK_EWOULDBLOCK)
continue;
eventlog(eventlog_level_error,__FUNCTION__,"could not send UDP datagram to client (psock_sendto: %s)",pstrerror(psock_errno()));
}
break;
}
}
}
else /* from client */
{
if (hexstrm)
{
strcpy(tempa,inet_ntoa(fromaddr.sin_addr));
strcpy(tempb,inet_ntoa(servaddr.sin_addr));
fprintf(hexstrm,"%d: clt prot=UDP from=%s:%hu to=%s:%hu length=%d\n",
udpsock,
tempa,
ntohs(fromaddr.sin_port),
tempb,
ntohs(servaddr.sin_port),
len);
hexdump(hexstrm,packet_get_raw_data(upacket,0),len);
}
/*queue_push_packet(virtconn_get_serverout_queue(vc));*/
for (;;) /* hack.. just block for now */
{
if (psock_sendto(udpsock,packet_get_raw_data_const(upacket,0),len,0,
(struct sockaddr *)&servaddr,(psock_t_socklen)sizeof(servaddr))<len)
{
if (psock_errno()==PSOCK_EINTR || psock_errno()==PSOCK_EAGAIN || psock_errno()==PSOCK_EWOULDBLOCK)
continue;
eventlog(eventlog_level_error,__FUNCTION__,"could not send UDP datagram to server (psock_sendto: %s)",pstrerror(psock_errno()));
}
break;
}
}
}
}
packet_del_ref(upacket);
}
}
/* search connections for sockets that need service */
eventlog(eventlog_level_debug,__FUNCTION__,"checking for sockets that need service");
LIST_TRAVERSE_CONST(virtconnlist(),curr)
{
unsigned int currsize;
t_packet * packet;
vc = elem_get_data(curr);
csocket = virtconn_get_client_socket(vc);
if (virtconn_get_state(vc)==virtconn_state_connected ||
virtconn_get_state(vc)==virtconn_state_connecting)
ssocket = virtconn_get_server_socket(vc);
else
ssocket = -1;
eventlog(eventlog_level_debug,__FUNCTION__,"checking %d for client readability",csocket);
if (PSOCK_FD_ISSET(csocket,&rfds))
{
if (virtconn_get_state(vc)==virtconn_state_initial)
{
if (init_virtconn(vc,servaddr)<0)
{
virtconn_destroy(vc);
continue;
}
}
else
{
currsize = virtconn_get_clientin_size(vc);
if (!queue_get_length(virtconn_get_clientin_queue(vc)))
{
switch (virtconn_get_class(vc))
{
case virtconn_class_bnet:
if (!(packet = packet_create(packet_class_bnet)))
{
eventlog(eventlog_level_error,__FUNCTION__,"could not allocate normal packet for input");
continue;
}
break;
case virtconn_class_file:
if (!(packet = packet_create(packet_class_file)))
{
eventlog(eventlog_level_error,__FUNCTION__,"could not allocate file packet for input");
continue;
}
break;
case virtconn_class_bot:
if (!(packet = packet_create(packet_class_raw)))
{
eventlog(eventlog_level_error,__FUNCTION__,"could not allocate raw packet for input");
continue;
}
packet_set_size(packet,1); /* start by only reading one char */
break;
default:
eventlog(eventlog_level_error,__FUNCTION__,"[%d] connection has bad type (closing connection)",virtconn_get_client_socket(vc));
virtconn_destroy(vc);
continue;
}
queue_push_packet(virtconn_get_clientin_queue(vc),packet);
packet_del_ref(packet);
if (!queue_get_length(virtconn_get_clientin_queue(vc)))
continue; /* push failed */
currsize = 0;
}
packet = queue_peek_packet((t_queue const * const *)virtconn_get_clientin_queue(vc)); /* avoid warning */
switch (net_recv_packet(csocket,packet,&currsize))
{
case -1:
virtconn_destroy(vc);
continue;
case 0: /* still working on it */
virtconn_set_clientin_size(vc,currsize);
break;
case 1: /* done reading */
if (virtconn_get_class(vc)==virtconn_class_bot &&
currsize<MAX_PACKET_SIZE)
{
char const * const temp=packet_get_raw_data_const(packet,0);
if (temp[currsize-1]!='\r' && temp[currsize-1]!='\n')
{
virtconn_set_clientin_size(vc,currsize);
packet_set_size(packet,currsize+1);
break; /* no end of line, get another char */
}
/* got a complete line... fall through */
}
packet = queue_pull_packet(virtconn_get_clientin_queue(vc));
if (hexstrm)
{
fprintf(hexstrm,"%d: cli class=%s[0x%04hx] type=%s[0x%04hx] length=%hu\n",
csocket,
packet_get_class_str(packet),packet_get_class(packet),
packet_get_type_str(packet,packet_dir_from_client),packet_get_type(packet),
packet_get_size(packet));
hexdump(hexstrm,packet_get_raw_data_const(packet,0),packet_get_size(packet));
}
queue_push_packet(virtconn_get_serverout_queue(vc),packet);
packet_del_ref(packet);
virtconn_set_clientin_size(vc,0);
}
}
}
eventlog(eventlog_level_debug,__FUNCTION__,"checking %d for server readability",ssocket);
if (ssocket!=-1 && PSOCK_FD_ISSET(ssocket,&rfds))
{
currsize = virtconn_get_serverin_size(vc);
if (!queue_get_length(virtconn_get_serverin_queue(vc)))
{
switch (virtconn_get_class(vc))
{
case virtconn_class_bnet:
if (!(packet = packet_create(packet_class_bnet)))
{
eventlog(eventlog_level_error,__FUNCTION__,"could not allocate normal packet for input");
continue;
}
break;
case virtconn_class_file:
{
unsigned int fileleft;
if ((fileleft = virtconn_get_fileleft(vc))>0)
{
if (!(packet = packet_create(packet_class_raw)))
{
eventlog(eventlog_level_error,__FUNCTION__,"could not allocate raw file packet for input");
continue;
}
if (fileleft>MAX_PACKET_SIZE)
packet_set_size(packet,MAX_PACKET_SIZE);
else
packet_set_size(packet,fileleft);
}
else
{
if (!(packet = packet_create(packet_class_file)))
{
eventlog(eventlog_level_error,__FUNCTION__,"could not allocate file packet for input");
continue;
}
}
}
break;
case virtconn_class_bot:
if (!(packet = packet_create(packet_class_raw)))
{
eventlog(eventlog_level_error,__FUNCTION__,"could not allocate raw packet for input");
continue;
}
packet_set_size(packet,MAX_PACKET_SIZE); /* read as much as possible */
break;
default:
eventlog(eventlog_level_error,__FUNCTION__,"[%d] connection has bad type (closing connection)",virtconn_get_client_socket(vc));
virtconn_destroy(vc);
continue;
}
queue_push_packet(virtconn_get_serverin_queue(vc),packet);
packet_del_ref(packet);
if (!queue_get_length(virtconn_get_serverin_queue(vc)))
continue; /* push failed */
currsize = 0;
}
packet = queue_peek_packet((t_queue const * const *)virtconn_get_serverin_queue(vc)); /* avoid warning */
switch (net_recv_packet(ssocket,packet,&currsize))
{
case -1:
virtconn_destroy(vc);
continue;
case 0: /* still working on it */
virtconn_set_serverin_size(vc,currsize);
if (virtconn_get_class(vc)!=virtconn_class_bot || currsize<1)
break;
else
packet_set_size(packet,currsize);
/* fallthough... we take what we can get with the bot data */
case 1: /* done reading */
packet = queue_pull_packet(virtconn_get_serverin_queue(vc));
if (virtconn_get_class(vc)==virtconn_class_file)
{
unsigned int len=virtconn_get_fileleft(vc);
if (len)
virtconn_set_fileleft(vc,len-currsize);
else if (packet_get_type(packet)==SERVER_FILE_REPLY &&
packet_get_size(packet)>=sizeof(t_server_file_reply))
virtconn_set_fileleft(vc,bn_int_get(packet->u.server_file_reply.filelen));
}
queue_push_packet(virtconn_get_clientout_queue(vc),packet);
packet_del_ref(packet);
virtconn_set_serverin_size(vc,0);
}
}
eventlog(eventlog_level_debug,__FUNCTION__,"checking %d for client writeability",csocket);
if (PSOCK_FD_ISSET(csocket,&wfds))
{
currsize = virtconn_get_clientout_size(vc);
switch (net_send_packet(csocket,queue_peek_packet((t_queue const * const *)virtconn_get_clientout_queue(vc)),&currsize)) /* avoid warning */
{
case -1:
virtconn_destroy(vc);
continue;
case 0: /* still working on it */
virtconn_set_clientout_size(vc,currsize);
break;
case 1: /* done sending */
packet = queue_pull_packet(virtconn_get_clientout_queue(vc));
if (hexstrm)
{
fprintf(hexstrm,"%d: srv class=%s[0x%04hx] type=%s[0x%04hx] length=%hu\n",
csocket,
packet_get_class_str(packet),packet_get_class(packet),
packet_get_type_str(packet,packet_dir_from_server),packet_get_type(packet),
packet_get_size(packet));
hexdump(hexstrm,packet_get_raw_data(packet,0),packet_get_size(packet));
}
packet_del_ref(packet);
virtconn_set_clientout_size(vc,0);
}
}
eventlog(eventlog_level_debug,__FUNCTION__,"checking %d for server writeability",ssocket);
if (ssocket!=-1 && PSOCK_FD_ISSET(ssocket,&wfds))
{
if (virtconn_get_state(vc)==virtconn_state_connecting)
{
int err;
psock_t_socklen errlen;
err = 0;
errlen = sizeof(err);
if (psock_getsockopt(ssocket,PSOCK_SOL_SOCKET,PSOCK_SO_ERROR,&err,&errlen)<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"[%d] unable to read socket error (psock_getsockopt[psock_connect]: %s)",virtconn_get_client_socket(vc),pstrerror(psock_errno()));
virtconn_destroy(vc);
continue;
}
if (errlen==0 || err==0)
virtconn_set_state(vc,virtconn_state_connected);
else
{
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not connect to server (psock_getsockopt[psock_connect]: %s)",virtconn_get_client_socket(vc),pstrerror(err));
virtconn_destroy(vc);
continue;
}
}
else
{
currsize = virtconn_get_serverout_size(vc);
switch (net_send_packet(ssocket,queue_peek_packet((t_queue const * const *)virtconn_get_serverout_queue(vc)),&currsize)) /* avoid warning */
{
case -1:
virtconn_destroy(vc);
continue;
case 0: /* still working on it */
virtconn_set_serverout_size(vc,currsize);
break;
case 1: /* done sending */
packet = queue_pull_packet(virtconn_get_serverout_queue(vc));
packet_del_ref(packet);
virtconn_set_serverout_size(vc,0);
}
}
}
}
