int Recebe_Pacote(int conexao,char nome_arq[],int tipo){ //ls ou arq
FILE *in;
Quadro *q,*p;
int i,cont=-1,k=-1,pacotes_rec=0,fim=FALSE,reenvio=FALSE,q_pacotes,j;
char buffer[TAM_QUADRO];
if(tipo==LS) in=fopen(nome_arq,"w");
else in=fopen(nome_arq,"wb");
q=novo_quadro();
Seta_Quadro(q,0x00);
p=novo_quadro();
Seta_Quadro(p,0x00);
//recebe atributos do arquivo
Seta_Quadro(q,0x00);
//Recebe_Msg(conexao,q);
recv(conexao,buffer,TAM_QUADRO,0);
buffer2quadro(buffer,q);
printf("ATIBUTOS\n\t q->tipo == %d q->dados ==%s q->marca==%d\n",q->tipo,q->dados,q->marca);
q_pacotes=atoi(q->dados);
printf("total de pacotes a receber %d\n",q_pacotes);
for(k=0;k<=q_pacotes+1;k++){
printf("recebendo pacote %d \n",k);
Recebe_Msg(conexao,p);
if(p->tipo==FIM){
printf("recebeu ultimo pacote\n");
fim=TRUE;
break;
}
else{
if(retorna_crc(q)==TRUE){
printf(" escrevendo em %s : [%s]\n",nome_arq,p->dados);
fprintf(in,"%s",p->dados);
printf("enviando ack de %d\n",k);
Seta_Quadro(q,ACK);
quadro2buffer(q,buffer);
Enviar(conexao,buffer);
}
else{
Seta_Quadro(q,NACK);
quadro2buffer(q,buffer);
Enviar(conexao,buffer);
}
}
Seta_Quadro(p,0x00);
}
if(fim==TRUE) printf("ACABOU pq recebeu ultimo pacote!!!\n");
else printf("ACABOU pq recebeu todos os pacotes esperados!!!\n");
free(q);
free(p);
fclose(in);
}
int Conecta_SERVIDOR(int conexao){
Quadro *q;
char buffer[TAM_QUADRO];
q=novo_quadro();
Seta_Quadro(q,ACK);
quadro2buffer(q,buffer);
printf("enviando ACK");
Enviar(conexao,buffer);
printf("ack de conecta foi\n");
Zera_Buffer(buffer);
printf("recebendo resposta do cliente ...\n");
recv(conexao,buffer,TAM_QUADRO,0);
printf(" ACK ? %d\n",q->tipo);
buffer2quadro(buffer,q);
if(q->tipo==ACK){
printf("\t\tCONEXAO OK\n");
}
else{
printf("erro no pacote conecta\n");
return;
}
free(q);
}
int main(void) {
leerArchivoConfiguracion("configPlanificador");
crearArchivoLog();
listenningSocket = Escuchar(PUERTO_ESCUCHA);
socketCPU = Aceptar(listenningSocket);
Enviar(socketCPU, "BIENVENIDO A PLANIFICADOR");
consola();
Desconectar(listenningSocket);
Desconectar(socketCPU);
return EXIT_SUCCESS;
}
int main(void) {
leerArchivoConfiguracion("configSwap");
crearArchivoLog();
int listenningSocket = Escuchar(PUERTO_ESCUCHA);
int socketMemoria = Aceptar(listenningSocket);
Enviar(socketMemoria, "BIENVENIDO A SWAPILANDIA");
char* comando;
char* parametro;
comando = Recibir(socketMemoria);
parametro = Recibir(socketMemoria);
printf("Recibi el siguiente comando %s %s\n", comando, parametro);
Desconectar(listenningSocket);
Desconectar(socketMemoria);
return EXIT_SUCCESS;
}
int main (int argc,char* argv[])
{
TPDU parameters;
int stcp,sudp;
char data[BUFLEN];
struct hostent *hp;
int fd;
int protocol;
sigset_t mask;
int ret;
int efiport;
int addrlen;
struct sockaddr_in myaddr_in;
int fp;
char titulo[50]="";
//Comprobracion de parametros de entrada
if(argc != 4)
{
fprintf(stderr,"\nError! How to use it: %s [hostname] [protocol TCP|UDP] [ordenes.txt|ordenes1.txt|ordenes2.txt]\n",argv[0]);
}
else
{
if(strcmp(argv[2],"UDP") != 0 && strcmp(argv[2],"TCP") != 0)
{
fprintf(stderr,"\nError! The protocol has to be TCP or UDP\n");
}
if(strcmp(argv[3],"ordenes.txt") != 0 && strcmp(argv[3],"ordenes1.txt") != 0 && strcmp(argv[3],"ordenes2.txt") != 0 )
{
fprintf(stderr,"\nError! The archive has to be ordenes.txt or ordenes1.txt or ordenes2.txt \n");
}
}
//Comprobamos que protocolo es
if(strcmp(argv[2],"UDP") == 0)
{
protocol = IPPROTO_UDP;
}
else
{
protocol = IPPROTO_TCP;
}
memset ((char *)&myaddr_in, 0, sizeof(struct sockaddr_in));
//Obtenemos los datos del host
hp = gethostbyname (argv[1]);
if (hp == NULL)
{
fprintf(stderr, "%s not found in /etc/hosts\n",argv[1]);
return 1;
}
//Rellenamos los parametros de configuracion
if(protocol == IPPROTO_UDP)
{
parameters.protocol = IPPROTO_UDP;
}
else
{
parameters.protocol = IPPROTO_TCP;
}
parameters.port = htons(PORT);
parameters.server = *((struct in_addr *)(hp->h_addr));
//creamos el socket dependiendo del protocolo
if(protocol == IPPROTO_UDP)
{
//creamos el socket UDP
sudp = crearSocket(parameters,CLIENT);
if(sudp == -1)
{
return 1;
}
//aqui obtenemos la informacion del socket, buscamos el puerto efimero
addrlen = sizeof(struct sockaddr_in);
if(getsockname(sudp, (struct sockaddr *)&myaddr_in, &addrlen) == -1)
{
fprintf(stderr, "%s: unable to read socket address\n", argv[0]);
exit(1);
}
efiport = myaddr_in.sin_port;
}
else
{
//creamos el socket TCP
stcp = crearSocket(parameters,CLIENT);
if(stcp == -1)
{
return 1;
}
//aqui obtenemos la informacion del socket, buscamos el puerto efimero
addrlen = sizeof(struct sockaddr_in);
if(getsockname(stcp, (struct sockaddr *)&myaddr_in, &addrlen) == -1)
{
fprintf(stderr, "%s: unable to read socket address\n", argv[0]);
exit(1);
}
efiport = myaddr_in.sin_port;
}
//abrimos el fichero que hemos pasado por parametros para lectura
fd = fopen(argv[3],"r");
if(fd==NULL)
{
fprintf(stderr,"\nCan't open text file\n");
return 1;
}
//nombramos al fichero con el nombre del puerto efimero
sprintf(titulo,"%d.txt",efiport);
//abrimos el fichero para el log
fp = fopen(titulo, "a");
if(fp==NULL)
{
fprintf(stderr,"\nCan't open log file\n");
return 1;
}
//recorrer el fichero e ir enviado y recibiendo los datos contenidos en el
while(1)
{
//obtenemos una frase del fichero
fgets(data,BUFLEN,fd);
//protocolo UDP
if(protocol == IPPROTO_UDP)
{
//enviamos la frase al servidor
ret =Enviar(sudp,data,sizeof(data),parameters);
//comprobamos si hay problemas en el envio
if(ret < 0)
{
writeAnswers(fp,"UDP",hp->h_name,ntohs(parameters.port),ntohs(efiport),inet_ntoa(parameters.server),1,0,data);
}
else
{
//comprobamos si enviamos la palabra FIN para finalizar el cliente
if(strcmp(data,"FIN\n") == 0 || strcmp(data,"FIN") == 0)
{
close(sudp);
close(fd);
close(fp);
return 0;
}
writeAnswers(fp,"UDP",hp->h_name,ntohs(parameters.port),ntohs(efiport),inet_ntoa(parameters.server),0,0,data);
//recibimos los datos
ret =Recibir(sudp,&data,sizeof(data),¶meters);
//comprobamos si se ha producido algun error en el envio
if(ret < 0)
{
writeAnswers(fp,"UDP",hp->h_name,ntohs(parameters.port),ntohs(efiport),inet_ntoa(parameters.server),1,1,data);
}
else
{
writeAnswers(fp,"UDP",hp->h_name,ntohs(parameters.port),ntohs(efiport),inet_ntoa(parameters.server),0,1,data);
}
}
}
//protocolo TCP
if(protocol == IPPROTO_TCP)
{
//enviamos los datos
ret =Enviar(stcp,data,sizeof(data),parameters);
//comprobamos si se ha producido algun error en el envio
if(ret < 0)
{
writeAnswers(fp,"TCP",hp->h_name,ntohs(parameters.port),ntohs(efiport),inet_ntoa(parameters.server),1,0,data);
}
else
{
//comprobamos si enviamos FIN para finalizar el cliente
if(strcmp(data,"FIN\n") == 0 || strcmp(data,"FIN") == 0)
{
close(sudp);
close(fd);//fichero del cual obtenemos los datos
close(fp);//fichero del log
return 0;
}
writeAnswers(fp,"TCP",hp->h_name,ntohs(parameters.port),ntohs(efiport),inet_ntoa(parameters.server),0,0,data);
//recibimos los datos
ret =Recibir(stcp,&data,sizeof(data),¶meters);
//comprobamos si se ha producido algun error en la recepcion
if(ret < 0)
{
writeAnswers(fp,"TCP",hp->h_name,ntohs(parameters.port),ntohs(efiport),inet_ntoa(parameters.server),1,1,data);
}
else
{
writeAnswers(fp,"TCP",hp->h_name,ntohs(parameters.port),ntohs(efiport),inet_ntoa(parameters.server),0,1,data);
}
}
}
}
}
int imudp(int s)
{
char datos[BUFLEN];
char datosmorse[BUFLEN];
int ret;
int translatedUDP = 1;
int sentUDP = 1;
//indicamos que se ha producido una nueva conexion (las variables a -1 controlan eso)
writeLog("UDP",parameters_udp,-1,-1);
//bucle que se ocupa de la recepcion y envio de datos
while(1)
{
//recibimos los datos
ret=Recibir(s,&datos,sizeof(datos),¶meters_udp);
//comprobamos que no se haya producido ningun error en la recepcion
if(ret < 0)
{
fprintf(stderr,"Error receiving data\n");
fflush(stdout);
}
else
{
//si nos llega la palabra FIN, finalizamos la conexion
if(strcmp(datos,"FIN\n") == 0 || strcmp(datos,"FIN") == 0)
{
writeLog("UDP",parameters_udp,sentUDP, translatedUDP);
close(s);
exit(0);
}
else
{ //la ip esta en parameters_udp.server y viene de la funciona recibir
/*printf("\n[Server UDP from %s:%d] I've receive: %s\n",inet_ntoa(parameters_udp.server),ntohs(parameters_udp.port),datos);
fflush(stdout);*/
//traducimos a morse
translate_morse(datos,datosmorse);
translatedUDP++;
//enviamos los datos traducidos
ret=Enviar(s,datosmorse,sizeof(datosmorse),parameters_udp);
//comprobamos que no se ha producido ningun error en el envio
if(ret < 0)
{
fprintf(stderr,"\nError sending data\n");
fflush(stdout);
}
else
{
sentUDP++;
/*printf("\n[Server UDP to %s:%d] I've send: %s\n",inet_ntoa(parameters_udp.server),ntohs(parameters_udp.port),datosmorse);
fflush(stdout);*/
}
}
}
}
}
int imtcp(int s)
{
char datos[BUFLEN];
char datosmorse[BUFLEN];
int ret;
int translatedTCP = -1;
int sentTCP = -1;
//creamos una estructura tpdu nueva para escribir en el log con los datos del cliente en TCP
parameterstcp_log.server = peeraddr_in.sin_addr;
parameterstcp_log.port = parameters_tcp.port;
//escribimos en el log que se ha producido una nueva conexion(las variables a -1 controlan eso)
writeLog("TCP",parameterstcp_log,sentTCP, translatedTCP);
//inicializamos variables
sentTCP = 0;
translatedTCP = 0;
//este sera el bucle de envio y recepcion de informacion
while(1)
{
//recibimos los datos
ret=Recibir(s,&datos,sizeof(datos),¶meters_tcp);
//comprobamos que no haya habido ningun problema con la recepcion
if(ret < 0)
{
fprintf(stderr,"Error receiving data\n");
fflush(stdout);
}
else
{
//si nos llega la palabra fin, finalizamos la conexion
if(strcmp(datos,"FIN\n") == 0 || strcmp(datos,"FIN") == 0)
{
writeLog("TCP",parameterstcp_log,sentTCP, translatedTCP);
close(s);
exit(0);
}
else
{
//la ip esta en peeraddr_in.sin_addr y viene de la funcion accept
/*printf("\n[Server TCP from %s:%d] I've receive: %s\n",inet_ntoa(peeraddr_in.sin_addr),ntohs(parameters_tcp.port),datos);
fflush(stdout);*/
//traducimos a morse
translate_morse(datos,datosmorse);
translatedTCP++;
//enviamos los datos traducidos
ret=Enviar(s,datosmorse,sizeof(datosmorse),parameters_tcp);
//comprobamos que no se hayan producido problemas en el envio
if(ret < 0)
{
fprintf(stderr,"Error sending data\n");
fflush(stdout);
}
else
{
sentTCP++;
/*printf("\n[Server TCP to %s:%d] I've send: %s\n",inet_ntoa(peeraddr_in.sin_addr),ntohs(parameters_tcp.port),datosmorse);
fflush(stdout);*/
}
}
}
}
}
io_handler()
{
fd_set readmask;
char buf[BUFLEN];
int numfds;
struct timeval timeout;
int addrlen;
int stcpnew;
int sudpnew;
char datos[BUFLEN];
char datosmorse[BUFLEN];
int ret;
memset (buf, 0, BUFLEN);
/* Notify operator of SIGIO interrupt */
/* setup the masks */
FD_ZERO(&readmask);
FD_SET(stcp, &readmask);
FD_SET(sudp, &readmask);
/* set the timeout value */
timeout.tv_sec = 0;
timeout.tv_usec = 0;
/* select on socket descriptors */
if ( (numfds=select(getdtablesize(), &readmask, (fd_set *)0,(fd_set *)0, &timeout)) < 0)
{
fprintf(stderr,"\nSelect failed\n");
exit(1);
}
//Se ha seleccionado el socket UDP
if (FD_ISSET(sudp, &readmask))
{
//recibimos los datos
ret=Recibir(sudp,&datos,sizeof(datos),¶meters_udp);
//comprobamos que no se produzca un error en la recepcion
if(ret < 0)
{
fprintf(stderr,"\nError receiving data\n");
fflush(stdout);
}
else
{
//vemos si nos ha llegado fin para terminar
if(strcmp(datos,"FIN\n") == 0 || strcmp(datos,"FIN") == 0)
{
writeLog("UDP",parameters_udp,0,0);
}
else
{
//la ip esta en peeraddr_in.sin_addr y viene de la funcion accept
/*printf("\n[Server UDP from %s:%d] I've receive: %s",inet_ntoa(parameters_udp.server),ntohs(parameters_udp.port),datos);
fflush(stdout);*/
//traducimos a morse
translate_morse(datos,datosmorse);
/*
Creamos el nuevo socket para la nueva peticion (gracias a esto podremos llevar cuenta del numero de peticiones
de cada cliente en particlar, si no lo hicieramos asi, no podriamos llevar esa cuenta. Por tanto estamos
imitando de cierta manera el comportamiento de TCP.
Si no quisiesemos llevar la cuenta no haria falta crear un socket nuevo, con el mismo socket atenderiamos
todas las nuevas peticiones
*/
sudpnew = crearSocket(parameters_udp,CLIENT);
//enviamos por el nuevo socket
ret=Enviar(sudpnew,datosmorse,sizeof(datosmorse),parameters_udp);
//comprobamos que no haya ocurrido ningun error en el envio
if(ret < 0)
{
fprintf(stderr,"Error sending data\n");
fflush(stdout);
}
/*else
{
printf("\n[Server UDP to %s:%d] I've send: %s",inet_ntoa(parameters_udp.server),ntohs(parameters_udp.port),datosmorse);
fflush(stdout);
}*/
}
}
/*
Ahora si creamos un nuevo hijo que se encargara de mantener esa "conversacion" con el cliente.
Antes no hemos podido hacerlo porque hasta que no hemos recibido la informacion no conociamos los datos
del cliente, una vez conocidos, delegamos el trabajo de "conversacion" a un hijo, como en TCP,
*/
switch(fork())
{
case -1:
fprintf(stderr,"\nError fork\n");
break;
case 0:
close(sudp);
imudp(sudpnew);
break;
default:
close(sudpnew);
break;
}
}
//TCP
if (FD_ISSET(stcp, &readmask))
{
addrlen = sizeof(struct sockaddr_in);
/* another program requests connection */
//aqui obtenemos la direccion del cliente con el que conectamos!
stcpnew = accept(stcp, (struct sockaddr *) &peeraddr_in, &addrlen);
if (stcpnew == -1 )
{
fprintf(stderr,"\nAccept call failed\n");
exit(1);
}
/*
Creamos un hijo que se ocupara unica y exclusivamente de la "conversacion" con el cliente
y que morira una vez finalizada dejando constancia de ello en un log
*/
switch(fork())
{
case -1:
fprintf(stderr,"\nError fork\n");
break;
case 0:
close(stcp);
imtcp(stcpnew);
break;
default:
close(stcpnew);
break;
}
}
}
void consola() {
//char eleccion[30];
char* eleccion;
char* comando;
char* parametro;
char c = 0;
int longComando = 0;
int posInicioParametro = 0;
int consola = 1;
while (consola) {
posInicioParametro = 0;
eleccion = string_new();
comando = string_new();
puts(
"____________________________________________________________________\n\n"
"Comandos disponibles: \n"
"- 1) correr PATH \n"
"- 2) finalizar PID \n"
"- 3) ps \n"
"- 4) cpu \n"
"Ingrese un comando: ");
scanf("%c", &c);
//printf("Escanee %c\n",c);
longComando++;
eleccion = (char*) malloc( sizeof(char) * longComando );
string_append(&eleccion, string_repeat(c,1));
while(c != '\n'){
scanf("%c", &c);
//printf("Escanee %c\n",c);
longComando++;
eleccion = (char*) realloc(eleccion, sizeof(char) * longComando );
string_append(&eleccion, string_repeat(c,1));
}
eleccion = (char*) realloc(eleccion, sizeof(char) * (longComando+1) );
eleccion[longComando] = '\0';
int i = 0;
while(eleccion[i] != '\0'){
if(eleccion[i] == ' ') posInicioParametro = i+1;
i++;
}
//printf("El parametro empieza en la posicion %d\n", posInicioParametro);
if(posInicioParametro != 0){
parametro = string_new();
comando = (char*) malloc( sizeof(char) * strlen(string_substring(eleccion, 0, posInicioParametro-1)));
comando = string_substring(eleccion, 0, posInicioParametro-1);
parametro = (char*) malloc( sizeof(char) * strlen(string_substring_from(eleccion, posInicioParametro)));
parametro = string_substring_from(eleccion, posInicioParametro);
}
else{
//printf("strlen %d \n", strlen(eleccion));
eleccion[strlen(eleccion)-1] = '\0';
//printf("strlen %d \n", strlen(eleccion));
comando = (char*) malloc( sizeof(char) * strlen(eleccion) );
comando = string_duplicate(eleccion);
}
if(posInicioParametro == 0){
if(strcmp(eleccion, "ps") == 0){
printf("3Comando a ejecutar: %s\n", comando);
}
else{
if(strcmp(eleccion, "cpu") == 0){
printf("4Comando a ejecutar: %s\n", comando);
}
else{
printf("El comando (%s) ingresado no es valido \n", comando);
eleccion[0] = '\0';
comando[0] = '\0';
}
}
}
if(posInicioParametro != 0){
if(strcmp(comando, "correr") == 0){
printf("1Comando a ejecutar: %s %s\n", comando, parametro);
Enviar(socketCPU, comando);
Enviar(socketCPU, parametro);
}
else{
if(strcmp(comando, "finalizar") == 0){
printf("2Comando a ejecutar: %s %s\n", comando, parametro);
}
else{
printf("El comando (%s %s) ingresado no es valido \n", comando, parametro);
eleccion[0] = '\0';
comando[0] = '\0';
parametro[0] = '\0';
}
}
}
free(eleccion);
free(comando);
if(posInicioParametro != 0){
free(parametro);
}
}
}
