lib582: used for test 582
Accidentally not included in commit 0e74e1d8d83
diff --git a/tests/libtest/lib582.c b/tests/libtest/lib582.c
new file mode 100644
index 0000000..804641e
--- /dev/null
+++ b/tests/libtest/lib582.c
@@ -0,0 +1,360 @@
+/*****************************************************************************
+ * _ _ ____ _
+ * 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;
+}
