dtd.c.zip_The Network

/* Daytime Daemon @2000 Helder Daniel formato de linha de comando: dtd <maximo de conexoes concorrentes> <porto> */ #include <stdlib.h> #include <stdio.h> #include <sys/socket.h> #include <sys/types.h> #include <sys/wait.h> #include <netinet/in.h> #include <signal.h> #include <sys/stat.h> #include <time.h> #include <string.h> #include <errno.h> int Numproc=0; void end_child(int s) { /* Suspende a execuçao do processo corrente, ate que um filho especificado pelo 1º parametro termine. Se este valor for 0 espera por qualquer processo do mesmo grupo. O 2º parametro indica onde a funçao pode guardar informacao sobre o estado da termincao do processo especificado no 1º parametro. O 3º parametro WNOHANG indica que waitpid retorna imediatamente se nenhum filho esta a terminar ou Zombie. Neste caso, waitpid, retorna zero, se existir um erro retorna -1, e em qualquer outro caso o PID do filho que terminou. */ if (waitpid(0, NULL, WNOHANG)>0) Numproc--; else signal (SIGCHLD, end_child); /* Se nao existir nenhum filho a terminar ou Zombie ou se ocorreu um erro com waitpid sera necessario restabelecer este manipulador */ } void killsocket(int s, char *m) { perror(m); /* Imprime mensagem de erro */ shutdown(s, 2); /* Desliga a conexao full-duplex associada com o socket s. 2 -> recusar futuros sends e receives */ exit (-1); } void sendinfo(int s, FILE *out) { char *buf; time_t t; t = time(NULL); if (t==-1) fprintf(out, "%s\n", strerror(errno)); fprintf(out, "%s", ctime(&t)); fclose (out); } main(int argc, char **argv) { int port; int maxproc; int sock, csock; int n; struct sockaddr_in server, client; int lc= sizeof(client); FILE *io; /* Valida linha de comandos */ if (argc!=3) { puts("formato de linha de comando:\n" "dtd <maximo de conexoes concorrentes> <porto>"); exit(-1); } if (atoi(*(argv+1))<1 || atoi(*(argv+1))>25) { puts("Conexoes suportadas 1 - 25.\n"); exit(-1); } else maxproc=atoi(*(argv+1)); if (atoi(*(argv+2))<1024 || atoi(*(argv+2))>65535) { puts("Portos possiveis: 1024 - 65535\n"); exit(-1); } else port=atoi(*(argv+2)); /* cria o socket sock, para internet, orientado para a ligaçao (tipo stream) */ if((sock=socket(AF_INET, SOCK_STREAM, 0))==-1) //start server socket TCP socket { perror("Impossivel criar socket!"); exit(-1); } /* Habilita reutilizaçao do endereço local (n=1 enable option; n=0 disable option) */ n=1; if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *) &n, sizeof(n))==-1) //Socker reutilizavel, mais do que um cliente killsocket (sock, "Impossivel seleccionar opcçoes do socket"); /* Preenche a estrutura server com zeros */ memset(&server, 0, sizeof(server)); /* Define o endereço local server */ server.sin_family=AF_INET; /* Suporta familia de endereços internet */ server.sin_addr.s_addr=htonl(INADDR_ANY); /* Aceita qualquer endereço de ligaçao */ server.sin_port=htons(port); /* Porto > 1023 e < 65535 */ /* Atribui ao socket sock o endereço local server, o qual identifica o servidor */ if (bind(sock, (struct sockaddr *) &server, sizeof(server))==-1) killsocket (sock, "Impossivel atribuir endereço local ao socket"); /* Activa a fila de espera de coneçoes, para o socket sock, e limita-a a 5 coneçoes */ if (listen(sock, 5)==-1) //qeue de 5, nao passa daqui ate que um cliente se conecte killsocket (sock, "Impossivel reservar fila de coneçoes para o socket"); /* Socket criado com sucesso */ /* Processo corrente lança um filho e termina. O pai do filho passa a ser o init. Seguidamente o Daemon fecha os canais de comunicaçao com a consola. Assim cria-se um daemon (em DOS chama-se TSR) */ if (fork()!=0) exit(0); close(stdin); close(stdout); /* Define a rotina para tratamento do fim de um filho */ signal (SIGCHLD, end_child); /* Ignora o sinal SIGHUP, ou seja evita terminar o processo corrente se o terminal que o lançou for fechado ou se o processo que o controla for morto */ signal (SIGHUP, SIG_IGN); /* Ciclo principal Escuta pedidos e trata-os */ for (;;) { if (Numproc <= maxproc) { /* Retira a primeira conecçao da fila de listen. accept cria um novo socket com as mesmas propriedades de sock e retorna um descritor para o novo socket (csock), ou -1 se nao existir nenhuma conecçao na fila de espera. Em client e guardado o endereco do cliente a servir. */ do { csock=accept (sock, (struct sockaddr *)&client, &lc); } while (csock==-1); /* Cria filho para atender o pedido */ if (csock==-1) sleep (1); /* Erro na abertura do sockect para cliente */ else { Numproc++; switch(fork()) { /* Filho atende pedido */ case 0: /* Fecha descritor nao necessario de socket */ close (sock); /* associa um stream com o descriptor para o cliente */ if ((io = fdopen(csock, "r+"))!=NULL) { /* Manipulador */ sendinfo(csock, io); /* descarrega buffers antes de terminar filho */ fflush (io); } /* Termina filho depois de atender o pedido */ exit (0); /* Erro na criaçao do filho */ case -1: Numproc--; close (csock); break; /* Se pai fechar csock pois o filho vai atender o pedido */ default: close(csock); } /* switch */ } /* else */ } /* if */ } /* for (;;) */ } /* main */