Programmazione di rete in C

[teo_smile89]

Salve, avrei una domanda:
ho un'architettura client/server, dove, dopo aver creato una connessione grazie alle socket, ad ogni richiesta di un client, il server (concorrente) restituisce ora e data.
Però la concorrenza del Server non la sfrutto, nel senso che le richieste del client le invio una ad una manualmente, dando il comando da terminale ./Client, che mi esegue il file relativo al client. Così facendo il Server non gestisce effettivamente i processi contemporaneamente.
La mia idea è quella di fare un file che, una volta eseguito, lancia più richieste contemporaneamente, cioè esegue più volte le operazioni di un client.
Come potrei fare?

Grazie in anticipo

[ESSE-EFFE]

La mia idea è quella di fare un file che, una volta eseguito, lancia più richieste contemporaneamente, cioè esegue più volte le operazioni di un client. Come potrei fare?

Potresti lanciare diversi thread paralleli che gestiscano la comunicazione client/server continuamente, magari ad intervalli casuali (o comunque diversi tra loro). Se poi vuoi essere proprio sicuro di avere chiamate contemporanee puoi sincronizzare i diversi thread (ad esempio con un semaforo).

[teo_smile89]

Quindi potrei usare, per esempio, la funzione Fork() avendo un processo padre ed un processo figlio, giusto?
Però mi chiedo, se 2 processi chiedono una connessione, contemporaneamente, al server sulla stessa porta, il Server (che gestisce più richieste simultaneamente) tende ad accettarle entrambe, oppure sicuramente ne accetterà solo una rifiutando l'altra?

Mi scuso se sono domande banali! :(

[ESSE-EFFE]

Quindi potrei usare, per esempio, la funzione Fork() avendo un processo padre ed un processo figlio, giusto?

Io parlavo di thread più che di processi, però per quello che serve a te più o meno è lo stesso (a regime ne userei comunque più di due).

Però mi chiedo, se 2 processi chiedono una connessione, contemporaneamente, al server sulla stessa porta, il Server (che gestisce più richieste simultaneamente) tende ad accettarle entrambe, oppure sicuramente ne accetterà solo una rifiutando l'altra?

Dipende tutto da com'è fatto l'applicativo lato server. Può comportarsi in entrambi i modi che hai descritto (e non solo).

[karch_kiraly]

La fase di connessione lato server sara' gestita da un unico thread. Saranno i socket stessi a sequenzializzarti le richieste di connect. Poi una volta che tu accetti la connessione (con relativo l'handle) puoi creare un altro thread per gestire la comunicazione.

[teo_smile89]

Io ho creato un Server concorrente in cui, dopo aver creato la socket, bind, listen e accept, faccio una fork così il processo padre delega al processo figlio la risposta alla richiesta del client e il processo padre rimane in ascolto di altre richieste.
Ora, nel file del Client, dopo aver creato la socket, ho eseguito una Fork che crea (in teoria) 2 client che chiedono di connettersi sulla stessa porta del Server.
Nessun errore di compilazione, ma quando vado ad eseguire prima il Server (nessun problema) e poi il Client, dei 2 processi (Client) in esecuzione (grazie alla Fork nel file del Client) mi ritornano sì, due risultati, ma non entrambi desiderati: il primo è la data e ora che il client richiede (Ok), il secondo risultato è un errore (Transport endpoint is already connected).
Non riesco a creare un Server capace di gestire più connessioni sulla stessa porta :(
Non so se avete ben capito. Se volete vi posto il codice del Server o di entrambi i file!

[karch_kiraly]

Scusa nel lato server la fork viene fatta dopo la accept?

[teo_smile89]

Sì..ecco qua un pezzo di codice giusto per darti un'idea:

while(1) {
len = sizeof(client);
if ((conn_fd = accept (list_fd, (struct sockaddr *)&client, &len)) < 0 ) {
perror ("accept error");
exit(-1);
}

if ((pid = fork()) < 0 ) {
perror("fork error");
exit(-1);
}

if (pid == 0) {
close (list_fd);
timeval = time(NULL);
snprintf(buffer, sizeof(buffer), "%24s\r\n", ctime(&timeval));
if ((write (conn_fd, buffer, strlen(buffer))) < 0 ) {
perror("write error");
exit(-1);
}
if (logging) {
inet_ntop(AF_INET, &client.sin_addr, buffer, sizeof(buffer));
printf("Request from host %s, port %d\n", buffer, ntohs(client.sin_port));
}
close (conn_fd);
exit(0);
} /* end if(pid==0) */
else {
close(conn_fd);
}
} /*end while */

[karch_kiraly]

E' parecchio che non programmo sotto linux, e mi dovrei andare a rinfrescare sulla fork. In ogni caso non capisco perche' fai una "close(list_fd);" prima di trasmettere sul socket connesso. Non vuoi che il socket in listen ti rimanga aperto per accettare le nuove connessioni?

[teo_smile89]

(conn_fd = accept (list_fd, (struct sockaddr *)&client, &len)
dove "conn_fd" sarà la connessione accettata, cioè conn_fd = list_fd accettata!

if (pid == 0) {
close (list_fd);
....
pid==0 è il processo figlio che chiude la "vecchia connessione" (vecchia perchè la socket è stata creata sulla variabile "list_fd") e svolge i propri compiti su "conn_fd".

else {
close(conn_fd);
se pid è diverso da 0 (cioè è il processo padre), allora chiudi la "conn_fd" e rimane in ascolto sulla connessione "list_fd".

[teo_smile89]

Nessun altro saprebbe aiutarmi?

[karch_kiraly]

scusami ma ho avuto da fare. Oggi se ci riesco do un occhio e ti faccio sapere. In ambiente windows programmo abitualmente oggetti client-server come i tuoi senza alcun problema.