-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
- Loading branch information
Showing
5 changed files
with
124 additions
and
205 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,116 +1,150 @@ | ||
| #include "cli_control.h" | ||
|
|
||
| #include <FreeRTOS.h> | ||
| #include <cli/cli.h> | ||
| #include <cli/cli_i.h> | ||
| #include <cli/cli_vcp.h> | ||
| #include "cligui_main_i.h" | ||
| #include <FreeRTOS.h> | ||
| #include <loader/loader.h> | ||
| #include <loader/loader_i.h> | ||
|
|
||
| volatile bool gotCallbackSet = false; | ||
| FuriStreamBuffer* cli_tx_stream = NULL; | ||
| FuriStreamBuffer* cli_rx_stream = NULL; | ||
|
|
||
| static volatile bool restore_tx_stdout = false; | ||
|
|
||
| FuriStreamBuffer* tx_stream; | ||
| FuriStreamBuffer* rx_stream; | ||
| static FuriThread* volatile cliThread = NULL; | ||
| static FuriThread* prev_appthread = NULL; | ||
| static void tx_handler_stdout(const char* buffer, size_t size) { | ||
| furi_stream_buffer_send(tx_stream, buffer, size, FuriWaitForever); | ||
| } | ||
| static void tx_handler(const uint8_t* buffer, size_t size) { | ||
| furi_thread_set_stdout_callback(tx_handler_stdout); | ||
| cliThread = furi_thread_get_current(); | ||
| furi_stream_buffer_send(tx_stream, buffer, size, FuriWaitForever); | ||
| furi_stream_buffer_send(cli_tx_stream, buffer, size, FuriWaitForever); | ||
| } | ||
|
|
||
| static void tx_handler_stdout(const char* buffer, size_t size) { | ||
| tx_handler((const uint8_t*)buffer, size); | ||
| } | ||
|
|
||
| static size_t real_rx_handler(uint8_t* buffer, size_t size, uint32_t timeout) { | ||
| size_t rx_cnt = 0; | ||
| while(size > 0) { | ||
| while (size > 0) { | ||
| size_t batch_size = size; | ||
| if(batch_size > 128) batch_size = 128; | ||
| size_t len = furi_stream_buffer_receive(rx_stream, buffer, batch_size, timeout); | ||
| if(len == 0) break; | ||
| if (batch_size > 128) | ||
| batch_size = 128; | ||
| size_t len = furi_stream_buffer_receive(cli_rx_stream, buffer, batch_size, timeout); | ||
| if (len == 0) | ||
| break; | ||
| size -= len; | ||
| buffer += len; | ||
| rx_cnt += len; | ||
| } | ||
| if (restore_tx_stdout) { | ||
| furi_thread_set_stdout_callback(cli_vcp.tx_stdout); | ||
| } else { | ||
| furi_thread_set_stdout_callback(tx_handler_stdout); | ||
| } | ||
| return rx_cnt; | ||
| } | ||
|
|
||
| static CliCommand_internal* getInternalCliCommand(Cli* cli, const char* name) { | ||
| FuriString* target_command = furi_string_alloc(); | ||
| furi_string_set_str(target_command, name); | ||
| CliCommand_internal* command = | ||
| CliCommandTree_internal_get(((Cli_internal*)cli)->commands, target_command); | ||
| furi_string_free(target_command); | ||
| return command; | ||
| } | ||
| static CliSession* session; | ||
|
|
||
| static void session_init(void) { | ||
| } | ||
| static void session_init(void) {} | ||
| static void session_deinit(void) { | ||
| free(session); | ||
| session = NULL; | ||
| } | ||
|
|
||
| static bool session_connected(void) { | ||
| return true; | ||
| } | ||
| static CliSession session; | ||
| void latch_tx_handler() { | ||
|
|
||
| void clicontrol_hijack(size_t tx_size, size_t rx_size) { | ||
| if (cli_rx_stream != NULL && cli_tx_stream != NULL) { | ||
| return; | ||
| } | ||
|
|
||
| Cli* global_cli = furi_record_open(RECORD_CLI); | ||
|
|
||
| CliCommand_internal* help_command = getInternalCliCommand(global_cli, "help"); | ||
| cliThread = help_command->context; | ||
| cli_rx_stream = furi_stream_buffer_alloc(rx_size, 1); | ||
| cli_tx_stream = furi_stream_buffer_alloc(tx_size, 1); | ||
|
|
||
| furi_thread_set_stdout_callback(tx_handler_stdout); | ||
| if(cliThread != NULL) { | ||
| ((FuriThread_internal*)cliThread)->output.write_callback = &tx_handler_stdout; | ||
| } | ||
| session = (CliSession*)malloc(sizeof(CliSession)); | ||
| session->tx = &tx_handler; | ||
| session->rx = &real_rx_handler; | ||
| session->tx_stdout = &tx_handler_stdout; | ||
| session->init = &session_init; | ||
| session->deinit = &session_deinit; | ||
| session->is_connected = &session_connected; | ||
|
|
||
| rx_stream = furi_stream_buffer_alloc(128, 1); | ||
| tx_stream = furi_stream_buffer_alloc(128, 1); | ||
| CliCommandTree_it_t cmd_iterator; | ||
| for (CliCommandTree_it(cmd_iterator, global_cli->commands); | ||
| !CliCommandTree_end_p(cmd_iterator); | ||
| CliCommandTree_next(cmd_iterator)) { | ||
| CliCommand* t = CliCommandTree_cref(cmd_iterator)->value_ptr; | ||
| // Move CliCommandFlagParallelSafe to another bit | ||
| t->flags ^= ((t->flags & (CliCommandFlagParallelSafe << 8)) ^ | ||
| ((t->flags & CliCommandFlagParallelSafe) << 8)); | ||
| // Set parallel safe | ||
| t->flags |= CliCommandFlagParallelSafe; | ||
| } | ||
|
|
||
| session.tx = &tx_handler; | ||
| session.rx = &real_rx_handler; | ||
| session.tx_stdout = &tx_handler_stdout; | ||
| session.init = &session_init; | ||
| session.deinit = &session_deinit; | ||
| session.is_connected = &session_connected; | ||
| // Session switcharooney | ||
| FuriThreadStdoutWriteCallback prev_stdout = furi_thread_get_stdout_callback(); | ||
| cli_session_close(global_cli); | ||
| cli_session_open(global_cli, &session); | ||
| // Unlock loader-lock | ||
| Loader* loader = furi_record_open(RECORD_LOADER); | ||
| Loader_internal* loader_i = (Loader_internal*)loader; | ||
| prev_appthread = loader_i->app.thread; | ||
| loader_i->app.thread = NULL; | ||
| furi_record_close(RECORD_LOADER); | ||
| restore_tx_stdout = false; | ||
| cli_session_open(global_cli, session); | ||
| furi_thread_set_stdout_callback(prev_stdout); | ||
|
|
||
| furi_record_close(RECORD_CLI); | ||
| } | ||
| void unlatch_tx_handler(bool persist) { | ||
| Cli* global_cli = furi_record_open(RECORD_CLI); | ||
| // Stash cliThread if not null | ||
| if(cliThread != NULL) { | ||
| CliCommand_internal* help_command = getInternalCliCommand(global_cli, "help"); | ||
| help_command->context = cliThread; | ||
|
|
||
| void clicontrol_unhijack(bool persist) { | ||
| if (cli_rx_stream == NULL && cli_tx_stream == NULL) { | ||
| return; | ||
| } | ||
| // Switch to new session | ||
| if(persist) { | ||
| // Use dummy debug firmware function as is_connected | ||
|
|
||
| // Consume remaining tx data | ||
| if (furi_stream_buffer_bytes_available(cli_tx_stream) > 0) { | ||
| char sink = 0; | ||
| while (!furi_stream_buffer_is_empty(cli_tx_stream)) { | ||
| furi_stream_buffer_receive(cli_tx_stream, &sink, 1, FuriWaitForever); | ||
| } | ||
| } | ||
|
|
||
| Cli* global_cli = furi_record_open(RECORD_CLI); | ||
|
|
||
| if (persist) { | ||
| // Don't trigger a terminal reset as the session switches | ||
| cli_vcp.is_connected = &furi_hal_version_do_i_belong_here; | ||
| } else { | ||
| // Send CTRL-C | ||
| // Send CTRL-C a few times | ||
| char eot = 0x03; | ||
| furi_stream_buffer_send(rx_stream, &eot, 1, FuriWaitForever); | ||
| furi_stream_buffer_send(cli_rx_stream, &eot, 1, FuriWaitForever); | ||
| furi_stream_buffer_send(cli_rx_stream, &eot, 1, FuriWaitForever); | ||
| furi_stream_buffer_send(cli_rx_stream, &eot, 1, FuriWaitForever); | ||
| } | ||
|
|
||
| // Restore command flags | ||
| CliCommandTree_it_t cmd_iterator; | ||
| for (CliCommandTree_it(cmd_iterator, global_cli->commands); | ||
| !CliCommandTree_end_p(cmd_iterator); | ||
| CliCommandTree_next(cmd_iterator)) { | ||
| CliCommand* t = CliCommandTree_cref(cmd_iterator)->value_ptr; | ||
| t->flags ^= (((t->flags & CliCommandFlagParallelSafe) >> 8) ^ | ||
| ((t->flags & (CliCommandFlagParallelSafe << 8)) >> 8)); | ||
| } | ||
|
|
||
| restore_tx_stdout = true; // Ready for next rx call | ||
|
|
||
| // Session switcharooney again | ||
| FuriThreadStdoutWriteCallback prev_stdout = furi_thread_get_stdout_callback(); | ||
| cli_session_close(global_cli); | ||
| cli_session_open(global_cli, &cli_vcp); | ||
| furi_thread_set_stdout_callback(prev_stdout); | ||
| furi_record_close(RECORD_CLI); | ||
| // Unblock waiting rx handler | ||
| furi_stream_buffer_send(rx_stream, "_", 1, FuriWaitForever); | ||
| // Reconfigure stdout_callback to cli_vcp | ||
| if(cliThread != NULL) { | ||
| ((FuriThread_internal*)cliThread)->output.write_callback = cli_vcp.tx_stdout; | ||
| } | ||
| // At this point, all cli_vcp functions should be back. | ||
| furi_stream_buffer_free(rx_stream); | ||
| furi_stream_buffer_free(tx_stream); | ||
| // Re-lock loader (to avoid crash on automatic unlock) | ||
| Loader* loader = furi_record_open(RECORD_LOADER); | ||
| Loader_internal* loader_i = (Loader_internal*)loader; | ||
| loader_i->app.thread = prev_appthread; | ||
| furi_record_close(RECORD_LOADER); | ||
|
|
||
| // Unblock waiting rx handler, restore old cli_vcp.tx_stdout | ||
| furi_stream_buffer_send(cli_rx_stream, "_", 1, FuriWaitForever); | ||
|
|
||
| // At this point, all cli_vcp functions should be restored. | ||
|
|
||
| furi_stream_buffer_free(cli_rx_stream); | ||
| furi_stream_buffer_free(cli_tx_stream); | ||
| cli_rx_stream = NULL; | ||
| cli_tx_stream = NULL; | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.