Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

1 files changed, 144 insertions, 144 deletions

diff --git a/contrib/libs/curl/lib/progress.c b/contrib/libs/curl/lib/progress.c
index e16b0725531..658d05ab8e5 100644
--- a/contrib/libs/curl/lib/progress.c
+++ b/contrib/libs/curl/lib/progress.c
@@ -26,13 +26,13 @@
 #include "sendf.h"
 #include "multiif.h"
 #include "progress.h"
-#include "timeval.h" 
+#include "timeval.h"
 #include "curl_printf.h"
 
 /* check rate limits within this many recent milliseconds, at minimum. */
 #define MIN_RATE_LIMIT_PERIOD 3000
 
-#ifndef CURL_DISABLE_PROGRESS_METER 
+#ifndef CURL_DISABLE_PROGRESS_METER
 /* Provide a string that is 2 + 1 + 2 + 1 + 2 = 8 letters long (plus the zero
    byte) */
 static void time2str(char *r, curl_off_t seconds)
@@ -121,7 +121,7 @@ static char *max5data(curl_off_t bytes, char *max5)
 
   return max5;
 }
-#endif 
+#endif
 
 /*
 
@@ -173,7 +173,7 @@ void Curl_pgrsResetTransferSizes(struct Curl_easy *data)
 struct curltime Curl_pgrsTime(struct Curl_easy *data, timerid timer)
 {
   struct curltime now = Curl_now();
-  timediff_t *delta = NULL; 
+  timediff_t *delta = NULL;
 
   switch(timer) {
   default:
@@ -242,8 +242,8 @@ void Curl_pgrsStartNow(struct Curl_easy *data)
   data->progress.is_t_startransfer_set = false;
   data->progress.ul_limit_start = data->progress.start;
   data->progress.dl_limit_start = data->progress.start;
-  data->progress.downloaded = 0; 
-  data->progress.uploaded = 0; 
+  data->progress.downloaded = 0;
+  data->progress.uploaded = 0;
   /* clear all bits except HIDE and HEADERS_OUT */
   data->progress.flags &= PGRS_HIDE|PGRS_HEADERS_OUT;
   Curl_ratelimit(data, data->progress.start);
