diff options
Diffstat (limited to 'src/cadet/gnunet-service-cadet.h')
-rw-r--r-- | src/cadet/gnunet-service-cadet.h | 332 |
1 files changed, 332 insertions, 0 deletions
diff --git a/src/cadet/gnunet-service-cadet.h b/src/cadet/gnunet-service-cadet.h new file mode 100644 index 000000000..162867823 --- /dev/null +++ b/src/cadet/gnunet-service-cadet.h | |||
@@ -0,0 +1,332 @@ | |||
1 | |||
2 | /* | ||
3 | This file is part of GNUnet. | ||
4 | Copyright (C) 2001-2017 GNUnet e.V. | ||
5 | |||
6 | GNUnet is free software; you can redistribute it and/or modify | ||
7 | it under the terms of the GNU General Public License as published | ||
8 | by the Free Software Foundation; either version 3, or (at your | ||
9 | option) any later version. | ||
10 | |||
11 | GNUnet is distributed in the hope that it will be useful, but | ||
12 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
14 | General Public License for more details. | ||
15 | |||
16 | You should have received a copy of the GNU General Public License | ||
17 | along with GNUnet; see the file COPYING. If not, write to the | ||
18 | Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, | ||
19 | Boston, MA 02110-1301, USA. | ||
20 | */ | ||
21 | |||
22 | /** | ||
23 | * @file cadet/gnunet-service-cadet.h | ||
24 | * @brief Information we track per peer. | ||
25 | * @author Bartlomiej Polot | ||
26 | * @author Christian Grothoff | ||
27 | */ | ||
28 | #ifndef GNUNET_SERVICE_CADET_H | ||
29 | #define GNUNET_SERVICE_CADET_H | ||
30 | |||
31 | #include "gnunet_util_lib.h" | ||
32 | #include "cadet_protocol.h" | ||
33 | |||
34 | /** | ||
35 | * A client to the CADET service. Each client gets a unique handle. | ||
36 | */ | ||
37 | struct CadetClient; | ||
38 | |||
39 | /** | ||
40 | * A peer in the GNUnet network. Each peer we care about must have one globally | ||
41 | * unique such handle within this process. | ||
42 | */ | ||
43 | struct CadetPeer; | ||
44 | |||
45 | /** | ||
46 | * Tunnel from us to another peer. There can only be at most one | ||
47 | * tunnel per peer. | ||
48 | */ | ||
49 | struct CadetTunnel; | ||
50 | |||
51 | /** | ||
52 | * Entry in the message queue of a `struct CadetTunnel`. | ||
53 | */ | ||
54 | struct CadetTunnelQueueEntry; | ||
55 | |||
56 | /** | ||
57 | * A path of peer in the GNUnet network. There must only be at most | ||
58 | * once such path. Paths may share disjoint prefixes, but must all | ||
59 | * end at a unique suffix. Paths must also not be proper subsets of | ||
60 | * other existing paths. | ||
61 | */ | ||
62 | struct CadetPeerPath; | ||
63 | |||
64 | /** | ||
65 | * Entry in a peer path. | ||
66 | */ | ||
67 | struct CadetPeerPathEntry | ||
68 | { | ||
69 | /** | ||
70 | * DLL of paths where the same @e peer is at the same offset. | ||
71 | */ | ||
72 | struct CadetPeerPathEntry *next; | ||
73 | |||
74 | /** | ||
75 | * DLL of paths where the same @e peer is at the same offset. | ||
76 | */ | ||
77 | struct CadetPeerPathEntry *prev; | ||
78 | |||
79 | /** | ||
80 | * The peer at this offset of the path. | ||
81 | */ | ||
82 | struct CadetPeer *peer; | ||
83 | |||
84 | /** | ||
85 | * Path this entry belongs to. | ||
86 | */ | ||
87 | struct CadetPeerPath *path; | ||
88 | |||
89 | /** | ||
90 | * Connection using this path, or NULL for none. | ||
91 | */ | ||
92 | struct CadetConnection *cc; | ||
93 | |||
94 | /** | ||
95 | * Path's historic score up to this point. Basically, how often did | ||
96 | * we succeed or fail to use the path up to this entry in a | ||
97 | * connection. Positive values indicate good experiences, negative | ||
98 | * values bad experiences. Code updating the score must guard | ||
99 | * against overflows. | ||
100 | */ | ||
101 | int score; | ||
102 | |||
103 | }; | ||
104 | |||
105 | /** | ||
106 | * Entry in list of connections used by tunnel, with metadata. | ||
107 | */ | ||
108 | struct CadetTConnection | ||
109 | { | ||
110 | /** | ||
111 | * Next in DLL. | ||
112 | */ | ||
113 | struct CadetTConnection *next; | ||
114 | |||
115 | /** | ||
116 | * Prev in DLL. | ||
117 | */ | ||
118 | struct CadetTConnection *prev; | ||
119 | |||
120 | /** | ||
121 | * Connection handle. | ||
122 | */ | ||
123 | struct CadetConnection *cc; | ||
124 | |||
125 | /** | ||
126 | * Tunnel this connection belongs to. | ||
127 | */ | ||
128 | struct CadetTunnel *t; | ||
129 | |||
130 | /** | ||
131 | * Creation time, to keep oldest connection alive. | ||
132 | */ | ||
133 | struct GNUNET_TIME_Absolute created; | ||
134 | |||
135 | /** | ||
136 | * Connection throughput, to keep fastest connection alive. | ||
137 | */ | ||
138 | uint32_t throughput; | ||
139 | |||
140 | /** | ||
141 | * Is the connection currently ready for transmission? | ||
142 | */ | ||
143 | int is_ready; | ||
144 | }; | ||
145 | |||
146 | |||
147 | /** | ||
148 | * Port opened by a client. | ||
149 | */ | ||
150 | struct OpenPort | ||
151 | { | ||
152 | |||
153 | /** | ||
154 | * Client that opened the port. | ||
155 | */ | ||
156 | struct CadetClient *c; | ||
157 | |||
158 | /** | ||
159 | * Port number. | ||
160 | */ | ||
161 | struct GNUNET_HashCode port; | ||
162 | |||
163 | /** | ||
164 | * Port hashed with our PID (matches incoming OPEN messages). | ||
165 | */ | ||
166 | struct GNUNET_HashCode h_port; | ||
167 | |||
168 | }; | ||
169 | |||
170 | |||
171 | /** | ||
172 | * Active path through the network (used by a tunnel). There may | ||
173 | * be at most one connection per path. | ||
174 | */ | ||
175 | struct CadetConnection; | ||
176 | |||
177 | /** | ||
178 | * Description of a segment of a `struct CadetConnection` at the | ||
179 | * intermediate peers. Routes are basically entries in a peer's | ||
180 | * routing table for forwarding traffic. At both endpoints, the | ||
181 | * routes are terminated by a `struct CadetConnection`, which knows | ||
182 | * the complete `struct CadetPath` that is formed by the individual | ||
183 | * routes. | ||
184 | */ | ||
185 | struct CadetRoute; | ||
186 | |||
187 | /** | ||
188 | * Logical end-to-end conenction between clients. There can be | ||
189 | * any number of channels between clients. | ||
190 | */ | ||
191 | struct CadetChannel; | ||
192 | |||
193 | /** | ||
194 | * Handle to our configuration. | ||
195 | */ | ||
196 | extern const struct GNUNET_CONFIGURATION_Handle *cfg; | ||
197 | |||
198 | /** | ||
199 | * Handle to the statistics service. | ||
200 | */ | ||
201 | extern struct GNUNET_STATISTICS_Handle *stats; | ||
202 | |||
203 | /** | ||
204 | * Handle to communicate with ATS. | ||
205 | */ | ||
206 | extern struct GNUNET_ATS_ConnectivityHandle *ats_ch; | ||
207 | |||
208 | /** | ||
209 | * Local peer own ID. | ||
210 | */ | ||
211 | extern struct GNUNET_PeerIdentity my_full_id; | ||
212 | |||
213 | /** | ||
214 | * Own private key. | ||
215 | */ | ||
216 | extern struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key; | ||
217 | |||
218 | /** | ||
219 | * All ports clients of this peer have opened. Maps from | ||
220 | * a hashed port to a `struct OpenPort`. | ||
221 | */ | ||
222 | extern struct GNUNET_CONTAINER_MultiHashMap *open_ports; | ||
223 | |||
224 | /** | ||
225 | * Map from `struct GNUNET_CADET_ConnectionTunnelIdentifier` | ||
226 | * hash codes to `struct CadetConnection` objects. | ||
227 | */ | ||
228 | extern struct GNUNET_CONTAINER_MultiShortmap *connections; | ||
229 | |||
230 | /** | ||
231 | * Map from ports to channels where the ports were closed at the | ||
232 | * time we got the inbound connection. | ||
233 | * Indexed by h_port, contains `struct CadetChannel`. | ||
234 | */ | ||
235 | extern struct GNUNET_CONTAINER_MultiHashMap *loose_channels; | ||
236 | |||
237 | /** | ||
238 | * Map from PIDs to `struct CadetPeer` entries. | ||
239 | */ | ||
240 | extern struct GNUNET_CONTAINER_MultiPeerMap *peers; | ||
241 | |||
242 | /** | ||
243 | * How many messages are needed to trigger an AXOLOTL ratchet advance. | ||
244 | */ | ||
245 | extern unsigned long long ratchet_messages; | ||
246 | |||
247 | /** | ||
248 | * How long until we trigger a ratched advance due to time. | ||
249 | */ | ||
250 | extern struct GNUNET_TIME_Relative ratchet_time; | ||
251 | |||
252 | /** | ||
253 | * How frequently do we send KEEPALIVE messages on idle connections? | ||
254 | */ | ||
255 | extern struct GNUNET_TIME_Relative keepalive_period; | ||
256 | |||
257 | /** | ||
258 | * Signal that shutdown is happening: prevent recovery measures. | ||
259 | */ | ||
260 | extern int shutting_down; | ||
261 | |||
262 | /** | ||
263 | * Set to non-zero values to create random drops to test retransmissions. | ||
264 | */ | ||
265 | extern unsigned long long drop_percent; | ||
266 | |||
267 | |||
268 | /** | ||
269 | * Send a message to a client. | ||
270 | * | ||
271 | * @param c client to get the message | ||
272 | * @param env envelope with the message | ||
273 | */ | ||
274 | void | ||
275 | GSC_send_to_client (struct CadetClient *c, | ||
276 | struct GNUNET_MQ_Envelope *env); | ||
277 | |||
278 | |||
279 | /** | ||
280 | * A channel was destroyed by the other peer. Tell our client. | ||
281 | * | ||
282 | * @param c client that lost a channel | ||
283 | * @param ccn channel identification number for the client | ||
284 | * @param ch the channel object | ||
285 | */ | ||
286 | void | ||
287 | GSC_handle_remote_channel_destroy (struct CadetClient *c, | ||
288 | struct GNUNET_CADET_ClientChannelNumber ccn, | ||
289 | struct CadetChannel *ch); | ||
290 | |||
291 | /** | ||
292 | * A client that created a loose channel that was not bound to a port | ||
293 | * disconnected, drop it from the #loose_channels list. | ||
294 | * | ||
295 | * @param h_port the hashed port the channel was trying to bind to | ||
296 | * @param ch the channel that was lost | ||
297 | */ | ||
298 | void | ||
299 | GSC_drop_loose_channel (const struct GNUNET_HashCode *h_port, | ||
300 | struct CadetChannel *ch); | ||
301 | |||
302 | |||
303 | /** | ||
304 | * Bind incoming channel to this client, and notify client | ||
305 | * about incoming connection. | ||
306 | * | ||
307 | * @param c client to bind to | ||
308 | * @param ch channel to be bound | ||
309 | * @param dest peer that establishes the connection | ||
310 | * @param port port number | ||
311 | * @param options options | ||
312 | * @return local channel number assigned to the new client | ||
313 | */ | ||
314 | struct GNUNET_CADET_ClientChannelNumber | ||
315 | GSC_bind (struct CadetClient *c, | ||
316 | struct CadetChannel *ch, | ||
317 | struct CadetPeer *dest, | ||
318 | const struct GNUNET_HashCode *port, | ||
319 | uint32_t options); | ||
320 | |||
321 | |||
322 | /** | ||
323 | * Return identifier for a client as a string. | ||
324 | * | ||
325 | * @param c client to identify | ||
326 | * @return string for debugging | ||
327 | */ | ||
328 | const char * | ||
329 | GSC_2s (struct CadetClient *c); | ||
330 | |||
331 | |||
332 | #endif | ||