console bash impazzita

[Crow]

ciao a tutti, ho un problema, devo sostenere un'esame di informatica e sto usando emacs, sto studiando le FIFO, PIPE, e IPC, per adesso sto smanettando solo con le FIFO, il problema è il seguente, stavo facendo delle prove, ho creato un server e un client che comunicano tramite FIFO, ho creato il client che scrive qualcosa sulla FIFO e poi il server legge e stampa sullo standard output, salvo i file compilo ed eseguo, tutto bene fino a qui, noto che il mio output si ripete per due volte, passo mezzagiornata per capire ma non ho trovato una spiegazione sembrava tutto ok a livello di codice, alla fine decido di contattare un mio amico e di fargli controllare il codice del client e del server, lui sulla sua ubuntu compila ed esegue e tutto va a meraviglia sullo standard output ha una sola stampa, allora io decido di riavviare il sistema visto che era da molto che compilavo ed eseguivo, ho pensato che forse qualchosa in memoria potesse creare problemi, dopo il riavvio compilo ed eseguo di nuovo e sempre il solito problema, decido di salvare i file e gli eseguibili su pendrive e riavvio facendo partire ubuntu che ho su un'altra partzione, su ubuntu senza compilare ho provato a eseguire gli eseguibili compilati su slackware e cosa scopro (l'acqua calda) che il problema non c'è, in effetti fa una sola stampa, bene allora cancello gli eseguibili e ricompilo ed rieseguo e come immaginavo mi da una sola stampa, allora decido di riavviare slackware ed eseguo gli eseguibili compilati su ubuntu e noto che comunque mi stampa due volte la stessa cosa, poi ho provato a ricompilare e sempre il solito problema, due volte la stampa della stessa parola.
a questo punto non penso che sia un problema di compilatore, ma penso che sia un problema di terminale che sia fuori di testa, non so da cosa possa dipendere, spero che qualcuno mi possa dare una spiegazione a tutto questo.

grazie a tutti.

p.s. spero di avere postato nella sezione giusta anche se penso l'inverso

[targzeta]

Secondo me, nonostante tutto, è un problema di codice. Almeno penso che sia la soluzione più plausibile. A meno che non ci dici che oltre che con il tuo programma, succede in altri casi.

Magari prova ad allegare il codice, se non è troppo lungo.

Emanuele

[Crow]

ciao spina e grazie mille del tuo aiuto, gentilissimo come sempre, ho provato a compilare ed eseguire su altre 3 macchine e l'output è giusto, solo su slackware mi da problemi, sto installando una debian su vm per curiosità e vedere se anche li mi da problemi anche se non credo sia un problema, comunque il codice l'ho ridotto un pò, fammi una cortesia spina non guardare la sintassi e la logica di questi codici perchè sono solo prove e basta .

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);
}


è un client che invia al server la parola ciao

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);
}



questo è il server che legge dalla fifo quello che i vari client scrivono, in questo caso ciao . 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.

con slackware il risultato è questo

rogrammi/FIFO$ ./serverfifo
Ciao
Ciao
e si mette in attesa che un'altro client scriva.

con ubuntu e backtrack
/prova$ ./serverfifo
Ciao
e si mette in attesa che un'altro client scriva

questo è tutto grazie.

[targzeta]

Per tutti e due i file c'è un inclusione che a me da errori.
client -> #include "ourhdr.h"
server -> #include <ourhdr.h>

Se, per entrambi i file, le include sono esclusivamente queste:

Codice: Seleziona tutto

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

sulla mia Slackware funziona bene.

Emanuele

[Crow]

grazie spina, allora per l'ourhdr.h e un headers fatto da me, usato da molto tempo e su altre distro e macchine e non ho avuto mai problemi, comunque ho fatto anche la controprova, ho tolto quel headers e ho incluso quelli che hai messo anche tu e niente non ho risolto, poi ho fatto questa modifica, nel server ho aggiunto dopo l'ultima printf "printf("%s\n",s);" un sleep di di 5, la differenza è stata che adesso mi stampa solo una volta il ciao e sinceramente ero abbastanza soddisfatto anche se usare quello sleep non ha senso, comunque poi ho avviato più volte il client e ho notato che non sempre mi stampa ciao, su 16 volte che ho eseguito il client, il server ha letto e scritto sullo stdout solo 5 volte ciao .

bho se qualcuno ha avuto la mia stessa esperienza si faccioa avanti che qui inizio a sklerare.

[targzeta]

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

[Crow]

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

grazie per il tuo aiuto, avevo chiesto di non fare commenti visto che il codice che avevo scritto era stupido per cui avevo un pò di vergogna, il mio problema era che su alcune macchine mi stampava una volta e su altre due volte, in questo caso su slack ,ma i suggerimenti sono più che accettati in questo momento .

