#include "netutl.h"
#include "protocol.h"
#include "route.h"
+#include "sptps.h"
#include "utils.h"
#include "xalloc.h"
static void send_udppacket(meshlink_handle_t *mesh, node_t *, vpn_packet_t *);
#define MAX_SEQNO 1073741824
+#define PROBE_OVERHEAD (SPTPS_DATAGRAM_OVERHEAD + 40)
/* mtuprobes == 1..30: initial discovery, send bursts with 1 second interval
mtuprobes == 31: sleep pinginterval seconds
}
if(n->mtuprobes == 31) {
- if(!n->minmtu && n->status.want_udp) {
+ if(!n->minmtu && n->status.want_udp && n->nexthop && n->nexthop->connection) {
/* Send a dummy ANS_KEY to try to update the reflexive UDP address */
send_request(mesh, n->nexthop->connection, NULL, "%d %s %s . -1 -1 -1 0", ANS_KEY, mesh->self->name, n->name);
n->status.want_udp = false;
logger(mesh, MESHLINK_DEBUG, "Sending MTU probe length %d to %s", len, n->name);
+ n->out_meta += packet.len + PROBE_OVERHEAD;
send_udppacket(mesh, n, &packet);
}
}
static void mtu_probe_h(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet, uint16_t len) {
+ n->in_meta += len + PROBE_OVERHEAD;
+
if(len < 64) {
logger(mesh, MESHLINK_WARNING, "Got too short MTU probe length %d from %s", packet->len, n->name);
return;
bool udp_confirmed = n->status.udp_confirmed;
n->status.udp_confirmed = true;
+ logger(mesh, MESHLINK_DEBUG, "Sending MTU probe reply %d to %s", packet->len, n->name);
+ n->out_meta += packet->len + PROBE_OVERHEAD;
send_udppacket(mesh, n, packet);
n->status.udp_confirmed = udp_confirmed;
} else {
if(!n->status.udp_confirmed) {
char *address, *port;
sockaddr2str(&n->address, &address, &port);
- send_request(mesh, n->nexthop->connection, NULL, "%d %s %s . -1 -1 -1 0 %s %s", ANS_KEY, n->name, n->name, address, port);
+
+ if(n->nexthop && n->nexthop->connection) {
+ send_request(mesh, n->nexthop->connection, NULL, "%d %s %s . -1 -1 -1 0 %s %s", ANS_KEY, n->name, n->name, address, port);
+ } else {
+ logger(mesh, MESHLINK_WARNING, "Cannot send reflexive address to %s via %s", n->name, n->nexthop ? n->nexthop->name : n->name);
+ }
+
free(address);
free(port);
n->status.udp_confirmed = true;
if(n->status.blacklisted) {
logger(mesh, MESHLINK_WARNING, "Dropping packet from blacklisted node %s", n->name);
} else {
- n->in_packets++;
- n->in_bytes += packet->len;
-
route(mesh, n, packet);
}
}
}
if(!n->status.validkey) {
+ if(n->connection && (n->connection->flags & PROTOCOL_TINY) & n->connection->status.active) {
+ send_raw_packet(mesh, n->connection, origpkt);
+ return;
+ }
+
logger(mesh, MESHLINK_INFO, "No valid key known yet for %s", n->name);
if(!n->status.waitingforkey) {
return;
}
-static void choose_udp_address(meshlink_handle_t *mesh, const node_t *n, const sockaddr_t **sa, int *sock) {
+static void choose_udp_address(meshlink_handle_t *mesh, const node_t *n, const sockaddr_t **sa, int *sock, sockaddr_t *sa_buf) {
/* Latest guess */
*sa = &n->address;
*sock = n->sock;
goto check_socket;
}
+ /* Else, if we have a canonical address, try this once every batch */
+ if(mesh->udp_choice == 1 && n->canonical_address) {
+ char *host = xstrdup(n->canonical_address);
+ char *port = strchr(host, ' ');
+
+ if(port) {
+ *port++ = 0;
+ *sa_buf = str2sockaddr_random(mesh, host, port);
+ *sa = sa_buf;
+
+ if(sa_buf->sa.sa_family != AF_UNKNOWN) {
+ free(host);
+ goto check_socket;
+ }
+ }
+
+ free(host);
+ }
+
/* Otherwise, address are found in edges to this node.
So we pick a random edge and a random socket. */
char buf[len * 4 / 3 + 5];
b64encode(data, buf, len);
+ if(!to->nexthop || !to->nexthop->connection) {
+ logger(mesh, MESHLINK_WARNING, "Unable to forward SPTPS packet to %s via %s", to->name, to->nexthop ? to->nexthop->name : to->name);
+ return false;
+ }
+
/* 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) {
/* Otherwise, send the packet via UDP */
+ sockaddr_t sa_buf;
const sockaddr_t *sa;
int sock;
if(to->status.broadcast) {
choose_broadcast_address(mesh, to, &sa, &sock);
} else {
- choose_udp_address(mesh, to, &sa, &sock);
+ choose_udp_address(mesh, to, &sa, &sock, &sa_buf);
}
if(sendto(mesh->listen_socket[sock].udp.fd, data, len, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
*/
void send_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet) {
if(n == mesh->self) {
- n->out_packets++;
- n->out_bytes += packet->len;
// TODO: send to application
return;
}
return;
}
- n->out_packets++;
- n->out_bytes += packet->len;
n->status.want_udp = true;
send_sptps_packet(mesh, n, packet);