lib582: used for test 582

Accidentally not included in commit 0e74e1d8

tests/libtest/lib582.c

+/*****************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ */
+
+#include "test.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "testutil.h"
+#include "memdebug.h"
+
+#define MAIN_LOOP_HANG_TIMEOUT     10 * 1000
+
+struct Sockets
+{
+  curl_socket_t* sockets;
+  int count;
+};
+
+struct ReadWriteSockets
+{
+  struct Sockets read, write;
+};
+
+/**
+ * Remove a file descriptor from a sockets array.
+ */
+static void removeFd(struct Sockets* sockets, curl_socket_t fd)
+{
+  int i;
+
+  fprintf(stderr, "Remove socket fd %d\n", (int) fd);
+
+  for (i = 0; i < sockets->count; ++i) {
+    if (sockets->sockets[i] == fd) {
+      memmove(&sockets->sockets[i], &sockets->sockets[i + 1],
+              sizeof(curl_socket_t) * (sockets->count - i - 1));
+      --sockets->count;
+    }
+  }
+}
+
+/**
+ * Add a file descriptor to a sockets array.
+ */
+static void addFd(struct Sockets* sockets, curl_socket_t fd)
+{
+  /**
+   * To ensure we only have each file descriptor once, we remove it then add
+   * it again.
+   */
+  fprintf(stderr, "Add socket fd %d\n", (int) fd);
+  removeFd(sockets, fd);
+  sockets->sockets = realloc(sockets->sockets,
+        sizeof(curl_socket_t) * (sockets->count + 1));
+  sockets->sockets[sockets->count] = fd;
+  ++sockets->count;
+}
+
+/**
+ * Callback invoked by curl to poll reading / writing of a socket.
+ */
+static int curlSocketCallback(CURL *easy, curl_socket_t s, int action,
+    void *userp, void *socketp)
+{
+  struct ReadWriteSockets* sockets = userp;
+
+  (void)easy; /* unused */
+  (void)socketp; /* unused */
+
+  if (action == CURL_POLL_IN || action == CURL_POLL_INOUT)
+    addFd(&sockets->read, s);
+  else
+    removeFd(&sockets->read, s);
+
+  if (action == CURL_POLL_OUT || action == CURL_POLL_INOUT)
+    addFd(&sockets->write, s);
+  else
+    removeFd(&sockets->write, s);
+
+  return 0;
+}
+
+/**
+ * Callback invoked by curl to set a timeout.
+ */
+static int curlTimerCallback(CURLM *multi, long timeout_ms, void *userp)
+{
+  struct timeval* timeout = userp;
+
+  (void)multi; /* unused */
+  if (timeout_ms != -1) {
+    gettimeofday(timeout, 0);
+    timeout->tv_usec += timeout_ms * 1000;
+  }
+  else {
+    timeout->tv_sec = -1;
+  }
+  return 0;
+}
+
+/**
+ * Check for curl completion.
+ */
+static int checkForCompletion(CURLM* curl, int* success)
+{
+  int numMessages;
+  CURLMsg* message;
+  int result = 0;
+  *success = 0;
+  while ((message = curl_multi_info_read(curl, &numMessages)) != 0) {
+    if (message->msg == CURLMSG_DONE) {
+      result = 1;
+      if (message->data.result == CURLE_OK)
+        *success = 1;
+      else
+        *success = 0;
+    }
+    else {
+      fprintf(stderr, "Got an unexpected message from curl: %i\n",
+              message->msg);
+      result = 1;
+      *success = 0;
+    }
+  }
+  return result;
+}
+
+static int getMicroSecondTimeout(struct timeval* timeout)
+{
+  struct timeval now;
+  int result;
+
+  gettimeofday(&now, 0);
+  result = (timeout->tv_sec - now.tv_sec) * 1000000 +
+    timeout->tv_usec - now.tv_usec;
+  if (result < 0)
+    result = 0;
+
+  return result;
+}
+
+/**
+ * Update a fd_set with all of the sockets in use.
+ */
+static void updateFdSet(struct Sockets* sockets, fd_set* fdset, int* maxFd)
+{
+  int i;
+  for (i = 0; i < sockets->count; ++i) {
+    FD_SET(sockets->sockets[i], fdset);
+    if (*maxFd < sockets->sockets[i] + 1) {
+      *maxFd = sockets->sockets[i] + 1;
+    }
+  }
+}
+
+static void notifyCurl(CURL* curl, curl_socket_t s, int evBitmask,
+                       const char* info)
+{
+  int numhandles = 0;
+  CURLMcode result = curl_multi_socket_action(curl, s, evBitmask, &numhandles);
+  if (result != CURLM_OK && result != CURLM_CALL_MULTI_PERFORM)
+  {
+    fprintf(stderr, "Curl error on %s: %i (%s)\n",
+            info, result, curl_multi_strerror(result));
+  }
+}
+
+/**
+ * Invoke curl when a file descriptor is set.
+ */
+static void checkFdSet(CURL* curl, struct Sockets* sockets, fd_set* fdset,
+      int evBitmask, const char* name)
+{
+  int i;
+  for (i = 0; i < sockets->count; ++i)
+  {
+    if (FD_ISSET(sockets->sockets[i], fdset))
+    {
+      notifyCurl(curl, sockets->sockets[i], evBitmask, name);
+    }
+  }
+}
+
+int test(char *URL)
+{
+  int res = 0;
+  CURL *curl;
+  FILE *hd_src ;
+  int hd ;
+  int error;
+  struct_stat file_info;
+  CURLM *m = NULL;
+  struct timeval ml_start;
+  char ml_timedout = FALSE;
+  struct ReadWriteSockets sockets = {{0, 0}, {0, 0}};
+  struct timeval timeout = {-1, 0};
+  int success = 0;
+
+  if (!libtest_arg3) {
+    fprintf(stderr, "Usage: lib582 [url] [filename] [username]\n");
+    return -1;
+  }
+
+  hd_src = fopen(libtest_arg2, "rb");
+  if(NULL == hd_src) {
+    error = ERRNO;
+    fprintf(stderr, "fopen() failed with error: %d %s\n",
+            error, strerror(error));
+    fprintf(stderr, "Error opening file: %s\n", libtest_arg2);
+    return TEST_ERR_MAJOR_BAD;
+  }
+
+  /* get the file size of the local file */
+  hd = fstat(fileno(hd_src), &file_info);
+  if(hd == -1) {
+    /* can't open file, bail out */
+    error = ERRNO;
+    fprintf(stderr, "fstat() failed with error: %d %s\n",
+            error, strerror(error));
+    fprintf(stderr, "ERROR: cannot open file %s\n", libtest_arg2);
+    fclose(hd_src);
+    return -1;
+  }
+
+  if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+    fprintf(stderr, "curl_global_init() failed\n");
+    fclose(hd_src);
+    return TEST_ERR_MAJOR_BAD;
+  }
+
+  if ((curl = curl_easy_init()) == NULL) {
+    fprintf(stderr, "curl_easy_init() failed\n");
+    fclose(hd_src);
+    curl_global_cleanup();
+    return TEST_ERR_MAJOR_BAD;
+  }
+
+  /* enable uploading */
+  test_setopt(curl, CURLOPT_UPLOAD, 1L);
+
+  /* specify target */
+  test_setopt(curl,CURLOPT_URL, URL);
+
+  /* go verbose */
+  test_setopt(curl, CURLOPT_VERBOSE, 1L);
+
+  /* now specify which file to upload */
+  test_setopt(curl, CURLOPT_READDATA, hd_src);
+
+  test_setopt(curl, CURLOPT_USERPWD, libtest_arg3);
+  test_setopt(curl, CURLOPT_SSH_PUBLIC_KEYFILE, "curl_client_key.pub");
+  test_setopt(curl, CURLOPT_SSH_PRIVATE_KEYFILE, "curl_client_key");
+
+  test_setopt(curl, CURLOPT_INFILESIZE_LARGE,
+                   (curl_off_t)file_info.st_size);
+
+  if ((m = curl_multi_init()) == NULL) {
+    fprintf(stderr, "curl_multi_init() failed\n");
+    curl_easy_cleanup(curl);
+    curl_global_cleanup();
+    fclose(hd_src);
+    return TEST_ERR_MAJOR_BAD;
+  }
+  test_multi_setopt(m, CURLMOPT_SOCKETFUNCTION, curlSocketCallback);
+  test_multi_setopt(m, CURLMOPT_SOCKETDATA, &sockets);
+
+  test_multi_setopt(m, CURLMOPT_TIMERFUNCTION, curlTimerCallback);
+  test_multi_setopt(m, CURLMOPT_TIMERDATA, &timeout);
+
+  if ((res = (int)curl_multi_add_handle(m, curl)) != CURLM_OK) {
+    fprintf(stderr, "curl_multi_add_handle() failed, "
+            "with code %d\n", res);
+    curl_multi_cleanup(m);
+    curl_easy_cleanup(curl);
+    curl_global_cleanup();
+    fclose(hd_src);
+    return TEST_ERR_MAJOR_BAD;
+  }
+
+  ml_timedout = FALSE;
+  ml_start = tutil_tvnow();
+
+  while (!checkForCompletion(m, &success))
+  {
+    fd_set readSet, writeSet;
+    int maxFd = 0;
+    struct timeval tv = {10, 0};
+
+    if (tutil_tvdiff(tutil_tvnow(), ml_start) >
+        MAIN_LOOP_HANG_TIMEOUT) {
+      ml_timedout = TRUE;
+      break;
+    }
+
+    FD_ZERO(&readSet);
+    FD_ZERO(&writeSet);
+    updateFdSet(&sockets.read, &readSet, &maxFd);
+    updateFdSet(&sockets.write, &writeSet, &maxFd);
+
+    if (timeout.tv_sec != -1)
+    {
+      int usTimeout = getMicroSecondTimeout(&timeout);
+      tv.tv_sec = usTimeout / 1000000;
+      tv.tv_usec = usTimeout % 1000000;
+    }
+    else if (maxFd <= 0)
+    {
+      tv.tv_sec = 0;
+      tv.tv_usec = 100000;
+    }
+
+    select_test(maxFd, &readSet, &writeSet, NULL, &tv);
+
+    /* Check the sockets for reading / writing */
+    checkFdSet(m, &sockets.read, &readSet, CURL_CSELECT_IN, "read");
+    checkFdSet(m, &sockets.write, &writeSet, CURL_CSELECT_OUT, "write");
+
+    if (timeout.tv_sec != -1 && getMicroSecondTimeout(&timeout) == 0)
+    {
+      /* Curl's timer has elapsed. */
+      notifyCurl(m, CURL_SOCKET_TIMEOUT, 0, "timeout");
+    }
+  }
+
+  if (!success)
+  {
+    fprintf(stderr, "Error uploading file.\n");
+    res = TEST_ERR_MAJOR_BAD;
+  }
+  else if (ml_timedout) {
+    fprintf(stderr, "ABORTING TEST, since it seems "
+            "that it would have run forever.\n");
+    res = TEST_ERR_RUNS_FOREVER;
+  }
+
+test_cleanup:
+
+  if(m)
+    curl_multi_remove_handle(m, curl);
+  curl_easy_cleanup(curl);
+  if(m)
+    curl_multi_cleanup(m);
+
+  fclose(hd_src); /* close the local file */
+  if (sockets.read.sockets != 0)
+    free(sockets.read.sockets);
+  if (sockets.write.sockets != 0)
+    free(sockets.write.sockets);
+
+  curl_global_cleanup();
+  return res;
+}