ftp.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	MyInetAddr (char *, size_t, char **, int)
int	GetOurHostName (char *, size_t)
void	CloseControlConnection (const FTPCIPtr)
int	SetKeepAlive (const FTPCIPtr, int)
int	SetLinger (const FTPCIPtr, int, int)
int	SetTypeOfService (const FTPCIPtr, int, int)
int	SetInlineOutOfBandData (const FTPCIPtr, int)
int	OpenControlConnection (const FTPCIPtr, char *, unsigned int)
void	CloseDataConnection (const FTPCIPtr)
int	SetStartOffset (const FTPCIPtr, longest_int)
int	OpenDataConnection (const FTPCIPtr, int)
int	AcceptDataConnection (const FTPCIPtr)
void	HangupOnServer (const FTPCIPtr)
void	SendTelnetInterrupt (const FTPCIPtr)

Function Documentation

AcceptDataConnection()

int AcceptDataConnection

(

const

FTPCIPtr

)

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().

CloseControlConnection()

void CloseControlConnection

(

const

FTPCIPtr

)

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 */

CloseDataConnection()

void CloseDataConnection

(

const

FTPCIPtr

)

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().

GetOurHostName()

int GetOurHostName	(	char *	,
		size_t
	)

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().

HangupOnServer()

void HangupOnServer

(

const

FTPCIPtr

)

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 */

MyInetAddr()

void MyInetAddr	(	char *	,
		size_t	,
		char **	,
		int
	)

Definition at line 185 of file util.c.

{
    struct in_addr *ia;
#ifndef HAVE_INET_NTOP
    char *cp;
#endif

    (void) Strncpy(dst, "???", siz);
    if (src != (char **) 0) {
        ia = (struct in_addr *) src[i];
#ifdef HAVE_INET_NTOP   /* Mostly to workaround bug in IRIX 6.5's inet_ntoa */
        (void) inet_ntop(AF_INET, ia, dst, siz - 1);
#else
        cp = inet_ntoa(*ia);
        if ((cp != (char *) 0) && (cp != (char *) -1) && (cp[0] != '\0'))
            (void) Strncpy(dst, cp, siz);
#endif
    }
}   /* MyInetAddr */

Referenced by LookupCmd().

OpenControlConnection()

int OpenControlConnection	(	const	FTPCIPtr,
		char *	,
		unsigned int
	)

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,
		int
	)

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().

SendTelnetInterrupt()

void SendTelnetInterrupt

(

const

FTPCIPtr

)

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().

SetInlineOutOfBandData()

int SetInlineOutOfBandData	(	const	FTPCIPtr,
		int
	)

Referenced by OpenControlConnection().

SetKeepAlive()

int SetKeepAlive	(	const	FTPCIPtr,
		int
	)

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().

SetLinger()

int SetLinger	(	const	FTPCIPtr,
		int	,
		int
	)

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().

SetStartOffset()

int SetStartOffset	(	const	FTPCIPtr,
		longest_int
	)

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().

SetTypeOfService()

int SetTypeOfService	(	const	FTPCIPtr,
		int	,
		int
	)

Referenced by OpenControlConnection(), and OpenDataConnection().