__ftp__.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2006-2021 The Octave Project Developers
//
// See the file COPYRIGHT.md in the top-level directory of this
// distribution or <https://octave.org/copyright/>.
//
// This file is part of Octave.
//
// Octave 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 3 of the License, or
// (at your option) any later version.
//
// Octave 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Octave; see the file COPYING.  If not, see
// <https://www.gnu.org/licenses/>.
//
////////////////////////////////////////////////////////////////////////
 
#if defined (HAVE_CONFIG_H)
#  include "config.h"
#endif
 
#include <string>
#include <fstream>
#include <iomanip>
 
#include "dir-ops.h"
#include "file-ops.h"
#include "file-stat.h"
#include "lo-sysdep.h"
#include "oct-env.h"
#include "oct-handle.h"
#include "glob-match.h"
#include "url-transfer.h"
 
#include "defun.h"
#include "error.h"
#include "interpreter.h"
#include "oct-map.h"
#include "oct-refcount.h"
#include "ov-cell.h"
#include "ov-classdef.h"
#include "ovl.h"
#include "pager.h"
#include "unwind-prot.h"
#include "url-handle-manager.h"
 
static void
delete_file (const std::string& file)
{
  octave::sys::unlink (file);
}
 
DEFMETHOD (__ftp__, interp, args, ,
           doc: /* -*- texinfo -*-
@deftypefn  {} {@var{handle} =} __ftp__ (@var{host})
@deftypefnx {} {@var{handle} =} __ftp__ (@var{host}, @var{username}, @var{password})
Undocumented internal function
@end deftypefn */)
{
  int nargin = args.length ();
 
  if (nargin < 1 || nargin > 3)
    print_usage ();
 
  std::string host = args(0).xstring_value ("__ftp__: HOST must be a string");
 
  std::string user = (nargin > 1)
                     ? args(1).xstring_value ("__ftp__: USER must be a string")
                     : "anonymous";
 
  std::string passwd = (nargin > 2)
                       ? args(2).xstring_value ("__ftp__: PASSWD must be a string")
                       : "";
 
  octave::url_handle_manager& uhm = interp.get_url_handle_manager ();
 
  octave::url_handle uh = uhm.make_url_handle (host, user, passwd,
                                               octave_stdout);
 
  return ovl (uh.value ());
}
 
DEFMETHOD (__ftp_pwd__, interp, args, ,
           doc: /* -*- texinfo -*-
@deftypefn {} {} __ftp_pwd__ (@var{handle})
Undocumented internal function
@end deftypefn */)
{
  if (args.length () != 1)
    error ("__ftp_pwd__: incorrect number of arguments");
 
  octave::url_handle_manager& uhm = interp.get_url_handle_manager ();
 
  octave::url_transfer url_xfer = uhm.get_object (args(0));
 
  if (! url_xfer.is_valid ())
    error ("__ftp_pwd__: invalid ftp handle");
 
  return ovl (url_xfer.pwd ());
}
 
DEFMETHOD (__ftp_cwd__, interp, args, ,
           doc: /* -*- texinfo -*-
@deftypefn {} {} __ftp_cwd__ (@var{handle}, @var{path})
Undocumented internal function
@end deftypefn */)
{
  int nargin = args.length ();
 
  if (nargin != 1 && nargin != 2)
    error ("__ftp_cwd__: incorrect number of arguments");
 
  std::string path = "";
  if (nargin > 1)
    path = args(1).xstring_value ("__ftp_cwd__: PATH must be a string");
 
  octave::url_handle_manager& uhm = interp.get_url_handle_manager ();
 
  octave::url_transfer url_xfer = uhm.get_object (args(0));
 
  if (! url_xfer.is_valid ())
    error ("__ftp_cwd__: invalid ftp handle");
 
  url_xfer.cwd (path);
 
  return ovl ();
}
 
