void HttpServerConnection::finish() {
finishHeader();
if(out_encoding_chunked) // finish chunk
async_write("\r\n0\r\n\r\n");
async_write_buffered();
if(keep_alive) {
write_state = LINE;
set_nodelay(true); // flushes it
set_nodelay(false);
} else
gracefulClose();
}
int
accept_client(int listen_socket) {
int sock = accept(listen_socket, NULL, NULL);
exit_error(sock, "accept");
set_nodelay(sock);
return sock;
}
int
connect_peer(char *peer, char *port) {
struct addrinfo *addr = get_peer_addr(peer, port);
int sock = get_socket(addr);
connect_addr(sock, addr);
set_nodelay(sock);
freeaddrinfo(addr);
return sock;
}
void network_t::update() {
int num = epoll_wait(epfd, events, max_conn, -1);
#pragma omp parallel for
for (int i=0; i<num; ++i) {
epoll_event* ev = events+i;
mydata_t* md = (mydata_t*)ev->data.ptr;
if (md->fd == acceptor) {
sockaddr_in client_addr;
socklen_t sinsize = sizeof(client_addr);
int newfd = accept(acceptor, (sockaddr*)&client_addr, &sinsize);
while (newfd >= 0) {
set_nonblock(newfd);
set_linger(newfd, 0);
set_nodelay(newfd);
auto md = deal_event(epfd, EPOLL_CTL_ADD, newfd, EPOLLIN|EPOLLET, new mydata_t);
logon(md);
newfd = accept(acceptor, (sockaddr*)&client_addr, &sinsize);
}
if (errno != EWOULDBLOCK && errno != EAGAIN) {
perror("accept newfd");
continue;
}
} else {
if (ev->events & (EPOLLERR | EPOLLHUP)) {
md->close();
} else {
if (ev->events & EPOLLIN) {
md->deal_read();
}
if (ev->events & EPOLLOUT) {
md->deal_write();
}
}
if (md->closed.load()) {
logoff(md);
shutdown(md->fd, SHUT_RDWR);
close(md->fd);
delete md;
}
}
}
}
int tcpstruct_connect( char *addr , int port )
{
int newti ;
int s, r;
struct sockaddr_in svaddr;
struct hostent *he;
s = socket( AF_INET, SOCK_STREAM , 0 );
if(s<0)return -2;
bzero( &svaddr , sizeof( svaddr ));
svaddr.sin_family = AF_INET;
svaddr.sin_port = htons( port );
if( inet_aton( addr, &svaddr.sin_addr ) == 0 ){
he = gethostbyname( addr );
if( he == NULL ){
return TCPSTRUCT_EHOST;
}
memcpy( & svaddr.sin_addr.s_addr , he->h_addr ,
sizeof( struct in_addr));
}
r = connect( s , ( struct sockaddr*)&svaddr,sizeof(svaddr));
if( r < 0 ){
return TCPSTRUCT_ECONNECT;
}
set_nodelay( s );
newti = findregBlankCon( );
if( newti < 0 ){
fprintf( stderr , "Á¬½Óʧ°Ü: newti:%d\n", newti );
return TCPSTRUCT_ECFULL;
}
con[newti].fd = s;
memcpy( & con[newti].remoteaddr , &svaddr ,
sizeof( struct sockaddr_in));
return newti;
}
int tcpstruct_accept( int *tis , int ticount )
{
int i;
int sret;
int accepted = 0;
struct timeval t;
struct sockaddr_in sin;
fd_set rfds, wfds , efds;
FD_ZERO( & rfds );
FD_ZERO( & wfds );
FD_ZERO( & efds );
for(i=0;i<MAXCONNECTION;i++){
if( con[i].use &&
con[i].fd >= 0 && con[i].closed_by_remote ==0 ){
FD_SET( con[i].fd , & rfds );
FD_SET( con[i].fd , & wfds );
FD_SET( con[i].fd , & efds );
}
}
t = select_timeout;
sret = select( 1024, & rfds , (fd_set*)NULL, & efds , &t);
if( sret > 0 ) {
for(i=0;i< MAXCONNECTION;i++){
if( ( con[i].fd >= 0 ) && FD_ISSET( con[i].fd , &rfds ) ){
int fr = getFreeMem( );
int rr , readsize ;
if( fr <= 0 ) continue;
if( fr > sizeof(tmpbuf ) ){
readsize = sizeof( tmpbuf);
} else {
readsize = fr;
}
rr = read( con[i].fd , tmpbuf , readsize );
if( rr <= 0 ){
con[i].closed_by_remote = 1;
} else {
appendReadBuffer( i , tmpbuf , rr );
}
}
}
}
/* write */
t = select_timeout;
sret = select( 1024, (fd_set*)NULL, &wfds, & efds , &t);
if( sret > 0 ) {
for(i=0;i<MAXCONNECTION;i++){
if( ( con[i].fd >= 0 ) && FD_ISSET( con[i].fd , &wfds )){
char send_buf[4096];
int l , rr;
memset( send_buf, 0, sizeof( send_buf));
l = consumeMemBufList( con[i].mbtop_wi ,send_buf, sizeof(send_buf),0 , 1 );
rr = write( con[i].fd , send_buf , l );
if( rr < 0 ){
con[i].closed_by_remote = 1;
} else {
consumeMemBufList( con[i].mbtop_wi , send_buf, l, 1 , 0 );
}
}
}
}
for( i=0; i<ticount; i++){
int asret;
struct timeval t;
t.tv_sec =0;
t.tv_usec =0;
FD_ZERO( & rfds );
FD_ZERO( & wfds );
FD_ZERO( & efds );
FD_SET( mainsockfd , & rfds );
FD_SET( mainsockfd , & wfds );
FD_SET( mainsockfd , & efds );
asret = select( 1024, &rfds , &wfds , &efds, &t );
// Nuke 20040610: add asret>0 to avoid signal interrupt in select
if( (asret>0) && FD_ISSET( mainsockfd , & rfds )){
struct sockaddr_in c;
int len , newsockfd;
int newcon;
bzero( &c , sizeof( c ));
len = sizeof( c );
fprintf( stderr, "i can accept " );
newcon = findregBlankCon( );
if( newcon < 0 ) continue;
newsockfd = accept( mainsockfd, (struct sockaddr*)&c , &len );
log( "ͬÒâ: %d\n" , newsockfd );
if( newsockfd < 0 ){
unregMemBuf( newcon );
continue;
}
char ipbuf[64];
char ipmsg[2048];
FILE *ipfp;
ipfp = fopen( "ip.txt" , "r" );
if( ipfp != NULL ){
//log("111111111\n");
while(fgets(ipbuf, sizeof(ipbuf), ipfp)){
sprintf(ipmsg,"%s%s",ipmsg,ipbuf);
}
fclose(ipfp);
unsigned long sinip;
memcpy( &sinip, &c.sin_addr, 4);
int ipa,ipb,ipc,ipd;
char ip[32];
ipa=(sinip % 0x100); sinip=sinip / 0x100;
ipb=(sinip % 0x100); sinip=sinip / 0x100;
ipc=(sinip % 0x100); sinip=sinip / 0x100;
ipd=(sinip % 0x100);
sprintf(ip,".%d.%d.%d.%d.",ipa,ipb,ipc,ipd);
//log("ip=%s,ip1=%s\n",ip,ipmsg);
if(strstr(ipmsg,ip)==NULL){
close(newsockfd);
unregMemBuf( newcon );
continue;
}
}
set_nodelay( newsockfd );
con[newcon].fd = newsockfd;
memcpy( &con[newcon].remoteaddr , &c ,sizeof(c));
tis[accepted] = newcon;
accepted ++;
}
}
return accepted;
}
int
meta_exchange_snd(int connected_fd, int file_fd)
{
int ret = 0;
ssize_t len;
ssize_t file_size;
struct ns_hdr ns_hdr;
struct stat stat_buf;
int perform_rtt;
memset(&ns_hdr, 0, sizeof(struct ns_hdr));
/* fetch file size */
xfstat(file_fd, &stat_buf, opts.infile);
file_size = S_ISREG(stat_buf.st_mode) ? stat_buf.st_size : 0;
ns_hdr.magic = htons(NS_MAGIC);
/* FIXME: catch overflow */
ns_hdr.version = htons((uint16_t) strtol(VERSIONSTRING, (char **)NULL, 10));
ns_hdr.data_size = htonl(file_size);
perform_rtt = (opts.rtt_probe_opt.iterations > 0) ? 1 : 0;
ns_hdr.nse_nxt_hdr = perform_rtt ? htons(NSE_NXT_RTT_PROBE) : htons(NSE_NXT_DATA);
len = sizeof(struct ns_hdr);
if (writen(connected_fd, &ns_hdr, len) != len)
err_msg_die(EXIT_FAILHEADER, "Can't send netsend header!\n");
/* probe for effective round trip time */
if (opts.rtt_probe_opt.iterations > 0) {
int flag_old;
struct sigaction sa;
/* initialize signalhandler for timeout handling */
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_INTERRUPT; /* don't restart system calls */
sa.sa_handler = timout_handler;
if (sigaction(SIGALRM, &sa, NULL) != 0)
err_sys("Can't add signal handler");
/* set TCP_NODELAY so tcp writes dont get buffered */
if (opts.protocol == IPPROTO_TCP) {
if ((flag_old = set_nodelay(connected_fd, 1)) < 0) {
err_sys("Can't set TCP_NODELAY for socket (ret: %d)",
flag_old);
}
}
alarm(TIMEOUT_SEC);
probe_rtt(connected_fd, NSE_NXT_DATA,
opts.rtt_probe_opt.iterations, opts.rtt_probe_opt.data_size);
alarm(0);
/* and restore TCP_NOPUSH */
if (opts.protocol == IPPROTO_TCP) {
if ((set_nodelay(connected_fd, flag_old)) < 0) {
err_sys("Can't set TCP_NODELAY for socket");
}
}
/* transmitt our rtt probe results to our peer */
send_rtt_info(connected_fd, NSE_NXT_DATA, &net_stat.rtt_probe);
}
/* XXX: add shasum next header if opts.sha, modify nse_nxt_hdr processing */
return ret;
}
int tcpstruct_work_accept( int *tis , int ticount )
{
int i,j;
int sret;
int accepted = 0;
struct timeval t;
char tmpbuf[256];
fd_set rfds, wfds , efds;
FD_ZERO( &rfds );
FD_ZERO( &wfds );
FD_ZERO( &efds );
select_timeout.tv_sec = 0;
select_timeout.tv_usec = 0;
for( i=0; i<MAXWORKCONNECTION; i++){
if( cWork[i].use && cWork[i].fd >= 0 && cWork[i].closed_by_remote ==0 ){
FD_SET( cWork[i].fd , & rfds );
FD_SET( cWork[i].fd , & wfds );
FD_SET( cWork[i].fd , & efds );
}
}
t = select_timeout;
sret = select( 1024, & rfds , (fd_set*)NULL, & efds , &t);
if( sret > 0 ) {
for(i=0;i< MAXWORKCONNECTION;i++){
if( cWork[i].use && ( cWork[i].fd >= 0 ) && FD_ISSET( cWork[i].fd , &rfds ) ){
int rr , readsize ;
readsize = sizeof( tmpbuf);
memset( tmpbuf, 0, sizeof( tmpbuf));
rr = read( cWork[i].fd , tmpbuf , readsize );
if( rr <= 0 ){
cWork[i].closed_by_remote = 1;
} else {
MEMBuffer_AddWkReadBuffer( i, tmpbuf, WK_R);
}
}
}
}
t = select_timeout;
sret = select( 1024 , (fd_set*)NULL, &wfds, & efds , &t);
if( sret > 0 ) {
for(i=0;i<MAXWORKCONNECTION;i++){
if( cWork[i].use && ( cWork[i].fd >= 0 ) && FD_ISSET( cWork[i].fd , &wfds )){
int rr;
memset( tmpbuf, 0, sizeof( tmpbuf));
if( MEMBuffer_getWkLineReadBuffer( i, tmpbuf, sizeof( tmpbuf), WK_W) <= 0 )
continue;
rr = write( cWork[i].fd , tmpbuf , strlen(tmpbuf) );
if( rr <= 0 ){
cWork[i].closed_by_remote = 1;
}else {
}
}
}
}
for(i=0; i<ticount; i++){
int asret;
struct timeval t;
t.tv_sec =0;
t.tv_usec =0;
FD_ZERO( & rfds );
FD_ZERO( & wfds );
FD_ZERO( & efds );
FD_SET( worksockfd , & rfds );
FD_SET( worksockfd , & wfds );
FD_SET( worksockfd , & efds );
asret = select( 1024, &rfds , &wfds , &efds, &t );
//if( FD_ISSET( worksockfd , & rfds )){
if( (asret>0) && FD_ISSET( worksockfd , & rfds )){
struct sockaddr_in c;
int len , newsockfd;
int newcon;
bzero( &c , sizeof( c ));
len = sizeof( c );
newcon = FindWorkRegBlankCon();
//newcon = FindWorkRegBlankCon( );
if( newcon < 0 ){
continue;
}
newsockfd = accept( worksockfd , (struct sockaddr*)&c , &len );
if( newsockfd < 0 ){
// UnWorkRegMemBuf( newcon );
continue;
}
if( MAXWK <= findWk ) continue;
set_nodelay( newsockfd );
cWork[newcon].fd = newsockfd;
memcpy( &cWork[newcon].remoteaddr , &c ,sizeof(c));
tis[accepted] = newcon;
//andy_add
for( j=0; j<MAXWK; j++) {
findWk++;
if( findWk >= MAXWK ) findWk=0;
if( wk[findWk].use != 1 && wk[findWk].fd < 0 ) {
wk[findWk].status = WKSTAT_IDLE;
wk[findWk].use = 1;
wk[findWk].ti = newcon;
wk[findWk].fd = newsockfd;
log( "accept WORK: sockfd:%d,newfd:%d=aWork:%d\n" , worksockfd, newsockfd, findWk);
break;
}
}
accepted ++;
}
}
return accepted;
}
int connect_to(const char *name, int port)
{
char buf[64];
char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
int fd, ret;
struct addrinfo hints, *res, *res0;
struct linger linger_opt = {1, 0};
memset(&hints, 0, sizeof(hints));
snprintf(buf, sizeof(buf), "%d", port);
hints.ai_socktype = SOCK_STREAM;
ret = getaddrinfo(name, buf, &hints, &res0);
if (ret) {
sd_err("failed to get address info: %m");
return -1;
}
for (res = res0; res; res = res->ai_next) {
ret = getnameinfo(res->ai_addr, res->ai_addrlen,
hbuf, sizeof(hbuf), sbuf, sizeof(sbuf),
NI_NUMERICHOST | NI_NUMERICSERV);
if (ret)
continue;
fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
if (fd < 0)
continue;
ret = setsockopt(fd, SOL_SOCKET, SO_LINGER, &linger_opt,
sizeof(linger_opt));
if (ret) {
sd_err("failed to set SO_LINGER: %m");
close(fd);
continue;
}
ret = set_snd_timeout(fd);
if (ret) {
sd_err("failed to set send timeout: %m");
close(fd);
break;
}
ret = set_rcv_timeout(fd);
if (ret) {
sd_err("failed to set recv timeout: %m");
close(fd);
break;
}
reconnect:
ret = connect(fd, res->ai_addr, res->ai_addrlen);
if (ret) {
if (errno == EINTR)
goto reconnect;
sd_err("failed to connect to %s:%d: %m", name, port);
close(fd);
continue;
}
ret = set_nodelay(fd);
if (ret) {
sd_err("%m");
close(fd);
break;
} else
goto success;
}
fd = -1;
success:
freeaddrinfo(res0);
sd_debug("%d, %s:%d", fd, name, port);
return fd;
}
/**
* @brief
* This function provides the port forwarding feature for forwarding the
* X data from mom to qsub and from qsub to the X server.
*
* @param socks[in] - Input structure which tracks the sockets that are active
* and data read/written by peers.
* @param connfunc[in] - Function pointer pointing to a function used for
* either connecting the X server (if running in qsub) or
* connecting qsub (if running in mom).
* @param phost[in] - peer host that needs to be connected.
* @param pport[in] - peer port number.
* @param inter_read_sock[in] - socket descriptor from where mom and qsub
* readers read data.
* @param readfunc[in] - function pointer pointing to the mom and qsub readers.
* @param logfunc[in] - Function pointer for log function
*
* @return void
*/
void
port_forwarder(
struct pfwdsock *socks,
int (*connfunc)(char *, long),
char *phost,
int pport,
int inter_read_sock,
int (*readfunc)(int),
void (*logfunc) (char *))
{
fd_set rfdset, wfdset, efdset;
int rc, maxsock = 0;
struct sockaddr_in from;
pbs_socklen_t fromlen;
int n, n2, sock;
fromlen = sizeof(from);
char err_msg[LOG_BUF_SIZE];
int readfunc_ret;
/*
* Make the sockets in the socks structure non blocking
*/
for (n = 0; n < NUM_SOCKS; n++) {
if (!(socks + n)->active || ((socks + n)->sock < 0))
continue;
if (set_nonblocking((socks + n)->sock) == -1) {
close((socks + n)->sock);
(socks + n)->active = 0;
snprintf(err_msg, sizeof(err_msg),
"set_nonblocking failed for socket=%d, errno=%d",
(socks + n)->sock, errno);
PF_LOGGER(logfunc, err_msg);
continue;
}
if (set_nodelay((socks + n)->sock) == -1) {
snprintf(err_msg, sizeof(err_msg),
"set_nodelay failed for socket=%d, errno=%d",
(socks + n)->sock, errno);
PF_LOGGER(logfunc, err_msg);
}
}
while (x11_reader_go) {
FD_ZERO(&rfdset);
FD_ZERO(&wfdset);
FD_ZERO(&efdset);
maxsock = inter_read_sock + 1;
/*setting the sock fd in rfdset for qsub and mom readers to read data*/
FD_SET(inter_read_sock, &rfdset);
FD_SET(inter_read_sock, &efdset);
for (n = 0; n < NUM_SOCKS; n++) {
if (!(socks + n)->active || ((socks + n)->sock < 0))
continue;
if ((socks + n)->listening) {
FD_SET((socks + n)->sock, &rfdset);
maxsock = (socks + n)->sock > maxsock ?(socks + n)->sock : maxsock;
} else{
if ((socks + n)->bufavail < PF_BUF_SIZE) {
FD_SET((socks + n)->sock, &rfdset);
maxsock = (socks + n)->sock > maxsock ?(socks + n)->sock : maxsock;
}
if ((socks + ((socks + n)->peer))->bufavail -
(socks + ((socks + n)->peer))->bufwritten > 0) {
FD_SET((socks + n)->sock, &wfdset);
maxsock = (socks + n)->sock > maxsock ?(socks + n)->sock : maxsock;
}
}
}
maxsock++;
rc = select(maxsock, &rfdset, &wfdset, &efdset, NULL);
if ((rc == -1) && (errno == EINTR))
continue;
if (rc < 0) {
snprintf(err_msg, sizeof(err_msg),
"port forwarding select() error");
PF_LOGGER(logfunc, err_msg);
return;
}
if (FD_ISSET(inter_read_sock, &efdset)) {
snprintf(err_msg, sizeof(err_msg),
"exception for socket=%d, errno=%d",
inter_read_sock, errno);
PF_LOGGER(logfunc, err_msg);
close(inter_read_sock);
return;
}
if (FD_ISSET(inter_read_sock, &rfdset)) {
/*calling mom/qsub readers*/
readfunc_ret = readfunc(inter_read_sock);
if (readfunc_ret == -1) {
snprintf(err_msg, sizeof(err_msg),
"readfunc failed for socket:%d", inter_read_sock);
PF_LOGGER(logfunc, err_msg);
}
if (readfunc_ret < 0) {
return;
}
}
for (n = 0; n < NUM_SOCKS; n++) {
if (!(socks + n)->active || ((socks + n)->sock < 0))
continue;
if (FD_ISSET((socks + n)->sock, &rfdset)) {
if ((socks + n)->listening && (socks + n)->active) {
int newsock = 0, peersock = 0;
if ((sock = accept((socks + n)->sock, (struct sockaddr *)
& from, &fromlen)) < 0) {
if ((errno == EAGAIN) || (errno == EWOULDBLOCK)
|| (errno == EINTR) || (errno == ECONNABORTED))
continue;
snprintf(err_msg, sizeof(err_msg),
"closing the socket %d after accept call failure, errno=%d",
(socks + n)->sock, errno);
PF_LOGGER(logfunc, err_msg);
close((socks + n)->sock);
(socks + n)->active = 0;
continue;
}
/*
* Make the sock non blocking
*/
if (set_nonblocking(sock) == -1) {
snprintf(err_msg, sizeof(err_msg),
"set_nonblocking failed for socket=%d, errno=%d",
sock, errno);
PF_LOGGER(logfunc, err_msg);
close(sock);
continue;
}
if (set_nodelay(sock) == -1) {
snprintf(err_msg, sizeof(err_msg),
"set_nodelay failed for socket=%d, errno=%d",
sock, errno);
PF_LOGGER(logfunc, err_msg);
}
newsock = peersock = 0;
for (n2 = 0; n2 < NUM_SOCKS; n2++) {
if ((socks + n2)->active || (((socks + n2)->peer != 0)
&& (socks + ((socks + n2)->peer))->active))
continue;
if (newsock == 0)
newsock = n2;
else if (peersock == 0)
peersock = n2;
else
break;
}
(socks + newsock)->sock = (socks + peersock)->remotesock
= sock;
(socks + newsock)->listening = (socks + peersock)->listening
= 0;
(socks + newsock)->active = (socks + peersock)->active = 1;
(socks + peersock)->sock = connfunc(phost, pport);
/*
* Make sockets non-blocking
*/
if (set_nonblocking((socks + peersock)->sock) == -1) {
snprintf(err_msg, sizeof(err_msg),
"set_nonblocking failed for socket=%d, errno=%d",
(socks + peersock)->sock, errno);
PF_LOGGER(logfunc, err_msg);
close((socks + peersock)->sock);
(socks + peersock)->active = 0;
continue;
}
if (set_nodelay((socks + peersock)->sock) == -1) {
snprintf(err_msg, sizeof(err_msg),
"set_nodelay failed for socket=%d, errno=%d",
(socks + peersock)->sock, errno);
PF_LOGGER(logfunc, err_msg);
}
(socks + newsock)->bufwritten = (socks + peersock)->bufwritten = 0;
(socks + newsock)->bufavail = (socks + peersock)->bufavail = 0;
(socks + newsock)->buff[0] = (socks + peersock)->buff[0] = '\0';
(socks + newsock)->peer = peersock;
(socks + peersock)->peer = newsock;
} else{
/* non-listening socket to be read */
rc = read(
(socks + n)->sock,
(socks + n)->buff + (socks + n)->bufavail,
PF_BUF_SIZE - (socks + n)->bufavail);
if (rc == -1) {
if ((errno == EWOULDBLOCK) || (errno == EAGAIN) || (errno == EINTR) || (errno == EINPROGRESS)) {
continue;
}
shutdown((socks + n)->sock, SHUT_RDWR);
close((socks + n)->sock);
(socks + n)->active = 0;
snprintf(err_msg, sizeof(err_msg),
"closing the socket %d after read failure, errno=%d",
(socks + n)->sock, errno);
PF_LOGGER(logfunc, err_msg);
} else if (rc == 0) {
shutdown((socks + n)->sock, SHUT_RDWR);
close((socks + n)->sock);
(socks + n)->active = 0;
} else{
(socks + n)->bufavail += rc;
}
}
} /* END if rfdset */
if (FD_ISSET((socks + n)->sock, &wfdset)) {
int peer = (socks + n)->peer;
rc = write(
(socks + n)->sock,
(socks + peer)->buff + (socks + peer)->bufwritten,
(socks + peer)->bufavail - (socks + peer)->bufwritten);
if (rc == -1) {
if ((errno == EWOULDBLOCK) || (errno == EAGAIN) || (errno == EINTR) || (errno == EINPROGRESS)) {
continue;
}
shutdown((socks + n)->sock, SHUT_RDWR);
close((socks + n)->sock);
(socks + n)->active = 0;
snprintf(err_msg, sizeof(err_msg),
"closing the socket %d after write failure, errno=%d",
(socks + n)->sock, errno);
PF_LOGGER(logfunc, err_msg);
} else if (rc == 0) {
shutdown((socks + n)->sock, SHUT_RDWR);
close((socks + n)->sock);
(socks + n)->active = 0;
} else{
(socks + peer)->bufwritten += rc;
}
} /* END if wfdset */
if (!(socks + n)->listening) {
int peer = (socks + n)->peer;
if ((socks + peer)->bufavail == (socks + peer)->bufwritten) {
(socks + peer)->bufavail = (socks + peer)->bufwritten = 0;
}
if (!(socks + peer)->active && ((socks + peer)->bufwritten
== (socks + peer)->bufavail)) {
shutdown((socks + n)->sock, SHUT_RDWR);
close((socks + n)->sock);
(socks + n)->active = 0;
}
}
} /* END foreach fd */
} /* END while(x11_reader_go) */
} /* END port_forwarder() */
/**
* @brief
* This function is called whenever there is a connection accepted by the
* port forwarder at qsub side. It will further send the data read by port
* forwarder to the x server listening on the display number set in the
* environment.
* @param[in] display - The display number where X server is listening in
* qsub.
* @param[in] alsounused - This parameter is not used. its there just to
* maintain consistency between function pointers used
* by port_forwarder.
* @return int
* @retval socket number which is connected to Xserver. success
* @retval -1 Failure
*/
int
x11_connect_display(
char *display,
long alsounused)
{
int display_number, sock = 0;
char buf[1024], *cp;
struct addrinfo hints, *ai, *aitop;
char strport[NI_MAXSERV];
int gaierr;
/*
* Now we decode the value of the DISPLAY variable and make a
* connection to the real X server.
*/
/*
* Check if it is a unix domain socket. Unix domain displays are in
* one of the following formats: unix:d[.s], :d[.s], ::d[.s]
*/
if (strncmp(display, "unix:", 5) == 0 ||
display[0] == ':') {
/* Connect to the unix domain socket. */
if (sscanf(strrchr(display, ':') + 1, "%d", &display_number) != 1) {
fprintf(stderr, "Could not parse display number from DISPLAY: %.100s",
display);
return -1;
}
/* Create a socket. */
sock = connect_local_xsocket(display_number);
if (sock < 0)
return -1;
/* OK, we now have a connection to the display. */
return sock;
}
/*
* Connect to an inet socket. The DISPLAY value is supposedly
* hostname:d[.s], where hostname may also be numeric IP address.
*/
strncpy(buf, display, sizeof(buf));
cp = strchr(buf, ':');
if (!cp) {
fprintf(stderr, "Could not find ':' in DISPLAY: %.100s", display);
return -1;
}
*cp = 0;
/* buf now contains the host name. But first we parse the display number. */
if (sscanf(cp + 1, "%d", &display_number) != 1) {
fprintf(stderr, "Could not parse display number from DISPLAY: %.100s",
display);
return -1;
}
/* Look up the host address */
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
snprintf(strport, sizeof(strport), "%d", 6000 + display_number);
if ((gaierr = getaddrinfo(buf, strport, &hints, &aitop)) != 0) {
fprintf(stderr, "%100s: unknown host. (%s)", buf, gai_strerror(gaierr));
return -1;
}
for (ai = aitop; ai; ai = ai->ai_next) {
/* Create a socket. */
sock = socket(ai->ai_family, SOCK_STREAM, 0);
if (sock < 0) {
fprintf(stderr, "socket: %.100s", strerror(errno));
continue;
}
/* Connect it to the display. */
if (connect(sock, ai->ai_addr, ai->ai_addrlen) < 0) {
fprintf(stderr, "connect %.100s port %d: %.100s", buf,
6000 + display_number, strerror(errno));
close(sock);
continue;
}
/* Success */
break;
}
freeaddrinfo(aitop);
if (!ai) {
fprintf(stderr, "connect %.100s port %d: %.100s", buf, 6000 + display_number,
strerror(errno));
return -1;
}
set_nodelay(sock);
return sock;
}
int tcpstruct_accept( int *tis , int ticount )
{
int i;
int sret;
int accepted = 0;
struct timeval t;
fd_set rfds, wfds , efds;
FD_ZERO( & rfds );
FD_ZERO( & wfds );
FD_ZERO( & efds );
for(i=0;i<MAXCONNECTION;i++){
if( con[i].use &&
con[i].fd >= 0 && con[i].closed_by_remote ==0 ){
FD_SET( con[i].fd , & rfds );
FD_SET( con[i].fd , & wfds );
FD_SET( con[i].fd , & efds );
}
}
t = select_timeout;
sret = select( 1024, & rfds , (fd_set*)NULL, & efds , &t);
if( sret > 0 ) {
for(i=0;i< MAXCONNECTION;i++){
if( ( con[i].fd >= 0 ) && FD_ISSET( con[i].fd , &rfds ) ){
int fr = getFreeMem( );
int rr , readsize ;
if( fr <= 0 ) continue;
if( fr > sizeof(tmpbuf ) ){
readsize = sizeof( tmpbuf);
} else {
readsize = fr;
}
rr = read( con[i].fd , tmpbuf , readsize );
if( rr <= 0 ){
con[i].closed_by_remote = 1;
} else {
appendReadBuffer( i , tmpbuf , rr );
}
}
}
}
/* write */
t = select_timeout;
sret = select( 1024, (fd_set*)NULL, &wfds, & efds , &t);
if( sret > 0 ) {
for(i=0;i<MAXCONNECTION;i++){
if( ( con[i].fd >= 0 ) && FD_ISSET( con[i].fd , &wfds )){
char send_buf[4096];
int l , rr;
memset( send_buf, 0, sizeof( send_buf));
l = consumeMemBufList( con[i].mbtop_wi ,send_buf, sizeof(send_buf),0 , 1 );
rr = write( con[i].fd , send_buf , l );
if( rr < 0 ){
con[i].closed_by_remote = 1;
} else {
consumeMemBufList( con[i].mbtop_wi , send_buf, l, 1 , 0 );
}
}
}
}
for( i=0; i<ticount; i++){
int asret;
struct timeval t;
t.tv_sec =0;
t.tv_usec =0;
FD_ZERO( & rfds );
FD_ZERO( & wfds );
FD_ZERO( & efds );
FD_SET( mainsockfd , & rfds );
FD_SET( mainsockfd , & wfds );
FD_SET( mainsockfd , & efds );
asret = select( 1024, &rfds , &wfds , &efds, &t );
// Nuke 20040610: add asret>0 to avoid signal interrupt in select
if( (asret>0) && FD_ISSET( mainsockfd , & rfds )){
struct sockaddr_in c;
int len , newsockfd;
int newcon;
bzero( &c , sizeof( c ));
len = sizeof( c );
fprintf( stderr, "i can accept " );
newcon = findregBlankCon( );
if( newcon < 0 ) continue;
newsockfd = accept( mainsockfd, (struct sockaddr*)&c , &len );
log( "ͬ��: %d\n" , newsockfd );
if( newsockfd < 0 ){
unregMemBuf( newcon );
continue;
}
set_nodelay( newsockfd );
con[newcon].fd = newsockfd;
memcpy( &con[newcon].remoteaddr , &c ,sizeof(c));
tis[accepted] = newcon;
accepted ++;
}
}
return accepted;
}
int main(int argc, char **argv)
{
pthread_t thr;
char *host;
int port;
int i;
int c;
char random_state[16];
while ((c = getopt(argc, argv, "c:g:i:k:r:t:")) != EOF) {
switch (c) {
case 'c':
num_connections = intarg(argv[0], optarg);
break;
case 'g':
probability_get = intarg(argv[0], optarg);
break;
case 'i':
num_iterations = intarg(argv[0], optarg);
break;
case 'k':
num_keys = intarg(argv[0], optarg);
break;
case 'r':
num_requests = intarg(argv[0], optarg);
break;
case 's':
seed = intarg(argv[0], optarg);
break;
case 't':
poll_wait_sec = intarg(argv[0], optarg);
break;
default:
usage(argv[0]);
break;
}
}
initstate(seed, random_state, sizeof(random_state));
if (argc < optind + 2)
usage(argv[0]);
host = argv[optind++];
port = intarg(argv[0], argv[optind]);
fds = malloc(num_connections * sizeof(int));
if (fds == NULL) {
perror("malloc");
exit(1);
}
for (i = 0; i < num_connections; i++) {
fds[i] = clientsock(host, port);
if (fds[i] < 0) {
perror(host);
exit(1);
}
if ((i % 25) == 0) {
printf("\rOpened %d connections", i);
fflush(stdout);
}
set_nodelay(fds[i], 1);
set_nonblock(fds[i]);
}
printf("\rOpened %d connections\n", num_connections);
fd_in_use = calloc(1, fds[num_connections - 1]);
if (fd_in_use == NULL) {
perror("calloc");
exit(1);
}
pthread_mutex_init(&stats_mutex, NULL);
pthread_mutex_init(&fd_mutex, NULL);
for (i = 0; i < num_requests; i++)
pthread_create(&thr, NULL, thread_main, NULL);
while (iteration_count < num_iterations) {
poll(NULL, 0, 1000);
stats();
}
stats();
putchar('\n');
}
