w32_sigchld_handler ();
CloseHandle (h);
+ return 0;
}
#endif
GNUNET_OS_set_process_priority (pid_t proc,
enum GNUNET_SCHEDULER_Priority prio)
{
- int rprio = 0;
- int have;
- int delta;
+ int rprio;
GNUNET_assert (prio < GNUNET_SCHEDULER_PRIORITY_COUNT);
if (prio == GNUNET_SCHEDULER_PRIORITY_KEEP)
/* Set process priority */
#ifdef MINGW
SetPriorityClass (GetCurrentProcess (), rprio);
-#elif LINUX
+#elif LINUX
if ( (0 == proc) ||
(proc == getpid () ) )
{
- have = nice (0);
- delta = rprio - have;
+ int have = nice (0);
+ int delta = rprio - have;
errno = 0;
if ( (delta != 0) &&
(rprio == nice (delta)) &&
if (pipe_stdout != NULL)
{
- dup2(fd_stdout_write, 1);
- close (fd_stdout_write);
- close (fd_stdout_read);
+ GNUNET_break (0 == close (fd_stdout_read));
+ if (-1 == dup2(fd_stdout_write, 1))
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "dup2");
+ GNUNET_break (0 == close (fd_stdout_write));
}
if (pipe_stdin != NULL)
{
- dup2(fd_stdin_read, 0);
- close (fd_stdin_read);
- close (fd_stdin_write);
+ GNUNET_break (0 == close (fd_stdin_write));
+ if (-1 == dup2(fd_stdin_read, 0))
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "dup2");
+ GNUNET_break (0 == close (fd_stdin_read));
}
-
execvp (filename, argv);
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
_exit (1);
HANDLE stdin_handle;
HANDLE stdout_handle;
#endif
- char *fn;
- int len;
+ char *fn = NULL;
char path[MAX_PATH + 1];
cmdlen = 0;
start.hStdOutput = stdout_handle;
}
#endif
- if (FindExecutable(filename, NULL, path) <= 32)
+ if ((int) FindExecutable(filename, NULL, path) <= 32)
{
SetErrnoFromWinError (GetLastError ());
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "FindExecutable", fn);
/**
* Start a process.
*
+ * @param lsocks array of listen sockets to dup systemd-style (or NULL);
+ * must be NULL on platforms where dup is not supported
* @param filename name of the binary
* @param argv NULL-terminated list of arguments to the process
* @return process ID of the new process, -1 on error
*/
pid_t
-GNUNET_OS_start_process_v (const char *filename, char *const argv[])
+GNUNET_OS_start_process_v (const int *lsocks,
+ const char *filename, char *const argv[])
{
#ifndef MINGW
pid_t ret;
-
+ char lpid[16];
+ char fds[16];
+ int i;
+ int j;
+ int k;
+ int tgt;
+ int flags;
+ int *lscp;
+ unsigned int ls;
+
+ lscp = NULL;
+ ls = 0;
+ if (lsocks != NULL)
+ {
+ i = 0;
+ while (-1 != (k = lsocks[i++]))
+ {
+ flags = fcntl (k, F_GETFD);
+ GNUNET_assert (flags >= 0);
+ flags &= ~FD_CLOEXEC;
+ (void) fcntl (k, F_SETFD, flags);
+ GNUNET_array_append (lscp, ls, k);
+ }
+ GNUNET_array_append (lscp, ls, -1);
+ }
#if HAVE_WORKING_VFORK
ret = vfork ();
#else
sleep (1);
#endif
}
+ GNUNET_array_grow (lscp, ls, 0);
return ret;
}
+ if (lscp != NULL)
+ {
+ /* read systemd documentation... */
+ GNUNET_snprintf (lpid, sizeof (lpid), "%u", getpid());
+ setenv ("LISTEN_PID", lpid, 1);
+ i = 0;
+ tgt = 3;
+ while (-1 != lscp[i])
+ {
+ j = i + 1;
+ while (-1 != lscp[j])
+ {
+ if (lscp[j] == tgt)
+ {
+ /* dup away */
+ k = dup (lscp[j]);
+ GNUNET_assert (-1 != k);
+ GNUNET_assert (0 == close (lscp[j]));
+ lscp[j] = k;
+ break;
+ }
+ j++;
+ }
+ if (lscp[i] != tgt)
+ {
+ /* Bury any existing FD, no matter what; they should all be closed
+ on exec anyway and the important onces have been dup'ed away */
+ (void) close (tgt);
+ GNUNET_assert (-1 != dup2 (lscp[i], tgt));
+ }
+ /* set close-on-exec flag */
+ flags = fcntl (tgt, F_GETFD);
+ GNUNET_assert (flags >= 0);
+ flags &= ~FD_CLOEXEC;
+ (void) fcntl (tgt, F_SETFD, flags);
+ tgt++;
+ i++;
+ }
+ GNUNET_snprintf (fds, sizeof (fds), "%u", i);
+ setenv ("LISTEN_FDS", fds, 1);
+ }
+ GNUNET_array_grow (lscp, ls, 0);
execvp (filename, argv);
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
_exit (1);
#else
- char **arg;
+ char **arg, **non_const_argv;
unsigned int cmdlen;
char *cmd, *idx;
STARTUPINFO start;
PROCESS_INFORMATION proc;
+ int argcount = 0;
+ char *non_const_filename = NULL;
+ int filenamelen = 0;
- cmdlen = 0;
+ GNUNET_assert (lsocks == NULL);
+ /* Count the number of arguments */
+ arg = argv;
+ while (*arg)
+ {
+ arg++;
+ argcount++;
+ }
+
+ /* Allocate a copy argv */
+ non_const_argv = GNUNET_malloc (sizeof (char *) * (argcount + 1));
+
+ /* Copy all argv strings */
+ argcount = 0;
arg = argv;
+ while (*arg)
+ {
+ non_const_argv[argcount] = GNUNET_strdup (*arg);
+ arg++;
+ argcount++;
+ }
+ non_const_argv[argcount] = NULL;
+
+ /* Fix .exe extension */
+ filenamelen = strlen (filename);
+ if (filenamelen <= 4 || stricmp (&filename[filenamelen - 4], ".exe") != 0)
+ {
+ non_const_filename = GNUNET_malloc (sizeof (char) * (filenamelen + 4 + 1));
+ non_const_filename = strcpy (non_const_filename, non_const_argv[0]);
+ strcat (non_const_filename, ".exe");
+ GNUNET_free (non_const_argv[0]);
+ non_const_argv[0] = non_const_filename;
+ }
+ else
+ non_const_filename = non_const_argv[0];
+
+ /* Count cmd len */
+ cmdlen = 1;
+ arg = non_const_argv;
while (*arg)
{
cmdlen = cmdlen + strlen (*arg) + 3;
arg++;
}
+ /* Allocate and create cmd */
cmd = idx = GNUNET_malloc (sizeof (char) * cmdlen);
- arg = argv;
+ arg = non_const_argv;
while (*arg)
{
idx += sprintf (idx, "\"%s\" ", *arg);
start.cb = sizeof (start);
if (!CreateProcess
- (filename, cmd, NULL, NULL, FALSE, DETACHED_PROCESS, NULL, NULL, &start,
+ (non_const_filename, cmd, NULL, NULL, FALSE, DETACHED_PROCESS, NULL, NULL, &start,
&proc))
{
SetErrnoFromWinError (GetLastError ());
CloseHandle (proc.hThread);
GNUNET_free (cmd);
+ while (argcount > 0)
+ GNUNET_free (non_const_argv[--argcount]);
+ GNUNET_free (non_const_argv);
+
return proc.dwProcessId;
#endif
}
GNUNET_assert (0 != proc);
ret = waitpid (proc, &status, WNOHANG);
+ if (ret < 0)
+ {
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+ return GNUNET_SYSERR;
+ }
if (0 == ret)
{
*type = GNUNET_OS_PROCESS_RUNNING;
return GNUNET_OK;
#else
HANDLE h;
- DWORD c;
int ret;
h = OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, proc);
projects / oweals / gnunet.git / blobdiff