ftplib.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include "ftplib.h"

Include dependency graph for ftplib.c:

Go to the source code of this file.

Classes
struct	NetBuf

Macros
#define	ACCEPT_TIMEOUT   10
#define	BUILDING_LIBRARY
#define	FTPLIB_BUFSIZ   8192
#define	FTPLIB_CONTROL   0
#define	FTPLIB_DEFMODE   FTPLIB_PASSIVE
#define	FTPLIB_READ   1
#define	FTPLIB_WRITE   2
#define	lllog(M)   fprintf(stderr, M);
#define	SETSOCKOPT_OPTVAL_TYPE   (void *)

Functions
static int	FtpAcceptConnection (netbuf *nData, netbuf *nControl)
GLOBALDEF int	FtpAccess (const char *path, int typ, int mode, netbuf *nControl, netbuf **nData)
GLOBALDEF int	FtpCDUp (netbuf *nControl)
GLOBALDEF int	FtpChdir (const char *path, netbuf *nControl)
GLOBALDEF int	FtpClose (netbuf *nData)
GLOBALDEF int	FtpConnect (const char *host, netbuf **nControl)
GLOBALDEF int	FtpDelete (const char *fnm, netbuf *nControl)
GLOBALDEF int	FtpDir (const char *outputfile, const char *path, netbuf *nControl)
GLOBALDEF int	FtpGet (const char *outputfile, const char *path, char mode, netbuf *nControl)
GLOBALDEF void	FtpInit (void)
GLOBALDEF char *	FtpLastResponse (netbuf *nControl)
GLOBALDEF int	FtpLogin (const char *user, const char *pass, netbuf *nControl)
GLOBALDEF int	FtpMkdir (const char *path, netbuf *nControl)
GLOBALDEF int	FtpModDate (const char *path, char *dt, int max, netbuf *nControl)
GLOBALDEF int	FtpNlst (const char *outputfile, const char *path, netbuf *nControl)
static int	FtpOpenPort (netbuf *nControl, netbuf **nData, int mode, int dir)
GLOBALDEF int	FtpOptions (int opt, long val, netbuf *nControl)
GLOBALDEF int	FtpPut (const char *inputfile, const char *path, char mode, netbuf *nControl)
GLOBALDEF int	FtpPwd (char *path, int max, netbuf *nControl)
GLOBALDEF void	FtpQuit (netbuf *nControl)
GLOBALDEF int	FtpRead (void *buf, int max, netbuf *nData)
GLOBALDEF int	FtpRename (const char *src, const char *dst, netbuf *nControl)
GLOBALDEF int	FtpRmdir (const char *path, netbuf *nControl)
static int	FtpSendCmd (const char *cmd, char expresp, netbuf *nControl)
GLOBALDEF int	FtpSite (const char *cmd, netbuf *nControl)
GLOBALDEF int	FtpSize (const char *path, int *size, char mode, netbuf *nControl)
GLOBALDEF int	FtpSysType (char *buf, int max, netbuf *nControl)
GLOBALDEF int	FtpWrite (void *buf, int len, netbuf *nData)
static int	FtpXfer (const char *localfile, const char *path, netbuf *nControl, int typ, int mode)
void *	mymemccpy (void *dst, const void *src, int c, size_t n)
static int	readline (char *buf, int max, netbuf *ctl)
static int	readresp (char c, netbuf *nControl)
static int	socket_wait (netbuf *ctl)
static int	writeline (char *buf, int len, netbuf *nData)

Variables
GLOBALDEF int	ftplib_debug = 0

Macro Definition Documentation

#define ACCEPT_TIMEOUT   10

Definition at line 77 of file ftplib.c.

#define BUILDING_LIBRARY

Definition at line 67 of file ftplib.c.

#define FTPLIB_BUFSIZ   8192

Definition at line 76 of file ftplib.c.

#define FTPLIB_CONTROL   0

Definition at line 79 of file ftplib.c.

#define FTPLIB_DEFMODE   FTPLIB_PASSIVE

Definition at line 84 of file ftplib.c.

#define FTPLIB_READ   1

Definition at line 80 of file ftplib.c.

#define FTPLIB_WRITE   2

Definition at line 81 of file ftplib.c.

#define lllog

(

M

)

fprintf(stderr, M);

Definition at line 92 of file ftplib.c.

#define SETSOCKOPT_OPTVAL_TYPE   (void *)

Definition at line 73 of file ftplib.c.

Function Documentation

static int FtpAcceptConnection ( netbuf *  nData, netbuf *  nControl  )

static

Definition at line 847 of file ftplib.c.

