Repository navigation
Expand file tree
/
Copy pathffi.h
More file actions
169 lines (144 loc) · 5.38 KB
/
Copy pathffi.h
File metadata and controls
169 lines (144 loc) · 5.38 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
#pragma once
#include <optional>
#include <string>
#include <string_view>
#include <vector>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <type_traits>
#include "base/capi.h"
#include "binaryninjacore.h"
// FFI Helpers
namespace BinaryNinja
{
//------------------------------------------------------------------------------------
//region string <-> char*
char BN_API_PTR* AllocApiString(std::string_view string);
void AllocApiString(std::string_view string, char BN_API_PTR** output);
char BN_API_PTR* BN_API_PTR* AllocApiStringList(const char* const* stringList, size_t count);
void AllocApiStringList(const char* const* stringList, size_t count, char BN_API_PTR* BN_API_PTR** output);
template <bn::base::capi::StringRange R>
char BN_API_PTR* BN_API_PTR* AllocApiStringList(const R& strings, size_t* count)
{
return bn::base::capi::AllocStringList(strings, count,
[](size_t n) { return new char*[n]; }, [](std::string_view sv) { return AllocApiString(sv); });
}
template <bn::base::capi::StringRange R>
void AllocApiStringList(const R& strings, char BN_API_PTR* BN_API_PTR** output, size_t* count)
{
*output = AllocApiStringList(strings, count);
}
template <bn::base::capi::StringPairRange R>
void AllocApiStringPairList(const R& pairs, char BN_API_PTR* BN_API_PTR** outputKeys, char BN_API_PTR* BN_API_PTR** outputValues, size_t* count)
{
*count = bn::base::capi::AllocStringPairList(pairs, outputKeys, outputValues,
[](size_t n) { return new char*[n]; }, [](std::string_view sv) { return AllocApiString(sv); });
}
std::string ParseString(const char* string);
std::vector<std::string> ParseStringList(const char* const* stringList, size_t count);
std::set<std::string> ParseStringSet(const char* const* stringList, size_t count);
std::unordered_set<std::string> ParseStringUnorderedSet(const char* const* stringList, size_t count);
std::vector<std::pair<std::string, std::string>> ParseStringPairList(const char* const* keys, const char* const* values, size_t count);
std::map<std::string, std::string> ParseStringMap(const char* const* keys, const char* const* values, size_t count);
std::unordered_map<std::string, std::string> ParseStringUnorderedMap(const char* const* keys, const char* const* values, size_t count);
void FreeApiString(char BN_API_PTR* string);
void FreeApiStringList(char BN_API_PTR* BN_API_PTR* stringList, size_t count);
void FreeApiStringPairList(char BN_API_PTR* BN_API_PTR* keys, char BN_API_PTR* BN_API_PTR* values, size_t count);
void FreeCoreString(char BN_CORE_PTR* string);
void FreeCoreStringList(char BN_CORE_PTR* BN_CORE_PTR* stringList, size_t count);
void FreeCoreStringPairList(char BN_CORE_PTR* BN_CORE_PTR* keys, char BN_CORE_PTR* BN_CORE_PTR* values, size_t count);
//endregion
//region Generic API Structs
using bn::base::capi::APIStruct;
using bn::base::capi::APIStructType;
using bn::base::capi::AllocAPIStruct;
using bn::base::capi::ParseAPIStruct;
using bn::base::capi::ParseAPIStructList;
template<APIStruct T>
void AllocAPIStructList(const std::vector<T>& objects, APIStructType<T> BN_API_PTR** output, size_t* count)
{
bn::base::capi::AllocAPIStructList<T>(objects, output, count);
}
template<APIStruct T>
APIStructType<T> BN_API_PTR* AllocAPIStructList(const std::vector<T>& objects, size_t* count)
{
return bn::base::capi::AllocAPIStructList<T>(objects, count);
}
template<APIStruct T>
void FreeAPIStructList(APIStructType<T> BN_API_PTR* objects, size_t count)
{
bn::base::capi::FreeAPIStructList<T>(objects, count);
}
//endregion
//------------------------------------------------------------------------------------
//region Try/Catch Helpers
using bn::base::capi::WrapThrowable;
// Forward declare this, so we don't have to depend on binaryninjaapi.h
void LogErrorForException(const std::exception& e, const char*, ...);
/*!
Wrap a throwable block in a try/catch, passing through the return value on success.
Specialized for pointers, where nullptr will be returned if an exception is thrown.
\tparam T Return type
\tparam F Throwable block
\param func Throwable block to execute
\return Either the func's result or nullptr
*/
template<typename T, typename F>
T WrapThrowablePointer(F&& func, typename std::enable_if<std::is_pointer<T>::value, int>::type _ = 0)
{
try
{
return func();
}
catch (const std::exception& e)
{
// TODO: How to handle this?
// g_lastExceptionMessage = e.what();
LogErrorForException(e, "%s", e.what());
return nullptr;
}
catch (...)
{
return nullptr;
}
}
/*!
Wrap a throwable block in a try/catch, passing through the return value on success.
Specialized for bool and void functions, returning false if the function throws, or
- if the function returns a bool, passing through that value.
- if the function returns void, returning true on completion.
\tparam F Throwable block
\param func Throwable block to execute
\return Bool as described above
*/
template<typename F>
bool WrapThrowableBool(F&& func)
{
try
{
if constexpr (std::is_same<typename std::invoke_result<F>::type, bool>::value)
{
return func();
}
else
{
func();
return true;
}
}
catch (const std::exception& e)
{
// TODO: How to handle this?
// g_lastExceptionMessage = e.what();
LogErrorForException(e, "%s", e.what());
return false;
}
catch (...)
{
return false;
}
}
//endregion
}