DEFMETHOD (__ftp_dir__, interp, args, nargout,
           doc: /* -*- texinfo -*-
@deftypefn {} {} __ftp_dir__ (@var{handle})
Undocumented internal function
@end deftypefn */)
{
  if (args.length () != 1)
    error ("__ftp_dir__: incorrect number of arguments");
 
  octave::url_handle_manager& uhm = interp.get_url_handle_manager ();
 
  octave::url_transfer url_xfer = uhm.get_object (args(0));
 
  if (! url_xfer.is_valid ())
    error ("__ftp_dir__: invalid ftp handle");
 
  octave_value retval;
 
  if (nargout == 0)
    url_xfer.dir ();
  else
    {
      string_vector sv = url_xfer.list ();
      octave_idx_type n = sv.numel ();
 
      if (n == 0)
        {
          string_vector flds (5);
 
          flds(0) = "name";
          flds(1) = "date";
          flds(2) = "bytes";
          flds(3) = "isdir";
          flds(4) = "datenum";
 
          retval = octave_map (flds);
        }
      else
        {
          octave_map st;
 
          Cell filectime (dim_vector (n, 1));
          Cell filesize (dim_vector (n, 1));
          Cell fileisdir (dim_vector (n, 1));
          Cell filedatenum (dim_vector (n, 1));
 
          st.assign ("name", Cell (sv));
 
          for (octave_idx_type i = 0; i < n; i++)
            {
              time_t ftime;
              bool fisdir;
              double fsize;
 
              url_xfer.get_fileinfo (sv(i), fsize, ftime, fisdir);
 
              fileisdir (i) = fisdir;
              filectime (i) = ctime (&ftime);
              filesize (i) = fsize;
              filedatenum (i) = double (ftime);
            }
 
          st.assign ("date", filectime);
          st.assign ("bytes", filesize);
          st.assign ("isdir", fileisdir);
          st.assign ("datenum", filedatenum);
 
          retval = st;
        }
    }
 
  return retval;
}
 
DEFMETHOD (__ftp_ascii__, interp, args, ,
           doc: /* -*- texinfo -*-
@deftypefn {} {} __ftp_ascii__ (@var{handle})
Undocumented internal function
@end deftypefn */)
{
  if (args.length () != 1)
    error ("__ftp_ascii__: incorrect number of arguments");
 
  octave::url_handle_manager& uhm = interp.get_url_handle_manager ();
 
  octave::url_transfer url_xfer = uhm.get_object (args(0));
 
  if (! url_xfer.is_valid ())
    error ("__ftp_ascii__: invalid ftp handle");
 
  url_xfer.ascii ();
 
  return ovl ();
}
 
DEFMETHOD (__ftp_binary__, interp, args, ,
           doc: /* -*- texinfo -*-
@deftypefn {} {} __ftp_binary__ (@var{handle})
Undocumented internal function
@end deftypefn */)
{
  if (args.length () != 1)
    error ("__ftp_binary__: incorrect number of arguments");
 
  octave::url_handle_manager& uhm = interp.get_url_handle_manager ();
 
  octave::url_transfer url_xfer = uhm.get_object (args(0));
 
  if (! url_xfer.is_valid ())
    error ("__ftp_binary__: invalid ftp handle");
 
  url_xfer.binary ();
 
  return ovl ();
}
 
DEFMETHOD (__ftp_close__, interp, args, ,
           doc: /* -*- texinfo -*-
@deftypefn {} {} __ftp_close__ (@var{handle})
Undocumented internal function
@end deftypefn */)
{
  if (args.length () != 1)
    error ("__ftp_close__: incorrect number of arguments");
 
  octave::url_handle_manager& uhm = interp.get_url_handle_manager ();
 
  octave::url_handle h = uhm.lookup (args(0));
 
  if (! h.ok ())
    error ("__ftp_close__: invalid ftp handle");
 
  uhm.free (h);
 
  return ovl ();
}
 
