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; }
/* * 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 VALUE io_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; }
/* * 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 VALUE rb_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); }
FILE* rb_gsl_open_writefile(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, "w"); *flag = 1; break; case T_FILE: GetOpenFile(io, fptr); name = fptr->path; rb_io_check_writable(fptr); #ifdef RUBY_1_9_LATER fp = rb_io_stdio_file(fptr); #else fp = GetWriteFile(fptr); #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: * document.debug_dump_head([stream]) -> true * * Debug-dump this document's header to the specified IO stream. * If no stream is specified, stdout is used. */ VALUE ruby_xml_document_debug_dump_head(int argc, VALUE *argv, VALUE self) { #ifdef LIBXML_DEBUG_ENABLED OpenFile *fptr; VALUE io; FILE *out; ruby_xml_document_t *rxd; Data_Get_Struct(self, ruby_xml_document_t, rxd); if (rxd->doc == NULL) return(Qnil); switch (argc) { case 0: io = rb_stdout; break; case 1: io = argv[0]; if (!rb_obj_is_kind_of(io, rb_cIO)) rb_raise(rb_eTypeError, "need an IO object"); break; default: rb_raise(rb_eArgError, "wrong number of arguments (0 or 1)"); } GetOpenFile(io, fptr); rb_io_check_writable(fptr); out = GetWriteFile(fptr); xmlDebugDumpDocumentHead(out, rxd->doc); return(Qtrue); #else rb_warn("libxml was compiled without debugging support. Please recompile libxml and ruby-libxml"); return(Qfalse); #endif }
FILE* rb_gsl_open_writefile(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, "w"); *flag = 1; break; case T_FILE: GetOpenFile(io, fptr); rb_io_check_writable(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; }
/* * call-seq: * document.dump([stream]) -> true * * Dump this document's XML to the specified IO stream. * If no stream is specified, stdout is used. */ VALUE ruby_xml_document_dump(int argc, VALUE *argv, VALUE self) { OpenFile *fptr; VALUE io; FILE *out; ruby_xml_document_t *rxd; Data_Get_Struct(self, ruby_xml_document_t, rxd); if (rxd->doc == NULL) return(Qnil); switch (argc) { case 0: io = rb_stdout; break; case 1: io = argv[0]; if (!rb_obj_is_kind_of(io, rb_cIO)) rb_raise(rb_eTypeError, "need an IO object"); break; default: rb_raise(rb_eArgError, "wrong number of arguments (0 or 1)"); } GetOpenFile(io, fptr); rb_io_check_writable(fptr); out = GetWriteFile(fptr); xmlDocDump(out, rxd->doc); return(Qtrue); }
static VALUE rb_gsl_ieee_fprintf_double(int argc, VALUE *argv, VALUE obj) { #ifdef RUBY_1_9_LATER rb_io_t *fptr = NULL; #else OpenFile *fptr = NULL; #endif FILE *fp = NULL; int flag = 0; VALUE vtmp; switch (argc) { case 2: switch (TYPE(argv[0])) { case T_STRING: fp = fopen(RSTRING_PTR(argv[0]), "w"); flag = 1; break; case T_FILE: GetOpenFile(argv[0], fptr); rb_io_check_writable(fptr); #ifdef RUBY_1_9_LATER fp = rb_io_stdio_file(fptr); #else fp = GetWriteFile(fptr); #endif break; default: rb_raise(rb_eTypeError, "wrong type argument %s (IO or String expected)", rb_class2name(CLASS_OF(argv[0]))); } vtmp = argv[1]; break; case 1: vtmp = argv[0]; fp = stdout; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } if (TYPE(vtmp) != T_FLOAT) rb_raise(rb_eTypeError, "wrong argument type %s (Float expected)", rb_class2name(CLASS_OF(vtmp))); #ifdef RUBY_1_9_LATER double rbfv = rb_float_value(vtmp); gsl_ieee_fprintf_double(fp, &rbfv); #else gsl_ieee_fprintf_double(fp, &(RFLOAT(vtmp)->value)); #endif if (fp == stdout) fprintf(stdout, "\n"); if (flag == 1) fclose(fp); return obj; }
/* * call-seq: * AIO.write(cb) -> fixnum * * Asynchronously writes to a file.This is an initial *blocking* implementation until * cross platform notification is supported. */ static VALUE rb_aio_s_write(VALUE aio, VALUE cb) { rb_aiocb_t *cbs = GetCBStruct(cb); #ifdef RUBY19 rb_io_t *fptr; #else OpenFile *fptr; #endif GetOpenFile(cbs->io, fptr); rb_io_check_writable(fptr); if (rb_block_given_p()){ cbs->rcb = rb_block_proc(); } return rb_ensure(rb_aio_write, (VALUE)&cbs->cb, control_block_close, cb); }
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; }
static VALUE rb_writev(VALUE io, VALUE list) { rb_io_t * fptr; struct iovec * iov; long i; ssize_t written; VALUE tmp; Check_Type(list, T_ARRAY); #ifdef IOV_MAX if(RARRAY_LEN(list) > IOV_MAX) #else if(RARRAY_LEN(list) > NUM2INT(rb_IOV_MAX)) #endif rb_raise(rb_eArgError, "list is too long"); tmp = rb_io_check_io(io); GetOpenFile(tmp, fptr); rb_io_check_writable(fptr); iov = xcalloc(RARRAY_LEN(list), sizeof(struct iovec)); for(i = 0; i < RARRAY_LEN(list); i++) { VALUE string = rb_ary_entry(list, i); iov[i].iov_base = StringValuePtr(string); iov[i].iov_len = RSTRING_LEN(string); } written = writev(fptr->fd, iov, (int)RARRAY_LEN(list)); xfree(iov); if (written == -1) rb_sys_fail_path(fptr->pathv); return LONG2FIX(written); }
VALUE io_spec_rb_io_check_writable(VALUE self, VALUE io) { rb_io_t* fp; GetOpenFile(io, fp); rb_io_check_writable(fp); return Qnil; }
// for testing and debugging only VALUE Wikitext_parser_tokenize(VALUE self, VALUE string, VALUE file1, VALUE file2, VALUE doc_id_v) { if (NIL_P(string)) return Qnil; int doc_id = FIX2INT(doc_id_v); rb_io_t * file_p_struct; Check_Type(file1,T_FILE); rb_io_binmode(file1); GetOpenFile(file1,file_p_struct); rb_io_check_writable(file_p_struct); FILE * file_p1 = rb_io_stdio_file(file_p_struct); Check_Type(file2,T_FILE); rb_io_binmode(file2); GetOpenFile(file2,file_p_struct); rb_io_check_writable(file_p_struct); FILE * file_p2 = rb_io_stdio_file(file_p_struct); string = StringValue(string); VALUE tokens = rb_ary_new(); char *p = RSTRING_PTR(string); long len = RSTRING_LEN(string); char *pe = p + len; const char *type = NULL; int state = DEFAULT; int ts[1000]; int ss[1000]; int ts_size = 1 ; int ss_size = 1 ; ss[0] = 0; ts[0] = 0; token_t token; token_t stack1[1000]; //tail, TODO add checks token_t stack2[1000]; //head, TODO add checks int s1_size = 0; int s2_size = 0; int start = 1; do { //printf("%i %i\n",s1_size,s2_size); if(start) { next_token(&token, NULL, p, pe, ts, ss, &ts_size, &ss_size, file_p1, doc_id); start = 0; } else { next_token(&token, &token, NULL, pe, ts, ss, &ts_size, &ss_size, file_p1, doc_id); } //rb_funcall(rb_mKernel, rb_intern("puts"), 1, wiki_token(&token)); if(token.type == END_OF_FILE){ if(state == POST_LINK) { finish_link1(&s1_size,&s2_size,stack1,stack2,file_p1,file_p2,doc_id); } break; } switch(token.type) { case SEPARATOR : memcpy(stack2,stack1,sizeof(token_t)*s1_size); s2_size = s1_size; s1_size = 0; state = SEPARATOR; break; case LINK_START : state = LINK; break; case LINK_END : if(state != SEPARATOR) { memcpy(stack2,stack1,sizeof(token_t)*s1_size); s2_size = s1_size; } state = POST_LINK; break; case EXT_LINK_START : state = EXT_LINK; break; case EXT_LINK_END : // TODO print what should be printed s1_size = 0; s2_size = 0; break; case ALNUM : if(state == POST_LINK){ finish_link(&s1_size,&s2_size,stack1,stack2,file_p1,file_p2,doc_id,&token); state = DEFAULT; } else { if(s1_size < 1000) memcpy(&(stack1[s1_size++]),&token,sizeof(token_t)); else printf("[%i]Token stack overflow\n",doc_id); } break; case SPACE : type = space_type; case PRINTABLE : case DEFAULT : if(type == NULL) type = printable_type; case NUM : if(type == NULL) type = num_type; if(state == POST_LINK) { finish_link1(&s1_size,&s2_size,stack1,stack2,file_p1,file_p2,doc_id); wikitext_print_token(&token,file_p1,doc_id,type); state = DEFAULT; } else { if(s1_size < 1000) memcpy(&(stack1[s1_size++]),&token,sizeof(token_t)); else printf("[%i]Token stack overflow\n",doc_id); } break; case CRLF : if(state == POST_LINK){ finish_link1(&s1_size,&s2_size,stack1,stack2,file_p1,file_p2,doc_id); wikitext_print_crlf(&token,file_p1,doc_id); state = DEFAULT; } else { if(s1_size < 1000) memcpy(&(stack1[s1_size++]),&token,sizeof(token_t)); else printf("[%i]Token stack overflow\n",doc_id); } break; case SKIP : if(state == POST_LINK){ finish_link1(&s1_size,&s2_size,stack1,stack2,file_p1,file_p2,doc_id); state = DEFAULT; } break; } type = NULL; } while(1); return tokens; }