ftp.c File Reference

#include "syshdrs.h"

Include dependency graph for ftp.c:

Go to the source code of this file.

Macros
#define	_libncftp_ftp_c_
#define	UC(x)   (int) (((int) x) & 0xff)

Functions
static struct hostent *	GetHostEntry (char *host, struct in_addr *ip_address)
int	GetOurHostName (char *host, size_t siz)
void	CloseControlConnection (const FTPCIPtr cip)
static int	GetSocketAddress (const FTPCIPtr cip, int sockfd, struct sockaddr_in *saddr)
int	SetKeepAlive (const FTPCIPtr cip, int sockfd)
int	SetLinger (const FTPCIPtr cip, int sockfd, int onoff)
int	OpenControlConnection (const FTPCIPtr cip, char *host, unsigned int port)
void	CloseDataConnection (const FTPCIPtr cip)
int	SetStartOffset (const FTPCIPtr cip, longest_int restartPt)
static int	SendPort (const FTPCIPtr cip, struct sockaddr_in *saddr)
static int	Passive (const FTPCIPtr cip, struct sockaddr_in *saddr, int *weird)
static int	BindToEphemeralPortNumber (int sockfd, struct sockaddr_in *addrp, int ephemLo, int ephemHi)
int	OpenDataConnection (const FTPCIPtr cip, int mode)
void	SetLinger (cip, dataSocket, 1)
void	SetKeepAlive (cip, dataSocket)
	return (0)
	return (result)
int	AcceptDataConnection (const FTPCIPtr cip)
void	HangupOnServer (const FTPCIPtr cip)
void	SendTelnetInterrupt (const FTPCIPtr cip)

Variables
char	gLibNcFTPVersion [64] = kLibraryVersion
char	gNoSignalsMarker [] = "@(#) LibNcFTP - NO_SIGNALS"
static char	gCopyright [] = "@(#) LibNcFTP Copyright 1995-2000, by Mike Gleason. All rights reserved."
cip	dataSocket = dataSocket
bad	__pad0__

Macro Definition Documentation

_libncftp_ftp_c_

#define _libncftp_ftp_c_

Definition at line 8 of file ftp.c.

UC

#define UC

(

x

)

(int) (((int) x) & 0xff)

Function Documentation

AcceptDataConnection()

int AcceptDataConnection

(

const FTPCIPtr

cip

)

Definition at line 1249 of file ftp.c.

{
    int newSocket;
#ifndef NO_SIGNALS
    int len;
#endif
    unsigned short remoteDataPort;
    unsigned short remoteCtrlPort;

    /* If we did a PORT, we have some things to finish up.
     * If we did a PASV, we're ready to go.
     */
    if (cip->dataPortMode == kSendPortMode) {
        /* Accept will give us back the server's data address;  at the
         * moment we don't do anything with it though.
         */
        memset(&cip->servDataAddr, 0, sizeof(cip->servDataAddr));

#ifdef NO_SIGNALS
        newSocket = SAccept(cip->dataSocket, &cip->servDataAddr, (int) cip->connTimeout);
#else   /* NO_SIGNALS */
        len = (int) sizeof(cip->servDataAddr);
        if (cip->connTimeout > 0)
            (void) alarm(cip->connTimeout);
        newSocket = accept(cip->dataSocket, (struct sockaddr *) &cip->servDataAddr, &len);
        if (cip->connTimeout > 0)
            (void) alarm(0);
#endif  /* NO_SIGNALS */

        (void) closesocket(cip->dataSocket);
        if (newSocket < 0) {
            Error(cip, kDoPerror, "Could not accept a data connection.\n");
            cip->dataSocket = kClosedFileDescriptor;
            cip->errNo = kErrAcceptDataSocket;
            return (kErrAcceptDataSocket);
        }

        if (cip->require20 != 0) {
            remoteDataPort = ntohs(cip->servDataAddr.sin_port);
            remoteCtrlPort = ntohs(cip->servCtlAddr.sin_port);
            if ((int) remoteDataPort != ((int) remoteCtrlPort - 1)) {
                Error(cip, kDontPerror, "Data connection did not originate on correct port!\n");
                (void) closesocket(newSocket);
                cip->dataSocket = kClosedFileDescriptor;
                cip->errNo = kErrAcceptDataSocket;
                return (kErrAcceptDataSocket);
            } else if (memcmp(&cip->servDataAddr.sin_addr.s_addr, &cip->servCtlAddr.sin_addr.s_addr, sizeof(cip->servDataAddr.sin_addr.s_addr)) != 0) {
                Error(cip, kDontPerror, "Data connection did not originate from remote server!\n");
                (void) closesocket(newSocket);
                cip->dataSocket = kClosedFileDescriptor;
                cip->errNo = kErrAcceptDataSocket;
                return (kErrAcceptDataSocket);
            }
        }

        cip->dataSocket = newSocket;
    }

    return (0);
}   /* AcceptDataConnection */

Referenced by FTPStartDataCmd().

BindToEphemeralPortNumber()

static int BindToEphemeralPortNumber ( int  sockfd, struct sockaddr_in *  addrp, int  ephemLo, int  ephemHi  )

static

Definition at line 1011 of file ftp.c.

{
    int i;
    int result;
    int rangesize;
    unsigned short port;

    addrp->sin_family = AF_INET;
    if (((int) ephemLo == 0) || ((int) ephemLo >= (int) ephemHi)) {
        /* Do it the normal way.  System will
         * pick one, typically in the range
         * of 1024-4999.
         */
        addrp->sin_port = 0;    /* Let system pick one. */

        result = bind(sockfd, (struct sockaddr *) addrp, sizeof(struct sockaddr_in));
    } else {
        rangesize = (int) ((int) ephemHi - (int) ephemLo);
        result = 0;
        for (i=0; i<10; i++) {
            port = (unsigned short) (((int) rand() % rangesize) + (int) ephemLo);
            addrp->sin_port = port;

            result = bind(sockfd, (struct sockaddr *) addrp, sizeof(struct sockaddr_in));
            if (result == 0)
                break;
            if ((errno != 999)
                /* This next line is just fodder to
                 * shut the compiler up about variable
                 * not being used.
                 */
                && (gCopyright[0] != '\0'))
                break;
        }
    }
    return (result);
}   /* BindToEphemeralPortNumber */

