Logo Search packages:      
Sourcecode: kasablanca version File versions  Download package

ftplib.cpp

/***************************************************************************
                          ftplib.cpp  -  description
                             -------------------
    begin                : Son Jul 27 2003
    copyright            : (C) 2003 by mkulke
    email                : sikor_sxe@radicalapproach.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

/* original unmodified copyright notes from Thomas Pfau */
 
/***************************************************************************/
/*                                                       */
/* ftplib.c - callable ftp access routines                           */
/* Copyright (C) 1996, 1997, 1998 Thomas Pfau, pfau@cnj.digex.net    */
/*    73 Catherine Street, South Bound Brook, NJ, 08880              */
/*                                                       */
/* This library is free software; you can redistribute it and/or     */
/* modify it under the terms of the GNU Library General Public             */
/* License as published by the Free Software Foundation; either            */
/* version 2 of the License, or (at your option) any later version.        */
/*                                                       */
/* This library is distributed in the hope that it will be useful,         */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of    */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU       */
/* Library General Public License for more details.                  */
/*                                                       */
/* You should have received a copy of the GNU Library General Public       */
/* License along with this progam; if not, write to the                    */
/* Free Software Foundation, Inc., 59 Temple Place - Suite 330,            */
/* Boston, MA 02111-1307, USA.                                       */
/*                                                       */
/***************************************************************************/

// enable > 2gb support (LFS)

#define _LARGEFILE_SOURCE
#define _LARGEFILE64_SOURCE

#include "ftplib.h"
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <string>

using namespace std;

/* socket values */
#define SETSOCKOPT_OPTVAL_TYPE (void *)
#define FTPLIB_BUFSIZ 1024
#define ACCEPT_TIMEOUT 30

/* io types */
#define FTPLIB_CONTROL 0
#define FTPLIB_READ 1
#define FTPLIB_WRITE 2

/*
 * Constructor
 */

ftplib::ftplib()
{
      SSL_library_init();

      mp_netbuf = static_cast<netbuf *>(calloc(1,sizeof(netbuf)));
      if (mp_netbuf == NULL) perror("calloc");
      mp_netbuf->buf = static_cast<char *>(malloc(FTPLIB_BUFSIZ));
      if (mp_netbuf->buf == NULL)
      {
            perror("calloc");
            free(mp_netbuf);
      }
      mp_netbuf->ctx = SSL_CTX_new(SSLv23_method());
      SSL_CTX_set_verify(mp_netbuf->ctx, SSL_VERIFY_NONE, NULL);
      mp_netbuf->ssl = SSL_new(mp_netbuf->ctx);

      ClearNetbuf();
}

/*
 * Destructor
 */

ftplib::~ftplib()
{
      SSL_free(mp_netbuf->ssl);
      SSL_CTX_free(mp_netbuf->ctx);
   free(mp_netbuf->buf);
   free(mp_netbuf);
}

/*
 * socket_wait - wait for socket to receive or flush data
 *
 * return 1 if no user callback, otherwise, return value returned by
 * user callback
 */
int ftplib::socket_wait(netbuf *ctl)
{
      fd_set fd,*rfd = NULL,*wfd = NULL;
      struct timeval tv;
      int rv = 0;

      if (ctl->idlecb == NULL) return 1;

      /*if ((ctl->dir == FTPLIB_CONTROL)
            || (ctl->idlecb == NULL)
            || ((ctl->idletime.tv_sec == 0)
            && //(ctl->idletime.tv_usec 0))
      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->cbarg)));

      return rv;
}

/*
 * read a line of text
 *
 * return -1 on error or bytecount
 */
int ftplib::readline(char *buf,int max,netbuf *ctl)
{
      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 = static_cast<char*>(memccpy(bp,ctl->cget,'\n',x));
                  if (end != NULL)
                  x = 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 (ctl->tlsdata) x = SSL_read(ctl->ssl, ctl->cput, ctl->cleft);
            else
            {
                  if (ctl->tlsctrl) x = SSL_read(ctl->ssl, ctl->cput, ctl->cleft);
                  else x = read(ctl->handle,ctl->cput,ctl->cleft);
            }
            if ( x == -1)
            {
                  perror("read");
                  retval = -1;
                  break;
            }

            // LOGGING FUNCTIONALITY!!!

            if ((ctl->dir == FTPLIB_CONTROL) && (mp_netbuf->logcb != NULL))
            {
                  *((ctl->cput)+x) = '\0';
                  mp_netbuf->logcb(ctl->cput, mp_netbuf->cbarg, true);
            }

            if (x == 0) eof = 1;
            ctl->cleft -= x;
            ctl->cavail += x;
            ctl->cput += x;
      } while (1);
      return retval;
}

/*
 * write lines of text
 *
 * return -1 on error or bytecount
 */
