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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
/**************************************************************************/
/* */
/* Copyright (c) 2001, 2009 NoMachine, http://www.nomachine.com/. */
/* */
/* NXCOMP, NX protocol compression and NX extensions to this software */
/* are copyright of NoMachine. Redistribution and use of the present */
/* software is allowed according to terms specified in the file LICENSE */
/* which comes in the source distribution. */
/* */
/* Check http://www.nomachine.com/licensing.html for applicability. */
/* */
/* NX and NoMachine are trademarks of Medialogic S.p.A. */
/* */
/* All rights reserved. */
/* */
/**************************************************************************/
#ifndef EncodeBuffer_H
#define EncodeBuffer_H
#include "IntCache.h"
#include "CharCache.h"
#include "XidCache.h"
#include "FreeCache.h"
#include "OpcodeCache.h"
#include "ActionCache.h"
#include "ActionCacheCompat.h"
#include "PositionCacheCompat.h"
#define ENCODE_BUFFER_DEFAULT_SIZE 16384
//
// This should match the maximum size of
// a single message added to write buffer
// (see WriteBuffer.h).
//
#define ENCODE_BUFFER_OVERFLOW_SIZE 4194304
//
// Adjust for the control messages and the
// frame length added by the proxy.
//
#define ENCODE_BUFFER_PREFIX_SIZE 64
//
// The encode routines may write one byte
// past the nominal end of the encode buffer.
// This additional byte is included in the
// payload. This is actually a harmless bug.
//
#define ENCODE_BUFFER_POSTFIX_SIZE 1
class EncodeBuffer
{
public:
EncodeBuffer();
~EncodeBuffer();
void setSize(unsigned int initialSize, unsigned int thresholdSize,
unsigned int maximumSize);
void encodeValue(unsigned int value, unsigned int numBits,
unsigned int blockSize = 0);
void encodeCachedValue(unsigned int value, unsigned int numBits,
IntCache &cache, unsigned int blockSize = 0);
void encodeCachedValue(unsigned char value, unsigned int numBits,
CharCache &cache, unsigned int blockSize = 0);
void encodeDiffCachedValue(const unsigned int value, unsigned int &previous,
unsigned int numBits, IntCache &cache,
unsigned int blockSize = 0)
{
encodeCachedValue((value - 1) - previous, numBits, cache, blockSize);
previous = value;
}
void encodeBoolValue(unsigned int value)
{
encodeValue(value, 1);
}
void encodeOpcodeValue(unsigned char value, OpcodeCache &cache)
{
encodeCachedValue(value, 8, cache.base_[cache.slot_], 8);
cache.slot_ = value;
}
void encodeActionValue(unsigned char value, ActionCache &cache)
{
unsigned short position = 0;
encodeActionValue(value, position, cache);
}
void encodeActionValue(unsigned char value, unsigned short position,
ActionCache &cache);
void encodeNewXidValue(unsigned int value, unsigned int &lastId,
IntCache &lastIdCache, IntCache &cache,
FreeCache &freeCache);
void encodeNewXidValue(unsigned int value, unsigned int &lastId,
IntCache &lastIdCache, XidCache &cache,
FreeCache &freeCache);
void encodeXidValue(unsigned int value, XidCache &cache);
void encodeFreeXidValue(unsigned int value, FreeCache &cache);
void encodeActionValueCompat(unsigned char value, ActionCacheCompat &cache)
{
encodeCachedValue(value, 2, cache.base_[cache.slot_]);
cache.slot_ = value;
}
void encodePositionValueCompat(short int value, PositionCacheCompat &cache);
void encodeTextData(const unsigned char *buffer, unsigned int numBytes)
{
encodeMemory(buffer, numBytes);
}
void encodeIntData(const unsigned char *buffer, unsigned int numBytes)
{
encodeMemory(buffer, numBytes);
}
void encodeLongData(const unsigned char *buffer, unsigned int numBytes)
{
encodeMemory(buffer, numBytes);
}
void encodeMemory(const unsigned char *buffer, unsigned int numBytes);
unsigned char *getData()
{
return buffer_;
}
unsigned int getLength() const;
unsigned int getBits() const
{
return ((nextDest_ - buffer_) << 3) + (7 - destShift_);
}
unsigned int diffBits();
void fullReset();
private:
void growBuffer(unsigned int numBytes = 0);
void alignBuffer();
unsigned int size_;
unsigned char *buffer_;
//
// This points to the first byte
// just beyond end of the buffer.
//
const unsigned char *end_;
unsigned char *nextDest_;
unsigned int destShift_;
unsigned int lastBits_;
unsigned int initialSize_;
unsigned int thresholdSize_;
unsigned int maximumSize_;
};
#endif /* EncodeBuffer_H */
|
