- commented parser
authorMartin Willi <martin@strongswan.org>
Tue, 15 Nov 2005 10:22:41 +0000 (10:22 -0000)
committerMartin Willi <martin@strongswan.org>
Tue, 15 Nov 2005 10:22:41 +0000 (10:22 -0000)
Source/charon/parser.c
Source/charon/parser.h

index 1cf467f..bbb4bc6 100644 (file)
@@ -32,6 +32,7 @@
 #include "utils/logger.h"
 #include "utils/linked_list.h"
 #include "payloads/payload.h"
+#include "payloads/encodings.h"
 
 
 
@@ -44,19 +45,137 @@ typedef struct private_parser_s private_parser_t;
 
 struct private_parser_s {
        /**
-        * Public members
+        * Public members, see parser_t
         */
        parser_t public;
        
-       status_t (*parse_uint4) (private_parser_t*,encoding_rule_t*,int,u_int8_t*);
-       status_t (*parse_uint8) (private_parser_t*,encoding_rule_t*,int,u_int8_t*);
-       status_t (*parse_uint15) (private_parser_t*,encoding_rule_t*,int,u_int16_t*);
-       status_t (*parse_uint16) (private_parser_t*,encoding_rule_t*,int,u_int16_t*);
-       status_t (*parse_uint32) (private_parser_t*,encoding_rule_t*,int,u_int32_t*);
-       status_t (*parse_uint64) (private_parser_t*,encoding_rule_t*,int,u_int32_t*);
-       status_t (*parse_bit) (private_parser_t*,encoding_rule_t*,int,bool*);
-       status_t (*parse_list) (private_parser_t*,encoding_rule_t*,int,linked_list_t**,payload_type_t,size_t);
-       status_t (*parse_chunk) (private_parser_t*,encoding_rule_t*,int,chunk_t*,size_t);
+       /**
+        * @brief parse a 4-Bit unsigned integer from the current parsing position.
+        * 
+        * @param this                          parser object
+        * @param rule_number           number of current rule
+        * @param[out] output_pos       pointer where to write the parsed result
+        * @return                                      
+        *                                                      - SUCCESS or
+        *                                                      - PARSE_ERROR when not successful
+        */
+       status_t (*parse_uint4)  (private_parser_t *this, int rule_number, u_int8_t *output_pos);
+       
+       /**
+        * @brief parse a 8-Bit unsigned integer from the current parsing position.
+        * 
+        * @param this                          parser object
+        * @param rule_number           number of current rule
+        * @param[out] output_pos       pointer where to write the parsed result
+        * @return                                      
+        *                                                      - SUCCESS or
+        *                                                      - PARSE_ERROR when not successful
+        */
+       status_t (*parse_uint8)  (private_parser_t *this, int rule_number, u_int8_t *output_pos);
+       
+       /**
+        * @brief parse a 15-Bit unsigned integer from the current parsing position.
+        * 
+        * This is a special case used for ATTRIBUTE_TYPE.
+        * Big-/Little-endian conversion is done here.
+        * 
+        * @param this                          parser object
+        * @param rule_number           number of current rule
+        * @param[out] output_pos       pointer where to write the parsed result
+        * @return                                      
+        *                                                      - SUCCESS or
+        *                                                      - PARSE_ERROR when not successful
+        */
+       status_t (*parse_uint15) (private_parser_t *this, int rule_number, u_int16_t *output_pos);
+       
+       /**
+        * @brief parse a 16-Bit unsigned integer from the current parsing position.
+        * 
+        * Big-/Little-endian conversion is done here.
+        * 
+        * @param this                          parser object
+        * @param rule_number           number of current rule
+        * @param[out] output_pos       pointer where to write the parsed result
+        * @return                                      
+        *                                                      - SUCCESS or
+        *                                                      - PARSE_ERROR when not successful
+        */
+       status_t (*parse_uint16) (private_parser_t *this, int rule_number, u_int16_t *output_pos);
+       
+       /**
+        * @brief parse a 32-Bit unsigned integer from the current parsing position.
+        * 
+        * Big-/Little-endian conversion is done here.
+        * 
+        * @param this                          parser object
+        * @param rule_number           number of current rule
+        * @param[out] output_pos       pointer where to write the parsed result
+        * @return                                      
+        *                                                      - SUCCESS or
+        *                                                      - PARSE_ERROR when not successful
+        */
+       status_t (*parse_uint32) (private_parser_t *this, int rule_number, u_int32_t *output_pos);
+       
+       /**
+        * @brief parse a 64-Bit unsigned integer from the current parsing position.
+        * 
+        * @todo add support for big-endian machines.
+        * 
+        * @param this                          parser object
+        * @param rule_number           number of current rule
+        * @param[out] output_pos       pointer where to write the parsed result
+        * @return                                      
+        *                                                      - SUCCESS or
+        *                                                      - PARSE_ERROR when not successful
+        */
+       status_t (*parse_uint64) (private_parser_t *this, int rule_number, u_int64_t *output_pos);
+       
+       /**
+        * @brief parse a single Bit from the current parsing position
+        * 
+        * @param this                          parser object
+        * @param rule_number           number of current rule
+        * @param[out] output_pos       pointer where to write the parsed result
+        * @return                                      
+        *                                                      - SUCCESS or
+        *                                                      - PARSE_ERROR when not successful
+        */
+       status_t (*parse_bit)    (private_parser_t *this, int rule_number, bool *output_pos);
+       
+       /**
+        * @brief parse substructures in a list
+        * 
+        * This function calls the parser recursivly to parse contained substructures
+        * in a linked_list_t. The list must already be created. Payload defines
+        * the type of the substructures. parsing is continued until the specified length
+        * is completely parsed.
+        * 
+        * @param this                          parser object
+        * @param rule_number           number of current rule
+        * @param[out] output_pos       pointer of a linked_list where substructures are added
+        * @param payload_type          type of the contained substructures to parse
+        * @param length                        number of bytes to parse in this list
+        * @return                                      
+        *                                                      - SUCCESS or
+        *                                                      - PARSE_ERROR when not successful
+        */
+       status_t (*parse_list)   (private_parser_t *this, int rule_number, linked_list_t **output_pos, payload_type_t payload_ype, size_t length);
+       
+       /**
+        * @brief parse data from current parsing position in a chunk.
+        * 
+        * This function clones length number of bytes to output_pos, without 
+        * modifiyng them. Space will be allocated and must be freed by caller.
+        * 
+        * @param this                          parser object
+        * @param rule_number           number of current rule
+        * @param[out] output_pos       pointer of a chunk which will point to the allocated data
+        * @param length                        number of bytes to clone
+        * @return                                      
+        *                                                      - SUCCESS or
+        *                                                      - PARSE_ERROR when not successful
+        */
+       status_t (*parse_chunk)  (private_parser_t *this, int rule_number, chunk_t *output_pos, size_t length);
 
        /**
         * Current bit for reading in input data
@@ -74,24 +193,30 @@ struct private_parser_s {
        u_int8_t *input;
        
        /**
-        * roof of input
+        * roof of input, used for length-checking
         */
        u_int8_t *input_roof;
        
-
+       /**
+        * set of encoding rules for this parsing session
+        */
+       encoding_rule_t *rules;
+       
        /**
         * logger object
         */
        logger_t *logger;
 };
 
