Passed everything through astyle.

1 files changed, 142 insertions, 105 deletions

diff --git a/core/Lossless_UDP.c b/core/Lossless_UDP.c
index 002e2cf8..fa5f9144 100644
--- a/core/Lossless_UDP.c
+++ b/core/Lossless_UDP.c
@@ -21,7 +21,7 @@
  *
  */
 
-/* 
+/*
  * TODO: clean this file a bit.
  * There are a couple of useless variables to get rid of.
  */
@@ -59,9 +59,9 @@ typedef struct {
      */
     uint8_t status;
 
-    /* 
+    /*
      * 1 or 2 if connection was initiated by someone else, 0 if not.
-     * 2 if incoming_connection() has not returned it yet, 1 if it has. 
+     * 2 if incoming_connection() has not returned it yet, 1 if it has.
      */
     uint8_t inbound;
 
@@ -81,31 +81,31 @@ typedef struct {
     uint32_t  handshake_id2;
 
     /* number of data packets received (also used as handshake_id1) */
-    uint32_t  recv_packetnum; 
+    uint32_t  recv_packetnum;
 
     /* number of packets received by the other peer */
     uint32_t  orecv_packetnum;
 
     /* number of data packets sent */
-    uint32_t  sent_packetnum; 
+    uint32_t  sent_packetnum;
 
     /* number of packets sent by the other peer. */
-    uint32_t  osent_packetnum; 
+    uint32_t  osent_packetnum;
 
     /* number of latest packet written onto the sendbuffer */
     uint32_t  sendbuff_packetnum;
 
     /* we know all packets before that number were successfully sent */
-    uint32_t  successful_sent; 
+    uint32_t  successful_sent;
 
     /* packet number of last packet read with the read_packet function */
-    uint32_t  successful_read; 
+    uint32_t  successful_read;
 
     /* list of currently requested packet numbers(by the other person) */
-    uint32_t  req_packets[BUFFER_PACKET_NUM]; 
+    uint32_t  req_packets[BUFFER_PACKET_NUM];
 
     /* total number of currently requested packets(by the other person) */
-    uint16_t  num_req_paquets;  
+    uint16_t  num_req_paquets;
 
     uint8_t   recv_counter;
     uint8_t   send_counter;
@@ -113,7 +113,7 @@ typedef struct {
 } Connection;
 
 
-static Connection * connections;
+static Connection *connections;
 
 static uint32_t connections_length; /* Length of connections array */
 static uint32_t connections_number; /* Number of connections in connections array */
@@ -122,7 +122,7 @@ static uint32_t connections_number; /* Number of connections in connections arra
 
 /* Functions */
 
-/* 
+/*
  * Get connection id from IP_Port
  * Return -1 if there are no connections like we are looking for
  * Return id if it found it
@@ -130,10 +130,11 @@ static uint32_t connections_number; /* Number of connections in connections arra
 int getconnection_id(IP_Port ip_port)
 {
     uint32_t i;
+
     for (i = 0; i < MAX_CONNECTIONS; ++i) {
         if (connections[i].ip_port.ip.i == ip_port.ip.i &&
-            connections[i].ip_port.port == ip_port.port && 
-            connections[i].status > 0)
+                connections[i].ip_port.port == ip_port.port &&
+                connections[i].status > 0)
             return i;
     }
 
@@ -143,7 +144,7 @@ int getconnection_id(IP_Port ip_port)
 /* table of random numbers used below. */
 static uint32_t randtable[6][256];
 
-/* 
+/*
  * Generate a handshake_id which depends on the ip_port.
  * This function will always give one unique handshake_id per ip_port.
  *
@@ -152,18 +153,21 @@ static uint32_t randtable[6][256];
 static uint32_t handshake_id(IP_Port source)
 {
     uint32_t id = 0, i;
+
     for (i = 0; i < 6; ++i) {
-        if(randtable[i][((uint8_t *)&source)[i]] == 0)
+        if (randtable[i][((uint8_t *)&source)[i]] == 0)
             randtable[i][((uint8_t *)&source)[i]] = random_int();
+
         id ^= randtable[i][((uint8_t *)&source)[i]];
     }
+
     if (id == 0) /* id can't be zero */
         id = 1;
 
     return id;
 }
 
-/* 
+/*
  * Change the hanshake id associated with that ip_port
  *
  * TODO: make this better
@@ -174,7 +178,7 @@ static void change_handshake(IP_Port source)
     randtable[rand][((uint8_t *)&source)[rand]] = random_int();
 }
 
-/* 
+/*
  * Initialize a new connection to ip_port
  * Returns an integer corresponding to the connection idt
  * Return -1 if it could not initialize the connectiont
@@ -183,53 +187,56 @@ static void change_handshake(IP_Port source)
 int new_connection(IP_Port ip_port)
 {
     int connect = getconnection_id(ip_port);
+
     if (connect != -1)
         return connect;
-    
-    if(connections_number == connections_length) {
-        Connection * temp;
+
+    if (connections_number == connections_length) {
+        Connection *temp;
         temp = realloc(connections, sizeof(Connection) * (connections_length + 1));
 
-        if(temp == NULL)
+        if (temp == NULL)
             return -1;
 
         memset(&temp[connections_length], 0, sizeof(Connection));
         ++connections_length;
         connections = temp;
     }
-    
+
     uint32_t i;
+
     for (i = 0; i < MAX_CONNECTIONS; ++i) {
-        if(connections[i].status == 0) {
+        if (connections[i].status == 0) {
             memset(&connections[i], 0, sizeof(Connection));
             uint32_t handshake_id1 = handshake_id(ip_port);
 
             connections[i] = (Connection) {
-              .ip_port            = ip_port,
-              .status             = 1,
-              .inbound            = 0,
-              .handshake_id1      = handshake_id1,
-              .sent_packetnum     = handshake_id1,
-              .sendbuff_packetnum = handshake_id1,
-              .successful_sent    = handshake_id1,
-              .SYNC_rate          = SYNC_RATE,
-              .data_rate          = DATA_SYNC_RATE,
-              .last_recvSYNC      = current_time(),
-              .last_sent          = current_time(),
-              .killat             = ~0,
-              .send_counter       = 0,
-              /* add randomness to timeout to prevent connections getting stuck in a loop. */
-              .timeout            = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT
+                .ip_port            = ip_port,
+                 .status             = 1,
+                  .inbound            = 0,
+                   .handshake_id1      = handshake_id1,
+                    .sent_packetnum     = handshake_id1,
+                     .sendbuff_packetnum = handshake_id1,
+                      .successful_sent    = handshake_id1,
+                       .SYNC_rate          = SYNC_RATE,
+                        .data_rate          = DATA_SYNC_RATE,
+                         .last_recvSYNC      = current_time(),
+                          .last_sent          = current_time(),
+                           .killat             = ~0,
+                            .send_counter       = 0,
+                             /* add randomness to timeout to prevent connections getting stuck in a loop. */
+                             .timeout            = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT
             };
             ++connections_number;
 
             return i;
         }
     }