int ftplib::writeline(char *buf, int len, netbuf *nData)
{
      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;

                        if (nData->tlsctrl) w = SSL_write(nData->ssl, nbp, FTPLIB_BUFSIZ);
                        else w = write(nData->handle, nbp, FTPLIB_BUFSIZ);

                        if (w != FTPLIB_BUFSIZ)
                        {
                              printf("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;

                  if (nData->tlsctrl) w = SSL_write(nData->ssl, nbp, FTPLIB_BUFSIZ);
                  else w = write(nData->handle, nbp, FTPLIB_BUFSIZ);

                  if (w != FTPLIB_BUFSIZ)
                  {
                        printf("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;
            if (nData->tlsctrl) w = SSL_write(nData->ssl, nbp, nb);
            else w = write(nData->handle, nbp, nb);
            if (w != nb)
            {
                  printf("write(3) returned %d, errno = %d\n", w, errno);
                  return(-1);
            }
      }
      return len;
}

/*
 * read a response from the server
 *
 * return 0 if first char doesn't match
 * return 1 if first char matches
 */
int ftplib::readresp(char c, netbuf *nControl)
{
      char match[5];
      
      if (readline(nControl->response,256,nControl) == -1)
      {
            perror("Control socket read failed");
            return 0;
      }
      
      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;
                  }
            } while (strncmp(nControl->response,match,4));
      }
      if (nControl->response[0] == c) return 1;
      return 0;
}

/*
 * FtpLastResponse - return a pointer to the last response received
 */
char* ftplib::LastResponse()
{
      if ((mp_netbuf) && (mp_netbuf->dir == FTPLIB_CONTROL)) return mp_netbuf->response;
      return NULL;
}

/*
 * ftplib::Connect - connect to remote server
 *
 * return 1 if connected, 0 if not
 */
int ftplib::Connect(const char *host)
{
      int sControl;
      struct sockaddr_in sin;
      struct hostent *phe;
      struct servent *pse;
      int on=1;
      int ret;
      char *lhost;
      char *pnum;
      
      mp_netbuf->dir = FTPLIB_CONTROL;
      mp_netbuf->ctrl = NULL;
      mp_netbuf->xfered = 0;
      mp_netbuf->xfered1 = 0;
      mp_netbuf->tlsctrl = 0;
      mp_netbuf->tlsdata = 0;
      mp_netbuf->offset = 0;
      mp_netbuf->handle = 0;
      
      memset(&sin,0,sizeof(sin));
      sin.sin_family = AF_INET;
      lhost = strdup(host);
      pnum = strchr(lhost,':');
      if (pnum == NULL)
      {
            if ((pse = getservbyname("ftp","tcp")) == NULL)
            {
            perror("getservbyname");
            return 0;
            }
            sin.sin_port = pse->s_port;
      }
      else
      {
            *pnum++ = '\0';
            if (isdigit(*pnum)) sin.sin_port = htons(atoi(pnum));
            else
            {
                  pse = getservbyname(pnum,"tcp");
                  sin.sin_port = pse->s_port;
            }
      }
      
      ret = inet_aton(lhost, &sin.sin_addr);
      if (ret == 0)
      {
            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");
            close(sControl);
            return 0;
      }
      if (connect(sControl, (struct sockaddr *)&sin, sizeof(sin)) == -1)
      {
            perror("connect");
            close(sControl);
            return 0;
      }

      mp_netbuf->handle = sControl;

      if (readresp('2', mp_netbuf) == 0)
      {
            close(sControl);
            mp_netbuf->handle = 0;
            return 0;
      }

      return 1;
}

/*
 * FtpSendCmd - send a command and wait for expected response
 *
 * return 1 if proper response received, 0 otherwise
 */
int ftplib::FtpSendCmd(const char *cmd, char expresp, netbuf *nControl)
{
      char buf[256];
      int x;

      if (!nControl->handle) return 0;

      if (nControl->dir != FTPLIB_CONTROL) return 0;
      sprintf(buf,"%s\r\n",cmd);

      if (nControl->tlsctrl) x = SSL_write(nControl->ssl,buf,strlen(buf));
      else x = write(nControl->handle,buf,strlen(buf));

      if (x <= 0)
      {
            perror("write");
            return 0;
      }

      if (mp_netbuf->logcb != NULL) mp_netbuf->logcb(buf, mp_netbuf->cbarg, false);
      
      return readresp(expresp, nControl);
}

/*
 * FtpLogin - log in to remote server
 *
 * return 1 if logged in, 0 otherwise
 */
int ftplib::Login(const char *user, const char *pass)
{
      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',mp_netbuf))
      {
            if (mp_netbuf->ctrl != NULL) return 1;
            if (*LastResponse() == '2') return 1;
            return 0;
      }
      sprintf(tempbuf,"PASS %s",pass);
      return FtpSendCmd(tempbuf,'2',mp_netbuf);
}