-
-static status_t parse_uint4(private_parser_t *this, encoding_rule_t *rule, int rule_number, u_int8_t *output_pos)
+/**
+ * implementation of private_parser_t.parse_uint4
+ */
+static status_t parse_uint4(private_parser_t *this, int rule_number, u_int8_t *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_t_mappings, rule->type));
+                                                       rule_number, mapping_find(encoding_type_t_mappings, this->rules[rule_number].type));
                return PARSE_ERROR;
        }
        switch (this->bit_pos)
@@ -115,7 +240,7 @@ static status_t parse_uint4(private_parser_t *this, encoding_rule_t *rule, int r
                        break;
                default:
                        this->logger->log(this->logger, ERROR, "  found rule %d %s on bitpos %d", 
-                                                               rule_number, mapping_find(encoding_type_t_mappings, rule->type), this->bit_pos);
+                                                               rule_number, mapping_find(encoding_type_t_mappings, this->rules[rule_number].type), this->bit_pos);
                        return PARSE_ERROR;
        }
        
@@ -128,18 +253,21 @@ static status_t parse_uint4(private_parser_t *this, encoding_rule_t *rule, int r
        return SUCCESS;
 }
 
-static status_t parse_uint8(private_parser_t *this, encoding_rule_t *rule, int rule_number, u_int8_t *output_pos)
+/**
+ * implementation of private_parser_t.parse_uint8
+ */
+static status_t parse_uint8(private_parser_t *this, int rule_number, u_int8_t *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_t_mappings, rule->type));
+                                                       rule_number, mapping_find(encoding_type_t_mappings, 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_t_mappings, rule->type), this->bit_pos);
+                                                       rule_number, mapping_find(encoding_type_t_mappings, this->rules[rule_number].type), this->bit_pos);
                return PARSE_ERROR;
        }
 
