#include "ruby/ruby.h"

#include "ruby/io.h"

#include "ruby/thread.h"

#include "dln.h"

#include "internal.h"

#include "id.h"

#include <ctype.h>

#include <errno.h>

#include "ruby_atomic.h"

#define free(x) xfree(x)

#if defined(DOSISH) || defined(__CYGWIN__)

#include <io.h>

#include <sys/types.h>

#if defined HAVE_NET_SOCKET_H

# include <net/socket.h>

#elif defined HAVE_SYS_SOCKET_H

# ifndef __native_client__

# include <sys/socket.h>

#if defined(__BOW__) || defined(__CYGWIN__) || defined(_WIN32) || defined(__EMX__) || defined(__BEOS__) || defined(__HAIKU__)

# define NO_SAFE_RENAME

#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__sun) || defined(_nec_ews)

# define USE_SETVBUF

#ifdef __QNXNTO__

#include "unix.h"

#include <sys/types.h>

#if defined(HAVE_SYS_IOCTL_H) && !defined(_WIN32)

#include <sys/ioctl.h>

#if defined(__native_client__) && defined(NACL_NEWLIB)

# include "nacl/ioctl.h"

#if defined(HAVE_FCNTL_H) || defined(_WIN32)

#include <fcntl.h>

#elif defined(HAVE_SYS_FCNTL_H)

#include <sys/fcntl.h>

#if !HAVE_OFF_T && !defined(off_t)

# define off_t long

#include <sys/stat.h>

#if defined(HAVE_SYS_PARAM_H) && !(defined(__EMX__) || defined(__HIUX_MPP__))

# include <sys/param.h>

#if !defined NOFILE

# define NOFILE 64

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#ifdef HAVE_SYSCALL_H

#include <syscall.h>

#elif defined HAVE_SYS_SYSCALL_H

#include <sys/syscall.h>

#if defined(__BEOS__) || defined(__HAIKU__)

# ifndef NOFILE

# define NOFILE (OPEN_MAX)

#include "ruby/util.h"

#ifndef O_ACCMODE

#define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)

#if SIZEOF_OFF_T > SIZEOF_LONG && !defined(HAVE_LONG_LONG)

# error off_t is bigger than long, but you have no long long...

#ifndef PIPE_BUF

# ifdef _POSIX_PIPE_BUF

# define PIPE_BUF _POSIX_PIPE_BUF

# define PIPE_BUF 512 /* is this ok? */

#ifndef EWOULDBLOCK

# define EWOULDBLOCK EAGAIN

#if defined(HAVE___SYSCALL) && (defined(__APPLE__) || defined(__OpenBSD__))

off_t __syscall(quad_t number, ...);

#define IO_RBUF_CAPA_MIN 8192

#define IO_CBUF_CAPA_MIN (128*1024)

#define IO_RBUF_CAPA_FOR(fptr) (NEED_READCONV(fptr) ? IO_CBUF_CAPA_MIN : IO_RBUF_CAPA_MIN)

#define IO_WBUF_CAPA_MIN 8192

#ifdef _WIN32

#undef open

#define open rb_w32_uopen

VALUE rb_cIO;

VALUE rb_eEOFError;

VALUE rb_eIOError;

VALUE rb_mWaitReadable;

VALUE rb_mWaitWritable;

extern VALUE rb_eEAGAIN;

extern VALUE rb_eEWOULDBLOCK;

extern VALUE rb_eEINPROGRESS;

static VALUE rb_eEAGAINWaitReadable;

static VALUE rb_eEAGAINWaitWritable;

static VALUE rb_eEWOULDBLOCKWaitReadable;

static VALUE rb_eEWOULDBLOCKWaitWritable;

static VALUE rb_eEINPROGRESSWaitWritable;

static VALUE rb_eEINPROGRESSWaitReadable;

VALUE rb_stdin, rb_stdout, rb_stderr;

VALUE rb_deferr; /* rescue VIM plugin */

static VALUE orig_stdout, orig_stderr;

VALUE rb_output_fs;

VALUE rb_rs;

VALUE rb_output_rs;

VALUE rb_default_rs;

static VALUE argf;