{
    int sData;
    struct sockaddr addr;
    socklen_t l;
    int i;
    struct timeval tv;
    fd_set mask;
    int rv = 0;

    FD_ZERO(&mask);
    FD_SET(nControl->handle, &mask);
    FD_SET(nData->handle, &mask);
    tv.tv_usec = 0;
    tv.tv_sec = ACCEPT_TIMEOUT;
    if (ftplib_debug > 1)
        printf("<<<<<<<<<<<<<<<<%d\n",ACCEPT_TIMEOUT);
    i = nControl->handle;
    if (i < nData->handle)
        i = nData->handle;
    i = select(i+1, &mask, NULL, NULL, &tv);
    if (i == -1)
      {
          strncpy(nControl->response, strerror(errno),
                  sizeof(nControl->response));
          net_close(nData->handle);
          nData->handle = 0;
          rv = 0;
      }
    else if (i == 0)
      {
          strcpy(nControl->response, "timed out waiting for connection");
          net_close(nData->handle);
          nData->handle = 0;
          rv = 0;
      }
    else
      {
          if (FD_ISSET(nData->handle, &mask))
            {
                l = sizeof(addr);
                sData = accept(nData->handle, &addr, &l);
                i = errno;
                net_close(nData->handle);
                if (sData > 0)
                  {
                      rv = 1;
                      nData->handle = sData;
                  }
                else
                  {
                      strncpy(nControl->response, strerror(i),
                              sizeof(nControl->response));
                      nData->handle = 0;
                      rv = 0;
                  }
            }
          else if (FD_ISSET(nControl->handle, &mask))
            {
                net_close(nData->handle);
                nData->handle = 0;
                readresp('2', nControl);
                rv = 0;
            }
      }
    return rv;  
}

GLOBALDEF int FtpAccess	(	const char *	path,
		int	typ,
		int	mode,
		netbuf *	nControl,
		netbuf **	nData
	)

Definition at line 920 of file ftplib.c.

{
    char buf[256];
    int dir;
    if ((path == NULL) &&
        ((typ == FTPLIB_FILE_WRITE) || (typ == FTPLIB_FILE_READ)))
      {
          sprintf(nControl->response,
                  "Missing path argument for file transfer\n");
          return 0;
      }
    sprintf(buf, "TYPE %c", mode);
    if (!FtpSendCmd(buf, '2', nControl))
        return 0;
    switch (typ)
      {
        case FTPLIB_DIR:
            strcpy(buf,"NLST");
            dir = FTPLIB_READ;
            break;
        case FTPLIB_DIR_VERBOSE:
            strcpy(buf,"LIST");
            dir = FTPLIB_READ;
            break;
        case FTPLIB_FILE_READ:
            strcpy(buf,"RETR");
            dir = FTPLIB_READ;
            break;
        case FTPLIB_FILE_WRITE:
            strcpy(buf,"STOR");
            dir = FTPLIB_WRITE;
            break;
        default:
            sprintf(nControl->response, "Invalid open type %d\n", typ);
            return 0;
      }
    if (path != NULL)
      {
          int i = (int)strlen(buf);
          buf[i++] = ' ';
          if ((strlen(path) + i) >= sizeof(buf))
              return 0;
          strcpy(&buf[i],path);
      }
    if (FtpOpenPort(nControl, nData, mode, dir) == -1)
        return 0;
    if (!FtpSendCmd(buf, '1', nControl))
      {
          FtpClose(*nData);
          *nData = NULL;
          return 0;
      }
    (*nData)->ctrl = nControl;
    nControl->data = *nData;
    if (nControl->cmode == FTPLIB_PORT)
      {
          if (!FtpAcceptConnection(*nData,nControl))
            {
                FtpClose(*nData);
                *nData = NULL;
                nControl->data = NULL;
                return 0;
            }
      }
    return 1;
}

GLOBALDEF int FtpCDUp

(

netbuf *

nControl

)

Definition at line 1168 of file ftplib.c.

{
    if (!FtpSendCmd("CDUP",'2',nControl))
        return 0;
    return 1;
}

GLOBALDEF int FtpChdir	(	const char *	path,
		netbuf *	nControl
	)

Definition at line 1151 of file ftplib.c.

{
    char buf[256];

    if ((strlen(path) + 6) > sizeof(buf))
        return 0;
    sprintf(buf,"CWD %s",path);
    if (!FtpSendCmd(buf,'2',nControl))
        return 0;
    return 1;
}

GLOBALDEF int FtpClose

(

netbuf *

nData

)

Definition at line 1054 of file ftplib.c.

{
    netbuf *ctrl;
    switch (nData->dir)
      {
        case FTPLIB_WRITE:
              /* potential problem - if buffer flush fails, how to notify user? */
            if (nData->buf != NULL)
                writeline(NULL, 0, nData);
        case FTPLIB_READ:
            if (nData->buf)
                free(nData->buf);
            shutdown(nData->handle,2);
            net_close(nData->handle);
            ctrl = nData->ctrl;
            free(nData);
            if (ctrl)
              {
                  ctrl->data = NULL;
                  return(readresp('2', ctrl));
              }
            return 1;
        case FTPLIB_CONTROL:
            if (nData->data)
              {
                  nData->ctrl = NULL;
                  FtpClose(nData);
              }
            net_close(nData->handle);
            free(nData);
            return 0;
      }
    return 1;
}

