mirrors/unleashed-firmware
1
Fork 0
mirror of https://github.com/DarkFlippers/unleashed-firmware.git synced 2025-12-13 05:06:30 +04:00
Code Issues Activity

Merge branch 'Eng1n33r:dev' into feat/playlist

Browse Source
This commit is contained in:
Daniel
2022-08-10 17:04:10 +02:00
committed by GitHub
parent f0937e91f1 ed034da3ff
commit b7922a2a49
12 changed files with 64 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
CHANGELOG.md
View File

@@ -1,10 +1,7 @@
### New changes
* Not replace keeloq mfcodes user file on every update
* Universal Remote for ACs - New button icon and updated asset by Svarich
* BadUSB proper fix from OFW PR 1525
* NRF24 Sniffer - Fixed an issue where attempts to write to addresses.txt freezes app if the file doesn't exist - by ESurge - PR #46
* OFW: Mifare Classic emulation fixes
* OFW: Storage fixes for handling empty files
* Fix qFlipper and other apps causes flipper crash while trying to interact with files - see commit `b2bd13`
* NRF24 Sniffer update
* Other fixes
**Note: Prefer installing using web updater or by self update package, all needed assets will be installed**

1
applications/barcode_generator/barcode_generator.c
View File

@@ -412,6 +412,7 @@ int32_t barcode_UPCA_generator_app(void* p) {
ValueMutex state_mutex;
if(!init_mutex(&state_mutex, plugin_state, sizeof(PluginState))) {
FURI_LOG_E("barcode_UPCA_generator", "cannot create mutex\r\n");
furi_message_queue_free(event_queue);
free(plugin_state);
return 255;
}

1
applications/clock_app/clock_app.c
View File

@@ -83,6 +83,7 @@ int32_t clock_app(void* p) {
ValueMutex state_mutex;
if(!init_mutex(&state_mutex, plugin_state, sizeof(ClockState))) {
FURI_LOG_E(TAG, "cannot create mutex\r\n");
furi_message_queue_free(event_queue);
free(plugin_state);
return 255;
}

1
applications/mousejacker/mousejacker.c
View File

@@ -229,6 +229,7 @@ int32_t mousejacker_app(void* p) {
ValueMutex state_mutex;
if(!init_mutex(&state_mutex, plugin_state, sizeof(PluginState))) {
FURI_LOG_E("mousejacker", "cannot create mutex\r\n");
furi_message_queue_free(event_queue);
free(plugin_state);
return 255;
}

12
applications/nrfsniff/nrfsniff.c
View File

@@ -34,7 +34,7 @@ typedef struct {
char rate_text_fmt[] = "Transfer rate: %dMbps";
char channel_text_fmt[] = "Channel: %d";
char preamble_text_fmt[] = "Preamble: %02X";
char sniff_text_fmt[] = "Sniffing: %s";
char sniff_text_fmt[] = "Sniffing: %s Found: %d";
char addresses_header_text[] = "Address,rate";
char sniffed_address_fmt[] = "%s,%d";
char rate_text[46];
@@ -44,6 +44,7 @@ char sniff_text[38];
char sniffed_address[14];
uint8_t target_channel = 0;
uint32_t found_count = 0;
uint8_t target_rate = 8; // rate can be either 8 (2Mbps) or 0 (1Mbps)
uint8_t target_preamble[] = {0xAA, 0x00};
uint8_t sniffing_state = false;
@@ -128,7 +129,7 @@ static void render_callback(Canvas* const canvas, void* ctx) {
snprintf(rate_text, sizeof(rate_text), rate_text_fmt, (int)rate);
snprintf(channel_text, sizeof(channel_text), channel_text_fmt, (int)target_channel);
snprintf(preamble_text, sizeof(preamble_text), preamble_text_fmt, target_preamble[0]);
snprintf(sniff_text, sizeof(sniff_text), sniff_text_fmt, sniffing);
snprintf(sniff_text, sizeof(sniff_text), sniff_text_fmt, sniffing, found_count);
snprintf(
sniffed_address, sizeof(sniffed_address), sniffed_address_fmt, top_address, (int)rate);
canvas_draw_str_aligned(canvas, 10, 10, AlignLeft, AlignBottom, rate_text);
@@ -289,6 +290,7 @@ static void wrap_up(Storage* storage, NotificationApp* notification) {
if(ch <= LOGITECH_MAX_CHANNEL) {
hexlify(addr, 5, top_address);
save_addr_to_file(storage, addr, 5, notification);
found_count++;
break;
}
}
@@ -310,6 +312,7 @@ int32_t nrfsniff_app(void* p) {
ValueMutex state_mutex;
if(!init_mutex(&state_mutex, plugin_state, sizeof(PluginState))) {
FURI_LOG_E(TAG, "cannot create mutex\r\n");
furi_message_queue_free(event_queue);
free(plugin_state);
return 255;
}
@@ -326,7 +329,6 @@ int32_t nrfsniff_app(void* p) {
gui_add_view_port(gui, view_port, GuiLayerFullscreen);
NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
furi_hal_power_suppress_charge_enter();
Storage* storage = furi_record_open(RECORD_STORAGE);
storage_common_mkdir(storage, NRFSNIFF_APP_PATH_FOLDER);
@@ -375,6 +377,7 @@ int32_t nrfsniff_app(void* p) {
// toggle sniffing
sniffing_state = !sniffing_state;
if(sniffing_state) {
found_count = 0;
start_sniffing();
start = furi_get_tick();
} else
@@ -422,7 +425,6 @@ int32_t nrfsniff_app(void* p) {
furi_hal_spi_release(nrf24_HANDLE);
view_port_enabled_set(view_port, false);
gui_remove_view_port(gui, view_port);
furi_hal_power_suppress_charge_exit();
furi_record_close(RECORD_GUI);
furi_record_close(RECORD_NOTIFICATION);
furi_record_close(RECORD_STORAGE);
@@ -430,4 +432,4 @@ int32_t nrfsniff_app(void* p) {
furi_message_queue_free(event_queue);
return 0;
}
}

64
applications/rpc/rpc_storage.c
View File

@@ -305,27 +305,21 @@ static void rpc_system_storage_read_process(const PB_Main* request, void* contex
response->command_id = request->command_id;
response->which_content = PB_Main_storage_read_response_tag;
response->command_status = PB_CommandStatus_OK;
response->content.storage_read_response.has_file = true;
response->content.storage_read_response.file.data =
malloc(PB_BYTES_ARRAY_T_ALLOCSIZE(MIN(size_left, MAX_DATA_SIZE)));
uint8_t* buffer = response->content.storage_read_response.file.data->bytes;
uint16_t* read_size_msg = &response->content.storage_read_response.file.data->size;
size_t read_size = MIN(size_left, MAX_DATA_SIZE);
if(read_size) {
response->content.storage_read_response.has_file = true;
response->content.storage_read_response.file.data =
malloc(PB_BYTES_ARRAY_T_ALLOCSIZE());
uint8_t* buffer = response->content.storage_read_response.file.data->bytes;
uint16_t* read_size_msg = &response->content.storage_read_response.file.data->size;
*read_size_msg = storage_file_read(file, buffer, read_size);
size_left -= read_size;
result = (*read_size_msg == read_size);
*read_size_msg = storage_file_read(file, buffer, read_size);
size_left -= read_size;
result = (*read_size_msg == read_size);
response->has_next = result && (size_left > 0);
} else {
response->content.storage_read_response.has_file = false;
response->has_next = false;
result = true;
if(result) {
response->has_next = (size_left > 0);
rpc_send_and_release(session, response);
}
rpc_send_and_release(session, response);
} while((size_left != 0) && result);
if(!result) {
@@ -355,7 +349,7 @@ static void rpc_system_storage_write_process(const PB_Main* request, void* conte
RpcSession* session = rpc_storage->session;
furi_assert(session);
bool fs_operation_success = true;
bool result = true;
if(!path_contains_only_ascii(request->content.storage_write_request.path)) {
rpc_storage->current_command_id = request->command_id;
@@ -376,32 +370,28 @@ static void rpc_system_storage_write_process(const PB_Main* request, void* conte
rpc_storage->current_command_id = request->command_id;
rpc_storage->state = RpcStorageStateWriting;
const char* path = request->content.storage_write_request.path;
fs_operation_success =
storage_file_open(rpc_storage->file, path, FSAM_WRITE, FSOM_CREATE_ALWAYS);
result = storage_file_open(rpc_storage->file, path, FSAM_WRITE, FSOM_CREATE_ALWAYS);
}
File* file = rpc_storage->file;
bool send_response = false;
if(fs_operation_success) {
if(request->content.storage_write_request.has_file) {
uint8_t* buffer = request->content.storage_write_request.file.data->bytes;
size_t buffer_size = request->content.storage_write_request.file.data->size;
uint16_t written_size = storage_file_write(file, buffer, buffer_size);
fs_operation_success = (written_size == buffer_size);
if(result) {
uint8_t* buffer = request->content.storage_write_request.file.data->bytes;
size_t buffer_size = request->content.storage_write_request.file.data->size;
uint16_t written_size = storage_file_write(file, buffer, buffer_size);
result = (written_size == buffer_size);
if(result && !request->has_next) {
rpc_send_and_release_empty(
session, rpc_storage->current_command_id, PB_CommandStatus_OK);
rpc_system_storage_reset_state(rpc_storage, session, false);
}
send_response = !request->has_next;
}
PB_CommandStatus command_status = PB_CommandStatus_OK;
if(!fs_operation_success) {
send_response = true;
command_status = rpc_system_storage_get_file_error(file);
}
if(send_response) {
rpc_send_and_release_empty(session, rpc_storage->current_command_id, command_status);
if(!result) {
rpc_send_and_release_empty(
session, rpc_storage->current_command_id, rpc_system_storage_get_file_error(file));
rpc_system_storage_reset_state(rpc_storage, session, false);
}
}

2
applications/sentry_safe/sentry_safe.c
View File

@@ -92,6 +92,7 @@ int32_t sentry_safe_app(void* p) {
ValueMutex state_mutex;
if(!init_mutex(&state_mutex, sentry_state, sizeof(SentryState))) {
FURI_LOG_E("SentrySafe", "cannot create mutex\r\n");
furi_message_queue_free(event_queue);
free(sentry_state);
return 255;
}
@@ -123,7 +124,6 @@ int32_t sentry_safe_app(void* p) {
break;
case InputKeyLeft:
break;
case InputKeyOk:
if(sentry_state->status == 2) {

1
applications/snake_game/snake_game.c
View File

@@ -311,6 +311,7 @@ int32_t snake_game_app(void* p) {
ValueMutex state_mutex;
if(!init_mutex(&state_mutex, snake_state, sizeof(SnakeState))) {
FURI_LOG_E("SnakeGame", "cannot create mutex\r\n");
furi_message_queue_free(event_queue);
free(snake_state);
return 255;
}

44
applications/storage/storage_cli.c
View File

@@ -274,26 +274,24 @@ static void storage_cli_read_chunks(Cli* cli, string_t path, string_t args) {
if(parsed_count == EOF || parsed_count != 1) {
storage_cli_print_usage();
} else if(storage_file_open(file, string_get_cstr(path), FSAM_READ, FSOM_OPEN_EXISTING)) {
uint8_t* data = malloc(buffer_size);
uint64_t file_size = storage_file_size(file);
printf("Size: %lu\r\n", (uint32_t)file_size);
if(buffer_size) {
uint8_t* data = malloc(buffer_size);
while(file_size > 0) {
printf("\r\nReady?\r\n");
cli_getc(cli);
while(file_size > 0) {
printf("\r\nReady?\r\n");
cli_getc(cli);
uint16_t read_size = storage_file_read(file, data, buffer_size);
for(uint16_t i = 0; i < read_size; i++) {
putchar(data[i]);
}
file_size -= read_size;
uint16_t read_size = storage_file_read(file, data, buffer_size);
for(uint16_t i = 0; i < read_size; i++) {
putchar(data[i]);
}
free(data);
file_size -= read_size;
}
printf("\r\n");
free(data);
} else {
storage_cli_print_error(storage_file_get_error(file));
}
@@ -317,21 +315,19 @@ static void storage_cli_write_chunk(Cli* cli, string_t path, string_t args) {
if(storage_file_open(file, string_get_cstr(path), FSAM_WRITE, FSOM_OPEN_APPEND)) {
printf("Ready\r\n");
if(buffer_size) {
uint8_t* buffer = malloc(buffer_size);
uint8_t* buffer = malloc(buffer_size);
for(uint32_t i = 0; i < buffer_size; i++) {
buffer[i] = cli_getc(cli);
}
uint16_t written_size = storage_file_write(file, buffer, buffer_size);
if(written_size != buffer_size) {
storage_cli_print_error(storage_file_get_error(file));
}
free(buffer);
for(uint32_t i = 0; i < buffer_size; i++) {
buffer[i] = cli_getc(cli);
}
uint16_t written_size = storage_file_write(file, buffer, buffer_size);
if(written_size != buffer_size) {
storage_cli_print_error(storage_file_get_error(file));
}
free(buffer);
} else {
storage_cli_print_error(storage_file_get_error(file));
}

1
applications/tetris_game/tetris_game.c
View File

@@ -354,6 +354,7 @@ int32_t tetris_game_app() {
ValueMutex state_mutex;
if(!init_mutex(&state_mutex, tetris_state, sizeof(TetrisState))) {
FURI_LOG_E("TetrisGame", "cannot create mutex\r\n");
furi_message_queue_free(event_queue);
free(tetris_state);
return 255;
}

2
applications/tictactoe_game/tictactoe_game.c
View File

@@ -310,8 +310,8 @@ int32_t tictactoe_game_app(void* p) {
ValueMutex state_mutex;
if(!init_mutex(&state_mutex, tictactoe_state, sizeof(TicTacToeState))) {
FURI_LOG_E(TAG, "Cannot create mutex\r\n");
free(tictactoe_state);
furi_message_queue_free(event_queue);
free(tictactoe_state);
return 255;
}

4
lib/toolbox/path.c
View File

@@ -85,10 +85,6 @@ void path_concat(const char* path, const char* suffix, string_t out_path) {
}
bool path_contains_only_ascii(const char* path) {
if(!path) {
return false;
}
const char* name_pos = strrchr(path, '/');
if(name_pos == NULL) {
name_pos = path;