static ID id_write, id_read, id_getc, id_flush, id_readpartial, id_set_encoding;

static VALUE sym_mode, sym_perm, sym_extenc, sym_intenc, sym_encoding, sym_open_args;

static VALUE sym_textmode, sym_binmode, sym_autoclose, sym_exception;

static VALUE sym_SET, sym_CUR, sym_END;

#ifdef SEEK_DATA

static VALUE sym_DATA;

#ifdef SEEK_HOLE

static VALUE sym_HOLE;

struct argf {

};

static rb_atomic_t max_file_descriptor = NOFILE;

rb_update_max_fd(int fd)

{

struct stat buf;

rb_atomic_t afd = (rb_atomic_t)fd;

if (fstat(fd, &buf) != 0 && errno == EBADF) {

rb_bug("rb_update_max_fd: invalid fd (%d) given.", fd);

}

while (max_file_descriptor < afd) {

ATOMIC_CAS(max_file_descriptor, max_file_descriptor, afd);

}

}

rb_maygvl_fd_fix_cloexec(int fd)

{

/* MinGW don't have F_GETFD and FD_CLOEXEC. [ruby-core:40281] */

#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)

int flags, flags2, ret;

flags = fcntl(fd, F_GETFD); /* should not fail except EBADF. */

if (flags == -1) {

rb_bug("rb_maygvl_fd_fix_cloexec: fcntl(%d, F_GETFD) failed: %s", fd, strerror(errno));

}

if (fd <= 2)

flags2 = flags & ~FD_CLOEXEC; /* Clear CLOEXEC for standard file descriptors: 0, 1, 2. */

else

flags2 = flags | FD_CLOEXEC; /* Set CLOEXEC for non-standard file descriptors: 3, 4, 5, ... */

if (flags != flags2) {

ret = fcntl(fd, F_SETFD, flags2);

if (ret == -1) {

rb_bug("rb_maygvl_fd_fix_cloexec: fcntl(%d, F_SETFD, %d) failed: %s", fd, flags2, strerror(errno));

}

}

}

rb_fd_fix_cloexec(int fd)

{

rb_maygvl_fd_fix_cloexec(fd);

rb_update_max_fd(fd);

}

rb_cloexec_open(const char *pathname, int flags, mode_t mode)

{

int ret;

#ifdef O_CLOEXEC

/* O_CLOEXEC is available since Linux 2.6.23. Linux 2.6.18 silently ignore it. */

flags |= O_CLOEXEC;

#elif defined O_NOINHERIT

flags |= O_NOINHERIT;

ret = open(pathname, flags, mode);

if (ret == -1) return -1;

rb_maygvl_fd_fix_cloexec(ret);

return ret;

}

rb_cloexec_dup(int oldfd)

{

/* Don't allocate standard file descriptors: 0, 1, 2 */

return rb_cloexec_fcntl_dupfd(oldfd, 3);

}

rb_cloexec_dup2(int oldfd, int newfd)

{

int ret;

/* When oldfd == newfd, dup2 succeeds but dup3 fails with EINVAL.

if (oldfd == newfd) {

ret = newfd;

}

else {

#if defined(HAVE_DUP3) && defined(O_CLOEXEC)

static int try_dup3 = 1;

if (2 < newfd && try_dup3) {

ret = dup3(oldfd, newfd, O_CLOEXEC);

if (ret != -1)

return ret;

/* dup3 is available since Linux 2.6.27, glibc 2.9. */

if (errno == ENOSYS) {

try_dup3 = 0;

ret = dup2(oldfd, newfd);

}

}

else {

ret = dup2(oldfd, newfd);

}

ret = dup2(oldfd, newfd);

if (ret == -1) return -1;

}

rb_maygvl_fd_fix_cloexec(ret);

return ret;

}

rb_cloexec_pipe(int fildes[2])

