int main(void)
{
fd_set active_fd_set, read_fd_set;
int i;
struct sockaddr_in clientname;
socklen_t size;
int sock = make_socket(PORT);
if(listen(sock, 1) < 0)
{
perror("listen");
exit(EXIT_FAILURE);
}
FD_ZERO(&active_fd_set);
FD_SET(sock,&active_fd_set);
while(1)
{
read_fd_set = active_fd_set;
if(select(FD_SETSIZE, &read_fd_set, NULL, NULL, NULL) < 0)
{
perror("select");
exit(EXIT_FAILURE);
}
for(i=0; i<FD_SETSIZE; ++i)
{
if(FD_ISSET(i, &read_fd_set))
{
if(i == sock)
{
int newc;
size = sizeof(clientname);
newc = accept(sock, (struct sockaddr *) &clientname, &size);
if(newc < 0)
{
perror("accept");
exit(EXIT_FAILURE);
}
fprintf(stderr, "connect from host %s, port %hd.\n", inet_ntoa(clientname.sin_addr), ntohs(clientname.sin_port));
FD_SET(newc, &active_fd_set);
}
else
{
if(read_from_client(i)<0)
{
close(i);
FD_CLR(i, &active_fd_set);
}
}
}
}
}
return 0;
}
int handle_client(t_selfd *fd, t_server *serv)
{
char *cmd;
int r;
ssize_t swr;
if (ISREADABLE(fd))
{
if (((r = read_from_client(fd)) < 0 && errno != EINTR) || (r == 0))
{
log_connection(((t_client *)fd->data)->sock,
"Client disconnected from:");
return (destroy_connection(serv, fd));
}
}
if (ISWRITEABLE(fd) && (r = write_to_client(fd)) < 0 && errno != EINTR)
return (destroy_connection(serv, fd));
while ((cmd = get_command(fd)))
handle_add_cmd(serv, fd, cmd);
swr = ring_buffer_left_read(fd->wbuff);
if (!swr && fd->to_close)
return (destroy_connection(serv, fd));
if (swr)
CHECKWRITE(fd);
CHECKREAD(fd);
push_instruction(serv, fd);
return (0);
}
apr_status_t serf__process_client(serf_incoming_t *client, apr_int16_t events)
{
apr_status_t rv;
if ((events & APR_POLLIN) != 0) {
rv = read_from_client(client);
if (rv) {
return rv;
}
}
if ((events & APR_POLLHUP) != 0) {
return APR_ECONNRESET;
}
if ((events & APR_POLLERR) != 0) {
return APR_EGENERAL;
}
if ((events & APR_POLLOUT) != 0) {
rv = write_to_client(client);
if (rv) {
return rv;
}
}
return APR_SUCCESS;
}
int main(int argc, char* argv[]) {
fd_set active_set, read_set;
int port = atoi(argv[1]);
int sock_fd = open_socket();
bind_socket(sock_fd, port);
listen_socket(sock_fd, 5);
FD_ZERO(&active_set);
FD_SET(sock_fd, &active_set);
while(1) {
read_set = active_set;
if (select(FD_SETSIZE, &read_set, NULL, NULL, NULL) < 0) {
perror("select error");
exit(EXIT_FAILURE);
}
for (int i = 0; i < FD_SETSIZE; i++) {
if (FD_ISSET(i, &read_set)) {
if (i == sock_fd) {
int accepted_fd = accept_connection(sock_fd);
FD_SET(accepted_fd, &active_set);
} else {
if (read_from_client(i) < 0) {
close_socket(i);
FD_CLR(i, &active_set);
}
}
}
}
}
return 0;
}
char *
check_node(void)
{
char *buf;
int sock, i;
struct sockaddr_in name;
struct hostent *hostinfo;
/* create socket */
sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock < 0)
bailout();
name.sin_family = AF_INET;
name.sin_port = htons(oportnum);
hostinfo = gethostbyname(jsd_host);
if (hostinfo == NULL) {
(void)fprintf(stderr, "Unknown host %s.\n", jsd_host);
exit(EXIT_FAILURE);
}
name.sin_addr = *(struct in_addr *)hostinfo->h_addr;
if (connect(sock, (struct sockaddr *)&name, sizeof(name)) < 0)
bailout();
i = read_from_client(sock, &buf); /* get a node */
buf[i] = '\0';
if (debug)
printf("Got node %s\n", buf);
(void)close(sock);
return(buf);
}
int
handle_client(int socket) {
// Get the client registered to the socket
Client *client = search_client(socket);
if (client == NULL) {
perror("Unregistered client socket found! This is not in the list!");
return EXIT_FAILURE;
}
// Read the complete input of the client
int res = read_from_client(client);
if (res != EXIT_SUCCESS)
return res;
// Try to extract a single message from the buffer
StringBuffer *msg = extract_message(client);
if (msg == NULL) {
return EXIT_SUCCESS;
}
if (is_command(client, msg) == EXIT_SUCCESS) {
handle_command(client, msg);
}
else {
broadcast_message(client, msg);
}
StringBuffer_free(msg);
return EXIT_SUCCESS;
}
int main(int argc , char *argv[])
{
Maintainer maintainer;
init_maintainer(&maintainer);
logger("<Server><main>maintainer initialized\n");
int opt = TRUE;
if((maintainer.master_socket=socket(AF_INET, SOCK_STREAM, 0))==0){
logger("<Server><main>failed at master socket creation\n");
return 1;
}
fcntl(maintainer.master_socket, F_SETFL, O_NONBLOCK);
if(setsockopt(maintainer.master_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(opt)) < 0){
logger("<Server><main>failed at master socket reuse\n");
return 1;
}
if(bind(maintainer.master_socket, (struct sockaddr *)&(maintainer.address), sizeof(maintainer.address)) < 0){
logger("<Server><main>failed at master socket binding\n");
return 1;
}
if (listen(maintainer.master_socket, 10) < 0){
logger("<Server><main>failed at master socket listen");
return 1;
}
FD_SET(maintainer.master_socket, &(maintainer.fd_read_set));
maintainer.max_sd = maintainer.master_socket;
while(TRUE){
maintainer.fd_read_set_select = maintainer.fd_read_set;
if ((select(maintainer.max_sd+1, &(maintainer.fd_read_set_select),NULL,NULL, NULL) < 0))
logger("<Server><main>error at select\n");
if (FD_ISSET(maintainer.master_socket, &(maintainer.fd_read_set_select)))
handle_new_client(&maintainer);
for(int i=0; i<MAX_CLIENTS; ++i){
int current_socket = maintainer.clients[i].socket_fd;
if(current_socket == -1)
continue;
if(FD_ISSET(current_socket, &(maintainer.fd_read_set_select)))
read_from_client(&maintainer, current_socket,&(maintainer.clients[i]));
}
}
return 0;
}
void chat_server() {
int sockfd = make_passive_socket_tcp(SERV_PORT, SERV_BACKLOG); // make a TCP socket
fd_set active_fds;
fd_set read_fds;
struct sockaddr_in client_addr;
int i;
// Initialize
FD_ZERO(&active_fds);
FD_SET(sockfd, &active_fds);
while (1) {
memcpy(&read_fds, &active_fds, sizeof(read_fds));
if (select(FD_SETSIZE, &read_fds, (fd_set *)NULL, (fd_set *)NULL,
(struct timeval *)NULL) < 0) {
perror("call select() error");
exit(1);
}
// Connections on original socket
if (FD_ISSET(sockfd, &read_fds)) {
int new_socket;
socklen_t size;
size = sizeof (client_addr);
new_socket = accept(sockfd, (struct sockaddr *)&client_addr, &size);
if (new_socket < 0) {
perror("call accept() error");
exit(1);
}
FD_SET(new_socket, &active_fds);
}
for (i = 0; i < FD_SETSIZE; i++)
if (i != sockfd && FD_ISSET(i, &read_fds)) {
// Data arriving on already connected socket
if (read_from_client(i)) {
close(i);
FD_CLR(i, &active_fds);
}
}
}
}
void check_fdset(fd_set *rfds, fd_set *wfds, t_mgs_context *context)
{
t_mgs_client *tmp;
if (FD_ISSET(context->fd, rfds))
accept_mgs_new_client(context);
tmp = context->clients;
while (tmp)
{
if (tmp->fd >= 0)
{
if (FD_ISSET(tmp->fd, rfds))
if (read_from_client(tmp))
return ;
if (tmp->buffout != NULL && FD_ISSET(tmp->fd, wfds))
write_to_client(tmp);
}
tmp = tmp->next;
}
return ;
}
void
free_node(char *nodename)
{
int sock;
char *buf;
struct sockaddr_in name;
struct hostent *hostinfo;
/* create socket */
sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock < 0)
bailout();
name.sin_family = AF_INET;
name.sin_port = htons(iportnum);
hostinfo = gethostbyname(jsd_host);
if (hostinfo == NULL) {
(void)fprintf(stderr, "Unknown host %s.\n", jsd_host);
exit(EXIT_FAILURE);
}
name.sin_addr = *(struct in_addr *)hostinfo->h_addr;
if (connect(sock, (struct sockaddr *)&name, sizeof(name)) < 0)
bailout();
if (debug)
printf("Freeing node %s\n", nodename);
read_from_client(sock, &buf);
/* we just ignore the contents, so free it */
free(buf);
if (write_to_client(sock, nodename) != 0)
bailout();
if (debug)
printf("freed node %s\n", nodename);
(void)close(sock);
}
int main(int argc , char *argv[])
{
Maintainer* maintainer = mymalloc(sizeof(Maintainer));
init_maintainer(maintainer);
logger("<Server><main>maintainer initialized\n");
int opt = TRUE;
if((maintainer->master_socket=socket(AF_INET, SOCK_STREAM, 0))==0) {
logger("<Server><main>failed at master socket creation\n");
myfree(maintainer);
exit(EXIT_FAILURE);
}
fcntl(maintainer->master_socket, F_SETFL, O_NONBLOCK);
if(setsockopt(maintainer->master_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(opt)) < 0) {
logger("<Server><main>failed at master socket reuse\n");
myfree(maintainer);
exit(EXIT_FAILURE);
}
if(bind(maintainer->master_socket, (struct sockaddr *)&(maintainer->address), sizeof(maintainer->address)) < 0) {
logger("<Server><main>failed at master socket binding\n");
myfree(maintainer);
exit(EXIT_FAILURE);
}
if (listen(maintainer->master_socket, 10) < 0) {
logger("<Server><main>failed at master socket listen");
exit(EXIT_FAILURE);
}
FD_SET(maintainer->master_socket, &(maintainer->fd_read_set));
FD_SET(maintainer->master_socket, &(maintainer->fd_exception_set));
maintainer->max_sd = maintainer->master_socket;
while(TRUE) {
maintainer->fd_read_set_select = maintainer->fd_read_set;
maintainer->fd_write_set_select = maintainer->fd_write_set;
maintainer->fd_exception_set_select = maintainer->fd_exception_set;
if ((select(maintainer->max_sd+1, &(maintainer->fd_read_set_select),
&(maintainer->fd_write_set_select),
&(maintainer->fd_exception_set_select), NULL) < 0))
logger("<Server><main>error at select\n");
if (FD_ISSET(maintainer->master_socket, &(maintainer->fd_read_set_select)))
handle_new_client(maintainer);
if (FD_ISSET(maintainer->master_socket, &(maintainer->fd_exception_set_select)))
handle_server_exception(maintainer);
struct Nodes_ll* prev = maintainer->clients;
struct Nodes_ll* iterator = maintainer->clients;
while(iterator != NULL) {
int current_socket = iterator->node->socket_fd;
if(FD_ISSET(current_socket, &(maintainer->fd_exception_set_select)))
close_client_connection(maintainer, current_socket, iterator->node, TRUE);
else if(FD_ISSET(current_socket, &(maintainer->fd_read_set_select)))
if(!read_from_client(maintainer, current_socket, iterator->node))
if(FD_ISSET(current_socket, &(maintainer->fd_write_set_select)))
write_to_client(maintainer, current_socket, iterator->node);
else if(FD_ISSET(current_socket, &(maintainer->fd_write_set_select)))
write_to_client(maintainer, current_socket, iterator->node);
if(iterator != maintainer->clients) {
if(iterator->node->socket_fd == -1) {
prev->next = iterator->next;
myfree(iterator->node);
struct Nodes_ll* tmp = iterator;
iterator = iterator->next;
myfree(tmp);
}
else {
prev = prev->next;
iterator = iterator->next;
}
} else if(iterator->node->socket_fd == -1) { /*marked for deletation*/
maintainer->clients = iterator->next;
myfree(iterator->node);
struct Nodes_ll* tmp = iterator;
iterator = iterator->next;
myfree(tmp);
} else
iterator = iterator->next;
}
}
myfree(maintainer);
return 0;
}
int main(int argc, char *argv[])
{
int retval,yes=1;
long curtime;
unsigned int serverlen, clientlen;
struct sockaddr_in server,client,clientname;
struct hostent *rem;
size_t size;
sigset_t intmask;
struct sigaction sigchild_action,act_stop;
if (argc < 4 || atoi(argv[2])<1 || atof(argv[3])<0.00 || atof(argv[3])>1.00) { // Check arg's //
printf("Usage:name TCP port number NUMCHILDREN>=1\n");
return 1; }
NUMCHILDREN=atoi(argv[2]);
if (pipe(fd)==-1) { // Create pipe//
perror("pipe");
return 1; }
if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) { //Create socket for TCP communication-passive//
perror("parent:socket"); //communication endpoint //
return 1; }
port = atoi(argv[1]); // Convert port number to integer //
server.sin_family = PF_INET; // Internet domain //
server.sin_addr.s_addr = htonl(INADDR_ANY); // My Internet address //
server.sin_port = htons(port); // The given port //
while ( (retval=setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(yes)))==-1 && errno==EINTR );
if ( (retval)>0){
perror("Reusing ADDR failed");//option in order to reuse immediately port//
return 1;}
while( (retval=bind(sock,(struct sockaddr *)&server,sizeof(server) ))==-1 && errno==EINTR);
if (retval < 0) {// Bind socket to address //
perror("bind");
return 1; }
if (listen(sock, 5) < 0) { // Set up queue for incoming connections. //
perror("parent:listen");
return 1; }
parent_pid=getpid();
for(i=0;i<NUMCHILDREN;i++)
if ((pid_code[i]=pid=fork())<=0) // Create children processes //
break;
if ( pid==0 ){//childcode//
curtime = time(NULL);
srand((unsigned int) curtime);
probFail=atof(argv[3]);
fprintf(stderr,"child:%ld is born and ready\n",(long)getpid());
act_stop.sa_handler=timeToStop; //handler for act_stop//
act_stop.sa_flags=0;
if ((sigemptyset(&act_stop.sa_mask ) == -1) || (sigaction(SIGUSR1,&act_stop,NULL) == -1 ) ){
perror("FAIL TO INSTAL SIGNAL HANDLER FOR SIGUSR1");//install handler for SIGUSR1//
return 1;}
if ((sigemptyset(&intmask) == -1) || (sigaddset(&intmask, SIGPIPE) == -1)){//create signal mask//
perror("Failed to initialize the signal mask");
return 1;}
if (sigprocmask(SIG_BLOCK, &intmask, NULL) == -1){ //ignore the signal of intmask//
perror("Failed to block SIGPIPE");
return 1;}
close(fd[WRITE]);//close unnecessary writing end//
ready=0;
command_count=0;
while(1){
srand((unsigned int) curtime);
bzero(temp,sizeof(temp));
while( (bytesread=read(fd[READ], temp, sizeof(temp)+1))==-1 && errno==EINTR );
if (bytesread < 0 ){
perror("child:read");//read from pipe-parent writter//
return 1;}
i=j=0;
bzero(dgr_port,sizeof(dgr_port));//figure out DGR port//
do{
ch=dgr_port[j]=temp[j++];
}while(ch!='\n');
port=atoi(dgr_port);
bzero(name,sizeof(name));//figure oudt client's name//
i=0;
do{
if(temp[j]==' ')
break;
name[i++]=temp[j++];
}while(1);
i=0;
j++;
bzero(command,sizeof(command));//figure out command//
while(1){
if (temp[j]=='\0')
break;
ch=command[i++]=temp[j++];
}
fprintf(stderr,"child:%ld is going to execute command:%s- for client:%s\n",
(long)getpid(),command,name);
server.sin_family = PF_INET; // Internet domain //
server.sin_port = htons(port); // Server's Internet address and port //
if ((rem = gethostbyname(name)) == NULL) { // Find client's address //
perror("child:gethostbyname");
return 1; }
if ((dgr_sock = socket(PF_INET, SOCK_DGRAM, 0)) < 0) { // Create socket //
perror("child:socket");
return 1; }
bcopy((char *) rem -> h_addr, (char *) &server.sin_addr,rem -> h_length);
client.sin_family = PF_INET; // Internet domain //
client.sin_addr.s_addr = htonl(INADDR_ANY); // My Internet address //
client.sin_port = htons(0); // Select any port //
while ( (retval=setsockopt(dgr_sock,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(yes)))==-1 && errno==EINTR );
if ( (retval)>0){
perror("Reusing ADDR failed");//option in order to reuse immediately port//
return 1;}
while( (retval=bind(dgr_sock,(struct sockaddr *)&client,sizeof(client)))==-1 && errno==EINTR);
if (retval < 0) {// Bind socket to address //
perror("bind");
return 1; }
ready=1;
if (strcmp(command,"end ")==0){ //do you catch end?//
if (sendto(dgr_sock, "all",strlen("all"),0,(struct sockaddr *)&server,sizeof(server)) < 0) {
perror("3 sendto");
exit(1); }
close(fd[READ]);//close your fd'ds//
close(dgr_sock);
fprintf(stderr,"child:%ld closing its fd's and killing itself\n",(long)getpid());
if ( kill(getppid(),SIGUSR2) || kill(getpid(),SIGTERM)){//send signal to parent //
perror("kill"); //and then kill yourself//
return 1;}
return 0;
}
if (strcmp(command,"timeToStop ")==0){//do you catch timeToStop?//
fprintf(stderr,"time to stop\n");
if (kill(getppid(),SIGUSR1)){//send signal to parent //
perror("kill");
return 1;}
sleep(1);
break;//break so as not to execute command TimeToStop which doesn't exist//
}
if ( (fp = popen(command, "r"))==NULL ){
perror("popen:");//open file and execute command//
return 1;}
bzero(PID_COMMAND,sizeof(PID_COMMAND));
sprintf(PID_COMMAND,"%s:%ld:results:\n",command,getpid());//PID:COMMAND//
bzero(temp,sizeof(temp));
j=i=packets=0;
first=1;
while((ch= getc(fp)) != EOF ){
temp[i++]=ch;
sent_flag=0;
if ( i==(BUFSIZE-1)){
if (first && ((float)(rand()%100+1))>(100*probFail)){
while ((retval=sendto(dgr_sock,PID_COMMAND,sizeof(PID_COMMAND)+1,0,(struct sockaddr *)&server,sizeof(server)))==-1
&& (errno==EINTR));
if (retval < 0) {
perror("1 sendto");//PID:COMMAND//
return 1; }
first=0;
}
if (((float)(rand()%100+1))>(100*probFail)){
while ((retval=sendto(dgr_sock,temp,sizeof(temp),0,(struct sockaddr *)&server,sizeof(server)))==-1
&&(errno==EINTR));
if (retval < 0) {
perror("1 sendto");
return 1; } //RESULTS//
packets++;
}
bzero(temp,sizeof(temp));
sent_flag=1;
i=0;
}
}
if (sent_flag!=1 && ((float)(rand()%100+1))>(100*probFail)){
if (first && ((float)(rand()%100+1))>(100*probFail)){
while( (retval=sendto(dgr_sock,PID_COMMAND,sizeof(PID_COMMAND)+1,0,(struct sockaddr *)&server,sizeof(server)))==-1
&& (errno==EINTR));//PID:COMMAND//
if (retval < 0) {
perror("1 sendto");
return 1; }
first=0;
}
while((retval=sendto(dgr_sock,temp,sizeof(temp),0,(struct sockaddr *)&server,sizeof(server)))==-1 &&(errno==EINTR));
if (retval < 0) {
perror("2 sendto");
return 1;} //RESULTS//
packets++;
}
if (((float)(rand()%100+1))>(100*probFail)){
while ((retval=sendto(dgr_sock,"all",strlen("all"),0,(struct sockaddr *)&server,sizeof(server)))==-1
&&(errno==EINTR));
if (retval <0) {
perror("1 sendto");//send phrase for end of packets//
return 1; }
}
fprintf(stderr,"packets send:%d\n\n",packets);
close(dgr_sock);
pclose(fp);
command_count++;
}
}
else{//father code//
printf("big papa is borned and ready with pid:%ld\n",(long)getpid());
close(fd[READ]);//close unnecessary readind end//
FD_ZERO (&active_fd_set);
FD_SET (sock, &active_fd_set);
if ((sigemptyset(&intmask) == -1) || (sigaddset(&intmask, SIGPIPE) == -1)){//create signal mask//
perror("Failed to initialize the signal mask");
return 1;}
if (sigprocmask(SIG_BLOCK, &intmask, NULL) == -1){ //ignore the signal of intmask//
perror("Failed to block SIGPIPE");
return 1;}
act_stop.sa_handler=timeToStop; //TimeToStop handler//
act_stop.sa_flags=0;
if ((sigemptyset(&act_stop.sa_mask ) == -1) || (sigaction(SIGUSR1,&act_stop,NULL) == -1 ) ){
perror("FAIL TO INSTAL SIGNAL HANDLER FOR SIGUSR1");//install handler for SIGUSR1//
return 1;}
sigchild_action.sa_handler = clean_up_children_process;//clean_up_child_process handler//
sigchild_action.sa_flags=0;
if ((sigemptyset(&sigchild_action.sa_mask ) == -1) || (sigaction(SIGUSR2,&sigchild_action,NULL) == -1 ) ){
perror("FAIL TO INSTAL SIGNAL HANDLER FOR SIGUSR2");//install handler for SIGUSR@//
return 1;}
do{
read_fd_set = active_fd_set;
while((retval=(select (FD_SETSIZE, &read_fd_set, NULL, NULL, NULL))==-1) && errno==EINTR);
if (retval < 0){
perror ("parent::select");//wait untill one or more fd's become ready//
return 1;}
for (i = 0; i < FD_SETSIZE; ++i){//for each fd//
if (FD_ISSET (i, &read_fd_set) ){//belong to the set?//
if (i == sock){//we have new request for conection to thr listening sockets//
size = sizeof (clientname);
clientlen = sizeof client;
if ((newsock = accept(sock, (struct sockaddr *)&client, &clientlen)) < 0) {
perror("parent:accept");//accept and create active communication endpoint//
return 1; }
if ((rem = gethostbyaddr((char *) &client.sin_addr.s_addr,sizeof
(client.sin_addr.s_addr),client.sin_family)) == NULL){
perror("parent:gethostbyaddr");
return 1; }
fprintf(stderr,"Accepted TCP connection from listening port:%d to newsock:%d from:%s\n",
(port),(newsock),(rem -> h_name), client.sin_port);
FD_SET (newsock, &active_fd_set);//and to active set//
}
else{//we have new data to a connected client//
size = sizeof (clientname);
clientlen = sizeof client;
getpeername(i,(struct sockaddr *) &client,&clientlen);//get client's name connected to sock//
if ((rem = gethostbyaddr((char *) &client.sin_addr.s_addr,sizeof
(client.sin_addr.s_addr),client.sin_family)) == NULL){
perror("parent:gethostbyaddr");
return 1;}
if (read_from_client (i,rem) < 0){//client no more connected//
fprintf(stderr,"client:%s is no more connected...i am going to close unused filedescripitor:%d\n",
(rem -> h_name),i);
close (i);
FD_CLR (i, &active_fd_set);}//remove from active set//
}
}
}
}while(1);
}
return 1;
}
int main (int argc, char **argv) {
struct sockaddr_rc loc_addr = { 0 }, rem_addr = { 0 };
int serverSock, fdmax, i;
socklen_t opt = sizeof(rem_addr);
fd_set read_fd_set;
char buf[MAXMSG+1] = { 0 };
struct team teams [MAXTEAM];
memset(teams, 0, MAXTEAM * sizeof(struct team));
if (argc < 2 || argc > 3) {
fprintf (stderr, "Usage: %s teamFile [ouputFile]\n", argv[0]);
exit (EXIT_FAILURE);
}
if (argc == 3) {
out = fopen (argv[2], "w");
if (out == NULL) {
fprintf (stderr, "Could not open file %s.\n", argv[2]);
exit (EXIT_FAILURE);
}
}
srand(time(NULL));
printf ("\n\n");
printf (KRED " ) ( ( \n");
printf ( " ( /( )\\ ) )\\ ) \n");
printf ( " ( ( ( ( ) )\\())(()/( (()/( ( ( ) ( ( \n");
printf ( " )\\ ))\\ )( ))\\ ( ( ( ((_)\\ /(_)) /(_)) ))\\ )( /(( ))\\ )( \n");
printf ( " ((_) /((_|()\\ /((_))\\ )\\ )\\ ' ((_)(_)) (_)) /((_|()\\(_))\\ /((_|()\\ \n");
printf (RESET " | __" KRED "(_))( ((_|_)) ((_|(_)_((_)) " RESET "/ _ \\/ __| / __|" KRED "(_)) ((_))((_|_)) ((_) \n");
printf (RESET " | _|| || | '_/ -_) _/ _ \\ ' \\" KRED "() " RESET "| (_) \\__ \\ \\__ \\/ -_)| '_\\ V // -_)| '_| \n");
printf ( " |___|\\_,_|_| \\___\\__\\___/_|_|_| \\___/|___/ |___/\\___||_| \\_/ \\___||_| \n");
printf ("\n\n");
// create server socket
printf ("Creating server socket... ");
fflush (stdout);
serverSock = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
// bind socket to port 1 of the first available local bluetooth adapter
loc_addr.rc_family = AF_BLUETOOTH;
loc_addr.rc_bdaddr = *BDADDR_ANY;
loc_addr.rc_channel = (uint8_t) 1;
bind(serverSock, (struct sockaddr *) &loc_addr, sizeof (loc_addr));
// put socket into listening mode
listen(serverSock, MAXTEAM);
printf ("[" KGRN "OK" RESET "]\n");
// load teams from file
int nbTeams = load_teams_file (argv[1], teams, MAXTEAM);
debug (KNRM, " ... %d teams have been loaded...\n", nbTeams);
// connect to server
connect(teams[0].sock, (struct sockaddr *)&rem_addr, sizeof(rem_addr));
// catch SIGINT to stop game
if (signal (SIGINT, intHandler) == SIG_ERR) {
fprintf (stderr, "Couldn't catch SIGINT.\n");
exit (EXIT_FAILURE);
}
// start the contest
while (running) {
// print all teams
printf (" +--------------------------------------------+\n");
printf (" |" KRED " TEAMS " RESET " |\n");
printf (" +--------------------------------------------+\n");
for (i=0; i<nbTeams; i++)
if (teams[i].robotType != RBT_MISS)
printf (" | %2d: %s%-" STR(MAXNAMESIZE) "s " RESET " (%3s) |\n",
i,
COL(i),
teams[i].name,
teams[i].robotType == RBT_EV3 ? "EV3" : "NXT");
printf (" +--------------------------------------------+\n");
// prompt for game composition
printf ("Which teams are going to participate? (^D to end the contest)\n");
char invalidInput;
int rankCmp;
do {
for (i=0; i<nbTeams; i++) {
teams[i].active = 0;
teams[i].rank = 0;
if (teams[i].robotType == RBT_NXT) {
teams[i].mailbox->messagesReady = 0;
teams[i].mailbox->nextMessage = 0;
}
}
invalidInput = 0;
printf ("> ");
fflush (stdout);
char *p = fgets (buf, MAXTEAM * 3 + 2, stdin);
if (p == NULL)
running = 0;
else {
rankCmp = 0;
// get participating teams
for (i=-1; *p && *p != '\n'; p++) {
if (*p == ' ') {
if (i != -1) {
if (i < nbTeams && teams[i].robotType != RBT_MISS && !teams[i].active) {
teams[i].active = 1;
teams[i].rank = rankCmp++;
} else {
invalidInput = 1;
printf ("Invalid team number: %d\n", i);
}
i = -1;
}
} else {
if (*p < '0' || *p > '9') {
invalidInput = 1;
printf ("Invalid input number: '%c'\n", *p);
break;
}
if (i == -1)
i = *p - '0';
else
i = i*10 + *p - '0';
}
}
if (i != -1) {
if (i < nbTeams && teams[i].robotType != RBT_MISS && !teams[i].active) {
teams[i].active = 1;
teams[i].rank = rankCmp++;
} else {
invalidInput = 1;
printf ("Invalid team number: %d\n", i);
}
}
if (rankCmp == 0)
invalidInput = 1;
}
} while (invalidInput);
if (running) {
int rep = 0;
while (rep != '0') {
printf ("Rank is:\n");
int j;
for (i=0; i<rankCmp; i++)
for (j=0; j<nbTeams; j++)
if (teams[j].active && teams[j].rank == i) {
printf ("%d: %s%s" RESET "\n", i, COL(j), teams[j].name);
break;
}
printf ("What do you want to do? (default: 0)\n");
printf (" 0: keep that\n");
printf (" 1: randomize all\n");
printf (" 2: randomize all but leader\n");
printf ("> ");
fflush (stdout);
char *p = fgets (buf, 2, stdin);
if (p == NULL || buf[0] == '\n')
break;
if (p[0] < '0' || p[0] > '2')
continue;
rep = p[0];
if (rep == '1') {
for (i=0; i<nbTeams; i++)
if (teams[i].active) {
char found;
unsigned char rnd;
do {
rnd = (unsigned char) (rand () % rankCmp);
found = 0;
for (j=0; j<i; j++)
if (teams[j].active && teams[j].rank == rnd) {
found = 1;
break;
}
} while (found);
teams[i].rank = rnd;
}
} else if (rep == '2') {
for (i=0; i<nbTeams; i++)
if (teams[i].active && teams[i].rank != 0) {
char found;
unsigned char rnd;
do {
rnd = (unsigned char) (rand () % (rankCmp-1)) + 1;
found = 0;
for (j=0; j<i; j++)
if (teams[j].active && teams[j].rank == rnd) {
found = 1;
break;
}
} while (found);
teams[i].rank = rnd;
}
}
}
debug (KRED, "Starting game with teams ");
int j;
for (i=0; i<rankCmp; i++)
for (j=0; j<nbTeams; j++)
if (teams[j].active && teams[j].rank == i) {
if (i != 0)
debug (KRED, ", ");
debug (COL(j), "%s", teams[j].name);
break;
}
debug (KRED, ".\n");
} else
break;
time_t startTime = time (NULL) + CONNECT_DELAY;
char state = GAM_CONNECTING;
while (running) {
fdmax = serverSock;
FD_ZERO (&read_fd_set);
FD_SET (serverSock, &read_fd_set);
for (i=0; i<nbTeams; i++)
if (teams[i].connected) {
FD_SET (teams[i].sock, &read_fd_set);
if (teams[i].sock > fdmax)
fdmax = teams[i].sock;
}
int selectRet;
time_t now = time (NULL);
if (now >= startTime && state == GAM_CONNECTING) {
printf (KRED "Game starts NOW !\n" RESET);
buf[0] = 0x00; // ID of start message
buf[1] = 0x00; // is 0000
buf[2] = 0xFF; // server ID is 0xFF
buf[4] = MSG_START; // This is a START message
buf[6] = (char) (0xFF & rankCmp); // length of the snake
char first = 1;
for (i=0; i<nbTeams; i++) {
if (teams[i].active) {
if (teams[i].connected) {
buf[3] = (char) (0xFF & i); // receiver
buf[5] = teams[i].rank; // rank
buf[7] = 0xFF;
buf[8] = 0xFF;
int j;
for (j=0; j<nbTeams; j++)
if (teams[j].active) {
if (teams[j].rank == teams[i].rank - 1)
buf[7] = (char) (0xFF & j); // previous
if (teams[j].rank == teams[i].rank + 1)
buf[8] = (char) (0xFF & j); // next
}
write_to_client (&teams[i], buf, 9);
} else {
if (first)
first = 0;
else
printf (KRED ", " RESET);
printf ("%s%s" RESET, COL(i), teams[i].name);
}
}
}
if (!first)
printf (KRED " failed to connect.\n" RESET);
state = GAM_RUNNING;
}
if (now < startTime) {
struct timeval tv;
tv.tv_sec = startTime - now;
tv.tv_usec = 0;
selectRet = select (fdmax+1, &read_fd_set, NULL, NULL, &tv);
} else
selectRet = select (fdmax+1, &read_fd_set, NULL, NULL, NULL);
if (selectRet < 0) {
if (running) {
fprintf (stderr, "Error when select.\n");
exit (EXIT_FAILURE);
}
} else {
if (FD_ISSET (serverSock, &read_fd_set)) {
// accept one connection
int client = accept(serverSock, (struct sockaddr *)&rem_addr, &opt);
for (i=0; i<nbTeams; i++)
if (memcmp (&teams[i].address, &rem_addr.rc_bdaddr, sizeof (bdaddr_t)) == 0) {
if (teams[i].active) {
teams[i].sock = client;
teams[i].connected = 1;
debug (KRED, "Team ");
debug (COL(i), "%s", teams[i].name);
debug (KRED, " is now connected.\n");
if (state == GAM_RUNNING) {
buf[0] = 0x00; // ID of start message
buf[1] = 0x00; // is 0000
buf[2] = 0xFF; // server ID is 0xFF
buf[3] = (char) (0xFF & i); // receiver
buf[4] = MSG_START; // This is a START message
buf[5] = teams[i].rank; // rank
buf[6] = (char) (0xFF & rankCmp); // length of the snake
buf[7] = 0xFF;
buf[8] = 0xFF;
int j;
for (j=0; j<nbTeams; j++)
if (teams[j].active) {
if (teams[j].rank == teams[i].rank - 1)
buf[7] = (char) (0xFF & j); // previous
if (teams[j].rank == teams[i].rank + 1)
buf[8] = (char) (0xFF & j); // next
}
write_to_client (&teams[i], buf, 9);
}
} else {
debug (KRED, "Team ");
debug (COL(i), "%s", teams[i].name);
debug (KRED, " tried to connect while not taking part in this game!\n");
close (client);
}
break;
}
if (i == nbTeams) {
ba2str(&rem_addr.rc_bdaddr, buf );
debug (KRED, "Unknown connection from address %s.\n", buf);
close (client);
}
}
for (i = 0; i <= nbTeams; ++i)
if (teams[i].connected && FD_ISSET (teams[i].sock, &read_fd_set)) {
memset(buf, 0, sizeof(buf));
int nbbytes;
if ((nbbytes = read_from_client (&teams[i], buf, MAXMSG)) < 0) {
close (teams[i].sock);
teams[i].connected = 0;
debug (KRED, "Team ");
debug (COL(i), "%s", teams[i].name);
debug (KRED, " has disconnected.\n");
} else if (nbbytes != 0 && state == GAM_RUNNING)
parseMessage (teams, nbTeams, i, (unsigned char *) buf, nbbytes);
}
}
}
printf ("\n");
debug (KRED, "End of this game.\n\n");
running = 1;
buf[0] = 0x01; // ID of stop message
buf[1] = 0x00; // is 0001
buf[2] = 0xFF; // server ID is 0xFF
buf[4] = MSG_STOP; // This is a STOP message
for (i = 0; i < nbTeams; i++) {
if (teams[i].connected) {
buf[3] = (char) (0xFF & i); // receiver
write_to_client (&teams[i], buf, 5);
close (teams[i].sock);
teams[i].connected = 0;
}
if (teams[i].active)
teams[i].active = 0;
}
}
printf ("\n");
debug (KRED, "End of the contest.\n");
for (i=0; i<nbTeams; i++)
if (teams[i].robotType == RBT_NXT)
free (teams[i].mailbox);
if (out)
fclose (out);
close(serverSock);
return 0;
}
