Exemplos de rb_io_check_readable em C++ (Cpp)

Exemplo n.º 1

Arquivo: ossl_ssl.c Projeto: srirammca53/update_status

static VALUE
ossl_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;
}

Exemplo n.º 2

Arquivo: wait.c Projeto: gogotanaka/ruby_svn

static VALUE
io_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;
}

Exemplo n.º 3

Arquivo: ossl_bio.c Projeto: gferguson-gd/ruby

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;
}

Exemplo n.º 4

Arquivo: common.c Projeto: davidrichards/rb-gsl

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;
}

Exemplo n.º 5

Arquivo: message.c Projeto: mrevilme/frostbitten

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;
}

Exemplo n.º 6

Arquivo: common.c Projeto: blackwinter/rb-gsl

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;
}

Exemplo n.º 7

Arquivo: aio.c Projeto: methodmissing/aio

static VALUE
control_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;    
}

Exemplo n.º 8

Arquivo: wait.c Projeto: gogotanaka/ruby_svn

static VALUE
io_ready_p(VALUE io)
{
    rb_io_t *fptr;
    ioctl_arg n;

    GetOpenFile(io, fptr);
    rb_io_check_readable(fptr);
    if (rb_io_read_pending(fptr)) return Qtrue;
    if (!FIONREAD_POSSIBLE_P(fptr->fd)) return Qnil;
    if (ioctl(fptr->fd, FIONREAD, &n)) return Qnil;
    if (n > 0) return Qtrue;
    return Qfalse;
}

Exemplo n.º 9

Arquivo: wait.c Projeto: gogotanaka/ruby_svn

static VALUE
io_nread(VALUE io)
{
    rb_io_t *fptr;
    int len;
    ioctl_arg n;

    GetOpenFile(io, fptr);
    rb_io_check_readable(fptr);
    len = rb_io_read_pending(fptr);
    if (len > 0) return len;
    if (!FIONREAD_POSSIBLE_P(fptr->fd)) return INT2FIX(0);
    if (ioctl(fptr->fd, FIONREAD, &n)) return INT2FIX(0);
    if (n > 0) return ioctl_arg2num(n);
    return INT2FIX(0);
}

Exemplo n.º 10

Arquivo: zkrb.c Projeto: ClarityServices/zookeeper

inline static int get_self_pipe_read_fd(VALUE self) {
  rb_io_t *fptr;
  VALUE pipe_read = rb_iv_get(self, "@pipe_read");

  if (NIL_P(pipe_read))
      rb_raise(rb_eRuntimeError, "@pipe_read was nil!");

  GetOpenFile(pipe_read, fptr);

  rb_io_check_readable(fptr);

#ifdef ZKRB_RUBY_187
  return fileno(fptr->f);
#else
  return fptr->fd;
#endif
}

Exemplo n.º 11

Arquivo: ossl_ssl.c Projeto: 2220142/ruby

static VALUE
ossl_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){
#ifdef HAVE_SSL_SET_TLSEXT_HOST_NAME
	VALUE hostname = rb_iv_get(self, "@hostname");
#endif

        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;

#ifdef HAVE_SSL_SET_TLSEXT_HOST_NAME
        if (!NIL_P(hostname)) {
           if (SSL_set_tlsext_host_name(ssl, StringValuePtr(hostname)) != 1)
               ossl_raise(eSSLError, "SSL_set_tlsext_host_name:");
        }
#endif
        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;
}

Exemplo n.º 12

Arquivo: message.c Projeto: mrevilme/frostbitten

VALUE frostbitten_message_read_from_io(VALUE self, VALUE io) {
	fb_message *message;
	Data_Get_Struct(self, fb_message, message);

	rb_io_t *fptr;
	GetOpenFile(io, fptr);
	rb_io_check_readable(fptr);
	FILE *fp = rb_io_stdio_file(fptr);
	fb_packet_buffer *buffer = read_buffer_from_io(fp);
	
	if ( !message->header ) {
		message->header = rb_class_new_instance(0, NULL, c_frostbitten_header);
		frostbitten_header_parse_from_buffer(message->header, buffer);
	}
   	
   	frostbitten_read_words_from_file(message, fp, buffer);
    return self;
}

Exemplo n.º 13

Arquivo: aio.c Projeto: methodmissing/aio

static VALUE 
control_block_path(VALUE cb)
{ 
    rb_aiocb_t *cbs = GetCBStruct(cb);
#ifdef RUBY19
    rb_io_t *fptr;
#else	
    OpenFile *fptr;
#endif
    if NIL_P(cbs->io) return rb_tainted_str_new2("");
    GetOpenFile(cbs->io, fptr);
    rb_io_check_readable(fptr);
#ifdef RUBY19
    return rb_file_s_expand_path( 1, &fptr->pathv );
#else
    VALUE path = rb_tainted_str_new2(fptr->path);
    return rb_file_s_expand_path( 1, &path );
#endif
}

Exemplo n.º 14

Arquivo: message.c Projeto: mrevilme/frostbitten

VALUE frostbitten_message_complete(VALUE self, VALUE io) {
	rb_io_t *fptr;
	GetOpenFile(io, fptr);
	rb_io_check_readable(fptr);
	FILE *fp = rb_io_stdio_file(fptr);

	fb_packet_buffer *buffer = read_buffer_from_io(fp);
	if (is_packet_valid(buffer)) {
		VALUE msg = rb_obj_alloc(c_frostbitten_message);
    	rb_obj_call_init(msg, 0, 0);
    	fb_message *message;
		Data_Get_Struct(msg, fb_message, message);
    	frostbitten_read_words_from_file(message, fp, buffer);

		if (rb_block_given_p()) {
			return rb_yield(msg);
		} else {
			return msg;
		}
	}
	free(buffer);
	return Qnil;
}

Exemplo n.º 15

VALUE io_spec_rb_io_check_readable(VALUE self, VALUE io) {
  rb_io_t* fp;
  GetOpenFile(io, fp);
  rb_io_check_readable(fp);
  return Qnil;
}