Referenced by OpenDataConnection().

CloseControlConnection()

void CloseControlConnection

(

const FTPCIPtr

cip

)

Definition at line 197 of file ftp.c.

{
    /* This will close each file, if it was open. */
#ifdef NO_SIGNALS
    SClose(cip->ctrlSocketR, 3);
    cip->ctrlSocketR = kClosedFileDescriptor;
    cip->ctrlSocketW = kClosedFileDescriptor;
    DisposeSReadlineInfo(&cip->ctrlSrl);
#else   /* NO_SIGNALS */
    if (cip->ctrlTimeout > 0)
        (void) alarm(cip->ctrlTimeout);
    CloseFile(&cip->cin);
    CloseFile(&cip->cout);
    cip->ctrlSocketR = kClosedFileDescriptor;
    cip->ctrlSocketW = kClosedFileDescriptor;
    if (cip->ctrlTimeout > 0)
        (void) alarm(0);
#endif  /* NO_SIGNALS */
    cip->connected = 0;
    cip->loggedIn = 0;
}   /* CloseControlConnection */

Referenced by FTPCloseHost(), FTPShutdownHost(), HangupOnServer(), and RunBatch().

CloseDataConnection()

void CloseDataConnection

(

const FTPCIPtr

cip

)

Definition at line 831 of file ftp.c.

{
    if (cip->dataSocket != kClosedFileDescriptor) {
#ifdef NO_SIGNALS
        SClose(cip->dataSocket, 3);
#else   /* NO_SIGNALS */
        if (cip->xferTimeout > 0)
            (void) alarm(cip->xferTimeout);
        (void) closesocket(cip->dataSocket);
        if (cip->xferTimeout > 0)
            (void) alarm(0);
#endif  /* NO_SIGNALS */
        cip->dataSocket = kClosedFileDescriptor;
    }
    memset(&cip->ourDataAddr, 0, sizeof(cip->ourDataAddr));
    memset(&cip->servDataAddr, 0, sizeof(cip->servDataAddr));
}   /* CloseDataConnection */

Referenced by FTPAbortDataTransfer(), FTPEndDataCmd(), FTPShutdownHost(), HangupOnServer(), and OpenDataConnection().

GetHostEntry()

static struct hostent* GetHostEntry ( char *  host, struct in_addr *  ip_address  )

static

Definition at line 53 of file ftp.c.

{
    struct in_addr ip;
    struct hostent *hp;

    /* See if the host was given in the dotted IP format, like "36.44.0.2."
     * If it was, inet_addr will convert that to a 32-bit binary value;
     * it not, inet_addr will return (-1L).
     */
    ip.s_addr = inet_addr(host);
    if (ip.s_addr != INADDR_NONE) {
        hp = NULL;
    } else {
        /* No IP address, so it must be a hostname, like ftp.wustl.edu. */
        hp = gethostbyname(host);
        if (hp != NULL)
            (void) memcpy(&ip.s_addr, hp->h_addr_list[0], (size_t) hp->h_length);
    }
    if (ip_address != NULL)
        *ip_address = ip;
    return (hp);
}   /* GetHostEntry */

Referenced by LookupCmd(), and OpenControlConnection().

GetOurHostName()

int GetOurHostName	(	char *	host,
		size_t	siz
	)

Definition at line 81 of file ftp.c.

{
#ifdef HOSTNAME
    /* You can hardcode in the name if this routine doesn't work
     * the way you want it to.
     */
    Strncpy(host, HOSTNAME, siz);
    return (1);     /* Success */
#else
    struct hostent *hp;
    int result;
    char **curAlias;
    char domain[64];
    char *cp;
    int rc;

    host[0] = '\0';
    result = gethostname(host, (int) siz);
    if ((result < 0) || (host[0] == '\0')) {
        return (-1);
    }

    if (strchr(host, '.') != NULL) {
        /* gethostname returned full name (like "cse.unl.edu"), instead
         * of just the node name (like "cse").
         */
        return (2);     /* Success */
    }

    hp = gethostbyname(host);
    if (hp != NULL) {
        /* Maybe the host entry has the full name. */
        cp = strchr((char *) hp->h_name, '.');
        if ((cp != NULL) && (cp[1] != '\0')) {
            /* The 'name' field for the host entry had full name. */
            (void) Strncpy(host, (char *) hp->h_name, siz);
            return (3);     /* Success */
        }

        /* Now try the list of aliases, to see if any of those look real. */
        for (curAlias = hp->h_aliases; *curAlias != NULL; curAlias++) {
            cp = strchr(*curAlias, '.');
            if ((cp != NULL) && (cp[1] != '\0')) {
                (void) Strncpy(host, *curAlias, siz);
                return (4);     /* Success */
            }
        }
    }

    /* Otherwise, we just have the node name.  See if we can get the
     * domain name ourselves.
     */
#ifdef DOMAINNAME
    (void) STRNCPY(domain, DOMAINNAME);
    rc = 5;
#else
    rc = -1;
    domain[0] = '\0';
#   if defined(HAVE_RES_INIT) && defined(HAVE__RES_DEFDNAME)
    if (domain[0] == '\0') {
        (void) res_init();
        if ((_res.defdname != NULL) && (_res.defdname[0] != '\0')) {
            (void) STRNCPY(domain, _res.defdname);
            rc = 6;
        }
    }
#   endif   /* HAVE_RES_INIT && HAVE__RES_DEFDNAME */

    if (domain[0] == '\0') {
        FILE *fp;
        char line[256];
        char *tok;

        fp = fopen("/etc/resolv.conf", "r");
        if (fp != NULL) {
            (void) memset(line, 0, sizeof(line));
            while (fgets(line, sizeof(line) - 1, fp) != NULL) {
                if (!isalpha((int) line[0]))
                    continue;   /* Skip comment lines. */
                tok = strtok(line, " \t\n\r");
                if (tok == NULL)
                    continue;   /* Impossible */
                if (strcmp(tok, "domain") == 0) {
                    tok = strtok(NULL, " \t\n\r");
                    if (tok == NULL)
                        continue;   /* syntax error */
                    (void) STRNCPY(domain, tok);
                    rc = 7;
                    break;  /* Done. */
                }
            }
            (void) fclose(fp);
        }
    }
#endif  /* DOMAINNAME */

    if (domain[0] != '\0') {
        /* Supposedly, it's legal for a domain name with
         * a period at the end.
         */
        cp = domain + strlen(domain) - 1;
        if (*cp == '.')
            *cp = '\0';
        if (domain[0] != '.')
            (void) Strncat(host, ".", siz);
        (void) Strncat(host, domain, siz);
    }
    if (rc < 0)
        host[0] = '\0';
    return(rc); /* Success */
#endif  /* !HOSTNAME */
}   /* GetOurHostName */

