/* * storage_reset_uuid() - Reset configuration uuid in RAM with random numbers * * INPUT * none * OUTPUT * none * */ void storage_reset_uuid(void) { // set random uuid random_buffer(shadow_config.meta.uuid, sizeof(shadow_config.meta.uuid)); data2hex(shadow_config.meta.uuid, sizeof(shadow_config.meta.uuid), shadow_config.meta.uuid_str); }
void reset_init(bool display_random, uint32_t _strength, bool passphrase_protection, bool pin_protection, const char *language, const char *label) { if(_strength != 128 && _strength != 192 && _strength != 256) { fsm_sendFailure(FailureType_Failure_SyntaxError, "Invalid strength (has to be 128, 192 or 256 bits)"); go_home(); return; } strength = _strength; random_buffer(int_entropy, 32); char ent_str[4][17]; data2hex(int_entropy , 8, ent_str[0]); data2hex(int_entropy + 8, 8, ent_str[1]); data2hex(int_entropy + 16, 8, ent_str[2]); data2hex(int_entropy + 24, 8, ent_str[3]); if(display_random) { if(!confirm(ButtonRequestType_ButtonRequest_ResetDevice, "Internal Entropy", "%s %s %s %s", ent_str[0], ent_str[1], ent_str[2], ent_str[3])) { fsm_sendFailure(FailureType_Failure_ActionCancelled, "Reset cancelled"); go_home(); return; } } if(pin_protection && !change_pin()) { go_home(); return; } storage_set_passphrase_protected(passphrase_protection); storage_set_language(language); storage_set_label(label); EntropyRequest resp; memset(&resp, 0, sizeof(EntropyRequest)); msg_write(MessageType_MessageType_EntropyRequest, &resp); awaiting_entropy = true; }
void layoutFirmwareHash(const uint8_t *hash) { char str[4][17]; for (int i = 0; i < 4; i++) { data2hex(hash + i * 8, 8, str[i]); } layoutDialog(NULL, str_abort, str_continue, "Comp. fingerprints", str[0], str[1], str[2], str[3], NULL, NULL, OLED_RED); }
void fill_serialno_fixed(char *s) { uint32_t uuid[8]; desig_get_unique_id(uuid); sha256_Raw((const uint8_t *)uuid, 12, (uint8_t *)uuid); sha256_Raw((const uint8_t *)uuid, 32, (uint8_t *)uuid); data2hex(uuid, 12, s); }
void layoutFirmwareHash(const uint8_t *hash) { char str[4][17]; for (int i = 0; i < 4; i++) { data2hex(hash + i * 8, 8, str[i]); } layoutDialog(&bmp_icon_question, "Abort", "Continue", "Compare fingerprints", str[0], str[1], str[2], str[3], NULL, NULL); }
static void test_one(const char *f, Elf *elf, int flags) { char *b = NULL; GElf_Ehdr ehdr; if (elf_kind(elf) != ELF_K_ELF) { if (flags & P_OTHER) goto out_print; return; } if (gelf_getehdr(elf, &ehdr) == NULL) return; if ((flags & P_BUILDID)) { size_t sz; uint8_t *data = get_buildid(elf, &sz); if (data) { b = alloca(sz * 2 + 1); data2hex(data, sz, b); goto out_print; } return; } if ((flags & P_REL) && (ehdr.e_type == ET_REL)) goto out_print; if ((flags & P_EXEC) && (ehdr.e_type == ET_EXEC)) goto out_print; if ((flags & P_DEBUG) && has_debuginfo(elf)) goto out_print; /* arguably should print if P_OTHER, but, nah. */ if (ehdr.e_type != ET_DYN) return; if (has_dt_debug(elf, &ehdr)) { if (flags & P_EXEC) { goto out_print; /* treat PIEs as executables */ } } else if (flags & P_DSO) { goto out_print; } return; out_print: write(1, f, strlen(f)); if (b) { write(1, " ", 1); write(1, b, strlen(b)); } write(1, (flags & P_NEWLINE) ? "\n" : "", 1); }
/* This function will convert an attribute value, specified by the OID, * to a string. The result will be a null terminated string. * * res may be null. This will just return the res_size, needed to * hold the string. */ int _gnutls_x509_dn_to_string(const char *oid, void *value, int value_size, gnutls_datum_t * str) { const struct oid_to_string *oentry; int ret; gnutls_datum_t tmp; size_t size; if (value == NULL || value_size <= 0) { gnutls_assert(); return GNUTLS_E_INVALID_REQUEST; } oentry = get_oid_entry(oid); if (oentry == NULL) { /* unknown OID -> hex */ unknown_oid: str->size = value_size * 2 + 2; str->data = gnutls_malloc(str->size); if (str->data == NULL) return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR); size = str->size; ret = data2hex(value, value_size, str->data, &size); if (ret < 0) { gnutls_assert(); gnutls_free(str->data); return ret; } str->size = size; return 0; } if (oentry->asn_desc != NULL) { /* complex */ ret = decode_complex_string(oentry, value, value_size, &tmp); if (ret < 0) { /* we failed decoding -> handle it as unknown OID */ goto unknown_oid; } } else { ret = _gnutls_x509_decode_string(oentry->etype, value, value_size, &tmp); if (ret < 0) { /* we failed decoding -> handle it as unknown OID */ goto unknown_oid; } } ret = str_escape(&tmp, str); _gnutls_free_datum(&tmp); if (ret < 0) return gnutls_assert_val(ret); return 0; }
void layoutFirmwareHash(uint8_t *hash) { char str[4][17]; int i; for (i = 0; i < 4; i++) { data2hex(hash + i * 8, 8, str[i]); } layoutDialog(DIALOG_ICON_QUESTION, "Abort", "Continue", "Compare fingerprints", str[0], str[1], str[2], str[3], NULL, NULL); }
void reset_init(bool display_random, uint32_t _strength, bool passphrase_protection, bool pin_protection, const char *language, const char *label) { if (_strength != 128 && _strength != 192 && _strength != 256) { fsm_sendFailure(FailureType_Failure_SyntaxError, "Invalid strength (has to be 128, 192 or 256 bits)"); layoutHome(); return; } strength = _strength; random_buffer(int_entropy, 32); char ent_str[4][17]; data2hex(int_entropy , 8, ent_str[0]); data2hex(int_entropy + 8, 8, ent_str[1]); data2hex(int_entropy + 16, 8, ent_str[2]); data2hex(int_entropy + 24, 8, ent_str[3]); if (display_random) { layoutDialogSwipe(DIALOG_ICON_INFO, "Cancel", "Continue", NULL, "Internal entropy:", ent_str[0], ent_str[1], ent_str[2], ent_str[3], NULL); if (!protectButton(ButtonRequestType_ButtonRequest_ResetDevice, false)) { fsm_sendFailure(FailureType_Failure_ActionCancelled, "Reset cancelled"); layoutHome(); return; } } if (pin_protection && !protectChangePin()) { fsm_sendFailure(FailureType_Failure_ActionCancelled, "PIN change failed"); layoutHome(); return; } storage.has_passphrase_protection = true; storage.passphrase_protection = passphrase_protection; storage_setLanguage(language); storage_setLabel(label); EntropyRequest resp; memset(&resp, 0, sizeof(EntropyRequest)); msg_write(MessageType_MessageType_EntropyRequest, &resp); awaiting_entropy = true; }
static int make_printable_string(unsigned etype, const gnutls_datum_t * input, gnutls_datum_t * out) { int printable = 0; int ret; unsigned int i; if (etype == ASN1_ETYPE_BMP_STRING) { ret = _gnutls_ucs2_to_utf8(input->data, input->size, out, 1); if (ret < 0) { /* could not convert. Handle it as non-printable */ printable = 0; } else printable = 1; } else if (etype == ASN1_ETYPE_TELETEX_STRING) { int ascii = 0; /* HACK: if the teletex string contains only ascii * characters then treat it as printable. */ for (i = 0; i < input->size; i++) if (!c_isascii(input->data[i])) ascii = 1; if (ascii == 0) { out->data = gnutls_malloc(input->size + 1); if (out->data == NULL) return gnutls_assert_val (GNUTLS_E_MEMORY_ERROR); memcpy(out->data, input->data, input->size); out->size = input->size; out->data[out->size] = 0; printable = 1; } } else if (etype != ASN1_ETYPE_UNIVERSAL_STRING) /* supported but not printable */ return GNUTLS_E_INVALID_REQUEST; if (printable == 0) { /* need to allocate out */ ret = data2hex(input->data, input->size, out); if (ret < 0) { gnutls_assert(); return ret; } } return 0; }
/* * storage_init() - Validate storage content and copy data to shadow memory * * INPUT * none * OUTPUT * none */ void storage_init(void) { ConfigFlash *stor_config; /* Find storage sector with valid data and set storage_location variable */ if(find_active_storage(&storage_location)) { stor_config = (ConfigFlash *)flash_write_helper(storage_location); } else { /* Set to storage sector1 as default if no sector has been initialized */ storage_location = STORAGE_SECT_DEFAULT; stor_config = (ConfigFlash *)flash_write_helper(storage_location); } /* Reset shadow configuration in RAM */ storage_reset(); /* Verify storage partition is initialized */ if(memcmp((void *)stor_config->meta.magic , STORAGE_MAGIC_STR, STORAGE_MAGIC_LEN) == 0) { /* Clear out stor_config before finding end config node */ memcpy(shadow_config.meta.uuid, (void *)&stor_config->meta.uuid, sizeof(shadow_config.meta.uuid)); data2hex(shadow_config.meta.uuid, sizeof(shadow_config.meta.uuid), shadow_config.meta.uuid_str); if(stor_config->storage.version) { if(stor_config->storage.version <= STORAGE_VERSION) { storage_from_flash(stor_config); } } /* New app with storage version changed! update the storage space */ if(stor_config->storage.version != STORAGE_VERSION) { storage_commit(); } } else { /* Keep storage area cleared */ storage_reset_uuid(); storage_commit(); } }
void layoutPublicKey(const uint8_t *pubkey) { char desc[16]; strlcpy(desc, "Public Key: 00", sizeof(desc)); if (pubkey[0] == 1) { /* ed25519 public key */ // pass - leave 00 } else { data2hex(pubkey, 1, desc + 12); } const char **str = split_message_hex(pubkey + 1, 32 * 2); layoutDialogSwipe(&bmp_icon_question, NULL, _("Continue"), NULL, desc, str[0], str[1], str[2], str[3], NULL); }
struct c_f_hex c_float2hex(struct c_float in) { short sign, esign, i; struct c_f_hex ret; for (i = 0; i < 15; ++i) ret.stri[i] = 0; if (in.mantisse < 0) { ret.stri[0] = '-'; sign = -1; } else { sign = 1; ret.stri[0] = '+'; }; if (in.exponent < 0) { ret.stri[9] = '-'; esign = -1; } else { esign = 1; ret.stri[9] = '+'; }; data2hex(8, sign * in.mantisse, &ret.stri[1]); /*ret.stri[9]='^';*/ data2hex(2, esign * in.exponent, &ret.stri[10]); return ret; }
/* * verify_exchange_address - verify address specified in exchange contract belongs to device. * * INPUT * coin - the CoinType * address_n_count - depth of node * address_n - pointer to node path * address_str - string representation of address * address_str_len - address length * root - root hd node * * OUTPUT * true/false - success/failure */ static bool verify_exchange_address(const CoinType *coin, size_t address_n_count, uint32_t *address_n, char *address_str, size_t address_str_len, const HDNode *root, bool is_token) { static CONFIDENTIAL HDNode node; memcpy(&node, root, sizeof(HDNode)); if (hdnode_private_ckd_cached(&node, address_n, address_n_count, NULL) == 0) { memzero(&node, sizeof(node)); return false; } if (isEthereumLike(coin->coin_name) || is_token) { char tx_out_address[sizeof(((ExchangeAddress *)NULL)->address)]; EthereumAddress_address_t ethereum_addr; ethereum_addr.size = 20; if (hdnode_get_ethereum_pubkeyhash(&node, ethereum_addr.bytes) == 0) { memzero(&node, sizeof(node)); return false; } data2hex((char *)ethereum_addr.bytes, 20, tx_out_address); return addresses_same(tx_out_address, sizeof(tx_out_address), address_str, address_str_len, true); } const curve_info *curve = get_curve_by_name(coin->curve_name); if (!curve) { memzero(&node, sizeof(node)); return false; } char tx_out_address[36]; hdnode_fill_public_key(&node); ecdsa_get_address(node.public_key, coin->address_type, curve->hasher_pubkey, curve->hasher_base58, tx_out_address, sizeof(tx_out_address)); memzero(&node, sizeof(node)); return strncmp(tx_out_address, address_str, sizeof(tx_out_address)) == 0; }
void storage_init(void) { storage_reset(); // if magic is ok if (memcmp((void *)FLASH_STORAGE_START, "stor", 4) == 0) { // load uuid memcpy(storage_uuid, (void *)(FLASH_STORAGE_START + 4), sizeof(storage_uuid)); data2hex(storage_uuid, sizeof(storage_uuid), storage_uuid_str); // load storage struct uint32_t version = ((Storage *)(FLASH_STORAGE_START + 4 + sizeof(storage_uuid)))->version; if (version && version <= STORAGE_VERSION) { storage_from_flash(version); } if (version != STORAGE_VERSION) { storage_commit(); } } else { storage_reset_uuid(); storage_commit(); } }
/* * verify_exchange_contract() - Verify content of exchange contract is valid * * INPUT * exchange: exchange pointer * root - root hd node * OUTPUT * true/false - success/failure */ static bool verify_exchange_contract(const CoinType *coin, void *vtx_out, const HDNode *root) { ExchangeType *exchange; if (isEthereumLike(coin->coin_name)) { exchange = &((EthereumSignTx *)vtx_out)->exchange_type; /*Verify response structure from client is compatible*/ if (exchange->signed_exchange_response.has_response) { /*Obsolete response data structure detected. Should be ExchangeResponseV2! */ set_exchange_error(ERROR_EXCHANGE_RESPONSE_STRUCTURE); return false; } } else { exchange = &((TxOutputType *)vtx_out)->exchange_type; } void *tx_out_amount; char tx_out_address[sizeof(((ExchangeAddress *)NULL)->address)]; memset(tx_out_address, 0, sizeof(tx_out_address)); CoinType standard_deposit; const CoinType *deposit_coin = NULL; if (isEthereumLike(coin->coin_name)) { EthereumSignTx *tx_out = (EthereumSignTx *)vtx_out; tx_out->has_chain_id = coin->has_forkid; tx_out->chain_id = coin->forkid; if (ethereum_isNonStandardERC20Transfer(tx_out)) { // token specific address, shorcut, and value data2hex(tx_out->token_to.bytes, tx_out->token_to.size, tx_out_address); tx_out_amount = (void *)tx_out->token_value.bytes; deposit_coin = coinByShortcut(tx_out->token_shortcut); } else if (ethereum_isStandardERC20Transfer(tx_out)) { if (!ethereum_getStandardERC20Recipient(tx_out, tx_out_address, sizeof(tx_out_address)) || !ethereum_getStandardERC20Amount(tx_out, &tx_out_amount) || !ethereum_getStandardERC20Coin(tx_out, &standard_deposit)) { set_exchange_error(ERROR_EXCHANGE_RESPONSE_STRUCTURE); return false; } deposit_coin = &standard_deposit; } else { data2hex(tx_out->to.bytes, tx_out->to.size, tx_out_address); tx_out_amount = (void *)tx_out->value.bytes; deposit_coin = coin; } } else { TxOutputType *tx_out = (TxOutputType *)vtx_out; exchange = &tx_out->exchange_type; memcpy(tx_out_address, tx_out->address, sizeof(tx_out->address)); tx_out_amount = (void *)&tx_out->amount; deposit_coin = coin; } if (!deposit_coin) { set_exchange_error(ERROR_EXCHANGE_RESPONSE_STRUCTURE); return false; } /* verify Exchange signature */ uint8_t response_raw[sizeof(ExchangeResponseV2)]; memset(response_raw, 0, sizeof(response_raw)); int response_raw_filled_len = encode_pb( (const void *)&exchange->signed_exchange_response.responseV2, ExchangeResponseV2_fields, response_raw, sizeof(response_raw)); if(response_raw_filled_len == 0) { set_exchange_error(ERROR_EXCHANGE_SIGNATURE); return false; } const CoinType *signed_coin = coinByShortcut((const char *)"BTC"); if(cryptoMessageVerify(signed_coin, response_raw, response_raw_filled_len, ShapeShift_pubkey, (uint8_t *)exchange->signed_exchange_response.signature.bytes) != 0) { set_exchange_error(ERROR_EXCHANGE_SIGNATURE); return false; } /* verify Exchange API-Key */ if(memcmp(ShapeShift_api_key, exchange->signed_exchange_response.responseV2.api_key.bytes, sizeof(ShapeShift_api_key)) != 0) { set_exchange_error(ERROR_EXCHANGE_API_KEY); return false; } /* verify Deposit coin type */ if (!verify_coins_match(deposit_coin, getDepositCoin(exchange))) { set_exchange_error(ERROR_EXCHANGE_DEPOSIT_COINTYPE); return false; } /* verify Deposit address */ if(!addresses_same(tx_out_address, sizeof(tx_out_address), exchange->signed_exchange_response.responseV2.deposit_address.address, sizeof(exchange->signed_exchange_response.responseV2.deposit_address.address), isEthereumLike(coin->coin_name))) { set_exchange_error(ERROR_EXCHANGE_DEPOSIT_ADDRESS); return false; } /* verify Deposit amount*/ if(!verify_exchange_dep_amount(coin->coin_name, tx_out_amount, &exchange->signed_exchange_response.responseV2.deposit_amount)) { set_exchange_error(ERROR_EXCHANGE_DEPOSIT_AMOUNT); return false; } /* verify Withdrawal address */ const CoinType *withdraw_coin = getWithdrawCoin(exchange); if (!withdraw_coin) { set_exchange_error(ERROR_EXCHANGE_WITHDRAWAL_COINTYPE); return false; } if (!verify_coins_match(withdraw_coin, coinByNameOrTicker(exchange->withdrawal_coin_name))) { set_exchange_error(ERROR_EXCHANGE_WITHDRAWAL_COINTYPE); return false; } if (!verify_exchange_address( withdraw_coin, exchange->withdrawal_address_n_count, exchange->withdrawal_address_n, exchange->signed_exchange_response.responseV2.withdrawal_address.address, sizeof(exchange->signed_exchange_response.responseV2.withdrawal_address.address), root, withdraw_coin->has_contract_address)) { set_exchange_error(ERROR_EXCHANGE_WITHDRAWAL_ADDRESS); return false; } /* verify Return coin type */ const CoinType *return_coin = getReturnCoin(exchange); if (!return_coin) { set_exchange_error(ERROR_EXCHANGE_RETURN_COINTYPE); return false; } if (!verify_coins_match(deposit_coin, return_coin)) { set_exchange_error(ERROR_EXCHANGE_RETURN_COINTYPE); return false; } /* verify Return address */ if (!verify_exchange_address( return_coin, exchange->return_address_n_count, exchange->return_address_n, exchange->signed_exchange_response.responseV2.return_address.address, sizeof(exchange->signed_exchange_response.responseV2.return_address.address), root, return_coin->has_contract_address)) { set_exchange_error(ERROR_EXCHANGE_RETURN_ADDRESS); return false; } set_exchange_error(NO_EXCHANGE_ERROR); return true; }
int input(struct inp_event *inp, int wait) { int rc; SDL_Event event; SDL_Event peek; memset(&event, 0, sizeof(event)); memset(&peek, 0, sizeof(peek)); if (wait) { rc = SDL_WaitEvent(&event); } else rc = SDL_PollEvent(&event); if (!rc) return 0; inp->sym[0] = 0; inp->type = 0; inp->count = 1; switch(event.type){ #if SDL_VERSION_ATLEAST(2,0,0) case SDL_MULTIGESTURE: case SDL_FINGERMOTION: if (DIRECT_MODE && !game_paused()) return AGAIN; if (SDL_PeepEvents(&peek, 1, SDL_PEEKEVENT, event.type, event.type) > 0) return AGAIN; /* to avoid flickering */ break; case SDL_FINGERUP: #ifdef IOS touch_num = 0; #endif case SDL_FINGERDOWN: #ifdef IOS if (event.type == SDL_FINGERDOWN) { if (gfx_ticks() - touch_stamp > 100) { touch_num = 0; touch_stamp = gfx_ticks(); } touch_num ++; if (touch_num >= 3) { inp->type = KEY_DOWN; inp->code = 0; strncpy(inp->sym, "escape", sizeof(inp->sym)); break; } } #endif gfx_finger_pos_scale(event.tfinger.x, event.tfinger.y, &inp->x, &inp->y); inp->type = (event.type == SDL_FINGERDOWN) ? FINGER_DOWN : FINGER_UP; data2hex(&event.tfinger.fingerId, sizeof(event.tfinger.fingerId), inp->sym); inp->sym[sizeof(event.tfinger.fingerId) * 2] = ':'; data2hex(&event.tfinger.touchId, sizeof(event.tfinger.touchId), inp->sym + sizeof(event.tfinger.fingerId) * 2 + 1); inp->sym[sizeof(event.tfinger.fingerId) * 2 + 1 + sizeof(event.tfinger.touchId) * 2] = 0; break; case SDL_WINDOWEVENT: switch (event.window.event) { /* case SDL_WINDOWEVENT_SHOWN: */ /* case SDL_WINDOWEVENT_RESIZED: */ case SDL_WINDOWEVENT_SIZE_CHANGED: gfx_resize(event.window.data1, event.window.data2); case SDL_WINDOWEVENT_EXPOSED: gfx_flip(); gfx_commit(); break; case SDL_WINDOWEVENT_MINIMIZED: #if defined(ANDROID) gfx_set_mode(gfx_width, gfx_height, gfx_fs); /* reset window size */ #endif case SDL_WINDOWEVENT_RESTORED: m_minimized = (event.window.event == SDL_WINDOWEVENT_MINIMIZED && !opt_fs); snd_pause(!nopause_sw && m_minimized); break; case SDL_WINDOWEVENT_ENTER: case SDL_WINDOWEVENT_FOCUS_GAINED: m_focus = 1; if (opt_fs) mouse_cursor(0); break; case SDL_WINDOWEVENT_LEAVE: m_focus = 0; if (opt_fs) mouse_cursor(1); /* is it hack?*/ break; default: break; } if (SDL_PeepEvents(&peek, 1, SDL_PEEKEVENT, SDL_WINDOWEVENT, SDL_WINDOWEVENT) > 0) return AGAIN; /* to avoid flickering */ return 0; #else case SDL_ACTIVEEVENT: if (event.active.state & SDL_APPACTIVE) { m_minimized = !event.active.gain; snd_pause(!nopause_sw && m_minimized); } if (event.active.state & (SDL_APPMOUSEFOCUS | SDL_APPINPUTFOCUS)) { if (event.active.gain) { m_focus = 1; if (opt_fs) mouse_cursor(0); } else if (event.active.state & SDL_APPMOUSEFOCUS) { m_focus = 0; if (opt_fs) mouse_cursor(1); /* is it hack?*/ } } #if SDL_VERSION_ATLEAST(1,3,0) if (SDL_PeepEvents(&peek, 1, SDL_PEEKEVENT, SDL_ACTIVEEVENT, SDL_ACTIVEEVENT) > 0) #else if (SDL_PeepEvents(&peek, 1, SDL_PEEKEVENT, SDL_EVENTMASK(SDL_ACTIVEEVENT)) > 0) #endif return AGAIN; /* to avoid flickering */ return 0; #endif case SDL_USEREVENT: { void (*p) (void*) = (void (*)(void*))event.user.data1; p(event.user.data2); return AGAIN; } case SDL_QUIT: game_running = 0; return -1; case SDL_KEYDOWN: /* A key has been pressed */ #if SDL_VERSION_ATLEAST(2,0,0) if (event.key.repeat) { if (DIRECT_MODE && !game_paused()) /* do not send key repeats */ return AGAIN; if (gfx_ticks() - last_press_ms < INPUT_REP_DELAY_MS) return AGAIN; if ((gfx_ticks() - last_repeat_ms) < INPUT_REP_INTERVAL_MS) return AGAIN; last_repeat_ms = gfx_ticks(); } else { last_press_ms = gfx_ticks(); last_repeat_ms = gfx_ticks(); } #endif inp->type = KEY_DOWN; inp->code = event.key.keysym.scancode; #if SDL_VERSION_ATLEAST(1,3,0) strncpy(inp->sym, SDL_GetScancodeName(inp->code), sizeof(inp->sym)); #else strncpy(inp->sym, SDL_GetKeyName(event.key.keysym.sym), sizeof(inp->sym)); #endif inp->sym[sizeof(inp->sym) - 1] = 0; tolow(inp->sym); #if SDL_VERSION_ATLEAST(1,3,0) key_compat(inp); #endif #if SDL_VERSION_ATLEAST(1,3,0) /* strange bug in some SDL2 env, with up/down events storm */ if (SDL_PeepEvents(&peek, 1, SDL_PEEKEVENT, SDL_KEYDOWN, SDL_KEYUP) > 0) { if (peek.key.keysym.scancode == event.key.keysym.scancode && peek.key.repeat == 0) return AGAIN; } #endif break; case SDL_KEYUP: inp->type = KEY_UP; inp->code = event.key.keysym.scancode; #if SDL_VERSION_ATLEAST(1,3,0) strncpy(inp->sym, SDL_GetScancodeName(inp->code), sizeof(inp->sym)); #else strncpy(inp->sym, SDL_GetKeyName(event.key.keysym.sym), sizeof(inp->sym)); #endif inp->sym[sizeof(inp->sym) - 1] = 0; tolow(inp->sym); #if SDL_VERSION_ATLEAST(1,3,0) key_compat(inp); #endif #if SDL_VERSION_ATLEAST(1,3,0) /* strange bug in some SDL2 env, with up/down events storm */ if (SDL_PeepEvents(&peek, 1, SDL_PEEKEVENT, SDL_KEYDOWN, SDL_KEYUP) > 0) { if (event.key.keysym.scancode == peek.key.keysym.scancode && peek.key.repeat == 0) return AGAIN; } #endif break; case SDL_MOUSEMOTION: m_focus = 1; /* ahhh */ if (DIRECT_MODE && !game_paused()) return AGAIN; inp->type = MOUSE_MOTION; inp->x = event.button.x; inp->y = event.button.y; #if SDL_VERSION_ATLEAST(1,3,0) while (SDL_PeepEvents(&peek, 1, SDL_GETEVENT, SDL_MOUSEMOTION, SDL_MOUSEMOTION) > 0) { #else while (SDL_PeepEvents(&peek, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)) > 0) { #endif inp->x = peek.button.x; inp->y = peek.button.y; } break; case SDL_MOUSEBUTTONUP: inp->type = MOUSE_UP; inp->x = event.button.x; inp->y = event.button.y; inp->code = event.button.button; if (event.button.button == 4) inp->type = 0; else if (event.button.button == 5) inp->type = 0; break; #if SDL_VERSION_ATLEAST(2,0,0) case SDL_MOUSEWHEEL: if (DIRECT_MODE && !game_paused()) return AGAIN; inp->type = (event.wheel.y > 0) ? MOUSE_WHEEL_UP : MOUSE_WHEEL_DOWN; while (SDL_PeepEvents(&peek, 1, SDL_GETEVENT, SDL_MOUSEWHEEL, SDL_MOUSEWHEEL) > 0) { if (!((event.wheel.y > 0 && inp->type == MOUSE_WHEEL_UP) || (event.wheel.y < 0 && inp->type == MOUSE_WHEEL_DOWN))) break; inp->count ++; } break; #endif case SDL_MOUSEBUTTONDOWN: m_focus = 1; /* ahhh */ inp->type = MOUSE_DOWN; inp->x = event.button.x; inp->y = event.button.y; inp->code = event.button.button; if (event.button.button == 4) inp->type = MOUSE_WHEEL_UP; else if (event.button.button == 5) inp->type = MOUSE_WHEEL_DOWN; #if SDL_VERSION_ATLEAST(1,3,0) while (SDL_PeepEvents(&peek, 1, SDL_GETEVENT, SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONDOWN) > 0) { #else while (SDL_PeepEvents(&peek, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEBUTTONDOWN)) > 0) { #endif if (!((event.button.button == 4 && inp->type == MOUSE_WHEEL_UP) || (event.button.button == 5 && inp->type == MOUSE_WHEEL_DOWN))) break; inp->count ++; } break; default: break; } return 1; }
void storage_reset_uuid(void) { // set random uuid random_buffer(storage_uuid, sizeof(storage_uuid)); data2hex(storage_uuid, sizeof(storage_uuid), storage_uuid_str); }