+
     return -1;
 }
 
-/* 
+/*
  * Initialize a new inbound connection from ip_port
  * Returns an integer corresponding to the connection id.
  * Return -1 if it could not initialize the connection.
@@ -238,55 +245,58 @@ static int new_inconnection(IP_Port ip_port)
 {
     if (getconnection_id(ip_port) != -1)
         return -1;
-    
-    if(connections_number == connections_length) {
-        Connection * temp;
+
+    if (connections_number == connections_length) {
+        Connection *temp;
         temp = realloc(connections, sizeof(Connection) * (connections_length + 1));
 
-        if(temp == NULL)
+        if (temp == NULL)
             return -1;
 
         memset(&temp[connections_length], 0, sizeof(Connection));
         ++connections_length;
         connections = temp;
     }
-    
+
     uint32_t i;
+
     for (i = 0; i < MAX_CONNECTIONS; ++i) {
         if (connections[i].status == 0) {
             memset(&connections[i], 0, sizeof(Connection));
             uint64_t timeout = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT;
 
-            connections[i] = (Connection){
+            connections[i] = (Connection) {
                 .ip_port       = ip_port,
-                .status        = 2,
-                .inbound       = 2,
-                .SYNC_rate     = SYNC_RATE,
-                .data_rate     = DATA_SYNC_RATE,
-                .last_recvSYNC = current_time(),
-                .last_sent     = current_time(),
-                .send_counter  = 127,
-
-                /* add randomness to timeout to prevent connections getting stuck in a loop. */
-                .timeout       = timeout,
-
-                /* if this connection isn't handled within the timeout kill it. */
-                .killat        = current_time() + 1000000UL*timeout
+                 .status        = 2,
+                  .inbound       = 2,
+                   .SYNC_rate     = SYNC_RATE,
+                    .data_rate     = DATA_SYNC_RATE,
+                     .last_recvSYNC = current_time(),
+                      .last_sent     = current_time(),
+                       .send_counter  = 127,
+
+                        /* add randomness to timeout to prevent connections getting stuck in a loop. */
+                        .timeout       = timeout,
+
+                         /* if this connection isn't handled within the timeout kill it. */
+                         .killat        = current_time() + 1000000UL * timeout
             };
             ++connections_number;
             return i;
         }
     }
