1 --- src/env.c.orig 2011-04-06 19:35:39 UTC 2 +++ src/env.c 3 @@ -67,8 +67,8 @@ bdb_env_rep_transport(DB_ENV *env, const DBT *control, 4 lsnobj = bdb_makelsn(obj); 5 Data_Get_Struct(lsnobj, struct dblsnst, lsnst); 6 MEMCPY(lsnst->lsn, lsn, DB_LSN, 1); 7 - av = rb_tainted_str_new(control->data, control->size); 8 - bv = rb_tainted_str_new(rec->data, rec->size); 9 + av = rb_str_new(control->data, control->size); 10 + bv = rb_str_new(rec->data, rec->size); 11 if (envst->rep_transport == 0) { 12 res = rb_funcall(obj, rb_intern("bdb_rep_transport"), 5, av, bv, lsnobj, 13 INT2FIX(envid), INT2FIX(flags)); 14 @@ -90,8 +90,8 @@ bdb_env_rep_transport(DB_ENV *env, const DBT *control, 15 bdb_ENV *envst; 16 17 GetIdEnv(obj, envst); 18 - av = rb_tainted_str_new(control->data, control->size); 19 - bv = rb_tainted_str_new(rec->data, rec->size); 20 + av = rb_str_new(control->data, control->size); 21 + bv = rb_str_new(rec->data, rec->size); 22 if (envst->rep_transport == 0) { 23 res = rb_funcall(obj, rb_intern("bdb_rep_transport"), 4, av, bv, 24 INT2FIX(envid), INT2FIX(flags)); 25 @@ -328,10 +328,10 @@ bdb_env_msgcall(const DB_ENV *dbenv, const char *msg) 26 return; 27 } 28 if (envst->msgcall == 0) { 29 - rb_funcall(obj, id_msgcall, 1, rb_tainted_str_new2(msg)); 30 + rb_funcall(obj, id_msgcall, 1, rb_str_new_cstr(msg)); 31 } 32 else { 33 - rb_funcall(envst->msgcall, bdb_id_call, 1, rb_tainted_str_new2(msg)); 34 + rb_funcall(envst->msgcall, bdb_id_call, 1, rb_str_new_cstr(msg)); 35 } 36 } 37 38 @@ -508,7 +508,7 @@ bdb_env_set_notify(VALUE obj, VALUE a) 39 40 41 static VALUE 42 -bdb_env_i_options(VALUE obj, VALUE db_stobj) 43 +bdb_env_i_options(VALUE obj, VALUE db_stobj, int _argc, const VALUE *_argv, VALUE _blockarg) 44 { 45 char *options; 46 DB_ENV *envp; 47 @@ -1121,9 +1121,11 @@ bdb_env_close(VALUE obj) 48 { 49 bdb_ENV *envst; 50 51 +#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 4 52 if (!OBJ_TAINTED(obj) && rb_safe_level() >= 4) { 53 rb_raise(rb_eSecurityError, "Insecure: can't close the environnement"); 54 } 55 +#endif 56 GetEnvDB(obj, envst); 57 bdb_final(envst); 58 RDATA(obj)->dfree = free; 59 @@ -1193,10 +1195,10 @@ bdb_env_open_db(int argc, VALUE *argv, VALUE obj) 60 argv[argc - 1] = rb_hash_new(); 61 } 62 if (rb_obj_is_kind_of(obj, bdb_cEnv)) { 63 - rb_hash_aset(argv[argc - 1], rb_tainted_str_new2("env"), obj); 64 + rb_hash_aset(argv[argc - 1], rb_str_new_cstr("env"), obj); 65 } 66 else { 67 - rb_hash_aset(argv[argc - 1], rb_tainted_str_new2("txn"), obj); 68 + rb_hash_aset(argv[argc - 1], rb_str_new_cstr("txn"), obj); 69 } 70 return rb_funcall2(cl, rb_intern("new"), argc, argv); 71 } 72 @@ -1206,7 +1208,7 @@ void 73 bdb_env_errcall(const DB_ENV *env, const char *errpfx, const char *msg) 74 { 75 bdb_errcall = 1; 76 - bdb_errstr = rb_tainted_str_new2(msg); 77 + bdb_errstr = rb_str_new_cstr(msg); 78 } 79 80 #else 81 @@ -1215,7 +1217,7 @@ void 82 bdb_env_errcall(const char *errpfx, char *msg) 83 { 84 bdb_errcall = 1; 85 - bdb_errstr = rb_tainted_str_new2(msg); 86 + bdb_errstr = rb_str_new_cstr(msg); 87 } 88 89 #endif 90 @@ -1303,7 +1305,7 @@ bdb_env_each_options(VALUE opt, VALUE stobj) 91 DB_ENV *envp; 92 struct db_stoptions *db_st; 93 94 - res = rb_iterate(rb_each, opt, bdb_env_i_options, stobj); 95 + res = rb_block_call(opt, rb_intern("each"), 0, NULL, bdb_env_i_options, stobj); 96 Data_Get_Struct(stobj, struct db_stoptions, db_st); 97 envp = db_st->env->envp; 98 #if HAVE_ST_DB_ENV_SET_LG_BSIZE 99 @@ -1322,8 +1324,9 @@ bdb_env_each_options(VALUE opt, VALUE stobj) 100 } 101 102 static VALUE 103 -bdb_env_s_i_options(VALUE obj, int *flags) 104 +bdb_env_s_i_options(VALUE obj, VALUE pflags, int _argc, const VALUE *_argv, VALUE _blockarg) 105 { 106 + int *flags = (int *)pflags; 107 char *options; 108 VALUE key, value; 109 110 @@ -1394,7 +1397,7 @@ bdb_env_s_new(int argc, VALUE *argv, VALUE obj) 111 envst->envp->db_errcall = bdb_env_errcall; 112 #else 113 if (argc && TYPE(argv[argc - 1]) == T_HASH) { 114 - rb_iterate(rb_each, argv[argc - 1], bdb_env_s_i_options, (VALUE)&flags); 115 + rb_block_call(argv[argc - 1], rb_intern("each"), 0, NULL, bdb_env_s_i_options, (VALUE)&flags); 116 } 117 bdb_test_error(db_env_create(&(envst->envp), flags)); 118 envst->envp->set_errpfx(envst->envp, "BDB::"); 119 @@ -1406,7 +1409,7 @@ bdb_env_s_new(int argc, VALUE *argv, VALUE obj) 120 if (argc && TYPE(argv[argc - 1]) == T_HASH) { 121 VALUE value = Qnil; 122 123 - rb_iterate(rb_each, argv[argc - 1], bdb_env_s_j_options, (VALUE)&value); 124 + rb_block_call(argv[argc - 1], rb_intern("each"), 0, NULL, bdb_env_s_j_options, (VALUE)&value); 125 if (!NIL_P(value)) { 126 if (!rb_respond_to(value, bdb_id_call)) { 127 rb_raise(bdb_eFatal, "arg must respond to #call"); 128 @@ -1517,12 +1520,16 @@ bdb_env_init(int argc, VALUE *argv, VALUE obj) 129 flags = NUM2INT(c); 130 break; 131 } 132 +#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 4 133 if (flags & DB_CREATE) { 134 rb_secure(4); 135 } 136 +#endif 137 +#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 1 138 if (flags & DB_USE_ENVIRON) { 139 rb_secure(1); 140 } 141 +#endif 142 #ifndef BDB_NO_THREAD_COMPILE 143 if (!(envst->options & BDB_NO_THREAD)) { 144 bdb_set_func(envst); 145 @@ -1621,7 +1628,7 @@ bdb_env_init(int argc, VALUE *argv, VALUE obj) 146 envst->options |= BDB_AUTO_COMMIT; 147 } 148 #endif 149 - envst->home = rb_tainted_str_new2(db_home); 150 + envst->home = rb_str_new_cstr(db_home); 151 OBJ_FREEZE(envst->home); 152 #if HAVE_CONST_DB_INIT_REP 153 if (flags & DB_INIT_REP) { 154 @@ -1658,7 +1665,9 @@ bdb_env_s_remove(int argc, VALUE *argv, VALUE obj) 155 char *db_home; 156 int flag = 0; 157 158 +#if defined(RUBY_SAFE_LEVEL_MAX) && RUBY_SAFE_LEVEL_MAX >= 2 159 rb_secure(2); 160 +#endif 161 if (rb_scan_args(argc, argv, "11", &a, &b) == 2) { 162 flag = NUM2INT(b); 163 } 164 @@ -1754,13 +1763,13 @@ bdb_thread_init(int argc, VALUE *argv, VALUE obj) 165 if (rb_block_given_p()) { 166 #if HAVE_RB_BLOCK_CALL 167 return rb_block_call(obj, rb_intern("__bdb_thread_init__"), argc, argv, 168 - rb_yield, obj); 169 + (rb_block_call_func_t)rb_yield, obj); 170 #else 171 VALUE tmp[3]; 172 tmp[0] = obj; 173 tmp[1] = (VALUE)argc; 174 tmp[2] = (VALUE)argv; 175 - return rb_iterate((VALUE (*)(VALUE))bdb_env_iterate, (VALUE)tmp, rb_yield, obj); 176 + return rb_block_call((VALUE)tmp, bdb_env_iterate, 0, NULL, (rb_block_call_func_t)rb_yield, obj); 177 #endif 178 } 179 return rb_funcall2(obj, rb_intern("__bdb_thread_init__"), argc, argv); 180 @@ -1828,7 +1837,7 @@ bdb_env_i_conf(VALUE obj, VALUE a) 181 res = rb_ary_new(); 182 if (dirs) { 183 for (i = 0; dirs[i] != NULL; i++) { 184 - rb_ary_push(res, rb_tainted_str_new2(dirs[i])); 185 + rb_ary_push(res, rb_str_new_cstr(dirs[i])); 186 } 187 } 188 return res; 189 @@ -1844,7 +1853,7 @@ bdb_env_i_conf(VALUE obj, VALUE a) 190 if (strcmp(str, "home") == 0) { 191 bdb_test_error(envst->envp->get_home(envst->envp, &strval)); 192 if (strval && strlen(strval)) { 193 - return rb_tainted_str_new2(strval); 194 + return rb_str_new_cstr(strval); 195 } 196 return Qnil; 197 } 198 @@ -1859,7 +1868,7 @@ bdb_env_i_conf(VALUE obj, VALUE a) 199 if (strcmp(str, "lg_dir") == 0) { 200 bdb_test_error(envst->envp->get_lg_dir(envst->envp, &strval)); 201 if (strval && strlen(strval)) { 202 - return rb_tainted_str_new2(strval); 203 + return rb_str_new_cstr(strval); 204 } 205 return Qnil; 206 } 207 @@ -1961,7 +1970,7 @@ bdb_env_i_conf(VALUE obj, VALUE a) 208 if (strcmp(str, "tmp_dir") == 0) { 209 bdb_test_error(envst->envp->get_tmp_dir(envst->envp, &strval)); 210 if (strval && strlen(strval)) { 211 - return rb_tainted_str_new2(strval); 212 + return rb_str_new_cstr(strval); 213 } 214 return Qnil; 215 } 216 @@ -2343,10 +2352,10 @@ bdb_env_repmgr_site_list(VALUE obj) 217 res = rb_ary_new(); 218 for (i = 0; i < count; i++) { 219 tmp = rb_hash_new(); 220 - rb_hash_aset(tmp, rb_tainted_str_new2("eid"), INT2NUM(list[i].eid)); 221 - rb_hash_aset(tmp, rb_tainted_str_new2("host"), rb_tainted_str_new2(list[i].host)); 222 - rb_hash_aset(tmp, rb_tainted_str_new2("port"), INT2NUM(list[i].port)); 223 - rb_hash_aset(tmp, rb_tainted_str_new2("status"), INT2NUM(list[i].status)); 224 + rb_hash_aset(tmp, rb_str_new_cstr("eid"), INT2NUM(list[i].eid)); 225 + rb_hash_aset(tmp, rb_str_new_cstr("host"), rb_str_new_cstr(list[i].host)); 226 + rb_hash_aset(tmp, rb_str_new_cstr("port"), INT2NUM(list[i].port)); 227 + rb_hash_aset(tmp, rb_str_new_cstr("status"), INT2NUM(list[i].status)); 228 rb_ary_push(res, tmp); 229 } 230 free(list); 231 @@ -2445,7 +2454,7 @@ bdb_env_rep_set_nsites(VALUE obj, VALUE a) 232 } 233 234 static VALUE 235 -bdb_env_rep_get_nsites(VALUE obj, VALUE a) 236 +bdb_env_rep_get_nsites(VALUE obj) 237 { 238 bdb_ENV *envst; 239 int offon; 240 @@ -2470,7 +2479,7 @@ bdb_env_rep_set_priority(VALUE obj, VALUE a) 241 } 242 243 static VALUE 244 -bdb_env_rep_get_priority(VALUE obj, VALUE a) 245 +bdb_env_rep_get_priority(VALUE obj) 246 { 247 bdb_ENV *envst; 248 int offon; 249 @@ -2571,102 +2580,102 @@ bdb_env_rep_stat(int argc, VALUE *argv, VALUE obj) 250 bdb_test_error(envst->envp->rep_stat(envst->envp, &bs, flags)); 251 a = rb_hash_new(); 252 #if HAVE_ST_DB_REP_STAT_ST_BULK_FILLS 253 - rb_hash_aset(a, rb_tainted_str_new2("st_bulk_fills"), INT2NUM(bs->st_bulk_fills)); 254 + rb_hash_aset(a, rb_str_new_cstr("st_bulk_fills"), INT2NUM(bs->st_bulk_fills)); 255 #endif 256 #if HAVE_ST_DB_REP_STAT_ST_BULK_OVERFLOWS 257 - rb_hash_aset(a, rb_tainted_str_new2("st_bulk_overflows"), INT2NUM(bs->st_bulk_overflows)); 258 + rb_hash_aset(a, rb_str_new_cstr("st_bulk_overflows"), INT2NUM(bs->st_bulk_overflows)); 259 #endif 260 #if HAVE_ST_DB_REP_STAT_ST_BULK_RECORDS 261 - rb_hash_aset(a, rb_tainted_str_new2("st_bulk_records"), INT2NUM(bs->st_bulk_records)); 262 + rb_hash_aset(a, rb_str_new_cstr("st_bulk_records"), INT2NUM(bs->st_bulk_records)); 263 #endif 264 #if HAVE_ST_DB_REP_STAT_ST_BULK_TRANSFERS 265 - rb_hash_aset(a, rb_tainted_str_new2("st_bulk_transfers"), INT2NUM(bs->st_bulk_transfers)); 266 + rb_hash_aset(a, rb_str_new_cstr("st_bulk_transfers"), INT2NUM(bs->st_bulk_transfers)); 267 #endif 268 #if HAVE_ST_DB_REP_STAT_ST_CLIENT_REREQUESTS 269 - rb_hash_aset(a, rb_tainted_str_new2("st_client_rerequests"), INT2NUM(bs->st_client_rerequests)); 270 + rb_hash_aset(a, rb_str_new_cstr("st_client_rerequests"), INT2NUM(bs->st_client_rerequests)); 271 #endif 272 #if HAVE_ST_DB_REP_STAT_ST_CLIENT_SVC_MISS 273 - rb_hash_aset(a, rb_tainted_str_new2("st_client_svc_miss"), INT2NUM(bs->st_client_svc_miss)); 274 + rb_hash_aset(a, rb_str_new_cstr("st_client_svc_miss"), INT2NUM(bs->st_client_svc_miss)); 275 #endif 276 #if HAVE_ST_DB_REP_STAT_ST_CLIENT_SVC_REQ 277 - rb_hash_aset(a, rb_tainted_str_new2("st_client_svc_req"), INT2NUM(bs->st_client_svc_req)); 278 + rb_hash_aset(a, rb_str_new_cstr("st_client_svc_req"), INT2NUM(bs->st_client_svc_req)); 279 #endif 280 - rb_hash_aset(a, rb_tainted_str_new2("st_dupmasters"), INT2NUM(bs->st_dupmasters)); 281 + rb_hash_aset(a, rb_str_new_cstr("st_dupmasters"), INT2NUM(bs->st_dupmasters)); 282 #if HAVE_ST_DB_REP_STAT_ST_EGEN 283 - rb_hash_aset(a, rb_tainted_str_new2("st_egen"), INT2NUM(bs->st_egen)); 284 + rb_hash_aset(a, rb_str_new_cstr("st_egen"), INT2NUM(bs->st_egen)); 285 #endif 286 - rb_hash_aset(a, rb_tainted_str_new2("st_election_cur_winner"), INT2NUM(bs->st_election_cur_winner)); 287 - rb_hash_aset(a, rb_tainted_str_new2("st_election_gen"), INT2NUM(bs->st_election_gen)); 288 + rb_hash_aset(a, rb_str_new_cstr("st_election_cur_winner"), INT2NUM(bs->st_election_cur_winner)); 289 + rb_hash_aset(a, rb_str_new_cstr("st_election_gen"), INT2NUM(bs->st_election_gen)); 290 291 lsn = bdb_makelsn(obj); 292 Data_Get_Struct(lsn, struct dblsnst, lsnst); 293 MEMCPY(lsnst->lsn, &bs->st_election_lsn, DB_LSN, 1); 294 - rb_hash_aset(a, rb_tainted_str_new2("st_election_lsn"), lsn); 295 + rb_hash_aset(a, rb_str_new_cstr("st_election_lsn"), lsn); 296 297 - rb_hash_aset(a, rb_tainted_str_new2("st_election_nsites"), INT2NUM(bs->st_election_nsites)); 298 + rb_hash_aset(a, rb_str_new_cstr("st_election_nsites"), INT2NUM(bs->st_election_nsites)); 299 #if HAVE_ST_DB_REP_STAT_ST_ELECTION_NVOTES 300 - rb_hash_aset(a, rb_tainted_str_new2("st_election_nvotes"), INT2NUM(bs->st_election_nvotes)); 301 + rb_hash_aset(a, rb_str_new_cstr("st_election_nvotes"), INT2NUM(bs->st_election_nvotes)); 302 #endif 303 - rb_hash_aset(a, rb_tainted_str_new2("st_election_priority"), INT2NUM(bs->st_election_priority)); 304 + rb_hash_aset(a, rb_str_new_cstr("st_election_priority"), INT2NUM(bs->st_election_priority)); 305 #if HAVE_ST_DB_REP_STAT_ST_ELECTION_SEC 306 - rb_hash_aset(a, rb_tainted_str_new2("st_election_sec"), INT2NUM(bs->st_election_sec)); 307 + rb_hash_aset(a, rb_str_new_cstr("st_election_sec"), INT2NUM(bs->st_election_sec)); 308 #endif 309 - rb_hash_aset(a, rb_tainted_str_new2("st_election_status"), INT2NUM(bs->st_election_status)); 310 - rb_hash_aset(a, rb_tainted_str_new2("st_election_tiebreaker"), INT2NUM(bs->st_election_tiebreaker)); 311 + rb_hash_aset(a, rb_str_new_cstr("st_election_status"), INT2NUM(bs->st_election_status)); 312 + rb_hash_aset(a, rb_str_new_cstr("st_election_tiebreaker"), INT2NUM(bs->st_election_tiebreaker)); 313 #if HAVE_ST_DB_REP_STAT_ST_ELECTION_USEC 314 - rb_hash_aset(a, rb_tainted_str_new2("st_election_usec"), INT2NUM(bs->st_election_usec)); 315 + rb_hash_aset(a, rb_str_new_cstr("st_election_usec"), INT2NUM(bs->st_election_usec)); 316 #endif 317 - rb_hash_aset(a, rb_tainted_str_new2("st_election_votes"), INT2NUM(bs->st_election_votes)); 318 - rb_hash_aset(a, rb_tainted_str_new2("st_elections"), INT2NUM(bs->st_elections)); 319 - rb_hash_aset(a, rb_tainted_str_new2("st_elections_won"), INT2NUM(bs->st_elections_won)); 320 - rb_hash_aset(a, rb_tainted_str_new2("st_env_id"), INT2NUM(bs->st_env_id)); 321 - rb_hash_aset(a, rb_tainted_str_new2("st_env_priority"), INT2NUM(bs->st_env_priority)); 322 - rb_hash_aset(a, rb_tainted_str_new2("st_gen"), INT2NUM(bs->st_gen)); 323 - rb_hash_aset(a, rb_tainted_str_new2("st_log_duplicated"), INT2NUM(bs->st_log_duplicated)); 324 - rb_hash_aset(a, rb_tainted_str_new2("st_log_queued"), INT2NUM(bs->st_log_queued)); 325 - rb_hash_aset(a, rb_tainted_str_new2("st_log_queued_max"), INT2NUM(bs->st_log_queued_max)); 326 - rb_hash_aset(a, rb_tainted_str_new2("st_log_queued_total"), INT2NUM(bs->st_log_queued_total)); 327 - rb_hash_aset(a, rb_tainted_str_new2("st_log_records"), INT2NUM(bs->st_log_records)); 328 - rb_hash_aset(a, rb_tainted_str_new2("st_log_requested"), INT2NUM(bs->st_log_requested)); 329 - rb_hash_aset(a, rb_tainted_str_new2("st_master"), INT2NUM(bs->st_master)); 330 - rb_hash_aset(a, rb_tainted_str_new2("st_master_changes"), INT2NUM(bs->st_master_changes)); 331 - rb_hash_aset(a, rb_tainted_str_new2("st_msgs_badgen"), INT2NUM(bs->st_msgs_badgen)); 332 - rb_hash_aset(a, rb_tainted_str_new2("st_msgs_processed"), INT2NUM(bs->st_msgs_processed)); 333 - rb_hash_aset(a, rb_tainted_str_new2("st_msgs_recover"), INT2NUM(bs->st_msgs_recover)); 334 - rb_hash_aset(a, rb_tainted_str_new2("st_msgs_send_failures"), INT2NUM(bs->st_msgs_send_failures)); 335 - rb_hash_aset(a, rb_tainted_str_new2("st_msgs_sent"), INT2NUM(bs->st_msgs_sent)); 336 - rb_hash_aset(a, rb_tainted_str_new2("st_newsites"), INT2NUM(bs->st_newsites)); 337 + rb_hash_aset(a, rb_str_new_cstr("st_election_votes"), INT2NUM(bs->st_election_votes)); 338 + rb_hash_aset(a, rb_str_new_cstr("st_elections"), INT2NUM(bs->st_elections)); 339 + rb_hash_aset(a, rb_str_new_cstr("st_elections_won"), INT2NUM(bs->st_elections_won)); 340 + rb_hash_aset(a, rb_str_new_cstr("st_env_id"), INT2NUM(bs->st_env_id)); 341 + rb_hash_aset(a, rb_str_new_cstr("st_env_priority"), INT2NUM(bs->st_env_priority)); 342 + rb_hash_aset(a, rb_str_new_cstr("st_gen"), INT2NUM(bs->st_gen)); 343 + rb_hash_aset(a, rb_str_new_cstr("st_log_duplicated"), INT2NUM(bs->st_log_duplicated)); 344 + rb_hash_aset(a, rb_str_new_cstr("st_log_queued"), INT2NUM(bs->st_log_queued)); 345 + rb_hash_aset(a, rb_str_new_cstr("st_log_queued_max"), INT2NUM(bs->st_log_queued_max)); 346 + rb_hash_aset(a, rb_str_new_cstr("st_log_queued_total"), INT2NUM(bs->st_log_queued_total)); 347 + rb_hash_aset(a, rb_str_new_cstr("st_log_records"), INT2NUM(bs->st_log_records)); 348 + rb_hash_aset(a, rb_str_new_cstr("st_log_requested"), INT2NUM(bs->st_log_requested)); 349 + rb_hash_aset(a, rb_str_new_cstr("st_master"), INT2NUM(bs->st_master)); 350 + rb_hash_aset(a, rb_str_new_cstr("st_master_changes"), INT2NUM(bs->st_master_changes)); 351 + rb_hash_aset(a, rb_str_new_cstr("st_msgs_badgen"), INT2NUM(bs->st_msgs_badgen)); 352 + rb_hash_aset(a, rb_str_new_cstr("st_msgs_processed"), INT2NUM(bs->st_msgs_processed)); 353 + rb_hash_aset(a, rb_str_new_cstr("st_msgs_recover"), INT2NUM(bs->st_msgs_recover)); 354 + rb_hash_aset(a, rb_str_new_cstr("st_msgs_send_failures"), INT2NUM(bs->st_msgs_send_failures)); 355 + rb_hash_aset(a, rb_str_new_cstr("st_msgs_sent"), INT2NUM(bs->st_msgs_sent)); 356 + rb_hash_aset(a, rb_str_new_cstr("st_newsites"), INT2NUM(bs->st_newsites)); 357 358 lsn = bdb_makelsn(obj); 359 Data_Get_Struct(lsn, struct dblsnst, lsnst); 360 MEMCPY(lsnst->lsn, &bs->st_next_lsn, DB_LSN, 1); 361 - rb_hash_aset(a, rb_tainted_str_new2("st_next_lsn"), lsn); 362 + rb_hash_aset(a, rb_str_new_cstr("st_next_lsn"), lsn); 363 #if HAVE_ST_DB_REP_STAT_ST_NEXT_PG 364 - rb_hash_aset(a, rb_tainted_str_new2("st_next_pg"), INT2NUM(bs->st_next_pg)); 365 + rb_hash_aset(a, rb_str_new_cstr("st_next_pg"), INT2NUM(bs->st_next_pg)); 366 #endif 367 - rb_hash_aset(a, rb_tainted_str_new2("st_nsites"), INT2NUM(bs->st_nsites)); 368 - rb_hash_aset(a, rb_tainted_str_new2("st_nthrottles"), INT2NUM(bs->st_nthrottles)); 369 - rb_hash_aset(a, rb_tainted_str_new2("st_outdated"), INT2NUM(bs->st_outdated)); 370 + rb_hash_aset(a, rb_str_new_cstr("st_nsites"), INT2NUM(bs->st_nsites)); 371 + rb_hash_aset(a, rb_str_new_cstr("st_nthrottles"), INT2NUM(bs->st_nthrottles)); 372 + rb_hash_aset(a, rb_str_new_cstr("st_outdated"), INT2NUM(bs->st_outdated)); 373 #if HAVE_ST_DB_REP_STAT_ST_PG_DUPLICATED 374 - rb_hash_aset(a, rb_tainted_str_new2("st_pg_duplicated"), INT2NUM(bs->st_pg_duplicated)); 375 + rb_hash_aset(a, rb_str_new_cstr("st_pg_duplicated"), INT2NUM(bs->st_pg_duplicated)); 376 #endif 377 #if HAVE_ST_DB_REP_STAT_ST_PG_RECORDS 378 - rb_hash_aset(a, rb_tainted_str_new2("st_pg_records"), INT2NUM(bs->st_pg_records)); 379 + rb_hash_aset(a, rb_str_new_cstr("st_pg_records"), INT2NUM(bs->st_pg_records)); 380 #endif 381 #if HAVE_ST_DB_REP_STAT_ST_PG_REQUESTED 382 - rb_hash_aset(a, rb_tainted_str_new2("st_pg_requested"), INT2NUM(bs->st_pg_requested)); 383 + rb_hash_aset(a, rb_str_new_cstr("st_pg_requested"), INT2NUM(bs->st_pg_requested)); 384 #endif 385 #if HAVE_ST_DB_REP_STAT_ST_STARTUP_COMPLETE 386 - rb_hash_aset(a, rb_tainted_str_new2("st_startup_complete"), INT2NUM(bs->st_startup_complete)); 387 + rb_hash_aset(a, rb_str_new_cstr("st_startup_complete"), INT2NUM(bs->st_startup_complete)); 388 #endif 389 - rb_hash_aset(a, rb_tainted_str_new2("st_status"), INT2NUM(bs->st_status)); 390 - rb_hash_aset(a, rb_tainted_str_new2("st_txns_applied"), INT2NUM(bs->st_txns_applied)); 391 + rb_hash_aset(a, rb_str_new_cstr("st_status"), INT2NUM(bs->st_status)); 392 + rb_hash_aset(a, rb_str_new_cstr("st_txns_applied"), INT2NUM(bs->st_txns_applied)); 393 lsn = bdb_makelsn(obj); 394 Data_Get_Struct(lsn, struct dblsnst, lsnst); 395 MEMCPY(lsnst->lsn, &bs->st_waiting_lsn, DB_LSN, 1); 396 - rb_hash_aset(a, rb_tainted_str_new2("st_waiting_lsn"), lsn); 397 + rb_hash_aset(a, rb_str_new_cstr("st_waiting_lsn"), lsn); 398 #if HAVE_ST_DB_REP_STAT_ST_WAITING_PG 399 - rb_hash_aset(a, rb_tainted_str_new2("st_waiting_pg"), INT2NUM(bs->st_waiting_pg)); 400 + rb_hash_aset(a, rb_str_new_cstr("st_waiting_pg"), INT2NUM(bs->st_waiting_pg)); 401 #endif 402 free(bs); 403 return a; 404 @@ -2764,7 +2773,7 @@ bdb_env_rep_set_clockskew(VALUE obj, VALUE a, VALUE b) 405 } 406 407 static VALUE 408 -bdb_env_rep_get_clockskew(VALUE obj, VALUE a) 409 +bdb_env_rep_get_clockskew(VALUE obj) 410 { 411 bdb_ENV *envst; 412 u_int32_t fast, slow; 413 @@ -2791,7 +2800,7 @@ bdb_env_rep_set_request(VALUE obj, VALUE a, VALUE b) 414 } 415 416 static VALUE 417 -bdb_env_rep_get_request(VALUE obj, VALUE a) 418 +bdb_env_rep_get_request(VALUE obj) 419 { 420 bdb_ENV *envst; 421 u_int32_t frmin, frmax; 422 @@ -2816,7 +2825,7 @@ bdb_env_dir_mode(VALUE obj) 423 if (envst->envp->get_intermediate_dir_mode(envst->envp, &dir)) { 424 rb_raise(rb_eArgError, "invalid environment"); 425 } 426 - return rb_tainted_str_new2(dir); 427 + return rb_str_new_cstr(dir); 428 } 429 430 #endif 431 @@ -3012,7 +3021,7 @@ void bdb_init_env() 432 rb_define_method(bdb_cEnv, "rep_timeout?", bdb_env_rep_intern_timeout, 1); 433 #endif 434 #if HAVE_ST_DB_ENV_REP_STAT 435 - rb_define_method(bdb_cEnv, "rep_stat", bdb_env_rep_stat, 0); 436 + rb_define_method(bdb_cEnv, "rep_stat", bdb_env_rep_stat, -1); 437 #endif 438 #if HAVE_ST_DB_ENV_REP_SYNC 439 rb_define_method(bdb_cEnv, "rep_sync", bdb_env_rep_sync, -1); 440