rcmd.c File Reference

#include "syshdrs.h"

Include dependency graph for rcmd.c:

Go to the source code of this file.

Functions
ResponsePtr	InitResponse (void)
void	TraceResponse (const FTPCIPtr cip, ResponsePtr rp)
void	PrintResponse (const FTPCIPtr cip, LineListPtr llp)
static void	SaveLastResponse (const FTPCIPtr cip, ResponsePtr rp)
void	DoneWithResponse (const FTPCIPtr cip, ResponsePtr rp)
void	ReInitResponse (const FTPCIPtr cip, ResponsePtr rp)
int	GetResponse (const FTPCIPtr cip, ResponsePtr rp)
static int	SendCommand (const FTPCIPtr cip, const char *cmdspec, va_list ap)
int	FTPCmd (const FTPCIPtr cip, const char *const cmdspec,...)
int	FTPCmdNoResponse (const FTPCIPtr cip, const char *const cmdspec,...)
int	WaitResponse (const FTPCIPtr cip, unsigned int sec)
int	RCmd (const FTPCIPtr cip, ResponsePtr rp, const char *cmdspec,...)
int	FTPStartDataCmd (const FTPCIPtr cip, int netMode, int type, longest_int startPoint, const char *cmdspec,...)
void	FTPAbortDataTransfer (const FTPCIPtr cip)
int	FTPEndDataCmd (const FTPCIPtr cip, int didXfer)
int	BufferGets (char *buf, size_t bufsize, int inStream, char *secondaryBuf, char **secBufPtr, char **secBufLimit, size_t secBufSize)

Function Documentation

BufferGets()

int BufferGets	(	char *	buf,
		size_t	bufsize,
		int	inStream,
		char *	secondaryBuf,
		char **	secBufPtr,
		char **	secBufLimit,
		size_t	secBufSize
	)

Definition at line 978 of file rcmd.c.

{
    int err;
    char *src;
    char *dst;
    char *dstlim;
    int len;
    int nr;
    int haveEof = 0;
 
    err = 0;
    dst = buf;
    dstlim = dst + bufsize - 1;     /* Leave room for NUL. */
    src = (*secBufPtr);
    for ( ; dst < dstlim; ) {
        if (src >= (*secBufLimit)) {
            /* Fill the buffer. */
 
/* Don't need to poll it here.  The routines that use BufferGets don't
 * need any special processing during timeouts (i.e. progress reports),
 * so go ahead and just let it block until there is data to read.
 */
            nr = (int) read(inStream, secondaryBuf, secBufSize);
            if (nr == 0) {
                /* EOF. */
                haveEof = 1;
                goto done;
            } else if (nr < 0) {
                /* Error. */
                err = -1;
                goto done;
            }
            (*secBufPtr) = secondaryBuf;
            (*secBufLimit) = secondaryBuf + nr;
            src = (*secBufPtr);
            if (nr < (int) secBufSize)
                src[nr] = '\0';
        }
        if (*src == '\r') {
            ++src;
        } else {
            if (*src == '\n') {
                /* *dst++ = *src++; */  ++src;
                goto done;
            }
            *dst++ = *src++;
        }
    }
 
done:
    (*secBufPtr) = src;
    *dst = '\0';
    len = (int) (dst - buf);
    if (err < 0)
        return (err);
    if ((len == 0) && (haveEof == 1))
        return (-1);
    return (len);   /* May be zero, if a blank line. */
}   /* BufferGets */

Referenced by FTPList(), and FTPListToMemory2().

DoneWithResponse()

void DoneWithResponse	(	const FTPCIPtr	cip,
		ResponsePtr	rp
	)

Definition at line 114 of file rcmd.c.

{
    /* Dispose space taken up by the Response, and clear it out
     * again.  For some reason, I like to return memory to zeroed
     * when not in use.
     */
    if (rp != NULL) {
        TraceResponse(cip, rp);
        if (cip->printResponseProc != 0) {
            if ((rp->printMode & kResponseNoProc) == 0)
                (*cip->printResponseProc)(cip, rp);
        }
        if ((rp->printMode & kResponseNoSave) == 0)
            SaveLastResponse(cip, rp);
        else
            DisposeLineListContents(&rp->msg);
        (void) memset(rp, 0, sizeof(Response));
        free(rp);
    }
}   /* DoneWithResponse */

