file-ops.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 1996-2026 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 <cerrno>
#include <cstdio>
#include <cstdlib>
#include <cstring>
 
#include <vector>
 
#if defined (OCTAVE_USE_WINDOWS_API)
#  include <cctype>
#  include <system_error>
 
#  include <windows.h>
#  include "unwind-prot.h"
#else
#  include "canonicalize-file-name-wrapper.h"
#endif
 
#include "areadlink-wrapper.h"
#include "dir-ops.h"
#include "file-ops.h"
#include "file-stat.h"
#include "gen-tempname-wrapper.h"
#include "oct-env.h"
#include "oct-locbuf.h"
#include "oct-password.h"
#include "oct-sysdep.h"
#include "quit.h"
#include "stat-wrappers.h"
#include "str-vec.h"
#include "unistd-wrappers.h"
 
OCTAVE_BEGIN_NAMESPACE(octave)
 
// The following tilde-expansion code was stolen and adapted from
// readline.
 
// The default value of tilde_additional_prefixes.  This is set to
// whitespace preceding a tilde so that simple programs which do not
// perform any word separation get desired behavior.
static const char *default_prefixes[] = { " ~", "\t~", ":~", nullptr };
 
// The default value of tilde_additional_suffixes.  This is set to
// whitespace or newline so that simple programs which do not perform
// any word separation get desired behavior.
static const char *default_suffixes[] = { " ", "\n", ":", nullptr };
 
static std::size_t
tilde_find_prefix (const std::string& s, std::size_t& len)
{
  len = 0;
 
  std::size_t s_len = s.length ();
 
  if (s_len == 0 || s[0] == '~')
    return 0;
 
  string_vector prefixes = sys::file_ops::tilde_additional_prefixes;
 
  if (! prefixes.empty ())
    {
      for (std::size_t i = 0; i < s_len; i++)
        {
          for (int j = 0; j < prefixes.numel (); j++)
            {
              std::size_t pfx_len = prefixes[j].length ();
 
              if (prefixes[j] == s.substr (i, pfx_len))
                {
                  len = pfx_len - 1;
                  return i + len;
                }
            }
        }
    }
 
  return s_len;
}
 
// Find the end of a tilde expansion in S, and return the index
// of the character which ends the tilde definition.
 
static std::size_t
tilde_find_suffix (const std::string& s)
{
  std::size_t s_len = s.length ();
 
  string_vector suffixes = sys::file_ops::tilde_additional_suffixes;
 
  std::size_t i = 0;
 
  for ( ; i < s_len; i++)
    {
      if (sys::file_ops::is_dir_sep (s[i]))
        break;
 
      if (! suffixes.empty ())
        {
          for (int j = 0; j < suffixes.numel (); j++)
            {
              std::size_t sfx_len = suffixes[j].length ();
 
              if (suffixes[j] == s.substr (i, sfx_len))
                return i;
            }
        }
    }
 
  return i;
}
 
// Take FNAME and return the tilde prefix we want expanded.
 
static std::string
isolate_tilde_prefix (const std::string& fname)
{
  std::size_t f_len = fname.length ();
 
  std::size_t len = 1;
 
  while (len < f_len && ! sys::file_ops::is_dir_sep (fname[len]))
    len++;
 
  return fname.substr (1, len);
}
 
// Do the work of tilde expansion on FILENAME.  FILENAME starts with a
// tilde.
 
