char buffer[256];
CURLcode result = curl_ws_recv(curl, buffer, sizeof(buffer), &rlen, &meta);
if(result) {
- curl_mfprintf(stderr, "ws: curl_ws_recv returned %u, received %zd\n",
+ curl_mfprintf(stderr, "ws: curl_ws_recv returned %u, received %zu\n",
result, rlen);
return result;
}
if(!(meta->flags & CURLWS_PONG)) {
- curl_mfprintf(stderr, "recv_pong: wrong frame, got %zd bytes rflags %x\n",
+ curl_mfprintf(stderr, "recv_pong: wrong frame, got %zu bytes rflags %x\n",
rlen, meta->flags);
return CURLE_RECV_ERROR;
}
test_setopt(curl, CURLOPT_VERBOSE, 1L);
test_setopt(curl, CURLOPT_RESUME_FROM, (p->flags & F_RESUME) ? 3L : 0L);
test_setopt(curl, CURLOPT_RANGE, !(p->flags & F_RESUME) ?
- "3-1000000": (char *) NULL);
+ "3-1000000": (char *)NULL);
test_setopt(curl, CURLOPT_FAILONERROR, (p->flags & F_FAIL) ? 1L : 0L);
hasbody = 0;
res = curl_easy_perform(curl);
if(res != p->result) {
- curl_mprintf("%zd: bad error code (%d): resume=%s, fail=%s, http416=%s, "
+ curl_mprintf("%zu: bad error code (%d): resume=%s, fail=%s, http416=%s, "
"content-range=%s, expected=%d\n", num, res,
(p->flags & F_RESUME) ? "yes": "no",
(p->flags & F_FAIL) ? "yes": "no",
if(st->http_status >= 200 && st->http_status < 300) {
result = curl_easy_getinfo(st->easy, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
&clen);
- curl_mfprintf(stderr, "header_callback, info Content-Length: %ld, %d\n",
- (long)clen, result);
+ curl_mfprintf(stderr, "header_callback, info Content-Length: "
+ "%" CURL_FORMAT_CURL_OFF_T ", %d\n", clen, result);
if(result) {
st->result = result;
return CURLE_WRITE_ERROR;
size_t WriteOutput(char *ptr, size_t size, size_t nmemb, void *stream);
size_t WriteHeader(char *ptr, size_t size, size_t nmemb, void *stream);
-static unsigned long realHeaderSize = 0;
+static size_t realHeaderSize = 0;
static CURLcode test_lib1509(const char *URL)
{
}
curl_mprintf("header length is ........: %ld\n", headerSize);
- curl_mprintf("header length should be..: %lu\n", realHeaderSize);
+ curl_mprintf("header length should be..: %zu\n", realHeaderSize);
test_cleanup:
(void)ptr;
(void)stream;
- realHeaderSize += curlx_uztoul(size * nmemb);
+ realHeaderSize += size * nmemb;
return nmemb * size;
}
#define KN(a) a, #a
-static int t1541_geterr(const char *name, CURLcode val, int lineno)
+static void t1541_geterr(const char *name, CURLcode val, int lineno)
{
curl_mprintf("CURLINFO_%s returned %d, \"%s\" on line %d\n",
name, val, curl_easy_strerror(val), lineno);
- return (int)val;
}
static void report_time(const char *key, const char *where, curl_off_t time,
typedef struct
{
- char *buf;
+ const char *buf;
size_t len;
} put_buffer;
easy_setopt(curl, CURLOPT_UPLOAD, 1L);
easy_setopt(curl, CURLOPT_HEADER, 1L);
easy_setopt(curl, CURLOPT_READFUNCTION, put_callback);
- pbuf.buf = (char *)CURL_UNCONST(testput);
+ pbuf.buf = testput;
pbuf.len = strlen(testput);
easy_setopt(curl, CURLOPT_READDATA, &pbuf);
easy_setopt(curl, CURLOPT_INFILESIZE, (long)strlen(testput));
else if(sock != ntlm_sockets[idx]) {
/* An easy handle with a socket different to previously
tracked one, log and fail right away. Known bug #37. */
- curl_mfprintf(stderr, "Handle %d started on socket %d and moved to %d\n",
- curlx_sztosi(idx), (int)ntlm_sockets[idx], (int)sock);
+ curl_mfprintf(stderr, "Handle %zd started on socket %" FMT_SOCKET_T
+ " and moved to %" FMT_SOCKET_T "\n",
+ idx, ntlm_sockets[idx], sock);
ntlmcb_res = TEST_ERR_MAJOR_BAD;
return failure;
}
if(result)
return result;
- curl_mfprintf(stderr, "recv_any: got %u bytes rflags %x\n", (int)rlen,
+ curl_mfprintf(stderr, "recv_any: got %zu bytes rflags %x\n", rlen,
meta->flags);
return CURLE_OK;
}
/* calling curl_multi_waitfds() on multi handle with added easy handle. */
easy_init(easy);
- if(set_easy((char *)CURL_UNCONST("http://example.com"), easy,
- TEST_USE_HTTP1) != CURLE_OK)
+ if(set_easy("http://example.com", easy, TEST_USE_HTTP1) != CURLE_OK)
goto test_cleanup;
multi_add_handle(multi, easy);
for(i = 0; i < PER_THREAD_SIZE; i++) {
CURL *curl = curl_easy_init();
if(curl) {
- curl_easy_setopt(curl, CURLOPT_URL, (char *)CURL_UNCONST(ctx->URL));
+ curl_easy_setopt(curl, CURLOPT_URL, ctx->URL);
/* use the share object */
curl_easy_setopt(curl, CURLOPT_SHARE, ctx->share);
locknum = 2;
break;
default:
- curl_mfprintf(stderr, "lock: no such data: %d\n", (int)data);
+ curl_mfprintf(stderr, "lock: no such data: %d\n", data);
return;
}
locknum = 2;
break;
default:
- curl_mfprintf(stderr, "unlock: no such data: %d\n", (int)data);
+ curl_mfprintf(stderr, "unlock: no such data: %d\n", data);
return;
}
int i;
if(mention)
- curl_mfprintf(stderr, "%s remove socket fd %d\n", t530_tag(), (int)fd);
+ curl_mfprintf(stderr, "%s remove socket fd %" FMT_SOCKET_T "\n",
+ t530_tag(), 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, "%s add socket fd %d for %s\n",
- t530_tag(), (int)fd, what);
+ curl_mfprintf(stderr, "%s add socket fd %" FMT_SOCKET_T " for %s\n",
+ t530_tag(), fd, what);
t530_removeFd(sockets, fd, 0);
/*
* Allocate array storage when required.
return result;
}
-static int t530_getMicroSecondTimeout(struct curltime *timeout)
+static ssize_t t530_getMicroSecondTimeout(struct curltime *timeout)
{
struct curltime now;
ssize_t result;
if(result < 0)
result = 0;
- return curlx_sztosi(result);
+ return result;
}
/**
}
}
-static int socket_action(CURLM *curl, curl_socket_t s, int evBitmask,
- const char *info)
+static CURLMcode socket_action(CURLM *curl, curl_socket_t s, int evBitmask,
+ const char *info)
{
int numhandles = 0;
CURLMcode result = curl_multi_socket_action(curl, s, evBitmask, &numhandles);
curl_mfprintf(stderr, "%s Curl error on %s (%i) %s\n",
t530_tag(), info, result, curl_multi_strerror(result));
}
- return (int)result;
+ return result;
}
/**
* Invoke curl when a file descriptor is set.
*/
-static int t530_checkFdSet(CURLM *curl, struct t530_Sockets *sockets,
- fd_set *fdset, int evBitmask, const char *name)
+static CURLMcode t530_checkFdSet(CURLM *curl, struct t530_Sockets *sockets,
+ fd_set *fdset, int evBitmask,
+ const char *name)
{
int i;
- int result = 0;
+ 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);
t530_updateFdSet(&sockets.write, &writeSet, &maxFd);
if(timeout.tv_sec != (time_t)-1) {
- int usTimeout = t530_getMicroSecondTimeout(&timeout);
+ int usTimeout = curlx_sztosi(t530_getMicroSecondTimeout(&timeout));
tv.tv_sec = usTimeout / 1000000;
tv.tv_usec = usTimeout % 1000000;
}
if(msg->msg == CURLMSG_DONE) {
size_t i;
CURL *e = msg->easy_handle;
- curl_mfprintf(stderr, "R: %d - %s\n", (int)msg->data.result,
+ 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);
static size_t t552_write_cb(char *ptr, size_t size, size_t nmemb, void *stream)
{
- int amount = curlx_uztosi(size * nmemb);
- curl_mprintf("%.*s", amount, (char *)ptr);
+ size_t amount = size * nmemb;
+ curl_mprintf("%.*s", (int)amount, ptr);
(void)stream;
- return size * nmemb;
+ return amount;
}
static curlioerr ioctl_callback(CURL *handle, int cmd, void *clientp)
test_setopt(curl, CURLOPT_RTSP_REQUEST, CURL_RTSPREQ_SETUP);
res = curl_easy_perform(curl);
- if(res != (int)CURLE_BAD_FUNCTION_ARGUMENT) {
+ if(res != CURLE_BAD_FUNCTION_ARGUMENT) {
curl_mfprintf(stderr, "This should have failed. "
"Cannot setup without a Transport: header");
res = TEST_ERR_MAJOR_BAD;
stream_uri = NULL;
res = curl_easy_perform(curl);
- if(res != (int)CURLE_RTSP_CSEQ_ERROR) {
+ if(res != CURLE_RTSP_CSEQ_ERROR) {
curl_mfprintf(stderr, "Failed to detect CSeq mismatch");
res = TEST_ERR_MAJOR_BAD;
goto test_cleanup;
static int rtp_packet_count = 0;
-static size_t rtp_write(char *ptr, size_t size, size_t nmemb, void *stream)
+static size_t rtp_write(char *data, size_t size, size_t nmemb, void *stream)
{
static const char *RTP_DATA = "$_1234\n\0Rsdf";
- char *data = (char *)ptr;
int channel = RTP_PKT_CHANNEL(data);
int message_size;
int coded_size = RTP_PKT_LENGTH(data);
int i;
if(mention)
- curl_mfprintf(stderr, "Remove socket fd %d\n", (int)fd);
+ curl_mfprintf(stderr, "Remove socket fd %" FMT_SOCKET_T "\n", 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 %" FMT_SOCKET_T " for %s\n", fd, what);
t582_removeFd(sockets, fd, 0);
/*
* Allocate array storage when required.
return result;
}
-static int t582_getMicroSecondTimeout(struct curltime *timeout)
+static ssize_t t582_getMicroSecondTimeout(struct curltime *timeout)
{
struct curltime now;
ssize_t result;
if(result < 0)
result = 0;
- return curlx_sztosi(result);
+ return result;
}
/**
t582_updateFdSet(&sockets.write, &writeSet, &maxFd);
if(timeout.tv_sec != (time_t)-1) {
- int usTimeout = t582_getMicroSecondTimeout(&timeout);
+ int usTimeout = curlx_sztosi(t582_getMicroSecondTimeout(&timeout));
tv.tv_sec = usTimeout / 1000000;
tv.tv_usec = usTimeout % 1000000;
}
what = "ssl_session";
break;
default:
- curl_mfprintf(stderr, "lock: no such data: %d\n", (int)data);
+ curl_mfprintf(stderr, "lock: no such data: %d\n", data);
return;
}
curl_mprintf("lock: %-6s [%s]: %d\n", what, user->text, user->counter);
what = "ssl_session";
break;
default:
- curl_mfprintf(stderr, "unlock: no such data: %d\n", (int)data);
+ curl_mfprintf(stderr, "unlock: no such data: %d\n", data);
return;
}
curl_mprintf("unlock: %-6s [%s]: %d\n", what, user->text, user->counter);
return 1; /* we return 1 byte at a time! */
}
- return 0; /* no more data left to deliver */
+ return 0; /* no more data left to deliver */
}
static CURLcode t643_test_once(const char *URL, bool oldstyle)
void *conv_to_network_cb = NULL;
void *conv_from_utf8_cb = NULL;
void *interleavecb = NULL;
- char *stringpointerextra = (char *)CURL_UNCONST("moooo");
+ const char *stringpointerextra = "moooo";
struct curl_slist *slist = NULL;
struct curl_httppost *httppost = NULL;
curl_mime *mimepost = NULL;