@@ -156,18 +284,21 @@ static status_t parse_uint8(private_parser_t *this, encoding_rule_t *rule, int r
        return SUCCESS;
 }
 
-static status_t parse_uint15(private_parser_t *this, encoding_rule_t *rule, int rule_number, u_int16_t *output_pos)
+/**
+ * implementation of private_parser_t.parse_uint15
+ */
+static status_t parse_uint15(private_parser_t *this, int rule_number, u_int16_t *output_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_t_mappings, rule->type));
+                                                       rule_number, mapping_find(encoding_type_t_mappings, 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_t_mappings, rule->type), this->bit_pos);
+                                                       rule_number, mapping_find(encoding_type_t_mappings, this->rules[rule_number].type), this->bit_pos);
                return PARSE_ERROR;
        }
        /* caller interested in result ? */
@@ -184,19 +315,21 @@ static status_t parse_uint15(private_parser_t *this, encoding_rule_t *rule, int
        return SUCCESS;
 }
 
-
-static status_t parse_uint16(private_parser_t *this, encoding_rule_t *rule, int rule_number, u_int16_t *output_pos)
+/**
+ * implementation of private_parser_t.parse_uint16
+ */
+static status_t parse_uint16(private_parser_t *this, int rule_number, u_int16_t *output_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_t_mappings, rule->type));
+                                                       rule_number, mapping_find(encoding_type_t_mappings, 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_t_mappings, rule->type), this->bit_pos);
+                                                       rule_number, mapping_find(encoding_type_t_mappings, this->rules[rule_number].type), this->bit_pos);
                return PARSE_ERROR;
        }
        /* caller interested in result ? */
@@ -211,19 +344,21 @@ static status_t parse_uint16(private_parser_t *this, encoding_rule_t *rule, int
        
        return SUCCESS;
 }
-
-static status_t parse_uint32(private_parser_t *this, encoding_rule_t *rule, int rule_number, u_int32_t *output_pos)
+/**
+ * implementation of private_parser_t.parse_uint32
+ */
+static status_t parse_uint32(private_parser_t *this, int rule_number, u_int32_t *output_pos)
 {
        if (this->byte_pos + sizeof(u_int32_t) > this->input_roof)
        {
                this->logger->log(this->logger, ERROR, "  not enough input to parse rule %d %s", 
-                                                       rule_number, mapping_find(encoding_type_t_mappings, rule->type));
+                                                       rule_number, mapping_find(encoding_type_t_mappings, 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_t_mappings, rule->type), this->bit_pos);
+                                                       rule_number, mapping_find(encoding_type_t_mappings, this->rules[rule_number].type), this->bit_pos);
                return PARSE_ERROR;
        }
        /* caller interested in result ? */
@@ -239,18 +374,21 @@ static status_t parse_uint32(private_parser_t *this, encoding_rule_t *rule, int
        return SUCCESS;
 }
 
