Remove files not used by MeshLink.

[meshlink] / src / net_packet.c

diff --git a/src/net_packet.c b/src/net_packet.c
index d700fd6b7502c34fb686e5df5bd473773408240c..30ad3e504c3cf56c68650d9897c2c4551230db28 100644 (file)
--- a/src/net_packet.c
+++ b/src/net_packet.c
@@ -35,14 +35,12 @@
 #include "connection.h"
 #include "crypto.h"
 #include "digest.h"
-#include "device.h"
 #include "ethernet.h"
 #include "graph.h"
 #include "logger.h"
 #include "net.h"
 #include "netutl.h"
 #include "protocol.h"
-#include "process.h"
 #include "route.h"
 #include "utils.h"
 #include "xalloc.h"
@@ -144,16 +142,15 @@ static void send_mtu_probe_handler(void *data) {
                memset(packet.data, 0, 14);
                randomize(packet.data + 14, len - 14);
                packet.len = len;
-               if(i >= 4 && n->mtuprobes <= 10)
-                       packet.priority = -1;
-               else
-                       packet.priority = 0;
+               packet.priority = 0;
+               n->status.broadcast = i >= 4 && n->mtuprobes <= 10 && n->prevedge;
 
                logger(DEBUG_TRAFFIC, LOG_INFO, "Sending MTU probe length %d to %s (%s)", len, n->name, n->hostname);
 
                send_udppacket(n, &packet);
        }
 
+       n->status.broadcast = false;
        n->probe_counter = 0;
        gettimeofday(&n->probe_time, NULL);
 
@@ -189,6 +186,11 @@ static void mtu_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
                        uint8_t* data = packet->data;
                        *data++ = 2;
                        uint16_t len16 = htons(len); memcpy(data, &len16, 2); data += 2;
+                       struct timeval now;
+                       gettimeofday(&now, NULL);
+                       uint32_t sec = htonl(now.tv_sec); memcpy(data, &sec, 4); data += 4;
+                       uint32_t usec = htonl(now.tv_usec); memcpy(data, &usec, 4); data += 4;
+                       packet->len = data - packet->data;
                } else {
                        /* Legacy protocol: n won't understand type 2 probe replies. */
                        packet->data[0] = 1;
@@ -244,19 +246,30 @@ static void mtu_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
                /* Calculate RTT and bandwidth.
                   The RTT is the time between the MTU probe burst was sent and the first
                   reply is received. The bandwidth is measured using the time between the
-                  arrival of the first and third probe reply.
+                  arrival of the first and third probe reply (or type 2 probe requests).
                 */
 
                struct timeval now, diff;
                gettimeofday(&now, NULL);
                timersub(&now, &n->probe_time, &diff);
+
+               struct timeval probe_timestamp = now;
+               if (packet->data[0] == 2 && packet->len >= 11) {
+                       uint32_t sec; memcpy(&sec, packet->data + 3, 4);
+                       uint32_t usec; memcpy(&usec, packet->data + 7, 4);
+                       probe_timestamp.tv_sec = ntohl(sec);
+                       probe_timestamp.tv_usec = ntohl(usec);
+               }
+               
                n->probe_counter++;
 
                if(n->probe_counter == 1) {
                        n->rtt = diff.tv_sec + diff.tv_usec * 1e-6;
-                       n->probe_time = now;
+                       n->probe_time = probe_timestamp;
                } else if(n->probe_counter == 3) {
-                       n->bandwidth = 2.0 * probelen / (diff.tv_sec + diff.tv_usec * 1e-6);
+                       struct timeval probe_timestamp_diff;
+                       timersub(&probe_timestamp, &n->probe_time, &probe_timestamp_diff);
+                       n->bandwidth = 2.0 * probelen / (probe_timestamp_diff.tv_sec + probe_timestamp_diff.tv_usec * 1e-6);
                        logger(DEBUG_TRAFFIC, LOG_DEBUG, "%s (%s) RTT %.2f ms, burst bandwidth %.3f Mbit/s, rx packet loss %.2f %%", n->name, n->hostname, n->rtt * 1e3, n->bandwidth * 8e-6, n->packetloss * 1e2);
                }
        }
@@ -719,9 +732,7 @@ static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
        const sockaddr_t *sa;
        int sock;
 
-       /* Overloaded use of priority field: -1 means local broadcast */
-
-       if(origpriority == -1 && n->prevedge)
+       if(n->status.broadcast)
                choose_broadcast_address(n, &sa, &sock);
        else
                choose_udp_address(n, &sa, &sock);
@@ -760,10 +771,12 @@ bool send_sptps_data(void *handle, uint8_t type, const char *data, size_t len) {
                b64encode(data, buf, len);
                /* If no valid key is known yet, send the packets using ANS_KEY requests,
                   to ensure we get to learn the reflexive UDP address. */
-               if(!to->status.validkey)
-                       return send_request(to->nexthop->connection, "%d %s %s %s -1 -1 -1 %d", ANS_KEY, myself->name, to->name, buf, myself->incompression);
-               else
+               if(!to->status.validkey) {
+                       to->incompression = myself->incompression;
+                       return send_request(to->nexthop->connection, "%d %s %s %s -1 -1 -1 %d", ANS_KEY, myself->name, to->name, buf, to->incompression);
+               } else {
                        return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, myself->name, to->name, REQ_SPTPS, buf);
+               }
        }
 
        /* Otherwise, send the packet via UDP */
@@ -771,7 +784,10 @@ bool send_sptps_data(void *handle, uint8_t type, const char *data, size_t len) {
        const sockaddr_t *sa;
        int sock;
 
-       choose_udp_address(to, &sa, &sock);
+       if(to->status.broadcast)
+               choose_broadcast_address(to, &sa, &sock);
+       else
+               choose_udp_address(to, &sa, &sock);
 
        if(sendto(listen_socket[sock].udp.fd, data, len, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
                if(sockmsgsize(sockerrno)) {
@@ -876,7 +892,7 @@ void send_packet(node_t *n, vpn_packet_t *packet) {
                         memcpy(packet->data, mymac.x, ETH_ALEN);
                n->out_packets++;
                n->out_bytes += packet->len;
-               devops.write(packet);
+               // TODO: send to application
                return;
        }
 
@@ -943,7 +959,7 @@ void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
                                break;
 
                        for splay_each(node_t, n, node_tree)
-                               if(n->status.reachable && ((n->via == myself && n->nexthop == n) || n->via == n))
+                               if(n->status.reachable && n != myself && ((n->via == myself && n->nexthop == n) || n->via == n))
                                        send_packet(n, packet);
                        break;
 
@@ -1022,15 +1038,3 @@ void handle_incoming_vpn_data(void *data, int flags) {
 
        receive_udppacket(n, &pkt);
 }
-
-void handle_device_data(void *data, int flags) {
-       vpn_packet_t packet;
-
-       packet.priority = 0;
-
-       if(devops.read(&packet)) {
-               myself->in_packets++;
-               myself->in_bytes += packet.len;
-               route(myself, &packet);
-       }
-}