int new_client(t_server *server, int *actual, char *buff)
{
int csock;
t_sockaddr_in csin;
socklen_t sinsize;
sinsize = sizeof(csin);
csock = accept(server->sock, (t_sockaddr *)&csin, &sinsize);
if (csock == SOCKET_ERROR)
{
error("accept");
return (-1);
}
if (read_client(csock, buff) == -1)
return (-1);
while (check_pseudo(buff, server) == -1)
{
write_client(csock, "Pseudo already used");
if (read_client(csock, buff) == -1)
return (-1);
}
FD_SET(csock, &(server->rdfs));
server->max = csock > server->max ? csock : server->max;
init_client(server, *actual, buff, csock);
(*actual)++;
return (csock);
}
void client_talking(t_server *server, int *actual, char *buff)
{
int i;
t_client client;
char *tmp;
i = 0;
while (i < *actual)
{
if (FD_ISSET(server->clients[i].sock, &(server->rdfs)))
{
client = server->clients[i];
if (read_client(server->clients[i].sock, buff) == 0)
{
if_read(server, actual, buff, i);
}
else if (buff[0] == '/')
{
if ((tmp = cmd(buff, &(server->clients[i]), server)))
write_client(server->clients[i].sock, tmp);
}
else
send_to_all(server->clients, client, *actual, buff);
break ;
}
i++;
}
}
int run_serveur(t_serv *serv)
{
t_user *user_list;
fd_set readfd;
int max;
int socks;
char *buff;
max = serv->s;
user_list = NULL;
if ((buff = malloc(4096 * sizeof(char))) == NULL)
return (EXIT_FAILURE);
while (1)
{
reset_list(&readfd, user_list, serv, max);
if (FD_ISSET(serv->s, &readfd))
{
accept_connect(&socks, serv);
if (read_client(socks, buff) != 0)
{
client_connexion(&max, socks, &readfd);
add_user(&user_list, DEFAULT_USER, socks, NULL);
}
}
else
send_rcv(&user_list, &readfd);
}
}
/**
* Poll relay server
* Return:
* 0 success
* -1 failed
*/
int rs_loop(rscntxt_t *cntxt)
{
if (NULL == cntxt) {
LogE("NULL Pointer");
return -1;
}
#define MAX_EVENTS 16
#define WAIT_TIMEOUT 10
struct epoll_event ev[MAX_EVENTS];
int ret = epoll_wait(cntxt->fd_epoll, ev, MAX_EVENTS, WAIT_TIMEOUT);
int i;
for (i = 0; i < ret; ++i) {
if (ev[i].data.fd == cntxt->fd_srvr) {
accept_connection(cntxt);
continue;
}
int nread = read_client(ev[i].data.fd, cntxt);
if (nread < 0) {
LogE("Failed read client");
}
}
return 0;
}
int main(void)
{
if(FAILED(init_com_client()))
{
PRINT("Failed to init\n");
return -1;
}
if(FAILED(run_com_client(COM_BNEP)))
{
PRINT("Failed to run\n");
}
else
{
int size = 17;
char msg[16];
PRINT("Connected to server\n");
memset(msg,0,size);
while(FAILED(read_client(msg,&size)))
size = 16;
PRINT("received: %s\n",msg);
}
if(FAILED(shutdown_com_client()))
{
PRINT("Failed to shutdown\n");
return -1;
}
return 0;
}
std::auto_ptr<image_list> TIFFFormat::do_read(byte_source* src, ImageFactory* factory, bool is_multi) {
tiff_warn_error twe;
tif_holder t = read_client(src);
std::auto_ptr<image_list> images(new image_list);
do {
const uint32 h = tiff_get<uint32>(t, TIFFTAG_IMAGELENGTH);
const uint32 w = tiff_get<uint32>(t, TIFFTAG_IMAGEWIDTH);
const uint16 nr_samples = tiff_get<uint16>(t, TIFFTAG_SAMPLESPERPIXEL);
const uint16 bits_per_sample = tiff_get<uint16>(t, TIFFTAG_BITSPERSAMPLE);
const int depth = nr_samples > 1 ? nr_samples : -1;
std::auto_ptr<Image> output = factory->create(bits_per_sample, h, w, depth);
if (ImageWithMetadata* metaout = dynamic_cast<ImageWithMetadata*>(output.get())) {
std::string description = tiff_get<std::string>(t, TIFFTAG_IMAGEDESCRIPTION, "");
metaout->set_meta(description);
}
for (uint32 r = 0; r != h; ++r) {
if(TIFFReadScanline(t.tif, output->rowp_as<byte>(r), r) == -1) {
throw CannotReadError("imread.imread._tiff: Error reading scanline");
}
}
images->push_back(output);
} while (is_multi && TIFFReadDirectory(t.tif));
return images;
}
void TcpServer::update(uint32_t diff)
{
int res;
while((res = accept(m_sock_fd, NULL, 0)) >= 0)
{
const int optval = 1;
ioctl(res, FIONBIO, &optval);
LOGD("Client connected: %d", res);
m_clients.push_back(tcp_client(res));
onClientAdded();
}
// disconnected clients must be removed from m_clients in this method and nowhere else
int av;
for(std::vector<tcp_client>::iterator itr = m_clients.begin(); itr != m_clients.end(); )
{
av = available((*itr).fd);
if(av > 0)
{
read_client(*itr);
++itr;
}
else if(av < 0 || (av == 0 && recv((*itr).fd, NULL, 0, 0) == 0))
{
LOGD("Client disconnected: %d", (*itr).fd);
::close((*itr).fd);
itr = m_clients.erase(itr);
onClientRm();
}
else
++itr;
}
}
void client_read(t_env *e, int fd, void (*tabptrfn[])())
{
int r;
char buf[BUFFER];
bzero(buf, BUFFER);
if ((r = (int)read(fd, buf, BUFFER - 1)) > 0)
buf[r - 1] = '\0';
else
read_client(fd, e);
printf("Received from client %d : %s\n", fd, buf);
client_choose_func(e, fd, buf, tabptrfn);
}
client::client(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::client)
{
ui->setupUi(this);
tcpclient = new QTcpSocket(this);
tcpclient->connectToHost(QHostAddress("192.168.1.80"), 5000);
//tcpclient->connectToHost(QHostAddress::LocalHost, 5000);
//qDebug() <<QHostAddress(QHostAddress::LocalHost).toString();
connect(tcpclient, SIGNAL (readyRead()), this, SLOT(read_client()));
connect(ui->lineEdit, SIGNAL(returnPressed()), ui->sendButton, SLOT(click()));
}
int manage_client(t_server *server,
fd_set *rfds,
fd_set *wfds)
{
t_client *client;
client = find_client(server->root_clients, rfds, wfds);
if (client)
{
if (FD_ISSET(client->fd, rfds))
read_client(server, client);
else
write_client(server, client);
}
return (0);
}
int run_serveur(t_serv *serv)
{
while (1)
{
if ((serv->cs = accept(serv->s, (struct sockaddr *)&(serv->sin_client),
(socklen_t *)&(serv->client_len))) == -1)
perror("");
else
{
if (user_identificate(serv) == EXIT_SUCCESS)
{
user_information(serv);
read_client(serv, serv->cs);
}
}
}
}
t_client *manage_select(t_client *client, t_time *time, int const sfd)
{
fd_set fd_read;
fd_set fd_write;
int fd_max;
fd_max = fd_set_client(&fd_read, &fd_write, client, sfd);
if (pselect(fd_max + 1, &fd_read, &fd_write, NULL, time, NULL) == -1)
{
perror("select()");
g_keep_running = false;
return (client);
}
if (FD_ISSET(sfd, &fd_read) && (client = add_client(client, sfd)) == NULL)
{
g_keep_running = false;
return (client);
}
return (write_client(&fd_write, read_client(&fd_read, client)));
}
std::auto_ptr<image_list> STKFormat::read_multi(byte_source* src, ImageFactory* factory) {
shift_source moved(src);
stk_extend ext;
tiff_warn_error twe;
tif_holder t = read_client(&moved);
std::auto_ptr<image_list> images(new image_list);
const uint32 h = tiff_get<uint32>(t, TIFFTAG_IMAGELENGTH);
const uint32 w = tiff_get<uint32>(t, TIFFTAG_IMAGEWIDTH);
const uint16 nr_samples = tiff_get<uint16>(t, TIFFTAG_SAMPLESPERPIXEL, 1);
const uint16 bits_per_sample = tiff_get<uint16>(t, TIFFTAG_BITSPERSAMPLE, 8);
const int depth = nr_samples > 1 ? nr_samples : -1;
const int strip_size = TIFFStripSize(t.tif);
const int n_strips = TIFFNumberOfStrips(t.tif);
int32_t n_planes;
void* data;
TIFFGetField(t.tif, UIC3Tag, &n_planes, &data);
int raw_strip_size = 0;
for (int st = 0; st != n_strips; ++st) {
raw_strip_size += TIFFRawStripSize(t.tif, st);
}
for (int z = 0; z < n_planes; ++z) {
// Monkey patch strip offsets. This is very hacky, but it seems to work!
moved.shift(z * raw_strip_size);
std::auto_ptr<Image> output(factory->create(bits_per_sample, h, w, depth));
uint8_t* start = output->rowp_as<uint8_t>(0);
for (int st = 0; st != n_strips; ++st) {
const int offset = TIFFReadEncodedStrip(t.tif, st, start, strip_size);
if (offset == -1) {
throw CannotReadError("imread.imread._tiff.stk: Error reading strip");
}
start += offset;
}
images->push_back(output);
}
return images;
}
void server(void)
{
SOCKET sock = init_connection();
char buffer[BUF_SIZE];
int max = sock;
fd_set rdfs;
while(1)
{
FD_ZERO(&rdfs);
FD_SET(STDIN_FILENO, &rdfs);
FD_SET(sock, &rdfs);
if(connected)
{
FD_SET(client.sock, &rdfs);
}
if(select(max + 1, &rdfs,NULL, NULL, NULL) == -1)
{
perror("select()");
exit(errno);
}
if(FD_ISSET(STDIN_FILENO, &rdfs))
{
fgets(buffer, BUF_SIZE - 1, stdin);
{
char *p = NULL;
p = strstr(buffer, "\n");
if(p != NULL)
{
*p = 0;
}
else
{
buffer[BUF_SIZE - 1] = 0;
}
}
if(connected && send(client.sock, buffer, strlen(buffer), 0) < 0)
{
perror("send()");
exit(errno);
}
}
else if(FD_ISSET(sock, &rdfs))
{
SOCKADDR_IN csin = { 0 };
socklen_t sinsize = sizeof csin;
int csock = accept(sock, (SOCKADDR *)&csin, &sinsize);
if(csock == SOCKET_ERROR)
{
perror("accept()");
continue;
}
if(read_client(csock, buffer) == -1)
{
continue;
}
max = csock > max ? csock : max;
FD_SET(csock, &rdfs);
Client c = { csock };
strncpy(c.name, buffer, BUF_SIZE - 1);
client=c;
connected=1;
}
else
{
if(connected)
{
if(FD_ISSET(client.sock, &rdfs))
{
int c = read_client(client.sock, buffer);
if(c == 0)
{
closesocket(client.sock);
remove_client(&client);
puts("Client déconnecté");
}
else
{
printf("%s : ",client.name);
puts(buffer);
}
}
}
}
}
clear_client(&client);
end_connection(sock);
}
static void app(void)
{
SOCKET sock = init_connection();
char buffer[BUF_SIZE];
int max = sock;
/* tableau des clients */
Client clients[MAX_CLIENTS];
fd_set rdfs;
/* Topologie */
struct graph * graph = initialiser_Graph();
while(1)
{
int i = 0;
FD_ZERO(&rdfs);
/* ajouter STDIN_FILENO */
FD_SET(STDIN_FILENO, &rdfs);
/* ajouter le socket de connexion */
FD_SET(sock, &rdfs);
/* ajouter un socket pour chaque client */
for(i = 0; i < actual; i++)
{
FD_SET(clients[i].sock, &rdfs);
}
if(select(max + 1, &rdfs, NULL, NULL, NULL) == -1)
{
perror("select()");
exit(errno);
}
/* quelque chose qui rentre depuis le clavier */
if(FD_ISSET(STDIN_FILENO, &rdfs))
{
/* char message[BUF_SIZE]; */
fgets(buffer, BUF_SIZE - 1, stdin);
{
char *p = NULL;
p = strstr(buffer, "\n");
if(p != NULL)
{
*p = 0;
}
else
{
/* fclean */
buffer[BUF_SIZE - 1] = 0;
}
}
/* ===Pour écrire à tous les clients===
message[0] = 0;
strncpy(message, "serveur : ", 0);
strncat(message, buffer, 10);
for(i = 0; i < actual; i++)
{
write_client(clients[i].sock, message);
} */
/* On analyse ce que l'utilisateur tape et on agit en conséquence */
if(analyse_cmd(graph, buffer) == 0)
break; /* L'utilisateur veut quitter */
}
else if(FD_ISSET(sock, &rdfs))
{
/* nouveau client */
SOCKADDR_IN csin = { 0 };
socklen_t sinsize = sizeof(csin);
int csock = accept(sock, (SOCKADDR *)&csin, &sinsize);
if(csock == SOCKET_ERROR)
{
perror("accept()");
continue;
}
/* après s'être connecté le client envoie son nom */
if(read_client(csock, buffer) == -1)
{
/* déconnecté */
continue;
}
/* quel est le nouveau fd maximum ? */
max = csock > max ? csock : max;
FD_SET(csock, &rdfs); /* On ajoute le socket à la liste d'écoute */
int nbTokens;
char **tokens = malloc(MAX_NB_TOKENS*sizeof(char*));
nbTokens = strsplit(buffer, tokens, MAX_LEN_LINE, " ");
printf("ENVOYE : %s, NB TOKENS : %d\n", buffer, nbTokens);
if (nbTokens == 6 && strcmp(tokens[0], "log") == 0 && strcmp(tokens[1], "in") == 0 && strcmp(tokens[2], "as") == 0 && strcmp(tokens[4], "port") == 0)
{
printf("nbTokens == 6\n");
int port;
tokens[5][strlen(tokens[5])-1] = '\0';
port = secure_atoi(tokens[5]);
/* On cherche si un client utilise déjà le nom demandé
* si le nom existe
* et si le port est bon*/
if (port <= 65535 && port >= 0) {
printf("port OK\n");
int indice_noeud, indice_noeud_gen;
Client c;
c.sock = csock;
c.port_number = port;
c.address = inet_ntoa(csin.sin_addr);
indice_noeud = exist_Noeud(graph, tokens[3]);
indice_noeud_gen = obtenir_Indice_Noeud_Non_Actif(graph);
if (indice_noeud < actual && indice_noeud >= 0 && est_actif_noeud(graph, indice_noeud)== 0) {
printf("indice noeud OK, %s\n", tokens[3]);
strcpy(c.name, tokens[3]);
activer_Noeud(graph, indice_noeud);
clients[actual] = c;
actual = actual + 1;
char bufG[BUF_SIZE] = "";
sprintf(bufG, "greeting %s*\n", c.name);
write_client(c.sock, bufG, clients);
}
else if(indice_noeud_gen != -1) {
printf("indice noeud gen OK\n");
strcpy(c.name, obtenir_Nom_Noeud(graph, indice_noeud_gen));
activer_Noeud(graph, indice_noeud_gen);
clients[actual] = c;
actual = actual + 1;
char bufG[BUF_SIZE] = "";
sprintf(bufG, "greeting %s*\n", c.name);
printf("bufG : %s\n", bufG);
write_client(c.sock, bufG, clients);
printf("écrit\n");
}
else {
printf("Tous les noeuds sont déjà occupés !\n");
}
}
else
printf("Erreur de port : %s\n", tokens[5]);
}
else if (nbTokens == 4 && strcmp(tokens[0], "log") == 0 && strcmp(tokens[1], "in") == 0 && strcmp(tokens[2], "port") == 0)
{
int port;
tokens[5][strlen(tokens[5])-1] = '\0';
port = secure_atoi(tokens[5]);
/* On cherche si un client utilise déjà le nom demandé
* si le nom existe
* et si le port est bon*/
if (port <= 65535 && port >= 0) {
int indice_noeud_gen;
Client c;
c.sock = csock;
c.port_number = port;
c.address = inet_ntoa(csin.sin_addr);
indice_noeud_gen = obtenir_Indice_Noeud_Non_Actif(graph);
if(indice_noeud_gen != -1) {
strcpy(c.name, obtenir_Nom_Noeud(graph, indice_noeud_gen));
activer_Noeud(graph, indice_noeud_gen);
clients[actual] = c;
actual = actual + 1;
char bufG[BUF_SIZE] = "";
sprintf(bufG, "greeting %s*\n", c.name);
/* printf("bufG : %s\n", bufG); */
write_client(c.sock, bufG, clients);
/* printf("écrit\n"); */
}
else {
printf("Tous les noeuds sont déjà occupés !\n");
}
}
else
printf("Erreur de port : %s\n", tokens[5]);
}
/*
for(i=0; i < nbTokens; i++) {
free(tokens[i]);
}
free(tokens);
*/
}
else
{
int i;
for(i = 0; i < actual; i++)
{
/* un client parle */
if(FD_ISSET(clients[i].sock, &rdfs))
{
Client client = clients[i];
int c = read_client(clients[i].sock, buffer);
/* client déconnecté */
if(c == 0)
{
closesocket(clients[i].sock);
remove_client(clients, i, &actual);
strncpy(buffer, client.name, BUF_SIZE - 1);
strncat(buffer, " déconnecté !", BUF_SIZE - strlen(buffer) - 1);
send_message_to_all_clients(clients, client, actual, buffer, 1);
}
else
{
/* On analyse la requête du client stockée dans buffer et on lui répond */
printf("router_poll : %s\n", buffer);
if(router_poll(graph, &clients[i], buffer, clients) == 0) {
/* Si le routeur veut être déconnecté */
closesocket(clients[i].sock);
remove_client(clients, i, &actual);
}
/* ====Pour envoyer un message à tous les routeurs====
send_message_to_all_clients(clients, client, actual, buffer, 0); */
}
break;
}
}
}
}
/* libération des données */
free_graph(graph);
clear_clients(clients, actual);
end_connection(sock);
}
/*
int main()
{
return 0;
}
*/
int communicate(struct donnees* donnees)
{
printf("communicate\n");
struct client* client=donnees->client;
ulong ip = client->sockaddr->sin_addr.s_addr;
struct peer* peer = find_peer(donnees->peer_list, ip);
struct file_list* file_list = donnees->file_list;
struct peer_list* peer_list = donnees->peer_list;
int refresh_time=get_refresh_time();
printf("refresh time:%d\n",refresh_time);
char* recv_buffer= malloc(sizeof(char)*RECV_BUF_SIZE);
char* send_buffer= malloc(sizeof(char)*SEND_BUF_SIZE);
char* s1 = malloc(RECV_BUF_SIZE*sizeof(char));
char* s2 = malloc(RECV_BUF_SIZE*sizeof(char));
char* s3 = malloc(RECV_BUF_SIZE*sizeof(char));
char* s4 = malloc(RECV_BUF_SIZE*sizeof(char));
char* s5 = malloc(RECV_BUF_SIZE*sizeof(char));
char* s6 = malloc(RECV_BUF_SIZE*sizeof(char));
char* s0 = malloc(RECV_BUF_SIZE*sizeof(char));
char* saux = malloc(RECV_BUF_SIZE*sizeof(char));
char** tab = malloc(7*sizeof(char *));
tab[0]=s0;
tab[1]=s1;
tab[2]=s2;
tab[3]=s3;
tab[4]=s4;
tab[5]=s5;
tab[6]=s6;
int port;
int read;
int decalage;
int length;
int piece_size;
struct timeval *t = malloc(sizeof(struct timeval));
struct timeval *t2 = malloc(sizeof(struct timeval));
struct timezone *tz = malloc(sizeof(struct timezone));
struct timezone *tz2 = malloc(sizeof(struct timezone));
gettimeofday(t,tz);
while(1)
{
recv_buffer[0]='\0';
send_buffer[0]='\0';
gettimeofday(t2,tz2);
if(( (int)(t2->tv_sec - t->tv_sec))>3*refresh_time)
{
if(peer!=NULL)
{
peer->time--;
if(!peer->time)
{
peer_list_peer_delete(peer_list,file_list,peer->ip_address);
}
}
//free
free(s0);
free(s1);
free(s2);
free(s3);
free(s4);
free(s5);
free(s6);
free(saux);
free(recv_buffer);
free(send_buffer);
free(tab);
free(t);
free(t2);
free(tz);
free(tz2);
end(client,donnees->ct);
return 0;
}
read=read_client(client->sock, recv_buffer);
if(read > 0)
{
gettimeofday(t,tz);
if(peer!=NULL)
peer->time ++;
//print_data(file_list, peer_list);
printf("received:\n");
switch(recv_buffer[0])
{
pthread_mutex_lock(& mutex);
case'a':
decalage=0;
while(compte_crochet_fermant(recv_buffer)<2)
{
decalage+=read;
read=read_client(client->sock, recv_buffer + decalage);
}
recv_buffer[decalage+read]='\0';
printf("%s\n", recv_buffer);
parse(recv_buffer, tab);
port = atoi(s2);
if(strcmp(s0,"announce")==0 && strcmp(s1,"listen")==0 && strcmp(s3,"seed")==0 && strcmp(s5,"leech")==0)
{
if(peer == NULL)
{
peer = peer_init(ip, port);
peer_list_add(peer_list, peer);
peer->time=1;
}
int i=0;
while(strlen(s4+i) > 0)
{
if(compte_espace(s4+i)>3)
{
sscanf(s4+i, "%s %d %d %s", s1, &length, &piece_size, s2);
sprintf(saux, "%s %d %d %s", s1, length, piece_size, s2);
struct file* file = find_file(file_list, s1);
if(NULL == file)
{
file = remplit_file(s1, length, piece_size, s2);
file_list_add(file_list, file);
}
add_link(file, peer);
i+=strlen(saux)+1;
}
else
{
sscanf(s4+i, "%s %d %d %s", s1, &length, &piece_size, s2);
struct file* file = find_file(file_list, s1);
if(NULL == file)
{
file = remplit_file(s1, length, piece_size, s2);
file_list_add(file_list, file);
}
add_link(file, peer);
s4[i]='\0';
}
}
struct file_list* f_add = keys_string_to_file_list(s6);
update_add(file_list, peer, f_add);
file_list_delete(f_add);
write_client(client->sock, "ok");
printf("replied:ok\n");
}
break;
case'u':
decalage=0;
while(compte_crochet_fermant(recv_buffer)<2)
{
decalage+=read;
read=read_client(client->sock, recv_buffer + decalage);
}
recv_buffer[decalage+read]='\0';
printf("%s\n", recv_buffer);
parse(recv_buffer, tab);
if(strcmp(s0,"update")==0 && strcmp(s1,"seed")==0 && strcmp(s3,"leech")==0)
{
if(peer==NULL){
//free
free(s0);
free(s1);
free(s2);
free(s3);
free(s4);
free(s5);
free(s6);
free(saux);
free(recv_buffer);
free(send_buffer);
free(tab);
free(t);
free(t2);
free(tz);
free(tz2);
end(client, donnees->ct);
return 0;}//ferme la socket
else
{
char* res=fusion_keys_string(s2, s4);
struct file_list* f = keys_string_to_file_list(res);
update_diff(f, peer->file_list, file_list, peer);
file_list_delete(f);
free(res);
write_client(client->sock, "ok");
printf("replied:ok\n");
}
}
break;
case'l':
decalage=0;
while(compte_crochet_fermant(recv_buffer)<1)
{
decalage+=read;
read=read_client(client->sock, recv_buffer + decalage);
}
recv_buffer[decalage+read]='\0';
printf("%s\n", recv_buffer);
parse(recv_buffer, tab);
if(strcmp(s0,"look")==0)
{
char* filename="filename";
int egal=1;
int i;
s2[0]='\n';
for(i=0;i<8;i++)
{
if(s1[i]!=filename[i]) egal --;
}
if(egal==1)
{
for(i=10;i<((int) strlen(s1))-1;i++)
{
s2[i-10]=s1[i];
}
s2[strlen(s1)-11]='\0';
printf("recherche:\nfilename=%s\n",s2);
struct file* file=find_file_name(file_list, s2);
if(file==NULL) write_client(client->sock, "list []");
else
{
sprintf(send_buffer, "list [%s %d %d %s]", s2, file->length, file->p_size, file->key);
write_client(client->sock, send_buffer);
printf("replied:%s\n", send_buffer);
}
}
}
break;
case'g':
recv_buffer[read]='\0';
printf("%s\n", recv_buffer);
parse(recv_buffer, tab);
if(strcmp(s0,"getfile")==0)
{
struct file* f=find_file(file_list, s1);
if(f==NULL||f->peer_list->first==NULL)
{
sprintf(send_buffer, "peers %s []", s1);
write_client(client->sock, send_buffer);
}
else
{
struct elt_peer* aux=f->peer_list->first;
struct in_addr* in_addr1=malloc(sizeof(struct in_addr));
in_addr1->s_addr=aux->peer->ip_address;
char* d= inet_ntoa(*in_addr1);
sprintf(send_buffer, "peers %s [%s:%d", s1, d, aux->peer->port);
aux=aux->next;
while(aux!=NULL)
{
struct in_addr* in_addr=malloc(sizeof(struct in_addr));
in_addr->s_addr=aux->peer->ip_address;
char* c= inet_ntoa(*in_addr);
sprintf(send_buffer+strlen(send_buffer), " %s:%d", c, aux->peer->port);
aux=aux->next;
}
sprintf(send_buffer+strlen(send_buffer), "]");
write_client(client->sock, send_buffer);
printf("replied:%s\n", send_buffer);
}
}
break;
default:
printf("entree non valide");
//free
free(s0);
free(s1);
free(s2);
free(s3);
free(s4);
free(s5);
free(s6);
free(saux);
free(recv_buffer);
free(send_buffer);
free(tab);
free(t);
free(t2);
free(tz);
free(tz2);
end(client,donnees->ct);
return 0;
}
pthread_mutex_unlock( &mutex);
}
}
return EXIT_SUCCESS;
}
/**
* Methode principale
**/
static void app(void)
{
/* Initialisation du socket */
SOCKET sock = init_connection();
char buffer[BUF_SIZE];
char message[BUF_SIZE];
/* Index de l'array */
int actual = 0;
int max = sock;
int sizeread;
/* Le tableau qui va stocker les clients */
Client clients[MAX_CLIENTS];
/* Lot de descripteurs */
fd_set rdfs;
char *commande;
char *nomFichier;
char *contenuFichier;
while(1)
{
int i = 0;
/* Remise à zéro des descripteurs */
FD_ZERO(&rdfs);
/* ajout STDIN_FILENO (console)*/
FD_SET(STDIN_FILENO, &rdfs);
/* ajout du socket comme descripteur */
FD_SET(sock, &rdfs);
/* Ajout d'un socket pour chaque clients */
for(i = 0; i < actual; i++)
{
FD_SET(clients[i].sock, &rdfs);
}
/* Son sélectionne tous les descripteurs prêts */
if(select(max + 1, &rdfs, NULL, NULL, NULL) == -1)
{
perror("select()");
exit(errno);
}
/* SI c'est une entrée clavier */
if(FD_ISSET(STDIN_FILENO, &rdfs))
{
/* Si on a tapé quelque chose au clavier on arrête l'application pour permettre à l'utilisateur d'écrire*/
break;
} /* Sinon si c'est une entrée socket ( nouveau )*/
else if(FD_ISSET(sock, &rdfs))
{
/* Nouveau client */
SOCKADDR_IN csin = { 0 };
size_t sinsize = sizeof csin;
int csock = accept(sock, (SOCKADDR *)&csin, &sinsize);
if(csock == SOCKET_ERROR)
{
perror("accept()");
continue;
}
/* Après s'être connecté le client envoi son pseudo */
if(read_client(csock, buffer) == -1)
{
/* déconnecté */
continue;
}
/* Quel est le nouveau numéro de descripteur max (pour le select) ? */
max = csock > max ? csock : max;
/* On ajoute le client à la liste des descripteurs */
FD_SET(csock, &rdfs);
/* On ajoute le client à la liste des clients avec son numéro de socket */
Client c = { csock };
strncpy(c.name, buffer, BUF_SIZE - 1);
clients[actual] = c;
actual++;
}
else /* Sinon on vérifie si un client a parlé */
{
int i = 0;
for(i = 0; i < actual; i++) /* Pour chaque client */
{
/* On vérifie que le socket du client contient quelque chose */
if(FD_ISSET(clients[i].sock, &rdfs))
{
/* Si c'est le cas on traite le message */
Client client = clients[i];
/* On lie le message envoyé par le client */
int c = read_client(clients[i].sock, buffer);
/* Client deconnecté */
if(c == 0)
{
/* Dans ce cas on ferme le socket */
closesocket(clients[i].sock);
remove_client(clients, i, &actual);
strncpy(buffer, client.name, BUF_SIZE - 1);
strncat(buffer, " disconnected !", BUF_SIZE - strlen(buffer) - 1);
send_message_to_all_clients(clients, client, actual, buffer, 1); /* On notifie tout les clients que ce dernier s'est déconnecté */
}
else
{
strcpy(message, buffer);
commande = strtok(buffer, " ");
if( commande != NULL ) {
if(!strncasecmp(commande,"/getfile", strlen(commande))){
printf("%s\n", "Début envoi fichier");
nomFichier = strtok(NULL, " ");
FILE* fp = fopen(nomFichier, "r");
sizeread = fread(buffer,sizeof(char),1000,fp);
buffer[sizeread] = 0;
write(clients[i].sock,buffer,strlen(buffer));
printf("%s\n", "Fin envoi fichier");
} else if(!strncasecmp(commande,"/sendfile", strlen(commande))){
printf("%s\n", "Début réception fichier");
nomFichier = strtok(NULL, " ");
FILE* fp = fopen(nomFichier, "w");
contenuFichier = strtok(NULL, "\0");
fprintf(fp,"%s\n",contenuFichier);
fclose(fp);
printf("%s\n", "Fin réception fichier");
} else {
/* Sinon on se chargfe juste de relayer le message */
send_message_to_all_clients(clients, client, actual, message, 0);
}
}
}
break;
}
}
}
}
/* On supprime les clients */
clear_clients(clients, actual);
/* On ferme les connexions */
end_connection(sock);
}
int main(int argc, char *argv[]) {
int fd_socket;
fd_set active_fd, read_fd;
struct sockaddr_in csa;
int i = 0;
uint16_t port;
int dsize; /* size of file descriptors table */
struct logserver_t logbuff = { 0, "" };
FILE *logfile;
/* Check params */
if (3 == argc) {
logbuff.message_buffsize = atoi(argv[2]);
logbuff.message_buffer = (char *) mem_zalloc(logbuff.message_buffsize);
port = atoi(argv[1]);
if (NULL == logbuff.message_buffer) {
fprintf(stdout, "Can't allocate %d buffer size\n",
logbuff.message_buffsize);
return EXIT_FAILURE;
}
} else {
print_usage();
return EXIT_FAILURE;
}
/*create a socket to listen to*/
fd_socket = create_socket(port);
/* Initialise file descriptors sockets. */
if (listen(fd_socket, 5) < 0) {
perror("listen");
exit(EXIT_FAILURE);
}
/* remember size for later usage */
/* calculate size of file descriptors table */
dsize = getdtablesize();
FD_ZERO(&active_fd);
FD_SET(fd_socket, &active_fd);
while (1) {
/*blocking socket block until input arrives*/
read_fd = active_fd;
if (select(dsize, &read_fd, NULL, NULL, (struct timeval *) NULL) < 0) {
perror("select");
exit(EXIT_FAILURE);
}
if (FD_ISSET(fd_socket,&read_fd)) {
printf("fd socket is set \n");
int size_csa = sizeof(csa);
int connectd_socket = accept(fd_socket, (struct sockaddr *) &csa,
(socklen_t *) &size_csa);
/*are we connected*/
if (connectd_socket < 0) {
perror("socket accept error");
continue;
}
fprintf(stdout, "Server: connected from host %s, port %d.\n",
(char *) inet_ntoa(csa.sin_addr),
ntohs(csa.sin_port));
FD_SET(connectd_socket, &active_fd);
logfile = open_logfile();
}
for (i = 0; i < dsize; ++i) {
if ((i != fd_socket ) && FD_ISSET(i,&read_fd)) {
if (read_client(i, &logbuff,logfile) < 0) {
close(i);
FD_CLR(i, &active_fd);
goto EXIT_SOCKFD;
}
}
}
}
EXIT_SOCKFD:
free_zalloc(logbuff.message_buffer);
close_logfile(logfile);
return 0;
}
