Moderatore: Staff
.Codice: Seleziona tutto
#include "ourhdr.h"
#include <sys/types.h>
#include <sys/stat.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));
close(fds);
exit(0);
}
Codice: Seleziona tutto
#include <ourhdr.h>
#include <sys/types.h>
#include <sys/stat.h>
int main(){
int fds;
char s[5];
int done=1;
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((read(fds, s, sizeof(s)))<0){
printf("Impossibile leggere\n");
exit(0);}
printf("%s\n",s);
close(fds);}
sleep(6);
remove("FIFO");
exit(0);
}
. rimane sempre nel while perchè devo inserire nel codice una funzione allarm che dopo tot secondi imposta done a 0 e esce dal while, per cui ripeto questo codice è solo una prova. Codice: Seleziona tutto
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> .
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:Se il client manda solo ciao, allora è inutile scrivere un ciclo nel server. Il ciclo dev'essere nella read() e non infinito.
- 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 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
,ma i suggerimenti sono più che accettati in questo momento . Codice: Seleziona tutto
#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);
}Codice: Seleziona tutto
#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);
}Codice: Seleziona tutto
server
1 5 - Ciao
2 0 - Ciao
3 5 - Ciao
4 0 - Ciao
...Codice: Seleziona tutto
bash-3.1$ ./provas
1 5 - Ciao
2 0 - Ciao
3 5 - Ciao
4 0 - Ciao
5 5 - Ciao
6 0 - Ciao
7 5 - Ciao
8 0 - Ciao
9 5 - Ciao
10 0 - Ciao
11 5 - Ciao
12 0 - Ciao
Codice: Seleziona tutto
bash-3.1$ ./clientfifo
bash-3.1$ ./clientfifo
bash-3.1$ ./clientfifo
bash-3.1$ ./clientfifo
bash-3.1$ ./clientfifo
bash-3.1$ ./clientfifo
bash-3.1$ Codice: Seleziona tutto
rsair$ ./provas
1 5 - Ciao
2 0 - Ciao
3 5 - Ciao
4 0 - Ciao
5 5 - Ciao
6 0 - Ciao
Codice: Seleziona tutto
r$ ./clientfifo
skynet@slack:/media/corsair$ ./clientfifo
skynet@slack:/media/corsair$ ./clientfifo
skynet@slack:/media/corsair$
Codice: Seleziona tutto
rsair$ gcc provas.c -o provas
skynet@slack:/media/corsair$ ./provas
Impossibile creare la fifo
skynet@slack:/media/corsair$ rm -r FIFO
skynet@slack:/media/corsair$ ./provas
1 5 - Ciao
2 0 - Ciao
3 5 - Ciao
4 0 - Ciao
Codice: Seleziona tutto
dia/corsair$ gcc clientfifo.c -o clientfifo
skynet@slack:/media/corsair$ ./clientfifo
skynet@slack:/media/corsair$ ./clientfifo
skynet@slack:/media/corsair$
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