+
     return -1;
 }
 
-/* 
+/*
  * Returns an integer corresponding to the next connection in our incoming connection list.
  * Return -1 if there are no new incoming connections in the list.
  */
 int incoming_connection(void)
 {
     uint32_t i;
+
     for (i = 0; i < MAX_CONNECTIONS; ++i) {
         if (connections[i].inbound == 2) {
             connections[i].inbound = 1;
@@ -301,23 +311,25 @@ int incoming_connection(void)
 static void free_connections(void)
 {
     uint32_t i;
-    for(i = connections_length; i != 0; --i)
+
+    for (i = connections_length; i != 0; --i)
         if (connections[i - 1].status != 0)
             break;
 
-    if(connections_length == i)
+    if (connections_length == i)
         return;
 
-    Connection * temp;
+    Connection *temp;
     temp = realloc(connections, sizeof(Connection) * i);
-    if(temp == NULL && i != 0)
+
+    if (temp == NULL && i != 0)
         return;
 
     connections = temp;
     connections_length = i;
 }
 
-/* 
+/*
  * Return -1 if it could not kill the connection.
  * Return 0 if killed successfully
  */
@@ -332,10 +344,11 @@ int kill_connection(int connection_id)
             return 0;
         }
     }
+
     return -1;
 }
 
-/* 
+/*
  * Kill connection in seconds.
  * Return -1 if it can not kill the connection.
  * Return 0 if it will kill it.
@@ -344,14 +357,15 @@ int kill_connection_in(int connection_id, uint32_t seconds)
 {
     if (connection_id >= 0 && connection_id < MAX_CONNECTIONS) {
         if (connections[connection_id].status > 0) {
-            connections[connection_id].killat = current_time() + 1000000UL*seconds;
+            connections[connection_id].killat = current_time() + 1000000UL * seconds;
             return 0;
         }
     }
+
     return -1;
 }
 
-/* 
+/*
  * Check if connection is connected:
  * Return 0 no.
  * Return 1 if attempting handshake.
@@ -363,6 +377,7 @@ int is_connected(int connection_id)
 {
     if (connection_id >= 0 && connection_id < MAX_CONNECTIONS)
         return connections[connection_id].status;
+
     return 0;
 }
 
@@ -371,6 +386,7 @@ IP_Port connection_ip(int connection_id)
 {
     if (connection_id >= 0 && connection_id < MAX_CONNECTIONS)
         return connections[connection_id].ip_port;
+
     IP_Port zero = {{{0}}, 0};
     return zero;
 }
@@ -380,6 +396,7 @@ uint32_t sendqueue(int connection_id)
 {
     if (connection_id < 0 || connection_id >= MAX_CONNECTIONS)
         return 0;
+
     return connections[connection_id].sendbuff_packetnum - connections[connection_id].successful_sent;
 }
 
@@ -388,6 +405,7 @@ uint32_t recvqueue(int connection_id)
 {
     if (connection_id < 0 || connection_id >= MAX_CONNECTIONS)
         return 0;
+
     return connections[connection_id].recv_packetnum - connections[connection_id].successful_read;
 }
 
@@ -406,7 +424,7 @@ char id_packet(int connection_id)
 
 /* return 0 if there is no received data in the buffer.
    return length of received packet if successful */
-int read_packet(int connection_id, uint8_t * data)
+int read_packet(int connection_id, uint8_t *data)
 {
     if (recvqueue(connection_id) != 0) {
         uint16_t index = connections[connection_id].successful_read % MAX_QUEUE_NUM;
@@ -416,14 +434,15 @@ int read_packet(int connection_id, uint8_t * data)
         connections[connection_id].recvbuffer[index].size = 0;
         return size;
     }
+
     return 0;
 }
 
