自学教程：C++ GetOpenFile函数代码示例

/* * call-seq: *   basicsocket.getpeereid => [euid, egid] * * Returns the user and group on the peer of the UNIX socket. * The result is a two element array which contains the effective uid and the effective gid. * *   Socket.unix_server_loop("/tmp/sock") {|s| *     begin *       euid, egid = s.getpeereid * *       # Check the connected client is myself or not. *       next if euid != Process.uid * *       # do something about my resource. * *     ensure *       s.close *     end *   } * */static VALUEbsock_getpeereid(VALUE self){UNRUBBY_SOCKET_HACK;#if defined(HAVE_GETPEEREID)    rb_io_t *fptr;    uid_t euid;    gid_t egid;    GetOpenFile(self, fptr);    if (getpeereid(fptr->fd, &euid, &egid) == -1)	rb_sys_fail("getpeereid");    return rb_assoc_new(UIDT2NUM(euid), GIDT2NUM(egid));#elif defined(SO_PEERCRED) /* GNU/Linux */    rb_io_t *fptr;    struct ucred cred;    socklen_t len = sizeof(cred);    GetOpenFile(self, fptr);    if (getsockopt(fptr->fd, SOL_SOCKET, SO_PEERCRED, &cred, &len) == -1)	rb_sys_fail("getsockopt(SO_PEERCRED)");    return rb_assoc_new(UIDT2NUM(cred.uid), GIDT2NUM(cred.gid));#elif defined(HAVE_GETPEERUCRED) /* Solaris */    rb_io_t *fptr;    ucred_t *uc = NULL;    VALUE ret;    GetOpenFile(self, fptr);    if (getpeerucred(fptr->fd, &uc) == -1)	rb_sys_fail("getpeerucred");    ret = rb_assoc_new(UIDT2NUM(ucred_geteuid(uc)), GIDT2NUM(ucred_getegid(uc)));    ucred_free(uc);    return ret;#endif}

static VALUEttymode(VALUE io, VALUE (*func)(VALUE), void (*setter)(conmode *, void *), void *arg){    rb_io_t *fptr;    int status = -1;    int error = 0;    int fd[FD_PER_IO];    conmode t[FD_PER_IO];    VALUE result = Qnil;    GetOpenFile(io, fptr);    fd[0] = GetReadFD(fptr);    if (fd[0] != -1) {	if (set_ttymode(fd[0], t+0, setter, arg)) {	    status = 0;	}	else {	    error = errno;	    fd[0] = -1;	}    }    fd[1] = GetWriteFD(fptr);    if (fd[1] != -1 && fd[1] != fd[0]) {	if (set_ttymode(fd[1], t+1, setter, arg)) {	    status = 0;	}	else {	    error = errno;	    fd[1] = -1;	}    }    if (status == 0) {	result = rb_protect(func, io, &status);    }    GetOpenFile(io, fptr);    if (fd[0] != -1 && fd[0] == GetReadFD(fptr)) {	if (!setattr(fd[0], t+0)) {	    error = errno;	    status = -1;	}    }    if (fd[1] != -1 && fd[1] != fd[0] && fd[1] == GetWriteFD(fptr)) {	if (!setattr(fd[1], t+1)) {	    error = errno;	    status = -1;	}    }    if (status) {	if (status == -1) {	    errno = error;	    rb_sys_fail(0);	}	rb_jump_tag(status);    }    return result;}

VALUE frostbitten_message_write_to_io(VALUE self, VALUE io) {	fb_message *message;	Data_Get_Struct(self, fb_message, message);	frostbitten_header_write_to_io(message->header, io);	uint32_t arrayLength = (uint32_t)RARRAY_LEN(message->words);	uint32_t packetSize = 0;	char** strings = frostbitten_message_generate(message, &packetSize);	packetSize += sizeof(uint32_t); // Header	packetSize += sizeof(uint32_t); // packetSize	packetSize += sizeof(uint32_t); // wordCount	rb_io_t *fptr;	GetOpenFile(io, fptr);	rb_io_check_readable(fptr);	FILE *fp = rb_io_stdio_file(fptr);	fwrite((const void*)&packetSize,sizeof(uint32_t),1,fp);	fwrite((const void*)&arrayLength,sizeof(uint32_t),1,fp);	for(uint32_t i=0; i < arrayLength; i++) {		char *str = strings[i];		uint32_t len = (uint32_t)strlen(str);		fwrite((const void*)&len, sizeof(uint32_t), 1, fp);		fwrite(str, sizeof(char), strlen(str)+1, fp);	}	fflush(fp);	return self;}

void TextWindow::ScreenBackgroundImage(int link, uint32_t v) {    if(SS.bgImage.fromFile) MemFree(SS.bgImage.fromFile);    SS.bgImage.fromFile = NULL;    if(link == 'l') {        FILE *f = NULL;        png_struct *png_ptr = NULL;        png_info *info_ptr = NULL;        char importFile[MAX_PATH] = "";        if(!GetOpenFile(importFile, PNG_EXT, PNG_PATTERN)) goto err;        f = fopen(importFile, "rb");        if(!f) goto err;        uint8_t header[8];        if (fread(header, 1, 8, f) != 8)            goto err;        if(png_sig_cmp(header, 0, 8)) goto err;        png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,            NULL, NULL, NULL);        if(!png_ptr) goto err;        info_ptr = png_create_info_struct(png_ptr);        if(!info_ptr) goto err;        if(setjmp(png_jmpbuf(png_ptr))) goto err;        png_init_io(png_ptr, f);        png_set_sig_bytes(png_ptr, 8);        png_read_png(png_ptr, info_ptr,            PNG_TRANSFORM_EXPAND | PNG_TRANSFORM_STRIP_ALPHA, NULL);        int w; w = (int)png_get_image_width(png_ptr, info_ptr);        int h; h = (int)png_get_image_height(png_ptr, info_ptr);        uint8_t **rows; rows = png_get_rows(png_ptr, info_ptr);        // Round to next-highest powers of two, since the textures require        // that. And round up to 4, to guarantee 32-bit alignment.        int rw; rw = max(4, RoundUpToPowerOfTwo(w));        int rh; rh = max(4, RoundUpToPowerOfTwo(h));        SS.bgImage.fromFile = (uint8_t *)MemAlloc(rw*rh*3);        {for(int i = 0; i < h; i++) {            memcpy(SS.bgImage.fromFile + ((h - 1) - i)*(rw*3), rows[i], w*3);        }}        SS.bgImage.w      = w;        SS.bgImage.h      = h;        SS.bgImage.rw     = rw;        SS.bgImage.rh     = rh;        SS.bgImage.scale  = SS.GW.scale;        SS.bgImage.origin = SS.GW.offset.ScaledBy(-1);err:        if(png_ptr) png_destroy_read_struct(&png_ptr, &info_ptr, NULL);        if(f) fclose(f);    }    SS.later.showTW = true;}

static VALUEossl_ssl_setup(VALUE self){    VALUE io, v_ctx, cb;    SSL_CTX *ctx;    SSL *ssl;    rb_io_t *fptr;    Data_Get_Struct(self, SSL, ssl);    if(!ssl){        v_ctx = ossl_ssl_get_ctx(self);        Data_Get_Struct(v_ctx, SSL_CTX, ctx);        ssl = SSL_new(ctx);        if (!ssl) {            ossl_raise(eSSLError, "SSL_new:");        }        DATA_PTR(self) = ssl;        io = ossl_ssl_get_io(self);        GetOpenFile(io, fptr);        rb_io_check_readable(fptr);        rb_io_check_writable(fptr);        SSL_set_fd(ssl, TO_SOCKET(FPTR_TO_FD(fptr)));	SSL_set_ex_data(ssl, ossl_ssl_ex_ptr_idx, (void*)self);	cb = ossl_sslctx_get_verify_cb(v_ctx);	SSL_set_ex_data(ssl, ossl_ssl_ex_vcb_idx, (void*)cb);	cb = ossl_sslctx_get_client_cert_cb(v_ctx);	SSL_set_ex_data(ssl, ossl_ssl_ex_client_cert_cb_idx, (void*)cb);	cb = ossl_sslctx_get_tmp_dh_cb(v_ctx);	SSL_set_ex_data(ssl, ossl_ssl_ex_tmp_dh_callback_idx, (void*)cb);    }    return Qtrue;}

/* * call-seq: *   io.wait_writable          -> IO *   io.wait_writable(timeout) -> IO or nil * * Waits until IO writable is available or times out and returns self or * nil when EOF is reached. */static VALUEio_wait_writable(int argc, VALUE *argv, VALUE io){    rb_io_t *fptr;    int i;    VALUE timeout;    struct timeval timerec;    struct timeval *tv;    GetOpenFile(io, fptr);    rb_io_check_writable(fptr);    rb_scan_args(argc, argv, "01", &timeout);    if (NIL_P(timeout)) {	tv = NULL;    }    else {	timerec = rb_time_interval(timeout);	tv = &timerec;    }    i = rb_wait_for_single_fd(fptr->fd, RB_WAITFD_OUT, tv);    if (i < 0)	rb_sys_fail(0);    rb_io_check_closed(fptr);    if (i & RB_WAITFD_OUT)	return io;    return Qnil;}

FILE* rb_gsl_open_readfile(VALUE io, int *flag){  rb_io_t *fptr = NULL;  FILE *fp = NULL;  char *name;  switch (TYPE(io)) {  case T_STRING:    name = RSTRING_PTR(io);    fp = fopen(name, "r");    *flag = 1;    break;  case T_FILE:    GetOpenFile(io, fptr);    rb_io_check_readable(fptr);    fp = rb_io_stdio_file(fptr);    *flag = 0;    break;  default:    rb_raise(rb_eTypeError, "argv 1 String or File expected");    break;  }  //  if (fp == NULL) rb_raise(rb_eIOError, "Cannot open file %s.", name);  if (fp == NULL) rb_raise(rb_eIOError, "Cannot open file");  return fp;}

static VALUEio_wait_readable(int argc, VALUE *argv, VALUE io){    rb_io_t *fptr;    int i;    ioctl_arg n;    VALUE timeout;    struct timeval timerec;    struct timeval *tv;    GetOpenFile(io, fptr);    rb_io_check_readable(fptr);    rb_scan_args(argc, argv, "01", &timeout);    if (NIL_P(timeout)) {	tv = NULL;    }    else {	timerec = rb_time_interval(timeout);	tv = &timerec;    }    if (rb_io_read_pending(fptr)) return Qtrue;    if (!FIONREAD_POSSIBLE_P(fptr->fd)) return Qfalse;    i = rb_wait_for_single_fd(fptr->fd, RB_WAITFD_IN, tv);    if (i < 0)	rb_sys_fail(0);    rb_io_check_closed(fptr);    if (ioctl(fptr->fd, FIONREAD, &n)) rb_sys_fail(0);    if (n > 0) return io;    return Qnil;}

static VALUEossl_start_ssl(VALUE self, int (*func)(), const char *funcname){    SSL *ssl;    rb_io_t *fptr;    int ret, ret2;    VALUE cb_state;    rb_ivar_set(self, ID_callback_state, Qnil);    Data_Get_Struct(self, SSL, ssl);    GetOpenFile(ossl_ssl_get_io(self), fptr);    for(;;){	if((ret = func(ssl)) > 0) break;	switch((ret2 = ssl_get_error(ssl, ret))){	case SSL_ERROR_WANT_WRITE:            rb_io_wait_writable(FPTR_TO_FD(fptr));            continue;	case SSL_ERROR_WANT_READ:            rb_io_wait_readable(FPTR_TO_FD(fptr));            continue;	case SSL_ERROR_SYSCALL:	    if (errno) rb_sys_fail(funcname);	    ossl_raise(eSSLError, "%s SYSCALL returned=%d errno=%d state=%s", funcname, ret2, errno, SSL_state_string_long(ssl));	default:	    ossl_raise(eSSLError, "%s returned=%d errno=%d state=%s", funcname, ret2, errno, SSL_state_string_long(ssl));	}    }    cb_state = rb_ivar_get(self, ID_callback_state);    if (!NIL_P(cb_state))        rb_jump_tag(NUM2INT(cb_state));    return self;}

FILE* rb_gsl_open_readfile(VALUE io, int *flag){#ifdef RUBY_1_9_LATER  rb_io_t *fptr = NULL;#else  OpenFile *fptr = NULL;#endif  FILE *fp = NULL;  char *name;  switch (TYPE(io)) {  case T_STRING:    name = RSTRING_PTR(io);    fp = fopen(name, "r");    *flag = 1;    break;  case T_FILE:    GetOpenFile(io, fptr);    name = fptr->path;    rb_io_check_readable(fptr);#ifdef RUBY_1_9_LATER    fp = rb_io_stdio_file(fptr);#else    fp = fptr->f;#endif    *flag = 0;    break;  default:    rb_raise(rb_eTypeError, "argv 1 String or File expected");    break;  }  if (fp == NULL) rb_raise(rb_eIOError, "Cannot open file %s.", name);  return fp;}

/* * call-seq: *   basicsocket.shutdown([how]) => 0 * * Calls shutdown(2) system call. * * s.shutdown(Socket::SHUT_RD) disallows further read. * * s.shutdown(Socket::SHUT_WR) disallows further write. * * s.shutdown(Socket::SHUT_RDWR) disallows further read and write. * * _how_ can be symbol or string: * - :RD, :SHUT_RD, "RD" and "SHUT_RD" are accepted as Socket::SHUT_RD. * - :WR, :SHUT_WR, "WR" and "SHUT_WR" are accepted as Socket::SHUT_WR. * - :RDWR, :SHUT_RDWR, "RDWR" and "SHUT_RDWR" are accepted as Socket::SHUT_RDWR. * *   UNIXSocket.pair {|s1, s2| *     s1.puts "ping" *     s1.shutdown(:WR) *     p s2.read          #=> "ping/n" *     s2.puts "pong" *     s2.close *     p s1.read          #=> "pong/n" *   } * */static VALUEbsock_shutdown(int argc, VALUE *argv, VALUE sock){UNRUBBY_SOCKET_HACK;    VALUE howto;    int how;    rb_io_t *fptr;    if (rb_safe_level() >= 4 && !OBJ_TAINTED(sock)) {	rb_raise(rb_eSecurityError, "Insecure: can't shutdown socket");    }    rb_scan_args(argc, argv, "01", &howto);    if (howto == Qnil)	how = SHUT_RDWR;    else {	how = rsock_shutdown_how_arg(howto);        if (how != SHUT_WR && how != SHUT_RD && how != SHUT_RDWR) {	    rb_raise(rb_eArgError, "`how' should be either :SHUT_RD, :SHUT_WR, :SHUT_RDWR");	}    }    GetOpenFile(sock, fptr);    if (shutdown(fptr->fd, how) == -1)	rb_sys_fail(0);    return INT2FIX(0);}

/* *  call-seq: *     #write_unblocked(string)   -> integer * *  Writes the given string to <em>ios</em> using *  the write(2) system call. It assumes that O_NONBLOCK  *  is already set for the underlying file descriptor. * *  Over ~100,000 calls it is about 0.043 seconds faster. * *  It returns the number of bytes written. */static VALUErb_yaram_mbox_write_unblocked(VALUE self, VALUE io, VALUE str){    rb_io_t *fptr;    long n;    rb_secure(4);    if (TYPE(str) != T_STRING)	    str = rb_obj_as_string(str);    io = rb_io_get_write_io(io);    GetOpenFile(io, fptr);    rb_io_check_writable(fptr);    if (io_fflush(fptr) < 0)        rb_sys_fail(0);    n = write(fptr->fd, RSTRING_PTR(str), RSTRING_LEN(str));    if (n == -1) {        if (errno == EWOULDBLOCK || errno == EAGAIN)            rb_mod_sys_fail(rb_mWaitWritable, "write would block");        rb_sys_fail_path(fptr->pathv);    }    return LONG2FIX(n);}

BIO *ossl_obj2bio(VALUE obj){    BIO *bio;    if (RB_TYPE_P(obj, T_FILE)) {	rb_io_t *fptr;	FILE *fp;	int fd;	GetOpenFile(obj, fptr);	rb_io_check_readable(fptr);	if ((fd = rb_cloexec_dup(FPTR_TO_FD(fptr))) < 0){	    rb_sys_fail(0);	}        rb_update_max_fd(fd);	if (!(fp = fdopen(fd, "r"))){	    int e = errno;	    close(fd);	    rb_syserr_fail(e, 0);	}	if (!(bio = BIO_new_fp(fp, BIO_CLOSE))){	    fclose(fp);	    ossl_raise(eOSSLError, NULL);	}    }    else {	StringValue(obj);	bio = BIO_new_mem_buf(RSTRING_PTR(obj), RSTRING_LENINT(obj));	if (!bio) ossl_raise(eOSSLError, NULL);    }    return bio;}

/* * call-seq: *   basicsocket.send(mesg, flags [, dest_sockaddr]) => numbytes_sent * * send _mesg_ via _basicsocket_. * * _mesg_ should be a string. * * _flags_ should be a bitwise OR of Socket::MSG_* constants. * * _dest_sockaddr_ should be a packed sockaddr string or an addrinfo. * *   TCPSocket.open("localhost", 80) {|s| *     s.send "GET / HTTP/1.0/r/n/r/n", 0 *     p s.read *   } */VALUErsock_bsock_send(int argc, VALUE *argv, VALUE sock){    struct rsock_send_arg arg;    VALUE flags, to;    rb_io_t *fptr;    int n;    rb_blocking_function_t *func;    rb_secure(4);    rb_scan_args(argc, argv, "21", &arg.mesg, &flags, &to);    StringValue(arg.mesg);    if (!NIL_P(to)) {	SockAddrStringValue(to);	to = rb_str_new4(to);	arg.to = (struct sockaddr *)RSTRING_PTR(to);	arg.tolen = (socklen_t)RSTRING_LENINT(to);	func = rsock_sendto_blocking;    }    else {	func = rsock_send_blocking;    }    GetOpenFile(sock, fptr);    arg.fd = fptr->fd;    arg.flags = NUM2INT(flags);    while (rb_thread_fd_writable(arg.fd),	   (n = (int)BLOCKING_REGION_FD(func, &arg)) < 0) {	if (rb_io_wait_writable(arg.fd)) {	    continue;	}	rb_sys_fail("send(2)");    }    return INT2FIX(n);}

static VALUEcontrol_block_open(int argc, VALUE *argv, VALUE cb){    const char *fmode;#ifdef RUBY19    rb_io_t *fptr;#else	    OpenFile *fptr;#endif    VALUE file, mode;    rb_aiocb_t *cbs = GetCBStruct(cb);    rb_scan_args(argc, argv, "02", &file, &mode);    fmode = NIL_P(mode) ? "r" : RSTRING_PTR(mode);    struct stat stats;       Check_Type(file, T_STRING);    cbs->io = rb_file_open(RSTRING_PTR(file), fmode);    GetOpenFile(cbs->io, fptr);    rb_io_check_readable(fptr);    if ( cbs->cb.aio_fildes == 0 && cbs->cb.aio_nbytes == 0){#ifdef RUBY19      cbs->cb.aio_fildes = fptr->fd;#else	      cbs->cb.aio_fildes = fileno(fptr->f);#endif      fstat(cbs->cb.aio_fildes, &stats);      control_block_nbytes_set(cb, INT2FIX(stats.st_size));    }    return cb;    }

/* * call-seq: *   basicsocket.do_not_reverse_lookup => true or false * * Gets the do_not_reverse_lookup flag of _basicsocket_. * *   TCPSocket.open("www.ruby-lang.org", 80) {|sock| *     p sock.do_not_reverse_lookup      #=> false *     p sock.peeraddr                   #=> ["AF_INET", 80, "carbon.ruby-lang.org", "221.186.184.68"] *     sock.do_not_reverse_lookup = true *     p sock.peeraddr                   #=> ["AF_INET", 80, "221.186.184.68", "221.186.184.68"] *   } */static VALUEbsock_do_not_reverse_lookup(VALUE sock){    rb_io_t *fptr;    GetOpenFile(sock, fptr);    return (fptr->mode & FMODE_NOREVLOOKUP) ? Qtrue : Qfalse;}

binyo_instream *binyo_instream_new_fd_io(VALUE value){    rb_io_t *fptr;    GetOpenFile(value, fptr);    rb_io_check_byte_readable(fptr);    return binyo_instream_new_fd(fptr->fd);}

/* * call-seq: *   io.nonblock = boolean -> boolean * * Enables non-blocking mode on a stream when set to * +true+, and blocking mode when set to +false+. */static VALUErb_io_nonblock_set(VALUE io, VALUE nb){    rb_io_t *fptr;    GetOpenFile(io, fptr);    io_nonblock_set(fptr->fd, io_nonblock_mode(fptr->fd), RTEST(nb));    return io;}

static VALUEossl_ssl_read_internal(int argc, VALUE *argv, VALUE self, int nonblock){    SSL *ssl;    int ilen, nread = 0;    VALUE len, str;    rb_io_t *fptr;    rb_scan_args(argc, argv, "11", &len, &str);    ilen = NUM2INT(len);    if(NIL_P(str)) str = rb_str_new(0, ilen);    else{        StringValue(str);        rb_str_modify(str);        rb_str_resize(str, ilen);    }    if(ilen == 0) return str;    Data_Get_Struct(self, SSL, ssl);    GetOpenFile(ossl_ssl_get_io(self), fptr);    if (ssl) {	if(!nonblock && SSL_pending(ssl) <= 0)	    rb_thread_wait_fd(FPTR_TO_FD(fptr));	for (;;){	    nread = SSL_read(ssl, RSTRING_PTR(str), RSTRING_LEN(str));	    switch(ssl_get_error(ssl, nread)){	    case SSL_ERROR_NONE:		goto end;	    case SSL_ERROR_ZERO_RETURN:		rb_eof_error();	    case SSL_ERROR_WANT_WRITE:                write_would_block(nonblock);                rb_io_wait_writable(FPTR_TO_FD(fptr));                continue;	    case SSL_ERROR_WANT_READ:                read_would_block(nonblock);                rb_io_wait_readable(FPTR_TO_FD(fptr));		continue;	    case SSL_ERROR_SYSCALL:		if(ERR_peek_error() == 0 && nread == 0) rb_eof_error();		rb_sys_fail(0);	    default:		ossl_raise(eSSLError, "SSL_read:");	    }        }    }    else {        ID meth = nonblock ? rb_intern("read_nonblock") : rb_intern("sysread");        rb_warning("SSL session is not started yet.");        return rb_funcall(ossl_ssl_get_io(self), meth, 2, len, str);    }  end:    rb_str_set_len(str, nread);    OBJ_TAINT(str);    return str;}

VALUErsock_init_unixsock(VALUE sock, VALUE path, int server){    struct sockaddr_un sockaddr;    socklen_t sockaddrlen;    int fd, status;    rb_io_t *fptr;    SafeStringValue(path);    fd = rsock_socket(AF_UNIX, SOCK_STREAM, 0);    if (fd < 0) {	rsock_sys_fail_path("socket(2)", path);    }    INIT_SOCKADDR_UN(&sockaddr, sizeof(struct sockaddr_un));    if (sizeof(sockaddr.sun_path) < (size_t)RSTRING_LEN(path)) {        rb_raise(rb_eArgError, "too long unix socket path (%ldbytes given but %dbytes max)",            RSTRING_LEN(path), (int)sizeof(sockaddr.sun_path));    }    memcpy(sockaddr.sun_path, RSTRING_PTR(path), RSTRING_LEN(path));    sockaddrlen = rsock_unix_sockaddr_len(path);    if (server) {        status = bind(fd, (struct sockaddr*)&sockaddr, sockaddrlen);    }    else {	int prot;	struct unixsock_arg arg;	arg.sockaddr = &sockaddr;	arg.sockaddrlen = sockaddrlen;	arg.fd = fd;        status = (int)rb_protect(unixsock_connect_internal, (VALUE)&arg, &prot);	if (prot) {	    close(fd);	    rb_jump_tag(prot);	}    }    if (status < 0) {	close(fd);        rsock_sys_fail_path("connect(2)", path);    }    if (server) {	if (listen(fd, SOMAXCONN) < 0) {	    close(fd);            rsock_sys_fail_path("listen(2)", path);	}    }    rsock_init_sock(sock, fd);    if (server) {	GetOpenFile(sock, fptr);        fptr->pathv = rb_str_new_frozen(path);    }    return sock;}

/* * call-seq: *   io.nonblock? -> boolean * * Returns +true+ if an IO object is in non-blocking mode. */static VALUErb_io_nonblock_p(VALUE io){    rb_io_t *fptr;    GetOpenFile(io, fptr);    if (io_nonblock_mode(fptr->fd) & O_NONBLOCK)	return Qtrue;    return Qfalse;}

static inline intget_write_fd(const rb_io_t *fptr){    VALUE wio = fptr->tied_io_for_writing;    rb_io_t *ofptr;    if (!wio) return fptr->fd;    GetOpenFile(wio, ofptr);    return ofptr->fd;}

VALUE Wikitext_parser_flush(VALUE self,VALUE file){  rb_io_t * file_p_struct;  FILE * file_p;  Check_Type(file,T_FILE);  rb_io_binmode(file);  GetOpenFile(file,file_p_struct);  file_p = rb_io_stdio_file(file_p_struct);  fflush(file_p);  return Qnil;}

/* :nodoc: */static VALUEtcp_accept_nonblock(VALUE sock, VALUE ex){    rb_io_t *fptr;    union_sockaddr from;    socklen_t len = (socklen_t)sizeof(from);    GetOpenFile(sock, fptr);    return rsock_s_accept_nonblock(rb_cTCPSocket, ex, fptr, &from.addr, &len);}

/* * call-seq: *   BasicSocket.for_fd(fd) => basicsocket * * Returns a socket object which contains the file descriptor, _fd_. * *   # If invoked by inetd, STDIN/STDOUT/STDERR is a socket. *   STDIN_SOCK = Socket.for_fd(STDIN.fileno) *   p STDIN_SOCK.remote_address * */static VALUEbsock_s_for_fd(VALUE klass, VALUE fd){    rb_io_t *fptr;    VALUE sock = rsock_init_sock(rb_obj_alloc(klass), NUM2INT(fd));    GetOpenFile(sock, fptr);    return sock;}

/* * call-seq: *   io.winsize = [rows, columns] * * Tries to set console size.  The effect depends on the platform and * the running environment. * * You must require 'io/console' to use this method. */static VALUEconsole_set_winsize(VALUE io, VALUE size){    rb_io_t *fptr;    rb_console_size_t ws;#if defined _WIN32    HANDLE wh;    int newrow, newcol;#endif    VALUE row, col, xpixel, ypixel;    const VALUE *sz;    int fd;    GetOpenFile(io, fptr);    size = rb_Array(size);    rb_check_arity(RARRAY_LENINT(size), 2, 4);    sz = RARRAY_CONST_PTR(size);    row = sz[0], col = sz[1], xpixel = sz[2], ypixel = sz[3];    fd = GetWriteFD(fptr);#if defined TIOCSWINSZ    ws.ws_row = ws.ws_col = ws.ws_xpixel = ws.ws_ypixel = 0;#define SET(m) ws.ws_##m = NIL_P(m) ? 0 : (unsigned short)NUM2UINT(m)    SET(row);    SET(col);    SET(xpixel);    SET(ypixel);#undef SET    if (!setwinsize(fd, &ws)) rb_sys_fail(0);#elif defined _WIN32    wh = (HANDLE)rb_w32_get_osfhandle(fd);#define SET(m) new##m = NIL_P(m) ? 0 : (unsigned short)NUM2UINT(m)    SET(row);    SET(col);#undef SET    if (!NIL_P(xpixel)) (void)NUM2UINT(xpixel);    if (!NIL_P(ypixel)) (void)NUM2UINT(ypixel);    if (!GetConsoleScreenBufferInfo(wh, &ws)) {	rb_syserr_fail(LAST_ERROR, "GetConsoleScreenBufferInfo");    }    if ((ws.dwSize.X < newcol && (ws.dwSize.X = newcol, 1)) ||	(ws.dwSize.Y < newrow && (ws.dwSize.Y = newrow, 1))) {	if (!SetConsoleScreenBufferSize(wh, ws.dwSize)) {	    rb_syserr_fail(LAST_ERROR, "SetConsoleScreenBufferInfo");	}    }    ws.srWindow.Left = 0;    ws.srWindow.Top = 0;    ws.srWindow.Right = newcol;    ws.srWindow.Bottom = newrow;    if (!SetConsoleWindowInfo(wh, FALSE, &ws.srWindow)) {	rb_syserr_fail(LAST_ERROR, "SetConsoleWindowInfo");    }#endif    return io;}

/* * call-seq: *   tcpserver.sysaccept => file_descriptor * * Returns a file descriptor of a accepted connection. * *   TCPServer.open("127.0.0.1", 28561) {|serv| *     fd = serv.sysaccept *     s = IO.for_fd(fd) *     s.puts Time.now *     s.close *   } * */static VALUEtcp_sysaccept(VALUE sock){    rb_io_t *fptr;    union_sockaddr from;    socklen_t fromlen;    GetOpenFile(sock, fptr);    fromlen = (socklen_t)sizeof(from);    return rsock_s_accept(0, fptr->fd, &from.addr, &fromlen);}