remove CYGWIN codeblocks, drop vendored Windows openvpn, drop win32 specific files.

configures and builds okay.
testsuite wasn't checked, will be checked.

diff including the plibc removal is now around 14370 lines of code less.

1 files changed, 1 insertions, 614 deletions

diff --git a/src/util/os_priority.c b/src/util/os_priority.c
index ebe469b3b..e25623af5 100644
--- a/src/util/os_priority.c
+++ b/src/util/os_priority.c
@@ -350,7 +350,6 @@ start_process(int pipe_control,
               const char *filename,
               char *const argv[])
 {
-#ifndef MINGW
   pid_t ret;
   char fds[16];
   struct GNUNET_OS_Process *gnunet_proc;
@@ -464,7 +463,7 @@ start_process(int pipe_control,
       GNUNET_array_append(lscp, ls, -1);
     }
 #if DARWIN
-  /* see https://gnunet.org/vfork */
+  /* see https://web.archive.org/web/20150924082249/gnunet.org/vfork */
   ret = vfork();
 #else
   ret = fork();
@@ -589,547 +588,6 @@ start_process(int pipe_control,
   execvp(filename, argv);
   LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
   _exit(1);
-#else
-  struct GNUNET_DISK_FileHandle *childpipe_read;
-  struct GNUNET_DISK_FileHandle *childpipe_write;
-  HANDLE childpipe_read_handle;
-  char **arg;
-  char **non_const_argv;
-  unsigned int cmdlen;
-  char *cmd;
-  char *idx;
-  STARTUPINFOW start;
-  PROCESS_INFORMATION proc;
-  int argcount = 0;
-  struct GNUNET_OS_Process *gnunet_proc;
-  char path[MAX_PATH + 1];
-  char *our_env[7] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL };
-  char *env_block = NULL;
-  char *pathbuf;
-  DWORD pathbuf_len;
-  DWORD alloc_len;
-  char *self_prefix;
-  char *bindir;
-  char *libdir;
-  char *ptr;
-  char *non_const_filename;
-  char win_path[MAX_PATH + 1];
-  struct GNUNET_DISK_PipeHandle *lsocks_pipe;
-  const struct GNUNET_DISK_FileHandle *lsocks_write_fd;
-  HANDLE lsocks_read;
-  HANDLE lsocks_write;
-  wchar_t *wpath;
-  wchar_t *wcmd;
-  size_t wpath_len;
-  size_t wcmd_len;
-  int env_off;
-  int fail;
-  long lRet;
-  HANDLE stdin_handle;
-  HANDLE stdout_handle;
-  HANDLE stdih, stdoh, stdeh;
-  DWORD stdif, stdof, stdef;
-  BOOL bresult;
-  DWORD error_code;
-  DWORD create_no_window;
-
-  if (GNUNET_SYSERR ==
-      GNUNET_OS_check_helper_binary(filename, GNUNET_NO, NULL))
-    return NULL; /* not executable */
-
-  /* Search in prefix dir (hopefully - the directory from which
-   * the current module was loaded), bindir and libdir, then in PATH
-   */
-  self_prefix = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_SELF_PREFIX);
-  bindir = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_BINDIR);
-  libdir = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_LIBDIR);
-
-  pathbuf_len = GetEnvironmentVariableA("PATH", (char *)&pathbuf, 0);
-
-  alloc_len = pathbuf_len + 1 + strlen(self_prefix) + 1 + strlen(bindir) + 1 +
-              strlen(libdir);
-
-  pathbuf = GNUNET_malloc(alloc_len * sizeof(char));
-
-  ptr = pathbuf;
-  ptr += sprintf(pathbuf, "%s;%s;%s;", self_prefix, bindir, libdir);
-  GNUNET_free(self_prefix);
-  GNUNET_free(bindir);
-  GNUNET_free(libdir);
-
-  alloc_len = GetEnvironmentVariableA("PATH", ptr, pathbuf_len);
-  if (alloc_len != pathbuf_len - 1)
-    {
-      GNUNET_free(pathbuf);
-      errno = ENOSYS; /* PATH changed on the fly. What kind of error is that? */
-      return NULL;
-    }
-
-  cmdlen = strlen(filename);
-  if ((cmdlen < 5) || (0 != strcmp(&filename[cmdlen - 4], ".exe")))
-    GNUNET_asprintf(&non_const_filename, "%s.exe", filename);
-  else
-    GNUNET_asprintf(&non_const_filename, "%s", filename);
-
-  /* It could be in POSIX form, convert it to a DOS path early on */
-  if (ERROR_SUCCESS !=
-      (lRet = plibc_conv_to_win_path(non_const_filename, win_path)))
-    {
-      SetErrnoFromWinError(lRet);
-      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR,
-                        "plibc_conv_to_win_path",
-                        non_const_filename);
-      GNUNET_free(non_const_filename);
-      GNUNET_free(pathbuf);
-      return NULL;
-    }
-  GNUNET_free(non_const_filename);
-  non_const_filename = GNUNET_strdup(win_path);
-  /* Check that this is the full path. If it isn't, search. */
-  /* FIXME: convert it to wchar_t and use SearchPathW?
-   * Remember: arguments to _start_process() are technically in UTF-8...
-   */
-  if (non_const_filename[1] == ':')
-    {
-      snprintf(path, sizeof(path) / sizeof(char), "%s", non_const_filename);
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Using path `%s' as-is. PATH is %s\n",
-          path,
-          ptr);
-    }
-  else if (!SearchPathA(pathbuf,
-                        non_const_filename,
-                        NULL,
-                        sizeof(path) / sizeof(char),
-                        path,
-                        NULL))
-    {
-      SetErrnoFromWinError(GetLastError());
-      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR,
-                        "SearchPath",
-                        non_const_filename);
-      GNUNET_free(non_const_filename);
-      GNUNET_free(pathbuf);
-      return NULL;
-    }
-  else
-    LOG(GNUNET_ERROR_TYPE_DEBUG, "Found `%s' in PATH `%s'\n", path, pathbuf);
-  GNUNET_free(pathbuf);
-  GNUNET_free(non_const_filename);
-
-  /* Count the number of arguments */
-  arg = (char **)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 = (char **)argv;
-  while (*arg)
-    {
-      if (arg == argv)
-        non_const_argv[argcount] = GNUNET_strdup(path);
-      else
-        non_const_argv[argcount] = GNUNET_strdup(*arg);
-      arg++;
-      argcount++;
-    }
-  non_const_argv[argcount] = NULL;
-
-  /* Count cmd len */
-  cmdlen = 1;
-  arg = non_const_argv;
-  while (*arg)
-    {
-      cmdlen = cmdlen + strlen(*arg) + 4;
-      arg++;
-    }
-
-  /* Allocate and create cmd */
-  cmd = idx = GNUNET_malloc(sizeof(char) * cmdlen);
-  arg = non_const_argv;
-  while (*arg)
-    {
-      char arg_last_char = (*arg)[strlen(*arg) - 1];
-      idx += sprintf(idx,
-                     "\"%s%s\"%s",
-                     *arg,
-                     arg_last_char == '\\' ? "\\" : "",
-                     *(arg + 1) ? " " : "");
-      arg++;
-    }
-
-  while (argcount > 0)
-    GNUNET_free(non_const_argv[--argcount]);
-  GNUNET_free(non_const_argv);
-
-  memset(&start, 0, sizeof(start));
-  start.cb = sizeof(start);
-  if ((pipe_stdin != NULL) || (pipe_stdout != NULL) || (std_inheritance != 0))
-    start.dwFlags |= STARTF_USESTDHANDLES;
-
-  stdih = GetStdHandle(STD_INPUT_HANDLE);
-  GetHandleInformation(stdih, &stdif);
-  if (pipe_stdin != NULL)
-    {
-      GNUNET_DISK_internal_file_handle_(
-        GNUNET_DISK_pipe_handle(pipe_stdin, GNUNET_DISK_PIPE_END_READ),
-        &stdin_handle,
-        sizeof(HANDLE));
-      start.hStdInput = stdin_handle;
-    }
-  else if (stdih)
-    {
-      if (std_inheritance & GNUNET_OS_INHERIT_STD_IN)
-        {
-          SetHandleInformation(stdih, HANDLE_FLAG_INHERIT, 1);
-          if (pipe_stdin == NULL)
-            start.hStdInput = stdih;
-        }
-      else
-        SetHandleInformation(stdih, HANDLE_FLAG_INHERIT, 0);
-    }
-
-
-  stdoh = GetStdHandle(STD_OUTPUT_HANDLE);
-  GetHandleInformation(stdoh, &stdof);
-  if (NULL != pipe_stdout)
-    {
-      GNUNET_DISK_internal_file_handle_(
-        GNUNET_DISK_pipe_handle(pipe_stdout, GNUNET_DISK_PIPE_END_WRITE),
-        &stdout_handle,
-        sizeof(HANDLE));
-      start.hStdOutput = stdout_handle;
-    }
-  else if (stdoh)
-    {
-      if (std_inheritance & GNUNET_OS_INHERIT_STD_OUT)
-        {
-          SetHandleInformation(stdoh, HANDLE_FLAG_INHERIT, 1);
-          if (pipe_stdout == NULL)
-            start.hStdOutput = stdoh;
-        }
-      else
-        SetHandleInformation(stdoh, HANDLE_FLAG_INHERIT, 0);
-    }
-
-  stdeh = GetStdHandle(STD_ERROR_HANDLE);
-  GetHandleInformation(stdeh, &stdef);
-  if (stdeh)
-    {
-      if (std_inheritance & GNUNET_OS_INHERIT_STD_ERR)
-        {
-          SetHandleInformation(stdeh, HANDLE_FLAG_INHERIT, 1);
-          start.hStdError = stdeh;
-        }
-      else
-        SetHandleInformation(stdeh, HANDLE_FLAG_INHERIT, 0);
-    }
-
-  if (GNUNET_YES == pipe_control)
-    {
-      struct GNUNET_DISK_PipeHandle *childpipe;
-      childpipe = GNUNET_DISK_pipe(GNUNET_NO, GNUNET_NO, GNUNET_YES, GNUNET_NO);
-      if (NULL == childpipe)
-        return NULL;
-      childpipe_read =
-        GNUNET_DISK_pipe_detach_end(childpipe, GNUNET_DISK_PIPE_END_READ);
-      childpipe_write =
-        GNUNET_DISK_pipe_detach_end(childpipe, GNUNET_DISK_PIPE_END_WRITE);
-      GNUNET_DISK_pipe_close(childpipe);
-      if ((NULL == childpipe_read) || (NULL == childpipe_write) ||
-          (GNUNET_OK != GNUNET_DISK_internal_file_handle_(childpipe_read,
-                                                          &childpipe_read_handle,
-                                                          sizeof(HANDLE))))
-        {
-          if (childpipe_read)
-            GNUNET_DISK_file_close(childpipe_read);
-          if (childpipe_write)
-            GNUNET_DISK_file_close(childpipe_write);
-          GNUNET_free(cmd);
-          return NULL;
-        }
-      /* Unlike *nix variant, we don't dup the handle, so can't close
-       * filehandle right now.
-       */
-      SetHandleInformation(childpipe_read_handle, HANDLE_FLAG_INHERIT, 1);
-    }
-  else
-    {
-      childpipe_read = NULL;
-      childpipe_write = NULL;
-    }
-
-  if (lsocks != NULL && lsocks[0] != INVALID_SOCKET)
-    {
-      lsocks_pipe =
-        GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
-
-      if (lsocks_pipe == NULL)
-        {
-          GNUNET_free(cmd);
-          GNUNET_DISK_pipe_close(lsocks_pipe);
-          if (GNUNET_YES == pipe_control)
-            {
-              GNUNET_DISK_file_close(childpipe_write);
-              GNUNET_DISK_file_close(childpipe_read);
-            }
-          return NULL;
-        }
-      lsocks_write_fd =
-        GNUNET_DISK_pipe_handle(lsocks_pipe, GNUNET_DISK_PIPE_END_WRITE);
-      GNUNET_DISK_internal_file_handle_(lsocks_write_fd,
-                                        &lsocks_write,
-                                        sizeof(HANDLE));
-      GNUNET_DISK_internal_file_handle_(
-        GNUNET_DISK_pipe_handle(lsocks_pipe, GNUNET_DISK_PIPE_END_READ),
-        &lsocks_read,
-        sizeof(HANDLE));
-    }
-  else
-    {
-      lsocks_pipe = NULL;
-      lsocks_write_fd = NULL;
-    }
-
-  env_off = 0;
-  if (GNUNET_YES == pipe_control)
-    {
-      GNUNET_asprintf(&our_env[env_off++], "%s=", GNUNET_OS_CONTROL_PIPE);
-      GNUNET_asprintf(&our_env[env_off++], "%p", childpipe_read_handle);
-    }
-  if ((lsocks != NULL) && (lsocks[0] != INVALID_SOCKET))
-    {
-      /*This will tell the child that we're going to send lsocks over the pipe*/
-      GNUNET_asprintf(&our_env[env_off++], "%s=", "GNUNET_OS_READ_LSOCKS");
-      GNUNET_asprintf(&our_env[env_off++], "%lu", lsocks_read);
-    }
-  our_env[env_off++] = NULL;
-  env_block = CreateCustomEnvTable(our_env);
-  while (0 > env_off)
-    GNUNET_free_non_null(our_env[--env_off]);
-
-  wpath_len = 0;
-  if (NULL ==
-      (wpath =
-         u8_to_u16((uint8_t *)path, 1 + strlen(path), NULL, &wpath_len)))
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Failed to convert `%s' from UTF-8 to UTF-16: %d\n",
-          path,
-          errno);
-      GNUNET_free(env_block);
-      GNUNET_free(cmd);
-      if (lsocks_pipe)
-        GNUNET_DISK_pipe_close(lsocks_pipe);
-      if (GNUNET_YES == pipe_control)
-        {
-          GNUNET_DISK_file_close(childpipe_write);
-          GNUNET_DISK_file_close(childpipe_read);
-        }
-      return NULL;
-    }
-
-  wcmd_len = 0;
-  if (NULL ==
-      (wcmd = u8_to_u16((uint8_t *)cmd, 1 + strlen(cmd), NULL, &wcmd_len)))
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Failed to convert `%s' from UTF-8 to UTF-16: %d\n",
-          cmd,
-          errno);
-      GNUNET_free(env_block);
-      GNUNET_free(cmd);
-      free(wpath);
-      if (lsocks_pipe)
-        GNUNET_DISK_pipe_close(lsocks_pipe);
-      if (GNUNET_YES == pipe_control)
-        {
-          GNUNET_DISK_file_close(childpipe_write);
-          GNUNET_DISK_file_close(childpipe_read);
-        }
-      return NULL;
-    }
-
-  create_no_window = 0;
-  {
-    HANDLE console_input = CreateFile("CONIN$",
-                                      GENERIC_READ,
-                                      FILE_SHARE_READ | FILE_SHARE_WRITE,
-                                      NULL,
-                                      OPEN_EXISTING,
-                                      0,
-                                      NULL);
-    if (INVALID_HANDLE_VALUE == console_input)
-      create_no_window = CREATE_NO_WINDOW;
-    else
-      CloseHandle(console_input);
-  }
-
-  bresult = CreateProcessW(wpath,
-                           wcmd,
-                           NULL,
-                           NULL,
-                           GNUNET_YES,
-                           create_no_window | CREATE_SUSPENDED,
-                           env_block,
-                           NULL,
-                           &start,
-                           &proc);
-  error_code = GetLastError();
-
-  if ((NULL == pipe_stdin) && (stdih))
-    SetHandleInformation(stdih, HANDLE_FLAG_INHERIT, stdif);
-
-
-  if ((NULL == pipe_stdout) && (stdoh))
-    SetHandleInformation(stdoh, HANDLE_FLAG_INHERIT, stdof);
-
-  if (stdeh)
-    SetHandleInformation(stdeh, HANDLE_FLAG_INHERIT, stdef);
-
-  if (!bresult)
-    LOG(GNUNET_ERROR_TYPE_ERROR,
-        "CreateProcess(%s, %s) failed: %lu\n",
-        path,
-        cmd,
-        error_code);
-
-  GNUNET_free(env_block);
-  GNUNET_free(cmd);
-  free(wpath);
-  free(wcmd);
-  if (GNUNET_YES == pipe_control)
-    {
-      GNUNET_DISK_file_close(childpipe_read);
-    }
-
-  if (!bresult)
-    {
-      if (GNUNET_YES == pipe_control)
-        {
-          GNUNET_DISK_file_close(childpipe_write);
-        }
-      if (NULL != lsocks)
-        GNUNET_DISK_pipe_close(lsocks_pipe);
-      SetErrnoFromWinError(error_code);
-      return NULL;
-    }
-
-  gnunet_proc = GNUNET_new(struct GNUNET_OS_Process);
-  gnunet_proc->pid = proc.dwProcessId;
-  gnunet_proc->handle = proc.hProcess;
-  gnunet_proc->control_pipe = childpipe_write;
-
-  CreateThread(NULL, 64000, &child_wait_thread, (void *)gnunet_proc, 0, NULL);
-
-  ResumeThread(proc.hThread);
-  CloseHandle(proc.hThread);
-
-  if ((NULL == lsocks) || (INVALID_SOCKET == lsocks[0]))
-    return gnunet_proc;
-
-  GNUNET_DISK_pipe_close_end(lsocks_pipe, GNUNET_DISK_PIPE_END_READ);
-
-  /* This is a replacement for "goto error" that doesn't use goto */
-  fail = 1;
-  do
-    {
-      ssize_t wrote;
-      uint64_t size;
-      uint64_t count;
-      unsigned int i;
-
-      /* Tell the number of sockets */
-      for (count = 0; lsocks && lsocks[count] != INVALID_SOCKET; count++)
-        ;
-
-      wrote = GNUNET_DISK_file_write(lsocks_write_fd, &count, sizeof(count));
-      if (sizeof(count) != wrote)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                     "Failed to write %u count bytes to the child: %lu\n",
-                     sizeof(count),
-                     GetLastError());
-          break;
-        }
-      for (i = 0; lsocks && lsocks[i] != INVALID_SOCKET; i++)
-        {
-          WSAPROTOCOL_INFOA pi;
-          /* Get a socket duplication info */
-          if (SOCKET_ERROR ==
-              WSADuplicateSocketA(lsocks[i], gnunet_proc->pid, &pi))
-            {
-              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                         "Failed to duplicate an socket[%u]: %lu\n",
-                         i,
-                         GetLastError());
-              break;
-            }
-          /* Synchronous I/O is not nice, but we can't schedule this:
-           * lsocks will be closed/freed by the caller soon, and until
-           * the child creates a duplicate, closing a socket here will
-           * close it for good.
-           */
-          /* Send the size of the structure
-           * (the child might be built with different headers...)
-           */
-          size = sizeof(pi);
-          wrote = GNUNET_DISK_file_write(lsocks_write_fd, &size, sizeof(size));
-          if (sizeof(size) != wrote)
-            {
-              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                         "Failed to write %u size[%u] bytes to the child: %lu\n",
-                         sizeof(size),
-                         i,
-                         GetLastError());
-              break;
-            }
-          /* Finally! Send the data */
-          wrote = GNUNET_DISK_file_write(lsocks_write_fd, &pi, sizeof(pi));
-          if (sizeof(pi) != wrote)
-            {
-              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                         "Failed to write %u socket[%u] bytes to the child: %lu\n",
-                         sizeof(pi),
-                         i,
-                         GetLastError());
-              break;
-            }
-        }
-      /* This will block us until the child makes a final read or closes
-       * the pipe (hence no 'wrote' check), since we have to wait for it
-       * to duplicate the last socket, before we return and start closing
-       * our own copies)
-       */
-      wrote = GNUNET_DISK_file_write(lsocks_write_fd, &count, sizeof(count));
-      fail = 0;
-    }
-  while (fail);
-
-  GNUNET_DISK_file_sync(lsocks_write_fd);
-  GNUNET_DISK_pipe_close(lsocks_pipe);
-
-  if (fail)
-    {
-      /* If we can't pass on the socket(s), the child will block forever,
-       * better put it out of its misery.
-       */
-      SafeTerminateProcess(gnunet_proc->handle, 0, 0);
-      CloseHandle(gnunet_proc->handle);
-      if (NULL != gnunet_proc->control_pipe)
-        GNUNET_DISK_file_close(gnunet_proc->control_pipe);
-      GNUNET_free(gnunet_proc);
-      return NULL;
-    }
-  return gnunet_proc;
-#endif
 }
 
 