/*
 * FtpAcceptConnection - accept connection from server
 *
 * return 1 if successful, 0 otherwise
 */
int ftplib::FtpAcceptConnection(netbuf *nData, netbuf *nControl)
{
      int sData;
      struct sockaddr addr;
      unsigned int 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;
      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));
            close(nData->handle);
            nData->handle = 0;
            rv = 0;
      }
      else if (i == 0)
      {
            strcpy(nControl->response, "timed out waiting for connection");
            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;
                  close(nData->handle);
                  if (sData > 0)
                  {
                        rv = 1;
                        nData->handle = sData;
                        nData->ctrl = nControl;
                  }
                  else
                  {
                        strncpy(nControl->response, strerror(i), sizeof(nControl->response));
                        nData->handle = 0;
                        rv = 0;
                  }
            }
            else if (FD_ISSET(nControl->handle, &mask))
            {
                  close(nData->handle);
                  nData->handle = 0;
                  readresp('2', nControl);
                  rv = 0;
            }
      }
      return rv;
}

/*
 * FtpAccess - return a handle for a data stream
 *
 * return 1 if successful, 0 otherwise
 */
int ftplib::FtpAccess(const char *path, int typ, int mode, netbuf *nControl, netbuf **nData)
//int ftplib::FtpAccess(const char *path, int typ, int mode)
{
      char buf[256];
      int dir, ret;

      if ((path == NULL) && ((typ == FTPLIB_FILE_WRITE)
            || (typ == FTPLIB_FILE_READ)
            || (typ == FTPLIB_FILE_READ_APPEND)
            || (typ == FTPLIB_FILE_WRITE_APPEND)))
      {
            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 -aL");
            dir = FTPLIB_READ;
            break;
      case FTPLIB_FILE_READ_APPEND:
      case FTPLIB_FILE_READ:
            strcpy(buf,"RETR");
            dir = FTPLIB_READ;
            break;
      case FTPLIB_FILE_WRITE_APPEND:
      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 = strlen(buf);
            buf[i++] = ' ';
            if ((strlen(path) + i) >= sizeof(buf)) return 0;
            strcpy(&buf[i],path);
      }

      if (nControl->cmode == ftplib::pasv)
      {
            if (FtpOpenPasv(nControl, nData, mode, dir, buf) == -1) return 0;
      }

      if (nControl->cmode == ftplib::port)
      {
            if (FtpOpenPort(nControl, nData, mode, dir, buf) == -1) return 0;
            if (!FtpAcceptConnection(*nData,nControl))
            {
                  FtpClose(*nData);
                  *nData = NULL;
                  return 0;
            }
      }

      if (nControl->tlsdata)
      {
            (*nData)->ssl = SSL_new(nControl->ctx);
            (*nData)->sbio = BIO_new_socket((*nData)->handle, BIO_NOCLOSE);
            SSL_set_bio((*nData)->ssl,(*nData)->sbio,(*nData)->sbio);
            ret = SSL_connect((*nData)->ssl);
            if (ret != 1) return 0;
            (*nData)->tlsdata = 1;
      }

      return 1;
}

/*
 * FtpOpenPort - Establishes a PORT connection for data transfer
 *
 * return 1 if successful, -1 otherwise
 */
int ftplib::FtpOpenPort(netbuf *nControl, netbuf **nData, int mode, int dir, char *cmd)
{
      int sData;
      union {
      struct sockaddr sa;
      struct sockaddr_in in;
      } sin;
      struct linger lng = { 0, 0 };
      unsigned int l;
      int on=1;
      netbuf *ctrl;
      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 (getsockname(nControl->handle, &sin.sa, &l) < 0)
      {
            perror("getsockname");
            return -1;
      }

      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");
            close(sData);
            return -1;
      }
      if (setsockopt(sData,SOL_SOCKET,SO_LINGER, SETSOCKOPT_OPTVAL_TYPE &lng,sizeof(lng)) == -1)
      {
            perror("setsockopt");
            close(sData);
            return -1;
      }

      sin.in.sin_port = 0;
      if (bind(sData, &sin.sa, sizeof(sin)) == -1)
      {
            perror("bind");
            close(sData);
            return -1;
      }
      if (listen(sData, 1) < 0)
      {
            perror("listen");
            close(sData);
            return -1;
      }
      if (getsockname(sData, &sin.sa, &l) < 0) return 0;
      sprintf(buf, "PORT %hhu,%hhu,%hhu,%hhu,%hhu,%hhu",
            (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))
      {
            close(sData);
            return -1;
      }

      if (mp_netbuf->offset != 0)
      {
      char buf[256];
      sprintf(buf,"REST %lld", mp_netbuf->offset);
      if (!FtpSendCmd(buf,'3',nControl))
      {
            close(sData);
            return 0;
      }
      }

      ctrl = static_cast<netbuf*>(calloc(1,sizeof(netbuf)));
      if (ctrl == NULL)
      {
            perror("calloc");
            close(sData);
            return -1;
      }
      if ((mode == 'A') && ((ctrl->buf = static_cast<char*>(malloc(FTPLIB_BUFSIZ))) == NULL))
      {
            perror("calloc");
            close(sData);
            free(ctrl);
            return -1;
      }

      if (!FtpSendCmd(cmd, '1', nControl))
      {
            FtpClose(*nData);
            *nData = NULL;
            return -1;
      }

      ctrl->handle = sData;
      ctrl->dir = dir;
      ctrl->ctrl = (nControl->cmode == ftplib::pasv) ? nControl : NULL;
      ctrl->idletime = nControl->idletime;
      ctrl->cbarg = nControl->cbarg;
      ctrl->xfered = 0;
      ctrl->xfered1 = 0;
      ctrl->cbbytes = nControl->cbbytes;
      if (ctrl->idletime.tv_sec || ctrl->idletime.tv_usec) ctrl->idlecb = nControl->idlecb;
      else ctrl->idlecb = NULL;
      if (ctrl->cbbytes ) ctrl->xfercb = nControl->xfercb;
      else ctrl->xfercb = NULL;
      *nData = ctrl;

      return 1;
}

