Ruby

AC_CHECK_FUNCS(pwrite)

#if defined(HAVE_PREAD) || defined(HAVE_PWRITE)

struct prdwr_internal_arg {

int fd;

void *buf;

size_t count;

off_t offset;

ssize_t len;

};

#endif /* HAVE_PREAD || HAVE_PWRITE */

#if defined(HAVE_PREAD)

static VALUE

internal_pread_func(void *arg)

{

struct prdwr_internal_arg *p = arg;

return (VALUE)pread(p->fd, p->buf, p->count, p->offset);

}

static VALUE

pread_internal_call(VALUE arg)

{

struct prdwr_internal_arg *p = (struct prdwr_internal_arg *)arg;

p->len = (ssize_t)rb_thread_io_blocking_region(internal_pread_func, p, p->fd);

return Qundef;

}

#endif /* HAVE_PREAD */

/*

* call-seq:

* ios.pread(maxlen, offset[, outbuf]) -> string

*

* Reads <i>maxlen</i> bytes from <em>ios</em> using the pread system call

* and returns them as a string without modifying the underlying

* descriptor offset. This is advantageous compared to combining IO#seek

* and IO#read in that it is atomic, allowing multiple threads/process to

* share the same IO object for reading the file at various locations.

* This bypasses any userspace buffering of the IO layer.

* If the optional <i>outbuf</i> argument is present, it must

* reference a String, which will receive the data.

* Raises <code>SystemCallError</code> on error, <code>EOFError</code>

* at end of file and <code>NotImplementedError</code> if platform does not

* implement the system call.

*

* f = File.new("testfile")

* f.read #=> "This is line one\nThis is line two\n"

* f.pread(12, 0) #=> "This is line"

* f.pread(9, 8) #=> "line one\n"

*/

static VALUE

rb_io_pread(int argc, VALUE *argv, VALUE io)

{

#if defined(HAVE_PREAD)

VALUE len, offset, str;

rb_io_t *fptr;

ssize_t n;

struct prdwr_internal_arg arg;

rb_scan_args(argc, argv, "21", &len, &offset, &str);

arg.count = NUM2SIZET(len);

arg.offset = NUM2OFFT(offset);

io_setstrbuf(&str, (long)arg.count);

if (arg.count == 0) return str;

arg.buf = RSTRING_PTR(str);

GetOpenFile(io, fptr);

rb_io_check_byte_readable(fptr);

arg.fd = fptr->fd;

rb_io_check_closed(fptr);

rb_str_locktmp(str);

rb_ensure(pread_internal_call, (VALUE)&arg, rb_str_unlocktmp, str);

n = arg.len;

if (n == -1) {

rb_sys_fail_path(fptr->pathv);

}

io_set_read_length(str, n);

if (n == 0 && arg.count > 0) {

rb_eof_error();

}

OBJ_TAINT(str);

return str;

#else

rb_raise(rb_eNotImpError, "pread() function is unimplemented on this machine");

return Qnil;

#endif /* HAVE_PREAD */

}

#if defined(HAVE_PWRITE)

static VALUE

internal_pwrite_func(void *ptr)

{

struct prdwr_internal_arg *arg = ptr;

return (VALUE)pwrite(arg->fd, arg->buf, arg->count, arg->offset);

}

#endif /* HAVE_PWRITE */

/*

* call-seq:

* ios.pwrite(string, offset) -> integer

*

* Writes the given string to <em>ios</em> at <i>offset</i> using pwrite()

* system call. This is advantageous to combining IO#seek and IO#write

* in that it is atomic, allowing multiple threads/process to share the

* same IO object for reading the file at various locations.

* This bypasses any userspace buffering of the IO layer.

* Returns the number of bytes written.

* Raises <code>SystemCallError</code> on error and <code>NotImplementedError</code>

* if platform does not implement the system call.

*

* f = File.new("out", "w")

* f.pwrite("ABCDEF", 3) #=> 6

*

* File.read("out") #=> "\u0000\u0000\u0000ABCDEF"

*/

static VALUE

rb_io_pwrite(VALUE io, VALUE offset, VALUE str)

{

#if defined(HAVE_PWRITE)

rb_io_t *fptr;

ssize_t n;

struct prdwr_internal_arg arg;

if (!RB_TYPE_P(str, T_STRING))

str = rb_obj_as_string(str);

arg.buf = RSTRING_PTR(str);

arg.count = (size_t)RSTRING_LEN(str);

arg.offset = NUM2OFFT(offset);

io = GetWriteIO(io);

GetOpenFile(io, fptr);

rb_io_check_writable(fptr);

arg.fd = fptr->fd;

n = (ssize_t)rb_thread_io_blocking_region(internal_pwrite_func, &arg, fptr->fd);

RB_GC_GUARD(str);

if (n == -1) rb_sys_fail_path(fptr->pathv);

return LONG2FIX(n);

#else

rb_raise(rb_eNotImpError, "pwrite() function is unimplemented on this machine");

return Qnil;

#endif /* HAVE_PWRITE */

}

rb_define_method(rb_cIO, "pread", rb_io_pread, -1);

rb_define_method(rb_cIO, "pwrite", rb_io_pwrite, 2);

def test_pread

make_tempfile { |t|

open(t.path) do |f|

assert_equal("bar", f.pread(3, 4))

buf = "asdf"

assert_equal("bar", f.pread(3, 4, buf))

assert_equal("bar", buf)

assert_raise(EOFError) { f.pread(1, f.size) }

end

}

rescue NotImplementedError

skip "pread(2) is not implemented."

end

def test_pwrite

make_tempfile { |t|

open(t.path, IO::RDWR) do |f|

assert_equal(3, f.pwrite(4, "ooo"))

assert_equal("ooo", f.pread(3, 4))

end

}

rescue NotImplementedError

skip "pwrite(2) and pread(2) are not implemented."

end