extern int net_recv_packet(int sock, t_packet * packet, unsigned int * currsize)
{
int addlen;
unsigned int header_size;
void * temp;
if (!packet) {
eventlog(eventlog_level_error,__FUNCTION__,"[%d] got NULL packet (closing connection)",sock);
return -1;
}
if (!currsize) {
eventlog(eventlog_level_error,__FUNCTION__,"[%d] got NULL currsize (closing connection)",sock);
return -1;
}
if ((header_size = packet_get_header_size(packet))>=MAX_PACKET_SIZE) {
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not determine header size (closing connection)",sock);
return -1;
}
if (!(temp = packet_get_raw_data_build(packet,*currsize))) {
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not obtain raw data pointer at offset %u (closing connection)",sock,*currsize);
return -1;
}
if (*currsize<header_size)
addlen = net_recv(sock, temp, header_size-*currsize);
else {
unsigned int total_size=packet_get_size(packet);
if (total_size<header_size) {
eventlog(eventlog_level_warn,__FUNCTION__,"[%d] corrupted packet received (total_size=%u currsize=%u) (closing connection)",sock,total_size,*currsize);
return -1;
}
if (*currsize>=total_size) {
eventlog(eventlog_level_warn,__FUNCTION__,"[%d] more data requested for already complete packet (total_size=%u currsize=%u) (closing connection)",sock,total_size,*currsize);
return -1;
}
addlen = net_recv(sock, temp, total_size-*currsize);
}
if (addlen<=0) return addlen;
*currsize += addlen;
if (*currsize>=header_size && *currsize==packet_get_size(packet))
return 1;
return 0;
}
/* Send a file. If the file doesn't exist we still need to respond
* to the file request. This will set filelen to 0 and send the server
* reply message and the client will be happy and not hang.
*/
extern int file_send(t_connection * c, char const * rawname, unsigned int adid, unsigned int etag, unsigned int startoffset, int need_header)
{
char const * filename;
t_packet * rpacket;
std::FILE * fp;
unsigned int filelen;
int nbytes;
if (!c)
{
eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
return -1;
}
if (!rawname)
{
eventlog(eventlog_level_error,__FUNCTION__,"got NULL rawname");
return -1;
}
if (!(rpacket = packet_create(packet_class_file)))
{
eventlog(eventlog_level_error,__FUNCTION__,"could not create file packet");
return -1;
}
packet_set_size(rpacket,sizeof(t_server_file_reply));
packet_set_type(rpacket,SERVER_FILE_REPLY);
if ((filename = file_get_info(rawname,&filelen,&rpacket->u.server_file_reply.timestamp)))
{
if (!(fp = std::fopen(filename,"rb")))
{
/* FIXME: check for lower-case version of filename */
eventlog(eventlog_level_error,__FUNCTION__, "stat() succeeded yet could not open file \"%s\" for reading (std::fopen: %s)", filename, std::strerror(errno));
filelen = 0;
}
xfree((void *)filename); /* avoid warning */
}
else
{
fp = NULL;
filelen = 0;
bn_long_set_a_b(&rpacket->u.server_file_reply.timestamp,0,0);
}
if (fp)
{
if (startoffset<filelen) {
std::fseek(fp,startoffset,SEEK_SET);
} else {
eventlog(eventlog_level_warn,__FUNCTION__,"[%d] startoffset is beyond end of file (%u>%u)",conn_get_socket(c),startoffset,filelen);
/* Keep the real filesize. Battle.net does it the same way ... */
std::fclose(fp);
fp = NULL;
}
}
if (need_header)
{
/* send the header from the server with the rawname and length. */
bn_int_set(&rpacket->u.server_file_reply.filelen,filelen);
bn_int_set(&rpacket->u.server_file_reply.adid,adid);
bn_int_set(&rpacket->u.server_file_reply.extensiontag,etag);
/* rpacket->u.server_file_reply.timestamp is set above */
packet_append_string(rpacket,rawname);
conn_push_outqueue(c,rpacket);
}
packet_del_ref(rpacket);
/* Now send the data. Since it may be longer than a packet; we use
* the raw packet class.
*/
if (!fp)
{
eventlog(eventlog_level_warn,__FUNCTION__,"[%d] sending no data for file \"%s\"",conn_get_socket(c),rawname);
return -1;
}
eventlog(eventlog_level_info,__FUNCTION__,"[%d] sending file \"%s\" of length %d",conn_get_socket(c),rawname,filelen);
for (;;)
{
if (!(rpacket = packet_create(packet_class_raw)))
{
eventlog(eventlog_level_error,__FUNCTION__,"could not create raw packet");
if (std::fclose(fp)<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not close file \"%s\" after reading (std::fclose: %s)",rawname,std::strerror(errno));
return -1;
}
if ((nbytes = std::fread(packet_get_raw_data_build(rpacket,0),1,MAX_PACKET_SIZE,fp))<(int)MAX_PACKET_SIZE)
{
if (nbytes>0) /* send out last portion */
{
packet_set_size(rpacket,nbytes);
conn_push_outqueue(c,rpacket);
}
packet_del_ref(rpacket);
if (std::ferror(fp))
eventlog(eventlog_level_error,__FUNCTION__,"read failed before EOF on file \"%s\" (std::fread: %s)",rawname,std::strerror(errno));
break;
}
packet_set_size(rpacket,nbytes);
conn_push_outqueue(c,rpacket);
packet_del_ref(rpacket);
}
if (std::fclose(fp)<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not close file \"%s\" after reading (std::fclose: %s)",rawname,std::strerror(errno));
return 0;
}
static int sd_udpinput(t_addr *const curr_laddr, const t_laddr_info *laddr_info,
int ssocket, int usocket)
{
int err;
psock_t_socklen errlen;
t_packet * upacket;
if (laddr_info == NULL) {
(void)ssocket;
}
err = 0;
errlen = sizeof(err);
if (psock_getsockopt(usocket,PSOCK_SOL_SOCKET,PSOCK_SO_ERROR,&err,&errlen)<0)
{
eventlog(eventlog_level_error,"sd_udpinput","[%d] unable to read socket error (psock_getsockopt: %s)",usocket,strerror(psock_errno()));
return -1;
}
if (errlen && err) /* if it was an error, there is no packet to read */
{
eventlog(eventlog_level_error,"sd_udpinput","[%d] async UDP socket error notification (psock_getsockopt: %s)",usocket,strerror(err));
return -1;
}
if (!(upacket = packet_create(packet_class_udp)))
{
eventlog(eventlog_level_error,"sd_udpinput","could not allocate raw packet for input");
return -1;
}
{
struct sockaddr_in fromaddr;
psock_t_socklen fromlen;
int len;
fromlen = sizeof(fromaddr);
if ((len = psock_recvfrom(usocket,packet_get_raw_data_build(upacket,0),MAX_PACKET_SIZE,0,(struct sockaddr *)&fromaddr,&fromlen))<0)
{
if (
#ifdef PSOCK_EINTR
psock_errno()!=PSOCK_EINTR &&
#endif
#ifdef PSOCK_EAGAIN
psock_errno()!=PSOCK_EAGAIN &&
#endif
#ifdef PSOCK_EWOULDBLOCK
psock_errno()!=PSOCK_EWOULDBLOCK &&
#endif
1)
eventlog(eventlog_level_error,"sd_udpinput","could not recv UDP datagram (psock_recvfrom: %s)",strerror(psock_errno()));
packet_del_ref(upacket);
return -1;
}
if (fromaddr.sin_family!=PSOCK_AF_INET)
{
eventlog(eventlog_level_error,"sd_udpinput","got UDP datagram with bad address family %d",(int)fromaddr.sin_family);
packet_del_ref(upacket);
return -1;
}
packet_set_size(upacket,len);
if (hexstrm)
{
char tempa[32];
if (!addr_get_addr_str(curr_laddr,tempa,sizeof(tempa)))
strcpy(tempa,"x.x.x.x:x");
fprintf(hexstrm,"%d: recv class=%s[0x%02x] type=%s[0x%04x] from=%s to=%s length=%u\n",
usocket,
packet_get_class_str(upacket),(unsigned int)packet_get_class(upacket),
packet_get_type_str(upacket,packet_dir_from_client),packet_get_type(upacket),
addr_num_to_addr_str(ntohl(fromaddr.sin_addr.s_addr),ntohs(fromaddr.sin_port)),
tempa,
packet_get_size(upacket));
hexdump(hexstrm,packet_get_raw_data(upacket,0),packet_get_size(upacket));
}
handle_udp_packet(usocket,ntohl(fromaddr.sin_addr.s_addr),ntohs(fromaddr.sin_port),upacket);
packet_del_ref(upacket);
}
return 0;
}
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);
}
}
}
}
extern int net_recv_packet(int sock, t_packet * packet, unsigned int * currsize)
{
int addlen;
unsigned int header_size;
void * temp;
if (!packet)
{
eventlog(eventlog_level_error,"net_recv_packet","[%d] got NULL packet (closing connection)",sock);
return -1;
}
if (!currsize)
{
eventlog(eventlog_level_error,"net_recv_packet","[%d] got NULL currsize (closing connection)",sock);
return -1;
}
if ((header_size = packet_get_header_size(packet))>=MAX_PACKET_SIZE)
{
eventlog(eventlog_level_error,"net_recv_packet","[%d] could not determine header size (closing connection)",sock);
return -1;
}
if (!(temp = packet_get_raw_data_build(packet,*currsize)))
{
eventlog(eventlog_level_error,"net_recv_packet","[%d] could not obtain raw data pointer at offset %u (closing connection)",sock,*currsize);
return -1;
}
if (*currsize<header_size)
{
addlen = psock_recv(sock,
temp,
header_size-*currsize,
0);
}
else
{
unsigned int total_size=packet_get_size(packet);
if (total_size<header_size)
{
eventlog(eventlog_level_warn,"net_recv_packet","[%d] corrupted packet received (total_size=%u currsize=%u) (closing connection)",sock,total_size,*currsize);
return -1;
}
if (*currsize>=total_size)
{
eventlog(eventlog_level_warn,"net_recv_packet","[%d] more data requested for already complete packet (total_size=%u currsize=%u) (closing connection)",sock,total_size,*currsize);
return -1;
}
addlen = psock_recv(sock,
temp,
total_size-*currsize,
0);
}
if (addlen==0)
{
eventlog(eventlog_level_debug,"net_recv_packet","[%d] remote host closed connection",sock);
return -1;
}
if (addlen<0)
{
if (
#ifdef PSOCK_EINTR
psock_errno()==PSOCK_EINTR ||
#endif
#ifdef PSOCK_EAGAIN
psock_errno()==PSOCK_EAGAIN ||
#endif
#ifdef PSOCK_EWOULDBLOCK
psock_errno()==PSOCK_EWOULDBLOCK ||
#endif
#ifdef PSOCK_ENOMEM
psock_errno()==PSOCK_ENOMEM ||
#endif
0) /* try later */
return 0;
if (
#ifdef PSOCK_ENOTCONN
psock_errno()==PSOCK_ENOTCONN ||
#endif
#ifdef PSOCK_ECONNRESET
psock_errno()==PSOCK_ECONNRESET ||
#endif
0)
{
/* eventlog(eventlog_level_debug,"net_recv_packet","[%d] remote host closed connection (psock_recv: %s)",sock,strerror(psock_errno())); */
return -1; /* common error: close connection, but no message */
}
eventlog(eventlog_level_error,"net_recv_packet","[%d] receive error (closing connection) (psock_recv: %s)",sock,strerror(psock_errno()));
return -1;
}
*currsize += addlen;
if (*currsize>=header_size && *currsize==packet_get_size(packet))
return 1;
return 0;
}