-static status_t parse_uint64(private_parser_t *this, encoding_rule_t *rule, int rule_number, u_int32_t *output_pos)
+/**
+ * implementation of private_parser_t.parse_uint64
+ */
+static status_t parse_uint64(private_parser_t *this, int rule_number, u_int64_t *output_pos)
 {
-       if (this->byte_pos + 2 * sizeof(u_int32_t) > this->input_roof)
+       if (this->byte_pos + sizeof(u_int64_t) > this->input_roof)
        {
                this->logger->log(this->logger, ERROR, "  not enough input to parse rule %d %s", 
-                                                       rule_number, mapping_find(encoding_type_t_mappings, rule->type));
+                                                       rule_number, mapping_find(encoding_type_t_mappings, 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_t_mappings, rule->type), this->bit_pos);
+                                                       rule_number, mapping_find(encoding_type_t_mappings, this->rules[rule_number].type), this->bit_pos);
                return PARSE_ERROR;
        }
        /* caller interested in result ? */
@@ -269,13 +407,15 @@ static status_t parse_uint64(private_parser_t *this, encoding_rule_t *rule, int
        return SUCCESS;
 }
 
-
-static status_t parse_bit(private_parser_t *this, encoding_rule_t *rule, int rule_number, bool *output_pos)
+/**
+ * implementation of private_parser_t.parse_bit
+ */
+static status_t parse_bit(private_parser_t *this, int rule_number, bool *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_t_mappings, rule->type));
+                                                       rule_number, mapping_find(encoding_type_t_mappings, this->rules[rule_number].type));
                return PARSE_ERROR;
        }
        /* caller interested in result ? */
@@ -303,21 +443,24 @@ static status_t parse_bit(private_parser_t *this, encoding_rule_t *rule, int rul
        return SUCCESS;
 }
 
-static status_t parse_list(private_parser_t *this, encoding_rule_t *rule, int rule_number, linked_list_t **output_pos, payload_type_t payload_type, size_t length)
+/**
+ * implementation of private_parser_t.parse_list
+ */
+static status_t parse_list(private_parser_t *this, int rule_number, linked_list_t **output_pos, payload_type_t payload_type, size_t length)
 {
        linked_list_t * list = *output_pos;
        
        if (length < 0)
        {
                this->logger->log(this->logger, ERROR, "  invalid length for rule %d %s", 
-                                                       rule_number, mapping_find(encoding_type_t_mappings, rule->type));
+                                                       rule_number, mapping_find(encoding_type_t_mappings, 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_t_mappings, rule->type), this->bit_pos);
+                                                       rule_number, mapping_find(encoding_type_t_mappings, this->rules[rule_number].type), this->bit_pos);
                return PARSE_ERROR;
        }
        
@@ -338,19 +481,21 @@ static status_t parse_list(private_parser_t *this, encoding_rule_t *rule, int ru
        return SUCCESS; 
 }
 
-
-static status_t parse_chunk(private_parser_t *this, encoding_rule_t *rule, int rule_number, chunk_t *output_pos, size_t length)
+/**
+ * implementation of private_parser_t.parse_chunk
+ */
+static status_t parse_chunk(private_parser_t *this, int rule_number, chunk_t *output_pos, size_t length)
 {
        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_t_mappings, rule->type), length);
+                                                       rule_number, mapping_find(encoding_type_t_mappings, this->rules[rule_number].type), length);
                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_t_mappings, rule->type), this->bit_pos);
+                                                       rule_number, mapping_find(encoding_type_t_mappings, this->rules[rule_number].type), this->bit_pos);
                return PARSE_ERROR;
        }
        if (output_pos != NULL)
@@ -379,7 +524,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
        void *output;
        size_t rule_count, payload_length, spi_size, attribute_length;
        bool attribute_format;
-       int current;
+       int rule_number;
        encoding_rule_t *rule;
        
        this->logger->log(this->logger, CONTROL, "parsing %s payload", mapping_find(payload_type_t_mappings, payload_type));
@@ -394,17 +539,18 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
        /* base pointer for output, avoids casting in every rule */
        output = pld;
        
-       pld->get_encoding_rules(pld, &rule, &rule_count);
+       pld->get_encoding_rules(pld, &(this->rules), &rule_count);
        