DEFMETHOD (__ftp_mode__, interp, args, ,
           doc: /* -*- texinfo -*-
@deftypefn {} {} __ftp_mode__ (@var{handle})
Undocumented internal function
@end deftypefn */)
{
  if (args.length () != 1)
    error ("__ftp_mode__: incorrect number of arguments");
 
  octave::url_handle_manager& uhm = interp.get_url_handle_manager ();
 
  octave::url_transfer url_xfer = uhm.get_object (args(0));
 
  if (! url_xfer.is_valid ())
    error ("__ftp_binary__: invalid ftp handle");
 
  return ovl (url_xfer.is_ascii () ? "ascii" : "binary");
}
 
DEFMETHOD (__ftp_delete__, interp, args, ,
           doc: /* -*- texinfo -*-
@deftypefn {} {} __ftp_delete__ (@var{handle}, @var{path})
Undocumented internal function
@end deftypefn */)
{
  if (args.length () != 2)
    error ("__ftp_delete__: incorrect number of arguments");
 
  std::string file = args(1).xstring_value ("__ftp_delete__: FILE must be a string");
 
  octave::url_handle_manager& uhm = interp.get_url_handle_manager ();
 
  octave::url_transfer url_xfer = uhm.get_object (args(0));
 
  if (! url_xfer.is_valid ())
    error ("__ftp_delete__: invalid ftp handle");
 
  url_xfer.del (file);
 
  return ovl ();
}
 
DEFMETHOD (__ftp_rmdir__, interp, args, ,
           doc: /* -*- texinfo -*-
@deftypefn {} {} __ftp_rmdir__ (@var{handle}, @var{path})
Undocumented internal function
@end deftypefn */)
{
  if (args.length () != 2)
    error ("__ftp_rmdir__: incorrect number of arguments");
 
  std::string dir = args(1).xstring_value ("__ftp_rmdir__: DIR must be a string");
 
  octave::url_handle_manager& uhm = interp.get_url_handle_manager ();
 
  octave::url_transfer url_xfer = uhm.get_object (args(0));
 
  if (! url_xfer.is_valid ())
    error ("__ftp_rmdir__: invalid ftp handle");
 
  url_xfer.rmdir (dir);
 
  return ovl ();
}
 
DEFMETHOD (__ftp_mkdir__, interp, args, ,
           doc: /* -*- texinfo -*-
@deftypefn {} {} __ftp_mkdir__ (@var{handle}, @var{path})
Undocumented internal function
@end deftypefn */)
{
  if (args.length () != 2)
    error ("__ftp_mkdir__: incorrect number of arguments");
 
  std::string dir = args(1).xstring_value ("__ftp_mkdir__: DIR must be a string");
 
  octave::url_handle_manager& uhm = interp.get_url_handle_manager ();
 
  octave::url_transfer url_xfer = uhm.get_object (args(0));
 
  if (! url_xfer.is_valid ())
    error ("__ftp_mkdir__: invalid ftp handle");
 
  url_xfer.mkdir (dir);
 
  return ovl ();
}
 
DEFMETHOD (__ftp_rename__, interp, args, ,
           doc: /* -*- texinfo -*-
@deftypefn {} {} __ftp_rename__ (@var{handle}, @var{path})
Undocumented internal function
@end deftypefn */)
{
  if (args.length () != 3)
    error ("__ftp_rename__: incorrect number of arguments");
 
  std::string oldname = args(1).xstring_value ("__ftp_rename__: OLDNAME must be a string");
  std::string newname = args(2).xstring_value ("__ftp_rename__: NEWNAME must be a string");
 
  octave::url_handle_manager& uhm = interp.get_url_handle_manager ();
 
  octave::url_transfer url_xfer = uhm.get_object (args(0));
 
  if (url_xfer.is_valid ())
    error ("__ftp_rename__: invalid ftp handle");
 
  url_xfer.rename (oldname, newname);
 
  return ovl ();
}
 
