mirrors/flipperzero-firmware
1
Fork 0
mirror of https://github.com/flipperdevices/flipperzero-firmware.git synced 2025-12-12 04:41:26 +04:00
Code Issues Activity

NFC FeliCa Improvement: Dump All Systems (#4293)

Browse Source 
* polling system code done

* select service done

* select system fixes. works fine now

* clean up select sys by idx

* reading, saving, loading done. render wrong

* render first layer works

* render fixed

* fix Lite Render triage

* regression Lite rendering

* sync API with 1.40 release

* clean up and lint

---------

Co-authored-by: hedger <hedger@users.noreply.github.com>
This commit is contained in:
Zinong Li
2025-11-06 22:30:02 +04:00
committed by GitHub
parent b54d63037b
commit 6c83a67173
14 changed files with 557 additions and 316 deletions
Download Patch File Download Diff File Expand all files Collapse all files

419
lib/nfc/protocols/felica/felica.c
View File

@@ -42,26 +42,16 @@ FelicaData* felica_alloc(void) {
FelicaData* data = malloc(sizeof(FelicaData));
furi_check(data);
data->services = simple_array_alloc(&felica_service_array_cfg);
data->areas = simple_array_alloc(&felica_area_array_cfg);
data->public_blocks = simple_array_alloc(&felica_public_block_array_cfg);
furi_check(data->services);
furi_check(data->areas);
furi_check(data->public_blocks);
data->systems = simple_array_alloc(&felica_system_array_cfg);
furi_check(data->systems);
return data;
}
void felica_free(FelicaData* data) {
furi_check(data);
furi_check(data->services);
simple_array_free(data->services);
furi_check(data->areas);
simple_array_free(data->areas);
furi_check(data->public_blocks);
simple_array_free(data->public_blocks);
furi_check(data->systems);
simple_array_free(data->systems);
free(data);
}
@@ -69,16 +59,8 @@ void felica_free(FelicaData* data) {
void felica_reset(FelicaData* data) {
furi_check(data);
if(data->services) {
simple_array_reset(data->services);
}
if(data->areas) {
simple_array_reset(data->areas);
}
if(data->public_blocks) {
simple_array_reset(data->public_blocks);
if(data->systems) {
simple_array_reset(data->systems);
}
data->blocks_read = 0;
@@ -102,9 +84,7 @@ void felica_copy(FelicaData* data, const FelicaData* other) {
data->data = other->data;
data->workflow_type = other->workflow_type;
simple_array_copy(data->services, other->services);
simple_array_copy(data->areas, other->areas);
simple_array_copy(data->public_blocks, other->public_blocks);
simple_array_copy(data->systems, other->systems);
}
bool felica_verify(FelicaData* data, const FuriString* device_type) {
@@ -175,99 +155,125 @@ bool felica_load(FelicaData* data, FlipperFormat* ff, uint32_t version) {
} while(false);
break;
case FelicaStandard:
// Areas
do {
uint32_t area_count = 0;
if(!flipper_format_read_uint32(ff, "Area found", &area_count, 1)) break;
simple_array_init(data->areas, area_count);
uint32_t systems_total = 0;
if(!flipper_format_read_uint32(ff, "System found", &systems_total, 1)) break;
simple_array_init(data->systems, systems_total);
for(uint8_t sys_idx = 0; sys_idx < systems_total; sys_idx++) {
FelicaSystem* system = simple_array_get(data->systems, sys_idx);
uint16_t system_code = 0;
furi_string_reset(str_key_buffer);
furi_string_reset(str_data_buffer);
for(uint16_t i = 0; i < area_count; i++) {
furi_string_printf(str_key_buffer, "Area %03X", i);
if(!flipper_format_read_string(
ff, furi_string_get_cstr(str_key_buffer), str_data_buffer)) {
break;
}
FelicaArea* area = simple_array_get(data->areas, i);
if(sscanf(
furi_string_get_cstr(str_data_buffer),
"| Code %04hX | Services #%03hX-#%03hX |",
&area->code,
&area->first_idx,
&area->last_idx) != 3) {
break;
}
}
} while(false);
// Services
do {
uint32_t service_count = 0;
if(!flipper_format_read_uint32(ff, "Service found", &service_count, 1)) break;
simple_array_init(data->services, service_count);
furi_string_reset(str_key_buffer);
furi_string_reset(str_data_buffer);
for(uint16_t i = 0; i < service_count; i++) {
furi_string_printf(str_key_buffer, "Service %03X", i);
if(!flipper_format_read_string(
ff, furi_string_get_cstr(str_key_buffer), str_data_buffer)) {
break;
}
FelicaService* service = simple_array_get(data->services, i);
// all unread in the beginning. reserved for future block load
if(!sscanf(
furi_string_get_cstr(str_data_buffer), "| Code %04hX |", &service->code)) {
break;
}
service->attr = service->code & 0x3F;
}
} while(false);
// Public blocks
do {
furi_string_reset(str_data_buffer);
furi_string_reset(str_key_buffer);
uint32_t public_block_count = 0;
if(!flipper_format_read_uint32(ff, "Public blocks read", &public_block_count, 1))
furi_string_printf(str_key_buffer, "System %02X", sys_idx);
if(!flipper_format_read_string(
ff, furi_string_get_cstr(str_key_buffer), str_data_buffer))
break;
simple_array_init(data->public_blocks, public_block_count);
for(uint16_t i = 0; i < public_block_count; i++) {
furi_string_printf(str_key_buffer, "Block %04X", i);
if(!flipper_format_read_string(
ff, furi_string_get_cstr(str_key_buffer), str_data_buffer)) {
break;
}
FelicaPublicBlock* public_block = simple_array_get(data->public_blocks, i);
if(sscanf(
furi_string_get_cstr(str_data_buffer),
"| Service code %04hX | Block index %02hhX |",
&public_block->service_code,
&public_block->block_idx) != 2) {
break;
}
size_t needle = furi_string_search_str(str_data_buffer, "Data: ");
if(needle == FURI_STRING_FAILURE) {
break;
}
needle += 6; // length of "Data: " = 6
furi_string_mid(str_data_buffer, needle, 3 * FELICA_DATA_BLOCK_SIZE);
furi_string_replace_all(str_data_buffer, " ", "");
if(!hex_chars_to_uint8(
furi_string_get_cstr(str_data_buffer), public_block->block.data)) {
break;
}
furi_string_reset(str_data_buffer);
for(size_t j = 0; j < FELICA_DATA_BLOCK_SIZE; j++) {
furi_string_cat_printf(str_data_buffer, "%02X ", public_block->block.data[j]);
}
if(!sscanf(furi_string_get_cstr(str_data_buffer), "%04hX", &system_code)) {
break;
}
} while(false);
system->system_code = system_code;
system->system_code_idx = sys_idx;
// Areas
do {
uint32_t area_count = 0;
if(!flipper_format_read_uint32(ff, "Area found", &area_count, 1)) break;
simple_array_init(system->areas, area_count);
furi_string_reset(str_key_buffer);
furi_string_reset(str_data_buffer);
for(uint16_t i = 0; i < area_count; i++) {
furi_string_printf(str_key_buffer, "Area %03X", i);
if(!flipper_format_read_string(
ff, furi_string_get_cstr(str_key_buffer), str_data_buffer)) {
break;
}
FelicaArea* area = simple_array_get(system->areas, i);
if(sscanf(
furi_string_get_cstr(str_data_buffer),
"| Code %04hX | Services #%03hX-#%03hX |",
&area->code,
&area->first_idx,
&area->last_idx) != 3) {
break;
}
}
} while(false);
// Services
do {
uint32_t service_count = 0;
if(!flipper_format_read_uint32(ff, "Service found", &service_count, 1)) break;
simple_array_init(system->services, service_count);
furi_string_reset(str_key_buffer);
furi_string_reset(str_data_buffer);
for(uint16_t i = 0; i < service_count; i++) {
furi_string_printf(str_key_buffer, "Service %03X", i);
if(!flipper_format_read_string(
ff, furi_string_get_cstr(str_key_buffer), str_data_buffer)) {
break;
}
FelicaService* service = simple_array_get(system->services, i);
// all unread in the beginning. reserved for future block load
if(!sscanf(
furi_string_get_cstr(str_data_buffer),
"| Code %04hX |",
&service->code)) {
break;
}
service->attr = service->code & 0x3F;
}
} while(false);
// Public blocks
do {
furi_string_reset(str_data_buffer);
furi_string_reset(str_key_buffer);
uint32_t public_block_count = 0;
if(!flipper_format_read_uint32(ff, "Public blocks read", &public_block_count, 1))
break;
simple_array_init(system->public_blocks, public_block_count);
for(uint16_t i = 0; i < public_block_count; i++) {
furi_string_printf(str_key_buffer, "Block %04X", i);
if(!flipper_format_read_string(
ff, furi_string_get_cstr(str_key_buffer), str_data_buffer)) {
break;
}
FelicaPublicBlock* public_block = simple_array_get(system->public_blocks, i);
if(sscanf(
furi_string_get_cstr(str_data_buffer),
"| Service code %04hX | Block index %02hhX |",
&public_block->service_code,
&public_block->block_idx) != 2) {
break;
}
size_t needle = furi_string_search_str(str_data_buffer, "Data: ");
if(needle == FURI_STRING_FAILURE) {
break;
}
needle += 6; // length of "Data: " = 6
furi_string_mid(str_data_buffer, needle, 3 * FELICA_DATA_BLOCK_SIZE);
furi_string_replace_all(str_data_buffer, " ", "");
if(!hex_chars_to_uint8(
furi_string_get_cstr(str_data_buffer), public_block->block.data)) {
break;
}
furi_string_reset(str_data_buffer);
for(size_t j = 0; j < FELICA_DATA_BLOCK_SIZE; j++) {
furi_string_cat_printf(
str_data_buffer, "%02X ", public_block->block.data[j]);
}
}
} while(false);
}
break;
default:
break;
@@ -334,88 +340,107 @@ bool felica_save(const FelicaData* data, FlipperFormat* ff) {
case FelicaStandard:
if(!flipper_format_write_comment_cstr(ff, "Felica Standard specific data")) break;
uint32_t systems_count = simple_array_get_count(data->systems);
if(!flipper_format_write_uint32(ff, "System found", &systems_count, 1)) break;
for(uint32_t sys_idx = 0; sys_idx < systems_count; sys_idx++) {
FelicaSystem* system = simple_array_get(data->systems, sys_idx);
do {
uint32_t area_count = simple_array_get_count(data->areas);
uint32_t service_count = simple_array_get_count(data->services);
// Note: The theoretical max area/service count is 2^10
// So uint16_t is already enough for practical usage
// The following key index print will use %03X because 12 bits are enough to cover 0-1023
// Area count
if(!flipper_format_write_uint32(ff, "Area found", &area_count, 1)) break;
// Area data
furi_string_reset(str_data_buffer);
furi_string_reset(str_key_buffer);
for(uint16_t i = 0; i < area_count; i++) {
FelicaArea* area = simple_array_get(data->areas, i);
furi_string_printf(str_key_buffer, "Area %03X", i);
furi_string_printf(
str_data_buffer,
"| Code %04X | Services #%03X-#%03X |",
area->code,
area->first_idx,
area->last_idx);
if(!flipper_format_write_string(
ff, furi_string_get_cstr(str_key_buffer), str_data_buffer))
break;
}
if(!flipper_format_write_empty_line(ff)) break;
// Service count
if(!flipper_format_write_uint32(ff, "Service found", &service_count, 1)) break;
// Service data
furi_string_reset(str_data_buffer);
furi_string_reset(str_key_buffer);
for(uint16_t i = 0; i < service_count; i++) {
FelicaService* service = simple_array_get(data->services, i);
furi_string_printf(str_key_buffer, "Service %03X", i);
furi_string_printf(
str_data_buffer, "| Code %04X | Attrib. %02X ", service->code, service->attr);
felica_service_get_attribute_string(service, str_data_buffer);
if(!flipper_format_write_string(
ff, furi_string_get_cstr(str_key_buffer), str_data_buffer))
break;
}
if(!flipper_format_write_empty_line(ff)) break;
// Directory tree
furi_string_reset(str_data_buffer);
furi_string_reset(str_key_buffer);
furi_string_printf(
str_data_buffer, "\n::: ... are public services\n||| ... are private services");
felica_write_directory_tree(data, str_data_buffer);
furi_string_replace_all(str_data_buffer, ":", "+");
// We use a clearer marker in saved text files
if(!flipper_format_write_string(ff, "Directory Tree", str_data_buffer)) break;
} while(false);
// Public blocks
do {
uint32_t public_block_count = simple_array_get_count(data->public_blocks);
if(!flipper_format_write_uint32(ff, "Public blocks read", &public_block_count, 1))
furi_string_printf(str_key_buffer, "\n\nSystem %02X", (uint8_t)sys_idx);
furi_string_printf(str_data_buffer, "%04X", system->system_code);
if(!flipper_format_write_string(
ff, furi_string_get_cstr(str_key_buffer), str_data_buffer))
break;
furi_string_reset(str_data_buffer);
furi_string_reset(str_key_buffer);
for(uint16_t i = 0; i < public_block_count; i++) {
FelicaPublicBlock* public_block = simple_array_get(data->public_blocks, i);
furi_string_printf(str_key_buffer, "Block %04X", i);
if(!flipper_format_write_empty_line(ff)) break;
do {
uint32_t area_count = simple_array_get_count(system->areas);
uint32_t service_count = simple_array_get_count(system->services);
// Note: The theoretical max area/service count is 2^10
// So uint16_t is already enough for practical usage
// The following key index print will use %03X because 12 bits are enough to cover 0-1023
// Area count
if(!flipper_format_write_uint32(ff, "Area found", &area_count, 1)) break;
// Area data
furi_string_reset(str_data_buffer);
furi_string_reset(str_key_buffer);
for(uint16_t i = 0; i < area_count; i++) {
FelicaArea* area = simple_array_get(system->areas, i);
furi_string_printf(str_key_buffer, "Area %03X", i);
furi_string_printf(
str_data_buffer,
"| Code %04X | Services #%03X-#%03X |",
area->code,
area->first_idx,
area->last_idx);
if(!flipper_format_write_string(
ff, furi_string_get_cstr(str_key_buffer), str_data_buffer))
break;
}
if(!flipper_format_write_empty_line(ff)) break;
// Service count
if(!flipper_format_write_uint32(ff, "Service found", &service_count, 1)) break;
// Service data
furi_string_reset(str_data_buffer);
furi_string_reset(str_key_buffer);
for(uint16_t i = 0; i < service_count; i++) {
FelicaService* service = simple_array_get(system->services, i);
furi_string_printf(str_key_buffer, "Service %03X", i);
furi_string_printf(
str_data_buffer,
"| Code %04X | Attrib. %02X ",
service->code,
service->attr);
felica_service_get_attribute_string(service, str_data_buffer);
if(!flipper_format_write_string(
ff, furi_string_get_cstr(str_key_buffer), str_data_buffer))
break;
}
if(!flipper_format_write_empty_line(ff)) break;
// Directory tree
furi_string_reset(str_data_buffer);
furi_string_reset(str_key_buffer);
furi_string_printf(
str_data_buffer,
"| Service code %04X | Block index %02X | Data: ",
public_block->service_code,
public_block->block_idx);
for(uint8_t j = 0; j < FELICA_DATA_BLOCK_SIZE; j++) {
furi_string_cat_printf(str_data_buffer, "%02X ", public_block->block.data[j]);
}
furi_string_cat_printf(str_data_buffer, "|");
if(!flipper_format_write_string(
ff, furi_string_get_cstr(str_key_buffer), str_data_buffer))
"\n::: ... are public services\n||| ... are private services");
felica_write_directory_tree(system, str_data_buffer);
furi_string_replace_all(str_data_buffer, ":", "+");
// We use a clearer marker in saved text files
if(!flipper_format_write_string(ff, "Directory Tree", str_data_buffer)) break;
} while(false);
// Public blocks
do {
uint32_t public_block_count = simple_array_get_count(system->public_blocks);
if(!flipper_format_write_uint32(ff, "Public blocks read", &public_block_count, 1))
break;
}
} while(false);
furi_string_reset(str_data_buffer);
furi_string_reset(str_key_buffer);
for(uint16_t i = 0; i < public_block_count; i++) {
FelicaPublicBlock* public_block = simple_array_get(system->public_blocks, i);
furi_string_printf(str_key_buffer, "Block %04X", i);
furi_string_printf(
str_data_buffer,
"| Service code %04X | Block index %02X | Data: ",
public_block->service_code,
public_block->block_idx);
for(uint8_t j = 0; j < FELICA_DATA_BLOCK_SIZE; j++) {
furi_string_cat_printf(
str_data_buffer, "%02X ", public_block->block.data[j]);
}
furi_string_cat_printf(str_data_buffer, "|");
if(!flipper_format_write_string(
ff, furi_string_get_cstr(str_key_buffer), str_data_buffer))
break;
}
} while(false);
}
break;
default:
break;
@@ -436,9 +461,7 @@ bool felica_is_equal(const FelicaData* data, const FelicaData* other) {
memcmp(data->pmm.data, other->pmm.data, sizeof(FelicaPMm)) == 0 &&
data->blocks_total == other->blocks_total && data->blocks_read == other->blocks_read &&
memcmp(&data->data, &other->data, sizeof(data->data)) == 0 &&
simple_array_is_equal(data->services, other->services) &&
simple_array_is_equal(data->areas, other->areas) &&
simple_array_is_equal(data->public_blocks, other->public_blocks);
simple_array_is_equal(data->systems, other->systems);
}
const char* felica_get_device_name(const FelicaData* data, NfcDeviceNameType name_type) {
@@ -640,8 +663,8 @@ void felica_calculate_mac_write(
felica_calculate_mac(ctx, session_swapped, rc, first_block, data, FELICA_DATA_BLOCK_SIZE, mac);
}
void felica_write_directory_tree(const FelicaData* data, FuriString* str) {
furi_check(data);
void felica_write_directory_tree(const FelicaSystem* system, FuriString* str) {
furi_check(system);
furi_check(str);
furi_string_cat_str(str, "\n");
@@ -650,12 +673,12 @@ void felica_write_directory_tree(const FelicaData* data, FuriString* str) {
uint8_t depth = 0;
size_t area_iter = 0;
const size_t area_count = simple_array_get_count(data->areas);
const size_t service_count = simple_array_get_count(data->services);
const size_t area_count = simple_array_get_count(system->areas);
const size_t service_count = simple_array_get_count(system->services);
for(size_t svc_idx = 0; svc_idx < service_count; ++svc_idx) {
while(area_iter < area_count) {
const FelicaArea* next_area = simple_array_get(data->areas, area_iter);
const FelicaArea* next_area = simple_array_get(system->areas, area_iter);
if(next_area->first_idx != svc_idx) break;
for(uint8_t i = 0; i < depth - 1; ++i)
@@ -667,7 +690,7 @@ void felica_write_directory_tree(const FelicaData* data, FuriString* str) {
area_iter++;
}
const FelicaService* service = simple_array_get(data->services, svc_idx);
const FelicaService* service = simple_array_get(system->services, svc_idx);
bool is_public = (service->attr & FELICA_SERVICE_ATTRIBUTE_UNAUTH_READ) != 0;
for(uint8_t i = 0; i < depth - 1; ++i)

27
lib/nfc/protocols/felica/felica.h
View File

@@ -50,8 +50,10 @@ extern "C" {
#define FELICA_TIME_SLOT_8 (0x07U)
#define FELICA_TIME_SLOT_16 (0x0FU)
#define FELICA_CMD_LIST_SERVICE_CODE 0x0A
#define FELICA_CMD_LIST_SERVICE_CODE_RESP 0x0B
#define FELICA_CMD_LIST_SERVICE_CODE 0x0A
#define FELICA_CMD_LIST_SERVICE_CODE_RESP 0x0B
#define FELICA_CMD_REQUEST_SYSTEM_CODE 0x0C
#define FELICA_CMD_REQUEST_SYSTEM_CODE_RESP 0x0D
#define FELICA_SERVICE_ATTRIBUTE_UNAUTH_READ (0b000001)
#define FELICA_SERVICE_ATTRIBUTE_READ_ONLY (0b000010)
@@ -182,6 +184,14 @@ typedef struct {
uint8_t block_idx;
} FelicaPublicBlock;
typedef struct {
uint8_t system_code_idx;
uint16_t system_code;
SimpleArray* services;
SimpleArray* areas;
SimpleArray* public_blocks;
} FelicaSystem;
/** @brief Structure used to store Felica data and additional values about reading */
typedef struct {
FelicaIDm idm;
@@ -190,9 +200,8 @@ typedef struct {
uint8_t blocks_read;
FelicaFSUnion data;
SimpleArray* services;
SimpleArray* areas;
SimpleArray* public_blocks;
SimpleArray* systems;
FelicaWorkflowType workflow_type;
} FelicaData;
@@ -248,6 +257,12 @@ typedef struct {
uint8_t data[];
} FelicaListServiceCommandResponse;
typedef struct {
FelicaCommandHeaderRaw header;
uint8_t system_count;
uint8_t system_code[];
} FelicaListSystemCodeCommandResponse;
typedef FelicaCommandResponseHeader FelicaListenerWriteCommandResponse;
typedef FelicaCommandResponseHeader FelicaPollerWriteCommandResponse;
@@ -309,7 +324,7 @@ void felica_calculate_mac_write(
const uint8_t* data,
uint8_t* mac);
void felica_write_directory_tree(const FelicaData* data, FuriString* str);
void felica_write_directory_tree(const FelicaSystem* system, FuriString* str);
void felica_get_workflow_type(FelicaData* data);

38
lib/nfc/protocols/felica/felica_i.c
View File

@@ -1,5 +1,36 @@
#include "felica_i.h"
void felica_system_init(FelicaSystem* system) {
system->system_code = 0;
system->system_code_idx = 0;
system->services = simple_array_alloc(&felica_service_array_cfg);
system->areas = simple_array_alloc(&felica_area_array_cfg);
system->public_blocks = simple_array_alloc(&felica_public_block_array_cfg);
}
void felica_system_reset(FelicaSystem* system) {
furi_check(system);
system->system_code = 0;
system->system_code_idx = 0;
furi_check(system->services);
furi_check(system->areas);
furi_check(system->public_blocks);
simple_array_free(system->services);
simple_array_free(system->areas);
simple_array_free(system->public_blocks);
memset(system, 0, sizeof(FelicaSystem));
}
void felica_system_copy(FelicaSystem* system, const FelicaSystem* other) {
furi_check(system);
furi_check(other);
system->system_code = other->system_code;
system->system_code_idx = other->system_code_idx;
simple_array_copy(system->services, other->services);
simple_array_copy(system->areas, other->areas);
simple_array_copy(system->public_blocks, other->public_blocks);
}
const SimpleArrayConfig felica_service_array_cfg = {
.init = NULL,
.copy = NULL,
@@ -20,3 +51,10 @@ const SimpleArrayConfig felica_public_block_array_cfg = {
.reset = NULL,
.type_size = sizeof(FelicaPublicBlock),
};
const SimpleArrayConfig felica_system_array_cfg = {
.init = (SimpleArrayInit)felica_system_init,
.copy = (SimpleArrayCopy)felica_system_copy,
.reset = (SimpleArrayReset)felica_system_reset,
.type_size = sizeof(FelicaSystem),
};

5
lib/nfc/protocols/felica/felica_i.h
View File

@@ -8,3 +8,8 @@
extern const SimpleArrayConfig felica_service_array_cfg;
extern const SimpleArrayConfig felica_area_array_cfg;
extern const SimpleArrayConfig felica_public_block_array_cfg;
extern const SimpleArrayConfig felica_system_array_cfg;
void felica_system_init(FelicaSystem* system);
void felica_system_reset(FelicaSystem* system);
void felica_system_copy(FelicaSystem* system, const FelicaSystem* other);

91
lib/nfc/protocols/felica/felica_poller.c
View File

@@ -12,6 +12,7 @@
ARRAY_DEF(felica_service_array, FelicaService, M_POD_OPLIST); // -V658
ARRAY_DEF(felica_area_array, FelicaArea, M_POD_OPLIST); // -V658
ARRAY_DEF(felica_public_block_array, FelicaPublicBlock, M_POD_OPLIST); // -V658
ARRAY_DEF(felica_system_array, FelicaSystem, M_POD_OPLIST); // -V658
typedef NfcCommand (*FelicaPollerReadHandler)(FelicaPoller* instance);
@@ -43,6 +44,9 @@ static FelicaPoller* felica_poller_alloc(Nfc* nfc) {
instance->general_event.event_data = &instance->felica_event;
instance->general_event.instance = instance;
instance->systems_read = 0;
instance->systems_total = 0;
return instance;
}
@@ -94,7 +98,7 @@ NfcCommand felica_poller_state_handler_activate(FelicaPoller* instance) {
switch(instance->data->workflow_type) {
case FelicaStandard:
instance->state = FelicaPollerStateTraverseStandardSystem;
instance->state = FelicaPollerStateListSystem;
break;
case FelicaLite:
instance->state = FelicaPollerStateReadLiteBlocks;
@@ -117,6 +121,44 @@ NfcCommand felica_poller_state_handler_activate(FelicaPoller* instance) {
return command;
}
NfcCommand felica_poller_state_handler_list_system(FelicaPoller* instance) {
FURI_LOG_D(TAG, "List System");
NfcCommand command = NfcCommandContinue;
FelicaListSystemCodeCommandResponse* response_system_code;
FelicaError error = felica_poller_list_system_code(instance, &response_system_code);
instance->systems_total = response_system_code->system_count;
simple_array_init(instance->data->systems, instance->systems_total);
uint8_t* system_codes = response_system_code->system_code;
for(uint8_t i = 0; i < instance->systems_total; i++) {
FelicaSystem* system = simple_array_get(instance->data->systems, i);
system->system_code = system_codes[i * 2] << 8 | system_codes[i * 2 + 1];
system->system_code_idx = i;
}
if(error == FelicaErrorNone) {
instance->state = FelicaPollerStateSelectSystemIndex;
} else if(error != FelicaErrorTimeout) {
instance->felica_event.type = FelicaPollerEventTypeError;
instance->felica_event_data.error = error;
instance->state = FelicaPollerStateReadFailed;
}
return command;
}
NfcCommand felica_poller_state_handler_select_system_idx(FelicaPoller* instance) {
FURI_LOG_D(TAG, "Select System Index %d", instance->systems_read);
uint8_t system_index_mask = instance->systems_read << 4;
instance->data->idm.data[0] &= 0x0F;
instance->data->idm.data[0] |= system_index_mask;
instance->state = FelicaPollerStateTraverseStandardSystem;
return NfcCommandContinue;
}
NfcCommand felica_poller_state_handler_auth_internal(FelicaPoller* instance) {
FURI_LOG_D(TAG, "Auth Internal");
@@ -274,6 +316,8 @@ NfcCommand felica_poller_state_handler_traverse_standard_system(FelicaPoller* in
service->code = code_begin;
service->attr = (uint8_t)(code_begin & 0x3F);
FURI_LOG_D(TAG, "Service %04X", service->code);
if(felica_area_array_size(area_buffer)) {
FelicaArea* current_area = felica_area_array_back(area_buffer);
current_area->last_idx = (uint16_t)(felica_service_array_size(service_buffer) - 1);
@@ -284,31 +328,30 @@ NfcCommand felica_poller_state_handler_traverse_standard_system(FelicaPoller* in
const size_t service_num = felica_service_array_size(service_buffer);
const size_t area_num = felica_area_array_size(area_buffer);
FelicaSystem* system = simple_array_get(instance->data->systems, instance->systems_read);
if(service_num) {
simple_array_init(instance->data->services, (uint32_t)service_num);
simple_array_init(system->services, (uint32_t)service_num);
memcpy(
simple_array_get(instance->data->services, 0),
simple_array_get(system->services, 0),
service_buffer->ptr,
service_num * sizeof(FelicaService));
} else {
simple_array_reset(instance->data->services);
simple_array_reset(system->services);
}
if(area_num) {
simple_array_init(instance->data->areas, (uint32_t)area_num);
simple_array_init(system->areas, (uint32_t)area_num);
memcpy(
simple_array_get(instance->data->areas, 0),
area_buffer->ptr,
area_num * sizeof(FelicaArea));
simple_array_get(system->areas, 0), area_buffer->ptr, area_num * sizeof(FelicaArea));
} else {
simple_array_reset(instance->data->areas);
simple_array_reset(system->areas);
}
FURI_LOG_I(
TAG,
"Services found: %lu, Areas found: %lu",
simple_array_get_count(instance->data->services),
simple_array_get_count(instance->data->areas));
simple_array_get_count(system->services),
simple_array_get_count(system->areas));
felica_service_array_clear(service_buffer);
felica_area_array_clear(area_buffer);
@@ -320,22 +363,22 @@ NfcCommand felica_poller_state_handler_traverse_standard_system(FelicaPoller* in
NfcCommand felica_poller_state_handler_read_standard_blocks(FelicaPoller* instance) {
FURI_LOG_D(TAG, "Read Standard Blocks");
const uint32_t service_count = simple_array_get_count(instance->data->services);
FelicaSystem* system = simple_array_get(instance->data->systems, instance->systems_read);
const uint32_t service_count = simple_array_get_count(system->services);
felica_public_block_array_t public_block_buffer;
felica_public_block_array_init(public_block_buffer);
instance->state = FelicaPollerStateReadSuccess;
bool have_read_anything = false;
FelicaError error = FelicaErrorNone;
for(uint32_t i = 0; i < service_count; i++) {
const FelicaService* service = simple_array_get(instance->data->services, i);
const FelicaService* service = simple_array_get(system->services, i);
if((service->attr & FELICA_SERVICE_ATTRIBUTE_UNAUTH_READ) == 0) continue;
uint8_t block_count = 1;
uint8_t block_list[1] = {0};
FelicaError error = FelicaErrorNone;
FelicaPollerReadCommandResponse* response;
do {
error = felica_poller_read_blocks(
@@ -369,11 +412,20 @@ NfcCommand felica_poller_state_handler_read_standard_blocks(FelicaPoller* instan
}
}
if(error == FelicaErrorNone) {
instance->systems_read++;
if(instance->systems_read == instance->systems_total) {
instance->state = FelicaPollerStateReadSuccess;
} else {
instance->state = FelicaPollerStateSelectSystemIndex;
}
}
if(have_read_anything) {
const size_t n = felica_public_block_array_size(public_block_buffer);
simple_array_init(instance->data->public_blocks, (uint32_t)n);
simple_array_init(system->public_blocks, (uint32_t)n);
memcpy(
simple_array_get(instance->data->public_blocks, 0),
simple_array_get(system->public_blocks, 0),
public_block_buffer->ptr,
n * sizeof(FelicaPublicBlock));
}
@@ -446,6 +498,8 @@ NfcCommand felica_poller_state_handler_read_success(FelicaPoller* instance) {
instance->felica_event.type = FelicaPollerEventTypeReady;
}
instance->data->idm.data[0] &= 0x0F;
instance->felica_event_data.error = FelicaErrorNone;
return instance->callback(instance->general_event, instance->context);
}
@@ -453,6 +507,7 @@ NfcCommand felica_poller_state_handler_read_success(FelicaPoller* instance) {
NfcCommand felica_poller_state_handler_read_failed(FelicaPoller* instance) {
FURI_LOG_D(TAG, "Read Fail");
instance->callback(instance->general_event, instance->context);
instance->data->idm.data[0] &= 0x0F;
return NfcCommandStop;
}
@@ -460,6 +515,8 @@ NfcCommand felica_poller_state_handler_read_failed(FelicaPoller* instance) {
static const FelicaPollerReadHandler felica_poller_handler[FelicaPollerStateNum] = {
[FelicaPollerStateIdle] = felica_poller_state_handler_idle,
[FelicaPollerStateActivated] = felica_poller_state_handler_activate,
[FelicaPollerStateListSystem] = felica_poller_state_handler_list_system,
[FelicaPollerStateSelectSystemIndex] = felica_poller_state_handler_select_system_idx,
[FelicaPollerStateAuthenticateInternal] = felica_poller_state_handler_auth_internal,
[FelicaPollerStateAuthenticateExternal] = felica_poller_state_handler_auth_external,
[FelicaPollerStateTraverseStandardSystem] =

32
lib/nfc/protocols/felica/felica_poller_i.c
View File

@@ -233,7 +233,9 @@ static void felica_poller_prepare_tx_buffer_raw(
cmd.length = sizeof(FelicaCommandHeaderRaw) + data_length;
bit_buffer_reset(instance->tx_buffer);
bit_buffer_append_bytes(instance->tx_buffer, (uint8_t*)&cmd, sizeof(FelicaCommandHeaderRaw));
bit_buffer_append_bytes(instance->tx_buffer, data, data_length);
if(data_length > 0) {
bit_buffer_append_bytes(instance->tx_buffer, data, data_length);
}
}
FelicaError felica_poller_list_service_by_cursor(
@@ -264,3 +266,31 @@ FelicaError felica_poller_list_service_by_cursor(
*response_ptr = (FelicaListServiceCommandResponse*)bit_buffer_get_data(instance->rx_buffer);
return error;
}
FelicaError felica_poller_list_system_code(
FelicaPoller* instance,
FelicaListSystemCodeCommandResponse** const response_ptr) {
furi_assert(instance);
furi_assert(response_ptr);
uint8_t data[] = {0};
felica_poller_prepare_tx_buffer_raw(instance, FELICA_CMD_REQUEST_SYSTEM_CODE, data, 0);
bit_buffer_reset(instance->rx_buffer);
FelicaError error = felica_poller_frame_exchange(
instance, instance->tx_buffer, instance->rx_buffer, FELICA_POLLER_POLLING_FWT);
if(error != FelicaErrorNone) {
FURI_LOG_E(TAG, "Request system code failed with error: %d", error);
return error;
}
size_t rx_len = bit_buffer_get_size_bytes(instance->rx_buffer);
if(rx_len < sizeof(FelicaCommandHeaderRaw) + 3) return FelicaErrorProtocol;
// at least 1 system code + the count being 0x01
// error is known to be FelicaErrorNone here
*response_ptr = (FelicaListSystemCodeCommandResponse*)bit_buffer_get_data(instance->rx_buffer);
return error;
}

8
lib/nfc/protocols/felica/felica_poller_i.h
View File

@@ -17,6 +17,8 @@ extern "C" {
typedef enum {
FelicaPollerStateIdle,
FelicaPollerStateActivated,
FelicaPollerStateListSystem,
FelicaPollerStateSelectSystemIndex,
FelicaPollerStateAuthenticateInternal,
FelicaPollerStateAuthenticateExternal,
FelicaPollerStateTraverseStandardSystem,
@@ -42,6 +44,8 @@ struct FelicaPoller {
FelicaPollerEventData felica_event_data;
NfcGenericCallback callback;
uint8_t block_index;
uint8_t systems_read;
uint8_t systems_total;
void* context;
};
@@ -116,6 +120,10 @@ FelicaError felica_poller_list_service_by_cursor(
uint16_t cursor,
FelicaListServiceCommandResponse** response_ptr);
FelicaError felica_poller_list_system_code(
FelicaPoller* instance,
FelicaListSystemCodeCommandResponse** response_ptr);
#ifdef __cplusplus
}
#endif