@@ -274,8 +274,8 @@ timediff_t Curl_pgrsLimitWaitTime(curl_off_t cursize,
                                   struct curltime now)
 {
   curl_off_t size = cursize - startsize;
-  timediff_t minimum; 
-  timediff_t actual; 
+  timediff_t minimum;
+  timediff_t actual;
 
   if(!limit || !size)
     return 0;
@@ -288,10 +288,10 @@ timediff_t Curl_pgrsLimitWaitTime(curl_off_t cursize,
     minimum = (timediff_t) (CURL_OFF_T_C(1000) * size / limit);
   else {
     minimum = (timediff_t) (size / limit);
-    if(minimum < TIMEDIFF_T_MAX/1000) 
+    if(minimum < TIMEDIFF_T_MAX/1000)
       minimum *= 1000;
     else
-      minimum = TIMEDIFF_T_MAX; 
+      minimum = TIMEDIFF_T_MAX;
   }
 
   /*
@@ -370,15 +370,15 @@ void Curl_pgrsSetUploadSize(struct Curl_easy *data, curl_off_t size)
   }
 }
 
-/* returns TRUE if it's time to show the progress meter */ 
-static bool progress_calc(struct connectdata *conn, struct curltime now) 
+/* returns TRUE if it's time to show the progress meter */
+static bool progress_calc(struct connectdata *conn, struct curltime now)
 {
   curl_off_t timespent;
   curl_off_t timespent_ms; /* milliseconds */
   struct Curl_easy *data = conn->data;
   curl_off_t dl = data->progress.downloaded;
   curl_off_t ul = data->progress.uploaded;
-  bool timetoshow = FALSE; 
+  bool timetoshow = FALSE;
 
   /* The time spent so far (from the start) */
   data->progress.timespent = Curl_timediff_us(now, data->progress.start);
@@ -400,9 +400,9 @@ static bool progress_calc(struct connectdata *conn, struct curltime now)
   /* Calculations done at most once a second, unless end is reached */
   if(data->progress.lastshow != now.tv_sec) {
     int countindex; /* amount of seconds stored in the speeder array */
-    int nowindex = data->progress.speeder_c% CURR_TIME; 
+    int nowindex = data->progress.speeder_c% CURR_TIME;
     data->progress.lastshow = now.tv_sec;
-    timetoshow = TRUE; 
+    timetoshow = TRUE;
 
     /* Let's do the "current speed" thing, with the dl + ul speeds
        combined. Store the speed at entry 'nowindex'. */
@@ -435,7 +435,7 @@ static bool progress_calc(struct connectdata *conn, struct curltime now)
         data->progress.speeder_c%CURR_TIME:0;
 
       /* Figure out the exact time for the time span */
-      span_ms = Curl_timediff(now, data->progress.speeder_time[checkindex]); 
+      span_ms = Curl_timediff(now, data->progress.speeder_time[checkindex]);
       if(0 == span_ms)
         span_ms = 1; /* at least one millisecond MUST have passed */
 
@@ -461,131 +461,131 @@ static bool progress_calc(struct connectdata *conn, struct curltime now)
         data->progress.ulspeed + data->progress.dlspeed;
 
   } /* Calculations end */
-  return timetoshow; 
-} 
-
-#ifndef CURL_DISABLE_PROGRESS_METER 
-static void progress_meter(struct connectdata *conn) 
-{ 
-  struct Curl_easy *data = conn->data; 
-  char max5[6][10]; 
-  curl_off_t dlpercen = 0; 
-  curl_off_t ulpercen = 0; 
-  curl_off_t total_percen = 0; 
-  curl_off_t total_transfer; 
-  curl_off_t total_expected_transfer; 
-  char time_left[10]; 
-  char time_total[10]; 
-  char time_spent[10]; 
-  curl_off_t ulestimate = 0; 
-  curl_off_t dlestimate = 0; 
-  curl_off_t total_estimate; 
-  curl_off_t timespent = 
-    (curl_off_t)data->progress.timespent/1000000; /* seconds */ 
- 
-  if(!(data->progress.flags & PGRS_HEADERS_OUT)) { 
-    if(data->state.resume_from) { 
-      fprintf(data->set.err, 
-              "** Resuming transfer from byte position %" 
-              CURL_FORMAT_CURL_OFF_T "\n", data->state.resume_from); 
-    } 
-    fprintf(data->set.err, 
-            "  %% Total    %% Received %% Xferd  Average Speed   " 
-            "Time    Time     Time  Current\n" 
-            "                                 Dload  Upload   " 
-            "Total   Spent    Left  Speed\n"); 
-    data->progress.flags |= PGRS_HEADERS_OUT; /* headers are shown */ 
-  } 
- 
-  /* Figure out the estimated time of arrival for the upload */ 
-  if((data->progress.flags & PGRS_UL_SIZE_KNOWN) && 
-     (data->progress.ulspeed > CURL_OFF_T_C(0))) { 
-    ulestimate = data->progress.size_ul / data->progress.ulspeed; 
- 
-    if(data->progress.size_ul > CURL_OFF_T_C(10000)) 
-      ulpercen = data->progress.uploaded / 
-        (data->progress.size_ul/CURL_OFF_T_C(100)); 
-    else if(data->progress.size_ul > CURL_OFF_T_C(0)) 
-      ulpercen = (data->progress.uploaded*100) / 
-        data->progress.size_ul; 
-  } 
- 
-  /* ... and the download */ 
-  if((data->progress.flags & PGRS_DL_SIZE_KNOWN) && 
-     (data->progress.dlspeed > CURL_OFF_T_C(0))) { 
-    dlestimate = data->progress.size_dl / data->progress.dlspeed; 
- 
-    if(data->progress.size_dl > CURL_OFF_T_C(10000)) 
-      dlpercen = data->progress.downloaded / 
-        (data->progress.size_dl/CURL_OFF_T_C(100)); 
-    else if(data->progress.size_dl > CURL_OFF_T_C(0)) 
-      dlpercen = (data->progress.downloaded*100) / 
-        data->progress.size_dl; 
-  } 
- 
-  /* Now figure out which of them is slower and use that one for the 
-     total estimate! */ 
-  total_estimate = ulestimate>dlestimate?ulestimate:dlestimate; 
- 
-  /* create the three time strings */ 
-  time2str(time_left, total_estimate > 0?(total_estimate - timespent):0); 
-  time2str(time_total, total_estimate); 
-  time2str(time_spent, timespent); 
- 
-  /* Get the total amount of data expected to get transferred */ 
-  total_expected_transfer = 
-    ((data->progress.flags & PGRS_UL_SIZE_KNOWN)? 
-     data->progress.size_ul:data->progress.uploaded)+ 
-    ((data->progress.flags & PGRS_DL_SIZE_KNOWN)? 
-     data->progress.size_dl:data->progress.downloaded); 
- 
-  /* We have transferred this much so far */ 
-  total_transfer = data->progress.downloaded + data->progress.uploaded; 
- 
-  /* Get the percentage of data transferred so far */ 
-  if(total_expected_transfer > CURL_OFF_T_C(10000)) 
-    total_percen = total_transfer / 
-      (total_expected_transfer/CURL_OFF_T_C(100)); 
-  else if(total_expected_transfer > CURL_OFF_T_C(0)) 
-    total_percen = (total_transfer*100) / total_expected_transfer; 
- 
-  fprintf(data->set.err, 
-          "\r" 
-          "%3" CURL_FORMAT_CURL_OFF_T " %s  " 
-          "%3" CURL_FORMAT_CURL_OFF_T " %s  " 
-          "%3" CURL_FORMAT_CURL_OFF_T " %s  %s  %s %s %s %s %s", 
-          total_percen,  /* 3 letters */                /* total % */ 
-          max5data(total_expected_transfer, max5[2]),   /* total size */ 
-          dlpercen,      /* 3 letters */                /* rcvd % */ 
-          max5data(data->progress.downloaded, max5[0]), /* rcvd size */ 
-          ulpercen,      /* 3 letters */                /* xfer % */ 
-          max5data(data->progress.uploaded, max5[1]),   /* xfer size */ 
-          max5data(data->progress.dlspeed, max5[3]),    /* avrg dl speed */ 
-          max5data(data->progress.ulspeed, max5[4]),    /* avrg ul speed */ 
-          time_total,    /* 8 letters */                /* total time */ 
-          time_spent,    /* 8 letters */                /* time spent */ 
-          time_left,     /* 8 letters */                /* time left */ 
-          max5data(data->progress.current_speed, max5[5]) 
-    ); 
- 
-  /* we flush the output stream to make it appear as soon as possible */ 
-  fflush(data->set.err); 
-} 
-#else 
- /* progress bar disabled */ 
-#define progress_meter(x) Curl_nop_stmt 
-#endif 
- 
- 
-/* 
- * Curl_pgrsUpdate() returns 0 for success or the value returned by the 
- * progress callback! 
- */ 
-int Curl_pgrsUpdate(struct connectdata *conn) 
-{ 
-  struct Curl_easy *data = conn->data; 
-  struct curltime now = Curl_now(); /* what time is it */ 
-  bool showprogress = progress_calc(conn, now); 
+  return timetoshow;
+}
+
+#ifndef CURL_DISABLE_PROGRESS_METER
+static void progress_meter(struct connectdata *conn)
+{
+  struct Curl_easy *data = conn->data;
+  char max5[6][10];
+  curl_off_t dlpercen = 0;
+  curl_off_t ulpercen = 0;
+  curl_off_t total_percen = 0;
+  curl_off_t total_transfer;
+  curl_off_t total_expected_transfer;
+  char time_left[10];
+  char time_total[10];
+  char time_spent[10];
+  curl_off_t ulestimate = 0;
+  curl_off_t dlestimate = 0;
+  curl_off_t total_estimate;
+  curl_off_t timespent =
+    (curl_off_t)data->progress.timespent/1000000; /* seconds */
+
+  if(!(data->progress.flags & PGRS_HEADERS_OUT)) {
+    if(data->state.resume_from) {
+      fprintf(data->set.err,
+              "** Resuming transfer from byte position %"
+              CURL_FORMAT_CURL_OFF_T "\n", data->state.resume_from);
+    }
+    fprintf(data->set.err,
+            "  %% Total    %% Received %% Xferd  Average Speed   "
+            "Time    Time     Time  Current\n"
+            "                                 Dload  Upload   "
+            "Total   Spent    Left  Speed\n");
+    data->progress.flags |= PGRS_HEADERS_OUT; /* headers are shown */
+  }
+
+  /* Figure out the estimated time of arrival for the upload */
+  if((data->progress.flags & PGRS_UL_SIZE_KNOWN) &&
+     (data->progress.ulspeed > CURL_OFF_T_C(0))) {
+    ulestimate = data->progress.size_ul / data->progress.ulspeed;
+
+    if(data->progress.size_ul > CURL_OFF_T_C(10000))
+      ulpercen = data->progress.uploaded /
+        (data->progress.size_ul/CURL_OFF_T_C(100));
+    else if(data->progress.size_ul > CURL_OFF_T_C(0))
+      ulpercen = (data->progress.uploaded*100) /
+        data->progress.size_ul;
+  }
+
+  /* ... and the download */
+  if((data->progress.flags & PGRS_DL_SIZE_KNOWN) &&
+     (data->progress.dlspeed > CURL_OFF_T_C(0))) {
+    dlestimate = data->progress.size_dl / data->progress.dlspeed;
+
+    if(data->progress.size_dl > CURL_OFF_T_C(10000))
+      dlpercen = data->progress.downloaded /
+        (data->progress.size_dl/CURL_OFF_T_C(100));
+    else if(data->progress.size_dl > CURL_OFF_T_C(0))
+      dlpercen = (data->progress.downloaded*100) /
+        data->progress.size_dl;
+  }
+
+  /* Now figure out which of them is slower and use that one for the
+     total estimate! */
+  total_estimate = ulestimate>dlestimate?ulestimate:dlestimate;
+
+  /* create the three time strings */
+  time2str(time_left, total_estimate > 0?(total_estimate - timespent):0);
+  time2str(time_total, total_estimate);
+  time2str(time_spent, timespent);
+
+  /* Get the total amount of data expected to get transferred */
+  total_expected_transfer =
+    ((data->progress.flags & PGRS_UL_SIZE_KNOWN)?
+     data->progress.size_ul:data->progress.uploaded)+
+    ((data->progress.flags & PGRS_DL_SIZE_KNOWN)?
+     data->progress.size_dl:data->progress.downloaded);
+
+  /* We have transferred this much so far */
+  total_transfer = data->progress.downloaded + data->progress.uploaded;
+
+  /* Get the percentage of data transferred so far */
+  if(total_expected_transfer > CURL_OFF_T_C(10000))
+    total_percen = total_transfer /
+      (total_expected_transfer/CURL_OFF_T_C(100));
+  else if(total_expected_transfer > CURL_OFF_T_C(0))
+    total_percen = (total_transfer*100) / total_expected_transfer;
+
+  fprintf(data->set.err,
+          "\r"
+          "%3" CURL_FORMAT_CURL_OFF_T " %s  "
+          "%3" CURL_FORMAT_CURL_OFF_T " %s  "
+          "%3" CURL_FORMAT_CURL_OFF_T " %s  %s  %s %s %s %s %s",
+          total_percen,  /* 3 letters */                /* total % */
+          max5data(total_expected_transfer, max5[2]),   /* total size */
+          dlpercen,      /* 3 letters */                /* rcvd % */
+          max5data(data->progress.downloaded, max5[0]), /* rcvd size */
+          ulpercen,      /* 3 letters */                /* xfer % */
+          max5data(data->progress.uploaded, max5[1]),   /* xfer size */
+          max5data(data->progress.dlspeed, max5[3]),    /* avrg dl speed */
+          max5data(data->progress.ulspeed, max5[4]),    /* avrg ul speed */
+          time_total,    /* 8 letters */                /* total time */
+          time_spent,    /* 8 letters */                /* time spent */
+          time_left,     /* 8 letters */                /* time left */
+          max5data(data->progress.current_speed, max5[5])
+    );
+
+  /* we flush the output stream to make it appear as soon as possible */
+  fflush(data->set.err);
+}
+#else
+ /* progress bar disabled */
+#define progress_meter(x) Curl_nop_stmt
+#endif
+
+
+/*
+ * Curl_pgrsUpdate() returns 0 for success or the value returned by the
+ * progress callback!
+ */
+int Curl_pgrsUpdate(struct connectdata *conn)
+{
+  struct Curl_easy *data = conn->data;
+  struct curltime now = Curl_now(); /* what time is it */
+  bool showprogress = progress_calc(conn, now);
   if(!(data->progress.flags & PGRS_HIDE)) {
     if(data->set.fxferinfo) {
       int result;
@@ -620,9 +620,9 @@ int Curl_pgrsUpdate(struct connectdata *conn)
       }
     }
 
-    if(showprogress) 
-      progress_meter(conn); 
-  } 
+    if(showprogress)
+      progress_meter(conn);
+  }
 
   return 0;
 }