GNUnet debian-0.24.3
os_priority.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet
3 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2011 GNUnet e.V.
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 "disk.h"
31#include <unistr.h>
32
33#define LOG(kind, ...) GNUNET_log_from (kind, "util-os-priority", __VA_ARGS__)
34
35#define LOG_STRERROR(kind, syscall) \
36 GNUNET_log_from_strerror (kind, "util-os-priority", syscall)
37
38#define LOG_STRERROR_FILE(kind, syscall, filename) \
39 GNUNET_log_from_strerror_file (kind, "util-os-priority", syscall, \
40 filename)
41
42#define GNUNET_OS_CONTROL_PIPE "GNUNET_OS_CONTROL_PIPE"
43
44
46{
50 pid_t pid;
51
57};
58
59
64
69
74
75
81static void
82shutdown_pch (void *cls)
83{
84 struct GNUNET_DISK_FileHandle *control_pipe = cls;
85
87 pch = NULL;
88 GNUNET_DISK_file_close (control_pipe);
89 control_pipe = NULL;
90}
91
92
98static void
100{
101 struct GNUNET_DISK_FileHandle *control_pipe = cls;
102 char sig;
103 char *pipe_fd;
104 ssize_t ret;
105
106 pch = NULL;
107 ret = GNUNET_DISK_file_read (control_pipe, &sig, sizeof(sig));
108 if (sizeof(sig) != ret)
109 {
110 if (-1 == ret)
111 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "GNUNET_DISK_file_read");
112 LOG (GNUNET_ERROR_TYPE_DEBUG, "Closing control pipe\n");
113 GNUNET_DISK_file_close (control_pipe);
114 control_pipe = NULL;
116 spch = NULL;
117 return;
118 }
119 pipe_fd = getenv (GNUNET_OS_CONTROL_PIPE);
120 GNUNET_assert ((NULL == pipe_fd) || (strlen (pipe_fd) <= 0));
122 "Got control code %d from parent via pipe %s\n",
123 sig,
124 pipe_fd);
126 control_pipe,
128 control_pipe);
129 GNUNET_SIGNAL_raise ((int) sig);
130}
131
132
133void
135{
136 const char *env_buf;
137 char *env_buf_end;
138 struct GNUNET_DISK_FileHandle *control_pipe;
139 uint64_t pipe_fd;
140
141 (void) cls;
142 if (NULL != pch)
143 {
144 /* already done, we've been called twice... */
145 GNUNET_break (0);
146 return;
147 }
148 env_buf = getenv (GNUNET_OS_CONTROL_PIPE);
149 if ((NULL == env_buf) || (strlen (env_buf) <= 0))
150 {
152 "Not installing a handler because $%s is empty\n",
154 setenv (GNUNET_OS_CONTROL_PIPE, "", 1);
155 return;
156 }
157 errno = 0;
158 pipe_fd = strtoull (env_buf, &env_buf_end, 16);
159 if ((0 != errno) || (env_buf == env_buf_end))
160 {
161 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "strtoull", env_buf);
162 setenv (GNUNET_OS_CONTROL_PIPE, "", 1);
163 return;
164 }
165 if (pipe_fd >= FD_SETSIZE)
166 {
168 "GNUNET_OS_CONTROL_PIPE `%s' contains garbage?\n",
169 env_buf);
170 setenv (GNUNET_OS_CONTROL_PIPE, "", 1);
171 return;
172 }
173
174 control_pipe = GNUNET_DISK_get_handle_from_int_fd ((int) pipe_fd);
175
176 if (NULL == control_pipe)
177 {
179 setenv (GNUNET_OS_CONTROL_PIPE, "", 1);
180 return;
181 }
183 "Adding parent control handler pipe `%s' to the scheduler\n",
184 env_buf);
186 control_pipe,
188 control_pipe);
190 setenv (GNUNET_OS_CONTROL_PIPE, "", 1);
191}
192
193
202struct GNUNET_OS_Process *
204{
206 return &current_process;
207}
208
209
210int
212 int sig)
213{
214 int ret;
215 char csig;
216
217 csig = (char) sig;
218 if (NULL != proc->control_pipe)
219 {
221 "Sending signal %d to pid: %u via pipe\n",
222 sig,
223 proc->pid);
224 ret = GNUNET_DISK_file_write (proc->control_pipe, &csig, sizeof(csig));
225 if (sizeof(csig) == ret)
226 return 0;
227 }
228 /* pipe failed or non-existent, try other methods */
229 switch (sig)
230 {
231 case SIGHUP:
232 case SIGINT:
233 case SIGKILL:
234 case SIGTERM:
235#if (SIGTERM != GNUNET_TERM_SIG)
236 case GNUNET_TERM_SIG:
237#endif
239 "Sending signal %d to pid: %u via system call\n",
240 sig,
241 proc->pid);
242 return kill (proc->pid, sig);
243 default:
245 "Sending signal %d to pid: %u via system call\n",
246 sig,
247 proc->pid);
248 return kill (proc->pid, sig);
249 }
250}
251
252
253pid_t
255{
256 return proc->pid;
257}
258
259
260void
262{
263 if (NULL != proc->control_pipe)
265
266 GNUNET_free (proc);
267}
268
269
277static void
278open_dev_null (int target_fd,
279 int flags)
280{
281 int fd;
282
283 fd = open ("/dev/null", flags);
284 if (-1 == fd)
285 {
287 return;
288 }
289 if (fd == target_fd)
290 return;
291 if (-1 == dup2 (fd, target_fd))
292 {
294 GNUNET_break (0 == close (fd));
295 return;
296 }
297 GNUNET_break (0 == close (fd));
298}
299
300
317static struct GNUNET_OS_Process *
319 struct GNUNET_DISK_PipeHandle *pipe_stdin,
320 struct GNUNET_DISK_PipeHandle *pipe_stdout,
321 struct GNUNET_DISK_PipeHandle *pipe_stderr,
322 const int *lsocks,
323 const char *filename,
324 char *const argv[])
325{
326 pid_t ret;
327 char fds[16];
328 struct GNUNET_OS_Process *gnunet_proc;
329 struct GNUNET_DISK_FileHandle *childpipe_read;
330 struct GNUNET_DISK_FileHandle *childpipe_write;
331 int childpipe_read_fd;
332 int i;
333 int j;
334 int k;
335 int tgt;
336 int flags;
337 int *lscp;
338 unsigned int ls;
339 int fd_stdout_write;
340 int fd_stdout_read;
341 int fd_stderr_write;
342 int fd_stderr_read;
343 int fd_stdin_read;
344 int fd_stdin_write;
345
346 if (GNUNET_SYSERR ==
348 return NULL; /* not executable */
349 if (0 != (std_inheritance & GNUNET_OS_USE_PIPE_CONTROL))
350 {
351 struct GNUNET_DISK_PipeHandle *childpipe;
352 int dup_childpipe_read_fd = -1;
353
355 if (NULL == childpipe)
356 return NULL;
357 childpipe_read =
359 childpipe_write =
361 GNUNET_DISK_pipe_close (childpipe);
362 if ((NULL == childpipe_read) || (NULL == childpipe_write) ||
364 &childpipe_read_fd)) ||
365 (-1 == (dup_childpipe_read_fd = dup (childpipe_read_fd))))
366 {
367 if (NULL != childpipe_read)
368 GNUNET_DISK_file_close (childpipe_read);
369 if (NULL != childpipe_write)
370 GNUNET_DISK_file_close (childpipe_write);
371 if (0 <= dup_childpipe_read_fd)
372 GNUNET_break (0 == close (dup_childpipe_read_fd));
373 return NULL;
374 }
375 childpipe_read_fd = dup_childpipe_read_fd;
376 GNUNET_DISK_file_close (childpipe_read);
377 }
378 else
379 {
380 childpipe_write = NULL;
381 childpipe_read_fd = -1;
382 }
383 if (NULL != pipe_stdin)
384 {
386 GNUNET_OK ==
389 &fd_stdin_read));
391 GNUNET_OK ==
394 &fd_stdin_write));
395 }
396 if (NULL != pipe_stdout)
397 {
399 GNUNET_OK ==
402 &fd_stdout_write));
404 GNUNET_OK ==
407 &fd_stdout_read));
408 }
409 if (NULL != pipe_stderr)
410 {
412 GNUNET_OK ==
415 &fd_stderr_read));
417 GNUNET_OK ==
420 &fd_stderr_write));
421 }
422 lscp = NULL;
423 ls = 0;
424 if (NULL != lsocks)
425 {
426 i = 0;
427 while (-1 != (k = lsocks[i++]))
428 GNUNET_array_append (lscp, ls, k);
429 GNUNET_array_append (lscp, ls, -1);
430 }
431#if DARWIN
432 /* see https://web.archive.org/web/20150924082249/gnunet.org/vfork */
433 #pragma GCC diagnostic push
434 #pragma GCC diagnostic ignored "-Wdeprecated"
435 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
436 #pragma clang diagnostic push
437 #pragma clang diagnostic ignored "-Wdeprecated"
438 ret = vfork ();
439 #pragma clang diagnostic pop
440 #pragma GCC diagnostic pop
441#else
442 ret = fork ();
443#endif
444 if (-1 == ret)
445 {
446 int eno = errno;
447
449 "fork");
450 GNUNET_array_grow (lscp,
451 ls,
452 0);
453 if (NULL != childpipe_write)
454 GNUNET_DISK_file_close (childpipe_write);
455 if (0 <= childpipe_read_fd)
456 GNUNET_break (0 == close (childpipe_read_fd));
457 errno = eno;
458 return NULL;
459 }
460 if (0 != ret)
461 {
462 unsetenv (GNUNET_OS_CONTROL_PIPE);
463 gnunet_proc = GNUNET_new (struct GNUNET_OS_Process);
464 gnunet_proc->pid = ret;
465 gnunet_proc->control_pipe = childpipe_write;
466 if (0 != (std_inheritance & GNUNET_OS_USE_PIPE_CONTROL))
467 {
468 GNUNET_break (0 == close (childpipe_read_fd));
469 }
470 GNUNET_array_grow (lscp, ls, 0);
471 return gnunet_proc;
472 }
473 if (0 <= childpipe_read_fd)
474 {
475 char fdbuf[100];
476#ifndef DARWIN
477 /* due to vfork, we must NOT free memory on DARWIN! */
478 GNUNET_DISK_file_close (childpipe_write);
479#endif
480 snprintf (fdbuf,
481 sizeof (fdbuf),
482 "%x",
483 childpipe_read_fd);
485 fdbuf,
486 1);
487 }
488 else
489 unsetenv (GNUNET_OS_CONTROL_PIPE);
490 if (NULL != pipe_stdin)
491 {
492 GNUNET_break (0 == close (fd_stdin_write));
493 if (-1 == dup2 (fd_stdin_read,
494 0))
496 "dup2");
497 GNUNET_break (0 == close (fd_stdin_read));
498 }
499 else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_IN))
500 {
501 GNUNET_break (0 == close (0));
502 open_dev_null (0,
503 O_RDONLY);
504 }
505 if (NULL != pipe_stdout)
506 {
507 GNUNET_break (0 == close (fd_stdout_read));
508 if (-1 == dup2 (fd_stdout_write,
509 1))
511 "dup2");
512 GNUNET_break (0 ==
513 close (fd_stdout_write));
514 }
515 else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_OUT))
516 {
517 GNUNET_break (0 == close (1));
518 open_dev_null (1,
519 O_WRONLY);
520 }
521 if (NULL != pipe_stderr)
522 {
523 GNUNET_break (0 == close (fd_stderr_read));
524 if (-1 == dup2 (fd_stderr_write,
525 2))
527 GNUNET_break (0 == close (fd_stderr_write));
528 }
529 else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_ERR))
530 {
531 GNUNET_break (0 == close (2));
532 open_dev_null (2,
533 O_WRONLY);
534 }
535 if (NULL != lscp)
536 {
537 char *fdnames = GNUNET_strdup ("");
538
539 /* read systemd documentation... */
540 i = 0;
541 tgt = 3;
542 while (-1 != lscp[i])
543 {
544 j = i + 1;
545 while (-1 != lscp[j])
546 {
547 if (lscp[j] == tgt)
548 {
549 /* dup away */
550 k = dup (lscp[j]);
551 GNUNET_assert (-1 != k);
552 GNUNET_assert (0 == close (lscp[j]));
553 lscp[j] = k;
554 break;
555 }
556 j++;
557 }
558 if (lscp[i] != tgt)
559 {
560 /* Bury any existing FD, no matter what; they should all be closed
561 * on exec anyway and the important ones have been dup'ed away */
562 GNUNET_break (0 == close (tgt));
563 GNUNET_assert (-1 != dup2 (lscp[i],
564 tgt));
565 }
566 /* unset close-on-exec flag */
567 flags = fcntl (tgt,
568 F_GETFD);
569 GNUNET_assert (flags >= 0);
570 flags &= ~FD_CLOEXEC;
571 fflush (stderr);
572 (void) fcntl (tgt,
573 F_SETFD,
574 flags);
575 {
576 char *tmp;
577
578 GNUNET_asprintf (&tmp,
579 "%s:%d",
580 fdnames,
581 tgt);
582 GNUNET_free (fdnames);
583 fdnames = tmp;
584 }
585 tgt++;
586 i++;
587 }
588 GNUNET_snprintf (fds,
589 sizeof(fds),
590 "%u",
591 i);
592 setenv ("LISTEN_FDS",
593 fds,
594 1);
595 if (0 != strlen (fdnames))
596 setenv ("LISTEN_FDNAMES",
597 fdnames + 1, /* skip leading ':' */
598 1);
599 GNUNET_free (fdnames);
600 }
601#ifndef DARWIN
602 /* due to vfork, we must NOT free memory on DARWIN! */
603 GNUNET_array_grow (lscp,
604 ls,
605 0);
606#endif
607 execvp (filename,
608 argv);
610 "execvp",
611 filename);
612 _exit (1);
613}
614
615
616struct GNUNET_OS_Process *
618 struct GNUNET_DISK_PipeHandle *pipe_stdin,
619 struct GNUNET_DISK_PipeHandle *pipe_stdout,
620 struct GNUNET_DISK_PipeHandle *pipe_stderr,
621 const char *filename,
622 char *const argv[])
623{
624 return start_process (std_inheritance,
625 pipe_stdin,
626 pipe_stdout,
627 pipe_stderr,
628 NULL,
629 filename,
630 argv);
631}
632
633
634struct GNUNET_OS_Process *
636 struct GNUNET_DISK_PipeHandle *pipe_stdin,
637 struct GNUNET_DISK_PipeHandle *pipe_stdout,
638 struct GNUNET_DISK_PipeHandle *pipe_stderr,
639 const char *filename,
640 va_list va)
641{
642 struct GNUNET_OS_Process *ret;
643 va_list ap;
644 char **argv;
645 int argc;
646
647 argc = 0;
648 va_copy (ap, va);
649 while (NULL != va_arg (ap, char *))
650 argc++;
651 va_end (ap);
652 argv = GNUNET_malloc (sizeof(char *) * (argc + 1));
653 argc = 0;
654 va_copy (ap, va);
655 while (NULL != (argv[argc] = va_arg (ap, char *)))
656 argc++;
657 va_end (ap);
658 ret = GNUNET_OS_start_process_vap (std_inheritance,
659 pipe_stdin,
660 pipe_stdout,
661 pipe_stderr,
662 filename,
663 argv);
664 GNUNET_free (argv);
665 return ret;
666}
667
668
669struct GNUNET_OS_Process *
671 struct GNUNET_DISK_PipeHandle *pipe_stdin,
672 struct GNUNET_DISK_PipeHandle *pipe_stdout,
673 struct GNUNET_DISK_PipeHandle *pipe_stderr,
674 const char *filename,
675 ...)
676{
677 struct GNUNET_OS_Process *ret;
678 va_list ap;
679
680 va_start (ap, filename);
681 ret = GNUNET_OS_start_process_va (std_inheritance,
682 pipe_stdin,
683 pipe_stdout,
684 pipe_stderr,
685 filename,
686 ap);
687 va_end (ap);
688 return ret;
689}
690
691
692struct GNUNET_OS_Process *
694 const int *lsocks,
695 const char *filename,
696 char *const argv[])
697{
698 return start_process (std_inheritance,
699 NULL,
700 NULL,
701 NULL,
702 lsocks,
703 filename,
704 argv);
705}
706
707
708struct GNUNET_OS_Process *
710 const int *lsocks,
711 const char *filename,
712 ...)
713{
714 va_list ap;
715 char **argv;
716 unsigned int argv_size;
717 const char *arg;
718 const char *rpos;
719 char *pos;
720 char *cp;
721 const char *last;
722 struct GNUNET_OS_Process *proc;
723 char *binary_path;
724 int quote_on;
725 unsigned int i;
726 size_t len;
727
728 argv_size = 1;
729 va_start (ap, filename);
730 arg = filename;
731 last = NULL;
732 do
733 {
734 rpos = arg;
735 quote_on = 0;
736 while ('\0' != *rpos)
737 {
738 if ('"' == *rpos)
739 {
740 if (1 == quote_on)
741 quote_on = 0;
742 else
743 quote_on = 1;
744 }
745 if ((' ' == *rpos) && (0 == quote_on))
746 {
747 if (NULL != last)
748 argv_size++;
749 last = NULL;
750 rpos++;
751 while (' ' == *rpos)
752 rpos++;
753 }
754 if ((NULL == last) && ('\0' != *rpos)) // FIXME: == or !=?
755 last = rpos;
756 if ('\0' != *rpos)
757 rpos++;
758 }
759 if (NULL != last)
760 argv_size++;
761 }
762 while (NULL != (arg = (va_arg (ap, const char *))));
763 va_end (ap);
764
765 argv = GNUNET_malloc (argv_size * sizeof(char *));
766 argv_size = 0;
767 va_start (ap, filename);
768 arg = filename;
769 last = NULL;
770 do
771 {
772 cp = GNUNET_strdup (arg);
773 quote_on = 0;
774 pos = cp;
775 while ('\0' != *pos)
776 {
777 if ('"' == *pos)
778 {
779 if (1 == quote_on)
780 quote_on = 0;
781 else
782 quote_on = 1;
783 }
784 if ((' ' == *pos) && (0 == quote_on))
785 {
786 *pos = '\0';
787 if (NULL != last)
788 argv[argv_size++] = GNUNET_strdup (last);
789 last = NULL;
790 pos++;
791 while (' ' == *pos)
792 pos++;
793 }
794 if ((NULL == last) && ('\0' != *pos)) // FIXME: == or !=?
795 last = pos;
796 if ('\0' != *pos)
797 pos++;
798 }
799 if (NULL != last)
800 argv[argv_size++] = GNUNET_strdup (last);
801 last = NULL;
802 GNUNET_free (cp);
803 }
804 while (NULL != (arg = (va_arg (ap, const char *))));
805 va_end (ap);
806 argv[argv_size] = NULL;
807
808 for (i = 0; i < argv_size; i++)
809 {
810 len = strlen (argv[i]);
811 if ((argv[i][0] == '"') && (argv[i][len - 1] == '"'))
812 {
813 memmove (&argv[i][0], &argv[i][1], len - 2);
814 argv[i][len - 2] = '\0';
815 }
816 }
817 binary_path = argv[0];
818 proc = GNUNET_OS_start_process_v (std_inheritance,
819 lsocks,
820 binary_path,
821 argv);
822 while (argv_size > 0)
823 GNUNET_free_nz (argv[--argv_size]);
824 GNUNET_free (argv);
825 return proc;
826}
827
828
842 unsigned long *code,
843 int options)
844{
845 int status;
846 int ret;
847
848 GNUNET_assert (0 != proc);
849 ret = waitpid (proc->pid,
850 &status,
851 options);
852 if (ret < 0)
853 {
855 "waitpid");
856 return GNUNET_SYSERR;
857 }
858 if (0 == ret)
859 {
861 *code = 0;
862 return GNUNET_NO;
863 }
864 if (proc->pid != ret)
865 {
867 "waitpid");
868 return GNUNET_SYSERR;
869 }
870 if (WIFEXITED (status))
871 {
873 *code = WEXITSTATUS (status);
874 }
875 else if (WIFSIGNALED (status))
876 {
878 *code = WTERMSIG (status);
879 }
880 else if (WIFSTOPPED (status))
881 {
883 *code = WSTOPSIG (status);
884 }
885#ifdef WIFCONTINUED
886 else if (WIFCONTINUED (status))
887 {
889 *code = 0;
890 }
891#endif
892 else
893 {
895 *code = 0;
896 }
897
898 return GNUNET_OK;
899}
900
901
905 unsigned long *code)
906{
907 return process_status (proc, type, code, WNOHANG);
908}
909
910
914 unsigned long *code)
915{
916 return process_status (proc, type, code, 0);
917}
918
919
922{
923 pid_t pid = proc->pid;
924 pid_t ret;
925
926 while ((pid != (ret = waitpid (pid, NULL, 0))) && (EINTR == errno))
927 ;
928 if (pid != ret)
929 {
931 "waitpid");
932 return GNUNET_SYSERR;
933 }
934 return GNUNET_OK;
935}
936
937
942{
947
952
957
962
966 void *proc_cls;
967
971 char buf[1024];
972
977
982
986 size_t off;
987};
988
989
990void
992{
993 if (NULL != cmd->proc)
994 {
995 GNUNET_assert (NULL != cmd->rtask);
997 }
998 (void) GNUNET_OS_process_kill (cmd->eip, SIGKILL);
1002 GNUNET_free (cmd);
1003}
1004
1005
1011static void
1012cmd_read (void *cls)
1013{
1014 struct GNUNET_OS_CommandHandle *cmd = cls;
1015 const struct GNUNET_SCHEDULER_TaskContext *tc;
1017 char *end;
1018 ssize_t ret;
1019
1020 cmd->rtask = NULL;
1023 {
1024 /* timeout */
1025 proc = cmd->proc;
1026 cmd->proc = NULL;
1027 proc (cmd->proc_cls, NULL);
1028 return;
1029 }
1030 ret = GNUNET_DISK_file_read (cmd->r,
1031 &cmd->buf[cmd->off],
1032 sizeof(cmd->buf) - cmd->off);
1033 if (ret <= 0)
1034 {
1035 if ((cmd->off > 0) && (cmd->off < sizeof(cmd->buf)))
1036 {
1037 cmd->buf[cmd->off] = '\0';
1038 cmd->proc (cmd->proc_cls, cmd->buf);
1039 }
1040 proc = cmd->proc;
1041 cmd->proc = NULL;
1042 proc (cmd->proc_cls, NULL);
1043 return;
1044 }
1045 end = memchr (&cmd->buf[cmd->off], '\n', ret);
1046 cmd->off += ret;
1047 while (NULL != end)
1048 {
1049 *end = '\0';
1050 cmd->proc (cmd->proc_cls, cmd->buf);
1051 memmove (cmd->buf, end + 1, cmd->off - (end + 1 - cmd->buf));
1052 cmd->off -= (end + 1 - cmd->buf);
1053 end = memchr (cmd->buf, '\n', cmd->off);
1054 }
1055 cmd->rtask =
1057 cmd->timeout),
1058 cmd->r,
1059 &cmd_read,
1060 cmd);
1061}
1062
1063
1066 void *proc_cls,
1068 const char *binary,
1069 ...)
1070{
1071 struct GNUNET_OS_CommandHandle *cmd;
1072 struct GNUNET_OS_Process *eip;
1073 struct GNUNET_DISK_PipeHandle *opipe;
1074 va_list ap;
1075
1077 if (NULL == opipe)
1078 return NULL;
1079 va_start (ap, binary);
1080 /* redirect stdout, don't inherit stderr/stdin */
1081 eip =
1083 NULL,
1084 opipe,
1085 NULL,
1086 binary,
1087 ap);
1088 va_end (ap);
1089 if (NULL == eip)
1090 {
1091 GNUNET_DISK_pipe_close (opipe);
1092 return NULL;
1093 }
1095 cmd = GNUNET_new (struct GNUNET_OS_CommandHandle);
1097 cmd->eip = eip;
1098 cmd->opipe = opipe;
1099 cmd->proc = proc;
1100 cmd->proc_cls = proc_cls;
1103 return cmd;
1104}
1105
1106
1107/* end of os_priority.c */
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
enum GNUNET_GenericReturnValue GNUNET_DISK_internal_file_handle_(const struct GNUNET_DISK_FileHandle *fh, int *dst)
Retrieve OS file handle.
Definition: disk.c:1652
Internal DISK related helper functions.
char * getenv()
static int ret
Final status code.
Definition: gnunet-arm.c:93
static struct GNUNET_TIME_Relative timeout
User defined timestamp for completing operations.
Definition: gnunet-arm.c:118
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:33
static char * filename
static uint32_t type
Type string converted to DNS type value.
static struct GNUNET_NETWORK_Handle * ls
Listen socket for STUN processing.
Definition: gnunet-nat.c:85
static int status
The program status; 0 for success.
Definition: gnunet-nse.c:39
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
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:1635
struct GNUNET_DISK_FileHandle * GNUNET_DISK_pipe_detach_end(struct GNUNET_DISK_PipeHandle *p, enum GNUNET_DISK_PipeEnd end)
Detaches one of the ends from the pipe.
Definition: disk.c:1578
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:700
struct GNUNET_DISK_PipeHandle * GNUNET_DISK_pipe(enum GNUNET_DISK_PipeFlags pf)
Creates an interprocess channel.
Definition: disk.c:1458
enum GNUNET_GenericReturnValue GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p)
Closes an interprocess channel.
Definition: disk.c:1605
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1322
struct GNUNET_DISK_FileHandle * GNUNET_DISK_get_handle_from_int_fd(int fno)
Get a handle from a native integer FD.
Definition: disk.c:1344
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:663
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:1552
@ GNUNET_DISK_PF_NONE
No special options, use non-blocking read/write operations.
@ 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.
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.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_array_append(arr, len, element)
Append an element to an array (growing the array by one).
#define GNUNET_free(ptr)
Wrapper around free.
#define GNUNET_free_nz(ptr)
Wrapper around free.
int GNUNET_NETWORK_fdset_handle_isset(const struct GNUNET_NETWORK_FDSet *fds, const struct GNUNET_DISK_FileHandle *h)
Check if a file handle is part of an fd set.
Definition: network.c:1127
void(* GNUNET_OS_LineProcessor)(void *cls, const char *line)
Type of a function to process a line of output.
struct GNUNET_OS_Process * GNUNET_OS_start_process(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,...)
Start a process.
Definition: os_priority.c:670
GNUNET_OS_InheritStdioFlags
Flags that determine which of the standard streams should be inherited by the child process.
Definition: gnunet_os_lib.h:73
struct GNUNET_OS_Process * GNUNET_OS_start_process_v(enum GNUNET_OS_InheritStdioFlags std_inheritance, const int *lsocks, const char *filename, char *const argv[])
Start a process.
Definition: os_priority.c:693
struct GNUNET_OS_Process * GNUNET_OS_process_current()
Get process structure for current process.
Definition: os_priority.c:203
enum GNUNET_GenericReturnValue GNUNET_OS_process_wait_status(struct GNUNET_OS_Process *proc, enum GNUNET_OS_ProcessStatusType *type, unsigned long *code)
Retrieve the status of a process, waiting on it if dead.
Definition: os_priority.c:912
void GNUNET_OS_install_parent_control_handler(void *cls)
Connects this process to its parent via pipe; essentially, the parent control handler will read signa...
Definition: os_priority.c:134
void GNUNET_OS_command_stop(struct GNUNET_OS_CommandHandle *cmd)
Stop/kill a command.
Definition: os_priority.c:991
struct GNUNET_OS_CommandHandle * GNUNET_OS_command_run(GNUNET_OS_LineProcessor proc, void *proc_cls, struct GNUNET_TIME_Relative timeout, const char *binary,...)
Run the given command line and call the given function for each line of the output.
Definition: os_priority.c:1065
struct GNUNET_OS_Process * GNUNET_OS_start_process_s(enum GNUNET_OS_InheritStdioFlags std_inheritance, const int *lsocks, const char *filename,...)
Start a process.
Definition: os_priority.c:709
pid_t GNUNET_OS_process_get_pid(struct GNUNET_OS_Process *proc)
Get the pid of the process in question.
Definition: os_priority.c:254
GNUNET_OS_ProcessStatusType
Process status types.
void GNUNET_OS_process_destroy(struct GNUNET_OS_Process *proc)
Cleans up process structure contents (OS-dependent) and deallocates it.
Definition: os_priority.c:261
enum GNUNET_GenericReturnValue GNUNET_OS_check_helper_binary(const char *binary, bool check_suid, const char *params)
Check whether an executable exists and possibly if the suid bit is set on the file.
int GNUNET_OS_process_kill(struct GNUNET_OS_Process *proc, int sig)
Sends a signal to the process.
Definition: os_priority.c:211
enum GNUNET_GenericReturnValue GNUNET_OS_process_status(struct GNUNET_OS_Process *proc, enum GNUNET_OS_ProcessStatusType *type, unsigned long *code)
Retrieve the status of a process.
Definition: os_priority.c:903
enum GNUNET_GenericReturnValue GNUNET_OS_process_wait(struct GNUNET_OS_Process *proc)
Wait for a process to terminate.
Definition: os_priority.c:921
struct GNUNET_OS_Process * GNUNET_OS_start_process_va(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, va_list va)
Start a process.
Definition: os_priority.c:635
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:617
@ GNUNET_OS_INHERIT_STD_IN
When this flag is set, the child process will inherit stdin of the parent.
Definition: gnunet_os_lib.h:83
@ GNUNET_OS_INHERIT_STD_OUT
When this flag is set, the child process will inherit stdout of the parent.
Definition: gnunet_os_lib.h:89
@ 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_INHERIT_STD_NONE
No standard streams should be inherited.
Definition: gnunet_os_lib.h:77
@ GNUNET_OS_USE_PIPE_CONTROL
Should a pipe be used to send signals to the child?
@ GNUNET_OS_PROCESS_SIGNALED
The process was killed by a signal.
@ GNUNET_OS_PROCESS_EXITED
The process exited with a return code.
@ GNUNET_OS_PROCESS_UNKNOWN
The process is not known to the OS (or at least not one of our children).
@ GNUNET_OS_PROCESS_RUNNING
The process is still running.
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
const struct GNUNET_SCHEDULER_TaskContext * GNUNET_SCHEDULER_get_task_context(void)
Obtain the reasoning why the current task was started.
Definition: scheduler.c:758
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1339
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:980
void GNUNET_SIGNAL_raise(const int sig)
Raise the given signal by calling the installed signal handlers.
Definition: signal.c:98
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:406
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:316
#define GNUNET_OS_CONTROL_PIPE
Definition: os_priority.c:42
static void parent_control_handler(void *cls)
This handler is called when there are control data to be read on the pipe.
Definition: os_priority.c:99
static struct GNUNET_OS_Process current_process
Handle for 'this' process.
Definition: os_priority.c:63
static struct GNUNET_SCHEDULER_Task * pch
Handle for the parent_control_handler() Task.
Definition: os_priority.c:68
#define LOG_STRERROR_FILE(kind, syscall, filename)
Definition: os_priority.c:38
static void shutdown_pch(void *cls)
This handler is called on shutdown to remove the pch.
Definition: os_priority.c:82
static void open_dev_null(int target_fd, int flags)
Open '/dev/null' and make the result the given file descriptor.
Definition: os_priority.c:278
static struct GNUNET_OS_Process * start_process(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 int *lsocks, const char *filename, char *const argv[])
Start a process.
Definition: os_priority.c:318
static struct GNUNET_SCHEDULER_Task * spch
Handle for the shutdown_pch() Task.
Definition: os_priority.c:73
#define LOG(kind,...)
Definition: os_priority.c:33
#define LOG_STRERROR(kind, syscall)
Definition: os_priority.c:35
static void cmd_read(void *cls)
Read from the process and call the line processor.
Definition: os_priority.c:1012
static enum GNUNET_GenericReturnValue process_status(struct GNUNET_OS_Process *proc, enum GNUNET_OS_ProcessStatusType *type, unsigned long *code, int options)
Retrieve the status of a process, waiting on it if dead.
Definition: os_priority.c:840
#define GNUNET_TERM_SIG
The termination signal.
Definition: platform.h:235
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:431
Handle used to access files (and pipes).
Handle used to manage a pipe.
Definition: disk.c:69
Handle to a command.
Definition: os_priority.c:942
struct GNUNET_DISK_PipeHandle * opipe
Handle to the output pipe.
Definition: os_priority.c:951
struct GNUNET_OS_Process * eip
Process handle.
Definition: os_priority.c:946
size_t off
Current read offset in buf.
Definition: os_priority.c:986
char buf[1024]
Buffer for the output.
Definition: os_priority.c:971
struct GNUNET_SCHEDULER_Task * rtask
Task reading from pipe.
Definition: os_priority.c:976
struct GNUNET_TIME_Absolute timeout
When to time out.
Definition: os_priority.c:981
void * proc_cls
Closure for proc.
Definition: os_priority.c:966
GNUNET_OS_LineProcessor proc
Function to call on each line of output.
Definition: os_priority.c:961
const struct GNUNET_DISK_FileHandle * r
Read-end of output pipe.
Definition: os_priority.c:956
pid_t pid
PID of the process.
Definition: os_priority.c:50
struct GNUNET_DISK_FileHandle * control_pipe
Pipe we use to signal the process.
Definition: os_priority.c:56
Context information passed to each scheduler task.
const struct GNUNET_NETWORK_FDSet * read_ready
Set of file descriptors ready for reading; note that additional bits may be set that were not in the ...
Entry in list of pending tasks.
Definition: scheduler.c:136
Time for absolute times used by GNUnet, in microseconds.
Time for relative time used by GNUnet, in microseconds.