allora per il ciclo mi occorre perchè non è solo un client a scrivere, ma i client sono un tot., il while è stato implementato con l'idea di costruire successivamente una funzione che dopo un tot. di tempo, all'arrivo di una segnale tipo SIGALRM con la funzione alarm(), e la collaborazione di signal(), il done verrebbe settato a 0 e così uscire dal while, per cui l'idea è questa, il server attende per tot tempo che alcuni client non si sa quanti facciamo un'offerta su un prodotto(implementazione in fase di costruzione), e vince chi offrè di più, poi il server deve elaborare chi ha offerto il massimo ed inviare ai vari client se l'offerta era vincente o perdente, sono partito costruendo passo passo queste parti.

qui, "Tu devi seguire un algoritmo di questo tipo:"
allora alla fine le FIFO sono come le pipe solo che possono essere implementate anche tra processi non imparentati, allora le fifo sono di tipo bloccante una open in lettura e bloccata finchè non c'è una open in scrittura e viceversa, per cui se io non utilizzassi quel ciclo while per la open e la read nel server, non penso che più client potessero scrivere ogni volta, poi le offerte dei vari client vanno memorizzate almeno la prima per poter confrontare di volta in volta l'offerta del client successivo, per cui per la mia realizzazione penso che quel ciclo sia abbastanza utile, poi accetto altre soluzione,.


* Il server crea la fifo e la apre in lettura VIENE CREATA LA FIFO E POI APERTA IN LETTURA FIN QUI PENSO CHE CI SIAMO O SBAGLIO?
* il client apre la fifo in scrittura OK, APRENDO IN SCRITTURA VIENE CHIUSA IN LETTURA DAL LATO SERVER, IL CLIENT SCRIVE "CIAO" E CHIUDE LA FIFO, IL SERVER IN ATTESA APRE IN LETTURA E LEGGE
* 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 QUI IL DISCORSO PENSO CHE NON SIA COMPLICATO, O SCRIVE SOLO CIAO O FA ALTRE COSE È DA IMPLEMENTARE IN BASE ALL'ESERCIZIO
* il server legge la stessa quantità di dati e la usa i qualche modo DIPENDE DALL'ESERCIZIO IN QUESTO CASO TUTTI STAMPANO CIAO
* quando la comunicazione è finita, il client chiude la pipe e il server legge -1. DOPO LA WRITE HO LA CLOSE DI FDS.

alla fine non riesco a rendermi conto se sbaglio o no, se potresti farmi un esempio da farmi capire, ho letto la teoria e penso che qualcosa l'ho capita e sembra che il discorso fili.

[targzeta]

Il programma non funziona perché non rispetti il protocollo. Ti devi assicurare che:

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

Se ti stampa due volte è perché avviene questo:

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

ovviamente questo non succede sempre, quindi delle volte viene stampata due volte "Ciao", delle volte solo una. Per convincertene prova questi:
server

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);
}

client

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);
}

Come vedi obbligo il client a chiudere la pipe dopo che il server l'ha riaperta. Eccoti un output:

Codice: Seleziona tutto

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

La seconda volta legge 0 perché il client chiude la connessione, ma nel buffer il server ha sempre scritto "Ciao".

Il fatto, invece, che eseguendo per 16 volte il client, c'erano solo 5 stampe te l'ho già spiegato prima nel precedente post.

Emanuele

[Crow]

ciao spina e grazie per la tanta pazienza che hai con me, ho fatto un copia e incolla dei tuoi codici,è e poi ho controllato anche riga per riga, ho compilato e mandato in esecuzione prima il server e poi il client e vedi cosa mi esce
lato server

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


quel qradrato che vedi sarebbe un C^ e non ho capito pechè esce,

tu adesso ti aspetti che io abbia mandato in esecuzione 12 volte il client, hehehehhe invece no

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$

solo 6 volte heheheheh punto e a capo, apparte la mia logica sbagliata, ma il punto è sempre quello, il fatto che su slackware e su vm debian questo è il risultato.
ti allego anche un'immagine
qui

riavvio e provo con gli stessi sorgenti e gli stessi eseguibili su ubuntu 9.04.

edit: eccovi da ubuntu 9.04
qui

poi con gli stessi sorgenti ricompilo su ubuntu
qui

bho non capisco.

[Crow]

edit2: di nuovo sotto slackware, ho mandato in esecuzione gli eseguibili che ho compilato sotto ubuntu

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$


ho ricompilato e uguale

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$


[targzeta]

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

[Crow]

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

ok penso che dopo qualche test e un pò di teoria ho capito quello che succede, per i numeretti che citi ho capito cosa fanno, in effetti ho risolto così il mio problema o mettere una sleep(1) nel server dopo la close(fds) oppure aprire la FIFO in lettura scrittura invece di sola lettura, e in questo modo il codice funge alla grande, ma la logica come dice spina è comunque sbagliata, infatti il mio errore penso che sia nell'apertura della FIFO nel server che la faccio gestire al while ogni volta per ogni client, invece adesso sto provando a far gestire solo la read all'interno del while.
spero che adesso sono sulla strada giusta.
un ringraziamento a spina e tutto il forum.

[targzeta]

Finalmente vai sulla strada giuista

• 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)

Emanuele

P.S. Non usare le sleep!!!