io-extra 1.3.0 → 1.5.0

data/examples/example_io_extra.rb

@@ -0,0 +1,53 @@
+##############################################################################
+# example_io_extra.rb
+#
+# This is a small example program for the io-extra library. Modify as you see
+# fit. You can run this via the 'rake example' task.
+##############################################################################
+require_relative "../lib/io-extra"
+puts "VERSION: #{IO::EXTRA_VERSION}"
+
+begin
+  fh = File.open("foo.txt","w+")
+
+  puts "DIRECTIO"
+  sleep 2
+
+  p fh.directio?
+  fh.directio = IO::DIRECTIO_ON
+  p fh.directio?
+
+  puts "FDWALK"
+  sleep 2
+
+  IO.fdwalk(0){ |handle|
+     p handle
+     p handle.fileno
+     puts
+  }
+
+=begin
+STDIN.close
+
+# Should print "Hello" 2 times
+IO.fdwalk(0){ |fd|
+   puts "Hello #{fd}"
+}
+
+
+IO.closefrom(0)
+
+puts "Done" # Shouldn't see this
+=end
+
+  puts "IO.writev"
+  sleep 2
+
+  a = (1..1000).map(&:to_s)
+  IO.writev(fh, a)
+  fh.rewind
+  p fh.read
+ensure
+  fh.close
+  File.delete("foo.txt") if File.exist?("foo.txt")
+end

data/examples/example_pread.rb

@@ -0,0 +1,24 @@
+########################################################################
+# example_pread.rb
+#
+# Example program demonstrating the use of IO.pread.
+########################################################################
+require_relative '../lib/io-extra'
+require 'tmpdir'
+
+# Create a temporary file with a little data in it.
+file = File.join(Dir.tmpdir, 'pread_test.txt')
+File.open(file, 'w'){ |fh| 100.times{ |n| fh.puts "Hello: #{n}" } }
+
+# Read from the file using pread.
+begin
+  fh = File.open(file)
+
+  puts "Handle position before read: #{fh.pos}"
+  puts IO.pread(fh, 18, 0)
+
+  puts "Handle position after read: #{fh.pos}"
+  puts IO.pread(fh, 18, 0)
+ensure
+  fh.close
+end

data/examples/writev_benchmark.rb

@@ -0,0 +1,19 @@
+require 'benchmark'
+require 'io-extra'
+
+a = (0..1023).to_a.map(&:to_s)
+
+file1 = 'write_test.txt'
+file2 = 'writev_test.txt'
+
+fh = File.open(file2, 'w')
+
+Benchmark.bm(25) do |x|
+  x.report('write'){ 100000.times{ File.write(file1, a.join) } }
+  x.report('writev'){ 100000.times{ IO.writev(fh.fileno, a) } }
+end
+
+fh.close
+
+File.delete(file1)
+File.delete(file2)

data/ext/extconf.rb

@@ -10,8 +10,6 @@ have_header('sys/uio.h')
 have_func('closefrom')
 have_func('fdwalk')
 have_func('directio')
-have_func('pread')
-have_func('pwrite')
 have_func('writev')
 have_func('ttyname')
 

data/ext/extra.bundle.dSYM/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.extra.bundle</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

data/ext/extra.bundle.dSYM/Contents/Resources/Relocations/aarch64/extra.bundle.yml

@@ -0,0 +1,5 @@
+---
+triple:          'arm64-apple-darwin'
+binary-path:     extra.bundle
+relocations:     []
+...

data/ext/io/extra.c

