TEST_F(avl_tree,DISABLED_big_split)
{
static const unsigned num_iterations=1000000000;
static const unsigned char key_mod=5;
static const unsigned perf_mod=200000;
static const unsigned kp=1;
bin_index_t::file_max_size=9223372036854775807ll;
recreate_dirs();
ObjectProgress::log_generator lg(true);
ObjectProgress::perfomance perf;
data_t key(kp*sizeof(unsigned long long));
{
bin_index_t ind(index_dir,kp*sizeof(unsigned long long));
for(unsigned long long i=0;i<num_iterations;i++)
{
fill_key(&key.front(),i,kp);
ind.set(key,key);
if((i!=0)&&(i%perf_mod)==0)
{
ObjectProgress::perfomance::val_t v=perf.delay();
lg<<"write: i="<<i<<" perf="<<(v/1000.0)<<"ms rate="<<(1.0*perf_mod/v*1000000.0)<<"rps";
perf.reset();
}
}
}
{
bin_index_t ind(index_dir,kp*sizeof(unsigned long long));
perf.reset();
for(unsigned long long i=0;i<num_iterations;i++)
{
fill_key(&key.front(),i,kp);
data_t val;
ASSERT_TRUE(ind.get(key,val));
ASSERT_EQ(key,val);
if((i!=0)&&(i%perf_mod)==0)
{
ObjectProgress::perfomance::val_t v=perf.delay();
lg<<"read: i="<<i<<" perf="<<(v/1000.0)<<"ms rate="<<(1.0*perf_mod/v*1000000.0)<<"rps";
perf.reset();
}
}
}
}
int e4crypt_delete_user_key(const char *user_handle) {
SLOGD("e4crypt_delete_user_key(\"%s\")", user_handle);
auto key_path = get_key_path(DATA_MNT_POINT, user_handle);
auto key = e4crypt_get_key(key_path, false);
auto ext4_key = fill_key(key);
auto ref = keyname(generate_key_ref(ext4_key.raw, ext4_key.size));
auto key_serial = keyctl_search(e4crypt_keyring(), "logon", ref.c_str(), 0);
if (keyctl_revoke(key_serial) == 0) {
SLOGD("Revoked key with serial %ld ref %s\n", key_serial, ref.c_str());
} else {
SLOGE("Failed to revoke key with serial %ld ref %s: %s\n",
key_serial, ref.c_str(), strerror(errno));
}
int pid = fork();
if (pid < 0) {
SLOGE("Unable to fork: %s", strerror(errno));
return -1;
}
if (pid == 0) {
SLOGD("Forked for secdiscard");
execl("/system/bin/secdiscard",
"/system/bin/secdiscard",
key_path.c_str(),
NULL);
SLOGE("Unable to launch secdiscard on %s: %s\n", key_path.c_str(),
strerror(errno));
exit(-1);
}
// ext4enc:TODO reap the zombie
return 0;
}
bool Connector::abbr(const std::string& key, const std::string& data)
{
StringList real_keylist;
fill_key(key);
generate_keys(real_keylist);
return generator_.on_have_data(real_keylist, data);
}
// Install password into global keyring
// Return raw key reference for use in policy
static std::string e4crypt_install_key(const std::string &key)
{
auto ext4_key = fill_key(key);
auto raw_ref = generate_key_ref(ext4_key.raw, ext4_key.size);
auto ref = keyname(raw_ref);
if (e4crypt_install_key(ext4_key, ref) == -1) {
return "";
}
return raw_ref;
}
bool Connector::abbr(const StringList& keylist, const std::string& data)
{
StringList real_keylist;
for (StringList::const_iterator it = keylist.begin();
it != keylist.end(); ++it) {
fill_key(*it);
generate_keys(real_keylist);
}
return generator_.on_have_data(real_keylist, data);
}
bool Connector::article(const std::string& key, const std::string& data,
bool kia)
{
std::string keystr;
StringList real_keylist;
if (!kia)
keystr += std::string("<k>") + key + "</k>\n";
fill_key(key);
generate_keys(real_keylist);
return generator_.on_have_data(real_keylist, keystr + data);
}
bool Connector::article(const StringList& keylist, const std::string& data, bool kia)
{
std::string keystr;
StringList real_keylist;
for (StringList::const_iterator it = keylist.begin();
it != keylist.end(); ++it) {
if (!kia)
keystr += std::string("<k>") + *it + "</k>\n";
fill_key(*it);
generate_keys(real_keylist);
}
return generator_.on_have_data(real_keylist, keystr + data);
}
static bool handle_input(struct input_state *st, int out_fd)
{
struct input_event ev;
ssize_t l;
unsigned long mask = 0, value;
bool do_submit = false;
l = read(st->fd, &ev, sizeof ev);
if (l == 0 || (l < 0 && errno == ENODEV))
return false;
if (l < 0) {
err("read(<event>): %m");
exit(1);
}
if (l != sizeof ev)
abort();
switch (ev.type) {
case EV_KEY:
st->is_raw = false;
switch (ev.code) {
case KEY_LEFTMETA:
case KEY_RIGHTMETA:
mask = MODE_META;
break;
case KEY_LEFTCTRL:
case KEY_RIGHTCTRL:
mask = MODE_CTRL;
break;
case KEY_LEFTALT:
case KEY_RIGHTALT:
mask = MODE_ALT;
break;
case KEY_LEFTSHIFT:
case KEY_RIGHTSHIFT:
mask = MODE_SHIFT;
break;
case KEY_NUMLOCK:
mask = MODE_NUMLOCK;
break;
}
if (mask) {
if (ev.value)
value = mask;
else
value = 0;
st->mode &= ~mask;
st->mode |= value;
if (st->mode != MODE_ALT && st->is_alt) {
ev.value = 1;
do_submit = true;
}
} else if (st->mode == MODE_ALT && ev.value == 0)
; /* noop */
else if (st->mode == MODE_ALT) {
int num_code = -1;
switch (ev.code) {
case KEY_KP0: num_code = 0; break;
case KEY_KP1: num_code = 1; break;
case KEY_KP2: num_code = 2; break;
case KEY_KP3: num_code = 3; break;
case KEY_KP4: num_code = 4; break;
case KEY_KP5: num_code = 5; break;
case KEY_KP6: num_code = 6; break;
case KEY_KP7: num_code = 7; break;
case KEY_KP8: num_code = 8; break;
case KEY_KP9: num_code = 9; break;
default: num_code = -1; break;
}
st->is_alt = num_code != -1;
if (!st->is_alt) {
st->key = ev.code;
do_submit = true;
} else
st->key = st->key * 10 + num_code;
} else if (st->is_alt) {
ev.value = 0;
do_submit = true;
st->is_alt = false;
} else {
st->key = ev.code;
do_submit = true;
}
break;
case EV_SYN:
if (st->is_raw &&
!send_events(out_fd, &ev, 1))
exit(1);
st->is_raw = false;
break;
case EV_MSC:
break;
case EV_REL:
if (!send_events(out_fd, &ev, 1))
exit(1);
st->is_raw = true;
break;
case EV_REP:
break;
default: ;
warn("unsupported event type %02x\n", ev.type);
break;
}
if (do_submit) {
int found;
st->ev[0].time = ev.time;
st->ev[1].time = ev.time;
st->ev[1].value = ev.value;
st->ev[2].time = ev.time;
st->ev[2].type = EV_SYN;
st->ev[2].code = SYN_REPORT;
st->ev[2].value = 0;
if (ev.value)
found = fill_key(st->ev,
st->mode |
(st->is_alt ? MODE_NUMALT : 0),
st->key);
else
found = true;
if (found) {
bool send_scancode = st->ev[1].value == 1;
if (!send_events(out_fd,
send_scancode ? &st->ev[0] : &st->ev[1],
send_scancode ? 3 : 2))
exit(1);
} else
warn("unknown code M(%u,%u,%u,%u,%u) %d %d %ld\n",
!!(st->mode & MODE_META),
!!(st->mode & MODE_CTRL),
!!(st->mode & MODE_SHIFT),
!!(st->mode & MODE_ALT),
!!st->is_alt,
st->key, ev.value, (st->mode & MODE_NUMLOCK));
st->key = 0;
}
return true;
}
