GNUnet  0.11.x
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 #include "gnunet_mst_lib.h"
31 
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 
176 int
177 GNUNET_HELPER_kill (struct GNUNET_HELPER_Handle *h, int soft_kill)
178 {
180  int ret;
181 
182  while (NULL != (sh = h->sh_head))
183  {
185  if (NULL != sh->cont)
186  sh->cont (sh->cont_cls, GNUNET_NO);
187  GNUNET_free (sh);
188  }
189  if (NULL != h->restart_task)
190  {
192  h->restart_task = NULL;
193  }
194  if (NULL != h->read_task)
195  {
197  h->read_task = NULL;
198  }
199  if (NULL == h->helper_proc)
200  return GNUNET_SYSERR;
201  if (GNUNET_YES == soft_kill)
202  {
203  /* soft-kill only possible with pipes */
204  GNUNET_assert (NULL != h->helper_in);
206  h->helper_in = NULL;
207  h->fh_to_helper = NULL;
208  return ret;
209  }
211  return GNUNET_SYSERR;
212  return GNUNET_OK;
213 }
214 
215 
224 int
226 {
228  int ret;
229 
230  ret = GNUNET_SYSERR;
231  if (NULL != h->helper_proc)
232  {
235  h->helper_proc = NULL;
236  }
237  if (NULL != h->read_task)
238  {
240  h->read_task = NULL;
241  }
242  if (NULL != h->write_task)
243  {
245  h->write_task = NULL;
246  }
247  if (NULL != h->helper_in)
248  {
250  h->helper_in = NULL;
251  h->fh_to_helper = NULL;
252  }
253  if (NULL != h->helper_out)
254  {
256  h->helper_out = NULL;
257  h->fh_from_helper = NULL;
258  }
259  while (NULL != (sh = h->sh_head))
260  {
262  if (NULL != sh->cont)
263  sh->cont (sh->cont_cls, GNUNET_NO);
264  GNUNET_free (sh);
265  }
266  /* purge MST buffer */
267  if (NULL != h->mst)
268  (void) GNUNET_MST_from_buffer (h->mst, NULL, 0, GNUNET_YES, GNUNET_NO);
269  return ret;
270 }
271 
272 
280 static void
281 stop_helper (struct GNUNET_HELPER_Handle *h, int soft_kill)
282 {
283  if (NULL != h->restart_task)
284  {
286  h->restart_task = NULL;
287  }
288  else
289  {
290  GNUNET_break (GNUNET_OK == GNUNET_HELPER_kill (h, soft_kill));
292  }
293 }
294 
295 
301 static void
302 restart_task (void *cls);
303 
304 
310 static void
311 helper_read (void *cls)
312 {
313  struct GNUNET_HELPER_Handle *h = cls;
315  ssize_t t;
316 
317  h->read_task = NULL;
318  t = GNUNET_DISK_file_read (h->fh_from_helper, &buf, sizeof(buf));
319  if (t < 0)
320  {
321  /* On read-error, restart the helper */
323  _ ("Error reading from `%s': %s\n"),
324  h->binary_name,
325  strerror (errno));
326  if (NULL != h->exp_cb)
327  {
328  h->exp_cb (h->cb_cls);
330  return;
331  }
332  stop_helper (h, GNUNET_NO);
333  /* Restart the helper */
336  h->retry_back_off),
337  &restart_task,
338  h);
339  return;
340  }
341  if (0 == t)
342  {
343  /* this happens if the helper is shut down via a
344  signal, so it is not a "hard" error */
346  "Got 0 bytes from helper `%s' (EOF)\n",
347  h->binary_name);
348  if (NULL != h->exp_cb)
349  {
350  h->exp_cb (h->cb_cls);
352  return;
353  }
354  stop_helper (h, GNUNET_NO);
355  /* Restart the helper */
358  h->retry_back_off),
359  &restart_task,
360  h);
361  return;
362  }
364  "Got %u bytes from helper `%s'\n",
365  (unsigned int) t,
366  h->binary_name);
368  h->fh_from_helper,
369  &helper_read,
370  h);
371  if (GNUNET_SYSERR ==
373  {
375  _ ("Failed to parse inbound message from helper `%s'\n"),
376  h->binary_name);
377  if (NULL != h->exp_cb)
378  {
379  h->exp_cb (h->cb_cls);
381  return;
382  }
383  stop_helper (h, GNUNET_NO);
384  /* Restart the helper */
387  h->retry_back_off),
388  &restart_task,
389  h);
390  return;
391  }
392 }
393 
394 
400 static void
402 {
403  h->helper_in =
405  h->helper_out =
407  if ((h->helper_in == NULL) || (h->helper_out == NULL))
408  {
409  /* out of file descriptors? try again later... */
410  stop_helper (h, GNUNET_NO);
413  h->retry_back_off),
414  &restart_task,
415  h);
416  return;
417  }
419  "Starting HELPER process `%s'\n",
420  h->binary_name);
421  h->fh_from_helper =
423  h->fh_to_helper =
427  h->helper_in,
428  h->helper_out,
429  NULL,
430  h->binary_name,
431  h->binary_argv);
432  if (NULL == h->helper_proc)
433  {
434  /* failed to start process? try again later... */
435  stop_helper (h, GNUNET_NO);
438  h->retry_back_off),
439  &restart_task,
440  h);
441  return;
442  }
445  if (NULL != h->mst)
447  h->fh_from_helper,
448  &helper_read,
449  h);
450 }
451 
452 
458 static void
459 restart_task (void *cls)
460 {
461  struct GNUNET_HELPER_Handle *h = cls;
462 
463  h->restart_task = NULL;
464  h->retry_back_off++;
466  "Restarting helper with back-off %u\n",
467  h->retry_back_off);
468  start_helper (h);
469 }
470 
471 
488 struct GNUNET_HELPER_Handle *
490  const char *binary_name,
491  char *const binary_argv[],
494  void *cb_cls)
495 {
496  struct GNUNET_HELPER_Handle *h;
497  unsigned int c;
498 
499  h = GNUNET_new (struct GNUNET_HELPER_Handle);
501  /* Lookup in libexec path only if we are starting gnunet helpers */
502  if (NULL != strstr (binary_name, "gnunet"))
504  else
505  h->binary_name = GNUNET_strdup (binary_name);
506  for (c = 0; NULL != binary_argv[c]; c++)
507  ;
508  h->binary_argv = GNUNET_malloc (sizeof(char *) * (c + 1));
509  for (c = 0; NULL != binary_argv[c]; c++)
510  h->binary_argv[c] = GNUNET_strdup (binary_argv[c]);
511  h->binary_argv[c] = NULL;
512  h->cb_cls = cb_cls;
513  if (NULL != cb)
514  h->mst = GNUNET_MST_create (cb, h->cb_cls);
515  h->exp_cb = exp_cb;
516  h->retry_back_off = 0;
517  start_helper (h);
518  return h;
519 }
520 
521 
527 void
529 {
530  unsigned int c;
532 
533  if (NULL != h->write_task)
534  {
536  h->write_task = NULL;
537  }
538  GNUNET_assert (NULL == h->read_task);
539  GNUNET_assert (NULL == h->restart_task);
540  while (NULL != (sh = h->sh_head))
541  {
543  if (NULL != sh->cont)
544  sh->cont (sh->cont_cls, GNUNET_SYSERR);
545  GNUNET_free (sh);
546  }
547  if (NULL != h->mst)
548  GNUNET_MST_destroy (h->mst);
550  for (c = 0; h->binary_argv[c] != NULL; c++)
551  GNUNET_free (h->binary_argv[c]);
553  GNUNET_free (h);
554 }
555 
556 
564 void
565 GNUNET_HELPER_stop (struct GNUNET_HELPER_Handle *h, int soft_kill)
566 {
567  h->exp_cb = NULL;
568  stop_helper (h, soft_kill);
570 }
571 
572 
578 static void
579 helper_write (void *cls)
580 {
581  struct GNUNET_HELPER_Handle *h = cls;
583  const char *buf;
584  ssize_t t;
585 
586  h->write_task = NULL;
587  if (NULL == (sh = h->sh_head))
588  {
589  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Helper write had no work!\n");
590  return; /* how did this happen? */
591  }
592  buf = (const char *) sh->msg;
594  &buf[sh->wpos],
595  ntohs (sh->msg->size) - sh->wpos);
596  if (-1 == t)
597  {
598  /* On write-error, restart the helper */
600  _ ("Error writing to `%s': %s\n"),
601  h->binary_name,
602  strerror (errno));
603  if (NULL != h->exp_cb)
604  {
605  h->exp_cb (h->cb_cls);
607  return;
608  }
610  "Stopping and restarting helper task!\n");
611  stop_helper (h, GNUNET_NO);
612  /* Restart the helper */
615  h->retry_back_off),
616  &restart_task,
617  h);
618  return;
619  }
621  "Transmitted %u bytes to %s\n",
622  (unsigned int) t,
623  h->binary_name);
624  sh->wpos += t;
625  if (sh->wpos == ntohs (sh->msg->size))
626  {
628  if (NULL != sh->cont)
629  sh->cont (sh->cont_cls, GNUNET_YES);
630  GNUNET_free (sh);
631  }
632  if (NULL != h->sh_head)
633  h->write_task =
635  h->fh_to_helper,
636  &helper_write,
637  h);
638 }
639 
640 
656  const struct GNUNET_MessageHeader *msg,
657  int can_drop,
659  void *cont_cls)
660 {
662  uint16_t mlen;
663 
664  if (NULL == h->fh_to_helper)
665  return NULL;
666  if ((GNUNET_YES == can_drop) && (NULL != h->sh_head))
667  return NULL;
668  mlen = ntohs (msg->size);
669  sh = GNUNET_malloc (sizeof(struct GNUNET_HELPER_SendHandle) + mlen);
670  sh->msg = (const struct GNUNET_MessageHeader *) &sh[1];
671  GNUNET_memcpy (&sh[1], msg, mlen);
672  sh->h = h;
673  sh->cont = cont;
674  sh->cont_cls = cont_cls;
676  if (NULL == h->write_task)
677  h->write_task =
679  h->fh_to_helper,
680  &helper_write,
681  h);
682 
683  return sh;
684 }
685 
686 
694 void
696 {
697  struct GNUNET_HELPER_Handle *h = sh->h;
698 
699  sh->cont = NULL;
700  sh->cont_cls = NULL;
701  if (0 == sh->wpos)
702  {
704  GNUNET_free (sh);
705  if (NULL == h->sh_head)
706  {
708  h->write_task = NULL;
709  }
710  }
711 }
712 
713 
714 /* end of helper.c */
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
int GNUNET_HELPER_kill(struct GNUNET_HELPER_Handle *h, int soft_kill)
Sends termination signal to the helper process.
Definition: helper.c:177
const struct GNUNET_DISK_FileHandle * fh_to_helper
FileHandle to send data to the helper.
Definition: helper.c:98
When this flag is set, the child process will inherit stderr of the parent.
Definition: gnunet_os_lib.h:91
static void restart_task(void *cls)
Restart the helper process.
Definition: helper.c:459
void GNUNET_OS_process_destroy(struct GNUNET_OS_Process *proc)
Cleans up process structure contents (OS-dependent) and deallocates it.
Definition: os_priority.c:287
struct GNUNET_SCHEDULER_Task * restart_task
Restart task.
Definition: helper.c:153
void(* GNUNET_HELPER_ExceptionCallback)(void *cls)
Callback that will be called when the helper process dies.
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:732
The handle to a helper process.
Definition: helper.c:78
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:489
unsigned int wpos
Current write position.
Definition: helper.c:71
struct GNUNET_DISK_PipeHandle * helper_out
PipeHandle to send data to the helper.
Definition: helper.c:88
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_HELPER_SendHandle * prev
This is an entry in a DLL.
Definition: helper.c:46
void(* GNUNET_HELPER_Continuation)(void *cls, int result)
Continuation function.
#define GNUNET_TIME_UNIT_SECONDS
One second.
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:565
Entry in the queue of messages we need to transmit to the helper.
Definition: helper.c:36
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
#define GNUNET_NO
Definition: gnunet_common.h:78
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:1669
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:1636
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_HELPER_SendHandle * sh_tail
Last message queued for transmission to helper.
Definition: helper.c:128
static struct GNUNET_SCHEDULER_Task * t
Main task.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
int with_control_pipe
Does the helper support the use of a control pipe for signalling?
Definition: helper.c:158
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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:1753
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
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...
struct GNUNET_SCHEDULER_Task * read_task
Task to read from the helper.
Definition: helper.c:143
struct GNUNET_SCHEDULER_Task * write_task
Task to read from the helper.
Definition: helper.c:148
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:1253
void GNUNET_HELPER_send_cancel(struct GNUNET_HELPER_SendHandle *sh)
Cancel a GNUNET_HELPER_send operation.
Definition: helper.c:695
struct GNUNET_HELPER_Handle * h
The handle to a helper process.
Definition: helper.c:56
void GNUNET_MST_destroy(struct GNUNET_MessageStreamTokenizer *mst)
Destroys a tokenizer.
Definition: mst.c:411
unsigned int retry_back_off
Count start attempts to increase linear back off.
Definition: helper.c:163
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:820
static struct SolverHandle * sh
Handle to a message stream tokenizer.
Definition: mst.c:43
struct GNUNET_DISK_PipeHandle * helper_in
PipeHandle to receive data from the helper.
Definition: helper.c:83
struct GNUNET_OS_Process * GNUNET_OS_start_process_vap(int pipe_control, 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:607
static char buf[2048]
struct GNUNET_MessageStreamTokenizer * GNUNET_MST_create(GNUNET_MessageTokenizerCallback cb, void *cb_cls)
Create a message stream tokenizer.
Definition: mst.c:85
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:442
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
The writing-end of a pipe.
The reading-end of a pipe.
int 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:114
struct GNUNET_HELPER_SendHandle * sh_head
First message queued for transmission to helper.
Definition: helper.c:123
struct GNUNET_DISK_PipeHandle * GNUNET_DISK_pipe(int blocking_read, int blocking_write, int inherit_read, int inherit_write)
Creates an interprocess channel.
Definition: disk.c:1526
char * binary_name
Binary to run.
Definition: helper.c:133
GNUNET_HELPER_ExceptionCallback exp_cb
The exception callback.
Definition: helper.c:113
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
char ** binary_argv
NULL-terminated list of command-line arguments.
Definition: helper.c:138
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
void * cb_cls
The closure for callbacks.
Definition: helper.c:118
struct GNUNET_MessageStreamTokenizer * mst
The Message-Tokenizer that tokenizes the messages comming from the helper.
Definition: helper.c:108
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
static void start_helper(struct GNUNET_HELPER_Handle *h)
Start the helper process.
Definition: helper.c:401
static void stop_helper(struct GNUNET_HELPER_Handle *h, int soft_kill)
Stop the helper process, we&#39;re closing down or had an error.
Definition: helper.c:281
int GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p)
Closes an interprocess channel.
Definition: disk.c:1715
int 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:1643
#define GNUNET_ALIGN
gcc-ism to force alignment; we use this to align char-arrays that may then be cast to &#39;struct&#39;s...
void GNUNET_HELPER_destroy(struct GNUNET_HELPER_Handle *h)
Free&#39;s the resources occupied by the helper handle.
Definition: helper.c:528
int GNUNET_OS_process_wait(struct GNUNET_OS_Process *proc)
Wait for a process to terminate.
Definition: os_priority.c:1000
struct GNUNET_OS_Process * helper_proc
The process id of the helper.
Definition: helper.c:103
struct GNUNET_HELPER_SendHandle * next
This is an entry in a DLL.
Definition: helper.c:41
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:655
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
int GNUNET_HELPER_wait(struct GNUNET_HELPER_Handle *h)
Reap the helper process.
Definition: helper.c:225
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 ...
Header for all communications.
#define GNUNET_YES
Definition: gnunet_common.h:77
static void helper_read(void *cls)
Read from the helper-process.
Definition: helper.c:311
#define GNUNET_TERM_SIG
The termination signal.
Definition: platform.h:242
Handle used to access files (and pipes).
Handle used to manage a pipe.
Definition: disk.c:68
const struct GNUNET_DISK_FileHandle * fh_from_helper
FileHandle to receive data from the helper.
Definition: helper.c:93
#define GNUNET_malloc(size)
Wrapper around malloc.
const struct GNUNET_MessageHeader * msg
Message to transmit (allocated at the end of this struct)
Definition: helper.c:51
GNUNET_HELPER_Continuation cont
Function to call upon completion.
Definition: helper.c:61
static void helper_write(void *cls)
Write to the helper-process.
Definition: helper.c:579
void * cont_cls
Closure to &#39;cont&#39;.
Definition: helper.c:66
#define GNUNET_free(ptr)
Wrapper around free.
int GNUNET_OS_process_kill(struct GNUNET_OS_Process *proc, int sig)
Sends a signal to the process.
Definition: os_priority.c:225
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966