← Back to branch summary

~ubuntu-branches/ubuntu/saucy/curl/saucy-proposed

« back to all changes in this revision

Viewing changes to tests/libtest/lib1900.c

  • Committer: Package Import Robot
  • Author(s): Sebastien Bacher
  • Date: 2013-05-07 12:16:37 UTC
  • mfrom: (3.4.37 sid)
  • Revision ID: package-import@ubuntu.com-20130507121637-9t3i98qgsyr9dw5d
Tags: 7.30.0-1ubuntu1
* Resynchronize on Debian. Remaining changes:
  - Drop dependencies not in main:
    + Build-Depends: Drop stunnel4 and libssh2-1-dev.
    + Drop libssh2-1-dev from binary package Depends.
  - Add new libcurl3-udeb package.
  - Add new curl-udeb package.
* Add warning to debian/patches/series.

Show diffs side-by-side

added added

removed removed

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