GLOBALDEF int FtpConnect	(	const char *	host,
		netbuf **	nControl
	)

Definition at line 444 of file ftplib.c.

{
    int sControl, stat, flags, oldflags;
    struct sockaddr_in sin;
    struct hostent *phe;
    struct servent *pse;
    int on=1;
    netbuf *ctrl;
    char *lhost;
    char *pnum;
    struct timeval tv;
    fd_set wr;

    memset(&sin,0,sizeof(sin));
    sin.sin_family = AF_INET;
    lhost = strdup(host);
    pnum = strchr(lhost,':');
    if (pnum == NULL)
      {
#if defined(VMS) || defined(ANDROID)
          sin.sin_port = htons(21);
#else
          if ((pse = getservbyname("ftp","tcp")) == NULL)
            {
                perror("getservbyname");
                return 0;
            }
          sin.sin_port = pse->s_port;
#endif
      }
    else
      {
          *pnum++ = '\0';
          if (isdigit(*pnum))
              sin.sin_port = htons(atoi(pnum));
          else
            {
                pse = getservbyname(pnum,"tcp");
                sin.sin_port = pse->s_port;
            }
      }
    if ((sin.sin_addr.s_addr = inet_addr(lhost)) == -1)
      {
          if ((phe = gethostbyname(lhost)) == NULL)
            {
                perror("gethostbyname");
                return 0;
            }

          memcpy((char *)&sin.sin_addr, phe->h_addr, phe->h_length);

      }
    free(lhost);

    sControl = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sControl == -1)
      {
          perror("socket");
          return 0;
      }

    if ( setsockopt(sControl,SOL_SOCKET,SO_REUSEADDR,
                   SETSOCKOPT_OPTVAL_TYPE &on, sizeof(on)) == -1)
      {
          perror("setsockopt");
          net_close(sControl);
          return 0;
      }

#if defined(_WIN32)
    if (connect(sControl, (struct sockaddr *)&sin, sizeof(sin)) == -1)
    {
        perror("connect");
        net_close(sControl);
        return 0;
    }
#else
     //set nonblocking for connection timeout
    flags = fcntl( sControl, F_GETFL,0);
    oldflags=flags;
    fcntl( sControl, F_SETFL, O_NONBLOCK|flags);

    stat=connect( sControl, (struct sockaddr *)&sin, sizeof(sin));
    if (stat < 0) 
      { 
          if (errno != EWOULDBLOCK && errno != EINPROGRESS) 
            { 
                perror("connect");
                net_close(sControl);
                return 0;
            } 
      } 

    FD_ZERO(&wr); 
    FD_SET( sControl, &wr); 

    tv.tv_sec = ACCEPT_TIMEOUT;
    tv.tv_usec = 0; 

    stat = select(sControl+1, 0, &wr, 0, &tv);

    if (stat < 1)
      { 
            // time out has expired, 
            // or an error has ocurred
          perror("timeout");
          net_close(sControl);
          return 0;
      } 

    if (ftplib_debug > 1)
        printf("connected\n");

      //set original flags
    fcntl( sControl, F_SETFL, oldflags);
#endif

    ctrl = calloc(1,sizeof(netbuf));
    if (ctrl == NULL)
      {
          perror("calloc");
          net_close(sControl);
          return 0;
      }
    ctrl->buf = malloc(FTPLIB_BUFSIZ);
    if (ctrl->buf == NULL)
      {
          perror("calloc");
          net_close(sControl);
          free(ctrl);
          return 0;
      }
    ctrl->handle = sControl;
    ctrl->dir = FTPLIB_CONTROL;
    ctrl->ctrl = NULL;
    ctrl->cmode = FTPLIB_DEFMODE;
    ctrl->idlecb = NULL;
    ctrl->writercb = NULL;
    ctrl->idletime.tv_sec = ctrl->idletime.tv_usec = 0;
    ctrl->idlearg = NULL;
    ctrl->writerarg = NULL;
    ctrl->xfered = 0;
    ctrl->xfered1 = 0;
    ctrl->cbbytes = 0;
    if (readresp('2', ctrl) == 0)
      {
          net_close(sControl);
          free(ctrl->buf);
          free(ctrl);
          return 0;
      }
    *nControl = ctrl;
    return 1;
}

GLOBALDEF int FtpDelete	(	const char *	fnm,
		netbuf *	nControl
	)

Definition at line 1397 of file ftplib.c.

