static VALUE font_open(VALUE klass, VALUE filename)
{
SWFFont font = newSWFFont_fromFile(StringValuePtr(filename));
if(font == NULL) rb_raise(rb_eRuntimeError, "could not read file");
return Data_Wrap_Struct(klass, NULL, deallocate, font);
}
VALUE ARGSS::ABitmap::rtext_size(VALUE self, VALUE str) {
ARGSS::ABitmap::CheckDisposed(self);
return Bitmap::Get(self)->GetTextSize(StringValuePtr(str)).GetARGSS();
}
VALUE am_sqlite3_database_open(int argc, VALUE *argv, VALUE class)
{
VALUE self = am_sqlite3_database_alloc(class);
VALUE rFlags;
VALUE rFilename;
int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
char* filename;
int rc;
am_sqlite3* am_db;
/* at least a filename argument is required */
rb_scan_args( argc, argv, "11", &rFilename, &rFlags );
/* convert flags to the sqlite version */
flags = ( Qnil == rFlags ) ? flags : FIX2INT(rFlags);
filename = StringValuePtr(rFilename);
/* extract the sqlite3 wrapper struct */
Data_Get_Struct(self, am_sqlite3, am_db);
/* open the sqlite3 database */
rc = sqlite3_open_v2( filename, &(am_db->db), flags, 0);
if ( SQLITE_OK != rc ) {
rb_raise(eAS_Error, "Failure to open database %s : [SQLITE_ERROR %d] : %s\n",
filename, rc, sqlite3_errmsg(am_db->db));
}
/* by default turn on the extended result codes */
rc = sqlite3_extended_result_codes( am_db->db, 1);
if ( SQLITE_OK != rc ) {
rb_raise(eAS_Error, "Failure to set extended result codes %s : [SQLITE_ERROR %d] : %s\n",
static VALUE
oletypelib_search_registry2(VALUE self, VALUE args)
{
HKEY htypelib, hguid, hversion;
double fver;
DWORD j;
LONG err;
VALUE found = Qfalse;
VALUE tlib;
VALUE ver;
VALUE version_str;
VALUE version = Qnil;
VALUE typelib = Qnil;
HRESULT hr;
ITypeLib *pTypeLib;
VALUE guid = rb_ary_entry(args, 0);
version_str = make_version_str(rb_ary_entry(args, 1), rb_ary_entry(args, 2));
err = reg_open_key(HKEY_CLASSES_ROOT, "TypeLib", &htypelib);
if(err != ERROR_SUCCESS) {
return Qfalse;
}
err = reg_open_vkey(htypelib, guid, &hguid);
if (err != ERROR_SUCCESS) {
RegCloseKey(htypelib);
return Qfalse;
}
if (version_str != Qnil) {
err = reg_open_vkey(hguid, version_str, &hversion);
if (err == ERROR_SUCCESS) {
tlib = reg_get_val(hversion, NULL);
if (tlib != Qnil) {
typelib = tlib;
version = version_str;
}
}
RegCloseKey(hversion);
} else {
fver = 0.0;
for(j = 0; ;j++) {
ver = reg_enum_key(hguid, j);
if (ver == Qnil)
break;
err = reg_open_vkey(hguid, ver, &hversion);
if (err != ERROR_SUCCESS)
continue;
tlib = reg_get_val(hversion, NULL);
if (tlib == Qnil) {
RegCloseKey(hversion);
continue;
}
if (fver < atof(StringValuePtr(ver))) {
fver = atof(StringValuePtr(ver));
version = ver;
typelib = tlib;
}
RegCloseKey(hversion);
}
}
RegCloseKey(hguid);
RegCloseKey(htypelib);
if (typelib != Qnil) {
hr = oletypelib_from_guid(guid, version, &pTypeLib);
if (SUCCEEDED(hr)) {
found = Qtrue;
oletypelib_set_member(self, pTypeLib);
}
}
return found;
}
static void full_connect(VALUE self, PGconn *db) {
PGresult *result = NULL;
VALUE r_host, r_user, r_password, r_path, r_port, r_query, r_options;
char *host = NULL, *user = NULL, *password = NULL, *path = NULL, *database = NULL;
const char *port = "5432";
VALUE encoding = Qnil;
const char *search_path = NULL;
char *search_path_query = NULL;
const char *backslash_off = "SET backslash_quote = off";
const char *standard_strings_on = "SET standard_conforming_strings = on";
const char *warning_messages = "SET client_min_messages = warning";
if((r_host = rb_iv_get(self, "@host")) != Qnil) {
host = StringValuePtr(r_host);
}
if((r_user = rb_iv_get(self, "@user")) != Qnil) {
user = StringValuePtr(r_user);
}
if((r_password = rb_iv_get(self, "@password")) != Qnil) {
password = StringValuePtr(r_password);
}
if((r_port = rb_iv_get(self, "@port")) != Qnil) {
port = StringValuePtr(r_port);
}
if((r_path = rb_iv_get(self, "@path")) != Qnil) {
path = StringValuePtr(r_path);
database = strtok(path, "/");
}
if (NULL == database || 0 == strlen(database)) {
rb_raise(eConnectionError, "Database must be specified");
}
r_query = rb_iv_get(self, "@query");
search_path = get_uri_option(r_query, "search_path");
db = PQsetdbLogin(
host,
port,
NULL,
NULL,
database,
user,
password
);
if ( PQstatus(db) == CONNECTION_BAD ) {
rb_raise(eConnectionError, "%s", PQerrorMessage(db));
}
if (search_path != NULL) {
search_path_query = (char *)calloc(256, sizeof(char));
snprintf(search_path_query, 256, "set search_path to %s;", search_path);
r_query = rb_str_new2(search_path_query);
result = cCommand_execute(self, db, r_query);
if (PQresultStatus(result) != PGRES_COMMAND_OK) {
free((void *)search_path_query);
raise_error(self, result, r_query);
}
free((void *)search_path_query);
}
r_options = rb_str_new2(backslash_off);
result = cCommand_execute(self, db, r_options);
if (PQresultStatus(result) != PGRES_COMMAND_OK) {
rb_warn("%s", PQresultErrorMessage(result));
}
r_options = rb_str_new2(standard_strings_on);
result = cCommand_execute(self, db, r_options);
if (PQresultStatus(result) != PGRES_COMMAND_OK) {
rb_warn("%s", PQresultErrorMessage(result));
}
r_options = rb_str_new2(warning_messages);
result = cCommand_execute(self, db, r_options);
if (PQresultStatus(result) != PGRES_COMMAND_OK) {
rb_warn("%s", PQresultErrorMessage(result));
}
encoding = rb_iv_get(self, "@encoding");
#ifdef HAVE_PQSETCLIENTENCODING
VALUE pg_encoding = rb_hash_aref(CONST_GET(mEncoding, "MAP"), encoding);
if(pg_encoding != Qnil) {
if(PQsetClientEncoding(db, rb_str_ptr_readonly(pg_encoding))) {
rb_raise(eConnectionError, "Couldn't set encoding: %s", rb_str_ptr_readonly(encoding));
} else {
#ifdef HAVE_RUBY_ENCODING_H
rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index(rb_str_ptr_readonly(encoding))));
#endif
rb_iv_set(self, "@pg_encoding", pg_encoding);
}
} else {
rb_warn("Encoding %s is not a known Ruby encoding for PostgreSQL\n", rb_str_ptr_readonly(encoding));
rb_iv_set(self, "@encoding", rb_str_new2("UTF-8"));
#ifdef HAVE_RUBY_ENCODING_H
rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index("UTF-8")));
#endif
rb_iv_set(self, "@pg_encoding", rb_str_new2("UTF8"));
}
#endif
rb_iv_set(self, "@connection", Data_Wrap_Struct(rb_cObject, 0, 0, db));
}
/*
* call-seq:
* Watchcat.new([options]) => watchcat_obj
* Watchcat.new([options]) { |watchcat| block } => watchcat_obj
*
* Create a new Watchcat object. The parameter hash may have the following
* symbols:
* +timeout+::
* If watchcatd doesn't receive a heartbeat after this period (in seconds),
* it will signal the process. (default: 60)
* +signal+::
* Defines which signal will be sent to the process after the timeout
* expires. Can be a string like 'HUP' or 'SIGHUP' or an integer like 9.
* (default: 9)
* +info+::
* Should be a string which is added to the log generated by watchcatd
* when it signals a process. (default: nil)
* +device+::
* The watchcat device. (default: +/var/run/watchcat.socket+). Use for
* debugging purposes.
*
* If a block is given, the Watchcat object will be yielded and automatically
* closed on block termination.
*/
static VALUE
rb_wcat_open(int argc, VALUE *argv, VALUE self)
{
int sock, timeout, signal;
char *signame;
const char *info;
VALUE opt, vtimeout, vsignal, vinfo, vdevice, vsiglist, mSignal;
rb_scan_args(argc, argv, "01", &opt);
if (NIL_P(opt)) {
sock = cat_open();
if (sock == -1)
rb_sys_fail("cat_open");
rb_iv_set(self, "@sock", INT2NUM(sock));
return(self);
}
/* Defaults. */
timeout = 60;
signal = SIGKILL;
info = NULL;
vtimeout = rb_hash_aref(opt, SYMBOL("timeout"));
if (!NIL_P(vtimeout)) {
if (FIXNUM_P(vtimeout))
timeout = NUM2INT(vtimeout);
else
rb_raise(rb_eArgError, "timeout must be an integer");
}
vsignal = rb_hash_aref(opt, SYMBOL("signal"));
if (!NIL_P(vsignal)) {
switch (TYPE(vsignal)) {
case T_FIXNUM:
signal = NUM2INT(vsignal);
break;
case T_STRING:
signame = StringValuePtr(vsignal);
if (strncmp("SIG", signame, 3) == 0) {
signame += 3;
vsignal = rb_str_new2(signame);
}
mSignal = rb_const_get(rb_cObject, rb_intern("Signal"));
vsiglist = rb_funcall(mSignal, rb_intern("list"), 0);
vsignal = rb_hash_aref(vsiglist, vsignal);
if (NIL_P(vsignal))
rb_raise(rb_eArgError, "invalid signal name");
else
signal = NUM2INT(vsignal);
break;
default:
rb_raise(rb_eArgError, "signal must be an integer or a string");
}
}
vinfo = rb_hash_aref(opt, SYMBOL("info"));
if (!NIL_P(vinfo))
info = StringValuePtr(vinfo);
vdevice = rb_hash_aref(opt, SYMBOL("device"));
if (!NIL_P(vdevice))
cat_set_device(StringValuePtr(vdevice));
sock = cat_open1(timeout, signal, info);
if (sock == -1)
rb_sys_fail("cat_open");
rb_iv_set(self, "@sock", INT2NUM(sock));
if (rb_block_given_p())
rb_ensure(rb_yield, self, (void *)cat_close, sock);
return(self);
}
/*
* call-seq:
* ctx.setup => Qtrue # first time
* ctx.setup => nil # thereafter
*
* This method is called automatically when a new SSLSocket is created.
* Normally you do not need to call this method (unless you are writing an extension in C).
*/
static VALUE
ossl_sslctx_setup(VALUE self)
{
SSL_CTX *ctx;
X509 *cert = NULL, *client_ca = NULL;
X509_STORE *store;
EVP_PKEY *key = NULL;
char *ca_path = NULL, *ca_file = NULL;
int i, verify_mode;
VALUE val;
if(OBJ_FROZEN(self)) return Qnil;
Data_Get_Struct(self, SSL_CTX, ctx);
#if !defined(OPENSSL_NO_DH)
if (RTEST(ossl_sslctx_get_tmp_dh_cb(self))){
SSL_CTX_set_tmp_dh_callback(ctx, ossl_tmp_dh_callback);
}
else{
SSL_CTX_set_tmp_dh_callback(ctx, ossl_default_tmp_dh_callback);
}
#endif
SSL_CTX_set_ex_data(ctx, ossl_ssl_ex_ptr_idx, (void*)self);
val = ossl_sslctx_get_cert_store(self);
if(!NIL_P(val)){
/*
* WORKAROUND:
* X509_STORE can count references, but
* X509_STORE_free() doesn't care it.
* So we won't increment it but mark it by ex_data.
*/
store = GetX509StorePtr(val); /* NO NEED TO DUP */
SSL_CTX_set_cert_store(ctx, store);
SSL_CTX_set_ex_data(ctx, ossl_ssl_ex_store_p, (void*)1);
}
val = ossl_sslctx_get_extra_cert(self);
if(!NIL_P(val)){
rb_block_call(val, rb_intern("each"), 0, 0, ossl_sslctx_add_extra_chain_cert_i, self);
}
/* private key may be bundled in certificate file. */
val = ossl_sslctx_get_cert(self);
cert = NIL_P(val) ? NULL : GetX509CertPtr(val); /* NO DUP NEEDED */
val = ossl_sslctx_get_key(self);
key = NIL_P(val) ? NULL : GetPKeyPtr(val); /* NO DUP NEEDED */
if (cert && key) {
if (!SSL_CTX_use_certificate(ctx, cert)) {
/* Adds a ref => Safe to FREE */
ossl_raise(eSSLError, "SSL_CTX_use_certificate:");
}
if (!SSL_CTX_use_PrivateKey(ctx, key)) {
/* Adds a ref => Safe to FREE */
ossl_raise(eSSLError, "SSL_CTX_use_PrivateKey:");
}
if (!SSL_CTX_check_private_key(ctx)) {
ossl_raise(eSSLError, "SSL_CTX_check_private_key:");
}
}
val = ossl_sslctx_get_client_ca(self);
if(!NIL_P(val)){
if(TYPE(val) == T_ARRAY){
for(i = 0; i < RARRAY_LEN(val); i++){
client_ca = GetX509CertPtr(RARRAY_PTR(val)[i]);
if (!SSL_CTX_add_client_CA(ctx, client_ca)){
/* Copies X509_NAME => FREE it. */
ossl_raise(eSSLError, "SSL_CTX_add_client_CA");
}
}
}
else{
client_ca = GetX509CertPtr(val); /* NO DUP NEEDED. */
if (!SSL_CTX_add_client_CA(ctx, client_ca)){
/* Copies X509_NAME => FREE it. */
ossl_raise(eSSLError, "SSL_CTX_add_client_CA");
}
}
}
val = ossl_sslctx_get_ca_file(self);
ca_file = NIL_P(val) ? NULL : StringValuePtr(val);
val = ossl_sslctx_get_ca_path(self);
ca_path = NIL_P(val) ? NULL : StringValuePtr(val);
if(ca_file || ca_path){
if (!SSL_CTX_load_verify_locations(ctx, ca_file, ca_path))
rb_warning("can't set verify locations");
}
val = ossl_sslctx_get_verify_mode(self);
verify_mode = NIL_P(val) ? SSL_VERIFY_NONE : NUM2INT(val);
SSL_CTX_set_verify(ctx, verify_mode, ossl_ssl_verify_callback);
if (RTEST(ossl_sslctx_get_client_cert_cb(self)))
SSL_CTX_set_client_cert_cb(ctx, ossl_client_cert_cb);
val = ossl_sslctx_get_timeout(self);
if(!NIL_P(val)) SSL_CTX_set_timeout(ctx, NUM2LONG(val));
val = ossl_sslctx_get_verify_dep(self);
if(!NIL_P(val)) SSL_CTX_set_verify_depth(ctx, NUM2LONG(val));
val = ossl_sslctx_get_options(self);
if(!NIL_P(val)) SSL_CTX_set_options(ctx, NUM2LONG(val));
rb_obj_freeze(self);
val = ossl_sslctx_get_sess_id_ctx(self);
if (!NIL_P(val)){
StringValue(val);
if (!SSL_CTX_set_session_id_context(ctx, RSTRING_PTR(val),
RSTRING_LEN(val))){
ossl_raise(eSSLError, "SSL_CTX_set_session_id_context:");
}
}
if (RTEST(rb_iv_get(self, "@session_get_cb"))) {
SSL_CTX_sess_set_get_cb(ctx, ossl_sslctx_session_get_cb);
OSSL_Debug("SSL SESSION get callback added");
}
if (RTEST(rb_iv_get(self, "@session_new_cb"))) {
SSL_CTX_sess_set_new_cb(ctx, ossl_sslctx_session_new_cb);
OSSL_Debug("SSL SESSION new callback added");
}
if (RTEST(rb_iv_get(self, "@session_remove_cb"))) {
SSL_CTX_sess_set_remove_cb(ctx, ossl_sslctx_session_remove_cb);
OSSL_Debug("SSL SESSION remove callback added");
}
return Qtrue;
}
/* call-seq: stmt.bind_param(key, value)
*
* Binds value to the named (or positional) placeholder. If +param+ is a
* Fixnum, it is treated as an index for a positional placeholder.
* Otherwise it is used as the name of the placeholder to bind to.
*
* See also #bind_params.
*/
static VALUE bind_param(VALUE self, VALUE key, VALUE value)
{
sqlite3StmtRubyPtr ctx;
int status;
int index;
Data_Get_Struct(self, sqlite3StmtRuby, ctx);
REQUIRE_OPEN_STMT(ctx);
switch(TYPE(key)) {
case T_SYMBOL:
key = rb_funcall(key, rb_intern("to_s"), 0);
case T_STRING:
if(RSTRING_PTR(key)[0] != ':') key = rb_str_plus(rb_str_new2(":"), key);
index = sqlite3_bind_parameter_index(ctx->st, StringValuePtr(key));
break;
default:
index = (int)NUM2INT(key);
}
if(index == 0)
rb_raise(rb_path2class("SQLite3::Exception"), "no such bind parameter");
switch(TYPE(value)) {
case T_STRING:
if(CLASS_OF(value) == cSqlite3Blob
#ifdef HAVE_RUBY_ENCODING_H
|| rb_enc_get_index(value) == rb_ascii8bit_encindex()
#endif
) {
status = sqlite3_bind_blob(
ctx->st,
index,
(const char *)StringValuePtr(value),
(int)RSTRING_LEN(value),
SQLITE_TRANSIENT
);
} else {
#ifdef HAVE_RUBY_ENCODING_H
if(!UTF8_P(value)) {
VALUE db = rb_iv_get(self, "@connection");
VALUE encoding = rb_funcall(db, rb_intern("encoding"), 0);
rb_encoding * enc = rb_to_encoding(encoding);
value = rb_str_export_to_enc(value, enc);
}
#endif
status = sqlite3_bind_text(
ctx->st,
index,
(const char *)StringValuePtr(value),
(int)RSTRING_LEN(value),
SQLITE_TRANSIENT
);
}
break;
case T_BIGNUM:
#if SIZEOF_LONG < 8
if (RBIGNUM_LEN(value) * SIZEOF_BDIGITS <= 8) {
status = sqlite3_bind_int64(ctx->st, index, (sqlite3_int64)NUM2LL(value));
break;
}
#endif
case T_FLOAT:
status = sqlite3_bind_double(ctx->st, index, NUM2DBL(value));
break;
case T_FIXNUM:
status = sqlite3_bind_int64(ctx->st, index, (sqlite3_int64)FIX2LONG(value));
break;
case T_NIL:
status = sqlite3_bind_null(ctx->st, index);
break;
default:
rb_raise(rb_eRuntimeError, "can't prepare %s",
rb_class2name(CLASS_OF(value)));
break;
}
CHECK(sqlite3_db_handle(ctx->st), status);
return self;
}
static VALUE
string_to_r_internal(VALUE self)
{
VALUE s, m;
s = self;
if (RSTRING_LEN(s) == 0)
return rb_assoc_new(Qnil, self);
m = f_match(rat_pat, s);
if (!NIL_P(m)) {
VALUE v, ifp, exp, ip, fp;
VALUE si = f_aref(m, INT2FIX(1));
VALUE nu = f_aref(m, INT2FIX(2));
VALUE de = f_aref(m, INT2FIX(3));
VALUE re = f_post_match(m);
{
VALUE a;
a = f_split(nu, an_e_pat);
ifp = RARRAY_PTR(a)[0];
if (RARRAY_LEN(a) != 2)
exp = Qnil;
else
exp = RARRAY_PTR(a)[1];
a = f_split(ifp, a_dot_pat);
ip = RARRAY_PTR(a)[0];
if (RARRAY_LEN(a) != 2)
fp = Qnil;
else
fp = RARRAY_PTR(a)[1];
}
v = rb_rational_new1(f_to_i(ip));
if (!NIL_P(fp)) {
char *p = StringValuePtr(fp);
long count = 0;
VALUE l;
while (*p) {
if (rb_isdigit(*p))
count++;
p++;
}
l = f_expt(INT2FIX(10), LONG2NUM(count));
v = f_mul(v, l);
v = f_add(v, f_to_i(fp));
v = f_div(v, l);
}
if (!NIL_P(si) && *StringValuePtr(si) == '-')
v = f_negate(v);
if (!NIL_P(exp))
v = f_mul(v, f_expt(INT2FIX(10), f_to_i(exp)));
#if 0
if (!NIL_P(de) && (!NIL_P(fp) || !NIL_P(exp)))
return rb_assoc_new(v, rb_usascii_str_new2("dummy"));
#endif
if (!NIL_P(de))
v = f_div(v, f_to_i(de));
return rb_assoc_new(v, re);
}
return rb_assoc_new(Qnil, self);
}
int
weechat_ruby_print_exception (VALUE err)
{
VALUE backtrace, tmp1, tmp2, tmp3;
int i;
int ruby_error;
char* line;
char* cline;
char* err_msg;
char* err_class;
backtrace = rb_protect_funcall (err, rb_intern("backtrace"),
&ruby_error, 0, NULL);
tmp1 = rb_protect_funcall(err, rb_intern("message"), &ruby_error, 0, NULL);
err_msg = StringValueCStr(tmp1);
tmp2 = rb_protect_funcall(rb_protect_funcall(err, rb_intern("class"),
&ruby_error, 0, NULL),
rb_intern("name"), &ruby_error, 0, NULL);
err_class = StringValuePtr(tmp2);
if (strcmp (err_class, "SyntaxError") == 0)
{
tmp3 = rb_inspect(err);
weechat_printf (NULL,
weechat_gettext ("%s%s: error: %s"),
weechat_prefix ("error"), RUBY_PLUGIN_NAME,
StringValuePtr(tmp3));
}
else
{
for (i = 0; i < RARRAY_LEN(backtrace); i++)
{
line = StringValuePtr(RARRAY_PTR(backtrace)[i]);
cline = NULL;
if (i == 0)
{
cline = (char *)calloc (strlen (line) + 2 + strlen (err_msg) +
3 + strlen (err_class) + 1,
sizeof (char));
if (cline)
{
strcat (cline, line);
strcat (cline, ": ");
strcat (cline, err_msg);
strcat (cline, " (");
strcat (cline, err_class);
strcat (cline, ")");
}
}
else
{
cline = (char *)calloc(strlen (line) + strlen (" from ") + 1,
sizeof (char));
if (cline)
{
strcat (cline, " from ");
strcat (cline, line);
}
}
if (cline)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: error: %s"),
weechat_prefix ("error"), RUBY_PLUGIN_NAME,
cline);
}
if (cline)
free (cline);
}
}
return 0;
}
void *
weechat_ruby_exec (struct t_plugin_script *script,
int ret_type, const char *function,
const char *format, void **argv)
{
VALUE rc, err;
int ruby_error, i, argc, *ret_i;
VALUE argv2[16];
void *ret_value;
struct t_plugin_script *old_ruby_current_script;
old_ruby_current_script = ruby_current_script;
ruby_current_script = script;
argc = 0;
if (format && format[0])
{
argc = strlen (format);
for (i = 0; i < argc; i++)
{
switch (format[i])
{
case 's': /* string */
argv2[i] = rb_str_new2 ((char *)argv[i]);
break;
case 'i': /* integer */
argv2[i] = INT2FIX (*((int *)argv[i]));
break;
case 'h': /* hash */
argv2[i] = weechat_ruby_hashtable_to_hash (argv[i]);
break;
}
}
}
if (argc > 0)
{
rc = rb_protect_funcall ((VALUE) script->interpreter,
rb_intern(function),
&ruby_error, argc, argv2);
}
else
{
rc = rb_protect_funcall ((VALUE) script->interpreter,
rb_intern(function),
&ruby_error, 0, NULL);
}
if (ruby_error)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to run function \"%s\""),
weechat_prefix ("error"), RUBY_PLUGIN_NAME, function);
err = rb_gv_get("$!");
weechat_ruby_print_exception(err);
return NULL;
}
if ((TYPE(rc) == T_STRING) && (ret_type == WEECHAT_SCRIPT_EXEC_STRING))
{
if (StringValuePtr (rc))
ret_value = strdup (StringValuePtr (rc));
else
ret_value = NULL;
}
else if ((TYPE(rc) == T_FIXNUM) && (ret_type == WEECHAT_SCRIPT_EXEC_INT))
{
ret_i = malloc (sizeof (*ret_i));
if (ret_i)
*ret_i = NUM2INT(rc);
ret_value = ret_i;
}
else if (ret_type == WEECHAT_SCRIPT_EXEC_HASHTABLE)
{
ret_value = weechat_ruby_hash_to_hashtable (rc,
WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE,
WEECHAT_HASHTABLE_STRING,
WEECHAT_HASHTABLE_STRING);
}
else
{
weechat_printf (NULL,
weechat_gettext ("%s%s: function \"%s\" must return a "
"valid value"),
weechat_prefix ("error"), RUBY_PLUGIN_NAME, function);
ruby_current_script = old_ruby_current_script;
return WEECHAT_RC_OK;
}
if (ret_value == NULL)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: not enough memory in function "
"\"%s\""),
weechat_prefix ("error"), RUBY_PLUGIN_NAME, function);
ruby_current_script = old_ruby_current_script;
return NULL;
}
ruby_current_script = old_ruby_current_script;
return ret_value;
}
VALUE xmlsec_is_valid_by_x509_file(VALUE self, xmlDocPtr doc, VALUE x509_file ) {
xmlSecKeysMngrPtr mngr;
VALUE v;
xmlNodePtr node = NULL;
xmlSecDSigCtxPtr dsigCtx = NULL;
long i;
mngr = xmlSecKeysMngrCreate();
if(mngr == NULL) {
if(doc != NULL) xmlFreeDoc(doc);
rb_raise(rb_eRuntimeError, "Error: failed to create keys manager.\n");
return Qnil;
}
if(xmlSecCryptoAppDefaultKeysMngrInit(mngr) < 0) {
if(doc != NULL) xmlFreeDoc(doc);
if(mngr != NULL) xmlSecKeysMngrDestroy(mngr);
rb_raise(rb_eRuntimeError, "Error: failed to initialize keys manager.\n");
return Qnil;
}
if (TYPE(x509_file) == T_STRING){
/* load trusted cert */
if(xmlSecCryptoAppKeysMngrCertLoad(mngr, StringValuePtr(x509_file), xmlSecKeyDataFormatPem, xmlSecKeyDataTypeTrusted) < 0) {
if(doc != NULL) xmlFreeDoc(doc);
if(mngr != NULL) xmlSecKeysMngrDestroy(mngr);
rb_raise(rb_eRuntimeError, "Error: failed to load pem certificate from \"%s\"\n", StringValuePtr(x509_file));
return Qnil;
}
}
if (TYPE(x509_file) == T_ARRAY) {
for (i =0; i < RARRAY_LEN(x509_file); i++) {
v = rb_ary_entry(x509_file, i);
StringValue(v);
if(xmlSecCryptoAppKeysMngrCertLoad(mngr, RSTRING_PTR(v), xmlSecKeyDataFormatPem, xmlSecKeyDataTypeTrusted) < 0) {
if(doc != NULL) xmlFreeDoc(doc);
if(mngr != NULL) xmlSecKeysMngrDestroy(mngr);
rb_raise(rb_eRuntimeError, "Error: failed to load pem certificate from \"%s\"\n", RSTRING_PTR(v));
return Qnil;
}
}
//rb_ary_entry
}
/* find start node */
node = xmlSecFindNode(xmlDocGetRootElement(doc), xmlSecNodeSignature, xmlSecDSigNs);
if(node == NULL) {
if(doc != NULL) xmlFreeDoc(doc);
rb_raise(rb_eRuntimeError, "Error: start node not found\n");
return Qnil;
}
/* create signature context*/
dsigCtx = xmlSecDSigCtxCreate(mngr);
if(dsigCtx == NULL) {
if(doc != NULL) xmlFreeDoc(doc);
if(mngr != NULL) xmlSecKeysMngrDestroy(mngr);
rb_raise(rb_eRuntimeError, "Error: failed to create signature context\n");
return Qnil;
}
/* limit the Reference URI attributes to empty or NULL */
dsigCtx->enabledReferenceUris = xmlSecTransformUriTypeEmpty;
/* Verify signature */
if(xmlSecDSigCtxVerify(dsigCtx, node) < 0) {
if(dsigCtx != NULL) xmlSecDSigCtxDestroy(dsigCtx);
if(doc != NULL) xmlFreeDoc(doc);
if(mngr != NULL) xmlSecKeysMngrDestroy(mngr);
rb_raise(rb_eRuntimeError, "Error: signature verify \"%s\"\n");
return Qnil;
}
/* verification result*/
if(dsigCtx->status == xmlSecDSigStatusSucceeded) {
if(dsigCtx != NULL) xmlSecDSigCtxDestroy(dsigCtx);
if(doc != NULL) xmlFreeDoc(doc);
if(mngr != NULL) xmlSecKeysMngrDestroy(mngr);
return Qtrue;
} else {
if(dsigCtx != NULL) xmlSecDSigCtxDestroy(dsigCtx);
if(doc != NULL) xmlFreeDoc(doc);
if(mngr != NULL) xmlSecKeysMngrDestroy(mngr);
return Qfalse;
}
}
/*
* call-seq:
* new
*
* Create a new document
*/
static VALUE new(int argc, VALUE *argv, VALUE klass)
{
VALUE uri, external_id, rest, rb_doc;
rb_scan_args(argc, argv, "0*", &rest);
uri = rb_ary_entry(rest, 0);
external_id = rb_ary_entry(rest, 1);
htmlDocPtr doc = htmlNewDoc(
RTEST(uri) ? (const xmlChar *)StringValuePtr(uri) : NULL,
RTEST(external_id) ? (const xmlChar *)StringValuePtr(external_id) : NULL
);
rb_doc = Nokogiri_wrap_xml_document(klass, doc);
rb_funcall2(rb_doc, rb_intern("initialize"), argc, argv);
return rb_doc ;
}
/*
* call-seq:
* read_io(io, url, encoding, options)
*
* Read the HTML document from +io+ with given +url+, +encoding+,
* and +options+. See Nokogiri::HTML.parse
*/
static VALUE read_io( VALUE klass,
static VALUE alphadecimal_base62_decode(VALUE self, VALUE arg) {
char* str = StringValuePtr(arg);
long val = base62_decode(str);
return ULL2NUM(val);
}
VALUE kernel_spec_rb_warn(VALUE self, VALUE msg) {
rb_warn("%s", StringValuePtr(msg));
return Qnil;
}
/**
* This method creates a database parameter buffer to be used in creating a
* database connection.
*
* @param user A reference to a string containing the user name to be used
* in making the connection.
* @param password A reference to a string containing the password to be used
* in making the connection.
* @param options A hash of the options to be used in making the connection
* to the database.
* @param length A pointer to a short integer that will be set to the
* length of the buffer.
*
* @return A pointer to an array of characters containing the database
* parameter buffer.
*
*/
char *createDPB(VALUE user, VALUE password, VALUE options, short *length) {
char *dpb = NULL;
VALUE keys;
VALUE entry;
int i;
short type;
/* Determine the dpb length and allocate it. */
*length = 1;
if(user != Qnil) {
*length += strlen(StringValuePtr(user)) + 2;
}
if(password != Qnil) {
*length += strlen(StringValuePtr(password)) + 2;
}
if(options != Qnil) {
keys = rb_funcall(options, rb_intern("keys"), 0);
for(i = 0; i < RARRAY_LEN(keys); i++) {
type = FIX2INT(rb_ary_entry(keys, i));
switch (type) {
case isc_dpb_sql_role_name:
case isc_dpb_lc_messages:
case isc_dpb_lc_ctype:
case isc_dpb_reserved:
{
entry = rb_hash_aref(options, INT2FIX(type));
*length += strlen(StringValuePtr(entry)) + 2;
break;
}
default:
{
*length += 3;
}
}
}
}
dpb = ALLOC_N(char, *length);
/* Populate the buffer. */
if(dpb != NULL) {
char *ptr = NULL;
int size = 0;
/* Fill out the DPB. */
memset(dpb, 0, *length);
dpb[0] = isc_dpb_version1;
ptr = &dpb[1];
if(user != Qnil) {
char *username = StringValuePtr(user);
size = strlen(username);
*ptr++ = isc_dpb_user_name;
*ptr++ = (char)size;
memcpy(ptr, username, size);
ptr = ptr + size;
}
if(password != Qnil) {
char *userpwd = StringValuePtr(password);
size = strlen(userpwd);
*ptr++ = isc_dpb_password;
*ptr++ = (char)size;
memcpy(ptr, userpwd, size);
ptr = ptr + size;
}
if(options != Qnil) {
for(i = 0; i < RARRAY_LEN(keys); i++) {
type = FIX2INT(rb_ary_entry(keys, i));
entry = rb_hash_aref(options, INT2FIX(type));
switch (type) {
case isc_dpb_sql_role_name:
case isc_dpb_lc_messages:
case isc_dpb_lc_ctype:
case isc_dpb_reserved:
{
char *text = StringValuePtr(entry);
size = strlen(text);
*ptr++ = type;
*ptr++ = (char)size;
memcpy(ptr, text, size);
ptr = ptr + size;
break;
}
default:
{
short value;
switch (TYPE(entry)) {
case T_FIXNUM: value = FIX2INT(entry);
case T_NIL: value = 0;
case T_FALSE: value = 0;
case T_TRUE: value = 1;
case T_UNDEF: value = 0;
case T_FLOAT: value = NUM2INT(entry);
case T_BIGNUM: value = NUM2INT(entry);
default: value = 0;
}
*ptr++ = type;
*ptr++ = (char)1;
*ptr++ = value;
}
}
}
}
} else {
/* Generate an error. */
rb_raise(rb_eNoMemError,
"Memory allocation failure creating database DPB.");
}
return(dpb);
}
VALUE kernel_spec_rb_catch(VALUE self, VALUE sym, VALUE main_proc) {
return rb_catch(StringValuePtr(sym), kernel_spec_call_proc_with_catch, main_proc);
}
// Used for our rb_protect calls.
static VALUE evaluateSimpleImpl(VALUE arg)
{
return rb_eval_string(StringValuePtr(arg));
}
}
/*
* call-seq:
* XML::Schema.initialize(schema_uri) -> schema
*
* Create a new schema from the specified URI.
*/
static VALUE rxml_schema_init_from_uri(VALUE class, VALUE uri)
{
xmlSchemaParserCtxtPtr xparser;
xmlSchemaPtr xschema;
Check_Type(uri, T_STRING);
xparser = xmlSchemaNewParserCtxt(StringValuePtr(uri));
xschema = xmlSchemaParse(xparser);
xmlSchemaFreeParserCtxt(xparser);
return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
}
/*
* call-seq:
* XML::Schema.document(document) -> schema
*
* Create a new schema from the specified document.
*/
static VALUE rxml_schema_init_from_document(VALUE class, VALUE document)
{
xmlDocPtr xdoc;
static VALUE new(int argc, VALUE *argv, VALUE klass)
{
xmlDocPtr xml_doc;
xmlNodePtr node;
VALUE document;
VALUE content;
VALUE rest;
VALUE rb_node;
rb_scan_args(argc, argv, "2*", &document, &content, &rest);
Data_Get_Struct(document, xmlDoc, xml_doc);
node = xmlNewDocComment(
xml_doc,
(const xmlChar *)StringValuePtr(content)
);
rb_node = Nokogiri_wrap_xml_node(klass, node);
rb_obj_call_init(rb_node, argc, argv);
nokogiri_root_node(node);
if(rb_block_given_p()) rb_yield(rb_node);
return rb_node;
}
VALUE cNokogiriXmlComment;
void init_xml_comment()
{
char*
rb_compat_str2cstr(VALUE x)
{
return StringValuePtr(x);
}
static VALUE t_send_data (VALUE self, VALUE signature, VALUE data, VALUE data_length)
{
int b = evma_send_data_to_connection (NUM2ULONG (signature), StringValuePtr (data), FIX2INT (data_length));
return INT2NUM (b);
}
static void
process_sflag(int *sflag)
{
if (*sflag > 0) {
long n;
VALUE *args;
VALUE argv = rb_argv;
n = RARRAY_LEN(argv);
args = RARRAY_PTR(argv);
while (n > 0) {
VALUE v = *args++;
char *s = StringValuePtr(v);
char *p;
int hyphen = FALSE;
if (s[0] != '-')
break;
n--;
if (s[1] == '-' && s[2] == '\0')
break;
v = Qtrue;
/* check if valid name before replacing - with _ */
for (p = s + 1; *p; p++) {
if (*p == '=') {
*p++ = '\0';
v = rb_str_new2(p);
break;
}
if (*p == '-') {
hyphen = TRUE;
}
else if (*p != '_' && !ISALNUM(*p)) {
VALUE name_error[2];
name_error[0] =
rb_str_new2("invalid name for global variable - ");
if (!(p = strchr(p, '='))) {
rb_str_cat2(name_error[0], s);
}
else {
rb_str_cat(name_error[0], s, p - s);
}
name_error[1] = args[-1];
rb_exc_raise(rb_class_new_instance(2, name_error, rb_eNameError));
}
}
s[0] = '$';
if (hyphen) {
for (p = s + 1; *p; ++p) {
if (*p == '-')
*p = '_';
}
}
rb_gv_set(s, v);
}
n = RARRAY_LEN(argv) - n;
while (n--) {
rb_ary_shift(argv);
}
*sflag = -1;
}
}
static VALUE t_send_datagram (VALUE self, VALUE signature, VALUE data, VALUE data_length, VALUE address, VALUE port)
{
int b = evma_send_datagram (NUM2ULONG (signature), StringValuePtr (data), FIX2INT (data_length), StringValuePtr(address), FIX2INT(port));
return INT2NUM (b);
}
static int
rb_feature_p(const char *feature, const char *ext, int rb, int expanded, const char **fn)
{
VALUE v, features, p, load_path = 0;
const char *f, *e;
long i, len, elen, n;
st_table *loading_tbl;
st_data_t data;
int type;
if (fn) *fn = 0;
if (ext) {
elen = strlen(ext);
len = strlen(feature) - elen;
type = rb ? 'r' : 's';
}
else {
len = strlen(feature);
elen = 0;
type = 0;
}
features = get_loaded_features();
for (i = 0; i < RARRAY_LEN(features); ++i) {
v = RARRAY_PTR(features)[i];
f = StringValuePtr(v);
if ((n = RSTRING_LEN(v)) < len) continue;
if (strncmp(f, feature, len) != 0) {
if (expanded) continue;
if (!load_path) load_path = rb_get_expanded_load_path();
if (!(p = loaded_feature_path(f, n, feature, len, type, load_path)))
continue;
expanded = 1;
f += RSTRING_LEN(p) + 1;
}
if (!*(e = f + len)) {
if (ext) continue;
return 'u';
}
if (*e != '.') continue;
if ((!rb || !ext) && (IS_SOEXT(e) || IS_DLEXT(e))) {
return 's';
}
if ((rb || !ext) && (IS_RBEXT(e))) {
return 'r';
}
}
loading_tbl = get_loading_table();
if (loading_tbl) {
f = 0;
if (!expanded) {
struct loaded_feature_searching fs;
fs.name = feature;
fs.len = len;
fs.type = type;
fs.load_path = load_path ? load_path : rb_get_load_path();
fs.result = 0;
st_foreach(loading_tbl, loaded_feature_path_i, (st_data_t)&fs);
if ((f = fs.result) != 0) {
if (fn) *fn = f;
goto loading;
}
}
if (st_get_key(loading_tbl, (st_data_t)feature, &data)) {
if (fn) *fn = (const char*)data;
loading:
if (!ext) return 'u';
return !IS_RBEXT(ext) ? 's' : 'r';
}
else {
VALUE bufstr;
char *buf;
if (ext && *ext) return 0;
bufstr = rb_str_tmp_new(len + DLEXT_MAXLEN);
buf = RSTRING_PTR(bufstr);
MEMCPY(buf, feature, char, len);
for (i = 0; (e = loadable_ext[i]) != 0; i++) {
strlcpy(buf + len, e, DLEXT_MAXLEN + 1);
if (st_get_key(loading_tbl, (st_data_t)buf, &data)) {
rb_str_resize(bufstr, 0);
if (fn) *fn = (const char*)data;
return i ? 's' : 'r';
}
}
rb_str_resize(bufstr, 0);
}
}
return 0;
}
static VALUE t_setuid_string (VALUE self, VALUE username)
{
evma_setuid_string (StringValuePtr (username));
return Qnil;
}
/*
* Returns a nested hash based on the values passed to the constructor. How
* deeply that hash is nested depends on the values passed to the constructor.
* The more specific your criterion, the less data you will receive.
*/
VALUE ks_record(VALUE self){
volatile VALUE v_m_hash, v_i_hash, v_n_hash, v_s_hash;
KstatStruct* ptr;
kstat_io_t kio;
kstat_timer_t kt;
char* module;
char* name;
int instance = -1; // -1 represents all instances (the default)
VALUE v_module, v_instance, v_name;
Data_Get_Struct(self,KstatStruct,ptr);
v_m_hash = rb_hash_new(); // Module name is key, holds v_i_hashes
v_module = rb_iv_get(self, "@module");
v_instance = rb_iv_get(self, "@instance");
v_name = rb_iv_get(self, "@name");
// Module is NULL by default (i.e. all modules are returned)
if(NIL_P(v_module))
module = NULL;
else
module = StringValuePtr(v_module);
// Instance defaults to -1 (i.e. all instances are returned)
if(!NIL_P(v_instance))
instance = NUM2INT(v_instance);
// Name is NULL by default (i.e. all names are returned)
if(NIL_P(v_name))
name = NULL;
else
name = StringValuePtr(v_name);
// A failure probably means the module, instance or name doesn't exist
if((ptr->kc = kstat_open()) == NULL)
rb_raise(cKstatError, "kstat_open() failure: %s", strerror(errno));
/*
* Traverse the kstat chain, looking for matches based on supplied data.
* A failure likely means a non-existant module or name was provided.
*/
if((ptr->ksp = kstat_lookup(ptr->kc, module, instance, name)) == NULL)
rb_raise(cKstatError, "kstat_lookup() failure: %s", strerror(errno));
// Sync the chain with the kernel
if(kstat_chain_update(ptr->kc) == -1)
rb_raise(cKstatError, "kstat_chain_update() failure: %s", strerror(errno));
while(ptr->ksp){
// If a module is specified, ignore modules that don't match
if((module) && (strcmp(module,ptr->ksp->ks_module))){
ptr->ksp = ptr->ksp->ks_next;
continue;
}
// If an instance is specified, ignore instances that don't match
if((instance != -1) && (instance != ptr->ksp->ks_instance)){
ptr->ksp = ptr->ksp->ks_next;
continue;
}
// If a name is specified, ignore names that don't match
if((name) && (strcmp(name,ptr->ksp->ks_name))){
ptr->ksp = ptr->ksp->ks_next;
continue;
}
// Call the appropriate data mapper based on ks_type
switch(ptr->ksp->ks_type){
case KSTAT_TYPE_NAMED:
kstat_read(ptr->kc, ptr->ksp, NULL);
v_s_hash = map_named_data_type(ptr->ksp);
break;
case KSTAT_TYPE_IO:
kstat_read(ptr->kc, ptr->ksp, &kio);
v_s_hash = map_io_data_type(&kio);
break;
case KSTAT_TYPE_TIMER:
kstat_read(ptr->kc, ptr->ksp, &kt);
v_s_hash = map_timer_data_type(&kt);
break;
case KSTAT_TYPE_INTR:
kstat_read(ptr->kc, ptr->ksp, NULL);
v_s_hash = map_intr_data_type(ptr->ksp);
break;
case KSTAT_TYPE_RAW:
kstat_read(ptr->kc, ptr->ksp, NULL);
v_s_hash = map_raw_data_type(ptr->ksp);
break;
default:
rb_raise(cKstatError,"Unknown data record type");
}
/* Set the class for this set of statistics */
if(ptr->ksp->ks_class)
rb_hash_aset(v_s_hash, rb_str_new2("class"), rb_str_new2(ptr->ksp->ks_class));
v_i_hash = get_hash_for_key(v_m_hash, rb_str_new2(ptr->ksp->ks_module));
v_n_hash = get_hash_for_key(v_i_hash, INT2FIX(ptr->ksp->ks_instance));
rb_hash_aset(v_n_hash, rb_str_new2(ptr->ksp->ks_name), v_s_hash);
rb_hash_aset(v_i_hash, INT2FIX(ptr->ksp->ks_instance), v_n_hash);
rb_hash_aset(v_m_hash, rb_str_new2(ptr->ksp->ks_module), v_i_hash);
ptr->ksp = ptr->ksp->ks_next;
}
return v_m_hash;
}
/**
* call-seq:
* 23874.localize(:decimal, 'es_ES') => 23.874
*/
VALUE rb_numeric_localize(int argc, VALUE *argv, VALUE self)
{
VALUE style, options;
UNumberFormatStyle formatStyle;
char *locale = NULL;
UNumberFormat *format;
UErrorCode status;
UChar result[256];
/* arguments */
rb_scan_args(argc, argv, "02", &style, &options);
if (style == Qnil) {
formatStyle = UNUM_DECIMAL;
} else {
ID style_ID;
Check_Type(style, T_SYMBOL);
style_ID = SYM2ID(style);
if (style_ID == rb_intern("decimal")) {
formatStyle = UNUM_DECIMAL;
} else if (style_ID == rb_intern("currency")) {
formatStyle = UNUM_CURRENCY;
} else if (style_ID == rb_intern("percent")) {
formatStyle = UNUM_PERCENT;
} else if (style_ID == rb_intern("scientific")) {
formatStyle = UNUM_SCIENTIFIC;
} else if (style_ID == rb_intern("spellout")) {
formatStyle = UNUM_SPELLOUT;
} else {
rb_raise(rb_eArgError, "unsupported format style %s", rb_id2name(style_ID));
}
}
if (options != Qnil) {
VALUE rb_locale;
Check_Type(options, T_HASH);
rb_locale = rb_hash_aref(options, ID2SYM(rb_intern("locale")));
if (rb_locale != Qnil) {
locale = StringValuePtr(rb_locale);
}
}
/* formatter */
status = U_ZERO_ERROR;
format = unum_open(formatStyle, NULL, 0, locale, NULL, &status);
RAISE_ON_ERROR(status);
/* set format attributes */
if (options != Qnil) {
VALUE currency, precision, round_mode, round_increment;
switch (formatStyle) {
case UNUM_CURRENCY:
currency = rb_hash_aref(options, ID2SYM(rb_intern("currency")));
if (currency != Qnil) {
UChar *uStr;
int32_t uStrLen;
uStr = u_strFromRString(currency, &uStrLen);
status = U_ZERO_ERROR;
unum_setTextAttribute(format, UNUM_CURRENCY_CODE, uStr, uStrLen, &status);
RAISE_ON_ERROR(status);
}
case UNUM_DECIMAL:
/* precision */
precision = rb_hash_aref(options, ID2SYM(rb_intern("precision")));
if (precision != Qnil) {
Check_Type(precision, T_FIXNUM);
status = U_ZERO_ERROR;
unum_setAttribute(format, UNUM_FRACTION_DIGITS, NUM2INT(precision));
RAISE_ON_ERROR(status);
}
round_mode = rb_hash_aref(options, ID2SYM(rb_intern("round_mode")));
if (round_mode != Qnil) {
ID round_mode_ID;
UNumberFormatRoundingMode rounding_mode;
Check_Type(round_mode, T_SYMBOL);
round_mode_ID = SYM2ID(round_mode);
if (round_mode_ID == rb_intern("ceil")) {
rounding_mode = UNUM_ROUND_CEILING;
} else if (round_mode_ID == rb_intern("floor")) {
rounding_mode = UNUM_ROUND_FLOOR;
} else if (round_mode_ID == rb_intern("down")) {
rounding_mode = UNUM_ROUND_DOWN;
} else if (round_mode_ID == rb_intern("up")) {
rounding_mode = UNUM_ROUND_UP;
} else if (round_mode_ID == rb_intern("halfeven")) {
rounding_mode = UNUM_FOUND_HALFEVEN;
} else if (round_mode_ID == rb_intern("halfdown")) {
rounding_mode = UNUM_ROUND_HALFDOWN;
} else if (round_mode_ID == rb_intern("halfup")) {
rounding_mode = UNUM_ROUND_HALFUP;
} else {
rb_raise(rb_eArgError, "unsupported rounding mode '%s'", rb_id2name(round_mode_ID));
}
status = U_ZERO_ERROR;
unum_setAttribute(format, UNUM_ROUNDING_MODE, rounding_mode);
RAISE_ON_ERROR(status);
}
round_increment = rb_hash_aref(options, ID2SYM(rb_intern("round_increment")));
if (round_increment != Qnil) {
Check_Type(round_increment, T_FLOAT);
status = U_ZERO_ERROR;
unum_setDoubleAttribute(format, UNUM_ROUNDING_INCREMENT, NUM2DBL(round_increment));
RAISE_ON_ERROR(status);
}
}
}
/* format */
status = U_ZERO_ERROR;
switch (TYPE(self)) {
case T_FIXNUM:
unum_format(format, NUM2INT(self), result, 256, NULL, &status);
break;
case T_FLOAT:
unum_formatDouble(format, NUM2DBL(self), result, 256, NULL, &status);
break;
case T_BIGNUM:
unum_formatInt64(format, rb_big2ll(self), result, 256, NULL, &status);
break;
}
RAISE_ON_ERROR(status);
/* free resources */
unum_close(format);
return u_strToRString(result, -1);
}
/* call-seq:
* client.query(sql, options = {})
*
* Query the database with +sql+, with optional +options+. For the possible
* options, see @@default_query_options on the Mysql2::Client class.
*/
static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
#ifndef _WIN32
struct async_query_args async_args;
#endif
struct nogvl_send_query_args args;
int async = 0;
VALUE opts, current;
VALUE thread_current = rb_thread_current();
#ifdef HAVE_RUBY_ENCODING_H
rb_encoding *conn_enc;
#endif
GET_CLIENT(self);
REQUIRE_CONNECTED(wrapper);
args.mysql = wrapper->client;
current = rb_hash_dup(rb_iv_get(self, "@query_options"));
RB_GC_GUARD(current);
Check_Type(current, T_HASH);
rb_iv_set(self, "@current_query_options", current);
if (rb_scan_args(argc, argv, "11", &args.sql, &opts) == 2) {
rb_funcall(current, intern_merge_bang, 1, opts);
if (rb_hash_aref(current, sym_async) == Qtrue) {
async = 1;
}
}
Check_Type(args.sql, T_STRING);
#ifdef HAVE_RUBY_ENCODING_H
conn_enc = rb_to_encoding(wrapper->encoding);
/* ensure the string is in the encoding the connection is expecting */
args.sql = rb_str_export_to_enc(args.sql, conn_enc);
#endif
args.sql_ptr = StringValuePtr(args.sql);
args.sql_len = RSTRING_LEN(args.sql);
/* see if this connection is still waiting on a result from a previous query */
if (NIL_P(wrapper->active_thread)) {
/* mark this connection active */
wrapper->active_thread = thread_current;
} else if (wrapper->active_thread == thread_current) {
rb_raise(cMysql2Error, "This connection is still waiting for a result, try again once you have the result");
} else {
VALUE inspect = rb_inspect(wrapper->active_thread);
const char *thr = StringValueCStr(inspect);
rb_raise(cMysql2Error, "This connection is in use by: %s", thr);
RB_GC_GUARD(inspect);
}
args.wrapper = wrapper;
#ifndef _WIN32
rb_rescue2(do_send_query, (VALUE)&args, disconnect_and_raise, self, rb_eException, (VALUE)0);
if (!async) {
async_args.fd = wrapper->client->net.fd;
async_args.self = self;
rb_rescue2(do_query, (VALUE)&async_args, disconnect_and_raise, self, rb_eException, (VALUE)0);
return rb_mysql_client_async_result(self);
} else {
return Qnil;
}
#else
do_send_query(&args);
/* this will just block until the result is ready */
return rb_ensure(rb_mysql_client_async_result, self, finish_and_mark_inactive, self);
#endif
}
static VALUE cConnection_initialize(VALUE self, VALUE uri) {
VALUE r_host, r_user, r_password, r_path, r_query, r_port;
char *host = "localhost", *user = "******", *password = NULL, *path;
char *database = "", *socket = NULL;
char *encoding = NULL;
int port = 3306;
unsigned long client_flags = 0;
int encoding_error;
MYSQL *db = 0, *result;
db = (MYSQL *)mysql_init(NULL);
rb_iv_set(self, "@using_socket", Qfalse);
r_host = rb_funcall(uri, rb_intern("host"), 0);
if (Qnil != r_host) {
host = StringValuePtr(r_host);
}
r_user = rb_funcall(uri, rb_intern("user"), 0);
if (Qnil != r_user) {
user = StringValuePtr(r_user);
}
r_password = rb_funcall(uri, rb_intern("password"), 0);
if (Qnil != r_password) {
password = StringValuePtr(r_password);
}
r_path = rb_funcall(uri, rb_intern("path"), 0);
path = StringValuePtr(r_path);
if (Qnil != r_path) {
database = strtok(path, "/");
}
if (NULL == database || 0 == strlen(database)) {
rb_raise(eMysqlError, "Database must be specified");
}
// Pull the querystring off the URI
r_query = rb_funcall(uri, rb_intern("query"), 0);
// Check to see if we're on the db machine. If so, try to use the socket
if (0 == strcasecmp(host, "localhost")) {
socket = get_uri_option(r_query, "socket");
if (NULL != socket) {
rb_iv_set(self, "@using_socket", Qtrue);
}
}
r_port = rb_funcall(uri, rb_intern("port"), 0);
if (Qnil != r_port) {
port = NUM2INT(r_port);
}
encoding = get_uri_option(r_query, "encoding");
if (!encoding) { encoding = get_uri_option(r_query, "charset"); }
if (!encoding) { encoding = "utf8"; }
// If ssl? {
// mysql_ssl_set(db, key, cert, ca, capath, cipher)
// }
my_bool reconnect = 1;
mysql_options(db, MYSQL_OPT_RECONNECT, &reconnect);
result = (MYSQL *)mysql_real_connect(
db,
host,
user,
password,
database,
port,
socket,
client_flags
);
if (NULL == result) {
raise_mysql_error(Qnil, db, -1, NULL);
}
// Set the connections character set
encoding_error = mysql_set_character_set(db, encoding);
if (0 != encoding_error) {
raise_mysql_error(Qnil, db, encoding_error, NULL);
}
rb_iv_set(self, "@uri", uri);
rb_iv_set(self, "@connection", Data_Wrap_Struct(rb_cObject, 0, 0, db));
return Qtrue;
}