Referenced by FTPAbortDataTransfer(), FTPChdirAndGetCWD(), FTPCloseHost(), FTPCmd(), FTPEndDataCmd(), FTPFileExistsStat(), FTPFileModificationTime(), FTPFileSize(), FTPGetCWD(), FTPLoginHost(), FTPMListOneFile(), FTPQueryFeatures(), FTPRemoteHelp(), FTPStartDataCmd(), FTPUtime(), nFTPChdirAndGetCWD(), OpenControlConnection(), Passive(), SendPort(), and SetStartOffset().

FTPAbortDataTransfer()

void FTPAbortDataTransfer

(

const FTPCIPtr

cip

)

Definition at line 870 of file rcmd.c.

{
    ResponsePtr rp;
    int result;
 
    if (cip->dataSocket != kClosedFileDescriptor) {
        PrintF(cip, "Starting abort sequence.\n");
        SendTelnetInterrupt(cip);       /* Probably could get by w/o doing this. */
 
        result = FTPCmdNoResponse(cip, "ABOR");
        if (result != kNoErr) {
            /* Linger could cause close to block, so unset it. */
            (void) SetLinger(cip, cip->dataSocket, 0);
            CloseDataConnection(cip);
            PrintF(cip, "Could not send abort command.\n");
            return;
        }
 
        if (cip->abortTimeout > 0) {
            result = WaitResponse(cip, (unsigned int) cip->abortTimeout);
            if (result <= 0) {
                /* Error or no response received to ABOR in time. */
                (void) SetLinger(cip, cip->dataSocket, 0);
                CloseDataConnection(cip);
                PrintF(cip, "No response received to abort request.\n");
                return;
            }
        }
 
        rp = InitResponse();
        if (rp == NULL) {
            Error(cip, kDontPerror, "Malloc failed.\n");
            cip->errNo = kErrMallocFailed;
            result = cip->errNo;
            return;
        }
 
        result = GetResponse(cip, rp);
        if (result < 0) {
            /* Shouldn't happen, and doesn't matter if it does. */
            (void) SetLinger(cip, cip->dataSocket, 0);
            CloseDataConnection(cip);
            PrintF(cip, "Invalid response to abort request.\n");
            DoneWithResponse(cip, rp);
            return;
        }
        DoneWithResponse(cip, rp);
 
        /* A response to the abort request has been received.
         * Now the only thing left to do is close the data
         * connection, making sure to turn off linger mode
         * since we don't care about straggling data bits.
         */
        (void) SetLinger(cip, cip->dataSocket, 0);
        CloseDataConnection(cip);       /* Must close (by protocol). */
        PrintF(cip, "End abort.\n");
    }
}   /* FTPAbortDataTransfer */

Referenced by FTPCloseHost(), FTPGetOneF(), and FTPPutOneF().

FTPCmd()

int FTPCmd	(	const FTPCIPtr	cip,
		const char *const	cmdspec,
			...
	)

Definition at line 603 of file rcmd.c.

{
    va_list ap;
    int result;
    ResponsePtr rp;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    rp = InitResponse();
    if (rp == NULL) {
        result = kErrMallocFailed;
        cip->errNo = kErrMallocFailed;
        Error(cip, kDontPerror, "Malloc failed.\n");
        return (cip->errNo);
    }
 
    va_start(ap, cmdspec);
#ifndef NO_SIGNALS
    if (cip->ctrlTimeout > 0)
        (void) alarm(cip->ctrlTimeout);
#endif  /* NO_SIGNALS */
    result = SendCommand(cip, cmdspec, ap);
    va_end(ap);
    if (result < 0) {
#ifndef NO_SIGNALS
        if (cip->ctrlTimeout > 0)
            (void) alarm(0);
#endif  /* NO_SIGNALS */
        return (result);
    }
 
    /* Get the response to the command we sent. */
    result = GetResponse(cip, rp);
#ifndef NO_SIGNALS
    if (cip->ctrlTimeout > 0)
        (void) alarm(0);
#endif  /* NO_SIGNALS */
 
    if (result == kNoErr)
        result = rp->codeType;
    DoneWithResponse(cip, rp);
    return (result);
}   /* FTPCmd */