Referenced by FTPInitializeOurHostName().

GetSocketAddress()

static int GetSocketAddress ( const FTPCIPtr  cip, int  sockfd, struct sockaddr_in *  saddr  )

static

Definition at line 222 of file ftp.c.

{
    int len = (int) sizeof (struct sockaddr_in);
    int result = 0;

    if (getsockname(sockfd, (struct sockaddr *)saddr, &len) < 0) {
        Error(cip, kDoPerror, "Could not get socket name.\n");
        cip->errNo = kErrGetSockName;
        result = kErrGetSockName;
    }
    return (result);
}   /* GetSocketAddress */

Referenced by OpenControlConnection(), and OpenDataConnection().

HangupOnServer()

void HangupOnServer

(

const FTPCIPtr

cip

)

Definition at line 1314 of file ftp.c.

{
    /* Since we want to close both sides of the connection for each
     * socket, we can just have them closed with close() instead of
     * using shutdown().
     */
    CloseControlConnection(cip);
    CloseDataConnection(cip);
}   /* HangupOnServer */

OpenControlConnection()

int OpenControlConnection	(	const FTPCIPtr	cip,
		char *	host,
		unsigned int	port
	)

Definition at line 347 of file ftp.c.

{
    struct in_addr ip_address;
    int err = 0;
    int result;
    int oerrno;
    volatile int sockfd = -1;
    volatile int sock2fd = -1;
    ResponsePtr rp;
    char **volatile curaddr;
    struct hostent *hp;
    char *volatile fhost;
    unsigned int fport;
#ifndef NO_SIGNALS
    volatile FTPSigProc osigint;
    volatile FTPSigProc osigalrm;
    volatile FTPCIPtr vcip;
    int sj;
#endif  /* NO_SIGNALS */
    const char *firstLine, *secondLine, *srvr;

    LIBNCFTP_USE_VAR(gLibNcFTPVersion);
    LIBNCFTP_USE_VAR(gCopyright);
#ifdef NO_SIGNALS
    LIBNCFTP_USE_VAR(gNoSignalsMarker);
#endif  /* NO_SIGNALS */

    if (cip->firewallType == kFirewallNotInUse) {
        fhost = host;
        fport = port;
    } else {
        fhost = cip->firewallHost;
        fport = cip->firewallPort;
    }
    if (fport == 0)
        fport = cip->lip->defaultPort;

    /* Since we're the client, we just have to get a socket() and
     * connect() it.
     */
    (void) ZERO(cip->servCtlAddr);
    cip->cin = NULL;
    cip->cout = NULL;

    /* Make sure we use network byte-order. */
    fport = (unsigned int) htons((unsigned short) fport);

    cip->servCtlAddr.sin_port = (unsigned short) fport;

    hp = GetHostEntry(fhost, &ip_address);

    if (hp == NULL) {
        /* Okay, no Host entry, but maybe we have a numeric address
         * in ip_address we can try.
         */
        if (ip_address.s_addr == INADDR_NONE) {
            Error(cip, kDontPerror, "%s: unknown host.\n", fhost);
            cip->errNo = kErrHostUnknown;
            return (kErrHostUnknown);
        }
        cip->servCtlAddr.sin_family = AF_INET;
        cip->servCtlAddr.sin_addr.s_addr = ip_address.s_addr;
    } else {
        cip->servCtlAddr.sin_family = hp->h_addrtype;
        /* We'll fill in the rest of the structure below. */
    }

    /* After obtaining a socket, try to connect it to a remote
     * address.  If we didn't get a host entry, we will only have
     * one thing to try (ip_address);  if we do have one, we can try
     * every address in the list from the host entry.
     */

    if (hp == NULL) {
        /* Since we're given a single raw address, and not a host entry,
         * we can only try this one address and not any other addresses
         * that could be present for a site with a host entry.
         */

        if ((sockfd = socket(cip->servCtlAddr.sin_family, SOCK_STREAM, 0)) < 0) {
            Error(cip, kDoPerror, "Could not get a socket.\n");
            cip->errNo = kErrNewStreamSocket;
            return (kErrNewStreamSocket);
        }

        /* This doesn't do anything if you left these
         * at their defaults (zero).  Otherwise it
         * tries to set the buffer size to the
         * size specified.
         */
        (void) SetSockBufSize(sockfd, cip->ctrlSocketRBufSize, cip->ctrlSocketSBufSize);

#ifdef NO_SIGNALS
        err = SConnect(sockfd, &cip->servCtlAddr, (int) cip->connTimeout);

        if (err < 0) {
            oerrno = errno;
            (void) SClose(sockfd, 3);
            errno = oerrno;
            sockfd = -1;
        }
#else   /* NO_SIGNALS */
        osigint = (volatile FTPSigProc) signal(SIGINT, CancelConnect);
        if (cip->connTimeout > 0) {
            osigalrm = (volatile FTPSigProc) signal(SIGALRM, CancelConnect);
            (void) alarm(cip->connTimeout);
        }

        vcip = cip;

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

        if (sj != 0) {
            /* Interrupted by a signal. */
            (void) closesocket(sockfd);
            (void) signal(SIGINT, (FTPSigProc) osigint);
            if (vcip->connTimeout > 0) {
                (void) alarm(0);
                (void) signal(SIGALRM, (FTPSigProc) osigalrm);
            }
            if (gGotSig == SIGINT) {
                result = vcip->errNo = kErrConnectMiscErr;
                Error(vcip, kDontPerror, "Connection attempt canceled.\n");
                (void) kill(getpid(), SIGINT);
            } else if (gGotSig == SIGALRM) {
                result = vcip->errNo = kErrConnectRetryableErr;
                Error(vcip, kDontPerror, "Connection attempt timed-out.\n");
                (void) kill(getpid(), SIGALRM);
            } else {
                result = vcip->errNo = kErrConnectMiscErr;
                Error(vcip, kDontPerror, "Connection attempt failed due to an unexpected signal (%d).\n", gGotSig);
            }
            return (result);
        } else  {
            err = connect(sockfd, (struct sockaddr *) &cip->servCtlAddr,
                      (int) sizeof (cip->servCtlAddr));
            if (cip->connTimeout > 0) {
                (void) alarm(0);
                (void) signal(SIGALRM, (FTPSigProc) osigalrm);
            }
            (void) signal(SIGINT, (FTPSigProc) osigint);
        }

        if (err < 0) {
            oerrno = errno;
            (void) closesocket(sockfd);
            errno = oerrno;
            sockfd = -1;
        }
#endif  /* NO_SIGNALS */
    } else {
        /* We can try each address in the list.  We'll quit when we
         * run out of addresses to try or get a successful connection.
         */
        for (curaddr = hp->h_addr_list; *curaddr != NULL; curaddr++) {
            if ((sockfd = socket(cip->servCtlAddr.sin_family, SOCK_STREAM, 0)) < 0) {
                Error(cip, kDoPerror, "Could not get a socket.\n");
                cip->errNo = kErrNewStreamSocket;
                return (kErrNewStreamSocket);
            }
            /* This could overwrite the address field in the structure,
             * but this is okay because the structure has a junk field
             * just for this purpose.
             */
            (void) memcpy(&cip->servCtlAddr.sin_addr, *curaddr, (size_t) hp->h_length);

            /* This doesn't do anything if you left these
             * at their defaults (zero).  Otherwise it
             * tries to set the buffer size to the
             * size specified.
             */
            (void) SetSockBufSize(sockfd, cip->ctrlSocketRBufSize, cip->ctrlSocketSBufSize);

#ifdef NO_SIGNALS
            err = SConnect(sockfd, &cip->servCtlAddr, (int) cip->connTimeout);

            if (err == 0)
                break;
            oerrno = errno;
            (void) SClose(sockfd, 3);
            errno = oerrno;
            sockfd = -1;
#else   /* NO_SIGNALS */

            osigint = (volatile FTPSigProc) signal(SIGINT, CancelConnect);
            if (cip->connTimeout > 0) {
                osigalrm = (volatile FTPSigProc) signal(SIGALRM, CancelConnect);
                (void) alarm(cip->connTimeout);
            }

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

            if (sj != 0) {
                /* Interrupted by a signal. */
                (void) closesocket(sockfd);
                (void) signal(SIGINT, (FTPSigProc) osigint);
                if (vcip->connTimeout > 0) {
                    (void) alarm(0);
                    (void) signal(SIGALRM, (FTPSigProc) osigalrm);
                }
                if (gGotSig == SIGINT) {
                    result = vcip->errNo = kErrConnectMiscErr;
                    Error(vcip, kDontPerror, "Connection attempt canceled.\n");
                    (void) kill(getpid(), SIGINT);
                } else if (gGotSig == SIGALRM) {
                    result = vcip->errNo = kErrConnectRetryableErr;
                    Error(vcip, kDontPerror, "Connection attempt timed-out.\n");
                    (void) kill(getpid(), SIGALRM);
                } else {
                    result = vcip->errNo = kErrConnectMiscErr;
                    Error(vcip, kDontPerror, "Connection attempt failed due to an unexpected signal (%d).\n", gGotSig);
                }
                return (result);
            } else {
                err = connect(sockfd, (struct sockaddr *) &cip->servCtlAddr,
                          (int) sizeof (cip->servCtlAddr));
                if (cip->connTimeout > 0) {
                    (void) alarm(0);
                    (void) signal(SIGALRM, (FTPSigProc) osigalrm);
                }
                (void) signal(SIGINT, (FTPSigProc) osigint);
            }

            if (err == 0)
                break;
            oerrno = errno;
            (void) closesocket(sockfd);
            errno = oerrno;
            sockfd = -1;
#endif /* NO_SIGNALS */
        }
    }

    if (err < 0) {
        /* Could not connect.  Close up shop and go home. */

        /* If possible, tell the caller if they should bother
         * calling back later.
         */
        switch (errno) {
#ifdef ENETDOWN
            case ENETDOWN:
#elif defined(WSAENETDOWN)
            case WSAENETDOWN:
#endif
#ifdef ENETUNREACH
            case ENETUNREACH:
#elif defined(WSAENETUNREACH)
            case WSAENETUNREACH:
#endif
#ifdef ECONNABORTED
            case ECONNABORTED:
#elif defined(WSAECONNABORTED)
            case WSAECONNABORTED:
#endif
#ifdef ETIMEDOUT
            case ETIMEDOUT:
#elif defined(WSAETIMEDOUT)
            case WSAETIMEDOUT:
#endif
#ifdef EHOSTDOWN
            case EHOSTDOWN:
#elif defined(WSAEHOSTDOWN)
            case WSAEHOSTDOWN:
#endif
#ifdef ECONNRESET
            case ECONNRESET:
#elif defined(WSAECONNRESET)
            case WSAECONNRESET:
#endif
                Error(cip, kDoPerror, "Could not connect to %s -- try again later.\n", fhost);
                result = cip->errNo = kErrConnectRetryableErr;
                break;
#ifdef ECONNREFUSED
            case ECONNREFUSED:
#elif defined(WSAECONNREFUSED)
            case WSAECONNREFUSED:
#endif
                Error(cip, kDoPerror, "Could not connect to %s.\n", fhost);
                result = cip->errNo = kErrConnectRefused;
                break;
            default:
                Error(cip, kDoPerror, "Could not connect to %s.\n", fhost);
                result = cip->errNo = kErrConnectMiscErr;
        }
        goto fatal;
    }

    /* Get our end of the socket address for later use. */
    if ((result = GetSocketAddress(cip, sockfd, &cip->ourCtlAddr)) < 0)
        goto fatal;

#ifdef SO_OOBINLINE
    /* We want Out-of-band data to appear in the regular stream,
     * since we can handle TELNET.
     */
    (void) SetInlineOutOfBandData(cip, sockfd);
#endif
    (void) SetKeepAlive(cip, sockfd);
    (void) SetLinger(cip, sockfd, 0);   /* Don't need it for ctrl. */

#if defined(IP_TOS) && defined(IPTOS_LOWDELAY)
    /* Control connection is somewhat interactive, so quick response
     * is desired.
     */
    (void) SetTypeOfService(cip, sockfd, IPTOS_LOWDELAY);
#endif

#ifdef NO_SIGNALS
    cip->ctrlSocketR = sockfd;
    cip->ctrlSocketW = sockfd;
    cip->cout = NULL;
    cip->cin = NULL;
    sock2fd = kClosedFileDescriptor;

    if (InitSReadlineInfo(&cip->ctrlSrl, sockfd, cip->srlBuf, sizeof(cip->srlBuf), (int) cip->ctrlTimeout, 1) < 0) {
        result = kErrFdopenW;
        cip->errNo = kErrFdopenW;
        Error(cip, kDoPerror, "Could not fdopen.\n");
        goto fatal;
    }
#else   /* NO_SIGNALS */
    if ((sock2fd = dup(sockfd)) < 0) {
        result = kErrDupSocket;
        cip->errNo = kErrDupSocket;
        Error(cip, kDoPerror, "Could not duplicate a file descriptor.\n");
        goto fatal;
    }

    /* Now setup the FILE pointers for use with the Std I/O library
     * routines.
     */
    if ((cip->cin = fdopen(sockfd, "r")) == NULL) {
        result = kErrFdopenR;
        cip->errNo = kErrFdopenR;
        Error(cip, kDoPerror, "Could not fdopen.\n");
        goto fatal;
    }

    if ((cip->cout = fdopen(sock2fd, "w")) == NULL) {
        result = kErrFdopenW;
        cip->errNo = kErrFdopenW;
        Error(cip, kDoPerror, "Could not fdopen.\n");
        CloseFile(&cip->cin);
        sockfd = kClosedFileDescriptor;
        goto fatal;
    }

    cip->ctrlSocketR = sockfd;
    cip->ctrlSocketW = sockfd;

    /* We'll be reading and writing lines, so use line buffering.  This
     * is necessary since the stdio library will use full buffering
     * for all streams not associated with the tty.
     */
#ifdef HAVE_SETLINEBUF
    setlinebuf(cip->cin);
    setlinebuf(cip->cout);
#else
    (void) SETVBUF(cip->cin, NULL, _IOLBF, (size_t) BUFSIZ);
    (void) SETVBUF(cip->cout, NULL, _IOLBF, (size_t) BUFSIZ);
#endif
#endif  /* NO_SIGNALS */

#ifdef HAVE_INET_NTOP   /* Mostly to workaround bug in IRIX 6.5's inet_ntoa */
    (void) memset(cip->ip, 0, sizeof(cip->ip));
    (void) inet_ntop(AF_INET, &cip->servCtlAddr.sin_addr, cip->ip, sizeof(cip->ip) - 1);
#else
    (void) STRNCPY(cip->ip, inet_ntoa(cip->servCtlAddr.sin_addr));
#endif
    if ((hp == NULL) || (hp->h_name == NULL))
        (void) STRNCPY(cip->actualHost, fhost);
    else
        (void) STRNCPY(cip->actualHost, (char *) hp->h_name);

    /* Read the startup message from the server. */
    rp = InitResponse();
    if (rp == NULL) {
        Error(cip, kDontPerror, "Malloc failed.\n");
        cip->errNo = kErrMallocFailed;
        result = cip->errNo;
        goto fatal;
    }

    result = GetResponse(cip, rp);
    if ((result < 0) && (rp->msg.first == NULL)) {
        goto fatal;
    }
    if (rp->msg.first != NULL) {
        cip->serverType = kServerTypeUnknown;
        srvr = NULL;
        firstLine = rp->msg.first->line;
        secondLine = NULL;
        if (rp->msg.first->next != NULL)
            secondLine = rp->msg.first->next->line;

        if (strstr(firstLine, "Version wu-") != NULL) {
            cip->serverType = kServerTypeWuFTPd;
            srvr = "wu-ftpd";
        } else if (strstr(firstLine, "NcFTPd") != NULL) {
            cip->serverType = kServerTypeNcFTPd;
            srvr = "NcFTPd Server";
        } else if (STRNEQ("ProFTPD", firstLine, 7)) {
            cip->serverType = kServerTypeProFTPD;
            srvr = "ProFTPD";
        } else if (strstr(firstLine, "Microsoft FTP Service") != NULL) {
            cip->serverType = kServerTypeMicrosoftFTP;
            srvr = "Microsoft FTP Service";
        } else if (strstr(firstLine, "(NetWare ") != NULL) {
            cip->serverType = kServerTypeNetWareFTP;
            srvr = "NetWare FTP Service";
        } else if (STRNEQ("WFTPD", firstLine, 5)) {
            cip->serverType = kServerTypeWFTPD;
            srvr = "WFTPD";
        } else if (STRNEQ("Serv-U FTP", firstLine, 10)) {
            cip->serverType = kServerTypeServ_U;
            srvr = "Serv-U FTP-Server";
        } else if (strstr(firstLine, "VFTPD") != NULL) {
            cip->serverType = kServerTypeVFTPD;
            srvr = "VFTPD";
        } else if (STRNEQ("FTP-Max", firstLine, 7)) {
            cip->serverType = kServerTypeFTP_Max;
            srvr = "FTP-Max";
        } else if (strstr(firstLine, "Roxen") != NULL) {
            cip->serverType = kServerTypeRoxen;
            srvr = "Roxen";
        } else if (strstr(firstLine, "WS_FTP") != NULL) {
            cip->serverType = kServerTypeWS_FTP;
            srvr = "WS_FTP Server";
        } else if ((secondLine != NULL) && (strstr(secondLine, "WarFTP") != NULL)) {
            cip->serverType = kServerTypeWarFTPd;
            srvr = "WarFTPd";
        }

        if (srvr != NULL)
            PrintF(cip, "Remote server is running %s.\n", srvr);

        /* Do the application's connect message callback, if present. */
        if ((cip->onConnectMsgProc != 0) && (rp->codeType < 4))
            (*cip->onConnectMsgProc)(cip, rp);
    }

    if (rp->codeType >= 4) {
        /* They probably hung up on us right away.  That's too bad,
         * but we can tell the caller that they can call back later
         * and try again.
         */
        DoneWithResponse(cip, rp);
        result = kErrConnectRetryableErr;
        Error(cip, kDontPerror, "Server hungup immediately after connect.\n");
        cip->errNo = kErrConnectRetryableErr;
        goto fatal;
    }
    if (result < 0)     /* Some other error occurred during connect message */
        goto fatal;
    cip->connected = 1;
    DoneWithResponse(cip, rp);
    return (kNoErr);

fatal:
    if (sockfd > 0)
        (void) closesocket(sockfd);
    if (sock2fd > 0)
        (void) closesocket(sock2fd);
    CloseFile(&cip->cin);
    CloseFile(&cip->cout);
    cip->ctrlSocketR = kClosedFileDescriptor;
    cip->ctrlSocketW = kClosedFileDescriptor;
    return (result);
}   /* OpenControlConnection */

