progress.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625
  1. /***************************************************************************
  2. * _ _ ____ _
  3. * Project ___| | | | _ \| |
  4. * / __| | | | |_) | |
  5. * | (__| |_| | _ <| |___
  6. * \___|\___/|_| \_\_____|
  7. *
  8. * Copyright (C) 1998 - 2019, 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 "curl_setup.h"
  23. #include "urldata.h"
  24. #include "sendf.h"
  25. #include "multiif.h"
  26. #include "progress.h"
  27. #include "timeval.h"
  28. #include "curl_printf.h"
  29. /* check rate limits within this many recent milliseconds, at minimum. */
  30. #define MIN_RATE_LIMIT_PERIOD 3000
  31. #ifndef CURL_DISABLE_PROGRESS_METER
  32. /* Provide a string that is 2 + 1 + 2 + 1 + 2 = 8 letters long (plus the zero
  33. byte) */
  34. static void time2str(char *r, curl_off_t seconds)
  35. {
  36. curl_off_t h;
  37. if(seconds <= 0) {
  38. strcpy(r, "--:--:--");
  39. return;
  40. }
  41. h = seconds / CURL_OFF_T_C(3600);
  42. if(h <= CURL_OFF_T_C(99)) {
  43. curl_off_t m = (seconds - (h*CURL_OFF_T_C(3600))) / CURL_OFF_T_C(60);
  44. curl_off_t s = (seconds - (h*CURL_OFF_T_C(3600))) - (m*CURL_OFF_T_C(60));
  45. msnprintf(r, 9, "%2" CURL_FORMAT_CURL_OFF_T ":%02" CURL_FORMAT_CURL_OFF_T
  46. ":%02" CURL_FORMAT_CURL_OFF_T, h, m, s);
  47. }
  48. else {
  49. /* this equals to more than 99 hours, switch to a more suitable output
  50. format to fit within the limits. */
  51. curl_off_t d = seconds / CURL_OFF_T_C(86400);
  52. h = (seconds - (d*CURL_OFF_T_C(86400))) / CURL_OFF_T_C(3600);
  53. if(d <= CURL_OFF_T_C(999))
  54. msnprintf(r, 9, "%3" CURL_FORMAT_CURL_OFF_T
  55. "d %02" CURL_FORMAT_CURL_OFF_T "h", d, h);
  56. else
  57. msnprintf(r, 9, "%7" CURL_FORMAT_CURL_OFF_T "d", d);
  58. }
  59. }
  60. /* The point of this function would be to return a string of the input data,
  61. but never longer than 5 columns (+ one zero byte).
  62. Add suffix k, M, G when suitable... */
  63. static char *max5data(curl_off_t bytes, char *max5)
  64. {
  65. #define ONE_KILOBYTE CURL_OFF_T_C(1024)
  66. #define ONE_MEGABYTE (CURL_OFF_T_C(1024) * ONE_KILOBYTE)
  67. #define ONE_GIGABYTE (CURL_OFF_T_C(1024) * ONE_MEGABYTE)
  68. #define ONE_TERABYTE (CURL_OFF_T_C(1024) * ONE_GIGABYTE)
  69. #define ONE_PETABYTE (CURL_OFF_T_C(1024) * ONE_TERABYTE)
  70. if(bytes < CURL_OFF_T_C(100000))
  71. msnprintf(max5, 6, "%5" CURL_FORMAT_CURL_OFF_T, bytes);
  72. else if(bytes < CURL_OFF_T_C(10000) * ONE_KILOBYTE)
  73. msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "k", bytes/ONE_KILOBYTE);
  74. else if(bytes < CURL_OFF_T_C(100) * ONE_MEGABYTE)
  75. /* 'XX.XM' is good as long as we're less than 100 megs */
  76. msnprintf(max5, 6, "%2" CURL_FORMAT_CURL_OFF_T ".%0"
  77. CURL_FORMAT_CURL_OFF_T "M", bytes/ONE_MEGABYTE,
  78. (bytes%ONE_MEGABYTE) / (ONE_MEGABYTE/CURL_OFF_T_C(10)) );
  79. #if (CURL_SIZEOF_CURL_OFF_T > 4)
  80. else if(bytes < CURL_OFF_T_C(10000) * ONE_MEGABYTE)
  81. /* 'XXXXM' is good until we're at 10000MB or above */
  82. msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "M", bytes/ONE_MEGABYTE);
  83. else if(bytes < CURL_OFF_T_C(100) * ONE_GIGABYTE)
  84. /* 10000 MB - 100 GB, we show it as XX.XG */
  85. msnprintf(max5, 6, "%2" CURL_FORMAT_CURL_OFF_T ".%0"
  86. CURL_FORMAT_CURL_OFF_T "G", bytes/ONE_GIGABYTE,
  87. (bytes%ONE_GIGABYTE) / (ONE_GIGABYTE/CURL_OFF_T_C(10)) );
  88. else if(bytes < CURL_OFF_T_C(10000) * ONE_GIGABYTE)
  89. /* up to 10000GB, display without decimal: XXXXG */
  90. msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "G", bytes/ONE_GIGABYTE);
  91. else if(bytes < CURL_OFF_T_C(10000) * ONE_TERABYTE)
  92. /* up to 10000TB, display without decimal: XXXXT */
  93. msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "T", bytes/ONE_TERABYTE);
  94. else
  95. /* up to 10000PB, display without decimal: XXXXP */
  96. msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "P", bytes/ONE_PETABYTE);
  97. /* 16384 petabytes (16 exabytes) is the maximum a 64 bit unsigned number
  98. can hold, but our data type is signed so 8192PB will be the maximum. */
  99. #else
  100. else
  101. msnprintf(max5, 6, "%4" CURL_FORMAT_CURL_OFF_T "M", bytes/ONE_MEGABYTE);
  102. #endif
  103. return max5;
  104. }
  105. #endif
  106. /*
  107. New proposed interface, 9th of February 2000:
  108. pgrsStartNow() - sets start time
  109. pgrsSetDownloadSize(x) - known expected download size
  110. pgrsSetUploadSize(x) - known expected upload size
  111. pgrsSetDownloadCounter() - amount of data currently downloaded
  112. pgrsSetUploadCounter() - amount of data currently uploaded
  113. pgrsUpdate() - show progress
  114. pgrsDone() - transfer complete
  115. */
  116. int Curl_pgrsDone(struct connectdata *conn)
  117. {
  118. int rc;
  119. struct Curl_easy *data = conn->data;
  120. data->progress.lastshow = 0;
  121. rc = Curl_pgrsUpdate(conn); /* the final (forced) update */
  122. if(rc)
  123. return rc;
  124. if(!(data->progress.flags & PGRS_HIDE) &&
  125. !data->progress.callback)
  126. /* only output if we don't use a progress callback and we're not
  127. * hidden */
  128. fprintf(data->set.err, "\n");
  129. data->progress.speeder_c = 0; /* reset the progress meter display */
  130. return 0;
  131. }
  132. /* reset the known transfer sizes */
  133. void Curl_pgrsResetTransferSizes(struct Curl_easy *data)
  134. {
  135. Curl_pgrsSetDownloadSize(data, -1);
  136. Curl_pgrsSetUploadSize(data, -1);
  137. }
  138. /*
  139. * @unittest: 1399
  140. */
  141. void Curl_pgrsTime(struct Curl_easy *data, timerid timer)
  142. {
  143. struct curltime now = Curl_now();
  144. timediff_t *delta = NULL;
  145. switch(timer) {
  146. default:
  147. case TIMER_NONE:
  148. /* mistake filter */
  149. break;
  150. case TIMER_STARTOP:
  151. /* This is set at the start of a transfer */
  152. data->progress.t_startop = now;
  153. break;
  154. case TIMER_STARTSINGLE:
  155. /* This is set at the start of each single fetch */
  156. data->progress.t_startsingle = now;
  157. data->progress.is_t_startransfer_set = false;
  158. break;
  159. case TIMER_STARTACCEPT:
  160. data->progress.t_acceptdata = now;
  161. break;
  162. case TIMER_NAMELOOKUP:
  163. delta = &data->progress.t_nslookup;
  164. break;
  165. case TIMER_CONNECT:
  166. delta = &data->progress.t_connect;
  167. break;
  168. case TIMER_APPCONNECT:
  169. delta = &data->progress.t_appconnect;
  170. break;
  171. case TIMER_PRETRANSFER:
  172. delta = &data->progress.t_pretransfer;
  173. break;
  174. case TIMER_STARTTRANSFER:
  175. delta = &data->progress.t_starttransfer;
  176. /* prevent updating t_starttransfer unless:
  177. * 1) this is the first time we're setting t_starttransfer
  178. * 2) a redirect has occurred since the last time t_starttransfer was set
  179. * This prevents repeated invocations of the function from incorrectly
  180. * changing the t_starttransfer time.
  181. */
  182. if(data->progress.is_t_startransfer_set) {
  183. return;
  184. }
  185. else {
  186. data->progress.is_t_startransfer_set = true;
  187. break;
  188. }
  189. case TIMER_POSTRANSFER:
  190. /* this is the normal end-of-transfer thing */
  191. break;
  192. case TIMER_REDIRECT:
  193. data->progress.t_redirect = Curl_timediff_us(now, data->progress.start);
  194. break;
  195. }
  196. if(delta) {
  197. timediff_t us = Curl_timediff_us(now, data->progress.t_startsingle);
  198. if(us < 1)
  199. us = 1; /* make sure at least one microsecond passed */
  200. *delta += us;
  201. }
  202. }
  203. void Curl_pgrsStartNow(struct Curl_easy *data)
  204. {
  205. data->progress.speeder_c = 0; /* reset the progress meter display */
  206. data->progress.start = Curl_now();
  207. data->progress.is_t_startransfer_set = false;
  208. data->progress.ul_limit_start.tv_sec = 0;
  209. data->progress.ul_limit_start.tv_usec = 0;
  210. data->progress.dl_limit_start.tv_sec = 0;
  211. data->progress.dl_limit_start.tv_usec = 0;
  212. data->progress.downloaded = 0;
  213. data->progress.uploaded = 0;
  214. /* clear all bits except HIDE and HEADERS_OUT */
  215. data->progress.flags &= PGRS_HIDE|PGRS_HEADERS_OUT;
  216. Curl_ratelimit(data, data->progress.start);
  217. }
  218. /*
  219. * This is used to handle speed limits, calculating how many milliseconds to
  220. * wait until we're back under the speed limit, if needed.
  221. *
  222. * The way it works is by having a "starting point" (time & amount of data
  223. * transferred by then) used in the speed computation, to be used instead of
  224. * the start of the transfer. This starting point is regularly moved as
  225. * transfer goes on, to keep getting accurate values (instead of average over
  226. * the entire transfer).
  227. *
  228. * This function takes the current amount of data transferred, the amount at
  229. * the starting point, the limit (in bytes/s), the time of the starting point
  230. * and the current time.
  231. *
  232. * Returns 0 if no waiting is needed or when no waiting is needed but the
  233. * starting point should be reset (to current); or the number of milliseconds
  234. * to wait to get back under the speed limit.
  235. */
  236. timediff_t Curl_pgrsLimitWaitTime(curl_off_t cursize,
  237. curl_off_t startsize,
  238. curl_off_t limit,
  239. struct curltime start,
  240. struct curltime now)
  241. {
  242. curl_off_t size = cursize - startsize;
  243. timediff_t minimum;
  244. timediff_t actual;
  245. if(!limit || !size)
  246. return 0;
  247. /*
  248. * 'minimum' is the number of milliseconds 'size' should take to download to
  249. * stay below 'limit'.
  250. */
  251. if(size < CURL_OFF_T_MAX/1000)
  252. minimum = (time_t) (CURL_OFF_T_C(1000) * size / limit);
  253. else {
  254. minimum = (time_t) (size / limit);
  255. if(minimum < TIMEDIFF_T_MAX/1000)
  256. minimum *= 1000;
  257. else
  258. minimum = TIMEDIFF_T_MAX;
  259. }
  260. /*
  261. * 'actual' is the time in milliseconds it took to actually download the
  262. * last 'size' bytes.
  263. */
  264. actual = Curl_timediff(now, start);
  265. if(actual < minimum) {
  266. /* if it downloaded the data faster than the limit, make it wait the
  267. difference */
  268. return (minimum - actual);
  269. }
  270. return 0;
  271. }
  272. /*
  273. * Set the number of downloaded bytes so far.
  274. */
  275. void Curl_pgrsSetDownloadCounter(struct Curl_easy *data, curl_off_t size)
  276. {
  277. data->progress.downloaded = size;
  278. }
  279. /*
  280. * Update the timestamp and sizestamp to use for rate limit calculations.
  281. */
  282. void Curl_ratelimit(struct Curl_easy *data, struct curltime now)
  283. {
  284. /* don't set a new stamp unless the time since last update is long enough */
  285. if(data->set.max_recv_speed > 0) {
  286. if(Curl_timediff(now, data->progress.dl_limit_start) >=
  287. MIN_RATE_LIMIT_PERIOD) {
  288. data->progress.dl_limit_start = now;
  289. data->progress.dl_limit_size = data->progress.downloaded;
  290. }
  291. }
  292. if(data->set.max_send_speed > 0) {
  293. if(Curl_timediff(now, data->progress.ul_limit_start) >=
  294. MIN_RATE_LIMIT_PERIOD) {
  295. data->progress.ul_limit_start = now;
  296. data->progress.ul_limit_size = data->progress.uploaded;
  297. }
  298. }
  299. }
  300. /*
  301. * Set the number of uploaded bytes so far.
  302. */
  303. void Curl_pgrsSetUploadCounter(struct Curl_easy *data, curl_off_t size)
  304. {
  305. data->progress.uploaded = size;
  306. }
  307. void Curl_pgrsSetDownloadSize(struct Curl_easy *data, curl_off_t size)
  308. {
  309. if(size >= 0) {
  310. data->progress.size_dl = size;
  311. data->progress.flags |= PGRS_DL_SIZE_KNOWN;
  312. }
  313. else {
  314. data->progress.size_dl = 0;
  315. data->progress.flags &= ~PGRS_DL_SIZE_KNOWN;
  316. }
  317. }
  318. void Curl_pgrsSetUploadSize(struct Curl_easy *data, curl_off_t size)
  319. {
  320. if(size >= 0) {
  321. data->progress.size_ul = size;
  322. data->progress.flags |= PGRS_UL_SIZE_KNOWN;
  323. }
  324. else {
  325. data->progress.size_ul = 0;
  326. data->progress.flags &= ~PGRS_UL_SIZE_KNOWN;
  327. }
  328. }
  329. /* returns TRUE if it's time to show the progress meter */
  330. static bool progress_calc(struct connectdata *conn, struct curltime now)
  331. {
  332. curl_off_t timespent;
  333. curl_off_t timespent_ms; /* milliseconds */
  334. struct Curl_easy *data = conn->data;
  335. curl_off_t dl = data->progress.downloaded;
  336. curl_off_t ul = data->progress.uploaded;
  337. bool timetoshow = FALSE;
  338. /* The time spent so far (from the start) */
  339. data->progress.timespent = Curl_timediff_us(now, data->progress.start);
  340. timespent = (curl_off_t)data->progress.timespent/1000000; /* seconds */
  341. timespent_ms = (curl_off_t)data->progress.timespent/1000; /* ms */
  342. /* The average download speed this far */
  343. if(dl < CURL_OFF_T_MAX/1000)
  344. data->progress.dlspeed = (dl * 1000 / (timespent_ms>0?timespent_ms:1));
  345. else
  346. data->progress.dlspeed = (dl / (timespent>0?timespent:1));
  347. /* The average upload speed this far */
  348. if(ul < CURL_OFF_T_MAX/1000)
  349. data->progress.ulspeed = (ul * 1000 / (timespent_ms>0?timespent_ms:1));
  350. else
  351. data->progress.ulspeed = (ul / (timespent>0?timespent:1));
  352. /* Calculations done at most once a second, unless end is reached */
  353. if(data->progress.lastshow != now.tv_sec) {
  354. int countindex; /* amount of seconds stored in the speeder array */
  355. int nowindex = data->progress.speeder_c% CURR_TIME;
  356. data->progress.lastshow = now.tv_sec;
  357. timetoshow = TRUE;
  358. /* Let's do the "current speed" thing, with the dl + ul speeds
  359. combined. Store the speed at entry 'nowindex'. */
  360. data->progress.speeder[ nowindex ] =
  361. data->progress.downloaded + data->progress.uploaded;
  362. /* remember the exact time for this moment */
  363. data->progress.speeder_time [ nowindex ] = now;
  364. /* advance our speeder_c counter, which is increased every time we get
  365. here and we expect it to never wrap as 2^32 is a lot of seconds! */
  366. data->progress.speeder_c++;
  367. /* figure out how many index entries of data we have stored in our speeder
  368. array. With N_ENTRIES filled in, we have about N_ENTRIES-1 seconds of
  369. transfer. Imagine, after one second we have filled in two entries,
  370. after two seconds we've filled in three entries etc. */
  371. countindex = ((data->progress.speeder_c >= CURR_TIME)?
  372. CURR_TIME:data->progress.speeder_c) - 1;
  373. /* first of all, we don't do this if there's no counted seconds yet */
  374. if(countindex) {
  375. int checkindex;
  376. timediff_t span_ms;
  377. /* Get the index position to compare with the 'nowindex' position.
  378. Get the oldest entry possible. While we have less than CURR_TIME
  379. entries, the first entry will remain the oldest. */
  380. checkindex = (data->progress.speeder_c >= CURR_TIME)?
  381. data->progress.speeder_c%CURR_TIME:0;
  382. /* Figure out the exact time for the time span */
  383. span_ms = Curl_timediff(now, data->progress.speeder_time[checkindex]);
  384. if(0 == span_ms)
  385. span_ms = 1; /* at least one millisecond MUST have passed */
  386. /* Calculate the average speed the last 'span_ms' milliseconds */
  387. {
  388. curl_off_t amount = data->progress.speeder[nowindex]-
  389. data->progress.speeder[checkindex];
  390. if(amount > CURL_OFF_T_C(4294967) /* 0xffffffff/1000 */)
  391. /* the 'amount' value is bigger than would fit in 32 bits if
  392. multiplied with 1000, so we use the double math for this */
  393. data->progress.current_speed = (curl_off_t)
  394. ((double)amount/((double)span_ms/1000.0));
  395. else
  396. /* the 'amount' value is small enough to fit within 32 bits even
  397. when multiplied with 1000 */
  398. data->progress.current_speed = amount*CURL_OFF_T_C(1000)/span_ms;
  399. }
  400. }
  401. else
  402. /* the first second we use the average */
  403. data->progress.current_speed =
  404. data->progress.ulspeed + data->progress.dlspeed;
  405. } /* Calculations end */
  406. return timetoshow;
  407. }
  408. #ifndef CURL_DISABLE_PROGRESS_METER
  409. static void progress_meter(struct connectdata *conn)
  410. {
  411. struct Curl_easy *data = conn->data;
  412. char max5[6][10];
  413. curl_off_t dlpercen = 0;
  414. curl_off_t ulpercen = 0;
  415. curl_off_t total_percen = 0;
  416. curl_off_t total_transfer;
  417. curl_off_t total_expected_transfer;
  418. char time_left[10];
  419. char time_total[10];
  420. char time_spent[10];
  421. curl_off_t ulestimate = 0;
  422. curl_off_t dlestimate = 0;
  423. curl_off_t total_estimate;
  424. curl_off_t timespent =
  425. (curl_off_t)data->progress.timespent/1000000; /* seconds */
  426. if(!(data->progress.flags & PGRS_HEADERS_OUT)) {
  427. if(data->state.resume_from) {
  428. fprintf(data->set.err,
  429. "** Resuming transfer from byte position %"
  430. CURL_FORMAT_CURL_OFF_T "\n", data->state.resume_from);
  431. }
  432. fprintf(data->set.err,
  433. " %% Total %% Received %% Xferd Average Speed "
  434. "Time Time Time Current\n"
  435. " Dload Upload "
  436. "Total Spent Left Speed\n");
  437. data->progress.flags |= PGRS_HEADERS_OUT; /* headers are shown */
  438. }
  439. /* Figure out the estimated time of arrival for the upload */
  440. if((data->progress.flags & PGRS_UL_SIZE_KNOWN) &&
  441. (data->progress.ulspeed > CURL_OFF_T_C(0))) {
  442. ulestimate = data->progress.size_ul / data->progress.ulspeed;
  443. if(data->progress.size_ul > CURL_OFF_T_C(10000))
  444. ulpercen = data->progress.uploaded /
  445. (data->progress.size_ul/CURL_OFF_T_C(100));
  446. else if(data->progress.size_ul > CURL_OFF_T_C(0))
  447. ulpercen = (data->progress.uploaded*100) /
  448. data->progress.size_ul;
  449. }
  450. /* ... and the download */
  451. if((data->progress.flags & PGRS_DL_SIZE_KNOWN) &&
  452. (data->progress.dlspeed > CURL_OFF_T_C(0))) {
  453. dlestimate = data->progress.size_dl / data->progress.dlspeed;
  454. if(data->progress.size_dl > CURL_OFF_T_C(10000))
  455. dlpercen = data->progress.downloaded /
  456. (data->progress.size_dl/CURL_OFF_T_C(100));
  457. else if(data->progress.size_dl > CURL_OFF_T_C(0))
  458. dlpercen = (data->progress.downloaded*100) /
  459. data->progress.size_dl;
  460. }
  461. /* Now figure out which of them is slower and use that one for the
  462. total estimate! */
  463. total_estimate = ulestimate>dlestimate?ulestimate:dlestimate;
  464. /* create the three time strings */
  465. time2str(time_left, total_estimate > 0?(total_estimate - timespent):0);
  466. time2str(time_total, total_estimate);
  467. time2str(time_spent, timespent);
  468. /* Get the total amount of data expected to get transferred */
  469. total_expected_transfer =
  470. ((data->progress.flags & PGRS_UL_SIZE_KNOWN)?
  471. data->progress.size_ul:data->progress.uploaded)+
  472. ((data->progress.flags & PGRS_DL_SIZE_KNOWN)?
  473. data->progress.size_dl:data->progress.downloaded);
  474. /* We have transferred this much so far */
  475. total_transfer = data->progress.downloaded + data->progress.uploaded;
  476. /* Get the percentage of data transferred so far */
  477. if(total_expected_transfer > CURL_OFF_T_C(10000))
  478. total_percen = total_transfer /
  479. (total_expected_transfer/CURL_OFF_T_C(100));
  480. else if(total_expected_transfer > CURL_OFF_T_C(0))
  481. total_percen = (total_transfer*100) / total_expected_transfer;
  482. fprintf(data->set.err,
  483. "\r"
  484. "%3" CURL_FORMAT_CURL_OFF_T " %s "
  485. "%3" CURL_FORMAT_CURL_OFF_T " %s "
  486. "%3" CURL_FORMAT_CURL_OFF_T " %s %s %s %s %s %s %s",
  487. total_percen, /* 3 letters */ /* total % */
  488. max5data(total_expected_transfer, max5[2]), /* total size */
  489. dlpercen, /* 3 letters */ /* rcvd % */
  490. max5data(data->progress.downloaded, max5[0]), /* rcvd size */
  491. ulpercen, /* 3 letters */ /* xfer % */
  492. max5data(data->progress.uploaded, max5[1]), /* xfer size */
  493. max5data(data->progress.dlspeed, max5[3]), /* avrg dl speed */
  494. max5data(data->progress.ulspeed, max5[4]), /* avrg ul speed */
  495. time_total, /* 8 letters */ /* total time */
  496. time_spent, /* 8 letters */ /* time spent */
  497. time_left, /* 8 letters */ /* time left */
  498. max5data(data->progress.current_speed, max5[5])
  499. );
  500. /* we flush the output stream to make it appear as soon as possible */
  501. fflush(data->set.err);
  502. }
  503. #else
  504. /* progress bar disabled */
  505. #define progress_meter(x) Curl_nop_stmt
  506. #endif
  507. /*
  508. * Curl_pgrsUpdate() returns 0 for success or the value returned by the
  509. * progress callback!
  510. */
  511. int Curl_pgrsUpdate(struct connectdata *conn)
  512. {
  513. struct Curl_easy *data = conn->data;
  514. struct curltime now = Curl_now(); /* what time is it */
  515. bool showprogress = progress_calc(conn, now);
  516. if(!(data->progress.flags & PGRS_HIDE)) {
  517. if(data->set.fxferinfo) {
  518. int result;
  519. /* There's a callback set, call that */
  520. Curl_set_in_callback(data, true);
  521. result = data->set.fxferinfo(data->set.progress_client,
  522. data->progress.size_dl,
  523. data->progress.downloaded,
  524. data->progress.size_ul,
  525. data->progress.uploaded);
  526. Curl_set_in_callback(data, false);
  527. if(result != CURL_PROGRESSFUNC_CONTINUE) {
  528. if(result)
  529. failf(data, "Callback aborted");
  530. return result;
  531. }
  532. }
  533. else if(data->set.fprogress) {
  534. int result;
  535. /* The older deprecated callback is set, call that */
  536. Curl_set_in_callback(data, true);
  537. result = data->set.fprogress(data->set.progress_client,
  538. (double)data->progress.size_dl,
  539. (double)data->progress.downloaded,
  540. (double)data->progress.size_ul,
  541. (double)data->progress.uploaded);
  542. Curl_set_in_callback(data, false);
  543. if(result != CURL_PROGRESSFUNC_CONTINUE) {
  544. if(result)
  545. failf(data, "Callback aborted");
  546. return result;
  547. }
  548. }
  549. if(showprogress)
  550. progress_meter(conn);
  551. }
  552. return 0;
  553. }