Properly terminating a receiver that has not yet received anything.

src/prrt/processes/data_receiver.c

@@ -79,6 +79,7 @@ void * receive_data_loop(void *ptr) {
     while (1) {
         memset(buffer, 0, MAX_PAYLOAD_LENGTH);
         n = recvfrom(sock_ptr->dataSocketFd, buffer, MAX_PAYLOAD_LENGTH, 0, (struct sockaddr *) &remote, &addrlen);
+        printf("RECEIVED: %d\n", n);
         check(send_feedback(sock_ptr, remote) == EXIT_SUCCESS, "Sending feedback failed.");
 
         packet = calloc(1, sizeof(PrrtPacket));

src/prrt/socket.c

@@ -23,7 +23,10 @@ int PrrtSocket_create(PrrtSocket *sock_ptr, const uint16_t port, const uint8_t i
     check(sock_ptr->dataSocketFd = socket(AF_INET, SOCK_DGRAM, 0), "Cannot create data socket.")
     check(sock_ptr->feedbackSocketFd = socket(AF_INET, SOCK_DGRAM, 0), "Cannot create feedback socket.");
 
-    pthread_mutex_init(&sock_ptr->closingMutex, NULL);
+    pthread_mutexattr_t attr;
+    pthread_mutexattr_init(&attr);
+    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+    pthread_mutex_init(&sock_ptr->closingMutex, &attr);
 
     if (is_sender) {
         // Bind Feedback Socket
@@ -97,11 +100,20 @@ int PrrtSocket_send(PrrtSocket *sock_ptr, const void *data, const size_t data_le
         return -1;
 }
 
-uint32_t PrrtSocket_recv(PrrtSocket *sock_ptr, void *buf_ptr) {
+int32_t PrrtSocket_recv(PrrtSocket *sock_ptr, void *buf_ptr) {
     pthread_mutex_t t = sock_ptr->inQueueFilledMutex;
     while (1) {
         pthread_mutex_lock(&t);
         while (List_count(sock_ptr->inQueue) == 0) {
+            pthread_mutex_lock(&sock_ptr->closingMutex);
+            if(sock_ptr->closing) {
+                // TODO: proper close
+                printf("CLOSE PROCESS");
+                pthread_mutex_unlock(&sock_ptr->closingMutex);
+                pthread_mutex_unlock(&t);
+                return -1;
+            }
+            pthread_mutex_unlock(&sock_ptr->closingMutex);
             pthread_cond_wait(&sock_ptr->inQueueFilledMutexCv, &t);
         }
 
@@ -117,11 +129,47 @@ uint32_t PrrtSocket_recv(PrrtSocket *sock_ptr, void *buf_ptr) {
     }
 }
 
-int PrrtSocket_close(PrrtSocket *sock_ptr) {
+int PrrtSocket_interrupt(PrrtSocket *sock_ptr) {
     pthread_mutex_lock(&sock_ptr->closingMutex);
     sock_ptr->closing = TRUE;
     pthread_mutex_unlock(&sock_ptr->closingMutex);
 
+    void **res = NULL;
+    if(sock_ptr->sendThread != 0) {
+        pthread_mutex_lock(&sock_ptr->outQueueFilledMutex);
+        pthread_cond_signal(&sock_ptr->outQueueFilledCv);
+        pthread_mutex_unlock(&sock_ptr->outQueueFilledMutex);
+
+        pthread_join(sock_ptr->sendThread, res);
+        sock_ptr->sendThread = 0;
+    }
+
+    if(sock_ptr->receiveDataThread != 0) {
+        pthread_mutex_lock(&sock_ptr->inQueueFilledMutex);
+        pthread_cond_signal(&sock_ptr->inQueueFilledMutexCv);
+        pthread_mutex_unlock(&sock_ptr->inQueueFilledMutex);
+
+        pthread_cancel(sock_ptr->receiveDataThread);
+        pthread_join(sock_ptr->receiveDataThread, res);
+
+        sock_ptr->receiveDataThread = 0;
+    }
+
+    if(sock_ptr->receiveFeedbackThread != 0) {
+        pthread_cancel(sock_ptr->receiveFeedbackThread);
+        pthread_join(sock_ptr->receiveFeedbackThread, res);
+
+        sock_ptr->receiveFeedbackThread = 0;
+    }
+}
+
+int PrrtSocket_close(PrrtSocket *sock_ptr) {
+    pthread_mutex_lock(&sock_ptr->closingMutex);
+    if(!sock_ptr->closing) {
+        PrrtSocket_interrupt(sock_ptr);
+    }
+    pthread_mutex_unlock(&sock_ptr->closingMutex);
+
     if(sock_ptr->dataStore != NULL) {
         sock_ptr->dataStore = BPTree_destroy(sock_ptr->dataStore);
     }
@@ -135,34 +183,26 @@ int PrrtSocket_close(PrrtSocket *sock_ptr) {
             free(List_shift(sock_ptr->receivers));
         }
         List_destroy(sock_ptr->receivers);
-    }
-
-    void **res = NULL;
-    if(sock_ptr->sendThread != 0) {
-        pthread_mutex_lock(&sock_ptr->outQueueFilledMutex);
-        pthread_cond_signal(&sock_ptr->outQueueFilledCv);
-        pthread_mutex_unlock(&sock_ptr->outQueueFilledMutex);
-
-        pthread_join(sock_ptr->sendThread, res);
-    }
-
-    // TODO: shut down receiver threads
-    
-    if(sock_ptr->receiveFeedbackThread != 0) {
-        pthread_cancel(sock_ptr->receiveFeedbackThread);
-        pthread_join(sock_ptr->receiveFeedbackThread, res);
+        sock_ptr->receivers = NULL;
     }
 
     if(sock_ptr->outQueue != NULL) {
         pthread_mutex_destroy(&sock_ptr->outQueueFilledMutex);
         pthread_cond_destroy(&sock_ptr->outQueueFilledCv);
         List_destroy(sock_ptr->outQueue);
+        sock_ptr->outQueue = NULL;
     }
 
     if(sock_ptr->inQueue != NULL) {
         pthread_mutex_destroy(&sock_ptr->inQueueFilledMutex);
         pthread_cond_destroy(&sock_ptr->inQueueFilledMutexCv);
         List_destroy(sock_ptr->inQueue);
+        sock_ptr->inQueue = NULL;
+    }
+
+    if(sock_ptr->forwardPacketTable != NULL ){
+        free(sock_ptr->forwardPacketTable);
+        sock_ptr->forwardPacketTable = NULL;
     }
 
     pthread_mutex_destroy(&sock_ptr->closingMutex);

src/prrt/socket.h

@@ -47,10 +47,11 @@ typedef struct {
 
 
 int PrrtSocket_create(PrrtSocket *sock_ptr, const uint16_t port, const uint8_t is_sender);
+int PrrtSocket_interrupt(PrrtSocket *sock_ptr);
 int PrrtSocket_close(PrrtSocket *sock_ptr);
 int PrrtSocket_connect(PrrtSocket *sock_ptr, const char *host, const uint16_t port);
 int PrrtSocket_send(PrrtSocket *sock_ptr, const void *data, const size_t data_len);
-uint32_t PrrtSocket_recv(PrrtSocket *sock_ptr, void *buf_ptr);
+int32_t PrrtSocket_recv(PrrtSocket *sock_ptr, void *buf_ptr);
 PrrtPacket *PrrtSocket_recv_feedback(const PrrtSocket *sock_ptr, void *bufin, const size_t length);
 
 #endif // PRRT_SOCKET_H

src/prrt/stores/forward_packet_table.c

@@ -41,10 +41,6 @@ int PrrtForwardPacketTable_create(PrrtForwardPacketTable *fpt_prt) {
     memset(fpt_prt->data, 0, sizeof(fpt_prt->data));
 }
 
-int PrrtForwardPacketTable_destroy(PrrtForwardPacketTable* fpt_prt) {
-
-}
-
 int PrrtForwardPacketTable_test_set_is_number_relevant(PrrtForwardPacketTable *fpt_ptr, uint16_t seqno) {
     int res = check_position(fpt_ptr, seqno);
 

src/prrt/stores/forward_packet_table.h

@@ -17,6 +17,4 @@ int PrrtForwardPacketTable_test_set_is_number_relevant(PrrtForwardPacketTable *f
 
 int PrrtForwardPacketTable_test_is_block_relevant(PrrtForwardPacketTable * forwardPacketTable, uint16_t start, uint16_t length);
 
-int PrrtForwardPacketTable_destroy(PrrtForwardPacketTable* fpt_prt);
-
 #endif //PRRT_FORWARD_PACKET_TABLE_H

src/receiver.c

 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
+#include <signal.h>
 #include "prrt/socket.h"
 
+PrrtSocket sock;
+static volatile int keepRunning = 1;
+
+void intHandler(int dummy) {
+    keepRunning = 0;
+    PrrtSocket_interrupt(&sock);
+}
+
 int main(int argc, char* const argv[]) {
+    signal(SIGINT, intHandler);
+
     if(argc != 2) {
         printf("Too few arguments.\n");
         return -1;
@@ -11,7 +22,6 @@ int main(int argc, char* const argv[]) {
 
     uint16_t port = (uint16_t) atoi(argv[1]);
 
-    PrrtSocket sock;
     printf("PRRT - RECEIVER\n");
 
     if(PrrtSocket_create(&sock, port, 0) < 0) {
@@ -20,9 +30,12 @@ int main(int argc, char* const argv[]) {
     }
 
     int i = 1;
-    while(1) {
+    while(keepRunning) {
         unsigned char buffer[MAX_PAYLOAD_LENGTH];
         int n = PrrtSocket_recv(&sock, buffer);
+        if(n < 0 ) {
+            continue;
+        }
         buffer[n] = '\0';
         printf("[B (n: %d, i: %3d)] %s", n, i, buffer);
         i++;
@@ -30,8 +43,5 @@ int main(int argc, char* const argv[]) {
     }
 
     PrrtSocket_close(&sock);
-
-    pthread_exit(NULL);
-
     return 0;
 }

tests/forward_packet_table_tests.cpp

@@ -16,8 +16,7 @@ protected:
 
 TEST_F(ForwardPacketTableTest, CreateDestroy) {
     ASSERT_EQ(forwardPacketTable->start, 1);
-
-    PrrtForwardPacketTable_destroy(forwardPacketTable);
+    free(forwardPacketTable);
 }
 
 TEST_F(ForwardPacketTableTest, SimpleTestAndSet) {