1/*************************************************************************** 2 * _ _ ____ _ 3 * Project ___| | | | _ \| | 4 * / __| | | | |_) | | 5 * | (__| |_| | _ <| |___ 6 * \___|\___/|_| \_\_____| 7 * 8 * Copyright (C) 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 https://curl.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 * SPDX-License-Identifier: curl 22 * 23 ***************************************************************************/ 24 25/* 26 * The purpose of this test is to make sure that if CURLMOPT_SOCKETFUNCTION or 27 * CURLMOPT_TIMERFUNCTION returns error, the associated transfer should be 28 * aborted correctly. 29 */ 30 31#include "test.h" 32 33#include <fcntl.h> 34 35#include "testutil.h" 36#include "warnless.h" 37#include "memdebug.h" 38 39#define TEST_HANG_TIMEOUT 60 * 1000 40 41struct Sockets 42{ 43 curl_socket_t *sockets; 44 int count; /* number of sockets actually stored in array */ 45 int max_count; /* max number of sockets that fit in allocated array */ 46}; 47 48struct ReadWriteSockets 49{ 50 struct Sockets read, write; 51}; 52 53/** 54 * Remove a file descriptor from a sockets array. 55 */ 56static void removeFd(struct Sockets *sockets, curl_socket_t fd, int mention) 57{ 58 int i; 59 60 if(mention) 61 fprintf(stderr, "Remove socket fd %d\n", (int) fd); 62 63 for(i = 0; i < sockets->count; ++i) { 64 if(sockets->sockets[i] == fd) { 65 if(i < sockets->count - 1) 66 memmove(&sockets->sockets[i], &sockets->sockets[i + 1], 67 sizeof(curl_socket_t) * (sockets->count - (i + 1))); 68 --sockets->count; 69 } 70 } 71} 72 73/** 74 * Add a file descriptor to a sockets array. 75 * Return 0 on success, 1 on error. 76 */ 77static int addFd(struct Sockets *sockets, curl_socket_t fd, const char *what) 78{ 79 /** 80 * To ensure we only have each file descriptor once, we remove it then add 81 * it again. 82 */ 83 fprintf(stderr, "Add socket fd %d for %s\n", (int) fd, what); 84 removeFd(sockets, fd, 0); 85 /* 86 * Allocate array storage when required. 87 */ 88 if(!sockets->sockets) { 89 sockets->sockets = malloc(sizeof(curl_socket_t) * 20U); 90 if(!sockets->sockets) 91 return 1; 92 sockets->max_count = 20; 93 } 94 else if(sockets->count + 1 > sockets->max_count) { 95 curl_socket_t *ptr = realloc(sockets->sockets, sizeof(curl_socket_t) * 96 (sockets->max_count + 20)); 97 if(!ptr) 98 /* cleanup in test_cleanup */ 99 return 1; 100 sockets->sockets = ptr; 101 sockets->max_count += 20; 102 } 103 /* 104 * Add file descriptor to array. 105 */ 106 sockets->sockets[sockets->count] = fd; 107 ++sockets->count; 108 return 0; 109} 110 111static int max_socket_calls; 112static int socket_calls = 0; 113 114/** 115 * Callback invoked by curl to poll reading / writing of a socket. 116 */ 117static int curlSocketCallback(CURL *easy, curl_socket_t s, int action, 118 void *userp, void *socketp) 119{ 120 struct ReadWriteSockets *sockets = userp; 121 122 (void)easy; /* unused */ 123 (void)socketp; /* unused */ 124 125 fprintf(stderr, "CURLMOPT_SOCKETFUNCTION called: %u\n", socket_calls++); 126 if(socket_calls == max_socket_calls) { 127 fprintf(stderr, "curlSocketCallback returns error\n"); 128 return -1; 129 } 130 131 if(action == CURL_POLL_IN || action == CURL_POLL_INOUT) 132 if(addFd(&sockets->read, s, "read")) 133 return -1; /* bail out */ 134 135 if(action == CURL_POLL_OUT || action == CURL_POLL_INOUT) 136 if(addFd(&sockets->write, s, "write")) 137 return -1; 138 139 if(action == CURL_POLL_REMOVE) { 140 removeFd(&sockets->read, s, 1); 141 removeFd(&sockets->write, s, 0); 142 } 143 144 return 0; 145} 146 147static int max_timer_calls; 148static int timer_calls = 0; 149 150/** 151 * Callback invoked by curl to set a timeout. 152 */ 153static int curlTimerCallback(CURLM *multi, long timeout_ms, void *userp) 154{ 155 struct timeval *timeout = userp; 156 157 (void)multi; /* unused */ 158 fprintf(stderr, "CURLMOPT_TIMERFUNCTION called: %u\n", timer_calls++); 159 if(timer_calls == max_timer_calls) { 160 fprintf(stderr, "curlTimerCallback returns error\n"); 161 return -1; 162 } 163 if(timeout_ms != -1) { 164 *timeout = tutil_tvnow(); 165 timeout->tv_usec += (int)timeout_ms * 1000; 166 } 167 else { 168 timeout->tv_sec = -1; 169 } 170 return 0; 171} 172 173/** 174 * Check for curl completion. 175 */ 176static int checkForCompletion(CURLM *curl, int *success) 177{ 178 int result = 0; 179 *success = 0; 180 while(1) { 181 int numMessages; 182 CURLMsg *message = curl_multi_info_read(curl, &numMessages); 183 if(!message) 184 break; 185 if(message->msg == CURLMSG_DONE) { 186 result = 1; 187 if(message->data.result == CURLE_OK) 188 *success = 1; 189 else 190 *success = 0; 191 } 192 else { 193 fprintf(stderr, "Got an unexpected message from curl: %i\n", 194 (int)message->msg); 195 result = 1; 196 *success = 0; 197 } 198 } 199 return result; 200} 201 202static int getMicroSecondTimeout(struct timeval *timeout) 203{ 204 struct timeval now; 205 ssize_t result; 206 now = tutil_tvnow(); 207 result = (ssize_t)((timeout->tv_sec - now.tv_sec) * 1000000 + 208 timeout->tv_usec - now.tv_usec); 209 if(result < 0) 210 result = 0; 211 212 return curlx_sztosi(result); 213} 214 215/** 216 * Update a fd_set with all of the sockets in use. 217 */ 218static void updateFdSet(struct Sockets *sockets, fd_set* fdset, 219 curl_socket_t *maxFd) 220{ 221 int i; 222 for(i = 0; i < sockets->count; ++i) { 223 FD_SET(sockets->sockets[i], fdset); 224 if(*maxFd < sockets->sockets[i] + 1) { 225 *maxFd = sockets->sockets[i] + 1; 226 } 227 } 228} 229 230static int socket_action(CURLM *curl, curl_socket_t s, int evBitmask, 231 const char *info) 232{ 233 int numhandles = 0; 234 CURLMcode result = curl_multi_socket_action(curl, s, evBitmask, &numhandles); 235 if(result != CURLM_OK) { 236 fprintf(stderr, "Curl error on %s: %i (%s)\n", 237 info, result, curl_multi_strerror(result)); 238 } 239 return (int)result; 240} 241 242/** 243 * Invoke curl when a file descriptor is set. 244 */ 245static int checkFdSet(CURLM *curl, 246 struct Sockets *sockets, fd_set *fdset, 247 int evBitmask, const char *name) 248{ 249 int i; 250 int result = 0; 251 for(i = 0; i < sockets->count; ++i) { 252 if(FD_ISSET(sockets->sockets[i], fdset)) { 253 result = socket_action(curl, sockets->sockets[i], evBitmask, name); 254 if(result) 255 break; 256 } 257 } 258 return result; 259} 260 261static int testone(char *URL, int timercb, int socketcb) 262{ 263 int res = 0; 264 CURL *curl = NULL; CURLM *m = NULL; 265 struct ReadWriteSockets sockets = {{NULL, 0, 0}, {NULL, 0, 0}}; 266 struct timeval timeout = {-1, 0}; 267 int success = 0; 268 269 /* set the limits */ 270 max_timer_calls = timercb; 271 max_socket_calls = socketcb; 272 timer_calls = 0; /* reset the globals */ 273 socket_calls = 0; 274 275 fprintf(stderr, "start test: %d %d\n", timercb, socketcb); 276 start_test_timing(); 277 278 res_global_init(CURL_GLOBAL_ALL); 279 if(res) 280 return res; 281 282 easy_init(curl); 283 284 /* specify target */ 285 easy_setopt(curl, CURLOPT_URL, URL); 286 287 /* go verbose */ 288 easy_setopt(curl, CURLOPT_VERBOSE, 1L); 289 290 multi_init(m); 291 292 multi_setopt(m, CURLMOPT_SOCKETFUNCTION, curlSocketCallback); 293 multi_setopt(m, CURLMOPT_SOCKETDATA, &sockets); 294 295 multi_setopt(m, CURLMOPT_TIMERFUNCTION, curlTimerCallback); 296 multi_setopt(m, CURLMOPT_TIMERDATA, &timeout); 297 298 multi_add_handle(m, curl); 299 300 res = socket_action(m, CURL_SOCKET_TIMEOUT, 0, "timeout"); 301 if(res) 302 goto test_cleanup; 303 304 while(!checkForCompletion(m, &success)) { 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 int usTimeout = getMicroSecondTimeout(&timeout); 316 tv.tv_sec = usTimeout / 1000000; 317 tv.tv_usec = usTimeout % 1000000; 318 } 319 else if(maxFd <= 0) { 320 tv.tv_sec = 0; 321 tv.tv_usec = 100000; 322 } 323 324 assert(maxFd); 325 select_test((int)maxFd, &readSet, &writeSet, NULL, &tv); 326 327 /* Check the sockets for reading / writing */ 328 res = checkFdSet(m, &sockets.read, &readSet, CURL_CSELECT_IN, "read"); 329 if(res) 330 goto test_cleanup; 331 res = checkFdSet(m, &sockets.write, &writeSet, CURL_CSELECT_OUT, "write"); 332 if(res) 333 goto test_cleanup; 334 335 if(timeout.tv_sec != -1 && getMicroSecondTimeout(&timeout) == 0) { 336 /* Curl's timer has elapsed. */ 337 res = socket_action(m, CURL_SOCKET_TIMEOUT, 0, "timeout"); 338 if(res) 339 goto test_cleanup; 340 } 341 342 abort_on_test_timeout(); 343 } 344 345 if(!success) { 346 fprintf(stderr, "Error getting file.\n"); 347 res = TEST_ERR_MAJOR_BAD; 348 } 349 350test_cleanup: 351 352 /* proper cleanup sequence */ 353 fprintf(stderr, "cleanup: %d %d\n", timercb, socketcb); 354 curl_multi_remove_handle(m, curl); 355 curl_easy_cleanup(curl); 356 curl_multi_cleanup(m); 357 curl_global_cleanup(); 358 359 /* free local memory */ 360 free(sockets.read.sockets); 361 free(sockets.write.sockets); 362 return res; 363} 364 365int test(char *URL) 366{ 367 int rc; 368 /* rerun the same transfer multiple times and make it fail in different 369 callback calls */ 370 rc = testone(URL, 0, 0); 371 if(rc) 372 fprintf(stderr, "test 0/0 failed: %d\n", rc); 373 374 rc = testone(URL, 1, 0); 375 if(!rc) 376 fprintf(stderr, "test 1/0 failed: %d\n", rc); 377 378 rc = testone(URL, 2, 0); 379 if(!rc) 380 fprintf(stderr, "test 2/0 failed: %d\n", rc); 381 382 rc = testone(URL, 0, 1); 383 if(!rc) 384 fprintf(stderr, "test 0/1 failed: %d\n", rc); 385 386 rc = testone(URL, 0, 2); 387 if(!rc) 388 fprintf(stderr, "test 0/2 failed: %d\n", rc); 389 390 return 0; 391} 392