mgaforever
09-12-2010, 15:20
salve vi descrivo brevemente cosa dovrebbe fare il mio programma.
Due processi client sono l'interfaccia tra giocatori e il server. Un client, una volta abilitato dal server,
accetta come input una mossa, la trasmette al server, e riceve la risposta dal server. Il server a sua volta quando riceve una mossa, comunica ai due client la posizione del colpo, se mette 4 pedine in fila decreta la vittoria altrimenti abilita il secondo client a spedire una mossa. il mio problema è che non so come prendere i dati da un client elaborarli e passarli all'altro client, vi posto il codice per farvi meglio capire
IL CODICE
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
#include <stdbool.h>
#include <semaphore.h>
#include <time.h>
#include <netinet/in.h>
#include <netdb.h>
#include <signal.h>
#define SIZE 4096
//Dichiarazione delle funzioni utilizzate:
void menu(int); //Funzione contenente le operazioni che il server deve compiere in base alla scelta fatta dai client.
void uscita(int); //Funzione utilizzata per la gestione dei segnali.
void stamp(int **array );
void matrice_gioco();
//Dichiarazione delle variabili globali:
//Struttura contenente tutte le informazioni riguardanti ciascun utente:
struct persona{
char nickname[20]; //Nickname dell'utente.
int flag_connesso; //Flag=1->Utente connesso,flag=0->Utente disconnesso
char data_connessione[30]; //Data di connessione dell'utente.
char ultima_operazione[100]; //Ultima operazione effettuata dall'utente.
int **myArray;//campo di gioco
int partite_vinte;//Numero partite vinte
int flag_partita
} utenti[SIZE];
int dim=0; //Variabile che indica la dimensione della struct "utenti".
int file; //Variabile utilizzata per il file "log.txt".
//Dichiarazione e inizializzazione dei semafori per la sincronizzazione dei client:
pthread_mutex_t semaforo0=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t semaforo1=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t semaforo2=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t semaforo3=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t semaforo4=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t semaforo5=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t semaforo6=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t semaforo7=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t semaforo8=PTHREAD_MUTEX_INITIALIZER;
void *applicazione(int *acc_sock)
{
//Dichiarazione delle variabili locali:
int client;
int n=0,flag_scelta=0,i=0,j=0;
char temp_nick[20],nick[20],flag_connesso_c[1],dim_amici_c[4],dim_richieste_c[4],dim_c[4],dim_messaggi_c[3];
time_t data;
char connesso[100]={' ','s','i',' ','e','`',' ','c','o','n','n','e','s','s','o',' ','i','l',':',' ','\0'};
char a_capo[3]={' ','\n','\0'},temp_c[200];
client=*acc_sock;
//int dim_amici; //Dimensione dell'array:"friends".
//int dim_richieste; //Dimensione dell'array:"richiesta_amicizia".
//int dim_messaggi; //Dimensione dell'array:"messaggi ricevuti".
//Semaforo.
pthread_mutex_lock(&semaforo0);
//Il server riceve il nickname che gli è stato inviato dal client
do{n=read(client,&nick,20);} while(n<0);
//Se la dimensione dell'array "utenti" è uguale a "0" allora il server memorizza il nickname del client collegato nell'array,in caso contrario il server controlla se tale nickname è già presente all'interno dell'array stesso,nel caso questo non fosse presente allora il server provvederà a memorizzarlo nell'array.
if (dim==0)
{
//Il server memorizza nell'array "utenti" il nickname del client connesso.
strcpy(utenti[dim].nickname,nick);
//Il server setta la "flag_connesso" del client che si è connesso ad "1" per indicare che tale client è connesso.
utenti[dim].flag_connesso=1;
//Il server memorizza la data di connessione del client e la memorizza nella variabile "data_connessione" associata al client connesso nell'array "utenti".
time(&data);
strcpy(utenti[dim].data_connessione,ctime(&data));
strcpy(temp_c,nick);
strcat(temp_c,connesso);
strcat(temp_c,utenti[dim].data_connessione);
strcat(temp_c,a_capo);
//Il server scrive all'interno del file "log.txt" la data di connessione del client.
if (write(file,temp_c,strlen(temp_c))!=strlen(temp_c))
{
perror("Write file log");
exit(errno);
}
dim++;
}
else //Il server controlla se il nick è già presente nell'array "utenti" se non lo è lo memorizza al suo interno.
{
flag_scelta=0;
i=0;
while ((flag_scelta==0) && (i<dim))
{
if (strcmp(nick,utenti[i].nickname))
{
flag_scelta=0;
i++;
}
else
{
flag_scelta=1;
j=i;
}
}
strcpy(temp_nick,nick);
if (flag_scelta==0) //flag=0->nickname non presente nell'array "utenti".
{
//Il server memorizza nell'array "utenti" il nickname del client connesso.
strcpy(utenti[dim].nickname,temp_nick);
//Il server setta la "flag_connesso" del client che si è connesso ad "1" per indicare che tale client è connesso.
utenti[dim].flag_connesso=1;
//Il server memorizza la data di connessione del client e la memorizza nella variabile "data_connessione" associata al client connesso nell'array "utenti".
time(&data);
strcpy(utenti[dim].data_connessione,ctime(&data));
strcpy(temp_c,temp_nick);
strcat(temp_c,connesso);
strcat(temp_c,utenti[dim].data_connessione);
strcat(temp_c,a_capo);
//Il server scrive all'interno del file "log.txt" la data di connessione del client.
if (write(file,temp_c,strlen(temp_c))!=strlen(temp_c))
{
perror("Write file log");
exit(errno);
}
dim++;
}
else //Altrimenti flag=1->nickname presente nell'array utente in questo caso non si ha la memorizzazione nell'array "utente" del client connesso.
{
//Il server setta la "flag_connesso" del client che si è connesso ad "1" per indicare che tale client è connesso.
utenti[j].flag_connesso=1;
//Il server memorizza la data di connessione del client e la memorizza nella variabile "data_connessione" associata al client connesso nell'array "utenti".
time(&data);
strcpy(utenti[j].data_connessione,ctime(&data));
strcpy(temp_c,temp_nick);
strcat(temp_c,connesso);
strcat(temp_c,utenti[j].data_connessione);
strcat(temp_c,a_capo);
//Il server scrive all'interno del file "log.txt" la data di connessione del client.
if (write(file,temp_c,strlen(temp_c))!=strlen(temp_c))
{
perror("Write file log");
exit(errno);
}
}
}
//Fine procedura di UpDate dei dati tra Server->Client.
//UnLock del semaforo.
pthread_mutex_unlock(&semaforo0);
menu(client);
close(client);
free(acc_sock);
pthread_exit(NULL);
}
int main ( void )
{
struct sockaddr_in my_adr; //Dichiaro la struttura.
int porta_TCP,server; //Dichiaro i file descriptor.
system("clear");
//Inserimento da tastiera della porta sulla quale il server dovrà mettersi in ascolto.
printf("\nInserire la porta TCP sulla quale mettersi in ascolto: ");
scanf("%d",&porta_TCP);
if ((server=socket(PF_INET,SOCK_STREAM,0))==-1) //Crea ill socket per il server.
{
perror("Creating the server socket");
exit(errno);
}
my_adr.sin_family=AF_INET; //Assegno alla struttura la famiglia.
my_adr.sin_port=htons(porta_TCP);
my_adr.sin_addr.s_addr=htonl(INADDR_ANY);
if (bind(server,(struct sockaddr*)&my_adr,sizeof(my_adr))==-1)
{
perror("Binding socket");
return(errno);
}
//Il server si mette in ascolto.
if (listen(server,4096)==-1)
{
perror("Listen");
return(errno);
}
//Il server apre in lettura/scrittura il file "log.txt",se non esiste lo crea.
if ((file=open("log.txt",O_WRONLY | O_CREAT | O_TRUNC,S_IRWXU))<0)
{
perror("Create file");
exit(1);
}
//Gestione dei segnali:
if(signal(SIGTERM,uscita)==SIG_ERR)
perror("can't catch SIGTERM"),exit(1);
if(signal(SIGINT,uscita)==SIG_ERR)
perror("can't catch SIGINT"),exit(1);
if(signal(SIGQUIT,uscita)==SIG_ERR)
perror("can't catch SIGQUIT"),exit(1);
if(signal(SIGHUP,uscita)==SIG_ERR)
perror("can't catch SIGHUP"),exit(1);
if(signal(SIGTSTP,uscita)==SIG_ERR)
perror("can't catch SIGTSTP"),exit(1);
if(signal(SIGPIPE,uscita)==SIG_ERR)
perror("can't catch SIGPIPE"),exit(1);
while(1)
{
struct sockaddr_in from_addr;
socklen_t from_addr_len;
int thread;
from_addr_len=sizeof(struct sockaddr_in);
int *acc_sock=calloc(sizeof(int),1);
pthread_t *new_tid=calloc(sizeof(pthread_t),1);
//Il server accetta la richiesta di connessione da parte del client.
*acc_sock=accept(server,(struct sockaddr*)&from_addr,&from_addr_len);
//Il server crea un thread per ogni client che si collega.
if ((thread=pthread_create(new_tid,NULL,(void * (*) (void *))applicazione,(void *)acc_sock)!=0))
errno=thread, perror("Pthread create"), exit(1);
pthread_detach(*new_tid);
free(new_tid);
continue;
}
close(server);
return(0);
}
void menu(int client)
{
//Dichiarazione delle variabili locali:
int scelta,i=0,j=0,n=0,k=0,x;
time_t data;
char sceltac[1],dim_c[4],flag_connesso_c[1],nick[20]
//Il server legge la scelta che verrà utilizzata per lo "switch" scelta,che viena inviata da ciascun client.
do{n=read(client,&sceltac,1);} while(n<0);
scelta=atoi(sceltac);
switch(scelta)
{
case 1:
//Semaforo.
pthread_mutex_lock(&semaforo1);
//il server crea una matrice per giocare in attesa di un'altro utente
{
utenti[i].myArray=(int **)malloc(sizeof(int *) * verti);
for (i = 0; x < verti; i++)
{
utenti[i].myArray[x] = (int *)malloc(sizeof(int) * orizo);
}
}
utenti[i].flag_partita=1;
//UnLock del semaforo.
pthread_mutex_unlock(&semaforo1);
menu(client);
break;
case 2:
//Semaforo.
pthread_mutex_lock(&semaforo2);
sprintf(dim_c,"%d",dim);
do{n=write(client,&dim_c,4);} while(n<0);
for (i=0;i<dim;i++)
{
if (utenti[i].flag_partita==1) then //il server manda al client i nomi dei client in attesa di qualcuno per giocare
{
do{n=write(client,&utenti[i].nickname,20);} while(n<0);
//sprintf(flag_connesso_c,"%d",utenti[i].flag_connesso);
do{n=write(client,&flag_connesso_c,1);} while(n<0);
}
do{n=read(client,&sceltac,1);} while(n<0);
for (i=0;i<dim;i++)//qui cerca la posizione nell'array dell'utente scelto per giocare
{
//Il server memorizza in "j" la posizione del client "nick" nell'array "utenti".
if ((!(strcmp(nick,utenti[i].nickname))))
j=i;
}
utenti[j].flag_partita=0;
// qui mi sono bloccato nn so come prender i dati di x eleborarlie e passarli a y aspettare che y faccia la propria mossa e passarla a x
//Fine procedura di UpDate dei dati tra Server->Client.
//UnLock del semaforo.
pthread_mutex_unlock(&semaforo2);
menu(client);
break;
Due processi client sono l'interfaccia tra giocatori e il server. Un client, una volta abilitato dal server,
accetta come input una mossa, la trasmette al server, e riceve la risposta dal server. Il server a sua volta quando riceve una mossa, comunica ai due client la posizione del colpo, se mette 4 pedine in fila decreta la vittoria altrimenti abilita il secondo client a spedire una mossa. il mio problema è che non so come prendere i dati da un client elaborarli e passarli all'altro client, vi posto il codice per farvi meglio capire
IL CODICE
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
#include <stdbool.h>
#include <semaphore.h>
#include <time.h>
#include <netinet/in.h>
#include <netdb.h>
#include <signal.h>
#define SIZE 4096
//Dichiarazione delle funzioni utilizzate:
void menu(int); //Funzione contenente le operazioni che il server deve compiere in base alla scelta fatta dai client.
void uscita(int); //Funzione utilizzata per la gestione dei segnali.
void stamp(int **array );
void matrice_gioco();
//Dichiarazione delle variabili globali:
//Struttura contenente tutte le informazioni riguardanti ciascun utente:
struct persona{
char nickname[20]; //Nickname dell'utente.
int flag_connesso; //Flag=1->Utente connesso,flag=0->Utente disconnesso
char data_connessione[30]; //Data di connessione dell'utente.
char ultima_operazione[100]; //Ultima operazione effettuata dall'utente.
int **myArray;//campo di gioco
int partite_vinte;//Numero partite vinte
int flag_partita
} utenti[SIZE];
int dim=0; //Variabile che indica la dimensione della struct "utenti".
int file; //Variabile utilizzata per il file "log.txt".
//Dichiarazione e inizializzazione dei semafori per la sincronizzazione dei client:
pthread_mutex_t semaforo0=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t semaforo1=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t semaforo2=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t semaforo3=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t semaforo4=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t semaforo5=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t semaforo6=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t semaforo7=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t semaforo8=PTHREAD_MUTEX_INITIALIZER;
void *applicazione(int *acc_sock)
{
//Dichiarazione delle variabili locali:
int client;
int n=0,flag_scelta=0,i=0,j=0;
char temp_nick[20],nick[20],flag_connesso_c[1],dim_amici_c[4],dim_richieste_c[4],dim_c[4],dim_messaggi_c[3];
time_t data;
char connesso[100]={' ','s','i',' ','e','`',' ','c','o','n','n','e','s','s','o',' ','i','l',':',' ','\0'};
char a_capo[3]={' ','\n','\0'},temp_c[200];
client=*acc_sock;
//int dim_amici; //Dimensione dell'array:"friends".
//int dim_richieste; //Dimensione dell'array:"richiesta_amicizia".
//int dim_messaggi; //Dimensione dell'array:"messaggi ricevuti".
//Semaforo.
pthread_mutex_lock(&semaforo0);
//Il server riceve il nickname che gli è stato inviato dal client
do{n=read(client,&nick,20);} while(n<0);
//Se la dimensione dell'array "utenti" è uguale a "0" allora il server memorizza il nickname del client collegato nell'array,in caso contrario il server controlla se tale nickname è già presente all'interno dell'array stesso,nel caso questo non fosse presente allora il server provvederà a memorizzarlo nell'array.
if (dim==0)
{
//Il server memorizza nell'array "utenti" il nickname del client connesso.
strcpy(utenti[dim].nickname,nick);
//Il server setta la "flag_connesso" del client che si è connesso ad "1" per indicare che tale client è connesso.
utenti[dim].flag_connesso=1;
//Il server memorizza la data di connessione del client e la memorizza nella variabile "data_connessione" associata al client connesso nell'array "utenti".
time(&data);
strcpy(utenti[dim].data_connessione,ctime(&data));
strcpy(temp_c,nick);
strcat(temp_c,connesso);
strcat(temp_c,utenti[dim].data_connessione);
strcat(temp_c,a_capo);
//Il server scrive all'interno del file "log.txt" la data di connessione del client.
if (write(file,temp_c,strlen(temp_c))!=strlen(temp_c))
{
perror("Write file log");
exit(errno);
}
dim++;
}
else //Il server controlla se il nick è già presente nell'array "utenti" se non lo è lo memorizza al suo interno.
{
flag_scelta=0;
i=0;
while ((flag_scelta==0) && (i<dim))
{
if (strcmp(nick,utenti[i].nickname))
{
flag_scelta=0;
i++;
}
else
{
flag_scelta=1;
j=i;
}
}
strcpy(temp_nick,nick);
if (flag_scelta==0) //flag=0->nickname non presente nell'array "utenti".
{
//Il server memorizza nell'array "utenti" il nickname del client connesso.
strcpy(utenti[dim].nickname,temp_nick);
//Il server setta la "flag_connesso" del client che si è connesso ad "1" per indicare che tale client è connesso.
utenti[dim].flag_connesso=1;
//Il server memorizza la data di connessione del client e la memorizza nella variabile "data_connessione" associata al client connesso nell'array "utenti".
time(&data);
strcpy(utenti[dim].data_connessione,ctime(&data));
strcpy(temp_c,temp_nick);
strcat(temp_c,connesso);
strcat(temp_c,utenti[dim].data_connessione);
strcat(temp_c,a_capo);
//Il server scrive all'interno del file "log.txt" la data di connessione del client.
if (write(file,temp_c,strlen(temp_c))!=strlen(temp_c))
{
perror("Write file log");
exit(errno);
}
dim++;
}
else //Altrimenti flag=1->nickname presente nell'array utente in questo caso non si ha la memorizzazione nell'array "utente" del client connesso.
{
//Il server setta la "flag_connesso" del client che si è connesso ad "1" per indicare che tale client è connesso.
utenti[j].flag_connesso=1;
//Il server memorizza la data di connessione del client e la memorizza nella variabile "data_connessione" associata al client connesso nell'array "utenti".
time(&data);
strcpy(utenti[j].data_connessione,ctime(&data));
strcpy(temp_c,temp_nick);
strcat(temp_c,connesso);
strcat(temp_c,utenti[j].data_connessione);
strcat(temp_c,a_capo);
//Il server scrive all'interno del file "log.txt" la data di connessione del client.
if (write(file,temp_c,strlen(temp_c))!=strlen(temp_c))
{
perror("Write file log");
exit(errno);
}
}
}
//Fine procedura di UpDate dei dati tra Server->Client.
//UnLock del semaforo.
pthread_mutex_unlock(&semaforo0);
menu(client);
close(client);
free(acc_sock);
pthread_exit(NULL);
}
int main ( void )
{
struct sockaddr_in my_adr; //Dichiaro la struttura.
int porta_TCP,server; //Dichiaro i file descriptor.
system("clear");
//Inserimento da tastiera della porta sulla quale il server dovrà mettersi in ascolto.
printf("\nInserire la porta TCP sulla quale mettersi in ascolto: ");
scanf("%d",&porta_TCP);
if ((server=socket(PF_INET,SOCK_STREAM,0))==-1) //Crea ill socket per il server.
{
perror("Creating the server socket");
exit(errno);
}
my_adr.sin_family=AF_INET; //Assegno alla struttura la famiglia.
my_adr.sin_port=htons(porta_TCP);
my_adr.sin_addr.s_addr=htonl(INADDR_ANY);
if (bind(server,(struct sockaddr*)&my_adr,sizeof(my_adr))==-1)
{
perror("Binding socket");
return(errno);
}
//Il server si mette in ascolto.
if (listen(server,4096)==-1)
{
perror("Listen");
return(errno);
}
//Il server apre in lettura/scrittura il file "log.txt",se non esiste lo crea.
if ((file=open("log.txt",O_WRONLY | O_CREAT | O_TRUNC,S_IRWXU))<0)
{
perror("Create file");
exit(1);
}
//Gestione dei segnali:
if(signal(SIGTERM,uscita)==SIG_ERR)
perror("can't catch SIGTERM"),exit(1);
if(signal(SIGINT,uscita)==SIG_ERR)
perror("can't catch SIGINT"),exit(1);
if(signal(SIGQUIT,uscita)==SIG_ERR)
perror("can't catch SIGQUIT"),exit(1);
if(signal(SIGHUP,uscita)==SIG_ERR)
perror("can't catch SIGHUP"),exit(1);
if(signal(SIGTSTP,uscita)==SIG_ERR)
perror("can't catch SIGTSTP"),exit(1);
if(signal(SIGPIPE,uscita)==SIG_ERR)
perror("can't catch SIGPIPE"),exit(1);
while(1)
{
struct sockaddr_in from_addr;
socklen_t from_addr_len;
int thread;
from_addr_len=sizeof(struct sockaddr_in);
int *acc_sock=calloc(sizeof(int),1);
pthread_t *new_tid=calloc(sizeof(pthread_t),1);
//Il server accetta la richiesta di connessione da parte del client.
*acc_sock=accept(server,(struct sockaddr*)&from_addr,&from_addr_len);
//Il server crea un thread per ogni client che si collega.
if ((thread=pthread_create(new_tid,NULL,(void * (*) (void *))applicazione,(void *)acc_sock)!=0))
errno=thread, perror("Pthread create"), exit(1);
pthread_detach(*new_tid);
free(new_tid);
continue;
}
close(server);
return(0);
}
void menu(int client)
{
//Dichiarazione delle variabili locali:
int scelta,i=0,j=0,n=0,k=0,x;
time_t data;
char sceltac[1],dim_c[4],flag_connesso_c[1],nick[20]
//Il server legge la scelta che verrà utilizzata per lo "switch" scelta,che viena inviata da ciascun client.
do{n=read(client,&sceltac,1);} while(n<0);
scelta=atoi(sceltac);
switch(scelta)
{
case 1:
//Semaforo.
pthread_mutex_lock(&semaforo1);
//il server crea una matrice per giocare in attesa di un'altro utente
{
utenti[i].myArray=(int **)malloc(sizeof(int *) * verti);
for (i = 0; x < verti; i++)
{
utenti[i].myArray[x] = (int *)malloc(sizeof(int) * orizo);
}
}
utenti[i].flag_partita=1;
//UnLock del semaforo.
pthread_mutex_unlock(&semaforo1);
menu(client);
break;
case 2:
//Semaforo.
pthread_mutex_lock(&semaforo2);
sprintf(dim_c,"%d",dim);
do{n=write(client,&dim_c,4);} while(n<0);
for (i=0;i<dim;i++)
{
if (utenti[i].flag_partita==1) then //il server manda al client i nomi dei client in attesa di qualcuno per giocare
{
do{n=write(client,&utenti[i].nickname,20);} while(n<0);
//sprintf(flag_connesso_c,"%d",utenti[i].flag_connesso);
do{n=write(client,&flag_connesso_c,1);} while(n<0);
}
do{n=read(client,&sceltac,1);} while(n<0);
for (i=0;i<dim;i++)//qui cerca la posizione nell'array dell'utente scelto per giocare
{
//Il server memorizza in "j" la posizione del client "nick" nell'array "utenti".
if ((!(strcmp(nick,utenti[i].nickname))))
j=i;
}
utenti[j].flag_partita=0;
// qui mi sono bloccato nn so come prender i dati di x eleborarlie e passarli a y aspettare che y faccia la propria mossa e passarla a x
//Fine procedura di UpDate dei dati tra Server->Client.
//UnLock del semaforo.
pthread_mutex_unlock(&semaforo2);
menu(client);
break;