Add format string resolution provider API

Author: plafosse

.doxygen.h

@@ -97,6 +97,10 @@
 	\defgroup flowgraph Flowgraph
 	\ingroup coreapi
 */
+/*!
+	\defgroup formatstringresolutionprovider Format String Resolution Provider
+	\ingroup coreapi
+*/
 /*!
 	\defgroup function Function
 	\ingroup coreapi

binaryninjaapi.h

@@ -20941,6 +20941,49 @@ namespace BinaryNinja {
 		virtual bool DeleteData(const std::string& key) override;
 	};
 
+	/*! Resolves the argument types described by a format string.
+
+		\ingroup formatstringresolutionprovider
+	*/
+	class FormatStringResolutionProvider : public StaticCoreRefCountObject<BNFormatStringResolutionProvider>
+	{
+		std::string m_nameForRegister;
+
+	  protected:
+		FormatStringResolutionProvider(const std::string& name);
+		FormatStringResolutionProvider(BNFormatStringResolutionProvider* provider);
+
+		static bool IsValidCallback(
+			void* ctxt, const char* format, BNTypeWithConfidence** types, size_t* count);
+		static void FreeTypeListCallback(void* ctxt, BNTypeWithConfidence* types, size_t count);
+
+	  public:
+		/*! Resolve the argument types described by a format string.
+
+		    \param format Format string to validate and resolve
+		    \return A list of argument types when valid, including an empty list for a valid format with no
+		            arguments, or an empty optional when invalid
+		*/
+		virtual std::optional<std::vector<Confidence<Ref<Type>>>> IsValid(const std::string& format) = 0;
+
+		std::string GetName() const;
+		static std::vector<Ref<FormatStringResolutionProvider>> GetList();
+		static Ref<FormatStringResolutionProvider> GetByName(const std::string& name);
+		static void Register(FormatStringResolutionProvider* provider);
+	};
+
+	/*!
+		\ingroup formatstringresolutionprovider
+	*/
+	class CoreFormatStringResolutionProvider : public FormatStringResolutionProvider
+	{
+	  public:
+		CoreFormatStringResolutionProvider(BNFormatStringResolutionProvider* provider);
+
+		virtual std::optional<std::vector<Confidence<Ref<Type>>>> IsValid(
+			const std::string& format) override;
+	};
+
 	/*! Components are objects that can contain Functions and other Components.
 
 		\note Components should not be instantiated directly. Instead use BinaryView::CreateComponent()

binaryninjacore.h

@@ -37,7 +37,7 @@
 // Current ABI version for linking to the core. This is incremented any time
 // there are changes to the API that affect linking, including new functions,
 // new types, or modifications to existing functions or types.
-#define BN_CURRENT_CORE_ABI_VERSION 179
+#define BN_CURRENT_CORE_ABI_VERSION 180
 
 // Minimum ABI version that is supported for loading of plugins. Plugins that
 // are linked to an ABI version less than this will not be able to load and
@@ -316,6 +316,7 @@ extern "C"
 	typedef struct BNDebugInfo BNDebugInfo;
 	typedef struct BNDebugInfoParser BNDebugInfoParser;
 	typedef struct BNSecretsProvider BNSecretsProvider;
+	typedef struct BNFormatStringResolutionProvider BNFormatStringResolutionProvider;
 	typedef struct BNLogger BNLogger;
 	typedef struct BNSymbolQueue BNSymbolQueue;
 	typedef struct BNTypeArchive BNTypeArchive;
@@ -3744,6 +3745,13 @@ extern "C"
 		bool (*deleteData)(void* ctxt, const char* key);
 	} BNSecretsProviderCallbacks;
 
+	typedef struct BNFormatStringResolutionProviderCallbacks
+	{
+		void* context;
+		bool (*isValid)(void* ctxt, const char* format, BNTypeWithConfidence** types, size_t* count);
+		void (*freeTypeList)(void* ctxt, BNTypeWithConfidence* types, size_t count);
+	} BNFormatStringResolutionProviderCallbacks;
+
 	typedef struct BNMergedVariable
 	{
 		BNVariable target;
@@ -8727,6 +8735,20 @@ extern "C"
 	BINARYNINJACOREAPI bool BNStoreSecretsProviderData(BNSecretsProvider* provider, const char* key, const char* data);
 	BINARYNINJACOREAPI bool BNDeleteSecretsProviderData(BNSecretsProvider* provider, const char* key);
 
+	// Format string resolution providers
+	BINARYNINJACOREAPI BNFormatStringResolutionProvider* BNRegisterFormatStringResolutionProvider(
+	    const char* name, BNFormatStringResolutionProviderCallbacks* callbacks);
+	BINARYNINJACOREAPI BNFormatStringResolutionProvider** BNGetFormatStringResolutionProviderList(size_t* count);
+	BINARYNINJACOREAPI void BNFreeFormatStringResolutionProviderList(
+	    BNFormatStringResolutionProvider** providers);
+	BINARYNINJACOREAPI BNFormatStringResolutionProvider* BNGetFormatStringResolutionProviderByName(const char* name);
+	BINARYNINJACOREAPI char* BNGetFormatStringResolutionProviderName(
+	    BNFormatStringResolutionProvider* provider);
+	BINARYNINJACOREAPI bool BNFormatStringResolutionProviderIsValid(
+	    BNFormatStringResolutionProvider* provider, const char* format,
+	    BNTypeWithConfidence** types, size_t* count);
+	BINARYNINJACOREAPI void BNFreeTypeWithConfidenceList(BNTypeWithConfidence* types, size_t count);
+
 	BINARYNINJACOREAPI BNSymbolQueue* BNCreateSymbolQueue(void);
 	BINARYNINJACOREAPI void BNDestroySymbolQueue(BNSymbolQueue* queue);
 	BINARYNINJACOREAPI void BNAppendSymbolQueue(BNSymbolQueue* queue,

formatstringresolutionprovider.cpp

@@ -0,0 +1,137 @@
+// Copyright (c) 2015-2026 Vector 35 Inc
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+
+#include "binaryninjaapi.h"
+
+using namespace BinaryNinja;
+using namespace std;
+
+
+FormatStringResolutionProvider::FormatStringResolutionProvider(const string& name) : m_nameForRegister(name) {}
+
+
+FormatStringResolutionProvider::FormatStringResolutionProvider(BNFormatStringResolutionProvider* provider)
+{
+	m_object = provider;
+}
+
+
+bool FormatStringResolutionProvider::IsValidCallback(
+	void* ctxt, const char* format, BNTypeWithConfidence** types, size_t* count)
+{
+	FormatStringResolutionProvider* provider = (FormatStringResolutionProvider*)ctxt;
+	auto result = provider->IsValid(format);
+	if (!result.has_value())
+	{
+		*types = nullptr;
+		*count = 0;
+		return false;
+	}
+
+	*count = result->size();
+	if (result->empty())
+	{
+		*types = nullptr;
+		return true;
+	}
+
+	*types = new BNTypeWithConfidence[result->size()];
+	for (size_t i = 0; i < result->size(); i++)
+	{
+		(*types)[i].type = BNNewTypeReference((*result)[i].GetValue()->GetObject());
+		(*types)[i].confidence = (*result)[i].GetConfidence();
+	}
+	return true;
+}
+
+
+void FormatStringResolutionProvider::FreeTypeListCallback(
+	void*, BNTypeWithConfidence* types, size_t count)
+{
+	for (size_t i = 0; i < count; i++)
+		BNFreeType(types[i].type);
+	delete[] types;
+}
+
+
+string FormatStringResolutionProvider::GetName() const
+{
+	char* name = BNGetFormatStringResolutionProviderName(m_object);
+	string result = name;
+	BNFreeString(name);
+	return result;
+}
+
+
+vector<Ref<FormatStringResolutionProvider>> FormatStringResolutionProvider::GetList()
+{
+	size_t count;
+	BNFormatStringResolutionProvider** list = BNGetFormatStringResolutionProviderList(&count);
+	vector<Ref<FormatStringResolutionProvider>> result;
+	result.reserve(count);
+	for (size_t i = 0; i < count; i++)
+		result.push_back(new CoreFormatStringResolutionProvider(list[i]));
+	BNFreeFormatStringResolutionProviderList(list);
+	return result;
+}
+
+
+Ref<FormatStringResolutionProvider> FormatStringResolutionProvider::GetByName(const string& name)
+{
+	BNFormatStringResolutionProvider* result = BNGetFormatStringResolutionProviderByName(name.c_str());
+	if (!result)
+		return nullptr;
+	return new CoreFormatStringResolutionProvider(result);
+}
+
+
+void FormatStringResolutionProvider::Register(FormatStringResolutionProvider* provider)
+{
+	BNFormatStringResolutionProviderCallbacks callbacks;
+	callbacks.context = provider;
+	callbacks.isValid = IsValidCallback;
+	callbacks.freeTypeList = FreeTypeListCallback;
+	provider->AddRefForRegistration();
+	provider->m_object = BNRegisterFormatStringResolutionProvider(provider->m_nameForRegister.c_str(), &callbacks);
+}
+
+
+CoreFormatStringResolutionProvider::CoreFormatStringResolutionProvider(BNFormatStringResolutionProvider* provider) :
+	FormatStringResolutionProvider(provider)
+{}
+
+
+optional<vector<Confidence<Ref<Type>>>> CoreFormatStringResolutionProvider::IsValid(const string& format)
+{
+	BNTypeWithConfidence* types = nullptr;
+	size_t count = 0;
+	if (!BNFormatStringResolutionProviderIsValid(m_object, format.c_str(), &types, &count))
+		return nullopt;
+
+	vector<Confidence<Ref<Type>>> result;
+	result.reserve(count);
+	for (size_t i = 0; i < count; i++)
+	{
+		result.emplace_back(
+			new Type(BNNewTypeReference(types[i].type)), types[i].confidence);
+	}
+	BNFreeTypeWithConfidenceList(types, count);
+	return result;
+}