Referenced by FTPOpenHost(), and FTPOpenHostNoLogin().

OpenDataConnection()

int OpenDataConnection	(	const FTPCIPtr	cip,
		int	mode
	)

Definition at line 1053 of file ftp.c.

{
    int dataSocket;
    int weirdPort;
    int result;

    /* Before we can transfer any data, and before we even ask the
     * remote server to start transferring via RETR/NLST/etc, we have
     * to setup the connection.
     */

tryPort2:
    weirdPort = 0;
    result = 0;
    CloseDataConnection(cip);   /* In case we didn't before... */

    dataSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (dataSocket < 0) {
        Error(cip, kDoPerror, "Could not get a data socket.\n");
        result = kErrNewStreamSocket;
        cip->errNo = kErrNewStreamSocket;
        return result;
    }

    /* This doesn't do anything if you left these
     * at their defaults (zero).  Otherwise it
     * tries to set the buffer size to the
     * size specified.
     */
    (void) SetSockBufSize(dataSocket, cip->dataSocketRBufSize, cip->dataSocketSBufSize);

    if ((cip->hasPASV == kCommandNotAvailable) || (mode == kSendPortMode)) {
tryPort:
        cip->ourDataAddr = cip->ourCtlAddr;
        cip->ourDataAddr.sin_family = AF_INET;

#ifdef HAVE_LIBSOCKS
        cip->ourDataAddr.sin_port = 0;
        if (Rbind(dataSocket, (struct sockaddr *) &cip->ourDataAddr,
            (int) sizeof (cip->ourDataAddr),
            cip->servCtlAddr.sin_addr.s_addr) < 0)
#else
        if (BindToEphemeralPortNumber(dataSocket, &cip->ourDataAddr, (int) cip->ephemLo, (int) cip->ephemHi) < 0)
#endif
        {
            Error(cip, kDoPerror, "Could not bind the data socket");
            result = kErrBindDataSocket;
            cip->errNo = kErrBindDataSocket;
            goto bad;
        }

        /* Need to do this so we can figure out which port the system
         * gave to us.
         */
        if ((result = GetSocketAddress(cip, dataSocket, &cip->ourDataAddr)) < 0)
            goto bad;

        if (listen(dataSocket, 1) < 0) {
            Error(cip, kDoPerror, "listen failed");
            result = kErrListenDataSocket;
            cip->errNo = kErrListenDataSocket;
            goto bad;
        }

        if ((result = SendPort(cip, &cip->ourDataAddr)) < 0)
            goto bad;

        cip->dataPortMode = kSendPortMode;
    } else {
        /* Passive mode.  Let the other side decide where to send. */

        cip->servDataAddr = cip->servCtlAddr;
        cip->servDataAddr.sin_family = AF_INET;
        cip->ourDataAddr = cip->ourCtlAddr;
        cip->ourDataAddr.sin_family = AF_INET;

        if (Passive(cip, &cip->servDataAddr, &weirdPort) < 0) {
            Error(cip, kDontPerror, "Passive mode refused.\n");
            cip->hasPASV = kCommandNotAvailable;

            /* We can try using regular PORT commands, which are required
             * by all FTP protocol compliant programs, if you said so.
             *
             * We don't do this automatically, because if your host
             * is running a firewall you (probably) do not want SendPort
             * FTP for security reasons.
             */
            if (mode == kFallBackToSendPortMode)
                goto tryPort;
            result = kErrPassiveModeFailed;
            cip->errNo = kErrPassiveModeFailed;
            goto bad;
        }

#ifdef HAVE_LIBSOCKS
        cip->ourDataAddr.sin_port = 0;
        if (Rbind(dataSocket, (struct sockaddr *) &cip->ourDataAddr,
            (int) sizeof (cip->ourDataAddr),
            cip->servCtlAddr.sin_addr.s_addr) < 0)
#else
        if (BindToEphemeralPortNumber(dataSocket, &cip->ourDataAddr, (int) cip->ephemLo, (int) cip->ephemHi) < 0)
#endif
        {
            Error(cip, kDoPerror, "Could not bind the data socket");
            result = kErrBindDataSocket;
            cip->errNo = kErrBindDataSocket;
            goto bad;
        }

#ifdef NO_SIGNALS
        result = SConnect(dataSocket, &cip->servDataAddr, (int) cip->connTimeout);
#else   /* NO_SIGNALS */
        if (cip->connTimeout > 0)
            (void) alarm(cip->connTimeout);

        result = connect(dataSocket, (struct sockaddr *) &cip->servDataAddr, (int) sizeof(cip->servDataAddr));
        if (cip->connTimeout > 0)
            (void) alarm(0);
#endif  /* NO_SIGNALS */

#ifdef NO_SIGNALS
        if (result == kTimeoutErr) {
            if (mode == kFallBackToSendPortMode) {
                Error(cip, kDontPerror, "Data connection timed out.\n");
                Error(cip, kDontPerror, "Falling back to PORT instead of PASV mode.\n");
                (void) closesocket(dataSocket);
                cip->hasPASV = kCommandNotAvailable;
                goto tryPort2;
            }
            Error(cip, kDontPerror, "Data connection timed out.\n");
            result = kErrConnectDataSocket;
            cip->errNo = kErrConnectDataSocket;
        } else
#endif  /* NO_SIGNALS */

        if (result < 0) {
#ifdef ECONNREFUSED
            if ((weirdPort > 0) && (errno == ECONNREFUSED)) {
#elif defined(WSAECONNREFUSED)
            if ((weirdPort > 0) && (errno == WSAECONNREFUSED)) {
#endif
                Error(cip, kDontPerror, "Server sent back a bogus port number.\nI will fall back to PORT instead of PASV mode.\n");
                if (mode == kFallBackToSendPortMode) {
                    (void) closesocket(dataSocket);
                    cip->hasPASV = kCommandNotAvailable;
                    goto tryPort2;
                }
                result = kErrServerSentBogusPortNumber;
                cip->errNo = kErrServerSentBogusPortNumber;
                goto bad;
            }
            if (mode == kFallBackToSendPortMode) {
                Error(cip, kDoPerror, "connect failed.\n");
                Error(cip, kDontPerror, "Falling back to PORT instead of PASV mode.\n");
                (void) closesocket(dataSocket);
                cip->hasPASV = kCommandNotAvailable;
                goto tryPort2;
            }
            Error(cip, kDoPerror, "connect failed.\n");
            result = kErrConnectDataSocket;
            cip->errNo = kErrConnectDataSocket;
            goto bad;
        }

        /* Need to do this so we can figure out which port the system
         * gave to us.
         */
        if ((result = GetSocketAddress(cip, dataSocket, &cip->ourDataAddr)) < 0)
            goto bad;

        cip->dataPortMode = kPassiveMode;
        cip->hasPASV = kCommandAvailable;
    }

Referenced by FTPStartDataCmd().

Passive()

static int Passive ( const FTPCIPtr  cip, struct sockaddr_in *  saddr, int *  weird  )

static

Definition at line 939 of file ftp.c.

{
    ResponsePtr rp;
    int i[6], j;
    unsigned char n[6];
    char *cp;
    int result;

    rp = InitResponse();
    if (rp == NULL) {
        Error(cip, kDontPerror, "Malloc failed.\n");
        cip->errNo = kErrMallocFailed;
        return (cip->errNo);
    }

    result = RCmd(cip, rp, "PASV");
    if (result < 0)
        goto done;

    if (rp->codeType != 2) {
        /* Didn't understand or didn't want passive port selection. */
        cip->errNo = result = kErrPASVFailed;
        goto done;
    }

    /* The other side returns a specification in the form of
     * an internet address as the first four integers (each
     * integer stands for 8-bits of the real 32-bit address),
     * and two more integers for the port (16-bit port).
     *
     * It should give us something like:
     * "Entering Passive Mode (129,93,33,1,10,187)", so look for
     * digits with sscanf() starting 24 characters down the string.
     */
    for (cp = rp->msg.first->line; ; cp++) {
        if (*cp == '\0') {
            Error(cip, kDontPerror, "Cannot parse PASV response: %s\n", rp->msg.first->line);
            goto done;
        }
        if (isdigit((int) *cp))
            break;
    }

    if (sscanf(cp, "%d,%d,%d,%d,%d,%d",
            &i[0], &i[1], &i[2], &i[3], &i[4], &i[5]) != 6) {
        Error(cip, kDontPerror, "Cannot parse PASV response: %s\n", rp->msg.first->line);
        goto done;
    }

    for (j=0, *weird = 0; j<6; j++) {
        /* Some ftp servers return bogus port octets, such as
         * boombox.micro.umn.edu.  Let the caller know if we got a
         * weird looking octet.
         */
        if ((i[j] < 0) || (i[j] > 255))
            *weird = *weird + 1;
        n[j] = (unsigned char) (i[j] & 0xff);
    }

    (void) memcpy(&saddr->sin_addr, &n[0], (size_t) 4);
    (void) memcpy(&saddr->sin_port, &n[4], (size_t) 2);

    result = kNoErr;
done:
    DoneWithResponse(cip, rp);
    return (result);
}   /* Passive */

Referenced by OpenDataConnection().

return() [1/2]

return

(

0

)

return() [2/2]

return

(

result

)

SendPort()

static int SendPort ( const FTPCIPtr  cip, struct sockaddr_in *  saddr  )

static

Definition at line 899 of file ftp.c.

{
    char *a, *p;
    int result;
    ResponsePtr rp;

    rp = InitResponse();
    if (rp == NULL) {
        Error(cip, kDontPerror, "Malloc failed.\n");
        cip->errNo = kErrMallocFailed;
        return (cip->errNo);
    }

    /* These will point to data in network byte order. */
    a = (char *) &saddr->sin_addr;
    p = (char *) &saddr->sin_port;
#define UC(x) (int) (((int) x) & 0xff)

    /* Need to tell the other side which host (the address) and
     * which process (port) on that host to send data to.
     */
    result = RCmd(cip, rp, "PORT %d,%d,%d,%d,%d,%d",
        UC(a[0]), UC(a[1]), UC(a[2]), UC(a[3]), UC(p[0]), UC(p[1]));

    if (result < 0) {
        return (result);
    } else if (result != 2) {
        /* A 500'ish response code means the PORT command failed. */
        DoneWithResponse(cip, rp);
        cip->errNo = kErrPORTFailed;
        return (cip->errNo);
    }
    DoneWithResponse(cip, rp);
    return (kNoErr);
}   /* SendPort */

Referenced by OpenDataConnection().

SendTelnetInterrupt()

void SendTelnetInterrupt

(

const FTPCIPtr

cip

)

Definition at line 1328 of file ftp.c.

{
    char msg[4];

    /* 1. User system inserts the Telnet "Interrupt Process" (IP) signal
     *    in the Telnet stream.
     */

    if (cip->cout != NULL)
        (void) fflush(cip->cout);

    msg[0] = (char) (unsigned char) IAC;
    msg[1] = (char) (unsigned char) IP;
    (void) send(cip->ctrlSocketW, msg, 2, 0);

    /* 2. User system sends the Telnet "Sync" signal. */
#if 1
    msg[0] = (char) (unsigned char) IAC;
    msg[1] = (char) (unsigned char) DM;
    if (send(cip->ctrlSocketW, msg, 2, MSG_OOB) != 2)
        Error(cip, kDoPerror, "Could not send an urgent message.\n");
#else
    /* "Send IAC in urgent mode instead of DM because UNIX places oob mark
     * after urgent byte rather than before as now is protocol," says
     * the BSD ftp code.
     */
    msg[0] = (char) (unsigned char) IAC;
    if (send(cip->ctrlSocketW, msg, 1, MSG_OOB) != 1)
        Error(cip, kDoPerror, "Could not send an urgent message.\n");
    (void) fprintf(cip->cout, "%c", DM);
    (void) fflush(cip->cout);
#endif
}   /* SendTelnetInterrupt */

Referenced by FTPAbortDataTransfer().

SetKeepAlive() [1/2]

int SetKeepAlive	(	const FTPCIPtr	cip,
		int	sockfd
	)

Definition at line 239 of file ftp.c.

{
#ifndef SO_KEEPALIVE
    cip->errNo = kErrSetKeepAlive;
    return (kErrSetKeepAlive);
#else
    int opt;

    opt = 1;

    if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (char *) &opt, (int) sizeof(opt)) < 0) {
        /* Error(cip, kDoPerror, "Could not set keep-alive mode.\n"); */
        cip->errNo = kErrSetKeepAlive;
        return (kErrSetKeepAlive);
    }
    return (kNoErr);
#endif  /* SO_KEEPALIVE */
}   /* SetKeepAlive */