@@ -87,9 +87,18 @@ static int open_max(void){
  */
 static VALUE io_closefrom(VALUE klass, VALUE v_low_fd){
   int i, lowfd;
-  int maxfd = open_max();
+  int maxfd;
+
   lowfd = NUM2INT(v_low_fd);
 
+  if(lowfd < 0)
+    rb_raise(rb_eArgError, "lowfd must be non-negative");
+
+  maxfd = open_max();
+
+  if(maxfd < 0)
+    rb_raise(rb_eRuntimeError, "failed to determine maximum file descriptor");
+
   for(i = lowfd; i < maxfd; i++) {
     if(!RB_RESERVED_FD_P(i))
       close(i);
@@ -99,54 +108,7 @@ static VALUE io_closefrom(VALUE klass, VALUE v_low_fd){
 }
 
 #ifndef HAVE_FDWALK
-static int fdwalk(int (*func)(void *data, int fd), void *data){
-   int rv = 0;
-   int fd;
-
-#ifdef PROC_SELF_FD_DIR
-   DIR *dir = opendir(PROC_SELF_FD_DIR);
-
-   if(dir){ /* procfs may not be mounted... */
-      struct dirent *ent;
-      int saved_errno;
-      int dir_fd = dirfd(dir);
-
-      while((ent = readdir(dir))){
-         char *err = NULL;
-
-         if(ent->d_name[0] == '.')
-            continue;
-
-         errno = 0;
-         fd = (int)strtol(ent->d_name, &err, 10);
-
-         if (errno || ! err || *err || fd == dir_fd)
-            continue;
-
-         if ((rv = func(data, fd)))
-            break;
-      }
-      saved_errno = errno;
-      closedir(dir);
-      errno = saved_errno;
-   } else
-#endif /* PROC_SELF_FD_DIR */
-   {
-      int maxfd = open_max();
-
-      for(fd = 0; fd < maxfd; fd++){
-         /* use fcntl to detect whether fd is a valid file descriptor */
-         errno = 0;
-         if(fcntl(fd, F_GETFD) < 0)
-            continue;
-
-         errno = 0;
-         if ((rv = func(data, fd)))
-            break;
-      }
-   }
-   return rv;
-}
+/* Define HAVE_FDWALK so the io_fdwalk implementation below is compiled */
 #define HAVE_FDWALK
 #endif
 
@@ -169,6 +131,74 @@ static int close_func(void* lowfd, int fd){
   return 0;
 }
 
+/* Structure to pass data to fdwalk_body and fdwalk_ensure */
+struct fdwalk_data {
+  int lowfd;
+#ifdef PROC_SELF_FD_DIR
+  DIR *dir;
+#endif
+};
+
+/* Cleanup function for rb_ensure */
+static VALUE fdwalk_ensure(VALUE arg){
+  struct fdwalk_data *data = (struct fdwalk_data *)arg;
+#ifdef PROC_SELF_FD_DIR
+  if(data->dir){
+    closedir(data->dir);
+    data->dir = NULL;
+  }
+#endif
+  (void)data; /* Suppress unused warning when PROC_SELF_FD_DIR not defined */
+  return Qnil;
+}
+
+/* Main fdwalk iteration body */
+static VALUE fdwalk_body(VALUE arg){
+  struct fdwalk_data *data = (struct fdwalk_data *)arg;
+  int fd;
+
+#ifdef PROC_SELF_FD_DIR
+  if(data->dir){
+    struct dirent *ent;
+    int dir_fd = dirfd(data->dir);
+
+    while((ent = readdir(data->dir))){
+      char *err = NULL;
+
+      if(ent->d_name[0] == '.')
+        continue;
+
+      errno = 0;
+      fd = (int)strtol(ent->d_name, &err, 10);
+
+      if (errno || !err || *err || fd == dir_fd)
+        continue;
+
+      /* Validate fd is still open before calling callback (reduces race window) */
+      if(fcntl(fd, F_GETFD) < 0)
+        continue;
+
+      close_func(&data->lowfd, fd);
+    }
+  } else
+#endif /* PROC_SELF_FD_DIR */
+  {
+    int maxfd = open_max();
+
+    for(fd = 0; fd < maxfd; fd++){
+      /* use fcntl to detect whether fd is a valid file descriptor */
+      errno = 0;
+      if(fcntl(fd, F_GETFD) < 0)
+        continue;
+
+      errno = 0;
+      close_func(&data->lowfd, fd);
+    }
+  }
+
+  return Qnil;
+}
+
 /*
  * call-seq:
  *    IO.fdwalk(lowfd){ |fh| ... }
@@ -179,12 +209,19 @@ static int close_func(void* lowfd, int fd){
  */
 static VALUE io_fdwalk(int argc, VALUE* argv, VALUE klass){
   VALUE v_low_fd, v_block;
-  int lowfd;
+  struct fdwalk_data data;
 
   rb_scan_args(argc, argv, "1&", &v_low_fd, &v_block);
-  lowfd = NUM2INT(v_low_fd);
+  data.lowfd = NUM2INT(v_low_fd);
 
-  fdwalk(close_func, &lowfd);
+  if(data.lowfd < 0)
+    rb_raise(rb_eArgError, "lowfd must be non-negative");
+
+#ifdef PROC_SELF_FD_DIR
+  data.dir = opendir(PROC_SELF_FD_DIR);
+#endif
+
+  rb_ensure(fdwalk_body, (VALUE)&data, fdwalk_ensure, (VALUE)&data);
 
   return klass;
 }
@@ -284,140 +321,51 @@ static VALUE io_set_directio(VALUE self, VALUE v_advice){
 }
 #endif
 
-#ifdef HAVE_PREAD
-struct pread_args {
-  int fd;
-  void *buf;
-  size_t nbyte;
-  off_t offset;
+/* Structure to track iovec allocation */
+struct iovec_buffer {
+   struct iovec *iov;
+   int iovcnt;
+   ssize_t expected;
 };
 
-static VALUE nogvl_pread(void *ptr)
-{
-  struct pread_args *args = ptr;
-  return (VALUE)pread(args->fd, args->buf, args->nbyte, args->offset);
-}
-
-/*
- * IO.pread(fd, length, offset)
- *
- * This is similar to the IO.read method, except that it reads from a given
- * position in the file without changing the file pointer. And unlike IO.read,
- * the +fd+, +length+ and +offset+ arguments are all mandatory.
- */
-static VALUE s_io_pread(VALUE klass, VALUE fd, VALUE nbyte, VALUE offset){
-  struct pread_args args;
-  VALUE str;
-  ssize_t nread;
-
-  args.fd = NUM2INT(fd);
-  args.nbyte = NUM2ULONG(nbyte);
-  args.offset = NUM2OFFT(offset);
-  str = rb_str_new(NULL, args.nbyte);
-  args.buf = RSTRING_PTR(str);
-
-  nread = (ssize_t)rb_thread_call_without_gvl((void*)nogvl_pread, &args, RUBY_UBF_IO, 0);
-
-  if(nread == -1)
-    rb_sys_fail("pread");
-
-  if((size_t)nread != args.nbyte)
-    rb_str_set_len(str, nread);
+/* Convert Ruby array to iovec using heap allocation */
+static void ary2iovec(struct iovec_buffer *buf, VALUE ary) {
+   VALUE *cur;
+   struct iovec *tmp;
+   long n;
 
-  return str;
-}
+   if (TYPE(ary) != T_ARRAY)
+      rb_raise(rb_eArgError, "must be an array of strings");
 
-/*
- * IO.pread_ptr(fd, length, offset)
- *
- * This is identical to IO.pread, except that it returns the pointer address
- * of the string, instead of the actual buffer.
- *--
- * This was added because, in some cases, the IO.pread buffer might return
- * an empty string. In such situations we are unable to get the actual pointer
- * address with pure Ruby.
- */
-static VALUE s_io_pread_ptr(VALUE klass, VALUE v_fd, VALUE v_nbyte, VALUE v_offset){
-  int fd = NUM2INT(v_fd);
-  size_t nbyte = NUM2ULONG(v_nbyte);
-  off_t offset = NUM2OFFT(v_offset);
-  uintptr_t* vector = malloc(nbyte + 1);
-
-  if(pread(fd, vector, nbyte, offset) == -1){
-    free(vector);
-    rb_sys_fail("pread");
-  }
+   cur = RARRAY_PTR(ary);
+   n = RARRAY_LEN(ary);
 
-  return ULL2NUM(vector[0]);
-}
-#endif
+   if (n > IOV_MAX)
+      rb_raise(rb_eArgError, "array is larger than IOV_MAX");
 
-#ifdef HAVE_PWRITE
-struct pwrite_args {
-  int fd;
-  const void *buf;
-  size_t nbyte;
-  off_t offset;
-};
+   buf->iov = tmp = ALLOC_N(struct iovec, n);
+   buf->expected = 0;
+   buf->iovcnt = (int)n;
 
-static VALUE nogvl_pwrite(void *ptr)
-{
-  struct pwrite_args *args = ptr;
-  return (VALUE)pwrite(args->fd, args->buf, args->nbyte, args->offset);
+   for (; --n >= 0; tmp++, cur++) {
+      if (TYPE(*cur) != T_STRING) {
+         xfree(buf->iov);
+         buf->iov = NULL;
+         rb_raise(rb_eArgError, "must be an array of strings");
+      }
+      tmp->iov_base = RSTRING_PTR(*cur);
+      tmp->iov_len = RSTRING_LEN(*cur);
+      buf->expected += tmp->iov_len;
+   }
 }
 
-/*
- * IO.pwrite(fd, buf, offset)
- *
- * This method writes the +buf+, starting at +offset+, to the given +fd+,
- * which must be opened with write permissions.
- *
- * This is similar to a seek & write in standard Ruby but the difference,
- * beyond being a singleton method, is that the file pointer is never moved.
- *
- * Returns the number of bytes written.
- */
-static VALUE s_io_pwrite(VALUE klass, VALUE fd, VALUE buf, VALUE offset){
-  ssize_t result;
-  struct pwrite_args args;
-
-  args.fd = NUM2INT(fd);
-  args.buf = RSTRING_PTR(buf);
-  args.nbyte = RSTRING_LEN(buf);
-  args.offset = NUM2OFFT(offset);
-
-  result = (ssize_t)rb_thread_call_without_gvl((void*)nogvl_pwrite, &args, RUBY_UBF_IO, 0);
-
-  if(result == -1)
-    rb_sys_fail("pwrite");
-
-  return ULL2NUM(result);
+/* Free iovec buffer */
+static void free_iovec_buffer(struct iovec_buffer *buf) {
+   if (buf->iov) {
+      xfree(buf->iov);
+      buf->iov = NULL;
+   }
 }
-#endif
-
-/* this can't be a function since we use alloca() */
-#define ARY2IOVEC(iov,iovcnt,expect,ary) \
-   do { \
-      VALUE *cur; \
-      struct iovec *tmp; \
-      long n; \
-      if (TYPE(ary) != T_ARRAY) \
-         rb_raise(rb_eArgError, "must be an array of strings"); \
-      cur = RARRAY_PTR(ary); \
-      n = RARRAY_LEN(ary); \
-      if (n > IOV_MAX) \
-         rb_raise(rb_eArgError, "array is larger than IOV_MAX"); \
-      iov = tmp = alloca(sizeof(struct iovec) * n); \
-      expect = 0; \
-      iovcnt = (int)n; \
-      for (; --n >= 0; tmp++, cur++) { \
-         if (TYPE(*cur) != T_STRING) \
-            rb_raise(rb_eArgError, "must be an array of strings"); \
-         tmp->iov_base = RSTRING_PTR(*cur); \
-         tmp->iov_len = RSTRING_LEN(*cur); \
-         expect += tmp->iov_len; \
-      } \
-   } while (0)
 
 #if defined(HAVE_WRITEV)
 struct writev_args {
@@ -447,9 +395,17 @@ static VALUE s_io_writev(VALUE klass, VALUE fd, VALUE ary) {
   ssize_t result = 0;
   ssize_t left;
   struct writev_args args;
+  struct iovec_buffer iov_buf;
+
+  // Allow a fileno or filehandle
+  if(rb_respond_to(fd, rb_intern("fileno")))
+    fd = rb_funcall(fd, rb_intern("fileno"), 0, 0);
 
   args.fd = NUM2INT(fd);
-  ARY2IOVEC(args.iov, args.iovcnt, left, ary);
+  ary2iovec(&iov_buf, ary);
+  args.iov = iov_buf.iov;
+  args.iovcnt = iov_buf.iovcnt;
+  left = iov_buf.expected;
 
   for(;;) {
     ssize_t w = (ssize_t)rb_thread_call_without_gvl(
@@ -466,6 +422,7 @@ static VALUE s_io_writev(VALUE klass, VALUE fd, VALUE ary) {
            * we'll let the next write (or close) fail instead */
           break;
         }
+        free_iovec_buffer(&iov_buf);
         rb_sys_fail("writev");
       }
     }
@@ -483,13 +440,25 @@ static VALUE s_io_writev(VALUE klass, VALUE fd, VALUE ary) {
       left -= w;
 
       // Skip over iovecs we've already written completely
-      for(i = 0; i < args.iovcnt; i++, new_iov++){
+      for(i = 0; i < args.iovcnt; i++){
         if (w == 0)
           break;
 
+        // Bounds check before pointer arithmetic
+        if(new_iov == NULL){
+          free_iovec_buffer(&iov_buf);
+          rb_raise(rb_eRuntimeError, "writev: iovec bounds check failed");
+        }
+
         // Partially written iov, modify and retry with current iovec in front
         if(new_iov->iov_len > (size_t)w){
-          VALUE base = (VALUE)new_iov->iov_base;
+          char* base = (char*)new_iov->iov_base;
+
+          // Validate base pointer before arithmetic
+          if(base == NULL){
+            free_iovec_buffer(&iov_buf);
+            rb_raise(rb_eRuntimeError, "writev: null iov_base");
+          }
 
           new_iov->iov_len -= w;
           new_iov->iov_base = (void *)(base + w);
@@ -497,6 +466,13 @@ static VALUE s_io_writev(VALUE klass, VALUE fd, VALUE ary) {
         }
 
         w -= new_iov->iov_len;
+        new_iov++;
+      }
+
+      // Validate we haven't exceeded bounds before modifying args
+      if(i > args.iovcnt){
+        free_iovec_buffer(&iov_buf);
+        rb_raise(rb_eRuntimeError, "writev: exceeded iovec array bounds");
       }
 
       // Retry without the already-written iovecs
@@ -505,6 +481,7 @@ static VALUE s_io_writev(VALUE klass, VALUE fd, VALUE ary) {
     }
   }
 
+  free_iovec_buffer(&iov_buf);
   return LONG2NUM(result);
 }
 #endif
@@ -525,8 +502,15 @@ static VALUE io_get_ttyname(VALUE self){
 
   int fd = NUM2INT(rb_funcall(self, rb_intern("fileno"), 0, 0));
 
-  if(isatty(fd))
-    v_return = rb_str_new2(ttyname(fd));
+  if(fd < 0)
+    rb_raise(rb_eArgError, "invalid file descriptor");
+
+  errno = 0;
+  if(isatty(fd)){
+    char *name = ttyname(fd);
+    if(name != NULL)
+      v_return = rb_str_new2(name);
+  }
 
   return v_return;
 }
@@ -535,7 +519,7 @@ static VALUE io_get_ttyname(VALUE self){
 /* Adds the IO.closefrom, IO.fdwalk class methods, as well as the IO#directio
  * and IO#directio? instance methods (if supported on your platform).
  */
-void Init_extra(){
+void Init_extra(void){
   rb_define_singleton_method(rb_cIO, "closefrom", io_closefrom, 1);
 
 #ifdef HAVE_FDWALK
@@ -553,22 +537,8 @@ void Init_extra(){
   rb_define_const(rb_cIO, "DIRECTIO_ON", UINT2NUM(DIRECTIO_ON));
 #endif
 
-#ifdef O_DIRECT
-  /* 040000: direct disk access (in Linux) */
-  rb_define_const(rb_cIO, "DIRECT", UINT2NUM(O_DIRECT));
-#endif
-
   rb_define_const(rb_cIO, "IOV_MAX", LONG2NUM(IOV_MAX));
 
-#ifdef HAVE_PREAD
-  rb_define_singleton_method(rb_cIO, "pread", s_io_pread, 3);
-  rb_define_singleton_method(rb_cIO, "pread_ptr", s_io_pread_ptr, 3);
-#endif
-
-#ifdef HAVE_PWRITE
-  rb_define_singleton_method(rb_cIO, "pwrite", s_io_pwrite, 3);
-#endif
-
 #ifdef HAVE_WRITEV
   rb_define_singleton_method(rb_cIO, "writev", s_io_writev, 2);
 #endif
@@ -576,7 +546,4 @@ void Init_extra(){
 #ifdef HAVE_TTYNAME
   rb_define_method(rb_cIO, "ttyname", io_get_ttyname, 0);
 #endif
-
-  /* 1.3.0: The version of this library. */
-  rb_define_const(rb_cIO, "EXTRA_VERSION", rb_str_freeze(rb_str_new2("1.3.0")));
 }

data/io-extra.gemspec

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rbconfig'
+
+Gem::Specification.new do |spec|
+  if File::ALT_SEPARATOR
+    STDERR.puts 'Not supported on this platform. Exiting.'
+    exit(-1)
+  end
+   
+  spec.name       = 'io-extra'
+  spec.version    = '1.5.0'
+  spec.author     = 'Daniel J. Berger'
+  spec.license    = 'Apache-2.0'
+  spec.email      = 'djberg96@gmail.com'
+  spec.homepage   = 'https://github.com/djberg96/io-extra'
+  spec.summary    = 'Adds extra methods to the IO class'
+  spec.test_files = Dir['spec/*_spec.rb']
+  spec.extensions = ['ext/extconf.rb']
+  spec.cert_chain = ['certs/djberg96_pub.pem']
+  spec.files      = Dir['**/*'].reject{ |f| f.include?('git') }
+
+  spec.extra_rdoc_files = [
+    'CHANGES.md',
+    'README.md',
+    'MANIFEST.md',
+    'ext/io/extra.c'
+  ]
+
+  spec.add_development_dependency('rake')
+  spec.add_development_dependency('rspec', '~> 3.9')
+  spec.add_development_dependency('rubocop')
+  spec.add_development_dependency('rubocop-rspec')
+
+  spec.metadata = {
+    'homepage_uri'          => 'https://github.com/djberg96/io-extra',
+    'bug_tracker_uri'       => 'https://github.com/djberg96/io-extra/issues',
+    'changelog_uri'         => 'https://github.com/djberg96/io-extra/blob/main/CHANGES.md',
+    'documentation_uri'     => 'https://github.com/djberg96/io-extra/wiki',
+    'source_code_uri'       => 'https://github.com/djberg96/io-extra',
+    'wiki_uri'              => 'https://github.com/djberg96/io-extra/wiki',
+    'rubygems_mfa_required' => 'true',
+    'github_repo'           => 'https://github.com/djberg96/io-extra',
+    'funding_uri'           => 'https://github.com/sponsors/djberg96',
+  }
+ 
+  spec.description = <<-EOF
+    Adds the IO.closefrom, IO.fdwalk, IO.pread, IO.pwrite, and IO.writev
+    singleton methods as well as the IO#directio, IO#directio? and IO#ttyname
+    instance methods (for those platforms that support them).
+  EOF
+end

data/lib/io-extra.rb

@@ -1 +1,19 @@
 require 'io/extra'
+
+# Reopen the core IO class to define pread and pwrite singleton methods
+# for backwards compatibility.
+class IO
+  EXTRA_VERSION = '1.5.0'.freeze
+
+  # Singleton version of the IO#pwrite method.
+  #
+  def self.pwrite(fd, string, offset)
+    fd.pwrite(string, offset)
+  end
+
+  # Singleton version of the IO#pread method.
+  #
+  def self.pread(fd, maxlen, offset)
+    fd.pread(maxlen, offset)
+  end
+end