io.c

Go to the documentation of this file.

/* io.c
 *
 * Copyright (c) 1996-2001 Mike Gleason, NCEMRSoft.
 * All rights reserved.
 *
 */

#include "syshdrs.h"

static int gGotBrokenData = 0;

#if defined(WIN32) || defined(_WINDOWS)
#   define ASCII_TRANSLATION 0
#endif

#ifndef ASCII_TRANSLATION
#   define ASCII_TRANSLATION 1
#endif

#if !defined(NO_SIGNALS) && (USE_SIO || !defined(SIGALRM) || !defined(SIGPIPE) || !defined(SIGINT))
#   define NO_SIGNALS 1
#endif

#ifndef NO_SIGNALS

#ifdef HAVE_SIGSETJMP
static sigjmp_buf gBrokenDataJmp;
#else
static jmp_buf gBrokenDataJmp;
#endif  /* HAVE_SIGSETJMP */
static int gCanBrokenDataJmp = 0;

#endif  /* NO_SIGNALS */


#ifndef O_BINARY
    /* Needed for platforms using different EOLN sequence (i.e. DOS) */
#   ifdef _O_BINARY
#       define O_BINARY _O_BINARY
#   else
#       define O_BINARY 0
#   endif
#endif

static int WaitForRemoteInput(const FTPCIPtr cip);
static int WaitForRemoteOutput(const FTPCIPtr cip);


#ifndef NO_SIGNALS

static void
BrokenData(int signum)
{
    gGotBrokenData = signum;
    if (gCanBrokenDataJmp != 0) {
        gCanBrokenDataJmp = 0;
#ifdef HAVE_SIGSETJMP
        siglongjmp(gBrokenDataJmp, 1);
#else
        longjmp(gBrokenDataJmp, 1);
#endif  /* HAVE_SIGSETJMP */
    }
}   /* BrokenData */

#endif  /* NO_SIGNALS */




void
FTPInitIOTimer(const FTPCIPtr cip)
{
    cip->bytesTransferred = (longest_int) 0;
    cip->expectedSize = kSizeUnknown;
    cip->mdtm = kModTimeUnknown;
    cip->rname = NULL;
    cip->lname = NULL;
    cip->kBytesPerSec = -1.0;
    cip->percentCompleted = -1.0;
    cip->sec = -1.0;
    cip->secLeft = -1.0;
    cip->nextProgressUpdate = 0;
    cip->stalled = 0;
    cip->dataTimedOut = 0;
    cip->useProgressMeter = 1;
    (void) gettimeofday(&cip->t0, NULL);
}   /* FTPInitIOTimer */




void
FTPStartIOTimer(const FTPCIPtr cip)
{
    (void) gettimeofday(&cip->t0, NULL);
    if (cip->progress != (FTPProgressMeterProc) 0)
        (*cip->progress)(cip, kPrInitMsg);
}   /* FTPStartIOTimer */




void
FTPUpdateIOTimer(const FTPCIPtr cip)
{
    double sec;
    struct timeval *t0, t1;
    time_t now;

    (void) time(&now);
    if (now < cip->nextProgressUpdate)
        return;
    now += 1;
    cip->nextProgressUpdate = now;

    (void) gettimeofday(&t1, NULL);
    t0 = &cip->t0;

    if (t0->tv_usec > t1.tv_usec) {
        t1.tv_usec += 1000000;
        t1.tv_sec--;
    }
    sec = ((double) (t1.tv_usec - t0->tv_usec) * 0.000001)
        + (t1.tv_sec - t0->tv_sec);
    if (sec > 0.0) {
        cip->kBytesPerSec = ((double) cip->bytesTransferred) / (1024.0 * sec);
    } else {
        cip->kBytesPerSec = -1.0;
    }
    if (cip->expectedSize == kSizeUnknown) {
        cip->percentCompleted = -1.0;
        cip->secLeft = -1.0;
    } else if (cip->expectedSize <= 0) {
        cip->percentCompleted = 100.0;
        cip->secLeft = 0.0;
    } else {
        cip->percentCompleted = ((double) (100.0 * (cip->bytesTransferred + cip->startPoint))) / ((double) cip->expectedSize);
        if (cip->percentCompleted >= 100.0) {
            cip->percentCompleted = 100.0;
            cip->secLeft = 0.0;
        } else if (cip->percentCompleted <= 0.0) {
            cip->secLeft = 999.0;
        }
        if (cip->kBytesPerSec > 0.0) {
            cip->secLeft = ((cip->expectedSize - cip->bytesTransferred - cip->startPoint) / 1024.0) / cip->kBytesPerSec;
            if (cip->secLeft < 0.0)
                cip->secLeft = 0.0;
        }
    }
    cip->sec = sec;
    if ((cip->progress != (FTPProgressMeterProc) 0) && (cip->useProgressMeter != 0))
        (*cip->progress)(cip, kPrUpdateMsg);
}   /* FTPUpdateIOTimer */




void
FTPStopIOTimer(const FTPCIPtr cip)
{
    cip->nextProgressUpdate = 0;    /* force last update */
    FTPUpdateIOTimer(cip);
    if (cip->progress != (FTPProgressMeterProc) 0)
        (*cip->progress)(cip, kPrEndMsg);
}   /* FTPStopIOTimer */




/* This isn't too useful -- it mostly serves as an example so you can write
 * your own function to do what you need to do with the listing.
 */
int
FTPList(const FTPCIPtr cip, const int outfd, const int longMode, const char *const lsflag)
{
    const char *cmd;
    char line[512];
    char secondaryBuf[768];
#ifndef NO_SIGNALS
    char *secBufPtr, *secBufLimit;
    int nread;
    volatile int result;
#else   /* NO_SIGNALS */
    SReadlineInfo lsSrl;
    int result;
#endif  /* NO_SIGNALS */

    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);

    cmd = (longMode != 0) ? "LIST" : "NLST";
    if ((lsflag == NULL) || (lsflag[0] == '\0')) {
        result = FTPStartDataCmd(cip, kNetReading, kTypeAscii, (longest_int) 0, "%s", cmd);
    } else {
        result = FTPStartDataCmd(cip, kNetReading, kTypeAscii, (longest_int) 0, "%s %s", cmd, lsflag);
    }


#ifdef NO_SIGNALS

    if (result == 0) {
        if (InitSReadlineInfo(&lsSrl, cip->dataSocket, secondaryBuf, sizeof(secondaryBuf), (int) cip->xferTimeout, 1) < 0) {
            /* Not really fdopen, but close in what we're trying to do. */
            result = kErrFdopenR;
            cip->errNo = kErrFdopenR;
            Error(cip, kDoPerror, "Could not fdopen.\n");
            return (result);
        }

        for (;;) {
            result = SReadline(&lsSrl, line, sizeof(line) - 2);
            if (result == kTimeoutErr) {
                /* timeout */
                Error(cip, kDontPerror, "Could not directory listing data -- timed out.\n");
                cip->errNo = kErrDataTimedOut;
                return (cip->errNo);
            } else if (result == 0) {
                /* end of listing -- done */
                cip->numListings++;
                break;
            } else if (result < 0) {
                /* error */
                Error(cip, kDoPerror, "Could not read directory listing data");
                result = kErrLISTFailed;
                cip->errNo = kErrLISTFailed;
                break;
            }

            (void) write(outfd, line, strlen(line));
        }

        DisposeSReadlineInfo(&lsSrl);
        if (FTPEndDataCmd(cip, 1) < 0) {
            result = kErrLISTFailed;
            cip->errNo = kErrLISTFailed;
        }
    } else if (result == kErrGeneric) {
        result = kErrLISTFailed;
        cip->errNo = kErrLISTFailed;
    }


#else   /* NO_SIGNALS */

    if (result == 0) {
        /* This line sets the buffer pointer so that the first thing
         * BufferGets will do is reset and fill the buffer using
         * real I/O.
         */
        secBufPtr = secondaryBuf + sizeof(secondaryBuf);
        secBufLimit = (char *) 0;

        for (;;) {
            if (cip->xferTimeout > 0)
                (void) alarm(cip->xferTimeout);
            nread = BufferGets(line, sizeof(line), cip->dataSocket, secondaryBuf, &secBufPtr, &secBufLimit, sizeof(secondaryBuf));
            if (nread <= 0) {
                if (nread < 0)
                    break;
            } else {
                cip->bytesTransferred += (longest_int) nread;
                (void) STRNCAT(line, "\n");
                (void) write(outfd, line, strlen(line));
            }
        }
        if (cip->xferTimeout > 0)
            (void) alarm(0);
        result = FTPEndDataCmd(cip, 1);
        if (result < 0) {
            result = kErrLISTFailed;
            cip->errNo = kErrLISTFailed;
        }
        result = kNoErr;
        cip->numListings++;
    } else if (result == kErrGeneric) {
        result = kErrLISTFailed;
        cip->errNo = kErrLISTFailed;
    }
#endif  /* NO_SIGNALS */
    return (result);
}   /* FTPList */




static void
FTPRequestMlsOptions(const FTPCIPtr cip)
{
    int f;
    char optstr[128];
    size_t optstrlen;

    if (cip->usedMLS == 0) {
        /* First MLSD/MLST ? */
        cip->usedMLS = 1;

        f = cip->mlsFeatures & kPreferredMlsOpts;
        optstr[0] = '\0';

        /* TYPE */
        if ((f & kMlsOptType) != 0) {
            STRNCAT(optstr, "type;");
        }

        /* SIZE */
        if ((f & kMlsOptSize) != 0) {
            STRNCAT(optstr, "size;");
        }

        /* MODTIME */
        if ((f & kMlsOptModify) != 0) {
            STRNCAT(optstr, "modify;");
        }

        /* MODE */
        if ((f & kMlsOptUNIXmode) != 0) {
            STRNCAT(optstr, "UNIX.mode;");
        }

        /* PERM */
        if ((f & kMlsOptPerm) != 0) {
            STRNCAT(optstr, "perm;");
        }

        /* OWNER */
        if ((f & kMlsOptUNIXowner) != 0) {
            STRNCAT(optstr, "UNIX.owner;");
        }

        /* UID */
        if ((f & kMlsOptUNIXuid) != 0) {
            STRNCAT(optstr, "UNIX.uid;");
        }

        /* GROUP */
        if ((f & kMlsOptUNIXgroup) != 0) {
            STRNCAT(optstr, "UNIX.group;");
        }

        /* GID */
        if ((f & kMlsOptUNIXgid) != 0) {
            STRNCAT(optstr, "UNIX.gid;");
        }

        /* UNIQUE */
        if ((f & kMlsOptUnique) != 0) {
            STRNCAT(optstr, "unique;");
        }

        /* Tell the server what we prefer. */
        optstrlen = strlen(optstr);
        if (optstrlen > 0) {
            if (optstr[optstrlen - 1] == ';')
                optstr[optstrlen - 1] = '\0';
            (void) FTPCmd(cip, "OPTS MLST %s", optstr);
        }
    }
}   /* FTPRequestMlsOptions */




