diff options
Diffstat (limited to 'src/daemon/daemontest_post.c')
-rw-r--r-- | src/daemon/daemontest_post.c | 538 |
1 files changed, 220 insertions, 318 deletions
diff --git a/src/daemon/daemontest_post.c b/src/daemon/daemontest_post.c index 2c020563..61850a24 100644 --- a/src/daemon/daemontest_post.c +++ b/src/daemon/daemontest_post.c | |||
@@ -41,246 +41,187 @@ | |||
41 | 41 | ||
42 | static int oneone; | 42 | static int oneone; |
43 | 43 | ||
44 | struct CBC { | 44 | struct CBC |
45 | char * buf; | 45 | { |
46 | char *buf; | ||
46 | size_t pos; | 47 | size_t pos; |
47 | size_t size; | 48 | size_t size; |
48 | }; | 49 | }; |
49 | 50 | ||
50 | static size_t copyBuffer(void * ptr, | 51 | static size_t |
51 | size_t size, | 52 | copyBuffer (void *ptr, size_t size, size_t nmemb, void *ctx) |
52 | size_t nmemb, | 53 | { |
53 | void * ctx) { | 54 | struct CBC *cbc = ctx; |
54 | struct CBC * cbc = ctx; | ||
55 | 55 | ||
56 | if (cbc->pos + size * nmemb > cbc->size) | 56 | if (cbc->pos + size * nmemb > cbc->size) |
57 | return 0; /* overflow */ | 57 | return 0; /* overflow */ |
58 | memcpy(&cbc->buf[cbc->pos], | 58 | memcpy (&cbc->buf[cbc->pos], ptr, size * nmemb); |
59 | ptr, | ||
60 | size * nmemb); | ||
61 | cbc->pos += size * nmemb; | 59 | cbc->pos += size * nmemb; |
62 | return size * nmemb; | 60 | return size * nmemb; |
63 | } | 61 | } |
64 | 62 | ||
65 | static int ahc_echo(void * cls, | 63 | static int |
66 | struct MHD_Connection * connection, | 64 | ahc_echo (void *cls, |
67 | const char * url, | 65 | struct MHD_Connection *connection, |
68 | const char * method, | 66 | const char *url, |
69 | const char * version, | 67 | const char *method, |
70 | const char * upload_data, | 68 | const char *version, |
71 | unsigned int * upload_data_size) { | 69 | const char *upload_data, unsigned int *upload_data_size) |
72 | struct MHD_Response * response; | 70 | { |
71 | struct MHD_Response *response; | ||
73 | int ret; | 72 | int ret; |
74 | const char * r1; | 73 | const char *r1; |
75 | const char * r2; | 74 | const char *r2; |
76 | 75 | ||
77 | if (0 != strcmp("POST", method)) { | 76 | if (0 != strcmp ("POST", method)) |
78 | printf("METHOD: %s\n", method); | 77 | { |
79 | return MHD_NO; /* unexpected method */ | 78 | printf ("METHOD: %s\n", method); |
80 | } | 79 | return MHD_NO; /* unexpected method */ |
81 | r1 = MHD_lookup_connection_value(connection, | 80 | } |
82 | MHD_POSTDATA_KIND, | 81 | r1 = MHD_lookup_connection_value (connection, MHD_POSTDATA_KIND, "name"); |
83 | "name"); | 82 | r2 = MHD_lookup_connection_value (connection, MHD_POSTDATA_KIND, "project"); |
84 | r2 = MHD_lookup_connection_value(connection, | 83 | if ((r1 != NULL) && |
85 | MHD_POSTDATA_KIND, | 84 | (r2 != NULL) && |
86 | "project"); | 85 | (0 == strcmp ("daniel", r1)) && (0 == strcmp ("curl", r2))) |
87 | if ( (r1 != NULL) && | 86 | { |
88 | (r2 != NULL) && | 87 | response = MHD_create_response_from_data (strlen (url), |
89 | (0 == strcmp("daniel", | 88 | (void *) url, |
90 | r1)) && | 89 | MHD_NO, MHD_YES); |
91 | (0 == strcmp("curl", | 90 | ret = MHD_queue_response (connection, MHD_HTTP_OK, response); |
92 | r2)) ) { | 91 | MHD_destroy_response (response); |
93 | response = MHD_create_response_from_data(strlen(url), | 92 | return MHD_YES; /* done */ |
94 | (void*) url, | 93 | } |
95 | MHD_NO, | ||
96 | MHD_YES); | ||
97 | ret = MHD_queue_response(connection, | ||
98 | MHD_HTTP_OK, | ||
99 | response); | ||
100 | MHD_destroy_response(response); | ||
101 | return MHD_YES; /* done */ | ||
102 | } | ||
103 | return MHD_YES; | 94 | return MHD_YES; |
104 | } | 95 | } |
105 | 96 | ||
106 | 97 | ||
107 | static int testInternalPost() { | 98 | static int |
108 | struct MHD_Daemon * d; | 99 | testInternalPost () |
109 | CURL * c; | 100 | { |
101 | struct MHD_Daemon *d; | ||
102 | CURL *c; | ||
110 | char buf[2048]; | 103 | char buf[2048]; |
111 | struct CBC cbc; | 104 | struct CBC cbc; |
112 | 105 | ||
113 | cbc.buf = buf; | 106 | cbc.buf = buf; |
114 | cbc.size = 2048; | 107 | cbc.size = 2048; |
115 | cbc.pos = 0; | 108 | cbc.pos = 0; |
116 | d = MHD_start_daemon(MHD_USE_SELECT_INTERNALLY | MHD_USE_DEBUG, | 109 | d = MHD_start_daemon (MHD_USE_SELECT_INTERNALLY | MHD_USE_DEBUG, |
117 | 1080, | 110 | 1080, NULL, NULL, &ahc_echo, NULL, MHD_OPTION_END); |
118 | NULL, | ||
119 | NULL, | ||
120 | &ahc_echo, | ||
121 | NULL, | ||
122 | MHD_OPTION_END); | ||
123 | if (d == NULL) | 111 | if (d == NULL) |
124 | return 1; | 112 | return 1; |
125 | c = curl_easy_init(); | 113 | c = curl_easy_init (); |
126 | curl_easy_setopt(c, | 114 | curl_easy_setopt (c, CURLOPT_URL, "http://localhost:1080/hello_world"); |
127 | CURLOPT_URL, | 115 | curl_easy_setopt (c, CURLOPT_WRITEFUNCTION, ©Buffer); |
128 | "http://localhost:1080/hello_world"); | 116 | curl_easy_setopt (c, CURLOPT_WRITEDATA, &cbc); |
129 | curl_easy_setopt(c, | 117 | curl_easy_setopt (c, CURLOPT_POSTFIELDS, POST_DATA); |
130 | CURLOPT_WRITEFUNCTION, | 118 | curl_easy_setopt (c, CURLOPT_POSTFIELDSIZE, strlen (POST_DATA)); |
131 | ©Buffer); | 119 | curl_easy_setopt (c, CURLOPT_POST, 1L); |
132 | curl_easy_setopt(c, | 120 | curl_easy_setopt (c, CURLOPT_FAILONERROR, 1); |
133 | CURLOPT_WRITEDATA, | 121 | curl_easy_setopt (c, CURLOPT_TIMEOUT, 2L); |
134 | &cbc); | ||
135 | curl_easy_setopt(c, | ||
136 | CURLOPT_POSTFIELDS, | ||
137 | POST_DATA); | ||
138 | curl_easy_setopt(c, | ||
139 | CURLOPT_POSTFIELDSIZE, | ||
140 | strlen(POST_DATA)); | ||
141 | curl_easy_setopt(c, | ||
142 | CURLOPT_POST, | ||
143 | 1L); | ||
144 | curl_easy_setopt(c, | ||
145 | CURLOPT_FAILONERROR, | ||
146 | 1); | ||
147 | curl_easy_setopt(c, | ||
148 | CURLOPT_TIMEOUT, | ||
149 | 2L); | ||
150 | if (oneone) | 122 | if (oneone) |
151 | curl_easy_setopt(c, | 123 | curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1); |
152 | CURLOPT_HTTP_VERSION, | ||
153 | CURL_HTTP_VERSION_1_1); | ||
154 | else | 124 | else |
155 | curl_easy_setopt(c, | 125 | curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0); |
156 | CURLOPT_HTTP_VERSION, | 126 | curl_easy_setopt (c, CURLOPT_CONNECTTIMEOUT, 2L); |
157 | CURL_HTTP_VERSION_1_0); | ||
158 | curl_easy_setopt(c, | ||
159 | CURLOPT_CONNECTTIMEOUT, | ||
160 | 2L); | ||
161 | // NOTE: use of CONNECTTIMEOUT without also | 127 | // NOTE: use of CONNECTTIMEOUT without also |
162 | // setting NOSIGNAL results in really weird | 128 | // setting NOSIGNAL results in really weird |
163 | // crashes on my system! | 129 | // crashes on my system! |
164 | curl_easy_setopt(c, | 130 | curl_easy_setopt (c, CURLOPT_NOSIGNAL, 1); |
165 | CURLOPT_NOSIGNAL, | 131 | if (CURLE_OK != curl_easy_perform (c)) |
166 | 1); | 132 | { |
167 | if (CURLE_OK != curl_easy_perform(c)) { | 133 | curl_easy_cleanup (c); |
168 | curl_easy_cleanup(c); | 134 | MHD_stop_daemon (d); |
169 | MHD_stop_daemon(d); | 135 | return 2; |
170 | return 2; | 136 | } |
171 | } | 137 | curl_easy_cleanup (c); |
172 | curl_easy_cleanup(c); | 138 | if (cbc.pos != strlen ("/hello_world")) |
173 | if (cbc.pos != strlen("/hello_world")) { | 139 | { |
174 | MHD_stop_daemon(d); | 140 | MHD_stop_daemon (d); |
175 | return 4; | 141 | return 4; |
176 | } | 142 | } |
177 | 143 | ||
178 | if (0 != strncmp("/hello_world", | 144 | if (0 != strncmp ("/hello_world", cbc.buf, strlen ("/hello_world"))) |
179 | cbc.buf, | 145 | { |
180 | strlen("/hello_world"))) { | 146 | MHD_stop_daemon (d); |
181 | MHD_stop_daemon(d); | 147 | return 8; |
182 | return 8; | 148 | } |
183 | } | 149 | MHD_stop_daemon (d); |
184 | MHD_stop_daemon(d); | ||
185 | 150 | ||
186 | return 0; | 151 | return 0; |
187 | } | 152 | } |
188 | 153 | ||
189 | static int testMultithreadedPost() { | 154 | static int |
190 | struct MHD_Daemon * d; | 155 | testMultithreadedPost () |
191 | CURL * c; | 156 | { |
157 | struct MHD_Daemon *d; | ||
158 | CURL *c; | ||
192 | char buf[2048]; | 159 | char buf[2048]; |
193 | struct CBC cbc; | 160 | struct CBC cbc; |
194 | 161 | ||
195 | cbc.buf = buf; | 162 | cbc.buf = buf; |
196 | cbc.size = 2048; | 163 | cbc.size = 2048; |
197 | cbc.pos = 0; | 164 | cbc.pos = 0; |
198 | d = MHD_start_daemon(MHD_USE_THREAD_PER_CONNECTION |MHD_USE_DEBUG, | 165 | d = MHD_start_daemon (MHD_USE_THREAD_PER_CONNECTION | MHD_USE_DEBUG, |
199 | 1081, | 166 | 1081, NULL, NULL, &ahc_echo, NULL, MHD_OPTION_END); |
200 | NULL, | ||
201 | NULL, | ||
202 | &ahc_echo, | ||
203 | NULL, | ||
204 | MHD_OPTION_END); | ||
205 | if (d == NULL) | 167 | if (d == NULL) |
206 | return 16; | 168 | return 16; |
207 | c = curl_easy_init(); | 169 | c = curl_easy_init (); |
208 | curl_easy_setopt(c, | 170 | curl_easy_setopt (c, CURLOPT_URL, "http://localhost:1081/hello_world"); |
209 | CURLOPT_URL, | 171 | curl_easy_setopt (c, CURLOPT_WRITEFUNCTION, ©Buffer); |
210 | "http://localhost:1081/hello_world"); | 172 | curl_easy_setopt (c, CURLOPT_WRITEDATA, &cbc); |
211 | curl_easy_setopt(c, | 173 | curl_easy_setopt (c, CURLOPT_POSTFIELDS, POST_DATA); |
212 | CURLOPT_WRITEFUNCTION, | 174 | curl_easy_setopt (c, CURLOPT_POSTFIELDSIZE, strlen (POST_DATA)); |
213 | ©Buffer); | 175 | curl_easy_setopt (c, CURLOPT_POST, 1L); |
214 | curl_easy_setopt(c, | 176 | curl_easy_setopt (c, CURLOPT_FAILONERROR, 1); |
215 | CURLOPT_WRITEDATA, | 177 | curl_easy_setopt (c, CURLOPT_TIMEOUT, 2L); |
216 | &cbc); | ||
217 | curl_easy_setopt(c, | ||
218 | CURLOPT_POSTFIELDS, | ||
219 | POST_DATA); | ||
220 | curl_easy_setopt(c, | ||
221 | CURLOPT_POSTFIELDSIZE, | ||
222 | strlen(POST_DATA)); | ||
223 | curl_easy_setopt(c, | ||
224 | CURLOPT_POST, | ||
225 | 1L); | ||
226 | curl_easy_setopt(c, | ||
227 | CURLOPT_FAILONERROR, | ||
228 | 1); | ||
229 | curl_easy_setopt(c, | ||
230 | CURLOPT_TIMEOUT, | ||
231 | 2L); | ||
232 | if (oneone) | 178 | if (oneone) |
233 | curl_easy_setopt(c, | 179 | curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1); |
234 | CURLOPT_HTTP_VERSION, | ||
235 | CURL_HTTP_VERSION_1_1); | ||
236 | else | 180 | else |
237 | curl_easy_setopt(c, | 181 | curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0); |
238 | CURLOPT_HTTP_VERSION, | 182 | curl_easy_setopt (c, CURLOPT_CONNECTTIMEOUT, 2L); |
239 | CURL_HTTP_VERSION_1_0); | ||
240 | curl_easy_setopt(c, | ||
241 | CURLOPT_CONNECTTIMEOUT, | ||
242 | 2L); | ||
243 | // NOTE: use of CONNECTTIMEOUT without also | 183 | // NOTE: use of CONNECTTIMEOUT without also |
244 | // setting NOSIGNAL results in really weird | 184 | // setting NOSIGNAL results in really weird |
245 | // crashes on my system! | 185 | // crashes on my system! |
246 | curl_easy_setopt(c, | 186 | curl_easy_setopt (c, CURLOPT_NOSIGNAL, 1); |
247 | CURLOPT_NOSIGNAL, | 187 | if (CURLE_OK != curl_easy_perform (c)) |
248 | 1); | 188 | { |
249 | if (CURLE_OK != curl_easy_perform(c)) { | 189 | curl_easy_cleanup (c); |
250 | curl_easy_cleanup(c); | 190 | MHD_stop_daemon (d); |
251 | MHD_stop_daemon(d); | 191 | return 32; |
252 | return 32; | 192 | } |
253 | } | 193 | curl_easy_cleanup (c); |
254 | curl_easy_cleanup(c); | 194 | if (cbc.pos != strlen ("/hello_world")) |
255 | if (cbc.pos != strlen("/hello_world")) { | 195 | { |
256 | MHD_stop_daemon(d); | 196 | MHD_stop_daemon (d); |
257 | return 64; | 197 | return 64; |
258 | } | 198 | } |
259 | if (0 != strncmp("/hello_world", | 199 | if (0 != strncmp ("/hello_world", cbc.buf, strlen ("/hello_world"))) |
260 | cbc.buf, | 200 | { |
261 | strlen("/hello_world"))) { | 201 | MHD_stop_daemon (d); |
262 | MHD_stop_daemon(d); | 202 | return 128; |
263 | return 128; | 203 | } |
264 | } | 204 | MHD_stop_daemon (d); |
265 | MHD_stop_daemon(d); | ||
266 | 205 | ||
267 | return 0; | 206 | return 0; |
268 | } | 207 | } |
269 | 208 | ||
270 | 209 | ||
271 | static int testExternalPost() { | 210 | static int |
272 | struct MHD_Daemon * d; | 211 | testExternalPost () |
273 | CURL * c; | 212 | { |
213 | struct MHD_Daemon *d; | ||
214 | CURL *c; | ||
274 | char buf[2048]; | 215 | char buf[2048]; |
275 | struct CBC cbc; | 216 | struct CBC cbc; |
276 | CURLM * multi; | 217 | CURLM *multi; |
277 | CURLMcode mret; | 218 | CURLMcode mret; |
278 | fd_set rs; | 219 | fd_set rs; |
279 | fd_set ws; | 220 | fd_set ws; |
280 | fd_set es; | 221 | fd_set es; |
281 | int max; | 222 | int max; |
282 | int running; | 223 | int running; |
283 | struct CURLMsg * msg; | 224 | struct CURLMsg *msg; |
284 | time_t start; | 225 | time_t start; |
285 | struct timeval tv; | 226 | struct timeval tv; |
286 | 227 | ||
@@ -288,163 +229,124 @@ static int testExternalPost() { | |||
288 | cbc.buf = buf; | 229 | cbc.buf = buf; |
289 | cbc.size = 2048; | 230 | cbc.size = 2048; |
290 | cbc.pos = 0; | 231 | cbc.pos = 0; |
291 | d = MHD_start_daemon(MHD_USE_DEBUG, | 232 | d = MHD_start_daemon (MHD_USE_DEBUG, |
292 | 1082, | 233 | 1082, NULL, NULL, &ahc_echo, NULL, MHD_OPTION_END); |
293 | NULL, | ||
294 | NULL, | ||
295 | &ahc_echo, | ||
296 | NULL, | ||
297 | MHD_OPTION_END); | ||
298 | if (d == NULL) | 234 | if (d == NULL) |
299 | return 256; | 235 | return 256; |
300 | c = curl_easy_init(); | 236 | c = curl_easy_init (); |
301 | curl_easy_setopt(c, | 237 | curl_easy_setopt (c, CURLOPT_URL, "http://localhost:1082/hello_world"); |
302 | CURLOPT_URL, | 238 | curl_easy_setopt (c, CURLOPT_WRITEFUNCTION, ©Buffer); |
303 | "http://localhost:1082/hello_world"); | 239 | curl_easy_setopt (c, CURLOPT_WRITEDATA, &cbc); |
304 | curl_easy_setopt(c, | 240 | curl_easy_setopt (c, CURLOPT_POSTFIELDS, POST_DATA); |
305 | CURLOPT_WRITEFUNCTION, | 241 | curl_easy_setopt (c, CURLOPT_POSTFIELDSIZE, strlen (POST_DATA)); |
306 | ©Buffer); | 242 | curl_easy_setopt (c, CURLOPT_POST, 1L); |
307 | curl_easy_setopt(c, | 243 | curl_easy_setopt (c, CURLOPT_FAILONERROR, 1); |
308 | CURLOPT_WRITEDATA, | 244 | curl_easy_setopt (c, CURLOPT_TIMEOUT, 5L); |
309 | &cbc); | ||
310 | curl_easy_setopt(c, | ||
311 | CURLOPT_POSTFIELDS, | ||
312 | POST_DATA); | ||
313 | curl_easy_setopt(c, | ||
314 | CURLOPT_POSTFIELDSIZE, | ||
315 | strlen(POST_DATA)); | ||
316 | curl_easy_setopt(c, | ||
317 | CURLOPT_POST, | ||
318 | 1L); | ||
319 | curl_easy_setopt(c, | ||
320 | CURLOPT_FAILONERROR, | ||
321 | 1); | ||
322 | curl_easy_setopt(c, | ||
323 | CURLOPT_TIMEOUT, | ||
324 | 5L); | ||
325 | if (oneone) | 245 | if (oneone) |
326 | curl_easy_setopt(c, | 246 | curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1); |
327 | CURLOPT_HTTP_VERSION, | ||
328 | CURL_HTTP_VERSION_1_1); | ||
329 | else | 247 | else |
330 | curl_easy_setopt(c, | 248 | curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0); |
331 | CURLOPT_HTTP_VERSION, | 249 | curl_easy_setopt (c, CURLOPT_CONNECTTIMEOUT, 5L); |
332 | CURL_HTTP_VERSION_1_0); | ||
333 | curl_easy_setopt(c, | ||
334 | CURLOPT_CONNECTTIMEOUT, | ||
335 | 5L); | ||
336 | // NOTE: use of CONNECTTIMEOUT without also | 250 | // NOTE: use of CONNECTTIMEOUT without also |
337 | // setting NOSIGNAL results in really weird | 251 | // setting NOSIGNAL results in really weird |
338 | // crashes on my system! | 252 | // crashes on my system! |
339 | curl_easy_setopt(c, | 253 | curl_easy_setopt (c, CURLOPT_NOSIGNAL, 1); |
340 | CURLOPT_NOSIGNAL, | ||
341 | 1); | ||
342 | 254 | ||
343 | 255 | ||
344 | multi = curl_multi_init(); | 256 | multi = curl_multi_init (); |
345 | if (multi == NULL) { | 257 | if (multi == NULL) |
346 | curl_easy_cleanup(c); | 258 | { |
347 | MHD_stop_daemon(d); | 259 | curl_easy_cleanup (c); |
348 | return 512; | 260 | MHD_stop_daemon (d); |
349 | } | 261 | return 512; |
350 | mret = curl_multi_add_handle(multi, c); | 262 | } |
351 | if (mret != CURLM_OK) { | 263 | mret = curl_multi_add_handle (multi, c); |
352 | curl_multi_cleanup(multi); | 264 | if (mret != CURLM_OK) |
353 | curl_easy_cleanup(c); | 265 | { |
354 | MHD_stop_daemon(d); | 266 | curl_multi_cleanup (multi); |
355 | return 1024; | 267 | curl_easy_cleanup (c); |
356 | } | 268 | MHD_stop_daemon (d); |
357 | start = time(NULL); | 269 | return 1024; |
358 | while ( (time(NULL) - start < 5) && | 270 | } |
359 | (multi != NULL) ) { | 271 | start = time (NULL); |
360 | max = 0; | 272 | while ((time (NULL) - start < 5) && (multi != NULL)) |
361 | FD_ZERO(&rs); | 273 | { |
362 | FD_ZERO(&ws); | 274 | max = 0; |
363 | FD_ZERO(&es); | 275 | FD_ZERO (&rs); |
364 | curl_multi_perform(multi, &running); | 276 | FD_ZERO (&ws); |
365 | mret = curl_multi_fdset(multi, | 277 | FD_ZERO (&es); |
366 | &rs, | 278 | curl_multi_perform (multi, &running); |
367 | &ws, | 279 | mret = curl_multi_fdset (multi, &rs, &ws, &es, &max); |
368 | &es, | 280 | if (mret != CURLM_OK) |
369 | &max); | 281 | { |
370 | if (mret != CURLM_OK) { | 282 | curl_multi_remove_handle (multi, c); |
371 | curl_multi_remove_handle(multi, c); | 283 | curl_multi_cleanup (multi); |
372 | curl_multi_cleanup(multi); | 284 | curl_easy_cleanup (c); |
373 | curl_easy_cleanup(c); | 285 | MHD_stop_daemon (d); |
374 | MHD_stop_daemon(d); | 286 | return 2048; |
375 | return 2048; | 287 | } |
288 | if (MHD_YES != MHD_get_fdset (d, &rs, &ws, &es, &max)) | ||
289 | { | ||
290 | curl_multi_remove_handle (multi, c); | ||
291 | curl_multi_cleanup (multi); | ||
292 | curl_easy_cleanup (c); | ||
293 | MHD_stop_daemon (d); | ||
294 | return 4096; | ||
295 | } | ||
296 | tv.tv_sec = 0; | ||
297 | tv.tv_usec = 1000; | ||
298 | select (max + 1, &rs, &ws, &es, &tv); | ||
299 | curl_multi_perform (multi, &running); | ||
300 | if (running == 0) | ||
301 | { | ||
302 | msg = curl_multi_info_read (multi, &running); | ||
303 | if (msg == NULL) | ||
304 | break; | ||
305 | if (msg->msg == CURLMSG_DONE) | ||
306 | { | ||
307 | if (msg->data.result != CURLE_OK) | ||
308 | printf ("%s failed at %s:%d: `%s'\n", | ||
309 | "curl_multi_perform", | ||
310 | __FILE__, | ||
311 | __LINE__, curl_easy_strerror (msg->data.result)); | ||
312 | curl_multi_remove_handle (multi, c); | ||
313 | curl_multi_cleanup (multi); | ||
314 | curl_easy_cleanup (c); | ||
315 | c = NULL; | ||
316 | multi = NULL; | ||
317 | } | ||
318 | } | ||
319 | MHD_run (d); | ||
376 | } | 320 | } |
377 | if (MHD_YES != MHD_get_fdset(d, | 321 | if (multi != NULL) |
378 | &rs, | 322 | { |
379 | &ws, | 323 | curl_multi_remove_handle (multi, c); |
380 | &es, | 324 | curl_easy_cleanup (c); |
381 | &max)) { | 325 | curl_multi_cleanup (multi); |
382 | curl_multi_remove_handle(multi, c); | ||
383 | curl_multi_cleanup(multi); | ||
384 | curl_easy_cleanup(c); | ||
385 | MHD_stop_daemon(d); | ||
386 | return 4096; | ||
387 | } | 326 | } |
388 | tv.tv_sec = 0; | 327 | MHD_stop_daemon (d); |
389 | tv.tv_usec = 1000; | 328 | if (cbc.pos != strlen ("/hello_world")) |
390 | select(max + 1, | ||
391 | &rs, | ||
392 | &ws, | ||
393 | &es, | ||
394 | &tv); | ||
395 | curl_multi_perform(multi, &running); | ||
396 | if (running == 0) { | ||
397 | msg = curl_multi_info_read(multi, | ||
398 | &running); | ||
399 | if (msg == NULL) | ||
400 | break; | ||
401 | if (msg->msg == CURLMSG_DONE) { | ||
402 | if (msg->data.result != CURLE_OK) | ||
403 | printf("%s failed at %s:%d: `%s'\n", | ||
404 | "curl_multi_perform", | ||
405 | __FILE__, | ||
406 | __LINE__, | ||
407 | curl_easy_strerror(msg->data.result)); | ||
408 | curl_multi_remove_handle(multi, c); | ||
409 | curl_multi_cleanup(multi); | ||
410 | curl_easy_cleanup(c); | ||
411 | c = NULL; | ||
412 | multi = NULL; | ||
413 | } | ||
414 | } | ||
415 | MHD_run(d); | ||
416 | } | ||
417 | if (multi != NULL) { | ||
418 | curl_multi_remove_handle(multi, c); | ||
419 | curl_easy_cleanup(c); | ||
420 | curl_multi_cleanup(multi); | ||
421 | } | ||
422 | MHD_stop_daemon(d); | ||
423 | if (cbc.pos != strlen("/hello_world")) | ||
424 | return 8192; | 329 | return 8192; |
425 | if (0 != strncmp("/hello_world", | 330 | if (0 != strncmp ("/hello_world", cbc.buf, strlen ("/hello_world"))) |
426 | cbc.buf, | ||
427 | strlen("/hello_world"))) | ||
428 | return 16384; | 331 | return 16384; |
429 | return 0; | 332 | return 0; |
430 | } | 333 | } |
431 | 334 | ||
432 | 335 | ||
433 | 336 | ||
434 | int main(int argc, | 337 | int |
435 | char * const * argv) { | 338 | main (int argc, char *const *argv) |
339 | { | ||
436 | unsigned int errorCount = 0; | 340 | unsigned int errorCount = 0; |
437 | 341 | ||
438 | oneone = NULL != strstr(argv[0], "11"); | 342 | oneone = NULL != strstr (argv[0], "11"); |
439 | if (0 != curl_global_init(CURL_GLOBAL_WIN32)) | 343 | if (0 != curl_global_init (CURL_GLOBAL_WIN32)) |
440 | return 2; | 344 | return 2; |
441 | errorCount += testInternalPost(); | 345 | errorCount += testInternalPost (); |
442 | errorCount += testMultithreadedPost(); | 346 | errorCount += testMultithreadedPost (); |
443 | errorCount += testExternalPost(); | 347 | errorCount += testExternalPost (); |
444 | if (errorCount != 0) | 348 | if (errorCount != 0) |
445 | fprintf(stderr, | 349 | fprintf (stderr, "Error (code: %u)\n", errorCount); |
446 | "Error (code: %u)\n", | 350 | curl_global_cleanup (); |
447 | errorCount); | 351 | return errorCount != 0; /* 0 == pass */ |
448 | curl_global_cleanup(); | ||
449 | return errorCount != 0; /* 0 == pass */ | ||
450 | } | 352 | } |