Newer
Older
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
#include <regex>
#include <stdexcept>
#include <string>
#include "codec_stack_builder.hh"
#include "http_codec.hh"
#include "loggers.hh"
#include "LibHttp_TypesAndValues.hh"
#include "LibHttp_MessageBodyTypes.hh"
#include "LibHttp_XmlMessageBodyTypes.hh"
#include "LibHttp_JsonMessageBodyTypes.hh"
int http_codec::encode(const LibHttp__TypesAndValues::HttpMessage &msg, OCTETSTRING &data) {
loggers::get_instance().log_msg(">>> http_codec::encode: ", (const Base_Type &)msg);
loggers::get_instance().log(">>> http_codec::encode: %p", this);
TTCN_EncDec::clear_error();
TTCN_Buffer encoding_buffer;
_ec.reset();
int result;
if (msg.ischosen(LibHttp__TypesAndValues::HttpMessage::ALT_request)) {
result = encode_request(msg.request(), encoding_buffer);
} else if (msg.ischosen(LibHttp__TypesAndValues::HttpMessage::ALT_response)) {
result = encode_response(msg.response(), encoding_buffer);
} else {
loggers::get_instance().warning("http_codec::encode: Unbound HttpMessage");
return -1;
}
data = OCTETSTRING(encoding_buffer.get_len(), encoding_buffer.get_data());
loggers::get_instance().log_msg("<<< http_codec::encode: data=", data);
return result;
}
int http_codec::decode(const OCTETSTRING &data, LibHttp__TypesAndValues::HttpMessage &msg, params *params) {
loggers::get_instance().log_msg(">>> http_codec::decode: data=", data);
TTCN_EncDec::clear_error();
TTCN_Buffer decoding_buffer;
if (_initial_content_length != 0) { // Check if the data is a new fragment of the response
loggers::get_instance().warning("http_codec::decode: Need to bufferize and wait for all fragments received");
_bufferized_buffers.push_back(data);
_current_content_length += data.lengthof(); // FIXME Need to calculate the size of the header buffer, do not assume th first fragmwnt is the header buffer
loggers::get_instance().log("http_codec::decode: _bufferized_buffers size: %d - _current_content_length: %d - _initial_content_length: %d", _bufferized_buffers.size(), _current_content_length, _initial_content_length);
if (_current_content_length < _initial_content_length) { // Wait for the next fragment
loggers::get_instance().warning("http_codec::decode: Wait for the next fragment");
return -2;
} else { // Rebuild the wall message and continue the decoding
loggers::get_instance().log("http_codec::decode: All the fragments were received, rebuild message");
// Concatenate the fragments
loggers::get_instance().log("http_codec::decode: Concatenate bufferized datas");
for (size_t i = 0; i < _bufferized_buffers.size(); i++) {
decoding_buffer.put_string(_bufferized_buffers[i]);
} // End of 'for' statement
_bufferized_buffers.clear();
loggers::get_instance().log("http_codec::decode: _bufferized_buffers cleared: %d", _bufferized_buffers.size());
// Reset counters
loggers::get_instance().log("http_codec::decode: Reset bufferization counters");
_initial_content_length = 0;
_current_content_length = 0;
// Continue the decoding
}
} else { // It can be a full HTTP response or the first gragment of the HTTP response
decoding_buffer.put_string(data);
}
loggers::get_instance().log("http_codec::decode: decoding_buffer size: %d", decoding_buffer.get_len());
loggers::get_instance().log_to_hexa("http_codec::decode: Before decoding_buffer Body: ", decoding_buffer);
if ((*decoding_buffer.get_data() & 0x80) == 0x80) {
loggers::get_instance().warning("http_codec::decode: Unicode format not supported");
return -1;
}
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
// Get the first line (e.g. HTTP/1.1 302 Found or POST / HTTP/1.1)
CHARSTRING message_id;
if (get_line(decoding_buffer, message_id) == -1) {
loggers::get_instance().warning("http_codec::decode: get_line failed, errno: %d", errno);
return -1;
}
loggers::get_instance().log_msg("http_codec::decode: message_id: ", message_id);
// Extract parameters
try {
std::string str(static_cast<const char *>(message_id));
std::regex rgx("\\s*(\\w+)/");
std::sregex_iterator begin(str.cbegin(), str.cend(), rgx);
std::smatch m = *begin;
loggers::get_instance().log("http_codec::decode: %d - %s", m.size(), m[0].str().c_str());
if (m[0].str().compare("HTTP/") == 0) { // HTTP response
LibHttp__TypesAndValues::Response response;
std::regex rgx("\\s*HTTP/(\\d+)\\.(\\d+)\\s+(\\d+)\\s+([\\w\\s\\t\\v\\f]+)*");
std::sregex_iterator begin(str.cbegin(), str.cend(), rgx);
std::smatch m = *begin;
loggers::get_instance().log("http_codec::decode: Process response: %d", m.size());
if (m.size() != 5) {
loggers::get_instance().warning("http_codec::decode: Unsupported tag");
return -1;
}
response.version__major() = std::stoi(m[1].str().c_str());
response.version__minor() = std::stoi(m[2].str().c_str());
response.statuscode() = std::stoi(m[3].str().c_str());
response.statustext() = CHARSTRING(m[4].str().c_str());
LibHttp__TypesAndValues::Headers headers;
decode_headers(decoding_buffer, headers, content_type);
loggers::get_instance().log("http_codec::decode: _dc.length=%d", _dc.length);
loggers::get_instance().log("http_codec::decode: decoding_buffer.get_len()=%d", decoding_buffer.get_len());
if (_dc.length > decoding_buffer.get_len()) { // HTTP response is fragmented
// Need to bufferize the first packet and wait for the other fragments tp be received
loggers::get_instance().warning("http_codec::decode: Need to bufferize the first packet and wait for the other fragments tp be received");
// Set counters
loggers::get_instance().log("http_codec::decode: Set bufferization counters");
_initial_content_length = _dc.length;
_current_content_length = 0;
_bufferized_buffers.push_back(data);
_current_content_length += data.lengthof();
loggers::get_instance().log("http_codec::decode: _bufferized_buffers size: %d - _current_content_length: %d", _bufferized_buffers.size(), _current_content_length);
return -2;
} else {
// Force reset counters
loggers::get_instance().log("http_codec::decode: Force reset bufferization counters");
_initial_content_length = 0;
_current_content_length = 0;
}
response.header() = headers;
loggers::get_instance().log_to_hexa("Before decoding Body: ", decoding_buffer);
loggers::get_instance().log("http_codec::decode: _initial_content_length = %d", _initial_content_length);
loggers::get_instance().log("http_codec::decode: headers().content_length (_dc.length) = %d - decoding_buffer.get_len() = %d", _dc.length, decoding_buffer.get_len());
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
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
LibHttp__MessageBodyTypes::HttpMessageBody body;
if (decode_body(decoding_buffer, body, content_type) == -1) {
response.body().set_to_omit();
} else {
response.body() = OPTIONAL<LibHttp__MessageBodyTypes::HttpMessageBody>(body);
}
// Add lower layers parameters
loggers::get_instance().log("http_codec::decode: Add lower layers parameters");
params->log();
params::const_iterator it = params->find(params::use_ssl);
if (it != params->cend()) {
loggers::get_instance().log("http_codec::receive_data: tls=%s", it->second.c_str());
response.tls() = (it->second.compare("1") == 0) ? true : false;
} else {
response.tls().set_to_omit();
}
it = params->find(params::mutual_auth);
if (it != params->cend()) {
loggers::get_instance().log("http_codec::receive_data: mutual_tls=%s", it->second.c_str());
response.mutual__tls() = (it->second.compare("1") == 0) ? true : false;
} else {
response.mutual__tls().set_to_omit();
}
msg.response() = response;
} else { // HTTP request
LibHttp__TypesAndValues::Request request;
std::regex rgx("\\s*(\\w+)\\s+(.+)\\s+HTTP/(\\d)\\.(\\d)");
std::sregex_iterator begin(str.cbegin(), str.cend(), rgx);
std::smatch m = *begin;
if (m.size() != 5) {
loggers::get_instance().error("http_codec::decode: Unsupported tag");
return -1;
}
request.method() = CHARSTRING(m[1].str().c_str());
request.uri() = CHARSTRING(m[2].str().c_str());
request.version__major() = std::stoi(m[3].str().c_str());
request.version__minor() = std::stoi(m[4].str().c_str());
LibHttp__TypesAndValues::Headers headers;
std::string content_type;
decode_headers(decoding_buffer, headers, content_type);
request.header() = headers;
OPTIONAL<LibHttp__MessageBodyTypes::HttpMessageBody> body;
body.set_to_omit();
if (decode_body(decoding_buffer, body, content_type) == -1) {
request.body().set_to_omit();
} else {
request.body() = body;
}
msg.request() = request;
}
loggers::get_instance().log_msg("<<< http_codec::decode: ", (const Base_Type &)msg);
return 0;
} catch (const std::logic_error &e) {
return -1;
}
}
int http_codec::encode_request(const LibHttp__TypesAndValues::Request &p_request, TTCN_Buffer &p_encoding_buffer) {
loggers::get_instance().log_msg(">>> http_codec::encode_request: ", (const Base_Type &)p_request);
// Encode generic part
p_encoding_buffer.put_cs(p_request.method());
p_encoding_buffer.put_c(' ');
p_encoding_buffer.put_cs(p_request.uri());
p_encoding_buffer.put_cs(" HTTP/");
p_encoding_buffer.put_cs(int2str(p_request.version__major()));
p_encoding_buffer.put_c('.');
p_encoding_buffer.put_cs(int2str(p_request.version__minor()));
p_encoding_buffer.put_cs("\r\n");
// Encode headers excepeted the Content-Length
const LibHttp__TypesAndValues::Headers &headers = p_request.header();
std::string content_type;
for (int i = 0; i < headers.size_of(); i++) {
const LibHttp__TypesAndValues::Header &header = headers[i];
loggers::get_instance().log_msg("http_codec::encode_request: Processing header ", header.header__name());
if (std::string(static_cast<const char *>(header.header__name())).compare("Content-Length") == 0) { // Skip it, processed later
loggers::get_instance().log("http_codec::encode_request: Skip it");
continue;
} else {
p_encoding_buffer.put_cs(header.header__name());
p_encoding_buffer.put_cs(": ");
const OPTIONAL<LibHttp__TypesAndValues::charstring__list> &o = header.header__value();
if (o.ispresent()) {
const LibHttp__TypesAndValues::charstring__list &v = dynamic_cast<const OPTIONAL<LibHttp__TypesAndValues::charstring__list> &>(o);
if (v.size_of() > 0) {
loggers::get_instance().log_msg("http_codec::encode_request: Processing value ", v[0]);
if (std::string(static_cast<const char *>(header.header__name())).compare("Content-Type") == 0) { // Store it for HTTP body payload encoding
loggers::get_instance().log("http_codec::encode_request: Storing Content-Type");
int j = 0;
while (j < v.size_of()) {
content_type += v[j++];
} // End of 'while' statement
}
p_encoding_buffer.put_cs(v[0]);
int j = 1;
while (j < v.size_of()) {
p_encoding_buffer.put_cs(", ");
loggers::get_instance().log_msg("http_codec::encode_request: Processing value ", v[j]);
p_encoding_buffer.put_cs(v[j++]);
} // End of 'while' statement
}
} // else, do not include it
}
p_encoding_buffer.put_cs("\r\n");
} // End of 'for' statement
// Encode message body
const OPTIONAL<LibHttp__MessageBodyTypes::HttpMessageBody> &v = p_request.body();
OCTETSTRING os;
if (v.ispresent()) {
const LibHttp__MessageBodyTypes::HttpMessageBody &body = static_cast<const LibHttp__MessageBodyTypes::HttpMessageBody &>(*v.get_opt_value());
loggers::get_instance().log_msg("http_codec::encode_request: body: ", body);
if (encode_body(body, os, content_type) == -1) {
loggers::get_instance().warning("http_codec::encode_request: Failed to encode HTTP body");
_ec.length = 0;
_ec.is_content_length_present = 0x00;
} else {
_ec.length = os.lengthof();
_ec.is_content_length_present = 0x01;
}
loggers::get_instance().log("http_codec::encode_request: length=%d", _ec.length);
} else {
loggers::get_instance().log("http_codec::encode_request: HTTP body field not present");
_ec.length = 0;
_ec.is_content_length_present = 0x00;
}
// Encode Content-Length header
p_encoding_buffer.put_cs("Content-Length: ");
if (_ec.length != 0) {
loggers::get_instance().log("http_codec::encode_request: Content-Length: '%s'",
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
static_cast<const char *>(int2str(_ec.length + 2 /*Stand for the last CRLF*/)));
p_encoding_buffer.put_cs(static_cast<const char *>(int2str(_ec.length)));
_ec.is_content_length_present = 0x01;
} else {
p_encoding_buffer.put_cs("0");
_ec.is_content_length_present = 0x00;
}
loggers::get_instance().log("http_codec::encode_request: Content-Length: %d - %x", _ec.length, _ec.is_content_length_present);
p_encoding_buffer.put_cs("\r\n");
// Add message body
p_encoding_buffer.put_cs("\r\n");
if (_ec.is_content_length_present == 0x01) {
loggers::get_instance().log_msg("http_codec::encode_request: Add body ", os);
p_encoding_buffer.put_os(os);
// p_encoding_buffer.put_cs("\r\n");
}
loggers::get_instance().log_to_hexa("<<< http_codec::encode_request: ", p_encoding_buffer);
return 0;
}
int http_codec::encode_response(const LibHttp__TypesAndValues::Response &p_response, TTCN_Buffer &p_encoding_buffer) {
loggers::get_instance().log_msg(">>> http_codec::encode_response: ", (const Base_Type &)p_response);
// Encode generic part
p_encoding_buffer.put_cs("HTTP/");
p_encoding_buffer.put_cs(int2str(p_response.version__major()));
p_encoding_buffer.put_c('.');
p_encoding_buffer.put_cs(int2str(p_response.version__minor()));
p_encoding_buffer.put_cs(" ");
p_encoding_buffer.put_cs(int2str(p_response.statuscode()));
p_encoding_buffer.put_cs(" ");
if (p_response.statustext().lengthof() != 0) {
p_encoding_buffer.put_cs(p_response.statustext());
}
p_encoding_buffer.put_cs("\r\n");
// Encode headers excepeted the Content-Length
const LibHttp__TypesAndValues::Headers &headers = p_response.header();
std::string content_type;
for (int i = 0; i < headers.size_of(); i++) {
const LibHttp__TypesAndValues::Header &header = headers[i];
loggers::get_instance().log_msg("http_codec::encode_response: Processing header ", header.header__name());
if (std::string(static_cast<const char *>(header.header__name())).compare("Content-Length") == 0) {
continue;
} else {
p_encoding_buffer.put_cs(header.header__name());
p_encoding_buffer.put_cs(": ");
const OPTIONAL<LibHttp__TypesAndValues::charstring__list> &o = header.header__value();
if (o.ispresent()) {
const LibHttp__TypesAndValues::charstring__list &v = dynamic_cast<const OPTIONAL<LibHttp__TypesAndValues::charstring__list> &>(o);
if (v.size_of() > 0) {
loggers::get_instance().log_msg("http_codec::encode_response: Processing value ", v[0]);
if (std::string(static_cast<const char *>(header.header__name())).compare("Content-Type") == 0) { // Store it for HTTP body payload encoding
loggers::get_instance().log("http_codec::encode_response: Storing Content-Type");
int j = 0;
while (j < v.size_of()) {
content_type += v[j++];
} // End of 'while' statement
}
p_encoding_buffer.put_cs(v[0]);
int j = 1;
while (j < v.size_of()) {
p_encoding_buffer.put_cs(", ");
loggers::get_instance().log_msg("http_codec::encode_response: Processing value ", v[j]);
p_encoding_buffer.put_cs(v[j++]);
j += 1;
} // End of 'while' statement
}
} // else, do not include it
}
p_encoding_buffer.put_cs("\r\n");
} // End of 'for' statement
// Encode message body
const OPTIONAL<LibHttp__MessageBodyTypes::HttpMessageBody> &v = p_response.body();
OCTETSTRING os;
if (v.ispresent()) {
const LibHttp__MessageBodyTypes::HttpMessageBody &body = static_cast<const LibHttp__MessageBodyTypes::HttpMessageBody &>(*v.get_opt_value());
loggers::get_instance().log_msg("http_codec::encode_response: body: ", body);
if (encode_body(body, os, content_type) == -1) {
_ec.length = 0;
_ec.is_content_length_present = 0x00;
} else {
_ec.length = os.lengthof();
_ec.is_content_length_present = 0x01;
}
loggers::get_instance().log("http_codec::encode_response: length=%d", _ec.length);
} else {
loggers::get_instance().log("http_codec::encode_response: HTTP body field not present");
_ec.length = 0;
_ec.is_content_length_present = 0x00;
}
// Encode Content-Length header
p_encoding_buffer.put_cs("Content-Length: ");
if (_ec.length != 0) {
loggers::get_instance().log("http_codec::encode_request: Content-Length: '%s'",
static_cast<const char *>(int2str(_ec.length + 2 /*Stand for the last CRLF*/)));
p_encoding_buffer.put_cs(static_cast<const char *>(int2str(_ec.length)));
_ec.is_content_length_present = 0x01;
} else {
p_encoding_buffer.put_cs("0");
_ec.is_content_length_present = 0x00;
}
loggers::get_instance().log("http_codec::encode_request: Content-Length: %d - %x", _ec.length, _ec.is_content_length_present);
p_encoding_buffer.put_cs("\r\n");
// Add message body
p_encoding_buffer.put_cs("\r\n");
if (_ec.is_content_length_present == 0x01) {
loggers::get_instance().log_msg("http_codec::encode_request: Add body ", os);
p_encoding_buffer.put_os(os);
// p_encoding_buffer.put_cs("\r\n");
}
loggers::get_instance().log_to_hexa("<<< http_codec::encode_response: ", p_encoding_buffer);
return 0;
}
int http_codec::decode_headers(TTCN_Buffer &decoding_buffer, LibHttp__TypesAndValues::Headers &headers, std::string& p_content_type) {
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
loggers::get_instance().log(">>> http_codec::decode_headers");
loggers::get_instance().log_to_hexa("http_codec::decode_headers: ", decoding_buffer);
CHARSTRING cstr;
int i = 0;
while (true) {
switch (get_line(decoding_buffer, cstr, true)) {
case 0: {
loggers::get_instance().log_msg("http_codec::decode_headers: ", cstr);
LibHttp__TypesAndValues::Header header;
if (decode_header(cstr, header) == -1) {
loggers::get_instance().warning("http_codec::decode_headers: Failed to decode header %s", static_cast<const char *>(cstr));
return -1;
}
headers[i++] = header;
if (std::string(static_cast<const char *>(header.header__name())).compare("Content-Type") == 0) {
if (header.header__value().is_present() != 0) {
const PreGenRecordOf::PREGEN__RECORD__OF__CHARSTRING &l =
static_cast<const PreGenRecordOf::PREGEN__RECORD__OF__CHARSTRING &>(*header.header__value().get_opt_value());
p_content_type = static_cast<const char *>(l[0]);
} else {
p_content_type = "";
}
}
} break;
case 1:
if (headers.is_bound()) {
if (_dc.length == -1) { // content-Length header not found, force length to 0, assuming no body is present
loggers::get_instance().log("http_codec::decode_headers: Force _dc.length to 0");
_dc.length = 0;
}
loggers::get_instance().log_msg("<<< http_codec::decode_headers: ", headers);
return 0;
} else {
loggers::get_instance().warning("http_codec::decode_headers: Failed to decode headers");
return -1;
}
case -1:
loggers::get_instance().warning("http_codec::decode_headers: Failed to decode headers");
return -1;
} // End of 'switch' statement
} // End of 'while' statement
}
int http_codec::decode_header(CHARSTRING &header_line, LibHttp__TypesAndValues::Header &header) {
loggers::get_instance().log_msg(">>> http_codec::decode_header: ", header_line);
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
try {
std::string str(static_cast<const char *>(header_line));
std::regex rgx("([0-9a-zA-Z-]+)\\:\\s+(.+)(,(.+))*");
std::sregex_iterator begin(str.cbegin(), str.cend(), rgx);
std::smatch m = *begin;
if (m.size() < 5) {
loggers::get_instance().warning("http_codec::decode_header: Failed to decode header %s", str.c_str());
return -1;
}
loggers::get_instance().log("http_codec::decode_header: %d", m.size());
header.header__name() = CHARSTRING(m[1].str().c_str());
LibHttp__TypesAndValues::charstring__list v;
for (unsigned int j = 0; j < m.size(); j++) {
if (m[j + 2].str().length() == 0) {
break;
}
v[j] = CHARSTRING(m[j + 2].str().c_str());
} // End of 'for' statement
header.header__value() = OPTIONAL<LibHttp__TypesAndValues::charstring__list>(v);
if (m[1].str().compare("Content-Length") == 0) {
// Save the the body length
loggers::get_instance().log("http_codec::decode_header: decoded Content-Length %s", m[2].str().c_str());
_dc.length = std::stoi(m[2].str());
} else if (m[1].str().compare("Transfer-Encoding") == 0) {
if (m[2].str().find("chunked") != std::string::npos) {
_dc.chunked = true;
loggers::get_instance().log("http_codec::decode_header: decoded Transfer-Encoding %x", _dc.chunked);
}
}
return 0;
} catch (const std::logic_error &e) {
return -1;
}
}
int http_codec::encode_body(const LibHttp__MessageBodyTypes::HttpMessageBody &p_message_body, OCTETSTRING &p_encoding_buffer,
loggers::get_instance().log_msg(">>> http_codec::encode_body: ", (const Base_Type &)p_message_body);
// Sanity check
if (p_content_type.empty()) {
loggers::get_instance().warning("http_codec::encode_body: Failed to select a codec for HTTP body payload");
return -1;
}
if (p_message_body.ischosen(LibHttp__MessageBodyTypes::HttpMessageBody::ALT_binary__body)) {
const LibHttp__BinaryMessageBodyTypes::BinaryBody &binary_body = p_message_body.binary__body();
if (binary_body.ischosen(LibHttp__BinaryMessageBodyTypes::BinaryBody::ALT_raw)) {
p_encoding_buffer = OCTETSTRING(binary_body.raw().lengthof(), (unsigned char *)static_cast<const unsigned char *>(binary_body.raw()));
} else {
encode_body_binary(binary_body, p_encoding_buffer, p_content_type);
}
} else if (p_message_body.ischosen(LibHttp__MessageBodyTypes::HttpMessageBody::ALT_json__body)) {
const LibHttp__JsonMessageBodyTypes::JsonBody& json_body = p_message_body.json__body();
if (json_body.ischosen(LibHttp__JsonMessageBodyTypes::JsonBody::ALT_raw)) {
p_encoding_buffer = unichar2oct(json_body.raw());
} else {
encode_body_json(json_body, p_encoding_buffer, p_content_type);
}
} else if (p_message_body.ischosen(LibHttp__MessageBodyTypes::HttpMessageBody::ALT_xml__body)) {
const LibHttp__XmlMessageBodyTypes::XmlBody &xml_body = p_message_body.xml__body();
if (xml_body.msg().ischosen(LibHttp__XmlMessageBodyTypes::XmlBodyMsg::ALT_raw)) {
p_encoding_buffer = OCTETSTRING(xml_body.msg().raw().lengthof(), (unsigned char *)static_cast<const char *>(xml_body.msg().raw()));
} else {
encode_body_xml(xml_body, p_encoding_buffer, p_content_type);
}
} else if (p_message_body.ischosen(LibHttp__MessageBodyTypes::HttpMessageBody::ALT_html__body)) {
p_encoding_buffer = OCTETSTRING(p_message_body.html__body().lengthof(), (unsigned char *)static_cast<const char *>(p_message_body.html__body()));
} else if (p_message_body.ischosen(LibHttp__MessageBodyTypes::HttpMessageBody::ALT_text__body)) {
p_encoding_buffer = OCTETSTRING(p_message_body.text__body().lengthof(), (unsigned char *)static_cast<const char *>(p_message_body.text__body()));
} else {
loggers::get_instance().warning("http_codec::encode_body: Failed to encode HTTP message body");
return -1;
}
loggers::get_instance().log_msg("http_codec::encode_body: HTTP message ", p_encoding_buffer);
_ec.length = p_encoding_buffer.lengthof();
loggers::get_instance().log("http_codec::encode_body: HTTP message length: %d", _ec.length);
return 0;
}
int http_codec::decode_body(TTCN_Buffer &decoding_buffer, LibHttp__MessageBodyTypes::HttpMessageBody &message_body, const std::string& p_content_type) {
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
loggers::get_instance().log(">>> http_codec::decode_body");
loggers::get_instance().log_to_hexa("http_codec::decode_body", decoding_buffer);
loggers::get_instance().log("http_codec::decode_body: # of codecs=%d - %p", _codecs.size(), this);
loggers::get_instance().log("http_codec::decode_body: Content-Type=%s", p_content_type.c_str());
// Sanity checks
if (decoding_buffer.get_len() - decoding_buffer.get_pos() <= 0) {
return -1;
}
/* TODO Uncomment if (p_content_type.empty()) {
loggers::get_instance().warning("http_codec::encode_body: Failed to select a codec for HTTP body payload");
return -1;
}*/
OCTETSTRING s(decoding_buffer.get_len() - decoding_buffer.get_pos(), decoding_buffer.get_data() + decoding_buffer.get_pos());
loggers::get_instance().log_msg("http_codec::decode_body: raw body=", s);
// Align the payload length with the specified Content-Lenght value
loggers::get_instance().log("http_codec::decode_body: _dc.length=%d - body length=%d", _dc.length, s.lengthof());
OCTETSTRING body;
if (_dc.length != 0) {
const unsigned char *p = static_cast<const unsigned char *>(s);
if ((unsigned int)s.lengthof() <= _dc.length) {
body = OCTETSTRING(s.lengthof(), p);
} else {
body = OCTETSTRING(_dc.length, p);
}
} else {
loggers::get_instance().warning("http_codec::decode_body: No Conten-Length header, process all remaining bytes");
body = s;
}
loggers::get_instance().log_msg("http_codec::decode_body: Aligned body=", body);
loggers::get_instance().log("http_codec::decode_body: body length=%d", body.lengthof());
/* TODO To be removed
// Remove CRLF if any
int counter = 0;
if ((body[body.lengthof() - 1].get_octet() == 0x0d) || (body[body.lengthof() - 1].get_octet() == 0x0a)) {
counter += 1;
if ((body[body.lengthof() - 2].get_octet() == 0x0d) || (body[body.lengthof() - 2].get_octet() == 0x0a)) {
counter += 1;
}
}
loggers::get_instance().log("http_codec::decode_body: counter=%d", counter);
body = OCTETSTRING(body.lengthof() - counter, static_cast<const unsigned char*>(body));
*/
if (_dc.chunked) {
int counter = 0;
int prev = 0;
OCTETSTRING os(0, nullptr);
do {
while (counter < body.lengthof()) { // Extract the size of the chunk <chunk size>\r[\n]
if ((body[counter].get_octet() == '\r') || (body[counter].get_octet() == '\n')) {
break;
}
counter += 1;
} // End of 'while' statement
loggers::get_instance().log("http_codec::decode_body: Chunked(0): prev = %d, counter=%d / %d", prev, counter, body.lengthof());
if (counter < body.lengthof()) {
int idx = counter - prev;
OCTETSTRING trunk(idx, static_cast<const unsigned char *>(body));
loggers::get_instance().log_msg("http_codec::decode_body: trunk: ", trunk);
std::string str((const char *)static_cast<const unsigned char *>(trunk), idx);
loggers::get_instance().log("http_codec::decode_body: str: '%s'", str.c_str());
int len = std::stoi(str, nullptr, 16); // converter::get_instance().string_to_int(str);
loggers::get_instance().log("http_codec::decode_body: Chunk len: %d", len);
while (counter < body.lengthof() && ((body[counter].get_octet() == '\r') || (body[counter].get_octet() == '\n'))) { // Skip additional \n
counter += 1;
} // End of 'while' statement
if (counter < body.lengthof()) {
loggers::get_instance().log("http_codec::decode_body: Chunked (1): prev = %d, counter=%d / %d", prev, counter, body.lengthof());
os += OCTETSTRING(len, counter + static_cast<const unsigned char *>(body));
loggers::get_instance().log_msg("http_codec::decode_body: os=", os);
counter += len;
loggers::get_instance().log("http_codec::decode_body: Chunked: %02x %02x %02x", body[counter].get_octet(), body[counter + 1].get_octet(),
body[counter + 2].get_octet());
loggers::get_instance().log("http_codec::decode_body: Chunked (2): prev = %d, counter=%d / %d", prev, counter, body.lengthof());
while (counter < body.lengthof() && ((body[counter].get_octet() == '\r') || (body[counter].get_octet() == '\n'))) { // Skip additional \n
counter += 1;
} // End of 'while' statement
prev = counter;
loggers::get_instance().log("http_codec::decode_body: Chunked (3): prev = %d, counter=%d / %d", prev, counter, body.lengthof());
}
}
} while (counter < body.lengthof()); // Process next chunk if any
body = os;
loggers::get_instance().log_msg("http_codec::decode_body: Finalised body=", body);
}
// Check if HTTP message body contains binary characters
for (int i = 0; i < body.lengthof(); i++) {
unsigned char c = body[i].get_octet();
if (!std::isprint(c) && !std::isspace(c) && !std::ispunct(c)) {
loggers::get_instance().log("http_codec::decode_body: Byte #%d is not printable: 0x%02x", i, body[i].get_octet());
_dc.is_binary = 0x01;
break;
}
} // End of 'for' statement
loggers::get_instance().log("http_codec::decode_body: Binary mode: %x", _dc.is_binary);
LibHttp__MessageBodyTypes::HttpMessageBody v;
if (_dc.is_binary == 0x01) {
LibHttp__BinaryMessageBodyTypes::BinaryBody binary_body;
decode_body_binary(body, binary_body, p_content_type);
message_body.binary__body() = binary_body;
} else {
// Convert into string
params p;
p["decode_str"] = std::string(static_cast<const unsigned char *>(body), body.lengthof() + static_cast<const unsigned char *>(body));
loggers::get_instance().log("http_codec::decode_body: decode_str: '%s'", p["decode_str"].c_str());
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
// Try to identify xml
if (p["decode_str"].find("<?xml version=") != std::string::npos) {
loggers::get_instance().log("http_codec::decode_body: Find xml message");
LibHttp__XmlMessageBodyTypes::XmlBody xml_body;
decode_body_xml(body, xml_body, p_content_type, &p);
message_body.xml__body() = xml_body;
} else if (p["decode_str"].find("<html>") != std::string::npos) { // Try to identify HTML
loggers::get_instance().log("http_codec::decode_body: Find html message");
LibHttp__MessageBodyTypes::HtmlBody html_body;
decode_body_html(body, html_body, p_content_type, &p);
message_body.html__body() = html_body;
} else if (p_content_type.find("json") != std::string::npos) { // Try to identify JSON
loggers::get_instance().log("http_codec::decode_body: Find json message");
LibHttp__JsonMessageBodyTypes::JsonBody json_body;
decode_body_json(body, json_body, p_content_type, &p);
message_body.json__body() = json_body;
} else {
loggers::get_instance().log("http_codec::decode_body: Use textBody as default");
LibHttp__MessageBodyTypes::TextBody text_body;
message_body.text__body() = CHARSTRING(body.lengthof(), (char *)static_cast<const unsigned char *>(body));
}
}
return 0;
}
int http_codec::get_line(TTCN_Buffer &buffer, CHARSTRING &to, const bool concatenate_header_lines) {
unsigned int i = 0;
const unsigned char *cc_to = buffer.get_read_data();
// Sanity checks
if (buffer.get_read_len() == 0) {
return -1;
}
while (true) {
// Skip spaces, and empty lines
for (; i < buffer.get_read_len() && cc_to[i] != '\0' && cc_to[i] != '\r' && cc_to[i] != '\n'; i++)
;
if (i >= buffer.get_read_len()) { // No more characters to process
to = CHARSTRING("");
return -1;
} else if (cc_to[i] == '\n') { // New line found, we don't care is '\r' is missing
if ((i > 0) && ((i + 1) < buffer.get_read_len()) && concatenate_header_lines && ((cc_to[i + 1] == ' ') || (cc_to[i + 1] == '\t'))) {
i += 1; // Skip it
} else {
to = CHARSTRING(i, (const char *)cc_to);
buffer.set_pos(buffer.get_pos() + i + 1);
return i == 0 ? 1 : 0;
}
} else {
if ((i + 1) < buffer.get_read_len() && cc_to[i + 1] != '\n') {
return -1;
} else if (i > 0 && (i + 2) < buffer.get_read_len() && concatenate_header_lines && (cc_to[i + 2] == ' ' || cc_to[i + 2] == '\t')) {
i += 2;
} else {
to = CHARSTRING(i, (const char *)cc_to);
buffer.set_pos(buffer.get_pos() + i + 2);
return i == 0 ? 1 : 0;
}
}
} // End of 'while' statement
}
void http_codec::set_payload_codecs(const std::string& p_codecs) {
loggers::get_instance().log(">>> http_codec::set_payload_codecs: '%s'", p_codecs.c_str());
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
// Sanity check
if (p_codecs.length() == 0) {
return;
}
// Extract codecs
try {
std::regex rgx("(\\w+):(\\w+)(;(\\w+):(\\w+))*");
std::sregex_iterator begin(p_codecs.cbegin(), p_codecs.cend(), rgx);
std::sregex_iterator end = std::sregex_iterator();
// E.g. 9 - xml - :held_codec - held_codec - ;html:html_codec - html:html_codec - html - :html_codec - html_codec
for (std::sregex_iterator it = begin; it != end; ++it) {
std::smatch m = *it;
loggers::get_instance().log("http_codec::set_payload_codecs: %d - %s - %s - %s - %s - %s - %s - %s - %s", m.size(), m[1].str().c_str(),
m[2].str().c_str(), m[3].str().c_str(), m[4].str().c_str(), m[5].str().c_str(), m[6].str().c_str(), m[7].str().c_str(),
m[8].str().c_str());
for (unsigned int j = 1; j < m.size() - 1; j += 3) { // Exclude m[0]
loggers::get_instance().log("http_codec::set_payload_codecs: insert (%s, %s), j = %d", m[j].str().c_str(), m[j + 1].str().c_str(), j);
if (m[j].str().empty()) {
break;
}
std::string key(m[j].str());
loggers::get_instance().log("http_codec::set_payload_codecs: Add codec %s", key.c_str());
_codecs.insert(
std::make_pair(key, std::unique_ptr<codec_gen<Record_Type, Record_Type>>(codec_stack_builder::get_instance()->get_codec(m[j + 1].str().c_str()))));
} // End of 'for' statement
} // End of 'for' statement
loggers::get_instance().log("http_codec::set_payload_codecs: _codecs length=%d - %p", _codecs.size(), this);
} catch (const std::logic_error &e) {
loggers::get_instance().warning("http_codec::set_payload_codecs: std::logic_error: '%s'", e.what());
bool http_codec::decode_body_html(const OCTETSTRING &p_data, CHARSTRING &p_html_body, const std::string& p_content_type, params* p_params) {
p_html_body = CHARSTRING(p_data.lengthof(), (char*)static_cast<const unsigned char*>(p_data));
return true;
}