From 1fad89aafb26179e0bfa3ee35eee1d3c9867fff1 Mon Sep 17 00:00:00 2001 From: "Roland C. Dowdeswell" Date: Wed, 20 Sep 2023 17:32:20 +0100 Subject: [PATCH] CI: enable clang-format and fix the files To review this commit, go to the directly previous commit, edit .pre-commit-config.yaml to uncomment the same things that were uncommented in this commit, exec pre-commit run --all-files, and diff against this commit. In short: ``` :; COMMIT=$(git rev-parse HEAD) :; git checkout HEAD~ :; git diff $COMMIT -- .pre-commit-config.yaml | patch -p1 -R :; pre-commit run --all-files :; git diff $COMMIT ``` To get back to your tree: ``` :; git reset --hard $COMMIT :; git checkout - ``` --- .pre-commit-config.yaml | 10 +- app/src/apdu.c | 22 +- app/src/apdu.h | 4 +- app/src/apdu_pubkey.c | 70 ++- app/src/apdu_sign.c | 180 ++++--- app/src/apdu_sign.h | 8 +- app/src/app_main.c | 19 +- app/src/compat.h | 6 +- app/src/exception.h | 99 ++-- app/src/globals.c | 16 +- app/src/globals.h | 23 +- app/src/keys.c | 111 ++--- app/src/keys.h | 18 +- app/src/parser/compat.h | 40 +- app/src/parser/formatting.c | 421 ++++++++-------- app/src/parser/formatting.h | 310 ++++++------ app/src/parser/micheline_parser.c | 183 +++---- app/src/parser/micheline_parser.h | 2 +- app/src/parser/micheline_state.h | 35 +- app/src/parser/num_parser.c | 53 ++- app/src/parser/num_parser.h | 9 +- app/src/parser/num_state.h | 6 +- app/src/parser/operation_parser.c | 712 +++++++++++++++------------- app/src/parser/operation_parser.h | 4 +- app/src/parser/operation_state.h | 57 ++- app/src/parser/parser_state.c | 69 ++- app/src/parser/parser_state.h | 73 +-- app/src/ui_commons.h | 18 +- app/src/ui_home.c | 35 +- app/src/ui_home_nbgl.c | 91 ++-- app/src/ui_settings.c | 8 +- app/src/ui_settings.h | 2 +- app/src/ui_stream.c | 217 +++++---- app/src/ui_stream.h | 54 +-- app/src/ui_stream_nbgl.c | 26 +- app/src/utils.h | 38 +- tests/unit/micheline_cparse_stubs.c | 287 +++++------ 37 files changed, 1790 insertions(+), 1546 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index ace7b2d4f..f5fd03ab5 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -11,8 +11,8 @@ repos: - id: check-yaml - id: check-added-large-files -# - repo: https://github.com/pre-commit/mirrors-clang-format -# rev: v16.0.6 -# hooks: -# - id: clang-format -# types_or: [c] + - repo: https://github.com/pre-commit/mirrors-clang-format + rev: v16.0.6 + hooks: + - id: clang-format + types_or: [c] diff --git a/app/src/apdu.c b/app/src/apdu.c index 77bc9c74f..9b97fc4a3 100644 --- a/app/src/apdu.c +++ b/app/src/apdu.c @@ -27,14 +27,12 @@ #include "apdu.h" #include "globals.h" -const uint8_t version[4] = { - 0 /* wallet */, - MAJOR_VERSION, - MINOR_VERSION, - PATCH_VERSION -}; - -void handle_unimplemented(__attribute__((unused))command_t *cmd) { +const uint8_t version[4] + = {0 /* wallet */, MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION}; + +void +handle_unimplemented(__attribute__((unused)) command_t *cmd) +{ TZ_PREAMBLE(("cmd=0x%p", cmd)); PRINTF("[ERROR] Unimplemented instruction 0x%02x\n", cmd->ins); @@ -42,7 +40,9 @@ void handle_unimplemented(__attribute__((unused))command_t *cmd) { TZ_POSTAMBLE; } -void handle_apdu_version(__attribute__((unused))command_t *cmd) { +void +handle_apdu_version(__attribute__((unused)) command_t *cmd) +{ TZ_PREAMBLE(("cmd=0x%p", cmd)); TZ_ASSERT(EXC_UNEXPECTED_STATE, global.step == ST_IDLE); @@ -50,7 +50,9 @@ void handle_apdu_version(__attribute__((unused))command_t *cmd) { TZ_POSTAMBLE; } -void handle_apdu_git(__attribute__((unused))command_t *cmd) { +void +handle_apdu_git(__attribute__((unused)) command_t *cmd) +{ static const char commit[] = COMMIT; TZ_PREAMBLE(("cmd=0x%p", cmd)); diff --git a/app/src/apdu.h b/app/src/apdu.h index 06edcd01b..15e5e7521 100644 --- a/app/src/apdu.h +++ b/app/src/apdu.h @@ -47,7 +47,7 @@ #define INS_SIGN_WITH_HASH 0x0F // Last valid instruction code -#define INS_MAX 0x0F +#define INS_MAX 0x0F /* * All of the handlers must be defined together below. We @@ -82,7 +82,7 @@ * */ -typedef void (tz_handler)(command_t *); +typedef void(tz_handler)(command_t *); typedef tz_handler *tz_handler_t; tz_handler handle_unimplemented; diff --git a/app/src/apdu_pubkey.c b/app/src/apdu_pubkey.c index 5f03cde25..539189e6d 100644 --- a/app/src/apdu_pubkey.c +++ b/app/src/apdu_pubkey.c @@ -37,16 +37,19 @@ static void prompt_address(void); static void format_pkh(char *); static void stream_cb(tz_ui_cb_type_t); -static void provide_pubkey(void) { - buffer_t bufs[2] = {0}; - uint8_t byte; +static void +provide_pubkey(void) +{ + buffer_t bufs[2] = {0}; + uint8_t byte; cx_ecfp_public_key_t pubkey; TZ_PREAMBLE(("void")); // Application could be PIN-locked, and pubkey->W_len would then be 0, // so throwing an error rather than returning an empty key TZ_ASSERT(EXC_SECURITY, os_global_pin_is_validated() == BOLOS_UX_OK); - TZ_CHECK(generate_public_key(&pubkey, global.path_with_curve.derivation_type, + TZ_CHECK(generate_public_key(&pubkey, + global.path_with_curve.derivation_type, &global.path_with_curve.bip32_path)); byte = pubkey.W_len; @@ -60,12 +63,15 @@ static void provide_pubkey(void) { TZ_POSTAMBLE; } -static void format_pkh(char *buffer) { +static void +format_pkh(char *buffer) +{ cx_ecfp_public_key_t pubkey = {0}; - uint8_t hash[21]; + uint8_t hash[21]; TZ_PREAMBLE(("buffer=%p", buffer)); - TZ_CHECK(generate_public_key(&pubkey, global.path_with_curve.derivation_type, + TZ_CHECK(generate_public_key(&pubkey, + global.path_with_curve.derivation_type, &global.path_with_curve.bip32_path)); // clang-format off TZ_CHECK(public_key_hash(hash+1, 20, NULL, @@ -83,7 +89,9 @@ static void format_pkh(char *buffer) { TZ_POSTAMBLE; } -static void stream_cb(tz_ui_cb_type_t type) { +static void +stream_cb(tz_ui_cb_type_t type) +{ TZ_PREAMBLE(("type=%u", type)); // clang-format off @@ -98,7 +106,9 @@ static void stream_cb(tz_ui_cb_type_t type) { } #ifdef HAVE_BAGL -static void prompt_address(void) { +static void +prompt_address(void) +{ char buf[TZ_UI_STREAM_CONTENTS_SIZE + 1]; TZ_PREAMBLE(("void")); @@ -117,25 +127,33 @@ static void prompt_address(void) { #include "nbgl_use_case.h" -static void cancel_callback(void) { +static void +cancel_callback(void) +{ stream_cb(TZ_UI_STREAM_CB_REJECT); nbgl_useCaseStatus("Address rejected", false, ui_home_init); } -static void approve_callback(void) { +static void +approve_callback(void) +{ stream_cb(TZ_UI_STREAM_CB_ACCEPT); nbgl_useCaseStatus("ADDRESS\nVERIFIED", true, ui_home_init); } -static void confirmation_callback(bool confirm) { +static void +confirmation_callback(bool confirm) +{ if (confirm) { - approve_callback(); + approve_callback(); } else { - cancel_callback(); + cancel_callback(); } } -static void verify_address(void) { +static void +verify_address(void) +{ char buf[TZ_UI_STREAM_CONTENTS_SIZE + 1]; TZ_PREAMBLE(("void")); @@ -144,16 +162,21 @@ static void verify_address(void) { TZ_POSTAMBLE; } -static void prompt_address(void) { +static void +prompt_address(void) +{ TZ_PREAMBLE(("void")); global.step = ST_PROMPT; - nbgl_useCaseReviewStart(&C_tezos, "Verify Tezos\naddress", NULL, "Cancel", verify_address, cancel_callback); + nbgl_useCaseReviewStart(&C_tezos, "Verify Tezos\naddress", NULL, "Cancel", + verify_address, cancel_callback); TZ_POSTAMBLE; } #endif -void handle_apdu_get_public_key(command_t *cmd) { +void +handle_apdu_get_public_key(command_t *cmd) +{ bool prompt = cmd->ins == INS_PROMPT_PUBLIC_KEY; TZ_PREAMBLE(("cmd=%p", cmd)); @@ -162,17 +185,18 @@ void handle_apdu_get_public_key(command_t *cmd) { // do not expose pks without prompt through U2F (permissionless legacy // comm in browser) - TZ_ASSERT(EXC_HID_REQUIRED, prompt || G_io_apdu_media != IO_APDU_MEDIA_U2F); + TZ_ASSERT(EXC_HID_REQUIRED, + prompt || G_io_apdu_media != IO_APDU_MEDIA_U2F); global.path_with_curve.derivation_type = cmd->p2; TZ_ASSERT(EXC_WRONG_PARAM, check_derivation_type(global.path_with_curve.derivation_type)); - TZ_CHECK(read_bip32_path(&global.path_with_curve.bip32_path, - cmd->data, cmd->lc)); + TZ_CHECK(read_bip32_path(&global.path_with_curve.bip32_path, cmd->data, + cmd->lc)); if (prompt) - prompt_address(); + prompt_address(); else - provide_pubkey(); + provide_pubkey(); TZ_POSTAMBLE; } diff --git a/app/src/apdu_sign.c b/app/src/apdu_sign.c index 502646474..e3c6d2b50 100644 --- a/app/src/apdu_sign.c +++ b/app/src/apdu_sign.c @@ -46,8 +46,8 @@ typedef struct { command_t cmd; - bool is_last; - bool is_first; + bool is_last; + bool is_first; } packet_t; /* Prototypes */ @@ -66,7 +66,6 @@ static void handle_data_apdu(packet_t *); static void handle_data_apdu_clear(packet_t *); static void handle_data_apdu_blind(packet_t *); - /* Macros */ #define P1_FIRST 0x00 @@ -76,11 +75,13 @@ static void handle_data_apdu_blind(packet_t *); #define TZ_UI_STREAM_CB_CANCEL 0xf0 -#define APDU_SIGN_ASSERT(_cond) TZ_ASSERT(EXC_UNEXPECTED_SIGN_STATE, (_cond)) -#define APDU_SIGN_ASSERT_STEP(x) APDU_SIGN_ASSERT(global.apdu.sign.step == (x)) - +#define APDU_SIGN_ASSERT(_cond) TZ_ASSERT(EXC_UNEXPECTED_SIGN_STATE, (_cond)) +#define APDU_SIGN_ASSERT_STEP(x) \ + APDU_SIGN_ASSERT(global.apdu.sign.step == (x)) -static void init_packet(packet_t *pkt, command_t *cmd) { +static void +init_packet(packet_t *pkt, command_t *cmd) +{ pkt->cmd.cla = cmd->cla; pkt->cmd.ins = cmd->ins; pkt->cmd.p1 = cmd->p1; @@ -91,10 +92,11 @@ static void init_packet(packet_t *pkt, command_t *cmd) { pkt->is_first = (cmd->p1 & ~P1_LAST_MARKER) == 0; } - -static void sign_packet(void) { +static void +sign_packet(void) +{ buffer_t bufs[2] = {0}; - uint8_t sig[MAX_SIGNATURE_SIZE]; + uint8_t sig[MAX_SIGNATURE_SIZE]; TZ_PREAMBLE(("void")); APDU_SIGN_ASSERT_STEP(SIGN_ST_WAIT_USER_INPUT); @@ -105,8 +107,8 @@ static void sign_packet(void) { bufs[1].ptr = sig; bufs[1].size = sizeof(sig); TZ_CHECK(sign(global.path_with_curve.derivation_type, - &global.path_with_curve.bip32_path, - bufs[0].ptr, bufs[0].size, sig, &bufs[1].size)); + &global.path_with_curve.bip32_path, bufs[0].ptr, + bufs[0].size, sig, &bufs[1].size)); /* If we aren't returning the hash, zero its buffer... */ if (!global.apdu.sign.return_hash) @@ -118,7 +120,9 @@ static void sign_packet(void) { TZ_POSTAMBLE; } -static void send_reject(void) { +static void +send_reject(void) +{ TZ_PREAMBLE(("void")); APDU_SIGN_ASSERT_STEP(SIGN_ST_WAIT_USER_INPUT); @@ -127,11 +131,13 @@ static void send_reject(void) { TZ_POSTAMBLE; } -static void send_continue(void) { +static void +send_continue(void) +{ TZ_PREAMBLE(("void")); - APDU_SIGN_ASSERT(global.apdu.sign.step == SIGN_ST_WAIT_USER_INPUT || - global.apdu.sign.step == SIGN_ST_WAIT_DATA); + APDU_SIGN_ASSERT(global.apdu.sign.step == SIGN_ST_WAIT_USER_INPUT + || global.apdu.sign.step == SIGN_ST_WAIT_DATA); APDU_SIGN_ASSERT(!global.apdu.sign.received_last_msg); io_send_sw(SW_OK); @@ -140,9 +146,11 @@ static void send_continue(void) { TZ_POSTAMBLE; } -static void refill() { - size_t wrote = 0; - tz_parser_state *st = &global.apdu.sign.u.clear.parser_state; +static void +refill() +{ + size_t wrote = 0; + tz_parser_state *st = &global.apdu.sign.u.clear.parser_state; TZ_PREAMBLE(("void")); while (!TZ_IS_BLOCKED(tz_operation_parser_step(st))) @@ -155,8 +163,8 @@ static void refill() { wrote = tz_ui_stream_push(TZ_UI_STREAM_CB_NOCB, st->field_name, global.line_buf, TZ_UI_ICON_NONE); - tz_parser_flush_up_to(st, global.line_buf, - TZ_UI_STREAM_CONTENTS_SIZE, wrote); + tz_parser_flush_up_to(st, global.line_buf, TZ_UI_STREAM_CONTENTS_SIZE, + wrote); break; case TZ_BLO_FEED_ME: TZ_CHECK(send_continue()); @@ -165,15 +173,13 @@ static void refill() { TZ_ASSERT(EXC_UNEXPECTED_STATE, global.apdu.sign.received_last_msg && st->regs.ilen == 0); if (st->regs.oofs != 0) - goto last_screen; + goto last_screen; global.apdu.sign.step = SIGN_ST_WAIT_USER_INPUT; tz_ui_stream_push_accept_reject(); tz_ui_stream_close(); break; case TZ_ERR_INVALID_STATE: - tz_ui_stream_push(TZ_UI_STREAM_CB_CANCEL, - "Unknown error", - "", + tz_ui_stream_push(TZ_UI_STREAM_CB_CANCEL, "Unknown error", "", TZ_UI_ICON_CROSS); tz_ui_stream_close(); break; @@ -182,10 +188,8 @@ static void refill() { case TZ_ERR_UNSUPPORTED: case TZ_ERR_TOO_LARGE: case TZ_ERR_TOO_DEEP: - tz_ui_stream_push(TZ_UI_STREAM_CB_CANCEL, - "Parsing error", - tz_parser_result_name(st->errno), - TZ_UI_ICON_CROSS); + tz_ui_stream_push(TZ_UI_STREAM_CB_CANCEL, "Parsing error", + tz_parser_result_name(st->errno), TZ_UI_ICON_CROSS); tz_ui_stream_close(); break; default: @@ -195,11 +199,13 @@ static void refill() { TZ_POSTAMBLE; } -static void send_cancel(void) { +static void +send_cancel(void) +{ tz_parser_state *st = &global.apdu.sign.u.clear.parser_state; TZ_PREAMBLE(("void")); - global.step = ST_IDLE; + global.step = ST_IDLE; global.apdu.sign.step = SIGN_ST_IDLE; switch (st->errno) { @@ -220,7 +226,9 @@ static void send_cancel(void) { TZ_POSTAMBLE; } -static void stream_cb(tz_ui_cb_type_t type) { +static void +stream_cb(tz_ui_cb_type_t type) +{ TZ_PREAMBLE(("type=%u", type)); // clang-format off @@ -236,14 +244,16 @@ static void stream_cb(tz_ui_cb_type_t type) { TZ_POSTAMBLE; } -static void handle_first_apdu(packet_t *pkt) { +static void +handle_first_apdu(packet_t *pkt) +{ TZ_PREAMBLE(("pkt=%p", pkt)); TZ_ASSERT_NOTNULL(pkt); APDU_SIGN_ASSERT_STEP(SIGN_ST_IDLE); - TZ_CHECK(read_bip32_path(&global.path_with_curve.bip32_path, pkt->cmd.data, - pkt->cmd.lc)); + TZ_CHECK(read_bip32_path(&global.path_with_curve.bip32_path, + pkt->cmd.data, pkt->cmd.lc)); global.path_with_curve.derivation_type = pkt->cmd.p2; TZ_CHECK(check_derivation_type(global.path_with_curve.derivation_type)); TZ_CHECK(cx_blake2b_init_no_throw(&global.apdu.hash.state, @@ -264,7 +274,9 @@ static void handle_first_apdu(packet_t *pkt) { TZ_POSTAMBLE; } -static void handle_first_apdu_clear(__attribute__((unused)) packet_t *pkt) { +static void +handle_first_apdu_clear(__attribute__((unused)) packet_t *pkt) +{ tz_parser_state *st = &global.apdu.sign.u.clear.parser_state; tz_operation_parser_init(st, TZ_UNKNOWN_SIZE, false); @@ -272,8 +284,9 @@ static void handle_first_apdu_clear(__attribute__((unused)) packet_t *pkt) { tz_parser_flush(st, global.line_buf, TZ_UI_STREAM_CONTENTS_SIZE); } -static void handle_first_apdu_blind(__attribute__((unused)) packet_t *pkt) { - +static void +handle_first_apdu_blind(__attribute__((unused)) packet_t *pkt) +{ /* * We set the tag to zero here which indicates that it is unset. * The first data packet will set it to the first byte. @@ -285,18 +298,19 @@ static void handle_first_apdu_blind(__attribute__((unused)) packet_t *pkt) { global.apdu.sign.u.blind.tag = 0; } -static void handle_data_apdu(packet_t *pkt) { +static void +handle_data_apdu(packet_t *pkt) +{ TZ_PREAMBLE(("pkt=%p", pkt)); APDU_SIGN_ASSERT_STEP(SIGN_ST_WAIT_DATA); TZ_ASSERT_NOTNULL(pkt); - global.apdu.sign.packet_index++; // XXX drop or check + global.apdu.sign.packet_index++; // XXX drop or check CX_CHECK(cx_hash_no_throw((cx_hash_t *)&global.apdu.hash.state, - pkt->is_last ? CX_LAST : 0, - pkt->cmd.data, pkt->cmd.lc, - global.apdu.hash.final_hash, + pkt->is_last ? CX_LAST : 0, pkt->cmd.data, + pkt->cmd.lc, global.apdu.hash.final_hash, sizeof(global.apdu.hash.final_hash))); if (pkt->is_last) @@ -313,7 +327,9 @@ static void handle_data_apdu(packet_t *pkt) { TZ_POSTAMBLE; } -static void handle_data_apdu_clear(packet_t *pkt) { +static void +handle_data_apdu_clear(packet_t *pkt) +{ tz_parser_state *st = &global.apdu.sign.u.clear.parser_state; TZ_PREAMBLE(("pkt=0x%p", pkt)); @@ -326,7 +342,8 @@ static void handle_data_apdu_clear(packet_t *pkt) { tz_parser_refill(st, pkt->cmd.data, pkt->cmd.lc); if (pkt->is_last) - tz_operation_parser_set_size(st, global.apdu.sign.u.clear.total_length); + tz_operation_parser_set_size(st, + global.apdu.sign.u.clear.total_length); TZ_CHECK(refill()); tz_ui_stream(); @@ -335,9 +352,11 @@ static void handle_data_apdu_clear(packet_t *pkt) { #ifdef HAVE_NBGL static nbgl_layoutTagValueList_t useCaseTagValueList; -static nbgl_pageInfoLongPress_t infoLongPress; +static nbgl_pageInfoLongPress_t infoLongPress; -void reject_blindsign_cb(void) { +void +reject_blindsign_cb(void) +{ FUNC_ENTER(("void")); stream_cb(TZ_UI_STREAM_CB_REJECT); @@ -346,7 +365,9 @@ void reject_blindsign_cb(void) { FUNC_LEAVE(); } -void accept_blindsign_cb(void) { +void +accept_blindsign_cb(void) +{ FUNC_ENTER(("void")); stream_cb(TZ_UI_STREAM_CB_ACCEPT); @@ -355,7 +376,9 @@ void accept_blindsign_cb(void) { FUNC_LEAVE(); } -static void reviewChoice(bool confirm) { +static void +reviewChoice(bool confirm) +{ FUNC_ENTER(("confirm=%d", confirm)); if (confirm) { @@ -367,17 +390,19 @@ static void reviewChoice(bool confirm) { FUNC_LEAVE(); } -static const char* transaction_type; +static const char *transaction_type; static char hash[TZ_BASE58_BUFFER_SIZE(sizeof(global.apdu.hash.final_hash))]; static nbgl_layoutTagValue_t pair; -static nbgl_layoutTagValue_t* getTagValuePair(uint8_t pairIndex) { +static nbgl_layoutTagValue_t * +getTagValuePair(uint8_t pairIndex) +{ switch (pairIndex) { case 0: - pair.item = "Type"; + pair.item = "Type"; pair.value = transaction_type; break; case 1: - pair.item = "Hash"; + pair.item = "Hash"; pair.value = hash; break; default: @@ -386,19 +411,22 @@ static nbgl_layoutTagValue_t* getTagValuePair(uint8_t pairIndex) { return &pair; } -void continue_blindsign_cb(void) { +void +continue_blindsign_cb(void) +{ FUNC_ENTER(("void")); - useCaseTagValueList.pairs = NULL; - useCaseTagValueList.callback = getTagValuePair; - useCaseTagValueList.startIndex = 0; - useCaseTagValueList.nbPairs = 2; + useCaseTagValueList.pairs = NULL; + useCaseTagValueList.callback = getTagValuePair; + useCaseTagValueList.startIndex = 0; + useCaseTagValueList.nbPairs = 2; useCaseTagValueList.smallCaseForValue = false; - useCaseTagValueList.wrapping = false; - infoLongPress.icon = &C_tezos; - infoLongPress.text = "Approve"; - infoLongPress.longPressText = "Sign"; - nbgl_useCaseStaticReview(&useCaseTagValueList, &infoLongPress, "Reject", reviewChoice); + useCaseTagValueList.wrapping = false; + infoLongPress.icon = &C_tezos; + infoLongPress.text = "Approve"; + infoLongPress.longPressText = "Sign"; + nbgl_useCaseStaticReview(&useCaseTagValueList, &infoLongPress, "Reject", + reviewChoice); FUNC_LEAVE(); } @@ -406,7 +434,9 @@ void continue_blindsign_cb(void) { #endif #define FINAL_HASH global.apdu.hash.final_hash -static void handle_data_apdu_blind(packet_t *pkt) { +static void +handle_data_apdu_blind(packet_t *pkt) +{ TZ_PREAMBLE(("pkt=0x%p", pkt)); TZ_ASSERT_NOTNULL(pkt); @@ -417,11 +447,11 @@ static void handle_data_apdu_blind(packet_t *pkt) { goto end; } - char obuf[TZ_BASE58_BUFFER_SIZE(sizeof(FINAL_HASH))]; + char obuf[TZ_BASE58_BUFFER_SIZE(sizeof(FINAL_HASH))]; const char *type = "unknown type"; global.apdu.sign.received_last_msg = true; - global.apdu.sign.step = SIGN_ST_WAIT_USER_INPUT; + global.apdu.sign.step = SIGN_ST_WAIT_USER_INPUT; tz_format_base58(FINAL_HASH, sizeof(FINAL_HASH), obuf); @@ -448,19 +478,15 @@ static void handle_data_apdu_blind(packet_t *pkt) { #ifdef HAVE_NBGL char request[80]; - snprintf(request, sizeof(request), "Review request to blind\nsign %s", type); + snprintf(request, sizeof(request), "Review request to blind\nsign %s", + type); global.apdu.sign.step = SIGN_ST_WAIT_USER_INPUT; transaction_type = type; strcpy(hash, obuf); - nbgl_useCaseReviewStart(&C_tezos, - request, - NULL, - "Reject request", - continue_blindsign_cb, - reject_blindsign_cb - ); + nbgl_useCaseReviewStart(&C_tezos, request, NULL, "Reject request", + continue_blindsign_cb, reject_blindsign_cb); #endif tz_ui_stream_close(); @@ -477,8 +503,10 @@ static void handle_data_apdu_blind(packet_t *pkt) { #define GET_HOME_SCREEN() global.home_screen #endif -void handle_apdu_sign(command_t *cmd) { - bool return_hash = cmd->ins == INS_SIGN_WITH_HASH; +void +handle_apdu_sign(command_t *cmd) +{ + bool return_hash = cmd->ins == INS_SIGN_WITH_HASH; packet_t pkt; TZ_PREAMBLE(("cmd=0x%p", cmd)); diff --git a/app/src/apdu_sign.h b/app/src/apdu_sign.h index 7dfa83e2a..c509c6bea 100644 --- a/app/src/apdu_sign.h +++ b/app/src/apdu_sign.h @@ -30,7 +30,7 @@ typedef struct { cx_blake2b_t state; - uint8_t final_hash[SIGN_HASH_SIZE]; + uint8_t final_hash[SIGN_HASH_SIZE]; } apdu_hash_state_t; typedef enum { @@ -43,12 +43,12 @@ typedef struct { uint8_t packet_index; sign_step_t step; - bool return_hash; - bool received_last_msg; + bool return_hash; + bool received_last_msg; union { struct { - size_t total_length; + size_t total_length; tz_parser_state parser_state; } clear; struct { diff --git a/app/src/app_main.c b/app/src/app_main.c index 065b72f3d..fca8d9fb4 100644 --- a/app/src/app_main.c +++ b/app/src/app_main.c @@ -30,11 +30,15 @@ #define CLA 0x80 -void app_exit(void) { +void +app_exit(void) +{ os_sched_exit(-1); } -static void dispatch(command_t *cmd) { +static void +dispatch(command_t *cmd) +{ tz_handler_t f; TZ_PREAMBLE(("cmd=0x%p {cla=0x02x ins=%u ...}", cmd, cmd->cla, cmd->ins)); @@ -78,10 +82,11 @@ static void dispatch(command_t *cmd) { TZ_POSTAMBLE; } - -void app_main() { +void +app_main() +{ command_t cmd; - int rx; + int rx; FUNC_ENTER(("void")); app_stack_canary = 0xDEADBEEF; @@ -99,9 +104,9 @@ void app_main() { PRINTF("[PTR] G_io_apdu_buffer: 0x%p\n", G_io_apdu_buffer); PRINTF("[SIZEOF] G_io_apdu_buffer: %u\n", sizeof(G_io_apdu_buffer)); PRINTF("[PTR] G_io_seproxyhal_spi_buffer: 0x%p\n", - G_io_seproxyhal_spi_buffer); + G_io_seproxyhal_spi_buffer); PRINTF("[SIZEOF] G_io_seproxyhal_spi_buffer: %u\n", - sizeof(G_io_seproxyhal_spi_buffer)); + sizeof(G_io_seproxyhal_spi_buffer)); PRINTF("[PTR] G_ux: 0x%p\n", &G_ux); PRINTF("[SIZEOF] G_ux: %u\n", sizeof(G_ux)); PRINTF("[PTR] G_ux_os: 0x%p\n", &G_ux_os); diff --git a/app/src/compat.h b/app/src/compat.h index 9a753e19d..04f3d84a3 100644 --- a/app/src/compat.h +++ b/app/src/compat.h @@ -11,13 +11,13 @@ #include -static inline int io_send_response_buffers(const buffer_t *rdatalist, - size_t count, uint16_t sw) +static inline int +io_send_response_buffers(const buffer_t *rdatalist, size_t count, uint16_t sw) { uint8_t buf[128]; size_t tx = 0; - for (size_t i=0; i < count; i++) { + for (size_t i = 0; i < count; i++) { memcpy(&buf[tx], rdatalist[i].ptr, rdatalist[i].size); tx += rdatalist[i].size; } diff --git a/app/src/exception.h b/app/src/exception.h index 9d2da3531..e97cd4e51 100644 --- a/app/src/exception.h +++ b/app/src/exception.h @@ -22,7 +22,7 @@ #include -#define SW_OK 0x9000 +#define SW_OK 0x9000 // Standard APDU error codes: // https://www.eftlab.co.uk/index.php/site-map/knowledge-base/118-apdu-response-list @@ -40,10 +40,10 @@ #define EXC_CLASS 0x6E00 #define EXC_MEMORY_ERROR 0x9200 -#define EXC_UNEXPECTED_STATE 0x9001 -#define EXC_UNEXPECTED_SIGN_STATE 0x9002 -#define EXC_UNKNOWN_CX_ERR 0x9003 -#define EXC_UNKNOWN 0x90FF +#define EXC_UNEXPECTED_STATE 0x9001 +#define EXC_UNEXPECTED_SIGN_STATE 0x9002 +#define EXC_UNKNOWN_CX_ERR 0x9003 +#define EXC_UNKNOWN 0x90FF /* * In the handlers and the routines that they call, we define a set of @@ -77,48 +77,51 @@ * with this framework, reply with io_send_sw() and return TZ_DONE. */ -#define TZ_PREAMBLE(_args) \ - uint16_t _sw_ret_code = 0x0000; \ - cx_err_t error = CX_OK; \ - if (0) \ - goto bail; \ - if (0) \ - goto end; \ - FUNC_ENTER(_args) - -#define TZ_POSTAMBLE \ - end: \ - if (error != CX_OK) { \ - _sw_ret_code = EXC_UNKNOWN_CX_ERR; \ - PRINTF("CX_CHECK failed with 0x%08x", error); \ - } \ - bail: \ - if (_sw_ret_code) { \ - global.step = ST_ERROR; \ - io_send_sw(_sw_ret_code); \ - } \ - FUNC_LEAVE(); - -#define TZ_FAIL(_sw_code) do { \ - _sw_ret_code = _sw_code; \ - goto bail; \ - } while (0) - -#define TZ_ASSERT(_err, _cond) do { \ - if (!(_cond)) { \ - PRINTF("Assertion (\"%s\") on %s:%u failed with %s\n", \ - #_cond, __FILE__, __LINE__, #_err); \ - TZ_FAIL(_err); \ - } \ - } while (0) - -#define TZ_CHECK(_call) do { \ - (_call); \ - if (global.step == ST_ERROR) { \ - PRINTF("TZ_CHECK(\"%s\") on %s:%u\n", #_call, \ - __FILE__, __LINE__); \ - goto bail; \ - } \ - } while (0) +#define TZ_PREAMBLE(_args) \ + uint16_t _sw_ret_code = 0x0000; \ + cx_err_t error = CX_OK; \ + if (0) \ + goto bail; \ + if (0) \ + goto end; \ + FUNC_ENTER(_args) + +#define TZ_POSTAMBLE \ + end: \ + if (error != CX_OK) { \ + _sw_ret_code = EXC_UNKNOWN_CX_ERR; \ + PRINTF("CX_CHECK failed with 0x%08x", error); \ + } \ + bail: \ + if (_sw_ret_code) { \ + global.step = ST_ERROR; \ + io_send_sw(_sw_ret_code); \ + } \ + FUNC_LEAVE(); + +#define TZ_FAIL(_sw_code) \ + do { \ + _sw_ret_code = _sw_code; \ + goto bail; \ + } while (0) + +#define TZ_ASSERT(_err, _cond) \ + do { \ + if (!(_cond)) { \ + PRINTF("Assertion (\"%s\") on %s:%u failed with %s\n", #_cond, \ + __FILE__, __LINE__, #_err); \ + TZ_FAIL(_err); \ + } \ + } while (0) + +#define TZ_CHECK(_call) \ + do { \ + (_call); \ + if (global.step == ST_ERROR) { \ + PRINTF("TZ_CHECK(\"%s\") on %s:%u\n", #_call, __FILE__, \ + __LINE__); \ + goto bail; \ + } \ + } while (0) #define TZ_ASSERT_NOTNULL(_x) TZ_ASSERT(EXC_MEMORY_ERROR, (_x) != NULL) diff --git a/app/src/globals.c b/app/src/globals.c index e5d5ba2d9..688b3b57c 100644 --- a/app/src/globals.c +++ b/app/src/globals.c @@ -28,20 +28,20 @@ globals_t global; const settings_t N_settings_real; -void init_globals(void) { +void +init_globals(void) +{ memset(&global, 0, sizeof(global)); memset(G_io_seproxyhal_spi_buffer, 0, sizeof(G_io_seproxyhal_spi_buffer)); memset(&G_ux, 0, sizeof(G_ux)); memset(&G_ux_params, 0, sizeof(G_ux_params)); } -void toggle_blindsigning(void) { +void +toggle_blindsigning(void) +{ settings_t tmp; - memcpy(&tmp, - (void*) &N_settings, - sizeof(tmp)); + memcpy(&tmp, (void *)&N_settings, sizeof(tmp)); tmp.blindsigning = !N_settings.blindsigning; - nvm_write((void*) &N_settings, - (void*) &tmp, - sizeof(N_settings)); + nvm_write((void *)&N_settings, (void *)&tmp, sizeof(N_settings)); } diff --git a/app/src/globals.h b/app/src/globals.h index 49bf72fa8..633d121fe 100644 --- a/app/src/globals.h +++ b/app/src/globals.h @@ -26,9 +26,9 @@ #define TZ_SCREEN_WITDH_FULL_REGULAR_11PX 19 #define TZ_SCREEN_WITDH_BETWEEN_ICONS_BOLD_11PX 16 #ifdef TARGET_NANOS -# define TZ_SCREEN_LINES_11PX 2 +#define TZ_SCREEN_LINES_11PX 2 #else -# define TZ_SCREEN_LINES_11PX 5 +#define TZ_SCREEN_LINES_11PX 5 #endif #include "apdu.h" @@ -70,34 +70,35 @@ typedef enum { typedef struct { /* State */ - main_step_t step; - tz_ui_stream_t stream; + main_step_t step; + tz_ui_stream_t stream; bip32_path_with_curve_t path_with_curve; struct { apdu_hash_state_t hash; apdu_sign_state_t sign; } apdu; char line_buf[TZ_UI_STREAM_CONTENTS_SIZE + 1]; -# ifdef HAVE_BAGL +#ifdef HAVE_BAGL struct { bagl_element_t bagls[5 + TZ_SCREEN_LINES_11PX]; - char lines[TZ_SCREEN_LINES_11PX][TZ_SCREEN_WITDH_FULL_REGULAR_11PX + 1]; + char lines[TZ_SCREEN_LINES_11PX] + [TZ_SCREEN_WITDH_FULL_REGULAR_11PX + 1]; } ux; -# endif -# ifdef HAVE_NBGL +#endif +#ifdef HAVE_NBGL screen_t home_screen; -# endif +#endif } globals_t; /* Settings */ typedef struct { - bool blindsigning; + bool blindsigning; } settings_t; extern globals_t global; extern const settings_t N_settings_real; -#define N_settings (*(volatile settings_t *) PIC(&N_settings_real)) +#define N_settings (*(volatile settings_t *)PIC(&N_settings_real)) extern unsigned int app_stack_canary; // From SDK diff --git a/app/src/keys.c b/app/src/keys.c index 6a9e299ac..a6ee51f0e 100644 --- a/app/src/keys.c +++ b/app/src/keys.c @@ -33,8 +33,9 @@ #include "keys.h" #include "globals.h" -static cx_curve_t derivation_type_to_cx_curve(derivation_type_t - derivation_type) { +static cx_curve_t +derivation_type_to_cx_curve(derivation_type_t derivation_type) +{ // clang-format off switch (derivation_type) { case DERIVATION_TYPE_ED25519: @@ -46,21 +47,24 @@ static cx_curve_t derivation_type_to_cx_curve(derivation_type_t // clang-format on } -void read_bip32_path(bip32_path_t *out, const uint8_t *in, - size_t in_size) { +void +read_bip32_path(bip32_path_t *out, const uint8_t *in, size_t in_size) +{ buffer_t cdata = {in, in_size, 0}; TZ_PREAMBLE(("out=%p, in=%p, in_size=%u", out, in, in_size)); TZ_ASSERT(EXC_WRONG_LENGTH_FOR_INS, - buffer_read_u8(&cdata, &out->length) && - buffer_read_bip32_path(&cdata, (uint32_t *) &out->components, - out->length)); + buffer_read_u8(&cdata, &out->length) + && buffer_read_bip32_path( + &cdata, (uint32_t *)&out->components, out->length)); TZ_POSTAMBLE; } -void generate_public_key(cx_ecfp_public_key_t *public_key, - derivation_type_t derivation_type, - const bip32_path_t *bip32_path) { +void +generate_public_key(cx_ecfp_public_key_t *public_key, + derivation_type_t derivation_type, + const bip32_path_t *bip32_path) +{ TZ_PREAMBLE(("public_key=%p, derivation_type=%d, bip32_path=%p", public_key, derivation_type, bip32_path)); @@ -69,21 +73,15 @@ void generate_public_key(cx_ecfp_public_key_t *public_key, int derivation_mode = HDW_NORMAL; if (derivation_type == DERIVATION_TYPE_ED25519) - derivation_mode = HDW_ED25519_SLIP10; + derivation_mode = HDW_ED25519_SLIP10; - CX_CHECK(bip32_derive_with_seed_get_pubkey_256(derivation_mode, - public_key->curve, - bip32_path->components, - bip32_path->length, - public_key->W, - NULL, - CX_SHA512, - NULL, 0)); + CX_CHECK(bip32_derive_with_seed_get_pubkey_256( + derivation_mode, public_key->curve, bip32_path->components, + bip32_path->length, public_key->W, NULL, CX_SHA512, NULL, 0)); if (public_key->curve == CX_CURVE_Ed25519) { - CX_CHECK(cx_edwards_compress_point_no_throw(CX_CURVE_Ed25519, - public_key->W, - public_key->W_len)); + CX_CHECK(cx_edwards_compress_point_no_throw( + CX_CURVE_Ed25519, public_key->W, public_key->W_len)); public_key->W_len = 33; } @@ -92,14 +90,17 @@ void generate_public_key(cx_ecfp_public_key_t *public_key, #define HASH_SIZE 20 -void public_key_hash(uint8_t *hash_out, size_t hash_out_size, - cx_ecfp_public_key_t *compressed_out, - derivation_type_t derivation_type, - const cx_ecfp_public_key_t *public_key) { - TZ_PREAMBLE(("hash_out=%p, hash_out_size=%u, compressed_out=%p, " - "derivation_type=%d, public_key=%p", - hash_out, hash_out_size, compressed_out, - derivation_type, public_key)); +void +public_key_hash(uint8_t *hash_out, size_t hash_out_size, + cx_ecfp_public_key_t *compressed_out, + derivation_type_t derivation_type, + const cx_ecfp_public_key_t *public_key) +{ + TZ_PREAMBLE( + ("hash_out=%p, hash_out_size=%u, compressed_out=%p, " + "derivation_type=%d, public_key=%p", + hash_out, hash_out_size, compressed_out, derivation_type, + public_key)); TZ_ASSERT_NOTNULL(hash_out); TZ_ASSERT_NOTNULL(public_key); @@ -115,7 +116,7 @@ void public_key_hash(uint8_t *hash_out, size_t hash_out_size, case DERIVATION_TYPE_SECP256K1: case DERIVATION_TYPE_SECP256R1: memcpy(compressed.W, public_key->W, public_key->W_len); - compressed.W[0] = 0x02 + (public_key->W[64] & 0x01); + compressed.W[0] = 0x02 + (public_key->W[64] & 0x01); compressed.W_len = 33; break; default: @@ -124,12 +125,8 @@ void public_key_hash(uint8_t *hash_out, size_t hash_out_size, cx_blake2b_t hash_state; CX_CHECK(cx_blake2b_init_no_throw(&hash_state, HASH_SIZE * 8)); - CX_CHECK(cx_hash_no_throw((cx_hash_t *) &hash_state, - CX_LAST, - compressed.W, - compressed.W_len, - hash_out, - HASH_SIZE)); + CX_CHECK(cx_hash_no_throw((cx_hash_t *)&hash_state, CX_LAST, compressed.W, + compressed.W_len, hash_out, HASH_SIZE)); if (compressed_out != NULL) { memmove(compressed_out, &compressed, sizeof(*compressed_out)); } @@ -137,16 +134,17 @@ void public_key_hash(uint8_t *hash_out, size_t hash_out_size, TZ_POSTAMBLE; } -void sign(derivation_type_t derivation_type, - const bip32_path_t *path, - const uint8_t *hash, size_t hashlen, - uint8_t *sig, size_t *siglen) { - unsigned derivation_mode; - uint32_t info; +void +sign(derivation_type_t derivation_type, const bip32_path_t *path, + const uint8_t *hash, size_t hashlen, uint8_t *sig, size_t *siglen) +{ + unsigned derivation_mode; + uint32_t info; cx_curve_t curve = derivation_type_to_cx_curve(derivation_type); - TZ_PREAMBLE(("sig=%p, siglen=%u, derivation_type=%d, " - "path=%p, hash=%p, hashlen=%u", - sig, *siglen, derivation_type, path, hash, hashlen)); + TZ_PREAMBLE( + ("sig=%p, siglen=%u, derivation_type=%d, " + "path=%p, hash=%p, hashlen=%u", + sig, *siglen, derivation_type, path, hash, hashlen)); TZ_ASSERT_NOTNULL(path); TZ_ASSERT_NOTNULL(hash); TZ_ASSERT_NOTNULL(sig); @@ -158,24 +156,15 @@ void sign(derivation_type_t derivation_type, derivation_mode = HDW_NORMAL; if (derivation_type == DERIVATION_TYPE_ED25519) derivation_mode = HDW_ED25519_SLIP10; - CX_CHECK(bip32_derive_with_seed_eddsa_sign_hash_256(derivation_mode, - curve, - path->components, - path->length, - CX_SHA512, - hash, hashlen, - sig, siglen, - NULL, 0)); + CX_CHECK(bip32_derive_with_seed_eddsa_sign_hash_256( + derivation_mode, curve, path->components, path->length, CX_SHA512, + hash, hashlen, sig, siglen, NULL, 0)); break; case DERIVATION_TYPE_SECP256K1: case DERIVATION_TYPE_SECP256R1: - CX_CHECK(bip32_derive_ecdsa_sign_hash_256(curve, - path->components, - path->length, - CX_RND_RFC6979 | CX_LAST, - CX_SHA256, - hash, hashlen, - sig, siglen, &info)); + CX_CHECK(bip32_derive_ecdsa_sign_hash_256( + curve, path->components, path->length, CX_RND_RFC6979 | CX_LAST, + CX_SHA256, hash, hashlen, sig, siglen, &info)); if (info & CX_ECCINFO_PARITY_ODD) sig[0] |= 0x01; break; diff --git a/app/src/keys.h b/app/src/keys.h index b77dc6aee..68bd58b60 100644 --- a/app/src/keys.h +++ b/app/src/keys.h @@ -31,26 +31,26 @@ #include "exception.h" -#define MAX_BIP32_LEN 10 +#define MAX_BIP32_LEN 10 #define SIGN_HASH_SIZE 32 /* The values in the following enum are from the on-the-wire protocol */ typedef enum { - DERIVATION_TYPE_ED25519 = 0, - DERIVATION_TYPE_SECP256K1 = 1, - DERIVATION_TYPE_SECP256R1 = 2, + DERIVATION_TYPE_ED25519 = 0, + DERIVATION_TYPE_SECP256K1 = 1, + DERIVATION_TYPE_SECP256R1 = 2, DERIVATION_TYPE_BIP32_ED25519 = 3, - DERIVATION_TYPE_MAX = 4 + DERIVATION_TYPE_MAX = 4 } derivation_type_t; typedef struct { - uint8_t length; + uint8_t length; uint32_t components[MAX_BIP32_LEN]; } bip32_path_t; typedef struct { - bip32_path_t bip32_path; + bip32_path_t bip32_path; derivation_type_t derivation_type; } bip32_path_with_curve_t; @@ -62,6 +62,8 @@ void public_key_hash(uint8_t *, size_t, cx_ecfp_public_key_t *, void sign(derivation_type_t, const bip32_path_t *, const uint8_t *, size_t, uint8_t *, size_t *); -static inline bool check_derivation_type(derivation_type_t code) { +static inline bool +check_derivation_type(derivation_type_t code) +{ return (code >= DERIVATION_TYPE_ED25519 && code < DERIVATION_TYPE_MAX); } diff --git a/app/src/parser/compat.h b/app/src/parser/compat.h index 0d96a9692..9fe85695c 100644 --- a/app/src/parser/compat.h +++ b/app/src/parser/compat.h @@ -20,28 +20,30 @@ // for BOLOS or running in the Tezos client/testing. #if __has_include("os.h") #include "os.h" -# if __has_include("cx.h") -# define ACTUALLY_ON_LEDGER -# endif +#if __has_include("cx.h") +#define ACTUALLY_ON_LEDGER +#endif #endif // On BOLOS, use the SDK. // Elsewhere, simulate the BOLOS API calls we need. #ifdef ACTUALLY_ON_LEDGER -# include "os.h" -# include "os_io_seproxyhal.h" -# include "cx.h" -# if CX_APILEVEL < 8 -# error "Only compiles with API level 8 or higher; requires newer firmware" -# endif +#include "os.h" +#include "os_io_seproxyhal.h" +#include "cx.h" +#if CX_APILEVEL < 8 +#error "Only compiles with API level 8 or higher; requires newer firmware" +#endif #else -# include -# define PIC(x) ((void*) x) -# ifdef TEZOS_DEBUG -# define PRINTF printf -# else -# define PRINTF(...) do {} while (0) -# endif +#include +#define PIC(x) ((void *)x) +#ifdef TEZOS_DEBUG +#define PRINTF printf +#else +#define PRINTF(...) \ + do { \ + } while (0) +#endif #endif #include @@ -50,11 +52,11 @@ // Type-safe versions of true/false #undef true -#define true ((bool) 1) +#define true ((bool)1) #undef false -#define false ((bool) 0) +#define false ((bool)0) #ifdef MIN #undef MIN #endif -#define MIN(a,b) (((a)<(b))?(a):(b)) +#define MIN(a, b) (((a) < (b)) ? (a) : (b)) diff --git a/app/src/parser/formatting.c b/app/src/parser/formatting.c index 5e5e04f80..530f4ccc0 100644 --- a/app/src/parser/formatting.c +++ b/app/src/parser/formatting.c @@ -22,167 +22,171 @@ // // NEVER REORDER elements of this array as the index is used as a // selector by `michelson_op_name`. -const char* const tz_michelson_op_names_ordered[TZ_LAST_MICHELSON_OPCODE+1] = { - "parameter", // 0 - "storage", // 1 - "code", // 2 - "False", // 3 - "Elt", // 4 - "Left", // 5 - "None", // 6 - "Pair", // 7 - "Right", // 8 - "Some", // 9 - "True", // 10 - "Unit", // 11 - "PACK", // 12 - "UNPACK", // 13 - "BLAKE2B", // 14 - "SHA256", // 15 - "SHA512", // 16 - "ABS", // 17 - "ADD", // 18 - "AMOUNT", // 19 - "AND", // 20 - "BALANCE", // 21 - "CAR", // 22 - "CDR", // 23 - "CHECK_SIGNATURE", // 24 - "COMPARE", // 25 - "CONCAT", // 26 - "CONS", // 27 - "CREATE_ACCOUNT", // 28 - "CREATE_CONTRACT", // 29 - "IMPLICIT_ACCOUNT", // 30 - "DIP", // 31 - "DROP", // 32 - "DUP", // 33 - "EDIV", // 34 - "EMPTY_MAP", // 35 - "EMPTY_SET", // 36 - "EQ", // 37 - "EXEC", // 38 - "FAILWITH", // 39 - "GE", // 40 - "GET", // 41 - "GT", // 42 - "HASH_KEY", // 43 - "IF", // 44 - "IF_CONS", // 45 - "IF_LEFT", // 46 - "IF_NONE", // 47 - "INT", // 48 - "LAMBDA", // 49 - "LE", // 50 - "LEFT", // 51 - "LOOP", // 52 - "LSL", // 53 - "LSR", // 54 - "LT", // 55 - "MAP", // 56 - "MEM", // 57 - "MUL", // 58 - "NEG", // 59 - "NEQ", // 60 - "NIL", // 61 - "NONE", // 62 - "NOT", // 63 - "NOW", // 64 - "OR", // 65 - "PAIR", // 66 - "PUSH", // 67 - "RIGHT", // 68 - "SIZE", // 69 - "SOME", // 70 - "SOURCE", // 71 - "SENDER", // 72 - "SELF", // 73 - "STEPS_TO_QUOTA", // 74 [DEPRECATED] - "SUB", // 75 - "SWAP", // 76 - "TRANSFER_TOKENS", // 77 - "SET_DELEGATE", // 78 - "UNIT", // 79 - "UPDATE", // 80 - "XOR", // 81 - "ITER", // 82 - "LOOP_LEFT", // 83 - "ADDRESS", // 84 - "CONTRACT", // 85 - "ISNAT", // 86 - "CAST", // 87 - "RENAME", // 88 - "bool", // 89 - "contract", // 90 - "int", // 91 - "key", // 92 - "key_hash", // 93 - "lambda", // 94 - "list", // 95 - "map", // 96 - "big_map", // 97 - "nat", // 98 - "option", // 99 - "or", // 100 - "pair", // 101 - "set", // 102 - "signature", // 103 - "string", // 104 - "bytes", // 105 - "mutez", // 106 - "timestamp", // 107 - "unit", // 108 - "operation", // 109 - "address", // 110 - "SLICE", // 111 - "DIG", // 112 - "DUG", // 113 - "EMPTY_BIG_MAP", // 114 - "APPLY", // 115 - "chain_id", // 116 - "CHAIN_ID", // 117 - "LEVEL", // 118 - "SELF_ADDRESS", // 119 - "never", // 120 - "NEVER", // 121 - "UNPAIR", // 122 - "VOTING_POWER", // 123 - "TOTAL_VOTING_POWER", // 124 - "KECCAK", // 125 - "SHA3", // 126 - "PAIRING_CHECK", // 127 - "bls12_381_g1", // 128 - "bls12_381_g2", // 129 - "bls12_381_fr", // 130 - "sapling_state", // 131 - "sapling_transaction_deprecated", // 132 [DEPRECATED] - "SAPLING_EMPTY_STATE", // 133 - "SAPLING_VERIFY_UPDATE", // 134 - "ticket", // 135 - "TICKET_DEPRECATED", // 136 - "READ_TICKET", // 137 - "SPLIT_TICKET", // 138 - "JOIN_TICKETS", // 139 - "GET_AND_UPDATE", // 140 - "chest", // 141 - "chest_key", // 142 - "OPEN_CHEST", // 143 - "VIEW", // 144 - "view", // 145 - "constant", // 146 - "SUB_MUTEZ", // 147 - "tx_rollup_l2_address", // 148 - "MIN_BLOCK_TIME", // 149 - "sapling_transaction", // 150 - "EMIT", // 151 - "Lambda_rec", // 152 - "LAMBDA_REC", // 153 - "TICKET" // 154 +const char *const tz_michelson_op_names_ordered[TZ_LAST_MICHELSON_OPCODE + 1] + = { + "parameter", // 0 + "storage", // 1 + "code", // 2 + "False", // 3 + "Elt", // 4 + "Left", // 5 + "None", // 6 + "Pair", // 7 + "Right", // 8 + "Some", // 9 + "True", // 10 + "Unit", // 11 + "PACK", // 12 + "UNPACK", // 13 + "BLAKE2B", // 14 + "SHA256", // 15 + "SHA512", // 16 + "ABS", // 17 + "ADD", // 18 + "AMOUNT", // 19 + "AND", // 20 + "BALANCE", // 21 + "CAR", // 22 + "CDR", // 23 + "CHECK_SIGNATURE", // 24 + "COMPARE", // 25 + "CONCAT", // 26 + "CONS", // 27 + "CREATE_ACCOUNT", // 28 + "CREATE_CONTRACT", // 29 + "IMPLICIT_ACCOUNT", // 30 + "DIP", // 31 + "DROP", // 32 + "DUP", // 33 + "EDIV", // 34 + "EMPTY_MAP", // 35 + "EMPTY_SET", // 36 + "EQ", // 37 + "EXEC", // 38 + "FAILWITH", // 39 + "GE", // 40 + "GET", // 41 + "GT", // 42 + "HASH_KEY", // 43 + "IF", // 44 + "IF_CONS", // 45 + "IF_LEFT", // 46 + "IF_NONE", // 47 + "INT", // 48 + "LAMBDA", // 49 + "LE", // 50 + "LEFT", // 51 + "LOOP", // 52 + "LSL", // 53 + "LSR", // 54 + "LT", // 55 + "MAP", // 56 + "MEM", // 57 + "MUL", // 58 + "NEG", // 59 + "NEQ", // 60 + "NIL", // 61 + "NONE", // 62 + "NOT", // 63 + "NOW", // 64 + "OR", // 65 + "PAIR", // 66 + "PUSH", // 67 + "RIGHT", // 68 + "SIZE", // 69 + "SOME", // 70 + "SOURCE", // 71 + "SENDER", // 72 + "SELF", // 73 + "STEPS_TO_QUOTA", // 74 [DEPRECATED] + "SUB", // 75 + "SWAP", // 76 + "TRANSFER_TOKENS", // 77 + "SET_DELEGATE", // 78 + "UNIT", // 79 + "UPDATE", // 80 + "XOR", // 81 + "ITER", // 82 + "LOOP_LEFT", // 83 + "ADDRESS", // 84 + "CONTRACT", // 85 + "ISNAT", // 86 + "CAST", // 87 + "RENAME", // 88 + "bool", // 89 + "contract", // 90 + "int", // 91 + "key", // 92 + "key_hash", // 93 + "lambda", // 94 + "list", // 95 + "map", // 96 + "big_map", // 97 + "nat", // 98 + "option", // 99 + "or", // 100 + "pair", // 101 + "set", // 102 + "signature", // 103 + "string", // 104 + "bytes", // 105 + "mutez", // 106 + "timestamp", // 107 + "unit", // 108 + "operation", // 109 + "address", // 110 + "SLICE", // 111 + "DIG", // 112 + "DUG", // 113 + "EMPTY_BIG_MAP", // 114 + "APPLY", // 115 + "chain_id", // 116 + "CHAIN_ID", // 117 + "LEVEL", // 118 + "SELF_ADDRESS", // 119 + "never", // 120 + "NEVER", // 121 + "UNPAIR", // 122 + "VOTING_POWER", // 123 + "TOTAL_VOTING_POWER", // 124 + "KECCAK", // 125 + "SHA3", // 126 + "PAIRING_CHECK", // 127 + "bls12_381_g1", // 128 + "bls12_381_g2", // 129 + "bls12_381_fr", // 130 + "sapling_state", // 131 + "sapling_transaction_deprecated", // 132 [DEPRECATED] + "SAPLING_EMPTY_STATE", // 133 + "SAPLING_VERIFY_UPDATE", // 134 + "ticket", // 135 + "TICKET_DEPRECATED", // 136 + "READ_TICKET", // 137 + "SPLIT_TICKET", // 138 + "JOIN_TICKETS", // 139 + "GET_AND_UPDATE", // 140 + "chest", // 141 + "chest_key", // 142 + "OPEN_CHEST", // 143 + "VIEW", // 144 + "view", // 145 + "constant", // 146 + "SUB_MUTEZ", // 147 + "tx_rollup_l2_address", // 148 + "MIN_BLOCK_TIME", // 149 + "sapling_transaction", // 150 + "EMIT", // 151 + "Lambda_rec", // 152 + "LAMBDA_REC", // 153 + "TICKET" // 154 }; -const char* tz_michelson_op_name(uint8_t op_code) { - if (op_code > TZ_LAST_MICHELSON_OPCODE) return NULL; - return PIC(tz_michelson_op_names_ordered[op_code]); +const char * +tz_michelson_op_name(uint8_t op_code) +{ + if (op_code > TZ_LAST_MICHELSON_OPCODE) + return NULL; + return PIC(tz_michelson_op_names_ordered[op_code]); } /* @@ -195,41 +199,49 @@ const char* tz_michelson_op_name(uint8_t op_code) { * under the terms of the standard MIT license. */ -static const char tz_b58digits_ordered[] = - "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; +static const char tz_b58digits_ordered[] + = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; -void tz_format_base58(const uint8_t *n, size_t l, char *obuf) { - int carry; +void +tz_format_base58(const uint8_t *n, size_t l, char *obuf) +{ + int carry; size_t i, j, high, zcount = 0, obuf_len = TZ_BASE58_BUFFER_SIZE(l); memset(obuf, 0, obuf_len); - while (zcount < l && !n[zcount]) ++zcount; + while (zcount < l && !n[zcount]) + ++zcount; for (i = zcount, high = obuf_len - 1; i < l; ++i, high = j) { carry = n[i]; - for (j = obuf_len - 1; ((int) j >= 0) && ((j > high) || carry); --j) { + for (j = obuf_len - 1; ((int)j >= 0) && ((j > high) || carry); --j) { carry += 256 * obuf[j]; obuf[j] = carry % 58; carry /= 58; } } - if (zcount) memset(obuf, '1', zcount); + if (zcount) + memset(obuf, '1', zcount); - for (j = 0; !obuf[j]; ++j); - for (i = 0; j < obuf_len; ++i, ++j) obuf[i] = - tz_b58digits_ordered[(unsigned)obuf[j]]; + for (j = 0; !obuf[j]; ++j) + ; + for (i = 0; j < obuf_len; ++i, ++j) + obuf[i] = tz_b58digits_ordered[(unsigned)obuf[j]]; obuf[i] = '\0'; } -void tz_format_decimal(const uint8_t *n, size_t l, char *obuf) { - int carry; +void +tz_format_decimal(const uint8_t *n, size_t l, char *obuf) +{ + int carry; size_t i, j, high, zcount = 0, obuf_len = TZ_DECIMAL_BUFFER_SIZE(l); memset(obuf, 0, obuf_len); - while (zcount < l && !n[l-zcount-1]) ++zcount; + while (zcount < l && !n[l - zcount - 1]) + ++zcount; if (zcount == l) { obuf[0] = '0'; @@ -238,15 +250,17 @@ void tz_format_decimal(const uint8_t *n, size_t l, char *obuf) { for (i = zcount, high = obuf_len - 1; i < l; ++i, high = j) { carry = n[l - i - 1]; - for (j = obuf_len - 1; ((int) j >= 0) && ((j > high) || carry); --j) { + for (j = obuf_len - 1; ((int)j >= 0) && ((j > high) || carry); --j) { carry += 256 * obuf[j]; obuf[j] = carry % 10; carry /= 10; } } - for (j = 0; !obuf[j]; ++j); - for (i = 0; j < obuf_len; ++i, ++j) obuf[i] = '0' + obuf[j]; + for (j = 0; !obuf[j]; ++j) + ; + for (i = 0; j < obuf_len; ++i, ++j) + obuf[i] = '0' + obuf[j]; obuf[i] = '\0'; } @@ -255,14 +269,19 @@ void tz_format_decimal(const uint8_t *n, size_t l, char *obuf) { // package does not publish their C header file for others to use, so // we are forced to piggy import the external definitions in order to // access them. -struct sha256_ctx { uint64_t sz; uint8_t buf[128]; uint32_t h[8];}; +struct sha256_ctx { + uint64_t sz; + uint8_t buf[128]; + uint32_t h[8]; +}; extern void digestif_sha256_init(struct sha256_ctx *); extern void digestif_sha256_update(struct sha256_ctx *, uint8_t *, uint32_t); extern void digestif_sha256_finalize(struct sha256_ctx *, uint8_t *); -static void cx_hash_sha256(uint8_t *data, size_t size, uint8_t *out, - size_t size_out) { +static void +cx_hash_sha256(uint8_t *data, size_t size, uint8_t *out, size_t size_out) +{ struct sha256_ctx ctx; - uint8_t res[32]; + uint8_t res[32]; digestif_sha256_init(&ctx); digestif_sha256_update(&ctx, data, size); digestif_sha256_finalize(&ctx, res); @@ -344,10 +363,12 @@ find_prefix(const char *s, const uint8_t **p, size_t *pl, size_t dl) } // clang-format on -int tz_format_base58check(const char *sprefix, const uint8_t *data, - size_t size, char *obuf) { +int +tz_format_base58check(const char *sprefix, const uint8_t *data, size_t size, + char *obuf) +{ const uint8_t *prefix = NULL; - size_t prefix_len; + size_t prefix_len; if (find_prefix(sprefix, &prefix, &prefix_len, size)) return 1; @@ -358,16 +379,18 @@ int tz_format_base58check(const char *sprefix, const uint8_t *data, return 1; memcpy(prepared, prefix, prefix_len); - memcpy(prepared+prefix_len, data, size); + memcpy(prepared + prefix_len, data, size); uint8_t tmp[32]; - cx_hash_sha256(prepared, size+prefix_len, tmp, 32); + cx_hash_sha256(prepared, size + prefix_len, tmp, 32); cx_hash_sha256(tmp, 32, tmp, 32); - memcpy(prepared+size+prefix_len, tmp, 4); - tz_format_base58(prepared, prefix_len+size+4, obuf); + memcpy(prepared + size + prefix_len, tmp, 4); + tz_format_base58(prepared, prefix_len + size + 4, obuf); return 0; } -int tz_format_pkh(const uint8_t *data, size_t size, char *obuf) { +int +tz_format_pkh(const uint8_t *data, size_t size, char *obuf) +{ const char *prefix; if (size < 1) @@ -382,10 +405,12 @@ int tz_format_pkh(const uint8_t *data, size_t size, char *obuf) { } // clang-format on - return tz_format_base58check(prefix, data+1, size-1, obuf); + return tz_format_base58check(prefix, data + 1, size - 1, obuf); } -int tz_format_pk(const uint8_t *data, size_t size, char *obuf) { +int +tz_format_pk(const uint8_t *data, size_t size, char *obuf) +{ const char *prefix; if (size < 1) @@ -400,20 +425,26 @@ int tz_format_pk(const uint8_t *data, size_t size, char *obuf) { } // clang-format on - return tz_format_base58check(prefix, data+1, size-1, obuf); + return tz_format_base58check(prefix, data + 1, size - 1, obuf); } /* Deprecated, use tz_format_base58check("o", ...) instead */ -int tz_format_oph(const uint8_t *data, size_t size, char *obuf) { +int +tz_format_oph(const uint8_t *data, size_t size, char *obuf) +{ return tz_format_base58check("o", data, size, obuf); } /* Deprecated, use tz_format_base58check("B", ...) instead */ -int tz_format_bh(const uint8_t *data, size_t size, char *obuf) { - return tz_format_base58check("B", data, size, obuf); +int +tz_format_bh(const uint8_t *data, size_t size, char *obuf) +{ + return tz_format_base58check("B", data, size, obuf); } -int tz_format_address(const uint8_t *data, size_t size, char *obuf) { +int +tz_format_address(const uint8_t *data, size_t size, char *obuf) +{ const char *prefix; if (size < 1) @@ -430,5 +461,5 @@ int tz_format_address(const uint8_t *data, size_t size, char *obuf) { } // clang-format on - return tz_format_base58check(prefix, data+1, size-2, obuf); + return tz_format_base58check(prefix, data + 1, size - 2, obuf); } diff --git a/app/src/parser/formatting.h b/app/src/parser/formatting.h index 4c6f46cd3..b258b6bcc 100644 --- a/app/src/parser/formatting.h +++ b/app/src/parser/formatting.h @@ -24,168 +24,168 @@ // Tezos protocol upgrade to support new opcodes, the existing opcodes // are guaranteed to stay unchanged, so not updating does not break // security. -const char* tz_michelson_op_name(uint8_t); +const char *tz_michelson_op_name(uint8_t); #define TZ_LAST_MICHELSON_OPCODE 154 // Should be kept in sync with the last protocol update, including // order, currently defined in the `michelson_v1_primitives.ml` file // in the Tezos protocol code. typedef enum { - TZ_MICHELSON_OP_parameter = 0, - TZ_MICHELSON_OP_storage = 1, - TZ_MICHELSON_OP_code = 2, - TZ_MICHELSON_OP_False = 3, - TZ_MICHELSON_OP_Elt = 4, - TZ_MICHELSON_OP_Left = 5, - TZ_MICHELSON_OP_None = 6, - TZ_MICHELSON_OP_Pair = 7, - TZ_MICHELSON_OP_Right = 8, - TZ_MICHELSON_OP_Some = 9, - TZ_MICHELSON_OP_True = 10, - TZ_MICHELSON_OP_Unit = 11, - TZ_MICHELSON_OP_PACK = 12, - TZ_MICHELSON_OP_UNPACK = 13, - TZ_MICHELSON_OP_BLAKE2B = 14, - TZ_MICHELSON_OP_SHA256 = 15, - TZ_MICHELSON_OP_SHA512 = 16, - TZ_MICHELSON_OP_ABS = 17, - TZ_MICHELSON_OP_ADD = 18, - TZ_MICHELSON_OP_AMOUNT = 19, - TZ_MICHELSON_OP_AND = 20, - TZ_MICHELSON_OP_BALANCE = 21, - TZ_MICHELSON_OP_CAR = 22, - TZ_MICHELSON_OP_CDR = 23, - TZ_MICHELSON_OP_CHECK_SIGNATURE = 24, - TZ_MICHELSON_OP_COMPARE = 25, - TZ_MICHELSON_OP_CONCAT = 26, - TZ_MICHELSON_OP_CONS = 27, - TZ_MICHELSON_OP_CREATE_ACCOUNT = 28, - TZ_MICHELSON_OP_CREATE_CONTRACT = 29, - TZ_MICHELSON_OP_IMPLICIT_ACCOUNT = 30, - TZ_MICHELSON_OP_DIP = 31, - TZ_MICHELSON_OP_DROP = 32, - TZ_MICHELSON_OP_DUP = 33, - TZ_MICHELSON_OP_EDIV = 34, - TZ_MICHELSON_OP_EMPTY_MAP = 35, - TZ_MICHELSON_OP_EMPTY_SET = 36, - TZ_MICHELSON_OP_EQ = 37, - TZ_MICHELSON_OP_EXEC = 38, - TZ_MICHELSON_OP_FAILWITH = 39, - TZ_MICHELSON_OP_GE = 40, - TZ_MICHELSON_OP_GET = 41, - TZ_MICHELSON_OP_GT = 42, - TZ_MICHELSON_OP_HASH_KEY = 43, - TZ_MICHELSON_OP_IF = 44, - TZ_MICHELSON_OP_IF_CONS = 45, - TZ_MICHELSON_OP_IF_LEFT = 46, - TZ_MICHELSON_OP_IF_NONE = 47, - TZ_MICHELSON_OP_INT = 48, - TZ_MICHELSON_OP_LAMBDA = 49, - TZ_MICHELSON_OP_LE = 50, - TZ_MICHELSON_OP_LEFT = 51, - TZ_MICHELSON_OP_LOOP = 52, - TZ_MICHELSON_OP_LSL = 53, - TZ_MICHELSON_OP_LSR = 54, - TZ_MICHELSON_OP_LT = 55, - TZ_MICHELSON_OP_MAP = 56, - TZ_MICHELSON_OP_MEM = 57, - TZ_MICHELSON_OP_MUL = 58, - TZ_MICHELSON_OP_NEG = 59, - TZ_MICHELSON_OP_NEQ = 60, - TZ_MICHELSON_OP_NIL = 61, - TZ_MICHELSON_OP_NONE = 62, - TZ_MICHELSON_OP_NOT = 63, - TZ_MICHELSON_OP_NOW = 64, - TZ_MICHELSON_OP_OR = 65, - TZ_MICHELSON_OP_PAIR = 66, - TZ_MICHELSON_OP_PUSH = 67, - TZ_MICHELSON_OP_RIGHT = 68, - TZ_MICHELSON_OP_SIZE = 69, - TZ_MICHELSON_OP_SOME = 70, - TZ_MICHELSON_OP_SOURCE = 71, - TZ_MICHELSON_OP_SENDER = 72, - TZ_MICHELSON_OP_SELF = 73, - TZ_MICHELSON_OP_STEPS_TO_QUOTA = 74, - TZ_MICHELSON_OP_SUB = 75, - TZ_MICHELSON_OP_SWAP = 76, - TZ_MICHELSON_OP_TRANSFER_TOKENS = 77, - TZ_MICHELSON_OP_SET_DELEGATE = 78, - TZ_MICHELSON_OP_UNIT = 79, - TZ_MICHELSON_OP_UPDATE = 80, - TZ_MICHELSON_OP_XOR = 81, - TZ_MICHELSON_OP_ITER = 82, - TZ_MICHELSON_OP_LOOP_LEFT = 83, - TZ_MICHELSON_OP_ADDRESS = 84, - TZ_MICHELSON_OP_CONTRACT = 85, - TZ_MICHELSON_OP_ISNAT = 86, - TZ_MICHELSON_OP_CAST = 87, - TZ_MICHELSON_OP_RENAME = 88, - TZ_MICHELSON_OP_bool = 89, - TZ_MICHELSON_OP_contract = 90, - TZ_MICHELSON_OP_int = 91, - TZ_MICHELSON_OP_key = 92, - TZ_MICHELSON_OP_key_hash = 93, - TZ_MICHELSON_OP_lambda = 94, - TZ_MICHELSON_OP_list = 95, - TZ_MICHELSON_OP_map = 96, - TZ_MICHELSON_OP_big_map = 97, - TZ_MICHELSON_OP_nat = 98, - TZ_MICHELSON_OP_option = 99, - TZ_MICHELSON_OP_or = 100, - TZ_MICHELSON_OP_pair = 101, - TZ_MICHELSON_OP_set = 102, - TZ_MICHELSON_OP_signature = 103, - TZ_MICHELSON_OP_string = 104, - TZ_MICHELSON_OP_bytes = 105, - TZ_MICHELSON_OP_mutez = 106, - TZ_MICHELSON_OP_timestamp = 107, - TZ_MICHELSON_OP_unit = 108, - TZ_MICHELSON_OP_operation = 109, - TZ_MICHELSON_OP_address = 110, - TZ_MICHELSON_OP_SLICE = 111, - TZ_MICHELSON_OP_DIG = 112, - TZ_MICHELSON_OP_DUG = 113, - TZ_MICHELSON_OP_EMPTY_BIG_MAP = 114, - TZ_MICHELSON_OP_APPLY = 115, - TZ_MICHELSON_OP_chain_id = 116, - TZ_MICHELSON_OP_CHAIN_ID = 117, - TZ_MICHELSON_OP_LEVEL = 118, - TZ_MICHELSON_OP_SELF_ADDRESS = 119, - TZ_MICHELSON_OP_never = 120, - TZ_MICHELSON_OP_NEVER = 121, - TZ_MICHELSON_OP_UNPAIR = 122, - TZ_MICHELSON_OP_VOTING_POWER = 123, - TZ_MICHELSON_OP_TOTAL_VOTING_POWER = 124, - TZ_MICHELSON_OP_KECCAK = 125, - TZ_MICHELSON_OP_SHA3 = 126, - TZ_MICHELSON_OP_PAIRING_CHECK = 127, - TZ_MICHELSON_OP_bls12_381_g1 = 128, - TZ_MICHELSON_OP_bls12_381_g2 = 129, - TZ_MICHELSON_OP_bls12_381_fr = 130, - TZ_MICHELSON_OP_sapling_state = 131, + TZ_MICHELSON_OP_parameter = 0, + TZ_MICHELSON_OP_storage = 1, + TZ_MICHELSON_OP_code = 2, + TZ_MICHELSON_OP_False = 3, + TZ_MICHELSON_OP_Elt = 4, + TZ_MICHELSON_OP_Left = 5, + TZ_MICHELSON_OP_None = 6, + TZ_MICHELSON_OP_Pair = 7, + TZ_MICHELSON_OP_Right = 8, + TZ_MICHELSON_OP_Some = 9, + TZ_MICHELSON_OP_True = 10, + TZ_MICHELSON_OP_Unit = 11, + TZ_MICHELSON_OP_PACK = 12, + TZ_MICHELSON_OP_UNPACK = 13, + TZ_MICHELSON_OP_BLAKE2B = 14, + TZ_MICHELSON_OP_SHA256 = 15, + TZ_MICHELSON_OP_SHA512 = 16, + TZ_MICHELSON_OP_ABS = 17, + TZ_MICHELSON_OP_ADD = 18, + TZ_MICHELSON_OP_AMOUNT = 19, + TZ_MICHELSON_OP_AND = 20, + TZ_MICHELSON_OP_BALANCE = 21, + TZ_MICHELSON_OP_CAR = 22, + TZ_MICHELSON_OP_CDR = 23, + TZ_MICHELSON_OP_CHECK_SIGNATURE = 24, + TZ_MICHELSON_OP_COMPARE = 25, + TZ_MICHELSON_OP_CONCAT = 26, + TZ_MICHELSON_OP_CONS = 27, + TZ_MICHELSON_OP_CREATE_ACCOUNT = 28, + TZ_MICHELSON_OP_CREATE_CONTRACT = 29, + TZ_MICHELSON_OP_IMPLICIT_ACCOUNT = 30, + TZ_MICHELSON_OP_DIP = 31, + TZ_MICHELSON_OP_DROP = 32, + TZ_MICHELSON_OP_DUP = 33, + TZ_MICHELSON_OP_EDIV = 34, + TZ_MICHELSON_OP_EMPTY_MAP = 35, + TZ_MICHELSON_OP_EMPTY_SET = 36, + TZ_MICHELSON_OP_EQ = 37, + TZ_MICHELSON_OP_EXEC = 38, + TZ_MICHELSON_OP_FAILWITH = 39, + TZ_MICHELSON_OP_GE = 40, + TZ_MICHELSON_OP_GET = 41, + TZ_MICHELSON_OP_GT = 42, + TZ_MICHELSON_OP_HASH_KEY = 43, + TZ_MICHELSON_OP_IF = 44, + TZ_MICHELSON_OP_IF_CONS = 45, + TZ_MICHELSON_OP_IF_LEFT = 46, + TZ_MICHELSON_OP_IF_NONE = 47, + TZ_MICHELSON_OP_INT = 48, + TZ_MICHELSON_OP_LAMBDA = 49, + TZ_MICHELSON_OP_LE = 50, + TZ_MICHELSON_OP_LEFT = 51, + TZ_MICHELSON_OP_LOOP = 52, + TZ_MICHELSON_OP_LSL = 53, + TZ_MICHELSON_OP_LSR = 54, + TZ_MICHELSON_OP_LT = 55, + TZ_MICHELSON_OP_MAP = 56, + TZ_MICHELSON_OP_MEM = 57, + TZ_MICHELSON_OP_MUL = 58, + TZ_MICHELSON_OP_NEG = 59, + TZ_MICHELSON_OP_NEQ = 60, + TZ_MICHELSON_OP_NIL = 61, + TZ_MICHELSON_OP_NONE = 62, + TZ_MICHELSON_OP_NOT = 63, + TZ_MICHELSON_OP_NOW = 64, + TZ_MICHELSON_OP_OR = 65, + TZ_MICHELSON_OP_PAIR = 66, + TZ_MICHELSON_OP_PUSH = 67, + TZ_MICHELSON_OP_RIGHT = 68, + TZ_MICHELSON_OP_SIZE = 69, + TZ_MICHELSON_OP_SOME = 70, + TZ_MICHELSON_OP_SOURCE = 71, + TZ_MICHELSON_OP_SENDER = 72, + TZ_MICHELSON_OP_SELF = 73, + TZ_MICHELSON_OP_STEPS_TO_QUOTA = 74, + TZ_MICHELSON_OP_SUB = 75, + TZ_MICHELSON_OP_SWAP = 76, + TZ_MICHELSON_OP_TRANSFER_TOKENS = 77, + TZ_MICHELSON_OP_SET_DELEGATE = 78, + TZ_MICHELSON_OP_UNIT = 79, + TZ_MICHELSON_OP_UPDATE = 80, + TZ_MICHELSON_OP_XOR = 81, + TZ_MICHELSON_OP_ITER = 82, + TZ_MICHELSON_OP_LOOP_LEFT = 83, + TZ_MICHELSON_OP_ADDRESS = 84, + TZ_MICHELSON_OP_CONTRACT = 85, + TZ_MICHELSON_OP_ISNAT = 86, + TZ_MICHELSON_OP_CAST = 87, + TZ_MICHELSON_OP_RENAME = 88, + TZ_MICHELSON_OP_bool = 89, + TZ_MICHELSON_OP_contract = 90, + TZ_MICHELSON_OP_int = 91, + TZ_MICHELSON_OP_key = 92, + TZ_MICHELSON_OP_key_hash = 93, + TZ_MICHELSON_OP_lambda = 94, + TZ_MICHELSON_OP_list = 95, + TZ_MICHELSON_OP_map = 96, + TZ_MICHELSON_OP_big_map = 97, + TZ_MICHELSON_OP_nat = 98, + TZ_MICHELSON_OP_option = 99, + TZ_MICHELSON_OP_or = 100, + TZ_MICHELSON_OP_pair = 101, + TZ_MICHELSON_OP_set = 102, + TZ_MICHELSON_OP_signature = 103, + TZ_MICHELSON_OP_string = 104, + TZ_MICHELSON_OP_bytes = 105, + TZ_MICHELSON_OP_mutez = 106, + TZ_MICHELSON_OP_timestamp = 107, + TZ_MICHELSON_OP_unit = 108, + TZ_MICHELSON_OP_operation = 109, + TZ_MICHELSON_OP_address = 110, + TZ_MICHELSON_OP_SLICE = 111, + TZ_MICHELSON_OP_DIG = 112, + TZ_MICHELSON_OP_DUG = 113, + TZ_MICHELSON_OP_EMPTY_BIG_MAP = 114, + TZ_MICHELSON_OP_APPLY = 115, + TZ_MICHELSON_OP_chain_id = 116, + TZ_MICHELSON_OP_CHAIN_ID = 117, + TZ_MICHELSON_OP_LEVEL = 118, + TZ_MICHELSON_OP_SELF_ADDRESS = 119, + TZ_MICHELSON_OP_never = 120, + TZ_MICHELSON_OP_NEVER = 121, + TZ_MICHELSON_OP_UNPAIR = 122, + TZ_MICHELSON_OP_VOTING_POWER = 123, + TZ_MICHELSON_OP_TOTAL_VOTING_POWER = 124, + TZ_MICHELSON_OP_KECCAK = 125, + TZ_MICHELSON_OP_SHA3 = 126, + TZ_MICHELSON_OP_PAIRING_CHECK = 127, + TZ_MICHELSON_OP_bls12_381_g1 = 128, + TZ_MICHELSON_OP_bls12_381_g2 = 129, + TZ_MICHELSON_OP_bls12_381_fr = 130, + TZ_MICHELSON_OP_sapling_state = 131, TZ_MICHELSON_OP_sapling_transaction_deprecated = 132, - TZ_MICHELSON_OP_SAPLING_EMPTY_STATE = 133, - TZ_MICHELSON_OP_SAPLING_VERIFY_UPDATE = 134, - TZ_MICHELSON_OP_ticket = 135, - TZ_MICHELSON_OP_TICKET_DEPRECATED = 136, - TZ_MICHELSON_OP_READ_TICKET = 137, - TZ_MICHELSON_OP_SPLIT_TICKET = 138, - TZ_MICHELSON_OP_JOIN_TICKETS = 139, - TZ_MICHELSON_OP_GET_AND_UPDATE = 140, - TZ_MICHELSON_OP_chest = 141, - TZ_MICHELSON_OP_chest_key = 142, - TZ_MICHELSON_OP_OPEN_CHEST = 143, - TZ_MICHELSON_OP_VIEW = 144, - TZ_MICHELSON_OP_view = 145, - TZ_MICHELSON_OP_constant = 146, - TZ_MICHELSON_OP_SUB_MUTEZ = 147, - TZ_MICHELSON_OP_tx_rollup_l2_address = 148, - TZ_MICHELSON_OP_MIN_BLOCK_TIME = 149, - TZ_MICHELSON_OP_sapling_transaction = 150, - TZ_MICHELSON_OP_EMIT = 151, - TZ_MICHELSON_OP_Lambda_rec = 152, - TZ_MICHELSON_OP_LAMBDA_REC = 153, - TZ_MICHELSON_OP_TICKET = 154 + TZ_MICHELSON_OP_SAPLING_EMPTY_STATE = 133, + TZ_MICHELSON_OP_SAPLING_VERIFY_UPDATE = 134, + TZ_MICHELSON_OP_ticket = 135, + TZ_MICHELSON_OP_TICKET_DEPRECATED = 136, + TZ_MICHELSON_OP_READ_TICKET = 137, + TZ_MICHELSON_OP_SPLIT_TICKET = 138, + TZ_MICHELSON_OP_JOIN_TICKETS = 139, + TZ_MICHELSON_OP_GET_AND_UPDATE = 140, + TZ_MICHELSON_OP_chest = 141, + TZ_MICHELSON_OP_chest_key = 142, + TZ_MICHELSON_OP_OPEN_CHEST = 143, + TZ_MICHELSON_OP_VIEW = 144, + TZ_MICHELSON_OP_view = 145, + TZ_MICHELSON_OP_constant = 146, + TZ_MICHELSON_OP_SUB_MUTEZ = 147, + TZ_MICHELSON_OP_tx_rollup_l2_address = 148, + TZ_MICHELSON_OP_MIN_BLOCK_TIME = 149, + TZ_MICHELSON_OP_sapling_transaction = 150, + TZ_MICHELSON_OP_EMIT = 151, + TZ_MICHELSON_OP_Lambda_rec = 152, + TZ_MICHELSON_OP_LAMBDA_REC = 153, + TZ_MICHELSON_OP_TICKET = 154 } tz_michelson_opcode; // Formats a positive number of arbitrary to decimal. The number is diff --git a/app/src/parser/micheline_parser.c b/app/src/parser/micheline_parser.c index aaf03b02d..9701ef6d6 100644 --- a/app/src/parser/micheline_parser.c +++ b/app/src/parser/micheline_parser.c @@ -25,54 +25,45 @@ /* Prototypes */ static tz_parser_result push_frame(tz_parser_state *, - tz_micheline_parser_step_kind); + tz_micheline_parser_step_kind); static tz_parser_result pop_frame(tz_parser_state *); static tz_parser_result begin_sized(tz_parser_state *); static tz_parser_result print_escaped(tz_parser_state *, uint8_t); static tz_parser_result parser_put(tz_parser_state *, char); static tz_parser_result tag_selection(tz_parser_state *, uint8_t); - #ifdef TEZOS_DEBUG -const char *const tz_micheline_parser_step_name[] = { - "TAG", - "PRIM_OP", - "PRIM_NAME", - "PRIM", - "SIZE", - "SEQ", - "BYTES", - "STRING", - "ANNOT", - "INT", - "PRINT_INT", - "CONTINUE" -}; +const char *const tz_micheline_parser_step_name[] + = {"TAG", "PRIM_OP", "PRIM_NAME", "PRIM", "SIZE", "SEQ", + "BYTES", "STRING", "ANNOT", "INT", "PRINT_INT", "CONTINUE"}; #endif - const char hex_c[] = "0123456789ABCDEF"; -void tz_micheline_parser_init(tz_parser_state *state) { +void +tz_micheline_parser_init(tz_parser_state *state) +{ tz_micheline_state *m = &state->micheline; - m->frame = m->stack; + m->frame = m->stack; m->stack[0].step = TZ_MICHELINE_STEP_TAG; } -static tz_parser_result push_frame(tz_parser_state *state, - tz_micheline_parser_step_kind step) { +static tz_parser_result +push_frame(tz_parser_state *state, tz_micheline_parser_step_kind step) +{ tz_micheline_state *m = &state->micheline; - if (m->frame >= - &m->stack[TZ_MICHELINE_STACK_DEPTH - 1]) + if (m->frame >= &m->stack[TZ_MICHELINE_STACK_DEPTH - 1]) tz_raise(TOO_DEEP); - m->frame++ ; + m->frame++; m->frame->step = step; tz_continue; } -static tz_parser_result pop_frame(tz_parser_state *state) { +static tz_parser_result +pop_frame(tz_parser_state *state) +{ tz_micheline_state *m = &state->micheline; if (m->frame == m->stack) { @@ -83,17 +74,22 @@ static tz_parser_result pop_frame(tz_parser_state *state) { tz_continue; } -static tz_parser_result begin_sized(tz_parser_state *state) { +static tz_parser_result +begin_sized(tz_parser_state *state) +{ tz_micheline_state *m = &state->micheline; - if (push_frame(state, TZ_MICHELINE_STEP_SIZE)) tz_reraise; + if (push_frame(state, TZ_MICHELINE_STEP_SIZE)) + tz_reraise; m->frame->step_size.size = 0; - m->frame->stop = state->ofs+4; + m->frame->stop = state->ofs + 4; tz_continue; } -static tz_parser_result print_escaped(tz_parser_state *state, uint8_t b) { - char* buf = (char*) state->buffers.capture; +static tz_parser_result +print_escaped(tz_parser_state *state, uint8_t b) +{ + char *buf = (char *)state->buffers.capture; tz_must(push_frame(state, TZ_MICHELINE_STEP_PRINT_CAPTURE)); state->micheline.frame->step_capture.ofs = 0; // clang-format off @@ -114,38 +110,41 @@ static tz_parser_result print_escaped(tz_parser_state *state, uint8_t b) { tz_continue; } -static tz_parser_result parser_put(tz_parser_state *state, char c) { - PRINTF("[DEBUG] put(char: '%c',int: %d)\n", c, (int) c); +static tz_parser_result +parser_put(tz_parser_state *state, char c) +{ + PRINTF("[DEBUG] put(char: '%c',int: %d)\n", c, (int)c); return tz_parser_put(state, c); } -static tz_parser_result tag_selection(tz_parser_state *state, uint8_t t) { +static tz_parser_result +tag_selection(tz_parser_state *state, uint8_t t) +{ tz_micheline_state *m = &state->micheline; - uint8_t nargs; - uint8_t annot; - uint8_t wrap; + uint8_t nargs; + uint8_t annot; + uint8_t wrap; switch (t) { case TZ_MICHELINE_TAG_INT: m->frame->step = TZ_MICHELINE_STEP_INT; - tz_parse_num_state_init(&state->buffers.num, - &m->frame->step_int); - for (int i = 0; i < TZ_NUM_BUFFER_SIZE/8;i++) + tz_parse_num_state_init(&state->buffers.num, &m->frame->step_int); + for (int i = 0; i < TZ_NUM_BUFFER_SIZE / 8; i++) state->buffers.num.bytes[i] = 0; break; case TZ_MICHELINE_TAG_SEQ: - m->frame->step = TZ_MICHELINE_STEP_SEQ; + m->frame->step = TZ_MICHELINE_STEP_SEQ; m->frame->step_seq.first = true; tz_must(begin_sized(state)); break; case TZ_MICHELINE_TAG_BYTES: - m->frame->step = TZ_MICHELINE_STEP_BYTES; - m->frame->step_bytes.first = true; + m->frame->step = TZ_MICHELINE_STEP_BYTES; + m->frame->step_bytes.first = true; m->frame->step_bytes.has_rem_half = false; tz_must(begin_sized(state)); break; case TZ_MICHELINE_TAG_STRING: - m->frame->step = TZ_MICHELINE_STEP_STRING; + m->frame->step = TZ_MICHELINE_STEP_STRING; m->frame->step_string.first = true; tz_must(begin_sized(state)); break; @@ -155,65 +154,70 @@ static tz_parser_result tag_selection(tz_parser_state *state, uint8_t t) { case TZ_MICHELINE_TAG_PRIM_1_NOANNOTS: case TZ_MICHELINE_TAG_PRIM_2_ANNOTS: case TZ_MICHELINE_TAG_PRIM_2_NOANNOTS: - nargs = (t-3) >> 1; + nargs = (t - 3) >> 1; annot = (~t & 1); - wrap = (m->frame > m->stack) - && m->frame[-1].step == TZ_MICHELINE_STEP_PRIM - && (nargs>0 || annot); + wrap = (m->frame > m->stack) + && m->frame[-1].step == TZ_MICHELINE_STEP_PRIM + && (nargs > 0 || annot); goto common_prim; case TZ_MICHELINE_TAG_PRIM_N: - wrap = (m->frame > m->stack) && - m->frame[-1].step == TZ_MICHELINE_STEP_PRIM; + wrap = (m->frame > m->stack) + && m->frame[-1].step == TZ_MICHELINE_STEP_PRIM; nargs = 3; annot = true; common_prim: - m->frame->step = TZ_MICHELINE_STEP_PRIM_OP; - m->frame->step_prim.ofs = 0; + m->frame->step = TZ_MICHELINE_STEP_PRIM_OP; + m->frame->step_prim.ofs = 0; m->frame->step_prim.nargs = nargs; - m->frame->step_prim.wrap = wrap; - m->frame->step_prim.spc = false; + m->frame->step_prim.wrap = wrap; + m->frame->step_prim.spc = false; m->frame->step_prim.first = true; m->frame->step_prim.annot = annot; break; - default: tz_raise(INVALID_TAG); + default: + tz_raise(INVALID_TAG); } tz_continue; } -tz_parser_result tz_micheline_parser_step(tz_parser_state *state) { +tz_parser_result +tz_micheline_parser_step(tz_parser_state *state) +{ tz_micheline_state *m = &state->micheline; - uint8_t b; - uint8_t op; - uint8_t t; + uint8_t b; + uint8_t op; + uint8_t t; // cannot restart after error - if (TZ_IS_ERR(state->errno)) tz_reraise; + if (TZ_IS_ERR(state->errno)) + tz_reraise; // nothing else to do - if (state->micheline.frame == NULL) tz_stop(DONE); + if (state->micheline.frame == NULL) + tz_stop(DONE); - PRINTF("[DEBUG] micheline(frame: %d, offset:%d/%d, step: %s, errno: %s)\n", - (int) (m->frame - m->stack), - (int) state->ofs, - (int) m->frame->stop, - (const char*) PIC(tz_micheline_parser_step_name[m->frame->step]), - tz_parser_result_name(state->errno)); + PRINTF( + "[DEBUG] micheline(frame: %d, offset:%d/%d, step: %s, errno: %s)\n", + (int)(m->frame - m->stack), (int)state->ofs, (int)m->frame->stop, + (const char *)PIC(tz_micheline_parser_step_name[m->frame->step]), + tz_parser_result_name(state->errno)); switch (state->micheline.frame->step) { case TZ_MICHELINE_STEP_INT: tz_must(tz_parser_read(state, &b)); - tz_must(tz_parse_int_step(&state->buffers.num, &m->frame->step_int, b)); + tz_must( + tz_parse_int_step(&state->buffers.num, &m->frame->step_int, b)); if (m->frame->step_int.stop) { - m->frame->step = TZ_MICHELINE_STEP_PRINT_INT; + m->frame->step = TZ_MICHELINE_STEP_PRINT_INT; m->frame->step_int.size = 0; } - break; + break; case TZ_MICHELINE_STEP_PRINT_INT: if (m->frame->step_int.sign) { tz_must(parser_put(state, '-')); m->frame->step_int.sign = 0; } else if (state->buffers.num.decimal[m->frame->step_int.size]) { - tz_must(parser_put(state, - state->buffers.num.decimal[m->frame->step_int.size])); + tz_must(parser_put( + state, state->buffers.num.decimal[m->frame->step_int.size])); m->frame->step_int.size++; } else { tz_must(pop_frame(state)); @@ -222,7 +226,7 @@ tz_parser_result tz_micheline_parser_step(tz_parser_state *state) { case TZ_MICHELINE_STEP_SIZE: tz_must(tz_parser_read(state, &b)); if (m->frame->step_size.size > 255) - tz_raise(TOO_LARGE); // enforce 16-bit restriction + tz_raise(TOO_LARGE); // enforce 16-bit restriction m->frame->step_size.size = m->frame->step_size.size << 8 | b; if (m->frame->stop == state->ofs) { m->frame[-1].stop = state->ofs + m->frame->step_size.size; @@ -249,9 +253,10 @@ tz_parser_result tz_micheline_parser_step(tz_parser_state *state) { } break; case TZ_MICHELINE_STEP_PRINT_CAPTURE: - if (state->buffers.capture[state->micheline.frame->step_capture.ofs]) { - tz_must(parser_put(state, - state->buffers.capture[m->frame->step_capture.ofs])); + if (state->buffers + .capture[state->micheline.frame->step_capture.ofs]) { + tz_must(parser_put( + state, state->buffers.capture[m->frame->step_capture.ofs])); m->frame->step_capture.ofs++; } else { tz_must(pop_frame(state)); @@ -264,8 +269,8 @@ tz_parser_result tz_micheline_parser_step(tz_parser_state *state) { } else if (state->micheline.frame->step_bytes.first) { tz_must(parser_put(state, '0')); m->frame->step_bytes.has_rem_half = true; - m->frame->step_bytes.rem_half = 'x'; - m->frame->step_bytes.first = false; + m->frame->step_bytes.rem_half = 'x'; + m->frame->step_bytes.first = false; } else if (m->frame->stop == state->ofs) { tz_must(pop_frame(state)); } else { @@ -274,7 +279,7 @@ tz_parser_result tz_micheline_parser_step(tz_parser_state *state) { half = hex_c[(b & 0xF0) >> 4]; tz_must(parser_put(state, half)); m->frame->step_bytes.has_rem_half = true; - m->frame->step_bytes.rem_half = hex_c[b & 0x0F]; + m->frame->step_bytes.rem_half = hex_c[b & 0x0F]; tz_parser_skip(state); } break; @@ -316,8 +321,9 @@ tz_parser_result tz_micheline_parser_step(tz_parser_state *state) { break; case TZ_MICHELINE_STEP_PRIM_OP: tz_must(tz_parser_read(state, &op)); - if (tz_michelson_op_name(op) == NULL) tz_raise(INVALID_OP); - m->frame->step = TZ_MICHELINE_STEP_PRIM_NAME; + if (tz_michelson_op_name(op) == NULL) + tz_raise(INVALID_OP); + m->frame->step = TZ_MICHELINE_STEP_PRIM_NAME; m->frame->step_prim.op = op; break; case TZ_MICHELINE_STEP_PRIM_NAME: @@ -325,9 +331,11 @@ tz_parser_result tz_micheline_parser_step(tz_parser_state *state) { tz_must(parser_put(state, '(')); m->frame->step_prim.first = false; } - if (tz_michelson_op_name(m->frame->step_prim.op)[m->frame->step_prim.ofs]) { - tz_must(parser_put(state, - tz_michelson_op_name(m->frame->step_prim.op)[m->frame->step_prim.ofs])); + if (tz_michelson_op_name( + m->frame->step_prim.op)[m->frame->step_prim.ofs]) { + tz_must(parser_put( + state, tz_michelson_op_name( + m->frame->step_prim.op)[m->frame->step_prim.ofs])); m->frame->step_prim.ofs++; } else { m->frame->step = TZ_MICHELINE_STEP_PRIM; @@ -336,9 +344,9 @@ tz_parser_result tz_micheline_parser_step(tz_parser_state *state) { } break; case TZ_MICHELINE_STEP_PRIM: - if (m->frame->step_prim.nargs == 0 || - (m->frame->step_prim.nargs == 3 && - m->frame->stop == state->ofs)) { + if (m->frame->step_prim.nargs == 0 + || (m->frame->step_prim.nargs == 3 + && m->frame->stop == state->ofs)) { if (m->frame->step_prim.annot) { m->frame->step_prim.annot = false; tz_must(push_frame(state, TZ_MICHELINE_STEP_ANNOT)); @@ -363,7 +371,8 @@ tz_parser_result tz_micheline_parser_step(tz_parser_state *state) { tz_must(tz_parser_read(state, &t)); tz_must(tag_selection(state, t)); break; - default: tz_raise(INVALID_STATE); + default: + tz_raise(INVALID_STATE); } tz_continue; } diff --git a/app/src/parser/micheline_parser.h b/app/src/parser/micheline_parser.h index b96944eff..9d5b28f6c 100644 --- a/app/src/parser/micheline_parser.h +++ b/app/src/parser/micheline_parser.h @@ -18,5 +18,5 @@ #include "parser_state.h" -void tz_micheline_parser_init(tz_parser_state *); +void tz_micheline_parser_init(tz_parser_state *); tz_parser_result tz_micheline_parser_step(tz_parser_state *); diff --git a/app/src/parser/micheline_state.h b/app/src/parser/micheline_state.h index ff3284726..2a2e60c4a 100644 --- a/app/src/parser/micheline_state.h +++ b/app/src/parser/micheline_state.h @@ -61,42 +61,43 @@ typedef enum { typedef struct { tz_micheline_parser_step_kind step : 4; - uint16_t stop; + uint16_t stop; union { struct { uint16_t size; - } step_size; // TZ_MICHELINE_STEP_SIZE + } step_size; // TZ_MICHELINE_STEP_SIZE struct { uint8_t first : 1; - } step_seq; // TZ_MICHELINE_STEP_SEQ + } step_seq; // TZ_MICHELINE_STEP_SEQ struct { - uint8_t first : 1, has_rem_half: 1; + uint8_t first : 1, has_rem_half : 1; uint8_t rem_half; - } step_bytes; // TZ_MICHELINE_STEP_BYTES + } step_bytes; // TZ_MICHELINE_STEP_BYTES struct { uint8_t first : 1; - } step_string; // TZ_MICHELINE_STEP_STRING + } step_string; // TZ_MICHELINE_STEP_STRING struct { uint8_t first : 1; - } step_annot; // TZ_MICHELINE_STEP_ANNOT - tz_num_parser_regs step_int; // TZ_MICHELINE_STEP_INT, - // TZ_MICHELINE_STEP_PRINT_INT + } step_annot; // TZ_MICHELINE_STEP_ANNOT + tz_num_parser_regs step_int; // TZ_MICHELINE_STEP_INT, + // TZ_MICHELINE_STEP_PRINT_INT struct { uint8_t op; uint8_t ofs; uint8_t nargs : 2, wrap : 1, spc : 1, annot : 1, first : 1; - } step_prim; // TZ_MICHELINE_STEP_PRIM_OP, - // TZ_MICHELINE_STEP_PRIM_NAME, - // TZ_MICHELINE_STEP_PRIM + } step_prim; // TZ_MICHELINE_STEP_PRIM_OP, + // TZ_MICHELINE_STEP_PRIM_NAME, + // TZ_MICHELINE_STEP_PRIM struct { int ofs; - } step_capture; // TZ_MICHELINE_STEP_CAPTURE_BYTES, - // TZ_MICHELINE_STEP_PRINT_CAPTURE - tz_micheline_capture_kind step_capturing; // TZ_MICHELINE_STEP_CAPTURING + } step_capture; // TZ_MICHELINE_STEP_CAPTURE_BYTES, + // TZ_MICHELINE_STEP_PRINT_CAPTURE + tz_micheline_capture_kind + step_capturing; // TZ_MICHELINE_STEP_CAPTURING }; } tz_micheline_parser_frame; typedef struct { - tz_micheline_parser_frame stack[TZ_MICHELINE_STACK_DEPTH]; - tz_micheline_parser_frame *frame; // init == stack, NULL when done + tz_micheline_parser_frame stack[TZ_MICHELINE_STACK_DEPTH]; + tz_micheline_parser_frame *frame; // init == stack, NULL when done } tz_micheline_state; diff --git a/app/src/parser/num_parser.c b/app/src/parser/num_parser.c index 985d2a574..b3cf6427a 100644 --- a/app/src/parser/num_parser.c +++ b/app/src/parser/num_parser.c @@ -16,35 +16,39 @@ #include "num_parser.h" -void tz_parse_num_state_init(tz_num_parser_buffer *buffers, - tz_num_parser_regs *regs) { +void +tz_parse_num_state_init(tz_num_parser_buffer *buffers, + tz_num_parser_regs *regs) +{ buffers->bytes[0] = 0; - regs->size = 0; - regs->sign = 0; - regs->stop = 0; + regs->size = 0; + regs->sign = 0; + regs->stop = 0; } -tz_parser_result tz_parse_num_step(tz_num_parser_buffer *buffers, - tz_num_parser_regs *regs, - uint8_t b, bool natural) { +tz_parser_result +tz_parse_num_step(tz_num_parser_buffer *buffers, tz_num_parser_regs *regs, + uint8_t b, bool natural) +{ uint8_t v, cont, s; cont = b >> 7; if (regs->size == 0 && !natural) { - v = b & 0x3F; - regs->sign = (b >> 6)&1; - s = 6; + v = b & 0x3F; + regs->sign = (b >> 6) & 1; + s = 6; } else { v = b & 0x7F; s = 7; } - uint8_t lo = v << (regs->size & 7); - uint8_t hi = v >> (8 - (regs->size & 7)); - int lo_idx = regs->size/8; - int hi_idx = lo_idx+1; + uint8_t lo = v << (regs->size & 7); + uint8_t hi = v >> (8 - (regs->size & 7)); + int lo_idx = regs->size / 8; + int hi_idx = lo_idx + 1; buffers->bytes[lo_idx] |= lo; - if (hi_idx >= TZ_NUM_BUFFER_SIZE/8) { + if (hi_idx >= TZ_NUM_BUFFER_SIZE / 8) { // accept and dismiss a few trailing zeroes - if (hi || cont) return TZ_ERR_TOO_LARGE; + if (hi || cont) + return TZ_ERR_TOO_LARGE; regs->size = TZ_NUM_BUFFER_SIZE; } else { buffers->bytes[hi_idx] = hi; @@ -52,17 +56,22 @@ tz_parser_result tz_parse_num_step(tz_num_parser_buffer *buffers, } if (!cont) { regs->stop = true; - tz_format_decimal(buffers->bytes, (regs->size+7)/8, buffers->decimal); + tz_format_decimal(buffers->bytes, (regs->size + 7) / 8, + buffers->decimal); } return TZ_CONTINUE; } -tz_parser_result tz_parse_int_step(tz_num_parser_buffer *buffers, - tz_num_parser_regs *regs, uint8_t b) { +tz_parser_result +tz_parse_int_step(tz_num_parser_buffer *buffers, tz_num_parser_regs *regs, + uint8_t b) +{ return tz_parse_num_step(buffers, regs, b, 0); } -tz_parser_result tz_parse_nat_step(tz_num_parser_buffer *buffers, - tz_num_parser_regs *regs, uint8_t b) { +tz_parser_result +tz_parse_nat_step(tz_num_parser_buffer *buffers, tz_num_parser_regs *regs, + uint8_t b) +{ return tz_parse_num_step(buffers, regs, b, 1); } diff --git a/app/src/parser/num_parser.h b/app/src/parser/num_parser.h index 6f263f243..9565506bc 100644 --- a/app/src/parser/num_parser.h +++ b/app/src/parser/num_parser.h @@ -20,11 +20,8 @@ void tz_parse_num_state_init(tz_num_parser_buffer *, tz_num_parser_regs *); tz_parser_result tz_parse_num_step(tz_num_parser_buffer *, - tz_num_parser_regs *, - uint8_t, bool); + tz_num_parser_regs *, uint8_t, bool); tz_parser_result tz_parse_int_step(tz_num_parser_buffer *, - tz_num_parser_regs *, - uint8_t); + tz_num_parser_regs *, uint8_t); tz_parser_result tz_parse_nat_step(tz_num_parser_buffer *, - tz_num_parser_regs *, - uint8_t); + tz_num_parser_regs *, uint8_t); diff --git a/app/src/parser/num_state.h b/app/src/parser/num_state.h index 4d4c271e6..363e2ac14 100644 --- a/app/src/parser/num_state.h +++ b/app/src/parser/num_state.h @@ -20,12 +20,12 @@ typedef struct { uint16_t size; - uint8_t sign : 1, stop : 1; + uint8_t sign : 1, stop : 1; } tz_num_parser_regs; #define TZ_NUM_BUFFER_SIZE 256 typedef struct { - uint8_t bytes[TZ_NUM_BUFFER_SIZE/8]; - char decimal[TZ_DECIMAL_BUFFER_SIZE(TZ_NUM_BUFFER_SIZE/8)]; + uint8_t bytes[TZ_NUM_BUFFER_SIZE / 8]; + char decimal[TZ_DECIMAL_BUFFER_SIZE(TZ_NUM_BUFFER_SIZE / 8)]; } tz_num_parser_buffer; diff --git a/app/src/parser/operation_parser.c b/app/src/parser/operation_parser.c index 32d8a1cdb..6751594c5 100644 --- a/app/src/parser/operation_parser.c +++ b/app/src/parser/operation_parser.c @@ -26,362 +26,372 @@ static tz_parser_result push_frame(tz_parser_state *, tz_operation_parser_step_kind); static tz_parser_result pop_frame(tz_parser_state *); - #ifdef TEZOS_DEBUG -const char *const tz_operation_parser_step_name[] = { - "MAGIC", - "READ_BINARY", - "BRANCH", - "BATCH", - "TAG", - "SIZE", - "OPERATION", - "PRINT", - "PARTIAL_PRINT", - "READ_NUM", - "READ_INT32", - "READ_PK", - "READ_BYTES", - "READ_STRING", - "READ_SMART_ENTRYPOINT", - "READ_MICHELINE", - "READ_SORU_MESSAGES", - "READ_SORU_KIND", - "READ_BALLOT", - "READ_PROTOS" -}; +const char *const tz_operation_parser_step_name[] = {"MAGIC", + "READ_BINARY", + "BRANCH", + "BATCH", + "TAG", + "SIZE", + "OPERATION", + "PRINT", + "PARTIAL_PRINT", + "READ_NUM", + "READ_INT32", + "READ_PK", + "READ_BYTES", + "READ_STRING", + "READ_SMART_ENTRYPOINT", + "READ_MICHELINE", + "READ_SORU_MESSAGES", + "READ_SORU_KIND", + "READ_BALLOT", + "READ_PROTOS"}; #endif const tz_operation_field_descriptor proposals_fields[] = { - // Name, Kind, Req, Skip, None - { "Source", TZ_OPERATION_FIELD_PKH, true, false, false }, - { "Period", TZ_OPERATION_FIELD_INT32, true, false, false }, - { "Proposal", TZ_OPERATION_FIELD_PROTOS, true, false, false }, - { NULL, 0, 0, 0, 0 } + // Name, Kind, Req, Skip, None + {"Source", TZ_OPERATION_FIELD_PKH, true, false, false}, + {"Period", TZ_OPERATION_FIELD_INT32, true, false, false}, + {"Proposal", TZ_OPERATION_FIELD_PROTOS, true, false, false}, + {NULL, 0, 0, 0, 0 } }; const tz_operation_field_descriptor ballot_fields[] = { - // Name, Kind, Req, Skip, None - { "Source", TZ_OPERATION_FIELD_PKH, true, false, false }, - { "Period", TZ_OPERATION_FIELD_INT32, true, false, false }, - { "Proposal", TZ_OPERATION_FIELD_PROTO, true, false, false }, - { "Ballot", TZ_OPERATION_FIELD_BALLOT, true, false, false }, - { NULL, 0, 0, 0, 0 } + // Name, Kind, Req, Skip, None + {"Source", TZ_OPERATION_FIELD_PKH, true, false, false}, + {"Period", TZ_OPERATION_FIELD_INT32, true, false, false}, + {"Proposal", TZ_OPERATION_FIELD_PROTO, true, false, false}, + {"Ballot", TZ_OPERATION_FIELD_BALLOT, true, false, false}, + {NULL, 0, 0, 0, 0 } }; const tz_operation_field_descriptor failing_noop_fields[] = { - // Name, Kind, Req, Skip, None - { "Message", TZ_OPERATION_FIELD_BINARY, true, false, false }, - { NULL, 0, 0, 0, 0 } + // Name, Kind, Req, Skip, None + {"Message", TZ_OPERATION_FIELD_BINARY, true, false, false}, + {NULL, 0, 0, 0, 0 } }; const tz_operation_field_descriptor transaction_fields[] = { - // Name, Kind, Req, Skip, None - { "Source", TZ_OPERATION_FIELD_SOURCE, true, true, false }, - { "Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false }, - { "Counter", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Gas", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false }, - { "Amount", TZ_OPERATION_FIELD_AMOUNT, true, false, false }, - { "Destination", TZ_OPERATION_FIELD_DESTINATION, true, false, false }, - { "Parameter", TZ_OPERATION_FIELD_PARAMETER, false,false, false }, - { NULL, 0, 0, 0, 0 } + // Name, Kind, Req, Skip, None + {"Source", TZ_OPERATION_FIELD_SOURCE, true, true, false}, + {"Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false}, + {"Counter", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Gas", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false}, + {"Amount", TZ_OPERATION_FIELD_AMOUNT, true, false, false}, + {"Destination", TZ_OPERATION_FIELD_DESTINATION, true, false, false}, + {"Parameter", TZ_OPERATION_FIELD_PARAMETER, false, false, false}, + {NULL, 0, 0, 0, 0 } }; const tz_operation_field_descriptor reveal_fields[] = { - // Name, Kind, Req, Skip, None - { "Source", TZ_OPERATION_FIELD_SOURCE, true, true, false }, - { "Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false }, - { "Counter", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Gas", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false }, - { "Public key", TZ_OPERATION_FIELD_PK, true, false, false }, - { NULL, 0, 0, 0, 0 } + // Name, Kind, Req, Skip, None + {"Source", TZ_OPERATION_FIELD_SOURCE, true, true, false}, + {"Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false}, + {"Counter", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Gas", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false}, + {"Public key", TZ_OPERATION_FIELD_PK, true, false, false}, + {NULL, 0, 0, 0, 0 } }; const tz_operation_field_descriptor delegation_fields[] = { - // Name, Kind, Req, Skip, None - { "Source", TZ_OPERATION_FIELD_SOURCE, true, true, false }, - { "Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false }, - { "Counter", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Gas", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false }, - { "Delegate", TZ_OPERATION_FIELD_PKH, false,false, true }, - { NULL, 0, 0, 0, 0 } + // Name, Kind, Req, Skip, None + {"Source", TZ_OPERATION_FIELD_SOURCE, true, true, false}, + {"Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false}, + {"Counter", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Gas", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false}, + {"Delegate", TZ_OPERATION_FIELD_PKH, false, false, true }, + {NULL, 0, 0, 0, 0 } }; const tz_operation_field_descriptor reg_glb_cst_fields[] = { - // Name, Kind, Req, Skip, None - { "Source", TZ_OPERATION_FIELD_SOURCE, true, true, false }, - { "Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false }, - { "Counter", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Gas", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false }, - { "Value", TZ_OPERATION_FIELD_EXPR, true, false, false }, - { NULL, 0, 0, 0, 0 } + // Name, Kind, Req, Skip, None + {"Source", TZ_OPERATION_FIELD_SOURCE, true, true, false}, + {"Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false}, + {"Counter", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Gas", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false}, + {"Value", TZ_OPERATION_FIELD_EXPR, true, false, false}, + {NULL, 0, 0, 0, 0 } }; const tz_operation_field_descriptor set_deposit_fields[] = { - // Name, Kind, Req, Skip, None - { "Source", TZ_OPERATION_FIELD_SOURCE, true, true, false }, - { "Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false }, - { "Counter", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Gas", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false }, - { "Staking limit", TZ_OPERATION_FIELD_AMOUNT, false,false, true }, - { NULL, 0, 0, 0, 0 } + // Name, Kind, Req, Skip, None + {"Source", TZ_OPERATION_FIELD_SOURCE, true, true, false}, + {"Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false}, + {"Counter", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Gas", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false}, + {"Staking limit", TZ_OPERATION_FIELD_AMOUNT, false, false, true }, + {NULL, 0, 0, 0, 0 } }; const tz_operation_field_descriptor inc_paid_stg_fields[] = { - // Name, Kind, Req, Skip, None - { "Source", TZ_OPERATION_FIELD_SOURCE, true, true, false }, - { "Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false }, - { "Counter", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Gas", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false }, - { "Amount", TZ_OPERATION_FIELD_INT, true, false, false }, - { "Destination", TZ_OPERATION_FIELD_DESTINATION, true, false, false }, - { NULL, 0, 0, 0, 0 } + // Name, Kind, Req, Skip, None + {"Source", TZ_OPERATION_FIELD_SOURCE, true, true, false}, + {"Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false}, + {"Counter", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Gas", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false}, + {"Amount", TZ_OPERATION_FIELD_INT, true, false, false}, + {"Destination", TZ_OPERATION_FIELD_DESTINATION, true, false, false}, + {NULL, 0, 0, 0, 0 } }; const tz_operation_field_descriptor update_ck_fields[] = { - // Name, Kind, Req, Skip, None - { "Source", TZ_OPERATION_FIELD_SOURCE, true, true, false }, - { "Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false }, - { "Counter", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Gas", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false }, - { "Public key", TZ_OPERATION_FIELD_PK, true, false, false }, - { NULL, 0, 0, 0, 0 } + // Name, Kind, Req, Skip, None + {"Source", TZ_OPERATION_FIELD_SOURCE, true, true, false}, + {"Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false}, + {"Counter", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Gas", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false}, + {"Public key", TZ_OPERATION_FIELD_PK, true, false, false}, + {NULL, 0, 0, 0, 0 } }; const tz_operation_field_descriptor origination_fields[] = { - // Name, Kind, Req, Skip, None - { "Source", TZ_OPERATION_FIELD_SOURCE, true, true, false }, - { "Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false }, - { "Counter", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Gas", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false }, - { "Balance", TZ_OPERATION_FIELD_AMOUNT, true, false, false }, - { "Delegate", TZ_OPERATION_FIELD_PKH, false,false, true }, - { "Code", TZ_OPERATION_FIELD_EXPR, true, false, false }, - { "Storage", TZ_OPERATION_FIELD_EXPR, true, false, false }, - { NULL, 0, 0, 0, 0 } + // Name, Kind, Req, Skip, None + {"Source", TZ_OPERATION_FIELD_SOURCE, true, true, false}, + {"Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false}, + {"Counter", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Gas", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false}, + {"Balance", TZ_OPERATION_FIELD_AMOUNT, true, false, false}, + {"Delegate", TZ_OPERATION_FIELD_PKH, false, false, true }, + {"Code", TZ_OPERATION_FIELD_EXPR, true, false, false}, + {"Storage", TZ_OPERATION_FIELD_EXPR, true, false, false}, + {NULL, 0, 0, 0, 0 } }; - const tz_operation_field_descriptor transfer_tck_fields[] = { - // Name, Kind, Req, Skip, None - { "Source", TZ_OPERATION_FIELD_SOURCE, true, true, false }, - { "Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false }, - { "Counter", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Gas", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false }, - { "Contents", TZ_OPERATION_FIELD_EXPR, true, false, false }, - { "Type", TZ_OPERATION_FIELD_EXPR, true, false, false }, - { "Ticketer", TZ_OPERATION_FIELD_DESTINATION, true, false, false }, - { "Amount", TZ_OPERATION_FIELD_NAT, true, false, false }, - { "Destination", TZ_OPERATION_FIELD_DESTINATION, true, false, false }, - { "Entrypoint", TZ_OPERATION_FIELD_STRING, true, false, false }, - { NULL, 0, 0, 0, 0 } + // Name, Kind, Req, Skip, None + {"Source", TZ_OPERATION_FIELD_SOURCE, true, true, false}, + {"Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false}, + {"Counter", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Gas", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false}, + {"Contents", TZ_OPERATION_FIELD_EXPR, true, false, false}, + {"Type", TZ_OPERATION_FIELD_EXPR, true, false, false}, + {"Ticketer", TZ_OPERATION_FIELD_DESTINATION, true, false, false}, + {"Amount", TZ_OPERATION_FIELD_NAT, true, false, false}, + {"Destination", TZ_OPERATION_FIELD_DESTINATION, true, false, false}, + {"Entrypoint", TZ_OPERATION_FIELD_STRING, true, false, false}, + {NULL, 0, 0, 0, 0 } }; const tz_operation_field_descriptor soru_add_msg_fields[] = { - // Name, Kind, Req, Skip, None - { "Source", TZ_OPERATION_FIELD_SOURCE, true, true, false }, - { "Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false }, - { "Counter", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Gas", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false }, - { "Message", TZ_OPERATION_FIELD_SORU_MESSAGES, true, false, false }, - { NULL, 0, 0, 0, 0 } + // Name, Kind, Req, Skip, None + {"Source", TZ_OPERATION_FIELD_SOURCE, true, true, false}, + {"Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false}, + {"Counter", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Gas", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false}, + {"Message", TZ_OPERATION_FIELD_SORU_MESSAGES, true, false, false}, + {NULL, 0, 0, 0, 0 } }; const tz_operation_field_descriptor soru_exe_msg_fields[] = { - // Name, Kind, Req, Skip, None - { "Source", TZ_OPERATION_FIELD_SOURCE, true, true, false }, - { "Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false }, - { "Counter", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Gas", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false }, - { "Rollup", TZ_OPERATION_FIELD_SR, true, false, false }, - { "Commitment", TZ_OPERATION_FIELD_SRC, true, false, false }, - { "Output proof", TZ_OPERATION_FIELD_BINARY, true, false, false }, - { NULL, 0, 0, 0, 0 } + // Name, Kind, Req, Skip, None + {"Source", TZ_OPERATION_FIELD_SOURCE, true, true, false}, + {"Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false}, + {"Counter", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Gas", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false}, + {"Rollup", TZ_OPERATION_FIELD_SR, true, false, false}, + {"Commitment", TZ_OPERATION_FIELD_SRC, true, false, false}, + {"Output proof", TZ_OPERATION_FIELD_BINARY, true, false, false}, + {NULL, 0, 0, 0, 0 } }; const tz_operation_field_descriptor soru_origin_fields[] = { - // Name, Kind, Req, Skip, None - { "Source", TZ_OPERATION_FIELD_SOURCE, true, true, false }, - { "Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false }, - { "Counter", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Gas", TZ_OPERATION_FIELD_NAT, true, true, false }, - { "Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false }, - { "Kind", TZ_OPERATION_FIELD_SORU_KIND, true, false, false }, - { "Kernel", TZ_OPERATION_FIELD_BINARY, true, false, false }, - { "Proof", TZ_OPERATION_FIELD_BINARY, true, false, false }, - { "Parameters", TZ_OPERATION_FIELD_EXPR, true, false, false }, - { NULL, 0, 0, 0, 0 } + // Name, Kind, Req, Skip, None + {"Source", TZ_OPERATION_FIELD_SOURCE, true, true, false}, + {"Fee", TZ_OPERATION_FIELD_AMOUNT, true, false, false}, + {"Counter", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Gas", TZ_OPERATION_FIELD_NAT, true, true, false}, + {"Storage limit", TZ_OPERATION_FIELD_NAT, true, false, false}, + {"Kind", TZ_OPERATION_FIELD_SORU_KIND, true, false, false}, + {"Kernel", TZ_OPERATION_FIELD_BINARY, true, false, false}, + {"Proof", TZ_OPERATION_FIELD_BINARY, true, false, false}, + {"Parameters", TZ_OPERATION_FIELD_EXPR, true, false, false}, + {NULL, 0, 0, 0, 0 } }; const tz_operation_descriptor tz_operation_descriptors[] = { - { TZ_OPERATION_TAG_PROPOSALS, "Proposals", proposals_fields }, - { TZ_OPERATION_TAG_BALLOT, "Ballot", ballot_fields }, - { TZ_OPERATION_TAG_FAILING_NOOP, "Failing noop", failing_noop_fields }, - { TZ_OPERATION_TAG_REVEAL, "Reveal", reveal_fields }, - { TZ_OPERATION_TAG_TRANSACTION, "Transaction", transaction_fields }, - { TZ_OPERATION_TAG_ORIGINATION, "Origination", origination_fields }, - { TZ_OPERATION_TAG_DELEGATION, "Delegation", delegation_fields }, - { TZ_OPERATION_TAG_REG_GLB_CST, "Register global constant", reg_glb_cst_fields }, - { TZ_OPERATION_TAG_SET_DEPOSIT, "Set deposit limit", set_deposit_fields }, - { TZ_OPERATION_TAG_INC_PAID_STG, "Increase paid storage", inc_paid_stg_fields }, - { TZ_OPERATION_TAG_UPDATE_CK, "Set consensus key", update_ck_fields }, - { TZ_OPERATION_TAG_TRANSFER_TCK, "Transfer ticket", transfer_tck_fields }, - { TZ_OPERATION_TAG_SORU_ADD_MSG, "SR: send messages", soru_add_msg_fields }, - { TZ_OPERATION_TAG_SORU_EXE_MSG, "SR: execute outbox message", soru_exe_msg_fields }, - { TZ_OPERATION_TAG_SORU_ORIGIN, "SR: originate", soru_origin_fields }, - { 0, NULL, 0 } + {TZ_OPERATION_TAG_PROPOSALS, "Proposals", proposals_fields }, + {TZ_OPERATION_TAG_BALLOT, "Ballot", ballot_fields }, + {TZ_OPERATION_TAG_FAILING_NOOP, "Failing noop", failing_noop_fields}, + {TZ_OPERATION_TAG_REVEAL, "Reveal", reveal_fields }, + {TZ_OPERATION_TAG_TRANSACTION, "Transaction", transaction_fields }, + {TZ_OPERATION_TAG_ORIGINATION, "Origination", origination_fields }, + {TZ_OPERATION_TAG_DELEGATION, "Delegation", delegation_fields }, + {TZ_OPERATION_TAG_REG_GLB_CST, "Register global constant", + reg_glb_cst_fields }, + {TZ_OPERATION_TAG_SET_DEPOSIT, "Set deposit limit", set_deposit_fields }, + {TZ_OPERATION_TAG_INC_PAID_STG, "Increase paid storage", + inc_paid_stg_fields }, + {TZ_OPERATION_TAG_UPDATE_CK, "Set consensus key", update_ck_fields }, + {TZ_OPERATION_TAG_TRANSFER_TCK, "Transfer ticket", transfer_tck_fields}, + {TZ_OPERATION_TAG_SORU_ADD_MSG, "SR: send messages", soru_add_msg_fields}, + {TZ_OPERATION_TAG_SORU_EXE_MSG, "SR: execute outbox message", + soru_exe_msg_fields }, + {TZ_OPERATION_TAG_SORU_ORIGIN, "SR: originate", soru_origin_fields }, + {0, NULL, 0 } }; -static const char* expression_name = "Expression"; -static const char* unset_message = "Field unset"; +static const char *expression_name = "Expression"; +static const char *unset_message = "Field unset"; -static tz_parser_result push_frame(tz_parser_state *state, - tz_operation_parser_step_kind step) { +static tz_parser_result +push_frame(tz_parser_state *state, tz_operation_parser_step_kind step) +{ tz_operation_state *op = &state->operation; - if (op->frame >= - &op->stack[TZ_OPERATION_STACK_DEPTH - 1]) + if (op->frame >= &op->stack[TZ_OPERATION_STACK_DEPTH - 1]) tz_raise(TOO_DEEP); - op->frame++ ; + op->frame++; op->frame->step = step; tz_continue; } -static tz_parser_result pop_frame(tz_parser_state *state) { +static tz_parser_result +pop_frame(tz_parser_state *state) +{ tz_operation_state *op = &state->operation; if (op->frame == op->stack) { op->frame = NULL; - tz_stop(DONE); + tz_stop(DONE); } op->frame--; tz_continue; } -void tz_operation_parser_set_size(tz_parser_state *state, uint16_t size) { +void +tz_operation_parser_set_size(tz_parser_state *state, uint16_t size) +{ state->operation.stack[0].stop = size; } -void tz_operation_parser_init(tz_parser_state *state, uint16_t size, - bool skip_magic) { +void +tz_operation_parser_init(tz_parser_state *state, uint16_t size, + bool skip_magic) +{ tz_operation_state *op = &state->operation; tz_parser_init(state); state->operation.seen_reveal = 0; memset(&state->operation.source, 0, 22); memset(&state->operation.destination, 0, 22); - op->batch_index = 0; - op->frame = op->stack; + op->batch_index = 0; + op->frame = op->stack; op->stack[0].stop = size; if (!skip_magic) { op->stack[0].step = TZ_OPERATION_STEP_MAGIC; } else { strcpy(state->field_name, "Branch"); op->stack[0].step = TZ_OPERATION_STEP_BRANCH; - push_frame(state, TZ_OPERATION_STEP_READ_BYTES); // ignore result, - // assume success + push_frame(state, TZ_OPERATION_STEP_READ_BYTES); // ignore result, + // assume success op->frame->step_read_bytes.kind = TZ_OPERATION_FIELD_BH; op->frame->step_read_bytes.skip = true; - op->frame->step_read_bytes.ofs = 0; - op->frame->step_read_bytes.len = 32; + op->frame->step_read_bytes.ofs = 0; + op->frame->step_read_bytes.len = 32; } } -static tz_parser_result tz_print_string(tz_parser_state *state) { +static tz_parser_result +tz_print_string(tz_parser_state *state) +{ tz_operation_state *op = &state->operation; if (op->frame->step_read_string.skip) { tz_must(pop_frame(state)); tz_continue; } - op->frame->step = TZ_OPERATION_STEP_PRINT; - op->frame->step_print.str = (char*) state->buffers.capture; + op->frame->step = TZ_OPERATION_STEP_PRINT; + op->frame->step_print.str = (char *)state->buffers.capture; tz_continue; } -tz_parser_result tz_operation_parser_step(tz_parser_state *state) { - tz_operation_state *op = &state->operation; - tz_parser_regs *regs = &state->regs; - uint8_t *capture = state->buffers.capture; +tz_parser_result +tz_operation_parser_step(tz_parser_state *state) +{ + tz_operation_state *op = &state->operation; + tz_parser_regs *regs = &state->regs; + uint8_t *capture = state->buffers.capture; // cannot restart after error - if (TZ_IS_ERR(state->errno)) tz_reraise; + if (TZ_IS_ERR(state->errno)) + tz_reraise; // nothing else to do - if (op->frame == NULL) tz_stop(DONE); - - PRINTF("[DEBUG] operation(frame: %d, offset:%d/%d, ilen: %d, olen: %d, " - "step: %s, errno: %s)\n", - (int) (op->frame - op->stack), - (int) state->ofs, - (int) op->stack[0].stop, - (int) regs->ilen, - (int) regs->oofs, - (const char*) - PIC(tz_operation_parser_step_name[op->frame->step]), - tz_parser_result_name(state->errno)); + if (op->frame == NULL) + tz_stop(DONE); + + PRINTF( + "[DEBUG] operation(frame: %d, offset:%d/%d, ilen: %d, olen: %d, " + "step: %s, errno: %s)\n", + (int)(op->frame - op->stack), (int)state->ofs, (int)op->stack[0].stop, + (int)regs->ilen, (int)regs->oofs, + (const char *)PIC(tz_operation_parser_step_name[op->frame->step]), + tz_parser_result_name(state->errno)); switch (op->frame->step) { case TZ_OPERATION_STEP_MAGIC: { uint8_t b; tz_must(tz_parser_read(state, &b)); switch (b) { - case 3: // manager/anonymous operation + case 3: // manager/anonymous operation strcpy(state->field_name, "Branch"); op->stack[0].step = TZ_OPERATION_STEP_BRANCH; - push_frame(state, TZ_OPERATION_STEP_READ_BYTES); // ignore result, - // assume success + push_frame(state, + TZ_OPERATION_STEP_READ_BYTES); // ignore result, + // assume success op->frame->step_read_bytes.kind = TZ_OPERATION_FIELD_BH; op->frame->step_read_bytes.skip = true; - op->frame->step_read_bytes.ofs = 0; - op->frame->step_read_bytes.len = 32; + op->frame->step_read_bytes.ofs = 0; + op->frame->step_read_bytes.len = 32; break; - case 5: // micheline expression + case 5: // micheline expression op->frame->step = TZ_OPERATION_STEP_READ_MICHELINE; op->frame->step_read_micheline.inited = 0; - op->frame->step_read_micheline.skip = false; - op->frame->step_read_micheline.name = - (char*) PIC(expression_name); + op->frame->step_read_micheline.skip = false; + op->frame->step_read_micheline.name + = (char *)PIC(expression_name); op->frame->stop = 0; break; - default: tz_raise(INVALID_TAG); + default: + tz_raise(INVALID_TAG); } - break; - } + break; + } case TZ_OPERATION_STEP_SIZE: { uint8_t b; tz_must(tz_parser_read(state, &b)); if (op->frame->step_size.size > 255) - tz_raise(TOO_LARGE); // enforce 16-bit restriction + tz_raise(TOO_LARGE); // enforce 16-bit restriction op->frame->step_size.size = op->frame->step_size.size << 8 | b; op->frame->step_size.size_len--; if (op->frame->step_size.size_len <= 0) { - op->frame[-1].stop = - state->ofs + op->frame->step_size.size; + op->frame[-1].stop = state->ofs + op->frame->step_size.size; tz_must(pop_frame(state)); } break; } case TZ_OPERATION_STEP_TAG: { - const tz_operation_descriptor* d; - uint8_t t; + const tz_operation_descriptor *d; + uint8_t t; tz_must(tz_parser_read(state, &t)); - for (d = tz_operation_descriptors; d->tag != TZ_OPERATION_TAG_END; d++) { + for (d = tz_operation_descriptors; d->tag != TZ_OPERATION_TAG_END; + d++) { if (d->tag == t) { op->frame->step = TZ_OPERATION_STEP_OPERATION; op->frame->step_operation.descriptor = d; - op->frame->step_operation.field = 0; + op->frame->step_operation.field = 0; tz_must(push_frame(state, TZ_OPERATION_STEP_PRINT)); snprintf(state->field_name, 30, "Operation (%d)", op->batch_index); @@ -389,24 +399,23 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { tz_continue; } } - tz_raise(INVALID_TAG); + tz_raise(INVALID_TAG); } case TZ_OPERATION_STEP_READ_MICHELINE: { if (!op->frame->step_read_micheline.inited) { op->frame->step_read_micheline.inited = 1; - strcpy(state->field_name, - op->frame->step_read_micheline.name); + strcpy(state->field_name, op->frame->step_read_micheline.name); tz_micheline_parser_init(state); } tz_micheline_parser_step(state); if (state->errno == TZ_BLO_DONE) { - if (op->frame->stop != 0 && - state->ofs != op->frame->stop) + if (op->frame->stop != 0 && state->ofs != op->frame->stop) tz_raise(TOO_LARGE); tz_must(pop_frame(state)); if (regs->oofs > 0) tz_stop(IM_FULL); - else tz_continue; + else + tz_continue; } tz_reraise; } @@ -421,14 +430,16 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { tz_must(pop_frame(state)); tz_continue; } - char *str = state->buffers.num.decimal; + char *str = state->buffers.num.decimal; op->frame->step = TZ_OPERATION_STEP_PRINT; switch (op->frame->step_read_num.kind) { case TZ_OPERATION_FIELD_INT: - case TZ_OPERATION_FIELD_NAT: break; + case TZ_OPERATION_FIELD_NAT: + break; case TZ_OPERATION_FIELD_AMOUNT: { int len = 0; - while (str[len])len++; + while (str[len]) + len++; if (len == 1 && str[0] == 0) // just 0 goto add_currency; @@ -436,34 +447,42 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { // less than one tez, pad left up to the '0.' int j; int pad = 7 - len; - for (j=len;j>=0;j--) str[j+pad] = str[j]; - for (j=0;j= 0; j--) + str[j + pad] = str[j]; + for (j = 0; j < pad; j++) + str[j] = '0'; len = 7; } int no_decimals = 1; - for (int i=0;i<6;i++) no_decimals &= (str[len-1-i] == '0'); + for (int i = 0; i < 6; i++) + no_decimals &= (str[len - 1 - i] == '0'); if (no_decimals) { // integral value, don't include the decimal part (no '.'_ str[len - 6] = 0; len -= 6; } else { // more than one tez, add the '.' - for (int i=0;i<6;i++) str[len-i] = str[len-i-1]; + for (int i = 0; i < 6; i++) + str[len - i] = str[len - i - 1]; str[len - 6] = '.'; len++; str[len] = 0; // drop trailing non significant zeroes - while (str[len-1] == '0') { len--; str[len] = 0; } + while (str[len - 1] == '0') { + len--; + str[len] = 0; + } } - add_currency: - str[len] = ' '; - str[len+1] = 't'; - str[len+2] = 'z'; + add_currency: + str[len] = ' '; + str[len + 1] = 't'; + str[len + 2] = 'z'; len += 3; str[len] = 0; break; } - default: tz_raise(INVALID_STATE); + default: + tz_raise(INVALID_STATE); } op->frame->step_print.str = str; } @@ -471,18 +490,17 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { } case TZ_OPERATION_STEP_READ_INT32: { uint32_t value = 0; - uint8_t b; + uint8_t b; for (int ofs = 0; ofs < 4; ofs++) { tz_must(tz_parser_read(state, &b)); value = value << 8 | b; } - snprintf((char*) capture, 30, "%d", value); + snprintf((char *)capture, 30, "%d", value); tz_must(tz_print_string(state)); break; } case TZ_OPERATION_STEP_READ_BYTES: { - if (op->frame->step_read_bytes.ofs < - op->frame->step_read_bytes.len) { + if (op->frame->step_read_bytes.ofs < op->frame->step_read_bytes.len) { uint8_t *c; c = &capture[op->frame->step_read_bytes.ofs]; tz_must(tz_parser_read(state, c)); @@ -497,43 +515,47 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { memcpy(op->source, capture, 22); __attribute__((fallthrough)); case TZ_OPERATION_FIELD_PKH: - if (tz_format_pkh(capture, 21, (char*) capture)) + if (tz_format_pkh(capture, 21, (char *)capture)) tz_raise(INVALID_TAG); break; case TZ_OPERATION_FIELD_PK: if (tz_format_pk(capture, op->frame->step_read_bytes.len, - (char*) capture)) + (char *)capture)) tz_raise(INVALID_TAG); break; case TZ_OPERATION_FIELD_SR: - if (tz_format_base58check("sr1", capture, 20, (char*) capture)) + if (tz_format_base58check("sr1", capture, 20, + (char *)capture)) tz_raise(INVALID_TAG); break; case TZ_OPERATION_FIELD_SRC: - if (tz_format_base58check("src1", capture, 32, (char*) capture)) + if (tz_format_base58check("src1", capture, 32, + (char *)capture)) tz_raise(INVALID_TAG); break; case TZ_OPERATION_FIELD_PROTO: - if (tz_format_base58check("proto", capture, 32, (char*) capture)) + if (tz_format_base58check("proto", capture, 32, + (char *)capture)) tz_raise(INVALID_TAG); break; case TZ_OPERATION_FIELD_DESTINATION: memcpy(op->destination, capture, 22); - if (tz_format_address(capture, 22, (char*) capture)) + if (tz_format_address(capture, 22, (char *)capture)) tz_raise(INVALID_TAG); break; case TZ_OPERATION_FIELD_OPH: - if (tz_format_oph(capture, 32, (char*) capture)) + if (tz_format_oph(capture, 32, (char *)capture)) tz_raise(INVALID_TAG); break; case TZ_OPERATION_FIELD_BH: - if (tz_format_bh(capture, 32, (char*) capture)) + if (tz_format_bh(capture, 32, (char *)capture)) tz_raise(INVALID_TAG); break; - default: tz_raise(INVALID_STATE); + default: + tz_raise(INVALID_STATE); } - op->frame->step = TZ_OPERATION_STEP_PRINT; - op->frame->step_print.str = (char*) capture; + op->frame->step = TZ_OPERATION_STEP_PRINT; + op->frame->step_print.str = (char *)capture; } break; } @@ -569,17 +591,18 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { if (state->ofs == op->frame->stop) { capture[op->frame->step_read_string.ofs] = 0; tz_must(tz_print_string(state)); - } else if (op->frame->step_read_string.ofs + 2 >= TZ_CAPTURE_BUFFER_SIZE) { + } else if (op->frame->step_read_string.ofs + 2 + >= TZ_CAPTURE_BUFFER_SIZE) { capture[op->frame->step_read_string.ofs] = 0; - op->frame->step_read_string.ofs = 0; + op->frame->step_read_string.ofs = 0; if (!op->frame->step_read_string.skip) { tz_must(push_frame(state, TZ_OPERATION_STEP_PARTIAL_PRINT)); - op->frame->step_print.str = (char*) capture; + op->frame->step_print.str = (char *)capture; } } else { uint8_t b; tz_must(tz_parser_read(state, &b)); - char* buf = (char*) capture + op->frame->step_read_string.ofs; + char *buf = (char *)capture + op->frame->step_read_string.ofs; snprintf(buf, 4, "%02x", b); op->frame->step_read_string.ofs += 2; } @@ -590,45 +613,46 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { tz_must(tz_parser_read(state, &b)); switch (b) { case 0: - strcpy((char*) capture, "default"); + strcpy((char *)capture, "default"); tz_must(tz_print_string(state)); break; case 1: - strcpy((char*) capture, "root"); + strcpy((char *)capture, "root"); tz_must(tz_print_string(state)); break; case 2: - strcpy((char*) capture, "do"); + strcpy((char *)capture, "do"); tz_must(tz_print_string(state)); break; case 3: - strcpy((char*) capture, "set_delegate"); + strcpy((char *)capture, "set_delegate"); tz_must(tz_print_string(state)); break; case 4: - strcpy((char*) capture, "remove_delegate"); + strcpy((char *)capture, "remove_delegate"); tz_must(tz_print_string(state)); break; case 5: - strcpy((char*) capture, "deposit"); + strcpy((char *)capture, "deposit"); tz_must(tz_print_string(state)); break; case 0xFF: - op->frame->step = TZ_OPERATION_STEP_READ_STRING; + op->frame->step = TZ_OPERATION_STEP_READ_STRING; op->frame->step_read_string.ofs = 0; tz_must(push_frame(state, TZ_OPERATION_STEP_SIZE)); - op->frame->step_size.size = 0; + op->frame->step_size.size = 0; op->frame->step_size.size_len = 1; break; - default: tz_raise(INVALID_TAG); + default: + tz_raise(INVALID_TAG); } break; } case TZ_OPERATION_STEP_OPERATION: { - const tz_operation_descriptor *d = - op->frame->step_operation.descriptor; - const tz_operation_field_descriptor *field = - PIC(&d->fields[op->frame->step_operation.field]); + const tz_operation_descriptor *d + = op->frame->step_operation.descriptor; + const tz_operation_field_descriptor *field + = PIC(&d->fields[op->frame->step_operation.field]); const char *name = PIC(field->name); // Remaining content from previous section - display this first. @@ -646,19 +670,20 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { op->frame->step_operation.field++; if (!present) { if (field->display_none) { - if (field->skip) tz_raise(INVALID_STATE); + if (field->skip) + tz_raise(INVALID_STATE); tz_must(push_frame(state, TZ_OPERATION_STEP_PRINT)); - op->frame->step_print.str = (char*) unset_message; + op->frame->step_print.str = (char *)unset_message; } tz_continue; } switch (field->kind) { case TZ_OPERATION_FIELD_BINARY: { tz_must(push_frame(state, TZ_OPERATION_STEP_READ_BINARY)); - op->frame->step_read_string.ofs = 0; + op->frame->step_read_string.ofs = 0; op->frame->step_read_string.skip = field->skip; tz_must(push_frame(state, TZ_OPERATION_STEP_SIZE)); - op->frame->step_size.size = 0; + op->frame->step_size.size = 0; op->frame->step_size.size_len = 4; break; } @@ -667,8 +692,8 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { tz_must(push_frame(state, TZ_OPERATION_STEP_READ_BYTES)); op->frame->step_read_bytes.kind = field->kind; op->frame->step_read_bytes.skip = field->skip; - op->frame->step_read_bytes.ofs = 0; - op->frame->step_read_bytes.len = 21; + op->frame->step_read_bytes.ofs = 0; + op->frame->step_read_bytes.len = 21; break; } case TZ_OPERATION_FIELD_PK: { @@ -680,33 +705,33 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { tz_must(push_frame(state, TZ_OPERATION_STEP_READ_BYTES)); op->frame->step_read_bytes.kind = field->kind; op->frame->step_read_bytes.skip = field->skip; - op->frame->step_read_bytes.ofs = 0; - op->frame->step_read_bytes.len = 20; + op->frame->step_read_bytes.ofs = 0; + op->frame->step_read_bytes.len = 20; break; } case TZ_OPERATION_FIELD_SRC: { tz_must(push_frame(state, TZ_OPERATION_STEP_READ_BYTES)); op->frame->step_read_bytes.kind = field->kind; op->frame->step_read_bytes.skip = field->skip; - op->frame->step_read_bytes.ofs = 0; - op->frame->step_read_bytes.len = 32; + op->frame->step_read_bytes.ofs = 0; + op->frame->step_read_bytes.len = 32; break; } case TZ_OPERATION_FIELD_PROTO: { tz_must(push_frame(state, TZ_OPERATION_STEP_READ_BYTES)); op->frame->step_read_bytes.kind = field->kind; op->frame->step_read_bytes.skip = field->skip; - op->frame->step_read_bytes.ofs = 0; - op->frame->step_read_bytes.len = 32; + op->frame->step_read_bytes.ofs = 0; + op->frame->step_read_bytes.len = 32; break; } case TZ_OPERATION_FIELD_PROTOS: { tz_must(push_frame(state, TZ_OPERATION_STEP_READ_PROTOS)); - op->frame->step_read_list.name = name; + op->frame->step_read_list.name = name; op->frame->step_read_list.index = 0; - op->frame->step_read_list.skip = field->skip; - tz_must (push_frame(state, TZ_OPERATION_STEP_SIZE)); - op->frame->step_size.size = 0; + op->frame->step_read_list.skip = field->skip; + tz_must(push_frame(state, TZ_OPERATION_STEP_SIZE)); + op->frame->step_size.size = 0; op->frame->step_size.size_len = 4; break; } @@ -714,8 +739,8 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { tz_must(push_frame(state, TZ_OPERATION_STEP_READ_BYTES)); op->frame->step_read_bytes.kind = field->kind; op->frame->step_read_bytes.skip = field->skip; - op->frame->step_read_bytes.ofs = 0; - op->frame->step_read_bytes.len = 22; + op->frame->step_read_bytes.ofs = 0; + op->frame->step_read_bytes.len = 22; break; } case TZ_OPERATION_FIELD_NAT: @@ -723,8 +748,8 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { tz_must(push_frame(state, TZ_OPERATION_STEP_READ_NUM)); tz_parse_num_state_init(&state->buffers.num, &op->frame->step_read_num.state); - op->frame->step_read_num.kind = field->kind; - op->frame->step_read_num.skip = field->skip; + op->frame->step_read_num.kind = field->kind; + op->frame->step_read_num.skip = field->skip; op->frame->step_read_num.natural = 1; break; } @@ -732,8 +757,8 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { tz_must(push_frame(state, TZ_OPERATION_STEP_READ_NUM)); tz_parse_num_state_init(&state->buffers.num, &op->frame->step_read_num.state); - op->frame->step_read_num.kind = field->kind; - op->frame->step_read_num.skip = field->skip; + op->frame->step_read_num.kind = field->kind; + op->frame->step_read_num.skip = field->skip; op->frame->step_read_num.natural = 0; break; } @@ -745,43 +770,45 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { case TZ_OPERATION_FIELD_PARAMETER: { tz_must(push_frame(state, TZ_OPERATION_STEP_READ_MICHELINE)); op->frame->step_read_micheline.inited = 0; - op->frame->step_read_micheline.skip = field->skip; - op->frame->step_read_micheline.name = name; + op->frame->step_read_micheline.skip = field->skip; + op->frame->step_read_micheline.name = name; tz_must(push_frame(state, TZ_OPERATION_STEP_SIZE)); - op->frame->step_size.size = 0; + op->frame->step_size.size = 0; op->frame->step_size.size_len = 4; - tz_must(push_frame(state, TZ_OPERATION_STEP_READ_SMART_ENTRYPOINT)); + tz_must(push_frame(state, + TZ_OPERATION_STEP_READ_SMART_ENTRYPOINT)); strcpy(state->field_name, "Entrypoint"); - op->frame->step_read_string.ofs = 0; + op->frame->step_read_string.ofs = 0; op->frame->step_read_string.skip = field->skip; break; } case TZ_OPERATION_FIELD_EXPR: { tz_must(push_frame(state, TZ_OPERATION_STEP_READ_MICHELINE)); op->frame->step_read_micheline.inited = 0; - op->frame->step_read_micheline.skip = field->skip; - op->frame->step_read_micheline.name = name; + op->frame->step_read_micheline.skip = field->skip; + op->frame->step_read_micheline.name = name; tz_must(push_frame(state, TZ_OPERATION_STEP_SIZE)); - op->frame->step_size.size = 0; + op->frame->step_size.size = 0; op->frame->step_size.size_len = 4; break; } case TZ_OPERATION_FIELD_STRING: { tz_must(push_frame(state, TZ_OPERATION_STEP_READ_STRING)); - op->frame->step_read_string.ofs = 0; + op->frame->step_read_string.ofs = 0; op->frame->step_read_string.skip = field->skip; tz_must(push_frame(state, TZ_OPERATION_STEP_SIZE)); - op->frame->step_size.size = 0; + op->frame->step_size.size = 0; op->frame->step_size.size_len = 4; break; } case TZ_OPERATION_FIELD_SORU_MESSAGES: { - tz_must(push_frame(state, TZ_OPERATION_STEP_READ_SORU_MESSAGES)); - op->frame->step_read_list.name = name; + tz_must( + push_frame(state, TZ_OPERATION_STEP_READ_SORU_MESSAGES)); + op->frame->step_read_list.name = name; op->frame->step_read_list.index = 0; - op->frame->step_read_list.skip = field->skip; + op->frame->step_read_list.skip = field->skip; tz_must(push_frame(state, TZ_OPERATION_STEP_SIZE)); - op->frame->step_size.size = 0; + op->frame->step_size.size = 0; op->frame->step_size.size_len = 4; break; } @@ -795,7 +822,8 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { op->frame->step_read_string.skip = field->skip; break; } - default: tz_raise(INVALID_STATE); + default: + tz_raise(INVALID_STATE); } } break; @@ -804,18 +832,18 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { uint8_t b; tz_must(tz_parser_peek(state, &b)); op->frame->step_read_bytes.kind = TZ_OPERATION_FIELD_PK; - op->frame->step_read_bytes.ofs = 0; - switch (b){ - case 0: // edpk + op->frame->step_read_bytes.ofs = 0; + switch (b) { + case 0: // edpk op->frame->step_read_bytes.len = 33; break; - case 1: // sppk + case 1: // sppk op->frame->step_read_bytes.len = 34; break; - case 2: // p2pk + case 2: // p2pk op->frame->step_read_bytes.len = 34; break; - case 3: // BLpk + case 3: // BLpk op->frame->step_read_bytes.len = 49; break; default: @@ -825,9 +853,9 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { break; } case TZ_OPERATION_STEP_READ_SORU_MESSAGES: { - uint8_t skip = op->frame->step_read_list.skip; - const char* name = op->frame->step_read_list.name; - uint16_t index = op->frame->step_read_list.index; + uint8_t skip = op->frame->step_read_list.skip; + const char *name = op->frame->step_read_list.name; + uint16_t index = op->frame->step_read_list.index; // Remaining content from previous message - display this first. if (regs->oofs > 0) @@ -838,11 +866,12 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { } else { op->frame->step_read_list.index++; tz_must(push_frame(state, TZ_OPERATION_STEP_READ_BINARY)); - snprintf(state->field_name, TZ_FIELD_NAME_SIZE, "%s (%d)", name, index); - op->frame->step_read_string.ofs = 0; + snprintf(state->field_name, TZ_FIELD_NAME_SIZE, "%s (%d)", name, + index); + op->frame->step_read_string.ofs = 0; op->frame->step_read_string.skip = skip; tz_must(push_frame(state, TZ_OPERATION_STEP_SIZE)); - op->frame->step_size.size = 0; + op->frame->step_size.size = 0; op->frame->step_size.size_len = 4; } break; @@ -850,14 +879,15 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { case TZ_OPERATION_STEP_READ_SORU_KIND: { uint8_t b; tz_must(tz_parser_read(state, &b)); - switch(b) { + switch (b) { case 0: - strcpy((char*) capture, "arith"); + strcpy((char *)capture, "arith"); break; case 1: - strcpy((char*) capture, "wasm_2_0_0"); + strcpy((char *)capture, "wasm_2_0_0"); break; - default: tz_raise(INVALID_TAG); + default: + tz_raise(INVALID_TAG); } tz_must(tz_print_string(state)); break; @@ -865,25 +895,26 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { case TZ_OPERATION_STEP_READ_BALLOT: { uint8_t b; tz_must(tz_parser_read(state, &b)); - switch(b) { + switch (b) { case 0: - strcpy((char*) capture, "yay"); + strcpy((char *)capture, "yay"); break; case 1: - strcpy((char*) capture, "nay"); + strcpy((char *)capture, "nay"); break; case 2: - strcpy((char*) capture, "pass"); + strcpy((char *)capture, "pass"); break; - default: tz_raise(INVALID_TAG); + default: + tz_raise(INVALID_TAG); } tz_must(tz_print_string(state)); break; } case TZ_OPERATION_STEP_READ_PROTOS: { - uint8_t skip = op->frame->step_read_list.skip; - const char* name = op->frame->step_read_list.name; - uint16_t index = op->frame->step_read_list.index; + uint8_t skip = op->frame->step_read_list.skip; + const char *name = op->frame->step_read_list.name; + uint16_t index = op->frame->step_read_list.index; // Remaining content from previous proto - display this first. if (regs->oofs > 0) @@ -897,13 +928,13 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { snprintf(state->field_name, 30, "%s (%d)", name, index); op->frame->step_read_bytes.kind = TZ_OPERATION_FIELD_PROTO; op->frame->step_read_bytes.skip = skip; - op->frame->step_read_bytes.ofs = 0; - op->frame->step_read_bytes.len = 32; + op->frame->step_read_bytes.ofs = 0; + op->frame->step_read_bytes.len = 32; } break; } case TZ_OPERATION_STEP_PRINT: { - const char* str = PIC(op->frame->step_print.str); + const char *str = PIC(op->frame->step_print.str); if (*str) { tz_must(tz_parser_put(state, *str)); op->frame->step_print.str++; @@ -914,7 +945,7 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { break; } case TZ_OPERATION_STEP_PARTIAL_PRINT: { - const char* str = PIC(op->frame->step_print.str); + const char *str = PIC(op->frame->step_print.str); if (*str) { tz_must(tz_parser_put(state, *str)); op->frame->step_print.str++; @@ -923,7 +954,8 @@ tz_parser_result tz_operation_parser_step(tz_parser_state *state) { } break; } - default: tz_raise(INVALID_STATE); + default: + tz_raise(INVALID_STATE); } tz_continue; } diff --git a/app/src/parser/operation_parser.h b/app/src/parser/operation_parser.h index eba79def5..fb5004eb1 100644 --- a/app/src/parser/operation_parser.h +++ b/app/src/parser/operation_parser.h @@ -19,6 +19,6 @@ #include "parser_state.h" #define TZ_UNKNOWN_SIZE 0xFFFF -void tz_operation_parser_init(tz_parser_state *, uint16_t, bool); -void tz_operation_parser_set_size(tz_parser_state *, uint16_t); +void tz_operation_parser_init(tz_parser_state *, uint16_t, bool); +void tz_operation_parser_set_size(tz_parser_state *, uint16_t); tz_parser_result tz_operation_parser_step(tz_parser_state *); diff --git a/app/src/parser/operation_state.h b/app/src/parser/operation_state.h index 5a606322a..96a4e3661 100644 --- a/app/src/parser/operation_state.h +++ b/app/src/parser/operation_state.h @@ -20,10 +20,10 @@ #include "num_state.h" typedef enum { - TZ_OPERATION_TAG_END = 0, - TZ_OPERATION_TAG_PROPOSALS = 5, - TZ_OPERATION_TAG_BALLOT = 6, - TZ_OPERATION_TAG_FAILING_NOOP = 17, + TZ_OPERATION_TAG_END = 0, + TZ_OPERATION_TAG_PROPOSALS = 5, + TZ_OPERATION_TAG_BALLOT = 6, + TZ_OPERATION_TAG_FAILING_NOOP = 17, TZ_OPERATION_TAG_REVEAL = 107, TZ_OPERATION_TAG_TRANSACTION = 108, TZ_OPERATION_TAG_ORIGINATION = 109, @@ -62,7 +62,7 @@ typedef enum { } tz_operation_parser_step_kind; typedef enum { - TZ_OPERATION_FIELD_SKIP, // not for use in field descriptors + TZ_OPERATION_FIELD_SKIP, // not for use in field descriptors TZ_OPERATION_FIELD_BINARY, TZ_OPERATION_FIELD_INT, TZ_OPERATION_FIELD_NAT, @@ -86,58 +86,57 @@ typedef enum { TZ_OPERATION_FIELD_BALLOT } tz_operation_field_kind; - typedef struct { - const char *name; + const char *name; tz_operation_field_kind kind : 5; - uint8_t required : 1, skip : 1, display_none : 1; + uint8_t required : 1, skip : 1, display_none : 1; } tz_operation_field_descriptor; typedef struct { - tz_operation_tag tag; - const char *name; + tz_operation_tag tag; + const char *name; const tz_operation_field_descriptor *fields; } tz_operation_descriptor; typedef struct { tz_operation_parser_step_kind step : 5; - uint16_t stop; + uint16_t stop; union { struct { - uint8_t size_len; + uint8_t size_len; uint16_t size; } step_size; struct { const tz_operation_descriptor *descriptor; - uint8_t field; + uint8_t field; } step_operation; struct { const char *str; } step_print; struct { - uint16_t ofs; - uint16_t len; + uint16_t ofs; + uint16_t len; tz_operation_field_kind kind : 5; - uint8_t skip : 1; + uint8_t skip : 1; } step_read_bytes; struct { - tz_num_parser_regs state; + tz_num_parser_regs state; tz_operation_field_kind kind : 5; - uint8_t skip : 1, natural : 1; + uint8_t skip : 1, natural : 1; } step_read_num; struct { uint16_t ofs; - uint8_t skip : 1; + uint8_t skip : 1; } step_read_string; struct { const char *name; - uint8_t inited : 1; - uint8_t skip : 1; + uint8_t inited : 1; + uint8_t skip : 1; } step_read_micheline; struct { const char *name; - uint16_t index; - uint8_t skip : 1; + uint16_t index; + uint8_t skip : 1; } step_read_list; }; } tz_operation_parser_frame; @@ -145,10 +144,10 @@ typedef struct { #define TZ_OPERATION_STACK_DEPTH 6 typedef struct { - tz_operation_parser_frame stack[TZ_OPERATION_STACK_DEPTH]; - tz_operation_parser_frame *frame; // init == stack, NULL when done - uint8_t seen_reveal : 1; // check at most one reveal - uint8_t source[22]; // check consistent source in batch - uint8_t destination[22]; // saved for entrypoint dispatch - uint16_t batch_index; // to print a sequence number + tz_operation_parser_frame stack[TZ_OPERATION_STACK_DEPTH]; + tz_operation_parser_frame *frame; // init == stack, NULL when done + uint8_t seen_reveal : 1; // check at most one reveal + uint8_t source[22]; // check consistent source in batch + uint8_t destination[22]; // saved for entrypoint dispatch + uint16_t batch_index; // to print a sequence number } tz_operation_state; diff --git a/app/src/parser/parser_state.c b/app/src/parser/parser_state.c index f98f68fdc..ba9874569 100644 --- a/app/src/parser/parser_state.c +++ b/app/src/parser/parser_state.c @@ -1,4 +1,5 @@ -/* Tezos Embedded C parser for Ledger - Full parser state definition and helpers +/* Tezos Embedded C parser for Ledger - Full parser state definition and + helpers Copyright 2023 Nomadic Labs Copyright 2023 TriliTech @@ -17,10 +18,16 @@ #include "parser_state.h" -#define TZ_LABEL(_x) case TZ_ ## _x: return #_x -#define BLO_LABEL(_x) case TZ_BLO_ ## _x: return #_x +#define TZ_LABEL(_x) \ + case TZ_##_x: \ + return #_x +#define BLO_LABEL(_x) \ + case TZ_BLO_##_x: \ + return #_x -const char* tz_parser_result_name(tz_parser_result code) { +const char * +tz_parser_result_name(tz_parser_result code) +{ // clang-format off switch (code) { TZ_LABEL(CONTINUE); @@ -40,18 +47,24 @@ const char* tz_parser_result_name(tz_parser_result code) { // clang-format on } -void tz_parser_init(tz_parser_state *state) { - state->errno = TZ_CONTINUE; - state->ofs = 0; +void +tz_parser_init(tz_parser_state *state) +{ + state->errno = TZ_CONTINUE; + state->ofs = 0; state->field_name[0] = 0; } -void tz_parser_flush(tz_parser_state *st, char *obuf, size_t olen) { +void +tz_parser_flush(tz_parser_state *st, char *obuf, size_t olen) +{ tz_parser_flush_up_to(st, obuf, olen, olen); } -void tz_parser_flush_up_to(tz_parser_state *st, char *obuf, size_t olen, - size_t up_to) { +void +tz_parser_flush_up_to(tz_parser_state *st, char *obuf, size_t olen, + size_t up_to) +{ tz_parser_regs *regs = &st->regs; regs->obuf = obuf; @@ -66,7 +79,9 @@ void tz_parser_flush_up_to(tz_parser_state *st, char *obuf, size_t olen, memset(regs->obuf + regs->oofs, 0x0, regs->olen); } -void tz_parser_refill(tz_parser_state *st, uint8_t *ibuf, size_t ilen) { +void +tz_parser_refill(tz_parser_state *st, uint8_t *ibuf, size_t ilen) +{ tz_parser_regs *regs = &st->regs; regs->ibuf = ibuf; @@ -74,41 +89,53 @@ void tz_parser_refill(tz_parser_state *st, uint8_t *ibuf, size_t ilen) { regs->ilen = ilen; } -tz_parser_result tz_parser_set_errno(tz_parser_state *state, - tz_parser_result code) { +tz_parser_result +tz_parser_set_errno(tz_parser_state *state, tz_parser_result code) +{ state->errno = ((code == TZ_BREAK) ? TZ_CONTINUE : code); return code; } -tz_parser_result tz_parser_put(tz_parser_state *state, char c) { - tz_parser_regs *regs = &state->regs; +tz_parser_result +tz_parser_put(tz_parser_state *state, char c) +{ + tz_parser_regs *regs = &state->regs; - if (regs->olen<1) tz_stop(IM_FULL); + if (regs->olen < 1) + tz_stop(IM_FULL); regs->obuf[regs->oofs] = c; regs->oofs++; regs->olen--; tz_continue; } -tz_parser_result tz_parser_read(tz_parser_state *state, uint8_t *r) { +tz_parser_result +tz_parser_read(tz_parser_state *state, uint8_t *r) +{ tz_parser_regs *regs = &state->regs; - if (regs->ilen<1) tz_stop(FEED_ME); + if (regs->ilen < 1) + tz_stop(FEED_ME); state->ofs++; regs->ilen--; *r = regs->ibuf[regs->iofs++]; tz_continue; } -tz_parser_result tz_parser_peek(tz_parser_state *state, uint8_t *r) { +tz_parser_result +tz_parser_peek(tz_parser_state *state, uint8_t *r) +{ tz_parser_regs *regs = &state->regs; - if (regs->ilen<1) tz_stop(FEED_ME); + if (regs->ilen < 1) + tz_stop(FEED_ME); *r = regs->ibuf[regs->iofs]; tz_continue; } -void tz_parser_skip(tz_parser_state *state) { +void +tz_parser_skip(tz_parser_state *state) +{ tz_parser_regs *regs = &state->regs; regs->iofs++; diff --git a/app/src/parser/parser_state.h b/app/src/parser/parser_state.h index 0f57df7fb..2ff16d4cc 100644 --- a/app/src/parser/parser_state.h +++ b/app/src/parser/parser_state.h @@ -1,4 +1,5 @@ -/* Tezos Embedded C parser for Ledger - Full parser state definition and helpers +/* Tezos Embedded C parser for Ledger - Full parser state definition and + helpers Copyright 2023 Nomadic Labs Copyright 2023 TriliTech @@ -27,30 +28,30 @@ typedef struct { // update `ibuf`, `iofs` and `ilen` at once with `parser_regs_refill` // invariant between two refills: // `iofs + ilen` = (constant) number of readable bytes in `ibuf` - uint8_t* ibuf; // input buffer - size_t iofs; // current offset - size_t ilen; // remaining bytes readable in input + uint8_t *ibuf; // input buffer + size_t iofs; // current offset + size_t ilen; // remaining bytes readable in input // update `obuf`, `oofs` and `olen` at once with `parser_regs_flush` // invariant between two refills: // `oofs + olen` = (constant) number of readable bytes in `obuf` - char* obuf; // output buffer - size_t oofs; // current offset - size_t olen; // remaining bytes writable in output + char *obuf; // output buffer + size_t oofs; // current offset + size_t olen; // remaining bytes writable in output } tz_parser_regs; // Parser state -#define TZ_FIELD_NAME_SIZE 80 +#define TZ_FIELD_NAME_SIZE 80 #define TZ_CAPTURE_BUFFER_SIZE 256 typedef enum { // success and non blocking, should loop again - TZ_CONTINUE = 0, // fall through rest of current step - TZ_BREAK, // signals caller to return, errno should be CONTINUE + TZ_CONTINUE = 0, // fall through rest of current step + TZ_BREAK, // signals caller to return, errno should be CONTINUE // success but parsing blocked - TZ_BLO_DONE = 100, // parsing complete - TZ_BLO_FEED_ME, // blocked on read from input - TZ_BLO_IM_FULL, // blocked on output space + TZ_BLO_DONE = 100, // parsing complete + TZ_BLO_FEED_ME, // blocked on read from input + TZ_BLO_IM_FULL, // blocked on output space // everything below is an error TZ_ERR_INVALID_TAG = 200, TZ_ERR_INVALID_OP, @@ -60,21 +61,21 @@ typedef enum { TZ_ERR_INVALID_STATE, } tz_parser_result; #define TZ_IS_BLOCKED(code) (code >= 100) -#define TZ_IS_ERR(code) (code >= 200) +#define TZ_IS_ERR(code) (code >= 200) -const char* tz_parser_result_name(tz_parser_result); +const char *tz_parser_result_name(tz_parser_result); typedef struct { tz_parser_regs regs; // common fields to communicate with caller tz_parser_result errno; - char field_name[TZ_FIELD_NAME_SIZE]; + char field_name[TZ_FIELD_NAME_SIZE]; // common singleton buffers int ofs; struct { tz_num_parser_buffer num; - uint8_t capture[TZ_CAPTURE_BUFFER_SIZE]; + uint8_t capture[TZ_CAPTURE_BUFFER_SIZE]; } buffers; // input type specific state tz_micheline_state micheline; @@ -83,7 +84,7 @@ typedef struct { void tz_parser_init(tz_parser_state *); void tz_parser_flush(tz_parser_state *, char *, size_t); -void tz_parser_flush_up_to(tz_parser_state *, char*, size_t, size_t); +void tz_parser_flush_up_to(tz_parser_state *, char *, size_t, size_t); void tz_parser_refill(tz_parser_state *, uint8_t *, size_t); void tz_parser_skip(tz_parser_state *); @@ -95,24 +96,26 @@ tz_parser_result tz_parser_peek(tz_parser_state *, uint8_t *); tz_parser_result tz_parser_set_errno(tz_parser_state *, tz_parser_result); #ifdef TEZOS_DEBUG -# define tz_return(e) do { \ - tz_parser_result _c = (e); \ - if (_c) { \ - PRINTF ("[DEBUG] tz_return(code: %s, loc: %s:%d)\n", \ - tz_parser_result_name(_c), __FILE__, __LINE__); \ - } \ - return tz_parser_set_errno(state, _c); \ - } while (0) +#define tz_return(e) \ + do { \ + tz_parser_result _c = (e); \ + if (_c) { \ + PRINTF("[DEBUG] tz_return(code: %s, loc: %s:%d)\n", \ + tz_parser_result_name(_c), __FILE__, __LINE__); \ + } \ + return tz_parser_set_errno(state, _c); \ + } while (0) #else -# define tz_return(e) return tz_parser_set_errno(state, e) +#define tz_return(e) return tz_parser_set_errno(state, e) #endif #define tz_raise(e) tz_return(TZ_ERR_##e) -#define tz_stop(e) tz_return(TZ_BLO_##e) -#define tz_reraise return state->errno -#define tz_must(cond) do { \ - tz_parser_result _err = cond; \ - if (_err) \ - tz_return(_err); \ - } while (0) +#define tz_stop(e) tz_return(TZ_BLO_##e) +#define tz_reraise return state->errno +#define tz_must(cond) \ + do { \ + tz_parser_result _err = cond; \ + if (_err) \ + tz_return(_err); \ + } while (0) #define tz_continue tz_return(TZ_CONTINUE) -#define tz_break tz_return(TZ_BREAK) +#define tz_break tz_return(TZ_BREAK) diff --git a/app/src/ui_commons.h b/app/src/ui_commons.h index 903548d2e..4e4e5f285 100644 --- a/app/src/ui_commons.h +++ b/app/src/ui_commons.h @@ -26,16 +26,16 @@ #include #include -#define DISPLAY(elts, cb)\ - memcpy(global.ux.bagls, elts, sizeof(elts)); \ +#define DISPLAY(elts, cb) \ + memcpy(global.ux.bagls, elts, sizeof(elts)); \ G_ux.stack[0].element_arrays[0].element_array = global.ux.bagls; \ - G_ux.stack[0].element_arrays[0].element_array_count = \ - sizeof(elts)/sizeof(bagl_element_t); \ - G_ux.stack[0].button_push_callback = cb; \ - G_ux.stack[0].screen_before_element_display_callback = NULL; \ - UX_WAKE_UP(); \ + G_ux.stack[0].element_arrays[0].element_array_count \ + = sizeof(elts) / sizeof(bagl_element_t); \ + G_ux.stack[0].button_push_callback = cb; \ + G_ux.stack[0].screen_before_element_display_callback = NULL; \ + UX_WAKE_UP(); \ UX_REDISPLAY(); #define REGULAR BAGL_FONT_OPEN_SANS_REGULAR_11px | BAGL_FONT_ALIGNMENT_CENTER -#define BOLD BAGL_FONT_OPEN_SANS_EXTRABOLD_11px | BAGL_FONT_ALIGNMENT_CENTER -#endif // HAVE_BAGL +#define BOLD BAGL_FONT_OPEN_SANS_EXTRABOLD_11px | BAGL_FONT_ALIGNMENT_CENTER +#endif // HAVE_BAGL diff --git a/app/src/ui_home.c b/app/src/ui_home.c index f1b646de5..3d80c5490 100644 --- a/app/src/ui_home.c +++ b/app/src/ui_home.c @@ -28,8 +28,9 @@ static void cb(tz_ui_cb_type_t); - -static void cb(tz_ui_cb_type_t type) { +static void +cb(tz_ui_cb_type_t type) +{ FUNC_ENTER(("type=%u\n", type)); switch (type) { @@ -47,29 +48,39 @@ static void cb(tz_ui_cb_type_t type) { } #ifdef TARGET_NANOS -static void clear_sign_screen(void) { - tz_ui_stream_push(SCREEN_CLEAR_SIGN, "ready for", - "safe signing", TZ_UI_ICON_NONE); +static void +clear_sign_screen(void) +{ + tz_ui_stream_push(SCREEN_CLEAR_SIGN, "ready for", "safe signing", + TZ_UI_ICON_NONE); } -static void blind_sign_screen(void) { - tz_ui_stream_push(SCREEN_BLIND_SIGN, "ready for", - "BLIND signing", TZ_UI_ICON_NONE); +static void +blind_sign_screen(void) +{ + tz_ui_stream_push(SCREEN_BLIND_SIGN, "ready for", "BLIND signing", + TZ_UI_ICON_NONE); } #else -static void clear_sign_screen(void) { +static void +clear_sign_screen(void) +{ tz_ui_stream_push(SCREEN_CLEAR_SIGN, "Tezos Wallet", "ready for\nsafe signing", TZ_UI_ICON_NONE); } -static void blind_sign_screen(void) { +static void +blind_sign_screen(void) +{ tz_ui_stream_push(SCREEN_BLIND_SIGN, "Tezos Wallet", "ready for\nBLIND signing", TZ_UI_ICON_NONE); } #endif -#endif // HAVE_BAGL +#endif // HAVE_BAGL -void ui_home_init(void) { +void +ui_home_init(void) +{ FUNC_ENTER(("void")); #ifdef HAVE_BAGL tz_ui_stream_init(cb); diff --git a/app/src/ui_home_nbgl.c b/app/src/ui_home_nbgl.c index b2fcb6673..b292be57f 100644 --- a/app/src/ui_home_nbgl.c +++ b/app/src/ui_home_nbgl.c @@ -30,9 +30,9 @@ void tz_ui_home_redisplay(void); -static const char* const infoTypes[] = {"Version", "Developer", "Copyright"}; -static const char* const infoContents[] = - {APPVERSION, "Tezos", "(c) 2023 "}; +static const char *const infoTypes[] = {"Version", "Developer", "Copyright"}; +static const char *const infoContents[] + = {APPVERSION, "Tezos", "(c) 2023 "}; enum { BLIND_SIGNING_TOKEN = FIRST_USER_TOKEN, @@ -40,27 +40,28 @@ enum { static nbgl_layoutSwitch_t switches[1]; -static bool navigation_cb_wallet(__attribute__((unused))uint8_t page, - nbgl_pageContent_t* content) { +static bool +navigation_cb_wallet(__attribute__((unused)) uint8_t page, + nbgl_pageContent_t *content) +{ switch (page) { case 0: - content->type = INFOS_LIST; - content->infosList.nbInfos = 3; - content->infosList.infoTypes = infoTypes; + content->type = INFOS_LIST; + content->infosList.nbInfos = 3; + content->infosList.infoTypes = infoTypes; content->infosList.infoContents = infoContents; break; case 1: - switches[0] = - (nbgl_layoutSwitch_t) - {.initState = N_settings.blindsigning ? ON_STATE : OFF_STATE, - .text = "Blind signing", - .subText = "Enable blindsigning", - .token = BLIND_SIGNING_TOKEN, - .tuneId = TUNE_TAP_CASUAL}; - - content->type = SWITCHES_LIST; + switches[0] = (nbgl_layoutSwitch_t){ + .initState = N_settings.blindsigning ? ON_STATE : OFF_STATE, + .text = "Blind signing", + .subText = "Enable blindsigning", + .token = BLIND_SIGNING_TOKEN, + .tuneId = TUNE_TAP_CASUAL}; + + content->type = SWITCHES_LIST; content->switchesList.nbSwitches = 1; - content->switchesList.switches = (nbgl_layoutSwitch_t*) switches; + content->switchesList.switches = (nbgl_layoutSwitch_t *)switches; break; default: return false; @@ -69,8 +70,9 @@ static bool navigation_cb_wallet(__attribute__((unused))uint8_t page, return true; } -static void controls_callback(int token, - __attribute__((unused))uint8_t index) { +static void +controls_callback(int token, __attribute__((unused)) uint8_t index) +{ switch (token) { case BLIND_SIGNING_TOKEN: toggle_blindsigning(); @@ -81,14 +83,18 @@ static void controls_callback(int token, } } -static void ui_menu_about_wallet(void) { +static void +ui_menu_about_wallet(void) +{ uint8_t nb_screens = 2; - nbgl_useCaseSettings("Tezos wallet", - 0, nb_screens, false, tz_ui_home_redisplay, - navigation_cb_wallet, controls_callback); + nbgl_useCaseSettings("Tezos wallet", 0, nb_screens, false, + tz_ui_home_redisplay, navigation_cb_wallet, + controls_callback); } -static void ui_toggle_clear_blind(void) { +static void +ui_toggle_clear_blind(void) +{ // clang-format off switch (global.home_screen) { case SCREEN_CLEAR_SIGN: global.home_screen = SCREEN_BLIND_SIGN; break; @@ -101,44 +107,37 @@ static void ui_toggle_clear_blind(void) { tz_ui_home_redisplay(); } -void tz_ui_home_redisplay(void) { +void +tz_ui_home_redisplay(void) +{ FUNC_ENTER(("void")); if (!N_settings.blindsigning) { - nbgl_useCaseHome("Tezos Wallet", - &C_tezos, - "Ready for signing", - true, - ui_menu_about_wallet, - app_exit); + nbgl_useCaseHome("Tezos Wallet", &C_tezos, "Ready for signing", true, + ui_menu_about_wallet, app_exit); } else { - const char* button_text; - const char* tagline; + const char *button_text; + const char *tagline; switch (global.home_screen) { case SCREEN_CLEAR_SIGN: - tagline = "Ready for clear signing"; + tagline = "Ready for clear signing"; button_text = "blind sign"; break; case SCREEN_BLIND_SIGN: - tagline = "Ready for blind signing"; + tagline = "Ready for blind signing"; button_text = "clear sign"; break; default: - THROW (EXC_UNEXPECTED_STATE); + THROW(EXC_UNEXPECTED_STATE); } - nbgl_useCaseHomeExt("Tezos Wallet", - &C_tezos, - tagline, - true, - button_text, - ui_toggle_clear_blind, - ui_menu_about_wallet, - app_exit); + nbgl_useCaseHomeExt("Tezos Wallet", &C_tezos, tagline, true, + button_text, ui_toggle_clear_blind, + ui_menu_about_wallet, app_exit); } FUNC_LEAVE(); } -#endif // HAVE_NBGL +#endif // HAVE_NBGL diff --git a/app/src/ui_settings.c b/app/src/ui_settings.c index 21386755b..744aec3ff 100644 --- a/app/src/ui_settings.c +++ b/app/src/ui_settings.c @@ -23,9 +23,8 @@ static void cb(tz_ui_cb_type_t); -#define BLIND_SIGNING 0x01 -#define BACK 0x02 - +#define BLIND_SIGNING 0x01 +#define BACK 0x02 static void cb(tz_ui_cb_type_t type) @@ -53,7 +52,8 @@ ui_settings_init(void) bsigning = "ENABLED"; tz_ui_stream_init(cb); - tz_ui_stream_push(BLIND_SIGNING, "Blind Signing", bsigning, TZ_UI_ICON_NONE); + tz_ui_stream_push(BLIND_SIGNING, "Blind Signing", bsigning, + TZ_UI_ICON_NONE); tz_ui_stream_push(BACK, "Back", "", TZ_UI_ICON_DASHBOARD); tz_ui_stream_close(); tz_ui_stream_start(); diff --git a/app/src/ui_settings.h b/app/src/ui_settings.h index e60109852..31e391fc7 100644 --- a/app/src/ui_settings.h +++ b/app/src/ui_settings.h @@ -4,4 +4,4 @@ #pragma once -void ui_settings_init(void); +void ui_settings_init(void); diff --git a/app/src/ui_stream.c b/app/src/ui_stream.c index 2a9d7b23b..d93b6e70f 100644 --- a/app/src/ui_stream.c +++ b/app/src/ui_stream.c @@ -21,31 +21,35 @@ #ifdef HAVE_BAGL static unsigned int cb(unsigned int, unsigned int); -static const char *find_icon(tz_ui_icon_t); -static void pred(void); -static void succ(void); -static void change_screen_left(void); -static void change_screen_right(void); -static void redisplay(void); +static const char *find_icon(tz_ui_icon_t); +static void pred(void); +static void succ(void); +static void change_screen_left(void); +static void change_screen_right(void); +static void redisplay(void); -const bagl_icon_details_t C_icon_rien = { 0, 0, 1, NULL, NULL }; -#endif // HAVE_BAGL +const bagl_icon_details_t C_icon_rien = {0, 0, 1, NULL, NULL}; +#endif // HAVE_BAGL // Model -void tz_ui_stream_init(void (*cb)(uint8_t)) { +void +tz_ui_stream_init(void (*cb)(uint8_t)) +{ tz_ui_stream_t *s = &global.stream; FUNC_ENTER(("cb=%p", cb)); memset(s, 0x0, sizeof(*s)); - s->cb = cb; - s->full = false; + s->cb = cb; + s->full = false; s->current = 0; - s->total = -1; + s->total = -1; FUNC_LEAVE(); } -void tz_ui_stream_push_accept_reject(void) { +void +tz_ui_stream_push_accept_reject(void) +{ FUNC_ENTER(("void")); tz_ui_stream_push(TZ_UI_STREAM_CB_ACCEPT, "Accept?", "Press both buttons to accept.", TZ_UI_ICON_TICK); @@ -54,7 +58,9 @@ void tz_ui_stream_push_accept_reject(void) { FUNC_LEAVE(); } -void tz_ui_stream_close() { +void +tz_ui_stream_close() +{ tz_ui_stream_t *s = &global.stream; FUNC_ENTER(("void")); @@ -67,7 +73,9 @@ void tz_ui_stream_close() { } #ifdef HAVE_BAGL -uint8_t tz_ui_max_line_chars(const char* value, int length) { +uint8_t +tz_ui_max_line_chars(const char *value, int length) +{ uint8_t will_fit = MIN(TZ_UI_STREAM_CONTENTS_WIDTH, length); FUNC_ENTER(("value=\"%s\", length=%d", value, length)); @@ -77,27 +85,30 @@ uint8_t tz_ui_max_line_chars(const char* value, int length) { if (tmp && (tmp - value) <= will_fit) will_fit = (tmp - value); -# ifdef TARGET_NANOS +#ifdef TARGET_NANOS will_fit = se_get_cropped_length(value, will_fit, BAGL_WIDTH, BAGL_ENCODING_LATIN1); -# else +#else uint8_t width; will_fit++; do { width = bagl_compute_line_width(BAGL_FONT_OPEN_SANS_REGULAR_11px, 0, - value, --will_fit, BAGL_ENCODING_LATIN1); + value, --will_fit, + BAGL_ENCODING_LATIN1); } while (width >= BAGL_WIDTH); PRINTF("[DEBUG] max_line_width(value: \"%s\", width: %d, will_fit: %d)\n", value, width, will_fit); -# endif +#endif FUNC_LEAVE(); return will_fit; } -size_t tz_ui_stream_push_all(tz_ui_cb_type_t type, const char *title, - const char *value, tz_ui_icon_t icon) { +size_t +tz_ui_stream_push_all(tz_ui_cb_type_t type, const char *title, + const char *value, tz_ui_icon_t icon) +{ size_t obuflen; size_t i = 0; @@ -109,15 +120,19 @@ size_t tz_ui_stream_push_all(tz_ui_cb_type_t type, const char *title, return i; } -size_t tz_ui_stream_push(tz_ui_cb_type_t type, const char *title, - const char *value, tz_ui_icon_t icon) { +size_t +tz_ui_stream_push(tz_ui_cb_type_t type, const char *title, const char *value, + tz_ui_icon_t icon) +{ return tz_ui_stream_pushl(type, title, value, -1, icon); } -size_t tz_ui_stream_pushl(tz_ui_cb_type_t type, const char *title, - const char *value, ssize_t max, tz_ui_icon_t icon) { +size_t +tz_ui_stream_pushl(tz_ui_cb_type_t type, const char *title, const char *value, + ssize_t max, tz_ui_icon_t icon) +{ tz_ui_stream_t *s = &global.stream; - size_t i; + size_t i; FUNC_ENTER(("title=%s, value=%s", title, value)); if (s->full) { @@ -125,7 +140,7 @@ size_t tz_ui_stream_pushl(tz_ui_cb_type_t type, const char *title, THROW(EXC_UNKNOWN); } #ifdef TEZOS_DEBUG - int prev_total = s->total; + int prev_total = s->total; int prev_current = s->current; #endif @@ -155,8 +170,10 @@ size_t tz_ui_stream_pushl(tz_ui_cb_type_t type, const char *title, will_fit = tz_ui_max_line_chars(&value[offset], length - offset); - PRINTF("[DEBUG] split(value: \"%s\", will_fit: %d, line: %d, " - "offset: %d)\n", &value[offset], will_fit, line, offset); + PRINTF( + "[DEBUG] split(value: \"%s\", will_fit: %d, line: %d, " + "offset: %d)\n", + &value[offset], will_fit, line, offset); strlcpy(s->screens[bucket].body[line], &value[offset], will_fit + 1); @@ -168,7 +185,7 @@ size_t tz_ui_stream_pushl(tz_ui_cb_type_t type, const char *title, PRINTF("[DEBUG] tz_ui_stream_pushl(%s, %s, %u)\n", title, value, max); PRINTF("[DEBUG] bucket %d\n", bucket); PRINTF("[DEBUG] title: \"%s\"\n", s->screens[bucket].title); - for (line=0; line < TZ_UI_STREAM_CONTENTS_LINES; line++) + for (line = 0; line < TZ_UI_STREAM_CONTENTS_LINES; line++) PRINTF("[DEBUG] value[%d]: \"%s\"\n", line, s->screens[bucket].body[line]); PRINTF("[DEBUG] total: %d -> %d\n", prev_total, s->total); @@ -178,28 +195,34 @@ size_t tz_ui_stream_pushl(tz_ui_cb_type_t type, const char *title, return offset; } -#endif // HAVE_BAGL +#endif // HAVE_BAGL -tz_ui_cb_type_t tz_ui_stream_get_type(void) { - tz_ui_stream_t *s = &global.stream; - size_t bucket = s->current % TZ_UI_STREAM_HISTORY_SCREENS; +tz_ui_cb_type_t +tz_ui_stream_get_type(void) +{ + tz_ui_stream_t *s = &global.stream; + size_t bucket = s->current % TZ_UI_STREAM_HISTORY_SCREENS; return s->screens[bucket].type; } #ifdef HAVE_BAGL -static void pred() { +static void +pred() +{ tz_ui_stream_t *s = &global.stream; FUNC_ENTER(("void")); - if (s->current >= 1 && - s->current >= s->total - TZ_UI_STREAM_HISTORY_SCREENS + 2) { + if (s->current >= 1 + && s->current >= s->total - TZ_UI_STREAM_HISTORY_SCREENS + 2) { s->current--; } FUNC_LEAVE(); } -static void succ() { +static void +succ() +{ tz_ui_stream_t *s = &global.stream; FUNC_ENTER(("void")); @@ -209,17 +232,18 @@ static void succ() { } FUNC_LEAVE(); } -#endif // HAVE_BAGL +#endif // HAVE_BAGL // View #ifdef HAVE_BAGL -static unsigned int cb(unsigned int button_mask, - __attribute__((unused)) - unsigned int button_mask_counter) { - tz_ui_stream_t *s = &global.stream; - size_t bucket = s->current % TZ_UI_STREAM_HISTORY_SCREENS; - uint8_t type = s->screens[bucket].type; +static unsigned int +cb(unsigned int button_mask, + __attribute__((unused)) unsigned int button_mask_counter) +{ + tz_ui_stream_t *s = &global.stream; + size_t bucket = s->current % TZ_UI_STREAM_HISTORY_SCREENS; + uint8_t type = s->screens[bucket].type; FUNC_ENTER(("button_mask=%d, button_mask_counter=%d", button_mask, button_mask_counter)); @@ -244,8 +268,9 @@ static unsigned int cb(unsigned int button_mask, return 0; } -static const char *find_icon(tz_ui_icon_t icon) { - +static const char * +find_icon(tz_ui_icon_t icon) +{ // clang-format off switch (icon) { case TZ_UI_ICON_TICK: return (const char *)&C_icon_validate_14; @@ -257,50 +282,63 @@ static const char *find_icon(tz_ui_icon_t icon) { // clang-format on } -static void redisplay() { +static void +redisplay() +{ bagl_element_t init[] = { - // {type, userid, x, y, width, height, stroke, radius, - // fill, fgcolor, bgcolor, font_id, icon_id}, text/icon - {{ BAGL_RECTANGLE, 0x00, 0, 0, 128, BAGL_HEIGHT, 0, 0, - BAGL_FILL, 0x000000, 0xFFFFFF, 0, 0 }, NULL }, - {{ BAGL_ICON, 0x00, 1, 1, 7, 7, 0, 0, 0, 0xFFFFFF, 0x000000, 0, - BAGL_GLYPH_NOGLYPH }, (const char*) &C_icon_rien }, - {{ BAGL_ICON, 0x00, 120, 1, 7, 7, 0, 0, 0, 0xFFFFFF, 0x000000, 0, - BAGL_GLYPH_NOGLYPH }, (const char*) &C_icon_rien }, - {{ BAGL_LABELINE, 0x02, 8, 8, 112, 11, 0, 0, 0, 0xFFFFFF, 0x000000, - BOLD, 0 }, global.ux.lines[0] }, + // {type, userid, x, y, width, height, stroke, radius, + // fill, fgcolor, bgcolor, font_id, icon_id}, text/icon + {{BAGL_RECTANGLE, 0x00, 0, 0, 128, BAGL_HEIGHT, 0, 0, BAGL_FILL, + 0x000000, 0xFFFFFF, 0, 0}, + NULL }, + {{BAGL_ICON, 0x00, 1, 1, 7, 7, 0, 0, 0, 0xFFFFFF, 0x000000, 0, + BAGL_GLYPH_NOGLYPH}, + (const char *)&C_icon_rien}, + {{BAGL_ICON, 0x00, 120, 1, 7, 7, 0, 0, 0, 0xFFFFFF, 0x000000, 0, + BAGL_GLYPH_NOGLYPH}, + (const char *)&C_icon_rien}, + {{BAGL_LABELINE, 0x02, 8, 8, 112, 11, 0, 0, 0, 0xFFFFFF, 0x000000, + BOLD, 0}, + global.ux.lines[0] }, #ifdef TARGET_NANOS - {{ BAGL_LABELINE, 0x02, 0, 19, 128, 11, 0, 0, 0, 0xFFFFFF, 0x000000, - REGULAR, 0 }, global.ux.lines[1] }, - {{ BAGL_ICON, 0x00, 56, 14, 16, 16, 0, 0, 0, 0xFFFFFF, 0x000000, 0, - BAGL_GLYPH_NOGLYPH }, (const char*) &C_icon_rien }, + {{BAGL_LABELINE, 0x02, 0, 19, 128, 11, 0, 0, 0, 0xFFFFFF, 0x000000, + REGULAR, 0}, + global.ux.lines[1] }, + {{BAGL_ICON, 0x00, 56, 14, 16, 16, 0, 0, 0, 0xFFFFFF, 0x000000, 0, + BAGL_GLYPH_NOGLYPH}, + (const char *)&C_icon_rien}, #else - {{ BAGL_LABELINE, 0x02, 0, 21, 128, 11, 0, 0, 0, 0xFFFFFF, 0x000000, - REGULAR, 0 }, global.ux.lines[1] }, - {{ BAGL_LABELINE, 0x02, 0, 34, 128, 11, 0, 0, 0, 0xFFFFFF, 0x000000, - REGULAR, 0 }, global.ux.lines[2] }, - {{ BAGL_LABELINE, 0x02, 0, 47, 128, 11, 0, 0, 0, 0xFFFFFF, 0x000000, - REGULAR, 0 }, global.ux.lines[3] }, - {{ BAGL_LABELINE, 0x02, 0, 60, 128, 11, 0, 0, 0, 0xFFFFFF, 0x000000, - REGULAR, 0 }, global.ux.lines[4] }, - {{ BAGL_ICON, 0x00, 56, 47, 16, 16, 0, 0, 0, 0xFFFFFF, 0x000000, 0, - BAGL_GLYPH_NOGLYPH }, (const char*) &C_icon_rien }, + {{BAGL_LABELINE, 0x02, 0, 21, 128, 11, 0, 0, 0, 0xFFFFFF, 0x000000, + REGULAR, 0}, + global.ux.lines[1]}, + {{BAGL_LABELINE, 0x02, 0, 34, 128, 11, 0, 0, 0, 0xFFFFFF, 0x000000, + REGULAR, 0}, + global.ux.lines[2]}, + {{BAGL_LABELINE, 0x02, 0, 47, 128, 11, 0, 0, 0, 0xFFFFFF, 0x000000, + REGULAR, 0}, + global.ux.lines[3]}, + {{BAGL_LABELINE, 0x02, 0, 60, 128, 11, 0, 0, 0, 0xFFFFFF, 0x000000, + REGULAR, 0}, + global.ux.lines[4]}, + {{BAGL_ICON, 0x00, 56, 47, 16, 16, 0, 0, 0, 0xFFFFFF, 0x000000, 0, + BAGL_GLYPH_NOGLYPH}, + (const char *)&C_icon_rien}, #endif }; tz_ui_stream_t *s = &global.stream; - size_t bucket, i; + size_t bucket, i; FUNC_ENTER(("void")); for (i = 0; i < TZ_SCREEN_LINES_11PX; i++) - global.ux.lines[i][0]=0; + global.ux.lines[i][0] = 0; bucket = s->current % TZ_UI_STREAM_HISTORY_SCREENS; STRLCPY(global.ux.lines[0], s->screens[bucket].title); for (i = 0; i < TZ_UI_STREAM_CONTENTS_LINES; i++) { - STRLCPY(global.ux.lines[i+1], s->screens[bucket].body[i]); + STRLCPY(global.ux.lines[i + 1], s->screens[bucket].body[i]); } tz_ui_icon_t icon = s->screens[bucket].icon; @@ -308,33 +346,38 @@ static void redisplay() { #ifdef TARGET_NANOS global.ux.lines[1][0] = 0; #endif - init[sizeof(init)/sizeof(bagl_element_t)-1].text = find_icon(icon); + init[sizeof(init) / sizeof(bagl_element_t) - 1].text + = find_icon(icon); } /* If we aren't on the first screen, we can go back */ if (s->current > 0) - init[1].text = (const char*) &C_icon_go_left; + init[1].text = (const char *)&C_icon_go_left; /* Unless we can't... */ if (s->current == s->total - TZ_UI_STREAM_HISTORY_SCREENS + 1) - init[1].text = (const char*) &C_icon_go_forbid; + init[1].text = (const char *)&C_icon_go_forbid; /* If we aren't full or aren't on the last page, we can go right */ if (!s->full || s->current < s->total) - init[2].text = (const char*) &C_icon_go_right; + init[2].text = (const char *)&C_icon_go_right; DISPLAY(init, cb); FUNC_LEAVE(); } -static void change_screen_left() { +static void +change_screen_left() +{ FUNC_ENTER(("void")); pred(); redisplay(); FUNC_LEAVE(); } -static void change_screen_right() { +static void +change_screen_right() +{ tz_ui_stream_t *s = &global.stream; FUNC_ENTER(("void")); @@ -348,9 +391,11 @@ static void change_screen_right() { redisplay(); FUNC_LEAVE(); } -#endif // HAVE_BAGL +#endif // HAVE_BAGL -void tz_ui_stream_start(void) { +void +tz_ui_stream_start(void) +{ FUNC_ENTER(("void")); #ifdef HAVE_BAGL redisplay(); @@ -358,7 +403,9 @@ void tz_ui_stream_start(void) { FUNC_LEAVE(); } -void tz_ui_stream() { +void +tz_ui_stream() +{ FUNC_ENTER(("void")); #ifdef HAVE_BAGL @@ -367,6 +414,6 @@ void tz_ui_stream() { succ(); redisplay(); -#endif // HAVE_BAGL +#endif // HAVE_BAGL FUNC_LEAVE(); } diff --git a/app/src/ui_stream.h b/app/src/ui_stream.h index 014b67277..9b0398b76 100644 --- a/app/src/ui_stream.h +++ b/app/src/ui_stream.h @@ -38,13 +38,13 @@ #include -#define TZ_UI_STREAM_HISTORY_SCREENS 8 -#define TZ_UI_STREAM_TITLE_WIDTH TZ_SCREEN_WITDH_BETWEEN_ICONS_BOLD_11PX -#define TZ_UI_STREAM_CONTENTS_WIDTH TZ_SCREEN_WITDH_FULL_REGULAR_11PX -#define TZ_UI_STREAM_CONTENTS_LINES (TZ_SCREEN_LINES_11PX - 1) +#define TZ_UI_STREAM_HISTORY_SCREENS 8 +#define TZ_UI_STREAM_TITLE_WIDTH TZ_SCREEN_WITDH_BETWEEN_ICONS_BOLD_11PX +#define TZ_UI_STREAM_CONTENTS_WIDTH TZ_SCREEN_WITDH_FULL_REGULAR_11PX +#define TZ_UI_STREAM_CONTENTS_LINES (TZ_SCREEN_LINES_11PX - 1) -#define TZ_UI_STREAM_CONTENTS_SIZE (TZ_UI_STREAM_CONTENTS_WIDTH * \ - TZ_UI_STREAM_CONTENTS_LINES) +#define TZ_UI_STREAM_CONTENTS_SIZE \ + (TZ_UI_STREAM_CONTENTS_WIDTH * TZ_UI_STREAM_CONTENTS_LINES) /* * In the following structure, "type" is passed to our callback and @@ -60,38 +60,38 @@ */ typedef uint8_t tz_ui_cb_type_t; -#define TZ_UI_STREAM_CB_NOCB 0x00 -#define TZ_UI_STREAM_CB_REFILL 0xef -#define TZ_UI_STREAM_CB_MAINMASK 0xf0 -#define TZ_UI_STREAM_CB_REJECT 0xfe -#define TZ_UI_STREAM_CB_ACCEPT 0xff +#define TZ_UI_STREAM_CB_NOCB 0x00 +#define TZ_UI_STREAM_CB_REFILL 0xef +#define TZ_UI_STREAM_CB_MAINMASK 0xf0 +#define TZ_UI_STREAM_CB_REJECT 0xfe +#define TZ_UI_STREAM_CB_ACCEPT 0xff /* * The icons we used are generalised to allow for seamless Stax support */ typedef uint8_t tz_ui_icon_t; -#define TZ_UI_ICON_NONE 0x00 -#define TZ_UI_ICON_TICK 0x01 -#define TZ_UI_ICON_CROSS 0x02 -#define TZ_UI_ICON_DASHBOARD 0x03 -#define TZ_UI_ICON_SETTINGS 0x04 +#define TZ_UI_ICON_NONE 0x00 +#define TZ_UI_ICON_TICK 0x01 +#define TZ_UI_ICON_CROSS 0x02 +#define TZ_UI_ICON_DASHBOARD 0x03 +#define TZ_UI_ICON_SETTINGS 0x04 typedef struct { - tz_ui_icon_t icon; + tz_ui_icon_t icon; tz_ui_cb_type_t type; - char title[TZ_UI_STREAM_TITLE_WIDTH + 1]; + char title[TZ_UI_STREAM_TITLE_WIDTH + 1]; char body[TZ_UI_STREAM_CONTENTS_LINES][TZ_UI_STREAM_CONTENTS_WIDTH + 1]; } tz_ui_stream_screen_t; typedef struct { void (*cb)(tz_ui_cb_type_t); tz_ui_stream_screen_t screens[TZ_UI_STREAM_HISTORY_SCREENS]; - int16_t current; - int16_t total; - bool full; - // FIXME: workaround for issue with non-local control flow. Remove once fixed - // see !66 + int16_t current; + int16_t total; + bool full; + // FIXME: workaround for issue with non-local control flow. Remove once + // fixed see !66 bool pressed_right; } tz_ui_stream_t; @@ -107,8 +107,8 @@ size_t tz_ui_stream_pushl(tz_ui_cb_type_t, const char *, const char *, ssize_t, tz_ui_icon_t); size_t tz_ui_stream_push_all(tz_ui_cb_type_t, const char *, const char *, tz_ui_icon_t); -void tz_ui_stream_push_accept_reject(void); -void tz_ui_stream_close(void); -void tz_ui_stream(void); -void tz_ui_stream_start(void); +void tz_ui_stream_push_accept_reject(void); +void tz_ui_stream_close(void); +void tz_ui_stream(void); +void tz_ui_stream_start(void); tz_ui_cb_type_t tz_ui_stream_get_type(void); diff --git a/app/src/ui_stream_nbgl.c b/app/src/ui_stream_nbgl.c index c3f53614c..be48b63c9 100644 --- a/app/src/ui_stream_nbgl.c +++ b/app/src/ui_stream_nbgl.c @@ -19,22 +19,28 @@ #include "globals.h" -size_t tz_ui_stream_push(tz_ui_cb_type_t type, const char *title, - const char *value, tz_ui_icon_t icon) { +size_t +tz_ui_stream_push(tz_ui_cb_type_t type, const char *title, const char *value, + tz_ui_icon_t icon) +{ return tz_ui_stream_pushl(type, title, value, -1, icon); } -size_t tz_ui_stream_push_all(__attribute__((unused))tz_ui_cb_type_t type, - __attribute__((unused))const char *title, - const char *value, - __attribute__((unused))tz_ui_icon_t icon) { +size_t +tz_ui_stream_push_all(__attribute__((unused)) tz_ui_cb_type_t type, + __attribute__((unused)) const char *title, + const char *value, + __attribute__((unused)) tz_ui_icon_t icon) +{ return strlen(value); } -size_t tz_ui_stream_pushl(__attribute__((unused))tz_ui_cb_type_t type, - __attribute__((unused))const char *title, - const char *value, ssize_t max, - __attribute__((unused))tz_ui_icon_t icon) { +size_t +tz_ui_stream_pushl(__attribute__((unused)) tz_ui_cb_type_t type, + __attribute__((unused)) const char *title, + const char *value, ssize_t max, + __attribute__((unused)) tz_ui_icon_t icon) +{ size_t length = strlen(value); if (max != -1) diff --git a/app/src/utils.h b/app/src/utils.h index 5850e9da1..8c8ce4b67 100644 --- a/app/src/utils.h +++ b/app/src/utils.h @@ -3,7 +3,7 @@ #include "globals.h" -#define STRLCPY(x, y) strlcpy((x), (y), sizeof(x)) +#define STRLCPY(x, y) strlcpy((x), (y), sizeof(x)) /* * Debugging macros. @@ -16,22 +16,26 @@ */ #ifdef TEZOS_DEBUG -#define FUNC_ENTER(x) do { \ - uint8_t _tmp; \ - PRINTF("[DEBUG] call %s(", __func__); \ - PRINTF x; \ - PRINTF(") at %s:%u\n", __FILE__, __LINE__); \ - PRINTF("[DEBUG] stack = 0x%p (%s)\n", &_tmp, __func__); \ - if (app_stack_canary != 0xDEADBEEF) \ - PRINTF("[DEBUG] Stack (0x%p) has been smashed\n", \ - &app_stack_canary); \ - } while (0) -#define FUNC_LEAVE() do { \ - if (app_stack_canary != 0xDEADBEEF) \ - PRINTF("[DEBUG] Stack (0x%p) has been smashed " \ - "(leaving function)\n", &app_stack_canary); \ - PRINTF("[DEBUG] leave %s\n", __func__); \ - } while (0) +#define FUNC_ENTER(x) \ + do { \ + uint8_t _tmp; \ + PRINTF("[DEBUG] call %s(", __func__); \ + PRINTF x; \ + PRINTF(") at %s:%u\n", __FILE__, __LINE__); \ + PRINTF("[DEBUG] stack = 0x%p (%s)\n", &_tmp, __func__); \ + if (app_stack_canary != 0xDEADBEEF) \ + PRINTF("[DEBUG] Stack (0x%p) has been smashed\n", \ + &app_stack_canary); \ + } while (0) +#define FUNC_LEAVE() \ + do { \ + if (app_stack_canary != 0xDEADBEEF) \ + PRINTF( \ + "[DEBUG] Stack (0x%p) has been smashed " \ + "(leaving function)\n", \ + &app_stack_canary); \ + PRINTF("[DEBUG] leave %s\n", __func__); \ + } while (0) #else #define FUNC_ENTER(x) #define FUNC_LEAVE() diff --git a/tests/unit/micheline_cparse_stubs.c b/tests/unit/micheline_cparse_stubs.c index 72fcd2874..cebfdc271 100644 --- a/tests/unit/micheline_cparse_stubs.c +++ b/tests/unit/micheline_cparse_stubs.c @@ -21,147 +21,160 @@ #include "micheline_parser.h" #include "operation_parser.h" -CAMLprim value micheline_cparse_capture_name(value mlstate) { - CAMLparam1(mlstate); - CAMLlocal1(r); - tz_parser_state **state = Data_abstract_val(mlstate); - r = caml_copy_string((*state)->field_name); - CAMLreturn(r); +CAMLprim value +micheline_cparse_capture_name(value mlstate) +{ + CAMLparam1(mlstate); + CAMLlocal1(r); + tz_parser_state **state = Data_abstract_val(mlstate); + r = caml_copy_string((*state)->field_name); + CAMLreturn(r); } -CAMLprim value micheline_cparse_init(value size) { - CAMLparam1(size); - CAMLlocal1(r); - r = caml_alloc(sizeof(value), Abstract_tag); - tz_parser_state *state = malloc(sizeof(tz_parser_state)); - *((tz_parser_state**) Data_abstract_val(r)) = state; - tz_micheline_parser_init(state); - size_t s = Long_val(size); - if (s >= 0xFFFF) caml_failwith("micheline_cparse_init: size too large"); - tz_operation_parser_init(state, (uint16_t) s, 1); - CAMLreturn(r); +CAMLprim value +micheline_cparse_init(value size) +{ + CAMLparam1(size); + CAMLlocal1(r); + r = caml_alloc(sizeof(value), Abstract_tag); + tz_parser_state *state = malloc(sizeof(tz_parser_state)); + *((tz_parser_state **)Data_abstract_val(r)) = state; + tz_micheline_parser_init(state); + size_t s = Long_val(size); + if (s >= 0xFFFF) + caml_failwith("micheline_cparse_init: size too large"); + tz_operation_parser_init(state, (uint16_t)s, 1); + CAMLreturn(r); } -CAMLprim value micheline_cparse_step(value mlstate, value input, - value output) { - CAMLparam3(mlstate, input, output); - CAMLlocal3(ibuf, obuf, r); - ibuf = Field(input, 0); - int iofs = Int_val(Field(input, 1)); - int ilen = Int_val(Field(input, 2)); - obuf = Field(output, 0); - int oofs = Int_val(Field(output, 1)); - int olen = Int_val(Field(output, 2)); - // Data_abstract_val() returns a value that could change. - // It must be dereferenced before being used. - // https://gitlab.com/nomadic-labs/tezos-ledger-app-revamp/-/merge_requests/58#note_1434368804 - tz_parser_state *state = *((tz_parser_state**) Data_abstract_val(mlstate)); - - state->regs.ibuf = Bytes_val(ibuf); - state->regs.iofs = iofs; - state->regs.ilen = ilen; - state->regs.obuf = (char*) Bytes_val(obuf); - state->regs.oofs = oofs; - state->regs.olen = olen; - - while (!TZ_IS_BLOCKED(tz_micheline_parser_step(state))); - - int read = ilen - state->regs.ilen; - int written = olen - state->regs.olen; - - r = caml_alloc_tuple(3); - Store_field(r, 0, Val_int(read)); - Store_field(r, 1, Val_int(written)); - - switch (state->errno) { - case TZ_BLO_DONE: - Store_field(r, 2, Val_int(0)); - break; - case TZ_BLO_FEED_ME: - Store_field(r, 2, Val_int(1)); - break; - case TZ_BLO_IM_FULL: - Store_field(r, 2, Val_int(2)); - break; - case TZ_ERR_INVALID_TAG: - caml_failwith("micheline_cparse_step: invalid tag"); - case TZ_ERR_INVALID_OP: - caml_failwith("micheline_cparse_step: invalid operation"); - case TZ_ERR_UNSUPPORTED: - caml_failwith("micheline_cparse_step: unsupported data"); - case TZ_ERR_TOO_LARGE: - caml_failwith("micheline_cparse_step: data size limitation exceeded"); - case TZ_ERR_TOO_DEEP: - caml_failwith("micheline_cparse_step: expression too deep"); - case TZ_ERR_INVALID_STATE: - caml_failwith("micheline_cparse_step: invalid state"); - default: - char err[100]; - snprintf(err, sizeof(err), "micheline_cparse_step: unknown error code %d", - state->errno); - caml_failwith(err); - } - CAMLreturn(r); +CAMLprim value +micheline_cparse_step(value mlstate, value input, value output) +{ + CAMLparam3(mlstate, input, output); + CAMLlocal3(ibuf, obuf, r); + ibuf = Field(input, 0); + int iofs = Int_val(Field(input, 1)); + int ilen = Int_val(Field(input, 2)); + obuf = Field(output, 0); + int oofs = Int_val(Field(output, 1)); + int olen = Int_val(Field(output, 2)); + // Data_abstract_val() returns a value that could change. + // It must be dereferenced before being used. + // https://gitlab.com/nomadic-labs/tezos-ledger-app-revamp/-/merge_requests/58#note_1434368804 + tz_parser_state *state + = *((tz_parser_state **)Data_abstract_val(mlstate)); + + state->regs.ibuf = Bytes_val(ibuf); + state->regs.iofs = iofs; + state->regs.ilen = ilen; + state->regs.obuf = (char *)Bytes_val(obuf); + state->regs.oofs = oofs; + state->regs.olen = olen; + + while (!TZ_IS_BLOCKED(tz_micheline_parser_step(state))) + ; + + int read = ilen - state->regs.ilen; + int written = olen - state->regs.olen; + + r = caml_alloc_tuple(3); + Store_field(r, 0, Val_int(read)); + Store_field(r, 1, Val_int(written)); + + switch (state->errno) { + case TZ_BLO_DONE: + Store_field(r, 2, Val_int(0)); + break; + case TZ_BLO_FEED_ME: + Store_field(r, 2, Val_int(1)); + break; + case TZ_BLO_IM_FULL: + Store_field(r, 2, Val_int(2)); + break; + case TZ_ERR_INVALID_TAG: + caml_failwith("micheline_cparse_step: invalid tag"); + case TZ_ERR_INVALID_OP: + caml_failwith("micheline_cparse_step: invalid operation"); + case TZ_ERR_UNSUPPORTED: + caml_failwith("micheline_cparse_step: unsupported data"); + case TZ_ERR_TOO_LARGE: + caml_failwith("micheline_cparse_step: data size limitation exceeded"); + case TZ_ERR_TOO_DEEP: + caml_failwith("micheline_cparse_step: expression too deep"); + case TZ_ERR_INVALID_STATE: + caml_failwith("micheline_cparse_step: invalid state"); + default: + char err[100]; + snprintf(err, sizeof(err), + "micheline_cparse_step: unknown error code %d", + state->errno); + caml_failwith(err); + } + CAMLreturn(r); } -CAMLprim value operation_cparse_step(value mlstate, value input, - value output) { - CAMLparam3(mlstate, input, output); - CAMLlocal3(ibuf, obuf, r); - ibuf = Field(input, 0); - int iofs = Int_val(Field(input, 1)); - int ilen = Int_val(Field(input, 2)); - obuf = Field(output, 0); - int oofs = Int_val(Field(output, 1)); - int olen = Int_val(Field(output, 2)); - // Data_abstract_val() returns a value that could change. - // It must be dereferenced before being used. - // https://gitlab.com/nomadic-labs/tezos-ledger-app-revamp/-/merge_requests/58#note_1434368804 - tz_parser_state *state = *((tz_parser_state**) Data_abstract_val(mlstate)); - - state->regs.ibuf = Bytes_val(ibuf); - state->regs.iofs = iofs; - state->regs.ilen = ilen; - state->regs.obuf = (char*) Bytes_val(obuf); - state->regs.oofs = oofs; - state->regs.olen = olen; - - while (!TZ_IS_BLOCKED(tz_operation_parser_step(state))); - - int read = ilen - state->regs.ilen; - int written = olen - state->regs.olen; - - r = caml_alloc_tuple(3); - Store_field(r, 0, Val_int(read)); - Store_field(r, 1, Val_int(written)); - - switch (state->errno) { - case TZ_BLO_DONE: - Store_field(r, 2, Val_int(0)); - break; - case TZ_BLO_FEED_ME: - Store_field(r, 2, Val_int(1)); - break; - case TZ_BLO_IM_FULL: - Store_field(r, 2, Val_int(2)); - break; - case TZ_ERR_INVALID_TAG: - caml_failwith("operation_cparse_step: invalid tag"); - case TZ_ERR_INVALID_OP: - caml_failwith("operation_cparse_step: invalid operation"); - case TZ_ERR_UNSUPPORTED: - caml_failwith("operation_cparse_step: unsupported data"); - case TZ_ERR_TOO_LARGE: - caml_failwith("operation_cparse_step: data size limitation exceeded"); - case TZ_ERR_TOO_DEEP: - caml_failwith("operation_cparse_step: expression too deep"); - case TZ_ERR_INVALID_STATE: - caml_failwith("operation_cparse_step: invalid state"); - default: - char err[100]; - snprintf(err, sizeof(err), "operation_cparse_step: unknown error code %d", - state->errno); - caml_failwith(err); - } - CAMLreturn(r); +CAMLprim value +operation_cparse_step(value mlstate, value input, value output) +{ + CAMLparam3(mlstate, input, output); + CAMLlocal3(ibuf, obuf, r); + ibuf = Field(input, 0); + int iofs = Int_val(Field(input, 1)); + int ilen = Int_val(Field(input, 2)); + obuf = Field(output, 0); + int oofs = Int_val(Field(output, 1)); + int olen = Int_val(Field(output, 2)); + // Data_abstract_val() returns a value that could change. + // It must be dereferenced before being used. + // https://gitlab.com/nomadic-labs/tezos-ledger-app-revamp/-/merge_requests/58#note_1434368804 + tz_parser_state *state + = *((tz_parser_state **)Data_abstract_val(mlstate)); + + state->regs.ibuf = Bytes_val(ibuf); + state->regs.iofs = iofs; + state->regs.ilen = ilen; + state->regs.obuf = (char *)Bytes_val(obuf); + state->regs.oofs = oofs; + state->regs.olen = olen; + + while (!TZ_IS_BLOCKED(tz_operation_parser_step(state))) + ; + + int read = ilen - state->regs.ilen; + int written = olen - state->regs.olen; + + r = caml_alloc_tuple(3); + Store_field(r, 0, Val_int(read)); + Store_field(r, 1, Val_int(written)); + + switch (state->errno) { + case TZ_BLO_DONE: + Store_field(r, 2, Val_int(0)); + break; + case TZ_BLO_FEED_ME: + Store_field(r, 2, Val_int(1)); + break; + case TZ_BLO_IM_FULL: + Store_field(r, 2, Val_int(2)); + break; + case TZ_ERR_INVALID_TAG: + caml_failwith("operation_cparse_step: invalid tag"); + case TZ_ERR_INVALID_OP: + caml_failwith("operation_cparse_step: invalid operation"); + case TZ_ERR_UNSUPPORTED: + caml_failwith("operation_cparse_step: unsupported data"); + case TZ_ERR_TOO_LARGE: + caml_failwith("operation_cparse_step: data size limitation exceeded"); + case TZ_ERR_TOO_DEEP: + caml_failwith("operation_cparse_step: expression too deep"); + case TZ_ERR_INVALID_STATE: + caml_failwith("operation_cparse_step: invalid state"); + default: + char err[100]; + snprintf(err, sizeof(err), + "operation_cparse_step: unknown error code %d", + state->errno); + caml_failwith(err); + } + CAMLreturn(r); }