int
FTPListToMemory2(const FTPCIPtr cip, const char *const pattern, const LineListPtr llines, const char *const lsflags, const int blankLines, int *const tryMLSD)
{
    char secondaryBuf[768];
    char line[512];
    char lsflags1[128];
    const char *command = "NLST";
    const char *scp;
    char *dcp, *lim;
#ifndef NO_SIGNALS
    char *secBufPtr, *secBufLimit;
    volatile FTPSigProc osigpipe;
    volatile FTPCIPtr vcip;
    int sj;
    int nread;
    volatile int result;
#else   /* NO_SIGNALS */
    SReadlineInfo lsSrl;
    int result;
#endif  /* NO_SIGNALS */

    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);

    if ((llines == NULL) || (pattern == NULL) || (lsflags == NULL))
        return (kErrBadParameter);

    if ((tryMLSD != (int *) 0) && (*tryMLSD != 0) && (cip->hasMLSD == kCommandAvailable)) {
        command = "MLSD";
        if ((lsflags[0] == '-') && (strchr(lsflags, 'd') != NULL) && (cip->hasMLST == kCommandAvailable))
            command = "MLST";
        lsflags1[0] = '\0';
        FTPRequestMlsOptions(cip);
    } else {
        /* Not using MLSD. */
        if (tryMLSD != (int *) 0)
            *tryMLSD = 0;
        if (lsflags[0] == '-') {
            /* See if we should use LIST instead. */
            scp = lsflags + 1;
            dcp = lsflags1;
            lim = lsflags1 + sizeof(lsflags1) - 2;
            for (; *scp != '\0'; scp++) {
                if (*scp == 'l') {
                    /* do not add the 'l' */
                    command = "LIST";
                } else if (dcp < lim) {
                    if (dcp == lsflags1)
                        *dcp++ = '-';
                    *dcp++ = *scp;
                }
            }
            *dcp = '\0';
        } else {
            (void) STRNCPY(lsflags1, lsflags);
        }
    }

    InitLineList(llines);

    result = FTPStartDataCmd(
        cip,
        kNetReading,
        kTypeAscii,
        (longest_int) 0,
        "%s%s%s%s%s",
        command,
        (lsflags1[0] == '\0') ? "" : " ",
        lsflags1,
        (pattern[0] == '\0') ? "" : " ",
        pattern
    );

#ifdef NO_SIGNALS

    if (result == 0) {
        if (InitSReadlineInfo(&lsSrl, cip->dataSocket, secondaryBuf, sizeof(secondaryBuf), (int) cip->xferTimeout, 1) < 0) {
            /* Not really fdopen, but close in what we're trying to do. */
            result = kErrFdopenR;
            cip->errNo = kErrFdopenR;
            Error(cip, kDoPerror, "Could not fdopen.\n");
            return (result);
        }

        for (;;) {
            result = SReadline(&lsSrl, line, sizeof(line) - 1);
            if (result == kTimeoutErr) {
                /* timeout */
                Error(cip, kDontPerror, "Could not directory listing data -- timed out.\n");
                cip->errNo = kErrDataTimedOut;
                return (cip->errNo);
            } else if (result == 0) {
                /* end of listing -- done */
                cip->numListings++;
                break;
            } else if (result < 0) {
                /* error */
                Error(cip, kDoPerror, "Could not read directory listing data");
                result = kErrLISTFailed;
                cip->errNo = kErrLISTFailed;
                break;
            }

            if (line[result - 1] == '\n')
                line[result - 1] = '\0';

            if ((blankLines == 0) && (result <= 1))
                continue;

            /* Valid directory listing line of output */
            if ((line[0] == '.') && ((line[1] == '\0') || ((line[1] == '.') && ((line[2] == '\0') || (iscntrl(line[2]))))))
                continue;   /* Skip . and .. */

            (void) AddLine(llines, line);
        }

        DisposeSReadlineInfo(&lsSrl);
        if (FTPEndDataCmd(cip, 1) < 0) {
            result = kErrLISTFailed;
            cip->errNo = kErrLISTFailed;
        }
    } else if (result == kErrGeneric) {
        result = kErrLISTFailed;
        cip->errNo = kErrLISTFailed;
    }


#else   /* NO_SIGNALS */
    vcip = cip;
    osigpipe = (volatile FTPSigProc) signal(SIGPIPE, BrokenData);

    gGotBrokenData = 0;
    gCanBrokenDataJmp = 0;

#ifdef HAVE_SIGSETJMP
    sj = sigsetjmp(gBrokenDataJmp, 1);
#else
    sj = setjmp(gBrokenDataJmp);
