Merge branch 'dev' of https://github.com/flipperdevices/flipperzero-firmware into mntm-dev

lib/flipper_application/api_hashtable/api_hashtable.cpp

@@ -9,6 +9,10 @@ bool elf_resolve_from_hashtable(
     const ElfApiInterface* interface,
     uint32_t hash,
     Elf32_Addr* address) {
+
+    furi_check(interface);
+    furi_check(address);
+
     bool result = false;
     const HashtableApiInterface* hashtable_interface =
         static_cast<const HashtableApiInterface*>(interface);
@@ -33,5 +37,6 @@ bool elf_resolve_from_hashtable(
 }
 
 uint32_t elf_symbolname_hash(const char* s) {
+    furi_check(s);
     return elf_gnu_hash(s);
 }

lib/flipper_application/application_manifest.c

@@ -1,8 +1,11 @@
 #include "application_manifest.h"
 
 #include <furi_hal_version.h>
+#include <furi.h>
 
 bool flipper_application_manifest_is_valid(const FlipperApplicationManifest* manifest) {
+    furi_check(manifest);
+
     if((manifest->base.manifest_magic != FAP_MANIFEST_MAGIC) ||
        (manifest->base.manifest_version != FAP_MANIFEST_SUPPORTED_VERSION)) {
         return false;
@@ -14,6 +17,9 @@ bool flipper_application_manifest_is_valid(const FlipperApplicationManifest* man
 bool flipper_application_manifest_is_too_old(
     const FlipperApplicationManifest* manifest,
     const ElfApiInterface* api_interface) {
+    furi_check(manifest);
+    furi_check(api_interface);
+
     if(manifest->base.api_version.major < api_interface->api_version_major /* ||
        manifest->base.api_version.minor > app->api_interface->api_version_minor */) {
         return false;
@@ -25,6 +31,9 @@ bool flipper_application_manifest_is_too_old(
 bool flipper_application_manifest_is_too_new(
     const FlipperApplicationManifest* manifest,
     const ElfApiInterface* api_interface) {
+    furi_check(manifest);
+    furi_check(api_interface);
+
     if(manifest->base.api_version.major > api_interface->api_version_major /* ||
        manifest->base.api_version.minor > app->api_interface->api_version_minor */) {
         return false;
@@ -34,6 +43,8 @@ bool flipper_application_manifest_is_too_new(
 }
 
 bool flipper_application_manifest_is_target_compatible(const FlipperApplicationManifest* manifest) {
+    furi_check(manifest);
+
     const Version* version = furi_hal_version_get_firmware_version();
     return version_get_target(version) == manifest->base.hardware_target_id;
 }

lib/flipper_application/flipper_application.c

@@ -25,7 +25,7 @@ FlipperApplicationList_t flipper_application_loaded_app_list = {0};
 static bool flipper_application_loaded_app_list_initialized = false;
 
 static void flipper_application_list_add_app(const FlipperApplication* app) {
-    furi_assert(app);
+    furi_check(app);
 
     if(!flipper_application_loaded_app_list_initialized) {
         FlipperApplicationList_init(flipper_application_loaded_app_list);
@@ -35,8 +35,8 @@ static void flipper_application_list_add_app(const FlipperApplication* app) {
 }
 
 static void flipper_application_list_remove_app(const FlipperApplication* app) {
-    furi_assert(flipper_application_loaded_app_list_initialized);
-    furi_assert(app);
+    furi_check(flipper_application_loaded_app_list_initialized);
+    furi_check(app);
 
     FlipperApplicationList_it_t it;
     for(FlipperApplicationList_it(it, flipper_application_loaded_app_list);
@@ -53,19 +53,24 @@ static void flipper_application_list_remove_app(const FlipperApplication* app) {
 
 FlipperApplication*
     flipper_application_alloc(Storage* storage, const ElfApiInterface* api_interface) {
+    furi_check(storage);
+    furi_check(api_interface);
+
     FlipperApplication* app = malloc(sizeof(FlipperApplication));
     app->elf = elf_file_alloc(storage, api_interface);
     app->thread = NULL;
     app->ep_thread_args = NULL;
+
     return app;
 }
 
 bool flipper_application_is_plugin(FlipperApplication* app) {
+    furi_check(app);
     return app->manifest.stack_size == 0;
 }
 
 void flipper_application_free(FlipperApplication* app) {
-    furi_assert(app);
+    furi_check(app);
 
     if(app->thread) {
         furi_thread_join(app->thread);
@@ -185,20 +190,29 @@ static FlipperApplicationPreloadStatus
 /* Parse headers, load manifest */
 FlipperApplicationPreloadStatus
     flipper_application_preload_manifest(FlipperApplication* app, const char* path) {
+    furi_check(app);
+    furi_check(path);
+
     return flipper_application_load(app, path, false);
 }
 
 /* Parse headers, load full file */
 FlipperApplicationPreloadStatus
     flipper_application_preload(FlipperApplication* app, const char* path) {
+    furi_check(app);
+    furi_check(path);
+
     return flipper_application_load(app, path, true);
 }
 
 const FlipperApplicationManifest* flipper_application_get_manifest(FlipperApplication* app) {
+    furi_check(app);
     return &app->manifest;
 }
 
 FlipperApplicationLoadStatus flipper_application_map_to_memory(FlipperApplication* app) {
+    furi_check(app);
+
     ELFFileLoadStatus status = elf_file_load_sections(app->elf);
 
     switch(status) {
@@ -216,7 +230,7 @@ FlipperApplicationLoadStatus flipper_application_map_to_memory(FlipperApplicatio
 }
 
 static int32_t flipper_application_thread(void* context) {
-    furi_assert(context);
+    furi_check(context);
     FlipperApplication* app = (FlipperApplication*)context;
 
     elf_file_call_init(app->elf);
@@ -238,6 +252,7 @@ static int32_t flipper_application_thread(void* context) {
 }
 
 FuriThread* flipper_application_alloc_thread(FlipperApplication* app, const char* args) {
+    furi_check(app);
     furi_check(app->thread == NULL);
     furi_check(!flipper_application_is_plugin(app));
 
@@ -294,6 +309,8 @@ const char* flipper_application_load_status_to_string(FlipperApplicationLoadStat
 
 const FlipperAppPluginDescriptor*
     flipper_application_plugin_get_descriptor(FlipperApplication* app) {
+    furi_check(app);
+
     if(!flipper_application_is_plugin(app)) {
         return NULL;
     }
@@ -322,6 +339,11 @@ bool flipper_application_load_name_and_icon(
     Storage* storage,
     uint8_t** icon_ptr,
     FuriString* item_name) {
+    furi_check(path);
+    furi_check(storage);
+    furi_check(icon_ptr);
+    furi_check(item_name);
+
     bool load_success = true;
 
     StorageData* storage_data;

lib/flipper_application/plugins/composite_resolver.c

@@ -1,5 +1,6 @@
 #include "composite_resolver.h"
 
+#include <furi.h>
 #include <m-list.h>
 #include <m-algo.h>
 
@@ -25,21 +26,28 @@ static bool composite_api_resolver_callback(
     return false;
 }
 
-CompositeApiResolver* composite_api_resolver_alloc() {
+CompositeApiResolver* composite_api_resolver_alloc(void) {
     CompositeApiResolver* resolver = malloc(sizeof(CompositeApiResolver));
+
     resolver->api_interface.api_version_major = 0;
     resolver->api_interface.api_version_minor = 0;
     resolver->api_interface.resolver_callback = &composite_api_resolver_callback;
     ElfApiInterfaceList_init(resolver->interfaces);
+
     return resolver;
 }
 
 void composite_api_resolver_free(CompositeApiResolver* resolver) {
+    furi_check(resolver);
+
     ElfApiInterfaceList_clear(resolver->interfaces);
     free(resolver);
 }
 
 void composite_api_resolver_add(CompositeApiResolver* resolver, const ElfApiInterface* interface) {
+    furi_check(resolver);
+    furi_check(interface);
+
     if(ElfApiInterfaceList_empty_p(resolver->interfaces)) {
         resolver->api_interface.api_version_major = interface->api_version_major;
         resolver->api_interface.api_version_minor = interface->api_version_minor;
@@ -48,5 +56,6 @@ void composite_api_resolver_add(CompositeApiResolver* resolver, const ElfApiInte
 }
 
 const ElfApiInterface* composite_api_resolver_get(CompositeApiResolver* resolver) {
+    furi_check(resolver);
     return &resolver->api_interface;
 }

lib/flipper_application/plugins/composite_resolver.h

@@ -19,7 +19,7 @@ typedef struct CompositeApiResolver CompositeApiResolver;
  * @brief Allocate composite API resolver
  * @return CompositeApiResolver* instance
  */
-CompositeApiResolver* composite_api_resolver_alloc();
+CompositeApiResolver* composite_api_resolver_alloc(void);
 
 /**
  * @brief Free composite API resolver

lib/flipper_application/plugins/plugin_manager.c

@@ -38,6 +38,8 @@ PluginManager* plugin_manager_alloc(
 }
 
 void plugin_manager_free(PluginManager* manager) {
+    furi_check(manager);
+
     for
         M_EACH(loaded_lib, manager->libs, FlipperApplicationList_t) {
             flipper_application_free(*loaded_lib);
@@ -48,6 +50,7 @@ void plugin_manager_free(PluginManager* manager) {
 }
 
 PluginManagerError plugin_manager_load_single(PluginManager* manager, const char* path) {
+    furi_check(manager);
     FlipperApplication* lib = flipper_application_alloc(manager->storage, manager->api_interface);
 
     PluginManagerError error = PluginManagerErrorNone;
@@ -105,6 +108,7 @@ PluginManagerError plugin_manager_load_single(PluginManager* manager, const char
 }
 
 PluginManagerError plugin_manager_load_all(PluginManager* manager, const char* path) {
+    furi_check(manager);
     File* directory = storage_file_alloc(manager->storage);
     char file_name_buffer[MAX_NAME_LEN];
     FuriString* file_name = furi_string_alloc();
@@ -141,15 +145,21 @@ PluginManagerError plugin_manager_load_all(PluginManager* manager, const char* p
 }
 
 uint32_t plugin_manager_get_count(PluginManager* manager) {
+    furi_check(manager);
+
     return FlipperApplicationList_size(manager->libs);
 }
 
 const FlipperAppPluginDescriptor* plugin_manager_get(PluginManager* manager, uint32_t index) {
+    furi_check(manager);
+
     FlipperApplication* app = *FlipperApplicationList_get(manager->libs, index);
     return flipper_application_plugin_get_descriptor(app);
 }
 
 const void* plugin_manager_get_ep(PluginManager* manager, uint32_t index) {
+    furi_check(manager);
+
     const FlipperAppPluginDescriptor* lib_descr = plugin_manager_get(manager, index);
     furi_check(lib_descr);
     return lib_descr->entry_point;