-/* 
+/*
  * Return 0 if data could not be put in packet queue
  * Return 1 if data was put into the queue
  */
-int write_packet(int connection_id, uint8_t * data, uint32_t length)
+int write_packet(int connection_id, uint8_t *data, uint32_t length)
 {
     if (length > MAX_DATA_SIZE || length == 0)
         return 0;
@@ -440,31 +459,31 @@ int write_packet(int connection_id, uint8_t * data, uint32_t length)
 }
 
 /* put the packet numbers the we are missing in requested and return the number */
-uint32_t missing_packets(int connection_id, uint32_t * requested)
+uint32_t missing_packets(int connection_id, uint32_t *requested)
 {
     uint32_t number = 0;
     uint32_t i;
     uint32_t temp;
 
     /* don't request packets if the buffer is full. */
-    if (recvqueue(connection_id) >= (BUFFER_PACKET_NUM - 1)) 
+    if (recvqueue(connection_id) >= (BUFFER_PACKET_NUM - 1))
         return 0;
 
     for (i = connections[connection_id].recv_packetnum; i != connections[connection_id].osent_packetnum; i++) {
-        if(connections[connection_id].recvbuffer[i % MAX_QUEUE_NUM].size == 0) {
+        if (connections[connection_id].recvbuffer[i % MAX_QUEUE_NUM].size == 0) {
             temp = htonl(i);
             memcpy(requested + number, &temp, 4);
             ++number;
         }
     }
-    
-    if(number == 0)
+
+    if (number == 0)
         connections[connection_id].recv_packetnum = connections[connection_id].osent_packetnum;
 
     return number;
 }
 
-/* 
+/*
  * BEGIN Packet sending functions
  * One per packet type.
  * see http://wiki.tox.im/index.php/Lossless_UDP for more information.
@@ -486,7 +505,7 @@ static int send_handshake(IP_Port ip_port, uint32_t handshake_id1, uint32_t hand
 
 static int send_SYNC(uint32_t connection_id)
 {
-    uint8_t packet[(BUFFER_PACKET_NUM*4 + 4 + 4 + 2)];
+    uint8_t packet[(BUFFER_PACKET_NUM * 4 + 4 + 4 + 2)];
     uint16_t index = 0;
 
     IP_Port ip_port         = connections[connection_id].ip_port;
@@ -507,7 +526,7 @@ static int send_SYNC(uint32_t connection_id)
     index += 4;
     memcpy(packet + index, requested, 4 * number);
 
-    return sendpacket(ip_port, packet, (number*4 + 4 + 4 + 2));
+    return sendpacket(ip_port, packet, (number * 4 + 4 + 4 + 2));
 
 }
 
@@ -530,6 +549,7 @@ static int send_DATA(uint32_t connection_id)
 {
     int ret;
     uint32_t buffer[BUFFER_PACKET_NUM];
+
     if (connections[connection_id].num_req_paquets > 0) {
         ret = send_data_packet(connection_id, connections[connection_id].req_packets[0]);
         connections[connection_id].num_req_paquets--;
@@ -537,15 +557,17 @@ static int send_DATA(uint32_t connection_id)
         memcpy(connections[connection_id].req_packets, buffer, connections[connection_id].num_req_paquets * 4);
         return ret;
     }
+
     if (connections[connection_id].sendbuff_packetnum != connections[connection_id].sent_packetnum) {
         ret = send_data_packet(connection_id, connections[connection_id].sent_packetnum);
         connections[connection_id].sent_packetnum++;
         return ret;
     }
+
     return 0;
 }
 
-/* 
+/*
  * END of packet sending functions
  *
  *
@@ -555,7 +577,7 @@ static int send_DATA(uint32_t connection_id)
 
 
 /* Return 0 if handled correctly, 1 if packet is bad. */
-static int handle_handshake(IP_Port source, uint8_t * packet, uint32_t length)
+static int handle_handshake(IP_Port source, uint8_t *packet, uint32_t length)
 {
     if (length != (1 + 4 + 4))
         return 1;
@@ -573,11 +595,12 @@ static int handle_handshake(IP_Port source, uint8_t * packet, uint32_t length)
         send_handshake(source, handshake_id(source), handshake_id1);
         return 0;
     }
+
     if (is_connected(connection) != 1)
         return 1;
 
     /* if handshake_id2 is what we sent previously as handshake_id1 */
-    if (handshake_id2 == connections[connection].handshake_id1) { 
+    if (handshake_id2 == connections[connection].handshake_id1) {
         connections[connection].status = 2;
         /* NOTE: is this necessary?
         connections[connection].handshake_id2 = handshake_id1; */
@@ -595,9 +618,11 @@ static int SYNC_valid(uint32_t length)
 {
     if (length < 4 + 4 + 2)
         return 0;
-    if (length > (BUFFER_PACKET_NUM*4 + 4 + 4 + 2) ||
-        ((length - 4 - 4 - 2) % 4) != 0)
+
+    if (length > (BUFFER_PACKET_NUM * 4 + 4 + 4 + 2) ||
+            ((length - 4 - 4 - 2) % 4) != 0)
         return 0;
+
     return 1;
 }
 
@@ -606,6 +631,7 @@ static int handle_SYNC1(IP_Port source, uint32_t recv_packetnum, uint32_t sent_p
 {
     if (handshake_id(source) == recv_packetnum) {
         int x = new_inconnection(source);
+
         if (x != -1) {
             connections[x].orecv_packetnum    = recv_packetnum;
             connections[x].sent_packetnum     = recv_packetnum;
@@ -618,6 +644,7 @@ static int handle_SYNC1(IP_Port source, uint32_t recv_packetnum, uint32_t sent_p
             return x;
         }
     }
+
     return -1;
 }
 
@@ -632,11 +659,13 @@ static int handle_SYNC2(int connection_id, uint8_t counter, uint32_t recv_packet
         send_SYNC(connection_id);
         return 0;
     }
+
     return 1;
 }
 /* case 3 in handle_SYNC: */
-static int handle_SYNC3(int connection_id, uint8_t counter, uint32_t recv_packetnum, uint32_t sent_packetnum, uint32_t * req_packets,
-                 uint16_t number)
+static int handle_SYNC3(int connection_id, uint8_t counter, uint32_t recv_packetnum, uint32_t sent_packetnum,
+                        uint32_t  *req_packets,
+                        uint16_t number)
 {
     uint8_t comp_counter = (counter - connections[connection_id].recv_counter );
     uint32_t i, temp;
@@ -646,9 +675,9 @@ static int handle_SYNC3(int connection_id, uint8_t counter, uint32_t recv_packet
     uint32_t comp_2 = (sent_packetnum - connections[connection_id].osent_packetnum);
 
     /* packet valid */
-    if (comp_1 <= BUFFER_PACKET_NUM && 
-        comp_2 <= BUFFER_PACKET_NUM && 
-        comp_counter < 10 && comp_counter != 0) { 
+    if (comp_1 <= BUFFER_PACKET_NUM &&
+            comp_2 <= BUFFER_PACKET_NUM &&
+            comp_counter < 10 && comp_counter != 0) {
 
         connections[connection_id].orecv_packetnum = recv_packetnum;
         connections[connection_id].osent_packetnum = sent_packetnum;
@@ -666,6 +695,7 @@ static int handle_SYNC3(int connection_id, uint8_t counter, uint32_t recv_packet
         connections[connection_id].num_req_paquets = number;
         return 0;
     }
+
     return 1;
 }
 
@@ -680,12 +710,12 @@ static int handle_SYNC(IP_Port source, uint8_t *packet, uint32_t length)
     uint32_t temp;
     uint32_t recv_packetnum, sent_packetnum;
     uint32_t req_packets[BUFFER_PACKET_NUM];
-    uint16_t number = (length - 4 - 4 - 2)/ 4;
+    uint16_t number = (length - 4 - 4 - 2) / 4;
 
     memcpy(&counter, packet + 1, 1);
     memcpy(&temp, packet + 2, 4);
     recv_packetnum = ntohl(temp);
-    memcpy(&temp,packet + 6,  4);
+    memcpy(&temp, packet + 6,  4);
     sent_packetnum = ntohl(temp);
 
     if (number != 0)
@@ -695,17 +725,18 @@ static int handle_SYNC(IP_Port source, uint8_t *packet, uint32_t length)
         return handle_SYNC1(source, recv_packetnum, sent_packetnum);
 
     if (connections[connection].status ==  2)
-        return handle_SYNC2(connection, counter, 
+        return handle_SYNC2(connection, counter,
                             recv_packetnum, sent_packetnum);
 
     if (connections[connection].status ==  3)
-        return handle_SYNC3(connection, counter, recv_packetnum, 
+        return handle_SYNC3(connection, counter, recv_packetnum,
                             sent_packetnum, req_packets, number);
+
     return 0;
 }
 
-/* 
- * Add a packet to the received buffer and set the recv_packetnum of the 
+/*
+ * Add a packet to the received buffer and set the recv_packetnum of the
  * connection to its proper value. Return 1 if data was too big, 0 if not.
  */
 static int add_recv(int connection_id, uint32_t data_num, uint8_t *data, uint16_t size)
@@ -766,8 +797,8 @@ static int handle_data(IP_Port source, uint8_t *packet, uint32_t length)
     return add_recv(connection, number, packet + 5, size);
 }
 
-/* 
- * END of packet handling functions 
+/*
+ * END of packet handling functions
  */
 
 void LosslessUDP_init(void)
@@ -785,17 +816,18 @@ static void doNew(void)
 {
     uint32_t i;
     uint64_t temp_time = current_time();
+
     for (i = 0; i < MAX_CONNECTIONS; ++i) {
         if (connections[i].status == 1)
-            if ((connections[i].last_sent + (1000000UL/connections[i].SYNC_rate)) <= temp_time) {
+            if ((connections[i].last_sent + (1000000UL / connections[i].SYNC_rate)) <= temp_time) {
                 send_handshake(connections[i].ip_port, connections[i].handshake_id1, 0);
                 connections[i].last_sent = temp_time;
             }
 
         /* kill all timed out connections */
-        if (connections[i].status > 0 && 
-            (connections[i].last_recvSYNC + connections[i].timeout * 1000000UL) < temp_time &&
-            connections[i].status != 4) {
+        if (connections[i].status > 0 &&
+                (connections[i].last_recvSYNC + connections[i].timeout * 1000000UL) < temp_time &&
+                connections[i].status != 4) {
             connections[i].status = 4;
             /* kill_connection(i); */
         }
@@ -809,9 +841,10 @@ static void doSYNC(void)
 {
     uint32_t i;
     uint64_t temp_time = current_time();
+
     for (i = 0; i < MAX_CONNECTIONS; ++i) {
         if (connections[i].status == 2 || connections[i].status == 3)
-            if ((connections[i].last_SYNC + (1000000UL/connections[i].SYNC_rate)) <= temp_time) {
+            if ((connections[i].last_SYNC + (1000000UL / connections[i].SYNC_rate)) <= temp_time) {
                 send_SYNC(i);
                 connections[i].last_SYNC = temp_time;
             }
@@ -823,18 +856,20 @@ static void doData(void)
     uint32_t i;
     uint64_t j;
     uint64_t temp_time = current_time();
+
     for (i = 0; i < MAX_CONNECTIONS; ++i)
         if (connections[i].status == 3 && sendqueue(i) != 0)
-            if ((connections[i].last_sent + (1000000UL/connections[i].data_rate)) <= temp_time) {
-                for (j = connections[i].last_sent; j < temp_time; j +=  (1000000UL/connections[i].data_rate))
+            if ((connections[i].last_sent + (1000000UL / connections[i].data_rate)) <= temp_time) {
+                for (j = connections[i].last_sent; j < temp_time; j +=  (1000000UL / connections[i].data_rate))
                     send_DATA(i);
+
                 connections[i].last_sent = temp_time;
             }
 }
 
 #define MAX_SYNC_RATE 10
 
-/* 
+/*
  * Automatically adjusts send rates of packets for optimal transmission.
  *
  * TODO: flow control.
@@ -843,9 +878,11 @@ static void adjustRates(void)
 {
     uint32_t i;
     uint64_t temp_time = current_time();
+
     for (i = 0; i < MAX_CONNECTIONS; ++i) {
         if (connections[i].status == 1 || connections[i].status == 2)
             connections[i].SYNC_rate = MAX_SYNC_RATE;
+
         if (connections[i].status == 3) {
             if (sendqueue(i) != 0) {
                 connections[i].data_rate = (BUFFER_PACKET_NUM - connections[i].num_req_paquets) * MAX_SYNC_RATE;