Referenced by OpenControlConnection(), and OpenDataConnection().

SetKeepAlive() [2/2]

void SetKeepAlive	(	cip	,
		dataSocket
	)

SetLinger() [1/2]

int SetLinger	(	const FTPCIPtr	cip,
		int	sockfd,
		int	onoff
	)

Definition at line 262 of file ftp.c.

{
#ifndef SO_LINGER
    cip->errNo = kErrSetLinger;
    return (kErrSetLinger);
#else
    struct linger li;

    if (onoff != 0) {
        li.l_onoff = 1;
        li.l_linger = 120;  /* 2 minutes, but system ignores field. */
    } else {
        li.l_onoff = 0;
        li.l_linger = 0;
    }
    /* Have the system make an effort to deliver any unsent data,
     * even after we close the connection.
     */
    if (setsockopt(sockfd, SOL_SOCKET, SO_LINGER, (char *) &li, (int) sizeof(li)) < 0) {
        /* Error(cip, kDoPerror, "Could not set linger mode.\n"); */
        cip->errNo = kErrSetLinger;
        return (kErrSetLinger);
    }
    return (kNoErr);
#endif  /* SO_LINGER */
}   /* SetLinger */

Referenced by FTPAbortDataTransfer(), FTPShutdownHost(), OpenControlConnection(), and OpenDataConnection().

