Move File and IO::FileDescriptor's platform-specific parts to Crystal::System

src/crystal/system/file.cr

@@ -0,0 +1 @@
+require "./unix/file"

src/crystal/system/file_descriptor.cr

@@ -0,0 +1 @@
+require "./unix/file_descriptor"

src/crystal/system/unix/file.cr

@@ -0,0 +1,230 @@
+require "c/sys/file"
+
+# :nodoc:
+module Crystal::System::File
+  def self.open(filename, mode, perm)
+    oflag = open_flag(mode) | LibC::O_CLOEXEC
+
+    fd = LibC.open(filename.check_no_null_byte, oflag, perm)
+    if fd < 0
+      raise Errno.new("Error opening file '#{filename}' with mode '#{mode}'")
+    end
+    fd
+  end
+
+  private def self.open_flag(mode)
+    if mode.size == 0
+      raise "Invalid access mode #{mode}"
+    end
+
+    m = 0
+    o = 0
+    case mode[0]
+    when 'r'
+      m = LibC::O_RDONLY
+    when 'w'
+      m = LibC::O_WRONLY
+      o = LibC::O_CREAT | LibC::O_TRUNC
+    when 'a'
+      m = LibC::O_WRONLY
+      o = LibC::O_CREAT | LibC::O_APPEND
+    else
+      raise "Invalid access mode #{mode}"
+    end
+
+    case mode.size
+    when 1
+      # Nothing
+    when 2
+      case mode[1]
+      when '+'
+        m = LibC::O_RDWR
+      when 'b'
+        # Nothing
+      else
+        raise "Invalid access mode #{mode}"
+      end
+    else
+      raise "Invalid access mode #{mode}"
+    end
+
+    oflag = m | o
+  end
+
+  def self.mktemp(name, extension)
+    tmpdir = tempdir + ::File::SEPARATOR
+    path = "#{tmpdir}#{name}.XXXXXX#{extension}"
+
+    if extension
+      fd = LibC.mkstemps(path, extension.bytesize)
+    else
+      fd = LibC.mkstemp(path)
+    end
+
+    raise Errno.new("mkstemp") if fd == -1
+    {fd, path}
+  end
+
+  def self.tempdir
+    tmpdir = ENV["TMPDIR"]? || "/tmp"
+    tmpdir.rchop(::File::SEPARATOR)
+  end
+
+  def self.stat(path)
+    if LibC.stat(path.check_no_null_byte, out stat) != 0
+      raise Errno.new("Unable to get stat for '#{path}'")
+    end
+    ::File::Stat.new(stat)
+  end
+
+  def self.lstat(path)
+    if LibC.lstat(path.check_no_null_byte, out stat) != 0
+      raise Errno.new("Unable to get lstat for '#{path}'")
+    end
+    ::File::Stat.new(stat)
+  end
+
+  def self.empty?(path)
+    begin
+      stat(path).size == 0
+    rescue Errno
+      raise Errno.new("Error determining size of '#{path}'")
+    end
+  end
+
+  def self.exists?(path)
+    accessible?(path, LibC::F_OK)
+  end
+
+  def self.readable?(path) : Bool
+    accessible?(path, LibC::R_OK)
+  end
+
+  def self.writable?(path) : Bool
+    accessible?(path, LibC::W_OK)
+  end
+
+  def self.executable?(path) : Bool
+    accessible?(path, LibC::X_OK)
+  end
+
+  private def self.accessible?(path, flag)
+    LibC.access(path.check_no_null_byte, flag) == 0
+  end
+
+  def self.file?(path) : Bool
+    if LibC.stat(path.check_no_null_byte, out stat) != 0
+      if Errno.value == Errno::ENOENT
+        return false
+      else
+        raise Errno.new("stat")
+      end
+    end
+    ::File::Stat.new(stat).file?
+  end
+
+  def self.chown(path, uid : Int, gid : Int, follow_symlinks)
+    ret = if !follow_symlinks && symlink?(path)
+            LibC.lchown(path, uid, gid)
+          else
+            LibC.chown(path, uid, gid)
+          end
+    raise Errno.new("Error changing owner of '#{path}'") if ret == -1
+  end
+
+  def self.chmod(path, mode : Int)
+    if LibC.chmod(path, mode) == -1
+      raise Errno.new("Error changing permissions of '#{path}'")
+    end
+  end
+
+  def self.delete(path)
+    err = LibC.unlink(path.check_no_null_byte)
+    if err == -1
+      raise Errno.new("Error deleting file '#{path}'")
+    end
+  end
+
+  def self.real_path(path)
+    real_path_ptr = LibC.realpath(path, nil)
+    raise Errno.new("Error resolving real path of #{path}") unless real_path_ptr
+    String.new(real_path_ptr).tap { LibC.free(real_path_ptr.as(Void*)) }
+  end
+
+  def self.link(old_path, new_path)
+    ret = LibC.link(old_path.check_no_null_byte, new_path.check_no_null_byte)
+    raise Errno.new("Error creating link from #{old_path} to #{new_path}") if ret != 0
+    ret
+  end
+
+  def self.symlink(old_path, new_path)
+    ret = LibC.symlink(old_path.check_no_null_byte, new_path.check_no_null_byte)
+    raise Errno.new("Error creating symlink from #{old_path} to #{new_path}") if ret != 0
+    ret
+  end
+
+  def self.symlink?(path)
+    if LibC.lstat(path.check_no_null_byte, out stat) != 0
+      if Errno.value == Errno::ENOENT
+        return false
+      else
+        raise Errno.new("stat")
+      end
+    end
+    (stat.st_mode & LibC::S_IFMT) == LibC::S_IFLNK
+  end
+
+  def self.rename(old_filename, new_filename)
+    code = LibC.rename(old_filename.check_no_null_byte, new_filename.check_no_null_byte)
+    if code != 0
+      raise Errno.new("Error renaming file '#{old_filename}' to '#{new_filename}'")
+    end
+  end
+
+  def self.utime(atime : ::Time, mtime : ::Time, filename : String) : Nil
+    timevals = uninitialized LibC::Timeval[2]
+    timevals[0] = to_timeval(atime)
+    timevals[1] = to_timeval(mtime)
+    ret = LibC.utimes(filename, timevals)
+    if ret != 0
+      raise Errno.new("Error setting time to file '#{filename}'")
+    end
+  end
+
+  private def self.to_timeval(time : ::Time)
+    t = uninitialized LibC::Timeval
+    t.tv_sec = typeof(t.tv_sec).new(time.to_local.epoch)
+    t.tv_usec = typeof(t.tv_usec).new(0)
+    t
+  end
+
+  private def system_truncate(size) : Nil
+    flush
+    code = LibC.ftruncate(fd, size)
+    if code != 0
+      raise Errno.new("Error truncating file '#{path}'")
+    end
+  end
+
+  private def system_flock_shared(blocking)
+    flock LibC::FlockOp::SH, blocking
+  end
+
+  private def system_flock_exclusive(blocking)
+    flock LibC::FlockOp::EX, blocking
+  end
+
+  private def system_flock_unlock
+    flock LibC::FlockOp::UN
+  end
+
+  private def flock(op : LibC::FlockOp, blocking : Bool = true)
+    op |= LibC::FlockOp::NB unless blocking
+
+    if LibC.flock(@fd, op) != 0
+      raise Errno.new("flock")
+    end
+
+    nil
+  end
+end

