tests/libtest/lib1900.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 2013 - 2016, Linus Nielsen Feltzing, <linus@haxx.se>
   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 https://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 "testutil.h"
  25 #include "warnless.h"
  26 #include "memdebug.h"
  27
  28 #define TEST_HANG_TIMEOUT 60 * 1000
  29 #define MAX_URLS 200
  30 #define MAX_BLACKLIST 20
  31
  32 int urltime[MAX_URLS];
  33 char *urlstring[MAX_URLS];
  34 CURL *handles[MAX_URLS];
  35 char *site_blacklist[MAX_BLACKLIST];
  36 char *server_blacklist[MAX_BLACKLIST];
  37 int num_handles;
  38 int blacklist_num_servers;
  39 int blacklist_num_sites;
  40
  41 static size_t
  42 write_callback(void *contents, size_t size, size_t nmemb, void *userp)
  43 {
  44   size_t realsize = size * nmemb;
  45   (void)contents;
  46   (void)userp;
  47
  48   return realsize;
  49 }
  50
  51 static int parse_url_file(const char *filename)
  52 {
  53   FILE *f;
  54   int filetime;
  55   char buf[200];
  56
  57   num_handles = 0;
  58   blacklist_num_sites = 0;
  59   blacklist_num_servers = 0;
  60
  61   f = fopen(filename, "rb");
  62   if(!f)
  63     return 0;
  64
  65   while(!feof(f)) {
  66     if(fscanf(f, "%d %s\n", &filetime, buf)) {
  67       urltime[num_handles] = filetime;
  68       urlstring[num_handles] = strdup(buf);
  69       num_handles++;
  70       continue;
  71     }
  72
  73     if(fscanf(f, "blacklist_site %s\n", buf)) {
  74       site_blacklist[blacklist_num_sites] = strdup(buf);
  75       blacklist_num_sites++;
  76       continue;
  77     }
  78
  79     break;
  80   }
  81   fclose(f);
  82
  83   site_blacklist[blacklist_num_sites] = NULL;
  84   server_blacklist[blacklist_num_servers] = NULL;
  85   return num_handles;
  86 }
  87
  88 static void free_urls(void)
  89 {
  90   int i;
  91   for(i = 0;i < num_handles;i++) {
  92     Curl_safefree(urlstring[i]);
  93   }
  94   for(i = 0;i < blacklist_num_servers;i++) {
  95     Curl_safefree(server_blacklist[i]);
  96   }
  97   for(i = 0;i < blacklist_num_sites;i++) {
  98     Curl_safefree(site_blacklist[i]);
  99   }
 100 }
 101
 102 static int create_handles(void)
 103 {
 104   int i;
 105
 106   for(i = 0;i < num_handles;i++) {
 107     handles[i] = curl_easy_init();
 108   }
 109   return 0;
 110 }
 111
 112 static void setup_handle(char *base_url, CURLM *m, int handlenum)
 113 {
 114   char urlbuf[256];
 115
 116   snprintf(urlbuf, sizeof(urlbuf), "%s%s", base_url, urlstring[handlenum]);
 117   curl_easy_setopt(handles[handlenum], CURLOPT_URL, urlbuf);
 118   curl_easy_setopt(handles[handlenum], CURLOPT_VERBOSE, 1L);
 119   curl_easy_setopt(handles[handlenum], CURLOPT_FAILONERROR, 1L);
 120   curl_easy_setopt(handles[handlenum], CURLOPT_WRITEFUNCTION, write_callback);
 121   curl_easy_setopt(handles[handlenum], CURLOPT_WRITEDATA, NULL);
 122   curl_multi_add_handle(m, handles[handlenum]);
 123 }
 124
 125 static void remove_handles(void)
 126 {
 127   int i;
 128
 129   for(i = 0;i < num_handles;i++) {
 130     if(handles[i])
 131       curl_easy_cleanup(handles[i]);
 132   }
 133 }
 134
 135 int test(char *URL)
 136 {
 137   int res = 0;
 138   CURLM *m = NULL;
 139   CURLMsg *msg; /* for picking up messages with the transfer status */
 140   int msgs_left; /* how many messages are left */
 141   int running;
 142   int handlenum = 0;
 143   struct timeval last_handle_add;
 144
 145   if(parse_url_file("log/urls.txt") <= 0)
 146     goto test_cleanup;
 147
 148   start_test_timing();
 149
 150   curl_global_init(CURL_GLOBAL_ALL);
 151
 152   multi_init(m);
 153
 154   create_handles();
 155
 156   multi_setopt(m, CURLMOPT_PIPELINING, 1L);
 157   multi_setopt(m, CURLMOPT_MAX_HOST_CONNECTIONS, 2L);
 158   multi_setopt(m, CURLMOPT_MAX_PIPELINE_LENGTH, 3L);
 159   multi_setopt(m, CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE, 15000L);
 160   multi_setopt(m, CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE, 10000L);
 161
 162   multi_setopt(m, CURLMOPT_PIPELINING_SITE_BL, site_blacklist);
 163   multi_setopt(m, CURLMOPT_PIPELINING_SERVER_BL, server_blacklist);
 164
 165   last_handle_add = tutil_tvnow();
 166
 167   for(;;) {
 168     struct timeval interval;
 169     struct timeval now;
 170     long int msnow, mslast;
 171     fd_set rd, wr, exc;
 172     int maxfd = -99;
 173     long timeout;
 174
 175     interval.tv_sec = 1;
 176     interval.tv_usec = 0;
 177
 178     if(handlenum < num_handles) {
 179       now = tutil_tvnow();
 180       msnow = now.tv_sec * 1000 + now.tv_usec / 1000;
 181       mslast = last_handle_add.tv_sec * 1000 + last_handle_add.tv_usec / 1000;
 182       if((msnow - mslast) >= urltime[handlenum]) {
 183         fprintf(stdout, "Adding handle %d\n", handlenum);
 184         setup_handle(URL, m, handlenum);
 185         last_handle_add = now;
 186         handlenum++;
 187       }
 188     }
 189
 190     curl_multi_perform(m, &running);
 191
 192     abort_on_test_timeout();
 193
 194     /* See how the transfers went */
 195     while((msg = curl_multi_info_read(m, &msgs_left))) {
 196       if(msg->msg == CURLMSG_DONE) {
 197         int i, found = 0;
 198
 199         /* Find out which handle this message is about */
 200         for(i = 0; i < num_handles; i++) {
 201           found = (msg->easy_handle == handles[i]);
 202           if(found)
 203             break;
 204         }
 205
 206         printf("Handle %d Completed with status %d\n", i, msg->data.result);
 207         curl_multi_remove_handle(m, handles[i]);
 208       }
 209     }
 210
 211     if(handlenum == num_handles && !running) {
 212       break; /* done */
 213     }
 214
 215     FD_ZERO(&rd);
 216     FD_ZERO(&wr);
 217     FD_ZERO(&exc);
 218
 219     curl_multi_fdset(m, &rd, &wr, &exc, &maxfd);
 220
 221     /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 222
 223     curl_multi_timeout(m, &timeout);
 224
 225     if(timeout < 0)
 226       timeout = 1;
 227
 228     interval.tv_sec = timeout / 1000;
 229     interval.tv_usec = (timeout % 1000) * 1000;
 230
 231     interval.tv_sec = 0;
 232     interval.tv_usec = 1000;
 233
 234     select_test(maxfd+1, &rd, &wr, &exc, &interval);
 235
 236     abort_on_test_timeout();
 237   }
 238
 239 test_cleanup:
 240
 241   remove_handles();
 242
 243   /* undocumented cleanup sequence - type UB */
 244
 245   curl_multi_cleanup(m);
 246   curl_global_cleanup();
 247
 248   free_urls();
 249   return res;
 250 }