diff options
Diffstat (limited to 'src/transport/plugin_transport_tcp.c')
-rw-r--r-- | src/transport/plugin_transport_tcp.c | 587 |
1 files changed, 537 insertions, 50 deletions
diff --git a/src/transport/plugin_transport_tcp.c b/src/transport/plugin_transport_tcp.c index 34bbd00e0..a63013caa 100644 --- a/src/transport/plugin_transport_tcp.c +++ b/src/transport/plugin_transport_tcp.c | |||
@@ -45,10 +45,538 @@ | |||
45 | */ | 45 | */ |
46 | #define NAT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10) | 46 | #define NAT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10) |
47 | 47 | ||
48 | GNUNET_NETWORK_STRUCT_BEGIN | 48 | /** |
49 | * Opaque handle that can be used to cancel | ||
50 | * a transmit-ready notification. | ||
51 | */ | ||
52 | struct GNUNET_CONNECTION_TransmitHandle; | ||
53 | |||
54 | /** | ||
55 | * @brief handle for a server | ||
56 | */ | ||
57 | struct GNUNET_SERVER_Handle; | ||
58 | |||
59 | /** | ||
60 | * @brief opaque handle for a client of the server | ||
61 | */ | ||
62 | struct GNUNET_SERVER_Client; | ||
63 | |||
64 | /** | ||
65 | * @brief opaque handle server returns for aborting transmission to a client. | ||
66 | */ | ||
67 | struct GNUNET_SERVER_TransmitHandle; | ||
68 | |||
69 | /** | ||
70 | * @brief handle for a network connection | ||
71 | */ | ||
72 | struct GNUNET_CONNECTION_Handle; | ||
73 | |||
74 | /** | ||
75 | * @brief handle for a network service | ||
76 | */ | ||
77 | struct LEGACY_SERVICE_Context; | ||
78 | |||
79 | |||
80 | /** | ||
81 | * Stops a service that was started with #GNUNET_SERVICE_start(). | ||
82 | * | ||
83 | * @param srv service to stop | ||
84 | */ | ||
85 | void | ||
86 | LEGACY_SERVICE_stop (struct LEGACY_SERVICE_Context *srv); | ||
87 | |||
88 | |||
89 | |||
90 | /** | ||
91 | * Function called to notify a client about the connection begin ready | ||
92 | * to queue more data. @a buf will be NULL and @a size zero if the | ||
93 | * connection was closed for writing in the meantime. | ||
94 | * | ||
95 | * @param cls closure | ||
96 | * @param size number of bytes available in @a buf | ||
97 | * @param buf where the callee should write the message | ||
98 | * @return number of bytes written to @a buf | ||
99 | */ | ||
100 | typedef size_t | ||
101 | (*GNUNET_CONNECTION_TransmitReadyNotify) (void *cls, | ||
102 | size_t size, | ||
103 | void *buf); | ||
104 | |||
105 | /** | ||
106 | * Credentials for UNIX domain sockets. | ||
107 | */ | ||
108 | struct GNUNET_CONNECTION_Credentials | ||
109 | { | ||
110 | /** | ||
111 | * UID of the other end of the connection. | ||
112 | */ | ||
113 | uid_t uid; | ||
114 | |||
115 | /** | ||
116 | * GID of the other end of the connection. | ||
117 | */ | ||
118 | gid_t gid; | ||
119 | }; | ||
120 | |||
121 | |||
122 | /** | ||
123 | * Functions with this signature are called whenever a client | ||
124 | * is disconnected on the network level. | ||
125 | * | ||
126 | * @param cls closure | ||
127 | * @param client identification of the client; NULL | ||
128 | * for the last call when the server is destroyed | ||
129 | */ | ||
130 | typedef void | ||
131 | (*GNUNET_SERVER_DisconnectCallback) (void *cls, | ||
132 | struct GNUNET_SERVER_Client *client); | ||
133 | |||
134 | |||
135 | /** | ||
136 | * Functions with this signature are called whenever a client | ||
137 | * is connected on the network level. | ||
138 | * | ||
139 | * @param cls closure | ||
140 | * @param client identification of the client | ||
141 | */ | ||
142 | typedef void | ||
143 | (*GNUNET_SERVER_ConnectCallback) (void *cls, | ||
144 | struct GNUNET_SERVER_Client *client); | ||
145 | |||
146 | |||
147 | |||
148 | |||
149 | /** | ||
150 | * Function to call for access control checks. | ||
151 | * | ||
152 | * @param cls closure | ||
153 | * @param ucred credentials, if available, otherwise NULL | ||
154 | * @param addr address | ||
155 | * @param addrlen length of address | ||
156 | * @return GNUNET_YES to allow, GNUNET_NO to deny, GNUNET_SYSERR | ||
157 | * for unknown address family (will be denied). | ||
158 | */ | ||
159 | typedef int | ||
160 | (*GNUNET_CONNECTION_AccessCheck) (void *cls, | ||
161 | const struct | ||
162 | GNUNET_CONNECTION_Credentials * | ||
163 | ucred, | ||
164 | const struct sockaddr * addr, | ||
165 | socklen_t addrlen); | ||
166 | |||
167 | /** | ||
168 | * Callback function for data received from the network. Note that | ||
169 | * both "available" and "err" would be 0 if the read simply timed out. | ||
170 | * | ||
171 | * @param cls closure | ||
172 | * @param buf pointer to received data | ||
173 | * @param available number of bytes availabe in "buf", | ||
174 | * possibly 0 (on errors) | ||
175 | * @param addr address of the sender | ||
176 | * @param addrlen size of addr | ||
177 | * @param errCode value of errno (on errors receiving) | ||
178 | */ | ||
179 | typedef void | ||
180 | (*GNUNET_CONNECTION_Receiver) (void *cls, const void *buf, | ||
181 | size_t available, | ||
182 | const struct sockaddr * addr, | ||
183 | socklen_t addrlen, int errCode); | ||
184 | |||
185 | |||
186 | |||
187 | /** | ||
188 | * Close the connection and free associated resources. There must | ||
189 | * not be any pending requests for reading or writing to the | ||
190 | * connection at this time. | ||
191 | * | ||
192 | * @param connection connection to destroy | ||
193 | */ | ||
194 | void | ||
195 | GNUNET_CONNECTION_destroy (struct GNUNET_CONNECTION_Handle *connection); | ||
196 | |||
197 | |||
198 | /** | ||
199 | * Signature of a function to create a custom tokenizer. | ||
200 | * | ||
201 | * @param cls closure from #GNUNET_SERVER_set_callbacks | ||
202 | * @param client handle to client the tokenzier will be used for | ||
203 | * @return handle to custom tokenizer ('mst') | ||
204 | */ | ||
205 | typedef void* | ||
206 | (*GNUNET_SERVER_MstCreateCallback) (void *cls, | ||
207 | struct GNUNET_SERVER_Client *client); | ||
208 | |||
209 | |||
210 | /** | ||
211 | * Signature of a function to destroy a custom tokenizer. | ||
212 | * | ||
213 | * @param cls closure from #GNUNET_SERVER_set_callbacks | ||
214 | * @param mst custom tokenizer handle | ||
215 | */ | ||
216 | typedef void | ||
217 | (*GNUNET_SERVER_MstDestroyCallback) (void *cls, | ||
218 | void *mst); | ||
219 | |||
220 | /** | ||
221 | * Signature of a function to receive data for a custom tokenizer. | ||
222 | * | ||
223 | * @param cls closure from #GNUNET_SERVER_set_callbacks | ||
224 | * @param mst custom tokenizer handle | ||
225 | * @param client_identity ID of client for which this is a buffer, | ||
226 | * can be NULL (will be passed back to 'cb') | ||
227 | * @param buf input data to add | ||
228 | * @param size number of bytes in @a buf | ||
229 | * @param purge should any excess bytes in the buffer be discarded | ||
230 | * (i.e. for packet-based services like UDP) | ||
231 | * @param one_shot only call callback once, keep rest of message in buffer | ||
232 | * @return #GNUNET_OK if we are done processing (need more data) | ||
233 | * #GNUNET_NO if one_shot was set and we have another message ready | ||
234 | * #GNUNET_SYSERR if the data stream is corrupt | ||
235 | */ | ||
236 | typedef int | ||
237 | (*GNUNET_SERVER_MstReceiveCallback) (void *cls, void *mst, | ||
238 | struct GNUNET_SERVER_Client *client, | ||
239 | const char *buf, | ||
240 | size_t size, | ||
241 | int purge, | ||
242 | int one_shot); | ||
243 | /** | ||
244 | * Functions with this signature are called whenever a message is | ||
245 | * received. | ||
246 | * | ||
247 | * @param cls closure | ||
248 | * @param client identification of the client | ||
249 | * @param message the actual message | ||
250 | */ | ||
251 | typedef void | ||
252 | (*GNUNET_SERVER_MessageCallback) (void *cls, | ||
253 | struct GNUNET_SERVER_Client *client, | ||
254 | const struct GNUNET_MessageHeader *message); | ||
255 | |||
256 | /** | ||
257 | * Message handler. Each struct specifies how to handle on particular | ||
258 | * type of message received. | ||
259 | */ | ||
260 | struct GNUNET_SERVER_MessageHandler | ||
261 | { | ||
262 | /** | ||
263 | * Function to call for messages of "type". | ||
264 | */ | ||
265 | GNUNET_SERVER_MessageCallback callback; | ||
266 | |||
267 | /** | ||
268 | * Closure argument for @e callback. | ||
269 | */ | ||
270 | void *callback_cls; | ||
271 | |||
272 | /** | ||
273 | * Type of the message this handler covers. | ||
274 | */ | ||
275 | uint16_t type; | ||
276 | |||
277 | /** | ||
278 | * Expected size of messages of this type. Use 0 for | ||
279 | * variable-size. If non-zero, messages of the given | ||
280 | * type will be discarded (and the connection closed) | ||
281 | * if they do not have the right size. | ||
282 | */ | ||
283 | uint16_t expected_size; | ||
284 | |||
285 | }; | ||
286 | |||
287 | |||
288 | /** | ||
289 | * Options for the service (bitmask). | ||
290 | */ | ||
291 | enum LEGACY_SERVICE_Options | ||
292 | { | ||
293 | /** | ||
294 | * Use defaults. Terminates all client connections and the listen | ||
295 | * sockets immediately upon receiving the shutdown signal. | ||
296 | */ | ||
297 | LEGACY_SERVICE_OPTION_NONE = 0, | ||
298 | |||
299 | /** | ||
300 | * Do not trigger server shutdown on signal at all; instead, allow | ||
301 | * for the user to terminate the server explicitly when needed | ||
302 | * by calling #LEGACY_SERVICE_shutdown(). | ||
303 | */ | ||
304 | LEGACY_SERVICE_OPTION_MANUAL_SHUTDOWN = 1, | ||
305 | |||
306 | /** | ||
307 | * Trigger a SOFT server shutdown on signals, allowing active | ||
308 | * non-monitor clients to complete their transactions. | ||
309 | */ | ||
310 | LEGACY_SERVICE_OPTION_SOFT_SHUTDOWN = 2 | ||
311 | }; | ||
312 | |||
313 | |||
314 | |||
315 | /** | ||
316 | * Ask the server to disconnect from the given client. This is the | ||
317 | * same as passing #GNUNET_SYSERR to #GNUNET_SERVER_receive_done, | ||
318 | * except that it allows dropping of a client even when not handling a | ||
319 | * message from that client. | ||
320 | * | ||
321 | * @param client the client to disconnect from | ||
322 | */ | ||
323 | void | ||
324 | GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client); | ||
325 | |||
326 | /** | ||
327 | * Return user context associated with the given client. | ||
328 | * Note: you should probably use the macro (call without the underscore). | ||
329 | * | ||
330 | * @param client client to query | ||
331 | * @param size number of bytes in user context struct (for verification only) | ||
332 | * @return pointer to user context | ||
333 | */ | ||
334 | void * | ||
335 | GNUNET_SERVER_client_get_user_context_ (struct GNUNET_SERVER_Client *client, | ||
336 | size_t size); | ||
337 | |||
338 | |||
339 | /** | ||
340 | * Functions with this signature are called whenever a | ||
341 | * complete message is received by the tokenizer. | ||
342 | * | ||
343 | * Do not call #GNUNET_SERVER_mst_destroy from within | ||
344 | * the scope of this callback. | ||
345 | * | ||
346 | * @param cls closure | ||
347 | * @param client identification of the client | ||
348 | * @param message the actual message | ||
349 | * @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing | ||
350 | */ | ||
351 | typedef int | ||
352 | (*GNUNET_SERVER_MessageTokenizerCallback) (void *cls, | ||
353 | void *client, | ||
354 | const struct GNUNET_MessageHeader *message); | ||
355 | |||
356 | |||
357 | /** | ||
358 | * Create a message stream tokenizer. | ||
359 | * | ||
360 | * @param cb function to call on completed messages | ||
361 | * @param cb_cls closure for @a cb | ||
362 | * @return handle to tokenizer | ||
363 | */ | ||
364 | struct GNUNET_SERVER_MessageStreamTokenizer * | ||
365 | GNUNET_SERVER_mst_create (GNUNET_SERVER_MessageTokenizerCallback cb, | ||
366 | void *cb_cls); | ||
367 | |||
368 | /** | ||
369 | * Add incoming data to the receive buffer and call the | ||
370 | * callback for all complete messages. | ||
371 | * | ||
372 | * @param mst tokenizer to use | ||
373 | * @param client_identity ID of client for which this is a buffer, | ||
374 | * can be NULL (will be passed back to 'cb') | ||
375 | * @param buf input data to add | ||
376 | * @param size number of bytes in @a buf | ||
377 | * @param purge should any excess bytes in the buffer be discarded | ||
378 | * (i.e. for packet-based services like UDP) | ||
379 | * @param one_shot only call callback once, keep rest of message in buffer | ||
380 | * @return #GNUNET_OK if we are done processing (need more data) | ||
381 | * #GNUNET_NO if one_shot was set and we have another message ready | ||
382 | * #GNUNET_SYSERR if the data stream is corrupt | ||
383 | */ | ||
384 | int | ||
385 | GNUNET_SERVER_mst_receive (struct GNUNET_SERVER_MessageStreamTokenizer *mst, | ||
386 | void *client_identity, | ||
387 | const char *buf, size_t size, | ||
388 | int purge, int one_shot); | ||
389 | |||
390 | |||
391 | |||
392 | /** | ||
393 | * Destroys a tokenizer. | ||
394 | * | ||
395 | * @param mst tokenizer to destroy | ||
396 | */ | ||
397 | void | ||
398 | GNUNET_SERVER_mst_destroy (struct GNUNET_SERVER_MessageStreamTokenizer *mst); | ||
49 | 399 | ||
50 | 400 | ||
51 | /** | 401 | /** |
402 | * Set user context to be associated with the given client. | ||
403 | * Note: you should probably use the macro (call without the underscore). | ||
404 | * | ||
405 | * @param client client to query | ||
406 | * @param ptr pointer to user context | ||
407 | * @param size number of bytes in user context struct (for verification only) | ||
408 | */ | ||
409 | void | ||
410 | GNUNET_SERVER_client_set_user_context_ (struct GNUNET_SERVER_Client *client, | ||
411 | void *ptr, | ||
412 | size_t size); | ||
413 | /** | ||
414 | * Return user context associated with the given client. | ||
415 | * | ||
416 | * @param client client to query | ||
417 | * @param type expected return type (i.e. 'struct Foo') | ||
418 | * @return pointer to user context of type 'type *'. | ||
419 | */ | ||
420 | #define GNUNET_SERVER_client_get_user_context(client,type) \ | ||
421 | (type *) GNUNET_SERVER_client_get_user_context_ (client, sizeof (type)) | ||
422 | |||
423 | /** | ||
424 | * Set user context to be associated with the given client. | ||
425 | * | ||
426 | * @param client client to query | ||
427 | * @param value pointer to user context | ||
428 | */ | ||
429 | #define GNUNET_SERVER_client_set_user_context(client,value) \ | ||
430 | GNUNET_SERVER_client_set_user_context_ (client, value, sizeof (*value)) | ||
431 | |||
432 | |||
433 | |||
434 | /** | ||
435 | * Notify us when the server has enough space to transmit | ||
436 | * a message of the given size to the given client. | ||
437 | * | ||
438 | * @param client client to transmit message to | ||
439 | * @param size requested amount of buffer space | ||
440 | * @param timeout after how long should we give up (and call | ||
441 | * notify with buf NULL and size 0)? | ||
442 | * @param callback function to call when space is available | ||
443 | * @param callback_cls closure for @a callback | ||
444 | * @return non-NULL if the notify callback was queued; can be used | ||
445 | * to cancel the request using | ||
446 | * #GNUNET_SERVER_notify_transmit_ready_cancel. | ||
447 | * NULL if we are already going to notify someone else (busy) | ||
448 | */ | ||
449 | struct GNUNET_SERVER_TransmitHandle * | ||
450 | GNUNET_SERVER_notify_transmit_ready (struct GNUNET_SERVER_Client *client, | ||
451 | size_t size, | ||
452 | struct GNUNET_TIME_Relative timeout, | ||
453 | GNUNET_CONNECTION_TransmitReadyNotify callback, | ||
454 | void *callback_cls); | ||
455 | |||
456 | /** | ||
457 | * Abort transmission request. | ||
458 | * | ||
459 | * @param th request to abort | ||
460 | */ | ||
461 | void | ||
462 | GNUNET_SERVER_notify_transmit_ready_cancel (struct GNUNET_SERVER_TransmitHandle *th); | ||
463 | |||
464 | |||
465 | |||
466 | |||
467 | /** | ||
468 | * Notify the server that the given client handle should | ||
469 | * be kept (keeps the connection up if possible, increments | ||
470 | * the internal reference counter). | ||
471 | * | ||
472 | * @param client the client to keep | ||
473 | */ | ||
474 | void | ||
475 | GNUNET_SERVER_client_keep (struct GNUNET_SERVER_Client *client); | ||
476 | |||
477 | |||
478 | /** | ||
479 | * Notify the server that the given client handle is no | ||
480 | * longer required. Decrements the reference counter. If | ||
481 | * that counter reaches zero an inactive connection maybe | ||
482 | * closed. | ||
483 | * | ||
484 | * @param client the client to drop | ||
485 | */ | ||
486 | void | ||
487 | GNUNET_SERVER_client_drop (struct GNUNET_SERVER_Client *client); | ||
488 | |||
489 | |||
490 | /** | ||
491 | * Function called by the service's run | ||
492 | * method to run service-specific setup code. | ||
493 | * | ||
494 | * @param cls closure | ||
495 | * @param server the initialized server | ||
496 | * @param cfg configuration to use | ||
497 | */ | ||
498 | typedef void | ||
499 | (*LEGACY_SERVICE_Main) (void *cls, | ||
500 | struct GNUNET_SERVER_Handle *server, | ||
501 | const struct GNUNET_CONFIGURATION_Handle *cfg); | ||
502 | |||
503 | |||
504 | |||
505 | /** | ||
506 | * Suspend accepting connections from the listen socket temporarily. | ||
507 | * Resume activity using #GNUNET_SERVER_resume. | ||
508 | * | ||
509 | * @param server server to stop accepting connections. | ||
510 | */ | ||
511 | void | ||
512 | GNUNET_SERVER_suspend (struct GNUNET_SERVER_Handle *server); | ||
513 | |||
514 | /** | ||
515 | * Notify us when the server has enough space to transmit | ||
516 | * a message of the given size to the given client. | ||
517 | * | ||
518 | * @param client client to transmit message to | ||
519 | * @param size requested amount of buffer space | ||
520 | * @param timeout after how long should we give up (and call | ||
521 | * notify with buf NULL and size 0)? | ||
522 | * @param callback function to call when space is available | ||
523 | * @param callback_cls closure for @a callback | ||
524 | * @return non-NULL if the notify callback was queued; can be used | ||
525 | * to cancel the request using | ||
526 | * #GNUNET_SERVER_notify_transmit_ready_cancel. | ||
527 | * NULL if we are already going to notify someone else (busy) | ||
528 | */ | ||
529 | struct GNUNET_SERVER_TransmitHandle * | ||
530 | GNUNET_SERVER_notify_transmit_ready (struct GNUNET_SERVER_Client *client, | ||
531 | size_t size, | ||
532 | struct GNUNET_TIME_Relative timeout, | ||
533 | GNUNET_CONNECTION_TransmitReadyNotify callback, | ||
534 | void *callback_cls); | ||
535 | |||
536 | |||
537 | /** | ||
538 | * Add a TCP socket-based connection to the set of handles managed by | ||
539 | * this server. Use this function for outgoing (P2P) connections that | ||
540 | * we initiated (and where this server should process incoming | ||
541 | * messages). | ||
542 | * | ||
543 | * @param server the server to use | ||
544 | * @param connection the connection to manage (client must | ||
545 | * stop using this connection from now on) | ||
546 | * @return the client handle | ||
547 | */ | ||
548 | struct GNUNET_SERVER_Client * | ||
549 | GNUNET_SERVER_connect_socket (struct GNUNET_SERVER_Handle *server, | ||
550 | struct GNUNET_CONNECTION_Handle *connection); | ||
551 | |||
552 | |||
553 | /** | ||
554 | * Resume accepting connections from the listen socket. | ||
555 | * | ||
556 | * @param server server to resume accepting connections. | ||
557 | */ | ||
558 | void | ||
559 | GNUNET_SERVER_resume (struct GNUNET_SERVER_Handle *server); | ||
560 | |||
561 | /** | ||
562 | * Free resources held by this server. | ||
563 | * | ||
564 | * @param server server to destroy | ||
565 | */ | ||
566 | void | ||
567 | GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *server); | ||
568 | |||
569 | |||
570 | |||
571 | |||
572 | #include "tcp_connection_legacy.c" | ||
573 | #include "tcp_server_mst_legacy.c" | ||
574 | #include "tcp_server_legacy.c" | ||
575 | #include "tcp_service_legacy.c" | ||
576 | |||
577 | GNUNET_NETWORK_STRUCT_BEGIN | ||
578 | |||
579 | /** | ||
52 | * Initial handshake message for a session. | 580 | * Initial handshake message for a session. |
53 | */ | 581 | */ |
54 | struct WelcomeMessage | 582 | struct WelcomeMessage |
@@ -434,7 +962,7 @@ struct Plugin | |||
434 | /** | 962 | /** |
435 | * Handle to the network service. | 963 | * Handle to the network service. |
436 | */ | 964 | */ |
437 | struct GNUNET_SERVICE_Context *service; | 965 | struct LEGACY_SERVICE_Context *service; |
438 | 966 | ||
439 | /** | 967 | /** |
440 | * Handle to the server for this service. | 968 | * Handle to the server for this service. |
@@ -521,47 +1049,6 @@ struct Plugin | |||
521 | }; | 1049 | }; |
522 | 1050 | ||
523 | 1051 | ||
524 | /* begin of ancient copy-and-pasted code that should be | ||
525 | specialized for TCP ...*/ | ||
526 | /** | ||
527 | * Add the given UNIX domain path as an address to the | ||
528 | * list (as the first entry). | ||
529 | * | ||
530 | * @param saddrs array to update | ||
531 | * @param saddrlens where to store the address length | ||
532 | * @param unixpath path to add | ||
533 | * @param abstract #GNUNET_YES to add an abstract UNIX domain socket. This | ||
534 | * parameter is ignore on systems other than LINUX | ||
535 | */ | ||
536 | static void | ||
537 | add_unixpath (struct sockaddr **saddrs, | ||
538 | socklen_t *saddrlens, | ||
539 | const char *unixpath, | ||
540 | int abstract) | ||
541 | { | ||
542 | #ifdef AF_UNIX | ||
543 | struct sockaddr_un *un; | ||
544 | |||
545 | un = GNUNET_new (struct sockaddr_un); | ||
546 | un->sun_family = AF_UNIX; | ||
547 | strncpy (un->sun_path, unixpath, sizeof (un->sun_path) - 1); | ||
548 | #ifdef LINUX | ||
549 | if (GNUNET_YES == abstract) | ||
550 | un->sun_path[0] = '\0'; | ||
551 | #endif | ||
552 | #if HAVE_SOCKADDR_UN_SUN_LEN | ||
553 | un->sun_len = (u_char) sizeof (struct sockaddr_un); | ||
554 | #endif | ||
555 | *saddrs = (struct sockaddr *) un; | ||
556 | *saddrlens = sizeof (struct sockaddr_un); | ||
557 | #else | ||
558 | /* this function should never be called | ||
559 | * unless AF_UNIX is defined! */ | ||
560 | GNUNET_assert (0); | ||
561 | #endif | ||
562 | } | ||
563 | |||
564 | |||
565 | /** | 1052 | /** |
566 | * Get the list of addresses that a server for the given service | 1053 | * Get the list of addresses that a server for the given service |
567 | * should bind to. | 1054 | * should bind to. |
@@ -3289,7 +3776,7 @@ libgnunet_plugin_transport_tcp_init (void *cls) | |||
3289 | struct GNUNET_TRANSPORT_PluginEnvironment *env = cls; | 3776 | struct GNUNET_TRANSPORT_PluginEnvironment *env = cls; |
3290 | struct GNUNET_TRANSPORT_PluginFunctions *api; | 3777 | struct GNUNET_TRANSPORT_PluginFunctions *api; |
3291 | struct Plugin *plugin; | 3778 | struct Plugin *plugin; |
3292 | struct GNUNET_SERVICE_Context *service; | 3779 | struct LEGACY_SERVICE_Context *service; |
3293 | unsigned long long aport; | 3780 | unsigned long long aport; |
3294 | unsigned long long bport; | 3781 | unsigned long long bport; |
3295 | unsigned long long max_connections; | 3782 | unsigned long long max_connections; |
@@ -3344,9 +3831,9 @@ libgnunet_plugin_transport_tcp_init (void *cls) | |||
3344 | aport = 0; | 3831 | aport = 0; |
3345 | if (0 != bport) | 3832 | if (0 != bport) |
3346 | { | 3833 | { |
3347 | service = GNUNET_SERVICE_start ("transport-tcp", | 3834 | service = LEGACY_SERVICE_start ("transport-tcp", |
3348 | env->cfg, | 3835 | env->cfg, |
3349 | GNUNET_SERVICE_OPTION_NONE); | 3836 | LEGACY_SERVICE_OPTION_NONE); |
3350 | if (NULL == service) | 3837 | if (NULL == service) |
3351 | { | 3838 | { |
3352 | LOG (GNUNET_ERROR_TYPE_WARNING, | 3839 | LOG (GNUNET_ERROR_TYPE_WARNING, |
@@ -3377,7 +3864,7 @@ libgnunet_plugin_transport_tcp_init (void *cls) | |||
3377 | { | 3864 | { |
3378 | #ifdef TCP_STEALTH | 3865 | #ifdef TCP_STEALTH |
3379 | plugin->myoptions |= TCP_OPTIONS_TCP_STEALTH; | 3866 | plugin->myoptions |= TCP_OPTIONS_TCP_STEALTH; |
3380 | lsocks = GNUNET_SERVICE_get_listen_sockets (service); | 3867 | lsocks = LEGACY_SERVICE_get_listen_sockets (service); |
3381 | if (NULL != lsocks) | 3868 | if (NULL != lsocks) |
3382 | { | 3869 | { |
3383 | uint32_t len = sizeof (struct WelcomeMessage); | 3870 | uint32_t len = sizeof (struct WelcomeMessage); |
@@ -3470,7 +3957,7 @@ libgnunet_plugin_transport_tcp_init (void *cls) | |||
3470 | plugin->service = service; | 3957 | plugin->service = service; |
3471 | if (NULL != service) | 3958 | if (NULL != service) |
3472 | { | 3959 | { |
3473 | plugin->server = GNUNET_SERVICE_get_server (service); | 3960 | plugin->server = LEGACY_SERVICE_get_server (service); |
3474 | } | 3961 | } |
3475 | else | 3962 | else |
3476 | { | 3963 | { |
@@ -3533,7 +4020,7 @@ libgnunet_plugin_transport_tcp_init (void *cls) | |||
3533 | GNUNET_NAT_unregister (plugin->nat); | 4020 | GNUNET_NAT_unregister (plugin->nat); |
3534 | GNUNET_CONTAINER_multipeermap_destroy (plugin->sessionmap); | 4021 | GNUNET_CONTAINER_multipeermap_destroy (plugin->sessionmap); |
3535 | if (NULL != service) | 4022 | if (NULL != service) |
3536 | GNUNET_SERVICE_stop (service); | 4023 | LEGACY_SERVICE_stop (service); |
3537 | GNUNET_free (plugin); | 4024 | GNUNET_free (plugin); |
3538 | GNUNET_free_non_null (api); | 4025 | GNUNET_free_non_null (api); |
3539 | return NULL; | 4026 | return NULL; |
@@ -3586,7 +4073,7 @@ libgnunet_plugin_transport_tcp_done (void *cls) | |||
3586 | } | 4073 | } |
3587 | 4074 | ||
3588 | if (NULL != plugin->service) | 4075 | if (NULL != plugin->service) |
3589 | GNUNET_SERVICE_stop (plugin->service); | 4076 | LEGACY_SERVICE_stop (plugin->service); |
3590 | else | 4077 | else |
3591 | GNUNET_SERVER_destroy (plugin->server); | 4078 | GNUNET_SERVER_destroy (plugin->server); |
3592 | GNUNET_free (plugin->handlers); | 4079 | GNUNET_free (plugin->handlers); |