src/crystal/system/unix/file_descriptor.cr

@@ -0,0 +1,141 @@
+require "c/fcntl"
+
+# :nodoc:
+module Crystal::System::FileDescriptor
+  include IO::Syscall
+
+  @fd : Int32
+
+  @read_event : Event::Event?
+  @write_event : Event::Event?
+
+  private def unbuffered_read(slice : Bytes)
+    read_syscall_helper(slice, "Error reading file") do
+      # `to_i32` is acceptable because `Slice#size` is a Int32
+      LibC.read(@fd, slice, slice.size).to_i32
+    end
+  end
+
+  private def unbuffered_write(slice : Bytes)
+    write_syscall_helper(slice, "Error writing file") do |slice|
+      LibC.write(@fd, slice, slice.size).tap do |return_code|
+        if return_code == -1 && Errno.value == Errno::EBADF
+          raise IO::Error.new "File not open for writing"
+        end
+      end
+    end
+  end
+
+  private def system_blocking?
+    fcntl(LibC::F_GETFL) & LibC::O_NONBLOCK == 0
+  end
+
+  private def system_blocking=(value)
+    current_flags = fcntl(LibC::F_GETFL)
+    new_flags = current_flags
+    if value
+      new_flags &= ~LibC::O_NONBLOCK
+    else
+      new_flags |= LibC::O_NONBLOCK
+    end
+    fcntl(LibC::F_SETFL, new_flags) unless new_flags == current_flags
+  end
+
+  private def system_close_on_exec?
+    flags = fcntl(LibC::F_GETFD)
+    (flags & LibC::FD_CLOEXEC) == LibC::FD_CLOEXEC
+  end
+
+  private def system_close_on_exec=(arg : Bool)
+    fcntl(LibC::F_SETFD, arg ? LibC::FD_CLOEXEC : 0)
+    arg
+  end
+
+  def self.fcntl(fd, cmd, arg = 0)
+    r = LibC.fcntl(fd, cmd, arg)
+    raise Errno.new("fcntl() failed") if r == -1
+    r
+  end
+
+  private def system_stat
+    if LibC.fstat(@fd, out stat) != 0
+      raise Errno.new("Unable to get stat")
+    end
+    ::File::Stat.new(stat)
+  end
+
+  private def system_seek(offset, whence : IO::Seek) : Nil
+    seek_value = LibC.lseek(@fd, offset, whence)
+
+    if seek_value == -1
+      raise Errno.new "Unable to seek"
+    end
+  end
+
+  private def system_pos
+    pos = LibC.lseek(@fd, 0, IO::Seek::Current)
+    raise Errno.new "Unable to tell" if pos == -1
+    pos
+  end
+
+  private def system_tty?
+    LibC.isatty(fd) == 1
+  end
+
+  private def system_reopen(other : IO::FileDescriptor)
+    {% if LibC.methods.includes? "dup3".id %}
+      # dup doesn't copy the CLOEXEC flag, so copy it manually using dup3
+      flags = other.close_on_exec? ? LibC::O_CLOEXEC : 0
+      if LibC.dup3(other.fd, self.fd, flags) == -1
+        raise Errno.new("Could not reopen file descriptor")
+      end
+    {% else %}
+      # dup doesn't copy the CLOEXEC flag, copy it manually to the new
+      if LibC.dup2(other.fd, self.fd) == -1
+        raise Errno.new("Could not reopen file descriptor")
+      end
+
+      if other.close_on_exec?
+        self.close_on_exec = true
+      end
+    {% end %}
+
+    # We are now pointing to a new file descriptor, we need to re-register
+    # events with libevent and enqueue readers and writers again.
+    @read_event.try &.free
+    @read_event = nil
+
+    @write_event.try &.free
+    @write_event = nil
+
+    reschedule_waiting
+  end
+
+  private def add_read_event(timeout = @read_timeout) : Nil
+    event = @read_event ||= Scheduler.create_fd_read_event(self)
+    event.add timeout
+  end
+
+  private def add_write_event(timeout = @write_timeout) : Nil
+    event = @write_event ||= Scheduler.create_fd_write_event(self)
+    event.add timeout
+  end
+
+  private def system_close
+    if LibC.close(@fd) != 0
+      case Errno.value
+      when Errno::EINTR, Errno::EINPROGRESS
+        # ignore
+      else
+        raise Errno.new("Error closing file")
+      end
+    end
+  ensure
+    @read_event.try &.free
+    @read_event = nil
+    @write_event.try &.free
+    @write_event = nil
+
+    reschedule_waiting
+  end
+end

src/crystal/system/unix/getrandom.cr

@@ -6,15 +6,15 @@ require "c/sys/syscall"
 module Crystal::System::Random
   @@initialized = false
   @@getrandom_available = false
-  @@urandom : File?
+  @@urandom : ::File?
 
   private def self.init
     @@initialized = true
 
     if sys_getrandom(Bytes.new(16)) >= 0
       @@getrandom_available = true
     else
-      urandom = File.open("/dev/urandom", "r")
+      urandom = ::File.open("/dev/urandom", "r")
       return unless urandom.stat.chardev?
 
       urandom.close_on_exec = true