slacky.eu

• Il server crea la fifo e la apre in lettura
• il client apre la fifo in scrittura
• il client scrive una quantità di dati prefissata in partenza, oppure un messaggio con un intestazione di dimensione fissa in cui il server trova quanto è grande il payload
• il server legge la stessa quantità di dati e la usa i qualche modo
• quando la comunicazione è finita, il client chiude la pipe e il server legge -1.

spina ha scritto:Perché non provi ad utilizzare le fifo in maniera classica, invece di fare questi programmi? Tu mi hai chiesto di non fare commenti ed io non li ho fatti, però se lavori "male" può anche darsi che qualcosa non funzioni.

La teoria vuole che tu la fifo la apri una volta, in lettura da un lato e in scrittura da un altro lato. La connessione rimane in piedi sono a che uno dei due lati non chiude la fifo. Ora, tu nel tuo codice fai aprire sempre la fifo al server ogni volta che ricomincia il ciclo. Ma se il client chiude la fifo prima che il server abbia letto, allora non legge niente, ed ecco perché legge 5 volte su 16.

Tu devi seguire un algoritmo di questo tipo:

• Il server crea la fifo e la apre in lettura
• il client apre la fifo in scrittura
• il client scrive una quantità di dati prefissata in partenza, oppure un messaggio con un intestazione di dimensione fissa in cui il server trova quanto è grande il payload
• il server legge la stessa quantità di dati e la usa i qualche modo
• quando la comunicazione è finita, il client chiude la pipe e il server legge -1.

Se il client manda solo ciao, allora è inutile scrivere un ciclo nel server. Il ciclo dev'essere nella read() e non infinito.

Se vuoi fare un protocollo client-server in cui un server rimane in attesa di connessioni e poi tutti i client si collegano, mandano il "ciao" e poi si scollegano, allora vanno considerate altre questioni. Intanto devi assicurarti che il server abbia letto il messaggio prima di chiudere la fifo, o altrimenti non leggerà niente. Poi devi anche considerare il caso in cui più client si collegano contemporaneamente al server aprendo contemporaneamente la pipe in scrittura.

Lo so che vuoi fare un esempietto stupido per capire come usare le SC, però se l'esempietto non segue il metodo ortodosso con cui usare le fifo è normale che ci saranno problemi.

Emanuele

• il server abbia letto
• il client chiuda la connessione
• il server riapre la pipe

• il server legge
• il servere chiude e riapre la pipe
• il client chiude la pipe

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(){
  int fds;
  char s[5];
  int done=1, i = 1, letti;

  if((mkfifo("FIFO", S_IRWXU|S_IRGRP|S_IROTH))<0){
    printf("Impossibile creare la fifo\n");
    exit(0);}

  while(done){
  if((fds=open("FIFO", O_RDONLY))<0){
    printf("Impossibile aprile la fifo in lettura\n");
    exit(0);}


  if((letti = read(fds, s, sizeof(s)))<0){
    printf("Impossibile leggere\n");
    exit(0);}
  printf("%d %d - %s\n",i,letti,s);
  close(fds);
  i++;
  }

  sleep(6);
  remove("FIFO");
  exit(0);
}

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(){
  int fds;
  char buf[5];

  if((fds=open("FIFO", O_WRONLY))<0){
    printf("La fifo non può essere aperta in scrittura\n");
    exit(0);}

  write(fds, "Ciao", sizeof(buf));
  sleep(1);
  close(fds);
  exit(0);
}

server
1 5 - Ciao
2 0 - Ciao
3 5 - Ciao
4 0 - Ciao
...

spina ha scritto:Sì, però così la cosa diventa lunga. Io non mi aspettavo affatto che tu avessi eseguito 12 volte il client, ma proprio 6. Rileggiti il mio post precedente con più attenzione, perché ti ho già spiegato come mai accade. Ma quei numeretti prima del "Ciao" hai capito cosa sono? Il primo è un contatore che conta le printf del server, il secondo è il numero di byte letti. Hai notato che il server ogni due volte legge 0 byte? La risposta è nel mio post precedente.

Leggitelo meglio,
Emanuele

• apri la pipe in lettura-scrittura
• fai il loop sulla read
• allo scadere del timer chiudi la pipe (così ti assicuri di uscire dal loop)