Visualizzazione dei risultati da 1 a 2 su 2
  1. #1

    [c/linux] client/server

    Ragazzi gentilmente potete darmi una visione di questi codici se vi sembrano corretti. Grazie
    Vi posto il testo:
    Titolo: Media di una matrice bidimensionale a valori interi.

    Scopo: Si progetti e si implementi in linguaggio C un’appicazione Client/Server in cui Il Client, dato in input un file contenente una matrice bidimensionale a valori interi, invia le dimensioni ed il contenuto del file, il Server restituisce il valore medio dei dati ricevuti.
    Si implementi un Server concorente (tramite thread o fork) ed un client possa essere interrotto o stoppato solo dopo avere ricevuto la risposta dal server o solo dopo un timeout di 2 minuti.
    codice:
    //lato server
    #include <stdio.h>
    #include <stdlib.h> 
    #include <string.h>
    #include <strings.h>
    #include <sys/types.h>
    #include <netinet/in.h> // struttura per la gestione degli indirizzi internet
    #include <sys/socket.h> // funzione socket(),bind()
    int main(int argc, char *argv[]){
        int sd_server, sd_client; //I socket descriptor
        struct sockaddr_in  server_addr, client_addr;
        int sin_size,ris,ls_result,temp,rig,col,i,j;
        float med,som=0;
        char buff[80]; /* dati di invio e ricezione */
        pid_t pid;
        /*Creazione della socket*/
        sd_server=socket(AF_INET, SOCK_STREAM, 0);
        if (sd_server < 0){
            printf("Server:errore nella creazione della socket.\n");
            exit(EXIT_FAILURE);
        }
        else printf("Socket creata con successo\n");
        /* Effettua la bind sull'indirizzo e porta ora specificati */
        server_addr.sin_family = AF_INET; /* la famiglia dei protocolli */
        server_addr.sin_port = htons(1745); /* la porta in ascolto */
        server_addr.sin_addr.s_addr = INADDR_ANY; /* dato che è un server bisogna associargli l'indirizzo della macchina su cui sta girando */
        /*Assegnazione del processo alla socket tramite la funzione BIND*/
        if(bind(sd_server,(struct sockaddr *)&server_addr,sizeof(struct sockaddr)) < 0){
        printf("Errore di binding\n");
        exit(EXIT_FAILURE);
        }
        /*la socket si mette in ascolto con un massimo di 10 connessioni*/
        ls_result = listen(sd_server, 10);
        if (ls_result < 0){
            printf("Server: errore durante la listen.\n");
            exit(EXIT_FAILURE);
        }
        else printf("La Socket e' in Ascolto\n");
        sin_size = sizeof(client_addr);
        while(1){
            sd_client = accept(sd_server, (struct sockaddr *)&client_addr, &sin_size);
    		if(sd_client < 0) {
            printf("Errore nella chiamata accept\n");
            exit(EXIT_FAILURE);
            }
            pid = fork();
            if(pid == 0) { /* figlio */
                close(sd_server); /* si chiude perché non serve più al figlio */
                strcpy(buff, "Tutto OK!");
                printf("%s\n",buff);
                send(sd_client,buff, 80, 0);
                recv(sd_client, &col, sizeof(int), 0);
                printf("il numero di colonne e' %d\n",col);
                memset(buff, '\0', 80); //funzione che cancella gli ultimi dati del buffer
                strcpy(buff, "Ok colonne!\n");
                send(sd_client, buff, 80, 0);
                recv(sd_client, &rig, sizeof(int), 0);
                printf("il numero di righe e' %d\n",rig);
                memset(buff, '\0', 80);
                strcpy(buff, "Ok righe\n");
                send(sd_client, buff,80, 0);
                for(i=0;i<rig;i++){
                    for(j=0;j<col;j++){
                        recv(sd_client,&ris,sizeof(int), 0);
                        printf("Ricezione dati in corso... ricevo il numero:%d\n",ris);
                        som=som+ris;
                    }
                    memset(buff, '\0', 80);
                    strcpy(buff, "Ok riga ");
                    sprintf(buff,"%s%d",buff,i+1);
                    send(sd_client, buff, 80, 0);
                }
                med=som/(rig*col);
                printf("Spedisco al client la media calcolata:%.2f\n",med);
                send(sd_client, &med, sizeof(float), 0);
                close(sd_client); /* disconnessione */
                exit(0); /* chiude il processo*/
            }
            else if(pid > 0) { /* padre */
                close(sd_client); /* si chiude perché non serve più al padre */
            }
            else {
                printf("Errore nella creazione del figlio\n");
    			exit(-1);
            }
        }
        /* Per terminare l'esecuzione del server è necessario usare i tasti CTRL + C */
        return EXIT_SUCCESS;
    }
    codice:
    //lato client
    #include <stdio.h>
    #include <stdlib.h> 
    #include <string.h>
    #include <strings.h>
    #include <sys/types.h> // system defined identifiers.
    #include <netinet/in.h> // internet address structure.
    #include <sys/socket.h> // Need 4 socket(), bind(), 
    #include <netdb.h>
    #include <signal.h>
    #define true 1
    #define false 0
    void EnableDisableTerm(int enable) //funzione per la gestione di ignoro e default dei segnali 
    {  
      signal (SIGINT,enable?SIG_DFL:SIG_IGN);
      signal (SIGTERM,enable?SIG_DFL:SIG_IGN);
    }
    void alarmhandler() //funzione per la gestione dei segnali dopo il timeout
    {
     EnableDisableTerm(true);
    }
    
    
    int main(int argc, char *argv[]){
        if(argc<4){
            printf("errore nelL'esucuzione del programma. Dati inseriti non sono sono sufficienti\n");
            exit(EXIT_FAILURE);}
        else{
            //gestione dei segnali
            signal(SIGALRM,alarmhandler);
            EnableDisableTerm(false); //disabilitazione dei segnali
            alarm(120);//SIG_DFL dopo un timout di due minuti
            int sd; /* Il socket descriptor del client */
            struct sockaddr_in addr; /* l'indirizzo del server */
            char buff[80]; /* dati di invio e ricezione */
            FILE*fp;
            fp=fopen(argv[3],"r");
            if(fp==NULL){
                printf("errore nell'apertura del file\n");
                exit(EXIT_FAILURE);
                }
            else{
                printf("File %s aperto con successo\n",argv[3]);
             /* Utilizzando la struttura hostent si definisce l'indirizzo del server */
                struct hostent *h;
                h = gethostbyname(argv[1]);
                addr.sin_family = AF_INET;
                addr.sin_port = htons(atoi(argv[2]));
                /* successivamente viene memorizzato nella struttura server_addr */
    	        bcopy(h->h_addr,&addr.sin_addr,h->h_length);
                /* Viene creato il socket descriptor */
                if((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
                    printf("Errore nella creazione della socket\n");
                    close(sd);
                    exit(EXIT_FAILURE);
                }
                /* Connessione al server */
                if(connect(sd, (struct sockaddr *)&addr, sizeof(addr)) < 0){
                    printf("Errore di connessione al server\n");
                    close(sd);
                    exit(EXIT_FAILURE);
                }
                alarm(0); //il timer viene riazzerato dopo la connect
                EnableDisableTerm(true);// dopo la rispota del server si imposta il SIG_DFL
                recv(sd, buff, 80, 0);
                printf("il Server risponde:%s\n",buff);
        /* Acquisizione della matrice letta da file */
                int **mat;
                float med;
                int c,i,j,r;
                printf("Lettura numero di colonne\n");
                fscanf(fp,"%d",&c);
                send(sd, &c,sizeof(int), 0);
                memset(buff, '\0', 80); //funzione che cancella gli ultimi dati del buffer
                recv(sd, buff, 80, 0);
                printf("il Server risponde:%s\n",buff);
                printf("Lettura numero di righe\n");
                fscanf(fp,"%d",&r);
                send(sd, &r,sizeof(int), 0);
                memset(buff, '\0', 80);
                recv(sd, buff, 80, 0);
                printf("il Server risponde:%s\n",buff);
                printf("Creo Matrice\n");
                mat=(int**)malloc(r*sizeof(int*));
                for(i=0;i<r;i++)
                mat[i]=(int*)malloc(c*sizeof(int));
                printf("Caricamento dati in matrice\n");
                for(i=0;i<r;i++)
                for(j=0;j<c;j++)
                fscanf(fp,"%d",&mat[i][j]);
                fclose(fp);
                printf("Matrice acquisita con successo\n");
                /* Si stampano e si inviano i dati della matrice */
                printf("stampo matrice\n");
                for(i=0;i<r;i++){
                    printf("\n");
                    for(j=0;j<c;j++)
                    printf("%d",mat[i][j]);
                }
                printf("\n");
                for(i=0;i<r;i++){
                    for(j=0;j<c;j++){
                        printf("i dati che sto inviando sono:%d\n",mat[i][j]);
                        send(sd,&mat[i][j],sizeof(int), 0);
                    }
                    memset(buff, '\0', 80);
                    recv(sd, buff, 80, 0);
                    printf("il Server risponde:%s\n",buff);
                }
                printf("Attendo il risultato...\n");
                recv(sd, &med, sizeof(float), 0);
                printf("la media della matrice è %.2f\n",med);
                close(sd);
            }
        }
        return 0;
    }

  2. #2
    nessuno ha la bontà di darci un occhiata? il codice dovrebbe essere corretto almeno per me xD appunto per questo vorrei un confronto esterno. Grazie

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.