dandri/seader
1
0
Fork 0
mirror of https://github.com/bettse/seader.git synced 2026-08-27 23:44:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

FWT timeout

Browse Source
This commit is contained in:
Eric Betts
2023-11-12 19:51:38 -08:00
parent 99c04ee2ed
commit 059fbb4540
2 changed files with 39 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files
seader_worker.c
+38 -33
View File
@@ -7,7 +7,7 @@
#define APDU_HEADER_LEN 5
#define ASN1_PREFIX 6
#define ASN1_DEBUG true
//#define ASN1_DEBUG true
#define RFAL_PICOPASS_TXRX_FLAGS \
(FURI_HAL_NFC_LL_TXRX_FLAGS_CRC_TX_MANUAL | FURI_HAL_NFC_LL_TXRX_FLAGS_AGC_ON | \
@@ -36,6 +36,7 @@ SeaderWorker* seader_worker_alloc() {
seader_worker->thread =
furi_thread_alloc_ex("SeaderWorker", 8192, seader_worker_task, seader_worker);
seader_worker->messages = furi_message_queue_alloc(2, SEADER_UART_RX_BUF_SIZE);
seader_worker->mq_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
seader_worker->callback = NULL;
seader_worker->context = NULL;
@@ -52,6 +53,7 @@ void seader_worker_free(SeaderWorker* seader_worker) {
furi_thread_free(seader_worker->thread);
furi_message_queue_free(seader_worker->messages);
furi_mutex_free(seader_worker->mq_mutex);
furi_record_close(RECORD_STORAGE);
@@ -302,7 +304,7 @@ bool seader_unpack_pacs(
char pacDebug[384] = {0};
(&asn_DEF_PAC)->op->print_struct(&asn_DEF_PAC, pac, 1, seader_asn_to_string, pacDebug);
if(strlen(pacDebug) > 0) {
FURI_LOG_D(TAG, "Received pac: %s", pacDebug);
// FURI_LOG_D(TAG, "Received pac: %s", pacDebug);
memset(display, 0, sizeof(display));
if(seader_credential->sio[0] == 0x30) {
@@ -310,7 +312,7 @@ bool seader_unpack_pacs(
snprintf(
display + (i * 2), sizeof(display), "%02x", seader_credential->sio[i]);
}
FURI_LOG_D(TAG, "SIO %s", display);
// FURI_LOG_D(TAG, "SIO %s", display);
}
}
@@ -361,7 +363,7 @@ bool seader_parse_version(SeaderWorker* seader_worker, uint8_t* buf, size_t size
->op->print_struct(
&asn_DEF_SamVersion, version, 1, seader_asn_to_string, versionDebug);
if(strlen(versionDebug) > 0) {
FURI_LOG_D(TAG, "Received version: %s", versionDebug);
// FURI_LOG_D(TAG, "Received version: %s", versionDebug);
}
if(version->version.size == 2) {
memcpy(seader_worker->sam_version, version->version.buf, version->version.size);
@@ -400,7 +402,7 @@ bool seader_parse_sam_response(SeaderWorker* seader_worker, SamResponse_t* samRe
for(uint8_t i = 0; i < samResponse->size; i++) {
snprintf(display + (i * 2), sizeof(display), "%02x", samResponse->buf[i]);
}
FURI_LOG_D(TAG, "unknown samResponse %d: %s", samResponse->size, display);
// FURI_LOG_D(TAG, "unknown samResponse %d: %s", samResponse->size, display);
}
return false;
@@ -451,7 +453,7 @@ void seader_send_nfc_rx(SeaderUartBridge* seader_uart, uint8_t* buffer, size_t l
}
/* Assumes this is called in the context of the NFC API callback */
bool seader_iso14443a_transmit(
NfcCommand seader_iso14443a_transmit(
Seader* seader,
uint8_t* buffer,
size_t len,
@@ -459,19 +461,17 @@ bool seader_iso14443a_transmit(
uint8_t format[3]) {
UNUSED(timeout);
UNUSED(format);
UNUSED(seader);
UNUSED(buffer);
UNUSED(len);
BitBuffer* tx_buffer = bit_buffer_alloc(len);
BitBuffer* rx_buffer = bit_buffer_alloc(SEADER_POLLER_MAX_BUFFER_SIZE);
NfcCommand ret = NfcCommandContinue;
do {
bit_buffer_append_bytes(tx_buffer, buffer, len);
NfcError error = nfc_poller_trx(seader->nfc, tx_buffer, rx_buffer, SEADER_POLLER_MAX_FWT);
if(error != NfcErrorNone) {
FURI_LOG_W(TAG, "nfc_poller_trx error %d", error);
//ret = iso14443_3a_poller_process_error(error);
ret = NfcCommandStop;
break;
}
@@ -482,10 +482,10 @@ bool seader_iso14443a_transmit(
bit_buffer_free(tx_buffer);
bit_buffer_free(rx_buffer);
return true;
return ret;
}
bool seader_parse_nfc_command_transmit(Seader* seader, NFCSend_t* nfcSend) {
NfcCommand seader_parse_nfc_command_transmit(Seader* seader, NFCSend_t* nfcSend) {
long timeOut = nfcSend->timeOut;
Protocol_t protocol = nfcSend->protocol;
FrameProtocol_t frameProtocol = protocol.buf[1];
@@ -517,11 +517,11 @@ bool seader_parse_nfc_command_transmit(Seader* seader, NFCSend_t* nfcSend) {
return seader_iso14443a_transmit(
seader, nfcSend->data.buf, nfcSend->data.size, (uint16_t)timeOut, nfcSend->format->buf);
}
return false;
return NfcCommandContinue;
}
NfcCommand seader_parse_nfc_off(SeaderUartBridge* seader_uart) {
FURI_LOG_D(TAG, "Set Field Off");
// FURI_LOG_D(TAG, "Set Field Off");
// seader_worker_disable_field();
// seader_nfc_scene_field_on_exit();
// nfc_poller_stop(poller);
@@ -548,15 +548,14 @@ NfcCommand seader_parse_nfc_off(SeaderUartBridge* seader_uart) {
return NfcCommandStop;
}
bool seader_parse_nfc_command(Seader* seader, NFCCommand_t* nfcCommand) {
NfcCommand seader_parse_nfc_command(Seader* seader, NFCCommand_t* nfcCommand) {
// TODO: THIS IS WHERE I WANT TO PUSH EVENTS TO MESSAGE QUEUE
SeaderWorker* seader_worker = seader->worker;
SeaderUartBridge* seader_uart = seader_worker->uart;
switch(nfcCommand->present) {
case NFCCommand_PR_nfcSend:
//seader_parse_nfc_command_transmit(seader, &nfcCommand->choice.nfcSend);
break;
return seader_parse_nfc_command_transmit(seader, &nfcCommand->choice.nfcSend);
case NFCCommand_PR_nfcOff:
seader_parse_nfc_off(seader_uart);
break;
@@ -565,7 +564,7 @@ bool seader_parse_nfc_command(Seader* seader, NFCCommand_t* nfcCommand) {
break;
};
return false;
return NfcCommandContinue;
}
bool seader_worker_state_machine(Seader* seader, Payload_t* payload) {
@@ -610,6 +609,8 @@ bool seader_process_success_response_i(Seader* seader, uint8_t* apdu, size_t len
}
#endif
seader_worker_state_machine(seader, payload);
} else {
FURI_LOG_D(TAG, "Failed to decode APDU payload");
}
ASN_STRUCT_FREE(asn_DEF_Payload, payload);
@@ -627,8 +628,11 @@ bool seader_process_success_response(Seader* seader, uint8_t* apdu, size_t len)
BitBuffer* buffer = bit_buffer_alloc(SEADER_POLLER_MAX_BUFFER_SIZE);
bit_buffer_append_bytes(buffer, apdu, len);
furi_message_queue_put(seader_worker->messages, buffer, SEADER_MQ_TIMEOUT);
bit_buffer_free(buffer);
if (furi_mutex_acquire(seader_worker->mq_mutex, FuriWaitForever) == FuriStatusOk) {
furi_message_queue_put(seader_worker->messages, buffer, FuriWaitForever);
furi_mutex_release(seader_worker->mq_mutex);
}
//bit_buffer_free(buffer);
}
} else {
seader_process_success_response_i(seader, apdu, len);
@@ -683,13 +687,13 @@ int32_t seader_worker_task(void* context) {
if(seader_worker->state == SeaderWorkerStateCheckSam) {
seader_ccid_check_for_sam(seader_uart);
} else if(seader_worker->state == SeaderWorkerStateReadPicopass) {
FURI_LOG_D(TAG, "Read Picopass");
// FURI_LOG_D(TAG, "Read Picopass");
requestPacs = true;
seader_credential_clear(seader_worker->credential);
seader_worker->credential->type = SeaderCredentialTypePicopass;
// TODO
} else if(seader_worker->state == SeaderWorkerStateRead14a) {
FURI_LOG_D(TAG, "Read 14a");
// FURI_LOG_D(TAG, "Read 14a");
requestPacs = true;
seader_credential_clear(seader_worker->credential);
seader_worker->credential->type = SeaderCredentialType14A;
@@ -699,7 +703,7 @@ int32_t seader_worker_task(void* context) {
// seader_nfc_scene_field_on_exit();
}
}
FURI_LOG_D(TAG, "Worker Task Complete");
// FURI_LOG_D(TAG, "Worker Task Complete");
seader_worker_change_state(seader_worker, SeaderWorkerStateReady);
return 0;
@@ -727,7 +731,7 @@ NfcCommand seader_worker_poller_callback_iso14443_4a(NfcGenericEvent event, void
if(iso14443_4a_event->type == Iso14443_4aPollerEventTypeReady) {
if(stage == SeaderPollerEventTypeCardDetect) {
FURI_LOG_D(TAG, "Card Detect");
// FURI_LOG_D(TAG, "Card Detect");
nfc_device_set_data(
seader->nfc_device, NfcProtocolIso14443_4a, nfc_poller_get_data(seader->poller));
@@ -761,17 +765,18 @@ NfcCommand seader_worker_poller_callback_iso14443_4a(NfcGenericEvent event, void
stage = SeaderPollerEventTypeConversation;
} else if(stage == SeaderPollerEventTypeConversation) {
UNUSED(seader_worker);
if (furi_mutex_acquire(seader_worker->mq_mutex, 0) == FuriStatusOk) {
furi_thread_set_current_priority(FuriThreadPriorityHighest);
uint32_t count = furi_message_queue_get_count(seader_worker->messages);
if(count > 0) {
furi_thread_set_current_priority(FuriThreadPriorityHighest);
FURI_LOG_D(TAG, "Conversation: %ld messages", count);
BitBuffer* message = bit_buffer_alloc(furi_message_queue_get_message_size(seader_worker->messages));
FuriStatus status =
furi_message_queue_get(seader_worker->messages, message, SEADER_MQ_TIMEOUT);
furi_message_queue_get(seader_worker->messages, message, FuriWaitForever);
if(status != FuriStatusOk) {
FURI_LOG_D(TAG, "furi_message_queue_get fail %d", status);
FURI_LOG_W(TAG, "furi_message_queue_get fail %d", status);
return NfcCommandStop;
}
size_t len = bit_buffer_get_size_bytes(message);
@@ -779,17 +784,17 @@ NfcCommand seader_worker_poller_callback_iso14443_4a(NfcGenericEvent event, void
FURI_LOG_D(TAG, "Conversation: message length %d: %p", len, payload);
seader_process_success_response_i(seader, payload, len);
bit_buffer_free(message);
//bit_buffer_free(message);
}
furi_thread_set_current_priority(FuriThreadPriorityLowest);
furi_mutex_release(seader_worker->mq_mutex);
}
furi_thread_set_current_priority(FuriThreadPriorityLowest);
// TESTING
//return NfcCommandStop;
//stage = SeaderPollerEventTypeComplete;
} else if(stage == SeaderPollerEventTypeComplete) {
FURI_LOG_D(TAG, "Complete");
// FURI_LOG_D(TAG, "Complete");
return NfcCommandStop;
}
}
seader_worker_i.h
+1 -1
View File
@@ -15,13 +15,13 @@
#define SEADER_POLLER_MAX_FWT (200000U)
#define SEADER_POLLER_MAX_BUFFER_SIZE (64U)
#define SEADER_MQ_TIMEOUT FuriWaitForever
struct SeaderWorker {
FuriThread* thread;
Storage* storage;
uint8_t sam_version[2];
FuriMessageQueue* messages;
FuriMutex* mq_mutex;
SeaderUartBridge* uart;
SeaderCredential* credential;