#include "digest.h"
#include "graph.h"
#include "logger.h"
+#include "meshlink_internal.h"
#include "net.h"
#include "netutl.h"
#include "protocol.h"
memset(packet.data, 0, 14);
randomize(packet.data + 14, len - 14);
packet.len = len;
- 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_mtu_probe_handler(n);
}
-static void mtu_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
+static void mtu_probe_h(node_t *n, vpn_packet_t *packet, uint16_t len) {
logger(DEBUG_TRAFFIC, LOG_INFO, "Got MTU probe length %d from %s (%s)", packet->len, n->name, n->hostname);
if(!packet->data[0]) {
}
}
-static length_t compress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
+static uint16_t compress_packet(uint8_t *dest, const uint8_t *source, uint16_t len, int level) {
if(level == 0) {
memcpy(dest, source, len);
return len;
return -1;
}
-static length_t uncompress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
+static uint16_t uncompress_packet(uint8_t *dest, const uint8_t *source, uint16_t len, int level) {
if(level == 0) {
memcpy(dest, source, len);
return len;
}
static bool try_mac(node_t *n, const vpn_packet_t *inpkt) {
- return sptps_verify_datagram(&n->sptps, (char *)&inpkt->seqno, inpkt->len);
+ return sptps_verify_datagram(&n->sptps, inpkt->data, inpkt->len);
}
static void receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
- vpn_packet_t pkt1, pkt2;
- vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
- int nextpkt = 0;
- vpn_packet_t *outpkt = pkt[0];
- size_t outlen;
-
if(!n->sptps.state) {
if(!n->status.waitingforkey) {
logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got packet from %s (%s) but we haven't exchanged keys yet", n->name, n->hostname);
}
return;
}
- sptps_receive_data(&n->sptps, (char *)&inpkt->seqno, inpkt->len);
+ sptps_receive_data(&n->sptps, inpkt->data, inpkt->len);
}
void receive_tcppacket(connection_t *c, const char *buffer, int len) {
return;
outpkt.len = len;
- if(c->options & OPTION_TCPONLY)
- outpkt.priority = 0;
- else
- outpkt.priority = -1;
+ outpkt.tcp = true;
memcpy(outpkt.data, buffer, len);
receive_packet(c->node, &outpkt);
uint8_t type = 0;
- // TODO: use a better way to signal that this is a PMTU probe
- if(!(origpkt->data[12] | origpkt->data[13])) {
- sptps_send_record(&n->sptps, PKT_PROBE, (char *)origpkt->data, origpkt->len);
+ // If it's a probe, send it immediately without trying to compress it.
+ if(origpkt->probe) {
+ sptps_send_record(&n->sptps, PKT_PROBE, origpkt->data, origpkt->len);
return;
}
}
}
- sptps_send_record(&n->sptps, type, (char *)origpkt->data, origpkt->len);
+ sptps_send_record(&n->sptps, type, origpkt->data, origpkt->len);
return;
}
vpn_packet_t *outpkt;
int origlen = origpkt->len;
size_t outlen;
-#if defined(SOL_IP) && defined(IP_TOS)
- static int priority = 0;
-#endif
- int origpriority = origpkt->priority;
if(!n->status.reachable) {
logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send UDP packet to unreachable node %s (%s)", n->name, n->hostname);
/* Send it via TCP if it is a handshake packet, TCPOnly is in use, or this packet is larger than the MTU. */
- if(type >= SPTPS_HANDSHAKE || ((myself->options | to->options) & OPTION_TCPONLY) || (type != PKT_PROBE && len > to->minmtu)) {
+ if(type >= SPTPS_HANDSHAKE || ((mesh->self->options | to->options) & OPTION_TCPONLY) || (type != PKT_PROBE && len > to->minmtu)) {
char buf[len * 4 / 3 + 5];
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) {
- 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);
+ to->incompression = mesh->self->incompression;
+ return send_request(to->nexthop->connection, "%d %s %s %s -1 -1 -1 %d", ANS_KEY, mesh->self->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);
+ return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, mesh->self->name, to->name, REQ_SPTPS, buf);
}
}
if(type == PKT_PROBE) {
inpkt.len = len;
+ inpkt.probe = true;
memcpy(inpkt.data, data, len);
mtu_probe_h(from, &inpkt, len);
return true;
+ } else {
+ inpkt.probe = false;
}
if(type & ~(PKT_COMPRESSED)) {
}
if(type & PKT_COMPRESSED) {
- length_t ulen = uncompress_packet(inpkt.data, (const uint8_t *)data, len, from->incompression);
+ uint16_t ulen = uncompress_packet(inpkt.data, (const uint8_t *)data, len, from->incompression);
if(ulen < 0) {
return false;
} else {
void send_packet(node_t *n, vpn_packet_t *packet) {
node_t *via;
- if(n == myself) {
+ if(n == mesh->self) {
n->out_packets++;
n->out_bytes += packet->len;
// TODO: send to application
void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
// Always give ourself a copy of the packet.
- if(from != myself)
- send_packet(myself, packet);
+ if(from != mesh->self)
+ send_packet(mesh->self, packet);
logger(DEBUG_TRAFFIC, LOG_INFO, "Broadcasting packet of %d bytes from %s (%s)",
packet->len, from->name, from->hostname);
- for list_each(connection_t, c, connection_list)
+ for list_each(connection_t, c, mesh->connections)
if(c->status.active && c->status.mst && c != from->nexthop->connection)
send_packet(c->node, packet);
}
bool hard = false;
static time_t last_hard_try = 0;
- for splay_each(edge_t, e, edge_weight_tree) {
- if(!e->to->status.reachable || e->to == myself)
+ for splay_each(edge_t, e, mesh->edges) {
+ if(!e->to->status.reachable || e->to == mesh->self)
continue;
if(sockaddrcmp_noport(from, &e->address)) {
node_t *n;
int len;
- len = recvfrom(ls->udp.fd, (char *) &pkt.seqno, MAXSIZE, 0, &from.sa, &fromlen);
+ len = recvfrom(ls->udp.fd, pkt.data, MAXSIZE, 0, &from.sa, &fromlen);
if(len <= 0 || len > MAXSIZE) {
if(!sockwouldblock(sockerrno))
projects / meshlink / blobdiff