static std::string
tilde_expand_word (const std::string& filename)
{
  std::size_t f_len = filename.length ();
 
  if (f_len == 0 || filename[0] != '~')
    return std::string (filename);
 
  // A leading '~/' or a bare '~' is *always* translated to the value
  // of $HOME or the home directory of the current user, regardless of
  // any preexpansion hook.
 
  if (f_len == 1 || sys::file_ops::is_dir_sep (filename[1]))
    return sys::env::get_home_directory () + filename.substr (1);
 
  std::string username = isolate_tilde_prefix (filename);
 
  std::size_t user_len = username.length ();
 
  std::string dirname;
 
  if (sys::file_ops::tilde_expansion_preexpansion_hook)
    {
      std::string expansion
        = sys::file_ops::tilde_expansion_preexpansion_hook (username);
 
      if (! expansion.empty ())
        return expansion + filename.substr (user_len+1);
    }
 
  // No preexpansion hook, or the preexpansion hook failed.  Look in the
  // password database.
 
  sys::password pw = sys::password::getpwnam (username);
 
  if (! pw)
    {
      // If the calling program has a special syntax for expanding tildes,
      // and we couldn't find a standard expansion, then let them try.
 
      if (sys::file_ops::tilde_expansion_failure_hook)
        {
          std::string expansion
            = sys::file_ops::tilde_expansion_failure_hook (username);
 
          if (! expansion.empty ())
            dirname = expansion + filename.substr (user_len+1);
        }
 
      // If we don't have a failure hook, or if the failure hook did not
      // expand the tilde, return a copy of what we were passed.
 
      if (dirname.empty ())
        dirname = filename;
    }
  else
    dirname = pw.dir () + filename.substr (user_len+1);
 
  return dirname;
}
 
OCTAVE_BEGIN_NAMESPACE(sys)
OCTAVE_BEGIN_NAMESPACE(file_ops)
 
char dev_sep_char ()
{
#if (defined (OCTAVE_HAVE_WINDOWS_FILESYSTEM) && ! defined (OCTAVE_HAVE_POSIX_FILESYSTEM))
  return ':';
#else
  return 0;
#endif
}
 
char
dir_sep_char ()
{
#if (defined (OCTAVE_HAVE_WINDOWS_FILESYSTEM) && ! defined (OCTAVE_HAVE_POSIX_FILESYSTEM))
  return '\\';
#else
  return '/';
#endif
}
 
std::string
dir_sep_str ()
{
#if (defined (OCTAVE_HAVE_WINDOWS_FILESYSTEM) && ! defined (OCTAVE_HAVE_POSIX_FILESYSTEM))
  return R"(\)";
#else
  return "/";
#endif
}
 
std::string
dir_sep_chars ()
{
#if defined (OCTAVE_HAVE_WINDOWS_FILESYSTEM)
  return R"(/\)";
#else
  return dir_sep_str ();
#endif
}
 
tilde_expansion_hook tilde_expansion_preexpansion_hook = nullptr;
 
tilde_expansion_hook tilde_expansion_failure_hook = nullptr;
 
string_vector tilde_additional_prefixes = default_prefixes;
 
string_vector tilde_additional_suffixes = default_suffixes;
 
bool
is_dev_sep (char c)
{
#if (defined (OCTAVE_HAVE_WINDOWS_FILESYSTEM) && ! defined (OCTAVE_HAVE_POSIX_FILESYSTEM))
  return c == dev_sep_char ();
#else
  octave_unused_parameter (c);
 
  return false;
#endif
}
 
bool
is_dir_sep (char c)
{
  std::string tmp = dir_sep_chars ();
  return tmp.find (c) != std::string::npos;
}
 
std::string
tilde_expand (const std::string& name)
{
  if (name.find ('~') == std::string::npos)
    return std::string (name);
  else
    {
      std::string result;
 
      std::size_t name_len = name.length ();
 
      // Scan through S expanding tildes as we come to them.
 
      std::size_t pos = 0;
 
      while (1)
        {
          if (pos > name_len)
            break;
 
          std::size_t len;
 
          // Make START point to the tilde which starts the expansion.
 
          std::size_t start = tilde_find_prefix (name.substr (pos), len);
 
          result.append (name.substr (pos, start));
 
          // Advance STRING to the starting tilde.
 
          pos += start;
 
          // Make FINI be the index of one after the last character of the
          // username.
 
          std::size_t fini = tilde_find_suffix (name.substr (pos));
 
          // If both START and FINI are zero, we are all done.
 
          if (! (start || fini))
            break;
 
          // Expand the entire tilde word, and copy it into RESULT.
 
          std::string tilde_word = name.substr (pos, fini);
 
          pos += fini;
 
          std::string expansion = tilde_expand_word (tilde_word);
 
          result.append (expansion);
        }
 
      return result;
    }
}
 