{

int ret;

#if defined(HAVE_PIPE2)

static int try_pipe2 = 1;

if (try_pipe2) {

ret = pipe2(fildes, O_CLOEXEC);

if (ret != -1)

return ret;

/* pipe2 is available since Linux 2.6.27, glibc 2.9. */

if (errno == ENOSYS) {

try_pipe2 = 0;

ret = pipe(fildes);

}

}

else {

ret = pipe(fildes);

}

ret = pipe(fildes);

if (ret == -1) return -1;

#ifdef __CYGWIN__

if (ret == 0 && fildes[1] == -1) {

close(fildes[0]);

fildes[0] = -1;

errno = ENFILE;

return -1;

}

rb_maygvl_fd_fix_cloexec(fildes[0]);

rb_maygvl_fd_fix_cloexec(fildes[1]);

return ret;

}

rb_cloexec_fcntl_dupfd(int fd, int minfd)

{

int ret;

#if defined(HAVE_FCNTL) && defined(F_DUPFD_CLOEXEC) && defined(F_DUPFD)

static int try_dupfd_cloexec = 1;

if (try_dupfd_cloexec) {

ret = fcntl(fd, F_DUPFD_CLOEXEC, minfd);

if (ret != -1) {

if (ret <= 2)

rb_maygvl_fd_fix_cloexec(ret);

return ret;

}

/* F_DUPFD_CLOEXEC is available since Linux 2.6.24. Linux 2.6.18 fails with EINVAL */

if (errno == EINVAL) {

ret = fcntl(fd, F_DUPFD, minfd);

if (ret != -1) {

try_dupfd_cloexec = 0;

}

}

}

else {

ret = fcntl(fd, F_DUPFD, minfd);

}

#elif defined(HAVE_FCNTL) && defined(F_DUPFD)

ret = fcntl(fd, F_DUPFD, minfd);

#elif defined(HAVE_DUP)

ret = dup(fd);

if (ret != -1 && ret < minfd) {

const int prev_fd = ret;

ret = rb_cloexec_fcntl_dupfd(fd, minfd);

close(prev_fd);

}

return ret;

# error "dup() or fcntl(F_DUPFD) must be supported."

if (ret == -1) return -1;

rb_maygvl_fd_fix_cloexec(ret);

return ret;

}

#define argf_of(obj) (*(struct argf *)DATA_PTR(obj))

#define ARGF argf_of(argf)

#ifdef _STDIO_USES_IOSTREAM /* GNU libc */

# ifdef _IO_fpos_t

# define STDIO_READ_DATA_PENDING(fp) ((fp)->_IO_read_ptr != (fp)->_IO_read_end)

# define STDIO_READ_DATA_PENDING(fp) ((fp)->_gptr < (fp)->_egptr)

#elif defined(FILE_COUNT)

# define STDIO_READ_DATA_PENDING(fp) ((fp)->FILE_COUNT > 0)

#elif defined(FILE_READEND)

# define STDIO_READ_DATA_PENDING(fp) ((fp)->FILE_READPTR < (fp)->FILE_READEND)

#elif defined(__BEOS__) || defined(__HAIKU__)

# define STDIO_READ_DATA_PENDING(fp) ((fp)->_state._eof == 0)

# define STDIO_READ_DATA_PENDING(fp) (!feof(fp))

#define GetWriteIO(io) rb_io_get_write_io(io)

#define READ_DATA_PENDING(fptr) ((fptr)->rbuf.len)

#define READ_DATA_PENDING_COUNT(fptr) ((fptr)->rbuf.len)

#define READ_DATA_PENDING_PTR(fptr) ((fptr)->rbuf.ptr+(fptr)->rbuf.off)

#define READ_DATA_BUFFERED(fptr) READ_DATA_PENDING(fptr)

#define READ_CHAR_PENDING(fptr) ((fptr)->cbuf.len)

#define READ_CHAR_PENDING_COUNT(fptr) ((fptr)->cbuf.len)

#define READ_CHAR_PENDING_PTR(fptr) ((fptr)->cbuf.ptr+(fptr)->cbuf.off)

#if defined(_WIN32)

#define WAIT_FD_IN_WIN32(fptr) \

(rb_w32_io_cancelable_p((fptr)->fd) ? 0 : rb_thread_wait_fd((fptr)->fd))

#define WAIT_FD_IN_WIN32(fptr)

#define READ_CHECK(fptr) do {\

