ioposrw 0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4a73f9689f954e9a73d234ab71568e67f1ec97b8
+  data.tar.gz: 85a997f0de8af73b8ed2d7d686da6e547987e240
+SHA512:
+  metadata.gz: 59e351ee0a4b470aabec3e2c3bc426e6db067839ed2ddb7e1a06df8ffff3b03a4e94965754b744dcafab0d7ef38541e8e9a52244808cfeb23547d3bb505abf65
+  data.tar.gz: 13a4080d5465fd244647949bd7618f5238ee6bc80ead9e0d1ba804dd3d2a36139cea707d3a84868a7919363d31eef4cf81fbb68d21dc14f49e1ddee46586f3d4

data/HISTORY.ja.md

@@ -0,0 +1,21 @@
+# ioposrw 変更履歴
+
+## 0.4 (平成29年12月26日 火曜日)
+
+  * ``IO#pread``/``IO#pwrite`` を ``IO#readat``/``IO#writeat`` に変更
+
+    Ruby-2.5 で ``IO#pread``/``IO#pwrite`` が組み込まれましたが引数のとり方が異なるため、 ``IO#readat``/``IO#writeat`` として利用できるように変更しました。
+
+  * ファイル終端位置の指定を行えるようになった
+
+    ``readat``/``writeat`` の ``offset`` 引数に nil を与えることで、ファイルの終端位置を示すことが出来るように機能を変更しました。
+
+  * ``IOPositioningReadWrite`` モジュールを追加し、``IO`` クラスへ include するように変更
+
+    実装の実体を ``IOPositioningReadWrite`` モジュールに行い、IO クラスへ include するようにしました。
+
+  * "ioposrw/stringio" ライブラリの追加
+
+    ``IO.ioposrw_enable_stringio_extend`` メソッドは廃止する予定です。
+
+    代わりに ``require "ioposrw/stringio"`` を使って下さい。

data/QUICKREF.md

@@ -0,0 +1,13 @@
+# QUICK REFERENCE FOR IOPOSRW
+
+## LIBRARIES
+
+*   ``require "ioposrw"`` - main library
+*   ``require "ioposrw/stringio"`` - need when use ``StringIO#pread/pwrite``
+
+## METHODS
+
+*   ``IO#pread`` - Similar functionality to the pread(2) system call. Implemented as ``IOPositioningReadWrite::IO#pread``.
+*   ``IO#pwrite`` - Similar functionality to the pwrite(2) system call. Implemented as ``IOPositioningReadWrite::IO#pwrite``.
+*   ``StringIO#pread`` - StringIO version pread(2). Implemented as ``IOPositioningReadWrite::StringIO#pread``.
+*   ``StringIO#pwrite`` - StringIO version pwrite(2). Implemented as ``IOPositioningReadWrite::StringIO#pwrite``.

data/README.md

@@ -0,0 +1,68 @@
+# ioposrw
+
+位置指定IO読み書きメソッド追加拡張ライブラリ
+
+  * Product Name: ioposrw
+  * Version: 0.4
+  * Project Page: https://github.com/dearblue/ruby-ioposrw
+  * License: 2-clause BSD License (二条項 BSD ライセンス)
+  * Author: dearblue <dearblue@users.noreply.github.com>
+
+
+## これは何?
+
+ioposrw は IO インスタンスに位置指定読み書き機能を追加する拡張ライブラリです。
+
+この機能は ``IO#readat`` / ``IO#writeat`` によって提供されます。
+
+これらのメソッドは、元々ある ``IO#read`` / ``IO#write`` によって更新されるファイル位置ポインタに影響されません。
+
+マルチスレッド動作中に同じファイルインスタンスの別の領域を読み書きしても、想定通りの動作が期待できます。
+
+追加の機能として、``StringIO#readat`` / ``StringIO#writeat`` も実装してあります (実際に利用する場合は、``require "ioposrw/stringio"`` を行って下さい)。
+
+
+## どう使うのか?
+
+ライブラリの読み込み:
+
+```ruby:ruby
+require "ioposrw"
+```
+
+ファイルの読み込み:
+
+```ruby:ruby
+File.open("sample.txt") do |file|
+  buf = ""
+  file.readat(200, 100, buf) # sample.txt の先頭 200 バイト位置から
+                             # 100 バイトを buf に読み込む
+end
+```
+
+ファイルの書き込み:
+
+```ruby:ruby
+File.open("sample.txt", "w") do |file|
+  buf = "ごにょごにょ"
+  file.writeat(200, buf) # sample.txt の先頭 200 バイト位置に buf を書き込む
+end
+```
+
+## 注意事項について
+
+- Windows 上では、``IO#readat / IO#writeat`` を呼び出すとファイルポインタ (IO#pos) が指定位置の次に変更されます (このことは丁度 ``IO#pos=`` と ``IO#read`` を呼び出した後の状態と考えてください)。
+
+    これは Windows 自身に伴う仕様となります。
+
+
+## 内部の実装方法
+
+POSIX システムコールの ``pread(2)`` / ``pwrite(2)`` を中心に実装しました。
+
+Windows 環境では ``OVERRAPPED`` 構造体を与えた ``ReadFile`` / ``WriteFile`` をそれぞれ用いて ``pread`` / ``pwrite`` 関数を構築し、あとは同じです。
+
+
+## ライセンスについて
+
+二条項BSDライセンスの下で取り扱うことができます。

data/Rakefile

