Pagina 1 di 2 1 2 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 17
  1. #1

    [C]Il mio programma viene correttamente compilato ma non funziona!!!

    Salve ragazzi...ho ancora un problema!!!Il programma che ho scritto viene compilato correttamente,ma non funziona...questo il server:
    codice:
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <time.h>
    #include <sys/stat.h>
    #include <sys/types.h>
    #include <fcntl.h>
    #include <unistd.h>
    
    typedef struct{
              char titolo[50];
              char autore[50];
              unsigned short disponibilita;       
              }Testo;
              
    struct richiesta{
               char tit[50];
               char aut[50];
               pid_t pid;
               char msg[50];
               }msg;
               
               int main(void){
                   int fd,fd1;
                   pid_t pid;
                   FILE *fp;
                   Testo libri[10];
                   char opz,PID_FIFO[100];
                   char buffer[50];
                   unsigned short i=0;     
                   time_t start;
                   
                   mkfifo("WK_FIFO",0666); //creo la wk fifo
                   
                   start=time(NULL);
                   while(difftime(time(NULL),start)<100.){
                        fd=open("WK_FIFO",O_RDONLY);
                        if(read(fd,&msg,sizeof(msg))<=0)
                        printf("Errore di lettura da WK_FIFO\n");
                        if(close(fd)<0)
                        printf("Errore chiusura WN_FIFO\n");
                        if(strcmp(msg.msg,"FINE")==0){                    //richiesta del client di chiudere la connessione
                                                      remove("WK_FIFO");
                                                      printf("Fine esecuzione\n");
                                                      exit(0);
                                                      }
                                                      
                   fp=fopen("libri.txt","r");
                   if(fp==NULL){
                                printf("Errore di lettura file!\n");
                                exit(1);
                                }                                   
                    while(!feof(fp)){
                                     fgets(buffer,sizeof(buffer),fp);
                                     buffer[strlen(buffer)-1]='\0';
                                     strcpy(libri[i].titolo,buffer);
                                     
                                     fgets(buffer,sizeof(buffer),fp);
                                     buffer[strlen(buffer)-1]='\0';
                                     strcpy(libri[i].autore,buffer);
                                     
                                     fgets(buffer,sizeof(buffer),fp);
                                     libri[i].disponibilita=(unsigned short)atoi(buffer);
                                     i++;
                                     }                                     
                               
                               sprintf(PID_FIFO,"%d.FIFO",msg.pid);
                                mkfifo(PID_FIFO,0666);
                                fd1=open(PID_FIFO,O_WRONLY);         
                              for(i=0;i<10;i++){
                                                if((strcmp(libri[i].titolo,msg.tit))!=0||(strcmp(libri[i].autore,msg.aut))!=0){
                                                                        write(fd1, libri[i].titolo, strlen(libri[i].titolo));
                                                                         write(fd1, libri[i].autore, strlen(libri[i].autore));
                                                                         write(fd1, &(libri[i].disponibilita), sizeof(libri[i].disponibilita));
                                               
                                                                                                                            }
                                                                        }
                                                if(close(fd1)<0)
                                                printf("Errore chiusura fifo di risposta\n");
                                                remove(PID_FIFO);
                                                               
                                                                                               
                       
                                                         }
                   
                   }
    va in loop una volta avviato!!!
    Questo il client:
    codice:
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <time.h>
    #include <sys/stat.h>
    #include <sys/types.h>
    #include <fcntl.h>
    #include <unistd.h>
    
    typedef struct{
              char titolo[50];
              char autore[50];
              unsigned short disponibilita;       
              }Testo;
              
    struct richiesta{
               char tit[50];
               char aut[50];
               pid_t pid;
               char msg[50];
               }msg;
               
               int main(void){
                   pid_t pid;
                   int fd,fd1,flag=1;
                   FILE *fp;
                   Testo libri[10];
                   char opz,opz1,PID_FIFO[100];
                   char buffer[50];
                   unsigned short disponibilita,i=0;     
                   time_t start;
                   char titolo[50], autore[50];
                    int nread;
    
                   pid=getpid();
                   
                   while(1){
                            while(flag){
                                        printf("Digitare:\nR per ricercare un libro per titolo o autore\nU per uscire\nD per disconnettere\n");
                                        scanf("%c",&opz);
                                        opz=toupper(opz);
                                        if(opz=='R'||opz=='U'||opz=='D')
                                        flag=0;
                                        }
                            if(opz=='U'){
                                         exit(0);
                                         }
                            
                            else if(opz=='D'){
                                 sprintf(msg.msg,"FINE");
                                 fd=open("WK_FIFO",O_WRONLY);
                                 write(fd,&msg,sizeof(msg));
                                 close(fd);
                                 exit(0);
                                 }
                            flag=1;
                            fd=open("WK_FIFO",O_WRONLY);
                            
                            while(flag){
                                        printf("Ricerca Libro:\nDigitare T per ricerca Titolo\nDigitare A per ricerca Autore\n");
                                        scanf("%c",&opz1);
                                        opz1=toupper(opz1);
                                         if(opz1=='T'||opz1=='A')
                                        flag=0;
                                        }
                                        
                                        if(opz1=='T'){
                                                     printf("Digita il Titolo del libro da ricercare:\n");
                                                     scanf("%s",msg.tit);
                                                     msg.pid=pid;
                                                     write(fd,&msg,sizeof(msg));
                                                     if(close(fd)<0)
                                                     printf("Errore nella chiusura della WK_FIFO\n");
                                                     sprintf(PID_FIFO,"%d.FIFO",pid);
                                                     while((fd1=open(PID_FIFO,O_RDONLY))<0)
                                                     ;
                                                     nread = read(fd1, titolo, sizeof(titolo));
                                                             titolo[nread] = '\0';
    
                                                            nread = read(fd1, autore, sizeof(autore));
                                                            autore[nread] = '\0';
    
                                                      read(fd1, &disponibilita, sizeof(disponibilita));
    
                                                     if(close(fd1)<0)
                                                     printf("Errore chiusura FIFO_RISPOSTA\n");
                                                    
                                                     printf("Il risultato della ricerca è:\n");
                                                     printf("Titolo: %s\nAutore: %s\nDisponibilità: %hu\n", titolo, autore, disponibilita);
    
                                                     
                                                     }
                                                      
                                                     else if(opz1=='A'){
                                                     printf("Digita l' Autore del libro da ricercare:\n");
                                                     scanf("%s",msg.aut);
                                                     msg.pid=pid;
                                                     write(fd,&msg,sizeof(msg));
                                                     if(close(fd)<0)
                                                     printf("Errore nella chiusura della WK_FIFO\n");
                                                     sprintf(PID_FIFO,"%d.FIFO",pid);
                                                     while((fd1=open(PID_FIFO,O_RDONLY))<0)
                                                     ;
                                                     nread = read(fd1, titolo, sizeof(titolo));
                                                             titolo[nread] = '\0';
    
                                                            nread = read(fd1, autore, sizeof(autore));
                                                            autore[nread] = '\0';
    
                                                      read(fd1, &disponibilita, sizeof(disponibilita));
                                                      
                                                     if(close(fd1)<0)
                                                     printf("Errore chiusura FIFO_RISPOSTA\n");
                                                    
                                                      printf("Il risultato della ricerca è:\n");
                                                     printf("Titolo: %s\nAutore: %s\nDisponibilità: %hu\n", titolo, autore, disponibilita);
                                                     
                                                     }
                                        
                            }
                   
                   }
    il client si blocca una volta richiesta una ricerca.
    Il programma consiste nel gestire un file con dei libri(titolo,autore e disponibilita)-server-
    il client interroga il server con ricerca titolo o autore,vengono proposti a video tutti quelli che soddisfano la richiesta.La comunicazione è tramite fifo.

    Ringrazio chiunque voglia darmi una mano a risolvere!!!

  2. #2
    Utente di HTML.it
    Registrato dal
    Jul 2008
    Messaggi
    1,326
    Che bislacco stile di indentazione! :)

    Comunque il problema è (almeno) nell'apertura della seconda FIFO sia da parte del client che del server.

    codice:
    sprintf(PID_FIFO,"%d.FIFO",pid);
    while((fd1=open(PID_FIFO,O_RDONLY))<0)
        ;
    se metti una stampa di debug in quel ciclo while ti renderai conto che il client si blocca proprio lì. Quella chiamata a open() fallirà se non hai già un file PID_FIFO nella directory corrente da aprire in lettura, perché non hai specificato in OR la costante O_CREAT, che significa: "prova ad aprire il file in lettura; se non lo trovi, crealo e aprilo in lettura". Chiaramente, nel caso il file fosse appunto creato ex-novo, dovrà anche avere dei permessi impostati, permessi che si specificano con una costante ottale come 3° argomento della funzione open(), quindi riscrivi il tutto con:

    codice:
    sprintf(PID_FIFO, "%d.FIFO", pid);
    if ((fd1 = open(PID_FIFO, O_RDONLY | O_CREAT, 0755)) < 0) {
            fprintf(stderr, "Errore nell'apertura della seconda fifo: %s\n", strerror(errno));
    }
    in questo modo di sicuro il client non si bloccherà. Qualcosa di simile va fatto nel server. Modifica, poi se hai altri problemi se ne discute...

    Comunque quel while era inutile: se la chiamata fallisce una volta, con tutta probabilità fallirà per sempre (ed era appunto il tuo caso), quindi un if basta e avanza.
    every day above ground is a good one

  3. #3
    Scusami l'ignoranza, ma la seconda fifo non è stata creata dal server e poi viene aperta dal client in lettura???
    Non riesco a capire:
    il server crea la prima fifo,la apre in lettura fa i suoi bei calcoli,apre una seconda fifo in scrittura ed invia il responso.
    il client invece scrive sulla prima fifo già creata dal server e legge sulla seconda fifo già creata dal server.
    Il ragionamento è errato?


    PS:GRAZIE DELLA RISPOSTA

  4. #4
    Utente di HTML.it
    Registrato dal
    Jul 2008
    Messaggi
    1,326
    Quindi il tuo obbiettivo con quel while è di mettere il client in attesa che il server apra la FIFO per poi iniziare la comunicazione? Può anche andare*, ma a questo punto è il server a dover aprire la FIFO nel modo che ti ho suggerito, altrimenti anche in quel caso la open fallirà, la fifo non sarà creata, il client rimarrà bloccato nel suo ciclo while e la comunicazione non andrà mai avanti.

    *in realtà come soluzione è un po' sporca perché di fatto costringi il client a fare N chiamate di sistema che falliscono per poi procedere. Potresti fare così: il server apre la nuova fifo, si serve della vecchia (prima di chiuderla) per inviare al client una sorta di ack per comunicargli che l'apertura è avvenuta e solo allora il client si sblocca dalla read sulla vecchia fifo (chiudendola) per poi aprire in lettura la seconda, sicuro che l'apertura andrà a buon fine.
    every day above ground is a good one

  5. #5
    Non riesco a capire perchè il server debba aprire la fifo in scrittura creandola anche se l'ha già creata con mkfifo!!!Nel server ,infatti, prima di scriverci il responso creo prima la fifo di risposta con mkfifo(PID_FIFO,0666)...

  6. #6
    Utente di HTML.it
    Registrato dal
    Jul 2008
    Messaggi
    1,326
    Ma allora scusa se c'è la mkfifo() (che credo di essermi perso prima!) dov'è che si blocca il client? Puoi postare un esempio di esecuzione sia del client che del server?
    every day above ground is a good one

  7. #7
    il server una volta avviato mostra sempre il cursore che lampeggia e solo con ctrl+c ho il possesso del terminale(crea solo la WK_FIFO che mi ritrovo nella directory).
    il client stampa:

    Digitare:
    R per ricercare un libro per titolo o autore
    U per uscire
    D per disconnettere

    se premo o U ritorna al terminale,se premo D si blocca,se premo R stampa:
    Ricerca Libro:
    Digitare T per ricerca Titolo
    Digitare A per ricerca Autore
    Ricerca Libro:
    Digitare T per ricerca Titolo
    Digitare A per ricerca Autore (due volte e non capisco perchè)

    se premo T oppure A si blocca.

    Spero di riuscire a risolvere per capire dove sbaglio.Grazie per l'aiuto e per la professionalità che stai mostrando.

  8. #8
    Utente di HTML.it
    Registrato dal
    Jul 2008
    Messaggi
    1,326
    Il fatto che il server mostri solo il cursore senza altro è normale perché una volta avviato entra in un ciclo della durata di 100 secondi durante il quale non fa altro che servire le richieste, ed eventualmente mostrare messaggi di errore. A proposito: quella questione dei 100 secondi è da rivedere perché nel server ci sono chiamate read() bloccanti, quindi non è detto che l'esecuzione effettiva duri 100 secondi. L'ideale sarebbe creare due processi: il figlio fa il server e il padre sta lì ad aspettare che siano trascorsi 100 secondi: una volta passati, invia un segnale SIGINT al figlio che quindi terminerà, qualsiasi cosa stesse facendo.

    Comunque, ritornando al problema, ora ho compilato ed eseguito il tutto con un file libri.txt di esempio e il client non mi si blocca affatto, anche se poi l'output non è soddisfacente

    Digitare:
    R per ricercare un libro per titolo o autore
    U per uscire
    D per disconnettere
    R
    Ricerca Libro:
    Digitare T per ricerca Titolo
    Digitare A per ricerca Autore
    T
    Digita il Titolo del libro da ricercare:
    divinacommedia
    Il risultato della ricerca è:
    Titolo: libro1autore1
    Autore:
    Disponibilità: 256
    Ricerca Libro:
    Digitare T per ricerca Titolo
    Digitare A per ricerca Autore
    Alcune domande:

    1) la lettura di libri.txt da parte del server avviene con successo o c'è qualche errore?
    2) client e server stanno nella stessa directory?

    Comunque se vuoi eliminare il problema della stampa di

    Digitare T per ricerca Titolo
    Digitare A per ricerca Autore
    Ricerca Libro:
    che nel tuo esempio avviene due volte, ripulisci lo stream di input con

    codice:
    while (getchar() != '\n');
    prima del secondo while(flag), appena dopo l'apertura di WK_FIFO.
    every day above ground is a good one

  9. #9
    1)Non so come testare se la lettura del file è corretta o meno.
    2)server,client e libri.txt sono nella stessa directory.

    Grazie.

  10. #10
    Utente di HTML.it
    Registrato dal
    Jul 2008
    Messaggi
    1,326
    Originariamente inviato da contemax83
    1)Non so come testare se la lettura del file è corretta o meno.
    Innanzitutto data questa condizione

    codice:
    	fp = fopen("libri.txt", "r");
    	if (fp == NULL) {
    	    printf("Errore di lettura file!\n");
    	    exit(1);
    	}
    se il server non riuscisse ad aprire il file in lettura avresti appunto una stampa a video dell'errore. Se non avviene, significa che l'apertura viene effettuata con successo.

    Per le altre verifiche, che dire... potresti stampare nel ciclo di lettura le informazioni che leggi dal file per constatare se avviene o no qualche errore... e comunque, potresti postare il contenuto del file libri.txt che stai usando?
    every day above ground is a good one

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.