Referenced by DoOpen(), FTPChdir(), FTPChdir3(), FTPChmod(), FTPDelete(), FTPGetOneF(), FTPMkdir2(), FTPPutOneF(), FTPRename(), FTPRequestMlsOptions(), FTPRmdir(), FTPSetTransferType(), FTPSymlink(), FTPUmask(), QuoteCmd(), and SiteCmd().

FTPCmdNoResponse()

int FTPCmdNoResponse	(	const FTPCIPtr	cip,
		const char *const	cmdspec,
			...
	)

Definition at line 656 of file rcmd.c.

{
    va_list ap;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    va_start(ap, cmdspec);
#ifndef NO_SIGNALS
    if (cip->ctrlTimeout > 0)
        (void) alarm(cip->ctrlTimeout);
#endif  /* NO_SIGNALS */
    (void) SendCommand(cip, cmdspec, ap);
#ifndef NO_SIGNALS
    if (cip->ctrlTimeout > 0)
        (void) alarm(0);
#endif  /* NO_SIGNALS */
    va_end(ap);
 
    return (kNoErr);
}   /* FTPCmdNoResponse */

Referenced by FTPAbortDataTransfer().

FTPEndDataCmd()

int FTPEndDataCmd	(	const FTPCIPtr	cip,
		int	didXfer
	)

Definition at line 933 of file rcmd.c.

{
    int result;
    int respCode;
    ResponsePtr rp;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    CloseDataConnection(cip);
    result = kNoErr;
    if (didXfer) {
        /* Get the response to the data transferred.  Most likely a message
         * saying that the transfer completed succesfully.  However, if
         * we tried to abort the transfer using ABOR, we will have a response
         * to that command instead.
         */
        rp = InitResponse();
        if (rp == NULL) {
            Error(cip, kDontPerror, "Malloc failed.\n");
            cip->errNo = kErrMallocFailed;
            result = cip->errNo;
            return (result);
        }
        result = GetResponse(cip, rp);
        if (result < 0)
            return (result);
        respCode = rp->codeType;
        DoneWithResponse(cip, rp);
        if (respCode != 2) {
            cip->errNo = kErrDataTransferFailed;
            result = cip->errNo;
        } else {
            result = kNoErr;
        }
    }
    return (result);
}   /* FTPEndDataCmd */

Referenced by FTPGetOneF(), FTPList(), FTPListToMemory2(), FTPPutOneF(), and FTPStartDataCmd().

FTPStartDataCmd()

int FTPStartDataCmd	(	const FTPCIPtr	cip,
		int	netMode,
		int	type,
		longest_int	startPoint,
		const char *	cmdspec,
			...
	)

Definition at line 763 of file rcmd.c.

{
    va_list ap;
    int result;
    int respCode;
    ResponsePtr rp;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    result = FTPSetTransferType(cip, type);
    if (result < 0)
        return (result);
 
    /* Re-set the cancellation flag. */
    cip->cancelXfer = 0;
 
    /* To transfer data, we do these things in order as specifed by
     * the RFC.
     *
     * First, we tell the other side to set up a data line.  This
     * is done below by calling OpenDataConnection(), which sets up
     * the socket.  When we do that, the other side detects a connection
     * attempt, so it knows we're there.  Then tell the other side
     * (by using listen()) that we're willing to receive a connection
     * going to our side.
     */
 
    if ((result = OpenDataConnection(cip, cip->dataPortMode)) < 0)
        goto done;
 
    /* If asked, attempt to start at a later position in the remote file. */
    if (startPoint != (longest_int) 0) {
        if ((startPoint == kSizeUnknown) || ((result = SetStartOffset(cip, startPoint)) != 0))
            startPoint = (longest_int) 0;
    }
    cip->startPoint = startPoint;
 
    /* Now we tell the server what we want to do.  This sends the
     * the type of transfer we want (RETR, STOR, LIST, etc) and the
     * parameters for that (files to send, directories to list, etc).
     */
    va_start(ap, cmdspec);
#ifndef NO_SIGNALS
    if (cip->ctrlTimeout > 0)
        (void) alarm(cip->ctrlTimeout);
#endif  /* NO_SIGNALS */
    result = SendCommand(cip, cmdspec, ap);
    va_end(ap);
    if (result < 0) {
#ifndef NO_SIGNALS
        if (cip->ctrlTimeout > 0)
            (void) alarm(0);
#endif  /* NO_SIGNALS */
        goto done;
    }
 
    /* Get the response to the transfer command we sent, to see if
     * they can accomodate the request.  If everything went okay,
     * we will get a preliminary response saying that the transfer
     * initiation was successful and that the data is there for
     * reading (for retrieves;  for sends, they will be waiting for
     * us to send them something).
     */
    rp = InitResponse();
    if (rp == NULL) {
        Error(cip, kDontPerror, "Malloc failed.\n");
        cip->errNo = kErrMallocFailed;
        result = cip->errNo;
        goto done;
    }
    result = GetResponse(cip, rp);
#ifndef NO_SIGNALS
    if (cip->ctrlTimeout > 0)
        (void) alarm(0);
#endif  /* NO_SIGNALS */
 
    if (result < 0)
        goto done;
    respCode = rp->codeType;
    DoneWithResponse(cip, rp);
 
    if (respCode > 2) {
        cip->errNo = kErrCouldNotStartDataTransfer;
        result = cip->errNo;
        goto done;
    }
 
    /* Now we accept the data connection that the other side is offering
     * to us.  Then we can do the actual I/O on the data we want.
     */
    cip->netMode = netMode;
    if ((result = AcceptDataConnection(cip)) < 0)
        goto done;
    return (kNoErr);
 
done:
    (void) FTPEndDataCmd(cip, 0);
    return (result);
}   /* FTPStartDataCmd */

Referenced by FTPGetOneF(), FTPList(), FTPListToMemory2(), and FTPPutOneF().

GetResponse()

int GetResponse	(	const FTPCIPtr	cip,
		ResponsePtr	rp
	)

Definition at line 287 of file rcmd.c.

{
    longstring str;
    int eofError;
    str16 code;
    char *cp;
    int continuation;
    volatile FTPCIPtr vcip;
#ifdef NO_SIGNALS
    int result;
#else   /* NO_SIGNALS */
    volatile FTPSigProc osigpipe;
    int sj;
#endif  /* NO_SIGNALS */
 
    /* RFC 959 states that a reply may span multiple lines.  A single
     * line message would have the 3-digit code <space> then the msg.
     * A multi-line message would have the code <dash> and the first
     * line of the msg, then additional lines, until the last line,
     * which has the code <space> and last line of the msg.
     *
     * For example:
     *  123-First line
     *  Second line
     *  234 A line beginning with numbers
     *  123 The last line
     */
 
#ifdef NO_SIGNALS
    vcip = cip;
#else   /* NO_SIGNALS */
    osigpipe = (volatile FTPSigProc) signal(SIGPIPE, BrokenCtrl);
    vcip = cip;
 
#ifdef HAVE_SIGSETJMP
    sj = sigsetjmp(gBrokenCtrlJmp, 1);
#else
    sj = setjmp(gBrokenCtrlJmp);
#endif  /* HAVE_SIGSETJMP */
 
    if (sj != 0) {
        (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
        FTPShutdownHost(vcip);
        vcip->errNo = kErrRemoteHostClosedConnection;
        return(vcip->errNo);
    }
#endif  /* NO_SIGNALS */
 
#ifdef NO_SIGNALS
    cp = str;
    eofError = 0;
    if (cip->dataTimedOut > 0) {
        /* Give up immediately unless the server had already
         * sent a message. Odds are since the data is timed
         * out, so is the control.
         */
        if (SWaitUntilReadyForReading(cip->ctrlSocketR, 0) == 0) {
            /* timeout */
            Error(cip, kDontPerror, "Could not read reply from control connection -- timed out.\n");
            FTPShutdownHost(vcip);
            cip->errNo = kErrControlTimedOut;
            return (cip->errNo);
        }
    }
    result = SReadline(&cip->ctrlSrl, str, sizeof(str) - 1);
    if (result == kTimeoutErr) {
        /* timeout */
        Error(cip, kDontPerror, "Could not read reply from control connection -- timed out.\n");
        FTPShutdownHost(vcip);
        cip->errNo = kErrControlTimedOut;
        return (cip->errNo);
    } else if (result == 0) {
        /* eof */
        eofError = 1;
        rp->hadEof = 1;
        if (rp->eofOkay == 0)
            Error(cip, kDontPerror, "Remote host has closed the connection.\n");
        FTPShutdownHost(vcip);
        cip->errNo = kErrRemoteHostClosedConnection;
        return (cip->errNo);
    } else if (result < 0) {
        /* error */
        Error(cip, kDoPerror, "Could not read reply from control connection");
        FTPShutdownHost(vcip);
        cip->errNo = kErrInvalidReplyFromServer;
        return (cip->errNo);
    }
 
    if (str[result - 1] == '\n')
        str[result - 1] = '\0';
 
#else   /* NO_SIGNALS */
    /* Get the first line of the response. */
    eofError = GetTelnetString(cip, str, sizeof(str), cip->cin, cip->cout);
 
    cp = str;
    if (*cp == '\0') {
        if (eofError < 0) {
            /* No bytes read for reply, and EOF detected. */
            rp->hadEof = 1;
            if (rp->eofOkay == 0)
                Error(cip, kDontPerror, "Remote host has closed the connection.\n");
            FTPShutdownHost(vcip);
            cip->errNo = kErrRemoteHostClosedConnection;
            (void) signal(SIGPIPE, osigpipe);
            return(cip->errNo);
        }
    }
#endif  /* NO_SIGNALS */
 
    if (!isdigit((int) *cp)) {
        Error(cip, kDontPerror, "Invalid reply: \"%s\"\n", cp);
        cip->errNo = kErrInvalidReplyFromServer;
#ifndef NO_SIGNALS
        (void) signal(SIGPIPE, osigpipe);
#endif
        return (cip->errNo);
    }
 
    rp->codeType = *cp - '0';
    cp += 3;
    continuation = (*cp == '-');
    *cp++ = '\0';
    (void) STRNCPY(code, str);
    rp->code = atoi(code);
    (void) AddLine(&rp->msg, cp);
    if (eofError < 0) {
        /* Read reply, but EOF was there also. */
        rp->hadEof = 1;
    }
 
    while (continuation) {
 
#ifdef NO_SIGNALS
        result = SReadline(&cip->ctrlSrl, str, sizeof(str) - 1);
        if (result == kTimeoutErr) {
            /* timeout */
            Error(cip, kDontPerror, "Could not read reply from control connection -- timed out.\n");
            FTPShutdownHost(vcip);
            cip->errNo = kErrControlTimedOut;
            return (cip->errNo);
        } else if (result == 0) {
            /* eof */
            eofError = 1;
            rp->hadEof = 1;
            if (rp->eofOkay == 0)
                Error(cip, kDontPerror, "Remote host has closed the connection.\n");
            FTPShutdownHost(vcip);
            cip->errNo = kErrRemoteHostClosedConnection;
            return (cip->errNo);
        } else if (result < 0) {
            /* error */
            Error(cip, kDoPerror, "Could not read reply from control connection");
            FTPShutdownHost(vcip);
            cip->errNo = kErrInvalidReplyFromServer;
            return (cip->errNo);
        }
 
        if (str[result - 1] == '\n')
            str[result - 1] = '\0';
#else   /* NO_SIGNALS */
        eofError = GetTelnetString(cip, str, sizeof(str), cip->cin, cip->cout);
        if (eofError < 0) {
            /* Read reply, but EOF was there also. */
            rp->hadEof = 1;
            continuation = 0;
        }
#endif  /* NO_SIGNALS */
        cp = str;
        if (strncmp(code, cp, SZ(3)) == 0) {
            cp += 3;
            if (*cp == ' ')
                continuation = 0;
            ++cp;
        }
        (void) AddLine(&rp->msg, cp);
    }
 
    if (rp->code == 421) {
        /*
         *   421 Service not available, closing control connection.
         *       This may be a reply to any command if the service knows it
         *       must shut down.
         */
        if (rp->eofOkay == 0)
            Error(cip, kDontPerror, "Remote host has closed the connection.\n");
        FTPShutdownHost(vcip);
        cip->errNo = kErrRemoteHostClosedConnection;
#ifndef NO_SIGNALS
        (void) signal(SIGPIPE, osigpipe);
#endif
        return(cip->errNo);
    }
 
#ifndef NO_SIGNALS
    (void) signal(SIGPIPE, osigpipe);
#endif
    return (kNoErr);
}   /* GetResponse */

Referenced by FTPAbortDataTransfer(), FTPCmd(), FTPEndDataCmd(), FTPStartDataCmd(), OpenControlConnection(), and RCmd().

InitResponse()

ResponsePtr InitResponse

(

void

)

Definition at line 38 of file rcmd.c.

{
    ResponsePtr rp;
 
    rp = (ResponsePtr) calloc(SZ(1), sizeof(Response));
    if (rp != NULL)
        InitLineList(&rp->msg);
    return (rp);
}   /* InitResponse */

Referenced by FTPAbortDataTransfer(), FTPChdirAndGetCWD(), FTPCloseHost(), FTPCmd(), FTPEndDataCmd(), FTPFileExistsStat(), FTPFileModificationTime(), FTPFileSize(), FTPGetCWD(), FTPLoginHost(), FTPMListOneFile(), FTPQueryFeatures(), FTPRemoteHelp(), FTPStartDataCmd(), FTPUtime(), nFTPChdirAndGetCWD(), OpenControlConnection(), Passive(), SendPort(), and SetStartOffset().

PrintResponse()

void PrintResponse	(	const FTPCIPtr	cip,
		LineListPtr	llp
	)

Definition at line 74 of file rcmd.c.

{
    LinePtr lp;
 
    if (llp != NULL) {
        for (lp = llp->first; lp != NULL; lp = lp->next)
            PrintF(cip, "%s\n", lp->line);
    }
}   /* PrintResponse */

RCmd()

int RCmd	(	const FTPCIPtr	cip,
		ResponsePtr	rp,
		const char *	cmdspec,
			...
	)

Definition at line 718 of file rcmd.c.

{
    va_list ap;
    int result;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    va_start(ap, cmdspec);
#ifndef NO_SIGNALS
    if (cip->ctrlTimeout > 0)
        (void) alarm(cip->ctrlTimeout);
#endif  /* NO_SIGNALS */
    result = SendCommand(cip, cmdspec, ap);
    va_end(ap);
    if (result < 0) {
#ifndef NO_SIGNALS
        if (cip->ctrlTimeout > 0)
            (void) alarm(0);
#endif  /* NO_SIGNALS */
        return (result);
    }
 
    /* Get the response to the command we sent. */
    result = GetResponse(cip, rp);
#ifndef NO_SIGNALS
    if (cip->ctrlTimeout > 0)
        (void) alarm(0);
#endif  /* NO_SIGNALS */
 
    if (result == kNoErr)
        result = rp->codeType;
    return (result);
}   /* RCmd */

Referenced by FTPChdirAndGetCWD(), FTPCloseHost(), FTPFileExistsStat(), FTPFileModificationTime(), FTPFileSize(), FTPGetCWD(), FTPLoginHost(), FTPMListOneFile(), FTPQueryFeatures(), FTPRemoteHelp(), FTPUtime(), nFTPChdirAndGetCWD(), Passive(), SendPort(), and SetStartOffset().

ReInitResponse()

void ReInitResponse	(	const FTPCIPtr	cip,
		ResponsePtr	rp
	)

Definition at line 142 of file rcmd.c.

{
    if (rp != NULL) {
        TraceResponse(cip, rp);
        if (cip->printResponseProc != 0) {
            if ((rp->printMode & kResponseNoProc) == 0)
                (*cip->printResponseProc)(cip, rp);
        }
        if ((rp->printMode & kResponseNoSave) == 0)
            SaveLastResponse(cip, rp);
        else
            DisposeLineListContents(&rp->msg);
        (void) memset(rp, 0, sizeof(Response));
    }
}   /* ReInitResponse */

Referenced by FTPLoginHost(), and FTPQueryFeatures().

SaveLastResponse()

static void SaveLastResponse ( const FTPCIPtr  cip, ResponsePtr  rp  )

static

Definition at line 89 of file rcmd.c.

{
    if (rp == NULL) {
        cip->lastFTPCmdResultStr[0] = '\0';
        cip->lastFTPCmdResultNum = -1;
        DisposeLineListContents(&cip->lastFTPCmdResultLL);
    } else if ((rp->msg.first == NULL) || (rp->msg.first->line == NULL)) {
        cip->lastFTPCmdResultStr[0] = '\0';
        cip->lastFTPCmdResultNum = rp->code;
        DisposeLineListContents(&cip->lastFTPCmdResultLL);
    } else {
        (void) STRNCPY(cip->lastFTPCmdResultStr, rp->msg.first->line);
        cip->lastFTPCmdResultNum = rp->code;
 
        /* Dispose previous command's line list. */
        DisposeLineListContents(&cip->lastFTPCmdResultLL);
 
        /* Save this command's line list. */
        cip->lastFTPCmdResultLL = rp->msg;
    }
}   /* SaveLastResponse */

Referenced by DoneWithResponse(), and ReInitResponse().

SendCommand()

static int SendCommand ( const FTPCIPtr  cip, const char *  cmdspec, va_list  ap  )

static

Definition at line 496 of file rcmd.c.

{
    longstring command;
    int result;
 
    if (cip->ctrlSocketW != kClosedFileDescriptor) {
#ifdef HAVE_VSNPRINTF
        (void) vsnprintf(command, sizeof(command) - 1, cmdspec, ap);
        command[sizeof(command) - 1] = '\0';
#else
        (void) vsprintf(command, cmdspec, ap);
#endif
        if ((strncmp(command, "PASS", SZ(4)) != 0) || ((strcmp(cip->user, "anonymous") == 0) && (cip->firewallType == kFirewallNotInUse)))
            PrintF(cip, "Cmd: %s\n", command);
        else
            PrintF(cip, "Cmd: %s\n", "PASS xxxxxxxx");
        (void) STRNCAT(command, "\r\n");    /* Use TELNET end-of-line. */
        cip->lastFTPCmdResultStr[0] = '\0';
        cip->lastFTPCmdResultNum = -1;
 
        result = SWrite(cip->ctrlSocketW, command, strlen(command), (int) cip->ctrlTimeout, 0);
 
        if (result < 0) {
            cip->errNo = kErrSocketWriteFailed;
            Error(cip, kDoPerror, "Could not write to control stream.\n");
            return (cip->errNo);
        }
        return (kNoErr);
    }
    return (kErrNotConnected);
}   /* SendCommand */

Referenced by FTPCmd(), FTPCmdNoResponse(), FTPStartDataCmd(), and RCmd().

TraceResponse()

void TraceResponse	(	const FTPCIPtr	cip,
		ResponsePtr	rp
	)

Definition at line 55 of file rcmd.c.

{
    LinePtr lp;
 
    if (rp != NULL) {
        lp = rp->msg.first;
        if (lp != NULL) {
            PrintF(cip, "%3d: %s\n", rp->code, lp->line);
            for (lp = lp->next; lp != NULL; lp = lp->next)
                PrintF(cip, "     %s\n", lp->line);
        }
    }
}   /* TraceResponse */

Referenced by DoneWithResponse(), and ReInitResponse().

WaitResponse()

int WaitResponse	(	const FTPCIPtr	cip,
		unsigned int	sec
	)

Definition at line 684 of file rcmd.c.

{
    int result;
    fd_set ss;
    struct timeval tv;
    int fd;
 
#ifdef NO_SIGNALS
    fd = cip->ctrlSocketR;
#else   /* NO_SIGNALS */
    if (cip->cin == NULL)
        return (-1);
    fd = fileno(cip->cin);
#endif  /* NO_SIGNALS */
    if (fd < 0)
        return (-1);
    FD_ZERO(&ss);
    FD_SET(fd, &ss);
    tv.tv_sec = (unsigned long) sec;
    tv.tv_usec = 0;
    result = select(fd + 1, SELECT_TYPE_ARG234 &ss, NULL, NULL, &tv);
    return (result);
}   /* WaitResponse */

Referenced by FTPAbortDataTransfer().