buffer_t
export_public_key(context& d, key_format fmt) {
#if defined(MBEDTLS_PK_WRITE_C)
buffer_t output(K::DefaultExportBufferSize, '\0');
if (fmt == pk::pem_format) {
mbedcrypto_c_call(
mbedtls_pk_write_pubkey_pem,
&d.pk_,
to_ptr(output),
K::DefaultExportBufferSize);
output.resize(std::strlen(output.c_str()));
finalize_pem(output);
} else if (fmt == pk::der_format) {
int ret = mbedtls_pk_write_pubkey_der(
&d.pk_, to_ptr(output), K::DefaultExportBufferSize);
if (ret < 0)
throw exception{ret, __FUNCTION__};
size_t length = ret;
output.erase(0, K::DefaultExportBufferSize - length);
output.resize(length);
}
return output;
#else // MBEDTLS_PK_WRITE_C
throw exceptions::pk_export_missed{};
#endif // MBEDTLS_PK_WRITE_C
}
void ShaderNode_clear_links(ShaderNode _sn)
{
ShaderObject exec_so = {NULL};
/**
if ( to_ptr(_sn->result_link) != NULL )
{
ShaderObject_delete(_sn->result_link);
_sn->result_link = exec_so;
}
**/
for (euint32 i = 0; i < array_n(_sn->input_links); i++)
{
ShaderObject so = array_safe_get(_sn->input_links, i);
if ( to_ptr(so) != NULL )
ShaderObject_delete(so);
}
array_delete(_sn->input_links);
_sn->input_links = array_new(ShaderObject, 5, exec_so);
for (euint32 i = 0; i < array_n(_sn->output_links); i++)
{
ShaderObject so = array_safe_get(_sn->output_links, i);
if ( to_ptr(so) != NULL )
ShaderObject_delete(so);
}
array_delete(_sn->output_links);
_sn->output_links = array_new(ShaderObject, 5, exec_so);
}
WriteXctAccess create_write_access(int i) {
WriteXctAccess access;
access.payload_address_ = reinterpret_cast<char*>(to_ptr(i * 542312));
access.storage_id_ = i * 52223ULL;
access.owner_id_address_ = reinterpret_cast<xct::LockableXctId*>(to_ptr(i * 14325));
access.write_set_ordinal_ = 0; // we should have a testcase to test this order
access.log_entry_ = reinterpret_cast<log::RecordLogType*>(to_ptr(i * 5423423));
return access;
}
ShaderNode ShaderNode_clone(ShaderNode _sn)
{
ShaderNode ret = ShaderNode_new();
if (_sn->node_name)
{
ShaderNode_set_name(ret, _sn->node_name);
}
if (_sn->function)
{
ret->function = (char*)EString_new(_sn->function);
}
for (euint32 i = 0; i < array_n(_sn->input_param_table); i++)
{
///ShaderObject so = array_safe_get(_sn->input_param_table, i);
ShaderObject so = _sn->input_param_table[i];
ShaderObject cso = ShaderObject_clone(so);
EAssert (to_ptr(so) && to_ptr(cso), "%s", "clone null shader object");
ret->input_param_table = array_push(ret->input_param_table, cso);
}
for (euint32 i = 0; i < array_n(_sn->output_param_table); i++)
{
///ShaderObject so = array_safe_get(_sn->output_param_table, i);
ShaderObject so = _sn->output_param_table[i];
ShaderObject cso = ShaderObject_clone(so);
EAssert (to_ptr(so) && to_ptr(cso), "%s", "clone null shader object");
ret->output_param_table = array_push(ret->output_param_table, cso);
}
for (euint32 i = 0; i < array_n(_sn->input_links); i++)
{
ShaderObject so = array_safe_get(_sn->input_links, i);
ret->input_links = array_push(ret->input_links, ShaderObject_clone(so));
}
for (euint32 i = 0; i < array_n(_sn->output_links); i++)
{
ShaderObject so = array_safe_get(_sn->output_links, i);
ret->output_links = array_push(ret->output_links, ShaderObject_clone(so));
}
/**
if ( to_ptr(_sn->result_link) )
{
ret->result_link = ShaderObject_clone(_sn->result_link);
}
**/
///ShaderObject_delete(ret->result);
///ret->result = ShaderObject_clone(_sn->result);
ret->base.compile_proc = (shader_node_compile_proc)ShaderNode_compile;
return ret;
}
buffer_t
hmac::finish() {
buffer_t digest(pimpl->size(), '\0');
mbedcrypto_c_call(mbedtls_md_hmac_finish, &pimpl->ctx_, to_ptr(digest));
return digest;
}
buffer_t
decrypt(context& d, buffer_view_t encrypted_value) {
if (type_of(d) != pk_t::rsa)
throw exceptions::support_error{};
if ((encrypted_value.size() << 3) > key_bitlen(d))
throw larger_than_key{};
size_t olen = 32 + max_crypt_size(d);
buffer_t output(olen, '\0');
mbedcrypto_c_call(
mbedtls_pk_decrypt,
&d.pk_,
encrypted_value.data(),
encrypted_value.size(),
to_ptr(output),
&olen,
olen,
rnd_generator::maker,
&d.rnd_);
output.resize(olen);
return output;
}
ReadXctAccess create_access(int i) {
ReadXctAccess access;
access.observed_owner_id_.set(i * 20, i * 12);
access.storage_id_ = i * 1234U;
access.owner_id_address_ = reinterpret_cast<xct::LockableXctId*>(to_ptr(i * 8452));
return access;
}
void verify_access(const ReadXctAccess &access, int i) {
XctId tmp;
tmp.set(i * 20, i * 12);
EXPECT_TRUE(access.observed_owner_id_ == tmp);
EXPECT_EQ(i * 1234U, access.storage_id_);
EXPECT_TRUE(access.owner_id_address_ == reinterpret_cast<xct::LockableXctId*>(to_ptr(i * 8452)));
}
///==============================ShaderNode========================================///
void ShaderNode_Dest(shader_node* _sn)
{
if (_sn->node_name)
EString_delete(_sn->node_name);
if (_sn->function)
EString_delete(_sn->function);
/**
ShaderObject_delete(_sn->result);
if ( to_ptr(_sn->result_link) != NULL )
ShaderObject_delete(_sn->result_link);
**/
for (euint32 i = 0; i < array_n(_sn->input_param_table); i++)
{
ShaderObject so = array_safe_get(_sn->input_param_table, i);
if ( to_ptr(so) != NULL )
ShaderObject_delete(so);
}
array_delete(_sn->input_param_table);
for (euint32 i = 0; i < array_n(_sn->output_param_table); i++)
{
ShaderObject so = array_safe_get(_sn->output_param_table, i);
if ( to_ptr(so) != NULL )
ShaderObject_delete(so);
}
array_delete(_sn->output_param_table);
for (euint32 i = 0; i < array_n(_sn->input_links); i++)
{
ShaderObject so = array_safe_get(_sn->input_links, i);
if ( to_ptr(so) != NULL )
ShaderObject_delete(so);
}
array_delete(_sn->input_links);
for (euint32 i = 0; i < array_n(_sn->output_links); i++)
{
ShaderObject so = array_safe_get(_sn->output_links, i);
if ( to_ptr(so) != NULL )
ShaderObject_delete(so);
}
array_delete(_sn->output_links);
}
buffer_t
hash::make(hash_t type, const unsigned char* src, size_t length) {
auto digest = digest_pair(type);
mbedcrypto_c_call(
mbedtls_md,
std::get<0>(digest),
src,
length,
to_ptr(std::get<1>(digest)));
return std::get<1>(digest);
}
buffer_t
hash::of_file(hash_t type, const char* filePath) {
#if defined(MBEDTLS_FS_IO)
auto digest = digest_pair(type);
mbedcrypto_c_call(
mbedtls_md_file,
std::get<0>(digest),
filePath,
to_ptr(std::get<1>(digest)));
return std::get<1>(digest);
#else
throw support_exception{};
#endif
}
buffer_t
sign(context& d, buffer_view_t hvalue, hash_t halgo) {
if (type_of(d) != pk_t::rsa && !can_do(d, pk_t::ecdsa))
throw exceptions::support_error{};
check_crypt_size_of(d, hvalue);
size_t olen = 32 + max_crypt_size(d);
buffer_t output(olen, '\0');
mbedcrypto_c_call(
mbedtls_pk_sign,
&d.pk_,
to_native(halgo),
hvalue.data(),
hvalue.size(),
to_ptr(output),
&olen,
rnd_generator::maker,
&d.rnd_);
output.resize(olen);
return output;
}
buffer_t
encrypt(context& d, buffer_view_t source) {
if (type_of(d) != pk_t::rsa)
throw exceptions::support_error{};
check_crypt_size_of(d, source);
size_t olen = 32 + max_crypt_size(d);
buffer_t output(olen, '\0');
mbedcrypto_c_call(
mbedtls_pk_encrypt,
&d.pk_,
source.data(),
source.size(),
to_ptr(output),
&olen,
olen,
rnd_generator::maker,
&d.rnd_);
output.resize(olen);
return output;
}
// Access.
inline const_reference
operator*() const
{
_GLIBCXX_DEBUG_ASSERT(m_p_e != NULL);
return *to_ptr(integral_constant<int, Simple>());
}
// Access.
inline const_pointer
operator->() const
{
_GLIBCXX_DEBUG_ASSERT(m_p_e != NULL);
return to_ptr(integral_constant<int, Simple>());
}
/*
* Class: org_jamruby_mruby_RString
* Method: n_getPtr
* Signature: (J)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_org_jamruby_mruby_RString_n_1getPtr
(JNIEnv *env, jclass clazz, jlong str)
{
safe_jni::safe_local_ref<jstring> jstr(env, env->NewStringUTF(to_ptr(str)->ptr));
return jstr.get();
}
int main() {
char buf[1024];
int command_number;
int result;
CFileSystem test_system;
do {
scanf("%s", buf);
command_number = get_command_number(buf);
switch(command_number) {
case (1): {
scanf("%s", buf);
int block_size = to_int(buf);
result = test_system.set_block_size(block_size);
break;
}
case (2): {
scanf("%s", buf);
int disk_size = to_int(buf);
result = test_system.start_with_disk_size(disk_size);
break;
}
case (3): {
result = test_system.creatable();
break;
}
case (4): {
result = test_system.create_file();
break;
}
case (5): {
scanf("%s", buf);
int file_key = to_int(buf);
result = test_system.is_empty(file_key);
break;
}
case (6): {
scanf("%s", buf);
int file_key = to_int(buf);
read_file_str_to_buffer(buf);
result = test_system.can_add_line(file_key, buf);
break;
}
case (7): {
scanf("%s", buf);
int file_key = to_int(buf);
read_file_str_to_buffer(buf);
result = test_system.push_back_line(file_key, buf);
break;
}
case (8): {
scanf("%s", buf);
int file_key = to_int(buf);
scanf("%s", buf);
char* ptr = to_ptr(buf);
result = test_system.get_last_line(file_key);
break;
}
case (9): {
scanf("%s", buf);
int file_key = to_int(buf);
result = test_system.at_begin(file_key);
break;
}
case (10): {
scanf("%s", buf);
int file_key = to_int(buf);
result = test_system.at_end(file_key);
break;
}
case (11): {
scanf("%s", buf);
int file_key = to_int(buf);
result = test_system.set_cursor_to_begin(file_key);
break;
}
case (12): {
scanf("%s", buf);
int file_key = to_int(buf);
result = test_system.set_cursor_to_end(file_key);
break;
}
case (13): {
scanf("%s", buf);
int file_key = to_int(buf);
scanf("%s", buf);
char* ptr = to_ptr(buf);
result = test_system.read_forward(file_key);
break;
}
case (14): {
scanf("%s", buf);
int file_key = to_int(buf);
scanf("%s", buf);
char* ptr = to_ptr(buf);
result = test_system.read_backward(file_key);
break;
break;
}
case (15): {
scanf("%s", buf);
int file_key = to_int(buf);
result = test_system.delete_file(file_key);
break;
}
case (16): {
result = test_system.end_work();
goto exit_main_loop;
}
default: {
std::cout << "Unknown command" << std::endl;
goto exit_main_loop;
}
}
std::cout.flush();
//std::cout << "Command_number: " << command_number << std::endl;
std::cout << result << std::endl;
} while (*buf != '\0');
exit_main_loop:
return 0;
}
void funk2_status(char* filename, int line_num, char* msg, ...) {
va_list args;
if (__funk2_status_disabled) {
return;
}
char temp_msg[2048];
va_start(args, msg);
vsprintf(temp_msg, msg, args);
va_end(args);
funk2_processor_spinlock__lock(&(__funk2.status.trace_mutex));
{
int trace_fd = open("funk2_debug.log", O_CREAT | O_APPEND | O_WRONLY, S_IRWXU | S_IRWXG | S_IRWXO);
if (trace_fd == -1) {
__funk2_status_disabled = boolean__true;
//printf("[WARNING] funk2_status couldn't open funk2_trace.log");
funk2_processor_spinlock__unlock(&(__funk2.status.trace_mutex));
return;
}
pthread_t self_thread = pthread_self();
u64 nanoseconds_since_1970 = raw__nanoseconds_since_1970();
u64 seconds_since_1970 = nanoseconds_since_1970 / nanoseconds_per_second;
u64 minutes_since_1970 = seconds_since_1970 / 60;
u64 hours_since_1970 = minutes_since_1970 / 60;
u64 earth_rotations_since_1970 = hours_since_1970 / 24;
u64 hours = hours_since_1970 - (earth_rotations_since_1970 * 24);
u64 minutes = minutes_since_1970 - (hours_since_1970 * 60);
u64 seconds = seconds_since_1970 - (minutes_since_1970 * 60);
u64 nanoseconds = nanoseconds_since_1970 - (seconds_since_1970 * nanoseconds_per_second);
{
char temp_msg2[2048];
sprintf(temp_msg2, "\n[%-40s %5d] tid=0x" "%-16" x64__fstr_without_percent " 0x%X_%02d_%02d_%02d." nano_decimal_fraction__fstr " funk2 status: %s", filename, line_num, (u64)to_ptr(self_thread), (int)earth_rotations_since_1970, (int)hours, (int)minutes, (int)seconds, (u64)nanoseconds, temp_msg);
size_t size_to_write = strlen(temp_msg2) + 1;
size_t size_written = write(trace_fd, temp_msg2, size_to_write);
if (size_written != size_to_write) {
error_writing_status_message();
}
}
close(trace_fd);
}
funk2_processor_spinlock__unlock(&(__funk2.status.trace_mutex));
}
void verify_access(const WriteXctAccess &access, int i) {
EXPECT_TRUE(access.payload_address_ == reinterpret_cast<char*>(to_ptr(i * 542312)));
EXPECT_EQ(i * 52223ULL, access.storage_id_);
EXPECT_TRUE(access.owner_id_address_ == reinterpret_cast<xct::LockableXctId*>(to_ptr(i * 14325)));
EXPECT_TRUE(access.log_entry_ == to_ptr(i * 5423423));
}
