/** * call-seq: * Coolio::StatWatcher.initialize(path, interval = 0) -> Coolio::StatWatcher * * Create a new Coolio::StatWatcher for the given path. This will monitor the * given path for changes at the filesystem level. The interval argument * specified how often in seconds the path should be polled for changes. * Setting interval to zero uses an "automatic" value (typically around 5 * seconds) which optimizes performance. Otherwise, values less than * 0.1 are not particularly meaningful. Where available (at present, on Linux) * high performance file monitoring interfaces will be used instead of polling. */ static VALUE Coolio_StatWatcher_initialize(int argc, VALUE *argv, VALUE self) { VALUE path, interval; struct Coolio_Watcher *watcher_data; rb_scan_args(argc, argv, "11", &path, &interval); if(interval != Qnil) interval = rb_convert_type(interval, T_FLOAT, "Float", "to_f"); path = rb_String(path); rb_iv_set(self, "@path", path); Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); watcher_data->dispatch_callback = Coolio_StatWatcher_dispatch_callback; ev_stat_init( &watcher_data->event_types.ev_stat, Coolio_StatWatcher_libev_callback, RSTRING_PTR(path), interval == Qnil ? 0 : NUM2DBL(interval) ); watcher_data->event_types.ev_stat.data = (void *)self; return Qnil; }
static VALUE make_version_str(VALUE major, VALUE minor) { VALUE version_str = Qnil; VALUE minor_str = Qnil; if (major == Qnil) { return Qnil; } version_str = rb_String(major); if (minor != Qnil) { minor_str = rb_String(minor); rb_str_cat2(version_str, "."); rb_str_append(version_str, minor_str); } return version_str; }
static VALUE rb_gl_buffer_write(int argc, VALUE *argv, VALUE self) { struct buffer *buf; VALUE _data, _offset; GLsizeiptr offset; long length; TypedData_Get_Struct(self, struct buffer, &buffer_type, buf); if (!buf->ptr) rb_raise(rb_eArgError, "write to unmapped buffer"); rb_scan_args(argc, argv, "11", &_data, &_offset); if (NIL_P(_data)) rb_raise(rb_eArgError, "cannot write nil to buffer"); _data = rb_String(_data); length = RSTRING_LEN(_data); if (NIL_P(_offset)) { offset = 0; } else { offset = NUM2SIZET(_offset); } if (buf->len != 0 && length + offset > buf->len) rb_raise(rb_eArgError, "write to %lu past end of buffer %lu", (unsigned long)(length + offset), (unsigned long)buf->len); memcpy((char *)buf->ptr + offset, RSTRING_PTR(_data), RSTRING_LEN(_data)); return self; }
/* * call-seq: * ctx.ciphers = "cipher1:cipher2:..." * ctx.ciphers = [name, ...] * ctx.ciphers = [[name, version, bits, alg_bits], ...] */ static VALUE ossl_sslctx_set_ciphers(VALUE self, VALUE v) { SSL_CTX *ctx; VALUE str, elem; int i; rb_check_frozen(self); if (NIL_P(v)) return v; else if (TYPE(v) == T_ARRAY) { str = rb_str_new(0, 0); for (i = 0; i < RARRAY_LEN(v); i++) { elem = rb_ary_entry(v, i); if (TYPE(elem) == T_ARRAY) elem = rb_ary_entry(elem, 0); elem = rb_String(elem); rb_str_append(str, elem); if (i < RARRAY_LEN(v)-1) rb_str_cat2(str, ":"); } } else { str = v; StringValue(str); } Data_Get_Struct(self, SSL_CTX, ctx); if(!ctx){ ossl_raise(eSSLError, "SSL_CTX is not initialized."); return Qnil; } if (!SSL_CTX_set_cipher_list(ctx, RSTRING_PTR(str))) { ossl_raise(eSSLError, "SSL_CTX_set_cipher_list:"); } return v; }
static VALUE exc_to_s(VALUE exc) { VALUE mesg = rb_attr_get(exc, rb_intern("mesg")); if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc)); return rb_String(mesg); }
char* unwrap< char* >(const VALUE &val ) { if(NIL_P(val)) return NULL; if (rb_obj_is_kind_of(val, rb_cString)){ return RSTRING_PTR(val); } else return unwrap< char* >(rb_String(val)); }
static VALUE exc_to_s(VALUE exc) { VALUE mesg = rb_attr_get(exc, rb_intern("mesg")); VALUE r = Qnil; if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc)); r = rb_String(mesg); OBJ_INFECT(r, exc); return r; }
static CFURLRef str_to_url(VALUE path) { #ifdef FilePathValue VALUE p = FilePathValue(path); #else VALUE p = rb_String(path); #endif CFURLRef fileURL = CFURLCreateFromFileSystemRepresentation(NULL, (const UInt8 *)RSTRING_PTR(p), RSTRING_LEN(p), false); if (!fileURL) { rb_raise(rb_eArgError, "Unable to create CFURL from `%s'.", RSTRING_PTR(rb_inspect(path))); } return fileURL; }
static VALUE method_name(ID mid) { VALUE result; if (mid == ID_ALLOCATOR) result = rb_str_new2("allocate"); else if (mid == 0) result = rb_str_new2("[No method]"); else result = rb_String(ID2SYM(mid)); return result; }
static VALUE data_type_set(VALUE self, VALUE value) { if (TYPE(value) != T_SYMBOL) { value = rb_str_intern(rb_String(value)); } if (rb_hash_aref(rb_hTypes, value) == Qnil) { rb_raise(rb_eArgError, "invalid data type %s", RSTRING_PTR(rb_inspect(value))); } rb_ivar_set(self, id_data_type, value); return self; }
rho_param *rho_param_fromvalue(VALUE v) { int i, size; /* if (v == NULL) { return NULL; } if (rho_ruby_is_NIL(v)) { return NULL; } */ switch(TYPE(v)) { case T_ARRAY: { rho_param *p = 0; size = RARRAY_LEN(v); p = rho_param_array(size); for (i = 0; i < size; ++i) { VALUE item = rb_ary_entry(v, i); p->v.array->value[i] = rho_param_fromvalue(item); } return p; } break; case T_HASH: { VALUE keys = rb_funcall(v, rb_intern("keys"), 0, NULL); rho_param *p = 0; size = RARRAY_LEN(keys); p = rho_param_hash(size); for (i = 0; i < size; ++i) { VALUE key = rb_ary_entry(keys, i); VALUE value = rb_hash_aref(v, key); p->v.hash->name[i] = strdup(RSTRING_PTR(rb_String(key))); p->v.hash->value[i] = rho_param_fromvalue(value); } return p; } break; default: { VALUE value = v; if (TYPE(v) != T_STRING) value = rb_funcall(value, rb_intern("to_s"), 0, NULL); return rho_param_str(RSTRING_PTR(value)); } } }
/* Method: Info#define(format, key[, value]) Purpose: Call SetImageOption Note: The only method in Info that is not an attribute accessor. */ VALUE Info_define(int argc, VALUE *argv, VALUE self) { Info *info; char *format, *key; const char *value = ""; long format_l, key_l; char ckey[100]; unsigned int okay; volatile VALUE fmt_arg; Data_Get_Struct(self, Info, info); switch (argc) { case 3: /* Allow any argument that supports to_s */ fmt_arg = rb_String(argv[2]); value = (const char *)StringValuePtr(fmt_arg); case 2: key = rm_str2cstr(argv[1], &key_l); format = rm_str2cstr(argv[0], &format_l); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); } if (2 + format_l + key_l > (long)sizeof(ckey)) { rb_raise(rb_eArgError, "%.20s:%.20s not defined - format or key too long", format, key); } (void) sprintf(ckey, "%s:%s", format, key); (void) RemoveImageOption(info, ckey); okay = SetImageOption(info, ckey, value); if (!okay) { rb_warn("%.20s=\"%.78s\" not defined - SetImageOption failed.", ckey, value); return Qnil; } return self; }
ASN1_INTEGER * num_to_asn1integer(VALUE obj, ASN1_INTEGER *ai) { BIGNUM *bn = NULL; if (RTEST(rb_obj_is_kind_of(obj, cBN))) { bn = GetBNPtr(obj); } else { obj = rb_String(obj); if (!BN_dec2bn(&bn, StringValuePtr(obj))) { ossl_raise(eOSSLError, NULL); } } if (!(ai = BN_to_ASN1_INTEGER(bn, ai))) { BN_free(bn); ossl_raise(eOSSLError, NULL); } BN_free(bn); return ai; }
static OCIAnyData * to_return_value(plruby_context_t *ctx, VALUE val) { OCIAnyData *sdata = NULL; OCIInd ind = OCI_IND_NOTNULL; if (NIL_P(val)) { return NULL; } switch (ctx->rettype) { case OCI_TYPECODE_VARCHAR2: { OCIString *str = NULL; VALUE sval = rb_String(val); sval = rb_str_export_to_enc(sval, oracle_encoding); chk(OCIStringAssignText(ctx->envhp, ctx->errhp, (text*)RSTRING_PTR(sval), RSTRING_LEN(sval), &str)); chk(OCIAnyDataConvert(ctx->svchp, ctx->errhp, ctx->rettype, NULL, OCI_DURATION_SESSION, &ind, str, 0, &sdata)); chk(OCIStringResize(ctx->envhp, ctx->errhp, 0, &str)); return sdata; } case OCI_TYPECODE_NUMBER: { OCINumber num; double dval = rb_num2dbl(val); chk(OCINumberFromReal(ctx->errhp, &dval, sizeof(dval), &num)); chk(OCIAnyDataConvert(ctx->svchp, ctx->errhp, ctx->rettype, NULL, OCI_DURATION_SESSION, &ind, &num, 0, &sdata)); return sdata; } case OCI_TYPECODE_BDOUBLE: { double dval = rb_num2dbl(val); chk(OCIAnyDataConvert(ctx->svchp, ctx->errhp, ctx->rettype, NULL, OCI_DURATION_SESSION, &ind, &dval, 0, &sdata)); return sdata; } } rb_raise(rb_eRuntimeError, "Unsupported Typecode %d", ctx->rettype); }
/* * Don't use the retuned value after any ruby function is called. * It may be GCed. */ static const char * get_error_msg(int *errnum) { VALUE exc = rb_String(rb_errinfo()); VALUE num = rb_iv_get(exc, "@plsql_error_number"); const char *errmsg; exc = rb_str_export_to_enc(exc, oracle_encoding); errmsg = StringValueCStr(exc); if (errmsg == NULL || errmsg[0] == '\0') { errmsg = "Unknown extproc_ruby error"; } if (FIXNUM_P(num)) { long n = FIX2INT(num); if (1 <= n && n <= 32767) { *errnum = (int)n; } } return errmsg; }
BIGNUM * GetBNPtr(VALUE obj) { BIGNUM *bn = NULL; if (RTEST(rb_obj_is_kind_of(obj, cBN))) { GetBN(obj, bn); } else switch (TYPE(obj)) { case T_FIXNUM: case T_BIGNUM: obj = rb_String(obj); if (!BN_dec2bn(&bn, StringValuePtr(obj))) { ossl_raise(eBNError, NULL); } WrapBN(cBN, obj, bn); /* Handle potencial mem leaks */ break; default: ossl_raise(rb_eTypeError, "Cannot convert into OpenSSL::BN"); } return bn; }
static VALUE method_name(ID mid, int depth) { VALUE result; if (mid == ID_ALLOCATOR) result = rb_str_new2("allocate"); else if (mid == 0) result = rb_str_new2("[No method]"); else result = rb_String(ID2SYM(mid)); if (depth > 0) { char buffer[65]; sprintf(buffer, "%i", depth); rb_str_cat2(result, "-"); rb_str_cat2(result, buffer); } return result; }
/** * call-seq: * Coolio::IOWatcher.initialize(IO, events = 'r') -> Coolio::IOWatcher * * Create a new Coolio::IOWatcher for the given IO object and add it to the given Coolio::Loop */ static VALUE Coolio_IOWatcher_initialize(int argc, VALUE *argv, VALUE self) { VALUE io, flags; char *flags_str; int events; struct Coolio_Watcher *watcher_data; #if HAVE_RB_IO_T rb_io_t *fptr; #else OpenFile *fptr; #endif rb_scan_args(argc, argv, "11", &io, &flags); if(flags != Qnil) flags_str = RSTRING_PTR(rb_String(flags)); else flags_str = "r"; if(!strcmp(flags_str, "r")) events = EV_READ; else if(!strcmp(flags_str, "w")) events = EV_WRITE; else if(!strcmp(flags_str, "rw")) events = EV_READ | EV_WRITE; else rb_raise(rb_eArgError, "invalid event type: '%s' (must be 'r', 'w', or 'rw')", flags_str); Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr); watcher_data->dispatch_callback = Coolio_IOWatcher_dispatch_callback; ev_io_init(&watcher_data->event_types.ev_io, Coolio_IOWatcher_libev_callback, FPTR_TO_FD(fptr), events); watcher_data->event_types.ev_io.data = (void *)self; return Qnil; }
/* :nodoc: */ char *rstring_ptr(VALUE s) { char* r = NIL_P(s) ? "nil" : RSTRING_PTR(rb_String(s)); return r ? r : "nil"; }
/* :nodoc: */ char *rstring_ptr_null(VALUE s) { char* r = NIL_P(s) ? NULL : RSTRING_PTR(rb_String(s)); return r ? r : NULL; }
int ox_sax_collapse_special(SaxDrive dr, char *str, int line, int col) { char *s = str; char *b = str; while ('\0' != *s) { if ('&' == *s) { int c = 0; char *end; s++; if ('#' == *s) { uint64_t u = 0; char x; s++; if ('x' == *s || 'X' == *s) { x = *s; s++; end = read_hex_uint64(s, &u); } else { x = '\0'; end = read_10_uint64(s, &u); } if (0 == end) { ox_sax_drive_error(dr, NO_TERM "special character does not end with a semicolon"); *b++ = '&'; *b++ = '#'; if ('\0' != x) { *b++ = x; } continue; } if (u <= 0x000000000000007FULL) { *b++ = (char)u; #if HAS_ENCODING_SUPPORT } else if (ox_utf8_encoding == dr->encoding) { b = ox_ucs_to_utf8_chars(b, u); } else if (0 == dr->encoding) { dr->encoding = ox_utf8_encoding; b = ox_ucs_to_utf8_chars(b, u); #elif HAS_PRIVATE_ENCODING } else if (ox_utf8_encoding == dr->encoding || 0 == strcasecmp(rb_str_ptr(rb_String(ox_utf8_encoding)), rb_str_ptr(rb_String(dr->encoding)))) { b = ox_ucs_to_utf8_chars(b, u); } else if (Qnil == dr->encoding) { dr->encoding = ox_utf8_encoding; b = ox_ucs_to_utf8_chars(b, u); #else } else if (0 == dr->encoding) { dr->encoding = UTF8_STR; b = ox_ucs_to_utf8_chars(b, u); } else if (0 == strcasecmp(UTF8_STR, dr->encoding)) { b = ox_ucs_to_utf8_chars(b, u); #endif } else { b = ox_ucs_to_utf8_chars(b, u); /* ox_sax_drive_error(dr, NO_TERM "Invalid encoding, need UTF-8 encoding to parse &#nnnn; character sequences."); *b++ = '&'; *b++ = '#'; if ('\0' != x) { *b++ = x; } continue; */ } s = end + 1; continue; } else if (0 == strncasecmp(s, "lt;", 3)) { c = '<'; s += 3; col += 3; } else if (0 == strncasecmp(s, "gt;", 3)) { c = '>'; s += 3; col += 3; } else if (0 == strncasecmp(s, "amp;", 4)) { c = '&'; s += 4; col += 4; } else if (0 == strncasecmp(s, "quot;", 5)) { c = '"'; s += 5; col += 5; } else if (0 == strncasecmp(s, "apos;", 5)) { c = '\''; s += 5; } else { ox_sax_drive_error_at(dr, NO_TERM "special character does not end with a semicolon", line, col); c = '&'; } *b++ = (char)c; col++; } else { if ('\n' == *s) { line++; col = 0; } col++; *b++ = *s++; } } *b = '\0'; return 0; }
// Coerces to String as well. static CFStringRef str_to_cfstr(VALUE str) { return CFStringCreateWithCString(NULL, RSTRING_PTR(rb_String(str)), kCFStringEncodingUTF8); }
static VALUE rhe_accept(VALUE self, VALUE fileno, VALUE timeoutv, VALUE tcp, VALUE env) { struct sockaddr_in cliaddr; unsigned int len; char read_buf[MAX_HEADER_SIZE]; VALUE req; int flag = 1; ssize_t rv = 0; ssize_t buf_len; ssize_t reqlen; int fd; double timeout = NUM2DBL(timeoutv); len = sizeof(cliaddr); fd = _accept(NUM2INT(fileno), (struct sockaddr *)&cliaddr, len); /* endif */ if (fd < 0) { goto badexit; } rv = _read_timeout(fd, timeout, &read_buf[0], MAX_HEADER_SIZE); if ( rv <= 0 ) { close(fd); goto badexit; } if ( IMMEDIATE_P(tcp) ) { setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(int)); rb_hash_aset(env, remote_addr_key, rb_str_new2(inet_ntoa(cliaddr.sin_addr))); rb_hash_aset(env, remote_port_key, rb_String(rb_int_new(ntohs(cliaddr.sin_port)))); } else { rb_hash_aset(env, remote_addr_key, rb_str_new("",0)); rb_hash_aset(env, remote_port_key, rb_String(rb_int_new(0))); } buf_len = rv; while (1) { reqlen = _parse_http_request(&read_buf[0],buf_len,env); if ( reqlen >= 0 ) { break; } else if ( reqlen == -1 ) { /* error */ close(fd); goto badexit; } if ( MAX_HEADER_SIZE - buf_len == 0 ) { /* too large header */ char* badreq; badreq = BAD_REQUEST; rv = _write_timeout(fd, timeout, badreq, sizeof(BAD_REQUEST) - 1); close(fd); goto badexit; } /* request is incomplete */ rv = _read_timeout(fd, timeout, &read_buf[buf_len], MAX_HEADER_SIZE - buf_len); if ( rv <= 0 ) { close(fd); goto badexit; } buf_len += rv; } req = rb_ary_new2(3); rb_ary_push(req, rb_int_new(fd)); rb_ary_push(req, rb_str_new(&read_buf[reqlen],buf_len - reqlen)); return req; badexit: return Qnil; }
/* :nodoc: */ size_t rstring_length(VALUE s) { size_t r = NIL_P(s) ? 0 : RSTRING_LEN(rb_String(s)); return r; }