@@ -1439,7 +897,6 @@ process_status(struct GNUNET_OS_Process *proc,
                unsigned long *code,
                int options)
 {
-#ifndef MINGW
   int status;
   int ret;
 
@@ -1488,53 +945,6 @@ process_status(struct GNUNET_OS_Process *proc,
       *type = GNUNET_OS_PROCESS_UNKNOWN;
       *code = 0;
     }
-#else
-#ifndef WNOHANG
-#define WNOHANG 42 /* just a flag for W32, purely internal at this point */
-#endif
-
-  HANDLE h;
-  DWORD c, error_code, ret;
-
-  h = proc->handle;
-  ret = proc->pid;
-  if (h == NULL || ret == 0)
-    {
-      LOG(GNUNET_ERROR_TYPE_WARNING,
-          "Invalid process information {%d, %08X}\n",
-          ret,
-          h);
-      return GNUNET_SYSERR;
-    }
-  if (h == NULL)
-    h = GetCurrentProcess();
-
-  if (WNOHANG != options)
-    {
-      if (WAIT_OBJECT_0 != WaitForSingleObject(h, INFINITE))
-        {
-          SetErrnoFromWinError(GetLastError());
-          return GNUNET_SYSERR;
-        }
-    }
-  SetLastError(0);
-  ret = GetExitCodeProcess(h, &c);
-  error_code = GetLastError();
-  if (ret == 0 || error_code != NO_ERROR)
-    {
-      SetErrnoFromWinError(error_code);
-      LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "GetExitCodeProcess");
-      return GNUNET_SYSERR;
-    }
-  if (STILL_ACTIVE == c)
-    {
-      *type = GNUNET_OS_PROCESS_RUNNING;
-      *code = 0;
-      return GNUNET_NO;
-    }
-  *type = GNUNET_OS_PROCESS_EXITED;
-  *code = c;
-#endif
 
   return GNUNET_OK;
 }
@@ -1589,7 +999,6 @@ GNUNET_OS_process_wait_status(struct GNUNET_OS_Process *proc,
 int
 GNUNET_OS_process_wait(struct GNUNET_OS_Process *proc)
 {
-#ifndef MINGW
   pid_t pid = proc->pid;
   pid_t ret;
 
@@ -1601,28 +1010,6 @@ GNUNET_OS_process_wait(struct GNUNET_OS_Process *proc)
       return GNUNET_SYSERR;
     }
   return GNUNET_OK;
-#else
-  HANDLE h;
-
-  h = proc->handle;
-  if (NULL == h)
-    {
-      LOG(GNUNET_ERROR_TYPE_WARNING,
-          "Invalid process information {%d, %08X}\n",
-          proc->pid,
-          h);
-      return GNUNET_SYSERR;
-    }
-  if (NULL == h)
-    h = GetCurrentProcess();
-
-  if (WAIT_OBJECT_0 != WaitForSingleObject(h, INFINITE))
-    {
-      SetErrnoFromWinError(GetLastError());
-      return GNUNET_SYSERR;
-    }
-  return GNUNET_OK;
-#endif
 }