void update_dirfile(const char * dir, const char * name, const char * user){
dirscan scan = {0};
ensure_directory("shares/");
{
char * dir_filename = fmtstr("shares/%s.dir", name);
size_t size0;
void * buf = read_file_to_buffer(dir_filename, &size0);
if(buf != NULL){
logd("Size: %i\n", size0);
scan = dirscan_from_buffer(buf);
dealloc(buf);
}
logd("SCAN: %i\n", scan.cnt);
udpc_dirscan_update(dir, &scan, false);
logd("SCAN2: %i\n", scan.cnt);
size_t size = 0;
buf = dirscan_to_buffer(scan,&size);
write_buffer_to_file(buf, size, dir_filename);
dealloc(buf);
}
{
void * buffer = NULL;
size_t cnt = 0;
udpc_pack_string(dir, &buffer, &cnt);
udpc_pack_string(name, &buffer, &cnt);
udpc_pack_string(user, &buffer, &cnt);
char * shareinfo_filename = fmtstr("shareinfo/%s", name);
FILE * f = fopen(shareinfo_filename, "w");
fwrite(buffer, 1, cnt, f);
fclose(f);
dealloc(shareinfo_filename);
}
char * bin_filename = fmtstr("shares/%s.bin", name);
size_t s = 0;
void * b = dirscan_to_buffer(scan, &s);
FILE * f = fopen(bin_filename, "w");
fwrite(b, 1, s, f);
fclose(f);
dealloc(bin_filename);
char * filename = fmtstr("shares/%s.json", name);
FILE * jsonfile = fopen(filename, "w");
fprintf(jsonfile, "{\"dir\": \"%s\", \"files\": [\n", dir);
for(size_t i = 0; i < scan.cnt; i++){
fprintf(jsonfile, "{ \"path\": \"%s\", \"md5\":\"", scan.files[i]);
udpc_fprintf_md5(jsonfile, scan.md5s[i]);
if(i != scan.cnt -1){
fprintf(jsonfile, "\"},\n");
}else{
fprintf(jsonfile, "\"}\n");
}
}
fprintf(jsonfile, "]}\n");
fclose(jsonfile);
dealloc(filename);
}
void write_symbol_to_buffer(working_state * state, uint32_t code, int32_t size)
{
int32_t working_buffer;
int32_t bits_in_working_buffer;
if (size == 0) ERREXIT("Code size is 0. Possible incorrect Huffman table.");
working_buffer = ((int32_t)code) & ((((int32_t)1) << size) - 1);
bits_in_working_buffer = size + state->bits_in_code_buffer; // add existing bits from coding buffer
working_buffer <<= 24 - bits_in_working_buffer; // shift buffer bits to correct position
working_buffer |= state->code_buffer; // add bits from coding buffer
while (bits_in_working_buffer >= 8) {
int c = (int)((working_buffer >> 16) & 0xFF);
*state->buffer_next_byte_position = (int8_t)(c);
state->buffer_next_byte_position++;
state->free_space_in_output_buffer--;
if (state->free_space_in_output_buffer == 0)
{
write_buffer_to_file(state);
}
if (c == 0xFF) { // check if byte stuffing is needed: section F.1.2.3 of JPEG standard
*state->buffer_next_byte_position = (int8_t)(0);
state->buffer_next_byte_position++;
state->free_space_in_output_buffer--;
if (state->free_space_in_output_buffer == 0)
write_buffer_to_file(state);
}
working_buffer <<= 8;
bits_in_working_buffer -= 8;
}
state->code_buffer = working_buffer;
state->bits_in_code_buffer = bits_in_working_buffer;
}
int main(int argc, char** argv) {
WasmStackAllocator stack_allocator;
WasmAllocator* allocator;
wasm_init_stdio();
wasm_init_file_writer_existing(&s_log_stream_writer, stdout);
wasm_init_stream(&s_log_stream, &s_log_stream_writer.base, NULL);
parse_options(argc, argv);
if (s_use_libc_allocator) {
allocator = &g_wasm_libc_allocator;
} else {
wasm_init_stack_allocator(&stack_allocator, &g_wasm_libc_allocator);
allocator = &stack_allocator.allocator;
}
WasmAstLexer* lexer = wasm_new_ast_file_lexer(allocator, s_infile);
if (!lexer)
WASM_FATAL("unable to read %s\n", s_infile);
WasmScript script;
WasmResult result = wasm_parse_ast(lexer, &script, &s_error_handler);
if (WASM_SUCCEEDED(result)) {
result =
wasm_resolve_names_script(allocator, lexer, &script, &s_error_handler);
if (WASM_SUCCEEDED(result) && s_validate) {
result =
wasm_validate_script(allocator, lexer, &script, &s_error_handler);
}
if (WASM_SUCCEEDED(result) && s_validate_assert_invalid_and_malformed) {
WasmDefaultErrorHandlerInfo assert_invalid_info;
WasmSourceErrorHandler assert_invalid_error_handler;
init_source_error_handler(&assert_invalid_error_handler,
&assert_invalid_info, "assert_invalid error");
WasmDefaultErrorHandlerInfo assert_malformed_info;
WasmSourceErrorHandler assert_malformed_error_handler;
init_source_error_handler(&assert_malformed_error_handler,
&assert_malformed_info,
"assert_malformed error");
result = wasm_validate_assert_invalid_and_malformed(
allocator, lexer, &script, &assert_invalid_error_handler,
&assert_malformed_error_handler, &s_error_handler);
}
if (WASM_SUCCEEDED(result)) {
if (s_spec) {
s_write_binary_spec_options.json_filename = s_outfile;
s_write_binary_spec_options.write_binary_options =
s_write_binary_options;
result = wasm_write_binary_spec_script(allocator, &script, s_infile,
&s_write_binary_spec_options);
} else {
WasmMemoryWriter writer;
WASM_ZERO_MEMORY(writer);
if (WASM_FAILED(wasm_init_mem_writer(allocator, &writer)))
WASM_FATAL("unable to open memory writer for writing\n");
result = wasm_write_binary_script(allocator, &writer.base, &script,
&s_write_binary_options);
if (WASM_SUCCEEDED(result))
write_buffer_to_file(s_outfile, &writer.buf);
wasm_close_mem_writer(&writer);
}
}
}
wasm_destroy_ast_lexer(lexer);
if (s_use_libc_allocator)
wasm_destroy_script(&script);
wasm_print_allocator_stats(allocator);
wasm_destroy_allocator(allocator);
return result;
}
bool test_dirscan(){
int buffer_test[10000];
for(size_t i = 0; i <array_count(buffer_test); i++){
buffer_test[i] = i;
}
allocator * _allocator = trace_allocator_make();
allocator * old_allocator = iron_get_allocator();
iron_set_allocator(_allocator);
dirscan ds = {0};
//size_t max_diff_cnt = 0;
//size_t max_file_cnt = 0;
mkdir("dir test 1", 0777);
mkdir("dir test 1/sub dir", 0777);
memset(buffer_test, 10, sizeof(buffer_test));
udpc_dirscan_update("dir test 1", &ds, false);
ASSERT(ds.cnt == 0);
write_buffer_to_file(buffer_test, sizeof(buffer_test), "dir test 1/test1" );
buffer_test[0] += 10;
write_buffer_to_file(buffer_test, sizeof(buffer_test), "dir test 1/test2" );
iron_usleep(30000);
size_t s = 0;
void * buffer = dirscan_to_buffer(ds, &s);
dirscan copy = dirscan_from_buffer(buffer);
dealloc(buffer);
udpc_dirscan_update("dir test 1", &ds, false);
dirscan_diff diff = udpc_dirscan_diff(copy, ds);
ASSERT(diff.cnt == 2);
ASSERT(diff.states[0] == DIRSCAN_NEW);
udpc_dirscan_clear_diff(&diff);
ASSERT(ds.type[0] == UDPC_DIRSCAN_FILE);
remove("dir test 1/test1");
iron_usleep(20000);
udpc_dirscan_update("dir test 1", &ds, false);
int idx = -1;
if(strcmp(ds.files[0], "test1") == 0)
idx = 0;
else if(strcmp(ds.files[1], "test1") == 0)
idx = 1;
ASSERT(idx != -1);
iron_usleep(30000);
ASSERT(ds.cnt == 2);
ASSERT(ds.type[idx] == UDPC_DIRSCAN_DELETED);
buffer_test[0] += 10;
write_buffer_to_file(buffer_test, sizeof(buffer_test), "dir test 1/test1" );
udpc_dirscan_update("dir test 1", ©, false);
diff = udpc_dirscan_diff(ds, copy);
ASSERT(diff.cnt == 1);
ASSERT(diff.states[0] == DIRSCAN_NEW);
udpc_dirscan_clear_diff(&diff);
dirscan_clean(©);
write_buffer_to_file(buffer_test, sizeof(buffer_test), "dir test 1/sub dir/test3" );
udpc_dirscan_update("dir test 1", &ds, false);
ASSERT(ds.cnt == 3);
ASSERT(udpc_md5_compare(ds.md5s[idx], ds.md5s[2]));
for(int i = 0; i < 10; i++){
char filename[40];
sprintf(filename, "dir test 1/sub dir/testx_%i", i);
write_buffer_to_file(buffer_test, sizeof(buffer_test), filename );
}
udpc_dirscan_update("dir test 1", &ds, false);
ASSERT(ds.cnt == 13);
dirscan_clean(&ds);
for(int i = 0; i < 10; i++){
char filename[40];
sprintf(filename, "dir test 1/sub dir/testx_%i", i);
remove(filename);
}
ASSERT(!remove("dir test 1/test2"));
ASSERT(!remove("dir test 1/sub dir/test3"));
ASSERT(!remove("dir test 1/sub dir"));
ASSERT(!remove("dir test 1/test1"));
ASSERT(!remove("dir test 1"));
iron_set_allocator(old_allocator);
int used_pointers = (int) trace_allocator_allocated_pointers(_allocator);
trace_allocator_release(_allocator);
ASSERT(used_pointers == 0);
return TEST_SUCCESS;
}