if (!READ_DATA_PENDING(fptr)) {\

WAIT_FD_IN_WIN32(fptr);\

rb_io_check_closed(fptr);\

}\

} while(0)

#ifndef S_ISSOCK

# ifdef _S_ISSOCK

# define S_ISSOCK(m) _S_ISSOCK(m)

# ifdef _S_IFSOCK

# define S_ISSOCK(m) (((m) & S_IFMT) == _S_IFSOCK)

# ifdef S_IFSOCK

# define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)

static int io_fflush(rb_io_t *);

static rb_io_t *flush_before_seek(rb_io_t *fptr);

#define NEED_NEWLINE_DECORATOR_ON_READ(fptr) ((fptr)->mode & FMODE_TEXTMODE)

#define NEED_NEWLINE_DECORATOR_ON_WRITE(fptr) ((fptr)->mode & FMODE_TEXTMODE)

#if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32)

# define DEFAULT_TEXTMODE FMODE_TEXTMODE

# define TEXTMODE_NEWLINE_DECORATOR_ON_WRITE ECONV_CRLF_NEWLINE_DECORATOR

#define NEED_READCONV(fptr) ((fptr)->encs.enc2 != NULL || (fptr)->encs.ecflags & ~ECONV_CRLF_NEWLINE_DECORATOR)

#define NEED_WRITECONV(fptr) (((fptr)->encs.enc != NULL && (fptr)->encs.enc != rb_ascii8bit_encoding()) || ((fptr)->encs.ecflags & ((ECONV_DECORATOR_MASK & ~ECONV_CRLF_NEWLINE_DECORATOR)|ECONV_STATEFUL_DECORATOR_MASK)))

#define SET_BINARY_MODE(fptr) setmode((fptr)->fd, O_BINARY)

#define NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr) do {\

if (NEED_NEWLINE_DECORATOR_ON_READ(fptr)) {\

if (((fptr)->mode & FMODE_READABLE) &&\

!((fptr)->encs.ecflags & ECONV_NEWLINE_DECORATOR_MASK)) {\

setmode((fptr)->fd, O_BINARY);\

}\

else {\

setmode((fptr)->fd, O_TEXT);\

}\

}\

} while(0)

#define SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags) do {\

if ((enc2) && ((ecflags) & ECONV_DEFAULT_NEWLINE_DECORATOR)) {\

(ecflags) |= ECONV_UNIVERSAL_NEWLINE_DECORATOR;\

}\

} while(0)

static void

io_unread(rb_io_t *fptr)

{

off_t r, pos;

ssize_t read_size;

long i;

long newlines = 0;

long extra_max;

char *p;

char *buf;

rb_io_check_closed(fptr);

if (fptr->rbuf.len == 0 || fptr->mode & FMODE_DUPLEX) {

return;

}

errno = 0;

if (!rb_w32_fd_is_text(fptr->fd)) {

r = lseek(fptr->fd, -fptr->rbuf.len, SEEK_CUR);

if (r < 0 && errno) {

if (errno == ESPIPE)

fptr->mode |= FMODE_DUPLEX;

return;

}

fptr->rbuf.off = 0;

fptr->rbuf.len = 0;

return;

}

pos = lseek(fptr->fd, 0, SEEK_CUR);

if (pos < 0 && errno) {

if (errno == ESPIPE)

fptr->mode |= FMODE_DUPLEX;

return;

}

/* add extra offset for removed '\r' in rbuf */

extra_max = (long)(pos - fptr->rbuf.len);

p = fptr->rbuf.ptr + fptr->rbuf.off;

/* if the end of rbuf is '\r', rbuf doesn't have '\r' within rbuf.len */

if (*(fptr->rbuf.ptr + fptr->rbuf.capa - 1) == '\r') {

newlines++;

}

for (i = 0; i < fptr->rbuf.len; i++) {

if (*p == '\n') newlines++;

if (extra_max == newlines) break;

p++;

}

buf = ALLOC_N(char, fptr->rbuf.len + newlines);

while (newlines >= 0) {

r = lseek(fptr->fd, pos - fptr->rbuf.len - newlines, SEEK_SET);

if (newlines == 0) break;

if (r < 0) {

newlines--;

continue;

}

read_size = _read(fptr->fd, buf, fptr->rbuf.len + newlines);

if (read_size < 0) {

free(buf);

rb_sys_fail_path(fptr->pathv);

}

if (read_size == fptr->rbuf.len) {

lseek(fptr->fd, r, SEEK_SET);

break;

}

else {

newlines--;

}

}

free(buf);

fptr->rbuf.off = 0;

fptr->rbuf.len = 0;

return;

}