SetLinger() [2/2]

void SetLinger	(	cip	,
		dataSocket	,
		1
	)

SetStartOffset()

int SetStartOffset	(	const FTPCIPtr	cip,
		longest_int	restartPt
	)

Definition at line 853 of file ftp.c.

{
    ResponsePtr rp;
    int result;

    if (restartPt != (longest_int) 0) {
        rp = InitResponse();
        if (rp == NULL) {
            Error(cip, kDontPerror, "Malloc failed.\n");
            cip->errNo = kErrMallocFailed;
            return (cip->errNo);
        }

        /* Force reset to offset zero. */
        if (restartPt == (longest_int) -1)
            restartPt = (longest_int) 0;
#ifdef PRINTF_LONG_LONG
        result = RCmd(cip, rp,
        "REST " PRINTF_LONG_LONG,
        restartPt);
#else
        result = RCmd(cip, rp, "REST %ld", (long) restartPt);
#endif

        if (result < 0) {
            return (result);
        } else if (result == 3) {
            cip->hasREST = kCommandAvailable;
            DoneWithResponse(cip, rp);
        } else if (UNIMPLEMENTED_CMD(rp->code)) {
            cip->hasREST = kCommandNotAvailable;
            DoneWithResponse(cip, rp);
            cip->errNo = kErrSetStartPoint;
            return (kErrSetStartPoint);
        } else {
            DoneWithResponse(cip, rp);
            cip->errNo = kErrSetStartPoint;
            return (kErrSetStartPoint);
        }
    }
    return (0);
}   /* SetStartOffset */

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

Variable Documentation

__pad0__

bad __pad0__

Definition at line 1241 of file ftp.c.

dataSocket

cip dataSocket = dataSocket

Definition at line 1238 of file ftp.c.

Referenced by OpenDataConnection().

gCopyright

char gCopyright[] = "@(#) LibNcFTP Copyright 1995-2000, by Mike Gleason. All rights reserved."

static

Definition at line 28 of file ftp.c.

Referenced by BindToEphemeralPortNumber(), kbd_rc(), and OpenControlConnection().

gLibNcFTPVersion

char gLibNcFTPVersion[64] = kLibraryVersion

Definition at line 11 of file ftp.c.

Referenced by OpenControlConnection(), OpenTrace(), Usage(), and VersionCmd().

gNoSignalsMarker

char gNoSignalsMarker[] = "@(#) LibNcFTP - NO_SIGNALS"

Definition at line 14 of file ftp.c.

Referenced by OpenControlConnection(), and SRead().