FileBase::FileBase(int data_fd, int meta_fd, const key_type& key_, const id_type& id_, bool check)
: m_lock()
, m_refcount(1)
, m_header()
, m_id(id_)
, m_data_fd(data_fd)
, m_meta_fd(meta_fd)
, m_dirty(false)
, m_check(check)
, m_stream()
, m_removed(false)
{
auto data_stream = std::make_shared<POSIXFileStream>(data_fd);
auto meta_stream = std::make_shared<POSIXFileStream>(meta_fd);
key_type data_key, meta_key;
byte generated_keys[KEY_LENGTH * 3];
hkdf(key_.data(),
key_.size(),
nullptr,
0,
id_.data(),
id_.size(),
generated_keys,
sizeof(generated_keys));
memcpy(data_key.data(), generated_keys, KEY_LENGTH);
memcpy(meta_key.data(), generated_keys + KEY_LENGTH, KEY_LENGTH);
memcpy(m_key.data(), generated_keys + 2 * KEY_LENGTH, KEY_LENGTH);
auto crypt = make_cryptstream_aes_gcm(
std::move(data_stream), std::move(meta_stream), data_key, meta_key, id_, check);
m_stream = crypt.first;
m_header = crypt.second;
read_header();
}
iterator insert( const key_type& key)
{
if( empty())
{
keys().push_back( key);
return begin();
}
if( key.time() < front().time())
{
keys().insert( begin(), key);
return begin();
}
if( key.time() > back().time())
{
keys().push_back( key);
return end() - 1;
}
iterator it( lower_bound( key.time()));
if( abs( it->time() - key.time()) <= keyframe_t::time_tolerance())
{
*it = key;
return it;
}
else
return keys().insert( it, key);
}
const key_type& key() {
if(!reversed_key_) {
key_.set_bits(0, ary_->lsize(), ary_->inverse_matrix().times(key_));
reversed_key_ = true;
}
return key_;
}
slirc::channeluser_list::size_type slirc::channeluser_list::erase(const key_type &key) {
slirc::channeluser_list::size_type ret = baseclass::erase(key);
if (ret && detacher) {
key->detach();
}
return ret;
}
void operator()(const key_type &key, std::array<M128I<U>, Rp1> &rk) const
{
M128I<std::uint64_t> weyl;
weyl.set(
ARSWeylConstantTrait<1>::value, ARSWeylConstantTrait<0>::value);
std::get<0>(rk).load(key.data());
generate<1>(rk, weyl, std::integral_constant<bool, 1 < Rp1>());
}
bool next() {
key_status success = array::EMPTY;
while(success != array::FILLED && id_ < end_id_)
success = ary_->get_key_val_at_id(id_++, key_, val_);
if(success == array::FILLED)
key_.set_bits(0, ary_->lsize(), ary_->inverse_matrix().times(key_));
return success == array::FILLED;
}
FileTable::FileTable(int version,
std::shared_ptr<FileSystemService> root,
const key_type& master_key,
uint32_t flags,
unsigned block_size,
unsigned iv_size)
: m_flags(flags), m_block_size(block_size), m_iv_size(iv_size), m_root(root)
{
memcpy(m_master_key.data(), master_key.data(), master_key.size());
switch (version)
{
case 1:
m_fio.reset(new FileTableIOVersion1(root, is_readonly()));
break;
case 2:
m_fio.reset(new FileTableIOVersion2(root, is_readonly()));
break;
default:
throw InvalidArgumentException("Unknown version");
}
}
bool next() {
reversed_key_ = false;
bool found_oid = false;
while(!found_oid && id_ < mid_) {
if(ary_->get_key_at_id((start_id_ + id_++) & mask_, *key_, &w_, &o_) == array::FILLED) {
oid_ = key_->get_bits(0, ary_->lsize());
found_oid = start_id_ <= oid_ && oid_ < end_id_;
}
}
return found_oid;
}
MappingIterator::MappingIterator(const ObjectHandle& containerHandle, const container_type& container,
const key_type& key, const Converters& typeConverters)
: containerHandle_(containerHandle), container_(container), keys_(container_.keys(PyScript::ScriptErrorPrint())),
index_(0), key_(key), typeConverters_(typeConverters)
{
if (!key_.exists())
{
index_ = container_.size();
}
else
{
bool found = false;
// If the key is not found, then index_ == end
for (; index_ < keys_.size(); ++index_)
{
auto scriptKey = keys_.getItem(index_);
if (key.compareTo(scriptKey, PyScript::ScriptErrorPrint()) == 0)
{
found = true;
break;
}
}
// HACK NGT-1603 Try to cast key to an index
// Work-around for how ReflectedPropertyItem::getChild will try to
// access items with the a string "[index]"
if (!found)
{
Variant result;
ObjectHandle parentHandle;
const char* childPath = "";
const bool success = typeConverters_.toVariant(key_, result, parentHandle, childPath);
PyScript::ScriptList::size_type fakeIndex = container_.size();
const bool isIndex = result.tryCast(fakeIndex);
if (isIndex && (fakeIndex >= 0) && (fakeIndex < container_.size()))
{
index_ = fakeIndex;
key_ = keys_.getItem(index_);
}
}
}
}
typename Matrix::size_type operator() (key_type const& key) const
{
return key.col();
}
reference operator[](key_type key) const { return (*internal_vector)[key->id()]; }
math::natural traits<phys::constraint::unilateral::key>::dimension(key_type k) { return k->dim(); }
inline friend reference get(const Constrained_edge_map& em, key_type e)
{
bool b = em.sm_.property(em.constraint,em.sm_.edge_handle(e.idx()));
return b;
}
/*!
* The method finds the attribute value by name.
*
* \param key Attribute name.
* \return Iterator to the found element or \c end() if the attribute with such name is not found.
*/
const_iterator find(key_type const& key) const
{
return find_impl(key.data(), key.size());
}
bool operator()(const key_type& x, const key_type& y) const { return x.here() < y.here(); }
int atoi_fast::atoi(const key_type& k, int offset) const
{
char* string = k.get();
int l = k.size();
return atoi((const char*)string, l, offset, 0);
}
value_type operator[] (const key_type& k) const { return k.get_id(); }
void init_decrypt(AES_KEY &ctx, const key_type &key, const iv_type &iv)
{
AES_set_decrypt_key(&key[0], key.size() * 8, &ctx);
}
void init_decrypt(AES_KEY &ctx, const key_type &key, const iv_type &iv)
{
// 같은 키 초기화함수를 통해 복호화해야 한다.
AES_set_encrypt_key(&key[0], key.size() * 8, &ctx);
}
bool operator()(ticket_type xk, const key_type& y) const { return xk < y.here(); }
size_t pos() const { return key_.get_bits(0, ary_->lsize()); }
// The put function is required by the property map concept.
friend void put(const Extended_face_property_map& map,
key_type key, value_type val)
{ key->set_data(val); }
bool operator()(const key_type& x, ticket_type yk) const { return x.here() < yk; }
result_type operator() (key_type const& left, key_type const& right) const
{
return left.id() < right.id();
}
#include <string.h>
#include <errno.h>
#include <vector>
#include <algorithm>
#include <set>
#include <fcntl.h>
#include <unistd.h>
TEST_CASE("File table")
{
using namespace securefs;
char dir_template[] = "/tmp/securefs_file_table.XXXXXXX";
mkdtemp(dir_template);
key_type master_key;
id_type null_id, file_id;
memset(master_key.data(), 0xFF, master_key.size());
memset(null_id.data(), 0, null_id.size());
memset(file_id.data(), 0xEE, file_id.size());
const char* xattr_name = "com.apple.FinderInfo...";
const securefs::PODArray<char, 32> xattr_value(0x11);
{
int tmp_fd = ::open(dir_template, O_RDONLY);
REQUIRE(tmp_fd >= 0);
FileTable table(tmp_fd, master_key, 0);
auto dir = dynamic_cast<Directory*>(table.create_as(null_id, FileBase::DIRECTORY));
dir->add_entry(".", null_id, FileBase::DIRECTORY);
dir->add_entry("..", null_id, FileBase::DIRECTORY);
dir->add_entry("hello", file_id, FileBase::REGULAR_FILE);
// The get function is required by the property map concept.
friend reference get(const Extended_face_property_map& /* map */,
key_type key)
{
return key->data();
}
reference operator[](key_type const& e) const { return e->is_border() || is_constrained(e) ; }
// The put function is required by the property map concept.
friend void put(Extended_face_property_map /* map */,
key_type key, value_type val)
{
key->set_data(val);
}
inline friend void put(const Constrained_edge_map& em, key_type e, value_type b)
{
em.sm_.property(em.constraint,em.sm_.edge_handle(e.idx())) = b;
}
void init_decrypt(SALSA20_ECRYPT_ctx &ctx, const key_type &key, const iv_type &iv)
{
SALSA20_ECRYPT_keysetup(&ctx, &key[0], key.size() * 8, iv.size() * 8);
SALSA20_ECRYPT_ivsetup(&ctx, &iv[0]);
}
