/* 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(curlx_now(), ares->happy_eyeballs_dns_time)
+ && (curlx_timediff_ms(curlx_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;
+ timediff_t timeout_ms;
struct curltime now = curlx_now();
DEBUGASSERT(entry);
*entry = NULL; /* clear on entry */
- timeout = Curl_timeleft(data, &now, TRUE);
- if(timeout < 0) {
+ timeout_ms = Curl_timeleft_ms(data, &now, TRUE);
+ if(timeout_ms < 0) {
/* already expired! */
connclose(data->conn, "Timed out before name resolve started");
return CURLE_OPERATION_TIMEDOUT;
}
- if(!timeout)
- timeout = CURL_TIMEOUT_RESOLVE * 1000; /* default name resolve timeout */
+ if(!timeout_ms)
+ timeout_ms = CURL_TIMEOUT_RESOLVE * 1000; /* default name resolve */
/* Wait for the name resolve query to complete. */
while(!result) {
- struct timeval *tvp, tv, store;
- int itimeout;
- timediff_t timeout_ms;
+ struct timeval *real_timeout, time_buf, max_timeout;
+ int itimeout_ms;
+ timediff_t call_timeout_ms;
#if TIMEDIFF_T_MAX > INT_MAX
- itimeout = (timeout > INT_MAX) ? INT_MAX : (int)timeout;
+ itimeout_ms = (timeout_ms > INT_MAX) ? INT_MAX : (int)timeout_ms;
#else
- itimeout = (int)timeout;
+ itimeout_ms = (int)timeout_ms;
#endif
- store.tv_sec = itimeout/1000;
- store.tv_usec = (itimeout%1000)*1000;
+ max_timeout.tv_sec = itimeout_ms/1000;
+ max_timeout.tv_usec = (itimeout_ms%1000)*1000;
- tvp = ares_timeout(ares->channel, &store, &tv);
+ real_timeout = ares_timeout(ares->channel, &max_timeout, &time_buf);
/* use the timeout period ares returned to us above if less than one
second is left, otherwise just use 1000ms to make sure the progress
callback gets called frequent enough */
- if(!tvp->tv_sec)
- timeout_ms = (timediff_t)(tvp->tv_usec/1000);
+ if(!real_timeout->tv_sec)
+ call_timeout_ms = (timediff_t)(real_timeout->tv_usec/1000);
else
- timeout_ms = 1000;
+ call_timeout_ms = 1000;
- if(Curl_ares_perform(ares->channel, timeout_ms) < 0)
+ if(Curl_ares_perform(ares->channel, call_timeout_ms) < 0)
return CURLE_UNRECOVERABLE_POLL;
result = Curl_async_is_resolved(data, entry);
result = CURLE_ABORTED_BY_CALLBACK;
else {
struct curltime now2 = curlx_now();
- timediff_t timediff = curlx_timediff(now2, now); /* spent time */
- if(timediff <= 0)
- timeout -= 1; /* always deduct at least 1 */
- else if(timediff > timeout)
- timeout = -1;
+ timediff_t elapsed_ms = curlx_timediff_ms(now2, now); /* spent time */
+ if(elapsed_ms <= 0)
+ timeout_ms -= 1; /* always deduct at least 1 */
+ else if(elapsed_ms > timeout_ms)
+ timeout_ms = -1;
else
- timeout -= timediff;
+ timeout_ms -= elapsed_ms;
now = now2; /* for next loop */
}
- if(timeout < 0)
+ if(timeout_ms < 0)
result = CURLE_OPERATION_TIMEDOUT;
}
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(curlx_now(),
- data->progress.t_startsingle);
+ timediff_t elapsed = curlx_timediff_ms(curlx_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(curlx_now(), thrdd->addr->start);
+ timediff_t ms = curlx_timediff_ms(curlx_now(), thrdd->addr->start);
if(ms < 3)
milli = 0;
else if(ms <= 50)
return CURLE_RECV_ERROR; /* Need a cfilter close and new bootstrap */
do {
- timediff_t check;
- check = Curl_timeleft(data, NULL, TRUE);
- if(check <= 0) {
+ if(Curl_timeleft_ms(data, NULL, TRUE) < 0) {
failf(data, "Proxy CONNECT aborted due to timeout");
result = CURLE_OPERATION_TIMEDOUT;
goto out;
struct cf_h2_proxy_ctx *ctx = cf->ctx;
CURLcode result = CURLE_OK;
struct cf_call_data save;
- timediff_t check;
struct tunnel_stream *ts = &ctx->tunnel;
if(cf->connected) {
}
DEBUGASSERT(ts->authority);
- check = Curl_timeleft(data, NULL, TRUE);
- if(check <= 0) {
+ if(Curl_timeleft_ms(data, NULL, TRUE) < 0) {
failf(data, "Proxy CONNECT aborted due to timeout");
result = CURLE_OPERATION_TIMEDOUT;
goto out;
reply_ms = cf_hc_baller_reply_ms(winner, data);
if(reply_ms >= 0)
CURL_TRC_CF(data, cf, "connect+handshake %s: %dms, 1st data: %dms",
- winner->name, (int)curlx_timediff(curlx_now(),
- winner->started), reply_ms);
+ winner->name,
+ (int)curlx_timediff_ms(curlx_now(),
+ winner->started), reply_ms);
else
CURL_TRC_CF(data, cf, "deferred handshake %s: %dms",
- winner->name, (int)curlx_timediff(curlx_now(),
- winner->started));
+ winner->name, (int)curlx_timediff_ms(curlx_now(),
+ winner->started));
/* install the winning filter below this one. */
cf->next = winner->cf;
ctx->ballers[idx].name);
return TRUE;
}
- elapsed_ms = curlx_timediff(now, ctx->started);
+ elapsed_ms = curlx_timediff_ms(now, ctx->started);
if(elapsed_ms >= ctx->hard_eyeballs_timeout_ms) {
CURL_TRC_CF(data, cf, "hard timeout of %" FMT_TIMEDIFF_T "ms reached, "
"starting %s",
more_possible = cf_ai_iter_has_more(&bs->ipv6_iter);
#endif
do_more = more_possible &&
- (curlx_timediff(now, bs->last_attempt_started) >=
- bs->attempt_delay_ms);
+ (curlx_timediff_ms(now, bs->last_attempt_started) >=
+ bs->attempt_delay_ms);
if(do_more)
CURL_TRC_CF(data, cf, "happy eyeballs timeout expired, "
"start next attempt");
else if(inconclusive) {
/* tried all addresses, no success but some where inconclusive.
* Let's restart the inconclusive ones. */
- timediff_t since_ms = curlx_timediff(now, bs->last_attempt_started);
+ timediff_t since_ms = curlx_timediff_ms(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");
bool more_possible;
/* when do we need to be called again? */
- next_expire_ms = Curl_timeleft(data, &now, TRUE);
+ next_expire_ms = Curl_timeleft_ms(data, &now, TRUE);
if(next_expire_ms <= 0) {
failf(data, "Connection timeout after %" FMT_OFF_T " ms",
- curlx_timediff(now, data->progress.t_startsingle));
+ curlx_timediff_ms(now, data->progress.t_startsingle));
return CURLE_OPERATION_TIMEDOUT;
}
#endif
if(more_possible) {
timediff_t expire_ms, elapsed_ms;
- elapsed_ms = curlx_timediff(now, bs->last_attempt_started);
+ elapsed_ms = curlx_timediff_ms(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(curlx_now(), data->progress.t_startsingle),
+ curlx_timediff_ms(curlx_now(), data->progress.t_startsingle),
curl_easy_strerror(result));
}
if(!dns)
return CURLE_FAILED_INIT;
- if(Curl_timeleft(data, NULL, TRUE) < 0) {
+ if(Curl_timeleft_ms(data, NULL, TRUE) < 0) {
/* a precaution, no need to continue if time already is up */
failf(data, "Connection time-out");
return CURLE_OPERATION_TIMEDOUT;
DWORD ideallen;
struct curltime n = curlx_now();
- if(curlx_timediff(n, ctx->last_sndbuf_query_at) > 1000) {
+ if(curlx_timediff_ms(n, 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 &&
return CURLE_OK;
case CF_QUERY_CONNECT_REPLY_MS:
if(ctx->got_first_byte) {
- timediff_t ms = curlx_timediff(ctx->first_byte_at, ctx->started_at);
+ timediff_t ms = curlx_timediff_ms(ctx->first_byte_at, ctx->started_at);
*pres1 = (ms < INT_MAX) ? (int)ms : INT_MAX;
}
else
{
struct cf_socket_ctx *ctx = cf->ctx;
timediff_t timeout_ms = DEFAULT_ACCEPT_TIMEOUT;
- timediff_t other;
+ timediff_t other_ms;
struct curltime now;
#ifndef CURL_DISABLE_FTP
now = curlx_now();
/* check if the generic timeout possibly is set shorter */
- other = Curl_timeleft(data, &now, FALSE);
- if(other && (other < timeout_ms))
- /* note that this also works fine for when other happens to be negative
+ other_ms = Curl_timeleft_ms(data, &now, 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;
+ timeout_ms = other_ms;
else {
/* subtract elapsed time */
- timeout_ms -= curlx_timediff(now, ctx->started_at);
+ timeout_ms -= curlx_timediff_ms(now, ctx->started_at);
if(!timeout_ms)
/* avoid returning 0 as that means no timeout! */
timeout_ms = -1;
goto out;
else {
/* check allowed time left */
- const timediff_t timeout_ms = Curl_timeleft(data, NULL, TRUE);
+ const timediff_t timeout_ms = Curl_timeleft_ms(data, NULL, TRUE);
curl_socket_t sockfd = Curl_conn_cf_get_socket(cf, data);
int rc;
if(!CONN_INUSE(conn)) {
/* Set higher score for the age passed since the connection was used */
- score = curlx_timediff(now, conn->lastused);
+ score = curlx_timediff_ms(now, conn->lastused);
if(score > highscore) {
highscore = score;
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(now, conn->lastused);
+ score = curlx_timediff_ms(now, conn->lastused);
if(score > highscore) {
highscore = score;
oldest_idle = conn;
rctx.now = curlx_now();
CPOOL_LOCK(cpool, data);
- elapsed = curlx_timediff(rctx.now, cpool->last_cleanup);
+ elapsed = curlx_timediff_ms(rctx.now, cpool->last_cleanup);
if(elapsed >= 1000L) {
while(cpool_foreach(data, cpool, &rctx, cpool_reap_dead_cb))
#endif
/*
- * Curl_timeleft() returns the amount of milliseconds left allowed for the
+ * Curl_timeleft_ms() returns the amount of milliseconds left allowed for the
* transfer/connection. If the value is 0, there is no timeout (ie there is
* infinite time left). If the value is negative, the timeout time has already
* elapsed.
* @param duringconnect TRUE iff connect timeout is also taken into account.
* @unittest: 1303
*/
-timediff_t Curl_timeleft(struct Curl_easy *data,
- struct curltime *nowp,
- bool duringconnect)
+timediff_t Curl_timeleft_ms(struct Curl_easy *data,
+ struct curltime *nowp,
+ bool duringconnect)
{
timediff_t timeleft_ms = 0;
timediff_t ctimeleft_ms = 0;
if(data->set.timeout) {
timeleft_ms = data->set.timeout -
- curlx_timediff(*nowp, data->progress.t_startop);
+ curlx_timediff_ms(*nowp, data->progress.t_startop);
if(!timeleft_ms)
timeleft_ms = -1; /* 0 is "no limit", fake 1 ms expiry */
if(!duringconnect)
timediff_t ctimeout_ms = (data->set.connecttimeout > 0) ?
data->set.connecttimeout : DEFAULT_CONNECT_TIMEOUT;
ctimeleft_ms = ctimeout_ms -
- curlx_timediff(*nowp, data->progress.t_startsingle);
+ curlx_timediff_ms(*nowp, data->progress.t_startsingle);
if(!ctimeleft_ms)
ctimeleft_ms = -1; /* 0 is "no limit", fake 1 ms expiry */
if(!timeleft_ms)
nowp = &now;
}
left_ms = conn->shutdown.timeout_ms -
- curlx_timediff(*nowp, conn->shutdown.start[sockindex]);
+ curlx_timediff_ms(*nowp, conn->shutdown.start[sockindex]);
return left_ms ? left_ms : -1;
}
/* generic function that returns how much time there is left to run, according
to the timeouts set */
-timediff_t Curl_timeleft(struct Curl_easy *data,
- struct curltime *nowp,
- bool duringconnect);
+timediff_t Curl_timeleft_ms(struct Curl_easy *data,
+ struct curltime *nowp,
+ bool duringconnect);
#define DEFAULT_CONNECT_TIMEOUT 300000 /* milliseconds == five minutes */
sigpipe_apply(data, &pipe_st);
while(Curl_llist_head(&cshutdn->list)) {
- timediff_t timespent;
+ timediff_t spent_ms;
int remain_ms;
cshutdn_perform(cshutdn, data);
}
/* wait for activity, timeout or "nothing" */
- timespent = curlx_timediff(curlx_now(), started);
- if(timespent >= (timediff_t)timeout_ms) {
+ spent_ms = curlx_timediff_ms(curlx_now(), started);
+ if(spent_ms >= (timediff_t)timeout_ms) {
CURL_TRC_M(data, "[SHUTDOWN] shutdown finished, %s",
(timeout_ms > 0) ? "timeout" : "best effort done");
break;
}
- remain_ms = timeout_ms - (int)timespent;
+ remain_ms = timeout_ms - (int)spent_ms;
if(cshutdn_wait(cshutdn, data, remain_ms)) {
CURL_TRC_M(data, "[SHUTDOWN] shutdown finished, aborted");
break;
*
* @unittest: 1323
*/
-timediff_t curlx_timediff(struct curltime newer, struct curltime older)
+timediff_t curlx_timediff_ms(struct curltime newer, struct curltime older)
{
timediff_t diff = (timediff_t)newer.tv_sec-older.tv_sec;
if(diff >= (TIMEDIFF_T_MAX/1000))
* Returns: time difference in number of milliseconds, rounded up.
* For too large diffs it returns max value.
*/
-timediff_t curlx_timediff_ceil(struct curltime newer, struct curltime older)
+timediff_t curlx_timediff_ceil_ms(struct curltime newer,
+ struct curltime older)
{
timediff_t diff = (timediff_t)newer.tv_sec-older.tv_sec;
if(diff >= (TIMEDIFF_T_MAX/1000))
*
* Returns: the time difference in number of milliseconds.
*/
-timediff_t curlx_timediff(struct curltime newer, struct curltime older);
+timediff_t curlx_timediff_ms(struct curltime newer, struct curltime older);
/*
* Make sure that the first argument (newer) is the more recent time and older
*
* Returns: the time difference in number of milliseconds, rounded up.
*/
-timediff_t curlx_timediff_ceil(struct curltime newer, struct curltime older);
+timediff_t curlx_timediff_ceil_ms(struct curltime newer,
+ struct curltime older);
/*
* Make sure that the first argument (newer) is the more recent time and older
goto error;
}
- timeout_ms = Curl_timeleft(data, NULL, TRUE);
+ timeout_ms = Curl_timeleft_ms(data, NULL, TRUE);
if(timeout_ms <= 0) {
result = CURLE_OPERATION_TIMEDOUT;
goto error;
/* If nothing updated the timeout, we decrease it by the spent time.
* If it was updated, it has the new timeout time stored already.
*/
- timediff_t timediff = curlx_timediff(curlx_now(), before);
- if(timediff > 0) {
+ timediff_t spent_ms = curlx_timediff_ms(curlx_now(), before);
+ if(spent_ms > 0) {
#if DEBUG_EV_POLL
curl_mfprintf(stderr, "poll timeout %ldms not updated, decrease by "
"time spent %ldms\n", ev->ms, (long)timediff);
#endif
- if(timediff > ev->ms)
+ if(spent_ms > ev->ms)
ev->ms = 0;
else
- ev->ms -= (long)timediff;
+ ev->ms -= (long)spent_ms;
}
}
}
else
break;
- timeout_ms = Curl_timeleft(data, NULL, FALSE);
+ timeout_ms = Curl_timeleft_ms(data, NULL, FALSE);
if(timeout_ms < 0) {
result = CURLE_OPERATION_TIMEDOUT;
break;
if(dns->timestamp.tv_sec || dns->timestamp.tv_usec) {
/* get age in milliseconds */
- timediff_t age = curlx_timediff(prune->now, dns->timestamp);
+ timediff_t age = curlx_timediff_ms(prune->now, dns->timestamp);
if(!dns->addr)
age *= 2; /* negative entries age twice as fast */
if(age >= prune->max_age_ms)
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(curlx_now(),
- data->conn->created) / 1000;
+ timediff_t elapsed_secs = curlx_timediff_ms(curlx_now(),
+ data->conn->created) / 1000;
/* the alarm period is counted in even number of seconds */
unsigned long alarm_set = (unsigned long)(prev_alarm - elapsed_secs);
*eos = FALSE;
return CURLE_READ_ERROR;
case EXP100_AWAITING_CONTINUE:
- ms = curlx_timediff(curlx_now(), ctx->start);
+ ms = curlx_timediff_ms(curlx_now(), ctx->start);
if(ms < data->set.expect_100_timeout) {
DEBUGF(infof(data, "cr_exp100_read, AWAITING_CONTINUE, not expired"));
data->req.keepon &= ~KEEP_SEND;
!mq->pingsent &&
data->set.upkeep_interval_ms > 0) {
struct curltime t = curlx_now();
- timediff_t diff = curlx_timediff(t, mq->lastTime);
+ timediff_t diff = curlx_timediff_ms(t, mq->lastTime);
if(diff > data->set.upkeep_interval_ms) {
/* 0xC0 is PINGREQ, and 0x00 is remaining length */
CURLcode *result)
{
bool connect_timeout = data->mstate < MSTATE_DO;
- timediff_t timeout_ms = Curl_timeleft(data, now, connect_timeout);
+ timediff_t timeout_ms = Curl_timeleft_ms(data, now, 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(*now, since));
+ " milliseconds", curlx_timediff_ms(*now, since));
else if(data->mstate == MSTATE_CONNECTING)
failf(data, "Connection timed out after %" FMT_TIMEDIFF_T
- " milliseconds", curlx_timediff(*now, since));
+ " milliseconds", curlx_timediff_ms(*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(*now, since), k->bytecount, k->size);
+ curlx_timediff_ms(*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(*now, since), k->bytecount);
+ curlx_timediff_ms(*now, since), k->bytecount);
}
}
*result = CURLE_OPERATION_TIMEDOUT;
if(multi->timetree &&
curlx_timediff_us(multi->timetree->key, now) > 0) {
/* some time left before expiration */
- timediff_t diff = curlx_timediff_ceil(multi->timetree->key, now);
+ timediff_t diff_ms = curlx_timediff_ceil_ms(multi->timetree->key, now);
#ifndef CURL_DISABLE_VERBOSE_STRINGS
data = Curl_splayget(multi->timetree);
#endif
/* this should be safe even on 32-bit archs, as we do not use that
overly long timeouts */
- *timeout_ms = (long)diff;
+ *timeout_ms = (long)diff_ms;
}
else {
#ifndef CURL_DISABLE_VERBOSE_STRINGS
/* find the correct spot in the list */
for(e = Curl_llist_head(timeoutlist); e; e = Curl_node_next(e)) {
struct time_node *check = Curl_node_elem(e);
- timediff_t diff = curlx_timediff(check->time, node->time);
+ timediff_t diff = curlx_timediff_ms(check->time, node->time);
if(diff > 0)
break;
prev = e;
/* This means that the struct is added as a node in the splay tree.
Compare if the new time is earlier, and only remove-old/add-new if it
is. */
- timediff_t diff = curlx_timediff(set, *curr_expire);
+ timediff_t diff = curlx_timediff_ms(set, *curr_expire);
int rc;
if(diff > 0) {
/* 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(now, pp->response);
+ timeout_ms = response_time - curlx_timediff_ms(now, pp->response);
if(data->set.timeout && !disconnecting) {
/* if timeout is requested, find out how much overall remains */
- timediff_t timeout2_ms = Curl_timeleft(data, &now, FALSE);
+ timediff_t timeout2_ms = Curl_timeleft_ms(data, &now, FALSE);
/* pick the lowest number */
timeout_ms = CURLMIN(timeout_ms, timeout2_ms);
}
if(disconnecting) {
- timediff_t total_left_ms = Curl_timeleft(data, NULL, FALSE);
+ timediff_t total_left_ms = Curl_timeleft_ms(data, NULL, FALSE);
timeout_ms = CURLMIN(timeout_ms, CURLMAX(total_left_ms, 0));
}
return 0;
/* The time it took us to have `bytes` */
- took_ms = curlx_timediff_ceil(now, d->limit.start);
+ took_ms = curlx_timediff_ceil_ms(now, d->limit.start);
/* The time it *should* have taken us to have `bytes`
* when obeying the bytes_per_sec speed_limit. */
{
/* do not set a new stamp unless the time since last update is long enough */
if(data->set.max_recv_speed) {
- if(curlx_timediff(now, data->progress.dl.limit.start) >=
+ if(curlx_timediff_ms(now, data->progress.dl.limit.start) >=
MIN_RATE_LIMIT_PERIOD) {
data->progress.dl.limit.start = now;
data->progress.dl.limit.start_size = data->progress.dl.cur_size;
}
}
if(data->set.max_send_speed) {
- if(curlx_timediff(now, data->progress.ul.limit.start) >=
+ if(curlx_timediff_ms(now, data->progress.ul.limit.start) >=
MIN_RATE_LIMIT_PERIOD) {
data->progress.ul.limit.start = now;
data->progress.ul.limit.start_size = data->progress.ul.cur_size;
checkindex = (p->speeder_c >= CURR_TIME) ? p->speeder_c%CURR_TIME : 0;
/* Figure out the exact time for the time span */
- span_ms = curlx_timediff(now, p->speeder_time[checkindex]);
+ span_ms = curlx_timediff_ms(now, p->speeder_time[checkindex]);
if(span_ms == 0)
span_ms = 1; /* at least one millisecond MUST have passed */
curlx_unicodefree(tchar_newpath);
break;
}
- diff = curlx_timediff(curlx_now(), start);
+ diff = curlx_timediff_ms(curlx_now(), start);
if(diff < 0 || diff > max_wait_ms) {
curlx_unicodefree(tchar_oldpath);
curlx_unicodefree(tchar_newpath);
if(nread == -1) {
int sockerr = SOCKERRNO;
/* Do not block forever */
- if(curlx_timediff(curlx_now(), start) > (60 * 1000))
+ if(curlx_timediff_ms(curlx_now(), start) > (60 * 1000))
goto error;
if(
#ifdef USE_WINSOCK
*pnread = 0;
for(;;) {
- timediff_t timeout_ms = Curl_timeleft(data, NULL, TRUE);
+ timediff_t timeout_ms = Curl_timeleft_ms(data, NULL, TRUE);
if(timeout_ms < 0) {
/* we already got the timeout */
return CURLE_OPERATION_TIMEDOUT;
data->state.keeps_speed = now;
else {
/* how long has it been under the limit */
- timediff_t howlong = curlx_timediff(now, data->state.keeps_speed);
+ timediff_t howlong = curlx_timediff_ms(now, data->state.keeps_speed);
if(howlong >= data->set.low_speed_time * 1000) {
/* too long */
if(data->set.timeout) {
now = curlx_now();
- if(curlx_timediff(now, conn->created) >= data->set.timeout) {
+ if(curlx_timediff_ms(now, conn->created) >= data->set.timeout) {
failf(data, "Time-out");
result = CURLE_OPERATION_TIMEDOUT;
keepon = FALSE;
if(data->set.timeout) {
now = curlx_now();
- if(curlx_timediff(now, conn->created) >= data->set.timeout) {
+ if(curlx_timediff_ms(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(state->data, NULL, start);
+ timeout_ms = Curl_timeleft_ms(state->data, NULL, start);
if(timeout_ms < 0) {
/* time-out, bail out, go home */
if(event)
*event = TFTP_EVENT_NONE;
- timeout_ms = Curl_timeleft(state->data, NULL,
- (state->state == TFTP_STATE_START));
+ timeout_ms = Curl_timeleft_ms(state->data, NULL,
+ (state->state == TFTP_STATE_START));
if(timeout_ms < 0) {
state->error = TFTP_ERR_TIMEOUT;
state->state = TFTP_STATE_FIN;
goto out;
if(k->keepon) {
- if(0 > Curl_timeleft(data, nowp, FALSE)) {
+ if(Curl_timeleft_ms(data, nowp, 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(*nowp, data->progress.t_startsingle),
+ curlx_timediff_ms(*nowp, 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(*nowp, data->progress.t_startsingle),
+ curlx_timediff_ms(*nowp, data->progress.t_startsingle),
k->bytecount);
}
result = CURLE_OPERATION_TIMEDOUT;
timediff_t age_ms;
if(data->set.conn_max_idle_ms) {
- age_ms = curlx_timediff(now, conn->lastused);
+ age_ms = curlx_timediff_ms(now, conn->lastused);
if(age_ms > data->set.conn_max_idle_ms) {
infof(data, "Too old connection (%" FMT_TIMEDIFF_T
" ms idle, max idle is %" FMT_TIMEDIFF_T " ms), disconnect it",
}
if(data->set.conn_max_age_ms) {
- age_ms = curlx_timediff(now, conn->created);
+ age_ms = curlx_timediff_ms(now, conn->created);
if(age_ms > data->set.conn_max_age_ms) {
infof(data,
"Too old connection (created %" FMT_TIMEDIFF_T
struct curltime *now)
{
CURLcode result = CURLE_OK;
- if(curlx_timediff(*now, conn->keepalive) <= data->set.upkeep_interval_ms)
+ if(curlx_timediff_ms(*now, conn->keepalive) <= data->set.upkeep_interval_ms)
return result;
/* briefly attach for action */
{
struct hostname *ehost;
int eport;
- timediff_t timeout_ms = Curl_timeleft(data, NULL, TRUE);
+ timediff_t timeout_ms = Curl_timeleft_ms(data, NULL, 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(curlx_now(), data->progress.t_startsingle));
+ curlx_timediff_ms(curlx_now(), data->progress.t_startsingle));
return CURLE_OPERATION_TIMEDOUT;
}
else if(result) {
if(Curl_trc_is_verbose(data)) {
const ngtcp2_transport_params *rp;
rp = ngtcp2_conn_get_remote_transport_params(ctx->qconn);
- CURL_TRC_CF(data, cf, "handshake complete after %dms, remote transport["
- "max_udp_payload=%" FMT_PRIu64
+ CURL_TRC_CF(data, cf, "handshake complete after %" FMT_TIMEDIFF_T
+ "ms, remote transport[max_udp_payload=%" FMT_PRIu64
", initial_max_data=%" FMT_PRIu64
"]",
- (int)curlx_timediff(ctx->handshake_at, ctx->started_at),
+ curlx_timediff_ms(ctx->handshake_at, ctx->started_at),
(curl_uint64_t)rp->max_udp_payload_size,
(curl_uint64_t)rp->initial_max_data);
}
}
case CF_QUERY_CONNECT_REPLY_MS:
if(ctx->q.got_first_byte) {
- timediff_t ms = curlx_timediff(ctx->q.first_byte_at, ctx->started_at);
+ timediff_t ms = curlx_timediff_ms(ctx->q.first_byte_at, ctx->started_at);
*pres1 = (ms < INT_MAX) ? (int)ms : INT_MAX;
}
else
* 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(curlx_now(), ctx->q.last_io);
+ timediff_t idletime_ms = curlx_timediff_ms(curlx_now(), ctx->q.last_io);
if(idletime_ms > 0) {
uint64_t max_idle_ms =
(uint64_t)(rp->max_idle_timeout / NGTCP2_MILLISECONDS);
/* connected */
ctx->handshake_at = now;
ctx->q.last_io = now;
- CURL_TRC_CF(data, cf, "handshake complete after %dms",
- (int)curlx_timediff(now, ctx->started_at));
+ CURL_TRC_CF(data, cf, "handshake complete after %" FMT_TIMEDIFF_T "ms",
+ curlx_timediff_ms(now, ctx->started_at));
result = cf_osslq_verify_peer(cf, data);
if(!result) {
CURL_TRC_CF(data, cf, "peer verified");
}
CURL_TRC_CF(data, cf, "negotiated idle timeout: %" FMT_PRIu64 "ms",
(curl_uint64_t)idle_ms);
- idletime = curlx_timediff(curlx_now(), ctx->q.last_io);
+ idletime = curlx_timediff_ms(curlx_now(), ctx->q.last_io);
if(idle_ms && idletime > 0 && (uint64_t)idletime > idle_ms)
goto out;
}
}
case CF_QUERY_CONNECT_REPLY_MS:
if(ctx->got_first_byte) {
- timediff_t ms = curlx_timediff(ctx->first_byte_at, ctx->started_at);
+ timediff_t ms = curlx_timediff_ms(ctx->first_byte_at, ctx->started_at);
*pres1 = (ms < INT_MAX) ? (int)ms : INT_MAX;
}
else
if(quiche_conn_is_established(ctx->qconn)) {
ctx->handshake_at = ctx->q.last_op;
- CURL_TRC_CF(data, cf, "handshake complete after %dms",
- (int)curlx_timediff(ctx->handshake_at, ctx->started_at));
+ CURL_TRC_CF(data, cf, "handshake complete after %" FMT_TIMEDIFF_T "ms",
+ curlx_timediff_ms(ctx->handshake_at, ctx->started_at));
result = cf_quiche_verify_peer(cf, data);
if(!result) {
CURL_TRC_CF(data, cf, "peer verified");
}
case CF_QUERY_CONNECT_REPLY_MS:
if(ctx->q.got_first_byte) {
- timediff_t ms = curlx_timediff(ctx->q.first_byte_at, ctx->started_at);
+ timediff_t ms = curlx_timediff_ms(ctx->q.first_byte_at, ctx->started_at);
*pres1 = (ms < INT_MAX) ? (int)ms : INT_MAX;
}
else
while((sshc->state != SSH_STOP) && !result) {
bool block;
- timediff_t left = 1000;
+ timediff_t left_ms = 1000;
struct curltime now = curlx_now();
result = myssh_statemach_act(data, sshc, sshp, &block);
if(result)
break;
- left = Curl_timeleft(data, NULL, FALSE);
- if(left < 0) {
+ left_ms = Curl_timeleft_ms(data, NULL, FALSE);
+ if(left_ms < 0) {
failf(data, "Operation timed out");
return CURLE_OPERATION_TIMEDOUT;
}
if(block) {
curl_socket_t fd_read = conn->sock[FIRSTSOCKET];
/* wait for the socket to become ready */
- (void)Curl_socket_check(fd_read, CURL_SOCKET_BAD,
- CURL_SOCKET_BAD, left > 1000 ? 1000 : left);
+ (void)Curl_socket_check(fd_read, CURL_SOCKET_BAD, CURL_SOCKET_BAD,
+ left_ms > 1000 ? 1000 : left_ms);
}
}
while((sshc->state != SSH_STOP) && !result) {
bool block;
- timediff_t left = 1000;
+ timediff_t left_ms = 1000;
struct curltime now = curlx_now();
result = ssh_statemachine(data, sshc, sshp, &block);
if(result)
break;
- left = Curl_timeleft(data, NULL, FALSE);
- if(left < 0) {
+ left_ms = Curl_timeleft_ms(data, NULL, FALSE);
+ if(left_ms < 0) {
failf(data, "Operation timed out");
return CURLE_OPERATION_TIMEDOUT;
}
}
- else if(curlx_timediff(now, dis) > 1000) {
+ else if(curlx_timediff_ms(now, dis) > 1000) {
/* disconnect timeout */
failf(data, "Disconnect timed out");
result = CURLE_OK;
fd_write = sock;
/* wait for the socket to become ready */
(void)Curl_socket_check(fd_read, CURL_SOCKET_BAD, fd_write,
- left > 1000 ? 1000 : left);
+ left_ms > 1000 ? 1000 : left_ms);
}
}
{
const struct ssl_general_config *cfg = &data->set.general_ssl;
struct curltime now = curlx_now();
- timediff_t elapsed_ms = curlx_timediff(now, sc->time);
+ timediff_t elapsed_ms = curlx_timediff_ms(now, sc->time);
timediff_t timeout_ms = cfg->ca_cache_timeout * (timediff_t)1000;
if(timeout_ms < 0)
return FALSE;
else {
struct curltime now = curlx_now();
- timediff_t elapsed_ms = curlx_timediff(now, mb->time);
+ timediff_t elapsed_ms = curlx_timediff_ms(now, mb->time);
timediff_t timeout_ms = cfg->ca_cache_timeout * (timediff_t)1000;
return elapsed_ms >= timeout_ms;
curl_socket_t readfd, writefd;
timediff_t elapsed;
- elapsed = curlx_timediff(curlx_now(), rs->start_time);
+ elapsed = curlx_timediff_ms(curlx_now(), rs->start_time);
if(elapsed >= MAX_RENEG_BLOCK_TIME) {
failf(data, "schannel: renegotiation timeout");
result = CURLE_SSL_CONNECT_ERROR;
for(;;) {
int what;
- timediff_t timeout, remaining;
+ timediff_t timeout_ms, remaining;
if(Curl_pgrsUpdate(data)) {
result = CURLE_ABORTED_BY_CALLBACK;
break;
}
- elapsed = curlx_timediff(curlx_now(), rs->start_time);
+ elapsed = curlx_timediff_ms(curlx_now(), rs->start_time);
if(elapsed >= MAX_RENEG_BLOCK_TIME) {
failf(data, "schannel: renegotiation timeout");
result = CURLE_SSL_CONNECT_ERROR;
remaining = MAX_RENEG_BLOCK_TIME - elapsed;
if(blocking) {
- timeout = Curl_timeleft(data, NULL, FALSE);
+ timeout_ms = Curl_timeleft_ms(data, NULL, FALSE);
- if(timeout < 0) {
+ if(timeout_ms < 0) {
result = CURLE_OPERATION_TIMEDOUT;
break;
}
/* the blocking is in intervals so that the progress function can be
called every second */
- if(!timeout || timeout > 1000)
- timeout = 1000;
+ if(!timeout_ms || timeout_ms > 1000)
+ timeout_ms = 1000;
- if(timeout > remaining)
- timeout = remaining;
+ if(timeout_ms > remaining)
+ timeout_ms = remaining;
}
else
- timeout = 0;
+ timeout_ms = 0;
SCH_DEV(infof(data, "schannel: renegotiation wait until socket is"
"%s%s for up to %" FMT_TIMEDIFF_T " ms",
((readfd != CURL_SOCKET_BAD) ? " readable" : ""),
((writefd != CURL_SOCKET_BAD) ? " writeable" : ""),
- timeout));
+ timeout_ms));
- what = Curl_socket_check(readfd, CURL_SOCKET_BAD, writefd, timeout);
+ what = Curl_socket_check(readfd, CURL_SOCKET_BAD, writefd, timeout_ms);
if(what > 0 && (what & (CURL_CSELECT_IN | CURL_CSELECT_OUT))) {
SCH_DEV(infof(data, "schannel: renegotiation socket %s%s",
while(len > *pnwritten) {
size_t this_write = 0;
int what;
- timediff_t timeout_ms = Curl_timeleft(data, NULL, FALSE);
+ timediff_t timeout_ms = Curl_timeleft_ms(data, NULL, FALSE);
if(timeout_ms < 0) {
/* we already got the timeout */
failf(data, "schannel: timed out sending data "
timeout_ms = cfg->ca_cache_timeout * (timediff_t)1000;
if(timeout_ms >= 0) {
now = curlx_now();
- elapsed_ms = curlx_timediff(now, share->time);
+ elapsed_ms = curlx_timediff_ms(now, share->time);
if(elapsed_ms >= timeout_ms) {
return NULL;
}
{
const struct ssl_general_config *cfg = &data->set.general_ssl;
struct curltime now = curlx_now();
- timediff_t elapsed_ms = curlx_timediff(now, mb->time);
+ timediff_t elapsed_ms = curlx_timediff_ms(now, mb->time);
timediff_t timeout_ms = cfg->ca_cache_timeout * (timediff_t)1000;
if(timeout_ms < 0)
CURL_TRC_WS(data, "ws_send_raw_blocking() partial, %zu left to send",
buflen);
- left_ms = Curl_timeleft(data, NULL, FALSE);
+ left_ms = Curl_timeleft_ms(data, NULL, FALSE);
if(left_ms < 0) {
failf(data, "[WS] Timeout waiting for socket becoming writable");
return CURLE_SEND_ERROR;
if(bar->prev == point)
/* progress did not change since last invoke */
return 0;
- else if((curlx_timediff(now, bar->prevtime) < 100L) && point < total)
+ else if((curlx_timediff_ms(now, bar->prevtime) < 100L) && point < total)
/* limit progress-bar updating to 10 Hz except when we are at 100% */
return 0;
}
else {
/* total is unknown */
- if(curlx_timediff(now, bar->prevtime) < 100L)
+ if(curlx_timediff_ms(now, bar->prevtime) < 100L)
/* limit progress-bar updating to 10 Hz */
return 0;
update_width(bar);
if(config->timeout_ms) {
struct curltime now = curlx_now();
- long msdelta = (long)curlx_timediff(now, per->start);
+ long msdelta = (long)curlx_timediff_ms(now, per->start);
if(msdelta > config->timeout_ms)
/* timeout */
maximum time allowed for retrying, then exit the retries right
away */
if(config->retry_maxtime_ms) {
- timediff_t ms = curlx_timediff(curlx_now(), per->retrystart);
+ timediff_t ms = curlx_timediff_ms(curlx_now(), per->retrystart);
if((CURL_OFF_T_MAX - sleeptime < ms) ||
(ms + sleeptime > config->retry_maxtime_ms)) {
time */
if(per->retry_remaining &&
(!config->retry_maxtime_ms ||
- (curlx_timediff(curlx_now(), per->retrystart) <
+ (curlx_timediff_ms(curlx_now(), per->retrystart) <
config->retry_maxtime_ms)) ) {
result = retrycheck(config, per, result, retryp, delay);
if(!result && *retryp)
if(per && global->ms_per_transfer) {
/* how long time did the most recent transfer take in number of
milliseconds */
- timediff_t milli = curlx_timediff(curlx_now(), start);
+ timediff_t milli = curlx_timediff_ms(curlx_now(), start);
if(milli < global->ms_per_transfer) {
notef("Transfer took %" CURL_FORMAT_CURL_OFF_T " ms, "
"waits %ldms as set by --rate",
return FALSE;
now = curlx_now();
- diff = curlx_timediff(now, stamp);
+ diff = curlx_timediff_ms(now, stamp);
if(!header) {
header = TRUE;
char time_total[10];
char time_spent[10];
char buffer[3][6];
- curl_off_t spent = curlx_timediff(now, *start)/1000;
+ curl_off_t spent = curlx_timediff_ms(now, *start)/1000;
char dlpercen[4]="--";
char ulpercen[4]="--";
struct per_transfer *per;
curl_off_t uls;
if(indexwrapped) {
/* 'speedindex' is the oldest stored data */
- deltams = curlx_timediff(now, speedstore[speedindex].stamp);
+ deltams = curlx_timediff_ms(now, speedstore[speedindex].stamp);
dl = all_dlnow - speedstore[speedindex].dl;
ul = all_ulnow - speedstore[speedindex].ul;
}
else {
/* since the beginning */
- deltams = curlx_timediff(now, *start);
+ deltams = curlx_timediff_ms(now, *start);
dl = all_dlnow;
ul = all_ulnow;
}
<info>
<keywords>
unittest
-Curl_timeleft
+Curl_timeleft_ms
</keywords>
</info>
unittest
</features>
<name>
-Curl_timeleft unit tests
+Curl_timeleft_ms unit tests
</name>
</client>
</testcase>
#define TEST_HANG_TIMEOUT 60 * 1000 /* global default */
#define exe_test_timedout(T,Y,Z) do { \
- timediff_t timediff = curlx_timediff(curlx_now(), tv_test_start); \
+ timediff_t timediff = curlx_timediff_ms(curlx_now(), tv_test_start); \
if(timediff > (T)) { \
curl_mfprintf(stderr, "%s:%d ABORTING TEST, since it seems " \
"that it would have run forever (%ld ms > %ld ms)\n", \
abort_on_test_timeout_custom(HANG_TIMEOUT);
after = curlx_now();
- e = curlx_timediff(after, before);
+ e = curlx_timediff_ms(after, before);
curl_mfprintf(stderr, "pong = %ld\n", (long)e);
if(e > MAX_BLOCKED_TIME_MS) {
rc = select(maxfd + 1, &fdread, &fdwrite, &fdexcep, &timeout);
- if(curlx_timediff(curlx_now(), mp_start) > MULTI_PERFORM_HANG_TIMEOUT) {
+ if(curlx_timediff_ms(curlx_now(), mp_start) > MULTI_PERFORM_HANG_TIMEOUT) {
curl_mfprintf(stderr, "ABORTING TEST, since it seems "
"that it would have run forever.\n");
break;
multi_poll(multi, NULL, 0, 1000, &numfds);
time_after_wait = curlx_now();
- if(curlx_timediff(time_after_wait, time_before_wait) < 500) {
+ if(curlx_timediff_ms(time_after_wait, time_before_wait) < 500) {
curl_mfprintf(stderr, "%s:%d curl_multi_poll returned too early\n",
__FILE__, __LINE__);
res = TEST_ERR_MAJOR_BAD;
multi_poll(multi, NULL, 0, 1000, &numfds);
time_after_wait = curlx_now();
- if(curlx_timediff(time_after_wait, time_before_wait) > 500) {
+ if(curlx_timediff_ms(time_after_wait, time_before_wait) > 500) {
curl_mfprintf(stderr, "%s:%d curl_multi_poll returned too late\n",
__FILE__, __LINE__);
res = TEST_ERR_MAJOR_BAD;
multi_poll(multi, NULL, 0, 1000, &numfds);
time_after_wait = curlx_now();
- if(curlx_timediff(time_after_wait, time_before_wait) < 500) {
+ if(curlx_timediff_ms(time_after_wait, time_before_wait) < 500) {
curl_mfprintf(stderr, "%s:%d curl_multi_poll returned too early\n",
__FILE__, __LINE__);
res = TEST_ERR_MAJOR_BAD;
multi_poll(multi, NULL, 0, 1000, &numfds);
time_after_wait = curlx_now();
- if(curlx_timediff(time_after_wait, time_before_wait) > 500) {
+ if(curlx_timediff_ms(time_after_wait, time_before_wait) > 500) {
curl_mfprintf(stderr, "%s:%d curl_multi_poll returned too late\n",
__FILE__, __LINE__);
res = TEST_ERR_MAJOR_BAD;
multi_poll(multi, NULL, 0, 1000, &numfds);
time_after_wait = curlx_now();
- if(curlx_timediff(time_after_wait, time_before_wait) < 500) {
+ if(curlx_timediff_ms(time_after_wait, time_before_wait) < 500) {
curl_mfprintf(stderr, "%s:%d curl_multi_poll returned too early\n",
__FILE__, __LINE__);
res = TEST_ERR_MAJOR_BAD;
timediff_t timeout;
NOW(run[i].now_s, run[i].now_us);
TIMEOUTS(run[i].timeout_ms, run[i].connecttimeout_ms);
- timeout = Curl_timeleft(easy, &now, run[i].connecting);
+ timeout = Curl_timeleft_ms(easy, &now, run[i].connecting);
if(timeout != run[i].result)
fail(run[i].comment);
}
size_t i;
for(i = 0; i < CURL_ARRAYSIZE(tests); i++) {
- timediff_t result = curlx_timediff(tests[i].first, tests[i].second);
+ timediff_t result = curlx_timediff_ms(tests[i].first, tests[i].second);
if(result != tests[i].result) {
curl_mprintf("%ld.%06u to %ld.%06u got %" FMT_TIMEDIFF_T
", but expected %" FMT_TIMEDIFF_T "\n",
struct cf_test_ctx *ctx = cf->ctx;
#ifndef CURL_DISABLE_VERBOSE_STRINGS
infof(data, "%04dms: cf[%s] destroyed",
- (int)curlx_timediff(curlx_now(), current_tr->started), ctx->id);
+ (int)curlx_timediff_ms(curlx_now(), current_tr->started), ctx->id);
#else
(void)data;
#endif
(void)data;
*done = FALSE;
- duration_ms = curlx_timediff(curlx_now(), ctx->started);
+ duration_ms = curlx_timediff_ms(curlx_now(), ctx->started);
if(duration_ms >= ctx->fail_delay_ms) {
infof(data, "%04dms: cf[%s] fail delay reached",
(int)duration_ms, ctx->id);
ctx->stats->creations++;
}
- created_at = curlx_timediff(ctx->started, current_tr->started);
+ created_at = curlx_timediff_ms(ctx->started, current_tr->started);
if(ctx->stats->creations == 1)
ctx->stats->first_created = created_at;
ctx->stats->last_created = created_at;
char msg[256];
timediff_t duration_ms;
- duration_ms = curlx_timediff(tr->ended, tr->started);
+ duration_ms = curlx_timediff_ms(tr->ended, tr->started);
curl_mfprintf(stderr, "%d: test case took %dms\n", tc->id, (int)duration_ms);
if(tr->result != tc->exp_result
fail(msg);
}
- duration_ms = curlx_timediff(tr->ended, tr->started);
+ duration_ms = curlx_timediff_ms(tr->ended, tr->started);
if(duration_ms < tc->min_duration_ms) {
curl_msprintf(msg, "%d: expected min duration of %dms, but took %dms",
tc->id, (int)tc->min_duration_ms, (int)duration_ms);
projects / thirdparty / curl.git / commitdiff