static inline int

set_binary_mode_with_seek_cur(rb_io_t *fptr)

{

if (!rb_w32_fd_is_text(fptr->fd)) return O_BINARY;

if (fptr->rbuf.len == 0 || fptr->mode & FMODE_DUPLEX) {

return setmode(fptr->fd, O_BINARY);

}

flush_before_seek(fptr);

return setmode(fptr->fd, O_BINARY);

}

#define SET_BINARY_MODE_WITH_SEEK_CUR(fptr) set_binary_mode_with_seek_cur(fptr)

# define DEFAULT_TEXTMODE 0

#define NEED_READCONV(fptr) ((fptr)->encs.enc2 != NULL || NEED_NEWLINE_DECORATOR_ON_READ(fptr))

#define NEED_WRITECONV(fptr) (((fptr)->encs.enc != NULL && (fptr)->encs.enc != rb_ascii8bit_encoding()) || NEED_NEWLINE_DECORATOR_ON_WRITE(fptr) || ((fptr)->encs.ecflags & (ECONV_DECORATOR_MASK|ECONV_STATEFUL_DECORATOR_MASK)))

#define SET_BINARY_MODE(fptr) (void)(fptr)

#define NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr) (void)(fptr)

#define SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags) ((void)(enc2), (void)(ecflags))

#define SET_BINARY_MODE_WITH_SEEK_CUR(fptr) (void)(fptr)

#if !defined HAVE_SHUTDOWN && !defined shutdown

#define shutdown(a,b) 0

#if defined(_WIN32)

#define is_socket(fd, path) rb_w32_is_socket(fd)

#elif !defined(S_ISSOCK)

#define is_socket(fd, path) 0

static int

is_socket(int fd, VALUE path)

{

struct stat sbuf;

if (fstat(fd, &sbuf) < 0)

rb_sys_fail_path(path);

return S_ISSOCK(sbuf.st_mode);

}

static const char closed_stream[] = "closed stream";

rb_eof_error(void)

{

rb_raise(rb_eEOFError, "end of file reached");

}

rb_io_taint_check(VALUE io)

{

rb_check_frozen(io);

return io;

}

rb_io_check_initialized(rb_io_t *fptr)

{

if (!fptr) {

rb_raise(rb_eIOError, "uninitialized stream");

}

}

rb_io_check_closed(rb_io_t *fptr)

{

rb_io_check_initialized(fptr);

if (fptr->fd < 0) {

rb_raise(rb_eIOError, closed_stream);

}

}

rb_io_get_io(VALUE io)

{

return rb_convert_type(io, T_FILE, "IO", "to_io");

}

rb_io_check_io(VALUE io)

{

return rb_check_convert_type(io, T_FILE, "IO", "to_io");

}

rb_io_get_write_io(VALUE io)

{

VALUE write_io;

rb_io_check_initialized(RFILE(io)->fptr);

write_io = RFILE(io)->fptr->tied_io_for_writing;

if (write_io) {

return write_io;

}

return io;

}

rb_io_set_write_io(VALUE io, VALUE w)

{

VALUE write_io;

rb_io_check_initialized(RFILE(io)->fptr);

if (!RTEST(w)) {

w = 0;

}

else {

GetWriteIO(w);

}

write_io = RFILE(io)->fptr->tied_io_for_writing;

RFILE(io)->fptr->tied_io_for_writing = w;

return write_io ? write_io : Qnil;

}

static VALUE

rb_io_s_try_convert(VALUE dummy, VALUE io)

{

return rb_io_check_io(io);

}

#if !(defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32))

static void

io_unread(rb_io_t *fptr)