#endif  /* HAVE_SIGSETJMP */

    if (sj != 0) {
        (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
        FTPShutdownHost(vcip);
        vcip->errNo = kErrRemoteHostClosedConnection;
        return(vcip->errNo);
    }
    gCanBrokenDataJmp = 1;

    if (result == 0) {
        /* This line sets the buffer pointer so that the first thing
         * BufferGets will do is reset and fill the buffer using
         * real I/O.
         */
        secBufPtr = secondaryBuf + sizeof(secondaryBuf);
        secBufLimit = (char *) 0;
        memset(secondaryBuf, 0, sizeof(secondaryBuf));

        for (;;) {
            memset(line, 0, sizeof(line));
            if (cip->xferTimeout > 0)
                (void) alarm(cip->xferTimeout);
            nread = BufferGets(line, sizeof(line), cip->dataSocket, secondaryBuf, &secBufPtr, &secBufLimit, sizeof(secondaryBuf));
            if (nread <= 0) {
                if (nread < 0)
                    break;
                if (blankLines != 0)
                    (void) AddLine(llines, line);
            } else {
                cip->bytesTransferred += (longest_int) nread;

                if ((line[0] == '.') && ((line[1] == '\0') || ((line[1] == '.') && ((line[2] == '\0') || (iscntrl(line[2]))))))
                    continue;   /* Skip . and .. */

                (void) AddLine(llines, line);
            }
        }
        if (cip->xferTimeout > 0)
            (void) alarm(0);
        result = FTPEndDataCmd(cip, 1);
        if (result < 0) {
            result = kErrLISTFailed;
            cip->errNo = kErrLISTFailed;
        }
        result = kNoErr;
        cip->numListings++;
    } else if (result == kErrGeneric) {
        result = kErrLISTFailed;
        cip->errNo = kErrLISTFailed;
    }
    (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
#endif  /* NO_SIGNALS */
    return (result);
}   /* FTPListToMemory2 */




static void
AutomaticallyUseASCIIModeDependingOnExtension(const FTPCIPtr cip, const char *const pathName, int *const xtype)
{
    if ((*xtype == kTypeBinary) && (cip->asciiFilenameExtensions != NULL)) {
        if (FilenameExtensionIndicatesASCII(pathName, cip->asciiFilenameExtensions)) {
            /* Matched -- send this file in ASCII mode
             * instead of binary since it's extension
             * appears to be that of a text file.
             */
            *xtype = kTypeAscii;
        }
    }
}   /* AutomaticallyUseASCIIModeDependingOnExtension */




/* The purpose of this is to provide updates for the progress meters
 * during lags.  Return zero if the operation timed-out.
 */
static int
WaitForRemoteOutput(const FTPCIPtr cip)
{
    fd_set ss, ss2;
    struct timeval tv;
    int result;
    int fd;
    int wsecs;
    int xferTimeout;
    int ocancelXfer;

    xferTimeout = cip->xferTimeout;
    if (xferTimeout < 1)
        return (1);

    fd = cip->dataSocket;
    if (fd < 0)
        return (1);

    ocancelXfer = cip->cancelXfer;
    wsecs = 0;
    cip->stalled = 0;

    while ((xferTimeout <= 0) || (wsecs < xferTimeout)) {
        if ((cip->cancelXfer != 0) && (ocancelXfer == 0)) {
            /* leave cip->stalled -- could have been stalled and then canceled. */
            return (1);
        }
        FD_ZERO(&ss);
        FD_SET(fd, &ss);
        ss2 = ss;
        tv.tv_sec = 1;
        tv.tv_usec = 0;
        result = select(fd + 1, NULL, SELECT_TYPE_ARG234 &ss, SELECT_TYPE_ARG234 &ss2, &tv);
        if (result == 1) {
            /* ready */
            cip->stalled = 0;
            return (1);
        } else if (result < 0) {
            if (errno != EINTR) {
                perror("select");
                cip->stalled = 0;
                return (1);
            }
        } else {
            wsecs++;
            cip->stalled = wsecs;
        }
        FTPUpdateIOTimer(cip);
    }

#if !defined(NO_SIGNALS)
    /* Shouldn't get here -- alarm() should have
     * went off by now.
     */
    (void) kill(getpid(), SIGALRM);
#endif  /* NO_SIGNALS */

    cip->dataTimedOut = 1;
    return (0); /* timed-out */
}   /* WaitForRemoteOutput */




static int
FTPPutOneF(
    const FTPCIPtr cip,
    const char *const file,
    const char *volatile dstfile,
    int xtype,
    const int fdtouse,
    const int appendflag,
    const char *volatile tmppfx,
    const char *volatile tmpsfx,
    const int resumeflag,
    const int deleteflag,
    const ConfirmResumeUploadProc resumeProc)
{
    char *buf, *cp;
    const char *cmd;
    const char *odstfile;
    size_t bufSize;
    size_t l;
    int tmpResult, result;
    int nread, nwrote;
    volatile int fd;
    char dstfile2[512];
#if ASCII_TRANSLATION
    char *src, *srclim, *dst;
    int ntowrite;
    char inbuf[256];
#endif
    int fstatrc, statrc;
    longest_int startPoint = 0;
    struct Stat st;
    time_t mdtm;
#if !defined(NO_SIGNALS)
    int sj;
    volatile FTPSigProc osigpipe;
    volatile FTPCIPtr vcip;
    volatile int vfd, vfdtouse;
#endif  /* NO_SIGNALS */
    volatile int vzaction;
    int zaction = kConfirmResumeProcSaidBestGuess;

    if (cip->buf == NULL) {
        Error(cip, kDoPerror, "Transfer buffer not allocated.\n");
        cip->errNo = kErrNoBuf;
        return (cip->errNo);
    }

    cip->usingTAR = 0;
    if (fdtouse < 0) {
        fd = Open(file, O_RDONLY|O_BINARY, 0);
        if (fd < 0) {
            Error(cip, kDoPerror, "Cannot open local file %s for reading.\n", file);
            cip->errNo = kErrOpenFailed;
            return (cip->errNo);
        }
    } else {
        fd = fdtouse;
    }

    fstatrc = Fstat(fd, &st);
    if ((fstatrc == 0) && (S_ISDIR(st.st_mode))) {
        if (fdtouse < 0) {
            (void) close(fd);
        }
        Error(cip, kDontPerror, "%s is a directory.\n", (file != NULL) ? file : "that");
        cip->errNo = kErrOpenFailed;
        return (cip->errNo);
    }

    /* For Put, we can't recover very well if it turns out restart
     * didn't work, so check beforehand.
     */
    if (cip->hasREST == kCommandAvailabilityUnknown) {
        (void) FTPSetTransferType(cip, kTypeBinary);
        if (SetStartOffset(cip, (longest_int) 1) == kNoErr) {
            /* Now revert -- we still may not end up
             * doing it.
             */
            SetStartOffset(cip, (longest_int) -1);
        }
    }

    if (fdtouse < 0) {
        AutomaticallyUseASCIIModeDependingOnExtension(cip, dstfile, &xtype);
        (void) FTPFileSizeAndModificationTime(cip, dstfile, &startPoint, xtype, &mdtm);

        if (appendflag == kAppendYes) {
            zaction = kConfirmResumeProcSaidAppend;
        } else if (
                (cip->hasREST == kCommandNotAvailable) ||
                (xtype != kTypeBinary) ||
                (fstatrc < 0)
        ) {
            zaction = kConfirmResumeProcSaidOverwrite;
        } else if (resumeflag == kResumeYes) {
            zaction = kConfirmResumeProcSaidBestGuess;
        } else {
            zaction = kConfirmResumeProcSaidOverwrite;
        }

        statrc = -1;
        if ((mdtm != kModTimeUnknown) || (startPoint != kSizeUnknown)) {
            /* Then we know the file exists.  We will
             * ask the user what to do, if possible, below.
             */
            statrc = 0;
        } else if ((resumeProc != NoConfirmResumeUploadProc) && (cip->hasMDTM != kCommandAvailable) && (cip->hasSIZE != kCommandAvailable)) {
            /* We already checked if the file had a filesize
             * or timestamp above, but if the server indicated
             * it did not support querying those directly,
             * we now need to try to determine if the file
             * exists in a few other ways.
             */
            statrc = FTPFileExists2(cip, dstfile, 0, 0, 0, 1, 1);
        }

        if (
            (resumeProc != NoConfirmResumeUploadProc) &&
            (statrc == 0)
        ) {
            zaction = (*resumeProc)(file, (longest_int) st.st_size, st.st_mtime, &dstfile, startPoint, mdtm, &startPoint);
        }

        if (zaction == kConfirmResumeProcSaidCancel) {
            /* User wants to cancel this file and any
             * remaining in batch.
             */
            cip->errNo = kErrUserCanceled;
            return (cip->errNo);
        }

        if (zaction == kConfirmResumeProcSaidBestGuess) {
            if ((mdtm != kModTimeUnknown) && (st.st_mtime > (mdtm + 1))) {
                /* Local file is newer than remote,
                 * overwrite the remote file instead
                 * of trying to resume it.
                 *
                 * Note:  Add one second fudge factor
                 * for Windows' file timestamps being
                 * imprecise to one second.
                 */
                zaction = kConfirmResumeProcSaidOverwrite;
            } else if ((longest_int) st.st_size == startPoint) {
                /* Already sent file, done. */
                zaction = kConfirmResumeProcSaidSkip;
            } else if ((startPoint != kSizeUnknown) && ((longest_int) st.st_size > startPoint)) {
                zaction = kConfirmResumeProcSaidResume;
            } else {
                zaction = kConfirmResumeProcSaidOverwrite;
            }
        }

        if (zaction == kConfirmResumeProcSaidSkip) {
            /* Nothing done, but not an error. */
            if (fdtouse < 0) {
                (void) close(fd);
            }
            if (deleteflag == kDeleteYes) {
                if (unlink(file) < 0) {
                    cip->errNo = kErrLocalDeleteFailed;
                    return (cip->errNo);
                }
            }
            return (kNoErr);
        } else if (zaction == kConfirmResumeProcSaidResume) {
            /* Resume; proc set the startPoint. */
            if ((longest_int) st.st_size == startPoint) {
                /* Already sent file, done. */
                if (fdtouse < 0) {
                    (void) close(fd);
                }

                if (deleteflag == kDeleteYes) {
                    if (unlink(file) < 0) {
                        cip->errNo = kErrLocalDeleteFailed;
                        return (cip->errNo);
                    }
                }
                return (kNoErr);
            } else if (Lseek(fd, (off_t) startPoint, SEEK_SET) != (off_t) -1) {
                cip->startPoint = startPoint;
            }
        } else if (zaction == kConfirmResumeProcSaidAppend) {
            /* append: leave startPoint at zero, we will append everything. */
            cip->startPoint = startPoint = 0;
        } else /* if (zaction == kConfirmResumeProcSaidOverwrite) */ {
            /* overwrite: leave startPoint at zero */
            cip->startPoint = startPoint = 0;
        }
    }

    if ((cip->numUploads == 0) && (cip->dataSocketSBufSize > 0)) {
        /* If dataSocketSBufSize is non-zero, it means you
         * want to explicitly try to set the size of the
         * socket's I/O buffer.
         *
         * If it is zero, it means you want to just use the
         * TCP stack's default value, which is typically
         * between 8 and 64 kB.
         *
         * If you try to set the buffer larger than 64 kB,
         * the TCP stack should try to use RFC 1323 to
         * negotiate "TCP Large Windows" which may yield
         * significant performance gains.
         */
        if (cip->hasSTORBUFSIZE == kCommandAvailable)
            (void) FTPCmd(cip, "SITE STORBUFSIZE %lu", (unsigned long) cip->dataSocketSBufSize);
        else if (cip->hasSBUFSIZ == kCommandAvailable)
            (void) FTPCmd(cip, "SITE SBUFSIZ %lu", (unsigned long) cip->dataSocketSBufSize);
        else if (cip->hasSBUFSZ == kCommandAvailable)
            (void) FTPCmd(cip, "SITE SBUFSZ %lu", (unsigned long) cip->dataSocketSBufSize);
        /* At least one server implemenation has RBUFSZ but not
         * SBUFSZ and instead uses RBUFSZ for both.
         */
        else if ((cip->hasSBUFSZ != kCommandAvailable) && (cip->hasRBUFSZ == kCommandAvailable))
            (void) FTPCmd(cip, "SITE RBUFSZ %lu", (unsigned long) cip->dataSocketSBufSize);
        else if (cip->hasBUFSIZE == kCommandAvailable)
            (void) FTPCmd(cip, "SITE BUFSIZE %lu", (unsigned long) cip->dataSocketSBufSize);
    }

#ifdef NO_SIGNALS
    vzaction = zaction;
#else   /* NO_SIGNALS */
    vcip = cip;
    vfdtouse = fdtouse;
    vfd = fd;
    vzaction = zaction;
    osigpipe = (volatile FTPSigProc) signal(SIGPIPE, BrokenData);

    gGotBrokenData = 0;
    gCanBrokenDataJmp = 0;

#ifdef HAVE_SIGSETJMP
    sj = sigsetjmp(gBrokenDataJmp, 1);
#else
    sj = setjmp(gBrokenDataJmp);
#endif  /* HAVE_SIGSETJMP */

    if (sj != 0) {
        (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
        if (vfdtouse < 0) {
            (void) close(vfd);
        }
        FTPShutdownHost(vcip);
        vcip->errNo = kErrRemoteHostClosedConnection;
        return(vcip->errNo);
    }
    gCanBrokenDataJmp = 1;
#endif  /* NO_SIGNALS */

    if (vzaction == kConfirmResumeProcSaidAppend) {
        cmd = "APPE";
        tmppfx = "";    /* Can't use that here. */
        tmpsfx = "";
    } else {
        cmd = "STOR";
        if (tmppfx == NULL)
            tmppfx = "";
        if (tmpsfx == NULL)
            tmpsfx = "";
    }

    odstfile = dstfile;
    if ((tmppfx[0] != '\0') || (tmpsfx[0] != '\0')) {
        cp = strrchr(dstfile, '/');
        if (cp == NULL)
            cp = strrchr(dstfile, '\\');
        if (cp == NULL) {
            (void) STRNCPY(dstfile2, tmppfx);
            (void) STRNCAT(dstfile2, dstfile);
            (void) STRNCAT(dstfile2, tmpsfx);
        } else {
            cp++;
            l = (size_t) (cp - dstfile);
            (void) STRNCPY(dstfile2, dstfile);
            dstfile2[l] = '\0'; /* Nuke stuff after / */
            (void) STRNCAT(dstfile2, tmppfx);
            (void) STRNCAT(dstfile2, cp);
            (void) STRNCAT(dstfile2, tmpsfx);
        }
        dstfile = dstfile2;
    }

    tmpResult = FTPStartDataCmd(
        cip,
        kNetWriting,
        xtype,
        startPoint,
        "%s %s",
        cmd,
        dstfile
    );

    if (tmpResult < 0) {
        cip->errNo = tmpResult;
        if (fdtouse < 0) {
            (void) close(fd);
        }
#if !defined(NO_SIGNALS)
        (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
#endif  /* NO_SIGNALS */
        return (cip->errNo);
    }

    if ((startPoint != 0) && (cip->startPoint == 0)) {
        /* Remote could not or would not set the start offset
         * to what we wanted.
         *
         * So now we have to undo our seek.
         */
        if (Lseek(fd, (off_t) 0, SEEK_SET) != (off_t) 0) {
            cip->errNo = kErrLseekFailed;
            if (fdtouse < 0) {
                (void) close(fd);
            }
#if !defined(NO_SIGNALS)
            (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
#endif  /* NO_SIGNALS */
            return (cip->errNo);
        }
        startPoint = 0;
    }

    result = kNoErr;
    buf = cip->buf;
    bufSize = cip->bufSize;

    FTPInitIOTimer(cip);
    if ((fstatrc == 0) && (S_ISREG(st.st_mode) != 0)) {
        cip->expectedSize = (longest_int) st.st_size;
        cip->mdtm = st.st_mtime;
    }
    cip->lname = file;  /* could be NULL */
    cip->rname = odstfile;
    if (fdtouse >= 0)
        cip->useProgressMeter = 0;
    FTPStartIOTimer(cip);

    /* Note: On Windows, we don't have to do anything special
     * for ASCII mode, since Net ASCII's end-of-line sequence
     * corresponds to the same thing used for DOS/Windows.
     */

#if ASCII_TRANSLATION
    if (xtype == kTypeAscii) {
        /* ascii */
        for (;;) {
#if !defined(NO_SIGNALS)
            gCanBrokenDataJmp = 0;
#endif  /* NO_SIGNALS */
            nread = read(fd, inbuf, sizeof(inbuf));
            if (nread < 0) {
                if (errno == EINTR) {
                    continue;
                } else {
                    result = kErrReadFailed;
                    cip->errNo = kErrReadFailed;
                    Error(cip, kDoPerror, "Local read failed.\n");
                }
                break;
            } else if (nread == 0) {
                break;
            }
            cip->bytesTransferred += (longest_int) nread;

#if !defined(NO_SIGNALS)
            gCanBrokenDataJmp = 1;
#endif  /* NO_SIGNALS */
            src = inbuf;
            srclim = src + nread;
            dst = cip->buf;     /* must be 2x sizeof inbuf or more. */
            while (src < srclim) {
                if (*src == '\n')
                    *dst++ = '\r';
                *dst++ = *src++;
            }
            ntowrite = (size_t) (dst - cip->buf);
            cp = cip->buf;

#if !defined(NO_SIGNALS)
            if (cip->xferTimeout > 0)
                (void) alarm(cip->xferTimeout);
#endif  /* NO_SIGNALS */
            do {
                if (! WaitForRemoteOutput(cip)) {   /* could set cancelXfer */
                    cip->errNo = result = kErrDataTimedOut;
                    Error(cip, kDontPerror, "Remote write timed out.\n");
                    goto brk;
                }
                if (cip->cancelXfer > 0) {
                    FTPAbortDataTransfer(cip);
                    result = cip->errNo = kErrDataTransferAborted;
                    goto brk;
                }

#ifdef NO_SIGNALS
                nwrote = SWrite(cip->dataSocket, cp, (size_t) ntowrite, (int) cip->xferTimeout, kNoFirstSelect);
                if (nwrote < 0) {
                    if (nwrote == kTimeoutErr) {
                        cip->errNo = result = kErrDataTimedOut;
                        Error(cip, kDontPerror, "Remote write timed out.\n");
                    } else if ((gGotBrokenData != 0) || (errno == EPIPE)) {
                        cip->errNo = result = kErrSocketWriteFailed;
                        errno = EPIPE;
                        Error(cip, kDoPerror, "Lost data connection to remote host.\n");
                    } else if (errno == EINTR) {
                        continue;
                    } else {
                        cip->errNo = result = kErrSocketWriteFailed;
                        Error(cip, kDoPerror, "Remote write failed.\n");
                    }
                    (void) shutdown(cip->dataSocket, 2);
                    goto brk;
                }
#else   /* NO_SIGNALS */
                nwrote = write(cip->dataSocket, cp, ntowrite);
                if (nwrote < 0) {
                    if ((gGotBrokenData != 0) || (errno == EPIPE)) {
                        cip->errNo = result = kErrSocketWriteFailed;
                        errno = EPIPE;
                        Error(cip, kDoPerror, "Lost data connection to remote host.\n");
                    } else if (errno == EINTR) {
                        continue;
                    } else {
                        cip->errNo = result = kErrSocketWriteFailed;
                        Error(cip, kDoPerror, "Remote write failed.\n");
                    }
                    (void) shutdown(cip->dataSocket, 2);
                    goto brk;
                }
#endif  /* NO_SIGNALS */
                cp += nwrote;
                ntowrite -= nwrote;
            } while (ntowrite > 0);
            FTPUpdateIOTimer(cip);
        }
    } else
#endif  /* ASCII_TRANSLATION */
    {
        /* binary */
        for (;;) {
#if !defined(NO_SIGNALS)
            gCanBrokenDataJmp = 0;
#endif  /* NO_SIGNALS */
            cp = buf;
            nread = read(fd, cp, bufSize);
            if (nread < 0) {
                if (errno == EINTR) {
                    continue;
                } else {
                    result = kErrReadFailed;
                    cip->errNo = kErrReadFailed;
                    Error(cip, kDoPerror, "Local read failed.\n");
                }
                break;
            } else if (nread == 0) {
                break;
            }
            cip->bytesTransferred += (longest_int) nread;

#if !defined(NO_SIGNALS)
            gCanBrokenDataJmp = 1;
            if (cip->xferTimeout > 0)
                (void) alarm(cip->xferTimeout);
#endif  /* NO_SIGNALS */
            do {
                if (! WaitForRemoteOutput(cip)) {   /* could set cancelXfer */
                    cip->errNo = result = kErrDataTimedOut;
                    Error(cip, kDontPerror, "Remote write timed out.\n");
                    goto brk;
                }
                if (cip->cancelXfer > 0) {
                    FTPAbortDataTransfer(cip);
                    result = cip->errNo = kErrDataTransferAborted;
                    goto brk;
                }

#ifdef NO_SIGNALS
                nwrote = SWrite(cip->dataSocket, cp, (size_t) nread, (int) cip->xferTimeout, kNoFirstSelect);
                if (nwrote < 0) {
                    if (nwrote == kTimeoutErr) {
                        cip->errNo = result = kErrDataTimedOut;
                        Error(cip, kDontPerror, "Remote write timed out.\n");
                    } else if ((gGotBrokenData != 0) || (errno == EPIPE)) {
                        cip->errNo = result = kErrSocketWriteFailed;
                        errno = EPIPE;
                        Error(cip, kDoPerror, "Lost data connection to remote host.\n");
                    } else if (errno == EINTR) {
                        continue;
                    } else {
                        cip->errNo = result = kErrSocketWriteFailed;
                        Error(cip, kDoPerror, "Remote write failed.\n");
                    }
                    (void) shutdown(cip->dataSocket, 2);
                    cip->dataSocket = -1;
                    goto brk;
                }
#else   /* NO_SIGNALS */
                nwrote = write(cip->dataSocket, cp, nread);
                if (nwrote < 0) {
                    if ((gGotBrokenData != 0) || (errno == EPIPE)) {
                        cip->errNo = result = kErrSocketWriteFailed;
                        errno = EPIPE;
                        Error(cip, kDoPerror, "Lost data connection to remote host.\n");
                    } else if (errno == EINTR) {
                        continue;
                    } else {
                        cip->errNo = result = kErrSocketWriteFailed;
                        Error(cip, kDoPerror, "Remote write failed.\n");
                    }
                    (void) shutdown(cip->dataSocket, 2);
                    cip->dataSocket = -1;
                    goto brk;
                }
#endif  /* NO_SIGNALS */
                cp += nwrote;
                nread -= nwrote;
            } while (nread > 0);
            FTPUpdateIOTimer(cip);
        }
    }
brk:

    if (fdtouse < 0) {
        (void) Fstat(fd, &st);
    }

    if (fdtouse < 0) {
        if (shutdown(fd, 1) == 0) {
            /* This looks very bizarre, since
             * we will be checking the socket
             * for readability here!
             *
             * The reason for this is that we
             * want to be able to timeout a
             * small put.  So, we close the
             * write end of the socket first,
             * which tells the server we're
             * done writing.  We then wait
             * for the server to close down
             * the whole socket, which tells
             * us that the file was completed.
             */
            (void) WaitForRemoteInput(cip); /* Close could block. */
        }
    }

#if !defined(NO_SIGNALS)
    gCanBrokenDataJmp = 0;
    if (cip->xferTimeout > 0)
        (void) alarm(0);
#endif  /* NO_SIGNALS */
    tmpResult = FTPEndDataCmd(cip, 1);
    if ((tmpResult < 0) && (result == kNoErr)) {
        cip->errNo = result = kErrSTORFailed;
    }
    FTPStopIOTimer(cip);

    if (fdtouse < 0) {
        /* If they gave us a descriptor (fdtouse >= 0),
         * leave it open, otherwise we opened it, so
         * we need to dispose of it.
         */
        (void) close(fd);
        fd = -1;
    }

    if (result == kNoErr) {
        /* The store succeeded;  If we were
         * uploading to a temporary file,
         * move the new file to the new name.
         */
        cip->numUploads++;

        if ((tmppfx[0] != '\0') || (tmpsfx[0] != '\0')) {
            if ((result = FTPRename(cip, dstfile, odstfile)) < 0) {
                /* May fail if file was already there,
                 * so delete the old one so we can move
                 * over it.
                 */
                if (FTPDelete(cip, odstfile, kRecursiveNo, kGlobNo) == kNoErr) {
                    result = FTPRename(cip, dstfile, odstfile);
                    if (result < 0) {
                        Error(cip, kDontPerror, "Could not rename %s to %s: %s.\n", dstfile, odstfile, FTPStrError(cip->errNo));
                    }
                } else {
                    Error(cip, kDontPerror, "Could not delete old %s, so could not rename %s to that: %s\n", odstfile, dstfile, FTPStrError(cip->errNo));
                }
            }
        }

        if (FTPUtime(cip, odstfile, st.st_atime, st.st_mtime, st.st_ctime) != kNoErr) {
            if (cip->errNo != kErrUTIMENotAvailable)
                Error(cip, kDontPerror, "Could not preserve times for %s: %s.\n", odstfile, FTPStrError(cip->errNo));
        }

        if (deleteflag == kDeleteYes) {
            if (unlink(file) < 0) {
                result = cip->errNo = kErrLocalDeleteFailed;
            }
        }
    }

#if !defined(NO_SIGNALS)
    (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
#endif  /* NO_SIGNALS */
    return (result);
}   /* FTPPutOneF */




int
FTPPutOneFile3(
    const FTPCIPtr cip,
    const char *const file,
    const char *const dstfile,
    const int xtype,
    const int fdtouse,
    const int appendflag,
    const char *const tmppfx,
    const char *const tmpsfx,
    const int resumeflag,
    const int deleteflag,
    const ConfirmResumeUploadProc resumeProc,
    int UNUSED(reserved))
{
    int result;

    LIBNCFTP_USE_VAR(reserved);
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);

    if ((dstfile == NULL) || (dstfile[0] == '\0'))
        return (kErrBadParameter);
    if (fdtouse < 0) {
        if ((file == NULL) || (file[0] == '\0'))
            return (kErrBadParameter);
    }
    result = FTPPutOneF(cip, file, dstfile, xtype, fdtouse, appendflag, tmppfx, tmpsfx, resumeflag, deleteflag, resumeProc);
    return (result);
}   /* FTPPutOneFile3 */




int
FTPPutFiles3(
    const FTPCIPtr cip,
    const char *const pattern,
    const char *const dstdir1,
    const int recurse,
    const int doGlob,
    const int xtype,
    int appendflag,
    const char *const tmppfx,
    const char *const tmpsfx,
    const int resumeflag,
    const int deleteflag,
    const ConfirmResumeUploadProc resumeProc,
    int UNUSED(reserved))
{
    LineList globList;
    FileInfoList files;
    FileInfoPtr filePtr;
    int batchResult;
    int result;
    const char *dstdir;
    char dstdir2[512];

    LIBNCFTP_USE_VAR(reserved);
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);

    if (dstdir1 == NULL) {
        dstdir = NULL;
    } else {
        dstdir = STRNCPY(dstdir2, dstdir1);
        StrRemoveTrailingLocalPathDelim(dstdir2);
    }

    (void) FTPLocalGlob(cip, &globList, pattern, doGlob);
    if (recurse == kRecursiveYes) {
        appendflag = kAppendNo;
        (void) FTPLocalRecursiveFileList(cip, &globList, &files);
        if (files.first == NULL) {
            cip->errNo = kErrNoValidFilesSpecified;
            return (kErrNoValidFilesSpecified);
        }
        (void) ComputeRNames(&files, dstdir, 0, 1);
    } else {
        (void) LineListToFileInfoList(&globList, &files);
        (void) ComputeLNames(&files, NULL, NULL, 1);
        (void) ComputeRNames(&files, dstdir, 0, 0);
    }
    DisposeLineListContents(&globList);

#if 0
    for (filePtr = files.first; filePtr != NULL; filePtr = filePtr->next) {
        PrintF(cip, "  R=%s, L=%s, 2=%s, size=%d, mdtm=%u, type=%c\n",
            filePtr->rname,
            filePtr->lname,
            filePtr->rlinkto ? filePtr->rlinkto : "",
            filePtr->size,
            (unsigned int) filePtr->mdtm,
            filePtr->type
        );
    }
#endif

    batchResult = kNoErr;
    for (filePtr = files.first; filePtr != NULL; filePtr = filePtr->next) {
        if (cip->connected == 0) {
            if (batchResult == kNoErr)
                batchResult = kErrRemoteHostClosedConnection;
            break;
        }
        if (filePtr->type == 'd') {
            /* mkdir */
            StrRemoveTrailingLocalPathDelim(filePtr->rname);
            result = FTPMkdir(cip, filePtr->rname, kRecursiveNo);
            if (result != kNoErr)
                batchResult = result;
#ifdef HAVE_SYMLINK
        } else if (filePtr->type == 'l') {
            /* symlink */
            /* no RFC way to create the link, though. */
            if ((filePtr->rlinkto != NULL) && (filePtr->rlinkto[0] != '\0'))
                (void) FTPSymlink(cip, filePtr->rname, filePtr->rlinkto);
#endif
        } else if (recurse != kRecursiveYes) {
            result = FTPPutOneF(cip, filePtr->lname, filePtr->rname, xtype, -1, appendflag, tmppfx, tmpsfx, resumeflag, deleteflag, resumeProc);
            if (files.nFileInfos == 1) {
                if (result != kNoErr)
                    batchResult = result;
            } else {
                if ((result != kNoErr) && (result != kErrLocalFileNewer) && (result != kErrRemoteFileNewer) && (result != kErrLocalSameAsRemote))
                    batchResult = result;
            }
            if (result == kErrUserCanceled)
                cip->cancelXfer = 1;
            if (cip->cancelXfer > 0)
                break;
        } else {
            result = FTPPutOneF(cip, filePtr->lname, filePtr->rname, xtype, -1, appendflag, tmppfx, tmpsfx, resumeflag, deleteflag, resumeProc);
            if (files.nFileInfos == 1) {
                if (result != kNoErr)
                    batchResult = result;
            } else {
                if ((result != kNoErr) && (result != kErrLocalFileNewer) && (result != kErrRemoteFileNewer) && (result != kErrLocalSameAsRemote))
                    batchResult = result;
            }
            if (result == kErrUserCanceled)
                cip->cancelXfer = 1;
            if (cip->cancelXfer > 0)
                break;
        }
    }
    DisposeFileInfoListContents(&files);
    if (batchResult < 0)
        cip->errNo = batchResult;
    return (batchResult);
}   /* FTPPutFiles3 */




/* The purpose of this is to provide updates for the progress meters
 * during lags.  Return zero if the operation timed-out.
 */
static int
WaitForRemoteInput(const FTPCIPtr cip)
{
    fd_set ss, ss2;
    struct timeval tv;
    int result;
    int fd;
    int wsecs;
    int xferTimeout;
    int ocancelXfer;

    xferTimeout = cip->xferTimeout;
    if (xferTimeout < 1)
        return (1);

    fd = cip->dataSocket;
    if (fd < 0)
        return (1);

    ocancelXfer = cip->cancelXfer;
    wsecs = 0;
    cip->stalled = 0;

    while ((xferTimeout <= 0) || (wsecs < xferTimeout)) {
        if ((cip->cancelXfer != 0) && (ocancelXfer == 0)) {
            /* leave cip->stalled -- could have been stalled and then canceled. */
            return (1);
        }
        FD_ZERO(&ss);
        FD_SET(fd, &ss);
        ss2 = ss;
        tv.tv_sec = 1;
        tv.tv_usec = 0;
        result = select(fd + 1, SELECT_TYPE_ARG234 &ss, NULL, SELECT_TYPE_ARG234 &ss2, &tv);
        if (result == 1) {
            /* ready */
            cip->stalled = 0;
            return (1);
        } else if (result < 0) {
            if (result != EINTR) {
                perror("select");
                cip->stalled = 0;
                return (1);
            }
        } else {
            wsecs++;
            cip->stalled = wsecs;
        }
        FTPUpdateIOTimer(cip);
    }

#if !defined(NO_SIGNALS)
    /* Shouldn't get here -- alarm() should have
     * went off by now.
     */
    (void) kill(getpid(), SIGALRM);
#endif  /* NO_SIGNALS */

    cip->dataTimedOut = 1;
    return (0); /* timed-out */
}   /* WaitForRemoteInput */




/* Nice for UNIX, but not necessary otherwise. */
#ifdef TAR

static int
OpenTar(const FTPCIPtr cip, const char *const dstdir, int *const pid)
{
    int pipe1[2];
    int pid1;
    int i;
    char *argv[8];

    *pid = -1;

    if (access(TAR, X_OK) < 0) {
        /* Path to TAR is invalid. */
        return (-1);
    }

    if (pipe(pipe1) < 0) {
        Error(cip, kDoPerror, "pipe to Tar failed");
        return (-1);
    }

    pid1 = (int) fork();
    if (pid1 < 0) {
        (void) close(pipe1[0]);
        (void) close(pipe1[1]);
        return (-1);
    } else if (pid1 == 0) {
        /* Child */
        if ((dstdir != NULL) && (dstdir[0] != '\0') && (chdir(dstdir) < 0)) {
            Error(cip, kDoPerror, "tar chdir to %s failed", dstdir);
            exit(1);
        }
        (void) close(pipe1[1]);     /* close write end */
        (void) dup2(pipe1[0], 0);   /* use read end on stdin */
        (void) close(pipe1[0]);

        for (i=3; i<256; i++)
            (void) close(i);

        argv[0] = (char *) "tar";
        argv[1] = (char *) "xpf";
        argv[2] = (char *) "-";
        argv[3] = NULL;

        (void) execv(TAR, argv);
        exit(1);
    }

    /* Parent */
    *pid = pid1;

    (void) close(pipe1[0]);     /* close read end */
    return (pipe1[1]);      /* use write end */
}   /* OpenTar */




static int
FTPGetOneTarF(const FTPCIPtr cip, const char *file, const char *const dstdir)
{
    char *buf;
    size_t bufSize;
    int tmpResult;
    volatile int result;
    int nread, nwrote;
    volatile int fd;
    volatile int vfd;
    const char *volatile vfile;
#ifndef NO_SIGNALS
    int sj;
    volatile FTPSigProc osigpipe;
    volatile FTPCIPtr vcip;
#endif
    int pid, status;
    char savedCwd[512];
    char *volatile basecp;

    result = kNoErr;
    cip->usingTAR = 0;

    if ((file[0] == '\0') || ((file[0] == '/') && (file[1] == '\0'))) {
        /* It was "/"
         * We can't do that, because "get /.tar"
         * or "get .tar" does not work.
         */
        result = kErrOpenFailed;
        cip->errNo = kErrOpenFailed;
        return (result);
    }

    if (FTPCmd(cip, "MDTM %s.tar", file) == 2) {
        /* Better not use this method since there is
         * no way to tell if the server would use the
         * existing .tar or do a new one on the fly.
         */
        result = kErrOpenFailed;
        cip->errNo = kErrOpenFailed;
        return (result);
    }

    basecp = strrchr(file, '/');
    if (basecp != NULL)
        basecp = strrchr(file, '\\');
    if (basecp != NULL) {
        /* Need to cd to the parent directory and get it
         * from there.
         */
        if (FTPGetCWD(cip, savedCwd, sizeof(savedCwd)) != 0) {
            result = kErrOpenFailed;
            cip->errNo = kErrOpenFailed;
            return (result);
        }
        result = FTPChdir(cip, file);
        if (result != kNoErr) {
            return (result);
        }
        result = FTPChdir(cip, "..");
        if (result != kNoErr) {
            (void) FTPChdir(cip, savedCwd);
            return (result);
        }
        file = basecp + 1;
    }

    fd = OpenTar(cip, dstdir, &pid);
    if (fd < 0) {
        result = kErrOpenFailed;
        cip->errNo = kErrOpenFailed;
        if (basecp != NULL)
            (void) FTPChdir(cip, savedCwd);
        return (result);
    }

    vfd = fd;
    vfile = file;

#ifndef NO_SIGNALS
    vcip = cip;
    osigpipe = (volatile FTPSigProc) signal(SIGPIPE, BrokenData);

    gGotBrokenData = 0;
    gCanBrokenDataJmp = 0;

#ifdef HAVE_SIGSETJMP
    sj = sigsetjmp(gBrokenDataJmp, 1);
#else
    sj = setjmp(gBrokenDataJmp);
#endif  /* HAVE_SIGSETJMP */

    if (sj != 0) {
        (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
        FTPShutdownHost(vcip);

        (void) signal(SIGPIPE, SIG_IGN);
        (void) close(vfd);
        for (;;) {
#ifdef HAVE_WAITPID
            if ((waitpid(pid, &status, 0) < 0) && (errno != EINTR))
                break;
#else
            if ((wait(&status) < 0) && (errno != EINTR))
                break;
#endif
            if (WIFEXITED(status) || WIFSIGNALED(status))
                break;      /* done */
        }
        if (basecp != NULL)
            (void) FTPChdir(cip, savedCwd);
        vcip->errNo = kErrRemoteHostClosedConnection;
        return(vcip->errNo);
    }
    gCanBrokenDataJmp = 1;

#endif  /* NO_SIGNALS */

    tmpResult = FTPStartDataCmd(cip, kNetReading, kTypeBinary, (longest_int) 0, "RETR %s.tar", vfile);

    if (tmpResult < 0) {
        result = tmpResult;
        if (result == kErrGeneric)
            result = kErrRETRFailed;
        cip->errNo = result;

#ifndef NO_SIGNALS
        (void) signal(SIGPIPE, SIG_IGN);
#endif
        (void) close(vfd);
        for (;;) {
#ifdef HAVE_WAITPID
            if ((waitpid(pid, &status, 0) < 0) && (errno != EINTR))
                break;
#else
            if ((wait(&status) < 0) && (errno != EINTR))
                break;
#endif
            if (WIFEXITED(status) || WIFSIGNALED(status))
                break;      /* done */
        }

#ifndef NO_SIGNALS
        (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
#endif
        if (basecp != NULL)
            (void) FTPChdir(cip, savedCwd);
        return (result);
    }

    cip->usingTAR = 1;
    buf = cip->buf;
    bufSize = cip->bufSize;

    FTPInitIOTimer(cip);
    cip->lname = vfile; /* could be NULL */
    cip->rname = vfile;
    FTPStartIOTimer(cip);

    /* Binary */
    for (;;) {
        if (! WaitForRemoteInput(cip)) {    /* could set cancelXfer */
            cip->errNo = result = kErrDataTimedOut;
            Error(cip, kDontPerror, "Remote read timed out.\n");
            break;
        }
        if (cip->cancelXfer > 0) {
            FTPAbortDataTransfer(cip);
            result = cip->errNo = kErrDataTransferAborted;
            break;
        }
#if !defined(NO_SIGNALS)
        gCanBrokenDataJmp = 1;
        if (cip->xferTimeout > 0)
            (void) alarm(cip->xferTimeout);
#endif  /* NO_SIGNALS */
#ifdef NO_SIGNALS
        nread = SRead(cip->dataSocket, buf, bufSize, (int) cip->xferTimeout, kFullBufferNotRequired|kNoFirstSelect);
        if (nread == kTimeoutErr) {
            cip->errNo = result = kErrDataTimedOut;
            Error(cip, kDontPerror, "Remote read timed out.\n");
            break;
        } else if (nread < 0) {
            if (errno == EINTR)
                continue;
            Error(cip, kDoPerror, "Remote read failed.\n");
            result = kErrSocketReadFailed;
            cip->errNo = kErrSocketReadFailed;
            break;
        } else if (nread == 0) {
            break;
        }
#else
        nread = read(cip->dataSocket, buf, bufSize);
        if (nread < 0) {
            if (errno == EINTR)
                continue;
            Error(cip, kDoPerror, "Remote read failed.\n");
            result = kErrSocketReadFailed;
            cip->errNo = kErrSocketReadFailed;
            break;
        } else if (nread == 0) {
            break;
        }
        gCanBrokenDataJmp = 0;
#endif

        nwrote = write(fd, buf, nread);
        if (nwrote != nread) {
            if ((gGotBrokenData != 0) || (errno == EPIPE)) {
                result = kErrWriteFailed;
                cip->errNo = kErrWriteFailed;
                errno = EPIPE;
            } else {
                Error(cip, kDoPerror, "Local write failed.\n");
                result = kErrWriteFailed;
                cip->errNo = kErrWriteFailed;
            }
            break;
        }
        cip->bytesTransferred += (longest_int) nread;
        FTPUpdateIOTimer(cip);
    }

#if !defined(NO_SIGNALS)
    if (cip->xferTimeout > 0)
        (void) alarm(0);
    gCanBrokenDataJmp = 0;
#endif  /* NO_SIGNALS */

    (void) close(fd);
    for (;;) {
#ifdef HAVE_WAITPID
        if ((waitpid(pid, &status, 0) < 0) && (errno != EINTR))
            break;
#else
        if ((wait(&status) < 0) && (errno != EINTR))
            break;
#endif
        if (WIFEXITED(status) || WIFSIGNALED(status))
            break;      /* done */
    }

    tmpResult = FTPEndDataCmd(cip, 1);
    if ((tmpResult < 0) && (result == 0)) {
        result = kErrRETRFailed;
        cip->errNo = kErrRETRFailed;
    }
    FTPStopIOTimer(cip);
#if !defined(NO_SIGNALS)
    (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
#endif

    if ((result == 0) && (cip->bytesTransferred == 0)) {
        result = kErrOpenFailed;
        cip->errNo = kErrOpenFailed;
    }
    if (basecp != NULL)
        (void) FTPChdir(cip, savedCwd);
    return (result);
}   /* FTPGetOneTarF */

#endif  /* TAR */





static int
FTPGetOneF(
    const FTPCIPtr cip,
    const char *const file,
    const char *dstfile,
    int xtype,
    const int fdtouse,
    longest_int expectedSize,
    time_t mdtm,
    const int resumeflag,
    const int appendflag,
    const int deleteflag,
    const ConfirmResumeDownloadProc resumeProc)
{
    char *buf;
    size_t bufSize;
    int tmpResult;
    volatile int result;
    int nread, nwrote;
    volatile int fd;
#if ASCII_TRANSLATION
    char *src, *srclim;
    char *dst, *dstlim;
    char outbuf[512];
#endif
    volatile longest_int startPoint = 0;
    struct utimbuf ut;
    struct Stat st;
#if !defined(NO_SIGNALS)
    volatile FTPSigProc osigpipe;
    volatile FTPCIPtr vcip;
    volatile int vfd, vfdtouse;
    int sj;
#endif  /* NO_SIGNALS */
    volatile int created = 0;
    int zaction = kConfirmResumeProcSaidBestGuess;
    int statrc;
    int noMdtmCheck;
    time_t now;

    if (cip->buf == NULL) {
        Error(cip, kDoPerror, "Transfer buffer not allocated.\n");
        cip->errNo = kErrNoBuf;
        return (cip->errNo);
    }

    result = kNoErr;
    cip->usingTAR = 0;

    if (fdtouse < 0) {
        /* Only ask for extended information
         * if we have the name of the file
         * and we didn't already have the
         * info.
         *
         * Always ask for the modification time,
         * because even if it was passed in it
         * may not be accurate.  This is often
         * the case when it came from an ls
         * listing, in which the local time
         * zone could be a factor.
         *
         */

        AutomaticallyUseASCIIModeDependingOnExtension(cip, file, &xtype);
        if (expectedSize == kSizeUnknown) {
            (void) FTPFileSizeAndModificationTime(cip, file, &expectedSize, xtype, &mdtm);
        } else {
            (void) FTPFileModificationTime(cip, file, &mdtm);
        }

        /* For Get, we can't recover very well if it turns out restart
         * didn't work, so check beforehand.
         */
        if ((resumeflag == kResumeYes) || (resumeProc != NoConfirmResumeDownloadProc)) {
            if (cip->hasREST == kCommandAvailabilityUnknown) {
                (void) FTPSetTransferType(cip, kTypeBinary);
                if (SetStartOffset(cip, (longest_int) 1) == kNoErr) {
                    /* Now revert -- we still may not end up
                     * doing it.
                     */
                    SetStartOffset(cip, (longest_int) -1);
                }
            }
        }

        if (appendflag == kAppendYes) {
            zaction = kConfirmResumeProcSaidAppend;
        } else if (cip->hasREST == kCommandNotAvailable) {
            zaction = kConfirmResumeProcSaidOverwrite;
        } else if (resumeflag == kResumeYes) {
            zaction = kConfirmResumeProcSaidBestGuess;
        } else {
            zaction = kConfirmResumeProcSaidOverwrite;
        }

        statrc = Stat(dstfile, &st);
        if (statrc == 0) {
            if (resumeProc != NULL) {
                zaction = (*resumeProc)(
                        &dstfile,
                        (longest_int) st.st_size,
                        st.st_mtime,
                        file,
                        expectedSize,
                        mdtm,
                        &startPoint
                );
            }

            if (zaction == kConfirmResumeProcSaidBestGuess) {
                if (expectedSize != kSizeUnknown) {
                    /* We know the size of the remote file,
                     * and we have a local file too.
                     *
                     * Try and decide if we need to get
                     * the entire file, or just part of it.
                     */

                    startPoint = (longest_int) st.st_size;
                    zaction = kConfirmResumeProcSaidResume;

                    /* If the local file exists and has a recent
                     * modification time (< 12 hours) and
                     * the remote file's modtime is not recent,
                     * then heuristically conclude that the
                     * local modtime should not be trusted
                     * (i.e. user killed the process before
                     * the local modtime could be preserved).
                     */
                    noMdtmCheck = 0;
                    if (mdtm != kModTimeUnknown) {
                        time(&now);
                        if ((st.st_mtime > now) || (((now - st.st_mtime) < 46200) && ((now - mdtm) >= 46200)))
                            noMdtmCheck = 1;
                    }

                    if ((mdtm == kModTimeUnknown) || (noMdtmCheck != 0)) {
                        /* Can't use the timestamps as an aid. */
                        if (startPoint == expectedSize) {
                            /* Don't go to all the trouble of downloading nothing. */
                            cip->errNo = kErrLocalSameAsRemote;
                            if (deleteflag == kDeleteYes)
                                (void) FTPDelete(cip, file, kRecursiveNo, kGlobNo);
                            return (cip->errNo);
                        } else if (startPoint > expectedSize) {
                            /* Panic;  odds are the file we have
                             * was a different file altogether,
                             * since it is larger than the
                             * remote copy.  Re-do it all.
                             */
                            zaction = kConfirmResumeProcSaidOverwrite;
                        } /* else resume at startPoint */
                    } else if ((mdtm == st.st_mtime) || (mdtm == (st.st_mtime - 1)) || (mdtm == (st.st_mtime + 1))) {
                        /* File has the same time.
                         * Note: Windows' file timestamps can be off by one second!
                         */
                        if (startPoint == expectedSize) {
                            /* Don't go to all the trouble of downloading nothing. */
                            cip->errNo = kErrLocalSameAsRemote;
                            if (deleteflag == kDeleteYes)
                                (void) FTPDelete(cip, file, kRecursiveNo, kGlobNo);
                            return (cip->errNo);
                        } else if (startPoint > expectedSize) {
                            /* Panic;  odds are the file we have
                             * was a different file altogether,
                             * since it is larger than the
                             * remote copy.  Re-do it all.
                             */
                            zaction = kConfirmResumeProcSaidOverwrite;
                        } else {
                            /* We have a file by the same time,
                             * but smaller start point.  Leave
                             * the startpoint as is since it
                             * is most likely valid.
                             */
                        }
                    } else if (mdtm < st.st_mtime) {
                        /* Remote file is older than
                         * local file.  Don't overwrite
                         * our file.
                         */
                        cip->errNo = kErrLocalFileNewer;
                        return (cip->errNo);
                    } else /* if (mdtm > st.st_mtime) */ {
                        /* File has a newer timestamp
                         * altogether, assume the remote
                         * file is an entirely new file
                         * and replace ours with it.
                         */
                        zaction = kConfirmResumeProcSaidOverwrite;
                    }
                } else {
                        zaction = kConfirmResumeProcSaidOverwrite;
                }
            }
        } else {
            zaction = kConfirmResumeProcSaidOverwrite;
        }

        if (zaction == kConfirmResumeProcSaidCancel) {
            /* User wants to cancel this file and any
             * remaining in batch.
             */
            cip->errNo = kErrUserCanceled;
            return (cip->errNo);
        } else if (zaction == kConfirmResumeProcSaidSkip) {
            /* Nothing done, but not an error. */
            if (deleteflag == kDeleteYes)
                (void) FTPDelete(cip, file, kRecursiveNo, kGlobNo);
            return (kNoErr);
        } else if (zaction == kConfirmResumeProcSaidResume) {
            /* Resume; proc set the startPoint. */
            if (startPoint == expectedSize) {
                /* Don't go to all the trouble of downloading nothing. */
                /* Nothing done, but not an error. */
                if (deleteflag == kDeleteYes)
                    (void) FTPDelete(cip, file, kRecursiveNo, kGlobNo);
                return (kNoErr);
            } else if (startPoint > expectedSize) {
                /* Cannot set start point past end of remote file */
                cip->errNo = result = kErrSetStartPoint;
                return (result);
            }
            fd = Open(dstfile, O_WRONLY|O_APPEND|O_BINARY, 00666);
        } else if (zaction == kConfirmResumeProcSaidAppend) {
            /* leave startPoint at zero, we will append everything. */
            startPoint = (longest_int) 0;
            fd = Open(dstfile, O_WRONLY|O_CREAT|O_APPEND|O_BINARY, 00666);
        } else /* if (zaction == kConfirmResumeProcSaidOverwrite) */ {
            created = 1;
            startPoint = (longest_int) 0;
            fd = Open(dstfile, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY, 00666);
        }

        if (fd < 0) {
            Error(cip, kDoPerror, "Cannot open local file %s for writing.\n", dstfile);
            result = kErrOpenFailed;
            cip->errNo = kErrOpenFailed;
            return (result);
        }

        if ((expectedSize == (longest_int) 0) && (startPoint <= (longest_int) 0) && (zaction != kConfirmResumeProcSaidOverwrite)) {
            /* Don't go to all the trouble of downloading nothing. */
#if defined(WIN32) || defined(_WINDOWS)
            /* Note: Windows doesn't allow zero-size files. */
            (void) write(fd, "\r\n", 2);
#endif
            (void) close(fd);
            if (mdtm != kModTimeUnknown) {
                cip->mdtm = mdtm;
                (void) time(&ut.actime);
                ut.modtime = mdtm;
                (void) utime(dstfile, &ut);
            }
            if (deleteflag == kDeleteYes)
                (void) FTPDelete(cip, file, kRecursiveNo, kGlobNo);
            return (kNoErr);
        }
    } else {
        fd = fdtouse;
    }

    if ((cip->numDownloads == 0) && (cip->dataSocketRBufSize > 0)) {
        /* If dataSocketSBufSize is non-zero, it means you
         * want to explicitly try to set the size of the
         * socket's I/O buffer.
         *
         * If it is zero, it means you want to just use the
         * TCP stack's default value, which is typically
         * between 8 and 64 kB.
         *
         * If you try to set the buffer larger than 64 kB,
         * the TCP stack should try to use RFC 1323 to
         * negotiate "TCP Large Windows" which may yield
         * significant performance gains.
         */
        if (cip->hasRETRBUFSIZE == kCommandAvailable)
            (void) FTPCmd(cip, "SITE RETRBUFSIZE %lu", (unsigned long) cip->dataSocketRBufSize);
        else if (cip->hasRBUFSIZ == kCommandAvailable)
            (void) FTPCmd(cip, "SITE RBUFSIZ %lu", (unsigned long) cip->dataSocketRBufSize);
        else if (cip->hasRBUFSZ == kCommandAvailable)
            (void) FTPCmd(cip, "SITE RBUFSZ %lu", (unsigned long) cip->dataSocketRBufSize);
        else if (cip->hasBUFSIZE == kCommandAvailable)
            (void) FTPCmd(cip, "SITE BUFSIZE %lu", (unsigned long) cip->dataSocketSBufSize);
    }

#ifdef NO_SIGNALS
#else   /* NO_SIGNALS */
    vcip = cip;
    vfdtouse = fdtouse;
    vfd = fd;
    osigpipe = (volatile FTPSigProc) signal(SIGPIPE, BrokenData);

    gGotBrokenData = 0;
    gCanBrokenDataJmp = 0;

#ifdef HAVE_SIGSETJMP
    sj = sigsetjmp(gBrokenDataJmp, 1);
#else
    sj = setjmp(gBrokenDataJmp);
#endif  /* HAVE_SIGSETJMP */

    if (sj != 0) {
        (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
        if (vfdtouse < 0) {
            (void) close(vfd);
        }
        FTPShutdownHost(vcip);
        vcip->errNo = kErrRemoteHostClosedConnection;
        return(vcip->errNo);
    }
    gCanBrokenDataJmp = 1;
#endif  /* NO_SIGNALS */

    tmpResult = FTPStartDataCmd(cip, kNetReading, xtype, startPoint, "RETR %s", file);

    if (tmpResult < 0) {
        result = tmpResult;
        if (result == kErrGeneric)
            result = kErrRETRFailed;
        cip->errNo = result;
        if (fdtouse < 0) {
            (void) close(fd);
            if ((created != 0) && (appendflag == kAppendNo) && (cip->startPoint == 0))
                (void) unlink(dstfile);
        }
#if !defined(NO_SIGNALS)
        (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
#endif  /* NO_SIGNALS */
        return (result);
    }

    if ((startPoint != 0) && (cip->startPoint == 0)) {
        /* Remote could not or would not set the start offset
         * to what we wanted.
         *
         * So now we have to undo our seek.
         */
        if (Lseek(fd, (off_t) 0, SEEK_SET) != (off_t) 0) {
            cip->errNo = kErrLseekFailed;
            if (fdtouse < 0) {
                (void) close(fd);
            }
#if !defined(NO_SIGNALS)
            (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
#endif  /* NO_SIGNALS */
            return (cip->errNo);
        }
        startPoint = 0;
    }

    buf = cip->buf;
    bufSize = cip->bufSize;

    FTPInitIOTimer(cip);
    cip->mdtm = mdtm;
    (void) time(&ut.actime);
    ut.modtime = mdtm;
    cip->expectedSize = expectedSize;
    cip->lname = dstfile;   /* could be NULL */
    cip->rname = file;
    if (fdtouse >= 0)
        cip->useProgressMeter = 0;
    FTPStartIOTimer(cip);

#if ASCII_TRANSLATION
    if (xtype == kTypeAscii) {
        /* Ascii */
        for (;;) {
            if (! WaitForRemoteInput(cip)) {    /* could set cancelXfer */
                cip->errNo = result = kErrDataTimedOut;
                Error(cip, kDontPerror, "Remote read timed out.\n");
                break;
            }
            if (cip->cancelXfer > 0) {
                FTPAbortDataTransfer(cip);
                result = cip->errNo = kErrDataTransferAborted;
                break;
            }
#ifdef TESTING_ABOR
            if (cip->bytesTransferred > 0) {
                cip->cancelXfer = 1;
                FTPAbortDataTransfer(cip);
                result = cip->errNo = kErrDataTransferAborted;
                break;
            }
#endif /* TESTING_ABOR */
#ifdef NO_SIGNALS
            nread = SRead(cip->dataSocket, buf, bufSize, (int) cip->xferTimeout, kFullBufferNotRequired|kNoFirstSelect);
            if (nread == kTimeoutErr) {
                cip->errNo = result = kErrDataTimedOut;
                Error(cip, kDontPerror, "Remote read timed out.\n");
                break;
            } else if (nread < 0) {
                if ((gGotBrokenData != 0) || (errno == EPIPE)) {
                    result = cip->errNo = kErrSocketReadFailed;
                    errno = EPIPE;
                    Error(cip, kDoPerror, "Lost data connection to remote host.\n");
                } else if (errno == EINTR) {
                    continue;
                } else {
                    Error(cip, kDoPerror, "Remote read failed.\n");
                    result = kErrSocketReadFailed;
                    cip->errNo = kErrSocketReadFailed;
                }
                break;
            } else if (nread == 0) {
                break;
            }
#else
            gCanBrokenDataJmp = 1;
            if (cip->xferTimeout > 0)
                (void) alarm(cip->xferTimeout);
            nread = read(cip->dataSocket, buf, bufSize);
            if (nread < 0) {
                if ((gGotBrokenData != 0) || (errno == EPIPE)) {
                    result = cip->errNo = kErrSocketReadFailed;
                    errno = EPIPE;
                    Error(cip, kDoPerror, "Lost data connection to remote host.\n");
                    (void) shutdown(cip->dataSocket, 2);
                } else if (errno == EINTR) {
                    continue;
                } else {
                    result = cip->errNo = kErrSocketReadFailed;
                    Error(cip, kDoPerror, "Remote read failed.\n");
                    (void) shutdown(cip->dataSocket, 2);
                }
                break;
            } else if (nread == 0) {
                break;
            }

            gCanBrokenDataJmp = 0;
#endif  /* NO_SIGNALS */

            src = buf;
            srclim = src + nread;
            dst = outbuf;
            dstlim = dst + sizeof(outbuf);
            while (src < srclim) {
                if (*src == '\r') {
                    src++;
                    continue;
                }
                if (dst >= dstlim) {
                    nwrote = write(fd, outbuf, (size_t) (dst - outbuf));
                    if (nwrote == (int) (dst - outbuf)) {
                        /* Success. */
                        dst = outbuf;
                    } else if ((gGotBrokenData != 0) || (errno == EPIPE)) {
                        result = kErrWriteFailed;
                        cip->errNo = kErrWriteFailed;
                        errno = EPIPE;
                        (void) shutdown(cip->dataSocket, 2);
                        goto brk;
                    } else {
                        Error(cip, kDoPerror, "Local write failed.\n");
                        result = kErrWriteFailed;
                        cip->errNo = kErrWriteFailed;
                        (void) shutdown(cip->dataSocket, 2);
                        goto brk;
                    }
                }
                *dst++ = *src++;
            }
            if (dst > outbuf) {
                nwrote = write(fd, outbuf, (size_t) (dst - outbuf));
                if (nwrote != (int) (dst - outbuf)) {
                    if ((gGotBrokenData != 0) || (errno == EPIPE)) {
                        result = kErrWriteFailed;
                        cip->errNo = kErrWriteFailed;
                        errno = EPIPE;
                        (void) shutdown(cip->dataSocket, 2);
                        goto brk;
                    } else {
                        Error(cip, kDoPerror, "Local write failed.\n");
                        result = kErrWriteFailed;
                        cip->errNo = kErrWriteFailed;
                        (void) shutdown(cip->dataSocket, 2);
                        goto brk;
                    }
                }
            }

            if (mdtm != kModTimeUnknown) {
                (void) utime(dstfile, &ut);
            }
            cip->bytesTransferred += (longest_int) nread;
            FTPUpdateIOTimer(cip);
        }
    } else
#endif  /* ASCII_TRANSLATION */
    {
        /* Binary */
        for (;;) {
            if (! WaitForRemoteInput(cip)) {    /* could set cancelXfer */
                cip->errNo = result = kErrDataTimedOut;
                Error(cip, kDontPerror, "Remote read timed out.\n");
                break;
            }
            if (cip->cancelXfer > 0) {
                FTPAbortDataTransfer(cip);
                result = cip->errNo = kErrDataTransferAborted;
                break;
            }
#ifdef TESTING_ABOR
            if (cip->bytesTransferred > 0) {
                cip->cancelXfer = 1;
                FTPAbortDataTransfer(cip);
                result = cip->errNo = kErrDataTransferAborted;
                break;
            }
#endif /* TESTING_ABOR */
#ifdef NO_SIGNALS
            nread = SRead(cip->dataSocket, buf, bufSize, (int) cip->xferTimeout, kFullBufferNotRequired|kNoFirstSelect);
            if (nread == kTimeoutErr) {
                cip->errNo = result = kErrDataTimedOut;
                Error(cip, kDontPerror, "Remote read timed out.\n");
                break;
            } else if (nread < 0) {
                if ((gGotBrokenData != 0) || (errno == EPIPE)) {
                    result = cip->errNo = kErrSocketReadFailed;
                    errno = EPIPE;
                    Error(cip, kDoPerror, "Lost data connection to remote host.\n");
                } else if (errno == EINTR) {
                    continue;
                } else {
                    Error(cip, kDoPerror, "Remote read failed.\n");
                    result = kErrSocketReadFailed;
                    cip->errNo = kErrSocketReadFailed;
                }
                break;
            } else if (nread == 0) {
                break;
            }
#else
            gCanBrokenDataJmp = 1;
            if (cip->xferTimeout > 0)
                (void) alarm(cip->xferTimeout);
            nread = read(cip->dataSocket, buf, bufSize);
            if (nread < 0) {
                if ((gGotBrokenData != 0) || (errno == EPIPE)) {
                    result = cip->errNo = kErrSocketReadFailed;
                    errno = EPIPE;
                    Error(cip, kDoPerror, "Lost data connection to remote host.\n");
                } else if (errno == EINTR) {
                    continue;
                } else {
                    result = cip->errNo = kErrSocketReadFailed;
                    Error(cip, kDoPerror, "Remote read failed.\n");
                }
                (void) shutdown(cip->dataSocket, 2);
                break;
            } else if (nread == 0) {
                break;
            }
            gCanBrokenDataJmp = 0;
#endif  /* NO_SIGNALS */

            nwrote = write(fd, buf, nread);
            if (nwrote != nread) {
                if ((gGotBrokenData != 0) || (errno == EPIPE)) {
                    result = kErrWriteFailed;
                    cip->errNo = kErrWriteFailed;
                    errno = EPIPE;
                } else {
                    Error(cip, kDoPerror, "Local write failed.\n");
                    result = kErrWriteFailed;
                    cip->errNo = kErrWriteFailed;
                }
                (void) shutdown(cip->dataSocket, 2);
                break;
            }

            /* Ugggh... do this after each write operation
             * so it minimizes the chance of a user killing
             * the process before we reset the timestamps.
             */
            if (mdtm != kModTimeUnknown) {
                (void) utime(dstfile, &ut);
            }
            cip->bytesTransferred += (longest_int) nread;
            FTPUpdateIOTimer(cip);
        }
    }

#if ASCII_TRANSLATION
brk:
#endif

#if !defined(NO_SIGNALS)
    if (cip->xferTimeout > 0)
        (void) alarm(0);
    gCanBrokenDataJmp = 0;
#endif  /* NO_SIGNALS */

    if (fdtouse < 0) {
        /* If they gave us a descriptor (fdtouse >= 0),
         * leave it open, otherwise we opened it, so
         * we need to close it.
         */
        (void) close(fd);
        fd = -1;
    }

    tmpResult = FTPEndDataCmd(cip, 1);
    if ((tmpResult < 0) && (result == 0)) {
        result = kErrRETRFailed;
        cip->errNo = kErrRETRFailed;
    }
    FTPStopIOTimer(cip);
#if !defined(NO_SIGNALS)
    (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
#endif  /* NO_SIGNALS */

    if ((mdtm != kModTimeUnknown) && (cip->bytesTransferred > 0)) {
        (void) utime(dstfile, &ut);
    }

    if (result == kNoErr) {
        cip->numDownloads++;

        if (deleteflag == kDeleteYes) {
            result = FTPDelete(cip, file, kRecursiveNo, kGlobNo);
        }
    }

    return (result);
}   /* FTPGetOneF */




int
FTPGetOneFile3(
    const FTPCIPtr cip,
    const char *const file,
    const char *const dstfile,
    const int xtype,
    const int fdtouse,
    const int resumeflag,
    const int appendflag,
    const int deleteflag,
    const ConfirmResumeDownloadProc resumeProc,
    int UNUSED(reserved))
{
    int result;

    LIBNCFTP_USE_VAR(reserved);
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);

    if ((file == NULL) || (file[0] == '\0'))
        return (kErrBadParameter);
    if (fdtouse < 0) {
        if ((dstfile == NULL) || (dstfile[0] == '\0'))
            return (kErrBadParameter);
    }

    result = FTPGetOneF(cip, file, dstfile, xtype, fdtouse, kSizeUnknown, kModTimeUnknown, resumeflag, appendflag, deleteflag, resumeProc);
    return (result);
}   /* FTPGetOneFile3 */




int
FTPGetFiles3(
    const FTPCIPtr cip,
    const char *pattern1,
    const char *const dstdir1,
    const int recurse,
    int doGlob,
    const int xtype,
    const int resumeflag,
    int appendflag,
    const int deleteflag,
    const int tarflag,
    const ConfirmResumeDownloadProc resumeProc,
    int UNUSED(reserved))
{
    LineList globList;
    LinePtr itemPtr;
    FileInfoList files;
    FileInfoPtr filePtr;
    int batchResult;
    int result;
    char *ldir;
    char *cp;
    const char *dstdir;
    const char *pattern;
    char *pattern2, *dstdir2;
    char c;
    int recurse1;
    int errRc;

    LIBNCFTP_USE_VAR(reserved);
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
    if (pattern1 == NULL)
        return (kErrBadParameter);

    dstdir2 = NULL;
    pattern2 = NULL;

    if (dstdir1 == NULL) {
        dstdir = NULL;
    } else {
        dstdir2 = StrDup(dstdir1);
        if (dstdir2 == NULL) {
            errRc = kErrMallocFailed;
            goto return_err;
        }
        StrRemoveTrailingLocalPathDelim(dstdir2);
        dstdir = dstdir2;
    }

    pattern2 = StrDup(pattern1);
    if (pattern2 == NULL) {
        errRc = kErrMallocFailed;
        goto return_err;
    }
    StrRemoveTrailingSlashes(pattern2);
    pattern = pattern2;

    if (pattern[0] == '\0') {
        if (recurse == kRecursiveNo) {
            errRc = kErrBadParameter;
            goto return_err;
        }
        pattern = ".";
        doGlob = kGlobNo;
    } else if (strcmp(pattern, ".") == 0) {
        if (recurse == kRecursiveNo) {
            errRc = kErrBadParameter;
            goto return_err;
        }
        doGlob = kGlobNo;
    }
    if (recurse == kRecursiveYes)
        appendflag = kAppendNo;

    batchResult = FTPRemoteGlob(cip, &globList, pattern, doGlob);
    if (batchResult != kNoErr) {
        errRc = batchResult;
        goto return_err;
    }

    cip->cancelXfer = 0;    /* should already be zero */

    for (itemPtr = globList.first; itemPtr != NULL; itemPtr = itemPtr->next) {
        if ((recurse == kRecursiveYes) && (FTPIsDir(cip, itemPtr->line) > 0)) {
#ifdef TAR
            if ((tarflag == kTarYes) && (xtype == kTypeBinary) && (appendflag == kAppendNo) && (deleteflag == kDeleteNo) && (FTPGetOneTarF(cip, itemPtr->line, dstdir) == kNoErr)) {
                /* Great! */
                continue;
            }
#endif  /* TAR */
            (void) FTPRemoteRecursiveFileList1(cip, itemPtr->line, &files);
            (void) ComputeLNames(&files, itemPtr->line, dstdir, 1);
            recurse1 = recurse;
        } else {
            recurse1 = kRecursiveNo;
            (void) LineToFileInfoList(itemPtr, &files);
            (void) ComputeRNames(&files, ".", 0, 1);
            (void) ComputeLNames(&files, NULL, dstdir, 0);
        }
        if (cip->cancelXfer > 0) {
            DisposeFileInfoListContents(&files);
            break;
        }

#if 0
        for (filePtr = files.first; filePtr != NULL; filePtr = filePtr->next) {
            PrintF(cip, "  R=%s, L=%s, 2=%s, size=%d, mdtm=%u, type=%c\n",
                filePtr->rname,
                filePtr->lname,
                filePtr->rlinkto ? filePtr->rlinkto : "",
                filePtr->size,
                (unsigned int) filePtr->mdtm,
                filePtr->type
            );
        }
#endif


        for (filePtr = files.first; filePtr != NULL; filePtr = filePtr->next) {
            if (cip->connected == 0) {
                if (batchResult == kNoErr)
                    batchResult = kErrRemoteHostClosedConnection;
                break;
            }
            if (filePtr->type == 'd') {
#if defined(WIN32) || defined(_WINDOWS)
                (void) MkDirs(filePtr->lname, 00777);
#else
                (void) mkdir(filePtr->lname, 00777);
#endif
            } else if (filePtr->type == 'l') {
                /* skip it -- we do that next pass. */
            } else if (recurse1 != kRecursiveYes) {
                result = FTPGetOneF(cip, filePtr->rname, filePtr->lname, xtype, -1, filePtr->size, filePtr->mdtm, resumeflag, appendflag, deleteflag, resumeProc);
                if (files.nFileInfos == 1) {
                    if (result != kNoErr)
                        batchResult = result;
                } else {
                    if ((result != kNoErr) && (result != kErrLocalFileNewer) && (result != kErrRemoteFileNewer) && (result != kErrLocalSameAsRemote))
                        batchResult = result;
                }
                if (result == kErrUserCanceled)
                    cip->cancelXfer = 1;
                if (cip->cancelXfer > 0)
                    break;
            } else {
                ldir = filePtr->lname;
                cp = StrRFindLocalPathDelim(ldir);
                if (cp != NULL) {
                    while (cp > ldir) {
                        if (! IsLocalPathDelim(*cp)) {
                            ++cp;
                            break;
                        }
                        --cp;
                    }
                    if (cp > ldir) {
                        c = *cp;
                        *cp = '\0';
                        if (MkDirs(ldir, 00777) < 0) {
                            Error(cip, kDoPerror, "Could not create local directory \"%s\"\n", ldir);
                            batchResult = kErrGeneric;
                            *cp = c;
                            continue;
                        }
                        *cp = c;
                    }
                }
                result = FTPGetOneF(cip, filePtr->rname, filePtr->lname, xtype, -1, filePtr->size, filePtr->mdtm, resumeflag, appendflag, deleteflag, resumeProc);

                if (files.nFileInfos == 1) {
                    if (result != kNoErr)
                        batchResult = result;
                } else {
                    if ((result != kNoErr) && (result != kErrLocalFileNewer) && (result != kErrRemoteFileNewer) && (result != kErrLocalSameAsRemote))
                        batchResult = result;
                }
                if (result == kErrUserCanceled)
                    cip->cancelXfer = 1;
                if (cip->cancelXfer > 0)
                    break;
            }
        }
        if (cip->cancelXfer > 0) {
            DisposeFileInfoListContents(&files);
            break;
        }

#ifdef HAVE_SYMLINK
        for (filePtr = files.first; filePtr != NULL; filePtr = filePtr->next) {
            if (filePtr->type == 'l') {
                (void) unlink(filePtr->lname);
                if (symlink(filePtr->rlinkto, filePtr->lname) < 0) {
                    Error(cip, kDoPerror, "Could not symlink %s to %s\n", filePtr->rlinkto, filePtr->lname);
                    /* Note: not worth setting batchResult */
                }
            }
        }
#endif  /* HAVE_SYMLINK */


        DisposeFileInfoListContents(&files);
    }

    DisposeLineListContents(&globList);
    if (batchResult < 0)
        cip->errNo = batchResult;
    errRc = batchResult;

return_err:
    if (dstdir2 != NULL)
        free(dstdir2);
    if (pattern2 != NULL)
        free(pattern2);
    return (errRc);
}   /* FTPGetFiles3 */




/*------------------------- wrappers for old routines ----------------------*/

int
FTPGetOneFile(const FTPCIPtr cip, const char *const file, const char *const dstfile)
{
    return (FTPGetOneFile3(cip, file, dstfile, kTypeBinary, -1, kResumeNo, kAppendNo, kDeleteNo, (ConfirmResumeDownloadProc) 0, 0));
}   /* FTPGetOneFile */




int
FTPGetOneFile2(const FTPCIPtr cip, const char *const file, const char *const dstfile, const int xtype, const int fdtouse, const int resumeflag, const int appendflag)
{
    return (FTPGetOneFile3(cip, file, dstfile, xtype, fdtouse, resumeflag, appendflag, kDeleteNo, (ConfirmResumeDownloadProc) 0, 0));
}   /* FTPGetOneFile2 */




int
FTPGetFiles(const FTPCIPtr cip, const char *const pattern, const char *const dstdir, const int recurse, const int doGlob)
{
    return (FTPGetFiles3(cip, pattern, dstdir, recurse, doGlob, kTypeBinary, kResumeNo, kAppendNo, kDeleteNo, kTarYes, (ConfirmResumeDownloadProc) 0, 0));
}   /* FTPGetFiles */




int
FTPGetFiles2(const FTPCIPtr cip, const char *const pattern, const char *const dstdir, const int recurse, const int doGlob, const int xtype, const int resumeflag, const int appendflag)
{
    return (FTPGetFiles3(cip, pattern, dstdir, recurse, doGlob, xtype, resumeflag, appendflag, kDeleteNo, kTarYes, (ConfirmResumeDownloadProc) 0, 0));
}   /* FTPGetFiles2 */




int
FTPGetOneFileAscii(const FTPCIPtr cip, const char *const file, const char *const dstfile)
{
    return (FTPGetOneFile3(cip, file, dstfile, kTypeAscii, -1, kResumeNo, kAppendNo, kDeleteNo, (ConfirmResumeDownloadProc) 0, 0));
}   /* FTPGetOneFileAscii */




int
FTPGetFilesAscii(const FTPCIPtr cip, const char *const pattern, const char *const dstdir, const int recurse, const int doGlob)
{
    return (FTPGetFiles3(cip, pattern, dstdir, recurse, doGlob, kTypeAscii, kResumeNo, kAppendNo, kDeleteNo, kTarNo, (ConfirmResumeDownloadProc) 0, 0));
}   /* FTPGetFilesAscii */




int
FTPPutOneFile(const FTPCIPtr cip, const char *const file, const char *const dstfile)
{
    return (FTPPutOneFile3(cip, file, dstfile, kTypeBinary, -1, 0, NULL, NULL, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
}   /* FTPPutOneFile */




int
FTPPutOneFile2(const FTPCIPtr cip, const char *const file, const char *const dstfile, const int xtype, const int fdtouse, const int appendflag, const char *const tmppfx, const char *const tmpsfx)
{
    return (FTPPutOneFile3(cip, file, dstfile, xtype, fdtouse, appendflag, tmppfx, tmpsfx, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
}   /* FTPPutOneFile2 */




int
FTPPutFiles(const FTPCIPtr cip, const char *const pattern, const char *const dstdir, const int recurse, const int doGlob)
{
    return (FTPPutFiles3(cip, pattern, dstdir, recurse, doGlob, kTypeBinary, 0, NULL, NULL, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
}   /* FTPPutFiles */




int
FTPPutFiles2(const FTPCIPtr cip, const char *const pattern, const char *const dstdir, const int recurse, const int doGlob, const int xtype, const int appendflag, const char *const tmppfx, const char *const tmpsfx)
{
    return (FTPPutFiles3(cip, pattern, dstdir, recurse, doGlob, xtype, appendflag, tmppfx, tmpsfx, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
}   /* FTPPutFiles2 */




int
FTPPutOneFileAscii(const FTPCIPtr cip, const char *const file, const char *const dstfile)
{
    return (FTPPutOneFile3(cip, file, dstfile, kTypeAscii, -1, 0, NULL, NULL, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
}   /* FTPPutOneFileAscii */




int
FTPPutFilesAscii(const FTPCIPtr cip, const char *const pattern, const char *const dstdir, const int recurse, const int doGlob)
{
    return (FTPPutFiles3(cip, pattern, dstdir, recurse, doGlob, kTypeAscii, 0, NULL, NULL, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
}   /* FTPPutFilesAscii */



int
FTPListToMemory(const FTPCIPtr cip, const char *const pattern, const LineListPtr llines, const char *const lsflags)
{
    return (FTPListToMemory2(cip, pattern, llines, lsflags, 1, (int *) 0));
}   /* FTPListToMemory */

/* eof IO.c */