Newsgroup: it.comp.lang.c
Titolo: fork e socket

salve (questa è la prima volta che posto...),
il problema che ho è questo:
main ()
{
	...
	sock = connect(...);
	if (fork())
	{
		/* codice processo padre */
	}
	else
	{
		/* codice processo figlio */
	}
}
in pratica il prog prima si connette, poi forka, e a questo punto,
entrambi i processi (padre e figlio) possono usare il socket sock? al
server cosa succede?
non ho fatto prove per vedere cosa succede, e comunque sono curioso
anche del caso in cui è un server (un prog che crea un socket e si mette
in ascolto) a forkare.
a quanto so nel caso di filehandlers di file, entrambi i processi hanno
gli stessi diritti, e mi aspetto che lo stesso valga nel caso dei
socket, ma in questo caso il processo server come fa a gestire i dati
che gli arrivano? se i client non si sincronizzano in qualche modo
rischiano di incasinarsi le comunicazioni a vicenda...
grazie, ciao, Simone

Per quello che ne so io la fork genera un parent, che resterà in ascolto di
altre connessioni di altri client, ed un child, che è "il processo server"
che si "sincronizza al client".
In definitiva ogni volta che un client si connette al server il server
stesso effettua una fork ed il parent rimane in attesa di ... effettuare
altre fork.
Se vuoi ne possiamo continuare a parlare, ora devo staccare.....

 Se vuoi ne possiamo continuare a parlare, ora devo staccare.....
volentieri: chiarisco meglio il problema che ho. la situazione e`
questa:
DBM <--> mio_prog <--> clients
in pratica il mio_prog è un server che attende richieste dai client, che
per risolvere necessita di fare delle query a un dbm (postgres per la
precisione). mio_prog attualmente è sequenziale, nel senso che:
1. parte e apre la connessione con postgres (che significa connettersi a
un certo socket da qualche parte, che sia INET o UNIX, e STREAM o UDP
non so e comunque non mi interessa).
2. attende una richiesta da un client
3. la risolve (eventualmente interagisce con postgres) e alla fine
genera una risposta.
ora, volendo far si' che mio_prog possa assolvere più di una richiesta
alla volta (tralasciando considerazioni di consistenza sul db e
sincronizzazioni varie), pensavo a una cosa del tipo:
1. mio_prog parte e apre le connessioni con postgres
2. riceve una richiesta, quindi forka come hai detto tu, il child esegue
la query, il parent rimane in attesa
...
ecco, il problema è: la connessione con postgres in che stato è?
entrambi i processi (parent e child) sono connessi in maniera
consistente col dbm? questa condizione di consistenza dipende da come
sono fatti i socket (e da come interagiscono con fork) e/o anche da come
è fatto il dbm?
più o meno le cose stanno così.
ho cercato di essere il più stringato possibile, essenzialmente per non
coinvolgere in una discossione troppo particolareggiata e quindi di
scarso interesse per tutti, comunque posso chiarire qua e là se
necessario.
grazie ancora, Simone

sebmarg wrote:
Se ti interessa ho fatto qualcosa del genere su un dns;
Ascolta e quando arriva una richiesta aggiunge i file di zona eccecc. con i
dati ricevuti.
per quello che puo' valere fa proprio (in fase di connessione) quello che
vuoi tu.
Se voui ti mando il sorgente. (anche se non e' proprio di programmazione...)
Vi][oZ
-- 
          We are the true believers
       It's our turn to show the world
 In the fire of heavy metal we were burned
         It's more than our religion
          It's the only way to live
           But the enemies of metal
              We can't forgive

server cosa succede?
esatto... padre e figlio sono eseguiti ovviamente in parallelo quindi
possono usare le risorse...
in pratica pero' solitamente si fa cosi':
il socket preso con la connect lo si lascia al figlio, il padre fa un
close(sock), mentre il figlio chiude il socket "prototipo" quello che
passi alla Connect... in questo modo eviti di fare confusione poi e ti
cauteli...
Il padre fatta la close(sock) si mette in attesa di un'altra
connessione, questo perche' prima del connect avrai messo un while(1)
o for(; ; ;) etc

è fatto il dbm?
direi che essendo il figlio e il padre con o stesso record, a parte il
PID diverso, entrambi hanno aperta la connessione con postgres...
questo non dipende da come sono fatti i socket...
L'unica possibilita' per evitare interferenze tra padre e figlio con
la connessione sul database e' di aprirla dopo il connect, e chiuderla
nel processo padre... in questo modo il padre appena forka lascia al
figlio la connessione e per lui la chiude, si rimette in attesa di un
altro connect (che e' bloccante) non appena riceve una nuova
connessione apre il collegamento con postgres, forka etc...