GNUnet 0.22.2
helper.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2011, 2012 Christian Grothoff
4
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
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version.
9
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details.
14
15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17
18 SPDX-License-Identifier: AGPL3.0-or-later
19 */
20
28#include "platform.h"
29#include "gnunet_util_lib.h"
30
35{
40
45
50
55
60
64 void *cont_cls;
65
69 unsigned int wpos;
70};
71
72
77{
82
87
92
97
102
107
112
116 void *cb_cls;
117
122
127
132
137
142
147
152
157
161 unsigned int retry_back_off;
162};
163
164
167{
169 int ret;
170
171 while (NULL != (sh = h->sh_head))
172 {
173 GNUNET_CONTAINER_DLL_remove (h->sh_head, h->sh_tail, sh);
174 if (NULL != sh->cont)
175 sh->cont (sh->cont_cls, GNUNET_NO);
176 GNUNET_free (sh);
177 }
178 if (NULL != h->restart_task)
179 {
180 GNUNET_SCHEDULER_cancel (h->restart_task);
181 h->restart_task = NULL;
182 }
183 if (NULL != h->read_task)
184 {
185 GNUNET_SCHEDULER_cancel (h->read_task);
186 h->read_task = NULL;
187 }
188 if (NULL == h->helper_proc)
189 return GNUNET_SYSERR;
190 if (GNUNET_YES == soft_kill)
191 {
192 /* soft-kill only possible with pipes */
193 GNUNET_assert (NULL != h->helper_in);
194 ret = GNUNET_DISK_pipe_close (h->helper_in);
195 h->helper_in = NULL;
196 h->fh_to_helper = NULL;
197 return ret;
198 }
199 if (0 != GNUNET_OS_process_kill (h->helper_proc, GNUNET_TERM_SIG))
200 return GNUNET_SYSERR;
201 return GNUNET_OK;
202}
203
204
207{
209 int ret;
210
212 if (NULL != h->helper_proc)
213 {
214 ret = GNUNET_OS_process_wait (h->helper_proc);
215 GNUNET_OS_process_destroy (h->helper_proc);
216 h->helper_proc = NULL;
217 }
218 if (NULL != h->read_task)
219 {
220 GNUNET_SCHEDULER_cancel (h->read_task);
221 h->read_task = NULL;
222 }
223 if (NULL != h->write_task)
224 {
225 GNUNET_SCHEDULER_cancel (h->write_task);
226 h->write_task = NULL;
227 }
228 if (NULL != h->helper_in)
229 {
230 GNUNET_DISK_pipe_close (h->helper_in);
231 h->helper_in = NULL;
232 h->fh_to_helper = NULL;
233 }
234 if (NULL != h->helper_out)
235 {
236 GNUNET_DISK_pipe_close (h->helper_out);
237 h->helper_out = NULL;
238 h->fh_from_helper = NULL;
239 }
240 while (NULL != (sh = h->sh_head))
241 {
242 GNUNET_CONTAINER_DLL_remove (h->sh_head, h->sh_tail, sh);
243 if (NULL != sh->cont)
244 sh->cont (sh->cont_cls, GNUNET_NO);
245 GNUNET_free (sh);
246 }
247 /* purge MST buffer */
248 if (NULL != h->mst)
249 (void) GNUNET_MST_from_buffer (h->mst, NULL, 0, GNUNET_YES, GNUNET_NO);
250 return ret;
251}
252
253
261static void
262stop_helper (struct GNUNET_HELPER_Handle *h, int soft_kill)
263{
264 if (NULL != h->restart_task)
265 {
266 GNUNET_SCHEDULER_cancel (h->restart_task);
267 h->restart_task = NULL;
268 }
269 else
270 {
271 GNUNET_break (GNUNET_OK == GNUNET_HELPER_kill (h, soft_kill));
273 }
274}
275
276
282static void
283restart_task (void *cls);
284
285
291static void
292helper_read (void *cls)
293{
294 struct GNUNET_HELPER_Handle *h = cls;
296 ssize_t t;
297
298 h->read_task = NULL;
299 t = GNUNET_DISK_file_read (h->fh_from_helper, &buf, sizeof(buf));
300 if (t < 0)
301 {
302 /* On read-error, restart the helper */
304 _ ("Error reading from `%s': %s\n"),
305 h->binary_name,
306 strerror (errno));
307 if (NULL != h->exp_cb)
308 {
309 h->exp_cb (h->cb_cls);
311 return;
312 }
314 /* Restart the helper */
315 h->restart_task = GNUNET_SCHEDULER_add_delayed (
317 h->retry_back_off),
319 h);
320 return;
321 }
322 if (0 == t)
323 {
324 /* this happens if the helper is shut down via a
325 signal, so it is not a "hard" error */
327 "Got 0 bytes from helper `%s' (EOF)\n",
328 h->binary_name);
329 if (NULL != h->exp_cb)
330 {
331 h->exp_cb (h->cb_cls);
333 return;
334 }
336 /* Restart the helper */
337 h->restart_task = GNUNET_SCHEDULER_add_delayed (
339 h->retry_back_off),
341 h);
342 return;
343 }
345 "Got %u bytes from helper `%s'\n",
346 (unsigned int) t,
347 h->binary_name);
349 h->fh_from_helper,
351 h);
352 if (GNUNET_SYSERR ==
354 {
356 _ ("Failed to parse inbound message from helper `%s'\n"),
357 h->binary_name);
358 if (NULL != h->exp_cb)
359 {
360 h->exp_cb (h->cb_cls);
362 return;
363 }
365 /* Restart the helper */
366 h->restart_task = GNUNET_SCHEDULER_add_delayed (
368 h->retry_back_off),
370 h);
371 return;
372 }
373}
374
375
381static void
383{
384 h->helper_in =
386 h->helper_out =
388 if ((h->helper_in == NULL) || (h->helper_out == NULL))
389 {
390 /* out of file descriptors? try again later... */
392 "out of file descriptors? try again later\n");
394 h->restart_task = GNUNET_SCHEDULER_add_delayed (
396 h->retry_back_off),
398 h);
399 return;
400 }
402 "Starting HELPER process `%s'\n",
403 h->binary_name);
404 h->fh_from_helper =
406 h->fh_to_helper =
408 h->helper_proc = GNUNET_OS_start_process_vap (h->with_control_pipe
412 h->helper_in,
413 h->helper_out,
414 NULL,
415 h->binary_name,
416 h->binary_argv);
417 if (NULL == h->helper_proc)
418 {
419 /* failed to start process? try again later... */
421 "failed to start process? try again later\n");
423 h->restart_task = GNUNET_SCHEDULER_add_delayed (
425 h->retry_back_off),
427 h);
428 return;
429 }
432 if (NULL != h->mst)
434 h->fh_from_helper,
436 h);
437}
438
439
445static void
446restart_task (void *cls)
447{
448 struct GNUNET_HELPER_Handle *h = cls;
449
450 h->restart_task = NULL;
451 h->retry_back_off++;
453 "Restarting helper with back-off %u\n",
454 h->retry_back_off);
455 start_helper (h);
456}
457
458
462 const char *binary_name,
463 char *const binary_argv[],
466 void *cb_cls)
467{
468 struct GNUNET_HELPER_Handle *h;
469 unsigned int c;
470
472 h->with_control_pipe = with_control_pipe;
473 /* Lookup in libexec path only if we are starting gnunet helpers */
474 if (NULL != strstr (binary_name, "gnunet"))
475 h->binary_name = GNUNET_OS_get_libexec_binary_path (pd,
477 else
478 h->binary_name = GNUNET_strdup (binary_name);
479 for (c = 0; NULL != binary_argv[c]; c++)
480 ;
481 h->binary_argv = GNUNET_malloc (sizeof(char *) * (c + 1));
482 for (c = 0; NULL != binary_argv[c]; c++)
483 h->binary_argv[c] = GNUNET_strdup (binary_argv[c]);
484 h->binary_argv[c] = NULL;
485 h->cb_cls = cb_cls;
486 if (NULL != cb)
487 h->mst = GNUNET_MST_create (cb, h->cb_cls);
488 h->exp_cb = exp_cb;
489 h->retry_back_off = 0;
490 start_helper (h);
491 return h;
492}
493
494
500void
502{
503 unsigned int c;
505
506 if (NULL != h->write_task)
507 {
508 GNUNET_SCHEDULER_cancel (h->write_task);
509 h->write_task = NULL;
510 }
511 GNUNET_assert (NULL == h->read_task);
512 GNUNET_assert (NULL == h->restart_task);
513 while (NULL != (sh = h->sh_head))
514 {
515 GNUNET_CONTAINER_DLL_remove (h->sh_head, h->sh_tail, sh);
516 if (NULL != sh->cont)
517 sh->cont (sh->cont_cls, GNUNET_SYSERR);
518 GNUNET_free (sh);
519 }
520 if (NULL != h->mst)
521 GNUNET_MST_destroy (h->mst);
522 GNUNET_free (h->binary_name);
523 for (c = 0; h->binary_argv[c] != NULL; c++)
524 GNUNET_free (h->binary_argv[c]);
525 GNUNET_free (h->binary_argv);
526 GNUNET_free (h);
527}
528
529
537void
539{
540 h->exp_cb = NULL;
541 stop_helper (h, soft_kill);
543}
544
545
551static void
552helper_write (void *cls)
553{
554 struct GNUNET_HELPER_Handle *h = cls;
556 const char *buf;
557 ssize_t t;
558
559 h->write_task = NULL;
560 if (NULL == (sh = h->sh_head))
561 {
562 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Helper write had no work!\n");
563 return; /* how did this happen? */
564 }
565 buf = (const char *) sh->msg;
566 t = GNUNET_DISK_file_write (h->fh_to_helper,
567 &buf[sh->wpos],
568 ntohs (sh->msg->size) - sh->wpos);
569 if (-1 == t)
570 {
571 /* On write-error, restart the helper */
573 _ ("Error writing to `%s': %s\n"),
574 h->binary_name,
575 strerror (errno));
576 if (NULL != h->exp_cb)
577 {
578 h->exp_cb (h->cb_cls);
580 return;
581 }
583 "Stopping and restarting helper task!\n");
585 /* Restart the helper */
586 h->restart_task = GNUNET_SCHEDULER_add_delayed (
588 h->retry_back_off),
590 h);
591 return;
592 }
594 "Transmitted %u bytes to %s\n",
595 (unsigned int) t,
596 h->binary_name);
597 sh->wpos += t;
598 if (sh->wpos == ntohs (sh->msg->size))
599 {
600 GNUNET_CONTAINER_DLL_remove (h->sh_head, h->sh_tail, sh);
601 if (NULL != sh->cont)
602 sh->cont (sh->cont_cls, GNUNET_YES);
603 GNUNET_free (sh);
604 }
605 if (NULL != h->sh_head)
606 h->write_task =
608 h->fh_to_helper,
610 h);
611}
612
613
616 const struct GNUNET_MessageHeader *msg,
617 bool can_drop,
619 void *cont_cls)
620{
622 uint16_t mlen;
623
624 if (NULL == h->fh_to_helper)
625 return NULL;
626 if (can_drop && (NULL != h->sh_head))
627 return NULL;
628 mlen = ntohs (msg->size);
629 sh = GNUNET_malloc (sizeof(struct GNUNET_HELPER_SendHandle) + mlen);
630 sh->msg = (const struct GNUNET_MessageHeader *) &sh[1];
631 GNUNET_memcpy (&sh[1], msg, mlen);
632 sh->h = h;
633 sh->cont = cont;
634 sh->cont_cls = cont_cls;
635 GNUNET_CONTAINER_DLL_insert_tail (h->sh_head, h->sh_tail, sh);
636 if (NULL == h->write_task)
637 h->write_task =
639 h->fh_to_helper,
641 h);
642
643 return sh;
644}
645
646
654void
656{
657 struct GNUNET_HELPER_Handle *h = sh->h;
658
659 sh->cont = NULL;
660 sh->cont_cls = NULL;
661 if (0 == sh->wpos)
662 {
663 GNUNET_CONTAINER_DLL_remove (h->sh_head, h->sh_tail, sh);
664 GNUNET_free (sh);
665 if (NULL == h->sh_head)
666 {
667 GNUNET_SCHEDULER_cancel (h->write_task);
668 h->write_task = NULL;
669 }
670 }
671}
672
673
674/* end of helper.c */
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:98
static int ret
Final status code.
Definition: gnunet-arm.c:93
static struct GNUNET_IDENTITY_Handle * sh
Handle to IDENTITY service.
static struct GNUNET_SCHEDULER_Task * t
Main task.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
const struct GNUNET_DISK_FileHandle * GNUNET_DISK_pipe_handle(const struct GNUNET_DISK_PipeHandle *p, enum GNUNET_DISK_PipeEnd n)
Get the handle to a particular pipe end.
Definition: disk.c:1621
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:697
struct GNUNET_DISK_PipeHandle * GNUNET_DISK_pipe(enum GNUNET_DISK_PipeFlags pf)
Creates an interprocess channel.
Definition: disk.c:1444
enum GNUNET_GenericReturnValue GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p)
Closes an interprocess channel.
Definition: disk.c:1591
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:660
enum GNUNET_GenericReturnValue GNUNET_DISK_pipe_close_end(struct GNUNET_DISK_PipeHandle *p, enum GNUNET_DISK_PipeEnd end)
Closes one half of an interprocess channel.
Definition: disk.c:1538
@ GNUNET_DISK_PF_BLOCKING_RW
Configure both pipe ends for blocking operations if set.
@ GNUNET_DISK_PIPE_END_WRITE
The writing-end of a pipe.
@ GNUNET_DISK_PIPE_END_READ
The reading-end of a pipe.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
void GNUNET_HELPER_send_cancel(struct GNUNET_HELPER_SendHandle *sh)
Cancel a GNUNET_HELPER_send operation.
Definition: helper.c:655
struct GNUNET_HELPER_SendHandle * GNUNET_HELPER_send(struct GNUNET_HELPER_Handle *h, const struct GNUNET_MessageHeader *msg, bool can_drop, GNUNET_HELPER_Continuation cont, void *cont_cls)
Send an message to the helper.
Definition: helper.c:615
enum GNUNET_GenericReturnValue GNUNET_HELPER_wait(struct GNUNET_HELPER_Handle *h)
Reap the helper process.
Definition: helper.c:206
struct GNUNET_HELPER_Handle * GNUNET_HELPER_start(const struct GNUNET_OS_ProjectData *pd, int with_control_pipe, const char *binary_name, char *const binary_argv[], GNUNET_MessageTokenizerCallback cb, GNUNET_HELPER_ExceptionCallback exp_cb, void *cb_cls)
Starts a helper and begins reading from it.
Definition: helper.c:460
void(* GNUNET_HELPER_ExceptionCallback)(void *cls)
Callback that will be called when the helper process dies.
enum GNUNET_GenericReturnValue GNUNET_HELPER_kill(struct GNUNET_HELPER_Handle *h, int soft_kill)
Sends termination signal to the helper process.
Definition: helper.c:166
void GNUNET_HELPER_stop(struct GNUNET_HELPER_Handle *h, int soft_kill)
Kills the helper, closes the pipe and frees the handle.
Definition: helper.c:538
void(* GNUNET_HELPER_Continuation)(void *cls, enum GNUNET_GenericReturnValue result)
Continuation function.
void GNUNET_HELPER_destroy(struct GNUNET_HELPER_Handle *h)
Free's the resources occupied by the helper handle.
Definition: helper.c:501
#define GNUNET_log(kind,...)
#define GNUNET_ALIGN
gcc-ism to force alignment; we use this to align char-arrays that may then be cast to 'struct's.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
GNUNET_GenericReturnValue
Named constants for return values.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_OS_process_destroy(struct GNUNET_OS_Process *proc)
Cleans up process structure contents (OS-dependent) and deallocates it.
Definition: os_priority.c:260
int GNUNET_OS_process_kill(struct GNUNET_OS_Process *proc, int sig)
Sends a signal to the process.
Definition: os_priority.c:210
enum GNUNET_GenericReturnValue GNUNET_OS_process_wait(struct GNUNET_OS_Process *proc)
Wait for a process to terminate.
Definition: os_priority.c:871
char * GNUNET_OS_get_libexec_binary_path(const struct GNUNET_OS_ProjectData *pd, const char *progname)
Given the name of a gnunet-helper, gnunet-service or gnunet-daemon binary, try to prefix it with the ...
struct GNUNET_OS_Process * GNUNET_OS_start_process_vap(enum GNUNET_OS_InheritStdioFlags std_inheritance, struct GNUNET_DISK_PipeHandle *pipe_stdin, struct GNUNET_DISK_PipeHandle *pipe_stdout, struct GNUNET_DISK_PipeHandle *pipe_stderr, const char *filename, char *const argv[])
Start a process.
Definition: os_priority.c:567
@ GNUNET_OS_INHERIT_STD_ERR
When this flag is set, the child process will inherit stderr of the parent.
Definition: gnunet_os_lib.h:95
@ GNUNET_OS_USE_PIPE_CONTROL
Should a pipe be used to send signals to the child?
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_write_file(struct GNUNET_TIME_Relative delay, const struct GNUNET_DISK_FileHandle *wfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1694
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_file(struct GNUNET_TIME_Relative delay, const struct GNUNET_DISK_FileHandle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1661
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:980
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1277
int(* GNUNET_MessageTokenizerCallback)(void *cls, const struct GNUNET_MessageHeader *message)
Functions with this signature are called whenever a complete message is received by the tokenizer.
enum GNUNET_GenericReturnValue GNUNET_MST_from_buffer(struct GNUNET_MessageStreamTokenizer *mst, const char *buf, size_t size, int purge, int one_shot)
Add incoming data to the receive buffer and call the callback for all complete messages.
Definition: mst.c:101
struct GNUNET_MessageStreamTokenizer * GNUNET_MST_create(GNUNET_MessageTokenizerCallback cb, void *cb_cls)
Create a message stream tokenizer.
Definition: mst.c:86
void GNUNET_MST_destroy(struct GNUNET_MessageStreamTokenizer *mst)
Destroys a tokenizer.
Definition: mst.c:404
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
#define GNUNET_TIME_UNIT_SECONDS
One second.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:486
static void helper_write(void *cls)
Write to the helper-process.
Definition: helper.c:552
static void start_helper(struct GNUNET_HELPER_Handle *h)
Start the helper process.
Definition: helper.c:382
static void restart_task(void *cls)
Restart the helper process.
Definition: helper.c:446
static void helper_read(void *cls)
Read from the helper-process.
Definition: helper.c:292
static void stop_helper(struct GNUNET_HELPER_Handle *h, int soft_kill)
Stop the helper process, we're closing down or had an error.
Definition: helper.c:262
#define _(String)
GNU gettext support macro.
Definition: platform.h:179
#define GNUNET_TERM_SIG
The termination signal.
Definition: platform.h:235
Handle used to access files (and pipes).
Handle used to manage a pipe.
Definition: disk.c:69
The handle to a helper process.
Definition: helper.c:77
GNUNET_HELPER_ExceptionCallback exp_cb
The exception callback.
Definition: helper.c:111
unsigned int retry_back_off
Count start attempts to increase linear back off.
Definition: helper.c:161
struct GNUNET_HELPER_SendHandle * sh_head
First message queued for transmission to helper.
Definition: helper.c:121
struct GNUNET_OS_Process * helper_proc
The process id of the helper.
Definition: helper.c:101
int with_control_pipe
Does the helper support the use of a control pipe for signalling?
Definition: helper.c:156
void * cb_cls
The closure for callbacks.
Definition: helper.c:116
struct GNUNET_HELPER_SendHandle * sh_tail
Last message queued for transmission to helper.
Definition: helper.c:126
struct GNUNET_DISK_PipeHandle * helper_in
PipeHandle to receive data from the helper.
Definition: helper.c:81
const struct GNUNET_DISK_FileHandle * fh_from_helper
FileHandle to receive data from the helper.
Definition: helper.c:91
const struct GNUNET_DISK_FileHandle * fh_to_helper
FileHandle to send data to the helper.
Definition: helper.c:96
struct GNUNET_SCHEDULER_Task * write_task
Task to read from the helper.
Definition: helper.c:146
struct GNUNET_DISK_PipeHandle * helper_out
PipeHandle to send data to the helper.
Definition: helper.c:86
struct GNUNET_SCHEDULER_Task * restart_task
Restart task.
Definition: helper.c:151
char ** binary_argv
NULL-terminated list of command-line arguments.
Definition: helper.c:136
struct GNUNET_MessageStreamTokenizer * mst
The Message-Tokenizer that tokenizes the messages coming from the helper.
Definition: helper.c:106
struct GNUNET_SCHEDULER_Task * read_task
Task to read from the helper.
Definition: helper.c:141
char * binary_name
Binary to run.
Definition: helper.c:131
Entry in the queue of messages we need to transmit to the helper.
Definition: helper.c:35
struct GNUNET_HELPER_SendHandle * prev
This is an entry in a DLL.
Definition: helper.c:44
struct GNUNET_HELPER_SendHandle * next
This is an entry in a DLL.
Definition: helper.c:39
struct GNUNET_HELPER_Handle * h
The handle to a helper process.
Definition: helper.c:54
GNUNET_HELPER_Continuation cont
Function to call upon completion.
Definition: helper.c:59
const struct GNUNET_MessageHeader * msg
Message to transmit (allocated at the end of this struct)
Definition: helper.c:49
void * cont_cls
Closure to 'cont'.
Definition: helper.c:64
unsigned int wpos
Current write position.
Definition: helper.c:69
Header for all communications.
Handle to a message stream tokenizer.
Definition: mst.c:45
Project-specific data used to help the OS subsystem find installation paths.
Entry in list of pending tasks.
Definition: scheduler.c:136
static void exp_cb(void *cls)
Callback called if there was an exception during execution of the helper.