Annotation of embedaddon/curl/src/tool_progress.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 2020, 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.haxx.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: ***************************************************************************/
! 22: #include "tool_setup.h"
! 23: #include "tool_operate.h"
! 24: #include "tool_progress.h"
! 25: #include "tool_util.h"
! 26:
! 27: #define ENABLE_CURLX_PRINTF
! 28: /* use our own printf() functions */
! 29: #include "curlx.h"
! 30:
! 31: /* The point of this function would be to return a string of the input data,
! 32: but never longer than 5 columns (+ one zero byte).
! 33: Add suffix k, M, G when suitable... */
! 34: static char *max5data(curl_off_t bytes, char *max5)
! 35: {
! 36: #define ONE_KILOBYTE CURL_OFF_T_C(1024)
! 37: #define ONE_MEGABYTE (CURL_OFF_T_C(1024) * ONE_KILOBYTE)
! 38: #define ONE_GIGABYTE (CURL_OFF_T_C(1024) * ONE_MEGABYTE)
! 39: #define ONE_TERABYTE (CURL_OFF_T_C(1024) * ONE_GIGABYTE)
! 40: #define ONE_PETABYTE (CURL_OFF_T_C(1024) * ONE_TERABYTE)
! 41:
! 42: if(bytes < CURL_OFF_T_C(100000))
! 43: msnprintf(max5, 6, "%5" CURL_FORMAT_CURL_OFF_T, bytes);
! 44:
! 45: else if(bytes < CURL_OFF_T_C(10000) * ONE_KILOBYTE)
! 46: msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "k", bytes/ONE_KILOBYTE);
! 47:
! 48: else if(bytes < CURL_OFF_T_C(100) * ONE_MEGABYTE)
! 49: /* 'XX.XM' is good as long as we're less than 100 megs */
! 50: msnprintf(max5, 6, "%2" CURL_FORMAT_CURL_OFF_T ".%0"
! 51: CURL_FORMAT_CURL_OFF_T "M", bytes/ONE_MEGABYTE,
! 52: (bytes%ONE_MEGABYTE) / (ONE_MEGABYTE/CURL_OFF_T_C(10)) );
! 53:
! 54: #if (CURL_SIZEOF_CURL_OFF_T > 4)
! 55:
! 56: else if(bytes < CURL_OFF_T_C(10000) * ONE_MEGABYTE)
! 57: /* 'XXXXM' is good until we're at 10000MB or above */
! 58: msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "M", bytes/ONE_MEGABYTE);
! 59:
! 60: else if(bytes < CURL_OFF_T_C(100) * ONE_GIGABYTE)
! 61: /* 10000 MB - 100 GB, we show it as XX.XG */
! 62: msnprintf(max5, 6, "%2" CURL_FORMAT_CURL_OFF_T ".%0"
! 63: CURL_FORMAT_CURL_OFF_T "G", bytes/ONE_GIGABYTE,
! 64: (bytes%ONE_GIGABYTE) / (ONE_GIGABYTE/CURL_OFF_T_C(10)) );
! 65:
! 66: else if(bytes < CURL_OFF_T_C(10000) * ONE_GIGABYTE)
! 67: /* up to 10000GB, display without decimal: XXXXG */
! 68: msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "G", bytes/ONE_GIGABYTE);
! 69:
! 70: else if(bytes < CURL_OFF_T_C(10000) * ONE_TERABYTE)
! 71: /* up to 10000TB, display without decimal: XXXXT */
! 72: msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "T", bytes/ONE_TERABYTE);
! 73:
! 74: else
! 75: /* up to 10000PB, display without decimal: XXXXP */
! 76: msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "P", bytes/ONE_PETABYTE);
! 77:
! 78: /* 16384 petabytes (16 exabytes) is the maximum a 64 bit unsigned number
! 79: can hold, but our data type is signed so 8192PB will be the maximum. */
! 80:
! 81: #else
! 82:
! 83: else
! 84: msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "M", bytes/ONE_MEGABYTE);
! 85:
! 86: #endif
! 87:
! 88: return max5;
! 89: }
! 90:
! 91: int xferinfo_cb(void *clientp,
! 92: curl_off_t dltotal,
! 93: curl_off_t dlnow,
! 94: curl_off_t ultotal,
! 95: curl_off_t ulnow)
! 96: {
! 97: struct per_transfer *per = clientp;
! 98: struct OperationConfig *config = per->config;
! 99: per->dltotal = dltotal;
! 100: per->dlnow = dlnow;
! 101: per->ultotal = ultotal;
! 102: per->ulnow = ulnow;
! 103:
! 104: if(config->readbusy) {
! 105: config->readbusy = FALSE;
! 106: curl_easy_pause(per->curl, CURLPAUSE_CONT);
! 107: }
! 108:
! 109: return 0;
! 110: }
! 111:
! 112: /* Provide a string that is 2 + 1 + 2 + 1 + 2 = 8 letters long (plus the zero
! 113: byte) */
! 114: static void time2str(char *r, curl_off_t seconds)
! 115: {
! 116: curl_off_t h;
! 117: if(seconds <= 0) {
! 118: strcpy(r, "--:--:--");
! 119: return;
! 120: }
! 121: h = seconds / CURL_OFF_T_C(3600);
! 122: if(h <= CURL_OFF_T_C(99)) {
! 123: curl_off_t m = (seconds - (h*CURL_OFF_T_C(3600))) / CURL_OFF_T_C(60);
! 124: curl_off_t s = (seconds - (h*CURL_OFF_T_C(3600))) - (m*CURL_OFF_T_C(60));
! 125: msnprintf(r, 9, "%2" CURL_FORMAT_CURL_OFF_T ":%02" CURL_FORMAT_CURL_OFF_T
! 126: ":%02" CURL_FORMAT_CURL_OFF_T, h, m, s);
! 127: }
! 128: else {
! 129: /* this equals to more than 99 hours, switch to a more suitable output
! 130: format to fit within the limits. */
! 131: curl_off_t d = seconds / CURL_OFF_T_C(86400);
! 132: h = (seconds - (d*CURL_OFF_T_C(86400))) / CURL_OFF_T_C(3600);
! 133: if(d <= CURL_OFF_T_C(999))
! 134: msnprintf(r, 9, "%3" CURL_FORMAT_CURL_OFF_T
! 135: "d %02" CURL_FORMAT_CURL_OFF_T "h", d, h);
! 136: else
! 137: msnprintf(r, 9, "%7" CURL_FORMAT_CURL_OFF_T "d", d);
! 138: }
! 139: }
! 140:
! 141: static curl_off_t all_dltotal = 0;
! 142: static curl_off_t all_ultotal = 0;
! 143: static curl_off_t all_dlalready = 0;
! 144: static curl_off_t all_ulalready = 0;
! 145:
! 146: curl_off_t all_xfers = 0; /* current total */
! 147:
! 148: struct speedcount {
! 149: curl_off_t dl;
! 150: curl_off_t ul;
! 151: struct timeval stamp;
! 152: };
! 153: #define SPEEDCNT 10
! 154: static unsigned int speedindex;
! 155: static bool indexwrapped;
! 156: static struct speedcount speedstore[SPEEDCNT];
! 157:
! 158: /*
! 159: |DL% UL% Dled Uled Xfers Live Qd Total Current Left Speed
! 160: | 6 -- 9.9G 0 2 2 0 0:00:40 0:00:02 0:00:37 4087M
! 161: */
! 162: bool progress_meter(struct GlobalConfig *global,
! 163: struct timeval *start,
! 164: bool final)
! 165: {
! 166: static struct timeval stamp;
! 167: static bool header = FALSE;
! 168: struct timeval now;
! 169: long diff;
! 170:
! 171: if(global->noprogress)
! 172: return FALSE;
! 173:
! 174: now = tvnow();
! 175: diff = tvdiff(now, stamp);
! 176:
! 177: if(!header) {
! 178: header = TRUE;
! 179: fputs("DL% UL% Dled Uled Xfers Live Qd "
! 180: "Total Current Left Speed\n",
! 181: global->errors);
! 182: }
! 183: if(final || (diff > 500)) {
! 184: char time_left[10];
! 185: char time_total[10];
! 186: char time_spent[10];
! 187: char buffer[3][6];
! 188: curl_off_t spent = tvdiff(now, *start)/1000;
! 189: char dlpercen[4]="--";
! 190: char ulpercen[4]="--";
! 191: struct per_transfer *per;
! 192: curl_off_t all_dlnow = 0;
! 193: curl_off_t all_ulnow = 0;
! 194: bool dlknown = TRUE;
! 195: bool ulknown = TRUE;
! 196: curl_off_t all_running = 0; /* in progress */
! 197: curl_off_t all_queued = 0; /* pending */
! 198: curl_off_t speed = 0;
! 199: unsigned int i;
! 200: stamp = now;
! 201:
! 202: /* first add the amounts of the already completed transfers */
! 203: all_dlnow += all_dlalready;
! 204: all_ulnow += all_ulalready;
! 205:
! 206: for(per = transfers; per; per = per->next) {
! 207: all_dlnow += per->dlnow;
! 208: all_ulnow += per->ulnow;
! 209: if(!per->dltotal)
! 210: dlknown = FALSE;
! 211: else if(!per->dltotal_added) {
! 212: /* only add this amount once */
! 213: all_dltotal += per->dltotal;
! 214: per->dltotal_added = TRUE;
! 215: }
! 216: if(!per->ultotal)
! 217: ulknown = FALSE;
! 218: else if(!per->ultotal_added) {
! 219: /* only add this amount once */
! 220: all_ultotal += per->ultotal;
! 221: per->ultotal_added = TRUE;
! 222: }
! 223: if(!per->added)
! 224: all_queued++;
! 225: else
! 226: all_running++;
! 227: }
! 228: if(dlknown && all_dltotal)
! 229: /* TODO: handle integer overflow */
! 230: msnprintf(dlpercen, sizeof(dlpercen), "%3d",
! 231: all_dlnow * 100 / all_dltotal);
! 232: if(ulknown && all_ultotal)
! 233: /* TODO: handle integer overflow */
! 234: msnprintf(ulpercen, sizeof(ulpercen), "%3d",
! 235: all_ulnow * 100 / all_ultotal);
! 236:
! 237: /* get the transfer speed, the higher of the two */
! 238:
! 239: i = speedindex;
! 240: speedstore[i].dl = all_dlnow;
! 241: speedstore[i].ul = all_ulnow;
! 242: speedstore[i].stamp = now;
! 243: if(++speedindex >= SPEEDCNT) {
! 244: indexwrapped = TRUE;
! 245: speedindex = 0;
! 246: }
! 247:
! 248: {
! 249: long deltams;
! 250: curl_off_t dl;
! 251: curl_off_t ul;
! 252: curl_off_t dls;
! 253: curl_off_t uls;
! 254: if(indexwrapped) {
! 255: /* 'speedindex' is the oldest stored data */
! 256: deltams = tvdiff(now, speedstore[speedindex].stamp);
! 257: dl = all_dlnow - speedstore[speedindex].dl;
! 258: ul = all_ulnow - speedstore[speedindex].ul;
! 259: }
! 260: else {
! 261: /* since the beginning */
! 262: deltams = tvdiff(now, *start);
! 263: dl = all_dlnow;
! 264: ul = all_ulnow;
! 265: }
! 266: dls = (curl_off_t)((double)dl / ((double)deltams/1000.0));
! 267: uls = (curl_off_t)((double)ul / ((double)deltams/1000.0));
! 268: speed = dls > uls ? dls : uls;
! 269: }
! 270:
! 271:
! 272: if(dlknown && speed) {
! 273: curl_off_t est = all_dltotal / speed;
! 274: curl_off_t left = (all_dltotal - all_dlnow) / speed;
! 275: time2str(time_left, left);
! 276: time2str(time_total, est);
! 277: }
! 278: else {
! 279: time2str(time_left, 0);
! 280: time2str(time_total, 0);
! 281: }
! 282: time2str(time_spent, spent);
! 283:
! 284: fprintf(global->errors,
! 285: "\r"
! 286: "%-3s " /* percent downloaded */
! 287: "%-3s " /* percent uploaded */
! 288: "%s " /* Dled */
! 289: "%s " /* Uled */
! 290: "%5" CURL_FORMAT_CURL_OFF_T " " /* Xfers */
! 291: "%5" CURL_FORMAT_CURL_OFF_T " " /* Live */
! 292: "%5" CURL_FORMAT_CURL_OFF_T " " /* Queued */
! 293: "%s " /* Total time */
! 294: "%s " /* Current time */
! 295: "%s " /* Time left */
! 296: "%s " /* Speed */
! 297: "%5s" /* final newline */,
! 298:
! 299: dlpercen, /* 3 letters */
! 300: ulpercen, /* 3 letters */
! 301: max5data(all_dlnow, buffer[0]),
! 302: max5data(all_ulnow, buffer[1]),
! 303: all_xfers,
! 304: all_running,
! 305: all_queued,
! 306: time_total,
! 307: time_spent,
! 308: time_left,
! 309: max5data(speed, buffer[2]), /* speed */
! 310: final ? "\n" :"");
! 311: return TRUE;
! 312: }
! 313: return FALSE;
! 314: }
! 315:
! 316: void progress_finalize(struct per_transfer *per)
! 317: {
! 318: /* get the numbers before this transfer goes away */
! 319: all_dlalready += per->dlnow;
! 320: all_ulalready += per->ulnow;
! 321: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tool_progress.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / src