--- /dev/null
+/* rcmd.c
+ *
+ * Copyright (c) 1996-2001 Mike Gleason, NCEMRSoft.
+ * All rights reserved.
+ *
+ */
+
+#include "syshdrs.h"
+
+#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 gBrokenCtrlJmp;
+#else
+static jmp_buf gBrokenCtrlJmp;
+#endif /* HAVE_SIGSETJMP */
+
+static void
+BrokenCtrl(int UNUSED(signumIgnored))
+{
+ LIBNCFTP_USE_VAR(signumIgnored); /* Shut up gcc */
+#ifdef HAVE_SIGSETJMP
+ siglongjmp(gBrokenCtrlJmp, 1);
+#else
+ longjmp(gBrokenCtrlJmp, 1);
+#endif /* HAVE_SIGSETJMP */
+} /* BrokenCtrl */
+
+#endif /* NO_SIGNALS */
+
+
+/* A 'Response' parameter block is simply zeroed to be considered init'ed. */
+ResponsePtr
+InitResponse(void)
+{
+ ResponsePtr rp;
+
+ rp = (ResponsePtr) calloc(SZ(1), sizeof(Response));
+ if (rp != NULL)
+ InitLineList(&rp->msg);
+ return (rp);
+} /* InitResponse */
+
+
+
+
+/* If we don't print it to the screen, we may want to save it to our
+ * trace log.
+ */
+void
+TraceResponse(const FTPCIPtr cip, ResponsePtr rp)
+{
+ 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 */
+
+
+
+
+
+void
+PrintResponse(const FTPCIPtr cip, LineListPtr llp)
+{
+ LinePtr lp;
+
+ if (llp != NULL) {
+ for (lp = llp->first; lp != NULL; lp = lp->next)
+ PrintF(cip, "%s\n", lp->line);
+ }
+} /* PrintResponse */
+
+
+
+
+
+static void
+SaveLastResponse(const FTPCIPtr cip, ResponsePtr rp)
+{
+ 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 */
+
+
+
+void
+DoneWithResponse(const FTPCIPtr cip, ResponsePtr rp)
+{
+ /* 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 */
+
+
+
+
+/* This takes an existing Response and recycles it, by clearing out
+ * the current contents.
+ */
+void
+ReInitResponse(const FTPCIPtr cip, ResponsePtr rp)
+{
+ 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 */
+
+
+
+
+#ifndef NO_SIGNALS
+
+/* Since the control stream is defined by the Telnet protocol (RFC 854),
+ * we follow Telnet rules when reading the control stream. We use this
+ * routine when we want to read a response from the host.
+ */
+int
+GetTelnetString(const FTPCIPtr cip, char *str, size_t siz, FILE *cin, FILE *cout)
+{
+ int c;
+ size_t n;
+ int eofError;
+ char *cp;
+
+ cp = str;
+ --siz; /* We'll need room for the \0. */
+
+ if ((cin == NULL) || (cout == NULL)) {
+ eofError = -1;
+ goto done;
+ }
+
+ for (n = (size_t)0, eofError = 0; ; ) {
+ c = fgetc(cin);
+checkChar:
+ if (c == EOF) {
+eof:
+ eofError = -1;
+ break;
+ } else if (c == '\r') {
+ /* A telnet string can have a CR by itself. But to denote that,
+ * the protocol uses \r\0; an end of line is denoted \r\n.
+ */
+ c = fgetc(cin);
+ if (c == '\n') {
+ /* Had \r\n, so done. */
+ goto done;
+ } else if (c == EOF) {
+ goto eof;
+ } else if (c == '\0') {
+ c = '\r';
+ goto addChar;
+ } else {
+ /* Telnet protocol violation! */
+ goto checkChar;
+ }
+ } else if (c == '\n') {
+ /* Really shouldn't get here. If we do, the other side
+ * violated the TELNET protocol, since eoln's are CR/LF,
+ * and not just LF.
+ */
+ PrintF(cip, "TELNET protocol violation: raw LF.\n");
+ goto done;
+ } else if (c == IAC) {
+ /* Since the control connection uses the TELNET protocol,
+ * we have to handle some of its commands ourselves.
+ * IAC is the protocol's escape character, meaning that
+ * the next character after the IAC (Interpret as Command)
+ * character is a telnet command. But, if there just
+ * happened to be a character in the text stream with the
+ * same numerical value of IAC, 255, the sender denotes
+ * that by having an IAC followed by another IAC.
+ */
+
+ /* Get the telnet command. */
+ c = fgetc(cin);
+
+ switch (c) {
+ case WILL:
+ case WONT:
+ /* Get the option code. */
+ c = fgetc(cin);
+
+ /* Tell the other side that we don't want
+ * to do what they're offering to do.
+ */
+ (void) fprintf(cout, "%c%c%c",IAC,DONT,c);
+ (void) fflush(cout);
+ break;
+ case DO:
+ case DONT:
+ /* Get the option code. */
+ c = fgetc(cin);
+
+ /* The other side said they are DOing (or not)
+ * something, which would happen if our side
+ * asked them to. Since we didn't do that,
+ * ask them to not do this option.
+ */
+ (void) fprintf(cout, "%c%c%c",IAC,WONT,c);
+ (void) fflush(cout);
+ break;
+
+ case EOF:
+ goto eof;
+
+ default:
+ /* Just add this character, since it was most likely
+ * just an escaped IAC character.
+ */
+ goto addChar;
+ }
+ } else {
+addChar:
+ /* If the buffer supplied has room, add this character to it. */
+ if (n < siz) {
+ *cp++ = c;
+ ++n;
+ }
+ }
+ }
+
+done:
+ *cp = '\0';
+ return (eofError);
+} /* GetTelnetString */
+
+#endif /* NO_SIGNALS */
+
+
+
+/* Returns 0 if a response was read, or (-1) if an error occurs.
+ * This reads the entire response text into a LineList, which is kept
+ * in the 'Response' structure.
+ */
+int
+GetResponse(const FTPCIPtr cip, ResponsePtr rp)
+{
+ 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 */
+
+
+
+
+/* This creates the complete command text to send, and writes it
+ * on the stream.
+ */
+#ifdef NO_SIGNALS
+
+static int
+SendCommand(const FTPCIPtr cip, const char *cmdspec, va_list ap)
+{
+ 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 */
+
+#else /* NO_SIGNALS */
+
+static int
+SendCommand(const FTPCIPtr cip, const char *cmdspec, va_list ap)
+{
+ longstring command;
+ int result;
+ volatile FTPCIPtr vcip;
+ volatile FTPSigProc osigpipe;
+ int sj;
+
+ if (cip->cout != NULL) {
+#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;
+
+ 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);
+ if (vcip->eofOkay == 0) {
+ Error(cip, kDontPerror, "Remote host has closed the connection.\n");
+ vcip->errNo = kErrRemoteHostClosedConnection;
+ return(vcip->errNo);
+ }
+ return (kNoErr);
+ }
+
+ result = fputs(command, cip->cout);
+ if (result < 0) {
+ (void) signal(SIGPIPE, osigpipe);
+ cip->errNo = kErrSocketWriteFailed;
+ Error(cip, kDoPerror, "Could not write to control stream.\n");
+ return (cip->errNo);
+ }
+ result = fflush(cip->cout);
+ if (result < 0) {
+ (void) signal(SIGPIPE, osigpipe);
+ cip->errNo = kErrSocketWriteFailed;
+ Error(cip, kDoPerror, "Could not write to control stream.\n");
+ return (cip->errNo);
+ }
+ (void) signal(SIGPIPE, osigpipe);
+ return (kNoErr);
+ }
+ return (kErrNotConnected);
+} /* SendCommand */
+#endif /* NO_SIGNALS */
+
+
+
+/* For "simple" (i.e. not data transfer) commands, this routine is used
+ * to send the command and receive one response. It returns the codeType
+ * field of the 'Response' as the result, or a negative number upon error.
+ */
+/*VARARGS*/
+int
+FTPCmd(const FTPCIPtr cip, const char *const cmdspec, ...)
+{
+ 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 */
+
+
+
+
+/* This is for debugging the library -- don't use. */
+/*VARARGS*/
+int
+FTPCmdNoResponse(const FTPCIPtr cip, const char *const cmdspec, ...)
+{
+ 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 */
+
+
+
+
+int
+WaitResponse(const FTPCIPtr cip, unsigned int sec)
+{
+ 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 */
+
+
+
+
+/* For "simple" (i.e. not data transfer) commands, this routine is used
+ * to send the command and receive one response. It returns the codeType
+ * field of the 'Response' as the result, or a negative number upon error.
+ */
+
+/*VARARGS*/
+int
+RCmd(const FTPCIPtr cip, ResponsePtr rp, const char *cmdspec, ...)
+{
+ 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 */
+
+
+
+/* Returns -1 if an error occurred, or 0 if not.
+ * This differs from RCmd, which returns the code class of a response.
+ */
+
+/*VARARGS*/
+int
+FTPStartDataCmd(const FTPCIPtr cip, int netMode, int type, longest_int startPoint, const char *cmdspec, ...)
+{
+ 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 */
+
+
+
+
+void
+FTPAbortDataTransfer(const FTPCIPtr cip)
+{
+ 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 */
+
+
+
+
+int
+FTPEndDataCmd(const FTPCIPtr cip, int didXfer)
+{
+ 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 */
+
+
+
+
+int
+BufferGets(char *buf, size_t bufsize, int inStream, char *secondaryBuf, char **secBufPtr, char **secBufLimit, size_t secBufSize)
+{
+ 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 */
+
+/* eof */
projects / reactos.git / blobdiff