diff options
author | xrs <xrs@mail36.net> | 2019-09-28 19:11:33 +0200 |
---|---|---|
committer | xrs <xrs@mail36.net> | 2019-09-28 19:11:33 +0200 |
commit | f5759dbc478ddf83b8a1d31d1580c845b9480633 (patch) | |
tree | 2087591b5f0f010df1c6b74e4d3874ac7ee2c9e7 | |
parent | 3df1c58ee5e23f59f71b3e495e6b863cda27ed5f (diff) | |
parent | 31aee41701fa2cd92ec566bd459e3425ee1f0b7d (diff) | |
download | gnunet-f5759dbc478ddf83b8a1d31d1580c845b9480633.tar.gz gnunet-f5759dbc478ddf83b8a1d31d1580c845b9480633.zip |
Merge branch 'master' of ssh://git.gnunet.org/gnunet
-rw-r--r-- | README | 2 | ||||
-rw-r--r-- | src/arm/arm.h | 45 | ||||
-rw-r--r-- | src/arm/arm_api.c | 933 | ||||
-rw-r--r-- | src/arm/arm_monitor_api.c | 8 | ||||
-rw-r--r-- | src/arm/gnunet-arm.c | 1044 | ||||
-rw-r--r-- | src/arm/gnunet-service-arm.c | 2359 | ||||
-rw-r--r-- | src/arm/test_exponential_backoff.c | 2 | ||||
-rw-r--r-- | src/arm/test_gnunet_service_arm.c | 10 | ||||
-rw-r--r-- | src/datastore/plugin_datastore_mysql.c | 2 | ||||
-rw-r--r-- | src/dns/gnunet-helper-dns.c | 4 | ||||
-rw-r--r-- | src/gns/gnunet-gns.c | 266 | ||||
-rw-r--r-- | src/include/gnunet_arm_service.h | 84 | ||||
-rw-r--r-- | src/include/gnunet_client_lib.h | 27 | ||||
-rw-r--r-- | src/include/gnunet_disk_lib.h | 189 | ||||
-rw-r--r-- | src/include/gnunet_os_lib.h | 134 | ||||
-rw-r--r-- | src/include/gnunet_scheduler_lib.h | 195 | ||||
-rw-r--r-- | src/include/gnunet_service_lib.h | 92 | ||||
-rw-r--r-- | src/util/client.c | 1000 | ||||
-rw-r--r-- | src/util/service.c | 2181 |
19 files changed, 4707 insertions, 3870 deletions
@@ -326,7 +326,7 @@ You can avoid running 'make install' as root if you run configure | |||
326 | with the "--with-sudo=yes" option and have extensive sudo rights | 326 | with the "--with-sudo=yes" option and have extensive sudo rights |
327 | (can run "chmod +s" and "chown" via 'sudo'). If you run 'make install' | 327 | (can run "chmod +s" and "chown" via 'sudo'). If you run 'make install' |
328 | as a normal user without sudo rights (or the configure option), | 328 | as a normal user without sudo rights (or the configure option), |
329 | certain binaries that require additional priviledges will not be | 329 | certain binaries that require additional privileges will not be |
330 | installed properly (and autonomous NAT traversal, WLAN, DNS/GNS and | 330 | installed properly (and autonomous NAT traversal, WLAN, DNS/GNS and |
331 | the VPN will then not work). | 331 | the VPN will then not work). |
332 | 332 | ||
diff --git a/src/arm/arm.h b/src/arm/arm.h index 983586060..bddcd7cf3 100644 --- a/src/arm/arm.h +++ b/src/arm/arm.h | |||
@@ -93,6 +93,44 @@ struct GNUNET_ARM_ResultMessage { | |||
93 | uint32_t result; | 93 | uint32_t result; |
94 | }; | 94 | }; |
95 | 95 | ||
96 | struct GNUNET_ARM_ServiceInfoMessage { | ||
97 | /** | ||
98 | * String pool index for the service's name. | ||
99 | */ | ||
100 | uint16_t name_index; | ||
101 | |||
102 | /** | ||
103 | * String pool index for the service's binary. | ||
104 | */ | ||
105 | uint16_t binary_index; | ||
106 | |||
107 | /** | ||
108 | * Last process exit status. | ||
109 | */ | ||
110 | int16_t last_exit_status; | ||
111 | |||
112 | /** | ||
113 | * Padding. | ||
114 | */ | ||
115 | uint16_t padding; | ||
116 | |||
117 | /** | ||
118 | * Status from the 'enum GNUNET_ARM_ServiceStatus' | ||
119 | */ | ||
120 | uint32_t status; | ||
121 | |||
122 | /** | ||
123 | * Time when the sevice will be restarted, if applicable | ||
124 | * to the current status. | ||
125 | */ | ||
126 | struct GNUNET_TIME_AbsoluteNBO restart_at; | ||
127 | |||
128 | /** | ||
129 | * Time when the sevice was first started, if applicable. | ||
130 | */ | ||
131 | struct GNUNET_TIME_AbsoluteNBO last_started_at; | ||
132 | }; | ||
133 | |||
96 | /** | 134 | /** |
97 | * Reply from ARM to client for the | 135 | * Reply from ARM to client for the |
98 | * #GNUNET_MESSAGE_TYPE_ARM_LIST request followed by count | 136 | * #GNUNET_MESSAGE_TYPE_ARM_LIST request followed by count |
@@ -107,10 +145,13 @@ struct GNUNET_ARM_ListResultMessage { | |||
107 | struct GNUNET_ARM_Message arm_msg; | 145 | struct GNUNET_ARM_Message arm_msg; |
108 | 146 | ||
109 | /** | 147 | /** |
110 | * Number of '\0' terminated strings that follow | 148 | * Number of 'struct GNUNET_ARM_ServiceInfoMessage' that |
111 | * this message. | 149 | * are at the end of this message. |
112 | */ | 150 | */ |
113 | uint16_t count; | 151 | uint16_t count; |
152 | |||
153 | /* struct GNUNET_ARM_ServiceInfoMessage[count]; */ | ||
154 | /* pool of 0-terminated strings */ | ||
114 | }; | 155 | }; |
115 | 156 | ||
116 | GNUNET_NETWORK_STRUCT_END | 157 | GNUNET_NETWORK_STRUCT_END |
diff --git a/src/arm/arm_api.c b/src/arm/arm_api.c index b42c95dc0..da7268f67 100644 --- a/src/arm/arm_api.c +++ b/src/arm/arm_api.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
3 | Copyright (C) 2009, 2010, 2012, 2013, 2016 GNUnet e.V. | 3 | Copyright (C) 2009, 2010, 2012, 2013, 2016, 2019 GNUnet e.V. |
4 | 4 | ||
5 | GNUnet is free software: you can redistribute it and/or modify it | 5 | GNUnet is free software: you can redistribute it and/or modify it |
6 | under the terms of the GNU Affero General Public License as published | 6 | under the terms of the GNU Affero General Public License as published |
@@ -30,14 +30,15 @@ | |||
30 | #include "gnunet_protocols.h" | 30 | #include "gnunet_protocols.h" |
31 | #include "arm.h" | 31 | #include "arm.h" |
32 | 32 | ||
33 | #define LOG(kind, ...) GNUNET_log_from(kind, "arm-api", __VA_ARGS__) | 33 | #define LOG(kind, ...) GNUNET_log_from (kind, "arm-api", __VA_ARGS__) |
34 | 34 | ||
35 | 35 | ||
36 | /** | 36 | /** |
37 | * Entry in a doubly-linked list of operations awaiting for replies | 37 | * Entry in a doubly-linked list of operations awaiting for replies |
38 | * (in-order) from the ARM service. | 38 | * (in-order) from the ARM service. |
39 | */ | 39 | */ |
40 | struct GNUNET_ARM_Operation { | 40 | struct GNUNET_ARM_Operation |
41 | { | ||
41 | /** | 42 | /** |
42 | * This is a doubly-linked list. | 43 | * This is a doubly-linked list. |
43 | */ | 44 | */ |
@@ -84,6 +85,11 @@ struct GNUNET_ARM_Operation { | |||
84 | enum GNUNET_ARM_Result starting_ret; | 85 | enum GNUNET_ARM_Result starting_ret; |
85 | 86 | ||
86 | /** | 87 | /** |
88 | * File descriptor to close on operation stop, if not NULL. | ||
89 | */ | ||
90 | struct GNUNET_DISK_FileHandle *rfd; | ||
91 | |||
92 | /** | ||
87 | * Is this an operation to stop the ARM service? | 93 | * Is this an operation to stop the ARM service? |
88 | */ | 94 | */ |
89 | int is_arm_stop; | 95 | int is_arm_stop; |
@@ -93,7 +99,8 @@ struct GNUNET_ARM_Operation { | |||
93 | /** | 99 | /** |
94 | * Handle for interacting with ARM. | 100 | * Handle for interacting with ARM. |
95 | */ | 101 | */ |
96 | struct GNUNET_ARM_Handle { | 102 | struct GNUNET_ARM_Handle |
103 | { | ||
97 | /** | 104 | /** |
98 | * Our connection to the ARM service. | 105 | * Our connection to the ARM service. |
99 | */ | 106 | */ |
@@ -164,7 +171,7 @@ struct GNUNET_ARM_Handle { | |||
164 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure | 171 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure |
165 | */ | 172 | */ |
166 | static int | 173 | static int |
167 | reconnect_arm(struct GNUNET_ARM_Handle *h); | 174 | reconnect_arm (struct GNUNET_ARM_Handle *h); |
168 | 175 | ||
169 | 176 | ||
170 | /** | 177 | /** |
@@ -173,12 +180,12 @@ reconnect_arm(struct GNUNET_ARM_Handle *h); | |||
173 | * @param cls the `struct GNUNET_ARM_Handle` | 180 | * @param cls the `struct GNUNET_ARM_Handle` |
174 | */ | 181 | */ |
175 | static void | 182 | static void |
176 | reconnect_arm_task(void *cls) | 183 | reconnect_arm_task (void *cls) |
177 | { | 184 | { |
178 | struct GNUNET_ARM_Handle *h = cls; | 185 | struct GNUNET_ARM_Handle *h = cls; |
179 | 186 | ||
180 | h->reconnect_task = NULL; | 187 | h->reconnect_task = NULL; |
181 | reconnect_arm(h); | 188 | reconnect_arm (h); |
182 | } | 189 | } |
183 | 190 | ||
184 | 191 | ||
@@ -189,31 +196,39 @@ reconnect_arm_task(void *cls) | |||
189 | * @param h our handle | 196 | * @param h our handle |
190 | */ | 197 | */ |
191 | static void | 198 | static void |
192 | reconnect_arm_later(struct GNUNET_ARM_Handle *h) | 199 | reconnect_arm_later (struct GNUNET_ARM_Handle *h) |
193 | { | 200 | { |
194 | struct GNUNET_ARM_Operation *op; | 201 | struct GNUNET_ARM_Operation *op; |
195 | 202 | ||
196 | if (NULL != h->mq) | 203 | if (NULL != h->mq) |
197 | { | 204 | { |
198 | GNUNET_MQ_destroy(h->mq); | 205 | GNUNET_MQ_destroy (h->mq); |
199 | h->mq = NULL; | 206 | h->mq = NULL; |
200 | } | 207 | } |
201 | h->currently_up = GNUNET_NO; | 208 | h->currently_up = GNUNET_NO; |
202 | GNUNET_assert(NULL == h->reconnect_task); | 209 | GNUNET_assert (NULL == h->reconnect_task); |
203 | h->reconnect_task = | 210 | h->reconnect_task = |
204 | GNUNET_SCHEDULER_add_delayed(h->retry_backoff, &reconnect_arm_task, h); | 211 | GNUNET_SCHEDULER_add_delayed (h->retry_backoff, |
212 | &reconnect_arm_task, | ||
213 | h); | ||
205 | while (NULL != (op = h->operation_pending_head)) | 214 | while (NULL != (op = h->operation_pending_head)) |
206 | { | 215 | { |
207 | if (NULL != op->result_cont) | 216 | if (NULL != op->result_cont) |
208 | op->result_cont(op->cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED, 0); | 217 | op->result_cont (op->cont_cls, |
209 | if (NULL != op->list_cont) | 218 | GNUNET_ARM_REQUEST_DISCONNECTED, |
210 | op->list_cont(op->cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED, 0, NULL); | 219 | 0); |
211 | GNUNET_ARM_operation_cancel(op); | 220 | if (NULL != op->list_cont) |
212 | } | 221 | op->list_cont (op->cont_cls, |
213 | GNUNET_assert(NULL == h->operation_pending_head); | 222 | GNUNET_ARM_REQUEST_DISCONNECTED, |
214 | h->retry_backoff = GNUNET_TIME_STD_BACKOFF(h->retry_backoff); | 223 | 0, |
224 | NULL); | ||
225 | GNUNET_ARM_operation_cancel (op); | ||
226 | } | ||
227 | GNUNET_assert (NULL == h->operation_pending_head); | ||
228 | h->retry_backoff = GNUNET_TIME_STD_BACKOFF (h->retry_backoff); | ||
215 | if (NULL != h->conn_status) | 229 | if (NULL != h->conn_status) |
216 | h->conn_status(h->conn_status_cls, GNUNET_NO); | 230 | h->conn_status (h->conn_status_cls, |
231 | GNUNET_NO); | ||
217 | } | 232 | } |
218 | 233 | ||
219 | 234 | ||
@@ -225,11 +240,11 @@ reconnect_arm_later(struct GNUNET_ARM_Handle *h) | |||
225 | * @return NULL if not found | 240 | * @return NULL if not found |
226 | */ | 241 | */ |
227 | static struct GNUNET_ARM_Operation * | 242 | static struct GNUNET_ARM_Operation * |
228 | find_op_by_id(struct GNUNET_ARM_Handle *h, uint64_t id) | 243 | find_op_by_id (struct GNUNET_ARM_Handle *h, |
244 | uint64_t id) | ||
229 | { | 245 | { |
230 | struct GNUNET_ARM_Operation *result; | 246 | for (struct GNUNET_ARM_Operation *result = h->operation_pending_head; |
231 | 247 | NULL != result; | |
232 | for (result = h->operation_pending_head; NULL != result; | ||
233 | result = result->next) | 248 | result = result->next) |
234 | if (id == result->id) | 249 | if (id == result->id) |
235 | return result; | 250 | return result; |
@@ -244,7 +259,8 @@ find_op_by_id(struct GNUNET_ARM_Handle *h, uint64_t id) | |||
244 | * @param res the message received from the arm service | 259 | * @param res the message received from the arm service |
245 | */ | 260 | */ |
246 | static void | 261 | static void |
247 | handle_arm_result(void *cls, const struct GNUNET_ARM_ResultMessage *res) | 262 | handle_arm_result (void *cls, |
263 | const struct GNUNET_ARM_ResultMessage *res) | ||
248 | { | 264 | { |
249 | struct GNUNET_ARM_Handle *h = cls; | 265 | struct GNUNET_ARM_Handle *h = cls; |
250 | struct GNUNET_ARM_Operation *op; | 266 | struct GNUNET_ARM_Operation *op; |
@@ -253,75 +269,123 @@ handle_arm_result(void *cls, const struct GNUNET_ARM_ResultMessage *res) | |||
253 | GNUNET_ARM_ResultCallback result_cont; | 269 | GNUNET_ARM_ResultCallback result_cont; |
254 | void *result_cont_cls; | 270 | void *result_cont_cls; |
255 | 271 | ||
256 | id = GNUNET_ntohll(res->arm_msg.request_id); | 272 | id = GNUNET_ntohll (res->arm_msg.request_id); |
257 | op = find_op_by_id(h, id); | 273 | op = find_op_by_id (h, |
274 | id); | ||
258 | if (NULL == op) | 275 | if (NULL == op) |
276 | { | ||
277 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
278 | "Message with unknown id %llu\n", | ||
279 | (unsigned long long) id); | ||
280 | return; | ||
281 | } | ||
282 | |||
283 | result = (enum GNUNET_ARM_Result) ntohl (res->result); | ||
284 | if ( (GNUNET_YES == op->is_arm_stop) && | ||
285 | (GNUNET_ARM_RESULT_STOPPING == result) ) | ||
286 | { | ||
287 | /* special case: if we are stopping 'gnunet-service-arm', we do not just | ||
288 | wait for the result message, but also wait for the service to close | ||
289 | the connection (and then we have to close our client handle as well); | ||
290 | this is done by installing a different receive handler, waiting for | ||
291 | the connection to go down */ | ||
292 | if (NULL != h->thm) | ||
259 | { | 293 | { |
260 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 294 | GNUNET_break (0); |
261 | "Message with unknown id %llu\n", | 295 | op->result_cont (h->thm->cont_cls, |
262 | (unsigned long long)id); | 296 | GNUNET_ARM_REQUEST_SENT_OK, |
263 | return; | 297 | GNUNET_ARM_RESULT_IS_NOT_KNOWN); |
264 | } | 298 | GNUNET_free (h->thm); |
265 | |||
266 | result = (enum GNUNET_ARM_Result)ntohl(res->result); | ||
267 | if ((GNUNET_YES == op->is_arm_stop) && (GNUNET_ARM_RESULT_STOPPING == result)) | ||
268 | { | ||
269 | /* special case: if we are stopping 'gnunet-service-arm', we do not just | ||
270 | wait for the result message, but also wait for the service to close | ||
271 | the connection (and then we have to close our client handle as well); | ||
272 | this is done by installing a different receive handler, waiting for | ||
273 | the connection to go down */ | ||
274 | if (NULL != h->thm) | ||
275 | { | ||
276 | GNUNET_break(0); | ||
277 | op->result_cont(h->thm->cont_cls, | ||
278 | GNUNET_ARM_REQUEST_SENT_OK, | ||
279 | GNUNET_ARM_RESULT_IS_NOT_KNOWN); | ||
280 | GNUNET_free(h->thm); | ||
281 | } | ||
282 | GNUNET_CONTAINER_DLL_remove(h->operation_pending_head, | ||
283 | h->operation_pending_tail, | ||
284 | op); | ||
285 | h->thm = op; | ||
286 | return; | ||
287 | } | 299 | } |
300 | GNUNET_CONTAINER_DLL_remove (h->operation_pending_head, | ||
301 | h->operation_pending_tail, | ||
302 | op); | ||
303 | h->thm = op; | ||
304 | return; | ||
305 | } | ||
288 | result_cont = op->result_cont; | 306 | result_cont = op->result_cont; |
289 | result_cont_cls = op->cont_cls; | 307 | result_cont_cls = op->cont_cls; |
290 | GNUNET_ARM_operation_cancel(op); | 308 | GNUNET_ARM_operation_cancel (op); |
291 | if (NULL != result_cont) | 309 | if (NULL != result_cont) |
292 | result_cont(result_cont_cls, GNUNET_ARM_REQUEST_SENT_OK, result); | 310 | result_cont (result_cont_cls, |
311 | GNUNET_ARM_REQUEST_SENT_OK, | ||
312 | result); | ||
293 | } | 313 | } |
294 | 314 | ||
295 | 315 | ||
296 | /** | 316 | /** |
297 | * Checked that list result message is well-formed. | 317 | * Read from a string pool. |
318 | * | ||
319 | * @param pool_start start of the string pool | ||
320 | * @param pool_size size of the string pool | ||
321 | * @param str_index index into the string pool | ||
322 | * @returns an index into the string pool, or | ||
323 | * NULL if the index is out of bounds | ||
324 | */ | ||
325 | static const char * | ||
326 | pool_get (const char *pool_start, | ||
327 | size_t pool_size, | ||
328 | size_t str_index) | ||
329 | { | ||
330 | const char *str_start; | ||
331 | const char *end; | ||
332 | |||
333 | if (str_index >= pool_size) | ||
334 | return NULL; | ||
335 | str_start = pool_start + str_index; | ||
336 | end = memchr (str_start, 0, pool_size - str_index); | ||
337 | if (NULL == end) | ||
338 | return NULL; | ||
339 | return str_start; | ||
340 | } | ||
341 | |||
342 | |||
343 | /** | ||
344 | * Check that list result message is well-formed. | ||
298 | * | 345 | * |
299 | * @param cls our `struct GNUNET_ARM_Handle` | 346 | * @param cls our `struct GNUNET_ARM_Handle` |
300 | * @param lres the message received from the arm service | 347 | * @param lres the message received from the arm service |
301 | * @return #GNUNET_OK if message is well-formed | 348 | * @return #GNUNET_OK if message is well-formed |
302 | */ | 349 | */ |
303 | static int | 350 | static int |
304 | check_arm_list_result(void *cls, | 351 | check_arm_list_result (void *cls, |
305 | const struct GNUNET_ARM_ListResultMessage *lres) | 352 | const struct GNUNET_ARM_ListResultMessage *lres) |
306 | { | 353 | { |
307 | const char *pos = (const char *)&lres[1]; | 354 | uint16_t rcount = ntohs (lres->count); |
308 | uint16_t rcount = ntohs(lres->count); | 355 | uint16_t msize = ntohs (lres->arm_msg.header.size) - sizeof(*lres); |
309 | uint16_t msize = ntohs(lres->arm_msg.header.size) - sizeof(*lres); | 356 | struct GNUNET_ARM_ServiceInfoMessage *ssm; |
310 | uint16_t size_check; | 357 | size_t pool_size; |
311 | 358 | char *pool_start; | |
312 | (void)cls; | 359 | |
313 | size_check = 0; | 360 | (void) cls; |
361 | if ((rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage) > msize)) | ||
362 | { | ||
363 | GNUNET_break_op (0); | ||
364 | return GNUNET_NO; | ||
365 | } | ||
366 | ssm = (struct GNUNET_ARM_ServiceInfoMessage *) &lres[1]; | ||
367 | pool_start = (char *) (ssm + rcount); | ||
368 | pool_size = msize - (rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage)); | ||
314 | for (unsigned int i = 0; i < rcount; i++) | 369 | for (unsigned int i = 0; i < rcount; i++) |
370 | { | ||
371 | uint16_t name_index = ntohs (ssm->name_index); | ||
372 | uint16_t binary_index = ntohs (ssm->binary_index); | ||
373 | if (NULL == pool_get (pool_start, | ||
374 | pool_size, | ||
375 | name_index)) | ||
315 | { | 376 | { |
316 | const char *end = memchr(pos, 0, msize - size_check); | 377 | GNUNET_break_op (0); |
317 | if (NULL == end) | 378 | return GNUNET_NO; |
318 | { | ||
319 | GNUNET_break(0); | ||
320 | return GNUNET_SYSERR; | ||
321 | } | ||
322 | size_check += (end - pos) + 1; | ||
323 | pos = end + 1; | ||
324 | } | 379 | } |
380 | if (NULL == pool_get (pool_start, | ||
381 | pool_size, | ||
382 | binary_index)) | ||
383 | { | ||
384 | GNUNET_break_op (0); | ||
385 | return GNUNET_NO; | ||
386 | } | ||
387 | ssm++; | ||
388 | } | ||
325 | return GNUNET_OK; | 389 | return GNUNET_OK; |
326 | } | 390 | } |
327 | 391 | ||
@@ -333,41 +397,65 @@ check_arm_list_result(void *cls, | |||
333 | * @param lres the message received from the arm service | 397 | * @param lres the message received from the arm service |
334 | */ | 398 | */ |
335 | static void | 399 | static void |
336 | handle_arm_list_result(void *cls, | 400 | handle_arm_list_result (void *cls, |
337 | const struct GNUNET_ARM_ListResultMessage *lres) | 401 | const struct GNUNET_ARM_ListResultMessage *lres) |
338 | { | 402 | { |
339 | struct GNUNET_ARM_Handle *h = cls; | 403 | struct GNUNET_ARM_Handle *h = cls; |
340 | uint16_t rcount = ntohs(lres->count); | 404 | uint16_t rcount = ntohs (lres->count); |
341 | const char *list[rcount]; | 405 | uint16_t msize = ntohs (lres->arm_msg.header.size) - sizeof(*lres); |
342 | const char *pos = (const char *)&lres[1]; | 406 | struct GNUNET_ARM_ServiceInfo list[rcount]; |
343 | uint16_t msize = ntohs(lres->arm_msg.header.size) - sizeof(*lres); | 407 | struct GNUNET_ARM_ServiceInfoMessage *ssm; |
344 | struct GNUNET_ARM_Operation *op; | 408 | struct GNUNET_ARM_Operation *op; |
345 | uint16_t size_check; | ||
346 | uint64_t id; | 409 | uint64_t id; |
410 | size_t pool_size; | ||
411 | char *pool_start; | ||
347 | 412 | ||
348 | id = GNUNET_ntohll(lres->arm_msg.request_id); | 413 | id = GNUNET_ntohll (lres->arm_msg.request_id); |
349 | op = find_op_by_id(h, id); | 414 | op = find_op_by_id (h, id); |
350 | if (NULL == op) | 415 | if (NULL == op) |
351 | { | 416 | { |
352 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 417 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
353 | "Message with unknown id %llu\n", | 418 | "Message with unknown id %llu\n", |
354 | (unsigned long long)id); | 419 | (unsigned long long) id); |
355 | return; | 420 | return; |
356 | } | 421 | } |
357 | size_check = 0; | ||
358 | for (unsigned int i = 0; i < rcount; i++) | ||
359 | { | ||
360 | const char *end = memchr(pos, 0, msize - size_check); | ||
361 | 422 | ||
362 | /* Assert, as this was already checked in #check_arm_list_result() */ | 423 | GNUNET_assert ((rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage) <= |
363 | GNUNET_assert(NULL != end); | 424 | msize)); |
364 | list[i] = pos; | 425 | |
365 | size_check += (end - pos) + 1; | 426 | ssm = (struct GNUNET_ARM_ServiceInfoMessage *) &lres[1]; |
366 | pos = end + 1; | 427 | pool_start = (char *) (ssm + rcount); |
367 | } | 428 | pool_size = msize - (rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage)); |
429 | |||
430 | for (unsigned int i = 0; i < rcount; i++) | ||
431 | { | ||
432 | uint16_t name_index = ntohs (ssm->name_index); | ||
433 | uint16_t binary_index = ntohs (ssm->binary_index); | ||
434 | const char *name; | ||
435 | const char *binary; | ||
436 | |||
437 | GNUNET_assert (NULL != (name = pool_get (pool_start, | ||
438 | pool_size, | ||
439 | name_index))); | ||
440 | GNUNET_assert (NULL != (binary = pool_get (pool_start, | ||
441 | pool_size, | ||
442 | binary_index))); | ||
443 | list[i] = (struct GNUNET_ARM_ServiceInfo) { | ||
444 | .name = name, | ||
445 | .binary = binary, | ||
446 | .status = ntohl (ssm->status), | ||
447 | .last_started_at = GNUNET_TIME_absolute_ntoh (ssm->last_started_at), | ||
448 | .restart_at = GNUNET_TIME_absolute_ntoh (ssm->restart_at), | ||
449 | .last_exit_status = ntohs (ssm->last_exit_status), | ||
450 | }; | ||
451 | ssm++; | ||
452 | } | ||
368 | if (NULL != op->list_cont) | 453 | if (NULL != op->list_cont) |
369 | op->list_cont(op->cont_cls, GNUNET_ARM_REQUEST_SENT_OK, rcount, list); | 454 | op->list_cont (op->cont_cls, |
370 | GNUNET_ARM_operation_cancel(op); | 455 | GNUNET_ARM_REQUEST_SENT_OK, |
456 | rcount, | ||
457 | list); | ||
458 | GNUNET_ARM_operation_cancel (op); | ||
371 | } | 459 | } |
372 | 460 | ||
373 | 461 | ||
@@ -378,18 +466,20 @@ handle_arm_list_result(void *cls, | |||
378 | * @param msg message received | 466 | * @param msg message received |
379 | */ | 467 | */ |
380 | static void | 468 | static void |
381 | handle_confirm(void *cls, const struct GNUNET_MessageHeader *msg) | 469 | handle_confirm (void *cls, |
470 | const struct GNUNET_MessageHeader *msg) | ||
382 | { | 471 | { |
383 | struct GNUNET_ARM_Handle *h = cls; | 472 | struct GNUNET_ARM_Handle *h = cls; |
384 | 473 | ||
385 | (void)msg; | 474 | (void) msg; |
386 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Got confirmation from ARM that we are up!\n"); | 475 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
476 | "Got confirmation from ARM that we are up!\n"); | ||
387 | if (GNUNET_NO == h->currently_up) | 477 | if (GNUNET_NO == h->currently_up) |
388 | { | 478 | { |
389 | h->currently_up = GNUNET_YES; | 479 | h->currently_up = GNUNET_YES; |
390 | if (NULL != h->conn_status) | 480 | if (NULL != h->conn_status) |
391 | h->conn_status(h->conn_status_cls, GNUNET_YES); | 481 | h->conn_status (h->conn_status_cls, GNUNET_YES); |
392 | } | 482 | } |
393 | } | 483 | } |
394 | 484 | ||
395 | 485 | ||
@@ -402,22 +492,23 @@ handle_confirm(void *cls, const struct GNUNET_MessageHeader *msg) | |||
402 | * @param error error code | 492 | * @param error error code |
403 | */ | 493 | */ |
404 | static void | 494 | static void |
405 | mq_error_handler(void *cls, enum GNUNET_MQ_Error error) | 495 | mq_error_handler (void *cls, |
496 | enum GNUNET_MQ_Error error) | ||
406 | { | 497 | { |
407 | struct GNUNET_ARM_Handle *h = cls; | 498 | struct GNUNET_ARM_Handle *h = cls; |
408 | struct GNUNET_ARM_Operation *op; | 499 | struct GNUNET_ARM_Operation *op; |
409 | 500 | ||
410 | (void)error; | 501 | (void) error; |
411 | h->currently_up = GNUNET_NO; | 502 | h->currently_up = GNUNET_NO; |
412 | if (NULL != (op = h->thm)) | 503 | if (NULL != (op = h->thm)) |
413 | { | 504 | { |
414 | h->thm = NULL; | 505 | h->thm = NULL; |
415 | op->result_cont(op->cont_cls, | 506 | op->result_cont (op->cont_cls, |
416 | GNUNET_ARM_REQUEST_SENT_OK, | 507 | GNUNET_ARM_REQUEST_SENT_OK, |
417 | GNUNET_ARM_RESULT_STOPPED); | 508 | GNUNET_ARM_RESULT_STOPPED); |
418 | GNUNET_free(op); | 509 | GNUNET_free (op); |
419 | } | 510 | } |
420 | reconnect_arm_later(h); | 511 | reconnect_arm_later (h); |
421 | } | 512 | } |
422 | 513 | ||
423 | 514 | ||
@@ -428,39 +519,48 @@ mq_error_handler(void *cls, enum GNUNET_MQ_Error error) | |||
428 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure | 519 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure |
429 | */ | 520 | */ |
430 | static int | 521 | static int |
431 | reconnect_arm(struct GNUNET_ARM_Handle *h) | 522 | reconnect_arm (struct GNUNET_ARM_Handle *h) |
432 | { | 523 | { |
433 | struct GNUNET_MQ_MessageHandler handlers[] = | 524 | struct GNUNET_MQ_MessageHandler handlers[] = { |
434 | { GNUNET_MQ_hd_fixed_size(arm_result, | 525 | GNUNET_MQ_hd_fixed_size (arm_result, |
435 | GNUNET_MESSAGE_TYPE_ARM_RESULT, | 526 | GNUNET_MESSAGE_TYPE_ARM_RESULT, |
436 | struct GNUNET_ARM_ResultMessage, | 527 | struct GNUNET_ARM_ResultMessage, |
437 | h), | 528 | h), |
438 | GNUNET_MQ_hd_var_size(arm_list_result, | 529 | GNUNET_MQ_hd_var_size (arm_list_result, |
439 | GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT, | 530 | GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT, |
440 | struct GNUNET_ARM_ListResultMessage, | 531 | struct GNUNET_ARM_ListResultMessage, |
441 | h), | 532 | h), |
442 | GNUNET_MQ_hd_fixed_size(confirm, | 533 | GNUNET_MQ_hd_fixed_size (confirm, |
443 | GNUNET_MESSAGE_TYPE_ARM_TEST, | 534 | GNUNET_MESSAGE_TYPE_ARM_TEST, |
444 | struct GNUNET_MessageHeader, | 535 | struct GNUNET_MessageHeader, |
445 | h), | 536 | h), |
446 | GNUNET_MQ_handler_end() }; | 537 | GNUNET_MQ_handler_end () |
538 | }; | ||
447 | struct GNUNET_MessageHeader *test; | 539 | struct GNUNET_MessageHeader *test; |
448 | struct GNUNET_MQ_Envelope *env; | 540 | struct GNUNET_MQ_Envelope *env; |
449 | 541 | ||
450 | if (NULL != h->mq) | 542 | if (NULL != h->mq) |
451 | return GNUNET_OK; | 543 | return GNUNET_OK; |
452 | GNUNET_assert(GNUNET_NO == h->currently_up); | 544 | GNUNET_assert (GNUNET_NO == h->currently_up); |
453 | h->mq = GNUNET_CLIENT_connect(h->cfg, "arm", handlers, &mq_error_handler, h); | 545 | h->mq = GNUNET_CLIENT_connect (h->cfg, |
546 | "arm", | ||
547 | handlers, | ||
548 | &mq_error_handler, | ||
549 | h); | ||
454 | if (NULL == h->mq) | 550 | if (NULL == h->mq) |
455 | { | 551 | { |
456 | LOG(GNUNET_ERROR_TYPE_DEBUG, "GNUNET_CLIENT_connect returned NULL\n"); | 552 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
457 | if (NULL != h->conn_status) | 553 | "GNUNET_CLIENT_connect returned NULL\n"); |
458 | h->conn_status(h->conn_status_cls, GNUNET_SYSERR); | 554 | if (NULL != h->conn_status) |
459 | return GNUNET_SYSERR; | 555 | h->conn_status (h->conn_status_cls, |
460 | } | 556 | GNUNET_SYSERR); |
461 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Sending TEST message to ARM\n"); | 557 | return GNUNET_SYSERR; |
462 | env = GNUNET_MQ_msg(test, GNUNET_MESSAGE_TYPE_ARM_TEST); | 558 | } |
463 | GNUNET_MQ_send(h->mq, env); | 559 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
560 | "Sending TEST message to ARM\n"); | ||
561 | env = GNUNET_MQ_msg (test, | ||
562 | GNUNET_MESSAGE_TYPE_ARM_TEST); | ||
563 | GNUNET_MQ_send (h->mq, env); | ||
464 | return GNUNET_OK; | 564 | return GNUNET_OK; |
465 | } | 565 | } |
466 | 566 | ||
@@ -477,21 +577,21 @@ reconnect_arm(struct GNUNET_ARM_Handle *h) | |||
477 | * @return context to use for further ARM operations, NULL on error. | 577 | * @return context to use for further ARM operations, NULL on error. |
478 | */ | 578 | */ |
479 | struct GNUNET_ARM_Handle * | 579 | struct GNUNET_ARM_Handle * |
480 | GNUNET_ARM_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, | 580 | GNUNET_ARM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, |
481 | GNUNET_ARM_ConnectionStatusCallback conn_status, | 581 | GNUNET_ARM_ConnectionStatusCallback conn_status, |
482 | void *conn_status_cls) | 582 | void *conn_status_cls) |
483 | { | 583 | { |
484 | struct GNUNET_ARM_Handle *h; | 584 | struct GNUNET_ARM_Handle *h; |
485 | 585 | ||
486 | h = GNUNET_new(struct GNUNET_ARM_Handle); | 586 | h = GNUNET_new (struct GNUNET_ARM_Handle); |
487 | h->cfg = cfg; | 587 | h->cfg = cfg; |
488 | h->conn_status = conn_status; | 588 | h->conn_status = conn_status; |
489 | h->conn_status_cls = conn_status_cls; | 589 | h->conn_status_cls = conn_status_cls; |
490 | if (GNUNET_OK != reconnect_arm(h)) | 590 | if (GNUNET_OK != reconnect_arm (h)) |
491 | { | 591 | { |
492 | GNUNET_free(h); | 592 | GNUNET_free (h); |
493 | return NULL; | 593 | return NULL; |
494 | } | 594 | } |
495 | return h; | 595 | return h; |
496 | } | 596 | } |
497 | 597 | ||
@@ -502,38 +602,43 @@ GNUNET_ARM_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
502 | * @param h the handle that was being used | 602 | * @param h the handle that was being used |
503 | */ | 603 | */ |
504 | void | 604 | void |
505 | GNUNET_ARM_disconnect(struct GNUNET_ARM_Handle *h) | 605 | GNUNET_ARM_disconnect (struct GNUNET_ARM_Handle *h) |
506 | { | 606 | { |
507 | struct GNUNET_ARM_Operation *op; | 607 | struct GNUNET_ARM_Operation *op; |
508 | 608 | ||
509 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from ARM service\n"); | 609 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from ARM service\n"); |
510 | while (NULL != (op = h->operation_pending_head)) | 610 | while (NULL != (op = h->operation_pending_head)) |
611 | { | ||
612 | GNUNET_CONTAINER_DLL_remove (h->operation_pending_head, | ||
613 | h->operation_pending_tail, | ||
614 | op); | ||
615 | if (NULL != op->result_cont) | ||
616 | op->result_cont (op->cont_cls, | ||
617 | GNUNET_ARM_REQUEST_DISCONNECTED, | ||
618 | 0); | ||
619 | if (NULL != op->list_cont) | ||
620 | op->list_cont (op->cont_cls, | ||
621 | GNUNET_ARM_REQUEST_DISCONNECTED, | ||
622 | 0, | ||
623 | NULL); | ||
624 | if (NULL != op->async) | ||
511 | { | 625 | { |
512 | GNUNET_CONTAINER_DLL_remove(h->operation_pending_head, | 626 | GNUNET_SCHEDULER_cancel (op->async); |
513 | h->operation_pending_tail, | 627 | op->async = NULL; |
514 | op); | ||
515 | if (NULL != op->result_cont) | ||
516 | op->result_cont(op->cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED, 0); | ||
517 | if (NULL != op->list_cont) | ||
518 | op->list_cont(op->cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED, 0, NULL); | ||
519 | if (NULL != op->async) | ||
520 | { | ||
521 | GNUNET_SCHEDULER_cancel(op->async); | ||
522 | op->async = NULL; | ||
523 | } | ||
524 | GNUNET_free(op); | ||
525 | } | 628 | } |
629 | GNUNET_free (op); | ||
630 | } | ||
526 | if (NULL != h->mq) | 631 | if (NULL != h->mq) |
527 | { | 632 | { |
528 | GNUNET_MQ_destroy(h->mq); | 633 | GNUNET_MQ_destroy (h->mq); |
529 | h->mq = NULL; | 634 | h->mq = NULL; |
530 | } | 635 | } |
531 | if (NULL != h->reconnect_task) | 636 | if (NULL != h->reconnect_task) |
532 | { | 637 | { |
533 | GNUNET_SCHEDULER_cancel(h->reconnect_task); | 638 | GNUNET_SCHEDULER_cancel (h->reconnect_task); |
534 | h->reconnect_task = NULL; | 639 | h->reconnect_task = NULL; |
535 | } | 640 | } |
536 | GNUNET_free(h); | 641 | GNUNET_free (h); |
537 | } | 642 | } |
538 | 643 | ||
539 | 644 | ||
@@ -543,11 +648,13 @@ GNUNET_ARM_disconnect(struct GNUNET_ARM_Handle *h) | |||
543 | * | 648 | * |
544 | * @param h the handle with configuration details | 649 | * @param h the handle with configuration details |
545 | * @param std_inheritance inheritance of std streams | 650 | * @param std_inheritance inheritance of std streams |
651 | * @param sigfd socket to pass to ARM for signalling | ||
546 | * @return operation status code | 652 | * @return operation status code |
547 | */ | 653 | */ |
548 | static enum GNUNET_ARM_Result | 654 | static enum GNUNET_ARM_Result |
549 | start_arm_service(struct GNUNET_ARM_Handle *h, | 655 | start_arm_service (struct GNUNET_ARM_Handle *h, |
550 | enum GNUNET_OS_InheritStdioFlags std_inheritance) | 656 | enum GNUNET_OS_InheritStdioFlags std_inheritance, |
657 | struct GNUNET_DISK_FileHandle *sigfd) | ||
551 | { | 658 | { |
552 | struct GNUNET_OS_Process *proc; | 659 | struct GNUNET_OS_Process *proc; |
553 | char *cbinary; | 660 | char *cbinary; |
@@ -556,99 +663,124 @@ start_arm_service(struct GNUNET_ARM_Handle *h, | |||
556 | char *config; | 663 | char *config; |
557 | char *loprefix; | 664 | char *loprefix; |
558 | char *lopostfix; | 665 | char *lopostfix; |
666 | SOCKTYPE ld[2]; | ||
667 | SOCKTYPE *lsocks; | ||
559 | 668 | ||
560 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(h->cfg, | 669 | if (NULL == sigfd) |
561 | "arm", | 670 | { |
562 | "PREFIX", | 671 | lsocks = NULL; |
563 | &loprefix)) | 672 | } |
564 | loprefix = GNUNET_strdup(""); | ||
565 | else | 673 | else |
566 | loprefix = GNUNET_CONFIGURATION_expand_dollar(h->cfg, loprefix); | 674 | { |
567 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(h->cfg, | 675 | ld[0] = sigfd->fd; |
568 | "arm", | 676 | ld[1] = -1; |
569 | "OPTIONS", | 677 | lsocks = ld; |
570 | &lopostfix)) | 678 | } |
571 | lopostfix = GNUNET_strdup(""); | 679 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (h->cfg, |
680 | "arm", | ||
681 | "PREFIX", | ||
682 | &loprefix)) | ||
683 | loprefix = GNUNET_strdup (""); | ||
572 | else | 684 | else |
573 | lopostfix = GNUNET_CONFIGURATION_expand_dollar(h->cfg, lopostfix); | 685 | loprefix = GNUNET_CONFIGURATION_expand_dollar (h->cfg, loprefix); |
686 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (h->cfg, | ||
687 | "arm", | ||
688 | "OPTIONS", | ||
689 | &lopostfix)) | ||
690 | lopostfix = GNUNET_strdup (""); | ||
691 | else | ||
692 | lopostfix = GNUNET_CONFIGURATION_expand_dollar (h->cfg, | ||
693 | lopostfix); | ||
574 | if (GNUNET_OK != | 694 | if (GNUNET_OK != |
575 | GNUNET_CONFIGURATION_get_value_string(h->cfg, "arm", "BINARY", &cbinary)) | 695 | GNUNET_CONFIGURATION_get_value_string (h->cfg, |
576 | { | 696 | "arm", |
577 | GNUNET_log_config_missing(GNUNET_ERROR_TYPE_WARNING, "arm", "BINARY"); | 697 | "BINARY", |
578 | GNUNET_free(loprefix); | 698 | &cbinary)) |
579 | GNUNET_free(lopostfix); | 699 | { |
580 | return GNUNET_ARM_RESULT_IS_NOT_KNOWN; | 700 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING, |
581 | } | 701 | "arm", |
582 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(h->cfg, | 702 | "BINARY"); |
583 | "arm", | 703 | GNUNET_free (loprefix); |
584 | "CONFIG", | 704 | GNUNET_free (lopostfix); |
585 | &config)) | 705 | return GNUNET_ARM_RESULT_IS_NOT_KNOWN; |
706 | } | ||
707 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (h->cfg, | ||
708 | "arm", | ||
709 | "CONFIG", | ||
710 | &config)) | ||
586 | config = NULL; | 711 | config = NULL; |
587 | binary = GNUNET_OS_get_libexec_binary_path(cbinary); | 712 | binary = GNUNET_OS_get_libexec_binary_path (cbinary); |
588 | GNUNET_asprintf("edbinary, "\"%s\"", binary); | 713 | GNUNET_asprintf ("edbinary, |
589 | GNUNET_free(cbinary); | 714 | "\"%s\"", |
590 | if ((GNUNET_YES == | 715 | binary); |
591 | GNUNET_CONFIGURATION_have_value(h->cfg, "TESTING", "WEAKRANDOM")) && | 716 | GNUNET_free (cbinary); |
592 | (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(h->cfg, | 717 | if ( (GNUNET_YES == |
593 | "TESTING", | 718 | GNUNET_CONFIGURATION_have_value (h->cfg, |
594 | "WEAKRANDOM")) && | 719 | "TESTING", |
595 | (GNUNET_NO == | 720 | "WEAKRANDOM")) && |
596 | GNUNET_CONFIGURATION_have_value(h->cfg, "TESTING", "HOSTFILE"))) | 721 | (GNUNET_YES == |
597 | { | 722 | GNUNET_CONFIGURATION_get_value_yesno (h->cfg, |
598 | /* Means we are ONLY running locally */ | 723 | "TESTING", |
599 | /* we're clearly running a test, don't daemonize */ | 724 | "WEAKRANDOM")) && |
600 | if (NULL == config) | 725 | (GNUNET_NO == |
601 | proc = GNUNET_OS_start_process_s(GNUNET_NO, | 726 | GNUNET_CONFIGURATION_have_value (h->cfg, |
602 | std_inheritance, | 727 | "TESTING", |
603 | NULL, | 728 | "HOSTFILE")) ) |
604 | loprefix, | 729 | { |
605 | quotedbinary, | 730 | /* Means we are ONLY running locally */ |
606 | /* no daemonization! */ | 731 | /* we're clearly running a test, don't daemonize */ |
607 | lopostfix, | 732 | if (NULL == config) |
608 | NULL); | 733 | proc = GNUNET_OS_start_process_s (GNUNET_NO, |
609 | else | 734 | std_inheritance, |
610 | proc = GNUNET_OS_start_process_s(GNUNET_NO, | 735 | lsocks, |
611 | std_inheritance, | 736 | loprefix, |
612 | NULL, | 737 | quotedbinary, |
613 | loprefix, | 738 | /* no daemonization! */ |
614 | quotedbinary, | 739 | lopostfix, |
615 | "-c", | 740 | NULL); |
616 | config, | 741 | else |
617 | /* no daemonization! */ | 742 | proc = GNUNET_OS_start_process_s (GNUNET_NO, |
618 | lopostfix, | 743 | std_inheritance, |
619 | NULL); | 744 | lsocks, |
620 | } | 745 | loprefix, |
746 | quotedbinary, | ||
747 | "-c", | ||
748 | config, | ||
749 | /* no daemonization! */ | ||
750 | lopostfix, | ||
751 | NULL); | ||
752 | } | ||
621 | else | 753 | else |
622 | { | 754 | { |
623 | if (NULL == config) | 755 | if (NULL == config) |
624 | proc = GNUNET_OS_start_process_s(GNUNET_NO, | 756 | proc = GNUNET_OS_start_process_s (GNUNET_NO, |
625 | std_inheritance, | 757 | std_inheritance, |
626 | NULL, | 758 | lsocks, |
627 | loprefix, | 759 | loprefix, |
628 | quotedbinary, | 760 | quotedbinary, |
629 | "-d", /* do daemonize */ | 761 | "-d", /* do daemonize */ |
630 | lopostfix, | 762 | lopostfix, |
631 | NULL); | 763 | NULL); |
632 | else | 764 | else |
633 | proc = GNUNET_OS_start_process_s(GNUNET_NO, | 765 | proc = GNUNET_OS_start_process_s (GNUNET_NO, |
634 | std_inheritance, | 766 | std_inheritance, |
635 | NULL, | 767 | lsocks, |
636 | loprefix, | 768 | loprefix, |
637 | quotedbinary, | 769 | quotedbinary, |
638 | "-c", | 770 | "-c", |
639 | config, | 771 | config, |
640 | "-d", /* do daemonize */ | 772 | "-d", /* do daemonize */ |
641 | lopostfix, | 773 | lopostfix, |
642 | NULL); | 774 | NULL); |
643 | } | 775 | } |
644 | GNUNET_free(binary); | 776 | GNUNET_free (binary); |
645 | GNUNET_free(quotedbinary); | 777 | GNUNET_free (quotedbinary); |
646 | GNUNET_free_non_null(config); | 778 | GNUNET_free_non_null (config); |
647 | GNUNET_free(loprefix); | 779 | GNUNET_free (loprefix); |
648 | GNUNET_free(lopostfix); | 780 | GNUNET_free (lopostfix); |
649 | if (NULL == proc) | 781 | if (NULL == proc) |
650 | return GNUNET_ARM_RESULT_START_FAILED; | 782 | return GNUNET_ARM_RESULT_START_FAILED; |
651 | GNUNET_OS_process_destroy(proc); | 783 | GNUNET_OS_process_destroy (proc); |
652 | return GNUNET_ARM_RESULT_STARTING; | 784 | return GNUNET_ARM_RESULT_STARTING; |
653 | } | 785 | } |
654 | 786 | ||
@@ -660,19 +792,29 @@ start_arm_service(struct GNUNET_ARM_Handle *h, | |||
660 | * @param op operation to cancel | 792 | * @param op operation to cancel |
661 | */ | 793 | */ |
662 | void | 794 | void |
663 | GNUNET_ARM_operation_cancel(struct GNUNET_ARM_Operation *op) | 795 | GNUNET_ARM_operation_cancel (struct GNUNET_ARM_Operation *op) |
664 | { | 796 | { |
665 | struct GNUNET_ARM_Handle *h = op->h; | 797 | struct GNUNET_ARM_Handle *h = op->h; |
666 | 798 | ||
799 | if (NULL != op->async) | ||
800 | { | ||
801 | GNUNET_SCHEDULER_cancel (op->async); | ||
802 | op->async = NULL; | ||
803 | } | ||
804 | if (NULL != op->rfd) | ||
805 | { | ||
806 | GNUNET_DISK_file_close (op->rfd); | ||
807 | op->rfd = NULL; | ||
808 | } | ||
667 | if (h->thm == op) | 809 | if (h->thm == op) |
668 | { | 810 | { |
669 | op->result_cont = NULL; | 811 | op->result_cont = NULL; |
670 | return; | 812 | return; |
671 | } | 813 | } |
672 | GNUNET_CONTAINER_DLL_remove(h->operation_pending_head, | 814 | GNUNET_CONTAINER_DLL_remove (h->operation_pending_head, |
673 | h->operation_pending_tail, | 815 | h->operation_pending_tail, |
674 | op); | 816 | op); |
675 | GNUNET_free(op); | 817 | GNUNET_free (op); |
676 | } | 818 | } |
677 | 819 | ||
678 | 820 | ||
@@ -687,38 +829,38 @@ GNUNET_ARM_operation_cancel(struct GNUNET_ARM_Operation *op) | |||
687 | * @return handle to queue, NULL on error | 829 | * @return handle to queue, NULL on error |
688 | */ | 830 | */ |
689 | static struct GNUNET_ARM_Operation * | 831 | static struct GNUNET_ARM_Operation * |
690 | change_service(struct GNUNET_ARM_Handle *h, | 832 | change_service (struct GNUNET_ARM_Handle *h, |
691 | const char *service_name, | 833 | const char *service_name, |
692 | GNUNET_ARM_ResultCallback cb, | 834 | GNUNET_ARM_ResultCallback cb, |
693 | void *cb_cls, | 835 | void *cb_cls, |
694 | uint16_t type) | 836 | uint16_t type) |
695 | { | 837 | { |
696 | struct GNUNET_ARM_Operation *op; | 838 | struct GNUNET_ARM_Operation *op; |
697 | size_t slen; | 839 | size_t slen; |
698 | struct GNUNET_MQ_Envelope *env; | 840 | struct GNUNET_MQ_Envelope *env; |
699 | struct GNUNET_ARM_Message *msg; | 841 | struct GNUNET_ARM_Message *msg; |
700 | 842 | ||
701 | slen = strlen(service_name) + 1; | 843 | slen = strlen (service_name) + 1; |
702 | if (slen + sizeof(struct GNUNET_ARM_Message) >= GNUNET_MAX_MESSAGE_SIZE) | 844 | if (slen + sizeof(struct GNUNET_ARM_Message) >= GNUNET_MAX_MESSAGE_SIZE) |
703 | { | 845 | { |
704 | GNUNET_break(0); | 846 | GNUNET_break (0); |
705 | return NULL; | 847 | return NULL; |
706 | } | 848 | } |
707 | if (0 == h->request_id_counter) | 849 | if (0 == h->request_id_counter) |
708 | h->request_id_counter++; | 850 | h->request_id_counter++; |
709 | op = GNUNET_new(struct GNUNET_ARM_Operation); | 851 | op = GNUNET_new (struct GNUNET_ARM_Operation); |
710 | op->h = h; | 852 | op->h = h; |
711 | op->result_cont = cb; | 853 | op->result_cont = cb; |
712 | op->cont_cls = cb_cls; | 854 | op->cont_cls = cb_cls; |
713 | op->id = h->request_id_counter++; | 855 | op->id = h->request_id_counter++; |
714 | GNUNET_CONTAINER_DLL_insert_tail(h->operation_pending_head, | 856 | GNUNET_CONTAINER_DLL_insert_tail (h->operation_pending_head, |
715 | h->operation_pending_tail, | 857 | h->operation_pending_tail, |
716 | op); | 858 | op); |
717 | env = GNUNET_MQ_msg_extra(msg, slen, type); | 859 | env = GNUNET_MQ_msg_extra (msg, slen, type); |
718 | msg->reserved = htonl(0); | 860 | msg->reserved = htonl (0); |
719 | msg->request_id = GNUNET_htonll(op->id); | 861 | msg->request_id = GNUNET_htonll (op->id); |
720 | GNUNET_memcpy(&msg[1], service_name, slen); | 862 | GNUNET_memcpy (&msg[1], service_name, slen); |
721 | GNUNET_MQ_send(h->mq, env); | 863 | GNUNET_MQ_send (h->mq, env); |
722 | return op; | 864 | return op; |
723 | } | 865 | } |
724 | 866 | ||
@@ -729,22 +871,24 @@ change_service(struct GNUNET_ARM_Handle *h, | |||
729 | * @param cls the operation that asked ARM to be started | 871 | * @param cls the operation that asked ARM to be started |
730 | */ | 872 | */ |
731 | static void | 873 | static void |
732 | notify_running(void *cls) | 874 | notify_running (void *cls) |
733 | { | 875 | { |
734 | struct GNUNET_ARM_Operation *op = cls; | 876 | struct GNUNET_ARM_Operation *op = cls; |
735 | struct GNUNET_ARM_Handle *h = op->h; | 877 | struct GNUNET_ARM_Handle *h = op->h; |
736 | 878 | ||
737 | op->async = NULL; | 879 | op->async = NULL; |
738 | GNUNET_CONTAINER_DLL_remove(h->operation_pending_head, | 880 | GNUNET_CONTAINER_DLL_remove (h->operation_pending_head, |
739 | h->operation_pending_tail, | 881 | h->operation_pending_tail, |
740 | op); | 882 | op); |
741 | if (NULL != op->result_cont) | 883 | if (NULL != op->result_cont) |
742 | op->result_cont(op->cont_cls, | 884 | op->result_cont (op->cont_cls, |
743 | GNUNET_ARM_REQUEST_SENT_OK, | 885 | GNUNET_ARM_REQUEST_SENT_OK, |
744 | GNUNET_ARM_RESULT_IS_STARTED_ALREADY); | 886 | GNUNET_ARM_RESULT_IS_STARTED_ALREADY); |
745 | if ((GNUNET_YES == h->currently_up) && (NULL != h->conn_status)) | 887 | if ( (GNUNET_YES == h->currently_up) && |
746 | h->conn_status(h->conn_status_cls, GNUNET_YES); | 888 | (NULL != h->conn_status) ) |
747 | GNUNET_free(op); | 889 | h->conn_status (h->conn_status_cls, |
890 | GNUNET_YES); | ||
891 | GNUNET_free (op); | ||
748 | } | 892 | } |
749 | 893 | ||
750 | 894 | ||
@@ -754,22 +898,22 @@ notify_running(void *cls) | |||
754 | * @param cls the operation that asked ARM to be started | 898 | * @param cls the operation that asked ARM to be started |
755 | */ | 899 | */ |
756 | static void | 900 | static void |
757 | notify_starting(void *cls) | 901 | notify_starting (void *cls) |
758 | { | 902 | { |
759 | struct GNUNET_ARM_Operation *op = cls; | 903 | struct GNUNET_ARM_Operation *op = cls; |
760 | struct GNUNET_ARM_Handle *h = op->h; | 904 | struct GNUNET_ARM_Handle *h = op->h; |
761 | 905 | ||
762 | op->async = NULL; | 906 | op->async = NULL; |
763 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 907 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
764 | "Notifying client that we started the ARM service\n"); | 908 | "Notifying client that we started the ARM service\n"); |
765 | GNUNET_CONTAINER_DLL_remove(h->operation_pending_head, | 909 | GNUNET_CONTAINER_DLL_remove (h->operation_pending_head, |
766 | h->operation_pending_tail, | 910 | h->operation_pending_tail, |
767 | op); | 911 | op); |
768 | if (NULL != op->result_cont) | 912 | if (NULL != op->result_cont) |
769 | op->result_cont(op->cont_cls, | 913 | op->result_cont (op->cont_cls, |
770 | GNUNET_ARM_REQUEST_SENT_OK, | 914 | GNUNET_ARM_REQUEST_SENT_OK, |
771 | op->starting_ret); | 915 | op->starting_ret); |
772 | GNUNET_free(op); | 916 | GNUNET_free (op); |
773 | } | 917 | } |
774 | 918 | ||
775 | 919 | ||
@@ -784,23 +928,28 @@ notify_starting(void *cls) | |||
784 | * @return handle for the operation, NULL on error | 928 | * @return handle for the operation, NULL on error |
785 | */ | 929 | */ |
786 | struct GNUNET_ARM_Operation * | 930 | struct GNUNET_ARM_Operation * |
787 | GNUNET_ARM_request_service_start( | 931 | GNUNET_ARM_request_service_start (struct GNUNET_ARM_Handle *h, |
788 | struct GNUNET_ARM_Handle *h, | 932 | const char *service_name, |
789 | const char *service_name, | 933 | enum GNUNET_OS_InheritStdioFlags |
790 | enum GNUNET_OS_InheritStdioFlags std_inheritance, | 934 | std_inheritance, |
791 | GNUNET_ARM_ResultCallback cont, | 935 | GNUNET_ARM_ResultCallback cont, |
792 | void *cont_cls) | 936 | void *cont_cls) |
793 | { | 937 | { |
794 | struct GNUNET_ARM_Operation *op; | 938 | struct GNUNET_ARM_Operation *op; |
795 | enum GNUNET_ARM_Result ret; | 939 | enum GNUNET_ARM_Result ret; |
796 | 940 | struct GNUNET_DISK_PipeHandle *sig; | |
797 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Starting service `%s'\n", service_name); | 941 | struct GNUNET_DISK_FileHandle *wsig; |
798 | if (0 != strcasecmp("arm", service_name)) | 942 | |
799 | return change_service(h, | 943 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
800 | service_name, | 944 | "Starting service `%s'\n", |
801 | cont, | 945 | service_name); |
802 | cont_cls, | 946 | if (0 != strcasecmp ("arm", |
803 | GNUNET_MESSAGE_TYPE_ARM_START); | 947 | service_name)) |
948 | return change_service (h, | ||
949 | service_name, | ||
950 | cont, | ||
951 | cont_cls, | ||
952 | GNUNET_MESSAGE_TYPE_ARM_START); | ||
804 | 953 | ||
805 | /* Possible cases: | 954 | /* Possible cases: |
806 | * 1) We're connected to ARM already. Invoke the callback immediately. | 955 | * 1) We're connected to ARM already. Invoke the callback immediately. |
@@ -809,37 +958,68 @@ GNUNET_ARM_request_service_start( | |||
809 | * a service test. | 958 | * a service test. |
810 | */ | 959 | */ |
811 | if (GNUNET_YES == h->currently_up) | 960 | if (GNUNET_YES == h->currently_up) |
812 | { | 961 | { |
813 | LOG(GNUNET_ERROR_TYPE_DEBUG, "ARM is already running\n"); | 962 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
814 | op = GNUNET_new(struct GNUNET_ARM_Operation); | 963 | "ARM is already running\n"); |
815 | op->h = h; | 964 | op = GNUNET_new (struct GNUNET_ARM_Operation); |
816 | op->result_cont = cont; | 965 | op->h = h; |
817 | op->cont_cls = cont_cls; | 966 | op->result_cont = cont; |
818 | GNUNET_CONTAINER_DLL_insert_tail(h->operation_pending_head, | 967 | op->cont_cls = cont_cls; |
819 | h->operation_pending_tail, | 968 | GNUNET_CONTAINER_DLL_insert_tail (h->operation_pending_head, |
820 | op); | 969 | h->operation_pending_tail, |
821 | op->async = GNUNET_SCHEDULER_add_now(¬ify_running, op); | 970 | op); |
822 | return op; | 971 | op->async = GNUNET_SCHEDULER_add_now (¬ify_running, op); |
823 | } | 972 | return op; |
973 | } | ||
824 | /* This is an inherently uncertain choice, as it is of course | 974 | /* This is an inherently uncertain choice, as it is of course |
825 | theoretically possible that ARM is up and we just did not | 975 | theoretically possible that ARM is up and we just did not |
826 | yet complete the MQ handshake. However, given that users | 976 | yet complete the MQ handshake. However, given that users |
827 | are unlikely to hammer 'gnunet-arm -s' on a busy system, | 977 | are unlikely to hammer 'gnunet-arm -s' on a busy system, |
828 | the above check should catch 99.99% of the cases where ARM | 978 | the above check should catch 99.99% of the cases where ARM |
829 | is already running. */ | 979 | is already running. */ |
830 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Starting ARM service\n"); | 980 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
831 | ret = start_arm_service(h, std_inheritance); | 981 | "Starting ARM service\n"); |
982 | if (NULL == (sig = GNUNET_DISK_pipe (GNUNET_NO, | ||
983 | GNUNET_NO, | ||
984 | GNUNET_NO, | ||
985 | GNUNET_YES))) | ||
986 | { | ||
987 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, | ||
988 | "pipe"); | ||
989 | } | ||
990 | wsig = GNUNET_DISK_pipe_detach_end (sig, | ||
991 | GNUNET_DISK_PIPE_END_WRITE); | ||
992 | ret = start_arm_service (h, | ||
993 | std_inheritance, | ||
994 | wsig); | ||
995 | GNUNET_DISK_file_close (wsig); | ||
832 | if (GNUNET_ARM_RESULT_STARTING == ret) | 996 | if (GNUNET_ARM_RESULT_STARTING == ret) |
833 | reconnect_arm(h); | 997 | reconnect_arm (h); |
834 | op = GNUNET_new(struct GNUNET_ARM_Operation); | 998 | op = GNUNET_new (struct GNUNET_ARM_Operation); |
835 | op->h = h; | 999 | op->h = h; |
836 | op->result_cont = cont; | 1000 | op->result_cont = cont; |
837 | op->cont_cls = cont_cls; | 1001 | op->cont_cls = cont_cls; |
838 | GNUNET_CONTAINER_DLL_insert_tail(h->operation_pending_head, | 1002 | GNUNET_CONTAINER_DLL_insert_tail (h->operation_pending_head, |
839 | h->operation_pending_tail, | 1003 | h->operation_pending_tail, |
840 | op); | 1004 | op); |
841 | op->starting_ret = ret; | 1005 | op->starting_ret = ret; |
842 | op->async = GNUNET_SCHEDULER_add_now(¬ify_starting, op); | 1006 | if (NULL != sig) |
1007 | { | ||
1008 | op->rfd = GNUNET_DISK_pipe_detach_end (sig, | ||
1009 | GNUNET_DISK_PIPE_END_READ); | ||
1010 | /* Wait at most a minute for gnunet-service-arm to be up, as beyond | ||
1011 | that something clearly just went wrong */ | ||
1012 | op->async = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_MINUTES, | ||
1013 | op->rfd, | ||
1014 | ¬ify_starting, | ||
1015 | op); | ||
1016 | } | ||
1017 | else | ||
1018 | { | ||
1019 | op->async = GNUNET_SCHEDULER_add_now (¬ify_starting, | ||
1020 | op); | ||
1021 | } | ||
1022 | GNUNET_DISK_pipe_close (sig); | ||
843 | return op; | 1023 | return op; |
844 | } | 1024 | } |
845 | 1025 | ||
@@ -859,24 +1039,27 @@ GNUNET_ARM_request_service_start( | |||
859 | * @return handle for the operation, NULL on error | 1039 | * @return handle for the operation, NULL on error |
860 | */ | 1040 | */ |
861 | struct GNUNET_ARM_Operation * | 1041 | struct GNUNET_ARM_Operation * |
862 | GNUNET_ARM_request_service_stop(struct GNUNET_ARM_Handle *h, | 1042 | GNUNET_ARM_request_service_stop (struct GNUNET_ARM_Handle *h, |
863 | const char *service_name, | 1043 | const char *service_name, |
864 | GNUNET_ARM_ResultCallback cont, | 1044 | GNUNET_ARM_ResultCallback cont, |
865 | void *cont_cls) | 1045 | void *cont_cls) |
866 | { | 1046 | { |
867 | struct GNUNET_ARM_Operation *op; | 1047 | struct GNUNET_ARM_Operation *op; |
868 | 1048 | ||
869 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Stopping service `%s'\n", service_name); | 1049 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
870 | op = change_service(h, | 1050 | "Stopping service `%s'\n", |
871 | service_name, | 1051 | service_name); |
872 | cont, | 1052 | op = change_service (h, |
873 | cont_cls, | 1053 | service_name, |
874 | GNUNET_MESSAGE_TYPE_ARM_STOP); | 1054 | cont, |
1055 | cont_cls, | ||
1056 | GNUNET_MESSAGE_TYPE_ARM_STOP); | ||
875 | if (NULL == op) | 1057 | if (NULL == op) |
876 | return NULL; | 1058 | return NULL; |
877 | /* If the service is ARM, set a flag as we will use MQ errors | 1059 | /* If the service is ARM, set a flag as we will use MQ errors |
878 | to detect that the process is really gone. */ | 1060 | to detect that the process is really gone. */ |
879 | if (0 == strcasecmp(service_name, "arm")) | 1061 | if (0 == strcasecmp (service_name, |
1062 | "arm")) | ||
880 | op->is_arm_stop = GNUNET_YES; | 1063 | op->is_arm_stop = GNUNET_YES; |
881 | return op; | 1064 | return op; |
882 | } | 1065 | } |
@@ -891,29 +1074,31 @@ GNUNET_ARM_request_service_stop(struct GNUNET_ARM_Handle *h, | |||
891 | * @return handle for the operation, NULL on error | 1074 | * @return handle for the operation, NULL on error |
892 | */ | 1075 | */ |
893 | struct GNUNET_ARM_Operation * | 1076 | struct GNUNET_ARM_Operation * |
894 | GNUNET_ARM_request_service_list(struct GNUNET_ARM_Handle *h, | 1077 | GNUNET_ARM_request_service_list (struct GNUNET_ARM_Handle *h, |
895 | GNUNET_ARM_ServiceListCallback cont, | 1078 | GNUNET_ARM_ServiceListCallback cont, |
896 | void *cont_cls) | 1079 | void *cont_cls) |
897 | { | 1080 | { |
898 | struct GNUNET_ARM_Operation *op; | 1081 | struct GNUNET_ARM_Operation *op; |
899 | struct GNUNET_MQ_Envelope *env; | 1082 | struct GNUNET_MQ_Envelope *env; |
900 | struct GNUNET_ARM_Message *msg; | 1083 | struct GNUNET_ARM_Message *msg; |
901 | 1084 | ||
902 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Requesting LIST from ARM service\n"); | 1085 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1086 | "Requesting LIST from ARM service\n"); | ||
903 | if (0 == h->request_id_counter) | 1087 | if (0 == h->request_id_counter) |
904 | h->request_id_counter++; | 1088 | h->request_id_counter++; |
905 | op = GNUNET_new(struct GNUNET_ARM_Operation); | 1089 | op = GNUNET_new (struct GNUNET_ARM_Operation); |
906 | op->h = h; | 1090 | op->h = h; |
907 | op->list_cont = cont; | 1091 | op->list_cont = cont; |
908 | op->cont_cls = cont_cls; | 1092 | op->cont_cls = cont_cls; |
909 | op->id = h->request_id_counter++; | 1093 | op->id = h->request_id_counter++; |
910 | GNUNET_CONTAINER_DLL_insert_tail(h->operation_pending_head, | 1094 | GNUNET_CONTAINER_DLL_insert_tail (h->operation_pending_head, |
911 | h->operation_pending_tail, | 1095 | h->operation_pending_tail, |
912 | op); | 1096 | op); |
913 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_ARM_LIST); | 1097 | env = GNUNET_MQ_msg (msg, |
914 | msg->reserved = htonl(0); | 1098 | GNUNET_MESSAGE_TYPE_ARM_LIST); |
915 | msg->request_id = GNUNET_htonll(op->id); | 1099 | msg->reserved = htonl (0); |
916 | GNUNET_MQ_send(h->mq, env); | 1100 | msg->request_id = GNUNET_htonll (op->id); |
1101 | GNUNET_MQ_send (h->mq, env); | ||
917 | return op; | 1102 | return op; |
918 | } | 1103 | } |
919 | 1104 | ||
diff --git a/src/arm/arm_monitor_api.c b/src/arm/arm_monitor_api.c index c6e1e2683..00faaaef1 100644 --- a/src/arm/arm_monitor_api.c +++ b/src/arm/arm_monitor_api.c | |||
@@ -61,7 +61,7 @@ struct GNUNET_ARM_MonitorHandle { | |||
61 | /** | 61 | /** |
62 | * Callback to invoke on status updates. | 62 | * Callback to invoke on status updates. |
63 | */ | 63 | */ |
64 | GNUNET_ARM_ServiceStatusCallback service_status; | 64 | GNUNET_ARM_ServiceMonitorCallback service_status; |
65 | 65 | ||
66 | /** | 66 | /** |
67 | * Closure for @e service_status. | 67 | * Closure for @e service_status. |
@@ -153,9 +153,9 @@ static void | |||
153 | handle_monitor_notify(void *cls, const struct GNUNET_ARM_StatusMessage *res) | 153 | handle_monitor_notify(void *cls, const struct GNUNET_ARM_StatusMessage *res) |
154 | { | 154 | { |
155 | struct GNUNET_ARM_MonitorHandle *h = cls; | 155 | struct GNUNET_ARM_MonitorHandle *h = cls; |
156 | enum GNUNET_ARM_ServiceStatus status; | 156 | enum GNUNET_ARM_ServiceMonitorStatus status; |
157 | 157 | ||
158 | status = (enum GNUNET_ARM_ServiceStatus)ntohl(res->status); | 158 | status = (enum GNUNET_ARM_ServiceMonitorStatus)ntohl(res->status); |
159 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 159 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
160 | "Received notification from ARM for service `%s' with status %d\n", | 160 | "Received notification from ARM for service `%s' with status %d\n", |
161 | (const char *)&res[1], | 161 | (const char *)&res[1], |
@@ -230,7 +230,7 @@ reconnect_arm_monitor(struct GNUNET_ARM_MonitorHandle *h) | |||
230 | */ | 230 | */ |
231 | struct GNUNET_ARM_MonitorHandle * | 231 | struct GNUNET_ARM_MonitorHandle * |
232 | GNUNET_ARM_monitor_start(const struct GNUNET_CONFIGURATION_Handle *cfg, | 232 | GNUNET_ARM_monitor_start(const struct GNUNET_CONFIGURATION_Handle *cfg, |
233 | GNUNET_ARM_ServiceStatusCallback cont, | 233 | GNUNET_ARM_ServiceMonitorCallback cont, |
234 | void *cont_cls) | 234 | void *cont_cls) |
235 | { | 235 | { |
236 | struct GNUNET_ARM_MonitorHandle *h; | 236 | struct GNUNET_ARM_MonitorHandle *h; |
diff --git a/src/arm/gnunet-arm.c b/src/arm/gnunet-arm.c index 3396a4dbe..0fdb66fa0 100644 --- a/src/arm/gnunet-arm.c +++ b/src/arm/gnunet-arm.c | |||
@@ -54,6 +54,11 @@ static int delete; | |||
54 | static int quiet; | 54 | static int quiet; |
55 | 55 | ||
56 | /** | 56 | /** |
57 | * Set if we should print all services, including stopped ones. | ||
58 | */ | ||
59 | static int show_all; | ||
60 | |||
61 | /** | ||
57 | * Monitor ARM activity. | 62 | * Monitor ARM activity. |
58 | */ | 63 | */ |
59 | static int monitor; | 64 | static int monitor; |
@@ -144,25 +149,25 @@ static struct GNUNET_ARM_Operation *op; | |||
144 | * were specified when gnunet-arm was run. | 149 | * were specified when gnunet-arm was run. |
145 | */ | 150 | */ |
146 | static void | 151 | static void |
147 | delete_files() | 152 | delete_files () |
148 | { | 153 | { |
149 | GNUNET_log( | 154 | GNUNET_log ( |
150 | GNUNET_ERROR_TYPE_DEBUG, | 155 | GNUNET_ERROR_TYPE_DEBUG, |
151 | "Will attempt to remove configuration file %s and service directory %s\n", | 156 | "Will attempt to remove configuration file %s and service directory %s\n", |
152 | config_file, | 157 | config_file, |
153 | dir); | 158 | dir); |
154 | if (0 != unlink(config_file)) | 159 | if (0 != unlink (config_file)) |
155 | { | 160 | { |
156 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 161 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
157 | _("Failed to remove configuration file %s\n"), | 162 | _ ("Failed to remove configuration file %s\n"), |
158 | config_file); | 163 | config_file); |
159 | } | 164 | } |
160 | if (GNUNET_OK != GNUNET_DISK_directory_remove(dir)) | 165 | if (GNUNET_OK != GNUNET_DISK_directory_remove (dir)) |
161 | { | 166 | { |
162 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 167 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
163 | _("Failed to remove servicehome directory %s\n"), | 168 | _ ("Failed to remove servicehome directory %s\n"), |
164 | dir); | 169 | dir); |
165 | } | 170 | } |
166 | } | 171 | } |
167 | 172 | ||
168 | 173 | ||
@@ -173,37 +178,38 @@ delete_files() | |||
173 | * @param cls closure, unused | 178 | * @param cls closure, unused |
174 | */ | 179 | */ |
175 | static void | 180 | static void |
176 | shutdown_task(void *cls) | 181 | shutdown_task (void *cls) |
177 | { | 182 | { |
178 | (void)cls; | 183 | (void) cls; |
179 | if (NULL != al_task) | 184 | if (NULL != al_task) |
180 | { | 185 | { |
181 | GNUNET_SCHEDULER_cancel(al_task); | 186 | GNUNET_SCHEDULER_cancel (al_task); |
182 | al_task = NULL; | 187 | al_task = NULL; |
183 | } | 188 | } |
184 | if (NULL != op) | 189 | if (NULL != op) |
185 | { | 190 | { |
186 | GNUNET_ARM_operation_cancel(op); | 191 | GNUNET_ARM_operation_cancel (op); |
187 | op = NULL; | 192 | op = NULL; |
188 | } | 193 | } |
189 | if (NULL != h) | 194 | if (NULL != h) |
190 | { | 195 | { |
191 | GNUNET_ARM_disconnect(h); | 196 | GNUNET_ARM_disconnect (h); |
192 | h = NULL; | 197 | h = NULL; |
193 | } | 198 | } |
194 | if (NULL != m) | 199 | if (NULL != m) |
195 | { | 200 | { |
196 | GNUNET_ARM_monitor_stop(m); | 201 | GNUNET_ARM_monitor_stop (m); |
197 | m = NULL; | 202 | m = NULL; |
198 | } | 203 | } |
199 | if (NULL != timeout_task) | 204 | if (NULL != timeout_task) |
200 | { | 205 | { |
201 | GNUNET_SCHEDULER_cancel(timeout_task); | 206 | GNUNET_SCHEDULER_cancel (timeout_task); |
202 | timeout_task = NULL; | 207 | timeout_task = NULL; |
203 | } | 208 | } |
204 | if ((GNUNET_YES == end) && (GNUNET_YES == delete)) | 209 | if ( (GNUNET_YES == end) && |
205 | delete_files(); | 210 | (GNUNET_YES == delete) ) |
206 | GNUNET_CONFIGURATION_destroy(cfg); | 211 | delete_files (); |
212 | GNUNET_CONFIGURATION_destroy (cfg); | ||
207 | cfg = NULL; | 213 | cfg = NULL; |
208 | } | 214 | } |
209 | 215 | ||
@@ -215,17 +221,17 @@ shutdown_task(void *cls) | |||
215 | * @return a string interpretation of the request status | 221 | * @return a string interpretation of the request status |
216 | */ | 222 | */ |
217 | static const char * | 223 | static const char * |
218 | req_string(enum GNUNET_ARM_RequestStatus rs) | 224 | req_string (enum GNUNET_ARM_RequestStatus rs) |
219 | { | 225 | { |
220 | switch (rs) | 226 | switch (rs) |
221 | { | 227 | { |
222 | case GNUNET_ARM_REQUEST_SENT_OK: | 228 | case GNUNET_ARM_REQUEST_SENT_OK: |
223 | return _("Message was sent successfully"); | 229 | return _ ("Message was sent successfully"); |
224 | 230 | ||
225 | case GNUNET_ARM_REQUEST_DISCONNECTED: | 231 | case GNUNET_ARM_REQUEST_DISCONNECTED: |
226 | return _("We disconnected from ARM before we could send a request"); | 232 | return _ ("We disconnected from ARM before we could send a request"); |
227 | } | 233 | } |
228 | return _("Unknown request status"); | 234 | return _ ("Unknown request status"); |
229 | } | 235 | } |
230 | 236 | ||
231 | 237 | ||
@@ -236,41 +242,41 @@ req_string(enum GNUNET_ARM_RequestStatus rs) | |||
236 | * @return a string interpretation | 242 | * @return a string interpretation |
237 | */ | 243 | */ |
238 | static const char * | 244 | static const char * |
239 | ret_string(enum GNUNET_ARM_Result result) | 245 | ret_string (enum GNUNET_ARM_Result result) |
240 | { | 246 | { |
241 | switch (result) | 247 | switch (result) |
242 | { | 248 | { |
243 | case GNUNET_ARM_RESULT_STOPPED: | 249 | case GNUNET_ARM_RESULT_STOPPED: |
244 | return _("is stopped"); | 250 | return _ ("is stopped"); |
245 | 251 | ||
246 | case GNUNET_ARM_RESULT_STARTING: | 252 | case GNUNET_ARM_RESULT_STARTING: |
247 | return _("is starting"); | 253 | return _ ("is starting"); |
248 | 254 | ||
249 | case GNUNET_ARM_RESULT_STOPPING: | 255 | case GNUNET_ARM_RESULT_STOPPING: |
250 | return _("is stopping"); | 256 | return _ ("is stopping"); |
251 | 257 | ||
252 | case GNUNET_ARM_RESULT_IS_STARTING_ALREADY: | 258 | case GNUNET_ARM_RESULT_IS_STARTING_ALREADY: |
253 | return _("is starting already"); | 259 | return _ ("is starting already"); |
254 | 260 | ||
255 | case GNUNET_ARM_RESULT_IS_STOPPING_ALREADY: | 261 | case GNUNET_ARM_RESULT_IS_STOPPING_ALREADY: |
256 | return _("is stopping already"); | 262 | return _ ("is stopping already"); |
257 | 263 | ||
258 | case GNUNET_ARM_RESULT_IS_STARTED_ALREADY: | 264 | case GNUNET_ARM_RESULT_IS_STARTED_ALREADY: |
259 | return _("is started already"); | 265 | return _ ("is started already"); |
260 | 266 | ||
261 | case GNUNET_ARM_RESULT_IS_STOPPED_ALREADY: | 267 | case GNUNET_ARM_RESULT_IS_STOPPED_ALREADY: |
262 | return _("is stopped already"); | 268 | return _ ("is stopped already"); |
263 | 269 | ||
264 | case GNUNET_ARM_RESULT_IS_NOT_KNOWN: | 270 | case GNUNET_ARM_RESULT_IS_NOT_KNOWN: |
265 | return _("service is not known to ARM"); | 271 | return _ ("service is not known to ARM"); |
266 | 272 | ||
267 | case GNUNET_ARM_RESULT_START_FAILED: | 273 | case GNUNET_ARM_RESULT_START_FAILED: |
268 | return _("service failed to start"); | 274 | return _ ("service failed to start"); |
269 | 275 | ||
270 | case GNUNET_ARM_RESULT_IN_SHUTDOWN: | 276 | case GNUNET_ARM_RESULT_IN_SHUTDOWN: |
271 | return _("service cannot be manipulated because ARM is shutting down"); | 277 | return _ ("service cannot be manipulated because ARM is shutting down"); |
272 | } | 278 | } |
273 | return _("Unknown result code."); | 279 | return _ ("Unknown result code."); |
274 | } | 280 | } |
275 | 281 | ||
276 | 282 | ||
@@ -280,7 +286,7 @@ ret_string(enum GNUNET_ARM_Result result) | |||
280 | * @param cls closure | 286 | * @param cls closure |
281 | */ | 287 | */ |
282 | static void | 288 | static void |
283 | action_loop(void *cls); | 289 | action_loop (void *cls); |
284 | 290 | ||
285 | 291 | ||
286 | /** | 292 | /** |
@@ -293,18 +299,20 @@ action_loop(void *cls); | |||
293 | * #GNUNET_SYSERR on error. | 299 | * #GNUNET_SYSERR on error. |
294 | */ | 300 | */ |
295 | static void | 301 | static void |
296 | conn_status(void *cls, int connected) | 302 | conn_status (void *cls, |
303 | int connected) | ||
297 | { | 304 | { |
298 | static int once; | 305 | static int once; |
299 | 306 | ||
300 | (void)cls; | 307 | (void) cls; |
301 | if ((GNUNET_SYSERR == connected) && (0 == once)) | 308 | if ( (GNUNET_SYSERR == connected) && |
302 | { | 309 | (0 == once) ) |
303 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 310 | { |
304 | _("Fatal error initializing ARM API.\n")); | 311 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
305 | GNUNET_SCHEDULER_shutdown(); | 312 | _ ("Fatal error initializing ARM API.\n")); |
306 | return; | 313 | GNUNET_SCHEDULER_shutdown (); |
307 | } | 314 | return; |
315 | } | ||
308 | once = 1; | 316 | once = 1; |
309 | } | 317 | } |
310 | 318 | ||
@@ -321,32 +329,34 @@ conn_status(void *cls, int connected) | |||
321 | * according to ARM | 329 | * according to ARM |
322 | */ | 330 | */ |
323 | static void | 331 | static void |
324 | start_callback(void *cls, | 332 | start_callback (void *cls, |
325 | enum GNUNET_ARM_RequestStatus rs, | 333 | enum GNUNET_ARM_RequestStatus rs, |
326 | enum GNUNET_ARM_Result result) | 334 | enum GNUNET_ARM_Result result) |
327 | { | 335 | { |
328 | (void)cls; | 336 | (void) cls; |
329 | op = NULL; | 337 | op = NULL; |
330 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) | 338 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) |
331 | { | 339 | { |
332 | fprintf(stdout, | 340 | fprintf (stdout, |
333 | _("Failed to start the ARM service: %s\n"), | 341 | _ ("Failed to start the ARM service: %s\n"), |
334 | req_string(rs)); | 342 | req_string (rs)); |
335 | GNUNET_SCHEDULER_shutdown(); | 343 | GNUNET_SCHEDULER_shutdown (); |
336 | return; | 344 | return; |
337 | } | 345 | } |
338 | if ((GNUNET_ARM_RESULT_STARTING != result) && | 346 | if ((GNUNET_ARM_RESULT_STARTING != result) && |
339 | (GNUNET_ARM_RESULT_IS_STARTED_ALREADY != result)) | 347 | (GNUNET_ARM_RESULT_IS_STARTED_ALREADY != result)) |
340 | { | 348 | { |
341 | fprintf(stdout, | 349 | fprintf (stdout, |
342 | _("Failed to start the ARM service: %s\n"), | 350 | _ ("Failed to start the ARM service: %s\n"), |
343 | ret_string(result)); | 351 | ret_string (result)); |
344 | GNUNET_SCHEDULER_shutdown(); | 352 | GNUNET_SCHEDULER_shutdown (); |
345 | return; | 353 | return; |
346 | } | 354 | } |
347 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "ARM service [re]start successful\n"); | 355 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
356 | "ARM service [re]start successful\n"); | ||
348 | start = 0; | 357 | start = 0; |
349 | al_task = GNUNET_SCHEDULER_add_now(&action_loop, NULL); | 358 | al_task = GNUNET_SCHEDULER_add_now (&action_loop, |
359 | NULL); | ||
350 | } | 360 | } |
351 | 361 | ||
352 | 362 | ||
@@ -362,44 +372,47 @@ start_callback(void *cls, | |||
362 | * according to ARM | 372 | * according to ARM |
363 | */ | 373 | */ |
364 | static void | 374 | static void |
365 | stop_callback(void *cls, | 375 | stop_callback (void *cls, |
366 | enum GNUNET_ARM_RequestStatus rs, | 376 | enum GNUNET_ARM_RequestStatus rs, |
367 | enum GNUNET_ARM_Result result) | 377 | enum GNUNET_ARM_Result result) |
368 | { | 378 | { |
369 | char *msg; | 379 | char *msg; |
370 | 380 | ||
371 | (void)cls; | 381 | (void) cls; |
372 | op = NULL; | 382 | op = NULL; |
373 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) | 383 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) |
374 | { | 384 | { |
375 | GNUNET_asprintf(&msg, | 385 | GNUNET_asprintf (&msg, |
376 | "%s", | 386 | "%s", |
377 | _( | 387 | _ ( |
378 | "Failed to send a stop request to the ARM service: %s\n")); | 388 | "Failed to send a stop request to the ARM service: %s\n")); |
379 | fprintf(stdout, msg, req_string(rs)); | 389 | fprintf (stdout, msg, req_string (rs)); |
380 | GNUNET_free(msg); | 390 | GNUNET_free (msg); |
381 | GNUNET_SCHEDULER_shutdown(); | 391 | GNUNET_SCHEDULER_shutdown (); |
382 | return; | 392 | return; |
383 | } | 393 | } |
384 | if ((GNUNET_ARM_RESULT_STOPPING != result) && | 394 | if ( (GNUNET_ARM_RESULT_STOPPING != result) && |
385 | (GNUNET_ARM_RESULT_STOPPED != result) && | 395 | (GNUNET_ARM_RESULT_STOPPED != result) && |
386 | (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY != result)) | 396 | (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY != result) ) |
387 | { | 397 | { |
388 | fprintf(stdout, | 398 | fprintf (stdout, |
389 | _("Failed to stop the ARM service: %s\n"), | 399 | _ ("Failed to stop the ARM service: %s\n"), |
390 | ret_string(result)); | 400 | ret_string (result)); |
391 | GNUNET_SCHEDULER_shutdown(); | 401 | GNUNET_SCHEDULER_shutdown (); |
392 | return; | 402 | return; |
393 | } | 403 | } |
394 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "ARM service shutdown successful\n"); | 404 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
405 | "ARM service shutdown successful\n"); | ||
395 | end = 0; | 406 | end = 0; |
396 | if (restart) | 407 | if (restart) |
397 | { | 408 | { |
398 | restart = 0; | 409 | restart = 0; |
399 | start = 1; | 410 | start = 1; |
400 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Initiating an ARM restart\n"); | 411 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
401 | } | 412 | "Initiating an ARM restart\n"); |
402 | al_task = GNUNET_SCHEDULER_add_now(&action_loop, NULL); | 413 | } |
414 | al_task = GNUNET_SCHEDULER_add_now (&action_loop, | ||
415 | NULL); | ||
403 | } | 416 | } |
404 | 417 | ||
405 | 418 | ||
@@ -415,37 +428,38 @@ stop_callback(void *cls, | |||
415 | * according to ARM | 428 | * according to ARM |
416 | */ | 429 | */ |
417 | static void | 430 | static void |
418 | init_callback(void *cls, | 431 | init_callback (void *cls, |
419 | enum GNUNET_ARM_RequestStatus rs, | 432 | enum GNUNET_ARM_RequestStatus rs, |
420 | enum GNUNET_ARM_Result result) | 433 | enum GNUNET_ARM_Result result) |
421 | { | 434 | { |
422 | (void)cls; | 435 | (void) cls; |
423 | op = NULL; | 436 | op = NULL; |
424 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) | 437 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) |
425 | { | 438 | { |
426 | fprintf(stdout, | 439 | fprintf (stdout, |
427 | _("Failed to send a request to start the `%s' service: %s\n"), | 440 | _ ("Failed to send a request to start the `%s' service: %s\n"), |
428 | init, | 441 | init, |
429 | req_string(rs)); | 442 | req_string (rs)); |
430 | GNUNET_SCHEDULER_shutdown(); | 443 | GNUNET_SCHEDULER_shutdown (); |
431 | return; | 444 | return; |
432 | } | 445 | } |
433 | if ((GNUNET_ARM_RESULT_STARTING != result) && | 446 | if ((GNUNET_ARM_RESULT_STARTING != result) && |
434 | (GNUNET_ARM_RESULT_IS_STARTED_ALREADY != result)) | 447 | (GNUNET_ARM_RESULT_IS_STARTED_ALREADY != result)) |
435 | { | 448 | { |
436 | fprintf(stdout, | 449 | fprintf (stdout, |
437 | _("Failed to start the `%s' service: %s\n"), | 450 | _ ("Failed to start the `%s' service: %s\n"), |
438 | init, | 451 | init, |
439 | ret_string(result)); | 452 | ret_string (result)); |
440 | GNUNET_SCHEDULER_shutdown(); | 453 | GNUNET_SCHEDULER_shutdown (); |
441 | return; | 454 | return; |
442 | } | 455 | } |
443 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 456 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
444 | "Service %s [re]started successfully\n", | 457 | "Service %s [re]started successfully\n", |
445 | init); | 458 | init); |
446 | GNUNET_free(init); | 459 | GNUNET_free (init); |
447 | init = NULL; | 460 | init = NULL; |
448 | al_task = GNUNET_SCHEDULER_add_now(&action_loop, NULL); | 461 | al_task = GNUNET_SCHEDULER_add_now (&action_loop, |
462 | NULL); | ||
449 | } | 463 | } |
450 | 464 | ||
451 | 465 | ||
@@ -461,42 +475,45 @@ init_callback(void *cls, | |||
461 | * according to ARM | 475 | * according to ARM |
462 | */ | 476 | */ |
463 | static void | 477 | static void |
464 | term_callback(void *cls, | 478 | term_callback (void *cls, |
465 | enum GNUNET_ARM_RequestStatus rs, | 479 | enum GNUNET_ARM_RequestStatus rs, |
466 | enum GNUNET_ARM_Result result) | 480 | enum GNUNET_ARM_Result result) |
467 | { | 481 | { |
468 | char *msg; | 482 | char *msg; |
469 | 483 | ||
470 | (void)cls; | 484 | (void) cls; |
471 | op = NULL; | 485 | op = NULL; |
472 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) | 486 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) |
473 | { | 487 | { |
474 | GNUNET_asprintf(&msg, | 488 | GNUNET_asprintf (&msg, |
475 | _( | 489 | _ ( |
476 | "Failed to send a request to kill the `%s' service: %%s\n"), | 490 | "Failed to send a request to kill the `%s' service: %%s\n"), |
477 | term); | 491 | term); |
478 | fprintf(stdout, msg, req_string(rs)); | 492 | fprintf (stdout, |
479 | GNUNET_free(msg); | 493 | msg, |
480 | GNUNET_SCHEDULER_shutdown(); | 494 | req_string (rs)); |
481 | return; | 495 | GNUNET_free (msg); |
482 | } | 496 | GNUNET_SCHEDULER_shutdown (); |
483 | if ((GNUNET_ARM_RESULT_STOPPED != result) && | 497 | return; |
484 | (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY != result)) | 498 | } |
485 | { | 499 | if ( (GNUNET_ARM_RESULT_STOPPED != result) && |
486 | fprintf(stdout, | 500 | (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY != result) ) |
487 | _("Failed to kill the `%s' service: %s\n"), | 501 | { |
488 | term, | 502 | fprintf (stdout, |
489 | ret_string(result)); | 503 | _ ("Failed to kill the `%s' service: %s\n"), |
490 | GNUNET_SCHEDULER_shutdown(); | 504 | term, |
491 | return; | 505 | ret_string (result)); |
492 | } | 506 | GNUNET_SCHEDULER_shutdown (); |
507 | return; | ||
508 | } | ||
493 | 509 | ||
494 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 510 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
495 | "Service %s stopped successfully\n", | 511 | "Service %s stopped successfully\n", |
496 | term); | 512 | term); |
497 | GNUNET_free(term); | 513 | GNUNET_free (term); |
498 | term = NULL; | 514 | term = NULL; |
499 | al_task = GNUNET_SCHEDULER_add_now(&action_loop, NULL); | 515 | al_task = GNUNET_SCHEDULER_add_now (&action_loop, |
516 | NULL); | ||
500 | } | 517 | } |
501 | 518 | ||
502 | 519 | ||
@@ -508,42 +525,196 @@ term_callback(void *cls, | |||
508 | * @param cls closure (unused) | 525 | * @param cls closure (unused) |
509 | * @param rs request status (success, failure, etc.) | 526 | * @param rs request status (success, failure, etc.) |
510 | * @param count number of services in the list | 527 | * @param count number of services in the list |
511 | * @param list list of services that are running | 528 | * @param list list of services managed by arm |
512 | */ | 529 | */ |
513 | static void | 530 | static void |
514 | list_callback(void *cls, | 531 | list_callback (void *cls, |
515 | enum GNUNET_ARM_RequestStatus rs, | 532 | enum GNUNET_ARM_RequestStatus rs, |
516 | unsigned int count, | 533 | unsigned int count, |
517 | const char *const *list) | 534 | const struct GNUNET_ARM_ServiceInfo *list) |
518 | { | 535 | { |
519 | (void)cls; | 536 | unsigned int num_stopped = 0; |
537 | unsigned int num_started = 0; | ||
538 | unsigned int num_stopping = 0; | ||
539 | unsigned int num_failed = 0; | ||
540 | unsigned int num_finished = 0; | ||
541 | (void) cls; | ||
520 | op = NULL; | 542 | op = NULL; |
521 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) | 543 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) |
544 | { | ||
545 | char *msg; | ||
546 | |||
547 | GNUNET_asprintf (&msg, | ||
548 | "%s", | ||
549 | _ ("Failed to request a list of services: %s\n")); | ||
550 | fprintf (stdout, | ||
551 | msg, | ||
552 | req_string (rs)); | ||
553 | GNUNET_free (msg); | ||
554 | ret = 3; | ||
555 | GNUNET_SCHEDULER_shutdown (); | ||
556 | } | ||
557 | if (NULL == list) | ||
558 | { | ||
559 | fprintf (stderr, | ||
560 | "%s", | ||
561 | _ ("Error communicating with ARM. ARM not running?\n")); | ||
562 | GNUNET_SCHEDULER_shutdown (); | ||
563 | ret = 3; | ||
564 | return; | ||
565 | } | ||
566 | for (unsigned int i = 0; i < count; i++) | ||
567 | { | ||
568 | switch (list[i].status) | ||
522 | { | 569 | { |
523 | char *msg; | 570 | case GNUNET_ARM_SERVICE_STATUS_STOPPED: |
524 | 571 | num_stopped++; | |
525 | GNUNET_asprintf(&msg, | 572 | break; |
526 | "%s", | 573 | case GNUNET_ARM_SERVICE_STATUS_FAILED: |
527 | _("Failed to request a list of services: %s\n")); | 574 | num_failed++; |
528 | fprintf(stdout, msg, req_string(rs)); | 575 | break; |
529 | GNUNET_free(msg); | 576 | case GNUNET_ARM_SERVICE_STATUS_FINISHED: |
530 | ret = 3; | 577 | num_finished++; |
531 | GNUNET_SCHEDULER_shutdown(); | 578 | break; |
579 | case GNUNET_ARM_SERVICE_STATUS_STARTED: | ||
580 | num_started++; | ||
581 | break; | ||
582 | case GNUNET_ARM_SERVICE_STATUS_STOPPING: | ||
583 | num_stopping++; | ||
584 | fprintf (stdout, | ||
585 | "%s (binary='%s', status=stopping)\n", | ||
586 | list[i].name, | ||
587 | list[i].binary); | ||
588 | break; | ||
589 | default: | ||
590 | GNUNET_break_op (0); | ||
591 | fprintf (stdout, | ||
592 | "%s (binary='%s', status=unknown)\n", | ||
593 | list[i].name, | ||
594 | list[i].binary); | ||
595 | break; | ||
532 | } | 596 | } |
533 | if (NULL == list) | 597 | } |
598 | if (! quiet) | ||
599 | { | ||
600 | if (show_all) | ||
601 | fprintf (stdout, | ||
602 | "%s", | ||
603 | _ ("All services:\n")); | ||
604 | else | ||
605 | fprintf (stdout, | ||
606 | "%s", | ||
607 | _ ("Services (excluding stopped services):\n")); | ||
608 | if (num_stopped || num_failed || num_finished || num_stopping || | ||
609 | num_started) | ||
534 | { | 610 | { |
535 | fprintf(stderr, | 611 | int sep = 0; |
536 | "%s", | 612 | fprintf (stdout, "("); |
537 | _("Error communicating with ARM. ARM not running?\n")); | 613 | if (0 != num_started) |
538 | GNUNET_SCHEDULER_shutdown(); | 614 | { |
539 | ret = 3; | 615 | if (sep) |
540 | return; | 616 | fprintf (stdout, " / "); |
617 | fprintf (stdout, | ||
618 | "started: %u", | ||
619 | num_started); | ||
620 | sep = 1; | ||
621 | } | ||
622 | if (0 != num_failed) | ||
623 | { | ||
624 | if (sep) | ||
625 | fprintf (stdout, " / "); | ||
626 | fprintf (stdout, | ||
627 | "failed: %u", | ||
628 | num_failed); | ||
629 | sep = 1; | ||
630 | } | ||
631 | if (0 != num_stopping) | ||
632 | { | ||
633 | if (sep) | ||
634 | fprintf (stdout, " / "); | ||
635 | fprintf (stdout, | ||
636 | "stopping: %u", | ||
637 | num_stopping); | ||
638 | sep = 1; | ||
639 | } | ||
640 | if (0 != num_stopped) | ||
641 | { | ||
642 | if (sep) | ||
643 | fprintf (stdout, " / "); | ||
644 | fprintf (stdout, | ||
645 | "stopped: %u", | ||
646 | num_stopped); | ||
647 | sep = 1; | ||
648 | } | ||
649 | if (0 != num_finished) | ||
650 | { | ||
651 | if (sep) | ||
652 | fprintf (stdout, " / "); | ||
653 | fprintf (stdout, | ||
654 | "finished: %u", | ||
655 | num_finished); | ||
656 | sep = 1; | ||
657 | } | ||
658 | fprintf (stdout, ")\n"); | ||
541 | } | 659 | } |
542 | if (!quiet) | 660 | else |
543 | fprintf(stdout, "%s", _("Running services:\n")); | 661 | { |
662 | fprintf (stdout, | ||
663 | "%s", | ||
664 | _ ("(No services configured.)\n")); | ||
665 | } | ||
666 | } | ||
544 | for (unsigned int i = 0; i < count; i++) | 667 | for (unsigned int i = 0; i < count; i++) |
545 | fprintf(stdout, "%s\n", list[i]); | 668 | { |
546 | al_task = GNUNET_SCHEDULER_add_now(&action_loop, NULL); | 669 | struct GNUNET_TIME_Relative restart_in; |
670 | switch (list[i].status) | ||
671 | { | ||
672 | case GNUNET_ARM_SERVICE_STATUS_STOPPED: | ||
673 | if (show_all) | ||
674 | fprintf (stdout, | ||
675 | "%s (binary='%s', status=stopped)\n", | ||
676 | list[i].name, | ||
677 | list[i].binary); | ||
678 | break; | ||
679 | case GNUNET_ARM_SERVICE_STATUS_FAILED: | ||
680 | restart_in = GNUNET_TIME_absolute_get_remaining (list[i].restart_at); | ||
681 | fprintf (stdout, | ||
682 | "%s (binary='%s', status=failed, exit_status=%d, restart_delay='%s')\n", | ||
683 | list[i].name, | ||
684 | list[i].binary, | ||
685 | list[i].last_exit_status, | ||
686 | GNUNET_STRINGS_relative_time_to_string (restart_in, | ||
687 | GNUNET_YES)); | ||
688 | break; | ||
689 | case GNUNET_ARM_SERVICE_STATUS_FINISHED: | ||
690 | fprintf (stdout, | ||
691 | "%s (binary='%s', status=finished)\n", | ||
692 | list[i].name, | ||
693 | list[i].binary); | ||
694 | break; | ||
695 | case GNUNET_ARM_SERVICE_STATUS_STARTED: | ||
696 | fprintf (stdout, | ||
697 | "%s (binary='%s', status=started)\n", | ||
698 | list[i].name, | ||
699 | list[i].binary); | ||
700 | break; | ||
701 | case GNUNET_ARM_SERVICE_STATUS_STOPPING: | ||
702 | fprintf (stdout, | ||
703 | "%s (binary='%s', status=stopping)\n", | ||
704 | list[i].name, | ||
705 | list[i].binary); | ||
706 | break; | ||
707 | default: | ||
708 | GNUNET_break_op (0); | ||
709 | fprintf (stdout, | ||
710 | "%s (binary='%s', status=unknown)\n", | ||
711 | list[i].name, | ||
712 | list[i].binary); | ||
713 | break; | ||
714 | } | ||
715 | } | ||
716 | al_task = GNUNET_SCHEDULER_add_now (&action_loop, | ||
717 | NULL); | ||
547 | } | 718 | } |
548 | 719 | ||
549 | 720 | ||
@@ -554,91 +725,115 @@ list_callback(void *cls, | |||
554 | * @param cls closure, unused | 725 | * @param cls closure, unused |
555 | */ | 726 | */ |
556 | static void | 727 | static void |
557 | action_loop(void *cls) | 728 | action_loop (void *cls) |
558 | { | 729 | { |
559 | (void)cls; | 730 | (void) cls; |
560 | al_task = NULL; | 731 | al_task = NULL; |
561 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Running requested actions\n"); | 732 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
733 | "Running requested actions\n"); | ||
562 | while (1) | 734 | while (1) |
735 | { | ||
736 | switch (phase++) | ||
563 | { | 737 | { |
564 | switch (phase++) | 738 | case 0: |
739 | if (NULL != term) | ||
740 | { | ||
741 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
742 | "Termination action\n"); | ||
743 | op = GNUNET_ARM_request_service_stop (h, | ||
744 | term, | ||
745 | &term_callback, | ||
746 | NULL); | ||
747 | return; | ||
748 | } | ||
749 | break; | ||
750 | |||
751 | case 1: | ||
752 | if (end || restart) | ||
753 | { | ||
754 | if (GNUNET_YES != | ||
755 | GNUNET_CLIENT_test (cfg, | ||
756 | "arm")) | ||
757 | { | ||
758 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
759 | "GNUnet not running, cannot stop the peer\n"); | ||
760 | } | ||
761 | else | ||
565 | { | 762 | { |
566 | case 0: | 763 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
567 | if (NULL != term) | 764 | "End action\n"); |
568 | { | 765 | op = GNUNET_ARM_request_service_stop (h, |
569 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Termination action\n"); | 766 | "arm", |
570 | op = GNUNET_ARM_request_service_stop(h, term, &term_callback, NULL); | 767 | &stop_callback, |
571 | return; | 768 | NULL); |
572 | } | ||
573 | break; | ||
574 | |||
575 | case 1: | ||
576 | if (end || restart) | ||
577 | { | ||
578 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "End action\n"); | ||
579 | op = GNUNET_ARM_request_service_stop(h, "arm", &stop_callback, NULL); | ||
580 | return; | ||
581 | } | ||
582 | break; | ||
583 | |||
584 | case 2: | ||
585 | if (start) | ||
586 | { | ||
587 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Start action\n"); | ||
588 | op = | ||
589 | GNUNET_ARM_request_service_start(h, | ||
590 | "arm", | ||
591 | (no_stdout | ||
592 | ? 0 | ||
593 | : GNUNET_OS_INHERIT_STD_OUT) | | ||
594 | (no_stderr | ||
595 | ? 0 | ||
596 | : GNUNET_OS_INHERIT_STD_ERR), | ||
597 | &start_callback, | ||
598 | NULL); | ||
599 | return; | ||
600 | } | ||
601 | break; | ||
602 | |||
603 | case 3: | ||
604 | if (NULL != init) | ||
605 | { | ||
606 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Initialization action\n"); | ||
607 | op = GNUNET_ARM_request_service_start(h, | ||
608 | init, | ||
609 | GNUNET_OS_INHERIT_STD_NONE, | ||
610 | &init_callback, | ||
611 | NULL); | ||
612 | return; | ||
613 | } | ||
614 | break; | ||
615 | |||
616 | case 4: | ||
617 | if (list) | ||
618 | { | ||
619 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
620 | "Going to list all running services controlled by ARM.\n"); | ||
621 | op = GNUNET_ARM_request_service_list(h, &list_callback, &list); | ||
622 | return; | ||
623 | } | ||
624 | break; | ||
625 | |||
626 | case 5: | ||
627 | if (monitor) | ||
628 | { | ||
629 | if (!quiet) | ||
630 | fprintf(stderr, _("Now only monitoring, press CTRL-C to stop.\n")); | ||
631 | quiet = | ||
632 | 0; /* does not make sense to stay quiet in monitor mode at this time */ | ||
633 | return; /* done with tasks, just monitor */ | ||
634 | } | ||
635 | break; | ||
636 | |||
637 | default: /* last phase */ | ||
638 | GNUNET_SCHEDULER_shutdown(); | ||
639 | return; | 769 | return; |
640 | } | 770 | } |
771 | } | ||
772 | break; | ||
773 | |||
774 | case 2: | ||
775 | if (start) | ||
776 | { | ||
777 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
778 | "Start action\n"); | ||
779 | op = | ||
780 | GNUNET_ARM_request_service_start (h, | ||
781 | "arm", | ||
782 | (no_stdout | ||
783 | ? 0 | ||
784 | : GNUNET_OS_INHERIT_STD_OUT) | ||
785 | | (no_stderr | ||
786 | ? 0 | ||
787 | : GNUNET_OS_INHERIT_STD_ERR), | ||
788 | &start_callback, | ||
789 | NULL); | ||
790 | return; | ||
791 | } | ||
792 | break; | ||
793 | |||
794 | case 3: | ||
795 | if (NULL != init) | ||
796 | { | ||
797 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
798 | "Initialization action\n"); | ||
799 | op = GNUNET_ARM_request_service_start (h, | ||
800 | init, | ||
801 | GNUNET_OS_INHERIT_STD_NONE, | ||
802 | &init_callback, | ||
803 | NULL); | ||
804 | return; | ||
805 | } | ||
806 | break; | ||
807 | |||
808 | case 4: | ||
809 | if (list) | ||
810 | { | ||
811 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
812 | "Going to list all running services controlled by ARM.\n"); | ||
813 | op = GNUNET_ARM_request_service_list (h, | ||
814 | &list_callback, | ||
815 | &list); | ||
816 | return; | ||
817 | } | ||
818 | break; | ||
819 | |||
820 | case 5: | ||
821 | if (monitor) | ||
822 | { | ||
823 | if (! quiet) | ||
824 | fprintf (stderr, | ||
825 | _ ("Now only monitoring, press CTRL-C to stop.\n")); | ||
826 | quiet = | ||
827 | 0; /* does not make sense to stay quiet in monitor mode at this time */ | ||
828 | return; /* done with tasks, just monitor */ | ||
829 | } | ||
830 | break; | ||
831 | |||
832 | default: /* last phase */ | ||
833 | GNUNET_SCHEDULER_shutdown (); | ||
834 | return; | ||
641 | } | 835 | } |
836 | } | ||
642 | } | 837 | } |
643 | 838 | ||
644 | 839 | ||
@@ -650,48 +845,50 @@ action_loop(void *cls) | |||
650 | * @param status status of the service | 845 | * @param status status of the service |
651 | */ | 846 | */ |
652 | static void | 847 | static void |
653 | srv_status(void *cls, | 848 | srv_status (void *cls, |
654 | const char *service, | 849 | const char *service, |
655 | enum GNUNET_ARM_ServiceStatus status) | 850 | enum GNUNET_ARM_ServiceMonitorStatus status) |
656 | { | 851 | { |
657 | const char *msg; | 852 | const char *msg; |
658 | 853 | ||
659 | (void)cls; | 854 | (void) cls; |
660 | switch (status) | 855 | switch (status) |
661 | { | 856 | { |
662 | case GNUNET_ARM_SERVICE_MONITORING_STARTED: | 857 | case GNUNET_ARM_SERVICE_MONITORING_STARTED: |
663 | return; /* this should be done silently */ | 858 | return; /* this should be done silently */ |
664 | 859 | ||
665 | case GNUNET_ARM_SERVICE_STOPPED: | 860 | case GNUNET_ARM_SERVICE_STOPPED: |
666 | msg = _("Stopped %s.\n"); | 861 | msg = _ ("Stopped %s.\n"); |
667 | break; | 862 | break; |
668 | 863 | ||
669 | case GNUNET_ARM_SERVICE_STARTING: | 864 | case GNUNET_ARM_SERVICE_STARTING: |
670 | msg = _("Starting %s...\n"); | 865 | msg = _ ("Starting %s...\n"); |
671 | break; | 866 | break; |
672 | 867 | ||
673 | case GNUNET_ARM_SERVICE_STOPPING: | 868 | case GNUNET_ARM_SERVICE_STOPPING: |
674 | msg = _("Stopping %s...\n"); | 869 | msg = _ ("Stopping %s...\n"); |
675 | break; | 870 | break; |
676 | 871 | ||
677 | default: | 872 | default: |
678 | msg = NULL; | 873 | msg = NULL; |
679 | break; | 874 | break; |
680 | } | 875 | } |
681 | if (!quiet) | 876 | if (! quiet) |
682 | { | 877 | { |
683 | if (NULL != msg) | 878 | if (NULL != msg) |
684 | fprintf(stderr, msg, service); | 879 | fprintf (stderr, |
685 | else | 880 | msg, |
686 | fprintf(stderr, | 881 | service); |
687 | _("Unknown status %u for service %s.\n"), | 882 | else |
688 | status, | 883 | fprintf (stderr, |
689 | service); | 884 | _ ("Unknown status %u for service %s.\n"), |
690 | } | 885 | status, |
691 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 886 | service); |
692 | "Got service %s status %d\n", | 887 | } |
693 | service, | 888 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
694 | (int)status); | 889 | "Got service %s status %d\n", |
890 | service, | ||
891 | (int) status); | ||
695 | } | 892 | } |
696 | 893 | ||
697 | 894 | ||
@@ -699,12 +896,12 @@ srv_status(void *cls, | |||
699 | * Task run on timeout (if -T is given). | 896 | * Task run on timeout (if -T is given). |
700 | */ | 897 | */ |
701 | static void | 898 | static void |
702 | timeout_task_cb(void *cls) | 899 | timeout_task_cb (void *cls) |
703 | { | 900 | { |
704 | (void)cls; | 901 | (void) cls; |
705 | timeout_task = NULL; | 902 | timeout_task = NULL; |
706 | ret = 2; | 903 | ret = 2; |
707 | GNUNET_SCHEDULER_shutdown(); | 904 | GNUNET_SCHEDULER_shutdown (); |
708 | } | 905 | } |
709 | 906 | ||
710 | 907 | ||
@@ -717,34 +914,47 @@ timeout_task_cb(void *cls) | |||
717 | * @param c configuration | 914 | * @param c configuration |
718 | */ | 915 | */ |
719 | static void | 916 | static void |
720 | run(void *cls, | 917 | run (void *cls, |
721 | char *const *args, | 918 | char *const *args, |
722 | const char *cfgfile, | 919 | const char *cfgfile, |
723 | const struct GNUNET_CONFIGURATION_Handle *c) | 920 | const struct GNUNET_CONFIGURATION_Handle *c) |
724 | { | 921 | { |
725 | (void)cls; | 922 | (void) cls; |
726 | (void)args; | 923 | (void) args; |
727 | (void)cfgfile; | 924 | (void) cfgfile; |
728 | cfg = GNUNET_CONFIGURATION_dup(c); | 925 | cfg = GNUNET_CONFIGURATION_dup (c); |
729 | if (GNUNET_OK != | 926 | if (GNUNET_OK != |
730 | GNUNET_CONFIGURATION_get_value_string(cfg, "PATHS", "GNUNET_HOME", &dir)) | 927 | GNUNET_CONFIGURATION_get_value_string (cfg, |
731 | { | 928 | "PATHS", |
732 | GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "PATHS", "GNUNET_HOME"); | 929 | "GNUNET_HOME", |
733 | return; | 930 | &dir)) |
734 | } | 931 | { |
735 | (void)GNUNET_CONFIGURATION_get_value_filename(cfg, | 932 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, |
736 | "arm", | 933 | "PATHS", |
737 | "CONFIG", | 934 | "GNUNET_HOME"); |
738 | &config_file); | 935 | return; |
739 | if (NULL == (h = GNUNET_ARM_connect(cfg, &conn_status, NULL))) | 936 | } |
937 | (void) GNUNET_CONFIGURATION_get_value_filename (cfg, | ||
938 | "arm", | ||
939 | "CONFIG", | ||
940 | &config_file); | ||
941 | if (NULL == (h = GNUNET_ARM_connect (cfg, | ||
942 | &conn_status, | ||
943 | NULL))) | ||
740 | return; | 944 | return; |
741 | if (monitor) | 945 | if (monitor) |
742 | m = GNUNET_ARM_monitor_start(cfg, &srv_status, NULL); | 946 | m = GNUNET_ARM_monitor_start (cfg, |
743 | al_task = GNUNET_SCHEDULER_add_now(&action_loop, NULL); | 947 | &srv_status, |
744 | GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL); | 948 | NULL); |
949 | al_task = GNUNET_SCHEDULER_add_now (&action_loop, | ||
950 | NULL); | ||
951 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, | ||
952 | NULL); | ||
745 | if (0 != timeout.rel_value_us) | 953 | if (0 != timeout.rel_value_us) |
746 | timeout_task = | 954 | timeout_task = |
747 | GNUNET_SCHEDULER_add_delayed(timeout, &timeout_task_cb, NULL); | 955 | GNUNET_SCHEDULER_add_delayed (timeout, |
956 | &timeout_task_cb, | ||
957 | NULL); | ||
748 | } | 958 | } |
749 | 959 | ||
750 | 960 | ||
@@ -756,88 +966,98 @@ run(void *cls, | |||
756 | * @return 0 ok, 1 on error, 2 on timeout | 966 | * @return 0 ok, 1 on error, 2 on timeout |
757 | */ | 967 | */ |
758 | int | 968 | int |
759 | main(int argc, char *const *argv) | 969 | main (int argc, char *const *argv) |
760 | { | 970 | { |
761 | struct GNUNET_GETOPT_CommandLineOption options[] = | 971 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
762 | { GNUNET_GETOPT_option_flag('e', | 972 | GNUNET_GETOPT_option_flag ('e', |
763 | "end", | 973 | "end", |
764 | gettext_noop("stop all GNUnet services"), | 974 | gettext_noop ("stop all GNUnet services"), |
765 | &end), | 975 | &end), |
766 | GNUNET_GETOPT_option_string('i', | 976 | GNUNET_GETOPT_option_string ('i', |
767 | "init", | 977 | "init", |
768 | "SERVICE", | 978 | "SERVICE", |
769 | gettext_noop("start a particular service"), | 979 | gettext_noop ("start a particular service"), |
770 | &init), | 980 | &init), |
771 | GNUNET_GETOPT_option_string('k', | 981 | GNUNET_GETOPT_option_string ('k', |
772 | "kill", | 982 | "kill", |
773 | "SERVICE", | 983 | "SERVICE", |
774 | gettext_noop("stop a particular service"), | 984 | gettext_noop ("stop a particular service"), |
775 | &term), | 985 | &term), |
776 | GNUNET_GETOPT_option_flag('s', | 986 | GNUNET_GETOPT_option_flag ('a', |
777 | "start", | 987 | "all", |
778 | gettext_noop( | 988 | gettext_noop ( |
779 | "start all GNUnet default services"), | 989 | "also show stopped services (used with -I)"), |
780 | &start), | 990 | &show_all), |
781 | GNUNET_GETOPT_option_flag('r', | 991 | GNUNET_GETOPT_option_flag ('s', |
782 | "restart", | 992 | "start", |
783 | gettext_noop( | 993 | gettext_noop ( |
784 | "stop and start all GNUnet default services"), | 994 | "start all GNUnet default services"), |
785 | &restart), | 995 | &start), |
786 | GNUNET_GETOPT_option_flag('d', | 996 | GNUNET_GETOPT_option_flag ('r', |
787 | "delete", | 997 | "restart", |
788 | gettext_noop( | 998 | gettext_noop ( |
789 | "delete config file and directory on exit"), | 999 | "stop and start all GNUnet default services"), |
790 | &delete), | 1000 | &restart), |
791 | GNUNET_GETOPT_option_flag('m', | 1001 | GNUNET_GETOPT_option_flag ('d', |
792 | "monitor", | 1002 | "delete", |
793 | gettext_noop("monitor ARM activities"), | 1003 | gettext_noop ( |
794 | &monitor), | 1004 | "delete config file and directory on exit"), |
795 | GNUNET_GETOPT_option_flag('q', | 1005 | &delete), |
796 | "quiet", | 1006 | GNUNET_GETOPT_option_flag ('m', |
797 | gettext_noop("don't print status messages"), | 1007 | "monitor", |
798 | &quiet), | 1008 | gettext_noop ("monitor ARM activities"), |
799 | GNUNET_GETOPT_option_relative_time( | 1009 | &monitor), |
1010 | GNUNET_GETOPT_option_flag ('q', | ||
1011 | "quiet", | ||
1012 | gettext_noop ("don't print status messages"), | ||
1013 | &quiet), | ||
1014 | GNUNET_GETOPT_option_relative_time ( | ||
800 | 'T', | 1015 | 'T', |
801 | "timeout", | 1016 | "timeout", |
802 | "DELAY", | 1017 | "DELAY", |
803 | gettext_noop( | 1018 | gettext_noop ( |
804 | "exit with error status if operation does not finish after DELAY"), | 1019 | "exit with error status if operation does not finish after DELAY"), |
805 | &timeout), | 1020 | &timeout), |
806 | GNUNET_GETOPT_option_flag('I', | 1021 | GNUNET_GETOPT_option_flag ('I', |
807 | "info", | 1022 | "info", |
808 | gettext_noop( | 1023 | gettext_noop ( |
809 | "list currently running services"), | 1024 | "list currently running services"), |
810 | &list), | 1025 | &list), |
811 | GNUNET_GETOPT_option_flag( | 1026 | GNUNET_GETOPT_option_flag ( |
812 | 'O', | 1027 | 'O', |
813 | "no-stdout", | 1028 | "no-stdout", |
814 | gettext_noop("don't let gnunet-service-arm inherit standard output"), | 1029 | gettext_noop ("don't let gnunet-service-arm inherit standard output"), |
815 | &no_stdout), | 1030 | &no_stdout), |
816 | GNUNET_GETOPT_option_flag( | 1031 | GNUNET_GETOPT_option_flag ( |
817 | 'E', | 1032 | 'E', |
818 | "no-stderr", | 1033 | "no-stderr", |
819 | gettext_noop("don't let gnunet-service-arm inherit standard error"), | 1034 | gettext_noop ("don't let gnunet-service-arm inherit standard error"), |
820 | &no_stderr), | 1035 | &no_stderr), |
821 | GNUNET_GETOPT_OPTION_END }; | 1036 | GNUNET_GETOPT_OPTION_END |
1037 | }; | ||
822 | int lret; | 1038 | int lret; |
823 | 1039 | ||
824 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv)) | 1040 | if (GNUNET_OK != |
1041 | GNUNET_STRINGS_get_utf8_args (argc, | ||
1042 | argv, | ||
1043 | &argc, | ||
1044 | &argv)) | ||
825 | return 2; | 1045 | return 2; |
826 | if (GNUNET_OK == | 1046 | if (GNUNET_OK == |
827 | (lret = GNUNET_PROGRAM_run( | 1047 | (lret = GNUNET_PROGRAM_run ( |
828 | argc, | 1048 | argc, |
829 | argv, | 1049 | argv, |
830 | "gnunet-arm", | 1050 | "gnunet-arm", |
831 | gettext_noop( | 1051 | gettext_noop ( |
832 | "Control services and the Automated Restart Manager (ARM)"), | 1052 | "Control services and the Automated Restart Manager (ARM)"), |
833 | options, | 1053 | options, |
834 | &run, | 1054 | &run, |
835 | NULL))) | 1055 | NULL))) |
836 | { | 1056 | { |
837 | GNUNET_free((void *)argv); | 1057 | GNUNET_free ((void *) argv); |
838 | return ret; | 1058 | return ret; |
839 | } | 1059 | } |
840 | GNUNET_free((void *)argv); | 1060 | GNUNET_free ((void *) argv); |
841 | return lret; | 1061 | return lret; |
842 | } | 1062 | } |
843 | 1063 | ||
diff --git a/src/arm/gnunet-service-arm.c b/src/arm/gnunet-service-arm.c index e02314b91..d13be6eb1 100644 --- a/src/arm/gnunet-service-arm.c +++ b/src/arm/gnunet-service-arm.c | |||
@@ -29,10 +29,10 @@ | |||
29 | #include "gnunet_protocols.h" | 29 | #include "gnunet_protocols.h" |
30 | #include "arm.h" | 30 | #include "arm.h" |
31 | 31 | ||
32 | #define LOG(kind, ...) GNUNET_log_from(kind, "util", __VA_ARGS__) | 32 | #define LOG(kind, ...) GNUNET_log_from (kind, "util", __VA_ARGS__) |
33 | 33 | ||
34 | #define LOG_STRERROR(kind, syscall) \ | 34 | #define LOG_STRERROR(kind, syscall) \ |
35 | GNUNET_log_from_strerror(kind, "util", syscall) | 35 | GNUNET_log_from_strerror (kind, "util", syscall) |
36 | 36 | ||
37 | 37 | ||
38 | #if HAVE_WAIT4 | 38 | #if HAVE_WAIT4 |
@@ -65,7 +65,8 @@ struct ServiceList; | |||
65 | /** | 65 | /** |
66 | * Record with information about a listen socket we have open. | 66 | * Record with information about a listen socket we have open. |
67 | */ | 67 | */ |
68 | struct ServiceListeningInfo { | 68 | struct ServiceListeningInfo |
69 | { | ||
69 | /** | 70 | /** |
70 | * This is a linked list. | 71 | * This is a linked list. |
71 | */ | 72 | */ |
@@ -106,7 +107,8 @@ struct ServiceListeningInfo { | |||
106 | /** | 107 | /** |
107 | * List of our services. | 108 | * List of our services. |
108 | */ | 109 | */ |
109 | struct ServiceList { | 110 | struct ServiceList |
111 | { | ||
110 | /** | 112 | /** |
111 | * This is a doubly-linked list. | 113 | * This is a doubly-linked list. |
112 | */ | 114 | */ |
@@ -164,6 +166,11 @@ struct ServiceList { | |||
164 | struct GNUNET_TIME_Relative backoff; | 166 | struct GNUNET_TIME_Relative backoff; |
165 | 167 | ||
166 | /** | 168 | /** |
169 | * Absolute time at which the process was (re-)started last. | ||
170 | */ | ||
171 | struct GNUNET_TIME_Absolute last_started_at; | ||
172 | |||
173 | /** | ||
167 | * Absolute time at which the process is scheduled to restart in case of death | 174 | * Absolute time at which the process is scheduled to restart in case of death |
168 | */ | 175 | */ |
169 | struct GNUNET_TIME_Absolute restart_at; | 176 | struct GNUNET_TIME_Absolute restart_at; |
@@ -186,6 +193,11 @@ struct ServiceList { | |||
186 | * are on Windoze). | 193 | * are on Windoze). |
187 | */ | 194 | */ |
188 | int pipe_control; | 195 | int pipe_control; |
196 | |||
197 | /** | ||
198 | * Last exit status of the process. | ||
199 | */ | ||
200 | int last_exit_status; | ||
189 | }; | 201 | }; |
190 | 202 | ||
191 | /** | 203 | /** |
@@ -278,30 +290,30 @@ static struct GNUNET_NotificationContext *notifier; | |||
278 | * parameter is ignore on systems other than LINUX | 290 | * parameter is ignore on systems other than LINUX |
279 | */ | 291 | */ |
280 | static void | 292 | static void |
281 | add_unixpath(struct sockaddr **saddrs, | 293 | add_unixpath (struct sockaddr **saddrs, |
282 | socklen_t *saddrlens, | 294 | socklen_t *saddrlens, |
283 | const char *unixpath, | 295 | const char *unixpath, |
284 | int abstract) | 296 | int abstract) |
285 | { | 297 | { |
286 | #ifdef AF_UNIX | 298 | #ifdef AF_UNIX |
287 | struct sockaddr_un *un; | 299 | struct sockaddr_un *un; |
288 | 300 | ||
289 | un = GNUNET_new(struct sockaddr_un); | 301 | un = GNUNET_new (struct sockaddr_un); |
290 | un->sun_family = AF_UNIX; | 302 | un->sun_family = AF_UNIX; |
291 | GNUNET_strlcpy(un->sun_path, unixpath, sizeof(un->sun_path)); | 303 | GNUNET_strlcpy (un->sun_path, unixpath, sizeof(un->sun_path)); |
292 | #ifdef LINUX | 304 | #ifdef LINUX |
293 | if (GNUNET_YES == abstract) | 305 | if (GNUNET_YES == abstract) |
294 | un->sun_path[0] = '\0'; | 306 | un->sun_path[0] = '\0'; |
295 | #endif | 307 | #endif |
296 | #if HAVE_SOCKADDR_UN_SUN_LEN | 308 | #if HAVE_SOCKADDR_UN_SUN_LEN |
297 | un->sun_len = (u_char)sizeof(struct sockaddr_un); | 309 | un->sun_len = (u_char) sizeof(struct sockaddr_un); |
298 | #endif | 310 | #endif |
299 | *saddrs = (struct sockaddr *)un; | 311 | *saddrs = (struct sockaddr *) un; |
300 | *saddrlens = sizeof(struct sockaddr_un); | 312 | *saddrlens = sizeof(struct sockaddr_un); |
301 | #else | 313 | #else |
302 | /* this function should never be called | 314 | /* this function should never be called |
303 | * unless AF_UNIX is defined! */ | 315 | * unless AF_UNIX is defined! */ |
304 | GNUNET_assert(0); | 316 | GNUNET_assert (0); |
305 | #endif | 317 | #endif |
306 | } | 318 | } |
307 | 319 | ||
@@ -327,10 +339,10 @@ add_unixpath(struct sockaddr **saddrs, | |||
327 | * set to NULL). | 339 | * set to NULL). |
328 | */ | 340 | */ |
329 | static int | 341 | static int |
330 | get_server_addresses(const char *service_name, | 342 | get_server_addresses (const char *service_name, |
331 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 343 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
332 | struct sockaddr ***addrs, | 344 | struct sockaddr ***addrs, |
333 | socklen_t **addr_lens) | 345 | socklen_t **addr_lens) |
334 | { | 346 | { |
335 | int disablev6; | 347 | int disablev6; |
336 | struct GNUNET_NETWORK_Handle *desc; | 348 | struct GNUNET_NETWORK_Handle *desc; |
@@ -351,72 +363,72 @@ get_server_addresses(const char *service_name, | |||
351 | *addrs = NULL; | 363 | *addrs = NULL; |
352 | *addr_lens = NULL; | 364 | *addr_lens = NULL; |
353 | desc = NULL; | 365 | desc = NULL; |
354 | if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "DISABLEV6")) | 366 | if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "DISABLEV6")) |
355 | { | 367 | { |
356 | if (GNUNET_SYSERR == | 368 | if (GNUNET_SYSERR == |
357 | (disablev6 = GNUNET_CONFIGURATION_get_value_yesno(cfg, | 369 | (disablev6 = GNUNET_CONFIGURATION_get_value_yesno (cfg, |
358 | service_name, | 370 | service_name, |
359 | "DISABLEV6"))) | 371 | "DISABLEV6"))) |
360 | return GNUNET_SYSERR; | 372 | return GNUNET_SYSERR; |
361 | } | 373 | } |
362 | else | 374 | else |
363 | disablev6 = GNUNET_NO; | 375 | disablev6 = GNUNET_NO; |
364 | 376 | ||
365 | if (!disablev6) | 377 | if (! disablev6) |
378 | { | ||
379 | /* probe IPv6 support */ | ||
380 | desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0); | ||
381 | if (NULL == desc) | ||
366 | { | 382 | { |
367 | /* probe IPv6 support */ | 383 | if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || |
368 | desc = GNUNET_NETWORK_socket_create(PF_INET6, SOCK_STREAM, 0); | 384 | (EACCES == errno)) |
369 | if (NULL == desc) | 385 | { |
370 | { | 386 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket"); |
371 | if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || | 387 | return GNUNET_SYSERR; |
372 | (EACCES == errno)) | 388 | } |
373 | { | 389 | LOG (GNUNET_ERROR_TYPE_INFO, |
374 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "socket"); | 390 | _ ( |
375 | return GNUNET_SYSERR; | 391 | "Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"), |
376 | } | 392 | service_name, |
377 | LOG(GNUNET_ERROR_TYPE_INFO, | 393 | strerror (errno)); |
378 | _( | 394 | disablev6 = GNUNET_YES; |
379 | "Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"), | ||
380 | service_name, | ||
381 | strerror(errno)); | ||
382 | disablev6 = GNUNET_YES; | ||
383 | } | ||
384 | else | ||
385 | { | ||
386 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(desc)); | ||
387 | desc = NULL; | ||
388 | } | ||
389 | } | 395 | } |
396 | else | ||
397 | { | ||
398 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc)); | ||
399 | desc = NULL; | ||
400 | } | ||
401 | } | ||
390 | 402 | ||
391 | port = 0; | 403 | port = 0; |
392 | if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "PORT")) | 404 | if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT")) |
405 | { | ||
406 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, | ||
407 | service_name, | ||
408 | "PORT", | ||
409 | &port)) | ||
393 | { | 410 | { |
394 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, | 411 | LOG (GNUNET_ERROR_TYPE_ERROR, |
395 | service_name, | 412 | _ ("Require valid port number for service `%s' in configuration!\n"), |
396 | "PORT", | 413 | service_name); |
397 | &port)) | ||
398 | { | ||
399 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
400 | _("Require valid port number for service `%s' in configuration!\n"), | ||
401 | service_name); | ||
402 | } | ||
403 | if (port > 65535) | ||
404 | { | ||
405 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
406 | _("Require valid port number for service `%s' in configuration!\n"), | ||
407 | service_name); | ||
408 | return GNUNET_SYSERR; | ||
409 | } | ||
410 | } | 414 | } |
411 | 415 | if (port > 65535) | |
412 | if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "BINDTO")) | ||
413 | { | 416 | { |
414 | GNUNET_break(GNUNET_OK == | 417 | LOG (GNUNET_ERROR_TYPE_ERROR, |
415 | GNUNET_CONFIGURATION_get_value_string(cfg, | 418 | _ ("Require valid port number for service `%s' in configuration!\n"), |
419 | service_name); | ||
420 | return GNUNET_SYSERR; | ||
421 | } | ||
422 | } | ||
423 | |||
424 | if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "BINDTO")) | ||
425 | { | ||
426 | GNUNET_break (GNUNET_OK == | ||
427 | GNUNET_CONFIGURATION_get_value_string (cfg, | ||
416 | service_name, | 428 | service_name, |
417 | "BINDTO", | 429 | "BINDTO", |
418 | &hostname)); | 430 | &hostname)); |
419 | } | 431 | } |
420 | else | 432 | else |
421 | hostname = NULL; | 433 | hostname = NULL; |
422 | 434 | ||
@@ -424,235 +436,235 @@ get_server_addresses(const char *service_name, | |||
424 | abstract = GNUNET_NO; | 436 | abstract = GNUNET_NO; |
425 | #ifdef AF_UNIX | 437 | #ifdef AF_UNIX |
426 | if ((GNUNET_YES == | 438 | if ((GNUNET_YES == |
427 | GNUNET_CONFIGURATION_have_value(cfg, service_name, "UNIXPATH")) && | 439 | GNUNET_CONFIGURATION_have_value (cfg, service_name, "UNIXPATH")) && |
428 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename(cfg, | 440 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg, |
429 | service_name, | 441 | service_name, |
430 | "UNIXPATH", | 442 | "UNIXPATH", |
431 | &unixpath)) && | 443 | &unixpath)) && |
432 | (0 < strlen(unixpath))) | 444 | (0 < strlen (unixpath))) |
433 | { | 445 | { |
434 | /* probe UNIX support */ | 446 | /* probe UNIX support */ |
435 | struct sockaddr_un s_un; | 447 | struct sockaddr_un s_un; |
436 | 448 | ||
437 | if (strlen(unixpath) >= sizeof(s_un.sun_path)) | 449 | if (strlen (unixpath) >= sizeof(s_un.sun_path)) |
438 | { | 450 | { |
439 | LOG(GNUNET_ERROR_TYPE_WARNING, | 451 | LOG (GNUNET_ERROR_TYPE_WARNING, |
440 | _("UNIXPATH `%s' too long, maximum length is %llu\n"), | 452 | _ ("UNIXPATH `%s' too long, maximum length is %llu\n"), |
441 | unixpath, | 453 | unixpath, |
442 | (unsigned long long)sizeof(s_un.sun_path)); | 454 | (unsigned long long) sizeof(s_un.sun_path)); |
443 | unixpath = GNUNET_NETWORK_shorten_unixpath(unixpath); | 455 | unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath); |
444 | LOG(GNUNET_ERROR_TYPE_INFO, _("Using `%s' instead\n"), unixpath); | 456 | LOG (GNUNET_ERROR_TYPE_INFO, _ ("Using `%s' instead\n"), unixpath); |
445 | } | 457 | } |
446 | #ifdef LINUX | 458 | #ifdef LINUX |
447 | abstract = GNUNET_CONFIGURATION_get_value_yesno(cfg, | 459 | abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg, |
448 | "TESTING", | 460 | "TESTING", |
449 | "USE_ABSTRACT_SOCKETS"); | 461 | "USE_ABSTRACT_SOCKETS"); |
450 | if (GNUNET_SYSERR == abstract) | 462 | if (GNUNET_SYSERR == abstract) |
451 | abstract = GNUNET_NO; | 463 | abstract = GNUNET_NO; |
452 | #endif | 464 | #endif |
453 | if ((GNUNET_YES != abstract) && | 465 | if ((GNUNET_YES != abstract) && |
454 | (GNUNET_OK != GNUNET_DISK_directory_create_for_file(unixpath))) | 466 | (GNUNET_OK != GNUNET_DISK_directory_create_for_file (unixpath))) |
455 | GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "mkdir", unixpath); | 467 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "mkdir", unixpath); |
456 | } | 468 | } |
457 | if (NULL != unixpath) | 469 | if (NULL != unixpath) |
470 | { | ||
471 | desc = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0); | ||
472 | if (NULL == desc) | ||
458 | { | 473 | { |
459 | desc = GNUNET_NETWORK_socket_create(AF_UNIX, SOCK_STREAM, 0); | 474 | if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || |
460 | if (NULL == desc) | 475 | (EACCES == errno)) |
461 | { | 476 | { |
462 | if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || | 477 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket"); |
463 | (EACCES == errno)) | 478 | GNUNET_free_non_null (hostname); |
464 | { | 479 | GNUNET_free (unixpath); |
465 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "socket"); | 480 | return GNUNET_SYSERR; |
466 | GNUNET_free_non_null(hostname); | 481 | } |
467 | GNUNET_free(unixpath); | 482 | LOG (GNUNET_ERROR_TYPE_INFO, |
468 | return GNUNET_SYSERR; | 483 | _ ( |
469 | } | 484 | "Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"), |
470 | LOG(GNUNET_ERROR_TYPE_INFO, | 485 | service_name, |
471 | _( | 486 | strerror (errno)); |
472 | "Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"), | 487 | GNUNET_free (unixpath); |
473 | service_name, | 488 | unixpath = NULL; |
474 | strerror(errno)); | 489 | } |
475 | GNUNET_free(unixpath); | 490 | else |
476 | unixpath = NULL; | 491 | { |
477 | } | 492 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc)); |
478 | else | 493 | desc = NULL; |
479 | { | ||
480 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(desc)); | ||
481 | desc = NULL; | ||
482 | } | ||
483 | } | 494 | } |
495 | } | ||
484 | #endif | 496 | #endif |
485 | 497 | ||
486 | if ((0 == port) && (NULL == unixpath)) | 498 | if ((0 == port) && (NULL == unixpath)) |
499 | { | ||
500 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (cfg, | ||
501 | service_name, | ||
502 | "START_ON_DEMAND")) | ||
503 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
504 | _ ( | ||
505 | "Have neither PORT nor UNIXPATH for service `%s', but one is required\n"), | ||
506 | service_name); | ||
507 | GNUNET_free_non_null (hostname); | ||
508 | return GNUNET_SYSERR; | ||
509 | } | ||
510 | if (0 == port) | ||
511 | { | ||
512 | saddrs = GNUNET_new_array (2, struct sockaddr *); | ||
513 | saddrlens = GNUNET_new_array (2, socklen_t); | ||
514 | add_unixpath (saddrs, saddrlens, unixpath, abstract); | ||
515 | GNUNET_free_non_null (unixpath); | ||
516 | GNUNET_free_non_null (hostname); | ||
517 | *addrs = saddrs; | ||
518 | *addr_lens = saddrlens; | ||
519 | return 1; | ||
520 | } | ||
521 | |||
522 | if (NULL != hostname) | ||
523 | { | ||
524 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
525 | "Resolving `%s' since that is where `%s' will bind to.\n", | ||
526 | hostname, | ||
527 | service_name); | ||
528 | memset (&hints, 0, sizeof(struct addrinfo)); | ||
529 | if (disablev6) | ||
530 | hints.ai_family = AF_INET; | ||
531 | hints.ai_protocol = IPPROTO_TCP; | ||
532 | if ((0 != (ret = getaddrinfo (hostname, NULL, &hints, &res))) || | ||
533 | (NULL == res)) | ||
487 | { | 534 | { |
488 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, | 535 | LOG (GNUNET_ERROR_TYPE_ERROR, |
489 | service_name, | 536 | _ ("Failed to resolve `%s': %s\n"), |
490 | "START_ON_DEMAND")) | 537 | hostname, |
491 | LOG(GNUNET_ERROR_TYPE_ERROR, | 538 | gai_strerror (ret)); |
492 | _( | 539 | GNUNET_free (hostname); |
493 | "Have neither PORT nor UNIXPATH for service `%s', but one is required\n"), | 540 | GNUNET_free_non_null (unixpath); |
494 | service_name); | ||
495 | GNUNET_free_non_null(hostname); | ||
496 | return GNUNET_SYSERR; | 541 | return GNUNET_SYSERR; |
497 | } | 542 | } |
498 | if (0 == port) | 543 | next = res; |
544 | i = 0; | ||
545 | while (NULL != (pos = next)) | ||
499 | { | 546 | { |
500 | saddrs = GNUNET_new_array(2, struct sockaddr *); | 547 | next = pos->ai_next; |
501 | saddrlens = GNUNET_new_array(2, socklen_t); | 548 | if ((disablev6) && (pos->ai_family == AF_INET6)) |
502 | add_unixpath(saddrs, saddrlens, unixpath, abstract); | 549 | continue; |
503 | GNUNET_free_non_null(unixpath); | 550 | i++; |
504 | GNUNET_free_non_null(hostname); | ||
505 | *addrs = saddrs; | ||
506 | *addr_lens = saddrlens; | ||
507 | return 1; | ||
508 | } | 551 | } |
509 | 552 | if (0 == i) | |
510 | if (NULL != hostname) | ||
511 | { | 553 | { |
512 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 554 | LOG (GNUNET_ERROR_TYPE_ERROR, |
513 | "Resolving `%s' since that is where `%s' will bind to.\n", | 555 | _ ("Failed to find %saddress for `%s'.\n"), |
514 | hostname, | 556 | disablev6 ? "IPv4 " : "", |
515 | service_name); | 557 | hostname); |
516 | memset(&hints, 0, sizeof(struct addrinfo)); | 558 | freeaddrinfo (res); |
517 | if (disablev6) | 559 | GNUNET_free (hostname); |
518 | hints.ai_family = AF_INET; | 560 | GNUNET_free_non_null (unixpath); |
519 | hints.ai_protocol = IPPROTO_TCP; | 561 | return GNUNET_SYSERR; |
520 | if ((0 != (ret = getaddrinfo(hostname, NULL, &hints, &res))) || | 562 | } |
521 | (NULL == res)) | 563 | resi = i; |
522 | { | 564 | if (NULL != unixpath) |
523 | LOG(GNUNET_ERROR_TYPE_ERROR, | 565 | resi++; |
524 | _("Failed to resolve `%s': %s\n"), | 566 | saddrs = GNUNET_new_array (resi + 1, struct sockaddr *); |
525 | hostname, | 567 | saddrlens = GNUNET_new_array (resi + 1, socklen_t); |
526 | gai_strerror(ret)); | 568 | i = 0; |
527 | GNUNET_free(hostname); | 569 | if (NULL != unixpath) |
528 | GNUNET_free_non_null(unixpath); | 570 | { |
529 | return GNUNET_SYSERR; | 571 | add_unixpath (saddrs, saddrlens, unixpath, abstract); |
530 | } | 572 | i++; |
531 | next = res; | 573 | } |
532 | i = 0; | 574 | next = res; |
533 | while (NULL != (pos = next)) | 575 | while (NULL != (pos = next)) |
534 | { | 576 | { |
535 | next = pos->ai_next; | 577 | next = pos->ai_next; |
536 | if ((disablev6) && (pos->ai_family == AF_INET6)) | 578 | if ((disablev6) && (AF_INET6 == pos->ai_family)) |
537 | continue; | 579 | continue; |
538 | i++; | 580 | if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol)) |
539 | } | 581 | continue; /* not TCP */ |
540 | if (0 == i) | 582 | if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype)) |
541 | { | 583 | continue; /* huh? */ |
542 | LOG(GNUNET_ERROR_TYPE_ERROR, | 584 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
543 | _("Failed to find %saddress for `%s'.\n"), | 585 | "Service `%s' will bind to `%s'\n", |
544 | disablev6 ? "IPv4 " : "", | 586 | service_name, |
545 | hostname); | 587 | GNUNET_a2s (pos->ai_addr, pos->ai_addrlen)); |
546 | freeaddrinfo(res); | 588 | if (AF_INET == pos->ai_family) |
547 | GNUNET_free(hostname); | 589 | { |
548 | GNUNET_free_non_null(unixpath); | 590 | GNUNET_assert (sizeof(struct sockaddr_in) == pos->ai_addrlen); |
549 | return GNUNET_SYSERR; | 591 | saddrlens[i] = pos->ai_addrlen; |
550 | } | 592 | saddrs[i] = GNUNET_malloc (saddrlens[i]); |
551 | resi = i; | 593 | GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); |
594 | ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); | ||
595 | } | ||
596 | else | ||
597 | { | ||
598 | GNUNET_assert (AF_INET6 == pos->ai_family); | ||
599 | GNUNET_assert (sizeof(struct sockaddr_in6) == pos->ai_addrlen); | ||
600 | saddrlens[i] = pos->ai_addrlen; | ||
601 | saddrs[i] = GNUNET_malloc (saddrlens[i]); | ||
602 | GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); | ||
603 | ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port); | ||
604 | } | ||
605 | i++; | ||
606 | } | ||
607 | GNUNET_free (hostname); | ||
608 | freeaddrinfo (res); | ||
609 | resi = i; | ||
610 | } | ||
611 | else | ||
612 | { | ||
613 | /* will bind against everything, just set port */ | ||
614 | if (disablev6) | ||
615 | { | ||
616 | /* V4-only */ | ||
617 | resi = 1; | ||
552 | if (NULL != unixpath) | 618 | if (NULL != unixpath) |
553 | resi++; | 619 | resi++; |
554 | saddrs = GNUNET_new_array(resi + 1, struct sockaddr *); | ||
555 | saddrlens = GNUNET_new_array(resi + 1, socklen_t); | ||
556 | i = 0; | 620 | i = 0; |
621 | saddrs = GNUNET_new_array (resi + 1, struct sockaddr *); | ||
622 | saddrlens = GNUNET_new_array (resi + 1, socklen_t); | ||
557 | if (NULL != unixpath) | 623 | if (NULL != unixpath) |
558 | { | 624 | { |
559 | add_unixpath(saddrs, saddrlens, unixpath, abstract); | 625 | add_unixpath (saddrs, saddrlens, unixpath, abstract); |
560 | i++; | 626 | i++; |
561 | } | 627 | } |
562 | next = res; | 628 | saddrlens[i] = sizeof(struct sockaddr_in); |
563 | while (NULL != (pos = next)) | 629 | saddrs[i] = GNUNET_malloc (saddrlens[i]); |
564 | { | ||
565 | next = pos->ai_next; | ||
566 | if ((disablev6) && (AF_INET6 == pos->ai_family)) | ||
567 | continue; | ||
568 | if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol)) | ||
569 | continue; /* not TCP */ | ||
570 | if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype)) | ||
571 | continue; /* huh? */ | ||
572 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
573 | "Service `%s' will bind to `%s'\n", | ||
574 | service_name, | ||
575 | GNUNET_a2s(pos->ai_addr, pos->ai_addrlen)); | ||
576 | if (AF_INET == pos->ai_family) | ||
577 | { | ||
578 | GNUNET_assert(sizeof(struct sockaddr_in) == pos->ai_addrlen); | ||
579 | saddrlens[i] = pos->ai_addrlen; | ||
580 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | ||
581 | GNUNET_memcpy(saddrs[i], pos->ai_addr, saddrlens[i]); | ||
582 | ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port); | ||
583 | } | ||
584 | else | ||
585 | { | ||
586 | GNUNET_assert(AF_INET6 == pos->ai_family); | ||
587 | GNUNET_assert(sizeof(struct sockaddr_in6) == pos->ai_addrlen); | ||
588 | saddrlens[i] = pos->ai_addrlen; | ||
589 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | ||
590 | GNUNET_memcpy(saddrs[i], pos->ai_addr, saddrlens[i]); | ||
591 | ((struct sockaddr_in6 *)saddrs[i])->sin6_port = htons(port); | ||
592 | } | ||
593 | i++; | ||
594 | } | ||
595 | GNUNET_free(hostname); | ||
596 | freeaddrinfo(res); | ||
597 | resi = i; | ||
598 | } | ||
599 | else | ||
600 | { | ||
601 | /* will bind against everything, just set port */ | ||
602 | if (disablev6) | ||
603 | { | ||
604 | /* V4-only */ | ||
605 | resi = 1; | ||
606 | if (NULL != unixpath) | ||
607 | resi++; | ||
608 | i = 0; | ||
609 | saddrs = GNUNET_new_array(resi + 1, struct sockaddr *); | ||
610 | saddrlens = GNUNET_new_array(resi + 1, socklen_t); | ||
611 | if (NULL != unixpath) | ||
612 | { | ||
613 | add_unixpath(saddrs, saddrlens, unixpath, abstract); | ||
614 | i++; | ||
615 | } | ||
616 | saddrlens[i] = sizeof(struct sockaddr_in); | ||
617 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | ||
618 | #if HAVE_SOCKADDR_IN_SIN_LEN | 630 | #if HAVE_SOCKADDR_IN_SIN_LEN |
619 | ((struct sockaddr_in *)saddrs[i])->sin_len = saddrlens[i]; | 631 | ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[i]; |
620 | #endif | 632 | #endif |
621 | ((struct sockaddr_in *)saddrs[i])->sin_family = AF_INET; | 633 | ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET; |
622 | ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port); | 634 | ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); |
623 | } | 635 | } |
624 | else | 636 | else |
625 | { | 637 | { |
626 | /* dual stack */ | 638 | /* dual stack */ |
627 | resi = 2; | 639 | resi = 2; |
628 | if (NULL != unixpath) | 640 | if (NULL != unixpath) |
629 | resi++; | 641 | resi++; |
630 | saddrs = GNUNET_new_array(resi + 1, struct sockaddr *); | 642 | saddrs = GNUNET_new_array (resi + 1, struct sockaddr *); |
631 | saddrlens = GNUNET_new_array(resi + 1, socklen_t); | 643 | saddrlens = GNUNET_new_array (resi + 1, socklen_t); |
632 | i = 0; | 644 | i = 0; |
633 | if (NULL != unixpath) | 645 | if (NULL != unixpath) |
634 | { | 646 | { |
635 | add_unixpath(saddrs, saddrlens, unixpath, abstract); | 647 | add_unixpath (saddrs, saddrlens, unixpath, abstract); |
636 | i++; | 648 | i++; |
637 | } | 649 | } |
638 | saddrlens[i] = sizeof(struct sockaddr_in6); | 650 | saddrlens[i] = sizeof(struct sockaddr_in6); |
639 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | 651 | saddrs[i] = GNUNET_malloc (saddrlens[i]); |
640 | #if HAVE_SOCKADDR_IN_SIN_LEN | 652 | #if HAVE_SOCKADDR_IN_SIN_LEN |
641 | ((struct sockaddr_in6 *)saddrs[i])->sin6_len = saddrlens[0]; | 653 | ((struct sockaddr_in6 *) saddrs[i])->sin6_len = saddrlens[0]; |
642 | #endif | 654 | #endif |
643 | ((struct sockaddr_in6 *)saddrs[i])->sin6_family = AF_INET6; | 655 | ((struct sockaddr_in6 *) saddrs[i])->sin6_family = AF_INET6; |
644 | ((struct sockaddr_in6 *)saddrs[i])->sin6_port = htons(port); | 656 | ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port); |
645 | i++; | 657 | i++; |
646 | saddrlens[i] = sizeof(struct sockaddr_in); | 658 | saddrlens[i] = sizeof(struct sockaddr_in); |
647 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | 659 | saddrs[i] = GNUNET_malloc (saddrlens[i]); |
648 | #if HAVE_SOCKADDR_IN_SIN_LEN | 660 | #if HAVE_SOCKADDR_IN_SIN_LEN |
649 | ((struct sockaddr_in *)saddrs[i])->sin_len = saddrlens[1]; | 661 | ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[1]; |
650 | #endif | 662 | #endif |
651 | ((struct sockaddr_in *)saddrs[i])->sin_family = AF_INET; | 663 | ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET; |
652 | ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port); | 664 | ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); |
653 | } | ||
654 | } | 665 | } |
655 | GNUNET_free_non_null(unixpath); | 666 | } |
667 | GNUNET_free_non_null (unixpath); | ||
656 | *addrs = saddrs; | 668 | *addrs = saddrs; |
657 | *addr_lens = saddrlens; | 669 | *addr_lens = saddrlens; |
658 | return resi; | 670 | return resi; |
@@ -670,19 +682,19 @@ get_server_addresses(const char *service_name, | |||
670 | * @return NULL if it was not found | 682 | * @return NULL if it was not found |
671 | */ | 683 | */ |
672 | static void | 684 | static void |
673 | signal_result(struct GNUNET_SERVICE_Client *client, | 685 | signal_result (struct GNUNET_SERVICE_Client *client, |
674 | const char *name, | 686 | const char *name, |
675 | uint64_t request_id, | 687 | uint64_t request_id, |
676 | enum GNUNET_ARM_Result result) | 688 | enum GNUNET_ARM_Result result) |
677 | { | 689 | { |
678 | struct GNUNET_MQ_Envelope *env; | 690 | struct GNUNET_MQ_Envelope *env; |
679 | struct GNUNET_ARM_ResultMessage *msg; | 691 | struct GNUNET_ARM_ResultMessage *msg; |
680 | 692 | ||
681 | (void)name; | 693 | (void) name; |
682 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_ARM_RESULT); | 694 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_ARM_RESULT); |
683 | msg->result = htonl(result); | 695 | msg->result = htonl (result); |
684 | msg->arm_msg.request_id = GNUNET_htonll(request_id); | 696 | msg->arm_msg.request_id = GNUNET_htonll (request_id); |
685 | GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client), env); | 697 | GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env); |
686 | } | 698 | } |
687 | 699 | ||
688 | 700 | ||
@@ -695,34 +707,34 @@ signal_result(struct GNUNET_SERVICE_Client *client, | |||
695 | * otherwise, send to all clients in the notifier | 707 | * otherwise, send to all clients in the notifier |
696 | */ | 708 | */ |
697 | static void | 709 | static void |
698 | broadcast_status(const char *name, | 710 | broadcast_status (const char *name, |
699 | enum GNUNET_ARM_ServiceStatus status, | 711 | enum GNUNET_ARM_ServiceMonitorStatus status, |
700 | struct GNUNET_SERVICE_Client *unicast) | 712 | struct GNUNET_SERVICE_Client *unicast) |
701 | { | 713 | { |
702 | struct GNUNET_MQ_Envelope *env; | 714 | struct GNUNET_MQ_Envelope *env; |
703 | struct GNUNET_ARM_StatusMessage *msg; | 715 | struct GNUNET_ARM_StatusMessage *msg; |
704 | size_t namelen; | 716 | size_t namelen; |
705 | 717 | ||
706 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 718 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
707 | "Sending status %u of service `%s' to client\n", | 719 | "Sending status %u of service `%s' to client\n", |
708 | (unsigned int)status, | 720 | (unsigned int) status, |
709 | name); | 721 | name); |
710 | namelen = strlen(name) + 1; | 722 | namelen = strlen (name) + 1; |
711 | env = GNUNET_MQ_msg_extra(msg, namelen, GNUNET_MESSAGE_TYPE_ARM_STATUS); | 723 | env = GNUNET_MQ_msg_extra (msg, namelen, GNUNET_MESSAGE_TYPE_ARM_STATUS); |
712 | msg->status = htonl((uint32_t)(status)); | 724 | msg->status = htonl ((uint32_t) (status)); |
713 | GNUNET_memcpy((char *)&msg[1], name, namelen); | 725 | GNUNET_memcpy ((char *) &msg[1], name, namelen); |
714 | if (NULL == unicast) | 726 | if (NULL == unicast) |
715 | { | 727 | { |
716 | if (NULL != notifier) | 728 | if (NULL != notifier) |
717 | GNUNET_notification_context_broadcast(notifier, | 729 | GNUNET_notification_context_broadcast (notifier, |
718 | &msg->header, | 730 | &msg->header, |
719 | GNUNET_YES); | 731 | GNUNET_YES); |
720 | GNUNET_MQ_discard(env); | 732 | GNUNET_MQ_discard (env); |
721 | } | 733 | } |
722 | else | 734 | else |
723 | { | 735 | { |
724 | GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(unicast), env); | 736 | GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (unicast), env); |
725 | } | 737 | } |
726 | } | 738 | } |
727 | 739 | ||
728 | 740 | ||
@@ -735,9 +747,9 @@ broadcast_status(const char *name, | |||
735 | * being started. 0 if starting was not requested. | 747 | * being started. 0 if starting was not requested. |
736 | */ | 748 | */ |
737 | static void | 749 | static void |
738 | start_process(struct ServiceList *sl, | 750 | start_process (struct ServiceList *sl, |
739 | struct GNUNET_SERVICE_Client *client, | 751 | struct GNUNET_SERVICE_Client *client, |
740 | uint64_t request_id) | 752 | uint64_t request_id) |
741 | { | 753 | { |
742 | char *loprefix; | 754 | char *loprefix; |
743 | char *options; | 755 | char *options; |
@@ -753,191 +765,192 @@ start_process(struct ServiceList *sl, | |||
753 | lsocks = NULL; | 765 | lsocks = NULL; |
754 | ls = 0; | 766 | ls = 0; |
755 | for (sli = sl->listen_head; NULL != sli; sli = sli->next) | 767 | for (sli = sl->listen_head; NULL != sli; sli = sli->next) |
768 | { | ||
769 | GNUNET_array_append (lsocks, | ||
770 | ls, | ||
771 | GNUNET_NETWORK_get_fd (sli->listen_socket)); | ||
772 | if (NULL != sli->accept_task) | ||
756 | { | 773 | { |
757 | GNUNET_array_append(lsocks, | 774 | GNUNET_SCHEDULER_cancel (sli->accept_task); |
758 | ls, | 775 | sli->accept_task = NULL; |
759 | GNUNET_NETWORK_get_fd(sli->listen_socket)); | ||
760 | if (NULL != sli->accept_task) | ||
761 | { | ||
762 | GNUNET_SCHEDULER_cancel(sli->accept_task); | ||
763 | sli->accept_task = NULL; | ||
764 | } | ||
765 | } | 776 | } |
777 | } | ||
766 | 778 | ||
767 | GNUNET_array_append(lsocks, ls, -1); | 779 | GNUNET_array_append (lsocks, ls, -1); |
768 | 780 | ||
769 | /* obtain configuration */ | 781 | /* obtain configuration */ |
770 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, | 782 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, |
771 | sl->name, | 783 | sl->name, |
772 | "PREFIX", | 784 | "PREFIX", |
773 | &loprefix)) | 785 | &loprefix)) |
774 | loprefix = GNUNET_strdup(prefix_command); | 786 | loprefix = GNUNET_strdup (prefix_command); |
775 | else | 787 | else |
776 | loprefix = GNUNET_CONFIGURATION_expand_dollar(cfg, loprefix); | 788 | loprefix = GNUNET_CONFIGURATION_expand_dollar (cfg, loprefix); |
777 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, | 789 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, |
778 | sl->name, | 790 | sl->name, |
779 | "OPTIONS", | 791 | "OPTIONS", |
780 | &options)) | 792 | &options)) |
781 | options = NULL; | 793 | options = NULL; |
782 | else | 794 | else |
783 | options = GNUNET_CONFIGURATION_expand_dollar(cfg, options); | 795 | options = GNUNET_CONFIGURATION_expand_dollar (cfg, options); |
784 | { | 796 | { |
785 | char *new_options; | 797 | char *new_options; |
786 | char *optpos; | 798 | char *optpos; |
787 | char *fin_options; | 799 | char *fin_options; |
788 | 800 | ||
789 | fin_options = GNUNET_strdup(final_option); | 801 | fin_options = GNUNET_strdup (final_option); |
790 | /* replace '{}' with service name */ | 802 | /* replace '{}' with service name */ |
791 | while (NULL != (optpos = strstr(fin_options, "{}"))) | 803 | while (NULL != (optpos = strstr (fin_options, "{}"))) |
792 | { | 804 | { |
793 | /* terminate string at opening parenthesis */ | 805 | /* terminate string at opening parenthesis */ |
794 | *optpos = 0; | 806 | *optpos = 0; |
795 | GNUNET_asprintf(&new_options, | 807 | GNUNET_asprintf (&new_options, |
796 | "%s%s%s", | 808 | "%s%s%s", |
797 | fin_options, | 809 | fin_options, |
798 | sl->name, | 810 | sl->name, |
799 | optpos + 2); | 811 | optpos + 2); |
800 | GNUNET_free(fin_options); | 812 | GNUNET_free (fin_options); |
801 | fin_options = new_options; | 813 | fin_options = new_options; |
802 | } | 814 | } |
803 | if (NULL != options) | 815 | if (NULL != options) |
804 | { | 816 | { |
805 | /* combine "fin_options" with "options" */ | 817 | /* combine "fin_options" with "options" */ |
806 | optpos = options; | 818 | optpos = options; |
807 | GNUNET_asprintf(&options, "%s %s", fin_options, optpos); | 819 | GNUNET_asprintf (&options, "%s %s", fin_options, optpos); |
808 | GNUNET_free(fin_options); | 820 | GNUNET_free (fin_options); |
809 | GNUNET_free(optpos); | 821 | GNUNET_free (optpos); |
810 | } | 822 | } |
811 | else | 823 | else |
812 | { | 824 | { |
813 | /* only have "fin_options", use that */ | 825 | /* only have "fin_options", use that */ |
814 | options = fin_options; | 826 | options = fin_options; |
815 | } | 827 | } |
816 | } | 828 | } |
817 | options = GNUNET_CONFIGURATION_expand_dollar(cfg, options); | 829 | options = GNUNET_CONFIGURATION_expand_dollar (cfg, options); |
818 | use_debug = GNUNET_CONFIGURATION_get_value_yesno(cfg, sl->name, "DEBUG"); | 830 | use_debug = GNUNET_CONFIGURATION_get_value_yesno (cfg, sl->name, "DEBUG"); |
819 | { | 831 | { |
820 | const char *service_type = NULL; | 832 | const char *service_type = NULL; |
821 | const char *choices[] = { "GNUNET", "SIMPLE", NULL }; | 833 | const char *choices[] = { "GNUNET", "SIMPLE", NULL }; |
822 | 834 | ||
823 | is_simple_service = GNUNET_NO; | 835 | is_simple_service = GNUNET_NO; |
824 | if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_choice(cfg, | 836 | if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_choice (cfg, |
825 | sl->name, | 837 | sl->name, |
826 | "TYPE", | 838 | "TYPE", |
827 | choices, | 839 | choices, |
828 | &service_type)) && | 840 | &service_type)) && |
829 | (0 == strcasecmp(service_type, "SIMPLE"))) | 841 | (0 == strcasecmp (service_type, "SIMPLE"))) |
830 | is_simple_service = GNUNET_YES; | 842 | is_simple_service = GNUNET_YES; |
831 | } | 843 | } |
832 | 844 | ||
833 | GNUNET_assert(NULL == sl->proc); | 845 | GNUNET_assert (NULL == sl->proc); |
834 | if (GNUNET_YES == is_simple_service) | 846 | if (GNUNET_YES == is_simple_service) |
835 | { | 847 | { |
836 | /* A simple service will receive no GNUnet specific | 848 | /* A simple service will receive no GNUnet specific |
837 | command line options. */ | 849 | command line options. */ |
838 | binary = GNUNET_strdup(sl->binary); | 850 | binary = GNUNET_strdup (sl->binary); |
839 | binary = GNUNET_CONFIGURATION_expand_dollar(cfg, binary); | 851 | binary = GNUNET_CONFIGURATION_expand_dollar (cfg, binary); |
840 | GNUNET_asprintf("edbinary, "\"%s\"", sl->binary); | 852 | GNUNET_asprintf ("edbinary, "\"%s\"", sl->binary); |
841 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 853 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
842 | "Starting simple service `%s' using binary `%s'\n", | 854 | "Starting simple service `%s' using binary `%s'\n", |
843 | sl->name, | 855 | sl->name, |
844 | sl->binary); | 856 | sl->binary); |
845 | /* FIXME: dollar expansion should only be done outside | 857 | /* FIXME: dollar expansion should only be done outside |
846 | * of ''-quoted strings, escaping should be considered. */ | 858 | * of ''-quoted strings, escaping should be considered. */ |
847 | if (NULL != options) | 859 | if (NULL != options) |
848 | options = GNUNET_CONFIGURATION_expand_dollar(cfg, options); | 860 | options = GNUNET_CONFIGURATION_expand_dollar (cfg, options); |
849 | sl->proc = GNUNET_OS_start_process_s(sl->pipe_control, | 861 | sl->proc = GNUNET_OS_start_process_s (sl->pipe_control, |
850 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 862 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, |
851 | lsocks, | 863 | lsocks, |
852 | loprefix, | 864 | loprefix, |
853 | quotedbinary, | 865 | quotedbinary, |
854 | options, | 866 | options, |
855 | NULL); | 867 | NULL); |
856 | } | 868 | } |
857 | else | 869 | else |
870 | { | ||
871 | /* actually start process */ | ||
872 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
873 | "Starting service `%s' using binary `%s' and configuration `%s'\n", | ||
874 | sl->name, | ||
875 | sl->binary, | ||
876 | sl->config); | ||
877 | binary = GNUNET_OS_get_libexec_binary_path (sl->binary); | ||
878 | GNUNET_asprintf ("edbinary, "\"%s\"", binary); | ||
879 | |||
880 | if (GNUNET_YES == use_debug) | ||
858 | { | 881 | { |
859 | /* actually start process */ | 882 | if (NULL == sl->config) |
860 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 883 | sl->proc = GNUNET_OS_start_process_s (sl->pipe_control, |
861 | "Starting service `%s' using binary `%s' and configuration `%s'\n", | 884 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, |
862 | sl->name, | 885 | lsocks, |
863 | sl->binary, | 886 | loprefix, |
864 | sl->config); | 887 | quotedbinary, |
865 | binary = GNUNET_OS_get_libexec_binary_path(sl->binary); | 888 | "-L", |
866 | GNUNET_asprintf("edbinary, "\"%s\"", binary); | 889 | "DEBUG", |
867 | 890 | options, | |
868 | if (GNUNET_YES == use_debug) | 891 | NULL); |
869 | { | ||
870 | if (NULL == sl->config) | ||
871 | sl->proc = GNUNET_OS_start_process_s(sl->pipe_control, | ||
872 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | ||
873 | lsocks, | ||
874 | loprefix, | ||
875 | quotedbinary, | ||
876 | "-L", | ||
877 | "DEBUG", | ||
878 | options, | ||
879 | NULL); | ||
880 | else | ||
881 | sl->proc = GNUNET_OS_start_process_s(sl->pipe_control, | ||
882 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | ||
883 | lsocks, | ||
884 | loprefix, | ||
885 | quotedbinary, | ||
886 | "-c", | ||
887 | sl->config, | ||
888 | "-L", | ||
889 | "DEBUG", | ||
890 | options, | ||
891 | NULL); | ||
892 | } | ||
893 | else | 892 | else |
894 | { | 893 | sl->proc = GNUNET_OS_start_process_s (sl->pipe_control, |
895 | if (NULL == sl->config) | 894 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, |
896 | sl->proc = GNUNET_OS_start_process_s(sl->pipe_control, | 895 | lsocks, |
897 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 896 | loprefix, |
898 | lsocks, | 897 | quotedbinary, |
899 | loprefix, | 898 | "-c", |
900 | quotedbinary, | 899 | sl->config, |
901 | options, | 900 | "-L", |
902 | NULL); | 901 | "DEBUG", |
903 | else | 902 | options, |
904 | sl->proc = GNUNET_OS_start_process_s(sl->pipe_control, | 903 | NULL); |
905 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | ||
906 | lsocks, | ||
907 | loprefix, | ||
908 | quotedbinary, | ||
909 | "-c", | ||
910 | sl->config, | ||
911 | options, | ||
912 | NULL); | ||
913 | } | ||
914 | } | 904 | } |
915 | GNUNET_free(binary); | 905 | else |
916 | GNUNET_free(quotedbinary); | ||
917 | if (NULL == sl->proc) | ||
918 | { | 906 | { |
919 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 907 | if (NULL == sl->config) |
920 | _("Failed to start service `%s'\n"), | 908 | sl->proc = GNUNET_OS_start_process_s (sl->pipe_control, |
921 | sl->name); | 909 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, |
922 | if (client) | 910 | lsocks, |
923 | signal_result(client, | 911 | loprefix, |
924 | sl->name, | 912 | quotedbinary, |
925 | request_id, | 913 | options, |
926 | GNUNET_ARM_RESULT_START_FAILED); | 914 | NULL); |
915 | else | ||
916 | sl->proc = GNUNET_OS_start_process_s (sl->pipe_control, | ||
917 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | ||
918 | lsocks, | ||
919 | loprefix, | ||
920 | quotedbinary, | ||
921 | "-c", | ||
922 | sl->config, | ||
923 | options, | ||
924 | NULL); | ||
927 | } | 925 | } |
926 | } | ||
927 | GNUNET_free (binary); | ||
928 | GNUNET_free (quotedbinary); | ||
929 | sl->last_started_at = GNUNET_TIME_absolute_get (); | ||
930 | if (NULL == sl->proc) | ||
931 | { | ||
932 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
933 | _ ("Failed to start service `%s'\n"), | ||
934 | sl->name); | ||
935 | if (client) | ||
936 | signal_result (client, | ||
937 | sl->name, | ||
938 | request_id, | ||
939 | GNUNET_ARM_RESULT_START_FAILED); | ||
940 | } | ||
928 | else | 941 | else |
929 | { | 942 | { |
930 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 943 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
931 | _("Starting service `%s'\n"), | 944 | _ ("Starting service `%s'\n"), |
932 | sl->name); | 945 | sl->name); |
933 | broadcast_status(sl->name, GNUNET_ARM_SERVICE_STARTING, NULL); | 946 | broadcast_status (sl->name, GNUNET_ARM_SERVICE_STARTING, NULL); |
934 | if (client) | 947 | if (client) |
935 | signal_result(client, sl->name, request_id, GNUNET_ARM_RESULT_STARTING); | 948 | signal_result (client, sl->name, request_id, GNUNET_ARM_RESULT_STARTING); |
936 | } | 949 | } |
937 | /* clean up */ | 950 | /* clean up */ |
938 | GNUNET_free(loprefix); | 951 | GNUNET_free (loprefix); |
939 | GNUNET_free(options); | 952 | GNUNET_free (options); |
940 | GNUNET_array_grow(lsocks, ls, 0); | 953 | GNUNET_array_grow (lsocks, ls, 0); |
941 | } | 954 | } |
942 | 955 | ||
943 | 956 | ||
@@ -949,17 +962,17 @@ start_process(struct ServiceList *sl, | |||
949 | * @return NULL if it was not found | 962 | * @return NULL if it was not found |
950 | */ | 963 | */ |
951 | static struct ServiceList * | 964 | static struct ServiceList * |
952 | find_service(const char *name) | 965 | find_service (const char *name) |
953 | { | 966 | { |
954 | struct ServiceList *sl; | 967 | struct ServiceList *sl; |
955 | 968 | ||
956 | sl = running_head; | 969 | sl = running_head; |
957 | while (sl != NULL) | 970 | while (sl != NULL) |
958 | { | 971 | { |
959 | if (0 == strcasecmp(sl->name, name)) | 972 | if (0 == strcasecmp (sl->name, name)) |
960 | return sl; | 973 | return sl; |
961 | sl = sl->next; | 974 | sl = sl->next; |
962 | } | 975 | } |
963 | return NULL; | 976 | return NULL; |
964 | } | 977 | } |
965 | 978 | ||
@@ -971,14 +984,14 @@ find_service(const char *name) | |||
971 | * @param cls callback data, `struct ServiceListeningInfo` describing a listen socket | 984 | * @param cls callback data, `struct ServiceListeningInfo` describing a listen socket |
972 | */ | 985 | */ |
973 | static void | 986 | static void |
974 | accept_connection(void *cls) | 987 | accept_connection (void *cls) |
975 | { | 988 | { |
976 | struct ServiceListeningInfo *sli = cls; | 989 | struct ServiceListeningInfo *sli = cls; |
977 | struct ServiceList *sl = sli->sl; | 990 | struct ServiceList *sl = sli->sl; |
978 | 991 | ||
979 | sli->accept_task = NULL; | 992 | sli->accept_task = NULL; |
980 | GNUNET_assert(GNUNET_NO == in_shutdown); | 993 | GNUNET_assert (GNUNET_NO == in_shutdown); |
981 | start_process(sl, NULL, 0); | 994 | start_process (sl, NULL, 0); |
982 | } | 995 | } |
983 | 996 | ||
984 | 997 | ||
@@ -991,9 +1004,9 @@ accept_connection(void *cls) | |||
991 | * @param sl service entry for the service in question | 1004 | * @param sl service entry for the service in question |
992 | */ | 1005 | */ |
993 | static void | 1006 | static void |
994 | create_listen_socket(struct sockaddr *sa, | 1007 | create_listen_socket (struct sockaddr *sa, |
995 | socklen_t addr_len, | 1008 | socklen_t addr_len, |
996 | struct ServiceList *sl) | 1009 | struct ServiceList *sl) |
997 | { | 1010 | { |
998 | static int on = 1; | 1011 | static int on = 1; |
999 | struct GNUNET_NETWORK_Handle *sock; | 1012 | struct GNUNET_NETWORK_Handle *sock; |
@@ -1003,107 +1016,107 @@ create_listen_socket(struct sockaddr *sa, | |||
1003 | int match_gid; | 1016 | int match_gid; |
1004 | 1017 | ||
1005 | switch (sa->sa_family) | 1018 | switch (sa->sa_family) |
1006 | { | 1019 | { |
1007 | case AF_INET: | 1020 | case AF_INET: |
1008 | sock = GNUNET_NETWORK_socket_create(PF_INET, SOCK_STREAM, 0); | 1021 | sock = GNUNET_NETWORK_socket_create (PF_INET, SOCK_STREAM, 0); |
1009 | break; | 1022 | break; |
1010 | 1023 | ||
1011 | case AF_INET6: | 1024 | case AF_INET6: |
1012 | sock = GNUNET_NETWORK_socket_create(PF_INET6, SOCK_STREAM, 0); | 1025 | sock = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0); |
1013 | break; | 1026 | break; |
1014 | 1027 | ||
1015 | case AF_UNIX: | 1028 | case AF_UNIX: |
1016 | if (0 == strcmp(GNUNET_a2s(sa, addr_len), | 1029 | if (0 == strcmp (GNUNET_a2s (sa, addr_len), |
1017 | "@")) /* Do not bind to blank UNIX path! */ | 1030 | "@")) /* Do not bind to blank UNIX path! */ |
1018 | return; | ||
1019 | sock = GNUNET_NETWORK_socket_create(PF_UNIX, SOCK_STREAM, 0); | ||
1020 | break; | ||
1021 | |||
1022 | default: | ||
1023 | GNUNET_break(0); | ||
1024 | sock = NULL; | ||
1025 | errno = EAFNOSUPPORT; | ||
1026 | break; | ||
1027 | } | ||
1028 | if (NULL == sock) | ||
1029 | { | ||
1030 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | ||
1031 | _("Unable to create socket for service `%s': %s\n"), | ||
1032 | sl->name, | ||
1033 | strerror(errno)); | ||
1034 | GNUNET_free(sa); | ||
1035 | return; | 1031 | return; |
1036 | } | 1032 | sock = GNUNET_NETWORK_socket_create (PF_UNIX, SOCK_STREAM, 0); |
1037 | if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt(sock, | 1033 | break; |
1038 | SOL_SOCKET, | 1034 | |
1039 | SO_REUSEADDR, | 1035 | default: |
1040 | &on, | 1036 | GNUNET_break (0); |
1041 | sizeof(on))) | 1037 | sock = NULL; |
1042 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | 1038 | errno = EAFNOSUPPORT; |
1043 | "setsockopt"); | 1039 | break; |
1040 | } | ||
1041 | if (NULL == sock) | ||
1042 | { | ||
1043 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
1044 | _ ("Unable to create socket for service `%s': %s\n"), | ||
1045 | sl->name, | ||
1046 | strerror (errno)); | ||
1047 | GNUNET_free (sa); | ||
1048 | return; | ||
1049 | } | ||
1050 | if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (sock, | ||
1051 | SOL_SOCKET, | ||
1052 | SO_REUSEADDR, | ||
1053 | &on, | ||
1054 | sizeof(on))) | ||
1055 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | ||
1056 | "setsockopt"); | ||
1044 | #ifdef IPV6_V6ONLY | 1057 | #ifdef IPV6_V6ONLY |
1045 | if ((sa->sa_family == AF_INET6) && | 1058 | if ((sa->sa_family == AF_INET6) && |
1046 | (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt(sock, | 1059 | (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (sock, |
1047 | IPPROTO_IPV6, | 1060 | IPPROTO_IPV6, |
1048 | IPV6_V6ONLY, | 1061 | IPV6_V6ONLY, |
1049 | &on, | 1062 | &on, |
1050 | sizeof(on)))) | 1063 | sizeof(on)))) |
1051 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | 1064 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, |
1052 | "setsockopt"); | 1065 | "setsockopt"); |
1053 | #endif | 1066 | #endif |
1054 | if (AF_UNIX == sa->sa_family) | 1067 | if (AF_UNIX == sa->sa_family) |
1055 | GNUNET_NETWORK_unix_precheck((struct sockaddr_un *)sa); | 1068 | GNUNET_NETWORK_unix_precheck ((struct sockaddr_un *) sa); |
1056 | if (GNUNET_OK != | 1069 | if (GNUNET_OK != |
1057 | GNUNET_NETWORK_socket_bind(sock, (const struct sockaddr *)sa, addr_len)) | 1070 | GNUNET_NETWORK_socket_bind (sock, (const struct sockaddr *) sa, addr_len)) |
1058 | { | 1071 | { |
1059 | GNUNET_log( | 1072 | GNUNET_log ( |
1060 | GNUNET_ERROR_TYPE_WARNING, | 1073 | GNUNET_ERROR_TYPE_WARNING, |
1061 | _( | 1074 | _ ( |
1062 | "Unable to bind listening socket for service `%s' to address `%s': %s\n"), | 1075 | "Unable to bind listening socket for service `%s' to address `%s': %s\n"), |
1063 | sl->name, | 1076 | sl->name, |
1064 | GNUNET_a2s(sa, addr_len), | 1077 | GNUNET_a2s (sa, addr_len), |
1065 | strerror(errno)); | 1078 | strerror (errno)); |
1066 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(sock)); | 1079 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock)); |
1067 | GNUNET_free(sa); | 1080 | GNUNET_free (sa); |
1068 | return; | 1081 | return; |
1069 | } | 1082 | } |
1070 | if ((AF_UNIX == sa->sa_family) | 1083 | if ((AF_UNIX == sa->sa_family) |
1071 | #ifdef LINUX | 1084 | #ifdef LINUX |
1072 | /* Permission settings are not required when abstract sockets are used */ | 1085 | /* Permission settings are not required when abstract sockets are used */ |
1073 | && ('\0' != ((const struct sockaddr_un *)sa)->sun_path[0]) | 1086 | && ('\0' != ((const struct sockaddr_un *) sa)->sun_path[0]) |
1074 | #endif | 1087 | #endif |
1075 | ) | 1088 | ) |
1076 | { | 1089 | { |
1077 | match_uid = | 1090 | match_uid = |
1078 | GNUNET_CONFIGURATION_get_value_yesno(cfg, sl->name, "UNIX_MATCH_UID"); | 1091 | GNUNET_CONFIGURATION_get_value_yesno (cfg, sl->name, "UNIX_MATCH_UID"); |
1079 | match_gid = | 1092 | match_gid = |
1080 | GNUNET_CONFIGURATION_get_value_yesno(cfg, sl->name, "UNIX_MATCH_GID"); | 1093 | GNUNET_CONFIGURATION_get_value_yesno (cfg, sl->name, "UNIX_MATCH_GID"); |
1081 | GNUNET_DISK_fix_permissions(((const struct sockaddr_un *)sa)->sun_path, | 1094 | GNUNET_DISK_fix_permissions (((const struct sockaddr_un *) sa)->sun_path, |
1082 | match_uid, | 1095 | match_uid, |
1083 | match_gid); | 1096 | match_gid); |
1084 | } | 1097 | } |
1085 | if (GNUNET_OK != GNUNET_NETWORK_socket_listen(sock, 5)) | 1098 | if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock, 5)) |
1086 | { | 1099 | { |
1087 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "listen"); | 1100 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "listen"); |
1088 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(sock)); | 1101 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock)); |
1089 | GNUNET_free(sa); | 1102 | GNUNET_free (sa); |
1090 | return; | 1103 | return; |
1091 | } | 1104 | } |
1092 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 1105 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1093 | _("ARM now monitors connections to service `%s' at `%s'\n"), | 1106 | _ ("ARM now monitors connections to service `%s' at `%s'\n"), |
1094 | sl->name, | 1107 | sl->name, |
1095 | GNUNET_a2s(sa, addr_len)); | 1108 | GNUNET_a2s (sa, addr_len)); |
1096 | sli = GNUNET_new(struct ServiceListeningInfo); | 1109 | sli = GNUNET_new (struct ServiceListeningInfo); |
1097 | sli->service_addr = sa; | 1110 | sli->service_addr = sa; |
1098 | sli->service_addr_len = addr_len; | 1111 | sli->service_addr_len = addr_len; |
1099 | sli->listen_socket = sock; | 1112 | sli->listen_socket = sock; |
1100 | sli->sl = sl; | 1113 | sli->sl = sl; |
1101 | sli->accept_task = | 1114 | sli->accept_task = |
1102 | GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | 1115 | GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
1103 | sock, | 1116 | sock, |
1104 | &accept_connection, | 1117 | &accept_connection, |
1105 | sli); | 1118 | sli); |
1106 | GNUNET_CONTAINER_DLL_insert(sl->listen_head, sl->listen_tail, sli); | 1119 | GNUNET_CONTAINER_DLL_insert (sl->listen_head, sl->listen_tail, sli); |
1107 | } | 1120 | } |
1108 | 1121 | ||
1109 | 1122 | ||
@@ -1114,15 +1127,15 @@ create_listen_socket(struct sockaddr *sa, | |||
1114 | * @param sl entry to free | 1127 | * @param sl entry to free |
1115 | */ | 1128 | */ |
1116 | static void | 1129 | static void |
1117 | free_service(struct ServiceList *sl) | 1130 | free_service (struct ServiceList *sl) |
1118 | { | 1131 | { |
1119 | GNUNET_assert(GNUNET_YES == in_shutdown); | 1132 | GNUNET_assert (GNUNET_YES == in_shutdown); |
1120 | GNUNET_CONTAINER_DLL_remove(running_head, running_tail, sl); | 1133 | GNUNET_CONTAINER_DLL_remove (running_head, running_tail, sl); |
1121 | GNUNET_assert(NULL == sl->listen_head); | 1134 | GNUNET_assert (NULL == sl->listen_head); |
1122 | GNUNET_free_non_null(sl->config); | 1135 | GNUNET_free_non_null (sl->config); |
1123 | GNUNET_free_non_null(sl->binary); | 1136 | GNUNET_free_non_null (sl->binary); |
1124 | GNUNET_free(sl->name); | 1137 | GNUNET_free (sl->name); |
1125 | GNUNET_free(sl); | 1138 | GNUNET_free (sl); |
1126 | } | 1139 | } |
1127 | 1140 | ||
1128 | 1141 | ||
@@ -1135,10 +1148,10 @@ free_service(struct ServiceList *sl) | |||
1135 | * #GNUNET_SYSERR to close it (signal serious error) | 1148 | * #GNUNET_SYSERR to close it (signal serious error) |
1136 | */ | 1149 | */ |
1137 | static int | 1150 | static int |
1138 | check_start(void *cls, const struct GNUNET_ARM_Message *amsg) | 1151 | check_start (void *cls, const struct GNUNET_ARM_Message *amsg) |
1139 | { | 1152 | { |
1140 | (void)cls; | 1153 | (void) cls; |
1141 | GNUNET_MQ_check_zero_termination(amsg); | 1154 | GNUNET_MQ_check_zero_termination (amsg); |
1142 | return GNUNET_OK; | 1155 | return GNUNET_OK; |
1143 | } | 1156 | } |
1144 | 1157 | ||
@@ -1150,43 +1163,43 @@ check_start(void *cls, const struct GNUNET_ARM_Message *amsg) | |||
1150 | * @param amsg the actual message | 1163 | * @param amsg the actual message |
1151 | */ | 1164 | */ |
1152 | static void | 1165 | static void |
1153 | handle_start(void *cls, const struct GNUNET_ARM_Message *amsg) | 1166 | handle_start (void *cls, const struct GNUNET_ARM_Message *amsg) |
1154 | { | 1167 | { |
1155 | struct GNUNET_SERVICE_Client *client = cls; | 1168 | struct GNUNET_SERVICE_Client *client = cls; |
1156 | const char *servicename; | 1169 | const char *servicename; |
1157 | struct ServiceList *sl; | 1170 | struct ServiceList *sl; |
1158 | uint64_t request_id; | 1171 | uint64_t request_id; |
1159 | 1172 | ||
1160 | request_id = GNUNET_ntohll(amsg->request_id); | 1173 | request_id = GNUNET_ntohll (amsg->request_id); |
1161 | servicename = (const char *)&amsg[1]; | 1174 | servicename = (const char *) &amsg[1]; |
1162 | GNUNET_SERVICE_client_continue(client); | 1175 | GNUNET_SERVICE_client_continue (client); |
1163 | if (GNUNET_YES == in_shutdown) | 1176 | if (GNUNET_YES == in_shutdown) |
1164 | { | 1177 | { |
1165 | signal_result(client, | 1178 | signal_result (client, |
1166 | servicename, | 1179 | servicename, |
1167 | request_id, | 1180 | request_id, |
1168 | GNUNET_ARM_RESULT_IN_SHUTDOWN); | 1181 | GNUNET_ARM_RESULT_IN_SHUTDOWN); |
1169 | return; | 1182 | return; |
1170 | } | 1183 | } |
1171 | sl = find_service(servicename); | 1184 | sl = find_service (servicename); |
1172 | if (NULL == sl) | 1185 | if (NULL == sl) |
1173 | { | 1186 | { |
1174 | signal_result(client, | 1187 | signal_result (client, |
1175 | servicename, | 1188 | servicename, |
1176 | request_id, | 1189 | request_id, |
1177 | GNUNET_ARM_RESULT_IS_NOT_KNOWN); | 1190 | GNUNET_ARM_RESULT_IS_NOT_KNOWN); |
1178 | return; | 1191 | return; |
1179 | } | 1192 | } |
1180 | sl->force_start = GNUNET_YES; | 1193 | sl->force_start = GNUNET_YES; |
1181 | if (NULL != sl->proc) | 1194 | if (NULL != sl->proc) |
1182 | { | 1195 | { |
1183 | signal_result(client, | 1196 | signal_result (client, |
1184 | servicename, | 1197 | servicename, |
1185 | request_id, | 1198 | request_id, |
1186 | GNUNET_ARM_RESULT_IS_STARTED_ALREADY); | 1199 | GNUNET_ARM_RESULT_IS_STARTED_ALREADY); |
1187 | return; | 1200 | return; |
1188 | } | 1201 | } |
1189 | start_process(sl, client, request_id); | 1202 | start_process (sl, client, request_id); |
1190 | } | 1203 | } |
1191 | 1204 | ||
1192 | 1205 | ||
@@ -1196,11 +1209,11 @@ handle_start(void *cls, const struct GNUNET_ARM_Message *amsg) | |||
1196 | * @param cls closure (refers to service) | 1209 | * @param cls closure (refers to service) |
1197 | */ | 1210 | */ |
1198 | static void | 1211 | static void |
1199 | trigger_shutdown(void *cls) | 1212 | trigger_shutdown (void *cls) |
1200 | { | 1213 | { |
1201 | (void)cls; | 1214 | (void) cls; |
1202 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Triggering shutdown\n"); | 1215 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Triggering shutdown\n"); |
1203 | GNUNET_SCHEDULER_shutdown(); | 1216 | GNUNET_SCHEDULER_shutdown (); |
1204 | } | 1217 | } |
1205 | 1218 | ||
1206 | 1219 | ||
@@ -1213,10 +1226,10 @@ trigger_shutdown(void *cls) | |||
1213 | * #GNUNET_SYSERR to close it (signal serious error) | 1226 | * #GNUNET_SYSERR to close it (signal serious error) |
1214 | */ | 1227 | */ |
1215 | static int | 1228 | static int |
1216 | check_stop(void *cls, const struct GNUNET_ARM_Message *amsg) | 1229 | check_stop (void *cls, const struct GNUNET_ARM_Message *amsg) |
1217 | { | 1230 | { |
1218 | (void)cls; | 1231 | (void) cls; |
1219 | GNUNET_MQ_check_zero_termination(amsg); | 1232 | GNUNET_MQ_check_zero_termination (amsg); |
1220 | return GNUNET_OK; | 1233 | return GNUNET_OK; |
1221 | } | 1234 | } |
1222 | 1235 | ||
@@ -1228,128 +1241,184 @@ check_stop(void *cls, const struct GNUNET_ARM_Message *amsg) | |||
1228 | * @param amsg the actual message | 1241 | * @param amsg the actual message |
1229 | */ | 1242 | */ |
1230 | static void | 1243 | static void |
1231 | handle_stop(void *cls, const struct GNUNET_ARM_Message *amsg) | 1244 | handle_stop (void *cls, const struct GNUNET_ARM_Message *amsg) |
1232 | { | 1245 | { |
1233 | struct GNUNET_SERVICE_Client *client = cls; | 1246 | struct GNUNET_SERVICE_Client *client = cls; |
1234 | struct ServiceList *sl; | 1247 | struct ServiceList *sl; |
1235 | const char *servicename; | 1248 | const char *servicename; |
1236 | uint64_t request_id; | 1249 | uint64_t request_id; |
1237 | 1250 | ||
1238 | request_id = GNUNET_ntohll(amsg->request_id); | 1251 | request_id = GNUNET_ntohll (amsg->request_id); |
1239 | servicename = (const char *)&amsg[1]; | 1252 | servicename = (const char *) &amsg[1]; |
1240 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 1253 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1241 | _("Preparing to stop `%s'\n"), | 1254 | _ ("Preparing to stop `%s'\n"), |
1242 | servicename); | 1255 | servicename); |
1243 | GNUNET_SERVICE_client_continue(client); | 1256 | GNUNET_SERVICE_client_continue (client); |
1244 | if (0 == strcasecmp(servicename, "arm")) | 1257 | if (0 == strcasecmp (servicename, "arm")) |
1245 | { | 1258 | { |
1246 | broadcast_status(servicename, GNUNET_ARM_SERVICE_STOPPING, NULL); | 1259 | broadcast_status (servicename, GNUNET_ARM_SERVICE_STOPPING, NULL); |
1247 | signal_result(client, servicename, request_id, GNUNET_ARM_RESULT_STOPPING); | 1260 | signal_result (client, servicename, request_id, GNUNET_ARM_RESULT_STOPPING); |
1248 | GNUNET_SERVICE_client_persist(client); | 1261 | GNUNET_SERVICE_client_persist (client); |
1249 | GNUNET_SCHEDULER_add_now(&trigger_shutdown, NULL); | 1262 | GNUNET_SCHEDULER_add_now (&trigger_shutdown, NULL); |
1250 | return; | 1263 | return; |
1251 | } | 1264 | } |
1252 | sl = find_service(servicename); | 1265 | sl = find_service (servicename); |
1253 | if (NULL == sl) | 1266 | if (NULL == sl) |
1254 | { | 1267 | { |
1255 | signal_result(client, | 1268 | signal_result (client, |
1256 | servicename, | 1269 | servicename, |
1257 | request_id, | 1270 | request_id, |
1258 | GNUNET_ARM_RESULT_IS_NOT_KNOWN); | 1271 | GNUNET_ARM_RESULT_IS_NOT_KNOWN); |
1259 | return; | 1272 | return; |
1260 | } | 1273 | } |
1261 | sl->force_start = GNUNET_NO; | 1274 | sl->force_start = GNUNET_NO; |
1262 | if (GNUNET_YES == in_shutdown) | 1275 | if (GNUNET_YES == in_shutdown) |
1263 | { | 1276 | { |
1264 | /* shutdown in progress */ | 1277 | /* shutdown in progress */ |
1265 | signal_result(client, | 1278 | signal_result (client, |
1266 | servicename, | 1279 | servicename, |
1267 | request_id, | 1280 | request_id, |
1268 | GNUNET_ARM_RESULT_IN_SHUTDOWN); | 1281 | GNUNET_ARM_RESULT_IN_SHUTDOWN); |
1269 | return; | 1282 | return; |
1270 | } | 1283 | } |
1271 | if (NULL != sl->killing_client) | 1284 | if (NULL != sl->killing_client) |
1272 | { | 1285 | { |
1273 | /* killing already in progress */ | 1286 | /* killing already in progress */ |
1274 | signal_result(client, | 1287 | signal_result (client, |
1275 | servicename, | 1288 | servicename, |
1276 | request_id, | 1289 | request_id, |
1277 | GNUNET_ARM_RESULT_IS_STOPPING_ALREADY); | 1290 | GNUNET_ARM_RESULT_IS_STOPPING_ALREADY); |
1278 | return; | 1291 | return; |
1279 | } | 1292 | } |
1280 | if (NULL == sl->proc) | 1293 | if (NULL == sl->proc) |
1281 | { | 1294 | { |
1282 | /* process is down */ | 1295 | /* process is down */ |
1283 | signal_result(client, | 1296 | signal_result (client, |
1284 | servicename, | 1297 | servicename, |
1285 | request_id, | 1298 | request_id, |
1286 | GNUNET_ARM_RESULT_IS_STOPPED_ALREADY); | 1299 | GNUNET_ARM_RESULT_IS_STOPPED_ALREADY); |
1287 | return; | 1300 | return; |
1288 | } | 1301 | } |
1289 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1302 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1290 | "Sending kill signal to service `%s', waiting for process to die.\n", | 1303 | "Sending kill signal to service `%s', waiting for process to die.\n", |
1291 | servicename); | 1304 | servicename); |
1292 | broadcast_status(servicename, GNUNET_ARM_SERVICE_STOPPING, NULL); | 1305 | broadcast_status (servicename, GNUNET_ARM_SERVICE_STOPPING, NULL); |
1293 | /* no signal_start - only when it's STOPPED */ | 1306 | /* no signal_start - only when it's STOPPED */ |
1294 | sl->killed_at = GNUNET_TIME_absolute_get(); | 1307 | sl->killed_at = GNUNET_TIME_absolute_get (); |
1295 | if (0 != GNUNET_OS_process_kill(sl->proc, GNUNET_TERM_SIG)) | 1308 | if (0 != GNUNET_OS_process_kill (sl->proc, GNUNET_TERM_SIG)) |
1296 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill"); | 1309 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); |
1297 | sl->killing_client = client; | 1310 | sl->killing_client = client; |
1298 | sl->killing_client_request_id = request_id; | 1311 | sl->killing_client_request_id = request_id; |
1299 | } | 1312 | } |
1300 | 1313 | ||
1301 | 1314 | ||
1302 | /** | 1315 | /** |
1316 | * Write a string to a string pool. | ||
1317 | * | ||
1318 | * @param pool_start pointer to the start of the string pool | ||
1319 | * @param pool_size size of the string pool | ||
1320 | * @param[in,out] pool_pos current position index in the string pool, | ||
1321 | * will be updated | ||
1322 | * @param str string to write to the string pool | ||
1323 | * @returns GNUNET_OK if the string fits into the pool, | ||
1324 | * GNUNET_SYSERR otherwise | ||
1325 | */ | ||
1326 | static int | ||
1327 | pool_write (char *pool_start, size_t pool_size, size_t *pool_pos, char *str) | ||
1328 | { | ||
1329 | size_t next_pos = (*pool_pos) + strlen (str) + 1; | ||
1330 | |||
1331 | if (next_pos > pool_size) | ||
1332 | return GNUNET_SYSERR; | ||
1333 | memcpy (pool_start + *pool_pos, str, strlen (str) + 1); | ||
1334 | *pool_pos = next_pos; | ||
1335 | return GNUNET_OK; | ||
1336 | } | ||
1337 | |||
1338 | /** | ||
1303 | * Handle LIST-message. | 1339 | * Handle LIST-message. |
1304 | * | 1340 | * |
1305 | * @param cls identification of the client | 1341 | * @param cls identification of the client |
1306 | * @param message the actual message | 1342 | * @param message the actual message |
1307 | */ | 1343 | */ |
1308 | static void | 1344 | static void |
1309 | handle_list(void *cls, const struct GNUNET_ARM_Message *request) | 1345 | handle_list (void *cls, const struct GNUNET_ARM_Message *request) |
1310 | { | 1346 | { |
1311 | struct GNUNET_SERVICE_Client *client = cls; | 1347 | struct GNUNET_SERVICE_Client *client = cls; |
1312 | struct GNUNET_MQ_Envelope *env; | 1348 | struct GNUNET_MQ_Envelope *env; |
1313 | struct GNUNET_ARM_ListResultMessage *msg; | 1349 | struct GNUNET_ARM_ListResultMessage *msg; |
1314 | size_t string_list_size; | 1350 | size_t extra_size; |
1315 | struct ServiceList *sl; | 1351 | struct ServiceList *sl; |
1316 | uint16_t count; | 1352 | uint16_t count; |
1317 | char *pos; | 1353 | size_t pool_size; |
1354 | size_t pool_pos; | ||
1355 | char *pool_start; | ||
1356 | struct GNUNET_ARM_ServiceInfoMessage *ssm; | ||
1318 | 1357 | ||
1319 | GNUNET_break(0 == ntohl(request->reserved)); | 1358 | GNUNET_break_op (0 == ntohl (request->reserved)); |
1320 | count = 0; | 1359 | count = 0; |
1321 | string_list_size = 0; | 1360 | pool_size = 0; |
1322 | 1361 | ||
1323 | /* first count the running processes get their name's size */ | 1362 | /* Do one pass over the list to compute the number of services |
1363 | * and the string pool size */ | ||
1324 | for (sl = running_head; NULL != sl; sl = sl->next) | 1364 | for (sl = running_head; NULL != sl; sl = sl->next) |
1325 | { | 1365 | { |
1326 | if (NULL != sl->proc) | 1366 | pool_size += strlen (sl->name) + 1; |
1327 | { | 1367 | pool_size += strlen (sl->binary) + 1; |
1328 | string_list_size += strlen(sl->name); | 1368 | count++; |
1329 | string_list_size += strlen(sl->binary); | 1369 | } |
1330 | string_list_size += 4; | ||
1331 | count++; | ||
1332 | } | ||
1333 | } | ||
1334 | 1370 | ||
1335 | env = GNUNET_MQ_msg_extra(msg, | 1371 | extra_size = pool_size + (count * sizeof (struct |
1336 | string_list_size, | 1372 | GNUNET_ARM_ServiceInfoMessage)); |
1337 | GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT); | 1373 | env = GNUNET_MQ_msg_extra (msg, |
1374 | extra_size, | ||
1375 | GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT); | ||
1338 | msg->arm_msg.request_id = request->request_id; | 1376 | msg->arm_msg.request_id = request->request_id; |
1339 | msg->count = htons(count); | 1377 | msg->count = htons (count); |
1378 | |||
1379 | ssm = (struct GNUNET_ARM_ServiceInfoMessage *) &msg[1]; | ||
1380 | pool_start = (char *) (ssm + count); | ||
1381 | pool_pos = 0; | ||
1340 | 1382 | ||
1341 | pos = (char *)&msg[1]; | ||
1342 | for (sl = running_head; NULL != sl; sl = sl->next) | 1383 | for (sl = running_head; NULL != sl; sl = sl->next) |
1384 | { | ||
1385 | ssm->name_index = htons ((uint16_t) pool_pos); | ||
1386 | GNUNET_assert (GNUNET_OK == pool_write (pool_start, pool_size, &pool_pos, | ||
1387 | sl->name)); | ||
1388 | ssm->binary_index = htons ((uint16_t) pool_pos); | ||
1389 | GNUNET_assert (GNUNET_OK == pool_write (pool_start, pool_size, &pool_pos, | ||
1390 | sl->binary)); | ||
1391 | if (NULL == sl->proc) | ||
1343 | { | 1392 | { |
1344 | if (NULL != sl->proc) | 1393 | if (0 == sl->last_started_at.abs_value_us) |
1345 | { | 1394 | { |
1346 | size_t s = strlen(sl->name) + strlen(sl->binary) + 4; | 1395 | /* Process never started */ |
1347 | GNUNET_snprintf(pos, s, "%s (%s)", sl->name, sl->binary); | 1396 | ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_STOPPED); |
1348 | pos += s; | 1397 | } |
1349 | } | 1398 | else if (0 == sl->last_exit_status) |
1399 | { | ||
1400 | ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_FINISHED); | ||
1401 | } | ||
1402 | else | ||
1403 | { | ||
1404 | ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_FAILED); | ||
1405 | ssm->last_exit_status = htons (sl->last_exit_status); | ||
1406 | } | ||
1407 | } | ||
1408 | else if ((NULL != sl->killing_client) || (GNUNET_YES == in_shutdown)) | ||
1409 | { | ||
1410 | ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_STOPPING); | ||
1411 | } | ||
1412 | else | ||
1413 | { | ||
1414 | ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_STARTED); | ||
1350 | } | 1415 | } |
1351 | GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client), env); | 1416 | ssm->last_started_at = GNUNET_TIME_absolute_hton (sl->last_started_at); |
1352 | GNUNET_SERVICE_client_continue(client); | 1417 | ssm->restart_at = GNUNET_TIME_absolute_hton (sl->restart_at); |
1418 | ssm++; | ||
1419 | } | ||
1420 | GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env); | ||
1421 | GNUNET_SERVICE_client_continue (client); | ||
1353 | } | 1422 | } |
1354 | 1423 | ||
1355 | 1424 | ||
@@ -1360,16 +1429,16 @@ handle_list(void *cls, const struct GNUNET_ARM_Message *request) | |||
1360 | * @param message the actual message | 1429 | * @param message the actual message |
1361 | */ | 1430 | */ |
1362 | static void | 1431 | static void |
1363 | handle_test(void *cls, const struct GNUNET_MessageHeader *message) | 1432 | handle_test (void *cls, const struct GNUNET_MessageHeader *message) |
1364 | { | 1433 | { |
1365 | struct GNUNET_SERVICE_Client *client = cls; | 1434 | struct GNUNET_SERVICE_Client *client = cls; |
1366 | struct GNUNET_MQ_Envelope *env; | 1435 | struct GNUNET_MQ_Envelope *env; |
1367 | struct GNUNET_MessageHeader *msg; | 1436 | struct GNUNET_MessageHeader *msg; |
1368 | 1437 | ||
1369 | (void)message; | 1438 | (void) message; |
1370 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_ARM_TEST); | 1439 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_ARM_TEST); |
1371 | GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client), env); | 1440 | GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env); |
1372 | GNUNET_SERVICE_client_continue(client); | 1441 | GNUNET_SERVICE_client_continue (client); |
1373 | } | 1442 | } |
1374 | 1443 | ||
1375 | 1444 | ||
@@ -1378,24 +1447,24 @@ handle_test(void *cls, const struct GNUNET_MessageHeader *message) | |||
1378 | * tasks, signal handler and the server. | 1447 | * tasks, signal handler and the server. |
1379 | */ | 1448 | */ |
1380 | static void | 1449 | static void |
1381 | do_shutdown() | 1450 | do_shutdown () |
1382 | { | 1451 | { |
1383 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Last shutdown phase\n"); | 1452 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Last shutdown phase\n"); |
1384 | if (NULL != notifier) | 1453 | if (NULL != notifier) |
1385 | { | 1454 | { |
1386 | GNUNET_notification_context_destroy(notifier); | 1455 | GNUNET_notification_context_destroy (notifier); |
1387 | notifier = NULL; | 1456 | notifier = NULL; |
1388 | } | 1457 | } |
1389 | if (NULL != service) | 1458 | if (NULL != service) |
1390 | { | 1459 | { |
1391 | GNUNET_SERVICE_shutdown(service); | 1460 | GNUNET_SERVICE_shutdown (service); |
1392 | service = NULL; | 1461 | service = NULL; |
1393 | } | 1462 | } |
1394 | if (NULL != child_death_task) | 1463 | if (NULL != child_death_task) |
1395 | { | 1464 | { |
1396 | GNUNET_SCHEDULER_cancel(child_death_task); | 1465 | GNUNET_SCHEDULER_cancel (child_death_task); |
1397 | child_death_task = NULL; | 1466 | child_death_task = NULL; |
1398 | } | 1467 | } |
1399 | } | 1468 | } |
1400 | 1469 | ||
1401 | 1470 | ||
@@ -1406,13 +1475,13 @@ do_shutdown() | |||
1406 | * @return number of active services found | 1475 | * @return number of active services found |
1407 | */ | 1476 | */ |
1408 | static unsigned int | 1477 | static unsigned int |
1409 | list_count(struct ServiceList *running_head) | 1478 | list_count (struct ServiceList *running_head) |
1410 | { | 1479 | { |
1411 | struct ServiceList *i; | 1480 | struct ServiceList *i; |
1412 | unsigned int res; | 1481 | unsigned int res; |
1413 | 1482 | ||
1414 | for (res = 0, i = running_head; NULL != i; i = i->next, res++) | 1483 | for (res = 0, i = running_head; NULL != i; i = i->next, res++) |
1415 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s\n", i->name); | 1484 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s\n", i->name); |
1416 | return res; | 1485 | return res; |
1417 | } | 1486 | } |
1418 | 1487 | ||
@@ -1423,61 +1492,61 @@ list_count(struct ServiceList *running_head) | |||
1423 | * @param cls closure, NULL if we need to self-restart | 1492 | * @param cls closure, NULL if we need to self-restart |
1424 | */ | 1493 | */ |
1425 | static void | 1494 | static void |
1426 | shutdown_task(void *cls) | 1495 | shutdown_task (void *cls) |
1427 | { | 1496 | { |
1428 | struct ServiceList *pos; | 1497 | struct ServiceList *pos; |
1429 | struct ServiceList *nxt; | 1498 | struct ServiceList *nxt; |
1430 | struct ServiceListeningInfo *sli; | 1499 | struct ServiceListeningInfo *sli; |
1431 | 1500 | ||
1432 | (void)cls; | 1501 | (void) cls; |
1433 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "First shutdown phase\n"); | 1502 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "First shutdown phase\n"); |
1434 | if (NULL != child_restart_task) | 1503 | if (NULL != child_restart_task) |
1435 | { | 1504 | { |
1436 | GNUNET_SCHEDULER_cancel(child_restart_task); | 1505 | GNUNET_SCHEDULER_cancel (child_restart_task); |
1437 | child_restart_task = NULL; | 1506 | child_restart_task = NULL; |
1438 | } | 1507 | } |
1439 | in_shutdown = GNUNET_YES; | 1508 | in_shutdown = GNUNET_YES; |
1440 | /* first, stop listening */ | 1509 | /* first, stop listening */ |
1441 | for (pos = running_head; NULL != pos; pos = pos->next) | 1510 | for (pos = running_head; NULL != pos; pos = pos->next) |
1511 | { | ||
1512 | while (NULL != (sli = pos->listen_head)) | ||
1442 | { | 1513 | { |
1443 | while (NULL != (sli = pos->listen_head)) | 1514 | GNUNET_CONTAINER_DLL_remove (pos->listen_head, pos->listen_tail, sli); |
1444 | { | 1515 | if (NULL != sli->accept_task) |
1445 | GNUNET_CONTAINER_DLL_remove(pos->listen_head, pos->listen_tail, sli); | 1516 | { |
1446 | if (NULL != sli->accept_task) | 1517 | GNUNET_SCHEDULER_cancel (sli->accept_task); |
1447 | { | 1518 | sli->accept_task = NULL; |
1448 | GNUNET_SCHEDULER_cancel(sli->accept_task); | 1519 | } |
1449 | sli->accept_task = NULL; | 1520 | GNUNET_break (GNUNET_OK == |
1450 | } | 1521 | GNUNET_NETWORK_socket_close (sli->listen_socket)); |
1451 | GNUNET_break(GNUNET_OK == | 1522 | GNUNET_free (sli->service_addr); |
1452 | GNUNET_NETWORK_socket_close(sli->listen_socket)); | 1523 | GNUNET_free (sli); |
1453 | GNUNET_free(sli->service_addr); | ||
1454 | GNUNET_free(sli); | ||
1455 | } | ||
1456 | } | 1524 | } |
1525 | } | ||
1457 | /* then, shutdown all existing service processes */ | 1526 | /* then, shutdown all existing service processes */ |
1458 | nxt = running_head; | 1527 | nxt = running_head; |
1459 | while (NULL != (pos = nxt)) | 1528 | while (NULL != (pos = nxt)) |
1529 | { | ||
1530 | nxt = pos->next; | ||
1531 | if (NULL != pos->proc) | ||
1460 | { | 1532 | { |
1461 | nxt = pos->next; | 1533 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stopping service `%s'\n", pos->name); |
1462 | if (NULL != pos->proc) | 1534 | pos->killed_at = GNUNET_TIME_absolute_get (); |
1463 | { | 1535 | if (0 != GNUNET_OS_process_kill (pos->proc, GNUNET_TERM_SIG)) |
1464 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Stopping service `%s'\n", pos->name); | 1536 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); |
1465 | pos->killed_at = GNUNET_TIME_absolute_get(); | ||
1466 | if (0 != GNUNET_OS_process_kill(pos->proc, GNUNET_TERM_SIG)) | ||
1467 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill"); | ||
1468 | } | ||
1469 | else | ||
1470 | { | ||
1471 | free_service(pos); | ||
1472 | } | ||
1473 | } | 1537 | } |
1538 | else | ||
1539 | { | ||
1540 | free_service (pos); | ||
1541 | } | ||
1542 | } | ||
1474 | /* finally, should all service processes be already gone, terminate for real */ | 1543 | /* finally, should all service processes be already gone, terminate for real */ |
1475 | if (NULL == running_head) | 1544 | if (NULL == running_head) |
1476 | do_shutdown(); | 1545 | do_shutdown (); |
1477 | else | 1546 | else |
1478 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1547 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1479 | "Delaying shutdown, have %u childs still running\n", | 1548 | "Delaying shutdown, have %u childs still running\n", |
1480 | list_count(running_head)); | 1549 | list_count (running_head)); |
1481 | } | 1550 | } |
1482 | 1551 | ||
1483 | 1552 | ||
@@ -1487,73 +1556,73 @@ shutdown_task(void *cls) | |||
1487 | * @param cls closure, always NULL | 1556 | * @param cls closure, always NULL |
1488 | */ | 1557 | */ |
1489 | static void | 1558 | static void |
1490 | delayed_restart_task(void *cls) | 1559 | delayed_restart_task (void *cls) |
1491 | 1560 | ||
1492 | { | 1561 | { |
1493 | struct ServiceList *sl; | 1562 | struct ServiceList *sl; |
1494 | struct GNUNET_TIME_Relative lowestRestartDelay; | 1563 | struct GNUNET_TIME_Relative lowestRestartDelay; |
1495 | struct ServiceListeningInfo *sli; | 1564 | struct ServiceListeningInfo *sli; |
1496 | 1565 | ||
1497 | (void)cls; | 1566 | (void) cls; |
1498 | child_restart_task = NULL; | 1567 | child_restart_task = NULL; |
1499 | GNUNET_assert(GNUNET_NO == in_shutdown); | 1568 | GNUNET_assert (GNUNET_NO == in_shutdown); |
1500 | lowestRestartDelay = GNUNET_TIME_UNIT_FOREVER_REL; | 1569 | lowestRestartDelay = GNUNET_TIME_UNIT_FOREVER_REL; |
1501 | 1570 | ||
1502 | /* check for services that need to be restarted due to | 1571 | /* check for services that need to be restarted due to |
1503 | * configuration changes or because the last restart failed */ | 1572 | * configuration changes or because the last restart failed */ |
1504 | for (sl = running_head; NULL != sl; sl = sl->next) | 1573 | for (sl = running_head; NULL != sl; sl = sl->next) |
1574 | { | ||
1575 | if (NULL != sl->proc) | ||
1576 | continue; | ||
1577 | /* service is currently not running */ | ||
1578 | if (0 == GNUNET_TIME_absolute_get_remaining (sl->restart_at).rel_value_us) | ||
1505 | { | 1579 | { |
1506 | if (NULL != sl->proc) | 1580 | /* restart is now allowed */ |
1507 | continue; | 1581 | if (sl->force_start) |
1508 | /* service is currently not running */ | 1582 | { |
1509 | if (0 == GNUNET_TIME_absolute_get_remaining(sl->restart_at).rel_value_us) | 1583 | /* process should run by default, start immediately */ |
1510 | { | 1584 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1511 | /* restart is now allowed */ | 1585 | _ ("Restarting service `%s'.\n"), |
1512 | if (sl->force_start) | 1586 | sl->name); |
1513 | { | 1587 | start_process (sl, NULL, 0); |
1514 | /* process should run by default, start immediately */ | 1588 | } |
1515 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | ||
1516 | _("Restarting service `%s'.\n"), | ||
1517 | sl->name); | ||
1518 | start_process(sl, NULL, 0); | ||
1519 | } | ||
1520 | else | ||
1521 | { | ||
1522 | /* process is run on-demand, ensure it is re-started if there is demand */ | ||
1523 | for (sli = sl->listen_head; NULL != sli; sli = sli->next) | ||
1524 | if (NULL == sli->accept_task) | ||
1525 | { | ||
1526 | /* accept was actually paused, so start it again */ | ||
1527 | sli->accept_task = | ||
1528 | GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | ||
1529 | sli->listen_socket, | ||
1530 | &accept_connection, | ||
1531 | sli); | ||
1532 | } | ||
1533 | } | ||
1534 | } | ||
1535 | else | 1589 | else |
1536 | { | 1590 | { |
1537 | /* update calculation for earliest time to reactivate a service */ | 1591 | /* process is run on-demand, ensure it is re-started if there is demand */ |
1538 | lowestRestartDelay = | 1592 | for (sli = sl->listen_head; NULL != sli; sli = sli->next) |
1539 | GNUNET_TIME_relative_min(lowestRestartDelay, | 1593 | if (NULL == sli->accept_task) |
1540 | GNUNET_TIME_absolute_get_remaining( | 1594 | { |
1541 | sl->restart_at)); | 1595 | /* accept was actually paused, so start it again */ |
1542 | } | 1596 | sli->accept_task = |
1597 | GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | ||
1598 | sli->listen_socket, | ||
1599 | &accept_connection, | ||
1600 | sli); | ||
1601 | } | ||
1602 | } | ||
1603 | } | ||
1604 | else | ||
1605 | { | ||
1606 | /* update calculation for earliest time to reactivate a service */ | ||
1607 | lowestRestartDelay = | ||
1608 | GNUNET_TIME_relative_min (lowestRestartDelay, | ||
1609 | GNUNET_TIME_absolute_get_remaining ( | ||
1610 | sl->restart_at)); | ||
1543 | } | 1611 | } |
1612 | } | ||
1544 | if (lowestRestartDelay.rel_value_us != | 1613 | if (lowestRestartDelay.rel_value_us != |
1545 | GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us) | 1614 | GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us) |
1546 | { | 1615 | { |
1547 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1616 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1548 | "Will restart process in %s\n", | 1617 | "Will restart process in %s\n", |
1549 | GNUNET_STRINGS_relative_time_to_string(lowestRestartDelay, | 1618 | GNUNET_STRINGS_relative_time_to_string (lowestRestartDelay, |
1550 | GNUNET_YES)); | 1619 | GNUNET_YES)); |
1551 | child_restart_task = | 1620 | child_restart_task = |
1552 | GNUNET_SCHEDULER_add_delayed_with_priority(lowestRestartDelay, | 1621 | GNUNET_SCHEDULER_add_delayed_with_priority (lowestRestartDelay, |
1553 | GNUNET_SCHEDULER_PRIORITY_IDLE, | 1622 | GNUNET_SCHEDULER_PRIORITY_IDLE, |
1554 | &delayed_restart_task, | 1623 | &delayed_restart_task, |
1555 | NULL); | 1624 | NULL); |
1556 | } | 1625 | } |
1557 | } | 1626 | } |
1558 | 1627 | ||
1559 | 1628 | ||
@@ -1564,7 +1633,7 @@ delayed_restart_task(void *cls) | |||
1564 | * @param cls closure, NULL | 1633 | * @param cls closure, NULL |
1565 | */ | 1634 | */ |
1566 | static void | 1635 | static void |
1567 | maint_child_death(void *cls) | 1636 | maint_child_death (void *cls) |
1568 | { | 1637 | { |
1569 | struct ServiceList *pos; | 1638 | struct ServiceList *pos; |
1570 | struct ServiceList *next; | 1639 | struct ServiceList *next; |
@@ -1577,199 +1646,200 @@ maint_child_death(void *cls) | |||
1577 | unsigned long statusCode; | 1646 | unsigned long statusCode; |
1578 | const struct GNUNET_DISK_FileHandle *pr; | 1647 | const struct GNUNET_DISK_FileHandle *pr; |
1579 | 1648 | ||
1580 | (void)cls; | 1649 | (void) cls; |
1581 | pr = GNUNET_DISK_pipe_handle(sigpipe, GNUNET_DISK_PIPE_END_READ); | 1650 | pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ); |
1582 | child_death_task = NULL; | 1651 | child_death_task = NULL; |
1583 | /* consume the signal */ | 1652 | /* consume the signal */ |
1584 | GNUNET_break(0 < GNUNET_DISK_file_read(pr, &c, sizeof(c))); | 1653 | GNUNET_break (0 < GNUNET_DISK_file_read (pr, &c, sizeof(c))); |
1585 | 1654 | ||
1586 | /* check for services that died (WAITPID) */ | 1655 | /* check for services that died (WAITPID) */ |
1587 | next = running_head; | 1656 | next = running_head; |
1588 | while (NULL != (pos = next)) | 1657 | while (NULL != (pos = next)) |
1589 | { | 1658 | { |
1590 | next = pos->next; | 1659 | next = pos->next; |
1591 | 1660 | ||
1592 | if (NULL == pos->proc) | 1661 | if (NULL == pos->proc) |
1593 | { | 1662 | { |
1594 | if (GNUNET_YES == in_shutdown) | 1663 | if (GNUNET_YES == in_shutdown) |
1595 | free_service(pos); | 1664 | free_service (pos); |
1596 | continue; | 1665 | continue; |
1597 | } | 1666 | } |
1598 | #if HAVE_WAIT4 | 1667 | #if HAVE_WAIT4 |
1599 | if (NULL != wait_file) | 1668 | if (NULL != wait_file) |
1600 | { | 1669 | { |
1601 | /* need to use 'wait4()' to obtain and log performance data */ | 1670 | /* need to use 'wait4()' to obtain and log performance data */ |
1602 | struct rusage ru; | 1671 | struct rusage ru; |
1603 | int status; | 1672 | int status; |
1604 | pid_t pid; | 1673 | pid_t pid; |
1605 | 1674 | ||
1606 | pid = GNUNET_OS_process_get_pid(pos->proc); | 1675 | pid = GNUNET_OS_process_get_pid (pos->proc); |
1607 | ret = wait4(pid, &status, WNOHANG, &ru); | 1676 | ret = wait4 (pid, &status, WNOHANG, &ru); |
1608 | if (ret <= 0) | 1677 | if (ret <= 0) |
1609 | continue; /* no process done */ | 1678 | continue; /* no process done */ |
1610 | if (WIFEXITED(status)) | 1679 | if (WIFEXITED (status)) |
1611 | { | 1680 | { |
1612 | statusType = GNUNET_OS_PROCESS_EXITED; | 1681 | statusType = GNUNET_OS_PROCESS_EXITED; |
1613 | statusCode = WEXITSTATUS(status); | 1682 | statusCode = WEXITSTATUS (status); |
1614 | } | 1683 | } |
1615 | else if (WIFSIGNALED(status)) | 1684 | else if (WIFSIGNALED (status)) |
1616 | { | 1685 | { |
1617 | statusType = GNUNET_OS_PROCESS_SIGNALED; | 1686 | statusType = GNUNET_OS_PROCESS_SIGNALED; |
1618 | statusCode = WTERMSIG(status); | 1687 | statusCode = WTERMSIG (status); |
1619 | } | 1688 | } |
1620 | else if (WIFSTOPPED(status)) | 1689 | else if (WIFSTOPPED (status)) |
1621 | { | 1690 | { |
1622 | statusType = GNUNET_OS_PROCESS_SIGNALED; | 1691 | statusType = GNUNET_OS_PROCESS_SIGNALED; |
1623 | statusCode = WSTOPSIG(status); | 1692 | statusCode = WSTOPSIG (status); |
1624 | } | 1693 | } |
1625 | #ifdef WIFCONTINUED | 1694 | #ifdef WIFCONTINUED |
1626 | else if (WIFCONTINUED(status)) | 1695 | else if (WIFCONTINUED (status)) |
1627 | { | 1696 | { |
1628 | statusType = GNUNET_OS_PROCESS_RUNNING; | 1697 | statusType = GNUNET_OS_PROCESS_RUNNING; |
1629 | statusCode = 0; | 1698 | statusCode = 0; |
1630 | } | 1699 | } |
1631 | #endif | ||
1632 | else | ||
1633 | { | ||
1634 | statusType = GNUNET_OS_PROCESS_UNKNOWN; | ||
1635 | statusCode = 0; | ||
1636 | } | ||
1637 | if ((GNUNET_OS_PROCESS_EXITED == statusType) || | ||
1638 | (GNUNET_OS_PROCESS_SIGNALED == statusType)) | ||
1639 | { | ||
1640 | double utime = ru.ru_utime.tv_sec + (ru.ru_utime.tv_usec / 10e6); | ||
1641 | double stime = ru.ru_stime.tv_sec + (ru.ru_stime.tv_usec / 10e6); | ||
1642 | fprintf(wait_file, | ||
1643 | "%s(%u) %.3f %.3f %llu %llu %llu %llu %llu\n", | ||
1644 | pos->binary, | ||
1645 | (unsigned int)pid, | ||
1646 | utime, | ||
1647 | stime, | ||
1648 | (unsigned long long)ru.ru_maxrss, | ||
1649 | (unsigned long long)ru.ru_inblock, | ||
1650 | (unsigned long long)ru.ru_oublock, | ||
1651 | (unsigned long long)ru.ru_nvcsw, | ||
1652 | (unsigned long long)ru.ru_nivcsw); | ||
1653 | } | ||
1654 | } | ||
1655 | else /* continue with JUST this "if" as "else" (intentionally no brackets!) */ | ||
1656 | #endif | 1700 | #endif |
1657 | if ((GNUNET_SYSERR == (ret = GNUNET_OS_process_status(pos->proc, | ||
1658 | &statusType, | ||
1659 | &statusCode))) || | ||
1660 | (ret == GNUNET_NO) || (statusType == GNUNET_OS_PROCESS_STOPPED) || | ||
1661 | (statusType == GNUNET_OS_PROCESS_UNKNOWN) || | ||
1662 | (statusType == GNUNET_OS_PROCESS_RUNNING)) | ||
1663 | continue; | ||
1664 | |||
1665 | if (statusType == GNUNET_OS_PROCESS_EXITED) | ||
1666 | { | ||
1667 | statstr = _(/* process termination method */ "exit"); | ||
1668 | statcode = statusCode; | ||
1669 | } | ||
1670 | else if (statusType == GNUNET_OS_PROCESS_SIGNALED) | ||
1671 | { | ||
1672 | statstr = _(/* process termination method */ "signal"); | ||
1673 | statcode = statusCode; | ||
1674 | } | ||
1675 | else | 1701 | else |
1676 | { | 1702 | { |
1677 | statstr = _(/* process termination method */ "unknown"); | 1703 | statusType = GNUNET_OS_PROCESS_UNKNOWN; |
1678 | statcode = 0; | 1704 | statusCode = 0; |
1679 | } | 1705 | } |
1680 | if (0 != pos->killed_at.abs_value_us) | 1706 | if ((GNUNET_OS_PROCESS_EXITED == statusType) || |
1681 | { | 1707 | (GNUNET_OS_PROCESS_SIGNALED == statusType)) |
1682 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 1708 | { |
1683 | _("Service `%s' took %s to terminate\n"), | 1709 | double utime = ru.ru_utime.tv_sec + (ru.ru_utime.tv_usec / 10e6); |
1710 | double stime = ru.ru_stime.tv_sec + (ru.ru_stime.tv_usec / 10e6); | ||
1711 | fprintf (wait_file, | ||
1712 | "%s(%u) %.3f %.3f %llu %llu %llu %llu %llu\n", | ||
1713 | pos->binary, | ||
1714 | (unsigned int) pid, | ||
1715 | utime, | ||
1716 | stime, | ||
1717 | (unsigned long long) ru.ru_maxrss, | ||
1718 | (unsigned long long) ru.ru_inblock, | ||
1719 | (unsigned long long) ru.ru_oublock, | ||
1720 | (unsigned long long) ru.ru_nvcsw, | ||
1721 | (unsigned long long) ru.ru_nivcsw); | ||
1722 | } | ||
1723 | } | ||
1724 | else /* continue with JUST this "if" as "else" (intentionally no brackets!) */ | ||
1725 | #endif | ||
1726 | if ((GNUNET_SYSERR == (ret = GNUNET_OS_process_status (pos->proc, | ||
1727 | &statusType, | ||
1728 | &statusCode))) || | ||
1729 | (ret == GNUNET_NO) || (statusType == GNUNET_OS_PROCESS_STOPPED) || | ||
1730 | (statusType == GNUNET_OS_PROCESS_UNKNOWN) || | ||
1731 | (statusType == GNUNET_OS_PROCESS_RUNNING)) | ||
1732 | continue; | ||
1733 | |||
1734 | if (statusType == GNUNET_OS_PROCESS_EXITED) | ||
1735 | { | ||
1736 | statstr = _ (/* process termination method */ "exit"); | ||
1737 | statcode = statusCode; | ||
1738 | } | ||
1739 | else if (statusType == GNUNET_OS_PROCESS_SIGNALED) | ||
1740 | { | ||
1741 | statstr = _ (/* process termination method */ "signal"); | ||
1742 | statcode = statusCode; | ||
1743 | } | ||
1744 | else | ||
1745 | { | ||
1746 | statstr = _ (/* process termination method */ "unknown"); | ||
1747 | statcode = 0; | ||
1748 | } | ||
1749 | if (0 != pos->killed_at.abs_value_us) | ||
1750 | { | ||
1751 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
1752 | _ ("Service `%s' took %s to terminate\n"), | ||
1753 | pos->name, | ||
1754 | GNUNET_STRINGS_relative_time_to_string ( | ||
1755 | GNUNET_TIME_absolute_get_duration (pos->killed_at), | ||
1756 | GNUNET_YES)); | ||
1757 | } | ||
1758 | GNUNET_OS_process_destroy (pos->proc); | ||
1759 | pos->proc = NULL; | ||
1760 | broadcast_status (pos->name, GNUNET_ARM_SERVICE_STOPPED, NULL); | ||
1761 | if (NULL != pos->killing_client) | ||
1762 | { | ||
1763 | signal_result (pos->killing_client, | ||
1684 | pos->name, | 1764 | pos->name, |
1685 | GNUNET_STRINGS_relative_time_to_string( | 1765 | pos->killing_client_request_id, |
1686 | GNUNET_TIME_absolute_get_duration(pos->killed_at), | 1766 | GNUNET_ARM_RESULT_STOPPED); |
1687 | GNUNET_YES)); | 1767 | pos->killing_client = NULL; |
1688 | } | 1768 | pos->killing_client_request_id = 0; |
1689 | GNUNET_OS_process_destroy(pos->proc); | 1769 | } |
1690 | pos->proc = NULL; | 1770 | if (GNUNET_YES != in_shutdown) |
1691 | broadcast_status(pos->name, GNUNET_ARM_SERVICE_STOPPED, NULL); | 1771 | { |
1692 | if (NULL != pos->killing_client) | 1772 | pos->last_exit_status = statcode; |
1693 | { | 1773 | if ((statusType == GNUNET_OS_PROCESS_EXITED) && (statcode == 0)) |
1694 | signal_result(pos->killing_client, | 1774 | { |
1695 | pos->name, | 1775 | /* process terminated normally, allow restart at any time */ |
1696 | pos->killing_client_request_id, | 1776 | pos->restart_at.abs_value_us = 0; |
1697 | GNUNET_ARM_RESULT_STOPPED); | 1777 | GNUNET_log ( |
1698 | pos->killing_client = NULL; | 1778 | GNUNET_ERROR_TYPE_INFO, |
1699 | pos->killing_client_request_id = 0; | 1779 | _ ("Service `%s' terminated normally, will restart at any time\n"), |
1700 | } | 1780 | pos->name); |
1701 | if (GNUNET_YES != in_shutdown) | 1781 | /* process can still be re-started on-demand, ensure it is re-started if there is demand */ |
1782 | for (sli = pos->listen_head; NULL != sli; sli = sli->next) | ||
1702 | { | 1783 | { |
1703 | if ((statusType == GNUNET_OS_PROCESS_EXITED) && (statcode == 0)) | 1784 | GNUNET_break (NULL == sli->accept_task); |
1704 | { | 1785 | sli->accept_task = |
1705 | /* process terminated normally, allow restart at any time */ | 1786 | GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
1706 | pos->restart_at.abs_value_us = 0; | 1787 | sli->listen_socket, |
1707 | GNUNET_log( | 1788 | &accept_connection, |
1708 | GNUNET_ERROR_TYPE_INFO, | 1789 | sli); |
1709 | _("Service `%s' terminated normally, will restart at any time\n"), | ||
1710 | pos->name); | ||
1711 | /* process can still be re-started on-demand, ensure it is re-started if there is demand */ | ||
1712 | for (sli = pos->listen_head; NULL != sli; sli = sli->next) | ||
1713 | { | ||
1714 | GNUNET_break(NULL == sli->accept_task); | ||
1715 | sli->accept_task = | ||
1716 | GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | ||
1717 | sli->listen_socket, | ||
1718 | &accept_connection, | ||
1719 | sli); | ||
1720 | } | ||
1721 | } | ||
1722 | else | ||
1723 | { | ||
1724 | GNUNET_log( | ||
1725 | GNUNET_ERROR_TYPE_INFO, | ||
1726 | _("Service `%s' terminated with status %s/%d, will restart in %s\n"), | ||
1727 | pos->name, | ||
1728 | statstr, | ||
1729 | statcode, | ||
1730 | GNUNET_STRINGS_relative_time_to_string(pos->backoff, GNUNET_YES)); | ||
1731 | { | ||
1732 | /* Reduce backoff based on runtime of the process, | ||
1733 | so that there is a cool-down if a process actually | ||
1734 | runs for a while. */ | ||
1735 | struct GNUNET_TIME_Relative runtime; | ||
1736 | unsigned int minutes; | ||
1737 | |||
1738 | runtime = GNUNET_TIME_absolute_get_duration(pos->restart_at); | ||
1739 | minutes = | ||
1740 | runtime.rel_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us; | ||
1741 | if (minutes > 31) | ||
1742 | pos->backoff = GNUNET_TIME_UNIT_ZERO; | ||
1743 | else | ||
1744 | pos->backoff.rel_value_us <<= minutes; | ||
1745 | } | ||
1746 | /* schedule restart */ | ||
1747 | pos->restart_at = GNUNET_TIME_relative_to_absolute(pos->backoff); | ||
1748 | pos->backoff = GNUNET_TIME_STD_BACKOFF(pos->backoff); | ||
1749 | if (NULL != child_restart_task) | ||
1750 | GNUNET_SCHEDULER_cancel(child_restart_task); | ||
1751 | child_restart_task = | ||
1752 | GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
1753 | &delayed_restart_task, | ||
1754 | NULL); | ||
1755 | } | ||
1756 | } | 1790 | } |
1791 | } | ||
1757 | else | 1792 | else |
1793 | { | ||
1794 | GNUNET_log ( | ||
1795 | GNUNET_ERROR_TYPE_WARNING, | ||
1796 | _ ("Service `%s' terminated with status %s/%d, will restart in %s\n"), | ||
1797 | pos->name, | ||
1798 | statstr, | ||
1799 | statcode, | ||
1800 | GNUNET_STRINGS_relative_time_to_string (pos->backoff, GNUNET_YES)); | ||
1758 | { | 1801 | { |
1759 | free_service(pos); | 1802 | /* Reduce backoff based on runtime of the process, |
1803 | so that there is a cool-down if a process actually | ||
1804 | runs for a while. */ | ||
1805 | struct GNUNET_TIME_Relative runtime; | ||
1806 | unsigned int minutes; | ||
1807 | |||
1808 | runtime = GNUNET_TIME_absolute_get_duration (pos->restart_at); | ||
1809 | minutes = | ||
1810 | runtime.rel_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us; | ||
1811 | if (minutes > 31) | ||
1812 | pos->backoff = GNUNET_TIME_UNIT_ZERO; | ||
1813 | else | ||
1814 | pos->backoff.rel_value_us <<= minutes; | ||
1760 | } | 1815 | } |
1816 | /* schedule restart */ | ||
1817 | pos->restart_at = GNUNET_TIME_relative_to_absolute (pos->backoff); | ||
1818 | pos->backoff = GNUNET_TIME_STD_BACKOFF (pos->backoff); | ||
1819 | if (NULL != child_restart_task) | ||
1820 | GNUNET_SCHEDULER_cancel (child_restart_task); | ||
1821 | child_restart_task = | ||
1822 | GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
1823 | &delayed_restart_task, | ||
1824 | NULL); | ||
1825 | } | ||
1761 | } | 1826 | } |
1827 | else | ||
1828 | { | ||
1829 | free_service (pos); | ||
1830 | } | ||
1831 | } | ||
1762 | child_death_task = | 1832 | child_death_task = |
1763 | GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL, | 1833 | GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, |
1764 | pr, | 1834 | pr, |
1765 | &maint_child_death, | 1835 | &maint_child_death, |
1766 | NULL); | 1836 | NULL); |
1767 | if ((NULL == running_head) && (GNUNET_YES == in_shutdown)) | 1837 | if ((NULL == running_head) && (GNUNET_YES == in_shutdown)) |
1768 | do_shutdown(); | 1838 | do_shutdown (); |
1769 | else if (GNUNET_YES == in_shutdown) | 1839 | else if (GNUNET_YES == in_shutdown) |
1770 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1840 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1771 | "Delaying shutdown after child's death, still have %u children\n", | 1841 | "Delaying shutdown after child's death, still have %u children\n", |
1772 | list_count(running_head)); | 1842 | list_count (running_head)); |
1773 | } | 1843 | } |
1774 | 1844 | ||
1775 | 1845 | ||
@@ -1778,17 +1848,17 @@ maint_child_death(void *cls) | |||
1778 | * respective handler by writing to the trigger pipe. | 1848 | * respective handler by writing to the trigger pipe. |
1779 | */ | 1849 | */ |
1780 | static void | 1850 | static void |
1781 | sighandler_child_death() | 1851 | sighandler_child_death () |
1782 | { | 1852 | { |
1783 | static char c; | 1853 | static char c; |
1784 | int old_errno = errno; /* back-up errno */ | 1854 | int old_errno = errno; /* back-up errno */ |
1785 | 1855 | ||
1786 | GNUNET_break( | 1856 | GNUNET_break ( |
1787 | 1 == | 1857 | 1 == |
1788 | GNUNET_DISK_file_write(GNUNET_DISK_pipe_handle(sigpipe, | 1858 | GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle (sigpipe, |
1789 | GNUNET_DISK_PIPE_END_WRITE), | 1859 | GNUNET_DISK_PIPE_END_WRITE), |
1790 | &c, | 1860 | &c, |
1791 | sizeof(c))); | 1861 | sizeof(c))); |
1792 | errno = old_errno; /* restore errno */ | 1862 | errno = old_errno; /* restore errno */ |
1793 | } | 1863 | } |
1794 | 1864 | ||
@@ -1802,7 +1872,7 @@ sighandler_child_death() | |||
1802 | * @return #GNUNET_OK (continue) | 1872 | * @return #GNUNET_OK (continue) |
1803 | */ | 1873 | */ |
1804 | static void | 1874 | static void |
1805 | setup_service(void *cls, const char *section) | 1875 | setup_service (void *cls, const char *section) |
1806 | { | 1876 | { |
1807 | struct ServiceList *sl; | 1877 | struct ServiceList *sl; |
1808 | char *binary; | 1878 | char *binary; |
@@ -1812,94 +1882,94 @@ setup_service(void *cls, const char *section) | |||
1812 | socklen_t *addr_lens; | 1882 | socklen_t *addr_lens; |
1813 | int ret; | 1883 | int ret; |
1814 | 1884 | ||
1815 | (void)cls; | 1885 | (void) cls; |
1816 | if (0 == strcasecmp(section, "arm")) | 1886 | if (0 == strcasecmp (section, "arm")) |
1817 | return; | 1887 | return; |
1818 | if (GNUNET_OK != | 1888 | if (GNUNET_OK != |
1819 | GNUNET_CONFIGURATION_get_value_string(cfg, section, "BINARY", &binary)) | 1889 | GNUNET_CONFIGURATION_get_value_string (cfg, section, "BINARY", &binary)) |
1820 | { | 1890 | { |
1821 | /* not a service section */ | 1891 | /* not a service section */ |
1822 | return; | 1892 | return; |
1823 | } | 1893 | } |
1824 | if ((GNUNET_YES == | 1894 | if ((GNUNET_YES == |
1825 | GNUNET_CONFIGURATION_have_value(cfg, section, "RUN_PER_USER")) && | 1895 | GNUNET_CONFIGURATION_have_value (cfg, section, "RUN_PER_USER")) && |
1826 | (GNUNET_YES == | 1896 | (GNUNET_YES == |
1827 | GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "RUN_PER_USER"))) | 1897 | GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "RUN_PER_USER"))) |
1898 | { | ||
1899 | if (GNUNET_NO == start_user) | ||
1828 | { | 1900 | { |
1829 | if (GNUNET_NO == start_user) | 1901 | GNUNET_free (binary); |
1830 | { | 1902 | return; /* user service, and we don't deal with those */ |
1831 | GNUNET_free(binary); | ||
1832 | return; /* user service, and we don't deal with those */ | ||
1833 | } | ||
1834 | } | 1903 | } |
1904 | } | ||
1835 | else | 1905 | else |
1906 | { | ||
1907 | if (GNUNET_NO == start_system) | ||
1836 | { | 1908 | { |
1837 | if (GNUNET_NO == start_system) | 1909 | GNUNET_free (binary); |
1838 | { | 1910 | return; /* system service, and we don't deal with those */ |
1839 | GNUNET_free(binary); | ||
1840 | return; /* system service, and we don't deal with those */ | ||
1841 | } | ||
1842 | } | 1911 | } |
1843 | sl = find_service(section); | 1912 | } |
1913 | sl = find_service (section); | ||
1844 | if (NULL != sl) | 1914 | if (NULL != sl) |
1845 | { | 1915 | { |
1846 | /* got the same section twice!? */ | 1916 | /* got the same section twice!? */ |
1847 | GNUNET_break(0); | 1917 | GNUNET_break (0); |
1848 | GNUNET_free(binary); | 1918 | GNUNET_free (binary); |
1849 | return; | 1919 | return; |
1850 | } | 1920 | } |
1851 | config = NULL; | 1921 | config = NULL; |
1852 | if (((GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg, | 1922 | if (((GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, |
1853 | section, | 1923 | section, |
1854 | "CONFIG", | 1924 | "CONFIG", |
1855 | &config)) && | 1925 | &config)) && |
1856 | (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg, | 1926 | (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, |
1857 | "PATHS", | 1927 | "PATHS", |
1858 | "DEFAULTCONFIG", | 1928 | "DEFAULTCONFIG", |
1859 | &config))) || | 1929 | &config))) || |
1860 | (0 != stat(config, &sbuf))) | 1930 | (0 != stat (config, &sbuf))) |
1931 | { | ||
1932 | if (NULL != config) | ||
1861 | { | 1933 | { |
1862 | if (NULL != config) | 1934 | GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING, |
1863 | { | 1935 | section, |
1864 | GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_WARNING, | 1936 | "CONFIG", |
1865 | section, | 1937 | strerror (errno)); |
1866 | "CONFIG", | 1938 | GNUNET_free (config); |
1867 | strerror(errno)); | 1939 | config = NULL; |
1868 | GNUNET_free(config); | ||
1869 | config = NULL; | ||
1870 | } | ||
1871 | } | 1940 | } |
1872 | sl = GNUNET_new(struct ServiceList); | 1941 | } |
1873 | sl->name = GNUNET_strdup(section); | 1942 | sl = GNUNET_new (struct ServiceList); |
1943 | sl->name = GNUNET_strdup (section); | ||
1874 | sl->binary = binary; | 1944 | sl->binary = binary; |
1875 | sl->config = config; | 1945 | sl->config = config; |
1876 | sl->backoff = GNUNET_TIME_UNIT_MILLISECONDS; | 1946 | sl->backoff = GNUNET_TIME_UNIT_MILLISECONDS; |
1877 | sl->restart_at = GNUNET_TIME_UNIT_FOREVER_ABS; | 1947 | sl->restart_at = GNUNET_TIME_UNIT_FOREVER_ABS; |
1878 | if (GNUNET_CONFIGURATION_have_value(cfg, section, "PIPECONTROL")) | 1948 | if (GNUNET_CONFIGURATION_have_value (cfg, section, "PIPECONTROL")) |
1879 | sl->pipe_control = | 1949 | sl->pipe_control = |
1880 | GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "PIPECONTROL"); | 1950 | GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "PIPECONTROL"); |
1881 | GNUNET_CONTAINER_DLL_insert(running_head, running_tail, sl); | 1951 | GNUNET_CONTAINER_DLL_insert (running_head, running_tail, sl); |
1882 | if (GNUNET_YES == | 1952 | if (GNUNET_YES == |
1883 | GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "IMMEDIATE_START")) | 1953 | GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "IMMEDIATE_START")) |
1884 | { | 1954 | { |
1885 | sl->force_start = GNUNET_YES; | 1955 | sl->force_start = GNUNET_YES; |
1886 | if (GNUNET_YES == | 1956 | if (GNUNET_YES == |
1887 | GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "NOARMBIND")) | 1957 | GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "NOARMBIND")) |
1888 | return; | 1958 | return; |
1889 | } | 1959 | } |
1890 | else | 1960 | else |
1891 | { | 1961 | { |
1892 | if (GNUNET_YES != | 1962 | if (GNUNET_YES != |
1893 | GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "START_ON_DEMAND")) | 1963 | GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "START_ON_DEMAND")) |
1894 | return; | 1964 | return; |
1895 | } | 1965 | } |
1896 | if (0 >= (ret = get_server_addresses(section, cfg, &addrs, &addr_lens))) | 1966 | if (0 >= (ret = get_server_addresses (section, cfg, &addrs, &addr_lens))) |
1897 | return; | 1967 | return; |
1898 | /* this will free (or capture) addrs[i] */ | 1968 | /* this will free (or capture) addrs[i] */ |
1899 | for (unsigned int i = 0; i < (unsigned int)ret; i++) | 1969 | for (unsigned int i = 0; i < (unsigned int) ret; i++) |
1900 | create_listen_socket(addrs[i], addr_lens[i], sl); | 1970 | create_listen_socket (addrs[i], addr_lens[i], sl); |
1901 | GNUNET_free(addrs); | 1971 | GNUNET_free (addrs); |
1902 | GNUNET_free(addr_lens); | 1972 | GNUNET_free (addr_lens); |
1903 | } | 1973 | } |
1904 | 1974 | ||
1905 | 1975 | ||
@@ -1912,16 +1982,16 @@ setup_service(void *cls, const char *section) | |||
1912 | * @return @a client | 1982 | * @return @a client |
1913 | */ | 1983 | */ |
1914 | static void * | 1984 | static void * |
1915 | client_connect_cb(void *cls, | 1985 | client_connect_cb (void *cls, |
1916 | struct GNUNET_SERVICE_Client *client, | 1986 | struct GNUNET_SERVICE_Client *client, |
1917 | struct GNUNET_MQ_Handle *mq) | 1987 | struct GNUNET_MQ_Handle *mq) |
1918 | { | 1988 | { |
1919 | /* All clients are considered to be of the "monitor" kind | 1989 | /* All clients are considered to be of the "monitor" kind |
1920 | * (that is, they don't affect ARM shutdown). | 1990 | * (that is, they don't affect ARM shutdown). |
1921 | */ | 1991 | */ |
1922 | (void)cls; | 1992 | (void) cls; |
1923 | (void)mq; | 1993 | (void) mq; |
1924 | GNUNET_SERVICE_client_mark_monitor(client); | 1994 | GNUNET_SERVICE_client_mark_monitor (client); |
1925 | return client; | 1995 | return client; |
1926 | } | 1996 | } |
1927 | 1997 | ||
@@ -1934,12 +2004,12 @@ client_connect_cb(void *cls, | |||
1934 | * @param app_ctx must match @a client | 2004 | * @param app_ctx must match @a client |
1935 | */ | 2005 | */ |
1936 | static void | 2006 | static void |
1937 | client_disconnect_cb(void *cls, | 2007 | client_disconnect_cb (void *cls, |
1938 | struct GNUNET_SERVICE_Client *client, | 2008 | struct GNUNET_SERVICE_Client *client, |
1939 | void *app_ctx) | 2009 | void *app_ctx) |
1940 | { | 2010 | { |
1941 | (void)cls; | 2011 | (void) cls; |
1942 | GNUNET_assert(client == app_ctx); | 2012 | GNUNET_assert (client == app_ctx); |
1943 | for (struct ServiceList *sl = running_head; NULL != sl; sl = sl->next) | 2013 | for (struct ServiceList *sl = running_head; NULL != sl; sl = sl->next) |
1944 | if (sl->killing_client == client) | 2014 | if (sl->killing_client == client) |
1945 | sl->killing_client = NULL; | 2015 | sl->killing_client = NULL; |
@@ -1955,18 +2025,18 @@ client_disconnect_cb(void *cls, | |||
1955 | * #GNUNET_SYSERR to close it (signal serious error) | 2025 | * #GNUNET_SYSERR to close it (signal serious error) |
1956 | */ | 2026 | */ |
1957 | static void | 2027 | static void |
1958 | handle_monitor(void *cls, const struct GNUNET_MessageHeader *message) | 2028 | handle_monitor (void *cls, const struct GNUNET_MessageHeader *message) |
1959 | { | 2029 | { |
1960 | struct GNUNET_SERVICE_Client *client = cls; | 2030 | struct GNUNET_SERVICE_Client *client = cls; |
1961 | 2031 | ||
1962 | (void)message; | 2032 | (void) message; |
1963 | /* FIXME: might want to start by letting monitor know about | 2033 | /* FIXME: might want to start by letting monitor know about |
1964 | services that are already running */ | 2034 | services that are already running */ |
1965 | /* Removal is handled by the server implementation, internally. */ | 2035 | /* Removal is handled by the server implementation, internally. */ |
1966 | GNUNET_notification_context_add(notifier, | 2036 | GNUNET_notification_context_add (notifier, |
1967 | GNUNET_SERVICE_client_get_mq(client)); | 2037 | GNUNET_SERVICE_client_get_mq (client)); |
1968 | broadcast_status("arm", GNUNET_ARM_SERVICE_MONITORING_STARTED, client); | 2038 | broadcast_status ("arm", GNUNET_ARM_SERVICE_MONITORING_STARTED, client); |
1969 | GNUNET_SERVICE_client_continue(client); | 2039 | GNUNET_SERVICE_client_continue (client); |
1970 | } | 2040 | } |
1971 | 2041 | ||
1972 | 2042 | ||
@@ -1978,71 +2048,71 @@ handle_monitor(void *cls, const struct GNUNET_MessageHeader *message) | |||
1978 | * @param c configuration to use | 2048 | * @param c configuration to use |
1979 | */ | 2049 | */ |
1980 | static void | 2050 | static void |
1981 | run(void *cls, | 2051 | run (void *cls, |
1982 | const struct GNUNET_CONFIGURATION_Handle *c, | 2052 | const struct GNUNET_CONFIGURATION_Handle *c, |
1983 | struct GNUNET_SERVICE_Handle *serv) | 2053 | struct GNUNET_SERVICE_Handle *serv) |
1984 | { | 2054 | { |
1985 | struct ServiceList *sl; | 2055 | struct ServiceList *sl; |
1986 | 2056 | ||
1987 | (void)cls; | 2057 | (void) cls; |
1988 | cfg = c; | 2058 | cfg = c; |
1989 | service = serv; | 2059 | service = serv; |
1990 | GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL); | 2060 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); |
1991 | child_death_task = GNUNET_SCHEDULER_add_read_file( | 2061 | child_death_task = GNUNET_SCHEDULER_add_read_file ( |
1992 | GNUNET_TIME_UNIT_FOREVER_REL, | 2062 | GNUNET_TIME_UNIT_FOREVER_REL, |
1993 | GNUNET_DISK_pipe_handle(sigpipe, GNUNET_DISK_PIPE_END_READ), | 2063 | GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ), |
1994 | &maint_child_death, | 2064 | &maint_child_death, |
1995 | NULL); | 2065 | NULL); |
1996 | #if HAVE_WAIT4 | 2066 | #if HAVE_WAIT4 |
1997 | if (GNUNET_OK == | 2067 | if (GNUNET_OK == |
1998 | GNUNET_CONFIGURATION_get_value_filename(cfg, | 2068 | GNUNET_CONFIGURATION_get_value_filename (cfg, |
1999 | "ARM", | 2069 | "ARM", |
2000 | "RESOURCE_DIAGNOSTICS", | 2070 | "RESOURCE_DIAGNOSTICS", |
2001 | &wait_filename)) | 2071 | &wait_filename)) |
2072 | { | ||
2073 | wait_file = fopen (wait_filename, "w"); | ||
2074 | if (NULL == wait_file) | ||
2002 | { | 2075 | { |
2003 | wait_file = fopen(wait_filename, "w"); | 2076 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, |
2004 | if (NULL == wait_file) | 2077 | "fopen", |
2005 | { | 2078 | wait_filename); |
2006 | GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, | ||
2007 | "fopen", | ||
2008 | wait_filename); | ||
2009 | } | ||
2010 | } | 2079 | } |
2080 | } | ||
2011 | #endif | 2081 | #endif |
2012 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, | 2082 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, |
2013 | "ARM", | 2083 | "ARM", |
2014 | "GLOBAL_PREFIX", | 2084 | "GLOBAL_PREFIX", |
2015 | &prefix_command)) | 2085 | &prefix_command)) |
2016 | prefix_command = GNUNET_strdup(""); | 2086 | prefix_command = GNUNET_strdup (""); |
2017 | else | 2087 | else |
2018 | prefix_command = GNUNET_CONFIGURATION_expand_dollar(cfg, prefix_command); | 2088 | prefix_command = GNUNET_CONFIGURATION_expand_dollar (cfg, prefix_command); |
2019 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, | 2089 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, |
2020 | "ARM", | 2090 | "ARM", |
2021 | "GLOBAL_POSTFIX", | 2091 | "GLOBAL_POSTFIX", |
2022 | &final_option)) | 2092 | &final_option)) |
2023 | final_option = GNUNET_strdup(""); | 2093 | final_option = GNUNET_strdup (""); |
2024 | else | 2094 | else |
2025 | final_option = GNUNET_CONFIGURATION_expand_dollar(cfg, final_option); | 2095 | final_option = GNUNET_CONFIGURATION_expand_dollar (cfg, final_option); |
2026 | start_user = | 2096 | start_user = |
2027 | GNUNET_CONFIGURATION_get_value_yesno(cfg, "ARM", "START_USER_SERVICES"); | 2097 | GNUNET_CONFIGURATION_get_value_yesno (cfg, "ARM", "START_USER_SERVICES"); |
2028 | start_system = | 2098 | start_system = |
2029 | GNUNET_CONFIGURATION_get_value_yesno(cfg, "ARM", "START_SYSTEM_SERVICES"); | 2099 | GNUNET_CONFIGURATION_get_value_yesno (cfg, "ARM", "START_SYSTEM_SERVICES"); |
2030 | if ((GNUNET_NO == start_user) && (GNUNET_NO == start_system)) | 2100 | if ((GNUNET_NO == start_user) && (GNUNET_NO == start_system)) |
2031 | { | 2101 | { |
2032 | GNUNET_log( | 2102 | GNUNET_log ( |
2033 | GNUNET_ERROR_TYPE_ERROR, | 2103 | GNUNET_ERROR_TYPE_ERROR, |
2034 | "Please configure either START_USER_SERVICES or START_SYSTEM_SERVICES or both.\n"); | 2104 | "Please configure either START_USER_SERVICES or START_SYSTEM_SERVICES or both.\n"); |
2035 | GNUNET_SCHEDULER_shutdown(); | 2105 | GNUNET_SCHEDULER_shutdown (); |
2036 | global_ret = 1; | 2106 | global_ret = 1; |
2037 | return; | 2107 | return; |
2038 | } | 2108 | } |
2039 | GNUNET_CONFIGURATION_iterate_sections(cfg, &setup_service, NULL); | 2109 | GNUNET_CONFIGURATION_iterate_sections (cfg, &setup_service, NULL); |
2040 | 2110 | ||
2041 | /* start default services... */ | 2111 | /* start default services... */ |
2042 | for (sl = running_head; NULL != sl; sl = sl->next) | 2112 | for (sl = running_head; NULL != sl; sl = sl->next) |
2043 | if (GNUNET_YES == sl->force_start) | 2113 | if (GNUNET_YES == sl->force_start) |
2044 | start_process(sl, NULL, 0); | 2114 | start_process (sl, NULL, 0); |
2045 | notifier = GNUNET_notification_context_create(MAX_NOTIFY_QUEUE); | 2115 | notifier = GNUNET_notification_context_create (MAX_NOTIFY_QUEUE); |
2046 | } | 2116 | } |
2047 | 2117 | ||
2048 | 2118 | ||
@@ -2054,61 +2124,64 @@ run(void *cls, | |||
2054 | * @return 0 ok, 1 on error | 2124 | * @return 0 ok, 1 on error |
2055 | */ | 2125 | */ |
2056 | int | 2126 | int |
2057 | main(int argc, char *const *argv) | 2127 | main (int argc, char *const *argv) |
2058 | { | 2128 | { |
2059 | struct GNUNET_SIGNAL_Context *shc_chld; | 2129 | struct GNUNET_SIGNAL_Context *shc_chld; |
2060 | struct GNUNET_MQ_MessageHandler handlers[] = | 2130 | struct GNUNET_MQ_MessageHandler handlers[] = { |
2061 | { GNUNET_MQ_hd_var_size(start, | 2131 | GNUNET_MQ_hd_var_size (start, |
2062 | GNUNET_MESSAGE_TYPE_ARM_START, | 2132 | GNUNET_MESSAGE_TYPE_ARM_START, |
2063 | struct GNUNET_ARM_Message, | 2133 | struct GNUNET_ARM_Message, |
2064 | NULL), | 2134 | NULL), |
2065 | GNUNET_MQ_hd_var_size(stop, | 2135 | GNUNET_MQ_hd_var_size (stop, |
2066 | GNUNET_MESSAGE_TYPE_ARM_STOP, | 2136 | GNUNET_MESSAGE_TYPE_ARM_STOP, |
2067 | struct GNUNET_ARM_Message, | 2137 | struct GNUNET_ARM_Message, |
2068 | NULL), | 2138 | NULL), |
2069 | GNUNET_MQ_hd_fixed_size(monitor, | 2139 | GNUNET_MQ_hd_fixed_size (monitor, |
2070 | GNUNET_MESSAGE_TYPE_ARM_MONITOR, | 2140 | GNUNET_MESSAGE_TYPE_ARM_MONITOR, |
2071 | struct GNUNET_MessageHeader, | 2141 | struct GNUNET_MessageHeader, |
2072 | NULL), | 2142 | NULL), |
2073 | GNUNET_MQ_hd_fixed_size(list, | 2143 | GNUNET_MQ_hd_fixed_size (list, |
2074 | GNUNET_MESSAGE_TYPE_ARM_LIST, | 2144 | GNUNET_MESSAGE_TYPE_ARM_LIST, |
2075 | struct GNUNET_ARM_Message, | 2145 | struct GNUNET_ARM_Message, |
2076 | NULL), | 2146 | NULL), |
2077 | GNUNET_MQ_hd_fixed_size(test, | 2147 | GNUNET_MQ_hd_fixed_size (test, |
2078 | GNUNET_MESSAGE_TYPE_ARM_TEST, | 2148 | GNUNET_MESSAGE_TYPE_ARM_TEST, |
2079 | struct GNUNET_MessageHeader, | 2149 | struct GNUNET_MessageHeader, |
2080 | NULL), | 2150 | NULL), |
2081 | GNUNET_MQ_handler_end() }; | 2151 | GNUNET_MQ_handler_end () |
2082 | 2152 | }; | |
2083 | sigpipe = GNUNET_DISK_pipe(GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO); | 2153 | |
2084 | GNUNET_assert(NULL != sigpipe); | 2154 | sigpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO); |
2155 | GNUNET_assert (NULL != sigpipe); | ||
2085 | shc_chld = | 2156 | shc_chld = |
2086 | GNUNET_SIGNAL_handler_install(GNUNET_SIGCHLD, &sighandler_child_death); | 2157 | GNUNET_SIGNAL_handler_install (GNUNET_SIGCHLD, |
2087 | if (0 != GNUNET_SERVICE_run_(argc, | 2158 | &sighandler_child_death); |
2088 | argv, | 2159 | if (0 != GNUNET_SERVICE_run_ (argc, |
2089 | "arm", | 2160 | argv, |
2090 | GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN, | 2161 | "arm", |
2091 | &run, | 2162 | GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN |
2092 | &client_connect_cb, | 2163 | | GNUNET_SERVICE_OPTION_CLOSE_LSOCKS, |
2093 | &client_disconnect_cb, | 2164 | &run, |
2094 | NULL, | 2165 | &client_connect_cb, |
2095 | handlers)) | 2166 | &client_disconnect_cb, |
2167 | NULL, | ||
2168 | handlers)) | ||
2096 | global_ret = 2; | 2169 | global_ret = 2; |
2097 | #if HAVE_WAIT4 | 2170 | #if HAVE_WAIT4 |
2098 | if (NULL != wait_file) | 2171 | if (NULL != wait_file) |
2099 | { | 2172 | { |
2100 | fclose(wait_file); | 2173 | fclose (wait_file); |
2101 | wait_file = NULL; | 2174 | wait_file = NULL; |
2102 | } | 2175 | } |
2103 | if (NULL != wait_filename) | 2176 | if (NULL != wait_filename) |
2104 | { | 2177 | { |
2105 | GNUNET_free(wait_filename); | 2178 | GNUNET_free (wait_filename); |
2106 | wait_filename = NULL; | 2179 | wait_filename = NULL; |
2107 | } | 2180 | } |
2108 | #endif | 2181 | #endif |
2109 | GNUNET_SIGNAL_handler_uninstall(shc_chld); | 2182 | GNUNET_SIGNAL_handler_uninstall (shc_chld); |
2110 | shc_chld = NULL; | 2183 | shc_chld = NULL; |
2111 | GNUNET_DISK_pipe_close(sigpipe); | 2184 | GNUNET_DISK_pipe_close (sigpipe); |
2112 | sigpipe = NULL; | 2185 | sigpipe = NULL; |
2113 | return global_ret; | 2186 | return global_ret; |
2114 | } | 2187 | } |
@@ -2120,11 +2193,11 @@ main(int argc, char *const *argv) | |||
2120 | /** | 2193 | /** |
2121 | * MINIMIZE heap size (way below 128k) since this process doesn't need much. | 2194 | * MINIMIZE heap size (way below 128k) since this process doesn't need much. |
2122 | */ | 2195 | */ |
2123 | void __attribute__ ((constructor)) GNUNET_ARM_memory_init() | 2196 | void __attribute__ ((constructor)) GNUNET_ARM_memory_init () |
2124 | { | 2197 | { |
2125 | mallopt(M_TRIM_THRESHOLD, 4 * 1024); | 2198 | mallopt (M_TRIM_THRESHOLD, 4 * 1024); |
2126 | mallopt(M_TOP_PAD, 1 * 1024); | 2199 | mallopt (M_TOP_PAD, 1 * 1024); |
2127 | malloc_trim(0); | 2200 | malloc_trim (0); |
2128 | } | 2201 | } |
2129 | #endif | 2202 | #endif |
2130 | 2203 | ||
diff --git a/src/arm/test_exponential_backoff.c b/src/arm/test_exponential_backoff.c index 8190d29c2..b13ab1cb8 100644 --- a/src/arm/test_exponential_backoff.c +++ b/src/arm/test_exponential_backoff.c | |||
@@ -196,7 +196,7 @@ arm_stop_cb(void *cls, | |||
196 | static void | 196 | static void |
197 | srv_status(void *cls, | 197 | srv_status(void *cls, |
198 | const char *service, | 198 | const char *service, |
199 | enum GNUNET_ARM_ServiceStatus status) | 199 | enum GNUNET_ARM_ServiceMonitorStatus status) |
200 | { | 200 | { |
201 | if (status == GNUNET_ARM_SERVICE_MONITORING_STARTED) | 201 | if (status == GNUNET_ARM_SERVICE_MONITORING_STARTED) |
202 | { | 202 | { |
diff --git a/src/arm/test_gnunet_service_arm.c b/src/arm/test_gnunet_service_arm.c index 8c8c664f9..cb2c14438 100644 --- a/src/arm/test_gnunet_service_arm.c +++ b/src/arm/test_gnunet_service_arm.c | |||
@@ -78,7 +78,7 @@ static void | |||
78 | service_list(void *cls, | 78 | service_list(void *cls, |
79 | enum GNUNET_ARM_RequestStatus rs, | 79 | enum GNUNET_ARM_RequestStatus rs, |
80 | unsigned int count, | 80 | unsigned int count, |
81 | const char *const*list) | 81 | const struct GNUNET_ARM_ServiceInfo *list) |
82 | { | 82 | { |
83 | unsigned int i; | 83 | unsigned int i; |
84 | 84 | ||
@@ -89,13 +89,13 @@ service_list(void *cls, | |||
89 | goto stop_arm; | 89 | goto stop_arm; |
90 | for (i = 0; i < count; i++) | 90 | for (i = 0; i < count; i++) |
91 | { | 91 | { |
92 | if (0 == strcasecmp(list[i], | 92 | if ((0 == strcasecmp(list[i].name, "resolver")) && |
93 | "resolver (gnunet-service-resolver)")) | 93 | (0 == strcasecmp(list[i].binary, "gnunet-service-resolver"))) |
94 | { | 94 | { |
95 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 95 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
96 | "Got service list, now stopping arm\n"); | 96 | "Got service list, now stopping arm\n"); |
97 | ret = 0; | 97 | ret = 0; |
98 | } | 98 | } |
99 | } | 99 | } |
100 | 100 | ||
101 | stop_arm: | 101 | stop_arm: |
diff --git a/src/datastore/plugin_datastore_mysql.c b/src/datastore/plugin_datastore_mysql.c index c670a6d99..cc5b558ee 100644 --- a/src/datastore/plugin_datastore_mysql.c +++ b/src/datastore/plugin_datastore_mysql.c | |||
@@ -77,7 +77,7 @@ | |||
77 | * Thats it. Note that .my.cnf file is a security risk unless its on | 77 | * Thats it. Note that .my.cnf file is a security risk unless its on |
78 | * a safe partition etc. The $HOME/.my.cnf can of course be a symbolic | 78 | * a safe partition etc. The $HOME/.my.cnf can of course be a symbolic |
79 | * link. Even greater security risk can be achieved by setting no | 79 | * link. Even greater security risk can be achieved by setting no |
80 | * password for $USER. Luckily $USER has only priviledges to mess | 80 | * password for $USER. Luckily $USER has only privileges to mess |
81 | * up GNUnet's tables, nothing else (unless you give them more, | 81 | * up GNUnet's tables, nothing else (unless you give them more, |
82 | * of course).<p> | 82 | * of course).<p> |
83 | * | 83 | * |
diff --git a/src/dns/gnunet-helper-dns.c b/src/dns/gnunet-helper-dns.c index 85c72579d..e837d81c6 100644 --- a/src/dns/gnunet-helper-dns.c +++ b/src/dns/gnunet-helper-dns.c | |||
@@ -499,7 +499,7 @@ set_address4(const char *dev, const char *address, const char *mask) | |||
499 | 499 | ||
500 | /** | 500 | /** |
501 | * Start forwarding to and from the tunnel. This function runs with | 501 | * Start forwarding to and from the tunnel. This function runs with |
502 | * "reduced" priviledges (saved UID is still 0, but effective UID is | 502 | * "reduced" privileges (saved UID is still 0, but effective UID is |
503 | * the real user ID). | 503 | * the real user ID). |
504 | * | 504 | * |
505 | * @param fd_tun tunnel FD | 505 | * @param fd_tun tunnel FD |
@@ -728,7 +728,7 @@ PROCESS_BUFFER: | |||
728 | * 25-39 failed to drop privs and then failed to undo some changes to routing table | 728 | * 25-39 failed to drop privs and then failed to undo some changes to routing table |
729 | * 40 failed to regain privs | 729 | * 40 failed to regain privs |
730 | * 41-55 failed to regain prisv and then failed to undo some changes to routing table | 730 | * 41-55 failed to regain prisv and then failed to undo some changes to routing table |
731 | * 254 insufficient priviledges | 731 | * 254 insufficient privileges |
732 | * 255 failed to handle kill signal properly | 732 | * 255 failed to handle kill signal properly |
733 | */ | 733 | */ |
734 | int | 734 | int |
diff --git a/src/gns/gnunet-gns.c b/src/gns/gnunet-gns.c index 352ccce04..5f4061f7d 100644 --- a/src/gns/gnunet-gns.c +++ b/src/gns/gnunet-gns.c | |||
@@ -90,24 +90,24 @@ static int global_ret; | |||
90 | * @param cls unused | 90 | * @param cls unused |
91 | */ | 91 | */ |
92 | static void | 92 | static void |
93 | do_shutdown(void *cls) | 93 | do_shutdown (void *cls) |
94 | { | 94 | { |
95 | (void)cls; | 95 | (void) cls; |
96 | if (NULL != to_task) | 96 | if (NULL != to_task) |
97 | { | 97 | { |
98 | GNUNET_SCHEDULER_cancel(to_task); | 98 | GNUNET_SCHEDULER_cancel (to_task); |
99 | to_task = NULL; | 99 | to_task = NULL; |
100 | } | 100 | } |
101 | if (NULL != lr) | 101 | if (NULL != lr) |
102 | { | 102 | { |
103 | GNUNET_GNS_lookup_with_tld_cancel(lr); | 103 | GNUNET_GNS_lookup_with_tld_cancel (lr); |
104 | lr = NULL; | 104 | lr = NULL; |
105 | } | 105 | } |
106 | if (NULL != gns) | 106 | if (NULL != gns) |
107 | { | 107 | { |
108 | GNUNET_GNS_disconnect(gns); | 108 | GNUNET_GNS_disconnect (gns); |
109 | gns = NULL; | 109 | gns = NULL; |
110 | } | 110 | } |
111 | } | 111 | } |
112 | 112 | ||
113 | /** | 113 | /** |
@@ -116,11 +116,11 @@ do_shutdown(void *cls) | |||
116 | * @param cls unused | 116 | * @param cls unused |
117 | */ | 117 | */ |
118 | static void | 118 | static void |
119 | do_timeout(void* cls) | 119 | do_timeout (void*cls) |
120 | { | 120 | { |
121 | to_task = NULL; | 121 | to_task = NULL; |
122 | global_ret = 3; //Timeout | 122 | global_ret = 3; // Timeout |
123 | GNUNET_SCHEDULER_shutdown(); | 123 | GNUNET_SCHEDULER_shutdown (); |
124 | } | 124 | } |
125 | 125 | ||
126 | /** | 126 | /** |
@@ -132,10 +132,10 @@ do_timeout(void* cls) | |||
132 | * @param rd array of @a rd_count records with the results | 132 | * @param rd array of @a rd_count records with the results |
133 | */ | 133 | */ |
134 | static void | 134 | static void |
135 | process_lookup_result(void *cls, | 135 | process_lookup_result (void *cls, |
136 | int was_gns, | 136 | int was_gns, |
137 | uint32_t rd_count, | 137 | uint32_t rd_count, |
138 | const struct GNUNET_GNSRECORD_Data *rd) | 138 | const struct GNUNET_GNSRECORD_Data *rd) |
139 | { | 139 | { |
140 | const char *name = cls; | 140 | const char *name = cls; |
141 | const char *typename; | 141 | const char *typename; |
@@ -143,41 +143,41 @@ process_lookup_result(void *cls, | |||
143 | 143 | ||
144 | lr = NULL; | 144 | lr = NULL; |
145 | if (GNUNET_NO == was_gns) | 145 | if (GNUNET_NO == was_gns) |
146 | { | 146 | { |
147 | global_ret = 4; /* not for GNS */ | 147 | global_ret = 4; /* not for GNS */ |
148 | GNUNET_SCHEDULER_shutdown(); | 148 | GNUNET_SCHEDULER_shutdown (); |
149 | return; | 149 | return; |
150 | } | 150 | } |
151 | if (!raw) | 151 | if (! raw) |
152 | { | 152 | { |
153 | if (0 == rd_count) | 153 | if (0 == rd_count) |
154 | printf("No results.\n"); | 154 | printf ("No results.\n"); |
155 | else | 155 | else |
156 | printf("%s:\n", name); | 156 | printf ("%s:\n", name); |
157 | } | 157 | } |
158 | for (uint32_t i = 0; i < rd_count; i++) | 158 | for (uint32_t i = 0; i < rd_count; i++) |
159 | { | ||
160 | if ((rd[i].record_type != rtype) && (GNUNET_GNSRECORD_TYPE_ANY != rtype)) | ||
161 | continue; | ||
162 | typename = GNUNET_GNSRECORD_number_to_typename (rd[i].record_type); | ||
163 | string_val = GNUNET_GNSRECORD_value_to_string (rd[i].record_type, | ||
164 | rd[i].data, | ||
165 | rd[i].data_size); | ||
166 | if (NULL == string_val) | ||
159 | { | 167 | { |
160 | if ((rd[i].record_type != rtype) && (GNUNET_GNSRECORD_TYPE_ANY != rtype)) | 168 | fprintf (stderr, |
161 | continue; | 169 | "Record %u of type %d malformed, skipping\n", |
162 | typename = GNUNET_GNSRECORD_number_to_typename(rd[i].record_type); | 170 | (unsigned int) i, |
163 | string_val = GNUNET_GNSRECORD_value_to_string(rd[i].record_type, | 171 | (int) rd[i].record_type); |
164 | rd[i].data, | 172 | continue; |
165 | rd[i].data_size); | ||
166 | if (NULL == string_val) | ||
167 | { | ||
168 | fprintf(stderr, | ||
169 | "Record %u of type %d malformed, skipping\n", | ||
170 | (unsigned int)i, | ||
171 | (int)rd[i].record_type); | ||
172 | continue; | ||
173 | } | ||
174 | if (raw) | ||
175 | printf("%s\n", string_val); | ||
176 | else | ||
177 | printf("Got `%s' record: %s\n", typename, string_val); | ||
178 | GNUNET_free(string_val); | ||
179 | } | 173 | } |
180 | GNUNET_SCHEDULER_shutdown(); | 174 | if (raw) |
175 | printf ("%s\n", string_val); | ||
176 | else | ||
177 | printf ("Got `%s' record: %s\n", typename, string_val); | ||
178 | GNUNET_free (string_val); | ||
179 | } | ||
180 | GNUNET_SCHEDULER_shutdown (); | ||
181 | } | 181 | } |
182 | 182 | ||
183 | 183 | ||
@@ -190,53 +190,69 @@ process_lookup_result(void *cls, | |||
190 | * @param c configuration | 190 | * @param c configuration |
191 | */ | 191 | */ |
192 | static void | 192 | static void |
193 | run(void *cls, | 193 | run (void *cls, |
194 | char *const *args, | 194 | char *const *args, |
195 | const char *cfgfile, | 195 | const char *cfgfile, |
196 | const struct GNUNET_CONFIGURATION_Handle *c) | 196 | const struct GNUNET_CONFIGURATION_Handle *c) |
197 | { | 197 | { |
198 | (void)cls; | 198 | (void) cls; |
199 | (void)args; | 199 | (void) args; |
200 | (void)cfgfile; | 200 | (void) cfgfile; |
201 | 201 | ||
202 | cfg = c; | 202 | cfg = c; |
203 | to_task = NULL; | 203 | to_task = NULL; |
204 | if (GNUNET_OK != GNUNET_DNSPARSER_check_name(lookup_name)) | 204 | if (GNUNET_OK != GNUNET_DNSPARSER_check_name (lookup_name)) |
205 | { | 205 | { |
206 | fprintf(stderr, _("`%s' is not a valid domain name\n"), lookup_name); | 206 | fprintf (stderr, |
207 | global_ret = 3; | 207 | _ ("`%s' is not a valid domain name\n"), |
208 | return; | 208 | lookup_name); |
209 | } | 209 | global_ret = 3; |
210 | to_task = GNUNET_SCHEDULER_add_delayed(timeout, &do_timeout, NULL); | 210 | return; |
211 | gns = GNUNET_GNS_connect(cfg); | 211 | } |
212 | if (GNUNET_YES != | ||
213 | GNUNET_CLIENT_test (cfg, | ||
214 | "arm")) | ||
215 | { | ||
216 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
217 | _ ("Cannot resolve using GNS: GNUnet peer not running\n")); | ||
218 | global_ret = 2; | ||
219 | return; | ||
220 | } | ||
221 | to_task = GNUNET_SCHEDULER_add_delayed (timeout, | ||
222 | &do_timeout, | ||
223 | NULL); | ||
224 | gns = GNUNET_GNS_connect (cfg); | ||
212 | if (NULL == gns) | 225 | if (NULL == gns) |
213 | { | 226 | { |
214 | fprintf(stderr, _("Failed to connect to GNS\n")); | 227 | fprintf (stderr, |
215 | global_ret = 2; | 228 | _ ("Failed to connect to GNS\n")); |
216 | return; | 229 | global_ret = 2; |
217 | } | 230 | return; |
218 | GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL); | 231 | } |
232 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, | ||
233 | NULL); | ||
219 | if (NULL != lookup_type) | 234 | if (NULL != lookup_type) |
220 | rtype = GNUNET_GNSRECORD_typename_to_number(lookup_type); | 235 | rtype = GNUNET_GNSRECORD_typename_to_number (lookup_type); |
221 | else | 236 | else |
222 | rtype = GNUNET_DNSPARSER_TYPE_A; | 237 | rtype = GNUNET_DNSPARSER_TYPE_A; |
223 | if (UINT32_MAX == rtype) | 238 | if (UINT32_MAX == rtype) |
224 | { | 239 | { |
225 | fprintf(stderr, _("Invalid typename specified, assuming `ANY'\n")); | 240 | fprintf (stderr, |
226 | rtype = GNUNET_GNSRECORD_TYPE_ANY; | 241 | _ ("Invalid typename specified, assuming `ANY'\n")); |
227 | } | 242 | rtype = GNUNET_GNSRECORD_TYPE_ANY; |
228 | lr = GNUNET_GNS_lookup_with_tld(gns, | 243 | } |
229 | lookup_name, | 244 | lr = GNUNET_GNS_lookup_with_tld (gns, |
230 | rtype, | 245 | lookup_name, |
231 | GNUNET_GNS_LO_DEFAULT, | 246 | rtype, |
232 | &process_lookup_result, | 247 | GNUNET_GNS_LO_DEFAULT, |
233 | lookup_name); | 248 | &process_lookup_result, |
249 | lookup_name); | ||
234 | if (NULL == lr) | 250 | if (NULL == lr) |
235 | { | 251 | { |
236 | global_ret = 2; | 252 | global_ret = 2; |
237 | GNUNET_SCHEDULER_shutdown(); | 253 | GNUNET_SCHEDULER_shutdown (); |
238 | return; | 254 | return; |
239 | } | 255 | } |
240 | } | 256 | } |
241 | 257 | ||
242 | 258 | ||
@@ -248,48 +264,50 @@ run(void *cls, | |||
248 | * @return 0 ok, 1 on error | 264 | * @return 0 ok, 1 on error |
249 | */ | 265 | */ |
250 | int | 266 | int |
251 | main(int argc, char *const *argv) | 267 | main (int argc, char *const *argv) |
252 | { | 268 | { |
253 | timeout = GNUNET_TIME_UNIT_FOREVER_REL; | 269 | timeout = GNUNET_TIME_UNIT_FOREVER_REL; |
254 | struct GNUNET_GETOPT_CommandLineOption options[] = | 270 | struct GNUNET_GETOPT_CommandLineOption options[] = |
255 | { GNUNET_GETOPT_option_mandatory( | 271 | { GNUNET_GETOPT_option_mandatory ( |
256 | GNUNET_GETOPT_option_string('u', | 272 | GNUNET_GETOPT_option_string ('u', |
257 | "lookup", | 273 | "lookup", |
258 | "NAME", | 274 | "NAME", |
259 | gettext_noop( | 275 | gettext_noop ( |
260 | "Lookup a record for the given name"), | 276 | "Lookup a record for the given name"), |
261 | &lookup_name)), | 277 | &lookup_name)), |
262 | GNUNET_GETOPT_option_string('t', | 278 | GNUNET_GETOPT_option_string ('t', |
263 | "type", | 279 | "type", |
264 | "TYPE", | 280 | "TYPE", |
265 | gettext_noop( | 281 | gettext_noop ( |
266 | "Specify the type of the record to lookup"), | 282 | "Specify the type of the record to lookup"), |
267 | &lookup_type), | 283 | &lookup_type), |
268 | GNUNET_GETOPT_option_relative_time('T', | 284 | GNUNET_GETOPT_option_relative_time ('T', |
269 | "timeout", | 285 | "timeout", |
270 | "TIMEOUT", | 286 | "TIMEOUT", |
271 | gettext_noop( | 287 | gettext_noop ( |
272 | "Specify a timeout for the lookup"), | 288 | "Specify a timeout for the lookup"), |
273 | &timeout), | 289 | &timeout), |
274 | GNUNET_GETOPT_option_flag('r', | 290 | GNUNET_GETOPT_option_flag ('r', |
275 | "raw", | 291 | "raw", |
276 | gettext_noop("No unneeded output"), | 292 | gettext_noop ("No unneeded output"), |
277 | &raw), | 293 | &raw), |
278 | GNUNET_GETOPT_OPTION_END }; | 294 | GNUNET_GETOPT_OPTION_END }; |
279 | int ret; | 295 | int ret; |
280 | 296 | ||
281 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv)) | 297 | if (GNUNET_OK != |
298 | GNUNET_STRINGS_get_utf8_args (argc, argv, | ||
299 | &argc, &argv)) | ||
282 | return 2; | 300 | return 2; |
283 | 301 | ||
284 | GNUNET_log_setup("gnunet-gns", "WARNING", NULL); | 302 | GNUNET_log_setup ("gnunet-gns", "WARNING", NULL); |
285 | ret = GNUNET_PROGRAM_run(argc, | 303 | ret = GNUNET_PROGRAM_run (argc, |
286 | argv, | 304 | argv, |
287 | "gnunet-gns", | 305 | "gnunet-gns", |
288 | _("GNUnet GNS resolver tool"), | 306 | _ ("GNUnet GNS resolver tool"), |
289 | options, | 307 | options, |
290 | &run, | 308 | &run, |
291 | NULL); | 309 | NULL); |
292 | GNUNET_free((void *)argv); | 310 | GNUNET_free ((void *) argv); |
293 | if (GNUNET_OK != ret) | 311 | if (GNUNET_OK != ret) |
294 | return 1; | 312 | return 1; |
295 | return global_ret; | 313 | return global_ret; |
diff --git a/src/include/gnunet_arm_service.h b/src/include/gnunet_arm_service.h index faf89128f..32355a3e5 100644 --- a/src/include/gnunet_arm_service.h +++ b/src/include/gnunet_arm_service.h | |||
@@ -70,7 +70,7 @@ enum GNUNET_ARM_RequestStatus { | |||
70 | /** | 70 | /** |
71 | * Statuses of services. | 71 | * Statuses of services. |
72 | */ | 72 | */ |
73 | enum GNUNET_ARM_ServiceStatus { | 73 | enum GNUNET_ARM_ServiceMonitorStatus { |
74 | /** | 74 | /** |
75 | * Dummy message. | 75 | * Dummy message. |
76 | */ | 76 | */ |
@@ -150,6 +150,78 @@ enum GNUNET_ARM_Result { | |||
150 | 150 | ||
151 | 151 | ||
152 | /** | 152 | /** |
153 | * Status of a service managed by ARM. | ||
154 | */ | ||
155 | enum GNUNET_ARM_ServiceStatus | ||
156 | { | ||
157 | /** | ||
158 | * Service is stopped. | ||
159 | */ | ||
160 | GNUNET_ARM_SERVICE_STATUS_STOPPED = 0, | ||
161 | |||
162 | /** | ||
163 | * Service has been started and is currently running. | ||
164 | */ | ||
165 | GNUNET_ARM_SERVICE_STATUS_STARTED = 1, | ||
166 | |||
167 | /** | ||
168 | * The service has previously failed, and | ||
169 | * will be restarted. | ||
170 | */ | ||
171 | GNUNET_ARM_SERVICE_STATUS_FAILED = 2, | ||
172 | |||
173 | /** | ||
174 | * The service was started, but then exited normally. | ||
175 | */ | ||
176 | GNUNET_ARM_SERVICE_STATUS_FINISHED = 3, | ||
177 | |||
178 | /** | ||
179 | * The service was started, and we're currently waiting | ||
180 | * for it to be stopped. | ||
181 | */ | ||
182 | GNUNET_ARM_SERVICE_STATUS_STOPPING = 4, | ||
183 | }; | ||
184 | |||
185 | |||
186 | /** | ||
187 | * Information about a service managed by ARM. | ||
188 | */ | ||
189 | struct GNUNET_ARM_ServiceInfo | ||
190 | { | ||
191 | /** | ||
192 | * The current status of the service. | ||
193 | */ | ||
194 | enum GNUNET_ARM_ServiceStatus status; | ||
195 | |||
196 | /** | ||
197 | * The name of the service. | ||
198 | */ | ||
199 | const char *name; | ||
200 | |||
201 | /** | ||
202 | * The binary used to execute the service. | ||
203 | */ | ||
204 | const char *binary; | ||
205 | |||
206 | /** | ||
207 | * Time when the sevice will be restarted, if applicable | ||
208 | * to the current status. | ||
209 | */ | ||
210 | struct GNUNET_TIME_Absolute restart_at; | ||
211 | |||
212 | /** | ||
213 | * Time when the sevice was first started, if applicable. | ||
214 | */ | ||
215 | struct GNUNET_TIME_Absolute last_started_at; | ||
216 | |||
217 | /** | ||
218 | * Last process exit status. | ||
219 | */ | ||
220 | int last_exit_status; | ||
221 | }; | ||
222 | |||
223 | |||
224 | /** | ||
153 | * Handle for interacting with ARM. | 225 | * Handle for interacting with ARM. |
154 | */ | 226 | */ |
155 | struct GNUNET_ARM_Handle; | 227 | struct GNUNET_ARM_Handle; |
@@ -197,13 +269,13 @@ typedef void | |||
197 | * @param cls closure | 269 | * @param cls closure |
198 | * @param rs status of the request | 270 | * @param rs status of the request |
199 | * @param count number of strings in the list | 271 | * @param count number of strings in the list |
200 | * @param list list of running services | 272 | * @param list list of services managed by arm |
201 | */ | 273 | */ |
202 | typedef void | 274 | typedef void |
203 | (*GNUNET_ARM_ServiceListCallback) (void *cls, | 275 | (*GNUNET_ARM_ServiceListCallback) (void *cls, |
204 | enum GNUNET_ARM_RequestStatus rs, | 276 | enum GNUNET_ARM_RequestStatus rs, |
205 | unsigned int count, | 277 | unsigned int count, |
206 | const char *const*list); | 278 | const struct GNUNET_ARM_ServiceInfo *list); |
207 | 279 | ||
208 | 280 | ||
209 | /** | 281 | /** |
@@ -309,9 +381,9 @@ struct GNUNET_ARM_MonitorHandle; | |||
309 | * @param status status of the service | 381 | * @param status status of the service |
310 | */ | 382 | */ |
311 | typedef void | 383 | typedef void |
312 | (*GNUNET_ARM_ServiceStatusCallback) (void *cls, | 384 | (*GNUNET_ARM_ServiceMonitorCallback) (void *cls, |
313 | const char *service, | 385 | const char *service, |
314 | enum GNUNET_ARM_ServiceStatus status); | 386 | enum GNUNET_ARM_ServiceMonitorStatus status); |
315 | 387 | ||
316 | 388 | ||
317 | /** | 389 | /** |
@@ -327,7 +399,7 @@ typedef void | |||
327 | */ | 399 | */ |
328 | struct GNUNET_ARM_MonitorHandle * | 400 | struct GNUNET_ARM_MonitorHandle * |
329 | GNUNET_ARM_monitor_start(const struct GNUNET_CONFIGURATION_Handle *cfg, | 401 | GNUNET_ARM_monitor_start(const struct GNUNET_CONFIGURATION_Handle *cfg, |
330 | GNUNET_ARM_ServiceStatusCallback cont, | 402 | GNUNET_ARM_ServiceMonitorCallback cont, |
331 | void *cont_cls); | 403 | void *cont_cls); |
332 | 404 | ||
333 | 405 | ||
diff --git a/src/include/gnunet_client_lib.h b/src/include/gnunet_client_lib.h index 8e4984124..9fc52724c 100644 --- a/src/include/gnunet_client_lib.h +++ b/src/include/gnunet_client_lib.h | |||
@@ -47,6 +47,23 @@ extern "C" | |||
47 | 47 | ||
48 | 48 | ||
49 | /** | 49 | /** |
50 | * Test if the port or UNIXPATH of the given @a service_name | ||
51 | * is in use and thus (most likely) the respective service is up. | ||
52 | * | ||
53 | * @param cfg our configuration | ||
54 | * @param service_name name of the service to connect to | ||
55 | * @return #GNUNET_YES if the service is (likely) up (or running remotely), | ||
56 | * #GNUNET_NO if the service is (definitively) down, | ||
57 | * #GNUNET_SYSERR if the configuration does not give us | ||
58 | * the necessary information about the service, or if | ||
59 | * we could not check (i.e. socket() failed) | ||
60 | */ | ||
61 | int | ||
62 | GNUNET_CLIENT_test (const struct GNUNET_CONFIGURATION_Handle *cfg, | ||
63 | const char *service_name); | ||
64 | |||
65 | |||
66 | /** | ||
50 | * Create a message queue to connect to a GNUnet service. | 67 | * Create a message queue to connect to a GNUnet service. |
51 | * If handlers are specfied, receive messages from the connection. | 68 | * If handlers are specfied, receive messages from the connection. |
52 | * | 69 | * |
@@ -57,11 +74,11 @@ extern "C" | |||
57 | * @return the message queue, NULL on error | 74 | * @return the message queue, NULL on error |
58 | */ | 75 | */ |
59 | struct GNUNET_MQ_Handle * | 76 | struct GNUNET_MQ_Handle * |
60 | GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, | 77 | GNUNET_CLIENT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, |
61 | const char *service_name, | 78 | const char *service_name, |
62 | const struct GNUNET_MQ_MessageHandler *handlers, | 79 | const struct GNUNET_MQ_MessageHandler *handlers, |
63 | GNUNET_MQ_ErrorHandler error_handler, | 80 | GNUNET_MQ_ErrorHandler error_handler, |
64 | void *error_handler_cls); | 81 | void *error_handler_cls); |
65 | 82 | ||
66 | 83 | ||
67 | #if 0 /* keep Emacsens' auto-indent happy */ | 84 | #if 0 /* keep Emacsens' auto-indent happy */ |
diff --git a/src/include/gnunet_disk_lib.h b/src/include/gnunet_disk_lib.h index d1e1e0333..9376a1059 100644 --- a/src/include/gnunet_disk_lib.h +++ b/src/include/gnunet_disk_lib.h | |||
@@ -38,7 +38,8 @@ struct GNUNET_DISK_PipeHandle; | |||
38 | /** | 38 | /** |
39 | * Type of a handle. | 39 | * Type of a handle. |
40 | */ | 40 | */ |
41 | enum GNUNET_FILE_Type { | 41 | enum GNUNET_FILE_Type |
42 | { | ||
42 | /** | 43 | /** |
43 | * Handle represents an event. | 44 | * Handle represents an event. |
44 | */ | 45 | */ |
@@ -58,7 +59,8 @@ enum GNUNET_FILE_Type { | |||
58 | /** | 59 | /** |
59 | * Handle used to access files (and pipes). | 60 | * Handle used to access files (and pipes). |
60 | */ | 61 | */ |
61 | struct GNUNET_DISK_FileHandle { | 62 | struct GNUNET_DISK_FileHandle |
63 | { | ||
62 | /** | 64 | /** |
63 | * File handle on Unix-like systems. | 65 | * File handle on Unix-like systems. |
64 | */ | 66 | */ |
@@ -86,7 +88,8 @@ extern "C" | |||
86 | /** | 88 | /** |
87 | * Specifies how a file should be opened. | 89 | * Specifies how a file should be opened. |
88 | */ | 90 | */ |
89 | enum GNUNET_DISK_OpenFlags { | 91 | enum GNUNET_DISK_OpenFlags |
92 | { | ||
90 | /** | 93 | /** |
91 | * Open the file for reading | 94 | * Open the file for reading |
92 | */ | 95 | */ |
@@ -126,7 +129,8 @@ enum GNUNET_DISK_OpenFlags { | |||
126 | /** | 129 | /** |
127 | * Specifies what type of memory map is desired. | 130 | * Specifies what type of memory map is desired. |
128 | */ | 131 | */ |
129 | enum GNUNET_DISK_MapType { | 132 | enum GNUNET_DISK_MapType |
133 | { | ||
130 | /** | 134 | /** |
131 | * Read-only memory map. | 135 | * Read-only memory map. |
132 | */ | 136 | */ |
@@ -147,7 +151,8 @@ enum GNUNET_DISK_MapType { | |||
147 | /** | 151 | /** |
148 | * File access permissions, UNIX-style. | 152 | * File access permissions, UNIX-style. |
149 | */ | 153 | */ |
150 | enum GNUNET_DISK_AccessPermissions { | 154 | enum GNUNET_DISK_AccessPermissions |
155 | { | ||
151 | /** | 156 | /** |
152 | * Nobody is allowed to do anything to the file. | 157 | * Nobody is allowed to do anything to the file. |
153 | */ | 158 | */ |
@@ -204,7 +209,8 @@ enum GNUNET_DISK_AccessPermissions { | |||
204 | * Constants for specifying how to seek. Do not change values or order, | 209 | * Constants for specifying how to seek. Do not change values or order, |
205 | * some of the code depends on the specific numeric values! | 210 | * some of the code depends on the specific numeric values! |
206 | */ | 211 | */ |
207 | enum GNUNET_DISK_Seek { | 212 | enum GNUNET_DISK_Seek |
213 | { | ||
208 | /** | 214 | /** |
209 | * Seek an absolute position (from the start of the file). | 215 | * Seek an absolute position (from the start of the file). |
210 | */ | 216 | */ |
@@ -225,7 +231,8 @@ enum GNUNET_DISK_Seek { | |||
225 | /** | 231 | /** |
226 | * Enumeration identifying the two ends of a pipe. | 232 | * Enumeration identifying the two ends of a pipe. |
227 | */ | 233 | */ |
228 | enum GNUNET_DISK_PipeEnd { | 234 | enum GNUNET_DISK_PipeEnd |
235 | { | ||
229 | /** | 236 | /** |
230 | * The reading-end of a pipe. | 237 | * The reading-end of a pipe. |
231 | */ | 238 | */ |
@@ -245,7 +252,7 @@ enum GNUNET_DISK_PipeEnd { | |||
245 | * @return #GNUNET_YES if invalid, #GNUNET_NO if valid | 252 | * @return #GNUNET_YES if invalid, #GNUNET_NO if valid |
246 | */ | 253 | */ |
247 | int | 254 | int |
248 | GNUNET_DISK_handle_invalid(const struct GNUNET_DISK_FileHandle *h); | 255 | GNUNET_DISK_handle_invalid (const struct GNUNET_DISK_FileHandle *h); |
249 | 256 | ||
250 | 257 | ||
251 | /** | 258 | /** |
@@ -257,7 +264,7 @@ GNUNET_DISK_handle_invalid(const struct GNUNET_DISK_FileHandle *h); | |||
257 | * else (will print an error message in that case, too). | 264 | * else (will print an error message in that case, too). |
258 | */ | 265 | */ |
259 | int | 266 | int |
260 | GNUNET_DISK_file_test(const char *fil); | 267 | GNUNET_DISK_file_test (const char *fil); |
261 | 268 | ||
262 | 269 | ||
263 | /** | 270 | /** |
@@ -268,7 +275,7 @@ GNUNET_DISK_file_test(const char *fil); | |||
268 | * @param fil name of the file to back up | 275 | * @param fil name of the file to back up |
269 | */ | 276 | */ |
270 | void | 277 | void |
271 | GNUNET_DISK_file_backup(const char *fil); | 278 | GNUNET_DISK_file_backup (const char *fil); |
272 | 279 | ||
273 | 280 | ||
274 | /** | 281 | /** |
@@ -279,8 +286,8 @@ GNUNET_DISK_file_backup(const char *fil); | |||
279 | * @return the new position on success, GNUNET_SYSERR otherwise | 286 | * @return the new position on success, GNUNET_SYSERR otherwise |
280 | */ | 287 | */ |
281 | off_t | 288 | off_t |
282 | GNUNET_DISK_file_seek(const struct GNUNET_DISK_FileHandle *h, off_t offset, | 289 | GNUNET_DISK_file_seek (const struct GNUNET_DISK_FileHandle *h, off_t offset, |
283 | enum GNUNET_DISK_Seek whence); | 290 | enum GNUNET_DISK_Seek whence); |
284 | 291 | ||
285 | 292 | ||
286 | /** | 293 | /** |
@@ -298,10 +305,10 @@ GNUNET_DISK_file_seek(const struct GNUNET_DISK_FileHandle *h, off_t offset, | |||
298 | * @return #GNUNET_SYSERR on error, #GNUNET_OK on success | 305 | * @return #GNUNET_SYSERR on error, #GNUNET_OK on success |
299 | */ | 306 | */ |
300 | int | 307 | int |
301 | GNUNET_DISK_file_size(const char *filename, | 308 | GNUNET_DISK_file_size (const char *filename, |
302 | uint64_t *size, | 309 | uint64_t *size, |
303 | int include_symbolic_links, | 310 | int include_symbolic_links, |
304 | int single_file_mode); | 311 | int single_file_mode); |
305 | 312 | ||
306 | 313 | ||
307 | /** | 314 | /** |
@@ -320,9 +327,9 @@ GNUNET_DISK_file_size(const char *filename, | |||
320 | * @return #GNUNET_OK on success | 327 | * @return #GNUNET_OK on success |
321 | */ | 328 | */ |
322 | int | 329 | int |
323 | GNUNET_DISK_file_get_identifiers(const char *filename, | 330 | GNUNET_DISK_file_get_identifiers (const char *filename, |
324 | uint64_t *dev, | 331 | uint64_t *dev, |
325 | uint64_t *ino); | 332 | uint64_t *ino); |
326 | 333 | ||
327 | 334 | ||
328 | /** | 335 | /** |
@@ -337,7 +344,7 @@ GNUNET_DISK_file_get_identifiers(const char *filename, | |||
337 | * file on disk in directory for temporary files | 344 | * file on disk in directory for temporary files |
338 | */ | 345 | */ |
339 | char * | 346 | char * |
340 | GNUNET_DISK_mktemp(const char *t); | 347 | GNUNET_DISK_mktemp (const char *t); |
341 | 348 | ||
342 | 349 | ||
343 | /** | 350 | /** |
@@ -350,7 +357,7 @@ GNUNET_DISK_mktemp(const char *t); | |||
350 | * @return NULL on error, otherwise name of freshly created directory | 357 | * @return NULL on error, otherwise name of freshly created directory |
351 | */ | 358 | */ |
352 | char * | 359 | char * |
353 | GNUNET_DISK_mkdtemp(const char *t); | 360 | GNUNET_DISK_mkdtemp (const char *t); |
354 | 361 | ||
355 | 362 | ||
356 | /** | 363 | /** |
@@ -366,9 +373,9 @@ GNUNET_DISK_mkdtemp(const char *t); | |||
366 | * @return IO handle on success, NULL on error | 373 | * @return IO handle on success, NULL on error |
367 | */ | 374 | */ |
368 | struct GNUNET_DISK_FileHandle * | 375 | struct GNUNET_DISK_FileHandle * |
369 | GNUNET_DISK_file_open(const char *fn, | 376 | GNUNET_DISK_file_open (const char *fn, |
370 | enum GNUNET_DISK_OpenFlags flags, | 377 | enum GNUNET_DISK_OpenFlags flags, |
371 | enum GNUNET_DISK_AccessPermissions perm); | 378 | enum GNUNET_DISK_AccessPermissions perm); |
372 | 379 | ||
373 | 380 | ||
374 | /** | 381 | /** |
@@ -379,8 +386,8 @@ GNUNET_DISK_file_open(const char *fn, | |||
379 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error | 386 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error |
380 | */ | 387 | */ |
381 | int | 388 | int |
382 | GNUNET_DISK_file_handle_size(struct GNUNET_DISK_FileHandle *fh, | 389 | GNUNET_DISK_file_handle_size (struct GNUNET_DISK_FileHandle *fh, |
383 | off_t *size); | 390 | off_t *size); |
384 | 391 | ||
385 | 392 | ||
386 | /** | 393 | /** |
@@ -393,10 +400,10 @@ GNUNET_DISK_file_handle_size(struct GNUNET_DISK_FileHandle *fh, | |||
393 | * @return handle to the new pipe, NULL on error | 400 | * @return handle to the new pipe, NULL on error |
394 | */ | 401 | */ |
395 | struct GNUNET_DISK_PipeHandle * | 402 | struct GNUNET_DISK_PipeHandle * |
396 | GNUNET_DISK_pipe(int blocking_read, | 403 | GNUNET_DISK_pipe (int blocking_read, |
397 | int blocking_write, | 404 | int blocking_write, |
398 | int inherit_read, | 405 | int inherit_read, |
399 | int inherit_write); | 406 | int inherit_write); |
400 | 407 | ||
401 | 408 | ||
402 | /** | 409 | /** |
@@ -410,9 +417,9 @@ GNUNET_DISK_pipe(int blocking_read, | |||
410 | * @return handle to the new pipe, NULL on error | 417 | * @return handle to the new pipe, NULL on error |
411 | */ | 418 | */ |
412 | struct GNUNET_DISK_PipeHandle * | 419 | struct GNUNET_DISK_PipeHandle * |
413 | GNUNET_DISK_pipe_from_fd(int blocking_read, | 420 | GNUNET_DISK_pipe_from_fd (int blocking_read, |
414 | int blocking_write, | 421 | int blocking_write, |
415 | int fd[2]); | 422 | int fd[2]); |
416 | 423 | ||
417 | 424 | ||
418 | /** | 425 | /** |
@@ -421,7 +428,7 @@ GNUNET_DISK_pipe_from_fd(int blocking_read, | |||
421 | * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise | 428 | * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise |
422 | */ | 429 | */ |
423 | int | 430 | int |
424 | GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p); | 431 | GNUNET_DISK_pipe_close (struct GNUNET_DISK_PipeHandle *p); |
425 | 432 | ||
426 | 433 | ||
427 | /** | 434 | /** |
@@ -432,8 +439,8 @@ GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p); | |||
432 | * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise | 439 | * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise |
433 | */ | 440 | */ |
434 | int | 441 | int |
435 | GNUNET_DISK_pipe_close_end(struct GNUNET_DISK_PipeHandle *p, | 442 | GNUNET_DISK_pipe_close_end (struct GNUNET_DISK_PipeHandle *p, |
436 | enum GNUNET_DISK_PipeEnd end); | 443 | enum GNUNET_DISK_PipeEnd end); |
437 | 444 | ||
438 | 445 | ||
439 | /** | 446 | /** |
@@ -449,8 +456,8 @@ GNUNET_DISK_pipe_close_end(struct GNUNET_DISK_PipeHandle *p, | |||
449 | * (or if that end is not present or is closed). | 456 | * (or if that end is not present or is closed). |
450 | */ | 457 | */ |
451 | struct GNUNET_DISK_FileHandle * | 458 | struct GNUNET_DISK_FileHandle * |
452 | GNUNET_DISK_pipe_detach_end(struct GNUNET_DISK_PipeHandle *p, | 459 | GNUNET_DISK_pipe_detach_end (struct GNUNET_DISK_PipeHandle *p, |
453 | enum GNUNET_DISK_PipeEnd end); | 460 | enum GNUNET_DISK_PipeEnd end); |
454 | 461 | ||
455 | /** | 462 | /** |
456 | * Close an open file. | 463 | * Close an open file. |
@@ -459,7 +466,7 @@ GNUNET_DISK_pipe_detach_end(struct GNUNET_DISK_PipeHandle *p, | |||
459 | * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise | 466 | * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise |
460 | */ | 467 | */ |
461 | int | 468 | int |
462 | GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h); | 469 | GNUNET_DISK_file_close (struct GNUNET_DISK_FileHandle *h); |
463 | 470 | ||
464 | 471 | ||
465 | /** | 472 | /** |
@@ -470,8 +477,8 @@ GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h); | |||
470 | * @return handle for the respective end | 477 | * @return handle for the respective end |
471 | */ | 478 | */ |
472 | const struct GNUNET_DISK_FileHandle * | 479 | const struct GNUNET_DISK_FileHandle * |
473 | GNUNET_DISK_pipe_handle(const struct GNUNET_DISK_PipeHandle *p, | 480 | GNUNET_DISK_pipe_handle (const struct GNUNET_DISK_PipeHandle *p, |
474 | enum GNUNET_DISK_PipeEnd n); | 481 | enum GNUNET_DISK_PipeEnd n); |
475 | 482 | ||
476 | /** | 483 | /** |
477 | * Update POSIX permissions mask of a file on disk. If both argumets | 484 | * Update POSIX permissions mask of a file on disk. If both argumets |
@@ -483,9 +490,9 @@ GNUNET_DISK_pipe_handle(const struct GNUNET_DISK_PipeHandle *p, | |||
483 | * @param require_gid_match #GNUNET_YES means 770 unless @a require_uid_match is set | 490 | * @param require_gid_match #GNUNET_YES means 770 unless @a require_uid_match is set |
484 | */ | 491 | */ |
485 | void | 492 | void |
486 | GNUNET_DISK_fix_permissions(const char *fn, | 493 | GNUNET_DISK_fix_permissions (const char *fn, |
487 | int require_uid_match, | 494 | int require_uid_match, |
488 | int require_gid_match); | 495 | int require_gid_match); |
489 | 496 | ||
490 | 497 | ||
491 | /** | 498 | /** |
@@ -495,7 +502,7 @@ GNUNET_DISK_fix_permissions(const char *fn, | |||
495 | * @return file handle corresponding to the descriptor | 502 | * @return file handle corresponding to the descriptor |
496 | */ | 503 | */ |
497 | struct GNUNET_DISK_FileHandle * | 504 | struct GNUNET_DISK_FileHandle * |
498 | GNUNET_DISK_get_handle_from_int_fd(int fno); | 505 | GNUNET_DISK_get_handle_from_int_fd (int fno); |
499 | 506 | ||
500 | 507 | ||
501 | /** | 508 | /** |
@@ -505,7 +512,7 @@ GNUNET_DISK_get_handle_from_int_fd(int fno); | |||
505 | * @return file handle corresponding to the descriptor | 512 | * @return file handle corresponding to the descriptor |
506 | */ | 513 | */ |
507 | struct GNUNET_DISK_FileHandle * | 514 | struct GNUNET_DISK_FileHandle * |
508 | GNUNET_DISK_get_handle_from_native(FILE *fd); | 515 | GNUNET_DISK_get_handle_from_native (FILE *fd); |
509 | 516 | ||
510 | 517 | ||
511 | /** | 518 | /** |
@@ -517,9 +524,9 @@ GNUNET_DISK_get_handle_from_native(FILE *fd); | |||
517 | * @return the number of bytes read on success, #GNUNET_SYSERR on failure | 524 | * @return the number of bytes read on success, #GNUNET_SYSERR on failure |
518 | */ | 525 | */ |
519 | ssize_t | 526 | ssize_t |
520 | GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, | 527 | GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle *h, |
521 | void *result, | 528 | void *result, |
522 | size_t len); | 529 | size_t len); |
523 | 530 | ||
524 | 531 | ||
525 | /** | 532 | /** |
@@ -533,9 +540,9 @@ GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, | |||
533 | * @return the number of bytes read on success, #GNUNET_SYSERR on failure | 540 | * @return the number of bytes read on success, #GNUNET_SYSERR on failure |
534 | */ | 541 | */ |
535 | ssize_t | 542 | ssize_t |
536 | GNUNET_DISK_file_read_non_blocking(const struct GNUNET_DISK_FileHandle * h, | 543 | GNUNET_DISK_file_read_non_blocking (const struct GNUNET_DISK_FileHandle *h, |
537 | void *result, | 544 | void *result, |
538 | size_t len); | 545 | size_t len); |
539 | 546 | ||
540 | 547 | ||
541 | /** | 548 | /** |
@@ -547,9 +554,9 @@ GNUNET_DISK_file_read_non_blocking(const struct GNUNET_DISK_FileHandle * h, | |||
547 | * @return number of bytes read, #GNUNET_SYSERR on failure | 554 | * @return number of bytes read, #GNUNET_SYSERR on failure |
548 | */ | 555 | */ |
549 | ssize_t | 556 | ssize_t |
550 | GNUNET_DISK_fn_read(const char *fn, | 557 | GNUNET_DISK_fn_read (const char *fn, |
551 | void *result, | 558 | void *result, |
552 | size_t len); | 559 | size_t len); |
553 | 560 | ||
554 | 561 | ||
555 | /** | 562 | /** |
@@ -561,9 +568,9 @@ GNUNET_DISK_fn_read(const char *fn, | |||
561 | * @return number of bytes written on success, #GNUNET_SYSERR on error | 568 | * @return number of bytes written on success, #GNUNET_SYSERR on error |
562 | */ | 569 | */ |
563 | ssize_t | 570 | ssize_t |
564 | GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, | 571 | GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle *h, |
565 | const void *buffer, | 572 | const void *buffer, |
566 | size_t n); | 573 | size_t n); |
567 | 574 | ||
568 | 575 | ||
569 | /** | 576 | /** |
@@ -575,9 +582,9 @@ GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, | |||
575 | * @return number of bytes written on success, #GNUNET_SYSERR on error | 582 | * @return number of bytes written on success, #GNUNET_SYSERR on error |
576 | */ | 583 | */ |
577 | ssize_t | 584 | ssize_t |
578 | GNUNET_DISK_file_write_blocking(const struct GNUNET_DISK_FileHandle *h, | 585 | GNUNET_DISK_file_write_blocking (const struct GNUNET_DISK_FileHandle *h, |
579 | const void *buffer, | 586 | const void *buffer, |
580 | size_t n); | 587 | size_t n); |
581 | 588 | ||
582 | 589 | ||
583 | /** | 590 | /** |
@@ -591,10 +598,10 @@ GNUNET_DISK_file_write_blocking(const struct GNUNET_DISK_FileHandle *h, | |||
591 | * @return number of bytes written on success, #GNUNET_SYSERR on error | 598 | * @return number of bytes written on success, #GNUNET_SYSERR on error |
592 | */ | 599 | */ |
593 | ssize_t | 600 | ssize_t |
594 | GNUNET_DISK_fn_write(const char *fn, | 601 | GNUNET_DISK_fn_write (const char *fn, |
595 | const void *buffer, | 602 | const void *buffer, |
596 | size_t n, | 603 | size_t n, |
597 | enum GNUNET_DISK_AccessPermissions mode); | 604 | enum GNUNET_DISK_AccessPermissions mode); |
598 | 605 | ||
599 | 606 | ||
600 | /** | 607 | /** |
@@ -605,8 +612,8 @@ GNUNET_DISK_fn_write(const char *fn, | |||
605 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error | 612 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error |
606 | */ | 613 | */ |
607 | int | 614 | int |
608 | GNUNET_DISK_file_copy(const char *src, | 615 | GNUNET_DISK_file_copy (const char *src, |
609 | const char *dst); | 616 | const char *dst); |
610 | 617 | ||
611 | 618 | ||
612 | /** | 619 | /** |
@@ -618,9 +625,9 @@ GNUNET_DISK_file_copy(const char *src, | |||
618 | * @return the number of files found, -1 on error | 625 | * @return the number of files found, -1 on error |
619 | */ | 626 | */ |
620 | int | 627 | int |
621 | GNUNET_DISK_directory_scan(const char *dir_name, | 628 | GNUNET_DISK_directory_scan (const char *dir_name, |
622 | GNUNET_FileNameCallback callback, | 629 | GNUNET_FileNameCallback callback, |
623 | void *callback_cls); | 630 | void *callback_cls); |
624 | 631 | ||
625 | 632 | ||
626 | /** | 633 | /** |
@@ -632,7 +639,7 @@ GNUNET_DISK_directory_scan(const char *dir_name, | |||
632 | * #GNUNET_NO if directory exists but is not writeable | 639 | * #GNUNET_NO if directory exists but is not writeable |
633 | */ | 640 | */ |
634 | int | 641 | int |
635 | GNUNET_DISK_directory_create_for_file(const char *filename); | 642 | GNUNET_DISK_directory_create_for_file (const char *filename); |
636 | 643 | ||
637 | 644 | ||
638 | /** | 645 | /** |
@@ -648,7 +655,7 @@ GNUNET_DISK_directory_create_for_file(const char *filename); | |||
648 | * does not exist or `stat`ed | 655 | * does not exist or `stat`ed |
649 | */ | 656 | */ |
650 | int | 657 | int |
651 | GNUNET_DISK_directory_test(const char *fil, int is_readable); | 658 | GNUNET_DISK_directory_test (const char *fil, int is_readable); |
652 | 659 | ||
653 | 660 | ||
654 | /** | 661 | /** |
@@ -659,7 +666,7 @@ GNUNET_DISK_directory_test(const char *fil, int is_readable); | |||
659 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error | 666 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error |
660 | */ | 667 | */ |
661 | int | 668 | int |
662 | GNUNET_DISK_directory_remove(const char *filename); | 669 | GNUNET_DISK_directory_remove (const char *filename); |
663 | 670 | ||
664 | 671 | ||
665 | /** | 672 | /** |
@@ -670,8 +677,8 @@ GNUNET_DISK_directory_remove(const char *filename); | |||
670 | * @param option option with the dir name to purge | 677 | * @param option option with the dir name to purge |
671 | */ | 678 | */ |
672 | void | 679 | void |
673 | GNUNET_DISK_purge_cfg_dir(const char *cfg_filename, | 680 | GNUNET_DISK_purge_cfg_dir (const char *cfg_filename, |
674 | const char *option); | 681 | const char *option); |
675 | 682 | ||
676 | 683 | ||
677 | /** | 684 | /** |
@@ -681,7 +688,7 @@ GNUNET_DISK_purge_cfg_dir(const char *cfg_filename, | |||
681 | * @returns #GNUNET_SYSERR on failure, #GNUNET_OK otherwise | 688 | * @returns #GNUNET_SYSERR on failure, #GNUNET_OK otherwise |
682 | */ | 689 | */ |
683 | int | 690 | int |
684 | GNUNET_DISK_directory_create(const char *dir); | 691 | GNUNET_DISK_directory_create (const char *dir); |
685 | 692 | ||
686 | 693 | ||
687 | /** | 694 | /** |
@@ -694,9 +701,9 @@ GNUNET_DISK_directory_create(const char *dir); | |||
694 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error | 701 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error |
695 | */ | 702 | */ |
696 | int | 703 | int |
697 | GNUNET_DISK_file_lock(struct GNUNET_DISK_FileHandle *fh, | 704 | GNUNET_DISK_file_lock (struct GNUNET_DISK_FileHandle *fh, |
698 | off_t lock_start, | 705 | off_t lock_start, |
699 | off_t lock_end, int excl); | 706 | off_t lock_end, int excl); |
700 | 707 | ||
701 | 708 | ||
702 | /** | 709 | /** |
@@ -708,9 +715,9 @@ GNUNET_DISK_file_lock(struct GNUNET_DISK_FileHandle *fh, | |||
708 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error | 715 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error |
709 | */ | 716 | */ |
710 | int | 717 | int |
711 | GNUNET_DISK_file_unlock(struct GNUNET_DISK_FileHandle *fh, | 718 | GNUNET_DISK_file_unlock (struct GNUNET_DISK_FileHandle *fh, |
712 | off_t unlock_start, | 719 | off_t unlock_start, |
713 | off_t unlock_end); | 720 | off_t unlock_end); |
714 | 721 | ||
715 | 722 | ||
716 | /** | 723 | /** |
@@ -718,7 +725,7 @@ GNUNET_DISK_file_unlock(struct GNUNET_DISK_FileHandle *fh, | |||
718 | * @param fn the filename to canonicalize | 725 | * @param fn the filename to canonicalize |
719 | */ | 726 | */ |
720 | void | 727 | void |
721 | GNUNET_DISK_filename_canonicalize(char *fn); | 728 | GNUNET_DISK_filename_canonicalize (char *fn); |
722 | 729 | ||
723 | 730 | ||
724 | /** | 731 | /** |
@@ -728,8 +735,8 @@ GNUNET_DISK_filename_canonicalize(char *fn); | |||
728 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure | 735 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure |
729 | */ | 736 | */ |
730 | int | 737 | int |
731 | GNUNET_DISK_file_change_owner(const char *filename, | 738 | GNUNET_DISK_file_change_owner (const char *filename, |
732 | const char *user); | 739 | const char *user); |
733 | 740 | ||
734 | 741 | ||
735 | /** | 742 | /** |
@@ -747,10 +754,10 @@ struct GNUNET_DISK_MapHandle; | |||
747 | * @return pointer to the mapped memory region, NULL on failure | 754 | * @return pointer to the mapped memory region, NULL on failure |
748 | */ | 755 | */ |
749 | void * | 756 | void * |
750 | GNUNET_DISK_file_map(const struct GNUNET_DISK_FileHandle *h, | 757 | GNUNET_DISK_file_map (const struct GNUNET_DISK_FileHandle *h, |
751 | struct GNUNET_DISK_MapHandle **m, | 758 | struct GNUNET_DISK_MapHandle **m, |
752 | enum GNUNET_DISK_MapType access, | 759 | enum GNUNET_DISK_MapType access, |
753 | size_t len); | 760 | size_t len); |
754 | 761 | ||
755 | 762 | ||
756 | /** | 763 | /** |
@@ -760,7 +767,7 @@ GNUNET_DISK_file_map(const struct GNUNET_DISK_FileHandle *h, | |||
760 | * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise | 767 | * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise |
761 | */ | 768 | */ |
762 | int | 769 | int |
763 | GNUNET_DISK_file_unmap(struct GNUNET_DISK_MapHandle *h); | 770 | GNUNET_DISK_file_unmap (struct GNUNET_DISK_MapHandle *h); |
764 | 771 | ||
765 | 772 | ||
766 | /** | 773 | /** |
@@ -770,7 +777,7 @@ GNUNET_DISK_file_unmap(struct GNUNET_DISK_MapHandle *h); | |||
770 | * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise | 777 | * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise |
771 | */ | 778 | */ |
772 | int | 779 | int |
773 | GNUNET_DISK_file_sync(const struct GNUNET_DISK_FileHandle *h); | 780 | GNUNET_DISK_file_sync (const struct GNUNET_DISK_FileHandle *h); |
774 | 781 | ||
775 | 782 | ||
776 | #if 0 /* keep Emacsens' auto-indent happy */ | 783 | #if 0 /* keep Emacsens' auto-indent happy */ |
diff --git a/src/include/gnunet_os_lib.h b/src/include/gnunet_os_lib.h index e5bc7146b..e4c0d6cdb 100644 --- a/src/include/gnunet_os_lib.h +++ b/src/include/gnunet_os_lib.h | |||
@@ -65,7 +65,8 @@ extern "C" | |||
65 | * Flags that determine which of the standard streams | 65 | * Flags that determine which of the standard streams |
66 | * should be inherited by the child process. | 66 | * should be inherited by the child process. |
67 | */ | 67 | */ |
68 | enum GNUNET_OS_InheritStdioFlags { | 68 | enum GNUNET_OS_InheritStdioFlags |
69 | { | ||
69 | /** | 70 | /** |
70 | * No standard streams should be inherited. | 71 | * No standard streams should be inherited. |
71 | */ | 72 | */ |
@@ -112,7 +113,8 @@ struct GNUNET_OS_Process; | |||
112 | /** | 113 | /** |
113 | * Possible installation paths to request | 114 | * Possible installation paths to request |
114 | */ | 115 | */ |
115 | enum GNUNET_OS_InstallationPathKind { | 116 | enum GNUNET_OS_InstallationPathKind |
117 | { | ||
116 | /** | 118 | /** |
117 | * Return the "PREFIX" directory given to configure. | 119 | * Return the "PREFIX" directory given to configure. |
118 | */ | 120 | */ |
@@ -166,7 +168,8 @@ enum GNUNET_OS_InstallationPathKind { | |||
166 | /** | 168 | /** |
167 | * Process status types | 169 | * Process status types |
168 | */ | 170 | */ |
169 | enum GNUNET_OS_ProcessStatusType { | 171 | enum GNUNET_OS_ProcessStatusType |
172 | { | ||
170 | /** | 173 | /** |
171 | * The process is not known to the OS (or at | 174 | * The process is not known to the OS (or at |
172 | * least not one of our children). | 175 | * least not one of our children). |
@@ -199,7 +202,8 @@ enum GNUNET_OS_ProcessStatusType { | |||
199 | * Project-specific data used to help the OS subsystem | 202 | * Project-specific data used to help the OS subsystem |
200 | * find installation paths. | 203 | * find installation paths. |
201 | */ | 204 | */ |
202 | struct GNUNET_OS_ProjectData { | 205 | struct GNUNET_OS_ProjectData |
206 | { | ||
203 | /** | 207 | /** |
204 | * Name of a library that is installed in the "lib/" directory of | 208 | * Name of a library that is installed in the "lib/" directory of |
205 | * the project, such as "libgnunetutil". Used to locate the | 209 | * the project, such as "libgnunetutil". Used to locate the |
@@ -290,14 +294,14 @@ struct GNUNET_OS_ProjectData { | |||
290 | * Return default project data used by 'libgnunetutil' for GNUnet. | 294 | * Return default project data used by 'libgnunetutil' for GNUnet. |
291 | */ | 295 | */ |
292 | const struct GNUNET_OS_ProjectData * | 296 | const struct GNUNET_OS_ProjectData * |
293 | GNUNET_OS_project_data_default(void); | 297 | GNUNET_OS_project_data_default (void); |
294 | 298 | ||
295 | 299 | ||
296 | /** | 300 | /** |
297 | * @return current (actual) project data. | 301 | * @return current (actual) project data. |
298 | */ | 302 | */ |
299 | const struct GNUNET_OS_ProjectData * | 303 | const struct GNUNET_OS_ProjectData * |
300 | GNUNET_OS_project_data_get(void); | 304 | GNUNET_OS_project_data_get (void); |
301 | 305 | ||
302 | 306 | ||
303 | /** | 307 | /** |
@@ -306,7 +310,7 @@ GNUNET_OS_project_data_get(void); | |||
306 | * @param pd project data used to determine paths. | 310 | * @param pd project data used to determine paths. |
307 | */ | 311 | */ |
308 | void | 312 | void |
309 | GNUNET_OS_init(const struct GNUNET_OS_ProjectData *pd); | 313 | GNUNET_OS_init (const struct GNUNET_OS_ProjectData *pd); |
310 | 314 | ||
311 | 315 | ||
312 | /** | 316 | /** |
@@ -318,7 +322,7 @@ GNUNET_OS_init(const struct GNUNET_OS_ProjectData *pd); | |||
318 | * @return a pointer to the dir path (to be freed by the caller) | 322 | * @return a pointer to the dir path (to be freed by the caller) |
319 | */ | 323 | */ |
320 | char * | 324 | char * |
321 | GNUNET_OS_installation_get_path(enum GNUNET_OS_InstallationPathKind dirkind); | 325 | GNUNET_OS_installation_get_path (enum GNUNET_OS_InstallationPathKind dirkind); |
322 | 326 | ||
323 | 327 | ||
324 | /** | 328 | /** |
@@ -330,7 +334,7 @@ GNUNET_OS_installation_get_path(enum GNUNET_OS_InstallationPathKind dirkind); | |||
330 | * @return full path to the binary, if possible, otherwise copy of 'progname' | 334 | * @return full path to the binary, if possible, otherwise copy of 'progname' |
331 | */ | 335 | */ |
332 | char * | 336 | char * |
333 | GNUNET_OS_get_libexec_binary_path(const char *progname); | 337 | GNUNET_OS_get_libexec_binary_path (const char *progname); |
334 | 338 | ||
335 | 339 | ||
336 | /** | 340 | /** |
@@ -346,8 +350,8 @@ GNUNET_OS_get_libexec_binary_path(const char *progname); | |||
346 | * otherwise | 350 | * otherwise |
347 | */ | 351 | */ |
348 | char * | 352 | char * |
349 | GNUNET_OS_get_suid_binary_path(const struct GNUNET_CONFIGURATION_Handle *cfg, | 353 | GNUNET_OS_get_suid_binary_path (const struct GNUNET_CONFIGURATION_Handle *cfg, |
350 | const char *progname); | 354 | const char *progname); |
351 | 355 | ||
352 | 356 | ||
353 | /** | 357 | /** |
@@ -379,14 +383,16 @@ typedef int | |||
379 | * @param proc_cls closure for @a proc | 383 | * @param proc_cls closure for @a proc |
380 | */ | 384 | */ |
381 | void | 385 | void |
382 | GNUNET_OS_network_interfaces_list(GNUNET_OS_NetworkInterfaceProcessor proc, | 386 | GNUNET_OS_network_interfaces_list (GNUNET_OS_NetworkInterfaceProcessor proc, |
383 | void *proc_cls); | 387 | void *proc_cls); |
384 | 388 | ||
385 | /** | 389 | /** |
386 | * @brief Get maximum string length returned by gethostname() | 390 | * @brief Get maximum string length returned by gethostname() |
387 | */ | 391 | */ |
388 | #if HAVE_SYSCONF && defined(_SC_HOST_NAME_MAX) | 392 | #if HAVE_SYSCONF && defined(_SC_HOST_NAME_MAX) |
389 | #define GNUNET_OS_get_hostname_max_length() ({ int __sc_tmp = sysconf(_SC_HOST_NAME_MAX); __sc_tmp <= 0 ? 255 : __sc_tmp; }) | 393 | #define GNUNET_OS_get_hostname_max_length() ({ int __sc_tmp = sysconf ( \ |
394 | _SC_HOST_NAME_MAX); __sc_tmp <= \ | ||
395 | 0 ? 255 : __sc_tmp; }) | ||
390 | #elif defined(HOST_NAME_MAX) | 396 | #elif defined(HOST_NAME_MAX) |
391 | #define GNUNET_OS_get_hostname_max_length() HOST_NAME_MAX | 397 | #define GNUNET_OS_get_hostname_max_length() HOST_NAME_MAX |
392 | #else | 398 | #else |
@@ -403,7 +409,7 @@ GNUNET_OS_network_interfaces_list(GNUNET_OS_NetworkInterfaceProcessor proc, | |||
403 | * @return pointer to the process sturcutre for this process | 409 | * @return pointer to the process sturcutre for this process |
404 | */ | 410 | */ |
405 | struct GNUNET_OS_Process * | 411 | struct GNUNET_OS_Process * |
406 | GNUNET_OS_process_current(void); | 412 | GNUNET_OS_process_current (void); |
407 | 413 | ||
408 | 414 | ||
409 | /** | 415 | /** |
@@ -414,8 +420,8 @@ GNUNET_OS_process_current(void); | |||
414 | * @return 0 on success, -1 on error | 420 | * @return 0 on success, -1 on error |
415 | */ | 421 | */ |
416 | int | 422 | int |
417 | GNUNET_OS_process_kill(struct GNUNET_OS_Process *proc, | 423 | GNUNET_OS_process_kill (struct GNUNET_OS_Process *proc, |
418 | int sig); | 424 | int sig); |
419 | 425 | ||
420 | 426 | ||
421 | /** | 427 | /** |
@@ -424,7 +430,7 @@ GNUNET_OS_process_kill(struct GNUNET_OS_Process *proc, | |||
424 | * @param proc pointer to process structure | 430 | * @param proc pointer to process structure |
425 | */ | 431 | */ |
426 | void | 432 | void |
427 | GNUNET_OS_process_destroy(struct GNUNET_OS_Process *proc); | 433 | GNUNET_OS_process_destroy (struct GNUNET_OS_Process *proc); |
428 | 434 | ||
429 | 435 | ||
430 | /** | 436 | /** |
@@ -435,7 +441,7 @@ GNUNET_OS_process_destroy(struct GNUNET_OS_Process *proc); | |||
435 | * @return the current process id | 441 | * @return the current process id |
436 | */ | 442 | */ |
437 | pid_t | 443 | pid_t |
438 | GNUNET_OS_process_get_pid(struct GNUNET_OS_Process *proc); | 444 | GNUNET_OS_process_get_pid (struct GNUNET_OS_Process *proc); |
439 | 445 | ||
440 | 446 | ||
441 | /** | 447 | /** |
@@ -451,13 +457,13 @@ GNUNET_OS_process_get_pid(struct GNUNET_OS_Process *proc); | |||
451 | * @return pointer to process structure of the new process, NULL on error | 457 | * @return pointer to process structure of the new process, NULL on error |
452 | */ | 458 | */ |
453 | struct GNUNET_OS_Process * | 459 | struct GNUNET_OS_Process * |
454 | GNUNET_OS_start_process_vap(int pipe_control, | 460 | GNUNET_OS_start_process_vap (int pipe_control, |
455 | enum GNUNET_OS_InheritStdioFlags std_inheritance, | 461 | enum GNUNET_OS_InheritStdioFlags std_inheritance, |
456 | struct GNUNET_DISK_PipeHandle *pipe_stdin, | 462 | struct GNUNET_DISK_PipeHandle *pipe_stdin, |
457 | struct GNUNET_DISK_PipeHandle *pipe_stdout, | 463 | struct GNUNET_DISK_PipeHandle *pipe_stdout, |
458 | struct GNUNET_DISK_PipeHandle *pipe_stderr, | 464 | struct GNUNET_DISK_PipeHandle *pipe_stderr, |
459 | const char *filename, | 465 | const char *filename, |
460 | char *const argv[]); | 466 | char *const argv[]); |
461 | 467 | ||
462 | 468 | ||
463 | /** | 469 | /** |
@@ -473,12 +479,12 @@ GNUNET_OS_start_process_vap(int pipe_control, | |||
473 | * @return pointer to process structure of the new process, NULL on error | 479 | * @return pointer to process structure of the new process, NULL on error |
474 | */ | 480 | */ |
475 | struct GNUNET_OS_Process * | 481 | struct GNUNET_OS_Process * |
476 | GNUNET_OS_start_process(int pipe_control, | 482 | GNUNET_OS_start_process (int pipe_control, |
477 | enum GNUNET_OS_InheritStdioFlags std_inheritance, | 483 | enum GNUNET_OS_InheritStdioFlags std_inheritance, |
478 | struct GNUNET_DISK_PipeHandle *pipe_stdin, | 484 | struct GNUNET_DISK_PipeHandle *pipe_stdin, |
479 | struct GNUNET_DISK_PipeHandle *pipe_stdout, | 485 | struct GNUNET_DISK_PipeHandle *pipe_stdout, |
480 | struct GNUNET_DISK_PipeHandle *pipe_stderr, | 486 | struct GNUNET_DISK_PipeHandle *pipe_stderr, |
481 | const char *filename, ...); | 487 | const char *filename, ...); |
482 | 488 | ||
483 | 489 | ||
484 | /** | 490 | /** |
@@ -494,12 +500,12 @@ GNUNET_OS_start_process(int pipe_control, | |||
494 | * @return pointer to process structure of the new process, NULL on error | 500 | * @return pointer to process structure of the new process, NULL on error |
495 | */ | 501 | */ |
496 | struct GNUNET_OS_Process * | 502 | struct GNUNET_OS_Process * |
497 | GNUNET_OS_start_process_va(int pipe_control, | 503 | GNUNET_OS_start_process_va (int pipe_control, |
498 | enum GNUNET_OS_InheritStdioFlags std_inheritance, | 504 | enum GNUNET_OS_InheritStdioFlags std_inheritance, |
499 | struct GNUNET_DISK_PipeHandle *pipe_stdin, | 505 | struct GNUNET_DISK_PipeHandle *pipe_stdin, |
500 | struct GNUNET_DISK_PipeHandle *pipe_stdout, | 506 | struct GNUNET_DISK_PipeHandle *pipe_stdout, |
501 | struct GNUNET_DISK_PipeHandle *pipe_stderr, | 507 | struct GNUNET_DISK_PipeHandle *pipe_stderr, |
502 | const char *filename, va_list va); | 508 | const char *filename, va_list va); |
503 | 509 | ||
504 | /** | 510 | /** |
505 | * Start a process. | 511 | * Start a process. |
@@ -514,11 +520,11 @@ GNUNET_OS_start_process_va(int pipe_control, | |||
514 | * @return pointer to process structure of the new process, NULL on error | 520 | * @return pointer to process structure of the new process, NULL on error |
515 | */ | 521 | */ |
516 | struct GNUNET_OS_Process * | 522 | struct GNUNET_OS_Process * |
517 | GNUNET_OS_start_process_v(int pipe_control, | 523 | GNUNET_OS_start_process_v (int pipe_control, |
518 | enum GNUNET_OS_InheritStdioFlags std_inheritance, | 524 | enum GNUNET_OS_InheritStdioFlags std_inheritance, |
519 | const SOCKTYPE *lsocks, | 525 | const SOCKTYPE *lsocks, |
520 | const char *filename, | 526 | const char *filename, |
521 | char *const argv[]); | 527 | char *const argv[]); |
522 | 528 | ||
523 | 529 | ||
524 | /** | 530 | /** |
@@ -540,10 +546,10 @@ GNUNET_OS_start_process_v(int pipe_control, | |||
540 | * @return pointer to process structure of the new process, NULL on error | 546 | * @return pointer to process structure of the new process, NULL on error |
541 | */ | 547 | */ |
542 | struct GNUNET_OS_Process * | 548 | struct GNUNET_OS_Process * |
543 | GNUNET_OS_start_process_s(int pipe_control, | 549 | GNUNET_OS_start_process_s (int pipe_control, |
544 | unsigned int std_inheritance, | 550 | unsigned int std_inheritance, |
545 | const SOCKTYPE * lsocks, | 551 | const SOCKTYPE *lsocks, |
546 | const char *filename, ...); | 552 | const char *filename, ...); |
547 | 553 | ||
548 | 554 | ||
549 | /** | 555 | /** |
@@ -568,7 +574,7 @@ typedef void | |||
568 | * @param cmd handle to the process | 574 | * @param cmd handle to the process |
569 | */ | 575 | */ |
570 | void | 576 | void |
571 | GNUNET_OS_command_stop(struct GNUNET_OS_CommandHandle *cmd); | 577 | GNUNET_OS_command_stop (struct GNUNET_OS_CommandHandle *cmd); |
572 | 578 | ||
573 | 579 | ||
574 | /** | 580 | /** |
@@ -583,11 +589,11 @@ GNUNET_OS_command_stop(struct GNUNET_OS_CommandHandle *cmd); | |||
583 | * @return NULL on error | 589 | * @return NULL on error |
584 | */ | 590 | */ |
585 | struct GNUNET_OS_CommandHandle * | 591 | struct GNUNET_OS_CommandHandle * |
586 | GNUNET_OS_command_run(GNUNET_OS_LineProcessor proc, | 592 | GNUNET_OS_command_run (GNUNET_OS_LineProcessor proc, |
587 | void *proc_cls, | 593 | void *proc_cls, |
588 | struct GNUNET_TIME_Relative timeout, | 594 | struct GNUNET_TIME_Relative timeout, |
589 | const char *binary, | 595 | const char *binary, |
590 | ...); | 596 | ...); |
591 | 597 | ||
592 | 598 | ||
593 | /** | 599 | /** |
@@ -600,9 +606,9 @@ GNUNET_OS_command_run(GNUNET_OS_LineProcessor proc, | |||
600 | * @return #GNUNET_OK on success, #GNUNET_NO if the process is still running, #GNUNET_SYSERR otherwise | 606 | * @return #GNUNET_OK on success, #GNUNET_NO if the process is still running, #GNUNET_SYSERR otherwise |
601 | */ | 607 | */ |
602 | int | 608 | int |
603 | GNUNET_OS_process_status(struct GNUNET_OS_Process *proc, | 609 | GNUNET_OS_process_status (struct GNUNET_OS_Process *proc, |
604 | enum GNUNET_OS_ProcessStatusType *type, | 610 | enum GNUNET_OS_ProcessStatusType *type, |
605 | unsigned long *code); | 611 | unsigned long *code); |
606 | 612 | ||
607 | 613 | ||
608 | /** | 614 | /** |
@@ -616,7 +622,7 @@ GNUNET_OS_process_status(struct GNUNET_OS_Process *proc, | |||
616 | * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise | 622 | * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise |
617 | */ | 623 | */ |
618 | int | 624 | int |
619 | GNUNET_OS_process_wait(struct GNUNET_OS_Process *proc); | 625 | GNUNET_OS_process_wait (struct GNUNET_OS_Process *proc); |
620 | 626 | ||
621 | 627 | ||
622 | 628 | ||
@@ -630,9 +636,9 @@ GNUNET_OS_process_wait(struct GNUNET_OS_Process *proc); | |||
630 | * @return #GNUNET_OK on success, #GNUNET_NO if the process is still running, #GNUNET_SYSERR otherwise | 636 | * @return #GNUNET_OK on success, #GNUNET_NO if the process is still running, #GNUNET_SYSERR otherwise |
631 | */ | 637 | */ |
632 | int | 638 | int |
633 | GNUNET_OS_process_wait_status(struct GNUNET_OS_Process *proc, | 639 | GNUNET_OS_process_wait_status (struct GNUNET_OS_Process *proc, |
634 | enum GNUNET_OS_ProcessStatusType *type, | 640 | enum GNUNET_OS_ProcessStatusType *type, |
635 | unsigned long *code); | 641 | unsigned long *code); |
636 | 642 | ||
637 | 643 | ||
638 | /** | 644 | /** |
@@ -644,7 +650,7 @@ GNUNET_OS_process_wait_status(struct GNUNET_OS_Process *proc, | |||
644 | * @param cls closure (unused) | 650 | * @param cls closure (unused) |
645 | */ | 651 | */ |
646 | void | 652 | void |
647 | GNUNET_OS_install_parent_control_handler(void *cls); | 653 | GNUNET_OS_install_parent_control_handler (void *cls); |
648 | 654 | ||
649 | 655 | ||
650 | /** | 656 | /** |
@@ -665,9 +671,9 @@ GNUNET_OS_install_parent_control_handler(void *cls); | |||
665 | * #GNUNET_SYSERR on error (no such binary or not executable) | 671 | * #GNUNET_SYSERR on error (no such binary or not executable) |
666 | */ | 672 | */ |
667 | int | 673 | int |
668 | GNUNET_OS_check_helper_binary(const char *binary, | 674 | GNUNET_OS_check_helper_binary (const char *binary, |
669 | int check_suid, | 675 | int check_suid, |
670 | const char *params); | 676 | const char *params); |
671 | 677 | ||
672 | 678 | ||
673 | #if 0 /* keep Emacsens' auto-indent happy */ | 679 | #if 0 /* keep Emacsens' auto-indent happy */ |
diff --git a/src/include/gnunet_scheduler_lib.h b/src/include/gnunet_scheduler_lib.h index 39b16a1b4..da968737e 100644 --- a/src/include/gnunet_scheduler_lib.h +++ b/src/include/gnunet_scheduler_lib.h | |||
@@ -52,7 +52,8 @@ struct GNUNET_SCHEDULER_Task; | |||
52 | * Reasons why the schedule may have triggered | 52 | * Reasons why the schedule may have triggered |
53 | * the task now. | 53 | * the task now. |
54 | */ | 54 | */ |
55 | enum GNUNET_SCHEDULER_Reason { | 55 | enum GNUNET_SCHEDULER_Reason |
56 | { | ||
56 | /** | 57 | /** |
57 | * This task is not ready. | 58 | * This task is not ready. |
58 | */ | 59 | */ |
@@ -99,7 +100,8 @@ enum GNUNET_SCHEDULER_Reason { | |||
99 | * Possible events on FDs, used as a bitmask. | 100 | * Possible events on FDs, used as a bitmask. |
100 | * Modelled after GPollFD. | 101 | * Modelled after GPollFD. |
101 | */ | 102 | */ |
102 | enum GNUNET_SCHEDULER_EventType { | 103 | enum GNUNET_SCHEDULER_EventType |
104 | { | ||
103 | /** | 105 | /** |
104 | * No event (useful for timeout). | 106 | * No event (useful for timeout). |
105 | */ | 107 | */ |
@@ -140,7 +142,8 @@ enum GNUNET_SCHEDULER_EventType { | |||
140 | /** | 142 | /** |
141 | * Information about an event relating to a file descriptor/socket. | 143 | * Information about an event relating to a file descriptor/socket. |
142 | */ | 144 | */ |
143 | struct GNUNET_SCHEDULER_FdInfo { | 145 | struct GNUNET_SCHEDULER_FdInfo |
146 | { | ||
144 | /** | 147 | /** |
145 | * GNUnet network socket the event is about, matches @a sock, | 148 | * GNUnet network socket the event is about, matches @a sock, |
146 | * NULL if this is about a file handle or if no network | 149 | * NULL if this is about a file handle or if no network |
@@ -170,7 +173,8 @@ struct GNUNET_SCHEDULER_FdInfo { | |||
170 | /** | 173 | /** |
171 | * Context information passed to each scheduler task. | 174 | * Context information passed to each scheduler task. |
172 | */ | 175 | */ |
173 | struct GNUNET_SCHEDULER_TaskContext { | 176 | struct GNUNET_SCHEDULER_TaskContext |
177 | { | ||
174 | /** | 178 | /** |
175 | * Reason why the task is run now | 179 | * Reason why the task is run now |
176 | */ | 180 | */ |
@@ -219,8 +223,8 @@ struct GNUNET_SCHEDULER_TaskContext { | |||
219 | * @param fdi information about the related FD | 223 | * @param fdi information about the related FD |
220 | */ | 224 | */ |
221 | void | 225 | void |
222 | GNUNET_SCHEDULER_task_ready(struct GNUNET_SCHEDULER_Task *task, | 226 | GNUNET_SCHEDULER_task_ready (struct GNUNET_SCHEDULER_Task *task, |
223 | struct GNUNET_SCHEDULER_FdInfo *fdi); | 227 | struct GNUNET_SCHEDULER_FdInfo *fdi); |
224 | 228 | ||
225 | 229 | ||
226 | /** | 230 | /** |
@@ -250,14 +254,15 @@ struct GNUNET_SCHEDULER_Handle; | |||
250 | * if we are done running tasks (yield to block) | 254 | * if we are done running tasks (yield to block) |
251 | */ | 255 | */ |
252 | int | 256 | int |
253 | GNUNET_SCHEDULER_do_work(struct GNUNET_SCHEDULER_Handle *sh); | 257 | GNUNET_SCHEDULER_do_work (struct GNUNET_SCHEDULER_Handle *sh); |
254 | 258 | ||
255 | 259 | ||
256 | /** | 260 | /** |
257 | * API an external event loop has to implement for | 261 | * API an external event loop has to implement for |
258 | * #GNUNET_SCHEDULER_driver_init. | 262 | * #GNUNET_SCHEDULER_driver_init. |
259 | */ | 263 | */ |
260 | struct GNUNET_SCHEDULER_Driver { | 264 | struct GNUNET_SCHEDULER_Driver |
265 | { | ||
261 | /** | 266 | /** |
262 | * Closure to pass to the functions in this struct. | 267 | * Closure to pass to the functions in this struct. |
263 | */ | 268 | */ |
@@ -348,7 +353,7 @@ typedef void | |||
348 | * #GNUNET_SCHEDULER_driver_done | 353 | * #GNUNET_SCHEDULER_driver_done |
349 | */ | 354 | */ |
350 | struct GNUNET_SCHEDULER_Handle * | 355 | struct GNUNET_SCHEDULER_Handle * |
351 | GNUNET_SCHEDULER_driver_init(const struct GNUNET_SCHEDULER_Driver *driver); | 356 | GNUNET_SCHEDULER_driver_init (const struct GNUNET_SCHEDULER_Driver *driver); |
352 | 357 | ||
353 | 358 | ||
354 | /** | 359 | /** |
@@ -366,7 +371,7 @@ GNUNET_SCHEDULER_driver_init(const struct GNUNET_SCHEDULER_Driver *driver); | |||
366 | * @param sh the handle returned by #GNUNET_SCHEDULER_driver_init | 371 | * @param sh the handle returned by #GNUNET_SCHEDULER_driver_init |
367 | */ | 372 | */ |
368 | void | 373 | void |
369 | GNUNET_SCHEDULER_driver_done(struct GNUNET_SCHEDULER_Handle *sh); | 374 | GNUNET_SCHEDULER_driver_done (struct GNUNET_SCHEDULER_Handle *sh); |
370 | 375 | ||
371 | 376 | ||
372 | /** | 377 | /** |
@@ -375,7 +380,7 @@ GNUNET_SCHEDULER_driver_done(struct GNUNET_SCHEDULER_Handle *sh); | |||
375 | * @return NULL on error | 380 | * @return NULL on error |
376 | */ | 381 | */ |
377 | struct GNUNET_SCHEDULER_Driver * | 382 | struct GNUNET_SCHEDULER_Driver * |
378 | GNUNET_SCHEDULER_driver_select(void); | 383 | GNUNET_SCHEDULER_driver_select (void); |
379 | 384 | ||
380 | 385 | ||
381 | /** | 386 | /** |
@@ -412,8 +417,8 @@ typedef int | |||
412 | * @param task_cls closure of @a task | 417 | * @param task_cls closure of @a task |
413 | */ | 418 | */ |
414 | void | 419 | void |
415 | GNUNET_SCHEDULER_run(GNUNET_SCHEDULER_TaskCallback task, | 420 | GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_TaskCallback task, |
416 | void *task_cls); | 421 | void *task_cls); |
417 | 422 | ||
418 | /** | 423 | /** |
419 | * Initialize and run scheduler. This function will return when all | 424 | * Initialize and run scheduler. This function will return when all |
@@ -427,9 +432,9 @@ GNUNET_SCHEDULER_run(GNUNET_SCHEDULER_TaskCallback task, | |||
427 | * @param task_cls closure of @a task | 432 | * @param task_cls closure of @a task |
428 | */ | 433 | */ |
429 | void | 434 | void |
430 | GNUNET_SCHEDULER_run_with_optional_signals(int install_signals, | 435 | GNUNET_SCHEDULER_run_with_optional_signals (int install_signals, |
431 | GNUNET_SCHEDULER_TaskCallback task, | 436 | GNUNET_SCHEDULER_TaskCallback task, |
432 | void *task_cls); | 437 | void *task_cls); |
433 | 438 | ||
434 | 439 | ||
435 | /** | 440 | /** |
@@ -439,7 +444,7 @@ GNUNET_SCHEDULER_run_with_optional_signals(int install_signals, | |||
439 | * will be delayed until the next shutdown signal. | 444 | * will be delayed until the next shutdown signal. |
440 | */ | 445 | */ |
441 | void | 446 | void |
442 | GNUNET_SCHEDULER_shutdown(void); | 447 | GNUNET_SCHEDULER_shutdown (void); |
443 | 448 | ||
444 | 449 | ||
445 | /** | 450 | /** |
@@ -454,7 +459,7 @@ GNUNET_SCHEDULER_shutdown(void); | |||
454 | * @return number of tasks pending right now | 459 | * @return number of tasks pending right now |
455 | */ | 460 | */ |
456 | unsigned int | 461 | unsigned int |
457 | GNUNET_SCHEDULER_get_load(enum GNUNET_SCHEDULER_Priority p); | 462 | GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p); |
458 | 463 | ||
459 | 464 | ||
460 | /** | 465 | /** |
@@ -464,7 +469,7 @@ GNUNET_SCHEDULER_get_load(enum GNUNET_SCHEDULER_Priority p); | |||
464 | * @return task context with information why the current task is run | 469 | * @return task context with information why the current task is run |
465 | */ | 470 | */ |
466 | const struct GNUNET_SCHEDULER_TaskContext * | 471 | const struct GNUNET_SCHEDULER_TaskContext * |
467 | GNUNET_SCHEDULER_get_task_context(void); | 472 | GNUNET_SCHEDULER_get_task_context (void); |
468 | 473 | ||
469 | 474 | ||
470 | /** | 475 | /** |
@@ -480,7 +485,7 @@ GNUNET_SCHEDULER_get_task_context(void); | |||
480 | * @return original closure of the task | 485 | * @return original closure of the task |
481 | */ | 486 | */ |
482 | void * | 487 | void * |
483 | GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task); | 488 | GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Task *task); |
484 | 489 | ||
485 | 490 | ||
486 | /** | 491 | /** |
@@ -494,10 +499,13 @@ GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task); | |||
494 | * @param priority priority to use for the task | 499 | * @param priority priority to use for the task |
495 | */ | 500 | */ |
496 | void | 501 | void |
497 | GNUNET_SCHEDULER_add_with_reason_and_priority(GNUNET_SCHEDULER_TaskCallback task, | 502 | GNUNET_SCHEDULER_add_with_reason_and_priority (GNUNET_SCHEDULER_TaskCallback |
498 | void *task_cls, | 503 | task, |
499 | enum GNUNET_SCHEDULER_Reason reason, | 504 | void *task_cls, |
500 | enum GNUNET_SCHEDULER_Priority priority); | 505 | enum GNUNET_SCHEDULER_Reason |
506 | reason, | ||
507 | enum GNUNET_SCHEDULER_Priority | ||
508 | priority); | ||
501 | 509 | ||
502 | 510 | ||
503 | /** | 511 | /** |
@@ -510,9 +518,9 @@ GNUNET_SCHEDULER_add_with_reason_and_priority(GNUNET_SCHEDULER_TaskCallback task | |||
510 | * only valid until @a task is started! | 518 | * only valid until @a task is started! |
511 | */ | 519 | */ |
512 | struct GNUNET_SCHEDULER_Task * | 520 | struct GNUNET_SCHEDULER_Task * |
513 | GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, | 521 | GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio, |
514 | GNUNET_SCHEDULER_TaskCallback task, | 522 | GNUNET_SCHEDULER_TaskCallback task, |
515 | void *task_cls); | 523 | void *task_cls); |
516 | 524 | ||
517 | 525 | ||
518 | /** | 526 | /** |
@@ -531,8 +539,8 @@ GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, | |||
531 | * only valid until @a task is started! | 539 | * only valid until @a task is started! |
532 | */ | 540 | */ |
533 | struct GNUNET_SCHEDULER_Task * | 541 | struct GNUNET_SCHEDULER_Task * |
534 | GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, | 542 | GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_TaskCallback task, |
535 | void *task_cls); | 543 | void *task_cls); |
536 | 544 | ||
537 | 545 | ||
538 | /** | 546 | /** |
@@ -546,8 +554,8 @@ GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, | |||
546 | * only valid until @a task is started! | 554 | * only valid until @a task is started! |
547 | */ | 555 | */ |
548 | struct GNUNET_SCHEDULER_Task * | 556 | struct GNUNET_SCHEDULER_Task * |
549 | GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, | 557 | GNUNET_SCHEDULER_add_shutdown (GNUNET_SCHEDULER_TaskCallback task, |
550 | void *task_cls); | 558 | void *task_cls); |
551 | 559 | ||
552 | 560 | ||
553 | /** | 561 | /** |
@@ -565,9 +573,9 @@ GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, | |||
565 | * only valid until @a task is started! | 573 | * only valid until @a task is started! |
566 | */ | 574 | */ |
567 | struct GNUNET_SCHEDULER_Task * | 575 | struct GNUNET_SCHEDULER_Task * |
568 | GNUNET_SCHEDULER_add_now_with_lifeness(int lifeness, | 576 | GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness, |
569 | GNUNET_SCHEDULER_TaskCallback task, | 577 | GNUNET_SCHEDULER_TaskCallback task, |
570 | void *task_cls); | 578 | void *task_cls); |
571 | 579 | ||
572 | 580 | ||
573 | /** | 581 | /** |
@@ -582,9 +590,9 @@ GNUNET_SCHEDULER_add_now_with_lifeness(int lifeness, | |||
582 | * only valid until @a task is started! | 590 | * only valid until @a task is started! |
583 | */ | 591 | */ |
584 | struct GNUNET_SCHEDULER_Task * | 592 | struct GNUNET_SCHEDULER_Task * |
585 | GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, | 593 | GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay, |
586 | GNUNET_SCHEDULER_TaskCallback task, | 594 | GNUNET_SCHEDULER_TaskCallback task, |
587 | void *task_cls); | 595 | void *task_cls); |
588 | 596 | ||
589 | 597 | ||
590 | /** | 598 | /** |
@@ -599,9 +607,9 @@ GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, | |||
599 | * only valid until @a task is started! | 607 | * only valid until @a task is started! |
600 | */ | 608 | */ |
601 | struct GNUNET_SCHEDULER_Task * | 609 | struct GNUNET_SCHEDULER_Task * |
602 | GNUNET_SCHEDULER_add_at(struct GNUNET_TIME_Absolute at, | 610 | GNUNET_SCHEDULER_add_at (struct GNUNET_TIME_Absolute at, |
603 | GNUNET_SCHEDULER_TaskCallback task, | 611 | GNUNET_SCHEDULER_TaskCallback task, |
604 | void *task_cls); | 612 | void *task_cls); |
605 | 613 | ||
606 | 614 | ||
607 | /** | 615 | /** |
@@ -616,10 +624,11 @@ GNUNET_SCHEDULER_add_at(struct GNUNET_TIME_Absolute at, | |||
616 | * only valid until @a task is started! | 624 | * only valid until @a task is started! |
617 | */ | 625 | */ |
618 | struct GNUNET_SCHEDULER_Task * | 626 | struct GNUNET_SCHEDULER_Task * |
619 | GNUNET_SCHEDULER_add_delayed_with_priority(struct GNUNET_TIME_Relative delay, | 627 | GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay, |
620 | enum GNUNET_SCHEDULER_Priority priority, | 628 | enum GNUNET_SCHEDULER_Priority |
621 | GNUNET_SCHEDULER_TaskCallback task, | 629 | priority, |
622 | void *task_cls); | 630 | GNUNET_SCHEDULER_TaskCallback task, |
631 | void *task_cls); | ||
623 | 632 | ||
624 | 633 | ||
625 | /** | 634 | /** |
@@ -634,10 +643,10 @@ GNUNET_SCHEDULER_add_delayed_with_priority(struct GNUNET_TIME_Relative delay, | |||
634 | * only valid until @a task is started! | 643 | * only valid until @a task is started! |
635 | */ | 644 | */ |
636 | struct GNUNET_SCHEDULER_Task * | 645 | struct GNUNET_SCHEDULER_Task * |
637 | GNUNET_SCHEDULER_add_at_with_priority(struct GNUNET_TIME_Absolute at, | 646 | GNUNET_SCHEDULER_add_at_with_priority (struct GNUNET_TIME_Absolute at, |
638 | enum GNUNET_SCHEDULER_Priority priority, | 647 | enum GNUNET_SCHEDULER_Priority priority, |
639 | GNUNET_SCHEDULER_TaskCallback task, | 648 | GNUNET_SCHEDULER_TaskCallback task, |
640 | void *task_cls); | 649 | void *task_cls); |
641 | 650 | ||
642 | 651 | ||
643 | /** | 652 | /** |
@@ -661,10 +670,10 @@ GNUNET_SCHEDULER_add_at_with_priority(struct GNUNET_TIME_Absolute at, | |||
661 | * only valid until @a task is started! | 670 | * only valid until @a task is started! |
662 | */ | 671 | */ |
663 | struct GNUNET_SCHEDULER_Task * | 672 | struct GNUNET_SCHEDULER_Task * |
664 | GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, | 673 | GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay, |
665 | struct GNUNET_NETWORK_Handle *rfd, | 674 | struct GNUNET_NETWORK_Handle *rfd, |
666 | GNUNET_SCHEDULER_TaskCallback task, | 675 | GNUNET_SCHEDULER_TaskCallback task, |
667 | void *task_cls); | 676 | void *task_cls); |
668 | 677 | ||
669 | 678 | ||
670 | /** | 679 | /** |
@@ -690,11 +699,12 @@ GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, | |||
690 | * only valid until @a task is started! | 699 | * only valid until @a task is started! |
691 | */ | 700 | */ |
692 | struct GNUNET_SCHEDULER_Task * | 701 | struct GNUNET_SCHEDULER_Task * |
693 | GNUNET_SCHEDULER_add_read_net_with_priority(struct GNUNET_TIME_Relative delay, | 702 | GNUNET_SCHEDULER_add_read_net_with_priority (struct GNUNET_TIME_Relative delay, |
694 | enum GNUNET_SCHEDULER_Priority priority, | 703 | enum GNUNET_SCHEDULER_Priority |
695 | struct GNUNET_NETWORK_Handle *rfd, | 704 | priority, |
696 | GNUNET_SCHEDULER_TaskCallback task, | 705 | struct GNUNET_NETWORK_Handle *rfd, |
697 | void *task_cls); | 706 | GNUNET_SCHEDULER_TaskCallback task, |
707 | void *task_cls); | ||
698 | 708 | ||
699 | 709 | ||
700 | /** | 710 | /** |
@@ -719,10 +729,10 @@ GNUNET_SCHEDULER_add_read_net_with_priority(struct GNUNET_TIME_Relative delay, | |||
719 | * only valid until @a task is started! | 729 | * only valid until @a task is started! |
720 | */ | 730 | */ |
721 | struct GNUNET_SCHEDULER_Task * | 731 | struct GNUNET_SCHEDULER_Task * |
722 | GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, | 732 | GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay, |
723 | struct GNUNET_NETWORK_Handle *wfd, | 733 | struct GNUNET_NETWORK_Handle *wfd, |
724 | GNUNET_SCHEDULER_TaskCallback task, | 734 | GNUNET_SCHEDULER_TaskCallback task, |
725 | void *task_cls); | 735 | void *task_cls); |
726 | 736 | ||
727 | 737 | ||
728 | /** | 738 | /** |
@@ -749,13 +759,13 @@ GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, | |||
749 | * only valid until "task" is started! | 759 | * only valid until "task" is started! |
750 | */ | 760 | */ |
751 | struct GNUNET_SCHEDULER_Task * | 761 | struct GNUNET_SCHEDULER_Task * |
752 | GNUNET_SCHEDULER_add_net_with_priority(struct GNUNET_TIME_Relative delay, | 762 | GNUNET_SCHEDULER_add_net_with_priority (struct GNUNET_TIME_Relative delay, |
753 | enum GNUNET_SCHEDULER_Priority priority, | 763 | enum GNUNET_SCHEDULER_Priority priority, |
754 | struct GNUNET_NETWORK_Handle *fd, | 764 | struct GNUNET_NETWORK_Handle *fd, |
755 | int on_read, | 765 | int on_read, |
756 | int on_write, | 766 | int on_write, |
757 | GNUNET_SCHEDULER_TaskCallback task, | 767 | GNUNET_SCHEDULER_TaskCallback task, |
758 | void *task_cls); | 768 | void *task_cls); |
759 | 769 | ||
760 | 770 | ||
761 | /** | 771 | /** |
@@ -779,10 +789,10 @@ GNUNET_SCHEDULER_add_net_with_priority(struct GNUNET_TIME_Relative delay, | |||
779 | * only valid until @a task is started! | 789 | * only valid until @a task is started! |
780 | */ | 790 | */ |
781 | struct GNUNET_SCHEDULER_Task * | 791 | struct GNUNET_SCHEDULER_Task * |
782 | GNUNET_SCHEDULER_add_read_file(struct GNUNET_TIME_Relative delay, | 792 | GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay, |
783 | const struct GNUNET_DISK_FileHandle *rfd, | 793 | const struct GNUNET_DISK_FileHandle *rfd, |
784 | GNUNET_SCHEDULER_TaskCallback task, | 794 | GNUNET_SCHEDULER_TaskCallback task, |
785 | void *task_cls); | 795 | void *task_cls); |
786 | 796 | ||
787 | 797 | ||
788 | /** | 798 | /** |
@@ -806,10 +816,10 @@ GNUNET_SCHEDULER_add_read_file(struct GNUNET_TIME_Relative delay, | |||
806 | * only valid until @a task is started! | 816 | * only valid until @a task is started! |
807 | */ | 817 | */ |
808 | struct GNUNET_SCHEDULER_Task * | 818 | struct GNUNET_SCHEDULER_Task * |
809 | GNUNET_SCHEDULER_add_write_file(struct GNUNET_TIME_Relative delay, | 819 | GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay, |
810 | const struct GNUNET_DISK_FileHandle *wfd, | 820 | const struct GNUNET_DISK_FileHandle *wfd, |
811 | GNUNET_SCHEDULER_TaskCallback task, | 821 | GNUNET_SCHEDULER_TaskCallback task, |
812 | void *task_cls); | 822 | void *task_cls); |
813 | 823 | ||
814 | 824 | ||
815 | /** | 825 | /** |
@@ -836,12 +846,15 @@ GNUNET_SCHEDULER_add_write_file(struct GNUNET_TIME_Relative delay, | |||
836 | * only valid until @a task is started! | 846 | * only valid until @a task is started! |
837 | */ | 847 | */ |
838 | struct GNUNET_SCHEDULER_Task * | 848 | struct GNUNET_SCHEDULER_Task * |
839 | GNUNET_SCHEDULER_add_file_with_priority(struct GNUNET_TIME_Relative delay, | 849 | GNUNET_SCHEDULER_add_file_with_priority (struct GNUNET_TIME_Relative delay, |
840 | enum GNUNET_SCHEDULER_Priority priority, | 850 | enum GNUNET_SCHEDULER_Priority |
841 | const struct GNUNET_DISK_FileHandle *fd, | 851 | priority, |
842 | int on_read, int on_write, | 852 | const struct |
843 | GNUNET_SCHEDULER_TaskCallback task, | 853 | GNUNET_DISK_FileHandle *fd, |
844 | void *task_cls); | 854 | int on_read, |
855 | int on_write, | ||
856 | GNUNET_SCHEDULER_TaskCallback task, | ||
857 | void *task_cls); | ||
845 | 858 | ||
846 | 859 | ||
847 | /** | 860 | /** |
@@ -876,12 +889,12 @@ GNUNET_SCHEDULER_add_file_with_priority(struct GNUNET_TIME_Relative delay, | |||
876 | * only valid until @a task is started! | 889 | * only valid until @a task is started! |
877 | */ | 890 | */ |
878 | struct GNUNET_SCHEDULER_Task * | 891 | struct GNUNET_SCHEDULER_Task * |
879 | GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, | 892 | GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio, |
880 | struct GNUNET_TIME_Relative delay, | 893 | struct GNUNET_TIME_Relative delay, |
881 | const struct GNUNET_NETWORK_FDSet *rs, | 894 | const struct GNUNET_NETWORK_FDSet *rs, |
882 | const struct GNUNET_NETWORK_FDSet *ws, | 895 | const struct GNUNET_NETWORK_FDSet *ws, |
883 | GNUNET_SCHEDULER_TaskCallback task, | 896 | GNUNET_SCHEDULER_TaskCallback task, |
884 | void *task_cls); | 897 | void *task_cls); |
885 | 898 | ||
886 | /** | 899 | /** |
887 | * Sets the select function to use in the scheduler (scheduler_select). | 900 | * Sets the select function to use in the scheduler (scheduler_select). |
@@ -890,8 +903,8 @@ GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, | |||
890 | * @param new_select_cls closure for @a new_select | 903 | * @param new_select_cls closure for @a new_select |
891 | */ | 904 | */ |
892 | void | 905 | void |
893 | GNUNET_SCHEDULER_set_select(GNUNET_SCHEDULER_select new_select, | 906 | GNUNET_SCHEDULER_set_select (GNUNET_SCHEDULER_select new_select, |
894 | void *new_select_cls); | 907 | void *new_select_cls); |
895 | 908 | ||
896 | 909 | ||
897 | 910 | ||
@@ -908,7 +921,7 @@ GNUNET_SCHEDULER_set_select(GNUNET_SCHEDULER_select new_select, | |||
908 | * @param aid the asynchronous scope id to enter | 921 | * @param aid the asynchronous scope id to enter |
909 | */ | 922 | */ |
910 | void | 923 | void |
911 | GNUNET_SCHEDULER_begin_async_scope(struct GNUNET_AsyncScopeId *aid); | 924 | GNUNET_SCHEDULER_begin_async_scope (struct GNUNET_AsyncScopeId *aid); |
912 | 925 | ||
913 | 926 | ||
914 | 927 | ||
diff --git a/src/include/gnunet_service_lib.h b/src/include/gnunet_service_lib.h index 9cdf4d459..19a5fb89b 100644 --- a/src/include/gnunet_service_lib.h +++ b/src/include/gnunet_service_lib.h | |||
@@ -50,7 +50,8 @@ extern "C" | |||
50 | /** | 50 | /** |
51 | * Options for the service (bitmask). | 51 | * Options for the service (bitmask). |
52 | */ | 52 | */ |
53 | enum GNUNET_SERVICE_Options { | 53 | enum GNUNET_SERVICE_Options |
54 | { | ||
54 | /** | 55 | /** |
55 | * Use defaults. Terminates all client connections and the listen | 56 | * Use defaults. Terminates all client connections and the listen |
56 | * sockets immediately upon receiving the shutdown signal. | 57 | * sockets immediately upon receiving the shutdown signal. |
@@ -68,7 +69,18 @@ enum GNUNET_SERVICE_Options { | |||
68 | * Trigger a SOFT server shutdown on signals, allowing active | 69 | * Trigger a SOFT server shutdown on signals, allowing active |
69 | * non-monitor clients to complete their transactions. | 70 | * non-monitor clients to complete their transactions. |
70 | */ | 71 | */ |
71 | GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN = 2 | 72 | GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN = 2, |
73 | |||
74 | /** | ||
75 | * Bitmask over the shutdown options. | ||
76 | */ | ||
77 | GNUNET_SERVICE_OPTION_SHUTDOWN_BITMASK = 3, | ||
78 | |||
79 | /** | ||
80 | * Instead of listening on lsocks passed by the parent, | ||
81 | * close them *after* opening our own listen socket(s). | ||
82 | */ | ||
83 | GNUNET_SERVICE_OPTION_CLOSE_LSOCKS = 4 | ||
72 | }; | 84 | }; |
73 | 85 | ||
74 | 86 | ||
@@ -164,12 +176,12 @@ typedef void | |||
164 | * @return NULL on error | 176 | * @return NULL on error |
165 | */ | 177 | */ |
166 | struct GNUNET_SERVICE_Handle * | 178 | struct GNUNET_SERVICE_Handle * |
167 | GNUNET_SERVICE_start(const char *service_name, | 179 | GNUNET_SERVICE_start (const char *service_name, |
168 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 180 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
169 | GNUNET_SERVICE_ConnectHandler connect_cb, | 181 | GNUNET_SERVICE_ConnectHandler connect_cb, |
170 | GNUNET_SERVICE_DisconnectHandler disconnect_cb, | 182 | GNUNET_SERVICE_DisconnectHandler disconnect_cb, |
171 | void *cls, | 183 | void *cls, |
172 | const struct GNUNET_MQ_MessageHandler *handlers); | 184 | const struct GNUNET_MQ_MessageHandler *handlers); |
173 | 185 | ||
174 | 186 | ||
175 | /** | 187 | /** |
@@ -178,7 +190,7 @@ GNUNET_SERVICE_start(const char *service_name, | |||
178 | * @param srv service to stop | 190 | * @param srv service to stop |
179 | */ | 191 | */ |
180 | void | 192 | void |
181 | GNUNET_SERVICE_stop(struct GNUNET_SERVICE_Handle *srv); | 193 | GNUNET_SERVICE_stop (struct GNUNET_SERVICE_Handle *srv); |
182 | 194 | ||
183 | 195 | ||
184 | /** | 196 | /** |
@@ -223,15 +235,15 @@ GNUNET_SERVICE_stop(struct GNUNET_SERVICE_Handle *srv); | |||
223 | * @return 0 on success, non-zero on error | 235 | * @return 0 on success, non-zero on error |
224 | */ | 236 | */ |
225 | int | 237 | int |
226 | GNUNET_SERVICE_run_(int argc, | 238 | GNUNET_SERVICE_run_ (int argc, |
227 | char *const *argv, | 239 | char *const *argv, |
228 | const char *service_name, | 240 | const char *service_name, |
229 | enum GNUNET_SERVICE_Options options, | 241 | enum GNUNET_SERVICE_Options options, |
230 | GNUNET_SERVICE_InitCallback service_init_cb, | 242 | GNUNET_SERVICE_InitCallback service_init_cb, |
231 | GNUNET_SERVICE_ConnectHandler connect_cb, | 243 | GNUNET_SERVICE_ConnectHandler connect_cb, |
232 | GNUNET_SERVICE_DisconnectHandler disconnect_cb, | 244 | GNUNET_SERVICE_DisconnectHandler disconnect_cb, |
233 | void *cls, | 245 | void *cls, |
234 | const struct GNUNET_MQ_MessageHandler *handlers); | 246 | const struct GNUNET_MQ_MessageHandler *handlers); |
235 | 247 | ||
236 | 248 | ||
237 | /** | 249 | /** |
@@ -291,23 +303,24 @@ GNUNET_SERVICE_run_(int argc, | |||
291 | * GNUNET_MQ_handler_end ()); | 303 | * GNUNET_MQ_handler_end ()); |
292 | * </code> | 304 | * </code> |
293 | */ | 305 | */ |
294 | #define GNUNET_SERVICE_MAIN(service_name, service_options, init_cb, connect_cb, disconnect_cb, cls, ...) \ | 306 | #define GNUNET_SERVICE_MAIN(service_name, service_options, init_cb, connect_cb, \ |
307 | disconnect_cb, cls, ...) \ | ||
295 | int \ | 308 | int \ |
296 | main(int argc, \ | 309 | main (int argc, \ |
297 | char *const *argv) \ | 310 | char *const *argv) \ |
298 | { \ | 311 | { \ |
299 | struct GNUNET_MQ_MessageHandler mh[] = { \ | 312 | struct GNUNET_MQ_MessageHandler mh[] = { \ |
300 | __VA_ARGS__ \ | 313 | __VA_ARGS__ \ |
301 | }; \ | 314 | }; \ |
302 | return GNUNET_SERVICE_run_(argc, \ | 315 | return GNUNET_SERVICE_run_ (argc, \ |
303 | argv, \ | 316 | argv, \ |
304 | service_name, \ | 317 | service_name, \ |
305 | service_options, \ | 318 | service_options, \ |
306 | init_cb, \ | 319 | init_cb, \ |
307 | connect_cb, \ | 320 | connect_cb, \ |
308 | disconnect_cb, \ | 321 | disconnect_cb, \ |
309 | cls, \ | 322 | cls, \ |
310 | mh); \ | 323 | mh); \ |
311 | } | 324 | } |
312 | 325 | ||
313 | 326 | ||
@@ -318,7 +331,7 @@ GNUNET_SERVICE_run_(int argc, | |||
318 | * @param sh service to stop accepting connections. | 331 | * @param sh service to stop accepting connections. |
319 | */ | 332 | */ |
320 | void | 333 | void |
321 | GNUNET_SERVICE_suspend(struct GNUNET_SERVICE_Handle *sh); | 334 | GNUNET_SERVICE_suspend (struct GNUNET_SERVICE_Handle *sh); |
322 | 335 | ||
323 | 336 | ||
324 | /** | 337 | /** |
@@ -327,7 +340,7 @@ GNUNET_SERVICE_suspend(struct GNUNET_SERVICE_Handle *sh); | |||
327 | * @param sh service to resume accepting connections. | 340 | * @param sh service to resume accepting connections. |
328 | */ | 341 | */ |
329 | void | 342 | void |
330 | GNUNET_SERVICE_resume(struct GNUNET_SERVICE_Handle *sh); | 343 | GNUNET_SERVICE_resume (struct GNUNET_SERVICE_Handle *sh); |
331 | 344 | ||
332 | 345 | ||
333 | /** | 346 | /** |
@@ -337,7 +350,7 @@ GNUNET_SERVICE_resume(struct GNUNET_SERVICE_Handle *sh); | |||
337 | * @param c the client to continue receiving from | 350 | * @param c the client to continue receiving from |
338 | */ | 351 | */ |
339 | void | 352 | void |
340 | GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c); | 353 | GNUNET_SERVICE_client_continue (struct GNUNET_SERVICE_Client *c); |
341 | 354 | ||
342 | 355 | ||
343 | /** | 356 | /** |
@@ -347,7 +360,7 @@ GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c); | |||
347 | * @return the message queue of @a c | 360 | * @return the message queue of @a c |
348 | */ | 361 | */ |
349 | struct GNUNET_MQ_Handle * | 362 | struct GNUNET_MQ_Handle * |
350 | GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c); | 363 | GNUNET_SERVICE_client_get_mq (struct GNUNET_SERVICE_Client *c); |
351 | 364 | ||
352 | 365 | ||
353 | /** | 366 | /** |
@@ -359,7 +372,8 @@ GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c); | |||
359 | * @param c client for which to disable the warning | 372 | * @param c client for which to disable the warning |
360 | */ | 373 | */ |
361 | void | 374 | void |
362 | GNUNET_SERVICE_client_disable_continue_warning(struct GNUNET_SERVICE_Client *c); | 375 | GNUNET_SERVICE_client_disable_continue_warning (struct |
376 | GNUNET_SERVICE_Client *c); | ||
363 | 377 | ||
364 | 378 | ||
365 | /** | 379 | /** |
@@ -378,7 +392,7 @@ GNUNET_SERVICE_client_disable_continue_warning(struct GNUNET_SERVICE_Client *c); | |||
378 | * @param c client to disconnect now | 392 | * @param c client to disconnect now |
379 | */ | 393 | */ |
380 | void | 394 | void |
381 | GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c); | 395 | GNUNET_SERVICE_client_drop (struct GNUNET_SERVICE_Client *c); |
382 | 396 | ||
383 | 397 | ||
384 | /** | 398 | /** |
@@ -387,7 +401,7 @@ GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c); | |||
387 | * @param sh server to shutdown | 401 | * @param sh server to shutdown |
388 | */ | 402 | */ |
389 | void | 403 | void |
390 | GNUNET_SERVICE_shutdown(struct GNUNET_SERVICE_Handle *sh); | 404 | GNUNET_SERVICE_shutdown (struct GNUNET_SERVICE_Handle *sh); |
391 | 405 | ||
392 | 406 | ||
393 | /** | 407 | /** |
@@ -403,7 +417,7 @@ GNUNET_SERVICE_shutdown(struct GNUNET_SERVICE_Handle *sh); | |||
403 | * @param c client to mark as a monitor | 417 | * @param c client to mark as a monitor |
404 | */ | 418 | */ |
405 | void | 419 | void |
406 | GNUNET_SERVICE_client_mark_monitor(struct GNUNET_SERVICE_Client *c); | 420 | GNUNET_SERVICE_client_mark_monitor (struct GNUNET_SERVICE_Client *c); |
407 | 421 | ||
408 | 422 | ||
409 | /** | 423 | /** |
@@ -414,7 +428,7 @@ GNUNET_SERVICE_client_mark_monitor(struct GNUNET_SERVICE_Client *c); | |||
414 | * @param c client to persist the socket (never to be closed) | 428 | * @param c client to persist the socket (never to be closed) |
415 | */ | 429 | */ |
416 | void | 430 | void |
417 | GNUNET_SERVICE_client_persist(struct GNUNET_SERVICE_Client *c); | 431 | GNUNET_SERVICE_client_persist (struct GNUNET_SERVICE_Client *c); |
418 | 432 | ||
419 | 433 | ||
420 | #if 0 /* keep Emacsens' auto-indent happy */ | 434 | #if 0 /* keep Emacsens' auto-indent happy */ |
diff --git a/src/util/client.c b/src/util/client.c index e3585af2e..d431909cf 100644 --- a/src/util/client.c +++ b/src/util/client.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
3 | Copyright (C) 2001-2016 GNUnet e.V. | 3 | Copyright (C) 2001-2016, 2019 GNUnet e.V. |
4 | 4 | ||
5 | GNUnet is free software: you can redistribute it and/or modify it | 5 | GNUnet is free software: you can redistribute it and/or modify it |
6 | under the terms of the GNU Affero General Public License as published | 6 | under the terms of the GNU Affero General Public License as published |
@@ -33,7 +33,7 @@ | |||
33 | #include "gnunet_socks.h" | 33 | #include "gnunet_socks.h" |
34 | 34 | ||
35 | 35 | ||
36 | #define LOG(kind, ...) GNUNET_log_from(kind, "util-client", __VA_ARGS__) | 36 | #define LOG(kind, ...) GNUNET_log_from (kind, "util-client", __VA_ARGS__) |
37 | 37 | ||
38 | /** | 38 | /** |
39 | * Timeout we use on TCP connect before trying another | 39 | * Timeout we use on TCP connect before trying another |
@@ -41,7 +41,8 @@ | |||
41 | * is this value divided by the number of address families. | 41 | * is this value divided by the number of address families. |
42 | * Default is 5s. | 42 | * Default is 5s. |
43 | */ | 43 | */ |
44 | #define CONNECT_RETRY_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5) | 44 | #define CONNECT_RETRY_TIMEOUT GNUNET_TIME_relative_multiply ( \ |
45 | GNUNET_TIME_UNIT_SECONDS, 5) | ||
45 | 46 | ||
46 | 47 | ||
47 | 48 | ||
@@ -55,7 +56,8 @@ struct ClientState; | |||
55 | * During connect, we try multiple possible IP addresses | 56 | * During connect, we try multiple possible IP addresses |
56 | * to find out which one might work. | 57 | * to find out which one might work. |
57 | */ | 58 | */ |
58 | struct AddressProbe { | 59 | struct AddressProbe |
60 | { | ||
59 | /** | 61 | /** |
60 | * This is a linked list. | 62 | * This is a linked list. |
61 | */ | 63 | */ |
@@ -96,7 +98,8 @@ struct AddressProbe { | |||
96 | /** | 98 | /** |
97 | * Internal state for a client connected to a GNUnet service. | 99 | * Internal state for a client connected to a GNUnet service. |
98 | */ | 100 | */ |
99 | struct ClientState { | 101 | struct ClientState |
102 | { | ||
100 | /** | 103 | /** |
101 | * The connection handle, NULL if not live | 104 | * The connection handle, NULL if not live |
102 | */ | 105 | */ |
@@ -205,7 +208,7 @@ struct ClientState { | |||
205 | * @param cls the `struct ClientState` to try to connect to the service | 208 | * @param cls the `struct ClientState` to try to connect to the service |
206 | */ | 209 | */ |
207 | static void | 210 | static void |
208 | start_connect(void *cls); | 211 | start_connect (void *cls); |
209 | 212 | ||
210 | 213 | ||
211 | /** | 214 | /** |
@@ -215,26 +218,26 @@ start_connect(void *cls); | |||
215 | * @param cstate the connection we tried to establish | 218 | * @param cstate the connection we tried to establish |
216 | */ | 219 | */ |
217 | static void | 220 | static void |
218 | connect_fail_continuation(struct ClientState *cstate) | 221 | connect_fail_continuation (struct ClientState *cstate) |
219 | { | 222 | { |
220 | GNUNET_break(NULL == cstate->ap_head); | 223 | GNUNET_break (NULL == cstate->ap_head); |
221 | GNUNET_break(NULL == cstate->ap_tail); | 224 | GNUNET_break (NULL == cstate->ap_tail); |
222 | GNUNET_break(NULL == cstate->dns_active); | 225 | GNUNET_break (NULL == cstate->dns_active); |
223 | GNUNET_break(NULL == cstate->sock); | 226 | GNUNET_break (NULL == cstate->sock); |
224 | GNUNET_assert(NULL == cstate->send_task); | 227 | GNUNET_assert (NULL == cstate->send_task); |
225 | GNUNET_assert(NULL == cstate->recv_task); | 228 | GNUNET_assert (NULL == cstate->recv_task); |
226 | // GNUNET_assert (NULL == cstate->proxy_handshake); | 229 | // GNUNET_assert (NULL == cstate->proxy_handshake); |
227 | 230 | ||
228 | cstate->back_off = GNUNET_TIME_STD_BACKOFF(cstate->back_off); | 231 | cstate->back_off = GNUNET_TIME_STD_BACKOFF (cstate->back_off); |
229 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 232 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
230 | "Failed to establish connection to `%s', no further addresses to try, will try again in %s.\n", | 233 | "Failed to establish connection to `%s', no further addresses to try, will try again in %s.\n", |
231 | cstate->service_name, | 234 | cstate->service_name, |
232 | GNUNET_STRINGS_relative_time_to_string(cstate->back_off, | 235 | GNUNET_STRINGS_relative_time_to_string (cstate->back_off, |
233 | GNUNET_YES)); | 236 | GNUNET_YES)); |
234 | cstate->retry_task | 237 | cstate->retry_task |
235 | = GNUNET_SCHEDULER_add_delayed(cstate->back_off, | 238 | = GNUNET_SCHEDULER_add_delayed (cstate->back_off, |
236 | &start_connect, | 239 | &start_connect, |
237 | cstate); | 240 | cstate); |
238 | } | 241 | } |
239 | 242 | ||
240 | 243 | ||
@@ -244,7 +247,7 @@ connect_fail_continuation(struct ClientState *cstate) | |||
244 | * @param cls the `struct ClientState` with the `msg` to transmit | 247 | * @param cls the `struct ClientState` with the `msg` to transmit |
245 | */ | 248 | */ |
246 | static void | 249 | static void |
247 | transmit_ready(void *cls) | 250 | transmit_ready (void *cls) |
248 | { | 251 | { |
249 | struct ClientState *cstate = cls; | 252 | struct ClientState *cstate = cls; |
250 | ssize_t ret; | 253 | ssize_t ret; |
@@ -255,56 +258,56 @@ transmit_ready(void *cls) | |||
255 | cstate->send_task = NULL; | 258 | cstate->send_task = NULL; |
256 | if (GNUNET_YES == cstate->in_destroy) | 259 | if (GNUNET_YES == cstate->in_destroy) |
257 | return; | 260 | return; |
258 | pos = (const char *)cstate->msg; | 261 | pos = (const char *) cstate->msg; |
259 | len = ntohs(cstate->msg->size); | 262 | len = ntohs (cstate->msg->size); |
260 | GNUNET_assert(cstate->msg_off < len); | 263 | GNUNET_assert (cstate->msg_off < len); |
261 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 264 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
262 | "message of type %u trying to send with socket %p (MQ: %p\n", | 265 | "message of type %u trying to send with socket %p (MQ: %p\n", |
263 | ntohs(cstate->msg->type), | 266 | ntohs (cstate->msg->type), |
264 | cstate->sock, | 267 | cstate->sock, |
265 | cstate->mq); | 268 | cstate->mq); |
266 | 269 | ||
267 | RETRY: | 270 | RETRY: |
268 | ret = GNUNET_NETWORK_socket_send(cstate->sock, | 271 | ret = GNUNET_NETWORK_socket_send (cstate->sock, |
269 | &pos[cstate->msg_off], | 272 | &pos[cstate->msg_off], |
270 | len - cstate->msg_off); | 273 | len - cstate->msg_off); |
271 | if (-1 == ret) | 274 | if (-1 == ret) |
275 | { | ||
276 | LOG (GNUNET_ERROR_TYPE_WARNING, | ||
277 | "Error during sending message of type %u\n", | ||
278 | ntohs (cstate->msg->type)); | ||
279 | if (EINTR == errno) | ||
272 | { | 280 | { |
273 | LOG(GNUNET_ERROR_TYPE_WARNING, | 281 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
274 | "Error during sending message of type %u\n", | 282 | "Retrying message of type %u\n", |
275 | ntohs(cstate->msg->type)); | 283 | ntohs (cstate->msg->type)); |
276 | if (EINTR == errno) | 284 | goto RETRY; |
277 | { | ||
278 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
279 | "Retrying message of type %u\n", | ||
280 | ntohs(cstate->msg->type)); | ||
281 | goto RETRY; | ||
282 | } | ||
283 | GNUNET_MQ_inject_error(cstate->mq, | ||
284 | GNUNET_MQ_ERROR_WRITE); | ||
285 | return; | ||
286 | } | 285 | } |
286 | GNUNET_MQ_inject_error (cstate->mq, | ||
287 | GNUNET_MQ_ERROR_WRITE); | ||
288 | return; | ||
289 | } | ||
287 | notify_in_flight = (0 == cstate->msg_off); | 290 | notify_in_flight = (0 == cstate->msg_off); |
288 | cstate->msg_off += ret; | 291 | cstate->msg_off += ret; |
289 | if (cstate->msg_off < len) | 292 | if (cstate->msg_off < len) |
290 | { | 293 | { |
291 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 294 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
292 | "rescheduling message of type %u\n", | 295 | "rescheduling message of type %u\n", |
293 | ntohs(cstate->msg->type)); | 296 | ntohs (cstate->msg->type)); |
294 | cstate->send_task | 297 | cstate->send_task |
295 | = GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, | 298 | = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, |
296 | cstate->sock, | 299 | cstate->sock, |
297 | &transmit_ready, | 300 | &transmit_ready, |
298 | cstate); | 301 | cstate); |
299 | if (notify_in_flight) | 302 | if (notify_in_flight) |
300 | GNUNET_MQ_impl_send_in_flight(cstate->mq); | 303 | GNUNET_MQ_impl_send_in_flight (cstate->mq); |
301 | return; | 304 | return; |
302 | } | 305 | } |
303 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 306 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
304 | "sending message of type %u successful\n", | 307 | "sending message of type %u successful\n", |
305 | ntohs(cstate->msg->type)); | 308 | ntohs (cstate->msg->type)); |
306 | cstate->msg = NULL; | 309 | cstate->msg = NULL; |
307 | GNUNET_MQ_impl_send_continue(cstate->mq); | 310 | GNUNET_MQ_impl_send_continue (cstate->mq); |
308 | } | 311 | } |
309 | 312 | ||
310 | 313 | ||
@@ -319,20 +322,20 @@ RETRY: | |||
319 | * #GNUNET_SYSERR to stop further processing due to error | 322 | * #GNUNET_SYSERR to stop further processing due to error |
320 | */ | 323 | */ |
321 | static int | 324 | static int |
322 | recv_message(void *cls, | 325 | recv_message (void *cls, |
323 | const struct GNUNET_MessageHeader *msg) | 326 | const struct GNUNET_MessageHeader *msg) |
324 | { | 327 | { |
325 | struct ClientState *cstate = cls; | 328 | struct ClientState *cstate = cls; |
326 | 329 | ||
327 | if (GNUNET_YES == cstate->in_destroy) | 330 | if (GNUNET_YES == cstate->in_destroy) |
328 | return GNUNET_NO; | 331 | return GNUNET_NO; |
329 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 332 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
330 | "Received message of type %u and size %u from %s\n", | 333 | "Received message of type %u and size %u from %s\n", |
331 | ntohs(msg->type), | 334 | ntohs (msg->type), |
332 | ntohs(msg->size), | 335 | ntohs (msg->size), |
333 | cstate->service_name); | 336 | cstate->service_name); |
334 | GNUNET_MQ_inject_message(cstate->mq, | 337 | GNUNET_MQ_inject_message (cstate->mq, |
335 | msg); | 338 | msg); |
336 | if (GNUNET_YES == cstate->in_destroy) | 339 | if (GNUNET_YES == cstate->in_destroy) |
337 | return GNUNET_NO; | 340 | return GNUNET_NO; |
338 | return GNUNET_OK; | 341 | return GNUNET_OK; |
@@ -345,20 +348,20 @@ recv_message(void *cls, | |||
345 | * @param cstate handle of the client state to process | 348 | * @param cstate handle of the client state to process |
346 | */ | 349 | */ |
347 | static void | 350 | static void |
348 | cancel_aps(struct ClientState *cstate) | 351 | cancel_aps (struct ClientState *cstate) |
349 | { | 352 | { |
350 | struct AddressProbe *pos; | 353 | struct AddressProbe *pos; |
351 | 354 | ||
352 | while (NULL != (pos = cstate->ap_head)) | 355 | while (NULL != (pos = cstate->ap_head)) |
353 | { | 356 | { |
354 | GNUNET_break(GNUNET_OK == | 357 | GNUNET_break (GNUNET_OK == |
355 | GNUNET_NETWORK_socket_close(pos->sock)); | 358 | GNUNET_NETWORK_socket_close (pos->sock)); |
356 | GNUNET_SCHEDULER_cancel(pos->task); | 359 | GNUNET_SCHEDULER_cancel (pos->task); |
357 | GNUNET_CONTAINER_DLL_remove(cstate->ap_head, | 360 | GNUNET_CONTAINER_DLL_remove (cstate->ap_head, |
358 | cstate->ap_tail, | 361 | cstate->ap_tail, |
359 | pos); | 362 | pos); |
360 | GNUNET_free(pos); | 363 | GNUNET_free (pos); |
361 | } | 364 | } |
362 | } | 365 | } |
363 | 366 | ||
364 | 367 | ||
@@ -370,51 +373,51 @@ cancel_aps(struct ClientState *cstate) | |||
370 | * @param impl_state our `struct ClientState` | 373 | * @param impl_state our `struct ClientState` |
371 | */ | 374 | */ |
372 | static void | 375 | static void |
373 | connection_client_destroy_impl(struct GNUNET_MQ_Handle *mq, | 376 | connection_client_destroy_impl (struct GNUNET_MQ_Handle *mq, |
374 | void *impl_state) | 377 | void *impl_state) |
375 | { | 378 | { |
376 | struct ClientState *cstate = impl_state; | 379 | struct ClientState *cstate = impl_state; |
377 | 380 | ||
378 | (void)mq; | 381 | (void) mq; |
379 | if (NULL != cstate->dns_active) | 382 | if (NULL != cstate->dns_active) |
380 | { | 383 | { |
381 | GNUNET_RESOLVER_request_cancel(cstate->dns_active); | 384 | GNUNET_RESOLVER_request_cancel (cstate->dns_active); |
382 | cstate->dns_active = NULL; | 385 | cstate->dns_active = NULL; |
383 | } | 386 | } |
384 | if (NULL != cstate->send_task) | 387 | if (NULL != cstate->send_task) |
385 | { | 388 | { |
386 | GNUNET_SCHEDULER_cancel(cstate->send_task); | 389 | GNUNET_SCHEDULER_cancel (cstate->send_task); |
387 | cstate->send_task = NULL; | 390 | cstate->send_task = NULL; |
388 | } | 391 | } |
389 | if (NULL != cstate->retry_task) | 392 | if (NULL != cstate->retry_task) |
390 | { | 393 | { |
391 | GNUNET_SCHEDULER_cancel(cstate->retry_task); | 394 | GNUNET_SCHEDULER_cancel (cstate->retry_task); |
392 | cstate->retry_task = NULL; | 395 | cstate->retry_task = NULL; |
393 | } | 396 | } |
394 | if (GNUNET_SYSERR == cstate->in_destroy) | 397 | if (GNUNET_SYSERR == cstate->in_destroy) |
395 | { | 398 | { |
396 | /* defer destruction */ | 399 | /* defer destruction */ |
397 | cstate->in_destroy = GNUNET_YES; | 400 | cstate->in_destroy = GNUNET_YES; |
398 | cstate->mq = NULL; | 401 | cstate->mq = NULL; |
399 | return; | 402 | return; |
400 | } | 403 | } |
401 | if (NULL != cstate->recv_task) | 404 | if (NULL != cstate->recv_task) |
402 | { | 405 | { |
403 | GNUNET_SCHEDULER_cancel(cstate->recv_task); | 406 | GNUNET_SCHEDULER_cancel (cstate->recv_task); |
404 | cstate->recv_task = NULL; | 407 | cstate->recv_task = NULL; |
405 | } | 408 | } |
406 | if (NULL != cstate->sock) | 409 | if (NULL != cstate->sock) |
407 | { | 410 | { |
408 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 411 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
409 | "destroying socket: %p\n", | 412 | "destroying socket: %p\n", |
410 | cstate->sock); | 413 | cstate->sock); |
411 | GNUNET_NETWORK_socket_close(cstate->sock); | 414 | GNUNET_NETWORK_socket_close (cstate->sock); |
412 | } | 415 | } |
413 | cancel_aps(cstate); | 416 | cancel_aps (cstate); |
414 | GNUNET_free(cstate->service_name); | 417 | GNUNET_free (cstate->service_name); |
415 | GNUNET_free_non_null(cstate->hostname); | 418 | GNUNET_free_non_null (cstate->hostname); |
416 | GNUNET_MST_destroy(cstate->mst); | 419 | GNUNET_MST_destroy (cstate->mst); |
417 | GNUNET_free(cstate); | 420 | GNUNET_free (cstate); |
418 | } | 421 | } |
419 | 422 | ||
420 | 423 | ||
@@ -424,39 +427,39 @@ connection_client_destroy_impl(struct GNUNET_MQ_Handle *mq, | |||
424 | * @param cls `struct ClientState` with connection to read from | 427 | * @param cls `struct ClientState` with connection to read from |
425 | */ | 428 | */ |
426 | static void | 429 | static void |
427 | receive_ready(void *cls) | 430 | receive_ready (void *cls) |
428 | { | 431 | { |
429 | struct ClientState *cstate = cls; | 432 | struct ClientState *cstate = cls; |
430 | int ret; | 433 | int ret; |
431 | 434 | ||
432 | cstate->recv_task = NULL; | 435 | cstate->recv_task = NULL; |
433 | cstate->in_destroy = GNUNET_SYSERR; | 436 | cstate->in_destroy = GNUNET_SYSERR; |
434 | ret = GNUNET_MST_read(cstate->mst, | 437 | ret = GNUNET_MST_read (cstate->mst, |
435 | cstate->sock, | 438 | cstate->sock, |
436 | GNUNET_NO, | 439 | GNUNET_NO, |
437 | GNUNET_NO); | 440 | GNUNET_NO); |
438 | if (GNUNET_SYSERR == ret) | 441 | if (GNUNET_SYSERR == ret) |
439 | { | 442 | { |
440 | if (NULL != cstate->mq) | 443 | if (NULL != cstate->mq) |
441 | GNUNET_MQ_inject_error(cstate->mq, | 444 | GNUNET_MQ_inject_error (cstate->mq, |
442 | GNUNET_MQ_ERROR_READ); | 445 | GNUNET_MQ_ERROR_READ); |
443 | if (GNUNET_YES == cstate->in_destroy) | 446 | if (GNUNET_YES == cstate->in_destroy) |
444 | connection_client_destroy_impl(cstate->mq, | 447 | connection_client_destroy_impl (cstate->mq, |
445 | cstate); | 448 | cstate); |
446 | return; | 449 | return; |
447 | } | 450 | } |
448 | if (GNUNET_YES == cstate->in_destroy) | 451 | if (GNUNET_YES == cstate->in_destroy) |
449 | { | 452 | { |
450 | connection_client_destroy_impl(cstate->mq, | 453 | connection_client_destroy_impl (cstate->mq, |
451 | cstate); | 454 | cstate); |
452 | return; | 455 | return; |
453 | } | 456 | } |
454 | cstate->in_destroy = GNUNET_NO; | 457 | cstate->in_destroy = GNUNET_NO; |
455 | cstate->recv_task | 458 | cstate->recv_task |
456 | = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | 459 | = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
457 | cstate->sock, | 460 | cstate->sock, |
458 | &receive_ready, | 461 | &receive_ready, |
459 | cstate); | 462 | cstate); |
460 | } | 463 | } |
461 | 464 | ||
462 | 465 | ||
@@ -466,23 +469,23 @@ receive_ready(void *cls) | |||
466 | * @param cstate the connection we tried to establish | 469 | * @param cstate the connection we tried to establish |
467 | */ | 470 | */ |
468 | static void | 471 | static void |
469 | connect_success_continuation(struct ClientState *cstate) | 472 | connect_success_continuation (struct ClientState *cstate) |
470 | { | 473 | { |
471 | GNUNET_assert(NULL == cstate->recv_task); | 474 | GNUNET_assert (NULL == cstate->recv_task); |
472 | cstate->recv_task | 475 | cstate->recv_task |
473 | = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | 476 | = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
474 | cstate->sock, | 477 | cstate->sock, |
475 | &receive_ready, | 478 | &receive_ready, |
476 | cstate); | 479 | cstate); |
477 | if (NULL != cstate->msg) | 480 | if (NULL != cstate->msg) |
478 | { | 481 | { |
479 | GNUNET_assert(NULL == cstate->send_task); | 482 | GNUNET_assert (NULL == cstate->send_task); |
480 | cstate->send_task | 483 | cstate->send_task |
481 | = GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, | 484 | = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, |
482 | cstate->sock, | 485 | cstate->sock, |
483 | &transmit_ready, | 486 | &transmit_ready, |
484 | cstate); | 487 | cstate); |
485 | } | 488 | } |
486 | } | 489 | } |
487 | 490 | ||
488 | 491 | ||
@@ -494,8 +497,8 @@ connect_success_continuation(struct ClientState *cstate) | |||
494 | * @return NULL on error, socket connected to UNIX otherwise | 497 | * @return NULL on error, socket connected to UNIX otherwise |
495 | */ | 498 | */ |
496 | static struct GNUNET_NETWORK_Handle * | 499 | static struct GNUNET_NETWORK_Handle * |
497 | try_unixpath(const char *service_name, | 500 | try_unixpath (const char *service_name, |
498 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 501 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
499 | { | 502 | { |
500 | #if AF_UNIX | 503 | #if AF_UNIX |
501 | struct GNUNET_NETWORK_Handle *sock; | 504 | struct GNUNET_NETWORK_Handle *sock; |
@@ -504,67 +507,56 @@ try_unixpath(const char *service_name, | |||
504 | 507 | ||
505 | unixpath = NULL; | 508 | unixpath = NULL; |
506 | if ((GNUNET_OK == | 509 | if ((GNUNET_OK == |
507 | GNUNET_CONFIGURATION_get_value_filename(cfg, | 510 | GNUNET_CONFIGURATION_get_value_filename (cfg, |
508 | service_name, | 511 | service_name, |
509 | "UNIXPATH", | 512 | "UNIXPATH", |
510 | &unixpath)) && | 513 | &unixpath)) && |
511 | (0 < strlen(unixpath))) | 514 | (0 < strlen (unixpath))) |
515 | { | ||
516 | /* We have a non-NULL unixpath, need to validate it */ | ||
517 | if (strlen (unixpath) >= sizeof(s_un.sun_path)) | ||
512 | { | 518 | { |
513 | /* We have a non-NULL unixpath, need to validate it */ | 519 | LOG (GNUNET_ERROR_TYPE_WARNING, |
514 | if (strlen(unixpath) >= sizeof(s_un.sun_path)) | 520 | _ ("UNIXPATH `%s' too long, maximum length is %llu\n"), |
515 | { | 521 | unixpath, |
516 | LOG(GNUNET_ERROR_TYPE_WARNING, | 522 | (unsigned long long) sizeof(s_un.sun_path)); |
517 | _("UNIXPATH `%s' too long, maximum length is %llu\n"), | 523 | unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath); |
518 | unixpath, | 524 | LOG (GNUNET_ERROR_TYPE_INFO, |
519 | (unsigned long long)sizeof(s_un.sun_path)); | 525 | _ ("Using `%s' instead\n"), |
520 | unixpath = GNUNET_NETWORK_shorten_unixpath(unixpath); | 526 | unixpath); |
521 | LOG(GNUNET_ERROR_TYPE_INFO, | 527 | if (NULL == unixpath) |
522 | _("Using `%s' instead\n"), | 528 | return NULL; |
523 | unixpath); | 529 | } |
524 | if (NULL == unixpath) | 530 | memset (&s_un, |
525 | return NULL; | 531 | 0, |
526 | } | 532 | sizeof(s_un)); |
527 | memset(&s_un, | 533 | s_un.sun_family = AF_UNIX; |
528 | 0, | 534 | GNUNET_strlcpy (s_un.sun_path, |
529 | sizeof(s_un)); | 535 | unixpath, |
530 | s_un.sun_family = AF_UNIX; | 536 | sizeof(s_un.sun_path)); |
531 | GNUNET_strlcpy(s_un.sun_path, | ||
532 | unixpath, | ||
533 | sizeof(s_un.sun_path)); | ||
534 | #ifdef LINUX | ||
535 | { | ||
536 | int abstract; | ||
537 | |||
538 | abstract = GNUNET_CONFIGURATION_get_value_yesno(cfg, | ||
539 | "TESTING", | ||
540 | "USE_ABSTRACT_SOCKETS"); | ||
541 | if (GNUNET_YES == abstract) | ||
542 | s_un.sun_path[0] = '\0'; | ||
543 | } | ||
544 | #endif | ||
545 | #if HAVE_SOCKADDR_UN_SUN_LEN | 537 | #if HAVE_SOCKADDR_UN_SUN_LEN |
546 | s_un.sun_len = (u_char)sizeof(struct sockaddr_un); | 538 | s_un.sun_len = (u_char) sizeof(struct sockaddr_un); |
547 | #endif | 539 | #endif |
548 | sock = GNUNET_NETWORK_socket_create(AF_UNIX, | 540 | sock = GNUNET_NETWORK_socket_create (AF_UNIX, |
549 | SOCK_STREAM, | 541 | SOCK_STREAM, |
550 | 0); | 542 | 0); |
551 | if ((NULL != sock) && | 543 | if ((NULL != sock) && |
552 | ((GNUNET_OK == | 544 | ((GNUNET_OK == |
553 | GNUNET_NETWORK_socket_connect(sock, | 545 | GNUNET_NETWORK_socket_connect (sock, |
554 | (struct sockaddr *)&s_un, | 546 | (struct sockaddr *) &s_un, |
555 | sizeof(s_un))) || | 547 | sizeof(s_un))) || |
556 | (EINPROGRESS == errno))) | 548 | (EINPROGRESS == errno))) |
557 | { | 549 | { |
558 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 550 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
559 | "Successfully connected to unixpath `%s'!\n", | 551 | "Successfully connected to unixpath `%s'!\n", |
560 | unixpath); | 552 | unixpath); |
561 | GNUNET_free(unixpath); | 553 | GNUNET_free (unixpath); |
562 | return sock; | 554 | return sock; |
563 | } | ||
564 | if (NULL != sock) | ||
565 | GNUNET_NETWORK_socket_close(sock); | ||
566 | } | 555 | } |
567 | GNUNET_free_non_null(unixpath); | 556 | if (NULL != sock) |
557 | GNUNET_NETWORK_socket_close (sock); | ||
558 | } | ||
559 | GNUNET_free_non_null (unixpath); | ||
568 | #endif | 560 | #endif |
569 | return NULL; | 561 | return NULL; |
570 | } | 562 | } |
@@ -577,7 +569,7 @@ try_unixpath(const char *service_name, | |||
577 | * @param cls the `struct AddressProbe *` with the address that we are probing | 569 | * @param cls the `struct AddressProbe *` with the address that we are probing |
578 | */ | 570 | */ |
579 | static void | 571 | static void |
580 | connect_probe_continuation(void *cls) | 572 | connect_probe_continuation (void *cls) |
581 | { | 573 | { |
582 | struct AddressProbe *ap = cls; | 574 | struct AddressProbe *ap = cls; |
583 | struct ClientState *cstate = ap->cstate; | 575 | struct ClientState *cstate = ap->cstate; |
@@ -586,40 +578,40 @@ connect_probe_continuation(void *cls) | |||
586 | socklen_t len; | 578 | socklen_t len; |
587 | 579 | ||
588 | ap->task = NULL; | 580 | ap->task = NULL; |
589 | GNUNET_assert(NULL != ap->sock); | 581 | GNUNET_assert (NULL != ap->sock); |
590 | GNUNET_CONTAINER_DLL_remove(cstate->ap_head, | 582 | GNUNET_CONTAINER_DLL_remove (cstate->ap_head, |
591 | cstate->ap_tail, | 583 | cstate->ap_tail, |
592 | ap); | 584 | ap); |
593 | len = sizeof(error); | 585 | len = sizeof(error); |
594 | error = 0; | 586 | error = 0; |
595 | tc = GNUNET_SCHEDULER_get_task_context(); | 587 | tc = GNUNET_SCHEDULER_get_task_context (); |
596 | if ((0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) || | 588 | if ((0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) || |
597 | (GNUNET_OK != | 589 | (GNUNET_OK != |
598 | GNUNET_NETWORK_socket_getsockopt(ap->sock, | 590 | GNUNET_NETWORK_socket_getsockopt (ap->sock, |
599 | SOL_SOCKET, | 591 | SOL_SOCKET, |
600 | SO_ERROR, | 592 | SO_ERROR, |
601 | &error, | 593 | &error, |
602 | &len)) || | 594 | &len)) || |
603 | (0 != error)) | 595 | (0 != error)) |
604 | { | 596 | { |
605 | GNUNET_break(GNUNET_OK == | 597 | GNUNET_break (GNUNET_OK == |
606 | GNUNET_NETWORK_socket_close(ap->sock)); | 598 | GNUNET_NETWORK_socket_close (ap->sock)); |
607 | GNUNET_free(ap); | 599 | GNUNET_free (ap); |
608 | if ((NULL == cstate->ap_head) && | 600 | if ((NULL == cstate->ap_head) && |
609 | // (NULL == cstate->proxy_handshake) && | 601 | // (NULL == cstate->proxy_handshake) && |
610 | (NULL == cstate->dns_active)) | 602 | (NULL == cstate->dns_active)) |
611 | connect_fail_continuation(cstate); | 603 | connect_fail_continuation (cstate); |
612 | return; | 604 | return; |
613 | } | 605 | } |
614 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 606 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
615 | "Connection to `%s' succeeded!\n", | 607 | "Connection to `%s' succeeded!\n", |
616 | cstate->service_name); | 608 | cstate->service_name); |
617 | /* trigger jobs that waited for the connection */ | 609 | /* trigger jobs that waited for the connection */ |
618 | GNUNET_assert(NULL == cstate->sock); | 610 | GNUNET_assert (NULL == cstate->sock); |
619 | cstate->sock = ap->sock; | 611 | cstate->sock = ap->sock; |
620 | GNUNET_free(ap); | 612 | GNUNET_free (ap); |
621 | cancel_aps(cstate); | 613 | cancel_aps (cstate); |
622 | connect_success_continuation(cstate); | 614 | connect_success_continuation (cstate); |
623 | } | 615 | } |
624 | 616 | ||
625 | 617 | ||
@@ -632,82 +624,82 @@ connect_probe_continuation(void *cls) | |||
632 | * @param addrlen length of @a addr | 624 | * @param addrlen length of @a addr |
633 | */ | 625 | */ |
634 | static void | 626 | static void |
635 | try_connect_using_address(void *cls, | 627 | try_connect_using_address (void *cls, |
636 | const struct sockaddr *addr, | 628 | const struct sockaddr *addr, |
637 | socklen_t addrlen) | 629 | socklen_t addrlen) |
638 | { | 630 | { |
639 | struct ClientState *cstate = cls; | 631 | struct ClientState *cstate = cls; |
640 | struct AddressProbe *ap; | 632 | struct AddressProbe *ap; |
641 | 633 | ||
642 | if (NULL == addr) | 634 | if (NULL == addr) |
643 | { | 635 | { |
644 | cstate->dns_active = NULL; | 636 | cstate->dns_active = NULL; |
645 | if ((NULL == cstate->ap_head) && | 637 | if ((NULL == cstate->ap_head) && |
646 | // (NULL == cstate->proxy_handshake) && | 638 | // (NULL == cstate->proxy_handshake) && |
647 | (NULL == cstate->sock)) | 639 | (NULL == cstate->sock)) |
648 | connect_fail_continuation(cstate); | 640 | connect_fail_continuation (cstate); |
649 | return; | 641 | return; |
650 | } | 642 | } |
651 | if (NULL != cstate->sock) | 643 | if (NULL != cstate->sock) |
652 | return; /* already connected */ | 644 | return; /* already connected */ |
653 | /* try to connect */ | 645 | /* try to connect */ |
654 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 646 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
655 | "Trying to connect using address `%s:%u'\n", | 647 | "Trying to connect using address `%s:%u'\n", |
656 | GNUNET_a2s(addr, | 648 | GNUNET_a2s (addr, |
657 | addrlen), | 649 | addrlen), |
658 | cstate->port); | 650 | cstate->port); |
659 | ap = GNUNET_malloc(sizeof(struct AddressProbe) + addrlen); | 651 | ap = GNUNET_malloc (sizeof(struct AddressProbe) + addrlen); |
660 | ap->addr = (const struct sockaddr *)&ap[1]; | 652 | ap->addr = (const struct sockaddr *) &ap[1]; |
661 | GNUNET_memcpy(&ap[1], | 653 | GNUNET_memcpy (&ap[1], |
662 | addr, | 654 | addr, |
663 | addrlen); | 655 | addrlen); |
664 | ap->addrlen = addrlen; | 656 | ap->addrlen = addrlen; |
665 | ap->cstate = cstate; | 657 | ap->cstate = cstate; |
666 | 658 | ||
667 | switch (ap->addr->sa_family) | 659 | switch (ap->addr->sa_family) |
668 | { | 660 | { |
669 | case AF_INET: | 661 | case AF_INET: |
670 | ((struct sockaddr_in *)ap->addr)->sin_port = htons(cstate->port); | 662 | ((struct sockaddr_in *) ap->addr)->sin_port = htons (cstate->port); |
671 | break; | 663 | break; |
672 | 664 | ||
673 | case AF_INET6: | 665 | case AF_INET6: |
674 | ((struct sockaddr_in6 *)ap->addr)->sin6_port = htons(cstate->port); | 666 | ((struct sockaddr_in6 *) ap->addr)->sin6_port = htons (cstate->port); |
675 | break; | 667 | break; |
676 | 668 | ||
677 | default: | 669 | default: |
678 | GNUNET_break(0); | 670 | GNUNET_break (0); |
679 | GNUNET_free(ap); | 671 | GNUNET_free (ap); |
680 | return; /* not supported by us */ | 672 | return; /* not supported by us */ |
681 | } | 673 | } |
682 | ap->sock = GNUNET_NETWORK_socket_create(ap->addr->sa_family, | 674 | ap->sock = GNUNET_NETWORK_socket_create (ap->addr->sa_family, |
683 | SOCK_STREAM, | 675 | SOCK_STREAM, |
684 | 0); | 676 | 0); |
685 | if (NULL == ap->sock) | 677 | if (NULL == ap->sock) |
686 | { | 678 | { |
687 | GNUNET_free(ap); | 679 | GNUNET_free (ap); |
688 | return; /* not supported by OS */ | 680 | return; /* not supported by OS */ |
689 | } | 681 | } |
690 | if ((GNUNET_OK != | 682 | if ((GNUNET_OK != |
691 | GNUNET_NETWORK_socket_connect(ap->sock, | 683 | GNUNET_NETWORK_socket_connect (ap->sock, |
692 | ap->addr, | 684 | ap->addr, |
693 | ap->addrlen)) && | 685 | ap->addrlen)) && |
694 | (EINPROGRESS != errno)) | 686 | (EINPROGRESS != errno)) |
695 | { | 687 | { |
696 | /* maybe refused / unsupported address, try next */ | 688 | /* maybe refused / unsupported address, try next */ |
697 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_INFO, | 689 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, |
698 | "connect"); | 690 | "connect"); |
699 | GNUNET_break(GNUNET_OK == | 691 | GNUNET_break (GNUNET_OK == |
700 | GNUNET_NETWORK_socket_close(ap->sock)); | 692 | GNUNET_NETWORK_socket_close (ap->sock)); |
701 | GNUNET_free(ap); | 693 | GNUNET_free (ap); |
702 | return; | 694 | return; |
703 | } | 695 | } |
704 | GNUNET_CONTAINER_DLL_insert(cstate->ap_head, | 696 | GNUNET_CONTAINER_DLL_insert (cstate->ap_head, |
705 | cstate->ap_tail, | 697 | cstate->ap_tail, |
706 | ap); | 698 | ap); |
707 | ap->task = GNUNET_SCHEDULER_add_write_net(CONNECT_RETRY_TIMEOUT, | 699 | ap->task = GNUNET_SCHEDULER_add_write_net (CONNECT_RETRY_TIMEOUT, |
708 | ap->sock, | 700 | ap->sock, |
709 | &connect_probe_continuation, | 701 | &connect_probe_continuation, |
710 | ap); | 702 | ap); |
711 | } | 703 | } |
712 | 704 | ||
713 | 705 | ||
@@ -720,8 +712,8 @@ try_connect_using_address(void *cls, | |||
720 | * @return #GNUNET_OK if the configuration is valid, #GNUNET_SYSERR if not | 712 | * @return #GNUNET_OK if the configuration is valid, #GNUNET_SYSERR if not |
721 | */ | 713 | */ |
722 | static int | 714 | static int |
723 | test_service_configuration(const char *service_name, | 715 | test_service_configuration (const char *service_name, |
724 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 716 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
725 | { | 717 | { |
726 | int ret = GNUNET_SYSERR; | 718 | int ret = GNUNET_SYSERR; |
727 | char *hostname = NULL; | 719 | char *hostname = NULL; |
@@ -731,45 +723,45 @@ test_service_configuration(const char *service_name, | |||
731 | char *unixpath = NULL; | 723 | char *unixpath = NULL; |
732 | 724 | ||
733 | if ((GNUNET_OK == | 725 | if ((GNUNET_OK == |
734 | GNUNET_CONFIGURATION_get_value_filename(cfg, | 726 | GNUNET_CONFIGURATION_get_value_filename (cfg, |
735 | service_name, | 727 | service_name, |
736 | "UNIXPATH", | 728 | "UNIXPATH", |
737 | &unixpath)) && | 729 | &unixpath)) && |
738 | (0 < strlen(unixpath))) | 730 | (0 < strlen (unixpath))) |
739 | ret = GNUNET_OK; | 731 | ret = GNUNET_OK; |
740 | else if ((GNUNET_OK == | 732 | else if ((GNUNET_OK == |
741 | GNUNET_CONFIGURATION_have_value(cfg, | 733 | GNUNET_CONFIGURATION_have_value (cfg, |
742 | service_name, | 734 | service_name, |
743 | "UNIXPATH"))) | 735 | "UNIXPATH"))) |
744 | { | 736 | { |
745 | GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR, | 737 | GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, |
746 | service_name, | 738 | service_name, |
747 | "UNIXPATH", | 739 | "UNIXPATH", |
748 | _("not a valid filename")); | 740 | _ ("not a valid filename")); |
749 | return GNUNET_SYSERR; /* UNIXPATH specified but invalid! */ | 741 | return GNUNET_SYSERR; /* UNIXPATH specified but invalid! */ |
750 | } | 742 | } |
751 | GNUNET_free_non_null(unixpath); | 743 | GNUNET_free_non_null (unixpath); |
752 | #endif | 744 | #endif |
753 | 745 | ||
754 | if ((GNUNET_YES == | 746 | if ((GNUNET_YES == |
755 | GNUNET_CONFIGURATION_have_value(cfg, | 747 | GNUNET_CONFIGURATION_have_value (cfg, |
756 | service_name, | 748 | service_name, |
757 | "PORT")) && | 749 | "PORT")) && |
758 | (GNUNET_OK == | 750 | (GNUNET_OK == |
759 | GNUNET_CONFIGURATION_get_value_number(cfg, | 751 | GNUNET_CONFIGURATION_get_value_number (cfg, |
760 | service_name, | 752 | service_name, |
761 | "PORT", | 753 | "PORT", |
762 | &port)) && | 754 | &port)) && |
763 | (port <= 65535) && | 755 | (port <= 65535) && |
764 | (0 != port) && | 756 | (0 != port) && |
765 | (GNUNET_OK == | 757 | (GNUNET_OK == |
766 | GNUNET_CONFIGURATION_get_value_string(cfg, | 758 | GNUNET_CONFIGURATION_get_value_string (cfg, |
767 | service_name, | 759 | service_name, |
768 | "HOSTNAME", | 760 | "HOSTNAME", |
769 | &hostname)) && | 761 | &hostname)) && |
770 | (0 != strlen(hostname))) | 762 | (0 != strlen (hostname))) |
771 | ret = GNUNET_OK; | 763 | ret = GNUNET_OK; |
772 | GNUNET_free_non_null(hostname); | 764 | GNUNET_free_non_null (hostname); |
773 | return ret; | 765 | return ret; |
774 | } | 766 | } |
775 | 767 | ||
@@ -780,7 +772,7 @@ test_service_configuration(const char *service_name, | |||
780 | * @param cls the `struct ClientState` to try to connect to the service | 772 | * @param cls the `struct ClientState` to try to connect to the service |
781 | */ | 773 | */ |
782 | static void | 774 | static void |
783 | start_connect(void *cls) | 775 | start_connect (void *cls) |
784 | { | 776 | { |
785 | struct ClientState *cstate = cls; | 777 | struct ClientState *cstate = cls; |
786 | 778 | ||
@@ -788,41 +780,41 @@ start_connect(void *cls) | |||
788 | #if 0 | 780 | #if 0 |
789 | /* Never use a local source if a proxy is configured */ | 781 | /* Never use a local source if a proxy is configured */ |
790 | if (GNUNET_YES == | 782 | if (GNUNET_YES == |
791 | GNUNET_SOCKS_check_service(cstate->service_name, | 783 | GNUNET_SOCKS_check_service (cstate->service_name, |
792 | cstate->cfg)) | 784 | cstate->cfg)) |
793 | { | 785 | { |
794 | socks_connect(cstate); | 786 | socks_connect (cstate); |
795 | return; | 787 | return; |
796 | } | 788 | } |
797 | #endif | 789 | #endif |
798 | 790 | ||
799 | if ((0 == (cstate->attempts++ % 2)) || | 791 | if ((0 == (cstate->attempts++ % 2)) || |
800 | (0 == cstate->port) || | 792 | (0 == cstate->port) || |
801 | (NULL == cstate->hostname)) | 793 | (NULL == cstate->hostname)) |
794 | { | ||
795 | /* on even rounds, try UNIX first, or always | ||
796 | if we do not have a DNS name and TCP port. */ | ||
797 | cstate->sock = try_unixpath (cstate->service_name, | ||
798 | cstate->cfg); | ||
799 | if (NULL != cstate->sock) | ||
802 | { | 800 | { |
803 | /* on even rounds, try UNIX first, or always | 801 | connect_success_continuation (cstate); |
804 | if we do not have a DNS name and TCP port. */ | 802 | return; |
805 | cstate->sock = try_unixpath(cstate->service_name, | ||
806 | cstate->cfg); | ||
807 | if (NULL != cstate->sock) | ||
808 | { | ||
809 | connect_success_continuation(cstate); | ||
810 | return; | ||
811 | } | ||
812 | } | 803 | } |
804 | } | ||
813 | if ((NULL == cstate->hostname) || | 805 | if ((NULL == cstate->hostname) || |
814 | (0 == cstate->port)) | 806 | (0 == cstate->port)) |
815 | { | 807 | { |
816 | /* All options failed. Boo! */ | 808 | /* All options failed. Boo! */ |
817 | connect_fail_continuation(cstate); | 809 | connect_fail_continuation (cstate); |
818 | return; | 810 | return; |
819 | } | 811 | } |
820 | cstate->dns_active | 812 | cstate->dns_active |
821 | = GNUNET_RESOLVER_ip_get(cstate->hostname, | 813 | = GNUNET_RESOLVER_ip_get (cstate->hostname, |
822 | AF_UNSPEC, | 814 | AF_UNSPEC, |
823 | CONNECT_RETRY_TIMEOUT, | 815 | CONNECT_RETRY_TIMEOUT, |
824 | &try_connect_using_address, | 816 | &try_connect_using_address, |
825 | cstate); | 817 | cstate); |
826 | } | 818 | } |
827 | 819 | ||
828 | 820 | ||
@@ -834,30 +826,30 @@ start_connect(void *cls) | |||
834 | * @param impl_state our `struct ClientState` | 826 | * @param impl_state our `struct ClientState` |
835 | */ | 827 | */ |
836 | static void | 828 | static void |
837 | connection_client_send_impl(struct GNUNET_MQ_Handle *mq, | 829 | connection_client_send_impl (struct GNUNET_MQ_Handle *mq, |
838 | const struct GNUNET_MessageHeader *msg, | 830 | const struct GNUNET_MessageHeader *msg, |
839 | void *impl_state) | 831 | void *impl_state) |
840 | { | 832 | { |
841 | struct ClientState *cstate = impl_state; | 833 | struct ClientState *cstate = impl_state; |
842 | 834 | ||
843 | (void)mq; | 835 | (void) mq; |
844 | /* only one message at a time allowed */ | 836 | /* only one message at a time allowed */ |
845 | GNUNET_assert(NULL == cstate->msg); | 837 | GNUNET_assert (NULL == cstate->msg); |
846 | GNUNET_assert(NULL == cstate->send_task); | 838 | GNUNET_assert (NULL == cstate->send_task); |
847 | cstate->msg = msg; | 839 | cstate->msg = msg; |
848 | cstate->msg_off = 0; | 840 | cstate->msg_off = 0; |
849 | if (NULL == cstate->sock) | 841 | if (NULL == cstate->sock) |
850 | { | 842 | { |
851 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 843 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
852 | "message of type %u waiting for socket\n", | 844 | "message of type %u waiting for socket\n", |
853 | ntohs(msg->type)); | 845 | ntohs (msg->type)); |
854 | return; /* still waiting for connection */ | 846 | return; /* still waiting for connection */ |
855 | } | 847 | } |
856 | cstate->send_task | 848 | cstate->send_task |
857 | = GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, | 849 | = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, |
858 | cstate->sock, | 850 | cstate->sock, |
859 | &transmit_ready, | 851 | &transmit_ready, |
860 | cstate); | 852 | cstate); |
861 | } | 853 | } |
862 | 854 | ||
863 | 855 | ||
@@ -868,20 +860,186 @@ connection_client_send_impl(struct GNUNET_MQ_Handle *mq, | |||
868 | * @param impl_state our `struct ClientState` | 860 | * @param impl_state our `struct ClientState` |
869 | */ | 861 | */ |
870 | static void | 862 | static void |
871 | connection_client_cancel_impl(struct GNUNET_MQ_Handle *mq, | 863 | connection_client_cancel_impl (struct GNUNET_MQ_Handle *mq, |
872 | void *impl_state) | 864 | void *impl_state) |
873 | { | 865 | { |
874 | struct ClientState *cstate = impl_state; | 866 | struct ClientState *cstate = impl_state; |
875 | 867 | ||
876 | (void)mq; | 868 | (void) mq; |
877 | GNUNET_assert(NULL != cstate->msg); | 869 | GNUNET_assert (NULL != cstate->msg); |
878 | GNUNET_assert(0 == cstate->msg_off); | 870 | GNUNET_assert (0 == cstate->msg_off); |
879 | cstate->msg = NULL; | 871 | cstate->msg = NULL; |
880 | if (NULL != cstate->send_task) | 872 | if (NULL != cstate->send_task) |
873 | { | ||
874 | GNUNET_SCHEDULER_cancel (cstate->send_task); | ||
875 | cstate->send_task = NULL; | ||
876 | } | ||
877 | } | ||
878 | |||
879 | |||
880 | /** | ||
881 | * Test if the port or UNIXPATH of the given @a service_name | ||
882 | * is in use and thus (most likely) the respective service is up. | ||
883 | * | ||
884 | * @param cfg our configuration | ||
885 | * @param service_name name of the service to connect to | ||
886 | * @return #GNUNET_YES if the service is (likely) up, | ||
887 | * #GNUNET_NO if the service is (definitively) down, | ||
888 | * #GNUNET_SYSERR if the configuration does not give us | ||
889 | * the necessary information about the service, or if | ||
890 | * we could not check (i.e. socket() failed) | ||
891 | */ | ||
892 | int | ||
893 | GNUNET_CLIENT_test (const struct GNUNET_CONFIGURATION_Handle *cfg, | ||
894 | const char *service_name) | ||
895 | { | ||
896 | char *hostname = NULL; | ||
897 | unsigned long long port; | ||
898 | int ret; | ||
899 | |||
900 | #if AF_UNIX | ||
901 | { | ||
902 | char *unixpath = NULL; | ||
903 | |||
904 | if (GNUNET_OK == | ||
905 | GNUNET_CONFIGURATION_get_value_filename (cfg, | ||
906 | service_name, | ||
907 | "UNIXPATH", | ||
908 | &unixpath)) | ||
881 | { | 909 | { |
882 | GNUNET_SCHEDULER_cancel(cstate->send_task); | 910 | if (0 == strlen (unixpath)) |
883 | cstate->send_task = NULL; | 911 | { |
912 | GNUNET_free (unixpath); | ||
913 | return GNUNET_SYSERR; /* empty string not OK */ | ||
914 | } | ||
915 | if (0 == access (unixpath, | ||
916 | F_OK)) | ||
917 | { | ||
918 | GNUNET_free (unixpath); | ||
919 | return GNUNET_OK; /* file exists, we assume service is running */ | ||
920 | } | ||
921 | GNUNET_free (unixpath); | ||
922 | } | ||
923 | else if (GNUNET_OK == | ||
924 | GNUNET_CONFIGURATION_have_value (cfg, | ||
925 | service_name, | ||
926 | "UNIXPATH")) | ||
927 | { | ||
928 | /* UNIXPATH specified but not a valid path! */ | ||
929 | GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, | ||
930 | service_name, | ||
931 | "UNIXPATH", | ||
932 | _ ("not a valid filename")); | ||
933 | return GNUNET_SYSERR; | ||
884 | } | 934 | } |
935 | } | ||
936 | #endif | ||
937 | |||
938 | if ( (GNUNET_OK != | ||
939 | GNUNET_CONFIGURATION_get_value_number (cfg, | ||
940 | service_name, | ||
941 | "PORT", | ||
942 | &port)) || | ||
943 | (port > 65535) || | ||
944 | (0 == port) ) | ||
945 | { | ||
946 | return GNUNET_SYSERR; | ||
947 | } | ||
948 | if (GNUNET_OK == | ||
949 | GNUNET_CONFIGURATION_get_value_string (cfg, | ||
950 | service_name, | ||
951 | "HOSTNAME", | ||
952 | &hostname)) | ||
953 | { | ||
954 | /* We always assume remotes are up */ | ||
955 | ret = GNUNET_YES; | ||
956 | } | ||
957 | else | ||
958 | { | ||
959 | /* We look for evidence the service is up */ | ||
960 | ret = GNUNET_NO; | ||
961 | } | ||
962 | if ( (NULL == hostname) || | ||
963 | (0 == strcasecmp (hostname, | ||
964 | "localhost")) || | ||
965 | (0 == strcasecmp (hostname, | ||
966 | "ip6-localnet")) ) | ||
967 | { | ||
968 | /* service runs on loopback */ | ||
969 | struct sockaddr_in v4; | ||
970 | struct sockaddr_in6 v6; | ||
971 | int sock; | ||
972 | |||
973 | memset (&v4, 0, sizeof (v4)); | ||
974 | memset (&v6, 0, sizeof (v6)); | ||
975 | v4.sin_family = AF_INET; | ||
976 | v4.sin_port = htons ((uint16_t) port); | ||
977 | #if HAVE_SOCKADDR_IN_SUN_LEN | ||
978 | v4.sin_len = (u_char) sizeof(struct sockaddr_in); | ||
979 | #endif | ||
980 | inet_pton (AF_INET, | ||
981 | "127.0.0.1", | ||
982 | &v4.sin_addr); | ||
983 | ret = GNUNET_NO; | ||
984 | sock = socket (AF_INET, | ||
985 | SOCK_STREAM, | ||
986 | 0); | ||
987 | if (-1 != sock) | ||
988 | { | ||
989 | if (0 != bind (sock, | ||
990 | (struct sockaddr *) &v4, | ||
991 | sizeof (v4))) | ||
992 | { | ||
993 | /* bind failed, so someone is listening! */ | ||
994 | ret = GNUNET_YES; | ||
995 | } | ||
996 | (void) close (sock); | ||
997 | } | ||
998 | else | ||
999 | { | ||
1000 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, | ||
1001 | "socket"); | ||
1002 | if (GNUNET_NO == ret) | ||
1003 | ret = GNUNET_SYSERR; | ||
1004 | } | ||
1005 | v6.sin6_family = AF_INET6; | ||
1006 | v6.sin6_port = htons ((uint16_t) port); | ||
1007 | #if HAVE_SOCKADDR_IN_SUN_LEN | ||
1008 | v6.sin6_len = (u_char) sizeof(struct sockaddr_in6); | ||
1009 | #endif | ||
1010 | inet_pton (AF_INET6, | ||
1011 | "::1", | ||
1012 | &v6.sin6_addr); | ||
1013 | sock = socket (AF_INET6, | ||
1014 | SOCK_STREAM, | ||
1015 | 0); | ||
1016 | if (-1 != sock) | ||
1017 | { | ||
1018 | if (0 != bind (sock, | ||
1019 | (struct sockaddr *) &v6, | ||
1020 | sizeof (v6))) | ||
1021 | { | ||
1022 | /* bind failed, so someone is listening! */ | ||
1023 | ret = GNUNET_YES; | ||
1024 | } | ||
1025 | (void) close (sock); | ||
1026 | } | ||
1027 | else | ||
1028 | { | ||
1029 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, | ||
1030 | "socket"); | ||
1031 | /* not changing 'ret' intentionally here, as | ||
1032 | v4 succeeding and v6 failing just means we | ||
1033 | should use v4 */ | ||
1034 | } | ||
1035 | } | ||
1036 | else | ||
1037 | { | ||
1038 | /* service running remotely */ | ||
1039 | ret = GNUNET_OK; | ||
1040 | } | ||
1041 | GNUNET_free_non_null (hostname); | ||
1042 | return ret; | ||
885 | } | 1043 | } |
886 | 1044 | ||
887 | 1045 | ||
@@ -897,57 +1055,57 @@ connection_client_cancel_impl(struct GNUNET_MQ_Handle *mq, | |||
897 | * @return the message queue, NULL on error | 1055 | * @return the message queue, NULL on error |
898 | */ | 1056 | */ |
899 | struct GNUNET_MQ_Handle * | 1057 | struct GNUNET_MQ_Handle * |
900 | GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, | 1058 | GNUNET_CLIENT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, |
901 | const char *service_name, | 1059 | const char *service_name, |
902 | const struct GNUNET_MQ_MessageHandler *handlers, | 1060 | const struct GNUNET_MQ_MessageHandler *handlers, |
903 | GNUNET_MQ_ErrorHandler error_handler, | 1061 | GNUNET_MQ_ErrorHandler error_handler, |
904 | void *error_handler_cls) | 1062 | void *error_handler_cls) |
905 | { | 1063 | { |
906 | struct ClientState *cstate; | 1064 | struct ClientState *cstate; |
907 | 1065 | ||
908 | if (GNUNET_OK != | 1066 | if (GNUNET_OK != |
909 | test_service_configuration(service_name, | 1067 | test_service_configuration (service_name, |
910 | cfg)) | 1068 | cfg)) |
911 | return NULL; | 1069 | return NULL; |
912 | cstate = GNUNET_new(struct ClientState); | 1070 | cstate = GNUNET_new (struct ClientState); |
913 | cstate->service_name = GNUNET_strdup(service_name); | 1071 | cstate->service_name = GNUNET_strdup (service_name); |
914 | cstate->cfg = cfg; | 1072 | cstate->cfg = cfg; |
915 | cstate->retry_task = GNUNET_SCHEDULER_add_now(&start_connect, | 1073 | cstate->retry_task = GNUNET_SCHEDULER_add_now (&start_connect, |
916 | cstate); | 1074 | cstate); |
917 | cstate->mst = GNUNET_MST_create(&recv_message, | 1075 | cstate->mst = GNUNET_MST_create (&recv_message, |
918 | cstate); | 1076 | cstate); |
919 | if (GNUNET_YES == | 1077 | if (GNUNET_YES == |
920 | GNUNET_CONFIGURATION_have_value(cfg, | 1078 | GNUNET_CONFIGURATION_have_value (cfg, |
921 | service_name, | 1079 | service_name, |
922 | "PORT")) | 1080 | "PORT")) |
923 | { | 1081 | { |
924 | if (!((GNUNET_OK != | 1082 | if (! ((GNUNET_OK != |
925 | GNUNET_CONFIGURATION_get_value_number(cfg, | 1083 | GNUNET_CONFIGURATION_get_value_number (cfg, |
926 | service_name, | 1084 | service_name, |
927 | "PORT", | 1085 | "PORT", |
928 | &cstate->port)) || | 1086 | &cstate->port)) || |
929 | (cstate->port > 65535) || | 1087 | (cstate->port > 65535) || |
930 | (GNUNET_OK != | 1088 | (GNUNET_OK != |
931 | GNUNET_CONFIGURATION_get_value_string(cfg, | 1089 | GNUNET_CONFIGURATION_get_value_string (cfg, |
932 | service_name, | 1090 | service_name, |
933 | "HOSTNAME", | 1091 | "HOSTNAME", |
934 | &cstate->hostname))) && | 1092 | &cstate->hostname))) && |
935 | (0 == strlen(cstate->hostname))) | 1093 | (0 == strlen (cstate->hostname))) |
936 | { | 1094 | { |
937 | GNUNET_free(cstate->hostname); | 1095 | GNUNET_free (cstate->hostname); |
938 | cstate->hostname = NULL; | 1096 | cstate->hostname = NULL; |
939 | LOG(GNUNET_ERROR_TYPE_WARNING, | 1097 | LOG (GNUNET_ERROR_TYPE_WARNING, |
940 | _("Need a non-empty hostname for service `%s'.\n"), | 1098 | _ ("Need a non-empty hostname for service `%s'.\n"), |
941 | service_name); | 1099 | service_name); |
942 | } | ||
943 | } | 1100 | } |
944 | cstate->mq = GNUNET_MQ_queue_for_callbacks(&connection_client_send_impl, | 1101 | } |
945 | &connection_client_destroy_impl, | 1102 | cstate->mq = GNUNET_MQ_queue_for_callbacks (&connection_client_send_impl, |
946 | &connection_client_cancel_impl, | 1103 | &connection_client_destroy_impl, |
947 | cstate, | 1104 | &connection_client_cancel_impl, |
948 | handlers, | 1105 | cstate, |
949 | error_handler, | 1106 | handlers, |
950 | error_handler_cls); | 1107 | error_handler, |
1108 | error_handler_cls); | ||
951 | return cstate->mq; | 1109 | return cstate->mq; |
952 | } | 1110 | } |
953 | 1111 | ||
diff --git a/src/util/service.c b/src/util/service.c index b0f4ea289..21b99547c 100644 --- a/src/util/service.c +++ b/src/util/service.c | |||
@@ -37,19 +37,20 @@ | |||
37 | #endif | 37 | #endif |
38 | 38 | ||
39 | 39 | ||
40 | #define LOG(kind, ...) GNUNET_log_from(kind, "util-service", __VA_ARGS__) | 40 | #define LOG(kind, ...) GNUNET_log_from (kind, "util-service", __VA_ARGS__) |
41 | 41 | ||
42 | #define LOG_STRERROR(kind, syscall) \ | 42 | #define LOG_STRERROR(kind, syscall) \ |
43 | GNUNET_log_from_strerror(kind, "util-service", syscall) | 43 | GNUNET_log_from_strerror (kind, "util-service", syscall) |
44 | 44 | ||
45 | #define LOG_STRERROR_FILE(kind, syscall, filename) \ | 45 | #define LOG_STRERROR_FILE(kind, syscall, filename) \ |
46 | GNUNET_log_from_strerror_file(kind, "util-service", syscall, filename) | 46 | GNUNET_log_from_strerror_file (kind, "util-service", syscall, filename) |
47 | 47 | ||
48 | 48 | ||
49 | /** | 49 | /** |
50 | * Information the service tracks per listen operation. | 50 | * Information the service tracks per listen operation. |
51 | */ | 51 | */ |
52 | struct ServiceListenContext { | 52 | struct ServiceListenContext |
53 | { | ||
53 | /** | 54 | /** |
54 | * Kept in a DLL. | 55 | * Kept in a DLL. |
55 | */ | 56 | */ |
@@ -80,7 +81,8 @@ struct ServiceListenContext { | |||
80 | /** | 81 | /** |
81 | * Reasons why we might be suspended. | 82 | * Reasons why we might be suspended. |
82 | */ | 83 | */ |
83 | enum SuspendReason { | 84 | enum SuspendReason |
85 | { | ||
84 | /** | 86 | /** |
85 | * We are running normally. | 87 | * We are running normally. |
86 | */ | 88 | */ |
@@ -111,7 +113,8 @@ enum SuspendReason { | |||
111 | /** | 113 | /** |
112 | * Handle to a service. | 114 | * Handle to a service. |
113 | */ | 115 | */ |
114 | struct GNUNET_SERVICE_Handle { | 116 | struct GNUNET_SERVICE_Handle |
117 | { | ||
115 | /** | 118 | /** |
116 | * Our configuration. | 119 | * Our configuration. |
117 | */ | 120 | */ |
@@ -172,6 +175,7 @@ struct GNUNET_SERVICE_Handle { | |||
172 | */ | 175 | */ |
173 | void *task_cls; | 176 | void *task_cls; |
174 | 177 | ||
178 | |||
175 | /** | 179 | /** |
176 | * IPv4 addresses that are not allowed to connect. | 180 | * IPv4 addresses that are not allowed to connect. |
177 | */ | 181 | */ |
@@ -243,7 +247,8 @@ struct GNUNET_SERVICE_Handle { | |||
243 | /** | 247 | /** |
244 | * Handle to a client that is connected to a service. | 248 | * Handle to a client that is connected to a service. |
245 | */ | 249 | */ |
246 | struct GNUNET_SERVICE_Client { | 250 | struct GNUNET_SERVICE_Client |
251 | { | ||
247 | /** | 252 | /** |
248 | * Kept in a DLL. | 253 | * Kept in a DLL. |
249 | */ | 254 | */ |
@@ -353,15 +358,15 @@ struct GNUNET_SERVICE_Client { | |||
353 | * @return #GNUNET_YES if we have non-monitoring clients left | 358 | * @return #GNUNET_YES if we have non-monitoring clients left |
354 | */ | 359 | */ |
355 | static int | 360 | static int |
356 | have_non_monitor_clients(struct GNUNET_SERVICE_Handle *sh) | 361 | have_non_monitor_clients (struct GNUNET_SERVICE_Handle *sh) |
357 | { | 362 | { |
358 | for (struct GNUNET_SERVICE_Client *client = sh->clients_head; NULL != client; | 363 | for (struct GNUNET_SERVICE_Client *client = sh->clients_head; NULL != client; |
359 | client = client->next) | 364 | client = client->next) |
360 | { | 365 | { |
361 | if (client->is_monitor) | 366 | if (client->is_monitor) |
362 | continue; | 367 | continue; |
363 | return GNUNET_YES; | 368 | return GNUNET_YES; |
364 | } | 369 | } |
365 | return GNUNET_NO; | 370 | return GNUNET_NO; |
366 | } | 371 | } |
367 | 372 | ||
@@ -374,20 +379,20 @@ have_non_monitor_clients(struct GNUNET_SERVICE_Handle *sh) | |||
374 | * @param sr reason for suspending accepting connections | 379 | * @param sr reason for suspending accepting connections |
375 | */ | 380 | */ |
376 | static void | 381 | static void |
377 | do_suspend(struct GNUNET_SERVICE_Handle *sh, enum SuspendReason sr) | 382 | do_suspend (struct GNUNET_SERVICE_Handle *sh, enum SuspendReason sr) |
378 | { | 383 | { |
379 | struct ServiceListenContext *slc; | 384 | struct ServiceListenContext *slc; |
380 | 385 | ||
381 | GNUNET_assert(0 == (sh->suspend_state & sr)); | 386 | GNUNET_assert (0 == (sh->suspend_state & sr)); |
382 | sh->suspend_state |= sr; | 387 | sh->suspend_state |= sr; |
383 | for (slc = sh->slc_head; NULL != slc; slc = slc->next) | 388 | for (slc = sh->slc_head; NULL != slc; slc = slc->next) |
389 | { | ||
390 | if (NULL != slc->listen_task) | ||
384 | { | 391 | { |
385 | if (NULL != slc->listen_task) | 392 | GNUNET_SCHEDULER_cancel (slc->listen_task); |
386 | { | 393 | slc->listen_task = NULL; |
387 | GNUNET_SCHEDULER_cancel(slc->listen_task); | ||
388 | slc->listen_task = NULL; | ||
389 | } | ||
390 | } | 394 | } |
395 | } | ||
391 | } | 396 | } |
392 | 397 | ||
393 | 398 | ||
@@ -400,29 +405,27 @@ do_suspend(struct GNUNET_SERVICE_Handle *sh, enum SuspendReason sr) | |||
400 | * @param cls our `struct GNUNET_SERVICE_Handle` | 405 | * @param cls our `struct GNUNET_SERVICE_Handle` |
401 | */ | 406 | */ |
402 | static void | 407 | static void |
403 | service_shutdown(void *cls) | 408 | service_shutdown (void *cls) |
404 | { | 409 | { |
405 | struct GNUNET_SERVICE_Handle *sh = cls; | 410 | struct GNUNET_SERVICE_Handle *sh = cls; |
406 | 411 | ||
407 | switch (sh->options) | 412 | switch (sh->options & GNUNET_SERVICE_OPTION_SHUTDOWN_BITMASK) |
408 | { | 413 | { |
409 | case GNUNET_SERVICE_OPTION_NONE: | 414 | case GNUNET_SERVICE_OPTION_NONE: |
410 | GNUNET_SERVICE_shutdown(sh); | 415 | GNUNET_SERVICE_shutdown (sh); |
411 | break; | 416 | break; |
412 | 417 | case GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN: | |
413 | case GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN: | 418 | /* This task should never be run if we are using |
414 | /* This task should never be run if we are using | 419 | the manual shutdown. */ |
415 | the manual shutdown. */ | 420 | GNUNET_assert (0); |
416 | GNUNET_assert(0); | 421 | break; |
417 | break; | 422 | case GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN: |
418 | 423 | if (0 == (sh->suspend_state & SUSPEND_STATE_SHUTDOWN)) | |
419 | case GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN: | 424 | do_suspend (sh, SUSPEND_STATE_SHUTDOWN); |
420 | if (0 == (sh->suspend_state & SUSPEND_STATE_SHUTDOWN)) | 425 | if (GNUNET_NO == have_non_monitor_clients (sh)) |
421 | do_suspend(sh, SUSPEND_STATE_SHUTDOWN); | 426 | GNUNET_SERVICE_shutdown (sh); |
422 | if (GNUNET_NO == have_non_monitor_clients(sh)) | 427 | break; |
423 | GNUNET_SERVICE_shutdown(sh); | 428 | } |
424 | break; | ||
425 | } | ||
426 | } | 429 | } |
427 | 430 | ||
428 | 431 | ||
@@ -434,8 +437,8 @@ service_shutdown(void *cls) | |||
434 | * @return #GNUNET_NO if the IP is not in the list, #GNUNET_YES if it it is | 437 | * @return #GNUNET_NO if the IP is not in the list, #GNUNET_YES if it it is |
435 | */ | 438 | */ |
436 | static int | 439 | static int |
437 | check_ipv4_listed(const struct GNUNET_STRINGS_IPv4NetworkPolicy *list, | 440 | check_ipv4_listed (const struct GNUNET_STRINGS_IPv4NetworkPolicy *list, |
438 | const struct in_addr *add) | 441 | const struct in_addr *add) |
439 | { | 442 | { |
440 | unsigned int i; | 443 | unsigned int i; |
441 | 444 | ||
@@ -443,12 +446,12 @@ check_ipv4_listed(const struct GNUNET_STRINGS_IPv4NetworkPolicy *list, | |||
443 | return GNUNET_NO; | 446 | return GNUNET_NO; |
444 | i = 0; | 447 | i = 0; |
445 | while ((0 != list[i].network.s_addr) || (0 != list[i].netmask.s_addr)) | 448 | while ((0 != list[i].network.s_addr) || (0 != list[i].netmask.s_addr)) |
446 | { | 449 | { |
447 | if ((add->s_addr & list[i].netmask.s_addr) == | 450 | if ((add->s_addr & list[i].netmask.s_addr) == |
448 | (list[i].network.s_addr & list[i].netmask.s_addr)) | 451 | (list[i].network.s_addr & list[i].netmask.s_addr)) |
449 | return GNUNET_YES; | 452 | return GNUNET_YES; |
450 | i++; | 453 | i++; |
451 | } | 454 | } |
452 | return GNUNET_NO; | 455 | return GNUNET_NO; |
453 | } | 456 | } |
454 | 457 | ||
@@ -461,8 +464,8 @@ check_ipv4_listed(const struct GNUNET_STRINGS_IPv4NetworkPolicy *list, | |||
461 | * @return #GNUNET_NO if the IP is not in the list, #GNUNET_YES if it it is | 464 | * @return #GNUNET_NO if the IP is not in the list, #GNUNET_YES if it it is |
462 | */ | 465 | */ |
463 | static int | 466 | static int |
464 | check_ipv6_listed(const struct GNUNET_STRINGS_IPv6NetworkPolicy *list, | 467 | check_ipv6_listed (const struct GNUNET_STRINGS_IPv6NetworkPolicy *list, |
465 | const struct in6_addr *ip) | 468 | const struct in6_addr *ip) |
466 | { | 469 | { |
467 | unsigned int i; | 470 | unsigned int i; |
468 | unsigned int j; | 471 | unsigned int j; |
@@ -471,17 +474,17 @@ check_ipv6_listed(const struct GNUNET_STRINGS_IPv6NetworkPolicy *list, | |||
471 | return GNUNET_NO; | 474 | return GNUNET_NO; |
472 | i = 0; | 475 | i = 0; |
473 | NEXT: | 476 | NEXT: |
474 | while (0 != GNUNET_is_zero(&list[i].network)) | 477 | while (0 != GNUNET_is_zero (&list[i].network)) |
475 | { | 478 | { |
476 | for (j = 0; j < sizeof(struct in6_addr) / sizeof(int); j++) | 479 | for (j = 0; j < sizeof(struct in6_addr) / sizeof(int); j++) |
477 | if (((((int *)ip)[j] & ((int *)&list[i].netmask)[j])) != | 480 | if (((((int *) ip)[j] & ((int *) &list[i].netmask)[j])) != |
478 | (((int *)&list[i].network)[j] & ((int *)&list[i].netmask)[j])) | 481 | (((int *) &list[i].network)[j] & ((int *) &list[i].netmask)[j])) |
479 | { | 482 | { |
480 | i++; | 483 | i++; |
481 | goto NEXT; | 484 | goto NEXT; |
482 | } | 485 | } |
483 | return GNUNET_YES; | 486 | return GNUNET_YES; |
484 | } | 487 | } |
485 | return GNUNET_NO; | 488 | return GNUNET_NO; |
486 | } | 489 | } |
487 | 490 | ||
@@ -493,63 +496,63 @@ NEXT: | |||
493 | * @param cls the `struct GNUNET_SERVICE_Client *` to send to | 496 | * @param cls the `struct GNUNET_SERVICE_Client *` to send to |
494 | */ | 497 | */ |
495 | static void | 498 | static void |
496 | do_send(void *cls) | 499 | do_send (void *cls) |
497 | { | 500 | { |
498 | struct GNUNET_SERVICE_Client *client = cls; | 501 | struct GNUNET_SERVICE_Client *client = cls; |
499 | ssize_t ret; | 502 | ssize_t ret; |
500 | size_t left; | 503 | size_t left; |
501 | const char *buf; | 504 | const char *buf; |
502 | 505 | ||
503 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 506 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
504 | "service: sending message with type %u\n", | 507 | "service: sending message with type %u\n", |
505 | ntohs(client->msg->type)); | 508 | ntohs (client->msg->type)); |
506 | 509 | ||
507 | 510 | ||
508 | client->send_task = NULL; | 511 | client->send_task = NULL; |
509 | buf = (const char *)client->msg; | 512 | buf = (const char *) client->msg; |
510 | left = ntohs(client->msg->size) - client->msg_pos; | 513 | left = ntohs (client->msg->size) - client->msg_pos; |
511 | ret = GNUNET_NETWORK_socket_send(client->sock, &buf[client->msg_pos], left); | 514 | ret = GNUNET_NETWORK_socket_send (client->sock, &buf[client->msg_pos], left); |
512 | GNUNET_assert(ret <= (ssize_t)left); | 515 | GNUNET_assert (ret <= (ssize_t) left); |
513 | if (0 == ret) | 516 | if (0 == ret) |
514 | { | 517 | { |
515 | LOG(GNUNET_ERROR_TYPE_DEBUG, "no data send"); | 518 | LOG (GNUNET_ERROR_TYPE_DEBUG, "no data send"); |
516 | GNUNET_MQ_inject_error(client->mq, GNUNET_MQ_ERROR_WRITE); | 519 | GNUNET_MQ_inject_error (client->mq, GNUNET_MQ_ERROR_WRITE); |
517 | return; | 520 | return; |
518 | } | 521 | } |
519 | if (-1 == ret) | 522 | if (-1 == ret) |
523 | { | ||
524 | if ((EAGAIN == errno) || (EINTR == errno)) | ||
520 | { | 525 | { |
521 | if ((EAGAIN == errno) || (EINTR == errno)) | 526 | /* ignore */ |
522 | { | 527 | ret = 0; |
523 | /* ignore */ | ||
524 | ret = 0; | ||
525 | } | ||
526 | else | ||
527 | { | ||
528 | if (EPIPE != errno) | ||
529 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "send"); | ||
530 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
531 | "socket send returned with error code %i", | ||
532 | errno); | ||
533 | GNUNET_MQ_inject_error(client->mq, GNUNET_MQ_ERROR_WRITE); | ||
534 | return; | ||
535 | } | ||
536 | } | ||
537 | if (0 == client->msg_pos) | ||
538 | { | ||
539 | GNUNET_MQ_impl_send_in_flight(client->mq); | ||
540 | } | 528 | } |
541 | client->msg_pos += ret; | 529 | else |
542 | if (left > (size_t)ret) | ||
543 | { | 530 | { |
544 | GNUNET_assert(NULL == client->drop_task); | 531 | if (EPIPE != errno) |
545 | client->send_task = | 532 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send"); |
546 | GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, | 533 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
547 | client->sock, | 534 | "socket send returned with error code %i", |
548 | &do_send, | 535 | errno); |
549 | client); | 536 | GNUNET_MQ_inject_error (client->mq, GNUNET_MQ_ERROR_WRITE); |
550 | return; | 537 | return; |
551 | } | 538 | } |
552 | GNUNET_MQ_impl_send_continue(client->mq); | 539 | } |
540 | if (0 == client->msg_pos) | ||
541 | { | ||
542 | GNUNET_MQ_impl_send_in_flight (client->mq); | ||
543 | } | ||
544 | client->msg_pos += ret; | ||
545 | if (left > (size_t) ret) | ||
546 | { | ||
547 | GNUNET_assert (NULL == client->drop_task); | ||
548 | client->send_task = | ||
549 | GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, | ||
550 | client->sock, | ||
551 | &do_send, | ||
552 | client); | ||
553 | return; | ||
554 | } | ||
555 | GNUNET_MQ_impl_send_continue (client->mq); | ||
553 | } | 556 | } |
554 | 557 | ||
555 | 558 | ||
@@ -562,27 +565,27 @@ do_send(void *cls) | |||
562 | * @param impl_state our `struct GNUNET_SERVICE_Client *` | 565 | * @param impl_state our `struct GNUNET_SERVICE_Client *` |
563 | */ | 566 | */ |
564 | static void | 567 | static void |
565 | service_mq_send(struct GNUNET_MQ_Handle *mq, | 568 | service_mq_send (struct GNUNET_MQ_Handle *mq, |
566 | const struct GNUNET_MessageHeader *msg, | 569 | const struct GNUNET_MessageHeader *msg, |
567 | void *impl_state) | 570 | void *impl_state) |
568 | { | 571 | { |
569 | struct GNUNET_SERVICE_Client *client = impl_state; | 572 | struct GNUNET_SERVICE_Client *client = impl_state; |
570 | 573 | ||
571 | (void)mq; | 574 | (void) mq; |
572 | if (NULL != client->drop_task) | 575 | if (NULL != client->drop_task) |
573 | return; /* we're going down right now, do not try to send */ | 576 | return; /* we're going down right now, do not try to send */ |
574 | GNUNET_assert(NULL == client->send_task); | 577 | GNUNET_assert (NULL == client->send_task); |
575 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 578 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
576 | "Sending message of type %u and size %u to client\n", | 579 | "Sending message of type %u and size %u to client\n", |
577 | ntohs(msg->type), | 580 | ntohs (msg->type), |
578 | ntohs(msg->size)); | 581 | ntohs (msg->size)); |
579 | client->msg = msg; | 582 | client->msg = msg; |
580 | client->msg_pos = 0; | 583 | client->msg_pos = 0; |
581 | client->send_task = | 584 | client->send_task = |
582 | GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, | 585 | GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, |
583 | client->sock, | 586 | client->sock, |
584 | &do_send, | 587 | &do_send, |
585 | client); | 588 | client); |
586 | } | 589 | } |
587 | 590 | ||
588 | 591 | ||
@@ -593,14 +596,14 @@ service_mq_send(struct GNUNET_MQ_Handle *mq, | |||
593 | * @param impl_state state specific to the implementation | 596 | * @param impl_state state specific to the implementation |
594 | */ | 597 | */ |
595 | static void | 598 | static void |
596 | service_mq_cancel(struct GNUNET_MQ_Handle *mq, void *impl_state) | 599 | service_mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state) |
597 | { | 600 | { |
598 | struct GNUNET_SERVICE_Client *client = impl_state; | 601 | struct GNUNET_SERVICE_Client *client = impl_state; |
599 | 602 | ||
600 | (void)mq; | 603 | (void) mq; |
601 | GNUNET_assert(0 == client->msg_pos); | 604 | GNUNET_assert (0 == client->msg_pos); |
602 | client->msg = NULL; | 605 | client->msg = NULL; |
603 | GNUNET_SCHEDULER_cancel(client->send_task); | 606 | GNUNET_SCHEDULER_cancel (client->send_task); |
604 | client->send_task = NULL; | 607 | client->send_task = NULL; |
605 | } | 608 | } |
606 | 609 | ||
@@ -615,20 +618,20 @@ service_mq_cancel(struct GNUNET_MQ_Handle *mq, void *impl_state) | |||
615 | * @param error error code | 618 | * @param error error code |
616 | */ | 619 | */ |
617 | static void | 620 | static void |
618 | service_mq_error_handler(void *cls, enum GNUNET_MQ_Error error) | 621 | service_mq_error_handler (void *cls, enum GNUNET_MQ_Error error) |
619 | { | 622 | { |
620 | struct GNUNET_SERVICE_Client *client = cls; | 623 | struct GNUNET_SERVICE_Client *client = cls; |
621 | struct GNUNET_SERVICE_Handle *sh = client->sh; | 624 | struct GNUNET_SERVICE_Handle *sh = client->sh; |
622 | 625 | ||
623 | if ((GNUNET_MQ_ERROR_NO_MATCH == error) && (GNUNET_NO == sh->require_found)) | 626 | if ((GNUNET_MQ_ERROR_NO_MATCH == error) && (GNUNET_NO == sh->require_found)) |
624 | { | 627 | { |
625 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 628 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
626 | "No handler for message of type %u found\n", | 629 | "No handler for message of type %u found\n", |
627 | (unsigned int)client->warn_type); | 630 | (unsigned int) client->warn_type); |
628 | GNUNET_SERVICE_client_continue(client); | 631 | GNUNET_SERVICE_client_continue (client); |
629 | return; /* ignore error */ | 632 | return; /* ignore error */ |
630 | } | 633 | } |
631 | GNUNET_SERVICE_client_drop(client); | 634 | GNUNET_SERVICE_client_drop (client); |
632 | } | 635 | } |
633 | 636 | ||
634 | 637 | ||
@@ -638,24 +641,24 @@ service_mq_error_handler(void *cls, enum GNUNET_MQ_Error error) | |||
638 | * @param cls our `struct GNUNET_SERVICE_Client *` to process more requests from | 641 | * @param cls our `struct GNUNET_SERVICE_Client *` to process more requests from |
639 | */ | 642 | */ |
640 | static void | 643 | static void |
641 | warn_no_client_continue(void *cls) | 644 | warn_no_client_continue (void *cls) |
642 | { | 645 | { |
643 | struct GNUNET_SERVICE_Client *client = cls; | 646 | struct GNUNET_SERVICE_Client *client = cls; |
644 | 647 | ||
645 | GNUNET_break( | 648 | GNUNET_break ( |
646 | 0 != | 649 | 0 != |
647 | client->warn_type); /* type should never be 0 here, as we don't use 0 */ | 650 | client->warn_type); /* type should never be 0 here, as we don't use 0 */ |
648 | client->warn_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES, | 651 | client->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, |
649 | &warn_no_client_continue, | 652 | &warn_no_client_continue, |
650 | client); | 653 | client); |
651 | LOG( | 654 | LOG ( |
652 | GNUNET_ERROR_TYPE_WARNING, | 655 | GNUNET_ERROR_TYPE_WARNING, |
653 | _( | 656 | _ ( |
654 | "Processing code for message of type %u did not call `GNUNET_SERVICE_client_continue' after %s\n"), | 657 | "Processing code for message of type %u did not call `GNUNET_SERVICE_client_continue' after %s\n"), |
655 | (unsigned int)client->warn_type, | 658 | (unsigned int) client->warn_type, |
656 | GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration( | 659 | GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration ( |
657 | client->warn_start), | 660 | client->warn_start), |
658 | GNUNET_YES)); | 661 | GNUNET_YES)); |
659 | } | 662 | } |
660 | 663 | ||
661 | 664 | ||
@@ -671,23 +674,23 @@ warn_no_client_continue(void *cls) | |||
671 | * @return #GNUNET_OK on success, #GNUNET_SYSERR if the client was dropped | 674 | * @return #GNUNET_OK on success, #GNUNET_SYSERR if the client was dropped |
672 | */ | 675 | */ |
673 | static int | 676 | static int |
674 | service_client_mst_cb(void *cls, const struct GNUNET_MessageHeader *message) | 677 | service_client_mst_cb (void *cls, const struct GNUNET_MessageHeader *message) |
675 | { | 678 | { |
676 | struct GNUNET_SERVICE_Client *client = cls; | 679 | struct GNUNET_SERVICE_Client *client = cls; |
677 | 680 | ||
678 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 681 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
679 | "Received message of type %u and size %u from client\n", | 682 | "Received message of type %u and size %u from client\n", |
680 | ntohs(message->type), | 683 | ntohs (message->type), |
681 | ntohs(message->size)); | 684 | ntohs (message->size)); |
682 | GNUNET_assert(GNUNET_NO == client->needs_continue); | 685 | GNUNET_assert (GNUNET_NO == client->needs_continue); |
683 | client->needs_continue = GNUNET_YES; | 686 | client->needs_continue = GNUNET_YES; |
684 | client->warn_type = ntohs(message->type); | 687 | client->warn_type = ntohs (message->type); |
685 | client->warn_start = GNUNET_TIME_absolute_get(); | 688 | client->warn_start = GNUNET_TIME_absolute_get (); |
686 | GNUNET_assert(NULL == client->warn_task); | 689 | GNUNET_assert (NULL == client->warn_task); |
687 | client->warn_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES, | 690 | client->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, |
688 | &warn_no_client_continue, | 691 | &warn_no_client_continue, |
689 | client); | 692 | client); |
690 | GNUNET_MQ_inject_message(client->mq, message); | 693 | GNUNET_MQ_inject_message (client->mq, message); |
691 | if (NULL != client->drop_task) | 694 | if (NULL != client->drop_task) |
692 | return GNUNET_SYSERR; | 695 | return GNUNET_SYSERR; |
693 | return GNUNET_OK; | 696 | return GNUNET_OK; |
@@ -701,37 +704,37 @@ service_client_mst_cb(void *cls, const struct GNUNET_MessageHeader *message) | |||
701 | * @param cls the `struct GNUNET_SERVICE_Client` that sent us data. | 704 | * @param cls the `struct GNUNET_SERVICE_Client` that sent us data. |
702 | */ | 705 | */ |
703 | static void | 706 | static void |
704 | service_client_recv(void *cls) | 707 | service_client_recv (void *cls) |
705 | { | 708 | { |
706 | struct GNUNET_SERVICE_Client *client = cls; | 709 | struct GNUNET_SERVICE_Client *client = cls; |
707 | int ret; | 710 | int ret; |
708 | 711 | ||
709 | client->recv_task = NULL; | 712 | client->recv_task = NULL; |
710 | ret = GNUNET_MST_read(client->mst, client->sock, GNUNET_NO, GNUNET_YES); | 713 | ret = GNUNET_MST_read (client->mst, client->sock, GNUNET_NO, GNUNET_YES); |
711 | if (GNUNET_SYSERR == ret) | 714 | if (GNUNET_SYSERR == ret) |
715 | { | ||
716 | /* client closed connection (or IO error) */ | ||
717 | if (NULL == client->drop_task) | ||
712 | { | 718 | { |
713 | /* client closed connection (or IO error) */ | 719 | GNUNET_assert (GNUNET_NO == client->needs_continue); |
714 | if (NULL == client->drop_task) | 720 | GNUNET_SERVICE_client_drop (client); |
715 | { | ||
716 | GNUNET_assert(GNUNET_NO == client->needs_continue); | ||
717 | GNUNET_SERVICE_client_drop(client); | ||
718 | } | ||
719 | return; | ||
720 | } | 721 | } |
722 | return; | ||
723 | } | ||
721 | if (GNUNET_NO == ret) | 724 | if (GNUNET_NO == ret) |
722 | return; /* more messages in buffer, wait for application | 725 | return; /* more messages in buffer, wait for application |
723 | to be done processing */ | 726 | to be done processing */ |
724 | GNUNET_assert(GNUNET_OK == ret); | 727 | GNUNET_assert (GNUNET_OK == ret); |
725 | if (GNUNET_YES == client->needs_continue) | 728 | if (GNUNET_YES == client->needs_continue) |
726 | return; | 729 | return; |
727 | if (NULL != client->recv_task) | 730 | if (NULL != client->recv_task) |
728 | return; | 731 | return; |
729 | /* MST needs more data, re-schedule read job */ | 732 | /* MST needs more data, re-schedule read job */ |
730 | client->recv_task = | 733 | client->recv_task = |
731 | GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | 734 | GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
732 | client->sock, | 735 | client->sock, |
733 | &service_client_recv, | 736 | &service_client_recv, |
734 | client); | 737 | client); |
735 | } | 738 | } |
736 | 739 | ||
737 | 740 | ||
@@ -743,31 +746,31 @@ service_client_recv(void *cls) | |||
743 | * @param sock socket associated with the client | 746 | * @param sock socket associated with the client |
744 | */ | 747 | */ |
745 | static void | 748 | static void |
746 | start_client(struct GNUNET_SERVICE_Handle *sh, | 749 | start_client (struct GNUNET_SERVICE_Handle *sh, |
747 | struct GNUNET_NETWORK_Handle *csock) | 750 | struct GNUNET_NETWORK_Handle *csock) |
748 | { | 751 | { |
749 | struct GNUNET_SERVICE_Client *client; | 752 | struct GNUNET_SERVICE_Client *client; |
750 | 753 | ||
751 | client = GNUNET_new(struct GNUNET_SERVICE_Client); | 754 | client = GNUNET_new (struct GNUNET_SERVICE_Client); |
752 | GNUNET_CONTAINER_DLL_insert(sh->clients_head, sh->clients_tail, client); | 755 | GNUNET_CONTAINER_DLL_insert (sh->clients_head, sh->clients_tail, client); |
753 | client->sh = sh; | 756 | client->sh = sh; |
754 | client->sock = csock; | 757 | client->sock = csock; |
755 | client->mq = GNUNET_MQ_queue_for_callbacks(&service_mq_send, | 758 | client->mq = GNUNET_MQ_queue_for_callbacks (&service_mq_send, |
756 | NULL, | 759 | NULL, |
757 | &service_mq_cancel, | 760 | &service_mq_cancel, |
758 | client, | 761 | client, |
759 | sh->handlers, | 762 | sh->handlers, |
760 | &service_mq_error_handler, | 763 | &service_mq_error_handler, |
761 | client); | 764 | client); |
762 | client->mst = GNUNET_MST_create(&service_client_mst_cb, client); | 765 | client->mst = GNUNET_MST_create (&service_client_mst_cb, client); |
763 | if (NULL != sh->connect_cb) | 766 | if (NULL != sh->connect_cb) |
764 | client->user_context = sh->connect_cb(sh->cb_cls, client, client->mq); | 767 | client->user_context = sh->connect_cb (sh->cb_cls, client, client->mq); |
765 | GNUNET_MQ_set_handlers_closure(client->mq, client->user_context); | 768 | GNUNET_MQ_set_handlers_closure (client->mq, client->user_context); |
766 | client->recv_task = | 769 | client->recv_task = |
767 | GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | 770 | GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
768 | client->sock, | 771 | client->sock, |
769 | &service_client_recv, | 772 | &service_client_recv, |
770 | client); | 773 | client); |
771 | } | 774 | } |
772 | 775 | ||
773 | 776 | ||
@@ -778,83 +781,83 @@ start_client(struct GNUNET_SERVICE_Handle *sh, | |||
778 | * @param cls the `struct ServiceListenContext` of the ready listen socket | 781 | * @param cls the `struct ServiceListenContext` of the ready listen socket |
779 | */ | 782 | */ |
780 | static void | 783 | static void |
781 | accept_client(void *cls) | 784 | accept_client (void *cls) |
782 | { | 785 | { |
783 | struct ServiceListenContext *slc = cls; | 786 | struct ServiceListenContext *slc = cls; |
784 | struct GNUNET_SERVICE_Handle *sh = slc->sh; | 787 | struct GNUNET_SERVICE_Handle *sh = slc->sh; |
785 | 788 | ||
786 | slc->listen_task = NULL; | 789 | slc->listen_task = NULL; |
787 | while (1) | 790 | while (1) |
791 | { | ||
792 | struct GNUNET_NETWORK_Handle *sock; | ||
793 | const struct sockaddr_in *v4; | ||
794 | const struct sockaddr_in6 *v6; | ||
795 | struct sockaddr_storage sa; | ||
796 | socklen_t addrlen; | ||
797 | int ok; | ||
798 | |||
799 | addrlen = sizeof(sa); | ||
800 | sock = GNUNET_NETWORK_socket_accept (slc->listen_socket, | ||
801 | (struct sockaddr *) &sa, | ||
802 | &addrlen); | ||
803 | if (NULL == sock) | ||
804 | { | ||
805 | if (EMFILE == errno) | ||
806 | do_suspend (sh, SUSPEND_STATE_EMFILE); | ||
807 | else if (EAGAIN != errno) | ||
808 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "accept"); | ||
809 | break; | ||
810 | } | ||
811 | switch (sa.ss_family) | ||
788 | { | 812 | { |
789 | struct GNUNET_NETWORK_Handle *sock; | 813 | case AF_INET: |
790 | const struct sockaddr_in *v4; | 814 | GNUNET_assert (addrlen == sizeof(struct sockaddr_in)); |
791 | const struct sockaddr_in6 *v6; | 815 | v4 = (const struct sockaddr_in *) &sa; |
792 | struct sockaddr_storage sa; | 816 | ok = (((NULL == sh->v4_allowed) || |
793 | socklen_t addrlen; | 817 | (check_ipv4_listed (sh->v4_allowed, &v4->sin_addr))) && |
794 | int ok; | 818 | ((NULL == sh->v4_denied) || |
795 | 819 | (! check_ipv4_listed (sh->v4_denied, &v4->sin_addr)))); | |
796 | addrlen = sizeof(sa); | 820 | break; |
797 | sock = GNUNET_NETWORK_socket_accept(slc->listen_socket, | 821 | |
798 | (struct sockaddr *)&sa, | 822 | case AF_INET6: |
799 | &addrlen); | 823 | GNUNET_assert (addrlen == sizeof(struct sockaddr_in6)); |
800 | if (NULL == sock) | 824 | v6 = (const struct sockaddr_in6 *) &sa; |
801 | { | 825 | ok = (((NULL == sh->v6_allowed) || |
802 | if (EMFILE == errno) | 826 | (check_ipv6_listed (sh->v6_allowed, &v6->sin6_addr))) && |
803 | do_suspend(sh, SUSPEND_STATE_EMFILE); | 827 | ((NULL == sh->v6_denied) || |
804 | else if (EAGAIN != errno) | 828 | (! check_ipv6_listed (sh->v6_denied, &v6->sin6_addr)))); |
805 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "accept"); | 829 | break; |
806 | break; | 830 | |
807 | } | 831 | case AF_UNIX: |
808 | switch (sa.ss_family) | 832 | ok = GNUNET_OK; /* controlled using file-system ACL now */ |
809 | { | 833 | break; |
810 | case AF_INET: | 834 | |
811 | GNUNET_assert(addrlen == sizeof(struct sockaddr_in)); | 835 | default: |
812 | v4 = (const struct sockaddr_in *)&sa; | 836 | LOG (GNUNET_ERROR_TYPE_WARNING, |
813 | ok = (((NULL == sh->v4_allowed) || | 837 | _ ("Unknown address family %d\n"), |
814 | (check_ipv4_listed(sh->v4_allowed, &v4->sin_addr))) && | 838 | sa.ss_family); |
815 | ((NULL == sh->v4_denied) || | 839 | return; |
816 | (!check_ipv4_listed(sh->v4_denied, &v4->sin_addr)))); | 840 | } |
817 | break; | 841 | if (! ok) |
818 | 842 | { | |
819 | case AF_INET6: | 843 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
820 | GNUNET_assert(addrlen == sizeof(struct sockaddr_in6)); | 844 | "Service rejected incoming connection from %s due to policy.\n", |
821 | v6 = (const struct sockaddr_in6 *)&sa; | 845 | GNUNET_a2s ((const struct sockaddr *) &sa, addrlen)); |
822 | ok = (((NULL == sh->v6_allowed) || | 846 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock)); |
823 | (check_ipv6_listed(sh->v6_allowed, &v6->sin6_addr))) && | 847 | continue; |
824 | ((NULL == sh->v6_denied) || | ||
825 | (!check_ipv6_listed(sh->v6_denied, &v6->sin6_addr)))); | ||
826 | break; | ||
827 | |||
828 | case AF_UNIX: | ||
829 | ok = GNUNET_OK; /* controlled using file-system ACL now */ | ||
830 | break; | ||
831 | |||
832 | default: | ||
833 | LOG(GNUNET_ERROR_TYPE_WARNING, | ||
834 | _("Unknown address family %d\n"), | ||
835 | sa.ss_family); | ||
836 | return; | ||
837 | } | ||
838 | if (!ok) | ||
839 | { | ||
840 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
841 | "Service rejected incoming connection from %s due to policy.\n", | ||
842 | GNUNET_a2s((const struct sockaddr *)&sa, addrlen)); | ||
843 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(sock)); | ||
844 | continue; | ||
845 | } | ||
846 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
847 | "Service accepted incoming connection from %s.\n", | ||
848 | GNUNET_a2s((const struct sockaddr *)&sa, addrlen)); | ||
849 | start_client(slc->sh, sock); | ||
850 | } | 848 | } |
849 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
850 | "Service accepted incoming connection from %s.\n", | ||
851 | GNUNET_a2s ((const struct sockaddr *) &sa, addrlen)); | ||
852 | start_client (slc->sh, sock); | ||
853 | } | ||
851 | if (0 != sh->suspend_state) | 854 | if (0 != sh->suspend_state) |
852 | return; | 855 | return; |
853 | slc->listen_task = | 856 | slc->listen_task = |
854 | GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | 857 | GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
855 | slc->listen_socket, | 858 | slc->listen_socket, |
856 | &accept_client, | 859 | &accept_client, |
857 | slc); | 860 | slc); |
858 | } | 861 | } |
859 | 862 | ||
860 | 863 | ||
@@ -866,23 +869,23 @@ accept_client(void *cls) | |||
866 | * or #SUSPEND_STATE_NONE on first startup | 869 | * or #SUSPEND_STATE_NONE on first startup |
867 | */ | 870 | */ |
868 | static void | 871 | static void |
869 | do_resume(struct GNUNET_SERVICE_Handle *sh, enum SuspendReason sr) | 872 | do_resume (struct GNUNET_SERVICE_Handle *sh, enum SuspendReason sr) |
870 | { | 873 | { |
871 | struct ServiceListenContext *slc; | 874 | struct ServiceListenContext *slc; |
872 | 875 | ||
873 | GNUNET_assert((SUSPEND_STATE_NONE == sr) || (0 != (sh->suspend_state & sr))); | 876 | GNUNET_assert ((SUSPEND_STATE_NONE == sr) || (0 != (sh->suspend_state & sr))); |
874 | sh->suspend_state -= sr; | 877 | sh->suspend_state -= sr; |
875 | if (SUSPEND_STATE_NONE != sh->suspend_state) | 878 | if (SUSPEND_STATE_NONE != sh->suspend_state) |
876 | return; | 879 | return; |
877 | for (slc = sh->slc_head; NULL != slc; slc = slc->next) | 880 | for (slc = sh->slc_head; NULL != slc; slc = slc->next) |
878 | { | 881 | { |
879 | GNUNET_assert(NULL == slc->listen_task); | 882 | GNUNET_assert (NULL == slc->listen_task); |
880 | slc->listen_task = | 883 | slc->listen_task = |
881 | GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | 884 | GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
882 | slc->listen_socket, | 885 | slc->listen_socket, |
883 | &accept_client, | 886 | &accept_client, |
884 | slc); | 887 | slc); |
885 | } | 888 | } |
886 | } | 889 | } |
887 | 890 | ||
888 | 891 | ||
@@ -894,23 +897,24 @@ do_resume(struct GNUNET_SERVICE_Handle *sh, enum SuspendReason sr) | |||
894 | * @param cls our `struct GNUNET_SERVICE_Handle` | 897 | * @param cls our `struct GNUNET_SERVICE_Handle` |
895 | */ | 898 | */ |
896 | static void | 899 | static void |
897 | service_main(void *cls) | 900 | service_main (void *cls) |
898 | { | 901 | { |
899 | struct GNUNET_SERVICE_Handle *sh = cls; | 902 | struct GNUNET_SERVICE_Handle *sh = cls; |
900 | 903 | ||
901 | if (GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN != sh->options) | 904 | if (GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN != |
902 | GNUNET_SCHEDULER_add_shutdown(&service_shutdown, sh); | 905 | (sh->options & GNUNET_SERVICE_OPTION_SHUTDOWN_BITMASK)) |
903 | do_resume(sh, SUSPEND_STATE_NONE); | 906 | GNUNET_SCHEDULER_add_shutdown (&service_shutdown, sh); |
907 | do_resume (sh, SUSPEND_STATE_NONE); | ||
904 | 908 | ||
905 | if (-1 != sh->ready_confirm_fd) | 909 | if (-1 != sh->ready_confirm_fd) |
906 | { | 910 | { |
907 | GNUNET_break(1 == write(sh->ready_confirm_fd, ".", 1)); | 911 | GNUNET_break (1 == write (sh->ready_confirm_fd, ".", 1)); |
908 | GNUNET_break(0 == close(sh->ready_confirm_fd)); | 912 | GNUNET_break (0 == close (sh->ready_confirm_fd)); |
909 | sh->ready_confirm_fd = -1; | 913 | sh->ready_confirm_fd = -1; |
910 | } | 914 | } |
911 | 915 | ||
912 | if (NULL != sh->service_init_cb) | 916 | if (NULL != sh->service_init_cb) |
913 | sh->service_init_cb(sh->cb_cls, sh->cfg, sh); | 917 | sh->service_init_cb (sh->cb_cls, sh->cfg, sh); |
914 | } | 918 | } |
915 | 919 | ||
916 | 920 | ||
@@ -924,33 +928,33 @@ service_main(void *cls) | |||
924 | * no ACL configured) | 928 | * no ACL configured) |
925 | */ | 929 | */ |
926 | static int | 930 | static int |
927 | process_acl4(struct GNUNET_STRINGS_IPv4NetworkPolicy **ret, | 931 | process_acl4 (struct GNUNET_STRINGS_IPv4NetworkPolicy **ret, |
928 | struct GNUNET_SERVICE_Handle *sh, | 932 | struct GNUNET_SERVICE_Handle *sh, |
929 | const char *option) | 933 | const char *option) |
930 | { | 934 | { |
931 | char *opt; | 935 | char *opt; |
932 | 936 | ||
933 | if (!GNUNET_CONFIGURATION_have_value(sh->cfg, sh->service_name, option)) | 937 | if (! GNUNET_CONFIGURATION_have_value (sh->cfg, sh->service_name, option)) |
934 | { | 938 | { |
935 | *ret = NULL; | 939 | *ret = NULL; |
936 | return GNUNET_OK; | 940 | return GNUNET_OK; |
937 | } | 941 | } |
938 | GNUNET_break(GNUNET_OK == | 942 | GNUNET_break (GNUNET_OK == |
939 | GNUNET_CONFIGURATION_get_value_string(sh->cfg, | 943 | GNUNET_CONFIGURATION_get_value_string (sh->cfg, |
940 | sh->service_name, | 944 | sh->service_name, |
941 | option, | 945 | option, |
942 | &opt)); | 946 | &opt)); |
943 | if (NULL == (*ret = GNUNET_STRINGS_parse_ipv4_policy(opt))) | 947 | if (NULL == (*ret = GNUNET_STRINGS_parse_ipv4_policy (opt))) |
944 | { | 948 | { |
945 | LOG(GNUNET_ERROR_TYPE_WARNING, | 949 | LOG (GNUNET_ERROR_TYPE_WARNING, |
946 | _("Could not parse IPv4 network specification `%s' for `%s:%s'\n"), | 950 | _ ("Could not parse IPv4 network specification `%s' for `%s:%s'\n"), |
947 | opt, | 951 | opt, |
948 | sh->service_name, | 952 | sh->service_name, |
949 | option); | 953 | option); |
950 | GNUNET_free(opt); | 954 | GNUNET_free (opt); |
951 | return GNUNET_SYSERR; | 955 | return GNUNET_SYSERR; |
952 | } | 956 | } |
953 | GNUNET_free(opt); | 957 | GNUNET_free (opt); |
954 | return GNUNET_OK; | 958 | return GNUNET_OK; |
955 | } | 959 | } |
956 | 960 | ||
@@ -965,33 +969,33 @@ process_acl4(struct GNUNET_STRINGS_IPv4NetworkPolicy **ret, | |||
965 | * no ACL configured) | 969 | * no ACL configured) |
966 | */ | 970 | */ |
967 | static int | 971 | static int |
968 | process_acl6(struct GNUNET_STRINGS_IPv6NetworkPolicy **ret, | 972 | process_acl6 (struct GNUNET_STRINGS_IPv6NetworkPolicy **ret, |
969 | struct GNUNET_SERVICE_Handle *sh, | 973 | struct GNUNET_SERVICE_Handle *sh, |
970 | const char *option) | 974 | const char *option) |
971 | { | 975 | { |
972 | char *opt; | 976 | char *opt; |
973 | 977 | ||
974 | if (!GNUNET_CONFIGURATION_have_value(sh->cfg, sh->service_name, option)) | 978 | if (! GNUNET_CONFIGURATION_have_value (sh->cfg, sh->service_name, option)) |
975 | { | 979 | { |
976 | *ret = NULL; | 980 | *ret = NULL; |
977 | return GNUNET_OK; | 981 | return GNUNET_OK; |
978 | } | 982 | } |
979 | GNUNET_break(GNUNET_OK == | 983 | GNUNET_break (GNUNET_OK == |
980 | GNUNET_CONFIGURATION_get_value_string(sh->cfg, | 984 | GNUNET_CONFIGURATION_get_value_string (sh->cfg, |
981 | sh->service_name, | 985 | sh->service_name, |
982 | option, | 986 | option, |
983 | &opt)); | 987 | &opt)); |
984 | if (NULL == (*ret = GNUNET_STRINGS_parse_ipv6_policy(opt))) | 988 | if (NULL == (*ret = GNUNET_STRINGS_parse_ipv6_policy (opt))) |
985 | { | 989 | { |
986 | LOG(GNUNET_ERROR_TYPE_WARNING, | 990 | LOG (GNUNET_ERROR_TYPE_WARNING, |
987 | _("Could not parse IPv6 network specification `%s' for `%s:%s'\n"), | 991 | _ ("Could not parse IPv6 network specification `%s' for `%s:%s'\n"), |
988 | opt, | 992 | opt, |
989 | sh->service_name, | 993 | sh->service_name, |
990 | option); | 994 | option); |
991 | GNUNET_free(opt); | 995 | GNUNET_free (opt); |
992 | return GNUNET_SYSERR; | 996 | return GNUNET_SYSERR; |
993 | } | 997 | } |
994 | GNUNET_free(opt); | 998 | GNUNET_free (opt); |
995 | return GNUNET_OK; | 999 | return GNUNET_OK; |
996 | } | 1000 | } |
997 | 1001 | ||
@@ -1003,34 +1007,27 @@ process_acl6(struct GNUNET_STRINGS_IPv6NetworkPolicy **ret, | |||
1003 | * @param saddrs array to update | 1007 | * @param saddrs array to update |
1004 | * @param saddrlens where to store the address length | 1008 | * @param saddrlens where to store the address length |
1005 | * @param unixpath path to add | 1009 | * @param unixpath path to add |
1006 | * @param abstract #GNUNET_YES to add an abstract UNIX domain socket. This | ||
1007 | * parameter is ignore on systems other than LINUX | ||
1008 | */ | 1010 | */ |
1009 | static void | 1011 | static void |
1010 | add_unixpath(struct sockaddr **saddrs, | 1012 | add_unixpath (struct sockaddr **saddrs, |
1011 | socklen_t *saddrlens, | 1013 | socklen_t *saddrlens, |
1012 | const char *unixpath, | 1014 | const char *unixpath) |
1013 | int abstract) | ||
1014 | { | 1015 | { |
1015 | #ifdef AF_UNIX | 1016 | #ifdef AF_UNIX |
1016 | struct sockaddr_un *un; | 1017 | struct sockaddr_un *un; |
1017 | 1018 | ||
1018 | un = GNUNET_new(struct sockaddr_un); | 1019 | un = GNUNET_new (struct sockaddr_un); |
1019 | un->sun_family = AF_UNIX; | 1020 | un->sun_family = AF_UNIX; |
1020 | GNUNET_strlcpy(un->sun_path, unixpath, sizeof(un->sun_path)); | 1021 | GNUNET_strlcpy (un->sun_path, unixpath, sizeof(un->sun_path)); |
1021 | #ifdef LINUX | ||
1022 | if (GNUNET_YES == abstract) | ||
1023 | un->sun_path[0] = '\0'; | ||
1024 | #endif | ||
1025 | #if HAVE_SOCKADDR_UN_SUN_LEN | 1022 | #if HAVE_SOCKADDR_UN_SUN_LEN |
1026 | un->sun_len = (u_char)sizeof(struct sockaddr_un); | 1023 | un->sun_len = (u_char) sizeof(struct sockaddr_un); |
1027 | #endif | 1024 | #endif |
1028 | *saddrs = (struct sockaddr *)un; | 1025 | *saddrs = (struct sockaddr *) un; |
1029 | *saddrlens = sizeof(struct sockaddr_un); | 1026 | *saddrlens = sizeof(struct sockaddr_un); |
1030 | #else | 1027 | #else |
1031 | /* this function should never be called | 1028 | /* this function should never be called |
1032 | * unless AF_UNIX is defined! */ | 1029 | * unless AF_UNIX is defined! */ |
1033 | GNUNET_assert(0); | 1030 | GNUNET_assert (0); |
1034 | #endif | 1031 | #endif |
1035 | } | 1032 | } |
1036 | 1033 | ||
@@ -1056,10 +1053,10 @@ add_unixpath(struct sockaddr **saddrs, | |||
1056 | * set to NULL). | 1053 | * set to NULL). |
1057 | */ | 1054 | */ |
1058 | static int | 1055 | static int |
1059 | get_server_addresses(const char *service_name, | 1056 | get_server_addresses (const char *service_name, |
1060 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 1057 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
1061 | struct sockaddr ***addrs, | 1058 | struct sockaddr ***addrs, |
1062 | socklen_t **addr_lens) | 1059 | socklen_t **addr_lens) |
1063 | { | 1060 | { |
1064 | int disablev6; | 1061 | int disablev6; |
1065 | struct GNUNET_NETWORK_Handle *desc; | 1062 | struct GNUNET_NETWORK_Handle *desc; |
@@ -1072,7 +1069,6 @@ get_server_addresses(const char *service_name, | |||
1072 | unsigned int i; | 1069 | unsigned int i; |
1073 | int resi; | 1070 | int resi; |
1074 | int ret; | 1071 | int ret; |
1075 | int abstract; | ||
1076 | struct sockaddr **saddrs; | 1072 | struct sockaddr **saddrs; |
1077 | socklen_t *saddrlens; | 1073 | socklen_t *saddrlens; |
1078 | char *hostname; | 1074 | char *hostname; |
@@ -1081,273 +1077,264 @@ get_server_addresses(const char *service_name, | |||
1081 | *addr_lens = NULL; | 1077 | *addr_lens = NULL; |
1082 | desc = NULL; | 1078 | desc = NULL; |
1083 | disablev6 = GNUNET_NO; | 1079 | disablev6 = GNUNET_NO; |
1084 | if ((GNUNET_NO == GNUNET_NETWORK_test_pf(PF_INET6)) || | 1080 | if ((GNUNET_NO == GNUNET_NETWORK_test_pf (PF_INET6)) || |
1085 | (GNUNET_YES == | 1081 | (GNUNET_YES == |
1086 | GNUNET_CONFIGURATION_get_value_yesno(cfg, service_name, "DISABLEV6"))) | 1082 | GNUNET_CONFIGURATION_get_value_yesno (cfg, service_name, "DISABLEV6"))) |
1087 | disablev6 = GNUNET_YES; | 1083 | disablev6 = GNUNET_YES; |
1088 | 1084 | ||
1089 | port = 0; | 1085 | port = 0; |
1090 | if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "PORT")) | 1086 | if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT")) |
1087 | { | ||
1088 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, | ||
1089 | service_name, | ||
1090 | "PORT", | ||
1091 | &port)) | ||
1091 | { | 1092 | { |
1092 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, | 1093 | LOG (GNUNET_ERROR_TYPE_ERROR, |
1093 | service_name, | 1094 | _ ("Require valid port number for service `%s' in configuration!\n"), |
1094 | "PORT", | 1095 | service_name); |
1095 | &port)) | ||
1096 | { | ||
1097 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
1098 | _("Require valid port number for service `%s' in configuration!\n"), | ||
1099 | service_name); | ||
1100 | } | ||
1101 | if (port > 65535) | ||
1102 | { | ||
1103 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
1104 | _("Require valid port number for service `%s' in configuration!\n"), | ||
1105 | service_name); | ||
1106 | return GNUNET_SYSERR; | ||
1107 | } | ||
1108 | } | 1096 | } |
1109 | 1097 | if (port > 65535) | |
1110 | if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "BINDTO")) | ||
1111 | { | 1098 | { |
1112 | GNUNET_break(GNUNET_OK == | 1099 | LOG (GNUNET_ERROR_TYPE_ERROR, |
1113 | GNUNET_CONFIGURATION_get_value_string(cfg, | 1100 | _ ("Require valid port number for service `%s' in configuration!\n"), |
1101 | service_name); | ||
1102 | return GNUNET_SYSERR; | ||
1103 | } | ||
1104 | } | ||
1105 | |||
1106 | if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "BINDTO")) | ||
1107 | { | ||
1108 | GNUNET_break (GNUNET_OK == | ||
1109 | GNUNET_CONFIGURATION_get_value_string (cfg, | ||
1114 | service_name, | 1110 | service_name, |
1115 | "BINDTO", | 1111 | "BINDTO", |
1116 | &hostname)); | 1112 | &hostname)); |
1117 | } | 1113 | } |
1118 | else | 1114 | else |
1119 | hostname = NULL; | 1115 | hostname = NULL; |
1120 | 1116 | ||
1121 | unixpath = NULL; | 1117 | unixpath = NULL; |
1122 | abstract = GNUNET_NO; | ||
1123 | #ifdef AF_UNIX | 1118 | #ifdef AF_UNIX |
1124 | if ((GNUNET_YES == | 1119 | if ((GNUNET_YES == |
1125 | GNUNET_CONFIGURATION_have_value(cfg, service_name, "UNIXPATH")) && | 1120 | GNUNET_CONFIGURATION_have_value (cfg, service_name, "UNIXPATH")) && |
1126 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename(cfg, | 1121 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg, |
1127 | service_name, | 1122 | service_name, |
1128 | "UNIXPATH", | 1123 | "UNIXPATH", |
1129 | &unixpath)) && | 1124 | &unixpath)) && |
1130 | (0 < strlen(unixpath))) | 1125 | (0 < strlen (unixpath))) |
1126 | { | ||
1127 | /* probe UNIX support */ | ||
1128 | struct sockaddr_un s_un; | ||
1129 | |||
1130 | if (strlen (unixpath) >= sizeof(s_un.sun_path)) | ||
1131 | { | 1131 | { |
1132 | /* probe UNIX support */ | 1132 | LOG (GNUNET_ERROR_TYPE_WARNING, |
1133 | struct sockaddr_un s_un; | 1133 | _ ("UNIXPATH `%s' too long, maximum length is %llu\n"), |
1134 | 1134 | unixpath, | |
1135 | if (strlen(unixpath) >= sizeof(s_un.sun_path)) | 1135 | (unsigned long long) sizeof(s_un.sun_path)); |
1136 | { | 1136 | unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath); |
1137 | LOG(GNUNET_ERROR_TYPE_WARNING, | 1137 | LOG (GNUNET_ERROR_TYPE_INFO, _ ("Using `%s' instead\n"), unixpath); |
1138 | _("UNIXPATH `%s' too long, maximum length is %llu\n"), | ||
1139 | unixpath, | ||
1140 | (unsigned long long)sizeof(s_un.sun_path)); | ||
1141 | unixpath = GNUNET_NETWORK_shorten_unixpath(unixpath); | ||
1142 | LOG(GNUNET_ERROR_TYPE_INFO, _("Using `%s' instead\n"), unixpath); | ||
1143 | } | ||
1144 | #ifdef LINUX | ||
1145 | abstract = GNUNET_CONFIGURATION_get_value_yesno(cfg, | ||
1146 | "TESTING", | ||
1147 | "USE_ABSTRACT_SOCKETS"); | ||
1148 | if (GNUNET_SYSERR == abstract) | ||
1149 | abstract = GNUNET_NO; | ||
1150 | #endif | ||
1151 | if ((GNUNET_YES != abstract) && | ||
1152 | (GNUNET_OK != GNUNET_DISK_directory_create_for_file(unixpath))) | ||
1153 | GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "mkdir", unixpath); | ||
1154 | } | 1138 | } |
1139 | if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (unixpath)) | ||
1140 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "mkdir", unixpath); | ||
1141 | } | ||
1155 | if (NULL != unixpath) | 1142 | if (NULL != unixpath) |
1143 | { | ||
1144 | desc = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0); | ||
1145 | if (NULL == desc) | ||
1156 | { | 1146 | { |
1157 | desc = GNUNET_NETWORK_socket_create(AF_UNIX, SOCK_STREAM, 0); | 1147 | if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || |
1158 | if (NULL == desc) | 1148 | (EACCES == errno)) |
1159 | { | 1149 | { |
1160 | if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || | 1150 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket"); |
1161 | (EACCES == errno)) | 1151 | GNUNET_free_non_null (hostname); |
1162 | { | 1152 | GNUNET_free (unixpath); |
1163 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "socket"); | 1153 | return GNUNET_SYSERR; |
1164 | GNUNET_free_non_null(hostname); | 1154 | } |
1165 | GNUNET_free(unixpath); | 1155 | LOG (GNUNET_ERROR_TYPE_INFO, |
1166 | return GNUNET_SYSERR; | 1156 | _ ( |
1167 | } | 1157 | "Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"), |
1168 | LOG(GNUNET_ERROR_TYPE_INFO, | 1158 | service_name, |
1169 | _( | 1159 | strerror (errno)); |
1170 | "Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"), | 1160 | GNUNET_free (unixpath); |
1171 | service_name, | 1161 | unixpath = NULL; |
1172 | strerror(errno)); | ||
1173 | GNUNET_free(unixpath); | ||
1174 | unixpath = NULL; | ||
1175 | } | ||
1176 | else | ||
1177 | { | ||
1178 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(desc)); | ||
1179 | desc = NULL; | ||
1180 | } | ||
1181 | } | 1162 | } |
1163 | else | ||
1164 | { | ||
1165 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc)); | ||
1166 | desc = NULL; | ||
1167 | } | ||
1168 | } | ||
1182 | #endif | 1169 | #endif |
1183 | 1170 | ||
1184 | if ((0 == port) && (NULL == unixpath)) | 1171 | if ((0 == port) && (NULL == unixpath)) |
1172 | { | ||
1173 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
1174 | _ ( | ||
1175 | "Have neither PORT nor UNIXPATH for service `%s', but one is required\n"), | ||
1176 | service_name); | ||
1177 | GNUNET_free_non_null (hostname); | ||
1178 | return GNUNET_SYSERR; | ||
1179 | } | ||
1180 | if (0 == port) | ||
1181 | { | ||
1182 | saddrs = GNUNET_new_array (2, struct sockaddr *); | ||
1183 | saddrlens = GNUNET_new_array (2, socklen_t); | ||
1184 | add_unixpath (saddrs, saddrlens, unixpath); | ||
1185 | GNUNET_free_non_null (unixpath); | ||
1186 | GNUNET_free_non_null (hostname); | ||
1187 | *addrs = saddrs; | ||
1188 | *addr_lens = saddrlens; | ||
1189 | return 1; | ||
1190 | } | ||
1191 | |||
1192 | if (NULL != hostname) | ||
1193 | { | ||
1194 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1195 | "Resolving `%s' since that is where `%s' will bind to.\n", | ||
1196 | hostname, | ||
1197 | service_name); | ||
1198 | memset (&hints, 0, sizeof(struct addrinfo)); | ||
1199 | if (disablev6) | ||
1200 | hints.ai_family = AF_INET; | ||
1201 | hints.ai_protocol = IPPROTO_TCP; | ||
1202 | if ((0 != (ret = getaddrinfo (hostname, NULL, &hints, &res))) || | ||
1203 | (NULL == res)) | ||
1185 | { | 1204 | { |
1186 | LOG(GNUNET_ERROR_TYPE_ERROR, | 1205 | LOG (GNUNET_ERROR_TYPE_ERROR, |
1187 | _( | 1206 | _ ("Failed to resolve `%s': %s\n"), |
1188 | "Have neither PORT nor UNIXPATH for service `%s', but one is required\n"), | 1207 | hostname, |
1189 | service_name); | 1208 | gai_strerror (ret)); |
1190 | GNUNET_free_non_null(hostname); | 1209 | GNUNET_free (hostname); |
1210 | GNUNET_free_non_null (unixpath); | ||
1191 | return GNUNET_SYSERR; | 1211 | return GNUNET_SYSERR; |
1192 | } | 1212 | } |
1193 | if (0 == port) | 1213 | next = res; |
1214 | i = 0; | ||
1215 | while (NULL != (pos = next)) | ||
1194 | { | 1216 | { |
1195 | saddrs = GNUNET_new_array(2, struct sockaddr *); | 1217 | next = pos->ai_next; |
1196 | saddrlens = GNUNET_new_array(2, socklen_t); | 1218 | if ((disablev6) && (pos->ai_family == AF_INET6)) |
1197 | add_unixpath(saddrs, saddrlens, unixpath, abstract); | 1219 | continue; |
1198 | GNUNET_free_non_null(unixpath); | 1220 | i++; |
1199 | GNUNET_free_non_null(hostname); | ||
1200 | *addrs = saddrs; | ||
1201 | *addr_lens = saddrlens; | ||
1202 | return 1; | ||
1203 | } | 1221 | } |
1204 | 1222 | if (0 == i) | |
1205 | if (NULL != hostname) | ||
1206 | { | 1223 | { |
1207 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1224 | LOG (GNUNET_ERROR_TYPE_ERROR, |
1208 | "Resolving `%s' since that is where `%s' will bind to.\n", | 1225 | _ ("Failed to find %saddress for `%s'.\n"), |
1209 | hostname, | 1226 | disablev6 ? "IPv4 " : "", |
1210 | service_name); | 1227 | hostname); |
1211 | memset(&hints, 0, sizeof(struct addrinfo)); | 1228 | freeaddrinfo (res); |
1212 | if (disablev6) | 1229 | GNUNET_free (hostname); |
1213 | hints.ai_family = AF_INET; | 1230 | GNUNET_free_non_null (unixpath); |
1214 | hints.ai_protocol = IPPROTO_TCP; | 1231 | return GNUNET_SYSERR; |
1215 | if ((0 != (ret = getaddrinfo(hostname, NULL, &hints, &res))) || | 1232 | } |
1216 | (NULL == res)) | 1233 | resi = i; |
1217 | { | 1234 | if (NULL != unixpath) |
1218 | LOG(GNUNET_ERROR_TYPE_ERROR, | 1235 | resi++; |
1219 | _("Failed to resolve `%s': %s\n"), | 1236 | saddrs = GNUNET_new_array (resi + 1, struct sockaddr *); |
1220 | hostname, | 1237 | saddrlens = GNUNET_new_array (resi + 1, socklen_t); |
1221 | gai_strerror(ret)); | 1238 | i = 0; |
1222 | GNUNET_free(hostname); | 1239 | if (NULL != unixpath) |
1223 | GNUNET_free_non_null(unixpath); | 1240 | { |
1224 | return GNUNET_SYSERR; | 1241 | add_unixpath (saddrs, saddrlens, unixpath); |
1225 | } | 1242 | i++; |
1226 | next = res; | 1243 | } |
1227 | i = 0; | 1244 | next = res; |
1228 | while (NULL != (pos = next)) | 1245 | while (NULL != (pos = next)) |
1229 | { | 1246 | { |
1230 | next = pos->ai_next; | 1247 | next = pos->ai_next; |
1231 | if ((disablev6) && (pos->ai_family == AF_INET6)) | 1248 | if ((disablev6) && (AF_INET6 == pos->ai_family)) |
1232 | continue; | 1249 | continue; |
1233 | i++; | 1250 | if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol)) |
1234 | } | 1251 | continue; /* not TCP */ |
1235 | if (0 == i) | 1252 | if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype)) |
1236 | { | 1253 | continue; /* huh? */ |
1237 | LOG(GNUNET_ERROR_TYPE_ERROR, | 1254 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1238 | _("Failed to find %saddress for `%s'.\n"), | 1255 | "Service `%s' will bind to `%s'\n", |
1239 | disablev6 ? "IPv4 " : "", | 1256 | service_name, |
1240 | hostname); | 1257 | GNUNET_a2s (pos->ai_addr, pos->ai_addrlen)); |
1241 | freeaddrinfo(res); | 1258 | if (AF_INET == pos->ai_family) |
1242 | GNUNET_free(hostname); | 1259 | { |
1243 | GNUNET_free_non_null(unixpath); | 1260 | GNUNET_assert (sizeof(struct sockaddr_in) == pos->ai_addrlen); |
1244 | return GNUNET_SYSERR; | 1261 | saddrlens[i] = pos->ai_addrlen; |
1245 | } | 1262 | saddrs[i] = GNUNET_malloc (saddrlens[i]); |
1246 | resi = i; | 1263 | GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); |
1264 | ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); | ||
1265 | } | ||
1266 | else | ||
1267 | { | ||
1268 | GNUNET_assert (AF_INET6 == pos->ai_family); | ||
1269 | GNUNET_assert (sizeof(struct sockaddr_in6) == pos->ai_addrlen); | ||
1270 | saddrlens[i] = pos->ai_addrlen; | ||
1271 | saddrs[i] = GNUNET_malloc (saddrlens[i]); | ||
1272 | GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); | ||
1273 | ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port); | ||
1274 | } | ||
1275 | i++; | ||
1276 | } | ||
1277 | GNUNET_free (hostname); | ||
1278 | freeaddrinfo (res); | ||
1279 | resi = i; | ||
1280 | } | ||
1281 | else | ||
1282 | { | ||
1283 | /* will bind against everything, just set port */ | ||
1284 | if (disablev6) | ||
1285 | { | ||
1286 | /* V4-only */ | ||
1287 | resi = 1; | ||
1247 | if (NULL != unixpath) | 1288 | if (NULL != unixpath) |
1248 | resi++; | 1289 | resi++; |
1249 | saddrs = GNUNET_new_array(resi + 1, struct sockaddr *); | ||
1250 | saddrlens = GNUNET_new_array(resi + 1, socklen_t); | ||
1251 | i = 0; | 1290 | i = 0; |
1291 | saddrs = GNUNET_new_array (resi + 1, struct sockaddr *); | ||
1292 | saddrlens = GNUNET_new_array (resi + 1, socklen_t); | ||
1252 | if (NULL != unixpath) | 1293 | if (NULL != unixpath) |
1253 | { | 1294 | { |
1254 | add_unixpath(saddrs, saddrlens, unixpath, abstract); | 1295 | add_unixpath (saddrs, saddrlens, unixpath); |
1255 | i++; | 1296 | i++; |
1256 | } | 1297 | } |
1257 | next = res; | 1298 | saddrlens[i] = sizeof(struct sockaddr_in); |
1258 | while (NULL != (pos = next)) | 1299 | saddrs[i] = GNUNET_malloc (saddrlens[i]); |
1259 | { | ||
1260 | next = pos->ai_next; | ||
1261 | if ((disablev6) && (AF_INET6 == pos->ai_family)) | ||
1262 | continue; | ||
1263 | if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol)) | ||
1264 | continue; /* not TCP */ | ||
1265 | if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype)) | ||
1266 | continue; /* huh? */ | ||
1267 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1268 | "Service `%s' will bind to `%s'\n", | ||
1269 | service_name, | ||
1270 | GNUNET_a2s(pos->ai_addr, pos->ai_addrlen)); | ||
1271 | if (AF_INET == pos->ai_family) | ||
1272 | { | ||
1273 | GNUNET_assert(sizeof(struct sockaddr_in) == pos->ai_addrlen); | ||
1274 | saddrlens[i] = pos->ai_addrlen; | ||
1275 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | ||
1276 | GNUNET_memcpy(saddrs[i], pos->ai_addr, saddrlens[i]); | ||
1277 | ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port); | ||
1278 | } | ||
1279 | else | ||
1280 | { | ||
1281 | GNUNET_assert(AF_INET6 == pos->ai_family); | ||
1282 | GNUNET_assert(sizeof(struct sockaddr_in6) == pos->ai_addrlen); | ||
1283 | saddrlens[i] = pos->ai_addrlen; | ||
1284 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | ||
1285 | GNUNET_memcpy(saddrs[i], pos->ai_addr, saddrlens[i]); | ||
1286 | ((struct sockaddr_in6 *)saddrs[i])->sin6_port = htons(port); | ||
1287 | } | ||
1288 | i++; | ||
1289 | } | ||
1290 | GNUNET_free(hostname); | ||
1291 | freeaddrinfo(res); | ||
1292 | resi = i; | ||
1293 | } | ||
1294 | else | ||
1295 | { | ||
1296 | /* will bind against everything, just set port */ | ||
1297 | if (disablev6) | ||
1298 | { | ||
1299 | /* V4-only */ | ||
1300 | resi = 1; | ||
1301 | if (NULL != unixpath) | ||
1302 | resi++; | ||
1303 | i = 0; | ||
1304 | saddrs = GNUNET_new_array(resi + 1, struct sockaddr *); | ||
1305 | saddrlens = GNUNET_new_array(resi + 1, socklen_t); | ||
1306 | if (NULL != unixpath) | ||
1307 | { | ||
1308 | add_unixpath(saddrs, saddrlens, unixpath, abstract); | ||
1309 | i++; | ||
1310 | } | ||
1311 | saddrlens[i] = sizeof(struct sockaddr_in); | ||
1312 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | ||
1313 | #if HAVE_SOCKADDR_IN_SIN_LEN | 1300 | #if HAVE_SOCKADDR_IN_SIN_LEN |
1314 | ((struct sockaddr_in *)saddrs[i])->sin_len = saddrlens[i]; | 1301 | ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[i]; |
1315 | #endif | 1302 | #endif |
1316 | ((struct sockaddr_in *)saddrs[i])->sin_family = AF_INET; | 1303 | ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET; |
1317 | ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port); | 1304 | ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); |
1318 | } | 1305 | } |
1319 | else | 1306 | else |
1320 | { | 1307 | { |
1321 | /* dual stack */ | 1308 | /* dual stack */ |
1322 | resi = 2; | 1309 | resi = 2; |
1323 | if (NULL != unixpath) | 1310 | if (NULL != unixpath) |
1324 | resi++; | 1311 | resi++; |
1325 | saddrs = GNUNET_new_array(resi + 1, struct sockaddr *); | 1312 | saddrs = GNUNET_new_array (resi + 1, struct sockaddr *); |
1326 | saddrlens = GNUNET_new_array(resi + 1, socklen_t); | 1313 | saddrlens = GNUNET_new_array (resi + 1, socklen_t); |
1327 | i = 0; | 1314 | i = 0; |
1328 | if (NULL != unixpath) | 1315 | if (NULL != unixpath) |
1329 | { | 1316 | { |
1330 | add_unixpath(saddrs, saddrlens, unixpath, abstract); | 1317 | add_unixpath (saddrs, saddrlens, unixpath); |
1331 | i++; | 1318 | i++; |
1332 | } | 1319 | } |
1333 | saddrlens[i] = sizeof(struct sockaddr_in6); | 1320 | saddrlens[i] = sizeof(struct sockaddr_in6); |
1334 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | 1321 | saddrs[i] = GNUNET_malloc (saddrlens[i]); |
1335 | #if HAVE_SOCKADDR_IN_SIN_LEN | 1322 | #if HAVE_SOCKADDR_IN_SIN_LEN |
1336 | ((struct sockaddr_in6 *)saddrs[i])->sin6_len = saddrlens[0]; | 1323 | ((struct sockaddr_in6 *) saddrs[i])->sin6_len = saddrlens[0]; |
1337 | #endif | 1324 | #endif |
1338 | ((struct sockaddr_in6 *)saddrs[i])->sin6_family = AF_INET6; | 1325 | ((struct sockaddr_in6 *) saddrs[i])->sin6_family = AF_INET6; |
1339 | ((struct sockaddr_in6 *)saddrs[i])->sin6_port = htons(port); | 1326 | ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port); |
1340 | i++; | 1327 | i++; |
1341 | saddrlens[i] = sizeof(struct sockaddr_in); | 1328 | saddrlens[i] = sizeof(struct sockaddr_in); |
1342 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | 1329 | saddrs[i] = GNUNET_malloc (saddrlens[i]); |
1343 | #if HAVE_SOCKADDR_IN_SIN_LEN | 1330 | #if HAVE_SOCKADDR_IN_SIN_LEN |
1344 | ((struct sockaddr_in *)saddrs[i])->sin_len = saddrlens[1]; | 1331 | ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[1]; |
1345 | #endif | 1332 | #endif |
1346 | ((struct sockaddr_in *)saddrs[i])->sin_family = AF_INET; | 1333 | ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET; |
1347 | ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port); | 1334 | ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); |
1348 | } | ||
1349 | } | 1335 | } |
1350 | GNUNET_free_non_null(unixpath); | 1336 | } |
1337 | GNUNET_free_non_null (unixpath); | ||
1351 | *addrs = saddrs; | 1338 | *addrs = saddrs; |
1352 | *addr_lens = saddrlens; | 1339 | *addr_lens = saddrlens; |
1353 | return resi; | 1340 | return resi; |
@@ -1362,89 +1349,93 @@ get_server_addresses(const char *service_name, | |||
1362 | * @return NULL on error, otherwise the listen socket | 1349 | * @return NULL on error, otherwise the listen socket |
1363 | */ | 1350 | */ |
1364 | static struct GNUNET_NETWORK_Handle * | 1351 | static struct GNUNET_NETWORK_Handle * |
1365 | open_listen_socket(const struct sockaddr *server_addr, socklen_t socklen) | 1352 | open_listen_socket (const struct sockaddr *server_addr, |
1353 | socklen_t socklen) | ||
1366 | { | 1354 | { |
1367 | struct GNUNET_NETWORK_Handle *sock; | 1355 | struct GNUNET_NETWORK_Handle *sock; |
1368 | uint16_t port; | 1356 | uint16_t port; |
1369 | int eno; | 1357 | int eno; |
1370 | 1358 | ||
1371 | switch (server_addr->sa_family) | 1359 | switch (server_addr->sa_family) |
1372 | { | 1360 | { |
1373 | case AF_INET: | 1361 | case AF_INET: |
1374 | port = ntohs(((const struct sockaddr_in *)server_addr)->sin_port); | 1362 | port = ntohs (((const struct sockaddr_in *) server_addr)->sin_port); |
1375 | break; | 1363 | break; |
1376 | 1364 | case AF_INET6: | |
1377 | case AF_INET6: | 1365 | port = ntohs (((const struct sockaddr_in6 *) server_addr)->sin6_port); |
1378 | port = ntohs(((const struct sockaddr_in6 *)server_addr)->sin6_port); | 1366 | break; |
1379 | break; | 1367 | case AF_UNIX: |
1380 | 1368 | port = 0; | |
1381 | case AF_UNIX: | 1369 | break; |
1382 | port = 0; | 1370 | default: |
1383 | break; | 1371 | GNUNET_break (0); |
1384 | 1372 | port = 0; | |
1385 | default: | 1373 | break; |
1386 | GNUNET_break(0); | 1374 | } |
1387 | port = 0; | 1375 | sock = GNUNET_NETWORK_socket_create (server_addr->sa_family, |
1388 | break; | 1376 | SOCK_STREAM, |
1389 | } | 1377 | 0); |
1390 | sock = GNUNET_NETWORK_socket_create(server_addr->sa_family, SOCK_STREAM, 0); | ||
1391 | if (NULL == sock) | 1378 | if (NULL == sock) |
1392 | { | 1379 | { |
1393 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "socket"); | 1380 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, |
1394 | errno = 0; | 1381 | "socket"); |
1395 | return NULL; | 1382 | errno = 0; |
1396 | } | 1383 | return NULL; |
1384 | } | ||
1397 | /* bind the socket */ | 1385 | /* bind the socket */ |
1398 | if (GNUNET_OK != GNUNET_NETWORK_socket_bind(sock, server_addr, socklen)) | 1386 | if (GNUNET_OK != |
1387 | GNUNET_NETWORK_socket_bind (sock, | ||
1388 | server_addr, | ||
1389 | socklen)) | ||
1390 | { | ||
1391 | eno = errno; | ||
1392 | if (EADDRINUSE != errno) | ||
1399 | { | 1393 | { |
1400 | eno = errno; | 1394 | /* we don't log 'EADDRINUSE' here since an IPv4 bind may |
1401 | if (EADDRINUSE != errno) | 1395 | * fail if we already took the port on IPv6; if both IPv4 and |
1402 | { | 1396 | * IPv6 binds fail, then our caller will log using the |
1403 | /* we don't log 'EADDRINUSE' here since an IPv4 bind may | 1397 | * errno preserved in 'eno' */ |
1404 | * fail if we already took the port on IPv6; if both IPv4 and | 1398 | if (0 != port) |
1405 | * IPv6 binds fail, then our caller will log using the | 1399 | LOG (GNUNET_ERROR_TYPE_ERROR, |
1406 | * errno preserved in 'eno' */ | 1400 | _ ("`%s' failed for port %d (%s).\n"), |
1407 | if (0 != port) | 1401 | "bind", |
1408 | LOG(GNUNET_ERROR_TYPE_ERROR, | 1402 | port, |
1409 | _("`%s' failed for port %d (%s).\n"), | 1403 | (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6"); |
1410 | "bind", | ||
1411 | port, | ||
1412 | (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6"); | ||
1413 | else | ||
1414 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "bind"); | ||
1415 | eno = 0; | ||
1416 | } | ||
1417 | else | 1404 | else |
1418 | { | 1405 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "bind"); |
1419 | if (0 != port) | 1406 | eno = 0; |
1420 | LOG(GNUNET_ERROR_TYPE_WARNING, | ||
1421 | _("`%s' failed for port %d (%s): address already in use\n"), | ||
1422 | "bind", | ||
1423 | port, | ||
1424 | (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6"); | ||
1425 | else if (AF_UNIX == server_addr->sa_family) | ||
1426 | { | ||
1427 | LOG(GNUNET_ERROR_TYPE_WARNING, | ||
1428 | _("`%s' failed for `%s': address already in use\n"), | ||
1429 | "bind", | ||
1430 | GNUNET_a2s(server_addr, socklen)); | ||
1431 | } | ||
1432 | } | ||
1433 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(sock)); | ||
1434 | errno = eno; | ||
1435 | return NULL; | ||
1436 | } | 1407 | } |
1437 | if (GNUNET_OK != GNUNET_NETWORK_socket_listen(sock, 5)) | 1408 | else |
1438 | { | 1409 | { |
1439 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "listen"); | 1410 | if (0 != port) |
1440 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(sock)); | 1411 | LOG (GNUNET_ERROR_TYPE_WARNING, |
1441 | errno = 0; | 1412 | _ ("`%s' failed for port %d (%s): address already in use\n"), |
1442 | return NULL; | 1413 | "bind", |
1414 | port, | ||
1415 | (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6"); | ||
1416 | else if (AF_UNIX == server_addr->sa_family) | ||
1417 | { | ||
1418 | LOG (GNUNET_ERROR_TYPE_WARNING, | ||
1419 | _ ("`%s' failed for `%s': address already in use\n"), | ||
1420 | "bind", | ||
1421 | GNUNET_a2s (server_addr, socklen)); | ||
1422 | } | ||
1443 | } | 1423 | } |
1424 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock)); | ||
1425 | errno = eno; | ||
1426 | return NULL; | ||
1427 | } | ||
1428 | if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock, 5)) | ||
1429 | { | ||
1430 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "listen"); | ||
1431 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock)); | ||
1432 | errno = 0; | ||
1433 | return NULL; | ||
1434 | } | ||
1444 | if (0 != port) | 1435 | if (0 != port) |
1445 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1436 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1446 | "Server starts to listen on port %u.\n", | 1437 | "Server starts to listen on port %u.\n", |
1447 | port); | 1438 | port); |
1448 | return sock; | 1439 | return sock; |
1449 | } | 1440 | } |
1450 | 1441 | ||
@@ -1466,128 +1457,141 @@ open_listen_socket(const struct sockaddr *server_addr, socklen_t socklen) | |||
1466 | * @return #GNUNET_OK if configuration succeeded | 1457 | * @return #GNUNET_OK if configuration succeeded |
1467 | */ | 1458 | */ |
1468 | static int | 1459 | static int |
1469 | setup_service(struct GNUNET_SERVICE_Handle *sh) | 1460 | setup_service (struct GNUNET_SERVICE_Handle *sh) |
1470 | { | 1461 | { |
1471 | int tolerant; | 1462 | int tolerant; |
1463 | struct GNUNET_NETWORK_Handle **csocks = NULL; | ||
1472 | struct GNUNET_NETWORK_Handle **lsocks; | 1464 | struct GNUNET_NETWORK_Handle **lsocks; |
1473 | const char *nfds; | 1465 | const char *nfds; |
1474 | unsigned int cnt; | 1466 | unsigned int cnt; |
1475 | int flags; | 1467 | int flags; |
1476 | char dummy[2]; | 1468 | char dummy[2]; |
1477 | 1469 | ||
1478 | if (GNUNET_CONFIGURATION_have_value(sh->cfg, sh->service_name, "TOLERANT")) | 1470 | if (GNUNET_CONFIGURATION_have_value (sh->cfg, |
1471 | sh->service_name, | ||
1472 | "TOLERANT")) | ||
1473 | { | ||
1474 | if (GNUNET_SYSERR == | ||
1475 | (tolerant = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg, | ||
1476 | sh->service_name, | ||
1477 | "TOLERANT"))) | ||
1479 | { | 1478 | { |
1480 | if (GNUNET_SYSERR == | 1479 | LOG (GNUNET_ERROR_TYPE_ERROR, |
1481 | (tolerant = GNUNET_CONFIGURATION_get_value_yesno(sh->cfg, | 1480 | _ ("Specified value for `%s' of service `%s' is invalid\n"), |
1482 | sh->service_name, | 1481 | "TOLERANT", |
1483 | "TOLERANT"))) | 1482 | sh->service_name); |
1484 | { | 1483 | return GNUNET_SYSERR; |
1485 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
1486 | _("Specified value for `%s' of service `%s' is invalid\n"), | ||
1487 | "TOLERANT", | ||
1488 | sh->service_name); | ||
1489 | return GNUNET_SYSERR; | ||
1490 | } | ||
1491 | } | 1484 | } |
1485 | } | ||
1492 | else | 1486 | else |
1493 | tolerant = GNUNET_NO; | 1487 | tolerant = GNUNET_NO; |
1494 | 1488 | ||
1495 | lsocks = NULL; | 1489 | lsocks = NULL; |
1496 | |||
1497 | errno = 0; | 1490 | errno = 0; |
1498 | if ((NULL != (nfds = getenv("LISTEN_FDS"))) && | 1491 | if ((NULL != (nfds = getenv ("LISTEN_FDS"))) && |
1499 | (1 == sscanf(nfds, "%u%1s", &cnt, dummy)) && (cnt > 0) && | 1492 | (1 == sscanf (nfds, "%u%1s", &cnt, dummy)) && (cnt > 0) && |
1500 | (cnt < FD_SETSIZE) && (cnt + 4 < FD_SETSIZE)) | 1493 | (cnt < FD_SETSIZE) && (cnt + 4 < FD_SETSIZE)) |
1494 | { | ||
1495 | lsocks = GNUNET_new_array (cnt + 1, struct GNUNET_NETWORK_Handle *); | ||
1496 | while (0 < cnt--) | ||
1501 | { | 1497 | { |
1502 | lsocks = GNUNET_new_array(cnt + 1, struct GNUNET_NETWORK_Handle *); | 1498 | flags = fcntl (3 + cnt, F_GETFD); |
1503 | while (0 < cnt--) | 1499 | if ((flags < 0) || (0 != (flags & FD_CLOEXEC)) || |
1504 | { | 1500 | (NULL == (lsocks[cnt] = GNUNET_NETWORK_socket_box_native (3 + cnt)))) |
1505 | flags = fcntl(3 + cnt, F_GETFD); | 1501 | { |
1506 | if ((flags < 0) || (0 != (flags & FD_CLOEXEC)) || | 1502 | LOG (GNUNET_ERROR_TYPE_ERROR, |
1507 | (NULL == (lsocks[cnt] = GNUNET_NETWORK_socket_box_native(3 + cnt)))) | 1503 | _ ( |
1508 | { | 1504 | "Could not access pre-bound socket %u, will try to bind myself\n"), |
1509 | LOG(GNUNET_ERROR_TYPE_ERROR, | 1505 | (unsigned int) 3 + cnt); |
1510 | _( | 1506 | cnt++; |
1511 | "Could not access pre-bound socket %u, will try to bind myself\n"), | 1507 | while (NULL != lsocks[cnt]) |
1512 | (unsigned int)3 + cnt); | 1508 | GNUNET_break (GNUNET_OK == |
1513 | cnt++; | 1509 | GNUNET_NETWORK_socket_close (lsocks[cnt++])); |
1514 | while (NULL != lsocks[cnt]) | 1510 | GNUNET_free (lsocks); |
1515 | GNUNET_break(GNUNET_OK == | 1511 | lsocks = NULL; |
1516 | GNUNET_NETWORK_socket_close(lsocks[cnt++])); | 1512 | break; |
1517 | GNUNET_free(lsocks); | 1513 | } |
1518 | lsocks = NULL; | ||
1519 | break; | ||
1520 | } | ||
1521 | } | ||
1522 | unsetenv("LISTEN_FDS"); | ||
1523 | } | 1514 | } |
1515 | unsetenv ("LISTEN_FDS"); | ||
1516 | } | ||
1517 | if ( (0 != (GNUNET_SERVICE_OPTION_CLOSE_LSOCKS & sh->options)) && | ||
1518 | (NULL != lsocks) ) | ||
1519 | { | ||
1520 | csocks = lsocks; | ||
1521 | lsocks = NULL; | ||
1522 | } | ||
1524 | 1523 | ||
1525 | if (NULL != lsocks) | 1524 | if (NULL != lsocks) |
1525 | { | ||
1526 | /* listen only on inherited sockets if we have any */ | ||
1527 | for (struct GNUNET_NETWORK_Handle **ls = lsocks; NULL != *ls; ls++) | ||
1526 | { | 1528 | { |
1527 | /* listen only on inherited sockets if we have any */ | 1529 | struct ServiceListenContext *slc; |
1528 | struct GNUNET_NETWORK_Handle **ls; | 1530 | |
1529 | 1531 | slc = GNUNET_new (struct ServiceListenContext); | |
1530 | for (ls = lsocks; NULL != *ls; ls++) | 1532 | slc->sh = sh; |
1531 | { | 1533 | slc->listen_socket = *ls; |
1532 | struct ServiceListenContext *slc; | 1534 | GNUNET_CONTAINER_DLL_insert (sh->slc_head, sh->slc_tail, slc); |
1533 | |||
1534 | slc = GNUNET_new(struct ServiceListenContext); | ||
1535 | slc->sh = sh; | ||
1536 | slc->listen_socket = *ls; | ||
1537 | GNUNET_CONTAINER_DLL_insert(sh->slc_head, sh->slc_tail, slc); | ||
1538 | } | ||
1539 | GNUNET_free(lsocks); | ||
1540 | } | 1535 | } |
1536 | GNUNET_free (lsocks); | ||
1537 | } | ||
1541 | else | 1538 | else |
1542 | { | 1539 | { |
1543 | struct sockaddr **addrs; | 1540 | struct sockaddr **addrs; |
1544 | socklen_t *addrlens; | 1541 | socklen_t *addrlens; |
1545 | int num; | 1542 | int num; |
1546 | 1543 | ||
1547 | num = get_server_addresses(sh->service_name, sh->cfg, &addrs, &addrlens); | 1544 | num = get_server_addresses (sh->service_name, sh->cfg, &addrs, &addrlens); |
1548 | if (GNUNET_SYSERR == num) | 1545 | if (GNUNET_SYSERR == num) |
1549 | return GNUNET_SYSERR; | 1546 | return GNUNET_SYSERR; |
1550 | 1547 | ||
1551 | for (int i = 0; i < num; i++) | 1548 | for (int i = 0; i < num; i++) |
1552 | { | 1549 | { |
1553 | struct ServiceListenContext *slc; | 1550 | struct ServiceListenContext *slc; |
1554 | |||
1555 | slc = GNUNET_new(struct ServiceListenContext); | ||
1556 | slc->sh = sh; | ||
1557 | slc->listen_socket = open_listen_socket(addrs[i], addrlens[i]); | ||
1558 | GNUNET_free(addrs[i]); | ||
1559 | if (NULL == slc->listen_socket) | ||
1560 | { | ||
1561 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "bind"); | ||
1562 | GNUNET_free(slc); | ||
1563 | continue; | ||
1564 | } | ||
1565 | GNUNET_CONTAINER_DLL_insert(sh->slc_head, sh->slc_tail, slc); | ||
1566 | } | ||
1567 | GNUNET_free_non_null(addrlens); | ||
1568 | GNUNET_free_non_null(addrs); | ||
1569 | if ((0 != num) && (NULL == sh->slc_head)) | ||
1570 | { | ||
1571 | /* All attempts to bind failed, hard failure */ | ||
1572 | GNUNET_log( | ||
1573 | GNUNET_ERROR_TYPE_ERROR, | ||
1574 | _( | ||
1575 | "Could not bind to any of the ports I was supposed to, refusing to run!\n")); | ||
1576 | return GNUNET_SYSERR; | ||
1577 | } | ||
1578 | } | ||
1579 | 1551 | ||
1552 | slc = GNUNET_new (struct ServiceListenContext); | ||
1553 | slc->sh = sh; | ||
1554 | slc->listen_socket = open_listen_socket (addrs[i], addrlens[i]); | ||
1555 | GNUNET_free (addrs[i]); | ||
1556 | if (NULL == slc->listen_socket) | ||
1557 | { | ||
1558 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind"); | ||
1559 | GNUNET_free (slc); | ||
1560 | continue; | ||
1561 | } | ||
1562 | GNUNET_CONTAINER_DLL_insert (sh->slc_head, sh->slc_tail, slc); | ||
1563 | } | ||
1564 | GNUNET_free_non_null (addrlens); | ||
1565 | GNUNET_free_non_null (addrs); | ||
1566 | if ((0 != num) && (NULL == sh->slc_head)) | ||
1567 | { | ||
1568 | /* All attempts to bind failed, hard failure */ | ||
1569 | GNUNET_log ( | ||
1570 | GNUNET_ERROR_TYPE_ERROR, | ||
1571 | _ ( | ||
1572 | "Could not bind to any of the ports I was supposed to, refusing to run!\n")); | ||
1573 | GNUNET_free_non_null (csocks); | ||
1574 | return GNUNET_SYSERR; | ||
1575 | } | ||
1576 | } | ||
1577 | if (NULL != csocks) | ||
1578 | { | ||
1579 | /* close inherited sockets to signal parent that we are ready */ | ||
1580 | for (struct GNUNET_NETWORK_Handle **ls = csocks; NULL != *ls; ls++) | ||
1581 | GNUNET_NETWORK_socket_close (*ls); | ||
1582 | GNUNET_free (csocks); | ||
1583 | } | ||
1580 | sh->require_found = tolerant ? GNUNET_NO : GNUNET_YES; | 1584 | sh->require_found = tolerant ? GNUNET_NO : GNUNET_YES; |
1581 | sh->match_uid = GNUNET_CONFIGURATION_get_value_yesno(sh->cfg, | 1585 | sh->match_uid = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg, |
1582 | sh->service_name, | 1586 | sh->service_name, |
1583 | "UNIX_MATCH_UID"); | 1587 | "UNIX_MATCH_UID"); |
1584 | sh->match_gid = GNUNET_CONFIGURATION_get_value_yesno(sh->cfg, | 1588 | sh->match_gid = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg, |
1585 | sh->service_name, | 1589 | sh->service_name, |
1586 | "UNIX_MATCH_GID"); | 1590 | "UNIX_MATCH_GID"); |
1587 | process_acl4(&sh->v4_denied, sh, "REJECT_FROM"); | 1591 | process_acl4 (&sh->v4_denied, sh, "REJECT_FROM"); |
1588 | process_acl4(&sh->v4_allowed, sh, "ACCEPT_FROM"); | 1592 | process_acl4 (&sh->v4_allowed, sh, "ACCEPT_FROM"); |
1589 | process_acl6(&sh->v6_denied, sh, "REJECT_FROM6"); | 1593 | process_acl6 (&sh->v6_denied, sh, "REJECT_FROM6"); |
1590 | process_acl6(&sh->v6_allowed, sh, "ACCEPT_FROM6"); | 1594 | process_acl6 (&sh->v6_allowed, sh, "ACCEPT_FROM6"); |
1591 | return GNUNET_OK; | 1595 | return GNUNET_OK; |
1592 | } | 1596 | } |
1593 | 1597 | ||
@@ -1600,14 +1604,14 @@ setup_service(struct GNUNET_SERVICE_Handle *sh) | |||
1600 | * @return value of the 'USERNAME' option | 1604 | * @return value of the 'USERNAME' option |
1601 | */ | 1605 | */ |
1602 | static char * | 1606 | static char * |
1603 | get_user_name(struct GNUNET_SERVICE_Handle *sh) | 1607 | get_user_name (struct GNUNET_SERVICE_Handle *sh) |
1604 | { | 1608 | { |
1605 | char *un; | 1609 | char *un; |
1606 | 1610 | ||
1607 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(sh->cfg, | 1611 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (sh->cfg, |
1608 | sh->service_name, | 1612 | sh->service_name, |
1609 | "USERNAME", | 1613 | "USERNAME", |
1610 | &un)) | 1614 | &un)) |
1611 | return NULL; | 1615 | return NULL; |
1612 | return un; | 1616 | return un; |
1613 | } | 1617 | } |
@@ -1620,45 +1624,45 @@ get_user_name(struct GNUNET_SERVICE_Handle *sh) | |||
1620 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error | 1624 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error |
1621 | */ | 1625 | */ |
1622 | static int | 1626 | static int |
1623 | set_user_id(struct GNUNET_SERVICE_Handle *sh) | 1627 | set_user_id (struct GNUNET_SERVICE_Handle *sh) |
1624 | { | 1628 | { |
1625 | char *user; | 1629 | char *user; |
1626 | 1630 | ||
1627 | if (NULL == (user = get_user_name(sh))) | 1631 | if (NULL == (user = get_user_name (sh))) |
1628 | return GNUNET_OK; /* keep */ | 1632 | return GNUNET_OK; /* keep */ |
1629 | 1633 | ||
1630 | struct passwd *pws; | 1634 | struct passwd *pws; |
1631 | 1635 | ||
1632 | errno = 0; | 1636 | errno = 0; |
1633 | pws = getpwnam(user); | 1637 | pws = getpwnam (user); |
1634 | if (NULL == pws) | 1638 | if (NULL == pws) |
1635 | { | 1639 | { |
1636 | LOG(GNUNET_ERROR_TYPE_ERROR, | 1640 | LOG (GNUNET_ERROR_TYPE_ERROR, |
1637 | _("Cannot obtain information about user `%s': %s\n"), | 1641 | _ ("Cannot obtain information about user `%s': %s\n"), |
1638 | user, | 1642 | user, |
1639 | errno == 0 ? _("No such user") : strerror(errno)); | 1643 | errno == 0 ? _ ("No such user") : strerror (errno)); |
1640 | GNUNET_free(user); | 1644 | GNUNET_free (user); |
1641 | return GNUNET_SYSERR; | 1645 | return GNUNET_SYSERR; |
1642 | } | 1646 | } |
1643 | if ((0 != setgid(pws->pw_gid)) || (0 != setegid(pws->pw_gid)) || | 1647 | if ((0 != setgid (pws->pw_gid)) || (0 != setegid (pws->pw_gid)) || |
1644 | #if HAVE_INITGROUPS | 1648 | #if HAVE_INITGROUPS |
1645 | (0 != initgroups(user, pws->pw_gid)) || | 1649 | (0 != initgroups (user, pws->pw_gid)) || |
1646 | #endif | 1650 | #endif |
1647 | (0 != setuid(pws->pw_uid)) || (0 != seteuid(pws->pw_uid))) | 1651 | (0 != setuid (pws->pw_uid)) || (0 != seteuid (pws->pw_uid))) |
1652 | { | ||
1653 | if ((0 != setregid (pws->pw_gid, pws->pw_gid)) || | ||
1654 | (0 != setreuid (pws->pw_uid, pws->pw_uid))) | ||
1648 | { | 1655 | { |
1649 | if ((0 != setregid(pws->pw_gid, pws->pw_gid)) || | 1656 | LOG (GNUNET_ERROR_TYPE_ERROR, |
1650 | (0 != setreuid(pws->pw_uid, pws->pw_uid))) | 1657 | _ ("Cannot change user/group to `%s': %s\n"), |
1651 | { | 1658 | user, |
1652 | LOG(GNUNET_ERROR_TYPE_ERROR, | 1659 | strerror (errno)); |
1653 | _("Cannot change user/group to `%s': %s\n"), | 1660 | GNUNET_free (user); |
1654 | user, | 1661 | return GNUNET_SYSERR; |
1655 | strerror(errno)); | ||
1656 | GNUNET_free(user); | ||
1657 | return GNUNET_SYSERR; | ||
1658 | } | ||
1659 | } | 1662 | } |
1663 | } | ||
1660 | 1664 | ||
1661 | GNUNET_free(user); | 1665 | GNUNET_free (user); |
1662 | return GNUNET_OK; | 1666 | return GNUNET_OK; |
1663 | } | 1667 | } |
1664 | 1668 | ||
@@ -1671,14 +1675,14 @@ set_user_id(struct GNUNET_SERVICE_Handle *sh) | |||
1671 | * @return name of the file for the process ID | 1675 | * @return name of the file for the process ID |
1672 | */ | 1676 | */ |
1673 | static char * | 1677 | static char * |
1674 | get_pid_file_name(struct GNUNET_SERVICE_Handle *sh) | 1678 | get_pid_file_name (struct GNUNET_SERVICE_Handle *sh) |
1675 | { | 1679 | { |
1676 | char *pif; | 1680 | char *pif; |
1677 | 1681 | ||
1678 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(sh->cfg, | 1682 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (sh->cfg, |
1679 | sh->service_name, | 1683 | sh->service_name, |
1680 | "PIDFILE", | 1684 | "PIDFILE", |
1681 | &pif)) | 1685 | &pif)) |
1682 | return NULL; | 1686 | return NULL; |
1683 | return pif; | 1687 | return pif; |
1684 | } | 1688 | } |
@@ -1690,15 +1694,15 @@ get_pid_file_name(struct GNUNET_SERVICE_Handle *sh) | |||
1690 | * @param sh service context | 1694 | * @param sh service context |
1691 | */ | 1695 | */ |
1692 | static void | 1696 | static void |
1693 | pid_file_delete(struct GNUNET_SERVICE_Handle *sh) | 1697 | pid_file_delete (struct GNUNET_SERVICE_Handle *sh) |
1694 | { | 1698 | { |
1695 | char *pif = get_pid_file_name(sh); | 1699 | char *pif = get_pid_file_name (sh); |
1696 | 1700 | ||
1697 | if (NULL == pif) | 1701 | if (NULL == pif) |
1698 | return; /* no PID file */ | 1702 | return; /* no PID file */ |
1699 | if (0 != unlink(pif)) | 1703 | if (0 != unlink (pif)) |
1700 | LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "unlink", pif); | 1704 | LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "unlink", pif); |
1701 | GNUNET_free(pif); | 1705 | GNUNET_free (pif); |
1702 | } | 1706 | } |
1703 | 1707 | ||
1704 | 1708 | ||
@@ -1709,73 +1713,73 @@ pid_file_delete(struct GNUNET_SERVICE_Handle *sh) | |||
1709 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error | 1713 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error |
1710 | */ | 1714 | */ |
1711 | static int | 1715 | static int |
1712 | detach_terminal(struct GNUNET_SERVICE_Handle *sh) | 1716 | detach_terminal (struct GNUNET_SERVICE_Handle *sh) |
1713 | { | 1717 | { |
1714 | pid_t pid; | 1718 | pid_t pid; |
1715 | int nullfd; | 1719 | int nullfd; |
1716 | int filedes[2]; | 1720 | int filedes[2]; |
1717 | 1721 | ||
1718 | if (0 != pipe(filedes)) | 1722 | if (0 != pipe (filedes)) |
1719 | { | 1723 | { |
1720 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "pipe"); | 1724 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "pipe"); |
1721 | return GNUNET_SYSERR; | 1725 | return GNUNET_SYSERR; |
1722 | } | 1726 | } |
1723 | pid = fork(); | 1727 | pid = fork (); |
1724 | if (pid < 0) | 1728 | if (pid < 0) |
1725 | { | 1729 | { |
1726 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "fork"); | 1730 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "fork"); |
1727 | return GNUNET_SYSERR; | 1731 | return GNUNET_SYSERR; |
1728 | } | 1732 | } |
1729 | if (0 != pid) | 1733 | if (0 != pid) |
1734 | { | ||
1735 | /* Parent */ | ||
1736 | char c; | ||
1737 | |||
1738 | GNUNET_break (0 == close (filedes[1])); | ||
1739 | c = 'X'; | ||
1740 | if (1 != read (filedes[0], &c, sizeof(char))) | ||
1741 | LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "read"); | ||
1742 | fflush (stdout); | ||
1743 | switch (c) | ||
1730 | { | 1744 | { |
1731 | /* Parent */ | 1745 | case '.': |
1732 | char c; | 1746 | exit (0); |
1733 | 1747 | ||
1734 | GNUNET_break(0 == close(filedes[1])); | 1748 | case 'I': |
1735 | c = 'X'; | 1749 | LOG (GNUNET_ERROR_TYPE_INFO, |
1736 | if (1 != read(filedes[0], &c, sizeof(char))) | 1750 | _ ("Service process failed to initialize\n")); |
1737 | LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "read"); | 1751 | break; |
1738 | fflush(stdout); | 1752 | |
1739 | switch (c) | 1753 | case 'S': |
1740 | { | 1754 | LOG (GNUNET_ERROR_TYPE_INFO, |
1741 | case '.': | 1755 | _ ("Service process could not initialize server function\n")); |
1742 | exit(0); | 1756 | break; |
1743 | 1757 | ||
1744 | case 'I': | 1758 | case 'X': |
1745 | LOG(GNUNET_ERROR_TYPE_INFO, | 1759 | LOG (GNUNET_ERROR_TYPE_INFO, |
1746 | _("Service process failed to initialize\n")); | 1760 | _ ("Service process failed to report status\n")); |
1747 | break; | 1761 | break; |
1748 | |||
1749 | case 'S': | ||
1750 | LOG(GNUNET_ERROR_TYPE_INFO, | ||
1751 | _("Service process could not initialize server function\n")); | ||
1752 | break; | ||
1753 | |||
1754 | case 'X': | ||
1755 | LOG(GNUNET_ERROR_TYPE_INFO, | ||
1756 | _("Service process failed to report status\n")); | ||
1757 | break; | ||
1758 | } | ||
1759 | exit(1); /* child reported error */ | ||
1760 | } | 1762 | } |
1761 | GNUNET_break(0 == close(0)); | 1763 | exit (1); /* child reported error */ |
1762 | GNUNET_break(0 == close(1)); | 1764 | } |
1763 | GNUNET_break(0 == close(filedes[0])); | 1765 | GNUNET_break (0 == close (0)); |
1764 | nullfd = open("/dev/null", O_RDWR | O_APPEND); | 1766 | GNUNET_break (0 == close (1)); |
1767 | GNUNET_break (0 == close (filedes[0])); | ||
1768 | nullfd = open ("/dev/null", O_RDWR | O_APPEND); | ||
1765 | if (nullfd < 0) | 1769 | if (nullfd < 0) |
1766 | return GNUNET_SYSERR; | 1770 | return GNUNET_SYSERR; |
1767 | /* set stdin/stdout to /dev/null */ | 1771 | /* set stdin/stdout to /dev/null */ |
1768 | if ((dup2(nullfd, 0) < 0) || (dup2(nullfd, 1) < 0)) | 1772 | if ((dup2 (nullfd, 0) < 0) || (dup2 (nullfd, 1) < 0)) |
1769 | { | 1773 | { |
1770 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "dup2"); | 1774 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2"); |
1771 | (void)close(nullfd); | 1775 | (void) close (nullfd); |
1772 | return GNUNET_SYSERR; | 1776 | return GNUNET_SYSERR; |
1773 | } | 1777 | } |
1774 | (void)close(nullfd); | 1778 | (void) close (nullfd); |
1775 | /* Detach from controlling terminal */ | 1779 | /* Detach from controlling terminal */ |
1776 | pid = setsid(); | 1780 | pid = setsid (); |
1777 | if (-1 == pid) | 1781 | if (-1 == pid) |
1778 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "setsid"); | 1782 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "setsid"); |
1779 | sh->ready_confirm_fd = filedes[1]; | 1783 | sh->ready_confirm_fd = filedes[1]; |
1780 | 1784 | ||
1781 | return GNUNET_OK; | 1785 | return GNUNET_OK; |
@@ -1789,23 +1793,23 @@ detach_terminal(struct GNUNET_SERVICE_Handle *sh) | |||
1789 | * @param sh handle to the service to tear down. | 1793 | * @param sh handle to the service to tear down. |
1790 | */ | 1794 | */ |
1791 | static void | 1795 | static void |
1792 | teardown_service(struct GNUNET_SERVICE_Handle *sh) | 1796 | teardown_service (struct GNUNET_SERVICE_Handle *sh) |
1793 | { | 1797 | { |
1794 | struct ServiceListenContext *slc; | 1798 | struct ServiceListenContext *slc; |
1795 | 1799 | ||
1796 | GNUNET_free_non_null(sh->v4_denied); | 1800 | GNUNET_free_non_null (sh->v4_denied); |
1797 | GNUNET_free_non_null(sh->v6_denied); | 1801 | GNUNET_free_non_null (sh->v6_denied); |
1798 | GNUNET_free_non_null(sh->v4_allowed); | 1802 | GNUNET_free_non_null (sh->v4_allowed); |
1799 | GNUNET_free_non_null(sh->v6_allowed); | 1803 | GNUNET_free_non_null (sh->v6_allowed); |
1800 | while (NULL != (slc = sh->slc_head)) | 1804 | while (NULL != (slc = sh->slc_head)) |
1801 | { | 1805 | { |
1802 | GNUNET_CONTAINER_DLL_remove(sh->slc_head, sh->slc_tail, slc); | 1806 | GNUNET_CONTAINER_DLL_remove (sh->slc_head, sh->slc_tail, slc); |
1803 | if (NULL != slc->listen_task) | 1807 | if (NULL != slc->listen_task) |
1804 | GNUNET_SCHEDULER_cancel(slc->listen_task); | 1808 | GNUNET_SCHEDULER_cancel (slc->listen_task); |
1805 | GNUNET_break(GNUNET_OK == | 1809 | GNUNET_break (GNUNET_OK == |
1806 | GNUNET_NETWORK_socket_close(slc->listen_socket)); | 1810 | GNUNET_NETWORK_socket_close (slc->listen_socket)); |
1807 | GNUNET_free(slc); | 1811 | GNUNET_free (slc); |
1808 | } | 1812 | } |
1809 | } | 1813 | } |
1810 | 1814 | ||
1811 | 1815 | ||
@@ -1816,7 +1820,7 @@ teardown_service(struct GNUNET_SERVICE_Handle *sh) | |||
1816 | * @param msg AGPL request | 1820 | * @param msg AGPL request |
1817 | */ | 1821 | */ |
1818 | static void | 1822 | static void |
1819 | return_agpl(void *cls, const struct GNUNET_MessageHeader *msg) | 1823 | return_agpl (void *cls, const struct GNUNET_MessageHeader *msg) |
1820 | { | 1824 | { |
1821 | struct GNUNET_SERVICE_Client *client = cls; | 1825 | struct GNUNET_SERVICE_Client *client = cls; |
1822 | struct GNUNET_MQ_Handle *mq; | 1826 | struct GNUNET_MQ_Handle *mq; |
@@ -1824,13 +1828,13 @@ return_agpl(void *cls, const struct GNUNET_MessageHeader *msg) | |||
1824 | struct GNUNET_MessageHeader *res; | 1828 | struct GNUNET_MessageHeader *res; |
1825 | size_t slen; | 1829 | size_t slen; |
1826 | 1830 | ||
1827 | (void)msg; | 1831 | (void) msg; |
1828 | slen = strlen(GNUNET_AGPL_URL) + 1; | 1832 | slen = strlen (GNUNET_AGPL_URL) + 1; |
1829 | env = GNUNET_MQ_msg_extra(res, GNUNET_MESSAGE_TYPE_RESPONSE_AGPL, slen); | 1833 | env = GNUNET_MQ_msg_extra (res, GNUNET_MESSAGE_TYPE_RESPONSE_AGPL, slen); |
1830 | memcpy(&res[1], GNUNET_AGPL_URL, slen); | 1834 | memcpy (&res[1], GNUNET_AGPL_URL, slen); |
1831 | mq = GNUNET_SERVICE_client_get_mq(client); | 1835 | mq = GNUNET_SERVICE_client_get_mq (client); |
1832 | GNUNET_MQ_send(mq, env); | 1836 | GNUNET_MQ_send (mq, env); |
1833 | GNUNET_SERVICE_client_continue(client); | 1837 | GNUNET_SERVICE_client_continue (client); |
1834 | } | 1838 | } |
1835 | 1839 | ||
1836 | 1840 | ||
@@ -1871,29 +1875,29 @@ return_agpl(void *cls, const struct GNUNET_MessageHeader *msg) | |||
1871 | * @return NULL on error | 1875 | * @return NULL on error |
1872 | */ | 1876 | */ |
1873 | struct GNUNET_SERVICE_Handle * | 1877 | struct GNUNET_SERVICE_Handle * |
1874 | GNUNET_SERVICE_start(const char *service_name, | 1878 | GNUNET_SERVICE_start (const char *service_name, |
1875 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 1879 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
1876 | GNUNET_SERVICE_ConnectHandler connect_cb, | 1880 | GNUNET_SERVICE_ConnectHandler connect_cb, |
1877 | GNUNET_SERVICE_DisconnectHandler disconnect_cb, | 1881 | GNUNET_SERVICE_DisconnectHandler disconnect_cb, |
1878 | void *cls, | 1882 | void *cls, |
1879 | const struct GNUNET_MQ_MessageHandler *handlers) | 1883 | const struct GNUNET_MQ_MessageHandler *handlers) |
1880 | { | 1884 | { |
1881 | struct GNUNET_SERVICE_Handle *sh; | 1885 | struct GNUNET_SERVICE_Handle *sh; |
1882 | 1886 | ||
1883 | sh = GNUNET_new(struct GNUNET_SERVICE_Handle); | 1887 | sh = GNUNET_new (struct GNUNET_SERVICE_Handle); |
1884 | sh->service_name = service_name; | 1888 | sh->service_name = service_name; |
1885 | sh->cfg = cfg; | 1889 | sh->cfg = cfg; |
1886 | sh->connect_cb = connect_cb; | 1890 | sh->connect_cb = connect_cb; |
1887 | sh->disconnect_cb = disconnect_cb; | 1891 | sh->disconnect_cb = disconnect_cb; |
1888 | sh->cb_cls = cls; | 1892 | sh->cb_cls = cls; |
1889 | sh->handlers = GNUNET_MQ_copy_handlers2(handlers, &return_agpl, NULL); | 1893 | sh->handlers = GNUNET_MQ_copy_handlers2 (handlers, &return_agpl, NULL); |
1890 | if (GNUNET_OK != setup_service(sh)) | 1894 | if (GNUNET_OK != setup_service (sh)) |
1891 | { | 1895 | { |
1892 | GNUNET_free_non_null(sh->handlers); | 1896 | GNUNET_free_non_null (sh->handlers); |
1893 | GNUNET_free(sh); | 1897 | GNUNET_free (sh); |
1894 | return NULL; | 1898 | return NULL; |
1895 | } | 1899 | } |
1896 | do_resume(sh, SUSPEND_STATE_NONE); | 1900 | do_resume (sh, SUSPEND_STATE_NONE); |
1897 | return sh; | 1901 | return sh; |
1898 | } | 1902 | } |
1899 | 1903 | ||
@@ -1904,16 +1908,16 @@ GNUNET_SERVICE_start(const char *service_name, | |||
1904 | * @param srv service to stop | 1908 | * @param srv service to stop |
1905 | */ | 1909 | */ |
1906 | void | 1910 | void |
1907 | GNUNET_SERVICE_stop(struct GNUNET_SERVICE_Handle *srv) | 1911 | GNUNET_SERVICE_stop (struct GNUNET_SERVICE_Handle *srv) |
1908 | { | 1912 | { |
1909 | struct GNUNET_SERVICE_Client *client; | 1913 | struct GNUNET_SERVICE_Client *client; |
1910 | 1914 | ||
1911 | GNUNET_SERVICE_suspend(srv); | 1915 | GNUNET_SERVICE_suspend (srv); |
1912 | while (NULL != (client = srv->clients_head)) | 1916 | while (NULL != (client = srv->clients_head)) |
1913 | GNUNET_SERVICE_client_drop(client); | 1917 | GNUNET_SERVICE_client_drop (client); |
1914 | teardown_service(srv); | 1918 | teardown_service (srv); |
1915 | GNUNET_free_non_null(srv->handlers); | 1919 | GNUNET_free_non_null (srv->handlers); |
1916 | GNUNET_free(srv); | 1920 | GNUNET_free (srv); |
1917 | } | 1921 | } |
1918 | 1922 | ||
1919 | 1923 | ||
@@ -1959,15 +1963,15 @@ GNUNET_SERVICE_stop(struct GNUNET_SERVICE_Handle *srv) | |||
1959 | * @return 0 on success, non-zero on error | 1963 | * @return 0 on success, non-zero on error |
1960 | */ | 1964 | */ |
1961 | int | 1965 | int |
1962 | GNUNET_SERVICE_run_(int argc, | 1966 | GNUNET_SERVICE_run_ (int argc, |
1963 | char *const *argv, | 1967 | char *const *argv, |
1964 | const char *service_name, | 1968 | const char *service_name, |
1965 | enum GNUNET_SERVICE_Options options, | 1969 | enum GNUNET_SERVICE_Options options, |
1966 | GNUNET_SERVICE_InitCallback service_init_cb, | 1970 | GNUNET_SERVICE_InitCallback service_init_cb, |
1967 | GNUNET_SERVICE_ConnectHandler connect_cb, | 1971 | GNUNET_SERVICE_ConnectHandler connect_cb, |
1968 | GNUNET_SERVICE_DisconnectHandler disconnect_cb, | 1972 | GNUNET_SERVICE_DisconnectHandler disconnect_cb, |
1969 | void *cls, | 1973 | void *cls, |
1970 | const struct GNUNET_MQ_MessageHandler *handlers) | 1974 | const struct GNUNET_MQ_MessageHandler *handlers) |
1971 | { | 1975 | { |
1972 | struct GNUNET_SERVICE_Handle sh; | 1976 | struct GNUNET_SERVICE_Handle sh; |
1973 | 1977 | ||
@@ -1986,40 +1990,40 @@ GNUNET_SERVICE_run_(int argc, | |||
1986 | struct GNUNET_CONFIGURATION_Handle *cfg; | 1990 | struct GNUNET_CONFIGURATION_Handle *cfg; |
1987 | int ret; | 1991 | int ret; |
1988 | int err; | 1992 | int err; |
1989 | const struct GNUNET_OS_ProjectData *pd = GNUNET_OS_project_data_get(); | 1993 | const struct GNUNET_OS_ProjectData *pd = GNUNET_OS_project_data_get (); |
1990 | 1994 | struct GNUNET_GETOPT_CommandLineOption service_options[] = { | |
1991 | struct GNUNET_GETOPT_CommandLineOption service_options[] = | 1995 | GNUNET_GETOPT_option_cfgfile (&opt_cfg_filename), |
1992 | { GNUNET_GETOPT_option_cfgfile(&opt_cfg_filename), | 1996 | GNUNET_GETOPT_option_flag ('d', |
1993 | GNUNET_GETOPT_option_flag('d', | 1997 | "daemonize", |
1994 | "daemonize", | 1998 | gettext_noop ( |
1995 | gettext_noop( | 1999 | "do daemonize (detach from terminal)"), |
1996 | "do daemonize (detach from terminal)"), | 2000 | &do_daemonize), |
1997 | &do_daemonize), | 2001 | GNUNET_GETOPT_option_help (NULL), |
1998 | GNUNET_GETOPT_option_help(NULL), | 2002 | GNUNET_GETOPT_option_loglevel (&loglev), |
1999 | GNUNET_GETOPT_option_loglevel(&loglev), | 2003 | GNUNET_GETOPT_option_logfile (&logfile), |
2000 | GNUNET_GETOPT_option_logfile(&logfile), | 2004 | GNUNET_GETOPT_option_version (pd->version), |
2001 | GNUNET_GETOPT_option_version(pd->version), | 2005 | GNUNET_GETOPT_OPTION_END |
2002 | GNUNET_GETOPT_OPTION_END }; | 2006 | }; |
2003 | 2007 | ||
2004 | err = 1; | 2008 | err = 1; |
2005 | memset(&sh, 0, sizeof(sh)); | 2009 | memset (&sh, 0, sizeof(sh)); |
2006 | xdg = getenv("XDG_CONFIG_HOME"); | 2010 | xdg = getenv ("XDG_CONFIG_HOME"); |
2007 | if (NULL != xdg) | 2011 | if (NULL != xdg) |
2008 | GNUNET_asprintf(&cfg_filename, | 2012 | GNUNET_asprintf (&cfg_filename, |
2009 | "%s%s%s", | 2013 | "%s%s%s", |
2010 | xdg, | 2014 | xdg, |
2011 | DIR_SEPARATOR_STR, | 2015 | DIR_SEPARATOR_STR, |
2012 | pd->config_file); | 2016 | pd->config_file); |
2013 | else | 2017 | else |
2014 | cfg_filename = GNUNET_strdup(pd->user_config_file); | 2018 | cfg_filename = GNUNET_strdup (pd->user_config_file); |
2015 | sh.ready_confirm_fd = -1; | 2019 | sh.ready_confirm_fd = -1; |
2016 | sh.options = options; | 2020 | sh.options = options; |
2017 | sh.cfg = cfg = GNUNET_CONFIGURATION_create(); | 2021 | sh.cfg = cfg = GNUNET_CONFIGURATION_create (); |
2018 | sh.service_init_cb = service_init_cb; | 2022 | sh.service_init_cb = service_init_cb; |
2019 | sh.connect_cb = connect_cb; | 2023 | sh.connect_cb = connect_cb; |
2020 | sh.disconnect_cb = disconnect_cb; | 2024 | sh.disconnect_cb = disconnect_cb; |
2021 | sh.cb_cls = cls; | 2025 | sh.cb_cls = cls; |
2022 | sh.handlers = GNUNET_MQ_copy_handlers(handlers); | 2026 | sh.handlers = GNUNET_MQ_copy_handlers (handlers); |
2023 | sh.service_name = service_name; | 2027 | sh.service_name = service_name; |
2024 | sh.ret = 0; | 2028 | sh.ret = 0; |
2025 | /* setup subsystems */ | 2029 | /* setup subsystems */ |
@@ -2029,135 +2033,140 @@ GNUNET_SERVICE_run_(int argc, | |||
2029 | do_daemonize = 0; | 2033 | do_daemonize = 0; |
2030 | #if ENABLE_NLS | 2034 | #if ENABLE_NLS |
2031 | if (NULL != pd->gettext_domain) | 2035 | if (NULL != pd->gettext_domain) |
2036 | { | ||
2037 | setlocale (LC_ALL, ""); | ||
2038 | path = (NULL == pd->gettext_path) ? | ||
2039 | GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LOCALEDIR) : | ||
2040 | GNUNET_strdup (pd->gettext_path); | ||
2041 | if (NULL != path) | ||
2032 | { | 2042 | { |
2033 | setlocale(LC_ALL, ""); | 2043 | bindtextdomain (pd->gettext_domain, path); |
2034 | path = (NULL == pd->gettext_path) ? | 2044 | GNUNET_free (path); |
2035 | GNUNET_OS_installation_get_path(GNUNET_OS_IPK_LOCALEDIR) : | ||
2036 | GNUNET_strdup(pd->gettext_path); | ||
2037 | if (NULL != path) | ||
2038 | { | ||
2039 | bindtextdomain(pd->gettext_domain, path); | ||
2040 | GNUNET_free(path); | ||
2041 | } | ||
2042 | textdomain(pd->gettext_domain); | ||
2043 | } | 2045 | } |
2046 | textdomain (pd->gettext_domain); | ||
2047 | } | ||
2044 | #endif | 2048 | #endif |
2045 | ret = GNUNET_GETOPT_run(service_name, service_options, argc, argv); | 2049 | ret = GNUNET_GETOPT_run (service_name, |
2050 | service_options, | ||
2051 | argc, | ||
2052 | argv); | ||
2046 | if (GNUNET_SYSERR == ret) | 2053 | if (GNUNET_SYSERR == ret) |
2047 | goto shutdown; | 2054 | goto shutdown; |
2048 | if (GNUNET_NO == ret) | 2055 | if (GNUNET_NO == ret) |
2049 | { | 2056 | { |
2050 | err = 0; | 2057 | err = 0; |
2051 | goto shutdown; | 2058 | goto shutdown; |
2052 | } | 2059 | } |
2053 | if (GNUNET_OK != GNUNET_log_setup(service_name, loglev, logfile)) | 2060 | if (GNUNET_OK != GNUNET_log_setup (service_name, |
2054 | { | 2061 | loglev, |
2055 | GNUNET_break(0); | 2062 | logfile)) |
2056 | goto shutdown; | 2063 | { |
2057 | } | 2064 | GNUNET_break (0); |
2065 | goto shutdown; | ||
2066 | } | ||
2058 | if (NULL != opt_cfg_filename) | 2067 | if (NULL != opt_cfg_filename) |
2068 | { | ||
2069 | if ((GNUNET_YES != GNUNET_DISK_file_test (opt_cfg_filename)) || | ||
2070 | (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, opt_cfg_filename))) | ||
2059 | { | 2071 | { |
2060 | if ((GNUNET_YES != GNUNET_DISK_file_test(opt_cfg_filename)) || | 2072 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
2061 | (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(cfg, opt_cfg_filename))) | 2073 | _ ("Malformed configuration file `%s', exit ...\n"), |
2062 | { | 2074 | opt_cfg_filename); |
2063 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 2075 | goto shutdown; |
2064 | _("Malformed configuration file `%s', exit ...\n"), | ||
2065 | opt_cfg_filename); | ||
2066 | goto shutdown; | ||
2067 | } | ||
2068 | } | 2076 | } |
2077 | } | ||
2069 | else | 2078 | else |
2079 | { | ||
2080 | if (GNUNET_YES == GNUNET_DISK_file_test (cfg_filename)) | ||
2070 | { | 2081 | { |
2071 | if (GNUNET_YES == GNUNET_DISK_file_test(cfg_filename)) | 2082 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, cfg_filename)) |
2072 | { | 2083 | { |
2073 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(cfg, cfg_filename)) | 2084 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
2074 | { | 2085 | _ ("Malformed configuration file `%s', exit ...\n"), |
2075 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 2086 | cfg_filename); |
2076 | _("Malformed configuration file `%s', exit ...\n"), | 2087 | goto shutdown; |
2077 | cfg_filename); | 2088 | } |
2078 | goto shutdown; | ||
2079 | } | ||
2080 | } | ||
2081 | else | ||
2082 | { | ||
2083 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(cfg, NULL)) | ||
2084 | { | ||
2085 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | ||
2086 | _("Malformed configuration, exit ...\n")); | ||
2087 | goto shutdown; | ||
2088 | } | ||
2089 | } | ||
2090 | } | 2089 | } |
2091 | if (GNUNET_OK != setup_service(&sh)) | 2090 | else |
2092 | goto shutdown; | ||
2093 | if ((1 == do_daemonize) && (GNUNET_OK != detach_terminal(&sh))) | ||
2094 | { | 2091 | { |
2095 | GNUNET_break(0); | 2092 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, NULL)) |
2096 | goto shutdown; | 2093 | { |
2094 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
2095 | _ ("Malformed configuration, exit ...\n")); | ||
2096 | goto shutdown; | ||
2097 | } | ||
2097 | } | 2098 | } |
2098 | if (GNUNET_OK != set_user_id(&sh)) | 2099 | } |
2100 | if (GNUNET_OK != setup_service (&sh)) | ||
2099 | goto shutdown; | 2101 | goto shutdown; |
2100 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2102 | if ((1 == do_daemonize) && (GNUNET_OK != detach_terminal (&sh))) |
2101 | "Service `%s' runs with configuration from `%s'\n", | 2103 | { |
2102 | service_name, | 2104 | GNUNET_break (0); |
2103 | (NULL != opt_cfg_filename) ? opt_cfg_filename : cfg_filename); | 2105 | goto shutdown; |
2104 | if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(sh.cfg, | 2106 | } |
2105 | "TESTING", | 2107 | if (GNUNET_OK != set_user_id (&sh)) |
2106 | "SKEW_OFFSET", | 2108 | goto shutdown; |
2107 | &skew_offset)) && | 2109 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2108 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(sh.cfg, | 2110 | "Service `%s' runs with configuration from `%s'\n", |
2109 | "TESTING", | 2111 | service_name, |
2110 | "SKEW_VARIANCE", | 2112 | (NULL != opt_cfg_filename) ? opt_cfg_filename : cfg_filename); |
2111 | &skew_variance))) | 2113 | if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (sh.cfg, |
2112 | { | 2114 | "TESTING", |
2113 | clock_offset = skew_offset - skew_variance; | 2115 | "SKEW_OFFSET", |
2114 | GNUNET_TIME_set_offset(clock_offset); | 2116 | &skew_offset)) && |
2115 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Skewing clock by %dll ms\n", clock_offset); | 2117 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (sh.cfg, |
2116 | } | 2118 | "TESTING", |
2117 | GNUNET_RESOLVER_connect(sh.cfg); | 2119 | "SKEW_VARIANCE", |
2120 | &skew_variance))) | ||
2121 | { | ||
2122 | clock_offset = skew_offset - skew_variance; | ||
2123 | GNUNET_TIME_set_offset (clock_offset); | ||
2124 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Skewing clock by %dll ms\n", clock_offset); | ||
2125 | } | ||
2126 | GNUNET_RESOLVER_connect (sh.cfg); | ||
2118 | 2127 | ||
2119 | /* actually run service */ | 2128 | /* actually run service */ |
2120 | err = 0; | 2129 | err = 0; |
2121 | GNUNET_SCHEDULER_run(&service_main, &sh); | 2130 | GNUNET_SCHEDULER_run (&service_main, &sh); |
2122 | /* shutdown */ | 2131 | /* shutdown */ |
2123 | if (1 == do_daemonize) | 2132 | if (1 == do_daemonize) |
2124 | pid_file_delete(&sh); | 2133 | pid_file_delete (&sh); |
2125 | 2134 | ||
2126 | shutdown: | 2135 | shutdown: |
2127 | if (-1 != sh.ready_confirm_fd) | 2136 | if (-1 != sh.ready_confirm_fd) |
2128 | { | 2137 | { |
2129 | if (1 != write(sh.ready_confirm_fd, err ? "I" : "S", 1)) | 2138 | if (1 != write (sh.ready_confirm_fd, err ? "I" : "S", 1)) |
2130 | LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "write"); | 2139 | LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "write"); |
2131 | GNUNET_break(0 == close(sh.ready_confirm_fd)); | 2140 | GNUNET_break (0 == close (sh.ready_confirm_fd)); |
2132 | } | 2141 | } |
2133 | #if HAVE_MALLINFO | 2142 | #if HAVE_MALLINFO |
2134 | { | 2143 | { |
2135 | char *counter; | 2144 | char *counter; |
2136 | 2145 | ||
2137 | if ((GNUNET_YES == GNUNET_CONFIGURATION_have_value(sh.cfg, | 2146 | if ((GNUNET_YES == GNUNET_CONFIGURATION_have_value (sh.cfg, |
2138 | service_name, | 2147 | service_name, |
2139 | "GAUGER_HEAP")) && | 2148 | "GAUGER_HEAP")) && |
2140 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(sh.cfg, | 2149 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (sh.cfg, |
2141 | service_name, | 2150 | service_name, |
2142 | "GAUGER_HEAP", | 2151 | "GAUGER_HEAP", |
2143 | &counter))) | 2152 | &counter))) |
2144 | { | 2153 | { |
2145 | struct mallinfo mi; | 2154 | struct mallinfo mi; |
2146 | 2155 | ||
2147 | mi = mallinfo(); | 2156 | mi = mallinfo (); |
2148 | GAUGER(service_name, counter, mi.usmblks, "blocks"); | 2157 | GAUGER (service_name, counter, mi.usmblks, "blocks"); |
2149 | GNUNET_free(counter); | 2158 | GNUNET_free (counter); |
2150 | } | 2159 | } |
2151 | } | 2160 | } |
2152 | #endif | 2161 | #endif |
2153 | teardown_service(&sh); | 2162 | teardown_service (&sh); |
2154 | GNUNET_free_non_null(sh.handlers); | 2163 | GNUNET_free_non_null (sh.handlers); |
2155 | GNUNET_SPEEDUP_stop_(); | 2164 | GNUNET_SPEEDUP_stop_ (); |
2156 | GNUNET_CONFIGURATION_destroy(cfg); | 2165 | GNUNET_CONFIGURATION_destroy (cfg); |
2157 | GNUNET_free_non_null(logfile); | 2166 | GNUNET_free_non_null (logfile); |
2158 | GNUNET_free_non_null(loglev); | 2167 | GNUNET_free_non_null (loglev); |
2159 | GNUNET_free(cfg_filename); | 2168 | GNUNET_free (cfg_filename); |
2160 | GNUNET_free_non_null(opt_cfg_filename); | 2169 | GNUNET_free_non_null (opt_cfg_filename); |
2161 | 2170 | ||
2162 | return err ? GNUNET_SYSERR : sh.ret; | 2171 | return err ? GNUNET_SYSERR : sh.ret; |
2163 | } | 2172 | } |
@@ -2170,9 +2179,9 @@ shutdown: | |||
2170 | * @param sh service to stop accepting connections. | 2179 | * @param sh service to stop accepting connections. |
2171 | */ | 2180 | */ |
2172 | void | 2181 | void |
2173 | GNUNET_SERVICE_suspend(struct GNUNET_SERVICE_Handle *sh) | 2182 | GNUNET_SERVICE_suspend (struct GNUNET_SERVICE_Handle *sh) |
2174 | { | 2183 | { |
2175 | do_suspend(sh, SUSPEND_STATE_APP); | 2184 | do_suspend (sh, SUSPEND_STATE_APP); |
2176 | } | 2185 | } |
2177 | 2186 | ||
2178 | 2187 | ||
@@ -2182,9 +2191,9 @@ GNUNET_SERVICE_suspend(struct GNUNET_SERVICE_Handle *sh) | |||
2182 | * @param sh service to resume accepting connections. | 2191 | * @param sh service to resume accepting connections. |
2183 | */ | 2192 | */ |
2184 | void | 2193 | void |
2185 | GNUNET_SERVICE_resume(struct GNUNET_SERVICE_Handle *sh) | 2194 | GNUNET_SERVICE_resume (struct GNUNET_SERVICE_Handle *sh) |
2186 | { | 2195 | { |
2187 | do_resume(sh, SUSPEND_STATE_APP); | 2196 | do_resume (sh, SUSPEND_STATE_APP); |
2188 | } | 2197 | } |
2189 | 2198 | ||
2190 | 2199 | ||
@@ -2195,32 +2204,32 @@ GNUNET_SERVICE_resume(struct GNUNET_SERVICE_Handle *sh) | |||
2195 | * @param cls our `struct GNUNET_SERVICE_Client` | 2204 | * @param cls our `struct GNUNET_SERVICE_Client` |
2196 | */ | 2205 | */ |
2197 | static void | 2206 | static void |
2198 | resume_client_receive(void *cls) | 2207 | resume_client_receive (void *cls) |
2199 | { | 2208 | { |
2200 | struct GNUNET_SERVICE_Client *c = cls; | 2209 | struct GNUNET_SERVICE_Client *c = cls; |
2201 | int ret; | 2210 | int ret; |
2202 | 2211 | ||
2203 | c->recv_task = NULL; | 2212 | c->recv_task = NULL; |
2204 | /* first, check if there is still something in the buffer */ | 2213 | /* first, check if there is still something in the buffer */ |
2205 | ret = GNUNET_MST_next(c->mst, GNUNET_YES); | 2214 | ret = GNUNET_MST_next (c->mst, GNUNET_YES); |
2206 | if (GNUNET_SYSERR == ret) | 2215 | if (GNUNET_SYSERR == ret) |
2207 | { | 2216 | { |
2208 | if (NULL == c->drop_task) | 2217 | if (NULL == c->drop_task) |
2209 | GNUNET_SERVICE_client_drop(c); | 2218 | GNUNET_SERVICE_client_drop (c); |
2210 | return; | 2219 | return; |
2211 | } | 2220 | } |
2212 | if (GNUNET_NO == ret) | 2221 | if (GNUNET_NO == ret) |
2213 | return; /* done processing, wait for more later */ | 2222 | return; /* done processing, wait for more later */ |
2214 | GNUNET_assert(GNUNET_OK == ret); | 2223 | GNUNET_assert (GNUNET_OK == ret); |
2215 | if (GNUNET_YES == c->needs_continue) | 2224 | if (GNUNET_YES == c->needs_continue) |
2216 | return; /* #GNUNET_MST_next() did give a message to the client */ | 2225 | return; /* #GNUNET_MST_next() did give a message to the client */ |
2217 | /* need to receive more data from the network first */ | 2226 | /* need to receive more data from the network first */ |
2218 | if (NULL != c->recv_task) | 2227 | if (NULL != c->recv_task) |
2219 | return; | 2228 | return; |
2220 | c->recv_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | 2229 | c->recv_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
2221 | c->sock, | 2230 | c->sock, |
2222 | &service_client_recv, | 2231 | &service_client_recv, |
2223 | c); | 2232 | c); |
2224 | } | 2233 | } |
2225 | 2234 | ||
2226 | 2235 | ||
@@ -2231,18 +2240,18 @@ resume_client_receive(void *cls) | |||
2231 | * @param c the client to continue receiving from | 2240 | * @param c the client to continue receiving from |
2232 | */ | 2241 | */ |
2233 | void | 2242 | void |
2234 | GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c) | 2243 | GNUNET_SERVICE_client_continue (struct GNUNET_SERVICE_Client *c) |
2235 | { | 2244 | { |
2236 | GNUNET_assert(NULL == c->drop_task); | 2245 | GNUNET_assert (NULL == c->drop_task); |
2237 | GNUNET_assert(GNUNET_YES == c->needs_continue); | 2246 | GNUNET_assert (GNUNET_YES == c->needs_continue); |
2238 | GNUNET_assert(NULL == c->recv_task); | 2247 | GNUNET_assert (NULL == c->recv_task); |
2239 | c->needs_continue = GNUNET_NO; | 2248 | c->needs_continue = GNUNET_NO; |
2240 | if (NULL != c->warn_task) | 2249 | if (NULL != c->warn_task) |
2241 | { | 2250 | { |
2242 | GNUNET_SCHEDULER_cancel(c->warn_task); | 2251 | GNUNET_SCHEDULER_cancel (c->warn_task); |
2243 | c->warn_task = NULL; | 2252 | c->warn_task = NULL; |
2244 | } | 2253 | } |
2245 | c->recv_task = GNUNET_SCHEDULER_add_now(&resume_client_receive, c); | 2254 | c->recv_task = GNUNET_SCHEDULER_add_now (&resume_client_receive, c); |
2246 | } | 2255 | } |
2247 | 2256 | ||
2248 | 2257 | ||
@@ -2255,14 +2264,14 @@ GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c) | |||
2255 | * @param c client for which to disable the warning | 2264 | * @param c client for which to disable the warning |
2256 | */ | 2265 | */ |
2257 | void | 2266 | void |
2258 | GNUNET_SERVICE_client_disable_continue_warning(struct GNUNET_SERVICE_Client *c) | 2267 | GNUNET_SERVICE_client_disable_continue_warning (struct GNUNET_SERVICE_Client *c) |
2259 | { | 2268 | { |
2260 | GNUNET_break(NULL != c->warn_task); | 2269 | GNUNET_break (NULL != c->warn_task); |
2261 | if (NULL != c->warn_task) | 2270 | if (NULL != c->warn_task) |
2262 | { | 2271 | { |
2263 | GNUNET_SCHEDULER_cancel(c->warn_task); | 2272 | GNUNET_SCHEDULER_cancel (c->warn_task); |
2264 | c->warn_task = NULL; | 2273 | c->warn_task = NULL; |
2265 | } | 2274 | } |
2266 | } | 2275 | } |
2267 | 2276 | ||
2268 | 2277 | ||
@@ -2272,32 +2281,32 @@ GNUNET_SERVICE_client_disable_continue_warning(struct GNUNET_SERVICE_Client *c) | |||
2272 | * @param cls the `struct GNUNET_SERVICE_Client`. | 2281 | * @param cls the `struct GNUNET_SERVICE_Client`. |
2273 | */ | 2282 | */ |
2274 | static void | 2283 | static void |
2275 | finish_client_drop(void *cls) | 2284 | finish_client_drop (void *cls) |
2276 | { | 2285 | { |
2277 | struct GNUNET_SERVICE_Client *c = cls; | 2286 | struct GNUNET_SERVICE_Client *c = cls; |
2278 | struct GNUNET_SERVICE_Handle *sh = c->sh; | 2287 | struct GNUNET_SERVICE_Handle *sh = c->sh; |
2279 | 2288 | ||
2280 | c->drop_task = NULL; | 2289 | c->drop_task = NULL; |
2281 | GNUNET_assert(NULL == c->send_task); | 2290 | GNUNET_assert (NULL == c->send_task); |
2282 | GNUNET_assert(NULL == c->recv_task); | 2291 | GNUNET_assert (NULL == c->recv_task); |
2283 | GNUNET_assert(NULL == c->warn_task); | 2292 | GNUNET_assert (NULL == c->warn_task); |
2284 | GNUNET_MST_destroy(c->mst); | 2293 | GNUNET_MST_destroy (c->mst); |
2285 | GNUNET_MQ_destroy(c->mq); | 2294 | GNUNET_MQ_destroy (c->mq); |
2286 | if (GNUNET_NO == c->persist) | 2295 | if (GNUNET_NO == c->persist) |
2287 | { | 2296 | { |
2288 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(c->sock)); | 2297 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (c->sock)); |
2289 | if ((0 != (SUSPEND_STATE_EMFILE & sh->suspend_state)) && | 2298 | if ((0 != (SUSPEND_STATE_EMFILE & sh->suspend_state)) && |
2290 | (0 == (SUSPEND_STATE_SHUTDOWN & sh->suspend_state))) | 2299 | (0 == (SUSPEND_STATE_SHUTDOWN & sh->suspend_state))) |
2291 | do_resume(sh, SUSPEND_STATE_EMFILE); | 2300 | do_resume (sh, SUSPEND_STATE_EMFILE); |
2292 | } | 2301 | } |
2293 | else | 2302 | else |
2294 | { | 2303 | { |
2295 | GNUNET_NETWORK_socket_free_memory_only_(c->sock); | 2304 | GNUNET_NETWORK_socket_free_memory_only_ (c->sock); |
2296 | } | 2305 | } |
2297 | GNUNET_free(c); | 2306 | GNUNET_free (c); |
2298 | if ((0 != (SUSPEND_STATE_SHUTDOWN & sh->suspend_state)) && | 2307 | if ((0 != (SUSPEND_STATE_SHUTDOWN & sh->suspend_state)) && |
2299 | (GNUNET_NO == have_non_monitor_clients(sh))) | 2308 | (GNUNET_NO == have_non_monitor_clients (sh))) |
2300 | GNUNET_SERVICE_shutdown(sh); | 2309 | GNUNET_SERVICE_shutdown (sh); |
2301 | } | 2310 | } |
2302 | 2311 | ||
2303 | 2312 | ||
@@ -2312,52 +2321,56 @@ finish_client_drop(void *cls) | |||
2312 | * @param c client to disconnect now | 2321 | * @param c client to disconnect now |
2313 | */ | 2322 | */ |
2314 | void | 2323 | void |
2315 | GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c) | 2324 | GNUNET_SERVICE_client_drop (struct GNUNET_SERVICE_Client *c) |
2316 | { | 2325 | { |
2317 | struct GNUNET_SERVICE_Handle *sh = c->sh; | 2326 | struct GNUNET_SERVICE_Handle *sh = c->sh; |
2318 | 2327 | ||
2319 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 2328 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2320 | "Client dropped: %p (MQ: %p)\n", | 2329 | "Client dropped: %p (MQ: %p)\n", |
2321 | c, | 2330 | c, |
2322 | c->mq); | 2331 | c->mq); |
2323 | #if EXECINFO | 2332 | #if EXECINFO |
2324 | { | 2333 | { |
2325 | void *backtrace_array[MAX_TRACE_DEPTH]; | 2334 | void *backtrace_array[MAX_TRACE_DEPTH]; |
2326 | int num_backtrace_strings = backtrace(backtrace_array, MAX_TRACE_DEPTH); | 2335 | int num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH); |
2327 | char **backtrace_strings = | 2336 | char **backtrace_strings = |
2328 | backtrace_symbols(backtrace_array, t->num_backtrace_strings); | 2337 | backtrace_symbols (backtrace_array, t->num_backtrace_strings); |
2329 | for (unsigned int i = 0; i < num_backtrace_strings; i++) | 2338 | for (unsigned int i = 0; i < num_backtrace_strings; i++) |
2330 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2339 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2331 | "client drop trace %u: %s\n", | 2340 | "client drop trace %u: %s\n", |
2332 | i, | 2341 | i, |
2333 | backtrace_strings[i]); | 2342 | backtrace_strings[i]); |
2334 | } | 2343 | } |
2335 | #endif | 2344 | #endif |
2336 | if (NULL != c->drop_task) | 2345 | if (NULL != c->drop_task) |
2337 | { | 2346 | { |
2338 | /* asked to drop twice! */ | 2347 | /* asked to drop twice! */ |
2339 | GNUNET_assert(0); | 2348 | GNUNET_assert (0); |
2340 | return; | 2349 | return; |
2341 | } | 2350 | } |
2342 | GNUNET_CONTAINER_DLL_remove(sh->clients_head, sh->clients_tail, c); | 2351 | GNUNET_CONTAINER_DLL_remove (sh->clients_head, |
2352 | sh->clients_tail, | ||
2353 | c); | ||
2343 | if (NULL != sh->disconnect_cb) | 2354 | if (NULL != sh->disconnect_cb) |
2344 | sh->disconnect_cb(sh->cb_cls, c, c->user_context); | 2355 | sh->disconnect_cb (sh->cb_cls, |
2356 | c, | ||
2357 | c->user_context); | ||
2345 | if (NULL != c->warn_task) | 2358 | if (NULL != c->warn_task) |
2346 | { | 2359 | { |
2347 | GNUNET_SCHEDULER_cancel(c->warn_task); | 2360 | GNUNET_SCHEDULER_cancel (c->warn_task); |
2348 | c->warn_task = NULL; | 2361 | c->warn_task = NULL; |
2349 | } | 2362 | } |
2350 | if (NULL != c->recv_task) | 2363 | if (NULL != c->recv_task) |
2351 | { | 2364 | { |
2352 | GNUNET_SCHEDULER_cancel(c->recv_task); | 2365 | GNUNET_SCHEDULER_cancel (c->recv_task); |
2353 | c->recv_task = NULL; | 2366 | c->recv_task = NULL; |
2354 | } | 2367 | } |
2355 | if (NULL != c->send_task) | 2368 | if (NULL != c->send_task) |
2356 | { | 2369 | { |
2357 | GNUNET_SCHEDULER_cancel(c->send_task); | 2370 | GNUNET_SCHEDULER_cancel (c->send_task); |
2358 | c->send_task = NULL; | 2371 | c->send_task = NULL; |
2359 | } | 2372 | } |
2360 | c->drop_task = GNUNET_SCHEDULER_add_now(&finish_client_drop, c); | 2373 | c->drop_task = GNUNET_SCHEDULER_add_now (&finish_client_drop, c); |
2361 | } | 2374 | } |
2362 | 2375 | ||
2363 | 2376 | ||
@@ -2367,14 +2380,14 @@ GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c) | |||
2367 | * @param sh server to shutdown | 2380 | * @param sh server to shutdown |
2368 | */ | 2381 | */ |
2369 | void | 2382 | void |
2370 | GNUNET_SERVICE_shutdown(struct GNUNET_SERVICE_Handle *sh) | 2383 | GNUNET_SERVICE_shutdown (struct GNUNET_SERVICE_Handle *sh) |
2371 | { | 2384 | { |
2372 | struct GNUNET_SERVICE_Client *client; | 2385 | struct GNUNET_SERVICE_Client *client; |
2373 | 2386 | ||
2374 | if (0 == (sh->suspend_state & SUSPEND_STATE_SHUTDOWN)) | 2387 | if (0 == (sh->suspend_state & SUSPEND_STATE_SHUTDOWN)) |
2375 | do_suspend(sh, SUSPEND_STATE_SHUTDOWN); | 2388 | do_suspend (sh, SUSPEND_STATE_SHUTDOWN); |
2376 | while (NULL != (client = sh->clients_head)) | 2389 | while (NULL != (client = sh->clients_head)) |
2377 | GNUNET_SERVICE_client_drop(client); | 2390 | GNUNET_SERVICE_client_drop (client); |
2378 | } | 2391 | } |
2379 | 2392 | ||
2380 | 2393 | ||
@@ -2391,12 +2404,12 @@ GNUNET_SERVICE_shutdown(struct GNUNET_SERVICE_Handle *sh) | |||
2391 | * @param c client to mark as a monitor | 2404 | * @param c client to mark as a monitor |
2392 | */ | 2405 | */ |
2393 | void | 2406 | void |
2394 | GNUNET_SERVICE_client_mark_monitor(struct GNUNET_SERVICE_Client *c) | 2407 | GNUNET_SERVICE_client_mark_monitor (struct GNUNET_SERVICE_Client *c) |
2395 | { | 2408 | { |
2396 | c->is_monitor = GNUNET_YES; | 2409 | c->is_monitor = GNUNET_YES; |
2397 | if (((0 != (SUSPEND_STATE_SHUTDOWN & c->sh->suspend_state)) && | 2410 | if (((0 != (SUSPEND_STATE_SHUTDOWN & c->sh->suspend_state)) && |
2398 | (GNUNET_NO == have_non_monitor_clients(c->sh)))) | 2411 | (GNUNET_NO == have_non_monitor_clients (c->sh)))) |
2399 | GNUNET_SERVICE_shutdown(c->sh); | 2412 | GNUNET_SERVICE_shutdown (c->sh); |
2400 | } | 2413 | } |
2401 | 2414 | ||
2402 | 2415 | ||
@@ -2408,7 +2421,7 @@ GNUNET_SERVICE_client_mark_monitor(struct GNUNET_SERVICE_Client *c) | |||
2408 | * @param c client to persist the socket (never to be closed) | 2421 | * @param c client to persist the socket (never to be closed) |
2409 | */ | 2422 | */ |
2410 | void | 2423 | void |
2411 | GNUNET_SERVICE_client_persist(struct GNUNET_SERVICE_Client *c) | 2424 | GNUNET_SERVICE_client_persist (struct GNUNET_SERVICE_Client *c) |
2412 | { | 2425 | { |
2413 | c->persist = GNUNET_YES; | 2426 | c->persist = GNUNET_YES; |
2414 | } | 2427 | } |
@@ -2421,10 +2434,10 @@ GNUNET_SERVICE_client_persist(struct GNUNET_SERVICE_Client *c) | |||
2421 | * @return the message queue of @a c | 2434 | * @return the message queue of @a c |
2422 | */ | 2435 | */ |
2423 | struct GNUNET_MQ_Handle * | 2436 | struct GNUNET_MQ_Handle * |
2424 | GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c) | 2437 | GNUNET_SERVICE_client_get_mq (struct GNUNET_SERVICE_Client *c) |
2425 | { | 2438 | { |
2426 | return c->mq; | 2439 | return c->mq; |
2427 | } | 2440 | } |
2428 | 2441 | ||
2429 | 2442 | ||
2430 | /* end of service_new.c */ | 2443 | /* end of service.c */ |