DEFMETHOD (__ftp_mput__, interp, args, nargout,
           doc: /* -*- texinfo -*-
@deftypefn {} {} __ftp_mput__ (@var{handle}, @var{files})
Undocumented internal function
@end deftypefn */)
{
  if (args.length () != 2)
    error ("__ftp_mput__: incorrect number of arguments");
 
  std::string pat = args(1).xstring_value ("__ftp_mput__: PATTERN must be a string");
 
  octave::url_handle_manager& uhm = interp.get_url_handle_manager ();
 
  octave::url_transfer url_xfer = uhm.get_object (args(0));
 
  if (! url_xfer.is_valid ())
    error ("__ftp_mput__: invalid ftp handle");
 
  string_vector file_list;
 
  glob_match pattern (octave::sys::file_ops::tilde_expand (pat));
  string_vector files = pattern.glob ();
 
  for (octave_idx_type i = 0; i < files.numel (); i++)
    {
      std::string file = files(i);
 
      octave::sys::file_stat fs (file);
 
      if (! fs.exists ())
        error ("__ftp__mput: file does not exist");
 
      if (fs.is_dir ())
        {
          file_list.append (url_xfer.mput_directory ("", file));
 
          if (! url_xfer.good ())
            error ("__ftp_mput__: %s", url_xfer.lasterror ().c_str ());
        }
      else
        {
          // FIXME: Does ascii mode need to be flagged here?
          std::ifstream ifile = 
            octave::sys::ifstream (file.c_str (),
                                   std::ios::in | std::ios::binary);
 
          if (! ifile.is_open ())
            error ("__ftp_mput__: unable to open file");
 
          url_xfer.put (file, ifile);
 
          ifile.close ();
 
          if (! url_xfer.good ())
            error ("__ftp_mput__: %s", url_xfer.lasterror ().c_str ());
 
          file_list.append (file);
        }
    }
 
  if (nargout > 0)
    return ovl (file_list);
  else
    return ovl ();
}
 
DEFMETHOD (__ftp_mget__, interp, args, ,
           doc: /* -*- texinfo -*-
@deftypefn  {} {} __ftp_mget__ (@var{handle}, @var{pattern})
@deftypefnx {} {} __ftp_mget__ (@var{handle}, @var{pattern}, @var{target})
Undocumented internal function
@end deftypefn */)
{
  int nargin = args.length ();
 
  if (nargin != 2 && nargin != 3)
    error ("__ftp_mget__: incorrect number of arguments");
 
  std::string file = args(1).xstring_value ("__ftp_mget__: PATTERN must be a string");
 
  std::string target;
 
  if (nargin == 3 && ! args(2).isempty ())
    target = args(2).xstring_value ("__ftp_mget__: TARGET must be a string")
             + octave::sys::file_ops::dir_sep_str ();
 
  octave::url_handle_manager& uhm = interp.get_url_handle_manager ();
 
  octave::url_transfer url_xfer = uhm.get_object (args(0));
 
  if (! url_xfer.is_valid ())
    error ("__ftp_mget__: invalid ftp handle");
 
  string_vector sv = url_xfer.list ();
  octave_idx_type n = 0;
  glob_match pattern (file);
 
  for (octave_idx_type i = 0; i < sv.numel (); i++)
    {
      if (pattern.match (sv(i)))
        {
          n++;
 
          time_t ftime;
          bool fisdir;
          double fsize;
 
          url_xfer.get_fileinfo (sv(i), fsize, ftime, fisdir);
 
          if (fisdir)
            url_xfer.mget_directory (sv(i), target);
          else
            {
              std::ofstream ofile =
                octave::sys::ofstream ((target + sv(i)).c_str (),
                                       std::ios::out | std::ios::binary);
 
              if (! ofile.is_open ())
                error ("__ftp_mget__: unable to open file");
 
              octave::unwind_protect_safe frame;
 
              frame.add_fcn (delete_file, target + sv(i));
 
              url_xfer.get (sv(i), ofile);
 
              ofile.close ();
 
              if (url_xfer.good ())
                frame.discard ();
            }
 
          if (! url_xfer.good ())
            error ("__ftp_mget__: %s", url_xfer.lasterror().c_str());
        }
    }
 
  if (n == 0)
    error ("__ftp_mget__: file not found");
 
  return ovl ();
}