{
    char cmd[256];

    if ((strlen(fnm) + 7) > sizeof(cmd))
        return 0;
    sprintf(cmd,"DELE %s",fnm);
    if (!FtpSendCmd(cmd,'2', nControl))
        return 0;
    return 1;
}

GLOBALDEF int FtpDir	(	const char *	outputfile,
		const char *	path,
		netbuf *	nControl
	)

Definition at line 1296 of file ftplib.c.

{
    return FtpXfer(outputfile, path, nControl, FTPLIB_DIR_VERBOSE, FTPLIB_ASCII);
}

GLOBALDEF int FtpGet	(	const char *	outputfile,
		const char *	path,
		char	mode,
		netbuf *	nControl
	)

Definition at line 1354 of file ftplib.c.

{
    return FtpXfer(outputfile, path, nControl, FTPLIB_FILE_READ, mode);
}

GLOBALDEF void FtpInit

(

void

)

Definition at line 416 of file ftplib.c.

{
#if defined(_WIN32)
    WORD wVersionRequested;
    WSADATA wsadata;
    int err;
    wVersionRequested = MAKEWORD(1,1);
    if ((err = WSAStartup(wVersionRequested,&wsadata)) != 0)
        if (ftplib_debug > 1)
            fprintf(stderr,"Network failed to start: %d\n",err);
#endif
}

GLOBALDEF char* FtpLastResponse

(

netbuf *

nControl

)

Definition at line 432 of file ftplib.c.

{
    if ((nControl) && (nControl->dir == FTPLIB_CONTROL))
        return nControl->response;
    return NULL;
}

GLOBALDEF int FtpLogin	(	const char *	user,
		const char *	pass,
		netbuf *	nControl
	)

Definition at line 675 of file ftplib.c.

{
    char tempbuf[64];

    if (((strlen(user) + 7) > sizeof(tempbuf)) ||
        ((strlen(pass) + 7) > sizeof(tempbuf)))
        return 0;
    sprintf(tempbuf,"USER %s",user);
    if (!FtpSendCmd(tempbuf,'3',nControl))
      {
          if (nControl->response[0] == '2')
              return 1;
          return 0;
      }
    sprintf(tempbuf,"PASS %s",pass);
    return FtpSendCmd(tempbuf,'2',nControl);
}

GLOBALDEF int FtpMkdir	(	const char *	path,
		netbuf *	nControl
	)

Definition at line 1134 of file ftplib.c.

{
    char buf[256];

    if ((strlen(path) + 6) > sizeof(buf))
        return 0;
    sprintf(buf,"MKD %s",path);
    if (!FtpSendCmd(buf,'2', nControl))
        return 0;
    return 1;
}

GLOBALDEF int FtpModDate	(	const char *	path,
		char *	dt,
		int	max,
		netbuf *	nControl
	)

Definition at line 1334 of file ftplib.c.

{
    char buf[256];
    int rv = 1;

    if ((strlen(path) + 7) > sizeof(buf))
        return 0;
    sprintf(buf,"MDTM %s",path);
    if (!FtpSendCmd(buf,'2',nControl))
        rv = 0;
    else
        strncpy(dt, &nControl->response[4], max);
    return rv;
}

GLOBALDEF int FtpNlst	(	const char *	outputfile,
		const char *	path,
		netbuf *	nControl
	)

Definition at line 1285 of file ftplib.c.

{
    return FtpXfer(outputfile, path, nControl, FTPLIB_DIR, FTPLIB_ASCII);
}

static int FtpOpenPort ( netbuf *  nControl, netbuf **  nData, int  mode, int  dir  )

static

Definition at line 698 of file ftplib.c.

