heck
3 years ago
1 changed files with 413 additions and 0 deletions
@ -0,0 +1,413 @@ |
|||
#include <iostream> |
|||
#include <cctype> |
|||
#include <pEp/pEpEngine.h> |
|||
#include <pEp/message_api.h> |
|||
#include <pEp/keymanagement.h> |
|||
#include <pEp/identity_list.h> |
|||
#include <pEp/utils.hh> |
|||
#include <pEp/pEpLog.hh> |
|||
#include <sstream> |
|||
#include <type_traits> |
|||
//using namespace pEp;
|
|||
|
|||
|
|||
namespace pEp { |
|||
|
|||
template<class T> |
|||
std::string type_add_val(const T c, size_t val_len = 30) |
|||
{ |
|||
static_assert(std::is_pointer<T>::value, "only pointer types are valid"); |
|||
std::stringstream ss_type; |
|||
//type
|
|||
ss_type << typeid(T).name(); |
|||
|
|||
//addr
|
|||
std::stringstream ss_addr{}; |
|||
ss_addr << static_cast<const void*>(c); |
|||
|
|||
//value
|
|||
std::stringstream ss_val{}; |
|||
if (c != nullptr) { |
|||
ss_val << "\"" << c << "\""; |
|||
} else { |
|||
ss_val << "<NULL>"; |
|||
} |
|||
|
|||
std::stringstream ret{}; |
|||
ret << "{ " << ss_type.str() << " | " + ss_addr.str() << " | " |
|||
<< pEp::Utils::clip(ss_val.str(), val_len) << " }"; |
|||
return ret.str(); |
|||
} |
|||
|
|||
char* alloc(const std::string& str) |
|||
{ |
|||
char* ret = strdup(str.c_str()); |
|||
pEpLog(type_add_val(ret)); |
|||
return ret; |
|||
} |
|||
|
|||
template<class T> |
|||
void free(T ptr_type) |
|||
{ |
|||
pEpLog(type_add_val(ptr_type)); |
|||
::pEp_free(ptr_type); |
|||
} |
|||
|
|||
template<> |
|||
void free(char* ptr_type) |
|||
{ |
|||
pEpLog(type_add_val(ptr_type)); |
|||
::pEp_free(ptr_type); |
|||
} |
|||
|
|||
template<> |
|||
void free(::pEp_identity* ptr_type) |
|||
{ |
|||
pEpLog(type_add_val(ptr_type)); |
|||
::pEp_free(ptr_type); |
|||
} |
|||
|
|||
|
|||
//---------------------------------------------------------------------------------------------
|
|||
#define EXSTR(msg) std::string(__FUNCTION__) + " - " + msg |
|||
|
|||
|
|||
// Manages a char* to appear like a std::string
|
|||
// char* c_str
|
|||
// c_str MUST point to either:
|
|||
// * NULL - means there is no value/mem alloc yet
|
|||
// * dyn allocated memory
|
|||
// in case the mem is already allocated, there must be 2 modes
|
|||
// * take ownership (and free it)
|
|||
// * dont take ownership, only provide a C++ interface
|
|||
// There must be the option to construct the object before the wrapped c_str (char*)
|
|||
// is known. This leads to a pEp::String object in invalid state, and it must be initialized using
|
|||
// set(). Otherwise all(most) functions will throw.
|
|||
// set() can only be called once, will throw otherwise.
|
|||
class String { |
|||
public: |
|||
String() = default; |
|||
|
|||
// Best to use this constructor, as the object is in a valid state when the wrapped
|
|||
// c_str (char*) is known
|
|||
explicit String(char** c_str_pp) |
|||
{ |
|||
initialize(c_str_pp); |
|||
} |
|||
|
|||
~String() |
|||
{ |
|||
_free(); |
|||
} |
|||
|
|||
void initialize(char** c_str_pp) |
|||
{ |
|||
if (c_str_pp == nullptr) { |
|||
throw Exception{ EXSTR("cant initialize on a nullptr") }; |
|||
} |
|||
|
|||
if (_is_initialized) { |
|||
throw Exception{ EXSTR("double initialization") }; |
|||
} |
|||
|
|||
// init
|
|||
_c_str_pp = c_str_pp; |
|||
// _c_str_p.reset(*_c_str_pp, [&](char* ptr) { this->_free(ptr); });
|
|||
_c_str_p = *_c_str_pp; |
|||
|
|||
_is_initialized = true; |
|||
pEpLogClass(to_string() + " - taking ownership"); |
|||
} |
|||
|
|||
// make a copy
|
|||
String& operator=(const std::string& str) |
|||
{ |
|||
pEpLogClass("Before: " + to_string() + " - new val: '" + pEp::Utils::clip(str, 30) + "'"); |
|||
if (_c_str_pp == nullptr) { |
|||
throw Exception{ EXSTR("invalid state") }; |
|||
} |
|||
|
|||
// DEALLOCATION
|
|||
_free(); |
|||
// // if we point to an initialized string
|
|||
// if (*_c_str_pp != nullptr) {
|
|||
// // if the string there is not the one we created
|
|||
//// if (*_c_str_pp != _c_str_p.get()) {
|
|||
// if (*_c_str_pp != _c_str_p) {
|
|||
// // we need to free it before we lose the pointer to it
|
|||
// pEpLog("freeing foreign allocated string");
|
|||
// pEp::free(*_c_str_pp);
|
|||
// // } // else it will be free automatically upon .reset()
|
|||
// }
|
|||
// //and we need to anyways free the strings we create ourselfes
|
|||
// if
|
|||
// pEp::free(_c_str_p;)
|
|||
// }
|
|||
|
|||
|
|||
// ALLOCATION
|
|||
if (str.empty()) { |
|||
// if the new value is empty str, lets point to nothing
|
|||
*_c_str_pp = nullptr; |
|||
// _c_str_p.reset(*_c_str_pp);
|
|||
_c_str_p = *_c_str_pp; |
|||
} else { |
|||
*_c_str_pp = pEp::alloc(str); |
|||
// _c_str_p.reset(*_c_str_pp, [&](char* ptr) { this->_free(ptr); });
|
|||
_c_str_p = *_c_str_pp; |
|||
} |
|||
pEpLogClass("After: " + to_string()); |
|||
return *this; |
|||
} |
|||
|
|||
// return a copy of whatever c_str currently is (maybe created by us, maybe changed meanwhile)
|
|||
operator std::string() const |
|||
{ |
|||
if (_c_str_pp == nullptr) { |
|||
throw Exception{ EXSTR("invalid state") }; |
|||
} |
|||
|
|||
if (*_c_str_pp != nullptr) { |
|||
return { *_c_str_pp }; |
|||
} |
|||
return {}; |
|||
} |
|||
|
|||
char** data() |
|||
{ |
|||
return _c_str_pp; |
|||
} |
|||
|
|||
const char* c_data() const |
|||
{ |
|||
if (_c_str_pp == nullptr) { |
|||
throw Exception{ EXSTR("invalid state") }; |
|||
} |
|||
return *_c_str_pp; |
|||
} |
|||
|
|||
std::string to_string() const |
|||
{ |
|||
if (_c_str_pp == nullptr) { |
|||
throw Exception{ EXSTR("invalid state") }; |
|||
} |
|||
|
|||
std::string ret{ "[" + type_add_val(_c_str_pp) + " / " + type_add_val(*_c_str_pp) + "]" }; |
|||
return ret; |
|||
} |
|||
|
|||
static bool log_enabled; |
|||
|
|||
|
|||
private: |
|||
void _free() |
|||
{ |
|||
// if the c_str points to a different address now, than the one we created
|
|||
if (*_c_str_pp != _c_str_p) { |
|||
// a new string has been created, and we need to free it as well
|
|||
pEpLog("raw access string change detected"); |
|||
pEp::free(*_c_str_pp); |
|||
} else { |
|||
// we anyways need to free the one we created
|
|||
// NO: WE ASSUME THAT:
|
|||
// if the char* has been replaced, it has been freed, as well
|
|||
if (_c_str_p != nullptr) { |
|||
pEp::free(_c_str_p); |
|||
} |
|||
} |
|||
} |
|||
|
|||
bool _is_initialized{ false }; |
|||
char** _c_str_pp{ nullptr }; |
|||
// std::shared_ptr<char> _c_str_p{};
|
|||
char* _c_str_p{ nullptr }; |
|||
|
|||
Adapter::pEpLog::pEpLogger logger{ "pEp::String", log_enabled }; |
|||
Adapter::pEpLog::pEpLogger& m4gic_logger_n4me = logger; |
|||
|
|||
class Exception : public std::runtime_error { |
|||
public: |
|||
explicit Exception(const std::string& msg) : std::runtime_error(msg) {} |
|||
}; |
|||
}; |
|||
|
|||
bool pEp::String::log_enabled{ true }; |
|||
|
|||
std::ostream& operator<<(std::ostream& o, const pEp::String& pEpStr) |
|||
{ |
|||
return o << std::string(pEpStr); |
|||
} |
|||
|
|||
//---------------------------------------------------------------------------------------------
|
|||
|
|||
// TOOD:
|
|||
// ctor not exception safe
|
|||
class Identity { |
|||
public: |
|||
Identity( |
|||
const std::string& address = "", |
|||
const std::string& username = "", |
|||
const std::string& user_id = "", |
|||
const std::string& fpr = "") |
|||
{ |
|||
pEpLogClass("called"); |
|||
_wrappee = ::new_identity(nullptr, nullptr, nullptr, nullptr); |
|||
|
|||
// set the pEp::String wrapper underlying c_str
|
|||
this->address.initialize(&_wrappee->address); |
|||
this->username.initialize(&_wrappee->username); |
|||
this->user_id.initialize(&_wrappee->user_id); |
|||
this->fpr.initialize(&_wrappee->fpr); |
|||
|
|||
// set the values
|
|||
this->address = address; |
|||
this->username = username; |
|||
this->user_id = user_id; |
|||
this->fpr = fpr; |
|||
} |
|||
|
|||
~Identity() |
|||
{ |
|||
_free(); |
|||
} |
|||
|
|||
|
|||
pEp::String address{}; |
|||
pEp::String username{}; |
|||
pEp::String user_id{}; |
|||
pEp::String fpr{}; |
|||
|
|||
operator ::pEp_identity*() |
|||
{ |
|||
return _wrappee; |
|||
} |
|||
|
|||
static bool log_enabled; |
|||
|
|||
private: |
|||
void _free() |
|||
{ |
|||
// pEp::free(_wrappee);
|
|||
} |
|||
|
|||
::pEp_identity* _wrappee{ nullptr }; |
|||
Adapter::pEpLog::pEpLogger logger{ "IdentWrappySP", log_enabled }; |
|||
Adapter::pEpLog::pEpLogger& m4gic_logger_n4me = logger; |
|||
}; |
|||
|
|||
bool Identity::log_enabled{ true }; |
|||
|
|||
} // namespace pEp
|
|||
|
|||
|
|||
::PEP_SESSION session; |
|||
|
|||
void test_getters(char const* const* const c_str_p, pEp::String& pstr) |
|||
{ |
|||
pEpLog("to_string(): " + pstr.to_string()); |
|||
assert(pstr.c_data() == *c_str_p); |
|||
assert(pstr.data() == c_str_p); |
|||
|
|||
if (*c_str_p != nullptr) { |
|||
std::string tmp{ pstr }; |
|||
pEpLog("operator std::string(): " + tmp); |
|||
assert(tmp == std::string(*c_str_p)); |
|||
|
|||
// will segfault with nullptr, and this is correct
|
|||
std::string tmp2{ *pstr.data() }; |
|||
pEpLog("data(): " + tmp2); |
|||
assert(tmp2 == std::string(*c_str_p)); |
|||
|
|||
std::string tmp3{ pstr.c_data() }; |
|||
pEpLog("c_data(): " + tmp2); |
|||
assert(tmp3 == std::string(*c_str_p)); |
|||
} else { |
|||
std::string tmp{ pstr }; |
|||
pEpLog("operator std::string(): " + tmp); |
|||
assert(tmp == ""); |
|||
} |
|||
} |
|||
|
|||
void test_assign_and_getters(char** c_str_p, pEp::String& pstr) |
|||
{ |
|||
test_getters(c_str_p, pstr); |
|||
pEpLogH2("assign operator"); |
|||
pstr = "assign operator"; |
|||
test_getters(c_str_p, pstr); |
|||
|
|||
pEpLogH2("raw c_str assign"); |
|||
*c_str_p = strdup("raw c_str assign"); |
|||
test_getters(c_str_p, pstr); |
|||
} |
|||
|
|||
int main() |
|||
{ |
|||
// pEp::Utils::readKey();
|
|||
pEp::Adapter::pEpLog::set_enabled(true); |
|||
|
|||
// pEp::String::log_enabled = false;
|
|||
if (1) { |
|||
// INVALID USAGE
|
|||
// char* c_str_u; // uninitialized == INVALID
|
|||
// undefined behaviour, most likely "pointer being freed was not allocated"
|
|||
// {
|
|||
// char* c_str;
|
|||
// pEp::String pstr(c_str);
|
|||
// }
|
|||
// char* c_str_s = "fdsfs"; // statically initialized == INVALID
|
|||
// {
|
|||
// char ca[4] = { 'p', 'E', 'p'};
|
|||
// char* c_str = ca;
|
|||
// pEp::String pstr(c_str);
|
|||
// }
|
|||
|
|||
// VALID USAGE
|
|||
// new pEp::String on char* pointing to NULL
|
|||
{ |
|||
pEpLogH1("new pEp::String on char* pointing to NULL"); |
|||
char* c_str = NULL; // nullptr
|
|||
|
|||
pEp::String pstr(&c_str); |
|||
test_assign_and_getters(&c_str, pstr); |
|||
} |
|||
|
|||
// new pEp::String on already initalized char*
|
|||
{ |
|||
pEpLogH1("new pEp::String on already initalized char*"); |
|||
char* c_str = strdup("initialized c string"); |
|||
|
|||
pEp::String pstr(&c_str); |
|||
test_assign_and_getters(&c_str, pstr); |
|||
} |
|||
|
|||
// initialize()
|
|||
{ |
|||
pEpLogH1("initialize()"); |
|||
pEp::String pstr{}; |
|||
|
|||
char* c_str = strdup("initialized c string"); |
|||
//TODO: PITYASSERT_THROWS
|
|||
pstr.initialize(&c_str); |
|||
|
|||
test_assign_and_getters(&c_str, pstr); |
|||
} |
|||
} |
|||
|
|||
setenv("HOME", ".", 1); |
|||
::init(&session, nullptr, nullptr, nullptr); |
|||
|
|||
// create identity
|
|||
pEp::Identity id1{ "wrong@entry.lol", "wrong", "23", "INVA_FPR" }; |
|||
|
|||
pEpLog(*id1); |
|||
id1.username = "alice"; |
|||
id1.address = "alice@peptest.org"; |
|||
pEpLog(id1.address); |
|||
pEpLog(id1.username); |
|||
::myself(session, id1); |
|||
pEpLog(*id1); |
|||
|
|||
pEp::Identity id2{ "bob" }; |
|||
::update_identity(session, id2); |
|||
pEpLog(*id2); |
|||
} |
|||
Loading…
Reference in new issue