{

off_t r;

rb_io_check_closed(fptr);

if (fptr->rbuf.len == 0 || fptr->mode & FMODE_DUPLEX)

return;

/* xxx: target position may be negative if buffer is filled by ungetc */

errno = 0;

r = lseek(fptr->fd, -fptr->rbuf.len, SEEK_CUR);

if (r < 0 && errno) {

if (errno == ESPIPE)

fptr->mode |= FMODE_DUPLEX;

return;

}

fptr->rbuf.off = 0;

fptr->rbuf.len = 0;

return;

}

static rb_encoding *io_input_encoding(rb_io_t *fptr);

static void

io_ungetbyte(VALUE str, rb_io_t *fptr)

{

long len = RSTRING_LEN(str);

if (fptr->rbuf.ptr == NULL) {

const int min_capa = IO_RBUF_CAPA_FOR(fptr);

fptr->rbuf.off = 0;

fptr->rbuf.len = 0;

#if SIZEOF_LONG > SIZEOF_INT

if (len > INT_MAX)

rb_raise(rb_eIOError, "ungetbyte failed");

if (len > min_capa)

fptr->rbuf.capa = (int)len;

else

fptr->rbuf.capa = min_capa;

fptr->rbuf.ptr = ALLOC_N(char, fptr->rbuf.capa);

}

if (fptr->rbuf.capa < len + fptr->rbuf.len) {

rb_raise(rb_eIOError, "ungetbyte failed");

}

if (fptr->rbuf.off < len) {

MEMMOVE(fptr->rbuf.ptr+fptr->rbuf.capa-fptr->rbuf.len,

fptr->rbuf.ptr+fptr->rbuf.off,

char, fptr->rbuf.len);

fptr->rbuf.off = fptr->rbuf.capa-fptr->rbuf.len;

}

fptr->rbuf.off-=(int)len;

fptr->rbuf.len+=(int)len;

MEMMOVE(fptr->rbuf.ptr+fptr->rbuf.off, RSTRING_PTR(str), char, len);

}

static rb_io_t *

flush_before_seek(rb_io_t *fptr)

{

if (io_fflush(fptr) < 0)

rb_sys_fail(0);

io_unread(fptr);

errno = 0;

return fptr;

}

#define io_seek(fptr, ofs, whence) (errno = 0, lseek(flush_before_seek(fptr)->fd, (ofs), (whence)))

#define io_tell(fptr) lseek(flush_before_seek(fptr)->fd, 0, SEEK_CUR)

#ifndef SEEK_CUR

# define SEEK_SET 0

# define SEEK_CUR 1

# define SEEK_END 2

rb_io_check_char_readable(rb_io_t *fptr)

{

rb_io_check_closed(fptr);

if (!(fptr->mode & FMODE_READABLE)) {

rb_raise(rb_eIOError, "not opened for reading");

}

if (fptr->wbuf.len) {

if (io_fflush(fptr) < 0)

rb_sys_fail(0);

}

if (fptr->tied_io_for_writing) {

rb_io_t *wfptr;

GetOpenFile(fptr->tied_io_for_writing, wfptr);

if (io_fflush(wfptr) < 0)

rb_sys_fail(0);

}

}

rb_io_check_byte_readable(rb_io_t *fptr)

{

rb_io_check_char_readable(fptr);

if (READ_CHAR_PENDING(fptr)) {

rb_raise(rb_eIOError, "byte oriented read for character buffered IO");

}

}

rb_io_check_readable(rb_io_t *fptr)

{

rb_io_check_byte_readable(fptr);

}

static rb_encoding*

io_read_encoding(rb_io_t *fptr)

{

if (fptr->encs.enc) {

return fptr->encs.enc;

}

return rb_default_external_encoding();

}

static rb_encoding*

io_input_encoding(rb_io_t *fptr)

{

if (fptr->encs.enc2) {

return fptr->encs.enc2;

}

return io_read_encoding(fptr);

}

rb_io_check_writable(rb_io_t *fptr)

{

rb_io_check_closed(fptr);

if (!(fptr->mode & FMODE_WRITABLE)) {

rb_raise(rb_eIOError, "not opened for writing");

}

if (fptr->rbuf.len) {

io_unread(fptr);

}

}

