← Commit list

d2f0a0e796

Viktor Szakats

2025-10-31

SUCCESS Duration: 185s

Subject

tests/libtest: consistent variable naming for easy/multi/share handles

Binary

No binary (build failed)

Architecture & Compiler Flags

Architecture: x86_64-linux-gnu Compiler: gcc (Ubuntu 11.4.0-1ubuntu1~22.04.3) 11.4.0

—

Build Log

(log yok)

Commit Diff GitHub →

tests/libtest/cli_h2_pausing.c+30 -26

@@ -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;

tests/libtest/cli_h2_serverpush.c+30 -30

@@ -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);

tests/libtest/cli_h2_upgrade_extreme.c+16 -16

@@ -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;

tests/libtest/cli_hx_download.c+52 -52

@@ -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;

tests/libtest/cli_hx_upload.c+62 -62

@@ -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);

tests/libtest/cli_tls_session_reuse.c+21 -21

@@ -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)

tests/libtest/cli_ws_data.c+18 -18

@@ -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);

tests/libtest/lib1485.c+14 -14

@@ -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 */

tests/libtest/lib1500.c+6 -6

@@ -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)

tests/libtest/lib1501.c+12 -12

@@ -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;

tests/libtest/lib1502.c+18 -18

@@ -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;

tests/libtest/lib1506.c+8 -8

@@ -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;

tests/libtest/lib1507.c+9 -9

@@ -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, "<[email protected]>");
	#if 0
@@ -66,12 +66,12 @@ static CURLcode test_lib1507(const char *URL)
	curl_easy_setopt(curl, CURLOPT_MAIL_FROM, "<[email protected]>");
	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();

tests/libtest/lib1508.c+3 -3

@@ -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");

tests/libtest/lib1515.c+18 -17

@@ -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;

tests/libtest/lib1523.c+14 -14

@@ -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;

tests/libtest/lib1531.c+15 -15

@@ -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;

tests/libtest/lib1533.c+3 -3

@@ -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;

tests/libtest/lib1540.c+18 -18

@@ -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 */

tests/libtest/lib1541.c+29 -29

@@ -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 */

tests/libtest/lib1542.c+12 -12

@@ -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;

tests/libtest/lib1545.c+7 -7

@@ -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;

tests/libtest/lib1550.c+5 -5

@@ -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;
	}

tests/libtest/lib1552.c+8 -8

@@ -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)

tests/libtest/lib1553.c+16 -16

@@ -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)

tests/libtest/lib1554.c+4 -4

@@ -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]);

tests/libtest/lib1557.c+9 -9

@@ -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;
	}

tests/libtest/lib1565.c+13 -13

@@ -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;

tests/libtest/lib1568.c+13 -13

@@ -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;

tests/libtest/lib1569.c+9 -9

@@ -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;
	}

tests/libtest/lib1592.c+6 -6

@@ -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;

tests/libtest/lib1662.c+17 -17

@@ -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;

tests/libtest/lib1900.c+11 -11

@@ -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;
	}

tests/libtest/lib1903.c+11 -11

@@ -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;

tests/libtest/lib1905.c+25 -25

@@ -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;

tests/libtest/lib1908.c+14 -14

@@ -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;

tests/libtest/lib1910.c+9 -9

@@ -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;

tests/libtest/lib1911.c+5 -5

@@ -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;
	}

tests/libtest/lib1913.c+8 -8

@@ -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;

tests/libtest/lib1915.c+36 -36

@@ -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;
	}

tests/libtest/lib1939.c+7 -7

@@ -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 */
	}

tests/libtest/lib1940.c+17 -17

@@ -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;
	}

tests/libtest/lib1945.c+13 -13

@@ -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;
	}

tests/libtest/lib2032.c+19 -19

@@ -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);

tests/libtest/lib2301.c+2 -2

@@ -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;
	}

tests/libtest/lib2302.c+3 -3

@@ -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 */

tests/libtest/lib2306.c+8 -8

@@ -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;
	}

tests/libtest/lib2402.c+8 -8

@@ -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;

tests/libtest/lib2404.c+8 -8

@@ -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;

tests/libtest/lib2405.c+29 -29

@@ -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;
	}

tests/libtest/lib2502.c+8 -8

@@ -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;

tests/libtest/lib3027.c+8 -8

@@ -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;

tests/libtest/lib3033.c+9 -9

@@ -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;
	}

tests/libtest/lib3105.c+7 -7

@@ -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)

tests/libtest/lib3207.c+4 -4

@@ -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]);
	}

tests/libtest/lib502.c+11 -11

@@ -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;

tests/libtest/lib503.c+18 -18

@@ -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;

tests/libtest/lib504.c+16 -16

@@ -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;

tests/libtest/lib506.c+4 -4

@@ -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";

tests/libtest/lib507.c+6 -6

@@ -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)

tests/libtest/lib525.c+9 -9

@@ -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();
	}

tests/libtest/lib526.c+12 -12

@@ -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();
	}

tests/libtest/lib530.c+24 -22

@@ -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 */

tests/libtest/lib533.c+8 -8

@@ -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;

tests/libtest/lib540.c+38 -37

@@ -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);

tests/libtest/lib543.c+7 -7

@@ -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();

tests/libtest/lib544.c+3 -3

@@ -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. */

tests/libtest/lib547.c+2 -2

@@ -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 */

tests/libtest/lib552.c+2 -2

@@ -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;
	}

tests/libtest/lib555.c+9 -9

@@ -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();

tests/libtest/lib560.c+14 -14

@@ -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;

tests/libtest/lib564.c+6 -6

@@ -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;

tests/libtest/lib573.c+16 -16

@@ -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;

tests/libtest/lib575.c+20 -20

@@ -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;

tests/libtest/lib576.c+11 -11

@@ -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;
	}

tests/libtest/lib582.c+24 -21

@@ -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 */

tests/libtest/lib583.c+6 -6

@@ -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;

tests/libtest/lib586.c+4 -4

@@ -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";

tests/libtest/lib591.c+10 -10

@@ -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 */

tests/libtest/lib597.c+8 -8

@@ -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;

tests/libtest/lib643.c+4 -4

@@ -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;

tests/libtest/lib653.c+11 -11

@@ -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 */
	}

tests/libtest/lib654.c+16 -16

@@ -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;

tests/libtest/lib658.c+7 -7

@@ -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;

tests/libtest/lib659.c+7 -7

@@ -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;

tests/libtest/lib667.c+9 -9

@@ -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;

tests/libtest/lib668.c+9 -9

@@ -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;

tests/libtest/lib670.c+18 -18

@@ -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);

tests/libtest/lib674.c+10 -10

@@ -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;

tests/libtest/lib678.c+4 -5

@@ -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;
	}

tests/libtest/lib751.c+16 -16

@@ -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;

tests/libtest/lib753.c+32 -32

@@ -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();

tests/libtest/lib758.c+27 -25

@@ -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 */

tests/libtest/lib766.c+8 -8

@@ -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;

tests/libtest/testtrace.c+6 -6

@@ -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 "-"

tests/libtest/testtrace.h+2 -2

@@ -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 */