From: Viktor Szakats Date: Fri, 31 Oct 2025 17:36:43 +0000 (+0100) Subject: tests/libtest: consistent variable naming for easy/multi/share handles X-Git-Tag: curl-8_17_0~40 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=d2f0a0e7961301a2d1181ed7e3926201d60870a0;p=thirdparty%2Fcurl.git tests/libtest: consistent variable naming for easy/multi/share handles Follow-up to 928363f28ca533d743adcb70597c3e30917c6cbd #19299 Closes #19311 --- diff --git a/tests/libtest/cli_h2_pausing.c b/tests/libtest/cli_h2_pausing.c index c3a51cf4da..692b0a3211 100644 --- a/tests/libtest/cli_h2_pausing.c +++ b/tests/libtest/cli_h2_pausing.c @@ -46,7 +46,7 @@ struct handle int resumed; int errored; int fail_write; - CURL *h; + CURL *curl; }; static size_t cb(char *data, size_t size, size_t nmemb, void *clientp) @@ -56,7 +56,7 @@ static size_t cb(char *data, size_t size, size_t nmemb, void *clientp) curl_off_t totalsize; (void)data; - if(curl_easy_getinfo(handle->h, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T, + if(curl_easy_getinfo(handle->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T, &totalsize) == CURLE_OK) curl_mfprintf(stderr, "INFO: [%zu] write, " "Content-Length %" CURL_FORMAT_CURL_OFF_T "\n", @@ -83,7 +83,7 @@ static size_t cb(char *data, size_t size, size_t nmemb, void *clientp) static CURLcode test_cli_h2_pausing(const char *URL) { struct handle handles[2]; - CURLM *multi_handle = NULL; + CURLM *multi = NULL; int still_running = 1, msgs_left, numfds; size_t i; CURLMsg *msg; @@ -174,35 +174,39 @@ static CURLcode test_cli_h2_pausing(const char *URL) handles[i].resumed = 0; handles[i].errored = 0; handles[i].fail_write = 1; - handles[i].h = curl_easy_init(); - if(!handles[i].h || - curl_easy_setopt(handles[i].h, CURLOPT_WRITEFUNCTION, cb) != CURLE_OK || - curl_easy_setopt(handles[i].h, CURLOPT_WRITEDATA, &handles[i]) + handles[i].curl = curl_easy_init(); + if(!handles[i].curl || + curl_easy_setopt(handles[i].curl, CURLOPT_WRITEFUNCTION, cb) != CURLE_OK || - curl_easy_setopt(handles[i].h, CURLOPT_FOLLOWLOCATION, 1L) != CURLE_OK || - curl_easy_setopt(handles[i].h, CURLOPT_VERBOSE, 1L) != CURLE_OK || - curl_easy_setopt(handles[i].h, CURLOPT_DEBUGFUNCTION, cli_debug_cb) + curl_easy_setopt(handles[i].curl, CURLOPT_WRITEDATA, &handles[i]) != CURLE_OK || - curl_easy_setopt(handles[i].h, CURLOPT_SSL_VERIFYPEER, 0L) != CURLE_OK || - curl_easy_setopt(handles[i].h, CURLOPT_RESOLVE, resolve) != CURLE_OK || - curl_easy_setopt(handles[i].h, CURLOPT_PIPEWAIT, 1L) || - curl_easy_setopt(handles[i].h, CURLOPT_URL, url) != CURLE_OK) { + curl_easy_setopt(handles[i].curl, CURLOPT_FOLLOWLOCATION, 1L) + != CURLE_OK || + curl_easy_setopt(handles[i].curl, CURLOPT_VERBOSE, 1L) != CURLE_OK || + curl_easy_setopt(handles[i].curl, CURLOPT_DEBUGFUNCTION, cli_debug_cb) + != CURLE_OK || + curl_easy_setopt(handles[i].curl, CURLOPT_SSL_VERIFYPEER, 0L) + != CURLE_OK || + curl_easy_setopt(handles[i].curl, CURLOPT_RESOLVE, resolve) + != CURLE_OK || + curl_easy_setopt(handles[i].curl, CURLOPT_PIPEWAIT, 1L) != CURLE_OK || + curl_easy_setopt(handles[i].curl, CURLOPT_URL, url) != CURLE_OK) { curl_mfprintf(stderr, "failed configuring easy handle - bailing out\n"); result = (CURLcode)2; goto cleanup; } - curl_easy_setopt(handles[i].h, CURLOPT_HTTP_VERSION, http_version); + curl_easy_setopt(handles[i].curl, CURLOPT_HTTP_VERSION, http_version); } - multi_handle = curl_multi_init(); - if(!multi_handle) { + multi = curl_multi_init(); + if(!multi) { curl_mfprintf(stderr, "curl_multi_init() failed - bailing out\n"); result = (CURLcode)2; goto cleanup; } for(i = 0; i < CURL_ARRAYSIZE(handles); i++) { - if(curl_multi_add_handle(multi_handle, handles[i].h) != CURLM_OK) { + if(curl_multi_add_handle(multi, handles[i].curl) != CURLM_OK) { curl_mfprintf(stderr, "curl_multi_add_handle() failed - bailing out\n"); result = (CURLcode)2; goto cleanup; @@ -211,7 +215,7 @@ static CURLcode test_cli_h2_pausing(const char *URL) for(rounds = 0;; rounds++) { curl_mfprintf(stderr, "INFO: multi_perform round %d\n", rounds); - if(curl_multi_perform(multi_handle, &still_running) != CURLM_OK) { + if(curl_multi_perform(multi, &still_running) != CURLM_OK) { curl_mfprintf(stderr, "curl_multi_perform() failed - bailing out\n"); result = (CURLcode)2; goto cleanup; @@ -248,17 +252,17 @@ static CURLcode test_cli_h2_pausing(const char *URL) break; } - if(curl_multi_poll(multi_handle, NULL, 0, 100, &numfds) != CURLM_OK) { + if(curl_multi_poll(multi, NULL, 0, 100, &numfds) != CURLM_OK) { curl_mfprintf(stderr, "curl_multi_poll() failed - bailing out\n"); result = (CURLcode)2; goto cleanup; } /* !checksrc! disable EQUALSNULL 1 */ - while((msg = curl_multi_info_read(multi_handle, &msgs_left)) != NULL) { + while((msg = curl_multi_info_read(multi, &msgs_left)) != NULL) { if(msg->msg == CURLMSG_DONE) { for(i = 0; i < CURL_ARRAYSIZE(handles); i++) { - if(msg->easy_handle == handles[i].h) { + if(msg->easy_handle == handles[i].curl) { if(handles[i].paused != 1 || !handles[i].resumed) { curl_mfprintf(stderr, "ERROR: [%zu] done, paused=%d, " "resumed=%d, result %d - wtf?\n", i, @@ -291,7 +295,7 @@ static CURLcode test_cli_h2_pausing(const char *URL) for(i = 0; i < CURL_ARRAYSIZE(handles); i++) { curl_mfprintf(stderr, "INFO: [%zu] resumed\n", i); handles[i].resumed = 1; - curl_easy_pause(handles[i].h, CURLPAUSE_CONT); + curl_easy_pause(handles[i].curl, CURLPAUSE_CONT); } } } @@ -299,15 +303,15 @@ static CURLcode test_cli_h2_pausing(const char *URL) cleanup: for(i = 0; i < CURL_ARRAYSIZE(handles); i++) { - curl_multi_remove_handle(multi_handle, handles[i].h); - curl_easy_cleanup(handles[i].h); + curl_multi_remove_handle(multi, handles[i].curl); + curl_easy_cleanup(handles[i].curl); } curl_slist_free_all(resolve); curl_free(host); curl_free(port); curl_url_cleanup(cu); - curl_multi_cleanup(multi_handle); + curl_multi_cleanup(multi); curl_global_cleanup(); return result; diff --git a/tests/libtest/cli_h2_serverpush.c b/tests/libtest/cli_h2_serverpush.c index 59688447b1..6936b3b0d6 100644 --- a/tests/libtest/cli_h2_serverpush.c +++ b/tests/libtest/cli_h2_serverpush.c @@ -28,26 +28,26 @@ static FILE *out_download = NULL; -static int setup_h2_serverpush(CURL *hnd, const char *url) +static int setup_h2_serverpush(CURL *curl, const char *url) { out_download = curlx_fopen("download_0.data", "wb"); if(!out_download) return 1; /* failed */ - curl_easy_setopt(hnd, CURLOPT_URL, url); - curl_easy_setopt(hnd, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0); - curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYPEER, 0L); - curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYHOST, 0L); + curl_easy_setopt(curl, CURLOPT_URL, url); + curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0); + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L); + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L); - curl_easy_setopt(hnd, CURLOPT_WRITEDATA, out_download); + curl_easy_setopt(curl, CURLOPT_WRITEDATA, out_download); /* please be verbose */ - curl_easy_setopt(hnd, CURLOPT_VERBOSE, 1L); - curl_easy_setopt(hnd, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); - curl_easy_setopt(hnd, CURLOPT_DEBUGDATA, &debug_config); + curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); + curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); + curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config); /* wait for pipe connection to confirm */ - curl_easy_setopt(hnd, CURLOPT_PIPEWAIT, 1L); + curl_easy_setopt(curl, CURLOPT_PIPEWAIT, 1L); return 0; /* all is good */ } @@ -56,7 +56,7 @@ static FILE *out_push = NULL; /* called when there is an incoming push */ static int server_push_callback(CURL *parent, - CURL *easy, + CURL *curl, size_t num_headers, struct curl_pushheaders *headers, void *userp) @@ -80,7 +80,7 @@ static int server_push_callback(CURL *parent, } /* write to this file */ - curl_easy_setopt(easy, CURLOPT_WRITEDATA, out_push); + curl_easy_setopt(curl, CURLOPT_WRITEDATA, out_push); curl_mfprintf(stderr, "**** push callback approves stream %u, " "got %zu headers!\n", count, num_headers); @@ -106,8 +106,8 @@ static int server_push_callback(CURL *parent, */ static CURLcode test_cli_h2_serverpush(const char *URL) { - CURL *easy = NULL; - CURLM *multi_handle; + CURL *curl = NULL; + CURLM *multi; int transfers = 1; /* we start with one */ CURLcode result = CURLE_OK; @@ -124,38 +124,38 @@ static CURLcode test_cli_h2_serverpush(const char *URL) return (CURLcode)3; } - multi_handle = curl_multi_init(); - if(!multi_handle) { + multi = curl_multi_init(); + if(!multi) { result = (CURLcode)1; goto cleanup; } - easy = curl_easy_init(); - if(!easy) { + curl = curl_easy_init(); + if(!curl) { result = (CURLcode)1; goto cleanup; } - if(setup_h2_serverpush(easy, URL)) { + if(setup_h2_serverpush(curl, URL)) { curl_mfprintf(stderr, "failed\n"); result = (CURLcode)1; goto cleanup; } - curl_multi_setopt(multi_handle, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX); - curl_multi_setopt(multi_handle, CURLMOPT_PUSHFUNCTION, server_push_callback); - curl_multi_setopt(multi_handle, CURLMOPT_PUSHDATA, &transfers); + curl_multi_setopt(multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX); + curl_multi_setopt(multi, CURLMOPT_PUSHFUNCTION, server_push_callback); + curl_multi_setopt(multi, CURLMOPT_PUSHDATA, &transfers); - curl_multi_add_handle(multi_handle, easy); + curl_multi_add_handle(multi, curl); do { struct CURLMsg *m; int still_running; /* keep number of running handles */ - CURLMcode mc = curl_multi_perform(multi_handle, &still_running); + CURLMcode mc = curl_multi_perform(multi, &still_running); if(still_running) /* wait for activity, timeout or "nothing" */ - mc = curl_multi_poll(multi_handle, NULL, 0, 1000, NULL); + mc = curl_multi_poll(multi, NULL, 0, 1000, NULL); if(mc) break; @@ -167,12 +167,12 @@ static CURLcode test_cli_h2_serverpush(const char *URL) */ do { int msgq = 0; - m = curl_multi_info_read(multi_handle, &msgq); + m = curl_multi_info_read(multi, &msgq); if(m && (m->msg == CURLMSG_DONE)) { - CURL *e = m->easy_handle; + CURL *easy = m->easy_handle; transfers--; - curl_multi_remove_handle(multi_handle, e); - curl_easy_cleanup(e); + curl_multi_remove_handle(multi, easy); + curl_easy_cleanup(easy); } } while(m); @@ -180,7 +180,7 @@ static CURLcode test_cli_h2_serverpush(const char *URL) cleanup: - curl_multi_cleanup(multi_handle); + curl_multi_cleanup(multi); if(out_download) curlx_fclose(out_download); diff --git a/tests/libtest/cli_h2_upgrade_extreme.c b/tests/libtest/cli_h2_upgrade_extreme.c index 7dc8f67816..eb05493800 100644 --- a/tests/libtest/cli_h2_upgrade_extreme.c +++ b/tests/libtest/cli_h2_upgrade_extreme.c @@ -37,7 +37,7 @@ static size_t write_h2_upg_extreme_cb(char *ptr, size_t size, size_t nmemb, static CURLcode test_cli_h2_upgrade_extreme(const char *URL) { CURLM *multi = NULL; - CURL *easy; + CURL *curl; CURLMcode mc; int running_handles = 0, start_count, numfds; CURLMsg *msg; @@ -64,33 +64,33 @@ static CURLcode test_cli_h2_upgrade_extreme(const char *URL) start_count = 200; do { if(start_count) { - easy = curl_easy_init(); - if(!easy) { + curl = curl_easy_init(); + if(!curl) { curl_mfprintf(stderr, "curl_easy_init failed\n"); goto cleanup; } - curl_easy_setopt(easy, CURLOPT_VERBOSE, 1L); - curl_easy_setopt(easy, CURLOPT_DEBUGFUNCTION, cli_debug_cb); - curl_easy_setopt(easy, CURLOPT_URL, URL); - curl_easy_setopt(easy, CURLOPT_NOSIGNAL, 1L); - curl_easy_setopt(easy, CURLOPT_AUTOREFERER, 1L); - curl_easy_setopt(easy, CURLOPT_FAILONERROR, 1L); - curl_easy_setopt(easy, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0); - curl_easy_setopt(easy, CURLOPT_WRITEFUNCTION, write_h2_upg_extreme_cb); - curl_easy_setopt(easy, CURLOPT_WRITEDATA, NULL); - curl_easy_setopt(easy, CURLOPT_HTTPGET, 1L); + curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); + curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, cli_debug_cb); + curl_easy_setopt(curl, CURLOPT_URL, URL); + curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L); + curl_easy_setopt(curl, CURLOPT_AUTOREFERER, 1L); + curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1L); + curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0); + curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_h2_upg_extreme_cb); + curl_easy_setopt(curl, CURLOPT_WRITEDATA, NULL); + curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L); curl_msnprintf(range, sizeof(range), "%" CURL_FORMAT_CURL_OFF_TU "-" "%" CURL_FORMAT_CURL_OFF_TU, (curl_off_t)0, (curl_off_t)16384); - curl_easy_setopt(easy, CURLOPT_RANGE, range); + curl_easy_setopt(curl, CURLOPT_RANGE, range); - mc = curl_multi_add_handle(multi, easy); + mc = curl_multi_add_handle(multi, curl); if(mc != CURLM_OK) { curl_mfprintf(stderr, "curl_multi_add_handle: %s\n", curl_multi_strerror(mc)); - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); goto cleanup; } --start_count; diff --git a/tests/libtest/cli_hx_download.c b/tests/libtest/cli_hx_download.c index a12d0e95c2..b7ad5912a9 100644 --- a/tests/libtest/cli_hx_download.c +++ b/tests/libtest/cli_hx_download.c @@ -51,7 +51,7 @@ static int verbose_d = 1; struct transfer_d { size_t idx; - CURL *easy; + CURL *curl; char filename[128]; FILE *out; curl_off_t recv_size; @@ -70,11 +70,11 @@ static size_t transfer_count_d = 1; static struct transfer_d *transfer_d; static int forbid_reuse_d = 0; -static struct transfer_d *get_transfer_for_easy_d(CURL *easy) +static struct transfer_d *get_transfer_for_easy_d(CURL *curl) { size_t i; for(i = 0; i < transfer_count_d; ++i) { - if(easy == transfer_d[i].easy) + if(curl == transfer_d[i].curl) return &transfer_d[i]; } return NULL; @@ -143,7 +143,7 @@ static int my_progress_d_cb(void *userdata, CURLcode res; t->checked_ssl = TRUE; - res = curl_easy_getinfo(t->easy, CURLINFO_TLS_SSL_PTR, &tls); + res = curl_easy_getinfo(t->curl, CURLINFO_TLS_SSL_PTR, &tls); if(res) { curl_mfprintf(stderr, "[t-%zu] info CURLINFO_TLS_SSL_PTR failed: %d\n", t->idx, res); @@ -212,40 +212,40 @@ static int my_progress_d_cb(void *userdata, return 0; } -static int setup_hx_download(CURL *hnd, const char *url, struct transfer_d *t, +static int setup_hx_download(CURL *curl, const char *url, struct transfer_d *t, long http_version, struct curl_slist *host, CURLSH *share, int use_earlydata, int fresh_connect) { - curl_easy_setopt(hnd, CURLOPT_SHARE, share); - curl_easy_setopt(hnd, CURLOPT_URL, url); - curl_easy_setopt(hnd, CURLOPT_HTTP_VERSION, http_version); - curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYPEER, 0L); - curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYHOST, 0L); - curl_easy_setopt(hnd, CURLOPT_ACCEPT_ENCODING, ""); - curl_easy_setopt(hnd, CURLOPT_BUFFERSIZE, (long)(128 * 1024)); - curl_easy_setopt(hnd, CURLOPT_WRITEFUNCTION, my_write_d_cb); - curl_easy_setopt(hnd, CURLOPT_WRITEDATA, t); - curl_easy_setopt(hnd, CURLOPT_NOPROGRESS, 0L); - curl_easy_setopt(hnd, CURLOPT_XFERINFOFUNCTION, my_progress_d_cb); - curl_easy_setopt(hnd, CURLOPT_XFERINFODATA, t); + curl_easy_setopt(curl, CURLOPT_SHARE, share); + curl_easy_setopt(curl, CURLOPT_URL, url); + curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, http_version); + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L); + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L); + curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, ""); + curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, (long)(128 * 1024)); + curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, my_write_d_cb); + curl_easy_setopt(curl, CURLOPT_WRITEDATA, t); + curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L); + curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, my_progress_d_cb); + curl_easy_setopt(curl, CURLOPT_XFERINFODATA, t); if(use_earlydata) - curl_easy_setopt(hnd, CURLOPT_SSL_OPTIONS, CURLSSLOPT_EARLYDATA); + curl_easy_setopt(curl, CURLOPT_SSL_OPTIONS, CURLSSLOPT_EARLYDATA); if(forbid_reuse_d) - curl_easy_setopt(hnd, CURLOPT_FORBID_REUSE, 1L); + curl_easy_setopt(curl, CURLOPT_FORBID_REUSE, 1L); if(host) - curl_easy_setopt(hnd, CURLOPT_RESOLVE, host); + curl_easy_setopt(curl, CURLOPT_RESOLVE, host); if(fresh_connect) - curl_easy_setopt(hnd, CURLOPT_FRESH_CONNECT, 1L); + curl_easy_setopt(curl, CURLOPT_FRESH_CONNECT, 1L); /* please be verbose */ if(verbose_d) { - curl_easy_setopt(hnd, CURLOPT_VERBOSE, 1L); - curl_easy_setopt(hnd, CURLOPT_DEBUGFUNCTION, cli_debug_cb); + curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); + curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, cli_debug_cb); } /* wait for pipe connection to confirm */ - curl_easy_setopt(hnd, CURLOPT_PIPEWAIT, 1L); + curl_easy_setopt(curl, CURLOPT_PIPEWAIT, 1L); return 0; /* all is good */ } @@ -278,7 +278,7 @@ static void usage_hx_download(const char *msg) */ static CURLcode test_cli_hx_download(const char *URL) { - CURLM *multi_handle = NULL; + CURLM *multi = NULL; struct CURLMsg *m; CURLSH *share = NULL; const char *url; @@ -405,11 +405,11 @@ static CURLcode test_cli_hx_download(const char *URL) goto cleanup; } - multi_handle = curl_multi_init(); - curl_multi_setopt(multi_handle, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX); - curl_multi_setopt(multi_handle, CURLMOPT_MAX_TOTAL_CONNECTIONS, + multi = curl_multi_init(); + curl_multi_setopt(multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX); + curl_multi_setopt(multi, CURLMOPT_MAX_TOTAL_CONNECTIONS, (long)max_total_conns); - curl_multi_setopt(multi_handle, CURLMOPT_MAX_HOST_CONNECTIONS, + curl_multi_setopt(multi, CURLMOPT_MAX_HOST_CONNECTIONS, (long)max_host_conns); active_transfers = 0; @@ -424,15 +424,15 @@ static CURLcode test_cli_hx_download(const char *URL) n = (max_parallel < transfer_count_d) ? max_parallel : transfer_count_d; for(i = 0; i < n; ++i) { t = &transfer_d[i]; - t->easy = curl_easy_init(); - if(!t->easy || - setup_hx_download(t->easy, url, t, http_version, host, share, + t->curl = curl_easy_init(); + if(!t->curl || + setup_hx_download(t->curl, url, t, http_version, host, share, use_earlydata, fresh_connect)) { curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i); result = (CURLcode)1; goto cleanup; } - curl_multi_add_handle(multi_handle, t->easy); + curl_multi_add_handle(multi, t->curl); t->started = 1; ++active_transfers; curl_mfprintf(stderr, "[t-%zu] STARTED\n", t->idx); @@ -440,11 +440,11 @@ static CURLcode test_cli_hx_download(const char *URL) do { int still_running; /* keep number of running handles */ - CURLMcode mc = curl_multi_perform(multi_handle, &still_running); + CURLMcode mc = curl_multi_perform(multi, &still_running); if(still_running) { /* wait for activity, timeout or "nothing" */ - mc = curl_multi_poll(multi_handle, NULL, 0, 1000, NULL); + mc = curl_multi_poll(multi, NULL, 0, 1000, NULL); } if(mc) @@ -452,12 +452,12 @@ static CURLcode test_cli_hx_download(const char *URL) do { int msgq = 0; - m = curl_multi_info_read(multi_handle, &msgq); + m = curl_multi_info_read(multi, &msgq); if(m && (m->msg == CURLMSG_DONE)) { - CURL *e = m->easy_handle; + CURL *easy = m->easy_handle; --active_transfers; - curl_multi_remove_handle(multi_handle, e); - t = get_transfer_for_easy_d(e); + curl_multi_remove_handle(multi, easy); + t = get_transfer_for_easy_d(easy); if(t) { t->done = 1; t->result = m->data.result; @@ -465,13 +465,13 @@ static CURLcode test_cli_hx_download(const char *URL) t->idx, t->result); if(use_earlydata) { curl_off_t sent; - curl_easy_getinfo(e, CURLINFO_EARLYDATA_SENT_T, &sent); + curl_easy_getinfo(easy, CURLINFO_EARLYDATA_SENT_T, &sent); curl_mfprintf(stderr, "[t-%zu] EarlyData: " "%" CURL_FORMAT_CURL_OFF_T "\n", t->idx, sent); } } else { - curl_easy_cleanup(e); + curl_easy_cleanup(easy); curl_mfprintf(stderr, "unknown FINISHED???\n"); } } @@ -481,8 +481,8 @@ static CURLcode test_cli_hx_download(const char *URL) /* abort paused transfers */ for(i = 0; i < transfer_count_d; ++i) { t = &transfer_d[i]; - if(!t->done && t->paused && t->easy) { - curl_multi_remove_handle(multi_handle, t->easy); + if(!t->done && t->paused && t->curl) { + curl_multi_remove_handle(multi, t->curl); t->done = 1; active_transfers--; curl_mfprintf(stderr, "[t-%zu] ABORTED\n", t->idx); @@ -496,7 +496,7 @@ static CURLcode test_cli_hx_download(const char *URL) if(!t->done && t->paused) { t->resumed = 1; t->paused = 0; - curl_easy_pause(t->easy, CURLPAUSE_CONT); + curl_easy_pause(t->curl, CURLPAUSE_CONT); curl_mfprintf(stderr, "[t-%zu] RESUMED\n", t->idx); break; } @@ -507,15 +507,15 @@ static CURLcode test_cli_hx_download(const char *URL) for(i = 0; i < transfer_count_d; ++i) { t = &transfer_d[i]; if(!t->started) { - t->easy = curl_easy_init(); - if(!t->easy || - setup_hx_download(t->easy, url, t, http_version, host, share, + t->curl = curl_easy_init(); + if(!t->curl || + setup_hx_download(t->curl, url, t, http_version, host, share, use_earlydata, fresh_connect)) { curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i); result = (CURLcode)1; goto cleanup; } - curl_multi_add_handle(multi_handle, t->easy); + curl_multi_add_handle(multi, t->curl); t->started = 1; ++active_transfers; curl_mfprintf(stderr, "[t-%zu] STARTED\n", t->idx); @@ -532,7 +532,7 @@ static CURLcode test_cli_hx_download(const char *URL) cleanup: - curl_multi_cleanup(multi_handle); + curl_multi_cleanup(multi); if(transfer_d) { for(i = 0; i < transfer_count_d; ++i) { @@ -541,9 +541,9 @@ cleanup: curlx_fclose(t->out); t->out = NULL; } - if(t->easy) { - curl_easy_cleanup(t->easy); - t->easy = NULL; + if(t->curl) { + curl_easy_cleanup(t->curl); + t->curl = NULL; } if(t->result) result = t->result; diff --git a/tests/libtest/cli_hx_upload.c b/tests/libtest/cli_hx_upload.c index 646836cb37..5069bcab63 100644 --- a/tests/libtest/cli_hx_upload.c +++ b/tests/libtest/cli_hx_upload.c @@ -30,7 +30,7 @@ static int verbose_u = 1; struct transfer_u { size_t idx; - CURL *easy; + CURL *curl; const char *method; char filename[128]; curl_mime *mime; @@ -51,11 +51,11 @@ static size_t transfer_count_u = 1; static struct transfer_u *transfer_u; static int forbid_reuse_u = 0; -static struct transfer_u *get_transfer_for_easy_u(CURL *easy) +static struct transfer_u *get_transfer_for_easy_u(CURL *curl) { size_t i; for(i = 0; i < transfer_count_u; ++i) { - if(easy == transfer_u[i].easy) + if(curl == transfer_u[i].curl) return &transfer_u[i]; } return NULL; @@ -142,62 +142,62 @@ static int my_progress_u_cb(void *userdata, return 0; } -static int setup_hx_upload(CURL *hnd, const char *url, struct transfer_u *t, +static int setup_hx_upload(CURL *curl, const char *url, struct transfer_u *t, long http_version, struct curl_slist *host, CURLSH *share, int use_earlydata, int announce_length) { - curl_easy_setopt(hnd, CURLOPT_SHARE, share); - curl_easy_setopt(hnd, CURLOPT_URL, url); - curl_easy_setopt(hnd, CURLOPT_HTTP_VERSION, http_version); - curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYPEER, 0L); - curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYHOST, 0L); - curl_easy_setopt(hnd, CURLOPT_BUFFERSIZE, (long)(128 * 1024)); - curl_easy_setopt(hnd, CURLOPT_FOLLOWLOCATION, CURLFOLLOW_OBEYCODE); - curl_easy_setopt(hnd, CURLOPT_WRITEFUNCTION, my_write_u_cb); - curl_easy_setopt(hnd, CURLOPT_WRITEDATA, t); + curl_easy_setopt(curl, CURLOPT_SHARE, share); + curl_easy_setopt(curl, CURLOPT_URL, url); + curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, http_version); + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L); + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L); + curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, (long)(128 * 1024)); + curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, CURLFOLLOW_OBEYCODE); + curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, my_write_u_cb); + curl_easy_setopt(curl, CURLOPT_WRITEDATA, t); if(use_earlydata) - curl_easy_setopt(hnd, CURLOPT_SSL_OPTIONS, CURLSSLOPT_EARLYDATA); + curl_easy_setopt(curl, CURLOPT_SSL_OPTIONS, CURLSSLOPT_EARLYDATA); if(!strcmp("MIME", t->method)) { curl_mimepart *part; - t->mime = curl_mime_init(hnd); + t->mime = curl_mime_init(curl); part = curl_mime_addpart(t->mime); curl_mime_name(part, "file"); curl_mime_data_cb(part, -1, my_read_cb, NULL, NULL, t); - curl_easy_setopt(hnd, CURLOPT_MIMEPOST, t->mime); + curl_easy_setopt(curl, CURLOPT_MIMEPOST, t->mime); } else { if(!t->method || !strcmp("PUT", t->method)) - curl_easy_setopt(hnd, CURLOPT_UPLOAD, 1L); + curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L); else if(!strcmp("POST", t->method)) - curl_easy_setopt(hnd, CURLOPT_POST, 1L); + curl_easy_setopt(curl, CURLOPT_POST, 1L); else { curl_mfprintf(stderr, "unsupported method '%s'\n", t->method); return 1; } - curl_easy_setopt(hnd, CURLOPT_READFUNCTION, my_read_cb); - curl_easy_setopt(hnd, CURLOPT_READDATA, t); + curl_easy_setopt(curl, CURLOPT_READFUNCTION, my_read_cb); + curl_easy_setopt(curl, CURLOPT_READDATA, t); if(announce_length) - curl_easy_setopt(hnd, CURLOPT_INFILESIZE_LARGE, t->send_total); + curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, t->send_total); } - curl_easy_setopt(hnd, CURLOPT_NOPROGRESS, 0L); - curl_easy_setopt(hnd, CURLOPT_XFERINFOFUNCTION, my_progress_u_cb); - curl_easy_setopt(hnd, CURLOPT_XFERINFODATA, t); + curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L); + curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, my_progress_u_cb); + curl_easy_setopt(curl, CURLOPT_XFERINFODATA, t); if(forbid_reuse_u) - curl_easy_setopt(hnd, CURLOPT_FORBID_REUSE, 1L); + curl_easy_setopt(curl, CURLOPT_FORBID_REUSE, 1L); if(host) - curl_easy_setopt(hnd, CURLOPT_RESOLVE, host); + curl_easy_setopt(curl, CURLOPT_RESOLVE, host); /* please be verbose */ if(verbose_u) { - curl_easy_setopt(hnd, CURLOPT_VERBOSE, 1L); - curl_easy_setopt(hnd, CURLOPT_DEBUGFUNCTION, cli_debug_cb); + curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); + curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, cli_debug_cb); } /* wait for pipe connection to confirm */ - curl_easy_setopt(hnd, CURLOPT_PIPEWAIT, 1L); + curl_easy_setopt(curl, CURLOPT_PIPEWAIT, 1L); return 0; /* all is good */ } @@ -227,7 +227,7 @@ static void usage_hx_upload(const char *msg) */ static CURLcode test_cli_hx_upload(const char *URL) { - CURLM *multi_handle; + CURLM *multi; CURLSH *share; const char *url; const char *method = "PUT"; @@ -369,8 +369,8 @@ static CURLcode test_cli_hx_upload(const char *URL) } if(reuse_easy) { - CURL *easy = curl_easy_init(); - if(!easy) { + CURL *curl = curl_easy_init(); + if(!curl) { curl_mfprintf(stderr, "failed to init easy handle\n"); result = (CURLcode)1; goto cleanup; @@ -378,8 +378,8 @@ static CURLcode test_cli_hx_upload(const char *URL) for(i = 0; i < transfer_count_u; ++i) { CURLcode rc; t = &transfer_u[i]; - t->easy = easy; - if(setup_hx_upload(t->easy, url, t, http_version, host, share, + t->curl = curl; + if(setup_hx_upload(t->curl, url, t, http_version, host, share, use_earlydata, announce_length)) { curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i); result = (CURLcode)1; @@ -387,28 +387,28 @@ static CURLcode test_cli_hx_upload(const char *URL) } curl_mfprintf(stderr, "[t-%zu] STARTING\n", t->idx); - rc = curl_easy_perform(easy); + rc = curl_easy_perform(curl); curl_mfprintf(stderr, "[t-%zu] DONE -> %d\n", t->idx, rc); - t->easy = NULL; - curl_easy_reset(easy); + t->curl = NULL; + curl_easy_reset(curl); } - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); } else { - multi_handle = curl_multi_init(); - curl_multi_setopt(multi_handle, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX); + multi = curl_multi_init(); + curl_multi_setopt(multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX); n = (max_parallel < transfer_count_u) ? max_parallel : transfer_count_u; for(i = 0; i < n; ++i) { t = &transfer_u[i]; - t->easy = curl_easy_init(); - if(!t->easy || setup_hx_upload(t->easy, url, t, http_version, host, + t->curl = curl_easy_init(); + if(!t->curl || setup_hx_upload(t->curl, url, t, http_version, host, share, use_earlydata, announce_length)) { curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i); result = (CURLcode)1; goto cleanup; } - curl_multi_add_handle(multi_handle, t->easy); + curl_multi_add_handle(multi, t->curl); t->started = 1; ++active_transfers; curl_mfprintf(stderr, "[t-%zu] STARTED\n", t->idx); @@ -416,12 +416,12 @@ static CURLcode test_cli_hx_upload(const char *URL) do { int still_running; /* keep number of running handles */ - CURLMcode mc = curl_multi_perform(multi_handle, &still_running); + CURLMcode mc = curl_multi_perform(multi, &still_running); struct CURLMsg *m; if(still_running) { /* wait for activity, timeout or "nothing" */ - mc = curl_multi_poll(multi_handle, NULL, 0, 1000, NULL); + mc = curl_multi_poll(multi, NULL, 0, 1000, NULL); } if(mc) @@ -429,28 +429,28 @@ static CURLcode test_cli_hx_upload(const char *URL) do { int msgq = 0; - m = curl_multi_info_read(multi_handle, &msgq); + m = curl_multi_info_read(multi, &msgq); if(m && (m->msg == CURLMSG_DONE)) { - CURL *e = m->easy_handle; + CURL *easy = m->easy_handle; --active_transfers; - curl_multi_remove_handle(multi_handle, e); - t = get_transfer_for_easy_u(e); + curl_multi_remove_handle(multi, easy); + t = get_transfer_for_easy_u(easy); if(t) { long res_status; - curl_easy_getinfo(e, CURLINFO_RESPONSE_CODE, &res_status); + curl_easy_getinfo(easy, CURLINFO_RESPONSE_CODE, &res_status); t->done = 1; curl_mfprintf(stderr, "[t-%zu] FINISHED, " "result=%d, response=%ld\n", t->idx, m->data.result, res_status); if(use_earlydata) { curl_off_t sent; - curl_easy_getinfo(e, CURLINFO_EARLYDATA_SENT_T, &sent); + curl_easy_getinfo(easy, CURLINFO_EARLYDATA_SENT_T, &sent); curl_mfprintf(stderr, "[t-%zu] EarlyData: " "%" CURL_FORMAT_CURL_OFF_T "\n", t->idx, sent); } } else { - curl_easy_cleanup(e); + curl_easy_cleanup(easy); curl_mfprintf(stderr, "unknown FINISHED???\n"); } } @@ -461,8 +461,8 @@ static CURLcode test_cli_hx_upload(const char *URL) /* abort paused transfers */ for(i = 0; i < transfer_count_u; ++i) { t = &transfer_u[i]; - if(!t->done && t->paused && t->easy) { - curl_multi_remove_handle(multi_handle, t->easy); + if(!t->done && t->paused && t->curl) { + curl_multi_remove_handle(multi, t->curl); t->done = 1; active_transfers--; curl_mfprintf(stderr, "[t-%zu] ABORTED\n", t->idx); @@ -476,7 +476,7 @@ static CURLcode test_cli_hx_upload(const char *URL) if(!t->done && t->paused) { t->resumed = 1; t->paused = 0; - curl_easy_pause(t->easy, CURLPAUSE_CONT); + curl_easy_pause(t->curl, CURLPAUSE_CONT); curl_mfprintf(stderr, "[t-%zu] RESUMED\n", t->idx); break; } @@ -487,15 +487,15 @@ static CURLcode test_cli_hx_upload(const char *URL) for(i = 0; i < transfer_count_u; ++i) { t = &transfer_u[i]; if(!t->started) { - t->easy = curl_easy_init(); - if(!t->easy || setup_hx_upload(t->easy, url, t, http_version, + t->curl = curl_easy_init(); + if(!t->curl || setup_hx_upload(t->curl, url, t, http_version, host, share, use_earlydata, announce_length)) { curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i); result = (CURLcode)1; goto cleanup; } - curl_multi_add_handle(multi_handle, t->easy); + curl_multi_add_handle(multi, t->curl); t->started = 1; ++active_transfers; curl_mfprintf(stderr, "[t-%zu] STARTED\n", t->idx); @@ -511,7 +511,7 @@ static CURLcode test_cli_hx_upload(const char *URL) } while(active_transfers); /* as long as we have transfers going */ curl_mfprintf(stderr, "all transfers done, cleanup multi\n"); - curl_multi_cleanup(multi_handle); + curl_multi_cleanup(multi); } cleanup: @@ -523,9 +523,9 @@ cleanup: curlx_fclose(t->out); t->out = NULL; } - if(t->easy) { - curl_easy_cleanup(t->easy); - t->easy = NULL; + if(t->curl) { + curl_easy_cleanup(t->curl); + t->curl = NULL; } if(t->mime) { curl_mime_free(t->mime); diff --git a/tests/libtest/cli_tls_session_reuse.c b/tests/libtest/cli_tls_session_reuse.c index 21f2c2da80..2a6c0ea3bf 100644 --- a/tests/libtest/cli_tls_session_reuse.c +++ b/tests/libtest/cli_tls_session_reuse.c @@ -30,13 +30,13 @@ static int tse_found_tls_session = FALSE; static size_t write_tse_cb(char *ptr, size_t size, size_t nmemb, void *opaque) { - CURL *easy = opaque; + CURL *curl = opaque; (void)ptr; if(!tse_found_tls_session) { struct curl_tlssessioninfo *tlssession; CURLcode rc; - rc = curl_easy_getinfo(easy, CURLINFO_TLS_SSL_PTR, &tlssession); + rc = curl_easy_getinfo(curl, CURLINFO_TLS_SSL_PTR, &tlssession); if(rc) { curl_mfprintf(stderr, "curl_easy_getinfo(CURLINFO_TLS_SSL_PTR) " "failed: %s\n", curl_easy_strerror(rc)); @@ -61,38 +61,38 @@ static CURL *tse_add_transfer(CURLM *multi, CURLSH *share, struct curl_slist *resolve, const char *url, long http_version) { - CURL *easy; + CURL *curl; CURLMcode mc; - easy = curl_easy_init(); - if(!easy) { + curl = curl_easy_init(); + if(!curl) { curl_mfprintf(stderr, "curl_easy_init failed\n"); return NULL; } - curl_easy_setopt(easy, CURLOPT_VERBOSE, 1L); - curl_easy_setopt(easy, CURLOPT_DEBUGFUNCTION, cli_debug_cb); - curl_easy_setopt(easy, CURLOPT_URL, url); - curl_easy_setopt(easy, CURLOPT_SHARE, share); - curl_easy_setopt(easy, CURLOPT_NOSIGNAL, 1L); - curl_easy_setopt(easy, CURLOPT_AUTOREFERER, 1L); - curl_easy_setopt(easy, CURLOPT_FAILONERROR, 1L); - curl_easy_setopt(easy, CURLOPT_HTTP_VERSION, http_version); - curl_easy_setopt(easy, CURLOPT_WRITEFUNCTION, write_tse_cb); - curl_easy_setopt(easy, CURLOPT_WRITEDATA, easy); - curl_easy_setopt(easy, CURLOPT_HTTPGET, 1L); - curl_easy_setopt(easy, CURLOPT_SSL_VERIFYPEER, 0L); + curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); + curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, cli_debug_cb); + curl_easy_setopt(curl, CURLOPT_URL, url); + curl_easy_setopt(curl, CURLOPT_SHARE, share); + curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L); + curl_easy_setopt(curl, CURLOPT_AUTOREFERER, 1L); + curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1L); + curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, http_version); + curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_tse_cb); + curl_easy_setopt(curl, CURLOPT_WRITEDATA, curl); + curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L); + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L); if(resolve) - curl_easy_setopt(easy, CURLOPT_RESOLVE, resolve); + curl_easy_setopt(curl, CURLOPT_RESOLVE, resolve); - mc = curl_multi_add_handle(multi, easy); + mc = curl_multi_add_handle(multi, curl); if(mc != CURLM_OK) { curl_mfprintf(stderr, "curl_multi_add_handle: %s\n", curl_multi_strerror(mc)); - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); return NULL; } - return easy; + return curl; } static CURLcode test_cli_tls_session_reuse(const char *URL) diff --git a/tests/libtest/cli_ws_data.c b/tests/libtest/cli_ws_data.c index 7223f99c4f..8b8b1fa0d1 100644 --- a/tests/libtest/cli_ws_data.c +++ b/tests/libtest/cli_ws_data.c @@ -190,7 +190,7 @@ out: } struct test_ws_m1_ctx { - CURL *easy; + CURL *curl; char *send_buf; char *recv_buf; size_t send_len, nsent; @@ -216,7 +216,7 @@ static size_t test_ws_data_m1_read(char *buf, size_t nitems, size_t buflen, goto out; if(!ctx->frame_reading) { - curl_ws_start_frame(ctx->easy, CURLWS_BINARY, ctx->send_len); + curl_ws_start_frame(ctx->curl, CURLWS_BINARY, ctx->send_len); ctx->frame_reading = TRUE; } @@ -310,8 +310,8 @@ static CURLcode test_ws_data_m1_echo(const char *url, goto out; } - m1_ctx.easy = curl_easy_init(); - if(!m1_ctx.easy) { + m1_ctx.curl = curl_easy_init(); + if(!m1_ctx.curl) { r = CURLE_OUT_OF_MEMORY; goto out; } @@ -330,22 +330,22 @@ static CURLcode test_ws_data_m1_echo(const char *url, m1_ctx.frames_read = 0; m1_ctx.frames_written = 0; memset(m1_ctx.recv_buf, 0, plen_max); - curl_easy_pause(m1_ctx.easy, CURLPAUSE_CONT); + curl_easy_pause(m1_ctx.curl, CURLPAUSE_CONT); - curl_easy_reset(m1_ctx.easy); - curl_easy_setopt(m1_ctx.easy, CURLOPT_URL, url); + curl_easy_reset(m1_ctx.curl); + curl_easy_setopt(m1_ctx.curl, CURLOPT_URL, url); /* use the callback style */ - curl_easy_setopt(m1_ctx.easy, CURLOPT_USERAGENT, "ws-data"); - curl_easy_setopt(m1_ctx.easy, CURLOPT_VERBOSE, 1L); + curl_easy_setopt(m1_ctx.curl, CURLOPT_USERAGENT, "ws-data"); + curl_easy_setopt(m1_ctx.curl, CURLOPT_VERBOSE, 1L); /* we want to send */ - curl_easy_setopt(m1_ctx.easy, CURLOPT_UPLOAD, 1L); - curl_easy_setopt(m1_ctx.easy, CURLOPT_READFUNCTION, test_ws_data_m1_read); - curl_easy_setopt(m1_ctx.easy, CURLOPT_READDATA, &m1_ctx); - curl_easy_setopt(m1_ctx.easy, CURLOPT_WRITEFUNCTION, + curl_easy_setopt(m1_ctx.curl, CURLOPT_UPLOAD, 1L); + curl_easy_setopt(m1_ctx.curl, CURLOPT_READFUNCTION, test_ws_data_m1_read); + curl_easy_setopt(m1_ctx.curl, CURLOPT_READDATA, &m1_ctx); + curl_easy_setopt(m1_ctx.curl, CURLOPT_WRITEFUNCTION, test_ws_data_m1_write); - curl_easy_setopt(m1_ctx.easy, CURLOPT_WRITEDATA, &m1_ctx); + curl_easy_setopt(m1_ctx.curl, CURLOPT_WRITEDATA, &m1_ctx); - curl_multi_add_handle(multi, m1_ctx.easy); + curl_multi_add_handle(multi, m1_ctx.curl); while(1) { int still_running; /* keep number of running handles */ @@ -366,7 +366,7 @@ static CURLcode test_ws_data_m1_echo(const char *url, } - curl_multi_remove_handle(multi, m1_ctx.easy); + curl_multi_remove_handle(multi, m1_ctx.curl); /* check results */ if(m1_ctx.frames_read < m1_ctx.nframes) { @@ -386,8 +386,8 @@ static CURLcode test_ws_data_m1_echo(const char *url, out: if(multi) curl_multi_cleanup(multi); - if(m1_ctx.easy) { - curl_easy_cleanup(m1_ctx.easy); + if(m1_ctx.curl) { + curl_easy_cleanup(m1_ctx.curl); } free(m1_ctx.send_buf); free(m1_ctx.recv_buf); diff --git a/tests/libtest/lib1485.c b/tests/libtest/lib1485.c index dd2b9728b7..36be7cd1e8 100644 --- a/tests/libtest/lib1485.c +++ b/tests/libtest/lib1485.c @@ -26,7 +26,7 @@ #include "memdebug.h" struct t1485_transfer_status { - CURL *easy; + CURL *curl; curl_off_t out_len; size_t hd_line; CURLcode result; @@ -47,7 +47,7 @@ static size_t t1485_header_callback(char *ptr, size_t size, size_t nmemb, curl_off_t clen; long httpcode = 0; /* end of a response */ - result = curl_easy_getinfo(st->easy, CURLINFO_RESPONSE_CODE, &httpcode); + result = curl_easy_getinfo(st->curl, CURLINFO_RESPONSE_CODE, &httpcode); curl_mfprintf(stderr, "header_callback, get status: %ld, %d\n", httpcode, result); if(httpcode < 100 || httpcode >= 1000) { @@ -57,7 +57,7 @@ static size_t t1485_header_callback(char *ptr, size_t size, size_t nmemb, } st->http_status = (int)httpcode; if(st->http_status >= 200 && st->http_status < 300) { - result = curl_easy_getinfo(st->easy, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T, + result = curl_easy_getinfo(st->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T, &clen); curl_mfprintf(stderr, "header_callback, info Content-Length: " "%" CURL_FORMAT_CURL_OFF_T ", %d\n", clen, result); @@ -87,7 +87,7 @@ static size_t t1485_write_cb(char *ptr, size_t size, size_t nmemb, void *userp) static CURLcode test_lib1485(const char *URL) { - CURL *curls = NULL; + CURL *curl = NULL; CURLcode res = CURLE_OK; struct t1485_transfer_status st; @@ -97,22 +97,22 @@ static CURLcode test_lib1485(const char *URL) global_init(CURL_GLOBAL_ALL); - easy_init(curls); - st.easy = curls; /* to allow callbacks access */ + easy_init(curl); + st.curl = curl; /* to allow callbacks access */ - easy_setopt(curls, CURLOPT_URL, URL); - easy_setopt(curls, CURLOPT_WRITEFUNCTION, t1485_write_cb); - easy_setopt(curls, CURLOPT_WRITEDATA, &st); - easy_setopt(curls, CURLOPT_HEADERFUNCTION, t1485_header_callback); - easy_setopt(curls, CURLOPT_HEADERDATA, &st); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_WRITEFUNCTION, t1485_write_cb); + easy_setopt(curl, CURLOPT_WRITEDATA, &st); + easy_setopt(curl, CURLOPT_HEADERFUNCTION, t1485_header_callback); + easy_setopt(curl, CURLOPT_HEADERDATA, &st); - easy_setopt(curls, CURLOPT_NOPROGRESS, 1L); + easy_setopt(curl, CURLOPT_NOPROGRESS, 1L); - res = curl_easy_perform(curls); + res = curl_easy_perform(curl); test_cleanup: - curl_easy_cleanup(curls); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; /* return the final return code */ diff --git a/tests/libtest/lib1500.c b/tests/libtest/lib1500.c index 8529f66a44..5fe8e7ab4f 100644 --- a/tests/libtest/lib1500.c +++ b/tests/libtest/lib1500.c @@ -27,7 +27,7 @@ static CURLcode test_lib1500(const char *URL) { - CURL *curls = NULL; + CURL *curl = NULL; CURLM *multi = NULL; int still_running; CURLcode i = TEST_ERR_FAILURE; @@ -40,12 +40,12 @@ static CURLcode test_lib1500(const char *URL) multi_init(multi); - easy_init(curls); + easy_init(curl); - easy_setopt(curls, CURLOPT_URL, URL); - easy_setopt(curls, CURLOPT_HEADER, 1L); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_HEADER, 1L); - multi_add_handle(multi, curls); + multi_add_handle(multi, curl); multi_perform(multi, &still_running); @@ -79,7 +79,7 @@ test_cleanup: /* undocumented cleanup sequence - type UA */ curl_multi_cleanup(multi); - curl_easy_cleanup(curls); + curl_easy_cleanup(curl); curl_global_cleanup(); if(res) diff --git a/tests/libtest/lib1501.c b/tests/libtest/lib1501.c index 61e586cd3d..feb775f136 100644 --- a/tests/libtest/lib1501.c +++ b/tests/libtest/lib1501.c @@ -32,8 +32,8 @@ static CURLcode test_lib1501(const char *URL) conservative to allow old and slow machines to run this test too */ static const int MAX_BLOCKED_TIME_MS = 500; - CURL *handle = NULL; - CURLM *mhandle = NULL; + CURL *curl = NULL; + CURLM *multi = NULL; CURLcode res = CURLE_OK; int still_running = 0; @@ -41,16 +41,16 @@ static CURLcode test_lib1501(const char *URL) global_init(CURL_GLOBAL_ALL); - easy_init(handle); + easy_init(curl); - easy_setopt(handle, CURLOPT_URL, URL); - easy_setopt(handle, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); - multi_init(mhandle); + multi_init(multi); - multi_add_handle(mhandle, handle); + multi_add_handle(multi, curl); - multi_perform(mhandle, &still_running); + multi_perform(multi, &still_running); abort_on_test_timeout_custom(HANG_TIMEOUT); @@ -71,7 +71,7 @@ static CURLcode test_lib1501(const char *URL) FD_ZERO(&fdwrite); FD_ZERO(&fdexcep); - multi_fdset(mhandle, &fdread, &fdwrite, &fdexcep, &maxfd); + multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ @@ -82,7 +82,7 @@ static CURLcode test_lib1501(const char *URL) curl_mfprintf(stderr, "ping\n"); before = curlx_now(); - multi_perform(mhandle, &still_running); + multi_perform(multi, &still_running); abort_on_test_timeout_custom(HANG_TIMEOUT); @@ -100,8 +100,8 @@ test_cleanup: /* undocumented cleanup sequence - type UA */ - curl_multi_cleanup(mhandle); - curl_easy_cleanup(handle); + curl_multi_cleanup(multi); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib1502.c b/tests/libtest/lib1502.c index 22ac6e7c80..527f969b11 100644 --- a/tests/libtest/lib1502.c +++ b/tests/libtest/lib1502.c @@ -35,8 +35,8 @@ static CURLcode test_lib1502(const char *URL) { - CURL *easy = NULL; - CURL *dup; + CURL *curl = NULL; + CURL *curldupe; CURLM *multi = NULL; int still_running; CURLcode res = CURLE_OK; @@ -62,27 +62,27 @@ static CURLcode test_lib1502(const char *URL) return TEST_ERR_MAJOR_BAD; } - easy_init(easy); + easy_init(curl); - easy_setopt(easy, CURLOPT_URL, URL); - easy_setopt(easy, CURLOPT_HEADER, 1L); - easy_setopt(easy, CURLOPT_RESOLVE, dns_cache_list); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_HEADER, 1L); + easy_setopt(curl, CURLOPT_RESOLVE, dns_cache_list); - dup = curl_easy_duphandle(easy); - if(dup) { - curl_easy_cleanup(easy); - easy = dup; + curldupe = curl_easy_duphandle(curl); + if(curldupe) { + curl_easy_cleanup(curl); + curl = curldupe; } else { curl_slist_free_all(dns_cache_list); - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); curl_global_cleanup(); return CURLE_OUT_OF_MEMORY; } multi_init(multi); - multi_add_handle(multi, easy); + multi_add_handle(multi, curl); multi_perform(multi, &still_running); @@ -121,26 +121,26 @@ test_cleanup: default: /* undocumented cleanup sequence - type UA */ curl_multi_cleanup(multi); - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); curl_global_cleanup(); break; case 1503: /* proper cleanup sequence - type PA */ - curl_multi_remove_handle(multi, easy); + curl_multi_remove_handle(multi, curl); curl_multi_cleanup(multi); - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); curl_global_cleanup(); break; case 1504: /* undocumented cleanup sequence - type UB */ - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); curl_multi_cleanup(multi); curl_global_cleanup(); break; case 1505: /* proper cleanup sequence - type PB */ - curl_multi_remove_handle(multi, easy); - curl_easy_cleanup(easy); + curl_multi_remove_handle(multi, curl); + curl_easy_cleanup(curl); curl_multi_cleanup(multi); curl_global_cleanup(); break; diff --git a/tests/libtest/lib1506.c b/tests/libtest/lib1506.c index 66768f7563..5790f3baeb 100644 --- a/tests/libtest/lib1506.c +++ b/tests/libtest/lib1506.c @@ -30,7 +30,7 @@ static CURLcode test_lib1506(const char *URL) CURLcode res = CURLE_OK; CURL *curl[NUM_HANDLES] = {0}; int running; - CURLM *m = NULL; + CURLM *multi = NULL; size_t i; char target_url[256]; char dnsentry[256]; @@ -57,9 +57,9 @@ static CURLcode test_lib1506(const char *URL) global_init(CURL_GLOBAL_ALL); - multi_init(m); + multi_init(multi); - multi_setopt(m, CURLMOPT_MAXCONNECTS, 3L); + multi_setopt(multi, CURLMOPT_MAXCONNECTS, 3L); /* get each easy handle */ for(i = 0; i < CURL_ARRAYSIZE(curl); i++) { @@ -83,7 +83,7 @@ static CURLcode test_lib1506(const char *URL) for(i = 0; i < CURL_ARRAYSIZE(curl); i++) { /* add handle to multi */ - multi_add_handle(m, curl[i]); + multi_add_handle(multi, curl[i]); for(;;) { struct timeval interval; @@ -93,7 +93,7 @@ static CURLcode test_lib1506(const char *URL) interval.tv_sec = 1; interval.tv_usec = 0; - multi_perform(m, &running); + multi_perform(multi, &running); abort_on_test_timeout(); @@ -104,7 +104,7 @@ static CURLcode test_lib1506(const char *URL) FD_ZERO(&wr); FD_ZERO(&exc); - multi_fdset(m, &rd, &wr, &exc, &maxfd); + multi_fdset(multi, &rd, &wr, &exc, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ @@ -120,13 +120,13 @@ test_cleanup: /* proper cleanup sequence - type PB */ for(i = 0; i < CURL_ARRAYSIZE(curl); i++) { - curl_multi_remove_handle(m, curl[i]); + curl_multi_remove_handle(multi, curl[i]); curl_easy_cleanup(curl[i]); } curl_slist_free_all(slist); - curl_multi_cleanup(m); + curl_multi_cleanup(multi); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib1507.c b/tests/libtest/lib1507.c index 8d96c6b300..a02a07e61b 100644 --- a/tests/libtest/lib1507.c +++ b/tests/libtest/lib1507.c @@ -40,7 +40,7 @@ static CURLcode test_lib1507(const char *URL) CURLcode res = CURLE_OK; CURL *curl = NULL; - CURLM *mcurl = NULL; + CURLM *multi = NULL; int still_running = 1; struct curltime mp_start; struct curl_slist *rcpt_list = NULL; @@ -49,7 +49,7 @@ static CURLcode test_lib1507(const char *URL) easy_init(curl); - multi_init(mcurl); + multi_init(multi); rcpt_list = curl_slist_append(rcpt_list, "<1507-recipient@example.com>"); #if 0 @@ -66,12 +66,12 @@ static CURLcode test_lib1507(const char *URL) curl_easy_setopt(curl, CURLOPT_MAIL_FROM, "<1507-realuser@example.com>"); curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, rcpt_list); curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); - multi_add_handle(mcurl, curl); + multi_add_handle(multi, curl); mp_start = curlx_now(); /* we start some action by calling perform right away */ - curl_multi_perform(mcurl, &still_running); + curl_multi_perform(multi, &still_running); while(still_running) { struct timeval timeout; @@ -92,7 +92,7 @@ static CURLcode test_lib1507(const char *URL) timeout.tv_sec = 1; timeout.tv_usec = 0; - curl_multi_timeout(mcurl, &curl_timeo); + curl_multi_timeout(multi, &curl_timeo); if(curl_timeo >= 0) { curlx_mstotv(&timeout, curl_timeo); if(timeout.tv_sec > 1) { @@ -102,7 +102,7 @@ static CURLcode test_lib1507(const char *URL) } /* get file descriptors from the transfers */ - curl_multi_fdset(mcurl, &fdread, &fdwrite, &fdexcep, &maxfd); + curl_multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd); /* In a real-world program you OF COURSE check the return code of the function calls. On success, the value of maxfd is guaranteed to be @@ -124,7 +124,7 @@ static CURLcode test_lib1507(const char *URL) break; case 0: /* timeout */ default: /* action */ - curl_multi_perform(mcurl, &still_running); + curl_multi_perform(multi, &still_running); break; } } @@ -132,8 +132,8 @@ static CURLcode test_lib1507(const char *URL) test_cleanup: curl_slist_free_all(rcpt_list); - curl_multi_remove_handle(mcurl, curl); - curl_multi_cleanup(mcurl); + curl_multi_remove_handle(multi, curl); + curl_multi_cleanup(multi); curl_easy_cleanup(curl); curl_global_cleanup(); diff --git a/tests/libtest/lib1508.c b/tests/libtest/lib1508.c index a305e652ff..b7b47daa3f 100644 --- a/tests/libtest/lib1508.c +++ b/tests/libtest/lib1508.c @@ -28,19 +28,19 @@ static CURLcode test_lib1508(const char *URL) { CURLcode res = CURLE_OK; - CURLM *m = NULL; + CURLM *multi = NULL; (void)URL; global_init(CURL_GLOBAL_ALL); - multi_init(m); + multi_init(multi); test_cleanup: /* proper cleanup sequence - type PB */ - curl_multi_cleanup(m); + curl_multi_cleanup(multi); curl_global_cleanup(); curl_mprintf("We are done\n"); diff --git a/tests/libtest/lib1515.c b/tests/libtest/lib1515.c index 02c3c99bf8..679a413c69 100644 --- a/tests/libtest/lib1515.c +++ b/tests/libtest/lib1515.c @@ -35,9 +35,10 @@ #define DNS_TIMEOUT 1L -static CURLcode do_one_request(CURLM *m, const char *URL, const char *resolve) +static CURLcode do_one_request(CURLM *multi, const char *URL, + const char *resolve) { - CURL *curls; + CURL *curl; struct curl_slist *resolve_list = NULL; int still_running; CURLcode res = CURLE_OK; @@ -46,20 +47,20 @@ static CURLcode do_one_request(CURLM *m, const char *URL, const char *resolve) resolve_list = curl_slist_append(resolve_list, resolve); - easy_init(curls); + easy_init(curl); - easy_setopt(curls, CURLOPT_URL, URL); - easy_setopt(curls, CURLOPT_RESOLVE, resolve_list); - easy_setopt(curls, CURLOPT_DNS_CACHE_TIMEOUT, DNS_TIMEOUT); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_RESOLVE, resolve_list); + easy_setopt(curl, CURLOPT_DNS_CACHE_TIMEOUT, DNS_TIMEOUT); debug_config.nohex = TRUE; debug_config.tracetime = TRUE; - easy_setopt(curls, CURLOPT_DEBUGDATA, &debug_config); - easy_setopt(curls, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); - easy_setopt(curls, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config); + easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); - multi_add_handle(m, curls); - multi_perform(m, &still_running); + multi_add_handle(multi, curl); + multi_perform(multi, &still_running); abort_on_test_timeout(); @@ -74,18 +75,18 @@ static CURLcode do_one_request(CURLM *m, const char *URL, const char *resolve) timeout.tv_sec = 1; timeout.tv_usec = 0; - multi_fdset(m, &fdread, &fdwrite, &fdexcep, &maxfd); + multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd); select_test(maxfd + 1, &fdread, &fdwrite, &fdexcep, &timeout); abort_on_test_timeout(); - multi_perform(m, &still_running); + multi_perform(multi, &still_running); abort_on_test_timeout(); } do { - msg = curl_multi_info_read(m, &msgs_left); - if(msg && msg->msg == CURLMSG_DONE && msg->easy_handle == curls) { + msg = curl_multi_info_read(multi, &msgs_left); + if(msg && msg->msg == CURLMSG_DONE && msg->easy_handle == curl) { res = msg->data.result; break; } @@ -93,8 +94,8 @@ static CURLcode do_one_request(CURLM *m, const char *URL, const char *resolve) test_cleanup: - curl_multi_remove_handle(m, curls); - curl_easy_cleanup(curls); + curl_multi_remove_handle(multi, curl); + curl_easy_cleanup(curl); curl_slist_free_all(resolve_list); return res; diff --git a/tests/libtest/lib1523.c b/tests/libtest/lib1523.c index 77767b20be..36bdce8e83 100644 --- a/tests/libtest/lib1523.c +++ b/tests/libtest/lib1523.c @@ -46,37 +46,37 @@ static size_t t1523_write_cb(char *d, size_t n, size_t l, void *p) return n*l; } -static CURLcode run(CURL *hnd, long limit, long time) +static CURLcode run(CURL *curl, long limit, long time) { - curl_easy_setopt(hnd, CURLOPT_LOW_SPEED_LIMIT, limit); - curl_easy_setopt(hnd, CURLOPT_LOW_SPEED_TIME, time); - return curl_easy_perform(hnd); + curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, limit); + curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, time); + return curl_easy_perform(curl); } static CURLcode test_lib1523(const char *URL) { CURLcode ret; - CURL *hnd; + CURL *curl; char buffer[CURL_ERROR_SIZE]; curl_global_init(CURL_GLOBAL_ALL); - hnd = curl_easy_init(); - curl_easy_setopt(hnd, CURLOPT_URL, URL); - curl_easy_setopt(hnd, CURLOPT_WRITEFUNCTION, t1523_write_cb); - curl_easy_setopt(hnd, CURLOPT_ERRORBUFFER, buffer); - curl_easy_setopt(hnd, CURLOPT_NOPROGRESS, 0L); - curl_easy_setopt(hnd, CURLOPT_XFERINFOFUNCTION, dload_progress_cb); + curl = curl_easy_init(); + curl_easy_setopt(curl, CURLOPT_URL, URL); + curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, t1523_write_cb); + curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, buffer); + curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L); + curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, dload_progress_cb); - ret = run(hnd, 1, 2); + ret = run(curl, 1, 2); if(ret) curl_mfprintf(stderr, "error (%d) %s\n", ret, buffer); - ret = run(hnd, 12000, 1); + ret = run(curl, 12000, 1); if(ret != CURLE_OPERATION_TIMEDOUT) curl_mfprintf(stderr, "error (%d) %s\n", ret, buffer); else ret = CURLE_OK; - curl_easy_cleanup(hnd); + curl_easy_cleanup(curl); curl_global_cleanup(); return ret; diff --git a/tests/libtest/lib1531.c b/tests/libtest/lib1531.c index 9d4cd77539..6e69c5baee 100644 --- a/tests/libtest/lib1531.c +++ b/tests/libtest/lib1531.c @@ -30,8 +30,8 @@ static CURLcode test_lib1531(const char *URL) static char const testData[] = ".abc\0xyz"; static curl_off_t const testDataSize = sizeof(testData) - 1; - CURL *easy; - CURLM *multi_handle; + CURL *curl; + CURLM *multi; int still_running; /* keep number of running handles */ CURLMsg *msg; /* for picking up messages with the transfer status */ int msgs_left; /* how many messages are left */ @@ -42,21 +42,21 @@ static CURLcode test_lib1531(const char *URL) global_init(CURL_GLOBAL_ALL); /* Allocate one curl handle per transfer */ - easy = curl_easy_init(); + curl = curl_easy_init(); /* init a multi stack */ - multi_handle = curl_multi_init(); + multi = curl_multi_init(); /* add the individual transfer */ - curl_multi_add_handle(multi_handle, easy); + curl_multi_add_handle(multi, curl); /* set the options (I left out a few, you'll get the point anyway) */ - curl_easy_setopt(easy, CURLOPT_URL, URL); - curl_easy_setopt(easy, CURLOPT_POSTFIELDSIZE_LARGE, testDataSize); - curl_easy_setopt(easy, CURLOPT_POSTFIELDS, testData); + curl_easy_setopt(curl, CURLOPT_URL, URL); + curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, testDataSize); + curl_easy_setopt(curl, CURLOPT_POSTFIELDS, testData); /* we start some action by calling perform right away */ - curl_multi_perform(multi_handle, &still_running); + curl_multi_perform(multi, &still_running); abort_on_test_timeout(); @@ -80,7 +80,7 @@ static CURLcode test_lib1531(const char *URL) timeout.tv_sec = 1; timeout.tv_usec = 0; - curl_multi_timeout(multi_handle, &curl_timeo); + curl_multi_timeout(multi, &curl_timeo); if(curl_timeo >= 0) { curlx_mstotv(&timeout, curl_timeo); if(timeout.tv_sec > 1) { @@ -90,7 +90,7 @@ static CURLcode test_lib1531(const char *URL) } /* get file descriptors from the transfers */ - mc = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd); + mc = curl_multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd); if(mc != CURLM_OK) { curl_mfprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc); @@ -118,7 +118,7 @@ static CURLcode test_lib1531(const char *URL) break; case 0: /* timeout */ default: /* action */ - curl_multi_perform(multi_handle, &still_running); + curl_multi_perform(multi, &still_running); break; } @@ -127,7 +127,7 @@ static CURLcode test_lib1531(const char *URL) /* See how the transfers went */ do { - msg = curl_multi_info_read(multi_handle, &msgs_left); + msg = curl_multi_info_read(multi, &msgs_left); if(msg && msg->msg == CURLMSG_DONE) { curl_mprintf("HTTP transfer completed with status %d\n", msg->data.result); @@ -138,10 +138,10 @@ static CURLcode test_lib1531(const char *URL) } while(msg); test_cleanup: - curl_multi_cleanup(multi_handle); + curl_multi_cleanup(multi); /* Free the curl handles */ - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib1533.c b/tests/libtest/lib1533.c index ff5c83cc82..1c60172734 100644 --- a/tests/libtest/lib1533.c +++ b/tests/libtest/lib1533.c @@ -34,7 +34,7 @@ #include "memdebug.h" struct cb_data { - CURL *easy_handle; + CURL *curl; int response_received; int paused; size_t remaining_bytes; @@ -42,7 +42,7 @@ struct cb_data { static void reset_data(struct cb_data *data, CURL *curl) { - data->easy_handle = curl; + data->curl = curl; data->response_received = 0; data->paused = 0; data->remaining_bytes = 3; @@ -85,7 +85,7 @@ static size_t t1533_write_cb(char *ptr, size_t size, size_t nmemb, void *userp) if(data->paused) { /* continue to send request body data */ data->paused = 0; - curl_easy_pause(data->easy_handle, CURLPAUSE_CONT); + curl_easy_pause(data->curl, CURLPAUSE_CONT); } return totalsize; diff --git a/tests/libtest/lib1540.c b/tests/libtest/lib1540.c index 55195b6ba8..7f91234356 100644 --- a/tests/libtest/lib1540.c +++ b/tests/libtest/lib1540.c @@ -27,7 +27,7 @@ #include "memdebug.h" struct t1540_transfer_status { - CURL *easy; + CURL *curl; int halted; int counter; /* count write callback invokes */ int please; /* number of times xferinfo is called while halted */ @@ -48,7 +48,7 @@ static int please_continue(void *userp, st->please++; if(st->please == 2) { /* waited enough, unpause! */ - curl_easy_pause(st->easy, CURLPAUSE_CONT); + curl_easy_pause(st->curl, CURLPAUSE_CONT); } } curl_mfprintf(stderr, "xferinfo: paused %d\n", st->halted); @@ -83,7 +83,7 @@ static size_t t1540_write_cb(char *ptr, size_t size, size_t nmemb, void *userp) static CURLcode test_lib1540(const char *URL) { - CURL *curls = NULL; + CURL *curl = NULL; CURLcode res = CURLE_OK; struct t1540_transfer_status st; @@ -93,30 +93,30 @@ static CURLcode test_lib1540(const char *URL) global_init(CURL_GLOBAL_ALL); - easy_init(curls); - st.easy = curls; /* to allow callbacks access */ + easy_init(curl); + st.curl = curl; /* to allow callbacks access */ - easy_setopt(curls, CURLOPT_URL, URL); - easy_setopt(curls, CURLOPT_WRITEFUNCTION, t1540_write_cb); - easy_setopt(curls, CURLOPT_WRITEDATA, &st); - easy_setopt(curls, CURLOPT_HEADERFUNCTION, t1540_header_callback); - easy_setopt(curls, CURLOPT_HEADERDATA, &st); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_WRITEFUNCTION, t1540_write_cb); + easy_setopt(curl, CURLOPT_WRITEDATA, &st); + easy_setopt(curl, CURLOPT_HEADERFUNCTION, t1540_header_callback); + easy_setopt(curl, CURLOPT_HEADERDATA, &st); - easy_setopt(curls, CURLOPT_XFERINFOFUNCTION, please_continue); - easy_setopt(curls, CURLOPT_XFERINFODATA, &st); - easy_setopt(curls, CURLOPT_NOPROGRESS, 0L); + easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, please_continue); + easy_setopt(curl, CURLOPT_XFERINFODATA, &st); + easy_setopt(curl, CURLOPT_NOPROGRESS, 0L); debug_config.nohex = TRUE; debug_config.tracetime = TRUE; - test_setopt(curls, CURLOPT_DEBUGDATA, &debug_config); - easy_setopt(curls, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); - easy_setopt(curls, CURLOPT_VERBOSE, 1L); + test_setopt(curl, CURLOPT_DEBUGDATA, &debug_config); + easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); - res = curl_easy_perform(curls); + res = curl_easy_perform(curl); test_cleanup: - curl_easy_cleanup(curls); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; /* return the final return code */ diff --git a/tests/libtest/lib1541.c b/tests/libtest/lib1541.c index 9e7b2d4365..a2caaef8c3 100644 --- a/tests/libtest/lib1541.c +++ b/tests/libtest/lib1541.c @@ -26,7 +26,7 @@ #include "memdebug.h" struct t1541_transfer_status { - CURL *easy; + CURL *curl; int hd_count; int bd_count; CURLcode result; @@ -50,11 +50,11 @@ static void report_time(const char *key, const char *where, curl_off_t time, key, where, time); } -static void check_time(CURL *easy, int key, const char *name, +static void check_time(CURL *curl, int key, const char *name, const char *where) { curl_off_t tval; - CURLcode res = curl_easy_getinfo(easy, (CURLINFO)key, &tval); + CURLcode res = curl_easy_getinfo(curl, (CURLINFO)key, &tval); if(res) { t1541_geterr(name, res, __LINE__); } @@ -62,11 +62,11 @@ static void check_time(CURL *easy, int key, const char *name, report_time(name, where, tval, tval > 0); } -static void check_time0(CURL *easy, int key, const char *name, +static void check_time0(CURL *curl, int key, const char *name, const char *where) { curl_off_t tval; - CURLcode res = curl_easy_getinfo(easy, (CURLINFO)key, &tval); + CURLcode res = curl_easy_getinfo(curl, (CURLINFO)key, &tval); if(res) { t1541_geterr(name, res, __LINE__); } @@ -83,15 +83,15 @@ static size_t t1541_header_callback(char *ptr, size_t size, size_t nmemb, (void)ptr; if(!st->hd_count++) { /* first header, check some CURLINFO value to be reported. See #13125 */ - check_time(st->easy, KN(CURLINFO_CONNECT_TIME_T), "1st header"); - check_time(st->easy, KN(CURLINFO_PRETRANSFER_TIME_T), "1st header"); - check_time(st->easy, KN(CURLINFO_STARTTRANSFER_TIME_T), "1st header"); + check_time(st->curl, KN(CURLINFO_CONNECT_TIME_T), "1st header"); + check_time(st->curl, KN(CURLINFO_PRETRANSFER_TIME_T), "1st header"); + check_time(st->curl, KN(CURLINFO_STARTTRANSFER_TIME_T), "1st header"); /* continuously updated */ - check_time(st->easy, KN(CURLINFO_TOTAL_TIME_T), "1st header"); + check_time(st->curl, KN(CURLINFO_TOTAL_TIME_T), "1st header"); /* no SSL, must be 0 */ - check_time0(st->easy, KN(CURLINFO_APPCONNECT_TIME_T), "1st header"); + check_time0(st->curl, KN(CURLINFO_APPCONNECT_TIME_T), "1st header"); /* download not really started */ - check_time0(st->easy, KN(CURLINFO_SPEED_DOWNLOAD_T), "1st header"); + check_time0(st->curl, KN(CURLINFO_SPEED_DOWNLOAD_T), "1st header"); } (void)fwrite(ptr, size, nmemb, stdout); return len; @@ -109,7 +109,7 @@ static size_t t1541_write_cb(char *ptr, size_t size, size_t nmemb, void *userp) static CURLcode test_lib1541(const char *URL) { - CURL *curls = NULL; + CURL *curl = NULL; CURLcode res = CURLE_OK; struct t1541_transfer_status st; @@ -119,31 +119,31 @@ static CURLcode test_lib1541(const char *URL) global_init(CURL_GLOBAL_ALL); - easy_init(curls); - st.easy = curls; /* to allow callbacks access */ + easy_init(curl); + st.curl = curl; /* to allow callbacks access */ - easy_setopt(curls, CURLOPT_URL, URL); - easy_setopt(curls, CURLOPT_WRITEFUNCTION, t1541_write_cb); - easy_setopt(curls, CURLOPT_WRITEDATA, &st); - easy_setopt(curls, CURLOPT_HEADERFUNCTION, t1541_header_callback); - easy_setopt(curls, CURLOPT_HEADERDATA, &st); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_WRITEFUNCTION, t1541_write_cb); + easy_setopt(curl, CURLOPT_WRITEDATA, &st); + easy_setopt(curl, CURLOPT_HEADERFUNCTION, t1541_header_callback); + easy_setopt(curl, CURLOPT_HEADERDATA, &st); - easy_setopt(curls, CURLOPT_NOPROGRESS, 0L); + easy_setopt(curl, CURLOPT_NOPROGRESS, 0L); - res = curl_easy_perform(curls); + res = curl_easy_perform(curl); - check_time(curls, KN(CURLINFO_CONNECT_TIME_T), "done"); - check_time(curls, KN(CURLINFO_PRETRANSFER_TIME_T), "done"); - check_time(curls, KN(CURLINFO_POSTTRANSFER_TIME_T), "done"); - check_time(curls, KN(CURLINFO_STARTTRANSFER_TIME_T), "done"); + check_time(curl, KN(CURLINFO_CONNECT_TIME_T), "done"); + check_time(curl, KN(CURLINFO_PRETRANSFER_TIME_T), "done"); + check_time(curl, KN(CURLINFO_POSTTRANSFER_TIME_T), "done"); + check_time(curl, KN(CURLINFO_STARTTRANSFER_TIME_T), "done"); /* no SSL, must be 0 */ - check_time0(curls, KN(CURLINFO_APPCONNECT_TIME_T), "done"); - check_time(curls, KN(CURLINFO_SPEED_DOWNLOAD_T), "done"); - check_time(curls, KN(CURLINFO_TOTAL_TIME_T), "done"); + check_time0(curl, KN(CURLINFO_APPCONNECT_TIME_T), "done"); + check_time(curl, KN(CURLINFO_SPEED_DOWNLOAD_T), "done"); + check_time(curl, KN(CURLINFO_TOTAL_TIME_T), "done"); test_cleanup: - curl_easy_cleanup(curls); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; /* return the final return code */ diff --git a/tests/libtest/lib1542.c b/tests/libtest/lib1542.c index b8edbcb797..9fc9f17efb 100644 --- a/tests/libtest/lib1542.c +++ b/tests/libtest/lib1542.c @@ -37,26 +37,26 @@ static CURLcode test_lib1542(const char *URL) { - CURL *easy = NULL; + CURL *curl = NULL; CURLcode res = CURLE_OK; global_init(CURL_GLOBAL_ALL); - res_easy_init(easy); + res_easy_init(curl); - easy_setopt(easy, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_URL, URL); debug_config.nohex = TRUE; debug_config.tracetime = FALSE; - easy_setopt(easy, CURLOPT_DEBUGDATA, &debug_config); - easy_setopt(easy, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); - easy_setopt(easy, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config); + easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); - res = curl_easy_perform(easy); + res = curl_easy_perform(curl); if(res) goto test_cleanup; - res = curl_easy_perform(easy); + res = curl_easy_perform(curl); if(res) goto test_cleanup; @@ -64,19 +64,19 @@ static CURLcode test_lib1542(const char *URL) * seconds old */ curlx_wait_ms(2000); - res = curl_easy_perform(easy); + res = curl_easy_perform(curl); if(res) goto test_cleanup; - easy_setopt(easy, CURLOPT_MAXLIFETIME_CONN, 1L); + easy_setopt(curl, CURLOPT_MAXLIFETIME_CONN, 1L); - res = curl_easy_perform(easy); + res = curl_easy_perform(curl); if(res) goto test_cleanup; test_cleanup: - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib1545.c b/tests/libtest/lib1545.c index ac59d028c0..7bb851f36e 100644 --- a/tests/libtest/lib1545.c +++ b/tests/libtest/lib1545.c @@ -25,27 +25,27 @@ static CURLcode test_lib1545(const char *URL) { - CURL *eh = NULL; + CURL *curl = NULL; CURLcode res = CURLE_OK; struct curl_httppost *lastptr = NULL; struct curl_httppost *m_formpost = NULL; global_init(CURL_GLOBAL_ALL); - easy_init(eh); + easy_init(curl); - easy_setopt(eh, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_URL, URL); curl_formadd(&m_formpost, &lastptr, CURLFORM_COPYNAME, "file", CURLFORM_FILE, "missing-file", CURLFORM_END); - curl_easy_setopt(eh, CURLOPT_HTTPPOST, m_formpost); + curl_easy_setopt(curl, CURLOPT_HTTPPOST, m_formpost); - (void)curl_easy_perform(eh); - (void)curl_easy_perform(eh); + (void)curl_easy_perform(curl); + (void)curl_easy_perform(curl); test_cleanup: curl_formfree(m_formpost); - curl_easy_cleanup(eh); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib1550.c b/tests/libtest/lib1550.c index 11583aec47..566cbfa192 100644 --- a/tests/libtest/lib1550.c +++ b/tests/libtest/lib1550.c @@ -29,7 +29,7 @@ static CURLcode test_lib1550(const char *URL) { - CURLM *handle; + CURLM *multi; CURLcode res = CURLE_OK; static const char * const bl_servers[] = {"Microsoft-IIS/6.0", "nginx/0.8.54", NULL}; @@ -37,12 +37,12 @@ static CURLcode test_lib1550(const char *URL) {"curl.se:443", "example.com:80", NULL}; global_init(CURL_GLOBAL_ALL); - handle = curl_multi_init(); + multi = curl_multi_init(); (void)URL; - curl_multi_setopt(handle, CURLMOPT_PIPELINING_SERVER_BL, bl_servers); - curl_multi_setopt(handle, CURLMOPT_PIPELINING_SITE_BL, bl_sites); - curl_multi_cleanup(handle); + curl_multi_setopt(multi, CURLMOPT_PIPELINING_SERVER_BL, bl_servers); + curl_multi_setopt(multi, CURLMOPT_PIPELINING_SITE_BL, bl_sites); + curl_multi_cleanup(multi); curl_global_cleanup(); return CURLE_OK; } diff --git a/tests/libtest/lib1552.c b/tests/libtest/lib1552.c index a5b23fbd8b..d0c3469d4c 100644 --- a/tests/libtest/lib1552.c +++ b/tests/libtest/lib1552.c @@ -27,7 +27,7 @@ static CURLcode test_lib1552(const char *URL) { - CURL *curls = NULL; + CURL *curl = NULL; CURLM *multi = NULL; int still_running; CURLcode i = CURLE_OK; @@ -41,14 +41,14 @@ static CURLcode test_lib1552(const char *URL) multi_init(multi); - easy_init(curls); + easy_init(curl); - easy_setopt(curls, CURLOPT_URL, URL); - easy_setopt(curls, CURLOPT_HEADER, 1L); - easy_setopt(curls, CURLOPT_VERBOSE, 1L); - easy_setopt(curls, CURLOPT_USERPWD, "u:s"); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_HEADER, 1L); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_USERPWD, "u:s"); - multi_add_handle(multi, curls); + multi_add_handle(multi, curl); multi_perform(multi, &still_running); @@ -82,7 +82,7 @@ test_cleanup: /* undocumented cleanup sequence - type UA */ curl_multi_cleanup(multi); - curl_easy_cleanup(curls); + curl_easy_cleanup(curl); curl_global_cleanup(); if(res) diff --git a/tests/libtest/lib1553.c b/tests/libtest/lib1553.c index 5d35adac5c..fa753ac231 100644 --- a/tests/libtest/lib1553.c +++ b/tests/libtest/lib1553.c @@ -41,7 +41,7 @@ static int t1553_xferinfo(void *p, static CURLcode test_lib1553(const char *URL) { - CURL *curls = NULL; + CURL *curl = NULL; CURLM *multi = NULL; int still_running; CURLcode i = CURLE_OK; @@ -56,28 +56,28 @@ static CURLcode test_lib1553(const char *URL) multi_init(multi); - easy_init(curls); + easy_init(curl); - mime = curl_mime_init(curls); + mime = curl_mime_init(curl); field = curl_mime_addpart(mime); curl_mime_name(field, "name"); curl_mime_data(field, "value", CURL_ZERO_TERMINATED); - easy_setopt(curls, CURLOPT_URL, URL); - easy_setopt(curls, CURLOPT_HEADER, 1L); - easy_setopt(curls, CURLOPT_VERBOSE, 1L); - easy_setopt(curls, CURLOPT_MIMEPOST, mime); - easy_setopt(curls, CURLOPT_USERPWD, "u:s"); - easy_setopt(curls, CURLOPT_XFERINFOFUNCTION, t1553_xferinfo); - easy_setopt(curls, CURLOPT_NOPROGRESS, 1L); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_HEADER, 1L); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_MIMEPOST, mime); + easy_setopt(curl, CURLOPT_USERPWD, "u:s"); + easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, t1553_xferinfo); + easy_setopt(curl, CURLOPT_NOPROGRESS, 1L); debug_config.nohex = TRUE; debug_config.tracetime = TRUE; - test_setopt(curls, CURLOPT_DEBUGDATA, &debug_config); - easy_setopt(curls, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); - easy_setopt(curls, CURLOPT_VERBOSE, 1L); + test_setopt(curl, CURLOPT_DEBUGDATA, &debug_config); + easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); - multi_add_handle(multi, curls); + multi_add_handle(multi, curl); multi_perform(multi, &still_running); @@ -103,9 +103,9 @@ static CURLcode test_lib1553(const char *URL) test_cleanup: curl_mime_free(mime); - curl_multi_remove_handle(multi, curls); + curl_multi_remove_handle(multi, curl); curl_multi_cleanup(multi); - curl_easy_cleanup(curls); + curl_easy_cleanup(curl); curl_global_cleanup(); if(res) diff --git a/tests/libtest/lib1554.c b/tests/libtest/lib1554.c index 240fea6577..050075df3f 100644 --- a/tests/libtest/lib1554.c +++ b/tests/libtest/lib1554.c @@ -37,19 +37,19 @@ static const char *ldata_names[] = { "NULL", }; -static void t1554_test_lock(CURL *handle, curl_lock_data data, +static void t1554_test_lock(CURL *curl, curl_lock_data data, curl_lock_access laccess, void *useptr) { - (void)handle; + (void)curl; (void)data; (void)laccess; (void)useptr; curl_mprintf("-> Mutex lock %s\n", ldata_names[data]); } -static void t1554_test_unlock(CURL *handle, curl_lock_data data, void *useptr) +static void t1554_test_unlock(CURL *curl, curl_lock_data data, void *useptr) { - (void)handle; + (void)curl; (void)data; (void)useptr; curl_mprintf("<- Mutex unlock %s\n", ldata_names[data]); diff --git a/tests/libtest/lib1557.c b/tests/libtest/lib1557.c index 0e33f48fbb..1c2785dbe3 100644 --- a/tests/libtest/lib1557.c +++ b/tests/libtest/lib1557.c @@ -27,7 +27,7 @@ static CURLcode test_lib1557(const char *URL) { - CURLM *curlm = NULL; + CURLM *multi = NULL; CURL *curl1 = NULL; CURL *curl2 = NULL; int running_handles = 0; @@ -35,28 +35,28 @@ static CURLcode test_lib1557(const char *URL) global_init(CURL_GLOBAL_ALL); - multi_init(curlm); - multi_setopt(curlm, CURLMOPT_MAX_HOST_CONNECTIONS, 1L); + multi_init(multi); + multi_setopt(multi, CURLMOPT_MAX_HOST_CONNECTIONS, 1L); easy_init(curl1); easy_setopt(curl1, CURLOPT_URL, URL); - multi_add_handle(curlm, curl1); + multi_add_handle(multi, curl1); easy_init(curl2); easy_setopt(curl2, CURLOPT_URL, URL); - multi_add_handle(curlm, curl2); + multi_add_handle(multi, curl2); - multi_perform(curlm, &running_handles); + multi_perform(multi, &running_handles); - multi_remove_handle(curlm, curl2); + multi_remove_handle(multi, curl2); /* If curl2 is still in the connect-pending list, this will crash */ - multi_remove_handle(curlm, curl1); + multi_remove_handle(multi, curl1); test_cleanup: curl_easy_cleanup(curl1); curl_easy_cleanup(curl2); - curl_multi_cleanup(curlm); + curl_multi_cleanup(multi); curl_global_cleanup(); return res; } diff --git a/tests/libtest/lib1565.c b/tests/libtest/lib1565.c index 1b218d37a7..893950b90d 100644 --- a/tests/libtest/lib1565.c +++ b/tests/libtest/lib1565.c @@ -32,7 +32,7 @@ #define TIME_BETWEEN_START_SECS 2 static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; -static CURL *pending_handles[CONN_NUM]; +static CURL *pending_curls[CONN_NUM]; static int pending_num = 0; static CURLcode t1565_test_failure = CURLE_OK; @@ -41,7 +41,7 @@ static const char *t1565_url; static void *t1565_run_thread(void *ptr) { - CURL *easy = NULL; + CURL *curl = NULL; CURLcode res = CURLE_OK; int i; @@ -50,10 +50,10 @@ static void *t1565_run_thread(void *ptr) for(i = 0; i < CONN_NUM; i++) { curlx_wait_ms(TIME_BETWEEN_START_SECS * 1000); - easy_init(easy); + easy_init(curl); - easy_setopt(easy, CURLOPT_URL, t1565_url); - easy_setopt(easy, CURLOPT_VERBOSE, 0L); + easy_setopt(curl, CURLOPT_URL, t1565_url); + easy_setopt(curl, CURLOPT_VERBOSE, 0L); pthread_mutex_lock(&lock); @@ -62,9 +62,9 @@ static void *t1565_run_thread(void *ptr) goto test_cleanup; } - pending_handles[pending_num] = easy; + pending_curls[pending_num] = curl; pending_num++; - easy = NULL; + curl = NULL; pthread_mutex_unlock(&lock); @@ -73,7 +73,7 @@ static void *t1565_run_thread(void *ptr) test_cleanup: - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); pthread_mutex_lock(&lock); @@ -92,7 +92,7 @@ static CURLcode test_lib1565(const char *URL) int i; int result; CURLcode res = CURLE_OK; - CURL *started_handles[CONN_NUM]; + CURL *started_curls[CONN_NUM]; int started_num = 0; int finished_num = 0; pthread_t tid = 0; @@ -150,13 +150,13 @@ static CURLcode test_lib1565(const char *URL) pthread_mutex_lock(&lock); while(pending_num > 0) { - res_multi_add_handle(testmulti, pending_handles[pending_num - 1]); + res_multi_add_handle(testmulti, pending_curls[pending_num - 1]); if(res) { pthread_mutex_unlock(&lock); goto test_cleanup; } - started_handles[started_num] = pending_handles[pending_num - 1]; + started_curls[started_num] = pending_curls[pending_num - 1]; started_num++; pending_num--; } @@ -190,9 +190,9 @@ test_cleanup: curl_multi_cleanup(testmulti); for(i = 0; i < pending_num; i++) - curl_easy_cleanup(pending_handles[i]); + curl_easy_cleanup(pending_curls[i]); for(i = 0; i < started_num; i++) - curl_easy_cleanup(started_handles[i]); + curl_easy_cleanup(started_curls[i]); curl_global_cleanup(); return t1565_test_failure; diff --git a/tests/libtest/lib1568.c b/tests/libtest/lib1568.c index 695badc85c..9e73029d51 100644 --- a/tests/libtest/lib1568.c +++ b/tests/libtest/lib1568.c @@ -28,23 +28,23 @@ static CURLcode test_lib1568(const char *URL) { CURLcode ret; - CURL *hnd; + CURL *curl; curl_global_init(CURL_GLOBAL_ALL); - hnd = curl_easy_init(); - curl_easy_setopt(hnd, CURLOPT_URL, URL); - curl_easy_setopt(hnd, CURLOPT_VERBOSE, 1L); - curl_easy_setopt(hnd, CURLOPT_HEADER, 1L); - curl_easy_setopt(hnd, CURLOPT_USERPWD, "testuser:testpass"); - curl_easy_setopt(hnd, CURLOPT_USERAGENT, "lib1568"); - curl_easy_setopt(hnd, CURLOPT_HTTPAUTH, CURLAUTH_DIGEST); - curl_easy_setopt(hnd, CURLOPT_MAXREDIRS, 50L); - curl_easy_setopt(hnd, CURLOPT_PORT, atol(libtest_arg2)); + curl = curl_easy_init(); + curl_easy_setopt(curl, CURLOPT_URL, URL); + curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); + curl_easy_setopt(curl, CURLOPT_HEADER, 1L); + curl_easy_setopt(curl, CURLOPT_USERPWD, "testuser:testpass"); + curl_easy_setopt(curl, CURLOPT_USERAGENT, "lib1568"); + curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_DIGEST); + curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 50L); + curl_easy_setopt(curl, CURLOPT_PORT, atol(libtest_arg2)); - ret = curl_easy_perform(hnd); + ret = curl_easy_perform(curl); - curl_easy_cleanup(hnd); - hnd = NULL; + curl_easy_cleanup(curl); + curl = NULL; curl_global_cleanup(); return ret; diff --git a/tests/libtest/lib1569.c b/tests/libtest/lib1569.c index 2846909e88..c2fd27bfe1 100644 --- a/tests/libtest/lib1569.c +++ b/tests/libtest/lib1569.c @@ -28,23 +28,23 @@ static CURLcode test_lib1569(const char *URL) { CURLcode res = CURLE_OK; - CURL *hnd; + CURL *curl; global_init(CURL_GLOBAL_ALL); - easy_init(hnd); - easy_setopt(hnd, CURLOPT_URL, URL); - easy_setopt(hnd, CURLOPT_VERBOSE, 1L); - easy_setopt(hnd, CURLOPT_HEADER, 1L); + easy_init(curl); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_HEADER, 1L); - res = curl_easy_perform(hnd); + res = curl_easy_perform(curl); if(res) goto test_cleanup; - curl_easy_setopt(hnd, CURLOPT_URL, libtest_arg2); - res = curl_easy_perform(hnd); + curl_easy_setopt(curl, CURLOPT_URL, libtest_arg2); + res = curl_easy_perform(curl); test_cleanup: - curl_easy_cleanup(hnd); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; } diff --git a/tests/libtest/lib1592.c b/tests/libtest/lib1592.c index 3f76a19c4f..7e23d576bf 100644 --- a/tests/libtest/lib1592.c +++ b/tests/libtest/lib1592.c @@ -41,7 +41,7 @@ static CURLcode test_lib1592(const char *URL) { int stillRunning; - CURLM *multiHandle = NULL; + CURLM *multi = NULL; CURL *curl = NULL; CURLcode res = CURLE_OK; CURLMcode mres; @@ -49,7 +49,7 @@ static CURLcode test_lib1592(const char *URL) global_init(CURL_GLOBAL_ALL); - multi_init(multiHandle); + multi_init(multi); easy_init(curl); @@ -88,17 +88,17 @@ static CURLcode test_lib1592(const char *URL) this. */ easy_setopt(curl, CURLOPT_TIMEOUT_MS, timeout); - multi_add_handle(multiHandle, curl); + multi_add_handle(multi, curl); /* This should move the handle from INIT => CONNECT => WAITRESOLVE. */ curl_mfprintf(stderr, "curl_multi_perform()...\n"); - multi_perform(multiHandle, &stillRunning); + multi_perform(multi, &stillRunning); curl_mfprintf(stderr, "curl_multi_perform() succeeded\n"); /* Start measuring how long it takes to remove the handle. */ curl_mfprintf(stderr, "curl_multi_remove_handle()...\n"); start_test_timing(); - mres = curl_multi_remove_handle(multiHandle, curl); + mres = curl_multi_remove_handle(multi, curl); if(mres) { curl_mfprintf(stderr, "curl_multi_remove_handle() failed, with code %d\n", mres); @@ -114,7 +114,7 @@ static CURLcode test_lib1592(const char *URL) test_cleanup: curl_easy_cleanup(curl); - curl_multi_cleanup(multiHandle); + curl_multi_cleanup(multi); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib1662.c b/tests/libtest/lib1662.c index b0ca4c5094..41a1bc0bd4 100644 --- a/tests/libtest/lib1662.c +++ b/tests/libtest/lib1662.c @@ -49,7 +49,7 @@ static size_t t1662_read_cb(char *ptr, size_t size, size_t nmemb, void *userp) static CURLcode test_lib1662(const char *URL) { CURLcode res = CURLE_OK; - CURL *hnd; + CURL *curl; curl_mime *mime1; curl_mimepart *part1; struct t1662_WriteThis pooh = { 1 }; @@ -58,30 +58,30 @@ static CURLcode test_lib1662(const char *URL) global_init(CURL_GLOBAL_ALL); - hnd = curl_easy_init(); - if(hnd) { - curl_easy_setopt(hnd, CURLOPT_BUFFERSIZE, 102400L); - curl_easy_setopt(hnd, CURLOPT_URL, URL); - curl_easy_setopt(hnd, CURLOPT_NOPROGRESS, 1L); - mime1 = curl_mime_init(hnd); + curl = curl_easy_init(); + if(curl) { + curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, 102400L); + curl_easy_setopt(curl, CURLOPT_URL, URL); + curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L); + mime1 = curl_mime_init(curl); if(mime1) { part1 = curl_mime_addpart(mime1); curl_mime_data_cb(part1, -1, t1662_read_cb, NULL, NULL, &pooh); curl_mime_filename(part1, "poetry.txt"); curl_mime_name(part1, "content"); - curl_easy_setopt(hnd, CURLOPT_MIMEPOST, mime1); - curl_easy_setopt(hnd, CURLOPT_USERAGENT, "curl/2000"); - curl_easy_setopt(hnd, CURLOPT_FOLLOWLOCATION, 1L); - curl_easy_setopt(hnd, CURLOPT_MAXREDIRS, 50L); - curl_easy_setopt(hnd, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2TLS); - curl_easy_setopt(hnd, CURLOPT_VERBOSE, 1L); - curl_easy_setopt(hnd, CURLOPT_FTP_SKIP_PASV_IP, 1L); - curl_easy_setopt(hnd, CURLOPT_TCP_KEEPALIVE, 1L); - res = curl_easy_perform(hnd); + curl_easy_setopt(curl, CURLOPT_MIMEPOST, mime1); + curl_easy_setopt(curl, CURLOPT_USERAGENT, "curl/2000"); + curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); + curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 50L); + curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2TLS); + curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); + curl_easy_setopt(curl, CURLOPT_FTP_SKIP_PASV_IP, 1L); + curl_easy_setopt(curl, CURLOPT_TCP_KEEPALIVE, 1L); + res = curl_easy_perform(curl); } } - curl_easy_cleanup(hnd); + curl_easy_cleanup(curl); curl_mime_free(mime1); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib1900.c b/tests/libtest/lib1900.c index 3e9c60f4a8..2f0954bb6c 100644 --- a/tests/libtest/lib1900.c +++ b/tests/libtest/lib1900.c @@ -28,26 +28,26 @@ static CURLcode test_lib1900(const char *URL) { CURLcode res = CURLE_OK; - CURL *hnd = NULL; - CURL *second = NULL; + CURL *curl1 = NULL; + CURL *curl2 = NULL; global_init(CURL_GLOBAL_ALL); - easy_init(hnd); - easy_setopt(hnd, CURLOPT_URL, URL); - easy_setopt(hnd, CURLOPT_HSTS, "first-hsts.txt"); - easy_setopt(hnd, CURLOPT_HSTS, "second-hsts.txt"); + easy_init(curl1); + easy_setopt(curl1, CURLOPT_URL, URL); + easy_setopt(curl1, CURLOPT_HSTS, "first-hsts.txt"); + easy_setopt(curl1, CURLOPT_HSTS, "second-hsts.txt"); - second = curl_easy_duphandle(hnd); + curl2 = curl_easy_duphandle(curl1); - curl_easy_cleanup(hnd); - curl_easy_cleanup(second); + curl_easy_cleanup(curl1); + curl_easy_cleanup(curl2); curl_global_cleanup(); return CURLE_OK; test_cleanup: - curl_easy_cleanup(hnd); - curl_easy_cleanup(second); + curl_easy_cleanup(curl1); + curl_easy_cleanup(curl2); curl_global_cleanup(); return res; } diff --git a/tests/libtest/lib1903.c b/tests/libtest/lib1903.c index af21e946b9..fc2858d5ee 100644 --- a/tests/libtest/lib1903.c +++ b/tests/libtest/lib1903.c @@ -28,26 +28,26 @@ static CURLcode test_lib1903(const char *URL) { CURLcode res = CURLE_OK; - CURL *ch = NULL; + CURL *curl = NULL; global_init(CURL_GLOBAL_ALL); - easy_init(ch); + easy_init(curl); - easy_setopt(ch, CURLOPT_URL, URL); - easy_setopt(ch, CURLOPT_COOKIEFILE, libtest_arg2); - res = curl_easy_perform(ch); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_COOKIEFILE, libtest_arg2); + res = curl_easy_perform(curl); if(res) goto test_cleanup; - curl_easy_reset(ch); + curl_easy_reset(curl); - easy_setopt(ch, CURLOPT_URL, URL); - easy_setopt(ch, CURLOPT_COOKIEFILE, libtest_arg2); - easy_setopt(ch, CURLOPT_COOKIEJAR, libtest_arg3); - res = curl_easy_perform(ch); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_COOKIEFILE, libtest_arg2); + easy_setopt(curl, CURLOPT_COOKIEJAR, libtest_arg3); + res = curl_easy_perform(curl); test_cleanup: - curl_easy_cleanup(ch); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib1905.c b/tests/libtest/lib1905.c index a227a09beb..600e696238 100644 --- a/tests/libtest/lib1905.c +++ b/tests/libtest/lib1905.c @@ -27,35 +27,35 @@ static CURLcode test_lib1905(const char *URL) { - CURLSH *sh = NULL; - CURL *ch = NULL; + CURLSH *share = NULL; + CURL *curl = NULL; int unfinished; - CURLM *cm; + CURLM *multi; curl_global_init(CURL_GLOBAL_ALL); - cm = curl_multi_init(); - if(!cm) { + multi = curl_multi_init(); + if(!multi) { curl_global_cleanup(); return TEST_ERR_MULTI; } - sh = curl_share_init(); - if(!sh) + share = curl_share_init(); + if(!share) goto cleanup; - curl_share_setopt(sh, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE); - curl_share_setopt(sh, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE); + curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE); + curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE); - ch = curl_easy_init(); - if(!ch) + curl = curl_easy_init(); + if(!curl) goto cleanup; - curl_easy_setopt(ch, CURLOPT_SHARE, sh); - curl_easy_setopt(ch, CURLOPT_URL, URL); - curl_easy_setopt(ch, CURLOPT_COOKIEFILE, libtest_arg2); - curl_easy_setopt(ch, CURLOPT_COOKIEJAR, libtest_arg2); + curl_easy_setopt(curl, CURLOPT_SHARE, share); + curl_easy_setopt(curl, CURLOPT_URL, URL); + curl_easy_setopt(curl, CURLOPT_COOKIEFILE, libtest_arg2); + curl_easy_setopt(curl, CURLOPT_COOKIEJAR, libtest_arg2); - curl_multi_add_handle(cm, ch); + curl_multi_add_handle(multi, curl); unfinished = 1; while(unfinished) { @@ -67,10 +67,10 @@ static CURLcode test_lib1905(const char *URL) FD_ZERO(&R); FD_ZERO(&W); FD_ZERO(&E); - curl_multi_perform(cm, &unfinished); + curl_multi_perform(multi, &unfinished); - curl_multi_fdset(cm, &R, &W, &E, &MAX); - curl_multi_timeout(cm, &max_tout); + curl_multi_fdset(multi, &R, &W, &E, &MAX); + curl_multi_timeout(multi, &max_tout); if(max_tout > 0) { curlx_mstotv(&timeout, max_tout); @@ -83,14 +83,14 @@ static CURLcode test_lib1905(const char *URL) select(MAX + 1, &R, &W, &E, &timeout); } - curl_easy_setopt(ch, CURLOPT_COOKIELIST, "FLUSH"); - curl_easy_setopt(ch, CURLOPT_SHARE, NULL); + curl_easy_setopt(curl, CURLOPT_COOKIELIST, "FLUSH"); + curl_easy_setopt(curl, CURLOPT_SHARE, NULL); - curl_multi_remove_handle(cm, ch); + curl_multi_remove_handle(multi, curl); cleanup: - curl_easy_cleanup(ch); - curl_share_cleanup(sh); - curl_multi_cleanup(cm); + curl_easy_cleanup(curl); + curl_share_cleanup(share); + curl_multi_cleanup(multi); curl_global_cleanup(); return CURLE_OK; diff --git a/tests/libtest/lib1908.c b/tests/libtest/lib1908.c index 98e01fac9a..500120066e 100644 --- a/tests/libtest/lib1908.c +++ b/tests/libtest/lib1908.c @@ -28,34 +28,34 @@ static CURLcode test_lib1908(const char *URL) { CURLcode ret = CURLE_OK; - CURL *hnd; + CURL *curl; start_test_timing(); curl_global_init(CURL_GLOBAL_ALL); - hnd = curl_easy_init(); - if(hnd) { - curl_easy_setopt(hnd, CURLOPT_URL, URL); - curl_easy_setopt(hnd, CURLOPT_NOPROGRESS, 1L); - curl_easy_setopt(hnd, CURLOPT_ALTSVC, libtest_arg2); - ret = curl_easy_perform(hnd); + curl = curl_easy_init(); + if(curl) { + curl_easy_setopt(curl, CURLOPT_URL, URL); + curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L); + curl_easy_setopt(curl, CURLOPT_ALTSVC, libtest_arg2); + ret = curl_easy_perform(curl); if(!ret) { /* make a copy and check that this also has alt-svc activated */ - CURL *also = curl_easy_duphandle(hnd); - if(also) { - ret = curl_easy_perform(also); + CURL *curldupe = curl_easy_duphandle(curl); + if(curldupe) { + ret = curl_easy_perform(curldupe); /* we close the second handle first, which makes it store the alt-svc file only to get overwritten when the next handle is closed! */ - curl_easy_cleanup(also); + curl_easy_cleanup(curldupe); } } - curl_easy_reset(hnd); + curl_easy_reset(curl); /* using the same file name for the alt-svc cache, this clobbers the - content just written from the 'also' handle */ - curl_easy_cleanup(hnd); + content just written from the 'curldupe' handle */ + curl_easy_cleanup(curl); } curl_global_cleanup(); return ret; diff --git a/tests/libtest/lib1910.c b/tests/libtest/lib1910.c index 6164d59545..425598bf88 100644 --- a/tests/libtest/lib1910.c +++ b/tests/libtest/lib1910.c @@ -28,19 +28,19 @@ static CURLcode test_lib1910(const char *URL) { CURLcode ret = CURLE_OK; - CURL *hnd; + CURL *curl; start_test_timing(); curl_global_init(CURL_GLOBAL_ALL); - hnd = curl_easy_init(); - if(hnd) { - curl_easy_setopt(hnd, CURLOPT_URL, URL); - curl_easy_setopt(hnd, CURLOPT_NOPROGRESS, 1L); - curl_easy_setopt(hnd, CURLOPT_FOLLOWLOCATION, 1L); - curl_easy_setopt(hnd, CURLOPT_USERPWD, "user\nname:pass\nword"); - ret = curl_easy_perform(hnd); - curl_easy_cleanup(hnd); + curl = curl_easy_init(); + if(curl) { + curl_easy_setopt(curl, CURLOPT_URL, URL); + curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L); + curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); + curl_easy_setopt(curl, CURLOPT_USERPWD, "user\nname:pass\nword"); + ret = curl_easy_perform(curl); + curl_easy_cleanup(curl); } curl_global_cleanup(); return ret; diff --git a/tests/libtest/lib1911.c b/tests/libtest/lib1911.c index 4ffc8085dc..7add65ec48 100644 --- a/tests/libtest/lib1911.c +++ b/tests/libtest/lib1911.c @@ -34,13 +34,13 @@ static CURLcode test_lib1911(const char *URL) static char testbuf[MAX_INPUT_LENGTH + 2]; const struct curl_easyoption *o; - CURL *easy; + CURL *curl; int error = 0; (void)URL; curl_global_init(CURL_GLOBAL_ALL); - easy = curl_easy_init(); - if(!easy) { + curl = curl_easy_init(); + if(!curl) { curl_global_cleanup(); return TEST_ERR_EASY_INIT; } @@ -72,7 +72,7 @@ static CURLcode test_lib1911(const char *URL) /* This is a string. Make sure that passing in a string longer CURL_MAX_INPUT_LENGTH returns an error */ - result = curl_easy_setopt(easy, o->id, testbuf); + result = curl_easy_setopt(curl, o->id, testbuf); switch(result) { case CURLE_BAD_FUNCTION_ARGUMENT: /* the most normal */ case CURLE_UNKNOWN_OPTION: /* left out from the build */ @@ -88,7 +88,7 @@ static CURLcode test_lib1911(const char *URL) } } } - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); curl_global_cleanup(); return error == 0 ? CURLE_OK : TEST_ERR_FAILURE; } diff --git a/tests/libtest/lib1913.c b/tests/libtest/lib1913.c index e0519aef29..94a319f0c7 100644 --- a/tests/libtest/lib1913.c +++ b/tests/libtest/lib1913.c @@ -28,20 +28,20 @@ static CURLcode test_lib1913(const char *URL) { CURLcode ret = CURLE_OK; - CURL *hnd; + CURL *curl; start_test_timing(); curl_global_init(CURL_GLOBAL_ALL); - hnd = curl_easy_init(); - if(hnd) { - curl_easy_setopt(hnd, CURLOPT_URL, URL); - curl_easy_setopt(hnd, CURLOPT_NOBODY, 1L); + curl = curl_easy_init(); + if(curl) { + curl_easy_setopt(curl, CURLOPT_URL, URL); + curl_easy_setopt(curl, CURLOPT_NOBODY, 1L); if(libtest_arg2) /* test1914 sets this extra arg */ - curl_easy_setopt(hnd, CURLOPT_FILETIME, 1L); - ret = curl_easy_perform(hnd); - curl_easy_cleanup(hnd); + curl_easy_setopt(curl, CURLOPT_FILETIME, 1L); + ret = curl_easy_perform(curl); + curl_easy_cleanup(curl); } curl_global_cleanup(); return ret; diff --git a/tests/libtest/lib1915.c b/tests/libtest/lib1915.c index c4cc39455f..e47ae9ee80 100644 --- a/tests/libtest/lib1915.c +++ b/tests/libtest/lib1915.c @@ -31,7 +31,7 @@ struct state { }; /* "read" is from the point of the library, it wants data from us */ -static CURLSTScode hstsread(CURL *easy, struct curl_hstsentry *e, +static CURLSTScode hstsread(CURL *curl, struct curl_hstsentry *e, void *userp) { struct entry { @@ -56,7 +56,7 @@ static CURLSTScode hstsread(CURL *easy, struct curl_hstsentry *e, const char *host; const char *expire; struct state *s = (struct state *)userp; - (void)easy; + (void)curl; host = preload_hosts[s->index].name; expire = preload_hosts[s->index++].exp; @@ -72,20 +72,20 @@ static CURLSTScode hstsread(CURL *easy, struct curl_hstsentry *e, } /* verify error from callback */ -static CURLSTScode hstsreadfail(CURL *easy, struct curl_hstsentry *e, +static CURLSTScode hstsreadfail(CURL *curl, struct curl_hstsentry *e, void *userp) { - (void)easy; + (void)curl; (void)e; (void)userp; return CURLSTS_FAIL; } /* check that we get the hosts back in the save */ -static CURLSTScode hstswrite(CURL *easy, struct curl_hstsentry *e, +static CURLSTScode hstswrite(CURL *curl, struct curl_hstsentry *e, struct curl_index *i, void *userp) { - (void)easy; + (void)curl; (void)userp; curl_mprintf("[%zu/%zu] %s %s\n", i->index, i->total, e->name, e->expire); return CURLSTS_OK; @@ -98,7 +98,7 @@ static CURLSTScode hstswrite(CURL *easy, struct curl_hstsentry *e, static CURLcode test_lib1915(const char *URL) { CURLcode res = CURLE_OK; - CURL *hnd; + CURL *curl; struct state st = {0}; global_init(CURL_GLOBAL_ALL); @@ -106,43 +106,43 @@ static CURLcode test_lib1915(const char *URL) debug_config.nohex = TRUE; debug_config.tracetime = TRUE; - easy_init(hnd); - easy_setopt(hnd, CURLOPT_URL, URL); - easy_setopt(hnd, CURLOPT_CONNECTTIMEOUT, 1L); - easy_setopt(hnd, CURLOPT_HSTSREADFUNCTION, hstsread); - easy_setopt(hnd, CURLOPT_HSTSREADDATA, &st); - easy_setopt(hnd, CURLOPT_HSTSWRITEFUNCTION, hstswrite); - easy_setopt(hnd, CURLOPT_HSTSWRITEDATA, &st); - easy_setopt(hnd, CURLOPT_HSTS_CTRL, CURLHSTS_ENABLE); - easy_setopt(hnd, CURLOPT_DEBUGDATA, &debug_config); - easy_setopt(hnd, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); - easy_setopt(hnd, CURLOPT_VERBOSE, 1L); - res = curl_easy_perform(hnd); - curl_easy_cleanup(hnd); - hnd = NULL; + easy_init(curl); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 1L); + easy_setopt(curl, CURLOPT_HSTSREADFUNCTION, hstsread); + easy_setopt(curl, CURLOPT_HSTSREADDATA, &st); + easy_setopt(curl, CURLOPT_HSTSWRITEFUNCTION, hstswrite); + easy_setopt(curl, CURLOPT_HSTSWRITEDATA, &st); + easy_setopt(curl, CURLOPT_HSTS_CTRL, CURLHSTS_ENABLE); + easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config); + easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); + res = curl_easy_perform(curl); + curl_easy_cleanup(curl); + curl = NULL; if(res == CURLE_OPERATION_TIMEDOUT) /* we expect that on Windows */ res = CURLE_COULDNT_CONNECT; curl_mprintf("First request returned %d\n", res); res = CURLE_OK; - easy_init(hnd); - easy_setopt(hnd, CURLOPT_URL, URL); - easy_setopt(hnd, CURLOPT_CONNECTTIMEOUT, 1L); - easy_setopt(hnd, CURLOPT_HSTSREADFUNCTION, hstsreadfail); - easy_setopt(hnd, CURLOPT_HSTSREADDATA, &st); - easy_setopt(hnd, CURLOPT_HSTSWRITEFUNCTION, hstswrite); - easy_setopt(hnd, CURLOPT_HSTSWRITEDATA, &st); - easy_setopt(hnd, CURLOPT_HSTS_CTRL, CURLHSTS_ENABLE); - easy_setopt(hnd, CURLOPT_DEBUGDATA, &debug_config); - easy_setopt(hnd, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); - easy_setopt(hnd, CURLOPT_VERBOSE, 1L); - res = curl_easy_perform(hnd); - curl_easy_cleanup(hnd); - hnd = NULL; + easy_init(curl); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 1L); + easy_setopt(curl, CURLOPT_HSTSREADFUNCTION, hstsreadfail); + easy_setopt(curl, CURLOPT_HSTSREADDATA, &st); + easy_setopt(curl, CURLOPT_HSTSWRITEFUNCTION, hstswrite); + easy_setopt(curl, CURLOPT_HSTSWRITEDATA, &st); + easy_setopt(curl, CURLOPT_HSTS_CTRL, CURLHSTS_ENABLE); + easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config); + easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); + res = curl_easy_perform(curl); + curl_easy_cleanup(curl); + curl = NULL; curl_mprintf("Second request returned %d\n", res); test_cleanup: - curl_easy_cleanup(hnd); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; } diff --git a/tests/libtest/lib1939.c b/tests/libtest/lib1939.c index 61199900df..5a10db96b1 100644 --- a/tests/libtest/lib1939.c +++ b/tests/libtest/lib1939.c @@ -28,29 +28,29 @@ static CURLcode test_lib1939(const char *URL) { CURLM *multi; - CURL *easy; + CURL *curl; int running_handles; curl_global_init(CURL_GLOBAL_DEFAULT); multi = curl_multi_init(); if(multi) { - easy = curl_easy_init(); - if(easy) { + curl = curl_easy_init(); + if(curl) { CURLcode c; CURLMcode m; /* Crash only happens when using HTTPS */ - c = curl_easy_setopt(easy, CURLOPT_URL, URL); + c = curl_easy_setopt(curl, CURLOPT_URL, URL); if(!c) /* Any old HTTP tunneling proxy will do here */ - c = curl_easy_setopt(easy, CURLOPT_PROXY, libtest_arg2); + c = curl_easy_setopt(curl, CURLOPT_PROXY, libtest_arg2); if(!c) { /* We're going to drive the transfer using multi interface here, because we want to stop during the middle. */ - m = curl_multi_add_handle(multi, easy); + m = curl_multi_add_handle(multi, curl); if(!m) /* Run the multi handle once, just enough to start establishing an @@ -62,7 +62,7 @@ static CURLcode test_lib1939(const char *URL) } /* Close the easy handle *before* the multi handle. Doing it the other way around avoids the issue. */ - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); } curl_multi_cleanup(multi); /* double-free happens here */ } diff --git a/tests/libtest/lib1940.c b/tests/libtest/lib1940.c index 50f4010e94..117afecf2f 100644 --- a/tests/libtest/lib1940.c +++ b/tests/libtest/lib1940.c @@ -33,7 +33,7 @@ static size_t t1940_write_cb(char *data, size_t n, size_t l, void *userp) return n*l; } -static void t1940_showem(CURL *easy, int header_request, unsigned int type) +static void t1940_showem(CURL *curl, int header_request, unsigned int type) { static const char *testdata[] = { "daTE", @@ -52,7 +52,7 @@ static void t1940_showem(CURL *easy, int header_request, unsigned int type) int i; struct curl_header *header; for(i = 0; testdata[i]; i++) { - if(CURLHE_OK == curl_easy_header(easy, testdata[i], 0, + if(CURLHE_OK == curl_easy_header(curl, testdata[i], 0, type, header_request, &header)) { if(header->amount > 1) { /* more than one, iterate over them */ @@ -64,7 +64,7 @@ static void t1940_showem(CURL *easy, int header_request, unsigned int type) if(++index == amount) break; - if(CURLHE_OK != curl_easy_header(easy, testdata[i], index, + if(CURLHE_OK != curl_easy_header(curl, testdata[i], index, type, header_request, &header)) break; } while(1); @@ -79,7 +79,7 @@ static void t1940_showem(CURL *easy, int header_request, unsigned int type) static CURLcode test_lib1940(const char *URL) { - CURL *easy = NULL; + CURL *curl = NULL; CURLcode res = CURLE_OK; int header_request; @@ -91,32 +91,32 @@ static CURLcode test_lib1940(const char *URL) } global_init(CURL_GLOBAL_DEFAULT); - easy_init(easy); - easy_setopt(easy, CURLOPT_URL, URL); - easy_setopt(easy, CURLOPT_VERBOSE, 1L); - easy_setopt(easy, CURLOPT_FOLLOWLOCATION, 1L); + easy_init(curl); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); /* ignores any content */ - easy_setopt(easy, CURLOPT_WRITEFUNCTION, t1940_write_cb); + easy_setopt(curl, CURLOPT_WRITEFUNCTION, t1940_write_cb); /* if there's a proxy set, use it */ if(libtest_arg2 && *libtest_arg2) { - easy_setopt(easy, CURLOPT_PROXY, libtest_arg2); - easy_setopt(easy, CURLOPT_HTTPPROXYTUNNEL, 1L); + easy_setopt(curl, CURLOPT_PROXY, libtest_arg2); + easy_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, 1L); } - res = curl_easy_perform(easy); + res = curl_easy_perform(curl); if(res) goto test_cleanup; - t1940_showem(easy, header_request, CURLH_HEADER); + t1940_showem(curl, header_request, CURLH_HEADER); if(libtest_arg2 && *libtest_arg2) { /* now show connect headers only */ - t1940_showem(easy, header_request, CURLH_CONNECT); + t1940_showem(curl, header_request, CURLH_CONNECT); } - t1940_showem(easy, header_request, CURLH_1XX); - t1940_showem(easy, header_request, CURLH_TRAILER); + t1940_showem(curl, header_request, CURLH_1XX); + t1940_showem(curl, header_request, CURLH_TRAILER); test_cleanup: - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; } diff --git a/tests/libtest/lib1945.c b/tests/libtest/lib1945.c index 6e693bda62..f0a92d6033 100644 --- a/tests/libtest/lib1945.c +++ b/tests/libtest/lib1945.c @@ -25,13 +25,13 @@ #include "memdebug.h" -static void t1945_showem(CURL *easy, unsigned int type) +static void t1945_showem(CURL *curl, unsigned int type) { struct curl_header *header = NULL; struct curl_header *prev = NULL; /* !checksrc! disable EQUALSNULL 1 */ - while((header = curl_easy_nextheader(easy, type, 0, prev)) != NULL) { + while((header = curl_easy_nextheader(curl, type, 0, prev)) != NULL) { curl_mprintf(" %s == %s (%zu/%zu)\n", header->name, header->value, header->index, header->amount); prev = header; @@ -48,31 +48,31 @@ static size_t t1945_write_cb(char *data, size_t n, size_t l, void *userp) static CURLcode test_lib1945(const char *URL) { - CURL *easy; + CURL *curl; CURLcode res = CURLE_OK; global_init(CURL_GLOBAL_DEFAULT); - easy_init(easy); - curl_easy_setopt(easy, CURLOPT_URL, URL); - curl_easy_setopt(easy, CURLOPT_VERBOSE, 1L); - curl_easy_setopt(easy, CURLOPT_FOLLOWLOCATION, 1L); + easy_init(curl); + curl_easy_setopt(curl, CURLOPT_URL, URL); + curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); + curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); /* ignores any content */ - curl_easy_setopt(easy, CURLOPT_WRITEFUNCTION, t1945_write_cb); + curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, t1945_write_cb); /* if there's a proxy set, use it */ if(libtest_arg2 && *libtest_arg2) { - curl_easy_setopt(easy, CURLOPT_PROXY, libtest_arg2); - curl_easy_setopt(easy, CURLOPT_HTTPPROXYTUNNEL, 1L); + curl_easy_setopt(curl, CURLOPT_PROXY, libtest_arg2); + curl_easy_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, 1L); } - res = curl_easy_perform(easy); + res = curl_easy_perform(curl); if(res) { curl_mprintf("badness: %d\n", res); } - t1945_showem(easy, CURLH_CONNECT|CURLH_HEADER|CURLH_TRAILER|CURLH_1XX); + t1945_showem(curl, CURLH_CONNECT|CURLH_HEADER|CURLH_TRAILER|CURLH_1XX); test_cleanup: - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; } diff --git a/tests/libtest/lib2032.c b/tests/libtest/lib2032.c index 25de34d530..81c949ab44 100644 --- a/tests/libtest/lib2032.c +++ b/tests/libtest/lib2032.c @@ -28,13 +28,13 @@ #define MAX_EASY_HANDLES 3 static int ntlm_counter[MAX_EASY_HANDLES]; -static CURL *ntlm_easy[MAX_EASY_HANDLES]; +static CURL *ntlm_curls[MAX_EASY_HANDLES]; static curl_socket_t ntlm_sockets[MAX_EASY_HANDLES]; static CURLcode ntlmcb_res = CURLE_OK; static size_t callback(char *ptr, size_t size, size_t nmemb, void *data) { - ssize_t idx = ((CURL **) data) - ntlm_easy; + ssize_t idx = ((CURL **) data) - ntlm_curls; curl_socket_t sock; long longdata; CURLcode code; @@ -44,7 +44,7 @@ static size_t callback(char *ptr, size_t size, size_t nmemb, void *data) ntlm_counter[idx] += (int)(size * nmemb); /* Get socket being used for this easy handle, otherwise CURL_SOCKET_BAD */ - code = curl_easy_getinfo(ntlm_easy[idx], CURLINFO_LASTSOCKET, &longdata); + code = curl_easy_getinfo(ntlm_curls[idx], CURLINFO_LASTSOCKET, &longdata); if(CURLE_OK != code) { curl_mfprintf(stderr, "%s:%d curl_easy_getinfo() failed, " @@ -102,7 +102,7 @@ static CURLcode test_lib2032(const char *URL) /* libntlmconnect */ } for(i = 0; i < MAX_EASY_HANDLES; ++i) { - ntlm_easy[i] = NULL; + ntlm_curls[i] = NULL; ntlm_sockets[i] = CURL_SOCKET_BAD; } @@ -125,28 +125,28 @@ static CURLcode test_lib2032(const char *URL) /* libntlmconnect */ /* Start a new handle if we aren't at the max */ if(state == ReadyForNewHandle) { - easy_init(ntlm_easy[num_handles]); + easy_init(ntlm_curls[num_handles]); if(num_handles % 3 == 2) { curl_msnprintf(full_url, urllen, "%s0200", URL); - easy_setopt(ntlm_easy[num_handles], CURLOPT_HTTPAUTH, CURLAUTH_NTLM); + easy_setopt(ntlm_curls[num_handles], CURLOPT_HTTPAUTH, CURLAUTH_NTLM); } else { curl_msnprintf(full_url, urllen, "%s0100", URL); - easy_setopt(ntlm_easy[num_handles], CURLOPT_HTTPAUTH, CURLAUTH_BASIC); + easy_setopt(ntlm_curls[num_handles], CURLOPT_HTTPAUTH, CURLAUTH_BASIC); } - easy_setopt(ntlm_easy[num_handles], CURLOPT_FRESH_CONNECT, 1L); - easy_setopt(ntlm_easy[num_handles], CURLOPT_URL, full_url); - easy_setopt(ntlm_easy[num_handles], CURLOPT_VERBOSE, 1L); - easy_setopt(ntlm_easy[num_handles], CURLOPT_HTTPGET, 1L); - easy_setopt(ntlm_easy[num_handles], CURLOPT_USERPWD, + easy_setopt(ntlm_curls[num_handles], CURLOPT_FRESH_CONNECT, 1L); + easy_setopt(ntlm_curls[num_handles], CURLOPT_URL, full_url); + easy_setopt(ntlm_curls[num_handles], CURLOPT_VERBOSE, 1L); + easy_setopt(ntlm_curls[num_handles], CURLOPT_HTTPGET, 1L); + easy_setopt(ntlm_curls[num_handles], CURLOPT_USERPWD, "testuser:testpass"); - easy_setopt(ntlm_easy[num_handles], CURLOPT_WRITEFUNCTION, callback); - easy_setopt(ntlm_easy[num_handles], CURLOPT_WRITEDATA, - (void *)(ntlm_easy + num_handles)); - easy_setopt(ntlm_easy[num_handles], CURLOPT_HEADER, 1L); + easy_setopt(ntlm_curls[num_handles], CURLOPT_WRITEFUNCTION, callback); + easy_setopt(ntlm_curls[num_handles], CURLOPT_WRITEDATA, + (void *)(ntlm_curls + num_handles)); + easy_setopt(ntlm_curls[num_handles], CURLOPT_HEADER, 1L); - multi_add_handle(multi, ntlm_easy[num_handles]); + multi_add_handle(multi, ntlm_curls[num_handles]); num_handles += 1; state = NeedSocketForNewHandle; res = ntlmcb_res; @@ -223,8 +223,8 @@ test_cleanup: for(i = 0; i < MAX_EASY_HANDLES; i++) { curl_mprintf("Data connection %d: %d\n", i, ntlm_counter[i]); - curl_multi_remove_handle(multi, ntlm_easy[i]); - curl_easy_cleanup(ntlm_easy[i]); + curl_multi_remove_handle(multi, ntlm_curls[i]); + curl_easy_cleanup(ntlm_curls[i]); } curl_multi_cleanup(multi); diff --git a/tests/libtest/lib2301.c b/tests/libtest/lib2301.c index cc6c00a1d4..40e357a3ba 100644 --- a/tests/libtest/lib2301.c +++ b/tests/libtest/lib2301.c @@ -42,7 +42,7 @@ static void t2301_websocket(CURL *curl) static size_t t2301_write_cb(char *b, size_t size, size_t nitems, void *p) { - CURL *easy = p; + CURL *curl = p; unsigned char *buffer = (unsigned char *)b; size_t i; size_t sent; @@ -59,7 +59,7 @@ static size_t t2301_write_cb(char *b, size_t size, size_t nitems, void *p) if(buffer[0] == 0x89) { CURLcode result; curl_mfprintf(stderr, "send back a simple PONG\n"); - result = curl_ws_send(easy, pong, 2, &sent, 0, 0); + result = curl_ws_send(curl, pong, 2, &sent, 0, 0); if(result) nitems = 0; } diff --git a/tests/libtest/lib2302.c b/tests/libtest/lib2302.c index d72761a851..47276197bb 100644 --- a/tests/libtest/lib2302.c +++ b/tests/libtest/lib2302.c @@ -26,7 +26,7 @@ #ifndef CURL_DISABLE_WEBSOCKETS struct ws_data { - CURL *easy; + CURL *curl; char *buf; size_t blen; size_t nwrites; @@ -83,7 +83,7 @@ static size_t t2302_write_cb(char *buffer, size_t size, size_t nitems, void *p) const struct curl_ws_frame *meta; (void)size; - meta = curl_ws_meta(ws_data->easy); + meta = curl_ws_meta(ws_data->curl); incoming = add_data(ws_data, buffer, incoming, meta); if(nitems != incoming) @@ -106,7 +106,7 @@ static CURLcode test_lib2302(const char *URL) if(ws_data.buf) { curl = curl_easy_init(); if(curl) { - ws_data.easy = curl; + ws_data.curl = curl; curl_easy_setopt(curl, CURLOPT_URL, URL); /* use the callback style */ diff --git a/tests/libtest/lib2306.c b/tests/libtest/lib2306.c index d2832e1cb2..6b60ea6376 100644 --- a/tests/libtest/lib2306.c +++ b/tests/libtest/lib2306.c @@ -26,24 +26,24 @@ static CURLcode test_lib2306(const char *URL) { /* first a fine GET response, then a bad one */ - CURL *cl; + CURL *curl; CURLcode res = CURLE_OK; global_init(CURL_GLOBAL_ALL); - easy_init(cl); - easy_setopt(cl, CURLOPT_URL, URL); - easy_setopt(cl, CURLOPT_VERBOSE, 1L); - res = curl_easy_perform(cl); + easy_init(curl); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); + res = curl_easy_perform(curl); if(res) goto test_cleanup; /* reuse handle, do a second transfer */ - easy_setopt(cl, CURLOPT_URL, libtest_arg2); - res = curl_easy_perform(cl); + easy_setopt(curl, CURLOPT_URL, libtest_arg2); + res = curl_easy_perform(curl); test_cleanup: - curl_easy_cleanup(cl); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; } diff --git a/tests/libtest/lib2402.c b/tests/libtest/lib2402.c index ef3dc226a0..1695208716 100644 --- a/tests/libtest/lib2402.c +++ b/tests/libtest/lib2402.c @@ -30,7 +30,7 @@ static CURLcode test_lib2402(const char *URL) CURLcode res = CURLE_OK; CURL *curl[NUM_HANDLES] = {0}; int running; - CURLM *m = NULL; + CURLM *multi = NULL; size_t i; char target_url[256]; char dnsentry[256]; @@ -53,9 +53,9 @@ static CURLcode test_lib2402(const char *URL) global_init(CURL_GLOBAL_ALL); - multi_init(m); + multi_init(multi); - multi_setopt(m, CURLMOPT_MAXCONNECTS, 1L); + multi_setopt(multi, CURLMOPT_MAXCONNECTS, 1L); /* get each easy handle */ for(i = 0; i < CURL_ARRAYSIZE(curl); i++) { @@ -86,7 +86,7 @@ static CURLcode test_lib2402(const char *URL) for(i = 0; i < CURL_ARRAYSIZE(curl); i++) { /* add handle to multi */ - multi_add_handle(m, curl[i]); + multi_add_handle(multi, curl[i]); for(;;) { struct timeval interval; @@ -96,7 +96,7 @@ static CURLcode test_lib2402(const char *URL) interval.tv_sec = 1; interval.tv_usec = 0; - multi_perform(m, &running); + multi_perform(multi, &running); abort_on_test_timeout(); @@ -107,7 +107,7 @@ static CURLcode test_lib2402(const char *URL) FD_ZERO(&wr); FD_ZERO(&exc); - multi_fdset(m, &rd, &wr, &exc, &maxfd); + multi_fdset(multi, &rd, &wr, &exc, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ @@ -123,13 +123,13 @@ test_cleanup: /* proper cleanup sequence - type PB */ for(i = 0; i < CURL_ARRAYSIZE(curl); i++) { - curl_multi_remove_handle(m, curl[i]); + curl_multi_remove_handle(multi, curl[i]); curl_easy_cleanup(curl[i]); } curl_slist_free_all(slist); - curl_multi_cleanup(m); + curl_multi_cleanup(multi); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib2404.c b/tests/libtest/lib2404.c index 8551957e0b..42d81d8d4a 100644 --- a/tests/libtest/lib2404.c +++ b/tests/libtest/lib2404.c @@ -30,7 +30,7 @@ static CURLcode test_lib2404(const char *URL) CURLcode res = CURLE_OK; CURL *curl[NUM_HANDLES] = {0}; int running; - CURLM *m = NULL; + CURLM *multi = NULL; size_t i; char target_url[256]; char dnsentry[256]; @@ -53,9 +53,9 @@ static CURLcode test_lib2404(const char *URL) global_init(CURL_GLOBAL_ALL); - multi_init(m); + multi_init(multi); - multi_setopt(m, CURLMOPT_MAXCONNECTS, 1L); + multi_setopt(multi, CURLMOPT_MAXCONNECTS, 1L); /* get each easy handle */ for(i = 0; i < CURL_ARRAYSIZE(curl); i++) { @@ -88,7 +88,7 @@ static CURLcode test_lib2404(const char *URL) for(i = 0; i < CURL_ARRAYSIZE(curl); i++) { /* add handle to multi */ - multi_add_handle(m, curl[i]); + multi_add_handle(multi, curl[i]); for(;;) { struct timeval interval; @@ -98,7 +98,7 @@ static CURLcode test_lib2404(const char *URL) interval.tv_sec = 1; interval.tv_usec = 0; - multi_perform(m, &running); + multi_perform(multi, &running); abort_on_test_timeout(); @@ -109,7 +109,7 @@ static CURLcode test_lib2404(const char *URL) FD_ZERO(&wr); FD_ZERO(&exc); - multi_fdset(m, &rd, &wr, &exc, &maxfd); + multi_fdset(multi, &rd, &wr, &exc, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ @@ -125,13 +125,13 @@ test_cleanup: /* proper cleanup sequence - type PB */ for(i = 0; i < CURL_ARRAYSIZE(curl); i++) { - curl_multi_remove_handle(m, curl[i]); + curl_multi_remove_handle(multi, curl[i]); curl_easy_cleanup(curl[i]); } curl_slist_free_all(slist); - curl_multi_cleanup(m); + curl_multi_cleanup(multi); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib2405.c b/tests/libtest/lib2405.c index 571a0bcaa8..8d7f9056ff 100644 --- a/tests/libtest/lib2405.c +++ b/tests/libtest/lib2405.c @@ -74,43 +74,43 @@ static size_t emptyWriteFunc(void *ptr, size_t size, size_t nmemb, return size * nmemb; } -static CURLcode set_easy(const char *URL, CURL *easy, long option) +static CURLcode set_easy(const char *URL, CURL *curl, long option) { CURLcode res = CURLE_OK; /* First set the URL that is about to receive our POST. */ - easy_setopt(easy, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_URL, URL); /* get verbose debug output please */ - easy_setopt(easy, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); switch(option) { case TEST_USE_HTTP1: /* go http1 */ - easy_setopt(easy, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1); + easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1); break; case TEST_USE_HTTP2: /* go http2 */ - easy_setopt(easy, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0); + easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0); break; case TEST_USE_HTTP2_MPLEX: /* go http2 with multiplexing */ - easy_setopt(easy, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0); - easy_setopt(easy, CURLOPT_PIPEWAIT, 1L); + easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0); + easy_setopt(curl, CURLOPT_PIPEWAIT, 1L); break; } /* no peer verify */ - easy_setopt(easy, CURLOPT_SSL_VERIFYPEER, 0L); - easy_setopt(easy, CURLOPT_SSL_VERIFYHOST, 0L); + easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L); + easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L); /* include headers */ - easy_setopt(easy, CURLOPT_HEADER, 1L); + easy_setopt(curl, CURLOPT_HEADER, 1L); /* empty write function */ - easy_setopt(easy, CURLOPT_WRITEFUNCTION, emptyWriteFunc); + easy_setopt(curl, CURLOPT_WRITEFUNCTION, emptyWriteFunc); test_cleanup: return res; @@ -123,8 +123,8 @@ static CURLcode test_run(const char *URL, long option, CURLM *multi = NULL; CURLM *multi1 = NULL; - CURL *easy1 = NULL; - CURL *easy2 = NULL; + CURL *curl1 = NULL; + CURL *curl2 = NULL; unsigned int max_count = 0; @@ -139,13 +139,13 @@ static CURLcode test_run(const char *URL, long option, struct curl_waitfd ufds1[10]; int numfds; - easy_init(easy1); - easy_init(easy2); + easy_init(curl1); + easy_init(curl2); - if(set_easy(URL, easy1, option) != CURLE_OK) + if(set_easy(URL, curl1, option) != CURLE_OK) goto test_cleanup; - if(set_easy(URL, easy2, option) != CURLE_OK) + if(set_easy(URL, curl2, option) != CURLE_OK) goto test_cleanup; multi_init(multi); @@ -154,8 +154,8 @@ static CURLcode test_run(const char *URL, long option, if(option == TEST_USE_HTTP2_MPLEX) multi_setopt(multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX); - multi_add_handle(multi, easy1); - multi_add_handle(multi, easy2); + multi_add_handle(multi, curl1); + multi_add_handle(multi, curl2); while(!mc) { /* get the count of file descriptors from the transfers */ @@ -293,12 +293,12 @@ static CURLcode test_run(const char *URL, long option, } } - curl_multi_remove_handle(multi, easy1); - curl_multi_remove_handle(multi, easy2); + curl_multi_remove_handle(multi, curl1); + curl_multi_remove_handle(multi, curl2); test_cleanup: - curl_easy_cleanup(easy1); - curl_easy_cleanup(easy2); + curl_easy_cleanup(curl1); + curl_easy_cleanup(curl2); curl_multi_cleanup(multi); curl_multi_cleanup(multi1); @@ -313,7 +313,7 @@ static CURLcode empty_multi_test(void) { CURLMcode mc = CURLM_OK; CURLM *multi = NULL; - CURL *easy = NULL; + CURL *curl = NULL; struct curl_waitfd ufds[10]; @@ -338,12 +338,12 @@ static CURLcode empty_multi_test(void) } /* calling curl_multi_waitfds() on multi handle with added easy handle. */ - easy_init(easy); + easy_init(curl); - if(set_easy("http://example.com", easy, TEST_USE_HTTP1) != CURLE_OK) + if(set_easy("http://example.com", curl, TEST_USE_HTTP1) != CURLE_OK) goto test_cleanup; - multi_add_handle(multi, easy); + multi_add_handle(multi, curl); mc = curl_multi_waitfds(multi, ufds, 10, &fd_count); @@ -359,10 +359,10 @@ static CURLcode empty_multi_test(void) goto test_cleanup; } - curl_multi_remove_handle(multi, easy); + curl_multi_remove_handle(multi, curl); test_cleanup: - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); curl_multi_cleanup(multi); return res; } diff --git a/tests/libtest/lib2502.c b/tests/libtest/lib2502.c index ba7da99a07..b9a2cabd79 100644 --- a/tests/libtest/lib2502.c +++ b/tests/libtest/lib2502.c @@ -31,7 +31,7 @@ static CURLcode test_lib2502(const char *URL) CURLcode res = CURLE_OK; CURL *curl[NUM_HANDLES] = {0}; int running; - CURLM *m = NULL; + CURLM *multi = NULL; size_t i; char target_url[256]; char dnsentry[256]; @@ -54,9 +54,9 @@ static CURLcode test_lib2502(const char *URL) global_init(CURL_GLOBAL_ALL); - multi_init(m); + multi_init(multi); - multi_setopt(m, CURLMOPT_MAXCONNECTS, 1L); + multi_setopt(multi, CURLMOPT_MAXCONNECTS, 1L); /* get each easy handle */ for(i = 0; i < CURL_ARRAYSIZE(curl); i++) { @@ -90,7 +90,7 @@ static CURLcode test_lib2502(const char *URL) for(i = 0; i < CURL_ARRAYSIZE(curl); i++) { /* add handle to multi */ - multi_add_handle(m, curl[i]); + multi_add_handle(multi, curl[i]); for(;;) { struct timeval interval; @@ -100,7 +100,7 @@ static CURLcode test_lib2502(const char *URL) interval.tv_sec = 1; interval.tv_usec = 0; - multi_perform(m, &running); + multi_perform(multi, &running); abort_on_test_timeout(); @@ -111,7 +111,7 @@ static CURLcode test_lib2502(const char *URL) FD_ZERO(&wr); FD_ZERO(&exc); - multi_fdset(m, &rd, &wr, &exc, &maxfd); + multi_fdset(multi, &rd, &wr, &exc, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ @@ -127,13 +127,13 @@ test_cleanup: /* proper cleanup sequence - type PB */ for(i = 0; i < CURL_ARRAYSIZE(curl); i++) { - curl_multi_remove_handle(m, curl[i]); + curl_multi_remove_handle(multi, curl[i]); curl_easy_cleanup(curl[i]); } curl_slist_free_all(slist); - curl_multi_cleanup(m); + curl_multi_cleanup(multi); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib3027.c b/tests/libtest/lib3027.c index 735f4c96e9..5cd2bd757d 100644 --- a/tests/libtest/lib3027.c +++ b/tests/libtest/lib3027.c @@ -28,26 +28,26 @@ static CURLcode test_lib3027(const char *URL) { CURLcode ret = CURLE_OK; - CURL *hnd; + CURL *curl; start_test_timing(); curl_global_init(CURL_GLOBAL_ALL); - hnd = curl_easy_init(); - if(hnd) { - curl_easy_setopt(hnd, CURLOPT_URL, URL); - curl_easy_setopt(hnd, CURLOPT_FILETIME, 1L); - ret = curl_easy_perform(hnd); + curl = curl_easy_init(); + if(curl) { + curl_easy_setopt(curl, CURLOPT_URL, URL); + curl_easy_setopt(curl, CURLOPT_FILETIME, 1L); + ret = curl_easy_perform(curl); if(CURLE_OK == ret) { long filetime; - ret = curl_easy_getinfo(hnd, CURLINFO_FILETIME, &filetime); + ret = curl_easy_getinfo(curl, CURLINFO_FILETIME, &filetime); /* MTDM fails with 550, so filetime should be -1 */ if((CURLE_OK == ret) && (filetime != -1)) { /* we just need to return something which is not CURLE_OK */ ret = CURLE_UNSUPPORTED_PROTOCOL; } } - curl_easy_cleanup(hnd); + curl_easy_cleanup(curl); } curl_global_cleanup(); return ret; diff --git a/tests/libtest/lib3033.c b/tests/libtest/lib3033.c index 1c0b9856fc..b00bba9e74 100644 --- a/tests/libtest/lib3033.c +++ b/tests/libtest/lib3033.c @@ -27,7 +27,7 @@ #include "memdebug.h" -static CURLcode t3033_req_test(CURLM *multi, CURL *easy, +static CURLcode t3033_req_test(CURLM *multi, CURL *curl, const char *URL, int index) { CURLMsg *msg = NULL; @@ -43,13 +43,13 @@ static CURLcode t3033_req_test(CURLM *multi, CURL *easy, curl_mprintf("[%d] no network change\n", index); } - curl_easy_reset(easy); - curl_easy_setopt(easy, CURLOPT_URL, URL); - easy_setopt(easy, CURLOPT_DEBUGDATA, &debug_config); - easy_setopt(easy, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); - easy_setopt(easy, CURLOPT_VERBOSE, 1L); + curl_easy_reset(curl); + curl_easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config); + easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); - curl_multi_add_handle(multi, easy); + curl_multi_add_handle(multi, curl); do { CURLMcode mres; @@ -76,7 +76,7 @@ static CURLcode t3033_req_test(CURLM *multi, CURL *easy, goto test_cleanup; } - curl_easy_getinfo(easy, CURLINFO_NUM_CONNECTS, &num_connects); + curl_easy_getinfo(curl, CURLINFO_NUM_CONNECTS, &num_connects); if(index == 1 && num_connects == 0) { curl_mprintf("[1] should not reuse connection in pool\n"); res = TEST_ERR_MAJOR_BAD; @@ -92,7 +92,7 @@ static CURLcode t3033_req_test(CURLM *multi, CURL *easy, test_cleanup: - curl_multi_remove_handle(multi, easy); + curl_multi_remove_handle(multi, curl); return res; } diff --git a/tests/libtest/lib3105.c b/tests/libtest/lib3105.c index 29dfdae00c..808fd98ca4 100644 --- a/tests/libtest/lib3105.c +++ b/tests/libtest/lib3105.c @@ -27,7 +27,7 @@ static CURLcode test_lib3105(const char *URL) { - CURL *curls = NULL; + CURL *curl = NULL; CURLM *multi = NULL; CURLcode i = CURLE_OK; CURLcode res = CURLE_OK; @@ -37,14 +37,14 @@ static CURLcode test_lib3105(const char *URL) multi_init(multi); - easy_init(curls); + easy_init(curl); - easy_setopt(curls, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_URL, URL); - multi_add_handle(multi, curls); + multi_add_handle(multi, curl); - mc = curl_multi_remove_handle(multi, curls); - mc += curl_multi_remove_handle(multi, curls); + mc = curl_multi_remove_handle(multi, curl); + mc += curl_multi_remove_handle(multi, curl); if(mc) { curl_mfprintf(stderr, "%d was unexpected\n", mc); @@ -53,7 +53,7 @@ static CURLcode test_lib3105(const char *URL) test_cleanup: curl_multi_cleanup(multi); - curl_easy_cleanup(curls); + curl_easy_cleanup(curl); curl_global_cleanup(); if(res) diff --git a/tests/libtest/lib3207.c b/tests/libtest/lib3207.c index e3b50ff40f..316258c86e 100644 --- a/tests/libtest/lib3207.c +++ b/tests/libtest/lib3207.c @@ -115,19 +115,19 @@ test_cleanup: #if defined(USE_THREADS_POSIX) || defined(USE_THREADS_WIN32) -static void t3207_test_lock(CURL *handle, curl_lock_data data, +static void t3207_test_lock(CURL *curl, curl_lock_data data, curl_lock_access laccess, void *useptr) { curl_mutex_t *mutexes = (curl_mutex_t*) useptr; - (void)handle; + (void)curl; (void)laccess; Curl_mutex_acquire(&mutexes[data]); } -static void t3207_test_unlock(CURL *handle, curl_lock_data data, void *useptr) +static void t3207_test_unlock(CURL *curl, curl_lock_data data, void *useptr) { curl_mutex_t *mutexes = (curl_mutex_t*) useptr; - (void)handle; + (void)curl; Curl_mutex_release(&mutexes[data]); } diff --git a/tests/libtest/lib502.c b/tests/libtest/lib502.c index 9a51267aae..c33783ea68 100644 --- a/tests/libtest/lib502.c +++ b/tests/libtest/lib502.c @@ -31,8 +31,8 @@ static CURLcode test_lib502(const char *URL) { - CURL *c = NULL; - CURLM *m = NULL; + CURL *curl = NULL; + CURLM *multi = NULL; CURLcode res = CURLE_OK; int running; @@ -40,13 +40,13 @@ static CURLcode test_lib502(const char *URL) global_init(CURL_GLOBAL_ALL); - easy_init(c); + easy_init(curl); - easy_setopt(c, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_URL, URL); - multi_init(m); + multi_init(multi); - multi_add_handle(m, c); + multi_add_handle(multi, curl); for(;;) { struct timeval timeout; @@ -56,7 +56,7 @@ static CURLcode test_lib502(const char *URL) timeout.tv_sec = 0; timeout.tv_usec = 100000L; /* 100 ms */ - multi_perform(m, &running); + multi_perform(multi, &running); abort_on_test_timeout(); @@ -67,7 +67,7 @@ static CURLcode test_lib502(const char *URL) FD_ZERO(&fdwrite); FD_ZERO(&fdexcep); - multi_fdset(m, &fdread, &fdwrite, &fdexcep, &maxfd); + multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ @@ -80,9 +80,9 @@ test_cleanup: /* proper cleanup sequence - type PA */ - curl_multi_remove_handle(m, c); - curl_multi_cleanup(m); - curl_easy_cleanup(c); + curl_multi_remove_handle(multi, curl); + curl_multi_cleanup(multi); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib503.c b/tests/libtest/lib503.c index f7529d47b7..34a6105bf7 100644 --- a/tests/libtest/lib503.c +++ b/tests/libtest/lib503.c @@ -35,8 +35,8 @@ static CURLcode test_lib503(const char *URL) { - CURL *c = NULL; - CURLM *m = NULL; + CURL *curl = NULL; + CURLM *multi = NULL; CURLcode res = CURLE_OK; int running; @@ -44,20 +44,20 @@ static CURLcode test_lib503(const char *URL) global_init(CURL_GLOBAL_ALL); - easy_init(c); + easy_init(curl); - easy_setopt(c, CURLOPT_PROXY, libtest_arg2); /* set in first.c */ - easy_setopt(c, CURLOPT_URL, URL); - easy_setopt(c, CURLOPT_USERPWD, "test:ing"); - easy_setopt(c, CURLOPT_PROXYUSERNAME, "test%20"); - easy_setopt(c, CURLOPT_PROXYPASSWORD, "ing%41"); - easy_setopt(c, CURLOPT_HTTPPROXYTUNNEL, 1L); - easy_setopt(c, CURLOPT_HEADER, 1L); - easy_setopt(c, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_PROXY, libtest_arg2); /* set in first.c */ + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_USERPWD, "test:ing"); + easy_setopt(curl, CURLOPT_PROXYUSERNAME, "test%20"); + easy_setopt(curl, CURLOPT_PROXYPASSWORD, "ing%41"); + easy_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, 1L); + easy_setopt(curl, CURLOPT_HEADER, 1L); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); - multi_init(m); + multi_init(multi); - multi_add_handle(m, c); + multi_add_handle(multi, curl); for(;;) { struct timeval interval; @@ -67,7 +67,7 @@ static CURLcode test_lib503(const char *URL) interval.tv_sec = 1; interval.tv_usec = 0; - multi_perform(m, &running); + multi_perform(multi, &running); abort_on_test_timeout(); @@ -78,7 +78,7 @@ static CURLcode test_lib503(const char *URL) FD_ZERO(&wr); FD_ZERO(&exc); - multi_fdset(m, &rd, &wr, &exc, &maxfd); + multi_fdset(multi, &rd, &wr, &exc, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ @@ -91,9 +91,9 @@ test_cleanup: /* proper cleanup sequence - type PA */ - curl_multi_remove_handle(m, c); - curl_multi_cleanup(m); - curl_easy_cleanup(c); + curl_multi_remove_handle(multi, curl); + curl_multi_cleanup(multi); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib504.c b/tests/libtest/lib504.c index 07b46345bb..fa9338f262 100644 --- a/tests/libtest/lib504.c +++ b/tests/libtest/lib504.c @@ -34,9 +34,9 @@ */ static CURLcode test_lib504(const char *URL) { - CURL *c = NULL; + CURL *curl = NULL; CURLcode res = CURLE_OK; - CURLM *m = NULL; + CURLM *multi = NULL; fd_set rd, wr, exc; int running; @@ -44,18 +44,18 @@ static CURLcode test_lib504(const char *URL) global_init(CURL_GLOBAL_ALL); - easy_init(c); + easy_init(curl); /* The point here is that there must not be anything running on the given proxy port */ if(libtest_arg2) - easy_setopt(c, CURLOPT_PROXY, libtest_arg2); - easy_setopt(c, CURLOPT_URL, URL); - easy_setopt(c, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_PROXY, libtest_arg2); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); - multi_init(m); + multi_init(multi); - multi_add_handle(m, c); + multi_add_handle(multi, curl); for(;;) { struct timeval interval; @@ -66,12 +66,12 @@ static CURLcode test_lib504(const char *URL) curl_mfprintf(stderr, "curl_multi_perform()\n"); - multi_perform(m, &running); + multi_perform(multi, &running); while(running) { CURLMcode mres; int num; - mres = curl_multi_wait(m, NULL, 0, TEST_HANG_TIMEOUT, &num); + mres = curl_multi_wait(multi, NULL, 0, TEST_HANG_TIMEOUT, &num); if(mres != CURLM_OK) { curl_mprintf("curl_multi_wait() returned %d\n", mres); res = TEST_ERR_MAJOR_BAD; @@ -79,7 +79,7 @@ static CURLcode test_lib504(const char *URL) } abort_on_test_timeout(); - multi_perform(m, &running); + multi_perform(multi, &running); abort_on_test_timeout(); } @@ -88,7 +88,7 @@ static CURLcode test_lib504(const char *URL) if(!running) { /* This is where this code is expected to reach */ int numleft; - CURLMsg *msg = curl_multi_info_read(m, &numleft); + CURLMsg *msg = curl_multi_info_read(multi, &numleft); curl_mfprintf(stderr, "Expected: not running\n"); if(msg && !numleft) res = TEST_ERR_SUCCESS; /* this is where we should be */ @@ -104,7 +104,7 @@ static CURLcode test_lib504(const char *URL) curl_mfprintf(stderr, "curl_multi_fdset()\n"); - multi_fdset(m, &rd, &wr, &exc, &maxfd); + multi_fdset(multi, &rd, &wr, &exc, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ @@ -117,9 +117,9 @@ test_cleanup: /* proper cleanup sequence - type PA */ - curl_multi_remove_handle(m, c); - curl_multi_cleanup(m); - curl_easy_cleanup(c); + curl_multi_remove_handle(multi, curl); + curl_multi_cleanup(multi); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib506.c b/tests/libtest/lib506.c index 4b6eb05f81..7971fbeb17 100644 --- a/tests/libtest/lib506.c +++ b/tests/libtest/lib506.c @@ -42,14 +42,14 @@ struct t506_userdata { static int locks[3]; /* lock callback */ -static void t506_test_lock(CURL *handle, curl_lock_data data, +static void t506_test_lock(CURL *curl, curl_lock_data data, curl_lock_access laccess, void *useptr) { const char *what; struct t506_userdata *user = (struct t506_userdata *)useptr; int locknum; - (void)handle; + (void)curl; (void)laccess; switch(data) { @@ -82,12 +82,12 @@ static void t506_test_lock(CURL *handle, curl_lock_data data, } /* unlock callback */ -static void t506_test_unlock(CURL *handle, curl_lock_data data, void *useptr) +static void t506_test_unlock(CURL *curl, curl_lock_data data, void *useptr) { const char *what; struct t506_userdata *user = (struct t506_userdata *)useptr; int locknum; - (void)handle; + (void)curl; switch(data) { case CURL_LOCK_DATA_SHARE: what = "share"; diff --git a/tests/libtest/lib507.c b/tests/libtest/lib507.c index de23b02f0a..9a306d39a6 100644 --- a/tests/libtest/lib507.c +++ b/tests/libtest/lib507.c @@ -27,7 +27,7 @@ static CURLcode test_lib507(const char *URL) { - CURL *curls = NULL; + CURL *curl = NULL; CURLM *multi = NULL; int still_running; CURLcode i = TEST_ERR_MAJOR_BAD; @@ -40,12 +40,12 @@ static CURLcode test_lib507(const char *URL) multi_init(multi); - easy_init(curls); + easy_init(curl); - easy_setopt(curls, CURLOPT_URL, URL); - easy_setopt(curls, CURLOPT_HEADER, 1L); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_HEADER, 1L); - multi_add_handle(multi, curls); + multi_add_handle(multi, curl); multi_perform(multi, &still_running); @@ -88,7 +88,7 @@ test_cleanup: /* undocumented cleanup sequence - type UA */ curl_multi_cleanup(multi); - curl_easy_cleanup(curls); + curl_easy_cleanup(curl); curl_global_cleanup(); if(res) diff --git a/tests/libtest/lib525.c b/tests/libtest/lib525.c index 55224eb76e..4c33973ec9 100644 --- a/tests/libtest/lib525.c +++ b/tests/libtest/lib525.c @@ -33,7 +33,7 @@ static CURLcode test_lib525(const char *URL) FILE *hd_src = NULL; int hd; struct_stat file_info; - CURLM *m = NULL; + CURLM *multi = NULL; int running; start_test_timing(); @@ -101,9 +101,9 @@ static CURLcode test_lib525(const char *URL) make sure that to pass in a type 'long' argument. */ easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)file_info.st_size); - multi_init(m); + multi_init(multi); - multi_add_handle(m, curl); + multi_add_handle(multi, curl); for(;;) { struct timeval interval; @@ -113,7 +113,7 @@ static CURLcode test_lib525(const char *URL) interval.tv_sec = 1; interval.tv_usec = 0; - multi_perform(m, &running); + multi_perform(multi, &running); abort_on_test_timeout(); @@ -124,7 +124,7 @@ static CURLcode test_lib525(const char *URL) FD_ZERO(&wr); FD_ZERO(&exc); - multi_fdset(m, &rd, &wr, &exc, &maxfd); + multi_fdset(multi, &rd, &wr, &exc, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ @@ -137,16 +137,16 @@ test_cleanup: if(testnum == 529) { /* proper cleanup sequence - type PA */ - curl_multi_remove_handle(m, curl); - curl_multi_cleanup(m); + curl_multi_remove_handle(multi, curl); + curl_multi_cleanup(multi); curl_easy_cleanup(curl); curl_global_cleanup(); } else { /* testnum == 525 */ /* proper cleanup sequence - type PB */ - curl_multi_remove_handle(m, curl); + curl_multi_remove_handle(multi, curl); curl_easy_cleanup(curl); - curl_multi_cleanup(m); + curl_multi_cleanup(multi); curl_global_cleanup(); } diff --git a/tests/libtest/lib526.c b/tests/libtest/lib526.c index 963181713b..6f586c5a3e 100644 --- a/tests/libtest/lib526.c +++ b/tests/libtest/lib526.c @@ -49,7 +49,7 @@ static CURLcode test_lib526(const char *URL) CURLcode res = CURLE_OK; CURL *curl[NUM_HANDLES]; int running; - CURLM *m = NULL; + CURLM *multi = NULL; size_t current = 0; size_t i; @@ -69,9 +69,9 @@ static CURLcode test_lib526(const char *URL) easy_setopt(curl[i], CURLOPT_VERBOSE, 1L); } - multi_init(m); + multi_init(multi); - multi_add_handle(m, curl[current]); + multi_add_handle(multi, curl[current]); curl_mfprintf(stderr, "Start at URL 0\n"); @@ -83,7 +83,7 @@ static CURLcode test_lib526(const char *URL) interval.tv_sec = 1; interval.tv_usec = 0; - multi_perform(m, &running); + multi_perform(multi, &running); abort_on_test_timeout(); @@ -99,7 +99,7 @@ static CURLcode test_lib526(const char *URL) curl_mfprintf(stderr, "Advancing to URL %zu\n", current); if(testnum == 532) { /* first remove the only handle we use */ - curl_multi_remove_handle(m, curl[0]); + curl_multi_remove_handle(multi, curl[0]); /* make us reuse the same handle all the time, and try resetting the handle first too */ @@ -109,10 +109,10 @@ static CURLcode test_lib526(const char *URL) easy_setopt(curl[0], CURLOPT_VERBOSE, 1L); /* re-add it */ - multi_add_handle(m, curl[0]); + multi_add_handle(multi, curl[0]); } else { - multi_add_handle(m, curl[current]); + multi_add_handle(multi, curl[current]); } } else { @@ -124,7 +124,7 @@ static CURLcode test_lib526(const char *URL) FD_ZERO(&wr); FD_ZERO(&exc); - multi_fdset(m, &rd, &wr, &exc, &maxfd); + multi_fdset(multi, &rd, &wr, &exc, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ @@ -139,10 +139,10 @@ test_cleanup: /* proper cleanup sequence - type PB */ for(i = 0; i < CURL_ARRAYSIZE(curl); i++) { - curl_multi_remove_handle(m, curl[i]); + curl_multi_remove_handle(multi, curl[i]); curl_easy_cleanup(curl[i]); } - curl_multi_cleanup(m); + curl_multi_cleanup(multi); curl_global_cleanup(); } else if(testnum == 527) { @@ -155,7 +155,7 @@ test_cleanup: for(i = 0; i < CURL_ARRAYSIZE(curl); i++) curl_easy_cleanup(curl[i]); - curl_multi_cleanup(m); + curl_multi_cleanup(multi); curl_global_cleanup(); } @@ -164,7 +164,7 @@ test_cleanup: for(i = 0; i < CURL_ARRAYSIZE(curl); i++) curl_easy_cleanup(curl[i]); - curl_multi_cleanup(m); + curl_multi_cleanup(multi); curl_global_cleanup(); } diff --git a/tests/libtest/lib530.c b/tests/libtest/lib530.c index 7d8cc3cbcb..5558487122 100644 --- a/tests/libtest/lib530.c +++ b/tests/libtest/lib530.c @@ -131,12 +131,12 @@ static int t530_addFd(struct t530_Sockets *sockets, curl_socket_t fd, /** * Callback invoked by curl to poll reading / writing of a socket. */ -static int t530_curlSocketCallback(CURL *easy, curl_socket_t s, int action, +static int t530_curlSocketCallback(CURL *curl, curl_socket_t s, int action, void *userp, void *socketp) { struct t530_ReadWriteSockets *sockets = userp; - (void)easy; + (void)curl; (void)socketp; t530_ctx.socket_calls++; @@ -189,13 +189,13 @@ static int t530_curlTimerCallback(CURLM *multi, long timeout_ms, void *userp) /** * Check for curl completion. */ -static int t530_checkForCompletion(CURLM *curl, int *success) +static int t530_checkForCompletion(CURLM *multi, int *success) { int result = 0; *success = 0; while(1) { int numMessages; - CURLMsg *message = curl_multi_info_read(curl, &numMessages); + CURLMsg *message = curl_multi_info_read(multi, &numMessages); if(!message) break; if(message->msg == CURLMSG_DONE) { @@ -250,11 +250,12 @@ static void t530_updateFdSet(struct t530_Sockets *sockets, fd_set* fdset, } } -static CURLMcode socket_action(CURLM *curl, curl_socket_t s, int evBitmask, +static CURLMcode socket_action(CURLM *multi, curl_socket_t s, int evBitmask, const char *info) { int numhandles = 0; - CURLMcode result = curl_multi_socket_action(curl, s, evBitmask, &numhandles); + CURLMcode result = curl_multi_socket_action(multi, s, evBitmask, + &numhandles); if(result != CURLM_OK) { curl_mfprintf(stderr, "%s Curl error on %s (%i) %s\n", t530_tag(), info, result, curl_multi_strerror(result)); @@ -265,7 +266,7 @@ static CURLMcode socket_action(CURLM *curl, curl_socket_t s, int evBitmask, /** * Invoke curl when a file descriptor is set. */ -static CURLMcode t530_checkFdSet(CURLM *curl, struct t530_Sockets *sockets, +static CURLMcode t530_checkFdSet(CURLM *multi, struct t530_Sockets *sockets, fd_set *fdset, int evBitmask, const char *name) { @@ -273,7 +274,7 @@ static CURLMcode t530_checkFdSet(CURLM *curl, struct t530_Sockets *sockets, CURLMcode result = CURLM_OK; for(i = 0; i < sockets->count; ++i) { if(FD_ISSET(sockets->sockets[i], fdset)) { - result = socket_action(curl, sockets->sockets[i], evBitmask, name); + result = socket_action(multi, sockets->sockets[i], evBitmask, name); if(result) break; } @@ -284,7 +285,8 @@ static CURLMcode t530_checkFdSet(CURLM *curl, struct t530_Sockets *sockets, static CURLcode testone(const char *URL, int timer_fail_at, int socket_fail_at) { CURLcode res = CURLE_OK; - CURL *curl = NULL; CURLM *m = NULL; + CURL *curl = NULL; + CURLM *multi = NULL; struct t530_ReadWriteSockets sockets = {{NULL, 0, 0}, {NULL, 0, 0}}; int success = 0; struct curltime timeout = {0}; @@ -310,22 +312,22 @@ static CURLcode testone(const char *URL, int timer_fail_at, int socket_fail_at) /* go verbose */ easy_setopt(curl, CURLOPT_VERBOSE, 1L); - multi_init(m); + multi_init(multi); - multi_setopt(m, CURLMOPT_SOCKETFUNCTION, t530_curlSocketCallback); - multi_setopt(m, CURLMOPT_SOCKETDATA, &sockets); + multi_setopt(multi, CURLMOPT_SOCKETFUNCTION, t530_curlSocketCallback); + multi_setopt(multi, CURLMOPT_SOCKETDATA, &sockets); - multi_setopt(m, CURLMOPT_TIMERFUNCTION, t530_curlTimerCallback); - multi_setopt(m, CURLMOPT_TIMERDATA, &timeout); + multi_setopt(multi, CURLMOPT_TIMERFUNCTION, t530_curlTimerCallback); + multi_setopt(multi, CURLMOPT_TIMERDATA, &timeout); - multi_add_handle(m, curl); + multi_add_handle(multi, curl); - if(socket_action(m, CURL_SOCKET_TIMEOUT, 0, "timeout")) { + if(socket_action(multi, CURL_SOCKET_TIMEOUT, 0, "timeout")) { res = TEST_ERR_MAJOR_BAD; goto test_cleanup; } - while(!t530_checkForCompletion(m, &success)) { + while(!t530_checkForCompletion(multi, &success)) { fd_set readSet, writeSet; curl_socket_t maxFd = 0; struct timeval tv = {0}; @@ -350,12 +352,12 @@ static CURLcode testone(const char *URL, int timer_fail_at, int socket_fail_at) select_test((int)maxFd, &readSet, &writeSet, NULL, &tv); /* Check the sockets for reading / writing */ - if(t530_checkFdSet(m, &sockets.read, &readSet, CURL_CSELECT_IN, + if(t530_checkFdSet(multi, &sockets.read, &readSet, CURL_CSELECT_IN, "read")) { res = TEST_ERR_MAJOR_BAD; goto test_cleanup; } - if(t530_checkFdSet(m, &sockets.write, &writeSet, CURL_CSELECT_OUT, + if(t530_checkFdSet(multi, &sockets.write, &writeSet, CURL_CSELECT_OUT, "write")) { res = TEST_ERR_MAJOR_BAD; goto test_cleanup; @@ -364,7 +366,7 @@ static CURLcode testone(const char *URL, int timer_fail_at, int socket_fail_at) if(timeout.tv_sec != (time_t)-1 && t530_getMicroSecondTimeout(&timeout) == 0) { /* Curl's timer has elapsed. */ - if(socket_action(m, CURL_SOCKET_TIMEOUT, 0, "timeout")) { + if(socket_action(multi, CURL_SOCKET_TIMEOUT, 0, "timeout")) { res = TEST_ERR_BAD_TIMEOUT; goto test_cleanup; } @@ -382,9 +384,9 @@ test_cleanup: /* proper cleanup sequence */ t530_msg("cleanup"); - curl_multi_remove_handle(m, curl); + curl_multi_remove_handle(multi, curl); curl_easy_cleanup(curl); - curl_multi_cleanup(m); + curl_multi_cleanup(multi); curl_global_cleanup(); /* free local memory */ diff --git a/tests/libtest/lib533.c b/tests/libtest/lib533.c index adba324f66..8f3b0f1474 100644 --- a/tests/libtest/lib533.c +++ b/tests/libtest/lib533.c @@ -32,7 +32,7 @@ static CURLcode test_lib533(const char *URL) CURLcode res = CURLE_OK; CURL *curl = NULL; int running; - CURLM *m = NULL; + CURLM *multi = NULL; int current = 0; start_test_timing(); @@ -45,9 +45,9 @@ static CURLcode test_lib533(const char *URL) easy_setopt(curl, CURLOPT_VERBOSE, 1L); easy_setopt(curl, CURLOPT_FAILONERROR, 1L); - multi_init(m); + multi_init(multi); - multi_add_handle(m, curl); + multi_add_handle(multi, curl); curl_mfprintf(stderr, "Start at URL 0\n"); @@ -59,7 +59,7 @@ static CURLcode test_lib533(const char *URL) interval.tv_sec = 1; interval.tv_usec = 0; - multi_perform(m, &running); + multi_perform(multi, &running); abort_on_test_timeout(); @@ -67,7 +67,7 @@ static CURLcode test_lib533(const char *URL) if(!current++) { curl_mfprintf(stderr, "Advancing to URL 1\n"); /* remove the handle we use */ - curl_multi_remove_handle(m, curl); + curl_multi_remove_handle(multi, curl); /* make us reuse the same handle all the time, and try resetting the handle first too */ @@ -77,7 +77,7 @@ static CURLcode test_lib533(const char *URL) easy_setopt(curl, CURLOPT_FAILONERROR, 1L); /* re-add it */ - multi_add_handle(m, curl); + multi_add_handle(multi, curl); } else break; /* done */ @@ -87,7 +87,7 @@ static CURLcode test_lib533(const char *URL) FD_ZERO(&wr); FD_ZERO(&exc); - multi_fdset(m, &rd, &wr, &exc, &maxfd); + multi_fdset(multi, &rd, &wr, &exc, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ @@ -101,7 +101,7 @@ test_cleanup: /* undocumented cleanup sequence - type UB */ curl_easy_cleanup(curl); - curl_multi_cleanup(m); + curl_multi_cleanup(multi); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib540.c b/tests/libtest/lib540.c index f544dec48d..9eb7e407c0 100644 --- a/tests/libtest/lib540.c +++ b/tests/libtest/lib540.c @@ -34,48 +34,49 @@ #include "memdebug.h" -static CURL *testeh[2]; +static CURL *t540_curl[2]; -static CURLcode init(int num, CURLM *cm, const char *url, const char *userpwd, - struct curl_slist *headers) +static CURLcode init(int num, CURLM *multi, const char *url, + const char *userpwd, struct curl_slist *headers) { CURLcode res = CURLE_OK; const char *proxy = libtest_arg2; - res_easy_init(testeh[num]); + res_easy_init(t540_curl[num]); if(res) goto init_failed; - res_easy_setopt(testeh[num], CURLOPT_URL, url); + res_easy_setopt(t540_curl[num], CURLOPT_URL, url); if(res) goto init_failed; - res_easy_setopt(testeh[num], CURLOPT_PROXY, proxy); + res_easy_setopt(t540_curl[num], CURLOPT_PROXY, proxy); if(res) goto init_failed; - res_easy_setopt(testeh[num], CURLOPT_PROXYUSERPWD, userpwd); + res_easy_setopt(t540_curl[num], CURLOPT_PROXYUSERPWD, userpwd); if(res) goto init_failed; - res_easy_setopt(testeh[num], CURLOPT_PROXYAUTH, CURLAUTH_ANY); + res_easy_setopt(t540_curl[num], CURLOPT_PROXYAUTH, CURLAUTH_ANY); if(res) goto init_failed; - res_easy_setopt(testeh[num], CURLOPT_VERBOSE, 1L); + res_easy_setopt(t540_curl[num], CURLOPT_VERBOSE, 1L); if(res) goto init_failed; - res_easy_setopt(testeh[num], CURLOPT_HEADER, 1L); + res_easy_setopt(t540_curl[num], CURLOPT_HEADER, 1L); if(res) goto init_failed; - res_easy_setopt(testeh[num], CURLOPT_HTTPHEADER, headers); /* custom Host: */ + /* custom Host: */ + res_easy_setopt(t540_curl[num], CURLOPT_HTTPHEADER, headers); if(res) goto init_failed; - res_multi_add_handle(cm, testeh[num]); + res_multi_add_handle(multi, t540_curl[num]); if(res) goto init_failed; @@ -83,14 +84,14 @@ static CURLcode init(int num, CURLM *cm, const char *url, const char *userpwd, init_failed: - curl_easy_cleanup(testeh[num]); - testeh[num] = NULL; + curl_easy_cleanup(t540_curl[num]); + t540_curl[num] = NULL; return res; /* failure */ } -static CURLcode loop(int num, CURLM *cm, const char *url, const char *userpwd, - struct curl_slist *headers) +static CURLcode loop(int num, CURLM *multi, const char *url, + const char *userpwd, struct curl_slist *headers) { CURLMsg *msg; long L; @@ -99,7 +100,7 @@ static CURLcode loop(int num, CURLM *cm, const char *url, const char *userpwd, struct timeval T; CURLcode res = CURLE_OK; - res = init(num, cm, url, userpwd, headers); + res = init(num, multi, url, userpwd, headers); if(res) return res; @@ -107,7 +108,7 @@ static CURLcode loop(int num, CURLM *cm, const char *url, const char *userpwd, int M = -99; - res_multi_perform(cm, &U); + res_multi_perform(multi, &U); if(res) return res; @@ -120,13 +121,13 @@ static CURLcode loop(int num, CURLM *cm, const char *url, const char *userpwd, FD_ZERO(&W); FD_ZERO(&E); - res_multi_fdset(cm, &R, &W, &E, &M); + res_multi_fdset(multi, &R, &W, &E, &M); if(res) return res; /* At this point, M is guaranteed to be greater or equal than -1. */ - res_multi_timeout(cm, &L); + res_multi_timeout(multi, &L); if(res) return res; @@ -153,19 +154,19 @@ static CURLcode loop(int num, CURLM *cm, const char *url, const char *userpwd, } while(1) { - msg = curl_multi_info_read(cm, &Q); + msg = curl_multi_info_read(multi, &Q); if(!msg) break; if(msg->msg == CURLMSG_DONE) { size_t i; - CURL *e = msg->easy_handle; + CURL *curl = msg->easy_handle; curl_mfprintf(stderr, "R: %d - %s\n", msg->data.result, curl_easy_strerror(msg->data.result)); - curl_multi_remove_handle(cm, e); - curl_easy_cleanup(e); - for(i = 0; i < CURL_ARRAYSIZE(testeh); i++) { - if(testeh[i] == e) { - testeh[i] = NULL; + curl_multi_remove_handle(multi, curl); + curl_easy_cleanup(curl); + for(i = 0; i < CURL_ARRAYSIZE(t540_curl); i++) { + if(t540_curl[i] == curl) { + t540_curl[i] = NULL; break; } } @@ -184,7 +185,7 @@ static CURLcode loop(int num, CURLM *cm, const char *url, const char *userpwd, static CURLcode test_lib540(const char *URL) { - CURLM *cm = NULL; + CURLM *multi = NULL; struct curl_slist *headers = NULL; char buffer[246]; /* naively fixed-size */ CURLcode res = CURLE_OK; @@ -193,8 +194,8 @@ static CURLcode test_lib540(const char *URL) const char *proxyuserpws = libtest_arg3; const char *host; - for(i = 0; i < CURL_ARRAYSIZE(testeh); i++) - testeh[i] = NULL; + for(i = 0; i < CURL_ARRAYSIZE(t540_curl); i++) + t540_curl[i] = NULL; start_test_timing(); @@ -217,31 +218,31 @@ static CURLcode test_lib540(const char *URL) return res; } - res_multi_init(cm); + res_multi_init(multi); if(res) { curl_global_cleanup(); curl_slist_free_all(headers); return res; } - res = loop(0, cm, URL, proxyuserpws, headers); + res = loop(0, multi, URL, proxyuserpws, headers); if(res) goto test_cleanup; curl_mfprintf(stderr, "lib540: now we do the request again\n"); - res = loop(1, cm, URL, proxyuserpws, headers); + res = loop(1, multi, URL, proxyuserpws, headers); test_cleanup: /* proper cleanup sequence - type PB */ - for(i = 0; i < CURL_ARRAYSIZE(testeh); i++) { - curl_multi_remove_handle(cm, testeh[i]); - curl_easy_cleanup(testeh[i]); + for(i = 0; i < CURL_ARRAYSIZE(t540_curl); i++) { + curl_multi_remove_handle(multi, t540_curl[i]); + curl_easy_cleanup(t540_curl[i]); } - curl_multi_cleanup(cm); + curl_multi_cleanup(multi); curl_global_cleanup(); curl_slist_free_all(headers); diff --git a/tests/libtest/lib543.c b/tests/libtest/lib543.c index d3653dbccd..579a71a611 100644 --- a/tests/libtest/lib543.c +++ b/tests/libtest/lib543.c @@ -34,37 +34,37 @@ static CURLcode test_lib543(const char *URL) 0xe0, 0xd8, 0x7c, 0x20, 0xb7, 0xef, 0x53, 0x29, 0xfa, 0x1d, 0x57, 0xe1}; - CURL *easy; + CURL *curl; CURLcode res = CURLE_OK; (void)URL; global_init(CURL_GLOBAL_ALL); - easy = curl_easy_init(); - if(!easy) { + curl = curl_easy_init(); + if(!curl) { curl_mfprintf(stderr, "curl_easy_init() failed\n"); res = TEST_ERR_MAJOR_BAD; } else { int asize = (int)sizeof(a); - char *s = curl_easy_escape(easy, (const char *)a, asize); + char *s = curl_easy_escape(curl, (const char *)a, asize); if(s) { curl_mprintf("%s\n", s); curl_free(s); } - s = curl_easy_escape(easy, "", 0); + s = curl_easy_escape(curl, "", 0); if(s) { curl_mprintf("IN: '' OUT: '%s'\n", s); curl_free(s); } - s = curl_easy_escape(easy, " 123", 3); + s = curl_easy_escape(curl, " 123", 3); if(s) { curl_mprintf("IN: ' 12' OUT: '%s'\n", s); curl_free(s); } - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); } curl_global_cleanup(); diff --git a/tests/libtest/lib544.c b/tests/libtest/lib544.c index c49a8e54b8..d0ed914051 100644 --- a/tests/libtest/lib544.c +++ b/tests/libtest/lib544.c @@ -67,11 +67,11 @@ static CURLcode test_lib544(const char *URL) strcpy(teststring, "FAIL"); { - CURL *handle2; - handle2 = curl_easy_duphandle(curl); + CURL *curl2; + curl2 = curl_easy_duphandle(curl); curl_easy_cleanup(curl); - curl = handle2; + curl = curl2; } /* Now, this is a POST request with binary 0 embedded in POST data. */ diff --git a/tests/libtest/lib547.c b/tests/libtest/lib547.c index 6114d57aab..9184d933a8 100644 --- a/tests/libtest/lib547.c +++ b/tests/libtest/lib547.c @@ -53,10 +53,10 @@ static size_t t547_read_cb(char *ptr, size_t size, size_t nmemb, void *clientp) return 0; } -static curlioerr t547_ioctl_callback(CURL *handle, int cmd, void *clientp) +static curlioerr t547_ioctl_callback(CURL *curl, int cmd, void *clientp) { int *counter = (int *)clientp; - (void)handle; + (void)curl; if(cmd == CURLIOCMD_RESTARTREAD) { curl_mfprintf(stderr, "REWIND!\n"); *counter = 0; /* clear counter to make the read callback restart */ diff --git a/tests/libtest/lib552.c b/tests/libtest/lib552.c index 198ba6aa88..3d5b09c1ec 100644 --- a/tests/libtest/lib552.c +++ b/tests/libtest/lib552.c @@ -54,7 +54,7 @@ static size_t t552_write_cb(char *ptr, size_t size, size_t nmemb, void *stream) return amount; } -static curlioerr ioctl_callback(CURL *handle, int cmd, void *clientp) +static curlioerr ioctl_callback(CURL *curl, int cmd, void *clientp) { (void)clientp; if(cmd == CURLIOCMD_RESTARTREAD) { @@ -63,7 +63,7 @@ static curlioerr ioctl_callback(CURL *handle, int cmd, void *clientp) current_offset = 0; return CURLIOE_OK; } - (void)handle; + (void)curl; return CURLIOE_UNKNOWNCMD; } diff --git a/tests/libtest/lib555.c b/tests/libtest/lib555.c index fe3b692117..19e0480e2a 100644 --- a/tests/libtest/lib555.c +++ b/tests/libtest/lib555.c @@ -57,10 +57,10 @@ static size_t t555_read_cb(char *ptr, size_t size, size_t nmemb, void *clientp) return 0; } -static curlioerr t555_ioctl_callback(CURL *handle, int cmd, void *clientp) +static curlioerr t555_ioctl_callback(CURL *curl, int cmd, void *clientp) { int *counter = (int *)clientp; - (void)handle; + (void)curl; if(cmd == CURLIOCMD_RESTARTREAD) { curl_mfprintf(stderr, "REWIND!\n"); *counter = 0; /* clear counter to make the read callback restart */ @@ -73,7 +73,7 @@ static CURLcode test_lib555(const char *URL) CURLcode res = CURLE_OK; CURL *curl = NULL; int counter = 0; - CURLM *m = NULL; + CURLM *multi = NULL; int running = 1; start_test_timing(); @@ -102,9 +102,9 @@ static CURLcode test_lib555(const char *URL) easy_setopt(curl, CURLOPT_PROXYAUTH, CURLAUTH_BASIC | CURLAUTH_DIGEST | CURLAUTH_NTLM); - multi_init(m); + multi_init(multi); - multi_add_handle(m, curl); + multi_add_handle(multi, curl); while(running) { struct timeval timeout; @@ -114,7 +114,7 @@ static CURLcode test_lib555(const char *URL) timeout.tv_sec = 0; timeout.tv_usec = 100000L; /* 100 ms */ - multi_perform(m, &running); + multi_perform(multi, &running); abort_on_test_timeout(); @@ -125,7 +125,7 @@ static CURLcode test_lib555(const char *URL) FD_ZERO(&fdwrite); FD_ZERO(&fdexcep); - multi_fdset(m, &fdread, &fdwrite, &fdexcep, &maxfd); + multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ @@ -138,8 +138,8 @@ test_cleanup: /* proper cleanup sequence - type PA */ - curl_multi_remove_handle(m, curl); - curl_multi_cleanup(m); + curl_multi_remove_handle(multi, curl); + curl_multi_cleanup(multi); curl_easy_cleanup(curl); curl_global_cleanup(); diff --git a/tests/libtest/lib560.c b/tests/libtest/lib560.c index 060e27eea0..bbdb7990e4 100644 --- a/tests/libtest/lib560.c +++ b/tests/libtest/lib560.c @@ -37,8 +37,8 @@ */ static CURLcode test_lib560(const char *URL) { - CURL *http_handle = NULL; - CURLM *multi_handle = NULL; + CURL *curl = NULL; + CURLM *multi = NULL; CURLcode res = CURLE_OK; int still_running; /* keep number of running handles */ @@ -49,22 +49,22 @@ static CURLcode test_lib560(const char *URL) ** curl_global_init called indirectly from curl_easy_init. */ - easy_init(http_handle); + easy_init(curl); /* set options */ - easy_setopt(http_handle, CURLOPT_URL, URL); - easy_setopt(http_handle, CURLOPT_HEADER, 1L); - easy_setopt(http_handle, CURLOPT_SSL_VERIFYPEER, 0L); - easy_setopt(http_handle, CURLOPT_SSL_VERIFYHOST, 0L); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_HEADER, 1L); + easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L); + easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L); /* init a multi stack */ - multi_init(multi_handle); + multi_init(multi); /* add the individual transfers */ - multi_add_handle(multi_handle, http_handle); + multi_add_handle(multi, curl); /* we start some action by calling perform right away */ - multi_perform(multi_handle, &still_running); + multi_perform(multi, &still_running); abort_on_test_timeout(); @@ -85,7 +85,7 @@ static CURLcode test_lib560(const char *URL) timeout.tv_usec = 0; /* get file descriptors from the transfers */ - multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd); + multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ @@ -94,7 +94,7 @@ static CURLcode test_lib560(const char *URL) abort_on_test_timeout(); /* timeout or readable/writable sockets */ - multi_perform(multi_handle, &still_running); + multi_perform(multi, &still_running); abort_on_test_timeout(); } @@ -103,8 +103,8 @@ test_cleanup: /* undocumented cleanup sequence - type UA */ - curl_multi_cleanup(multi_handle); - curl_easy_cleanup(http_handle); + curl_multi_cleanup(multi); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib564.c b/tests/libtest/lib564.c index 3fc8601504..b105fc710e 100644 --- a/tests/libtest/lib564.c +++ b/tests/libtest/lib564.c @@ -31,7 +31,7 @@ static CURLcode test_lib564(const char *URL) CURLcode res = CURLE_OK; CURL *curl = NULL; int running; - CURLM *m = NULL; + CURLM *multi = NULL; debug_config.nohex = TRUE; debug_config.tracetime = TRUE; @@ -49,9 +49,9 @@ static CURLcode test_lib564(const char *URL) easy_setopt(curl, CURLOPT_PROXY, libtest_arg2); easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4); - multi_init(m); + multi_init(multi); - multi_add_handle(m, curl); + multi_add_handle(multi, curl); curl_mfprintf(stderr, "Start at URL 0\n"); @@ -63,7 +63,7 @@ static CURLcode test_lib564(const char *URL) interval.tv_sec = 1; interval.tv_usec = 0; - multi_perform(m, &running); + multi_perform(multi, &running); abort_on_test_timeout(); @@ -74,7 +74,7 @@ static CURLcode test_lib564(const char *URL) FD_ZERO(&wr); FD_ZERO(&exc); - multi_fdset(m, &rd, &wr, &exc, &maxfd); + multi_fdset(multi, &rd, &wr, &exc, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ @@ -88,7 +88,7 @@ test_cleanup: /* undocumented cleanup sequence - type UB */ curl_easy_cleanup(curl); - curl_multi_cleanup(m); + curl_multi_cleanup(multi); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib573.c b/tests/libtest/lib573.c index 572bfa0cd1..38612df7b5 100644 --- a/tests/libtest/lib573.c +++ b/tests/libtest/lib573.c @@ -32,8 +32,8 @@ static CURLcode test_lib573(const char *URL) { - CURL *c = NULL; - CURLM *m = NULL; + CURL *curl = NULL; + CURLM *multi = NULL; CURLcode res = CURLE_OK; int running = 1; double connect_time = 0.0; @@ -48,20 +48,20 @@ static CURLcode test_lib573(const char *URL) global_init(CURL_GLOBAL_ALL); - easy_init(c); + easy_init(curl); - easy_setopt(c, CURLOPT_HEADER, 1L); - easy_setopt(c, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_HEADER, 1L); + easy_setopt(curl, CURLOPT_URL, URL); debug_config.nohex = TRUE; debug_config.tracetime = TRUE; - easy_setopt(c, CURLOPT_DEBUGDATA, &debug_config); - easy_setopt(c, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); - easy_setopt(c, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config); + easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); - multi_init(m); + multi_init(multi); - multi_add_handle(m, c); + multi_add_handle(multi, curl); while(running) { struct timeval timeout; @@ -71,7 +71,7 @@ static CURLcode test_lib573(const char *URL) timeout.tv_sec = 0; timeout.tv_usec = 100000L; /* 100 ms */ - multi_perform(m, &running); + multi_perform(multi, &running); abort_on_test_timeout(); @@ -82,7 +82,7 @@ static CURLcode test_lib573(const char *URL) FD_ZERO(&fdwrite); FD_ZERO(&fdexcep); - multi_fdset(m, &fdread, &fdwrite, &fdexcep, &maxfd); + multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ @@ -91,7 +91,7 @@ static CURLcode test_lib573(const char *URL) abort_on_test_timeout(); } - curl_easy_getinfo(c, CURLINFO_CONNECT_TIME, &connect_time); + curl_easy_getinfo(curl, CURLINFO_CONNECT_TIME, &connect_time); if(connect_time < dbl_epsilon) { curl_mfprintf(stderr, "connect time %e is < epsilon %e\n", connect_time, dbl_epsilon); @@ -102,9 +102,9 @@ test_cleanup: /* proper cleanup sequence - type PA */ - curl_multi_remove_handle(m, c); - curl_multi_cleanup(m); - curl_easy_cleanup(c); + curl_multi_remove_handle(multi, curl); + curl_multi_cleanup(multi); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib575.c b/tests/libtest/lib575.c index a0ac02f852..36efe6ef5a 100644 --- a/tests/libtest/lib575.c +++ b/tests/libtest/lib575.c @@ -33,9 +33,9 @@ static CURLcode test_lib575(const char *URL) { - CURL *handle = NULL; - CURL *duphandle = NULL; - CURLM *mhandle = NULL; + CURL *curl = NULL; + CURL *curldupe = NULL; + CURLM *multi = NULL; CURLcode res = CURLE_OK; int still_running = 0; @@ -43,31 +43,31 @@ static CURLcode test_lib575(const char *URL) global_init(CURL_GLOBAL_ALL); - easy_init(handle); + easy_init(curl); - easy_setopt(handle, CURLOPT_URL, URL); - easy_setopt(handle, CURLOPT_WILDCARDMATCH, 1L); - easy_setopt(handle, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_WILDCARDMATCH, 1L); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); - res = curl_easy_perform(handle); + res = curl_easy_perform(curl); if(res) goto test_cleanup; - res = curl_easy_perform(handle); + res = curl_easy_perform(curl); if(res) goto test_cleanup; - duphandle = curl_easy_duphandle(handle); - if(!duphandle) + curldupe = curl_easy_duphandle(curl); + if(!curldupe) goto test_cleanup; - curl_easy_cleanup(handle); - handle = duphandle; + curl_easy_cleanup(curl); + curl = curldupe; - multi_init(mhandle); + multi_init(multi); - multi_add_handle(mhandle, handle); + multi_add_handle(multi, curl); - multi_perform(mhandle, &still_running); + multi_perform(multi, &still_running); abort_on_test_timeout(); @@ -85,7 +85,7 @@ static CURLcode test_lib575(const char *URL) FD_ZERO(&fdwrite); FD_ZERO(&fdexcep); - multi_fdset(mhandle, &fdread, &fdwrite, &fdexcep, &maxfd); + multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ @@ -93,7 +93,7 @@ static CURLcode test_lib575(const char *URL) abort_on_test_timeout(); - multi_perform(mhandle, &still_running); + multi_perform(multi, &still_running); abort_on_test_timeout(); } @@ -102,8 +102,8 @@ test_cleanup: /* undocumented cleanup sequence - type UA */ - curl_multi_cleanup(mhandle); - curl_easy_cleanup(handle); + curl_multi_cleanup(multi); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib576.c b/tests/libtest/lib576.c index a054dba3fa..11c0f76d13 100644 --- a/tests/libtest/lib576.c +++ b/tests/libtest/lib576.c @@ -98,27 +98,27 @@ static long chunk_end(void *ptr) static CURLcode test_lib576(const char *URL) { - CURL *handle = NULL; + CURL *curl = NULL; CURLcode res = CURLE_OK; struct chunk_data chunk_data = {0, 0}; curl_global_init(CURL_GLOBAL_ALL); - handle = curl_easy_init(); - if(!handle) { + curl = curl_easy_init(); + if(!curl) { res = CURLE_OUT_OF_MEMORY; goto test_cleanup; } - test_setopt(handle, CURLOPT_URL, URL); - test_setopt(handle, CURLOPT_WILDCARDMATCH, 1L); - test_setopt(handle, CURLOPT_CHUNK_BGN_FUNCTION, chunk_bgn); - test_setopt(handle, CURLOPT_CHUNK_END_FUNCTION, chunk_end); - test_setopt(handle, CURLOPT_CHUNK_DATA, &chunk_data); + test_setopt(curl, CURLOPT_URL, URL); + test_setopt(curl, CURLOPT_WILDCARDMATCH, 1L); + test_setopt(curl, CURLOPT_CHUNK_BGN_FUNCTION, chunk_bgn); + test_setopt(curl, CURLOPT_CHUNK_END_FUNCTION, chunk_end); + test_setopt(curl, CURLOPT_CHUNK_DATA, &chunk_data); - res = curl_easy_perform(handle); + res = curl_easy_perform(curl); test_cleanup: - if(handle) - curl_easy_cleanup(handle); + if(curl) + curl_easy_cleanup(curl); curl_global_cleanup(); return res; } diff --git a/tests/libtest/lib582.c b/tests/libtest/lib582.c index 187432ac0c..e013daedff 100644 --- a/tests/libtest/lib582.c +++ b/tests/libtest/lib582.c @@ -92,12 +92,12 @@ static void t582_addFd(struct t582_Sockets *sockets, curl_socket_t fd, /** * Callback invoked by curl to poll reading / writing of a socket. */ -static int t582_curlSocketCallback(CURL *easy, curl_socket_t s, int action, +static int t582_curlSocketCallback(CURL *curl, curl_socket_t s, int action, void *userp, void *socketp) { struct t582_ReadWriteSockets *sockets = userp; - (void)easy; + (void)curl; (void)socketp; if(action == CURL_POLL_IN || action == CURL_POLL_INOUT) @@ -135,13 +135,13 @@ static int t582_curlTimerCallback(CURLM *multi, long timeout_ms, void *userp) /** * Check for curl completion. */ -static int t582_checkForCompletion(CURLM *curl, int *success) +static int t582_checkForCompletion(CURLM *multi, int *success) { int result = 0; *success = 0; while(1) { int numMessages; - CURLMsg *message = curl_multi_info_read(curl, &numMessages); + CURLMsg *message = curl_multi_info_read(multi, &numMessages); if(!message) break; if(message->msg == CURLMSG_DONE) { @@ -196,11 +196,12 @@ static void t582_updateFdSet(struct t582_Sockets *sockets, fd_set* fdset, } } -static void notifyCurl(CURLM *curl, curl_socket_t s, int evBitmask, +static void notifyCurl(CURLM *multi, curl_socket_t s, int evBitmask, const char *info) { int numhandles = 0; - CURLMcode result = curl_multi_socket_action(curl, s, evBitmask, &numhandles); + CURLMcode result = curl_multi_socket_action(multi, s, evBitmask, + &numhandles); if(result != CURLM_OK) { curl_mfprintf(stderr, "Curl error on %s (%i) %s\n", info, result, curl_multi_strerror(result)); @@ -210,13 +211,13 @@ static void notifyCurl(CURLM *curl, curl_socket_t s, int evBitmask, /** * Invoke curl when a file descriptor is set. */ -static void t582_checkFdSet(CURLM *curl, struct t582_Sockets *sockets, +static void t582_checkFdSet(CURLM *multi, struct t582_Sockets *sockets, fd_set *fdset, int evBitmask, const char *name) { int i; for(i = 0; i < sockets->count; ++i) { if(FD_ISSET(sockets->sockets[i], fdset)) { - notifyCurl(curl, sockets->sockets[i], evBitmask, name); + notifyCurl(multi, sockets->sockets[i], evBitmask, name); } } } @@ -229,7 +230,7 @@ static CURLcode test_lib582(const char *URL) FILE *hd_src = NULL; int hd; struct_stat file_info; - CURLM *m = NULL; + CURLM *multi = NULL; struct t582_ReadWriteSockets sockets = {{NULL, 0, 0}, {NULL, 0, 0}}; int success = 0; struct curltime timeout = {0}; @@ -297,17 +298,17 @@ static CURLcode test_lib582(const char *URL) easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)file_info.st_size); - multi_init(m); + multi_init(multi); - multi_setopt(m, CURLMOPT_SOCKETFUNCTION, t582_curlSocketCallback); - multi_setopt(m, CURLMOPT_SOCKETDATA, &sockets); + multi_setopt(multi, CURLMOPT_SOCKETFUNCTION, t582_curlSocketCallback); + multi_setopt(multi, CURLMOPT_SOCKETDATA, &sockets); - multi_setopt(m, CURLMOPT_TIMERFUNCTION, t582_curlTimerCallback); - multi_setopt(m, CURLMOPT_TIMERDATA, &timeout); + multi_setopt(multi, CURLMOPT_TIMERFUNCTION, t582_curlTimerCallback); + multi_setopt(multi, CURLMOPT_TIMERDATA, &timeout); - multi_add_handle(m, curl); + multi_add_handle(multi, curl); - while(!t582_checkForCompletion(m, &success)) { + while(!t582_checkForCompletion(multi, &success)) { fd_set readSet, writeSet; curl_socket_t maxFd = 0; struct timeval tv = {0}; @@ -331,13 +332,15 @@ static CURLcode test_lib582(const char *URL) select_test((int)maxFd, &readSet, &writeSet, NULL, &tv); /* Check the sockets for reading / writing */ - t582_checkFdSet(m, &sockets.read, &readSet, CURL_CSELECT_IN, "read"); - t582_checkFdSet(m, &sockets.write, &writeSet, CURL_CSELECT_OUT, "write"); + t582_checkFdSet(multi, &sockets.read, &readSet, CURL_CSELECT_IN, + "read"); + t582_checkFdSet(multi, &sockets.write, &writeSet, CURL_CSELECT_OUT, + "write"); if(timeout.tv_sec != (time_t)-1 && t582_getMicroSecondTimeout(&timeout) == 0) { /* Curl's timer has elapsed. */ - notifyCurl(m, CURL_SOCKET_TIMEOUT, 0, "timeout"); + notifyCurl(multi, CURL_SOCKET_TIMEOUT, 0, "timeout"); } abort_on_test_timeout(); @@ -352,9 +355,9 @@ test_cleanup: /* proper cleanup sequence - type PB */ - curl_multi_remove_handle(m, curl); + curl_multi_remove_handle(multi, curl); curl_easy_cleanup(curl); - curl_multi_cleanup(m); + curl_multi_cleanup(multi); curl_global_cleanup(); /* close the local file */ diff --git a/tests/libtest/lib583.c b/tests/libtest/lib583.c index 9950e8b402..510c5a3bdc 100644 --- a/tests/libtest/lib583.c +++ b/tests/libtest/lib583.c @@ -33,7 +33,7 @@ static CURLcode test_lib583(const char *URL) { int stillRunning; - CURLM *multiHandle = NULL; + CURLM *multi = NULL; CURL *curl = NULL; CURLcode res = CURLE_OK; CURLMcode mres; @@ -42,7 +42,7 @@ static CURLcode test_lib583(const char *URL) global_init(CURL_GLOBAL_ALL); - multi_init(multiHandle); + multi_init(multi); easy_init(curl); @@ -56,19 +56,19 @@ static CURLcode test_lib583(const char *URL) easy_setopt(curl, CURLOPT_URL, URL); easy_setopt(curl, CURLOPT_INFILESIZE, 5L); - multi_add_handle(multiHandle, curl); + multi_add_handle(multi, curl); /* this tests if removing an easy handle immediately after multi perform has been called succeeds or not. */ curl_mfprintf(stderr, "curl_multi_perform()...\n"); - multi_perform(multiHandle, &stillRunning); + multi_perform(multi, &stillRunning); curl_mfprintf(stderr, "curl_multi_perform() succeeded\n"); curl_mfprintf(stderr, "curl_multi_remove_handle()...\n"); - mres = curl_multi_remove_handle(multiHandle, curl); + mres = curl_multi_remove_handle(multi, curl); if(mres) { curl_mfprintf(stderr, "curl_multi_remove_handle() failed, with code %d\n", mres); @@ -82,7 +82,7 @@ test_cleanup: /* undocumented cleanup sequence - type UB */ curl_easy_cleanup(curl); - curl_multi_cleanup(multiHandle); + curl_multi_cleanup(multi); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib586.c b/tests/libtest/lib586.c index 439c92bf35..5ee1582a8e 100644 --- a/tests/libtest/lib586.c +++ b/tests/libtest/lib586.c @@ -39,13 +39,13 @@ struct t586_userdata { }; /* lock callback */ -static void t586_test_lock(CURL *handle, curl_lock_data data, +static void t586_test_lock(CURL *curl, curl_lock_data data, curl_lock_access laccess, void *useptr) { const char *what; struct t586_userdata *user = (struct t586_userdata *)useptr; - (void)handle; + (void)curl; (void)laccess; switch(data) { @@ -70,11 +70,11 @@ static void t586_test_lock(CURL *handle, curl_lock_data data, } /* unlock callback */ -static void t586_test_unlock(CURL *handle, curl_lock_data data, void *useptr) +static void t586_test_unlock(CURL *curl, curl_lock_data data, void *useptr) { const char *what; struct t586_userdata *user = (struct t586_userdata *)useptr; - (void)handle; + (void)curl; switch(data) { case CURL_LOCK_DATA_SHARE: what = "share"; diff --git a/tests/libtest/lib591.c b/tests/libtest/lib591.c index c0d5b1a436..0b7a0b4e85 100644 --- a/tests/libtest/lib591.c +++ b/tests/libtest/lib591.c @@ -29,7 +29,7 @@ static CURLcode test_lib591(const char *URL) { - CURL *easy = NULL; + CURL *curl = NULL; CURLM *multi = NULL; CURLcode res = CURLE_OK; int running; @@ -54,29 +54,29 @@ static CURLcode test_lib591(const char *URL) return res; } - easy_init(easy); + easy_init(curl); /* go verbose */ - easy_setopt(easy, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); /* specify target */ - easy_setopt(easy, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_URL, URL); /* enable uploading */ - easy_setopt(easy, CURLOPT_UPLOAD, 1L); + easy_setopt(curl, CURLOPT_UPLOAD, 1L); /* data pointer for the file read function */ - easy_setopt(easy, CURLOPT_READDATA, upload); + easy_setopt(curl, CURLOPT_READDATA, upload); /* use active mode FTP */ - easy_setopt(easy, CURLOPT_FTPPORT, "-"); + easy_setopt(curl, CURLOPT_FTPPORT, "-"); /* server connection timeout */ - easy_setopt(easy, CURLOPT_ACCEPTTIMEOUT_MS, atol(libtest_arg2)*1000); + easy_setopt(curl, CURLOPT_ACCEPTTIMEOUT_MS, atol(libtest_arg2)*1000); multi_init(multi); - multi_add_handle(multi, easy); + multi_add_handle(multi, curl); for(;;) { struct timeval interval; @@ -134,7 +134,7 @@ test_cleanup: /* undocumented cleanup sequence - type UA */ curl_multi_cleanup(multi); - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); curl_global_cleanup(); /* close the local file */ diff --git a/tests/libtest/lib597.c b/tests/libtest/lib597.c index 126ce74f38..e82d061a22 100644 --- a/tests/libtest/lib597.c +++ b/tests/libtest/lib597.c @@ -36,7 +36,7 @@ static CURLcode test_lib597(const char *URL) { - CURL *easy = NULL; + CURL *curl = NULL; CURLM *multi = NULL; CURLcode res = CURLE_OK; int running; @@ -47,19 +47,19 @@ static CURLcode test_lib597(const char *URL) global_init(CURL_GLOBAL_ALL); - easy_init(easy); + easy_init(curl); multi_init(multi); /* go verbose */ - easy_setopt(easy, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); /* specify target */ - easy_setopt(easy, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_URL, URL); - easy_setopt(easy, CURLOPT_CONNECT_ONLY, 1L); + easy_setopt(curl, CURLOPT_CONNECT_ONLY, 1L); - multi_add_handle(multi, easy); + multi_add_handle(multi, curl); for(;;) { struct timeval interval; @@ -113,14 +113,14 @@ static CURLcode test_lib597(const char *URL) if(msg) res = msg->data.result; - multi_remove_handle(multi, easy); + multi_remove_handle(multi, curl); test_cleanup: /* undocumented cleanup sequence - type UA */ curl_multi_cleanup(multi); - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib643.c b/tests/libtest/lib643.c index 612f0b566c..a0fef02dda 100644 --- a/tests/libtest/lib643.c +++ b/tests/libtest/lib643.c @@ -225,13 +225,13 @@ test_cleanup: static CURLcode t643_cyclic_add(void) { - CURL *easy = curl_easy_init(); - curl_mime *mime = curl_mime_init(easy); + CURL *curl = curl_easy_init(); + curl_mime *mime = curl_mime_init(curl); curl_mimepart *part = curl_mime_addpart(mime); CURLcode a1 = curl_mime_subparts(part, mime); if(a1 == CURLE_BAD_FUNCTION_ARGUMENT) { - curl_mime *submime = curl_mime_init(easy); + curl_mime *submime = curl_mime_init(curl); curl_mimepart *subpart = curl_mime_addpart(submime); curl_mime_subparts(part, submime); @@ -239,7 +239,7 @@ static CURLcode t643_cyclic_add(void) } curl_mime_free(mime); - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); if(a1 != CURLE_BAD_FUNCTION_ARGUMENT) /* that should have failed */ return TEST_ERR_FAILURE; diff --git a/tests/libtest/lib653.c b/tests/libtest/lib653.c index 4f20865e26..21948a5720 100644 --- a/tests/libtest/lib653.c +++ b/tests/libtest/lib653.c @@ -27,36 +27,36 @@ static CURLcode test_lib653(const char *URL) { - CURL *curls = NULL; + CURL *curl = NULL; CURLcode res = CURLE_OK; curl_mimepart *field = NULL; curl_mime *mime = NULL; global_init(CURL_GLOBAL_ALL); - easy_init(curls); + easy_init(curl); - mime = curl_mime_init(curls); + mime = curl_mime_init(curl); field = curl_mime_addpart(mime); curl_mime_name(field, "name"); curl_mime_data(field, "short value", CURL_ZERO_TERMINATED); - easy_setopt(curls, CURLOPT_URL, URL); - easy_setopt(curls, CURLOPT_HEADER, 1L); - easy_setopt(curls, CURLOPT_VERBOSE, 1L); - easy_setopt(curls, CURLOPT_MIMEPOST, mime); - easy_setopt(curls, CURLOPT_NOPROGRESS, 1L); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_HEADER, 1L); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_MIMEPOST, mime); + easy_setopt(curl, CURLOPT_NOPROGRESS, 1L); - res = curl_easy_perform(curls); + res = curl_easy_perform(curl); if(res) goto test_cleanup; /* Alter form and resubmit. */ curl_mime_data(field, "long value for length change", CURL_ZERO_TERMINATED); - res = curl_easy_perform(curls); + res = curl_easy_perform(curl); test_cleanup: curl_mime_free(mime); - curl_easy_cleanup(curls); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; /* return the final return code */ } diff --git a/tests/libtest/lib654.c b/tests/libtest/lib654.c index a808e24a0a..5b2236ebb0 100644 --- a/tests/libtest/lib654.c +++ b/tests/libtest/lib654.c @@ -63,8 +63,8 @@ static CURLcode test_lib654(const char *URL) { static const char testdata[] = "dummy\n"; - CURL *easy = NULL; - CURL *easy2 = NULL; + CURL *curl = NULL; + CURL *curl2 = NULL; curl_mime *mime = NULL; curl_mimepart *part; struct curl_slist *hdrs = NULL; @@ -81,16 +81,16 @@ static CURLcode test_lib654(const char *URL) return TEST_ERR_MAJOR_BAD; } - easy = curl_easy_init(); + curl = curl_easy_init(); /* First set the URL that is about to receive our POST. */ - test_setopt(easy, CURLOPT_URL, URL); + test_setopt(curl, CURLOPT_URL, URL); /* get verbose debug output please */ - test_setopt(easy, CURLOPT_VERBOSE, 1L); + test_setopt(curl, CURLOPT_VERBOSE, 1L); /* include headers in the output */ - test_setopt(easy, CURLOPT_HEADER, 1L); + test_setopt(curl, CURLOPT_HEADER, 1L); /* Prepare the callback structure. */ pooh.readptr = testdata; @@ -98,7 +98,7 @@ static CURLcode test_lib654(const char *URL) pooh.freecount = 0; /* Build the mime tree. */ - mime = curl_mime_init(easy); + mime = curl_mime_init(curl); part = curl_mime_addpart(mime); curl_mime_data(part, "hello", CURL_ZERO_TERMINATED); curl_mime_name(part, "greeting"); @@ -113,11 +113,11 @@ static CURLcode test_lib654(const char *URL) free_callback, &pooh); /* Bind mime data to its easy handle. */ - test_setopt(easy, CURLOPT_MIMEPOST, mime); + test_setopt(curl, CURLOPT_MIMEPOST, mime); /* Duplicate the handle. */ - easy2 = curl_easy_duphandle(easy); - if(!easy2) { + curl2 = curl_easy_duphandle(curl); + if(!curl2) { curl_mfprintf(stderr, "curl_easy_duphandle() failed\n"); res = TEST_ERR_FAILURE; goto test_cleanup; @@ -129,7 +129,7 @@ static CURLcode test_lib654(const char *URL) mime = NULL; /* Already cleaned up. */ /* Perform on the first handle: should not send any data. */ - res = curl_easy_perform(easy); + res = curl_easy_perform(curl); if(res != CURLE_OK) { curl_mfprintf(stderr, "curl_easy_perform(original) failed\n"); goto test_cleanup; @@ -137,7 +137,7 @@ static CURLcode test_lib654(const char *URL) /* Perform on the second handle: if the bound mime structure has not been duplicated properly, it should cause a valgrind error. */ - res = curl_easy_perform(easy2); + res = curl_easy_perform(curl2); if(res != CURLE_OK) { curl_mfprintf(stderr, "curl_easy_perform(duplicated) failed\n"); goto test_cleanup; @@ -146,8 +146,8 @@ static CURLcode test_lib654(const char *URL) /* Free the duplicated handle: it should call free_callback again. If the mime copy was bad or not automatically released, valgrind will signal it. */ - curl_easy_cleanup(easy2); - easy2 = NULL; /* Already cleaned up. */ + curl_easy_cleanup(curl2); + curl2 = NULL; /* Already cleaned up. */ if(pooh.freecount != 2) { curl_mfprintf(stderr, "free_callback() called %d times instead of 2\n", @@ -157,8 +157,8 @@ static CURLcode test_lib654(const char *URL) } test_cleanup: - curl_easy_cleanup(easy); - curl_easy_cleanup(easy2); + curl_easy_cleanup(curl); + curl_easy_cleanup(curl2); curl_mime_free(mime); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib658.c b/tests/libtest/lib658.c index 00a2a35906..4f0f867d65 100644 --- a/tests/libtest/lib658.c +++ b/tests/libtest/lib658.c @@ -31,13 +31,13 @@ static CURLcode test_lib658(const char *URL) { - CURL *handle = NULL; + CURL *curl = NULL; CURLcode res = CURLE_OK; CURLU *urlp = NULL; CURLUcode uc = CURLUE_OK; global_init(CURL_GLOBAL_ALL); - easy_init(handle); + easy_init(curl); urlp = curl_url(); @@ -54,12 +54,12 @@ static CURLcode test_lib658(const char *URL) } /* demonstrate override behavior */ - easy_setopt(handle, CURLOPT_URL, "http://www.example.com"); + easy_setopt(curl, CURLOPT_URL, "http://www.example.com"); - easy_setopt(handle, CURLOPT_CURLU, urlp); - easy_setopt(handle, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_CURLU, urlp); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); - res = curl_easy_perform(handle); + res = curl_easy_perform(curl); if(res) { curl_mfprintf(stderr, "%s:%d curl_easy_perform() failed " @@ -71,7 +71,7 @@ static CURLcode test_lib658(const char *URL) test_cleanup: curl_url_cleanup(urlp); - curl_easy_cleanup(handle); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib659.c b/tests/libtest/lib659.c index 70a630758c..44fe7b0c49 100644 --- a/tests/libtest/lib659.c +++ b/tests/libtest/lib659.c @@ -31,12 +31,12 @@ static CURLcode test_lib659(const char *URL) { - CURL *handle = NULL; + CURL *curl = NULL; CURLcode res = CURLE_OK; CURLU *urlp = NULL; global_init(CURL_GLOBAL_ALL); - easy_init(handle); + easy_init(curl); urlp = curl_url(); @@ -53,11 +53,11 @@ static CURLcode test_lib659(const char *URL) goto test_cleanup; } - easy_setopt(handle, CURLOPT_CURLU, urlp); - easy_setopt(handle, CURLOPT_VERBOSE, 1L); - easy_setopt(handle, CURLOPT_PROXY, URL); + easy_setopt(curl, CURLOPT_CURLU, urlp); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_PROXY, URL); - res = curl_easy_perform(handle); + res = curl_easy_perform(curl); if(res) { curl_mfprintf(stderr, "%s:%d curl_easy_perform() failed " @@ -69,7 +69,7 @@ static CURLcode test_lib659(const char *URL) test_cleanup: curl_url_cleanup(urlp); - curl_easy_cleanup(handle); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib667.c b/tests/libtest/lib667.c index a46d1b8cdd..2827d00511 100644 --- a/tests/libtest/lib667.c +++ b/tests/libtest/lib667.c @@ -55,7 +55,7 @@ static CURLcode test_lib667(const char *URL) { static const char testdata[] = "dummy"; - CURL *easy = NULL; + CURL *curl = NULL; curl_mime *mime = NULL; curl_mimepart *part; CURLcode res = TEST_ERR_FAILURE; @@ -71,23 +71,23 @@ static CURLcode test_lib667(const char *URL) return TEST_ERR_MAJOR_BAD; } - easy = curl_easy_init(); + curl = curl_easy_init(); /* First set the URL that is about to receive our POST. */ - test_setopt(easy, CURLOPT_URL, URL); + test_setopt(curl, CURLOPT_URL, URL); /* get verbose debug output please */ - test_setopt(easy, CURLOPT_VERBOSE, 1L); + test_setopt(curl, CURLOPT_VERBOSE, 1L); /* include headers in the output */ - test_setopt(easy, CURLOPT_HEADER, 1L); + test_setopt(curl, CURLOPT_HEADER, 1L); /* Prepare the callback structure. */ pooh.readptr = testdata; pooh.sizeleft = (curl_off_t) strlen(testdata); /* Build the mime tree. */ - mime = curl_mime_init(easy); + mime = curl_mime_init(curl); part = curl_mime_addpart(mime); curl_mime_name(part, "field"); curl_mime_encoder(part, "base64"); @@ -96,16 +96,16 @@ static CURLcode test_lib667(const char *URL) NULL, NULL, &pooh); /* Bind mime data to its easy handle. */ - test_setopt(easy, CURLOPT_MIMEPOST, mime); + test_setopt(curl, CURLOPT_MIMEPOST, mime); /* Send data. */ - res = curl_easy_perform(easy); + res = curl_easy_perform(curl); if(res != CURLE_OK) { curl_mfprintf(stderr, "curl_easy_perform() failed\n"); } test_cleanup: - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); curl_mime_free(mime); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib668.c b/tests/libtest/lib668.c index 87cf19bbe4..488f862152 100644 --- a/tests/libtest/lib668.c +++ b/tests/libtest/lib668.c @@ -50,7 +50,7 @@ static CURLcode test_lib668(const char *URL) { static const char testdata[] = "dummy"; - CURL *easy = NULL; + CURL *curl = NULL; curl_mime *mime = NULL; curl_mimepart *part; CURLcode res = TEST_ERR_FAILURE; @@ -65,16 +65,16 @@ static CURLcode test_lib668(const char *URL) return TEST_ERR_MAJOR_BAD; } - easy = curl_easy_init(); + curl = curl_easy_init(); /* First set the URL that is about to receive our POST. */ - test_setopt(easy, CURLOPT_URL, URL); + test_setopt(curl, CURLOPT_URL, URL); /* get verbose debug output please */ - test_setopt(easy, CURLOPT_VERBOSE, 1L); + test_setopt(curl, CURLOPT_VERBOSE, 1L); /* include headers in the output */ - test_setopt(easy, CURLOPT_HEADER, 1L); + test_setopt(curl, CURLOPT_HEADER, 1L); /* Prepare the callback structures. */ pooh1.readptr = testdata; @@ -82,7 +82,7 @@ static CURLcode test_lib668(const char *URL) pooh2 = pooh1; /* Build the mime tree. */ - mime = curl_mime_init(easy); + mime = curl_mime_init(curl); part = curl_mime_addpart(mime); curl_mime_name(part, "field1"); /* Early end of data detection can be done because the data size is known. */ @@ -101,16 +101,16 @@ static CURLcode test_lib668(const char *URL) curl_mime_filedata(part, libtest_arg2); /* Bind mime data to its easy handle. */ - test_setopt(easy, CURLOPT_MIMEPOST, mime); + test_setopt(curl, CURLOPT_MIMEPOST, mime); /* Send data. */ - res = curl_easy_perform(easy); + res = curl_easy_perform(curl); if(res != CURLE_OK) { curl_mfprintf(stderr, "curl_easy_perform() failed\n"); } test_cleanup: - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); curl_mime_free(mime); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib670.c b/tests/libtest/lib670.c index 9dcdd7fd45..b30d097f68 100644 --- a/tests/libtest/lib670.c +++ b/tests/libtest/lib670.c @@ -28,7 +28,7 @@ #define PAUSE_TIME 5 struct t670_ReadThis { - CURL *easy; + CURL *curl; time_t origin; int count; }; @@ -79,7 +79,7 @@ static int t670_xferinfo(void *clientp, } if(delta >= PAUSE_TIME) - curl_easy_pause(pooh->easy, CURLPAUSE_CONT); + curl_easy_pause(pooh->curl, CURLPAUSE_CONT); } return 0; @@ -106,21 +106,21 @@ static CURLcode test_lib670(const char *URL) pooh.origin = (time_t) 0; pooh.count = 0; - pooh.easy = curl_easy_init(); + pooh.curl = curl_easy_init(); /* First set the URL that is about to receive our POST. */ - test_setopt(pooh.easy, CURLOPT_URL, URL); + test_setopt(pooh.curl, CURLOPT_URL, URL); /* get verbose debug output please */ - test_setopt(pooh.easy, CURLOPT_VERBOSE, 1L); + test_setopt(pooh.curl, CURLOPT_VERBOSE, 1L); /* include headers in the output */ - test_setopt(pooh.easy, CURLOPT_HEADER, 1L); + test_setopt(pooh.curl, CURLOPT_HEADER, 1L); if(testnum == 670 || testnum == 671) { curl_mimepart *part; /* Build the mime tree. */ - mime = curl_mime_init(pooh.easy); + mime = curl_mime_init(pooh.curl); part = curl_mime_addpart(mime); res = curl_mime_name(part, testname); if(res != CURLE_OK) { @@ -135,7 +135,7 @@ static CURLcode test_lib670(const char *URL) /* Bind mime data to its easy handle. */ if(res == CURLE_OK) - test_setopt(pooh.easy, CURLOPT_MIMEPOST, mime); + test_setopt(pooh.curl, CURLOPT_MIMEPOST, mime); } else { struct curl_httppost *lastptr = NULL; @@ -152,10 +152,10 @@ static CURLcode test_lib670(const char *URL) } /* We want to use our own read function. */ - test_setopt(pooh.easy, CURLOPT_READFUNCTION, t670_read_cb); + test_setopt(pooh.curl, CURLOPT_READFUNCTION, t670_read_cb); /* Send a multi-part formpost. */ - test_setopt(pooh.easy, CURLOPT_HTTPPOST, formpost); + test_setopt(pooh.curl, CURLOPT_HTTPPOST, formpost); } if(testnum == 670 || testnum == 672) { @@ -163,7 +163,7 @@ static CURLcode test_lib670(const char *URL) CURLM *multi; /* Use the multi interface. */ multi = curl_multi_init(); - mres = curl_multi_add_handle(multi, pooh.easy); + mres = curl_multi_add_handle(multi, pooh.curl); while(!mres) { struct timeval timeout; int rc = 0; @@ -187,7 +187,7 @@ static CURLcode test_lib670(const char *URL) } if(delta >= PAUSE_TIME) - curl_easy_pause(pooh.easy, CURLPAUSE_CONT); + curl_easy_pause(pooh.curl, CURLPAUSE_CONT); } FD_ZERO(&fdread); @@ -222,19 +222,19 @@ static CURLcode test_lib670(const char *URL) } } - curl_multi_remove_handle(multi, pooh.easy); + curl_multi_remove_handle(multi, pooh.curl); curl_multi_cleanup(multi); } else { /* Use the easy interface. */ - test_setopt(pooh.easy, CURLOPT_XFERINFODATA, &pooh); - test_setopt(pooh.easy, CURLOPT_XFERINFOFUNCTION, t670_xferinfo); - test_setopt(pooh.easy, CURLOPT_NOPROGRESS, 0L); - res = curl_easy_perform(pooh.easy); + test_setopt(pooh.curl, CURLOPT_XFERINFODATA, &pooh); + test_setopt(pooh.curl, CURLOPT_XFERINFOFUNCTION, t670_xferinfo); + test_setopt(pooh.curl, CURLOPT_NOPROGRESS, 0L); + res = curl_easy_perform(pooh.curl); } test_cleanup: - curl_easy_cleanup(pooh.easy); + curl_easy_cleanup(pooh.curl); if(testnum == 670 || testnum == 671) { curl_mime_free(mime); diff --git a/tests/libtest/lib674.c b/tests/libtest/lib674.c index a46f2be6eb..668ecdf32d 100644 --- a/tests/libtest/lib674.c +++ b/tests/libtest/lib674.c @@ -31,14 +31,14 @@ static CURLcode test_lib674(const char *URL) { - CURL *handle = NULL; - CURL *handle2; + CURL *curl = NULL; + CURL *curl2; CURLcode res = CURLE_OK; CURLU *urlp = NULL; CURLUcode uc = CURLUE_OK; global_init(CURL_GLOBAL_ALL); - easy_init(handle); + easy_init(curl); urlp = curl_url(); @@ -56,10 +56,10 @@ static CURLcode test_lib674(const char *URL) /* demonstrate override behavior */ - easy_setopt(handle, CURLOPT_CURLU, urlp); - easy_setopt(handle, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_CURLU, urlp); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); - res = curl_easy_perform(handle); + res = curl_easy_perform(curl); if(res) { curl_mfprintf(stderr, "%s:%d curl_easy_perform() failed " @@ -68,14 +68,14 @@ static CURLcode test_lib674(const char *URL) goto test_cleanup; } - handle2 = curl_easy_duphandle(handle); - res = curl_easy_perform(handle2); - curl_easy_cleanup(handle2); + curl2 = curl_easy_duphandle(curl); + res = curl_easy_perform(curl2); + curl_easy_cleanup(curl2); test_cleanup: curl_url_cleanup(urlp); - curl_easy_cleanup(handle); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib678.c b/tests/libtest/lib678.c index 5fdabdda96..2a2e21321f 100644 --- a/tests/libtest/lib678.c +++ b/tests/libtest/lib678.c @@ -99,15 +99,14 @@ static CURLcode test_lib678(const char *URL) CURLcode res = CURLE_OK; curl_global_init(CURL_GLOBAL_DEFAULT); if(!strcmp("check", URL)) { - CURL *e; CURLcode w = CURLE_OK; struct curl_blob blob = {0}; - e = curl_easy_init(); - if(e) { - w = curl_easy_setopt(e, CURLOPT_CAINFO_BLOB, &blob); + CURL *curl = curl_easy_init(); + if(curl) { + w = curl_easy_setopt(curl, CURLOPT_CAINFO_BLOB, &blob); if(w) curl_mprintf("CURLOPT_CAINFO_BLOB is not supported\n"); - curl_easy_cleanup(e); + curl_easy_cleanup(curl); } res = w; } diff --git a/tests/libtest/lib751.c b/tests/libtest/lib751.c index 0e0a1968e6..42c1aeb117 100644 --- a/tests/libtest/lib751.c +++ b/tests/libtest/lib751.c @@ -31,37 +31,37 @@ static CURLcode test_lib751(const char *URL) { - CURL *easies[1000]; - CURLM *m; + CURL *curls[1000]; + CURLM *multi; CURLcode res = CURLE_FAILED_INIT; CURLMcode mres; int i; (void)URL; - memset(easies, 0, sizeof(easies)); + memset(curls, 0, sizeof(curls)); curl_global_init(CURL_GLOBAL_DEFAULT); - m = curl_multi_init(); - if(!m) { + multi = curl_multi_init(); + if(!multi) { res = CURLE_OUT_OF_MEMORY; goto test_cleanup; } for(i = 0; i < 1000; i++) { - CURL *e = curl_easy_init(); - if(!e) { + CURL *curl = curl_easy_init(); + if(!curl) { res = CURLE_OUT_OF_MEMORY; goto test_cleanup; } - easies[i] = e; + curls[i] = curl; - res = curl_easy_setopt(e, CURLOPT_URL, "https://www.example.com/"); + res = curl_easy_setopt(curl, CURLOPT_URL, "https://www.example.com/"); if(!res) - res = curl_easy_setopt(e, CURLOPT_VERBOSE, 1L); + res = curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); if(res) goto test_cleanup; - mres = curl_multi_add_handle(m, e); + mres = curl_multi_add_handle(multi, curl); if(mres != CURLM_OK) { curl_mfprintf(stderr, "MULTI ERROR: %s\n", curl_multi_strerror(mres)); res = CURLE_FAILED_INIT; @@ -75,13 +75,13 @@ test_cleanup: curl_mfprintf(stderr, "ERROR: %s\n", curl_easy_strerror(res)); for(i = 0; i < 1000; i++) { - if(easies[i]) { - curl_multi_add_handle(m, easies[i]); - curl_easy_cleanup(easies[i]); - easies[i] = NULL; + if(curls[i]) { + curl_multi_add_handle(multi, curls[i]); + curl_easy_cleanup(curls[i]); + curls[i] = NULL; } } - curl_multi_cleanup(m); + curl_multi_cleanup(multi); curl_global_cleanup(); return res; diff --git a/tests/libtest/lib753.c b/tests/libtest/lib753.c index ea3f0268af..19194c4646 100644 --- a/tests/libtest/lib753.c +++ b/tests/libtest/lib753.c @@ -27,7 +27,7 @@ #include "memdebug.h" struct t753_transfer_status { - CURL *easy; + CURL *curl; const char *name; bool pause; bool is_paused; @@ -56,49 +56,49 @@ static size_t t753_hd_cb(char *ptr, size_t size, size_t nmemb, void *userp) curl_mfprintf(stderr, "[%s] hd_cb '%.*s'\n", st->name, (int)len, ptr); if(!strcmp("230 Welcome you silly person\r\n", ptr)) { st->seen_welcome = TRUE; - st->easy = NULL; + st->curl = NULL; } return len; } static bool t753_setup(const char *URL, const char *name, - CURL **peasy, + CURL **pcurl, struct t753_transfer_status *st) { - CURL *easy = NULL; + CURL *curl = NULL; CURLcode res = CURLE_OK; - *peasy = NULL; + *pcurl = NULL; memset(st, 0, sizeof(*st)); st->name = name; - st->easy = easy; + st->curl = curl; st->pause = TRUE; - easy_init(easy); + easy_init(curl); - easy_setopt(easy, CURLOPT_URL, URL); - easy_setopt(easy, CURLOPT_WRITEFUNCTION, t753_write_cb); - easy_setopt(easy, CURLOPT_WRITEDATA, st); - easy_setopt(easy, CURLOPT_HEADERFUNCTION, t753_hd_cb); - easy_setopt(easy, CURLOPT_HEADERDATA, st); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_WRITEFUNCTION, t753_write_cb); + easy_setopt(curl, CURLOPT_WRITEDATA, st); + easy_setopt(curl, CURLOPT_HEADERFUNCTION, t753_hd_cb); + easy_setopt(curl, CURLOPT_HEADERDATA, st); - easy_setopt(easy, CURLOPT_NOPROGRESS, 1L); - easy_setopt(easy, CURLOPT_DEBUGDATA, &debug_config); - easy_setopt(easy, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); - easy_setopt(easy, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_NOPROGRESS, 1L); + easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config); + easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); - *peasy = easy; + *pcurl = curl; return TRUE; test_cleanup: - if(easy) - curl_easy_cleanup(easy); + if(curl) + curl_easy_cleanup(curl); return FALSE; } static CURLcode test_lib753(const char *URL) { - CURL *easy1 = NULL, *easy2 = NULL; + CURL *curl1 = NULL, *curl2 = NULL; CURLM *multi = NULL; struct t753_transfer_status st1, st2; CURLcode res = CURLE_OK; @@ -119,10 +119,10 @@ static CURLcode test_lib753(const char *URL) goto test_cleanup; } - if(!t753_setup(URL, "EASY1", &easy1, &st1)) + if(!t753_setup(URL, "EASY1", &curl1, &st1)) goto test_cleanup; - multi_add_handle(multi, easy1); + multi_add_handle(multi, curl1); multi_perform(multi, &still_running); abort_on_test_timeout(); @@ -142,14 +142,14 @@ static CURLcode test_lib753(const char *URL) * that the connection is NOT reused, e.g. all FTP commands * are sent again on the new connection. */ - if(easy1 && st1.seen_welcome) { - curl_easy_cleanup(easy1); - easy1 = NULL; - if(!easy2) { - if(!t753_setup(URL, "EASY2", &easy2, &st2)) + if(curl1 && st1.seen_welcome) { + curl_easy_cleanup(curl1); + curl1 = NULL; + if(!curl2) { + if(!t753_setup(URL, "EASY2", &curl2, &st2)) goto test_cleanup; st2.pause = FALSE; - multi_add_handle(multi, easy2); + multi_add_handle(multi, curl2); } } @@ -173,10 +173,10 @@ test_cleanup: if(res) curl_mfprintf(stderr, "ERROR: %s\n", curl_easy_strerror(res)); - if(easy1) - curl_easy_cleanup(easy1); - if(easy2) - curl_easy_cleanup(easy2); + if(curl1) + curl_easy_cleanup(curl1); + if(curl2) + curl_easy_cleanup(curl2); curl_multi_cleanup(multi); curl_global_cleanup(); diff --git a/tests/libtest/lib758.c b/tests/libtest/lib758.c index e9fe4ea2c9..35e60cc04f 100644 --- a/tests/libtest/lib758.c +++ b/tests/libtest/lib758.c @@ -146,12 +146,12 @@ static int t758_addFd(struct t758_Sockets *sockets, curl_socket_t fd, /** * Callback invoked by curl to poll reading / writing of a socket. */ -static int t758_curlSocketCallback(CURL *easy, curl_socket_t s, int action, +static int t758_curlSocketCallback(CURL *curl, curl_socket_t s, int action, void *userp, void *socketp) { struct t758_ReadWriteSockets *sockets = userp; - (void)easy; + (void)curl; (void)socketp; t758_ctx.socket_calls++; @@ -235,13 +235,13 @@ t758_set_ssl_ctx_callback(CURL *curl, void *ssl_ctx, void *clientp) /** * Check for curl completion. */ -static int t758_checkForCompletion(CURLM *curl, int *success) +static int t758_checkForCompletion(CURLM *multi, int *success) { int result = 0; *success = 0; while(1) { int numMessages; - CURLMsg *message = curl_multi_info_read(curl, &numMessages); + CURLMsg *message = curl_multi_info_read(multi, &numMessages); if(!message) break; if(message->msg == CURLMSG_DONE) { @@ -296,11 +296,12 @@ static void t758_updateFdSet(struct t758_Sockets *sockets, fd_set* fdset, } } -static CURLMcode t758_saction(CURLM *curl, curl_socket_t s, +static CURLMcode t758_saction(CURLM *multi, curl_socket_t s, int evBitmask, const char *info) { int numhandles = 0; - CURLMcode result = curl_multi_socket_action(curl, s, evBitmask, &numhandles); + CURLMcode result = curl_multi_socket_action(multi, s, evBitmask, + &numhandles); if(result != CURLM_OK) { curl_mfprintf(stderr, "%s Curl error on %s (%i) %s\n", t758_tag(), info, result, curl_multi_strerror(result)); @@ -311,7 +312,7 @@ static CURLMcode t758_saction(CURLM *curl, curl_socket_t s, /** * Invoke curl when a file descriptor is set. */ -static CURLMcode t758_checkFdSet(CURLM *curl, struct t758_Sockets *sockets, +static CURLMcode t758_checkFdSet(CURLM *multi, struct t758_Sockets *sockets, fd_set *fdset, int evBitmask, const char *name) { @@ -319,7 +320,7 @@ static CURLMcode t758_checkFdSet(CURLM *curl, struct t758_Sockets *sockets, CURLMcode result = CURLM_OK; for(i = 0; i < sockets->count; ++i) { if(FD_ISSET(sockets->sockets[i], fdset)) { - result = t758_saction(curl, sockets->sockets[i], evBitmask, name); + result = t758_saction(multi, sockets->sockets[i], evBitmask, name); if(result) break; } @@ -331,7 +332,8 @@ static CURLcode t758_one(const char *URL, int timer_fail_at, int socket_fail_at) { CURLcode res = CURLE_OK; - CURL *curl = NULL; CURLM *m = NULL; + CURL *curl = NULL; + CURLM *multi = NULL; struct t758_ReadWriteSockets sockets = {{NULL, 0, 0}, {NULL, 0, 0}}; int success = 0; struct curltime timeout = {0}; @@ -373,28 +375,28 @@ static CURLcode t758_one(const char *URL, int timer_fail_at, easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, t758_set_ssl_ctx_callback); - multi_init(m); + multi_init(multi); - multi_setopt(m, CURLMOPT_SOCKETFUNCTION, t758_curlSocketCallback); - multi_setopt(m, CURLMOPT_SOCKETDATA, &sockets); + multi_setopt(multi, CURLMOPT_SOCKETFUNCTION, t758_curlSocketCallback); + multi_setopt(multi, CURLMOPT_SOCKETDATA, &sockets); - multi_setopt(m, CURLMOPT_TIMERFUNCTION, t758_curlTimerCallback); - multi_setopt(m, CURLMOPT_TIMERDATA, &timeout); + multi_setopt(multi, CURLMOPT_TIMERFUNCTION, t758_curlTimerCallback); + multi_setopt(multi, CURLMOPT_TIMERDATA, &timeout); - multi_add_handle(m, curl); + multi_add_handle(multi, curl); - if(t758_saction(m, CURL_SOCKET_TIMEOUT, 0, "timeout")) { + if(t758_saction(multi, CURL_SOCKET_TIMEOUT, 0, "timeout")) { res = TEST_ERR_MAJOR_BAD; goto test_cleanup; } - while(!t758_checkForCompletion(m, &success)) { + while(!t758_checkForCompletion(multi, &success)) { fd_set readSet, writeSet; curl_socket_t maxFd = 0; struct timeval tv = {0}; tv.tv_sec = 10; if(t758_ctx.fake_async_cert_verification_pending && - !t758_ctx.fake_async_cert_verification_finished) { + !t758_ctx.fake_async_cert_verification_finished) { if(sockets.read.count || sockets.write.count) { t758_msg("during verification there should be no sockets scheduled"); res = TEST_ERR_MAJOR_BAD; @@ -406,13 +408,13 @@ static CURLcode t758_one(const char *URL, int timer_fail_at, goto test_cleanup; } t758_ctx.fake_async_cert_verification_finished = 1; - if(t758_saction(m, CURL_SOCKET_TIMEOUT, 0, "timeout")) { + if(t758_saction(multi, CURL_SOCKET_TIMEOUT, 0, "timeout")) { t758_msg("spurious retry cert action"); res = TEST_ERR_MAJOR_BAD; goto test_cleanup; } curl_easy_pause(curl, CURLPAUSE_CONT); - if(t758_saction(m, CURL_SOCKET_TIMEOUT, 0, "timeout")) { + if(t758_saction(multi, CURL_SOCKET_TIMEOUT, 0, "timeout")) { t758_msg("unblocking transfer after cert verification finished"); res = TEST_ERR_MAJOR_BAD; goto test_cleanup; @@ -442,12 +444,12 @@ static CURLcode t758_one(const char *URL, int timer_fail_at, select_test((int)maxFd, &readSet, &writeSet, NULL, &tv); /* Check the sockets for reading / writing */ - if(t758_checkFdSet(m, &sockets.read, &readSet, CURL_CSELECT_IN, + if(t758_checkFdSet(multi, &sockets.read, &readSet, CURL_CSELECT_IN, "read")) { res = TEST_ERR_MAJOR_BAD; goto test_cleanup; } - if(t758_checkFdSet(m, &sockets.write, &writeSet, CURL_CSELECT_OUT, + if(t758_checkFdSet(multi, &sockets.write, &writeSet, CURL_CSELECT_OUT, "write")) { res = TEST_ERR_MAJOR_BAD; goto test_cleanup; @@ -456,7 +458,7 @@ static CURLcode t758_one(const char *URL, int timer_fail_at, if(timeout.tv_sec != (time_t)-1 && t758_getMicroSecondTimeout(&timeout) == 0) { /* Curl's timer has elapsed. */ - if(t758_saction(m, CURL_SOCKET_TIMEOUT, 0, "timeout")) { + if(t758_saction(multi, CURL_SOCKET_TIMEOUT, 0, "timeout")) { res = TEST_ERR_BAD_TIMEOUT; goto test_cleanup; } @@ -479,9 +481,9 @@ test_cleanup: /* proper cleanup sequence */ t758_msg("cleanup"); - curl_multi_remove_handle(m, curl); + curl_multi_remove_handle(multi, curl); curl_easy_cleanup(curl); - curl_multi_cleanup(m); + curl_multi_cleanup(multi); curl_global_cleanup(); /* free local memory */ diff --git a/tests/libtest/lib766.c b/tests/libtest/lib766.c index 5cfc6bb270..53f1dd97b5 100644 --- a/tests/libtest/lib766.c +++ b/tests/libtest/lib766.c @@ -42,24 +42,24 @@ static int sockopt_766(void *clientp, static CURLcode test_lib766(const char *URL) { - CURL *easy = NULL; + CURL *curl = NULL; CURLcode res = CURLE_OK; start_test_timing(); res_global_init(CURL_GLOBAL_ALL); - easy_init(easy); - easy_setopt(easy, CURLOPT_VERBOSE, 1L); - easy_setopt(easy, CURLOPT_URL, URL); - easy_setopt(easy, CURLOPT_FTPPORT, "-"); - easy_setopt(easy, CURLOPT_SOCKOPTFUNCTION, sockopt_766); + easy_init(curl); + easy_setopt(curl, CURLOPT_VERBOSE, 1L); + easy_setopt(curl, CURLOPT_URL, URL); + easy_setopt(curl, CURLOPT_FTPPORT, "-"); + easy_setopt(curl, CURLOPT_SOCKOPTFUNCTION, sockopt_766); - res = curl_easy_perform(easy); + res = curl_easy_perform(curl); test_cleanup: - curl_easy_cleanup(easy); + curl_easy_cleanup(curl); curl_global_cleanup(); return res; diff --git a/tests/libtest/testtrace.c b/tests/libtest/testtrace.c index 8aa377fb0c..092aca8385 100644 --- a/tests/libtest/testtrace.c +++ b/tests/libtest/testtrace.c @@ -81,7 +81,7 @@ void debug_dump(const char *timebuf, const char *text, fflush(stream); } -int libtest_debug_cb(CURL *handle, curl_infotype type, +int libtest_debug_cb(CURL *curl, curl_infotype type, char *data, size_t size, void *userp) { struct libtest_trace_cfg *trace_cfg = userp; @@ -89,7 +89,7 @@ int libtest_debug_cb(CURL *handle, curl_infotype type, char timebuf[20]; char *timestr; - (void)handle; + (void)curl; timebuf[0] = '\0'; timestr = &timebuf[0]; @@ -157,7 +157,7 @@ static void log_line_start(FILE *log, const char *idsbuf, curl_infotype type) } /* callback for CURLOPT_DEBUGFUNCTION (used in client tests) */ -int cli_debug_cb(CURL *handle, curl_infotype type, +int cli_debug_cb(CURL *curl, curl_infotype type, char *data, size_t size, void *userp) { FILE *output = stderr; @@ -166,11 +166,11 @@ int cli_debug_cb(CURL *handle, curl_infotype type, char idsbuf[60]; curl_off_t xfer_id, conn_id; - (void)handle; + (void)curl; (void)userp; - if(!curl_easy_getinfo(handle, CURLINFO_XFER_ID, &xfer_id) && xfer_id >= 0) { - if(!curl_easy_getinfo(handle, CURLINFO_CONN_ID, &conn_id) && + if(!curl_easy_getinfo(curl, CURLINFO_XFER_ID, &xfer_id) && xfer_id >= 0) { + if(!curl_easy_getinfo(curl, CURLINFO_CONN_ID, &conn_id) && conn_id >= 0) { curl_msnprintf(idsbuf, sizeof(idsbuf), "[%" CURL_FORMAT_CURL_OFF_T "-" diff --git a/tests/libtest/testtrace.h b/tests/libtest/testtrace.h index 79d2f8529d..e066595b2c 100644 --- a/tests/libtest/testtrace.h +++ b/tests/libtest/testtrace.h @@ -36,11 +36,11 @@ struct libtest_trace_cfg { extern struct libtest_trace_cfg debug_config; -int libtest_debug_cb(CURL *handle, curl_infotype type, +int libtest_debug_cb(CURL *curl, curl_infotype type, char *data, size_t size, void *userp); /* callback for CURLOPT_DEBUGFUNCTION (client tests) */ -int cli_debug_cb(CURL *handle, curl_infotype type, +int cli_debug_cb(CURL *curl, curl_infotype type, char *data, size_t size, void *userp); #endif /* HEADER_LIBTEST_TESTTRACE_H */