liz/flipperzero-firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[FL-1447] NFC application refactoring (#532)

Browse Source 
* nfc: add separate nfc_detect
* nfc_worker: add callback and context
* api-hal-nfc: return busy if rfal worker is running
* nfc: introduce nfc_detect, change nfc_worker API, rework main nfc task
* nfc_emulate: introduce nfc_emulate module
* nfc: introduce nfc_emv module
* nfc: introduce nfc_mifare_ul module
* nfc: remove unused nfc_views
* nfc: separate messages and models
* nfc: remove unused nfc message types
* nfc: remove message_queue from common api
* view_dispatcher: delete internal queue in destructor
* api-hal-nfc: fix rfal worker initialization condition

Co-authored-by: あく <alleteam@gmail.com>
This commit is contained in:
gornekich
2021-06-24 11:46:37 +03:00
committed by GitHub
parent 4cf000f270
commit 5b8f147882
19 changed files with 902 additions and 664 deletions
Download Patch File Download Diff File Expand all files Collapse all files

187
applications/nfc/nfc_worker.c
View File

@@ -5,12 +5,16 @@
#define NFC_WORKER_TAG "nfc worker"
/***************************** NFC Worker API *******************************/
NfcWorker* nfc_worker_alloc(osMessageQueueId_t message_queue) {
NfcWorker* nfc_worker = furi_alloc(sizeof(NfcWorker));
nfc_worker->message_queue = message_queue;
// Worker thread attributes
nfc_worker->thread_attr.name = "nfc_worker";
nfc_worker->thread_attr.stack_size = 8192;
nfc_worker->callback = NULL;
nfc_worker->context = NULL;
// Initialize rfal
nfc_worker->error = api_hal_nfc_init();
if(nfc_worker->error == ERR_NONE) {
@@ -36,9 +40,16 @@ ReturnCode nfc_worker_get_error(NfcWorker* nfc_worker) {
return nfc_worker->error;
}
void nfc_worker_start(NfcWorker* nfc_worker, NfcWorkerState state) {
void nfc_worker_start(
NfcWorker* nfc_worker,
NfcWorkerState state,
NfcWorkerCallback callback,
void* context) {
furi_assert(nfc_worker);
furi_assert(nfc_worker->state == NfcWorkerStateReady);
nfc_worker->callback = callback;
nfc_worker->context = context;
nfc_worker_change_state(nfc_worker, state);
nfc_worker->thread = osThreadNew(nfc_worker_task, nfc_worker, &nfc_worker->thread_attr);
}
@@ -56,24 +67,26 @@ void nfc_worker_change_state(NfcWorker* nfc_worker, NfcWorkerState state) {
nfc_worker->state = state;
}
/***************************** NFC Worker Thread *******************************/
void nfc_worker_task(void* context) {
NfcWorker* nfc_worker = context;
api_hal_power_insomnia_enter();
api_hal_nfc_exit_sleep();
if(nfc_worker->state == NfcWorkerStatePoll) {
nfc_worker_poll(nfc_worker);
if(nfc_worker->state == NfcWorkerStateDetect) {
nfc_worker_detect(nfc_worker);
} else if(nfc_worker->state == NfcWorkerStateEmulate) {
nfc_worker_emulate(nfc_worker);
} else if(nfc_worker->state == NfcWorkerStateReadEMV) {
nfc_worker_read_emv(nfc_worker);
} else if(nfc_worker->state == NfcWorkerStateEmulateEMV) {
nfc_worker_emulate_emv(nfc_worker);
} else if(nfc_worker->state == NfcWorkerStateEmulate) {
nfc_worker_emulate(nfc_worker);
} else if(nfc_worker->state == NfcWorkerStateField) {
nfc_worker_field(nfc_worker);
} else if(nfc_worker->state == NfcWorkerStateReadMfUltralight) {
nfc_worker_read_mf_ultralight(nfc_worker);
nfc_worker_emulate_emv(nfc_worker);
} else if(nfc_worker->state == NfcWorkerStateField) {
}
api_hal_nfc_deactivate();
nfc_worker_change_state(nfc_worker, NfcWorkerStateReady);
@@ -81,6 +94,55 @@ void nfc_worker_task(void* context) {
osThreadExit();
}
void nfc_worker_detect(NfcWorker* nfc_worker) {
rfalNfcDevice* dev_list;
rfalNfcDevice* dev;
uint8_t dev_cnt;
NfcMessage message;
while(nfc_worker->state == NfcWorkerStateDetect) {
message.found = false;
if(api_hal_nfc_detect(&dev_list, &dev_cnt, 1000, true)) {
// Process first found device
dev = &dev_list[0];
message.found = true;
message.nfc_detect_data.uid_len = dev->nfcidLen;
memcpy(message.nfc_detect_data.uid, dev->nfcid, dev->nfcidLen);
if(dev->type == RFAL_NFC_LISTEN_TYPE_NFCA) {
message.nfc_detect_data.device = NfcDeviceNfca;
message.nfc_detect_data.atqa[0] = dev->dev.nfca.sensRes.anticollisionInfo;
message.nfc_detect_data.atqa[1] = dev->dev.nfca.sensRes.platformInfo;
message.nfc_detect_data.sak = dev->dev.nfca.selRes.sak;
// TODO check protocols
} else if(dev->type == RFAL_NFC_LISTEN_TYPE_NFCB) {
message.nfc_detect_data.device = NfcDeviceNfcb;
} else if(dev->type == RFAL_NFC_LISTEN_TYPE_NFCF) {
message.nfc_detect_data.device = NfcDeviceNfcf;
} else if(dev->type == RFAL_NFC_LISTEN_TYPE_NFCV) {
message.nfc_detect_data.device = NfcDeviceNfcv;
}
}
if(nfc_worker->callback) {
nfc_worker->callback(nfc_worker->context);
}
furi_check(
osMessageQueuePut(nfc_worker->message_queue, &message, 0, osWaitForever) == osOK);
osDelay(100);
}
}
void nfc_worker_emulate(NfcWorker* nfc_worker) {
while(nfc_worker->state == NfcWorkerStateEmulate) {
if(api_hal_nfc_listen(ApiHalNfcEmulateParamsMifare, 100)) {
FURI_LOG_I(NFC_WORKER_TAG, "Reader detected");
api_hal_nfc_deactivate();
}
osDelay(10);
}
}
void nfc_worker_read_emv(NfcWorker* nfc_worker) {
ReturnCode err;
rfalNfcDevice* dev_list;
@@ -91,9 +153,11 @@ void nfc_worker_read_emv(NfcWorker* nfc_worker) {
uint8_t* rx_buff;
uint16_t* rx_len;
// Update screen before start searching
NfcMessage message = {.type = NfcMessageTypeEMVNotFound};
NfcMessage message = {.found = false};
while(nfc_worker->state == NfcWorkerStateReadEMV) {
if(nfc_worker->callback) {
nfc_worker->callback(nfc_worker->context);
}
furi_check(
osMessageQueuePut(nfc_worker->message_queue, &message, 0, osWaitForever) == osOK);
memset(&emv_app, 0, sizeof(emv_app));
@@ -105,7 +169,7 @@ void nfc_worker_read_emv(NfcWorker* nfc_worker) {
err = api_hal_nfc_data_exchange(tx_buff, tx_len, &rx_buff, &rx_len, false);
if(err != ERR_NONE) {
FURI_LOG_E(NFC_WORKER_TAG, "Error during selection PPSE request: %d", err);
message.type = NfcMessageTypeEMVNotFound;
message.found = false;
api_hal_nfc_deactivate();
continue;
}
@@ -115,7 +179,7 @@ void nfc_worker_read_emv(NfcWorker* nfc_worker) {
FURI_LOG_I(NFC_WORKER_TAG, "Select PPSE responce parced");
} else {
FURI_LOG_E(NFC_WORKER_TAG, "Can't find pay application");
message.type = NfcMessageTypeEMVNotFound;
message.found = false;
api_hal_nfc_deactivate();
continue;
}
@@ -125,7 +189,7 @@ void nfc_worker_read_emv(NfcWorker* nfc_worker) {
if(err != ERR_NONE) {
FURI_LOG_E(
NFC_WORKER_TAG, "Error during application selection request: %d", err);
message.type = NfcMessageTypeEMVNotFound;
message.found = false;
api_hal_nfc_deactivate();
continue;
}
@@ -134,10 +198,10 @@ void nfc_worker_read_emv(NfcWorker* nfc_worker) {
"Select application response received. Start parsing response");
if(emv_decode_select_app_response(rx_buff, *rx_len, &emv_app)) {
FURI_LOG_I(NFC_WORKER_TAG, "Card name: %s", emv_app.name);
memcpy(message.device.emv_card.name, emv_app.name, sizeof(emv_app.name));
memcpy(message.nfc_emv_data.name, emv_app.name, sizeof(emv_app.name));
} else {
FURI_LOG_E(NFC_WORKER_TAG, "Can't read card name");
message.type = NfcMessageTypeEMVNotFound;
message.found = false;
api_hal_nfc_deactivate();
continue;
}
@@ -147,15 +211,15 @@ void nfc_worker_read_emv(NfcWorker* nfc_worker) {
if(err != ERR_NONE) {
FURI_LOG_E(
NFC_WORKER_TAG, "Error during Get Processing Options command: %d", err);
message.type = NfcMessageTypeEMVNotFound;
message.found = false;
api_hal_nfc_deactivate();
continue;
}
if(emv_decode_get_proc_opt(rx_buff, *rx_len, &emv_app)) {
FURI_LOG_I(NFC_WORKER_TAG, "Card number parsed");
message.type = NfcMessageTypeEMVFound;
message.found = true;
memcpy(
message.device.emv_card.number,
message.nfc_emv_data.number,
emv_app.card_number,
sizeof(emv_app.card_number));
api_hal_nfc_deactivate();
@@ -189,27 +253,27 @@ void nfc_worker_read_emv(NfcWorker* nfc_worker) {
}
if(pan_found) {
FURI_LOG_I(NFC_WORKER_TAG, "Card PAN found");
message.type = NfcMessageTypeEMVFound;
message.found = true;
memcpy(
message.device.emv_card.number,
message.nfc_emv_data.number,
emv_app.card_number,
sizeof(emv_app.card_number));
} else {
FURI_LOG_E(NFC_WORKER_TAG, "Can't read card number");
message.type = NfcMessageTypeEMVNotFound;
message.found = false;
}
api_hal_nfc_deactivate();
}
} else {
// Can't find EMV card
FURI_LOG_W(NFC_WORKER_TAG, "Card doesn't support EMV");
message.type = NfcMessageTypeEMVNotFound;
message.found = false;
api_hal_nfc_deactivate();
}
} else {
// Can't find EMV card
FURI_LOG_W(NFC_WORKER_TAG, "Can't find any cards");
message.type = NfcMessageTypeEMVNotFound;
message.found = false;
api_hal_nfc_deactivate();
}
osDelay(20);
@@ -271,44 +335,6 @@ void nfc_worker_emulate_emv(NfcWorker* nfc_worker) {
}
}
void nfc_worker_poll(NfcWorker* nfc_worker) {
rfalNfcDevice* dev_list;
uint8_t dev_cnt;
// Update screen before start searching
NfcMessage message = {.type = NfcMessageTypeDeviceNotFound};
furi_check(osMessageQueuePut(nfc_worker->message_queue, &message, 0, osWaitForever) == osOK);
while(nfc_worker->state == NfcWorkerStatePoll) {
if(api_hal_nfc_detect(&dev_list, &dev_cnt, 1000, true)) {
// Send message with first device found
message.type = NfcMessageTypeDeviceFound;
if(dev_list[0].type == RFAL_NFC_LISTEN_TYPE_NFCA) {
message.device.type = NfcDeviceTypeNfca;
message.device.nfca = dev_list[0].dev.nfca;
} else if(dev_list[0].type == RFAL_NFC_LISTEN_TYPE_NFCB) {
message.device.type = NfcDeviceTypeNfcb;
message.device.nfcb = dev_list[0].dev.nfcb;
} else if(dev_list[0].type == RFAL_NFC_LISTEN_TYPE_NFCF) {
message.device.type = NfcDeviceTypeNfcf;
message.device.nfcf = dev_list[0].dev.nfcf;
} else if(dev_list[0].type == RFAL_NFC_LISTEN_TYPE_NFCV) {
message.device.type = NfcDeviceTypeNfcv;
message.device.nfcv = dev_list[0].dev.nfcv;
} else {
// TODO show information about all found devices
message.type = NfcMessageTypeDeviceNotFound;
}
furi_check(
osMessageQueuePut(nfc_worker->message_queue, &message, 0, osWaitForever) == osOK);
} else {
message.type = NfcMessageTypeDeviceNotFound;
furi_check(
osMessageQueuePut(nfc_worker->message_queue, &message, 0, osWaitForever) == osOK);
}
osDelay(5);
}
}
void nfc_worker_read_mf_ultralight(NfcWorker* nfc_worker) {
ReturnCode err;
rfalNfcDevice* dev_list;
@@ -320,8 +346,11 @@ void nfc_worker_read_mf_ultralight(NfcWorker* nfc_worker) {
MfUltralightRead mf_ul_read;
// Update screen before start searching
NfcMessage message = {.type = NfcMessageTypeMfUlNotFound};
NfcMessage message = {.found = false};
while(nfc_worker->state == NfcWorkerStateReadMfUltralight) {
if(nfc_worker->callback) {
nfc_worker->callback(nfc_worker->context);
}
furi_check(
osMessageQueuePut(nfc_worker->message_queue, &message, 0, osWaitForever) == osOK);
api_hal_nfc_deactivate();
@@ -354,7 +383,7 @@ void nfc_worker_read_mf_ultralight(NfcWorker* nfc_worker) {
api_hal_nfc_deactivate();
if(!api_hal_nfc_detect(&dev_list, &dev_cnt, 1000, false)) {
FURI_LOG_E(NFC_WORKER_TAG, "Lost connection. Restarting search");
message.type = NfcMessageTypeMfUlNotFound;
message.found = false;
continue;
}
} else {
@@ -362,7 +391,7 @@ void nfc_worker_read_mf_ultralight(NfcWorker* nfc_worker) {
NFC_WORKER_TAG,
"Error getting Mifare Ultralight version. Error code: %d",
err);
message.type = NfcMessageTypeMfUlNotFound;
message.found = false;
continue;
}
@@ -382,7 +411,7 @@ void nfc_worker_read_mf_ultralight(NfcWorker* nfc_worker) {
mf_ul_read.pages_readed = mf_ul_read.pages_to_read;
} else {
FURI_LOG_E(NFC_WORKER_TAG, "Fast read failed");
message.type = NfcMessageTypeMfUlNotFound;
message.found = false;
continue;
}
} else {
@@ -403,13 +432,19 @@ void nfc_worker_read_mf_ultralight(NfcWorker* nfc_worker) {
}
// Fill message for nfc application
message.type = NfcMessageTypeMfUlFound;
message.found = true;
message.nfc_mifare_ul_data.nfc_data.uid_len = dev_list[0].dev.nfca.nfcId1Len;
message.nfc_mifare_ul_data.nfc_data.atqa[0] =
dev_list[0].dev.nfca.sensRes.anticollisionInfo;
message.nfc_mifare_ul_data.nfc_data.atqa[1] =
dev_list[0].dev.nfca.sensRes.platformInfo;
message.nfc_mifare_ul_data.nfc_data.sak = dev_list[0].dev.nfca.selRes.sak;
memcpy(
message.device.mf_ul_card.uid,
message.nfc_mifare_ul_data.nfc_data.uid,
dev_list[0].dev.nfca.nfcId1,
sizeof(message.device.mf_ul_card.uid));
memcpy(message.device.mf_ul_card.man_block, mf_ul_read.dump, 4 * 3);
memcpy(message.device.mf_ul_card.otp, &mf_ul_read.dump[4 * 3], 4);
message.nfc_mifare_ul_data.nfc_data.uid_len);
memcpy(message.nfc_mifare_ul_data.man_block, mf_ul_read.dump, 4 * 3);
memcpy(message.nfc_mifare_ul_data.otp, &mf_ul_read.dump[4 * 3], 4);
for(uint8_t i = 0; i < mf_ul_read.pages_readed * 4; i += 4) {
printf("Page %2d: ", i / 4);
for(uint8_t j = 0; j < 4; j++) {
@@ -418,27 +453,17 @@ void nfc_worker_read_mf_ultralight(NfcWorker* nfc_worker) {
printf("\r\n");
}
} else {
message.type = NfcMessageTypeMfUlNotFound;
message.found = false;
FURI_LOG_W(NFC_WORKER_TAG, "Tag does not support Mifare Ultralight");
}
} else {
message.type = NfcMessageTypeMfUlNotFound;
message.found = false;
FURI_LOG_W(NFC_WORKER_TAG, "Can't find any tags");
}
osDelay(100);
}
}
void nfc_worker_emulate(NfcWorker* nfc_worker) {
while(nfc_worker->state == NfcWorkerStateEmulate) {
if(api_hal_nfc_listen(ApiHalNfcEmulateParamsMifare, 100)) {
FURI_LOG_I(NFC_WORKER_TAG, "Reader detected");
api_hal_nfc_deactivate();
}
osDelay(5);
}
}
void nfc_worker_field(NfcWorker* nfc_worker) {
api_hal_nfc_field_on();
while(nfc_worker->state == NfcWorkerStateField) {