[FL-3446] Feature check adjustment and nesting removal

firmware/targets/f7/api_symbols.csv

@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,35.0,,
+Version,+,36.0,,
 Header,+,applications/services/bt/bt_service/bt.h,,
 Header,+,applications/services/cli/cli.h,,
 Header,+,applications/services/cli/cli_vcp.h,,
@@ -2138,6 +2138,7 @@ Function,+,mf_ultralight_poller_write_page,MfUltralightError,"Nfc*, uint16_t, Mf
 Function,+,mf_ultralight_reset,void,MfUltralightData*
 Function,+,mf_ultralight_save,_Bool,"const MfUltralightData*, FlipperFormat*"
 Function,+,mf_ultralight_set_uid,_Bool,"MfUltralightData*, const uint8_t*, size_t"
+Function,+,mf_ultralight_support_feature,_Bool,"const uint32_t, const uint32_t"
 Function,+,mf_ultralight_verify,_Bool,"MfUltralightData*, const FuriString*"
 Function,-,mkdtemp,char*,char*
 Function,-,mkostemp,int,"char*, int"

lib/nfc/protocols/mf_ultralight/mf_ultralight.c

@@ -535,6 +535,10 @@ uint16_t mf_ultralight_get_config_page_num(MfUltralightType type) {
     return mf_ultralight_features[type].config_page;
 }
 