{
    int sData;
    union {
        struct sockaddr sa;
        struct sockaddr_in in;
    } sin;
    struct linger lng = { 0, 0 };
    socklen_t l;
    int on=1;
    netbuf *ctrl;
    char *cp;
    unsigned int v[6];
    char buf[256];

    if (nControl->dir != FTPLIB_CONTROL)
        return -1;
    if ((dir != FTPLIB_READ) && (dir != FTPLIB_WRITE))
      {
          sprintf(nControl->response, "Invalid direction %d\n", dir);
          return -1;
      }
    if ((mode != FTPLIB_ASCII) && (mode != FTPLIB_IMAGE))
      {
          sprintf(nControl->response, "Invalid mode %c\n", mode);
          return -1;
      }
    l = sizeof(sin);
    if (nControl->cmode == FTPLIB_PASSIVE)
      {
          memset(&sin, 0, l);
          sin.in.sin_family = AF_INET;
          if (!FtpSendCmd("PASV",'2',nControl))
              return -1;
          cp = strchr(nControl->response,'(');
          if (cp == NULL)
              return -1;
          cp++;
          sscanf(cp,"%u,%u,%u,%u,%u,%u",&v[2],&v[3],&v[4],&v[5],&v[0],&v[1]);
          sin.sa.sa_data[2] = v[2];
          sin.sa.sa_data[3] = v[3];
          sin.sa.sa_data[4] = v[4];
          sin.sa.sa_data[5] = v[5];
          sin.sa.sa_data[0] = v[0];
          sin.sa.sa_data[1] = v[1];
      }
    else
      {
          if (getsockname(nControl->handle, &sin.sa, &l) < 0)
            {
                perror("getsockname");
                return 0;
            }
      }
    sData = socket(PF_INET,SOCK_STREAM,IPPROTO_TCP);
    if (sData == -1)
      {
          perror("socket");
          return -1;
      }
    if (setsockopt(sData,SOL_SOCKET,SO_REUSEADDR,
                   SETSOCKOPT_OPTVAL_TYPE &on,sizeof(on)) == -1)
      {
          perror("setsockopt");
          net_close(sData);
          return -1;
      }
    if (setsockopt(sData,SOL_SOCKET,SO_LINGER,
                   SETSOCKOPT_OPTVAL_TYPE &lng,sizeof(lng)) == -1)
      {
          perror("setsockopt");
          net_close(sData);
          return -1;
      }
    if (nControl->cmode == FTPLIB_PASSIVE)
      {
          if (connect(sData, &sin.sa, sizeof(sin.sa)) == -1)
            {
                perror("connect");
                net_close(sData);
                return -1;
            }
      }
    else
      {
          sin.in.sin_port = 0;
          if (bind(sData, &sin.sa, sizeof(sin)) == -1)
            {
                perror("bind");
                net_close(sData);
                return 0;
            }
          if (listen(sData, 1) < 0)
            {
                perror("listen");
                net_close(sData);
                return 0;
            }
          if (getsockname(sData, &sin.sa, &l) < 0)
              return 0;
          sprintf(buf, "PORT %d,%d,%d,%d,%d,%d",
                  (unsigned char) sin.sa.sa_data[2],
                  (unsigned char) sin.sa.sa_data[3],
                  (unsigned char) sin.sa.sa_data[4],
                  (unsigned char) sin.sa.sa_data[5],
                  (unsigned char) sin.sa.sa_data[0],
                  (unsigned char) sin.sa.sa_data[1]);
          if (!FtpSendCmd(buf,'2',nControl))
            {
                net_close(sData);
                return 0;
            }
      }
    ctrl = calloc(1,sizeof(netbuf));
    if (ctrl == NULL)
      {
          perror("calloc");
          net_close(sData);
          return -1;
      }
    if ((mode == 'A') && ((ctrl->buf = malloc(FTPLIB_BUFSIZ)) == NULL))
      {
          perror("calloc");
          net_close(sData);
          free(ctrl);
          return -1;
      }
    ctrl->handle = sData;
    ctrl->dir = dir;
    ctrl->idletime = nControl->idletime;
    ctrl->idlearg = nControl->idlearg;
    ctrl->writerarg = nControl->writerarg;
    ctrl->xfered = 0;
    ctrl->xfered1 = 0;
    ctrl->cbbytes = nControl->cbbytes;
    if (ctrl->idletime.tv_sec || ctrl->idletime.tv_usec || ctrl->cbbytes)
        ctrl->idlecb = nControl->idlecb;
    else
        ctrl->idlecb = NULL;
    ctrl->writercb = nControl->writercb;
    *nData = ctrl;
    return 1;
}

GLOBALDEF int FtpOptions	(	int	opt,
		long	val,
		netbuf *	nControl
	)

Definition at line 604 of file ftplib.c.

{
    int v,rv=0;
    switch (opt)
      {
        case FTPLIB_CONNMODE:
            v = (int) val;
            if ((v == FTPLIB_PASSIVE) || (v == FTPLIB_PORT))
              {
                  nControl->cmode = v;
                  rv = 1;
              }
            break;
        case FTPLIB_CALLBACK:
            nControl->idlecb = (FtpCallback) val;
            rv = 1;
            break;
        case FTPLIB_CALLBACK_WRITER:
            nControl->writercb = (FtpCallbackWriter) val;
            rv = 1;
            break;
        case FTPLIB_IDLETIME:
            v = (int) val;
            rv = 1;
            nControl->idletime.tv_sec = v / 1000;
            nControl->idletime.tv_usec = (v % 1000) * 1000;
            break;
        case FTPLIB_CALLBACKARG:
            rv = 1;
            nControl->idlearg = (void *) val;
            break;
        case FTPLIB_CALLBACK_WRITERARG:
            rv = 1;
            nControl->writerarg = (void *) val;
            break;
        case FTPLIB_CALLBACKBYTES:
            rv = 1;
            nControl->cbbytes = (int) val;
            break;
      }
    return rv;
}