rb_io_read_pending(rb_io_t *fptr)

{

/* This function is used for bytes and chars. Confusing. */

if (READ_CHAR_PENDING(fptr))

return 1; /* should raise? */

return READ_DATA_PENDING(fptr);

}

rb_read_check(FILE *fp)

{

if (!STDIO_READ_DATA_PENDING(fp)) {

rb_thread_wait_fd(fileno(fp));

}

}

rb_io_read_check(rb_io_t *fptr)

{

if (!READ_DATA_PENDING(fptr)) {

rb_thread_wait_fd(fptr->fd);

}

return;

}

static int

ruby_dup(int orig)

{

int fd;

fd = rb_cloexec_dup(orig);

if (fd < 0) {

if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {

rb_gc();

fd = rb_cloexec_dup(orig);

}

if (fd < 0) {

rb_sys_fail(0);

}

}

rb_update_max_fd(fd);

return fd;

}

static VALUE

io_alloc(VALUE klass)

{

NEWOBJ_OF(io, struct RFile, klass, T_FILE);

io->fptr = 0;

return (VALUE)io;

}

#ifndef S_ISREG

# define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)

static int

wsplit_p(rb_io_t *fptr)

{

#if defined(HAVE_FCNTL) && defined(F_GETFL) && defined(O_NONBLOCK)

int r;

if (!(fptr->mode & FMODE_WSPLIT_INITIALIZED)) {

struct stat buf;

if (fstat(fptr->fd, &buf) == 0 &&

!S_ISREG(buf.st_mode)

#if defined(HAVE_FCNTL) && defined(F_GETFL) && defined(O_NONBLOCK)

&& (r = fcntl(fptr->fd, F_GETFL)) != -1 &&

!(r & O_NONBLOCK)

) {

fptr->mode |= FMODE_WSPLIT;

}

fptr->mode |= FMODE_WSPLIT_INITIALIZED;

}

return fptr->mode & FMODE_WSPLIT;

}

struct io_internal_read_struct {

};

struct io_internal_write_struct {

};

static VALUE

internal_read_func(void *ptr)

{

struct io_internal_read_struct *iis = ptr;

return read(iis->fd, iis->buf, iis->capa);

}

static VALUE

internal_write_func(void *ptr)

{

struct io_internal_write_struct *iis = ptr;

return write(iis->fd, iis->buf, iis->capa);

}

static void*

internal_write_func2(void *ptr)

{

struct io_internal_write_struct *iis = ptr;

return (void*)(intptr_t)write(iis->fd, iis->buf, iis->capa);

}

static ssize_t

rb_read_internal(int fd, void *buf, size_t count)

{

struct io_internal_read_struct iis;

iis.fd = fd;

iis.buf = buf;

iis.capa = count;

return (ssize_t)rb_thread_io_blocking_region(internal_read_func, &iis, fd);

}

static ssize_t

rb_write_internal(int fd, const void *buf, size_t count)

{

struct io_internal_write_struct iis;

iis.fd = fd;

iis.buf = buf;

iis.capa = count;

return (ssize_t)rb_thread_io_blocking_region(internal_write_func, &iis, fd);

}

static ssize_t

rb_write_internal2(int fd, const void *buf, size_t count)

{

struct io_internal_write_struct iis;

iis.fd = fd;

iis.buf = buf;

iis.capa = count;

return (ssize_t)rb_thread_call_without_gvl2(internal_write_func2, &iis,

RUBY_UBF_IO, NULL);

}

static long

io_writable_length(rb_io_t *fptr, long l)

{

if (PIPE_BUF < l &&

!rb_thread_alone() &&

wsplit_p(fptr)) {

l = PIPE_BUF;

}

return l;

}

static VALUE

io_flush_buffer_sync(void *arg)

{

rb_io_t *fptr = arg;

long l = io_writable_length(fptr, fptr->wbuf.len);

ssize_t r = write(fptr->fd, fptr->wbuf.ptr+fptr->wbuf.off, (size_t)l);

if (fptr->wbuf.len <= r) {

fptr->wbuf.off = 0;

fptr->wbuf.len = 0;

return 0;

}