Example #1
0
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);
    
    
    
}	
Example #2
0
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);
	 
}
Example #3
0
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;
}
Example #5
0
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),&parameters);

                //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),&parameters);

                //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);
                }
            }
        }
    }
}
Example #6
0
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),&parameters_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);*/
                }
            }
        }
    }
}
Example #7
0
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),&parameters_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);*/
                }
            }
        }
    }
}
Example #8
0
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),&parameters_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;
		}
    }
}
Example #9
0
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);
		}
	}
}