-       for (current = 0; current < rule_count; current++)
+       for (rule_number = 0; rule_number < rule_count; rule_number++)
        {
+               rule = &(this->rules[rule_number]);
                this->logger->log(this->logger, CONTROL_MORE, "  parsing rule %d %s", 
-                                                       current, mapping_find(encoding_type_t_mappings, rule->type));
+                                                       rule_number, mapping_find(encoding_type_t_mappings, rule->type));
                switch (rule->type)
                {
                        case U_INT_4:
                        {
-                               if (this->parse_uint4(this, rule, current, output + rule->offset) != SUCCESS) 
+                               if (this->parse_uint4(this, rule_number, output + rule->offset) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -413,7 +559,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        }
                        case U_INT_8:
                        {
-                               if (this->parse_uint8(this, rule, current, output + rule->offset) != SUCCESS) 
+                               if (this->parse_uint8(this, rule_number, output + rule->offset) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -422,7 +568,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        }
                        case U_INT_16:
                        {
-                               if (this->parse_uint16(this, rule, current, output + rule->offset) != SUCCESS) 
+                               if (this->parse_uint16(this, rule_number, output + rule->offset) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -431,7 +577,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        }
                        case U_INT_32:
                        {
-                               if (this->parse_uint32(this, rule, current, output + rule->offset) != SUCCESS) 
+                               if (this->parse_uint32(this, rule_number, output + rule->offset) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -440,7 +586,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        }
                        case U_INT_64:
                        {
-                               if (this->parse_uint64(this, rule, current, output + rule->offset) != SUCCESS) 
+                               if (this->parse_uint64(this, rule_number, output + rule->offset) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -449,7 +595,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        }
                        case RESERVED_BIT:
                        {
-                               if (this->parse_bit(this, rule, current, NULL) != SUCCESS) 
+                               if (this->parse_bit(this, rule_number, NULL) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -458,7 +604,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        }
                        case RESERVED_BYTE:
                        {
-                               if (this->parse_uint8(this, rule, current, NULL) != SUCCESS) 
+                               if (this->parse_uint8(this, rule_number, NULL) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -467,7 +613,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        }
                        case FLAG:
                        {
-                               if (this->parse_bit(this, rule, current, output + rule->offset) != SUCCESS) 
+                               if (this->parse_bit(this, rule_number, output + rule->offset) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -476,7 +622,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        }
                        case PAYLOAD_LENGTH:
                        {
-                               if (this->parse_uint16(this, rule, current, output + rule->offset) != SUCCESS) 
+                               if (this->parse_uint16(this, rule_number, output + rule->offset) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -486,7 +632,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        }
                        case HEADER_LENGTH:
                        {
-                               if (this->parse_uint32(this, rule, current, output + rule->offset) != SUCCESS) 
+                               if (this->parse_uint32(this, rule_number, output + rule->offset) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -495,7 +641,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        }
                        case SPI_SIZE:
                        {
-                               if (this->parse_uint8(this, rule, current, output + rule->offset) != SUCCESS) 
+                               if (this->parse_uint8(this, rule_number, output + rule->offset) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -505,7 +651,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        }
                        case SPI:
                        {
-                               if (this->parse_chunk(this, rule, current, output + rule->offset, spi_size) != SUCCESS) 
+                               if (this->parse_chunk(this, rule_number, output + rule->offset, spi_size) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -515,7 +661,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        case PROPOSALS:
                        {
                                size_t proposals_length = payload_length - 4;
-                               if (this->parse_list(this, rule, current, output + rule->offset, PROPOSAL_SUBSTRUCTURE, proposals_length) != SUCCESS) 
+                               if (this->parse_list(this, rule_number, output + rule->offset, PROPOSAL_SUBSTRUCTURE, proposals_length) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -526,7 +672,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        case TRANSFORMS:
                        {
                                size_t transforms_length = payload_length - spi_size - 8;
-                               if (this->parse_list(this, rule, current, output + rule->offset, TRANSFORM_SUBSTRUCTURE, transforms_length) != SUCCESS) 
+                               if (this->parse_list(this, rule_number, output + rule->offset, TRANSFORM_SUBSTRUCTURE, transforms_length) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -537,7 +683,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        case TRANSFORM_ATTRIBUTES:
                        {
                                size_t transform_a_length = payload_length - 8;
-                               if (this->parse_list(this, rule, current, output + rule->offset, TRANSFORM_ATTRIBUTE, transform_a_length) != SUCCESS) 
+                               if (this->parse_list(this, rule_number, output + rule->offset, TRANSFORM_ATTRIBUTE, transform_a_length) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -546,7 +692,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        }
                        case ATTRIBUTE_FORMAT:
                        {
-                               if (this->parse_bit(this, rule, current, output + rule->offset) != SUCCESS) 
+                               if (this->parse_bit(this, rule_number, output + rule->offset) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -556,7 +702,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        }
                        case ATTRIBUTE_TYPE:
                        {
-                               if (this->parse_uint15(this, rule, current, output + rule->offset) != SUCCESS) 
+                               if (this->parse_uint15(this, rule_number, output + rule->offset) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -568,7 +714,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        {       
                                this->logger->log_bytes(this->logger, RAW, "ATTRIBUTE_LENGTH_OR_VALUE", this->byte_pos, 2);
        
-                               if (this->parse_uint16(this, rule, current, output + rule->offset) != SUCCESS) 
+                               if (this->parse_uint16(this, rule_number, output + rule->offset) != SUCCESS) 
                                {
                                        pld->destroy(pld);
                                        return PARSE_ERROR;
@@ -582,7 +728,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        {
                                if (attribute_format == FALSE)
                                {
-                                       if (this->parse_chunk(this, rule, current, output + rule->offset, attribute_length) != SUCCESS) 
+                                       if (this->parse_chunk(this, rule_number, output + rule->offset, attribute_length) != SUCCESS) 
                                        {
                                                pld->destroy(pld);
                                                return PARSE_ERROR;
@@ -592,7 +738,7 @@ static status_t parse_payload(private_parser_t *this, payload_type_t payload_typ
                        }
                        default:
                        {
-                               this->logger->log(this->logger, ERROR, "  no rule to parse rule %d %s (%d)", current, mapping_find(encoding_type_t_mappings, rule->type), rule->type);
+                               this->logger->log(this->logger, ERROR, "  no rule to parse rule %d %s (%d)", rule_number, mapping_find(encoding_type_t_mappings, rule->type), rule->type);
                                pld->destroy(pld);
                                return PARSE_ERROR;
                        }
index b414351..758e3db 100644 (file)
 
 
 /**
- * @brief A parser_t object which parses payloads of specific type
+ * @brief A parser_t object which parses payloads
+ * 
+ * A parser is used for parsing one chunk of data. Multiple
+ * payloads can be parsed out of the chunk using parse_payload.
+ * The parser remains the state until destroyed.
  */
 typedef struct parser_s parser_t;
 
 struct parser_s {
        
        /**
-        * @brief parses the next payload in the current context
+        * @brief parses the next payload
+        * 
+        * @warning caller is responsible for freeing allocated payload
         * 
-        * @warning caller is responsible for freeing allocated data_struct
+        * Rules for parsing are described in the payload definition.
         *
         * @param parser                        parser Object
-        * @param payload_type          payload to parse
+        * @param payload_type          payload type to parse
         * @param[out] payload          pointer where parsed payload was allocated
         * @return                      
         *                                                      - SUCCESSFUL if succeeded,
         *                                                      - NOT_SUPPORTED if payload_type is not supported
         *                                                      - OUT_OF_RES if out of ressources
-        *                                                      - PARSE_ERROR if corrupted data found
+        *                                                      - PARSE_ERROR if corrupted/invalid data found
         */
        status_t (*parse_payload) (parser_t *this, payload_type_t payload_type, payload_t **payload);
        
@@ -64,10 +70,7 @@ struct parser_s {
 /**
  * @brief Constructor to create a parser
  * 
- * The parser uses a set of payload_infos to know how to
- * parse different payloads.
- * 
- * @param chunk                                chunk of data to parse in this session
+ * @param data                         chunk of data to parse with this parser object
  * @return                                     the parser, or NULL if failed
  *
  */