/*
 * FtpOpenPasv - Establishes a PASV connection for data transfer
 *
 * return 1 if successful, -1 otherwise
 */
int ftplib::FtpOpenPasv(netbuf *nControl, netbuf **nData, int mode, int dir, char *cmd)
{
      int sData;
      union {
            struct sockaddr sa;
            struct sockaddr_in in;
      } sin;
      struct linger lng = { 0, 0 };
      unsigned int l;
      int on=1;
      netbuf *ctrl;
      char *cp;
      unsigned char v[6];
      int ret;

      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);

      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,"%hhu,%hhu,%hhu,%hhu,%hhu,%hhu",&v[2],&v[3],&v[4],&v[5],&v[0],&v[1]);
      if (nControl->correctpasv) if (!CorrectPasvResponse(v)) return -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];

      if (mp_netbuf->offset != 0)
      {
            char buf[256];
            sprintf(buf,"REST %lld",mp_netbuf->offset);
            if (!FtpSendCmd(buf,'3',nControl)) 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");
            close(sData);
            return -1;
      }
      if (setsockopt(sData,SOL_SOCKET,SO_LINGER, SETSOCKOPT_OPTVAL_TYPE &lng,sizeof(lng)) == -1)
      {
            perror("setsockopt");
            close(sData);
            return -1;
      }

      if (nControl->dir != FTPLIB_CONTROL) return -1;
      sprintf(cmd,"%s\r\n",cmd);
      if (nControl->tlsctrl) ret = SSL_write(nControl->ssl,cmd,strlen(cmd));
      else ret = write(nControl->handle,cmd,strlen(cmd));
      if (ret <= 0)
      {
            perror("write");
            return -1;
      }

      if (connect(sData, &sin.sa, sizeof(sin.sa)) == -1)
      {
            perror("connect");
            close(sData);
            return -1;
      }
      if (!readresp('1', nControl))
      {
            close(sData);
            return -1;
      }
      ctrl = static_cast<netbuf*>(calloc(1,sizeof(netbuf)));
      if (ctrl == NULL)
      {
            perror("calloc");
            close(sData);
            return -1;
      }
      if ((mode == 'A') && ((ctrl->buf = static_cast<char*>(malloc(FTPLIB_BUFSIZ))) == NULL))
      {
            perror("calloc");
            close(sData);
            free(ctrl);
            return -1;
      }
      ctrl->handle = sData;
      ctrl->dir = dir;
      ctrl->ctrl = (nControl->cmode == ftplib::pasv) ? nControl : NULL;
      ctrl->idletime = nControl->idletime;
      ctrl->cbarg = nControl->cbarg;
      ctrl->xfered = 0;
      ctrl->xfered1 = 0;
      ctrl->cbbytes = nControl->cbbytes;
      if (ctrl->idletime.tv_sec || ctrl->idletime.tv_usec) ctrl->idlecb = nControl->idlecb;
      else ctrl->idlecb = NULL;
      if (ctrl->cbbytes ) ctrl->xfercb = nControl->xfercb;
      else ctrl->xfercb = NULL;
      *nData = ctrl;

      return 1;
}

/*
 * FtpClose - close a data connection
 */
int ftplib::FtpClose(netbuf *nData)
{
      netbuf *ctrl;

      if (nData->dir == FTPLIB_WRITE)
      {
            if (nData->buf != NULL) writeline(NULL, 0, nData);
      }
      else if (nData->dir != FTPLIB_READ) return 0;
      if (nData->buf) free(nData->buf);
      shutdown(nData->handle,2);
      close(nData->handle);

      ctrl = nData->ctrl;
      SSL_free(nData->ssl);
      free(nData);
      if (ctrl) return readresp('2', ctrl);
      return 1;
}

