#ifndef RUBY_IO_H /*-*-C++-*-vi:se ft=cpp:*/ #define RUBY_IO_H 1 /** * @file * @author $Author$ * @date Fri Nov 12 16:47:09 JST 1993 * @copyright Copyright (C) 1993-2007 Yukihiro Matsumoto * @copyright This file is a part of the programming language Ruby. * Permission is hereby granted, to either redistribute and/or * modify this file, provided that the conditions mentioned in the * file COPYING are met. Consult the file for details. */ #include "ruby/internal/config.h" #include #include "ruby/encoding.h" #if defined(HAVE_STDIO_EXT_H) #include #endif #include /** @cond INTERNAL_MACRO */ #if defined(HAVE_POLL) # ifdef _AIX # define reqevents events # define rtnevents revents # endif # include # ifdef _AIX # undef reqevents # undef rtnevents # undef events # undef revents # endif # define RB_WAITFD_IN POLLIN # if defined(POLLPRI) # define RB_WAITFD_PRI POLLPRI # else # define RB_WAITFD_PRI 0 # endif # define RB_WAITFD_OUT POLLOUT #else # define RB_WAITFD_IN 0x001 # define RB_WAITFD_PRI 0x002 # define RB_WAITFD_OUT 0x004 #endif /** @endcond */ #include "ruby/internal/attr/const.h" #include "ruby/internal/attr/packed_struct.h" #include "ruby/internal/attr/pure.h" #include "ruby/internal/attr/noreturn.h" #include "ruby/internal/dllexport.h" #include "ruby/internal/value.h" // IO#wait, IO#wait_readable, IO#wait_writable, IO#wait_priority are defined by this implementation. #define RUBY_IO_WAIT_METHODS // Used as the default timeout argument to `rb_io_wait` to use the `IO#timeout` value. #define RUBY_IO_TIMEOUT_DEFAULT Qnil RBIMPL_SYMBOL_EXPORT_BEGIN() struct stat; struct timeval; /** * Indicates that a timeout has occurred while performing an IO operation. */ RUBY_EXTERN VALUE rb_eIOTimeoutError; /** * Type of events that an IO can wait. * * @internal * * This is visible from extension libraries because `io/wait` wants it. */ enum rb_io_event { RUBY_IO_READABLE = RB_WAITFD_IN, /**< `IO::READABLE` */ RUBY_IO_WRITABLE = RB_WAITFD_OUT, /**< `IO::WRITABLE` */ RUBY_IO_PRIORITY = RB_WAITFD_PRI, /**< `IO::PRIORITY` */ }; typedef enum rb_io_event rb_io_event_t; /** * IO buffers. This is an implementation detail of ::rb_io_t::wbuf and * ::rb_io_t::rbuf. People don't manipulate it directly. */ RBIMPL_ATTR_PACKED_STRUCT_UNALIGNED_BEGIN() struct rb_io_internal_buffer { /** Pointer to the underlying memory region, of at least `capa` bytes. */ char *ptr; /* off + len <= capa */ /** Offset inside of `ptr`. */ int off; /** Length of the buffer. */ int len; /** Designed capacity of the buffer. */ int capa; } RBIMPL_ATTR_PACKED_STRUCT_UNALIGNED_END(); /** @alias{rb_io_buffer_t} */ typedef struct rb_io_internal_buffer rb_io_buffer_t; /** Decomposed encoding flags (e.g. `"enc:enc2""`). */ /* * enc enc2 read action write action * NULL NULL force_encoding(default_external) write the byte sequence of str * e1 NULL force_encoding(e1) convert str.encoding to e1 * e1 e2 convert from e2 to e1 convert str.encoding to e2 */ struct rb_io_encoding { /** Internal encoding. */ rb_encoding *enc; /** External encoding. */ rb_encoding *enc2; /** * Flags. * * @see enum ::ruby_econv_flag_type */ int ecflags; /** * Flags as Ruby hash. * * @internal * * This is set. But used from nowhere maybe? */ VALUE ecopts; }; #ifndef HAVE_RB_IO_T #define HAVE_RB_IO_T 1 /** Ruby's IO, metadata and buffers. */ struct rb_io { /** The IO's Ruby level counterpart. */ RBIMPL_ATTR_DEPRECATED(("with no replacement")) VALUE self; /** stdio ptr for read/write, if available. */ RBIMPL_ATTR_DEPRECATED(("with no replacement")) FILE *stdio_file; /** file descriptor. */ RBIMPL_ATTR_DEPRECATED(("rb_io_descriptor")) int fd; /** mode flags: FMODE_XXXs */ RBIMPL_ATTR_DEPRECATED(("rb_io_mode")) int mode; /** child's pid (for pipes) */ RBIMPL_ATTR_DEPRECATED(("with no replacement")) rb_pid_t pid; /** number of lines read */ RBIMPL_ATTR_DEPRECATED(("with no replacement")) int lineno; /** pathname for file */ RBIMPL_ATTR_DEPRECATED(("rb_io_path")) VALUE pathv; /** finalize proc */ RBIMPL_ATTR_DEPRECATED(("with no replacement")) void (*finalize)(struct rb_io*,int); /** Write buffer. */ RBIMPL_ATTR_DEPRECATED(("with no replacement")) rb_io_buffer_t wbuf; /** * (Byte) read buffer. Note also that there is a field called * ::rb_io_t::cbuf, which also concerns read IO. */ RBIMPL_ATTR_DEPRECATED(("with no replacement")) rb_io_buffer_t rbuf; /** * Duplex IO object, if set. * * @see rb_io_set_write_io() */ RBIMPL_ATTR_DEPRECATED(("rb_io_get_write_io")) VALUE tied_io_for_writing; RBIMPL_ATTR_DEPRECATED(("with no replacement")) struct rb_io_encoding encs; /**< Decomposed encoding flags. */ /** Encoding converter used when reading from this IO. */ RBIMPL_ATTR_DEPRECATED(("with no replacement")) rb_econv_t *readconv; /** * rb_io_ungetc() destination. This buffer is read before checking * ::rb_io_t::rbuf */ RBIMPL_ATTR_DEPRECATED(("with no replacement")) rb_io_buffer_t cbuf; /** Encoding converter used when writing to this IO. */ RBIMPL_ATTR_DEPRECATED(("with no replacement")) rb_econv_t *writeconv; /** * This is, when set, an instance of ::rb_cString which holds the "common" * encoding. Write conversion can convert strings twice... In case * conversion from encoding X to encoding Y does not exist, Ruby finds an * encoding Z that bridges the two, so that X to Z to Y conversion happens. */ RBIMPL_ATTR_DEPRECATED(("with no replacement")) VALUE writeconv_asciicompat; /** Whether ::rb_io_t::writeconv is already set up. */ RBIMPL_ATTR_DEPRECATED(("with no replacement")) int writeconv_initialized; /** * Value of ::rb_io_t::rb_io_enc_t::ecflags stored right before * initialising ::rb_io_t::writeconv. */ RBIMPL_ATTR_DEPRECATED(("with no replacement")) int writeconv_pre_ecflags; /** * Value of ::rb_io_t::rb_io_enc_t::ecopts stored right before initialising * ::rb_io_t::writeconv. */ RBIMPL_ATTR_DEPRECATED(("with no replacement")) VALUE writeconv_pre_ecopts; /** * This is a Ruby level mutex. It avoids multiple threads to write to an * IO at once; helps for instance rb_io_puts() to ensure newlines right * next to its arguments. * * This of course doesn't help inter-process IO interleaves, though. */ RBIMPL_ATTR_DEPRECATED(("with no replacement")) VALUE write_lock; /** * The timeout associated with this IO when performing blocking operations. */ RBIMPL_ATTR_DEPRECATED(("rb_io_timeout/rb_io_set_timeout")) VALUE timeout; }; #endif typedef struct rb_io rb_io_t; /** @alias{rb_io_enc_t} */ typedef struct rb_io_encoding rb_io_enc_t; /** * @name Possible flags for ::rb_io_t::mode * * @{ */ /** The IO is opened for reading. */ #define FMODE_READABLE 0x00000001 /** The IO is opened for writing. */ #define FMODE_WRITABLE 0x00000002 /** The IO is opened for both read/write. */ #define FMODE_READWRITE (FMODE_READABLE|FMODE_WRITABLE) /** * The IO is in "binary mode". This is not what everything rb_io_binmode() * concerns. This low-level flag is to stop CR <-> CRLF conversions that would * happen in the underlying operating system. * * Setting this one and #FMODE_TEXTMODE at the same time is a contradiction. * Setting this one and #ECONV_NEWLINE_DECORATOR_MASK at the same time is also * a contradiction. */ #define FMODE_BINMODE 0x00000004 /** * The IO is in "sync mode". All output is immediately flushed to the * underlying operating system then. Can be set via rb_io_synchronized(), but * there is no way except calling `IO#sync=` to reset. */ #define FMODE_SYNC 0x00000008 /** * The IO is a TTY. What is a TTY and what isn't depends on the underlying * operating system's `isatty(3)` output. You cannot change this. */ #define FMODE_TTY 0x00000010 /** * Ruby eventually detects that the IO is bidirectional. For instance a TTY * has such property. There are several other things known to be duplexed. * Additionally you (extension library authors) can also implement your own * bidirectional IO subclasses. One of such example is `Socket`. */ #define FMODE_DUPLEX 0x00000020 /** * The IO is opened for appending. This mode always writes at the end of the * IO. Ruby manages this flag for record but basically the logic behind this * mode is at the underlying operating system. We almost do nothing. */ #define FMODE_APPEND 0x00000040 /** * The IO is opened for creating. This makes sense only when the destination * file does not exist at the time the IO object was created. This is the * default mode for writing, but you can pass `"r+"` to `IO.open` etc., to * reroute this creation. */ #define FMODE_CREATE 0x00000080 /* #define FMODE_NOREVLOOKUP 0x00000100 */ /** * This flag amends the effect of #FMODE_CREATE, so that if there already is a * file at the given path the operation fails. Using this you can be sure that * the file you get is a fresh new one. */ #define FMODE_EXCL 0x00000400 /** * This flag amends the effect of #FMODE_CREATE, so that if there already is a * file at the given path it gets truncated. */ #define FMODE_TRUNC 0x00000800 /** * The IO is in "text mode". On systems where such mode make sense, this flag * changes the way the IO handles the contents. On POSIX systems it is * basically a no-op, but with this flag set you can optionally let Ruby * manually convert newlines, unlike when in binary mode: * * ```ruby * IO.open("/p/a/t/h", "wt", crlf_newline: true) # "wb" is NG. * ``` * * Setting this one and #FMODE_BINMODE at the same time is a contradiction. */ #define FMODE_TEXTMODE 0x00001000 /** * This flag means that an IO object is wrapping an "external" file descriptor, * which is owned by something outside the Ruby interpreter (usually a C extension). * Ruby will not close this file when the IO object is garbage collected. * If this flag is set, then IO#autoclose? is false, and vice-versa. * * This flag was previously called FMODE_PREP internally. */ #define FMODE_EXTERNAL 0x00010000 /* #define FMODE_SIGNAL_ON_EPIPE 0x00020000 */ /** * This flag amends the encoding of the IO so that the BOM of the contents of * the IO takes effect. */ #define FMODE_SETENC_BY_BOM 0x00100000 /* #define FMODE_UNIX 0x00200000 */ /* #define FMODE_INET 0x00400000 */ /* #define FMODE_INET6 0x00800000 */ /** @} */ /** * Allocate a new IO object, with the given file descriptor. */ VALUE rb_io_open_descriptor(VALUE klass, int descriptor, int mode, VALUE path, VALUE timeout, struct rb_io_encoding *encoding); /** * Returns whether or not the underlying IO is closed. * * @return Whether the underlying IO is closed. */ VALUE rb_io_closed_p(VALUE io); /** * Queries the underlying IO pointer. * * @param[in] obj An IO object. * @param[out] fp A variable of type ::rb_io_t. * @exception rb_eFrozenError `obj` is frozen. * @exception rb_eIOError `obj` is closed. * @post `fp` holds `obj`'s underlying IO. */ #define RB_IO_POINTER(obj,fp) rb_io_check_closed((fp) = RFILE(rb_io_taint_check(obj))->fptr) /** * This is an old name of #RB_IO_POINTER. Not sure if we want to deprecate * this macro. There still are tons of usages out there in the wild. */ #define GetOpenFile RB_IO_POINTER /** * Fills an IO object. This makes the best sense when called from inside of an * `#initialize` method of a 3rd party extension library that inherits * ::rb_cIO. * * If the passed IO is already opened for something it first closes that and * opens a new one instead. * * @param[out] obj An IO object to fill in. * @param[out] fp A variable of type ::rb_io_t. * @exception rb_eTypeError `obj` is not ::RUBY_T_FILE. * @post `fp` holds `obj`'s underlying IO. */ #define RB_IO_OPEN(obj, fp) do {\ (fp) = rb_io_make_open_file(obj);\ } while (0) /** * This is an old name of #RB_IO_OPEN. Not sure if we want to deprecate this * macro. There still are usages out there in the wild. */ #define MakeOpenFile RB_IO_OPEN /** * @private * * This is an implementation detail of #RB_IO_OPEN. People don't use it * directly. * * @param[out] obj An IO object to fill in. * @exception rb_eTypeError `obj` is not ::RUBY_T_FILE. * @return `obj`'s backend IO. * @post `obj` is initialised. */ rb_io_t *rb_io_make_open_file(VALUE obj); /** * Finds or creates a stdio's file structure from a Ruby's one. This can be * handy if you want to call an external API that accepts `FILE *`. * * @note Note however, that `FILE`s can have their own buffer. Mixing Ruby's * and stdio's file are basically dangerous. Use with care. * * @param[in,out] fptr Target IO. * @return A stdio's file, created if absent. * @post `fptr` has its corresponding stdio's file. * * @internal * * We had rich support for `FILE` before! In the days of 1.8.x ::rb_io_t was * like this: * * ```CXX * typedef struct rb_io { * FILE *f; // stdio ptr for read/write * FILE *f2; // additional ptr for rw pipes * int mode; // mode flags * int pid; // child's pid (for pipes) * int lineno; // number of lines read * char *path; // pathname for file * void (*finalize) _((struct rb_io*,int)); // finalize proc * } rb_io_t; *``` * * But we eventually abandoned this layout. It was too difficult. We could * not have fine-grained control over the `f` field. * * - `FILE` tends to be an opaque struct. It does not interface well with * `select(2)` etc. This makes IO multiplexing quite hard. Using stdio, * there is arguably no portable way to know if `fwrite(3)` blocks. * * - Nonblocking mode, which is another core concept that enables IO * multiplexing, does not interface with stdio routines at all. * * - Detection of duplexed IO is also hard for the same reason. * * - `feof(3)` is not portable. * https://mail.python.org/pipermail/python-dev/2001-January/011390.html * * - Solaris was a thing back then. They could not have more than 256 `FILE` * structures at a time. Their file descriptors ware stored in an * `unsigned char`. * * - It is next to impossible to avoid SEGV, especially when a thread tries to * `ungetc(3)`-ing from a `FILE` which is `fread(3)`-ed by another one. * * In short, it is a bad idea to let someone else manage IO buffers, especially * someone you cannot control. This still applies to extension libraries * methinks. Ruby doesn't prevent you from shooting yourself in the foot, but * consider yourself warned here. */ FILE *rb_io_stdio_file(rb_io_t *fptr); /** * Identical to rb_io_stdio_file(), except it takes file descriptors instead of * Ruby's IO. It can also be seen as a compatibility layer to wrap * `fdopen(3)`. Nowadays all supporting systems, including Windows, have * `fdopen`. Why not use them. * * @param[in] fd A file descriptor. * @param[in] modestr C string, something like `"r+"`. * @exception rb_eSystemCallError `fdopen` failed for some reason. * @return A stdio's file associated with `fd`. * @note Interpretation of `modestr` depends on the underlying operating * system. On glibc you might be able to pass e.g. `"rm"`, but * that's an extension to POSIX. */ FILE *rb_fdopen(int fd, const char *modestr); /** * Maps a file mode string (that rb_file_open() takes) into a mixture of * `FMODE_` flags. This for instance returns * `FMODE_WRITABLE | FMODE_TRUNC | FMODE_CREATE | FMODE_EXCL` for `"wx"`. * * @note You cannot pass this return value to OS provided `open(2)` etc. * * @param[in] modestr File mode, in C's string. * @exception rb_eArgError `modestr` is broken. * @return A set of flags. * * @internal * * rb_io_modestr_fmode() is not a pure function because it raises. */ int rb_io_modestr_fmode(const char *modestr); /** * Identical to rb_io_modestr_fmode(), except it returns a mixture of `O_` * flags. This for instance returns `O_WRONLY | O_TRUNC | O_CREAT | O_EXCL` for * `"wx"`. * * @param[in] modestr File mode, in C's string. * @exception rb_eArgError `modestr` is broken. * @return A set of flags. * * @internal * * rb_io_modestr_oflags() is not a pure function because it raises. */ int rb_io_modestr_oflags(const char *modestr); RBIMPL_ATTR_CONST() /** * Converts an oflags (that rb_io_modestr_oflags() returns) to a fmode (that * rb_io_mode_flags() returns). This is a purely functional operation. * * @param[in] oflags A set of `O_` flags. * @return Corresponding set of `FMODE_` flags. */ int rb_io_oflags_fmode(int oflags); /** * Asserts that an IO is opened for writing. * * @param[in] fptr An IO you want to write to. * @exception rb_eIOError `fptr` is not for writing. * @post Upon successful return `fptr` is ready for writing. * * @internal * * The parameter must have been `const rb_io_t *`. */ void rb_io_check_writable(rb_io_t *fptr); /** @alias{rb_io_check_byte_readable} */ void rb_io_check_readable(rb_io_t *fptr); /** * Asserts that an IO is opened for character-based reading. A character can * be wider than a byte. Because of this we have to buffer reads from * descriptors. This fiction checks if that is possible. * * @param[in] fptr An IO you want to read characters from. * @exception rb_eIOError `fptr` is not for reading. * @post Upon successful return `fptr` is ready for reading characters. * * @internal * * Unlike rb_io_check_writable() the parameter cannot be `const rb_io_t *`. * Behind the scene this operation flushes its write buffers. This is because * of OpenSSL. They mandate this way. * * @see "Can I use OpenSSL's SSL library with non-blocking I/O?" * https://www.openssl.org/docs/faq.html */ void rb_io_check_char_readable(rb_io_t *fptr); /** * Asserts that an IO is opened for byte-based reading. Byte-based and * character-based reading operations cannot be mixed at a time. * * @param[in] fptr An IO you want to read characters from. * @exception rb_eIOError `fptr` is not for reading. * @post Upon successful return `fptr` is ready for reading bytes. */ void rb_io_check_byte_readable(rb_io_t *fptr); /** * Destroys the given IO. Any pending operations are flushed. * * @note It makes no sense to call this function from anywhere outside of your * class' ::rb_data_type_struct::dfree. * * @param[out] fptr IO to close. * @post `fptr` is no longer a valid pointer. */ int rb_io_fptr_finalize(rb_io_t *fptr); /** * Sets #FMODE_SYNC. * * @note There is no way for C extensions to undo this operation. * * @param[out] fptr IO to set the flag. * @exception rb_eIOError `fptr` is not opened. * @post `fptr` is in sync mode. */ void rb_io_synchronized(rb_io_t *fptr); /** * Asserts that the passed IO is initialised. * * @param[in] fptr IO that you expect be initialised. * @exception rb_eIOError `fptr` is not initialised. * @post `fptr` is initialised. */ void rb_io_check_initialized(rb_io_t *fptr); /** * This badly named function asserts that the passed IO is _open_. * * @param[in] fptr An IO * @exception rb_eIOError `fptr` is closed. * @post `fptr` is open. */ void rb_io_check_closed(rb_io_t *fptr); /** * Identical to rb_io_check_io(), except it raises exceptions on conversion * failures. * * @param[in] io Target object. * @exception rb_eTypeError No implicit conversion to IO. * @return Return value of `obj.to_io`. * @see rb_str_to_str * @see rb_ary_to_ary */ VALUE rb_io_get_io(VALUE io); /** * Try converting an object to its IO representation using its `to_io` method, * if any. If there is no such thing, returns ::RUBY_Qnil. * * @param[in] io Arbitrary ruby object to convert. * @exception rb_eTypeError `obj.to_io` returned something non-IO. * @retval RUBY_Qnil No conversion from `obj` to IO defined. * @retval otherwise Converted IO representation of `obj`. * @see rb_check_array_type * @see rb_check_string_type * @see rb_check_hash_type */ VALUE rb_io_check_io(VALUE io); /** * Queries the tied IO for writing. An IO can be duplexed. Fine. The thing * is, that characteristics could sometimes be achieved by the underlying * operating system (for instance a socket's duplexity is by nature) but * sometimes by us. Notable example is a bidirectional pipe. Suppose you * have: * * ```ruby * fp = IO.popen("-", "r+") * ``` * * This pipe is duplexed (the `"r+"`). You can both read from/write to it. * However your operating system may or may not implement bidirectional pipes. * FreeBSD is one of such operating systems known to have one; OTOH Linux is * known to lack such things. So to achieve maximum portability, Ruby's * bidirectional pipes are done purely in user land. A pipe in ruby can have * multiple file descriptors; one for reading and the other for writing. This * API is to obtain the IO port which corresponds to the passed one, for * writing. * * @param[in] io An IO. * @return Its tied IO for writing, if any, or `io` itself otherwise. */ VALUE rb_io_get_write_io(VALUE io); /** * Assigns the tied IO for writing. See rb_io_get_write_io() for what a "tied * IO for writing" is. * * @param[out] io An IO. * @param[in] w Another IO. * @retval RUBY_Qnil There was no tied IO for writing for `io`. * @retval otherwise The IO formerly tied to `io`. * @post `io` ties `w` for writing. * * @internal * * @shyouhei doesn't think there is any needs of this function for 3rd party * extension libraries. */ VALUE rb_io_set_write_io(VALUE io, VALUE w); /** * Instructs the OS to put its internal file structure into "nonblocking mode". * This is an in-Kernel concept. Reading from/writing to that file using C * function calls would return -1 with errno set. However when it comes to a * ruby program, we hide that error behind our `IO#read` method. Ruby level * `IO#read` blocks regardless of this flag. If you want to avoid blocking, * you should consider using methods like `IO#readpartial`. * * ```ruby * require 'io/nonblock' * STDIN.nonblock = true * STDIN.gets # blocks. * ``` * * As of writing there is a room of this API in Fiber schedulers. A Fiber * scheduler could be written in a way its behaviour depends on this property. * You need an in-depth understanding of how schedulers work to properly * leverage this, though. * * @note Note however that nonblocking-ness propagates across process * boundaries. You must really carefully watch your step when turning * for instance `stderr` into nonblock mode (it tends to be shared * across many processes). Also it is a complete disaster to mix a * nonblocking file and stdio, and `stderr` tends to be under control of * stdio in other processes. * * @param[out] fptr An IO that is to ne nonblocking. * @post Descriptor that `fptr` describes is under nonblocking mode. * * @internal * * There is `O_NONBLOCK` but not `FMODE_NONBLOCK`. You cannot atomically * create a nonblocking file descriptor using our API. */ void rb_io_set_nonblock(rb_io_t *fptr); /** * Returns the path for the given IO. * */ VALUE rb_io_path(VALUE io); /** * Returns an integer representing the numeric file descriptor for * io. * * @param[in] io An IO. * @retval int A file descriptor. */ int rb_io_descriptor(VALUE io); /** * Get the mode of the IO. * */ int rb_io_mode(VALUE io); /** * This function breaks down the option hash that `IO#initialize` takes into * components. This is an implementation detail of rb_io_extract_modeenc() * today. People prefer that API instead. * * @param[in] opt The hash to decompose. * @param[out] enc_p Return value buffer. * @param[out] enc2_p Return value buffer. * @param[out] fmode_p Return value buffer. * @exception rb_eTypeError `opt` is broken. * @exception rb_eArgError Specified encoding does not exist. * @retval 1 Components got extracted. * @retval 0 Otherwise. * @post `enc_p` is the specified internal encoding. * @post `enc2_p` is the specified external encoding. * @post `fmode_p` is the specified set of `FMODE_` modes. */ int rb_io_extract_encoding_option(VALUE opt, rb_encoding **enc_p, rb_encoding **enc2_p, int *fmode_p); /** * This function can be seen as an extended version of * rb_io_extract_encoding_option() that not only concerns the option hash but * also mode string and so on. This should be mixed with rb_scan_args() like: * * ```CXX * // This method mimics File.new * static VALUE * your_method(int argc, const VALUE *argv, VALUE self) * { * VALUE f; // file name * VALUE m; // open mode * VALUE p; // permission (O_CREAT) * VALUE k; // keywords * rb_io_enc_t c; // converter * int oflags; * int fmode; * * int n = rb_scan_args(argc, argv, "12:", &f, &m, &p, &k); * rb_io_extract_modeenc(&m, &p, k, &oflags, &fmode, &c); * * // Every local variables declared so far has been properly filled here. * ... * } * ``` * * @param[in,out] vmode_p Pointer to a mode object. * @param[in,out] vperm_p Pointer to a permission object. * @param[in] opthash Keyword arguments * @param[out] oflags_p `O_` flags return buffer. * @param[out] fmode_p `FMODE_` flags return buffer. * @param[out] convconfig_p Encoding config return buffer. * @exception rb_eTypeError Unexpected object (e.g. Time) passed. * @exception rb_eArgError Contradiction inside of params. * @post `*vmode_p` is a mode object (filled if any). * @post `*vperm_p` is a permission object (filled if any). * @post `*oflags_p` is filled with `O_` flags. * @post `*fmode_p` is filled with `FMODE_` flags. * @post `*convconfig_p` is filled with conversion instructions. * * @internal * * ```rbs * class File * def initialize: ( * (String | int) path, * ?(String | int) fmode, * ?(String | int) perm, * ?mode: (String | int), * ?flags: int, * ?external_encoding: (Encoding | String), * ?internal_encoding: (Encoding | String), * ?encoding: String, * ?textmode: bool, * ?binmode: bool, * ?autoclose: bool, * ?invalid: :replace, * ?undef: :replace, * ?replace: String, * ?fallback: (Hash | Proc | Method), * ?xml: (:text | :attr), * ?crlf_newline: bool, * ?cr_newline: bool, * ?universal_newline: bool * ) -> void * ``` */ void rb_io_extract_modeenc(VALUE *vmode_p, VALUE *vperm_p, VALUE opthash, int *oflags_p, int *fmode_p, rb_io_enc_t *convconfig_p); /* :TODO: can this function be __attribute__((warn_unused_result)) or not? */ /** * Buffered write to the passed IO. * * @param[out] io Destination IO. * @param[in] buf Contents to go to `io`. * @param[in] size Number of bytes of `buf`. * @exception rb_eFrozenError `io` is frozen. * @exception rb_eIOError `io` is not open for writing. * @exception rb_eSystemCallError `writev(2)` failed for some reason. * @retval -1 Write failed. * @retval otherwise Number of bytes actually written. * @post `buf` is written to `io`. * @note Partial write is a thing. It is a failure not to check the * return value. */ ssize_t rb_io_bufwrite(VALUE io, const void *buf, size_t size); //RBIMPL_ATTR_DEPRECATED(("use rb_io_maybe_wait_readable")) /** * Blocks until the passed file descriptor gets readable. * * @deprecated We now prefer rb_io_maybe_wait_readable() over this one. * @param[in] fd The file descriptor to wait. * @exception rb_eIOError Bad file descriptor. * @return 0 or 1 (meaning unclear). * @post `fd` is ready for reading. */ int rb_io_wait_readable(int fd); //RBIMPL_ATTR_DEPRECATED(("use rb_io_maybe_wait_writable")) /** * Blocks until the passed file descriptor gets writable. * * @deprecated We now prefer rb_io_maybe_wait_writable() over this one. * @param[in] fd The file descriptor to wait. * @exception rb_eIOError Bad file descriptor. * @return 0 or 1 (meaning unclear). */ int rb_io_wait_writable(int fd); //RBIMPL_ATTR_DEPRECATED(("use rb_io_wait")) /** * Blocks until the passed file descriptor is ready for the passed events. * * @deprecated We now prefer rb_io_maybe_wait() over this one. * @param[in] fd The file descriptor to wait. * @param[in] events A set of enum ::rb_io_event_t. * @param[in,out] tv Timeout. * @retval 0 Operation timed out. * @retval -1 `select(2)` failed for some reason. * @retval otherwise A set of enum ::rb_io_event_t. * @note Depending on your operating system `tv` might or might not * be updated (POSIX permits both). Portable programs must * have no assumptions. */ int rb_wait_for_single_fd(int fd, int events, struct timeval *tv); /** * Get the timeout associated with the specified io object. * * @param[in] io An IO object. * @retval RUBY_Qnil There is no associated timeout. * @retval Otherwise The timeout value. */ VALUE rb_io_timeout(VALUE io); /** * Set the timeout associated with the specified io object. This timeout is * used as a best effort timeout to prevent operations from blocking forever. * * @param[in] io An IO object. * @param[in] timeout A timeout value. Must respond to #to_f. * @ */ VALUE rb_io_set_timeout(VALUE io, VALUE timeout); /** * Blocks until the passed IO is ready for the passed events. The "events" * here is a Ruby level integer, which is an OR-ed value of `IO::READABLE`, * `IO::WRITable`, and `IO::PRIORITY`. * * If timeout is `Qnil`, it will use the default timeout as given by * `rb_io_timeout(io)`. * * @param[in] io An IO object to wait. * @param[in] events See above. * @param[in] timeout Time, or numeric seconds since UNIX epoch. * If Qnil, use the default timeout. If Qfalse * or Qundef, wait forever. * @exception rb_eIOError `io` is not open. * @exception rb_eRangeError `timeout` is out of range. * @exception rb_eSystemCallError `select(2)` failed for some reason. * @retval RUBY_Qfalse Operation timed out. * @retval Otherwise Actual events reached. */ VALUE rb_io_wait(VALUE io, VALUE events, VALUE timeout); /** * Identical to rb_io_wait() except it additionally takes previous errno. If * the passed errno indicates for instance `EINTR`, this function returns * immediately. This is expected to be called in a loop. * * ```CXX * while (true) { * * ... // Your interesting operation here * // `errno` could be updated * * rb_io_maybe_wait(errno, io, ev, Qnil); * } * ``` * * @param[in] error System errno. * @param[in] io An IO object to wait. * @param[in] events An integer set of interests. * @param[in] timeout Time, or numeric seconds since UNIX epoch. * @exception rb_eIOError `io` is not open. * @exception rb_eRangeError `timeout` is out of range. * @exception rb_eSystemCallError `select(2)` failed for some reason. * @retval RUBY_Qfalse Operation timed out. * @retval Otherwise Actual events reached. * * @internal * * This function to return ::RUBY_Qfalse on timeout could be unintended. It * seems timeout feature has some rough edge. */ VALUE rb_io_maybe_wait(int error, VALUE io, VALUE events, VALUE timeout); /** * Blocks until the passed IO is ready for reading, if that makes sense for the * passed errno. This is a special case of rb_io_maybe_wait() that only * concerns for reading. * * @param[in] error System errno. * @param[in] io An IO object to wait. * @param[in] timeout Time, or numeric seconds since UNIX epoch. * @exception rb_eIOError `io` is not open. * @exception rb_eRangeError `timeout` is out of range. * @exception rb_eSystemCallError `select(2)` failed for some reason. * @retval 0 Operation timed out. * @retval Otherwise Always returns ::RUBY_IO_READABLE. */ int rb_io_maybe_wait_readable(int error, VALUE io, VALUE timeout); /** * Blocks until the passed IO is ready for writing, if that makes sense for the * passed errno. This is a special case of rb_io_maybe_wait() that only * concernsfor writing. * * @param[in] error System errno. * @param[in] io An IO object to wait. * @param[in] timeout Time, or numeric seconds since UNIX epoch. * @exception rb_eIOError `io` is not open. * @exception rb_eRangeError `timeout` is out of range. * @exception rb_eSystemCallError `select(2)` failed for some reason. * @retval 0 Operation timed out. * @retval Otherwise Always returns ::RUBY_IO_WRITABLE. */ int rb_io_maybe_wait_writable(int error, VALUE io, VALUE timeout); /** @cond INTERNAL_MACRO */ /* compatibility for ruby 1.8 and older */ #define rb_io_mode_flags(modestr) [<"rb_io_mode_flags() is obsolete; use rb_io_modestr_fmode()">] #define rb_io_modenum_flags(oflags) [<"rb_io_modenum_flags() is obsolete; use rb_io_oflags_fmode()">] /** @endcond */ /** * @deprecated This function once was a thing in the old days, but makes no * sense any longer today. Exists here for backwards * compatibility only. You can safely forget about it. * * @param[in] obj Object in question. * @exception rb_eFrozenError obj is frozen. * @return The passed `obj` */ VALUE rb_io_taint_check(VALUE obj); RBIMPL_ATTR_NORETURN() /** * Utility function to raise ::rb_eEOFError. * * @exception rb_eEOFError End of file situation. * @note It never returns. */ void rb_eof_error(void); /** * Blocks until there is a pending read in the passed IO. If there already is * it just returns. * * @param[out] fptr An IO to wait for reading. * @post The are bytes to be read. */ void rb_io_read_check(rb_io_t *fptr); RBIMPL_ATTR_PURE() /** * Queries if the passed IO has any pending reads. Unlike rb_io_read_check() * this doesn't block; has no side effects. * * @param[in] fptr An IO which can have pending reads. * @retval 0 The IO is empty. * @retval 1 There is something buffered. */ int rb_io_read_pending(rb_io_t *fptr); /** * Constructs an instance of ::rb_cStat from the passed information. * * @param[in] st A stat. * @return Allocated new instance of ::rb_cStat. */ VALUE rb_stat_new(const struct stat *st); /* gc.c */ RBIMPL_SYMBOL_EXPORT_END() #endif /* RUBY_IO_H */