/*
* 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);
}
