tests/libtest/lib582.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2012, Daniel Stenberg, <daniel@haxx.se>, et al.
   9  *
  10  * This software is licensed as described in the file COPYING, which
  11  * you should have received as part of this distribution. The terms
  12  * are also available at http://curl.haxx.se/docs/copyright.html.
  13  *
  14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15  * copies of the Software, and permit persons to whom the Software is
  16  * furnished to do so, under the terms of the COPYING file.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ***************************************************************************/
  22 #include "test.h"
  23
  24 #include <fcntl.h>
  25
  26 #include "testutil.h"
  27 #include "warnless.h"
  28 #include "memdebug.h"
  29
  30 #define TEST_HANG_TIMEOUT 60 * 1000
  31
  32 struct Sockets
  33 {
  34   curl_socket_t *sockets;
  35   int count;      /* number of sockets actually stored in array */
  36   int max_count;  /* max number of sockets that fit in allocated array */
  37 };
  38
  39 struct ReadWriteSockets
  40 {
  41   struct Sockets read, write;
  42 };
  43
  44 /**
  45  * Remove a file descriptor from a sockets array.
  46  */
  47 static void removeFd(struct Sockets* sockets, curl_socket_t fd, int mention)
  48 {
  49   int i;
  50
  51   if(mention)
  52     fprintf(stderr, "Remove socket fd %d\n", (int) fd);
  53
  54   for (i = 0; i < sockets->count; ++i) {
  55     if (sockets->sockets[i] == fd) {
  56       if (i < sockets->count - 1)
  57         memmove(&sockets->sockets[i], &sockets->sockets[i + 1],
  58               sizeof(curl_socket_t) * (sockets->count - (i + 1)));
  59       --sockets->count;
  60     }
  61   }
  62 }
  63
  64 /**
  65  * Add a file descriptor to a sockets array.
  66  */
  67 static void addFd(struct Sockets* sockets, curl_socket_t fd, const char *what)
  68 {
  69   /**
  70    * To ensure we only have each file descriptor once, we remove it then add
  71    * it again.
  72    */
  73   fprintf(stderr, "Add socket fd %d for %s\n", (int) fd, what);
  74   removeFd(sockets, fd, 0);
  75   /*
  76    * Allocate array storage when required.
  77    */
  78   if(!sockets->sockets) {
  79     sockets->sockets = malloc(sizeof(curl_socket_t) * 20U);
  80     if(!sockets->sockets)
  81       return;
  82     sockets->max_count = 20;
  83   }
  84   else if(sockets->count + 1 > sockets->max_count) {
  85     curl_socket_t *oldptr = sockets->sockets;
  86     sockets->sockets = realloc(oldptr, sizeof(curl_socket_t) *
  87                                (sockets->max_count + 20));
  88     if(!sockets->sockets) {
  89       /* cleanup in test_cleanup */
  90       sockets->sockets = oldptr;
  91       return;
  92     }
  93     sockets->max_count += 20;
  94   }
  95   /*
  96    * Add file descriptor to array.
  97    */
  98   sockets->sockets[sockets->count] = fd;
  99   ++sockets->count;
 100 }
 101
 102 /**
 103  * Callback invoked by curl to poll reading / writing of a socket.
 104  */
 105 static int curlSocketCallback(CURL *easy, curl_socket_t s, int action,
 106                               void *userp, void *socketp)
 107 {
 108   struct ReadWriteSockets* sockets = userp;
 109
 110   (void)easy; /* unused */
 111   (void)socketp; /* unused */
 112
 113   if (action == CURL_POLL_IN || action == CURL_POLL_INOUT)
 114     addFd(&sockets->read, s, "read");
 115
 116   if (action == CURL_POLL_OUT || action == CURL_POLL_INOUT)
 117     addFd(&sockets->write, s, "write");
 118
 119   if(action == CURL_POLL_REMOVE) {
 120     removeFd(&sockets->read, s, 1);
 121     removeFd(&sockets->write, s, 0);
 122   }
 123
 124   return 0;
 125 }
 126
 127 /**
 128  * Callback invoked by curl to set a timeout.
 129  */
 130 static int curlTimerCallback(CURLM *multi, long timeout_ms, void *userp)
 131 {
 132   struct timeval* timeout = userp;
 133
 134   (void)multi; /* unused */
 135   if (timeout_ms != -1) {
 136     *timeout = tutil_tvnow();
 137     timeout->tv_usec += timeout_ms * 1000;
 138   }
 139   else {
 140     timeout->tv_sec = -1;
 141   }
 142   return 0;
 143 }
 144
 145 /**
 146  * Check for curl completion.
 147  */
 148 static int checkForCompletion(CURLM* curl, int* success)
 149 {
 150   int numMessages;
 151   CURLMsg* message;
 152   int result = 0;
 153   *success = 0;
 154   while ((message = curl_multi_info_read(curl, &numMessages)) != NULL) {
 155     if (message->msg == CURLMSG_DONE) {
 156       result = 1;
 157       if (message->data.result == CURLE_OK)
 158         *success = 1;
 159       else
 160         *success = 0;
 161     }
 162     else {
 163       fprintf(stderr, "Got an unexpected message from curl: %i\n",
 164               (int)message->msg);
 165       result = 1;
 166       *success = 0;
 167     }
 168   }
 169   return result;
 170 }
 171
 172 static int getMicroSecondTimeout(struct timeval* timeout)
 173 {
 174   struct timeval now;
 175   ssize_t result;
 176   now = tutil_tvnow();
 177   result = (timeout->tv_sec - now.tv_sec) * 1000000 +
 178     timeout->tv_usec - now.tv_usec;
 179   if (result < 0)
 180     result = 0;
 181
 182   return curlx_sztosi(result);
 183 }
 184
 185 /**
 186  * Update a fd_set with all of the sockets in use.
 187  */
 188 static void updateFdSet(struct Sockets* sockets, fd_set* fdset,
 189                         curl_socket_t *maxFd)
 190 {
 191   int i;
 192   for (i = 0; i < sockets->count; ++i) {
 193     FD_SET(sockets->sockets[i], fdset);
 194     if (*maxFd < sockets->sockets[i] + 1) {
 195       *maxFd = sockets->sockets[i] + 1;
 196     }
 197   }
 198 }
 199
 200 static void notifyCurl(CURLM *curl, curl_socket_t s, int evBitmask,
 201                        const char *info)
 202 {
 203   int numhandles = 0;
 204   CURLMcode result = curl_multi_socket_action(curl, s, evBitmask, &numhandles);
 205   if (result != CURLM_OK) {
 206     fprintf(stderr, "Curl error on %s: %i (%s)\n",
 207             info, result, curl_multi_strerror(result));
 208   }
 209 }
 210
 211 /**
 212  * Invoke curl when a file descriptor is set.
 213  */
 214 static void checkFdSet(CURLM *curl, struct Sockets *sockets, fd_set *fdset,
 215                        int evBitmask, const char *name)
 216 {
 217   int i;
 218   for (i = 0; i < sockets->count; ++i) {
 219     if (FD_ISSET(sockets->sockets[i], fdset)) {
 220       notifyCurl(curl, sockets->sockets[i], evBitmask, name);
 221     }
 222   }
 223 }
 224
 225 int test(char *URL)
 226 {
 227   int res = 0;
 228   CURL *curl = NULL;
 229   FILE *hd_src = NULL;
 230   int hd ;
 231   int error;
 232   struct_stat file_info;
 233   CURLM *m = NULL;
 234   struct ReadWriteSockets sockets = {{NULL, 0, 0}, {NULL, 0, 0}};
 235   struct timeval timeout = {-1, 0};
 236   int success = 0;
 237
 238   start_test_timing();
 239
 240   if (!libtest_arg3) {
 241     fprintf(stderr, "Usage: lib582 [url] [filename] [username]\n");
 242     return TEST_ERR_USAGE;
 243   }
 244
 245   hd_src = fopen(libtest_arg2, "rb");
 246   if(NULL == hd_src) {
 247     error = ERRNO;
 248     fprintf(stderr, "fopen() failed with error: %d (%s)\n",
 249             error, strerror(error));
 250     fprintf(stderr, "Error opening file: (%s)\n", libtest_arg2);
 251     return TEST_ERR_FOPEN;
 252   }
 253
 254   /* get the file size of the local file */
 255   hd = fstat(fileno(hd_src), &file_info);
 256   if(hd == -1) {
 257     /* can't open file, bail out */
 258     error = ERRNO;
 259     fprintf(stderr, "fstat() failed with error: %d (%s)\n",
 260             error, strerror(error));
 261     fprintf(stderr, "ERROR: cannot open file (%s)\n", libtest_arg2);
 262     fclose(hd_src);
 263     return TEST_ERR_FSTAT;
 264   }
 265   fprintf(stderr, "Set to upload %d bytes\n", (int)file_info.st_size);
 266
 267   res_global_init(CURL_GLOBAL_ALL);
 268   if(res) {
 269     fclose(hd_src);
 270     return res;
 271   }
 272
 273   easy_init(curl);
 274
 275   /* enable uploading */
 276   easy_setopt(curl, CURLOPT_UPLOAD, 1L);
 277
 278   /* specify target */
 279   easy_setopt(curl,CURLOPT_URL, URL);
 280
 281   /* go verbose */
 282   easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 283
 284   /* now specify which file to upload */
 285   easy_setopt(curl, CURLOPT_READDATA, hd_src);
 286
 287   easy_setopt(curl, CURLOPT_USERPWD, libtest_arg3);
 288   easy_setopt(curl, CURLOPT_SSH_PUBLIC_KEYFILE, "curl_client_key.pub");
 289   easy_setopt(curl, CURLOPT_SSH_PRIVATE_KEYFILE, "curl_client_key");
 290
 291   easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)file_info.st_size);
 292
 293   multi_init(m);
 294
 295   multi_setopt(m, CURLMOPT_SOCKETFUNCTION, curlSocketCallback);
 296   multi_setopt(m, CURLMOPT_SOCKETDATA, &sockets);
 297
 298   multi_setopt(m, CURLMOPT_TIMERFUNCTION, curlTimerCallback);
 299   multi_setopt(m, CURLMOPT_TIMERDATA, &timeout);
 300
 301   multi_add_handle(m, curl);
 302
 303   while (!checkForCompletion(m, &success))
 304   {
 305     fd_set readSet, writeSet;
 306     curl_socket_t maxFd = 0;
 307     struct timeval tv = {10, 0};
 308
 309     FD_ZERO(&readSet);
 310     FD_ZERO(&writeSet);
 311     updateFdSet(&sockets.read, &readSet, &maxFd);
 312     updateFdSet(&sockets.write, &writeSet, &maxFd);
 313
 314     if (timeout.tv_sec != -1)
 315     {
 316       int usTimeout = getMicroSecondTimeout(&timeout);
 317       tv.tv_sec = usTimeout / 1000000;
 318       tv.tv_usec = usTimeout % 1000000;
 319     }
 320     else if (maxFd <= 0)
 321     {
 322       tv.tv_sec = 0;
 323       tv.tv_usec = 100000;
 324     }
 325
 326     select_test(maxFd, &readSet, &writeSet, NULL, &tv);
 327
 328     /* Check the sockets for reading / writing */
 329     checkFdSet(m, &sockets.read, &readSet, CURL_CSELECT_IN, "read");
 330     checkFdSet(m, &sockets.write, &writeSet, CURL_CSELECT_OUT, "write");
 331
 332     if (timeout.tv_sec != -1 && getMicroSecondTimeout(&timeout) == 0)
 333     {
 334       /* Curl's timer has elapsed. */
 335       notifyCurl(m, CURL_SOCKET_TIMEOUT, 0, "timeout");
 336     }
 337
 338     abort_on_test_timeout();
 339   }
 340
 341   if (!success)
 342   {
 343     fprintf(stderr, "Error uploading file.\n");
 344     res = TEST_ERR_MAJOR_BAD;
 345   }
 346
 347 test_cleanup:
 348
 349   /* proper cleanup sequence - type PB */
 350
 351   curl_multi_remove_handle(m, curl);
 352   curl_easy_cleanup(curl);
 353   curl_multi_cleanup(m);
 354   curl_global_cleanup();
 355
 356   /* close the local file */
 357   fclose(hd_src);
 358
 359   /* free local memory */
 360   free(sockets.read.sockets);
 361   free(sockets.write.sockets);
 362
 363   return res;
 364 }