ftp.cxx

Go to the documentation of this file.

//
// Copyright 2002, Lowell Boggs Jr.
//
// This file or directory, containing source code for a computer program,
// is Copyrighted by Lowell Boggs, Jr.  987 Regency Drive, Lewisville
// TX (USA), 75067.  You may use, copy, modify, and distribute this
// source file without charge or obligation so long as you agree to
// the following:
//
//  1.  You must indemnify Lowell Boggs against any and all financial
//      obligations caused by its use, misuse, function, or malfunction.
//      Further, you acknowledge that there is no warranty of any kind,
//      whatsoever.
//
//  2.  You agree not to attempt to patent any portion of this original
//      work -- though you may attempt to patent your own extensions to
//      it if you so choose.
//
//  3.  You keep this copyright notice with the file and all copies
//      of the file and do not change it anyway except language translation.
//
// You are responsible for enforcing your own compliance with these
// conditions and may not use this source file if you cannot agree to the
// above terms and conditions.



#include <cxxtls/ftp.h>
#include <cxxtls/strtool.h>
#include <cxxtls/simple_regex.h>
#include <stdlib.h>
#include <portable_io.h>
#include <string.h>
#include <signal.h>

namespace cxxtls
{

using namespace std;

static string error_text;

static string open   ("open ");
static string user   ("user ");
static string quit   ("quit ");
static string dir    ("dir ");
static string getf   ("get ");
static string putf   ("put ");
static string delf   ("del ");
static string cd     ("cd ");
static string eol    ("\n");
static string space  (" ");
static string echo   ("echo ");
static string oparen (" ( ");
static string cparen (" ) ");

#ifdef _MSC_VER
static string ftp    (" ftp -n <ftp.cmd ");
static string sh     ("cmd /c ");
#else
static string ftp    (" | ftp -n 2>/dev/null ");
static string sh     ("sh -c '");
#endif

static string semic  (" ; ");
static string star   ("*");
static string binary ("binary ");

static bool is_ftp_error(char const *line)
{
  static char const *loginfailure="Login Failed.";
  static char const *loginIncorrect="Login incorrect.";
  static char const *notconnected="Not connected.";
  static char const *user="User ";

  if(  0 == strncmp(line, loginfailure, strlen(loginfailure))
     ||
       0 == strncmp(line, loginfailure, strlen(loginIncorrect))
    )
  {
    error_text = "error:  incorrect username or password";
    return true;
  }

  if(0 == strncmp(line, notconnected, strlen(notconnected)))
  {
    error_text = "error:  invalid ftp site";
    return true;
  }

 if(0 == strncmp(line, user, strlen(user)))
 {
   error_text = "error: user cannot log in";
   return true;
 }

  return false;

}

static bool is_ftp_dir_line(char const *buffer)
  //
  // Returns true if a character string is the output of an
  // ftp dir command
  //
{
  return buffer[0] == 'd' ||
         buffer[0] == 'l' ||
         buffer[0] == '-';
}

bool
FTP::
parse_ftp_dir_text(char const *buffer, FileStatus *statbuf, FileName *filename)
  //
  //  Parse the text provided by ftp describing the file status.
  //
  //  Return false if this is not a valid file status line
  //
{
    //
    //    d---------   1 owner    group               0 Feb 10 10:30 incoming  size
    //

    StrTool::stringlist_t line;


    int patterns = StrTool::parse_words(buffer, &line, 9);

    if(patterns != 9)
      return false;

    StrTool::stringlist_t::const_iterator scan = line.begin();

    string const& permissions  = *scan++;
    string const& links        = *scan++;
    string const& owner        = *scan++;
    string const& group        = *scan++;
    string const& size         = *scan++;
    string const& month        = *scan++;
    string const& day          = *scan++;
    string const& year         = *scan++;

    string        name         = *scan;

    {

      if(!is_ftp_dir_line(permissions.c_str()))
        return false;
        
      if(permissions.size() < 10)
        return false;
        
      // size_t offset = name.find_first_of(" -> ");

       size_t offset = name.size();

      {
         static string arrow(" -> ");
        
         string::iterator where = std::search(name.begin(), name.end(),
                                              arrow.begin(), arrow.end()
                                             );
                                        
         if(where != name.end())
           offset = where - name.begin();
      }



      if(offset > 0 && offset < name.size() )
        name.erase(name.begin() + offset,
                   name.end()
                  );
        
      if(name[name.size() - 1] == '\n')
        name.erase(name.end() -1);
        
      *filename = name;

      int tmp;

      sscanf(size.c_str(), "%d", &tmp);

      statbuf->size = tmp;

      statbuf->owner_id = -2;
      statbuf->group_id = -2;

      statbuf->mode.construct_from_string(permissions);


      string time_buf(month);

      time_buf += " ";
      time_buf += day;
      time_buf += " ";
      time_buf += year;

      statbuf->time.construct_from_string(time_buf);

      string const* t = &group;  // silence stupid unused variable warnings
                    t = &owner;
                    t = &links;

      return true;
    }


  return false;
}


string
FTP::
error()
{
  return error_text;
}

static int child_alarm_occurred=0;

extern "C" void child_alarm_handler(int signum)
{
#ifndef _MSC_VER
   child_alarm_occurred=1;
   #ifdef __IBMCXX_
   signal(SIGCHLD, child_alarm_handler);
   #endif
#endif
}


static FILE* ftplog = 0;


int
FTP::
stat_matching(char const          *hostname,
              char const          *username,
              char const          *password,
              char const          *pattern,
              std::list<FileInfo> *result
             )
  //
  // Find a list of FileInfo's matching a specified file name pattern
  // on a remote host using ftp.  Returns 0 if no matches found
  // returns -1 if an error occurred.  Otherwise, returns the count
  // of matches.
  //
{
  int matches=0;
  int dirents_found=0;

  if(!password || password[0] == 0)
  {
    error_text="Sorry, empty passwords not supported";
    return -1;
  }

  FileName ftp_program = FileName::find_executable("ftp");

  if(ftp_program.size() == 0)
  {
    error_text="Sorry, couldn't find 'ftp' executable in path";
    return -1;
  }

  error_text="";   // clean out the error string

  // make a command to feed to ftp's standard in:
  //
  //    open host
  //    user username password
  //    dir  pattern
  //    quit
  //

  FileName dirname(pattern);    // directory/file*.c

  FileName basename = dirname.basename();   // file*.c

  dirname = dirname.dirname();  // directory

  if(pattern[0] == 0 || strcmp(pattern,"*") == 0)
  {
    dirname="";
    pattern="*";
    basename=pattern;
  }

#ifdef _MSC_VER

  string command(sh + space + ftp_program + " -n <ftp.cmd" );

  FileName cmdfile("ftp.cmd");

  bool err =
  cmdfile.write(
                  open + space + hostname + "\r\n" +
                  user + space + username + space + password + "\r\n" +
                  dir  + space + dirname  + "\r\n" +
                  quit + "\r\n"
               );
        
  if(err)
  {
    error_text="couldn't write to file ftp.cmd";
    return -1;
  }


#else
  string command(sh +
                 oparen + echo + open + space + hostname + semic +
                          echo + user + space + username + space + password + semic +
                          echo + dir  + space + dirname  + semic +
                          echo + quit + semic +
                 cparen + ftp
                 + "'"
                );
#endif


  //
  // launch ftp with the command
  //


  child_alarm_handler(0);  // set the alarm
  child_alarm_occurred = 0; // clear the flag

  // ftplog = fopen("ftp.log", "w");  // Uncomment out this line to turn on log

  if(ftplog) fputs(command.c_str(), ftplog); // prints pasword into ftp.log!


  FILE *f = popen(command.c_str(), "r");

  if(!f)
  {
    error_text = "error:  command wouldn't start\n  " + command;
    return -1;
  }

  char buffer[max_ftp_line_length];

  //
  // read ftp's output and interpret what it says
  //

  int records_read = 0;

  while(!child_alarm_occurred && fgets(buffer, max_ftp_line_length, f))
  {
    ++records_read;

    int l = strlen(buffer);

    if(buffer[l-1] == '\n') --l;   // remote end of line crap
    if(buffer[l-1] == '\r') --l;
    buffer[l] = 0;

    if(ftplog) { fputs(buffer, ftplog); fflush(ftplog); }

    if( !is_ftp_dir_line(buffer) )
    {

      if(is_ftp_error(buffer))
      {
        if(records_read == 0)
        {
          error_text = "Login failure";
        }
        pclose(f);
        return -1;
      }


      continue;  // this isn't a directory line
    }

    FileInfo thisfile;

    if( !parse_ftp_dir_text(buffer, &thisfile.status_, &thisfile.name_) )
      continue;

    ++dirents_found;

    if(thisfile.name_.matches(basename))
    {
       ++matches;
       result->push_back(thisfile);
    }

  }

#ifndef _MSC_VER
  signal(SIGCHLD, SIG_IGN);
#endif

  pclose(f);

  return matches;

}


bool
FTP::
put(string      hostname,
    string      username,
    string      password,
    FileName    filename,
    string      localfile
   )
{
  error_text="";   // clean out the error string

  FileName ftp_program = FileName::find_executable("ftp");

  if(ftp_program.size() == 0)
  {
    error_text="Sorry, couldn't find 'ftp' executable in path";
    return -1;
  }

  // make a command to feed to ftp's standard in:
  //
  //    open host
  //    user username password
  //    cd filename.dirname()
  //    binary
  //    put filename.basename()
  //    quit
  //

#ifdef _MSC_VER

  string command(sh + space + ftp_program + " -n <ftp.cmd");

  FileName cmdfile("ftp.cmd");

  cmdfile.write(
                 open + space + hostname + "\r\n" +
                 user + space + username + space + password + "\r\n" +
                 cd   + space + filename.dirname() + "\r\n" +
                 binary + "\r\n" +
                 putf + space + localfile + space + filename.basename() + "\r\n" +
                 quit + "\r\n"
               );

#else
  string command(sh +
                   oparen + echo + open + space + hostname + semic +
                            echo + user + space + username + space + password + semic +
                            echo + cd  + space + filename.dirname() + semic +
                            echo + binary + semic +
                            echo + putf + space + localfile + space + filename.basename()  + space + semic +
                            echo + quit + semic +
                   cparen + ftp +
                 "'"
                );
#endif

  //
  // launch ftp with the command
  //

  // ftplog = fopen("ftp.log", "w");  // Uncomment out this line to turn on log

  if(ftplog) fputs(command.c_str(), ftplog); // prints pasword into ftp.log!

  FILE *f = popen(command.c_str(), "r");

  if(!f)
  {
    error_text = "error:  command wouldn't start\n  " + command;
    return -1;
  }

  char buffer[max_ftp_line_length];

  //
  // read ftp's output and interpret what it says
  //

  int records_read=0;

  while(fgets(buffer, max_ftp_line_length, f))
  {
    ++records_read;

    {
      if(is_ftp_error(buffer))
      {
        pclose(f);
        return -1;
      }
    }

  }

#ifndef _MSC_VER
  if(records_read == 0)
  {
    error_text = "error:  ftp wouldn't start -- PATH problem maybe?";
    pclose(f);
    return -1;
  }
#endif

  pclose(f);
  return false;

}


bool
FTP::
get(string      hostname,
    string      username,
    string      password,
    FileName    filename,
    string      localfile
   )
{
  error_text="";   // clean out the error string

  FileName ftp_program = FileName::find_executable("ftp");

  if(ftp_program.size() == 0)
  {
    error_text="Sorry, couldn't find 'ftp' executable in path";
    return -1;
  }

  // make a command to feed to ftp's standard in:
  //
  //    open host
  //    user username password
  //    cd filename.dirname()
  //    binary
  //    get filename.basename()
  //    quit
  //

#ifdef _MSC_VER
  string command(sh + space + ftp_program + " -n <ftp.cmd");

  FileName cmdfile("ftp.cmd");

  cmdfile.write(
                 open + space + hostname +                    "\r\n" +
                 user + space + username + space + password + "\r\n" +
                 binary                                     + "\r\n" +
                 getf + space + filename.basename() +
                                           space    + localfile +
                                                              "\r\n" +
                 quit +                                       "\r\n"
               );

#else
  string command(sh +
                   oparen + echo + open + space + hostname + semic +
                            echo + user + space + username + space + password + semic +
                            echo + cd  + space + filename.dirname() + semic +
                            echo + binary + semic +
                            echo + getf + space + filename.basename() + space + localfile + space + semic +
                            echo + quit + semic +
                   cparen + ftp +
                 "'"
                );
#endif

  //
  // launch ftp with the command
  //

  FILE *f = popen(command.c_str(), "r");

  if(!f)
  {
    error_text = "error:  command wouldn't start\n  " + command;
    return -1;
  }

  char buffer[max_ftp_line_length];

  //
  // read ftp's output and interpret what it says
  //

  while(fgets(buffer, max_ftp_line_length, f))
  {
    {
      if(is_ftp_error(buffer))
      {
        pclose(f);
        return -1;
      }
    }

  }

  pclose(f);

  if(localfile.size())
    filename = localfile;
  else
    filename = filename.basename();

  if(!filename.exists())
  {
    error_text = "error:  requested file did not download";
    return true;
  }

  return false;

}


bool
FTP::
del(string      hostname,
    string      username,
    string      password,
    FileName    filename
   )
{
  error_text="";   // clean out the error string

  FileName ftp_program = FileName::find_executable("ftp");

  if(ftp_program.size() == 0)
  {
    error_text="Sorry, couldn't find 'ftp' executable in path";
    return -1;
  }

  // make a command to feed to ftp's standard in:
  //
  //    open host
  //    user username password
  //    cd filename.dirname()
  //    del filename.basename()
  //    quit
  //

#ifdef _MSC_VER

  string command(sh + space + ftp_program + " -n <ftp.cmd");

  FileName cmdfile("ftp.cmd");

  cmdfile.write(
                 open + space + hostname +                    "\r\n" +
                 user + space + username + space + password + "\r\n" +
                 cd   + space + filename.dirname()          + "\r\n" +
                 delf + space + filename.basename() +         "\r\n" +
                 quit +                                       "\r\n"
               );


#else
  string command(sh +
                   oparen + echo + open + space + hostname + semic +
                            echo + user + space + username + space + password + semic +
                            echo + cd  + space + filename.dirname() + semic +
                            echo + delf + space + filename.basename() + space + semic +
                            echo + quit + semic +
                   cparen + ftp +
                 "'"
                );
#endif

  //
  // launch ftp with the command
  //

  FILE *f = popen(command.c_str(), "r");

  if(!f)
  {
    error_text = "error:  command wouldn't start\n  " + command;
    return -1;
  }

  char buffer[max_ftp_line_length];

  //
  // read ftp's output and interpret what it says
  // When removing a file, it may be so fast that the ftp
  // process dies before we get to read its output....
  // This means we occaisionally miss some error messages...

  while(fgets(buffer, max_ftp_line_length, f))
  {

    {
      if(is_ftp_error(buffer))
      {
        pclose(f);
        return -1;
      }
    }

  }

  pclose(f);
  return false;

}

} // namespace cxxtls