/*
 * FtpRead - read from a data connection
 */
int ftplib::FtpRead(void *buf, int max, netbuf *nData)
{
      int i;

      if (nData->dir != FTPLIB_READ)
      return 0;
      if (nData->buf) i = readline(static_cast<char*>(buf), max, nData);
      else
      {
            i = socket_wait(nData);
            if (i != 1) return 0;
            if (nData->tlsdata) i = SSL_read(nData->ssl, buf, max);
            else i = read(nData->handle,buf,max);
      }
      if (i == -1) return 0;
      nData->xfered += i;
      if (nData->xfercb && nData->cbbytes)
      {
            nData->xfered1 += i;
            if (nData->xfered1 > nData->cbbytes)
            {
                  if (nData->xfercb(nData->xfered, nData->cbarg) == 0) return 0;
                  nData->xfered1 = 0;
            }
      }
      return i;
}

/*
 * FtpWrite - write to a data connection
 */
int ftplib::FtpWrite(void *buf, int len, netbuf *nData)
{
      int i;

      if (nData->dir != FTPLIB_WRITE) return 0;
      if (nData->buf) i = writeline(static_cast<char*>(buf), len, nData);
      else
      {
            socket_wait(nData);
            if (nData->tlsdata) i = SSL_write(nData->ssl, buf, len);
            else i = write(nData->handle, buf, len);
      }
      if (i == -1) return 0;
      nData->xfered += i;

      if (nData->xfercb && nData->cbbytes)
      {
            nData->xfered1 += i;
            if (nData->xfered1 > nData->cbbytes)
            {
                  if (nData->xfercb(nData->xfered, nData->cbarg) == 0) return 0;
                  nData->xfered1 = 0;
            }
      }
      return i;
}

/*
 * FtpSite - send a SITE command
 *
 * return 1 if command successful, 0 otherwise
 */
int ftplib::Site(const char *cmd)
{
      char buf[256];

      if ((strlen(cmd) + 7) > sizeof(buf)) return 0;
      sprintf(buf,"SITE %s",cmd);
      if (!FtpSendCmd(buf,'2',mp_netbuf)) return 0;
      return 1;
}

/*
 * FtpRaw - send a raw string string
 *
 * return 1 if command successful, 0 otherwise
 */

int ftplib::Raw(const char *cmd)
{
      char buf[256];
      strncpy(buf, cmd, 256);
      if (!FtpSendCmd(buf,'2',mp_netbuf)) return 0;
      return 1;
}

/*
 * FtpSysType - send a SYST command
 *
 * Fills in the user buffer with the remote system type.  If more
 * information from the response is required, the user can parse
 * it out of the response buffer returned by FtpLastResponse().
 *
 * return 1 if command successful, 0 otherwise
 */
int ftplib::SysType(char *buf, int max)
{
      int l = max;
      char *b = buf;
      char *s;
      if (!FtpSendCmd("SYST",'2',mp_netbuf)) return 0;
      s = &mp_netbuf->response[4];
      while ((--l) && (*s != ' ')) *b++ = *s++;
      *b++ = '\0';
      return 1;
}

/*
 * FtpMkdir - create a directory at server
 *
 * return 1 if successful, 0 otherwise
 */