GLOBALDEF int FtpPut	(	const char *	inputfile,
		const char *	path,
		char	mode,
		netbuf *	nControl
	)

Definition at line 1365 of file ftplib.c.

{
    return FtpXfer(inputfile, path, nControl, FTPLIB_FILE_WRITE, mode);
}

GLOBALDEF int FtpPwd	(	char *	path,
		int	max,
		netbuf *	nControl
	)

Definition at line 1197 of file ftplib.c.

{
    int l = max;
    char *b = path;
    char *s;
    if (!FtpSendCmd("PWD",'2',nControl))
        return 0;
    s = strchr(nControl->response, '"');
    if (s == NULL)
        return 0;
    s++;
    while ((--l) && (*s) && (*s != '"'))
        *b++ = *s++;
    *b++ = '\0';
    return 1;
}

GLOBALDEF void FtpQuit

(

netbuf *

nControl

)

Definition at line 1414 of file ftplib.c.

{
    if (nControl->dir != FTPLIB_CONTROL)
        return;
    FtpSendCmd("QUIT",'2',nControl);
    net_close(nControl->handle);
    free(nControl->buf);
    free(nControl);
}

GLOBALDEF int FtpRead	(	void *	buf,
		int	max,
		netbuf *	nData
	)

Definition at line 991 of file ftplib.c.

{
    int i;
    if (nData->dir != FTPLIB_READ)
        return 0;
    if (nData->buf)
        i = readline(buf, max, nData);
    else
      {
          i = socket_wait(nData);
          if (i != 1)
              return 0;
          i = (int)net_read(nData->handle, buf, max);
      }
    if (i == -1)
        return 0;
    nData->xfered += i;
    if (nData->idlecb && nData->cbbytes)
      {
          nData->xfered1 += i;
          if (nData->xfered1 > nData->cbbytes)
            {
                if (nData->idlecb(nData, nData->xfered, nData->idlearg) == 0)
                    return 0;
                nData->xfered1 = 0;
            }
      }
    return i;
}

GLOBALDEF int FtpRename	(	const char *	src,
		const char *	dst,
		netbuf *	nControl
	)

Definition at line 1376 of file ftplib.c.

{
    char cmd[256];

    if (((strlen(src) + 7) > sizeof(cmd)) ||
        ((strlen(dst) + 7) > sizeof(cmd)))
        return 0;
    sprintf(cmd,"RNFR %s",src);
    if (!FtpSendCmd(cmd,'3',nControl))
        return 0;
    sprintf(cmd,"RNTO %s",dst);
    if (!FtpSendCmd(cmd,'2',nControl))
        return 0;
    return 1;
}

GLOBALDEF int FtpRmdir	(	const char *	path,
		netbuf *	nControl
	)

Definition at line 1180 of file ftplib.c.

{
    char buf[256];

    if ((strlen(path) + 6) > sizeof(buf))
        return 0;
    sprintf(buf,"RMD %s",path);
    if (!FtpSendCmd(buf,'2',nControl))
        return 0;
    return 1;
}

static int FtpSendCmd ( const char *  cmd, char  expresp, netbuf *  nControl  )

static

Definition at line 652 of file ftplib.c.

{
    char buf[256];
    if (nControl->dir != FTPLIB_CONTROL)
        return 0;
    if (ftplib_debug > 2)
        fprintf(stderr,"%s\n",cmd);
    if ((strlen(cmd) + 3) > sizeof(buf))
        return 0;
    sprintf(buf,"%s\r\n",cmd);
    if (net_write(nControl->handle,buf,strlen(buf)) <= 0)
      {
          perror("write");
          return 0;
      }
    return readresp(expresp, nControl);
}

GLOBALDEF int FtpSite	(	const char *	cmd,
		netbuf *	nControl
	)

Definition at line 1094 of file ftplib.c.

{
    char buf[256];
    
    if ((strlen(cmd) + 7) > sizeof(buf))
        return 0;
    sprintf(buf,"SITE %s",cmd);
    if (!FtpSendCmd(buf,'2',nControl))
        return 0;
    return 1;
}

GLOBALDEF int FtpSize	(	const char *	path,
		int *	size,
		char	mode,
		netbuf *	nControl
	)

Definition at line 1306 of file ftplib.c.

{
    char cmd[256];
    int resp,sz,rv=1;

    if ((strlen(path) + 7) > sizeof(cmd))
        return 0;
    sprintf(cmd, "TYPE %c", mode);
    if (!FtpSendCmd(cmd, '2', nControl))
        return 0;
    sprintf(cmd,"SIZE %s",path);
    if (!FtpSendCmd(cmd,'2',nControl))
        rv = 0;
    else
      {
          if (sscanf(nControl->response, "%d %d", &resp, &sz) == 2)
              *size = sz;
          else
              rv = 0;
      }   
    return rv;
}

