]> git.meshlink.io Git - meshlink/blob - src/meshlink_internal.h
Reset UTCP timers when learning a node's public key.
[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
36 #include <pthread.h>
37
38 #define MAXSOCKETS 4    /* Probably overkill... */
39
40 static const char meshlink_invitation_label[] = "MeshLink invitation";
41 static const char meshlink_tcp_label[] = "MeshLink TCP";
42 static const char meshlink_udp_label[] = "MeshLink UDP";
43
44 #define MESHLINK_CONFIG_VERSION 1
45 #define MESHLINK_INVITATION_VERSION 1
46
47 struct CattaServer;
48 struct CattaSServiceBrowser;
49 struct CattaSimplePoll;
50 struct CattaSEntryGroup;
51
52 typedef struct listen_socket_t {
53         struct io_t tcp;
54         struct io_t udp;
55         sockaddr_t sa;
56         bool bindto;
57 } listen_socket_t;
58
59 typedef enum proxytype_t {
60         PROXY_NONE = 0,
61         PROXY_SOCKS4,
62         PROXY_SOCKS4A,
63         PROXY_SOCKS5,
64         PROXY_HTTP,
65 } proxytype_t;
66
67 struct meshlink_open_params {
68         char *confbase;
69         char *appname;
70         char *name;
71         dev_class_t devclass;
72
73         int netns;
74
75         const void *key;
76         size_t keylen;
77 };
78
79 /// Device class traits
80 typedef struct {
81         int pinginterval;
82         int pingtimeout;
83         unsigned int min_connects;
84         unsigned int max_connects;
85         int edge_weight;
86 } dev_class_traits_t;
87
88 /// A handle for an instance of MeshLink.
89 struct meshlink_handle {
90         // public members
91         char *name;
92         void *priv;
93
94         // private members
95         pthread_mutex_t mesh_mutex;
96         event_loop_t loop;
97         struct node_t *self;
98         meshlink_log_cb_t log_cb;
99         meshlink_log_level_t log_level;
100
101         // The most important network-related members come first
102         int listen_sockets;
103         listen_socket_t listen_socket[MAXSOCKETS];
104
105         meshlink_receive_cb_t receive_cb;
106         meshlink_queue_t outpacketqueue;
107         signal_t datafromapp;
108
109         hash_t *node_udp_cache;
110
111         struct splay_tree_t *nodes;
112         struct splay_tree_t *edges;
113
114         struct list_t *connections;
115         struct list_t *outgoings;
116         struct list_t *submeshes;
117
118         // Meta-connection-related members
119         struct splay_tree_t *past_request_tree;
120         timeout_t past_request_timeout;
121
122         int connection_burst;
123         int contradicting_add_edge;
124         int contradicting_del_edge;
125         int sleeptime;
126         time_t connection_burst_time;
127         time_t last_config_check;
128         time_t last_hard_try;
129         timeout_t pingtimer;
130         timeout_t periodictimer;
131
132         struct connection_t *everyone;
133
134         int next_pit;
135         int pits[10];
136
137         // Infrequently used callbacks
138         meshlink_node_status_cb_t node_status_cb;
139         meshlink_channel_accept_cb_t channel_accept_cb;
140         meshlink_node_duplicate_cb_t node_duplicate_cb;
141         meshlink_connection_try_cb_t connection_try_cb;
142
143         // Mesh parameters
144         char *appname;
145         char *myport;
146
147         struct ecdsa *private_key;
148         struct ecdsa *invitation_key;
149
150         dev_class_t devclass;
151
152         int invitation_timeout;
153         int maxtimeout;
154         int udp_choice;
155
156         dev_class_traits_t dev_class_traits[DEV_CLASS_COUNT];
157
158         int netns;
159
160         bool default_blacklist;
161         bool discovery;         // Whether Catta is enabled or not
162
163
164         // Configuration
165         char *confbase;
166         FILE *conffile;
167         void *config_key;
168
169         // Thread management
170         pthread_t thread;
171         pthread_cond_t cond;
172         pthread_mutex_t discovery_mutex;
173         pthread_cond_t discovery_cond;
174         bool threadstarted;
175         bool discovery_threadstarted;
176
177         // Catta
178         pthread_t discovery_thread;
179         struct CattaServer *catta_server;
180         struct CattaSServiceBrowser *catta_browser;
181         struct CattaSimplePoll *catta_poll;
182         struct CattaSEntryGroup *catta_group;
183         char *catta_servicetype;
184         unsigned int catta_interfaces;
185
186         // State used for meshlink_join()
187         int sock;
188         char cookie[18], hash[18];
189         bool success;
190         sptps_t sptps;
191         char *data;
192         size_t thedatalen;
193         size_t blen;
194         char line[4096];
195         char buffer[4096];
196
197         // Proxy configuration, currently not exposed.
198         char *proxyhost;
199         char *proxyport;
200         char *proxyuser;
201         char *proxypass;
202         proxytype_t proxytype;
203 };
204
205 /// A handle for a MeshLink node.
206 struct meshlink_node {
207         const char *name;
208         void *priv;
209 };
210
211 /// A handle for a node Sub-Mesh.
212 struct meshlink_submesh {
213         const char *name;
214         void *priv;
215 };
216
217 /// An AIO buffer.
218 typedef struct meshlink_aio_buffer {
219         const void *data;
220         int fd;
221         size_t len;
222         size_t done;
223         union {
224                 meshlink_aio_cb_t buffer;
225                 meshlink_aio_fd_cb_t fd;
226         } cb;
227         void *priv;
228         struct meshlink_aio_buffer *next;
229 } meshlink_aio_buffer_t;
230
231 /// A channel.
232 struct meshlink_channel {
233         struct node_t *node;
234         void *priv;
235
236         struct utcp_connection *c;
237         meshlink_aio_buffer_t *aio_send;
238         meshlink_aio_buffer_t *aio_receive;
239         meshlink_channel_receive_cb_t receive_cb;
240         meshlink_channel_poll_cb_t poll_cb;
241 };
242
243 /// Header for data packets routed between nodes
244 typedef struct meshlink_packethdr {
245         uint8_t destination[16];
246         uint8_t source[16];
247 } __attribute__((__packed__)) meshlink_packethdr_t;
248
249 extern void meshlink_send_from_queue(event_loop_t *el, meshlink_handle_t *mesh);
250 extern void update_node_status(meshlink_handle_t *mesh, struct node_t *n);
251 extern meshlink_log_level_t global_log_level;
252 extern meshlink_log_cb_t global_log_cb;
253 extern int check_port(meshlink_handle_t *mesh);
254 extern void handle_duplicate_node(meshlink_handle_t *mesh, struct node_t *n);
255 extern void handle_network_change(meshlink_handle_t *mesh, bool online);
256
257 #endif