VALUE string_spec_rb_str_new_cstr(VALUE self, VALUE str) {
if(NIL_P(str)) {
return rb_str_new_cstr(NULL);
} else {
return rb_str_new_cstr(RSTRING_PTR(str));
}
}
static VALUE symbol_new(bfd * abfd, asymbol *s, char is_dynamic) {
symbol_info info;
VALUE class, instance;
VALUE argv[1] = { Qnil };
class = rb_class_new(clsSymbol);
instance = Data_Wrap_Struct(class, NULL, NULL, s);
rb_obj_call_init(instance, 0, argv);
bfd_symbol_info(s, &info);
/* set instance variables */
rb_iv_set(instance, IVAR(SYM_ATTR_NAME), rb_str_new_cstr(info.name) );
rb_iv_set(instance, IVAR(SYM_ATTR_TYPE), INT2NUM((int) info.type) );
rb_iv_set(instance, IVAR(SYM_ATTR_VALUE), SIZET2NUM(info.value) );
rb_iv_set(instance, IVAR(SYM_ATTR_FLAGS), INT2NUM(s->flags) );
rb_iv_set(instance, IVAR(SYM_ATTR_BIND),
rb_str_new_cstr( (is_dynamic ? SYM_BIND_DYNAMIC :
SYM_BIND_STATIC) ) );
if ( s->section ) {
rb_iv_set(instance, IVAR(SYM_ATTR_SECTION),
rb_str_new_cstr(s->section->name));
}
return instance;
}
static VALUE
arg_string_literal_serialize(void* data)
{
rb_tracelog_arg_string_literal_t *arg = (rb_tracelog_arg_string_literal_t*)data;
VALUE key = rb_str_new_cstr(arg->key);
VALUE val = rb_str_new_cstr(arg->val);
VALUE args = rb_hash_new();
rb_hash_aset(args, key, val);
return args;
}
static void showExc(VALUE exc)
{
VALUE bt = rb_funcall2(exc, rb_intern("backtrace"), 0, NULL);
VALUE bt0 = rb_ary_entry(bt, 0);
VALUE name = rb_class_path(rb_obj_class(exc));
VALUE ds = rb_sprintf("%" PRIsVALUE ": %" PRIsVALUE " (%" PRIsVALUE ")",
bt0, exc, name);
/* omit "useless" last entry (from ruby:1:in `eval') */
for (long i = 1, btlen = RARRAY_LEN(bt) - 1; i < btlen; ++i)
rb_str_catf(ds, "\n\tfrom %" PRIsVALUE, rb_ary_entry(bt, i));
Debug() << StringValueCStr(ds);
ID id_index = rb_intern("index");
/* an "offset" argument is not needed for the first time */
VALUE argv[2] = { rb_str_new_cstr(":") };
long filelen = NUM2LONG(rb_funcall2(bt0, id_index, 1, argv));
argv[1] = LONG2NUM(filelen + 1);
VALUE tmp = rb_funcall2(bt0, id_index, ARRAY_SIZE(argv), argv);
long linelen = NUM2LONG(tmp) - filelen - 1;
VALUE file = rb_str_subseq(bt0, 0, filelen);
VALUE line = rb_str_subseq(bt0, filelen + 1, linelen);
VALUE ms = rb_sprintf("Script '%" PRIsVALUE "' line %" PRIsVALUE
": %" PRIsVALUE " occured.\n\n%" PRIsVALUE,
file, line, name, exc);
showMsg(StringValueCStr(ms));
}
static void grpc_rb_call_credentials_callback_with_gil(void* param) {
callback_params* const params = (callback_params*)param;
VALUE auth_uri = rb_str_new_cstr(params->context.service_url);
/* Pass the arguments to the proc in a hash, which currently only has they key
'auth_uri' */
VALUE callback_args = rb_ary_new();
VALUE args = rb_hash_new();
VALUE result;
grpc_metadata_array md_ary;
grpc_status_code status;
VALUE details;
char* error_details;
grpc_metadata_array_init(&md_ary);
rb_hash_aset(args, ID2SYM(rb_intern("jwt_aud_uri")), auth_uri);
rb_ary_push(callback_args, params->get_metadata);
rb_ary_push(callback_args, args);
result = rb_rescue(grpc_rb_call_credentials_callback, callback_args,
grpc_rb_call_credentials_callback_rescue, Qnil);
// Both callbacks return a hash, so result should be a hash
grpc_rb_md_ary_convert(rb_hash_aref(result, rb_str_new2("metadata")),
&md_ary);
status = NUM2INT(rb_hash_aref(result, rb_str_new2("status")));
details = rb_hash_aref(result, rb_str_new2("details"));
error_details = StringValueCStr(details);
params->callback(params->user_data, md_ary.metadata, md_ary.count, status,
error_details);
grpc_rb_metadata_array_destroy_including_entries(&md_ary);
gpr_free(params);
}
VALUE zval_to_hash(zval *zv) {
HashTable *ht;
HashPosition pos;
zval **data;
VALUE ret;
convert_to_array(zv);
ht = Z_ARRVAL_P(zv);
ret = rb_hash_new();
zend_hash_internal_pointer_reset_ex(ht, &pos);
while (zend_hash_get_current_data_ex(ht, (void **)&data, &pos) == SUCCESS) {
char* key_str;
uint key_len;
ulong num_index;
VALUE key = Qnil;
VALUE val = new_php_embed_value(*data);
switch(zend_hash_get_current_key_ex(ht, &key_str, &key_len, &num_index, 0, &pos)) {
case HASH_KEY_IS_STRING:
//key = rb_str_new(key_str, key_len);
key = rb_str_new_cstr(key_str);
break;
case HASH_KEY_IS_LONG:
key = LONG2NUM(num_index);
break;
}
rb_hash_aset(ret, key, val);
zend_hash_move_forward_ex(ht, &pos);
}
return ret;
}
static VALUE
test_num2ull(VALUE obj, VALUE num)
{
char buf[128];
sprintf(buf, "%"PRI_LL_PREFIX"u", NUM2ULL(num));
return rb_str_new_cstr(buf);
}
static VALUE
test_num2int(VALUE obj, VALUE num)
{
char buf[128];
sprintf(buf, "%d", NUM2INT(num));
return rb_str_new_cstr(buf);
}
static VALUE
test_num2ulong(VALUE obj, VALUE num)
{
char buf[128];
sprintf(buf, "%lu", NUM2ULONG(num));
return rb_str_new_cstr(buf);
}
/*
* Errors
*/
static VALUE
ossl_make_error(VALUE exc, const char *fmt, va_list args)
{
VALUE str = Qnil;
unsigned long e;
if (fmt) {
str = rb_vsprintf(fmt, args);
}
e = ERR_peek_last_error();
if (e) {
const char *msg = ERR_reason_error_string(e);
if (NIL_P(str)) {
if (msg) str = rb_str_new_cstr(msg);
}
else {
if (RSTRING_LEN(str)) rb_str_cat2(str, ": ");
rb_str_cat2(str, msg ? msg : "(null)");
}
ossl_clear_error();
}
if (NIL_P(str)) str = rb_str_new(0, 0);
return rb_exc_new3(exc, str);
}
VALUE xopenssl_md5(VALUE self, VALUE str) {
// We need to copy to a native string as we can't pass Ruby strings into native at the moment
size_t str_len = RSTRING_LEN(str);
char *str_ptr = RSTRING_PTR(str);
unsigned char *native_str = alloca(str_len + 1);
for (int n = 0; n < str_len; n++) {
native_str[n] = str_ptr[n];
}
native_str[str_len] = '\0';
unsigned char digest[MD5_DIGEST_LENGTH];
MD5(native_str, str_len, digest);
char *hex = alloca(MD5_DIGEST_LENGTH * 2 + 1);
char *hex_ptr = hex;
for (int n = 0; n < MD5_DIGEST_LENGTH; n++){
hex_ptr += sprintf(hex_ptr, "%02x", digest[n]);
}
*hex_ptr = '\0';
return rb_str_new_cstr(hex);
}
int proxenet_ruby_load_file(plugin_t* plugin)
{
char* filename;
char* pathname;
int res = 0;
if(plugin->state != INACTIVE){
#ifdef DEBUG
if(cfg->verbose > 2)
xlog(LOG_DEBUG, "Plugin '%s' is already loaded. Skipping...\n", plugin->name);
#endif
return 0;
}
filename = plugin->filename;
pathname = plugin->fullpath;
rb_load_protect(rb_str_new_cstr(pathname), 0, &res);
if (res != 0) {
xlog(LOG_ERROR, "[Ruby] Error %d when load file '%s'\n", res, pathname);
return -1;
}
#ifdef DEBUG
xlog(LOG_DEBUG, "%s\n", pathname);
#endif
return 0;
}
static VALUE
test_fix2short(VALUE obj, VALUE num)
{
char buf[128];
sprintf(buf, "%d", FIX2SHORT(num));
return rb_str_new_cstr(buf);
}
static VALUE
test_fix2uint(VALUE obj, VALUE num)
{
char buf[128];
sprintf(buf, "%u", FIX2UINT(num));
return rb_str_new_cstr(buf);
}
static VALUE rd_die_source_files(VALUE self)
{
rd_die_t *die = GetDie(self);
Dwarf_Signed cnt = 0;
char **srcfiles = 0;
Dwarf_Error err;
VALUE files = Qnil;
if (die->srcfiles != Qfalse) {
return die->srcfiles;
}
if (chkerr2(dwarf_srcfiles(die->die, &srcfiles, &cnt, &err), &err)) {
int i;
files = rb_ary_new_capa(cnt);
for (i = 0; i < cnt; i++) {
VALUE file = rb_str_new_cstr(srcfiles[i]);
OBJ_FREEZE(file);
rb_ary_store(files, i, file);
dwarf_dealloc(die->shared_data->dbg, srcfiles[i], DW_DLA_STRING);
}
dwarf_dealloc(die->shared_data->dbg, srcfiles, DW_DLA_LIST);
}
die->srcfiles = files;
return files;
}
static VALUE
test_fix2long(VALUE obj, VALUE num)
{
char buf[128];
sprintf(buf, "%ld", FIX2LONG(num));
return rb_str_new_cstr(buf);
}
static VALUE
test_num2ushort(VALUE obj, VALUE num)
{
char buf[128];
sprintf(buf, "%u", NUM2USHORT(num));
return rb_str_new_cstr(buf);
}
void KeyboardEvent::run_procs(VALUE *observer, int type, int *keycode)
{
for (int i = 0; i < RARRAY_LEN(*observer); i++)
{
if (keycode_names)
key = rb_str_new_cstr(al_keycode_to_name(*keycode));
else if (unichar)
key = rb_str_new_cstr((char*)keycode);
else
key = INT2FIX(*keycode);
rb_proc_call_with_block(rb_ary_entry(*observer, i), 1, &key,
rb_ary_entry(*observer, i));
}
}
static void
rb_grn_query_logger_log (grn_ctx *ctx, unsigned int flag,
const char *timestamp, const char *info,
const char *message, void *user_data)
{
VALUE handler = (VALUE)user_data;
if (NIL_P(handler))
return;
/* TODO: use rb_protect(). */
rb_funcall(handler, id_log, 4,
GRNQUERYLOGFLAGS2RVAL(flag),
rb_str_new_cstr(timestamp),
rb_str_new_cstr(info),
rb_str_new_cstr(message));
}
/*
* Convert date to a String
*
* @return [String]
*/
static VALUE
rb_ct_date_to_string(VALUE self)
{
ct_date *date;
char *format;
CTDBRET rc;
VRLEN size = 0;
TEXT str;
GetCTDate(self, date);
switch ( date->type ) {
case CTDATE_MDCY :
format = (char *)"%m/%d/%Y";
break;
case CTDATE_DMCY :
format = (char *)"%m/%d/%y";
break;
case CTDATE_CYMD :
format = (char *)"%d/%m/%Y";
break;
case CTDATE_MDY :
format = (char *)"%d/%m/%y";
break;
case CTDATE_DMY :
format = (char *)"%Y%m%d";
break;
case CTDATE_YMD :
format = (char *)"%y%m%d";
break;
default :
rb_raise(cCTError, "Unexpected default date format");
break;
}
if ( date->value > 0 ) {
size = (VRLEN)(strlen(format) + 3);
if ( (rc = ctdbDateToString(date->value, date->type, &str, size) ) != CTDBRET_OK )
rb_raise(cCTError, "[%d] ctdbDateToString failed.", rc);
return rb_str_new_cstr(&str);
} else
return rb_str_new_cstr("");
}
/* Return a list of trace hook line numbers for the string in Ruby source src*/
static VALUE
lnums_for_str(VALUE self, VALUE src)
{
VALUE result = rb_ary_new(); /* The returned array of line numbers. */
int len;
char *token;
char *disasm;
rb_thread_t *th;
VALUE iseqval;
VALUE disasm_val;
StringValue(src); /* Check that src is a string. */
th = GET_THREAD();
/* First compile to bytecode, using the method in eval_string_with_cref() in vm_eval.c */
th->parse_in_eval++;
th->mild_compile_error++;
iseqval = rb_iseq_compile(src, rb_str_new_cstr("(numbers_for_str)"), INT2FIX(1));
th->mild_compile_error--;
th->parse_in_eval--;
/* Disassemble the bytecode into text and parse into lines */
disasm_val = rb_iseq_disasm(iseqval);
if (disasm_val == Qnil)
return(result);
disasm = (char*)malloc(strlen(RSTRING_PTR(disasm_val))+1);
strcpy(disasm, RSTRING_PTR(disasm_val));
for (token = strtok(disasm, "\n"); token != NULL; token = strtok(NULL, "\n"))
{
/* look only for lines tracing RUBY_EVENT_LINE (1) */
if (strstr(token, "trace 1 ") == NULL)
continue;
len = strlen(token) - 1;
if (token[len] != ')')
continue;
len--;
if ((token[len] == '(') || (token[len] == ' '))
continue;
for (; len > 0; len--)
{
if (token[len] == ' ')
continue;
if ((token[len] >= '0') && (token[len] <= '9'))
continue;
if (token[len] == '(')
rb_ary_push(result, INT2NUM(atoi(token + len + 1))); /* trace found */
break;
}
}
free(disasm);
return result;
}
static void
rb_grn_logger_log (grn_ctx *ctx, grn_log_level level,
const char *timestamp, const char *title, const char *message,
const char *location, void *user_data)
{
VALUE handler = (VALUE)user_data;
if (NIL_P(handler))
return;
/* TODO: use rb_protect(). */
rb_funcall(handler, id_log, 5,
GRNLOGLEVEL2RVAL(level),
rb_str_new_cstr(timestamp),
rb_str_new_cstr(title),
rb_str_new_cstr(message),
rb_str_new_cstr(location));
}
static void init_symbol_class( VALUE modBfd ) {
/* NOTE: Symbol does not support instantiation via .new() */
clsSymbol = rb_define_class_under(modBfd, SYMBOL_CLASS_NAME,
rb_cObject);
/* attributes (read-only) */
rb_define_attr(clsSymbol, SYM_ATTR_NAME, 1, 0);
rb_define_attr(clsSymbol, SYM_ATTR_VALUE, 1, 0);
rb_define_attr(clsSymbol, SYM_ATTR_FLAGS, 1, 0);
rb_define_attr(clsSymbol, SYM_ATTR_SECTION, 1, 0);
rb_define_attr(clsSymbol, SYM_ATTR_BIND, 1, 0);
/* constants */
rb_define_const(clsSymbol, SYM_BIND_DYN_NAME,
rb_str_new_cstr(SYM_BIND_DYNAMIC));
rb_define_const(clsSymbol, SYM_BIND_STAT_NAME,
rb_str_new_cstr(SYM_BIND_STATIC));
}
static VALUE wcs2rb(const wchar_t *s) {
size_t n = wcslen(s);
size_t size = n * 6; // Max size of a UTF-8 character
char bytes[size];
if (wcstombs(bytes, s, size) != n) {
encoding_failure();
}
return rb_str_new_cstr(bytes);
}
void Init_wkhtml_native() {
//Global initialization of library and when Ruby shuts down
wkhtmltopdf_init(USE_GRAPHICS_INT);
wkhtmltoimage_init(USE_GRAPHICS_INT);
rb_set_end_proc(Deinit_wkhtml_native, Qnil);
idReady = rb_intern("ready");
mWkHtml = rb_define_module("WkHtml");
rb_define_const(mWkHtml, "LIBRARY_VERSION", rb_obj_freeze(rb_str_new_cstr(wkhtmltopdf_version())));
rb_define_const(mWkHtml, "USE_GRAPHICS", INT2BOOL(USE_GRAPHICS_INT));
mWkHtmlToPdf = rb_define_module_under(mWkHtml, "ToPdf");
cWkHtmlToPdfGlobalSettings = rb_define_class_under(mWkHtmlToPdf, "GlobalSettings", rb_cObject);
rb_define_alloc_func(cWkHtmlToPdfGlobalSettings, wkhtml_topdf_globalsettings_alloc);
rb_define_method(cWkHtmlToPdfGlobalSettings, "[]=", wkhtml_topdf_globalsettings_aset, 2);
rb_define_method(cWkHtmlToPdfGlobalSettings, "[]", wkhtml_topdf_globalsettings_aref, 1);
cWkHtmlToPdfObjectSettings = rb_define_class_under(mWkHtmlToPdf, "ObjectSettings", rb_cObject);
rb_define_alloc_func(cWkHtmlToPdfObjectSettings, wkhtml_topdf_objectsettings_alloc);
rb_define_method(cWkHtmlToPdfObjectSettings, "[]=", wkhtml_topdf_objectsettings_aset, 2);
rb_define_method(cWkHtmlToPdfObjectSettings, "[]", wkhtml_topdf_objectsettings_aref, 1);
cWkHtmlToPdfConverter = rb_define_class_under(mWkHtmlToPdf, "Converter", rb_cObject);
/*
TODO
rb_define_singleton_method(klass, "new", constructor, 1); //Uses Data_Wrap_Struct -> rb_obj_call_init(t_data, 1, argv);
rb_define_method(klass, "initialize", initialize, 1);
*/
rb_define_singleton_method(cWkHtmlToPdfConverter, "create", wkhtml_topdf_converter_create, 1);
rb_define_method(cWkHtmlToPdfConverter, "add_object", wkhtml_topdf_converter_add_object, 2);
rb_define_method(cWkHtmlToPdfConverter, "convert", wkhtml_topdf_converter_convert, 0);
rb_define_method(cWkHtmlToPdfConverter, "http_error_code", wkhtml_topdf_converter_http_error_code, 0);
rb_define_method(cWkHtmlToPdfConverter, "get_output", wkhtml_topdf_converter_get_output, 0);
//Force use of factory method
rb_undef_alloc_func(cWkHtmlToPdfConverter);
rb_undef_method(rb_singleton_class(cWkHtmlToPdfConverter), "new");
mWkHtmlToImage = rb_define_module_under(mWkHtml, "ToImage");
cWkHtmlToImageGlobalSettings = rb_define_class_under(mWkHtmlToImage, "GlobalSettings", rb_cObject);
rb_define_alloc_func(cWkHtmlToImageGlobalSettings, wkhtml_toimage_globalsettings_alloc);
rb_define_method(cWkHtmlToImageGlobalSettings, "[]=", wkhtml_toimage_globalsettings_aset, 2);
rb_define_method(cWkHtmlToImageGlobalSettings, "[]", wkhtml_toimage_globalsettings_aref, 1);
cWkHtmlToImageConverter = rb_define_class_under(mWkHtmlToImage, "Converter", rb_cObject);
rb_define_singleton_method(cWkHtmlToImageConverter, "create", wkhtml_toimage_converter_create, 2);
rb_define_method(cWkHtmlToImageConverter, "convert", wkhtml_toimage_converter_convert, 0);
rb_define_method(cWkHtmlToImageConverter, "http_error_code", wkhtml_toimage_converter_http_error_code, 0);
rb_define_method(cWkHtmlToImageConverter, "get_output", wkhtml_toimage_converter_get_output, 0);
//Force use of factory method
rb_undef_alloc_func(cWkHtmlToImageConverter);
rb_undef_method(rb_singleton_class(cWkHtmlToImageConverter), "new");
}
static VALUE
rb_hello_message(VALUE self)
{
Hello *hello;
const char *message;
TypedData_Get_Struct(self, Hello, &rb_hello_type, hello);
message = hello_message(hello);
return rb_str_new_cstr(message);
}
/*
* Gets the current query log path that is used the default query logger.
*
* @overload path
* @return [String or nil] The current query log path
*
* @since 3.0.1
*/
static VALUE
rb_grn_query_logger_s_get_path (VALUE klass)
{
const char *path;
VALUE rb_path = Qnil;
path = grn_default_query_logger_get_path();
if (path) {
rb_path = rb_str_new_cstr(path);
}
return rb_path;
}
static void reader_emit(const clj_Reader *reader, const clj_Node *node) {
clj_rb_ReadData *data = (clj_rb_ReadData*)reader->data;
ID id;
VALUE s, value;
VALUE one = rb_str_new_cstr("1"); // TODO: Delete me
if (clj_is_atomic(node->type)) {
s = wcs2rb(node->value);
//TODO: begin shit code
switch (node->type) {
case CLJ_NUMBER:
value = rb_funcall(data->target, sym_number, 5,
s, one, one, Qfalse, Qfalse);
break;
case CLJ_STRING:
value = rb_funcall(data->target, sym_string, 1, s);
break;
case CLJ_CHARACTER:
value = rb_funcall(data->target, sym_character, 1, s);
break;
case CLJ_KEYWORD:
value = rb_funcall(data->target, sym_keyword, 3, s, one, one);
break;
case CLJ_SYMBOL:
value = rb_funcall(data->target, sym_symbol, 3, s, one, one);
break;
//TODO: DEFAULT CASE!
}
//TODO: END shit code
rb_funcall(data->target, sym_atomic, 1, value);
} else if (clj_is_end(node->type)) {
rb_funcall(data->target, sym_end_composite, 0);
} else {
switch (node->type) {
case CLJ_LIST:
id = sym_list_builder;
break;
case CLJ_VECTOR:
id = sym_vector_builder;
break;
case CLJ_MAP:
id = sym_map_builder;
break;
case CLJ_SET:
id = sym_set_builder;
break;
default:
assert(0); //TODO: Real error
//TODO: DEFAULT CASE!
}
value = rb_funcall(data->target, id, 0);
rb_funcall(data->target, sym_begin_composite, 1, value);
}
}
void libssh_ruby_raise(ssh_session session) {
VALUE exc, code, message;
VALUE argv[1];
code = INT2FIX(ssh_get_error_code(session));
message = rb_str_new_cstr(ssh_get_error(session));
argv[0] = message;
exc = rb_class_new_instance(1, argv, rb_eLibSSHError);
rb_ivar_set(exc, id_code, code);
rb_exc_raise(exc);
}
VALUE cbasic_to_str(VALUE self) {
basic_struct *this;
char *str_ptr;
VALUE result;
Data_Get_Struct(self, basic_struct, this);
str_ptr = basic_str(this);
result = rb_str_new_cstr(str_ptr);
basic_str_free(str_ptr);
return result;
}
