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