+bool mf_ultralight_support_feature(const uint32_t feature_set, const uint32_t features_to_check) {
+    return (feature_set & features_to_check) != 0;
+}
+
 bool mf_ultralight_get_config_page(const MfUltralightData* data, MfUltralightConfigPages** config) {
     furi_assert(data);
     furi_assert(config);

lib/nfc/protocols/mf_ultralight/mf_ultralight.h

@@ -200,6 +200,8 @@ uint32_t mf_ultralight_get_feature_support_set(MfUltralightType type);
 
 uint16_t mf_ultralight_get_config_page_num(MfUltralightType type);
 
+bool mf_ultralight_support_feature(const uint32_t feature_set, const uint32_t features_to_check);
+
 bool mf_ultralight_get_config_page(const MfUltralightData* data, MfUltralightConfigPages** config);
 
 bool mf_ultralight_is_all_data_read(const MfUltralightData* data);

lib/nfc/protocols/mf_ultralight/mf_ultralight_listener.c

@@ -137,7 +137,7 @@ static bool
 
     bool command_processed = false;
 
-    if((instance->features & MfUltralightFeatureSupportReadVersion)) {
+    if(mf_ultralight_support_feature(instance->features, MfUltralightFeatureSupportReadVersion)) {
         bit_buffer_copy_bytes(
             instance->tx_buffer, (uint8_t*)&instance->data->version, sizeof(MfUltralightVersion));
         iso14443_3a_listener_send_standard_frame(
@@ -160,7 +160,7 @@ static bool mf_ultralight_listener_read_signature_handler(
 
     bool command_processed = false;
 
-    if((instance->features & MfUltralightFeatureSupportReadSignature)) {
+    if(mf_ultralight_support_feature(instance->features, MfUltralightFeatureSupportReadSignature)) {
         bit_buffer_copy_bytes(
             instance->tx_buffer, instance->data->signature.data, sizeof(MfUltralightSignature));
         iso14443_3a_listener_send_standard_frame(
@@ -182,16 +182,16 @@ static bool
 
     do {
         uint8_t counter_num = bit_buffer_get_byte(buffer, 1);
-        if((instance->features & MfUltralightFeatureSupportReadCounter) == 0) break;
-        if(instance->features & MfUltralightFeatureSupportSingleCounter) {
-            if(counter_num != 2) {
-                break;
-            }
-        }
+        if(!mf_ultralight_support_feature(
+               instance->features, MfUltralightFeatureSupportReadCounter))
+            break;
+
+        if(mf_ultralight_support_feature(
+               instance->features, MfUltralightFeatureSupportSingleCounter) &&
+           (counter_num != 2))
+            break;
+
         if(instance->config) {
-            /* if(!instance->config->access.nfc_cnt_en) {
-                break;
-            }*/
             if(instance->config->access.nfc_cnt_pwd_prot) {
                 if(instance->auth_state != MfUltralightListenerAuthStateSuccess) {
                     break;
@@ -222,20 +222,25 @@ static bool mf_ultralight_listener_check_tearing_handler(
 
     do {
         uint8_t tearing_flag_num = bit_buffer_get_byte(buffer, 1);
-        if(instance->features & (MfUltralightFeatureSupportCheckTearingFlag |
-                                 MfUltralightFeatureSupportSingleCounter)) {
-            if((instance->features & MfUltralightFeatureSupportSingleCounter) &&
-               (tearing_flag_num != 2)) {
-                break;
-            }
-
-            bit_buffer_set_size_bytes(instance->tx_buffer, 1);
-            bit_buffer_set_byte(
-                instance->tx_buffer, 0, instance->data->tearing_flag->data[tearing_flag_num]);
-            iso14443_3a_listener_send_standard_frame(
-                instance->iso14443_3a_listener, instance->tx_buffer);
-            command_processed = true;
+        if(!mf_ultralight_support_feature(
+               instance->features,
+               MfUltralightFeatureSupportCheckTearingFlag |
+                   MfUltralightFeatureSupportSingleCounter)) {
+            break;
         }
+        if(mf_ultralight_support_feature(
+               instance->features, MfUltralightFeatureSupportSingleCounter) &&
+           (tearing_flag_num != 2)) {
+            break;
+        }
+
+        bit_buffer_set_size_bytes(instance->tx_buffer, 1);
+        bit_buffer_set_byte(
+            instance->tx_buffer, 0, instance->data->tearing_flag->data[tearing_flag_num]);
+        iso14443_3a_listener_send_standard_frame(
+            instance->iso14443_3a_listener, instance->tx_buffer);
+        command_processed = true;
+
     } while(false);
 
     return command_processed;
@@ -248,7 +253,9 @@ static bool
     FURI_LOG_D(TAG, "CMD_AUTH");
 
     do {
-        if((instance->features & MfUltralightFeatureSupportAuthentication) == 0) break;
+        if(!mf_ultralight_support_feature(
+               instance->features, MfUltralightFeatureSupportAuthentication))
+            break;
 
         const uint8_t* rx_data = bit_buffer_get_data(buffer);
         MfUltralightAuthPassword password = {};

lib/nfc/protocols/mf_ultralight/mf_ultralight_poller.c

@@ -276,7 +276,8 @@ static NfcCommand mf_ultralight_poller_handler_get_feature_set(MfUltralightPolle
 
 static NfcCommand mf_ultralight_poller_handler_read_signature(MfUltralightPoller* instance) {
     MfUltralightPollerState next_state = MfUltralightPollerStateAuth;
-    if(instance->feature_set & MfUltralightFeatureSupportReadSignature) {
+    if(mf_ultralight_support_feature(
+           instance->feature_set, MfUltralightFeatureSupportReadSignature)) {
         FURI_LOG_D(TAG, "Reading signature");
         instance->error =
             mf_ultralight_poller_async_read_signature(instance, &instance->data->signature);
@@ -293,44 +294,49 @@ static NfcCommand mf_ultralight_poller_handler_read_signature(MfUltralightPoller
 }
 
 static NfcCommand mf_ultralight_poller_handler_read_counters(MfUltralightPoller* instance) {
-    if(instance->feature_set & MfUltralightFeatureSupportReadCounter) {
-        if(mf_ultralight_is_counter_configured(instance->data)) {
-            if(instance->feature_set & MfUltralightFeatureSupportSingleCounter) {
-                instance->counters_read = 2;
-            }
-            if(instance->counters_read == instance->counters_total) {
-                instance->state = MfUltralightPollerStateReadTearingFlags;
-            } else {
-                FURI_LOG_D(TAG, "Reading counter %d", instance->counters_read);
-                instance->error = mf_ultralight_poller_async_read_counter(
-                    instance,
-                    instance->counters_read,
-                    &instance->data->counter[instance->counters_read]);
-                if(instance->error != MfUltralightErrorNone) {
-                    FURI_LOG_D(TAG, "Failed to read %d counter", instance->counters_read);
-                    instance->state = MfUltralightPollerStateReadTearingFlags;
-                } else {
-                    instance->counters_read++;
-                }
-            }
-        } else {
+    do {
+        if(!mf_ultralight_support_feature(
+               instance->feature_set, MfUltralightFeatureSupportReadCounter) ||
+           !mf_ultralight_is_counter_configured(instance->data)) {
+            FURI_LOG_D(TAG, "Skip reading counters");
             instance->state = MfUltralightPollerStateReadTearingFlags;
+            break;
         }
-    } else {
-        FURI_LOG_D(TAG, "Skip reading counters");
-        instance->state = MfUltralightPollerStateReadTearingFlags;
-    }
+
+        if(instance->counters_read == instance->counters_total) {
+            instance->state = MfUltralightPollerStateReadTearingFlags;
+            break;
+        }
+
+        if(mf_ultralight_support_feature(
+               instance->feature_set, MfUltralightFeatureSupportSingleCounter)) {
+            instance->counters_read = 2;
+        }
+
+        FURI_LOG_D(TAG, "Reading counter %d", instance->counters_read);
+        instance->error = mf_ultralight_poller_async_read_counter(
+            instance, instance->counters_read, &instance->data->counter[instance->counters_read]);
+        if(instance->error != MfUltralightErrorNone) {
+            FURI_LOG_D(TAG, "Failed to read %d counter", instance->counters_read);
+            instance->state = MfUltralightPollerStateReadTearingFlags;
+        } else {
+            instance->counters_read++;
+        }
+
+    } while(false);
 
     return NfcCommandContinue;
 }
 
 static NfcCommand mf_ultralight_poller_handler_read_tearing_flags(MfUltralightPoller* instance) {
-    if(instance->feature_set &
-       (MfUltralightFeatureSupportCheckTearingFlag | MfUltralightFeatureSupportSingleCounter)) {
+    if(mf_ultralight_support_feature(
+           instance->feature_set,
+           MfUltralightFeatureSupportCheckTearingFlag | MfUltralightFeatureSupportSingleCounter)) {
         if(instance->tearing_flag_read == instance->tearing_flag_total) {
             instance->state = MfUltralightPollerStateTryDefaultPass;
         } else {
-            if(instance->feature_set & MfUltralightFeatureSupportSingleCounter) {
+            if(mf_ultralight_support_feature(
+                   instance->feature_set, MfUltralightFeatureSupportSingleCounter)) {
                 instance->tearing_flag_read = 2;
             }
             FURI_LOG_D(TAG, "Reading tearing flag %d", instance->tearing_flag_read);
@@ -355,7 +361,8 @@ static NfcCommand mf_ultralight_poller_handler_read_tearing_flags(MfUltralightPo
 
 static NfcCommand mf_ultralight_poller_handler_auth(MfUltralightPoller* instance) {
     NfcCommand command = NfcCommandContinue;
-    if(instance->feature_set & MfUltralightFeatureSupportAuthentication) {
+    if(mf_ultralight_support_feature(
+           instance->feature_set, MfUltralightFeatureSupportAuthentication)) {
         instance->mfu_event.type = MfUltralightPollerEventTypeAuthRequest;
 
         command = instance->callback(instance->general_event, instance->context);
@@ -430,7 +437,11 @@ static NfcCommand mf_ultralight_poller_handler_read_pages(MfUltralightPoller* in
 }
 
 static NfcCommand mf_ultralight_poller_handler_try_default_pass(MfUltralightPoller* instance) {
-    if(instance->feature_set & MfUltralightFeatureSupportAuthentication) {
+    do {
+        if(!mf_ultralight_support_feature(
+               instance->feature_set, MfUltralightFeatureSupportAuthentication))
+            break;
+
         MfUltralightConfigPages* config = NULL;
         mf_ultralight_get_config_page(instance->data, &config);
         if(instance->auth_context.auth_success) {
@@ -454,7 +465,7 @@ static NfcCommand mf_ultralight_poller_handler_try_default_pass(MfUltralightPoll
             config->auth0 = instance->pages_read;
             config->access.prot = true;
         }
-    }
+    } while(false);
 
     instance->state = MfUltralightPollerStateReadSuccess;
     return NfcCommandContinue;