#include "utils/allocator.h"
#include "utils/logger.h"
#include "utils/linked_list.h"
-#include "payloads/payload.h"
#include "payloads/encodings.h"
+#include "payloads/payload.h"
+#include "payloads/sa_payload.h"
+#include "payloads/proposal_substructure.h"
+#include "payloads/transform_substructure.h"
+#include "payloads/transform_attribute.h"
+#include "payloads/ke_payload.h"
+#include "payloads/nonce_payload.h"
+#include "payloads/notify_payload.h"
if (this->byte_pos + sizeof(u_int8_t) > this->input_roof)
{
this->logger->log(this->logger, ERROR, " not enough input to parse rule %d %s",
- rule_number, mapping_find(encoding_type_m, this->rules[rule_number].type));
+ rule_number, mapping_find(encoding_type_m,
+ this->rules[rule_number].type));
return PARSE_ERROR;
}
switch (this->bit_pos)
break;
default:
this->logger->log(this->logger, ERROR, " found rule %d %s on bitpos %d",
- rule_number, mapping_find(encoding_type_m, this->rules[rule_number].type), this->bit_pos);
+ rule_number, mapping_find(encoding_type_m,
+ this->rules[rule_number].type), this->bit_pos);
return PARSE_ERROR;
}
if (output_pos != NULL)
{
- this->logger->log(this->logger, RAW, " => %d", *output_pos);
+ this->logger->log(this->logger, RAW|MORE, " => %d", *output_pos);
}
if (this->byte_pos + sizeof(u_int8_t) > this->input_roof)
{
this->logger->log(this->logger, ERROR, " not enough input to parse rule %d %s",
- rule_number, mapping_find(encoding_type_m, this->rules[rule_number].type));
+ rule_number, mapping_find(encoding_type_m,
+ this->rules[rule_number].type));
return PARSE_ERROR;
}
if (this->bit_pos)
{
this->logger->log(this->logger, ERROR, " found rule %d %s on bitpos %d",
- rule_number, mapping_find(encoding_type_m, this->rules[rule_number].type), this->bit_pos);
+ rule_number, mapping_find(encoding_type_m,
+ this->rules[rule_number].type), this->bit_pos);
return PARSE_ERROR;
}
if (output_pos != NULL)
{
*output_pos = *(this->byte_pos);
- this->logger->log(this->logger, RAW, " => %d", *output_pos);
+ this->logger->log(this->logger, RAW|MORE, " => %d", *output_pos);
}
this->byte_pos++;
if (this->byte_pos + sizeof(u_int16_t) > this->input_roof)
{
this->logger->log(this->logger, ERROR, " not enough input to parse rule %d %s",
- rule_number, mapping_find(encoding_type_m, this->rules[rule_number].type));
+ rule_number, mapping_find(encoding_type_m,
+ this->rules[rule_number].type));
return PARSE_ERROR;
}
if (this->bit_pos != 1)
{
this->logger->log(this->logger, ERROR, " found rule %d %s on bitpos %d",
- rule_number, mapping_find(encoding_type_m, this->rules[rule_number].type), this->bit_pos);
+ rule_number, mapping_find(encoding_type_m, this->rules[rule_number].type),
+ this->bit_pos);
return PARSE_ERROR;
}
/* caller interested in result ? */
if (output_pos != NULL)
{
*output_pos = ntohs(*((u_int16_t*)this->byte_pos)) & ~0x8000;
- this->logger->log(this->logger, RAW, " => %d", *output_pos);
+ this->logger->log(this->logger, RAW|MORE, " => %d", *output_pos);
}
this->byte_pos += 2;
this->bit_pos = 0;
if (this->bit_pos)
{
this->logger->log(this->logger, ERROR, " found rule %d %s on bitpos %d",
- rule_number, mapping_find(encoding_type_m, this->rules[rule_number].type), this->bit_pos);
+ rule_number, mapping_find(encoding_type_m, this->rules[rule_number].type),
+ this->bit_pos);
return PARSE_ERROR;
}
/* caller interested in result ? */
{
*output_pos = ntohs(*((u_int16_t*)this->byte_pos));
- this->logger->log(this->logger, RAW, " => %d", *output_pos);
+ this->logger->log(this->logger, RAW|MORE, " => %d", *output_pos);
}
this->byte_pos += 2;
if (this->bit_pos)
{
this->logger->log(this->logger, ERROR, " found rule %d %s on bitpos %d",
- rule_number, mapping_find(encoding_type_m, this->rules[rule_number].type), this->bit_pos);
+ rule_number, mapping_find(encoding_type_m, this->rules[rule_number].type),
+ this->bit_pos);
return PARSE_ERROR;
}
/* caller interested in result ? */
{
*output_pos = ntohl(*((u_int32_t*)this->byte_pos));
- this->logger->log(this->logger, RAW, " => %d", *output_pos);
+ this->logger->log(this->logger, RAW|MORE, " => %d", *output_pos);
}
this->byte_pos += 4;
if (this->bit_pos)
{
this->logger->log(this->logger, ERROR, " found rule %d %s on bitpos %d",
- rule_number, mapping_find(encoding_type_m, this->rules[rule_number].type), this->bit_pos);
+ rule_number, mapping_find(encoding_type_m, this->rules[rule_number].type),
+ this->bit_pos);
return PARSE_ERROR;
}
/* caller interested in result ? */
*(output_pos + 1) = ntohl(*((u_int32_t*)this->byte_pos));
*output_pos = ntohl(*(((u_int32_t*)this->byte_pos) + 1));
- this->logger->log_bytes(this->logger, RAW, " =>", (void*)output_pos, 8);
+ this->logger->log_bytes(this->logger, RAW|MORE, " =>", (void*)output_pos, 8);
}
this->byte_pos += 8;
*output_pos = TRUE;
}
- this->logger->log(this->logger, RAW, " => %d", *output_pos);
+ this->logger->log(this->logger, RAW|MORE, " => %d", *output_pos);
}
this->bit_pos = (this->bit_pos + 1) % 8;
if (this->bit_pos == 0)
u_int8_t *pos_before = this->byte_pos;
payload_t *payload;
status_t status;
+ this->logger->log(this->logger, CONTROL|MORE, " %d bytes left, parsing recursivly %s",
+ length, mapping_find(payload_type_m, payload_type));
status = this->public.parse_payload((parser_t*)this, payload_type, &payload);
if (status != SUCCESS)
{
+ this->logger->log(this->logger, ERROR, " parsing of a %s substructure failed",
+ mapping_find(payload_type_m, payload_type));
return status;
}
list->insert_last(list, payload);
{
if (this->byte_pos + length > this->input_roof)
{
- this->logger->log(this->logger, ERROR, " not enough input to parse rule %d %s, SPI_LENGTH: %d",
- rule_number, mapping_find(encoding_type_m, this->rules[rule_number].type), length);
+ this->logger->log(this->logger, ERROR, " not enough input (%d bytes) to parse rule %d %s",
+ length, rule_number, mapping_find(encoding_type_m, this->rules[rule_number].type));
return PARSE_ERROR;
}
if (this->bit_pos)
output_pos->ptr = allocator_alloc(length);
if (output_pos->ptr == NULL)
{
+ this->logger->log(this->logger, ERROR, " allocation of chunk (%d bytes) failed", length);
return OUT_OF_RES;
}
memcpy(output_pos->ptr, this->byte_pos, length);
}
this->byte_pos += length;
- this->logger->log_bytes(this->logger, RAW, " =>", (void*)output_pos->ptr, length);
+ this->logger->log_bytes(this->logger, RAW|MORE, " =>", (void*)output_pos->ptr, length);
return SUCCESS;
}
int rule_number;
encoding_rule_t *rule;
- this->logger->log(this->logger, CONTROL, "parsing %s payload", mapping_find(payload_type_m, payload_type));
+ this->logger->log(this->logger, CONTROL, "parsing %s payload, %d bytes left",
+ mapping_find(payload_type_m, payload_type),
+ this->input_roof-this->byte_pos);
+
+ this->logger->log_bytes(this->logger, RAW, "parsing payload from", this->byte_pos,
+ this->input_roof-this->byte_pos);
/* ok, do the parsing */
pld = payload_create(payload_type);
}
case PROPOSALS:
{
- size_t proposals_length = payload_length - 4;
+ size_t proposals_length = payload_length - SA_PAYLOAD_HEADER_LENGTH;
if (this->parse_list(this, rule_number, output + rule->offset, PROPOSAL_SUBSTRUCTURE, proposals_length) != SUCCESS)
{
pld->destroy(pld);
return PARSE_ERROR;
}
- //TODO check if next_payloads are correct?
break;
}
case TRANSFORMS:
{
- size_t transforms_length = payload_length - spi_size - 8;
+ size_t transforms_length = payload_length - spi_size - PROPOSAL_SUBSTRUCTURE_HEADER_LENGTH;
if (this->parse_list(this, rule_number, output + rule->offset, TRANSFORM_SUBSTRUCTURE, transforms_length) != SUCCESS)
{
pld->destroy(pld);
return PARSE_ERROR;
}
- //TODO check if we have the desired transforms count
break;
}
case TRANSFORM_ATTRIBUTES:
{
- size_t transform_a_length = payload_length - 8;
+ size_t transform_a_length = payload_length - TRANSFORM_SUBSTRUCTURE_HEADER_LENGTH;
if (this->parse_list(this, rule_number, output + rule->offset, TRANSFORM_ATTRIBUTE, transform_a_length) != SUCCESS)
{
pld->destroy(pld);
}
case NONCE_DATA:
{
- size_t nonce_length = payload_length - 4;
+ size_t nonce_length = payload_length - NONCE_PAYLOAD_HEADER_LENGTH;
if (this->parse_chunk(this, rule_number, output + rule->offset, nonce_length) != SUCCESS)
{
pld->destroy(pld);
}
case KEY_EXCHANGE_DATA:
{
- size_t keydata_length = payload_length - 8;
+ size_t keydata_length = payload_length - KE_PAYLOAD_HEADER_LENGTH;
if (this->parse_chunk(this, rule_number, output + rule->offset, keydata_length) != SUCCESS)
{
pld->destroy(pld);
}
case NOTIFICATION_DATA:
{
- size_t notify_length = payload_length - 8 - spi_size;
+ size_t notify_length = payload_length - NOTIFY_PAYLOAD_HEADER_LENGTH - spi_size;
if (this->parse_chunk(this, rule_number, output + rule->offset, notify_length) != SUCCESS)
{
pld->destroy(pld);
}
this->logger = global_logger_manager->create_logger(global_logger_manager, PARSER, NULL);
- this->logger->enable_level(this->logger, CONTROL|MORE|ERROR|RAW);
+ this->logger->disable_level(this->logger, FULL);
+ this->logger->enable_level(this->logger, RAW|CONTROL|ALL);
if (this->logger == NULL)
{
+ global_logger_manager->destroy_logger(global_logger_manager, this->logger);
allocator_free(this);
return NULL;
}
this->parse_bit = parse_bit;
this->parse_list = parse_list;
this->parse_chunk = parse_chunk;
-
-
+
this->input = data.ptr;
this->byte_pos = data.ptr;
this->bit_pos = 0;