]> git.meshlink.io Git - meshlink/blob - src/meshlink_internal.h
When a new connection is activated, terminate any pending connections to the same...
[meshlink] / src / meshlink_internal.h
1 #ifndef MESHLINK_INTERNAL_H
2 #define MESHLINK_INTERNAL_H
3
4 /*
5     meshlink_internal.h -- Internal parts of the public API.
6     Copyright (C) 2014-2019 Guus Sliepen <guus@meshlink.io>
7
8     This program is free software; you can redistribute it and/or modify
9     it under the terms of the GNU General Public License as published by
10     the Free Software Foundation; either version 2 of the License, or
11     (at your option) any later version.
12
13     This program is distributed in the hope that it will be useful,
14     but WITHOUT ANY WARRANTY; without even the implied warranty of
15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16     GNU General Public License for more details.
17
18     You should have received a copy of the GNU General Public License along
19     with this program; if not, write to the Free Software Foundation, Inc.,
20     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 */
22
23 #ifdef MESHLINK_H
24 #error You must not include both meshlink.h and meshlink_internal.h!
25 #endif
26
27 #include "system.h"
28
29 #include "event.h"
30 #include "hash.h"
31 #include "meshlink.h"
32 #include "meshlink_queue.h"
33 #include "sockaddr.h"
34 #include "sptps.h"
35 #include "xoshiro.h"
36
37 #include <pthread.h>
38
39 #define MAXSOCKETS 4    /* Probably overkill... */
40
41 static const char meshlink_invitation_label[] = "MeshLink invitation";
42 static const char meshlink_tcp_label[] = "MeshLink TCP";
43 static const char meshlink_udp_label[] = "MeshLink UDP";
44
45 #define MESHLINK_CONFIG_VERSION 2
46 #define MESHLINK_INVITATION_VERSION 2
47
48 struct CattaServer;
49 struct CattaSServiceBrowser;
50 struct CattaSimplePoll;
51 struct CattaSEntryGroup;
52
53 typedef struct listen_socket_t {
54         struct io_t tcp;
55         struct io_t udp;
56         sockaddr_t sa;
57         sockaddr_t broadcast_sa;
58 } listen_socket_t;
59
60 struct meshlink_open_params {
61         char *confbase;
62         char *appname;
63         char *name;
64         dev_class_t devclass;
65
66         int netns;
67
68         const void *key;
69         size_t keylen;
70 };
71
72 /// Device class traits
73 typedef struct {
74         int pinginterval;
75         int pingtimeout;
76         int fast_retry_period;
77         int maxtimeout;
78         unsigned int min_connects;
79         unsigned int max_connects;
80         int edge_weight;
81 } dev_class_traits_t;
82
83 /// A handle for an instance of MeshLink.
84 struct meshlink_handle {
85         // public members
86         char *name;
87         void *priv;
88
89         // private members
90         pthread_mutex_t mutex;
91         event_loop_t loop;
92         struct node_t *self;
93         meshlink_log_cb_t log_cb;
94         meshlink_log_level_t log_level;
95         void *packet;
96
97         // The most important network-related members come first
98         int reachable;
99         int listen_sockets;
100         listen_socket_t listen_socket[MAXSOCKETS];
101
102         meshlink_receive_cb_t receive_cb;
103         meshlink_queue_t outpacketqueue;
104         signal_t datafromapp;
105
106         hash_t *node_udp_cache;
107
108         struct splay_tree_t *nodes;
109         struct splay_tree_t *edges;
110
111         struct list_t *connections;
112         struct list_t *outgoings;
113         struct list_t *submeshes;
114
115         // Meta-connection-related members
116         struct splay_tree_t *past_request_tree;
117         timeout_t past_request_timeout;
118
119         int connection_burst;
120         int contradicting_add_edge;
121         int contradicting_del_edge;
122         int sleeptime;
123         time_t connection_burst_time;
124         time_t last_hard_try;
125         time_t last_unreachable;
126         timeout_t pingtimer;
127         timeout_t periodictimer;
128
129         struct connection_t *everyone;
130         uint64_t prng_state[4];
131         uint32_t session_id;
132
133         int next_pit;
134         int pits[10];
135
136         // Infrequently used callbacks
137         meshlink_node_status_cb_t node_status_cb;
138         meshlink_node_status_cb_t meta_status_cb;
139         meshlink_node_pmtu_cb_t node_pmtu_cb;
140         meshlink_channel_listen_cb_t channel_listen_cb;
141         meshlink_channel_accept_cb_t channel_accept_cb;
142         meshlink_node_duplicate_cb_t node_duplicate_cb;
143         meshlink_connection_try_cb_t connection_try_cb;
144         meshlink_error_cb_t error_cb;
145
146         // Mesh parameters
147         char *appname;
148         char *myport;
149
150         struct ecdsa *private_key;
151         struct ecdsa *invitation_key;
152
153         dev_class_t devclass;
154
155         int invitation_timeout;
156         int udp_choice;
157
158         dev_class_traits_t dev_class_traits[DEV_CLASS_COUNT];
159
160         int netns;
161
162         bool default_blacklist;
163         bool discovery;         // Whether Catta is enabled or not
164         bool inviter_commits_first;
165
166         // Configuration
167         char *confbase;
168         FILE *lockfile;
169         void *config_key;
170         char *external_address_url;
171         struct list_t *invitation_addresses;
172
173         // Thread management
174         pthread_t thread;
175         pthread_cond_t cond;
176         pthread_mutex_t discovery_mutex;
177         pthread_cond_t discovery_cond;
178         bool threadstarted;
179         bool discovery_threadstarted;
180
181         // Catta
182         pthread_t discovery_thread;
183         struct CattaServer *catta_server;
184         struct CattaSServiceBrowser *catta_browser;
185         struct CattaSimplePoll *catta_poll;
186         struct CattaSEntryGroup *catta_group;
187         char *catta_servicetype;
188         unsigned int catta_interfaces;
189
190         // ADNS
191         pthread_t adns_thread;
192         pthread_cond_t adns_cond;
193         meshlink_queue_t adns_queue;
194         meshlink_queue_t adns_done_queue;
195         signal_t adns_signal;
196 };
197
198 /// A handle for a MeshLink node.
199 struct meshlink_node {
200         const char *name;
201         void *priv;
202 };
203
204 /// A handle for a node Sub-Mesh.
205 struct meshlink_submesh {
206         const char *name;
207         void *priv;
208 };
209
210 /// An AIO buffer.
211 typedef struct meshlink_aio_buffer {
212         const void *data;
213         int fd;
214         size_t len;
215         size_t done;
216         union {
217                 meshlink_aio_cb_t buffer;
218                 meshlink_aio_fd_cb_t fd;
219         } cb;
220         void *priv;
221         struct meshlink_aio_buffer *next;
222 } meshlink_aio_buffer_t;
223
224 /// A channel.
225 struct meshlink_channel {
226         struct node_t *node;
227         void *priv;
228         bool in_callback;
229
230         struct utcp_connection *c;
231         meshlink_aio_buffer_t *aio_send;
232         meshlink_aio_buffer_t *aio_receive;
233         meshlink_channel_receive_cb_t receive_cb;
234         meshlink_channel_poll_cb_t poll_cb;
235 };
236
237 /// Header for data packets routed between nodes
238 typedef struct meshlink_packethdr {
239         uint8_t destination[16];
240         uint8_t source[16];
241 } __attribute__((__packed__)) meshlink_packethdr_t;
242
243 void meshlink_send_from_queue(event_loop_t *loop, void *mesh);
244 void update_node_status(meshlink_handle_t *mesh, struct node_t *n);
245 void update_node_pmtu(meshlink_handle_t *mesh, struct node_t *n);
246 extern meshlink_log_level_t global_log_level;
247 extern meshlink_log_cb_t global_log_cb;
248 void handle_duplicate_node(meshlink_handle_t *mesh, struct node_t *n);
249 void handle_network_change(meshlink_handle_t *mesh, bool online);
250 void call_error_cb(meshlink_handle_t *mesh, meshlink_errno_t meshlink_errno);
251
252 /// Per-instance PRNG
253 static inline int prng(meshlink_handle_t *mesh, uint64_t max) {
254         return xoshiro(mesh->prng_state) % max;
255 }
256
257 /// Fudge value of ~0.1 seconds, in microseconds.
258 static const unsigned int TIMER_FUDGE = 0x8000000;
259
260 #endif