summaryrefslogtreecommitdiffstats
path: root/src/mbedTLS++/BufferedSslContext.cpp
blob: 88b66c592cedb7e85fa367207246103cf1a00f3f (plain) (blame)
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);
}