sync/ports
1
0
Fork 0
mirror of https://git.freebsd.org/ports.git synced 2025-06-06 05:10:29 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
ports/databases/ruby-bdb/files/patch-src-common.c

1327 lines
42 KiB
C
Raw Blame History

--- src/common.c.orig 2011-04-06 19:35:39 UTC
+++ src/common.c
@@ -273,7 +273,7 @@ bdb_test_load(VALUE obj, DBT *a, int type_kv)
res = Qnil;
}
else {
- res = rb_tainted_str_new(a->data, a->size);
+ res = rb_str_new(a->data, a->size);
if (dbst->filter[2 + posi]) {
if (FIXNUM_P(dbst->filter[2 + posi])) {
res = rb_funcall(obj, NUM2INT(dbst->filter[2 + posi]),
@@ -494,7 +494,7 @@ bdb_h_hash(DB *dbbd, const void *bytes, u_int32_t leng
#endif
GetIdDbSec(obj, dbst, dbbd);
- st = rb_tainted_str_new((char *)bytes, length);
+ st = rb_str_new((char *)bytes, length);
if (dbst->h_hash == 0)
res = rb_funcall(obj, id_h_hash, 1, st);
else
@@ -603,7 +603,7 @@ compar_func(VALUE value)
}
static VALUE
-bdb_i_options(VALUE obj, VALUE dbstobj)
+bdb_i_options(VALUE obj, VALUE dbstobj, int _argc, const VALUE *_argv, VALUE _blockarg)
{
VALUE key, value;
char *options, *str;
@@ -1080,9 +1080,11 @@ bdb_close(int argc, VALUE *argv, VALUE obj)
bdb_DB *dbst;
int flags = 0;
+#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 4
if (!OBJ_TAINTED(obj) && rb_safe_level() >= 4) {
rb_raise(rb_eSecurityError, "Insecure: can't close the database");
}
+#endif
Data_Get_Struct(obj, bdb_DB, dbst);
if (dbst->dbp != NULL) {
if (rb_scan_args(argc, argv, "01", &opt)) {
@@ -1140,8 +1142,7 @@ bdb_hard_count(dbp)
#endif
static long
-bdb_is_recnum(dbp)
- DB *dbp;
+bdb_is_recnum(DB *dbp)
{
DB_BTREE_STAT *bdb_stat;
long count;
@@ -1172,8 +1173,7 @@ bdb_is_recnum(dbp)
}
static VALUE
-bdb_recno_length(obj)
- VALUE obj;
+bdb_recno_length(VALUE obj)
{
bdb_DB *dbst;
DB_BTREE_STAT *bdb_stat;
@@ -1229,7 +1229,7 @@ bdb_s_new(int argc, VALUE *argv, VALUE obj)
if (argc && TYPE(argv[argc - 1]) == T_HASH) {
VALUE v, f = argv[argc - 1];
- if ((v = rb_hash_aref(f, rb_str_new2("txn"))) != RHASH(f)->ifnone) {
+ if ((v = rb_hash_lookup(f, rb_str_new2("txn"))) != Qnil) {
if (!rb_obj_is_kind_of(v, bdb_cTxn)) {
rb_raise(bdb_eFatal, "argument of txn must be a transaction");
}
@@ -1241,7 +1241,7 @@ bdb_s_new(int argc, VALUE *argv, VALUE obj)
dbst->options |= envst->options & BDB_NO_THREAD;
dbst->marshal = txnst->marshal;
}
- else if ((v = rb_hash_aref(f, rb_str_new2("env"))) != RHASH(f)->ifnone) {
+ else if ((v = rb_hash_lookup(f, rb_str_new2("env"))) != Qnil) {
if (!rb_obj_is_kind_of(v, bdb_cEnv)) {
rb_raise(bdb_eFatal, "argument of env must be an environnement");
}
@@ -1254,11 +1254,11 @@ bdb_s_new(int argc, VALUE *argv, VALUE obj)
#if HAVE_CONST_DB_ENCRYPT
if (envst && (envst->options & BDB_ENV_ENCRYPT)) {
VALUE tmp = rb_str_new2("set_flags");
- if ((v = rb_hash_aref(f, rb_intern("set_flags"))) != RHASH(f)->ifnone) {
+ if ((v = rb_hash_lookup(f, rb_intern("set_flags"))) != Qnil) {
rb_hash_aset(f, rb_intern("set_flags"),
INT2NUM(NUM2INT(v) | DB_ENCRYPT));
}
- else if ((v = rb_hash_aref(f, tmp)) != RHASH(f)->ifnone) {
+ else if ((v = rb_hash_lookup(f, tmp)) != Qnil) {
rb_hash_aset(f, tmp, INT2NUM(NUM2INT(v) | DB_ENCRYPT));
}
else {
@@ -1338,7 +1338,7 @@ bdb_init(int argc, VALUE *argv, VALUE obj)
#endif
if (argc && TYPE(argv[argc - 1]) == T_HASH) {
hash_arg = argv[argc - 1];
- rb_iterate(rb_each, argv[argc - 1], bdb_i_options, obj);
+ rb_block_call(argv[argc - 1], rb_intern("each"), 0, NULL, bdb_i_options, obj);
argc--;
}
mode = flags = 0;
@@ -1431,15 +1431,19 @@ bdb_init(int argc, VALUE *argv, VALUE obj)
dbst->options |= BDB_FEEDBACK;
}
#endif
+#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 2
if (flags & DB_TRUNCATE) {
rb_secure(2);
}
+#endif
+#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 4
if (flags & DB_CREATE) {
rb_secure(4);
}
if (rb_safe_level() >= 4) {
flags |= DB_RDONLY;
}
+#endif
#if HAVE_CONST_DB_DUPSORT
if (dbst->options & BDB_DUP_COMPARE) {
#if HAVE_TYPE_DB_INFO
@@ -1540,12 +1544,12 @@ bdb_init(int argc, VALUE *argv, VALUE obj)
}
dbst->filename = dbst->database = Qnil;
if (name) {
- dbst->filename = rb_tainted_str_new2(name);
+ dbst->filename = rb_str_new_cstr(name);
OBJ_FREEZE(dbst->filename);
}
#if HAVE_ST_DB_OPEN
if (subname) {
- dbst->database = rb_tainted_str_new2(subname);
+ dbst->database = rb_str_new_cstr(subname);
OBJ_FREEZE(dbst->database);
}
#endif
@@ -1570,10 +1574,10 @@ bdb_init(int argc, VALUE *argv, VALUE obj)
#endif
switch(dbst->type) {
case DB_BTREE:
- RBASIC(obj)->klass = bdb_cBtree;
+ RBASIC_SET_CLASS_RAW(obj, bdb_cBtree);
break;
case DB_HASH:
- RBASIC(obj)->klass = bdb_cHash;
+ RBASIC_SET_CLASS_RAW(obj, bdb_cHash);
break;
case DB_RECNO:
{
@@ -1581,17 +1585,17 @@ bdb_init(int argc, VALUE *argv, VALUE obj)
rb_warning("It's hard to distinguish Recnum with Recno for all versions of Berkeley DB");
if ((count = bdb_is_recnum(dbst->dbp)) != -1) {
- RBASIC(obj)->klass = bdb_cRecnum;
+ RBASIC_SET_CLASS_RAW(obj, bdb_cRecnum);
dbst->len = count;
}
else {
- RBASIC(obj)->klass = bdb_cRecno;
+ RBASIC_SET_CLASS_RAW(obj, bdb_cRecno);
}
break;
}
#if HAVE_CONST_DB_QUEUE
case DB_QUEUE:
- RBASIC(obj)->klass = bdb_cQueue;
+ RBASIC_SET_CLASS_RAW(obj, bdb_cQueue);
break;
#endif
default:
@@ -1625,8 +1629,7 @@ bdb_init(int argc, VALUE *argv, VALUE obj)
}
static VALUE
-bdb_s_alloc(obj)
- VALUE obj;
+bdb_s_alloc(VALUE obj)
{
VALUE res, cl;
bdb_DB *dbst;
@@ -1635,29 +1638,29 @@ bdb_s_alloc(obj)
dbst->options = BDB_NOT_OPEN;
cl = obj;
while (cl) {
- if (cl == bdb_cBtree || RCLASS(cl)->m_tbl == RCLASS(bdb_cBtree)->m_tbl) {
+ if (cl == bdb_cBtree || RCLASS_M_TBL(cl) == RCLASS_M_TBL(bdb_cBtree)) {
dbst->type = DB_BTREE;
break;
}
- if (cl == bdb_cRecnum || RCLASS(cl)->m_tbl == RCLASS(bdb_cRecnum)->m_tbl) {
+ if (cl == bdb_cRecnum || RCLASS_M_TBL(cl) == RCLASS_M_TBL(bdb_cRecnum)) {
dbst->type = DB_RECNO;
break;
}
- else if (cl == bdb_cHash || RCLASS(cl)->m_tbl == RCLASS(bdb_cHash)->m_tbl) {
+ else if (cl == bdb_cHash || RCLASS_M_TBL(cl) == RCLASS_M_TBL(bdb_cHash)) {
dbst->type = DB_HASH;
break;
}
- else if (cl == bdb_cRecno || RCLASS(cl)->m_tbl == RCLASS(bdb_cRecno)->m_tbl) {
+ else if (cl == bdb_cRecno || RCLASS_M_TBL(cl) == RCLASS_M_TBL(bdb_cRecno)) {
dbst->type = DB_RECNO;
break;
}
#if HAVE_CONST_DB_QUEUE
- else if (cl == bdb_cQueue || RCLASS(cl)->m_tbl == RCLASS(bdb_cQueue)->m_tbl) {
+ else if (cl == bdb_cQueue || RCLASS_M_TBL(cl) == RCLASS_M_TBL(bdb_cQueue)) {
dbst->type = DB_QUEUE;
break;
}
#endif
- else if (cl == bdb_cUnknown || RCLASS(cl)->m_tbl == RCLASS(bdb_cUnknown)->m_tbl) {
+ else if (cl == bdb_cUnknown || RCLASS_M_TBL(cl) == RCLASS_M_TBL(bdb_cUnknown)) {
dbst->type = DB_UNKNOWN;
break;
}
@@ -1671,8 +1674,7 @@ bdb_s_alloc(obj)
}
static VALUE
-bdb_i_s_create(obj, db)
- VALUE obj, db;
+bdb_i_s_create(VALUE obj, VALUE db, int _argc, const VALUE *_argv, VALUE _blockarg)
{
VALUE tmp[2];
tmp[0] = rb_ary_entry(obj, 0);
@@ -1689,7 +1691,7 @@ bdb_s_create(int argc, VALUE *argv, VALUE obj)
res = rb_funcall2(obj, rb_intern("new"), 0, 0);
if (argc == 1 && TYPE(argv[0]) == T_HASH) {
- rb_iterate(rb_each, argv[0], bdb_i_s_create, res);
+ rb_block_call(argv[0], rb_intern("each"), 0, NULL, bdb_i_s_create, res);
return res;
}
if (argc % 2 != 0) {
@@ -1718,8 +1720,7 @@ struct re {
};
static VALUE
-bdb_queue_i_search_re_len(obj, restobj)
- VALUE obj, restobj;
+bdb_queue_i_search_re_len(VALUE obj, VALUE restobj, int _argc, const VALUE *_argv, VALUE _blockarg)
{
VALUE key, value;
char *str;
@@ -1760,14 +1761,14 @@ bdb_queue_s_new(int argc, VALUE *argv, VALUE obj)
rest->re_len = -1;
rest->re_pad = -1;
if (argc && TYPE(argv[argc - 1]) == T_HASH) {
- rb_iterate(rb_each, argv[argc - 1], bdb_queue_i_search_re_len, restobj);
+ rb_block_call(argv[argc - 1], rb_intern("each"), 0, NULL, bdb_queue_i_search_re_len, restobj);
if (rest->re_len <= 0) {
rest->re_len = DEFAULT_RECORD_LENGTH;
- rb_hash_aset(argv[argc - 1], rb_tainted_str_new2("set_re_len"), INT2NUM(rest->re_len));
+ rb_hash_aset(argv[argc - 1], rb_str_new_cstr("set_re_len"), INT2NUM(rest->re_len));
}
if (rest->re_pad < 0) {
rest->re_pad = DEFAULT_RECORD_PAD;
- rb_hash_aset(argv[argc - 1], rb_tainted_str_new2("set_re_pad"), INT2NUM(rest->re_pad));
+ rb_hash_aset(argv[argc - 1], rb_str_new_cstr("set_re_pad"), INT2NUM(rest->re_pad));
}
nargv = argv;
}
@@ -1777,8 +1778,8 @@ bdb_queue_s_new(int argc, VALUE *argv, VALUE obj)
nargv[argc] = rb_hash_new();
rest->re_len = DEFAULT_RECORD_LENGTH;
rest->re_pad = DEFAULT_RECORD_PAD;
- rb_hash_aset(nargv[argc], rb_tainted_str_new2("set_re_len"), INT2NUM(DEFAULT_RECORD_LENGTH));
- rb_hash_aset(nargv[argc], rb_tainted_str_new2("set_re_pad"), INT2NUM(DEFAULT_RECORD_PAD));
+ rb_hash_aset(nargv[argc], rb_str_new_cstr("set_re_len"), INT2NUM(DEFAULT_RECORD_LENGTH));
+ rb_hash_aset(nargv[argc], rb_str_new_cstr("set_re_pad"), INT2NUM(DEFAULT_RECORD_PAD));
argc += 1;
}
ret = bdb_s_new(argc, nargv, obj);
@@ -1790,9 +1791,7 @@ bdb_queue_s_new(int argc, VALUE *argv, VALUE obj)
#endif
static VALUE
-bdb_append_internal(argc, argv, obj, flag, retval)
- int argc, flag;
- VALUE *argv, obj;
+bdb_append_internal(int argc, VALUE *argv, VALUE obj, int flag, retval)
{
bdb_DB *dbst;
DB_TXN *txnid;
@@ -1800,9 +1799,11 @@ bdb_append_internal(argc, argv, obj, flag, retval)
db_recno_t recno;
int i;
VALUE *a, ary = Qnil;
- volatile VALUE res = Qnil;
+ volatile VALUE res;
+#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 4
rb_secure(4);
+#endif
if (argc < 1)
return obj;
INIT_TXN(txnid, obj, dbst);
@@ -1876,7 +1877,7 @@ bdb_unshift(int argc, VALUE *argv, VALUE obj)
VALUE
bdb_put(int argc, VALUE *argv, VALUE obj)
{
- volatile VALUE a0 = Qnil;
+ volatile VALUE a0;
volatile VALUE b0 = Qnil;
VALUE a, b, c;
bdb_DB *dbst;
@@ -1885,7 +1886,9 @@ bdb_put(int argc, VALUE *argv, VALUE obj)
int ret, flags;
db_recno_t recno;
+#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 4
rb_secure(4);
+#endif
INIT_TXN(txnid, obj, dbst);
flags = 0;
a = b = c = Qnil;
@@ -1924,8 +1927,7 @@ bdb_put(int argc, VALUE *argv, VALUE obj)
}
static VALUE
-bdb_aset(obj, a, b)
- VALUE obj, a, b;
+bdb_aset(VALUE obj, VALUE a, VALUE b)
{
VALUE tmp[2];
tmp[0] = a;
@@ -1935,9 +1937,7 @@ bdb_aset(obj, a, b)
}
VALUE
-bdb_test_load_key(obj, key)
- VALUE obj;
- DBT *key;
+bdb_test_load_key(VALUE obj, DBT *key)
{
bdb_DB *dbst;
Data_Get_Struct(obj, bdb_DB, dbst);
@@ -1947,18 +1947,14 @@ bdb_test_load_key(obj, key)
}
VALUE
-bdb_assoc(obj, key, data)
- VALUE obj;
- DBT *key, *data;
+bdb_assoc(VALUE obj, DBT *key, DBT *data)
{
return rb_assoc_new(bdb_test_load_key(obj, key),
bdb_test_load(obj, data, FILTER_VALUE));
}
VALUE
-bdb_assoc_dyna(obj, key, data)
- VALUE obj;
- DBT *key, *data;
+bdb_assoc_dyna(VALUE obj, DBT *key, DBT *data)
{
VALUE k, v;
int to_free = key->flags & DB_DBT_MALLOC;
@@ -1976,9 +1972,7 @@ bdb_assoc_dyna(obj, key, data)
#if HAVE_ST_DB_PGET
static VALUE
-bdb_assoc2(obj, skey, pkey, data)
- VALUE obj;
- DBT *skey, *pkey, *data;
+bdb_assoc2(VALUE obj, DBT *skey, DBT *pkey, DBT *data)
{
return rb_assoc_new(
rb_assoc_new(bdb_test_load_key(obj, skey), bdb_test_load_key(obj, pkey)),
@@ -1988,9 +1982,7 @@ bdb_assoc2(obj, skey, pkey, data)
#endif
VALUE
-bdb_assoc3(obj, skey, pkey, data)
- VALUE obj;
- DBT *skey, *pkey, *data;
+bdb_assoc3(VALUE obj, DBT *skey, DBT *pkey, DBT *data)
{
return rb_ary_new3(3, bdb_test_load_key(obj, skey),
bdb_test_load_key(obj, pkey),
@@ -2006,12 +1998,7 @@ static VALUE bdb_has_both_internal _((VALUE, VALUE, VA
#endif
static VALUE
-bdb_get_internal(argc, argv, obj, notfound, dyna)
- int argc;
- VALUE *argv;
- VALUE obj;
- VALUE notfound;
- int dyna;
+bdb_get_internal(int argc, VALUE *argv, VALUE obj, VALUE notfound, int dyna)
{
VALUE a = Qnil;
VALUE b = Qnil;
@@ -2019,13 +2006,12 @@ bdb_get_internal(argc, argv, obj, notfound, dyna)
bdb_DB *dbst;
DB_TXN *txnid;
DBT key, data;
- int flagss;
int ret, flags;
db_recno_t recno;
void *tmp_data = 0;
INIT_TXN(txnid, obj, dbst);
- flagss = flags = 0;
+ flags = 0;
MEMZERO(&key, DBT, 1);
MEMZERO(&data, DBT, 1);
data.flags |= DB_DBT_MALLOC;
@@ -2043,7 +2029,7 @@ bdb_get_internal(argc, argv, obj, notfound, dyna)
}
break;
case 2:
- flagss = flags = NUM2INT(b);
+ flags = NUM2INT(b);
break;
}
a = bdb_test_recno(obj, &key, &recno, a);
@@ -2128,13 +2114,12 @@ bdb_pget(int argc, VALUE *argv, VALUE obj)
bdb_DB *dbst;
DB_TXN *txnid;
DBT pkey, data, skey;
- int flagss;
int ret, flags;
db_recno_t srecno;
void *tmp_data = 0;
INIT_TXN(txnid, obj, dbst);
- flagss = flags = 0;
+ flags = 0;
MEMZERO(&skey, DBT, 1);
MEMZERO(&pkey, DBT, 1);
MEMZERO(&data, DBT, 1);
@@ -2150,7 +2135,7 @@ bdb_pget(int argc, VALUE *argv, VALUE obj)
}
break;
case 2:
- flagss = flags = NUM2INT(b);
+ flags = NUM2INT(b);
break;
}
a = bdb_test_recno(obj, &skey, &srecno, a);
@@ -2174,15 +2159,14 @@ bdb_pget(int argc, VALUE *argv, VALUE obj)
#if HAVE_TYPE_DB_KEY_RANGE
static VALUE
-bdb_btree_key_range(obj, a)
- VALUE obj, a;
+bdb_btree_key_range(VALUE obj, VALUE a)
{
bdb_DB *dbst;
DB_TXN *txnid;
DBT key;
db_recno_t recno;
DB_KEY_RANGE key_range;
- volatile VALUE b = Qnil;
+ volatile VALUE b;
INIT_TXN(txnid, obj, dbst);
MEMZERO(&key, DBT, 1);
@@ -2203,8 +2187,7 @@ struct data_flags {
};
static VALUE
-bdb_compact_i(obj, dataobj)
- VALUE obj, dataobj;
+bdb_compact_i(VALUE obj, VALUE dataobj, int _argc, const VALUE *_argv, VALUE _blockarg)
{
VALUE key, value;
char *str;
@@ -2255,10 +2238,10 @@ bdb_treerec_compact(int argc, VALUE *argv, VALUE obj)
struct data_flags *dtf;
VALUE dtobj;
- dtobj = Data_Make_Struct(rb_cData, struct data_flags, 0, free, dtf);
+ dtobj = Data_Make_Struct(rb_cObject, struct data_flags, 0, free, dtf);
dtf->cdata = &cdata;
dtf->flags = 0;
- rb_iterate(rb_each, c, bdb_compact_i, dtobj);
+ rb_block_call(c, rb_intern("each"), 0, NULL, bdb_compact_i, dtobj);
flags = dtf->flags;
}
/* ... */
@@ -2280,16 +2263,16 @@ bdb_treerec_compact(int argc, VALUE *argv, VALUE obj)
bdb_test_error(dbst->dbp->compact(dbst->dbp, txnid, pstart, pstop, &cdata,
flags, &end));
result = rb_hash_new();
- rb_hash_aset(result, rb_tainted_str_new2("end"), bdb_test_load_key(obj, &end));
- rb_hash_aset(result, rb_tainted_str_new2("compact_deadlock"),
+ rb_hash_aset(result, rb_str_new_cstr("end"), bdb_test_load_key(obj, &end));
+ rb_hash_aset(result, rb_str_new_cstr("compact_deadlock"),
INT2NUM(cdata.compact_deadlock));
- rb_hash_aset(result, rb_tainted_str_new2("compact_levels"),
+ rb_hash_aset(result, rb_str_new_cstr("compact_levels"),
INT2NUM(cdata.compact_levels));
- rb_hash_aset(result, rb_tainted_str_new2("compact_pages_free"),
+ rb_hash_aset(result, rb_str_new_cstr("compact_pages_free"),
INT2NUM(cdata.compact_pages_free));
- rb_hash_aset(result, rb_tainted_str_new2("compact_pages_examine"),
+ rb_hash_aset(result, rb_str_new_cstr("compact_pages_examine"),
INT2NUM(cdata.compact_pages_examine));
- rb_hash_aset(result, rb_tainted_str_new2("compact_pages_truncated"),
+ rb_hash_aset(result, rb_str_new_cstr("compact_pages_truncated"),
INT2NUM(cdata.compact_pages_truncated));
return result;
}
@@ -2301,8 +2284,7 @@ bdb_treerec_compact(int argc, VALUE *argv, VALUE obj)
#if HAVE_CONST_DB_NEXT_DUP
static VALUE
-bdb_count(obj, a)
- VALUE obj, a;
+bdb_count(VALUE obj, VALUE a)
{
bdb_DB *dbst;
DB_TXN *txnid;
@@ -2311,7 +2293,7 @@ bdb_count(obj, a)
int ret, flags27;
db_recno_t recno;
db_recno_t count;
- volatile VALUE b = Qnil;
+ volatile VALUE b;
INIT_TXN(txnid, obj, dbst);
MEMZERO(&key, DBT, 1);
@@ -2364,8 +2346,7 @@ bdb_count(obj, a)
#if HAVE_CONST_DB_CONSUME
static VALUE
-bdb_consume(obj)
- VALUE obj;
+bdb_consume(VALUE obj)
{
bdb_DB *dbst;
DB_TXN *txnid;
@@ -2374,7 +2355,9 @@ bdb_consume(obj)
int ret;
db_recno_t recno;
+#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 4
rb_secure(4);
+#endif
INIT_TXN(txnid, obj, dbst);
MEMZERO(&key, DBT, 1);
MEMZERO(&data, DBT, 1);
@@ -2396,8 +2379,7 @@ bdb_consume(obj)
#endif
static VALUE
-bdb_has_key(obj, key)
- VALUE obj, key;
+bdb_has_key(VALUE obj, VALUE key)
{
return (bdb_get_internal(1, &key, obj, Qundef, 0) == Qundef)?Qfalse:Qtrue;
}
@@ -2405,8 +2387,7 @@ bdb_has_key(obj, key)
#if CANT_DB_CURSOR_GET_BOTH
static VALUE
-bdb_has_both_internal(obj, a, b, flag)
- VALUE obj, a, b, flag;
+bdb_has_both_internal(VALUE obj, VALUE a, VALUE b, VALUE flag)
{
bdb_DB *dbst;
DB_TXN *txnid;
@@ -2491,8 +2472,7 @@ bdb_has_both_internal(obj, a, b, flag)
#endif
static VALUE
-bdb_has_both(obj, a, b)
- VALUE obj, a, b;
+bdb_has_both(VALUE obj, VALUE a, VALUE b)
{
#if ! HAVE_CONST_DB_GET_BOTH
return bdb_has_both_internal(obj, a, b, Qfalse);
@@ -2502,8 +2482,8 @@ bdb_has_both(obj, a, b)
DBT key, data;
int ret, flags;
db_recno_t recno;
- volatile VALUE c = Qnil;
- volatile VALUE d = Qnil;
+ volatile VALUE c;
+ volatile VALUE d;
void *tmp_key, *tmp_data;
INIT_TXN(txnid, obj, dbst);
@@ -2540,8 +2520,7 @@ bdb_has_both(obj, a, b)
}
VALUE
-bdb_del(obj, a)
- VALUE a, obj;
+bdb_del(VALUE obj, VALUE a)
{
bdb_DB *dbst;
DB_TXN *txnid;
@@ -2549,9 +2528,11 @@ bdb_del(obj, a)
DBT key;
int ret;
db_recno_t recno;
- volatile VALUE b = Qnil;
+ volatile VALUE b;
+#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 4
rb_secure(4);
+#endif
INIT_TXN(txnid, obj, dbst);
#if HAVE_CONST_DB_AUTO_COMMIT
if (txnid == NULL && (dbst->options & BDB_AUTO_COMMIT)) {
@@ -2568,8 +2549,7 @@ bdb_del(obj, a)
}
static VALUE
-bdb_empty(obj)
- VALUE obj;
+bdb_empty(VALUE obj)
{
bdb_DB *dbst;
DB_TXN *txnid;
@@ -2603,8 +2583,7 @@ bdb_empty(obj)
}
static VALUE
-bdb_lgth_intern(obj, delete)
- VALUE obj, delete;
+bdb_lgth_intern(VALUE obj, VALUE delete)
{
bdb_DB *dbst;
DB_TXN *txnid;
@@ -2646,8 +2625,7 @@ bdb_lgth_intern(obj, delete)
}
static VALUE
-bdb_length(obj)
- VALUE obj;
+bdb_length(VALUE obj)
{
return bdb_lgth_intern(obj, Qfalse);
}
@@ -2667,10 +2645,10 @@ typedef struct {
} eachst;
static VALUE
-bdb_each_ensure(st)
- eachst *st;
+bdb_each_ensure(VALUE pst)
{
#if HAVE_CONST_DB_MULTIPLE_KEY
+ eachst *st = (eachst *)pst;
if (st->len && st->data) {
free(st->data);
}
@@ -2680,9 +2658,7 @@ bdb_each_ensure(st)
}
static void
-bdb_treat(st, pkey, key, data)
- eachst *st;
- DBT *pkey, *key, *data;
+bdb_treat(eachst *st, DBT *pkey, DBT *key, DBT *data)
{
bdb_DB *dbst;
DBC *dbcp;
@@ -2772,10 +2748,7 @@ bdb_treat(st, pkey, key, data)
}
static int
-bdb_i_last_prefix(dbcp, key, pkey, data, orig, st)
- DBC *dbcp;
- DBT *key, *pkey, *data, *orig;
- eachst *st;
+bdb_i_last_prefix(DBC *dbcp, DBT *key, DBT *pkey, DBT *data, DBT *orig, eachst *st)
{
int ret, flags = DB_LAST;
@@ -2811,15 +2784,14 @@ bdb_i_last_prefix(dbcp, key, pkey, data, orig, st)
}
static VALUE
-bdb_i_each_kv(st)
- eachst *st;
+bdb_i_each_kv(VALUE pst)
{
+ eachst *st = (eachst *)pst;
bdb_DB *dbst;
DBC *dbcp;
DBT pkey, key, data, orig;
int ret, init = Qfalse, prefix = Qfalse;
db_recno_t recno;
- volatile VALUE res = Qnil;
prefix = st->type & BDB_ST_PREFIX;
st->type &= ~BDB_ST_PREFIX;
@@ -2834,7 +2806,7 @@ bdb_i_each_kv(st)
MEMZERO(&pkey, DBT, 1);
pkey.flags = DB_DBT_MALLOC;
if (!NIL_P(st->set)) {
- res = bdb_test_recno(st->db, &key, &recno, st->set);
+ bdb_test_recno(st->db, &key, &recno, st->set);
if (prefix) {
init = Qtrue;
orig.size = key.size;
@@ -2929,9 +2901,9 @@ bdb_i_each_kv(st)
#if HAVE_CONST_DB_MULTIPLE_KEY
static VALUE
-bdb_i_each_kv_bulk(st)
- eachst *st;
+bdb_i_each_kv_bulk(VALUE pst)
{
+ eachst *st = (eachst *)pst;
bdb_DB *dbst;
DBC *dbcp;
DBT key, data;
@@ -2940,7 +2912,6 @@ bdb_i_each_kv_bulk(st)
int ret, init;
db_recno_t recno;
void *p;
- volatile VALUE res = Qnil;
GetDB(st->db, dbst);
dbcp = st->dbcp;
@@ -2958,7 +2929,7 @@ bdb_i_each_kv_bulk(st)
init = 1;
do {
if (init && !NIL_P(st->set)) {
- res = bdb_test_recno(st->db, &key, &recno, st->set);
+ bdb_test_recno(st->db, &key, &recno, st->set);
ret = bdb_test_error(dbcp->c_get(dbcp, &key, &data,
((st->type & BDB_ST_DUP)?DB_SET:
DB_SET_RANGE)|DB_MULTIPLE_KEY));
@@ -2990,11 +2961,7 @@ bdb_i_each_kv_bulk(st)
#endif
VALUE
-bdb_each_kvc(argc, argv, obj, sens, replace, type)
- VALUE obj, *argv;
- int argc, sens;
- VALUE replace;
- int type;
+bdb_each_kvc(int argc, VALUE *argv, VALUE obj, int sens, VALUE replace, int type)
{
bdb_DB *dbst;
DB_TXN *txnid;
@@ -3004,8 +2971,8 @@ bdb_each_kvc(argc, argv, obj, sens, replace, type)
if (argc && TYPE(argv[argc - 1]) == T_HASH) {
VALUE g, f = argv[argc - 1];
- if ((g = rb_hash_aref(f, rb_intern("flags"))) != RHASH(f)->ifnone ||
- (g = rb_hash_aref(f, rb_str_new2("flags"))) != RHASH(f)->ifnone) {
+ if ((g = rb_hash_lookup(f, rb_intern("flags"))) != Qnil ||
+ (g = rb_hash_lookup(f, rb_str_new2("flags"))) != Qnil) {
flags = NUM2INT(g);
}
argc--;
@@ -3053,9 +3020,11 @@ bdb_each_kvc(argc, argv, obj, sens, replace, type)
}
#endif
type &= ~BDB_ST_ONE;
+#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 4
if ((type & ~BDB_ST_PREFIX) == BDB_ST_DELETE) {
rb_secure(4);
}
+#endif
INIT_TXN(txnid, obj, dbst);
#if HAVE_DB_CURSOR_4
bdb_test_error(dbst->dbp->cursor(dbst->dbp, txnid, &dbcp, flags));
@@ -3211,8 +3180,7 @@ bdb_each_riap_prim(int argc, VALUE *argv, VALUE obj)
}
VALUE
-bdb_to_type(obj, result, flag)
- VALUE obj, result, flag;
+bdb_to_type(VALUE obj, VALUE result, VALUE flag)
{
bdb_DB *dbst;
DB_TXN *txnid;
@@ -3266,15 +3234,13 @@ bdb_to_type(obj, result, flag)
}
static VALUE
-bdb_to_a(obj)
- VALUE obj;
+bdb_to_a(VALUE obj)
{
return bdb_to_type(obj, rb_ary_new(), Qtrue);
}
static VALUE
-bdb_update_i(pair, obj)
- VALUE pair, obj;
+bdb_update_i(VALUE pair, VALUE obj, int _argc, const VALUE *_argv, VALUE _blockarg)
{
Check_Type(pair, T_ARRAY);
if (RARRAY_LEN(pair) < 2) {
@@ -3285,17 +3251,15 @@ bdb_update_i(pair, obj)
}
static VALUE
-each_pair(obj)
- VALUE obj;
+each_pair(VALUE obj)
{
return rb_funcall(obj, rb_intern("each_pair"), 0, 0);
}
static VALUE
-bdb_update(obj, other)
- VALUE obj, other;
+bdb_update(VALUE obj, VALUE other)
{
- rb_iterate(each_pair, other, bdb_update_i, obj);
+ rb_block_call(other, each_pair, 0, NULL, bdb_update_i, obj);
return obj;
}
@@ -3309,7 +3273,9 @@ bdb_clear(int argc, VALUE *argv, VALUE obj)
#endif
int flags = 0;
+#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 4
rb_secure(4);
+#endif
#if HAVE_ST_DB_TRUNCATE
INIT_TXN(txnid, obj, dbst);
#if HAVE_CONST_DB_AUTO_COMMIT
@@ -3323,8 +3289,8 @@ bdb_clear(int argc, VALUE *argv, VALUE obj)
flags = 0;
if (argc && TYPE(argv[argc - 1]) == T_HASH) {
VALUE g, f = argv[argc - 1];
- if ((g = rb_hash_aref(f, rb_intern("flags"))) != RHASH(f)->ifnone ||
- (g = rb_hash_aref(f, rb_str_new2("flags"))) != RHASH(f)->ifnone) {
+ if ((g = rb_hash_lookup(f, rb_intern("flags"))) != Qnil ||
+ (g = rb_hash_lookup(f, rb_str_new2("flags"))) != Qnil) {
flags = NUM2INT(g);
}
argc--;
@@ -3348,8 +3314,8 @@ bdb_replace(int argc, VALUE *argv, VALUE obj)
flags = 0;
if (TYPE(argv[argc - 1]) == T_HASH) {
VALUE f = argv[argc - 1];
- if ((g = rb_hash_aref(f, rb_intern("flags"))) != RHASH(f)->ifnone ||
- (g = rb_hash_aref(f, rb_str_new2("flags"))) != RHASH(f)->ifnone) {
+ if ((g = rb_hash_lookup(f, rb_intern("flags"))) != Qnil ||
+ (g = rb_hash_lookup(f, rb_str_new2("flags"))) != Qnil) {
flags = NUM2INT(g);
}
argc--;
@@ -3359,28 +3325,24 @@ bdb_replace(int argc, VALUE *argv, VALUE obj)
}
g = INT2FIX(flags);
bdb_clear(1, &g, obj);
- rb_iterate(each_pair, argv[0], bdb_update_i, obj);
+ rb_block_call(argv[0], rb_intern("each_pair"), 0, NULL, bdb_update_i, obj);
return obj;
}
static VALUE
-bdb_invert(obj)
- VALUE obj;
+bdb_invert(VALUE obj)
{
return bdb_to_type(obj, rb_hash_new(), Qfalse);
}
static VALUE
-bdb_to_hash(obj)
- VALUE obj;
+bdb_to_hash(VALUE obj)
{
return bdb_to_type(obj, rb_hash_new(), Qtrue);
}
static VALUE
-bdb_kv(obj, type)
- VALUE obj;
- int type;
+bdb_kv(VALUE obj, int type)
{
bdb_DB *dbst;
DB_TXN *txnid;
@@ -3426,23 +3388,19 @@ bdb_kv(obj, type)
}
static VALUE
-bdb_values(obj)
- VALUE obj;
+bdb_values(VALUE obj)
{
return bdb_kv(obj, BDB_ST_VALUE);
}
static VALUE
-bdb_keys(obj)
- VALUE obj;
+bdb_keys(VALUE obj)
{
return bdb_kv(obj, BDB_ST_KEY);
}
VALUE
-bdb_internal_value(obj, a, b, sens)
- VALUE obj, a, b;
- int sens;
+bdb_internal_value(VALUE obj, VALUE a, VALUE b, int sens)
{
bdb_DB *dbst;
DB_TXN *txnid;
@@ -3490,8 +3448,7 @@ bdb_internal_value(obj, a, b, sens)
}
VALUE
-bdb_index(obj, a)
- VALUE obj, a;
+bdb_index(VALUE obj, VALUE a)
{
return bdb_internal_value(obj, a, Qtrue, DB_NEXT);
}
@@ -3545,20 +3502,20 @@ bdb_select(int argc, VALUE *argv, VALUE obj)
}
VALUE
-bdb_has_value(obj, a)
- VALUE obj, a;
+bdb_has_value(VALUE obj, VALUE a)
{
return bdb_internal_value(obj, a, Qfalse, DB_NEXT);
}
static VALUE
-bdb_sync(obj)
- VALUE obj;
+bdb_sync(VALUE obj)
{
bdb_DB *dbst;
+#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 4
if (!OBJ_TAINTED(obj) && rb_safe_level() >= 4)
rb_raise(rb_eSecurityError, "Insecure: can't sync the database");
+#endif
GetDB(obj, dbst);
bdb_test_error(dbst->dbp->sync(dbst->dbp, 0));
return Qtrue;
@@ -3597,36 +3554,36 @@ bdb_hash_stat(int argc, VALUE *argv, VALUE obj)
bdb_test_error(dbst->dbp->stat(dbst->dbp, &bdb_stat, flags));
#endif
hash = rb_hash_new();
- rb_hash_aset(hash, rb_tainted_str_new2("hash_magic"), INT2NUM(bdb_stat->hash_magic));
- rb_hash_aset(hash, rb_tainted_str_new2("hash_version"), INT2NUM(bdb_stat->hash_version));
- rb_hash_aset(hash, rb_tainted_str_new2("hash_pagesize"), INT2NUM(bdb_stat->hash_pagesize));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_magic"), INT2NUM(bdb_stat->hash_magic));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_version"), INT2NUM(bdb_stat->hash_version));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_pagesize"), INT2NUM(bdb_stat->hash_pagesize));
#if HAVE_ST_DB_HASH_STAT_HASH_NKEYS
- rb_hash_aset(hash, rb_tainted_str_new2("hash_nkeys"), INT2NUM(bdb_stat->hash_nkeys));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_nkeys"), INT2NUM(bdb_stat->hash_nkeys));
#if ! HAVE_ST_DB_HASH_STAT_HASH_NRECS
- rb_hash_aset(hash, rb_tainted_str_new2("hash_nrecs"), INT2NUM(bdb_stat->hash_nkeys));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_nrecs"), INT2NUM(bdb_stat->hash_nkeys));
#endif
#endif
#if HAVE_ST_DB_HASH_STAT_HASH_NRECS
- rb_hash_aset(hash, rb_tainted_str_new2("hash_nrecs"), INT2NUM(bdb_stat->hash_nrecs));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_nrecs"), INT2NUM(bdb_stat->hash_nrecs));
#endif
#if HAVE_ST_DB_HASH_STAT_HASH_NDATA
- rb_hash_aset(hash, rb_tainted_str_new2("hash_ndata"), INT2NUM(bdb_stat->hash_ndata));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_ndata"), INT2NUM(bdb_stat->hash_ndata));
#endif
#if HAVE_ST_DB_HASH_STAT_HASH_NELEM
- rb_hash_aset(hash, rb_tainted_str_new2("hash_nelem"), INT2NUM(bdb_stat->hash_nelem));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_nelem"), INT2NUM(bdb_stat->hash_nelem));
#endif
- rb_hash_aset(hash, rb_tainted_str_new2("hash_ffactor"), INT2NUM(bdb_stat->hash_ffactor));
- rb_hash_aset(hash, rb_tainted_str_new2("hash_buckets"), INT2NUM(bdb_stat->hash_buckets));
- rb_hash_aset(hash, rb_tainted_str_new2("hash_free"), INT2NUM(bdb_stat->hash_free));
- rb_hash_aset(hash, rb_tainted_str_new2("hash_bfree"), INT2NUM(bdb_stat->hash_bfree));
- rb_hash_aset(hash, rb_tainted_str_new2("hash_bigpages"), INT2NUM(bdb_stat->hash_bigpages));
- rb_hash_aset(hash, rb_tainted_str_new2("hash_big_bfree"), INT2NUM(bdb_stat->hash_big_bfree));
- rb_hash_aset(hash, rb_tainted_str_new2("hash_overflows"), INT2NUM(bdb_stat->hash_overflows));
- rb_hash_aset(hash, rb_tainted_str_new2("hash_ovfl_free"), INT2NUM(bdb_stat->hash_ovfl_free));
- rb_hash_aset(hash, rb_tainted_str_new2("hash_dup"), INT2NUM(bdb_stat->hash_dup));
- rb_hash_aset(hash, rb_tainted_str_new2("hash_dup_free"), INT2NUM(bdb_stat->hash_dup_free));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_ffactor"), INT2NUM(bdb_stat->hash_ffactor));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_buckets"), INT2NUM(bdb_stat->hash_buckets));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_free"), INT2NUM(bdb_stat->hash_free));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_bfree"), INT2NUM(bdb_stat->hash_bfree));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_bigpages"), INT2NUM(bdb_stat->hash_bigpages));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_big_bfree"), INT2NUM(bdb_stat->hash_big_bfree));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_overflows"), INT2NUM(bdb_stat->hash_overflows));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_ovfl_free"), INT2NUM(bdb_stat->hash_ovfl_free));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_dup"), INT2NUM(bdb_stat->hash_dup));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_dup_free"), INT2NUM(bdb_stat->hash_dup_free));
#if HAVE_ST_DB_HASH_STAT_HASH_PAGECNT
- rb_hash_aset(hash, rb_tainted_str_new2("hash_pagecnt"), INT2NUM(bdb_stat->hash_pagecnt));
+ rb_hash_aset(hash, rb_str_new_cstr("hash_pagecnt"), INT2NUM(bdb_stat->hash_pagecnt));
#endif
free(bdb_stat);
return hash;
@@ -3666,37 +3623,37 @@ bdb_tree_stat(int argc, VALUE *argv, VALUE obj)
bdb_test_error(dbst->dbp->stat(dbst->dbp, &bdb_stat, flags));
#endif
hash = rb_hash_new();
- rb_hash_aset(hash, rb_tainted_str_new2("bt_magic"), INT2NUM(bdb_stat->bt_magic));
- rb_hash_aset(hash, rb_tainted_str_new2("bt_version"), INT2NUM(bdb_stat->bt_version));
- rb_hash_aset(hash, rb_tainted_str_new2("bt_dup_pg"), INT2NUM(bdb_stat->bt_dup_pg));
- rb_hash_aset(hash, rb_tainted_str_new2("bt_dup_pgfree"), INT2NUM(bdb_stat->bt_dup_pgfree));
- rb_hash_aset(hash, rb_tainted_str_new2("bt_free"), INT2NUM(bdb_stat->bt_free));
- rb_hash_aset(hash, rb_tainted_str_new2("bt_int_pg"), INT2NUM(bdb_stat->bt_int_pg));
- rb_hash_aset(hash, rb_tainted_str_new2("bt_int_pgfree"), INT2NUM(bdb_stat->bt_int_pgfree));
- rb_hash_aset(hash, rb_tainted_str_new2("bt_leaf_pg"), INT2NUM(bdb_stat->bt_leaf_pg));
- rb_hash_aset(hash, rb_tainted_str_new2("bt_leaf_pgfree"), INT2NUM(bdb_stat->bt_leaf_pgfree));
- rb_hash_aset(hash, rb_tainted_str_new2("bt_levels"), INT2NUM(bdb_stat->bt_levels));
- rb_hash_aset(hash, rb_tainted_str_new2("bt_minkey"), INT2NUM(bdb_stat->bt_minkey));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_magic"), INT2NUM(bdb_stat->bt_magic));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_version"), INT2NUM(bdb_stat->bt_version));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_dup_pg"), INT2NUM(bdb_stat->bt_dup_pg));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_dup_pgfree"), INT2NUM(bdb_stat->bt_dup_pgfree));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_free"), INT2NUM(bdb_stat->bt_free));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_int_pg"), INT2NUM(bdb_stat->bt_int_pg));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_int_pgfree"), INT2NUM(bdb_stat->bt_int_pgfree));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_leaf_pg"), INT2NUM(bdb_stat->bt_leaf_pg));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_leaf_pgfree"), INT2NUM(bdb_stat->bt_leaf_pgfree));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_levels"), INT2NUM(bdb_stat->bt_levels));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_minkey"), INT2NUM(bdb_stat->bt_minkey));
#if HAVE_ST_DB_BTREE_STAT_BT_NRECS
- rb_hash_aset(hash, rb_tainted_str_new2("bt_nrecs"), INT2NUM(bdb_stat->bt_nrecs));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_nrecs"), INT2NUM(bdb_stat->bt_nrecs));
#endif
#if HAVE_ST_DB_BTREE_STAT_BT_NKEYS
- rb_hash_aset(hash, rb_tainted_str_new2("bt_nkeys"), INT2NUM(bdb_stat->bt_nkeys));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_nkeys"), INT2NUM(bdb_stat->bt_nkeys));
#if ! HAVE_ST_DB_BTREE_STAT_BT_NRECS
- rb_hash_aset(hash, rb_tainted_str_new2("bt_nrecs"), INT2NUM(bdb_stat->bt_nkeys));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_nrecs"), INT2NUM(bdb_stat->bt_nkeys));
#endif
#endif
#if HAVE_ST_DB_BTREE_STAT_BT_NDATA
- rb_hash_aset(hash, rb_tainted_str_new2("bt_ndata"), INT2NUM(bdb_stat->bt_ndata));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_ndata"), INT2NUM(bdb_stat->bt_ndata));
#endif
- rb_hash_aset(hash, rb_tainted_str_new2("bt_over_pg"), INT2NUM(bdb_stat->bt_over_pg));
- rb_hash_aset(hash, rb_tainted_str_new2("bt_over_pgfree"), INT2NUM(bdb_stat->bt_over_pgfree));
- rb_hash_aset(hash, rb_tainted_str_new2("bt_pagesize"), INT2NUM(bdb_stat->bt_pagesize));
- rb_hash_aset(hash, rb_tainted_str_new2("bt_re_len"), INT2NUM(bdb_stat->bt_re_len));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_over_pg"), INT2NUM(bdb_stat->bt_over_pg));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_over_pgfree"), INT2NUM(bdb_stat->bt_over_pgfree));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_pagesize"), INT2NUM(bdb_stat->bt_pagesize));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_re_len"), INT2NUM(bdb_stat->bt_re_len));
pad = (char)bdb_stat->bt_re_pad;
- rb_hash_aset(hash, rb_tainted_str_new2("bt_re_pad"), rb_tainted_str_new(&pad, 1));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_re_pad"), rb_str_new(&pad, 1));
#if HAVE_ST_DB_BTREE_STAT_BT_PAGECNT
- rb_hash_aset(hash, rb_tainted_str_new2("bt_pagecnt"), INT2NUM(bdb_stat->bt_pagecnt));
+ rb_hash_aset(hash, rb_str_new_cstr("bt_pagecnt"), INT2NUM(bdb_stat->bt_pagecnt));
#endif
free(bdb_stat);
return hash;
@@ -3736,38 +3693,37 @@ bdb_queue_stat(int argc, VALUE *argv, VALUE obj)
bdb_test_error(dbst->dbp->stat(dbst->dbp, &bdb_stat, flags));
#endif
hash = rb_hash_new();
- rb_hash_aset(hash, rb_tainted_str_new2("qs_magic"), INT2NUM(bdb_stat->qs_magic));
- rb_hash_aset(hash, rb_tainted_str_new2("qs_version"), INT2NUM(bdb_stat->qs_version));
+ rb_hash_aset(hash, rb_str_new_cstr("qs_magic"), INT2NUM(bdb_stat->qs_magic));
+ rb_hash_aset(hash, rb_str_new_cstr("qs_version"), INT2NUM(bdb_stat->qs_version));
#if HAVE_ST_DB_QUEUE_STAT_QS_NKEYS
- rb_hash_aset(hash, rb_tainted_str_new2("qs_nkeys"), INT2NUM(bdb_stat->qs_nkeys));
+ rb_hash_aset(hash, rb_str_new_cstr("qs_nkeys"), INT2NUM(bdb_stat->qs_nkeys));
#if ! HAVE_ST_DB_QUEUE_STAT_QS_NRECS
- rb_hash_aset(hash, rb_tainted_str_new2("qs_nrecs"), INT2NUM(bdb_stat->qs_nkeys));
+ rb_hash_aset(hash, rb_str_new_cstr("qs_nrecs"), INT2NUM(bdb_stat->qs_nkeys));
#endif
#endif
#if HAVE_ST_DB_QUEUE_STAT_QS_NDATA
- rb_hash_aset(hash, rb_tainted_str_new2("qs_ndata"), INT2NUM(bdb_stat->qs_ndata));
+ rb_hash_aset(hash, rb_str_new_cstr("qs_ndata"), INT2NUM(bdb_stat->qs_ndata));
#endif
#if HAVE_ST_DB_QUEUE_STAT_QS_NRECS
- rb_hash_aset(hash, rb_tainted_str_new2("qs_nrecs"), INT2NUM(bdb_stat->qs_nrecs));
+ rb_hash_aset(hash, rb_str_new_cstr("qs_nrecs"), INT2NUM(bdb_stat->qs_nrecs));
#endif
- rb_hash_aset(hash, rb_tainted_str_new2("qs_pages"), INT2NUM(bdb_stat->qs_pages));
- rb_hash_aset(hash, rb_tainted_str_new2("qs_pagesize"), INT2NUM(bdb_stat->qs_pagesize));
- rb_hash_aset(hash, rb_tainted_str_new2("qs_pgfree"), INT2NUM(bdb_stat->qs_pgfree));
- rb_hash_aset(hash, rb_tainted_str_new2("qs_re_len"), INT2NUM(bdb_stat->qs_re_len));
+ rb_hash_aset(hash, rb_str_new_cstr("qs_pages"), INT2NUM(bdb_stat->qs_pages));
+ rb_hash_aset(hash, rb_str_new_cstr("qs_pagesize"), INT2NUM(bdb_stat->qs_pagesize));
+ rb_hash_aset(hash, rb_str_new_cstr("qs_pgfree"), INT2NUM(bdb_stat->qs_pgfree));
+ rb_hash_aset(hash, rb_str_new_cstr("qs_re_len"), INT2NUM(bdb_stat->qs_re_len));
pad = (char)bdb_stat->qs_re_pad;
- rb_hash_aset(hash, rb_tainted_str_new2("qs_re_pad"), rb_tainted_str_new(&pad, 1));
+ rb_hash_aset(hash, rb_str_new_cstr("qs_re_pad"), rb_str_new(&pad, 1));
#if HAVE_ST_DB_QUEUE_STAT_QS_START
- rb_hash_aset(hash, rb_tainted_str_new2("qs_start"), INT2NUM(bdb_stat->qs_start));
+ rb_hash_aset(hash, rb_str_new_cstr("qs_start"), INT2NUM(bdb_stat->qs_start));
#endif
- rb_hash_aset(hash, rb_tainted_str_new2("qs_first_recno"), INT2NUM(bdb_stat->qs_first_recno));
- rb_hash_aset(hash, rb_tainted_str_new2("qs_cur_recno"), INT2NUM(bdb_stat->qs_cur_recno));
+ rb_hash_aset(hash, rb_str_new_cstr("qs_first_recno"), INT2NUM(bdb_stat->qs_first_recno));
+ rb_hash_aset(hash, rb_str_new_cstr("qs_cur_recno"), INT2NUM(bdb_stat->qs_cur_recno));
free(bdb_stat);
return hash;
}
static VALUE
-bdb_queue_padlen(obj)
- VALUE obj;
+bdb_queue_padlen(VALUE obj)
{
bdb_DB *dbst;
DB_QUEUE_STAT *bdb_stat;
@@ -3794,7 +3750,7 @@ bdb_queue_padlen(obj)
bdb_test_error(dbst->dbp->stat(dbst->dbp, &bdb_stat, 0));
#endif
pad = (char)bdb_stat->qs_re_pad;
- hash = rb_assoc_new(rb_tainted_str_new(&pad, 1), INT2NUM(bdb_stat->qs_re_len));
+ hash = rb_assoc_new(rb_str_new(&pad, 1), INT2NUM(bdb_stat->qs_re_len));
free(bdb_stat);
return hash;
}
@@ -3802,8 +3758,7 @@ bdb_queue_padlen(obj)
#endif
static VALUE
-bdb_set_partial(obj, a, b)
- VALUE obj, a, b;
+bdb_set_partial(VALUE obj, VALUE a, VALUE b)
{
bdb_DB *dbst;
VALUE ret;
@@ -3823,8 +3778,7 @@ bdb_set_partial(obj, a, b)
}
static VALUE
-bdb_clear_partial(obj)
- VALUE obj;
+bdb_clear_partial(VALUE obj)
{
bdb_DB *dbst;
VALUE ret;
@@ -3844,8 +3798,7 @@ bdb_clear_partial(obj)
#if HAVE_ST_DB_SET_ERRCALL
static VALUE
-bdb_i_create(obj)
- VALUE obj;
+bdb_i_create(VALUE obj)
{
DB *dbp;
bdb_ENV *envst = 0;
@@ -3884,7 +3837,9 @@ bdb_s_upgrade(int argc, VALUE *argv, VALUE obj)
int flags;
VALUE val;
+#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 4
rb_secure(4);
+#endif
flags = 0;
if (rb_scan_args(argc, argv, "11", &a, &b) == 2) {
flags = NUM2INT(b);
@@ -3908,7 +3863,9 @@ bdb_s_remove(int argc, VALUE *argv, VALUE obj)
VALUE a, b, c;
char *name, *subname;
+#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 2
rb_secure(2);
+#endif
c = bdb_i_create(obj);
GetDB(c, dbst);
name = subname = NULL;
@@ -3936,7 +3893,9 @@ bdb_s_rename(int argc, VALUE *argv, VALUE obj)
VALUE a, b, c;
char *name, *subname, *newname;
+#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 2
rb_secure(2);
+#endif
c = bdb_i_create(obj);
GetDB(c, dbst);
name = subname = NULL;
@@ -3959,9 +3918,9 @@ bdb_s_rename(int argc, VALUE *argv, VALUE obj)
#if HAVE_ST_DB_JOIN
static VALUE
-bdb_i_joinclose(st)
- eachst *st;
+bdb_i_joinclose(VALUE pst)
{
+ eachst *st = (eachst *)pst;
bdb_DB *dbst;
GetDB(st->db, dbst);
@@ -3973,9 +3932,9 @@ bdb_i_joinclose(st)
static VALUE
-bdb_i_join(st)
- eachst *st;
+bdb_i_join(VALUE pst)
{
+ eachst *st = (eachst *)pst;
int ret;
DBT key, data;
db_recno_t recno;
@@ -4004,9 +3963,8 @@ bdb_join(int argc, VALUE *argv, VALUE obj)
DBC *dbc, **dbcarr;
int flags, i;
eachst st;
- VALUE a, b, c;
+ VALUE a, b;
- c = 0;
flags = 0;
GetDB(obj, dbst);
if (rb_scan_args(argc, argv, "11", &a, &b) == 2) {
@@ -4050,8 +4008,7 @@ bdb_join(int argc, VALUE *argv, VALUE obj)
#if HAVE_ST_DB_BYTESWAPPED || HAVE_ST_DB_GET_BYTESWAPPED
static VALUE
-bdb_byteswapp(obj)
- VALUE obj;
+bdb_byteswapp(VALUE obj)
{
bdb_DB *dbst;
int byteswap = 0;
@@ -4072,18 +4029,14 @@ bdb_byteswapp(obj)
#if HAVE_ST_DB_ASSOCIATE
static VALUE
-bdb_internal_second_call(tmp)
- VALUE *tmp;
+bdb_internal_second_call(VALUE ptmp)
{
+ VALUE *tmp = (VALUE *)ptmp;
return rb_funcall2(tmp[0], bdb_id_call, 3, tmp + 1);
}
static int
-bdb_call_secondary(secst, pkey, pdata, skey)
- DB *secst;
- DBT *pkey;
- DBT *pdata;
- DBT *skey;
+bdb_call_secondary(DB *secst, DBT *pkey, DBT *pdata, DBT *skey)
{
VALUE obj, ary, second;
bdb_DB *dbst, *secondst;
@@ -4189,8 +4142,7 @@ bdb_associate(int argc, VALUE *argv, VALUE obj)
#endif
static VALUE
-bdb_filename(obj)
- VALUE obj;
+bdb_filename(VALUE obj)
{
bdb_DB *dbst;
GetDB(obj, dbst);
@@ -4198,8 +4150,7 @@ bdb_filename(obj)
}
static VALUE
-bdb_database(obj)
- VALUE obj;
+bdb_database(VALUE obj)
{
bdb_DB *dbst;
GetDB(obj, dbst);
@@ -4222,7 +4173,9 @@ bdb_verify(int argc, VALUE *argv, VALUE obj)
#endif
FILE *io = NULL;
+#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 4
rb_secure(4);
+#endif
file = database = NULL;
switch(rb_scan_args(argc, argv, "02", &iov, &flagv)) {
case 2:
@@ -4346,8 +4299,7 @@ bdb_feedback_set(VALUE obj, VALUE a)
#endif
static VALUE
-bdb_i_conf(obj, a)
- VALUE obj, a;
+bdb_i_conf(VALUE obj, VALUE a)
{
bdb_DB *dbst;
u_int32_t value;
@@ -4390,13 +4342,13 @@ bdb_i_conf(obj, a)
bdb_test_error(dbst->dbp->get_dbname(dbst->dbp, &filename, &dbname));
res = rb_ary_new2(3);
if (filename && strlen(filename)) {
- rb_ary_push(res, rb_tainted_str_new2(filename));
+ rb_ary_push(res, rb_str_new_cstr(filename));
}
else {
rb_ary_push(res, Qnil);
}
if (dbname && strlen(dbname)) {
- rb_ary_push(res, rb_tainted_str_new2(dbname));
+ rb_ary_push(res, rb_str_new_cstr(dbname));
}
else {
rb_ary_push(res, Qnil);
@@ -4463,7 +4415,7 @@ bdb_i_conf(obj, a)
bdb_test_error(dbst->dbp->get_re_source(dbst->dbp, &strval));
if (strval && strlen(strval)) {
- return rb_tainted_str_new2(strval);
+ return rb_str_new_cstr(strval);
}
return Qnil;
}
@@ -4539,9 +4491,9 @@ struct optst {
};
static VALUE
-bdb_intern_conf(optp)
- struct optst *optp;
+bdb_intern_conf(VALUE poptp)
{
+ struct optst *optp = (struct optst *)poptp;
return bdb_i_conf(optp->obj, optp->str);
}
Reference in a new issue View git blame Copy permalink