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; }