forked from nodejs/node
-
Notifications
You must be signed in to change notification settings - Fork 0
/
node_crypto_bio.h
118 lines (89 loc) · 2.79 KB
/
node_crypto_bio.h
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
#ifndef SRC_NODE_CRYPTO_BIO_H_
#define SRC_NODE_CRYPTO_BIO_H_
#include "openssl/bio.h"
#include "util.h"
#include "util-inl.h"
namespace node {
class NodeBIO {
public:
NodeBIO() : initial_(kInitialBufferLength),
length_(0),
read_head_(nullptr),
write_head_(nullptr) {
}
~NodeBIO();
static BIO* New();
// Move read head to next buffer if needed
void TryMoveReadHead();
// Allocate new buffer for write if needed
void TryAllocateForWrite(size_t hint);
// Read `len` bytes maximum into `out`, return actual number of read bytes
size_t Read(char* out, size_t size);
// Memory optimization:
// Deallocate children of write head's child if they're empty
void FreeEmpty();
// Return pointer to internal data and amount of
// contiguous data available to read
char* Peek(size_t* size);
// Return pointers and sizes of multiple internal data chunks available for
// reading
size_t PeekMultiple(char** out, size_t* size, size_t* count);
// Find first appearance of `delim` in buffer or `limit` if `delim`
// wasn't found.
size_t IndexOf(char delim, size_t limit);
// Discard all available data
void Reset();
// Put `len` bytes from `data` into buffer
void Write(const char* data, size_t size);
// Return pointer to internal data and amount of
// contiguous data available for future writes
char* PeekWritable(size_t* size);
// Commit reserved data
void Commit(size_t size);
// Return size of buffer in bytes
inline size_t Length() const {
return length_;
}
inline void set_initial(size_t initial) {
initial_ = initial;
}
static inline NodeBIO* FromBIO(BIO* bio) {
CHECK_NE(bio->ptr, nullptr);
return static_cast<NodeBIO*>(bio->ptr);
}
private:
static int New(BIO* bio);
static int Free(BIO* bio);
static int Read(BIO* bio, char* out, int len);
static int Write(BIO* bio, const char* data, int len);
static int Puts(BIO* bio, const char* str);
static int Gets(BIO* bio, char* out, int size);
static long Ctrl(BIO* bio, int cmd, long num, void* ptr);
// Enough to handle the most of the client hellos
static const size_t kInitialBufferLength = 1024;
static const size_t kThroughputBufferLength = 16384;
static const BIO_METHOD method;
class Buffer {
public:
explicit Buffer(size_t len) : read_pos_(0),
write_pos_(0),
len_(len),
next_(nullptr) {
data_ = new char[len];
}
~Buffer() {
delete[] data_;
}
size_t read_pos_;
size_t write_pos_;
size_t len_;
Buffer* next_;
char* data_;
};
size_t initial_;
size_t length_;
Buffer* read_head_;
Buffer* write_head_;
};
} // namespace node
#endif // SRC_NODE_CRYPTO_BIO_H_