home *** CD-ROM | disk | FTP | other *** search
/ Big Green CD 8 / BGCD_8_Dev.iso / NEXTSTEP / UNIX / Networking / ncftp-2.4.2-MIHS / src / Progress.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-10-16  |  22.4 KB  |  840 lines
  1. /* Progress.c */
  2.  
  3. #include "Sys.h"
  4. #include "Curses.h"
  5.  
  6. #include "Util.h"
  7. #include "Cmds.h"
  8. #include "Xfer.h"
  9. #include "Progress.h"
  10. #include "GetPass.h"
  11. #include "Bookmark.h"
  12. #include "Main.h"
  13.  
  14. /* NOTE: There is more commentary at the bottom of this source file. */
  15.  
  16. /* The progress meter the user requested us to use.  We may not actually be
  17.  * able to use this one, if certain conditions are not met.
  18.  */
  19. int gWhichProgMeter = PROGRESS;
  20.  
  21. /* Before each report, this is set to the elapsed time between the
  22.  * starting and current time.
  23.  */
  24. struct timeval gElapsedTVal;
  25.                                         
  26. /* These are the different progress meter functions the user can
  27.  * choose from.  The order must correspond to the equates in progress.h!
  28.  */
  29. ProgressMeterProc gProgressMeterProcs[kPrLast + 1] = {
  30.     PrNone,
  31.     PrPercent,
  32.     PrPhilBar,
  33.     PrKBytes,
  34.     PrDots,
  35.     PrStatBar
  36. };
  37.  
  38. long gTotalXferHSeconds = 0L, gTotalXferKiloBytes = 0L;
  39.  
  40. #ifdef SIGTSTP
  41. static int gStoppedInProgressReport;
  42. #endif
  43.  
  44. extern int gVerbosity, gIsFromTTY, gScreenWidth;
  45. extern FILE *gLogFile;
  46. extern longstring gRemoteCWD;
  47. extern Bookmark gRmtInfo;
  48.  
  49. #ifdef USE_CURSES
  50. extern int gWinInit;
  51. extern WINDOW *gListWin;
  52. void WAttr(WINDOW *w, int attr, int on);
  53. #endif    /* USE_CURSES */
  54.  
  55. #ifdef SYSLOG
  56. extern UserInfo gUserInfo;
  57. extern string gActualHostName;
  58. #endif
  59.  
  60. /* Difftime(), only for timeval structures.  */
  61. void TimeValSubtract(struct timeval *tdiff, struct timeval *t1, struct timeval *t0)
  62. {
  63.     tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
  64.     tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
  65.     if (tdiff->tv_usec < 0) {
  66.         tdiff->tv_sec--;
  67.         tdiff->tv_usec += 1000000;
  68.     }
  69. }                                       /* TimeValSubtract */
  70.  
  71.  
  72.  
  73. /* Computes how fast the transfer went. */
  74. double TransferRate(
  75.     long bytes,
  76.     struct timeval *start,
  77.     struct timeval *end,
  78.     char **units,
  79.     double *elapsedSecs
  80. )
  81. {
  82.     struct timeval td;
  83.     double unitsPerSec;
  84.  
  85.     TimeValSubtract(&td, end, start);
  86.     *elapsedSecs = td.tv_sec + ((double) td.tv_usec / 1000000.0);
  87.     
  88.     unitsPerSec = 0.0;
  89.     *units = "Bytes/s";
  90.  
  91.     if (*elapsedSecs > 0.0) {
  92.         unitsPerSec = bytes / *elapsedSecs;
  93.         if (unitsPerSec > (1024.0 * 1024.0)) {
  94.             unitsPerSec /= (1024.0 * 1024.0);
  95.             *units = "MB/s";
  96.         } else if (unitsPerSec > 1024.0) {
  97.             unitsPerSec /= 1024.0;
  98.             *units = "kB/s";
  99.         }
  100.     }
  101.     
  102.     return (unitsPerSec);
  103. }    /* TransferRate */
  104.  
  105.  
  106.  
  107.  
  108. int PrNone(XferSpecPtr xp, int mode)
  109. {
  110.     xp->doReports = 0;
  111.     if (mode == kPrEndMsg && gIsFromTTY)
  112.         return kPrWantStatsMsg;
  113.     return 0;
  114. }    /* PrNone */
  115.  
  116.  
  117.  
  118.  
  119. /* This progress meter function displays the percentage of the file
  120.  * we've transferred so far;  it's simple and unobtrusive.
  121.  */
  122. int PrPercent(XferSpecPtr xp, int mode)
  123. {
  124.     int result = kPrWantStatsMsg;
  125.     int perc;
  126.     
  127.     switch (mode) {
  128.         case kPrInitMsg:
  129.             EPrintF("%s:     ", xp->localFileName);
  130.             break;
  131.         case kPrUpdateMsg:
  132.             perc = (int) (100 * xp->frac);
  133.             EPrintF("\b\b\b\b%3d%%", perc);
  134.             break;
  135.         case kPrEndMsg:
  136.             result = kPrWantStatsMsg;
  137.             EPrintF("\b\b\b\b");
  138.             break;
  139.     }
  140.     return result;
  141. }    /* PrPercent */
  142.  
  143.  
  144.  
  145.  
  146. /* This one is the brainchild of my comrade, Phil Dietz.  It shows the
  147.  * progress as a fancy bar graph.
  148.  */
  149. int PrPhilBar(XferSpecPtr xp, int mode)
  150. {
  151.     int result = kPrWantStatsMsg;
  152.     int perc;
  153.     long s;
  154.     int curBarLen;
  155.     static int maxBarLen;
  156.     str64 spec1, spec3;
  157.     static string bar;
  158.     int i;
  159.     int secsLeft, minLeft;
  160.  
  161.     switch (mode) {
  162.         case kPrInitMsg:
  163.             EPrintF("%s file: %s \n",
  164.                 NETREADING(xp) ? "Receiving" : "Sending",
  165.                 xp->localFileName
  166.             );
  167.             
  168.             for (i=0; i < (int) sizeof(bar) - 1; i++)
  169.                 bar[i] = '=';
  170.             bar[i] = '\0';
  171.  
  172.             /* Compute the size of the bar itself.  This sits between
  173.              * two numbers, one on each side of the screen.  So the
  174.              * bar length will vary, depending on how many digits we
  175.              * need to display the size of the file.
  176.              */
  177.             maxBarLen = gScreenWidth - 1 - 28;
  178.             for (s = xp->expectedSize; s > 0; s /= 10L)
  179.                 maxBarLen--;
  180.             
  181.             /* Create a specification we can hand to printf. */
  182.             (void) sprintf(spec1, "      0 %%%ds %%ld bytes. ETA: --:--",
  183.                 maxBarLen);
  184.                 
  185.             /* Print the first invocation, which is an empty graph
  186.              * plus the other stuff.
  187.              */
  188.             EPrintF(spec1, " ", xp->expectedSize);
  189.             break;
  190.         case kPrUpdateMsg:
  191.             /* Compute how much of the bar should be colored in. */
  192.             curBarLen = (int) (xp->frac * (double)maxBarLen);
  193.  
  194.             /* Colored portion must be at least one character so
  195.              * the spec isn't '%0s' which would screw the right side
  196.              * of the indicator.
  197.              */
  198.             if (curBarLen < 1)
  199.                 curBarLen = 1;
  200.             
  201.             bar[curBarLen - 1] = '>';
  202.             bar[curBarLen] = '\0';
  203.  
  204.             /* Make the spec, so we can print the bar and the other stuff. */
  205.             STRNCPY(spec1, "\r%3d%%  0 ");
  206.             (void) sprintf(spec3, "%%%ds %%ld bytes. %s%%3d:%%02d", 
  207.                 maxBarLen - curBarLen,
  208.                 "ETA:"
  209.             );
  210.             
  211.             /* We also show the percentage as a number at the left side. */
  212.             perc = (int) (100.0 * xp->frac);
  213.             
  214.             /* Guess how much time is remaining in the transfer, based on
  215.              * the current transfer statistics.
  216.              */
  217.             secsLeft = (int) ((xp->bytesLeft / xp->bytesPerSec) + 0.5);
  218.             minLeft = secsLeft / 60;
  219.             secsLeft = secsLeft - (minLeft * 60);
  220.             if (minLeft > 999) {
  221.                 minLeft = 999;
  222.                 secsLeft = 59;
  223.             }
  224.             
  225.             /* Print the updated information. */
  226. #ifdef USE_CURSES
  227.             if (gWinInit) {
  228.                 EPrintF(spec1, perc);    
  229.                 WAttr(gListWin, kReverse, 1);
  230.                 EPrintF("%s", bar);
  231.                 WAttr(gListWin, kReverse, 0);
  232.                 EPrintF(spec3,
  233.                     "",
  234.                     xp->expectedSize,
  235.                     minLeft,
  236.                     secsLeft
  237.                 );
  238.             } else
  239. #endif    /* USE_CURSES */
  240.             {
  241.                 EPrintF(spec1, perc);    
  242.                 EPrintF("%s", bar);
  243.                 EPrintF(spec3,
  244.                     "",
  245.                     xp->expectedSize,
  246.                     minLeft,
  247.                     secsLeft
  248.                 );
  249.             }
  250.  
  251.             bar[curBarLen - 1] = '=';
  252.             bar[curBarLen] = '=';
  253.  
  254.             break;
  255.         case kPrEndMsg:
  256.             result = kPrWantStatsMsg;
  257.             EPrintF("\n");
  258.             break;
  259.     }
  260.     return result;
  261. }    /* PrPhilBar */
  262.  
  263.  
  264.  
  265. static double
  266. FileSize(double size, char **uStr0, double *uMult0)
  267. {
  268.     double uMult, uTotal;
  269.     char *uStr;
  270.  
  271.     if (size > kGigabyte) {
  272.         uStr = "GB";
  273.         uMult = kGigabyte;
  274.     } else if (size > kMegabyte) {
  275.         uStr = "MB";
  276.         uMult = kMegabyte;
  277.     } else if (size > kKilobyte) {
  278.         uStr = "kB";
  279.         uMult = 1024;
  280.     } else {
  281.         uStr = "B";
  282.         uMult = 1;
  283.     }
  284.     if (uStr0 != NULL)
  285.         *uStr0 = uStr;
  286.     if (uMult0 != NULL)
  287.         *uMult0 = uMult;
  288.     uTotal = size / ((double) uMult);
  289.     return (uTotal);
  290. }    /* FileSize */
  291.  
  292.  
  293.  
  294.  
  295. int PrStatBar(XferSpecPtr xp, int mode)
  296. {
  297.     int result = kPrWantStatsMsg;
  298.     double rate, done;
  299.     int secLeft, minLeft;
  300.     char *rStr;
  301.     static char *uStr;
  302.     static double uTotal, uMult;
  303.     char localName[32];
  304.     string line;
  305.     int i;
  306.  
  307.     switch (mode) {
  308.         case kPrInitMsg:
  309.             uTotal = FileSize((double) xp->expectedSize, &uStr, &uMult);
  310.  
  311.             /* Leave room for a ':' and '\0'. */
  312.             AbbrevStr(localName, xp->localFileName, 30, 0);
  313.             STRNCAT(localName, ":");
  314.             EPrintF("%-32s", localName);
  315.             break;
  316.         case kPrUpdateMsg:
  317.             /* Guess how much time is remaining in the transfer, based on
  318.              * the current transfer statistics.
  319.              */
  320.             secLeft = (int) ((xp->bytesLeft / xp->bytesPerSec) + 0.5);
  321.             minLeft = secLeft / 60;
  322.             secLeft = secLeft - (minLeft * 60);
  323.             if (minLeft > 999) {
  324.                 minLeft = 999;
  325.                 secLeft = 59;
  326.             }
  327.  
  328.             rate = FileSize(xp->bytesPerSec, &rStr, NULL);
  329.             done = (double) xp->bytesTransferred / uMult;
  330.  
  331.             AbbrevStr(localName, xp->localFileName, sizeof(localName) - 2, 0);
  332.             STRNCAT(localName, ":");
  333.  
  334.             sprintf(line, "%-32s   %5.1f/%.1f %s   %5.1f %s/s   ETA %3d:%02d",
  335.                 localName,
  336.                 done,
  337.                 uTotal,
  338.                 uStr,
  339.                 rate,
  340.                 rStr,
  341.                 minLeft,
  342.                 secLeft
  343.             );
  344.  
  345.             /* Pad the rest of the line with spaces, to erase any
  346.              * stuff that might have been left over from the last
  347.              * update.
  348.              */
  349.             for (i=strlen(line); i < gScreenWidth - 2; i++)
  350.                 line[i] = ' ';
  351.             line[i] = '\0';
  352.  
  353.             /* Print the updated information. */
  354.             EPrintF("\r%s", line);
  355.  
  356.             break;
  357.         case kPrEndMsg:
  358.             result = kPrWantStatsMsg;
  359.             EPrintF("\r");
  360.             break;
  361.     }
  362.     return result;
  363. }    /* PrStatBar */
  364.  
  365.  
  366.  
  367.  
  368. /* This one is handy when we don't know the size of the file we're
  369.  * transferring, but we still want to have a progress meter.
  370.  */
  371. int PrKBytes(XferSpecPtr xp, int mode)
  372. {
  373.     int result = 0;
  374.  
  375.     switch (mode) {
  376.         case kPrInitMsg:
  377.             EPrintF("%s:       ", xp->localFileName);
  378.             break;
  379.         case kPrUpdateMsg:
  380.             EPrintF("\b\b\b\b\b\b%5ldK", (xp->bytesTransferred +
  381.                 xp->startPoint) / 1024);
  382.             break;
  383.         case kPrEndMsg:
  384.             result = kPrWantStatsMsg;
  385.             EPrintF("\b\b\b\b\b\b");
  386.             break;
  387.     }
  388.     return result;
  389. }    /* PrKBytes */
  390.  
  391.  
  392.  
  393.  
  394. /* This progress meter spews as little output as possible.  It uses
  395.  * no backspaces or ANSI escapes nor does it ask for transfer stats to
  396.  * be printed.
  397.  */
  398. int PrDots(XferSpecPtr xp, int mode)
  399. {
  400.     static int dotsPrinted;
  401.     int newDots;
  402.  
  403.     switch (mode) {
  404.         case kPrInitMsg:
  405.             dotsPrinted = 0;
  406.             EPrintF("%s: ", xp->localFileName);
  407.             break;
  408.         case kPrUpdateMsg:
  409.             if (xp->expectedSize <= 0)
  410.                 newDots = 10;
  411.             else
  412.                 newDots = (LOCALSIZE(xp) * 10 / xp->expectedSize) + 1;
  413.             while ((dotsPrinted < newDots) && (dotsPrinted < 10)) {
  414.                 EPrintF(".");
  415.                 dotsPrinted++;
  416.             }
  417.             break;
  418.         case kPrEndMsg:
  419.             for (; dotsPrinted < 10; dotsPrinted++)
  420.                 EPrintF(".");
  421.             EPrintF("\n");
  422.             break;
  423.     }
  424.     return 0;
  425. }    /* PrDots */
  426.  
  427.  
  428.  
  429.  
  430. /* This determines which progress meter we can use, and sends an
  431.  * init message to the progress meter function to be used.  Note
  432.  * that we may have to use an alternative progress meter if the
  433.  * one the user requested won't work under the current conditions (like
  434.  * not being able to get the remote file size would disable any
  435.  * prog meter that needs to know that).
  436.  *
  437.  * This routine takes care of turning off echoing to stdin and flushes
  438.  * the stderr stream, so individual progress meter functions need not
  439.  * worry about that.
  440.  */
  441. int StartProgress(XferSpecPtr xp)
  442. {
  443.     int progMeterInUse;
  444.  
  445.     /* If the user doesn't want any unnecessary output, or is in the
  446.      * background, don't have progress reports at all.  Also don't
  447.      * do reports if the xp said explicitly not to do.  For example,
  448.      * we don't want any reports for directory listings.
  449.      */
  450.     if ((gVerbosity == kQuiet) || (!xp->doReports) || (!InForeGround())) {
  451.         progMeterInUse = kPrNone;
  452.         xp->doReports = 0;
  453.     } else {
  454.         progMeterInUse =  gWhichProgMeter;
  455.         
  456.         /* If the progress meter number is out of range, use a default value. */
  457.         if ((progMeterInUse > kPrLast) || (progMeterInUse < 0))
  458.             progMeterInUse = PROGRESS;
  459.         
  460.         /* If we couldn't determine the size of the file in advance,
  461.          * we can't use any progress meter that needs to know the size.
  462.          */
  463.         if (xp->expectedSize == kSizeUnknown)
  464.             progMeterInUse = kPrKBytes;    /* Only one that doesn't need size. */
  465.     }
  466.  
  467.     /* Get a pointer to the progress meter function to use. */
  468.     xp->prProc = gProgressMeterProcs[progMeterInUse];
  469.  
  470.     /* Make a note of the start time, so we can see how long this takes. */
  471.     (void) Gettimeofday(&xp->startTime);
  472.     
  473.     /* Initialize the seconds counter to the current time.  We don't do
  474.      * a progress report after each block read.  Instead, we wait at least
  475.      * 'kDelaySeconds' seconds before attempting an update.  But this time
  476.      * we set it so we do an update after the very first block.
  477.      */
  478.     xp->timeOfNextUpdate = xp->startTime.tv_sec;
  479.     
  480.     /* This should have been zeroed automatically when you initialized
  481.      * the structure, but for completeness, do it ourselves here.
  482.      */
  483.     xp->bytesTransferred = 0;
  484.  
  485.     (*xp->prProc)(xp, kPrInitMsg);
  486.     
  487.     /* The progress report proc may decide for itself whether progress
  488.      * reports may be used, so don't do the following if progress
  489.      * reports got turned off at the initialization step.
  490.      */
  491.     if (xp->doReports) {
  492.         FlushListWindow();
  493.         Echo(stdin, 0);
  494.     }
  495.     
  496.     /* Just a nice way for us to quickly tell which one we're using,
  497.      * without looking at function pointers.
  498.      */
  499.     xp->progMeterInUse = progMeterInUse;
  500.     return (progMeterInUse);
  501. }                                       /* StartProgress */
  502.  
  503.  
  504.  
  505. #ifdef SIGTSTP
  506. static void ProgressSuspsend(int ignored)
  507. {
  508.     gStoppedInProgressReport = 1;
  509. }    /* ProgressSuspsend */
  510. #endif
  511.  
  512.  
  513.  
  514.  
  515. /* This should be called after each "block" in the transfer.  We check
  516.  * here to see if we should bother updating the progress meter.  We
  517.  * won't update if we had already updated within the last second or so.
  518.  */
  519. void ProgressReport(XferSpecPtr xp, int forceUpdate)
  520. {
  521.     double frac;
  522. #ifdef SIGTSTP
  523.     Sig_t sts;
  524. #endif
  525.  
  526.     if (xp->doReports) {
  527.         /* Check the current time. */
  528.         (void) Gettimeofday(&xp->endTime);
  529.         
  530.         /* Won't update unless it's past the 'timeOfNextUpdate'
  531.          * or we got a message saying to do your last update.
  532.          */
  533.         if ((xp->endTime.tv_sec > xp->timeOfNextUpdate) || forceUpdate) {
  534.             /* Won't do updates anymore if we get backgrounded. */
  535.             xp->doReports = InForeGround();
  536.             if (xp->doReports != 0) {
  537. #ifdef SIGTSTP
  538.                 /* The user could hit ^Z right when we are trying to do
  539.                  * a progress report.  This could mean that as soon as the
  540.                  * user put the program in the background, we would output
  541.                  * the progress report, which would suspend the process
  542.                  * because of tty output.
  543.                  *
  544.                  * We try to avoid that scenario by temporarily putting off
  545.                  * the ^Z, doing the progress report, then sending us the
  546.                  * suspend signal again.
  547.                  */
  548.                 sts = SIGNAL(SIGTSTP, SIG_IGN);
  549.                 if (sts != SIG_IGN) {
  550.                     gStoppedInProgressReport = 0;
  551.                     SIGNAL(SIGTSTP, ProgressSuspsend);
  552.                 }
  553. #endif
  554.                 /* Figure out how long the transfer has been going. */
  555.                 TimeValSubtract(&gElapsedTVal, &xp->endTime,
  556.                     &xp->startTime);
  557.                 
  558.                 /* Get current transfer duration. */
  559.                 xp->secsElap = (gElapsedTVal.tv_usec / 1000000.0)
  560.                     + gElapsedTVal.tv_sec;
  561.  
  562.                 /* Get current transfer rate. */
  563.                 if ((xp->secsElap <= 0.0) || (xp->bytesTransferred == 0)) {
  564.                     xp->bytesPerSec = 1.0;        /* Don't set to 0. */
  565.                 } else {
  566.                     xp->bytesPerSec = ((double) xp->bytesTransferred)
  567.                         / xp->secsElap;
  568.                 }
  569.  
  570.                 /* Compute how much we've done so far, if we can. */
  571.                 if (xp->expectedSize > 0) {
  572.                     xp->bytesLeft = xp->expectedSize - LOCALSIZE(xp);
  573.  
  574.                     frac = (double) LOCALSIZE(xp)
  575.                         / (double) xp->expectedSize;
  576.                     if (frac > 1.0)
  577.                         frac = 1.0;
  578.                     else if (frac < 0.0)
  579.                         frac = 0.0;
  580.                     xp->frac = frac;
  581.                 } else {
  582.                     xp->frac = 0.0;
  583.                 }
  584.                 
  585.                 /* Have this progress meter do its thing. */
  586.                 (*xp->prProc)(xp, kPrUpdateMsg);
  587.             
  588.                 FlushListWindow();
  589.                 /* Compute the next update time. */
  590.                 xp->timeOfNextUpdate = xp->endTime.tv_sec + kDelaySeconds - 1;
  591. #ifdef SIGTSTP
  592.                 if (sts != SIG_IGN) {
  593.                     SIGNAL(SIGTSTP, sts);
  594.                     if (gStoppedInProgressReport != 0)
  595.                         kill(getpid(), SIGTSTP);
  596.                 }
  597. #endif
  598.                 /* Figure out how long the transfer has been going. */
  599.             } else {
  600.                 return;
  601.             }
  602.         }
  603.         
  604.         /* Won't do reports if the user isn't logged in to see them. */
  605.         xp->doReports = UserLoggedIn();
  606.     }
  607. }                                       /* ProgressReport */
  608.  
  609.  
  610.  
  611.  
  612. /* This routine should be called after a transfer finishes, even if no
  613.  * progress reports were done.  Besides cleaning up the progress stuff,
  614.  * we also do our logging here.
  615.  */
  616. void EndProgress(XferSpecPtr xp)
  617. {
  618.     double elapsedTime, xRate, xferred;
  619.     char *unitStr;
  620.     char *shortName;
  621.     string statMsg;
  622.     longstring fullRemote;
  623.     long kb, hsecs;
  624.     int wantStats;
  625.     int localFileIsStdout;
  626.  
  627.     wantStats = 0;
  628.     if ((xp->doReports) && (xp->bytesTransferred > 0) && (gVerbosity != kQuiet)) {
  629.         ProgressReport(xp, kPrLastUpdateMsg);
  630.         wantStats = (InForeGround()) &&
  631.             ((*xp->prProc)(xp, kPrEndMsg) == kPrWantStatsMsg);
  632.     }
  633.     (void) Gettimeofday(&xp->endTime);
  634.  
  635.     /* Compute transfer stats. */
  636.     xRate = TransferRate(
  637.         xp->bytesTransferred,
  638.         &xp->startTime,
  639.         &xp->endTime,
  640.         &unitStr,
  641.         &elapsedTime
  642.     );
  643.  
  644.     /* Print the stats, if requested. */
  645.     if (wantStats) {
  646.         shortName = strrchr(xp->localFileName, '/');
  647.         if (shortName == NULL)
  648.             shortName = xp->localFileName;
  649.         else
  650.             shortName++;
  651.         sprintf(statMsg, "%s:  %ld bytes %s%s in %.2f seconds",
  652.             shortName,
  653.             xp->bytesTransferred,
  654.             NETREADING(xp) ? "received" : "sent",
  655.             xp->startPoint ? " and appended to existing file" : "",
  656.             elapsedTime
  657.         );
  658.         if (xRate > 0.0) {
  659.             sprintf(statMsg + strlen(statMsg), ", %.2f %s",
  660.                 xRate,
  661.                 unitStr
  662.             );
  663.         }
  664.         STRNCAT(statMsg, ".");
  665.     
  666.         /* Make sure echoing is back on! */
  667.         Echo(stdin, 1);
  668.  
  669.         /* Make sure the rest of the line is padded with spaces, so it will
  670.          * erase junk that may have been leftover from a progress meter.
  671.          */
  672.         EPrintF("%-79s\n", statMsg);
  673.         FlushListWindow();
  674.     } else {
  675.         if (xRate > 0.0) {
  676.             DebugMsg("%ld bytes transferred in %.2f seconds, %.2f %s.\n",
  677.                 xp->bytesTransferred,
  678.                 elapsedTime,
  679.                 xRate,
  680.                 unitStr
  681.             );
  682.         } else {
  683.             DebugMsg("%ld bytes transferred in %.2f seconds.\n",
  684.                 xp->bytesTransferred,
  685.                 elapsedTime
  686.             );
  687.         }
  688.     }
  689.  
  690.     /* Only log stuff if there was a remote filename specified.
  691.      * We don't want to log directory listings or globbings.
  692.      */
  693.     if ((xp->remoteFileName != NULL)) {
  694.         /* Get kilobytes transferred, rounding to the nearest kB. */
  695.         kb = ((long) xp->bytesTransferred + 512L) / 1024L;
  696.         OverflowAdd(&gTotalXferKiloBytes, kb);
  697.         OverflowAdd(&gRmtInfo.xferKbytes, kb);
  698.  
  699.         /* Get hundredths of seconds, rounded up to nearest. */
  700.         hsecs = (long) (100.0 * (elapsedTime + 0.0050));
  701.         OverflowAdd(&gTotalXferHSeconds, hsecs);
  702.         OverflowAdd(&gRmtInfo.xferHSeconds, hsecs);
  703.         if (gTotalXferHSeconds < 0)
  704.             gTotalXferHSeconds = 1L;
  705.         if (gRmtInfo.xferHSeconds <= 0)
  706.             gRmtInfo.xferHSeconds = 1L;
  707.  
  708.         localFileIsStdout =
  709.             (STREQ(xp->remoteFileName, kLocalFileIsStdout));
  710.         /* If a simple path is given, try to log the full path. */
  711.         if ((xp->remoteFileName[0] == '/') || (localFileIsStdout)) {
  712.             /* Use what we had in the xp. */
  713.             STRNCPY(fullRemote, xp->remoteFileName);
  714.         } else {
  715.             /* Make full path by appending what we had in the xp
  716.              * to the current remote directory.
  717.              */
  718.             STRNCPY(fullRemote, gRemoteCWD);
  719.             STRNCAT(fullRemote, "/");
  720.             STRNCAT(fullRemote, xp->remoteFileName);
  721.         }
  722.     
  723.         /* Save transfers to the user's logfile.  We only log something to
  724.          * the user log if we are actually saving a file;  we don't log
  725.          * to the user log if we are piping the remote output into something,
  726.          * or dumping it to stdout.
  727.          */
  728.         if ((gLogFile != NULL) && (!localFileIsStdout)) {
  729.             xferred = FileSize((double) xp->bytesTransferred, &unitStr, NULL);
  730.             (void) fprintf(gLogFile, "  %-3s  %6.2f %-2s  ftp://%s%s\n",
  731.                 NETREADING(xp) ? "get" : "put",
  732.                 xferred,
  733.                 unitStr,
  734.                 gRmtInfo.name,
  735.                 fullRemote
  736.             );
  737.             fflush(gLogFile);
  738.         }
  739.  
  740. #ifdef SYSLOG
  741.         {
  742.         longstring infoPart1;
  743.  
  744.         /* Some syslog()'s can't take an unlimited number of arguments,
  745.          * so shorten our call to syslog to 5 arguments total.
  746.          */
  747.         STRNCPY(infoPart1, gUserInfo.userName);
  748.         if (NETREADING(xp)) {
  749.             STRNCAT(infoPart1, " received ");
  750.             STRNCAT(infoPart1, fullRemote);    /* kLocalFileIsStdout is ok. */
  751.             STRNCAT(infoPart1, " as ");
  752.             STRNCAT(infoPart1, xp->localFileName);
  753.             STRNCAT(infoPart1, " from ");
  754.         } else {
  755.             STRNCAT(infoPart1, " sent ");
  756.             STRNCAT(infoPart1, xp->localFileName);
  757.             STRNCAT(infoPart1, " as ");
  758.             STRNCAT(infoPart1, fullRemote);
  759.             STRNCAT(infoPart1, " to ");
  760.         }
  761.         STRNCAT(infoPart1, gActualHostName);
  762. #ifndef LOG_INFO
  763. #    define LOG_INFO 6        /* Don't know if this is standard! */
  764. #endif
  765.         syslog (LOG_INFO, "%s (%ld bytes).", infoPart1, xp->bytesTransferred);
  766.         }
  767. #endif  /* SYSLOG */
  768.     }
  769. }                                       /* EndProgress */
  770.  
  771. /*****************************************************************************
  772.  
  773. How progress meters are used.
  774. -----------------------------
  775.  
  776. Just before the transfer is to be started, StartProgress is called.  This is
  777. called even if the 'doReports' field is set to 0 in the XferSpec. The reason
  778. for this is because this module also handles logging, both to the system log,
  779. and to the user's log.  We have to call both StartProgress and EndProgress to
  780. make sure logging is done correctly.
  781.  
  782. StartProgress figures out which progress meter to use.  The user may have
  783. decided on a favorite, but sometimes we may not be able to use the one
  784. requested.  The classic example is when we could not get the size of the file
  785. we're transferring in advance.  Things that use percentages or bar graphs
  786. won't work in that case.
  787.  
  788. If StartProgress found that progress reports will be used, it determines
  789. which progress meter function to use, and sends it a 'kPrInitMsg' so the
  790. function can do any necessary initialization.  The progress meter function
  791. doesn't have to print anything at this point.  Character echoing is turned
  792. off at this point, so any keys typed by the user won't mess up the progress
  793. function's hard work.
  794.  
  795. During the transfer, which is taken care of in Xfer.c, we call
  796. ProgressReport.  We only bother doing this if progress reports are really on,
  797. since none of the logging stuff is done at this time.
  798.  
  799. ProgressReport does a few quick checks to see if it should call the progress
  800. meter.  Because reporting could waste too much time, we don't want to do it
  801. too often.  Instead we wait a few seconds between each actual screen update.
  802.  
  803. ProgressReport also does a few checks to see if reporting should be turned
  804. off.  We don't want any more reports if we've been put into the background,
  805. since as soon as we printed something, the job would stop, because of pending
  806. tty output.  We also don't want any more reports if the user logged out.
  807.  
  808. ProgressReport then sends a 'kPrUpdateMsg' to the progress function, which
  809. then does the screen update.
  810.  
  811. After the transfer finishes, we call EndReport.  The first thing it does, if
  812. reports are still on, is to force one last screen update.  This is needed,
  813. for example, by the bar graph meter so the bar will be completely filled.
  814.  
  815. EndReport then sends the progress function a 'kPrEndMsg' so the function can
  816. do any necessary cleanup.  After turning character echoing back on, the stats
  817. are printed if they were requested, and then the logs are updated.
  818.  
  819. Adding your own progress meters.
  820. --------------------------------
  821.  
  822. You need to create a function that answers to the 'kPrInitMsg,' 'kPrUpdateMsg,'
  823. and 'kPrEndMsg' messages.  You'll be given as parameters the XferSpecPtr in
  824. use, and a 'mode' that indicates which of the messages you received.  Have
  825. the function return 0, or kPrWantStatsMsg.
  826.  
  827. You'll need to have a look at StartProgress and see if your function has any
  828. special requirements.  You'll need to edit Progress.h and make a #define for
  829. your function.  Don't forget to change kPrLast, and add a function prototype
  830. in the header too.  Lastly, add an entry to 'gProgressMeterProcs' with your
  831. function corresponding to whatever value you #defined in the header.
  832.  
  833. In order for your progress meter to be recognized by the Preferences screen,
  834. edit Prefs.c and add the name of your meter in the "case kProgressPrefsWinItem:"
  835. portion of GetPrefSetting().
  836.  
  837. *****************************************************************************/
  838.  
  839. /* eof Progress.c */
  840.