Use `data->progress.now` as the timestamp of proecssing a transfer.
Update it on significant events and refrain from calling `curlx_now()`
in many places.
The problem this addresses is
a) calling curlx_now() has costs, depending on platform. Calling it
every time results in 25% increase `./runtest` duration on macOS.
b) we used to pass a `struct curltime *` around to save on calls, but
when some method directly use `curx_now()` and some use the passed
pointer, the transfer experienes non-linear time. This results in
timeline checks to report events in the wrong order.
By keeping a timestamp in the easy handle and updating it there, no
longer invoking `curlx_now()` in the "lower" methods, the transfer
can observer a steady clock progression.
Add documentation in docs/internals/TIME-KEEPING.md
Reported-by: Viktor Szakats
Fixes #19935
Closes #19961
internals/SCORECARD.md \
internals/SPLAY.md \
internals/STRPARSE.md \
+ internals/TIME-KEEPING.md \
internals/TLS-SESSIONS.md \
internals/UINT_SETS.md \
internals/WEBSOCKET.md
--- /dev/null
+<!--
+Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+
+SPDX-License-Identifier: curl
+-->
+
+# Keeping Time
+
+Transfers need the current time to handle timeouts and keep a record of events. The current
+time function is `curlx_now()` and it uses a **monotonic** clock on most platforms. This
+ensures that time only ever increases (the timestamps it gives are however not the "real"
+world clock).
+
+The simplest handling of transfer time would be to just always call `curlx_now()`. However
+there is a performance penalty to that - varying by platform - so this is not a desirable
+strategy. Processing thousands of transfers in a loop needs a smarter approach.
+
+## Initial Approach (now historic)
+
+The loop processing functions called `curlx_now()` at the beginning and then passed
+a pointer to the `struct curltime now` to functions to save them the calls. Passing
+this pointer down to all functions possibly involved was not done as this pollutes
+the internal APIs.
+
+So, some functions continued to call `curlx_now()` on their own while others used the
+passed pointer *to a timestamp in the past*. This led to a transfer experiencing *jumps*
+in time, reversing cause and effect. On fast systems, this was mostly not noticeable. On
+slow machines or in CI, this led to rare and annoying test failures.
+
+(Especially when we added assertions that the reported "timeline" of a transfer was
+in the correct order: *queue -> nameloopup -> connect -> appconnect ->...*.)
+
+## Revised Approach
+
+The strategy of handling transfer's time is now:
+
+* Keep a "now" timestamp in `data->progress.now`.
+* Perform time checks and event recording using `data->progress.now`.
+* Set `data->progress.now` at the start of API calls (e.g. `curl_multi_perform()`, etc.).
+* Set `data->progress.now` when recorded events happen (for precision).
+* Set `data->progress.now` on multi state changes.
+* Set `data->progress.now` in `pingpong` timeout handling, since `pingpong` is old and not always non-blocking.
+
+In addition to *setting* `data->progress.now` this timestamp can be *advanced* using 2 new methods:
+
+* `Curl_pgrs_now_at_least(data, &now)`: code that has a "now" timestamp can progress the `data`'s own "now" to be at least as new. If `data->progress.now` is already newer, no change is done. A transfer never goes **back**.
+* `Curl_pgrs_now_update(data1, data2)`: update the "now" in `data1` to be at least as new as the one in `data2`. If it already is newer, nothing changes.
+
+### Time Advancing Loops
+
+This advancing is used in the following way in loop like `curl_multi_perform()`:
+
+```C
+struct curltime now = curlx_now(); /* start of API call */
+forall data in transfers {
+ Curl_pgrs_set_at_least(data, now);
+ progress(data); /* may update "now" */
+ now = data->progress.now;
+}
+```
+
+Transfers that update their "now" pass that timestamp to the next transfer processed.
+
+### Transfers triggering other transfers
+
+In HTTP/2 and HTTP/3 processing, incoming data causes actions on transfers other than
+the calling one. The protocols may receive data for any transfer on the connection and need
+to dispatch it:
+
+* a Close/Reset comes in for another transfer. That transfer is marked as "dirty", making sure it is processed in a timely manner.
+* Response Data arrives: this data is written out to the client. Before this is done, the "now" timestamp is updated via `Curl_pgrs_now_update(data, calling)` from the "calling" transfer.
+
+## Blocking Operations
+
+We still have places in `libcurl` where we do blocking operations. We should always use `Curl_pgrs_now_set(data)` afterwards since we cannot be sure how much time has passed. Since loop processing passed an updated "now" to the next transfer, a delay due to blocking is passed on.
+
+There are other places where we may lose track of time:
+
+* Cache/Pool Locks: no "now" updates happen after a lock has been acquired. These locks should not be kept for a longer time.
+* User Callbacks: no "now" updates happen after callbacks have been invoked. The expectation is that those do not take long.
+
+Should these assumptions prove wrong, we need to add updates.
/* This is only set to non-zero if the timer was started. */
(ares->happy_eyeballs_dns_time.tv_sec ||
ares->happy_eyeballs_dns_time.tv_usec) &&
- (curlx_timediff_ms(curlx_now(), ares->happy_eyeballs_dns_time) >=
+ (curlx_timediff_ms(data->progress.now, ares->happy_eyeballs_dns_time) >=
HAPPY_EYEBALLS_DNS_TIMEOUT)) {
/* Remember that the EXPIRE_HAPPY_EYEBALLS_DNS timer is no longer
running. */
struct async_ares_ctx *ares = &data->state.async.ares;
CURLcode result = CURLE_OK;
timediff_t timeout_ms;
- struct curltime now = curlx_now();
DEBUGASSERT(entry);
*entry = NULL; /* clear on entry */
- timeout_ms = Curl_timeleft_ms(data, &now, TRUE);
+ timeout_ms = Curl_timeleft_ms(data, TRUE);
if(timeout_ms < 0) {
/* already expired! */
connclose(data->conn, "Timed out before name resolve started");
if(Curl_pgrsUpdate(data))
result = CURLE_ABORTED_BY_CALLBACK;
else {
- struct curltime now2 = curlx_now();
- timediff_t elapsed_ms = curlx_timediff_ms(now2, now); /* spent time */
+ struct curltime now = curlx_now(); /* update in loop */
+ timediff_t elapsed_ms = curlx_timediff_ms(now, data->progress.now);
if(elapsed_ms <= 0)
timeout_ms -= 1; /* always deduct at least 1 */
else if(elapsed_ms > timeout_ms)
timeout_ms = -1;
else
timeout_ms -= elapsed_ms;
- now = now2; /* for next loop */
+ Curl_pgrs_now_at_least(data, &now);
}
if(timeout_ms < 0)
result = CURLE_OPERATION_TIMEDOUT;
timeout to prevent it. After all, we do not even know where in the
c-ares retry cycle each request is.
*/
- ares->happy_eyeballs_dns_time = curlx_now();
+ ares->happy_eyeballs_dns_time = data->progress.now;
Curl_expire(data, HAPPY_EYEBALLS_DNS_TIMEOUT, EXPIRE_HAPPY_EYEBALLS_DNS);
}
}
/* passing addr_ctx to the thread adds a reference */
addr_ctx->ref_count = 2;
- addr_ctx->start = curlx_now();
+ addr_ctx->start = data->progress.now;
#ifdef HAVE_GETADDRINFO
addr_ctx->thread_hnd = Curl_thread_create(getaddrinfo_thread, addr_ctx);
else {
/* poll for name lookup done with exponential backoff up to 250ms */
/* should be fine even if this converts to 32-bit */
- timediff_t elapsed = curlx_timediff_ms(curlx_now(),
+ timediff_t elapsed = curlx_timediff_ms(data->progress.now,
data->progress.t_startsingle);
if(elapsed < 0)
elapsed = 0;
result = Curl_pollset_add_in(data, ps, thrdd->addr->sock_pair[0]);
#else
timediff_t milli;
- timediff_t ms = curlx_timediff_ms(curlx_now(), thrdd->addr->start);
+ timediff_t ms = curlx_timediff_ms(data->progress.now, thrdd->addr->start);
if(ms < 3)
milli = 0;
else if(ms <= 50)
do {
- if(Curl_timeleft_ms(data, NULL, TRUE) < 0) {
+ if(Curl_timeleft_ms(data, TRUE) < 0) {
failf(data, "Proxy CONNECT aborted due to timeout");
result = CURLE_OPERATION_TIMEDOUT;
goto out;
}
DEBUGASSERT(ts->authority);
- if(Curl_timeleft_ms(data, NULL, TRUE) < 0) {
+ if(Curl_timeleft_ms(data, TRUE) < 0) {
failf(data, "Proxy CONNECT aborted due to timeout");
result = CURLE_OPERATION_TIMEDOUT;
goto out;
struct Curl_cfilter *save = cf->next;
cf->next = NULL;
- b->started = curlx_now();
+ b->started = data->progress.now;
switch(b->alpn_id) {
case ALPN_h3:
transport = TRNSPRT_QUIC;
if(reply_ms >= 0)
CURL_TRC_CF(data, cf, "connect+handshake %s: %dms, 1st data: %dms",
winner->name,
- (int)curlx_timediff_ms(curlx_now(),
+ (int)curlx_timediff_ms(data->progress.now,
winner->started), reply_ms);
else
CURL_TRC_CF(data, cf, "deferred handshake %s: %dms",
- winner->name, (int)curlx_timediff_ms(curlx_now(),
+ winner->name, (int)curlx_timediff_ms(data->progress.now,
winner->started));
/* install the winning filter below this one. */
bool *done)
{
struct cf_hc_ctx *ctx = cf->ctx;
- struct curltime now;
CURLcode result = CURLE_OK;
size_t i, failed_ballers;
}
*done = FALSE;
- now = curlx_now();
switch(ctx->state) {
case CF_HC_INIT:
DEBUGASSERT(!cf->next);
for(i = 0; i < ctx->baller_count; i++)
DEBUGASSERT(!ctx->ballers[i].cf);
CURL_TRC_CF(data, cf, "connect, init");
- ctx->started = now;
+ ctx->started = data->progress.now;
cf_hc_baller_init(&ctx->ballers[0], cf, data, ctx->ballers[0].transport);
if(ctx->baller_count > 1) {
Curl_expire(data, ctx->soft_eyeballs_timeout_ms, EXPIRE_ALPN_EYEBALLS);
}
}
- if(time_to_start_next(cf, data, 1, now)) {
+ if(time_to_start_next(cf, data, 1, data->progress.now)) {
cf_hc_baller_init(&ctx->ballers[1], cf, data, ctx->ballers[1].transport);
}
CURLcode result = CURLE_OK;
struct cf_ip_attempt *a = NULL, **panchor;
bool do_more;
- struct curltime now;
timediff_t next_expire_ms;
int i, inconclusive, ongoing;
return CURLE_OK;
evaluate:
- now = curlx_now();
ongoing = inconclusive = 0;
/* check if a running baller connects now */
/* no attempt connected yet, start another one? */
if(!ongoing) {
if(!bs->started.tv_sec && !bs->started.tv_usec)
- bs->started = now;
+ bs->started = data->progress.now;
do_more = TRUE;
}
else {
more_possible = cf_ai_iter_has_more(&bs->ipv6_iter);
#endif
do_more = more_possible &&
- (curlx_timediff_ms(now, bs->last_attempt_started) >=
- bs->attempt_delay_ms);
+ (curlx_timediff_ms(data->progress.now, bs->last_attempt_started) >=
+ bs->attempt_delay_ms);
if(do_more)
CURL_TRC_CF(data, cf, "happy eyeballs timeout expired, "
"start next attempt");
while(*panchor)
panchor = &((*panchor)->next);
*panchor = a;
- bs->last_attempt_started = now;
+ bs->last_attempt_started = data->progress.now;
bs->last_attempt_ai_family = ai_family;
/* and run everything again */
goto evaluate;
else if(inconclusive) {
/* tried all addresses, no success but some where inconclusive.
* Let's restart the inconclusive ones. */
- timediff_t since_ms = curlx_timediff_ms(now, bs->last_attempt_started);
+ timediff_t since_ms =
+ curlx_timediff_ms(data->progress.now, bs->last_attempt_started);
timediff_t delay_ms = bs->attempt_delay_ms - since_ms;
if(delay_ms <= 0) {
CURL_TRC_CF(data, cf, "all attempts inconclusive, restarting one");
CURL_TRC_CF(data, cf, "restarted baller %d -> %d", i, result);
if(result) /* serious failure */
goto out;
- bs->last_attempt_started = now;
+ bs->last_attempt_started = data->progress.now;
goto evaluate;
}
DEBUGASSERT(0); /* should not come here */
bool more_possible;
/* when do we need to be called again? */
- next_expire_ms = Curl_timeleft_ms(data, &now, TRUE);
+ next_expire_ms = Curl_timeleft_ms(data, TRUE);
if(next_expire_ms <= 0) {
failf(data, "Connection timeout after %" FMT_OFF_T " ms",
- curlx_timediff_ms(now, data->progress.t_startsingle));
+ curlx_timediff_ms(data->progress.now, data->progress.t_startsingle));
return CURLE_OPERATION_TIMEDOUT;
}
#endif
if(more_possible) {
timediff_t expire_ms, elapsed_ms;
- elapsed_ms = curlx_timediff_ms(now, bs->last_attempt_started);
+ elapsed_ms =
+ curlx_timediff_ms(data->progress.now, bs->last_attempt_started);
expire_ms = CURLMAX(bs->attempt_delay_ms - elapsed_ms, 0);
next_expire_ms = CURLMIN(next_expire_ms, expire_ms);
if(next_expire_ms <= 0) {
proxy_name ? "via " : "",
proxy_name ? proxy_name : "",
proxy_name ? " " : "",
- curlx_timediff_ms(curlx_now(), data->progress.t_startsingle),
+ curlx_timediff_ms(data->progress.now, data->progress.t_startsingle),
curl_easy_strerror(result));
}
if(!dns)
return CURLE_FAILED_INIT;
- if(Curl_timeleft_ms(data, NULL, TRUE) < 0) {
+ if(Curl_timeleft_ms(data, TRUE) < 0) {
/* a precaution, no need to continue if time already is up */
failf(data, "Connection time-out");
return CURLE_OPERATION_TIMEDOUT;
}
CURL_TRC_CF(data, cf, "init ip ballers for transport %u", ctx->transport);
- ctx->started = curlx_now();
+ ctx->started = data->progress.now;
return cf_ip_ballers_init(&ctx->ballers, cf->conn->ip_version,
dns->addr, ctx->cf_create, ctx->transport,
data->set.happy_eyeballs_timeout);
(void)data;
DEBUGASSERT(ctx->sock == CURL_SOCKET_BAD);
- ctx->started_at = curlx_now();
+ ctx->started_at = data->progress.now;
#ifdef SOCK_NONBLOCK
/* Do not tuck SOCK_NONBLOCK into socktype when opensocket callback is set
* because we would not know how socketype is about to be used in the
}
else if(isconnected) {
set_local_ip(cf, data);
- ctx->connected_at = curlx_now();
+ ctx->connected_at = data->progress.now;
cf->connected = TRUE;
}
CURL_TRC_CF(data, cf, "cf_socket_open() -> %d, fd=%" FMT_SOCKET_T,
else if(rc == CURL_CSELECT_OUT || cf->conn->bits.tcp_fastopen) {
if(verifyconnect(ctx->sock, &ctx->error)) {
/* we are connected with TCP, awesome! */
- ctx->connected_at = curlx_now();
+ ctx->connected_at = data->progress.now;
set_local_ip(cf, data);
*done = TRUE;
cf->connected = TRUE;
#define SIO_IDEAL_SEND_BACKLOG_QUERY 0x4004747B
#endif
-static void win_update_sndbuf_size(struct cf_socket_ctx *ctx)
+static void win_update_sndbuf_size(struct Curl_easy *data,
+ struct cf_socket_ctx *ctx)
{
ULONG ideal;
DWORD ideallen;
- struct curltime n = curlx_now();
- if(curlx_timediff_ms(n, ctx->last_sndbuf_query_at) > 1000) {
+ if(curlx_timediff_ms(data->progress.now, ctx->last_sndbuf_query_at) > 1000) {
if(!WSAIoctl(ctx->sock, SIO_IDEAL_SEND_BACKLOG_QUERY, 0, 0,
&ideal, sizeof(ideal), &ideallen, 0, 0) &&
ideal != ctx->sndbuf_size &&
(const char *)&ideal, sizeof(ideal))) {
ctx->sndbuf_size = ideal;
}
- ctx->last_sndbuf_query_at = n;
+ ctx->last_sndbuf_query_at = data->progress.now;
}
}
#ifdef USE_WINSOCK
if(!result)
- win_update_sndbuf_size(ctx);
+ win_update_sndbuf_size(data, ctx);
#endif
CURL_TRC_CF(data, cf, "send(len=%zu) -> %d, %zu",
CURL_TRC_CF(data, cf, "recv(len=%zu) -> %d, %zu", len, result, *pnread);
if(!result && !ctx->got_first_byte) {
- ctx->first_byte_at = curlx_now();
+ ctx->first_byte_at = data->progress.now;
ctx->got_first_byte = TRUE;
}
return result;
struct cf_socket_ctx *ctx = cf->ctx;
timediff_t timeout_ms = DEFAULT_ACCEPT_TIMEOUT;
timediff_t other_ms;
- struct curltime now;
#ifndef CURL_DISABLE_FTP
if(data->set.accepttimeout > 0)
timeout_ms = data->set.accepttimeout;
#endif
- now = curlx_now();
/* check if the generic timeout possibly is set shorter */
- other_ms = Curl_timeleft_ms(data, &now, FALSE);
+ other_ms = Curl_timeleft_ms(data, FALSE);
if(other_ms && (other_ms < timeout_ms))
/* note that this also works fine for when other_ms happens to be negative
due to it already having elapsed */
timeout_ms = other_ms;
else {
/* subtract elapsed time */
- timeout_ms -= curlx_timediff_ms(now, ctx->started_at);
+ timeout_ms -= curlx_timediff_ms(data->progress.now, ctx->started_at);
if(!timeout_ms)
/* avoid returning 0 as that means no timeout! */
timeout_ms = -1;
cf_tcp_set_accepted_remote_ip(cf, data);
set_local_ip(cf, data);
ctx->active = TRUE;
- ctx->connected_at = curlx_now();
+ ctx->connected_at = data->progress.now;
cf->connected = TRUE;
CURL_TRC_CF(data, cf, "accepted_set(sock=%" FMT_SOCKET_T
", remote=%s port=%d)",
goto out;
Curl_conn_cf_add(data, conn, sockindex, cf);
- ctx->started_at = curlx_now();
+ ctx->started_at = data->progress.now;
conn->sock[sockindex] = ctx->sock;
set_local_ip(cf, data);
CURL_TRC_CF(data, cf, "set filter for listen socket fd=%" FMT_SOCKET_T
struct Curl_cfilter *cf;
CURLcode result = CURLE_OK;
timediff_t timeout_ms;
- struct curltime now;
DEBUGASSERT(data->conn);
}
*done = FALSE;
- now = curlx_now();
if(!Curl_shutdown_started(data, sockindex)) {
CURL_TRC_M(data, "shutdown start on%s connection",
sockindex ? " secondary" : "");
- Curl_shutdown_start(data, sockindex, 0, &now);
+ Curl_shutdown_start(data, sockindex, 0);
}
else {
- timeout_ms = Curl_shutdown_timeleft(data->conn, sockindex, &now);
+ timeout_ms = Curl_shutdown_timeleft(data, data->conn, sockindex);
if(timeout_ms < 0) {
/* info message, since this might be regarded as acceptable */
infof(data, "shutdown timeout");
* socket and ip related information. */
cf_cntrl_update_info(data, data->conn);
conn_report_connect_stats(cf, data);
- data->conn->keepalive = curlx_now();
+ data->conn->keepalive = data->progress.now;
#ifndef CURL_DISABLE_VERBOSE_STRINGS
result = cf_verboseconnect(data, cf);
#endif
goto out;
else {
/* check allowed time left */
- const timediff_t timeout_ms = Curl_timeleft_ms(data, NULL, TRUE);
+ const timediff_t timeout_ms = Curl_timeleft_ms(data, TRUE);
curl_socket_t sockfd = Curl_conn_cf_get_socket(cf, data);
int rc;
cpool->share ? "[SHARE] " : "", cpool->num_conn);
/* Move all connections to the shutdown list */
sigpipe_init(&pipe_st);
+ Curl_pgrs_now_set(cpool->idata);
CPOOL_LOCK(cpool, cpool->idata);
conn = cpool_get_first(cpool);
while(conn) {
}
static struct connectdata *
-cpool_bundle_get_oldest_idle(struct cpool_bundle *bundle)
+cpool_bundle_get_oldest_idle(struct cpool_bundle *bundle,
+ struct curltime *pnow)
{
struct Curl_llist_node *curr;
timediff_t highscore = -1;
timediff_t score;
- struct curltime now;
struct connectdata *oldest_idle = NULL;
struct connectdata *conn;
- now = curlx_now();
curr = Curl_llist_head(&bundle->conns);
while(curr) {
conn = Curl_node_elem(curr);
if(!CONN_INUSE(conn)) {
/* Set higher score for the age passed since the connection was used */
- score = curlx_timediff_ms(now, conn->lastused);
+ score = curlx_timediff_ms(*pnow, conn->lastused);
if(score > highscore) {
highscore = score;
return oldest_idle;
}
-static struct connectdata *cpool_get_oldest_idle(struct cpool *cpool)
+static struct connectdata *cpool_get_oldest_idle(struct cpool *cpool,
+ struct curltime *pnow)
{
struct Curl_hash_iterator iter;
struct Curl_llist_node *curr;
struct Curl_hash_element *he;
struct connectdata *oldest_idle = NULL;
struct cpool_bundle *bundle;
- struct curltime now;
timediff_t highscore = -1;
timediff_t score;
- now = curlx_now();
Curl_hash_start_iterate(&cpool->dest2bundle, &iter);
for(he = Curl_hash_next_element(&iter); he;
if(CONN_INUSE(conn) || conn->bits.close || conn->connect_only)
continue;
/* Set higher score for the age passed since the connection was used */
- score = curlx_timediff_ms(now, conn->lastused);
+ score = curlx_timediff_ms(*pnow, conn->lastused);
if(score > highscore) {
highscore = score;
oldest_idle = conn;
if(!dest_limit && !total_limit)
return CPOOL_LIMIT_OK;
+ Curl_pgrs_now_update(cpool->idata, data);
CPOOL_LOCK(cpool, cpool->idata);
if(dest_limit) {
size_t live;
struct connectdata *oldest_idle = NULL;
/* The bundle is full. Extract the oldest connection that may
* be removed now, if there is one. */
- oldest_idle = cpool_bundle_get_oldest_idle(bundle);
+ oldest_idle = cpool_bundle_get_oldest_idle(bundle,
+ &data->progress.now);
if(!oldest_idle)
break;
/* disconnect the old conn and continue */
break;
}
else {
- struct connectdata *oldest_idle = cpool_get_oldest_idle(cpool);
+ struct connectdata *oldest_idle =
+ cpool_get_oldest_idle(cpool, &data->progress.now);
if(!oldest_idle)
break;
/* disconnect the old conn and continue */
out:
CPOOL_UNLOCK(cpool, cpool->idata);
+ Curl_pgrs_now_update(data, cpool->idata);
return result;
}
maxconnects = data->multi->maxconnects;
}
- conn->lastused = curlx_now(); /* it was used up until now */
+ conn->lastused = data->progress.now; /* it was used up until now */
if(cpool && maxconnects) {
/* may be called form a callback already under lock */
bool do_lock = !CPOOL_IS_LOCKED(cpool);
infof(data, "Connection pool is full, closing the oldest of %zu/%u",
cpool->num_conn, maxconnects);
- oldest_idle = cpool_get_oldest_idle(cpool);
+ oldest_idle = cpool_get_oldest_idle(cpool, &data->progress.now);
kept = (oldest_idle != conn);
if(oldest_idle) {
Curl_conn_terminate(data, oldest_idle, FALSE);
* If we do a shutdown for an aborted transfer, the server might think
* it was successful otherwise (for example an ftps: upload). This is
* not what we want. */
+ Curl_pgrs_now_update(cpool->idata, data);
if(aborted)
done = TRUE;
if(!done) {
CPOOL_UNLOCK(cpool, data);
}
-struct cpool_reaper_ctx {
- struct curltime now;
-};
-
static int cpool_reap_dead_cb(struct Curl_easy *data,
struct connectdata *conn, void *param)
{
- struct cpool_reaper_ctx *rctx = param;
+ (void)param;
if((!CONN_INUSE(conn) && conn->bits.no_reuse) ||
- Curl_conn_seems_dead(conn, data, &rctx->now)) {
+ Curl_conn_seems_dead(conn, data)) {
/* stop the iteration here, pass back the connection that was pruned */
Curl_conn_terminate(data, conn, FALSE);
return 1;
void Curl_cpool_prune_dead(struct Curl_easy *data)
{
struct cpool *cpool = cpool_get_instance(data);
- struct cpool_reaper_ctx rctx;
timediff_t elapsed;
if(!cpool)
return;
- rctx.now = curlx_now();
CPOOL_LOCK(cpool, data);
- elapsed = curlx_timediff_ms(rctx.now, cpool->last_cleanup);
+ elapsed = curlx_timediff_ms(data->progress.now, cpool->last_cleanup);
if(elapsed >= 1000L) {
- while(cpool_foreach(data, cpool, &rctx, cpool_reap_dead_cb))
+ while(cpool_foreach(data, cpool, NULL, cpool_reap_dead_cb))
;
- cpool->last_cleanup = rctx.now;
+ cpool->last_cleanup = data->progress.now;
}
CPOOL_UNLOCK(cpool, data);
}
return 0; /* continue iteration */
}
-CURLcode Curl_cpool_upkeep(void *data)
+CURLcode Curl_cpool_upkeep(struct Curl_easy *data)
{
struct cpool *cpool = cpool_get_instance(data);
- struct curltime now = curlx_now();
if(!cpool)
return CURLE_OK;
CPOOL_LOCK(cpool, data);
- cpool_foreach(data, cpool, &now, conn_upkeep);
+ cpool_foreach(data, cpool, &data->progress.now, conn_upkeep);
CPOOL_UNLOCK(cpool, data);
return CURLE_OK;
}
/**
* Perform upkeep actions on connections in the transfer's pool.
*/
-CURLcode Curl_cpool_upkeep(void *data);
+CURLcode Curl_cpool_upkeep(struct Curl_easy *data);
typedef void Curl_cpool_conn_do_cb(struct connectdata *conn,
struct Curl_easy *data,
* infinite time left). If the value is negative, the timeout time has already
* elapsed.
* @param data the transfer to check on
- * @param nowp timestamp to use for calculation, NULL to use curlx_now()
* @param duringconnect TRUE iff connect timeout is also taken into account.
* @unittest: 1303
*/
timediff_t Curl_timeleft_ms(struct Curl_easy *data,
- struct curltime *nowp,
bool duringconnect)
{
timediff_t timeleft_ms = 0;
timediff_t ctimeleft_ms = 0;
timediff_t ctimeout_ms;
- struct curltime now;
/* The duration of a connect and the total transfer are calculated from two
different time-stamps. It can end up with the total timeout being reached
if((!data->set.timeout || data->set.connect_only) && !duringconnect)
return 0; /* no timeout in place or checked, return "no limit" */
- if(!nowp) {
- now = curlx_now();
- nowp = &now;
- }
-
if(data->set.timeout) {
timeleft_ms = data->set.timeout -
- curlx_timediff_ms(*nowp, data->progress.t_startop);
+ curlx_timediff_ms(data->progress.now, data->progress.t_startop);
if(!timeleft_ms)
timeleft_ms = -1; /* 0 is "no limit", fake 1 ms expiry */
}
ctimeout_ms = (data->set.connecttimeout > 0) ?
data->set.connecttimeout : DEFAULT_CONNECT_TIMEOUT;
ctimeleft_ms = ctimeout_ms -
- curlx_timediff_ms(*nowp, data->progress.t_startsingle);
+ curlx_timediff_ms(data->progress.now, data->progress.t_startsingle);
if(!ctimeleft_ms)
ctimeleft_ms = -1; /* 0 is "no limit", fake 1 ms expiry */
if(!timeleft_ms)
}
void Curl_shutdown_start(struct Curl_easy *data, int sockindex,
- int timeout_ms, struct curltime *nowp)
+ int timeout_ms)
{
- struct curltime now;
struct connectdata *conn = data->conn;
DEBUGASSERT(conn);
- if(!nowp) {
- now = curlx_now();
- nowp = &now;
- }
- conn->shutdown.start[sockindex] = *nowp;
+ conn->shutdown.start[sockindex] = data->progress.now;
conn->shutdown.timeout_ms = (timeout_ms > 0) ?
(timediff_t)timeout_ms :
((data->set.shutdowntimeout > 0) ?
data->set.shutdowntimeout : DEFAULT_SHUTDOWN_TIMEOUT_MS);
/* Set a timer, unless we operate on the admin handle */
if(data->mid)
- Curl_expire_ex(data, nowp, conn->shutdown.timeout_ms,
- EXPIRE_SHUTDOWN);
+ Curl_expire_ex(data, conn->shutdown.timeout_ms, EXPIRE_SHUTDOWN);
}
-timediff_t Curl_shutdown_timeleft(struct connectdata *conn, int sockindex,
- struct curltime *nowp)
+timediff_t Curl_shutdown_timeleft(struct Curl_easy *data,
+ struct connectdata *conn,
+ int sockindex)
{
- struct curltime now;
timediff_t left_ms;
if(!conn->shutdown.start[sockindex].tv_sec ||
(conn->shutdown.timeout_ms <= 0))
return 0; /* not started or no limits */
- if(!nowp) {
- now = curlx_now();
- nowp = &now;
- }
left_ms = conn->shutdown.timeout_ms -
- curlx_timediff_ms(*nowp, conn->shutdown.start[sockindex]);
+ curlx_timediff_ms(data->progress.now,
+ conn->shutdown.start[sockindex]);
return left_ms ? left_ms : -1;
}
-timediff_t Curl_conn_shutdown_timeleft(struct connectdata *conn,
- struct curltime *nowp)
+timediff_t Curl_conn_shutdown_timeleft(struct Curl_easy *data,
+ struct connectdata *conn)
{
timediff_t left_ms = 0, ms;
- struct curltime now;
int i;
for(i = 0; conn->shutdown.timeout_ms && (i < 2); ++i) {
if(!conn->shutdown.start[i].tv_sec)
continue;
- if(!nowp) {
- now = curlx_now();
- nowp = &now;
- }
- ms = Curl_shutdown_timeleft(conn, i, nowp);
+ ms = Curl_shutdown_timeleft(data, conn, i);
if(ms && (!left_ms || ms < left_ms))
left_ms = ms;
}
/* generic function that returns how much time there is left to run, according
to the timeouts set */
timediff_t Curl_timeleft_ms(struct Curl_easy *data,
- struct curltime *nowp,
bool duringconnect);
#define DEFAULT_CONNECT_TIMEOUT 300000 /* milliseconds == five minutes */
#define DEFAULT_SHUTDOWN_TIMEOUT_MS (2 * 1000)
void Curl_shutdown_start(struct Curl_easy *data, int sockindex,
- int timeout_ms, struct curltime *nowp);
+ int timeout_ms);
/* return how much time there is left to shutdown the connection at
* sockindex. Returns 0 if there is no limit or shutdown has not started. */
-timediff_t Curl_shutdown_timeleft(struct connectdata *conn, int sockindex,
- struct curltime *nowp);
+timediff_t Curl_shutdown_timeleft(struct Curl_easy *data,
+ struct connectdata *conn,
+ int sockindex);
/* return how much time there is left to shutdown the connection.
* Returns 0 if there is no limit or shutdown has not started. */
-timediff_t Curl_conn_shutdown_timeleft(struct connectdata *conn,
- struct curltime *nowp);
+timediff_t Curl_conn_shutdown_timeleft(struct Curl_easy *data,
+ struct connectdata *conn);
void Curl_shutdown_clear(struct Curl_easy *data, int sockindex);
struct Curl_llist_node *e = Curl_llist_head(&cshutdn->list);
struct Curl_llist_node *enext;
struct connectdata *conn;
- struct curltime *nowp = NULL;
- struct curltime now;
timediff_t next_expire_ms = 0, ms;
bool done;
else {
/* idata has one timer list, but maybe more than one connection.
* Set EXPIRE_SHUTDOWN to the smallest time left for all. */
- if(!nowp) {
- now = curlx_now();
- nowp = &now;
- }
- ms = Curl_conn_shutdown_timeleft(conn, nowp);
+ ms = Curl_conn_shutdown_timeleft(data, conn);
if(ms && ms < next_expire_ms)
next_expire_ms = ms;
}
}
if(next_expire_ms)
- Curl_expire_ex(data, nowp, next_expire_ms, EXPIRE_SHUTDOWN);
+ Curl_expire_ex(data, next_expire_ms, EXPIRE_SHUTDOWN);
}
static void cshutdn_terminate_all(struct cshutdn *cshutdn,
struct Curl_easy *data,
int timeout_ms)
{
- struct curltime started = curlx_now();
+ struct curltime started = data->progress.now;
struct Curl_llist_node *e;
SIGPIPE_VARIABLE(pipe_st);
}
/* wait for activity, timeout or "nothing" */
- spent_ms = curlx_timediff_ms(curlx_now(), started);
+ Curl_pgrs_now_set(data); /* update in loop */
+ spent_ms = curlx_timediff_ms(data->progress.now, started);
if(spent_ms >= (timediff_t)timeout_ms) {
CURL_TRC_M(data, "[SHUTDOWN] shutdown finished, %s",
(timeout_ms > 0) ? "timeout" : "best effort done");
if(CURL_TRC_TIMER_is_verbose(data)) {
struct Curl_llist_node *e = Curl_llist_head(&data->state.timeoutlist);
if(e) {
- struct curltime now = curlx_now();
while(e) {
struct time_node *n = Curl_node_elem(e);
e = Curl_node_next(e);
CURL_TRC_TIMER(data, n->eid, "expires in %" FMT_TIMEDIFF_T "ns",
- curlx_timediff_us(n->time, now));
+ curlx_timediff_us(n->time, data->progress.now));
}
}
}
goto error;
}
- timeout_ms = Curl_timeleft_ms(data, NULL, TRUE);
+ timeout_ms = Curl_timeleft_ms(data, TRUE);
if(timeout_ms <= 0) {
result = CURLE_OPERATION_TIMEDOUT;
goto error;
if(dupset(outcurl, data))
goto fail;
+ Curl_pgrs_now_set(outcurl); /* start of API call */
outcurl->progress.hide = data->progress.hide;
outcurl->progress.callback = data->progress.callback;
if(Curl_is_in_callback(data))
recursive = TRUE;
+ Curl_pgrs_now_set(data); /* start of API call */
recv_paused = Curl_xfer_recv_is_paused(data);
recv_paused_new = (action & CURLPAUSE_RECV);
send_paused = Curl_xfer_send_is_paused(data);
Curl_multi_mark_dirty(data); /* make it run */
/* On changes, tell application to update its timers. */
if(changed) {
- if(Curl_update_timer(data->multi) && !result)
+ if(Curl_update_timer(data->multi, &data->progress.now) && !result)
result = CURLE_ABORTED_BY_CALLBACK;
}
}
CURLcode result = CURLE_OK;
char *xfer_ulbuf;
size_t xfer_ulblen;
- curl_off_t bytecount = 0;
struct_stat file_stat;
const char *sendbuf;
bool eos = FALSE;
result = CURLE_SEND_ERROR;
break;
}
- bytecount += nwritten;
-
- Curl_pgrsSetUploadCounter(data, bytecount);
+ Curl_pgrs_upload_inc(data, nwritten);
result = Curl_pgrsCheck(data);
}
conn->bits.ftp_use_control_ssl = TRUE;
}
- Curl_pp_init(pp); /* once per transfer */
+ Curl_pp_init(pp, &data->progress.now); /* once per transfer */
/* When we connect, we start in the state where we await the 220
response */
* data has been transferred. This happens when doing through NATs etc that
* abandon old silent connections.
*/
- pp->response = curlx_now(); /* timeout relative now */
+ pp->response = data->progress.now; /* timeout relative now */
result = getftpresponse(data, &nread, &ftpcode);
if(!nread && (CURLE_OPERATION_TIMEDOUT == result)) {
result = Curl_pp_sendf(data, &ftpc->pp, "%s", cmd);
if(!result) {
- pp->response = curlx_now(); /* timeout relative now */
+ pp->response = data->progress.now; /* timeout relative now */
result = getftpresponse(data, &nread, &ftpcode);
}
if(result)
else
break;
- timeout_ms = Curl_timeleft_ms(data, NULL, FALSE);
+ timeout_ms = Curl_timeleft_ms(data, FALSE);
if(timeout_ms < 0) {
result = CURLE_OPERATION_TIMEDOUT;
break;
void Curl_dnscache_prune(struct Curl_easy *data)
{
struct Curl_dnscache *dnscache = dnscache_get(data);
- struct curltime now;
/* the timeout may be set -1 (forever) */
timediff_t timeout_ms = data->set.dns_cache_timeout_ms;
dnscache_lock(data, dnscache);
- now = curlx_now();
-
do {
/* Remove outdated and unused entries from the hostcache */
- timediff_t oldest_ms = dnscache_prune(&dnscache->entries, timeout_ms, now);
+ timediff_t oldest_ms =
+ dnscache_prune(&dnscache->entries, timeout_ms, data->progress.now);
if(Curl_hash_count(&dnscache->entries) > MAX_DNS_CACHE_SIZE)
/* prune the ones over half this age */
/* See whether the returned entry is stale. Done before we release lock */
struct dnscache_prune_data user;
- user.now = curlx_now();
+ user.now = data->progress.now;
user.max_age_ms = data->set.dns_cache_timeout_ms;
user.oldest_ms = 0;
dns->timestamp.tv_usec = 0; /* an entry that never goes stale */
}
else {
- dns->timestamp = curlx_now();
+ dns->timestamp = data->progress.now;
}
dns->hostport = port;
if(hostlen)
the time we spent until now! */
if(prev_alarm) {
/* there was an alarm() set before us, now put it back */
- timediff_t elapsed_secs = curlx_timediff_ms(curlx_now(),
+ timediff_t elapsed_secs = curlx_timediff_ms(data->progress.now,
data->conn->created) / 1000;
/* the alarm period is counted in even number of seconds */
DEBUGF(infof(data, "cr_exp100_read, start AWAITING_CONTINUE, "
"timeout %dms", data->set.expect_100_timeout));
ctx->state = EXP100_AWAITING_CONTINUE;
- ctx->start = curlx_now();
+ ctx->start = data->progress.now;
Curl_expire(data, data->set.expect_100_timeout, EXPIRE_100_TIMEOUT);
*nread = 0;
*eos = FALSE;
*eos = FALSE;
return CURLE_READ_ERROR;
case EXP100_AWAITING_CONTINUE:
- ms = curlx_timediff_ms(curlx_now(), ctx->start);
+ ms = curlx_timediff_ms(data->progress.now, ctx->start);
if(ms < data->set.expect_100_timeout) {
DEBUGF(infof(data, "cr_exp100_read, AWAITING_CONTINUE, not expired"));
*nread = 0;
#include "select.h"
#include "curlx/base64.h"
#include "multiif.h"
+#include "progress.h"
#include "url.h"
#include "urlapi-int.h"
#include "cfilters.h"
static int32_t cf_h2_get_desired_local_win(struct Curl_cfilter *cf,
struct Curl_easy *data)
{
- curl_off_t avail = Curl_rlimit_avail(&data->progress.dl.rlimit, curlx_now());
+ curl_off_t avail =
+ Curl_rlimit_avail(&data->progress.dl.rlimit, &data->progress.now);
(void)cf;
if(avail < CURL_OFF_T_MAX) { /* limit in place */
struct Curl_cfilter *cf = userp;
struct cf_h2_ctx *ctx = cf->ctx;
struct h2_stream_ctx *stream;
- struct Curl_easy *data_s;
+ struct Curl_easy *data_s, *calling = CF_DATA_CURRENT(cf);
(void)flags;
DEBUGASSERT(stream_id); /* should never be a zero stream ID here */
stream = H2_STREAM_CTX(ctx, data_s);
if(!stream)
return NGHTTP2_ERR_CALLBACK_FAILURE;
+ if(calling)
+ Curl_pgrs_now_update(data_s, calling);
h2_xfer_write_resp(cf, data_s, stream, (const char *)mem, len, FALSE);
Curl_sasl_init(&imapc->sasl, data, &saslimap);
curlx_dyn_init(&imapc->dyn, DYN_IMAP_CMD);
- Curl_pp_init(pp);
+ Curl_pp_init(pp, &data->progress.now);
if(Curl_conn_meta_set(conn, CURL_META_IMAP_CONN, imapc, imap_conn_dtor))
return CURLE_OUT_OF_MEMORY;
result = Curl_xfer_send(data, buf, len, FALSE, &n);
if(result)
return result;
- mq->lastTime = curlx_now();
+ mq->lastTime = data->progress.now;
Curl_debug(data, CURLINFO_HEADER_OUT, buf, n);
if(len != n) {
size_t nsend = len - n;
}
/* we received something */
- mq->lastTime = curlx_now();
+ mq->lastTime = data->progress.now;
/* if QoS is set, message contains packet id */
result = Curl_client_write(data, CLIENTWRITE_BODY, buffer, nread);
if(!mq)
return CURLE_FAILED_INIT;
- mq->lastTime = curlx_now();
+ mq->lastTime = data->progress.now;
mq->pingsent = FALSE;
result = mqtt_connect(data);
if(mqtt->state == MQTT_FIRST &&
!mq->pingsent &&
data->set.upkeep_interval_ms > 0) {
- struct curltime t = curlx_now();
+ struct curltime t = data->progress.now;
timediff_t diff = curlx_timediff_ms(t, mq->lastTime);
if(diff > data->set.upkeep_interval_ms) {
Curl_debug(data, CURLINFO_HEADER_IN, (const char *)&mq->firstbyte, 1);
/* we received something */
- mq->lastTime = curlx_now();
+ mq->lastTime = data->progress.now;
/* remember the first byte */
mq->npacket = 0;
struct Curl_multi *multi,
struct Curl_easy *d);
static void multi_timeout(struct Curl_multi *multi,
+ struct curltime *pnow,
struct curltime *expire_time,
long *timeout_ms);
static void process_pending_handles(struct Curl_multi *multi);
CURL_TRC_M(data, "-> [%s]", CURL_MSTATE_NAME(state));
#endif
+ /* really switching state */
+ Curl_pgrs_now_set(data);
data->mstate = state;
switch(state) {
case MSTATE_DONE:
CURLMcode rc;
struct Curl_multi *multi = m;
struct Curl_easy *data = d;
+
/* First, make some basic checks that the CURLM handle is a good handle */
if(!GOOD_MULTI_HANDLE(multi))
return CURLM_BAD_HANDLE;
Curl_uint32_bset_clear(&multi->msgsent);
}
+ Curl_pgrs_now_set(data); /* start of API call */
if(data->multi_easy) {
/* if this easy handle was previously used for curl_easy_perform(), there
is a private multi handle here that we can kill */
/* Necessary in event based processing, where dirty handles trigger
* a timeout callback invocation. */
- rc = Curl_update_timer(multi);
+ rc = Curl_update_timer(multi, &data->progress.now);
if(rc) {
data->multi = NULL; /* not anymore */
Curl_uint32_tbl_remove(&multi->xfers, data->mid);
if(multi->in_callback)
return CURLM_RECURSIVE_API_CALL;
+ Curl_pgrs_now_set(data); /* start of API call */
premature = (data->mstate < MSTATE_COMPLETED);
/* If the 'state' is not INIT or COMPLETED, we might need to do something
process_pending_handles(multi);
if(removed_timer) {
- rc = Curl_update_timer(multi);
+ rc = Curl_update_timer(multi, &data->progress.now);
if(rc)
return rc;
}
CURLcode result = CURLE_OK;
if(ps->n) {
- struct curltime now = curlx_now();
- bool send_blocked, recv_blocked;
+ bool send_blocked =
+ (Curl_rlimit_avail(&data->progress.dl.rlimit, &data->progress.now) <= 0);
+ bool recv_blocked =
+ (Curl_rlimit_avail(&data->progress.ul.rlimit, &data->progress.now) <= 0);
- recv_blocked = (Curl_rlimit_avail(&data->progress.dl.rlimit, now) <= 0);
- send_blocked = (Curl_rlimit_avail(&data->progress.ul.rlimit, now) <= 0);
if(send_blocked || recv_blocked) {
int i;
for(i = 0; i <= SECONDARYSOCKET; ++i) {
struct Curl_multi *multi = m;
struct easy_pollset ps;
unsigned int i, mid;
+ struct curltime now = curlx_now(); /* start of API call */
(void)exc_fd_set;
if(!GOOD_MULTI_HANDLE(multi))
continue;
}
+ Curl_pgrs_now_at_least(data, &now);
Curl_multi_pollset(data, &ps);
for(i = 0; i < ps.n; i++) {
if(!FDSET_SOCK(ps.sockets[i]))
struct Curl_multi *multi = m;
struct easy_pollset ps;
unsigned int need = 0, mid;
+ struct curltime now = curlx_now(); /* start of API call */
if(!ufds && (size || !fd_count))
return CURLM_BAD_FUNCTION_ARGUMENT;
Curl_uint32_bset_remove(&multi->dirty, mid);
continue;
}
+ Curl_pgrs_now_at_least(data, &now);
Curl_multi_pollset(data, &ps);
need += Curl_waitfds_add_ps(&cwfds, &ps);
} while(Curl_uint32_bset_next(&multi->process, mid, &mid));
unsigned int curl_nfds = 0; /* how many pfds are for curl transfers */
struct Curl_easy *data = NULL;
CURLMcode result = CURLM_OK;
+ struct curltime now = curlx_now(); /* start of API call */
uint32_t mid;
#ifdef USE_WINSOCK
Curl_uint32_bset_remove(&multi->dirty, mid);
continue;
}
+ Curl_pgrs_now_at_least(data, &now);
Curl_multi_pollset(data, &ps);
if(Curl_pollfds_add_ps(&cpfds, &ps)) {
result = CURLM_OUT_OF_MEMORY;
goto out;
}
+ now = data->progress.now;
} while(Curl_uint32_bset_next(&multi->process, mid, &mid));
}
* poll. Collecting the sockets may install new timers by protocols
* and connection filters.
* Use the shorter one of the internal and the caller requested timeout. */
- multi_timeout(multi, &expire_time, &timeout_internal);
+ multi_timeout(multi, &now, &expire_time, &timeout_internal);
if((timeout_internal >= 0) && (timeout_internal < (long)timeout_ms))
timeout_ms = (int)timeout_internal;
long sleep_ms = 0;
/* Avoid busy-looping when there is nothing particular to wait for */
- multi_timeout(multi, &expire_time, &sleep_ms);
+ multi_timeout(multi, &now, &expire_time, &sleep_ms);
if(sleep_ms) {
if(sleep_ms > timeout_ms)
sleep_ms = timeout_ms;
* Check whether a timeout occurred, and handle it if it did
*/
static bool multi_handle_timeout(struct Curl_easy *data,
- struct curltime *now,
bool *stream_error,
CURLcode *result)
{
bool connect_timeout = data->mstate < MSTATE_DO;
- timediff_t timeout_ms = Curl_timeleft_ms(data, now, connect_timeout);
+ timediff_t timeout_ms =
+ Curl_timeleft_ms(data, connect_timeout);
if(timeout_ms < 0) {
/* Handle timed out */
struct curltime since;
since = data->progress.t_startop;
if(data->mstate == MSTATE_RESOLVING)
failf(data, "Resolving timed out after %" FMT_TIMEDIFF_T
- " milliseconds", curlx_timediff_ms(*now, since));
+ " milliseconds", curlx_timediff_ms(data->progress.now, since));
else if(data->mstate == MSTATE_CONNECTING)
failf(data, "Connection timed out after %" FMT_TIMEDIFF_T
- " milliseconds", curlx_timediff_ms(*now, since));
+ " milliseconds", curlx_timediff_ms(data->progress.now, since));
else {
struct SingleRequest *k = &data->req;
if(k->size != -1) {
failf(data, "Operation timed out after %" FMT_TIMEDIFF_T
" milliseconds with %" FMT_OFF_T " out of %"
FMT_OFF_T " bytes received",
- curlx_timediff_ms(*now, since), k->bytecount, k->size);
+ curlx_timediff_ms(data->progress.now, since),
+ k->bytecount, k->size);
}
else {
failf(data, "Operation timed out after %" FMT_TIMEDIFF_T
" milliseconds with %" FMT_OFF_T " bytes received",
- curlx_timediff_ms(*now, since), k->bytecount);
+ curlx_timediff_ms(data->progress.now, since), k->bytecount);
}
}
*result = CURLE_OPERATION_TIMEDOUT;
return CURLE_TOO_MANY_REDIRECTS;
}
-static CURLcode mspeed_check(struct Curl_easy *data, struct curltime now)
+static CURLcode mspeed_check(struct Curl_easy *data)
{
timediff_t recv_wait_ms = 0;
timediff_t send_wait_ms = 0;
/* check if our send/recv limits require idle waits */
- send_wait_ms = Curl_rlimit_wait_ms(&data->progress.ul.rlimit, now);
- recv_wait_ms = Curl_rlimit_wait_ms(&data->progress.dl.rlimit, now);
+ send_wait_ms =
+ Curl_rlimit_wait_ms(&data->progress.ul.rlimit, &data->progress.now);
+ recv_wait_ms =
+ Curl_rlimit_wait_ms(&data->progress.dl.rlimit, &data->progress.now);
if(send_wait_ms || recv_wait_ms) {
if(data->mstate != MSTATE_RATELIMITING) {
}
static CURLMcode state_performing(struct Curl_easy *data,
- struct curltime *nowp,
bool *stream_errorp,
CURLcode *resultp)
{
CURLcode result = *resultp = CURLE_OK;
*stream_errorp = FALSE;
- if(mspeed_check(data, *nowp) == CURLE_AGAIN)
+ if(mspeed_check(data) == CURLE_AGAIN)
return CURLM_OK;
/* read/write data if it is ready to do so */
- result = Curl_sendrecv(data, nowp);
+ result = Curl_sendrecv(data);
if(data->req.done || (result == CURLE_RECV_ERROR)) {
/* If CURLE_RECV_ERROR happens early enough, we assume it was a race
}
}
else { /* not errored, not done */
- *nowp = curlx_now();
- mspeed_check(data, *nowp);
+ mspeed_check(data);
}
curlx_free(newurl);
*resultp = result;
}
static CURLMcode state_ratelimiting(struct Curl_easy *data,
- struct curltime *nowp,
CURLcode *resultp)
{
CURLcode result = CURLE_OK;
multi_done(data, result, TRUE);
}
else {
- if(!mspeed_check(data, *nowp))
+ if(!mspeed_check(data))
rc = CURLM_CALL_MULTI_PERFORM;
}
*resultp = result;
static CURLMcode state_connect(struct Curl_multi *multi,
struct Curl_easy *data,
- struct curltime *nowp,
CURLcode *resultp)
{
/* Connect. We want to get a connection identifier filled in. This state can
process_pending_handles(data->multi);
if(!result) {
- *nowp = curlx_now();
if(async)
/* We are now waiting for an asynchronous name lookup */
multistate(data, MSTATE_RESOLVING);
}
static CURLMcode multi_runsingle(struct Curl_multi *multi,
- struct curltime *nowp,
struct Curl_easy *data)
{
struct Curl_message *msg = NULL;
(HTTP/2), or the full connection for older protocols */
bool stream_error = FALSE;
rc = CURLM_OK;
- /* update at start for continuous increase when looping */
- *nowp = curlx_now();
if(multi_ischanged(multi, TRUE)) {
CURL_TRC_M(data, "multi changed, check CONNECT_PEND queue");
/* Wait for the connect state as only then is the start time stored, but
we must not check already completed handles */
if((data->mstate >= MSTATE_CONNECT) && (data->mstate < MSTATE_COMPLETED) &&
- multi_handle_timeout(data, nowp, &stream_error, &result))
+ multi_handle_timeout(data, &stream_error, &result))
/* Skip the statemachine and go directly to error handling section. */
goto statemachine_end;
case MSTATE_SETUP:
/* Transitional state. Setup things for a new transfer. The handle
can come back to this state on a redirect. */
- *nowp = Curl_pgrsTime(data, TIMER_STARTSINGLE);
+ Curl_pgrsTime(data, TIMER_STARTSINGLE);
if(data->set.timeout)
Curl_expire(data, data->set.timeout, EXPIRE_TIMEOUT);
if(data->set.connecttimeout)
FALLTHROUGH();
case MSTATE_CONNECT:
- rc = state_connect(multi, data, nowp, &result);
+ rc = state_connect(multi, data, &result);
break;
case MSTATE_RESOLVING:
break;
case MSTATE_RATELIMITING: /* limit-rate exceeded in either direction */
- rc = state_ratelimiting(data, nowp, &result);
+ rc = state_ratelimiting(data, &result);
break;
case MSTATE_PERFORMING:
- rc = state_performing(data, nowp, &stream_error, &result);
+ rc = state_performing(data, &stream_error, &result);
break;
case MSTATE_DONE:
* (i.e. CURLM_CALL_MULTI_PERFORM == TRUE) then we should do that before
* declaring the connection timed out as we may almost have a completed
* connection. */
- multi_handle_timeout(data, nowp, &stream_error, &result);
+ multi_handle_timeout(data, &stream_error, &result);
}
statemachine_end:
return rc;
}
-CURLMcode curl_multi_perform(CURLM *m, int *running_handles)
+static CURLMcode multi_perform(struct Curl_multi *multi,
+ struct curltime *pnow,
+ int *running_handles)
{
CURLMcode returncode = CURLM_OK;
struct Curl_tree *t = NULL;
- struct curltime now = curlx_now();
- struct Curl_multi *multi = m;
uint32_t mid;
SIGPIPE_VARIABLE(pipe_st);
- if(!GOOD_MULTI_HANDLE(multi))
- return CURLM_BAD_HANDLE;
-
if(multi->in_callback)
return CURLM_RECURSIVE_API_CALL;
continue;
}
sigpipe_apply(data, &pipe_st);
- result = multi_runsingle(multi, &now, data);
+ Curl_pgrs_now_at_least(data, pnow);
+ result = multi_runsingle(multi, data);
+ *pnow = data->progress.now; /* in case transfer updated */
if(result)
returncode = result;
} while(Curl_uint32_bset_next(&multi->process, mid, &mid));
}
sigpipe_restore(&pipe_st);
- if(multi_ischanged(m, TRUE))
- process_pending_handles(m);
+ if(multi_ischanged(multi, TRUE))
+ process_pending_handles(multi);
if(!returncode)
returncode = Curl_mntfy_dispatch_all(multi);
* been handled!
*/
do {
- multi->timetree = Curl_splaygetbest(now, multi->timetree, &t);
+ multi->timetree = Curl_splaygetbest(*pnow, multi->timetree, &t);
if(t) {
/* the removed may have another timeout in queue */
struct Curl_easy *data = Curl_splayget(t);
- (void)add_next_timeout(now, multi, data);
+ (void)add_next_timeout(*pnow, multi, data);
if(data->mstate == MSTATE_PENDING) {
bool stream_unused;
CURLcode result_unused;
- if(multi_handle_timeout(data, &now, &stream_unused, &result_unused)) {
+ if(multi_handle_timeout(data, &stream_unused, &result_unused)) {
infof(data, "PENDING handle timeout");
move_pending_to_connect(multi, data);
}
}
if(CURLM_OK >= returncode)
- returncode = Curl_update_timer(multi);
+ returncode = Curl_update_timer(multi, pnow);
return returncode;
}
+CURLMcode curl_multi_perform(CURLM *m, int *running_handles)
+{
+ struct curltime now = curlx_now(); /* start of API call */
+ struct Curl_multi *multi = m;
+
+ if(!GOOD_MULTI_HANDLE(multi))
+ return CURLM_BAD_HANDLE;
+ multi = m;
+ return multi_perform(multi, &now, running_handles);
+}
+
CURLMcode curl_multi_cleanup(CURLM *m)
{
struct Curl_multi *multi = m;
mrc->run_xfers++;
sigpipe_apply(data, &mrc->pipe_st);
/* runsingle() clears the dirty mid */
- result = multi_runsingle(multi, &mrc->now, data);
+ Curl_pgrs_now_at_least(data, &mrc->now);
+ result = multi_runsingle(multi, data);
+ mrc->now = data->progress.now; /* in case transfer updated */
if(CURLM_OK >= result) {
/* reassess event handling of data */
(void)ev_bitmask;
memset(&mrc, 0, sizeof(mrc));
mrc.multi = multi;
- mrc.now = curlx_now();
+ mrc.now = curlx_now(); /* start of API call */
sigpipe_init(&mrc.pipe_st);
if(checkall) {
/* *perform() deals with running_handles on its own */
- result = curl_multi_perform(multi, running_handles);
+ result = multi_perform(multi, &mrc.now, running_handles);
if(result != CURLM_BAD_HANDLE) {
/* Reassess event status of all active transfers */
- result = Curl_multi_ev_assess_xfer_bset(multi, &multi->process);
+ result = Curl_multi_ev_assess_xfer_bset(multi, &multi->process,
+ &mrc.now);
}
goto out;
}
* to set a 0 timeout and call us again, we run them here.
* Do that only once or it might be unfair to transfers on other
* sockets. */
- mrc.now = curlx_now();
multi_mark_expired_as_dirty(&mrc);
result = multi_run_dirty(&mrc);
}
}
if(CURLM_OK >= result)
- result = Curl_update_timer(multi);
+ result = Curl_update_timer(multi, &mrc.now);
return result;
}
}
static void multi_timeout(struct Curl_multi *multi,
+ struct curltime *pnow,
struct curltime *expire_time,
long *timeout_ms)
{
}
if(multi_has_dirties(multi)) {
- *expire_time = curlx_now();
+ *expire_time = *pnow;
*timeout_ms = 0;
return;
}
else if(multi->timetree) {
- /* we have a tree of expire times */
- struct curltime now = curlx_now();
-
/* splay the lowest to the bottom */
multi->timetree = Curl_splay(tv_zero, multi->timetree);
/* this will not return NULL from a non-empty tree, but some compilers
/* 'multi->timetree' will be non-NULL here but the compilers sometimes
yell at us if we assume so */
if(multi->timetree &&
- curlx_timediff_us(multi->timetree->key, now) > 0) {
+ curlx_timediff_us(multi->timetree->key, *pnow) > 0) {
/* some time left before expiration */
- timediff_t diff_ms = curlx_timediff_ceil_ms(multi->timetree->key, now);
+ timediff_t diff_ms = curlx_timediff_ceil_ms(multi->timetree->key, *pnow);
#ifndef CURL_DISABLE_VERBOSE_STRINGS
data = Curl_splayget(multi->timetree);
#endif
{
struct curltime expire_time;
struct Curl_multi *multi = m;
+ struct curltime now = curlx_now(); /* start of API call */
/* First, make some basic checks that the CURLM handle is a good handle */
if(!GOOD_MULTI_HANDLE(multi))
if(multi->in_callback)
return CURLM_RECURSIVE_API_CALL;
- multi_timeout(multi, &expire_time, timeout_ms);
+ multi_timeout(multi, &now, &expire_time, timeout_ms);
return CURLM_OK;
}
* Tell the application it should update its timers, if it subscribes to the
* update timer callback.
*/
-CURLMcode Curl_update_timer(struct Curl_multi *multi)
+CURLMcode Curl_update_timer(struct Curl_multi *multi,
+ struct curltime *pnow)
{
struct curltime expire_ts;
long timeout_ms;
if(!multi->timer_cb || multi->dead)
return CURLM_OK;
- multi_timeout(multi, &expire_ts, &timeout_ms);
+ multi_timeout(multi, pnow, &expire_ts, &timeout_ms);
if(timeout_ms < 0 && multi->last_timeout_ms < 0) {
/* nothing to do */
}
void Curl_expire_ex(struct Curl_easy *data,
- const struct curltime *nowp,
timediff_t milli, expire_id id)
{
struct Curl_multi *multi = data->multi;
DEBUGASSERT(id < EXPIRE_LAST);
- set = *nowp;
+ set = data->progress.now;
set.tv_sec += (time_t)(milli / 1000); /* may be a 64 to 32-bit conversion */
set.tv_usec += (int)(milli % 1000) * 1000;
/* Add it to the timer list. It must stay in the list until it has expired
in case we need to recompute the minimum timer later. */
- multi_addtimeout(data, &set, id, nowp);
+ multi_addtimeout(data, &set, id, &data->progress.now);
if(curr_expire->tv_sec || curr_expire->tv_usec) {
/* This means that the struct is added as a node in the splay tree.
*/
void Curl_expire(struct Curl_easy *data, timediff_t milli, expire_id id)
{
- struct curltime now = curlx_now();
- Curl_expire_ex(data, &now, milli, id);
+ Curl_expire_ex(data, milli, id);
}
/*
#include "multiif.h"
#include "curlx/timeval.h"
#include "multi_ev.h"
+#include "progress.h"
#include "select.h"
#include "uint-bset.h"
#include "uint-spbset.h"
return NULL;
}
-static CURLMcode mev_assess(struct Curl_multi *multi, struct Curl_easy *data,
+static CURLMcode mev_assess(struct Curl_multi *multi,
+ struct Curl_easy *data,
struct connectdata *conn)
{
struct easy_pollset ps, *last_ps;
}
CURLMcode Curl_multi_ev_assess_xfer_bset(struct Curl_multi *multi,
- struct uint32_bset *set)
+ struct uint32_bset *set,
+ struct curltime *pnow)
{
uint32_t mid;
CURLMcode result = CURLM_OK;
if(multi && multi->socket_cb && Curl_uint32_bset_first(set, &mid)) {
do {
struct Curl_easy *data = Curl_multi_get_easy(multi, mid);
- if(data)
+ if(data) {
+ Curl_pgrs_now_at_least(data, pnow);
result = Curl_multi_ev_assess_xfer(multi, data);
+ }
} while(!result && Curl_uint32_bset_next(set, mid, &mid));
}
return result;
struct Curl_easy *data);
/* Assess all easy handles on the list */
CURLMcode Curl_multi_ev_assess_xfer_bset(struct Curl_multi *multi,
- struct uint32_bset *set);
+ struct uint32_bset *set,
+ struct curltime *pnow);
/* Assess the connection by getting its current pollset */
CURLMcode Curl_multi_ev_assess_conn(struct Curl_multi *multi,
struct Curl_easy *data,
void Curl_expire(struct Curl_easy *data, timediff_t milli, expire_id);
void Curl_expire_ex(struct Curl_easy *data,
- const struct curltime *nowp,
timediff_t milli, expire_id id);
bool Curl_expire_clear(struct Curl_easy *data);
void Curl_expire_done(struct Curl_easy *data, expire_id id);
-CURLMcode Curl_update_timer(struct Curl_multi *multi) WARN_UNUSED_RESULT;
+CURLMcode Curl_update_timer(struct Curl_multi *multi,
+ struct curltime *pnow) WARN_UNUSED_RESULT;
void Curl_attach_connection(struct Curl_easy *data,
struct connectdata *conn);
void Curl_detach_connection(struct Curl_easy *data);
timediff_t timeout_ms; /* in milliseconds */
timediff_t response_time = data->set.server_response_timeout ?
data->set.server_response_timeout : RESP_TIMEOUT;
- struct curltime now = curlx_now();
/* if CURLOPT_SERVER_RESPONSE_TIMEOUT is set, use that to determine
remaining time, or use pp->response because SERVER_RESPONSE_TIMEOUT is
supposed to govern the response for any given server response, not for
the time from connect to the given server response. */
+ /* pingpong can spend some time processing, always update
+ * the transfer timestamp before checking timeouts. */
+ Curl_pgrs_now_set(data);
+
/* Without a requested timeout, we only wait 'response_time' seconds for the
full response to arrive before we bail out */
- timeout_ms = response_time - curlx_timediff_ms(now, pp->response);
+ timeout_ms = response_time -
+ curlx_timediff_ms(data->progress.now, pp->response);
if(data->set.timeout && !disconnecting) {
/* if timeout is requested, find out how much overall remains */
- timediff_t timeout2_ms = Curl_timeleft_ms(data, &now, FALSE);
+ timediff_t timeout2_ms = Curl_timeleft_ms(data, FALSE);
/* pick the lowest number */
timeout_ms = CURLMIN(timeout_ms, timeout2_ms);
}
if(disconnecting) {
- timediff_t total_left_ms = Curl_timeleft_ms(data, NULL, FALSE);
+ timediff_t total_left_ms = Curl_timeleft_ms(data, FALSE);
timeout_ms = CURLMIN(timeout_ms, CURLMAX(total_left_ms, 0));
}
}
/* initialize stuff to prepare for reading a fresh new response */
-void Curl_pp_init(struct pingpong *pp)
+void Curl_pp_init(struct pingpong *pp, struct curltime *pnow)
{
DEBUGASSERT(!pp->initialised);
pp->nread_resp = 0;
- pp->response = curlx_now(); /* start response time-out now! */
+ pp->response = *pnow; /* start response time-out */
pp->pending_resp = TRUE;
curlx_dyn_init(&pp->sendbuf, DYN_PINGPPONG_CMD);
curlx_dyn_init(&pp->recvbuf, DYN_PINGPPONG_CMD);
else {
pp->sendthis = NULL;
pp->sendleft = pp->sendsize = 0;
- pp->response = curlx_now();
+ pp->response = data->progress.now;
}
return CURLE_OK;
else {
pp->sendthis = NULL;
pp->sendleft = pp->sendsize = 0;
- pp->response = curlx_now();
+ pp->response = data->progress.now;
}
return CURLE_OK;
}
bool block, bool disconnecting);
/* initialize stuff to prepare for reading a fresh new response */
-void Curl_pp_init(struct pingpong *pp);
+void Curl_pp_init(struct pingpong *pp, struct curltime *pnow);
/* Returns timeout in ms. 0 or negative number means the timeout has already
triggered */
Curl_sasl_init(&pop3c->sasl, data, &saslpop3);
/* Initialise the pingpong layer */
- Curl_pp_init(pp);
+ Curl_pp_init(pp, &data->progress.now);
/* Parse the URL options */
result = pop3_parse_url_options(conn);
return CURLE_OK;
}
+void Curl_pgrs_now_set(struct Curl_easy *data)
+{
+ data->progress.now = curlx_now();
+}
+
+void Curl_pgrs_now_at_least(struct Curl_easy *data, struct curltime *pts)
+{
+ if((pts->tv_sec > data->progress.now.tv_sec) ||
+ ((pts->tv_sec == data->progress.now.tv_sec) &&
+ (pts->tv_usec > data->progress.now.tv_usec))) {
+ data->progress.now = *pts;
+ }
+}
+
+void Curl_pgrs_now_update(struct Curl_easy *data, struct Curl_easy *other)
+{
+ Curl_pgrs_now_at_least(data, &other->progress.now);
+}
+
/*
New proposed interface, 9th of February 2000:
void Curl_pgrsReset(struct Curl_easy *data)
{
Curl_pgrsSetUploadCounter(data, 0);
- Curl_pgrsSetDownloadCounter(data, 0);
+ data->progress.dl.cur_size = 0;
Curl_pgrsSetUploadSize(data, -1);
Curl_pgrsSetDownloadSize(data, -1);
data->progress.speeder_c = 0; /* reset speed records */
*
* @unittest: 1399
*/
-struct curltime Curl_pgrsTime(struct Curl_easy *data, timerid timer)
+void Curl_pgrsTime(struct Curl_easy *data, timerid timer)
{
- struct curltime now = curlx_now();
-
- Curl_pgrsTimeWas(data, timer, now);
- return now;
+ Curl_pgrs_now_set(data); /* update on real progress */
+ Curl_pgrsTimeWas(data, timer, data->progress.now);
}
void Curl_pgrsStartNow(struct Curl_easy *data)
{
struct Progress *p = &data->progress;
p->speeder_c = 0; /* reset the progress meter display */
- p->start = curlx_now();
+ p->start = data->progress.now;
p->is_t_startransfer_set = FALSE;
p->dl.cur_size = 0;
p->ul.cur_size = 0;
p->ul_size_known = FALSE;
}
-/*
- * Set the number of downloaded bytes so far.
- */
-void Curl_pgrsSetDownloadCounter(struct Curl_easy *data, curl_off_t size)
+void Curl_pgrs_download_inc(struct Curl_easy *data, size_t delta)
+{
+ if(delta) {
+ data->progress.dl.cur_size += delta;
+ Curl_rlimit_drain(&data->progress.dl.rlimit, delta, &data->progress.now);
+ }
+}
+
+void Curl_pgrs_upload_inc(struct Curl_easy *data, size_t delta)
{
- data->progress.dl.cur_size = size;
+ if(delta) {
+ data->progress.ul.cur_size += delta;
+ Curl_rlimit_drain(&data->progress.ul.rlimit, delta, &data->progress.now);
+ }
}
/*
CURLcode Curl_pgrsUpdate(struct Curl_easy *data)
{
- struct curltime now = curlx_now(); /* what time is it */
- return pgrs_update(data, &now);
+ return pgrs_update(data, &data->progress.now);
}
CURLcode Curl_pgrsCheck(struct Curl_easy *data)
{
- struct curltime now = curlx_now();
CURLcode result;
- result = pgrs_update(data, &now);
+ result = pgrs_update(data, &data->progress.now);
if(!result && !data->req.done)
- result = pgrs_speedcheck(data, &now);
+ result = pgrs_speedcheck(data, &data->progress.now);
return result;
}
*/
void Curl_pgrsUpdate_nometer(struct Curl_easy *data)
{
- struct curltime now = curlx_now(); /* what time is it */
- (void)progress_calc(data, &now);
+ (void)progress_calc(data, &data->progress.now);
}
TIMER_LAST /* must be last */
} timerid;
+#define CURL_PGRS_NOW_MONOTONIC
+
+/* Set current time in data->progress.now */
+void Curl_pgrs_now_set(struct Curl_easy *data);
+/* Advance `now` timestamp at least to given timestamp.
+ * No effect it data's `now` is already later than `pts`. */
+void Curl_pgrs_now_at_least(struct Curl_easy *data, struct curltime *pts);
+/* `data` progressing continues after `other` processing. Advance `data`s
+ * now timestamp to at least `other's` timestamp. */
+void Curl_pgrs_now_update(struct Curl_easy *data, struct Curl_easy *other);
+
int Curl_pgrsDone(struct Curl_easy *data);
void Curl_pgrsStartNow(struct Curl_easy *data);
void Curl_pgrsSetDownloadSize(struct Curl_easy *data, curl_off_t size);
void Curl_pgrsSetUploadSize(struct Curl_easy *data, curl_off_t size);
-void Curl_pgrsSetDownloadCounter(struct Curl_easy *data, curl_off_t size);
+void Curl_pgrs_download_inc(struct Curl_easy *data, size_t delta);
+void Curl_pgrs_upload_inc(struct Curl_easy *data, size_t delta);
void Curl_pgrsSetUploadCounter(struct Curl_easy *data, curl_off_t size);
/* perform progress update, invoking callbacks at intervals */
/* Reset sizes for up- and download. */
void Curl_pgrsResetTransferSizes(struct Curl_easy *data);
-struct curltime Curl_pgrsTime(struct Curl_easy *data, timerid timer);
+void Curl_pgrsTime(struct Curl_easy *data, timerid timer);
/**
* Update progress timer with the elapsed time from its start to `timestamp`.
* This allows updating timers later and is used by happy eyeballing, where
void Curl_rlimit_init(struct Curl_rlimit *r,
curl_off_t rate_per_s,
curl_off_t burst_per_s,
- struct curltime ts)
+ struct curltime *pts)
{
curl_off_t rate_steps;
DEBUGASSERT(rate_per_s >= 0);
DEBUGASSERT(burst_per_s >= rate_per_s || !burst_per_s);
+ DEBUGASSERT(pts);
r->step_us = CURL_US_PER_SEC;
r->rate_per_step = rate_per_s;
r->burst_per_step = burst_per_s;
}
r->tokens = r->rate_per_step;
r->spare_us = 0;
- r->ts = ts;
+ r->ts = *pts;
r->blocked = FALSE;
}
-void Curl_rlimit_start(struct Curl_rlimit *r, struct curltime ts)
+void Curl_rlimit_start(struct Curl_rlimit *r, struct curltime *pts)
{
r->tokens = r->rate_per_step;
r->spare_us = 0;
- r->ts = ts;
+ r->ts = *pts;
}
bool Curl_rlimit_active(struct Curl_rlimit *r)
}
static void ratelimit_update(struct Curl_rlimit *r,
- struct curltime ts)
+ struct curltime *pts)
{
timediff_t elapsed_us, elapsed_steps;
curl_off_t token_gain;
DEBUGASSERT(r->rate_per_step);
- if((r->ts.tv_sec == ts.tv_sec) && (r->ts.tv_usec == ts.tv_usec))
+ if((r->ts.tv_sec == pts->tv_sec) && (r->ts.tv_usec == pts->tv_usec))
return;
- elapsed_us = curlx_timediff_us(ts, r->ts);
+ elapsed_us = curlx_timediff_us(*pts, r->ts);
if(elapsed_us < 0) { /* not going back in time */
DEBUGASSERT(0);
return;
return;
/* we do the update */
- r->ts = ts;
+ r->ts = *pts;
elapsed_steps = elapsed_us / r->step_us;
r->spare_us = elapsed_us % r->step_us;
}
curl_off_t Curl_rlimit_avail(struct Curl_rlimit *r,
- struct curltime ts)
+ struct curltime *pts)
{
if(r->blocked)
return 0;
else if(r->rate_per_step) {
- ratelimit_update(r, ts);
+ ratelimit_update(r, pts);
return r->tokens;
}
else
void Curl_rlimit_drain(struct Curl_rlimit *r,
size_t tokens,
- struct curltime ts)
+ struct curltime *pts)
{
if(r->blocked || !r->rate_per_step)
return;
- ratelimit_update(r, ts);
+ ratelimit_update(r, pts);
#if SIZEOF_CURL_OFF_T <= SIZEOF_SIZE_T
if(tokens > CURL_OFF_T_MAX) {
r->tokens = CURL_OFF_T_MIN;
}
timediff_t Curl_rlimit_wait_ms(struct Curl_rlimit *r,
- struct curltime ts)
+ struct curltime *pts)
{
timediff_t wait_us, elapsed_us;
if(r->blocked || !r->rate_per_step)
return 0;
- ratelimit_update(r, ts);
+ ratelimit_update(r, pts);
if(r->tokens > 0)
return 0;
wait_us = (1 + (-r->tokens / r->rate_per_step)) * r->step_us;
wait_us -= r->spare_us;
- elapsed_us = curlx_timediff_us(ts, r->ts);
+ elapsed_us = curlx_timediff_us(*pts, r->ts);
if(elapsed_us >= wait_us)
return 0;
wait_us -= elapsed_us;
void Curl_rlimit_block(struct Curl_rlimit *r,
bool activate,
- struct curltime ts)
+ struct curltime *pts)
{
if(!activate == !r->blocked)
return;
- r->ts = ts;
+ r->ts = *pts;
r->blocked = activate;
if(!r->blocked) {
/* Start rate limiting fresh. The amount of time this was blocked
* does not generate extra tokens. */
- Curl_rlimit_start(r, ts);
+ Curl_rlimit_start(r, pts);
}
else {
r->tokens = 0;
void Curl_rlimit_init(struct Curl_rlimit *r,
curl_off_t rate_per_s,
curl_off_t burst_per_s,
- struct curltime ts);
+ struct curltime *pts);
/* Start ratelimiting with the given timestamp. Resets available tokens. */
-void Curl_rlimit_start(struct Curl_rlimit *r, struct curltime ts);
+void Curl_rlimit_start(struct Curl_rlimit *r, struct curltime *pts);
/* How many milliseconds to wait until token are available again. */
timediff_t Curl_rlimit_wait_ms(struct Curl_rlimit *r,
- struct curltime ts);
+ struct curltime *pts);
/* Return if rate limiting of tokens is active */
bool Curl_rlimit_active(struct Curl_rlimit *r);
/* Return how many tokens are available to spend, may be negative */
curl_off_t Curl_rlimit_avail(struct Curl_rlimit *r,
- struct curltime ts);
+ struct curltime *pts);
/* Drain tokens from the ratelimit, return how many are now available. */
void Curl_rlimit_drain(struct Curl_rlimit *r,
size_t tokens,
- struct curltime ts);
+ struct curltime *pts);
/* Block/unblock ratelimiting. A blocked ratelimit has 0 tokens available. */
void Curl_rlimit_block(struct Curl_rlimit *r,
bool activate,
- struct curltime ts);
+ struct curltime *pts);
#endif /* HEADER_Curl_rlimit_H */
CURLcode Curl_req_start(struct SingleRequest *req,
struct Curl_easy *data)
{
- req->start = curlx_now();
+ req->start = data->progress.now;
return Curl_req_soft_reset(req, data);
}
size_t body_len = *pnwritten - hds_len;
Curl_debug(data, CURLINFO_DATA_OUT, buf + hds_len, body_len);
data->req.writebytecount += body_len;
- Curl_pgrsSetUploadCounter(data, data->req.writebytecount);
+ Curl_pgrs_upload_inc(data, body_len);
}
}
}
if(!ctx->started_response &&
!(type & (CLIENTWRITE_INFO | CLIENTWRITE_CONNECT))) {
Curl_pgrsTime(data, TIMER_STARTTRANSFER);
- Curl_rlimit_start(&data->progress.dl.rlimit, curlx_now());
+ Curl_rlimit_start(&data->progress.dl.rlimit, &data->progress.now);
ctx->started_response = TRUE;
}
}
/* Update stats, write and report progress */
- Curl_rlimit_drain(&data->progress.dl.rlimit, nwrite, curlx_now());
- data->req.bytecount += nwrite;
- Curl_pgrsSetDownloadCounter(data, data->req.bytecount);
+ if(nwrite) {
+ data->req.bytecount += nwrite;
+ Curl_pgrs_download_inc(data, nwrite);
+ }
if(excess_len) {
if(!data->req.ignorebody) {
DEBUGASSERT(data->req.reader_stack);
}
if(!data->req.reader_started) {
- Curl_rlimit_start(&data->progress.ul.rlimit, curlx_now());
+ Curl_rlimit_start(&data->progress.ul.rlimit, &data->progress.now);
data->req.reader_started = TRUE;
}
if(Curl_rlimit_active(&data->progress.ul.rlimit)) {
curl_off_t ul_avail =
- Curl_rlimit_avail(&data->progress.ul.rlimit, curlx_now());
+ Curl_rlimit_avail(&data->progress.ul.rlimit, &data->progress.now);
if(ul_avail <= 0) {
result = CURLE_OK;
*eos = FALSE;
}
result = Curl_creader_read(data, data->req.reader_stack, buf, blen,
nread, eos);
- if(!result)
- Curl_rlimit_drain(&data->progress.ul.rlimit, *nread, curlx_now());
out:
CURL_TRC_READ(data, "client_read(len=%zu) -> %d, nread=%zu, eos=%d",
if(offt < 0)
return CURLE_BAD_FUNCTION_ARGUMENT;
s->max_send_speed = offt;
- Curl_rlimit_init(&data->progress.ul.rlimit, offt, offt, curlx_now());
+ Curl_rlimit_init(&data->progress.ul.rlimit, offt, offt,
+ &data->progress.now);
break;
case CURLOPT_MAX_RECV_SPEED_LARGE:
/*
if(offt < 0)
return CURLE_BAD_FUNCTION_ARGUMENT;
s->max_recv_speed = offt;
- Curl_rlimit_init(&data->progress.dl.rlimit, offt, offt, curlx_now());
+ Curl_rlimit_init(&data->progress.dl.rlimit, offt, offt,
+ &data->progress.now);
break;
case CURLOPT_RESUME_FROM_LARGE:
/*
sizeof(struct smb_header) + 5);
data->req.bytecount += len;
data->req.offset += len;
- Curl_pgrsSetUploadCounter(data, data->req.bytecount);
+ Curl_pgrs_upload_inc(data, len);
if(data->req.bytecount >= data->req.size)
next_state = SMB_CLOSE;
else
Curl_sasl_init(&smtpc->sasl, data, &saslsmtp);
/* Initialise the pingpong layer */
- Curl_pp_init(&smtpc->pp);
+ Curl_pp_init(&smtpc->pp, &data->progress.now);
/* Parse the URL options */
result = smtp_parse_url_options(data->conn, smtpc);
*pnread = 0;
for(;;) {
- timediff_t timeout_ms = Curl_timeleft_ms(data, NULL, TRUE);
+ timediff_t timeout_ms = Curl_timeleft_ms(data, TRUE);
if(timeout_ms < 0) {
/* we already got the timeout */
return CURLE_OPERATION_TIMEDOUT;
timediff_t interval_ms;
struct pollfd pfd[2];
int poll_cnt;
- curl_off_t total_dl = 0;
- curl_off_t total_ul = 0;
ssize_t snread;
#endif
- struct curltime now;
bool keepon = TRUE;
char buffer[4 * 1024];
struct TELNET *tn;
} /* switch */
if(data->set.timeout) {
- now = curlx_now();
- if(curlx_timediff_ms(now, conn->created) >= data->set.timeout) {
+ Curl_pgrs_now_set(data);
+ if(curlx_timediff_ms(data->progress.now, conn->created) >=
+ data->set.timeout) {
failf(data, "Time-out");
result = CURLE_OPERATION_TIMEDOUT;
keepon = FALSE;
break;
}
- total_dl += nread;
- Curl_pgrsSetDownloadCounter(data, total_dl);
+ Curl_pgrs_download_inc(data, nread);
result = telrcv(data, tn, (unsigned char *)buffer, nread);
if(result) {
keepon = FALSE;
keepon = FALSE;
break;
}
- total_ul += snread;
- Curl_pgrsSetUploadCounter(data, total_ul);
+ Curl_pgrs_upload_inc(data, (size_t)snread);
}
else if(snread < 0)
keepon = FALSE;
} /* poll switch statement */
if(data->set.timeout) {
- now = curlx_now();
- if(curlx_timediff_ms(now, conn->created) >= data->set.timeout) {
+ Curl_pgrs_now_set(data);
+ if(curlx_timediff_ms(data->progress.now, conn->created) >=
+ data->set.timeout) {
failf(data, "Time-out");
result = CURLE_OPERATION_TIMEDOUT;
keepon = FALSE;
bool start = (state->state == TFTP_STATE_START);
/* Compute drop-dead time */
- timeout_ms = Curl_timeleft_ms(state->data, NULL, start);
+ timeout_ms = Curl_timeleft_ms(state->data, start);
if(timeout_ms < 0) {
/* time-out, bail out, go home */
}
/* Update the progress meter */
k->writebytecount += state->sbytes;
- Curl_pgrsSetUploadCounter(data, k->writebytecount);
+ Curl_pgrs_upload_inc(data, state->sbytes);
break;
case TFTP_EVENT_TIMEOUT:
if(event)
*event = TFTP_EVENT_NONE;
- timeout_ms = Curl_timeleft_ms(state->data, NULL,
+ timeout_ms = Curl_timeleft_ms(state->data,
(state->state == TFTP_STATE_START));
if(timeout_ms < 0) {
state->error = TFTP_ERR_TIMEOUT;
if(bytestoread && Curl_rlimit_active(&data->progress.dl.rlimit)) {
curl_off_t dl_avail = Curl_rlimit_avail(&data->progress.dl.rlimit,
- curlx_now());
+ &data->progress.now);
/* DEBUGF(infof(data, "dl_rlimit, available=%" FMT_OFF_T, dl_avail));
*/
/* In case of rate limited downloads: if this loop already got
* Curl_sendrecv() is the low-level function to be called when data is to
* be read and written to/from the connection.
*/
-CURLcode Curl_sendrecv(struct Curl_easy *data, struct curltime *nowp)
+CURLcode Curl_sendrecv(struct Curl_easy *data)
{
struct SingleRequest *k = &data->req;
CURLcode result = CURLE_OK;
- DEBUGASSERT(nowp);
if(Curl_xfer_is_blocked(data)) {
result = CURLE_OK;
goto out;
goto out;
if(k->keepon) {
- if(Curl_timeleft_ms(data, nowp, FALSE) < 0) {
+ if(Curl_timeleft_ms(data, FALSE) < 0) {
if(k->size != -1) {
failf(data, "Operation timed out after %" FMT_TIMEDIFF_T
" milliseconds with %" FMT_OFF_T " out of %"
FMT_OFF_T " bytes received",
- curlx_timediff_ms(*nowp, data->progress.t_startsingle),
+ curlx_timediff_ms(data->progress.now,
+ data->progress.t_startsingle),
k->bytecount, k->size);
}
else {
failf(data, "Operation timed out after %" FMT_TIMEDIFF_T
" milliseconds with %" FMT_OFF_T " bytes received",
- curlx_timediff_ms(*nowp, data->progress.t_startsingle),
+ curlx_timediff_ms(data->progress.now,
+ data->progress.t_startsingle),
k->bytecount);
}
result = CURLE_OPERATION_TIMEDOUT;
CURLcode Curl_xfer_pause_send(struct Curl_easy *data, bool enable)
{
CURLcode result = CURLE_OK;
- Curl_rlimit_block(&data->progress.ul.rlimit, enable, curlx_now());
+ Curl_rlimit_block(&data->progress.ul.rlimit, enable, &data->progress.now);
if(!enable && Curl_creader_is_paused(data))
result = Curl_creader_unpause(data);
Curl_pgrsSendPause(data, enable);
CURLcode Curl_xfer_pause_recv(struct Curl_easy *data, bool enable)
{
CURLcode result = CURLE_OK;
- Curl_rlimit_block(&data->progress.dl.rlimit, enable, curlx_now());
+ Curl_rlimit_block(&data->progress.dl.rlimit, enable, &data->progress.now);
if(!enable && Curl_cwriter_is_paused(data))
result = Curl_cwriter_unpause(data);
Curl_conn_ev_data_pause(data, enable);
CURLcode Curl_pretransfer(struct Curl_easy *data);
-CURLcode Curl_sendrecv(struct Curl_easy *data, struct curltime *nowp);
+CURLcode Curl_sendrecv(struct Curl_easy *data);
CURLcode Curl_retry_request(struct Curl_easy *data, char **url);
bool Curl_meets_timecondition(struct Curl_easy *data, time_t timeofdoc);
#endif
Curl_netrc_init(&data->state.netrc);
Curl_init_userdefined(data);
+ Curl_pgrs_now_set(data); /* on easy handle create */
*curl = data;
return CURLE_OK;
* Return TRUE iff the given connection is considered dead.
*/
bool Curl_conn_seems_dead(struct connectdata *conn,
- struct Curl_easy *data,
- struct curltime *pnow)
+ struct Curl_easy *data)
{
DEBUGASSERT(!data->conn);
if(!CONN_INUSE(conn)) {
/* The check for a dead socket makes sense only if the connection is not in
use */
bool dead;
- struct curltime now;
- if(!pnow) {
- now = curlx_now();
- pnow = &now;
- }
- if(conn_maxage(data, conn, *pnow)) {
+ if(conn_maxage(data, conn, data->progress.now)) {
/* avoid check if already too old */
dead = TRUE;
}
if(!url_match_multiplex_limits(conn, m))
return FALSE;
- if(!CONN_INUSE(conn) && Curl_conn_seems_dead(conn, m->data, NULL)) {
+ if(!CONN_INUSE(conn) && Curl_conn_seems_dead(conn, m->data)) {
/* remove and disconnect. */
Curl_conn_terminate(m->data, conn, FALSE);
return FALSE;
conn->remote_port = -1; /* unknown at this point */
/* Store creation time to help future close decision making */
- conn->created = curlx_now();
+ conn->created = data->progress.now;
/* Store current time to give a baseline to keepalive connection times. */
conn->keepalive = conn->created;
{
struct hostname *ehost;
int eport;
- timediff_t timeout_ms = Curl_timeleft_ms(data, NULL, TRUE);
+ timediff_t timeout_ms = Curl_timeleft_ms(data, TRUE);
const char *peertype = "host";
CURLcode result;
else if(result == CURLE_OPERATION_TIMEDOUT) {
failf(data, "Failed to resolve %s '%s' with timeout after %"
FMT_TIMEDIFF_T " ms", peertype, ehost->dispname,
- curlx_timediff_ms(curlx_now(), data->progress.t_startsingle));
+ curlx_timediff_ms(data->progress.now, data->progress.t_startsingle));
return CURLE_OPERATION_TIMEDOUT;
}
else if(result) {
* @param nowp NULL or pointer to time being checked against.
*/
bool Curl_conn_seems_dead(struct connectdata *conn,
- struct Curl_easy *data,
- struct curltime *nowp);
+ struct Curl_easy *data);
/**
* Perform upkeep operations on the connection.
};
struct Progress {
+ struct curltime now; /* current time of processing */
time_t lastshow; /* time() of the last displayed progress meter or NULL to
force redraw at next call */
struct pgrs_dir ul;
ngtcp2_path_storage ps;
};
-static void pktx_update_time(struct pkt_io_ctx *pktx,
+static void pktx_update_time(struct Curl_easy *data,
+ struct pkt_io_ctx *pktx,
struct Curl_cfilter *cf)
{
struct cf_ngtcp2_ctx *ctx = cf->ctx;
- vquic_ctx_update_time(&ctx->q);
+ vquic_ctx_update_time(data, &ctx->q);
pktx->ts = (ngtcp2_tstamp)ctx->q.last_op.tv_sec * NGTCP2_SECONDS +
(ngtcp2_tstamp)ctx->q.last_op.tv_usec * NGTCP2_MICROSECONDS;
}
struct Curl_cfilter *cf,
struct Curl_easy *data)
{
+ struct cf_ngtcp2_ctx *ctx = cf->ctx;
+
pktx->cf = cf;
pktx->data = data;
ngtcp2_path_storage_zero(&pktx->ps);
- pktx_update_time(pktx, cf);
+ vquic_ctx_set_time(data, &ctx->q);
+ pktx->ts = (ngtcp2_tstamp)ctx->q.last_op.tv_sec * NGTCP2_SECONDS +
+ (ngtcp2_tstamp)ctx->q.last_op.tv_usec * NGTCP2_MICROSECONDS;
}
static int cb_h3_acked_req_body(nghttp3_conn *conn, int64_t stream_id,
if(!ctx || !data)
return NGHTTP3_ERR_CALLBACK_FAILURE;
- ctx->handshake_at = curlx_now();
+ Curl_pgrs_now_set(data); /* real change */
+ ctx->handshake_at = data->progress.now;
ctx->tls_handshake_complete = TRUE;
Curl_vquic_report_handshake(&ctx->tls, cf, data);
pktx = &local_pktx;
}
else {
- pktx_update_time(pktx, cf);
+ pktx_update_time(data, pktx, cf);
}
expiry = ngtcp2_conn_get_expiry(ctx->qconn);
struct h3_stream_ctx *stream)
{
struct cf_ngtcp2_ctx *ctx = cf->ctx;
- struct curltime now = curlx_now();
curl_off_t avail;
uint64_t ack_len = 0;
/* How many byte to ack on the stream? */
/* how much does rate limiting allow us to acknowledge? */
- avail = Curl_rlimit_avail(&data->progress.dl.rlimit, now);
+ avail = Curl_rlimit_avail(&data->progress.dl.rlimit, &data->progress.now);
if(avail == CURL_OFF_T_MAX) { /* no rate limit, ack all */
ack_len = stream->download_unacked;
}
struct Curl_cfilter *cf = user_data;
struct cf_ngtcp2_ctx *ctx = cf->ctx;
struct Curl_easy *data = stream_user_data;
+ struct Curl_easy *calling = CF_DATA_CURRENT(cf);
struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, data);
(void)conn;
if(!stream)
return NGHTTP3_ERR_CALLBACK_FAILURE;
+ if(calling)
+ Curl_pgrs_now_update(data, calling);
h3_xfer_write_resp(cf, data, stream, (const char *)buf, blen, FALSE);
CURL_TRC_CF(data, cf, "[%" PRId64 "] DATA len=%zu", stream->id, blen);
return result;
}
+struct cf_ngtcp2_recv_ctx {
+ struct pkt_io_ctx *pktx;
+ size_t pkt_count;
+};
+
static CURLcode cf_ngtcp2_recv_pkts(const unsigned char *buf, size_t buflen,
size_t gso_size,
struct sockaddr_storage *remote_addr,
socklen_t remote_addrlen, int ecn,
void *userp)
{
- struct pkt_io_ctx *pktx = userp;
+ struct cf_ngtcp2_recv_ctx *rctx = userp;
+ struct pkt_io_ctx *pktx = rctx->pktx;
struct cf_ngtcp2_ctx *ctx = pktx->cf->ctx;
ngtcp2_pkt_info pi;
ngtcp2_path path;
size_t offset, pktlen;
int rv;
+ if(!rctx->pkt_count) {
+ pktx_update_time(pktx->data, pktx, pktx->cf);
+ ngtcp2_path_storage_zero(&pktx->ps);
+ }
+
if(ecn)
CURL_TRC_CF(pktx->data, pktx->cf, "vquic_recv(len=%zu, gso=%zu, ecn=%x)",
buflen, gso_size, ecn);
pi.ecn = (uint8_t)ecn;
for(offset = 0; offset < buflen; offset += gso_size) {
+ rctx->pkt_count++;
pktlen = ((offset + gso_size) <= buflen) ? gso_size : (buflen - offset);
rv = ngtcp2_conn_read_pkt(ctx->qconn, &path, &pi,
buf + offset, pktlen, pktx->ts);
{
struct cf_ngtcp2_ctx *ctx = cf->ctx;
struct pkt_io_ctx local_pktx;
+ struct cf_ngtcp2_recv_ctx rctx;
CURLcode result = CURLE_OK;
if(!pktx) {
pktx_init(&local_pktx, cf, data);
pktx = &local_pktx;
}
- else {
- pktx_update_time(pktx, cf);
- ngtcp2_path_storage_zero(&pktx->ps);
- }
result = Curl_vquic_tls_before_recv(&ctx->tls, cf, data);
if(result)
return result;
+ rctx.pktx = pktx;
+ rctx.pkt_count = 0;
return vquic_recv_packets(cf, data, &ctx->q, 1000,
- cf_ngtcp2_recv_pkts, pktx);
+ cf_ngtcp2_recv_pkts, &rctx);
}
/**
pktx = &local_pktx;
}
else {
- pktx_update_time(pktx, cf);
+ pktx_update_time(data, pktx, cf);
ngtcp2_path_storage_zero(&pktx->ps);
}
}
return curlcode;
}
- pktx_update_time(pktx, cf);
+ pktx_update_time(data, pktx, cf);
ngtcp2_conn_update_pkt_tx_time(ctx->qconn, pktx->ts);
}
return CURLE_OK;
ctx->qlogfd = qfd; /* -1 if failure above */
quic_settings(ctx, data, pktx);
- result = vquic_ctx_init(&ctx->q);
+ result = vquic_ctx_init(data, &ctx->q);
if(result)
return result;
struct cf_ngtcp2_ctx *ctx = cf->ctx;
CURLcode result = CURLE_OK;
struct cf_call_data save;
- struct curltime now;
struct pkt_io_ctx pktx;
if(cf->connected) {
}
*done = FALSE;
- now = curlx_now();
pktx_init(&pktx, cf, data);
CF_DATA_SAVE(save, cf, data);
if(!ctx->qconn) {
- ctx->started_at = now;
+ ctx->started_at = data->progress.now;
result = cf_connect_start(cf, data, &pktx);
if(result)
goto out;
* it will close the connection when it expires. */
rp = ngtcp2_conn_get_remote_transport_params(ctx->qconn);
if(rp && rp->max_idle_timeout) {
- timediff_t idletime_ms = curlx_timediff_ms(curlx_now(), ctx->q.last_io);
+ timediff_t idletime_ms =
+ curlx_timediff_ms(data->progress.now, ctx->q.last_io);
if(idletime_ms > 0) {
uint64_t max_idle_ms =
(uint64_t)(rp->max_idle_timeout / NGTCP2_MILLISECONDS);
if(result)
goto out;
- result = vquic_ctx_init(&ctx->q);
+ result = vquic_ctx_init(data, &ctx->q);
if(result)
goto out;
struct cf_osslq_ctx *ctx = cf->ctx;
CURLcode result = CURLE_OK;
struct cf_call_data save;
- struct curltime now;
int err;
if(cf->connected) {
}
*done = FALSE;
- now = curlx_now();
CF_DATA_SAVE(save, cf, data);
if(!ctx->tls.ossl.ssl) {
- ctx->started_at = now;
+ ctx->started_at = data->progress.now;
result = cf_osslq_ctx_start(cf, data);
if(result)
goto out;
int readable = SOCKET_READABLE(ctx->q.sockfd, 0);
if(readable > 0 && (readable & CURL_CSELECT_IN)) {
ctx->got_first_byte = TRUE;
- ctx->first_byte_at = curlx_now();
+ ctx->first_byte_at = data->progress.now;
}
}
/* if not recorded yet, take the timestamp before we called
* SSL_do_handshake() as the time we received the first packet. */
ctx->got_first_byte = TRUE;
- ctx->first_byte_at = now;
+ ctx->first_byte_at = data->progress.now;
}
/* Record the handshake complete with a new time stamp. */
- now = curlx_now();
- ctx->handshake_at = now;
- ctx->q.last_io = now;
+ Curl_pgrs_now_set(data);
+ ctx->handshake_at = data->progress.now;
+ ctx->q.last_io = data->progress.now;
CURL_TRC_CF(data, cf, "handshake complete after %" FMT_TIMEDIFF_T "ms",
- curlx_timediff_ms(now, ctx->started_at));
+ curlx_timediff_ms(data->progress.now, ctx->started_at));
result = cf_osslq_verify_peer(cf, data);
if(!result) {
CURL_TRC_CF(data, cf, "peer verified");
int detail = SSL_get_error(ctx->tls.ossl.ssl, err);
switch(detail) {
case SSL_ERROR_WANT_READ:
- ctx->q.last_io = now;
+ ctx->q.last_io = data->progress.now;
CURL_TRC_CF(data, cf, "QUIC SSL_connect() -> WANT_RECV");
goto out;
case SSL_ERROR_WANT_WRITE:
- ctx->q.last_io = now;
+ ctx->q.last_io = data->progress.now;
CURL_TRC_CF(data, cf, "QUIC SSL_connect() -> WANT_SEND");
result = CURLE_OK;
goto out;
#ifdef SSL_ERROR_WANT_ASYNC
case SSL_ERROR_WANT_ASYNC:
- ctx->q.last_io = now;
+ ctx->q.last_io = data->progress.now;
CURL_TRC_CF(data, cf, "QUIC SSL_connect() -> WANT_ASYNC");
result = CURLE_OK;
goto out;
goto out;
}
CURL_TRC_CF(data, cf, "negotiated idle timeout: %" PRIu64 "ms", idle_ms);
- idletime = curlx_timediff_ms(curlx_now(), ctx->q.last_io);
+ idletime = curlx_timediff_ms(data->progress.now, ctx->q.last_io);
if(idle_ms && idletime > 0 && (uint64_t)idletime > idle_ms)
goto out;
}
}
static void cf_quiche_process_ev(struct Curl_cfilter *cf,
+ struct Curl_easy *calling,
struct Curl_easy *data,
struct h3_stream_ctx *stream,
quiche_h3_event *ev)
if(!stream)
return;
+ Curl_pgrs_now_update(data, calling);
switch(quiche_h3_event_type(ev)) {
case QUICHE_H3_EVENT_HEADERS: {
struct cb_ctx cb_ctx;
uint64_t stream_id;
struct Curl_cfilter *cf;
struct Curl_multi *multi;
+ struct Curl_easy *calling;
quiche_h3_event *ev;
};
if(stream->id == dctx->stream_id) {
struct Curl_easy *sdata = Curl_multi_get_easy(dctx->multi, mid);
if(sdata)
- cf_quiche_process_ev(dctx->cf, sdata, stream, dctx->ev);
+ cf_quiche_process_ev(dctx->cf, dctx->calling, sdata, stream, dctx->ev);
return FALSE; /* stop iterating */
}
return TRUE;
stream = H3_STREAM_CTX(ctx, data);
if(stream && stream->id == (uint64_t)rv) {
/* event for calling transfer */
- cf_quiche_process_ev(cf, data, stream, ev);
+ cf_quiche_process_ev(cf, data, data, stream, ev);
quiche_h3_event_free(ev);
if(stream->xfer_result)
return stream->xfer_result;
struct cf_quich_disp_ctx dctx;
dctx.stream_id = (uint64_t)rv;
dctx.cf = cf;
+ dctx.calling = data;
dctx.multi = data->multi;
dctx.ev = ev;
Curl_uint32_hash_visit(&ctx->streams, cf_quiche_disp_event, &dctx);
*pnread = 0;
(void)buf;
(void)blen;
- vquic_ctx_update_time(&ctx->q);
+ vquic_ctx_update_time(data, &ctx->q);
if(!stream)
return CURLE_RECV_ERROR;
CURLcode result;
*pnwritten = 0;
- vquic_ctx_update_time(&ctx->q);
+ vquic_ctx_update_time(data, &ctx->q);
result = cf_process_ingress(cf, data);
if(result)
DEBUGASSERT(ctx->q.sockfd != CURL_SOCKET_BAD);
DEBUGASSERT(ctx->initialized);
- result = vquic_ctx_init(&ctx->q);
+ result = vquic_ctx_init(data, &ctx->q);
if(result)
return result;
}
*done = FALSE;
- vquic_ctx_update_time(&ctx->q);
+ vquic_ctx_update_time(data, &ctx->q);
if(!ctx->qconn) {
result = cf_quiche_ctx_open(cf, data);
int err;
ctx->shutdown_started = TRUE;
- vquic_ctx_update_time(&ctx->q);
+ vquic_ctx_update_time(data, &ctx->q);
err = quiche_conn_close(ctx->qconn, TRUE, 0, NULL, 0);
if(err) {
CURL_TRC_CF(data, cf, "error %d adding shutdown packet, "
#include "curl_osslq.h"
#include "curl_quiche.h"
#include "../multiif.h"
+#include "../progress.h"
#include "../rand.h"
#include "vquic.h"
#include "vquic_int.h"
#endif
}
-CURLcode vquic_ctx_init(struct cf_quic_ctx *qctx)
+CURLcode vquic_ctx_init(struct Curl_easy *data,
+ struct cf_quic_ctx *qctx)
{
Curl_bufq_init2(&qctx->sendbuf, NW_CHUNK_SIZE, NW_SEND_CHUNKS,
BUFQ_OPT_SOFT_LIMIT);
}
}
#endif
- vquic_ctx_update_time(qctx);
+ vquic_ctx_set_time(data, qctx);
return CURLE_OK;
}
Curl_bufq_free(&qctx->sendbuf);
}
-void vquic_ctx_update_time(struct cf_quic_ctx *qctx)
+void vquic_ctx_set_time(struct Curl_easy *data,
+ struct cf_quic_ctx *qctx)
{
- qctx->last_op = curlx_now();
+ qctx->last_op = data->progress.now;
+}
+
+void vquic_ctx_update_time(struct Curl_easy *data,
+ struct cf_quic_ctx *qctx)
+{
+ Curl_pgrs_now_set(data);
+ qctx->last_op = data->progress.now;
}
static CURLcode send_packet_no_gso(struct Curl_cfilter *cf,
#define H3_STREAM_CTX(ctx, data) \
(data ? Curl_uint32_hash_get(&(ctx)->streams, (data)->mid) : NULL)
-CURLcode vquic_ctx_init(struct cf_quic_ctx *qctx);
+CURLcode vquic_ctx_init(struct Curl_easy *data,
+ struct cf_quic_ctx *qctx);
void vquic_ctx_free(struct cf_quic_ctx *qctx);
-void vquic_ctx_update_time(struct cf_quic_ctx *qctx);
+void vquic_ctx_set_time(struct Curl_easy *data,
+ struct cf_quic_ctx *qctx);
+
+void vquic_ctx_update_time(struct Curl_easy *data,
+ struct cf_quic_ctx *qctx);
void vquic_push_blocked_pkt(struct Curl_cfilter *cf,
struct cf_quic_ctx *qctx,
if(result)
break;
- left_ms = Curl_timeleft_ms(data, NULL, FALSE);
+ left_ms = Curl_timeleft_ms(data, FALSE);
if(left_ms < 0) {
failf(data, "Operation timed out");
return CURLE_OPERATION_TIMEDOUT;
bool disconnect)
{
CURLcode result = CURLE_OK;
- struct curltime dis = curlx_now();
+ struct curltime start = data->progress.now;
while((sshc->state != SSH_STOP) && !result) {
bool block;
timediff_t left_ms = 1000;
- struct curltime now = curlx_now();
+ Curl_pgrs_now_set(data); /* timeout disconnect */
result = ssh_statemachine(data, sshc, sshp, &block);
if(result)
break;
if(result)
break;
- left_ms = Curl_timeleft_ms(data, NULL, FALSE);
+ left_ms = Curl_timeleft_ms(data, FALSE);
if(left_ms < 0) {
failf(data, "Operation timed out");
return CURLE_OPERATION_TIMEDOUT;
}
}
- else if(curlx_timediff_ms(now, dis) > 1000) {
+ else if(curlx_timediff_ms(data->progress.now, start) > 1000) {
/* disconnect timeout */
failf(data, "Disconnect timed out");
result = CURLE_OK;
}
shared->refcount = 1;
- shared->time = curlx_now();
+ shared->time = data->progress.now;
*pcreds = shared;
return CURLE_OK;
}
const struct gtls_shared_creds *sc)
{
const struct ssl_general_config *cfg = &data->set.general_ssl;
- struct curltime now = curlx_now();
- timediff_t elapsed_ms = curlx_timediff_ms(now, sc->time);
+ timediff_t elapsed_ms = curlx_timediff_ms(data->progress.now, sc->time);
timediff_t timeout_ms = cfg->ca_cache_timeout * (timediff_t)1000;
if(timeout_ms < 0)
if(cfg->ca_cache_timeout < 0)
return FALSE;
else {
- struct curltime now = curlx_now();
- timediff_t elapsed_ms = curlx_timediff_ms(now, mb->time);
+ timediff_t elapsed_ms = curlx_timediff_ms(data->progress.now, mb->time);
timediff_t timeout_ms = cfg->ca_cache_timeout * (timediff_t)1000;
return elapsed_ms >= timeout_ms;
curlx_free(share->CAfile);
}
- share->time = curlx_now();
+ share->time = data->progress.now;
share->store = store;
share->store_is_empty = is_empty;
share->CAfile = CAfile;
remaining = MAX_RENEG_BLOCK_TIME - elapsed;
if(blocking) {
- timeout_ms = Curl_timeleft_ms(data, NULL, FALSE);
+ timeout_ms = Curl_timeleft_ms(data, FALSE);
if(timeout_ms < 0) {
result = CURLE_OPERATION_TIMEDOUT;
while(len > *pnwritten) {
size_t this_write = 0;
int what;
- timediff_t timeout_ms = Curl_timeleft_ms(data, NULL, FALSE);
+ timediff_t timeout_ms = Curl_timeleft_ms(data, FALSE);
if(timeout_ms < 0) {
/* we already got the timeout */
failf(data, "schannel: timed out sending data "
if(!result && *done) {
cf->connected = TRUE;
- if(connssl->state == ssl_connection_complete)
- connssl->handshake_done = curlx_now();
+ if(connssl->state == ssl_connection_complete) {
+ Curl_pgrs_now_set(data);
+ connssl->handshake_done = data->progress.now;
+ }
/* Connection can be deferred when sending early data */
DEBUGASSERT(connssl->state == ssl_connection_complete ||
connssl->state == ssl_connection_deferred);
*done = FALSE;
while(!result && !*done && loop--) {
- timeout_ms = Curl_shutdown_timeleft(cf->conn, cf->sockindex, NULL);
+ timeout_ms = Curl_shutdown_timeleft(data, cf->conn, cf->sockindex);
if(timeout_ms < 0) {
/* no need to continue if time is already up */
if(cf->cft == &Curl_cft_ssl) {
bool done;
CURL_TRC_CF(data, cf, "shutdown and remove SSL, start");
- Curl_shutdown_start(data, sockindex, 0, NULL);
+ Curl_shutdown_start(data, sockindex, 0);
result = vtls_shutdown_blocking(cf, data, send_shutdown, &done);
Curl_shutdown_clear(data, sockindex);
if(!result && !done) /* blocking failed? */
const struct wssl_x509_share *mb)
{
const struct ssl_general_config *cfg = &data->set.general_ssl;
- struct curltime now = curlx_now();
- timediff_t elapsed_ms = curlx_timediff_ms(now, mb->time);
+ timediff_t elapsed_ms = curlx_timediff_ms(data->progress.now, mb->time);
timediff_t timeout_ms = cfg->ca_cache_timeout * (timediff_t)1000;
if(timeout_ms < 0)
curlx_free(share->CAfile);
}
- share->time = curlx_now();
+ share->time = data->progress.now;
share->store = store;
share->CAfile = CAfile;
}
CURL_TRC_WS(data, "ws_send_raw_blocking() partial, %zu left to send",
buflen);
- left_ms = Curl_timeleft_ms(data, NULL, FALSE);
+ left_ms = Curl_timeleft_ms(data, FALSE);
if(left_ms < 0) {
failf(data, "[WS] Timeout waiting for socket becoming writable");
return CURLE_SEND_ERROR;
s/^server: nghttpx.*\r?\n//
</stripfile>
<limits>
-Allocations: 150
+Allocations: 155
Maximum allocated: 1800000
</limits>
</verify>
timediff_t timeout;
NOW(run[i].now_s, run[i].now_us);
TIMEOUTS(run[i].timeout_ms, run[i].connecttimeout_ms);
- timeout = Curl_timeleft_ms(easy, &now, run[i].connecting);
+ easy->progress.now = now;
+ timeout = Curl_timeleft_ms(easy, run[i].connecting);
if(timeout != run[i].result)
fail(run[i].comment);
}
struct Curl_easy data;
struct curltime now = curlx_now();
+ data.progress.now = now;
data.progress.t_nslookup = 0;
data.progress.t_connect = 0;
data.progress.t_appconnect = 0;
/* A ratelimit that is unlimited */
ts = curlx_now();
- Curl_rlimit_init(&r, 0, 0, ts);
- fail_unless(Curl_rlimit_avail(&r, ts) == CURL_OFF_T_MAX, "inf");
- Curl_rlimit_drain(&r, 1000000, ts);
- fail_unless(Curl_rlimit_avail(&r, ts) == CURL_OFF_T_MAX, "drain keep inf");
- fail_unless(Curl_rlimit_wait_ms(&r, ts) == 0, "inf never waits");
+ Curl_rlimit_init(&r, 0, 0, &ts);
+ fail_unless(Curl_rlimit_avail(&r, &ts) == CURL_OFF_T_MAX, "inf");
+ Curl_rlimit_drain(&r, 1000000, &ts);
+ fail_unless(Curl_rlimit_avail(&r, &ts) == CURL_OFF_T_MAX, "drain keep inf");
+ fail_unless(Curl_rlimit_wait_ms(&r, &ts) == 0, "inf never waits");
- Curl_rlimit_block(&r, TRUE, ts);
- fail_unless(Curl_rlimit_avail(&r, ts) == 0, "inf blocked to 0");
- Curl_rlimit_drain(&r, 1000000, ts);
- fail_unless(Curl_rlimit_avail(&r, ts) == 0, "blocked inf");
- Curl_rlimit_block(&r, FALSE, ts);
- fail_unless(Curl_rlimit_avail(&r, ts) == CURL_OFF_T_MAX,
+ Curl_rlimit_block(&r, TRUE, &ts);
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 0, "inf blocked to 0");
+ Curl_rlimit_drain(&r, 1000000, &ts);
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 0, "blocked inf");
+ Curl_rlimit_block(&r, FALSE, &ts);
+ fail_unless(Curl_rlimit_avail(&r, &ts) == CURL_OFF_T_MAX,
"unblocked unlimited");
/* A ratelimit that give 10 tokens per second */
ts = curlx_now();
- Curl_rlimit_init(&r, 10, 0, ts);
- fail_unless(Curl_rlimit_avail(&r, ts) == 10, "initial 10");
- Curl_rlimit_drain(&r, 5, ts);
- fail_unless(Curl_rlimit_avail(&r, ts) == 5, "drain to 5");
- Curl_rlimit_drain(&r, 3, ts);
- fail_unless(Curl_rlimit_avail(&r, ts) == 2, "drain to 2");
+ Curl_rlimit_init(&r, 10, 0, &ts);
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 10, "initial 10");
+ Curl_rlimit_drain(&r, 5, &ts);
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 5, "drain to 5");
+ Curl_rlimit_drain(&r, 3, &ts);
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 2, "drain to 2");
ts.tv_usec += 1000; /* 1ms */
- Curl_rlimit_drain(&r, 3, ts);
- fail_unless(Curl_rlimit_avail(&r, ts) == -1, "drain to -1");
- fail_unless(Curl_rlimit_wait_ms(&r, ts) == 999, "wait 999ms");
+ Curl_rlimit_drain(&r, 3, &ts);
+ fail_unless(Curl_rlimit_avail(&r, &ts) == -1, "drain to -1");
+ fail_unless(Curl_rlimit_wait_ms(&r, &ts) == 999, "wait 999ms");
ts.tv_usec += 1000; /* 1ms */
- fail_unless(Curl_rlimit_wait_ms(&r, ts) == 998, "wait 998ms");
+ fail_unless(Curl_rlimit_wait_ms(&r, &ts) == 998, "wait 998ms");
ts.tv_sec += 1;
- fail_unless(Curl_rlimit_avail(&r, ts) == 9, "10 inc per sec");
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 9, "10 inc per sec");
ts.tv_sec += 1;
- fail_unless(Curl_rlimit_avail(&r, ts) == 19, "10 inc per sec(2)");
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 19, "10 inc per sec(2)");
- Curl_rlimit_block(&r, TRUE, curlx_now());
- fail_unless(Curl_rlimit_avail(&r, curlx_now()) == 0, "10 blocked to 0");
- Curl_rlimit_block(&r, FALSE, curlx_now());
- fail_unless(Curl_rlimit_avail(&r, curlx_now()) == 10, "unblocked 10");
+ ts = curlx_now();
+ Curl_rlimit_block(&r, TRUE, &ts);
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 0, "10 blocked to 0");
+ Curl_rlimit_block(&r, FALSE, &ts);
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 10, "unblocked 10");
/* A ratelimit that give 10 tokens per second, max burst 15/s */
ts = curlx_now();
- Curl_rlimit_init(&r, 10, 15, ts);
- fail_unless(Curl_rlimit_avail(&r, ts) == 10, "initial 10");
- Curl_rlimit_drain(&r, 5, ts);
- fail_unless(Curl_rlimit_avail(&r, ts) == 5, "drain to 5");
- Curl_rlimit_drain(&r, 3, ts);
- fail_unless(Curl_rlimit_avail(&r, ts) == 2, "drain to 2");
- Curl_rlimit_drain(&r, 3, ts);
- fail_unless(Curl_rlimit_avail(&r, ts) == -1, "drain to -1");
+ Curl_rlimit_init(&r, 10, 15, &ts);
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 10, "initial 10");
+ Curl_rlimit_drain(&r, 5, &ts);
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 5, "drain to 5");
+ Curl_rlimit_drain(&r, 3, &ts);
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 2, "drain to 2");
+ Curl_rlimit_drain(&r, 3, &ts);
+ fail_unless(Curl_rlimit_avail(&r, &ts) == -1, "drain to -1");
ts.tv_sec += 1;
- fail_unless(Curl_rlimit_avail(&r, ts) == 9, "10 inc per sec");
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 9, "10 inc per sec");
ts.tv_sec += 1;
- fail_unless(Curl_rlimit_avail(&r, ts) == 15, "10/15 burst limit");
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 15, "10/15 burst limit");
ts.tv_sec += 1;
- fail_unless(Curl_rlimit_avail(&r, ts) == 15, "10/15 burst limit(2)");
- Curl_rlimit_drain(&r, 15, ts);
- fail_unless(Curl_rlimit_avail(&r, ts) == 0, "drain to 0");
- fail_unless(Curl_rlimit_wait_ms(&r, ts) == 1000, "wait 1 sec");
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 15, "10/15 burst limit(2)");
+ Curl_rlimit_drain(&r, 15, &ts);
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 0, "drain to 0");
+ fail_unless(Curl_rlimit_wait_ms(&r, &ts) == 1000, "wait 1 sec");
ts.tv_usec += 500000; /* half a sec, cheating on second carry */
- fail_unless(Curl_rlimit_avail(&r, ts) == 0, "0 after 0.5 sec");
- fail_unless(Curl_rlimit_wait_ms(&r, ts) == 500, "wait 0.5 sec");
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 0, "0 after 0.5 sec");
+ fail_unless(Curl_rlimit_wait_ms(&r, &ts) == 500, "wait 0.5 sec");
ts.tv_sec += 1;
- fail_unless(Curl_rlimit_avail(&r, ts) == 10, "10 after 1.5 sec");
- fail_unless(Curl_rlimit_wait_ms(&r, ts) == 0, "wait 0");
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 10, "10 after 1.5 sec");
+ fail_unless(Curl_rlimit_wait_ms(&r, &ts) == 0, "wait 0");
ts.tv_usec += 500000; /* half a sec, cheating on second carry */
- fail_unless(Curl_rlimit_avail(&r, ts) == 15, "10 after 2 sec");
+ fail_unless(Curl_rlimit_avail(&r, &ts) == 15, "10 after 2 sec");
UNITTEST_END_SIMPLE
}
projects / thirdparty / curl.git / commitdiff
