- bump format strings to show the full value, drop casts.
- drop redundant casts (enum -> `%d`).
- drop some single-use macros.
- replace `int` with `bool` in testtrace.
Closes #18106
(void)data;
if(curl_easy_getinfo(handle->h, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
&totalsize) == CURLE_OK)
- curl_mfprintf(stderr, "INFO: [%d] write, "
+ curl_mfprintf(stderr, "INFO: [%zu] write, "
"Content-Length %" CURL_FORMAT_CURL_OFF_T "\n",
- (int)handle->idx, totalsize);
+ handle->idx, totalsize);
if(!handle->resumed) {
++handle->paused;
- curl_mfprintf(stderr, "INFO: [%d] write, PAUSING %d time on %lu bytes\n",
- (int)handle->idx, handle->paused, (long)realsize);
+ curl_mfprintf(stderr, "INFO: [%zu] write, PAUSING %d time on %zu bytes\n",
+ handle->idx, handle->paused, realsize);
assert(handle->paused == 1);
return CURL_WRITEFUNC_PAUSE;
}
if(handle->fail_write) {
++handle->errored;
- curl_mfprintf(stderr, "INFO: [%d] FAIL write of %lu bytes, %d time\n",
- (int)handle->idx, (long)realsize, handle->errored);
+ curl_mfprintf(stderr, "INFO: [%zu] FAIL write of %zu bytes, %d time\n",
+ handle->idx, realsize, handle->errored);
return CURL_WRITEFUNC_ERROR;
}
- curl_mfprintf(stderr, "INFO: [%d] write, accepting %lu bytes\n",
- (int)handle->idx, (long)realsize);
+ curl_mfprintf(stderr, "INFO: [%zu] write, accepting %zu bytes\n",
+ handle->idx, realsize);
return realsize;
}
curl_mfprintf(stderr, "INFO: no more handles running\n");
for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
if(!handles[i].paused) {
- curl_mfprintf(stderr, "ERROR: [%d] NOT PAUSED\n", (int)i);
+ curl_mfprintf(stderr, "ERROR: [%zu] NOT PAUSED\n", i);
as_expected = 0;
}
else if(handles[i].paused != 1) {
- curl_mfprintf(stderr, "ERROR: [%d] PAUSED %d times!\n",
- (int)i, handles[i].paused);
+ curl_mfprintf(stderr, "ERROR: [%zu] PAUSED %d times!\n",
+ i, handles[i].paused);
as_expected = 0;
}
else if(!handles[i].resumed) {
- curl_mfprintf(stderr, "ERROR: [%d] NOT resumed!\n", (int)i);
+ curl_mfprintf(stderr, "ERROR: [%zu] NOT resumed!\n", i);
as_expected = 0;
}
else if(handles[i].errored != 1) {
- curl_mfprintf(stderr, "ERROR: [%d] NOT errored once, %d instead!\n",
- (int)i, handles[i].errored);
+ curl_mfprintf(stderr, "ERROR: [%zu] NOT errored once, %d instead!\n",
+ i, handles[i].errored);
as_expected = 0;
}
}
for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
if(msg->easy_handle == handles[i].h) {
if(handles[i].paused != 1 || !handles[i].resumed) {
- curl_mfprintf(stderr, "ERROR: [%d] done, pauses=%d, resumed=%d, "
- "result %d - wtf?\n", (int)i, handles[i].paused,
+ curl_mfprintf(stderr, "ERROR: [%zu] done, paused=%d, "
+ "resumed=%d, result %d - wtf?\n", i,
+ handles[i].paused,
handles[i].resumed, msg->data.result);
rc = (CURLcode)1;
goto out;
if(resume_round > 0 && rounds == resume_round) {
/* time to resume */
for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
- curl_mfprintf(stderr, "INFO: [%d] resumed\n", (int)i);
+ curl_mfprintf(stderr, "INFO: [%zu] resumed\n", i);
handles[i].resumed = 1;
curl_easy_pause(handles[i].h, CURLPAUSE_CONT);
}
curl_easy_setopt(easy, CURLOPT_WRITEDATA, out_push);
curl_mfprintf(stderr, "**** push callback approves stream %u, "
- "got %lu headers!\n", count, (unsigned long)num_headers);
+ "got %zu headers!\n", count, num_headers);
for(i = 0; i < num_headers; i++) {
headp = curl_pushheader_bynum(headers, i);
- curl_mfprintf(stderr, "**** header %lu: %s\n", (unsigned long)i, headp);
+ curl_mfprintf(stderr, "**** header %zu: %s\n", i, headp);
}
headp = curl_pushheader_byname(headers, ":path");
int transfers = 1; /* we start with one */
struct CURLMsg *m;
- debug_config.nohex = 1;
- debug_config.tracetime = 0;
+ debug_config.nohex = TRUE;
+ debug_config.tracetime = FALSE;
if(!URL) {
curl_mfprintf(stderr, "need URL as argument\n");
static int verbose_d = 1;
struct transfer_d {
- int idx;
+ size_t idx;
CURL *easy;
char filename[128];
FILE *out;
size_t blen = (nitems * buflen);
size_t nwritten;
- curl_mfprintf(stderr, "[t-%d] RECV %ld bytes, total=%ld, pause_at=%ld\n",
- t->idx, (long)blen, (long)t->recv_size, (long)t->pause_at);
+ curl_mfprintf(stderr, "[t-%zu] RECV %zu bytes, "
+ "total=%" CURL_FORMAT_CURL_OFF_T ", "
+ "pause_at=%" CURL_FORMAT_CURL_OFF_T "\n",
+ t->idx, blen, t->recv_size, t->pause_at);
if(!t->out) {
- curl_msnprintf(t->filename, sizeof(t->filename)-1, "download_%u.data",
+ curl_msnprintf(t->filename, sizeof(t->filename)-1, "download_%zu.data",
t->idx);
t->out = fopen(t->filename, "wb");
if(!t->out)
if(!t->resumed &&
t->recv_size < t->pause_at &&
((t->recv_size + (curl_off_t)blen) >= t->pause_at)) {
- curl_mfprintf(stderr, "[t-%d] PAUSE\n", t->idx);
+ curl_mfprintf(stderr, "[t-%zu] PAUSE\n", t->idx);
t->paused = 1;
return CURL_WRITEFUNC_PAUSE;
}
nwritten = fwrite(buf, nitems, buflen, t->out);
if(nwritten < blen) {
- curl_mfprintf(stderr, "[t-%d] write failure\n", t->idx);
+ curl_mfprintf(stderr, "[t-%zu] write failure\n", t->idx);
return 0;
}
t->recv_size += (curl_off_t)nwritten;
if(t->fail_at > 0 && t->recv_size >= t->fail_at) {
- curl_mfprintf(stderr, "[t-%d] FAIL by write callback at %ld bytes\n",
- t->idx, (long)t->recv_size);
+ curl_mfprintf(stderr, "[t-%zu] FAIL by write callback at "
+ "%" CURL_FORMAT_CURL_OFF_T " bytes\n", t->idx, t->recv_size);
return CURL_WRITEFUNC_ERROR;
}
(void)ulnow;
(void)dltotal;
if(t->abort_at > 0 && dlnow >= t->abort_at) {
- curl_mfprintf(stderr, "[t-%d] ABORT by progress_cb at %ld bytes\n",
- t->idx, (long)dlnow);
+ curl_mfprintf(stderr, "[t-%zu] ABORT by progress_cb at "
+ "%" CURL_FORMAT_CURL_OFF_T " bytes\n", t->idx, dlnow);
return 1;
}
return 0;
active_transfers = 0;
for(i = 0; i < transfer_count_d; ++i) {
t = &transfer_d[i];
- t->idx = (int)i;
+ t->idx = i;
t->abort_at = (curl_off_t)abort_offset;
t->fail_at = (curl_off_t)fail_offset;
t->pause_at = (curl_off_t)pause_offset;
if(!t->easy ||
setup_hx_download(t->easy, url, t, http_version, host, share,
use_earlydata, fresh_connect)) {
- curl_mfprintf(stderr, "[t-%d] FAILED setup\n", (int)i);
+ curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i);
result = (CURLcode)1;
goto cleanup;
}
curl_multi_add_handle(multi_handle, t->easy);
t->started = 1;
++active_transfers;
- curl_mfprintf(stderr, "[t-%d] STARTED\n", t->idx);
+ curl_mfprintf(stderr, "[t-%zu] STARTED\n", t->idx);
}
do {
if(t) {
t->done = 1;
t->result = m->data.result;
- curl_mfprintf(stderr, "[t-%d] FINISHED with result %d\n",
+ curl_mfprintf(stderr, "[t-%zu] FINISHED with result %d\n",
t->idx, t->result);
if(use_earlydata) {
curl_off_t sent;
curl_easy_getinfo(e, CURLINFO_EARLYDATA_SENT_T, &sent);
- curl_mfprintf(stderr, "[t-%d] EarlyData: %ld\n", t->idx,
- (long)sent);
+ curl_mfprintf(stderr, "[t-%zu] EarlyData: "
+ "%" CURL_FORMAT_CURL_OFF_T "\n", t->idx, sent);
}
}
else {
curl_multi_remove_handle(multi_handle, t->easy);
t->done = 1;
active_transfers--;
- curl_mfprintf(stderr, "[t-%d] ABORTED\n", t->idx);
+ curl_mfprintf(stderr, "[t-%zu] ABORTED\n", t->idx);
}
}
}
t->resumed = 1;
t->paused = 0;
curl_easy_pause(t->easy, CURLPAUSE_CONT);
- curl_mfprintf(stderr, "[t-%d] RESUMED\n", t->idx);
+ curl_mfprintf(stderr, "[t-%zu] RESUMED\n", t->idx);
break;
}
}
if(!t->easy ||
setup_hx_download(t->easy, url, t, http_version, host, share,
use_earlydata, fresh_connect)) {
- curl_mfprintf(stderr, "[t-%d] FAILED setup\n", (int)i);
+ curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i);
result = (CURLcode)1;
goto cleanup;
}
curl_multi_add_handle(multi_handle, t->easy);
t->started = 1;
++active_transfers;
- curl_mfprintf(stderr, "[t-%d] STARTED\n", t->idx);
+ curl_mfprintf(stderr, "[t-%zu] STARTED\n", t->idx);
break;
}
}
static int verbose_u = 1;
struct transfer_u {
- int idx;
+ size_t idx;
CURL *easy;
const char *method;
char filename[128];
size_t blen = (nitems * buflen);
size_t nwritten;
- curl_mfprintf(stderr, "[t-%d] RECV %ld bytes, total=%ld, pause_at=%ld\n",
- t->idx, (long)blen, (long)t->recv_size, (long)t->pause_at);
+ curl_mfprintf(stderr, "[t-%zu] RECV %zu bytes, "
+ "total=%" CURL_FORMAT_CURL_OFF_T ", "
+ "pause_at=%" CURL_FORMAT_CURL_OFF_T "\n",
+ t->idx, blen, t->recv_size, t->pause_at);
if(!t->out) {
- curl_msnprintf(t->filename, sizeof(t->filename)-1, "download_%u.data",
+ curl_msnprintf(t->filename, sizeof(t->filename)-1, "download_%zu.data",
t->idx);
t->out = fopen(t->filename, "wb");
if(!t->out)
nwritten = fwrite(buf, nitems, buflen, t->out);
if(nwritten < blen) {
- curl_mfprintf(stderr, "[t-%d] write failure\n", t->idx);
+ curl_mfprintf(stderr, "[t-%zu] write failure\n", t->idx);
return 0;
}
t->recv_size += (curl_off_t)nwritten;
else
nread = blen;
- curl_mfprintf(stderr, "[t-%d] SEND %ld bytes, total=%ld, pause_at=%ld\n",
- t->idx, (long)nread, (long)t->send_total, (long)t->pause_at);
+ curl_mfprintf(stderr, "[t-%zu] SEND %zu bytes, "
+ "total=%" CURL_FORMAT_CURL_OFF_T ", "
+ "pause_at=%" CURL_FORMAT_CURL_OFF_T "\n",
+ t->idx, nread, t->send_total, t->pause_at);
if(!t->resumed &&
t->send_size < t->pause_at &&
((t->send_size + (curl_off_t)blen) >= t->pause_at)) {
- curl_mfprintf(stderr, "[t-%d] PAUSE\n", t->idx);
+ curl_mfprintf(stderr, "[t-%zu] PAUSE\n", t->idx);
t->paused = 1;
return CURL_READFUNC_PAUSE;
}
memset(buf, 'x', nread);
t->send_size += (curl_off_t)nread;
if(t->fail_at > 0 && t->send_size >= t->fail_at) {
- curl_mfprintf(stderr, "[t-%d] ABORT by read callback at %ld bytes\n",
- t->idx, (long)t->send_size);
+ curl_mfprintf(stderr, "[t-%zu] ABORT by read callback at "
+ "%" CURL_FORMAT_CURL_OFF_T " bytes\n", t->idx, t->send_size);
return CURL_READFUNC_ABORT;
}
return (size_t)nread;
(void)dlnow;
(void)dltotal;
if(t->abort_at > 0 && ulnow >= t->abort_at) {
- curl_mfprintf(stderr, "[t-%d] ABORT by progress_cb at %ld bytes sent\n",
- t->idx, (long)ulnow);
+ curl_mfprintf(stderr, "[t-%zu] ABORT by progress_cb at "
+ "%" CURL_FORMAT_CURL_OFF_T " bytes sent\n", t->idx, ulnow);
return 1;
}
return 0;
active_transfers = 0;
for(i = 0; i < transfer_count_u; ++i) {
t = &transfer_u[i];
- t->idx = (int)i;
+ t->idx = i;
t->method = method;
t->send_total = (curl_off_t)send_total;
t->abort_at = (curl_off_t)abort_offset;
t->easy = easy;
if(setup_hx_upload(t->easy, url, t, http_version, host, share,
use_earlydata, announce_length)) {
- curl_mfprintf(stderr, "[t-%d] FAILED setup\n", (int)i);
+ curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i);
return (CURLcode)1;
}
- curl_mfprintf(stderr, "[t-%d] STARTING\n", t->idx);
+ curl_mfprintf(stderr, "[t-%zu] STARTING\n", t->idx);
rc = curl_easy_perform(easy);
- curl_mfprintf(stderr, "[t-%d] DONE -> %d\n", t->idx, rc);
+ curl_mfprintf(stderr, "[t-%zu] DONE -> %d\n", t->idx, rc);
t->easy = NULL;
curl_easy_reset(easy);
}
t->easy = curl_easy_init();
if(!t->easy || setup_hx_upload(t->easy, url, t, http_version, host,
share, use_earlydata, announce_length)) {
- curl_mfprintf(stderr, "[t-%d] FAILED setup\n", (int)i);
+ curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i);
return (CURLcode)1;
}
curl_multi_add_handle(multi_handle, t->easy);
t->started = 1;
++active_transfers;
- curl_mfprintf(stderr, "[t-%d] STARTED\n", t->idx);
+ curl_mfprintf(stderr, "[t-%zu] STARTED\n", t->idx);
}
do {
long res_status;
curl_easy_getinfo(e, CURLINFO_RESPONSE_CODE, &res_status);
t->done = 1;
- curl_mfprintf(stderr, "[t-%d] FINISHED, result=%d, response=%ld\n",
+ 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_mfprintf(stderr, "[t-%d] EarlyData: %ld\n", t->idx,
- (long)sent);
+ curl_mfprintf(stderr, "[t-%zu] EarlyData: "
+ "%" CURL_FORMAT_CURL_OFF_T "\n", t->idx, sent);
}
}
else {
curl_multi_remove_handle(multi_handle, t->easy);
t->done = 1;
active_transfers--;
- curl_mfprintf(stderr, "[t-%d] ABORTED\n", t->idx);
+ curl_mfprintf(stderr, "[t-%zu] ABORTED\n", t->idx);
}
}
}
t->resumed = 1;
t->paused = 0;
curl_easy_pause(t->easy, CURLPAUSE_CONT);
- curl_mfprintf(stderr, "[t-%d] RESUMED\n", t->idx);
+ curl_mfprintf(stderr, "[t-%zu] RESUMED\n", t->idx);
break;
}
}
if(!t->easy || setup_hx_upload(t->easy, url, t, http_version,
host, share, use_earlydata,
announce_length)) {
- curl_mfprintf(stderr, "[t-%d] FAILED setup\n", (int)i);
+ curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i);
return (CURLcode)1;
}
curl_multi_add_handle(multi_handle, t->easy);
t->started = 1;
++active_transfers;
- curl_mfprintf(stderr, "[t-%d] STARTED\n", t->idx);
+ curl_mfprintf(stderr, "[t-%zu] STARTED\n", t->idx);
break;
}
}
if(frame->flags & CURLWS_CLOSE) {
curl_mfprintf(stderr, "recv_data: unexpected CLOSE frame from server, "
- "got %ld bytes, offset=%ld, rflags %x\n",
- (long)nread, (long)r_offset, frame->flags);
+ "got %zu bytes, offset=%zu, rflags %x\n",
+ nread, r_offset, frame->flags);
return CURLE_RECV_ERROR;
}
if(!r_offset && !(frame->flags & CURLWS_BINARY)) {
- curl_mfprintf(stderr, "recv_data: wrong frame, got %ld bytes, offset=%ld, "
+ curl_mfprintf(stderr, "recv_data: wrong frame, got %zu bytes, offset=%zu, "
"rflags %x\n",
- (long)nread, (long)r_offset, frame->flags);
+ nread, r_offset, frame->flags);
return CURLE_RECV_ERROR;
}
if(frame->offset != (curl_off_t)r_offset) {
- curl_mfprintf(stderr, "recv_data: frame offset, expected %ld, got %ld\n",
- (long)r_offset, (long)frame->offset);
+ curl_mfprintf(stderr, "recv_data: frame offset, expected %zu, "
+ "got %" CURL_FORMAT_CURL_OFF_T "\n",
+ r_offset, frame->offset);
return CURLE_RECV_ERROR;
}
if(frame->bytesleft != (curl_off_t)(exp_len - r_offset - nread)) {
curl_mfprintf(stderr, "recv_data: frame bytesleft, "
- "expected %ld, got %ld\n",
- (long)(exp_len - r_offset - nread), (long)frame->bytesleft);
+ "expected %" CURL_FORMAT_CURL_OFF_T ", "
+ "got %" CURL_FORMAT_CURL_OFF_T "\n",
+ (curl_off_t)(exp_len - r_offset - nread), frame->bytesleft);
return CURLE_RECV_ERROR;
}
if(r_offset + nread > exp_len) {
- curl_mfprintf(stderr, "recv_data: data length, expected %ld, now at %ld\n",
- (long)exp_len, (long)(r_offset + nread));
+ curl_mfprintf(stderr, "recv_data: data length, expected %zu, now at %zu\n",
+ exp_len, r_offset + nread);
return CURLE_RECV_ERROR;
}
return CURLE_OK;
r = curl_ws_send(curl, sbuf, slen, &nwritten, 0, CURLWS_BINARY);
sblock = (r == CURLE_AGAIN);
if(!r || (r == CURLE_AGAIN)) {
- curl_mfprintf(stderr, "curl_ws_send(len=%ld) -> %d, %ld (%ld/%ld)\n",
- (long)slen, r, (long)nwritten,
- (long)(len - slen), (long)len);
+ curl_mfprintf(stderr, "curl_ws_send(len=%zu) -> %d, "
+ "%zu (%" CURL_FORMAT_CURL_OFF_T "/%zu)\n",
+ slen, r, nwritten, (curl_off_t)(len - slen), len);
sbuf += nwritten;
slen -= nwritten;
}
&nread, &frame);
if(!r || (r == CURLE_AGAIN)) {
rblock = (r == CURLE_AGAIN);
- curl_mfprintf(stderr, "curl_ws_recv(len=%ld) -> %d, %ld (%ld/%ld) "
- "\n",
- (long)rlen, r, (long)nread, (long)(len - rlen),
- (long)len);
+ curl_mfprintf(stderr, "curl_ws_recv(len=%zu) -> %d, %zu (%ld/%zu) "
+ "\n", rlen, r, nread, (long)(len - rlen), len);
if(!r) {
r = check_recv(frame, len - rlen, nread, len);
if(r)
if(memcmp(send_buf, recv_buf, len)) {
curl_mfprintf(stderr, "recv_data: data differs\n");
debug_dump("", "expected:", stderr,
- (const unsigned char *)send_buf, len, 0);
+ (const unsigned char *)send_buf, len, FALSE);
debug_dump("", "received:", stderr,
- (const unsigned char *)recv_buf, len, 0);
+ (const unsigned char *)recv_buf, len, FALSE);
r = CURLE_RECV_ERROR;
goto out;
}
plen_max = plen_min;
if(plen_max < plen_min) {
- curl_mfprintf(stderr, "maxlen must be >= minlen, got %ld-%ld\n",
- (long)plen_min, (long)plen_max);
+ curl_mfprintf(stderr, "maxlen must be >= minlen, got %zu-%zu\n",
+ plen_min, plen_max);
res = CURLE_BAD_FUNCTION_ARGUMENT;
goto cleanup;
}
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 2L); /* websocket style */
res = curl_easy_perform(curl);
- curl_mfprintf(stderr, "curl_easy_perform() returned %u\n", (int)res);
+ curl_mfprintf(stderr, "curl_easy_perform() returned %u\n", res);
if(res == CURLE_OK)
res = data_echo(curl, count, plen_min, plen_max);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 2L); /* websocket style */
res = curl_easy_perform(curl);
- curl_mfprintf(stderr, "curl_easy_perform() returned %u\n", (int)res);
+ curl_mfprintf(stderr, "curl_easy_perform() returned %u\n", res);
if(res == CURLE_OK)
res = pingpong(curl, payload);
if((ec = curl_easy_setopt((A), (B), (C))) != CURLE_OK) { \
curl_mfprintf(stderr, "%s:%d curl_easy_setopt() failed, " \
"with code %d (%s)\n", \
- (Y), (Z), (int)ec, curl_easy_strerror(ec)); \
+ (Y), (Z), ec, curl_easy_strerror(ec)); \
res = ec; \
} \
} while(0)
if((ec = curl_multi_setopt((A), (B), (C))) != CURLM_OK) { \
curl_mfprintf(stderr, "%s:%d curl_multi_setopt() failed, " \
"with code %d (%s)\n", \
- (Y), (Z), (int)ec, curl_multi_strerror(ec)); \
+ (Y), (Z), ec, curl_multi_strerror(ec)); \
res = TEST_ERR_MULTI; \
} \
} while(0)
if((ec = curl_multi_add_handle((A), (B))) != CURLM_OK) { \
curl_mfprintf(stderr, "%s:%d curl_multi_add_handle() failed, " \
"with code %d (%s)\n", \
- (Y), (Z), (int)ec, curl_multi_strerror(ec)); \
+ (Y), (Z), ec, curl_multi_strerror(ec)); \
res = TEST_ERR_MULTI; \
} \
} while(0)
if((ec = curl_multi_remove_handle((A), (B))) != CURLM_OK) { \
curl_mfprintf(stderr, "%s:%d curl_multi_remove_handle() failed, " \
"with code %d (%s)\n", \
- (Y), (Z), (int)ec, curl_multi_strerror(ec)); \
+ (Y), (Z), ec, curl_multi_strerror(ec)); \
res = TEST_ERR_MULTI; \
} \
} while(0)
if((ec = curl_multi_perform((A), (B))) != CURLM_OK) { \
curl_mfprintf(stderr, "%s:%d curl_multi_perform() failed, " \
"with code %d (%s)\n", \
- (Y), (Z), (int)ec, curl_multi_strerror(ec)); \
+ (Y), (Z), ec, curl_multi_strerror(ec)); \
res = TEST_ERR_MULTI; \
} \
else if(*((B)) < 0) { \
if((ec = curl_multi_fdset((A), (B), (C), (D), (E))) != CURLM_OK) { \
curl_mfprintf(stderr, "%s:%d curl_multi_fdset() failed, " \
"with code %d (%s)\n", \
- (Y), (Z), (int)ec, curl_multi_strerror(ec)); \
+ (Y), (Z), ec, curl_multi_strerror(ec)); \
res = TEST_ERR_MULTI; \
} \
else if(*((E)) < -1) { \
if((ec = curl_multi_timeout((A), (B))) != CURLM_OK) { \
curl_mfprintf(stderr, "%s:%d curl_multi_timeout() failed, " \
"with code %d (%s)\n", \
- (Y), (Z), (int)ec, curl_multi_strerror(ec)); \
+ (Y), (Z), ec, curl_multi_strerror(ec)); \
res = TEST_ERR_BAD_TIMEOUT; \
} \
else if(*((B)) < -1L) { \
if((ec = curl_multi_poll((A), (B), (C), (D), (E))) != CURLM_OK) { \
curl_mfprintf(stderr, "%s:%d curl_multi_poll() failed, " \
"with code %d (%s)\n", \
- (Y), (Z), (int)ec, curl_multi_strerror(ec)); \
+ (Y), (Z), ec, curl_multi_strerror(ec)); \
res = TEST_ERR_MULTI; \
} \
else if(*((E)) < 0) { \
if((ec = curl_multi_wakeup((A))) != CURLM_OK) { \
curl_mfprintf(stderr, "%s:%d curl_multi_wakeup() failed, " \
"with code %d (%s)\n", \
- (Y), (Z), (int)ec, curl_multi_strerror(ec)); \
+ (Y), (Z), ec, curl_multi_strerror(ec)); \
res = TEST_ERR_MULTI; \
} \
} while(0)
if((ec = curl_global_init((A))) != CURLE_OK) { \
curl_mfprintf(stderr, "%s:%d curl_global_init() failed, " \
"with code %d (%s)\n", \
- (Y), (Z), (int)ec, curl_easy_strerror(ec)); \
+ (Y), (Z), ec, curl_easy_strerror(ec)); \
res = ec; \
} \
} while(0)
if(clen < 0) {
curl_mfprintf(stderr,
"header_callback, expected known Content-Length, "
- "got: %ld\n", (long)clen);
+ "got: %" CURL_FORMAT_CURL_OFF_T "\n", clen);
return CURLE_WRITE_ERROR;
}
}
/* Create fake DNS entries for serverX.example.com for all handles */
for(i = 0; i < CURL_ARRAYSIZE(curl); i++) {
- curl_msnprintf(dnsentry, sizeof(dnsentry), "server%d.example.com:%s:%s",
- (int)i + 1, port, address);
+ curl_msnprintf(dnsentry, sizeof(dnsentry), "server%zu.example.com:%s:%s",
+ i + 1, port, address);
curl_mprintf("%s\n", dnsentry);
slist2 = curl_slist_append(slist, dnsentry);
if(!slist2) {
easy_init(curl[i]);
/* specify target */
curl_msnprintf(target_url, sizeof(target_url),
- "http://server%d.example.com:%s/path/1506%04i",
- (int)i + 1, port, (int)i + 1);
+ "http://server%zu.example.com:%s/path/1506%04zu",
+ i + 1, port, i + 1);
target_url[sizeof(target_url) - 1] = '\0';
easy_setopt(curl[i], CURLOPT_URL, target_url);
/* go verbose */
#include "memdebug.h"
-/*
- * This is the list of basic details you need to tweak to get things right.
- */
-#define USERNAME "user@example.com"
-#define PASSWORD "123qwerty"
-#define RECIPIENT "<1507-recipient@example.com>"
-#define MAILFROM "<1507-realuser@example.com>"
-
static size_t t1507_read_cb(char *ptr, size_t size, size_t nmemb, void *userp)
{
(void)ptr;
multi_init(mcurl);
- rcpt_list = curl_slist_append(rcpt_list, RECIPIENT);
+ rcpt_list = curl_slist_append(rcpt_list, "<1507-recipient@example.com>");
#if 0
/* more addresses can be added here */
rcpt_list = curl_slist_append(rcpt_list, "<others@example.com>");
#endif
curl_easy_setopt(curl, CURLOPT_URL, URL);
#if 0
- curl_easy_setopt(curl, CURLOPT_USERNAME, USERNAME);
- curl_easy_setopt(curl, CURLOPT_PASSWORD, PASSWORD);
+ curl_easy_setopt(curl, CURLOPT_USERNAME, "user@example.com");
+ curl_easy_setopt(curl, CURLOPT_PASSWORD, "123qwerty");
#endif
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
curl_easy_setopt(curl, CURLOPT_READFUNCTION, t1507_read_cb);
- curl_easy_setopt(curl, CURLOPT_MAIL_FROM, MAILFROM);
+ 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);
easy_init(curl[i]);
/* specify target */
curl_msnprintf(target_url, sizeof(target_url),
- "http://server.example.curl:%s/path/1512%04i",
- port, (int)i + 1);
+ "http://server.example.curl:%s/path/1512%04zu",
+ port, i + 1);
target_url[sizeof(target_url) - 1] = '\0';
easy_setopt(curl[i], CURLOPT_URL, target_url);
/* go verbose */
easy_setopt(curls, CURLOPT_RESOLVE, resolve_list);
easy_setopt(curls, CURLOPT_DNS_CACHE_TIMEOUT, DNS_TIMEOUT);
- debug_config.nohex = 1;
- debug_config.tracetime = 1;
+ 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);
#include "memdebug.h"
-/*
- * This is the list of basic details you need to tweak to get things right.
- */
-#define TO "<recipient@example.com>"
-#define FROM "<sender@example.com>"
-
struct upload_status {
int lines_read;
};
return TEST_ERR_MAJOR_BAD;
}
- rcpt_list = curl_slist_append(rcpt_list, TO);
- /* more addresses can be added here
- rcpt_list = curl_slist_append(rcpt_list, "<others@example.com>");
- */
-
+ rcpt_list = curl_slist_append(rcpt_list, "<recipient@example.com>");
+#if 0
+ /* more addresses can be added here */
+ rcpt_list = curl_slist_append(rcpt_list, "<others@example.com>");
+#endif
test_setopt(curl, CURLOPT_URL, URL);
test_setopt(curl, CURLOPT_UPLOAD, 1L);
test_setopt(curl, CURLOPT_READFUNCTION, t1520_read_cb);
test_setopt(curl, CURLOPT_READDATA, &upload_ctx);
- test_setopt(curl, CURLOPT_MAIL_FROM, FROM);
+ test_setopt(curl, CURLOPT_MAIL_FROM, "<sender@example.com>");
test_setopt(curl, CURLOPT_MAIL_RCPT, rcpt_list);
test_setopt(curl, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, g_Data);
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)sizeof(g_Data));
- debug_config.nohex = 1;
- debug_config.tracetime = 1;
+ debug_config.nohex = TRUE;
+ debug_config.tracetime = TRUE;
test_setopt(curl, CURLOPT_DEBUGDATA, &debug_config);
test_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
test_setopt(curl, CURLOPT_VERBOSE, 1L);
curl_off_t uploadSize;
curl_easy_getinfo(curl, CURLINFO_SIZE_UPLOAD_T, &uploadSize);
- curl_mprintf("uploadSize = %ld\n", (long)uploadSize);
+ curl_mprintf("uploadSize = %" CURL_FORMAT_CURL_OFF_T "\n", uploadSize);
if((size_t) uploadSize == sizeof(g_Data)) {
curl_mprintf("!!!!!!!!!! PASS\n");
}
else {
- curl_mprintf("sent %d, libcurl says %d\n",
- (int)sizeof(g_Data), (int)uploadSize);
+ curl_mprintf("sent %zu, libcurl says %" CURL_FORMAT_CURL_OFF_T "\n",
+ sizeof(g_Data), uploadSize);
}
}
else {
curl_url_strerror((CURLUcode)-INT_MAX);
/* NOLINTEND(clang-analyzer-optin.core.EnumCastOutOfRange) */
for(easyret = CURLE_OK; easyret <= CURL_LAST; easyret++) {
- curl_mprintf("e%d: %s\n", (int)easyret, curl_easy_strerror(easyret));
+ curl_mprintf("e%d: %s\n", easyret, curl_easy_strerror(easyret));
}
for(multiret = CURLM_CALL_MULTI_PERFORM; multiret <= CURLM_LAST;
multiret++) {
- curl_mprintf("m%d: %s\n", (int)multiret, curl_multi_strerror(multiret));
+ curl_mprintf("m%d: %s\n", multiret, curl_multi_strerror(multiret));
}
for(shareret = CURLSHE_OK; shareret <= CURLSHE_LAST; shareret++) {
- curl_mprintf("s%d: %s\n", (int)shareret, curl_share_strerror(shareret));
+ curl_mprintf("s%d: %s\n", shareret, curl_share_strerror(shareret));
}
for(urlret = CURLUE_OK; urlret <= CURLUE_LAST; urlret++) {
- curl_mprintf("u%d: %s\n", (int)urlret, curl_url_strerror(urlret));
+ curl_mprintf("u%d: %s\n", urlret, curl_url_strerror(urlret));
}
return res;
easy_setopt(curls, CURLOPT_XFERINFODATA, &st);
easy_setopt(curls, CURLOPT_NOPROGRESS, 0L);
- debug_config.nohex = 1;
- debug_config.tracetime = 1;
+ 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);
easy_setopt(easy, CURLOPT_URL, URL);
- debug_config.nohex = 1;
- debug_config.tracetime = 0;
+ 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(curls, CURLOPT_XFERINFOFUNCTION, t1553_xferinfo);
easy_setopt(curls, CURLOPT_NOPROGRESS, 1L);
- debug_config.nohex = 1;
- debug_config.tracetime = 1;
+ 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);
goto test_cleanup;
}
- curl_mprintf("Max = %ld\n", (long)info.largest);
+ curl_mprintf("Max = %zu\n", info.largest);
test_cleanup:
if(u) {
CURLUcode uc = curl_url_set(u, CURLUPART_URL, longurl, 0);
curl_mprintf("CURLUPART_URL %d bytes URL == %d (%s)\n",
- EXCESSIVE, (int)uc, curl_url_strerror(uc));
+ EXCESSIVE, uc, curl_url_strerror(uc));
uc = curl_url_set(u, CURLUPART_SCHEME, longurl, CURLU_NON_SUPPORT_SCHEME);
curl_mprintf("CURLUPART_SCHEME %d bytes scheme == %d (%s)\n",
- EXCESSIVE, (int)uc, curl_url_strerror(uc));
+ EXCESSIVE, uc, curl_url_strerror(uc));
uc = curl_url_set(u, CURLUPART_USER, longurl, 0);
curl_mprintf("CURLUPART_USER %d bytes user == %d (%s)\n",
- EXCESSIVE, (int)uc, curl_url_strerror(uc));
+ EXCESSIVE, uc, curl_url_strerror(uc));
curl_url_cleanup(u);
}
curl_msnprintf(bufp, len, "%s%s", buf[0]?" | ":"", p);
}
else
- curl_msnprintf(bufp, len, "%s[%d]", buf[0]?" | ":"", (int)rc);
+ curl_msnprintf(bufp, len, "%s[%d]", buf[0]?" | ":"", rc);
n = strlen(bufp);
bufp += n;
CURLUPart what = part2id(part);
#if 0
/* for debugging this */
- curl_mfprintf(stderr, "%s = \"%s\" [%d]\n", part, value, (int)what);
+ curl_mfprintf(stderr, "%s = \"%s\" [%d]\n", part, value, what);
#endif
if(what > CURLUPART_ZONEID)
curl_mfprintf(stderr, "UNKNOWN part '%s'\n", part);
if(rc) {
curl_mfprintf(stderr, "%s:%d Set URL %s returned %d (%s)\n",
__FILE__, __LINE__, set_url_list[i].set,
- (int)rc, curl_url_strerror(rc));
+ rc, curl_url_strerror(rc));
error++;
}
else {
rc = curl_url_get(urlp, CURLUPART_URL, &url, 0);
if(rc) {
curl_mfprintf(stderr, "%s:%d Get URL returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ __FILE__, __LINE__, rc, curl_url_strerror(rc));
error++;
}
else {
}
else if(rc != set_url_list[i].ucode) {
curl_mfprintf(stderr, "Set URL\nin: %s\nreturned %d (expected %d)\n",
- set_url_list[i].in, (int)rc, set_url_list[i].ucode);
+ set_url_list[i].in, rc, set_url_list[i].ucode);
error++;
}
curl_url_cleanup(urlp);
if(uc != setget_parts_list[i].pcode) {
curl_mfprintf(stderr,
"updateurl\nin: %s\nreturned %d (expected %d)\n",
- setget_parts_list[i].set, (int)uc,
+ setget_parts_list[i].set, uc,
setget_parts_list[i].pcode);
error++;
}
}
else if(rc != CURLUE_OK) {
curl_mfprintf(stderr, "Set parts\nin: %s\nreturned %d (expected %d)\n",
- setget_parts_list[i].in, (int)rc, 0);
+ setget_parts_list[i].in, rc, 0);
error++;
}
}
if(uc != set_parts_list[i].pcode) {
curl_mfprintf(stderr, "updateurl\nin: %s\nreturned %d (expected %d)\n",
- set_parts_list[i].set, (int)uc, set_parts_list[i].pcode);
+ set_parts_list[i].set, uc, set_parts_list[i].pcode);
error++;
}
if(!uc) {
if(rc) {
curl_mfprintf(stderr, "%s:%d Get URL returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ __FILE__, __LINE__, rc, curl_url_strerror(rc));
error++;
}
else if(checkurl(set_parts_list[i].in, url, set_parts_list[i].out)) {
}
else if(rc != set_parts_list[i].ucode) {
curl_mfprintf(stderr, "Set parts\nin: %s\nreturned %d (expected %d)\n",
- set_parts_list[i].in, (int)rc, set_parts_list[i].ucode);
+ set_parts_list[i].in, rc, set_parts_list[i].ucode);
error++;
}
curl_url_cleanup(urlp);
if(rc) {
curl_mfprintf(stderr, "%s:%d returned %d (%s). URL: '%s'\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc),
+ __FILE__, __LINE__, rc, curl_url_strerror(rc),
get_url_list[i].in);
error++;
}
}
if(rc != get_url_list[i].ucode) {
curl_mfprintf(stderr, "Get URL\nin: %s\nreturned %d (expected %d)\n",
- get_url_list[i].in, (int)rc, get_url_list[i].ucode);
+ get_url_list[i].in, rc, get_url_list[i].ucode);
error++;
}
}
get_parts_list[i].urlflags);
if(rc != get_parts_list[i].ucode) {
curl_mfprintf(stderr, "Get parts\nin: %s\nreturned %d (expected %d)\n",
- get_parts_list[i].in, (int)rc, get_parts_list[i].ucode);
+ get_parts_list[i].in, rc, get_parts_list[i].ucode);
error++;
}
else if(get_parts_list[i].ucode) {
;
else if(rc != append_list[i].ucode) {
curl_mfprintf(stderr, "Append\nin: %s\nreturned %d (expected %d)\n",
- append_list[i].in, (int)rc, append_list[i].ucode);
+ append_list[i].in, rc, append_list[i].ucode);
error++;
}
else if(append_list[i].ucode) {
rc = curl_url_get(urlp, CURLUPART_URL, &url, 0);
if(rc) {
curl_mfprintf(stderr, "%s:%d Get URL returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ __FILE__, __LINE__, rc, curl_url_strerror(rc));
error++;
}
else {
"https://[fe80::20c:29ff:fe9c:409b%25eth0]/hello.html", 0);
if(rc != CURLUE_OK) {
curl_mfprintf(stderr, "%s:%d curl_url_set returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ __FILE__, __LINE__, rc, curl_url_strerror(rc));
error++;
}
if(rc != CURLUE_OK) {
curl_mfprintf(stderr,
"%s:%d curl_url_get CURLUPART_HOST returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ __FILE__, __LINE__, rc, curl_url_strerror(rc));
error++;
}
else {
if(rc != CURLUE_OK) {
curl_mfprintf(stderr,
"%s:%d curl_url_set CURLUPART_HOST returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ __FILE__, __LINE__, rc, curl_url_strerror(rc));
error++;
}
if(rc != CURLUE_OK) {
curl_mfprintf(stderr,
"%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ __FILE__, __LINE__, rc, curl_url_strerror(rc));
error++;
}
else {
if(rc != CURLUE_OK) {
curl_mfprintf(stderr,
"%s:%d curl_url_set CURLUPART_HOST returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ __FILE__, __LINE__, rc, curl_url_strerror(rc));
error++;
}
if(rc != CURLUE_OK) {
curl_mfprintf(stderr,
"%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ __FILE__, __LINE__, rc, curl_url_strerror(rc));
error++;
}
else {
if(rc != CURLUE_OK) {
curl_mfprintf(stderr,
"%s:%d curl_url_set CURLUPART_HOST returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ __FILE__, __LINE__, rc, curl_url_strerror(rc));
error++;
}
if(rc != CURLUE_OK) {
curl_mfprintf(stderr,
"%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ __FILE__, __LINE__, rc, curl_url_strerror(rc));
error++;
}
else {
if(rc != CURLUE_OK) {
curl_mfprintf(stderr,
"%s:%d curl_url_get CURLUPART_HOST returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ __FILE__, __LINE__, rc, curl_url_strerror(rc));
error++;
}
else {
if(rc != CURLUE_OK) {
curl_mfprintf(stderr,
"%s:%d curl_url_get CURLUPART_ZONEID returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ __FILE__, __LINE__, rc, curl_url_strerror(rc));
error++;
}
else {
if(rc != CURLUE_OK) {
curl_mfprintf(stderr,
"%s:%d curl_url_set CURLUPART_ZONEID returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ __FILE__, __LINE__, rc, curl_url_strerror(rc));
error++;
}
if(rc != CURLUE_OK) {
curl_mfprintf(stderr,
"%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
- __FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
+ __FILE__, __LINE__, rc, curl_url_strerror(rc));
error++;
}
else {
rc = curl_url_get(u, CURLUPART_ZONEID, &p, 0);
if(rc != CURLUE_NO_ZONEID)
- curl_mfprintf(stderr, "unexpected return code %u on line %u\n", (int)rc,
+ curl_mfprintf(stderr, "unexpected return code %u on line %u\n", rc,
__LINE__);
curl_url_cleanup(u);
else {
curl_mfprintf(stderr,
"%s:%d Got an unexpected message from curl: %i\n",
- __FILE__, __LINE__, (int)message->msg);
+ __FILE__, __LINE__, message->msg);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
res = curl_easy_perform(curl);
if(!res)
curl_mfprintf(stderr, "failure expected, "
- "curl_easy_perform returned %ld: <%s>, <%s>\n",
- (long) res, curl_easy_strerror(res), error_buffer);
+ "curl_easy_perform returned %d: <%s>, <%s>\n",
+ res, curl_easy_strerror(res), error_buffer);
/* print the used url */
if(!curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &url_after))
memset(testbuf, 'A', MAX_INPUT_LENGTH + 1);
testbuf[MAX_INPUT_LENGTH + 1] = 0;
- curl_mprintf("string length: %d\n", (int)strlen(testbuf));
+ curl_mprintf("string length: %zu\n", strlen(testbuf));
for(o = curl_easy_option_next(NULL);
o;
global_init(CURL_GLOBAL_ALL);
- debug_config.nohex = 1;
- debug_config.tracetime = 1;
+ debug_config.nohex = TRUE;
+ debug_config.tracetime = TRUE;
easy_init(hnd);
easy_setopt(hnd, CURLOPT_URL, URL);
size_t index = 0;
size_t amount = header->amount;
do {
- curl_mprintf("- %s == %s (%u/%u)\n", header->name, header->value,
- (int)index, (int)amount);
+ curl_mprintf("- %s == %s (%zu/%zu)\n", header->name, header->value,
+ index, amount);
if(++index == amount)
break;
/* !checksrc! disable EQUALSNULL 1 */
while((header = curl_easy_nextheader(easy, type, 0, prev)) != NULL) {
- curl_mprintf(" %s == %s (%u/%u)\n", header->name, header->value,
- (int)header->index, (int)header->amount);
+ curl_mprintf(" %s == %s (%zu/%zu)\n", header->name, header->value,
+ header->index, header->amount);
prev = header;
}
}
if(CURLE_OK != code) {
curl_mfprintf(stderr, "%s:%d curl_easy_getinfo() failed, "
"with code %d (%s)\n",
- __FILE__, __LINE__, (int)code, curl_easy_strerror(code));
+ __FILE__, __LINE__, code, curl_easy_strerror(code));
ntlmcb_res = TEST_ERR_MAJOR_BAD;
return failure;
}
0x8a, 0x0
};
size_t incoming = nitems;
- curl_mfprintf(stderr, "Called CURLOPT_WRITEFUNCTION with %d bytes: ",
- (int)nitems);
+ curl_mfprintf(stderr, "Called CURLOPT_WRITEFUNCTION with %zu bytes: ",
+ nitems);
for(i = 0; i < nitems; i++)
curl_mfprintf(stderr, "%02x ", (unsigned char)buffer[i]);
curl_mfprintf(stderr, "\n");
easy_init(curl[i]);
/* specify target */
curl_msnprintf(target_url, sizeof(target_url),
- "https://localhost:%s/path/2402%04i",
- port, (int)i + 1);
+ "https://localhost:%s/path/2402%04zu",
+ port, i + 1);
target_url[sizeof(target_url) - 1] = '\0';
easy_setopt(curl[i], CURLOPT_URL, target_url);
/* go http2 */
easy_init(curl[i]);
/* specify target */
curl_msnprintf(target_url, sizeof(target_url),
- "https://localhost:%s/path/2404%04i",
- port, (int)i + 1);
+ "https://localhost:%s/path/2404%04zu",
+ port, i + 1);
target_url[sizeof(target_url) - 1] = '\0';
easy_setopt(curl[i], CURLOPT_URL, target_url);
/* go http2 */
easy_init(curl[i]);
/* specify target */
curl_msnprintf(target_url, sizeof(target_url),
- "https://localhost:%s/path/2502%04i",
- port, (int)i + 1);
+ "https://localhost:%s/path/2502%04zu",
+ port, i + 1);
target_url[sizeof(target_url) - 1] = '\0';
easy_setopt(curl[i], CURLOPT_URL, target_url);
/* go http2 */
/* wait for first connection established to see if we can share it */
easy_setopt(curl[i], CURLOPT_PIPEWAIT, 1L);
/* go verbose */
- debug_config.nohex = 1;
- debug_config.tracetime = 0;
+ debug_config.nohex = TRUE;
+ debug_config.tracetime = FALSE;
test_setopt(curl[i], CURLOPT_DEBUGDATA, &debug_config);
easy_setopt(curl[i], CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
easy_setopt(curl[i], CURLOPT_VERBOSE, 1L);
easy_setopt(curl, CURLOPT_URL, URL);
easy_setopt(curl, CURLOPT_USERAGENT, "client/test2700");
- debug_config.nohex = 1;
- debug_config.tracetime = 1;
+ debug_config.nohex = TRUE;
+ debug_config.tracetime = TRUE;
easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config);
easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
easy_setopt(curl, CURLOPT_VERBOSE, 1L);
if(results[i] != CURLE_OK) {
curl_mfprintf(stderr, "%s:%d thread[%u]: curl_global_init() failed,"
"with code %d (%s)\n", __FILE__, __LINE__,
- i, (int) results[i], curl_easy_strerror(results[i]));
+ i, results[i], curl_easy_strerror(results[i]));
test_failure = TEST_ERR_MAJOR_BAD;
}
}
if(results[i] != CURLE_OK) {
curl_mfprintf(stderr, "%s:%d thread[%u]: curl_global_init() failed,"
"with code %d (%s)\n", __FILE__, __LINE__,
- i, (int) results[i], curl_easy_strerror(results[i]));
+ i, results[i], curl_easy_strerror(results[i]));
test_failure = TEST_ERR_MAJOR_BAD;
}
}
multi_init(multi);
easy_init(curl);
- debug_config.nohex = 1;
- debug_config.tracetime = 1;
+ debug_config.nohex = TRUE;
+ debug_config.tracetime = TRUE;
res = t3033_req_test(multi, curl, URL, 0);
if(res != CURLE_OK)
mc += curl_multi_remove_handle(multi, curls);
if(mc) {
- curl_mfprintf(stderr, "%d was unexpected\n", (int)mc);
+ curl_mfprintf(stderr, "%d was unexpected\n", mc);
i = CURLE_FAILED_INIT;
}
test_setopt(curl, CURLOPT_URL, URL);
test_setopt(curl, CURLOPT_HEADER, 1L);
- debug_config.nohex = 1;
- debug_config.tracetime = 1;
+ debug_config.nohex = TRUE;
+ debug_config.tracetime = TRUE;
test_setopt(curl, CURLOPT_DEBUGDATA, &debug_config);
test_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
test_setopt(curl, CURLOPT_VERBOSE, 1L);
#include "testutil.h"
#include "memdebug.h"
-#define JAR libtest_arg2
#define THREADS 2
/* struct containing data of a thread */
if(code) {
int i = 0;
curl_mfprintf(stderr, "perform url '%s' repeat %d failed, curlcode %d\n",
- tdata->url, i, (int)code);
+ tdata->url, i, code);
}
curl_mprintf("CLEANUP\n");
int i;
struct t506_userdata user;
+ const char *jar = libtest_arg2;
+
user.text = "Pigs in space";
user.counter = 0;
curl_mprintf("CURLOPT_SHARE\n");
test_setopt(curl, CURLOPT_SHARE, share);
curl_mprintf("CURLOPT_COOKIEJAR\n");
- test_setopt(curl, CURLOPT_COOKIEJAR, JAR);
+ test_setopt(curl, CURLOPT_COOKIEJAR, jar);
curl_mprintf("CURLOPT_COOKIELIST FLUSH\n");
test_setopt(curl, CURLOPT_COOKIELIST, "FLUSH");
curl_mprintf("CURLOPT_COOKIELIST ALL\n");
test_setopt(curl, CURLOPT_COOKIELIST, "ALL");
curl_mprintf("CURLOPT_COOKIEJAR\n");
- test_setopt(curl, CURLOPT_COOKIEFILE, JAR);
+ test_setopt(curl, CURLOPT_COOKIEFILE, jar);
curl_mprintf("CURLOPT_COOKIELIST RELOAD\n");
test_setopt(curl, CURLOPT_COOKIELIST, "RELOAD");
}
curl_mprintf("loaded cookies:\n");
if(!cookies) {
- curl_mfprintf(stderr, " reloading cookies from '%s' failed\n", JAR);
+ curl_mfprintf(stderr, " reloading cookies from '%s' failed\n", jar);
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
}
curl_mprintf("SHARE_CLEANUP\n");
scode = curl_share_cleanup(share);
if(scode != CURLSHE_OK)
- curl_mfprintf(stderr, "curl_share_cleanup failed, code errno %d\n",
- (int)scode);
+ curl_mfprintf(stderr, "curl_share_cleanup failed, code errno %d\n", scode);
curl_mprintf("GLOBAL_CLEANUP\n");
curl_global_cleanup();
curl[current] = NULL;
}
if(++current < CURL_ARRAYSIZE(curl)) {
- curl_mfprintf(stderr, "Advancing to URL %d\n", (int)current);
+ 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]);
}
else {
curl_mfprintf(stderr, "%s got an unexpected message from curl: %i\n",
- t530_tag(), (int)message->msg);
+ t530_tag(), message->msg);
result = 1;
*success = 0;
}
#include "memdebug.h"
-#define WITH_PROXY "http://usingproxy.com/"
-#define WITHOUT_PROXY libtest_arg2
-
static void proxystat(CURL *curl)
{
long wasproxy;
CURL *curl;
struct curl_slist *host = NULL;
+ static const char *url_with_proxy = "http://usingproxy.com/";
+ const char *url_without_proxy = libtest_arg2;
+
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
curl_mfprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
test_setopt(curl, CURLOPT_RESOLVE, host);
test_setopt(curl, CURLOPT_PROXY, URL);
- test_setopt(curl, CURLOPT_URL, WITH_PROXY);
+ test_setopt(curl, CURLOPT_URL, url_with_proxy);
test_setopt(curl, CURLOPT_NOPROXY, "goingdirect.com");
test_setopt(curl, CURLOPT_VERBOSE, 1L);
res = curl_easy_perform(curl);
if(!res) {
proxystat(curl);
- test_setopt(curl, CURLOPT_URL, WITHOUT_PROXY);
+ test_setopt(curl, CURLOPT_URL, url_without_proxy);
res = curl_easy_perform(curl);
if(!res)
proxystat(curl);
#include "memdebug.h"
-#define PROXY libtest_arg2
-#define PROXYUSERPWD libtest_arg3
-#define HOST test_argv[4]
-
static CURL *testeh[2];
static CURLcode init(int num, CURLM *cm, const char *url, const char *userpwd,
{
CURLcode res = CURLE_OK;
+ const char *proxy = libtest_arg2;
+
res_easy_init(testeh[num]);
if(res)
goto init_failed;
if(res)
goto init_failed;
- res_easy_setopt(testeh[num], CURLOPT_PROXY, PROXY);
+ res_easy_setopt(testeh[num], CURLOPT_PROXY, proxy);
if(res)
goto init_failed;
}
}
else
- curl_mfprintf(stderr, "E: CURLMsg (%d)\n", (int)msg->msg);
+ curl_mfprintf(stderr, "E: CURLMsg (%d)\n", msg->msg);
}
res_test_timedout();
CURLcode res = CURLE_OK;
size_t i;
+ const char *proxyuserpws = libtest_arg3;
+ const char *host;
+
for(i = 0; i < CURL_ARRAYSIZE(testeh); i++)
testeh[i] = NULL;
if(test_argc < 4)
return TEST_ERR_MAJOR_BAD;
- curl_msnprintf(buffer, sizeof(buffer), "Host: %s", HOST);
+ host = test_argv[4];
+ curl_msnprintf(buffer, sizeof(buffer), "Host: %s", host);
/* now add a custom Host: header */
headers = curl_slist_append(headers, buffer);
return res;
}
- res = loop(0, cm, URL, PROXYUSERPWD, headers);
+ res = loop(0, cm, URL, proxyuserpws, headers);
if(res)
goto test_cleanup;
curl_mfprintf(stderr, "lib540: now we do the request again\n");
- res = loop(1, cm, URL, PROXYUSERPWD, headers);
+ res = loop(1, cm, URL, proxyuserpws, headers);
test_cleanup:
test_setopt(curl, CURLOPT_URL, URL);
if(testnum == 545)
- test_setopt(curl, CURLOPT_POSTFIELDSIZE, (long) sizeof(teststring));
+ test_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)sizeof(teststring));
test_setopt(curl, CURLOPT_COPYPOSTFIELDS, teststring);
#include "memdebug.h"
-#define UPLOADTHIS "this is the blurb we want to upload\n"
+static const char t547_uploadthis[] = "this is the blurb we want to upload\n";
+#define T547_DATALEN (sizeof(t547_uploadthis)-1)
static size_t t547_read_cb(char *ptr, size_t size, size_t nmemb, void *clientp)
{
}
(*counter)++; /* bump */
- if(size * nmemb >= strlen(UPLOADTHIS)) {
+ if(size * nmemb >= T547_DATALEN) {
curl_mfprintf(stderr, "READ!\n");
- strcpy(ptr, UPLOADTHIS);
- return strlen(UPLOADTHIS);
+ strcpy(ptr, t547_uploadthis);
+ return T547_DATALEN;
}
curl_mfprintf(stderr, "READ NOT FINE!\n");
return 0;
test_setopt(curl, CURLOPT_HEADER, 1L);
if(testnum == 548) {
/* set the data to POST with a mere pointer to a null-terminated string */
- test_setopt(curl, CURLOPT_POSTFIELDS, UPLOADTHIS);
+ test_setopt(curl, CURLOPT_POSTFIELDS, t547_uploadthis);
}
else {
/* 547 style, which means reading the POST data from a callback */
test_setopt(curl, CURLOPT_READDATA, &counter);
/* We CANNOT do the POST fine without setting the size (or choose
chunked)! */
- test_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)strlen(UPLOADTHIS));
+ test_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)T547_DATALEN);
}
test_setopt(curl, CURLOPT_POST, 1L);
test_setopt(curl, CURLOPT_PROXY, libtest_arg2);
size_t i;
static const char fill[] = "test data";
- debug_config.nohex = 1;
- debug_config.tracetime = 0;
+ debug_config.nohex = TRUE;
+ debug_config.tracetime = FALSE;
global_init(CURL_GLOBAL_ALL);
easy_init(curl);
test_setopt(curl, CURLOPT_POST, 1L);
/* Setup read callback */
- test_setopt(curl, CURLOPT_POSTFIELDSIZE, (long) sizeof(databuf));
+ test_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)sizeof(databuf));
test_setopt(curl, CURLOPT_READFUNCTION, t552_read_cb);
/* Write callback */
}
if(formrc)
- curl_mprintf("curl_formadd(1) = %d\n", (int)formrc);
+ curl_mprintf("curl_formadd(1) = %d\n", formrc);
/* Now add the same data with another name and make it not look like
a file upload but still using the callback */
CURLFORM_END);
if(formrc)
- curl_mprintf("curl_formadd(2) = %d\n", (int)formrc);
+ curl_mprintf("curl_formadd(2) = %d\n", formrc);
/* Fill in the filename field */
formrc = curl_formadd(&formpost,
CURLFORM_COPYCONTENTS, "postit2.c",
CURLFORM_END);
if(formrc)
- curl_mprintf("curl_formadd(3) = %d\n", (int)formrc);
+ curl_mprintf("curl_formadd(3) = %d\n", formrc);
/* Fill in a submit field too */
formrc = curl_formadd(&formpost,
CURLFORM_END);
if(formrc)
- curl_mprintf("curl_formadd(4) = %d\n", (int)formrc);
+ curl_mprintf("curl_formadd(4) = %d\n", formrc);
formrc = curl_formadd(&formpost, &lastptr,
CURLFORM_COPYNAME, "somename",
CURLFORM_BUFFER, "somefile.txt",
CURLFORM_BUFFERPTR, "blah blah",
- CURLFORM_BUFFERLENGTH, (long)9,
+ CURLFORM_BUFFERLENGTH, 9L,
CURLFORM_END);
if(formrc)
- curl_mprintf("curl_formadd(5) = %d\n", (int)formrc);
+ curl_mprintf("curl_formadd(5) = %d\n", formrc);
curl = curl_easy_init();
if(!curl) {
#include "memdebug.h"
-static const char uploadthis[] = "this is the blurb we want to upload\n";
+static const char t555_uploadthis[] = "this is the blurb we want to upload\n";
+#define T555_DATALEN (sizeof(t555_uploadthis)-1)
static size_t t555_read_cb(char *ptr, size_t size, size_t nmemb, void *clientp)
{
}
(*counter)++; /* bump */
- if(size * nmemb >= strlen(uploadthis)) {
+ if(size * nmemb >= T555_DATALEN) {
curl_mfprintf(stderr, "READ!\n");
- strcpy(ptr, uploadthis);
- return strlen(uploadthis);
+ strcpy(ptr, t555_uploadthis);
+ return T555_DATALEN;
}
curl_mfprintf(stderr, "READ NOT FINE!\n");
return 0;
easy_setopt(curl, CURLOPT_READDATA, &counter);
/* We CANNOT do the POST fine without setting the size (or choose
chunked)! */
- easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)strlen(uploadthis));
+ easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)T555_DATALEN);
easy_setopt(curl, CURLOPT_POST, 1L);
easy_setopt(curl, CURLOPT_PROXY, libtest_arg2);
#endif
#define BUFSZ 256
-#define USHORT_TESTS_ARRSZ 1 + 100
-#define SSHORT_TESTS_ARRSZ 1 + 100
-#define UINT_TESTS_ARRSZ 1 + 100
-#define SINT_TESTS_ARRSZ 1 + 100
-#define ULONG_TESTS_ARRSZ 1 + 100
-#define SLONG_TESTS_ARRSZ 1 + 100
-#define COFFT_TESTS_ARRSZ 1 + 100
struct unsshort_st {
};
-static struct unsshort_st us_test[USHORT_TESTS_ARRSZ];
-static struct sigshort_st ss_test[SSHORT_TESTS_ARRSZ];
-static struct unsint_st ui_test[UINT_TESTS_ARRSZ];
-static struct sigint_st si_test[SINT_TESTS_ARRSZ];
-static struct unslong_st ul_test[ULONG_TESTS_ARRSZ];
-static struct siglong_st sl_test[SLONG_TESTS_ARRSZ];
-static struct curloff_st co_test[COFFT_TESTS_ARRSZ];
+static struct unsshort_st us_test[1 + 100];
+static struct sigshort_st ss_test[1 + 100];
+static struct unsint_st ui_test[1 + 100];
+static struct sigint_st si_test[1 + 100];
+static struct unslong_st ul_test[1 + 100];
+static struct siglong_st sl_test[1 + 100];
+static struct curloff_st co_test[1 + 100];
static int test_unsigned_short_formatting(void)
curl_mprintf("RTP: message size %d, channel %d\n", message_size, channel);
if(message_size != coded_size) {
curl_mprintf("RTP embedded size (%d) does not match "
- "the write size (%d).\n",
- coded_size, message_size);
+ "the write size (%d).\n", coded_size, message_size);
return failure;
}
easy_setopt(c, CURLOPT_HEADER, 1L);
easy_setopt(c, CURLOPT_URL, URL);
- debug_config.nohex = 1;
- debug_config.tracetime = 1;
+ 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);
test_setopt(curl, CURLOPT_URL, URL);
test_setopt(curl, CURLOPT_WILDCARDMATCH, 1L);
test_setopt(curl, CURLOPT_FNMATCH_FUNCTION, new_fnmatch);
- test_setopt(curl, CURLOPT_TIMEOUT_MS, (long) TEST_HANG_TIMEOUT);
+ test_setopt(curl, CURLOPT_TIMEOUT_MS, (long)TEST_HANG_TIMEOUT);
res = curl_easy_perform(curl);
if(res) {
curl_mprintf(" (parsed => %o)", finfo->perm);
curl_mprintf("\n");
}
- curl_mprintf("Size: %ldB\n", (long)finfo->size);
+ curl_mprintf("Size: %" CURL_FORMAT_CURL_OFF_T "B\n", finfo->size);
if(finfo->strings.user)
curl_mprintf("User: %s\n", finfo->strings.user);
if(finfo->strings.group)
int i;
if(mention)
- curl_mfprintf(stderr, "Remove socket fd %d\n", (int) fd);
+ curl_mfprintf(stderr, "Remove socket fd %d\n", (int)fd);
for(i = 0; i < sockets->count; ++i) {
if(sockets->sockets[i] == fd) {
* To ensure we only have each file descriptor once, we remove it then add
* it again.
*/
- curl_mfprintf(stderr, "Add socket fd %d for %s\n", (int) fd, what);
+ curl_mfprintf(stderr, "Add socket fd %d for %s\n", (int)fd, what);
t582_removeFd(sockets, fd, 0);
/*
* Allocate array storage when required.
}
else {
curl_mfprintf(stderr, "Got an unexpected message from curl: %i\n",
- (int)message->msg);
+ message->msg);
result = 1;
*success = 0;
}
fclose(hd_src);
return TEST_ERR_FSTAT;
}
- curl_mfprintf(stderr, "Set to upload %d bytes\n", (int)file_info.st_size);
+ curl_mfprintf(stderr, "Set to upload %" CURL_FORMAT_CURL_OFF_T " bytes\n",
+ (curl_off_t)file_info.st_size);
res_global_init(CURL_GLOBAL_ALL);
if(res != CURLE_OK) {
curl_mfprintf(stderr, "curl_multi_remove_handle()...\n");
mres = curl_multi_remove_handle(multiHandle, curl);
if(mres) {
- curl_mfprintf(stderr, "curl_multi_remove_handle() failed, "
- "with code %d\n", (int)mres);
+ curl_mfprintf(stderr, "curl_multi_remove_handle() failed, with code %d\n",
+ mres);
res = TEST_ERR_MULTI;
}
else
if(code != CURLE_OK) {
int i = 0;
curl_mfprintf(stderr, "perform url '%s' repeat %d failed, curlcode %d\n",
- tdata->url, i, (int)code);
+ tdata->url, i, code);
}
curl_mprintf("CLEANUP\n");
scode = curl_share_cleanup(share);
if(scode != CURLSHE_OK)
curl_mfprintf(stderr, "curl_share_cleanup failed, code errno %d\n",
- (int)scode);
+ scode);
curl_mprintf("GLOBAL_CLEANUP\n");
curl_global_cleanup();
CURLFORM_CONTENTHEADER, headers,
CURLFORM_END);
if(formrc) {
- curl_mprintf("curl_formadd(1) = %d\n", (int) formrc);
+ curl_mprintf("curl_formadd(1) = %d\n", formrc);
goto test_cleanup;
}
CURLFORM_END);
if(formrc) {
- curl_mprintf("curl_formadd(2) = %d\n", (int) formrc);
+ curl_mprintf("curl_formadd(2) = %d\n", formrc);
goto test_cleanup;
}
CURLFORM_END);
if(formrc) {
- curl_mprintf("curl_formadd(3) = %d\n", (int) formrc);
+ curl_mprintf("curl_formadd(3) = %d\n", formrc);
goto test_cleanup;
}
CURLFORM_FILECONTENT, libtest_arg2,
CURLFORM_END);
if(formrc) {
- curl_mprintf("curl_formadd(4) = %d\n", (int) formrc);
+ curl_mprintf("curl_formadd(4) = %d\n", formrc);
goto test_cleanup;
}
curl_formget(formpost, (void *) &formlength, count_chars);
/* Include length in data for external check. */
- curl_msnprintf(flbuf, sizeof(flbuf), "%lu", (unsigned long) formlength);
+ curl_msnprintf(flbuf, sizeof(flbuf), "%zu", formlength);
formrc = curl_formadd(&formpost,
&lastptr,
CURLFORM_END);
if(formrc) {
- curl_mprintf("curl_formadd(5) = %d\n", (int) formrc);
+ curl_mprintf("curl_formadd(5) = %d\n", formrc);
goto test_cleanup;
}
CURLFORM_END);
if(formrc) {
- curl_mprintf("curl_formadd(6) = %d\n", (int) formrc);
+ curl_mprintf("curl_formadd(6) = %d\n", formrc);
goto test_cleanup;
}
CURLFORM_COPYCONTENTS, testbuf,
CURLFORM_END);
if(formrc)
- curl_mprintf("curl_formadd(1) = %d\n", (int) formrc);
+ curl_mprintf("curl_formadd(1) = %d\n", formrc);
curl = curl_easy_init();
res = curl_mime_name(part, testname);
if(res != CURLE_OK) {
curl_mfprintf(stderr,
- "Something went wrong when building the mime structure: %d\n",
- res);
+ "Something went wrong when building the mime structure: %d\n",
+ res);
goto test_cleanup;
}
CURLFORM_CONTENTLEN, (curl_off_t) 2,
CURLFORM_END);
if(formrc) {
- curl_mfprintf(stderr, "curl_formadd() = %d\n", (int) formrc);
+ curl_mfprintf(stderr, "curl_formadd() = %d\n", formrc);
goto test_cleanup;
}
}
else if(ec) {
curl_mfprintf(stderr, "curl_easy_send() failed, with code %d (%s)\n",
- (int)ec, curl_easy_strerror(ec));
+ ec, curl_easy_strerror(ec));
res = ec;
goto test_cleanup;
}
}
else if(ec) {
curl_mfprintf(stderr, "curl_easy_recv() failed, with code %d (%s)\n",
- (int)ec, curl_easy_strerror(ec));
+ ec, curl_easy_strerror(ec));
res = ec;
goto test_cleanup;
}
start_test_timing();
- debug_config.nohex = 1;
- debug_config.tracetime = 1;
+ debug_config.nohex = TRUE;
+ debug_config.tracetime = TRUE;
curl_global_init(CURL_GLOBAL_DEFAULT);
void debug_dump(const char *timebuf, const char *text,
FILE *stream, const unsigned char *ptr,
- size_t size, int nohex)
+ size_t size, bool nohex)
{
size_t i;
size_t c;
if(!traced_data) {
if(!newl)
log_line_start(output, idsbuf, type);
- curl_mfprintf(output, "[%ld bytes data]\n", (long)size);
+ curl_mfprintf(output, "[%zu bytes data]\n", size);
newl = 0;
traced_data = 1;
}
void debug_dump(const char *timebuf, const char *text,
FILE *stream, const unsigned char *ptr,
- size_t size, int nohex);
+ size_t size, bool nohex);
struct libtest_trace_cfg {
- int tracetime; /* 0 represents FALSE, anything else TRUE */
- int nohex; /* 0 represents FALSE, anything else TRUE */
+ bool tracetime;
+ bool nohex;
};
extern struct libtest_trace_cfg debug_config;
printf(" ");
if(output) {
- printf("%ld.%ld[%d]", (long)t->key.tv_sec,
- (long)t->key.tv_usec, i);
+ printf("%ld.%ld[%d]", (long)t->key.tv_sec, (long)t->key.tv_usec, i);
}
for(count = 0, node = t->samen; node != t; node = node->samen, count++)
projects / thirdparty / curl.git / commitdiff
