/***************************************************************************** * _ _ ____ _ * Project ___| | | | _ \| | * / __| | | | |_) | | * | (__| |_| | _ <| |___ * \___|\___/|_| \_\_____| * * The contents of this file are subject to the Mozilla Public License * Version 1.0 (the "License"); you may not use this file except in * compliance with the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the * License for the specific language governing rights and limitations * under the License. * * The Original Code is Curl. * * The Initial Developer of the Original Code is Daniel Stenberg. * * Portions created by the Initial Developer are Copyright (C) 1998. * All Rights Reserved. * * ------------------------------------------------------------ * Main author: * - Daniel Stenberg * * http://curl.haxx.se * * $Source$ * $Revision$ * $Date$ * $Author$ * $State$ * $Locker$ * * ------------------------------------------------------------ ****************************************************************************/ #include #include "setup.h" #if defined(WIN32) && !defined(__GNUC__) || defined(__MINGW32__) #if defined(__MINGW32__) #include #endif #include #endif /* 20000318 mgs * later we use _scrsize to determine the screen width, this emx library * function needs stdlib.h to be included */ #if defined(__EMX__) #include #endif #include #include "urldata.h" #include "sendf.h" #include "progress.h" void time2str(char *r, int t) { int h = (t/3600); int m = (t-(h*3600))/60; int s = (t-(h*3600)-(m*60)); sprintf(r,"%2d:%02d:%02d",h,m,s); } /* The point of this function would be to return a string of the input data, but never longer than 5 columns. Add suffix k, M, G when suitable... */ char *max5data(double bytes, char *max5) { #define ONE_KILOBYTE 1024 #define ONE_MEGABYTE (1024*1024) if(bytes < 100000) { sprintf(max5, "%5d", (int)bytes); return max5; } if(bytes < (9999*ONE_KILOBYTE)) { sprintf(max5, "%4dk", (int)bytes/ONE_KILOBYTE); return max5; } if(bytes < (100*ONE_MEGABYTE)) { /* 'XX.XM' is good as long as we're less than 100 megs */ sprintf(max5, "%2.1fM", bytes/ONE_MEGABYTE); return max5; } sprintf(max5, "%4dM", (int)bytes/ONE_MEGABYTE); return max5; } /* New proposed interface, 9th of February 2000: pgrsStartNow() - sets start time pgrsSetDownloadSize(x) - known expected download size pgrsSetUploadSize(x) - known expected upload size pgrsSetDownloadCounter() - amount of data currently downloaded pgrsSetUploadCounter() - amount of data currently uploaded pgrsUpdate() - show progress pgrsDone() - transfer complete */ void pgrsDone(struct UrlData *data) { if(!(data->progress.flags & PGRS_HIDE)) { data->progress.lastshow=0; pgrsUpdate(data); /* the final (forced) update */ fprintf(stderr, "\n"); } } void pgrsTime(struct UrlData *data, timerid timer) { switch(timer) { default: case TIMER_NONE: /* mistake filter */ break; case TIMER_NAMELOOKUP: data->progress.t_nslookup = tvnow(); break; case TIMER_CONNECT: data->progress.t_connect = tvnow(); break; case TIMER_PRETRANSFER: data->progress.t_pretransfer = tvnow(); break; case TIMER_POSTRANSFER: /* this is the normal end-of-transfer thing */ break; } } void pgrsStartNow(struct UrlData *data) { data->progress.start = tvnow(); } void pgrsSetDownloadCounter(struct UrlData *data, double size) { data->progress.downloaded = size; } void pgrsSetUploadCounter(struct UrlData *data, double size) { data->progress.uploaded = size; } void pgrsSetDownloadSize(struct UrlData *data, double size) { if(size > 0) { data->progress.size_dl = size; data->progress.flags |= PGRS_DL_SIZE_KNOWN; } } void pgrsSetUploadSize(struct UrlData *data, double size) { if(size > 0) { data->progress.size_ul = size; data->progress.flags |= PGRS_UL_SIZE_KNOWN; } } /* EXAMPLE OUTPUT to follow: % Total % Received % Xferd Average Speed Time Curr. Dload Upload Total Current Left Speed 100 12345 100 12345 100 12345 12345 12345 12:12:12 12:12:12 12:12:12 12345 */ int pgrsUpdate(struct UrlData *data) { struct timeval now; int result; char max5[6][6]; double dlpercen=0; double ulpercen=0; double total_percen=0; double total_transfer; double total_expected_transfer; #define CURR_TIME 5 static double speeder[ CURR_TIME ]; static int speeder_c=0; int nowindex = speeder_c% CURR_TIME; int checkindex; int count; char time_left[10]; char time_total[10]; char time_current[10]; double ulestimate=0; double dlestimate=0; double total_estimate; if(data->progress.flags & PGRS_HIDE) ; /* We do enter this function even if we don't wanna see anything, since this is were lots of the calculations are being made that will be used even when not displayed! */ else if(!(data->progress.flags & PGRS_HEADERS_OUT)) { if (!data->progress.callback) { fprintf(data->err, " %% Total %% Received %% Xferd Average Speed Time Curr.\n" " Dload Upload Total Current Left Speed\n"); } data->progress.flags |= PGRS_HEADERS_OUT; /* headers are shown */ } now = tvnow(); /* what time is it */ if(data->progress.lastshow == tvlong(now)) return 0; /* never update this more than once a second if the end isn't reached */ data->progress.lastshow = now.tv_sec; /* The exact time spent so far */ data->progress.timespent = tvdiff (now, data->progress.start); /* The average download speed this far */ data->progress.dlspeed = data->progress.downloaded/(data->progress.timespent!=0.0?data->progress.timespent:1.0); /* The average upload speed this far */ data->progress.ulspeed = data->progress.uploaded/(data->progress.timespent!=0.0?data->progress.timespent:1.0); /* Let's do the "current speed" thing, which should use the fastest of the dl/ul speeds */ speeder[ nowindex ] = data->progress.downloaded>data->progress.uploaded? data->progress.downloaded:data->progress.uploaded; speeder_c++; /* increase */ count = ((speeder_c>=CURR_TIME)?CURR_TIME:speeder_c) - 1; checkindex = (speeder_c>=CURR_TIME)?speeder_c%CURR_TIME:0; /* find out the average speed the last CURR_TIME seconds */ data->progress.current_speed = (speeder[nowindex]-speeder[checkindex])/(count?count:1); if(data->progress.flags & PGRS_HIDE) return 0; else if(data->fprogress) { result= data->fprogress(data->progress_client, data->progress.size_dl, data->progress.downloaded, data->progress.size_ul, data->progress.uploaded); if(result) failf(data, "Callback aborted"); return result; } /* Figure out the estimated time of arrival for the upload */ if(data->progress.flags & PGRS_UL_SIZE_KNOWN) { if(!data->progress.ulspeed) data->progress.ulspeed=1; ulestimate = data->progress.size_ul / data->progress.ulspeed; ulpercen = (data->progress.uploaded / data->progress.size_ul)*100; } /* ... and the download */ if(data->progress.flags & PGRS_DL_SIZE_KNOWN) { if(!data->progress.dlspeed) data->progress.dlspeed=1; dlestimate = data->progress.size_dl / data->progress.dlspeed; dlpercen = (data->progress.downloaded / data->progress.size_dl)*100; } /* Now figure out which of them that is slower and use for the for total estimate! */ total_estimate = ulestimate>dlestimate?ulestimate:dlestimate; /* If we have a total estimate, we can display that and the expected time left */ if(total_estimate) { time2str(time_left, total_estimate-(int) data->progress.timespent); time2str(time_total, total_estimate); } else { /* otherwise we blank those times */ strcpy(time_left, "--:--:--"); strcpy(time_total, "--:--:--"); } /* The time spent so far is always known */ time2str(time_current, data->progress.timespent); /* Get the total amount of data expected to get transfered */ 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 transfered this much so far */ total_transfer = data->progress.downloaded + data->progress.uploaded; /* Get the percentage of data transfered so far */ if(total_expected_transfer) total_percen=(double)(total_transfer/total_expected_transfer)*100; fprintf(stderr, "\r%3d %s %3d %s %3d %s %s %s %s %s %s %s", (int)total_percen, /* total % */ max5data(total_expected_transfer, max5[2]), /* total size */ (int)dlpercen, /* rcvd % */ max5data(data->progress.downloaded, max5[0]), /* rcvd size */ (int)ulpercen, /* 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, /* total time */ time_current, /* current time */ time_left, /* time left */ max5data(data->progress.current_speed, max5[5]) /* current speed */ ); return 0; }