luna - curl/lib/progress.c

  1/***************************************************************************
  2 *                                  _   _ ____  _
  3 *  Project                     ___| | | |  _ \| |
  4 *                             / __| | | | |_) | |
  5 *                            | (__| |_| |  _ <| |___
  6 *                             \___|\___/|_| \_\_____|
  7 *
  8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
  9 *
 10 * This software is licensed as described in the file COPYING, which
 11 * you should have received as part of this distribution. The terms
 12 * are also available at https://curl.se/docs/copyright.html.
 13 *
 14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
 15 * copies of the Software, and permit persons to whom the Software is
 16 * furnished to do so, under the terms of the COPYING file.
 17 *
 18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 19 * KIND, either express or implied.
 20 *
 21 * SPDX-License-Identifier: curl
 22 *
 23 ***************************************************************************/
 24#include "curl_setup.h"
 25
 26#include "urldata.h"
 27#include "curl_trc.h"
 28#include "multiif.h"
 29#include "progress.h"
 30#include "transfer.h"
 31#include "curlx/strcopy.h"
 32
 33#ifndef CURL_DISABLE_PROGRESS_METER
 34/* Provide a string that is 7 letters long (plus the zero byte).
 35
 36   @unittest 1636
 37*/
 38UNITTEST void time2str(char *r, size_t rsize, curl_off_t seconds);
 39UNITTEST void time2str(char *r, size_t rsize, curl_off_t seconds)
 40{
 41  curl_off_t h;
 42  if(seconds <= 0) {
 43    curlx_strcopy(r, rsize, STRCONST("       "));
 44    return;
 45  }
 46  h = seconds / 3600;
 47  if(h <= 99) {
 48    curl_off_t m = (seconds - (h * 3600)) / 60;
 49    if(h <= 9) {
 50      curl_off_t s = (seconds - (h * 3600)) - (m * 60);
 51      if(h)
 52        curl_msnprintf(r, rsize, "%" FMT_OFF_T ":%02" FMT_OFF_T ":"
 53                       "%02" FMT_OFF_T, h, m, s);
 54      else
 55        curl_msnprintf(r, rsize, "  %02" FMT_OFF_T ":%02" FMT_OFF_T, m, s);
 56    }
 57    else
 58      curl_msnprintf(r, rsize, "%" FMT_OFF_T "h %02" FMT_OFF_T "m", h, m);
 59  }
 60  else {
 61    curl_off_t d = seconds / 86400;
 62    h = (seconds - (d * 86400)) / 3600;
 63    if(d <= 99)
 64      curl_msnprintf(r, rsize, "%2" FMT_OFF_T "d %02" FMT_OFF_T "h", d, h);
 65    else if(d <= 999)
 66      curl_msnprintf(r, rsize, "%6" FMT_OFF_T "d", d);
 67    else { /* more than 999 days */
 68      curl_off_t m = d / 30;
 69      if(m <= 999)
 70        curl_msnprintf(r, rsize, "%6" FMT_OFF_T "m", m);
 71      else { /* more than 999 months */
 72        curl_off_t y = d / 365;
 73        if(y <= 99999)
 74          curl_msnprintf(r, rsize, "%6" FMT_OFF_T "y", y);
 75        else
 76          curlx_strcopy(r, rsize, STRCONST(">99999y"));
 77      }
 78    }
 79  }
 80}
 81
 82/* The point of this function would be to return a string of the input data,
 83   but never longer than 6 columns (+ one zero byte).
 84   Add suffix k, M, G when suitable...
 85
 86   @unittest 1636
 87*/
 88UNITTEST char *max6out(curl_off_t bytes, char *max6, size_t mlen);
 89UNITTEST char *max6out(curl_off_t bytes, char *max6, size_t mlen)
 90{
 91  /* a signed 64-bit value is 8192 petabytes maximum, shown as
 92     8.0E (exabytes)*/
 93  if(bytes < 100000)
 94    curl_msnprintf(max6, mlen, "%6" CURL_FORMAT_CURL_OFF_T, bytes);
 95  else {
 96    const char unit[] = { 'k', 'M', 'G', 'T', 'P', 'E', 0 };
 97    int k = 0;
 98    curl_off_t nbytes;
 99    curl_off_t rest;
100    do {
101      nbytes = bytes / 1024;
102      if(nbytes < 1000)
103        break;
104      bytes = nbytes;
105      k++;
106      DEBUGASSERT(unit[k]);
107    } while(unit[k]);
108    rest = bytes % 1024;
109    if(nbytes <= 99)
110      /* xx.yyU */
111      curl_msnprintf(max6, mlen, "%2" CURL_FORMAT_CURL_OFF_T
112                     ".%02" CURL_FORMAT_CURL_OFF_T "%c", nbytes,
113                     rest * 100 / 1024, unit[k]);
114    else
115      /* xxx.yU */
116      curl_msnprintf(max6, mlen, "%3" CURL_FORMAT_CURL_OFF_T
117                     ".%" CURL_FORMAT_CURL_OFF_T "%c", nbytes,
118                     rest * 10 / 1024, unit[k]);
119  }
120  return max6;
121}
122#endif
123
124static void pgrs_speedinit(struct Curl_easy *data)
125{
126  memset(&data->state.keeps_speed, 0, sizeof(struct curltime));
127}
128
129/*
130 * @unittest 1606
131 */
132UNITTEST CURLcode pgrs_speedcheck(struct Curl_easy *data,
133                                  const struct curltime *pnow);
134UNITTEST CURLcode pgrs_speedcheck(struct Curl_easy *data,
135                                  const struct curltime *pnow)
136{
137  if(!data->set.low_speed_time || !data->set.low_speed_limit ||
138     Curl_xfer_recv_is_paused(data) || Curl_xfer_send_is_paused(data))
139    /* A paused transfer is not qualified for speed checks */
140    return CURLE_OK;
141
142  if(data->progress.current_speed >= 0) {
143    if(data->progress.current_speed < data->set.low_speed_limit) {
144      if(!data->state.keeps_speed.tv_sec)
145        /* under the limit at this moment */
146        data->state.keeps_speed = *pnow;
147      else {
148        /* how long has it been under the limit */
149        timediff_t howlong =
150          curlx_ptimediff_ms(pnow, &data->state.keeps_speed);
151
152        if(howlong >= data->set.low_speed_time * 1000) {
153          /* too long */
154          failf(data, "Operation too slow. Less than %" FMT_OFF_T
155                " bytes/sec transferred the last %u seconds",
156                data->set.low_speed_limit, data->set.low_speed_time);
157          return CURLE_OPERATION_TIMEDOUT;
158        }
159      }
160    }
161    else
162      /* faster right now */
163      data->state.keeps_speed.tv_sec = 0;
164  }
165
166  /* since low speed limit is enabled, set the expire timer to make this
167     connection's speed get checked again in a second */
168  Curl_expire(data, 1000, EXPIRE_SPEEDCHECK);
169
170  return CURLE_OK;
171}
172
173const struct curltime *Curl_pgrs_now(struct Curl_easy *data)
174{
175  struct curltime *pnow = data->multi ?
176                          &data->multi->now : &data->progress.now;
177  curlx_pnow(pnow);
178  return pnow;
179}
180
181/*
182   New proposed interface, 9th of February 2000:
183
184   pgrsStartNow() - sets start time
185   pgrsSetDownloadSize(x) - known expected download size
186   pgrsSetUploadSize(x) - known expected upload size
187   pgrsSetDownloadCounter() - amount of data currently downloaded
188   pgrsSetUploadCounter() - amount of data currently uploaded
189   pgrsUpdate() - show progress
190   pgrsDone() - transfer complete
191*/
192
193int Curl_pgrsDone(struct Curl_easy *data)
194{
195  int rc;
196  data->progress.lastshow = 0;
197  rc = Curl_pgrsUpdate(data); /* the final (forced) update */
198  if(rc)
199    return rc;
200
201  if(!data->progress.hide && !data->progress.callback)
202    /* only output if we do not use a progress callback and we are not
203     * hidden */
204    curl_mfprintf(data->set.err, "\n");
205
206  return 0;
207}
208
209void Curl_pgrsReset(struct Curl_easy *data)
210{
211  Curl_pgrsSetUploadCounter(data, 0);
212  data->progress.dl.cur_size = 0;
213  Curl_pgrsSetUploadSize(data, -1);
214  Curl_pgrsSetDownloadSize(data, -1);
215  data->progress.speeder_c = 0; /* reset speed records */
216  data->progress.deliver = 0;
217  pgrs_speedinit(data);
218}
219
220/* reset the known transfer sizes */
221void Curl_pgrsResetTransferSizes(struct Curl_easy *data)
222{
223  Curl_pgrsSetDownloadSize(data, -1);
224  Curl_pgrsSetUploadSize(data, -1);
225}
226
227void Curl_pgrsRecvPause(struct Curl_easy *data, bool enable)
228{
229  if(!enable) {
230    data->progress.speeder_c = 0; /* reset speed records */
231    pgrs_speedinit(data); /* reset low speed measurements */
232  }
233}
234
235void Curl_pgrsSendPause(struct Curl_easy *data, bool enable)
236{
237  if(!enable) {
238    data->progress.speeder_c = 0; /* reset speed records */
239    pgrs_speedinit(data); /* reset low speed measurements */
240  }
241}
242
243/*
244 * Curl_pgrsTimeWas(). Store the timestamp time at the given label.
245 */
246void Curl_pgrsTimeWas(struct Curl_easy *data, timerid timer,
247                      struct curltime timestamp)
248{
249  timediff_t *delta = NULL;
250
251  switch(timer) {
252  default:
253  case TIMER_NONE:
254    /* mistake filter */
255    break;
256  case TIMER_STARTOP:
257    /* This is set at the start of a transfer */
258    data->progress.t_startop = timestamp;
259    data->progress.t_startqueue = timestamp;
260    data->progress.t_postqueue = 0;
261    break;
262  case TIMER_STARTSINGLE:
263    /* This is set at the start of each single transfer */
264    data->progress.t_startsingle = timestamp;
265    data->progress.is_t_startransfer_set = FALSE;
266    break;
267  case TIMER_POSTQUEUE:
268    /* Queue time is accumulative from all involved redirects */
269    data->progress.t_postqueue +=
270      curlx_ptimediff_us(&timestamp, &data->progress.t_startqueue);
271    break;
272  case TIMER_STARTACCEPT:
273    data->progress.t_acceptdata = timestamp;
274    break;
275  case TIMER_NAMELOOKUP:
276    delta = &data->progress.t_nslookup;
277    break;
278  case TIMER_CONNECT:
279    delta = &data->progress.t_connect;
280    break;
281  case TIMER_APPCONNECT:
282    delta = &data->progress.t_appconnect;
283    break;
284  case TIMER_PRETRANSFER:
285    delta = &data->progress.t_pretransfer;
286    break;
287  case TIMER_STARTTRANSFER:
288    delta = &data->progress.t_starttransfer;
289    /* prevent updating t_starttransfer unless:
290     *   1. this is the first time we are setting t_starttransfer
291     *   2. a redirect has occurred since the last time t_starttransfer was set
292     * This prevents repeated invocations of the function from incorrectly
293     * changing the t_starttransfer time.
294     */
295    if(data->progress.is_t_startransfer_set) {
296      return;
297    }
298    else {
299      data->progress.is_t_startransfer_set = TRUE;
300      break;
301    }
302  case TIMER_POSTRANSFER:
303    delta = &data->progress.t_posttransfer;
304    break;
305  case TIMER_REDIRECT:
306    data->progress.t_redirect = curlx_ptimediff_us(&timestamp,
307                                                   &data->progress.start);
308    data->progress.t_startqueue = timestamp;
309    break;
310  }
311  if(delta) {
312    timediff_t us = curlx_ptimediff_us(&timestamp,
313                                       &data->progress.t_startsingle);
314    if(us < 1)
315      us = 1; /* make sure at least one microsecond passed */
316    *delta += us;
317  }
318}
319
320/*
321 * Curl_pgrsTime(). Store the current time at the given label. This fetches a
322 * fresh "now" and returns it.
323 *
324 * @unittest: 1399
325 */
326void Curl_pgrsTime(struct Curl_easy *data, timerid timer)
327{
328  Curl_pgrsTimeWas(data, timer, *Curl_pgrs_now(data));
329}
330
331void Curl_pgrsStartNow(struct Curl_easy *data)
332{
333  struct Progress *p = &data->progress;
334
335  p->speeder_c = 0; /* reset the progress meter display */
336  p->start = *Curl_pgrs_now(data);
337  p->is_t_startransfer_set = FALSE;
338  p->dl.cur_size = 0;
339  p->ul.cur_size = 0;
340  /* the sizes are unknown at start */
341  p->dl_size_known = FALSE;
342  p->ul_size_known = FALSE;
343}
344
345/* check that the 'delta' amount of bytes are okay to deliver to the
346   application, or return error if not. */
347CURLcode Curl_pgrs_deliver_check(struct Curl_easy *data, size_t delta)
348{
349  if(data->set.max_filesize &&
350     ((curl_off_t)delta > data->set.max_filesize - data->progress.deliver)) {
351    failf(data, "Would have exceeded max file size");
352    return CURLE_FILESIZE_EXCEEDED;
353  }
354  return CURLE_OK;
355}
356
357/* this counts how much data is delivered to the application, which
358   in compressed cases may differ from downloaded amount */
359void Curl_pgrs_deliver_inc(struct Curl_easy *data, size_t delta)
360{
361  data->progress.deliver += delta;
362}
363
364void Curl_pgrs_download_inc(struct Curl_easy *data, size_t delta)
365{
366  if(delta) {
367    data->progress.dl.cur_size += delta;
368    Curl_rlimit_drain(&data->progress.dl.rlimit, delta, Curl_pgrs_now(data));
369  }
370}
371
372void Curl_pgrs_upload_inc(struct Curl_easy *data, size_t delta)
373{
374  if(delta) {
375    data->progress.ul.cur_size += delta;
376    Curl_rlimit_drain(&data->progress.ul.rlimit, delta, Curl_pgrs_now(data));
377  }
378}
379
380/*
381 * Set the number of uploaded bytes so far.
382 */
383void Curl_pgrsSetUploadCounter(struct Curl_easy *data, curl_off_t size)
384{
385  data->progress.ul.cur_size = size;
386}
387
388void Curl_pgrsSetDownloadSize(struct Curl_easy *data, curl_off_t size)
389{
390  if(size >= 0) {
391    data->progress.dl.total_size = size;
392    data->progress.dl_size_known = TRUE;
393  }
394  else {
395    data->progress.dl.total_size = 0;
396    data->progress.dl_size_known = FALSE;
397  }
398}
399
400void Curl_pgrsSetUploadSize(struct Curl_easy *data, curl_off_t size)
401{
402  if(size >= 0) {
403    data->progress.ul.total_size = size;
404    data->progress.ul_size_known = TRUE;
405  }
406  else {
407    data->progress.ul.total_size = 0;
408    data->progress.ul_size_known = FALSE;
409  }
410}
411
412void Curl_pgrsEarlyData(struct Curl_easy *data, curl_off_t sent)
413{
414  data->progress.earlydata_sent = sent;
415}
416
417/* returns the average speed in bytes / second */
418static curl_off_t trspeed(curl_off_t size, /* number of bytes */
419                          curl_off_t us)   /* microseconds */
420{
421  if(us < 1)
422    return size * 1000000;
423  else if(size < CURL_OFF_T_MAX / 1000000)
424    return (size * 1000000) / us;
425  else if(us >= 1000000)
426    return size / (us / 1000000);
427  else
428    return CURL_OFF_T_MAX;
429}
430
431/* returns TRUE if it is time to show the progress meter */
432static bool progress_calc(struct Curl_easy *data,
433                          const struct curltime *pnow)
434{
435  struct Progress * const p = &data->progress;
436  int i_next, i_oldest, i_latest;
437  timediff_t duration_us;
438  curl_off_t amount;
439
440  /* The time spent so far (from the start) in microseconds */
441  p->timespent = curlx_ptimediff_us(pnow, &p->start);
442  p->dl.speed = trspeed(p->dl.cur_size, p->timespent);
443  p->ul.speed = trspeed(p->ul.cur_size, p->timespent);
444
445  if(!p->speeder_c) { /* no previous record exists */
446    p->speed_amount[0] = p->dl.cur_size + p->ul.cur_size;
447    p->speed_time[0] = *pnow;
448    p->speeder_c++;
449    /* use the overall average at the start */
450    p->current_speed = p->ul.speed + p->dl.speed;
451    p->lastshow = pnow->tv_sec;
452    return TRUE;
453  }
454  /* We have at least one record now. Where to put the next and
455   * where is the latest one? */
456  i_next = p->speeder_c % CURL_SPEED_RECORDS;
457  i_latest = (i_next > 0) ? (i_next - 1) : (CURL_SPEED_RECORDS - 1);
458
459  /* Make a new record only when some time has passed.
460   * Too frequent calls otherwise ruin the history. */
461  if(curlx_ptimediff_ms(pnow, &p->speed_time[i_latest]) >= 1000) {
462    p->speeder_c++;
463    i_latest = i_next;
464    p->speed_amount[i_latest] = p->dl.cur_size + p->ul.cur_size;
465    p->speed_time[i_latest] = *pnow;
466  }
467  else if(data->req.done) {
468    /* When a transfer is done, and we did not have a current speed
469     * already, update the last record. Otherwise, stay at the speed
470     * we have. The last chunk of data, when rate limiting, would increase
471     * reported speed since it no longer measures a full second. */
472    if(!p->current_speed) {
473      p->speed_amount[i_latest] = p->dl.cur_size + p->ul.cur_size;
474      p->speed_time[i_latest] = *pnow;
475    }
476  }
477  else {
478    /* transfer ongoing, wait for more time to pass. */
479    return FALSE;
480  }
481
482  i_oldest = (p->speeder_c < CURL_SPEED_RECORDS) ? 0 :
483             ((i_latest + 1) % CURL_SPEED_RECORDS);
484
485  /* How much we transferred between oldest and current records */
486  amount = p->speed_amount[i_latest] - p->speed_amount[i_oldest];
487  /* How long this took */
488  duration_us = curlx_ptimediff_us(&p->speed_time[i_latest],
489                                   &p->speed_time[i_oldest]);
490  if(duration_us <= 0)
491    duration_us = 1;
492
493  if(amount > (CURL_OFF_T_MAX / 1000000)) {
494    /* the 'amount' value is bigger than would fit in 64 bits if
495       multiplied with 1000000, so we use the double math for this */
496    p->current_speed =
497      (curl_off_t)(((double)amount * 1000000.0) / (double)duration_us);
498  }
499  else {
500    p->current_speed = amount * 1000000 / duration_us;
501  }
502
503  if((p->lastshow == pnow->tv_sec) && !data->req.done)
504    return FALSE;
505  p->lastshow = pnow->tv_sec;
506  return TRUE;
507}
508
509#ifndef CURL_DISABLE_PROGRESS_METER
510
511struct pgrs_estimate {
512  curl_off_t secs;
513  curl_off_t percent;
514};
515
516static curl_off_t pgrs_est_percent(curl_off_t total, curl_off_t cur)
517{
518  if(total > 10000)
519    return cur / (total / 100);
520  else if(total > 0)
521    return (cur * 100) / total;
522  return 0;
523}
524
525static void pgrs_estimates(struct pgrs_dir *d,
526                           bool total_known,
527                           struct pgrs_estimate *est)
528{
529  est->secs = 0;
530  est->percent = 0;
531  if(total_known && (d->speed > 0)) {
532    est->secs = d->total_size / d->speed;
533    est->percent = pgrs_est_percent(d->total_size, d->cur_size);
534  }
535}
536
537static void progress_meter(struct Curl_easy *data)
538{
539  struct Progress *p = &data->progress;
540  char max6[6][7];
541  struct pgrs_estimate dl_estm;
542  struct pgrs_estimate ul_estm;
543  struct pgrs_estimate total_estm;
544  curl_off_t total_cur_size;
545  curl_off_t total_expected_size;
546  curl_off_t dl_size;
547  char time_left[8];
548  char time_total[8];
549  char time_spent[8];
550  curl_off_t cur_secs = (curl_off_t)p->timespent / 1000000; /* seconds */
551
552  if(!p->headers_out) {
553    if(data->state.resume_from) {
554      curl_mfprintf(data->set.err,
555                    "** Resuming transfer from byte position %" FMT_OFF_T "\n",
556                    data->state.resume_from);
557    }
558    curl_mfprintf(data->set.err,
559                  "  %% Total    %% Received %% Xferd  Average Speed  "
560                  "Time    Time    Time   Current\n"
561                  "                                 Dload  Upload  "
562                  "Total   Spent   Left   Speed\n");
563    p->headers_out = TRUE; /* headers are shown */
564  }
565
566  /* Figure out the estimated time of arrival for upload and download */
567  pgrs_estimates(&p->ul, (bool)p->ul_size_known, &ul_estm);
568  pgrs_estimates(&p->dl, (bool)p->dl_size_known, &dl_estm);
569
570  /* Since both happen at the same time, total expected duration is max. */
571  total_estm.secs = CURLMAX(ul_estm.secs, dl_estm.secs);
572  /* create the three time strings */
573  time2str(time_left, sizeof(time_left),
574           total_estm.secs > 0 ? (total_estm.secs - cur_secs) : 0);
575  time2str(time_total, sizeof(time_total), total_estm.secs);
576  time2str(time_spent, sizeof(time_spent), cur_secs);
577
578  /* Get the total amount of data expected to get transferred */
579  total_expected_size = p->ul_size_known ? p->ul.total_size : p->ul.cur_size;
580
581  dl_size = p->dl_size_known ? p->dl.total_size : p->dl.cur_size;
582
583  /* integer overflow check */
584  if((CURL_OFF_T_MAX - total_expected_size) < dl_size)
585    total_expected_size = CURL_OFF_T_MAX; /* capped */
586  else
587    total_expected_size += dl_size;
588
589  /* We have transferred this much so far */
590  total_cur_size = p->dl.cur_size + p->ul.cur_size;
591
592  /* Get the percentage of data transferred so far */
593  total_estm.percent = pgrs_est_percent(total_expected_size, total_cur_size);
594
595  curl_mfprintf(data->set.err,
596                "\r"
597                "%3" FMT_OFF_T " %s "
598                "%3" FMT_OFF_T " %s "
599                "%3" FMT_OFF_T " %s %s %s %s %s %s %s",
600                total_estm.percent, /* 3 letters */    /* total % */
601                max6out(total_expected_size, max6[2],
602                        sizeof(max6[2])),              /* total size */
603                dl_estm.percent, /* 3 letters */       /* rcvd % */
604                max6out(p->dl.cur_size, max6[0],
605                        sizeof(max6[0])),              /* rcvd size */
606                ul_estm.percent, /* 3 letters */       /* xfer % */
607                max6out(p->ul.cur_size, max6[1],
608                        sizeof(max6[1])),              /* xfer size */
609                max6out(p->dl.speed, max6[3],
610                        sizeof(max6[3])),              /* avrg dl speed */
611                max6out(p->ul.speed, max6[4],
612                        sizeof(max6[4])),              /* avrg ul speed */
613                time_total,    /* 7 letters */         /* total time */
614                time_spent,    /* 7 letters */         /* time spent */
615                time_left,     /* 7 letters */         /* time left */
616                max6out(p->current_speed, max6[5],
617                        sizeof(max6[5]))               /* current speed */
618    );
619
620  /* we flush the output stream to make it appear as soon as possible */
621  fflush(data->set.err);
622}
623#else /* CURL_DISABLE_PROGRESS_METER */
624#define progress_meter(x) Curl_nop_stmt
625#endif
626
627/*
628 * Curl_pgrsUpdate() returns 0 for success or the value returned by the
629 * progress callback!
630 */
631static CURLcode pgrsupdate(struct Curl_easy *data, bool showprogress)
632{
633  if(!data->progress.hide) {
634    int rc;
635    if(data->set.fxferinfo) {
636      /* There is a callback set, call that */
637      Curl_set_in_callback(data, TRUE);
638      rc = data->set.fxferinfo(data->set.progress_client,
639                               data->progress.dl.total_size,
640                               data->progress.dl.cur_size,
641                               data->progress.ul.total_size,
642                               data->progress.ul.cur_size);
643      Curl_set_in_callback(data, FALSE);
644      if(rc != CURL_PROGRESSFUNC_CONTINUE) {
645        if(rc) {
646          failf(data, "Callback aborted");
647          return CURLE_ABORTED_BY_CALLBACK;
648        }
649        return CURLE_OK;
650      }
651    }
652    else if(data->set.fprogress) {
653      /* The older deprecated callback is set, call that */
654      Curl_set_in_callback(data, TRUE);
655      rc = data->set.fprogress(data->set.progress_client,
656                               (double)data->progress.dl.total_size,
657                               (double)data->progress.dl.cur_size,
658                               (double)data->progress.ul.total_size,
659                               (double)data->progress.ul.cur_size);
660      Curl_set_in_callback(data, FALSE);
661      if(rc != CURL_PROGRESSFUNC_CONTINUE) {
662        if(rc) {
663          failf(data, "Callback aborted");
664          return CURLE_ABORTED_BY_CALLBACK;
665        }
666        return CURLE_OK;
667      }
668    }
669
670    if(showprogress)
671      progress_meter(data);
672  }
673
674  return CURLE_OK;
675}
676
677static CURLcode pgrs_update(struct Curl_easy *data,
678                            const struct curltime *pnow)
679{
680  bool showprogress = progress_calc(data, pnow);
681  return pgrsupdate(data, showprogress);
682}
683
684CURLcode Curl_pgrsUpdate(struct Curl_easy *data)
685{
686  return pgrs_update(data, Curl_pgrs_now(data));
687}
688
689CURLcode Curl_pgrsCheck(struct Curl_easy *data)
690{
691  CURLcode result;
692
693  result = pgrs_update(data, Curl_pgrs_now(data));
694  if(!result && !data->req.done)
695    result = pgrs_speedcheck(data, Curl_pgrs_now(data));
696  return result;
697}
698
699/*
700 * Update all progress, do not do progress meter/callbacks.
701 */
702void Curl_pgrsUpdate_nometer(struct Curl_easy *data)
703{
704  (void)progress_calc(data, Curl_pgrs_now(data));
705}