void (*devtool_set_inviter_commits_first)(bool inviter_commited_first) = inviter_commits_first_nop_probe;
void (*devtool_sptps_renewal_probe)(meshlink_node_t *node) = sptps_renewal_nop_probe;
-void devtool_get_node_status(meshlink_handle_t *mesh, meshlink_node_t *node, devtool_node_status_t *status) {
- if(!mesh || !node || !status) {
- meshlink_errno = MESHLINK_EINVAL;
- return;
- }
-
- node_t *internal = (node_t *)node;
-
- if(pthread_mutex_lock(&mesh->mutex) != 0) {
- abort();
- }
-
- memcpy(&status->status, &internal->status, sizeof status->status);
- status->mtu = internal->mtu;
- status->minmtu = internal->minmtu;
- status->maxmtu = internal->maxmtu;
- status->mtuprobes = internal->mtuprobes;
- status->in_packets = internal->in_packets;
- status->in_bytes = internal->in_bytes;
- status->out_packets = internal->out_packets;
- status->out_bytes = internal->out_bytes;
-
- // Derive UDP connection status
- if(internal == mesh->self) {
- status->udp_status = DEVTOOL_UDP_WORKING;
- } else if(!internal->status.reachable) {
- status->udp_status = DEVTOOL_UDP_IMPOSSIBLE;
- } else if(!internal->status.validkey) {
- status->udp_status = DEVTOOL_UDP_UNKNOWN;
- } else if(internal->status.udp_confirmed) {
- status->udp_status = DEVTOOL_UDP_WORKING;
- } else if(internal->mtuprobes > 30) {
- status->udp_status = DEVTOOL_UDP_FAILED;
- } else if(internal->mtuprobes > 0) {
- status->udp_status = DEVTOOL_UDP_TRYING;
- } else {
- status->udp_status = DEVTOOL_UDP_UNKNOWN;
- }
-
- pthread_mutex_unlock(&mesh->mutex);
-}
-
meshlink_handle_t *devtool_open_in_netns(const char *confbase, const char *name, const char *appname, dev_class_t devclass, int netns) {
meshlink_open_params_t *params = meshlink_open_params_init(confbase, name, appname, devclass);
params->netns = dup(netns);
* Applications should not depend on any of these functions for their normal operation.
*/
-/// The status of a node.
-typedef struct devtool_node_status devtool_node_status_t;
-
-/// The status of a node.
-struct devtool_node_status {
- uint32_t status;
- uint16_t mtu;
- uint16_t minmtu;
- uint16_t maxmtu;
- int mtuprobes;
- enum {
- DEVTOOL_UDP_FAILED = -2, /// UDP tried but failed
- DEVTOOL_UDP_IMPOSSIBLE = -1, /// UDP not possible (node unreachable)
- DEVTOOL_UDP_UNKNOWN = 0, /// UDP status not known (never tried to communicate with the node)
- DEVTOOL_UDP_TRYING, /// UDP detection in progress
- DEVTOOL_UDP_WORKING, /// UDP communication established
- } udp_status;
- uint64_t in_packets;
- uint64_t in_bytes;
- uint64_t out_packets;
- uint64_t out_bytes;
-};
-
-/// Get the status of a node.
-/** This function returns a struct containing extra information about a node.
- * The information is a snapshot taken at call time.
- *
- * @param mesh A handle which represents an instance of MeshLink.
- * @param node A pointer to a meshlink_node_t.
- * @param status A pointer to a devtools_node_status_t variable that has
- * to be provided by the caller.
- * The contents of this variable will be changed to reflect
- * the current status of the node.
- */
-void devtool_get_node_status(meshlink_handle_t *mesh, meshlink_node_t *node, devtool_node_status_t *status);
-
/// Open a MeshLink instance in a given network namespace.
/** This function opens MeshLink in the given network namespace.
*
*/
typedef void (*node_status_cb_t)(mesh *mesh, node *node, bool reachable);
-/// A callback reporting node path MTU changes.
-/** @param mesh A handle which represents an instance of MeshLink.
- * @param node A pointer to a meshlink_node_t describing the node whose status changed.
- * This pointer is valid until meshlink_close() is called.
- * @param pmtu The current path MTU to the node, or 0 if UDP communication is not (yet) possible.
- */
-typedef void (*node_pmtu_cb_t)(mesh *mesh, node *node, uint16_t pmtu);
-
/// A callback reporting duplicate node detection.
/** @param mesh A handle which represents an instance of MeshLink.
* @param node A pointer to a meshlink_node_t describing the node which is duplicate.
(void)reachable;
}
- /// This functions is called whenever another node's path MTU changes.
- virtual void node_pmtu(node *peer, uint16_t pmtu) {
- /* do nothing */
- (void)peer;
- (void)pmtu;
- }
-
/// This functions is called whenever a duplicate node is detected.
virtual void node_duplicate(node *peer) {
/* do nothing */
bool start() {
meshlink_set_receive_cb(handle, &receive_trampoline);
meshlink_set_node_status_cb(handle, &node_status_trampoline);
- meshlink_set_node_pmtu_cb(handle, &node_pmtu_trampoline);
meshlink_set_node_duplicate_cb(handle, &node_duplicate_trampoline);
meshlink_set_log_cb(handle, MESHLINK_DEBUG, &log_trampoline);
meshlink_set_error_cb(handle, &error_trampoline);
that->node_status(static_cast<node *>(peer), reachable);
}
- static void node_pmtu_trampoline(meshlink_handle_t *handle, meshlink_node_t *peer, uint16_t pmtu) {
- if(!(handle->priv)) {
- return;
- }
-
- meshlink::mesh *that = static_cast<mesh *>(handle->priv);
- that->node_pmtu(static_cast<node *>(peer), pmtu);
- }
-
static void node_duplicate_trampoline(meshlink_handle_t *handle, meshlink_node_t *peer) {
if(!(handle->priv)) {
return;
*/
void meshlink_set_node_status_cb(struct meshlink_handle *mesh, meshlink_node_status_cb_t cb);
-/// A callback reporting node path MTU changes.
-/** @param mesh A handle which represents an instance of MeshLink.
- * @param node A pointer to a struct meshlink_node describing the node whose status changed.
- * This pointer is valid until meshlink_close() is called.
- * @param pmtu The current path MTU to the node, or 0 if UDP communication is not (yet) possible.
- */
-typedef void (*meshlink_node_pmtu_cb_t)(struct meshlink_handle *mesh, struct meshlink_node *node, uint16_t pmtu);
-
-/// Set the node extended status callback.
-/** This functions sets the callback that is called whenever certain connectivity parameters for a node change.
- * The callback is run in MeshLink's own thread.
- * It is therefore important that the callback uses apprioriate methods (queues, pipes, locking, etc.)
- * to hand the data over to the application's thread.
- * The callback should also not block itself and return as quickly as possible.
- *
- * \memberof meshlink_handle
- * @param mesh A handle which represents an instance of MeshLink.
- * @param cb A pointer to the function which will be called when another node's extended status changes.
- * If a NULL pointer is given, the callback will be disabled.
- */
-void meshlink_set_node_pmtu_cb(struct meshlink_handle *mesh, meshlink_node_pmtu_cb_t cb);
-
/// A callback reporting duplicate node detection.
/** @param mesh A handle which represents an instance of MeshLink.
* @param node A pointer to a struct meshlink_node describing the node which is duplicate.
* the packet is sent as one unit and is received as one unit,
* and that there is no guarantee that the packet will arrive at the destination.
* Packets that are too big to be sent over the network as one unit might be dropped, and this function may return an error if this situation can be detected beforehand.
- * The application should not send packets that are larger than the path MTU, which can be queried with meshlink_get_pmtu().
* The application should take care of getting an acknowledgement and retransmission if necessary.
*
* \memberof meshlink_node
*/
bool meshlink_send(struct meshlink_handle *mesh, struct meshlink_node *destination, const void *data, size_t len) __attribute__((__warn_unused_result__));
-/// Query the maximum packet size that can be sent to a node.
-/** This functions returns the maximum size of packets (path MTU) that can be sent to a specific node with meshlink_send().
- * The path MTU is a property of the path packets will take to the destination node over the Internet.
- * It can be different for different destination nodes.
- * and the path MTU can change at any point in time due to changes in the Internet.
- * Therefore, although this should only occur rarely, it can still happen that packets that do not exceed this size get dropped.
- *
- * \memberof meshlink_node
- * @param mesh A handle which represents an instance of MeshLink.
- * @param destination A pointer to a struct meshlink_node describing the destination for the data.
- *
- * @return The recommended maximum size of packets that are to be sent to the destination node, 0 if the node is unreachable,
- * or a negative value in case of an error.
- */
-ssize_t meshlink_get_pmtu(struct meshlink_handle *mesh, struct meshlink_node *destination) __attribute__((__warn_unused_result__));
-
/// Get a handle for our own node.
/** This function returns a handle for the local node.
*
pthread_mutex_unlock(&mesh->mutex);
}
-void meshlink_set_node_pmtu_cb(meshlink_handle_t *mesh, meshlink_node_pmtu_cb_t cb) {
- logger(mesh, MESHLINK_DEBUG, "meshlink_set_node_pmtu_cb(%p)", (void *)(intptr_t)cb);
-
- if(!mesh) {
- meshlink_errno = MESHLINK_EINVAL;
- return;
- }
-
- if(pthread_mutex_lock(&mesh->mutex) != 0) {
- abort();
- }
-
- mesh->node_pmtu_cb = cb;
- pthread_mutex_unlock(&mesh->mutex);
-}
-
void meshlink_set_node_duplicate_cb(meshlink_handle_t *mesh, meshlink_node_duplicate_cb_t cb) {
logger(mesh, MESHLINK_DEBUG, "meshlink_set_node_duplicate_cb(%p)", (void *)(intptr_t)cb);
for(vpn_packet_t *packet; (packet = meshlink_queue_pop(&mesh->outpacketqueue));) {
logger(mesh, MESHLINK_DEBUG, "Removing packet of %d bytes from packet queue", packet->len);
- mesh->self->in_packets++;
- mesh->self->in_bytes += packet->len;
route(mesh, mesh->self, packet);
free(packet);
}
}
-ssize_t meshlink_get_pmtu(meshlink_handle_t *mesh, meshlink_node_t *destination) {
- if(!mesh || !destination) {
- meshlink_errno = MESHLINK_EINVAL;
- return -1;
- }
-
- if(pthread_mutex_lock(&mesh->mutex) != 0) {
- abort();
- }
-
- node_t *n = (node_t *)destination;
-
- if(!n->status.reachable) {
- pthread_mutex_unlock(&mesh->mutex);
- return 0;
-
- } else if(n->mtuprobes > 30 && n->minmtu) {
- pthread_mutex_unlock(&mesh->mutex);
- return n->minmtu;
- } else {
- pthread_mutex_unlock(&mesh->mutex);
- return MTU;
- }
-}
-
char *meshlink_get_fingerprint(meshlink_handle_t *mesh, meshlink_node_t *node) {
if(!mesh || !node) {
meshlink_errno = MESHLINK_EINVAL;
}
}
-static void channel_retransmit(struct utcp_connection *utcp_connection) {
- node_t *n = utcp_connection->utcp->priv;
- meshlink_handle_t *mesh = n->mesh;
-
- if(n->mtuprobes == 31 && n->mtutimeout.cb) {
- timeout_set(&mesh->loop, &n->mtutimeout, &(struct timespec) {
- 0, 0
- });
- }
-}
-
static ssize_t channel_send(struct utcp *utcp, const void *data, size_t len) {
node_t *n = utcp->priv;
if(mesh->peer) {
mesh->peer->utcp = utcp_init(channel_accept, channel_pre_accept, channel_send, mesh->peer);
- utcp_set_mtu(mesh->peer->utcp, mesh->peer->mtu - sizeof(meshlink_packethdr_t));
- utcp_set_retransmit_cb(mesh->peer->utcp, channel_retransmit);
}
pthread_mutex_unlock(&mesh->mutex);
if(!n->utcp) {
n->utcp = utcp_init(channel_accept, channel_pre_accept, channel_send, n);
- utcp_set_mtu(n->utcp, n->mtu - sizeof(meshlink_packethdr_t));
- utcp_set_retransmit_cb(n->utcp, channel_retransmit);
mesh->receive_cb = channel_receive;
if(!n->utcp) {
if(!n->utcp) {
n->utcp = utcp_init(channel_accept, channel_pre_accept, channel_send, n);
- utcp_set_mtu(n->utcp, n->mtu - sizeof(meshlink_packethdr_t));
- utcp_set_retransmit_cb(n->utcp, channel_retransmit);
}
utcp_set_user_timeout(n->utcp, timeout);
void update_node_status(meshlink_handle_t *mesh, node_t *n) {
if(n->status.reachable && mesh->channel_accept_cb && !n->utcp) {
n->utcp = utcp_init(channel_accept, channel_pre_accept, channel_send, n);
- utcp_set_mtu(n->utcp, n->mtu - sizeof(meshlink_packethdr_t));
- utcp_set_retransmit_cb(n->utcp, channel_retransmit);
}
if(mesh->node_status_cb) {
mesh->node_status_cb(mesh, (meshlink_node_t *)n, n->status.reachable && !n->status.blacklisted);
}
-
- if(mesh->node_pmtu_cb) {
- mesh->node_pmtu_cb(mesh, (meshlink_node_t *)n, n->minmtu);
- }
-}
-
-void update_node_pmtu(meshlink_handle_t *mesh, node_t *n) {
- utcp_set_mtu(n->utcp, (n->minmtu > MINMTU ? n->minmtu : MINMTU) - sizeof(meshlink_packethdr_t));
-
- if(mesh->node_pmtu_cb && !n->status.blacklisted) {
- mesh->node_pmtu_cb(mesh, (meshlink_node_t *)n, n->minmtu);
- }
}
void handle_duplicate_node(meshlink_handle_t *mesh, node_t *n) {
meshlink_get_node
meshlink_get_node_dev_class
meshlink_get_node_reachability
-meshlink_get_pmtu
meshlink_get_self
meshlink_hint_address
meshlink_hint_network_change
meshlink_set_log_cb
meshlink_set_node_channel_timeout
meshlink_set_node_duplicate_cb
-meshlink_set_node_pmtu_cb
meshlink_set_node_status_cb
meshlink_set_receive_cb
meshlink_set_scheduling_granularity
// Infrequently used callbacks
meshlink_node_status_cb_t node_status_cb;
meshlink_node_status_cb_t meta_status_cb;
- meshlink_node_pmtu_cb_t node_pmtu_cb;
meshlink_channel_listen_cb_t channel_listen_cb;
meshlink_channel_accept_cb_t channel_accept_cb;
meshlink_node_duplicate_cb_t node_duplicate_cb;
void meshlink_send_from_queue(event_loop_t *loop, void *mesh);
void update_node_status(meshlink_handle_t *mesh, struct node_t *n);
-void update_node_pmtu(meshlink_handle_t *mesh, struct node_t *n);
extern meshlink_log_level_t global_log_level;
extern meshlink_log_cb_t global_log_cb;
void handle_duplicate_node(meshlink_handle_t *mesh, struct node_t *n);
bool read_ecdsa_public_key(struct meshlink_handle *mesh, struct connection_t *) __attribute__((__warn_unused_result__));
bool read_ecdsa_private_key(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
bool node_write_config(struct meshlink_handle *mesh, struct node_t *, bool new_key) __attribute__((__warn_unused_result__));
-void send_mtu_probe(struct meshlink_handle *mesh, struct node_t *);
void handle_meta_connection_data(struct meshlink_handle *mesh, struct connection_t *);
void retry(struct meshlink_handle *mesh);
void flush_meta(struct meshlink_handle *mesh, struct connection_t *);
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);
}
}
*/
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);
return;
}
node_t *new_node(void) {
node_t *n = xzalloc(sizeof(*n));
- n->mtu = MTU;
- n->maxmtu = MTU;
n->devclass = DEV_CLASS_UNKNOWN;
return n;
ecdsa_free(n->ecdsa);
sptps_stop(&n->sptps);
- if(n->mtutimeout.cb) {
- abort();
- }
-
free(n->name);
free(n->canonical_address);
}
assert(mesh->peer && mesh->peer == n);
- timeout_del(&mesh->loop, &n->mtutimeout);
free_node(n);
mesh->peer = NULL;
}
// Private member variables
node_status_t status;
- uint16_t minmtu; /* Probed minimum MTU */
dev_class_t devclass;
// Used for packet I/O
struct utcp *utcp;
- // Traffic counters
- uint64_t in_packets;
- uint64_t in_bytes;
- uint64_t out_packets;
- uint64_t out_bytes;
-
- // MTU probes
- timeout_t mtutimeout; /* Probe event */
- int mtuprobes; /* Number of probes */
- uint16_t mtu; /* Maximum size of packets to send to this node */
- uint16_t maxmtu; /* Probed maximum MTU */
-
// Used for meta-connection I/O, timeouts
struct meshlink_handle *mesh; /* The mesh this node belongs to */
projects / meshlink-tiny / commitdiff