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
|
// BufferedSslContext.cpp
// Implements the cBufferedSslContext class representing a SSL context with the SSL peer data backed by a cByteBuffer
#include "Globals.h"
#include "BufferedSslContext.h"
cBufferedSslContext::cBufferedSslContext(size_t a_BufferSize):
m_OutgoingData(a_BufferSize),
m_IncomingData(a_BufferSize)
{
}
size_t cBufferedSslContext::WriteIncoming(const void * a_Data, size_t a_NumBytes)
{
size_t NumBytes = std::min(m_IncomingData.GetFreeSpace(), a_NumBytes);
if (NumBytes > 0)
{
m_IncomingData.Write(a_Data, NumBytes);
return NumBytes;
}
return 0;
}
size_t cBufferedSslContext::ReadOutgoing(void * a_Data, size_t a_DataMaxSize)
{
size_t NumBytes = std::min(m_OutgoingData.GetReadableSpace(), a_DataMaxSize);
if (NumBytes > 0)
{
m_OutgoingData.ReadBuf(a_Data, NumBytes);
m_OutgoingData.CommitRead();
return NumBytes;
}
return 0;
}
int cBufferedSslContext::ReceiveEncrypted(unsigned char * a_Buffer, size_t a_NumBytes)
{
// Called when mbedTLS wants to read encrypted data from the SSL peer
// Read the data from the buffer inside this object, where the owner has stored them using WriteIncoming():
size_t NumBytes = std::min(a_NumBytes, m_IncomingData.GetReadableSpace());
if (NumBytes == 0)
{
return MBEDTLS_ERR_SSL_WANT_READ;
}
if (!m_IncomingData.ReadBuf(a_Buffer, NumBytes))
{
m_IncomingData.ResetRead();
return MBEDTLS_ERR_NET_RECV_FAILED;
}
m_IncomingData.CommitRead();
return static_cast<int>(NumBytes);
}
int cBufferedSslContext::SendEncrypted(const unsigned char * a_Buffer, size_t a_NumBytes)
{
// Called when mbedTLS wants to write encrypted data to the SSL peer
// Write the data into the buffer inside this object, where the owner can later read them using ReadOutgoing():
if (!m_OutgoingData.CanWriteBytes(a_NumBytes))
{
return MBEDTLS_ERR_SSL_WANT_WRITE;
}
if (!m_OutgoingData.Write(reinterpret_cast<const char *>(a_Buffer), a_NumBytes))
{
return MBEDTLS_ERR_NET_SEND_FAILED;
}
return static_cast<int>(a_NumBytes);
}
|
