/**
* Callback to be called when forwarded peer create operation is successfull. We
* have to relay the reply msg back to the client
*
* @param cls ForwardedOperationContext
* @param msg the peer create success message
*/
static void
peer_create_success_cb (void *cls, const struct GNUNET_MessageHeader *msg)
{
struct ForwardedOperationContext *fopc = cls;
struct Peer *remote_peer;
if (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS)
{
GNUNET_assert (NULL != fopc->cls);
remote_peer = fopc->cls;
peer_list_add (remote_peer);
}
GST_forwarded_operation_reply_relay (fopc,
msg);
}
/**
* Handler for #GNUNET_MESSAGE_TYPE_TESTBED_CREATEPEER messages
*
* @param cls identification of the client
* @param msg the actual message
*/
void
handle_peer_create (void *cls,
const struct GNUNET_TESTBED_PeerCreateMessage *msg)
{
struct GNUNET_SERVICE_Client *client = cls;
struct GNUNET_MQ_Envelope *env;
struct GNUNET_TESTBED_PeerCreateSuccessEventMessage *reply;
struct GNUNET_CONFIGURATION_Handle *cfg;
struct ForwardedOperationContext *fo_ctxt;
struct Route *route;
struct Peer *peer;
char *emsg;
uint32_t host_id;
uint32_t peer_id;
host_id = ntohl (msg->host_id);
peer_id = ntohl (msg->peer_id);
if (VALID_PEER_ID (peer_id))
{
(void) GNUNET_asprintf (&emsg,
"Peer with ID %u already exists",
peer_id);
GST_send_operation_fail_msg (client,
GNUNET_ntohll (msg->operation_id),
emsg);
GNUNET_free (emsg);
GNUNET_SERVICE_client_continue (client);
return;
}
if (UINT32_MAX == peer_id)
{
GST_send_operation_fail_msg (client,
GNUNET_ntohll (msg->operation_id),
"Cannot create peer with given ID");
GNUNET_SERVICE_client_continue (client);
return;
}
if (host_id == GST_context->host_id)
{
/* We are responsible for this peer */
cfg = GNUNET_TESTBED_extract_config_ (&msg->header);
if (NULL == cfg)
{
GNUNET_break (0);
GNUNET_SERVICE_client_drop (client);
return;
}
GNUNET_CONFIGURATION_set_value_number (cfg,
"TESTBED",
"PEERID",
(unsigned long long) peer_id);
GNUNET_CONFIGURATION_set_value_number (cfg,
"PATHS",
"PEERID",
(unsigned long long) peer_id);
peer = GNUNET_new (struct Peer);
peer->is_remote = GNUNET_NO;
peer->details.local.cfg = cfg;
peer->id = peer_id;
LOG_DEBUG ("Creating peer with id: %u\n",
(unsigned int) peer->id);
peer->details.local.peer =
GNUNET_TESTING_peer_configure (GST_context->system,
peer->details.local.cfg, peer->id,
NULL /* Peer id */ ,
&emsg);
if (NULL == peer->details.local.peer)
{
LOG (GNUNET_ERROR_TYPE_WARNING,
"Configuring peer failed: %s\n",
emsg);
GNUNET_free (emsg);
GNUNET_free (peer);
GNUNET_break (0);
GNUNET_SERVICE_client_drop (client);
return;
}
peer->details.local.is_running = GNUNET_NO;
peer_list_add (peer);
env = GNUNET_MQ_msg (reply,
GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS);
reply->peer_id = msg->peer_id;
reply->operation_id = msg->operation_id;
GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
env);
GNUNET_SERVICE_client_continue (client);
return;
}
/*
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;
}
