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