int
main(int argc, char **argv)
{
int ret, i, connfd;
struct sockaddr_in cliaddr, servaddr;
socklen_t clilen, addrlen;
void sig_int(int);
pthread_t tid;
struct Thread *arg;
if (argc != 3)
err_quit("Usage: %s <port> <#threads>", basename(argv[0]));
nthreads = atoi(argv[2]);
if ((pThread = calloc(nthreads, sizeof(struct Thread))) == NULL)
err_sys("calloc error");
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(atoi(argv[1]));
Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));
Listen(listenfd, LISTENQ);
addrlen = sizeof(struct sockaddr_in);
for (i = 0; i < nthreads; i++) {
arg = pThread + i;
arg->id = i;
if ((ret = pthread_create(&tid, NULL, &mode_doit, (void *)arg)) != 0) {
errno = ret;
perror("pthread_create error");
exit(1);
}
}
Signal(SIGINT, sig_int);
iput = iget = 0;
for (;;) {
clilen = addrlen;
if ((connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen)) < 0)
err_sys("accept error");
if ((ret = pthread_mutex_lock(&mlock)) != 0) {
errno = ret;
perror("pthread_mutex_lock error");
exit(1);
}
clifd[iput] = connfd;
if (++iput == MAXNCLI)
iput = 0;
if (iput == iget)
err_quit("iput = iget = %d\n", iput);
if ((ret = pthread_cond_signal(&cond)) != 0) {
errno = ret;
perror("pthread_cond_signal error");
exit(1);
}
if ((ret = pthread_mutex_unlock(&mlock)) != 0) {
errno = ret;
perror("pthread_mutex_unlock error");
exit(1);
}
}
}
int main()
{
int Listenfd,connfd;
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
int val,len;
pthread_t recv_thread, send_thread,getinfo_thread;
int res;
Listenfd = Socket(AF_INET,SOCK_STREAM,0);
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(Listenfd,(SA*)&servaddr,sizeof(servaddr));
Listen(Listenfd,LISTENQ);
for( ; ;){
val = 3000;
len = sizeof(int);
Setsockopt(Listenfd, SOL_SOCKET, SO_RCVBUF,(void *)&val, len);
clilen = sizeof(cliaddr);
connfd = Accept(Listenfd,(SA*)&cliaddr,&clilen);
val = 1;
len = sizeof(int);
Setsockopt(connfd, SOL_SOCKET, SO_DEBUG,(void *)&val, len);
res = pthread_create(&getinfo_thread, NULL, get_info, (void *)(&connfd));
if (res != 0)
{
perror("Thread creation failed!");
exit(EXIT_FAILURE);
}
res = pthread_create(&recv_thread, NULL, recv_function, (void *)(&connfd));
if (res != 0)
{
perror("Thread creation failed!");
exit(EXIT_FAILURE);
}
res = pthread_create(&send_thread, NULL, send_function, (void *)(&connfd));
if (res != 0)
{
perror("Thread creation failed!");
exit(EXIT_FAILURE);
}
//sleep(200);
printf("close\n");
//交由系统回收关闭文件描述符
//Close(connfd);
}
return 0;
}
int
main(int argc, char **argv)
{
int i,j, maxi, maxfd, listenfd, connfd, sockfd;
int nready, client[FD_SETSIZE];
ssize_t n;
fd_set rset, allset;
char buf[MAXLINE];
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(7746);
Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));
Listen(listenfd, LISTENQ);
maxfd = listenfd; /* initialize */
maxi = -1; /* index into client[] array */
for (i = 0; i < FD_SETSIZE; i++)
client[i] = -1; /* -1 indicates available entry */
FD_ZERO(&allset);
FD_SET(listenfd, &allset);
/* end fig01 */
/* include fig02 */
for ( ; ; ) {
rset = allset; /* structure assignment */
nready = Select(maxfd+1, &rset, NULL, NULL, NULL);
if (FD_ISSET(listenfd, &rset)) { /* new client connection */
clilen = sizeof(cliaddr);
connfd = Accept(listenfd, (SA *) &cliaddr, &clilen);
#ifdef NOTDEF
printf("new client: %s, port %d\n",
Inet_ntop(AF_INET, &cliaddr.sin_addr, 4, NULL),
ntohs(cliaddr.sin_port));
#endif
for (i = 0; i < FD_SETSIZE; i++)
if (client[i] < 0) {
client[i] = connfd; /* save descriptor */
break;
}
if (i == FD_SETSIZE)
err_quit("too many clients");
FD_SET(connfd, &allset); /* add new descriptor to set */
if (connfd > maxfd)
maxfd = connfd; /* for select */
if (i > maxi)
maxi = i; /* max index in client[] array */
if (--nready <= 0)
continue; /* no more readable descriptors */
}
for (i = 0; i <= maxi; i++) { /* check all clients for data */
if ( (sockfd = client[i]) < 0)
continue;
if (FD_ISSET(sockfd, &rset)) {
if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {
/*4connection closed by client */
Close(sockfd);
FD_CLR(sockfd, &allset);
client[i] = -1;
} else
for(j = 0; j<= maxi;j++) {
if ((sockfd = client[j]) > 0 && i != j && strlen(buf) > 0) { //像自己以外的客户端发送信息
Writen(sockfd, buf, n);
}
}
Writen(fileno(stdout), buf, n);
if (--nready <= 0)
break; /* no more readable descriptors */
}
}
}
}
int
main(int argc, char **argv)
{
int sock_fd,msg_flags;
char readbuf[BUFFSIZE];
struct sockaddr_in servaddr, cliaddr;
struct sctp_sndrcvinfo sri;
struct sctp_event_subscribe evnts;
int stream_increment=1;
socklen_t len;
size_t rd_sz;
if (argc == 2)
stream_increment = atoi(argv[1]);
sock_fd = Socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(sock_fd, (SA *) &servaddr, sizeof(servaddr));
/* include mod_serv06 */
bzero(&evnts, sizeof(evnts));
evnts.sctp_data_io_event = 1;
evnts.sctp_association_event = 1;
evnts.sctp_address_event = 1;
evnts.sctp_send_failure_event = 1;
evnts.sctp_peer_error_event = 1;
evnts.sctp_shutdown_event = 1;
evnts.sctp_partial_delivery_event = 1;
evnts.sctp_adaptation_layer_event = 1;
Setsockopt(sock_fd, IPPROTO_SCTP, SCTP_EVENTS,
&evnts, sizeof(evnts));
Listen(sock_fd, LISTENQ);
printf("Start waiting...\n");
for ( ; ; ) {
len = sizeof(struct sockaddr_in);
rd_sz = Sctp_recvmsg(sock_fd, readbuf, sizeof(readbuf),
(SA *)&cliaddr, &len,
&sri,&msg_flags);
if(msg_flags & MSG_NOTIFICATION) { // 表示收到一個事件,而非一個資料
print_notification(readbuf);
continue;
}
/* end mod_serv06 */
if(stream_increment) {
sri.sinfo_stream++;
// getsockopt用在sctp有問題!!先跳過!
// if(sri.sinfo_stream >= sctp_get_no_strms(sock_fd,(SA *)&cliaddr, len))
if(sri.sinfo_stream >= 100)
sri.sinfo_stream = 0;
}
Sctp_sendmsg(sock_fd, readbuf, rd_sz,
(SA *)&cliaddr, len,
sri.sinfo_ppid,
sri.sinfo_flags,
sri.sinfo_stream,
0, 0);
}
}
int
main (int argc,char* argv[])
{
int i,maxi,listenfd,connfd,sockfd;
int nready;
ssize_t n;
char line[MAXLINE];
socklen_t clilen;
struct pollfd client[OPEN_MAX];
struct sockaddr_in cliaddr,servaddr;
listenfd = Socket(AF_INET,SOCK_STREAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(listenfd,(sockaddr*)&servaddr,sizeof(servaddr));
Listen(listenfd,LISTENQ);
client[0].fd = listenfd;
client[0].events = POLLRDNORM;
for (i=1;i<OPEN_MAX;++i)
client[i].fd = -1;//indicates avallable entry
maxi=0; //max index int client[]
for(;;)
{
//nready = poll(client,maxi+1,INFTIM);
nready = poll(client,maxi+1,-1);
if(client[0].revents&POLLRDNORM)//new client connection
{
clilen = sizeof(cliaddr);
connfd = Accept(listenfd,(sockaddr*)&cliaddr,&clilen);
for (i=1; i<OPEN_MAX;++i)
{
if (client[i].fd<0)
{
client[i].fd = connfd; //save descriptor
break;
}
}
if (i == OPEN_MAX)
err_sys("too many clients");
client[i].events = POLLRDNORM;
if(i>maxi)
maxi = i; //max index in client[]
if(--nready<=0)
continue; //no more readable descriptors
}
for (i=1; i<=maxi; ++i)//check all clients for data
{
if((sockfd = client[i].fd)<0)
continue;;
if(client[i].revents&(POLLRDNORM|POLLERR))
{
if((n=readline(sockfd,line,MAXLINE))<0)
{
if(errno == ECONNRESET)
{//connection reset by client
Close(sockfd);
client[i].fd=-1;
}
else
err_sys("readline error");
}
else if(n==0)
{//connection closed by client
Close(sockfd);
client[i].fd=-1;
}
else
writen(sockfd,line,n);
if(--nready<=0)
break; //no more readable descriptors
}
}
}
}
void
if_init()
{
struct hwa_info *hwa, *hwahead;
struct sockaddr *sa;
struct hostent *hptr;
char *ptr;
char **pptr;
int i, j, prflag, n;
struct arp_cache_entry cache_entry;
memset(if_hwaddr, 0, sizeof(if_hwaddr));
memset(if_sock, 0, sizeof(if_sock));
if_size = 0;
puts("<-- HW INFO -->");
for (i = 0; i < NUM_VM; i++){
sprintf(node_ip[i], "vm%d", i+1);
hptr = gethostbyname(node_ip[i]);
for (pptr = hptr->h_addr_list; *pptr != NULL; pptr++){
Inet_ntop(hptr->h_addrtype, *pptr, node_ip[i], INET_ADDRSTRLEN);
}
}
for (hwahead = hwa = Get_hw_addrs(); hwa != NULL; hwa = hwa->hwa_next) {
printf("interface index = %d\n", (n = hwa->if_index));
printf("%s :%s", hwa->if_name,
((hwa->ip_alias) == IP_ALIAS) ? " (alias)\n" : "\n");
if ((hwa->ip_alias) != IP_ALIAS) {
if_size++;
}
if ((sa = hwa->ip_addr) != NULL) {
printf("\tIP addr = %s\n", Sock_ntop_host(sa, sizeof(*sa)));
if (hwa->if_haddr != NULL) {
if (strcmp(hwa->if_haddr, if_hwaddr[my_index])
== 0 && (hwa->ip_alias) == IP_ALIAS) {
insert_local_hw_cache(Sock_ntop_host(sa, sizeof(*sa)));
}
}
}
// get canonical ip
if (strcmp(hwa->if_name, "eth0") == 0) {
sprintf(my_ip, "%s", Sock_ntop_host(sa, sizeof(*sa)));
my_index = hwa->if_index;
for (my_vm = 0; my_vm < NUM_VM; my_vm++) {
if (strcmp(my_ip, node_ip[my_vm]) == 0) {
my_vm++;
break;
}
}
}
prflag = i = 0;
do {
if (hwa->if_haddr[i] != '\0') {
prflag = 1;
break;
}
} while (++i < IF_HADDR);
if (prflag) {
printf("\tHW addr = ");
for (i = 0; i < IF_HADDR; i++) {
if_hwaddr[n][i] = hwa->if_haddr[i];
printf("%02x ", (int) if_hwaddr[n][i] & 0xff);
}
puts("");
}
}
// printf("***info: number of interfaces -- %d\n***", if_size);
// Create PF_PACKET socket for etho0
if_sockfd = Socket(AF_PACKET, SOCK_RAW, htons(ARP_PROTOCOL));
addr.sll_family = PF_PACKET;
addr.sll_protocol = htons(ARP_PROTOCOL);
addr.sll_ifindex = my_index;
addr.sll_hatype = ARPHRD_ETHER;
addr.sll_pkttype = PACKET_HOST;
addr.sll_halen = ETH_ALEN;
for (j = 0; j < ETH_ALEN; j++){
addr.sll_addr[j] = if_hwaddr[my_index][j];
}
Bind(if_sockfd, (SA *)&addr, sizeof(struct sockaddr_ll));
maxfd= (maxfd, if_sockfd);
insert_local_hw_cache(my_ip);
// puts("if_init done\n");
puts("");
}
int main(int argc, char** argv)
{
int i, maxi, maxfd, listenfd,connfd, sockfd;
int nready;
ssize_t n;
char buf[MAXLINE];
socklen_t clilen;
struct pollfd client[OPEN_MAX];
struct sockaddr_in cliaddr, servaddr;
fprintf(stdout, "main\n");
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(listenfd, (SA*) &servaddr, sizeof(servaddr));
fprintf(stdout,"begin listen");
Listen(listenfd, LISTENQ);
client[0].fd = listenfd;
client[0].events = POLLRDNORM;
for(i = 0; i != OPEN_MAX; ++i)
{
client[i].fd = -1;
}
fprintf(stdout,"begin loop");
maxi = 0;
for(; ; ){
fprintf(stdout,"begin poll");
nready = Poll(client, maxi + 1, INFTIM);
if(client[0].revents & POLLRDNORM){
clilen = sizeof(cliaddr);
connfd = Accept(listenfd, (SA*) & cliaddr, & clilen);
fprintf(stdout,"accept success");
for(i = 1; i != OPEN_MAX; ++i)
{
if(client[i].fd < 0)
{
client[i].fd = connfd;
break;
}
}
if(i == OPEN_MAX)
err_quit("too many clients");
client[i].events = POLLRDNORM;
if(i > maxi)
maxi = i;
if(--nready <= 0)
continue;
}
for(i = 1; i <= maxi; ++i){
if( (sockfd = client[i].fd) <0)
continue;
if(client[i].revents & (POLLRDNORM | POLLERR)){
if((n = read(sockfd, buf, MAXLINE)) < 0){
if(errno == ECONNRESET){
Close(sockfd);
client[i].fd = -1;
}
else
{
err_sys("read error");
}
}else if(n == 0)
{
Close(sockfd);
client[i].fd =-1;
}
else{
Writen(sockfd, buf, n);
}
if(--nready <=0)break;
}
}
}
}
int
main(int argc, char **argv)
{
Signal( SIGINT, sigInt);
int i, maxi, maxfd, listenfd, connfd, sockfd;
int nready, client[FD_SETSIZE];
ssize_t n;
fd_set rset, allset;
char buf[MAXLINE];
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
/* SO_REUSEADDR allows a new server to be started
* on the same port as an existing server that is
* bound to the wildcard address, as long as each
* instance binds a different local IP address.
* This is common for a site hosting multiple HTTP
* servers using the IP alias technique */
int reuseaddr_on = 1;
if( setsockopt( listenfd, SOL_SOCKET, SO_REUSEADDR,
&reuseaddr_on, sizeof( reuseaddr_on)) < 0)
{
// log
}
Bind( listenfd, (SA *) &servaddr, sizeof(servaddr));
Listen( listenfd, LISTENQ);
maxfd = listenfd; /* initialize */
maxi = -1; /* index into client[] array */
for ( i = 0; i < FD_SETSIZE; ++i)
client[i] = -1; /* -1 indicates available entry */
FD_ZERO( &allset);
FD_SET( listenfd, &allset);
for ( ; ; ) {
rset = allset; /* structure assignment */
/* select waits for something to happen: either the establishment
* of a new client connection or the arrival of data, a FIN,
* or an RST on an existing connection */
nready = Select( maxfd + 1, &rset, NULL, NULL, NULL);
if ( FD_ISSET( listenfd, &rset)) { /* new client connection */
/* simulate busy server */
printf( "listening socket readable -> sleep(5)\n");
sleep(5);
/* If the listening socket is readable, a new connection has been
* established. We call accept and update our data structures
* accordingly. We use the first unused entry in the client array
* to record the connected socket. The number of ready descriptors
* is decremented, and if it is 0, we can avoid the next for loop.
* This lets us use the return value from select to avoid checking
* descriptors that are not ready.*/
clilen = sizeof( cliaddr);
printf( "accept called\n"); fflush( stdout);
connfd = accept( listenfd, ( SA *) &cliaddr, &clilen);
printf( "accept returned, connfd=%d\n", connfd); fflush( stdout);
for ( i = 0; i < FD_SETSIZE; ++i)
if (client[i] < 0) {
client[i] = connfd; /* save descriptor */
break;
}
if ( i == FD_SETSIZE)
err_quit( "too many clients");
FD_SET( connfd, &allset); /* add new descriptor to set */
if ( connfd > maxfd)
maxfd = connfd; /* for select */
if ( i > maxi)
maxi = i; /* max index in client[] array */
if ( --nready <= 0)
continue; /* no more readable descriptors */
}
for ( i = 0; i <= maxi; ++i) { /* check all clients for data */
/* A test is made for each existing client connection as to whether
* or not its descriptor is in the descriptor set returned by select.
* If so, a line is read from the client and echoed back to the client.
* If the client closes the connection, read returns 0 and we update
* our data structures accordingly. We never decrement the value
* of maxi, but we could check for this possibility each time a client
* closes its connection.*/
if ( ( sockfd = client[i]) < 0)
continue;
if ( FD_ISSET( sockfd, &rset)) {
if ( ( n = Read( sockfd, buf, MAXLINE)) == 0) {
/* connection closed by client */
Close( sockfd);
FD_CLR( sockfd, &allset);
client[i] = -1;
} else
Writen( sockfd, buf, n); /* echo */
if ( --nready <= 0)
break; /* no more readable descriptors */
}
}
}
return 0;
}
void benchcore(const char *host,const int port,const char *req)
{
int rlen;
char buf[1500];
int s,i;
struct sigaction sa;
/*安装信号 */
/* setup alarm signal handler */
sa.sa_handler = alarm_handler;
sa.sa_flags = 0;
if(sigaction(SIGALRM,&sa,NULL))
exit(3);
/* 设置闹钟函数 */
alarm(benchtime);
rlen = strlen(req);
nexttry:
while(1){
/* 收到信号则 timerexpired = 1 */
if(timerexpired)
{
if(failed > 0)
{
/* fprintf(stderr,"Correcting failed by signal\n"); */
failed--;
}
return;
}
/* 建立 socket, 进行 HTTP 请求 */
s = Socket(host,port);
if(s < 0)
{
failed++;
continue;
}
if(rlen!=write(s,req,rlen))
{
failed++;
close(s);
continue;
}
/* HTTP 0.9 的处理 */
if(http10==0)
/* 如果关闭不成功 */
if(shutdown(s,1))
{
failed++;
close(s);
continue;
}
/* -f 选项时不读取服务器回复 */
if(force == 0)
{
/* read all available data from socket */
while(1)
{
if(timerexpired) break;
i = read(s,buf,1500);
/* fprintf(stderr,"%d\n",i); */
if(i<0)
{
failed++;
close(s);
goto nexttry;
}
else
if(i == 0) break;
else bytes+=i;
}
}
if(close(s))
{
failed++;
continue;
}
speed++;
}
}
int
main(int argc, char *argv[])
{
int c, lopt=0;
char *ptr, localname[1024], *localport;
struct addrinfo *aip;
/* end main1 */
/* include main2 */
opterr = 0; /* don't want getopt() writing to stderr */
while ( (c = getopt(argc, argv, "0i:l:v")) != -1)
{
switch (c)
{
case '0':
zerosum = 1;
break;
case 'i':
device = optarg; /* pcap device */
break;
case 'l': /* local IP address and port #: a.b.c.d.p */
if ( (ptr = strrchr(optarg, '.')) == NULL)
usage("invalid -l option");
*ptr++ = 0; /* null replaces final period */
localport = ptr; /* service name or port number */
strncpy(localname, optarg, sizeof(localname));
lopt = 1;
break;
case 'v':
verbose = 1;
break;
case '?':
usage("unrecognized option");
}
}
/* end main2 */
/* include main3 */
if (optind != argc-2)
usage("missing <host> and/or <serv>");
/* 4convert destination name and service */
aip = Host_serv(argv[optind], argv[optind+1], AF_INET, SOCK_DGRAM);
dest = aip->ai_addr; /* don't freeaddrinfo() */
destlen = aip->ai_addrlen;
/*
* Need local IP address for source IP address for UDP datagrams.
* Can't specify 0 and let IP choose, as we need to know it for
* the pseudoheader to calculate the UDP checksum.
* If -l option supplied, then use those values; otherwise,
* connect a UDP socket to the destination to determine the right
* source address.
*/
if (lopt)
{
/* 4convert local name and service */
aip = Host_serv(localname, localport, AF_INET, SOCK_DGRAM);
local = aip->ai_addr; /* don't freeaddrinfo() */
locallen = aip->ai_addrlen;
}
else
{
int s;
s = Socket(AF_INET, SOCK_DGRAM, 0);
Connect(s, dest, destlen);
/* kernel chooses correct local address for dest */
locallen = sizeof(locallookup);
local = (struct sockaddr *)&locallookup;
Getsockname(s, local, &locallen);
if (locallookup.sin_addr.s_addr == htonl(INADDR_ANY))
err_quit("Can't determine local address - use -l\n");
close(s);
}
open_output(); /* open output, either raw socket or libnet */
open_pcap(); /* open packet capture device */
setuid(getuid()); /* don't need superuser privileges anymore */
Signal(SIGTERM, cleanup);
Signal(SIGINT, cleanup);
Signal(SIGHUP, cleanup);
test_udp();
cleanup(0);
}
int main(int argc,char* argv[])
{
char *str = new char[MAXSIZE],*p;
int Port_BDS = atoi(argv[2]);
int Port_FC = atoi(argv[3]);
sockfd_BDS = Socket();
sockfd_FC = Socket();
struct sockaddr_in servself_addr,client_addr,servBDS_addr;
struct hostent *host;
int nread;
socklen_t len;
Bind(sockfd_FC,servself_addr,Port_FC);
Listen(sockfd_FC,5);
printf("The FS is listening\n");
bzero(&servBDS_addr,sizeof(servBDS_addr));
servBDS_addr.sin_family = AF_INET;
host = gethostbyname(argv[1]);
memcpy(&servBDS_addr.sin_addr.s_addr,host->h_addr,host->h_length);
servBDS_addr.sin_port = htons(Port_BDS);
connect(sockfd_BDS,(struct sockaddr*)&servBDS_addr,sizeof(servBDS_addr));
initial();
while (1)
{
len = sizeof(client_addr);
client_sockfd = accept(sockfd_FC,(struct sockaddr *) &client_addr, &len);
printf("Connect successfully\n");
bzero(SendToFC,sizeof(SendToFC));
strcat(SendToFC,CurrentInode.Name);
strcat(SendToFC," $ ");
Write(client_sockfd,SendToFC,strlen(SendToFC));
while (1)
{
bzero(ReceFromFC,sizeof(ReceFromFC));
int n = Read(client_sockfd,ReceFromFC,MAXSIZE);
Write(STDOUT_FILENO,ReceFromFC,strlen(ReceFromFC));
// Show(CurrentInode,CurrentData);
strcpy(str,ReceFromFC);
p = str;
str = strtok(str," \n");
if (0 == strcmp(str,"f")) Format();
else if (0 == strcmp(str,"mk")) /*Create a file*/
{
str = strtok(NULL," \n");
Createfile(str,0);
}
else if (0 == strcmp(str,"mkdir")) /*Create a folder*/
{
str = strtok(NULL," \n");
Createfile(str,1);
}
else if (0 == strcmp(str,"rm")) /*Remove a file*/
{
str = strtok(NULL," \n");
Removefile(str,0);
}
else if (0 == strcmp(str,"cd")) /*Change path*/
{
str = strtok(NULL," \n");
Changedir(str);
HandleError("cdok!\n");
}
else if (0 == strcmp(str,"rmdir"))
{
str = strtok(NULL," \n"); /*Remove a folder*/
Removefile(str,1);
}
else if (0 == strcmp(str,"ls"))
{
str = strtok(NULL," \n");
List(str);
}
else if (0 == strcmp(str,"cat")) /*Catch a file*/
{
str = strtok(NULL," \n");
Catchfile(str);
printf("Catch ok!\n");
}
else if (0 == strcmp(str,"w"))
{
str = strtok(NULL,"\n");
WriteData(str);
}
else if (0 == strcmp(str,"a"))
{
str = strtok(NULL,"\n");
Append(str);
}
else if (0 == strcmp(str,"exit"))
Exit();
else
{
HandleError("2:Unavailable command\n");
}
bzero(SendToFC,sizeof(SendToFC));
strcat(SendToFC,CurrentInode.Name);
strcat(SendToFC," $ ");
Write(client_sockfd,SendToFC,strlen(SendToFC));
}
Close(client_sockfd);
}
Close(sockfd_BDS);
Close(sockfd_FC);
}
int
main(int argc, char **argv)
{
/*
int sockfd;
//sockaddr_in for the internet family
struct sockaddr_in servaddr;
//struct addrinfo hints;
struct addrinfo *res;
//const char *result = argv[1];
//int port = atoi(argv[2]);
if(argc != 3)
err_quit("usage: tcpcli <IPAddress>");
//
sockfd = Socket(AF_INET, SOCK_STREAM, 0);
if(sockfd != -1)
{
//printf("socket created\n");
} else {
printf("socket failed\n");
}
//convert names.
//hints->ai_flags = AI_PASSIVE;
//puts an appropriate number of zero bytes in area pointed to by &servaddr
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(atoi(argv[2])); //SERV_PORT to *argv[2]
getaddrinfo(argv[1], argv[2], NULL, &res);
Bind(sockfd, (SA *) &servaddr, sizeof(servaddr));
// Bind(sockfd, , sizeof(res));
Connect(sockfd, (SA *) &servaddr, sizeof(servaddr));
str_cli(stdin, sockfd);
close(sockfd);
*/
struct addrinfo hints, *res;
int sockfd;
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
getaddrinfo(argv[1], argv[2], &hints, &res);
sockfd = Socket(res->ai_family, res->ai_socktype, res->ai_protocol);
//Bind(sockfd, res->ai_addr, res->ai_addrlen);
Connect(sockfd, res->ai_addr, res->ai_addrlen);
str_cli(stdin, sockfd);
close(sockfd);
exit(0);
}
int main(int argc, char** argv) {
char rbuf[MAXBUF]; // transmitter and receiver buffers
SOCKET s; // socket
struct in_addr sIPaddr; // server IP address structure
struct sockaddr_in saddr; // server address structure
uint16_t tport_n, tport_h; // server port number by htons()
char *filename;
FILE* fp;
uint32_t fileBytesN, fileBytes, nNext, nLeft;
ssize_t nread, nwritten;
XDR xdrs_in; // Input XDR stream
XDR xdrs_out; // Output XDR stream
FILE* stream_socket_r; // FILE stream for reading from the socket
FILE* stream_socket_w; // FILE stream for writing to the socket
call_msg reqMessage;
response_msg resMessage;
/* Check number of arguments */
checkArg(argc, 4);
prog_name = argv[0];
/* Set IP address */
setIParg(argv[1], &sIPaddr);
/* Set port number */
tport_n = setPortarg(argv[2], &tport_h);
/* Save the file to request */
filename = argv[3];
/* Create the socket */
fprintf(stdout, "Creating the socket...\n");
s = Socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
fprintf(stdout, "- OK. Socket fd: %d\n", s);
/* Prepare server address structure */
saddr.sin_family = AF_INET;
saddr.sin_port = tport_n;
saddr.sin_addr = sIPaddr;
/* Send connection request */
fprintf(stdout, "Connecting to target address...\n");
Connect(s, (struct sockaddr*) &saddr, sizeof(saddr));
fprintf(stdout, "- OK. Connected to ");
showAddress(&saddr);
/* Open FILE reading stream and bind it to the corresponding XDR stream */
stream_socket_r = fdopen(s, "r");
if (stream_socket_r == NULL) {
fprintf(stderr, "---ERROR. fdopen() failed.\n");
return 1;
}
xdrstdio_create(&xdrs_in, stream_socket_r, XDR_DECODE);
/* Open FILE writing stream and bind it to the corresponding XDR stream */
stream_socket_w = fdopen(s, "w");
if (stream_socket_w == NULL) {
fprintf(stderr, "---ERROR. fdopen() failed.\n");
xdr_destroy(&xdrs_in);
fclose(stream_socket_r);
return 1;
}
xdrstdio_create(&xdrs_out, stream_socket_w, XDR_ENCODE);
while(1) {
/* Send a file request */
reqMessage.ctype = GET;
reqMessage.call_msg_u.filename = filename;
if (!xdr_call_msg(&xdrs_out, &reqMessage)) {
fprintf(stdout, "- ERROR sending GET message.\n");
break;
}
fflush(stream_socket_w);
/* Receive a message */
if (!xdr_response_msg(&xdrs_in, &resMessage)) {
fprintf(stdout, "- ERROR. Response xdr_response_msg() failed.\n");
break;
}
fprintf(stdout, "- Received response.\n");
if (resMessage == OK) {
fprintf(stdout, "- File received: %s\n", filename);
// Read the file size
nread = read(s, (void*)&fileBytesN, sizeof(uint32_t));
fileBytes = ntohl(fileBytesN);
fprintf(stdout, "- File size: %u\n", fileBytesN);
// Received and write file
fp = Fopen(filename, "wb");
nLeft = fileBytes;
while(nLeft > 0) {
if (nLeft < MAXBUF) {
nNext = nLeft;
} else {
nNext = MAXBUF;
}
nread = Read(s, rbuf, nNext*sizeof(char));
nwritten = Fwrite(rbuf, sizeof(char), nNext, fp);
if (nread != nNext || nwritten != nNext) {
fprintf(stdout, "--- ERROR saving file.\n");
break;
}
nLeft -= nNext;
}
Fclose(fp);
fprintf(stdout, "--- File written: %s\n", filename);
} else if (resMessage == ERR) {
fprintf(stderr, "- Received ERR message.\n");
break;
} else {
fprintf(stderr, "- ERROR. Something goes wrong with the communication protocol.\n");
break;
}
/* End the communication */
reqMessage.ctype = QUIT;
reqMessage.call_msg_u.filename = NULL;
if (!xdr_call_msg(&xdrs_out, &reqMessage)) {
fprintf(stdout, "- ERROR sending QUIT message.\n");
break;
}
fprintf(stdout, "- QUIT message sent.\n");
fflush(stream_socket_r);
fflush(stream_socket_w);
break;
}
xdr_destroy(&xdrs_in);
fclose(stream_socket_r);
xdr_destroy(&xdrs_out);
fclose(stream_socket_w);
/* Close the socket connection */
fprintf(stdout, "Closing the socket connection...\n");
closesocket(s);
fprintf(stdout, "- OK. Closed.\n");
return 0;
}
/* getnrd
write command to wthd and read response
IPv4 version
*/
int getnrd(unsigned char *data, int *mdat, struct cmd *pcmd) {
int sockfd, n, len;
char sendline[MAXLINE] = "1";
struct sockaddr_in servaddr;
struct in_addr **pptr, *addrs[2];
struct hostent *hp;
struct servent *sp;
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
/* hostname or ipaddress */
if (inet_pton(AF_INET, pcmd->hostname, &servaddr.sin_addr) == 1) {
addrs[0] = &servaddr.sin_addr;
addrs[1] = NULL;
pptr = &addrs[0];
} else if ( (hp = gethostbyname(pcmd->hostname)) != NULL) {
pptr = (struct in_addr **) hp->h_addr_list;
} else {
werrno = h_errno;
syslog(LOG_INFO,"hostname error for %s: %s",
pcmd->hostname, hstrerror(h_errno));
return (-1);
}
/* port number or service name */
if ( (n = atoi(pcmd->port)) > 0)
servaddr.sin_port = htons(n);
else if ( (sp = getservbyname(pcmd->port, "tcp")) != NULL)
servaddr.sin_port = sp->s_port;
else {
syslog(LOG_INFO,"getservbyname error for %s", pcmd->port);
werrno = ENET;
return(-1);
}
/* connect to server */
for ( ; *pptr != NULL; pptr++) {
if ( ( sockfd = Socket(AF_INET, SOCK_STREAM, 0)) == -1 )
return(-1);
memmove(&servaddr.sin_addr, *pptr, sizeof(struct in_addr));
Sock_ntop((SA *) &servaddr, sizeof(servaddr));
if (connect(sockfd, (SA *) &servaddr, sizeof(servaddr)) == 0)
break; /* success */
werrno = errno;
syslog(LOG_INFO, "getnrd: connect error: %s",
strerror(werrno));
return(-1);
close(sockfd);
}
if (*pptr == NULL ) {
syslog(LOG_INFO, "unable to connect");
werrno = ENET;
return(-1);
}
/* write command to server */
snprintf(sendline, sizeof(sendline), "%d\r\n", (*pcmd).command);
if ( Writen(sockfd, sendline, 1) == -1 )
return(-1);
/* read response. rwstephens unp p.10 */
while ( ( n = read(sockfd, data, MAXBUFF)) > 0) {
data[n] = 0;
}
/* code doesn't work. why?
if (Readline(sockfd, line, MAXLINE) == 0)
err_quit("getnrd: server terminated prematurely");
*/
len = wstrlen(data);
*mdat = len;
return(0);
}
int main(int argc, char **argv){
int res = 0;
struct timeval tv1, tv2;
char *directory = NULL;
if (argc != 3)
err_quit("usage: client <IPaddress> <file dir>");
serverip = argv[1];
directory = argv[2];
gettimeofday(&tv1, NULL);
sockfd4pox = get_udp_socket(QUICK_PORT);// channel with POX
bzero(&servaddrfp, sizeof(servaddrfp));
servaddrfp.sin_family = AF_INET;
servaddrfp.sin_port = htons(SERV_PORT+1);
Inet_pton(AF_INET, argv[1], &servaddrfp.sin_addr);
sockfd2serverfp = Socket(AF_INET, SOCK_DGRAM, 0);
// Connect(sockfd2serverfp, (SA *)&servaddrfp, sizeof(servaddrfp));
struct timeval tv;
tv.tv_sec = 1;
tv.tv_usec = 0;//
setsockopt(sockfd2serverfp, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
int a = 65535;
Setsockopt(sockfd2serverfp, SOL_SOCKET, SO_SNDBUF, &a, sizeof(int));
Setsockopt(sockfd2serverfp, SOL_SOCKET, SO_RCVBUF, &a, sizeof(int));
#ifdef USE_UDP
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERV_PORT);
Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
sockfd2server = Socket(AF_INET, SOCK_DGRAM, 0);
#else
sockfd2server = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERV_PORT); //
Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
Connect(sockfd2server, (SA *) &servaddr, sizeof(servaddr));
Setsockopt(sockfd2server, SOL_SOCKET, SO_SNDBUF, &a, sizeof(int));
#endif
// start
start_backup();
uploadDir(directory);
// uploadDir_recur(directory);
gettimeofday(&tv2, NULL);
printf("Time cost = %lfms\n",(tv2.tv_sec-tv1.tv_sec)*1000.0+(tv2.tv_usec-tv1.tv_usec)/1000.0);
/* Upload complete, tell server to sync data to SDN controller
* Need a alg(by dedu ratio) to control this sync
*/
end_backup();
close(sockfd4pox);
// shutdown(sockfd2server, SHUT_WR);
// shutdown(sockfd2serverfp, SHUT_WR);
close(sockfd2serverfp);
close(sockfd2server);
exit(0);
}
int
main(int argc, char **argv)
{
struct pollfd clients[CLI_OPENMAX];
long num_transmitted[CLI_OPENMAX],
num_recieved[CLI_OPENMAX];
struct sockaddr_in serv_addr;
socklen_t serv_addr_len;
int i, j, nready, tmp_fd, n;
char buf[MAXLINE];
size_t num_bytes, trans_size, num_open_clients;
if (argc != 3) {
err_quit("Usage: %s <ip_addr> <num_bytes>", argv[0]);
}
num_bytes = atoi(argv[2]);
Inet_pton(AF_INET, argv[1], &serv_addr.sin_addr.s_addr);
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(SERV_PORT);
for (i = 0; i<CLI_OPENMAX; ++i) {
tmp_fd = Socket(AF_INET, SOCK_STREAM, 0);
if (connect(tmp_fd, (SA *)&serv_addr, sizeof(serv_addr)) != 0) {
err_sys("%s: error connecting client #%d to server %s.",
argv[0], i, argv[1]);
}
clients[i].fd = tmp_fd;
clients[i].events = POLLOUT | POLLRDNORM;
num_transmitted[i] = 0;
num_recieved[i] = 0;
num_open_clients++;
}
while(num_open_clients > 0) {
/*
* Poll looks at all the structures in the array
* and polls them for the events we've specified,
* which in this case are POLLOUT and POLLRDNORM.
* We ask it to block indefinitely until one of these
* things has an event.
*/
nready = Poll(clients, num_open_clients, INFTIM);
for (i=0; i < CLI_OPENMAX; ++i) {
/*
* Now we've gotten a poll event. But we don't know
* who on. So we go over each and every client,
* examining the revents (result events) structure
* for the events we want.
*/
if(clients[i].fd == -1) {
continue;
}
if(clients[i].revents & POLLOUT) {
trans_size = rand()%MAXLINE;
randomize_charbuf(buf, trans_size);
Writen(clients[i].fd, buf, trans_size);
num_transmitted[i] += trans_size;
if(num_transmitted[i] >= num_bytes) {
/*
* When we've finished blasting out data,
* close down the write half of the connection.
* Only close the actual file descriptor once
* we have recieved all data from the server.
*
* When you don't do this, i.e. do a
* close(clients[i].fd) immediately,
* you shutdown both sides and some
* data can get thrown away, especially
* w/ a large RTT or slow server.
* large amount of data out and get acks
* from the server's kernel, but eh server
* process has to do some special thing,
* and spends a while doing it. But we've
* sent all the data so we close, for example.
* The user, however, might still expect
* something.
*/
Shutdown(clients[i].fd, SHUT_WR);
}
} else if (clients[i].revents & (POLLRDNORM | POLLERR) ) {
/* We know it won't be more than maxline, that's
* how much we send (at most).
*
* POLLERR you can't listen for, but it shows up
* anyway on an fd. This in our case means
* a RST.
*/
if ( (n = read(clients[i].fd, buf, MAXLINE) == 0)) {
/*
* The server can reset the connection if,
* for example, the server process crashes.
* It could have nothing operating on that port
* or, a new process could be running that
* isn't expecting our packets. In this case,
* we get an RST, which comes up to us as
* a bad read w/ errno = ECONNRESET.
*/
if (errno == ECONNRESET) {
finish_client(clients[i]);
printf("Reset for client #%d\n", i);
}
} else if (n == 0) {
finish_client(clients[i]);
} else {
num_recieved[i] += n;
}
}
}
}
return 0;
}
Try<Socket> Socket::create(Kind kind, Option<int> s)
{
// If the caller passed in a file descriptor, we do
// not own its life cycle and must not close it.
bool owned = s.isNone();
if (owned) {
// Supported in Linux >= 2.6.27.
#if defined(SOCK_NONBLOCK) && defined(SOCK_CLOEXEC)
Try<int> fd =
network::socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
if (fd.isError()) {
return Error("Failed to create socket: " + fd.error());
}
#else
Try<int> fd = network::socket(AF_INET, SOCK_STREAM, 0);
if (fd.isError()) {
return Error("Failed to create socket: " + fd.error());
}
Try<Nothing> nonblock = os::nonblock(fd.get());
if (nonblock.isError()) {
os::close(fd.get());
return Error("Failed to create socket, nonblock: " + nonblock.error());
}
Try<Nothing> cloexec = os::cloexec(fd.get());
if (cloexec.isError()) {
os::close(fd.get());
return Error("Failed to create socket, cloexec: " + cloexec.error());
}
#endif
s = fd.get();
}
switch (kind) {
case POLL: {
Try<std::shared_ptr<Socket::Impl>> socket =
PollSocketImpl::create(s.get());
if (socket.isError()) {
if (owned) {
os::close(s.get());
}
return Error(socket.error());
}
return Socket(socket.get());
}
#ifdef USE_SSL_SOCKET
case SSL: {
Try<std::shared_ptr<Socket::Impl>> socket =
LibeventSSLSocketImpl::create(s.get());
if (socket.isError()) {
if (owned) {
os::close(s.get());
}
return Error(socket.error());
}
return Socket(socket.get());
}
#endif
// By not setting a default we leverage the compiler errors when
// the enumeration is augmented to find all the cases we need to
// provide.
}
}
Socket *Network::OpenListenSocket(unsigned short port, SocketTransportLayer transport, bool allowAddressReuse)
{
addrinfo *result = NULL;
addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_flags = AI_PASSIVE;
hints.ai_socktype = (transport == SocketOverTCP) ? SOCK_STREAM : SOCK_DGRAM;
hints.ai_protocol = (transport == SocketOverTCP) ? IPPROTO_TCP : IPPROTO_UDP;
char strPort[256];
sprintf(strPort, "%d", (unsigned int)port);
int ret = getaddrinfo(NULL, strPort, &hints, &result);
if (ret != 0)
{
KNET_LOG(LogError, "getaddrinfo failed: %s", GetErrorString(ret).c_str());
return 0;
}
SOCKET listenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
KNET_LOG(LogInfo, "Network::OpenListenSocket: Created listenSocket 0x%8X.", (unsigned int)listenSocket);
if (listenSocket == INVALID_SOCKET)
{
KNET_LOG(LogError, "Error at socket(): %s", GetLastErrorString().c_str());
freeaddrinfo(result);
return 0;
}
if (allowAddressReuse)
{
// Allow other sockets to be bound to this address after this.
// (Possibly unsecure, only enable for development purposes - to avoid having to wait for the server listen socket
// to time out if the server crashes.)
#ifdef _WIN32
BOOL val = TRUE;
ret = setsockopt(listenSocket, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
#else
int val = 1;
ret = setsockopt(listenSocket, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
#endif
if (ret != 0)
KNET_LOG(LogError, "setsockopt to SO_REUSEADDR failed: %s", GetLastErrorString().c_str());
}
// It is safe to cast to a sockaddr_in, since we've specifically queried for AF_INET addresses.
sockaddr_in localAddress = *(sockaddr_in*)&result->ai_addr;
// Setup the listening socket - bind it to a local port.
// If we are setting up a TCP socket, the socket will be only for listening and accepting incoming connections.
// If we are setting up an UDP socket, all connection initialization and data transfers will be managed through this socket.
ret = bind(listenSocket, result->ai_addr, (int)result->ai_addrlen);
if (ret == KNET_SOCKET_ERROR)
{
KNET_LOG(LogError, "bind failed: %s when trying to bind to port %d with transport %s",
GetLastErrorString().c_str(), (int)port, transport == SocketOverTCP ? "TCP" : "UDP");
closesocket(listenSocket);
freeaddrinfo(result);
return 0;
}
freeaddrinfo(result);
// For a reliable TCP socket, start the server with a call to listen().
if (transport == SocketOverTCP)
{
// Transition the bound socket to a listening state.
ret = listen(listenSocket, SOMAXCONN);
if (ret == KNET_SOCKET_ERROR)
{
KNET_LOG(LogError, "Error at listen(): %s", GetLastErrorString().c_str());
closesocket(listenSocket);
return 0;
}
}
EndPoint localEndPoint = EndPoint::FromSockAddrIn(localAddress);
// We are starting up a server listen socket, which is not bound to an address. Use null address for the remote endpoint.
EndPoint remoteEndPoint;
remoteEndPoint.Reset();
const size_t maxSendSize = (transport == SocketOverTCP ? cMaxTCPSendSize : cMaxUDPSendSize);
sockets.push_back(Socket(listenSocket, localEndPoint, localHostName.c_str(), remoteEndPoint, "", transport, ServerListenSocket, maxSendSize));
Socket *listenSock = &sockets.back();
listenSock->SetBlocking(false);
return listenSock;
}
ostream & print_IndividualTestResults (ostream &os, const struct CDASH_HarnessTestResults &tr)
{
string cdashclntip;
char *envvalue = getenv ("cdashclientip");
if (!envvalue || *envvalue == 0)
{
/* Warning : value for "cdashclientip" is not set in the environment. Will use IP of this machine.
* Find ethernet address for this machine. */
int unneeded_sockfd=0;
unneeded_sockfd = Socket (AF_INET, SOCK_STREAM, 0);
struct ifconf ifc;
int num_iface = if_addr_fetch (&ifc, unneeded_sockfd);
Close (unneeded_sockfd);
if (num_iface == 0)
throw ConfigError (FILE_LINE_FUNCTION, "Network interfaces are not properly configured.");
struct ifreq *ip = ifc.ifc_req; ;
for ( ; num_iface > 0; num_iface--, ip++)
{
cdashclntip = inet_ntoa (((struct sockaddr_in *) &ip->ifr_addr)->sin_addr);
cout << "IFACE: " << ip->ifr_name << " - " << cdashclntip << endl;
if (num_iface == 1 && cdashclntip == "127.0.0.1")
throw ConfigError (FILE_LINE_FUNCTION, "Network interfaces are not properly configured.");
if (cdashclntip != "127.0.0.1")
break;
}
}
else
cdashclntip = envvalue;
string scidbtestcasesURL = "scidbtestcases";
string scidbtestresultsURL = "scidbtestresults";
string revisionURL = "?rev=";
envvalue = getenv ("scidbtestcasesURL");
if (envvalue && *envvalue)
{
scidbtestcasesURL = envvalue;
}
envvalue = getenv ("scidbtestresultsURL");
if (envvalue && *envvalue)
{
scidbtestresultsURL = envvalue;
}
envvalue = getenv ("revisionURL");
if (envvalue && *envvalue)
{
revisionURL += envvalue;
}
cout << "CdashReportApp :: Using cdashclientip=" << cdashclntip << endl;
cout << "CdashReportApp :: Using scidbtestcasesURL=" << scidbtestcasesURL << endl;
cout << "CdashReportApp :: Using scidbtestresultsURL=" << scidbtestresultsURL << endl;
cout << "CdashReportApp :: Using revisionURL=" << revisionURL << endl;
cout << "INFO : Total TestList Size = [" << tr.v_IndividualTestResult.size() << "]" << endl;
for (unsigned int i=0; i<tr.v_IndividualTestResult.size(); i++)
{
// cout << "INFO : putting in test number [" << i+1 << "]" << endl;
string status_str="failed";
if ((strcasecmp (tr.v_IndividualTestResult[i].TestcaseResult.c_str(), "PASS") == 0) ||
(strcasecmp (tr.v_IndividualTestResult[i].TestcaseResult.c_str(), "RECORDED") == 0))
status_str = "passed";
os << "<Test Status=\"" << status_str << "\">" << endl;
os << "<Name>" << tr.v_IndividualTestResult[i].TestID << "</Name>" << endl;
//<< "<Path>.</Path>" << endl
//<< "<FullName>" << tr.v_IndividualTestResult[i].TestID << "</FullName>" << endl
//<< "<FullCommandLine></FullCommandLine>" << endl
os << "<Results>" << endl;
os << "<NamedMeasurement type=\"numeric/double\" name=\"Execution Time\"><Value>" << tr.v_IndividualTestResult[i].TestTotalExeTime << "</Value></NamedMeasurement>" << endl;
os << "<NamedMeasurement type=\"text/string\" name=\"Completion Status\"><Value>Completed</Value></NamedMeasurement>" << endl;
/* test case file name */
string tmp = tr.v_IndividualTestResult[i].TestcaseFile;
string testdir = "/t/";
size_t found = tmp.find (testdir);
bool run_tests_basic=false;
if (found == string :: npos)
run_tests_basic=true;
/* if (found == string :: npos)
{
stringstream ss;
ss << "Invalid test case file name [" << tmp << "]. Check if file exists.";
throw ConfigError (FILE_LINE_FUNCTION, ss.str());
}
*/
string trac_url = "http://trac.scidb.org/browser/trunk/tests/harness/testcases/";
char *env_trac = getenv ("trac_url");
if (env_trac && *env_trac)
{
trac_url = env_trac;
}
else
{
trac_url = "http://trac.scidb.org/browser/trunk/tests/harness/testcases/";
}
string url = "";
if (!run_tests_basic)
{
found += 2;
tmp.replace (0, found, "");
// url = "http://" + cdashclntip + "/" + scidbtestcasesURL + "/" + tmp;
url = trac_url + "t/" + tmp + revisionURL;
}
else
// url = "http://trac.scidb.org/browser/trunk/tests/basic/" + tmp + revisionURL;
// url = trac_url + tmp + revisionURL;
// url = "http://" + cdashclntip + "/" + scidbtestresultsURL + "/" + "/tests_basic/" + tmp;
url = scidbtestcasesURL;
os << "<NamedMeasurement type=\"text/string\" name=\"Testcase File\"><Value><a href=\""
<< url << "\">" << tr.v_IndividualTestResult[i].TestcaseFile << " </a></Value></NamedMeasurement>" << endl;
/* .expected file name */
tmp = tr.v_IndividualTestResult[i].TestcaseExpectedResultFile;
if (tmp.length())
{
if (!run_tests_basic)
{
tmp.replace (0, found, "");
// url = "http://" + cdashclntip + "/" + scidbtestresultsURL + "/" + tmp;
url = trac_url + "r/" + tmp + revisionURL;
}
else
url = trac_url + tmp + revisionURL;
// url = "http://" + cdashclntip + "/" + scidbtestresultsURL + "/tests_basic/" + tmp;
os << "<NamedMeasurement type=\"text/string\" name=\"Expected Result File\"><Value><a href=\""
<< url << "\">" << tr.v_IndividualTestResult[i].TestcaseExpectedResultFile << " </a></Value></NamedMeasurement>" << endl;
}
/* .out file name */
tmp = tr.v_IndividualTestResult[i].TestcaseActualResultFile;
if (tmp.length())
{
if (!run_tests_basic)
{
tmp.replace (0, found, "");
url = "http://" + cdashclntip + "/" + scidbtestresultsURL + "/" + tmp;
}
else
url = "http://" + cdashclntip + "/" + scidbtestresultsURL + "/tests_basic/" + tmp;
os << "<NamedMeasurement type=\"text/string\" name=\"Actual Result File\"><Value><a href=\""
<< url << "\">" << tr.v_IndividualTestResult[i].TestcaseActualResultFile << " </a></Value></NamedMeasurement>" << endl;
}
/* .diff file name */
tmp = tr.v_IndividualTestResult[i].TestcaseDiffFile;
if (tmp.length())
{
if (!run_tests_basic)
{
tmp.replace (0, found, "");
url = "http://" + cdashclntip + "/" + scidbtestresultsURL + "/" + tmp;
}
else
url = "http://" + cdashclntip + "/" + scidbtestresultsURL + "/tests_basic/" + tmp;
os << "<NamedMeasurement type=\"text/string\" name=\"Diff File\"><Value><a href=\""
<< url << "\">" << tr.v_IndividualTestResult[i].TestcaseDiffFile << " </a></Value></NamedMeasurement>" << endl;
}
/* .timer file name */
tmp = tr.v_IndividualTestResult[i].TestcaseTimerFile;
if (tmp.length())
{
if (!run_tests_basic)
{
tmp.replace (0, found, "");
url = "http://" + cdashclntip + "/" + scidbtestresultsURL + "/" + tmp;
}
else
url = "http://" + cdashclntip + "/" + scidbtestresultsURL + "/tests_basic/" + tmp;
os << "<NamedMeasurement type=\"text/string\" name=\"Timer File\"><Value><a href=\""
<< url << "\">" << tr.v_IndividualTestResult[i].TestcaseTimerFile << " </a></Value></NamedMeasurement>" << endl;
}
/* test case result (PASS/FAIL) */
os << "<NamedMeasurement type=\"text/string\" name=\"TestcaseResult\"><Value>"
<< tr.v_IndividualTestResult[i].TestcaseResult << "</Value></NamedMeasurement>" << endl;
if (tr.v_IndividualTestResult[i].TestcaseFailureReason != "")
{
os << "<NamedMeasurement type=\"text/string\" name=\"Testcase Failure Reason\"><Value>"
<< tr.v_IndividualTestResult[i].TestcaseFailureReason << "</Value></NamedMeasurement>" << endl;
}
/* .log file name */
tmp = tr.v_IndividualTestResult[i].TestcaseLogFile;
if (tmp != "")
{
if (!run_tests_basic)
{
tmp.replace (0, found, "");
url = "http://" + cdashclntip + "/" + scidbtestresultsURL + "/" + tmp;
}
else
url = "http://" + cdashclntip + "/" + scidbtestresultsURL + "/tests_basic/" + tmp;
os << "<NamedMeasurement type=\"text/string\" name=\"Testcase Log File\"><Value><a href=\""
<< url << "\">" << tr.v_IndividualTestResult[i].TestcaseLogFile << " </a></Value></NamedMeasurement>" << endl;
}
os << "<Measurement><Value>Not Applicable</Value></Measurement>" << endl;
os << "</Results>" << endl;
os << "</Test>" << endl;
}
return os;
}
/* vraci system rc error kod */
static int bench(void)
{
int i,j,k;
pid_t pid = 0;
FILE *f;
/* check avaibility of target server */
i = Socket(proxyhost == NULL? host : proxyhost, proxyport);
if(i < 0) {
fprintf(stderr,"\nConnect to server failed. Aborting benchmark.\n");
return 1;
}
close(i);
/* create pipe */
if(pipe(mypipe))
{
perror("pipe failed.");
return 3;
}
/* not needed, since we have alarm() in childrens */
/* wait 4 next system clock tick */
/*
cas=time(NULL);
while(time(NULL)==cas)
sched_yield();
*/
/* fork childs */
for(i = 0; i < clients; i++) {
pid = fork();
if(pid <= (pid_t) 0) {
/* child process or error*/
sleep(1); /* make childs faster */
break;
}
}
if(pid < (pid_t)0) {
fprintf(stderr,"problems forking worker no. %d\n", i);
perror("fork failed.");
return 3;
}
if(pid == (pid_t)0) {
/* I am a child */
if(proxyhost == NULL)
benchcore(host, proxyport, request);
else
benchcore(proxyhost, proxyport, request);
/* write results to pipe */
f=fdopen(mypipe[1], "w");
if(f == NULL)
{
perror("open pipe for writing failed.");
return 3;
}
/* fprintf(stderr,"Child - %d %d\n",speed,failed); */
fprintf(f, "%d %d %d\n", speed, failed, bytes);
fclose(f);
return 0;
} else {
f = fdopen(mypipe[0], "r");
if(f == NULL) {
perror("open pipe for reading failed.");
return 3;
}
setvbuf(f, NULL,_IONBF, 0);
speed = 0;
failed = 0;
bytes=0;
while(1) {
pid = fscanf(f, "%d %d %d", &i, &j, &k);
if(pid < 2) {
fprintf(stderr,"Some of our childrens died.\n");
break;
}
speed += i;
failed += j;
bytes += k;
/* fprintf(stderr,"*Knock* %d %d read=%d\n",speed,failed,pid); */
if(--clients == 0)
break;
}
fclose(f);
printf("\nSpeed=%d pages/min, %d bytes/sec.\nRequests: %d susceed, %d failed.\n", (int)((speed + failed) / (benchtime / 60.0f)), (int)(bytes / (float)benchtime), speed, failed);
}
return i;
}
int main(int argc, char **argv) {
int command = -1;
int playing = 1;
int sock;
unsigned int addrlen = sizeof(struct sockaddr_in);
unsigned int port = 40642;
sockaddr_in addr;
char move = EOF;
common_init(argc, argv, port, addr.sin_addr.s_addr);
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
sock = Socket(PF_INET, SOCK_STREAM, 0);
Connect(sock, (struct sockaddr *)&addr, addrlen);
Read(sock, &player.x, sizeof(int));
Read(sock, &player.y, sizeof(int));
p_torpedo.x = p_torpedo.y = -1;
s_torpedo.x = s_torpedo.y = -1;
while (playing) {
display();
do {
move = getchar();
} while (move != EOF && !isalpha(move));
switch(move) {
case 'r': player.x = (player.x + 1) % GRID_SZ;
command = MOVE;
break;
case 'l': player.x = (player.x + GRID_SZ - 1) % GRID_SZ;
command = MOVE;
break;
case 'd': player.y = (player.y + 1) % GRID_SZ;
command = MOVE;
break;
case 'u': player.y = (player.y + GRID_SZ - 1) % GRID_SZ;
command = MOVE;
break;
case 'f': printf("Enter target position (x y) => ");
command = FIRE;
scanf("%d %d", &p_torpedo.x, &p_torpedo.y);
break;
case 's': printf("\n***** GAME OVER - You have surrendered! *****\n");
case EOF: command = SURRENDER;
break;
default: printf("Sorry, I don't understand the command '%c'.\n", move);
printf("Enter your move => ");
}
Write(sock, &command, sizeof(int));
if (command == FIRE) {
Write(sock, &p_torpedo, sizeof(pos));
} else if (command == SURRENDER) {
break;
}
Read(sock, &command, sizeof(int));
if (command == HIT) {
player_score++;
}
Read(sock, &command, sizeof(int));
switch (command) {
case FIRE: Read(sock, &s_torpedo, sizeof(pos));
if (s_torpedo.x == player.x && s_torpedo.y == player.y) {
command = HIT;
server_score++;
} else {
command = MISS;
}
break;
case MOVE: command = ACK;
}
Write(sock, &command, sizeof(int));
if (player_score == max_score || server_score == max_score) {
command = SURRENDER;
Write(sock, &command, sizeof(int));
playing = 0;
}
}
if (player_score == max_score) {
printf("You have won!\n");
} else if (server_score == max_score) {
printf("You have lost!\n");
}
return 0;
}
void benchcore(const char *host,const int port,const char *req)
{
int rlen;
char buf[8192];
int s, i = 0;
struct sigaction sa;
/* setup alarm signal handler */
sa.sa_handler = alarm_handler;
sa.sa_flags = 0;
if(sigaction(SIGALRM, &sa, NULL))
exit(3);
alarm(benchtime);
rlen = strlen(req);
nexttry :
while(1) {
if(timerexpired) {
if(failed > 0) {
/* fprintf(stderr,"Correcting failed by signal\n"); */
failed--;
}
return;
}
s = Socket(host,port);
if(s < 0) {
if (s != EINTR)
failed++;
continue;
}
if(rlen != write(s, req, rlen)) {
if (errno != EINTR) {
failed++;
perror("write");
}
close(s);
continue;
}
if(http10 == 0)
if(shutdown(s, 1)) {
perror("shutdown");
failed++;
close(s);
continue;
}
if(force == 0) {
/* read all available data from socket */
int index = 0;
while(1) {
if(timerexpired)
break;
i = read(s, buf + index, sizeof(buf) - index);
/* fprintf(stderr,"%d\n",i); */
if(i < 0) {
if (errno != EINTR) {
failed++;
perror("read");
}
close(s);
goto nexttry;
} else if(i == 0)
break;
else {
bytes += i;
index += i;
}
}
if ((check != NULL) && (strstr(buf, check) == NULL)) {
failed++;
fprintf(stderr, "check %s fail\n", check);
}
}
if(close(s)) {
perror("close");
failed++;
continue;
}
speed++;
}
}
int main()
{
int Listenfd,connfd;
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
int val,len,i,last_in = 0,last_out = 0;
struct tcp_info_user info;
char writebuf[MAX_PKT_SIZE];
Listenfd = Socket(AF_INET,SOCK_STREAM,0);
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(Listenfd,(SA*)&servaddr,sizeof(servaddr));
Listen(Listenfd,LISTENQ);
for( ; ;){
clilen = sizeof(cliaddr);
connfd = Accept(Listenfd,(SA*)&cliaddr,&clilen);
sleep(3);
val = 1;
len = sizeof(int);
Setsockopt(connfd, SOL_TCP, TCP_NODELAY,(void *)&val, len);
snprintf(writebuf,TRANSSIZE,"world01");
Write(connfd,writebuf,strlen(writebuf)+1);
sleep_ms(20);
snprintf(writebuf,TRANSSIZE,"world02");
Write(connfd,writebuf,strlen(writebuf)+1);
sleep_ms(20);
snprintf(writebuf,TRANSSIZE,"world03");
Write(connfd,writebuf,strlen(writebuf)+1);
sleep_ms(10);
snprintf(writebuf,TRANSSIZE,"world04");
Write(connfd,writebuf,strlen(writebuf)+1);
i = 0;
while(i < 100*200)
{
len = sizeof(info);
Getsockopt(connfd, SOL_TCP, TCP_INFO,(void *)&info, (socklen_t *)&len);
if( (last_in != info.tcpi_segs_in) || (last_out != info.tcpi_segs_out) )
{
sleep_ms(1);
len = sizeof(info);
Getsockopt(connfd, SOL_TCP, TCP_INFO,(void *)&info, (socklen_t *)&len);
printftcpinfo(&info);
printf("i=%d\n",i);
last_in = info.tcpi_segs_in;
last_out = info.tcpi_segs_out;
}
sleep_ms(10);
i++;
}
sleep(200);
printf("close\n");
Close(connfd);
}
return 0;
}
int main(int argc, char* argv[]) {
struct sockaddr_in sad; // structure to hold an IP address
struct sockaddr_in cad; // structure to hold an IP address
struct addrinfo hint;
struct addrinfo *serverptr;
int sd, sd2; // socket descriptor
int port; // protocol port number
char *host; // pointer to host name
char buf[BUFSIZE]; // buffer for data from the server
char buf2[BUFSIZE];
int bytes_expected;
int alen;
memset((char *)&sad,0,sizeof(sad)); // clear sockaddr structure
sad.sin_family = AF_INET; // set family to Internet
int i;
for(i = 65; i < BUFSIZE + 65; i++)
buf2[i-65] = i % 256;
if (argc < 3) {
printf("usage: %s [ host ] [ port ]\n",argv[0]);
exit(-1);
}
host = argv[1];
port = atoi(argv[2]);
if (port <= 0) {
fprintf(stderr,"SOURCE: bad port number %s\n",argv[2]);
exit(1);
}
// prepare the hint information
bzero(&hint, sizeof(hint));
hint.ai_flags = AI_CANONNAME;
hint.ai_family = AF_INET;
Getaddrinfo(host, NULL, &hint, &serverptr);
bcopy(serverptr->ai_addr, (char *)&sad, serverptr->ai_addrlen);
sad.sin_port = htons((u_short)port);
// Create a socket.
sd = Socket(AF_INET, SOCK_STREAM, 0);
//Bind the socket to the specififed port
Bind(sd, (struct sockaddr *) &sad, sizeof(sad));
printf("SINK: Socket created\n");
listen(sd, 5);
alen = sizeof(cad);
printf("SINK: Waiting for a connection\n");
sd2 = accept(sd, (struct sockaddr *) &cad, &alen);
printf("SINK: Waiting to receive a message\n");
Readn(sd2, &bytes_expected, sizeof(int));
Readn(sd2, buf2, bytes_expected+1);
printf("SINK: Received a message\n");
printf("SINK: (%d) '%s'\n", bytes_expected, buf2);
Readn(sd2, &bytes_expected, sizeof(int));
Readn(sd2, buf2, bytes_expected+1);
printf("SINK: Received a message\n");
printf("SINK: (%d) '%s'\n", bytes_expected, buf2);
printf("SINK: Responding to Source\n");
strcpy(buf, "message recieved");
bytes_expected = strlen(buf);
Writen(sd, &bytes_expected, sizeof(int));
Writen(sd, buf, bytes_expected);
close(sd2);
close(sd);
return 1;
}
/* download the frame */
int tcp_receive_frame(void)
{
int sPort = DEFAULT_PORT_TCP;
int sListen = 0;
int sAccept = 0;
int sRecv = 0;
int frame_fd;
unsigned int sLen = 0;
char tar_cmd[50];
char frame_name[20];
char recv_buf[RECV_BUF_LEN];
struct sockaddr_in ser;
struct sockaddr_in cli;
printf("Server waiting...\n");
sListen = Socket(AF_INET, SOCK_STREAM, 0);
if (sListen < 0)
{
printf("socket() failure!\n");
return -1;
}
ser.sin_family = AF_INET;
ser.sin_port = htons(sPort);
ser.sin_addr.s_addr = htonl(INADDR_ANY);
Bind(sListen, (struct sockaddr*)&ser, sizeof(ser));
Listen(sListen, 5);
while(1)
{
sLen = sizeof(cli);
sAccept = Accept(sListen, (struct sockaddr*)&cli, (unsigned int*)&sLen);
// printf("accept() client IP: [%s]\n", (char*)inet_ntoa(cli.sin_addr));
// printf("accept() client PORT: [%d]\n", ntohs(cli.sin_port));
sRecv = Recv(sAccept, frame_name, sizeof(frame_name), 0);
frame_fd = open(frame_name, O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (frame_fd == -1)
{
perror("open frame");
return -1;
}
while (1)
{
sRecv = Recv(sAccept, recv_buf, sizeof(recv_buf), 0);
write(frame_fd, recv_buf, sRecv);
if (sRecv == 0)
{
break;
}
}
close(frame_fd);
Close(sAccept);
sprintf(tar_cmd, "tar -xzf %s", frame_name);
system(tar_cmd);
sleep(1);
}
Close(sListen);
return 0;
}
TCPStream::TCPStream(TCPSocket &server, bool throwflag, timeout_t to) :
streambuf(), Socket(accept(server.getSocket(), NULL, NULL)),
#ifdef OLD_IOSTREAM
iostream()
#else
iostream((streambuf *)this)
#endif
,bufsize(0)
,gbuf(NULL)
,pbuf(NULL) {
tpport_t port;
family = IPV4;
#ifdef OLD_IOSTREAM
init((streambuf *)this);
#endif
timeout = to;
setError(throwflag);
IPV4Host host = getPeer(&port);
if(!server.onAccept(host, port)) {
endSocket();
error(errConnectRejected);
iostream::clear(ios::failbit | rdstate());
return;
}
segmentBuffering(server.getSegmentSize());
Socket::state = CONNECTED;
}
#ifdef CCXX_IPV6
TCPStream::TCPStream(TCPV6Socket &server, bool throwflag, timeout_t to) :
streambuf(), Socket(accept(server.getSocket(), NULL, NULL)),
#ifdef OLD_IOSTREAM
iostream()
#else
iostream((streambuf *)this)
#endif
,bufsize(0)
,gbuf(NULL)
,pbuf(NULL) {
tpport_t port;
family = IPV6;
#ifdef OLD_IOSTREAM
init((streambuf *)this);
#endif
timeout = to;
setError(throwflag);
IPV6Host host = getIPV6Peer(&port);
if(!server.onAccept(host, port)) {
endSocket();
error(errConnectRejected);
iostream::clear(ios::failbit | rdstate());
return;
}
segmentBuffering(server.getSegmentSize());
Socket::state = CONNECTED;
}
#endif
TCPStream::TCPStream(const IPV4Host &host, tpport_t port, unsigned size, bool throwflag, timeout_t to) :
streambuf(), Socket(AF_INET, SOCK_STREAM, IPPROTO_TCP),
#ifdef OLD_IOSTREAM
iostream(),
#else
iostream((streambuf *)this),
#endif
bufsize(0),gbuf(NULL),pbuf(NULL) {
#ifdef OLD_IOSTREAM
init((streambuf *)this);
#endif
family = IPV4;
timeout = to;
setError(throwflag);
connect(host, port, size);
}
#ifdef CCXX_IPV6
TCPStream::TCPStream(const IPV6Host &host, tpport_t port, unsigned size, bool throwflag, timeout_t to) :
streambuf(), Socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP),
#ifdef OLD_IOSTREAM
iostream(),
#else
iostream((streambuf *)this),
#endif
bufsize(0),gbuf(NULL),pbuf(NULL) {
family = IPV6;
#ifdef OLD_IOSTREAM
init((streambuf *)this);
#endif
timeout = to;
setError(throwflag);
connect(host, port, size);
}
#endif
TCPStream::~TCPStream()
{
#ifdef CCXX_EXCEPTIONS
try { endStream(); }
catch( ... ) { if ( ! std::uncaught_exception()) throw;};
#else
endStream();
#endif
}
#ifdef HAVE_GETADDRINFO
void TCPStream::connect(const char *target, unsigned mss)
{
char namebuf[128];
char *cp;
struct addrinfo hint, *list = NULL, *next, *first;
bool connected = false;
snprintf(namebuf, sizeof(namebuf), "%s", target);
cp = strrchr(namebuf, '/');
if(!cp)
cp = strrchr(namebuf, ':');
if(!cp) {
endStream();
connectError();
return;
}
*(cp++) = 0;
memset(&hint, 0, sizeof(hint));
hint.ai_family = family;
hint.ai_socktype = SOCK_STREAM;
hint.ai_protocol = IPPROTO_TCP;
if(getaddrinfo(namebuf, cp, &hint, &list) || !list) {
endStream();
connectError();
return;
}
first = list;
#ifdef TCP_MAXSEG
if(mss)
setsockopt(so, IPPROTO_TCP, TCP_MAXSEG, (char *)&mss, sizeof(mss));
#endif
while(list) {
if(!::connect(so, list->ai_addr, (socklen_t)list->ai_addrlen)) {
connected = true;
break;
}
next = list->ai_next;
list = next;
}
freeaddrinfo(first);
if(!connected) {
endStream();
connectError();
return;
}
segmentBuffering(mss);
Socket::state = CONNECTED;
}
int main(int argc, char *argv[])
{
int sockfd;
const int on = 1;
pid_t pid;
struct ifaddrs *ifp, *ifphead;
struct sockaddr_in *sa, cliaddr, wildaddr;
struct ifreq ifr;
if (getifaddrs(&ifp) < 0)
err_sys("getifaddrs error");
for (ifphead = ifp; ifp = ifp->ifa_next; ifp != NULL) {
if (!(ifp->ifa_flags & IFF_UP))
continue;
if (ifp->ifa_addr->sa_family != AF_INET)
continue;
sockfd = Socket(AF_INET, SOCK_DGRAM, 0);
Setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
sa = (struct sockaddr_in *) ifp->ifa_addr;
sa -> sin_family = AF_INET;
sa -> sin_port = htons(SERV_PORT);
Bind(sockfd, (SA *)sa, sizeof(*sa));
printf("bound %s\n", Sock_ntop((SA *)sa, sizeof(*sa)));
if ((pid = fork()) == 0) { /* child */
adv_mydg_echo(sockfd, (SA *)&cliaddr, sizeof(cliaddr), (SA *)sa);
exit(0); /* never executed */
}
/* Parent continue... */
/* try to bind the broadcast address */
#ifdef SIOCGIFBRDADDR
if (ifp->ifa_flags & IFF_BROADCAST) {
sockfd = Socket(AF_INET, SOCK_DGRAM, 0);
bzero(&ifr, sizeof(struct ifreq));
strncpy(ifr.ifr_name, ifp->ifa_name, IFNAMSIZ);
if (ioctl(sockfd, SIOCGIFBRDADDR, &ifr) < 0)
err_sys("ioctl SIOCGIFBRDADDR error");
sa = (struct sockaddr_in *) &ifr.ifr_ifru.ifru_broadaddr;
sa->sin_family = AF_INET;
sa->sin_port = htons(SERV_PORT);
close(sockfd);
sockfd = Socket(AF_INET, SOCK_DGRAM, 0);
Setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
if (bind(sockfd, (SA *)sa, sizeof(*sa)) < 0) {
if (errno == EADDRINUSE) {
printf("EADDRINUSE: %s\n",
Sock_ntop((SA *)sa, sizeof(*sa)));
Close(sockfd);
continue;
} else {
err_sys("bind error for %s",
Sock_ntop((SA *)sa, sizeof(*sa)));
}
}
printf("bound %s\n", Sock_ntop((SA *)sa, sizeof(*sa)));
if ((pid = fork()) == 0) { /* child */
adv_mydg_echo(sockfd, (SA *)&cliaddr, sizeof(cliaddr), (SA *)sa);
exit(0); /* never executed */
}
}
#endif
}
/* bind wildcard address */
sockfd = Socket(AF_INET, SOCK_DGRAM, 0);
Setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
bzero(&wildaddr, sizeof(wildaddr));
wildaddr.sin_family = AF_INET;
wildaddr.sin_addr.s_addr = htonl(INADDR_ANY);
wildaddr.sin_port = htons(SERV_PORT);
Bind(sockfd, (SA *)&wildaddr, sizeof(wildaddr));
printf("bound %s\n", Sock_ntop((SA *)&wildaddr, sizeof(wildaddr)));
if ((pid = fork()) == 0) { /* child */
adv_mydg_echo(sockfd, (SA *)&cliaddr, sizeof(cliaddr), (SA *)&wildaddr);
exit(0);
}
freeifaddrs(ifphead);
exit(0);
}
void
traceloop(void)
{
int seq, code, done;
double rtt;
struct rec *rec;
struct timeval tvrecv;
recvfd = Socket(pr->sasend->sa_family, SOCK_RAW, pr->icmpproto);
setuid(getuid()); /* don't need special permissions anymore */
#ifdef IPV6
if (pr->sasend->sa_family == AF_INET6 && verbose == 0) {
struct icmp6_filter myfilt;
ICMP6_FILTER_SETBLOCKALL(&myfilt);
ICMP6_FILTER_SETPASS(ICMP6_TIME_EXCEEDED, &myfilt);
ICMP6_FILTER_SETPASS(ICMP6_DST_UNREACH, &myfilt);
setsockopt(recvfd, IPPROTO_IPV6, ICMP6_FILTER,
&myfilt, sizeof(myfilt));
}
#endif
sendfd = Socket(pr->sasend->sa_family, SOCK_DGRAM, 0);
pr->sabind->sa_family = pr->sasend->sa_family;
sport = (getpid() & 0xffff) | 0x8000; /* our source UDP port # */
sock_set_port(pr->sabind, pr->salen, htons(sport));
Bind(sendfd, pr->sabind, pr->salen);
sig_alrm(SIGALRM);
seq = 0;
done = 0;
for (ttl = 1; ttl <= max_ttl && done == 0; ttl++) {
Setsockopt(sendfd, pr->ttllevel, pr->ttloptname, &ttl, sizeof(int));
bzero(pr->salast, pr->salen);
printf("%2d ", ttl);
fflush(stdout);
for (probe = 0; probe < nprobes; probe++) {
rec = (struct rec *) sendbuf;
rec->rec_seq = ++seq;
rec->rec_ttl = ttl;
Gettimeofday(&rec->rec_tv, NULL);
sock_set_port(pr->sasend, pr->salen, htons(dport + seq));
Sendto(sendfd, sendbuf, datalen, 0, pr->sasend, pr->salen);
if ( (code = (*pr->recv)(seq, &tvrecv)) == -3)
printf(" *"); /* timeout, no reply */
else {
char str[NI_MAXHOST];
if (sock_cmp_addr(pr->sarecv, pr->salast, pr->salen) != 0) {
if (getnameinfo(pr->sarecv, pr->salen, str, sizeof(str),
NULL, 0, 0) == 0)
printf(" %s (%s)", str,
Sock_ntop_host(pr->sarecv, pr->salen));
else
printf(" %s",
Sock_ntop_host(pr->sarecv, pr->salen));
memcpy(pr->salast, pr->sarecv, pr->salen);
}
tv_sub(&tvrecv, &rec->rec_tv);
rtt = tvrecv.tv_sec * 1000.0 + tvrecv.tv_usec / 1000.0;
printf(" %.3f ms", rtt);
if (code == -1) /* port unreachable; at destination */
done++;
else if (code >= 0)
printf(" (ICMP %s)", (*pr->icmpcode)(code));
}
fflush(stdout);
}
printf("\n");
}
}
static int handle_connect(struct socket_buffer *client_sock,
struct http_request *request)
{
union sockaddr_u su;
size_t sslen = sizeof(su.storage);
int maxfd, s;
char *line;
size_t len;
fd_set m, r;
if (request->uri.port == -1) {
if (o.verbose)
logdebug("No port number in CONNECT URI.\n");
return 400;
}
if (o.debug > 1)
logdebug("CONNECT to %s:%hu.\n", request->uri.host, request->uri.port);
if (!resolve(request->uri.host, request->uri.port, &su.storage, &sslen, o.af)) {
if (o.debug)
logdebug("Can't resolve name %s.\n", request->uri.host);
return 504;
}
s = Socket(su.storage.ss_family, SOCK_STREAM, IPPROTO_TCP);
if (connect(s, &su.sockaddr, sslen) == -1) {
if (o.debug)
logdebug("Can't connect to %s.\n", inet_socktop(&su));
Close(s);
return 504;
}
send_string(&client_sock->fdn, http_code2str(200));
/* Clear out whatever is left in the socket buffer. The client may have
already sent the first part of its request to the origin server. */
line = socket_buffer_remainder(client_sock, &len);
if (send(s, line, len, 0) < 0) {
if (o.debug)
logdebug("Error sending %u leftover bytes: %s.\n", len, strerror(errno));
Close(s);
return 0;
}
maxfd = client_sock->fdn.fd < s ? s : client_sock->fdn.fd;
FD_ZERO(&m);
FD_SET(client_sock->fdn.fd, &m);
FD_SET(s, &m);
errno = 0;
while (!socket_errno() || socket_errno() == EINTR) {
char buf[DEFAULT_TCP_BUF_LEN];
int len, rc, numready;
r = m;
numready = fselect(maxfd + 1, &r, NULL, NULL, NULL);
zmem(buf, sizeof(buf));
if (FD_ISSET(client_sock->fdn.fd, &r)) {
do {
do {
len = fdinfo_recv(&client_sock->fdn, buf, sizeof(buf));
} while (len == -1 && socket_errno() == EINTR);
if (len <= 0)
goto end;
do {
rc = send(s, buf, len, 0);
} while (rc == -1 && socket_errno() == EINTR);
if (rc == -1)
goto end;
} while (fdinfo_pending(&client_sock->fdn));
}
if (FD_ISSET(s, &r)) {
do {
len = recv(s, buf, sizeof(buf), 0);
} while (len == -1 && socket_errno() == EINTR);
if (len <= 0)
goto end;
do {
rc = fdinfo_send(&client_sock->fdn, buf, len);
} while (rc == -1 && socket_errno() == EINTR);
if (rc == -1)
goto end;
}
}
end:
close(s);
return 0;
}
int main(int argc, char **argv) {
int sockfd, n;
char recvline[MAXLINE + 1];
char error[MAXLINE + 1];
char addrbuf[30];
struct sockaddr_in servaddr;
struct sockaddr_in conndata;
socklen_t socklength;
struct pollfd ufds[2];
int rv;
int bytes_read;
int bytes_sent;
char buf0[MAXLINE];
char buf1[MAXLINE];
if (argc != 2) {
strcpy(error,"uso: ");
strcat(error,argv[0]);
strcat(error," <IPaddress>");
perror(error);
exit(1);
}
// Criação do socket
sockfd = Socket(AF_INET, SOCK_STREAM, 0);
// Seta os campos da struct com os dados para a conexão
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(PORT);
if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0) {
perror("inet_pton error");
exit(1);
}
// Realiza a conexão
Connect(sockfd, &servaddr);
// Dados da conexão para impressão
socklength = (socklen_t)sizeof(struct sockaddr_in);
if (getsockname(sockfd, (struct sockaddr *) &conndata, &socklength) == -1) {
perror("erro no getsockname");
exit(1);
}
if (!inet_ntop(AF_INET, (void *)&conndata.sin_addr, addrbuf, socklength)) {
perror("erro no inet_ntop");
exit(1);
}
printf("Conectado a %s na porta %d\n", argv[1], PORT);
printf("Dados da conexão local: IP %s e porta %d\n", addrbuf, ntohs(conndata.sin_port));
ufds[0].fd = sockfd;
ufds[0].events = POLLIN | POLLOUT;
ufds[1].fd = fileno(stdin);
ufds[1].events = POLLIN;
bytes_read = 0;
bytes_sent = 0;
memset(buf0, 0, sizeof(buf0));
memset(buf1, 0, sizeof(buf1));
while (1)
{
n = 0;
rv = poll(ufds, 2, 1000);
if ((bytes_sent > 0) && (ufds[0].revents & POLLIN))
{
if (read(ufds[0].fd, buf0, strlen(buf0)))
{
bytes_sent = 0;
puts(buf0);
memset(buf0, 0, sizeof(buf0));n = 1;
}
}
if ((bytes_read > 0) && (ufds[0].revents & POLLOUT))
{
send(ufds[0].fd, buf1, strlen(buf1), 0);
bytes_sent = 1;
bytes_read = 0;
memset(buf1, 0, sizeof(buf1));n = 1;
}
if ((bytes_read == 0) && (ufds[1].revents & POLLIN))
{
fgets(buf1, sizeof(buf1), stdin);
bytes_read = 1;n = 1;
}
if (n)
{
printf("%d %d\n", bytes_read, bytes_sent);
}
}
/* Recebe os dados e os imprime
while (1) {
fgets(recvline, sizeof(recvline) - 1, stdin);
n = strlen(recvline) + 1;
write(sockfd, recvline, n);
read(sockfd, recvline, n);
puts(recvline);
}
if (n < 0) {
perror("read error");
exit(1);
}*/
exit(0);
}