GLOBALDEF int FtpSysType	(	char *	buf,
		int	max,
		netbuf *	nControl
	)

Definition at line 1115 of file ftplib.c.

{
    int l = max;
    char *b = buf;
    char *s;
    if (!FtpSendCmd("SYST",'2',nControl))
        return 0;
    s = &nControl->response[4];
    while ((--l) && (*s != ' '))
        *b++ = *s++;
    *b++ = '\0';
    return 1;
}

GLOBALDEF int FtpWrite	(	void *	buf,
		int	len,
		netbuf *	nData
	)

Definition at line 1024 of file ftplib.c.

{
    int i;
    if (nData->dir != FTPLIB_WRITE)
        return 0;
    if (nData->buf)
        i = writeline(buf, len, nData);
    else
      {
          socket_wait(nData);
          i = (int)net_write(nData->handle, buf, len);
      }
    if (i == -1)
        return 0;
    nData->xfered += i;
    if (nData->idlecb && nData->cbbytes)
      {
          nData->xfered1 += i;
          if (nData->xfered1 > nData->cbbytes)
            {
                nData->idlecb(nData, nData->xfered, nData->idlearg);
                nData->xfered1 = 0;
            }
      }
    return i;
}

static int FtpXfer ( const char *  localfile, const char *  path, netbuf *  nControl, int  typ, int  mode  )

static

Definition at line 1219 of file ftplib.c.

{
    int l,c;
    char *dbuf;
    FILE *local = NULL;
    netbuf *nData;
    int rv=1;
    int writeResult = 0;

    if (localfile != NULL)
      {
          char ac[4] = "w";
          if (typ == FTPLIB_FILE_WRITE)
              ac[0] = 'r';
          if (mode == FTPLIB_IMAGE)
              ac[1] = 'b';
          local = fopen(localfile, ac);
          if (local == NULL)
            {
                strncpy(nControl->response, strerror(errno),
                        sizeof(nControl->response));
                return 0;
            }
      }
    if (local == NULL)
        local = (typ == FTPLIB_FILE_WRITE) ? stdin : stdout;
    if (!FtpAccess(path, typ, mode, nControl, &nData))
        return 0;
    dbuf = malloc(FTPLIB_BUFSIZ);
    if (typ == FTPLIB_FILE_WRITE)
      {
          while ((l = (int)fread(dbuf, 1, FTPLIB_BUFSIZ, local)) > 0)
              if ((c = FtpWrite(dbuf, l, nData)) < l)
                {
                    if (ftplib_debug > 1)
                        printf("short write: passed %d, wrote %d\n", l, c);
                    rv = 0;
                    break;
                }
      }
    else
      {
          while ((l = FtpRead(dbuf, FTPLIB_BUFSIZ, nData)) > 0) {
              writeResult = (int)((nData->writercb) ? nData->writercb(nData, dbuf, l, nData->writerarg) : fwrite(dbuf, 1, l, local));
              if (writeResult <= 0)
                {
                    perror("localstore write");
                    rv = 0;
                    break;
                }
          }
      }
    free(dbuf);
    fflush(local);
    if (localfile != NULL)
        fclose(local);
    FtpClose(nData);
    return rv;
}

void* mymemccpy	(	void *	dst,
		const void *	src,
		int	c,
		size_t	n
	)

Definition at line 95 of file ftplib.c.

{
    char*        q     = dst;
    const char*  p     = src;
    const char*  p_end = p + n;
    char         ch    = ~(char)c;  /* ensure ch != c */

    for (;;) {
        if (ch == c || p >= p_end) break;
        *q++ = ch = *p++;

        if (ch == c || p >= p_end) break;
        *q++ = ch = *p++;

        if (ch == c || p >= p_end) break;
        *q++ = ch = *p++;

        if (ch == c || p >= p_end) break;
        *q++ = ch = *p++;
    }

    if (p >= p_end && ch != c)
        return NULL;

    return q;
}

static int readline ( char *  buf, int  max, netbuf *  ctl  )

static

Definition at line 240 of file ftplib.c.

