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'); }