curl/curl
1
1
Fork 0
mirror of https://github.com/curl/curl.git synced 2025-09-12 07:02:41 +03:00
Code Issues Packages Projects Releases Wiki Activity

lib: use FMT_ as prefix instead of CURL_FORMAT_

Browse Source 
For printf format defines used internally. Makes the code slighly
easier to read.

Closes #14764
This commit is contained in:
Daniel Stenberg 2024-09-03 00:04:23 +02:00
parent a2bcec0ee0
commit 4ff04615a0
No known key found for this signature in database
GPG Key ID: 5CC908FDB71E12C2
40 changed files with 357 additions and 395 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lib/cf-h1-proxy.c
View File

@ -489,8 +489,7 @@ static CURLcode recv_CONNECT_resp(struct Curl_cfilter *cf,
ts->keepon = KEEPON_IGNORE; ts->keepon = KEEPON_IGNORE;
if(ts->cl) { if(ts->cl) {
infof(data, "Ignore %" CURL_FORMAT_CURL_OFF_T infof(data, "Ignore %" FMT_OFF_T " bytes of response-body", ts->cl);
" bytes of response-body", ts->cl);
} }
else if(ts->chunked_encoding) { else if(ts->chunked_encoding) {
infof(data, "Ignore chunked response-body"); infof(data, "Ignore chunked response-body");

53
lib/cf-socket.c
View File

@ -183,7 +183,7 @@ tcpkeepalive(struct Curl_easy *data,
if(setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, if(setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE,
(void *)&optval, sizeof(optval)) < 0) { (void *)&optval, sizeof(optval)) < 0) {
infof(data, "Failed to set SO_KEEPALIVE on fd " infof(data, "Failed to set SO_KEEPALIVE on fd "
"%" CURL_FORMAT_SOCKET_T ": errno %d", "%" FMT_SOCKET_T ": errno %d",
sockfd, SOCKERRNO); sockfd, SOCKERRNO);
} }
else { else {
@ -195,7 +195,7 @@ tcpkeepalive(struct Curl_easy *data,
if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE, if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE,
(const char *)&optval, sizeof(optval)) < 0) { (const char *)&optval, sizeof(optval)) < 0) {
infof(data, "Failed to set TCP_KEEPIDLE on fd " infof(data, "Failed to set TCP_KEEPIDLE on fd "
"%" CURL_FORMAT_SOCKET_T ": errno %d", "%" FMT_SOCKET_T ": errno %d",
sockfd, SOCKERRNO); sockfd, SOCKERRNO);
} }
optval = curlx_sltosi(data->set.tcp_keepintvl); optval = curlx_sltosi(data->set.tcp_keepintvl);
@ -203,14 +203,14 @@ tcpkeepalive(struct Curl_easy *data,
if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPINTVL, if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPINTVL,
(const char *)&optval, sizeof(optval)) < 0) { (const char *)&optval, sizeof(optval)) < 0) {
infof(data, "Failed to set TCP_KEEPINTVL on fd " infof(data, "Failed to set TCP_KEEPINTVL on fd "
"%" CURL_FORMAT_SOCKET_T ": errno %d", "%" FMT_SOCKET_T ": errno %d",
sockfd, SOCKERRNO); sockfd, SOCKERRNO);
} }
optval = curlx_sltosi(data->set.tcp_keepcnt); optval = curlx_sltosi(data->set.tcp_keepcnt);
if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPCNT, if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPCNT,
(const char *)&optval, sizeof(optval)) < 0) { (const char *)&optval, sizeof(optval)) < 0) {
infof(data, "Failed to set TCP_KEEPCNT on fd " infof(data, "Failed to set TCP_KEEPCNT on fd "
"%" CURL_FORMAT_SOCKET_T ": errno %d", "%" FMT_SOCKET_T ": errno %d",
sockfd, SOCKERRNO); sockfd, SOCKERRNO);
} }
#else /* Windows < 10.0.16299 */ #else /* Windows < 10.0.16299 */
@ -226,8 +226,7 @@ tcpkeepalive(struct Curl_easy *data,
if(WSAIoctl(sockfd, SIO_KEEPALIVE_VALS, (LPVOID) &vals, sizeof(vals), if(WSAIoctl(sockfd, SIO_KEEPALIVE_VALS, (LPVOID) &vals, sizeof(vals),
NULL, 0, &dummy, NULL, NULL) != 0) { NULL, 0, &dummy, NULL, NULL) != 0) {
infof(data, "Failed to set SIO_KEEPALIVE_VALS on fd " infof(data, "Failed to set SIO_KEEPALIVE_VALS on fd "
"%" CURL_FORMAT_SOCKET_T ": errno %d", "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);
sockfd, SOCKERRNO);
} }
#endif #endif
#else /* !Windows */ #else /* !Windows */
@ -237,7 +236,7 @@ tcpkeepalive(struct Curl_easy *data,
if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE, if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE,
(void *)&optval, sizeof(optval)) < 0) { (void *)&optval, sizeof(optval)) < 0) {
infof(data, "Failed to set TCP_KEEPIDLE on fd " infof(data, "Failed to set TCP_KEEPIDLE on fd "
"%" CURL_FORMAT_SOCKET_T ": errno %d", "%" FMT_SOCKET_T ": errno %d",
sockfd, SOCKERRNO); sockfd, SOCKERRNO);
} }
#elif defined(TCP_KEEPALIVE) #elif defined(TCP_KEEPALIVE)
@ -247,7 +246,7 @@ tcpkeepalive(struct Curl_easy *data,
if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPALIVE, if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPALIVE,
(void *)&optval, sizeof(optval)) < 0) { (void *)&optval, sizeof(optval)) < 0) {
infof(data, "Failed to set TCP_KEEPALIVE on fd " infof(data, "Failed to set TCP_KEEPALIVE on fd "
"%" CURL_FORMAT_SOCKET_T ": errno %d", "%" FMT_SOCKET_T ": errno %d",
sockfd, SOCKERRNO); sockfd, SOCKERRNO);
} }
#elif defined(TCP_KEEPALIVE_THRESHOLD) #elif defined(TCP_KEEPALIVE_THRESHOLD)
@ -257,7 +256,7 @@ tcpkeepalive(struct Curl_easy *data,
if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD, if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD,
(void *)&optval, sizeof(optval)) < 0) { (void *)&optval, sizeof(optval)) < 0) {
infof(data, "Failed to set TCP_KEEPALIVE_THRESHOLD on fd " infof(data, "Failed to set TCP_KEEPALIVE_THRESHOLD on fd "
"%" CURL_FORMAT_SOCKET_T ": errno %d", "%" FMT_SOCKET_T ": errno %d",
sockfd, SOCKERRNO); sockfd, SOCKERRNO);
} }
#endif #endif
@ -267,7 +266,7 @@ tcpkeepalive(struct Curl_easy *data,
if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPINTVL, if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPINTVL,
(void *)&optval, sizeof(optval)) < 0) { (void *)&optval, sizeof(optval)) < 0) {
infof(data, "Failed to set TCP_KEEPINTVL on fd " infof(data, "Failed to set TCP_KEEPINTVL on fd "
"%" CURL_FORMAT_SOCKET_T ": errno %d", "%" FMT_SOCKET_T ": errno %d",
sockfd, SOCKERRNO); sockfd, SOCKERRNO);
} }
#elif defined(TCP_KEEPALIVE_ABORT_THRESHOLD) #elif defined(TCP_KEEPALIVE_ABORT_THRESHOLD)
@ -288,8 +287,7 @@ tcpkeepalive(struct Curl_easy *data,
if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPALIVE_ABORT_THRESHOLD, if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPALIVE_ABORT_THRESHOLD,
(void *)&optval, sizeof(optval)) < 0) { (void *)&optval, sizeof(optval)) < 0) {
infof(data, "Failed to set TCP_KEEPALIVE_ABORT_THRESHOLD on fd " infof(data, "Failed to set TCP_KEEPALIVE_ABORT_THRESHOLD on fd "
"%" CURL_FORMAT_SOCKET_T ": errno %d", "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);
sockfd, SOCKERRNO);
} }
#endif #endif
#ifdef TCP_KEEPCNT #ifdef TCP_KEEPCNT
@ -297,8 +295,7 @@ tcpkeepalive(struct Curl_easy *data,
if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPCNT, if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPCNT,
(void *)&optval, sizeof(optval)) < 0) { (void *)&optval, sizeof(optval)) < 0) {
infof(data, "Failed to set TCP_KEEPCNT on fd " infof(data, "Failed to set TCP_KEEPCNT on fd "
"%" CURL_FORMAT_SOCKET_T ": errno %d", "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);
sockfd, SOCKERRNO);
} }
#endif #endif
#endif #endif
@ -1001,8 +998,7 @@ static void cf_socket_close(struct Curl_cfilter *cf, struct Curl_easy *data)
struct cf_socket_ctx *ctx = cf->ctx; struct cf_socket_ctx *ctx = cf->ctx;
if(ctx && CURL_SOCKET_BAD != ctx->sock) { if(ctx && CURL_SOCKET_BAD != ctx->sock) {
CURL_TRC_CF(data, cf, "cf_socket_close(%" CURL_FORMAT_SOCKET_T CURL_TRC_CF(data, cf, "cf_socket_close(%" FMT_SOCKET_T ")", ctx->sock);
")", ctx->sock);
if(ctx->sock == cf->conn->sock[cf->sockindex]) if(ctx->sock == cf->conn->sock[cf->sockindex])
cf->conn->sock[cf->sockindex] = CURL_SOCKET_BAD; cf->conn->sock[cf->sockindex] = CURL_SOCKET_BAD;
socket_close(data, cf->conn, !ctx->accepted, ctx->sock); socket_close(data, cf->conn, !ctx->accepted, ctx->sock);
@ -1024,8 +1020,7 @@ static CURLcode cf_socket_shutdown(struct Curl_cfilter *cf,
if(cf->connected) { if(cf->connected) {
struct cf_socket_ctx *ctx = cf->ctx; struct cf_socket_ctx *ctx = cf->ctx;
CURL_TRC_CF(data, cf, "cf_socket_shutdown(%" CURL_FORMAT_SOCKET_T CURL_TRC_CF(data, cf, "cf_socket_shutdown(%" FMT_SOCKET_T ")", ctx->sock);
")", ctx->sock);
/* On TCP, and when the socket looks well and non-blocking mode /* On TCP, and when the socket looks well and non-blocking mode
* can be enabled, receive dangling bytes before close to avoid * can be enabled, receive dangling bytes before close to avoid
* entering RST states unnecessarily. */ * entering RST states unnecessarily. */
@ -1235,7 +1230,7 @@ out:
ctx->connected_at = Curl_now(); ctx->connected_at = Curl_now();
cf->connected = TRUE; cf->connected = TRUE;
} }
CURL_TRC_CF(data, cf, "cf_socket_open() -> %d, fd=%" CURL_FORMAT_SOCKET_T, CURL_TRC_CF(data, cf, "cf_socket_open() -> %d, fd=%" FMT_SOCKET_T,
result, ctx->sock); result, ctx->sock);
return result; return result;
} }
@ -1277,8 +1272,8 @@ static int do_connect(struct Curl_cfilter *cf, struct Curl_easy *data,
#elif defined(TCP_FASTOPEN_CONNECT) /* Linux >= 4.11 */ #elif defined(TCP_FASTOPEN_CONNECT) /* Linux >= 4.11 */
if(setsockopt(ctx->sock, IPPROTO_TCP, TCP_FASTOPEN_CONNECT, if(setsockopt(ctx->sock, IPPROTO_TCP, TCP_FASTOPEN_CONNECT,
(void *)&optval, sizeof(optval)) < 0) (void *)&optval, sizeof(optval)) < 0)
infof(data, "Failed to enable TCP Fast Open on fd %" infof(data, "Failed to enable TCP Fast Open on fd %" FMT_SOCKET_T,
CURL_FORMAT_SOCKET_T, ctx->sock); ctx->sock);
rc = connect(ctx->sock, &ctx->addr.sa_addr, ctx->addr.addrlen); rc = connect(ctx->sock, &ctx->addr.sa_addr, ctx->addr.addrlen);
#elif defined(MSG_FASTOPEN) /* old Linux */ #elif defined(MSG_FASTOPEN) /* old Linux */
@ -1416,12 +1411,12 @@ static void cf_socket_adjust_pollset(struct Curl_cfilter *cf,
if(!cf->connected) { if(!cf->connected) {
Curl_pollset_set_out_only(data, ps, ctx->sock); Curl_pollset_set_out_only(data, ps, ctx->sock);
CURL_TRC_CF(data, cf, "adjust_pollset, !connected, POLLOUT fd=%" CURL_TRC_CF(data, cf, "adjust_pollset, !connected, POLLOUT fd=%"
CURL_FORMAT_SOCKET_T, ctx->sock); FMT_SOCKET_T, ctx->sock);
} }
else if(!ctx->active) { else if(!ctx->active) {
Curl_pollset_add_in(data, ps, ctx->sock); Curl_pollset_add_in(data, ps, ctx->sock);
CURL_TRC_CF(data, cf, "adjust_pollset, !active, POLLIN fd=%" CURL_TRC_CF(data, cf, "adjust_pollset, !active, POLLIN fd=%"
CURL_FORMAT_SOCKET_T, ctx->sock); FMT_SOCKET_T, ctx->sock);
} }
} }
} }
@ -1825,7 +1820,7 @@ static CURLcode cf_udp_setup_quic(struct Curl_cfilter *cf,
} }
ctx->sock_connected = TRUE; ctx->sock_connected = TRUE;
set_local_ip(cf, data); set_local_ip(cf, data);
CURL_TRC_CF(data, cf, "%s socket %" CURL_FORMAT_SOCKET_T CURL_TRC_CF(data, cf, "%s socket %" FMT_SOCKET_T
" connected: [%s:%d] -> [%s:%d]", " connected: [%s:%d] -> [%s:%d]",
(ctx->transport == TRNSPRT_QUIC)? "QUIC" : "UDP", (ctx->transport == TRNSPRT_QUIC)? "QUIC" : "UDP",
ctx->sock, ctx->ip.local_ip, ctx->ip.local_port, ctx->sock, ctx->ip.local_ip, ctx->ip.local_port,
@ -1890,12 +1885,12 @@ static CURLcode cf_udp_connect(struct Curl_cfilter *cf,
if(result) if(result)
goto out; goto out;
CURL_TRC_CF(data, cf, "cf_udp_connect(), opened socket=%" CURL_TRC_CF(data, cf, "cf_udp_connect(), opened socket=%"
CURL_FORMAT_SOCKET_T " (%s:%d)", FMT_SOCKET_T " (%s:%d)",
ctx->sock, ctx->ip.local_ip, ctx->ip.local_port); ctx->sock, ctx->ip.local_ip, ctx->ip.local_port);
} }
else { else {
CURL_TRC_CF(data, cf, "cf_udp_connect(), opened socket=%" CURL_TRC_CF(data, cf, "cf_udp_connect(), opened socket=%"
CURL_FORMAT_SOCKET_T " (unconnected)", ctx->sock); FMT_SOCKET_T " (unconnected)", ctx->sock);
} }
*done = TRUE; *done = TRUE;
cf->connected = TRUE; cf->connected = TRUE;
@ -2070,8 +2065,8 @@ CURLcode Curl_conn_tcp_listen_set(struct Curl_easy *data,
ctx->active = TRUE; ctx->active = TRUE;
ctx->connected_at = Curl_now(); ctx->connected_at = Curl_now();
cf->connected = TRUE; cf->connected = TRUE;
CURL_TRC_CF(data, cf, "Curl_conn_tcp_listen_set(%" CURL_TRC_CF(data, cf, "Curl_conn_tcp_listen_set(%" FMT_SOCKET_T ")",
CURL_FORMAT_SOCKET_T ")", ctx->sock); ctx->sock);
out: out:
if(result) { if(result) {
@ -2135,7 +2130,7 @@ CURLcode Curl_conn_tcp_accepted_set(struct Curl_easy *data,
ctx->accepted = TRUE; ctx->accepted = TRUE;
ctx->connected_at = Curl_now(); ctx->connected_at = Curl_now();
cf->connected = TRUE; cf->connected = TRUE;
CURL_TRC_CF(data, cf, "accepted_set(sock=%" CURL_FORMAT_SOCKET_T CURL_TRC_CF(data, cf, "accepted_set(sock=%" FMT_SOCKET_T
", remote=%s port=%d)", ", remote=%s port=%d)",
ctx->sock, ctx->ip.remote_ip, ctx->ip.remote_port); ctx->sock, ctx->ip.remote_ip, ctx->ip.remote_port);

41
lib/conncache.c
View File

@ -325,7 +325,7 @@ int Curl_cpool_check_limits(struct Curl_easy *data,
break; break;
/* disconnect the old conn and continue */ /* disconnect the old conn and continue */
DEBUGF(infof(data, "Discarding connection #%" DEBUGF(infof(data, "Discarding connection #%"
CURL_FORMAT_CURL_OFF_T " from %zu to reach destination " FMT_OFF_T " from %zu to reach destination "
"limit of %zu", oldest_idle->connection_id, "limit of %zu", oldest_idle->connection_id,
Curl_llist_count(&bundle->conns), dest_limit)); Curl_llist_count(&bundle->conns), dest_limit));
Curl_cpool_disconnect(data, oldest_idle, FALSE); Curl_cpool_disconnect(data, oldest_idle, FALSE);
@ -343,7 +343,7 @@ int Curl_cpool_check_limits(struct Curl_easy *data,
break; break;
/* disconnect the old conn and continue */ /* disconnect the old conn and continue */
DEBUGF(infof(data, "Discarding connection #%" DEBUGF(infof(data, "Discarding connection #%"
CURL_FORMAT_CURL_OFF_T " from %zu to reach total " FMT_OFF_T " from %zu to reach total "
"limit of %zu", "limit of %zu",
oldest_idle->connection_id, cpool->num_conn, total_limit)); oldest_idle->connection_id, cpool->num_conn, total_limit));
Curl_cpool_disconnect(data, oldest_idle, FALSE); Curl_cpool_disconnect(data, oldest_idle, FALSE);
@ -384,7 +384,7 @@ CURLcode Curl_cpool_add_conn(struct Curl_easy *data,
cpool_bundle_add(bundle, conn); cpool_bundle_add(bundle, conn);
conn->connection_id = cpool->next_connection_id++; conn->connection_id = cpool->next_connection_id++;
cpool->num_conn++; cpool->num_conn++;
DEBUGF(infof(data, "Added connection %" CURL_FORMAT_CURL_OFF_T ". " DEBUGF(infof(data, "Added connection %" FMT_OFF_T ". "
"The cache now contains %zu members", "The cache now contains %zu members",
conn->connection_id, cpool->num_conn)); conn->connection_id, cpool->num_conn));
out: out:
@ -636,8 +636,8 @@ static void cpool_shutdown_discard_all(struct cpool *cpool)
while(e) { while(e) {
conn = Curl_node_elem(e); conn = Curl_node_elem(e);
Curl_node_remove(e); Curl_node_remove(e);
DEBUGF(infof(cpool->idata, "discard connection #%" DEBUGF(infof(cpool->idata, "discard connection #%" FMT_OFF_T,
CURL_FORMAT_CURL_OFF_T, conn->connection_id)); conn->connection_id));
cpool_close_and_destroy(cpool, conn, NULL, FALSE); cpool_close_and_destroy(cpool, conn, NULL, FALSE);
e = Curl_llist_head(&cpool->shutdowns); e = Curl_llist_head(&cpool->shutdowns);
} }
@ -719,7 +719,7 @@ static void cpool_discard_conn(struct cpool *cpool,
* are other users of it * are other users of it
*/ */
if(CONN_INUSE(conn) && !aborted) { if(CONN_INUSE(conn) && !aborted) {
DEBUGF(infof(data, "[CCACHE] not discarding #%" CURL_FORMAT_CURL_OFF_T DEBUGF(infof(data, "[CCACHE] not discarding #%" FMT_OFF_T
" still in use by %zu transfers", conn->connection_id, " still in use by %zu transfers", conn->connection_id,
CONN_INUSE(conn))); CONN_INUSE(conn)));
return; return;
@ -742,8 +742,8 @@ static void cpool_discard_conn(struct cpool *cpool,
/* Attempt to shutdown the connection right away. */ /* Attempt to shutdown the connection right away. */
Curl_attach_connection(data, conn); Curl_attach_connection(data, conn);
cpool_run_conn_shutdown(data, conn, &done); cpool_run_conn_shutdown(data, conn, &done);
DEBUGF(infof(data, "[CCACHE] shutdown #%" CURL_FORMAT_CURL_OFF_T DEBUGF(infof(data, "[CCACHE] shutdown #%" FMT_OFF_T ", done=%d",
", done=%d",conn->connection_id, done)); conn->connection_id, done));
Curl_detach_connection(data); Curl_detach_connection(data);
} }
@ -770,7 +770,7 @@ static void cpool_discard_conn(struct cpool *cpool,
memset(&conn->shutdown_poll, 0, sizeof(conn->shutdown_poll)); memset(&conn->shutdown_poll, 0, sizeof(conn->shutdown_poll));
if(cpool_update_shutdown_ev(data->multi, cpool->idata, conn)) { if(cpool_update_shutdown_ev(data->multi, cpool->idata, conn)) {
DEBUGF(infof(data, "[CCACHE] update events for shutdown failed, " DEBUGF(infof(data, "[CCACHE] update events for shutdown failed, "
"discarding #%" CURL_FORMAT_CURL_OFF_T, "discarding #%" FMT_OFF_T,
conn->connection_id)); conn->connection_id));
cpool_close_and_destroy(cpool, conn, data, FALSE); cpool_close_and_destroy(cpool, conn, data, FALSE);
return; return;
@ -778,7 +778,7 @@ static void cpool_discard_conn(struct cpool *cpool,
} }
Curl_llist_append(&cpool->shutdowns, conn, &conn->cpool_node); Curl_llist_append(&cpool->shutdowns, conn, &conn->cpool_node);
DEBUGF(infof(data, "[CCACHE] added #%" CURL_FORMAT_CURL_OFF_T DEBUGF(infof(data, "[CCACHE] added #%" FMT_OFF_T
" to shutdown list of length %zu", conn->connection_id, " to shutdown list of length %zu", conn->connection_id,
Curl_llist_count(&cpool->shutdowns))); Curl_llist_count(&cpool->shutdowns)));
} }
@ -819,14 +819,13 @@ void Curl_cpool_disconnect(struct Curl_easy *data,
if(data->multi) { if(data->multi) {
/* Add it to the multi's cpool for shutdown handling */ /* Add it to the multi's cpool for shutdown handling */
infof(data, "%s connection #%" CURL_FORMAT_CURL_OFF_T, infof(data, "%s connection #%" FMT_OFF_T,
aborted? "closing" : "shutting down", conn->connection_id); aborted? "closing" : "shutting down", conn->connection_id);
cpool_discard_conn(&data->multi->cpool, data, conn, aborted); cpool_discard_conn(&data->multi->cpool, data, conn, aborted);
} }
else { else {
/* No multi available. Make a best-effort shutdown + close */ /* No multi available. Make a best-effort shutdown + close */
infof(data, "closing connection #%" CURL_FORMAT_CURL_OFF_T, infof(data, "closing connection #%" FMT_OFF_T, conn->connection_id);
conn->connection_id);
cpool_close_and_destroy(NULL, conn, data, !aborted); cpool_close_and_destroy(NULL, conn, data, !aborted);
} }
@ -849,7 +848,7 @@ static void cpool_run_conn_shutdown_handler(struct Curl_easy *data,
if(conn->handler && conn->handler->disconnect) { if(conn->handler && conn->handler->disconnect) {
/* This is set if protocol-specific cleanups should be made */ /* This is set if protocol-specific cleanups should be made */
DEBUGF(infof(data, "connection #%" CURL_FORMAT_CURL_OFF_T DEBUGF(infof(data, "connection #%" FMT_OFF_T
", shutdown protocol handler (aborted=%d)", ", shutdown protocol handler (aborted=%d)",
conn->connection_id, conn->bits.aborted)); conn->connection_id, conn->bits.aborted));
@ -990,8 +989,8 @@ static void cpool_perform(struct cpool *cpool)
conn = Curl_node_elem(e); conn = Curl_node_elem(e);
Curl_attach_connection(data, conn); Curl_attach_connection(data, conn);
cpool_run_conn_shutdown(data, conn, &done); cpool_run_conn_shutdown(data, conn, &done);
DEBUGF(infof(data, "[CCACHE] shutdown #%" CURL_FORMAT_CURL_OFF_T DEBUGF(infof(data, "[CCACHE] shutdown #%" FMT_OFF_T ", done=%d",
", done=%d", conn->connection_id, done)); conn->connection_id, done));
Curl_detach_connection(data); Curl_detach_connection(data);
if(done) { if(done) {
Curl_node_remove(e); Curl_node_remove(e);
@ -1055,10 +1054,10 @@ static void cpool_close_and_destroy(struct cpool *cpool,
} }
if(cpool) if(cpool)
DEBUGF(infof(data, "[CCACHE] closing #%" CURL_FORMAT_CURL_OFF_T, DEBUGF(infof(data, "[CCACHE] closing #%" FMT_OFF_T,
conn->connection_id)); conn->connection_id));
else else
DEBUGF(infof(data, "closing connection #%" CURL_FORMAT_CURL_OFF_T, DEBUGF(infof(data, "closing connection #%" FMT_OFF_T,
conn->connection_id)); conn->connection_id));
Curl_conn_close(data, SECONDARYSOCKET); Curl_conn_close(data, SECONDARYSOCKET);
Curl_conn_close(data, FIRSTSOCKET); Curl_conn_close(data, FIRSTSOCKET);
@ -1109,8 +1108,8 @@ void Curl_cpool_multi_socket(struct Curl_multi *multi,
if(s == conn->sock[FIRSTSOCKET] || s == conn->sock[SECONDARYSOCKET]) { if(s == conn->sock[FIRSTSOCKET] || s == conn->sock[SECONDARYSOCKET]) {
Curl_attach_connection(data, conn); Curl_attach_connection(data, conn);
cpool_run_conn_shutdown(data, conn, &done); cpool_run_conn_shutdown(data, conn, &done);
DEBUGF(infof(data, "[CCACHE] shutdown #%" CURL_FORMAT_CURL_OFF_T DEBUGF(infof(data, "[CCACHE] shutdown #%" FMT_OFF_T ", done=%d",
", done=%d", conn->connection_id, done)); conn->connection_id, done));
Curl_detach_connection(data); Curl_detach_connection(data);
if(done || cpool_update_shutdown_ev(multi, data, conn)) { if(done || cpool_update_shutdown_ev(multi, data, conn)) {
Curl_node_remove(e); Curl_node_remove(e);
@ -1160,7 +1159,7 @@ static void cpool_shutdown_all(struct cpool *cpool,
for(conn = cpool_get_live_conn(cpool); conn; for(conn = cpool_get_live_conn(cpool); conn;
conn = cpool_get_live_conn(cpool)) { conn = cpool_get_live_conn(cpool)) {
/* Move conn from live set to shutdown or destroy right away */ /* Move conn from live set to shutdown or destroy right away */
DEBUGF(infof(data, "moving connection #%" CURL_FORMAT_CURL_OFF_T DEBUGF(infof(data, "moving connection #%" FMT_OFF_T
" to shutdown queue", conn->connection_id)); " to shutdown queue", conn->connection_id));
cpool_remove_conn(cpool, conn); cpool_remove_conn(cpool, conn);
cpool_discard_conn(cpool, data, conn, FALSE); cpool_discard_conn(cpool, data, conn, FALSE);

15
lib/connect.c
View File

@ -581,7 +581,7 @@ static CURLcode baller_connect(struct Curl_cfilter *cf,
baller->is_done = TRUE; baller->is_done = TRUE;
} }
else if(Curl_timediff(*now, baller->started) >= baller->timeoutms) { else if(Curl_timediff(*now, baller->started) >= baller->timeoutms) {
infof(data, "%s connect timeout after %" CURL_FORMAT_TIMEDIFF_T infof(data, "%s connect timeout after %" FMT_TIMEDIFF_T
"ms, move on!", baller->name, baller->timeoutms); "ms, move on!", baller->name, baller->timeoutms);
#if defined(ETIMEDOUT) #if defined(ETIMEDOUT)
baller->error = ETIMEDOUT; baller->error = ETIMEDOUT;
@ -672,7 +672,7 @@ evaluate:
/* Nothing connected, check the time before we might /* Nothing connected, check the time before we might
* start new ballers or return ok. */ * start new ballers or return ok. */
if((ongoing || not_started) && Curl_timeleft(data, &now, TRUE) < 0) { if((ongoing || not_started) && Curl_timeleft(data, &now, TRUE) < 0) {
failf(data, "Connection timeout after %" CURL_FORMAT_CURL_OFF_T " ms", failf(data, "Connection timeout after %" FMT_OFF_T " ms",
Curl_timediff(now, data->progress.t_startsingle)); Curl_timediff(now, data->progress.t_startsingle));
return CURLE_OPERATION_TIMEDOUT; return CURLE_OPERATION_TIMEDOUT;
} }
@ -695,8 +695,7 @@ evaluate:
CURL_TRC_CF(data, cf, "%s done", baller->name); CURL_TRC_CF(data, cf, "%s done", baller->name);
} }
else { else {
CURL_TRC_CF(data, cf, "%s starting (timeout=%" CURL_TRC_CF(data, cf, "%s starting (timeout=%" FMT_TIMEDIFF_T "ms)",
CURL_FORMAT_TIMEDIFF_T "ms)",
baller->name, baller->timeoutms); baller->name, baller->timeoutms);
++ongoing; ++ongoing;
++added; ++added;
@ -741,7 +740,7 @@ evaluate:
hostname = conn->host.name; hostname = conn->host.name;
failf(data, "Failed to connect to %s port %u after " failf(data, "Failed to connect to %s port %u after "
"%" CURL_FORMAT_TIMEDIFF_T " ms: %s", "%" FMT_TIMEDIFF_T " ms: %s",
hostname, conn->primary.remote_port, hostname, conn->primary.remote_port,
Curl_timediff(now, data->progress.t_startsingle), Curl_timediff(now, data->progress.t_startsingle),
curl_easy_strerror(result)); curl_easy_strerror(result));
@ -834,8 +833,7 @@ static CURLcode start_connect(struct Curl_cfilter *cf,
timeout_ms, EXPIRE_DNS_PER_NAME); timeout_ms, EXPIRE_DNS_PER_NAME);
if(result) if(result)
return result; return result;
CURL_TRC_CF(data, cf, "created %s (timeout %" CURL_TRC_CF(data, cf, "created %s (timeout %" FMT_TIMEDIFF_T "ms)",
CURL_FORMAT_TIMEDIFF_T "ms)",
ctx->baller[0]->name, ctx->baller[0]->timeoutms); ctx->baller[0]->name, ctx->baller[0]->timeoutms);
if(addr1) { if(addr1) {
/* second one gets a delayed start */ /* second one gets a delayed start */
@ -846,8 +844,7 @@ static CURLcode start_connect(struct Curl_cfilter *cf,
timeout_ms, EXPIRE_DNS_PER_NAME2); timeout_ms, EXPIRE_DNS_PER_NAME2);
if(result) if(result)
return result; return result;
CURL_TRC_CF(data, cf, "created %s (timeout %" CURL_TRC_CF(data, cf, "created %s (timeout %" FMT_TIMEDIFF_T "ms)",
CURL_FORMAT_TIMEDIFF_T "ms)",
ctx->baller[1]->name, ctx->baller[1]->timeoutms); ctx->baller[1]->name, ctx->baller[1]->timeoutms);
Curl_expire(data, data->set.happy_eyeballs_timeout, Curl_expire(data, data->set.happy_eyeballs_timeout,
EXPIRE_HAPPY_EYEBALLS); EXPIRE_HAPPY_EYEBALLS);

4
lib/cookie.c
View File

@ -1170,7 +1170,7 @@ Curl_cookie_add(struct Curl_easy *data,
if(c->running) if(c->running)
/* Only show this when NOT reading the cookies from a file */ /* Only show this when NOT reading the cookies from a file */
infof(data, "%s cookie %s=\"%s\" for domain %s, path %s, " infof(data, "%s cookie %s=\"%s\" for domain %s, path %s, "
"expire %" CURL_FORMAT_CURL_OFF_T, "expire %" FMT_OFF_T,
replace_old?"Replaced":"Added", co->name, co->value, replace_old?"Replaced":"Added", co->name, co->value,
co->domain, co->path, co->expires); co->domain, co->path, co->expires);
@ -1589,7 +1589,7 @@ static char *get_netscape_format(const struct Cookie *co)
"%s\t" /* tailmatch */ "%s\t" /* tailmatch */
"%s\t" /* path */ "%s\t" /* path */
"%s\t" /* secure */ "%s\t" /* secure */
"%" CURL_FORMAT_CURL_OFF_T "\t" /* expires */ "%" FMT_OFF_T "\t" /* expires */
"%s\t" /* name */ "%s\t" /* name */
"%s", /* value */ "%s", /* value */
co->httponly?"#HttpOnly_":"", co->httponly?"#HttpOnly_":"",

15
lib/curl_range.c
View File

@ -55,15 +55,13 @@ CURLcode Curl_range(struct Curl_easy *data)
if((to_t == CURL_OFFT_INVAL) && !from_t) { if((to_t == CURL_OFFT_INVAL) && !from_t) {
/* X - */ /* X - */
data->state.resume_from = from; data->state.resume_from = from;
DEBUGF(infof(data, "RANGE %" CURL_FORMAT_CURL_OFF_T " to end of file", DEBUGF(infof(data, "RANGE %" FMT_OFF_T " to end of file", from));
from));
} }
else if((from_t == CURL_OFFT_INVAL) && !to_t) { else if((from_t == CURL_OFFT_INVAL) && !to_t) {
/* -Y */ /* -Y */
data->req.maxdownload = to; data->req.maxdownload = to;
data->state.resume_from = -to; data->state.resume_from = -to;
DEBUGF(infof(data, "RANGE the last %" CURL_FORMAT_CURL_OFF_T " bytes", DEBUGF(infof(data, "RANGE the last %" FMT_OFF_T " bytes", to));
to));
} }
else { else {
/* X-Y */ /* X-Y */
@ -79,13 +77,12 @@ CURLcode Curl_range(struct Curl_easy *data)
data->req.maxdownload = totalsize + 1; /* include last byte */ data->req.maxdownload = totalsize + 1; /* include last byte */
data->state.resume_from = from; data->state.resume_from = from;
DEBUGF(infof(data, "RANGE from %" CURL_FORMAT_CURL_OFF_T DEBUGF(infof(data, "RANGE from %" FMT_OFF_T
" getting %" CURL_FORMAT_CURL_OFF_T " bytes", " getting %" FMT_OFF_T " bytes",
from, data->req.maxdownload)); from, data->req.maxdownload));
} }
DEBUGF(infof(data, "range-download from %" CURL_FORMAT_CURL_OFF_T DEBUGF(infof(data, "range-download from %" FMT_OFF_T
" to %" CURL_FORMAT_CURL_OFF_T ", totally %" " to %" FMT_OFF_T ", totally %" FMT_OFF_T " bytes",
CURL_FORMAT_CURL_OFF_T " bytes",
from, to, data->req.maxdownload)); from, to, data->req.maxdownload));
} }
else else

13
lib/curl_setup.h
View File

@ -519,11 +519,11 @@
#endif #endif
#if SIZEOF_CURL_SOCKET_T < 8 #if SIZEOF_CURL_SOCKET_T < 8
# define CURL_FORMAT_SOCKET_T "d" # define FMT_SOCKET_T "d"
#elif defined(__MINGW32__) #elif defined(__MINGW32__)
# define CURL_FORMAT_SOCKET_T "zd" # define FMT_SOCKET_T "zd"
#else #else
# define CURL_FORMAT_SOCKET_T "qd" # define FMT_SOCKET_T "qd"
#endif #endif
/* /*
@ -571,10 +571,13 @@
# endif # endif
# define CURL_UINT64_SUFFIX CURL_SUFFIX_CURL_OFF_TU # define CURL_UINT64_SUFFIX CURL_SUFFIX_CURL_OFF_TU
# define CURL_UINT64_C(val) CURL_CONC_MACROS(val,CURL_UINT64_SUFFIX) # define CURL_UINT64_C(val) CURL_CONC_MACROS(val,CURL_UINT64_SUFFIX)
# define CURL_PRId64 CURL_FORMAT_CURL_OFF_T # define FMT_PRId64 CURL_FORMAT_CURL_OFF_T
# define CURL_PRIu64 CURL_FORMAT_CURL_OFF_TU # define FMT_PRIu64 CURL_FORMAT_CURL_OFF_TU
#endif #endif
#define FMT_OFF_T CURL_FORMAT_CURL_OFF_T
#define FMT_OFF_TU CURL_FORMAT_CURL_OFF_TU
#if (SIZEOF_TIME_T == 4) #if (SIZEOF_TIME_T == 4)
# ifdef HAVE_TIME_T_UNSIGNED # ifdef HAVE_TIME_T_UNSIGNED
# define TIME_T_MAX UINT_MAX # define TIME_T_MAX UINT_MAX

4
lib/doh.c
View File

@ -218,7 +218,7 @@ static int doh_done(struct Curl_easy *doh, CURLcode result)
data = Curl_multi_get_handle(doh->multi, doh->set.dohfor_mid); data = Curl_multi_get_handle(doh->multi, doh->set.dohfor_mid);
if(!data) { if(!data) {
DEBUGF(infof(doh, "doh_done: xfer for mid=%" CURL_FORMAT_CURL_OFF_T DEBUGF(infof(doh, "doh_done: xfer for mid=%" FMT_OFF_T
" not found", doh->set.dohfor_mid)); " not found", doh->set.dohfor_mid));
DEBUGASSERT(0); DEBUGASSERT(0);
} }
@ -1437,7 +1437,7 @@ void Curl_doh_close(struct Curl_easy *data)
probe_data = data->multi? Curl_multi_get_handle(data->multi, mid) : NULL; probe_data = data->multi? Curl_multi_get_handle(data->multi, mid) : NULL;
if(!probe_data) { if(!probe_data) {
DEBUGF(infof(data, "Curl_doh_close: xfer for mid=%" DEBUGF(infof(data, "Curl_doh_close: xfer for mid=%"
CURL_FORMAT_CURL_OFF_T " not found!", FMT_OFF_T " not found!",
doh->probe[slot].easy_mid)); doh->probe[slot].easy_mid));
continue; continue;
} }

12
lib/easy.c
View File

@ -479,14 +479,13 @@ static int events_socket(struct Curl_easy *easy, /* easy handle */
else else
ev->list = nxt; ev->list = nxt;
free(m); free(m);
infof(easy, "socket cb: socket %" CURL_FORMAT_SOCKET_T infof(easy, "socket cb: socket %" FMT_SOCKET_T " REMOVED", s);
" REMOVED", s);
} }
else { else {
/* The socket 's' is already being monitored, update the activity /* The socket 's' is already being monitored, update the activity
mask. Convert from libcurl bitmask to the poll one. */ mask. Convert from libcurl bitmask to the poll one. */
m->socket.events = socketcb2poll(what); m->socket.events = socketcb2poll(what);
infof(easy, "socket cb: socket %" CURL_FORMAT_SOCKET_T infof(easy, "socket cb: socket %" FMT_SOCKET_T
" UPDATED as %s%s", s, " UPDATED as %s%s", s,
(what&CURL_POLL_IN)?"IN":"", (what&CURL_POLL_IN)?"IN":"",
(what&CURL_POLL_OUT)?"OUT":""); (what&CURL_POLL_OUT)?"OUT":"");
@ -501,7 +500,7 @@ static int events_socket(struct Curl_easy *easy, /* easy handle */
if(what == CURL_POLL_REMOVE) { if(what == CURL_POLL_REMOVE) {
/* should not happen if our logic is correct, but is no drama. */ /* should not happen if our logic is correct, but is no drama. */
DEBUGF(infof(easy, "socket cb: asked to REMOVE socket %" DEBUGF(infof(easy, "socket cb: asked to REMOVE socket %"
CURL_FORMAT_SOCKET_T "but not present!", s)); FMT_SOCKET_T "but not present!", s));
DEBUGASSERT(0); DEBUGASSERT(0);
} }
else { else {
@ -512,8 +511,7 @@ static int events_socket(struct Curl_easy *easy, /* easy handle */
m->socket.events = socketcb2poll(what); m->socket.events = socketcb2poll(what);
m->socket.revents = 0; m->socket.revents = 0;
ev->list = m; ev->list = m;
infof(easy, "socket cb: socket %" CURL_FORMAT_SOCKET_T infof(easy, "socket cb: socket %" FMT_SOCKET_T " ADDED as %s%s", s,
" ADDED as %s%s", s,
(what&CURL_POLL_IN)?"IN":"", (what&CURL_POLL_IN)?"IN":"",
(what&CURL_POLL_OUT)?"OUT":""); (what&CURL_POLL_OUT)?"OUT":"");
} }
@ -626,7 +624,7 @@ static CURLcode wait_or_timeout(struct Curl_multi *multi, struct events *ev)
/* sending infof "randomly" to the first easy handle */ /* sending infof "randomly" to the first easy handle */
infof(data, "call curl_multi_socket_action(socket " infof(data, "call curl_multi_socket_action(socket "
"%" CURL_FORMAT_SOCKET_T ")", (curl_socket_t)fds[i].fd); "%" FMT_SOCKET_T ")", (curl_socket_t)fds[i].fd);
mcode = curl_multi_socket_action(multi, fds[i].fd, act, mcode = curl_multi_socket_action(multi, fds[i].fd, act,
&ev->running_handles); &ev->running_handles);
} }

3
lib/file.c
View File

@ -468,8 +468,7 @@ static CURLcode file_do(struct Curl_easy *data, bool *done)
static const char accept_ranges[]= { "Accept-ranges: bytes\r\n" }; static const char accept_ranges[]= { "Accept-ranges: bytes\r\n" };
if(expected_size >= 0) { if(expected_size >= 0) {
headerlen = headerlen =
msnprintf(header, sizeof(header), msnprintf(header, sizeof(header), "Content-Length: %" FMT_OFF_T "\r\n",
"Content-Length: %" CURL_FORMAT_CURL_OFF_T "\r\n",
expected_size); expected_size);
result = Curl_client_write(data, CLIENTWRITE_HEADER, header, headerlen); result = Curl_client_write(data, CLIENTWRITE_HEADER, header, headerlen);
if(result) if(result)

30
lib/ftp.c
View File

@ -2388,8 +2388,8 @@ static CURLcode ftp_state_retr(struct Curl_easy *data,
if(data->state.resume_from< 0) { if(data->state.resume_from< 0) {
/* We are supposed to download the last abs(from) bytes */ /* We are supposed to download the last abs(from) bytes */
if(filesize < -data->state.resume_from) { if(filesize < -data->state.resume_from) {
failf(data, "Offset (%" CURL_FORMAT_CURL_OFF_T failf(data, "Offset (%" FMT_OFF_T
") was beyond file size (%" CURL_FORMAT_CURL_OFF_T ")", ") was beyond file size (%" FMT_OFF_T ")",
data->state.resume_from, filesize); data->state.resume_from, filesize);
return CURLE_BAD_DOWNLOAD_RESUME; return CURLE_BAD_DOWNLOAD_RESUME;
} }
@ -2400,8 +2400,8 @@ static CURLcode ftp_state_retr(struct Curl_easy *data,
} }
else { else {
if(filesize < data->state.resume_from) { if(filesize < data->state.resume_from) {
failf(data, "Offset (%" CURL_FORMAT_CURL_OFF_T failf(data, "Offset (%" FMT_OFF_T
") was beyond file size (%" CURL_FORMAT_CURL_OFF_T ")", ") was beyond file size (%" FMT_OFF_T ")",
data->state.resume_from, filesize); data->state.resume_from, filesize);
return CURLE_BAD_DOWNLOAD_RESUME; return CURLE_BAD_DOWNLOAD_RESUME;
} }
@ -2423,10 +2423,10 @@ static CURLcode ftp_state_retr(struct Curl_easy *data,
} }
/* Set resume file transfer offset */ /* Set resume file transfer offset */
infof(data, "Instructs server to resume from offset %" infof(data, "Instructs server to resume from offset %" FMT_OFF_T,
CURL_FORMAT_CURL_OFF_T, data->state.resume_from); data->state.resume_from);
result = Curl_pp_sendf(data, &ftpc->pp, "REST %" CURL_FORMAT_CURL_OFF_T, result = Curl_pp_sendf(data, &ftpc->pp, "REST %" FMT_OFF_T,
data->state.resume_from); data->state.resume_from);
if(!result) if(!result)
ftp_state(data, FTP_RETR_REST); ftp_state(data, FTP_RETR_REST);
@ -2484,7 +2484,7 @@ static CURLcode ftp_state_size_resp(struct Curl_easy *data,
if(-1 != filesize) { if(-1 != filesize) {
char clbuf[128]; char clbuf[128];
int clbuflen = msnprintf(clbuf, sizeof(clbuf), int clbuflen = msnprintf(clbuf, sizeof(clbuf),
"Content-Length: %" CURL_FORMAT_CURL_OFF_T "\r\n", filesize); "Content-Length: %" FMT_OFF_T "\r\n", filesize);
result = client_write_header(data, clbuf, clbuflen); result = client_write_header(data, clbuf, clbuflen);
if(result) if(result)
return result; return result;
@ -2664,12 +2664,10 @@ static CURLcode ftp_state_get_resp(struct Curl_easy *data,
else if((instate != FTP_LIST) && (data->state.prefer_ascii)) else if((instate != FTP_LIST) && (data->state.prefer_ascii))
size = -1; /* kludge for servers that understate ASCII mode file size */ size = -1; /* kludge for servers that understate ASCII mode file size */
infof(data, "Maxdownload = %" CURL_FORMAT_CURL_OFF_T, infof(data, "Maxdownload = %" FMT_OFF_T, data->req.maxdownload);
data->req.maxdownload);
if(instate != FTP_LIST) if(instate != FTP_LIST)
infof(data, "Getting file with size: %" CURL_FORMAT_CURL_OFF_T, infof(data, "Getting file with size: %" FMT_OFF_T, size);
size);
/* FTP download: */ /* FTP download: */
conn->proto.ftpc.state_saved = instate; conn->proto.ftpc.state_saved = instate;
@ -3534,8 +3532,8 @@ static CURLcode ftp_done(struct Curl_easy *data, CURLcode status,
(data->state.infilesize != data->req.writebytecount) && (data->state.infilesize != data->req.writebytecount) &&
!data->set.crlf && !data->set.crlf &&
(ftp->transfer == PPTRANSFER_BODY)) { (ftp->transfer == PPTRANSFER_BODY)) {
failf(data, "Uploaded unaligned file size (%" CURL_FORMAT_CURL_OFF_T failf(data, "Uploaded unaligned file size (%" FMT_OFF_T
" out of %" CURL_FORMAT_CURL_OFF_T " bytes)", " out of %" FMT_OFF_T " bytes)",
data->req.writebytecount, data->state.infilesize); data->req.writebytecount, data->state.infilesize);
result = CURLE_PARTIAL_FILE; result = CURLE_PARTIAL_FILE;
} }
@ -3544,8 +3542,8 @@ static CURLcode ftp_done(struct Curl_easy *data, CURLcode status,
if((-1 != data->req.size) && if((-1 != data->req.size) &&
(data->req.size != data->req.bytecount) && (data->req.size != data->req.bytecount) &&
(data->req.maxdownload != data->req.bytecount)) { (data->req.maxdownload != data->req.bytecount)) {
failf(data, "Received only partial file: %" CURL_FORMAT_CURL_OFF_T failf(data, "Received only partial file: %" FMT_OFF_T " bytes",
" bytes", data->req.bytecount); data->req.bytecount);
result = CURLE_PARTIAL_FILE; result = CURLE_PARTIAL_FILE;
} }
else if(!ftpc->dont_check && else if(!ftpc->dont_check &&

18
lib/http.c
View File

@ -462,8 +462,7 @@ static CURLcode http_perhapsrewind(struct Curl_easy *data,
if(abort_upload) { if(abort_upload) {
if(upload_remain >= 0) if(upload_remain >= 0)
infof(data, "%s%sclose instead of sending %" infof(data, "%s%sclose instead of sending %" FMT_OFF_T " more bytes",
CURL_FORMAT_CURL_OFF_T " more bytes",
ongoing_auth? ongoing_auth : "", ongoing_auth? ongoing_auth : "",
ongoing_auth? " send, " : "", ongoing_auth? " send, " : "",
upload_remain); upload_remain);
@ -2049,7 +2048,7 @@ static CURLcode http_resume(struct Curl_easy *data, Curl_HttpReq httpreq)
CURLcode result; CURLcode result;
result = Curl_creader_resume_from(data, data->state.resume_from); result = Curl_creader_resume_from(data, data->state.resume_from);
if(result) { if(result) {
failf(data, "Unable to resume from offset %" CURL_FORMAT_CURL_OFF_T, failf(data, "Unable to resume from offset %" FMT_OFF_T,
data->state.resume_from); data->state.resume_from);
return result; return result;
} }
@ -2186,9 +2185,8 @@ CURLcode Curl_http_req_complete(struct Curl_easy *data,
!Curl_checkheaders(data, STRCONST("Content-Length")))) { !Curl_checkheaders(data, STRCONST("Content-Length")))) {
/* we allow replacing this header if not during auth negotiation, /* we allow replacing this header if not during auth negotiation,
although it is not very wise to actually set your own */ although it is not very wise to actually set your own */
result = Curl_dyn_addf(r, result = Curl_dyn_addf(r, "Content-Length: %" FMT_OFF_T "\r\n",
"Content-Length: %" CURL_FORMAT_CURL_OFF_T req_clen);
"\r\n", req_clen);
} }
if(result) if(result)
goto out; goto out;
@ -2343,8 +2341,7 @@ CURLcode Curl_http_range(struct Curl_easy *data,
remote part so we tell the server (and act accordingly) that we remote part so we tell the server (and act accordingly) that we
upload the whole file (again) */ upload the whole file (again) */
data->state.aptr.rangeline = data->state.aptr.rangeline =
aprintf("Content-Range: bytes 0-%" CURL_FORMAT_CURL_OFF_T aprintf("Content-Range: bytes 0-%" FMT_OFF_T "/%" FMT_OFF_T "\r\n",
"/%" CURL_FORMAT_CURL_OFF_T "\r\n",
req_clen - 1, req_clen); req_clen - 1, req_clen);
} }
@ -2357,15 +2354,14 @@ CURLcode Curl_http_range(struct Curl_easy *data,
data->state.infilesize : data->state.infilesize :
(data->state.resume_from + req_clen); (data->state.resume_from + req_clen);
data->state.aptr.rangeline = data->state.aptr.rangeline =
aprintf("Content-Range: bytes %s%" CURL_FORMAT_CURL_OFF_T aprintf("Content-Range: bytes %s%" FMT_OFF_T "/%" FMT_OFF_T "\r\n",
"/%" CURL_FORMAT_CURL_OFF_T "\r\n",
data->state.range, total_len-1, total_len); data->state.range, total_len-1, total_len);
} }
else { else {
/* Range was selected and then we just pass the incoming range and /* Range was selected and then we just pass the incoming range and
append total size */ append total size */
data->state.aptr.rangeline = data->state.aptr.rangeline =
aprintf("Content-Range: bytes %s/%" CURL_FORMAT_CURL_OFF_T "\r\n", aprintf("Content-Range: bytes %s/%" FMT_OFF_T "\r\n",
data->state.range, req_clen); data->state.range, req_clen);
} }
if(!data->state.aptr.rangeline) if(!data->state.aptr.rangeline)

2
lib/http2.c
View File

@ -2012,7 +2012,7 @@ static ssize_t cf_h2_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
* a read() is called anyway. It is not clear what the calling sequence * a read() is called anyway. It is not clear what the calling sequence
* is for such a case. */ * is for such a case. */
failf(data, "http/2 recv on a transfer never opened " failf(data, "http/2 recv on a transfer never opened "
"or already cleared, mid=%" CURL_FORMAT_CURL_OFF_T, data->mid); "or already cleared, mid=%" FMT_OFF_T, data->mid);
*err = CURLE_HTTP2; *err = CURLE_HTTP2;
return -1; return -1;
} }

4
lib/http_chunks.c
View File

@ -189,7 +189,7 @@ static CURLcode httpchunk_readwrite(struct Curl_easy *data,
else { else {
ch->state = CHUNK_DATA; ch->state = CHUNK_DATA;
CURL_TRC_WRITE(data, "http_chunked, chunk start of %" CURL_TRC_WRITE(data, "http_chunked, chunk start of %"
CURL_FORMAT_CURL_OFF_T " bytes", ch->datasize); FMT_OFF_T " bytes", ch->datasize);
} }
} }
@ -226,7 +226,7 @@ static CURLcode httpchunk_readwrite(struct Curl_easy *data,
buf += piece; /* move read pointer forward */ buf += piece; /* move read pointer forward */
blen -= piece; /* decrease space left in this round */ blen -= piece; /* decrease space left in this round */
CURL_TRC_WRITE(data, "http_chunked, write %zu body bytes, %" CURL_TRC_WRITE(data, "http_chunked, write %zu body bytes, %"
CURL_FORMAT_CURL_OFF_T " bytes in chunk remain", FMT_OFF_T " bytes in chunk remain",
piece, ch->datasize); piece, ch->datasize);
if(0 == ch->datasize) if(0 == ch->datasize)

8
lib/imap.c
View File

@ -814,8 +814,7 @@ static CURLcode imap_perform_append(struct Curl_easy *data)
return CURLE_OUT_OF_MEMORY; return CURLE_OUT_OF_MEMORY;
/* Send the APPEND command */ /* Send the APPEND command */
result = imap_sendf(data, result = imap_sendf(data, "APPEND %s (\\Seen) {%" FMT_OFF_T "}",
"APPEND %s (\\Seen) {%" CURL_FORMAT_CURL_OFF_T "}",
mailbox, data->state.infilesize); mailbox, data->state.infilesize);
free(mailbox); free(mailbox);
@ -1168,8 +1167,7 @@ static CURLcode imap_state_fetch_resp(struct Curl_easy *data,
} }
if(parsed) { if(parsed) {
infof(data, "Found %" CURL_FORMAT_CURL_OFF_T " bytes to download", infof(data, "Found %" FMT_OFF_T " bytes to download", size);
size);
Curl_pgrsSetDownloadSize(data, size); Curl_pgrsSetDownloadSize(data, size);
if(pp->overflow) { if(pp->overflow) {
@ -1196,7 +1194,7 @@ static CURLcode imap_state_fetch_resp(struct Curl_easy *data,
if(result) if(result)
return result; return result;
infof(data, "Written %zu bytes, %" CURL_FORMAT_CURL_OFF_TU infof(data, "Written %zu bytes, %" FMT_OFF_TU
" bytes are left for transfer", chunk, size - chunk); " bytes are left for transfer", chunk, size - chunk);
/* Have we used the entire overflow or just part of it?*/ /* Have we used the entire overflow or just part of it?*/

8
lib/memdebug.c
View File

@ -312,7 +312,7 @@ curl_socket_t curl_dbg_socket(int domain, int type, int protocol,
sockfd = socket(domain, type, protocol); sockfd = socket(domain, type, protocol);
if(source && (sockfd != CURL_SOCKET_BAD)) if(source && (sockfd != CURL_SOCKET_BAD))
curl_dbg_log("FD %s:%d socket() = %" CURL_FORMAT_SOCKET_T "\n", curl_dbg_log("FD %s:%d socket() = %" FMT_SOCKET_T "\n",
source, line, sockfd); source, line, sockfd);
return sockfd; return sockfd;
@ -356,7 +356,7 @@ int curl_dbg_socketpair(int domain, int type, int protocol,
if(source && (0 == res)) if(source && (0 == res))
curl_dbg_log("FD %s:%d socketpair() = " curl_dbg_log("FD %s:%d socketpair() = "
"%" CURL_FORMAT_SOCKET_T " %" CURL_FORMAT_SOCKET_T "\n", "%" FMT_SOCKET_T " %" FMT_SOCKET_T "\n",
source, line, socket_vector[0], socket_vector[1]); source, line, socket_vector[0], socket_vector[1]);
return res; return res;
@ -372,7 +372,7 @@ curl_socket_t curl_dbg_accept(curl_socket_t s, void *saddr, void *saddrlen,
curl_socket_t sockfd = accept(s, addr, addrlen); curl_socket_t sockfd = accept(s, addr, addrlen);
if(source && (sockfd != CURL_SOCKET_BAD)) if(source && (sockfd != CURL_SOCKET_BAD))
curl_dbg_log("FD %s:%d accept() = %" CURL_FORMAT_SOCKET_T "\n", curl_dbg_log("FD %s:%d accept() = %" FMT_SOCKET_T "\n",
source, line, sockfd); source, line, sockfd);
return sockfd; return sockfd;
@ -382,7 +382,7 @@ curl_socket_t curl_dbg_accept(curl_socket_t s, void *saddr, void *saddrlen,
void curl_dbg_mark_sclose(curl_socket_t sockfd, int line, const char *source) void curl_dbg_mark_sclose(curl_socket_t sockfd, int line, const char *source)
{ {
if(source) if(source)
curl_dbg_log("FD %s:%d sclose(%" CURL_FORMAT_SOCKET_T ")\n", curl_dbg_log("FD %s:%d sclose(%" FMT_SOCKET_T ")\n",
source, line, sockfd); source, line, sockfd);
} }

8
lib/mime.c
View File

@ -1989,7 +1989,7 @@ static CURLcode cr_mime_read(struct Curl_easy *data,
case 0: case 0:
if((ctx->total_len >= 0) && (ctx->read_len < ctx->total_len)) { if((ctx->total_len >= 0) && (ctx->read_len < ctx->total_len)) {
failf(data, "client mime read EOF fail, " failf(data, "client mime read EOF fail, "
"only %"CURL_FORMAT_CURL_OFF_T"/%"CURL_FORMAT_CURL_OFF_T "only %"FMT_OFF_T"/%"FMT_OFF_T
" of needed bytes read", ctx->read_len, ctx->total_len); " of needed bytes read", ctx->read_len, ctx->total_len);
return CURLE_READ_ERROR; return CURLE_READ_ERROR;
} }
@ -2042,8 +2042,8 @@ static CURLcode cr_mime_read(struct Curl_easy *data,
} }
out: out:
CURL_TRC_READ(data, "cr_mime_read(len=%zu, total=%" CURL_FORMAT_CURL_OFF_T CURL_TRC_READ(data, "cr_mime_read(len=%zu, total=%" FMT_OFF_T
", read=%"CURL_FORMAT_CURL_OFF_T") -> %d, %zu, %d", ", read=%"FMT_OFF_T") -> %d, %zu, %d",
blen, ctx->total_len, ctx->read_len, CURLE_OK, *pnread, *peos); blen, ctx->total_len, ctx->read_len, CURLE_OK, *pnread, *peos);
return CURLE_OK; return CURLE_OK;
} }
@ -2086,7 +2086,7 @@ static CURLcode cr_mime_resume_from(struct Curl_easy *data,
if((nread == 0) || (nread > readthisamountnow)) { if((nread == 0) || (nread > readthisamountnow)) {
/* this checks for greater-than only to make sure that the /* this checks for greater-than only to make sure that the
CURL_READFUNC_ABORT return code still aborts */ CURL_READFUNC_ABORT return code still aborts */
failf(data, "Could only read %" CURL_FORMAT_CURL_OFF_T failf(data, "Could only read %" FMT_OFF_T
" bytes from the mime post", passed); " bytes from the mime post", passed);
return CURLE_READ_ERROR; return CURLE_READ_ERROR;
} }

26
lib/multi.c
View File

@ -647,7 +647,7 @@ static void multi_done_locked(struct connectdata *conn,
) || conn->bits.close ) || conn->bits.close
|| (mdctx->premature && !Curl_conn_is_multiplex(conn, FIRSTSOCKET))) { || (mdctx->premature && !Curl_conn_is_multiplex(conn, FIRSTSOCKET))) {
DEBUGF(infof(data, "multi_done, not reusing connection=%" DEBUGF(infof(data, "multi_done, not reusing connection=%"
CURL_FORMAT_CURL_OFF_T ", forbid=%d" FMT_OFF_T ", forbid=%d"
", close=%d, premature=%d, conn_multiplex=%d", ", close=%d, premature=%d, conn_multiplex=%d",
conn->connection_id, data->set.reuse_forbid, conn->connection_id, data->set.reuse_forbid,
conn->bits.close, mdctx->premature, conn->bits.close, mdctx->premature,
@ -668,8 +668,8 @@ static void multi_done_locked(struct connectdata *conn,
conn->bits.conn_to_host ? conn->conn_to_host.dispname : conn->bits.conn_to_host ? conn->conn_to_host.dispname :
conn->host.dispname; conn->host.dispname;
data->state.lastconnect_id = conn->connection_id; data->state.lastconnect_id = conn->connection_id;
infof(data, "Connection #%" CURL_FORMAT_CURL_OFF_T infof(data, "Connection #%" FMT_OFF_T " to host %s left intact",
" to host %s left intact", conn->connection_id, host); conn->connection_id, host);
} }
else { else {
/* connection was removed from the cpool and destroyed. */ /* connection was removed from the cpool and destroyed. */
@ -1669,23 +1669,23 @@ static bool multi_handle_timeout(struct Curl_easy *data,
else else
since = data->progress.t_startop; since = data->progress.t_startop;
if(data->mstate == MSTATE_RESOLVING) if(data->mstate == MSTATE_RESOLVING)
failf(data, "Resolving timed out after %" CURL_FORMAT_TIMEDIFF_T failf(data, "Resolving timed out after %" FMT_TIMEDIFF_T
" milliseconds", Curl_timediff(*now, since)); " milliseconds", Curl_timediff(*now, since));
else if(data->mstate == MSTATE_CONNECTING) else if(data->mstate == MSTATE_CONNECTING)
failf(data, "Connection timed out after %" CURL_FORMAT_TIMEDIFF_T failf(data, "Connection timed out after %" FMT_TIMEDIFF_T
" milliseconds", Curl_timediff(*now, since)); " milliseconds", Curl_timediff(*now, since));
else { else {
struct SingleRequest *k = &data->req; struct SingleRequest *k = &data->req;
if(k->size != -1) { if(k->size != -1) {
failf(data, "Operation timed out after %" CURL_FORMAT_TIMEDIFF_T failf(data, "Operation timed out after %" FMT_TIMEDIFF_T
" milliseconds with %" CURL_FORMAT_CURL_OFF_T " out of %" " milliseconds with %" FMT_OFF_T " out of %"
CURL_FORMAT_CURL_OFF_T " bytes received", FMT_OFF_T " bytes received",
Curl_timediff(*now, since), k->bytecount, k->size); Curl_timediff(*now, since), k->bytecount, k->size);
} }
else { else {
failf(data, "Operation timed out after %" CURL_FORMAT_TIMEDIFF_T failf(data, "Operation timed out after %" FMT_TIMEDIFF_T
" milliseconds with %" CURL_FORMAT_CURL_OFF_T " milliseconds with %" FMT_OFF_T " bytes received",
" bytes received", Curl_timediff(*now, since), k->bytecount); Curl_timediff(*now, since), k->bytecount);
} }
} }
*result = CURLE_OPERATION_TIMEDOUT; *result = CURLE_OPERATION_TIMEDOUT;
@ -3019,14 +3019,14 @@ void Curl_multi_closed(struct Curl_easy *data, curl_socket_t s)
if(data) { if(data) {
/* if there is still an easy handle associated with this connection */ /* if there is still an easy handle associated with this connection */
struct Curl_multi *multi = data->multi; struct Curl_multi *multi = data->multi;
DEBUGF(infof(data, "Curl_multi_closed, fd=%" CURL_FORMAT_SOCKET_T DEBUGF(infof(data, "Curl_multi_closed, fd=%" FMT_SOCKET_T
" multi is %p", s, (void *)multi)); " multi is %p", s, (void *)multi));
if(multi) { if(multi) {
/* this is set if this connection is part of a handle that is added to /* this is set if this connection is part of a handle that is added to
a multi handle, and only then this is necessary */ a multi handle, and only then this is necessary */
struct Curl_sh_entry *entry = sh_getentry(&multi->sockhash, s); struct Curl_sh_entry *entry = sh_getentry(&multi->sockhash, s);
DEBUGF(infof(data, "Curl_multi_closed, fd=%" CURL_FORMAT_SOCKET_T DEBUGF(infof(data, "Curl_multi_closed, fd=%" FMT_SOCKET_T
" entry is %p", s, (void *)entry)); " entry is %p", s, (void *)entry));
if(entry) { if(entry) {
int rc = 0; int rc = 0;

38
lib/progress.c
View File

@ -48,8 +48,7 @@ static void time2str(char *r, curl_off_t seconds)
if(h <= CURL_OFF_T_C(99)) { if(h <= CURL_OFF_T_C(99)) {
curl_off_t m = (seconds - (h*CURL_OFF_T_C(3600))) / CURL_OFF_T_C(60); curl_off_t m = (seconds - (h*CURL_OFF_T_C(3600))) / CURL_OFF_T_C(60);
curl_off_t s = (seconds - (h*CURL_OFF_T_C(3600))) - (m*CURL_OFF_T_C(60)); curl_off_t s = (seconds - (h*CURL_OFF_T_C(3600))) - (m*CURL_OFF_T_C(60));
msnprintf(r, 9, "%2" CURL_FORMAT_CURL_OFF_T ":%02" CURL_FORMAT_CURL_OFF_T msnprintf(r, 9, "%2" FMT_OFF_T ":%02" FMT_OFF_T ":%02" FMT_OFF_T, h, m, s);
":%02" CURL_FORMAT_CURL_OFF_T, h, m, s);
} }
else { else {
/* this equals to more than 99 hours, switch to a more suitable output /* this equals to more than 99 hours, switch to a more suitable output
@ -57,10 +56,9 @@ static void time2str(char *r, curl_off_t seconds)
curl_off_t d = seconds / CURL_OFF_T_C(86400); curl_off_t d = seconds / CURL_OFF_T_C(86400);
h = (seconds - (d*CURL_OFF_T_C(86400))) / CURL_OFF_T_C(3600); h = (seconds - (d*CURL_OFF_T_C(86400))) / CURL_OFF_T_C(3600);
if(d <= CURL_OFF_T_C(999)) if(d <= CURL_OFF_T_C(999))
msnprintf(r, 9, "%3" CURL_FORMAT_CURL_OFF_T msnprintf(r, 9, "%3" FMT_OFF_T "d %02" FMT_OFF_T "h", d, h);
"d %02" CURL_FORMAT_CURL_OFF_T "h", d, h);
else else
msnprintf(r, 9, "%7" CURL_FORMAT_CURL_OFF_T "d", d); msnprintf(r, 9, "%7" FMT_OFF_T "d", d);
} }
} }
@ -76,38 +74,38 @@ static char *max5data(curl_off_t bytes, char *max5)
#define ONE_PETABYTE (CURL_OFF_T_C(1024) * ONE_TERABYTE) #define ONE_PETABYTE (CURL_OFF_T_C(1024) * ONE_TERABYTE)
if(bytes < CURL_OFF_T_C(100000)) if(bytes < CURL_OFF_T_C(100000))
msnprintf(max5, 6, "%5" CURL_FORMAT_CURL_OFF_T, bytes); msnprintf(max5, 6, "%5" FMT_OFF_T, bytes);
else if(bytes < CURL_OFF_T_C(10000) * ONE_KILOBYTE) else if(bytes < CURL_OFF_T_C(10000) * ONE_KILOBYTE)
msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "k", bytes/ONE_KILOBYTE); msnprintf(max5, 6, "%4" FMT_OFF_T "k", bytes/ONE_KILOBYTE);
else if(bytes < CURL_OFF_T_C(100) * ONE_MEGABYTE) else if(bytes < CURL_OFF_T_C(100) * ONE_MEGABYTE)
/* 'XX.XM' is good as long as we are less than 100 megs */ /* 'XX.XM' is good as long as we are less than 100 megs */
msnprintf(max5, 6, "%2" CURL_FORMAT_CURL_OFF_T ".%0" msnprintf(max5, 6, "%2" FMT_OFF_T ".%0"
CURL_FORMAT_CURL_OFF_T "M", bytes/ONE_MEGABYTE, FMT_OFF_T "M", bytes/ONE_MEGABYTE,
(bytes%ONE_MEGABYTE) / (ONE_MEGABYTE/CURL_OFF_T_C(10)) ); (bytes%ONE_MEGABYTE) / (ONE_MEGABYTE/CURL_OFF_T_C(10)) );
else if(bytes < CURL_OFF_T_C(10000) * ONE_MEGABYTE) else if(bytes < CURL_OFF_T_C(10000) * ONE_MEGABYTE)
/* 'XXXXM' is good until we are at 10000MB or above */ /* 'XXXXM' is good until we are at 10000MB or above */
msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "M", bytes/ONE_MEGABYTE); msnprintf(max5, 6, "%4" FMT_OFF_T "M", bytes/ONE_MEGABYTE);
else if(bytes < CURL_OFF_T_C(100) * ONE_GIGABYTE) else if(bytes < CURL_OFF_T_C(100) * ONE_GIGABYTE)
/* 10000 MB - 100 GB, we show it as XX.XG */ /* 10000 MB - 100 GB, we show it as XX.XG */
msnprintf(max5, 6, "%2" CURL_FORMAT_CURL_OFF_T ".%0" msnprintf(max5, 6, "%2" FMT_OFF_T ".%0"
CURL_FORMAT_CURL_OFF_T "G", bytes/ONE_GIGABYTE, FMT_OFF_T "G", bytes/ONE_GIGABYTE,
(bytes%ONE_GIGABYTE) / (ONE_GIGABYTE/CURL_OFF_T_C(10)) ); (bytes%ONE_GIGABYTE) / (ONE_GIGABYTE/CURL_OFF_T_C(10)) );
else if(bytes < CURL_OFF_T_C(10000) * ONE_GIGABYTE) else if(bytes < CURL_OFF_T_C(10000) * ONE_GIGABYTE)
/* up to 10000GB, display without decimal: XXXXG */ /* up to 10000GB, display without decimal: XXXXG */
msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "G", bytes/ONE_GIGABYTE); msnprintf(max5, 6, "%4" FMT_OFF_T "G", bytes/ONE_GIGABYTE);
else if(bytes < CURL_OFF_T_C(10000) * ONE_TERABYTE) else if(bytes < CURL_OFF_T_C(10000) * ONE_TERABYTE)
/* up to 10000TB, display without decimal: XXXXT */ /* up to 10000TB, display without decimal: XXXXT */
msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "T", bytes/ONE_TERABYTE); msnprintf(max5, 6, "%4" FMT_OFF_T "T", bytes/ONE_TERABYTE);
else else
/* up to 10000PB, display without decimal: XXXXP */ /* up to 10000PB, display without decimal: XXXXP */
msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "P", bytes/ONE_PETABYTE); msnprintf(max5, 6, "%4" FMT_OFF_T "P", bytes/ONE_PETABYTE);
/* 16384 petabytes (16 exabytes) is the maximum a 64-bit unsigned number can /* 16384 petabytes (16 exabytes) is the maximum a 64-bit unsigned number can
hold, but our data type is signed so 8192PB will be the maximum. */ hold, but our data type is signed so 8192PB will be the maximum. */
@ -514,8 +512,8 @@ static void progress_meter(struct Curl_easy *data)
if(!(p->flags & PGRS_HEADERS_OUT)) { if(!(p->flags & PGRS_HEADERS_OUT)) {
if(data->state.resume_from) { if(data->state.resume_from) {
fprintf(data->set.err, fprintf(data->set.err,
"** Resuming transfer from byte position %" "** Resuming transfer from byte position %" FMT_OFF_T "\n",
CURL_FORMAT_CURL_OFF_T "\n", data->state.resume_from); data->state.resume_from);
} }
fprintf(data->set.err, fprintf(data->set.err,
" %% Total %% Received %% Xferd Average Speed " " %% Total %% Received %% Xferd Average Speed "
@ -549,9 +547,9 @@ static void progress_meter(struct Curl_easy *data)
fprintf(data->set.err, fprintf(data->set.err,
"\r" "\r"
"%3" CURL_FORMAT_CURL_OFF_T " %s " "%3" FMT_OFF_T " %s "
"%3" CURL_FORMAT_CURL_OFF_T " %s " "%3" FMT_OFF_T " %s "
"%3" CURL_FORMAT_CURL_OFF_T " %s %s %s %s %s %s %s", "%3" FMT_OFF_T " %s %s %s %s %s %s %s",
total_estm.percent, /* 3 letters */ /* total % */ total_estm.percent, /* 3 letters */ /* total % */
max5data(total_expected_size, max5[2]), /* total size */ max5data(total_expected_size, max5[2]), /* total size */
dl_estm.percent, /* 3 letters */ /* rcvd % */ dl_estm.percent, /* 3 letters */ /* rcvd % */

8
lib/request.c
View File

@ -264,14 +264,14 @@ CURLcode Curl_req_set_upload_done(struct Curl_easy *data)
if(data->req.upload_aborted) { if(data->req.upload_aborted) {
Curl_bufq_reset(&data->req.sendbuf); Curl_bufq_reset(&data->req.sendbuf);
if(data->req.writebytecount) if(data->req.writebytecount)
infof(data, "abort upload after having sent %" CURL_FORMAT_CURL_OFF_T infof(data, "abort upload after having sent %" FMT_OFF_T " bytes",
" bytes", data->req.writebytecount); data->req.writebytecount);
else else
infof(data, "abort upload"); infof(data, "abort upload");
} }
else if(data->req.writebytecount) else if(data->req.writebytecount)
infof(data, "upload completely sent off: %" CURL_FORMAT_CURL_OFF_T infof(data, "upload completely sent off: %" FMT_OFF_T " bytes",
" bytes", data->req.writebytecount); data->req.writebytecount);
else if(!data->req.download_done) { else if(!data->req.download_done) {
DEBUGASSERT(Curl_bufq_is_empty(&data->req.sendbuf)); DEBUGASSERT(Curl_bufq_is_empty(&data->req.sendbuf));
infof(data, Curl_creader_total_length(data)? infof(data, Curl_creader_total_length(data)?

5
lib/rtsp.c
View File

@ -533,8 +533,7 @@ static CURLcode rtsp_do(struct Curl_easy *data, bool *done)
* actually set a custom Content-Length in the headers */ * actually set a custom Content-Length in the headers */
if(!Curl_checkheaders(data, STRCONST("Content-Length"))) { if(!Curl_checkheaders(data, STRCONST("Content-Length"))) {
result = result =
Curl_dyn_addf(&req_buffer, Curl_dyn_addf(&req_buffer, "Content-Length: %" FMT_OFF_T"\r\n",
"Content-Length: %" CURL_FORMAT_CURL_OFF_T"\r\n",
req_clen); req_clen);
if(result) if(result)
goto out; goto out;
@ -854,7 +853,7 @@ static CURLcode rtsp_rtp_write_resp(struct Curl_easy *data,
* In which case we write out the left over bytes, letting the client * In which case we write out the left over bytes, letting the client
* writer deal with it (it will report EXCESS and fail the transfer). */ * writer deal with it (it will report EXCESS and fail the transfer). */
DEBUGF(infof(data, "rtsp_rtp_write_resp(len=%zu, in_header=%d, done=%d " DEBUGF(infof(data, "rtsp_rtp_write_resp(len=%zu, in_header=%d, done=%d "
" rtspc->state=%d, req.size=%" CURL_FORMAT_CURL_OFF_T ")", " rtspc->state=%d, req.size=%" FMT_OFF_T ")",
blen, rtspc->in_header, data->req.done, rtspc->state, blen, rtspc->in_header, data->req.done, rtspc->state,
data->req.size)); data->req.size));
if(!result && (is_eos || blen)) { if(!result && (is_eos || blen)) {

29
lib/sendf.c
View File

@ -292,8 +292,8 @@ static CURLcode cw_download_write(struct Curl_easy *data,
if((type & CLIENTWRITE_EOS) && !data->req.no_body && if((type & CLIENTWRITE_EOS) && !data->req.no_body &&
(data->req.maxdownload > data->req.bytecount)) { (data->req.maxdownload > data->req.bytecount)) {
failf(data, "end of response with %" CURL_FORMAT_CURL_OFF_T failf(data, "end of response with %" FMT_OFF_T " bytes missing",
" bytes missing", data->req.maxdownload - data->req.bytecount); data->req.maxdownload - data->req.bytecount);
return CURLE_PARTIAL_FILE; return CURLE_PARTIAL_FILE;
} }
} }
@ -328,9 +328,9 @@ static CURLcode cw_download_write(struct Curl_easy *data,
infof(data, infof(data,
"Excess found writing body:" "Excess found writing body:"
" excess = %zu" " excess = %zu"
", size = %" CURL_FORMAT_CURL_OFF_T ", size = %" FMT_OFF_T
", maxdownload = %" CURL_FORMAT_CURL_OFF_T ", maxdownload = %" FMT_OFF_T
", bytecount = %" CURL_FORMAT_CURL_OFF_T, ", bytecount = %" FMT_OFF_T,
excess_len, data->req.size, data->req.maxdownload, excess_len, data->req.size, data->req.maxdownload,
data->req.bytecount); data->req.bytecount);
connclose(data->conn, "excess found in a read"); connclose(data->conn, "excess found in a read");
@ -338,8 +338,7 @@ static CURLcode cw_download_write(struct Curl_easy *data,
} }
else if(nwrite < nbytes) { else if(nwrite < nbytes) {
failf(data, "Exceeded the maximum allowed file size " failf(data, "Exceeded the maximum allowed file size "
"(%" CURL_FORMAT_CURL_OFF_T ") with %" "(%" FMT_OFF_T ") with %" FMT_OFF_T " bytes",
CURL_FORMAT_CURL_OFF_T " bytes",
data->set.max_filesize, data->req.bytecount); data->set.max_filesize, data->req.bytecount);
return CURLE_FILESIZE_EXCEEDED; return CURLE_FILESIZE_EXCEEDED;
} }
@ -688,8 +687,8 @@ static CURLcode cr_in_read(struct Curl_easy *data,
case 0: case 0:
if((ctx->total_len >= 0) && (ctx->read_len < ctx->total_len)) { if((ctx->total_len >= 0) && (ctx->read_len < ctx->total_len)) {
failf(data, "client read function EOF fail, " failf(data, "client read function EOF fail, "
"only %"CURL_FORMAT_CURL_OFF_T"/%"CURL_FORMAT_CURL_OFF_T "only %"FMT_OFF_T"/%"FMT_OFF_T " of needed bytes read",
" of needed bytes read", ctx->read_len, ctx->total_len); ctx->read_len, ctx->total_len);
return CURLE_READ_ERROR; return CURLE_READ_ERROR;
} }
*pnread = 0; *pnread = 0;
@ -738,8 +737,8 @@ static CURLcode cr_in_read(struct Curl_easy *data,
*peos = ctx->seen_eos; *peos = ctx->seen_eos;
break; break;
} }
CURL_TRC_READ(data, "cr_in_read(len=%zu, total=%"CURL_FORMAT_CURL_OFF_T CURL_TRC_READ(data, "cr_in_read(len=%zu, total=%"FMT_OFF_T
", read=%"CURL_FORMAT_CURL_OFF_T") -> %d, nread=%zu, eos=%d", ", read=%"FMT_OFF_T") -> %d, nread=%zu, eos=%d",
blen, ctx->total_len, ctx->read_len, CURLE_OK, blen, ctx->total_len, ctx->read_len, CURLE_OK,
*pnread, *peos); *pnread, *peos);
return CURLE_OK; return CURLE_OK;
@ -804,8 +803,8 @@ static CURLcode cr_in_resume_from(struct Curl_easy *data,
if((actuallyread == 0) || (actuallyread > readthisamountnow)) { if((actuallyread == 0) || (actuallyread > readthisamountnow)) {
/* this checks for greater-than only to make sure that the /* this checks for greater-than only to make sure that the
CURL_READFUNC_ABORT return code still aborts */ CURL_READFUNC_ABORT return code still aborts */
failf(data, "Could only read %" CURL_FORMAT_CURL_OFF_T failf(data, "Could only read %" FMT_OFF_T " bytes from the input",
" bytes from the input", passed); passed);
return CURLE_READ_ERROR; return CURLE_READ_ERROR;
} }
} while(passed < offset); } while(passed < offset);
@ -1126,8 +1125,8 @@ CURLcode Curl_creader_set_fread(struct Curl_easy *data, curl_off_t len)
cl_reset_reader(data); cl_reset_reader(data);
result = do_init_reader_stack(data, r); result = do_init_reader_stack(data, r);
out: out:
CURL_TRC_READ(data, "add fread reader, len=%"CURL_FORMAT_CURL_OFF_T CURL_TRC_READ(data, "add fread reader, len=%"FMT_OFF_T " -> %d",
" -> %d", len, result); len, result);
return result; return result;
} }

2
lib/smtp.c
View File

@ -723,7 +723,7 @@ static CURLcode smtp_perform_mail(struct Curl_easy *data)
/* Calculate the optional SIZE parameter */ /* Calculate the optional SIZE parameter */
if(conn->proto.smtpc.size_supported && data->state.infilesize > 0) { if(conn->proto.smtpc.size_supported && data->state.infilesize > 0) {
size = aprintf("%" CURL_FORMAT_CURL_OFF_T, data->state.infilesize); size = aprintf("%" FMT_OFF_T, data->state.infilesize);
if(!size) { if(!size) {
result = CURLE_OUT_OF_MEMORY; result = CURLE_OUT_OF_MEMORY;

5
lib/tftp.c
View File

@ -240,8 +240,7 @@ static CURLcode tftp_set_timeouts(struct tftp_state_data *state)
state->retry_time = 1; state->retry_time = 1;
infof(state->data, infof(state->data,
"set timeouts for state %d; Total % " CURL_FORMAT_CURL_OFF_T "set timeouts for state %d; Total % " FMT_OFF_T ", retry %d maxtry %d",
", retry %d maxtry %d",
(int)state->state, timeout_ms, state->retry_time, state->retry_max); (int)state->state, timeout_ms, state->retry_time, state->retry_max);
/* init RX time */ /* init RX time */
@ -484,7 +483,7 @@ static CURLcode tftp_send_first(struct tftp_state_data *state,
char buf[64]; char buf[64];
/* add tsize option */ /* add tsize option */
if(data->state.upload && (data->state.infilesize != -1)) if(data->state.upload && (data->state.infilesize != -1))
msnprintf(buf, sizeof(buf), "%" CURL_FORMAT_CURL_OFF_T, msnprintf(buf, sizeof(buf), "%" FMT_OFF_T,
data->state.infilesize); data->state.infilesize);
else else
strcpy(buf, "0"); /* the destination is large enough */ strcpy(buf, "0"); /* the destination is large enough */

2
lib/timediff.h
View File

@ -29,7 +29,7 @@
/* Use a larger type even for 32-bit time_t systems so that we can keep /* Use a larger type even for 32-bit time_t systems so that we can keep
microsecond accuracy in it */ microsecond accuracy in it */
typedef curl_off_t timediff_t; typedef curl_off_t timediff_t;
#define CURL_FORMAT_TIMEDIFF_T CURL_FORMAT_CURL_OFF_T #define FMT_TIMEDIFF_T FMT_OFF_T
#define TIMEDIFF_T_MAX CURL_OFF_T_MAX #define TIMEDIFF_T_MAX CURL_OFF_T_MAX
#define TIMEDIFF_T_MIN CURL_OFF_T_MIN #define TIMEDIFF_T_MIN CURL_OFF_T_MIN

12
lib/transfer.c
View File

@ -496,15 +496,15 @@ CURLcode Curl_sendrecv(struct Curl_easy *data, struct curltime *nowp)
if(k->keepon) { if(k->keepon) {
if(0 > Curl_timeleft(data, nowp, FALSE)) { if(0 > Curl_timeleft(data, nowp, FALSE)) {
if(k->size != -1) { if(k->size != -1) {
failf(data, "Operation timed out after %" CURL_FORMAT_TIMEDIFF_T failf(data, "Operation timed out after %" FMT_TIMEDIFF_T
" milliseconds with %" CURL_FORMAT_CURL_OFF_T " out of %" " milliseconds with %" FMT_OFF_T " out of %"
CURL_FORMAT_CURL_OFF_T " bytes received", FMT_OFF_T " bytes received",
Curl_timediff(*nowp, data->progress.t_startsingle), Curl_timediff(*nowp, data->progress.t_startsingle),
k->bytecount, k->size); k->bytecount, k->size);
} }
else { else {
failf(data, "Operation timed out after %" CURL_FORMAT_TIMEDIFF_T failf(data, "Operation timed out after %" FMT_TIMEDIFF_T
" milliseconds with %" CURL_FORMAT_CURL_OFF_T " bytes received", " milliseconds with %" FMT_OFF_T " bytes received",
Curl_timediff(*nowp, data->progress.t_startsingle), Curl_timediff(*nowp, data->progress.t_startsingle),
k->bytecount); k->bytecount);
} }
@ -519,7 +519,7 @@ CURLcode Curl_sendrecv(struct Curl_easy *data, struct curltime *nowp)
*/ */
if(!(data->req.no_body) && (k->size != -1) && if(!(data->req.no_body) && (k->size != -1) &&
(k->bytecount != k->size) && !k->newurl) { (k->bytecount != k->size) && !k->newurl) {
failf(data, "transfer closed with %" CURL_FORMAT_CURL_OFF_T failf(data, "transfer closed with %" FMT_OFF_T
" bytes remaining to read", k->size - k->bytecount); " bytes remaining to read", k->size - k->bytecount);
result = CURLE_PARTIAL_FILE; result = CURLE_PARTIAL_FILE;
goto out; goto out;

19
lib/url.c
View File

@ -629,8 +629,7 @@ bool Curl_on_disconnect(struct Curl_easy *data,
/* the transfer must be detached from the connection */ /* the transfer must be detached from the connection */
DEBUGASSERT(!data->conn); DEBUGASSERT(!data->conn);
DEBUGF(infof(data, "Curl_disconnect(conn #%" DEBUGF(infof(data, "Curl_disconnect(conn #%" FMT_OFF_T ", aborted=%d)",
CURL_FORMAT_CURL_OFF_T ", aborted=%d)",
conn->connection_id, aborted)); conn->connection_id, aborted));
if(conn->dns_entry) if(conn->dns_entry)
@ -721,7 +720,7 @@ static bool conn_maxage(struct Curl_easy *data,
idletime /= 1000; /* integer seconds is fine */ idletime /= 1000; /* integer seconds is fine */
if(idletime > data->set.maxage_conn) { if(idletime > data->set.maxage_conn) {
infof(data, "Too old connection (%" CURL_FORMAT_TIMEDIFF_T infof(data, "Too old connection (%" FMT_TIMEDIFF_T
" seconds idle), disconnect it", idletime); " seconds idle), disconnect it", idletime);
return TRUE; return TRUE;
} }
@ -731,7 +730,7 @@ static bool conn_maxage(struct Curl_easy *data,
if(data->set.maxlifetime_conn && lifetime > data->set.maxlifetime_conn) { if(data->set.maxlifetime_conn && lifetime > data->set.maxlifetime_conn) {
infof(data, infof(data,
"Too old connection (%" CURL_FORMAT_TIMEDIFF_T "Too old connection (%" FMT_TIMEDIFF_T
" seconds since creation), disconnect it", lifetime); " seconds since creation), disconnect it", lifetime);
return TRUE; return TRUE;
} }
@ -799,7 +798,7 @@ bool Curl_conn_seems_dead(struct connectdata *conn,
if(dead) { if(dead) {
/* remove connection from cpool */ /* remove connection from cpool */
infof(data, "Connection %" CURL_FORMAT_CURL_OFF_T " seems to be dead", infof(data, "Connection %" FMT_OFF_T " seems to be dead",
conn->connection_id); conn->connection_id);
return TRUE; return TRUE;
} }
@ -914,7 +913,7 @@ static bool url_match_conn(struct connectdata *conn, void *userdata)
if(match->may_multiplex) { if(match->may_multiplex) {
match->seen_pending_conn = TRUE; match->seen_pending_conn = TRUE;
/* Do not pick a connection that has not connected yet */ /* Do not pick a connection that has not connected yet */
infof(data, "Connection #%" CURL_FORMAT_CURL_OFF_T infof(data, "Connection #%" FMT_OFF_T
" is not open enough, cannot reuse", conn->connection_id); " is not open enough, cannot reuse", conn->connection_id);
} }
/* Do not pick a connection that has not connected yet */ /* Do not pick a connection that has not connected yet */
@ -989,7 +988,7 @@ static bool url_match_conn(struct connectdata *conn, void *userdata)
/* match SSL config to proxy */ /* match SSL config to proxy */
if(!Curl_ssl_conn_config_match(data, conn, TRUE)) { if(!Curl_ssl_conn_config_match(data, conn, TRUE)) {
DEBUGF(infof(data, DEBUGF(infof(data,
"Connection #%" CURL_FORMAT_CURL_OFF_T "Connection #%" FMT_OFF_T
" has different SSL proxy parameters, cannot reuse", " has different SSL proxy parameters, cannot reuse",
conn->connection_id)); conn->connection_id));
return FALSE; return FALSE;
@ -1088,7 +1087,7 @@ static bool url_match_conn(struct connectdata *conn, void *userdata)
if((needle->handler->flags & PROTOPT_SSL) && if((needle->handler->flags & PROTOPT_SSL) &&
!Curl_ssl_conn_config_match(data, conn, FALSE)) { !Curl_ssl_conn_config_match(data, conn, FALSE)) {
DEBUGF(infof(data, DEBUGF(infof(data,
"Connection #%" CURL_FORMAT_CURL_OFF_T "Connection #%" FMT_OFF_T
" has different SSL parameters, cannot reuse", " has different SSL parameters, cannot reuse",
conn->connection_id)); conn->connection_id));
return FALSE; return FALSE;
@ -1931,7 +1930,7 @@ static CURLcode setup_range(struct Curl_easy *data)
free(s->range); free(s->range);
if(s->resume_from) if(s->resume_from)
s->range = aprintf("%" CURL_FORMAT_CURL_OFF_T "-", s->resume_from); s->range = aprintf("%" FMT_OFF_T "-", s->resume_from);
else else
s->range = strdup(data->set.str[STRING_SET_RANGE]); s->range = strdup(data->set.str[STRING_SET_RANGE]);
@ -3159,7 +3158,7 @@ static CURLcode resolve_server(struct Curl_easy *data,
*async = TRUE; *async = TRUE;
else if(rc == CURLRESOLV_TIMEDOUT) { else if(rc == CURLRESOLV_TIMEDOUT) {
failf(data, "Failed to resolve %s '%s' with timeout after %" failf(data, "Failed to resolve %s '%s' with timeout after %"
CURL_FORMAT_TIMEDIFF_T " ms", peertype, ehost->dispname, FMT_TIMEDIFF_T " ms", peertype, ehost->dispname,
Curl_timediff(Curl_now(), data->progress.t_startsingle)); Curl_timediff(Curl_now(), data->progress.t_startsingle));
return CURLE_OPERATION_TIMEDOUT; return CURLE_OPERATION_TIMEDOUT;
} }

81
lib/vquic/curl_ngtcp2.c
View File

@ -268,7 +268,7 @@ static void cf_ngtcp2_stream_close(struct Curl_cfilter *cf,
NGHTTP3_H3_REQUEST_CANCELLED); NGHTTP3_H3_REQUEST_CANCELLED);
result = cf_progress_egress(cf, data, NULL); result = cf_progress_egress(cf, data, NULL);
if(result) if(result)
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] cancel stream -> %d", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] cancel stream -> %d",
stream->id, result); stream->id, result);
} }
} }
@ -279,7 +279,7 @@ static void h3_data_done(struct Curl_cfilter *cf, struct Curl_easy *data)
struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, data); struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, data);
(void)cf; (void)cf;
if(stream) { if(stream) {
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] easy handle is done", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] easy handle is done",
stream->id); stream->id);
cf_ngtcp2_stream_close(cf, data, stream); cf_ngtcp2_stream_close(cf, data, stream);
Curl_hash_offt_remove(&ctx->streams, data->mid); Curl_hash_offt_remove(&ctx->streams, data->mid);
@ -518,12 +518,12 @@ static int cb_recv_stream_data(ngtcp2_conn *tconn, uint32_t flags,
if(!data) if(!data)
data = CF_DATA_CURRENT(cf); data = CF_DATA_CURRENT(cf);
if(data) if(data)
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] read_stream(len=%zu) -> %zd", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] read_stream(len=%zu) -> %zd",
stream_id, buflen, nconsumed); stream_id, buflen, nconsumed);
if(nconsumed < 0) { if(nconsumed < 0) {
struct h3_stream_ctx *stream = H3_STREAM_CTX_ID(ctx, stream_id); struct h3_stream_ctx *stream = H3_STREAM_CTX_ID(ctx, stream_id);
if(data && stream) { if(data && stream) {
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] error on known stream, " CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] error on known stream, "
"reset=%d, closed=%d", "reset=%d, closed=%d",
stream_id, stream->reset, stream->closed); stream_id, stream->reset, stream->closed);
} }
@ -583,8 +583,8 @@ static int cb_stream_close(ngtcp2_conn *tconn, uint32_t flags,
} }
rv = nghttp3_conn_close_stream(ctx->h3conn, stream_id, app_error_code); rv = nghttp3_conn_close_stream(ctx->h3conn, stream_id, app_error_code);
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] quic close(app_error=%" CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] quic close(app_error=%"
CURL_PRIu64 ") -> %d", stream_id, (curl_uint64_t)app_error_code, FMT_PRIu64 ") -> %d", stream_id, (curl_uint64_t)app_error_code,
rv); rv);
if(rv && rv != NGHTTP3_ERR_STREAM_NOT_FOUND) { if(rv && rv != NGHTTP3_ERR_STREAM_NOT_FOUND) {
cf_ngtcp2_h3_err_set(cf, data, rv); cf_ngtcp2_h3_err_set(cf, data, rv);
@ -609,7 +609,7 @@ static int cb_stream_reset(ngtcp2_conn *tconn, int64_t sid,
(void)data; (void)data;
rv = nghttp3_conn_shutdown_stream_read(ctx->h3conn, stream_id); rv = nghttp3_conn_shutdown_stream_read(ctx->h3conn, stream_id);
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] reset -> %d", stream_id, rv); CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] reset -> %d", stream_id, rv);
if(rv && rv != NGHTTP3_ERR_STREAM_NOT_FOUND) { if(rv && rv != NGHTTP3_ERR_STREAM_NOT_FOUND) {
return NGTCP2_ERR_CALLBACK_FAILURE; return NGTCP2_ERR_CALLBACK_FAILURE;
} }
@ -647,8 +647,8 @@ static int cb_extend_max_local_streams_bidi(ngtcp2_conn *tconn,
(void)tconn; (void)tconn;
ctx->max_bidi_streams = max_streams; ctx->max_bidi_streams = max_streams;
if(data) if(data)
CURL_TRC_CF(data, cf, "max bidi streams now %" CURL_PRIu64 CURL_TRC_CF(data, cf, "max bidi streams now %" FMT_PRIu64
", used %" CURL_PRIu64, (curl_uint64_t)ctx->max_bidi_streams, ", used %" FMT_PRIu64, (curl_uint64_t)ctx->max_bidi_streams,
(curl_uint64_t)ctx->used_bidi_streams); (curl_uint64_t)ctx->used_bidi_streams);
return 0; return 0;
} }
@ -674,8 +674,7 @@ static int cb_extend_max_stream_data(ngtcp2_conn *tconn, int64_t sid,
} }
s_data = get_stream_easy(cf, data, stream_id, &stream); s_data = get_stream_easy(cf, data, stream_id, &stream);
if(s_data && stream && stream->quic_flow_blocked) { if(s_data && stream && stream->quic_flow_blocked) {
CURL_TRC_CF(s_data, cf, "[%" CURL_PRId64 "] unblock quic flow", CURL_TRC_CF(s_data, cf, "[%" FMT_PRId64 "] unblock quic flow", stream_id);
stream_id);
stream->quic_flow_blocked = FALSE; stream->quic_flow_blocked = FALSE;
h3_drain_stream(cf, s_data); h3_drain_stream(cf, s_data);
} }
@ -895,11 +894,11 @@ static int cb_h3_stream_close(nghttp3_conn *conn, int64_t sid,
if(stream->error3 != NGHTTP3_H3_NO_ERROR) { if(stream->error3 != NGHTTP3_H3_NO_ERROR) {
stream->reset = TRUE; stream->reset = TRUE;
stream->send_closed = TRUE; stream->send_closed = TRUE;
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] RESET: error %" CURL_PRIu64, CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] RESET: error %" FMT_PRIu64,
stream->id, stream->error3); stream->id, stream->error3);
} }
else { else {
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] CLOSED", stream->id); CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] CLOSED", stream->id);
} }
h3_drain_stream(cf, data); h3_drain_stream(cf, data);
return 0; return 0;
@ -915,7 +914,7 @@ static void h3_xfer_write_resp_hd(struct Curl_cfilter *cf,
if(!stream->xfer_result) { if(!stream->xfer_result) {
stream->xfer_result = Curl_xfer_write_resp_hd(data, buf, blen, eos); stream->xfer_result = Curl_xfer_write_resp_hd(data, buf, blen, eos);
if(stream->xfer_result) if(stream->xfer_result)
CURL_TRC_CF(data, cf, "[%"CURL_PRId64"] error %d writing %zu " CURL_TRC_CF(data, cf, "[%"FMT_PRId64"] error %d writing %zu "
"bytes of headers", stream->id, stream->xfer_result, blen); "bytes of headers", stream->id, stream->xfer_result, blen);
} }
} }
@ -931,7 +930,7 @@ static void h3_xfer_write_resp(struct Curl_cfilter *cf,
stream->xfer_result = Curl_xfer_write_resp(data, buf, blen, eos); stream->xfer_result = Curl_xfer_write_resp(data, buf, blen, eos);
/* If the transfer write is errored, we do not want any more data */ /* If the transfer write is errored, we do not want any more data */
if(stream->xfer_result) { if(stream->xfer_result) {
CURL_TRC_CF(data, cf, "[%"CURL_PRId64"] error %d writing %zu bytes " CURL_TRC_CF(data, cf, "[%"FMT_PRId64"] error %d writing %zu bytes "
"of data", stream->id, stream->xfer_result, blen); "of data", stream->id, stream->xfer_result, blen);
} }
} }
@ -954,12 +953,12 @@ static int cb_h3_recv_data(nghttp3_conn *conn, int64_t stream3_id,
h3_xfer_write_resp(cf, data, stream, (char *)buf, blen, FALSE); h3_xfer_write_resp(cf, data, stream, (char *)buf, blen, FALSE);
if(blen) { if(blen) {
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] ACK %zu bytes of DATA", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] ACK %zu bytes of DATA",
stream->id, blen); stream->id, blen);
ngtcp2_conn_extend_max_stream_offset(ctx->qconn, stream->id, blen); ngtcp2_conn_extend_max_stream_offset(ctx->qconn, stream->id, blen);
ngtcp2_conn_extend_max_offset(ctx->qconn, blen); ngtcp2_conn_extend_max_offset(ctx->qconn, blen);
} }
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] DATA len=%zu", stream->id, blen); CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] DATA len=%zu", stream->id, blen);
return 0; return 0;
} }
@ -997,7 +996,7 @@ static int cb_h3_end_headers(nghttp3_conn *conn, int64_t sid,
/* add a CRLF only if we have received some headers */ /* add a CRLF only if we have received some headers */
h3_xfer_write_resp_hd(cf, data, stream, STRCONST("\r\n"), stream->closed); h3_xfer_write_resp_hd(cf, data, stream, STRCONST("\r\n"), stream->closed);
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] end_headers, status=%d", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] end_headers, status=%d",
stream_id, stream->status_code); stream_id, stream->status_code);
if(stream->status_code / 100 != 1) { if(stream->status_code / 100 != 1) {
stream->resp_hds_complete = TRUE; stream->resp_hds_complete = TRUE;
@ -1045,7 +1044,7 @@ static int cb_h3_recv_header(nghttp3_conn *conn, int64_t sid,
if(!result) if(!result)
h3_xfer_write_resp_hd(cf, data, stream, Curl_dyn_ptr(&ctx->scratch), h3_xfer_write_resp_hd(cf, data, stream, Curl_dyn_ptr(&ctx->scratch),
Curl_dyn_len(&ctx->scratch), FALSE); Curl_dyn_len(&ctx->scratch), FALSE);
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] status: %s", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] status: %s",
stream_id, Curl_dyn_ptr(&ctx->scratch)); stream_id, Curl_dyn_ptr(&ctx->scratch));
if(result) { if(result) {
return -1; return -1;
@ -1053,7 +1052,7 @@ static int cb_h3_recv_header(nghttp3_conn *conn, int64_t sid,
} }
else { else {
/* store as an HTTP1-style header */ /* store as an HTTP1-style header */
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] header: %.*s: %.*s", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] header: %.*s: %.*s",
stream_id, (int)h3name.len, h3name.base, stream_id, (int)h3name.len, h3name.base,
(int)h3val.len, h3val.base); (int)h3val.len, h3val.base);
Curl_dyn_reset(&ctx->scratch); Curl_dyn_reset(&ctx->scratch);
@ -1105,7 +1104,7 @@ static int cb_h3_reset_stream(nghttp3_conn *conn, int64_t sid,
rv = ngtcp2_conn_shutdown_stream_write(ctx->qconn, 0, stream_id, rv = ngtcp2_conn_shutdown_stream_write(ctx->qconn, 0, stream_id,
app_error_code); app_error_code);
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] reset -> %d", stream_id, rv); CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] reset -> %d", stream_id, rv);
if(rv && rv != NGTCP2_ERR_STREAM_NOT_FOUND) { if(rv && rv != NGTCP2_ERR_STREAM_NOT_FOUND) {
return NGHTTP3_ERR_CALLBACK_FAILURE; return NGHTTP3_ERR_CALLBACK_FAILURE;
} }
@ -1200,14 +1199,13 @@ static ssize_t recv_closed_stream(struct Curl_cfilter *cf,
(void)cf; (void)cf;
if(stream->reset) { if(stream->reset) {
failf(data, failf(data, "HTTP/3 stream %" FMT_PRId64 " reset by server", stream->id);
"HTTP/3 stream %" CURL_PRId64 " reset by server", stream->id);
*err = data->req.bytecount? CURLE_PARTIAL_FILE : CURLE_HTTP3; *err = data->req.bytecount? CURLE_PARTIAL_FILE : CURLE_HTTP3;
goto out; goto out;
} }
else if(!stream->resp_hds_complete) { else if(!stream->resp_hds_complete) {
failf(data, failf(data,
"HTTP/3 stream %" CURL_PRId64 " was closed cleanly, but before " "HTTP/3 stream %" FMT_PRId64 " was closed cleanly, but before "
"getting all response header fields, treated as error", "getting all response header fields, treated as error",
stream->id); stream->id);
*err = CURLE_HTTP3; *err = CURLE_HTTP3;
@ -1254,7 +1252,7 @@ static ssize_t cf_ngtcp2_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
} }
if(stream->xfer_result) { if(stream->xfer_result) {
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] xfer write failed", stream->id); CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] xfer write failed", stream->id);
cf_ngtcp2_stream_close(cf, data, stream); cf_ngtcp2_stream_close(cf, data, stream);
*err = stream->xfer_result; *err = stream->xfer_result;
nread = -1; nread = -1;
@ -1279,7 +1277,7 @@ out:
nread = -1; nread = -1;
} }
} }
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] cf_recv(blen=%zu) -> %zd, %d", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] cf_recv(blen=%zu) -> %zd, %d",
stream? stream->id : -1, blen, nread, *err); stream? stream->id : -1, blen, nread, *err);
CF_DATA_RESTORE(cf, save); CF_DATA_RESTORE(cf, save);
return nread; return nread;
@ -1370,14 +1368,13 @@ cb_h3_read_req_body(nghttp3_conn *conn, int64_t stream_id,
} }
else if(!nwritten) { else if(!nwritten) {
/* Not EOF, and nothing to give, we signal WOULDBLOCK. */ /* Not EOF, and nothing to give, we signal WOULDBLOCK. */
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] read req body -> AGAIN", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] read req body -> AGAIN",
stream->id); stream->id);
return NGHTTP3_ERR_WOULDBLOCK; return NGHTTP3_ERR_WOULDBLOCK;
} }
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] read req body -> " CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] read req body -> "
"%d vecs%s with %zu (buffered=%zu, left=%" "%d vecs%s with %zu (buffered=%zu, left=%" FMT_OFF_T ")",
CURL_FORMAT_CURL_OFF_T ")",
stream->id, (int)nvecs, stream->id, (int)nvecs,
*pflags == NGHTTP3_DATA_FLAG_EOF?" EOF":"", *pflags == NGHTTP3_DATA_FLAG_EOF?" EOF":"",
nwritten, Curl_bufq_len(&stream->sendbuf), nwritten, Curl_bufq_len(&stream->sendbuf),
@ -1491,11 +1488,11 @@ static ssize_t h3_stream_open(struct Curl_cfilter *cf,
if(rc) { if(rc) {
switch(rc) { switch(rc) {
case NGHTTP3_ERR_CONN_CLOSING: case NGHTTP3_ERR_CONN_CLOSING:
CURL_TRC_CF(data, cf, "h3sid[%" CURL_PRId64 "] failed to send, " CURL_TRC_CF(data, cf, "h3sid[%" FMT_PRId64 "] failed to send, "
"connection is closing", stream->id); "connection is closing", stream->id);
break; break;
default: default:
CURL_TRC_CF(data, cf, "h3sid[%" CURL_PRId64 "] failed to send -> " CURL_TRC_CF(data, cf, "h3sid[%" FMT_PRId64 "] failed to send -> "
"%d (%s)", stream->id, rc, nghttp3_strerror(rc)); "%d (%s)", stream->id, rc, nghttp3_strerror(rc));
break; break;
} }
@ -1505,10 +1502,10 @@ static ssize_t h3_stream_open(struct Curl_cfilter *cf,
} }
if(Curl_trc_is_verbose(data)) { if(Curl_trc_is_verbose(data)) {
infof(data, "[HTTP/3] [%" CURL_PRId64 "] OPENED stream for %s", infof(data, "[HTTP/3] [%" FMT_PRId64 "] OPENED stream for %s",
stream->id, data->state.url); stream->id, data->state.url);
for(i = 0; i < nheader; ++i) { for(i = 0; i < nheader; ++i) {
infof(data, "[HTTP/3] [%" CURL_PRId64 "] [%.*s: %.*s]", stream->id, infof(data, "[HTTP/3] [%" FMT_PRId64 "] [%.*s: %.*s]", stream->id,
(int)nva[i].namelen, nva[i].name, (int)nva[i].namelen, nva[i].name,
(int)nva[i].valuelen, nva[i].value); (int)nva[i].valuelen, nva[i].value);
} }
@ -1560,7 +1557,7 @@ static ssize_t cf_ngtcp2_send(struct Curl_cfilter *cf, struct Curl_easy *data,
stream = H3_STREAM_CTX(ctx, data); stream = H3_STREAM_CTX(ctx, data);
} }
else if(stream->xfer_result) { else if(stream->xfer_result) {
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] xfer write failed", stream->id); CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] xfer write failed", stream->id);
cf_ngtcp2_stream_close(cf, data, stream); cf_ngtcp2_stream_close(cf, data, stream);
*err = stream->xfer_result; *err = stream->xfer_result;
sent = -1; sent = -1;
@ -1573,13 +1570,13 @@ static ssize_t cf_ngtcp2_send(struct Curl_cfilter *cf, struct Curl_easy *data,
* body. This happens on 30x or 40x responses. * body. This happens on 30x or 40x responses.
* We silently discard the data sent, since this is not a transport * We silently discard the data sent, since this is not a transport
* error situation. */ * error situation. */
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] discarding data" CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] discarding data"
"on closed stream with response", stream->id); "on closed stream with response", stream->id);
*err = CURLE_OK; *err = CURLE_OK;
sent = (ssize_t)len; sent = (ssize_t)len;
goto out; goto out;
} }
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] send_body(len=%zu) " CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] send_body(len=%zu) "
"-> stream closed", stream->id, len); "-> stream closed", stream->id, len);
*err = CURLE_HTTP3; *err = CURLE_HTTP3;
sent = -1; sent = -1;
@ -1593,7 +1590,7 @@ static ssize_t cf_ngtcp2_send(struct Curl_cfilter *cf, struct Curl_easy *data,
} }
else { else {
sent = Curl_bufq_write(&stream->sendbuf, buf, len, err); sent = Curl_bufq_write(&stream->sendbuf, buf, len, err);
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] cf_send, add to " CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] cf_send, add to "
"sendbuf(len=%zu) -> %zd, %d", "sendbuf(len=%zu) -> %zd, %d",
stream->id, len, sent, *err); stream->id, len, sent, *err);
if(sent < 0) { if(sent < 0) {
@ -1615,7 +1612,7 @@ out:
*err = result; *err = result;
sent = -1; sent = -1;
} }
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] cf_send(len=%zu) -> %zd, %d", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] cf_send(len=%zu) -> %zd, %d",
stream? stream->id : -1, len, sent, *err); stream? stream->id : -1, len, sent, *err);
CF_DATA_RESTORE(cf, save); CF_DATA_RESTORE(cf, save);
return sent; return sent;
@ -1761,7 +1758,7 @@ static ssize_t read_pkt_to_send(void *userp,
struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, x->data); struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, x->data);
DEBUGASSERT(ndatalen == -1); DEBUGASSERT(ndatalen == -1);
nghttp3_conn_block_stream(ctx->h3conn, stream_id); nghttp3_conn_block_stream(ctx->h3conn, stream_id);
CURL_TRC_CF(x->data, x->cf, "[%" CURL_PRId64 "] block quic flow", CURL_TRC_CF(x->data, x->cf, "[%" FMT_PRId64 "] block quic flow",
(curl_int64_t)stream_id); (curl_int64_t)stream_id);
DEBUGASSERT(stream); DEBUGASSERT(stream);
if(stream) if(stream)
@ -2060,7 +2057,7 @@ static CURLcode cf_ngtcp2_shutdown(struct Curl_cfilter *cf,
(uint8_t *)buffer, sizeof(buffer), (uint8_t *)buffer, sizeof(buffer),
&ctx->last_error, pktx.ts); &ctx->last_error, pktx.ts);
CURL_TRC_CF(data, cf, "start shutdown(err_type=%d, err_code=%" CURL_TRC_CF(data, cf, "start shutdown(err_type=%d, err_code=%"
CURL_PRIu64 ") -> %d", ctx->last_error.type, FMT_PRIu64 ") -> %d", ctx->last_error.type,
(curl_uint64_t)ctx->last_error.error_code, (int)nwritten); (curl_uint64_t)ctx->last_error.error_code, (int)nwritten);
if(nwritten > 0) { if(nwritten > 0) {
Curl_bufq_write(&ctx->q.sendbuf, (const unsigned char *)buffer, Curl_bufq_write(&ctx->q.sendbuf, (const unsigned char *)buffer,
@ -2408,7 +2405,7 @@ static CURLcode cf_ngtcp2_query(struct Curl_cfilter *cf,
} }
else /* transport params not arrived yet? take our default. */ else /* transport params not arrived yet? take our default. */
*pres1 = (int)Curl_multi_max_concurrent_streams(data->multi); *pres1 = (int)Curl_multi_max_concurrent_streams(data->multi);
CURL_TRC_CF(data, cf, "query conn[%" CURL_FORMAT_CURL_OFF_T "]: " CURL_TRC_CF(data, cf, "query conn[%" FMT_OFF_T "]: "
"MAX_CONCURRENT -> %d (%zu in use)", "MAX_CONCURRENT -> %d (%zu in use)",
cf->conn->connection_id, *pres1, CONN_INUSE(cf->conn)); cf->conn->connection_id, *pres1, CONN_INUSE(cf->conn));
CF_DATA_RESTORE(cf, save); CF_DATA_RESTORE(cf, save);

85
lib/vquic/curl_osslq.c
View File

@ -453,7 +453,7 @@ static CURLcode cf_osslq_h3conn_add_stream(struct cf_osslq_h3conn *h3,
if(h3->remote_ctrl_n >= ARRAYSIZE(h3->remote_ctrl)) { if(h3->remote_ctrl_n >= ARRAYSIZE(h3->remote_ctrl)) {
/* rejected, we are full */ /* rejected, we are full */
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] rejecting remote stream", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] rejecting remote stream",
stream_id); stream_id);
SSL_free(stream_ssl); SSL_free(stream_ssl);
return CURLE_FAILED_INIT; return CURLE_FAILED_INIT;
@ -464,12 +464,12 @@ static CURLcode cf_osslq_h3conn_add_stream(struct cf_osslq_h3conn *h3,
nstream->id = stream_id; nstream->id = stream_id;
nstream->ssl = stream_ssl; nstream->ssl = stream_ssl;
Curl_bufq_initp(&nstream->recvbuf, &ctx->stream_bufcp, 1, BUFQ_OPT_NONE); Curl_bufq_initp(&nstream->recvbuf, &ctx->stream_bufcp, 1, BUFQ_OPT_NONE);
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] accepted remote uni stream", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] accepted remote uni stream",
stream_id); stream_id);
break; break;
} }
default: default:
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] reject remote non-uni-read" CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] reject remote non-uni-read"
" stream", stream_id); " stream", stream_id);
SSL_free(stream_ssl); SSL_free(stream_ssl);
return CURLE_FAILED_INIT; return CURLE_FAILED_INIT;
@ -650,7 +650,7 @@ static void h3_data_done(struct Curl_cfilter *cf, struct Curl_easy *data)
(void)cf; (void)cf;
if(stream) { if(stream) {
CURL_TRC_CF(data, cf, "[%"CURL_PRId64"] easy handle is done", CURL_TRC_CF(data, cf, "[%"FMT_PRId64"] easy handle is done",
stream->s.id); stream->s.id);
if(ctx->h3.conn && !stream->closed) { if(ctx->h3.conn && !stream->closed) {
nghttp3_conn_shutdown_stream_read(ctx->h3.conn, stream->s.id); nghttp3_conn_shutdown_stream_read(ctx->h3.conn, stream->s.id);
@ -748,11 +748,11 @@ static int cb_h3_stream_close(nghttp3_conn *conn, int64_t stream_id,
if(stream->error3 != NGHTTP3_H3_NO_ERROR) { if(stream->error3 != NGHTTP3_H3_NO_ERROR) {
stream->reset = TRUE; stream->reset = TRUE;
stream->send_closed = TRUE; stream->send_closed = TRUE;
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] RESET: error %" CURL_PRIu64, CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] RESET: error %" FMT_PRIu64,
stream->s.id, stream->error3); stream->s.id, stream->error3);
} }
else { else {
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] CLOSED", stream->s.id); CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] CLOSED", stream->s.id);
} }
h3_drain_stream(cf, data); h3_drain_stream(cf, data);
return 0; return 0;
@ -812,12 +812,12 @@ static int cb_h3_recv_data(nghttp3_conn *conn, int64_t stream3_id,
result = write_resp_raw(cf, data, buf, buflen, TRUE); result = write_resp_raw(cf, data, buf, buflen, TRUE);
if(result) { if(result) {
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] DATA len=%zu, ERROR %d", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] DATA len=%zu, ERROR %d",
stream->s.id, buflen, result); stream->s.id, buflen, result);
return NGHTTP3_ERR_CALLBACK_FAILURE; return NGHTTP3_ERR_CALLBACK_FAILURE;
} }
stream->download_recvd += (curl_off_t)buflen; stream->download_recvd += (curl_off_t)buflen;
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] DATA len=%zu, total=%zd", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] DATA len=%zu, total=%zd",
stream->s.id, buflen, stream->download_recvd); stream->s.id, buflen, stream->download_recvd);
h3_drain_stream(cf, data); h3_drain_stream(cf, data);
return 0; return 0;
@ -835,7 +835,7 @@ static int cb_h3_deferred_consume(nghttp3_conn *conn, int64_t stream_id,
(void)conn; (void)conn;
(void)stream_id; (void)stream_id;
if(stream) if(stream)
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] deferred consume %zu bytes", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] deferred consume %zu bytes",
stream->s.id, consumed); stream->s.id, consumed);
return 0; return 0;
} }
@ -873,7 +873,7 @@ static int cb_h3_recv_header(nghttp3_conn *conn, int64_t sid,
return -1; return -1;
ncopy = msnprintf(line, sizeof(line), "HTTP/3 %03d \r\n", ncopy = msnprintf(line, sizeof(line), "HTTP/3 %03d \r\n",
stream->status_code); stream->status_code);
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] status: %s", stream_id, line); CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] status: %s", stream_id, line);
result = write_resp_raw(cf, data, line, ncopy, FALSE); result = write_resp_raw(cf, data, line, ncopy, FALSE);
if(result) { if(result) {
return -1; return -1;
@ -881,7 +881,7 @@ static int cb_h3_recv_header(nghttp3_conn *conn, int64_t sid,
} }
else { else {
/* store as an HTTP1-style header */ /* store as an HTTP1-style header */
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] header: %.*s: %.*s", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] header: %.*s: %.*s",
stream_id, (int)h3name.len, h3name.base, stream_id, (int)h3name.len, h3name.base,
(int)h3val.len, h3val.base); (int)h3val.len, h3val.base);
result = write_resp_raw(cf, data, h3name.base, h3name.len, FALSE); result = write_resp_raw(cf, data, h3name.base, h3name.len, FALSE);
@ -926,7 +926,7 @@ static int cb_h3_end_headers(nghttp3_conn *conn, int64_t sid,
return -1; return -1;
} }
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] end_headers, status=%d", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] end_headers, status=%d",
stream_id, stream->status_code); stream_id, stream->status_code);
if(stream->status_code / 100 != 1) { if(stream->status_code / 100 != 1) {
stream->resp_hds_complete = TRUE; stream->resp_hds_complete = TRUE;
@ -950,7 +950,7 @@ static int cb_h3_stop_sending(nghttp3_conn *conn, int64_t sid,
if(!stream || !stream->s.ssl) if(!stream || !stream->s.ssl)
return 0; return 0;
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] stop_sending", stream_id); CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] stop_sending", stream_id);
cf_osslq_stream_close(&stream->s); cf_osslq_stream_close(&stream->s);
return 0; return 0;
} }
@ -970,7 +970,7 @@ static int cb_h3_reset_stream(nghttp3_conn *conn, int64_t sid,
SSL_STREAM_RESET_ARGS args = {0}; SSL_STREAM_RESET_ARGS args = {0};
args.quic_error_code = app_error_code; args.quic_error_code = app_error_code;
rv = !SSL_stream_reset(stream->s.ssl, &args, sizeof(args)); rv = !SSL_stream_reset(stream->s.ssl, &args, sizeof(args));
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] reset -> %d", stream_id, rv); CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] reset -> %d", stream_id, rv);
if(!rv) { if(!rv) {
return NGHTTP3_ERR_CALLBACK_FAILURE; return NGHTTP3_ERR_CALLBACK_FAILURE;
} }
@ -1030,14 +1030,13 @@ cb_h3_read_req_body(nghttp3_conn *conn, int64_t stream_id,
} }
else if(!nwritten) { else if(!nwritten) {
/* Not EOF, and nothing to give, we signal WOULDBLOCK. */ /* Not EOF, and nothing to give, we signal WOULDBLOCK. */
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] read req body -> AGAIN", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] read req body -> AGAIN",
stream->s.id); stream->s.id);
return NGHTTP3_ERR_WOULDBLOCK; return NGHTTP3_ERR_WOULDBLOCK;
} }
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] read req body -> " CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] read req body -> "
"%d vecs%s with %zu (buffered=%zu, left=%" "%d vecs%s with %zu (buffered=%zu, left=%" FMT_OFF_T ")",
CURL_FORMAT_CURL_OFF_T ")",
stream->s.id, (int)nvecs, stream->s.id, (int)nvecs,
*pflags == NGHTTP3_DATA_FLAG_EOF?" EOF":"", *pflags == NGHTTP3_DATA_FLAG_EOF?" EOF":"",
nwritten, Curl_bufq_len(&stream->sendbuf), nwritten, Curl_bufq_len(&stream->sendbuf),
@ -1277,7 +1276,7 @@ static ssize_t h3_quic_recv(void *reader_ctx,
return -1; return -1;
} }
else if(detail == SSL_ERROR_ZERO_RETURN) { else if(detail == SSL_ERROR_ZERO_RETURN) {
CURL_TRC_CF(x->data, x->cf, "[%" CURL_PRId64 "] h3_quic_recv -> EOS", CURL_TRC_CF(x->data, x->cf, "[%" FMT_PRId64 "] h3_quic_recv -> EOS",
x->s->id); x->s->id);
x->s->recvd_eos = TRUE; x->s->recvd_eos = TRUE;
return 0; return 0;
@ -1286,8 +1285,8 @@ static ssize_t h3_quic_recv(void *reader_ctx,
SSL_STREAM_STATE_RESET_REMOTE) { SSL_STREAM_STATE_RESET_REMOTE) {
uint64_t app_error_code = NGHTTP3_H3_NO_ERROR; uint64_t app_error_code = NGHTTP3_H3_NO_ERROR;
SSL_get_stream_read_error_code(x->s->ssl, &app_error_code); SSL_get_stream_read_error_code(x->s->ssl, &app_error_code);
CURL_TRC_CF(x->data, x->cf, "[%" CURL_PRId64 "] h3_quic_recv -> RESET, " CURL_TRC_CF(x->data, x->cf, "[%" FMT_PRId64 "] h3_quic_recv -> RESET, "
"rv=%d, app_err=%" CURL_PRIu64, "rv=%d, app_err=%" FMT_PRIu64,
x->s->id, rv, (curl_uint64_t)app_error_code); x->s->id, rv, (curl_uint64_t)app_error_code);
if(app_error_code != NGHTTP3_H3_NO_ERROR) { if(app_error_code != NGHTTP3_H3_NO_ERROR) {
x->s->reset = TRUE; x->s->reset = TRUE;
@ -1343,7 +1342,7 @@ static CURLcode cf_osslq_stream_recv(struct cf_osslq_stream *s,
while(Curl_bufq_peek(&s->recvbuf, &buf, &blen)) { while(Curl_bufq_peek(&s->recvbuf, &buf, &blen)) {
nread = nghttp3_conn_read_stream(ctx->h3.conn, s->id, nread = nghttp3_conn_read_stream(ctx->h3.conn, s->id,
buf, blen, 0); buf, blen, 0);
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] forward %zu bytes " CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] forward %zu bytes "
"to nghttp3 -> %zd", s->id, blen, nread); "to nghttp3 -> %zd", s->id, blen, nread);
if(nread < 0) { if(nread < 0) {
failf(data, "nghttp3_conn_read_stream(len=%zu) error: %s", failf(data, "nghttp3_conn_read_stream(len=%zu) error: %s",
@ -1382,7 +1381,7 @@ static CURLcode cf_osslq_stream_recv(struct cf_osslq_stream *s,
rv = nghttp3_conn_close_stream(ctx->h3.conn, s->id, rv = nghttp3_conn_close_stream(ctx->h3.conn, s->id,
NGHTTP3_H3_NO_ERROR); NGHTTP3_H3_NO_ERROR);
s->closed = TRUE; s->closed = TRUE;
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] close nghttp3 stream -> %d", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] close nghttp3 stream -> %d",
s->id, rv); s->id, rv);
if(rv < 0 && rv != NGHTTP3_ERR_STREAM_NOT_FOUND) { if(rv < 0 && rv != NGHTTP3_ERR_STREAM_NOT_FOUND) {
failf(data, "nghttp3_conn_close_stream returned error: %s", failf(data, "nghttp3_conn_close_stream returned error: %s",
@ -1395,7 +1394,7 @@ static CURLcode cf_osslq_stream_recv(struct cf_osslq_stream *s,
} }
out: out:
if(result) if(result)
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] cf_osslq_stream_recv -> %d", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] cf_osslq_stream_recv -> %d",
s->id, result); s->id, result);
return result; return result;
} }
@ -1521,7 +1520,7 @@ static CURLcode h3_send_streams(struct Curl_cfilter *cf,
s = cf_osslq_get_qstream(cf, data, stream_id); s = cf_osslq_get_qstream(cf, data, stream_id);
if(!s) { if(!s) {
failf(data, "nghttp3_conn_writev_stream gave unknown stream %" failf(data, "nghttp3_conn_writev_stream gave unknown stream %"
CURL_PRId64, (curl_int64_t)stream_id); FMT_PRId64, (curl_int64_t)stream_id);
result = CURLE_SEND_ERROR; result = CURLE_SEND_ERROR;
goto out; goto out;
} }
@ -1542,7 +1541,7 @@ static CURLcode h3_send_streams(struct Curl_cfilter *cf,
if(ok) { if(ok) {
/* As OpenSSL buffers the data, we count this as acknowledged /* As OpenSSL buffers the data, we count this as acknowledged
* from nghttp3's point of view */ * from nghttp3's point of view */
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] send %zu bytes to QUIC ok", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] send %zu bytes to QUIC ok",
s->id, vec[i].len); s->id, vec[i].len);
acked_len += vec[i].len; acked_len += vec[i].len;
} }
@ -1552,14 +1551,14 @@ static CURLcode h3_send_streams(struct Curl_cfilter *cf,
case SSL_ERROR_WANT_WRITE: case SSL_ERROR_WANT_WRITE:
case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_READ:
/* QUIC blocked us from writing more */ /* QUIC blocked us from writing more */
CURL_TRC_CF(data, cf, "[%"CURL_PRId64 "] send %zu bytes to " CURL_TRC_CF(data, cf, "[%"FMT_PRId64 "] send %zu bytes to "
"QUIC blocked", s->id, vec[i].len); "QUIC blocked", s->id, vec[i].len);
written = 0; written = 0;
nghttp3_conn_block_stream(ctx->h3.conn, s->id); nghttp3_conn_block_stream(ctx->h3.conn, s->id);
s->send_blocked = blocked = TRUE; s->send_blocked = blocked = TRUE;
break; break;
default: default:
failf(data, "[%"CURL_PRId64 "] send %zu bytes to QUIC, SSL error %d", failf(data, "[%"FMT_PRId64 "] send %zu bytes to QUIC, SSL error %d",
s->id, vec[i].len, detail); s->id, vec[i].len, detail);
result = cf_osslq_ssl_err(cf, data, detail, CURLE_HTTP3); result = cf_osslq_ssl_err(cf, data, detail, CURLE_HTTP3);
goto out; goto out;
@ -1585,13 +1584,13 @@ static CURLcode h3_send_streams(struct Curl_cfilter *cf,
result = CURLE_SEND_ERROR; result = CURLE_SEND_ERROR;
goto out; goto out;
} }
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] forwarded %zu/%zu h3 bytes " CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] forwarded %zu/%zu h3 bytes "
"to QUIC, eos=%d", s->id, acked_len, total_len, eos); "to QUIC, eos=%d", s->id, acked_len, total_len, eos);
} }
if(eos && !s->send_blocked && !eos_written) { if(eos && !s->send_blocked && !eos_written) {
/* wrote everything and H3 indicates end of stream */ /* wrote everything and H3 indicates end of stream */
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] closing QUIC stream", s->id); CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] closing QUIC stream", s->id);
SSL_stream_conclude(s->ssl, 0); SSL_stream_conclude(s->ssl, 0);
} }
} }
@ -1884,11 +1883,11 @@ static ssize_t h3_stream_open(struct Curl_cfilter *cf,
if(rc) { if(rc) {
switch(rc) { switch(rc) {
case NGHTTP3_ERR_CONN_CLOSING: case NGHTTP3_ERR_CONN_CLOSING:
CURL_TRC_CF(data, cf, "h3sid[%"CURL_PRId64"] failed to send, " CURL_TRC_CF(data, cf, "h3sid[%"FMT_PRId64"] failed to send, "
"connection is closing", stream->s.id); "connection is closing", stream->s.id);
break; break;
default: default:
CURL_TRC_CF(data, cf, "h3sid[%"CURL_PRId64 "] failed to send -> %d (%s)", CURL_TRC_CF(data, cf, "h3sid[%"FMT_PRId64 "] failed to send -> %d (%s)",
stream->s.id, rc, nghttp3_strerror(rc)); stream->s.id, rc, nghttp3_strerror(rc));
break; break;
} }
@ -1898,10 +1897,10 @@ static ssize_t h3_stream_open(struct Curl_cfilter *cf,
} }
if(Curl_trc_is_verbose(data)) { if(Curl_trc_is_verbose(data)) {
infof(data, "[HTTP/3] [%" CURL_PRId64 "] OPENED stream for %s", infof(data, "[HTTP/3] [%" FMT_PRId64 "] OPENED stream for %s",
stream->s.id, data->state.url); stream->s.id, data->state.url);
for(i = 0; i < nheader; ++i) { for(i = 0; i < nheader; ++i) {
infof(data, "[HTTP/3] [%" CURL_PRId64 "] [%.*s: %.*s]", infof(data, "[HTTP/3] [%" FMT_PRId64 "] [%.*s: %.*s]",
stream->s.id, stream->s.id,
(int)nva[i].namelen, nva[i].name, (int)nva[i].namelen, nva[i].name,
(int)nva[i].valuelen, nva[i].value); (int)nva[i].valuelen, nva[i].value);
@ -1960,13 +1959,13 @@ static ssize_t cf_osslq_send(struct Curl_cfilter *cf, struct Curl_easy *data,
* body. This happens on 30x or 40x responses. * body. This happens on 30x or 40x responses.
* We silently discard the data sent, since this is not a transport * We silently discard the data sent, since this is not a transport
* error situation. */ * error situation. */
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] discarding data" CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] discarding data"
"on closed stream with response", stream->s.id); "on closed stream with response", stream->s.id);
*err = CURLE_OK; *err = CURLE_OK;
nwritten = (ssize_t)len; nwritten = (ssize_t)len;
goto out; goto out;
} }
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] send_body(len=%zu) " CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] send_body(len=%zu) "
"-> stream closed", stream->s.id, len); "-> stream closed", stream->s.id, len);
*err = CURLE_HTTP3; *err = CURLE_HTTP3;
nwritten = -1; nwritten = -1;
@ -1974,7 +1973,7 @@ static ssize_t cf_osslq_send(struct Curl_cfilter *cf, struct Curl_easy *data,
} }
else { else {
nwritten = Curl_bufq_write(&stream->sendbuf, buf, len, err); nwritten = Curl_bufq_write(&stream->sendbuf, buf, len, err);
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] cf_send, add to " CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] cf_send, add to "
"sendbuf(len=%zu) -> %zd, %d", "sendbuf(len=%zu) -> %zd, %d",
stream->s.id, len, nwritten, *err); stream->s.id, len, nwritten, *err);
if(nwritten < 0) { if(nwritten < 0) {
@ -1992,7 +1991,7 @@ static ssize_t cf_osslq_send(struct Curl_cfilter *cf, struct Curl_easy *data,
out: out:
result = check_and_set_expiry(cf, data); result = check_and_set_expiry(cf, data);
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] cf_send(len=%zu) -> %zd, %d", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] cf_send(len=%zu) -> %zd, %d",
stream? stream->s.id : -1, len, nwritten, *err); stream? stream->s.id : -1, len, nwritten, *err);
CF_DATA_RESTORE(cf, save); CF_DATA_RESTORE(cf, save);
return nwritten; return nwritten;
@ -2008,14 +2007,14 @@ static ssize_t recv_closed_stream(struct Curl_cfilter *cf,
(void)cf; (void)cf;
if(stream->reset) { if(stream->reset) {
failf(data, failf(data,
"HTTP/3 stream %" CURL_PRId64 " reset by server", "HTTP/3 stream %" FMT_PRId64 " reset by server",
stream->s.id); stream->s.id);
*err = data->req.bytecount? CURLE_PARTIAL_FILE : CURLE_HTTP3; *err = data->req.bytecount? CURLE_PARTIAL_FILE : CURLE_HTTP3;
goto out; goto out;
} }
else if(!stream->resp_hds_complete) { else if(!stream->resp_hds_complete) {
failf(data, failf(data,
"HTTP/3 stream %" CURL_PRId64 "HTTP/3 stream %" FMT_PRId64
" was closed cleanly, but before getting" " was closed cleanly, but before getting"
" all response header fields, treated as error", " all response header fields, treated as error",
stream->s.id); stream->s.id);
@ -2055,7 +2054,7 @@ static ssize_t cf_osslq_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
nread = Curl_bufq_read(&stream->recvbuf, nread = Curl_bufq_read(&stream->recvbuf,
(unsigned char *)buf, len, err); (unsigned char *)buf, len, err);
if(nread < 0) { if(nread < 0) {
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] read recvbuf(len=%zu) " CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] read recvbuf(len=%zu) "
"-> %zd, %d", stream->s.id, len, nread, *err); "-> %zd, %d", stream->s.id, len, nread, *err);
goto out; goto out;
} }
@ -2073,7 +2072,7 @@ static ssize_t cf_osslq_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
nread = Curl_bufq_read(&stream->recvbuf, nread = Curl_bufq_read(&stream->recvbuf,
(unsigned char *)buf, len, err); (unsigned char *)buf, len, err);
if(nread < 0) { if(nread < 0) {
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] read recvbuf(len=%zu) " CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] read recvbuf(len=%zu) "
"-> %zd, %d", stream->s.id, len, nread, *err); "-> %zd, %d", stream->s.id, len, nread, *err);
goto out; goto out;
} }
@ -2103,7 +2102,7 @@ out:
nread = -1; nread = -1;
} }
} }
CURL_TRC_CF(data, cf, "[%" CURL_PRId64 "] cf_recv(len=%zu) -> %zd, %d", CURL_TRC_CF(data, cf, "[%" FMT_PRId64 "] cf_recv(len=%zu) -> %zd, %d",
stream? stream->s.id : -1, len, nread, *err); stream? stream->s.id : -1, len, nread, *err);
CF_DATA_RESTORE(cf, save); CF_DATA_RESTORE(cf, save);
return nread; return nread;