string_vector
tilde_expand (const string_vector& names)
{
  int n = names.numel ();
 
  string_vector retval (n);
 
  for (int i = 0; i < n; i++)
    retval[i] = tilde_expand (names[i]);
 
  return retval;
}
 
std::string
concat (const std::string& dir, const std::string& file)
{
  return dir.empty ()
         ? file
         : (is_dir_sep (dir.back ())
            ? dir + file
            : dir + dir_sep_char () + file);
}
 
std::string
dirname (const std::string& path)
{
  std::size_t ipos = path.find_last_of (dir_sep_chars ());
 
  return (ipos != std::string::npos) ? path.substr (0, ipos) : "";
}
 
std::string
tail (const std::string& path)
{
  std::size_t ipos = path.find_last_of (dir_sep_chars ());
 
  if (ipos != std::string::npos)
    ipos++;
  else
    ipos = 0;
 
  return path.substr (ipos);
}
 
std::string
native_separator_path (const std::string& path)
{
  std::string retval;
 
  if (dir_sep_char () == '/')
    retval = path;
  else
    {
      std::size_t n = path.length ();
      for (std::size_t i = 0; i < n; i++)
        {
          if (path[i] == '/')
            retval += dir_sep_char();
          else
            retval += path[i];
        }
    }
 
  return retval;
}
 
OCTAVE_END_NAMESPACE(file_ops)
 
int mkdir (const std::string& nm, mode_t md)
{
  std::string msg;
  return mkdir (nm, md, msg);
}
 
int
mkdir (const std::string& name, mode_t mode, std::string& msg)
{
  msg = "";
 
  int status = octave_mkdir_wrapper (name.c_str (), mode);
 
  if (status < 0)
    msg = std::strerror (errno);
 
  return status;
}
 
int
recursive_mkdir (const std::string& name, mode_t mode)
{
  std::string msg;
  return recursive_mkdir (name, mode, msg);
}
 
int
recursive_mkdir (const std::string& name, mode_t mode, std::string& msg)
{
  int status;
 
  // account for root in absolute directories
#if defined (OCTAVE_USE_WINDOWS_API)
  // root of current drive
  std::size_t skip_root = 0;
  if (name.size () > 1)
    {
      if (name[1] == ':')
        // drive root (e.g., C:\‍)
        skip_root = 2;
      else if (file_ops::is_dir_sep (name[0])
               && file_ops::is_dir_sep (name[1]))
        {
          // UNC path root (e.g., \\SERVER\share\‍)
          skip_root = name.find_first_of (file_ops::dir_sep_chars (), 2);
          skip_root = name.find_first_of (file_ops::dir_sep_chars (),
                                          skip_root + 1);
        }
    }
 
  std::size_t delim = name.find_first_of (file_ops::dir_sep_chars (),
                                          skip_root + 1);
#else
  std::size_t delim = name.find_first_of (file_ops::dir_sep_chars (), 1);
#endif
 
  // iterate over all componenents of NAME and make directories
  while (delim != std::string::npos)
    {
      std::string base = name.substr (0, delim);
      sys::file_stat fs (base);
      if (! fs.is_dir ())
        {
          status = mkdir (base, mode, msg);
          if (status < 0)
            return status;
        }
      delim = name.find_first_of (file_ops::dir_sep_chars (), delim + 1);
    }
 
  // finally, create requested directory
  return mkdir (name, mode, msg);
}
 
int
mkfifo (const std::string& nm, mode_t md)
{
  std::string msg;
  return mkfifo (nm, md, msg);
}
 
int
mkfifo (const std::string& name, mode_t mode, std::string& msg)
{
  msg = "";
 
  int status = octave_mkfifo_wrapper (name.c_str (), mode);
 
  if (status < 0)
    msg = std::strerror (errno);
 
  return status;
}
 
int
link (const std::string& old_name, const std::string& new_name)
{
  std::string msg;
  return link (old_name, new_name, msg);
}
 
int
link (const std::string& old_name, const std::string& new_name,
      std::string& msg)
{
  msg = "";
 
  int status = -1;
 
  status = octave_link_wrapper (old_name.c_str (), new_name.c_str ());
 
  if (status < 0)
    msg = std::strerror (errno);
 
  return status;
}
 
