heck yea

A4/src/cascade.c

@@ -22,6 +22,9 @@ char tracker_port[PORT_LEN];
 char my_ip[IP_LEN];
 char my_port[PORT_LEN];
 
+csc_file_t* cascade_files[64];
+int cascade_amount;
+
 /*
  * Frees global resources that are malloc'ed during peer downloads.
  */
@@ -498,27 +501,105 @@ int send_tracker_request(csc_peer_t** peers, uint8_t hash[32], int command)
 
 void service_block_request(void* arg) {
     block_request_t* request = (block_request_t*)arg;
-    printf("servicing block request for %s\n",request->casc_file->outputfile);
+    printf("servicing block request.\n");
 
-    char request_header[HEADER_SIZE];
-    memcpy(request_header, request->request, HEADER_SIZE);
+    char request_header[32];
+    memcpy(request_header, request->request, 32);
 
-    if (!memcmp(request_header, "CASCADE1",8)) {
-        // send error
+    if (memcmp(request_header, "CASCADE1", 8) != 0) {
+        char response[9];
+        response[0] = 4;
+        for (int j = 1 ; j < 9; j++) {
+            response[j] = 0;
+        }
+        Rio_writen(request->socket,&response,9);
         close(request->socket);
         return;
     }
 
-    if (!memcmp(request_header[8], 0, 16)) {
-        // send error
+    for (int i = 8;i<16;i++) {
+        if ((int)request_header[i] != 0) {
+            char response[9];
+            response[0] = 4;
+            for (int j = 1 ; j < 9; j++) {
+                response[j] = 0;
+            }
+            Rio_writen(request->socket,&response,9);
             close(request->socket);
             return;
         }
+    }
+
+    uint64_t block_number = be64toh(*((unsigned long long*)&request_header[24]));
+
+    unsigned char hash[32];
+    memcpy(hash, &(request->request[32]), 32);
+    csc_file_t* casc_file = NULL;
+
+    for (int i = 0; i < cascade_amount; i++){
+        if (memcmp(cascade_files[i]->cascadehash,hash,32) == 0) {
+            casc_file = cascade_files[i];
+            break;
+        }
+    }
+
+    if (casc_file == NULL) {
+        char response[9];
+        response[0] = 1;
+        for (int j = 1 ; j < 9; j++) {
+            response[j] = 0;
+        }
+        Rio_writen(request->socket,&response,9);
+        close(request->socket);
+        return;
+    }
+
+    if (block_number >= casc_file->blockcount) {
+        char response[9];
+        response[0] = 3;
+        for (int j = 1 ; j < 9; j++) {
+            response[j] = 0;
+        }
+        Rio_writen(request->socket,&response,9);
+        close(request->socket);
+        return;
+    }
+
+    csc_block_t* block = (&casc_file->blocks[block_number]);
+
+    pthread_mutex_lock(&casc_file->mutex);
+
+    if (!block->completed) {
+        char response[9];
+        response[0] = 2;
+        for (int j = 1 ; j < 9; j++) {
+            response[j] = 0;
+        }
+        Rio_writen(request->socket,&response,9);
+        pthread_mutex_unlock(&casc_file->mutex);
+        close(request->socket);
+        return;
+    }
+
+    FILE* fp = fopen(casc_file->outputfile, "rb+");
+    fseek(fp, block->offset, SEEK_SET);
+    char buffer[block->length];
+    fread(&buffer,1,block->length,fp);
+    fclose(fp);
+    pthread_mutex_unlock(&casc_file->mutex);
+    char response[9 + block->length];
+    response[0] = 0;
+    char* block_length = be64toh(block->length);
+    memcpy(&response[1],&block_length,8);
+    memcpy(&response[9],buffer,block->length);
+
+    Rio_writen(request->socket, &response, 9+block->length);
+
+    close(request->socket);
 
 }
 
-void server_mt(void* arg) {
-    csc_file_t* casc_file = (csc_file_t*)arg;
+void server_mt() {
     char rio_buf[64];
 
     int socket = open_listenfd(my_port);
@@ -529,17 +610,17 @@ void server_mt(void* arg) {
         rio_t rio;
         int new_socket = Accept(socket, peer_address, &address_length);
         Rio_readinitb(&rio, new_socket);
-        Rio_readnb(&rio, rio_buf, MAXLINE);
+        Rio_readnb(&rio, rio_buf, 64);
 
         pthread_t request_handler;
         block_request_t* request = malloc(sizeof(block_request_t));
         memcpy(request->request,rio_buf,64);
         request->peer_address = peer_address;
-        request->casc_file = casc_file;
         request->rio = rio;
         request->socket = new_socket;
         
         pthread_create(&request_handler, NULL, service_block_request, (void*)request);
+        //pthread_join(&request_handler, NULL);
     }
 }
 
@@ -582,13 +663,16 @@ void client_mt(void* arg) {
 
         for (int i=0; i<uncomp_count; i++)
         {
+            pthread_mutex_lock(&casc_file->mutex);
             get_block(queue[i], peer, casc_file->cascadehash, casc_file->outputfile);
+            pthread_mutex_unlock(&casc_file->mutex);
         }
 
         printf("\n");
+        pthread_mutex_lock(&casc_file->mutex);
         casc_file = check_blocks(casc_file);
+        pthread_mutex_unlock(&casc_file->mutex);
 
-        check_blocks(casc_file);
         if (!casc_file->completed) {
             send_tracker_request(&(casc_file->peers), casc_file->cascadehash,1);
         }
@@ -611,6 +695,9 @@ void start_peer(char* cascade_file){
     csc_file_t *casc_file;
     casc_file = csc_parse_file(cascade_file);
 
+    cascade_files[cascade_amount] = casc_file;
+    cascade_amount++;
+
     // start client and server on separate threads
     pthread_t client;
 
@@ -620,7 +707,6 @@ void start_peer(char* cascade_file){
 
 
     pthread_create(&client, NULL, client_mt, (void*)casc_file);
-    pthread_join(client, NULL);
 }
 
 /*
@@ -685,12 +771,14 @@ int main(int argc, char **argv)
     }
 
     pthread_t server;
-    pthread_create(&server, NULL, server_mt, (void*)casc_file);
+    pthread_create(&server, NULL, server_mt, NULL);
 
     for (int j=0; j<casc_count; j++)
     {
         start_peer(cascade_files[j]);
     }
 
+    pthread_join(server, NULL);
+
     exit(EXIT_SUCCESS);
 }

A4/src/cascade.h

@@ -84,7 +84,6 @@ typedef struct csc_file {
 
 typedef struct block_request {
     char request[64];
-    csc_file_t* casc_file;
     struct sockaddr* peer_address;
     rio_t rio;
     int socket;