int ftplib::Mkdir(const char *path)
{
      char buf[256];

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

/*
 * FtpChdir - change path at remote
 *
 * return 1 if successful, 0 otherwise
 */
int ftplib::Chdir(const char *path)
{
      char buf[256];

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

/*
 * FtpCDUp - move to parent directory at remote
 *
 * return 1 if successful, 0 otherwise
 */
int ftplib::Cdup()
{
      if (!FtpSendCmd("CDUP",'2',mp_netbuf)) return 0;
      return 1;
}

/*
 * FtpRmdir - remove directory at remote
 *
 * return 1 if successful, 0 otherwise
 */
int ftplib::Rmdir(const char *path)
{
      char buf[256];

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

/*
 * FtpPwd - get working directory at remote
 *
 * return 1 if successful, 0 otherwise
 */
int ftplib::Pwd(char *path, int max)
{
      int l = max;
      char *b = path;
      char *s;

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

/*
 * FtpXfer - issue a command and transfer data
 *
 * return 1 if successful, 0 otherwise
 */
int ftplib::FtpXfer(const char *localfile, const char *path, netbuf *nControl, int typ, int mode)
{
      int l,c;
      char *dbuf;
      FILE *local = NULL;
      netbuf *nData;
      int rv=1; // 3.1-1

      if (localfile != NULL)
      {
            printf("localfile: -%s-", localfile);
      
            //local = fopen(localfile, (typ == FTPLIB_FILE_WRITE) ? "r" : "w");
            char ac[3] = "  ";
            if ((typ == FTPLIB_DIR) || (typ == FTPLIB_DIR_VERBOSE)) { ac[0] = 'w'; ac[1] = '\0'; }
            if (typ == FTPLIB_FILE_READ) { ac[0] = 'w'; ac[1] = '\0'; }
            if (typ == FTPLIB_FILE_WRITE_APPEND) { ac[0] = 'r'; ac[1] = '\0'; }
            if (typ == FTPLIB_FILE_READ_APPEND) { ac[0] = 'a'; ac[1] = '\0'; }
            if (typ == FTPLIB_FILE_WRITE) { ac[0] = 'r'; ac[1] = '\0'; }
            if (mode == ftplib::image) ac[1] = 'b';

            local = fopen64(localfile, ac);
            if (typ == FTPLIB_FILE_WRITE_APPEND) fseeko64(local,mp_netbuf->offset,SEEK_SET);

            if (local == NULL)
            {
                  strncpy(nControl->response, strerror(errno), sizeof(nControl->response));
                  return 0;
            }
      }
      if (local == NULL) local = ((typ == FTPLIB_FILE_WRITE)
            || (typ == FTPLIB_FILE_WRITE_APPEND)) ? stdin : stdout;
      if (!FtpAccess(path, typ, mode, nControl, &nData)) return 0;

      dbuf = static_cast<char*>(malloc(FTPLIB_BUFSIZ));
      if ((typ == FTPLIB_FILE_WRITE) || (typ == FTPLIB_FILE_WRITE_APPEND))
      {
            while ((l = fread(dbuf, 1, FTPLIB_BUFSIZ, local)) > 0)
            {
                  if ((c = FtpWrite(dbuf, l, nData)) < l)
                  {
                        printf("short write: passed %d, wrote %d\n", l, c);
                        rv = 0;
                        break;
                  }
            }
      }
      else
      {
            while ((l = FtpRead(dbuf, FTPLIB_BUFSIZ, nData)) > 0)
            {
                  if (fwrite(dbuf, 1, l, local) <= 0)
                  {
                        perror("localfile write");
                        break;
                  }
            }
      }
      free(dbuf);
      fflush(local);
      if (localfile != NULL)
      fclose(local);
      return FtpClose(nData);
      return rv;
}

/*
 * FtpNlst - issue an NLST command and write response to output
 *
 * return 1 if successful, 0 otherwise
 */
int ftplib::Nlst(const char *outputfile, const char *path)
{
      mp_netbuf->offset = 0;
      return FtpXfer(outputfile, path, mp_netbuf, FTPLIB_DIR, ftplib::ascii);
}

/*
 * FtpDir - issue a LIST command and write response to output
 *
 * return 1 if successful, 0 otherwise
 */
int ftplib::Dir(const char *outputfile, const char *path)
{
      mp_netbuf->offset = 0;
      return FtpXfer(outputfile, path, mp_netbuf, FTPLIB_DIR_VERBOSE, ftplib::ascii);
}

/*
 * FtpSize - determine the size of a remote file
 *
 * return 1 if successful, 0 otherwise
 */
//int ftplib::Size(const char *path, int *size, char mode)
int ftplib::Size(const char *path, int *size, ftplib::ftp mode)
{
   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', mp_netbuf)) return 0;

      sprintf(cmd,"SIZE %s",path);
   if (!FtpSendCmd(cmd,'2',mp_netbuf)) rv = 0;
   else
   {
            if (sscanf(mp_netbuf->response, "%d %d", &resp, &sz) == 2) *size = sz;
            else rv = 0;
   }
   return rv;
}

/*
 * FtpModDate - determine the modification date of a remote file
 *
 * return 1 if successful, 0 otherwise
 */
int ftplib::ModDate(const char *path, char *dt, int max)
{
      char buf[256];
      int rv = 1;

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

/*
 * FtpGet - issue a GET command and write received data to output
 *
 * return 1 if successful, 0 otherwise
 */

int ftplib::Get(const char *outputfile, const char *path, ftplib::ftp mode, off64_t offset)
{
      mp_netbuf->offset = offset;
      if (offset == 0) return FtpXfer(outputfile, path, mp_netbuf, FTPLIB_FILE_READ, mode);
      else return FtpXfer(outputfile, path, mp_netbuf, FTPLIB_FILE_READ_APPEND, mode);
}

/*
 * FtpPut - issue a PUT command and send data from input
 *
 * return 1 if successful, 0 otherwise
 */

int ftplib::Put(const char *inputfile, const char *path, ftplib::ftp mode, off64_t offset)
{
      mp_netbuf->offset = offset;
      if (offset == 0) return FtpXfer(inputfile, path, mp_netbuf, FTPLIB_FILE_WRITE, mode);
      else return FtpXfer(inputfile, path, mp_netbuf, FTPLIB_FILE_WRITE_APPEND, mode);
}

/*
 * FtpRename - rename a file at remote
 *
 * return 1 if successful, 0 otherwise
 */
int ftplib::Rename(const char *src, const char *dst)
{
      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',mp_netbuf)) return 0;
      sprintf(cmd,"RNTO %s",dst);
      if (!FtpSendCmd(cmd,'2',mp_netbuf)) return 0;

      return 1;
}

/*
 * FtpDelete - delete a file at remote
 *
 * return 1 if successful, 0 otherwise
 */
int ftplib::Delete(const char *fnm)
{
      char cmd[256];

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

/*
 * FtpQuit - disconnect from remote
 *
 * return 1 if successful, 0 otherwise
 */
int ftplib::Quit()
{
      if (mp_netbuf->dir != FTPLIB_CONTROL) return 0;
      if (mp_netbuf->handle == 0)
      {
            strcpy(mp_netbuf->response, "error: no anwser from server\n");
            return 0;
      }
      if (!FtpSendCmd("QUIT",'2',mp_netbuf))
      {
            close(mp_netbuf->handle);
            return 0;
      }
      else
      {
            close(mp_netbuf->handle);
            return 1;
      }
}
 
int ftplib::Fxp(ftplib* src, ftplib* dst, const char *pathSrc, const char *pathDst, ftplib::ftp mode, ftplib::ftp method)
{
      char *cp;
      unsigned char v[6];
      char buf[256];
      int retval = 0;
      
      sprintf(buf, "TYPE %c", mode);
      if (!dst->FtpSendCmd(buf,'2',dst->mp_netbuf)) return -1;
      if (!src->FtpSendCmd(buf,'2',src->mp_netbuf)) return -1;

      if (method == ftplib::defaultfxp)
      {
            // PASV dst

            if (!dst->FtpSendCmd("PASV",'2',dst->mp_netbuf)) return -1;
            cp = strchr(dst->mp_netbuf->response,'(');
            if (cp == NULL) return -1;
            cp++;
            sscanf(cp,"%hhu,%hhu,%hhu,%hhu,%hhu,%hhu",&v[2],&v[3],&v[4],&v[5],&v[0],&v[1]);
            if (dst->mp_netbuf->correctpasv) if (!dst->CorrectPasvResponse(v)) return -1;

            // PORT src

            sprintf(buf, "PORT %d,%d,%d,%d,%d,%d", v[2],v[3],v[4],v[5],v[0],v[1]);
            if (!src->FtpSendCmd(buf,'2',src->mp_netbuf)) return -1;

            // RETR src

            strcpy(buf,"RETR");
            if (pathSrc != NULL)
            {
                  int i = strlen(buf);
                  buf[i++] = ' ';
                  if ((strlen(pathSrc) + i) >= sizeof(buf)) return 0;
                  strcpy(&buf[i],pathSrc);
            }
            if (!src->FtpSendCmd(buf, '1', src->mp_netbuf)) return 0;

            // STOR dst

            strcpy(buf,"STOR");
            if (pathDst != NULL)
            {
                  int i = strlen(buf);
                  buf[i++] = ' ';
                  if ((strlen(pathDst) + i) >= sizeof(buf)) return 0;
                  strcpy(&buf[i],pathDst);
            }
            if (!dst->FtpSendCmd(buf, '1', dst->mp_netbuf))
            {
                  /* this closes the data connection, to abort the RETR on
                  the source ftp. all hail pftp, it took me several
                  hours and i was absolutely clueless, playing around with
                  ABOR and whatever, when i desperately checked the pftp
                  source which gave me this final hint. thanks dude(s). */
            
                  dst->FtpSendCmd("PASV", '2', dst->mp_netbuf);
                  src->readresp('4', src->mp_netbuf);
                  return 0;
            }

            retval = (src->readresp('2', src->mp_netbuf)) & (dst->readresp('2', dst->mp_netbuf));

      }
      else 
      {
            // PASV src

            if (!src->FtpSendCmd("PASV",'2',src->mp_netbuf)) return -1;
            cp = strchr(src->mp_netbuf->response,'(');
            if (cp == NULL) return -1;
            cp++;
            sscanf(cp,"%hhu,%hhu,%hhu,%hhu,%hhu,%hhu",&v[2],&v[3],&v[4],&v[5],&v[0],&v[1]);
            if (src->mp_netbuf->correctpasv) if (!src->CorrectPasvResponse(v)) return -1;

            // PORT dst

            sprintf(buf, "PORT %d,%d,%d,%d,%d,%d", v[2],v[3],v[4],v[5],v[0],v[1]);
            if (!dst->FtpSendCmd(buf,'2',dst->mp_netbuf)) return -1;

            // STOR dest

            strcpy(buf,"STOR");
            if (pathDst != NULL)
            {
                  int i = strlen(buf);
                  buf[i++] = ' ';
                  if ((strlen(pathDst) + i) >= sizeof(buf)) return 0;
                  strcpy(&buf[i],pathDst);
            }
            if (!dst->FtpSendCmd(buf, '1', dst->mp_netbuf)) return 0;

            // RETR src

            strcpy(buf,"RETR");
            if (pathSrc != NULL)
            {
                  int i = strlen(buf);
                  buf[i++] = ' ';
                  if ((strlen(pathSrc) + i) >= sizeof(buf)) return 0;
                  strcpy(&buf[i],pathSrc);
            }
            if (!src->FtpSendCmd(buf, '1', src->mp_netbuf))
            {
                  src->FtpSendCmd("PASV", '2', src->mp_netbuf);
                  dst->readresp('4', dst->mp_netbuf);
                  return 0;
            }

            // wait til its finished!

            retval = (src->readresp('2', src->mp_netbuf)) & (dst->readresp('2', dst->mp_netbuf));

      }

      return retval;
}
int ftplib::SetDataEncryption(ftplib::ftp flag)
{
      if (!mp_netbuf->tlsctrl) return 0;
      if (!FtpSendCmd("PBSZ 0",'2',mp_netbuf)) return 0;
      switch(flag)
      {
      case 0:
            mp_netbuf->tlsdata = 0;
            if (!FtpSendCmd("PROT C",'2',mp_netbuf)) return 0;
            break;
      case 1:
            mp_netbuf->tlsdata = 1;
            if (!FtpSendCmd("PROT P",'2',mp_netbuf)) return 0;
            break;
      default:
            return 0;
      }
      return 1;
}

int ftplib::NegotiateEncryption()
{
      int ret;

      if (!FtpSendCmd("AUTH TLS",'2',mp_netbuf)) return 0;

      mp_netbuf->sbio = BIO_new_socket(mp_netbuf->handle, BIO_NOCLOSE);
      SSL_set_bio(mp_netbuf->ssl,mp_netbuf->sbio,mp_netbuf->sbio);

      ret = SSL_connect(mp_netbuf->ssl);
      if (ret == 1) mp_netbuf->tlsctrl = 1;

      if (ret < 1) return 0;

      return 1;
}

void ftplib::SetCallbackIdleFunction(FtpCallbackIdle pointer)
{
      mp_netbuf->idlecb = pointer;
}

void ftplib::SetCallbackXferFunction(FtpCallbackXfer pointer)
{
      mp_netbuf->xfercb = pointer;
}

void ftplib::SetCallbackLogFunction(FtpCallbackLog pointer)
{
      mp_netbuf->logcb = pointer;
}

void ftplib::SetCallbackArg(void *arg)
{
      mp_netbuf->cbarg = arg;
}

void ftplib::SetCallbackBytes(off64_t bytes)
{
      mp_netbuf->cbbytes = bytes;
}

void ftplib::SetCallbackIdletime(int time)
{
      mp_netbuf->idletime.tv_sec = time / 1000;
      mp_netbuf->idletime.tv_usec = (time % 1000) * 1000;
}

void ftplib::SetConnmode(ftplib::ftp mode)
{
      if ((mode != ftplib::pasv) && (mode != ftplib::port)) mode = ftplib::defaultconnmode;
      mp_netbuf->cmode = mode;
}

void ftplib::ClearNetbuf()
{
      mp_netbuf->dir = FTPLIB_CONTROL;
      mp_netbuf->ctrl = NULL;
      mp_netbuf->cmode = ftplib::defaultconnmode;
      mp_netbuf->idlecb = NULL;
      mp_netbuf->idletime.tv_sec = mp_netbuf->idletime.tv_usec = 0;
      mp_netbuf->cbarg = NULL;
      mp_netbuf->xfered = 0;
      mp_netbuf->xfered1 = 0;
      mp_netbuf->cbbytes = 0;
      mp_netbuf->tlsctrl = 0;
      mp_netbuf->tlsdata = 0;
      mp_netbuf->offset = 0;
      mp_netbuf->handle = 0;
      mp_netbuf->logcb = NULL;
      mp_netbuf->xfercb = NULL;
      mp_netbuf->correctpasv = false;
}

int ftplib::CorrectPasvResponse(unsigned char *v)
{
      struct sockaddr ipholder;
      unsigned int ipholder_size = sizeof(ipholder);

      if (getpeername(mp_netbuf->handle, &ipholder, &ipholder_size) == -1)
      {
            perror("getpeername");
            close(mp_netbuf->handle);
            return 0;
      }
      
      for (int i = 2; i < 6; i++) v[i] = ipholder.sa_data[i];
      
      return 1;
}

Generated by  Doxygen 1.6.0   Back to index