sharpetronics/strongswan
1
0
Fork 0
mirror of https://github.com/strongswan/strongswan.git synced 2025-12-08 00:00:29 -05:00
Code Issues Projects Releases Wiki Activity

- clean logging

Browse Source 
- testet too-short-input errors
This commit is contained in:
Martin Willi 2005-11-14 12:10:05 +00:00
parent 517c1af09f
commit ba18b8aa18
1 changed files with 52 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
Source/charon/parser.c
View File

@ -79,7 +79,7 @@ struct private_parser_s {
static status_t parse_payload(private_parser_t *this, payload_type_t payload_type, payload_t **payload) static status_t parse_payload(private_parser_t *this, payload_type_t payload_type, payload_t **payload)
{ {
this->logger->log(this->logger, CONTROL, "Parsing a %s payload", mapping_find(payload_type_t_mappings, payload_type)); this->logger->log(this->logger, CONTROL, "parsing %s payload", mapping_find(payload_type_t_mappings, payload_type));
/* find payload in null terminated list*/ /* find payload in null terminated list*/
@ -93,10 +93,9 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
pld = payload_create(payload_type); pld = payload_create(payload_type);
if (pld == NULL) if (pld == NULL)
{ {
this->logger->log(this->logger, ERROR, "Payload not supported"); this->logger->log(this->logger, ERROR, " payload %s not supported", mapping_find(payload_type_t_mappings, payload_type));
return NOT_SUPPORTED; return NOT_SUPPORTED;
} }
/* base pointer for output, avoids casting in every rule */ /* base pointer for output, avoids casting in every rule */
output = pld; output = pld;
@ -104,14 +103,17 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
for (current = 0; current < rule_count; current++) for (current = 0; current < rule_count; current++)
{ {
this->logger->log(this->logger, CONTROL_MORE, " parsing rule %d %s",
current, mapping_find(encoding_type_t_mappings, rule->type));
switch (rule->type) switch (rule->type)
{ {
case U_INT_4: case U_INT_4:
{ {
u_int8_t *output_pos = output + rule->offset; u_int8_t *output_pos = output + rule->offset;
if (this->byte_pos + sizeof(u_int8_t) > this->input_roof) if (this->byte_pos + sizeof(u_int8_t) > this->input_roof)
{ {
this->logger->log(this->logger, ERROR, "not enough input to parse U_INT_4"); this->logger->log(this->logger, ERROR, " not enough input to parse rule %d %s",
current, mapping_find(encoding_type_t_mappings, rule->type));
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
@ -127,7 +129,8 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
this->byte_pos++; this->byte_pos++;
break; break;
default: default:
this->logger->log(this->logger, ERROR, "found rule U_INT_4 on bitpos %d", this->bit_pos); this->logger->log(this->logger, ERROR, " found rule %d %s on bitpos %d",
current, mapping_find(encoding_type_t_mappings, rule->type), this->bit_pos);
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
@ -138,13 +141,15 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
u_int8_t *output_pos = output + rule->offset; u_int8_t *output_pos = output + rule->offset;
if (this->byte_pos + sizeof(u_int8_t) > this->input_roof) if (this->byte_pos + sizeof(u_int8_t) > this->input_roof)
{ {
this->logger->log(this->logger, ERROR, "not enough input to parse U_INT_8"); this->logger->log(this->logger, ERROR, " not enough input to parse rule %d %s",
current, mapping_find(encoding_type_t_mappings, rule->type));
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
if (this->bit_pos) if (this->bit_pos)
{ {
this->logger->log(this->logger, ERROR, "found rule U_INT_8 on bitpos %d", this->bit_pos); this->logger->log(this->logger, ERROR, " found rule %d %s on bitpos %d",
current, mapping_find(encoding_type_t_mappings, rule->type), this->bit_pos);
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
@ -158,19 +163,22 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
u_int16_t *output_pos = output + rule->offset; u_int16_t *output_pos = output + rule->offset;
if (this->byte_pos + sizeof(u_int16_t) > this->input_roof) if (this->byte_pos + sizeof(u_int16_t) > this->input_roof)
{ {
this->logger->log(this->logger, ERROR, "not enough input to parse U_INT_16"); this->logger->log(this->logger, ERROR, " not enough input to parse rule %d %s",
current, mapping_find(encoding_type_t_mappings, rule->type));
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
if (this->bit_pos) if (this->bit_pos)
{ {
this->logger->log(this->logger, ERROR, "found rule U_INT_16 on bitpos %d", this->bit_pos); this->logger->log(this->logger, ERROR, " found rule %d %s on bitpos %d",
current, mapping_find(encoding_type_t_mappings, rule->type), this->bit_pos);
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
if ((int)this->byte_pos % 2) if ((int)this->byte_pos % 2)
{ {
this->logger->log(this->logger, ERROR, "found rule U_INT_16 on odd bytepos"); this->logger->log(this->logger, ERROR, " found rule %d %s on bitpos odd bytepos",
current, mapping_find(encoding_type_t_mappings, rule->type));
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
@ -183,19 +191,22 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
u_int32_t *output_pos = output + rule->offset; u_int32_t *output_pos = output + rule->offset;
if (this->byte_pos + sizeof(u_int32_t) > this->input_roof) if (this->byte_pos + sizeof(u_int32_t) > this->input_roof)
{ {
this->logger->log(this->logger, ERROR, "not enough input to parse U_INT_32"); this->logger->log(this->logger, ERROR, " not enough input to parse rule %d %s",
current, mapping_find(encoding_type_t_mappings, rule->type));
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
if (this->bit_pos) if (this->bit_pos)
{ {
this->logger->log(this->logger, ERROR, "found rule U_INT_32 on bitpos %d", this->bit_pos); this->logger->log(this->logger, ERROR, " found rule %d %s on bitpos %d",
current, mapping_find(encoding_type_t_mappings, rule->type), this->bit_pos);
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
if ((int)this->byte_pos % 4) if ((int)this->byte_pos % 4)
{ {
this->logger->log(this->logger, ERROR, "found rule U_INT_32 on unaligned bytepos"); this->logger->log(this->logger, ERROR, " found rule %d %s on unaligned bytepos",
current, mapping_find(encoding_type_t_mappings, rule->type));
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
@ -208,19 +219,22 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
u_int32_t *output_pos = output + rule->offset; u_int32_t *output_pos = output + rule->offset;
if (this->byte_pos + 2 * sizeof(u_int32_t) > this->input_roof) if (this->byte_pos + 2 * sizeof(u_int32_t) > this->input_roof)
{ {
this->logger->log(this->logger, ERROR, "not enough input to parse U_INT_64"); this->logger->log(this->logger, ERROR, " not enough input to parse rule %d %s",
current, mapping_find(encoding_type_t_mappings, rule->type));
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
if (this->bit_pos) if (this->bit_pos)
{ {
this->logger->log(this->logger, ERROR, "found rule U_INT_64 on bitpos %d", this->bit_pos); this->logger->log(this->logger, ERROR, " found rule %d %s on bitpos %d",
current, mapping_find(encoding_type_t_mappings, rule->type), this->bit_pos);
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
if ((int)this->byte_pos % 8) if ((int)this->byte_pos % 8)
{ {
this->logger->log(this->logger, ERROR, "found rule U_INT_64 on unaligned bytepos"); this->logger->log(this->logger, ERROR, " found rule %d %s on unaligned bytepos",
current, mapping_find(encoding_type_t_mappings, rule->type));
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
@ -234,9 +248,10 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
} }
case RESERVED_BIT: case RESERVED_BIT:
{ {
if (this->byte_pos > this->input_roof) if (this->byte_pos + sizeof(u_int8_t) > this->input_roof)
{ {
this->logger->log(this->logger, ERROR, "not enough input to parse RESERVED_BIT"); this->logger->log(this->logger, ERROR, " not enough input to parse rule %d %s",
current, mapping_find(encoding_type_t_mappings, rule->type));
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
@ -249,15 +264,17 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
} }
case RESERVED_BYTE: case RESERVED_BYTE:
{ {
if (this->byte_pos > this->input_roof) if (this->byte_pos + sizeof(u_int8_t) > this->input_roof)
{ {
this->logger->log(this->logger, ERROR, "not enough input to parse RESERVED_BYTE"); this->logger->log(this->logger, ERROR, " not enough input to parse rule %d %s",
current, mapping_find(encoding_type_t_mappings, rule->type));
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
if (this->bit_pos) if (this->bit_pos)
{ {
this->logger->log(this->logger, ERROR, "found rule RESERVED_BYTE on bitpos %d", this->bit_pos); this->logger->log(this->logger, ERROR, " found rule %d %s on bitpos %d",
current, mapping_find(encoding_type_t_mappings, rule->type), this->bit_pos);
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
@ -268,9 +285,10 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
{ {
bool *output_pos = output + rule->offset; bool *output_pos = output + rule->offset;
u_int8_t mask; u_int8_t mask;
if (this->byte_pos > this->input_roof) if (this->byte_pos + sizeof(u_int8_t) > this->input_roof)
{ {
this->logger->log(this->logger, ERROR, "not enough input to parse FLAG"); this->logger->log(this->logger, ERROR, " not enough input to parse rule %d %s",
current, mapping_find(encoding_type_t_mappings, rule->type));
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
@ -289,24 +307,27 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
} }
break; break;
} }
case LENGTH: case HEADER_LENGTH:
{ {
u_int32_t *output_pos = output + rule->offset; u_int32_t *output_pos = output + rule->offset;
if (this->byte_pos + sizeof(u_int32_t) > this->input_roof) if (this->byte_pos + sizeof(u_int32_t) > this->input_roof)
{ {
this->logger->log(this->logger, ERROR, "not enough input to parse LENGTH"); this->logger->log(this->logger, ERROR, " not enough input to parse rule %d %s",
current, mapping_find(encoding_type_t_mappings, rule->type));
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
if (this->bit_pos) if (this->bit_pos)
{ {
this->logger->log(this->logger, ERROR, "found rule LENGTH on bitpos %d", this->bit_pos); this->logger->log(this->logger, ERROR, " found rule %d %s on bitpos %d",
current, mapping_find(encoding_type_t_mappings, rule->type), this->bit_pos);
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
if ((int)this->byte_pos % 4) if ((int)this->byte_pos % 4)
{ {
this->logger->log(this->logger, ERROR, "found rule LENGTH on unaligned bytepos"); this->logger->log(this->logger, ERROR, " found rule %d %s on unaligned bytepos",
current, mapping_find(encoding_type_t_mappings, rule->type));
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
@ -314,14 +335,10 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
this->byte_pos += 4; this->byte_pos += 4;
break; break;
}
case SPI_SIZE:
{
} }
default: default:
{ {
this->logger->log(this->logger, ERROR, "parser found unknown type"); this->logger->log(this->logger, ERROR, " no rule to parse rule %d %s (%d)", current, mapping_find(payload_type_t_mappings, payload_type), payload_type);
pld->destroy(pld); pld->destroy(pld);
return PARSE_ERROR; return PARSE_ERROR;
} }
@ -358,6 +375,8 @@ parser_t *parser_create(chunk_t data)
} }
this->logger = global_logger_manager->create_logger(global_logger_manager, PARSER, NULL); this->logger = global_logger_manager->create_logger(global_logger_manager, PARSER, NULL);
this->logger->enable_level(this->logger, ALL);
if (this->logger == NULL) if (this->logger == NULL)
{ {