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
|
// SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
//
// SPDX-License-Identifier: LGPL-2.1-or-later
#ifndef OMEMOLIBWRAPPERS_H
#define OMEMOLIBWRAPPERS_H
#include <key_helper.h>
#include <session_builder.h>
#include <session_cipher.h>
#include <signal_protocol.h>
#include <QByteArray>
// Wraps various types of the OMEMO library.
template<typename T, void(destruct)(T *)>
class OmemoLibPtr
{
T *m_ptr = nullptr;
public:
OmemoLibPtr(T *ptr = nullptr) : m_ptr(ptr) { }
OmemoLibPtr(const OmemoLibPtr &) = delete;
~OmemoLibPtr()
{
if (m_ptr) {
destruct(m_ptr);
}
}
OmemoLibPtr &operator=(const OmemoLibPtr &) = delete;
OmemoLibPtr<T, destruct> &operator=(T *ptr)
{
reset(ptr);
return *this;
}
operator bool() const { return m_ptr != nullptr; }
T *operator->() const { return m_ptr; }
T *get() const { return m_ptr; }
T **ptrRef() { return &m_ptr; }
void reset(T *ptr)
{
if (m_ptr) {
destruct(m_ptr);
}
m_ptr = ptr;
}
};
template<typename T>
void omemoLibUnrefHelper(T *ptr)
{
SIGNAL_UNREF(ptr);
}
template<typename T>
using RefCountedPtr = OmemoLibPtr<T, omemoLibUnrefHelper<T>>;
static QByteArray omemoLibBufferToByteArray(signal_buffer *buffer)
{
return QByteArray(reinterpret_cast<const char *>(signal_buffer_data(buffer)), signal_buffer_len(buffer));
}
static signal_buffer *omemoLibBufferFromByteArray(const QByteArray &bytes)
{
return signal_buffer_create(reinterpret_cast<const unsigned char *>(bytes.constData()), bytes.size());
}
template<void(destruct)(signal_buffer *)>
class BufferPtrBase : public OmemoLibPtr<signal_buffer, destruct>
{
public:
BufferPtrBase(signal_buffer *ptr)
: OmemoLibPtr<signal_buffer, destruct>(ptr)
{
}
QByteArray toByteArray() const
{
return omemoLibBufferToByteArray(this->get());
}
};
class BufferSecurePtr : public BufferPtrBase<signal_buffer_bzero_free>
{
public:
BufferSecurePtr() : BufferPtrBase<signal_buffer_bzero_free>(nullptr) { }
BufferSecurePtr(signal_buffer *ptr)
: BufferPtrBase<signal_buffer_bzero_free>(ptr)
{
}
static BufferSecurePtr fromByteArray(const QByteArray &bytes)
{
return { omemoLibBufferFromByteArray(bytes) };
}
};
class BufferPtr : public BufferPtrBase<signal_buffer_free>
{
public:
BufferPtr() : BufferPtrBase<signal_buffer_free>(nullptr) { }
BufferPtr(signal_buffer *ptr)
: BufferPtrBase<signal_buffer_free>(ptr)
{
}
static BufferPtr fromByteArray(const QByteArray &bytes)
{
return { omemoLibBufferFromByteArray(bytes) };
}
};
using KeyListNodePtr = OmemoLibPtr<signal_protocol_key_helper_pre_key_list_node, signal_protocol_key_helper_key_list_free>;
using SessionCipherPtr = OmemoLibPtr<session_cipher, session_cipher_free>;
using SessionBuilderPtr = OmemoLibPtr<session_builder, session_builder_free>;
using OmemoContextPtr = OmemoLibPtr<signal_context, signal_context_destroy>;
using StoreContextPtr = OmemoLibPtr<signal_protocol_store_context, signal_protocol_store_context_destroy>;
#endif // OMEMOLIBWRAPPERS_H
|