@@ -0,0 +1,212 @@
+
+require "pathname"
+require "rake/clean"
+
+docnames = "{README,LICENSE,CHANGELOG,Changelog,HISTORY}"
+doctypes = "{,.txt,.rd,.rdoc,.md,.markdown}"
+cexttypes = "{c,C,cc,cxx,cpp,h,H,hh}"
+
+DOC = FileList["#{docnames}{,.ja}#{doctypes}"] +
+      FileList["{contrib,ext}/**/#{docnames}{,.ja}#{doctypes}"] +
+      FileList["ext/**/*.#{cexttypes}"]
+EXT = FileList["ext/**/*"]
+BIN = FileList["bin/*"]
+LIB = FileList["lib/**/*.rb"]
+SPEC = FileList["spec/**/*"]
+TEST = FileList["test/**/*"]
+EXAMPLE = FileList["examples/**/*"]
+GEMSTUB_SRC = "gemstub.rb"
+RAKEFILE = [File.basename(__FILE__), GEMSTUB_SRC]
+EXTRA = []
+EXTCONF = FileList["ext/**/extconf.rb"]
+EXTCONF.reject! { |n| !File.file?(n) }
+EXTMAP = {}
+
+load GEMSTUB_SRC
+
+EXTMAP.dup.each_pair do |dir, name|
+  EXTMAP[Pathname.new(dir).cleanpath.to_s] = Pathname.new(name).cleanpath.to_s
+end
+
+GEMSTUB.extensions += EXTCONF
+GEMSTUB.executables += FileList["bin/*"].map { |n| File.basename n }
+GEMSTUB.executables.sort!
+
+PACKAGENAME = "#{GEMSTUB.name}-#{GEMSTUB.version}"
+GEMFILE = "#{PACKAGENAME}.gem"
+GEMSPEC = "#{PACKAGENAME}.gemspec"
+
+GEMSTUB.files += DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + RAKEFILE + EXTRA
+GEMSTUB.files.sort!
+if GEMSTUB.rdoc_options.nil? || GEMSTUB.rdoc_options.empty?
+  readme = %W(.md .markdown .rd .rdoc .txt #{""}).map { |ext| "README#{ext}" }.find { |m| DOC.find { |n| n == m } }
+  GEMSTUB.rdoc_options = %w(--charset UTF-8) + (readme ? %W(-m #{readme}) : [])
+end
+GEMSTUB.extra_rdoc_files += DOC + LIB + EXT.reject { |n| n.include?("/externals/") || !%w(.h .hh .c .cc .cpp .cxx).include?(File.extname(n)) }
+GEMSTUB.extra_rdoc_files.sort!
+
+GEMSTUB_TRYOUT = GEMSTUB.dup
+GEMSTUB_TRYOUT.version = "#{GEMSTUB.version}#{Time.now.strftime(".TRYOUT.%Y%m%d.%H%M%S")}"
+PACKAGENAME_TRYOUT = "#{GEMSTUB.name}-#{GEMSTUB_TRYOUT.version}"
+GEMFILE_TRYOUT = "#{PACKAGENAME_TRYOUT}.gem"
+GEMSPEC_TRYOUT = "#{PACKAGENAME_TRYOUT}.gemspec"
+
+CLEAN << GEMSPEC << GEMSPEC_TRYOUT
+CLOBBER << GEMFILE
+
+task :default => :tryout do
+  $stderr.puts <<-EOS
+#{__FILE__}:#{__LINE__}:
+\ttype ``rake release'' to build release package.
+  EOS
+end
+
+desc "build tryout package"
+task :tryout
+
+desc "build release package"
+task :release => :all
+
+unless EXTCONF.empty?
+  RUBYSET ||= (ENV["RUBYSET"] || "").split(",")
+
+  if RUBYSET.nil? || RUBYSET.empty?
+    $stderr.puts <<-EOS
+#{__FILE__}:
+|
+| If you want binary gem package, launch rake with ``RUBYSET`` enviroment
+| variable for set ruby interpreters by comma separated.
+|
+|   e.g.) $ rake RUBYSET=ruby
+|     or) $ rake RUBYSET=ruby21,ruby22,ruby23
+|
+    EOS
+  else
+    platforms = RUBYSET.map { |ruby| `#{ruby} --disable-gems -e "puts RUBY_PLATFORM"`.chomp }
+    platforms1 = platforms.uniq
+    unless platforms1.size == 1 && !platforms1[0].empty?
+      abort <<-EOS
+#{__FILE__}:#{__LINE__}: different platforms:
+#{RUBYSET.zip(platforms).map { |ruby, platform| "%24s => %s" % [ruby, platform] }.join("\n")}
+ABORTED.
+      EOS
+    end
+    PLATFORM = platforms1[0]
+
+    RUBY_VERSIONS = RUBYSET.map do |ruby|
+      ver = `#{ruby} --disable-gems -e "puts RUBY_VERSION"`.slice(/\d+\.\d+/)
+      raise "failed ruby checking - ``#{ruby}''" unless $?.success?
+      [ver, ruby]
+    end
+
+    SOFILES_SET = RUBY_VERSIONS.map { |(ver, ruby)|
+      EXTCONF.map { |extconf|
+        extdir = Pathname.new(extconf).cleanpath.dirname.to_s
+        case
+        when soname = EXTMAP[extdir.sub(/^ext\//i, "")]
+          soname = soname.sub(/\.so$/i, "")
+        when extdir == "ext" || extdir == "."
+          soname = GEMSTUB.name
+        else
+          soname = File.basename(extdir)
+        end
+
+        [ruby, File.join("lib", "#{soname.sub(/(?<=\/)|^(?!.*\/)/, "#{ver}/")}.so"), extconf]
+      }
+    }.flatten(1)
+    SOFILES = SOFILES_SET.map { |(ruby, sopath, extconf)| sopath }
+
+    GEMSTUB_NATIVE = GEMSTUB.dup
+    GEMSTUB_NATIVE.files += SOFILES
+    GEMSTUB_NATIVE.platform = Gem::Platform.new(PLATFORM).to_s
+    GEMSTUB_NATIVE.extensions.clear
+    GEMFILE_NATIVE = "#{GEMSTUB_NATIVE.name}-#{GEMSTUB_NATIVE.version}-#{GEMSTUB_NATIVE.platform}.gem"
+    GEMSPEC_NATIVE = "#{GEMSTUB_NATIVE.name}-#{GEMSTUB_NATIVE.platform}.gemspec"
+
+    task :all => ["native-gem", GEMFILE]
+
+    desc "build binary gem package"
+    task "native-gem" => GEMFILE_NATIVE
+
+    desc "generate binary gemspec"
+    task "native-gemspec" => GEMSPEC_NATIVE
+
+    file GEMFILE_NATIVE => DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + SOFILES + RAKEFILE + [GEMSPEC_NATIVE] do
+      sh "gem build #{GEMSPEC_NATIVE}"
+    end
+
+    file GEMSPEC_NATIVE => RAKEFILE do
+      File.write(GEMSPEC_NATIVE, GEMSTUB_NATIVE.to_ruby, mode: "wb")
+    end
+
+    desc "build c-extension libraries"
+    task "sofiles" => SOFILES
+
+    SOFILES_SET.each do |(ruby, soname, extconf)|
+      sodir = File.dirname(soname)
+      makefile = File.join(sodir, "Makefile")
+
+      CLEAN << GEMSPEC_NATIVE << sodir
+      CLOBBER << GEMFILE_NATIVE
+
+      directory sodir
+
+      desc "generate Makefile for binary extension library"
+      file makefile => [sodir, extconf] do
+        rel_extconf = Pathname.new(extconf).relative_path_from(Pathname.new(sodir)).to_s
+        cd sodir do
+          sh *%W"#{ruby} #{rel_extconf} --ruby=#{ruby} #{ENV["EXTCONF"]}"
+        end
+      end
+
+      desc "build binary extension library"
+      file soname => [makefile] + EXT do
+        cd sodir do
+          sh "make"
+        end
+      end
+    end
+  end
+end
+
+
+task :all => GEMFILE
+task :tryout => GEMFILE_TRYOUT
+
+desc "generate local rdoc"
+task :rdoc => DOC + LIB do
+  sh *(%w(rdoc) + GEMSTUB.rdoc_options + DOC + LIB)
+end
+
+desc "launch rspec"
+task rspec: :all do
+  sh "rspec"
+end
+
+desc "build gem package"
+task gem: GEMFILE
+
+desc "generate gemspec"
+task gemspec: GEMSPEC
+
+desc "print package name"
+task "package-name" do
+  puts PACKAGENAME
+end
+
+file GEMFILE => DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + RAKEFILE + [GEMSPEC] do
+  sh "gem build #{GEMSPEC}"
+end
+
+file GEMFILE_TRYOUT => DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + RAKEFILE + [GEMSPEC_TRYOUT] do
+#file GEMFILE_TRYOUT do
+  sh "gem build #{GEMSPEC_TRYOUT}"
+end
+
+file GEMSPEC => RAKEFILE do
+  File.write(GEMSPEC, GEMSTUB.to_ruby, mode: "wb")
+end
+
+file GEMSPEC_TRYOUT => RAKEFILE do
+  File.write(GEMSPEC_TRYOUT, GEMSTUB_TRYOUT.to_ruby, mode: "wb")
+end

data/ext/extconf.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+#vim: set fileencoding:utf-8
+
+require "mkmf"
+
+create_makefile "ioposrw" or exit 1

data/ext/ioposrw.c

@@ -0,0 +1,582 @@
+/* encoding:utf-8 */
+
+/*
+ * ioposrw.c -
+ *
+ * - Author: dearblue <dearblue@users.sourceforge.jp>
+ * - License: 2-clause BSD License
+ * - Project Page: http://sourceforge.jp/projects/rutsubo/
+ */
+
+#include <ruby.h>
+#include <ruby/io.h>
+#include <ruby/intern.h>
+#include <ruby/thread.h>
+
+// rdoc 用に認識させるために使う
+#define RDOC(...)
+
+#define NOGVL_FUNC(FUNC) ((void *(*)(void *))(FUNC))
+
+#define FUNCALL(RECV, METHOD, ...)                                  \
+    ({                                                              \
+        VALUE _params[] = { __VA_ARGS__ };                          \
+        rb_funcall3((RECV), (METHOD),                               \
+                    sizeof(_params) / sizeof(_params[0]), _params); \
+    })                                                              \
+
+
+#ifndef RUBY_WIN32_H
+#   include <unistd.h>
+#   include <sys/types.h>
+#   include <sys/stat.h>
+#else
+
+#include <windows.h>
+#include <io.h>
+
+static ssize_t
+pread(int d, void *buf, size_t nbytes, off_t offset)
+{
+    HANDLE file = (HANDLE)_get_osfhandle(d);
+    OVERLAPPED ol;
+    memset(&ol, 0, sizeof(ol));
+    ol.Offset = offset;
+    ol.OffsetHigh = offset >> 32;
+    DWORD read;
+    DWORD status = ReadFile(file, buf, nbytes, &read, &ol);
+
+    if (status == 0) {
+        DWORD err = GetLastError();
+        if (err == ERROR_HANDLE_EOF) { return 0; }
+        errno = rb_w32_map_errno(err);
+        return -1;
+    }
+
+    return read;
+}
+
+static ssize_t
+pwrite(int d, const void *buf, size_t nbytes, off_t offset)
+{
+    HANDLE file = (HANDLE)_get_osfhandle(d);
+    OVERLAPPED ol;
+    memset(&ol, 0, sizeof(ol));
+    ol.Offset = offset;
+    ol.OffsetHigh = offset >> 32;
+    DWORD wrote;
+    DWORD status = WriteFile(file, buf, nbytes, &wrote, &ol);
+    if (status == 0) {
+        errno = rb_w32_map_errno(GetLastError());
+        return -1;
+    }
+
+    return wrote;
+}
+
+#endif /* ! RUBY_WIN32_H */
+
+
+/* ---- */
+
+static VALUE mIOPosRW, mExtIO, mExtStrIO;
+
+
+static void
+ext_getoffset(VALUE io, int d, VALUE offset, off_t *offp)
+{
+    struct stat st;
+    if (NIL_P(offset)) {
+        if (fstat(d, &st) != 0) {
+            VALUE p = rb_inspect(io);
+            rb_raise(rb_eArgError,
+                     "unable to give a nil to `offset' for this IO object - %s",
+                     StringValueCStr(p));
+        }
+        *offp = st.st_size;
+    } else {
+        *offp = NUM2OFFT(offset);
+        if (*offp < 0) {
+            if (fstat(d, &st) != 0) {
+                VALUE p = rb_inspect(io);
+                rb_raise(rb_eArgError,
+                         "unable to give a negative to `offset' for this IO object - %s",
+                         StringValueCStr(p));
+            }
+            *offp += st.st_size;
+        }
+        if (*offp < 0) {
+            VALUE p = rb_inspect(io);
+            rb_raise(rb_eArgError,
+                     "file offset too small at %"PRId64" - %s",
+                     (int64_t)NUM2OFFT(offset),
+                     StringValueCStr(p));
+        }
+    }
+}
+
+struct readat_args
+{
+    rb_io_t *fptr;
+    void *buf;
+    size_t nbytes;
+    off_t offset;
+};
+
+static ssize_t
+io_readat_pread(struct readat_args *args)
+{
+    return pread(args->fptr->fd, args->buf, args->nbytes, args->offset);
+}
+
+static ssize_t
+io_readat_try(struct readat_args *args)
+{
+    return (ssize_t)rb_thread_call_without_gvl(NOGVL_FUNC(io_readat_pread),
+                                               args, RUBY_UBF_IO, 0);
+}
+
+enum {
+    READ_BLOCK_SIZE = 1024 * 1024,
+};
+
+static inline VALUE
+io_readat_all(struct readat_args *args, VALUE buffer)
+{
+    VALUE tmp = rb_str_buf_new(READ_BLOCK_SIZE);
+    rb_str_set_len(tmp, 0);
+
+    if (NIL_P(buffer)) {
+        buffer = rb_str_buf_new(0);
+    } else {
+        StringValue(buffer);
+    }
+    rb_str_set_len(buffer, 0);
+
+    rb_str_locktmp(buffer);
+    args->buf = RSTRING_PTR(tmp);
+
+    for (;;) {
+        rb_str_resize(tmp, READ_BLOCK_SIZE);
+        args->nbytes = RSTRING_LEN(tmp);
+        ssize_t n = (ssize_t)rb_ensure(RUBY_METHOD_FUNC(io_readat_try), (VALUE)args, rb_str_unlocktmp, buffer);
+
+        if (n == 0) {
+            break;
+        } else if (n < 0) {
+            rb_str_resize(tmp, 0);
+            rb_str_set_len(tmp, 0);
+            rb_sys_fail(NIL_P(args->fptr->pathv) ? NULL : RSTRING_PTR(args->fptr->pathv));
+        } else {
+            args->offset += n;
+            rb_str_set_len(tmp, n);
+            rb_str_concat(buffer, tmp);
+            rb_str_locktmp(buffer);
+        }
+    }
+
+    rb_str_resize(tmp, 0);
+    rb_str_set_len(tmp, 0);
+
+    if (RSTRING_LEN(buffer) == 0) {
+        return Qnil;
+    } else {
+        return buffer;
+    }
+}
+
+static inline VALUE
+io_readat_partial(struct readat_args *args, VALUE buffer)
+{
+    if (NIL_P(buffer)) {
+        buffer = rb_str_buf_new(args->nbytes);
+    } else {
+        StringValue(buffer);
+    }
+    rb_str_resize(buffer, args->nbytes);
+
+    rb_str_locktmp(buffer);
+    args->buf = RSTRING_PTR(buffer);
+    ssize_t n = (ssize_t)rb_ensure(RUBY_METHOD_FUNC(io_readat_try), (VALUE)args, rb_str_unlocktmp, buffer);
+
+    if (n == 0) {
+        return Qnil;
+    } else if (n < 0) {
+        rb_sys_fail(NIL_P(args->fptr->pathv) ? NULL : RSTRING_PTR(args->fptr->pathv));
+    }
+
+    rb_str_set_len(buffer, n);
+    rb_str_resize(buffer, n);
+
+    return buffer;
+}
+
+static void
+io_readat_security(VALUE io, VALUE offset, VALUE length, VALUE buffer)
+{
+    if (rb_safe_level() < 3) {
+        return;
+    }
+
+    if (!OBJ_TAINTED(io)) {
+        rb_secure(4);
+        if (!OBJ_TAINTED(offset) && !OBJ_TAINTED(length) && !OBJ_TAINTED(buffer)) {
+            return;
+        }
+    } else {
+        if (OBJ_TAINTED(offset) &&
+            (NIL_P(length) || OBJ_TAINTED(length)) &&
+            (NIL_P(buffer) || OBJ_TAINTED(buffer))) {
+
+            return;
+        }
+    }
+
+    rb_secure(3);
+}
+
+/*
+ * call-seq:
+ *  readat(offset) -> string or nil
+ *  readat(offset, length) -> string or nil
+ *  readat(offset, length, buffer) -> buffer or nil
+ *
+ * 指定位置から読み込むことが出来ます。
+ *
+ * IO#read との違いは、IO#pos= と IO#read との間でスレッドスイッチが発生することによる、
+ * 意図したストリーム位置から #read できないという問題がないことです。
+ *
+ * [RETURN]
+ *      正常に読み込んだ場合、データが格納された buffer、もしくは String インスタンスを返します。
+ *
+ *      ファイルサイズを越えた位置を offset に与えた場合、nil を返します。
+ *
+ * [offset]
+ *      読み込み位置をバイト値で指定します。
+ *
+ *      これはストリーム先端からの絶対位置となります。
+ *
+ *      負の整数を指定した場合、ファイル終端からの相対位置になります。
+ *      File#seek に SEEK_END で負の値を指定した場合と同じです。
+ *
+ *      nil を指定した場合、<tt>seek(0, SEEK_END)</tt> と同等となります。
+ *
+ * [length (省略可能)]
+ *      読み込むデータ長をバイト値で指定します。
+ *
+ *      省略もしくは nil を指定すると、ファイルの最後まで読み込みます。
+ *
+ * [buffer (省略可能)]
+ *      読み込み先バッファとして指定します。
+ *
+ *      省略もしくは nil を指定すると、IO#readat 内部で勝手に用意します。
+ *
+ *      buffer は変更可能 (frozen ではない String) なインスタンスである必要があります。
+ *
+ * [EXCEPTIONS]
+ *      いろいろ。
+ *
+ *      Errno::EXXX だったり、SEGV だったり、これらにとどまりません。
+ *
+ * 処理中は呼び出しスレッドのみが停止します (GVL を開放します)。
+ * その間別スレッドから buffer オブジェクトの変更はできなくなります
+ * (厳密に言うと、内部バッファの伸縮を伴う操作が出来なくなるだけです)。
+ *
+ *
+ * ==== 注意点
+ *
+ * Windows においては、#readat 後に IO 位置が更新されます (IO#pos= と IO#read した後と同じ位置)。
+ * これは Windows 上の制限となります。
+ */
+static VALUE
+io_readat(int argc, VALUE argv[], VALUE io)
+{
+    VALUE offset, length = Qnil, buffer = Qnil;
+    struct readat_args args;
+
+    rb_scan_args(argc, argv, "12", &offset, &length, &buffer);
+    io_readat_security(io, offset, length, buffer);
+    rb_check_type(io, RUBY_T_FILE);
+
+    GetOpenFile(io, args.fptr);
+    rb_io_check_char_readable(args.fptr);
+    ext_getoffset(io, args.fptr->fd, offset, &args.offset);
+
+    if (NIL_P(length)) {
+        buffer = io_readat_all(&args, buffer);
+    } else {
+        args.nbytes = NUM2SIZET(length);
+        if (args.nbytes > 0) {
+            buffer = io_readat_partial(&args, buffer);
+        } else {
+            if (NIL_P(buffer)) {
+                buffer = rb_str_new(0, 0);
+            } else {
+                rb_str_set_len(buffer, 0);
+            }
+        }
+    }
+
+    if (!NIL_P(buffer)) {
+        OBJ_TAINT(buffer);
+    }
+
+    return buffer;
+}
+
+
+struct writeat_args
+{
+    rb_io_t *fptr;
+    const void *buf;
+    size_t nbytes;
+    off_t offset;
+};
+
+static ssize_t
+io_writeat_pwrite(struct writeat_args *args)
+{
+    return pwrite(args->fptr->fd, args->buf, args->nbytes, args->offset);
+}
+
+static ssize_t
+io_writeat_try(struct writeat_args *args)
+{
+    return (ssize_t)rb_thread_call_without_gvl(NOGVL_FUNC(io_writeat_pwrite), args, RUBY_UBF_IO, 0);
+}
+
+/*
+ * call-seq:
+ *  writeat(offset, buffer) -> wrote size
+ *
+ * 指定位置への書き込みを行います。
+ *
+ * [RETURN]
+ *      書き込んだデータ量がバイト値で返ります。
+ *
+ * [offset]
+ *      書き込み位置をバイト値で指定します。これはストリーム先端からの絶対位置となります。
+ *
+ * [buffer]
+ *      書き込みたいデータが格納されたStringインスタンスを指定します。
+ *
+ * [EXCEPTIONS]
+ *      Errno::EXXX や、SEGV など。
+ *
+ * 処理中は呼び出しスレッドのみが停止します (GVL を開放します)。
+ * また、別スレッドから buffer オブジェクトの変更はできなくなります
+ * (厳密に言うと、内部バッファの伸縮を伴う操作が出来なくなるだけです)。
+ */
+static VALUE
+io_writeat(VALUE io, VALUE offset, VALUE buffer)
+{
+    rb_secure(4);
+    rb_check_type(io, RUBY_T_FILE);
+
+    struct writeat_args args;
+
+    StringValue(buffer);
+    args.nbytes = RSTRING_LEN(buffer);
+    GetOpenFile(io, args.fptr);
+    rb_io_check_closed(args.fptr);
+    ext_getoffset(io, args.fptr->fd, offset, &args.offset);
+
+    rb_str_locktmp(buffer);
+    args.buf = RSTRING_PTR(buffer);
+    ssize_t n = (ssize_t)rb_ensure(RUBY_METHOD_FUNC(io_writeat_try), (VALUE)&args, rb_str_unlocktmp, buffer);
+
+    if (n < 0) {
+        rb_sys_fail(NIL_P(args.fptr->pathv) ? NULL : RSTRING_PTR(args.fptr->pathv));
+    }
+
+    return SIZET2NUM(n);
+}
+
+
+/* ---- */
+
+
+static VALUE cStringIO;
+static ID IDstring, IDis_closed_read, IDis_closed_write;
+
+
+static inline VALUE
+strio_getstr(VALUE io)
+{
+    VALUE str = FUNCALL(io, IDstring);
+    rb_check_type(str, RUBY_T_STRING);
+    return str;
+}
+
+static inline VALUE
+strio_getread(VALUE io)
+{
+    if (RTEST(FUNCALL(io, IDis_closed_read))) {
+        rb_raise(rb_eIOError, "not opened for reading");
+    }
+
+    return strio_getstr(io);
+}
+
+static inline VALUE
+strio_getwrite(VALUE io)
+{
+    if (RTEST(FUNCALL(io, IDis_closed_write))) {
+        rb_raise(rb_eIOError, "not opened for writing");
+    }
+
+    return strio_getstr(io);
+}
+
+
+/*
+ * call-seq:
+ *  readat(offset) -> nil or string
+ *  readat(offset, length) -> nil or string
+ *  readat(offset, length, buffer) -> nil or buffer
+ *
+ * IO#readat と同じ。
+ *
+ * ただし、例外の搬出は挙動が異なります。このあたりは将来的に (200年後くらいには) 改善される見込みです。
+ *
+ * 処理中は Ruby のすべてのスレッドが停止します (GVL を開放しないため)。
+ */
+static VALUE
+strio_readat(int argc, VALUE argv[], VALUE io)
+{
+    VALUE offset, length = Qnil, buffer = Qnil;
+
+    rb_scan_args(argc, argv, "12", &offset, &length, &buffer);
+
+    VALUE str = strio_getread(io);
+
+    VALUE tmp = Qnil;
+    if (NIL_P(buffer)) {
+        tmp = buffer = rb_str_buf_new(0);
+    }
+
+    ssize_t lenmax = RSTRING_LEN(str);
+    ssize_t len = NIL_P(length) ? lenmax : NUM2SSIZET(length);
+
+    ssize_t off = NUM2SSIZET(offset);
+    if (off < 0) {
+        off += lenmax;
+    }
+
+    if (len == 0) {
+        if (NIL_P(buffer)) {
+            buffer = rb_str_new(0, 0);
+        } else {
+            rb_str_modify(buffer);
+            rb_str_set_len(buffer, 0);
+        }
+        OBJ_INFECT(buffer, io);
+        return buffer;
+    }
+
+    if (off >= lenmax) { return Qnil; }
+
+    if (off + len < 0) {
+        rb_raise(rb_eRangeError, "offset and length are too small or too large");
+    }
+
+    if (off + len > lenmax) { len = lenmax - off; }
+
+    StringValue(buffer);
+    rb_str_modify(buffer);
+    rb_str_resize(buffer, len);
+    rb_str_set_len(buffer, len);
+
+    memcpy(RSTRING_PTR(buffer), RSTRING_PTR(str) + off, len);
+
+    OBJ_INFECT(buffer, str);
+
+    return buffer;
+}
+
+/*
+ * call-seq:
+ *  writeat(offset, buffer) -> integer
+ *
+ * IO#writeat と同じ。
+ *
+ * ただし、例外の搬出は挙動が異なります。このあたりは将来的に (200年後くらいには) 改善される見込みです。
+ *
+ * 処理中は Ruby のすべてのスレッドが停止します (GVL を開放しないため)。
+ */
+static VALUE
+strio_writeat(VALUE io, VALUE offset, VALUE buffer)
+{
+    rb_secure(4);
+
+    VALUE str = strio_getwrite(io);
+
+    ssize_t off = NUM2SSIZET(offset);
+    if (off < 0) { NUM2SSIZET(SIZET2NUM(off)); } // EXCEPTION!
+    StringValue(buffer);
+    ssize_t len = RSTRING_LEN(buffer);
+    if (len < 0) { NUM2SSIZET(SIZET2NUM(len)); } // EXCEPTION!
+    if (off + len < 0) {
+        rb_raise(rb_eRangeError,
+                 "offset and buffer size are too large");
+    }
+
+    if (off + len > RSTRING_LEN(str)) {
+        ssize_t p = RSTRING_LEN(str);
+        rb_str_modify(buffer);
+        rb_str_resize(str, off + len);
+        rb_str_set_len(str, off + len);
+        if (off > p) {
+            memset(RSTRING_PTR(str) + p, 0, off - p);
+        }
+    } else {
+        rb_str_modify(str);
+    }
+
+    memcpy(RSTRING_PTR(str) + off, RSTRING_PTR(buffer), len);
+
+    return SSIZET2NUM(len);
+}
+
+
+/*
+ * Document-class: IO
+ *
+ * <b>現段階の実装状況においてセーフレベルをまともに扱っていないため、セキュリティリスクがあります。</b>
+ *
+ * この拡張ライブラリは IO#readat / IO#writeat を提供します。
+ *
+ * <tt>require "ioposrw"</tt> によって利用できるようになります。
+ */
+
+/*
+ * Document-class: StringIO
+ *
+ * <b>現段階の実装状況においてセーフレベルをまともに扱っていないため、セキュリティリスクがあります。</b>
+ *
+ * StringIO#readat / StringIO#writeat を提供します。
+ *
+ * StringIO#readat / StringIO#writeat は <tt>require "ioposrw"</tt> しただけでは有効になりません。
+ *
+ * <tt>require "ioposrw/stringio"</tt> をして下さい。
+ *
+ * まだ <tt>require "stringio"</tt> されていなければ勝手に読み込みます。
+ */
+
+void
+Init_ioposrw(void)
+{
+    IDstring          = rb_intern_const("string");
+    IDis_closed_read  = rb_intern_const("closed_read?");
+    IDis_closed_write = rb_intern_const("closed_write?");
+
+    mIOPosRW = rb_define_module("IOPositioningReadWrite");
+    mExtIO = rb_define_module_under(mIOPosRW, "IO");
+    mExtStrIO = rb_define_module_under(mIOPosRW, "StringIO");
+
+    rb_define_method(mExtIO, "readat", RUBY_METHOD_FUNC(io_readat), -1);
+    rb_define_method(mExtIO, "writeat", RUBY_METHOD_FUNC(io_writeat), 2);
+
+    rb_define_method(mExtStrIO, "readat", RUBY_METHOD_FUNC(strio_readat), -1);
+    rb_define_method(mExtStrIO, "writeat", RUBY_METHOD_FUNC(strio_writeat), 2);
+}

data/gemstub.rb

@@ -0,0 +1,35 @@
+unless File.read("README.md", 4096) =~ /^\s*\*\s*version:{1,2}\s*(.+)/i
+  raise "バージョン情報が README.md に見つかりません"
+end
+
+ver = $1
+verfile = "lib/ioposrw/version.rb"
+LIB << verfile
+
+file verfile => "README.md" do |*args|
+  File.binwrite args[0].name, <<-VERSION_FILE
+module IOPositioningReadWrite
+  VERSION = "#{ver}"
+end
+  VERSION_FILE
+end
+
+
+GEMSTUB = Gem::Specification.new do |s|
+  s.name = "ioposrw"
+  s.version = ver
+  s.summary = "Append IO#readat/writeat methods. These provide similar functionality to the POSIX pread/pwrite."
+  s.description = <<EOS
+Append IO#readat/writeat methods. These provide similar functionality to the POSIX pread/pwrite.
+This library works on windows and unix. But tested on windows and FreeBSD only.
+EOS
+  s.license = "BSD-2-Clause License"
+  s.author = "dearblue"
+  s.email = "dearblue@users.noreply.github.com"
+  s.homepage = "https://github.com/dearblue/ruby-ioposrw"
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "test-unit"
+end
+
+DOC << "QUICKREF.md"

data/lib/ioposrw.rb

@@ -0,0 +1,35 @@
+ver = RUBY_VERSION.slice(/\d+\.\d+/)
+soname = File.basename(__FILE__, ".rb") << ".so"
+lib = File.join(File.dirname(__FILE__), ver, soname)
+if File.file?(lib)
+  require_relative File.join(ver, soname)
+else
+  require_relative soname
+end
+
+require_relative "ioposrw/version"
+
+module IOPositioningReadWrite
+  module IOClass
+    #
+    # call-seq:
+    #  IO.ioposrw_enable_stringio_extend -> nil
+    #
+    # This is a feature that is FUTURE OBSOLUTE.
+    #
+    # Please use <tt>require "ioposrw/stringio"</tt> insted.
+    #
+    def ioposrw_enable_stringio_extend
+      warn <<-EOM
+(warning) #{caller(1, 1)[0]}: IO.ioposrw_enable_stringio_extend is FUTURE OBSOLUTE. please use ``require \"ioposrw/stringio\"'' insted.
+      EOM
+      require_relative "ioposrw/stringio"
+      nil
+    end
+  end
+end
+
+class IO
+  extend IOPositioningReadWrite::IOClass
+  include IOPositioningReadWrite::IO
+end

data/lib/ioposrw/stringio.rb

@@ -0,0 +1,6 @@
+require_relative "../ioposrw"
+require "stringio"
+
+class StringIO
+  include IOPositioningReadWrite::StringIO
+end

data/lib/ioposrw/version.rb

@@ -0,0 +1,3 @@
+module IOPositioningReadWrite
+  VERSION = "0.4"
+end

data/test/test_ioposrw.rb

@@ -0,0 +1,125 @@
+#!/usr/bin/env ruby
+
+require "test/unit"
+require "ioposrw"
+require "tempfile"
+
+class TC_ioposrw < Test::Unit::TestCase
+  attr_reader :file
+
+  SOURCE = ((0...256).to_a * 257).shuffle!.pack("C*")
+
+  def setup
+    @file = Tempfile.open("")
+    file.binmode
+    file << SOURCE
+    file.flush
+  end
+
+  def try_readat(file)
+    [
+      [0, 0, false, "", "空文字列になるべき"],
+      [SOURCE.length, 0, false, "", "空文字列になるべき"],
+      [SOURCE.length, nil, false, nil, "不適切な EOF"],
+      [file.size, nil, false, nil, "不適切な EOF"],
+      [file.size, 99999999, false, nil, "不適切な EOF"],
+      [0, nil, false, SOURCE, "先頭からの全読み込みが不一致"],
+      [0, SOURCE.length, false, SOURCE, "先頭からの全読み込みが不一致"],
+      [SOURCE.length / 2, SOURCE.length / 2, false,
+       SOURCE.slice(SOURCE.length / 2, SOURCE.length / 2),
+       "途中位置からの固定長分の読み込みが不一致"],
+
+       [0, 0, true, "", "空文字列になるべき"],
+       [SOURCE.length, 0, true, "", "空文字列になるべき"],
+       [SOURCE.length, nil, true, nil, "不適切な EOF"],
+       [file.size, nil, true, nil, "不適切な EOF"],
+       [file.size, 99999999, true, nil, "不適切な EOF"],
+       [0, nil, true, SOURCE, "先頭からの全読み込みが不一致"],
+       [0, SOURCE.length, true, SOURCE, "先頭からの全読み込みが不一致"],
+       [SOURCE.length / 2, SOURCE.length / 2, true,
+        SOURCE.slice(SOURCE.length / 2, SOURCE.length / 2),
+        "途中位置からの固定長分の読み込みが不一致"],
+    ].each do |pos, size, buf, ref, mesg|
+      if buf
+        buf = 200.times.reduce("") { |a, *| a << rand(256).chr(Encoding::BINARY) }
+      else
+        buf = nil
+      end
+      assert(file.readat(pos, size, buf) == ref,
+             "%s (%s)" % [mesg, pos: pos, size: size, buf_len: (buf ? buf.length : nil)])
+    end
+
+    256.times do
+      size = rand(file.size * 2)
+      pos = file.pos = rand(file.size)
+      assert(file.read(size) == (buf = file.readat(pos, size)),
+             "IO#pos + IO#read との不一致 (pos=#{pos}, size=#{size})")
+      buf1 = "".force_encoding(Encoding::BINARY)
+      file.pos = pos
+      assert(file.read(size, buf1) == (buf = file.readat(pos, size, buf1)),
+             "IO#pos + IO#read with buffer との不一致 (pos=#{pos}, size=#{size})")
+      assert(buf == SOURCE.byteslice(pos, size),
+             "SOURCE.byteslice との不一致 (pos=#{pos}, size=#{size})")
+    end
+  end
+
+  def try_writeat(file)
+    test = proc do |pos, buf|
+      assert(file.writeat(pos, buf) == buf.bytesize, "書き込み量の不一致")
+      if SOURCE.length < pos
+        SOURCE << "\0" * (pos - SOURCE.length)
+      end
+      SOURCE[pos, buf.bytesize] = buf
+      assert(file.size == SOURCE.length, "ファイルサイズが不正 (file.size=#{file.size})")
+      buf = file.readat(0)
+      assert(buf.length == SOURCE.length, "ファイルデータ量の不一致")
+      assert(buf == SOURCE, "書き込みデータの不一致")
+    end
+    [
+      [0, "HERGFDGFHMFDNGF"],
+      [10, "fsdghjljlkjhtgrfegvhjmg"],
+      [SOURCE.length + 100, "guiuydrtfv nm,j\;lkjchxdgxehtrjyukli,mnbvgdshbjt\n\r\r\n\0liu;79pfy7kt7lofvol"],
+    ].each(&test)
+
+    256.times do
+      pos = rand(SOURCE.length + 16384)
+      buf = (0...256).to_a.shuffle!.pack("C*")
+      test.(pos, buf)
+    end
+  end
+
+  def test_io_readat
+    try_readat(file)
+  end
+
+  def test_io_writeat
+    try_writeat(file)
+  end
+
+  def test_stringio_enable
+    if RUBY_VERSION < "2.2"
+      th = Thread.fork do
+        $SAFE = 2
+        IO.ioposrw_enable_stringio_extend
+      end
+      assert_raise(SecurityError) { th.join }
+    end
+
+    require "ioposrw/stringio"
+    assert($".select{|x| x=~/stringio\.so$/}.length == 1, 'require "stringio" されない')
+    assert(StringIO.instance_methods.select{|x| x==:readat}.length == 1, "StringIO#readat が未定義")
+    assert(StringIO.instance_methods.select{|x| x==:writeat}.length == 1, "StringIO#writeat が未定義")
+    @@str = StringIO.new(SOURCE.dup)
+    assert_not_nil(@@str)
+  end
+
+  def test_stringio_readat
+    assert(@@str)
+    try_readat(@@str)
+  end
+
+  def test_stringio_writeat
+    assert(@@str)
+    try_writeat(@@str)
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: ioposrw
+version: !ruby/object:Gem::Version
+  version: '0.4'
+platform: ruby
+authors:
+- dearblue
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Append IO#readat/writeat methods. These provide similar functionality to the POSIX pread/pwrite.
+  This library works on windows and unix. But tested on windows and FreeBSD only.
+email: dearblue@users.noreply.github.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files:
+- HISTORY.ja.md
+- QUICKREF.md
+- README.md
+- ext/ioposrw.c
+- lib/ioposrw.rb
+- lib/ioposrw/stringio.rb
+- lib/ioposrw/version.rb
+files:
+- HISTORY.ja.md
+- QUICKREF.md
+- README.md
+- Rakefile
+- ext/extconf.rb
+- ext/ioposrw.c
+- gemstub.rb
+- lib/ioposrw.rb
+- lib/ioposrw/stringio.rb
+- lib/ioposrw/version.rb
+- test/test_ioposrw.rb
+homepage: https://github.com/dearblue/ruby-ioposrw
+licenses:
+- BSD-2-Clause License
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset"
+- UTF-8
+- "-m"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Append IO#readat/writeat methods. These provide similar functionality to
+  the POSIX pread/pwrite.
+test_files: []