int
symlink (const std::string& old_name, const std::string& new_name)
{
  std::string msg;
  return symlink (old_name, new_name, msg);
}
 
int
symlink (const std::string& old_name, const std::string& new_name,
         std::string& msg)
{
  msg = "";
 
  int status = -1;
 
  status = octave_symlink_wrapper (old_name.c_str (), new_name.c_str ());
 
  if (status < 0)
    msg = std::strerror (errno);
 
  return status;
}
 
int
readlink (const std::string& path, std::string& result)
{
  std::string msg;
  return readlink (path, result, msg);
}
 
int
readlink (const std::string& path, std::string& result, std::string& msg)
{
  int status = -1;
 
  msg = "";
 
  char *buf = octave_areadlink_wrapper (path.c_str ());
 
  if (! buf)
    msg = std::strerror (errno);
  else
    {
      result = buf;
      ::free (buf);
      status = 0;
    }
 
  return status;
}
 
int
rename (const std::string& from, const std::string& to)
{
  std::string msg;
  return rename (from, to, msg);
}
 
int
rename (const std::string& from, const std::string& to,
        std::string& msg)
{
  int status = -1;
 
  msg = "";
 
  // Do nothing if source and target are the same file.
  if (same_file (to, from))
    return 0;
 
  // The behavior of std::rename with existing target is not defined by the
  // standard.  Implementations differ vastly.  For Octave, use the following
  // for the case that the target already exists:
  // If the source and the target are regular files, overwrite the target.
  // In other cases, fail.
  if (file_exists (to))
    {
      if (file_exists (to, false) && file_exists (from, false))
        {
#if ! defined (OCTAVE_USE_WINDOWS_API)
          unlink (to);
#endif
        }
      else
        {
          msg = "Target already exists.";
          return status;
        }
    }
 
#if defined (OCTAVE_USE_WINDOWS_API)
  std::wstring wfrom = u8_to_wstring (from);
  std::wstring wto = u8_to_wstring (to);
 
  DWORD from_attr = GetFileAttributesW (wfrom.c_str ());
  DWORD to_attr = GetFileAttributesW (wto.c_str ());
 
  if (from_attr == INVALID_FILE_ATTRIBUTES)
    {
      // from does not exist
      const std::error_condition econd
        = std::system_category ().default_error_condition (ERROR_FILE_NOT_FOUND);
      msg = econd.message ();
      return status;
    }
 
  if (from_attr & FILE_ATTRIBUTE_DIRECTORY)
    {
      // rename directory
      if (to_attr != INVALID_FILE_ATTRIBUTES)
        {
          // target already exists
          msg = "Cannot replace with directory";
          return status;
        }
 
      if (MoveFileExW (wfrom.c_str (), wto.c_str (), 0))
        return 0;
 
      const std::error_condition econd
        = std::system_category ().default_error_condition (GetLastError ());
      msg = econd.message ();
      return status;
    }
 
  // use MoveFileExW with MOVEFILE_REPLACE_EXISTING in a retry loop
  // files might be locked by anti-virus, indexers, etc.
 
  static const int max_retries = 10;
 
  for (int attempt = 0; attempt < max_retries; ++attempt)
    {
      if (MoveFileExW (wfrom.c_str (), wto.c_str (), MOVEFILE_REPLACE_EXISTING))
        return 0;
 
      DWORD err = GetLastError ();
 
      if (err != ERROR_SHARING_VIOLATION
          && err != ERROR_ACCESS_DENIED
          && err != ERROR_LOCK_VIOLATION
          && err != ERROR_DRIVE_LOCKED)
        {
          // return if the error is not potentially transient
          const std::error_condition econd
            = std::system_category ().default_error_condition (err);
          msg = econd.message ();
          return status;
        }
 
      if (attempt + 1 < max_retries)
        {
          // wait before next try
          Sleep (5);
        }
    }
 
  const std::error_condition econd
    = std::system_category ().default_error_condition (GetLastError ());
  msg = econd.message ();
 
#else
  status = std::rename (from.c_str (), to.c_str ());
 
  if (status < 0)
    msg = std::strerror (errno);
#endif
 
  return status;
}
 
