/*---------------------------------------------------------------------------*/
PROCESS_THREAD(main_process, ev, data)
{
PROCESS_BEGIN();
INIT_NETWORK_DEBUG();
{
// Due to the way Contiki protothreads work this needs to be static,
// otherwise the data will be lost when switching to a different thread
static struct uip_udp_conn * conn;
static char buffer[BUFFER_SIZE];
static int i = 0;
PRINTF("===START===\n");
conn = udp_new_connection(CLIENT_PORT, SERVER_PORT, SERVER_IP_ADDR);
while(1)
{
i++;
sprintf(buffer, "Hello number %i from client", i);
PRINTF("Sending data: %s\n", buffer);
udp_packet_send(conn, buffer, strlen(buffer));
PROCESS_WAIT_UDP_SENT();
}
}
PROCESS_END();
}
/*
* Decode UDP packet according to the given instructions!
*/
void udp_packet_decode(char * packet, char * fromIP){
struct dir_files_status_list *currTmp, *watchedTmp, *result;
char pak[MAXBUF];
char fileSHA[SHA1_BYTES_LEN];
off_t file_len;
int64_t clk, mod_time;
char FromClient[255], file_name[255];
uint16_t tcp_port;
int count =3 , i=0;
char tmp[2], *file_full_path;
/* First Decode each field and then print */
memcpy(pak, packet,MAXBUF);
tmp[0] = pak[0];
tmp[1] = pak[1];
if(pak[2] != 0)
perror("Not a Valid Message Field Client_name\n");
while(pak[count] != 0){
FromClient[i++] = pak[count++];
}FromClient[i] = '\0';
count++;
memcpy(&tcp_port, &pak[count], 2);
count+=2;
memcpy(&clk, &pak[count],8);
count+=8;
if( (tmp[0] >= 3) && (tmp[0] <= 7)){
memcpy(&mod_time, &pak[count], 8);
count += 9;
i=0;
while(pak[count] != 0){
file_name[i++] = pak[count++];
}file_name[i] = '\0';
count++;
memcpy(fileSHA, &pak[count], SHA1_BYTES_LEN);
count+=SHA1_BYTES_LEN;
memcpy(&file_len, &pak[count], 8);
count+=8;
}
/* Get the Lock and start printing!*/
pthread_mutex_lock(&print_mutex);
switch(tmp[0]){
case(1):
printf("\n\tSTATUS_MSG \n");
break;
case(2):
printf("\n\tNO_CHANGES_MSG \n");
break;
case(3):
printf("\n\tNEW_FILE_MSG \n");
pthread_mutex_lock(&file_list_mutex);
watchedTmp = watched_files;
currTmp = (struct dir_files_status_list * ) malloc( sizeof (struct dir_files_status_list));
if (!currTmp) {
fprintf(stderr, "malloc() failed: insufficient memory!\n");
exit(EXIT_FAILURE);
}
currTmp->filename = (char *) malloc(strlen(file_name));
if (!currTmp->filename) {
fprintf(stderr, "malloc() failed: insufficient memory!\n");
exit(EXIT_FAILURE);
}
strcpy(currTmp->filename, file_name);
SGLIB_LIST_FIND_MEMBER(struct dir_files_status_list, watchedTmp, currTmp, ILIST_COMPARATOR, next, result);
/* Case 1: the client does not have the file */
if(result == NULL){
/* Add file to the list and wait until its received to compare the SHA */
currTmp->size_in_bytes = file_len;
currTmp->modifictation_time_from_epoch = mod_time;
/* deep copy */
for(i = 0; i < SHA1_BYTES_LEN; i++)
currTmp->sha1sum[i] = fileSHA[i];
SGLIB_SORTED_LIST_ADD(struct dir_files_status_list, watched_files, currTmp, ILIST_COMPARATOR, next);
/* Ask for Transfer! */
i = udp_file_packet_encode(FILE_TRANSFER_REQUEST,client_name,TCP_PORT,&clk,&mod_time, file_name,fileSHA,file_len);
currTmp->processed = TRUE;
udp_packet_send(i);
currTmp->processed = FALSE;
}
/* Case 2: the client DOES have the file listed */
else{
if(result->modifictation_time_from_epoch < mod_time){
/* Ask for Transfer! */
i = udp_file_packet_encode(FILE_TRANSFER_REQUEST,client_name,TCP_PORT,&clk,&mod_time, file_name,fileSHA,file_len);
currTmp->processed = TRUE;
udp_packet_send(i);
currTmp->processed = FALSE;
}
free(currTmp);
}
pthread_mutex_unlock(&file_list_mutex);
break;
case(4):
printf("\n\tFILE_CHANGED_MSG \n");
pthread_mutex_lock(&file_list_mutex);
watchedTmp = watched_files;
currTmp = (struct dir_files_status_list * ) malloc( sizeof (struct dir_files_status_list));
if (!currTmp) {
fprintf(stderr, "malloc() failed: insufficient memory!\n");
exit(EXIT_FAILURE);
}
currTmp->filename = (char *) malloc(strlen(file_name));
if (!currTmp->filename) {
fprintf(stderr, "malloc() failed: insufficient memory!\n");
exit(EXIT_FAILURE);
}
strcpy(currTmp->filename, file_name);
SGLIB_LIST_FIND_MEMBER(struct dir_files_status_list, watchedTmp, currTmp, ILIST_COMPARATOR, next, result);
/* Case 1: the client does not have the file, so add and transfer */
if(result == NULL){
/* Add file to the list and wait until its received to compare the SHA */
currTmp->size_in_bytes = file_len;
currTmp->modifictation_time_from_epoch = mod_time;
/* deep copy */
for(i = 0; i < SHA1_BYTES_LEN; i++)
currTmp->sha1sum[i] = fileSHA[i];
SGLIB_SORTED_LIST_ADD(struct dir_files_status_list, watched_files, currTmp, ILIST_COMPARATOR, next);
/* Ask for Transfer! */
i = udp_file_packet_encode(FILE_TRANSFER_REQUEST,client_name,TCP_PORT,&clk,&mod_time, file_name,fileSHA,file_len);
/* file does not exist so its ok to set processed without checking */
currTmp->processed = TRUE;
udp_packet_send(i);
currTmp->processed = FALSE;
}
/* Case 2: the client DOES have the file listed so update it!*/
else{
/*Check timestamp */
if(result->modifictation_time_from_epoch < mod_time){
/* Add file to the list and wait until its received to compare the SHA */
result->size_in_bytes = file_len;
result->modifictation_time_from_epoch = mod_time;
/* deep copy */
for(i = 0; i < SHA1_BYTES_LEN; i++)
result->sha1sum[i] = fileSHA[i];
/* Ask for Transfer! */
i = udp_file_packet_encode(FILE_TRANSFER_REQUEST,client_name,TCP_PORT,&clk,&mod_time, file_name,fileSHA,file_len);
if (result->processed == FALSE){
result->processed = TRUE;
udp_packet_send(i);
result->processed = FALSE;
}
}
free(currTmp);
}
pthread_mutex_unlock(&file_list_mutex);
break;
case(5):
printf("\n\tFILE_DELETED_MSG \n");
pthread_mutex_lock(&file_list_mutex);
watchedTmp = watched_files;
currTmp = (struct dir_files_status_list * ) malloc( sizeof (struct dir_files_status_list));
if (!currTmp) {
fprintf(stderr, "malloc() failed: insufficient memory!\n");
exit(EXIT_FAILURE);
}
currTmp->filename = (char *) malloc(strlen(file_name));
if (!currTmp->filename) {
fprintf(stderr, "malloc() failed: insufficient memory!\n");
exit(EXIT_FAILURE);
}
strcpy(currTmp->filename, file_name);
SGLIB_LIST_FIND_MEMBER(struct dir_files_status_list, watchedTmp, currTmp, ILIST_COMPARATOR, next, result);
/* Case 1: the client does have the file */
if(result != NULL){
/* Check file similarity! */
if((file_len == result->size_in_bytes) && (compare_sha1(result->sha1sum,fileSHA) == 0))
{
/* remove from dir */
file_full_path = (char * )malloc(strlen(file_name) + strlen(watched_dir)+1);
strcpy(file_full_path,watched_dir);
strcat(file_full_path,file_name);
/*now remove from list*/
if (result->processed == FALSE){
result->processed = TRUE;
if(remove(file_full_path) != 0 ){
fprintf(stderr,"[Cloudbox] Error deleting file %s\n",file_full_path);
exit(EXIT_FAILURE);
}
SGLIB_LIST_DELETE(struct dir_files_status_list, watchedTmp, result, next);
result->processed = FALSE;
}
free(file_full_path);
}
}
/* Case 2: the client DOES NOT have the file Deleted */
else{
free(currTmp);
}
pthread_mutex_unlock(&file_list_mutex);
break;
case(6):
printf("\n\tFILE_TRANSFER_REQUEST \n");
pthread_mutex_lock(&file_list_mutex);
watchedTmp = watched_files;
currTmp = (struct dir_files_status_list * ) malloc( sizeof (struct dir_files_status_list));
if (!currTmp) {
fprintf(stderr, "malloc() failed: insufficient memory!\n");
exit(EXIT_FAILURE);
}
currTmp->filename = (char *) malloc(strlen(file_name));
if (!currTmp->filename) {
fprintf(stderr, "malloc() failed: insufficient memory!\n");
exit(EXIT_FAILURE);
}
strcpy(currTmp->filename, file_name);
SGLIB_LIST_FIND_MEMBER(struct dir_files_status_list, watchedTmp, currTmp, ILIST_COMPARATOR, next, result);
if((result != NULL) && (compare_sha1(result->sha1sum,fileSHA) == 0) ){
/* its my file the other client is looking for!
*/
if (result->processed == FALSE){
result->processed = TRUE;
send_file(fromIP, tcp_port, file_name);
result->processed = FALSE;
}
}
pthread_mutex_unlock(&file_list_mutex);
free(currTmp->filename);
free(currTmp);
break;
case(7):
printf("\n\tFILE_TRANSFER_OFFER \n");
pthread_mutex_lock(&file_list_mutex);
watchedTmp = watched_files;
currTmp = (struct dir_files_status_list * ) malloc( sizeof (struct dir_files_status_list));
if (!currTmp) {
fprintf(stderr, "malloc() failed: insufficient memory!\n");
exit(EXIT_FAILURE);
}
currTmp->filename = (char *) malloc(strlen(file_name));
if (!currTmp->filename) {
fprintf(stderr, "malloc() failed: insufficient memory!\n");
exit(EXIT_FAILURE);
}
strcpy(currTmp->filename, file_name);
SGLIB_LIST_FIND_MEMBER(struct dir_files_status_list, watchedTmp, currTmp, ILIST_COMPARATOR, next, result);
/* Case 1: the client does not have the file */
if(result == NULL){
/* Add file to the list and wait until its received to compare the SHA */
currTmp->size_in_bytes = file_len;
currTmp->modifictation_time_from_epoch = mod_time;
/* deep copy */
for(i = 0; i < SHA1_BYTES_LEN; i++)
currTmp->sha1sum[i] = fileSHA[i];
SGLIB_SORTED_LIST_ADD(struct dir_files_status_list, watched_files, currTmp, ILIST_COMPARATOR, next);
/* Ask for Transfer! */
i = udp_file_packet_encode(FILE_TRANSFER_REQUEST,client_name,TCP_PORT,&clk,&mod_time, file_name,fileSHA,file_len);
currTmp->processed = TRUE;
udp_packet_send(i);
currTmp->processed = FALSE;
}
/* Case 2: the client DOES have the file listed */
else{
free(currTmp);
}
pthread_mutex_unlock(&file_list_mutex);
break;
case(8):
printf("\n\tDIR_EMPTY \n");
pthread_mutex_unlock(&print_mutex);
/* sleep is useful in case we remove all files from directory and we have both DELETE FILE and EMPTY DIR messages */
sleep(2);
watchedTmp = listWatchedDir(watched_dir);
watched_files = watchedTmp;
pthread_mutex_lock(&print_mutex);
pthread_mutex_lock(&file_list_mutex);
currTmp = (struct dir_files_status_list * ) malloc( sizeof (struct dir_files_status_list));
if (!currTmp) {
fprintf(stderr, "malloc() failed: insufficient memory!\n");
exit(EXIT_FAILURE);
}
int listlen=0;
SGLIB_LIST_LEN(struct dir_files_status_list,watchedTmp,next, listlen);
UNUSED(currTmp);
/* If other client is empty start updating him */
if(listlen > 0){
SGLIB_LIST_MAP_ON_ELEMENTS(struct dir_files_status_list, watchedTmp, currTmp, next, {
/* Offer file! */
i = udp_file_packet_encode(FILE_TRANSFER_OFFER,client_name,TCP_PORT,&clk,&currTmp->modifictation_time_from_epoch, currTmp->filename,currTmp->sha1sum,currTmp->size_in_bytes);
if (currTmp->processed == FALSE){
currTmp->processed = TRUE;
udp_packet_send(i);
currTmp->processed = FALSE;
}
});
