int bin2hex_process_files( char const* const* input, char const* const* output, int columns )
{
int result = BIN2HEX_RESULT_OK;
unsigned int ifile, files_size;
for( ifile = 0, files_size = array_size( input ); ( result == BIN2HEX_RESULT_OK ) && ( ifile < files_size ); ++ifile )
{
char* input_filename = 0;
char* output_filename = 0;
stream_t* input_file = 0;
stream_t* output_file = 0;
input_filename = path_clean( string_clone( input[ifile] ), path_is_absolute( input[ifile] ) );
error_context_push( "parsing file", input_filename );
output_filename = path_clean( string_clone( output[ifile] ), path_is_absolute( output[ifile] ) );
log_infof( 0, "bin2hex %s -> %s", input_filename, output_filename );
input_file = stream_open( input_filename, STREAM_IN | STREAM_BINARY );
if( !input_file )
{
log_warnf( 0, WARNING_BAD_DATA, "Unable to open input file: %s", input_filename );
result = BIN2HEX_RESULT_MISSING_INPUT_FILE;
}
else
{
output_file = stream_open( output_filename, STREAM_OUT );
if( !output_file )
{
log_warnf( 0, WARNING_BAD_DATA, "Unable to open output file: %s", output_filename );
result = BIN2HEX_RESULT_UNABLE_TO_OPEN_OUTPUT_FILE;
}
}
if( input_file && output_file )
result = bin2hex_process_file( input_file, output_file, columns );
stream_deallocate( input_file );
stream_deallocate( output_file );
string_deallocate( output_filename );
error_context_pop();
string_deallocate( input_filename );
}
if( ( result == BIN2HEX_RESULT_OK ) && ( files_size > 0 ) )
log_info( 0, "All files generated" );
return result;
}
void
process_finalize(process_t* proc) {
if (!(proc->flags & PROCESS_DETACHED))
process_wait(proc);
stream_deallocate(proc->pipeout);
stream_deallocate(proc->pipein);
string_deallocate(proc->wd.str);
string_deallocate(proc->path.str);
string_array_deallocate(proc->args);
#if FOUNDATION_PLATFORM_WINDOWS
string_deallocate(proc->verb.str);
#endif
}
static lua_module_t
lua_module_load_resource(const uuid_t uuid) {
lua_module_t module = {0, 0};
bool success = false;
const uint32_t expected_version = 1;
uint64_t platform = 0;
stream_t* stream;
stream = resource_stream_open_static(uuid, platform);
if (stream) {
resource_header_t header = resource_stream_read_header(stream);
if ((header.type == HASH_LUA) && (header.version == expected_version)) {
success = true;
}
else {
log_warnf(HASH_LUA, WARNING_INVALID_VALUE,
STRING_CONST("Got unexpected type/version when loading Lua module: %" PRIx64 " : %u"),
header.type, header.version);
}
stream_deallocate(stream);
stream = nullptr;
}
if (success)
stream = resource_stream_open_dynamic(uuid, platform);
if (stream) {
uint32_t version = stream_read_uint32(stream);
size_t size = (size_t)stream_read_uint64(stream);
if (version == expected_version) {
void* buffer = memory_allocate(HASH_LUA, size, 0, MEMORY_TEMPORARY);
if (stream_read(stream, buffer, size) == size) {
module.bytecode = buffer;
module.size = size;
}
else {
memory_deallocate(buffer);
}
}
else {
log_warnf(HASH_LUA, WARNING_INVALID_VALUE,
STRING_CONST("Got unexpected type/version when loading Lua module blob: %u"),
version);
}
stream_deallocate(stream);
stream = nullptr;
}
return module;
}
void process_deallocate( process_t* proc )
{
if( !proc )
return;
if( !( proc->flags & PROCESS_DETACHED ) )
process_wait( proc );
stream_deallocate( proc->pipeout );
stream_deallocate( proc->pipein );
string_deallocate( proc->wd );
string_deallocate( proc->path );
string_array_deallocate( proc->args );
#if FOUNDATION_PLATFORM_WINDOWS
string_deallocate( proc->verb );
#endif
memory_deallocate( proc );
}
int
hashify_write_file(stream_t* generated_file, string_t output_filename) {
bool need_update = false;
stream_t* output_file = 0;
int result = HASHIFY_RESULT_OK;
output_file = stream_open(STRING_ARGS(output_filename), STREAM_OUT | STREAM_IN);
if (!output_file) {
need_update = true;
output_file = stream_open(STRING_ARGS(output_filename), STREAM_OUT);
if (!output_file) {
log_warnf(0, WARNING_INVALID_VALUE, STRING_CONST("Unable to open output file: %.*s"),
STRING_FORMAT(output_filename));
return HASHIFY_RESULT_MISSING_OUTPUT_FILE;
}
}
if (!need_update)
need_update = !uint128_equal(stream_md5(generated_file), stream_md5(output_file));
if (need_update) {
char local_buffer[1024];
size_t read = 0;
size_t written = 0;
uint64_t total_written = 0;
stream_seek(generated_file, 0, STREAM_SEEK_BEGIN);
stream_seek(output_file, 0, STREAM_SEEK_BEGIN);
while (!stream_eos(generated_file)) {
read = stream_read(generated_file, local_buffer, 1024);
if (!read)
break;
written = stream_write(output_file, local_buffer, read);
total_written += written;
if (written != read) {
log_errorf(0, ERROR_SYSTEM_CALL_FAIL,
STRING_CONST("Unable to write to output file '%.*s': %" PRIsize " of %" PRIsize " bytes written"),
STRING_FORMAT(output_filename), written, read);
result = HASHIFY_RESULT_OUTPUT_FILE_WRITE_FAIL;
break;
}
}
if (result == HASHIFY_RESULT_OK) {
stream_truncate(output_file, (size_t)total_written);
log_infof(0, STRING_CONST(" wrote %.*s : %" PRIu64 " bytes"), STRING_FORMAT(output_filename),
total_written);
}
}
else {
log_info(0, STRING_CONST(" hash file already up to date"));
}
stream_deallocate(output_file);
return result;
}
static void*
stream_blocking_thread(void* arg) {
int iloop;
socket_t* sock = (socket_t*)arg;
char buffer_out[317] = {0};
char buffer_in[317] = {0};
stream_t* stream = socket_stream(sock);
for (iloop = 0; !thread_try_wait(0) && iloop < 512; ++iloop) {
log_infof(HASH_NETWORK, STRING_CONST("UDP write pass %d"), iloop);
EXPECT_SIZEEQ(stream_write(stream, buffer_out, 127), 127);
EXPECT_SIZEEQ(stream_write(stream, buffer_out + 127, 180), 180);
stream_flush(stream);
EXPECT_SIZEEQ(stream_write(stream, buffer_out + 307, 10), 10);
stream_flush(stream);
log_infof(HASH_NETWORK, STRING_CONST("UDP read pass %d"), iloop);
EXPECT_SIZEEQ(stream_read(stream, buffer_in, 235), 235);
EXPECT_SIZEEQ(stream_read(stream, buffer_in + 235, 82), 82);
thread_yield();
}
log_debugf(HASH_NETWORK, STRING_CONST("IO complete on socket 0x%llx"), sock);
stream_deallocate(stream);
return 0;
}
DECLARE_TEST( fs, util )
{
tick_t systime = time_system();
tick_t lastmod = 0;
char* testpath = path_merge( environment_temporary_directory(), string_from_int_static( random64(), 0, 0 ) );
if( !fs_is_directory( environment_temporary_directory() ) )
fs_make_directory( environment_temporary_directory() );
if( fs_is_directory( testpath ) )
fs_remove_directory( testpath );
fs_remove_file( testpath );
EXPECT_EQ( fs_last_modified( testpath ), 0 );
thread_sleep( 1000 ); //For fs time granularity, make sure at least one second passed since systime
stream_deallocate( fs_open_file( testpath, STREAM_OUT ) );
EXPECT_TRUE( fs_is_file( testpath ) );
EXPECT_GE( fs_last_modified( testpath ), systime );
fs_remove_file( testpath );
EXPECT_FALSE( fs_is_file( testpath ) );
EXPECT_EQ( fs_last_modified( testpath ), 0 );
stream_deallocate( fs_open_file( testpath, STREAM_OUT ) );
EXPECT_TRUE( fs_is_file( testpath ) );
EXPECT_GE( fs_last_modified( testpath ), systime );
lastmod = fs_last_modified( testpath );
thread_sleep( 5000 );
EXPECT_EQ( fs_last_modified( testpath ), lastmod );
fs_touch( testpath );
EXPECT_GT( fs_last_modified( testpath ), lastmod );
fs_remove_file( testpath );
string_deallocate( testpath );
return 0;
}
int
hashify_generate_preamble(stream_t* output_file, string_t output_filename) {
//Read and preserve everything before #pragma once in case it contains header comments to be preserved
char line_buffer[HASHIFY_LINEBUFFER_LENGTH];
size_t capacity = 1024;
string_t preamble = string_allocate(0, capacity);
stream_t* prev_file = stream_open(STRING_ARGS(output_filename), STREAM_IN);
memset(line_buffer, 0, sizeof(line_buffer));
while (prev_file && !stream_eos(prev_file)) {
string_t line;
string_const_t stripped_line;
line = stream_read_line_buffer(prev_file, line_buffer, sizeof(line_buffer), '\n');
stripped_line = string_strip(STRING_ARGS(line), STRING_CONST("\n\r"));
if ((string_find_string(STRING_ARGS(stripped_line), STRING_CONST("pragma"), 0) != STRING_NPOS) &&
(string_find_string(STRING_ARGS(stripped_line), STRING_CONST("once"), 0) != STRING_NPOS))
break;
if (preamble.length + stripped_line.length + 1 >= capacity) {
size_t newcapacity = capacity + 1024 + stripped_line.length;
preamble.str = memory_reallocate(preamble.str, newcapacity, 0, capacity);
capacity = newcapacity;
}
preamble = string_append(STRING_ARGS(preamble), capacity, STRING_ARGS(stripped_line));
if (line.length < sizeof(line_buffer))
preamble = string_append(STRING_ARGS(preamble), capacity, STRING_CONST(STRING_NEWLINE));
}
stream_deallocate(prev_file);
stream_seek(output_file, 0, STREAM_SEEK_BEGIN);
if (preamble.length)
stream_write_string(output_file, STRING_ARGS(preamble));
stream_write_string(output_file, STRING_CONST(
"#pragma once\n\n"
"#include <foundation/hash.h>\n\n"
"/* ****** AUTOMATICALLY GENERATED, DO NOT EDIT ******\n"
" Edit corresponding definitions file and rerun\n"
" the foundation hashify tool to update this file */\n\n"
));
string_deallocate(preamble.str);
return 0;
}
font_t font_create(const char* name)
{
//todo: make this a task
FOUNDATION_ASSERT(fs_is_file(name));
stream_t* ttf_stream = fs_open_file(name, STREAM_IN|STREAM_BINARY);
FOUNDATION_ASSERT(ttf_stream);
const uint64_t ttf_stream_size = stream_size(ttf_stream);
unsigned char* ttf_buffer = (unsigned char*) memory_allocate(ttf_stream_size, 4, MEMORY_TEMPORARY);
unsigned char* ttf_bitmap = (unsigned char*) memory_allocate(MINT_FONT_BITMAPSIZE*MINT_FONT_BITMAPSIZE, 4, MEMORY_PERSISTENT);
const uint64_t read = stream_read(ttf_stream, ttf_buffer, ttf_stream_size);
FOUNDATION_ASSERT(read == ttf_stream_size);
font_data_t data;
stbtt_BakeFontBitmap(
ttf_buffer,0, 32.0,
ttf_bitmap,
MINT_FONT_BITMAPSIZE,
MINT_FONT_BITMAPSIZE,
32,96,
data.cdata
);
TextureCreationInfo info;
info.type = Texture2D;
info.format = FormatR8;
info.width = MINT_FONT_BITMAPSIZE;
info.height = MINT_FONT_BITMAPSIZE;
data.texture = texture_create(ttf_bitmap, info);
array_push_memcpy(s_fontCtx.fonts, &data);
memory_deallocate(ttf_bitmap);
memory_deallocate(ttf_buffer);
stream_deallocate(ttf_stream);
return array_size(s_fontCtx.fonts)-1;
}
DECLARE_TEST( pipe, readwrite )
{
stream_t* pipe = pipe_allocate();
object_t reader = thread_create( read_thread, "reader", THREAD_PRIORITY_NORMAL, 0 );
object_t writer = thread_create( write_thread, "writer", THREAD_PRIORITY_NORMAL, 0 );
thread_start( reader, pipe );
thread_start( writer, pipe );
thread_sleep( 100 );
while( thread_is_running( reader ) || thread_is_running( writer ) )
thread_sleep( 10 );
EXPECT_EQ( thread_result( reader ), 0 );
EXPECT_EQ( thread_result( writer ), 0 );
thread_destroy( reader );
thread_destroy( writer );
stream_deallocate( pipe );
return 0;
}
int
lua_compile(const uuid_t uuid, uint64_t platform, resource_source_t* source,
const uint256_t source_hash, const char* type, size_t type_length) {
int result = 0;
uint64_t* subplatforms = 0;
size_t iplat, psize;
hashmap_fixed_t fixedmap;
hashmap_t* map = (hashmap_t*)&fixedmap;
hash_t resource_type_hash;
resource_type_hash = hash(type, type_length);
if (resource_type_hash != HASH_LUA)
return -1;
array_push(subplatforms, platform);
hashmap_initialize(map, sizeof(fixedmap.bucket) / sizeof(fixedmap.bucket[0]), 8);
resource_source_map_all(source, map, false);
resource_source_map_reduce(source, map, &subplatforms, resource_source_platform_reduce);
resource_source_map_clear(map);
for (iplat = 1, psize = array_size(subplatforms); (iplat != psize) && (result == 0); ++iplat) {
void* compiled_blob = 0;
size_t compiled_size = 0;
stream_t* stream;
uint64_t subplatform = subplatforms[iplat];
resource_change_t* sourcechange = resource_source_get(source, HASH_SOURCE, subplatform);
if (sourcechange && (sourcechange->flags & RESOURCE_SOURCEFLAG_BLOB)) {
compiled_size = sourcechange->value.blob.size;
compiled_blob = memory_allocate(HASH_RESOURCE, compiled_size, 0, MEMORY_PERSISTENT);
if (!resource_source_read_blob(uuid, HASH_SOURCE, subplatform, sourcechange->value.blob.checksum,
compiled_blob, compiled_size)) {
memory_deallocate(compiled_blob);
compiled_blob = 0;
compiled_size = 0;
}
}
if (compiled_size <= 0)
continue;
stream = resource_local_create_static(uuid, subplatform);
if (stream) {
const uint32_t version = 1;
resource_header_t header = {
.type = resource_type_hash,
.version = version,
.source_hash = source_hash
};
resource_stream_write_header(stream, header);
stream_deallocate(stream);
if (compiled_size > 0) {
stream = resource_local_create_dynamic(uuid, subplatform);
if (stream) {
stream_write_uint32(stream, version);
stream_write_uint64(stream, compiled_size);
stream_write(stream, compiled_blob, compiled_size);
stream_deallocate(stream);
}
else {
log_errorf(HASH_RESOURCE, ERROR_SYSTEM_CALL_FAIL,
STRING_CONST("Unable to create dynamic resource stream"));
result = -1;
}
}
}
else {
log_errorf(HASH_RESOURCE, ERROR_SYSTEM_CALL_FAIL,
STRING_CONST("Unable to create static resource stream"));
result = -1;
}
memory_deallocate(compiled_blob);
}
DECLARE_TEST(profile, stream) {
thread_t thread[32];
int ith;
uint64_t frame;
string_t filename;
error(); //Clear error
filename = path_allocate_concat(STRING_ARGS(environment_temporary_directory()),
STRING_CONST("test.profile"));
//log_infof(HASH_TEST, STRING_CONST("Output to profile file: %.*s"), STRING_FORMAT(filename));
fs_make_directory(STRING_ARGS(environment_temporary_directory()));
_profile_stream = fs_open_file(STRING_ARGS(filename), STREAM_OUT | STREAM_BINARY);
string_deallocate(filename.str);
profile_initialize(STRING_CONST("test_profile"), _test_profile_buffer, TEST_PROFILE_BUFFER_SIZE);
profile_set_output(_profile_file_writer);
profile_set_output_wait(10);
profile_enable(true);
for (ith = 0; ith < 32; ++ith)
thread_initialize(&thread[ith], _profile_stream_thread, 0, STRING_CONST("profile_thread"),
THREAD_PRIORITY_NORMAL, 0);
for (ith = 0; ith < 32; ++ith)
thread_start(&thread[ith]);
test_wait_for_threads_startup(thread, 32);
for (frame = 0; frame < 1000; ++frame) {
thread_sleep(16);
profile_log(
STRING_CONST("This is a really long profile log line that should break into multiple profile blocks automatically without causing any issues whatsoever if everything works as expected which it should or the code needs to be fixed"));
profile_end_frame(frame++);
if ((frame % 30) == 0) {
profile_enable(false);
thread_sleep(10);
profile_enable(true);
}
}
for (ith = 0; ith < 32; ++ith)
thread_signal(&thread[ith]);
test_wait_for_threads_finish(thread, 32);
for (ith = 0; ith < 32; ++ith)
thread_finalize(&thread[ith]);
profile_end_frame(frame++);
profile_set_output_wait(10000);
thread_sleep(1000);
profile_begin_block(STRING_CONST("Should be cleaned up"));
profile_end_block();
profile_enable(false);
profile_finalize();
error();
stream_deallocate(_profile_stream);
//TODO: Validate that output is sane
log_debugf(HASH_TEST, STRING_CONST("Generated %" PRId64 " blocks"),
atomic_load64(&_profile_generated_blocks));
return 0;
}
DECLARE_TEST( fs, file )
{
char* testpath = path_merge( environment_temporary_directory(), string_from_int_static( random64(), 0, 0 ) );
char* copypath = path_merge( environment_temporary_directory(), string_from_int_static( random64(), 0, 0 ) );
stream_t* teststream = 0;
if( !fs_is_directory( environment_temporary_directory() ) )
fs_make_directory( environment_temporary_directory() );
if( fs_is_directory( testpath ) )
fs_remove_directory( testpath );
fs_remove_file( testpath );
if( fs_is_directory( copypath ) )
fs_remove_directory( copypath );
fs_remove_file( copypath );
teststream = fs_open_file( testpath, STREAM_IN );
EXPECT_EQ( teststream, 0 );
EXPECT_FALSE( fs_is_file( testpath ) );
teststream = fs_open_file( testpath, STREAM_IN | STREAM_OUT );
EXPECT_NE( teststream, 0 );
EXPECT_TRUE( fs_is_file( testpath ) );
stream_deallocate( teststream );
fs_remove_file( testpath );
teststream = fs_open_file( testpath, STREAM_IN );
EXPECT_EQ( teststream, 0 );
EXPECT_FALSE( fs_is_file( testpath ) );
teststream = fs_open_file( testpath, STREAM_OUT );
EXPECT_NE( teststream, 0 );
EXPECT_TRUE( fs_is_file( testpath ) );
stream_deallocate( teststream );
teststream = 0;
fs_copy_file( testpath, copypath );
EXPECT_TRUE( fs_is_file( copypath ) );
fs_remove_file( copypath );
EXPECT_FALSE( fs_is_file( copypath ) );
teststream = fs_open_file( testpath, STREAM_OUT );
EXPECT_NE( teststream, 0 );
EXPECT_TRUE( fs_is_file( testpath ) );
stream_write_string( teststream, "testing testing" );
stream_deallocate( teststream );
teststream = 0;
fs_copy_file( testpath, copypath );
EXPECT_TRUE( fs_is_file( copypath ) );
fs_remove_file( copypath );
EXPECT_FALSE( fs_is_file( copypath ) );
stream_deallocate( teststream );
string_deallocate( testpath );
string_deallocate( copypath );
return 0;
}
DECLARE_TEST( fs, monitor )
{
char* testpath = path_merge( environment_temporary_directory(), string_from_int_static( random64(), 0, 0 ) );
char* filetestpath = path_merge( testpath, string_from_int_static( random64(), 0, 0 ) );
stream_t* test_stream;
event_stream_t* stream;
event_block_t* block;
event_t* event;
stream = fs_event_stream();
if( fs_is_file( testpath ) )
fs_remove_file( testpath );
if( !fs_is_directory( testpath ) )
fs_make_directory( testpath );
if( fs_is_file( filetestpath ) )
fs_remove_file( filetestpath );
stream_deallocate( fs_open_file( filetestpath, STREAM_OUT ) );
fs_remove_file( filetestpath );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_EQ( event, 0 );
fs_monitor( testpath );
thread_sleep( 1000 );
stream_deallocate( fs_open_file( filetestpath, STREAM_OUT ) );
thread_sleep( 100 );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_NE( event, 0 );
EXPECT_EQ( event->system, SYSTEM_FOUNDATION );
EXPECT_EQ( event->id, FOUNDATIONEVENT_FILE_CREATED );
EXPECT_STREQ( event->payload, filetestpath );
event = event_next( block, event );
EXPECT_EQ( event, 0 );
test_stream = fs_open_file( filetestpath, STREAM_IN | STREAM_OUT );
stream_write_string( test_stream, filetestpath );
stream_deallocate( test_stream );
thread_sleep( 100 );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_NE( event, 0 );
EXPECT_EQ( event->system, SYSTEM_FOUNDATION );
EXPECT_EQ( event->id, FOUNDATIONEVENT_FILE_MODIFIED );
EXPECT_STREQ( event->payload, filetestpath );
event = event_next( block, event );
EXPECT_EQ( event, 0 );
fs_remove_file( filetestpath );
thread_sleep( 100 );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_NE( event, 0 );
EXPECT_EQ( event->system, SYSTEM_FOUNDATION );
EXPECT_EQ( event->id, FOUNDATIONEVENT_FILE_DELETED );
EXPECT_STREQ( event->payload, filetestpath );
event = event_next( block, event );
EXPECT_EQ( event, 0 );
fs_unmonitor( testpath );
thread_sleep( 1000 );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_EQ( event, 0 );
stream_deallocate( fs_open_file( filetestpath, STREAM_OUT ) );
thread_sleep( 100 );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_EQ( event, 0 );
fs_remove_file( filetestpath );
thread_sleep( 100 );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_EQ( event, 0 );
fs_remove_directory( testpath );
string_deallocate( testpath );
string_deallocate( filetestpath );
return 0;
}
DECLARE_TEST( fs, query )
{
uint64_t subpathid = random64();
uint64_t subfileid = random64();
char* testpath = path_merge( environment_temporary_directory(), string_from_int_static( random64(), 0, 0 ) );
char* subtestpath = path_merge( testpath, string_from_int_static( subpathid, 0, 0 ) );
char* filepath[8];
char** subdirs;
char** files;
int ifp = 0;
char* subfilepath;
if( fs_is_file( testpath ) )
fs_remove_file( testpath );
if( !fs_is_directory( testpath ) )
fs_make_directory( testpath );
if( !fs_is_directory( subtestpath ) )
fs_make_directory( subtestpath );
for( ifp = 0; ifp < 8; ++ifp )
{
filepath[ifp] = path_merge( testpath, string_from_int_static( random64(), 0, 0 ) );
filepath[ifp] = string_append( string_append( filepath[ifp], "." ), string_from_int_static( ifp, 0, 0 ) );
stream_deallocate( fs_open_file( filepath[ifp], STREAM_OUT ) );
}
subfilepath = path_merge( subtestpath, string_from_int_static( subfileid, 0, 0 ) );
subfilepath = string_append( subfilepath, ".0" );
stream_deallocate( fs_open_file( subfilepath, STREAM_OUT ) );
files = fs_files( filepath[0] );
EXPECT_EQ( array_size( files ), 0 );
string_array_deallocate( files );
subdirs = fs_subdirs( subtestpath );
EXPECT_EQ( array_size( subdirs ), 0 );
string_array_deallocate( subdirs );
files = fs_files( testpath );
EXPECT_EQ( array_size( files ), 8 );
string_array_deallocate( files );
subdirs = fs_subdirs( testpath );
EXPECT_EQ( array_size( subdirs ), 1 );
string_array_deallocate( subdirs );
files = fs_matching_files( testpath, "*", false );
EXPECT_EQ( array_size( files ), 8 );
string_array_deallocate( files );
files = fs_matching_files( testpath, "*", true );
EXPECT_EQ( array_size( files ), 9 );
string_array_deallocate( files );
files = fs_matching_files( testpath, "*.0", false );
EXPECT_EQ( array_size( files ), 1 );
string_array_deallocate( files );
files = fs_matching_files( testpath, "*.0", true );
EXPECT_EQ( array_size( files ), 2 );
string_array_deallocate( files );
files = fs_matching_files( testpath, "*.1", false );
EXPECT_EQ( array_size( files ), 1 );
string_array_deallocate( files );
files = fs_matching_files( testpath, "*.1", true );
EXPECT_EQ( array_size( files ), 1 );
string_array_deallocate( files );
files = fs_matching_files( testpath, "*.?", true );
EXPECT_EQ( array_size( files ), 9 );
{
char* verifypath = string_from_int( subpathid, 0, 0 );
verifypath = path_append( verifypath, string_from_int_static( subfileid, 0, 0 ) );
verifypath = string_append( verifypath, ".0" );
EXPECT_STREQ( files[8], verifypath );
string_deallocate( verifypath );
}
string_array_deallocate( files );
fs_remove_directory( testpath );
string_array_deallocate( subdirs );
string_array_deallocate( files );
string_deallocate( subfilepath );
for( ifp = 0; ifp < 8; ++ifp )
string_deallocate( filepath[ifp] );
string_deallocate( subtestpath );
string_deallocate( testpath );
return 0;
}
int
hashify_process_files(string_t* files, bool check_only) {
int result = HASHIFY_RESULT_OK;
hashify_string_t* history = 0;
size_t ifile, files_size;
for (ifile = 0, files_size = array_size(files); (result == HASHIFY_RESULT_OK) &&
(ifile < files_size); ++ifile) {
string_t input_filename;
string_t output_filename;
string_const_t base_filename;
stream_t* input_file;
stream_t* output_file;
input_filename = string_allocate(0, BUILD_MAX_PATHLEN);
input_filename = string_copy(input_filename.str, BUILD_MAX_PATHLEN, STRING_ARGS(files[ifile]));
input_filename = path_clean(STRING_ARGS(input_filename), BUILD_MAX_PATHLEN);
error_context_push(STRING_CONST("parsing file"), STRING_ARGS(input_filename));
base_filename = path_base_file_name_with_directory(STRING_ARGS(input_filename));
output_filename = string_allocate_format(STRING_CONST("%.*s.h"), STRING_FORMAT(base_filename));
log_infof(0, STRING_CONST("Hashifying %.*s -> %.*s"), STRING_FORMAT(input_filename),
STRING_FORMAT(output_filename));
input_file = stream_open(STRING_ARGS(input_filename), STREAM_IN);
//If only validating, open the final output file. If generating, make a memory buffer as intermediate storage
if (check_only)
output_file = stream_open(STRING_ARGS(output_filename), STREAM_IN);
else
output_file = buffer_stream_allocate(memory_allocate(0, 65536, 0, MEMORY_PERSISTENT),
STREAM_IN | STREAM_OUT, 0, 65536, true, true);
if (!input_file) {
log_warnf(0, WARNING_INVALID_VALUE, STRING_CONST("Unable to open input file: %.*s"),
STRING_FORMAT(input_filename));
result = HASHIFY_RESULT_MISSING_INPUT_FILE;
}
else if (!output_file) {
log_warnf(0, WARNING_INVALID_VALUE, STRING_CONST("Unable to open output file: %.*s"),
STRING_FORMAT(output_filename));
result = HASHIFY_RESULT_MISSING_OUTPUT_FILE;
}
if (input_file && output_file) {
result = hashify_process_file(input_file, output_file, output_filename, check_only, &history);
if ((result == HASHIFY_RESULT_OK) && !check_only)
result = hashify_write_file(output_file, output_filename);
}
stream_deallocate(input_file);
stream_deallocate(output_file);
error_context_pop();
string_deallocate(input_filename.str);
string_deallocate(output_filename.str);
}
if ((result == HASHIFY_RESULT_OK) && (files_size > 0)) {
if (check_only)
log_info(0, STRING_CONST("All hashes validated"));
else
log_info(0, STRING_CONST("All hashes generated"));
}
array_deallocate(history);
return result;
}
void config_load( const char* name, hash_t filter_section, bool built_in, bool overwrite )
{
/*lint --e{838} Safety null assign all pointers for all preprocessor paths */
/*lint --e{750} Unused macros in some paths */
#define NUM_SEARCH_PATHS 10
#define ANDROID_ASSET_PATH_INDEX 5
char* sub_exe_path = 0;
char* exe_parent_path = 0;
char* exe_processed_path = 0;
char* abs_exe_parent_path = 0;
char* abs_exe_processed_path = 0;
char* bundle_path = 0;
char* home_dir = 0;
char* cmdline_path = 0;
char* cwd_config_path = 0;
const char* paths[NUM_SEARCH_PATHS];
#if !FOUNDATION_PLATFORM_FAMILY_MOBILE
const char* const* cmd_line;
int icl, clsize;
#endif
int start_path, i, j;
const char buildsuffix[4][9] = { "/debug", "/release", "/profile", "/deploy" };
const char platformsuffix[7][14] = { "/win32", "/win64", "/osx", "/ios", "/android", "/raspberrypi", "/unknown" };
const char binsuffix[1][5] = { "/bin" };
FOUNDATION_ASSERT( name );
sub_exe_path = path_merge( environment_executable_directory(), "config" );
exe_parent_path = path_merge( environment_executable_directory(), "../config" );
abs_exe_parent_path = path_make_absolute( exe_parent_path );
exe_processed_path = string_clone( environment_executable_directory() );
for( i = 0; i < 4; ++i )
{
if( string_ends_with( exe_processed_path, buildsuffix[i] ) )
{
exe_processed_path[ string_length( exe_processed_path ) - string_length( buildsuffix[i] ) ] = 0;
break;
}
}
for( i = 0; i < 7; ++i )
{
if( string_ends_with( exe_processed_path, platformsuffix[i] ) )
{
exe_processed_path[ string_length( exe_processed_path ) - string_length( platformsuffix[i] ) ] = 0;
break;
}
}
for( i = 0; i < 1; ++i )
{
if( string_ends_with( exe_processed_path, binsuffix[i] ) )
{
exe_processed_path[ string_length( exe_processed_path ) - string_length( binsuffix[i] ) ] = 0;
break;
}
}
exe_processed_path = path_append( exe_processed_path, "config" );
abs_exe_processed_path = path_make_absolute( exe_processed_path );
paths[0] = environment_executable_directory();
paths[1] = sub_exe_path;
paths[2] = abs_exe_parent_path;
paths[3] = abs_exe_processed_path;
#if FOUNDATION_PLATFORM_FAMILY_DESKTOP && !BUILD_DEPLOY
paths[4] = environment_initial_working_directory();
#else
paths[4] = 0;
#endif
#if FOUNDATION_PLATFORM_APPLE
bundle_path = path_merge( environment_executable_directory(), "../Resources/config" );
paths[5] = bundle_path;
#elif FOUNDATION_PLATFORM_ANDROID
paths[5] = "/config";
#else
paths[5] = 0;
#endif
#if FOUNDATION_PLATFORM_FAMILY_DESKTOP
paths[6] = environment_current_working_directory();
#else
paths[6] = 0;
#endif
paths[7] = 0;
paths[8] = 0;
string_deallocate( exe_parent_path );
string_deallocate( exe_processed_path );
#if FOUNDATION_PLATFORM_FAMILY_DESKTOP
cwd_config_path = path_merge( environment_current_working_directory(), "config" );
paths[7] = cwd_config_path;
cmd_line = environment_command_line();
/*lint -e{850} We modify loop var to skip extra arg */
for( icl = 0, clsize = array_size( cmd_line ); icl < clsize; ++icl )
{
/*lint -e{613} array_size( cmd_line ) in loop condition does the null pointer guard */
if( string_equal_substr( cmd_line[icl], "--configdir", 11 ) )
{
if( string_equal_substr( cmd_line[icl], "--configdir=", 12 ) )
{
paths[8] = cmdline_path = string_substr( cmd_line[icl], 12, STRING_NPOS );
}
else if( icl < ( clsize - 1 ) )
{
paths[8] = cmdline_path = string_clone( cmd_line[++icl] );
}
}
}
#endif
start_path = 0;
if( !built_in )
{
#if FOUNDATION_PLATFORM_WINDOWS
home_dir = path_merge( environment_home_directory(), environment_application()->config_dir );
#elif FOUNDATION_PLATFORM_LINUX || FOUNDATION_PLATFORM_MACOSX
home_dir = path_prepend( string_concat( ".", environment_application()->config_dir ), environment_home_directory() );
#endif
if( home_dir )
paths[9] = home_dir;
start_path = 9;
}
else
{
paths[9] = 0;
}
for( i = start_path; i < NUM_SEARCH_PATHS; ++i )
{
char* filename;
stream_t* istream;
bool path_already_searched = false;
if( !paths[i] )
continue;
for( j = start_path; j < i; ++j )
{
if( paths[j] && string_equal( paths[j], paths[i] ) )
{
path_already_searched = true;
break;
}
}
if( path_already_searched )
continue;
//TODO: Support loading configs from virtual file system (i.e in zip/other packages)
filename = string_append( path_merge( paths[i], name ), ".ini" );
istream = 0;
#if FOUNDATION_PLATFORM_ANDROID
if( i == ANDROID_ASSET_PATH_INDEX )
istream = asset_stream_open( filename, STREAM_IN );
else
#endif
istream = stream_open( filename, STREAM_IN );
if( istream )
{
config_parse( istream, filter_section, overwrite );
stream_deallocate( istream );
}
string_deallocate( filename );
if( built_in )
{
const char* FOUNDATION_PLATFORM_name =
#if FOUNDATION_PLATFORM_WINDOWS
"windows";
#elif FOUNDATION_PLATFORM_LINUX_RASPBERRYPI
"raspberrypi";
#elif FOUNDATION_PLATFORM_LINUX
"linux";
#elif FOUNDATION_PLATFORM_MACOSX
"osx";
#elif FOUNDATION_PLATFORM_IOS
"ios";
#elif FOUNDATION_PLATFORM_ANDROID
"android";
#else
# error Insert platform name
"unknown";
#endif
filename = string_append( path_append( path_merge( paths[i], FOUNDATION_PLATFORM_name ), name ), ".ini" );
#if FOUNDATION_PLATFORM_ANDROID
if( i == ANDROID_ASSET_PATH_INDEX )
istream = asset_stream_open( filename, STREAM_IN );
else
#endif
istream = stream_open( filename, STREAM_IN );
if( istream )
{
config_parse( istream, filter_section, overwrite );
stream_deallocate( istream );
}
string_deallocate( filename );
}
}
string_deallocate( home_dir );
string_deallocate( cmdline_path );
string_deallocate( sub_exe_path );
string_deallocate( abs_exe_processed_path );
string_deallocate( abs_exe_parent_path );
string_deallocate( bundle_path );
string_deallocate( cwd_config_path );
}
int hashify_process_files( const char* const* files, bool check_only )
{
int result = HASHIFY_RESULT_OK;
hashify_string_t* history = 0;
unsigned int ifile, files_size;
for( ifile = 0, files_size = array_size( files ); ( result == HASHIFY_RESULT_OK ) && ( ifile < files_size ); ++ifile )
{
char* input_filename;
char* output_filename;
stream_t* input_file;
stream_t* output_file;
input_filename = path_clean( string_clone( files[ifile] ), path_is_absolute( files[ifile] ) );
error_context_push( "parsing file", input_filename );
output_filename = string_append( path_base_file_name_with_path( input_filename ), ".h" );
log_infof( "Hashifying %s -> %s", input_filename, output_filename );
input_file = stream_open( input_filename, STREAM_IN );
//If only validating, open the final output file. If generating, make a memory buffer as intermediate storage
if( check_only )
output_file = stream_open( output_filename, STREAM_IN );
else
output_file = buffer_stream_allocate( memory_allocate( 65536, 0, MEMORY_PERSISTENT ), STREAM_IN | STREAM_OUT, 0, 65536, true, true );
if( !input_file )
{
log_warnf( WARNING_BAD_DATA, "Unable to open input file: %s", input_filename );
result = HASHIFY_RESULT_MISSING_INPUT_FILE;
}
else if( !output_file )
{
log_warnf( WARNING_BAD_DATA, "Unable to open output file: %s", output_filename );
result = HASHIFY_RESULT_MISSING_OUTPUT_FILE;
}
if( input_file && output_file )
{
result = hashify_process_file( input_file, output_file, check_only, &history );
if( ( result == HASHIFY_RESULT_OK ) && !check_only )
result = hashify_write_file( output_file, output_filename );
}
stream_deallocate( input_file );
stream_deallocate( output_file );
error_context_pop();
string_deallocate( input_filename );
string_deallocate( output_filename );
}
if( ( result == HASHIFY_RESULT_OK ) && ( files_size > 0 ) )
{
if( check_only )
log_infof( "All hashes validated" );
else
log_infof( "All hashes generated" );
}
array_deallocate( history );
return result;
}
int
process_spawn(process_t* proc) {
static const string_const_t unescaped = { STRING_CONST("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.:/\\") };
size_t i, num_args;
size_t size;
#if FOUNDATION_PLATFORM_WINDOWS
wchar_t* wcmdline;
wchar_t* wwd;
string_t cmdline;
#endif
#if !FOUNDATION_PLATFORM_POSIX
size_t capacity;
#endif
proc->code = PROCESS_INVALID_ARGS;
if (!proc->path.length)
return proc->code;
//Always escape path on Windows platforms
#if FOUNDATION_PLATFORM_POSIX
if (string_find_first_not_of(STRING_ARGS(proc->path), STRING_ARGS(unescaped), 0) != STRING_NPOS)
#endif
{
bool preesc = (proc->path.str[0] != '"');
bool postesc = (proc->path.str[ proc->path.length - 1 ] != '"');
if (preesc || postesc) {
char* buffer = memory_allocate(HASH_STRING, proc->path.length + 4, 0, MEMORY_PERSISTENT);
string_t pathesc = string_concat_varg(buffer, proc->path.length + 4,
"\"", (size_t)(preesc ? 1 : 0),
STRING_ARGS(proc->path),
"\"", (size_t)(postesc ? 1 : 0),
nullptr);
string_deallocate(proc->path.str);
proc->path = pathesc;
}
}
size = array_size(proc->args);
for (i = 0, num_args = 0; i < size; ++i) {
string_t arg = proc->args[i];
if (!arg.length)
continue;
++num_args;
#if !FOUNDATION_PLATFORM_POSIX
if (string_find_first_not_of(arg.str, arg.length,
unescaped.str, unescaped.length, 0) != STRING_NPOS) {
if (arg.str[0] != '"') {
//Check if we need to escape " characters
string_t escarg;
size_t pos = string_find(arg.str, arg.length, '"', 0);
while (pos != STRING_NPOS) {
if (arg.str[ pos - 1 ] != '\\') {
string_const_t right = string_substr(STRING_ARGS(arg), 0, pos);
string_const_t left = string_substr(STRING_ARGS(arg), pos, STRING_NPOS);
capacity = arg.length + 2;
escarg = string_allocate(0, capacity);
escarg = string_concat(escarg.str, capacity, STRING_ARGS(right), STRING_CONST("\\"));
escarg = string_append(STRING_ARGS(escarg), capacity, STRING_ARGS(left));
string_deallocate(arg.str);
arg = escarg;
}
pos = string_find(STRING_ARGS(arg), '"', pos + 2);
}
escarg = string_allocate_concat_varg(STRING_CONST("\""), STRING_ARGS(arg),
STRING_CONST("\""), nullptr);
string_deallocate(arg.str);
proc->args[i] = escarg;
}
}
#endif
}
#if FOUNDATION_PLATFORM_WINDOWS
# ifndef SEE_MASK_NOASYNC
# define SEE_MASK_NOASYNC 0x00000100
# endif
capacity = BUILD_MAX_PATHLEN;
cmdline = string_allocate(0, capacity);
//Don't prepend exe path to parameters if using ShellExecute
if (!(proc->flags & PROCESS_WINDOWS_USE_SHELLEXECUTE))
cmdline = string_copy(cmdline.str, capacity, STRING_ARGS(proc->path));
//Build command line string
for (i = 0; i < size; ++i) {
string_t arg = proc->args[i];
if (!arg.length)
continue;
if (cmdline.length + arg.length + 2 >= capacity) {
string_t newline;
capacity *= 2;
newline = string_allocate(0, capacity);
newline = string_copy(newline.str, capacity, STRING_ARGS(cmdline));
}
if (cmdline.length)
cmdline = string_append(STRING_ARGS(cmdline), capacity, STRING_CONST(" "));
cmdline = string_append(STRING_ARGS(cmdline), capacity, STRING_ARGS(arg));
}
if (!proc->wd.length)
proc->wd = string_clone(STRING_ARGS(environment_current_working_directory()));
wcmdline = wstring_allocate_from_string(STRING_ARGS(cmdline));
wwd = wstring_allocate_from_string(STRING_ARGS(proc->wd));
if (proc->flags & PROCESS_WINDOWS_USE_SHELLEXECUTE) {
SHELLEXECUTEINFOW sei;
wchar_t* wverb;
wchar_t* wpath;
wverb = (proc->verb.length ? wstring_allocate_from_string(STRING_ARGS(proc->verb)) : 0);
wpath = wstring_allocate_from_string(STRING_ARGS(proc->path));
ZeroMemory(&sei, sizeof(sei));
sei.cbSize = sizeof(SHELLEXECUTEINFOW);
sei.hwnd = 0;
sei.fMask = SEE_MASK_NOASYNC | SEE_MASK_FLAG_NO_UI | SEE_MASK_NOCLOSEPROCESS;
sei.lpVerb = wverb;
sei.lpFile = wpath;
sei.lpParameters = wcmdline;
sei.lpDirectory = wwd;
sei.nShow = SW_SHOWNORMAL;
if (!(proc->flags & PROCESS_CONSOLE))
sei.fMask |= SEE_MASK_NO_CONSOLE;
if (proc->flags & PROCESS_STDSTREAMS)
log_warn(0, WARNING_UNSUPPORTED, STRING_CONST("Unable to redirect standard in/out"
" through pipes when using ShellExecute for process spawning"));
log_debugf(0, STRING_CONST("Spawn process (ShellExecute): %.*s %.*s"),
STRING_FORMAT(proc->path), STRING_FORMAT(cmdline));
if (!ShellExecuteExW(&sei)) {
string_const_t errstr = system_error_message(0);
log_warnf(0, WARNING_SYSTEM_CALL_FAIL,
STRING_CONST("Unable to spawn process (ShellExecute) for executable '%.*s': %s"),
STRING_FORMAT(proc->path), STRING_FORMAT(errstr));
}
else {
proc->hp = sei.hProcess;
proc->ht = 0;
proc->code = 0;
}
wstring_deallocate(wverb);
wstring_deallocate(wpath);
}
else {
STARTUPINFOW si;
PROCESS_INFORMATION pi;
BOOL inherit_handles = FALSE;
memset(&si, 0, sizeof(si));
memset(&pi, 0, sizeof(pi));
si.cb = sizeof(si);
if (proc->flags & PROCESS_STDSTREAMS) {
proc->pipeout = pipe_allocate();
proc->pipein = pipe_allocate();
si.dwFlags |= STARTF_USESTDHANDLES;
si.hStdOutput = pipe_write_handle(proc->pipeout);
si.hStdInput = pipe_read_handle(proc->pipein);
si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
//Don't inherit wrong ends of pipes
SetHandleInformation(pipe_read_handle(proc->pipeout), HANDLE_FLAG_INHERIT, 0);
SetHandleInformation(pipe_write_handle(proc->pipein), HANDLE_FLAG_INHERIT, 0);
inherit_handles = TRUE;
}
log_debugf(0, STRING_CONST("Spawn process (CreateProcess): %.*s %.*s"),
STRING_FORMAT(proc->path), STRING_FORMAT(cmdline));
if (!CreateProcessW(0, wcmdline, 0, 0, inherit_handles,
(proc->flags & PROCESS_CONSOLE) ? CREATE_NEW_CONSOLE : 0, 0, wwd, &si, &pi)) {
string_const_t errstr = system_error_message(0);
log_warnf(0, WARNING_SYSTEM_CALL_FAIL,
STRING_CONST("Unable to spawn process (CreateProcess) for executable '%.*s': %.*s"),
STRING_FORMAT(proc->path), STRING_FORMAT(errstr));
stream_deallocate(proc->pipeout);
stream_deallocate(proc->pipein);
proc->pipeout = 0;
proc->pipein = 0;
}
else {
proc->hp = pi.hProcess;
proc->ht = pi.hThread;
proc->code = 0;
}
if (proc->pipeout)
pipe_close_write(proc->pipeout);
if (proc->pipein)
pipe_close_read(proc->pipein);
}
wstring_deallocate(wcmdline);
wstring_deallocate(wwd);
string_deallocate(cmdline.str);
if (proc->code < 0)
return proc->code; //Error
#endif
#if FOUNDATION_PLATFORM_MACOSX
if (proc->flags & PROCESS_MACOSX_USE_OPENAPPLICATION) {
proc->pid = 0;
LSApplicationParameters params;
ProcessSerialNumber psn;
FSRef* fsref = memory_allocate(0, sizeof(FSRef), 0, MEMORY_TEMPORARY | MEMORY_ZERO_INITIALIZED);
memset(¶ms, 0, sizeof(LSApplicationParameters));
memset(&psn, 0, sizeof(ProcessSerialNumber));
string_const_t pathstripped = string_strip(proc->path.str, proc->path.length, STRING_CONST("\""));
size_t localcap = pathstripped.length + 5;
string_t localpath = string_allocate(0, localcap - 1);
localpath = string_copy(localpath.str, localcap,
STRING_ARGS(pathstripped)); //Need it zero terminated
OSStatus status = 0;
status = FSPathMakeRef((uint8_t*)localpath.str, fsref, 0);
if (status < 0) {
localpath = string_append(localpath.str, localpath.length, localcap, STRING_CONST(".app"));
status = FSPathMakeRef((uint8_t*)localpath.str, fsref, 0);
}
CFStringRef* args = 0;
for (i = 0, size = array_size(proc->args); i < size;
++i) //App gets executable path automatically, don't include
array_push(args, CFStringCreateWithCString(0, proc->args[i].str, kCFStringEncodingUTF8));
CFArrayRef argvref = CFArrayCreate(0, (const void**)args, (CFIndex)array_size(args), 0);
params.flags = kLSLaunchDefaults;
params.application = fsref;
params.argv = argvref;
log_debugf(0, STRING_CONST("Spawn process (LSOpenApplication): %.*s"), STRING_FORMAT(localpath));
status = LSOpenApplication(¶ms, &psn);
if (status != 0) {
int err = status;
string_const_t errmsg = system_error_message(err);
proc->code = status;
log_errorf(0, ERROR_SYSTEM_CALL_FAIL,
STRING_CONST("Unable to spawn process for executable '%.*s': %.*s (%d)"),
STRING_FORMAT(localpath), STRING_FORMAT(errmsg), err);
}
CFRelease(argvref);
for (i = 0, size = array_size(args); i < size; ++i)
CFRelease(args[i]);
array_deallocate(args);
memory_deallocate(fsref);
string_deallocate(localpath.str);
if (status == 0) {
pid_t pid = 0;
GetProcessPID(&psn, &pid);
proc->pid = pid;
//Always "detached" with LSOpenApplication, not a child process at all
//Setup a kqueue to watch when process terminates so we can emulate a wait
proc->kq = kqueue();
if (proc->kq < 0) {
string_const_t errmsg = system_error_message(proc->kq);
log_errorf(0, ERROR_SYSTEM_CALL_FAIL,
STRING_CONST("Unable to create kqueue for process watch: %.*s (%d)"),
STRING_FORMAT(errmsg), proc->kq);
proc->kq = 0;
}
else {
struct kevent changes;
EV_SET(&changes, (pid_t)pid, EVFILT_PROC, EV_ADD | EV_RECEIPT, NOTE_EXIT, 0, 0);
int ret = kevent(proc->kq, &changes, 1, &changes, 1, 0);
if (ret != 1) {
int err = errno;
string_const_t errmsg = system_error_message(err);
log_errorf(0, ERROR_SYSTEM_CALL_FAIL,
STRING_CONST("Unable to setup kqueue for process watch, failed to add event to kqueue: %.*s (%d)"),
STRING_FORMAT(errmsg), err);
close(proc->kq);
proc->kq = 0;
}
}
}
goto exit;
}
#endif
#if FOUNDATION_PLATFORM_POSIX
//Insert executable arg at start and null ptr at end
size_t arg;
size_t argc = array_size(proc->args) + 1;
array_grow(proc->args, 2);
for (arg = argc - 1; arg > 0; --arg)
proc->args[arg] = proc->args[arg - 1];
proc->args[0] = string_clone(STRING_ARGS(proc->path));
proc->args[argc] = (string_t) { 0, 0 };
char** argv = memory_allocate(0, sizeof(char*) * (argc + 1), 0, MEMORY_PERSISTENT);
for (arg = 0; arg < argc; ++arg)
argv[arg] = proc->args[arg].str;
argv[argc] = 0;
if (proc->flags & PROCESS_STDSTREAMS) {
proc->pipeout = pipe_allocate();
proc->pipein = pipe_allocate();
}
proc->pid = 0;
pid_t pid = fork();
if (pid == 0) {
//Child
if (proc->wd.length) {
log_debugf(0, STRING_CONST("Spawned child process, setting working directory to %.*s"),
STRING_FORMAT(proc->wd));
environment_set_current_working_directory(STRING_ARGS(proc->wd));
}
log_debugf(0, STRING_CONST("Child process executing: %.*s"), STRING_FORMAT(proc->path));
if (proc->flags & PROCESS_STDSTREAMS) {
pipe_close_read(proc->pipeout);
dup2(pipe_write_handle(proc->pipeout), STDOUT_FILENO);
pipe_close_write(proc->pipein);
dup2(pipe_read_handle(proc->pipein), STDIN_FILENO);
}
int code = execv(proc->path.str, (char* const*)argv);
//Error
int err = errno;
string_const_t errmsg = system_error_message(err);
log_errorf(0, ERROR_SYSTEM_CALL_FAIL,
STRING_CONST("Child process failed execve() '%.*s': %.*s (%d) (%d)"),
STRING_FORMAT(proc->path), STRING_FORMAT(errmsg), err, code);
process_exit(PROCESS_EXIT_FAILURE);
FOUNDATION_UNUSED(code);
}
memory_deallocate(argv);
if (pid > 0) {
log_debugf(0, STRING_CONST("Child process forked, pid %d"), pid);
proc->pid = pid;
if (proc->pipeout)
pipe_close_write(proc->pipeout);
if (proc->pipein)
pipe_close_read(proc->pipein);
/*if (proc->flags & PROCESS_DETACHED) {
int cstatus = 0;
pid_t err = waitpid(pid, &cstatus, WNOHANG);
if (err == 0) {
//TODO: Ugly wait to make sure process spawned correctly
thread_sleep(500);
err = waitpid(pid, &cstatus, WNOHANG);
}
if (err > 0) {
//Process exited, check code
proc->pid = 0;
proc->code = (int)((char)WEXITSTATUS(cstatus));
log_debugf(0, STRING_CONST("Child process returned: %d"), proc->code);
return proc->code;
}
}*/
}
else {
//Error
string_const_t errmsg;
errmsg = system_error_message(proc->code);
log_errorf(0, ERROR_SYSTEM_CALL_FAIL, STRING_CONST("Unable to spawn process '%.*s': %.*s (%d)"),
STRING_FORMAT(proc->path), STRING_FORMAT(errmsg), proc->code);
if (proc->pipeout)
stream_deallocate(proc->pipeout);
if (proc->pipein)
stream_deallocate(proc->pipein);
proc->pipeout = 0;
proc->pipein = 0;
proc->code = PROCESS_INVALID_ARGS;
return proc->code;
}
#endif
#if !FOUNDATION_PLATFORM_WINDOWS && !FOUNDATION_PLATFORM_POSIX
FOUNDATION_ASSERT_FAIL("Process spawning not supported on platform");
#endif
#if FOUNDATION_PLATFORM_MACOSX
exit:
#endif
if (proc->flags & PROCESS_DETACHED)
return PROCESS_STILL_ACTIVE;
return process_wait(proc);
}
DECLARE_TEST( ringbufferstream, threadedio )
{
ringbufferstream_test_t test = {0};
uint32_t* srcbuffer;
unsigned int si;
unsigned int loop, loops;
real elapsed, throughput;
unsigned int mbytes;
#if FOUNDATION_PLATFORM_ANDROID || FOUNDATION_PLATFORM_IOS
mbytes = 16;
loops = 32;
#else
mbytes = 256;
loops = 16;
#endif
test.buffer_size = mbytes * 1024 * 1024;
srcbuffer = memory_allocate( test.buffer_size, 0, MEMORY_PERSISTENT );
test.source_buffer = (void*)srcbuffer;
test.dest_buffer = memory_allocate_zero( test.buffer_size, 0, MEMORY_PERSISTENT );
for( si = 0; si < ( test.buffer_size / 4 ); ++si )
srcbuffer[si] = random32();
elapsed = 0;
for( loop = 0; loop < loops; ++loop )
{
test.stream = ringbuffer_stream_allocate( 23477, test.buffer_size );
test.read_thread = thread_create( read_thread, "reader", THREAD_PRIORITY_NORMAL, 0 );
test.write_thread = thread_create( write_thread, "writer", THREAD_PRIORITY_NORMAL, 0 );
thread_start( test.read_thread, &test );
thread_start( test.write_thread, &test );
thread_sleep( 100 );
while( thread_is_running( test.read_thread ) || thread_is_running( test.write_thread ) )
thread_sleep( 10 );
thread_destroy( test.read_thread );
thread_destroy( test.write_thread );
for( si = 0; si < test.buffer_size; ++si )
EXPECT_EQ( test.source_buffer[si], test.dest_buffer[si] );
stream_deallocate( test.stream );
elapsed += time_ticks_to_seconds( time_diff( test.start_time, test.end_time ) );
}
throughput = (real)( (float64_t)( mbytes * loops ) / (float64_t)elapsed );
log_infof( HASH_TEST, "Ringbuffer throughput: %d MiB in %.2f sec -> %.2f MiB/sec", ( loops * mbytes ), (float32_t)elapsed, (float32_t)throughput );
elapsed = 0;
for( loop = 0; loop < loops; ++loop )
{
test.start_time = time_current();
memcpy( test.dest_buffer, test.source_buffer, test.buffer_size );
test.end_time = time_current();
for( si = 0; si < test.buffer_size; ++si )
EXPECT_EQ( test.source_buffer[si], test.dest_buffer[si] );
elapsed += time_ticks_to_seconds( time_diff( test.start_time, test.end_time ) );
}
throughput = (real)( (float64_t)( mbytes * loops ) / (float64_t)elapsed );
log_infof( HASH_TEST, "Memcpy throughput: %d MiB in %.2f sec -> %.2f MiB/sec", ( loops * mbytes ), (float32_t)elapsed, (float32_t)throughput );
memory_deallocate( test.source_buffer );
memory_deallocate( test.dest_buffer );
return 0;
}
int process_spawn( process_t* proc )
{
static char unescaped[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.:/\\";
int i, num_args;
int size;
#if FOUNDATION_PLATFORM_WINDOWS
wchar_t* wcmdline;
wchar_t* wwd;
char* cmdline = 0;
#endif
if( !proc )
return PROCESS_INVALID_ARGS;
proc->code = PROCESS_INVALID_ARGS;
if( !string_length( proc->path ) )
return proc->code;
//Always escape path on Windows platforms
#if FOUNDATION_PLATFORM_POSIX
if( string_find_first_not_of( proc->path, unescaped, 0 ) != STRING_NPOS )
#endif
{
if( proc->path[0] != '"' )
proc->path = string_prepend( proc->path, "\"" );
if( proc->path[ string_length( proc->path ) - 1 ] != '"' )
proc->path = string_append( proc->path, "\"" );
}
size = array_size( proc->args );
for( i = 0, num_args = 0; i < size; ++i )
{
char* arg = proc->args[i];
if( !string_length( arg ) )
continue;
++num_args;
if( string_find_first_not_of( arg, unescaped, 0 ) != STRING_NPOS )
{
if( arg[0] != '"' )
{
//Check if we need to escape " characters
unsigned int pos = string_find( arg, '"', 0 );
while( pos != STRING_NPOS )
{
if( arg[ pos - 1 ] != '\\' )
{
char* escarg = string_substr( arg, 0, pos );
char* left = string_substr( arg, pos, STRING_NPOS );
escarg = string_append( escarg, "\\" );
escarg = string_append( escarg, left );
string_deallocate( left );
string_deallocate( arg );
arg = escarg;
}
pos = string_find( arg, '"', pos + 2 );
}
arg = string_prepend( arg, "\"" );
arg = string_append( arg, "\"" );
proc->args[i] = arg;
}
}
}
#if FOUNDATION_PLATFORM_WINDOWS
# ifndef SEE_MASK_NOASYNC
# define SEE_MASK_NOASYNC 0x00000100
# endif
if( !( proc->flags & PROCESS_WINDOWS_USE_SHELLEXECUTE ) ) //Don't prepend exe path to parameters if using ShellExecute
cmdline = string_clone( proc->path );
//Build command line string
for( i = 0; i < size; ++i )
{
char* arg = proc->args[i];
if( !string_length( arg ) )
continue;
if( cmdline )
cmdline = string_append( cmdline, " " );
cmdline = string_append( cmdline, arg );
}
if( !string_length( proc->wd ) )
proc->wd = string_clone( environment_current_working_directory() );
wcmdline = wstring_allocate_from_string( cmdline, 0 );
wwd = wstring_allocate_from_string( proc->wd, 0 );
if( proc->flags & PROCESS_WINDOWS_USE_SHELLEXECUTE )
{
SHELLEXECUTEINFOW sei;
wchar_t* wverb;
wchar_t* wpath;
wverb = ( proc->verb && string_length( proc->verb ) ) ? wstring_allocate_from_string( proc->verb, 0 ) : 0;
wpath = wstring_allocate_from_string( proc->path, 0 );
ZeroMemory( &sei, sizeof( sei ) );
sei.cbSize = sizeof(SHELLEXECUTEINFOW);
sei.hwnd = 0;
sei.fMask = SEE_MASK_NOASYNC | SEE_MASK_FLAG_NO_UI | SEE_MASK_NOCLOSEPROCESS;
sei.lpVerb = wverb;
sei.lpFile = wpath;
sei.lpParameters = wcmdline;
sei.lpDirectory = wwd;
sei.nShow = SW_SHOWNORMAL;
if( !( proc->flags & PROCESS_CONSOLE ) )
sei.fMask |= SEE_MASK_NO_CONSOLE;
if( proc->flags & PROCESS_STDSTREAMS )
log_warnf( 0, WARNING_UNSUPPORTED, "Unable to redirect standard in/out through pipes when using ShellExecute for process spawning" );
log_debugf( 0, "Spawn process (ShellExecute): %s %s", proc->path, cmdline );
if( !ShellExecuteExW( &sei ) )
{
log_warnf( 0, WARNING_SYSTEM_CALL_FAIL, "Unable to spawn process (ShellExecute) for executable '%s': %s", proc->path, system_error_message( GetLastError() ) );
}
else
{
proc->hp = sei.hProcess;
proc->ht = 0;
proc->code = 0;
}
wstring_deallocate( wverb );
wstring_deallocate( wpath );
}
else
{
STARTUPINFOW si;
PROCESS_INFORMATION pi;
BOOL inherit_handles = FALSE;
memset( &si, 0, sizeof( si ) );
memset( &pi, 0, sizeof( pi ) );
si.cb = sizeof( si );
if( proc->flags & PROCESS_STDSTREAMS )
{
proc->pipeout = pipe_allocate();
proc->pipein = pipe_allocate();
si.dwFlags |= STARTF_USESTDHANDLES;
si.hStdOutput = pipe_write_handle( proc->pipeout );
si.hStdError = pipe_write_handle( proc->pipeout );
si.hStdInput = pipe_read_handle( proc->pipein );
//Don't inherit wrong ends of pipes
SetHandleInformation( pipe_read_handle( proc->pipeout ), HANDLE_FLAG_INHERIT, 0 );
SetHandleInformation( pipe_write_handle( proc->pipein ), HANDLE_FLAG_INHERIT, 0 );
inherit_handles = TRUE;
}
log_debugf( 0, "Spawn process (CreateProcess): %s %s", proc->path, cmdline );
if( !CreateProcessW( 0/*wpath*/, wcmdline, 0, 0, inherit_handles, ( proc->flags & PROCESS_CONSOLE ) ? CREATE_NEW_CONSOLE : 0, 0, wwd, &si, &pi ) )
{
log_warnf( 0, WARNING_SYSTEM_CALL_FAIL, "Unable to spawn process (CreateProcess) for executable '%s': %s", proc->path, system_error_message( GetLastError() ) );
stream_deallocate( proc->pipeout );
stream_deallocate( proc->pipein );
proc->pipeout = 0;
proc->pipein = 0;
}
else
{
proc->hp = pi.hProcess;
proc->ht = pi.hThread;
proc->code = 0;
}
if( proc->pipeout )
pipe_close_write( proc->pipeout );
if( proc->pipein )
pipe_close_read( proc->pipein );
}
wstring_deallocate( wcmdline );
wstring_deallocate( wwd );
string_deallocate( cmdline );
if( proc->code < 0 )
return proc->code; //Error
#endif
#if FOUNDATION_PLATFORM_MACOSX
if( proc->flags & PROCESS_OSX_USE_OPENAPPLICATION )
{
proc->pid = 0;
LSApplicationParameters params;
ProcessSerialNumber psn;
FSRef* fsref = memory_allocate( 0, sizeof( FSRef ), 0, MEMORY_TEMPORARY | MEMORY_ZERO_INITIALIZED );
memset( ¶ms, 0, sizeof( LSApplicationParameters ) );
memset( &psn, 0, sizeof( ProcessSerialNumber ) );
char* pathstripped = string_strip( string_clone( proc->path ), "\"" );
OSStatus status = 0;
status = FSPathMakeRef( (uint8_t*)pathstripped, fsref, 0 );
if( status < 0 )
{
pathstripped = string_append( pathstripped, ".app" );
status = FSPathMakeRef( (uint8_t*)pathstripped, fsref, 0 );
}
CFStringRef* args = 0;
for( i = 0, size = array_size( proc->args ); i < size; ++i ) //App gets executable path automatically, don't include
array_push( args, CFStringCreateWithCString( 0, proc->args[i], kCFStringEncodingUTF8 ) );
CFArrayRef argvref = CFArrayCreate( 0, (const void**)args, (CFIndex)array_size( args ), 0 );
params.flags = kLSLaunchDefaults;
params.application = fsref;
params.argv = argvref;
log_debugf( 0, "Spawn process (LSOpenApplication): %s", pathstripped );
status = LSOpenApplication( ¶ms, &psn );
if( status != 0 )
{
proc->code = status;
log_warnf( 0, WARNING_BAD_DATA, "Unable to spawn process for executable '%s': %s", proc->path, system_error_message( status ) );
}
CFRelease( argvref );
for( i = 0, size = array_size( args ); i < size; ++i )
CFRelease( args[i] );
memory_deallocate( fsref );
string_deallocate( pathstripped );
if( status == 0 )
{
pid_t pid = 0;
GetProcessPID( &psn, &pid );
proc->pid = pid;
//Always "detached" with LSOpenApplication, not a child process at all
//Setup a kqueue to watch when process terminates so we can emulate a wait
proc->kq = kqueue();
if( proc->kq < 0 )
{
log_warnf( 0, WARNING_SYSTEM_CALL_FAIL, "Unable to create kqueue for process watch: %s (%d)", proc->kq, system_error_message( proc->kq ) );
proc->kq = 0;
}
else
{
struct kevent changes;
EV_SET( &changes, (pid_t)pid, EVFILT_PROC, EV_ADD | EV_RECEIPT, NOTE_EXIT, 0, 0 );
int ret = kevent( proc->kq, &changes, 1, &changes, 1, 0 );
if( ret != 1 )
{
log_warnf( 0, WARNING_SYSTEM_CALL_FAIL, "Unable to setup kqueue for process watch, failed to add event to kqueue (%d)", ret );
close( proc->kq );
proc->kq = 0;
}
}
}
goto exit;
}
#endif
#if FOUNDATION_PLATFORM_POSIX
//Insert executable arg at start and null ptr at end
int argc = array_size( proc->args ) + 1;
array_grow( proc->args, 2 );
for( int arg = argc - 1; arg > 0; --arg )
proc->args[arg] = proc->args[arg-1];
proc->args[0] = string_clone( proc->path );
proc->args[argc] = 0;
if( proc->flags & PROCESS_STDSTREAMS )
{
proc->pipeout = pipe_allocate();
proc->pipein = pipe_allocate();
}
proc->pid = 0;
pid_t pid = fork();
if( pid == 0 )
{
//Child
if( string_length( proc->wd ) )
{
log_debugf( 0, "Spawned child process, setting working directory to %s", proc->wd );
environment_set_current_working_directory( proc->wd );
}
log_debugf( 0, "Child process executing: %s", proc->path );
if( proc->flags & PROCESS_STDSTREAMS )
{
pipe_close_read( proc->pipeout );
dup2( pipe_write_fd( proc->pipeout ), STDOUT_FILENO );
pipe_close_write( proc->pipein );
dup2( pipe_read_fd( proc->pipein ), STDIN_FILENO );
}
int code = execv( proc->path, proc->args );
if( code < 0 ) //Will always be true since this point will never be reached if execve() is successful
log_warnf( 0, WARNING_BAD_DATA, "Child process failed execve() : %s : %s", proc->path, system_error_message( errno ) );
//Error
process_exit( -1 );
}
if( pid > 0 )
{
log_debugf( 0, "Child process forked, pid %d", pid );
proc->pid = pid;
if( proc->pipeout )
pipe_close_write( proc->pipeout );
if( proc->pipein )
pipe_close_read( proc->pipein );
if( proc->flags & PROCESS_DETACHED )
{
int cstatus = 0;
pid_t err = waitpid( pid, &cstatus, WNOHANG );
if( err == 0 )
{
//TODO: Ugly wait to make sure process spawned correctly
thread_sleep( 500 );
err = waitpid( pid, &cstatus, WNOHANG );
}
if( err > 0 )
{
//Process exited, check code
proc->code = (int)((char)WEXITSTATUS( cstatus ));
log_debugf( 0, "Child process returned: %d", proc->code );
return proc->code;
}
}
}
else
{
//Error
proc->code = errno;
log_warnf( 0, WARNING_BAD_DATA, "Unable to spawn process: %s : %s", proc->path, system_error_message( proc->code ) );
if( proc->pipeout )
stream_deallocate( proc->pipeout );
if( proc->pipein )
stream_deallocate( proc->pipein );
proc->pipeout = 0;
proc->pipein = 0;
return proc->code;
}
#endif
#if !FOUNDATION_PLATFORM_WINDOWS && !FOUNDATION_PLATFORM_POSIX
FOUNDATION_ASSERT_FAIL( "Process spawning not supported on platform" );
#endif
#if FOUNDATION_PLATFORM_MACOSX
exit:
#endif
if( proc->flags & PROCESS_DETACHED )
return PROCESS_STILL_ACTIVE;
return process_wait( proc );
}
int hashify_write_file( stream_t* generated_file, const char* output_filename )
{
bool need_update = false;
stream_t* output_file = 0;
int result = HASHIFY_RESULT_OK;
output_file = stream_open( output_filename, STREAM_OUT | STREAM_IN );
if( !output_file )
{
need_update = true;
output_file = stream_open( output_filename, STREAM_OUT );
if( !output_file )
{
log_warnf( WARNING_BAD_DATA, "Unable to open output file: %s", output_filename );
return HASHIFY_RESULT_MISSING_OUTPUT_FILE;
}
}
if( !need_update )
need_update = !uint128_equal( stream_md5( generated_file ), stream_md5( output_file ) );
if( need_update )
{
char local_buffer[1024];
uint64_t read = 0;
uint64_t written = 0;
uint64_t total_written = 0;
stream_seek( generated_file, 0, STREAM_SEEK_BEGIN );
stream_seek( output_file, 0, STREAM_SEEK_BEGIN );
while( !stream_eos( generated_file ) )
{
read = stream_read( generated_file, local_buffer, 1024 );
if( !read )
break;
written = stream_write( output_file, local_buffer, read );
total_written += written;
if( written != read )
{
log_errorf( ERROR_SYSTEM_CALL_FAIL, "Unable to write to output file '%s': %llu of %llu bytes written", output_filename, written, read );
result = HASHIFY_RESULT_OUTPUT_FILE_WRITE_FAIL;
break;
}
}
if( result == HASHIFY_RESULT_OK )
{
stream_truncate( output_file, total_written );
log_infof( " wrote %s : %llu bytes", output_filename, total_written );
}
}
else
{
log_infof( " hash file already up to date" );
}
stream_deallocate( output_file );
return result;
}
DECLARE_TEST( profile, stream )
{
object_t thread[32];
int ith;
int frame;
char* filename;
error();
filename = path_merge( environment_temporary_directory(), "test.profile" );
log_infof( HASH_TEST, "Output to profile file: %s", filename );
fs_make_directory( environment_temporary_directory() );
_profile_stream = fs_open_file( filename, STREAM_OUT | STREAM_BINARY );
string_deallocate( filename );
profile_initialize( "test_profile", _test_profile_buffer, _test_profile_buffer_size );
profile_set_output( _profile_file_writer );
profile_set_output_wait( 10 );
profile_enable( true );
for( ith = 0; ith < 32; ++ith )
{
thread[ith] = thread_create( _profile_stream_thread, "profile_thread", THREAD_PRIORITY_NORMAL, 0 );
thread_start( thread[ith], 0 );
}
test_wait_for_threads_startup( thread, 32 );
for( frame = 0; frame < 1000; ++frame )
{
thread_sleep( 16 );
profile_log( "This is a really long profile log line that should break into multiple profile blocks automatically without causing any issues whatsoever if everything works as expected which it should or the code needs to be fixed" );
profile_end_frame( frame++ );
if( ( frame % 30 ) == 0 )
{
profile_enable( false );
thread_sleep( 10 );
profile_enable( true );
}
}
for( ith = 0; ith < 32; ++ith )
{
thread_terminate( thread[ith] );
thread_destroy( thread[ith] );
thread_yield();
}
test_wait_for_threads_exit( thread, 32 );
profile_end_frame( frame++ );
profile_set_output_wait( 100 );
thread_sleep( 1000 );
profile_enable( false );
profile_shutdown();
error();
stream_deallocate( _profile_stream );
//TODO: Validate that output is sane
log_debugf( HASH_TEST, "Generated %lld blocks", atomic_load64( &_profile_generated_blocks ) );
return 0;
}
DECLARE_TEST(md5, streams) {
stream_t* test_stream;
stream_t* unix_stream;
stream_t* windows_stream;
uint128_t digest, unix_digest, windows_digest;
size_t ichunks;
char unix_buffer[] =
"tvqy0C9TO2MI7uyUqr\n\n"
"QVcrmjDKDEcB3e7dpM\n\n"
"bMpRv6uH0LWPjvNcNp\n"
"jpkje9KYXhJjSA2TBy\n"
"bTqnOPhOOZ5aWnUdgO\n"
"fLapbWSZInasn1SJlk\n"
"ytNFKkASDln05zw39X\n"
"L8McmojqPmn41Y6CRN\n\n"
"wZbKo0PZofDpbAMr1u\n"
"u8GJIocbEBFzsyKo62\n"
"FlQh1pjm9jBeoEJIHL\n"
"v4ixQn77l4M7zbRHgJ\n"
"DIVy0vvpNEzxFRyD3Z\n"
"5OrJvr\n";
char windows_buffer[] =
"tvqy0C9TO2MI7uyUqr\r\n\r\n"
"QVcrmjDKDEcB3e7dpM\r\n\r\n"
"bMpRv6uH0LWPjvNcNp\r\n"
"jpkje9KYXhJjSA2TBy\r\n"
"bTqnOPhOOZ5aWnUdgO\r\n"
"fLapbWSZInasn1SJlk\r\n"
"ytNFKkASDln05zw39X\r\n"
"L8McmojqPmn41Y6CRN\r\n\r\n"
"wZbKo0PZofDpbAMr1u\r\n"
"u8GJIocbEBFzsyKo62\r\n"
"FlQh1pjm9jBeoEJIHL\r\n"
"v4ixQn77l4M7zbRHgJ\r\n"
"DIVy0vvpNEzxFRyD3Z\r\n"
"5OrJvr\r\n";
test_stream = buffer_stream_allocate(0, STREAM_IN | STREAM_OUT | STREAM_BINARY, 0, 0, true, true);
stream_write(test_stream, digest_test_string, 2000);
stream_seek(test_stream, 0, STREAM_SEEK_BEGIN);
digest = stream_md5(test_stream);
stream_deallocate(test_stream);
EXPECT_TRUE(uint128_equal(digest, uint128_make(0x230e0a23943c7d13ULL, 0xd2ccac7ec9df4d0cULL)));
unix_stream = buffer_stream_allocate((void*)unix_buffer, STREAM_IN, string_length(unix_buffer),
string_length(unix_buffer), false, false);
windows_stream = buffer_stream_allocate((void*)windows_buffer, STREAM_IN,
string_length(windows_buffer), string_length(windows_buffer), false, false);
stream_set_binary(unix_stream, false);
stream_set_binary(windows_stream, false);
unix_digest = stream_md5(unix_stream);
windows_digest = stream_md5(windows_stream);
EXPECT_TRUE(uint128_equal(unix_digest, uint128_make(0xcf32b789c7e77197ULL, 0x2bff28c36c601093ULL)));
EXPECT_TRUE(uint128_equal(unix_digest, windows_digest));
stream_set_binary(unix_stream, true);
stream_set_binary(windows_stream, true);
stream_seek(unix_stream, 0, STREAM_SEEK_BEGIN);
stream_seek(windows_stream, 0, STREAM_SEEK_BEGIN);
unix_digest = stream_md5(unix_stream);
windows_digest = stream_md5(windows_stream);
stream_deallocate(unix_stream);
stream_deallocate(windows_stream);
EXPECT_TRUE(uint128_equal(unix_digest, uint128_make(0xcf32b789c7e77197ULL, 0x2bff28c36c601093ULL)));
EXPECT_TRUE(uint128_equal(windows_digest, uint128_make(0xf77d63bbe1df9334ULL,
0x24d5cb05cd503e44ULL)));
EXPECT_TRUE(!uint128_equal(unix_digest, windows_digest));
unix_stream = buffer_stream_allocate(nullptr, STREAM_IN | STREAM_OUT,
128 * 1024, 128 * 1024, true, true);
windows_stream = buffer_stream_allocate(nullptr, STREAM_IN | STREAM_OUT,
128 * 1024, 128 * 1024, true, true);
ichunks = 0;
while ((ichunks+1) * 3 < 128 * 1024) {
stream_write(unix_stream, STRING_CONST("a\n"));
stream_write(windows_stream, STRING_CONST("a\r\n"));
++ichunks;
}
stream_seek(unix_stream, 0, STREAM_SEEK_BEGIN);
stream_seek(windows_stream, 0, STREAM_SEEK_BEGIN);
unix_digest = stream_md5(unix_stream);
windows_digest = stream_md5(windows_stream);
stream_deallocate(unix_stream);
stream_deallocate(windows_stream);
EXPECT_TRUE(uint128_equal(unix_digest, windows_digest));
return 0;
}
