GNUnet  0.20.0
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 
29 #include "gnunet_common.h"
30 #include "platform.h"
31 #include "gnunet_util_lib.h"
32 
37 {
42 
47 
51  const struct GNUNET_MessageHeader *msg;
52 
57 
62 
66  void *cont_cls;
67 
71  unsigned int wpos;
72 };
73 
74 
79 {
84 
89 
94 
99 
104 
109 
114 
118  void *cb_cls;
119 
124 
129 
133  char *binary_name;
134 
138  char **binary_argv;
139 
144 
149 
154 
159 
163  unsigned int retry_back_off;
164 };
165 
166 
168 GNUNET_HELPER_kill (struct GNUNET_HELPER_Handle *h, int soft_kill)
169 {
171  int ret;
172 
173  while (NULL != (sh = h->sh_head))
174  {
175  GNUNET_CONTAINER_DLL_remove (h->sh_head, h->sh_tail, sh);
176  if (NULL != sh->cont)
177  sh->cont (sh->cont_cls, GNUNET_NO);
178  GNUNET_free (sh);
179  }
180  if (NULL != h->restart_task)
181  {
182  GNUNET_SCHEDULER_cancel (h->restart_task);
183  h->restart_task = NULL;
184  }
185  if (NULL != h->read_task)
186  {
187  GNUNET_SCHEDULER_cancel (h->read_task);
188  h->read_task = NULL;
189  }
190  if (NULL == h->helper_proc)
191  return GNUNET_SYSERR;
192  if (GNUNET_YES == soft_kill)
193  {
194  /* soft-kill only possible with pipes */
195  GNUNET_assert (NULL != h->helper_in);
196  ret = GNUNET_DISK_pipe_close (h->helper_in);
197  h->helper_in = NULL;
198  h->fh_to_helper = NULL;
199  return ret;
200  }
201  if (0 != GNUNET_OS_process_kill (h->helper_proc, GNUNET_TERM_SIG))
202  return GNUNET_SYSERR;
203  return GNUNET_OK;
204 }
205 
206 
209 {
211  int ret;
212 
213  ret = GNUNET_SYSERR;
214  if (NULL != h->helper_proc)
215  {
216  ret = GNUNET_OS_process_wait (h->helper_proc);
217  GNUNET_OS_process_destroy (h->helper_proc);
218  h->helper_proc = NULL;
219  }
220  if (NULL != h->read_task)
221  {
222  GNUNET_SCHEDULER_cancel (h->read_task);
223  h->read_task = NULL;
224  }
225  if (NULL != h->write_task)
226  {
227  GNUNET_SCHEDULER_cancel (h->write_task);
228  h->write_task = NULL;
229  }
230  if (NULL != h->helper_in)
231  {
232  GNUNET_DISK_pipe_close (h->helper_in);
233  h->helper_in = NULL;
234  h->fh_to_helper = NULL;
235  }
236  if (NULL != h->helper_out)
237  {
238  GNUNET_DISK_pipe_close (h->helper_out);
239  h->helper_out = NULL;
240  h->fh_from_helper = NULL;
241  }
242  while (NULL != (sh = h->sh_head))
243  {
244  GNUNET_CONTAINER_DLL_remove (h->sh_head, h->sh_tail, sh);
245  if (NULL != sh->cont)
246  sh->cont (sh->cont_cls, GNUNET_NO);
247  GNUNET_free (sh);
248  }
249  /* purge MST buffer */
250  if (NULL != h->mst)
251  (void) GNUNET_MST_from_buffer (h->mst, NULL, 0, GNUNET_YES, GNUNET_NO);
252  return ret;
253 }
254 
255 
263 static void
264 stop_helper (struct GNUNET_HELPER_Handle *h, int soft_kill)
265 {
266  if (NULL != h->restart_task)
267  {
268  GNUNET_SCHEDULER_cancel (h->restart_task);
269  h->restart_task = NULL;
270  }
271  else
272  {
273  GNUNET_break (GNUNET_OK == GNUNET_HELPER_kill (h, soft_kill));
275  }
276 }
277 
278 
284 static void
285 restart_task (void *cls);
286 
287 
293 static void
294 helper_read (void *cls)
295 {
296  struct GNUNET_HELPER_Handle *h = cls;
298  ssize_t t;
299 
300  h->read_task = NULL;
301  t = GNUNET_DISK_file_read (h->fh_from_helper, &buf, sizeof(buf));
302  if (t < 0)
303  {
304  /* On read-error, restart the helper */
306  _ ("Error reading from `%s': %s\n"),
307  h->binary_name,
308  strerror (errno));
309  if (NULL != h->exp_cb)
310  {
311  h->exp_cb (h->cb_cls);
313  return;
314  }
316  /* Restart the helper */
317  h->restart_task = GNUNET_SCHEDULER_add_delayed (
319  h->retry_back_off),
320  &restart_task,
321  h);
322  return;
323  }
324  if (0 == t)
325  {
326  /* this happens if the helper is shut down via a
327  signal, so it is not a "hard" error */
329  "Got 0 bytes from helper `%s' (EOF)\n",
330  h->binary_name);
331  if (NULL != h->exp_cb)
332  {
333  h->exp_cb (h->cb_cls);
335  return;
336  }
338  /* Restart the helper */
339  h->restart_task = GNUNET_SCHEDULER_add_delayed (
341  h->retry_back_off),
342  &restart_task,
343  h);
344  return;
345  }
347  "Got %u bytes from helper `%s'\n",
348  (unsigned int) t,
349  h->binary_name);
351  h->fh_from_helper,
352  &helper_read,
353  h);
354  if (GNUNET_SYSERR ==
356  {
358  _ ("Failed to parse inbound message from helper `%s'\n"),
359  h->binary_name);
360  if (NULL != h->exp_cb)
361  {
362  h->exp_cb (h->cb_cls);
364  return;
365  }
367  /* Restart the helper */
368  h->restart_task = GNUNET_SCHEDULER_add_delayed (
370  h->retry_back_off),
371  &restart_task,
372  h);
373  return;
374  }
375 }
376 
377 
383 static void
385 {
386  h->helper_in =
388  h->helper_out =
390  if ((h->helper_in == NULL) || (h->helper_out == NULL))
391  {
392  /* out of file descriptors? try again later... */
394  "out of file descriptors? try again later\n");
396  h->restart_task = GNUNET_SCHEDULER_add_delayed (
398  h->retry_back_off),
399  &restart_task,
400  h);
401  return;
402  }
404  "Starting HELPER process `%s'\n",
405  h->binary_name);
406  h->fh_from_helper =
408  h->fh_to_helper =
410  h->helper_proc = GNUNET_OS_start_process_vap (h->with_control_pipe
414  h->helper_in,
415  h->helper_out,
416  NULL,
417  h->binary_name,
418  h->binary_argv);
419  if (NULL == h->helper_proc)
420  {
421  /* failed to start process? try again later... */
423  "failed to start process? try again later\n");
425  h->restart_task = GNUNET_SCHEDULER_add_delayed (
427  h->retry_back_off),
428  &restart_task,
429  h);
430  return;
431  }
434  if (NULL != h->mst)
436  h->fh_from_helper,
437  &helper_read,
438  h);
439 }
440 
441 
447 static void
448 restart_task (void *cls)
449 {
450  struct GNUNET_HELPER_Handle *h = cls;
451 
452  h->restart_task = NULL;
453  h->retry_back_off++;
455  "Restarting helper with back-off %u\n",
456  h->retry_back_off);
457  start_helper (h);
458 }
459 
460 
461 struct GNUNET_HELPER_Handle *
463  const char *binary_name,
464  char *const binary_argv[],
467  void *cb_cls)
468 {
469  struct GNUNET_HELPER_Handle *h;
470  unsigned int c;
471 
472  h = GNUNET_new (struct GNUNET_HELPER_Handle);
473  h->with_control_pipe = with_control_pipe;
474  /* Lookup in libexec path only if we are starting gnunet helpers */
475  if (NULL != strstr (binary_name, "gnunet"))
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 
500 void
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 
537 void
538 GNUNET_HELPER_stop (struct GNUNET_HELPER_Handle *h, int soft_kill)
539 {
540  h->exp_cb = NULL;
541  stop_helper (h, soft_kill);
543 }
544 
545 
551 static void
552 helper_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),
589  &restart_task,
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,
609  &helper_write,
610  h);
611 }
612 
613 
616  const struct GNUNET_MessageHeader *msg,
617  int can_drop,
619  void *cont_cls)
620 {
622  uint16_t mlen;
623 
624  if (NULL == h->fh_to_helper)
625  return NULL;
626  if ((GNUNET_YES == 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,
640  &helper_write,
641  h);
642 
643  return sh;
644 }
645 
646 
654 void
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 int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static struct SolverHandle * sh
static char buf[2048]
static struct GNUNET_SCHEDULER_Task * t
Main task.
commonly used definitions; globals in this file are exempt from the rule that the module name ("commo...
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
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:686
enum GNUNET_GenericReturnValue GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p)
Closes an interprocess channel.
Definition: disk.c:1587
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:622
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:1617
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:1534
struct GNUNET_DISK_PipeHandle * GNUNET_DISK_pipe(enum GNUNET_DISK_PipeFlags pf)
Creates an interprocess channel.
Definition: disk.c:1444
@ 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, int can_drop, GNUNET_HELPER_Continuation cont, void *cont_cls)
Send an message to the helper.
Definition: helper.c:615
struct GNUNET_HELPER_Handle * GNUNET_HELPER_start(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:462
enum GNUNET_GenericReturnValue GNUNET_HELPER_wait(struct GNUNET_HELPER_Handle *h)
Reap the helper process.
Definition: helper.c:208
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:168
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.
@ 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.
char * GNUNET_OS_get_libexec_binary_path(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
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
@ 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_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:1656
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:1689
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
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:1272
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
void GNUNET_MST_destroy(struct GNUNET_MessageStreamTokenizer *mst)
Destroys a tokenizer.
Definition: mst.c:404
struct GNUNET_MessageStreamTokenizer * GNUNET_MST_create(GNUNET_MessageTokenizerCallback cb, void *cb_cls)
Create a message stream tokenizer.
Definition: mst.c:86
#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:484
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:384
static void restart_task(void *cls)
Restart the helper process.
Definition: helper.c:448
static void helper_read(void *cls)
Read from the helper-process.
Definition: helper.c:294
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:264
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
#define GNUNET_TERM_SIG
The termination signal.
Definition: platform.h:234
Handle used to access files (and pipes).
Handle used to manage a pipe.
Definition: disk.c:68
The handle to a helper process.
Definition: helper.c:79
GNUNET_HELPER_ExceptionCallback exp_cb
The exception callback.
Definition: helper.c:113
unsigned int retry_back_off
Count start attempts to increase linear back off.
Definition: helper.c:163
struct GNUNET_HELPER_SendHandle * sh_head
First message queued for transmission to helper.
Definition: helper.c:123
struct GNUNET_OS_Process * helper_proc
The process id of the helper.
Definition: helper.c:103
int with_control_pipe
Does the helper support the use of a control pipe for signalling?
Definition: helper.c:158
void * cb_cls
The closure for callbacks.
Definition: helper.c:118
struct GNUNET_HELPER_SendHandle * sh_tail
Last message queued for transmission to helper.
Definition: helper.c:128
struct GNUNET_DISK_PipeHandle * helper_in
PipeHandle to receive data from the helper.
Definition: helper.c:83
const struct GNUNET_DISK_FileHandle * fh_from_helper
FileHandle to receive data from the helper.
Definition: helper.c:93
const struct GNUNET_DISK_FileHandle * fh_to_helper
FileHandle to send data to the helper.
Definition: helper.c:98
struct GNUNET_SCHEDULER_Task * write_task
Task to read from the helper.
Definition: helper.c:148
struct GNUNET_DISK_PipeHandle * helper_out
PipeHandle to send data to the helper.
Definition: helper.c:88
struct GNUNET_SCHEDULER_Task * restart_task
Restart task.
Definition: helper.c:153
char ** binary_argv
NULL-terminated list of command-line arguments.
Definition: helper.c:138
struct GNUNET_MessageStreamTokenizer * mst
The Message-Tokenizer that tokenizes the messages coming from the helper.
Definition: helper.c:108
struct GNUNET_SCHEDULER_Task * read_task
Task to read from the helper.
Definition: helper.c:143
char * binary_name
Binary to run.
Definition: helper.c:133
Entry in the queue of messages we need to transmit to the helper.
Definition: helper.c:37
struct GNUNET_HELPER_SendHandle * prev
This is an entry in a DLL.
Definition: helper.c:46
struct GNUNET_HELPER_SendHandle * next
This is an entry in a DLL.
Definition: helper.c:41
struct GNUNET_HELPER_Handle * h
The handle to a helper process.
Definition: helper.c:56
GNUNET_HELPER_Continuation cont
Function to call upon completion.
Definition: helper.c:61
const struct GNUNET_MessageHeader * msg
Message to transmit (allocated at the end of this struct)
Definition: helper.c:51
void * cont_cls
Closure to 'cont'.
Definition: helper.c:66
unsigned int wpos
Current write position.
Definition: helper.c:71
Header for all communications.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Handle to a message stream tokenizer.
Definition: mst.c:45
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.