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)
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",
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;
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;
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;
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,
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);
}
}
}
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;
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 */
}
/* 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)
}
/* 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);
*/
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;
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;
*/
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);
cleanup:
- curl_multi_cleanup(multi_handle);
+ curl_multi_cleanup(multi);
if(out_download)
curlx_fclose(out_download);
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;
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;
struct transfer_d {
size_t idx;
- CURL *easy;
+ CURL *curl;
char filename[128];
FILE *out;
curl_off_t recv_size;
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;
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);
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 */
}
*/
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;
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;
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);
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)
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;
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");
}
}
/* 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);
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;
}
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);
cleanup:
- curl_multi_cleanup(multi_handle);
+ curl_multi_cleanup(multi);
if(transfer_d) {
for(i = 0; i < transfer_count_d; ++i) {
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;
struct transfer_u {
size_t idx;
- CURL *easy;
+ CURL *curl;
const char *method;
char filename[128];
curl_mime *mime;
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;
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 */
}
*/
static CURLcode test_cli_hx_upload(const char *URL)
{
- CURLM *multi_handle;
+ CURLM *multi;
CURLSH *share;
const char *url;
const char *method = "PUT";
}
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;
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;
}
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);
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)
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");
}
}
/* 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);
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;
}
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);
} 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:
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);
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));
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)
}
struct test_ws_m1_ctx {
- CURL *easy;
+ CURL *curl;
char *send_buf;
char *recv_buf;
size_t send_len, nsent;
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;
}
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;
}
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 */
}
- 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) {
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);
#include "memdebug.h"
struct t1485_transfer_status {
- CURL *easy;
+ CURL *curl;
curl_off_t out_len;
size_t hd_line;
CURLcode result;
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) {
}
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);
static CURLcode test_lib1485(const char *URL)
{
- CURL *curls = NULL;
+ CURL *curl = NULL;
CURLcode res = CURLE_OK;
struct t1485_transfer_status st;
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 */
static CURLcode test_lib1500(const char *URL)
{
- CURL *curls = NULL;
+ CURL *curl = NULL;
CURLM *multi = NULL;
int still_running;
CURLcode i = TEST_ERR_FAILURE;
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);
/* undocumented cleanup sequence - type UA */
curl_multi_cleanup(multi);
- curl_easy_cleanup(curls);
+ curl_easy_cleanup(curl);
curl_global_cleanup();
if(res)
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;
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);
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. */
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);
/* 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;
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;
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);
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;
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];
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++) {
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;
interval.tv_sec = 1;
interval.tv_usec = 0;
- multi_perform(m, &running);
+ multi_perform(multi, &running);
abort_on_test_timeout();
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. */
/* 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;
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;
easy_init(curl);
- multi_init(mcurl);
+ multi_init(multi);
rcpt_list = curl_slist_append(rcpt_list, "<1507-recipient@example.com>");
#if 0
curl_easy_setopt(curl, CURLOPT_MAIL_FROM, "<1507-realuser@example.com>");
curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, rcpt_list);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
- multi_add_handle(mcurl, curl);
+ multi_add_handle(multi, curl);
mp_start = curlx_now();
/* we start some action by calling perform right away */
- curl_multi_perform(mcurl, &still_running);
+ curl_multi_perform(multi, &still_running);
while(still_running) {
struct timeval timeout;
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) {
}
/* 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
break;
case 0: /* timeout */
default: /* action */
- curl_multi_perform(mcurl, &still_running);
+ curl_multi_perform(multi, &still_running);
break;
}
}
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();
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");
#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;
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();
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;
}
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;
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;
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 */
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();
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) {
}
/* 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);
break;
case 0: /* timeout */
default: /* action */
- curl_multi_perform(multi_handle, &still_running);
+ curl_multi_perform(multi, &still_running);
break;
}
/* 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);
} 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;
#include "memdebug.h"
struct cb_data {
- CURL *easy_handle;
+ CURL *curl;
int response_received;
int paused;
size_t remaining_bytes;
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;
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;
#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 */
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);
static CURLcode test_lib1540(const char *URL)
{
- CURL *curls = NULL;
+ CURL *curl = NULL;
CURLcode res = CURLE_OK;
struct t1540_transfer_status st;
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 */
#include "memdebug.h"
struct t1541_transfer_status {
- CURL *easy;
+ CURL *curl;
int hd_count;
int bd_count;
CURLcode result;
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__);
}
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__);
}
(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;
static CURLcode test_lib1541(const char *URL)
{
- CURL *curls = NULL;
+ CURL *curl = NULL;
CURLcode res = CURLE_OK;
struct t1541_transfer_status st;
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 */
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;
* 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;
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;
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};
{"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;
}
static CURLcode test_lib1552(const char *URL)
{
- CURL *curls = NULL;
+ CURL *curl = NULL;
CURLM *multi = NULL;
int still_running;
CURLcode i = CURLE_OK;
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);
/* undocumented cleanup sequence - type UA */
curl_multi_cleanup(multi);
- curl_easy_cleanup(curls);
+ curl_easy_cleanup(curl);
curl_global_cleanup();
if(res)
static CURLcode test_lib1553(const char *URL)
{
- CURL *curls = NULL;
+ CURL *curl = NULL;
CURLM *multi = NULL;
int still_running;
CURLcode i = CURLE_OK;
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);
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)
"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]);
static CURLcode test_lib1557(const char *URL)
{
- CURLM *curlm = NULL;
+ CURLM *multi = NULL;
CURL *curl1 = NULL;
CURL *curl2 = NULL;
int running_handles = 0;
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;
}
#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;
static void *t1565_run_thread(void *ptr)
{
- CURL *easy = NULL;
+ CURL *curl = NULL;
CURLcode res = CURLE_OK;
int i;
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);
goto test_cleanup;
}
- pending_handles[pending_num] = easy;
+ pending_curls[pending_num] = curl;
pending_num++;
- easy = NULL;
+ curl = NULL;
pthread_mutex_unlock(&lock);
test_cleanup:
- curl_easy_cleanup(easy);
+ curl_easy_cleanup(curl);
pthread_mutex_lock(&lock);
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;
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--;
}
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;
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;
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;
}
static CURLcode test_lib1592(const char *URL)
{
int stillRunning;
- CURLM *multiHandle = NULL;
+ CURLM *multi = NULL;
CURL *curl = NULL;
CURLcode res = CURLE_OK;
CURLMcode mres;
global_init(CURL_GLOBAL_ALL);
- multi_init(multiHandle);
+ multi_init(multi);
easy_init(curl);
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);
test_cleanup:
curl_easy_cleanup(curl);
- curl_multi_cleanup(multiHandle);
+ curl_multi_cleanup(multi);
curl_global_cleanup();
return res;
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 };
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;
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;
}
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;
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) {
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);
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;
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;
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;
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;
}
/* 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 */
}
}
}
- curl_easy_cleanup(easy);
+ curl_easy_cleanup(curl);
curl_global_cleanup();
return error == 0 ? CURLE_OK : TEST_ERR_FAILURE;
}
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;
};
/* "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 {
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;
}
/* 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;
static CURLcode test_lib1915(const char *URL)
{
CURLcode res = CURLE_OK;
- CURL *hnd;
+ CURL *curl;
struct state st = {0};
global_init(CURL_GLOBAL_ALL);
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;
}
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
}
/* 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 */
}
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",
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 */
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);
static CURLcode test_lib1940(const char *URL)
{
- CURL *easy = NULL;
+ CURL *curl = NULL;
CURLcode res = CURLE_OK;
int header_request;
}
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;
}
#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;
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;
}
#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;
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, "
}
for(i = 0; i < MAX_EASY_HANDLES; ++i) {
- ntlm_easy[i] = NULL;
+ ntlm_curls[i] = NULL;
ntlm_sockets[i] = CURL_SOCKET_BAD;
}
/* 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;
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);
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;
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;
}
#ifndef CURL_DISABLE_WEBSOCKETS
struct ws_data {
- CURL *easy;
+ CURL *curl;
char *buf;
size_t blen;
size_t nwrites;
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)
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 */
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;
}
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];
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++) {
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;
interval.tv_sec = 1;
interval.tv_usec = 0;
- multi_perform(m, &running);
+ multi_perform(multi, &running);
abort_on_test_timeout();
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. */
/* 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;
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];
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++) {
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;
interval.tv_sec = 1;
interval.tv_usec = 0;
- multi_perform(m, &running);
+ multi_perform(multi, &running);
abort_on_test_timeout();
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. */
/* 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;
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;
CURLM *multi = NULL;
CURLM *multi1 = NULL;
- CURL *easy1 = NULL;
- CURL *easy2 = NULL;
+ CURL *curl1 = NULL;
+ CURL *curl2 = NULL;
unsigned int max_count = 0;
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);
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 */
}
}
- 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);
{
CURLMcode mc = CURLM_OK;
CURLM *multi = NULL;
- CURL *easy = NULL;
+ CURL *curl = NULL;
struct curl_waitfd ufds[10];
}
/* 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);
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;
}
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];
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++) {
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;
interval.tv_sec = 1;
interval.tv_usec = 0;
- multi_perform(m, &running);
+ multi_perform(multi, &running);
abort_on_test_timeout();
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. */
/* 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;
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;
#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;
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;
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;
test_cleanup:
- curl_multi_remove_handle(multi, easy);
+ curl_multi_remove_handle(multi, curl);
return res;
}
static CURLcode test_lib3105(const char *URL)
{
- CURL *curls = NULL;
+ CURL *curl = NULL;
CURLM *multi = NULL;
CURLcode i = CURLE_OK;
CURLcode res = CURLE_OK;
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);
test_cleanup:
curl_multi_cleanup(multi);
- curl_easy_cleanup(curls);
+ curl_easy_cleanup(curl);
curl_global_cleanup();
if(res)
#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]);
}
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;
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;
timeout.tv_sec = 0;
timeout.tv_usec = 100000L; /* 100 ms */
- multi_perform(m, &running);
+ multi_perform(multi, &running);
abort_on_test_timeout();
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. */
/* 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;
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;
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;
interval.tv_sec = 1;
interval.tv_usec = 0;
- multi_perform(m, &running);
+ multi_perform(multi, &running);
abort_on_test_timeout();
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. */
/* 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;
*/
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;
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;
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;
}
abort_on_test_timeout();
- multi_perform(m, &running);
+ multi_perform(multi, &running);
abort_on_test_timeout();
}
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 */
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. */
/* 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;
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) {
}
/* 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";
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;
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);
/* undocumented cleanup sequence - type UA */
curl_multi_cleanup(multi);
- curl_easy_cleanup(curls);
+ curl_easy_cleanup(curl);
curl_global_cleanup();
if(res)
FILE *hd_src = NULL;
int hd;
struct_stat file_info;
- CURLM *m = NULL;
+ CURLM *multi = NULL;
int running;
start_test_timing();
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;
interval.tv_sec = 1;
interval.tv_usec = 0;
- multi_perform(m, &running);
+ multi_perform(multi, &running);
abort_on_test_timeout();
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. */
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();
}
CURLcode res = CURLE_OK;
CURL *curl[NUM_HANDLES];
int running;
- CURLM *m = NULL;
+ CURLM *multi = NULL;
size_t current = 0;
size_t i;
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");
interval.tv_sec = 1;
interval.tv_usec = 0;
- multi_perform(m, &running);
+ multi_perform(multi, &running);
abort_on_test_timeout();
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 */
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 {
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. */
/* 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) {
for(i = 0; i < CURL_ARRAYSIZE(curl); i++)
curl_easy_cleanup(curl[i]);
- curl_multi_cleanup(m);
+ curl_multi_cleanup(multi);
curl_global_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();
}
/**
* 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++;
/**
* 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) {
}
}
-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));
/**
* 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)
{
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;
}
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};
/* 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};
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;
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;
}
/* 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 */
CURLcode res = CURLE_OK;
CURL *curl = NULL;
int running;
- CURLM *m = NULL;
+ CURLM *multi = NULL;
int current = 0;
start_test_timing();
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");
interval.tv_sec = 1;
interval.tv_usec = 0;
- multi_perform(m, &running);
+ multi_perform(multi, &running);
abort_on_test_timeout();
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 */
easy_setopt(curl, CURLOPT_FAILONERROR, 1L);
/* re-add it */
- multi_add_handle(m, curl);
+ multi_add_handle(multi, curl);
}
else
break; /* done */
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. */
/* undocumented cleanup sequence - type UB */
curl_easy_cleanup(curl);
- curl_multi_cleanup(m);
+ curl_multi_cleanup(multi);
curl_global_cleanup();
return res;
#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;
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;
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;
int M = -99;
- res_multi_perform(cm, &U);
+ res_multi_perform(multi, &U);
if(res)
return res;
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;
}
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;
}
}
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;
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();
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);
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();
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. */
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 */
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) {
current_offset = 0;
return CURLIOE_OK;
}
- (void)handle;
+ (void)curl;
return CURLIOE_UNKNOWNCMD;
}
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 */
CURLcode res = CURLE_OK;
CURL *curl = NULL;
int counter = 0;
- CURLM *m = NULL;
+ CURLM *multi = NULL;
int running = 1;
start_test_timing();
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;
timeout.tv_sec = 0;
timeout.tv_usec = 100000L; /* 100 ms */
- multi_perform(m, &running);
+ multi_perform(multi, &running);
abort_on_test_timeout();
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. */
/* 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();
*/
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 */
** 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();
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. */
abort_on_test_timeout();
/* timeout or readable/writable sockets */
- multi_perform(multi_handle, &still_running);
+ multi_perform(multi, &still_running);
abort_on_test_timeout();
}
/* 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;
CURLcode res = CURLE_OK;
CURL *curl = NULL;
int running;
- CURLM *m = NULL;
+ CURLM *multi = NULL;
debug_config.nohex = TRUE;
debug_config.tracetime = TRUE;
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");
interval.tv_sec = 1;
interval.tv_usec = 0;
- multi_perform(m, &running);
+ multi_perform(multi, &running);
abort_on_test_timeout();
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. */
/* undocumented cleanup sequence - type UB */
curl_easy_cleanup(curl);
- curl_multi_cleanup(m);
+ curl_multi_cleanup(multi);
curl_global_cleanup();
return res;
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;
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;
timeout.tv_sec = 0;
timeout.tv_usec = 100000L; /* 100 ms */
- multi_perform(m, &running);
+ multi_perform(multi, &running);
abort_on_test_timeout();
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. */
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);
/* 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;
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;
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();
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. */
abort_on_test_timeout();
- multi_perform(mhandle, &still_running);
+ multi_perform(multi, &still_running);
abort_on_test_timeout();
}
/* 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;
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;
}
/**
* 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)
/**
* 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) {
}
}
-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));
/**
* 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);
}
}
}
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};
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};
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();
/* 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 */
static CURLcode test_lib583(const char *URL)
{
int stillRunning;
- CURLM *multiHandle = NULL;
+ CURLM *multi = NULL;
CURL *curl = NULL;
CURLcode res = CURLE_OK;
CURLMcode mres;
global_init(CURL_GLOBAL_ALL);
- multi_init(multiHandle);
+ multi_init(multi);
easy_init(curl);
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);
/* undocumented cleanup sequence - type UB */
curl_easy_cleanup(curl);
- curl_multi_cleanup(multiHandle);
+ curl_multi_cleanup(multi);
curl_global_cleanup();
return res;
};
/* 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) {
}
/* 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";
static CURLcode test_lib591(const char *URL)
{
- CURL *easy = NULL;
+ CURL *curl = NULL;
CURLM *multi = NULL;
CURLcode res = CURLE_OK;
int running;
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;
/* undocumented cleanup sequence - type UA */
curl_multi_cleanup(multi);
- curl_easy_cleanup(easy);
+ curl_easy_cleanup(curl);
curl_global_cleanup();
/* close the local file */
static CURLcode test_lib597(const char *URL)
{
- CURL *easy = NULL;
+ CURL *curl = NULL;
CURLM *multi = NULL;
CURLcode res = CURLE_OK;
int running;
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;
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;
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);
}
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;
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 */
}
{
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;
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.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");
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;
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;
/* 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;
/* 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",
}
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;
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();
}
/* 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 "
test_cleanup:
curl_url_cleanup(urlp);
- curl_easy_cleanup(handle);
+ curl_easy_cleanup(curl);
curl_global_cleanup();
return res;
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();
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 "
test_cleanup:
curl_url_cleanup(urlp);
- curl_easy_cleanup(handle);
+ curl_easy_cleanup(curl);
curl_global_cleanup();
return res;
{
static const char testdata[] = "dummy";
- CURL *easy = NULL;
+ CURL *curl = NULL;
curl_mime *mime = NULL;
curl_mimepart *part;
CURLcode res = TEST_ERR_FAILURE;
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");
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;
{
static const char testdata[] = "dummy";
- CURL *easy = NULL;
+ CURL *curl = NULL;
curl_mime *mime = NULL;
curl_mimepart *part;
CURLcode res = TEST_ERR_FAILURE;
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;
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. */
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;
#define PAUSE_TIME 5
struct t670_ReadThis {
- CURL *easy;
+ CURL *curl;
time_t origin;
int count;
};
}
if(delta >= PAUSE_TIME)
- curl_easy_pause(pooh->easy, CURLPAUSE_CONT);
+ curl_easy_pause(pooh->curl, CURLPAUSE_CONT);
}
return 0;
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) {
/* 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;
}
/* 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) {
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;
}
if(delta >= PAUSE_TIME)
- curl_easy_pause(pooh.easy, CURLPAUSE_CONT);
+ curl_easy_pause(pooh.curl, CURLPAUSE_CONT);
}
FD_ZERO(&fdread);
}
}
- 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);
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();
/* 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 "
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;
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;
}
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;
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;
#include "memdebug.h"
struct t753_transfer_status {
- CURL *easy;
+ CURL *curl;
const char *name;
bool pause;
bool is_paused;
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;
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();
* 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);
}
}
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();
/**
* 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++;
/**
* 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) {
}
}
-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));
/**
* 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)
{
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;
}
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};
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;
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;
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;
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;
}
/* 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 */
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;
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;
char timebuf[20];
char *timestr;
- (void)handle;
+ (void)curl;
timebuf[0] = '\0';
timestr = &timebuf[0];
}
/* 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;
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 "-"
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 */
projects / thirdparty / curl.git / commitdiff
