ftpviewer.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.
//
// Warning:  not all files in this directory structure are covered by the
// same copyright.  Some of them are part of the GNU source distribution
// and you must obey the GPL copyright for those files.

#include <cxxtls/ftpviewer.h>
#include <cxxtls/ftp.h>
#include <cxxtls/viewermanager.h>
#include <vector>
#include <list>
#include <cxxtls/file.h>
#include <portable_io.h>
#include <cxxtls/strtool.h>
#include <cxxtls/cursesinterface.h>

namespace cxxtls
{

// labor saving typedefs

typedef CursorWindow::viewport       viewport;
typedef CursorWindow::input_event    input_event;
typedef std::string                  string;
typedef std::vector<FTP::FileInfo>   dir_rep;  // directory lines representation
typedef CursorWindow::Dialog         dialog;
typedef dialog::String               string_field;
typedef dialog::Password             password_field;
typedef dialog::Ok                   ok_field;
typedef FTP::FileInfo                file_info;
typedef CursorWindow::Message        message;
typedef CursorWindow::Selection      selection;
typedef FileName::sorted_names_t     filename_list;
typedef std::list<file_info>         fileinfo_list;
typedef std::map<string, FTPviewer*> viewer_map;


struct FTPviewer::Impl
//
//  The members of the real FTPviewer class are opaque in the
//  public header, the real members appear in this class.
//
//  Note that all ftp viewer objects are kept in a static list.
//  Never iterate over this list and delete the items in it
//  because the destructor for the Impl class automatically
//  removes itself from the list.  The constructor automatically
//  puts the object in the list...
//
{
  void paint        (viewport*          vp, int       cmd);
  bool handle_event (input_event const *e,  viewport* vp);
  void help();
  void paint_row    (viewport*vp, int row, size_t line, bool show_highlights=true);

  static viewer_map  active_viewers_;

  ViewerManager* manager_;
  FileName       local_directory_;
  FileName       remote_directory_;
  string         remote_host_;
  string         userid_;
  string         password_;
  dir_rep        lines_;
  bool           is_active_;
  size_t         page_top_;
  size_t         cur_line_;
  int            first_row_;    // first row of actual data display (below titles)
  int            visible_rows_;
  string         search_;
  int            left_margin_;  // first usable column (after border)
};

viewer_map FTPviewer::Impl::active_viewers_;


void 
FTPviewer::
operator() (viewport* vp, int cmd)
{
  // WARNING:  do not save vp -- it gets deleted regularly!

  impl_->paint(vp, cmd);
}

bool 
FTPviewer::
handle_event(input_event const * e,viewport* vp)
{
  return impl_->handle_event(e,vp);
}

void 
FTPviewer::
help()
{
  impl_->help();
}

string 
FTPviewer::
app_name("FTP");

FTPviewer::
FTPviewer(ViewerManager    *   vm,
          FileName    const&   local_directory,
          string      const&   remote_host,
          string      const&   userid,
          string      const&   password,
          string      const&   remote_directory
         )
:  Viewer(vm),
   impl_(new Impl)
{
  impl_->active_viewers_[remote_directory] = this;

  impl_->local_directory_ = local_directory;
  impl_->remote_host_     = remote_host;
  impl_->userid_          = userid;
  impl_->password_        = password;
  impl_->remote_directory_= remote_directory;
  impl_->is_active_       = false;
  impl_->first_row_       = 1;          // leave a 1 line title area on each page
  impl_->page_top_        = 0;
  impl_->cur_line_        = 0;
  impl_->visible_rows_    = 0;
  impl_->manager_         = vm;
  impl_->left_margin_     = 0;

}

FTPviewer::
~FTPviewer()
 {
    viewer_map::iterator victim = 
                     impl_->active_viewers_.find(impl_->remote_directory_);

    if(victim != impl_->active_viewers_.end())
    {
      impl_->active_viewers_.erase(victim);
    }

 }

string 
FTPviewer::
description() const
{
  return impl_->remote_host_ + ":" + impl_->remote_directory_;
}

Viewer* 
FTPviewer::
app(ViewerManager*vm, string &fullname)
{


  string   host;
  string   user;
  string   pwd;
  FileName localdir(FileName::getcwd());

  if(fullname != "")
  {
    // user has tried to specify some of the text on the command line

    StrTool::stringlist_t parts;

    StrTool::parse_words(fullname, &parts);

    size_t count = parts.size();

    if(count >= 1) 
    {
      host = parts.front();
      --count;
      parts.erase(parts.begin());
    }

    if(count >= 1) 
    {
      user = parts.front();
      --count;
      parts.erase(parts.begin());
    }

    if(count >= 1) 
    {
      pwd = parts.front();
      --count;
      parts.erase(parts.begin());
    }

    if(count >= 1) 
    {
      localdir = parts.front();
      --count;
      parts.erase(parts.begin());
    }

    fullname="";

  }



  if(pwd == "")
  {
    // If the user didn't specify it all, prompt for it

    dialog d("FTP connection");
    d += new string_field("host", "Host", host, 20);
    d += new string_field("user", "User", user, 20);
    d += new password_field("password", "Password", pwd, 20);
    d += new string_field("localdir", "Local Directory", localdir, 40);
    d += new ok_field("ok", "Ok");
    
    if(d.popup(vm->window()))
      return 0;
    
    host      = d.element_value("host");
    user      = d.element_value("user");
    pwd       = d.element_value("password");
    localdir  = d.element_value("localdir");
  }


  FTPviewer* rv = new FTPviewer(vm, fullname=localdir, host, user, pwd);

  fileinfo_list lofi;
        
  int count = FTP::stat_matching(host, user, pwd, "", &lofi);

  if(count < 0)
  {
    message m("Couldn't connect to remote server");
    m += "Ftp error was: ";
    m += "   " + FTP::error();
    m += "";

    m.popup(vm->window());

    delete rv;
    return 0;
  }

  rv->impl_->lines_.resize(count);

  std::copy(lofi.begin(), lofi.end(), rv->impl_->lines_.begin());
        
  return rv;
                
}
void 
FTPviewer::Impl::
paint_row    (viewport*vp, int row, size_t line, bool show_highlights)
{
  //
  // paint an FTP directory row.
  //

  //
  // Determine the text attribute for drawing the row
  //

  if(line != cur_line_ || !show_highlights)
  {
    if(row == visible_rows_ - 1)
      vp->set_text_attribute(ViewerManager::bottom_att);
    else
      vp->set_text_attribute(ViewerManager::normal_att);
  }
  else
    vp->set_text_attribute(ViewerManager::highlighted_att);


  //
  //  Position the cursor to the beginning of the row data --
  //  skipping any left margin to handle any needed borders.
  //

  vp->set_curpos(row + first_row_, left_margin_);

  //
  //  compute the text of the directory entry and draw it --
  //  unless the line requested is outside the range of valid lines
  //

  if(line < lines_.size())
  {
    //
    //  When constructing a string of text to output, take into
    //  account the width of the line available.  If insufficient
    //  space, leave out things in order to give preference to 
    //  the most important parts
    //

    file_info &info = lines_[line];

    FileStatus& status =  info.status_;

    string line_text;

    int cols = vp->size().col_;

    if(cols > 30)
    {
      if(cols >= 69)
      {
        line_text += status.mode;
        line_text += " ";
      }

      if(cols >= 60)
      {

        line_text += status.time;
        line_text += " ";
      }

      if(cols >= 42 )
      {
        char buffer[40];
        
        sprintf(buffer, "%12lu", (unsigned long)status.size);
        
        line_text += buffer;
      }

      line_text += " ";
    }

    line_text += info.name_;

    vp->write(line_text);

  }

  vp->fill_to_eol();
}
void 
FTPviewer::Impl::
paint(viewport* vp, int cmd)
{
  //
  //  Fully repaint the current window and leave the cursor
  //  sitting on the 'current' row of the window
  //


  // When painting, first determine if this window is the active
  // window or only being refreshed after a screen resize or
  // something.  Save this information in the is_active_ flag.

  if(cmd == viewport::repaint_handler::activate)
    is_active_ = true;
  else
  if(cmd == viewport::repaint_handler::deactivate)
    is_active_ = false;

  //
  //  Next, determine the size an absolute position of the window.
  //  The size is used for computing scrolling information.  The
  //  absolute position of the window is used to determine the
  //  left margin for drawing.  If the absolute position of the
  //  the window is left aligned, then no left border is needed --
  //  and thus the left margin is 0.  Per the standard of the
  //  viewers, if a left border is needed, it will be a column of
  //  vertical bars.
  //

  row_col size    = vp->size();
  row_col origin  = vp->origin();

  if(origin.col_ == 0)
    left_margin_ = 0;
  else
    left_margin_ = 1;  // skip space for column of '|' characters


  //
  //  Now we know the needed info for drawing.  Start with the title
  //  and draw down the page vertically -- handling the data rows
  //  and the empty region below them.
  //
  //
  //  handle the title area
  //

  vp->set_curpos(0,0);

  if(left_margin_)  // handle left border if needed
  {
    vp->set_text_attribute(ViewerManager::inactive_mark_att);

    using namespace CursesInterface;

    vp->write(line_chars[VL_MIDDLE]);
  }

  if(is_active_)
   vp->set_text_attribute(ViewerManager::active_title_att);
  else
   vp->set_text_attribute(ViewerManager::inactive_title_att);

  *vp << "FTP("
      << remote_host_
      << "): "
      << remote_directory_.shorten(size.col_ - 6 - remote_host_.size())
      ;

  vp->fill_to_eol();

  //
  // handle the data rows
  //

  visible_rows_ = size.row_- first_row_;

  int row; // count of rows processed, not screen pos

  for(row=0; row < visible_rows_; ++row)
  {
    size_t line = row + page_top_;

    if(line >= lines_.size())
      break;

    paint_row(vp, row, line);

    if(left_margin_)
    {
      vp->set_curpos(row + first_row_, 0);
      vp->set_text_attribute(ViewerManager::inactive_mark_att);

      using namespace CursesInterface;

      vp->write(line_chars[VL_MIDDLE]);
    }

  }

  //
  // Handle the empty region below the last title
  //

  vp->set_text_attribute(ViewerManager::normal_att);

  while(row < visible_rows_)
  {
    vp->set_curpos(row + first_row_, 0);
   
    if(row == visible_rows_ - 1)
      vp->set_text_attribute(ViewerManager::bottom_att);

    vp->fill_to_eol();

    if(left_margin_)
    {
      vp->set_curpos(row + first_row_, 0);
      vp->set_text_attribute(ViewerManager::inactive_mark_att);

      using namespace CursesInterface;

      vp->write(line_chars[VL_MIDDLE]);
    }

    ++row;
  }

  //
  //  Leave the cursor in the correct place for input
  //

  vp->set_curpos(cur_line_ - page_top_ + first_row_, left_margin_);

}
bool 
FTPviewer::Impl::
handle_event (input_event const *e,  viewport* vp)
{

  if(e->type_ == input_event::ForceExitKey)
    return true;


  if(e->type_ != input_event::DataKey &&
     e->type_ != input_event::FunctionKey
    )
    return false;


  if(lines_.size() == 0 &&
     e->value_ != 'p'    &&
     e->value_ != '^'
    )
    return true;  // can't issue commands to empty records -- except for
                  // quit, put file to empty page
                  // list parent directory

  int edit_func = vp->window()->func[e->value_];

  paint_row(vp, cur_line_ - page_top_, cur_line_, false); 

  // handle key with no highlight of current line, then re-highlight it

  switch(edit_func)
  {
    case CursorWindow::func_data:
      switch(e->value_)
      {
        case 'q':  // 'q' quits
        case 'k':  // 'k' quits too
          return true;
        
        case 'd': // delete a file
          {
             std::string child_path;
        
             child_path = remote_directory_;
        
             if(child_path.size())
               child_path += "/";
        
             FileName curfile = child_path + lines_[cur_line_].name_;
        
             if(lines_[cur_line_].status_.mode.is_dir())
             {
               vp->beep();
               break;
             }
        
             {
               dialog d("Delete file (Esc means NO!)");
        
               d += new ok_field("ok", string("Delete") + lines_[cur_line_].name_);
        
               if(d.popup(manager_->window()))
               {
                 break;
               }
        
             }
        
             int err = FTP::del(remote_host_,
                                userid_,
                                password_,
                                curfile
                               );
                                
             if(err < 0)
             {
                vp->beep();
             }
             else
             {
               lines_.erase(lines_.begin() + cur_line_);
               vp->activate();
             }
        
          }
          break;
        
        case 'g': // get a file
          {

             std::string child_path;
        
             child_path = remote_directory_;
        
             if(child_path.size())
               child_path += "/";

             FileName curfile = child_path + lines_[cur_line_].name_;
        
             if(lines_[cur_line_].status_.mode.is_dir())
             {
               vp->beep();
               break;
             }
        
             {
               dialog d("Download " + lines_[cur_line_].name_ + " (esc for no)");
        
               d += new ok_field("ok", "ok");
        
               if(d.popup(manager_->window()))
               {
                 break;
               }
             }
        
        
             if(FTP::get(remote_host_,
                         userid_,
                         password_,
                         curfile,
                         local_directory_ + "/" + lines_[cur_line_].name_
                        )
               )
             {
                message m("Error downloading " + curfile);
                m.popup(manager_->window());
             }
             else
             {
                manager_->window()->beep();
                message m("Download successfull!");
                m.popup(manager_->window());
        
             }
        
          }
          break;
        
        case 'p':
          {
             filename_list filenames;
        
             int count = FileName::find_matching(local_directory_ + "/*", 
                                                 &filenames);
        
             if(count)
             {
               selection s("Select a file to upload:");
        
               filename_list::iterator first = filenames.begin(),
                                             last  = filenames.end();
        
               while(first != last)
               {
                 string const& cur = *first++;
                
                 s += cur;
               }
        
        
               if(!s.popup(manager_->window()))
               {
                  int rc = FTP::put(remote_host_,
                                    userid_,
                                    password_,
                                    remote_directory_ +  "/" +s.selection_
                                   );
                                
                  if(rc < 0)
                  {
                    message m("Error putting file");
                
                    m += " " + FTP::error();
                
                    m.popup( manager_->window() );
                  }
                  else
                  {
                    fileinfo_list tmp;
                
                    int count = FTP::stat_matching(remote_host_,
                                                   userid_,
                                                   password_,
                                                   remote_directory_ + "/*",
                                                   &tmp
                                                  );
                                                
                    if(count < 0)
                    {
                      message m("Error:  couldn't re-read remote directory");
                      m += "";
                      m += "  " + FTP::error();
                
                      m.popup(manager_->window());
                    }
                    else
                    {
                      lines_.resize(count);
                
                      std::copy(tmp.begin(), tmp.end(), lines_.begin());
                      vp->activate();
                
                    }
                
                  }
               }
        
             }
             else
             {
               message m("No files in local directory");
               m += "";
               m += "  sorry...";
        
               m.popup(manager_->window());
             }
        
        
          }
          break;
        
        case '^':  // go up to the parent directory
          {
            if(remote_directory_.size() == 0)
            {
              vp->beep();
              break;
            }
        
            FileName curfile = remote_directory_.dirname();
        
            if(curfile[curfile.size()-1] == '/')
            {
              curfile.erase(curfile.size()-1);
            }
        
            Viewer*parent_ftp_session = active_viewers_[curfile];
        
            if(parent_ftp_session) // already have a session for this, show it
            {
              manager_->activate(parent_ftp_session);
              return false;
            }
        
            {
              // navigate down into the directory on the remote host
        
              FTPviewer* newbie = new FTPviewer(manager_,
                                                local_directory_,
                                                remote_host_,
                                                userid_,
                                                password_,
                                                curfile);
        
              if(newbie)
              {
                fileinfo_list lofi;
        
                int count = FTP::stat_matching(remote_host_,
                                               userid_,
                                               password_,
                                               curfile + "/*",
                                               &lofi
                                              );
        
        
                                        
                if(count < 0)
                {
                   message m("FTP operation failed");
        
                   m += "  " + FTP::error();
        
                   m.popup(manager_->window());
                   delete newbie;
                }
                else
                {
                  newbie->impl_->lines_.resize(count);
        
                  std::copy(lofi.begin(), lofi.end(), newbie->impl_->lines_.begin());
        
                  manager_->add(newbie, local_directory_);
        
                  return false;  // prevent painting of current window info
                                 // that appears below
                }
              }
            }
          }
          break;
        
        
        default:
          vp->beep();
          break;
      }
      break;

    case CursorWindow::func_find:
      {
         dialog d("Find file or directory");

         d += new string_field("string", "Search for", "", 20);
         d += new ok_field("ok", "ok");
        
         if(d.popup(manager_->window()))
         {
           break;
         }
        
         search_ = d.element_value("string");

         size_t scan = cur_line_+1;
        
         while(scan < lines_.size())
         {
        
           string::iterator start = std::search(lines_[scan].name_.begin(),
                                                lines_[scan].name_.end(),
                                                search_.begin(),
                                                search_.end()
                                               );
           if(start != lines_[scan].name_.end())
           {
             // found it
        
             break;
           }
        
           ++scan;
         }
        
         if(scan == lines_.size())
         {
           vp->beep();
         }
         else
         {
            page_top_ = scan;
            cur_line_ = scan;
            vp->activate();
         }
      }
      break;

    case CursorWindow::func_findnxt:
      {
         size_t scan = cur_line_+1;
        
         while(scan < lines_.size())
         {
        
           string::iterator start = std::search(lines_[scan].name_.begin(),
                                                lines_[scan].name_.end(),
                                                search_.begin(),
                                                search_.end()
                                               );
           if(start != lines_[scan].name_.end())
           {
             // found it
        
             break;
           }
        
           ++scan;
         }
        
         if(scan == lines_.size())
         {
           vp->beep();
         }
         else
         {
            page_top_ = scan;
            cur_line_ = scan;
            vp->activate();
         }
      }
      break;

    case CursorWindow::func_clreol:
      return true;  // ^K quits

    case CursorWindow::func_enter:
      {
        std::string child_path;
        
        child_path = remote_directory_;
        
        if(child_path.size())
          child_path += "/";

        FileName curfile = child_path + lines_[cur_line_].name_;
        
        if(lines_[cur_line_].status_.mode.is_dir())
        {
          // navigate down into the directory on the remote host
        
          Viewer* child_ftp_session = active_viewers_[curfile];
        
          if(child_ftp_session) // already started this viewer, just show it
          {
            manager_->activate(child_ftp_session);
            return false;
          }
        
        
          FTPviewer* newbie = new FTPviewer(manager_,
                                            local_directory_,
                                            remote_host_,
                                            userid_,
                                            password_,
                                            curfile);
        
          if(newbie)
          {
            fileinfo_list lofi;
        
            int count = FTP::stat_matching(remote_host_,
                                           userid_,
                                           password_,
                                           curfile + "/*",
                                           &lofi
                                          );
        
        
                                        
            if(count < 0)
            {
               message m("FTP operation failed");
        
               m += "  " + FTP::error();
        
               m.popup(manager_->window());
               delete newbie;
            }
            else
            {
              newbie->impl_->lines_.resize(count);
        
              std::copy(lofi.begin(), lofi.end(), newbie->impl_->lines_.begin());
        
              manager_->add(newbie, local_directory_);
        
              return false;  // prevent painting of current window info
                             // that appears below
            }
          }
        }
        else
        {
           // download it to a temp file and bring up a viewer on it
        
           int count = FTP::get(remote_host_,
                                userid_,
                                password_,
                                curfile,
                                "ftp.tmp"
                               );
                        
           if(count < 0)
           {
             message m("Error downloading file for viewing");
        
               m += string("Remote file name = ") + lines_[cur_line_].name_;
               m += "";
               m += "Local file name = ftp.tmp";
               m += "";
               m += string("Error = ") + FTP::error();
        
               m.popup( manager_->window() );
        
           }
           else
           {
             Viewer *v = manager_->open("ftp.tmp");
        
             if(v)
             {
               manager_->add(v, string("ftp://") + remote_host_ + "/" + curfile);
               return false;
             }
           }
        
                        
        
        }
        
      }
      break;

    case CursorWindow::func_top:
      page_top_ = 0;
      cur_line_ = 0;
      vp->activate();
      break;

    case CursorWindow::func_bottom:
      if(lines_.size())
      {
        page_top_ = lines_.size()-1;
        cur_line_ = lines_.size()-1;
      }
      else
      {
        page_top_ = 0;
        cur_line_ = 0;
      }
      vp->activate();
      break;

    case CursorWindow::func_down:

      if(cur_line_ < lines_.size() -1)
      {
        ++cur_line_;
      }

      if(cur_line_ - page_top_ >= size_t(visible_rows_))
      {
        ++page_top_;

        vp->activate();
      }
      break;

    case CursorWindow::func_up:

      if(cur_line_)
      {
        --cur_line_;
        
        if(cur_line_ < page_top_ )
        {
          --page_top_;
        
          vp->activate();
        }
      }
      break;

    case CursorWindow::func_next:

      cur_line_ += visible_rows_;
      page_top_ += visible_rows_;

      if(cur_line_ >= lines_.size())
      {
        cur_line_ = lines_.size() - 1;
        page_top_ = cur_line_;
      }

      vp->activate();

      break;

    case CursorWindow::func_prior:

      if(page_top_ < size_t(visible_rows_))
      {
        page_top_ = 0;
        cur_line_ = 0;
      }
      else
      {
        page_top_ -= visible_rows_;
        cur_line_ -= visible_rows_;
      }

      vp->activate();
      break;
  }

  paint_row(vp, cur_line_ - page_top_, cur_line_);

  vp->set_curpos(first_row_ + (cur_line_ - page_top_), 0);

  return false;

}
void
FTPviewer::Impl::
help()
{
  typedef std::list<string> help_text;

  std::auto_ptr< help_text > viewer_help( new help_text );

  viewer_help->push_back("Help for the FTP viewer");

  viewer_help->push_back("  In addition to the standard key bindings");
  viewer_help->push_back("  shown later, the text editor interprets");
  viewer_help->push_back("  the following parochial key bindings:");
  viewer_help->push_back("    ^X ^K -- quits the edit session");
  viewer_help->push_back("    ^X  k -- quits the edit session");
  viewer_help->push_back("");
  viewer_help->push_back("    'g'   -- downloads the file under the cursor");
  viewer_help->push_back("    'p'   -- uploads a file from the local directory");
  viewer_help->push_back("    'd'   -- deletes the file under the cursor");
  viewer_help->push_back("    Enter -- navigates down into sub-directories");
  viewer_help->push_back("    '^'   -- navigate up to the parent directory");
  viewer_help->push_back("    ^S    -- search for file or directory name fragments");
  viewer_help->push_back("    ^N    -- repeat previous search");
  viewer_help->push_back("");


  manager_->help_helper(*viewer_help);
}

} // namespace cxxtls