76
lib/vquic/curl_quiche.c
View File

@ -211,7 +211,7 @@ static void check_resumes(struct Curl_cfilter *cf,
if(stream && stream->quic_flow_blocked) { if(stream && stream->quic_flow_blocked) {
stream->quic_flow_blocked = FALSE; stream->quic_flow_blocked = FALSE;
Curl_expire(data, 0, EXPIRE_RUN_NOW); Curl_expire(data, 0, EXPIRE_RUN_NOW);
CURL_TRC_CF(data, cf, "[%"CURL_PRIu64"] unblock", stream->id); CURL_TRC_CF(data, cf, "[%"FMT_PRIu64"] unblock", stream->id);
} }
} }
} }
@ -251,7 +251,7 @@ static void h3_data_done(struct Curl_cfilter *cf, struct Curl_easy *data)
(void)cf; (void)cf;
if(stream) { if(stream) {
CURL_TRC_CF(data, cf, "[%"CURL_PRIu64"] easy handle is done", stream->id); CURL_TRC_CF(data, cf, "[%"FMT_PRIu64"] easy handle is done", stream->id);
if(ctx->qconn && !stream->closed) { if(ctx->qconn && !stream->closed) {
quiche_conn_stream_shutdown(ctx->qconn, stream->id, quiche_conn_stream_shutdown(ctx->qconn, stream->id,
QUICHE_SHUTDOWN_READ, CURL_H3_NO_ERROR); QUICHE_SHUTDOWN_READ, CURL_H3_NO_ERROR);
@ -382,7 +382,7 @@ static int cb_each_header(uint8_t *name, size_t name_len,
return CURLE_OK; return CURLE_OK;
if((name_len == 7) && !strncmp(HTTP_PSEUDO_STATUS, (char *)name, 7)) { if((name_len == 7) && !strncmp(HTTP_PSEUDO_STATUS, (char *)name, 7)) {
CURL_TRC_CF(x->data, x->cf, "[%" CURL_PRIu64 "] status: %.*s", CURL_TRC_CF(x->data, x->cf, "[%" FMT_PRIu64 "] status: %.*s",
stream->id, (int)value_len, value); stream->id, (int)value_len, value);
result = write_resp_raw(x->cf, x->data, "HTTP/3 ", sizeof("HTTP/3 ") - 1); result = write_resp_raw(x->cf, x->data, "HTTP/3 ", sizeof("HTTP/3 ") - 1);
if(!result) if(!result)
@ -391,7 +391,7 @@ static int cb_each_header(uint8_t *name, size_t name_len,
result = write_resp_raw(x->cf, x->data, " \r\n", 3); result = write_resp_raw(x->cf, x->data, " \r\n", 3);
} }
else { else {
CURL_TRC_CF(x->data, x->cf, "[%" CURL_PRIu64 "] header: %.*s: %.*s", CURL_TRC_CF(x->data, x->cf, "[%" FMT_PRIu64 "] header: %.*s: %.*s",
stream->id, (int)name_len, name, stream->id, (int)name_len, name,
(int)value_len, value); (int)value_len, value);
result = write_resp_raw(x->cf, x->data, name, name_len); result = write_resp_raw(x->cf, x->data, name, name_len);
@ -403,7 +403,7 @@ static int cb_each_header(uint8_t *name, size_t name_len,
result = write_resp_raw(x->cf, x->data, "\r\n", 2); result = write_resp_raw(x->cf, x->data, "\r\n", 2);
} }
if(result) { if(result) {
CURL_TRC_CF(x->data, x->cf, "[%"CURL_PRIu64"] on header error %d", CURL_TRC_CF(x->data, x->cf, "[%"FMT_PRIu64"] on header error %d",
stream->id, result); stream->id, result);
} }
return result; return result;
@ -460,9 +460,9 @@ static CURLcode cf_recv_body(struct Curl_cfilter *cf,
stream_resp_read, &cb_ctx, &result); stream_resp_read, &cb_ctx, &result);
if(nwritten < 0 && result != CURLE_AGAIN) { if(nwritten < 0 && result != CURLE_AGAIN) {
CURL_TRC_CF(data, cf, "[%"CURL_PRIu64"] recv_body error %zd", CURL_TRC_CF(data, cf, "[%"FMT_PRIu64"] recv_body error %zd",
stream->id, nwritten); stream->id, nwritten);
failf(data, "Error %d in HTTP/3 response body for stream[%"CURL_PRIu64"]", failf(data, "Error %d in HTTP/3 response body for stream[%"FMT_PRIu64"]",
result, stream->id); result, stream->id);
stream->closed = TRUE; stream->closed = TRUE;
stream->reset = TRUE; stream->reset = TRUE;
@ -514,10 +514,10 @@ static CURLcode h3_process_event(struct Curl_cfilter *cf,
rc = quiche_h3_event_for_each_header(ev, cb_each_header, &cb_ctx); rc = quiche_h3_event_for_each_header(ev, cb_each_header, &cb_ctx);
if(rc) { if(rc) {
failf(data, "Error %d in HTTP/3 response header for stream[%" failf(data, "Error %d in HTTP/3 response header for stream[%"
CURL_PRIu64"]", rc, stream->id); FMT_PRIu64"]", rc, stream->id);
return CURLE_RECV_ERROR; return CURLE_RECV_ERROR;
} }
CURL_TRC_CF(data, cf, "[%"CURL_PRIu64"] <- [HEADERS]", stream->id); CURL_TRC_CF(data, cf, "[%"FMT_PRIu64"] <- [HEADERS]", stream->id);
break; break;
case QUICHE_H3_EVENT_DATA: case QUICHE_H3_EVENT_DATA:
@ -527,7 +527,7 @@ static CURLcode h3_process_event(struct Curl_cfilter *cf,
break; break;
case QUICHE_H3_EVENT_RESET: case QUICHE_H3_EVENT_RESET:
CURL_TRC_CF(data, cf, "[%"CURL_PRIu64"] RESET", stream->id); CURL_TRC_CF(data, cf, "[%"FMT_PRIu64"] RESET", stream->id);
stream->closed = TRUE; stream->closed = TRUE;
stream->reset = TRUE; stream->reset = TRUE;
stream->send_closed = TRUE; stream->send_closed = TRUE;
@ -535,7 +535,7 @@ static CURLcode h3_process_event(struct Curl_cfilter *cf,
break; break;
case QUICHE_H3_EVENT_FINISHED: case QUICHE_H3_EVENT_FINISHED:
CURL_TRC_CF(data, cf, "[%"CURL_PRIu64"] CLOSED", stream->id); CURL_TRC_CF(data, cf, "[%"FMT_PRIu64"] CLOSED", stream->id);
if(!stream->resp_hds_complete) { if(!stream->resp_hds_complete) {
result = write_resp_raw(cf, data, "\r\n", 2); result = write_resp_raw(cf, data, "\r\n", 2);
if(result) if(result)
@ -547,11 +547,11 @@ static CURLcode h3_process_event(struct Curl_cfilter *cf,
break; break;
case QUICHE_H3_EVENT_GOAWAY: case QUICHE_H3_EVENT_GOAWAY:
CURL_TRC_CF(data, cf, "[%"CURL_PRIu64"] <- [GOAWAY]", stream->id); CURL_TRC_CF(data, cf, "[%"FMT_PRIu64"] <- [GOAWAY]", stream->id);
break; break;
default: default:
CURL_TRC_CF(data, cf, "[%"CURL_PRIu64"] recv, unhandled event %d", CURL_TRC_CF(data, cf, "[%"FMT_PRIu64"] recv, unhandled event %d",
stream->id, quiche_h3_event_type(ev)); stream->id, quiche_h3_event_type(ev));
break; break;
} }
@ -574,13 +574,13 @@ static CURLcode cf_poll_events(struct Curl_cfilter *cf,
break; break;
} }
else if(stream3_id < 0) { else if(stream3_id < 0) {
CURL_TRC_CF(data, cf, "error poll: %"CURL_PRId64, stream3_id); CURL_TRC_CF(data, cf, "error poll: %"FMT_PRId64, stream3_id);
return CURLE_HTTP3; return CURLE_HTTP3;
} }
sdata = get_stream_easy(cf, data, stream3_id, &stream); sdata = get_stream_easy(cf, data, stream3_id, &stream);
if(!sdata || !stream) { if(!sdata || !stream) {
CURL_TRC_CF(data, cf, "discard event %s for unknown [%"CURL_PRId64"]", CURL_TRC_CF(data, cf, "discard event %s for unknown [%"FMT_PRId64"]",
cf_ev_name(ev), stream3_id); cf_ev_name(ev), stream3_id);
} }
else { else {
@ -588,7 +588,7 @@ static CURLcode cf_poll_events(struct Curl_cfilter *cf,
drain_stream(cf, sdata); drain_stream(cf, sdata);
if(result) { if(result) {
CURL_TRC_CF(data, cf, "error processing event %s " CURL_TRC_CF(data, cf, "error processing event %s "
"for [%"CURL_PRIu64"] -> %d", cf_ev_name(ev), "for [%"FMT_PRIu64"] -> %d", cf_ev_name(ev),
stream3_id, result); stream3_id, result);
if(data == sdata) { if(data == sdata) {
/* Only report this error to the caller if it is about the /* Only report this error to the caller if it is about the
@ -818,19 +818,19 @@ static ssize_t recv_closed_stream(struct Curl_cfilter *cf,
DEBUGASSERT(stream); DEBUGASSERT(stream);
if(stream->reset) { if(stream->reset) {
failf(data, failf(data,
"HTTP/3 stream %" CURL_PRIu64 " reset by server", stream->id); "HTTP/3 stream %" FMT_PRIu64 " reset by server", stream->id);
*err = data->req.bytecount? CURLE_PARTIAL_FILE : CURLE_HTTP3; *err = data->req.bytecount? CURLE_PARTIAL_FILE : CURLE_HTTP3;
CURL_TRC_CF(data, cf, "[%" CURL_PRIu64 "] cf_recv, was reset -> %d", CURL_TRC_CF(data, cf, "[%" FMT_PRIu64 "] cf_recv, was reset -> %d",
stream->id, *err); stream->id, *err);
} }
else if(!stream->resp_got_header) { else if(!stream->resp_got_header) {
failf(data, failf(data,
"HTTP/3 stream %" CURL_PRIu64 " was closed cleanly, but before " "HTTP/3 stream %" FMT_PRIu64 " was closed cleanly, but before "
"getting all response header fields, treated as error", "getting all response header fields, treated as error",
stream->id); stream->id);
/* *err = CURLE_PARTIAL_FILE; */ /* *err = CURLE_PARTIAL_FILE; */
*err = CURLE_HTTP3; *err = CURLE_HTTP3;
CURL_TRC_CF(data, cf, "[%" CURL_PRIu64 "] cf_recv, closed incomplete" CURL_TRC_CF(data, cf, "[%" FMT_PRIu64 "] cf_recv, closed incomplete"
" -> %d", stream->id, *err); " -> %d", stream->id, *err);
} }
else { else {
@ -858,7 +858,7 @@ static ssize_t cf_quiche_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
if(!Curl_bufq_is_empty(&stream->recvbuf)) { if(!Curl_bufq_is_empty(&stream->recvbuf)) {
nread = Curl_bufq_read(&stream->recvbuf, nread = Curl_bufq_read(&stream->recvbuf,
(unsigned char *)buf, len, err); (unsigned char *)buf, len, err);
CURL_TRC_CF(data, cf, "[%" CURL_PRIu64 "] read recvbuf(len=%zu) " CURL_TRC_CF(data, cf, "[%" FMT_PRIu64 "] read recvbuf(len=%zu) "
"-> %zd, %d", stream->id, len, nread, *err); "-> %zd, %d", stream->id, len, nread, *err);
if(nread < 0) if(nread < 0)
goto out; goto out;
@ -875,7 +875,7 @@ static ssize_t cf_quiche_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
if(nread < 0 && !Curl_bufq_is_empty(&stream->recvbuf)) { if(nread < 0 && !Curl_bufq_is_empty(&stream->recvbuf)) {
nread = Curl_bufq_read(&stream->recvbuf, nread = Curl_bufq_read(&stream->recvbuf,
(unsigned char *)buf, len, err); (unsigned char *)buf, len, err);
CURL_TRC_CF(data, cf, "[%" CURL_PRIu64 "] read recvbuf(len=%zu) " CURL_TRC_CF(data, cf, "[%" FMT_PRIu64 "] read recvbuf(len=%zu) "
"-> %zd, %d", stream->id, len, nread, *err); "-> %zd, %d", stream->id, len, nread, *err);
if(nread < 0) if(nread < 0)
goto out; goto out;
@ -909,8 +909,8 @@ out:
} }
if(nread > 0) if(nread > 0)
ctx->data_recvd += nread; ctx->data_recvd += nread;
CURL_TRC_CF(data, cf, "[%"CURL_PRIu64"] cf_recv(total=%" CURL_TRC_CF(data, cf, "[%"FMT_PRIu64"] cf_recv(total=%"
CURL_FORMAT_CURL_OFF_T ") -> %zd, %d", FMT_OFF_T ") -> %zd, %d",
stream->id, ctx->data_recvd, nread, *err); stream->id, ctx->data_recvd, nread, *err);
return nread; return nread;
} }
@ -930,7 +930,7 @@ static ssize_t cf_quiche_send_body(struct Curl_cfilter *cf,
/* TODO: we seem to be blocked on flow control and should HOLD /* TODO: we seem to be blocked on flow control and should HOLD
* sending. But when do we open again? */ * sending. But when do we open again? */
if(!quiche_conn_stream_writable(ctx->qconn, stream->id, len)) { if(!quiche_conn_stream_writable(ctx->qconn, stream->id, len)) {
CURL_TRC_CF(data, cf, "[%" CURL_PRIu64 "] send_body(len=%zu) " CURL_TRC_CF(data, cf, "[%" FMT_PRIu64 "] send_body(len=%zu) "
"-> window exhausted", stream->id, len); "-> window exhausted", stream->id, len);
stream->quic_flow_blocked = TRUE; stream->quic_flow_blocked = TRUE;
} }
@ -938,19 +938,19 @@ static ssize_t cf_quiche_send_body(struct Curl_cfilter *cf,
return -1; return -1;
} }
else if(nwritten == QUICHE_H3_TRANSPORT_ERR_INVALID_STREAM_STATE) { else if(nwritten == QUICHE_H3_TRANSPORT_ERR_INVALID_STREAM_STATE) {
CURL_TRC_CF(data, cf, "[%" CURL_PRIu64 "] send_body(len=%zu) " CURL_TRC_CF(data, cf, "[%" FMT_PRIu64 "] send_body(len=%zu) "
"-> invalid stream state", stream->id, len); "-> invalid stream state", stream->id, len);
*err = CURLE_HTTP3; *err = CURLE_HTTP3;
return -1; return -1;
} }
else if(nwritten == QUICHE_H3_TRANSPORT_ERR_FINAL_SIZE) { else if(nwritten == QUICHE_H3_TRANSPORT_ERR_FINAL_SIZE) {
CURL_TRC_CF(data, cf, "[%" CURL_PRIu64 "] send_body(len=%zu) " CURL_TRC_CF(data, cf, "[%" FMT_PRIu64 "] send_body(len=%zu) "
"-> exceeds size", stream->id, len); "-> exceeds size", stream->id, len);
*err = CURLE_SEND_ERROR; *err = CURLE_SEND_ERROR;
return -1; return -1;
} }
else if(nwritten < 0) { else if(nwritten < 0) {
CURL_TRC_CF(data, cf, "[%" CURL_PRIu64 "] send_body(len=%zu) " CURL_TRC_CF(data, cf, "[%" FMT_PRIu64 "] send_body(len=%zu) "
"-> quiche err %zd", stream->id, len, nwritten); "-> quiche err %zd", stream->id, len, nwritten);
*err = CURLE_SEND_ERROR; *err = CURLE_SEND_ERROR;
return -1; return -1;
@ -958,7 +958,7 @@ static ssize_t cf_quiche_send_body(struct Curl_cfilter *cf,
else { else {
if(eos && (len == (size_t)nwritten)) if(eos && (len == (size_t)nwritten))
stream->send_closed = TRUE; stream->send_closed = TRUE;
CURL_TRC_CF(data, cf, "[%" CURL_PRIu64 "] send body(len=%zu, " CURL_TRC_CF(data, cf, "[%" FMT_PRIu64 "] send body(len=%zu, "
"eos=%d) -> %zd", "eos=%d) -> %zd",
stream->id, len, stream->send_closed, nwritten); stream->id, len, stream->send_closed, nwritten);
*err = CURLE_OK; *err = CURLE_OK;
@ -1037,14 +1037,14 @@ static ssize_t h3_open_stream(struct Curl_cfilter *cf,
if(QUICHE_H3_ERR_STREAM_BLOCKED == stream3_id) { if(QUICHE_H3_ERR_STREAM_BLOCKED == stream3_id) {
/* quiche seems to report this error if the connection window is /* quiche seems to report this error if the connection window is
* exhausted. Which happens frequently and intermittent. */ * exhausted. Which happens frequently and intermittent. */
CURL_TRC_CF(data, cf, "[%"CURL_PRIu64"] blocked", stream->id); CURL_TRC_CF(data, cf, "[%"FMT_PRIu64"] blocked", stream->id);
stream->quic_flow_blocked = TRUE; stream->quic_flow_blocked = TRUE;
*err = CURLE_AGAIN; *err = CURLE_AGAIN;
nwritten = -1; nwritten = -1;
goto out; goto out;
} }
else { else {
CURL_TRC_CF(data, cf, "send_request(%s) -> %" CURL_PRIu64, CURL_TRC_CF(data, cf, "send_request(%s) -> %" FMT_PRIu64,
data->state.url, stream3_id); data->state.url, stream3_id);
} }
*err = CURLE_SEND_ERROR; *err = CURLE_SEND_ERROR;
@ -1060,10 +1060,10 @@ static ssize_t h3_open_stream(struct Curl_cfilter *cf,
stream->reset = FALSE; stream->reset = FALSE;
if(Curl_trc_is_verbose(data)) { if(Curl_trc_is_verbose(data)) {
infof(data, "[HTTP/3] [%" CURL_PRIu64 "] OPENED stream for %s", infof(data, "[HTTP/3] [%" FMT_PRIu64 "] OPENED stream for %s",
stream->id, data->state.url); stream->id, data->state.url);
for(i = 0; i < nheader; ++i) { for(i = 0; i < nheader; ++i) {
infof(data, "[HTTP/3] [%" CURL_PRIu64 "] [%.*s: %.*s]", stream->id, infof(data, "[HTTP/3] [%" FMT_PRIu64 "] [%.*s: %.*s]", stream->id,
(int)nva[i].name_len, nva[i].name, (int)nva[i].name_len, nva[i].name,
(int)nva[i].value_len, nva[i].value); (int)nva[i].value_len, nva[i].value);
} }
@ -1124,13 +1124,13 @@ static ssize_t cf_quiche_send(struct Curl_cfilter *cf, struct Curl_easy *data,
* sending the 30x response. * sending the 30x response.
* This is sort of a race: had the transfer loop called recv first, * This is sort of a race: had the transfer loop called recv first,
* it would see the response and stop/discard sending on its own- */ * it would see the response and stop/discard sending on its own- */
CURL_TRC_CF(data, cf, "[%" CURL_PRIu64 "] discarding data" CURL_TRC_CF(data, cf, "[%" FMT_PRIu64 "] discarding data"
"on closed stream with response", stream->id); "on closed stream with response", stream->id);
*err = CURLE_OK; *err = CURLE_OK;
nwritten = (ssize_t)len; nwritten = (ssize_t)len;
goto out; goto out;
} }
CURL_TRC_CF(data, cf, "[%" CURL_PRIu64 "] send_body(len=%zu) " CURL_TRC_CF(data, cf, "[%" FMT_PRIu64 "] send_body(len=%zu) "
"-> stream closed", stream->id, len); "-> stream closed", stream->id, len);
*err = CURLE_HTTP3; *err = CURLE_HTTP3;
nwritten = -1; nwritten = -1;
@ -1146,7 +1146,7 @@ out:
*err = result; *err = result;
nwritten = -1; nwritten = -1;
} }
CURL_TRC_CF(data, cf, "[%" CURL_PRIu64 "] cf_send(len=%zu) -> %zd, %d", CURL_TRC_CF(data, cf, "[%" FMT_PRIu64 "] cf_send(len=%zu) -> %zd, %d",
stream? stream->id : (curl_uint64_t)~0, len, nwritten, *err); stream? stream->id : (curl_uint64_t)~0, len, nwritten, *err);
return nwritten; return nwritten;
} }
@ -1244,7 +1244,7 @@ static CURLcode cf_quiche_data_event(struct Curl_cfilter *cf,
stream->send_closed = TRUE; stream->send_closed = TRUE;
body[0] = 'X'; body[0] = 'X';
sent = cf_quiche_send(cf, data, body, 0, TRUE, &result); sent = cf_quiche_send(cf, data, body, 0, TRUE, &result);
CURL_TRC_CF(data, cf, "[%"CURL_PRIu64"] DONE_SEND -> %zd, %d", CURL_TRC_CF(data, cf, "[%"FMT_PRIu64"] DONE_SEND -> %zd, %d",
stream->id, sent, result); stream->id, sent, result);
} }
break; break;
@ -1555,7 +1555,7 @@ static CURLcode cf_quiche_query(struct Curl_cfilter *cf,
max_streams += quiche_conn_peer_streams_left_bidi(ctx->qconn); max_streams += quiche_conn_peer_streams_left_bidi(ctx->qconn);
} }
*pres1 = (max_streams > INT_MAX)? INT_MAX : (int)max_streams; *pres1 = (max_streams > INT_MAX)? INT_MAX : (int)max_streams;
CURL_TRC_CF(data, cf, "query conn[%" CURL_FORMAT_CURL_OFF_T "]: " CURL_TRC_CF(data, cf, "query conn[%" FMT_OFF_T "]: "
"MAX_CONCURRENT -> %d (%zu in use)", "MAX_CONCURRENT -> %d (%zu in use)",
cf->conn->connection_id, *pres1, CONN_INUSE(cf->conn)); cf->conn->connection_id, *pres1, CONN_INUSE(cf->conn));
return CURLE_OK; return CURLE_OK;

19
lib/vssh/libssh.c
View File

@ -1236,7 +1236,7 @@ static CURLcode myssh_statemach_act(struct Curl_easy *data, bool *block)
if(attrs) { if(attrs) {
curl_off_t size = attrs->size; curl_off_t size = attrs->size;
if(size < 0) { if(size < 0) {
failf(data, "Bad file size (%" CURL_FORMAT_CURL_OFF_T ")", size); failf(data, "Bad file size (%" FMT_OFF_T ")", size);
MOVE_TO_ERROR_STATE(CURLE_BAD_DOWNLOAD_RESUME); MOVE_TO_ERROR_STATE(CURLE_BAD_DOWNLOAD_RESUME);
break; break;
} }
@ -1621,7 +1621,7 @@ static CURLcode myssh_statemach_act(struct Curl_easy *data, bool *block)
sftp_attributes_free(attrs); sftp_attributes_free(attrs);
if(size < 0) { if(size < 0) {
failf(data, "Bad file size (%" CURL_FORMAT_CURL_OFF_T ")", size); failf(data, "Bad file size (%" FMT_OFF_T ")", size);
return CURLE_BAD_DOWNLOAD_RESUME; return CURLE_BAD_DOWNLOAD_RESUME;
} }
if(data->state.use_range) { if(data->state.use_range) {
@ -1651,9 +1651,8 @@ static CURLcode myssh_statemach_act(struct Curl_easy *data, bool *block)
to = size - 1; to = size - 1;
} }
if(from > size) { if(from > size) {
failf(data, "Offset (%" failf(data, "Offset (%" FMT_OFF_T ") was beyond file size (%"
CURL_FORMAT_CURL_OFF_T ") was beyond file size (%" FMT_OFF_T ")", from, size);
CURL_FORMAT_CURL_OFF_T ")", from, size);
return CURLE_BAD_DOWNLOAD_RESUME; return CURLE_BAD_DOWNLOAD_RESUME;
} }
if(from > to) { if(from > to) {
@ -1682,10 +1681,8 @@ static CURLcode myssh_statemach_act(struct Curl_easy *data, bool *block)
if(data->state.resume_from < 0) { if(data->state.resume_from < 0) {
/* We are supposed to download the last abs(from) bytes */ /* We are supposed to download the last abs(from) bytes */
if((curl_off_t)size < -data->state.resume_from) { if((curl_off_t)size < -data->state.resume_from) {
failf(data, "Offset (%" failf(data, "Offset (%" FMT_OFF_T ") was beyond file size (%"
CURL_FORMAT_CURL_OFF_T ") was beyond file size (%" FMT_OFF_T ")", data->state.resume_from, size);
CURL_FORMAT_CURL_OFF_T ")",
data->state.resume_from, size);
return CURLE_BAD_DOWNLOAD_RESUME; return CURLE_BAD_DOWNLOAD_RESUME;
} }
/* download from where? */ /* download from where? */
@ -1693,8 +1690,8 @@ static CURLcode myssh_statemach_act(struct Curl_easy *data, bool *block)
} }
else { else {
if((curl_off_t)size < data->state.resume_from) { if((curl_off_t)size < data->state.resume_from) {
failf(data, "Offset (%" CURL_FORMAT_CURL_OFF_T failf(data, "Offset (%" FMT_OFF_T
") was beyond file size (%" CURL_FORMAT_CURL_OFF_T ")", ") was beyond file size (%" FMT_OFF_T ")",
data->state.resume_from, size); data->state.resume_from, size);
return CURLE_BAD_DOWNLOAD_RESUME; return CURLE_BAD_DOWNLOAD_RESUME;
} }

19
lib/vssh/libssh2.c
View File

@ -2066,7 +2066,7 @@ static CURLcode ssh_statemach_act(struct Curl_easy *data, bool *block)
else { else {
curl_off_t size = attrs.filesize; curl_off_t size = attrs.filesize;
if(size < 0) { if(size < 0) {
failf(data, "Bad file size (%" CURL_FORMAT_CURL_OFF_T ")", size); failf(data, "Bad file size (%" FMT_OFF_T ")", size);
return CURLE_BAD_DOWNLOAD_RESUME; return CURLE_BAD_DOWNLOAD_RESUME;
} }
data->state.resume_from = attrs.filesize; data->state.resume_from = attrs.filesize;
@ -2507,7 +2507,7 @@ static CURLcode ssh_statemach_act(struct Curl_easy *data, bool *block)
curl_off_t size = attrs.filesize; curl_off_t size = attrs.filesize;
if(size < 0) { if(size < 0) {
failf(data, "Bad file size (%" CURL_FORMAT_CURL_OFF_T ")", size); failf(data, "Bad file size (%" FMT_OFF_T ")", size);
return CURLE_BAD_DOWNLOAD_RESUME; return CURLE_BAD_DOWNLOAD_RESUME;
} }
if(data->state.use_range) { if(data->state.use_range) {
@ -2535,10 +2535,8 @@ static CURLcode ssh_statemach_act(struct Curl_easy *data, bool *block)
to = size - 1; to = size - 1;
} }
if(from > size) { if(from > size) {
failf(data, "Offset (%" failf(data, "Offset (%" FMT_OFF_T ") was beyond file size (%"
CURL_FORMAT_CURL_OFF_T ") was beyond file size (%" FMT_OFF_T ")", from, (curl_off_t)attrs.filesize);
CURL_FORMAT_CURL_OFF_T ")", from,
(curl_off_t)attrs.filesize);
return CURLE_BAD_DOWNLOAD_RESUME; return CURLE_BAD_DOWNLOAD_RESUME;
} }
if(from > to) { if(from > to) {
@ -2563,9 +2561,8 @@ static CURLcode ssh_statemach_act(struct Curl_easy *data, bool *block)
if(data->state.resume_from < 0) { if(data->state.resume_from < 0) {
/* We are supposed to download the last abs(from) bytes */ /* We are supposed to download the last abs(from) bytes */
if((curl_off_t)attrs.filesize < -data->state.resume_from) { if((curl_off_t)attrs.filesize < -data->state.resume_from) {
failf(data, "Offset (%" failf(data, "Offset (%" FMT_OFF_T ") was beyond file size (%"
CURL_FORMAT_CURL_OFF_T ") was beyond file size (%" FMT_OFF_T ")",
CURL_FORMAT_CURL_OFF_T ")",
data->state.resume_from, (curl_off_t)attrs.filesize); data->state.resume_from, (curl_off_t)attrs.filesize);
return CURLE_BAD_DOWNLOAD_RESUME; return CURLE_BAD_DOWNLOAD_RESUME;
} }
@ -2574,8 +2571,8 @@ static CURLcode ssh_statemach_act(struct Curl_easy *data, bool *block)
} }
else { else {
if((curl_off_t)attrs.filesize < data->state.resume_from) { if((curl_off_t)attrs.filesize < data->state.resume_from) {
failf(data, "Offset (%" CURL_FORMAT_CURL_OFF_T failf(data, "Offset (%" FMT_OFF_T
") was beyond file size (%" CURL_FORMAT_CURL_OFF_T ")", ") was beyond file size (%" FMT_OFF_T ")",
data->state.resume_from, (curl_off_t)attrs.filesize); data->state.resume_from, (curl_off_t)attrs.filesize);
return CURLE_BAD_DOWNLOAD_RESUME; return CURLE_BAD_DOWNLOAD_RESUME;
} }

6
lib/vssh/wolfssh.c
View File

@ -281,7 +281,7 @@ static ssize_t wsftp_send(struct Curl_easy *data, int sockindex,
return -1; return -1;
} }
DEBUGASSERT(rc == (int)len); DEBUGASSERT(rc == (int)len);
infof(data, "sent %zu bytes SFTP from offset %" CURL_FORMAT_CURL_OFF_T, infof(data, "sent %zu bytes SFTP from offset %" FMT_OFF_T,
len, sshc->offset); len, sshc->offset);
sshc->offset += len; sshc->offset += len;
return (ssize_t)rc; return (ssize_t)rc;
@ -578,7 +578,7 @@ static CURLcode wssh_statemach_act(struct Curl_easy *data, bool *block)
else { else {
curl_off_t size = ((curl_off_t)attrs.sz[1] << 32) | attrs.sz[0]; curl_off_t size = ((curl_off_t)attrs.sz[1] << 32) | attrs.sz[0];
if(size < 0) { if(size < 0) {
failf(data, "Bad file size (%" CURL_FORMAT_CURL_OFF_T ")", size); failf(data, "Bad file size (%" FMT_OFF_T ")", size);
return CURLE_BAD_DOWNLOAD_RESUME; return CURLE_BAD_DOWNLOAD_RESUME;
} }
data->state.resume_from = size; data->state.resume_from = size;
@ -769,7 +769,7 @@ static CURLcode wssh_statemach_act(struct Curl_easy *data, bool *block)
data->req.maxdownload = size; data->req.maxdownload = size;
Curl_pgrsSetDownloadSize(data, size); Curl_pgrsSetDownloadSize(data, size);
infof(data, "SFTP download %" CURL_FORMAT_CURL_OFF_T " bytes", size); infof(data, "SFTP download %" FMT_OFF_T " bytes", size);
/* We cannot seek with wolfSSH so resuming and range requests are not /* We cannot seek with wolfSSH so resuming and range requests are not
possible */ possible */

4
lib/vtls/rustls.c
View File

@ -856,8 +856,8 @@ cr_connect_common(struct Curl_cfilter *cf,
return CURLE_SSL_CONNECT_ERROR; return CURLE_SSL_CONNECT_ERROR;
} }
if(blocking && 0 == what) { if(blocking && 0 == what) {
failf(data, "rustls: connection timeout after %" failf(data, "rustls: connection timeout after %" FMT_TIMEDIFF_T " ms",
CURL_FORMAT_TIMEDIFF_T " ms", socket_check_timeout); socket_check_timeout);
return CURLE_OPERATION_TIMEDOUT; return CURLE_OPERATION_TIMEDOUT;
} }
if(0 == what) { if(0 == what) {

8
lib/vtls/vtls.c
View File

@ -784,13 +784,13 @@ void Curl_ssl_adjust_pollset(struct Curl_cfilter *cf, struct Curl_easy *data,
if(sock != CURL_SOCKET_BAD) { if(sock != CURL_SOCKET_BAD) {
if(connssl->io_need & CURL_SSL_IO_NEED_SEND) { if(connssl->io_need & CURL_SSL_IO_NEED_SEND) {
Curl_pollset_set_out_only(data, ps, sock); Curl_pollset_set_out_only(data, ps, sock);
CURL_TRC_CF(data, cf, "adjust_pollset, POLLOUT fd=%" CURL_TRC_CF(data, cf, "adjust_pollset, POLLOUT fd=%" FMT_SOCKET_T,
CURL_FORMAT_SOCKET_T, sock); sock);
} }
else { else {
Curl_pollset_set_in_only(data, ps, sock); Curl_pollset_set_in_only(data, ps, sock);
CURL_TRC_CF(data, cf, "adjust_pollset, POLLIN fd=%" CURL_TRC_CF(data, cf, "adjust_pollset, POLLIN fd=%" FMT_SOCKET_T,
CURL_FORMAT_SOCKET_T, sock); sock);
} }
} }
} }

17
lib/ws.c
View File

@ -128,7 +128,7 @@ static void ws_dec_info(struct ws_decoder *dec, struct Curl_easy *data,
} }
else { else {
CURL_TRC_WRITE(data, "websocket, decoded %s [%s%s payload=%" CURL_TRC_WRITE(data, "websocket, decoded %s [%s%s payload=%"
CURL_FORMAT_CURL_OFF_T "/%" CURL_FORMAT_CURL_OFF_T "]", FMT_OFF_T "/%" FMT_OFF_T "]",
msg, ws_frame_name_of_op(dec->head[0]), msg, ws_frame_name_of_op(dec->head[0]),
(dec->head[0] & WSBIT_FIN)? "" : " NON-FINAL", (dec->head[0] & WSBIT_FIN)? "" : " NON-FINAL",
dec->payload_offset, dec->payload_len); dec->payload_offset, dec->payload_len);
@ -282,7 +282,7 @@ static CURLcode ws_dec_pass_payload(struct ws_decoder *dec,
dec->payload_offset += (curl_off_t)nwritten; dec->payload_offset += (curl_off_t)nwritten;
remain = dec->payload_len - dec->payload_offset; remain = dec->payload_len - dec->payload_offset;
CURL_TRC_WRITE(data, "websocket, passed %zd bytes payload, %" CURL_TRC_WRITE(data, "websocket, passed %zd bytes payload, %"
CURL_FORMAT_CURL_OFF_T " remain", nwritten, remain); FMT_OFF_T " remain", nwritten, remain);
} }
return remain? CURLE_AGAIN : CURLE_OK; return remain? CURLE_AGAIN : CURLE_OK;
@ -492,8 +492,7 @@ static const struct Curl_cwtype ws_cw_decode = {
static void ws_enc_info(struct ws_encoder *enc, struct Curl_easy *data, static void ws_enc_info(struct ws_encoder *enc, struct Curl_easy *data,
const char *msg) const char *msg)
{ {
infof(data, "WS-ENC: %s [%s%s%s payload=%" CURL_FORMAT_CURL_OFF_T infof(data, "WS-ENC: %s [%s%s%s payload=%" FMT_OFF_T "/%" FMT_OFF_T "]",
"/%" CURL_FORMAT_CURL_OFF_T "]",
msg, ws_frame_name_of_op(enc->firstbyte), msg, ws_frame_name_of_op(enc->firstbyte),
(enc->firstbyte & WSBIT_OPCODE_MASK) == WSBIT_OPCODE_CONT ? (enc->firstbyte & WSBIT_OPCODE_MASK) == WSBIT_OPCODE_CONT ?
" CONT" : "", " CONT" : "",
@ -551,7 +550,7 @@ static ssize_t ws_enc_write_head(struct Curl_easy *data,
if(payload_len < 0) { if(payload_len < 0) {
failf(data, "WS: starting new frame with negative payload length %" failf(data, "WS: starting new frame with negative payload length %"
CURL_FORMAT_CURL_OFF_T, payload_len); FMT_OFF_T, payload_len);
*err = CURLE_SEND_ERROR; *err = CURLE_SEND_ERROR;
return -1; return -1;
} }
@ -1006,7 +1005,7 @@ CURL_EXTERN CURLcode curl_ws_recv(struct Curl_easy *data, void *buffer,
*metap = &ws->frame; *metap = &ws->frame;
*nread = ws->frame.len; *nread = ws->frame.len;
CURL_TRC_WS(data, "curl_ws_recv(len=%zu) -> %zu bytes (frame at %" CURL_TRC_WS(data, "curl_ws_recv(len=%zu) -> %zu bytes (frame at %"
CURL_FORMAT_CURL_OFF_T ", %" CURL_FORMAT_CURL_OFF_T " left)", FMT_OFF_T ", %" FMT_OFF_T " left)",
buflen, *nread, ws->frame.offset, ws->frame.bytesleft); buflen, *nread, ws->frame.offset, ws->frame.bytesleft);
return CURLE_OK; return CURLE_OK;
} }
@ -1137,7 +1136,7 @@ CURL_EXTERN CURLcode curl_ws_send(CURL *data, const void *buffer,
size_t space, payload_added; size_t space, payload_added;
CURLcode result; CURLcode result;
CURL_TRC_WS(data, "curl_ws_send(len=%zu, fragsize=%" CURL_FORMAT_CURL_OFF_T CURL_TRC_WS(data, "curl_ws_send(len=%zu, fragsize=%" FMT_OFF_T
", flags=%x), raw=%d", ", flags=%x), raw=%d",
buflen, fragsize, flags, data->set.ws_raw_mode); buflen, fragsize, flags, data->set.ws_raw_mode);
*sent = 0; *sent = 0;
@ -1193,7 +1192,7 @@ CURL_EXTERN CURLcode curl_ws_send(CURL *data, const void *buffer,
else { else {
if((curl_off_t)buflen > ws->enc.payload_remain) { if((curl_off_t)buflen > ws->enc.payload_remain) {
infof(data, "WS: unaligned frame size (sending %zu instead of %" infof(data, "WS: unaligned frame size (sending %zu instead of %"
CURL_FORMAT_CURL_OFF_T ")", FMT_OFF_T ")",
buflen, ws->enc.payload_remain); buflen, ws->enc.payload_remain);
} }
} }
@ -1258,7 +1257,7 @@ CURL_EXTERN CURLcode curl_ws_send(CURL *data, const void *buffer,
} }
out: out:
CURL_TRC_WS(data, "curl_ws_send(len=%zu, fragsize=%" CURL_FORMAT_CURL_OFF_T CURL_TRC_WS(data, "curl_ws_send(len=%zu, fragsize=%" FMT_OFF_T
", flags=%x, raw=%d) -> %d, %zu", ", flags=%x, raw=%d) -> %d, %zu",
buflen, fragsize, flags, data->set.ws_raw_mode, result, *sent); buflen, fragsize, flags, data->set.ws_raw_mode, result, *sent);
return result; return result;

6
tests/server/mqttd.c
View File

@ -766,11 +766,11 @@ static bool incoming(curl_socket_t listenfd)
curl_socket_t newfd = accept(sockfd, NULL, NULL); curl_socket_t newfd = accept(sockfd, NULL, NULL);
if(CURL_SOCKET_BAD == newfd) { if(CURL_SOCKET_BAD == newfd) {
error = SOCKERRNO; error = SOCKERRNO;
logmsg("accept(%" CURL_FORMAT_SOCKET_T ", NULL, NULL) " logmsg("accept(%" FMT_SOCKET_T ", NULL, NULL) "
"failed with error: (%d) %s", sockfd, error, sstrerror(error)); "failed with error: (%d) %s", sockfd, error, sstrerror(error));
} }
else { else {
logmsg("====> Client connect, fd %" CURL_FORMAT_SOCKET_T ". " logmsg("====> Client connect, fd %" FMT_SOCKET_T ". "
"Read config from %s", newfd, configfile); "Read config from %s", newfd, configfile);
set_advisor_read_lock(loglockfile); set_advisor_read_lock(loglockfile);
(void)mqttit(newfd); /* until done */ (void)mqttit(newfd); /* until done */
@ -909,7 +909,7 @@ static curl_socket_t sockdaemon(curl_socket_t sock,
rc = listen(sock, 5); rc = listen(sock, 5);
if(0 != rc) { if(0 != rc) {
error = SOCKERRNO; error = SOCKERRNO;
logmsg("listen(%" CURL_FORMAT_SOCKET_T ", 5) failed with error: (%d) %s", logmsg("listen(%" FMT_SOCKET_T ", 5) failed with error: (%d) %s",
sock, error, sstrerror(error)); sock, error, sstrerror(error));
sclose(sock); sclose(sock);
return CURL_SOCKET_BAD; return CURL_SOCKET_BAD;

4
tests/server/sockfilt.c
View File

@ -1155,7 +1155,7 @@ static bool juggle(curl_socket_t *sockfdp,
curl_socket_t newfd = accept(sockfd, NULL, NULL); curl_socket_t newfd = accept(sockfd, NULL, NULL);
if(CURL_SOCKET_BAD == newfd) { if(CURL_SOCKET_BAD == newfd) {
error = SOCKERRNO; error = SOCKERRNO;
logmsg("accept(%" CURL_FORMAT_SOCKET_T ", NULL, NULL) " logmsg("accept(%" FMT_SOCKET_T ", NULL, NULL) "
"failed with error: (%d) %s", sockfd, error, sstrerror(error)); "failed with error: (%d) %s", sockfd, error, sstrerror(error));
} }
else { else {
@ -1331,7 +1331,7 @@ static curl_socket_t sockdaemon(curl_socket_t sock,
rc = listen(sock, 5); rc = listen(sock, 5);
if(0 != rc) { if(0 != rc) {
error = SOCKERRNO; error = SOCKERRNO;
logmsg("listen(%" CURL_FORMAT_SOCKET_T ", 5) failed with error: (%d) %s", logmsg("listen(%" FMT_SOCKET_T ", 5) failed with error: (%d) %s",
sock, error, sstrerror(error)); sock, error, sstrerror(error));
sclose(sock); sclose(sock);
return CURL_SOCKET_BAD; return CURL_SOCKET_BAD;

6
tests/server/socksd.c
View File

@ -751,13 +751,13 @@ static bool incoming(curl_socket_t listenfd)
curl_socket_t newfd = accept(sockfd, NULL, NULL); curl_socket_t newfd = accept(sockfd, NULL, NULL);
if(CURL_SOCKET_BAD == newfd) { if(CURL_SOCKET_BAD == newfd) {
error = SOCKERRNO; error = SOCKERRNO;
logmsg("accept(%" CURL_FORMAT_SOCKET_T ", NULL, NULL) " logmsg("accept(%" FMT_SOCKET_T ", NULL, NULL) "
"failed with error: (%d) %s", "failed with error: (%d) %s",
sockfd, error, sstrerror(error)); sockfd, error, sstrerror(error));
} }
else { else {
curl_socket_t remotefd; curl_socket_t remotefd;
logmsg("====> Client connect, fd %" CURL_FORMAT_SOCKET_T ". " logmsg("====> Client connect, fd %" FMT_SOCKET_T ". "
"Read config from %s", newfd, configfile); "Read config from %s", newfd, configfile);
remotefd = sockit(newfd); /* SOCKS until done */ remotefd = sockit(newfd); /* SOCKS until done */
if(remotefd == CURL_SOCKET_BAD) { if(remotefd == CURL_SOCKET_BAD) {
@ -941,7 +941,7 @@ static curl_socket_t sockdaemon(curl_socket_t sock,
rc = listen(sock, 5); rc = listen(sock, 5);
if(0 != rc) { if(0 != rc) {
error = SOCKERRNO; error = SOCKERRNO;
logmsg("listen(%" CURL_FORMAT_SOCKET_T ", 5) failed with error: (%d) %s", logmsg("listen(%" FMT_SOCKET_T ", 5) failed with error: (%d) %s",
sock, error, sstrerror(error)); sock, error, sstrerror(error));
sclose(sock); sclose(sock);
return CURL_SOCKET_BAD; return CURL_SOCKET_BAD;

4
tests/server/sws.c
View File

@ -2331,8 +2331,8 @@ int main(int argc, char *argv[])
curl_socket_t msgsock; curl_socket_t msgsock;
do { do {
msgsock = accept_connection(sock); msgsock = accept_connection(sock);
logmsg("accept_connection %" CURL_FORMAT_SOCKET_T logmsg("accept_connection %" FMT_SOCKET_T
" returned %" CURL_FORMAT_SOCKET_T, sock, msgsock); " returned %" FMT_SOCKET_T, sock, msgsock);
if(CURL_SOCKET_BAD == msgsock) if(CURL_SOCKET_BAD == msgsock)
goto sws_cleanup; goto sws_cleanup;
if(req->delay) if(req->delay)