int
rmdir (const std::string& name)
{
  std::string msg;
  return rmdir (name, msg);
}
 
int
rmdir (const std::string& name, std::string& msg)
{
  msg = "";
 
  int status = -1;
 
  status = octave_rmdir_wrapper (name.c_str ());
 
  if (status < 0)
    msg = std::strerror (errno);
 
  return status;
}
 
// And a version that works recursively.
 
int
recursive_rmdir (const std::string& name)
{
  std::string msg;
  return recursive_rmdir (name, msg);
}
 
int
recursive_rmdir (const std::string& name, std::string& msg)
{
  msg = "";
 
  int status = 0;
 
  string_vector dirlist;
 
  if (get_dirlist (name, dirlist, msg))
    {
      for (octave_idx_type i = 0; i < dirlist.numel (); i++)
        {
          octave_quit ();
 
          std::string nm = dirlist[i];
 
          // Skip current directory and parent.
          if (nm == "." || nm == "..")
            continue;
 
          std::string fullnm = name + file_ops::dir_sep_str () + nm;
 
          // Get info about the file.  Don't follow links.
          file_stat fs (fullnm, false);
 
          if (fs)
            {
              if (fs.is_dir ())
                {
                  status = recursive_rmdir (fullnm, msg);
 
                  if (status < 0)
                    break;
                }
              else
                {
                  status = unlink (fullnm, msg);
 
                  if (status < 0)
                    break;
                }
            }
          else
            {
              msg = fs.error ();
              break;
            }
        }
 
      if (status >= 0)
        status = rmdir (name, msg);
    }
  else
    status = -1;
 
  return status;
}
 
int
umask (mode_t mode)
{
  return octave_umask_wrapper (mode);
}
 
int
unlink (const std::string& name)
{
  std::string msg;
  return unlink (name, msg);
}
 
int
unlink (const std::string& name, std::string& msg)
{
  msg = "";
 
  int status = -1;
 
  status = octave_unlink_wrapper (name.c_str ());
 
  if (status < 0)
    msg = std::strerror (errno);
 
  return status;
}
 
std::string
tempnam (const std::string& dir, const std::string& pfx)
{
  std::string msg;
  return tempnam (dir, pfx, msg);
}
 
std::string
tempnam (const std::string& dir, const std::string& pfx,
         std::string& msg)
{
  msg = "";
 
  std::string retval;
 
  // get dir path to use for template
  std::string templatename;
  if (dir.empty ())
    templatename = env::get_temp_directory ();
  else if (! file_stat (dir, false).is_dir ())
    templatename = env::get_temp_directory ();
  else
    templatename = dir;
 
  // add dir sep char if it is not there
  if (*templatename.rbegin () != file_ops::dir_sep_char ())
    templatename += file_ops::dir_sep_char ();
 
  if (pfx.empty ())
    templatename += "file";
  else
    templatename += pfx;
 
  // add the required XXXXXX for the template
  templatename += "XXXXXX";
 
  // create and copy template to char array for call to gen_tempname
  OCTAVE_LOCAL_BUFFER (char, tname, templatename.length () + 1);
 
  strcpy (tname, templatename.c_str ());
 
  if (octave_gen_tempname_wrapper (tname) == -1)
    msg = std::strerror (errno);
  else
    retval = tname;
 
  return retval;
}
 
std::string
canonicalize_file_name (const std::string& name)
{
  std::string msg;
  return canonicalize_file_name (name, msg);
}
 