{
    int x,retval = 0;
    char *end,*bp=buf;
    int eof = 0;

    if ((ctl->dir != FTPLIB_CONTROL) && (ctl->dir != FTPLIB_READ))
        return -1;
    if (max == 0)
        return 0;
    do
      {
          if (ctl->cavail > 0)
            {
                x = (max >= ctl->cavail) ? ctl->cavail : max-1;
                end = mymemccpy(bp,ctl->cget,'\n',x);
                if (end != NULL) {
                    x = (int)(end - bp);
             }
                retval += x;
                bp += x;
                *bp = '\0';
                max -= x;
                ctl->cget += x;
                ctl->cavail -= x;
                if (end != NULL)
                  {
                      bp -= 2;
                      if (strcmp(bp,"\r\n") == 0)
                        {
                            *bp++ = '\n';
                            *bp++ = '\0';
                            --retval;
                        }
                      break;
                  }
            }
          if (max == 1)
            {
                *buf = '\0';
                break;
            }
          if (ctl->cput == ctl->cget)
            {
                ctl->cput = ctl->cget = ctl->buf;
                ctl->cavail = 0;
                ctl->cleft = FTPLIB_BUFSIZ;
            }
          if (eof)
            {
                if (retval == 0)
                    retval = -1;
                break;
            }
          if (!socket_wait(ctl))
              return retval;
          if ((x = (int)net_read(ctl->handle,ctl->cput,ctl->cleft)) == -1)
            {
                perror("read");
                retval = -1;
                break;
            }
          if (x == 0) //< ctl->cleft)
              eof = 1;
          ctl->cleft -= x;
          ctl->cavail += x;
          ctl->cput += x;
      }
    while (1);
    return retval;
}

static int readresp ( char  c, netbuf *  nControl  )

static

Definition at line 381 of file ftplib.c.

{
    char match[5];
    if (readline(nControl->response,256,nControl) == -1)
      {
          perror("Control socket read failed");
          return 0;
      }
    if (ftplib_debug > 1)
        fprintf(stderr,"%s",nControl->response);
    if (nControl->response[3] == '-')
      {
          strncpy(match,nControl->response,3);
          match[3] = ' ';
          match[4] = '\0';
          do
            {
                if (readline(nControl->response,256,nControl) == -1)
                  {
                      perror("Control socket read failed");
                      return 0;
                  }
                if (ftplib_debug > 1)
                    fprintf(stderr,"%s",nControl->response);
            }
          while (strncmp(nControl->response,match,4));
      }
    if (nControl->response[0] == c)
        return 1;
    return 0;
}

static int socket_wait ( netbuf *  ctl )

static

Definition at line 201 of file ftplib.c.

{
    fd_set fd,*rfd = NULL,*wfd = NULL;
    struct timeval tv;
    int rv = 0;
    if ((ctl->dir == FTPLIB_CONTROL) || (ctl->idlecb == NULL))
        return 1;
    if (ctl->dir == FTPLIB_WRITE)
        wfd = &fd;
    else
        rfd = &fd;
    FD_ZERO(&fd);
    do
      {
          FD_SET(ctl->handle,&fd);
          tv = ctl->idletime;
          rv = select(ctl->handle+1, rfd, wfd, NULL, &tv);
          if (rv == -1)
            {
                rv = 0;
                strncpy(ctl->ctrl->response, strerror(errno),
                        sizeof(ctl->ctrl->response));
                break;
            }
          else if (rv > 0)
            {
                rv = 1;
                break;
            }
      }
    while ((rv = ctl->idlecb(ctl, ctl->xfered, ctl->idlearg)));
    return rv;
}

static int writeline ( char *  buf, int  len, netbuf *  nData  )

static

Definition at line 317 of file ftplib.c.

{
    int x, nb=0, w;
    char *ubp = buf, *nbp;
    char lc=0;

    if (nData->dir != FTPLIB_WRITE)
        return -1;
    nbp = nData->buf;
    for (x=0; x < len; x++)
      {
          if ((*ubp == '\n') && (lc != '\r'))
            {
                if (nb == FTPLIB_BUFSIZ)
                  {
                      if (!socket_wait(nData))
                          return x;
                      w = (int)net_write(nData->handle, nbp, FTPLIB_BUFSIZ);
                      if (w != FTPLIB_BUFSIZ)
                        {
                            if (ftplib_debug > 1)
                                printf("net_write(1) returned %d, errno = %d\n", w, errno);
                            return(-1);
                        }
                      nb = 0;
                  }
                nbp[nb++] = '\r';
            }
          if (nb == FTPLIB_BUFSIZ)
            {
                if (!socket_wait(nData))
                    return x;
                w = (int)net_write(nData->handle, nbp, FTPLIB_BUFSIZ);
                if (w != FTPLIB_BUFSIZ)
                  {
                        if (ftplib_debug > 1)
                            printf("net_write(2) returned %d, errno = %d\n", w, errno);
                      return(-1);
                  }
                nb = 0;
            }
          nbp[nb++] = lc = *ubp++;
      }
    if (nb)
      {
          if (!socket_wait(nData))
              return x;
          w = (int)net_write(nData->handle, nbp, nb);
          if (w != nb)
            {
                if (ftplib_debug > 1)
                    printf("net_write(3) returned %d, errno = %d\n", w, errno);
                return(-1);
            }
      }
    return len;
}

Variable Documentation

GLOBALDEF int ftplib_debug = 0

Definition at line 148 of file ftplib.c.