std::string
canonicalize_file_name (const std::string& name, std::string& msg)
{
  msg = "";
 
  std::string retval;
 
  // FIXME:  Consider replacing this with std::filesystem::canonical on all
  // platforms once we allow using C++17.
 
#if defined (OCTAVE_USE_WINDOWS_API)
  // open file handle
  std::wstring wname = u8_to_wstring (name);
  HANDLE h_file = CreateFileW (wname.c_str (), GENERIC_READ,
                               FILE_SHARE_READ, nullptr, OPEN_EXISTING,
                               FILE_FLAG_BACKUP_SEMANTICS, nullptr);
 
  // Might have been a symbolic link that points to a network share.
  // It looks like opening a network share itself (not a file or folder
  // *on* a share) might return an invalid handle. As a workaround, try to
  // open a handle to the symbolic link itself (and do not resolve it).
  if (h_file == INVALID_HANDLE_VALUE)
    h_file = CreateFileW (wname.c_str (), GENERIC_READ,
                          FILE_SHARE_READ, nullptr, OPEN_EXISTING,
                          FILE_FLAG_BACKUP_SEMANTICS
                          | FILE_FLAG_OPEN_REPARSE_POINT, nullptr);
 
  if (h_file == INVALID_HANDLE_VALUE)
    {
      msg = "Unable to open file \"" + name + "\"";
      return retval;
    }
 
  unwind_action close_file_handle (CloseHandle, h_file);
 
  const std::size_t buf_size = 32767;
  wchar_t buffer[buf_size] = L"";
 
  // query canonical name
  DWORD len = GetFinalPathNameByHandleW (h_file, buffer, buf_size,
                                         FILE_NAME_NORMALIZED);
  if (len >= buf_size)
    {
      msg = "Error querying normalized name for \"" + name + "\"";
      return retval;
    }
 
  retval = u8_from_wstring (std::wstring (buffer, len));
 
  // remove prefix
  // "Normal" paths are prefixed by "\\?\".
  // UNC paths are prefixed by "\\?\UNC\".
  if (retval.compare (0, 8, R"(\\?\UNC\)") == 0)
    {
      retval = retval.erase (2, 6);
 
      // If the initial path looked like a mapped network drive, replace
      // portion of path that corresponds to mapped root with drive root.
      if (name.size () < 3 || name[1] != ':')
        return retval;
 
      // UNC path corresponding to original drive letter (mappped drive)
      std::wstring orig_map = wname.substr (0, 3);
      orig_map[2] = L'\\';
      HANDLE h_map = CreateFileW (orig_map.c_str (), GENERIC_READ,
                                  FILE_SHARE_READ, nullptr, OPEN_EXISTING,
                                  FILE_FLAG_BACKUP_SEMANTICS
                                  | FILE_FLAG_OPEN_REPARSE_POINT,
                                  nullptr);
 
      if (h_map == INVALID_HANDLE_VALUE)
        // cannot determine common root
        return retval;
 
      unwind_action close_map_handle (CloseHandle, h_map);
      len = GetFinalPathNameByHandleW (h_map, buffer, buf_size,
                                       FILE_NAME_NORMALIZED);
 
      std::string orig_root
        = u8_from_wstring (std::wstring (buffer, len));
 
      if (orig_root.compare (0, 8, R"(\\?\UNC\)"))
        // root was not a mapped share
        return retval;
 
      orig_root = orig_root.erase (2, 6);
      // trim trailing file separators from UNC path corresponding to root
      std::string file_seps = file_ops::dir_sep_chars ();
      while (file_seps.find (orig_root.back ()) != std::string::npos)
        orig_root.pop_back ();
 
      if (retval.compare (0, orig_root.size (), orig_root))
        // start of UNC path doesn't match mapped drive root
        return retval;
 
      // file is on mapped share
      size_t sep_pos = orig_root.size ();
      if (sep_pos != retval.size ())
        retval = retval.substr (sep_pos-2);
      else
        retval.resize (2);  // no file component
      retval[0] = std::toupper (name[0]);
      retval[1] = ':';
    }
  else if (retval.compare (0, 4, R"(\\?\)") == 0)
    retval = retval.erase (0, 4);
#else
  char *tmp = octave_canonicalize_file_name_wrapper (name.c_str ());
 
  if (tmp)
    {
      retval = tmp;
      free (tmp);
    }
 
  if (retval.empty ())
    msg = std::strerror (errno);
#endif
 
  return retval;
}
 
OCTAVE_END_NAMESPACE(sys)
OCTAVE_END_NAMESPACE(octave)